collectTopLevelBinders (ThenBinds b1 b2)
= (collectTopLevelBinders b1) ++ (collectTopLevelBinders b2)
-{- --------- DO THIS WHEN VarMonoBind binds a "name" rather than a "Id"
-
-collectBinders :: Bind name (InPat name) -> [name]
-collectBinders = collectGenericBinders collectPatBinders
-collectTypedBinders :: TypecheckedBind -> TypecheckedPat -> [name]
-collectTypedBinders = collectGenericBinders collectTypedPatBinders
-
-collectGenericBinders :: (pat -> [name]) -> Bind name pat -> [name]
-collectGenericBinders pat_fn EmptyBind = []
-collectGenericBinders pat_fn (NonRecBind monobinds)
- = collectGenericMonoBinders pat_fn monobinds
-collectGenericBinders pat_fn (RecBind monobinds)
- = collectGenericMonoBinders pat_fn monobinds
-
-collectMonoBinders :: MonoBinds name (InPat name) -> [name]
-collectMonoBinders = collectGenericMonoBinders collectPatBinders
-
-
-collectGenericMonoBinders :: (pat -> [name]) -> MonoBinds name pat -> [name]
-collectGenericMonoBinders pat_fn EmptyMonoBinds = []
-collectGenericMonoBinders pat_fn (AndMonoBinds bs1 bs2)
- = (collectGenericMonoBinders pat_fn bs1) ++ (collectGenericMonoBinders pat_fn bs2)
-collectGenericMonoBinders pat_fn (PatMonoBind pat grhss_w_binds locn)
- = pat_fn pat
-collectGenericMonoBinders pat_fn (FunMonoBind f matches locn) = [f]
-collectGenericMonoBinders pat_fn (VarMonoBind v expr) = [v]
-
------------------- -}
-
--- ------- UNTIL THEN, WE DUPLICATE CODE -----------}
-
collectBinders :: Bind name (InPat name) -> [name]
collectBinders EmptyBind = []
collectBinders (NonRecBind monobinds) = collectMonoBinders monobinds
collectTypedMonoBinders (AndMonoBinds bs1 bs2)
= (collectTypedMonoBinders bs1) ++ (collectTypedMonoBinders bs2)
--- ---------- END OF DUPLICATED CODE
-
-- We'd like the binders -- and where they came from --
-- so we can make new ones with equally-useful origin info.
TyCon, Unique
)
import Id ( externallyVisibleId, cmpId_withSpecDataCon,
- DataCon(..), Id, fIRST_TAG, ConTag(..)
+ isDataCon, isDictFunId, isConstMethodId_maybe,
+ isClassOpId, isDefaultMethodId_maybe, isSuperDictSelId_maybe,
+ Id, Class, ClassOp, DataCon(..), ConTag(..), fIRST_TAG
#ifdef DPH
,isInventedTopLevId
#endif {- Data Parallel Haskell -}
)
+import Maybes
import Outputable
import Pretty ( ppNil, ppChar, ppStr, ppPStr, ppDouble, ppInt,
ppInteger, ppBeside, ppIntersperse, prettyToUn
C ``static'' or not...
\begin{code}
-externallyVisibleCLabel (TyConLabel tc _) = not (isBigTupleTyCon tc)
- -- i.e. not generated for
- -- purely-local use...
+externallyVisibleCLabel (TyConLabel tc _) = True
externallyVisibleCLabel (CaseLabel _ _) = False
externallyVisibleCLabel (AsmTempLabel _) = False
externallyVisibleCLabel (RtsLabel _) = True
#ifndef DPH
-externallyVisibleCLabel (IdLabel (CLabelId id) _) = externallyVisibleId id
-
+externallyVisibleCLabel (IdLabel (CLabelId id) _)
+ | isDataCon id = True
+ | is_ConstMethodId id = True -- These are here to ensure splitting works
+ | isDictFunId id = True -- when these values have not been exported
+ | isClassOpId id = True
+ | is_DefaultMethodId id = True
+ | is_SuperDictSelId id = True
+ | otherwise = externallyVisibleId id
+ where
+ is_ConstMethodId id = maybeToBool (isConstMethodId_maybe id)
+ is_DefaultMethodId id = maybeToBool (isDefaultMethodId_maybe id)
+ is_SuperDictSelId id = maybeToBool (isSuperDictSelId_maybe id)
#else
-- DPH pays a big price for exported identifiers. For example with
-- a statically allocated closure, if it is local to a file it will
getIdUnfolding :: Id -> UnfoldingDetails
getIdUniType :: Id -> UniType
getIdUpdateInfo :: Id -> UpdateInfo
+getInstIdModule :: Id -> _PackedString
getInstNamePieces :: Bool -> Inst -> [_PackedString]
getInstantiatedDataConSig :: Id -> [UniType] -> ([UniType], [UniType], UniType)
getMentionedTyConsAndClassesFromId :: Id -> (Bag TyCon, Bag Class)
idWantsToBeINLINEd :: Id -> Bool
isBottomingId :: Id -> Bool
isClassOpId :: Id -> Bool
-isConstMethodId :: Id -> Bool
+isConstMethodId_maybe :: Id -> Labda (Class, UniType, ClassOp)
isDataCon :: Id -> Bool
-isDefaultMethodId :: Id -> Bool
+isDefaultMethodId_maybe :: Id -> Labda (Class, ClassOp, Bool)
isDictFunId :: Id -> Bool
isImportedId :: Id -> Bool
isInstId_maybe :: Id -> Labda Inst
isWrapperId :: Id -> Bool
localiseId :: Id -> Id
mkClassOpId :: Unique -> Class -> ClassOp -> UniType -> IdInfo -> Id
-mkConstMethodId :: Unique -> Class -> ClassOp -> UniType -> UniType -> Bool -> IdInfo -> Id
+mkConstMethodId :: Unique -> Class -> ClassOp -> UniType -> UniType -> Bool -> _PackedString -> IdInfo -> Id
mkDataCon :: Unique -> FullName -> [TyVarTemplate] -> [(Class, UniType)] -> [UniType] -> TyCon -> SpecEnv -> Id
mkDefaultMethodId :: Unique -> Class -> ClassOp -> Bool -> UniType -> IdInfo -> Id
-mkDictFunId :: Unique -> Class -> UniType -> UniType -> Bool -> IdInfo -> Id
+mkDictFunId :: Unique -> Class -> UniType -> UniType -> Bool -> _PackedString -> IdInfo -> Id
mkId :: Name -> UniType -> IdInfo -> Id
mkIdWithNewUniq :: Id -> Unique -> Id
mkImported :: Unique -> FullName -> UniType -> IdInfo -> Id
nullSpecEnv :: SpecEnv
pprIdInUnfolding :: UniqFM Id -> Id -> Int -> Bool -> PrettyRep
replaceIdInfo :: Id -> IdInfo -> Id
+selectIdInfoForSpecId :: Id -> IdInfo
showId :: PprStyle -> Id -> [Char]
toplevelishId :: Id -> Bool
unfoldingUnfriendlyId :: Id -> Bool
mkSysLocal, mkUserLocal,
mkSpecPragmaId,
mkSpecId, mkSameSpecCon,
+ selectIdInfoForSpecId,
mkTemplateLocals,
mkImported, mkPreludeId,
mkDataCon, mkTupleCon,
-- DESTRUCTION
getIdUniType,
getInstNamePieces, getIdInfo, replaceIdInfo,
- getIdKind,
+ getIdKind, getInstIdModule,
getMentionedTyConsAndClassesFromId,
getDataConTag,
getDataConSig, getInstantiatedDataConSig,
isTopLevId, isWorkerId, isWrapperId,
isImportedId, isSysLocalId,
isBottomingId,
- isClassOpId, isConstMethodId, isDefaultMethodId,
- isDictFunId, isInstId_maybe, isSuperDictSelId_maybe,
+ isClassOpId, isDefaultMethodId_maybe, isSuperDictSelId_maybe,
+ isDictFunId, isInstId_maybe, isConstMethodId_maybe,
#ifdef DPH
isInventedTopLevId,
isProcessorCon,
import Outputable
import Pretty -- for pretty-printing
import SrcLoc
-import Subst ( applySubstToTy ) -- PRETTY GRIMY TO LOOK IN HERE
+import Subst ( applySubstToTy ) -- PRETTY GRIMY TO LOOK IN HERE
import PlainCore
-import PrelFuns ( pcGenerateDataSpecs ) -- PRETTY GRIMY TO LOOK IN HERE
+import PrelFuns ( pcGenerateTupleSpecs ) -- PRETTY GRIMY TO LOOK IN HERE
import UniqFM
import UniqSet
import Unique
-- actually do comparisons that way, we kindly supply
-- a Unique for that purpose.
Bool -- True <=> from an instance decl in this mod
+ FAST_STRING -- module where instance came from
\end{code}
Constant method ids are generated from instance decls where
UniType -- (class, type, classop) triple
ClassOp
Bool -- True <=> from an instance decl in this mod
+ FAST_STRING -- module where instance came from
| InstId Inst -- An instance of a dictionary, class operation,
-- or overloaded value
chk (SuperDictSelId _ _) = True
chk (ClassOpId _ _) = True
chk (DefaultMethodId _ _ _) = True
- chk (DictFunId _ _ _) = True
- chk (ConstMethodId _ _ _ _) = True
+ chk (DictFunId _ _ _ _) = True
+ chk (ConstMethodId _ _ _ _ _) = True
chk (SpecId unspec _ _) = toplevelishId unspec
-- depends what the unspecialised thing is
chk (WorkerId unwrkr) = toplevelishId unwrkr
chk (SuperDictSelId _ _) = True
chk (ClassOpId _ _) = True
chk (DefaultMethodId _ _ _) = True
- chk (DictFunId _ _ _) = True
- chk (ConstMethodId _ _ _ _) = True
+ chk (DictFunId _ _ _ _) = True
+ chk (ConstMethodId _ _ _ _ _) = True
chk (WorkerId unwrkr) = idHasNoFreeTyVars unwrkr
chk (InstId _) = False -- these are local
chk (SpecId _ _ no_free_tvs) = no_free_tvs
isClassOpId (Id _ _ _ (ClassOpId _ _)) = True
isClassOpId _ = False
-isDefaultMethodId (Id _ _ _ (DefaultMethodId _ _ _)) = True
+isDefaultMethodId_maybe (Id _ _ _ (DefaultMethodId cls clsop err)) = Just (cls, clsop, err)
#ifdef DPH
-isDefaultMethodId (PodId _ _ id) = isDefaultMethodId id
+isDefaultMethodId_maybe (PodId _ _ id) = isDefaultMethodId_maybe id
#endif {- Data Parallel Haskell -}
-isDefaultMethodId other = False
+isDefaultMethodId_maybe other = Nothing
-isDictFunId (Id _ _ _ (DictFunId _ _ _)) = True
+isDictFunId (Id _ _ _ (DictFunId _ _ _ _)) = True
#ifdef DPH
-isDictFunId (PodId _ _ id) = isDictFunId id
+isDictFunId (PodId _ _ id) = isDictFunId id
#endif {- Data Parallel Haskell -}
-isDictFunId other = False
+isDictFunId other = False
-isConstMethodId (Id _ _ _ (ConstMethodId _ _ _ _)) = True
+isConstMethodId_maybe (Id _ _ _ (ConstMethodId cls ty clsop _ _)) = Just (cls, ty, clsop)
#ifdef DPH
-isConstMethodId (PodId _ _ id) = isConstMethodId id
+isConstMethodId_maybe (PodId _ _ id) = isConstMethodId_maybe id
#endif {- Data Parallel Haskell -}
-isConstMethodId other = False
+isConstMethodId_maybe other = Nothing
isInstId_maybe (Id _ _ _ (InstId inst)) = Just inst
#ifdef DPH
-- instance-ish things: should we try to figure out
-- *exactly* which extra instances have to be exported? (ToDo)
- DictFunId c t _
+ DictFunId c t _ _
-> ppCat [ppPStr SLIT("_DFUN_"), pp_class c, pp_type t]
- ConstMethodId c t o _
+ ConstMethodId c t o _ _
-> ppCat [ppPStr SLIT("_CONSTM_"), pp_class c, pp_class_op o, pp_type t]
-- specialisations and workers
class_thing (Id _ _ _ (DefaultMethodId _ _ _)) = True
class_thing other = False
-unfoldingUnfriendlyId (Id _ _ _ (SpecId d@(Id _ _ _ dfun@(DictFunId _ t _)) _ _))
+unfoldingUnfriendlyId (Id _ _ _ (SpecId d@(Id _ _ _ dfun@(DictFunId _ t _ _)) _ _))
-- a SPEC of a DictFunId can end up w/ gratuitous
-- TyVar(Templates) in the i/face; only a problem
-- if -fshow-pragma-name-errs; but we can do without the pain.
naughty_DictFunId dfun
--)
-unfoldingUnfriendlyId d@(Id _ _ _ dfun@(DictFunId _ t _))
+unfoldingUnfriendlyId d@(Id _ _ _ dfun@(DictFunId _ t _ _))
= --pprTrace "unfriendly2:" (ppCat [ppr PprDebug d, ppr PprDebug t]) (
naughty_DictFunId dfun -- similar deal...
--)
naughty_DictFunId :: IdDetails -> Bool
-- True <=> has a TyVar(Template) in the "type" part of its "name"
-naughty_DictFunId (DictFunId _ _ False) = False -- came from outside; must be OK
-naughty_DictFunId (DictFunId _ ty _)
+naughty_DictFunId (DictFunId _ _ False _) = False -- came from outside; must be OK
+naughty_DictFunId (DictFunId _ ty _ _)
= not (isGroundTy ty)
\end{code}
then [SLIT("defm"), op_name]
else [SLIT("defm"), c_mod, c_name, op_name] }}
- DictFunId c ty _ ->
+ DictFunId c ty _ _ ->
case (getOrigName c) of { (c_mod, c_name) ->
let
c_bits = if fromPreludeCore c
[SLIT("dfun")] ++ c_bits ++ ty_bits }
- ConstMethodId c ty o _ ->
+ ConstMethodId c ty o _ _ ->
case (getOrigName c) of { (c_mod, c_name) ->
case (getTypeString ty) of { ty_bits ->
case (getClassOpString o) of { o_name ->
\end{code}
\begin{code}
+getInstIdModule (Id _ _ _ (DictFunId _ _ _ mod)) = mod
+getInstIdModule (Id _ _ _ (ConstMethodId _ _ _ _ mod)) = mod
+getInstIdModule other = panic "Id:getInstIdModule"
+\end{code}
+
+
+\begin{code}
{- NOT USED
getIdTauType :: Id -> TauType
getIdTauType i = expandTySyn (getTauType (getIdUniType i))
mkClassOpId u c op ty info = Id u ty info (ClassOpId c op)
mkDefaultMethodId u c op gen ty info = Id u ty info (DefaultMethodId c op gen)
-mkDictFunId u c ity full_ty from_here info
- = Id u full_ty info (DictFunId c ity from_here)
+mkDictFunId u c ity full_ty from_here modname info
+ = Id u full_ty info (DictFunId c ity from_here modname)
-mkConstMethodId u c op ity full_ty from_here info
- = Id u full_ty info (ConstMethodId c ity op from_here)
+mkConstMethodId u c op ity full_ty from_here modname info
+ = Id u full_ty info (ConstMethodId c ity op from_here modname)
mkWorkerId u unwrkr ty info = Id u ty info (WorkerId unwrkr)
mkUserLocal str uniq ty loc
= Id uniq ty noIdInfo (LocalId (mkShortName str loc) (no_free_tvs ty))
--- for an SpecPragmaId being created by the compiler out of thin air...
+-- for a SpecPragmaId being created by the compiler out of thin air...
mkSpecPragmaId :: FAST_STRING -> Unique -> UniType -> Maybe SpecInfo -> SrcLoc -> Id
mkSpecPragmaId str uniq ty specinfo loc
= Id uniq ty noIdInfo (SpecPragmaId (mkShortName str loc) specinfo (no_free_tvs ty))
#ifdef DPH
replaceIdInfo (PodId dim ity id) info = PodId dim ity (replaceIdInfo id info)
#endif {- Data Parallel Haskell -}
+
+selectIdInfoForSpecId :: Id -> IdInfo
+selectIdInfoForSpecId unspec
+ = ASSERT(not (maybeToBool (isSpecId_maybe unspec)))
+ noIdInfo `addInfo_UF` getIdUnfolding unspec
\end{code}
%************************************************************************
tuplecon_info
= noIdInfo `addInfo_UF` unfolding
`addInfo` mkArityInfo arity
- `addInfo` tuplecon_specenv
-
- tuplecon_specenv
- = if arity == 2 then
- pcGenerateDataSpecs ty
- else
- nullSpecEnv
+ `addInfo` pcGenerateTupleSpecs arity ty
unfolding
= -- if arity == 0
get (SuperDictSelId c _) = getExportFlag c
get (ClassOpId c _) = getExportFlag c
get (DefaultMethodId c _ _) = getExportFlag c
- get (DictFunId c ty from_here) = instance_export_flag c ty from_here
- get (ConstMethodId c ty _ from_here) = instance_export_flag c ty from_here
+ get (DictFunId c ty from_here _) = instance_export_flag c ty from_here
+ get (ConstMethodId c ty _ from_here _) = instance_export_flag c ty from_here
get (SpecId unspec _ _) = getExportFlag unspec
get (WorkerId unwrkr) = getExportFlag unwrkr
get (InstId _) = NotExported
get (SuperDictSelId c _) = isLocallyDefined c
get (ClassOpId c _) = isLocallyDefined c
get (DefaultMethodId c _ _) = isLocallyDefined c
- get (DictFunId c tyc from_here) = from_here
+ get (DictFunId c tyc from_here _) = from_here
-- For DictFunId and ConstMethodId things, you really have to
-- know whether it came from an imported instance or one
-- really here; no matter where the tycon and class came from.
- get (ConstMethodId c tyc _ from_here) = from_here
+ get (ConstMethodId c tyc _ from_here _) = from_here
get (SpecId unspec _ _) = isLocallyDefined unspec
get (WorkerId unwrkr) = isLocallyDefined unwrkr
get (InstId _) = True
get (SuperDictSelId c _) = fromPreludeCore c
get (ClassOpId c _) = fromPreludeCore c
get (DefaultMethodId c _ _) = fromPreludeCore c
- get (DictFunId c t _) = fromPreludeCore c && is_prelude_core_ty t
- get (ConstMethodId c t _ _) = fromPreludeCore c && is_prelude_core_ty t
+ get (DictFunId c t _ _) = fromPreludeCore c && is_prelude_core_ty t
+ get (ConstMethodId c t _ _ _) = fromPreludeCore c && is_prelude_core_ty t
get (SpecId unspec _ _) = fromPreludeCore unspec
get (WorkerId unwrkr) = fromPreludeCore unwrkr
get (InstId _) = False
type OutExpr = CoreExpr Id Id
type OutId = Id
data UnfoldingDetails = NoUnfoldingDetails | LiteralForm BasicLit | OtherLiteralForm [BasicLit] | ConstructorForm Id [UniType] [CoreAtom Id] | OtherConstructorForm [Id] | GeneralForm Bool FormSummary (CoreExpr (Id, BinderInfo) Id) UnfoldingGuidance | MagicForm _PackedString MagicUnfoldingFun | IWantToBeINLINEd UnfoldingGuidance
-data UnfoldingGuidance = UnfoldNever | UnfoldAlways | EssentialUnfolding | UnfoldIfGoodArgs Int Int [Bool] Int
+data UnfoldingGuidance = UnfoldNever | UnfoldAlways | EssentialUnfolding | UnfoldIfGoodArgs Int Int [Bool] Int | BadUnfolding
data SrcLoc
data Subst
type SimplifiableBinder = (Id, BinderInfo)
getWrapperArgTypeCategories :: UniType -> StrictnessInfo -> Labda [Char]
iWantToBeINLINEd :: UnfoldingGuidance -> UnfoldingDetails
indicatesWorker :: [Demand] -> Bool
-lookupConstMethodId :: SpecEnv -> UniType -> Labda Id
+lookupConstMethodId :: Id -> UniType -> Labda Id
lookupSpecEnv :: SpecEnv -> [UniType] -> Labda (Id, [UniType], Int)
lookupSpecId :: Id -> [Labda UniType] -> Id
mkArgUsageInfo :: [ArgUsage] -> ArgUsageInfo
UnfoldingDetails(..), -- non-abstract! re-exported
UnfoldingGuidance(..), -- non-abstract; ditto
mkUnfolding,
---OLD: mkUnfolding_NoGuideGiven, -- a convenient interface; for imported things only
iWantToBeINLINEd, mkMagicUnfolding,
---UNUSED: haveUnfolding,
noInfo_UF, getInfo_UF, addInfo_UF, -- to avoid instance virus
---UNUSED: clearInfo_UF,
UpdateInfo,
mkUpdateInfo,
import AbsUniType
import Bag ( emptyBag, Bag )
import CmdLineOpts ( GlobalSwitch(..) )
-import Id ( getIdUniType, getDataConSig,
- getInstantiatedDataConSig, getIdInfo,
+import Id ( getIdUniType, getIdInfo,
+ getDataConSig, getInstantiatedDataConSig,
externallyVisibleId, isDataCon,
unfoldingUnfriendlyId, isWorkerId,
isWrapperId, DataCon(..)
ppInfo sty better_id_fn arity,
ppInfo sty better_id_fn update,
ppInfo sty better_id_fn deforest,
+
pp_strictness sty (Just for_this_id)
- better_id_fn inline_env strictness,
- pp_unfolding sty for_this_id inline_env unfold,
+ better_id_fn inline_env strictness,
+
+ if bottomIsGuaranteed strictness
+ then pp_NONE
+ else pp_unfolding sty for_this_id inline_env unfold,
+
if specs_please
then pp_specs sty (not (isDataCon for_this_id))
better_id_fn inline_env specialise
nullSpecEnv = SpecEnv []
addOneToSpecEnv (SpecEnv xs) x = SpecEnv (x : xs)
-lookupConstMethodId :: SpecEnv -> UniType -> Maybe Id
+lookupConstMethodId :: Id -> UniType -> Maybe Id
-- slight variant on "lookupSpecEnv" below
-lookupConstMethodId (SpecEnv spec_infos) spec_ty
- = firstJust (map try spec_infos)
+lookupConstMethodId sel_id spec_ty
+ = case (getInfo (getIdInfo sel_id)) of
+ SpecEnv spec_infos -> firstJust (map try spec_infos)
where
try (SpecInfo (Just ty:nothings) _ const_meth_id)
= ASSERT(all nothing_is_nothing nothings)
_ -> Nothing
nothing_is_nothing Nothing = True -- debugging only
- nothing_is_nothing _ = panic "nothing_is_nothing!"
+ nothing_is_nothing _ = panic "nothing_is_nothing!"
lookupSpecId :: Id -- *un*specialised Id
-> [Maybe UniType] -- types to which it is to be specialised
-> Id -- specialised Id
lookupSpecId unspec_id ty_maybes
- = case (getInfo (getIdInfo unspec_id)) of { SpecEnv spec_infos ->
+ = case (getInfo (getIdInfo unspec_id)) of { SpecEnv spec_infos ->
case (firstJust (map try spec_infos)) of
Just id -> id
getWorkerId (StrictnessInfo _ (Just worker_id)) = worker_id
#ifdef DEBUG
-getWorkerId junk = pprPanic "getWorkerId: Nothing" (ppInfo PprDebug (\x->x) junk)
+getWorkerId junk = pprPanic "getWorkerId: " (ppInfo PprDebug (\x->x) junk)
#endif
\end{code}
mkMagicUnfolding :: FAST_STRING -> UnfoldingDetails
mkUnfolding guide expr
- = GeneralForm False (mkFormSummary NoStrictnessInfo{-NB:lying-} expr)
+ = GeneralForm False (mkFormSummary NoStrictnessInfo expr)
(BSCC("OccurExpr") occurAnalyseGlobalExpr expr ESCC)
guide
\end{code}
mkMagicUnfolding tag = MagicForm tag (mkMagicUnfoldingFun tag)
-{- UNUSED:
-haveUnfolding NoUnfoldingDetails = False
-haveUnfolding (IWantToBeINLINEd _) = False -- don't have the unfolding *YET*
-haveUnfolding _ = True
--}
\end{code}
\begin{code}
noInfo_UF = NoUnfoldingDetails
-getInfo_UF (IdInfo _ _ _ _ unfolding _ _ _ _ _) = unfolding
+getInfo_UF (IdInfo _ _ _ _ unfolding _ _ _ _ _)
+ = case unfolding of
+ NoUnfoldingDetails -> NoUnfoldingDetails
+ GeneralForm _ _ _ BadUnfolding -> NoUnfoldingDetails
+ unfold_ok -> unfold_ok
+
+-- getInfo_UF ensures that any BadUnfoldings are never returned
+-- We had to delay the test required in TcPragmas until now due
+-- to strictness constraints in TcPragmas
addInfo_UF id_info@(IdInfo a b c d e f g h i j) NoUnfoldingDetails = id_info
-addInfo_UF (IdInfo a b d e xxx f g h i j) uf = IdInfo a b d e uf f g h i j
+addInfo_UF (IdInfo a b d e xxx f g h i j) uf = IdInfo a b d e uf f g h i j
---UNUSED:clearInfo_UF (IdInfo a b d e xxx f g h i j) = IdInfo a b d e noInfo_UF f g h i j
\end{code}
\begin{code}
pp (MagicForm tag _)
= ppCat [ppPStr SLIT("_MF_"), ppPStr tag]
+ pp (GeneralForm _ _ _ BadUnfolding) = pp_NONE
+
pp (GeneralForm _ _ template guide)
= let
untagged = unTagBinders template
addInfo id_info NoArgUsageInfo = id_info
addInfo (IdInfo a b d e f g h _ i j) au_info = IdInfo a b d e f g h au_info i j
- ppInfo sty better_id_fn NoArgUsageInfo = ifPprInterface sty pp_NONE
- ppInfo sty better_id_fn (SomeArgUsageInfo []) = ifPprInterface sty pp_NONE
+ ppInfo sty better_id_fn NoArgUsageInfo = ifPprInterface sty pp_NONE
+ ppInfo sty better_id_fn (SomeArgUsageInfo []) = ifPprInterface sty pp_NONE
ppInfo sty better_id_fn (SomeArgUsageInfo aut)
= ppBeside (ppPStr SLIT("_L_ ")) (ppArgUsageType aut)
integerDataConKey :: Unique
integerMinusOneIdKey :: Unique
integerPlusOneIdKey :: Unique
+integerPlusTwoIdKey :: Unique
integerTyConKey :: Unique
integerZeroIdKey :: Unique
integralClassKey :: Unique
trueDataConKey,
unpackCStringIdKey, unpackCString2IdKey, unpackCStringAppendIdKey,
packCStringIdKey,
- integerZeroIdKey, integerPlusOneIdKey, integerMinusOneIdKey,
+ integerZeroIdKey, integerPlusOneIdKey,
+ integerPlusTwoIdKey, integerMinusOneIdKey,
voidPrimIdKey,
cCallableClassKey,
cReturnableClassKey,
integerMinusOneIdKey = mkPreludeMiscIdUnique 8
integerPlusOneIdKey = mkPreludeMiscIdUnique 9
integerZeroIdKey = mkPreludeMiscIdUnique 10
---UNUSED:lexIdKey = mkPreludeMiscIdUnique 11
+integerPlusTwoIdKey = mkPreludeMiscIdUnique 11
packCStringIdKey = mkPreludeMiscIdUnique 12
parIdKey = mkPreludeMiscIdUnique 13
parErrorIdKey = mkPreludeMiscIdUnique 14
data CompilationInfo
type TCE = UniqFM TyCon
data UniqFM a
-genStaticConBits :: CompilationInfo -> [TyCon] -> FiniteMap TyCon [[Labda UniType]] -> AbstractC
+genStaticConBits :: CompilationInfo -> [TyCon] -> FiniteMap TyCon [(Bool, [Labda UniType])] -> AbstractC
import CgMonad
import AbsUniType ( getTyConDataCons, kindFromType,
- maybeIntLikeTyCon,
- mkSpecTyCon, isLocalSpecTyCon,
+ maybeIntLikeTyCon, mkSpecTyCon,
TyVarTemplate, TyCon, Class,
TauType(..), UniType, ThetaType(..)
IF_ATTACK_PRAGMAS(COMMA cmpTyCon COMMA cmpClass)
\begin{code}
genStaticConBits :: CompilationInfo -- global info about the compilation
-> [TyCon] -- tycons to generate
- -> FiniteMap TyCon [[Maybe UniType]]
+ -> FiniteMap TyCon [(Bool, [Maybe UniType])]
-- tycon specialisation info
-> AbstractC -- output
-- ToDo: for tycons and specialisations which are not
-- declared in this module we must ensure that the
-- C labels are local to this module i.e. static
+ -- since they may be duplicated in other modules
mkAbstractCs [ gen_for_tycon tc | tc <- gen_tycons ]
`mkAbsCStmts`
mkAbstractCs [ mkAbstractCs [ gen_for_spec_tycon tc spec
- | spec <- specs ]
- | (tc, specs) <- fmToList tycon_specs,
- isLocalSpecTyCon (sw_chkr CompilingPrelude) tc
- ]
+ | (imported_spec, spec) <- specs,
+ -- no code generated if spec is imported
+ not imported_spec
+ ]
+ | (tc, specs) <- fmToList tycon_specs ]
where
gen_for_tycon :: TyCon -> AbstractC
gen_for_tycon tycon
= mkAbstractCs (map (genConInfo comp_info tycon) data_cons)
- `mkAbsCStmts` maybe_tycon_vtbl
-
+ `mkAbsCStmts`
+ maybe_tycon_vtbl
where
data_cons = getTyConDataCons tycon
tycon_upd_label = mkStdUpdVecTblLabel tycon
UnvectoredReturn 1 -> CRetUnVector tycon_upd_label
(mk_upd_label tycon (head data_cons))
UnvectoredReturn _ -> AbsCNop
- VectoredReturn _ -> CFlatRetVector tycon_upd_label
+ VectoredReturn _ -> CFlatRetVector tycon_upd_label
(map (mk_upd_label tycon) data_cons)
------------------
gen_for_spec_tycon :: TyCon -> [Maybe UniType] -> AbstractC
gen_for_spec_tycon tycon ty_maybes
- = mkAbstractCs (map (genConInfo comp_info tycon) spec_data_cons)
+ = mkAbstractCs (map (genConInfo comp_info spec_tycon) spec_data_cons)
`mkAbsCStmts`
maybe_spec_tycon_vtbl
where
&& maybeToBool offset_into_int_maybe
&& offset_into_int <= mAX_SPEC_SELECTEE_SIZE -- Offset is small enough
=
- ASSERT(is_single_constructor) -- This should be true anyway
+ -- ASSERT(is_single_constructor) -- Should be true, by causes error for SpecTyCon
LFThunk False False True (SelectorThunk scrutinee con offset_into_int)
where
(_, params_w_offsets) = layOutDynCon con getIdKind params
data Id
data StgBinding a b
data UniqFM a
-codeGen :: _PackedString -> ([CostCentre], [CostCentre]) -> [_PackedString] -> (GlobalSwitch -> SwitchResult) -> [TyCon] -> FiniteMap TyCon [[Labda UniType]] -> [StgBinding Id Id] -> AbstractC
+codeGen :: _PackedString -> ([CostCentre], [CostCentre]) -> [_PackedString] -> (GlobalSwitch -> SwitchResult) -> [TyCon] -> FiniteMap TyCon [(Bool, [Labda UniType])] -> [StgBinding Id Id] -> AbstractC
-> (GlobalSwitch -> SwitchResult)
-- global switch lookup function
-> [TyCon] -- tycons with data constructors to convert
- -> FiniteMap TyCon [[Maybe UniType]]
+ -> FiniteMap TyCon [(Bool, [Maybe UniType])]
-- tycon specialisation info
-> PlainStgProgram -- bindings to convert
-> AbstractC -- output
int_switch_set = intSwitchSet sw_lookup_fn
doing_profiling = switch_is_on SccProfilingOn
compiling_prelude = switch_is_on CompilingPrelude
- splitting = switch_is_on (EnsureSplittableC (panic "codeGen:esc"))
+ maybe_split = if (switch_is_on (EnsureSplittableC (panic "codeGen:esc")))
+ then CSplitMarker
+ else AbsCNop
cinfo = MkCompInfo switch_is_on int_switch_set mod_name
in
if not doing_profiling then
mkAbstractCs [
genStaticConBits cinfo gen_tycons tycon_specs,
- initC cinfo (cgTopBindings splitting stg_pgm) ]
+ initC cinfo (cgTopBindings maybe_split stg_pgm) ]
else -- yes, cost-centre profiling:
-- Besides the usual stuff, we must produce:
mkCcRegister local_CCs import_names],
genStaticConBits cinfo gen_tycons tycon_specs,
- initC cinfo (cgTopBindings splitting stg_pgm) ]
+ initC cinfo (cgTopBindings maybe_split stg_pgm) ]
where
-----------------
grp_name = case (stringSwitchSet sw_lookup_fn SccGroup) of
variable.
\begin{code}
-cgTopBindings :: Bool -> PlainStgProgram -> Code
+cgTopBindings :: AbstractC -> PlainStgProgram -> Code
-cgTopBindings splitting bindings = mapCs (cgTopBinding splitting) bindings
+cgTopBindings split bindings = mapCs (cgTopBinding split) bindings
-cgTopBinding :: Bool -> PlainStgBinding -> Code
+cgTopBinding :: AbstractC -> PlainStgBinding -> Code
-cgTopBinding splitting (StgNonRec name rhs)
- = absC maybe_split `thenC`
+cgTopBinding split (StgNonRec name rhs)
+ = absC split `thenC`
cgTopRhs name rhs `thenFC` \ (name, info) ->
addBindC name info
- where
- maybe_split = if splitting then CSplitMarker else AbsCNop
-cgTopBinding splitting (StgRec pairs)
- = absC maybe_split `thenC`
+cgTopBinding split (StgRec pairs)
+ = absC split `thenC`
fixC (\ new_binds -> addBindsC new_binds `thenC`
mapFCs ( \ (b,e) -> cgTopRhs b e ) pairs
) `thenFC` \ new_binds ->
addBindsC new_binds
- where
- maybe_split = if splitting then CSplitMarker else AbsCNop
-- Urgh! I tried moving the forkStatics call from the rhss of cgTopRhs
-- to enclose the listFCs in cgTopBinding, but that tickled the
data Unique
applyBindUnlifts :: [CoreExpr Id Id -> CoreExpr Id Id] -> CoreExpr Id Id -> CoreExpr Id Id
bindUnlift :: Id -> Id -> CoreExpr Id Id -> CoreExpr Id Id
+isUnboxedButNotState :: UniType -> Bool
liftCoreBindings :: SplitUniqSupply -> [CoreBinding Id Id] -> [CoreBinding Id Id]
liftExpr :: Id -> CoreExpr Id Id -> CoreExpr Id Id
mkLiftedId :: Id -> Unique -> (Id, Id)
liftExpr,
bindUnlift,
applyBindUnlifts,
+ isUnboxedButNotState,
CoreBinding, PlainCoreBinding(..),
CoreExpr, PlainCoreExpr(..),
) where
IMPORT_Trace
+import Pretty
import AbsPrel ( liftDataCon, mkLiftTy )
import TysPrim ( statePrimTyCon ) -- ToDo: get from AbsPrel
= initL (lift_top_binds binds) us
where
lift_top_binds (b:bs)
- = liftBindAndScope True (is_rec b) b (
+ = liftBindAndScope True b (
lift_top_binds bs `thenL` \ bs ->
returnL (ItsABinds bs)
) `thenL` \ (b, ItsABinds bs) ->
lift_top_binds []
= returnL []
-is_rec (CoNonRec _ _) = False
-is_rec _ = True
-
-liftBindAndScope :: Bool -- True <=> a top level group
- -> Bool -- True <=> a recursive group
- -> PlainCoreBinding -- As yet unprocessed
- -> LiftM BindsOrExpr -- Do the scope of the bindings
- -> LiftM (PlainCoreBinding, -- Processed
- BindsOrExpr)
-
-liftBindAndScope toplev is_rec bind scopeM
- = liftBinders toplev is_rec binders (
+liftBindAndScope :: Bool -- top level ?
+ -> PlainCoreBinding -- As yet unprocessed
+ -> LiftM BindsOrExpr -- Do the scope of the bindings
+ -> LiftM (PlainCoreBinding, -- Processed
+ BindsOrExpr)
+
+liftBindAndScope top_lev bind scopeM
+ = liftBinders top_lev bind (
liftCoreBind bind `thenL` \ bind ->
scopeM `thenL` \ bindsorexpr ->
returnL (bind, bindsorexpr)
)
- where
- binders = bindersOf bind
+
liftCoreAtom :: PlainCoreAtom -> LiftM (PlainCoreAtom, PlainCoreExpr -> PlainCoreExpr)
= liftCoreExpr expr `thenL` \ expr ->
returnL (CoSCC label expr)
-liftCoreExpr (CoLet (CoNonRec binder rhs) body) -- special case: for speed
- = liftCoreExpr rhs `thenL` \ rhs2 ->
- liftCoreExpr body `thenL` \ body2 ->
- returnL (mkCoLetUnboxedToCase (CoNonRec binder rhs2) body2)
+liftCoreExpr (CoLet (CoNonRec binder rhs) body) -- special case: no lifting
+ = liftCoreExpr rhs `thenL` \ rhs ->
+ liftCoreExpr body `thenL` \ body ->
+ returnL (mkCoLetUnboxedToCase (CoNonRec binder rhs) body)
liftCoreExpr (CoLet bind body) -- general case
- = liftBindAndScope False{-not top-level-} (is_rec bind) bind (
+ = liftBindAndScope False bind (
liftCoreExpr body `thenL` \ body ->
returnL (ItsAnExpr body)
) `thenL` \ (bind, ItsAnExpr body) ->
mapAndUnzipL f xs `thenL` \ (rs1,rs2) ->
returnL ((r1:rs1),(r2:rs2))
+-- liftBinders is only called for top-level or recusive case
+liftBinders :: Bool -> PlainCoreBinding -> LiftM thing -> LiftM thing
-liftBinders :: Bool -> Bool -> [Id] -> LiftM thing -> LiftM thing
-liftBinders toplev is_rec ids liftM idenv s0
+liftBinders False (CoNonRec _ _) liftM idenv s0
+ = error "CoreLift:liftBinders" -- should be caught by special case above
---ToDo | toplev || is_rec -- *must* play the lifting game
+liftBinders top_lev bind liftM idenv s0
= liftM (growIdEnvList idenv lift_map) s1
where
- lift_ids = [ id | id <- ids, is_unboxed_but_not_state (getIdUniType id) ]
+ lift_ids = [ id | id <- bindersOf bind, isUnboxedButNotState (getIdUniType id) ]
(lift_uniqs, s1) = getSUniquesAndDepleted (length lift_ids) s0
lift_map = zip lift_ids (zipWith mkLiftedId lift_ids lift_uniqs)
+ -- ToDo: Give warning for recursive bindings involving unboxed values ???
+
+
isLiftedId :: Id -> LiftM (Maybe (Id, Id))
isLiftedId id idenv us
| isLocallyDefined id
= lookupIdEnv idenv id
| otherwise -- ensure all imported ids are lifted
- = if is_unboxed_but_not_state (getIdUniType id)
+ = if isUnboxedButNotState (getIdUniType id)
then Just (mkLiftedId id (getSUnique us))
else Nothing
mkLiftedId :: Id -> Unique -> (Id,Id)
mkLiftedId id u
- = ASSERT (is_unboxed_but_not_state unlifted_ty)
+ = ASSERT (isUnboxedButNotState unlifted_ty)
(lifted_id, unlifted_id)
where
id_name = getOccurrenceName id
bindUnlift :: Id -> Id -> PlainCoreExpr -> PlainCoreExpr
bindUnlift vlift vunlift expr
- = ASSERT (is_unboxed_but_not_state unlift_ty && lift_ty == mkLiftTy unlift_ty)
+ = ASSERT (isUnboxedButNotState unlift_ty)
+ ASSERT (lift_ty == mkLiftTy unlift_ty)
CoCase (CoVar vlift)
(CoAlgAlts [(liftDataCon, [vunlift], expr)] CoNoDefault)
where
liftExpr :: Id -> PlainCoreExpr -> PlainCoreExpr
liftExpr vunlift rhs
- = ASSERT (is_unboxed_but_not_state unlift_ty && rhs_ty == unlift_ty)
+ = ASSERT (isUnboxedButNotState unlift_ty)
+ ASSERT (rhs_ty == unlift_ty)
CoCase rhs (CoPrimAlts [] (CoBindDefault vunlift
(CoCon liftDataCon [unlift_ty] [CoVarAtom vunlift])))
where
applyBindUnlifts [] expr = expr
applyBindUnlifts (f:fs) expr = f (applyBindUnlifts fs expr)
-is_unboxed_but_not_state ty
+isUnboxedButNotState ty
= case (getUniDataTyCon_maybe ty) of
Nothing -> False
Just (tycon, _, _) ->
import CmdLineOpts(GlobalSwitch)
import CoreSyn(CoreBinding, CoreExpr)
import Id(Id)
+import Maybes(Labda)
import PlainCore(PlainCoreBinding(..))
import Pretty(PprStyle)
import SrcLoc(SrcLoc)
type PlainCoreBinding = CoreBinding Id Id
data PprStyle
lintCoreBindings :: PprStyle -> [Char] -> Bool -> [CoreBinding Id Id] -> [CoreBinding Id Id]
-lintUnfolding :: SrcLoc -> CoreExpr Id Id -> CoreExpr Id Id
+lintUnfolding :: SrcLoc -> CoreExpr Id Id -> Labda (CoreExpr Id Id)
We use this to check all unfoldings that come in from interfaces
(it is very painful to catch errors otherwise):
\begin{code}
-lintUnfolding :: SrcLoc -> PlainCoreExpr -> PlainCoreExpr
+lintUnfolding :: SrcLoc -> PlainCoreExpr -> Maybe PlainCoreExpr
lintUnfolding locn expr
= case (initL (addLoc (ImportedUnfolding locn) (lintCoreExpr expr)) True{-pretend spec done-}) of
- Nothing -> expr
- Just msg -> error ("ERROR: Type-incorrect unfolding from an interface:\n"++
- (ppShow 80 (ppAboves [msg PprForUser,
- ppStr "*** Bad unfolding ***",
- ppr PprDebug expr,
- ppStr "*** End of bad unfolding ***"])))
+ Nothing -> Just expr
+ Just msg -> pprTrace "WARNING: Discarded bad unfolding from interface:\n"
+ (ppAboves [msg PprForUser,
+ ppStr "*** Bad unfolding ***",
+ ppr PprDebug expr,
+ ppStr "*** End unfolding ***"])
+ Nothing
\end{code}
\begin{code}
) `thenL_`
-- Check not isPrimType
- checkL (not (isPrimType (getIdUniType binder)))
- (mkRhsPrimMsg binder rhs)
+ checkIfSpecDoneL (not (isPrimType (getIdUniType binder)))
+ (mkRhsPrimMsg binder rhs)
`thenL_`
-- Check unfolding, if any
))
lintCoreExpr e@(CoCon con tys args)
- = checkTyApp con_ty tys (mkTyAppMsg e) `thenMaybeL` \ con_tau_ty ->
- -- Note: no call to checkSpecTyApp;
- -- we allow CoCons applied to unboxed types to sail through
- mapMaybeL lintCoreAtom args `thenL` \ maybe_arg_tys ->
+ = checkTyApp con_ty tys (mkTyAppMsg e) `thenMaybeL` \ con_tau_ty ->
+ -- Note: no call to checkSpecTyApp for constructor type args
+ mapMaybeL lintCoreAtom args `thenL` \ maybe_arg_tys ->
case maybe_arg_tys of
Nothing -> returnL Nothing
Just arg_tys -> checkFunApp con_tau_ty arg_tys (mkFunAppMsg con_tau_ty arg_tys e)
lintCoreExpr e@(CoPrim op tys args)
= checkTyApp op_ty tys (mkTyAppMsg e) `thenMaybeL` \ op_tau_ty ->
- -- checkSpecTyApp e tys (mkSpecTyAppMsg e) `thenMaybeL_`
+ -- ToDo: checkSpecTyApp e tys (mkSpecTyAppMsg e) `thenMaybeL_`
mapMaybeL lintCoreAtom args `thenL` \ maybe_arg_tys ->
case maybe_arg_tys of
Nothing -> returnL Nothing
checkL True msg spec loc scope errs = ((), errs)
checkL False msg spec loc scope errs = ((), addErr errs msg loc)
+checkIfSpecDoneL :: Bool -> ErrMsg -> LintM ()
+checkIfSpecDoneL True msg spec loc scope errs = ((), errs)
+checkIfSpecDoneL False msg True loc scope errs = ((), addErr errs msg loc)
+checkIfSpecDoneL False msg False loc scope errs = ((), errs)
+
addErrL :: ErrMsg -> LintM ()
addErrL msg spec loc scope errs = ((), addErr errs msg loc)
> )
> import CmdLineOpts ( SwitchResult, switchIsOn )
> import CoreFuns ( mkCoLam, unTagBinders, typeOfCoreExpr )
-> import Id ( applyTypeEnvToId, getIdInfo, isTopLevId, Id,
+> import Id ( applyTypeEnvToId, getIdUnfolding, isTopLevId, Id,
> isInstId_maybe
> )
> import Inst -- Inst(..)
> if (not . deforestable) id
> then no_unfold
>
-> else case (getInfo_UF (getIdInfo id)) of
+> else case (getIdUnfolding id) of
> GeneralForm _ _ expr guidance ->
> panic "DefExpr:GeneralForm has changed a little; needs mod here"
> -- SLPJ March 95
data MaybeErr a b
type MethodInstInfo = (Id, [UniType], InstTemplate)
data TypecheckedPat
+data SpecEnv
data SpecInfo
data SplitUniqSupply
data TyCon
lookupClassInstAtSimpleType :: Class -> UniType -> Labda Id
lookupInst :: SplitUniqSupply -> Inst -> Labda (Expr Id TypecheckedPat, [Inst])
lookupNoBindInst :: SplitUniqSupply -> Inst -> Labda [Inst]
+mkInstSpecEnv :: Class -> UniType -> [TyVarTemplate] -> [(Class, UniType)] -> SpecEnv
nullMEnv :: [(a, b)]
lookupInst,
lookupClassInstAtSimpleType,
lookupNoBindInst,
+ mkInstSpecEnv,
MatchEnv(..), -- mk more abstract (??? ToDo)
nullMEnv,
--- mkMEnv, lookupMEnv, insertMEnv, -- no need to export
+-- mkMEnv, lookupMEnv, matchMEnv, insertMEnv, -- no need to export
-- and to make the interface self-sufficient...
Class, ClassOp, CoreExpr, Expr, TypecheckedPat, Id,
Inst, InstOrigin, Maybe, MaybeErr, TyVarTemplate, TyCon,
- UniType, SplitUniqSupply, SpecInfo
+ UniType, SplitUniqSupply, SpecInfo, SpecEnv
) where
IMPORT_Trace -- ToDo: rm (debugging)
type InstanceMapper
= Class -> (ClassInstEnv, ClassOp -> SpecEnv)
-type ClassInstEnv = MatchEnv UniType InstTemplate -- Instances of dicts
---OLD: type IdInstEnv = MatchEnv [UniType] InstTemplate -- Instances of ids
+type ClassInstEnv
+ = MatchEnv UniType InstTemplate -- Instances of dicts
data InstTemplate
= MkInstTemplate
float_lit = App (Var floatDataCon) (Lit (FloatPrimLit fD))
\end{code}
-There is a second, simpler interface, when you want an instance
-of a class at a given nullary type constructor. It just returns
-the appropriate dictionary if it exists. It is used only when resolving
+There is a second, simpler interface, when you want an instance of a
+class at a given nullary type constructor. It just returns the
+appropriate dictionary if it exists. It is used only when resolving
ambiguous dictionaries.
\begin{code}
inst_env = getClassInstEnv clas
\end{code}
+\begin{code}
+mkInstSpecEnv :: Class -- class
+ -> UniType -- instance type
+ -> [TyVarTemplate] -- instance tyvars
+ -> ThetaType -- superclasses dicts
+ -> SpecEnv -- specenv for dfun of instance
+
+mkInstSpecEnv clas inst_ty inst_tvs inst_theta
+ = mkSpecEnv (catMaybes (map maybe_spec_info matches))
+ where
+ matches = matchMEnv matchTy (getClassInstEnv clas) inst_ty
+
+ maybe_spec_info (_, match_info, MkInstTemplate dfun _ [])
+ = Just (SpecInfo (map (assocMaybe match_info) inst_tvs) (length inst_theta) dfun)
+ maybe_spec_info (_, match_info, _)
+ = Nothing
+
+\end{code}
+
%************************************************************************
%* *
\subsection[MatchEnv]{Matching environments}
\end{code}
@lookupMEnv@ looks up in a @MatchEnv@.
-It
-simply takes the first match, should be the most specific.
+It simply takes the first match, should be the most specific.
\begin{code}
lookupMEnv :: (key {- template -} -> -- Matching function
Just match_info -> Just (tpl, match_info, val)
\end{code}
+@matchEnv@ returns all more specidfic matches in a @MatchEnv@,
+most specific first.
+
+\begin{code}
+matchMEnv :: (key {- template -} -> -- Matching function
+ key {- instance -} ->
+ Maybe match_info)
+ -> MatchEnv key value -- The envt
+ -> key -- Key
+ -> [(key,
+ match_info, -- Match info returned by matching fn
+ value)] -- Value
+
+matchMEnv key_match alist key
+ = match alist
+ where
+ match [] = []
+ match ((tpl, val) : rest)
+ = case key_match tpl key of
+ Nothing -> case key_match key tpl of
+ Nothing -> match rest
+ Just match_info -> (tpl, match_info, val) : match rest
+ Just _ -> []
+\end{code}
+
@insertMEnv@ extends a match environment, checking for overlaps.
\begin{code}
import MainMonad(MainIO(..))
import Maybes(Labda)
type CmdLineInfo = (GlobalSwitch -> SwitchResult, [CoreToDo], [StgToDo])
-data CoreToDo = CoreDoSimplify (SimplifierSwitch -> SwitchResult) | CoreDoArityAnalysis | CoreDoCalcInlinings1 | CoreDoCalcInlinings2 | CoreDoFloatInwards | CoreDoFullLaziness | CoreLiberateCase | CoreDoPrintCore | CoreDoStaticArgs | CoreDoStrictness | CoreDoSpecialising | CoreDoDeforest | CoreDoAutoCostCentres | CoreDoFoldrBuildWorkerWrapper | CoreDoFoldrBuildWWAnal
+data CoreToDo = CoreDoSimplify (SimplifierSwitch -> SwitchResult) | Core_Unused_Flag_1 | CoreDoCalcInlinings1 | CoreDoCalcInlinings2 | CoreDoFloatInwards | CoreDoFullLaziness | CoreLiberateCase | CoreDoPrintCore | CoreDoStaticArgs | CoreDoStrictness | CoreDoSpecialising | CoreDoDeforest | CoreDoAutoCostCentres | CoreDoFoldrBuildWorkerWrapper | CoreDoFoldrBuildWWAnal
data GlobalSwitch
- = ProduceC [Char] | ProduceS [Char] | ProduceHi [Char] | AsmTarget [Char] | ForConcurrent | Haskell_1_3 | GlasgowExts | CompilingPrelude | HideBuiltinNames | HideMostBuiltinNames | EnsureSplittableC [Char] | Verbose | PprStyle_User | PprStyle_Debug | PprStyle_All | DoCoreLinting | EmitArityChecks | OmitInterfacePragmas | OmitDerivedRead | OmitReexportedInstances | UnfoldingUseThreshold Int | UnfoldingCreationThreshold Int | UnfoldingOverrideThreshold Int | ReportWhyUnfoldingsDisallowed | UseGetMentionedVars | ShowPragmaNameErrs | NameShadowingNotOK | SigsRequired | SccProfilingOn | AutoSccsOnExportedToplevs | AutoSccsOnAllToplevs | AutoSccsOnIndividualCafs | SccGroup [Char] | DoTickyProfiling | DoSemiTagging | FoldrBuildOn | FoldrBuildTrace | SpecialiseImports | ShowImportSpecs | OmitUnspecialisedCode | SpecialiseOverloaded | SpecialiseUnboxed | SpecialiseAll | SpecialiseTrace | OmitBlackHoling | StgDoLetNoEscapes | IgnoreStrictnessPragmas | IrrefutableTuples | IrrefutableEverything | AllStrict | NumbersStrict | AllDemanded | ReturnInRegsThreshold Int | VectoredReturnThreshold Int | D_dump_rif2hs | D_dump_rn4 | D_dump_tc | D_dump_deriv | D_dump_ds | D_dump_occur_anal | D_dump_simpl | D_dump_spec | D_dump_stranal | D_dump_deforest | D_dump_stg | D_dump_absC | D_dump_flatC | D_dump_realC | D_dump_asm | D_dump_core_passes | D_dump_core_passes_info | D_verbose_core2core | D_verbose_stg2stg | D_simplifier_stats
+ = ProduceC [Char] | ProduceS [Char] | ProduceHi [Char] | AsmTarget [Char] | ForConcurrent | Haskell_1_3 | GlasgowExts | CompilingPrelude | HideBuiltinNames | HideMostBuiltinNames | EnsureSplittableC [Char] | Verbose | PprStyle_User | PprStyle_Debug | PprStyle_All | DoCoreLinting | EmitArityChecks | OmitInterfacePragmas | OmitDerivedRead | OmitReexportedInstances | UnfoldingUseThreshold Int | UnfoldingCreationThreshold Int | UnfoldingOverrideThreshold Int | ReportWhyUnfoldingsDisallowed | UseGetMentionedVars | ShowPragmaNameErrs | NameShadowingNotOK | SigsRequired | SccProfilingOn | AutoSccsOnExportedToplevs | AutoSccsOnAllToplevs | AutoSccsOnIndividualCafs | SccGroup [Char] | DoTickyProfiling | DoSemiTagging | FoldrBuildOn | FoldrBuildTrace | SpecialiseImports | ShowImportSpecs | OmitDefaultInstanceMethods | SpecialiseOverloaded | SpecialiseUnboxed | SpecialiseAll | SpecialiseTrace | OmitBlackHoling | StgDoLetNoEscapes | IgnoreStrictnessPragmas | IrrefutableTuples | IrrefutableEverything | AllStrict | NumbersStrict | AllDemanded | ReturnInRegsThreshold Int | VectoredReturnThreshold Int | D_dump_rif2hs | D_dump_rn4 | D_dump_tc | D_dump_deriv | D_dump_ds | D_dump_occur_anal | D_dump_simpl | D_dump_spec | D_dump_stranal | D_dump_deforest | D_dump_stg | D_dump_absC | D_dump_flatC | D_dump_realC | D_dump_asm | D_show_passes | D_verbose_core2core | D_verbose_stg2stg | D_simplifier_stats | D_source_stats
type MainIO a = _State _RealWorld -> (a, _State _RealWorld)
data Labda a
data SimplifierSwitch = SimplOkToDupCode | SimplFloatLetsExposingWHNF | SimplOkToFloatPrimOps | SimplAlwaysFloatLetsFromLets | SimplDoCaseElim | SimplReuseCon | SimplCaseOfCase | SimplLetToCase | SimplMayDeleteConjurableIds | SimplPedanticBottoms | SimplDoArityExpand | SimplDoFoldrBuild | SimplDoNewOccurAnal | SimplDoInlineFoldrBuild | IgnoreINLINEPragma | SimplDoLambdaEtaExpansion | SimplDoEtaReduction | EssentialUnfoldingsOnly | ShowSimplifierProgress | MaxSimplifierIterations Int | SimplUnfoldingUseThreshold Int | SimplUnfoldingCreationThreshold Int | KeepSpecPragmaIds | KeepUnusedBindings | SimplNoLetFromCase | SimplNoLetFromApp | SimplNoLetFromStrictLet
-- Each run of the simplifier can take a different
-- set of simplifier-specific flags.
- | CoreDoArityAnalysis -- UNUSED right now
+ | Core_Unused_Flag_1
| CoreDoCalcInlinings1
| CoreDoCalcInlinings2
| CoreDoFloatInwards
= ProduceC String -- generate C output into this file
| ProduceS String -- generate native-code assembler into this file
| ProduceHi String -- generate .hi interface into this file
---UNUSED: | ProduceHu String -- generate .hu usage-info into this file
| AsmTarget String -- architecture we are generating code for
| ForConcurrent
| AutoSccsOnExportedToplevs
| AutoSccsOnAllToplevs
| AutoSccsOnIndividualCafs
---UNUSED: | AutoSccsOnIndividualDicts
| SccGroup String -- name of "group" for this cost centres in this module
| DoTickyProfiling
| SpecialiseImports -- Treat non-essential spec requests as errors
| ShowImportSpecs -- Output spec requests for non-essential specs
- | OmitUnspecialisedCode -- ToDo? (Patrick)
+ | OmitDefaultInstanceMethods
| SpecialiseOverloaded
| SpecialiseUnboxed
| SpecialiseAll
-- this batch of flags is for particular experiments;
-- v unlikely to be used in any other circumstance
---UNUSED: | OmitStkChecks
| OmitBlackHoling
| StgDoLetNoEscapes
| IgnoreStrictnessPragmas -- ToDo: still useful?
| ReturnInRegsThreshold Int
| VectoredReturnThreshold Int -- very likely UNUSED
--- NOT REALLY USED: | D_dump_type_info -- for Robin Popplestone stuff
-
| D_dump_rif2hs -- debugging: print out various things
| D_dump_rn4
| D_dump_tc
| D_dump_flatC
| D_dump_realC
| D_dump_asm
- | D_dump_core_passes -- A Gill-ism
- | D_dump_core_passes_info -- Yet another Gill-ism
+ | D_show_passes
+--ANDY: | D_dump_core_passes_info -- A Gill-ism
| D_verbose_core2core
| D_verbose_stg2stg
| D_simplifier_stats
-
-{- ????
- | Extra__Flag1
- | Extra__Flag2
- | Extra__Flag3
- | Extra__Flag4
- | Extra__Flag5
- | Extra__Flag6
- | Extra__Flag7
- | Extra__Flag8
- | Extra__Flag9
--}
+ | D_source_stats
#ifdef DPH
| PodizeIntelligent
| SimplReuseCon
| SimplCaseOfCase
| SimplLetToCase
---UNUSED: | SimplOkToInlineInLambdas
| SimplMayDeleteConjurableIds
| SimplPedanticBottoms -- see Simplifier for an explanation
| SimplDoArityExpand -- expand arity of bindings
| IgnoreINLINEPragma
| SimplDoLambdaEtaExpansion
---UNUSED: | SimplDoMonadEtaExpansion
-
| SimplDoEtaReduction
| EssentialUnfoldingsOnly -- never mind the thresholds, only
"-ddump-spec" -> GLOBAL_SW(D_dump_spec)
"-ddump-simpl" -> GLOBAL_SW(D_dump_simpl)
"-ddump-occur-anal" -> GLOBAL_SW(D_dump_occur_anal)
--- NOT REALLY USED: "-ddump-type-info" -> GLOBAL_SW(D_dump_type_info)
#ifdef DPH
- "-ddump-pod" -> GLOBAL_SW(D_dump_pod)
- "-ddump-psimpl"-> GLOBAL_SW(D_dump_psimpl)
- "-ddump-nextC" -> GLOBAL_SW(D_dump_nextC)
+ "-ddump-pod" -> GLOBAL_SW(D_dump_pod)
+ "-ddump-psimpl" -> GLOBAL_SW(D_dump_psimpl)
+ "-ddump-nextC" -> GLOBAL_SW(D_dump_nextC)
#endif {- Data Parallel Haskell -}
- "-ddump-stg" -> GLOBAL_SW(D_dump_stg)
- "-ddump-absC" -> GLOBAL_SW(D_dump_absC)
- "-ddump-flatC"-> GLOBAL_SW(D_dump_flatC)
- "-ddump-realC"-> GLOBAL_SW(D_dump_realC)
- "-ddump-asm" -> GLOBAL_SW(D_dump_asm)
+ "-ddump-stg" -> GLOBAL_SW(D_dump_stg)
+ "-ddump-absC" -> GLOBAL_SW(D_dump_absC)
+ "-ddump-flatC" -> GLOBAL_SW(D_dump_flatC)
+ "-ddump-realC" -> GLOBAL_SW(D_dump_realC)
+ "-ddump-asm" -> GLOBAL_SW(D_dump_asm)
+ "-dshow-passes" -> GLOBAL_SW(D_show_passes)
- "-ddump-core-passes" -> GLOBAL_SW(D_dump_core_passes)
-- ANDY: "-ddump-haskell" -> GLOBAL_SW(D_dump_core_passes_info)
"-dsimplifier-stats" -> GLOBAL_SW(D_simplifier_stats)
+ "-dsource-stats" -> GLOBAL_SW(D_source_stats)
"-dverbose-simpl" ->GLOBAL_SW(D_verbose_core2core)
"-dverbose-stg" -> GLOBAL_SW(D_verbose_stg2stg)
"-fsimplify" -> -- gather up SimplifierSwitches specially...
simpl_sep opts [] glob_sw core_td stg_td
---UNUSED: "-farity-analysis" -> CORE_TD(CoreDoArityAnalysis)
"-fcalc-inlinings1"-> CORE_TD(CoreDoCalcInlinings1)
"-fcalc-inlinings2"-> CORE_TD(CoreDoCalcInlinings2)
"-ffloat-inwards" -> CORE_TD(CoreDoFloatInwards)
"-ffoldr-build-ww-anal" -> CORE_TD(CoreDoFoldrBuildWWAnal)
--ANDY: "-fprint-haskell-core" -> CORE_TD(CoreDoHaskPrint)
-- "-fprint-haskell-letless-core" -> CORE_TD(CoreDoHaskLetlessPrint)
-
+ "-fomit-default-instance-methods" -> GLOBAL_SW(OmitDefaultInstanceMethods)
"-fspecialise-overloaded" -> GLOBAL_SW(SpecialiseOverloaded)
"-fspecialise-unboxed" -> GLOBAL_SW(SpecialiseUnboxed)
"-fspecialise-all" -> GLOBAL_SW(SpecialiseAll)
"-fauto-sccs-on-exported-toplevs" -> GLOBAL_SW(AutoSccsOnExportedToplevs)
"-fauto-sccs-on-all-toplevs" -> GLOBAL_SW(AutoSccsOnAllToplevs)
"-fauto-sccs-on-individual-cafs" -> GLOBAL_SW(AutoSccsOnIndividualCafs)
---UNUSED: "-fauto-sccs-on-individual-dicts" -> GLOBAL_SW(AutoSccsOnIndividualDicts)
"-fticky-ticky" -> GLOBAL_SW(DoTickyProfiling)
"-fconcurrent" -> GLOBAL_SW(ForConcurrent)
- "-fomit-unspecialised-code" -> GLOBAL_SW(OmitUnspecialisedCode)
"-fshow-pragma-name-errs" -> GLOBAL_SW(ShowPragmaNameErrs)
"-fname-shadowing-not-ok" -> GLOBAL_SW(NameShadowingNotOK)
"-fsignatures-required" -> GLOBAL_SW(SigsRequired)
"-fomit-reexported-instances" -> GLOBAL_SW(OmitReexportedInstances)
"-darity-checks" -> GLOBAL_SW(EmitArityChecks)
---UNUSED: "-dno-stk-chks" -> GLOBAL_SW(OmitStkChecks)
"-dno-black-holing"-> GLOBAL_SW(OmitBlackHoling)
_ | starts_with_fasm -> GLOBAL_SW(AsmTarget after_fasm)
"-fdo-case-elim" -> GLOBAL_SIMPL_SW(SimplDoCaseElim)
"-fdo-eta-reduction" -> GLOBAL_SIMPL_SW(SimplDoEtaReduction)
"-fdo-lambda-eta-expansion" -> GLOBAL_SIMPL_SW(SimplDoLambdaEtaExpansion)
---UNUSED: "-fdo-monad-eta-expansion" -> GLOBAL_SIMPL_SW(SimplDoMonadEtaExpansion)
"-fdo-foldr-build" -> GLOBAL_SIMPL_SW(SimplDoFoldrBuild)
"-fdo-new-occur-anal" -> GLOBAL_SIMPL_SW(SimplDoNewOccurAnal)
"-fdo-arity-expand" -> GLOBAL_SIMPL_SW(SimplDoArityExpand)
"-fpedantic-bottoms" -> GLOBAL_SIMPL_SW(SimplPedanticBottoms)
"-fkeep-spec-pragma-ids" -> GLOBAL_SIMPL_SW(KeepSpecPragmaIds)
"-fkeep-unused-bindings" -> GLOBAL_SIMPL_SW(KeepUnusedBindings)
---UNUSED: "-finline-in-lambdas-ok" -> GLOBAL_SIMPL_SW(SimplOkToInlineInLambdas)
"-fmay-delete-conjurable-ids" -> GLOBAL_SIMPL_SW(SimplMayDeleteConjurableIds)
"-fessential-unfoldings-only" -> GLOBAL_SIMPL_SW(EssentialUnfoldingsOnly)
"-fignore-inline-pragma" -> GLOBAL_SIMPL_SW(IgnoreINLINEPragma)
tagOf_Switch (ProduceC _) =(ILIT(0) :: FAST_INT)
tagOf_Switch (ProduceS _) = ILIT(1)
tagOf_Switch (ProduceHi _) = ILIT(2)
---UNUSED:tagOf_Switch (ProduceHu _) = ILIT(3)
tagOf_Switch (AsmTarget _) = ILIT(4)
---UNUSED:tagOf_Switch ForParallel = ILIT(5)
tagOf_Switch ForConcurrent = ILIT(6)
---UNUSED:tagOf_Switch ForGRIP = ILIT(7)
tagOf_Switch Haskell_1_3 = ILIT(8)
tagOf_Switch GlasgowExts = ILIT(9)
tagOf_Switch CompilingPrelude = ILIT(10)
tagOf_Switch AutoSccsOnExportedToplevs = ILIT(32)
tagOf_Switch AutoSccsOnAllToplevs = ILIT(33)
tagOf_Switch AutoSccsOnIndividualCafs = ILIT(34)
---UNUSED:tagOf_Switch AutoSccsOnIndividualDicts = ILIT(35)
tagOf_Switch (SccGroup _) = ILIT(36)
tagOf_Switch DoTickyProfiling = ILIT(37)
tagOf_Switch DoSemiTagging = ILIT(38)
tagOf_Switch FoldrBuildTrace = ILIT(40)
tagOf_Switch SpecialiseImports = ILIT(41)
tagOf_Switch ShowImportSpecs = ILIT(42)
-tagOf_Switch OmitUnspecialisedCode = ILIT(43)
+tagOf_Switch OmitDefaultInstanceMethods = ILIT(43)
tagOf_Switch SpecialiseOverloaded = ILIT(44)
tagOf_Switch SpecialiseUnboxed = ILIT(45)
tagOf_Switch SpecialiseAll = ILIT(46)
tagOf_Switch SpecialiseTrace = ILIT(47)
---UNUSED:tagOf_Switch OmitStkChecks = ILIT(48)
+
tagOf_Switch OmitBlackHoling = ILIT(49)
tagOf_Switch StgDoLetNoEscapes = ILIT(50)
tagOf_Switch IgnoreStrictnessPragmas = ILIT(51)
tagOf_Switch AllStrict = ILIT(54)
tagOf_Switch NumbersStrict = ILIT(55)
tagOf_Switch AllDemanded = ILIT(56)
--- NOT REALLY USED: tagOf_Switch D_dump_type_info = ILIT(56)
+
tagOf_Switch (ReturnInRegsThreshold _) = ILIT(57)
tagOf_Switch (VectoredReturnThreshold _)= ILIT(58)
tagOf_Switch D_dump_rif2hs = ILIT(59)
tagOf_Switch D_dump_flatC = ILIT(70)
tagOf_Switch D_dump_realC = ILIT(71)
tagOf_Switch D_dump_asm = ILIT(72)
-tagOf_Switch D_dump_core_passes = ILIT(73)
-tagOf_Switch D_dump_core_passes_info = ILIT(74)
-tagOf_Switch D_verbose_core2core = ILIT(75)
-tagOf_Switch D_verbose_stg2stg = ILIT(76)
-tagOf_Switch D_simplifier_stats = ILIT(77) {-see note below!-}
-
-{-
-tagOf_Switch Extra__Flag1 = ILIT(76)
-tagOf_Switch Extra__Flag2 = ILIT(77)
-tagOf_Switch Extra__Flag3 = ILIT(78)
-tagOf_Switch Extra__Flag4 = ILIT(79)
-tagOf_Switch Extra__Flag5 = ILIT(80)
-tagOf_Switch Extra__Flag6 = ILIT(81)
-tagOf_Switch Extra__Flag7 = ILIT(82)
-tagOf_Switch Extra__Flag8 = ILIT(83)
-tagOf_Switch Extra__Flag9 = ILIT(84)
--}
+tagOf_Switch D_show_passes = ILIT(73)
+--ANDY:tagOf_Switch D_dump_core_passes_info = ILIT(??)
+tagOf_Switch D_verbose_core2core = ILIT(74)
+tagOf_Switch D_verbose_stg2stg = ILIT(75)
+tagOf_Switch D_simplifier_stats = ILIT(76)
+tagOf_Switch D_source_stats = ILIT(77) {-see note below!-}
#ifndef DPH
tagOf_Switch _ = case (panic "tagOf_Switch") of -- BUG avoidance
s -> tagOf_Switch s
-lAST_SWITCH_TAG = IBOX(tagOf_Switch D_simplifier_stats)
+lAST_SWITCH_TAG = IBOX(tagOf_Switch D_source_stats)
#else {- Data Parallel Haskell -}
tagOf_SimplSwitch SimplReuseCon = ILIT(5)
tagOf_SimplSwitch SimplCaseOfCase = ILIT(6)
tagOf_SimplSwitch SimplLetToCase = ILIT(7)
---UNUSED:tagOf_SimplSwitch SimplOkToInlineInLambdas = ILIT(8)
tagOf_SimplSwitch SimplMayDeleteConjurableIds = ILIT(9)
tagOf_SimplSwitch SimplPedanticBottoms = ILIT(10)
tagOf_SimplSwitch SimplDoArityExpand = ILIT(11)
tagOf_SimplSwitch SimplDoInlineFoldrBuild = ILIT(14)
tagOf_SimplSwitch IgnoreINLINEPragma = ILIT(15)
tagOf_SimplSwitch SimplDoLambdaEtaExpansion = ILIT(16)
---UNUSED:tagOf_SimplSwitch SimplDoMonadEtaExpansion = ILIT(17)
tagOf_SimplSwitch SimplDoEtaReduction = ILIT(18)
tagOf_SimplSwitch EssentialUnfoldingsOnly = ILIT(19)
tagOf_SimplSwitch ShowSimplifierProgress = ILIT(20)
type Error = PprStyle -> Int -> Bool -> PrettyRep
data UnifyErrContext
= PredCtxt (Expr Name (InPat Name)) | AppCtxt (Expr Name (InPat Name)) (Expr Name (InPat Name)) | TooManyArgsCtxt (Expr Name (InPat Name)) | FunAppCtxt (Expr Name (InPat Name)) (Labda Id) (Expr Name (InPat Name)) UniType UniType Int | OpAppCtxt (Expr Name (InPat Name)) (Expr Name (InPat Name)) (Expr Name (InPat Name)) | SectionLAppCtxt (Expr Name (InPat Name)) (Expr Name (InPat Name)) | SectionRAppCtxt (Expr Name (InPat Name)) (Expr Name (InPat Name)) | CaseCtxt (Expr Name (InPat Name)) [Match Name (InPat Name)] | BranchCtxt (Expr Name (InPat Name)) (Expr Name (InPat Name)) | ListCtxt [Expr Name (InPat Name)] | PatCtxt (InPat Name) | CaseBranchesCtxt [Match Name (InPat Name)] | FilterCtxt (Expr Name (InPat Name)) | GeneratorCtxt (InPat Name) (Expr Name (InPat Name)) | GRHSsBranchCtxt [GRHS Name (InPat Name)] | GRHSsGuardCtxt (Expr Name (InPat Name)) | PatMonoBindsCtxt (InPat Name) (GRHSsAndBinds Name (InPat Name)) | FunMonoBindsCtxt Name [Match Name (InPat Name)] | MatchCtxt UniType UniType | ArithSeqCtxt (Expr Name (InPat Name)) | CCallCtxt [Char] [Expr Name (InPat Name)] | AmbigDictCtxt [Inst] | SigCtxt Id UniType | MethodSigCtxt Name UniType | ExprSigCtxt (Expr Name (InPat Name)) UniType | ValSpecSigCtxt Name UniType SrcLoc | ValSpecSpecIdCtxt Name UniType Name SrcLoc | BindSigCtxt [Id] | SuperClassSigCtxt | CaseBranchCtxt (Match Name (InPat Name)) | Rank2ArgCtxt (Expr Id TypecheckedPat) UniType
-data UnifyErrInfo = UnifyMisMatch UniType UniType | TypeRec TyVar UniType | UnifyListMisMatch [UniType] [UniType]
+data UnifyErrInfo = UnifyMisMatch UniType UniType | TypeRec TyVar UniType | UnifyListMisMatch [UniType] [UniType] | UnifyUnboxedMisMatch UniType UniType
data SignatureInfo
data MonoBinds a b
type ProtoNameMonoBinds = MonoBinds ProtoName (InPat ProtoName)
import UniType(UniType)
data UnifyErrContext
= PredCtxt (Expr Name (InPat Name)) | AppCtxt (Expr Name (InPat Name)) (Expr Name (InPat Name)) | TooManyArgsCtxt (Expr Name (InPat Name)) | FunAppCtxt (Expr Name (InPat Name)) (Labda Id) (Expr Name (InPat Name)) UniType UniType Int | OpAppCtxt (Expr Name (InPat Name)) (Expr Name (InPat Name)) (Expr Name (InPat Name)) | SectionLAppCtxt (Expr Name (InPat Name)) (Expr Name (InPat Name)) | SectionRAppCtxt (Expr Name (InPat Name)) (Expr Name (InPat Name)) | CaseCtxt (Expr Name (InPat Name)) [Match Name (InPat Name)] | BranchCtxt (Expr Name (InPat Name)) (Expr Name (InPat Name)) | ListCtxt [Expr Name (InPat Name)] | PatCtxt (InPat Name) | CaseBranchesCtxt [Match Name (InPat Name)] | FilterCtxt (Expr Name (InPat Name)) | GeneratorCtxt (InPat Name) (Expr Name (InPat Name)) | GRHSsBranchCtxt [GRHS Name (InPat Name)] | GRHSsGuardCtxt (Expr Name (InPat Name)) | PatMonoBindsCtxt (InPat Name) (GRHSsAndBinds Name (InPat Name)) | FunMonoBindsCtxt Name [Match Name (InPat Name)] | MatchCtxt UniType UniType | ArithSeqCtxt (Expr Name (InPat Name)) | CCallCtxt [Char] [Expr Name (InPat Name)] | AmbigDictCtxt [Inst] | SigCtxt Id UniType | MethodSigCtxt Name UniType | ExprSigCtxt (Expr Name (InPat Name)) UniType | ValSpecSigCtxt Name UniType SrcLoc | ValSpecSpecIdCtxt Name UniType Name SrcLoc | BindSigCtxt [Id] | SuperClassSigCtxt | CaseBranchCtxt (Match Name (InPat Name)) | Rank2ArgCtxt (Expr Id TypecheckedPat) UniType
-data UnifyErrInfo = UnifyMisMatch UniType UniType | TypeRec TyVar UniType | UnifyListMisMatch [UniType] [UniType]
+data UnifyErrInfo = UnifyMisMatch UniType UniType | TypeRec TyVar UniType | UnifyListMisMatch [UniType] [UniType] | UnifyUnboxedMisMatch UniType UniType
ambigErr :: [Inst] -> PprStyle -> Int -> Bool -> PrettyRep
badMatchErr :: UniType -> UniType -> UnifyErrContext -> SrcLoc -> PprStyle -> Int -> Bool -> PrettyRep
badSpecialisationErr :: [Char] -> [Char] -> Int -> [Labda UniType] -> SrcLoc -> PprStyle -> Int -> Bool -> PrettyRep
\begin{code}
data UnifyErrInfo
= UnifyMisMatch UniType UniType
- | TypeRec TyVar TauType -- Occurs check failure
+ | TypeRec TyVar TauType -- Occurs check failure
+
+ | UnifyListMisMatch [TauType] [TauType] -- Args to unifyList: diff lengths
+ -- produces system error
+
+ | UnifyUnboxedMisMatch UniType UniType -- No unboxed specialisation
- | UnifyListMisMatch [TauType] [TauType] -- Args to unifyList: diff lengths
- -- produces system error
\end{code}
@UnifyErrContext@ gives some context for unification
pprUnifyErrInfo sty (UnifyMisMatch mt1 mt2) err_ctxt
= ppUnifyErr (ppSep [ppBesides [ppStr "Couldn't match the type `", ppr sty mt1, ppStr "'"],
- ppBesides [ppStr "against `", ppr sty mt2, ppStr "'."]])
+ ppBesides [ppStr "against `", ppr sty mt2, ppStr "'."]])
(pprUnifyErrContext sty err_ctxt)
pprUnifyErrInfo sty (TypeRec tyvar ty) err_ctxt
pprUnifyErrInfo sty (UnifyListMisMatch tys1 tys2) err_ctxt
= panic "pprUnifyErrInfo: unifying lists of types of different lengths"
+
+pprUnifyErrInfo sty (UnifyUnboxedMisMatch mt1 mt2) err_ctxt
+ = ppUnifyErr (ppSep [ppBesides [ppStr "Couldn't match the type variable `", ppr sty mt1, ppStr "'"],
+ ppBesides [ppStr "against unboxed type `", ppr sty mt2, ppStr "'."],
+ ppStr "Try using -fspecialise-unboxed ..." ])
+ (pprUnifyErrContext sty err_ctxt)
\end{code}
%************************************************************************
import PlainCore ( CoreExpr, CoreBinding, pprPlainCoreBinding,
PlainCoreProgram(..), PlainCoreBinding(..)
)
-import Pretty ( PprStyle(..), ppShow, ppAboves, ppAppendFile
- IF_ATTACK_PRAGMAS(COMMA ppAbove)
- )
+import Pretty
+
#ifdef USE_NEW_READER
import ReadPrefix2 ( rdModule )
#else
-- ****** help functions:
switch_is_on switch = switchIsOn switch_lookup_fn switch
- -- essentially, converts SwBool answer to Bool
string_switch_is_on switch
= maybeToBool (stringSwitchSet switch_lookup_fn switch)
+ show_pass
+ = if switch_is_on D_show_passes
+ then \ what -> writeMn stderr ("*** "++what++":\n")
+ else \ what -> returnMn ()
+
doOutput switch io_action
= BSCC("doOutput")
case (stringSwitchSet switch_lookup_fn switch) of
#endif {- Data Parallel Haskell -}
-- ******* READER
+ show_pass "Read" `thenMn_`
#ifdef USE_NEW_READER
BSCC("rdModule")
rdModule
cc_mod_name = mod_name
-- also: export_list_fns
in
+ doDump D_source_stats "\nSource Statistics:"
+ (pp_show (ppSourceStats absyn_tree)) `thenMn_`
+
doDump D_dump_rif2hs "Parsed, Haskellised:"
- (pp_show (ppr pprStyle absyn_tree)) `thenMn_`
+ (pp_show (ppr pprStyle absyn_tree)) `thenMn_`
-- UniqueSupplies for later use
getSplitUniqSupplyMn 'r' `thenMn` \ rn_uniqs -> -- renamer
ncg_uniqs = {-mkUniqueSupplyGrimily-} pre_ncg_uniqs
in
-- ******* RENAMER
+ show_pass "Rename" `thenMn_`
BIND BSCC("Renamer")
renameModule switch_is_on
(init_val_lookup_fn, init_tc_lookup_fn)
else -- No renaming errors, carry on with...
-- ******* TYPECHECKER
+ show_pass "TypeCheck" `thenMn_`
BIND (case BSCC("TypeChecker")
typecheckModule switch_is_on tc_uniqs final_name_funs mod4
ESCC
BIND tc_results
_TO_ (typechecked_quad@(class_binds, inst_binds, val_binds, const_binds),
interface_stuff@(_,_,_,_,_), -- @-pat just for strictness...
- tycon_specs, {-UNUSED:big_env,-} this_mod_env, ddump_deriv) ->
+ pragma_tycon_specs, {-UNUSED:big_env,-} this_mod_env, ddump_deriv) ->
let
-- big_tce = getE_TCE big_env
-- big_elts = rngTCE big_tce
--NOT REALLY USED:
-- doDump D_dump_type_info "" (pp_show (printTypeInfoForPop big_tce)) `thenMn_`
-- ******* DESUGARER
+ show_pass "DeSugar" `thenMn_`
let
(desugared,ds_warnings)
= BSCC("DeSugarer")
-- ******* CORE-TO-CORE SIMPLIFICATION (NB: I/O op)
core2core core_cmds switch_lookup_fn co_mod_name pprStyle
- sm_uniqs local_tycons tycon_specs desugared
+ sm_uniqs local_tycons pragma_tycon_specs desugared
`thenMn` \ (simplified, inlinings_env,
- SpecData _ _ _ gen_tycons all_tycon_specs
- spec_errs spec_warn spec_tyerrs) ->
+ SpecData _ _ _ gen_tycons all_tycon_specs _ _ _) ->
doDump D_dump_simpl "Simplified:" (pp_show (ppAboves
(map (pprPlainCoreBinding pprStyle) simplified))) `thenMn_`
#endif
-- ******* STG-TO-STG SIMPLIFICATION
+ show_pass "Core2Stg" `thenMn_`
let
#ifndef DPH
stg_binds = BSCC("Core2Stg")
ESCC
#endif {- Data Parallel Haskell -}
in
-
+ show_pass "Stg2Stg" `thenMn_`
stg2stg stg_cmds switch_lookup_fn st_mod_name pprStyle st_uniqs stg_binds
`thenMn` \ (stg_binds2, cost_centre_info) ->
if_tce = nullTCE
if_inst_info = emptyBag
in
--} let
+-}
+ show_pass "Interface" `thenMn_`
+ let
mod_interface
= BSCC("MkInterface")
mkInterface switch_is_on if_mod_name export_list_fns
ESCC `thenMn_`
-- ******* "ABSTRACT", THEN "FLAT", THEN *REAL* C!
+ show_pass "CodeGen" `thenMn_`
let
abstractC = BSCC("CodeGen")
codeGen cc_mod_name -- module name for CC labelling
#endif {- Data Parallel Haskell -}
exitMn 0
{-)-} BEND ) BEND BEND BEND BEND
+
+
+ppSourceStats (Module name exports imports fixities typedecls typesigs
+ classdecls instdecls instsigs defdecls binds
+ [{-no sigs-}] src_loc)
+ = ppAboves (map pp_val
+ [("ExportAll ", export_all), -- 1 if no export list
+ ("ExportDecls ", export_ds),
+ ("ExportModules ", export_ms),
+ ("ImportAll ", import_all),
+ ("ImportPartial ", import_partial),
+ (" PartialDecls ", partial_decls),
+ ("ImportHiding ", import_hiding),
+ (" HidingDecls ", hiding_decls),
+ ("FixityDecls ", fixity_ds),
+ ("DefaultDecls ", defalut_ds),
+ ("TypeDecls ", type_ds),
+ ("DataDecls ", data_ds),
+ ("DataConstrs ", data_constrs),
+ ("DataDerivings ", data_derivs),
+ ("ClassDecls ", class_ds),
+ ("ClassMethods ", class_method_ds),
+ ("DefaultMethods ", default_method_ds),
+ ("InstDecls ", inst_ds),
+ ("InstMethods ", inst_method_ds),
+ ("TypeSigs ", bind_tys),
+ ("ValBinds ", val_bind_ds),
+ ("FunBinds ", fn_bind_ds),
+ ("InlineMeths ", method_inlines),
+ ("InlineBinds ", bind_inlines),
+ ("SpecialisedData ", data_specs),
+ ("SpecialisedInsts ", inst_specs),
+ ("SpecialisedMeths ", method_specs),
+ ("SpecialisedBinds ", bind_specs)
+ ])
+ where
+ pp_val (str, 0) = ppNil
+ pp_val (str, n) = ppBesides [ppStr str, ppInt n]
+
+ (export_decls, export_mods) = getRawIEStrings exports
+ type_decls = filter is_type_decl typedecls
+ data_decls = filter is_data_decl typedecls
+
+ export_ds = length export_decls
+ export_ms = length export_mods
+ export_all = if export_ds == 0 && export_ms == 0 then 1 else 0
+
+ fixity_ds = length fixities
+ defalut_ds = length defdecls
+ type_ds = length type_decls
+ data_ds = length data_decls
+ class_ds = length classdecls
+ inst_ds = length instdecls
+
+ (val_bind_ds, fn_bind_ds, bind_tys, bind_specs, bind_inlines)
+ = count_binds binds
+
+ (import_all, import_partial, partial_decls, import_hiding, hiding_decls)
+ = foldr add5 (0,0,0,0,0) (map import_info imports)
+ (data_constrs, data_derivs)
+ = foldr add2 (0,0) (map data_info data_decls)
+ (class_method_ds, default_method_ds)
+ = foldr add2 (0,0) (map class_info classdecls)
+ (inst_method_ds, method_specs, method_inlines)
+ = foldr add3 (0,0,0) (map inst_info instdecls)
+
+ data_specs = length (filter is_data_spec_sig typesigs)
+ inst_specs = length (filter is_inst_spec_sig instsigs)
+
+
+ count_binds EmptyBinds = (0,0,0,0,0)
+ count_binds (ThenBinds b1 b2) = count_binds b1 `add5` count_binds b2
+ count_binds (SingleBind b) = case count_bind b of
+ (vs,fs) -> (vs,fs,0,0,0)
+ count_binds (BindWith b sigs) = case (count_bind b, count_sigs sigs) of
+ ((vs,fs),(ts,_,ss,is)) -> (vs,fs,ts,ss,is)
+
+ count_bind EmptyBind = (0,0)
+ count_bind (NonRecBind b) = count_monobinds b
+ count_bind (RecBind b) = count_monobinds b
+
+ count_monobinds EmptyMonoBinds = (0,0)
+ count_monobinds (AndMonoBinds b1 b2) = count_monobinds b1 `add2` count_monobinds b2
+ count_monobinds (PatMonoBind (VarPatIn n) r _) = (1,0)
+ count_monobinds (PatMonoBind p r _) = (0,1)
+ count_monobinds (FunMonoBind f m _) = (0,1)
+
+ count_sigs sigs = foldr add4 (0,0,0,0) (map sig_info sigs)
+
+ sig_info (Sig _ _ _ _) = (1,0,0,0)
+ sig_info (ClassOpSig _ _ _ _) = (0,1,0,0)
+ sig_info (SpecSig _ _ _ _) = (0,0,1,0)
+ sig_info (InlineSig _ _ _) = (0,0,0,1)
+ sig_info _ = (0,0,0,0)
+
+ import_info (ImportAll _ _) = (1,0,0,0,0)
+ import_info (ImportSome _ ds _) = (0,1,length ds,0,0)
+ import_info (ImportButHide _ ds _) = (0,0,0,1,length ds)
+
+ data_info (TyData _ _ _ constrs derivs _ _)
+ = (length constrs, length derivs)
+
+ class_info (ClassDecl _ _ _ meth_sigs def_meths _ _)
+ = case count_sigs meth_sigs of
+ (_,classops,_,_) ->
+ (classops, addpr (count_monobinds def_meths))
+
+ inst_info (InstDecl _ _ _ inst_meths _ _ _ inst_sigs _ _)
+ = case count_sigs inst_sigs of
+ (_,_,ss,is) ->
+ (addpr (count_monobinds inst_meths), ss, is)
+
+ is_type_decl (TySynonym _ _ _ _ _) = True
+ is_type_decl _ = False
+ is_data_decl (TyData _ _ _ _ _ _ _) = True
+ is_data_decl _ = False
+ is_data_spec_sig (SpecDataSig _ _ _) = True
+ is_data_spec_sig _ = False
+ is_inst_spec_sig (InstSpecSig _ _ _) = True
+
+ addpr (x,y) = x+y
+ add1 x1 y1 = x1+y1
+ add2 (x1,x2) (y1,y2) = (x1+y1,x2+y2)
+ add3 (x1,x2,x3) (y1,y2,y3) = (x1+y1,x2+y2,x3+y3)
+ add4 (x1,x2,x3,x4) (y1,y2,y3,y4) = (x1+y1,x2+y2,x3+y3,x4+y4)
+ add5 (x1,x2,x3,x4,x5) (y1,y2,y3,y4,y5) = (x1+y1,x2+y2,x3+y3,x4+y4,x5+y5)
\end{code}
+
+
type TCE = UniqFM TyCon
data InstInfo
data UniqFM a
-mkInterface :: (GlobalSwitch -> Bool) -> _PackedString -> (_PackedString -> Bool, _PackedString -> Bool) -> UniqFM UnfoldingDetails -> FiniteMap TyCon [[Labda UniType]] -> ([FixityDecl Name], [Id], UniqFM Class, UniqFM TyCon, Bag InstInfo) -> [StgBinding Id Id] -> Int -> Bool -> PrettyRep
+mkInterface :: (GlobalSwitch -> Bool) -> _PackedString -> (_PackedString -> Bool, _PackedString -> Bool) -> UniqFM UnfoldingDetails -> FiniteMap TyCon [(Bool, [Labda UniType])] -> ([FixityDecl Name], [Id], UniqFM Class, UniqFM TyCon, Bag InstInfo) -> [StgBinding Id Id] -> Int -> Bool -> PrettyRep
-> (FAST_STRING -> Bool, -- is something in export list, explicitly?
FAST_STRING -> Bool) -- is a module among the "dotdot" exported modules?
-> IdEnv UnfoldingDetails
- -> FiniteMap TyCon [[Maybe UniType]]
+ -> FiniteMap TyCon [(Bool, [Maybe UniType])]
-> ([RenamedFixityDecl], -- interface info from the typecheck
[Id],
CE,
else
-- trace ("mkIface:Ids:"++(ppShow 80 (ppr PprDebug global_ids))) (
ppAboves
- [ppPStr SLIT("{-# GHC_PRAGMA INTERFACE VERSION 5 #-}"),
+ [ppPStr SLIT("{-# GHC_PRAGMA INTERFACE VERSION 6 #-}"),
ppCat [ppPStr SLIT("interface"), ppPStr modname, ppPStr SLIT("where")],
do_import_decls sw_chkr modname
%************************************************************************
\begin{code}
-do_tycon :: (GlobalSwitch -> Bool) -> FiniteMap TyCon [[Maybe UniType]] -> TyCon -> Pretty
+do_tycon :: (GlobalSwitch -> Bool) -> FiniteMap TyCon [(Bool, [Maybe UniType])] -> TyCon -> Pretty
do_tycon sw_chkr tycon_specs_map tycon
= pprTyCon (PprInterface sw_chkr) tycon tycon_specs
where
- tycon_specs = lookupWithDefaultFM tycon_specs_map [] tycon
+ tycon_specs = map snd (lookupWithDefaultFM tycon_specs_map [] tycon)
\end{code}
%************************************************************************
|| boringIdInfo id_info
then ppNil
else ppCat [ppPStr SLIT("\t{-# GHC_PRAGMA"),
- ppIdInfo sty better_val True{-specs, absolutely-}
+ ppIdInfo sty better_val True{-yes specs-}
better_id_fn inline_env id_info,
ppPStr SLIT("#-}")]
in
name_pragma_pairs
= pp_the_list [ ppCat [ppChar '\t', ppr_non_op op, ppEquals,
- ppIdInfo sty constm True{-YES, specs-}
+ ppChar '{' ,
+ ppIdInfo sty constm True{-YES, specs-}
better_id_fn inline_env
- (getIdInfo constm)]
+ (getIdInfo constm),
+ ppChar '}' ]
| (op, constm) <- class_op_strs `zip` better_constms ]
#ifdef DEBUG
if null better_constms
then ppCat [pragma_begin, pragma_end]
else ppAbove pragma_begin (ppCat [name_pragma_pairs, pragma_end])
- -- ToDo: specialised instances
)
\end{code}
import Outputable(NamedThing, Outputable)
import PlainCore(PlainCoreExpr(..))
import PrelFuns(gLASGOW_MISC, gLASGOW_ST, pRELUDE, pRELUDE_BUILTIN, pRELUDE_CORE, pRELUDE_IO, pRELUDE_LIST, pRELUDE_PRIMIO, pRELUDE_PS, pRELUDE_RATIO, pRELUDE_TEXT)
-import PrelVals(aBSENT_ERROR_ID, buildId, eRROR_ID, foldlId, foldrId, integerMinusOneId, integerPlusOneId, integerZeroId, mkBuild, mkFoldl, mkFoldr, pAT_ERROR_ID, packStringForCId, realWorldPrimId, unpackCString2Id, unpackCStringAppendId, unpackCStringId, voidPrimId)
+import PrelVals(aBSENT_ERROR_ID, buildId, eRROR_ID, foldlId, foldrId, integerMinusOneId, integerPlusOneId, integerPlusTwoId, integerZeroId, mkBuild, mkFoldl, mkFoldr, pAT_ERROR_ID, packStringForCId, realWorldPrimId, unpackCString2Id, unpackCStringAppendId, unpackCStringId, voidPrimId)
import PreludePS(_PackedString)
import Pretty(PprStyle, PrettyRep)
import PrimKind(PrimKind)
foldrId :: Id
integerMinusOneId :: Id
integerPlusOneId :: Id
+integerPlusTwoId :: Id
integerZeroId :: Id
mkBuild :: UniType -> TyVar -> Id -> Id -> Id -> CoreExpr Id Id -> CoreExpr Id Id
mkFoldl :: UniType -> UniType -> Id -> Id -> Id -> CoreExpr a Id
-- *odd* values that need to be reached out and grabbed:
eRROR_ID, pAT_ERROR_ID, aBSENT_ERROR_ID,
unpackCStringId, unpackCString2Id, packStringForCId, unpackCStringAppendId,
- integerZeroId, integerPlusOneId, integerMinusOneId,
+ integerZeroId, integerPlusOneId,
+ integerPlusTwoId, integerMinusOneId,
#ifdef DPH
-- ProcessorClass
doubleTyCon,
integerTyCon,
ratioTyCon,
+ liftTyCon,
return2GMPsTyCon, -- ADR asked for these last two (WDP 94/11)
returnIntAndGMPTyCon ]
data PrimOp
= CharGtOp | CharGeOp | CharEqOp | CharNeOp | CharLtOp | CharLeOp | IntGtOp | IntGeOp | IntEqOp | IntNeOp | IntLtOp | IntLeOp | WordGtOp | WordGeOp | WordEqOp | WordNeOp | WordLtOp | WordLeOp | AddrGtOp | AddrGeOp | AddrEqOp | AddrNeOp | AddrLtOp | AddrLeOp | FloatGtOp | FloatGeOp | FloatEqOp | FloatNeOp | FloatLtOp | FloatLeOp | DoubleGtOp | DoubleGeOp | DoubleEqOp | DoubleNeOp | DoubleLtOp | DoubleLeOp | OrdOp | ChrOp | IntAddOp | IntSubOp | IntMulOp | IntQuotOp | IntDivOp | IntRemOp | IntNegOp | IntAbsOp | AndOp | OrOp | NotOp | SllOp | SraOp | SrlOp | ISllOp | ISraOp | ISrlOp | Int2WordOp | Word2IntOp | Int2AddrOp | Addr2IntOp | FloatAddOp | FloatSubOp | FloatMulOp | FloatDivOp | FloatNegOp | Float2IntOp | Int2FloatOp | FloatExpOp | FloatLogOp | FloatSqrtOp | FloatSinOp | FloatCosOp | FloatTanOp | FloatAsinOp | FloatAcosOp | FloatAtanOp | FloatSinhOp | FloatCoshOp | FloatTanhOp | FloatPowerOp | DoubleAddOp | DoubleSubOp | DoubleMulOp | DoubleDivOp | DoubleNegOp | Double2IntOp | Int2DoubleOp | Double2FloatOp | Float2DoubleOp | DoubleExpOp | DoubleLogOp | DoubleSqrtOp | DoubleSinOp | DoubleCosOp | DoubleTanOp | DoubleAsinOp | DoubleAcosOp | DoubleAtanOp | DoubleSinhOp | DoubleCoshOp | DoubleTanhOp | DoublePowerOp | IntegerAddOp | IntegerSubOp | IntegerMulOp | IntegerQuotRemOp | IntegerDivModOp | IntegerNegOp | IntegerCmpOp | Integer2IntOp | Int2IntegerOp | Word2IntegerOp | Addr2IntegerOp | FloatEncodeOp | FloatDecodeOp | DoubleEncodeOp | DoubleDecodeOp | NewArrayOp | NewByteArrayOp PrimKind | SameMutableArrayOp | SameMutableByteArrayOp | ReadArrayOp | WriteArrayOp | IndexArrayOp | ReadByteArrayOp PrimKind | WriteByteArrayOp PrimKind | IndexByteArrayOp PrimKind | IndexOffAddrOp PrimKind | UnsafeFreezeArrayOp | UnsafeFreezeByteArrayOp | NewSynchVarOp | TakeMVarOp | PutMVarOp | ReadIVarOp | WriteIVarOp | MakeStablePtrOp | DeRefStablePtrOp | CCallOp _PackedString Bool Bool [UniType] UniType | ErrorIOPrimOp | ReallyUnsafePtrEqualityOp | SeqOp | ParOp | ForkOp | DelayOp | WaitOp
data UnfoldingDetails
-data UnfoldingGuidance = UnfoldNever | UnfoldAlways | EssentialUnfolding | UnfoldIfGoodArgs Int Int [Bool] Int
+data UnfoldingGuidance = UnfoldNever | UnfoldAlways | EssentialUnfolding | UnfoldIfGoodArgs Int Int [Bool] Int | BadUnfolding
data SrcLoc
type Arity = Int
data TyCon
pcDataTyCon :: Unique -> _PackedString -> _PackedString -> [TyVarTemplate] -> [Id] -> TyCon
pcGenerateDataSpecs :: UniType -> SpecEnv
pcGenerateSpecs :: Unique -> Id -> IdInfo -> UniType -> SpecEnv
+pcGenerateTupleSpecs :: Int -> UniType -> SpecEnv
pcMiscPrelId :: Unique -> _PackedString -> _PackedString -> UniType -> IdInfo -> Id
pcPrimTyCon :: Unique -> _PackedString -> Int -> ([PrimKind] -> PrimKind) -> TyCon
pcDataTyCon, pcPrimTyCon,
pcDataCon, pcMiscPrelId,
- pcGenerateSpecs, pcGenerateDataSpecs,
+ pcGenerateSpecs, pcGenerateDataSpecs, pcGenerateTupleSpecs,
-- mkBuild, mkListFilter,
The specialisations which exist for the builtin values must be recorded in
their IdInfos.
+NOTE: THE USES OF THE pcGenerate... FUNCTIONS MUST CORRESPOND
+ TO THE SPECIALISATIONS DECLARED IN THE PRELUDE !!!
+
HACK: We currently use the same unique for the specialised Ids.
The list @specing_types@ determines the types for which specialised
versions are created. Note: This should correspond with the
-@SpecingTypes@ in hscpp.prl.
+types passed to the pre-processor with the -genSPECS arg (see ghc.lprl).
-ToDo: Automatic generation of required specialised versions.
+ToDo: Create single mkworld definition which is grabbed here and in ghc.lprl
\begin{code}
pcGenerateSpecs :: Unique -> Id -> IdInfo -> UniType -> SpecEnv
where
err = panic "PrelFuns:GenerateDataSpecs"
+pcGenerateTupleSpecs :: Int -> UniType -> SpecEnv
+pcGenerateTupleSpecs arity ty
+ = if arity < 5 then
+ pcGenerateDataSpecs ty
+ else if arity == 5 then
+ let
+ tup5_spec jty = SpecInfo (take 5 (repeat jty))
+ 0 (panic "SpecData:SpecInfo:SpecId")
+ in
+ mkSpecEnv (map tup5_spec (tail specing_types))
+ else if arity == 19 then
+ mkSpecEnv [SpecInfo (Nothing : Just doublePrimTy : take 17 (repeat Nothing))
+ 0 (panic "SpecData:SpecInfo:SpecId")]
+ else
+ nullSpecEnv
pc_gen_specs is_id key id info ty
= mkSpecEnv spec_infos
where
- spec_infos = [ let spec_ty = specialiseTy ty ty_maybes 0
+ spec_infos = [ let spec_ty = specialiseTy ty spec_tys 0
spec_id = if is_id
then mkSpecId key {- HACK WARNING: same unique! -}
- id ty_maybes spec_ty info
+ id spec_tys spec_ty info
else panic "SpecData:SpecInfo:SpecId"
in
- SpecInfo ty_maybes (length ctxts) spec_id
- | ty_maybes <- tail (cross_product (length tyvars) specing_types) ]
-
- -- N.B. tail removes fully polymorphic specialisation
+ SpecInfo spec_tys (length ctxts) spec_id
+ | spec_tys <- specialisations ]
(tyvars, ctxts, _) = splitType ty
+ no_tyvars = length tyvars
- cross_product 0 tys = panic "PrelFuns:cross_product"
- cross_product 1 tys = map (:[]) tys
- cross_product n tys = concat [map (:cp) tys | cp <- cross_product (n-1) tys]
+ specialisations = if no_tyvars == 0
+ then []
+ else tail (cross_product no_tyvars specing_types)
+
+ -- N.B. tail removes fully polymorphic specialisation
+cross_product 0 tys = []
+cross_product 1 tys = map (:[]) tys
+cross_product n tys = concat [map (:cp) tys | cp <- cross_product (n-1) tys]
--- Note: The Just types should correspond to SpecingTypes in hscpp.prl
specing_types = [Nothing,
Just charPrimTy,
forkId :: Id
integerMinusOneId :: Id
integerPlusOneId :: Id
+integerPlusTwoId :: Id
integerZeroId :: Id
mkBuild :: UniType -> TyVar -> Id -> Id -> Id -> CoreExpr Id Id -> CoreExpr Id Id
mkFoldl :: UniType -> UniType -> Id -> Id -> Id -> CoreExpr a Id
\end{code}
OK, this is Will's idea: we should have magic values for Integers 0,
-+1, and -1 (go ahead, fire me):
++1, +2, and -1 (go ahead, fire me):
\begin{code}
integerZeroId
- = pcMiscPrelId integerZeroIdKey pRELUDE_CORE SLIT("_integer_0") integerTy noIdInfo
+ = pcMiscPrelId integerZeroIdKey pRELUDE_CORE SLIT("__integer0") integerTy noIdInfo
integerPlusOneId
- = pcMiscPrelId integerPlusOneIdKey pRELUDE_CORE SLIT("_integer_1") integerTy noIdInfo
+ = pcMiscPrelId integerPlusOneIdKey pRELUDE_CORE SLIT("__integer1") integerTy noIdInfo
+integerPlusTwoId
+ = pcMiscPrelId integerPlusTwoIdKey pRELUDE_CORE SLIT("__integer2") integerTy noIdInfo
integerMinusOneId
- = pcMiscPrelId integerMinusOneIdKey pRELUDE_CORE SLIT("_integer_m1") integerTy noIdInfo
+ = pcMiscPrelId integerMinusOneIdKey pRELUDE_CORE SLIT("__integerm1") integerTy noIdInfo
\end{code}
%************************************************************************
\begin{code}
buildId
= pcMiscPrelId buildIdKey pRELUDE_CORE SLIT("_build") buildTy
- (((noIdInfo
+ ((((noIdInfo
`addInfo_UF` mkMagicUnfolding SLIT("build"))
`addInfo` mkStrictnessInfo [WwStrict] Nothing)
`addInfo` mkArgUsageInfo [ArgUsage 2])
+ `addInfo` pcGenerateSpecs buildIdKey buildId noIdInfo{-ToDo-} buildTy)
-- cheating, but since _build never actually exists ...
where
-- The type of this strange object is:
`UniFun` ((mkListTy alpha)
`UniFun` beta)))
- idInfo = ((((noIdInfo
+ idInfo = (((((noIdInfo
`addInfo_UF` mkMagicUnfolding SLIT("foldr"))
`addInfo` mkStrictnessInfo [WwLazy False,WwLazy False,WwStrict] Nothing)
`addInfo` mkArityInfo 3)
`addInfo` mkUpdateInfo [2,2,1])
+ `addInfo` pcGenerateSpecs foldrIdKey foldrId noIdInfo{-ToDo-} foldrTy)
mkFoldr a b f z xs = foldl CoApp
(mkCoTyApps (CoVar foldrId) [a, b])
`UniFun` ((mkListTy beta)
`UniFun` alpha)))
- idInfo = ((((noIdInfo
+ idInfo = (((((noIdInfo
`addInfo_UF` mkMagicUnfolding SLIT("foldl"))
`addInfo` mkStrictnessInfo [WwLazy False,WwLazy False,WwStrict] Nothing)
`addInfo` mkArityInfo 3)
`addInfo` mkUpdateInfo [2,2,1])
+ `addInfo` pcGenerateSpecs foldlIdKey foldlId noIdInfo{-ToDo-} foldlTy)
mkFoldl a b f z xs = foldl CoApp
(mkCoTyApps (CoVar foldlId) [a, b])
cvt_pragmas RdrNoPragma = NoClassOpPragmas
cvt_pragmas (RdrClassOpPragmas ps) = ps
-cvInstDeclSig (RdrInlineValSig sig) = [ sig ]
-cvInstDeclSig (RdrDeforestSig sig) = [ sig ]
-cvInstDeclSig (RdrMagicUnfoldingSig sig) = [ sig ]
+cvInstDeclSig (RdrSpecValSig sigs) = sigs
+cvInstDeclSig (RdrInlineValSig sig) = [ sig ]
+cvInstDeclSig (RdrDeforestSig sig) = [ sig ]
+cvInstDeclSig (RdrMagicUnfoldingSig sig) = [ sig ]
\end{code}
%************************************************************************
}
where
sep_stuff s@(RdrTySig _ _ _ _) (sigs,defs) = (s:sigs,defs)
+ sep_stuff s@(RdrSpecValSig _) (sigs,defs) = (s:sigs,defs)
sep_stuff s@(RdrInlineValSig _) (sigs,defs) = (s:sigs,defs)
sep_stuff s@(RdrDeforestSig _) (sigs,defs) = (s:sigs,defs)
sep_stuff s@(RdrMagicUnfoldingSig _) (sigs,defs) = (s:sigs,defs)
RETN (Just modname, ConstantInstancePragma gen_pragma constm_pragmas, xs3)
BEND BEND BEND
-rdInstPragma ('P' : 'i' : 'S' : xs)
- = BIND (rdIdString xs) _TO_ (modname, xs1) ->
- BIND (rdGenPragma xs1) _TO_ (gen_pragma, xs2) ->
- BIND (rdList rd_spec xs2) _TO_ (spec_pragmas, xs3) ->
- RETN (Just modname, SpecialisedInstancePragma gen_pragma spec_pragmas, xs3)
- BEND BEND BEND
- where
- rd_spec ('P' : '3' : xs)
- = BIND (rdList rdMonoTypeMaybe xs) _TO_ (mono_tys_maybe, xs1) ->
- BIND (rdIdString xs1) _TO_ (num_dicts, xs2) ->
- BIND (rdGenPragma xs2) _TO_ (gen_prag, xs3) ->
- BIND (rdList rd_constm xs3) _TO_ (constms, xs4) ->
- let
- inst_prag
- = if null constms then
- if null_gen_prag gen_prag
- then NoInstancePragmas
- else SimpleInstancePragma gen_prag
- else -- some constms...
- ConstantInstancePragma gen_prag constms
- in
- RETN ((mono_tys_maybe, ((read (_UNPK_ num_dicts)) :: Int), inst_prag), xs4)
- BEND BEND BEND BEND
- where
- null_gen_prag NoGenPragmas = True
- null_gen_prag _ = False
-
rd_constm ('P' : '1' : xs)
= BIND (rdId xs) _TO_ (name, xs1) ->
BIND (rdGenPragma xs1) _TO_ (prag, xs2) ->
wlkList rd_constm constm_stuff `thenUgn` \ constm_pragmas ->
returnUgn (Just modname, ConstantInstancePragma gen_pragma constm_pragmas)
- U_iinst_spec_pragma modname dfun_gen spec_stuff ->
- wlkGenPragma dfun_gen `thenUgn` \ gen_pragma ->
- wlkList rd_spec spec_stuff `thenUgn` \ spec_pragmas ->
- returnUgn (Just modname, SpecialisedInstancePragma gen_pragma spec_pragmas)
- where
- rd_spec pt
- = rdU_hpragma pt `thenUgn` \ stuff ->
- case stuff of { U_iinst_pragma_3s maybe_tys num_dicts gen consts ->
-
- wlkList rdMonoTypeMaybe maybe_tys `thenUgn` \ mono_tys_maybe ->
- wlkGenPragma gen `thenUgn` \ gen_prag ->
- wlkList rd_constm consts `thenUgn` \ constms ->
- let
- inst_prag
- = if null constms then
- if null_gen_prag gen_prag
- then NoInstancePragmas
- else SimpleInstancePragma gen_prag
- else -- some constms...
- ConstantInstancePragma gen_prag constms
- in
- returnUgn (mono_tys_maybe, num_dicts, inst_prag) }
- where
- null_gen_prag NoGenPragmas = True
- null_gen_prag _ = False
-
rd_constm pt
= rdU_hpragma pt `thenUgn` \ stuff ->
case stuff of { U_iname_pragma_pr name gen ->
import Errors ( dupNamesErr, Error(..) )
import HsCore -- ****** NEED TO SEE CONSTRUCTORS ******
import HsPragmas -- ****** NEED TO SEE CONSTRUCTORS ******
-import HsTypes ( pprParendMonoType )
+import HsTypes ( cmpMonoType, pprParendMonoType )
import IdInfo ( DeforestInfo(..) )
import Maybes ( Maybe(..) )
import ProtoName
-- ToDo: Should we use selByBetterName ???
-- ToDo: Report errors properly and recover quietly ???
+ -- ToDo: Should we merge specialisations ???
+
eq_data_specs [] [] = True
eq_data_specs (spec1:specs1) (spec2:specs2)
= eq_spec spec1 spec2 && eq_data_specs specs1 specs2
eq_data_specs _ _ = False
+ eq_spec spec1 spec2 = case cmp_spec spec1 spec2 of { EQ_ -> True; _ -> False}
+
ppr_data_specs specs
= ppBesides [ppStr "_SPECIALISE_ ", pp_the_list [
ppCat [ppLbrack, ppInterleave ppComma (map pp_maybe ty_maybes), ppRbrack]
returnRn12 ( (name1, new_prags) : rest )
\end{code}
+For specialisations we merge the lists from each Sig. This allows the user to
+declare specialised prelude functions in their own PreludeSpec module.
+
\begin{code}
selSpecialisations
:: [([Maybe ProtoNameMonoType], Int, ProtoNameGenPragmas)] -> SrcLoc
selSpecialisations [] _ bs _ = returnRn12 bs -- arguable ... ToDo?
selSpecialisations as _ [] _ = returnRn12 as -- ditto
-selSpecialisations ((spec1, dicts1, prags1) : specs1) loc1
- ((spec2, dicts2, prags2) : specs2) loc2
+selSpecialisations all_specs1@((spec1, dicts1, prags1) : rest_specs1) loc1
+ all_specs2@((spec2, dicts2, prags2) : rest_specs2) loc2
- = if not (eq_spec spec1 spec2) || dicts1 /= dicts2 then
- -- msg of any kind??? ToDo
- pRAGMA_ERROR "specialisation pragmas" specs1
- else
- recoverQuietlyRn12 NoGenPragmas (
- selGenPragmas prags1 loc1 prags2 loc2
- ) `thenRn12` \ new_prags ->
- selSpecialisations specs1 loc1 specs2 loc2
+ = case (cmp_spec spec1 spec2) of
+ LT_ -> selSpecialisations rest_specs1 loc1 all_specs2 loc2
`thenRn12` \ rest ->
- returnRn12 ( (spec1, dicts1, new_prags) : rest )
+ returnRn12 ( (spec1, dicts1, prags1) : rest )
-eq_spec [] [] = True
-eq_spec (Nothing:xs) (Nothing:ys) = eq_spec xs ys
-eq_spec (Just t1:xs) (Just t2:ys) = eqMonoType t1 t2 && eq_spec xs ys
-eq_spec _ _ = False
+ EQ_ -> ASSERT(dicts1 == dicts2)
+ recoverQuietlyRn12 NoGenPragmas (
+ selGenPragmas prags1 loc1 prags2 loc2
+ ) `thenRn12` \ new_prags ->
+ selSpecialisations rest_specs1 loc1 rest_specs2 loc2
+ `thenRn12` \ rest ->
+ returnRn12 ( (spec1, dicts1, new_prags) : rest )
+
+ GT_ -> selSpecialisations all_specs1 loc1 rest_specs2 loc2
+ `thenRn12` \ rest ->
+ returnRn12 ( (spec2, dicts2, prags2) : rest )
+
+cmp_spec [] [] = EQ_
+cmp_spec (Nothing:xs) (Nothing:ys) = cmp_spec xs ys
+cmp_spec (Just t1:xs) (Just t2:ys) = case cmpMonoType cmpProtoName t1 t2 of
+ EQ_ -> cmp_spec xs ys
+ xxx -> xxx
+cmp_spec (Nothing:xs) (Just t2:ys) = LT_
+cmp_spec (Just t1:xs) (Nothing:ys) = GT_
\end{code}
%************************************************************************
import Errors
import HsCore -- ****** NEED TO SEE CONSTRUCTORS ******
import HsPragmas -- ****** NEED TO SEE CONSTRUCTORS ******
-import Maybes ( catMaybes, Maybe(..) )
+import Maybes ( catMaybes, maybeToBool, Maybe(..) )
import ProtoName ( eqProtoName, elemProtoNames )
import RenameBinds4 ( rnTopBinds4, rnMethodBinds4 )
import RenameMonad4
rnMonoType4 False{-no invisibles-} tv_env ty
`thenRn4` \ ty' ->
rnMethodBinds4 cname' mbinds `thenRn4` \ mbinds' ->
- mapRn4 rn_uprag uprags `thenRn4` \ new_uprags ->
+ mapRn4 (rn_uprag cname') uprags `thenRn4` \ new_uprags ->
recoverQuietlyRn4 NoInstancePragmas (
rnInstancePragmas4 cname' tv_env pragmas
) `thenRn4` \ new_pragmas ->
from_here modname imod new_uprags new_pragmas src_loc)
)
where
- rn_uprag (InlineSig var guide locn)
- = pushSrcLocRn4 locn (
- lookupValue var `thenRn4` \ new_var ->
- returnRn4 (InlineSig new_var guide locn)
+ rn_uprag class_name (SpecSig op ty using locn)
+ = ASSERT(not (maybeToBool using)) -- ToDo: SPEC method with explicit spec_id
+ pushSrcLocRn4 src_loc (
+ lookupClassOp class_name op `thenRn4` \ op_name ->
+ rnPolyType4 False True nullTyVarNamesEnv ty `thenRn4` \ new_ty ->
+ returnRn4 (SpecSig op_name new_ty Nothing locn)
)
- rn_uprag (DeforestSig var locn)
- = pushSrcLocRn4 locn (
- lookupValue var `thenRn4` \ new_var ->
- returnRn4 (DeforestSig new_var locn)
+ rn_uprag class_name (InlineSig op guide locn)
+ = pushSrcLocRn4 locn (
+ lookupClassOp class_name op `thenRn4` \ op_name ->
+ returnRn4 (InlineSig op_name guide locn)
)
- rn_uprag (MagicUnfoldingSig var str locn)
- = pushSrcLocRn4 locn (
- lookupValue var `thenRn4` \ new_var ->
- returnRn4 (MagicUnfoldingSig new_var str locn)
+ rn_uprag class_name (DeforestSig op locn)
+ = pushSrcLocRn4 locn (
+ lookupClassOp class_name op `thenRn4` \ op_name ->
+ returnRn4 (DeforestSig op_name locn)
+ )
+ rn_uprag class_name (MagicUnfoldingSig op str locn)
+ = pushSrcLocRn4 locn (
+ lookupClassOp class_name op `thenRn4` \ op_name ->
+ returnRn4 (MagicUnfoldingSig op_name str locn)
)
\end{code}
isInterestingArg env _ = False
foldl_fun env (TypeArg ty1:TypeArg ty2:ValArg arg_k:ValArg arg_z:ValArg arg_list:rest_args)
- | do_fb_red && isNilForm env arg_list
+ | do_fb_red && isNilForm env arg_list
= -- foldl f z [] = z
-- again another short cut, helps with unroling of constant lists
tick Foldr_Nil `thenSmpl_`
import BinderInfo
import CmdLineOpts ( GlobalSwitch(..), SimplifierSwitch(..) )
import Digraph ( stronglyConnComp )
-import Id ( eqId, idWantsToBeINLINEd, isConstMethodId,
+import Id ( eqId, idWantsToBeINLINEd, isConstMethodId_maybe,
isSpecPragmaId_maybe, getIdArgUsageInfo,
SpecInfo
)
keepBecauseConjurable (OccEnv _ _ keep_conjurable _ _) binder
= keep_conjurable && is_conjurable
where
- is_conjurable = isConstMethodId binder
+ is_conjurable = maybeToBool (isConstMethodId_maybe binder)
type UsageDetails = IdEnv BinderInfo -- A finite map from ids to their usage
import BinderInfo
import CmdLineOpts ( GlobalSwitch(..), SimplifierSwitch(..) )
import Digraph ( stronglyConnComp )
-import Id ( eqId, idWantsToBeINLINEd, isConstMethodId,
+import Id ( eqId, idWantsToBeINLINEd, isConstMethodId_maybe,
isSpecPragmaId_maybe, SpecInfo )
import IdEnv
import Maybes
keepBecauseConjurable (OccEnv _ _ keep_conjurable _ _) binder
= keep_conjurable && is_conjurable
where
- is_conjurable = isConstMethodId binder
+ is_conjurable = maybeToBool (isConstMethodId_maybe binder)
type UsageDetails = IdEnv BinderInfo -- A finite map from ids to their usage
data Bag a
type IdEnv a = UniqFM a
data UnfoldingDetails
-data SpecialiseData = SpecData Bool Bool [TyCon] [TyCon] (FiniteMap TyCon [[Labda UniType]]) (Bag (Id, [Labda UniType])) (Bag (Id, [Labda UniType])) (Bag (TyCon, [Labda UniType]))
+data SpecialiseData = SpecData Bool Bool [TyCon] [TyCon] (FiniteMap TyCon [(Bool, [Labda UniType])]) (Bag (Id, [Labda UniType])) (Bag (Id, [Labda UniType])) (Bag (TyCon, [Labda UniType]))
data UniqFM a
data Unique
-core2core :: [CoreToDo] -> (GlobalSwitch -> SwitchResult) -> _PackedString -> PprStyle -> SplitUniqSupply -> [TyCon] -> FiniteMap TyCon [[Labda UniType]] -> [CoreBinding Id Id] -> _State _RealWorld -> (([CoreBinding Id Id], UniqFM UnfoldingDetails, SpecialiseData), _State _RealWorld)
+core2core :: [CoreToDo] -> (GlobalSwitch -> SwitchResult) -> _PackedString -> PprStyle -> SplitUniqSupply -> [TyCon] -> FiniteMap TyCon [(Bool, [Labda UniType])] -> [CoreBinding Id Id] -> _State _RealWorld -> (([CoreBinding Id Id], UniqFM UnfoldingDetails, SpecialiseData), _State _RealWorld)
-> PprStyle -- printing style (for debugging only)
-> SplitUniqSupply -- a name supply
-> [TyCon] -- local data tycons and tycon specialisations
- -> FiniteMap TyCon [[Maybe UniType]]
+ -> FiniteMap TyCon [(Bool, [Maybe UniType])]
-> [PlainCoreBinding] -- input...
-> MainIO
([PlainCoreBinding], -- results: program, plus...
`thenMn` \ (processed_binds, _, inline_env, spec_data, simpl_stats) ->
(if switch_is_on D_simplifier_stats
- then trace ("Simplifier Stats:\n" ++ showSimplCount simpl_stats) (returnMn ())
+ then writeMn stderr ("\nSimplifier Stats:\n")
+ `thenMn_`
+ writeMn stderr (showSimplCount simpl_stats)
+ `thenMn_`
+ writeMn stderr "\n"
else returnMn ()
- ) `thenMn_`
-
-{- LATER:
- (if do_dump_core_passes
- then trace (unlines (
- (nOfThem 78 '-'
- : "Core2Core"
- : "+------------------------------+"
- : reverse [ " " ++ take (30::Int) (what ++ repeat ' ') ++ "|"
- | what <- simpl_whats ])
- ++ ["+------------------------------+"]))
- else \x -> x) -- to the end
--}
+ ) `thenMn_`
+
returnMn (processed_binds, inline_env, spec_data)
ESCC
where
switch_is_on = switchIsOn sw_chkr
- do_dump_core_passes = switch_is_on D_dump_core_passes -- an Andy flag
do_verbose_core2core = switch_is_on D_verbose_core2core
- lib_case_threshold -- ToDo: HACK HACK HACK : FIX ME FIX ME FIX ME
+ lib_case_threshold -- ToDo: HACK HACK HACK : FIX ME FIX ME FIX ME
-- Use 4x a known threshold
= case (intSwitchSet sw_chkr UnfoldingOverrideThreshold) of
Nothing -> 4 * uNFOLDING_USE_THRESHOLD
case to_do of
CoreDoSimplify simpl_sw_chkr
-> BSCC("CoreSimplify")
+ begin_pass ("Simplify" ++ if switchIsOn simpl_sw_chkr SimplDoFoldrBuild
+ then " (foldr/build)" else "") `thenMn_`
case (simplifyPgm binds sw_chkr simpl_sw_chkr simpl_stats us1) of
(p, it_cnt, simpl_stats2)
- -> end_pass us2 p inline_env spec_data simpl_stats2 ("Simplify (" ++ show it_cnt ++ ")")
+ -> end_pass False us2 p inline_env spec_data simpl_stats2
+ ("Simplify (" ++ show it_cnt ++ ")"
+ ++ if switchIsOn simpl_sw_chkr SimplDoFoldrBuild
+ then " foldr/build" else "")
ESCC
CoreDoFoldrBuildWorkerWrapper
-> error "ERROR: CoreDoFoldrBuildWorkerWrapper: not built into compiler\n"
#else
-> BSCC("CoreDoFoldrBuildWorkerWrapper")
- end_pass us2 (mkFoldrBuildWW switch_is_on us1 binds) inline_env spec_data simpl_stats "FBWW"
- ESCC
+ begin_pass "FBWW" `thenMn_`
+ case (mkFoldrBuildWW switch_is_on us1 binds) of { binds2 ->
+ end_pass False us2 binds2 inline_env spec_data simpl_stats "FBWW"
+ } ESCC
#endif
CoreDoFoldrBuildWWAnal
-> error "ERROR: CoreDoFoldrBuildWWAnal: not built into compiler\n"
#else
-> BSCC("CoreDoFoldrBuildWWAnal")
- end_pass us2 (analFBWW switch_is_on binds) inline_env spec_data simpl_stats "AnalFBWW"
- ESCC
+ begin_pass "AnalFBWW" `thenMn_`
+ case (analFBWW switch_is_on binds) of { binds2 ->
+ end_pass False us2 binds2 inline_env spec_data simpl_stats "AnalFBWW"
+ } ESCC
#endif
CoreLiberateCase
-> BSCC("LiberateCase")
+ begin_pass "LiberateCase" `thenMn_`
case (liberateCase lib_case_threshold binds) of { binds2 ->
- end_pass us2 binds2 inline_env spec_data simpl_stats "LiberateCase"
- }
- ESCC
+ end_pass False us2 binds2 inline_env spec_data simpl_stats "LiberateCase"
+ } ESCC
CoreDoCalcInlinings1 -- avoid inlinings w/ cost-centres
-> BSCC("CoreInlinings1")
+ begin_pass "CalcInlinings" `thenMn_`
case (calcInlinings False sw_chkr inline_env binds) of { inline_env2 ->
- end_pass us2 binds inline_env2 spec_data simpl_stats "Calc Inlinings"
+ end_pass False us2 binds inline_env2 spec_data simpl_stats "CalcInlinings"
} ESCC
CoreDoCalcInlinings2 -- allow inlinings w/ cost-centres
-> BSCC("CoreInlinings2")
+ begin_pass "CalcInlinings" `thenMn_`
case (calcInlinings True sw_chkr inline_env binds) of { inline_env2 ->
- end_pass us2 binds inline_env2 spec_data simpl_stats "Calc Inlinings"
+ end_pass False us2 binds inline_env2 spec_data simpl_stats "CalcInlinings"
} ESCC
CoreDoFloatInwards
-> BSCC("FloatInwards")
- end_pass us2 (floatInwards binds) inline_env spec_data simpl_stats "FloatIn"
- ESCC
+ begin_pass "FloatIn" `thenMn_`
+ case (floatInwards binds) of { binds2 ->
+ end_pass False us2 binds2 inline_env spec_data simpl_stats "FloatIn"
+ } ESCC
CoreDoFullLaziness
-> BSCC("CoreFloating")
- case (floatOutwards switch_is_on us1 binds) of { p ->
- end_pass us2 p inline_env spec_data simpl_stats "FloatOut"
+ begin_pass "FloatOut" `thenMn_`
+ case (floatOutwards switch_is_on us1 binds) of { binds2 ->
+ end_pass False us2 binds2 inline_env spec_data simpl_stats "FloatOut"
} ESCC
- CoreDoPrintCore ->
- let
- printed = ppShow 80 (ppr ppr_style binds)
- strict [] a = a
- strict (s:ss) a | ord s == 0 = error "0 in output string"
- | otherwise = strict ss a
- in
- end_pass us2 (strict printed (trace ("PrintCore:\n" ++ printed) binds)) inline_env spec_data simpl_stats "Print"
-
-{- ANDY:
- CoreDoHaskPrint ->
- let
- printed = coreToHaskell binds
- strict [] a = a
- strict (s:ss) a | ord s == 0 = error "0 in output string"
- | otherwise = strict ss a
- in
- strict printed (trace ("PrintCore:\n" ++ printed) binds), inline_env, spec_data, simpl_stats, "PrintHask"
--}
-
CoreDoStaticArgs
-> BSCC("CoreStaticArgs")
- end_pass us2 (doStaticArgs binds us1) inline_env spec_data simpl_stats "SAT"
+ begin_pass "StaticArgs" `thenMn_`
+ case (doStaticArgs binds us1) of { binds2 ->
+ end_pass False us2 binds2 inline_env spec_data simpl_stats "StaticArgs"
-- Binds really should be dependency-analysed for static-
-- arg transformation... Not to worry, they probably are.
-- (I don't think it *dies* if they aren't [WDP 94/04/15])
- ESCC
+ } ESCC
CoreDoStrictness
-> BSCC("CoreStranal")
- end_pass us2 (saWwTopBinds us1 switch_is_on binds) inline_env spec_data simpl_stats "StrAnal"
- ESCC
+ begin_pass "StrAnal" `thenMn_`
+ case (saWwTopBinds us1 switch_is_on binds) of { binds2 ->
+ end_pass False us2 binds2 inline_env spec_data simpl_stats "StrAnal"
+ } ESCC
CoreDoSpecialising
-> BSCC("Specialise")
+ begin_pass "Specialise" `thenMn_`
case (specProgram switch_is_on us1 binds spec_data) of {
(p, spec_data2@(SpecData _ spec_noerrs _ _ _
spec_errs spec_warn spec_tyerrs)) ->
(if not spec_noerrs ||
(switch_is_on ShowImportSpecs && not (isEmptyBag spec_warn)) then
writeMn stderr (ppShow 1000 {-pprCols-}
- (pprSpecErrs PprForUser spec_errs spec_warn spec_tyerrs))
+ (pprSpecErrs module_name spec_errs spec_warn spec_tyerrs))
`thenMn_` writeMn stderr "\n"
else
returnMn ()) `thenMn_`
else
returnMn ()) `thenMn_`
- end_pass us2 p inline_env spec_data2 simpl_stats "Specialise"
+ end_pass False us2 p inline_env spec_data2 simpl_stats "Specialise"
}
ESCC
-> error "ERROR: CoreDoDeforest: not built into compiler\n"
#else
-> BSCC("Deforestation")
- case (deforestProgram sw_chkr binds us1) of { binds ->
- end_pass us2 binds inline_env spec_data simpl_stats "Deforestation"
+ begin_pass "Deforestation" `thenMn_`
+ case (deforestProgram sw_chkr binds us1) of { binds2 ->
+ end_pass False us2 binds2 inline_env spec_data simpl_stats "Deforestation"
}
ESCC
#endif
CoreDoAutoCostCentres
-> BSCC("AutoSCCs")
- end_pass us2 (addAutoCostCentres sw_chkr module_name binds) inline_env spec_data simpl_stats "AutoSCCs"
+ begin_pass "AutoSCCs" `thenMn_`
+ case (addAutoCostCentres sw_chkr module_name binds) of { binds2 ->
+ end_pass False us2 binds2 inline_env spec_data simpl_stats "AutoSCCs"
+ }
ESCC
+ CoreDoPrintCore -- print result of last pass
+ -> end_pass True us2 binds inline_env spec_data simpl_stats "Print"
+
+
-------------------------------------------------
- end_pass us2 binds2 inline_env2
+ begin_pass
+ = if switch_is_on D_show_passes
+ then \ what -> writeMn stderr ("*** Core2Core: "++what++"\n")
+ else \ what -> returnMn ()
+
+ end_pass print us2 binds2 inline_env2
spec_data2@(SpecData spec_done _ _ _ _ _ _ _)
simpl_stats2 what
= -- report verbosely, if required
- (if do_verbose_core2core then
+ (if (do_verbose_core2core && not print) ||
+ (print && not do_verbose_core2core)
+ then
writeMn stderr ("\n*** "++what++":\n")
`thenMn_`
writeMn stderr (ppShow 1000
| rhs_mentions_an_unmentionable
|| (not explicit_INLINE_requested
- && (guidance_says_don't || guidance_size_just_too_big))
+ && (rhs_looks_like_a_caf || guidance_says_don't || guidance_size_too_big))
= let
my_my_trace
= if explicit_INLINE_requested
&& not (isWrapperId binder) -- these always claim to be INLINEd
&& not have_inlining_already
- then trace -- we'd better have a look...
+ then trace -- we'd better have a look...
else my_trace
which = if scc_s_OK then " (late):" else " (early):"
in
- --pprTrace "giving up on size:" (ppCat [ppr PprDebug binder, ppr PprDebug [rhs_mentions_an_unmentionable, explicit_INLINE_requested, guidance_says_don't, guidance_size_just_too_big]]) (
+ --pprTrace "giving up on size:" (ppCat [ppr PprDebug binder, ppr PprDebug
+ -- [rhs_mentions_an_unmentionable, explicit_INLINE_requested,
+ -- rhs_looks_like_a_caf, guidance_says_don't, guidance_size_too_big]]) (
my_my_trace ("unfolding disallowed for"++which++(ppShow 80 (ppr PprDebug binder))) (
ignominious_defeat
)
= glorious_success UnfoldAlways
#endif
- | is_recursive && not rhs_looks_like_a_data_val_to_me
+ | is_recursive && not rhs_looks_like_a_data_val
-- The only recursive defns we are prepared to tolerate at the
-- moment is top-level very-obviously-a-data-value ones.
-- We *need* these for dictionaries to be exported!
then 100000 -- you asked for it, you got it
else unfolding_creation_threshold
- guidance_says_don't = case guidance of { UnfoldNever -> True; _ -> False }
-
guidance_size
= case guidance of
UnfoldAlways -> 0 -- *extremely* small
EssentialUnfolding -> 0 -- ditto
UnfoldIfGoodArgs _ _ _ size -> size
- guidance_size_just_too_big
+ guidance_says_don't = case guidance of { UnfoldNever -> True; _ -> False }
+
+ guidance_size_too_big
-- Does the guidance suggest that this unfolding will
-- be of no use *no matter* the arguments given to it?
-- Could be more sophisticated...
= case guidance of
- UnfoldNever -> False -- debugging only (ToDo:rm)
UnfoldAlways -> False
EssentialUnfolding -> False
UnfoldIfGoodArgs _ no_val_args arg_info_vec size
-> if explicit_creation_threshold then
- False -- user set threshold; don't second-guess...
+ False -- user set threshold; don't second-guess...
- else if no_val_args == 0 && rhs_looks_like_a_data_val_to_me then
- False -- probably a data value; we'd like the
- -- other guy to see the value, even if
- -- s/he doesn't unfold it.
+ else if no_val_args == 0 && rhs_looks_like_a_data_val then
+ False -- we'd like a top-level data constr to be
+ -- visible even if it is never unfolded
else
let
cost
-- )
- rhs_arg_tys
- = let
- (_, val_binders, _) = digForLambdas rhs
- in
- map getIdUniType val_binders
+ rhs_looks_like_a_caf = not (manifestlyWHNF rhs)
- rhs_looks_like_a_data_val_to_me
- = let
- (_,val_binders,body) = digForLambdas rhs
- in
- case (val_binders, body) of
- ([], CoCon _ _ _) -> True
- other -> False
+ rhs_looks_like_a_data_val
+ = case digForLambdas rhs of
+ (_, [], CoCon _ _ _) -> True
+ other -> False
+
+ rhs_arg_tys
+ = case digForLambdas rhs of
+ (_, val_binders, _) -> map getIdUniType val_binders
(mentioned_ids, _, _, mentions_litlit)
= mentionedInUnfolding (\x -> x) rhs
data UnfoldEnv
data UnfoldItem
data UnfoldingDetails = NoUnfoldingDetails | LiteralForm BasicLit | OtherLiteralForm [BasicLit] | ConstructorForm Id [UniType] [CoreAtom Id] | OtherConstructorForm [Id] | GeneralForm Bool FormSummary (CoreExpr (Id, BinderInfo) Id) UnfoldingGuidance | MagicForm _PackedString MagicUnfoldingFun | IWantToBeINLINEd UnfoldingGuidance
-data UnfoldingGuidance = UnfoldNever | UnfoldAlways | EssentialUnfolding | UnfoldIfGoodArgs Int Int [Bool] Int
+data UnfoldingGuidance = UnfoldNever | UnfoldAlways | EssentialUnfolding | UnfoldIfGoodArgs Int Int [Bool] Int | BadUnfolding
data UniType
data UniqFM a
data Unique
-- be possible).
Int -- The "size" of the unfolding; to be elaborated
-- later. ToDo
+
+ | BadUnfolding -- This is used by TcPragmas if the *lazy*
+ -- lintUnfolding test fails
+ -- It will never escape from the IdInfo as
+ -- it is caught by getInfo_UF and converted
+ -- to NoUnfoldingDetails
\end{code}
\begin{code}
False)
in
if stop_now then
- (if global_switch_is_on D_verbose_core2core
- then show_status
- else id)
- (returnSmpl (new_pgm, iterations, dr))
+ returnSmpl (new_pgm, iterations, dr)
else
simpl_pgm r (iterations + 1) new_pgm
)
dont_go_for_it
else if n_vals_wanted == 0
- && looks_like_a_data_val_to_me then
+ && rhs_looks_like_a_CoCon then
-- we are very keen on inlining data values
-- (see comments elsewhere); we ignore any size issues!
go_for_it
no_tyargs = length tyargs
no_valargs = length valargs
- looks_like_a_data_val_to_me
+ rhs_looks_like_a_CoCon
= let
(_,val_binders,body) = digForLambdas template
in
\begin{code}
simplExpr env (CoTyLam tyvar body) (TypeArg ty : args)
- = ASSERT(not (isPrimType ty))
+ = -- ASSERT(not (isPrimType ty))
let
new_env = extendTyEnv env tyvar ty
in
import Class(Class)
import Id(Id)
import Maybes(Labda(..))
-import Pretty(PprStyle, Pretty(..), PrettyRep)
+import PreludePS(_PackedString)
+import Pretty(Pretty(..), PrettyRep)
import TyCon(TyCon)
import TyVar(TyVarTemplate)
import UniType(UniType)
type Pretty = Int -> Bool -> PrettyRep
data UniType
argTysMatchSpecTys_error :: [Labda UniType] -> [UniType] -> Labda (Int -> Bool -> PrettyRep)
+getIdOverloading :: Id -> ([TyVarTemplate], [(Class, TyVarTemplate)])
isUnboxedSpecialisation :: [Labda UniType] -> Bool
-mkConstraintVector :: [TyVarTemplate] -> [(Class, TyVarTemplate)] -> [Bool]
+mkConstraintVector :: Id -> [Bool]
mkSpecialisedCon :: Id -> [UniType] -> Id
-pprSpecErrs :: PprStyle -> Bag (Id, [Labda UniType]) -> Bag (Id, [Labda UniType]) -> Bag (TyCon, [Labda UniType]) -> Int -> Bool -> PrettyRep
+pprSpecErrs :: _PackedString -> Bag (Id, [Labda UniType]) -> Bag (Id, [Labda UniType]) -> Bag (TyCon, [Labda UniType]) -> Int -> Bool -> PrettyRep
specialiseCallTys :: Bool -> Bool -> Bool -> [Bool] -> [UniType] -> [Labda UniType]
specialiseConstrTys :: [UniType] -> [Labda UniType]
module SpecTyFuns (
specialiseCallTys,
ConstraintVector(..),
+ getIdOverloading,
mkConstraintVector,
isUnboxedSpecialisation,
import AbsUniType
import Bag ( Bag, isEmptyBag, bagToList )
import FiniteMap ( FiniteMap, emptyFM, addListToFM_C,
- keysFM, lookupWithDefaultFM
+ plusFM_C, keysFM, lookupWithDefaultFM
)
import Id ( mkSameSpecCon, getIdUniType,
- isDictFunId, isConstMethodId, Id )
+ isDictFunId, isConstMethodId_maybe,
+ isDefaultMethodId_maybe,
+ getInstIdModule, Id )
import Maybes
import Outputable
import Pretty
import Util
\end{code}
-%************************************************************************
-%* *
-\subsection[@specialiseTys@]{Determine specialising types}
-%* *
-%************************************************************************
-
@specialiseCallTys@ works out which type args don't need to be specialised on,
based on flags, the overloading constraint vector, and the types.
= Just ty
| otherwise
= Nothing
+\end{code}
+
+@getIdOverloading@ grabs the type of an Id, and returns a
+list of its polymorphic variables, and the initial segment of
+its ThetaType, in which the classes constrain only type variables.
+For example, if the Id's type is
+
+ forall a,b,c. Eq a -> Ord [a] -> tau
+
+we'll return
+ ([a,b,c], [(Eq,a)])
+
+This seems curious at first. For a start, the type above looks odd,
+because we usually only have dictionary args whose types are of
+the form (C a) where a is a type variable. But this doesn't hold for
+the functions arising from instance decls, which sometimes get
+arguements with types of form (C (T a)) for some type constructor T.
+
+Should we specialise wrt this compound-type dictionary? This is
+a heuristic judgement, as indeed is the fact that we specialise wrt
+only dictionaries. We choose *not* to specialise wrt compound dictionaries
+because at the moment the only place they show up is in instance decls,
+where they are simply plugged into a returned dictionary. So nothing is
+gained by specialising wrt them.
+
+\begin{code}
+getIdOverloading :: Id
+ -> ([TyVarTemplate], [(Class,TyVarTemplate)])
+getIdOverloading id
+ = (tyvars, tyvar_part_of theta)
+ where
+ (tyvars, theta, _) = splitType (getIdUniType id)
+
+ tyvar_part_of [] = []
+ tyvar_part_of ((clas,ty) : theta) = case getTyVarTemplateMaybe ty of
+ Nothing -> []
+ Just tyvar -> (clas, tyvar) : tyvar_part_of theta
+\end{code}
+
+\begin{code}
type ConstraintVector = [Bool] -- True for constrained tyvar, false otherwise
-mkConstraintVector :: [TyVarTemplate]
- -> [(Class,TyVarTemplate)]
+mkConstraintVector :: Id
-> ConstraintVector
-mkConstraintVector tyvars class_tyvar_pairs
+mkConstraintVector id
= [tyvar `elem` constrained_tyvars | tyvar <- tyvars]
where
+ (tyvars, class_tyvar_pairs) = getIdOverloading id
constrained_tyvars = map snd class_tyvar_pairs -- May contain dups
\end{code}
about imported specialisations which do not exist.
\begin{code}
-pprSpecErrs :: PprStyle
+pprSpecErrs :: FAST_STRING -- module name
-> (Bag (Id,[Maybe UniType])) -- errors
-> (Bag (Id,[Maybe UniType])) -- warnings
-> (Bag (TyCon,[Maybe UniType])) -- errors
-> Pretty
-pprSpecErrs sty spec_errs spec_warn spec_tyerrs
+pprSpecErrs this_mod spec_errs spec_warn spec_tyerrs
| not any_errs && not any_warn
= ppNil
| otherwise
- = ppAboves [if any_errs then ppAboves [
- ppStr "SPECIALISATION ERRORS (Essential):",
- ppAboves (map pp_module_errs use_modules),
- ppStr "***"
- ]
- else
- ppNil,
- if any_warn then ppAboves [
- ppStr "SPECIALISATION MESSAGES (Desirable):",
- ppAboves (map pp_module_warn use_modules),
- ppStr "***"
- ]
- else
- ppNil
- ]
+ = ppAboves [
+ ppStr "SPECIALISATION MESSAGES:",
+ ppAboves (map pp_module_specs use_modules)
+ ]
where
- any_errs = not (isEmptyBag spec_errs) || not (isEmptyBag spec_tyerrs)
+ any_errs = not (isEmptyBag spec_errs && isEmptyBag spec_tyerrs)
any_warn = not (isEmptyBag spec_warn)
- mk_module_fm errs_bag
+ mk_module_fm get_mod_data errs_bag
= addListToFM_C (++) emptyFM errs_list
where
- errs_list = map add_name (bagToList errs_bag)
-
- add_name (id, tys) = (mod, [(name, id, tys)])
- where
- (mod,name) = getOrigName id
-
- tyerrs_fm = mk_module_fm spec_tyerrs
- errs_fm = mk_module_fm spec_errs
- warn_fm = mk_module_fm spec_warn
-
- module_names = concat [keysFM errs_fm, keysFM warn_fm, keysFM tyerrs_fm]
- sorted_modules = map head (equivClasses _CMP_STRING_ module_names)
-
- -- Ensure any dfun instance specialisations (module _NIL_) are printed last
- -- ToDo: Print instance specialisations with the instance module
- -- This requires the module which defined the instance to be known:
- -- add_name could then extract the instance module for a dfun id
- -- and pp_dfun made a special case of pp_err
- use_modules = if (head sorted_modules == _NIL_)
- then tail sorted_modules ++ [_NIL_]
- else sorted_modules
-
-
- pp_module_errs :: FAST_STRING -> Pretty
- pp_module_errs mod
- | have_errs && mod == _NIL_
- -- A _NIL_ module string corresponds to internal Ids
- -- The only ones for which call instances should arise are
- -- dfuns which correspond to instance specialisations
- = ASSERT (null mod_tyerrs)
- ppAboves [
- ppStr "*** INSTANCES",
- ppAboves (map (pp_dfun sty) mod_errs)
- ]
-
- | have_errs
- = ppAboves [
- pp_module mod,
- ppAboves (map (pp_err sty) mod_errs),
- ppAboves (map (pp_tyerr sty) mod_tyerrs)
- ]
+ errs_list = map get_mod_data (bagToList errs_bag)
- | otherwise
- = ppNil
+ tyspecs_fm = mk_module_fm get_ty_data spec_tyerrs
+
+ iderrs_fm = mk_module_fm (get_id_data True) spec_errs
+ idwarn_fm = mk_module_fm (get_id_data False) spec_warn
+ idspecs_fm = plusFM_C (++) idwarn_fm iderrs_fm
+ get_id_data is_err (id, tys)
+ = (mod_name, [(id_name, id, tys, is_err)])
where
- mod_tyerrs = lookupWithDefaultFM tyerrs_fm [] mod
- mod_errs = lookupWithDefaultFM errs_fm [] mod
- have_errs = not (null mod_tyerrs) || not (null mod_errs)
+ (mod_name, id_name) = get_id_name id
+ get_id_name id
+ | maybeToBool (isDefaultMethodId_maybe id)
+ = (this_mod, _NIL_)
- pp_module_warn :: FAST_STRING -> Pretty
- pp_module_warn mod
- | have_warn && mod == _NIL_
- -- A _NIL_ module string corresponds to internal Ids
- -- The only ones for which call instances should arise are
- -- dfuns which correspond to instance specialisations
- = ppAboves [
- ppStr "*** INSTANCES",
- ppAboves (map (pp_dfun sty) mod_warn)
- ]
+ | isDictFunId id || maybeToBool (isConstMethodId_maybe id)
+ = let get_mod = getInstIdModule id
+ use_mod = if from_prelude get_mod
+ then SLIT("Prelude")
+ else get_mod
+ in (use_mod, _NIL_)
+
+ | otherwise
+ = getOrigName id
- | have_warn
+ get_ty_data (ty, tys)
+ = (mod_name, [(ty_name, ty, tys)])
+ where
+ (mod_name,ty_name) = getOrigName ty
+
+ from_prelude mod
+ = SLIT("Prelude") == (_SUBSTR_ mod 0 6)
+
+ module_names = concat [keysFM idspecs_fm, keysFM tyspecs_fm]
+ mods = map head (equivClasses _CMP_STRING_ module_names)
+
+ (unks, known) = if null mods
+ then ([], [])
+ else case _CMP_STRING_ (head mods) _NIL_ of
+ EQ_ -> ([_NIL_], tail mods)
+ other -> ([], mods)
+
+ (prels, others) = partition from_prelude known
+ use_modules = unks ++ prels ++ others
+
+ pp_module_specs :: FAST_STRING -> Pretty
+ pp_module_specs mod
+ | mod == _NIL_
+ = ASSERT (null mod_tyspecs)
+ ppAboves (map (pp_idspec ty_sty (ppStr "UNKNOWN:")) mod_idspecs)
+
+ | have_specs
= ppAboves [
- pp_module mod,
- ppAboves (map (pp_err sty) mod_warn)
- ]
+ ppAboves (map (pp_tyspec ty_sty (pp_module mod)) mod_tyspecs),
+ ppAboves (map (pp_idspec ty_sty (pp_module mod)) mod_idspecs)
+ ]
| otherwise
= ppNil
where
- mod_warn = lookupWithDefaultFM warn_fm [] mod
- have_warn = not (null mod_warn)
-
+ mod_tyspecs = lookupWithDefaultFM tyspecs_fm [] mod
+ mod_idspecs = lookupWithDefaultFM idspecs_fm [] mod
+ have_specs = not (null mod_tyspecs && null mod_idspecs)
+ ty_sty = PprInterface (error "SpecTyFuns:PprInterface:sw_chkr")
pp_module mod
- = ppCat [ppStr "*** module", ppPStr mod, ppStr "***"]
-
+ = ppBesides [ppPStr mod, ppStr ":"]
-pp_tyerr :: PprStyle -> (FAST_STRING, TyCon, [Maybe UniType]) -> Pretty
+pp_tyspec :: PprStyle -> Pretty -> (FAST_STRING, TyCon, [Maybe UniType]) -> Pretty
-pp_tyerr sty (_, tycon, tys)
- = ppCat [ppStr "{-# SPECIALIZE data",
- pprNonOp sty tycon, ppCat (map (pprParendUniType sty) spec_tys),
- ppStr "#-}" ]
+pp_tyspec sty pp_mod (_, tycon, tys)
+ = ppCat [pp_mod,
+ ppStr "{-# SPECIALIZE", ppStr "data",
+ pprNonOp PprForUser tycon, ppCat (map (pprParendUniType sty) spec_tys),
+ ppStr "#-}", ppStr "{- Essential -}"
+ ]
where
tvs = getTyConTyVarTemplates tycon
(spec_args, tv_maybes) = unzip (map choose_ty (tvs `zip` tys))
choose_ty (tv, Nothing) = (mkTyVarTemplateTy tv, Just tv)
choose_ty (tv, Just ty) = (ty, Nothing)
-pp_err sty (_, id, tys)
- = ppCat [ppStr "{-# SPECIALIZE",
- pprNonOp sty id, ppStr "::",
- pprUniType sty spec_ty,
- ppStr "#-}" ]
- where
- spec_ty = specialiseTy (getIdUniType id) tys 100 -- HACK to drop all dicts!!!
+pp_idspec :: PprStyle -> Pretty -> (FAST_STRING, Id, [Maybe UniType], Bool) -> Pretty
-pp_dfun sty (_, id, tys)
+pp_idspec sty pp_mod (_, id, tys, is_err)
| isDictFunId id
- = ppCat [ppStr "{-# SPECIALIZE instance",
+ = ppCat [pp_mod,
+ ppStr "{-# SPECIALIZE",
+ ppStr "instance",
+ pprUniType sty spec_ty,
+ ppStr "#-}", pp_essential ]
+
+ | is_const_method_id
+ = let
+ Just (cls, clsty, clsop) = const_method_maybe
+ (_, cls_str) = getOrigName cls
+ clsop_str = getClassOpString clsop
+ in
+ ppCat [pp_mod,
+ ppStr "{-# SPECIALIZE",
+ pp_clsop clsop_str, ppStr "::",
+ pprUniType sty spec_ty,
+ ppStr "#-} {- IN instance",
+ ppPStr cls_str, pprParendUniType sty clsty,
+ ppStr "-}", pp_essential ]
+
+ | is_default_method_id
+ = let
+ Just (cls, clsop, _) = default_method_maybe
+ (_, cls_str) = getOrigName cls
+ clsop_str = getClassOpString clsop
+ in
+ ppCat [pp_mod,
+ ppStr "{- instance",
+ ppPStr cls_str,
+ ppStr "EXPLICIT METHOD REQUIRED",
+ pp_clsop clsop_str, ppStr "::",
pprUniType sty spec_ty,
- ppStr "#-}" ]
- | isConstMethodId id
- = pp_comment sty "OVERLOADED METHOD" id spec_ty
+ ppStr "-}", pp_essential ]
+
| otherwise
- = pp_comment sty "HELP ..." id spec_ty
+ = ppCat [pp_mod,
+ ppStr "{-# SPECIALIZE",
+ pprNonOp PprForUser id, ppStr "::",
+ pprUniType sty spec_ty,
+ ppStr "#-}", pp_essential ]
where
spec_ty = specialiseTy (getIdUniType id) tys 100 -- HACK to drop all dicts!!!
+ pp_essential = if is_err then ppStr "{- Essential -}" else ppNil
+
+ const_method_maybe = isConstMethodId_maybe id
+ is_const_method_id = maybeToBool const_method_maybe
+
+ default_method_maybe = isDefaultMethodId_maybe id
+ is_default_method_id = maybeToBool default_method_maybe
+
+ pp_clsop str | isAvarop str
+ = ppBesides [ppLparen, ppPStr str, ppRparen]
+ | otherwise
+ = ppPStr str
-pp_comment sty msg id spec_ty
- = ppCat [ppStr "{-", ppStr msg,
- pprNonOp sty id, ppStr "::",
- pprUniType sty spec_ty,
- ppStr "-}" ]
\end{code}
import UniType(UniType)
data Bag a
data FiniteMap a b
-data SpecialiseData = SpecData Bool Bool [TyCon] [TyCon] (FiniteMap TyCon [[Labda UniType]]) (Bag (Id, [Labda UniType])) (Bag (Id, [Labda UniType])) (Bag (TyCon, [Labda UniType]))
-initSpecData :: [TyCon] -> FiniteMap TyCon [[Labda UniType]] -> SpecialiseData
+data SpecialiseData = SpecData Bool Bool [TyCon] [TyCon] (FiniteMap TyCon [(Bool, [Labda UniType])]) (Bag (Id, [Labda UniType])) (Bag (Id, [Labda UniType])) (Bag (TyCon, [Labda UniType]))
+initSpecData :: [TyCon] -> FiniteMap TyCon [(Bool, [Labda UniType])] -> SpecialiseData
specProgram :: (GlobalSwitch -> Bool) -> SplitUniqSupply -> [CoreBinding Id Id] -> SpecialiseData -> ([CoreBinding Id Id], SpecialiseData)
cmpCI_tys (CallInstance _ tys1 _ _ _) (CallInstance _ tys2 _ _ _)
= cmpUniTypeMaybeList tys1 tys2
+eqCI_tys :: CallInstance -> CallInstance -> Bool
+eqCI_tys c1 c2
+ = case cmpCI_tys c1 c2 of { EQ_ -> True; other -> False }
+
isCIofTheseIds :: [Id] -> CallInstance -> Bool
-isCIofTheseIds ids (CallInstance ci_id _ _ _ _) = any (eqId ci_id) ids
+isCIofTheseIds ids (CallInstance ci_id _ _ _ _)
+ = any (eqId ci_id) ids
singleCI :: Id -> [Maybe UniType] -> [PlainCoreArg] -> UsageDetails
singleCI id tys dicts
= UsageDetails (unitBag (CallInstance id tys dicts fv_set Nothing))
- emptyBag [] emptyUniqSet
+ emptyBag [] emptyUniqSet 0 0
where
fv_set = mkUniqSet (id : [dict | ValArg (CoVarAtom dict) <- dicts])
explicitCI :: Id -> [Maybe UniType] -> SpecInfo -> UsageDetails
explicitCI id tys specinfo
- = UsageDetails (unitBag call_inst) emptyBag [] emptyUniqSet
+ = UsageDetails (unitBag call_inst) emptyBag [] emptyUniqSet 0 0
where
call_inst = CallInstance id tys dicts fv_set (Just specinfo)
dicts = panic "Specialise:explicitCI:dicts"
fv_set = singletonUniqSet id
-getCIs :: [Id] -> UsageDetails -> ([CallInstance], UsageDetails)
-getCIs ids (UsageDetails cis tycon_cis dbs fvs)
+-- We do not process the CIs for top-level dfuns or defms
+-- Instead we require an explicit SPEC inst pragma for dfuns
+-- and an explict method within any instances for the defms
+
+getCIids :: Bool -> [Id] -> [Id]
+getCIids True ids = filter not_dict_or_defm ids
+getCIids _ ids = ids
+
+not_dict_or_defm id
+ = not (isDictTy (getIdUniType id) || maybeToBool (isDefaultMethodId_maybe id))
+
+getCIs :: Bool -> [Id] -> UsageDetails -> ([CallInstance], UsageDetails)
+getCIs top_lev ids (UsageDetails cis tycon_cis dbs fvs c i)
= let
- (cis_here, cis_not_here) = partitionBag (isCIofTheseIds ids) cis
+ (cis_here, cis_not_here) = partitionBag (isCIofTheseIds (getCIids top_lev ids)) cis
cis_here_list = bagToList cis_here
in
-- pprTrace "getCIs:"
- -- (ppHang (ppBesides [ppStr "{", ppr PprDebug ids, ppStr "}"])
- -- 4 (ppAboves (map pprCI cis_here_list)))
- (cis_here_list, UsageDetails cis_not_here tycon_cis dbs fvs)
+ -- (ppHang (ppBesides [ppStr "{", ppr PprDebug ids, ppStr "}"])
+ -- 4 (ppAboves (map pprCI cis_here_list)))
+ (cis_here_list, UsageDetails cis_not_here tycon_cis dbs fvs c i)
dumpCIs :: Bag CallInstance -- The call instances
+ -> Bool -- True <=> top level bound Ids
+ -> Bool -- True <=> dict bindings to be floated (specBind only)
+ -> [CallInstance] -- Call insts for bound ids (instBind only)
-> [Id] -- Bound ids *new*
+ -> [Id] -- Full bound ids: includes dumped dicts
-> Bag CallInstance -- Kept call instances
-dumpCIs cis bound_ids
- = (if not (isEmptyBag cis_dict_bound_arg) then
- (if isEmptyBag unboxed_cis_dict_bound_arg
- then (\ x y -> y) -- pprTrace "dumpCIs: bound dictionary arg ... \n"
- else pprTrace "dumpCIs: bound dictionary arg ... WITH UNBOXED TYPES!\n")
- (ppHang (ppBesides [ppStr "{", ppr PprDebug bound_ids, ppStr "}"])
- 4 (ppAboves (map pprCI (bagToList cis_dump))))
- else id)
- cis_keep
+
+ -- CIs are dumped if:
+ -- 1) they are a CI for one of the bound ids, or
+ -- 2) they mention any of the dicts in a local unfloated binding
+ --
+ -- For top-level bindings we allow the call instances to
+ -- float past a dict bind and place all the top-level binds
+ -- in a *global* CoRec.
+ -- We leave it to the simplifier will sort it all out ...
+
+dumpCIs cis top_lev floating inst_cis bound_ids full_ids
+ = (if not (isEmptyBag cis_of_bound_id) &&
+ not (isEmptyBag cis_of_bound_id_without_inst_cis)
+ then
+ pprTrace ("dumpCIs: dumping CI which was not instantiated ... \n" ++
+ " (may be a non-HM recursive call)\n")
+ (ppHang (ppBesides [ppStr "{", ppr PprDebug bound_ids, ppStr "}"])
+ 4 (ppAboves [ppStr "Dumping CIs:",
+ ppAboves (map pprCI (bagToList cis_of_bound_id)),
+ ppStr "Instantiating CIs:",
+ ppAboves (map pprCI inst_cis)]))
+ else id) (
+ if top_lev || floating then
+ cis_not_bound_id
+ else
+ (if not (isEmptyBag cis_dump_unboxed)
+ then pprTrace "dumpCIs: bound dictionary arg ... WITH UNBOXED TYPES!\n"
+ (ppHang (ppBesides [ppStr "{", ppr PprDebug full_ids, ppStr "}"])
+ 4 (ppAboves (map pprCI (bagToList cis_dump))))
+ else id)
+ cis_keep_not_bound_id
+ )
where
- (cis_dump, cis_keep) = partitionBag mentions_bound_ids cis
+ (cis_of_bound_id, cis_not_bound_id)
+ = partitionBag (isCIofTheseIds (getCIids top_lev bound_ids)) cis
+
+ (cis_dump, cis_keep_not_bound_id)
+ = partitionBag ok_to_dump_ci cis_not_bound_id
- mentions_bound_ids (CallInstance _ _ _ fv_set _)
- = or [i `elementOfUniqSet` fv_set | i <- bound_ids]
+ ok_to_dump_ci (CallInstance _ _ _ fv_set _)
+ = or [i `elementOfUniqSet` fv_set | i <- full_ids]
- (cis_of_bound_id, cis_dict_bound_arg) = partitionBag (isCIofTheseIds bound_ids) cis_dump
- (unboxed_cis_dict_bound_arg, _) = partitionBag isUnboxedCI cis_dict_bound_arg
+ (_, cis_of_bound_id_without_inst_cis) = partitionBag have_inst_ci cis_of_bound_id
+ have_inst_ci ci = any (eqCI_tys ci) inst_cis
+
+ (cis_dump_unboxed, _) = partitionBag isUnboxedCI cis_dump
\end{code}
arising from specialising f's RHS. The only instance we'll find
is another call of (f Int#).
-ToDo: We should check this rather than just dumping them.
-
-However, we do report any call instances which are mysteriously dumped
-because they have a dictionary argument which is bound here ...
+We check this in dumpCIs by passing in all the instantiated call
+instances (inst_cis) and reporting any dumped cis (cis_of_bound_id)
+for which there is no such instance.
-ToDo: Under what circumstances does this occur, if at all?
+We also report CIs dumped due to a bound dictionary arg if they
+contain unboxed types.
%************************************************************************
%* *
singleTyConI :: TyCon -> [Maybe UniType] -> UsageDetails
singleTyConI ty_con spec_tys
- = UsageDetails emptyBag (unitBag (TyConInstance ty_con spec_tys)) [] emptyUniqSet
+ = UsageDetails emptyBag (unitBag (TyConInstance ty_con spec_tys)) [] emptyUniqSet 0 0
isTyConIofThisTyCon :: TyCon -> TyConInstance -> Bool
isTyConIofThisTyCon ty_con (TyConInstance inst_ty_con _) = eqTyCon ty_con inst_ty_con
isLocalSpecTyConI comp_prel (TyConInstance inst_ty_con _) = isLocalSpecTyCon comp_prel inst_ty_con
getLocalSpecTyConIs :: Bool -> UsageDetails -> ([TyConInstance], UsageDetails)
-getLocalSpecTyConIs comp_prel (UsageDetails cis tycon_cis dbs fvs)
+getLocalSpecTyConIs comp_prel (UsageDetails cis tycon_cis dbs fvs c i)
= let
(tycon_cis_local, tycon_cis_global)
= partitionBag (isLocalSpecTyConI comp_prel) tycon_cis
tycon_cis_local_list = bagToList tycon_cis_local
in
- (tycon_cis_local_list, UsageDetails cis tycon_cis_global dbs fvs)
+ (tycon_cis_local_list, UsageDetails cis tycon_cis_global dbs fvs c i)
\end{code}
(Bag TyConInstance) -- Constructor call-instances
[DictBindDetails] -- Dictionary bindings in data-dependence order!
FreeVarsSet -- Free variables (excl imported ones, incl top level) (cloned)
+ Int -- no. of spec calls
+ Int -- no. of spec insts
\end{code}
The DictBindDetails are fully processed; their call-instance information is
unionUDs :: UsageDetails -> UsageDetails -> UsageDetails
unionUDList :: [UsageDetails] -> UsageDetails
-emptyUDs = UsageDetails emptyBag emptyBag [] emptyUniqSet
+tickSpecCall :: Bool -> UsageDetails -> UsageDetails
+tickSpecInsts :: UsageDetails -> UsageDetails
+
+tickSpecCall found (UsageDetails cis ty_cis dbs fvs c i)
+ = UsageDetails cis ty_cis dbs fvs (c + (if found then 1 else 0)) i
+
+tickSpecInsts (UsageDetails cis ty_cis dbs fvs c i)
+ = UsageDetails cis ty_cis dbs fvs c (i+1)
-unionUDs (UsageDetails cis1 tycon_cis1 dbs1 fvs1) (UsageDetails cis2 tycon_cis2 dbs2 fvs2)
+emptyUDs = UsageDetails emptyBag emptyBag [] emptyUniqSet 0 0
+
+unionUDs (UsageDetails cis1 tycon_cis1 dbs1 fvs1 c1 i1) (UsageDetails cis2 tycon_cis2 dbs2 fvs2 c2 i2)
= UsageDetails (unionBags cis1 cis2) (unionBags tycon_cis1 tycon_cis2)
- (dbs1 ++ dbs2) (fvs1 `unionUniqSets` fvs2)
+ (dbs1 ++ dbs2) (fvs1 `unionUniqSets` fvs2) (c1+c2) (i1+i2)
-- The append here is really redundant, since the bindings don't
-- scope over each other. ToDo.
unionUDList = foldr unionUDs emptyUDs
singleFvUDs (CoVarAtom v) | not (isImportedId v)
- = UsageDetails emptyBag emptyBag [] (singletonUniqSet v)
+ = UsageDetails emptyBag emptyBag [] (singletonUniqSet v) 0 0
singleFvUDs other
= emptyUDs
-singleConUDs con = UsageDetails emptyBag emptyBag [] (singletonUniqSet con)
+singleConUDs con = UsageDetails emptyBag emptyBag [] (singletonUniqSet con) 0 0
dumpDBs :: [DictBindDetails]
+ -> Bool -- True <=> top level bound Ids
-> [TyVar] -- TyVars being bound (cloned)
-> [Id] -- Ids being bound (cloned)
-> FreeVarsSet -- Fvs of body
-> ([PlainCoreBinding], -- These ones have to go here
[DictBindDetails], -- These can float further
[Id], -- Incoming list + names of dicts bound here
- FreeVarsSet -- Incominf fvs + fvs of dicts bound here
+ FreeVarsSet -- Incoming fvs + fvs of dicts bound here
)
-dumpDBs [] bound_tyvars bound_ids fvs = ([], [], bound_ids, fvs)
+
+ -- It is just to complex to try to float top-level
+ -- dict bindings with constant methods, inst methods,
+ -- auxillary derived instance defns and user instance
+ -- defns all getting in the way.
+ -- So we dump all dbinds as soon as we get to the top
+ -- level and place them in a *global* CoRec.
+ -- We leave it to the simplifier will sort it all out ...
+
+dumpDBs [] top_lev bound_tyvars bound_ids fvs
+ = ([], [], bound_ids, fvs)
dumpDBs ((db@(DictBindDetails dbinders dbind db_fvs db_ftv)):dbs)
- bound_tyvars bound_ids fvs
- | or [i `elementOfUniqSet` db_fvs | i <- bound_ids]
- ||
- or [tv `elementOfUniqSet` db_ftv | tv <- bound_tyvars]
+ top_lev bound_tyvars bound_ids fvs
+ | top_lev
+ || or [i `elementOfUniqSet` db_fvs | i <- bound_ids]
+ || or [tv `elementOfUniqSet` db_ftv | tv <- bound_tyvars]
= let -- Ha! Dump it!
(dbinds_here, dbs_outer, full_bound_ids, full_fvs)
- = dumpDBs dbs bound_tyvars (dbinders ++ bound_ids) (db_fvs `unionUniqSets` fvs)
+ = dumpDBs dbs top_lev bound_tyvars (dbinders ++ bound_ids) (db_fvs `unionUniqSets` fvs)
in
(dbind : dbinds_here, dbs_outer, full_bound_ids, full_fvs)
| otherwise -- This one can float out further
= let
(dbinds_here, dbs_outer, full_bound_ids, full_fvs)
- = dumpDBs dbs bound_tyvars bound_ids fvs
+ = dumpDBs dbs top_lev bound_tyvars bound_ids fvs
in
(dbinds_here, db : dbs_outer, full_bound_ids, full_fvs)
dumpUDs :: UsageDetails
+ -> Bool -- True <=> top level bound Ids
+ -> Bool -- True <=> dict bindings to be floated (specBind only)
+ -> [CallInstance] -- Call insts for bound Ids (instBind only)
-> [Id] -- Ids which are just being bound; *new*
-> [TyVar] -- TyVars which are just being bound
-> ([PlainCoreBinding], -- Bindings from UsageDetails which mention the ids
UsageDetails) -- The above bindings removed, and
-- any call-instances which mention the ids dumped too
-dumpUDs (UsageDetails cis tycon_cis dbs fvs) bound_ids tvs
+dumpUDs (UsageDetails cis tycon_cis dbs fvs c i) top_lev floating inst_cis bound_ids tvs
= let
- (dict_binds_here, dbs_outer, full_bound_ids, full_fvs) = dumpDBs dbs tvs bound_ids fvs
- cis_outer = dumpCIs cis full_bound_ids
+ (dict_binds_here, dbs_outer, full_bound_ids, full_fvs)
+ = dumpDBs dbs top_lev tvs bound_ids fvs
+ cis_outer = dumpCIs cis top_lev floating inst_cis bound_ids full_bound_ids
fvs_outer = full_fvs `minusUniqSet` (mkUniqSet full_bound_ids)
in
- (dict_binds_here, UsageDetails cis_outer tycon_cis dbs_outer fvs_outer)
+ (dict_binds_here, UsageDetails cis_outer tycon_cis dbs_outer fvs_outer c i)
\end{code}
\begin{code}
addDictBinds :: [Id] -> PlainCoreBinding -> UsageDetails -- Dict binding and RHS usage
-> UsageDetails -- The usage to augment
-> UsageDetails
-addDictBinds dbinders dbind (UsageDetails db_cis db_tycon_cis db_dbs db_fvs)
- (UsageDetails cis tycon_cis dbs fvs)
+addDictBinds dbinders dbind (UsageDetails db_cis db_tycon_cis db_dbs db_fvs db_c db_i)
+ (UsageDetails cis tycon_cis dbs fvs c i)
= UsageDetails (db_cis `unionBags` cis)
(db_tycon_cis `unionBags` tycon_cis)
(db_dbs ++ [DictBindDetails dbinders dbind db_fvs db_ftvs] ++ dbs)
- fvs
+ fvs c i
+ -- NB: We ignore counts from dictbinds since it is not user code
where
-- The free tyvars of the dictionary bindings should really be
-- gotten from the RHSs, but I'm pretty sure it's good enough just
-- any big tuples used in this module
-- The initial (and default) value is the local tycons
- (FiniteMap TyCon [[Maybe UniType]])
+ (FiniteMap TyCon [(Bool, [Maybe UniType])])
-- TyCon specialisations to be generated
- -- We generate specialisations for data types defined
- -- in this module and any tuples used in this module
+ -- We generate specialialised code (Bool=True) for data types
+ -- defined in this module and any tuples used in this module
-- The initial (and default) value is the specialisations
- -- requested by source-level SPECIALIZE data pragmas
- -- and _SPECIALISE_ pragmas in the interface files
+ -- requested by source-level SPECIALIZE data pragmas (Bool=True)
+ -- and _SPECIALISE_ pragmas (Bool=False) in the interface files
(Bag (Id,[Maybe UniType]))
-- Imported specialisation errors
(SpecData False _ local_tycons _ init_specs init_errs init_warn init_tyerrs)
= case (initSM (specTyConsAndScope (specTopBinds binds)) sw_chker uniqs) of
(final_binds, tycon_specs_list,
- UsageDetails import_cis import_tycis _ fvs)
+ UsageDetails import_cis import_tycis _ fvs spec_calls spec_insts)
-> let
used_conids = filter isDataCon (uniqSetToList fvs)
used_tycons = map getDataConTyCon used_conids
no_errs = isEmptyBag cis_errs && isEmptyBag tycis_errs
&& (not (sw_chker SpecialiseImports) || isEmptyBag cis_warn)
in
+ (if sw_chker D_simplifier_stats then
+ pprTrace "\nSpecialiser Stats:\n" (ppAboves [
+ ppBesides [ppStr "SpecCalls ", ppInt spec_calls],
+ ppBesides [ppStr "SpecInsts ", ppInt spec_insts],
+ ppSP])
+ else id)
+
(final_binds,
SpecData True no_errs local_tycons gen_tycons result_specs
cis_errs cis_warn tycis_errs)
be required. We don't create the specialised constructors in
Core. These are only introduced when we convert to StgSyn.
-ToDo: Perhaps this should be done in CoreToStg to ensure no inconsistencies!
+ToDo: Perhaps this collection should be done in CoreToStg to ensure no inconsistencies!
\begin{code}
specTyConsAndScope :: SpecM ([PlainCoreBinding], UsageDetails)
- -> SpecM ([PlainCoreBinding], [(TyCon,[[Maybe UniType]])], UsageDetails)
+ -> SpecM ([PlainCoreBinding], [(TyCon,[(Bool,[Maybe UniType])])], UsageDetails)
specTyConsAndScope scopeM
= scopeM `thenSM` \ (binds, scope_uds) ->
in
(if sw_chkr SpecialiseTrace && not (null tycon_specs_list) then
pprTrace "Specialising TyCons:\n"
- (ppAboves [ if not (null specs) then
- ppHang (ppCat [(ppr PprDebug tycon), ppStr "at types"])
- 4 (ppAboves (map pp_specs specs))
- else ppNil
- | (tycon, specs) <- tycon_specs_list])
+ (ppAboves [ if not (null specs) then
+ ppHang (ppCat [(ppr PprDebug tycon), ppStr "at types"])
+ 4 (ppAboves (map pp_specs specs))
+ else ppNil
+ | (tycon, specs) <- tycon_specs_list])
else id) (
returnSM (binds, tycon_specs_list, gotci_scope_uds)
)
where
(tycon_cis, other_tycons_cis) = partition (isTyConIofThisTyCon tycon) tycons_cis
uniq_cis = map head (equivClasses cmpTyConI_tys tycon_cis)
- tycon_specs = [spec_tys | TyConInstance _ spec_tys <- uniq_cis]
+ tycon_specs = [(False, spec_tys) | TyConInstance _ spec_tys <- uniq_cis]
- pp_specs specs = ppInterleave ppNil [pprMaybeTy PprDebug ty | ty <- specs]
+ pp_specs (False, spec_tys) = ppInterleave ppNil [pprMaybeTy PprDebug spec_ty | spec_ty <- spec_tys]
-
-{- UNUSED: create specialised constructors in Core
-
-NB: this code may have some bitrot (Andy & Will 95/06)
-
-specTyConsAndScope spec_tycons scopeM
- = fixSM (\ ~(_, _, _, rec_spec_infos) ->
- bindConIds cons_tospec rec_spec_infos (
- scopeM `thenSM` \ (binds, scope_uds) ->
- let
- (tycons_cis, gotci_scope_uds)
- = getLocalSpecTyConIs (sw_chkr CompilingPrelude) scope_uds
- in
- mapAndUnzipSM (inst_tycon tycons_cis) spec_tycons
- `thenSM` \ (tycon_specs_list, spec_infoss) ->
- returnSM (binds, tycon_specs_list, gotci_scope_uds, concat spec_infoss)
- )
-
- ) `thenSM` \ (binds, tycon_specs_list, final_uds, spec_infos) ->
- returnSM (binds, tycon_specs_list, final_uds)
-
- where
- conss_tospec = map getTyConDataCons spec_tycons
- cons_tospec = concat conss_tospec
-
- inst_tycon tycons_cis tycon
- = mapSM mk_con_specs (getTyConDataCons tycon) `thenSM` \ spec_infos ->
- getSwitchCheckerSM `thenSM` \ sw_chkr ->
- (if sw_chkr SpecialiseTrace && not (null tycon_cis) then
- pprTrace "Specialising:"
- (ppHang (ppCat [ppr PprDebug tycon, ppStr "at types"])
- 4 (ppAboves (map pp_inst uniq_cis)))
- else id) (
- returnSM ((tycon, tycon_specs), spec_infos)
- )
- where
- tycon_cis = filter (isTyConIofThisTyCon tycon) tycons_cis
- uniq_cis = map head (equivClasses cmpTyConI_tys tycon_cis)
-
- tycon_specs = [spec_tys | TyConInstance _ spec_tys <- uniq_cis]
-
- mk_con_specs con_id
- = mapSM (mk_con_spec con_id) uniq_cis
- mk_con_spec con_id (TyConInstance _ spec_tys)
- = newSpecIds [con_id] spec_tys 0 copy_arity_info_and `thenSM` \ [spec_id] ->
- returnSM (SpecInfo spec_tys 0 spec_id)
-
- copy_arity_info old new = addIdArity new (getDataConArity old)
-
- pp_inst (TyConInstance _ spec_tys)
- = ppInterleave ppNil [pprMaybeTy PprDebug ty | ty <- spec_tys]
--}
\end{code}
-
+
%************************************************************************
%* *
\subsection[specTopBinds]{Specialising top-level bindings}
-> SpecM ([PlainCoreBinding], UsageDetails)
specTopBinds binds
- = spec_top_binds binds `thenSM` \ (binds, UsageDetails cis tycis dbind_details fvs) ->
+ = spec_top_binds binds `thenSM` \ (binds, UsageDetails cis tycis dbind_details fvs c i) ->
let
-- Add bindings for floated dbinds and collect fvs
-- In actual fact many of these bindings are dead code since dict
full_fvs = fvs `unionUniqSets` unionManyUniqSets dfvs_s
fvs_outer = full_fvs `minusUniqSet` (mkUniqSet (concat dbinders_s))
+
+ -- It is just to complex to try to sort out top-level dependencies
+ -- So we just place all the top-level binds in a *global* CoRec and
+ -- leave it to the simplifier to sort it all out ...
in
- returnSM (dbinds ++ binds, UsageDetails cis tycis [] fvs_outer)
+ ASSERT(null dbinds)
+ returnSM ([CoRec (pairsFromCoreBinds binds)], UsageDetails cis tycis [] fvs_outer c i)
where
spec_top_binds (first_bind:rest_binds)
- = specBindAndScope True {- top level -} first_bind (
+ = specBindAndScope True first_bind (
spec_top_binds rest_binds `thenSM` \ (rest_binds, rest_uds) ->
returnSM (ItsABinds rest_binds, rest_uds)
) `thenSM` \ (first_binds, ItsABinds rest_binds, all_uds) ->
returnSM (bindUnlift vl vu (CoVar vu), singleFvUDs (CoVarAtom vl))
NoLift vatom@(CoVarAtom new_v)
- -> mapSM specArg args `thenSM` \ arg_info ->
- mkCallInstance v new_v arg_info `thenSM` \ uds ->
- mkCall new_v arg_info `thenSM` \ call ->
- returnSM (call, uds)
+ -> mapSM specArg args `thenSM` \ arg_info ->
+ mkCallInstance v new_v arg_info `thenSM` \ call_uds ->
+ mkCall new_v arg_info `thenSM` \ ~(speced, call) ->
+ let
+ uds = unionUDList [call_uds,
+ singleFvUDs vatom,
+ unionUDList [uds | (_,uds,_) <- arg_info]
+ ]
+ in
+ returnSM (call, tickSpecCall speced uds)
specExpr expr@(CoLit _) null_args
= ASSERT (null null_args)
returnSM (applyBindUnlifts unlifts (CoCon con tys args),
unionUDList args_uds_s `unionUDs` con_uds)
-{- UNUSED: create specialised constructors in CoCon
-specExpr (CoCon con tys args) null_args
- = ASSERT (null null_args)
- mapSM specTy tys `thenSM` \ tys ->
- mapAndUnzipSM specAtom args `thenSM` \ (args, args_uds_s) ->
- mkTyConInstance con tys `thenSM` \ con_con ->
- lookupId con `thenSM` \ con ->
- mkConstrCall con tys `thenSM` \ ~(spec_con, spec_tys) ->
- returnSM (CoCon spec_con spec_tys args,
- unionUDList args_uds_s `unionUDs` con_uds)
--}
-
specExpr (CoPrim op@(CCallOp str is_asm may_gc arg_tys res_ty) tys args) null_args
= ASSERT (null null_args)
ASSERT (null tys)
bindTyVar tyvar (mkTyVarTy new_tyvar) (
specExpr body [] `thenSM` \ (body, body_uds) ->
let
- (binds_here, final_uds) = dumpUDs body_uds [] [new_tyvar]
+ (binds_here, final_uds) = dumpUDs body_uds False False [] [] [new_tyvar]
in
returnSM (CoTyLam new_tyvar (mkCoLetsNoUnboxed binds_here body), final_uds)
)
specExpr (CoLet bind body) args
- = specBindAndScope False {- not top level -} bind (
+ = specBindAndScope False bind (
specExpr body args `thenSM` \ (body, body_uds) ->
returnSM (ItsAnExpr body, body_uds)
) `thenSM` \ (binds, ItsAnExpr body, all_uds) ->
- returnSM (mkCoLetsNoUnboxed binds body, all_uds)
+ returnSM (mkCoLetsUnboxedToCase binds body, all_uds)
specExpr (CoSCC cc expr) args
= specExpr expr [] `thenSM` \ (expr, expr_uds) ->
returnSM (applyBindUnlifts unlifts (applyToArgs scc_expr args),
unionUDList args_uds_s `unionUDs` expr_uds)
--- ToDo:DPH: add stuff here!
+-- ToDo: This may leave some unspeced dictionaries !!
+
+-- ToDo: DPH: add stuff here!
\end{code}
%************************************************************************
let
-- Dump any dictionary bindings (and call instances)
-- from the scope which mention things bound here
- (binds_here, final_uds) = dumpUDs body_uds new_ids []
+ (binds_here, final_uds) = dumpUDs body_uds False False [] new_ids []
in
returnSM (new_ids, mkCoLetsNoUnboxed binds_here body, final_uds)
)
mkTyConInstance con ty_args `thenSM` \ con_uds ->
returnSM ((con,binders,rhs), rhs_uds `unionUDs` con_uds)
-{- UNUSED: creating specialised constructors in case alts
- specAlgAlt ty_args (con,binders,rhs)
- = specLambdaOrCaseBody binders rhs args `thenSM` \ (binders, rhs, rhs_uds) ->
- mkTyConInstance con ty_args `thenSM` \ con_uds ->
- lookupId con `thenSM` \ con ->
- mkConstrCall con ty_args `thenSM` \ ~(spec_con, _) ->
- returnSM ((spec_con,binders,rhs), rhs_uds `unionUDs` con_uds)
--}
-
specAlts (CoPrimAlts alts deflt) scrutinee_ty args
= mapAndUnzipSM specPrimAlt alts `thenSM` \ (alts, alts_uds_s) ->
specDeflt deflt args `thenSM` \ (deflt, deflt_uds) ->
BindsOrExpr, -- Combined result
UsageDetails) -- Usage details of the whole lot
-specBindAndScope is_top_level_group bind scopeM
- = cloneLetrecBinders binders `thenSM` \ (new_binders, clone_infos) ->
+specBindAndScope top_lev bind scopeM
+ = cloneLetBinders top_lev (is_rec bind) binders
+ `thenSM` \ (new_binders, clone_infos) ->
- -- Two cases now: either this is a bunch of dictionaries, in
- -- which case we float them; or its a bunch of other values,
- -- in which case we see if they correspond to any
- -- call-instances we have in hand.
+ -- Two cases now: either this is a bunch of local dictionaries,
+ -- in which case we float them; or its a bunch of other values,
+ -- in which case we see if they correspond to any call-instances
+ -- we have from processing the scope
- if all (\id -> isDictTy (getIdUniType id) || isConstMethodId id) binders then
- -- Ha! A group of dictionary bindings, or constant methods.
- -- The reason for the latter is interesting. Consider
- --
- -- dfun.Eq.Foo = /\a \ d -> ...
- --
- -- constmeth1 = ...
- -- constmeth2 = ...
- -- dict = (constmeth1,constmeth2)
- --
- -- ...(dfun.Eq.Foo dict)...
- --
- -- Now, the defn of dict can't float above the constant-method
- -- decls, so the call-instance for dfun.Eq.Foo will be dropped.
- --
- -- Solution: float the constant methods in the same way as dictionaries
- --
- -- The other interesting bit is the test for dictionary-hood.
- -- Constant dictionaries, like dict above, are sometimes built
- -- as zero-arity dfuns, so isDictId alone won't work.
+ if not top_lev && all (isDictTy . getIdUniType) binders
+ then
+ -- Ha! A group of local dictionary bindings
bindIds binders clone_infos (
-- Process the dictionary bindings themselves
- specBind new_binders bind `thenSM` \ (bind, rhs_uds) ->
+ specBind False True new_binders [] bind `thenSM` \ (bind, rhs_uds) ->
-- Process their scope
- scopeM `thenSM` \ (thing, scope_uds) ->
+ scopeM `thenSM` \ (thing, scope_uds) ->
let
-- Add the bindings to the current stuff
final_uds = addDictBinds new_binders bind rhs_uds scope_uds
returnSM ([], thing, final_uds)
)
else
- -- Ho! A group of ordinary (non-dict) bindings
+ -- Ho! A group of bindings
+
fixSM (\ ~(_, _, _, rec_spec_infos) ->
bindSpecIds binders clone_infos rec_spec_infos (
-- Do the scope of the bindings
scopeM `thenSM` \ (thing, scope_uds) ->
- let
- (call_insts_these_binders, gotci_scope_uds) = getCIs new_binders scope_uds
+ let
+ (call_insts, gotci_scope_uds) = getCIs top_lev new_binders scope_uds
+
+ equiv_ciss = equivClasses cmpCI_tys call_insts
+ inst_cis = map head equiv_ciss
in
-- Do the bindings themselves
- specBind new_binders bind `thenSM` \ (spec_bind, spec_uds) ->
+ specBind top_lev False new_binders inst_cis bind
+ `thenSM` \ (spec_bind, spec_uds) ->
-- Create any necessary instances
- instBind new_binders bind call_insts_these_binders
+ instBind top_lev new_binders bind equiv_ciss inst_cis
`thenSM` \ (inst_binds, inst_uds, spec_infos) ->
let
- -- Dump any dictionary bindings from the scope
- -- which mention things bound here
- (dict_binds, final_scope_uds) = dumpUDs gotci_scope_uds new_binders []
- -- The spec_ids can't appear anywhere in uds, because they only
- -- appear in SpecInfos.
-
- -- Build final binding group
- -- see note below about dependecies
- final_binds = [spec_bind,
- CoRec (pairsFromCoreBinds (inst_binds ++ dict_binds))
- ]
-
+ -- NB: dumpUDs only worries about new_binders since the free var
+ -- stuff only records free new_binders
+ -- The spec_ids only appear in SpecInfos and final speced calls
+
+ -- Build final binding group and usage details
+ (final_binds, final_uds)
+ = if top_lev then
+ -- For a top-level binding we have to dumpUDs from
+ -- spec_uds and inst_uds and scope_uds creating
+ -- *global* dict bindings
+ let
+ (scope_dict_binds, final_scope_uds)
+ = dumpUDs gotci_scope_uds True False [] new_binders []
+ (spec_dict_binds, final_spec_uds)
+ = dumpUDs spec_uds True False inst_cis new_binders []
+ (inst_dict_binds, final_inst_uds)
+ = dumpUDs inst_uds True False inst_cis new_binders []
+ in
+ ([spec_bind] ++ inst_binds ++ scope_dict_binds
+ ++ spec_dict_binds ++ inst_dict_binds,
+ final_spec_uds `unionUDs` final_scope_uds `unionUDs` final_inst_uds)
+ else
+ -- For a local binding we only have to dumpUDs from
+ -- scope_uds since the UDs from spec_uds and inst_uds
+ -- have already been dumped by specBind and instBind
+ let
+ (scope_dict_binds, final_scope_uds)
+ = dumpUDs gotci_scope_uds False False [] new_binders []
+ in
+ ([spec_bind] ++ inst_binds ++ scope_dict_binds,
+ spec_uds `unionUDs` final_scope_uds `unionUDs` inst_uds)
+
+ -- inst_uds comes last, because there may be dict bindings
+ -- floating outward in scope_uds which are mentioned
+ -- in the call-instances, and hence in spec_uds.
+ -- This ordering makes sure that the precedence order
+ -- among the dict bindings finally floated out is maintained.
in
- -- Combine the results together
- returnSM (final_binds,
- thing,
- spec_uds `unionUDs` final_scope_uds `unionUDs` inst_uds,
- -- inst_uds comes last, because there may be dict bindings
- -- floating outward in final_scope_uds which are mentioned
- -- in the call-instances, and hence in spec_uds.
- -- This ordering makes sure that the precedence order
- -- among the dict bindings finally floated out is maintained.
- spec_infos)
+ returnSM (final_binds, thing, final_uds, spec_infos)
)
) `thenSM` \ (binds, thing, final_uds, spec_infos) ->
returnSM (binds, thing, final_uds)
where
binders = bindersOf bind
-\end{code}
-
-We place the spec_binds and dict_binds in a CoRec as there may be some
-nasty dependencies. These don't actually require a CoRec, but its the
-simplest solution. (The alternative would require some tricky dependency
-analysis.) We leave it to the real dependency analyser to sort it all
-out during a subsequent simplification pass.
-
-Where do these dependencies arise? Consider this case:
-
- data Foo a = ...
-
- {- instance Eq a => Eq (Foo a) where ... -}
- dfun.Eq.(Foo *) d.eq.a = <wurble>
-
- d2 = dfun.Eq.(Foo *) Char# d.Eq.Char#
- d1 = dfun.Eq.(Foo *) (Foo Char#) d2
-
-Now, when specialising we must write the Char# instance of dfun.Eq.(Foo *) before
-that for the (Foo Char#) instance:
-
- dfun.Eq.(Foo *) d.eq.a = <wurble>
-
- dfun.Eq.(Foo *)@Char# = <wurble>[d.Eq.Char#/d.eq.a]
- d2 = dfun.Eq.(Foo *)@Char#
-
- dfun.Eq.(Foo *)@(Foo Char#) = <wurble>[d2/d.eq.a]
- d1 = dfun.Eq.(Foo *)@(Foo Char#)
-
-The definition of dfun.Eq.(Foo *)@(Foo Char#) uses d2!!! So it must
-come after the definition of dfun.Eq.(Foo *)@Char#.
-AAARGH!
-
+ is_rec (CoNonRec _ _) = False
+ is_rec _ = True
+\end{code}
\begin{code}
-specBind :: [Id] -> PlainCoreBinding -> SpecM (PlainCoreBinding, UsageDetails)
+specBind :: Bool -> Bool -> [Id] -> [CallInstance]
+ -> PlainCoreBinding
+ -> SpecM (PlainCoreBinding, UsageDetails)
-- The UsageDetails returned has already had stuff to do with this group
-- of binders deleted; that's why new_binders is passed in.
-specBind new_binders (CoNonRec binder rhs)
- = specOneBinding new_binders (binder,rhs) `thenSM` \ ((binder,rhs), rhs_uds) ->
+specBind top_lev floating new_binders inst_cis (CoNonRec binder rhs)
+ = specOneBinding top_lev floating new_binders inst_cis (binder,rhs)
+ `thenSM` \ ((binder,rhs), rhs_uds) ->
returnSM (CoNonRec binder rhs, rhs_uds)
-specBind new_binders (CoRec pairs)
- = mapAndUnzipSM (specOneBinding new_binders) pairs `thenSM` \ (pairs, rhs_uds_s) ->
+specBind top_lev floating new_binders inst_cis (CoRec pairs)
+ = mapAndUnzipSM (specOneBinding top_lev floating new_binders inst_cis) pairs
+ `thenSM` \ (pairs, rhs_uds_s) ->
returnSM (CoRec pairs, unionUDList rhs_uds_s)
-specOneBinding :: [Id] -> (Id,PlainCoreExpr) -> SpecM ((Id,PlainCoreExpr), UsageDetails)
+specOneBinding :: Bool -> Bool -> [Id] -> [CallInstance]
+ -> (Id,PlainCoreExpr)
+ -> SpecM ((Id,PlainCoreExpr), UsageDetails)
-specOneBinding new_binders (binder, rhs)
+specOneBinding top_lev floating new_binders inst_cis (binder, rhs)
= lookupId binder `thenSM` \ blookup ->
specExpr rhs [] `thenSM` \ (rhs, rhs_uds) ->
let
specid_with_info = maybeToBool specinfo_maybe
Just spec_info = specinfo_maybe
+ -- If we have a SpecInfo stored in a SpecPragmaId binder
+ -- it will contain a SpecInfo with an explicit SpecId
+ -- We add the explicit ci to the usage details
+ -- Any ordinary cis for orig_id (there should only be one)
+ -- will be ignored later
+
pragma_uds
= if is_specid && specid_with_info then
- -- Have a SpecInfo stored in a SpecPragmaId binder
- -- This contains the SpecInfo for a specialisation pragma
- -- with an explicit SpecId specified
- -- We remove any cis for orig_id (there should only be one)
- -- and add the explicit ci to the usage details
let
(SpecInfo spec_tys _ spec_id) = spec_info
Just (orig_id, _) = isSpecId_maybe spec_id
else
emptyUDs
- (binds_here, final_uds) = dumpUDs rhs_uds new_binders []
+ -- For a local binding we dump the usage details, creating
+ -- any local dict bindings required
+ -- At the top-level the uds will be dumped in specBindAndScope
+ -- and the dict bindings made *global*
+
+ (local_dict_binds, final_uds)
+ = if not top_lev then
+ dumpUDs rhs_uds False floating inst_cis new_binders []
+ else
+ ([], rhs_uds)
in
case blookup of
Lifted lift_binder unlift_binder
mkTyConInstance liftDataCon [getIdUniType unlift_binder]
`thenSM` \ lift_uds ->
returnSM ((lift_binder,
- mkCoLetsNoUnboxed binds_here (liftExpr unlift_binder rhs)),
+ mkCoLetsNoUnboxed local_dict_binds (liftExpr unlift_binder rhs)),
final_uds `unionUDs` pragma_uds `unionUDs` lift_uds)
NoLift (CoVarAtom binder)
- -> returnSM ((binder, mkCoLetsNoUnboxed binds_here rhs),
+ -> returnSM ((binder, mkCoLetsNoUnboxed local_dict_binds rhs),
final_uds `unionUDs` pragma_uds)
\end{code}
%************************************************************************
\begin{code}
-instBind main_ids@(first_binder:other_binders) bind call_insts_for_main_ids
+instBind top_lev new_ids@(first_binder:other_binders) bind equiv_ciss inst_cis
+ | null equiv_ciss
+ = returnSM ([], emptyUDs, [])
+
| all same_overloading other_binders
- = let
- -- Collect up identical call instances
- equiv_classes = equivClasses cmpCI_tys call_insts_for_main_ids
- in
- -- For each equivalence class, build an instance
- mapAndUnzip3SM do_this_class equiv_classes `thenSM` \ (inst_binds, inst_uds_s, spec_infos) ->
+ = -- For each call_inst, build an instance
+ mapAndUnzip3SM do_this_class equiv_ciss
+ `thenSM` \ (inst_binds, inst_uds_s, spec_infos) ->
-- Add in the remaining UDs
returnSM (catMaybes inst_binds,
)
| otherwise -- Incompatible overloadings; see below by same_overloading
- = (if null (filter isUnboxedCI call_insts_for_main_ids)
- then (\ x y -> y) -- pprTrace "dumpCIs: not same overloading ... \n"
- else pprTrace "dumpCIs: not same overloading ... WITH UNBOXED TYPES!\n")
- (ppHang (ppBesides [ppStr "{", ppr PprDebug main_ids, ppStr "}"])
- 4 (ppAboves (map pprCI call_insts_for_main_ids)))
+ = (if not (null (filter isUnboxedCI (concat equiv_ciss)))
+ then pprTrace "dumpCIs: not same overloading ... WITH UNBOXED TYPES!\n"
+ else if top_lev
+ then pprTrace "dumpCIs: not same overloading ... top level \n"
+ else (\ x y -> y)
+ ) (ppHang (ppBesides [ppStr "{", ppr PprDebug new_ids, ppStr "}"])
+ 4 (ppAboves [ppAboves (map (pprUniType PprDebug . getIdUniType) new_ids),
+ ppAboves (map pprCI (concat equiv_ciss))]))
(returnSM ([], emptyUDs, []))
where
no_of_dicts = length class_tyvar_pairs
do_this_class equiv_cis
- | not (null explicit_cis)
- = if (length main_ids > 1 || length explicit_cis > 1) then
- -- ToDo: If this situation arose we would need to go through
- -- checking cis for each main_id and only creating an
- -- instantiation if we had no explicit_cis for that main_id
- pprPanic "Specialise:instBind:explicit call instances\n"
- (ppAboves [ppCat [ppStr "{", ppr PprDebug main_ids, ppStr "}"],
- ppAboves (map pprCI equiv_cis)])
- else
- getSwitchCheckerSM `thenSM` \ sw_chkr ->
- (if sw_chkr SpecialiseTrace then
- let
- SpecInfo spec_tys _ spec_id = explicit_spec_info
- in
- pprTrace "Specialising:"
- (ppHang (ppBesides [ppStr "{", ppr PprDebug main_ids, ppStr "}"])
- 4 (ppAboves [
- ppCat (ppStr "at types:" : [pprMaybeTy PprDebug ty | ty <- spec_tys]),
- ppCat [ppStr "spec ids:", ppr PprDebug [spec_id], ppStr "(explicit)"]]))
- else id) (
-
- returnSM (Nothing, emptyUDs, [explicit_spec_info])
- )
- | otherwise
- = mkOneInst (head equiv_cis) no_of_dicts main_ids bind
+ = mkOneInst do_cis explicit_cis no_of_dicts top_lev inst_cis new_ids bind
where
- explicit_cis = filter isExplicitCI equiv_cis
- [CallInstance _ _ _ _ (Just explicit_spec_info)] = explicit_cis
-
-
+ (explicit_cis, normal_cis) = partition isExplicitCI equiv_cis
+ do_cis = head (normal_cis ++ explicit_cis)
+ -- must choose a normal_cis in preference since dict_args will
+ -- not be defined for an explicit_cis
+
-- same_overloading tests whether the types of all the binders
-- are "compatible"; ie have the same type and dictionary abstractions
-- Almost always this is the case, because a recursive group is abstracted
\begin{code}
mkOneInst :: CallInstance
+ -> [CallInstance] -- Any explicit cis for this inst
-> Int -- No of dicts to specialise
+ -> Bool -- Top level binders?
+ -> [CallInstance] -- Instantiated call insts for binders
-> [Id] -- New binders
-> PlainCoreBinding -- Unprocessed
-> SpecM (Maybe PlainCoreBinding, -- Instantiated version of input
UsageDetails,
- [SpecInfo] -- One for each id in the original binding
+ [Maybe SpecInfo] -- One for each id in the original binding
)
-mkOneInst (CallInstance _ spec_tys dict_args _ _) no_of_dicts_to_specialise main_ids orig_bind
- = ASSERT (no_of_dicts_to_specialise == length dict_args)
- newSpecIds main_ids spec_tys no_of_dicts_to_specialise copy_inline_info
+mkOneInst do_cis@(CallInstance _ spec_tys dict_args _ _) explicit_cis
+ no_of_dicts_to_specialise top_lev inst_cis new_ids orig_bind
+ = getSwitchCheckerSM `thenSM` \ sw_chkr ->
+ newSpecIds new_ids spec_tys no_of_dicts_to_specialise
`thenSM` \ spec_ids ->
newTyVars (length [() | Nothing <- spec_tys]) `thenSM` \ poly_tyvars ->
let
args :: [PlainCoreArg]
args = map TypeArg arg_tys ++ dict_args
- (one_spec_id:_) = spec_ids
+ (new_id:_) = new_ids
+ (spec_id:_) = spec_ids
- do_bind (CoNonRec binder rhs)
- = do_one_rhs rhs `thenSM` \ (rhs, rhs_uds) ->
- returnSM (CoNonRec one_spec_id rhs, rhs_uds)
+ do_bind (CoNonRec orig_id rhs)
+ = do_one_rhs (spec_id, new_id, (orig_id,rhs))
+ `thenSM` \ (maybe_spec, rhs_uds, spec_info) ->
+ case maybe_spec of
+ Just (spec_id, rhs) -> returnSM (Just (CoNonRec spec_id rhs), rhs_uds, [spec_info])
+ Nothing -> returnSM (Nothing, rhs_uds, [spec_info])
do_bind (CoRec pairs)
- = mapAndUnzipSM do_one_rhs [rhs | (_,rhs) <- pairs] `thenSM` \ (rhss, rhss_uds_s) ->
- returnSM (CoRec (spec_ids `zip` rhss), unionUDList rhss_uds_s)
-
- -- Apply the specialiser to (orig_rhs t1 a t3 d1 d2)
- do_one_rhs orig_rhs = specExpr orig_rhs args `thenSM` \ (inst_rhs, inst_uds) ->
- let
- (binds_here, final_uds) = dumpUDs inst_uds main_ids []
- -- NB: main_ids!! not spec_ids!! Why? Because the free-var
- -- stuff knows nowt about spec_ids; it'll just have the
- -- original polymorphic main_ids as free. Belgh
- in
- returnSM (mkCoLetsNoUnboxed binds_here (mkCoTyLam poly_tyvars inst_rhs),
- final_uds)
+ = mapAndUnzip3SM do_one_rhs (zip3 spec_ids new_ids pairs)
+ `thenSM` \ (maybe_pairs, rhss_uds_s, spec_infos) ->
+ returnSM (Just (CoRec (catMaybes maybe_pairs)),
+ unionUDList rhss_uds_s, spec_infos)
+
+ do_one_rhs (spec_id, new_id, (orig_id, orig_rhs))
+
+ -- Avoid duplicating a spec which has already been created ...
+ -- This can arise in a CoRec involving a dfun for which a
+ -- a specialised instance has been created but specialisation
+ -- "required" by one of the other Ids in the CoRec
+ | top_lev && maybeToBool lookup_orig_spec
+ = (if sw_chkr SpecialiseTrace
+ then trace_nospec " Exists: " exists_id
+ else id) (
+
+ returnSM (Nothing, emptyUDs, Nothing)
+ )
+
+ -- Check for a (single) explicit call instance for this id
+ | not (null explicit_cis_for_this_id)
+ = ASSERT (length explicit_cis_for_this_id == 1)
+ (if sw_chkr SpecialiseTrace
+ then trace_nospec " Explicit: " explicit_id
+ else id) (
+
+ returnSM (Nothing, tickSpecInsts emptyUDs, Just explicit_spec_info)
+ )
+
+ -- Apply the specialiser to (orig_rhs t1 a t3 d1 d2)
+ | otherwise
+ = ASSERT (no_of_dicts_to_specialise == length dict_args)
+ specExpr orig_rhs args `thenSM` \ (inst_rhs, inst_uds) ->
+ let
+ -- For a local binding we dump the usage details, creating
+ -- any local dict bindings required
+ -- At the top-level the uds will be dumped in specBindAndScope
+ -- and the dict bindings made *global*
+
+ (local_dict_binds, final_uds)
+ = if not top_lev then
+ dumpUDs inst_uds False False inst_cis new_ids []
+ else
+ ([], inst_uds)
+
+ spec_info = Just (SpecInfo spec_tys no_of_dicts_to_specialise spec_id)
+ in
+ if isUnboxedDataType (getIdUniType spec_id) then
+ ASSERT (null poly_tyvars)
+ liftId spec_id `thenSM` \ (lift_spec_id, unlift_spec_id) ->
+ mkTyConInstance liftDataCon [getIdUniType unlift_spec_id]
+ `thenSM` \ lift_uds ->
+ returnSM (Just (lift_spec_id,
+ mkCoLetsNoUnboxed local_dict_binds (liftExpr unlift_spec_id inst_rhs)),
+ tickSpecInsts (final_uds `unionUDs` lift_uds), spec_info)
+ else
+ returnSM (Just (spec_id,
+ mkCoLetsNoUnboxed local_dict_binds (mkCoTyLam poly_tyvars inst_rhs)),
+ tickSpecInsts final_uds, spec_info)
+ where
+ lookup_orig_spec = lookupSpecEnv (getIdSpecialisation orig_id) arg_tys
+ Just (exists_id, _, _) = lookup_orig_spec
+
+ explicit_cis_for_this_id = filter (isCIofTheseIds [new_id]) explicit_cis
+ [CallInstance _ _ _ _ (Just explicit_spec_info)] = explicit_cis_for_this_id
+ SpecInfo _ _ explicit_id = explicit_spec_info
+
+ trace_nospec str spec_id
+ = pprTrace str
+ (ppCat [ppr PprDebug new_id, ppInterleave ppNil (map pp_ty arg_tys),
+ ppStr "==>", ppr PprDebug spec_id])
in
- getSwitchCheckerSM `thenSM` \ sw_chkr ->
(if sw_chkr SpecialiseTrace then
pprTrace "Specialising:"
- (ppHang (ppBesides [ppStr "{", ppr PprDebug main_ids, ppStr "}"])
- 4 (ppAboves [
- ppBesides [ppStr "with args: ", ppInterleave ppNil (map pp_arg args)],
- ppBesides [ppStr "spec ids: ", ppr PprDebug spec_ids]]))
+ (ppHang (ppBesides [ppStr "{", ppr PprDebug new_ids, ppStr "}"])
+ 4 (ppAboves [
+ ppBesides [ppStr "types: ", ppInterleave ppNil (map pp_ty arg_tys)],
+ if isExplicitCI do_cis then ppNil else
+ ppBesides [ppStr "dicts: ", ppInterleave ppNil (map pp_dict dict_args)],
+ ppBesides [ppStr "specs: ", ppr PprDebug spec_ids]]))
else id) (
- do_bind orig_bind `thenSM` \ (inst_bind, inst_uds) ->
+ do_bind orig_bind `thenSM` \ (maybe_inst_bind, inst_uds, spec_infos) ->
- returnSM (Just inst_bind,
- inst_uds,
- [SpecInfo spec_tys no_of_dicts_to_specialise spec_id | spec_id <- spec_ids]
- )
+ returnSM (maybe_inst_bind, inst_uds, spec_infos)
)
where
- -- debugging
- pp_arg (ValArg a) = ppBesides [ppLparen, ppStr "ValArg ", ppr PprDebug a, ppRparen]
- pp_arg (TypeArg t) = ppBesides [ppLparen, ppStr "TypeArg ", ppr PprDebug t, ppRparen]
+ pp_dict (ValArg d) = ppr PprDebug d
+ pp_ty t = pprParendUniType PprDebug t
do_the_wotsit (tyvar:tyvars) Nothing = (tyvars, mkTyVarTy tyvar)
do_the_wotsit tyvars (Just ty) = (tyvars, ty)
- copy_inline_info new_id old_uf_info = addIdUnfolding new_id old_uf_info
\end{code}
%************************************************************************
%* *
%************************************************************************
-@getIdOverloading@ grabs the type of an Id, and returns a
-list of its polymorphic variables, and the initial segment of
-its ThetaType, in which the classes constrain only type variables.
-For example, if the Id's type is
-
- forall a,b,c. Eq a -> Ord [a] -> tau
-
-we'll return
-
- ([a,b,c], [(Eq,a)])
-
-This seems curious at first. For a start, the type above looks odd,
-because we usually only have dictionary args whose types are of
-the form (C a) where a is a type variable. But this doesn't hold for
-the functions arising from instance decls, which sometimes get
-arguements with types of form (C (T a)) for some type constructor T.
-
-Should we specialise wrt this compound-type dictionary? This is
-a heuristic judgement, as indeed is the fact that we specialise wrt
-only dictionaries. We choose *not* to specialise wrt compound dictionaries
-because at the moment the only place they show up is in instance decls,
-where they are simply plugged into a returned dictionary. So nothing is
-gained by specialising wrt them.
-
-\begin{code}
-getIdOverloading :: Id
- -> ([TyVarTemplate], [(Class,TyVarTemplate)])
-getIdOverloading id
- = (tyvars, tyvar_part_of theta)
- where
- (tyvars, theta, _) = splitType (getIdUniType id)
-
- tyvar_part_of [] = []
- tyvar_part_of ((clas,ty) : theta) = case getTyVarTemplateMaybe ty of
- Nothing -> []
- Just tyvar -> (clas, tyvar) : tyvar_part_of theta
-\end{code}
-
\begin{code}
mkCallInstance :: Id
-> Id
-> [(PlainCoreArg, UsageDetails, PlainCoreExpr -> PlainCoreExpr)]
-> SpecM UsageDetails
-mkCallInstance old_id new_id args
- = recordCallInst old_id args `thenSM` \ record_call ->
- case record_call of
- Nothing -- No specialisation required
- -> -- pprTrace "NoSpecReqd:"
- -- (ppCat [ppr PprDebug old_id, ppStr "at", ppCat (map (ppr PprDebug) args)])
+mkCallInstance id new_id []
+ = returnSM emptyUDs
- (returnSM call_fv_uds)
+mkCallInstance id new_id args
- Just (True, spec_tys, dict_args, rest_args) -- Requires specialisation: spec already exists
- -> -- pprTrace "SpecExists:"
- -- (ppCat [ppr PprDebug old_id, ppStr " at ", ppCat (map (ppr PprDebug) args),
- -- ppBesides [ppStr "(", ppCat [pprMaybeTy PprDebug ty | ty <- spec_tys],
- -- ppCat [ppr PprDebug dict | dict <- dict_args],
- -- ppStr ")"]])
+ -- No specialised versions for "error" and friends are req'd.
+ -- This is a special case in core lint etc.
- (returnSM call_fv_uds)
+ | isBottomingId id
+ = returnSM emptyUDs
- Just (False, spec_tys, dict_args, rest_args) -- Requires specialisation: record call-instance
- -> -- pprTrace "CallInst:"
- -- (ppCat [ppr PprDebug old_id, ppStr " at ", ppCat (map (ppr PprDebug) args),
- -- ppBesides [ppStr "(", ppCat [pprMaybeTy PprDebug ty | ty <- spec_tys],
- -- ppCat [ppr PprDebug dict | dict <- dict_args],
- -- ppStr ")"]])
-
- (returnSM (singleCI new_id spec_tys dict_args `unionUDs` call_fv_uds))
- where
- call_fv_uds = singleFvUDs (CoVarAtom new_id) `unionUDs` unionUDList [uds | (_,uds,_) <- args]
-\end{code}
-
-\begin{code}
-recordCallInst :: Id
- -> [(PlainCoreArg, UsageDetails, PlainCoreExpr -> PlainCoreExpr)]
- -> SpecM (Maybe (Bool, [Maybe UniType], [PlainCoreArg],
- [(PlainCoreArg, UsageDetails, PlainCoreExpr -> PlainCoreExpr)]))
+ -- No call instances for SuperDictSelIds
+ -- These are a special case in mkCall
-recordCallInst id [] -- No args => no call instance
- = returnSM Nothing
-
-recordCallInst id args
- | isBottomingId id -- No specialised versions for "error" and friends are req'd.
- = returnSM Nothing -- This is a special case in core lint etc.
-
- -- No call instances for Ids associated with a Class declaration,
- -- i.e. default methods, super-dict selectors and class ops.
- -- We rely on the instance declarations to provide suitable specialisations.
- -- These are dealt with in mkCall.
-
- | isDefaultMethodId id
- = returnSM Nothing
-
| maybeToBool (isSuperDictSelId_maybe id)
- = returnSM Nothing
-
- | isClassOpId id
- = returnSM Nothing
+ = returnSM emptyUDs
- -- Finally, the default case ...
+ -- There are also no call instances for ClassOpIds
+ -- However, we need to process it to get any second-level call
+ -- instances for a ConstMethodId extracted from its SpecEnv
| otherwise
= getSwitchCheckerSM `thenSM` \ sw_chkr ->
spec_unboxed = sw_chkr SpecialiseUnboxed
spec_all = sw_chkr SpecialiseAll
- (tyvar_tmpls, class_tyvar_pairs) = getIdOverloading id
- constraint_vec = mkConstraintVector tyvar_tmpls class_tyvar_pairs
+ (tyvars, class_tyvar_pairs) = getIdOverloading id
- arg_res = take_type_args tyvar_tmpls class_tyvar_pairs args
+ arg_res = take_type_args tyvars class_tyvar_pairs args
enough_args = maybeToBool arg_res
- (Just (inst_tys, dict_args, rest_args)) = arg_res
- spec_tys = specialiseCallTys spec_all spec_unboxed spec_overloading
- constraint_vec inst_tys
+ (Just (tys, dicts, rest_args)) = arg_res
- spec_exists = maybeToBool (lookupSpecEnv
- (getIdSpecialisation id)
- inst_tys)
+ record_spec id tys
+ = (record, lookup, spec_tys)
+ where
+ spec_tys = specialiseCallTys spec_all spec_unboxed spec_overloading
+ (mkConstraintVector id) tys
- -- We record the call instance if there is some meaningful
- -- type which we want to specialise on ...
- record_spec = any (not . isTyVarTy) (catMaybes spec_tys)
+ record = any (not . isTyVarTy) (catMaybes spec_tys)
+
+ lookup = lookupSpecEnv (getIdSpecialisation id) tys
in
if (not enough_args) then
pprPanic "Specialise:recordCallInst: Unsaturated Type & Dict Application:\n\t"
(ppCat [ppr PprDebug id, ppr PprDebug [arg | (arg,_,_) <- args] ])
else
- if record_spec then
- returnSM (Just (spec_exists, spec_tys, dict_args, rest_args))
- else
- returnSM Nothing
+ case record_spec id tys of
+ (False, _, _)
+ -> -- pprTrace "CallInst:NotReqd\n"
+ -- (ppCat [ppr PprDebug id, ppCat (map (ppr PprDebug) args)])
+ (returnSM emptyUDs)
+
+ (True, Nothing, spec_tys)
+ -> if isClassOpId id then -- No CIs for class ops, dfun will give SPEC inst
+ returnSM emptyUDs
+ else
+ -- pprTrace "CallInst:Reqd\n"
+ -- (ppAboves [ppCat [ppr PprDebug id, ppCat (map (ppr PprDebug) args)],
+ -- ppCat [ppStr "CI", ppCat (map (pprMaybeTy PprDebug) spec_tys),
+ -- ppCat (map (ppr PprDebug) dicts)]])
+ (returnSM (singleCI new_id spec_tys dicts))
+
+ (True, Just (spec_id, tys_left, toss), _)
+ -> if maybeToBool (isConstMethodId_maybe spec_id) then
+ -- If we got a const method spec_id see if further spec required
+ -- NB: const method is top-level so spec_id will not be cloned
+ case record_spec spec_id tys_left of
+ (False, _, _)
+ -> -- pprTrace "CallInst:Exists\n"
+ -- (ppAboves [ppCat [ppr PprDebug id, ppCat (map (ppr PprDebug) args)],
+ -- ppCat [ppStr "->", ppr PprDebug spec_id,
+ -- ppr PprDebug (tys_left ++ drop toss dicts)]])
+ (returnSM emptyUDs)
+
+ (True, Nothing, spec_tys)
+ -> -- pprTrace "CallInst:Exists:Reqd\n"
+ -- (ppAboves [ppCat [ppr PprDebug id, ppCat (map (ppr PprDebug) args)],
+ -- ppCat [ppStr "->", ppr PprDebug spec_id,
+ -- ppr PprDebug (tys_left ++ drop toss dicts)],
+ -- ppCat [ppStr "CI", ppCat (map (pprMaybeTy PprDebug) spec_tys),
+ -- ppCat (map (ppr PprDebug) (drop toss dicts))]])
+ (returnSM (singleCI spec_id spec_tys (drop toss dicts)))
+
+ (True, Just (spec_spec_id, tys_left_left, toss_toss), _)
+ -> -- pprTrace "CallInst:Exists:Exists\n"
+ -- (ppAboves [ppCat [ppr PprDebug id, ppCat (map (ppr PprDebug) args)],
+ -- ppCat [ppStr "->", ppr PprDebug spec_id,
+ -- ppr PprDebug (tys_left ++ drop toss dicts)],
+ -- ppCat [ppStr "->", ppr PprDebug spec_spec_id,
+ -- ppr PprDebug (tys_left_left ++ drop (toss + toss_toss) dicts)]])
+ (returnSM emptyUDs)
+
+ else
+ -- pprTrace "CallInst:Exists\n"
+ -- (ppAboves [ppCat [ppr PprDebug id, ppCat (map (ppr PprDebug) args)],
+ -- ppCat [ppStr "->", ppr PprDebug spec_id,
+ -- ppr PprDebug (tys_left ++ drop toss dicts)]])
+ (returnSM emptyUDs)
take_type_args (_:tyvars) class_tyvar_pairs ((TypeArg ty,_,_):args)
\begin{code}
mkCall :: Id
-> [(PlainCoreArg, UsageDetails, PlainCoreExpr -> PlainCoreExpr)]
- -> SpecM PlainCoreExpr
-
-mkCall main_id args
- | isDefaultMethodId main_id
- && any isUnboxedDataType ty_args
- -- No specialisations for default methods
- -- Unboxed calls to DefaultMethodIds should not occur
- -- The method should be specified in the instance declaration
- = panic "Specialise:mkCall:DefaultMethodId"
+ -> SpecM (Bool, PlainCoreExpr)
- | maybeToBool (isSuperDictSelId_maybe main_id)
+mkCall new_id args
+ | maybeToBool (isSuperDictSelId_maybe new_id)
&& any isUnboxedDataType ty_args
-- No specialisations for super-dict selectors
-- Specialise unboxed calls to SuperDictSelIds by extracting
-- the super class dictionary directly form the super class
-- NB: This should be dead code since all uses of this dictionary should
- -- have been specialised. We only do this to keep keep core-lint happy.
+ -- have been specialised. We only do this to keep core-lint happy.
= let
- Just (_, super_class) = isSuperDictSelId_maybe main_id
+ Just (_, super_class) = isSuperDictSelId_maybe new_id
super_dict_id = case lookupClassInstAtSimpleType super_class (head ty_args) of
Nothing -> panic "Specialise:mkCall:SuperDictId"
Just id -> id
in
- returnSM (CoVar super_dict_id)
+ returnSM (False, CoVar super_dict_id)
| otherwise
- = case lookupSpecEnv (getIdSpecialisation main_id) ty_args of
- Nothing -> checkUnspecOK main_id ty_args (
- returnSM unspec_call
+ = case lookupSpecEnv (getIdSpecialisation new_id) ty_args of
+ Nothing -> checkUnspecOK new_id ty_args (
+ returnSM (False, unspec_call)
)
- Just (spec_id, tys_left, dicts_to_toss)
- -> checkSpecOK main_id ty_args spec_id tys_left (
- let
+ Just spec_1_details@(spec_id_1, tys_left_1, dicts_to_toss_1)
+ -> let
+ -- It may be necessary to specialsie a constant method spec_id again
+ (spec_id, tys_left, dicts_to_toss) =
+ case (maybeToBool (isConstMethodId_maybe spec_id_1),
+ lookupSpecEnv (getIdSpecialisation spec_id_1) tys_left_1) of
+ (False, _ ) -> spec_1_details
+ (True, Nothing) -> spec_1_details
+ (True, Just (spec_id_2, tys_left_2, dicts_to_toss_2))
+ -> (spec_id_2, tys_left_2, dicts_to_toss_1 + dicts_to_toss_2)
+
args_left = toss_dicts dicts_to_toss val_args
in
-
- -- The resulting spec_id may be an unboxed constant method
- -- eg: pi Double# d.Floating.Double# ==> pi.Double#
- -- Since it is a top level id pi.Double# will have been lifted.
- -- We must add code to unlift such a spec_id
+ checkSpecOK new_id ty_args spec_id tys_left (
+
+ -- The resulting spec_id may be a top-level unboxed value
+ -- This can arise for:
+ -- 1) constant method values
+ -- eq: class Num a where pi :: a
+ -- instance Num Double# where pi = 3.141#
+ -- 2) specilised overloaded values
+ -- eq: i1 :: Num a => a
+ -- i1 Int# d.Num.Int# ==> i1.Int#
+ -- These top level defns should have been lifted.
+ -- We must add code to unlift such a spec_id.
if isUnboxedDataType (getIdUniType spec_id) then
ASSERT (null tys_left && null args_left)
- if isConstMethodId spec_id then
- liftId spec_id `thenSM` \ (lifted_spec_id, unlifted_spec_id) ->
- returnSM (bindUnlift lifted_spec_id unlifted_spec_id
- (CoVar unlifted_spec_id))
+ if toplevelishId spec_id then
+ liftId spec_id `thenSM` \ (lift_spec_id, unlift_spec_id) ->
+ returnSM (True, bindUnlift lift_spec_id unlift_spec_id
+ (CoVar unlift_spec_id))
else
- -- ToDo: Are there other cases where we have an unboxed spec_id ???
- pprPanic "Specialise:mkCall: unboxed spec_id ...\n"
- (ppCat [ppr PprDebug main_id,
+ pprPanic "Specialise:mkCall: unboxed spec_id not top-level ...\n"
+ (ppCat [ppr PprDebug new_id,
ppInterleave ppNil (map (pprParendUniType PprDebug) ty_args),
ppStr "==>",
ppr PprDebug spec_id])
- else
+ else
let
(vals_left, _, unlifts_left) = unzip3 args_left
applied_tys = mkCoTyApps (CoVar spec_id) tys_left
applied_vals = applyToArgs applied_tys vals_left
in
- returnSM (applyBindUnlifts unlifts_left applied_vals)
+ returnSM (True, applyBindUnlifts unlifts_left applied_vals)
)
where
(tys_and_vals, _, unlifts) = unzip3 args
- unspec_call = applyBindUnlifts unlifts (applyToArgs (CoVar main_id) tys_and_vals)
+ unspec_call = applyBindUnlifts unlifts (applyToArgs (CoVar new_id) tys_and_vals)
-- ty_args is the types at the front of the arg list
get ((TypeArg ty,_,_) : args) = (ty : tys, rest) where (tys,rest) = get args
get args = ([], args)
+
-- toss_dicts chucks away dict args, checking that they ain't types!
- toss_dicts 0 args = args
+ toss_dicts 0 args = args
toss_dicts n ((ValArg _,_,_) : args) = toss_dicts (n-1) args
+
\end{code}
\begin{code}
case record_inst of
Nothing -- No TyCon instance
-> -- pprTrace "NoTyConInst:"
- -- (ppCat [ppr PprDebug tycon, ppStr "at",
- -- ppr PprDebug con, ppCat (map (ppr PprDebug) tys)])
+ -- (ppCat [ppr PprDebug tycon, ppStr "at",
+ -- ppr PprDebug con, ppCat (map (ppr PprDebug) tys)])
(returnSM (singleConUDs con))
Just spec_tys -- Record TyCon instance
-> -- pprTrace "TyConInst:"
- -- (ppCat [ppr PprDebug tycon, ppStr "at",
- -- ppr PprDebug con, ppCat (map (ppr PprDebug) tys),
- -- ppBesides [ppStr "(",
- -- ppCat [pprMaybeTy PprDebug ty | ty <- spec_tys],
- -- ppStr ")"]])
+ -- (ppCat [ppr PprDebug tycon, ppStr "at",
+ -- ppr PprDebug con, ppCat (map (ppr PprDebug) tys),
+ -- ppBesides [ppStr "(",
+ -- ppCat [pprMaybeTy PprDebug ty | ty <- spec_tys],
+ -- ppStr ")"]])
(returnSM (singleTyConI tycon spec_tys `unionUDs` singleConUDs con))
where
tycon = getDataConTyCon con
tys)
in
-- pprTrace "ConSpecExists?: "
- -- (ppAboves [ppStr (if spec_exists then "True" else "False"),
- -- ppr PprShowAll con, ppCat (map (ppr PprDebug) tys)])
+ -- (ppAboves [ppStr (if spec_exists then "True" else "False"),
+ -- ppr PprShowAll con, ppCat (map (ppr PprDebug) tys)])
(if (not spec_exists && do_tycon_spec)
then returnSM (Just spec_tys)
else returnSM Nothing)
\end{code}
-\begin{code}
-{- UNUSED: create specilaised constructor calls in Core
-mkConstrCall :: PlainCoreAtom -> [UniType] -- This constructor at these types
- -> SpecM (Id, [UniType]) -- The specialised constructor and reduced types
-
-mkConstrCall (CoVarAtom con_id) tys
- = case lookupSpecEnv (getIdSpecialisation con_id) tys of
- Nothing -> checkUnspecOK con_id tys (
- returnSM (con_id, tys)
- )
- Just (spec_id, tys_left, 0)
- -> checkSpecOK con_id tys spec_id tys_left (
- returnSM (spec_id, tys_left)
- )
--}
-\end{code}
-
%************************************************************************
%* *
\subsection[monad-Specialise]{Monad used in specialisation}
newSpecIds :: [Id] -- The id of which to make a specialised version
-> [Maybe UniType] -- Specialise to these types
-> Int -- No of dicts to specialise
- -> (Id -> UnfoldingDetails -> Id) -- copies any arity info required
-> SpecM [Id]
-newSpecIds main_ids maybe_tys dicts_to_ignore copy_id_info sw_chkr tvenv idenv us
- = spec_ids
+newSpecIds new_ids maybe_tys dicts_to_ignore sw_chkr tvenv idenv us
+ = [ mkSpecId uniq id maybe_tys (spec_id_ty id) (selectIdInfoForSpecId id)
+ | (id,uniq) <- new_ids `zip` uniqs ]
where
- uniqs = getSUniques (length main_ids) us
+ uniqs = getSUniques (length new_ids) us
spec_id_ty id = specialiseTy (getIdUniType id) maybe_tys dicts_to_ignore
- spec_ids = [ copy_id_info (mkSpecId uniq id maybe_tys (spec_id_ty id) noIdInfo) (getIdUnfolding id)
- | (id,uniq) <- main_ids `zip` uniqs
- ]
newTyVars :: Int -> SpecM [TyVar]
newTyVars n sw_chkr tvenv idenv us
uniqs = getSUniques n us
\end{code}
-@cloneLambdaOrCaseBinders@ and @cloneLetrecBinders@ take a bunch of
+@cloneLambdaOrCaseBinders@ and @cloneLetBinders@ take a bunch of
binders, and build ``clones'' for them. The clones differ from the
originals in three ways:
(a) they have a fresh unique
(b) they have the current type environment applied to their type
- (c) for letrec binders which have been specialised to unboxed values
+ (c) for Let binders which have been specialised to unboxed values
the clone will have a lifted type
As well as returning the list of cloned @Id@s they also return a list of
where
new_id = applyTypeEnvToId tvenv (mkIdWithNewUniq old_id uniq)
-cloneLetrecBinders :: [Id] -- Old binders
- -> SpecM ([Id], [CloneInfo]) -- New ones
+cloneLetBinders :: Bool -- Top level ?
+ -> Bool -- Recursice
+ -> [Id] -- Old binders
+ -> SpecM ([Id], [CloneInfo]) -- New ones
-cloneLetrecBinders old_ids sw_chkr tvenv idenv us
+cloneLetBinders top_lev is_rec old_ids sw_chkr tvenv idenv us
= let
uniqs = getSUniques (2 * length old_ids) us
in
clone_them [] [] = []
clone_them (old_id:olds) (u1:u2:uniqs)
- | toplevelishId old_id
+ | top_lev
= (old_id,
NoLift (CoVarAtom old_id)) : clone_rest
-- (c) the thing is polymorphic so no need to subst
| otherwise
- = if (isUnboxedDataType new_ty && not (isUnboxedDataType old_ty))
+ = if (is_rec && isUnboxedDataType new_ty && not (isUnboxedDataType old_ty))
then (lifted_id,
Lifted lifted_id unlifted_id) : clone_rest
else (new_id,
bindIds olds news specm sw_chkr tvenv idenv us
= specm sw_chkr tvenv (growIdEnvList idenv (zip olds news)) us
-bindSpecIds :: [Id] -- Old
- -> [(CloneInfo)] -- New
- -> [[SpecInfo]] -- Corresponding specialisations
- -- Each sub-list corresponds to a different type,
- -- and contains one spec_info for each id
+bindSpecIds :: [Id] -- Old
+ -> [(CloneInfo)] -- New
+ -> [[Maybe SpecInfo]] -- Corresponding specialisations
+ -- Each sub-list corresponds to a different type,
+ -- and contains one Maybe spec_info for each id
-> SpecM thing
-> SpecM thing
add_spec_info lifted
= lifted -- no specialised instances for unboxed lifted values
- spec_infos_this_id = map head spec_infos
+ spec_infos_this_id = catMaybes (map head spec_infos)
spec_infos_rest = map tail spec_infos
-{- UNUSED: creating specialised constructors
-bindConIds :: [Id] -- Old constructors
- -> [[SpecInfo]] -- Corresponding specialisations to be added
- -- Each sub-list corresponds to one constructor, and
- -- gives all its specialisations
- -> SpecM thing
- -> SpecM thing
-
-bindConIds ids spec_infos specm sw_chkr tvenv idenv us
- = specm sw_chkr tvenv (growIdEnvList idenv id_to_newspec) us
- where
- id_to_newspec = mk_id_to_newspec ids spec_infos
-
- -- The important thing here is that we are *lazy* in spec_infos
- mk_id_to_newspec [] _ = []
- mk_id_to_newspec (id:rest_ids) spec_infos
- = (id, CoVarAtom id_with_spec) :
- mk_id_to_newspec rest_ids spec_infos_rest
- where
- id_with_spec = id `addIdSpecialisation` (mkSpecEnv spec_infos_this_id)
- spec_infos_this_id = head spec_infos
- spec_infos_rest = tail spec_infos
--}
bindTyVar :: TyVar -> UniType -> SpecM thing -> SpecM thing
import AbsPrel ( unpackCStringId, unpackCString2Id, stringTy,
integerTy, rationalTy, ratioDataCon,
PrimOp(..), -- For Int2IntegerOp etc
- integerZeroId, integerPlusOneId, integerMinusOneId
+ integerZeroId, integerPlusOneId,
+ integerPlusTwoId, integerMinusOneId
IF_ATTACK_PRAGMAS(COMMA mkListTy COMMA charTy)
IF_ATTACK_PRAGMAS(COMMA tagOf_PrimOp)
IF_ATTACK_PRAGMAS(COMMA pprPrimOp)
-- Integer literals!
| i == 0 = returnSUs (StgVarAtom integerZeroId, emptyBag)
| i == 1 = returnSUs (StgVarAtom integerPlusOneId, emptyBag)
+ | i == 2 = returnSUs (StgVarAtom integerPlusTwoId, emptyBag)
| i == (-1) = returnSUs (StgVarAtom integerMinusOneId, emptyBag)
| otherwise
import Bag(Bag)
import CmdLineOpts(GlobalSwitch)
import E(E)
-import HsBinds(Binds)
+import GenSpecEtc(SignatureInfo)
+import HsBinds(Binds, MonoBinds, Sig)
import HsPat(InPat, TypecheckedPat)
import Id(Id)
import LIE(LIE)
import Subst(Subst)
import TcMonad(TcResult)
import UniType(UniType)
+doSpecPragma :: E -> (Name -> Id) -> SignatureInfo -> (GlobalSwitch -> Bool) -> [UniType] -> Subst -> SplitUniqSupply -> Bag (PprStyle -> Int -> Bool -> PrettyRep) -> SrcLoc -> TcResult (MonoBinds Id TypecheckedPat, LIE)
tcLocalBindsAndThen :: E -> (Binds Id TypecheckedPat -> a -> a) -> Binds Name (InPat Name) -> (E -> (GlobalSwitch -> Bool) -> [UniType] -> Subst -> SplitUniqSupply -> Bag (PprStyle -> Int -> Bool -> PrettyRep) -> SrcLoc -> TcResult (a, LIE, b)) -> (GlobalSwitch -> Bool) -> [UniType] -> Subst -> SplitUniqSupply -> Bag (PprStyle -> Int -> Bool -> PrettyRep) -> SrcLoc -> TcResult (a, LIE, b)
+tcSigs :: E -> [(Name, Id)] -> [Sig Name] -> (GlobalSwitch -> Bool) -> [UniType] -> Subst -> SplitUniqSupply -> Bag (PprStyle -> Int -> Bool -> PrettyRep) -> SrcLoc -> TcResult [SignatureInfo]
tcTopBindsAndThen :: E -> (Binds Id TypecheckedPat -> a -> a) -> Binds Name (InPat Name) -> (E -> (GlobalSwitch -> Bool) -> [UniType] -> Subst -> SplitUniqSupply -> Bag (PprStyle -> Int -> Bool -> PrettyRep) -> SrcLoc -> TcResult (a, LIE, b)) -> (GlobalSwitch -> Bool) -> [UniType] -> Subst -> SplitUniqSupply -> Bag (PprStyle -> Int -> Bool -> PrettyRep) -> SrcLoc -> TcResult (a, LIE, b)
#include "HsVersions.h"
module TcBinds (
- tcTopBindsAndThen, tcLocalBindsAndThen
+ tcTopBindsAndThen, tcLocalBindsAndThen,
+ tcSigs, doSpecPragma
) where
--IMPORT_Trace -- ToDo:rm (debugging)
genBinds top_level e bind' lie lve sig_info `thenTc` \ (binds', lie, lve) ->
-- Add bindings corresponding to SPECIALIZE pragmas in the code
- mapAndUnzipTc (doSpecPragma e lve) (get_spec_pragmas sig_info)
+ mapAndUnzipTc (doSpecPragma e (assoc "doSpecPragma" lve))
+ (get_spec_pragmas sig_info)
`thenTc` \ (spec_binds_s, spec_lie_s) ->
returnTc (binds' `ThenBinds` (SingleBind (NonRecBind (
\end{verbatim}
\begin{code}
-doSpecPragma :: E -> LVE
+doSpecPragma :: E
+ -> (Name -> Id)
-> SignatureInfo
-> TcM (TypecheckedMonoBinds, LIE)
-doSpecPragma e lve (ValSpecInfo name spec_ty using src_loc)
+doSpecPragma e name_to_id (ValSpecInfo name spec_ty using src_loc)
= let
- main_id = assoc "doSpecPragma" lve name
- -- Get the parent Id; it should exist (renamer promises...).
+ main_id = name_to_id name -- Get the parent Id
main_id_ty = getIdUniType main_id
main_id_free_tyvars = extractTyVarsFromTy main_id_ty
where
rec_ce = getE_CE e
rec_tce = getE_TCE e
---FAKE: fake_E = mkE rec_tce rec_ce
tc_clas1 (ClassDecl context class_name
tyvar_name class_sigs def_methods pragmas src_loc)
-- suitable Ids for selectors and default methods.
babyTcMtoTcM
(tcClassSigs e tve rec_clas rec_class_op_inst_fn
- clas_tyvar class_sigs)
+ clas_tyvar defm_names class_sigs)
`thenTc` \ (ops, ops_gve, op_sel_ids, defm_ids) ->
-- Make the class object itself, producing clas::Class
ops_gve
))
where
+ defm_names = collectMonoBinders def_methods
+
-----------
mk_super_id clas (super_clas, uniq, ty) id_info
= mkSuperDictSelId uniq clas super_clas ty id_info
import TyVar(TyVarTemplate)
import UniType(UniType)
import UniqFM(UniqFM)
-tcClassSigs :: E -> UniqFM UniType -> Class -> (ClassOp -> SpecEnv) -> TyVarTemplate -> [Sig Name] -> (GlobalSwitch -> Bool) -> SplitUniqSupply -> Bag (PprStyle -> Int -> Bool -> PrettyRep) -> SrcLoc -> Baby_TcResult ([ClassOp], [(Name, Id)], [Id], [Id])
+tcClassSigs :: E -> UniqFM UniType -> Class -> (ClassOp -> SpecEnv) -> TyVarTemplate -> [Name] -> [Sig Name] -> (GlobalSwitch -> Bool) -> SplitUniqSupply -> Bag (PprStyle -> Int -> Bool -> PrettyRep) -> SrcLoc -> Baby_TcResult ([ClassOp], [(Name, Id)], [Id], [Id])
tcClassSigs :: E -> TVE -> Class -- Knot tying only!
-> (ClassOp -> SpecEnv) -- Ditto; the spec info for the class ops
-> TyVarTemplate -- The class type variable, used for error check only
+ -> [Name] -- Names with default methods
-> [RenamedClassOpSig]
-> Baby_TcM ([ClassOp], -- class ops
GVE, -- env for looking up the class ops
[Id], -- selector ids
[Id]) -- default-method ids
-tcClassSigs e tve rec_clas rec_classop_spec_fn clas_tyvar sigs
+tcClassSigs e tve rec_clas rec_classop_spec_fn clas_tyvar defm_names sigs
= mapB_Tc tc_sig sigs `thenB_Tc` \ stuff ->
let
(ops, op_gves, sel_ids, defm_ids) = unzip4 stuff
where
rec_ce = getE_CE e
rec_tce = getE_TCE e
---FAKE: fake_E = mkE rec_tce rec_ce
- tc_sig (ClassOpSig name@(ClassOpName op_uniq _ op_name tag) poly_ty pragmas src_loc)
+ tc_sig (ClassOpSig name@(ClassOpName op_uniq clas_name op_name tag) poly_ty pragmas src_loc)
= addSrcLocB_Tc src_loc (
tcPolyType rec_ce rec_tce tve poly_ty `thenB_Tc` \ local_ty ->
-
--- OLD: convoluted way to compute global_ty
--- let
--- (local_tyvar_tmpls, theta, tau) = splitType local_ty
--- in
--- -- Make new tyvars for each of the universally quantified type vars
--- copyTyVars (clas_tyvar:local_tyvar_tmpls)
--- `thenB_Tc` \ (inst_env, new_tyvars, _) ->
---
--- let -- Instantiate the tau type
--- full_theta = (rec_clas, (mkTyVarTemplateTy clas_tyvar)) : theta
--- full_rho = mkRhoTy full_theta tau
--- inst_full_rho = instantiateTy inst_env full_rho
--- (_, global_ty) = quantifyTy new_tyvars inst_full_rho
-
let
(local_tyvar_tmpls, theta, tau) = splitType local_ty
full_theta = (rec_clas, (mkTyVarTemplateTy clas_tyvar)) : theta
rec_op_id rec_defm_id
(rec_classop_spec_fn class_op)
pragmas `thenB_Tc` \ (op_info, defm_info) ->
-
+ let
+ -- the default method is error "No default ..." if there is no
+ -- default method code or the imported default method is bottoming.
+
+ error_defm = if isLocallyDefined clas_name then
+ name `notElem` defm_names
+ else
+ bottomIsGuaranteed (getInfo defm_info)
+ in
returnB_Tc (
mkClassOpId op_uniq rec_clas class_op global_ty op_info,
- mkDefaultMethodId d_uniq rec_clas class_op False{-do better later-} global_ty defm_info
+ mkDefaultMethodId d_uniq rec_clas class_op error_defm global_ty defm_info
)
) `thenB_Tc` \ (selector_id, default_method_id) ->
-- These two are only needed if there are pragmas to typecheck;
-- but there ain't since we are generating the code right here.
True {-yes, from_here-}
+ modname
NoInstancePragmas
mkGeneratedSrcLoc
clas
import AbsSyn -- the stuff being typechecked
-import AbsPrel {-( trueDataCon, falseDataCon, intDataCon, eRROR_ID,
- ltPrimDataCon, eqPrimDataCon, gtPrimDataCon,
- charPrimTy, intPrimTy, wordPrimTy, addrPrimTy,
- floatPrimTy, doublePrimTy
- )-}
-import PrimOps -- *********** ditto
+import AbsPrel
+import PrimOps
import AbsUniType ( getTyConDataCons, isEnumerationTyCon,
maybeSingleConstructorTyCon, --UNUSED: preludeClassDerivedFor,
anyway. We provide a command-line flag to say ``Don't bother''
(@OmitDerivedRead@).
-We just use the default methods for @showList@ and @readList@.
-
Also: ignoring all the infix-ery mumbo jumbo (ToDo)
The part of the Haskell report that deals with this (pages~147--151,
gen_Text_binds fixities omit_derived_read tycon
= if omit_derived_read
- then shows_prec
- else shows_prec `AndMonoBinds` reads_prec
+ then shows_prec `AndMonoBinds` show_list
+ else shows_prec `AndMonoBinds` show_list
+ `AndMonoBinds`
+ reads_prec `AndMonoBinds` read_list
where
-----------------------------------------------------------------------
+ show_list = mk_easy_FunMonoBind showList_PN [] []
+ (App (Var _showList_PN) (App (Var showsPrec_PN) (Lit (IntLit 0))))
+
+ read_list = mk_easy_FunMonoBind readList_PN [] []
+ (App (Var _readList_PN) (App (Var readsPrec_PN) (Lit (IntLit 0))))
+
+ -----------------------------------------------------------------------
shows_prec
= mk_FunMonoBind showsPrec_PN (map pats_etc (getTyConDataCons tycon))
where
inRange_PN = prelude_method SLIT("Ix") SLIT("inRange")
readsPrec_PN = prelude_method SLIT("Text") SLIT("readsPrec")
showsPrec_PN = prelude_method SLIT("Text") SLIT("showsPrec")
+readList_PN = prelude_method SLIT("Text") SLIT("readList")
+showList_PN = prelude_method SLIT("Text") SLIT("showList")
plus_PN = prelude_method SLIT("Num") SLIT("+")
times_PN = prelude_method SLIT("Num") SLIT("*")
showParen_PN = prelude_val pRELUDE_TEXT SLIT("showParen")
readParen_PN = prelude_val pRELUDE_TEXT SLIT("readParen")
lex_PN = prelude_val pRELUDE_TEXT SLIT("lex")
+_showList_PN = prelude_val pRELUDE_CORE SLIT("_showList")
+_readList_PN = prelude_val pRELUDE_CORE SLIT("_readList")
prelude_val m s = Imp m s [m] s
prelude_method c o = Imp pRELUDE_CORE o [pRELUDE_CORE] o -- class not used...
import UniqFM(UniqFM)
data InstInfo = InstInfo Class [TyVarTemplate] UniType [(Class, UniType)] [(Class, UniType)] Id [Id] (MonoBinds Name (InPat Name)) Bool _PackedString SrcLoc [Sig Name]
buildInstanceEnvs :: Bag InstInfo -> (GlobalSwitch -> Bool) -> [UniType] -> Subst -> SplitUniqSupply -> Bag (PprStyle -> Int -> Bool -> PrettyRep) -> SrcLoc -> TcResult (Class -> ([(UniType, InstTemplate)], ClassOp -> SpecEnv))
-mkInstanceRelatedIds :: E -> Bool -> InstancePragmas Name -> a -> Class -> [TyVarTemplate] -> UniType -> [(Class, UniType)] -> [Sig Name] -> (GlobalSwitch -> Bool) -> [UniType] -> Subst -> SplitUniqSupply -> Bag (PprStyle -> Int -> Bool -> PrettyRep) -> SrcLoc -> TcResult (Id, [(Class, UniType)], [Id])
+mkInstanceRelatedIds :: E -> Bool -> _PackedString -> InstancePragmas Name -> a -> Class -> [TyVarTemplate] -> UniType -> [(Class, UniType)] -> [Sig Name] -> (GlobalSwitch -> Bool) -> [UniType] -> Subst -> SplitUniqSupply -> Bag (PprStyle -> Int -> Bool -> PrettyRep) -> SrcLoc -> TcResult (Id, [(Class, UniType)], [Id])
processInstBinds :: E -> [TyVar] -> (Int -> (GlobalSwitch -> Bool) -> [UniType] -> Subst -> SplitUniqSupply -> Bag (PprStyle -> Int -> Bool -> PrettyRep) -> SrcLoc -> (Expr Id TypecheckedPat, Subst, Bag (PprStyle -> Int -> Bool -> PrettyRep))) -> [TyVar] -> [Inst] -> [Id] -> MonoBinds Name (InPat Name) -> (GlobalSwitch -> Bool) -> [UniType] -> Subst -> SplitUniqSupply -> Bag (PprStyle -> Int -> Bool -> PrettyRep) -> SrcLoc -> TcResult ([Inst], MonoBinds Id TypecheckedPat)
tcInstDecls1 :: E -> UniqFM Class -> UniqFM TyCon -> [InstDecl Name (InPat Name)] -> (GlobalSwitch -> Bool) -> [UniType] -> Subst -> SplitUniqSupply -> Bag (PprStyle -> Int -> Bool -> PrettyRep) -> SrcLoc -> (Bag InstInfo, Subst, Bag (PprStyle -> Int -> Bool -> PrettyRep))
tcInstDecls2 :: E -> Bag InstInfo -> (GlobalSwitch -> Bool) -> [UniType] -> Subst -> SplitUniqSupply -> Bag (PprStyle -> Int -> Bool -> PrettyRep) -> SrcLoc -> ((LIE, Binds Id TypecheckedPat), Subst, Bag (PprStyle -> Int -> Bool -> PrettyRep))
applyTcSubstAndCollectTyVars
)
import AbsSyn -- the stuff being typechecked
-
+import AbsPrel ( pAT_ERROR_ID )
import AbsUniType
import BackSubst ( applyTcSubstToBinds )
import Bag ( emptyBag, unitBag, unionBags, bagToList )
import CE ( lookupCE, CE(..) )
import CmdLineOpts ( GlobalSwitch(..) )
-import GenSpecEtc ( checkSigTyVars )
+import GenSpecEtc ( checkSigTyVars, SignatureInfo )
import E ( mkE, getE_CE, getE_TCE, growE_LVE, tvOfE, LVE(..), E )
import Errors ( dupInstErr, derivingWhenInstanceExistsErr,
preludeInstanceErr, nonBoxedPrimCCallErr,
import Maybes ( catMaybes, mkLookupFun, maybeToBool, Maybe(..) )
import Name ( getTagFromClassOpName )
import NameTypes ( fromPrelude )
+import PlainCore ( escErrorMsg )
import LIE ( nullLIE, mkLIE, unMkLIE, plusLIE, LIE )
import ListSetOps ( minusList )
import TCE ( TCE(..), UniqFM )
import TVE ( mkTVE, TVE(..) )
import Spec ( specTy )
import TcContext ( tcContext )
+import TcBinds ( tcSigs, doSpecPragma )
import TcGRHSs ( tcGRHSsAndBinds )
import TcMatches ( tcMatchesFun )
import TcMonoType ( tcInstanceType )
FAST_STRING -- Name of module where this instance was
-- defined.
SrcLoc -- Source location assoc'd with this instance's defn
- [RenamedSig] -- User pragmas recorded for generating specilaised instances
+ [RenamedSig] -- User pragmas recorded for generating specialised methods
\end{code}
else
-- Make the dfun id and constant-method ids
mkInstanceRelatedIds e
- from_here pragmas src_loc
+ from_here modname pragmas src_loc
clas inst_tyvars inst_ty theta uprags
`thenTc` \ (dfun_id, dfun_theta, const_meth_ids) ->
Common bit of code shared with @tcDeriving@:
\begin{code}
mkInstanceRelatedIds e
- from_here inst_pragmas locn
+ from_here modname inst_pragmas locn
clas
inst_tyvars inst_ty inst_decl_theta uprags
= getUniqueTc `thenNF_Tc` \ uniq ->
fixNF_Tc ( \ rec_dfun_id ->
babyTcMtoNF_TcM (
tcDictFunPragmas e dfun_ty rec_dfun_id inst_pragmas
- ) `thenNF_Tc` \ dfun_id_info ->
-
- returnNF_Tc (mkDictFunId uniq clas inst_ty dfun_ty from_here dfun_id_info)
+ ) `thenNF_Tc` \ dfun_pragma_info ->
+ let
+ dfun_specenv = mkInstSpecEnv clas inst_ty inst_tyvars dfun_theta
+ dfun_info = dfun_pragma_info `addInfo` dfun_specenv
+ in
+ returnNF_Tc (mkDictFunId uniq clas inst_ty dfun_ty from_here modname dfun_info)
) `thenNF_Tc` \ dfun_id ->
-- Make the constant-method ids, if there are no type variables involved
= mkConstMethodId
uniq
clas op inst_ty
- meth_ty from_here info
+ meth_ty from_here modname info
where
is_elem = isIn "mkInstanceRelatedIds"
`thenNF_Tc` \ id_info ->
returnNF_Tc (mkConstMethodId u clas op inst_ty meth_ty
- from_here id_info)
+ from_here modname id_info)
)
where
tenv = [(class_tyvar, inst_ty)]
addClassInstance
(class_inst_env, op_spec_envs)
(InstInfo clas inst_tyvars inst_ty inst_decl_theta dfun_theta dfun_id const_meth_ids _ _ _ src_loc _)
- = -- Insert into the class_inst_env first
- checkMaybeErrTc (addClassInst clas class_inst_env inst_ty dfun_id inst_tyvars dfun_theta src_loc)
- dupInstErr `thenTc` \ class_inst_env' ->
- let
- -- Adding the classop instances can't fail if the class instance itself didn't
- op_spec_envs' = case const_meth_ids of
- [] -> op_spec_envs
- other -> zipWith add_const_meth op_spec_envs const_meth_ids
- in
- returnTc (class_inst_env', op_spec_envs')
+ = getSwitchCheckerTc `thenNF_Tc` \ sw_chkr ->
+ -- We anly add specialised/overlapped instances
+ -- if we are specialising the overloading
+--
+-- ToDo ... This causes getConstMethodId errors!
+--
+-- if is_plain_instance inst_ty || sw_chkr SpecialiseOverloaded
+-- then
+
+ -- Insert into the class_inst_env first
+ checkMaybeErrTc (addClassInst clas class_inst_env inst_ty dfun_id inst_tyvars dfun_theta src_loc)
+ dupInstErr `thenTc` \ class_inst_env' ->
+ let
+ -- Adding the classop instances can't fail if the class instance itself didn't
+ op_spec_envs' = case const_meth_ids of
+ [] -> op_spec_envs
+ other -> zipWith add_const_meth op_spec_envs const_meth_ids
+ in
+ returnTc (class_inst_env', op_spec_envs')
+
+-- else
+-- -- Drop this specialised/overlapped instance
+-- returnTc (class_inst_env, op_spec_envs)
+
where
add_const_meth spec_env meth_id
= addOneToSpecEnv spec_env (SpecInfo (Just inst_ty:nothings) 1 meth_id)
-- op x = ...
-- then the constant method will be polymorphic in a,b,c, and
-- the SpecInfo will need to be elaborated.
-\end{code}
+\end{code}
%************************************************************************
%* *
tcInstDecl2
e free_tyvars
(InstInfo clas template_tyvars inst_ty_tmpl inst_decl_theta dfun_theta
- dfun_id const_meth_ids monobinds True{-from here-} _ locn _)
+ dfun_id const_meth_ids monobinds True{-from here-} inst_mod locn uprags)
= let
origin = InstanceDeclOrigin locn
in
newDicts origin dfun_theta' `thenNF_Tc` \ dfun_arg_dicts' ->
newDicts origin inst_decl_theta' `thenNF_Tc` \ inst_decl_dicts' ->
let
- sc_dicts'_ids = map mkInstId sc_dicts'
+ sc_dicts'_ids = map mkInstId sc_dicts'
dfun_arg_dicts'_ids = map mkInstId dfun_arg_dicts'
in
-- Instantiate the dictionary being constructed
method_insts ++
dfun_arg_dicts'
in
- processInstBinds e free_tyvars
- (makeInstanceDeclDefaultMethodExpr origin this_dict_id class_ops defm_ids inst_ty)
- inst_tyvars avail_insts method_ids monobinds
+ getSwitchCheckerTc `thenNF_Tc` \ sw_chkr ->
+ let
+ mk_method_expr
+ = if sw_chkr OmitDefaultInstanceMethods then
+ makeInstanceDeclNoDefaultExpr origin clas method_ids defm_ids inst_mod inst_ty
+ else
+ makeInstanceDeclDefaultMethodExpr origin this_dict_id class_ops defm_ids inst_ty
+ in
+ processInstBinds e free_tyvars mk_method_expr
+ inst_tyvars avail_insts method_ids monobinds
`thenTc` \ (insts_needed, method_mbinds) ->
- -- Complete the binding group
- let this_dict_bind
+ let
+ -- Create the dict and method binds
+ dict_bind
= VarMonoBind this_dict_id (Dictionary sc_dicts'_ids method_ids)
+
dict_and_method_binds
- = this_dict_bind `AndMonoBinds` method_mbinds
+ = dict_bind `AndMonoBinds` method_mbinds
in
-- Check the overloading constraints of the methods and superclasses
-- The global tyvars must be a fixed point of the substitution
`thenTc_`
-- Ignore the result; we're only doing
-- this to make sure it can be done.
-
- -- Create the dictionary function binding itself
- let inst_binds
+
+ -- Now process any SPECIALIZE pragmas for the methods
+ let
+ spec_sigs = [ s | s@(SpecSig _ _ _ _) <- uprags ]
+
+ get_const_method_id name
+ = const_meth_ids !! ((getTagFromClassOpName name) - 1)
+ in
+ tcSigs e [] spec_sigs `thenTc` \ sig_info ->
+
+ mapAndUnzipTc (doSpecPragma e get_const_method_id) sig_info
+ `thenTc` \ (spec_binds_s, spec_lie_s) ->
+ let
+ spec_lie = foldr plusLIE nullLIE spec_lie_s
+ spec_binds = foldr AndMonoBinds EmptyMonoBinds spec_binds_s
+
+ -- Complete the binding group, adding any spec_binds
+ inst_binds
= AbsBinds
inst_tyvars
dfun_arg_dicts'_ids
-- const_meth_ids will often be empty
super_binds
(RecBind dict_and_method_binds)
+
+ `ThenBinds`
+ SingleBind (NonRecBind spec_binds)
in
-
-- Back-substitute
applyTcSubstToBinds inst_binds `thenNF_Tc` \ final_inst_binds ->
- returnTc (mkLIE const_insts, final_inst_binds)
+ returnTc (mkLIE const_insts `plusLIE` spec_lie,
+ final_inst_binds)
)))
\end{code}
idx = tag - 1
class_op = class_ops !! idx
defm_id = defm_ids !! idx
+
+
+makeInstanceDeclNoDefaultExpr
+ :: InstOrigin
+ -> Class
+ -> [Id]
+ -> [Id]
+ -> FAST_STRING
+ -> UniType
+ -> Int
+ -> NF_TcM TypecheckedExpr
+
+makeInstanceDeclNoDefaultExpr origin clas method_ids defm_ids inst_mod inst_ty tag
+ = specTy origin (getIdUniType method_id) `thenNF_Tc` \ (tyvars, dicts, tau) ->
+
+ (if not err_defm then
+ pprTrace "Warning: "
+ (ppCat [ppStr "Omitted default method for",
+ ppr PprForUser clas_op, ppStr "in instance",
+ ppPStr clas_name, pprParendUniType PprForUser inst_ty])
+ else id) (
+
+ returnNF_Tc (mkTyLam tyvars (
+ mkDictLam (map mkInstId dicts) (
+ App (mkTyApp (Var pAT_ERROR_ID) [tau])
+ (Lit (StringLit (_PK_ error_msg))))))
+ )
+ where
+ idx = tag - 1
+ clas_op = (getClassOps clas) !! idx
+ method_id = method_ids !! idx
+ defm_id = defm_ids !! idx
+
+ Just (_, _, err_defm) = isDefaultMethodId_maybe defm_id
+
+ error_msg = "%E" -- => No explicit method for \"
+ ++ escErrorMsg error_str
+
+ error_str = _UNPK_ inst_mod ++ "." ++ _UNPK_ clas_name ++ "."
+ ++ (ppShow 80 (ppr PprForUser inst_ty)) ++ "."
+ ++ (ppShow 80 (ppr PprForUser clas_op)) ++ "\""
+
+ (_, clas_name) = getOrigName clas
\end{code}
babyTcMtoTcM (tcInstanceType ce tce tmpl_e True src_loc ty)
`thenTc` \ inst_ty ->
let
- tycon = case getUniDataTyCon_maybe inst_ty of
- Just (tc,_,_) -> tc
- Nothing -> panic "tcSpecInstSig:inst_tycon"
+ maybe_tycon = case getUniDataTyCon_maybe inst_ty of
+ Just (tc,_,_) -> Just tc
+ Nothing -> Nothing
- maybe_unspec_inst = lookup_unspec_inst clas tycon inst_infos
+ maybe_unspec_inst = lookup_unspec_inst clas maybe_tycon inst_infos
in
-- Check that we have a local instance declaration to specialise
checkMaybeTc maybe_unspec_inst
tv_tmpl_map = inst_tv_tys `zipEqual` inst_tmpl_tys
tv_to_tmpl tv = assoc "tcSpecInstSig" tv_tmpl_map tv
in
- mkInstanceRelatedIds e True{-from here-} NoInstancePragmas src_loc
+ mkInstanceRelatedIds e True{-from here-} mod NoInstancePragmas src_loc
clas inst_tmpls inst_ty simpl_theta uprag
`thenTc` \ (dfun_id, dfun_theta, const_meth_ids) ->
getSwitchCheckerTc `thenNF_Tc` \ sw_chkr ->
(if sw_chkr SpecialiseTrace then
pprTrace "Specialised Instance: "
- (ppAboves [ppCat [if null simpl_theta then ppNil else ppr PprDebug simpl_theta,
- if null simpl_theta then ppNil else ppStr "=>",
- ppr PprDebug clas,
- pprParendUniType PprDebug inst_ty],
- ppCat [ppStr " derived from:",
- if null unspec_theta then ppNil else ppr PprDebug unspec_theta,
- if null unspec_theta then ppNil else ppStr "=>",
- ppr PprDebug clas,
- pprParendUniType PprDebug unspec_inst_ty]])
- else id) (
+ (ppAboves [ppCat [if null simpl_theta then ppNil else ppr PprDebug simpl_theta,
+ if null simpl_theta then ppNil else ppStr "=>",
+ ppr PprDebug clas,
+ pprParendUniType PprDebug inst_ty],
+ ppCat [ppStr " derived from:",
+ if null unspec_theta then ppNil else ppr PprDebug unspec_theta,
+ if null unspec_theta then ppNil else ppStr "=>",
+ ppr PprDebug clas,
+ pprParendUniType PprDebug unspec_inst_ty]])
+ else id) (
returnTc (unitBag (InstInfo clas inst_tmpls inst_ty simpl_theta
dfun_theta dfun_id const_meth_ids
)))
-lookup_unspec_inst clas tycon inst_infos
- = case filter match_info (bagToList inst_infos) of
+lookup_unspec_inst clas maybe_tycon inst_infos
+ = case filter (match_info match_inst_ty) (bagToList inst_infos) of
[] -> Nothing
(info:_) -> Just info
where
- match_info (InstInfo inst_clas _ inst_ty _ _ _ _ _ from_here _ _ _)
- = from_here && clas == inst_clas && inst_ty_matches_tycon
- where
- inst_ty_matches_tycon = case (getUniDataTyCon_maybe inst_ty) of
- Just (inst_tc,tys,_) -> tycon == inst_tc && all isTyVarTemplateTy tys
- Nothing -> False
+ match_info match_ty (InstInfo inst_clas _ inst_ty _ _ _ _ _ from_here _ _ _)
+ = from_here && clas == inst_clas &&
+ match_ty inst_ty && is_plain_instance inst_ty
+
+ match_inst_ty = case maybe_tycon of
+ Just tycon -> match_tycon tycon
+ Nothing -> match_fun
+
+ match_tycon tycon inst_ty = case (getUniDataTyCon_maybe inst_ty) of
+ Just (inst_tc,_,_) -> tycon == inst_tc
+ Nothing -> False
+
+ match_fun inst_ty = isFunType inst_ty
+
+is_plain_instance inst_ty
+ = case (getUniDataTyCon_maybe inst_ty) of
+ Just (_,tys,_) -> all isTyVarTemplateTy tys
+ Nothing -> case maybeUnpackFunTy inst_ty of
+ Just (arg, res) -> isTyVarTemplateTy arg && isTyVarTemplateTy res
+ Nothing -> error "TcInstDecls:is_plain_instance"
\end{code}
data InstInfo
data TcResult a
data UniqFM a
-tcModule :: E -> (ProtoName -> Labda Name, ProtoName -> Labda Name) -> Module Name (InPat Name) -> (GlobalSwitch -> Bool) -> [UniType] -> Subst -> SplitUniqSupply -> Bag (PprStyle -> Int -> Bool -> PrettyRep) -> SrcLoc -> TcResult ((Binds Id TypecheckedPat, Binds Id TypecheckedPat, Binds Id TypecheckedPat, [(Inst, Expr Id TypecheckedPat)]), ([FixityDecl Name], [Id], UniqFM Class, UniqFM TyCon, Bag InstInfo), FiniteMap TyCon [[Labda UniType]], E, PprStyle -> Int -> Bool -> PrettyRep)
+tcModule :: E -> (ProtoName -> Labda Name, ProtoName -> Labda Name) -> Module Name (InPat Name) -> (GlobalSwitch -> Bool) -> [UniType] -> Subst -> SplitUniqSupply -> Bag (PprStyle -> Int -> Bool -> PrettyRep) -> SrcLoc -> TcResult ((Binds Id TypecheckedPat, Binds Id TypecheckedPat, Binds Id TypecheckedPat, [(Inst, Expr Id TypecheckedPat)]), ([FixityDecl Name], [Id], UniqFM Class, UniqFM TyCon, Bag InstInfo), FiniteMap TyCon [(Bool, [Labda UniType])], E, PprStyle -> Int -> Bool -> PrettyRep)
TCE,
Bag InstInfo),
- FiniteMap TyCon [[Maybe UniType]],
+ FiniteMap TyCon [(Bool, [Maybe UniType])],
-- source tycon specialisation requests
--UNUSED: E, -- environment of total accumulated info
inst_info = deriv_inst_info `unionBags` decl_inst_info
in
-- Handle specialise instance pragmas
--- getSwitchCheckerTc `thenNF_Tc` \ sw_chkr ->
--- (if sw_chkr GlasgowExts then
+ getSwitchCheckerTc `thenNF_Tc` \ sw_chkr ->
+ (if sw_chkr SpecialiseOverloaded then
tcSpecInstSigs e3 ce3 tce3 inst_info specinst_sigs
--- else
--- returnTc emptyBag)
+ else
+ returnTc emptyBag)
`thenTc` \ spec_inst_info ->
let
full_inst_info = inst_info `unionBags` spec_inst_info
import AbsSyn
import AbsUniType
-import Id ( mkId, mkUserLocal, mkSpecPragmaId, mkSpecId, Id, DictVar(..) )
+import Id ( mkId, mkUserLocal, mkSpecPragmaId, mkSpecId,
+ selectIdInfoForSpecId, Id, DictVar(..) )
import IdInfo
import Inst ( mkDict, mkMethod, mkLitInst,
Inst(..), -- .. for pragmas
newSpecId :: Id -> [Maybe UniType] -> UniType -> NF_TcM Id
newSpecId unspec spec_tys ty
= getUniqueTc `thenNF_Tc` \ uniq ->
- returnNF_Tc (mkSpecId uniq unspec spec_tys ty noIdInfo)
+ returnNF_Tc (mkSpecId uniq unspec spec_tys ty (selectIdInfoForSpecId unspec))
\end{code}
ToDo: This @newClassOpLocals@ is used only to make new ClassOps. Pretty yukky.
arity_info = get_arity arity_maybe
upd_info = get_upd upd_maybe
in
+ tc_strictness e ty_maybe rec_final_id strictness
+ `thenB_Tc` \ (strict_info, wrapper_unfold_info) ->
-- If the unfolding fails to look consistent, we don't
-- want to junk *all* the IdInfo
tc_unfolding e unfold
) `thenB_Tc` \ unfold_info ->
- tc_strictness e ty_maybe rec_final_id strictness
- `thenB_Tc` \ (strict_info, wrapper_unfold_info) ->
-
-- Same as unfolding; if we fail, don't junk all IdInfo
recoverIgnoreErrorsB_Tc nullSpecEnv (
tc_specs e rec_final_id ty_maybe specs
tc_unfolding e (ImpUnfolding guidance uf_core)
= tc_uf_core nullLVE nullTVE uf_core `thenB_Tc` \ core_expr ->
getSrcLocB_Tc `thenB_Tc` \ locn ->
- returnB_Tc (mkUnfolding guidance (lintUnfolding locn core_expr))
- -- type-incorrect unfoldings are so painful that we
- -- always lint-check them; such unfoldings can arise
- -- because of by-hand mix-and-match jiggery-pokery with
- -- interface files (WDP 95/05)
+ let
+ -- Bad unfoldings are so painful that we always lint-check them,
+ -- marking them with BadUnfolding if lintUnfolding fails
+ -- NB: We cant check the lint result and return noInfo_UF if
+ -- lintUnfolding failed as this is too strict
+ -- Instead getInfo_UF tests for BadUnfolding and converts
+ -- to NoUnfoldingDetails when the unfolding is accessed
+
+ maybe_lint_expr = lintUnfolding locn core_expr
+
+ (lint_guidance, lint_expr) = case maybe_lint_expr of
+ Just lint_expr -> (guidance, lint_expr)
+ Nothing -> (BadUnfolding, panic_expr)
+ in
+ returnB_Tc (mkUnfolding lint_guidance lint_expr)
where
rec_ce = getE_CE e
rec_tce = getE_TCE e
+ panic_expr = panic "TcPragmas: BadUnfolding should not be touched"
+
tc_uf_core :: LVE -- lookup table for local binders
-- (others: we hope we can figure them out)
-> TVE -- lookup table for tyvars
Just xx -> returnB_Tc xx
Nothing -> case (lookupE_ValueQuietly e v) of
Just xx -> returnB_Tc xx
- Nothing -> --pprTrace "lookup_Quietly: " (ppr PprDebug v) (
- failB_Tc (panic "tc_uf_Id: no lookup")
- --)
- -- should be recover'd from
+ Nothing -> -- pprTrace "WARNING: Discarded bad unfolding from interface:\n"
+ -- (ppCat [ppStr "Failed lookup for BoringUfId:",
+ -- ppr PprDebug v])
+ (failB_Tc (panic "tc_uf_Id:BoringUfId: no lookup"))
+ -- will be recover'd from
-- ToDo: shouldn't the renamer have handled this? [wdp 94/04/29]
tc_uf_Id lve (SuperDictSelUfId c sc)
tc_uf_Id lve (WorkerUfId unwrkr)
= tc_uf_Id lve unwrkr `thenB_Tc` \ unwrkr_id ->
- let
+ let
strictness_info = getIdStrictness unwrkr_id
- in
- returnB_Tc (getWorkerId strictness_info)
+ in
+ if isLocallyDefined unwrkr_id
+ then
+ -- A locally defined value will not have any strictness info (yet),
+ -- so we can't extract the locally defined worker Id from it :-(
+
+ pprTrace "WARNING: Discarded bad unfolding from interface:\n"
+ (ppCat [ppStr "Worker Id in unfolding is defined locally:",
+ ppr PprDebug unwrkr_id])
+ (failB_Tc (panic "tc_uf_Id:WorkerUfId: locally defined"))
+ -- will be recover'd from
+ else
+ returnB_Tc (getWorkerId strictness_info)
---------------
lookup_class_op clas (ClassOpName _ _ _ tag)
import TyCon(TyCon)
import UniType(UniType)
import UniqFM(UniqFM)
-tcTyDecls :: E -> (Name -> Bool) -> (Name -> [DataTypeSig Name]) -> [TyDecl Name] -> (GlobalSwitch -> Bool) -> SplitUniqSupply -> Bag (PprStyle -> Int -> Bool -> PrettyRep) -> SrcLoc -> Baby_TcResult (UniqFM TyCon, [(Name, Id)], FiniteMap TyCon [[Labda UniType]])
+tcTyDecls :: E -> (Name -> Bool) -> (Name -> [DataTypeSig Name]) -> [TyDecl Name] -> (GlobalSwitch -> Bool) -> SplitUniqSupply -> Bag (PprStyle -> Int -> Bool -> PrettyRep) -> SrcLoc -> Baby_TcResult (UniqFM TyCon, [(Name, Id)], FiniteMap TyCon [(Bool, [Labda UniType])])
-> (Name -> [RenamedDataTypeSig]) -- given Name, get specialisation pragmas
-> [RenamedTyDecl]
-> Baby_TcM (TCE, GVE,
- FiniteMap TyCon [[Maybe UniType]])
+ FiniteMap TyCon [(Bool, [Maybe UniType])])
-- specialisations:
- -- local data types: requsted by source pragmas
- -- imported data types: from interface file
+ -- True => imported data types i.e. from interface file
+ -- False => local data types i.e. requsted by source pragmas
tcTyDecls e _ _ [] = returnB_Tc (nullTCE, nullGVE, emptyFM)
then (pragma_con_decls, recoverIgnoreErrorsB_Tc nullGVE)
else panic "tcTyDecls:data: user and pragma condecls!"
- specinfos_to_use
+ (imported_specs, specinfos_to_use)
= if null pragma_spec_infos then
- user_spec_infos
+ (False, user_spec_infos)
else
if null user_spec_infos
- then pragma_spec_infos
+ then (True, pragma_spec_infos)
else panic "tcTyDecls:data: user and pragma specinfos!"
specenv_to_use = mkSpecEnv specinfos_to_use
-- if constrs are from pragma we are *abstract*
spec_list
- = map (\ (SpecInfo maybe_tys _ _) -> maybe_tys) specinfos_to_use
+ = [(imported_specs, maybe_tys) | (SpecInfo maybe_tys _ _) <- specinfos_to_use]
spec_map
= if null spec_list then
data SplitUniqSupply
data InstInfo
data UniqFM a
-typecheckModule :: (GlobalSwitch -> Bool) -> SplitUniqSupply -> (ProtoName -> Labda Name, ProtoName -> Labda Name) -> Module Name (InPat Name) -> MaybeErr ((Binds Id TypecheckedPat, Binds Id TypecheckedPat, Binds Id TypecheckedPat, [(Inst, Expr Id TypecheckedPat)]), ([FixityDecl Name], [Id], UniqFM Class, UniqFM TyCon, Bag InstInfo), FiniteMap TyCon [[Labda UniType]], E, PprStyle -> Int -> Bool -> PrettyRep) (Bag (PprStyle -> Int -> Bool -> PrettyRep))
+typecheckModule :: (GlobalSwitch -> Bool) -> SplitUniqSupply -> (ProtoName -> Labda Name, ProtoName -> Labda Name) -> Module Name (InPat Name) -> MaybeErr ((Binds Id TypecheckedPat, Binds Id TypecheckedPat, Binds Id TypecheckedPat, [(Inst, Expr Id TypecheckedPat)]), ([FixityDecl Name], [Id], UniqFM Class, UniqFM TyCon, Bag InstInfo), FiniteMap TyCon [(Bool, [Labda UniType])], E, PprStyle -> Int -> Bool -> PrettyRep) (Bag (PprStyle -> Int -> Bool -> PrettyRep))
TCE,
Bag InstInfo),
- FiniteMap TyCon [[Maybe UniType]],
+ FiniteMap TyCon [(Bool, [Maybe UniType])],
-- source tycon specialisation requests
--UNUSED: E, -- new cumulative E (with everything)
import TcMonad
import CmdLineOpts ( GlobalSwitch(..) )
+import CoreLift ( isUnboxedButNotState )
import Errors ( unifyErr, UnifyErrInfo(..), UnifyErrContext )
import Id ( Id, DataCon(..), Inst )
import Maybes ( Maybe(..) )
tyvar1 `bindTo` ty2
= extendSubstTc tyvar1 ty2 err_ctxt
- tyvar1 `bindToUnboxed` ty2
+ tyvar1 `bindToUnboxed` ty2
= getSwitchCheckerTc `thenNF_Tc` \ sw_chkr ->
- if sw_chkr SpecialiseUnboxed then
+ if sw_chkr SpecialiseUnboxed && isUnboxedButNotState ty2 then
extendSubstTc tyvar1 ty2 err_ctxt
else
getSrcLocTc `thenNF_Tc` \ src_loc ->
- failTc (unifyErr (UnifyMisMatch ty1 ps_ty2) err_ctxt src_loc)
+ failTc (unifyErr (UnifyUnboxedMisMatch ty1 ps_ty2) err_ctxt src_loc)
\end{code}
let
sel_id = op_ids !! (getClassOpTag op - 1)
in
- case (lookupConstMethodId (getIdSpecialisation sel_id) ty) of
+ case (lookupConstMethodId sel_id ty) of
Just xx -> xx
Nothing -> error (ppShow 80 (ppAboves [
ppCat [ppStr "ERROR: getConstMethodId:", ppr PprDebug op, ppr PprDebug ty, ppr PprDebug ops, ppr PprDebug op_ids, ppr PprDebug sel_id],
\begin{code}
isLocalSpecTyCon :: Bool -> TyCon -> Bool
+isLocalGenTyCon :: TyCon -> Bool
isLocalSpecTyCon compiling_prelude tc
- = isLocallyDefined tc || (fromPreludeCore tc && not compiling_prelude)
-
-isLocalGenTyCon (SpecTyCon tc tys) = isLocalGenTyCon tc
-isLocalGenTyCon tc = isBigTupleTyCon tc || isLocallyDefined tc
+ = isLocallyDefined tc -- || (fromPreludeCore tc && not compiling_prelude)
+ -- Not for now ... need to be local
+ -- This will cause problem with splitting
+
+isLocalGenTyCon tc
+ = isLocallyDefined tc -- || isBigTupleTyCon tc
+ -- Not for now ... need to be local
+ -- This will cause problem with splitting
isBigTupleTyCon (TupleTyCon arity) = arity > 32
-- Tuple0 to Tuple32 declared in prelude
= ppCat [ppr PprForUser clas, ppr_ty sty lookup_fn tYCON_PREC ty]
ppr_tau_ty sty lookup_fn ctxt_prec (UniSyn _ _ expansion)
+ -- Expand type synonyms unless PprForUser
+ -- NB: it is important that synonyms are expanded with PprInterface
| case sty of { PprForUser -> False; _ -> True }
- = ppr_tau_ty sty lookup_fn ctxt_prec expansion -- always expand types in an interface
-
--- .....................
+ = ppr_tau_ty sty lookup_fn ctxt_prec expansion
ppr_tau_ty sty lookup_fn ctxt_prec (UniTyVarTemplate tyvar) = lookup_fn tyvar
| ty_maybes <- specs ]]
pp_the_list [p] = p
- pp_the_list (p:ps) = ppAbove (ppBeside p ppComma) (pp_the_list ps)
+ pp_the_list (p:ps) = ppCat [ppBeside p ppComma, pp_the_list ps]
pp_maybe Nothing = pp_NONE
pp_maybe (Just ty) = pprParendUniType sty ty
import ProtoName(ProtoName)
import U_coresyn(U_coresyn)
import U_list(U_list)
-data U_hpragma = U_no_pragma | U_idata_pragma U_list U_list | U_itype_pragma | U_iclas_pragma U_list | U_iclasop_pragma U_hpragma U_hpragma | U_iinst_simpl_pragma _PackedString U_hpragma | U_iinst_const_pragma _PackedString U_hpragma U_list | U_iinst_spec_pragma _PackedString U_hpragma U_list | U_igen_pragma U_hpragma U_hpragma U_hpragma U_hpragma U_hpragma U_list | U_iarity_pragma Int | U_iupdate_pragma _PackedString | U_ideforest_pragma | U_istrictness_pragma _PackedString U_hpragma | U_imagic_unfolding_pragma _PackedString | U_iunfolding_pragma U_hpragma U_coresyn | U_iunfold_always | U_iunfold_if_args Int Int _PackedString Int | U_iname_pragma_pr ProtoName U_hpragma | U_itype_pragma_pr U_list Int U_hpragma | U_iinst_pragma_3s U_list Int U_hpragma U_list | U_idata_pragma_4s U_list
+data U_hpragma = U_no_pragma | U_idata_pragma U_list U_list | U_itype_pragma | U_iclas_pragma U_list | U_iclasop_pragma U_hpragma U_hpragma | U_iinst_simpl_pragma _PackedString U_hpragma | U_iinst_const_pragma _PackedString U_hpragma U_list | U_igen_pragma U_hpragma U_hpragma U_hpragma U_hpragma U_hpragma U_list | U_iarity_pragma Int | U_iupdate_pragma _PackedString | U_ideforest_pragma | U_istrictness_pragma _PackedString U_hpragma | U_imagic_unfolding_pragma _PackedString | U_iunfolding_pragma U_hpragma U_coresyn | U_iunfold_always | U_iunfold_if_args Int Int _PackedString Int | U_iname_pragma_pr ProtoName U_hpragma | U_itype_pragma_pr U_list Int U_hpragma | U_idata_pragma_4s U_list
rdU_hpragma :: _Addr -> _PackedString -> _State _RealWorld -> (U_hpragma, _State _RealWorld)
import U_list
import U_literal ( U_literal ) -- ditto
import U_ttype ( U_ttype ) -- interface only
-data U_hpragma = U_no_pragma | U_idata_pragma U_list U_list | U_itype_pragma | U_iclas_pragma U_list | U_iclasop_pragma U_hpragma U_hpragma | U_iinst_simpl_pragma U_stringId U_hpragma | U_iinst_const_pragma U_stringId U_hpragma U_list | U_iinst_spec_pragma U_stringId U_hpragma U_list | U_igen_pragma U_hpragma U_hpragma U_hpragma U_hpragma U_hpragma U_list | U_iarity_pragma U_numId | U_iupdate_pragma U_stringId | U_ideforest_pragma | U_istrictness_pragma U_hstring U_hpragma | U_imagic_unfolding_pragma U_stringId | U_iunfolding_pragma U_hpragma U_coresyn | U_iunfold_always | U_iunfold_if_args U_numId U_numId U_stringId U_numId | U_iname_pragma_pr U_unkId U_hpragma | U_itype_pragma_pr U_list U_numId U_hpragma | U_iinst_pragma_3s U_list U_numId U_hpragma U_list | U_idata_pragma_4s U_list
+data U_hpragma = U_no_pragma | U_idata_pragma U_list U_list | U_itype_pragma | U_iclas_pragma U_list | U_iclasop_pragma U_hpragma U_hpragma | U_iinst_simpl_pragma U_stringId U_hpragma | U_iinst_const_pragma U_stringId U_hpragma U_list | U_igen_pragma U_hpragma U_hpragma U_hpragma U_hpragma U_hpragma U_list | U_iarity_pragma U_numId | U_iupdate_pragma U_stringId | U_ideforest_pragma | U_istrictness_pragma U_hstring U_hpragma | U_imagic_unfolding_pragma U_stringId | U_iunfolding_pragma U_hpragma U_coresyn | U_iunfold_always | U_iunfold_if_args U_numId U_numId U_stringId U_numId | U_iname_pragma_pr U_unkId U_hpragma | U_itype_pragma_pr U_list U_numId U_hpragma | U_idata_pragma_4s U_list
rdU_hpragma :: _Addr -> UgnM U_hpragma
rdU_hpragma t
ioToUgnM (_ccall_ gprag_constms t) `thenUgn` \ x_gprag_constms ->
rdU_list x_gprag_constms `thenUgn` \ y_gprag_constms ->
returnUgn (U_iinst_const_pragma y_gprag_imod_const y_gprag_dfun_const y_gprag_constms)
- else if tag == ``iinst_spec_pragma'' then
- ioToUgnM (_ccall_ gprag_imod_spec t) `thenUgn` \ x_gprag_imod_spec ->
- rdU_stringId x_gprag_imod_spec `thenUgn` \ y_gprag_imod_spec ->
- ioToUgnM (_ccall_ gprag_dfun_spec t) `thenUgn` \ x_gprag_dfun_spec ->
- rdU_hpragma x_gprag_dfun_spec `thenUgn` \ y_gprag_dfun_spec ->
- ioToUgnM (_ccall_ gprag_inst_specs t) `thenUgn` \ x_gprag_inst_specs ->
- rdU_list x_gprag_inst_specs `thenUgn` \ y_gprag_inst_specs ->
- returnUgn (U_iinst_spec_pragma y_gprag_imod_spec y_gprag_dfun_spec y_gprag_inst_specs)
else if tag == ``igen_pragma'' then
ioToUgnM (_ccall_ gprag_arity t) `thenUgn` \ x_gprag_arity ->
rdU_hpragma x_gprag_arity `thenUgn` \ y_gprag_arity ->
ioToUgnM (_ccall_ gprag_type_pr3 t) `thenUgn` \ x_gprag_type_pr3 ->
rdU_hpragma x_gprag_type_pr3 `thenUgn` \ y_gprag_type_pr3 ->
returnUgn (U_itype_pragma_pr y_gprag_type_pr1 y_gprag_type_pr2 y_gprag_type_pr3)
- else if tag == ``iinst_pragma_3s'' then
- ioToUgnM (_ccall_ gprag_inst_pt1 t) `thenUgn` \ x_gprag_inst_pt1 ->
- rdU_list x_gprag_inst_pt1 `thenUgn` \ y_gprag_inst_pt1 ->
- ioToUgnM (_ccall_ gprag_inst_pt2 t) `thenUgn` \ x_gprag_inst_pt2 ->
- rdU_numId x_gprag_inst_pt2 `thenUgn` \ y_gprag_inst_pt2 ->
- ioToUgnM (_ccall_ gprag_inst_pt3 t) `thenUgn` \ x_gprag_inst_pt3 ->
- rdU_hpragma x_gprag_inst_pt3 `thenUgn` \ y_gprag_inst_pt3 ->
- ioToUgnM (_ccall_ gprag_inst_pt4 t) `thenUgn` \ x_gprag_inst_pt4 ->
- rdU_list x_gprag_inst_pt4 `thenUgn` \ y_gprag_inst_pt4 ->
- returnUgn (U_iinst_pragma_3s y_gprag_inst_pt1 y_gprag_inst_pt2 y_gprag_inst_pt3 y_gprag_inst_pt4)
else if tag == ``idata_pragma_4s'' then
ioToUgnM (_ccall_ gprag_data_spec t) `thenUgn` \ x_gprag_data_spec ->
rdU_list x_gprag_data_spec `thenUgn` \ y_gprag_data_spec ->
= U_cobinder ProtoName U_ttype | U_colit U_literal | U_colocal U_coresyn | U_cononrec U_coresyn U_coresyn | U_corec U_list | U_corec_pair U_coresyn U_coresyn | U_covar U_coresyn | U_coliteral U_literal | U_cocon U_coresyn U_list U_list | U_coprim U_coresyn U_list U_list | U_colam U_list U_coresyn | U_cotylam U_list U_coresyn | U_coapp U_coresyn U_list | U_cotyapp U_coresyn U_ttype | U_cocase U_coresyn U_coresyn | U_colet U_coresyn U_coresyn | U_coscc U_coresyn U_coresyn | U_coalg_alts U_list U_coresyn | U_coalg_alt U_coresyn U_list U_coresyn | U_coprim_alts U_list U_coresyn | U_coprim_alt U_literal U_coresyn | U_conodeflt | U_cobinddeflt U_coresyn U_coresyn | U_co_primop _PackedString | U_co_ccall _PackedString Int U_list U_ttype | U_co_casm U_literal Int U_list U_ttype | U_co_preludedictscc U_coresyn | U_co_alldictscc _PackedString _PackedString U_coresyn | U_co_usercc _PackedString _PackedString _PackedString U_coresyn U_coresyn | U_co_autocc U_coresyn _PackedString _PackedString U_coresyn U_coresyn | U_co_dictcc U_coresyn _PackedString _PackedString U_coresyn U_coresyn | U_co_scc_noncaf | U_co_scc_caf | U_co_scc_nondupd | U_co_scc_dupd | U_co_id _PackedString | U_co_orig_id _PackedString _PackedString | U_co_sdselid ProtoName ProtoName | U_co_classopid ProtoName ProtoName | U_co_defmid ProtoName ProtoName | U_co_dfunid ProtoName U_ttype | U_co_constmid ProtoName ProtoName U_ttype | U_co_specid U_coresyn U_list | U_co_wrkrid U_coresyn
data U_entidt = U_entid _PackedString | U_enttype _PackedString | U_enttypeall _PackedString | U_enttypecons _PackedString U_list | U_entclass _PackedString U_list | U_entmod _PackedString
data U_finfot = U_finfo _PackedString _PackedString
-data U_hpragma = U_no_pragma | U_idata_pragma U_list U_list | U_itype_pragma | U_iclas_pragma U_list | U_iclasop_pragma U_hpragma U_hpragma | U_iinst_simpl_pragma _PackedString U_hpragma | U_iinst_const_pragma _PackedString U_hpragma U_list | U_iinst_spec_pragma _PackedString U_hpragma U_list | U_igen_pragma U_hpragma U_hpragma U_hpragma U_hpragma U_hpragma U_list | U_iarity_pragma Int | U_iupdate_pragma _PackedString | U_ideforest_pragma | U_istrictness_pragma _PackedString U_hpragma | U_imagic_unfolding_pragma _PackedString | U_iunfolding_pragma U_hpragma U_coresyn | U_iunfold_always | U_iunfold_if_args Int Int _PackedString Int | U_iname_pragma_pr ProtoName U_hpragma | U_itype_pragma_pr U_list Int U_hpragma | U_iinst_pragma_3s U_list Int U_hpragma U_list | U_idata_pragma_4s U_list
+data U_hpragma = U_no_pragma | U_idata_pragma U_list U_list | U_itype_pragma | U_iclas_pragma U_list | U_iclasop_pragma U_hpragma U_hpragma | U_iinst_simpl_pragma _PackedString U_hpragma | U_iinst_const_pragma _PackedString U_hpragma U_list | U_igen_pragma U_hpragma U_hpragma U_hpragma U_hpragma U_hpragma U_list | U_iarity_pragma Int | U_iupdate_pragma _PackedString | U_ideforest_pragma | U_istrictness_pragma _PackedString U_hpragma | U_imagic_unfolding_pragma _PackedString | U_iunfolding_pragma U_hpragma U_coresyn | U_iunfold_always | U_iunfold_if_args Int Int _PackedString Int | U_iname_pragma_pr ProtoName U_hpragma | U_itype_pragma_pr U_list Int U_hpragma | U_idata_pragma_4s U_list
data U_list = U_lcons _Addr U_list | U_lnil
data U_literal = U_integer _PackedString | U_intprim _PackedString | U_floatr _PackedString | U_doubleprim _PackedString | U_floatprim _PackedString | U_charr _PackedString | U_charprim _PackedString | U_string _PackedString | U_stringprim _PackedString | U_clitlit _PackedString _PackedString | U_norepi _PackedString | U_norepr _PackedString _PackedString | U_noreps _PackedString
data U_pbinding = U_pgrhs U_tree U_list U_binding _PackedString Int
return(& t -> Xgprag_constms);
}
-/************** iinst_spec_pragma ******************/
-
-hpragma mkiinst_spec_pragma(PPgprag_imod_spec, PPgprag_dfun_spec, PPgprag_inst_specs)
- stringId PPgprag_imod_spec;
- hpragma PPgprag_dfun_spec;
- list PPgprag_inst_specs;
-{
- register struct Siinst_spec_pragma *pp =
- (struct Siinst_spec_pragma *) malloc(sizeof(struct Siinst_spec_pragma));
- pp -> tag = iinst_spec_pragma;
- pp -> Xgprag_imod_spec = PPgprag_imod_spec;
- pp -> Xgprag_dfun_spec = PPgprag_dfun_spec;
- pp -> Xgprag_inst_specs = PPgprag_inst_specs;
- return((hpragma)pp);
-}
-
-stringId *Rgprag_imod_spec(t)
- struct Siinst_spec_pragma *t;
-{
-#ifdef UGEN_DEBUG
- if(t -> tag != iinst_spec_pragma)
- fprintf(stderr,"gprag_imod_spec: illegal selection; was %d\n", t -> tag);
-#endif /* UGEN_DEBUG */
- return(& t -> Xgprag_imod_spec);
-}
-
-hpragma *Rgprag_dfun_spec(t)
- struct Siinst_spec_pragma *t;
-{
-#ifdef UGEN_DEBUG
- if(t -> tag != iinst_spec_pragma)
- fprintf(stderr,"gprag_dfun_spec: illegal selection; was %d\n", t -> tag);
-#endif /* UGEN_DEBUG */
- return(& t -> Xgprag_dfun_spec);
-}
-
-list *Rgprag_inst_specs(t)
- struct Siinst_spec_pragma *t;
-{
-#ifdef UGEN_DEBUG
- if(t -> tag != iinst_spec_pragma)
- fprintf(stderr,"gprag_inst_specs: illegal selection; was %d\n", t -> tag);
-#endif /* UGEN_DEBUG */
- return(& t -> Xgprag_inst_specs);
-}
-
/************** igen_pragma ******************/
hpragma mkigen_pragma(PPgprag_arity, PPgprag_update, PPgprag_deforest, PPgprag_strictness, PPgprag_unfolding, PPgprag_specs)
return(& t -> Xgprag_type_pr3);
}
-/************** iinst_pragma_3s ******************/
-
-hpragma mkiinst_pragma_3s(PPgprag_inst_pt1, PPgprag_inst_pt2, PPgprag_inst_pt3, PPgprag_inst_pt4)
- list PPgprag_inst_pt1;
- numId PPgprag_inst_pt2;
- hpragma PPgprag_inst_pt3;
- list PPgprag_inst_pt4;
-{
- register struct Siinst_pragma_3s *pp =
- (struct Siinst_pragma_3s *) malloc(sizeof(struct Siinst_pragma_3s));
- pp -> tag = iinst_pragma_3s;
- pp -> Xgprag_inst_pt1 = PPgprag_inst_pt1;
- pp -> Xgprag_inst_pt2 = PPgprag_inst_pt2;
- pp -> Xgprag_inst_pt3 = PPgprag_inst_pt3;
- pp -> Xgprag_inst_pt4 = PPgprag_inst_pt4;
- return((hpragma)pp);
-}
-
-list *Rgprag_inst_pt1(t)
- struct Siinst_pragma_3s *t;
-{
-#ifdef UGEN_DEBUG
- if(t -> tag != iinst_pragma_3s)
- fprintf(stderr,"gprag_inst_pt1: illegal selection; was %d\n", t -> tag);
-#endif /* UGEN_DEBUG */
- return(& t -> Xgprag_inst_pt1);
-}
-
-numId *Rgprag_inst_pt2(t)
- struct Siinst_pragma_3s *t;
-{
-#ifdef UGEN_DEBUG
- if(t -> tag != iinst_pragma_3s)
- fprintf(stderr,"gprag_inst_pt2: illegal selection; was %d\n", t -> tag);
-#endif /* UGEN_DEBUG */
- return(& t -> Xgprag_inst_pt2);
-}
-
-hpragma *Rgprag_inst_pt3(t)
- struct Siinst_pragma_3s *t;
-{
-#ifdef UGEN_DEBUG
- if(t -> tag != iinst_pragma_3s)
- fprintf(stderr,"gprag_inst_pt3: illegal selection; was %d\n", t -> tag);
-#endif /* UGEN_DEBUG */
- return(& t -> Xgprag_inst_pt3);
-}
-
-list *Rgprag_inst_pt4(t)
- struct Siinst_pragma_3s *t;
-{
-#ifdef UGEN_DEBUG
- if(t -> tag != iinst_pragma_3s)
- fprintf(stderr,"gprag_inst_pt4: illegal selection; was %d\n", t -> tag);
-#endif /* UGEN_DEBUG */
- return(& t -> Xgprag_inst_pt4);
-}
-
/************** idata_pragma_4s ******************/
hpragma mkidata_pragma_4s(PPgprag_data_spec)
iclasop_pragma,
iinst_simpl_pragma,
iinst_const_pragma,
- iinst_spec_pragma,
igen_pragma,
iarity_pragma,
iupdate_pragma,
iunfold_if_args,
iname_pragma_pr,
itype_pragma_pr,
- iinst_pragma_3s,
idata_pragma_4s
} Thpragma;
list Xgprag_constms;
};
-struct Siinst_spec_pragma {
- Thpragma tag;
- stringId Xgprag_imod_spec;
- hpragma Xgprag_dfun_spec;
- list Xgprag_inst_specs;
-};
-
struct Sigen_pragma {
Thpragma tag;
hpragma Xgprag_arity;
hpragma Xgprag_type_pr3;
};
-struct Siinst_pragma_3s {
- Thpragma tag;
- list Xgprag_inst_pt1;
- numId Xgprag_inst_pt2;
- hpragma Xgprag_inst_pt3;
- list Xgprag_inst_pt4;
-};
-
struct Sidata_pragma_4s {
Thpragma tag;
list Xgprag_data_spec;
#define gprag_constms(xyzxyz) (*Rgprag_constms((struct Siinst_const_pragma *) (xyzxyz)))
-extern hpragma mkiinst_spec_pragma PROTO((stringId, hpragma, list));
-#ifdef __GNUC__
-
-stringId *Rgprag_imod_spec PROTO((struct Siinst_spec_pragma *));
-
-extern __inline__ stringId *Rgprag_imod_spec(struct Siinst_spec_pragma *t)
-{
-#ifdef UGEN_DEBUG
- if(t -> tag != iinst_spec_pragma)
- fprintf(stderr,"gprag_imod_spec: illegal selection; was %d\n", t -> tag);
-#endif /* UGEN_DEBUG */
- return(& t -> Xgprag_imod_spec);
-}
-#else /* ! __GNUC__ */
-extern stringId *Rgprag_imod_spec PROTO((struct Siinst_spec_pragma *));
-#endif /* ! __GNUC__ */
-
-#define gprag_imod_spec(xyzxyz) (*Rgprag_imod_spec((struct Siinst_spec_pragma *) (xyzxyz)))
-#ifdef __GNUC__
-
-hpragma *Rgprag_dfun_spec PROTO((struct Siinst_spec_pragma *));
-
-extern __inline__ hpragma *Rgprag_dfun_spec(struct Siinst_spec_pragma *t)
-{
-#ifdef UGEN_DEBUG
- if(t -> tag != iinst_spec_pragma)
- fprintf(stderr,"gprag_dfun_spec: illegal selection; was %d\n", t -> tag);
-#endif /* UGEN_DEBUG */
- return(& t -> Xgprag_dfun_spec);
-}
-#else /* ! __GNUC__ */
-extern hpragma *Rgprag_dfun_spec PROTO((struct Siinst_spec_pragma *));
-#endif /* ! __GNUC__ */
-
-#define gprag_dfun_spec(xyzxyz) (*Rgprag_dfun_spec((struct Siinst_spec_pragma *) (xyzxyz)))
-#ifdef __GNUC__
-
-list *Rgprag_inst_specs PROTO((struct Siinst_spec_pragma *));
-
-extern __inline__ list *Rgprag_inst_specs(struct Siinst_spec_pragma *t)
-{
-#ifdef UGEN_DEBUG
- if(t -> tag != iinst_spec_pragma)
- fprintf(stderr,"gprag_inst_specs: illegal selection; was %d\n", t -> tag);
-#endif /* UGEN_DEBUG */
- return(& t -> Xgprag_inst_specs);
-}
-#else /* ! __GNUC__ */
-extern list *Rgprag_inst_specs PROTO((struct Siinst_spec_pragma *));
-#endif /* ! __GNUC__ */
-
-#define gprag_inst_specs(xyzxyz) (*Rgprag_inst_specs((struct Siinst_spec_pragma *) (xyzxyz)))
-
extern hpragma mkigen_pragma PROTO((hpragma, hpragma, hpragma, hpragma, hpragma, list));
#ifdef __GNUC__
#define gprag_type_pr3(xyzxyz) (*Rgprag_type_pr3((struct Sitype_pragma_pr *) (xyzxyz)))
-extern hpragma mkiinst_pragma_3s PROTO((list, numId, hpragma, list));
-#ifdef __GNUC__
-
-list *Rgprag_inst_pt1 PROTO((struct Siinst_pragma_3s *));
-
-extern __inline__ list *Rgprag_inst_pt1(struct Siinst_pragma_3s *t)
-{
-#ifdef UGEN_DEBUG
- if(t -> tag != iinst_pragma_3s)
- fprintf(stderr,"gprag_inst_pt1: illegal selection; was %d\n", t -> tag);
-#endif /* UGEN_DEBUG */
- return(& t -> Xgprag_inst_pt1);
-}
-#else /* ! __GNUC__ */
-extern list *Rgprag_inst_pt1 PROTO((struct Siinst_pragma_3s *));
-#endif /* ! __GNUC__ */
-
-#define gprag_inst_pt1(xyzxyz) (*Rgprag_inst_pt1((struct Siinst_pragma_3s *) (xyzxyz)))
-#ifdef __GNUC__
-
-numId *Rgprag_inst_pt2 PROTO((struct Siinst_pragma_3s *));
-
-extern __inline__ numId *Rgprag_inst_pt2(struct Siinst_pragma_3s *t)
-{
-#ifdef UGEN_DEBUG
- if(t -> tag != iinst_pragma_3s)
- fprintf(stderr,"gprag_inst_pt2: illegal selection; was %d\n", t -> tag);
-#endif /* UGEN_DEBUG */
- return(& t -> Xgprag_inst_pt2);
-}
-#else /* ! __GNUC__ */
-extern numId *Rgprag_inst_pt2 PROTO((struct Siinst_pragma_3s *));
-#endif /* ! __GNUC__ */
-
-#define gprag_inst_pt2(xyzxyz) (*Rgprag_inst_pt2((struct Siinst_pragma_3s *) (xyzxyz)))
-#ifdef __GNUC__
-
-hpragma *Rgprag_inst_pt3 PROTO((struct Siinst_pragma_3s *));
-
-extern __inline__ hpragma *Rgprag_inst_pt3(struct Siinst_pragma_3s *t)
-{
-#ifdef UGEN_DEBUG
- if(t -> tag != iinst_pragma_3s)
- fprintf(stderr,"gprag_inst_pt3: illegal selection; was %d\n", t -> tag);
-#endif /* UGEN_DEBUG */
- return(& t -> Xgprag_inst_pt3);
-}
-#else /* ! __GNUC__ */
-extern hpragma *Rgprag_inst_pt3 PROTO((struct Siinst_pragma_3s *));
-#endif /* ! __GNUC__ */
-
-#define gprag_inst_pt3(xyzxyz) (*Rgprag_inst_pt3((struct Siinst_pragma_3s *) (xyzxyz)))
-#ifdef __GNUC__
-
-list *Rgprag_inst_pt4 PROTO((struct Siinst_pragma_3s *));
-
-extern __inline__ list *Rgprag_inst_pt4(struct Siinst_pragma_3s *t)
-{
-#ifdef UGEN_DEBUG
- if(t -> tag != iinst_pragma_3s)
- fprintf(stderr,"gprag_inst_pt4: illegal selection; was %d\n", t -> tag);
-#endif /* UGEN_DEBUG */
- return(& t -> Xgprag_inst_pt4);
-}
-#else /* ! __GNUC__ */
-extern list *Rgprag_inst_pt4 PROTO((struct Siinst_pragma_3s *));
-#endif /* ! __GNUC__ */
-
-#define gprag_inst_pt4(xyzxyz) (*Rgprag_inst_pt4((struct Siinst_pragma_3s *) (xyzxyz)))
-
extern hpragma mkidata_pragma_4s PROTO((list));
#ifdef __GNUC__
gprag_dfun_const : hpragma; /* gen pragma: of dfun */
gprag_constms : list; /* (name, gen pragma) pairs */ >;
- iinst_spec_pragma: < gprag_imod_spec : stringId;
- gprag_dfun_spec : hpragma; /* gen pragma: of dfun */
- gprag_inst_specs : list; /* (type, inst_pragma) pairs */ >;
-
igen_pragma: < gprag_arity : hpragma; /* arity */
gprag_update : hpragma; /* update info */
gprag_deforest : hpragma; /* deforest info */
itype_pragma_pr: < gprag_type_pr1 : list; /* of maybe types */
gprag_type_pr2 : numId; /* # dicts to ignore */
gprag_type_pr3 : hpragma; >;
- iinst_pragma_3s: < gprag_inst_pt1 : list; /* of maybe types */
- gprag_inst_pt2 : numId;
- gprag_inst_pt3 : hpragma;
- gprag_inst_pt4 : list; >;
-
+
idata_pragma_4s: < gprag_data_spec : list; /* of maybe types */ >;
end;
/* A lexical scanner generated by flex */
/* Scanner skeleton version:
- * $Header: /srv/cvs/cvs.haskell.org/fptools/ghc/compiler/yaccParser/Attic/hslexer.c,v 1.2 1996/01/12 11:36:07 partain Exp $
+ * $Header: /srv/cvs/cvs.haskell.org/fptools/ghc/compiler/yaccParser/Attic/hslexer.c,v 1.3 1996/01/18 16:36:38 partain Exp $
*/
#define FLEX_SCANNER
*yy_cp = '\0'; \
yy_c_buf_p = yy_cp;
-#define YY_NUM_RULES 201
-#define YY_END_OF_BUFFER 202
-static yyconst short int yy_accept[836] =
+#define YY_NUM_RULES 202
+#define YY_END_OF_BUFFER 203
+static yyconst short int yy_accept[837] =
{ 0,
- 0, 0, 0, 0, 0, 0, 0, 0, 190, 190,
+ 0, 0, 0, 0, 0, 0, 0, 0, 191, 191,
0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
- 202, 196, 197, 129, 128, 136, 198, 141, 184, 198,
- 198, 198, 198, 198, 198, 198, 198, 198, 198, 198,
- 198, 198, 198, 139, 198, 150, 152, 160, 156, 198,
- 162, 154, 158, 198, 188, 121, 132, 126, 91, 92,
- 97, 84, 104, 121, 110, 110, 121, 83, 121, 86,
- 98, 120, 93, 99, 94, 101, 102, 120, 120, 120,
- 120, 120, 120, 120, 120, 120, 120, 120, 95, 85,
- 96, 103, 121, 190, 195, 195, 132, 126, 104, 110,
-
- 110, 120, 101, 102, 120, 120, 120, 120, 120, 120,
- 120, 120, 120, 120, 120, 188, 126, 121, 110, 196,
- 120, 120, 120, 120, 120, 95, 121, 121, 121, 196,
- 196, 120, 120, 196, 199, 135, 134, 138, 200, 188,
- 141, 200, 184, 200, 200, 200, 200, 200, 200, 200,
- 200, 200, 200, 200, 200, 200, 200, 140, 200, 150,
- 152, 160, 156, 200, 162, 154, 158, 200, 200, 129,
- 128, 127, 184, 0, 0, 151, 0, 161, 0, 0,
- 0, 174, 0, 0, 0, 0, 159, 177, 178, 153,
- 155, 0, 0, 179, 164, 163, 181, 0, 0, 0,
-
- 180, 157, 183, 185, 186, 188, 121, 132, 131, 126,
- 125, 187, 88, 82, 0, 110, 0, 0, 90, 87,
- 89, 120, 119, 0, 119, 120, 120, 120, 120, 120,
- 120, 60, 120, 74, 120, 120, 68, 120, 120, 71,
- 120, 120, 189, 0, 0, 190, 191, 0, 194, 192,
- 193, 0, 132, 131, 126, 0, 0, 109, 0, 110,
- 0, 0, 118, 120, 119, 0, 0, 120, 120, 120,
- 120, 120, 120, 60, 120, 74, 120, 120, 68, 120,
- 120, 71, 120, 120, 0, 126, 0, 110, 0, 0,
- 0, 119, 119, 119, 119, 119, 119, 119, 119, 119,
-
- 119, 119, 119, 119, 119, 119, 119, 0, 120, 120,
- 74, 120, 68, 189, 0, 120, 135, 134, 133, 137,
- 148, 149, 173, 166, 167, 168, 169, 182, 165, 147,
- 146, 176, 172, 145, 170, 142, 143, 144, 175, 171,
- 126, 124, 187, 187, 187, 187, 113, 106, 108, 119,
- 119, 120, 120, 120, 120, 120, 120, 120, 120, 120,
- 120, 120, 75, 120, 120, 120, 120, 120, 0, 0,
- 1, 1, 0, 130, 124, 0, 0, 113, 106, 108,
- 119, 119, 0, 0, 0, 120, 120, 120, 120, 120,
- 120, 120, 120, 120, 120, 120, 75, 120, 120, 120,
-
- 120, 120, 0, 0, 0, 18, 19, 0, 119, 119,
- 119, 119, 12, 119, 119, 119, 119, 119, 119, 17,
- 119, 15, 119, 119, 119, 11, 119, 119, 6, 119,
- 119, 119, 119, 14, 119, 119, 119, 13, 119, 119,
- 117, 120, 75, 52, 187, 0, 119, 53, 120, 55,
- 120, 120, 58, 120, 120, 120, 120, 120, 120, 120,
- 70, 72, 120, 0, 0, 0, 0, 0, 0, 0,
- 0, 123, 0, 0, 112, 0, 105, 107, 119, 119,
- 122, 0, 53, 120, 55, 120, 120, 58, 120, 120,
- 120, 120, 120, 120, 120, 70, 72, 120, 46, 0,
-
- 100, 119, 119, 119, 119, 119, 119, 119, 119, 119,
- 119, 119, 119, 119, 119, 119, 16, 119, 7, 119,
- 119, 119, 119, 119, 119, 119, 119, 119, 119, 119,
- 119, 117, 53, 0, 113, 80, 54, 120, 120, 120,
- 120, 62, 120, 120, 120, 120, 73, 0, 0, 0,
- 0, 0, 0, 0, 0, 111, 0, 113, 119, 119,
- 114, 54, 120, 120, 120, 120, 62, 120, 120, 120,
- 120, 73, 0, 0, 119, 22, 119, 119, 20, 119,
- 119, 119, 119, 119, 119, 119, 119, 119, 119, 119,
- 115, 119, 119, 119, 119, 119, 119, 119, 119, 119,
-
- 119, 119, 119, 120, 120, 59, 61, 63, 64, 120,
- 120, 67, 120, 0, 0, 0, 0, 0, 0, 0,
- 0, 78, 119, 120, 120, 59, 61, 63, 64, 120,
- 120, 67, 120, 119, 119, 119, 119, 119, 119, 35,
- 119, 36, 119, 119, 119, 119, 34, 119, 119, 40,
- 119, 23, 119, 119, 38, 116, 119, 119, 39, 119,
- 56, 120, 120, 120, 120, 0, 0, 0, 0, 0,
- 0, 0, 0, 2, 2, 119, 76, 56, 120, 120,
- 120, 120, 119, 119, 119, 119, 119, 119, 119, 119,
- 119, 119, 119, 119, 119, 119, 33, 119, 21, 119,
-
- 119, 57, 65, 120, 69, 0, 0, 0, 0, 0,
- 0, 0, 119, 119, 57, 65, 120, 69, 119, 119,
- 41, 119, 32, 37, 119, 119, 119, 119, 25, 119,
- 119, 119, 119, 119, 119, 119, 81, 66, 0, 0,
- 0, 0, 48, 0, 0, 79, 119, 66, 119, 119,
- 29, 119, 30, 31, 42, 43, 44, 45, 119, 119,
- 119, 28, 0, 0, 0, 0, 0, 0, 0, 77,
- 8, 119, 9, 24, 119, 119, 0, 0, 51, 50,
- 0, 0, 119, 119, 119, 0, 3, 3, 0, 0,
- 119, 119, 10, 0, 0, 47, 119, 119, 0, 0,
-
- 27, 119, 5, 0, 119, 0, 0, 119, 0, 0,
- 119, 0, 49, 26, 0, 0, 0, 0, 0, 0,
+ 203, 197, 198, 130, 129, 137, 199, 142, 185, 199,
+ 199, 199, 199, 199, 199, 199, 199, 199, 199, 199,
+ 199, 199, 199, 140, 199, 151, 153, 161, 157, 199,
+ 163, 155, 159, 199, 189, 122, 133, 127, 92, 93,
+ 98, 85, 105, 122, 111, 111, 122, 84, 122, 87,
+ 99, 121, 94, 100, 95, 102, 103, 121, 121, 121,
+ 121, 121, 121, 121, 121, 121, 121, 121, 96, 86,
+ 97, 104, 122, 191, 196, 196, 133, 127, 105, 111,
+
+ 111, 121, 102, 103, 121, 121, 121, 121, 121, 121,
+ 121, 121, 121, 121, 121, 189, 127, 122, 111, 197,
+ 121, 121, 121, 121, 121, 96, 122, 122, 122, 197,
+ 197, 121, 121, 197, 200, 136, 135, 139, 201, 189,
+ 142, 201, 185, 201, 201, 201, 201, 201, 201, 201,
+ 201, 201, 201, 201, 201, 201, 201, 141, 201, 151,
+ 153, 161, 157, 201, 163, 155, 159, 201, 201, 130,
+ 129, 128, 185, 0, 0, 152, 0, 162, 0, 0,
+ 0, 175, 0, 0, 0, 0, 160, 178, 179, 154,
+ 156, 0, 0, 180, 165, 164, 182, 0, 0, 0,
+
+ 181, 158, 184, 186, 187, 189, 122, 133, 132, 127,
+ 126, 188, 89, 83, 0, 111, 0, 0, 91, 88,
+ 90, 121, 120, 0, 120, 121, 121, 121, 121, 121,
+ 121, 61, 121, 75, 121, 121, 69, 121, 121, 72,
+ 121, 121, 190, 0, 0, 191, 192, 0, 195, 193,
+ 194, 0, 133, 132, 127, 0, 0, 110, 0, 111,
+ 0, 0, 119, 121, 120, 0, 0, 121, 121, 121,
+ 121, 121, 121, 61, 121, 75, 121, 121, 69, 121,
+ 121, 72, 121, 121, 0, 127, 0, 111, 0, 0,
+ 0, 120, 120, 120, 120, 120, 120, 120, 120, 120,
+
+ 120, 120, 120, 120, 120, 120, 120, 0, 121, 121,
+ 75, 121, 69, 190, 0, 121, 136, 135, 134, 138,
+ 149, 150, 174, 167, 168, 169, 170, 183, 166, 148,
+ 147, 177, 173, 146, 171, 143, 144, 145, 176, 172,
+ 127, 125, 188, 188, 188, 188, 114, 107, 109, 120,
+ 120, 121, 121, 121, 121, 121, 121, 121, 121, 121,
+ 121, 121, 76, 121, 121, 121, 121, 121, 0, 0,
+ 1, 1, 0, 131, 125, 0, 0, 114, 107, 109,
+ 120, 120, 0, 0, 0, 121, 121, 121, 121, 121,
+ 121, 121, 121, 121, 121, 121, 76, 121, 121, 121,
+
+ 121, 121, 0, 0, 0, 18, 19, 0, 120, 120,
+ 120, 120, 12, 120, 120, 120, 120, 120, 120, 17,
+ 120, 15, 120, 120, 120, 11, 120, 120, 6, 120,
+ 120, 120, 120, 14, 120, 120, 120, 13, 120, 120,
+ 118, 121, 76, 53, 188, 0, 120, 54, 121, 56,
+ 121, 121, 59, 121, 121, 121, 121, 121, 121, 121,
+ 71, 73, 121, 0, 0, 52, 52, 52, 52, 52,
+ 52, 0, 124, 0, 0, 113, 0, 106, 108, 120,
+ 120, 123, 0, 54, 121, 56, 121, 121, 59, 121,
+ 121, 121, 121, 121, 121, 121, 71, 73, 121, 46,
+
+ 0, 101, 120, 120, 120, 120, 120, 120, 120, 120,
+ 120, 120, 120, 120, 120, 120, 120, 16, 120, 7,
+ 120, 120, 120, 120, 120, 120, 120, 120, 120, 120,
+ 120, 120, 118, 54, 0, 114, 81, 55, 121, 121,
+ 121, 121, 63, 121, 121, 121, 121, 74, 52, 52,
+ 52, 52, 52, 52, 52, 0, 112, 0, 114, 120,
+ 120, 115, 55, 121, 121, 121, 121, 63, 121, 121,
+ 121, 121, 74, 0, 0, 120, 22, 120, 120, 20,
+ 120, 120, 120, 120, 120, 120, 120, 120, 120, 120,
+ 120, 116, 120, 120, 120, 120, 120, 120, 120, 120,
+
+ 120, 120, 120, 120, 121, 121, 60, 62, 64, 65,
+ 121, 121, 68, 121, 52, 52, 52, 52, 52, 52,
+ 52, 0, 79, 120, 121, 121, 60, 62, 64, 65,
+ 121, 121, 68, 121, 120, 120, 120, 120, 120, 120,
+ 35, 120, 36, 120, 120, 120, 120, 34, 120, 120,
+ 40, 120, 23, 120, 120, 38, 117, 120, 120, 39,
+ 120, 57, 121, 121, 121, 121, 52, 52, 52, 52,
+ 52, 52, 52, 0, 2, 2, 120, 77, 57, 121,
+ 121, 121, 121, 120, 120, 120, 120, 120, 120, 120,
+ 120, 120, 120, 120, 120, 120, 120, 33, 120, 21,
+
+ 120, 120, 58, 66, 121, 70, 52, 52, 52, 52,
+ 52, 52, 52, 120, 120, 58, 66, 121, 70, 120,
+ 120, 41, 120, 32, 37, 120, 120, 120, 120, 25,
+ 120, 120, 120, 120, 120, 120, 120, 82, 67, 52,
+ 0, 52, 52, 48, 52, 52, 80, 120, 67, 120,
+ 120, 29, 120, 30, 31, 42, 43, 44, 45, 120,
+ 120, 120, 28, 52, 0, 0, 52, 52, 52, 52,
+ 78, 8, 120, 9, 24, 120, 120, 52, 0, 51,
+ 50, 52, 52, 120, 120, 120, 52, 3, 3, 52,
+ 52, 120, 120, 10, 52, 52, 47, 120, 120, 52,
+
+ 52, 27, 120, 5, 52, 120, 0, 52, 120, 0,
+ 52, 120, 0, 49, 26, 0, 0, 0, 0, 0,
0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
- 0, 0, 0, 4, 0
+ 0, 0, 0, 0, 4, 0
} ;
static yyconst int yy_ec[256] =
static yyconst int yy_meta[92] =
{ 0,
- 1, 1, 2, 1, 3, 4, 3, 5, 6, 4,
- 4, 7, 3, 3, 4, 3, 8, 4, 4, 9,
- 9, 9, 9, 9, 9, 9, 4, 3, 4, 4,
- 4, 10, 11, 11, 11, 11, 11, 11, 12, 12,
- 12, 12, 12, 12, 12, 12, 12, 12, 12, 12,
- 12, 12, 12, 12, 12, 12, 12, 12, 13, 14,
- 13, 10, 15, 16, 17, 17, 17, 17, 17, 17,
- 18, 18, 18, 18, 18, 18, 18, 18, 18, 18,
- 18, 18, 18, 18, 18, 18, 18, 19, 4, 20,
- 4
+ 1, 2, 3, 2, 4, 5, 6, 7, 8, 5,
+ 5, 9, 6, 6, 5, 6, 10, 5, 5, 11,
+ 11, 11, 11, 11, 11, 11, 5, 6, 5, 5,
+ 5, 12, 13, 13, 13, 13, 13, 13, 14, 14,
+ 14, 14, 14, 14, 14, 14, 14, 14, 14, 14,
+ 14, 14, 14, 14, 14, 14, 14, 14, 15, 16,
+ 15, 12, 17, 18, 19, 19, 19, 19, 19, 19,
+ 20, 20, 20, 20, 20, 20, 20, 20, 20, 20,
+ 20, 20, 20, 20, 20, 20, 20, 21, 5, 22,
+ 5
} ;
-static yyconst short int yy_base[879] =
+static yyconst short int yy_base[881] =
{ 0,
- 0, 0, 0, 4, 58, 138, 224, 2188, 0, 1,
- 315, 2187, 402, 0, 487, 0, 25, 39, 578, 0,
- 2194, 2197, 2197, 2181, 2184, 2197, 2197, 2197, 13, 2156,
- 7, 12, 12, 21, 10, 2139, 2137, 2150, 18, 2136,
- 69, 2135, 2133, 2197, 0, 2197, 2197, 2197, 2197, 0,
- 2197, 2197, 2197, 0, 50, 0, 2177, 2171, 2197, 2197,
- 0, 2197, 46, 2164, 131, 415, 2154, 2197, 2163, 2148,
- 0, 0, 2197, 0, 2197, 6, 2197, 11, 36, 2103,
- 2104, 30, 2107, 2097, 2104, 2104, 47, 2100, 2154, 0,
- 2197, 0, 52, 0, 13, 2, 2163, 2157, 425, 662,
-
- 506, 2160, 66, 2103, 66, 452, 105, 2, 129, 124,
+ 0, 0, 0, 4, 58, 138, 224, 2450, 0, 1,
+ 315, 2449, 402, 0, 487, 0, 25, 39, 578, 0,
+ 2456, 2459, 2459, 2443, 2446, 2459, 2459, 2459, 13, 2418,
+ 7, 12, 12, 21, 10, 2401, 2399, 2412, 18, 2398,
+ 69, 2397, 2395, 2459, 0, 2459, 2459, 2459, 2459, 0,
+ 2459, 2459, 2459, 0, 50, 0, 2439, 2433, 2459, 2459,
+ 0, 2459, 46, 2426, 131, 415, 2416, 2459, 2425, 2410,
+ 0, 0, 2459, 0, 2459, 6, 2459, 11, 36, 2365,
+ 2366, 30, 2369, 2359, 2366, 2366, 47, 2362, 2416, 0,
+ 2459, 0, 52, 0, 13, 2, 2425, 2419, 425, 662,
+
+ 506, 2422, 66, 2365, 66, 452, 105, 2, 129, 124,
107, 131, 138, 663, 42, 407, 0, 148, 515, 745,
- 5, 158, 421, 449, 455, 2149, 0, 2148, 2133, 2100,
- 2098, 122, 135, 2144, 2197, 2153, 2151, 2147, 2197, 192,
- 2197, 2140, 652, 2121, 132, 169, 417, 497, 370, 2104,
- 2102, 2115, 137, 2101, 648, 2100, 2098, 2197, 0, 2197,
- 2197, 2197, 2197, 686, 2197, 2197, 2197, 0, 2132, 2136,
- 2139, 2197, 692, 2103, 2101, 2197, 2098, 2197, 669, 2099,
- 2105, 2197, 2092, 2088, 2104, 410, 2197, 2197, 2197, 2197,
- 2197, 2095, 2093, 2197, 2197, 2096, 2197, 2079, 2100, 2087,
-
- 2197, 2197, 2197, 699, 0, 723, 0, 2125, 2197, 2119,
- 2197, 727, 0, 0, 734, 745, 722, 0, 0, 2197,
- 0, 0, 0, 2067, 2062, 2047, 2062, 2044, 141, 2044,
- 2056, 0, 2044, 464, 2040, 2053, 0, 2043, 2050, 0,
- 2039, 2048, 2108, 210, 2042, 0, 0, 2097, 2197, 0,
- 2197, 2025, 2105, 2103, 2098, 796, 815, 2197, 822, 841,
- 752, 0, 2197, 2101, 114, 2100, 0, 410, 435, 424,
- 488, 489, 454, 2099, 495, 725, 484, 493, 2098, 726,
- 451, 2097, 673, 730, 2087, 2091, 830, 863, 2039, 2038,
- 2040, 846, 524, 772, 2036, 2060, 2034, 2059, 699, 738,
-
- 2045, 2044, 843, 641, 501, 2043, 2014, 0, 694, 819,
- 821, 823, 849, 2197, 2001, 753, 2083, 2081, 2197, 2197,
- 2197, 2197, 2197, 2197, 2197, 2197, 2197, 2197, 2197, 2197,
- 2197, 2197, 2197, 2197, 2197, 2197, 2197, 2197, 2197, 2197,
- 2076, 2197, 873, 893, 899, 908, 894, 901, 0, 0,
- 2020, 2017, 2004, 2019, 2018, 2009, 2012, 2007, 2001, 2005,
- 1995, 2007, 0, 1992, 2009, 1996, 2003, 1991, 925, 865,
- 2197, 869, 1993, 2197, 2061, 912, 0, 930, 957, 2060,
- 1986, 2001, 2001, 2056, 2051, 899, 779, 884, 931, 797,
- 900, 932, 671, 933, 934, 935, 2054, 936, 937, 816,
-
- 938, 731, 1971, 2052, 963, 2197, 2197, 1996, 2007, 918,
- 2009, 2004, 0, 2017, 2008, 2015, 1999, 2016, 2002, 0,
- 1986, 0, 1996, 1995, 1983, 0, 928, 897, 0, 2004,
- 953, 1993, 2006, 0, 1994, 2008, 2003, 0, 1996, 1958,
- 0, 966, 984, 2197, 1006, 1000, 1974, 0, 1955, 0,
- 1952, 1950, 0, 1956, 1952, 1945, 1965, 1949, 1953, 1951,
- 0, 0, 1957, 1025, 1036, 1991, 1987, 1977, 1989, 1973,
- 1951, 2197, 1023, 2011, 2010, 1068, 2197, 2197, 1941, 1941,
- 2197, 2003, 2006, 956, 2005, 951, 987, 2004, 990, 993,
- 696, 989, 1004, 1025, 1006, 2003, 2002, 995, 2197, 1081,
-
- 2197, 1957, 1945, 1944, 1973, 1942, 1957, 1940, 1951, 408,
- 1955, 1948, 1963, 1965, 1947, 1956, 0, 1932, 0, 1957,
- 1957, 1953, 1947, 1945, 1952, 1953, 1924, 1938, 1935, 1934,
- 1918, 0, 1041, 1088, 1095, 0, 0, 1907, 1908, 1909,
- 1897, 938, 1901, 1907, 1907, 1902, 0, 1934, 1932, 1921,
- 1933, 1926, 1930, 1931, 1962, 2197, 1102, 1121, 1903, 1890,
- 2197, 1956, 1055, 1060, 1028, 1049, 1057, 1071, 140, 1066,
- 1078, 1955, 1132, 1141, 1912, 0, 1925, 1903, 0, 1896,
- 1923, 1905, 1893, 1905, 1891, 1890, 1889, 1901, 1913, 1886,
- 0, 1900, 1910, 1883, 1892, 1881, 1899, 1015, 1148, 1894,
-
- 1878, 1877, 1864, 1856, 1860, 0, 0, 0, 0, 1869,
- 1870, 0, 1857, 1898, 1886, 1879, 1883, 1888, 1887, 1892,
- 1048, 1887, 1862, 1052, 1128, 1916, 1915, 1914, 1913, 1130,
- 1131, 1912, 1132, 1886, 1877, 1866, 1881, 1880, 1869, 0,
- 1876, 0, 1877, 1876, 1871, 1874, 0, 1845, 1869, 0,
- 1870, 0, 1842, 1871, 0, 1155, 1840, 1867, 0, 1826,
- 0, 1829, 1830, 1831, 1826, 1833, 1858, 1844, 1825, 1805,
- 1814, 1807, 1156, 2197, 1179, 1810, 1804, 1827, 1142, 1176,
- 1177, 1178, 1786, 1784, 1755, 1780, 1750, 1733, 1736, 1750,
- 1749, 1730, 1716, 1148, 1733, 1732, 0, 1703, 0, 1694,
-
- 1657, 0, 0, 1640, 0, 1631, 1672, 1643, 1636, 1634,
- 1604, 1632, 1601, 1626, 1651, 1623, 1179, 1605, 1547, 1545,
- 0, 1533, 0, 0, 1541, 1528, 1518, 1511, 0, 1503,
- 1502, 1501, 1507, 1494, 1515, 1490, 0, 0, 1501, 1532,
- 1506, 1472, 2197, 1438, 1427, 0, 1397, 1442, 1385, 1396,
- 0, 1379, 0, 0, 0, 0, 0, 0, 1377, 1403,
- 1385, 0, 1401, 1409, 1171, 1356, 1343, 1348, 1352, 0,
- 0, 1328, 0, 0, 1349, 1352, 1334, 1187, 2197, 2197,
- 1222, 1004, 1224, 1223, 1194, 1211, 2197, 1238, 1207, 1216,
- 1217, 1199, 0, 1217, 1203, 2197, 1183, 1192, 1237, 1205,
-
- 0, 1177, 1198, 1197, 1200, 1188, 1187, 1197, 1160, 1172,
- 1147, 1171, 2197, 0, 1157, 1059, 1062, 1024, 1016, 1037,
- 894, 765, 744, 733, 658, 650, 527, 548, 1194, 1201,
- 408, 396, 96, 2197, 2197, 1261, 1281, 1301, 1321, 1341,
- 1359, 1370, 1183, 1382, 1394, 1412, 1426, 1434, 1452, 1472,
- 1492, 1509, 1527, 1543, 1551, 1567, 1583, 1599, 1617, 1637,
- 1184, 1651, 1663, 1681, 1701, 1721, 1739, 1755, 1219, 1771,
- 1789, 1185, 1805, 1821, 1220, 1835, 1853, 1873
+ 5, 158, 421, 449, 455, 2411, 0, 2410, 2395, 2362,
+ 2360, 122, 135, 2406, 2459, 2415, 2413, 2409, 2459, 192,
+ 2459, 2402, 652, 2383, 132, 169, 417, 497, 370, 2366,
+ 2364, 2377, 137, 2363, 648, 2362, 2360, 2459, 0, 2459,
+ 2459, 2459, 2459, 686, 2459, 2459, 2459, 0, 2394, 2398,
+ 2401, 2459, 692, 2365, 2363, 2459, 2360, 2459, 669, 2361,
+ 2367, 2459, 2354, 2350, 2366, 410, 2459, 2459, 2459, 2459,
+ 2459, 2357, 2355, 2459, 2459, 2358, 2459, 2341, 2362, 2349,
+
+ 2459, 2459, 2459, 699, 0, 723, 0, 2387, 2459, 2381,
+ 2459, 727, 0, 0, 734, 745, 722, 0, 0, 2459,
+ 0, 0, 0, 2329, 2324, 2309, 2324, 2306, 141, 2306,
+ 2318, 0, 2306, 464, 2302, 2315, 0, 2305, 2312, 0,
+ 2301, 2310, 2370, 210, 2304, 0, 0, 2359, 2459, 0,
+ 2459, 2287, 2367, 2365, 2360, 796, 815, 2459, 822, 841,
+ 752, 0, 2459, 2363, 114, 2362, 0, 410, 435, 424,
+ 488, 489, 454, 2361, 495, 725, 484, 493, 2360, 726,
+ 451, 2359, 673, 730, 2349, 2353, 830, 863, 2301, 2300,
+ 2302, 846, 524, 772, 2298, 2322, 2296, 2321, 699, 738,
+
+ 2307, 2306, 843, 641, 501, 2305, 2276, 0, 694, 819,
+ 821, 823, 849, 2459, 2263, 753, 2345, 2343, 2459, 2459,
+ 2459, 2459, 2459, 2459, 2459, 2459, 2459, 2459, 2459, 2459,
+ 2459, 2459, 2459, 2459, 2459, 2459, 2459, 2459, 2459, 2459,
+ 2338, 2459, 873, 893, 899, 908, 894, 901, 0, 0,
+ 2282, 2279, 2266, 2281, 2280, 2271, 2274, 2269, 2263, 2267,
+ 2257, 2269, 0, 2254, 2271, 2258, 2265, 2253, 925, 865,
+ 2459, 869, 2255, 2459, 2323, 912, 0, 930, 957, 2322,
+ 2248, 2263, 2263, 2318, 2313, 899, 779, 884, 931, 797,
+ 900, 932, 671, 933, 934, 935, 2316, 936, 937, 816,
+
+ 938, 731, 2233, 2314, 963, 2459, 2459, 2258, 2269, 918,
+ 2271, 2266, 0, 2279, 2270, 2277, 2261, 2278, 2264, 0,
+ 2248, 0, 2258, 2257, 2245, 0, 928, 897, 0, 2266,
+ 953, 2255, 2268, 0, 2256, 2270, 2265, 0, 2258, 2220,
+ 0, 966, 984, 2459, 1006, 1000, 2236, 0, 2217, 0,
+ 2214, 2212, 0, 2218, 2214, 2207, 2227, 2211, 2215, 2213,
+ 0, 0, 2219, 1025, 660, 1034, 1038, 1042, 1046, 1050,
+ 1060, 2218, 2459, 1064, 2278, 2277, 1076, 2459, 2459, 2208,
+ 2208, 2459, 2270, 2273, 990, 2272, 951, 989, 2271, 956,
+ 987, 995, 1004, 1010, 1005, 1006, 2270, 2269, 1048, 2459,
+
+ 1089, 2459, 2224, 2212, 2211, 2240, 2209, 2224, 2207, 2218,
+ 408, 2222, 2215, 2230, 2232, 2214, 2223, 0, 2199, 0,
+ 2224, 2224, 2220, 2214, 2212, 2219, 2220, 2191, 2205, 2202,
+ 2201, 2185, 0, 1051, 1098, 1105, 0, 0, 2174, 2175,
+ 2176, 2164, 1057, 2168, 2174, 2174, 2169, 0, 1131, 1136,
+ 1140, 1144, 1148, 1154, 1158, 2236, 2459, 1144, 1164, 2177,
+ 2164, 2459, 2230, 1099, 1108, 1023, 993, 1146, 1147, 140,
+ 1165, 1167, 2229, 1176, 1186, 2186, 0, 2199, 2177, 0,
+ 2170, 2197, 2179, 2167, 2179, 2165, 2164, 2163, 2175, 2168,
+ 2115, 0, 2128, 2138, 2109, 2117, 2104, 2122, 1142, 1193,
+
+ 2115, 2099, 2098, 2085, 2077, 2081, 0, 0, 0, 0,
+ 2090, 2091, 0, 2069, 1225, 1233, 1239, 1243, 1247, 1251,
+ 1259, 1074, 2092, 2066, 1097, 1195, 2120, 2117, 2115, 2098,
+ 1172, 1168, 2087, 1196, 2060, 2051, 2038, 2052, 2050, 2032,
+ 0, 2017, 0, 1999, 1988, 1973, 1943, 0, 1913, 1937,
+ 0, 1936, 0, 1907, 1933, 0, 1245, 1901, 1928, 0,
+ 1885, 0, 1887, 1859, 1842, 1823, 1272, 1278, 1282, 1293,
+ 1298, 1302, 1306, 1219, 2459, 1228, 1857, 1852, 1880, 1249,
+ 1250, 1251, 1270, 1851, 1841, 1806, 1825, 1796, 1795, 1802,
+ 1816, 1815, 1796, 1782, 1271, 1799, 1798, 0, 1772, 0,
+
+ 1746, 1696, 0, 0, 1679, 0, 1321, 1325, 1346, 1350,
+ 1354, 1358, 1362, 1673, 1699, 1725, 1718, 1305, 1717, 1660,
+ 1641, 0, 1616, 0, 0, 1626, 1614, 1612, 1611, 0,
+ 1610, 1607, 1593, 1474, 1462, 1483, 1458, 0, 0, 1368,
+ 1502, 1373, 1378, 1394, 1398, 1402, 0, 1455, 1495, 1439,
+ 1450, 0, 1437, 0, 0, 0, 0, 0, 0, 1436,
+ 1459, 1441, 0, 1407, 1464, 1203, 1411, 1420, 1428, 1432,
+ 0, 0, 1416, 0, 0, 1436, 1434, 1439, 1435, 1445,
+ 1451, 1455, 1462, 1393, 1392, 1357, 1288, 2459, 1400, 1287,
+ 1424, 1359, 1338, 0, 1335, 1418, 1334, 1326, 1337, 1440,
+
+ 1432, 0, 1321, 1301, 1429, 1305, 1290, 1438, 1296, 1262,
+ 1446, 1236, 1252, 1368, 0, 1175, 1140, 1070, 1060, 1037,
+ 1052, 894, 765, 744, 733, 741, 650, 527, 548, 1485,
+ 1507, 408, 396, 96, 2459, 2459, 1533, 1555, 1577, 1599,
+ 1621, 1640, 1651, 1475, 1664, 1677, 1696, 1710, 1718, 1738,
+ 1760, 1782, 1800, 1819, 1835, 1843, 1860, 1876, 1893, 1912,
+ 1934, 1503, 1948, 1960, 1980, 2002, 2024, 2044, 2061, 1504,
+ 2077, 2097, 1297, 2113, 2130, 2151, 1709, 2160, 2180, 2202
} ;
-static yyconst short int yy_def[879] =
+static yyconst short int yy_def[881] =
{ 0,
- 836, 836, 837, 837, 838, 838, 835, 7, 839, 839,
- 835, 11, 11, 13, 11, 15, 840, 840, 835, 19,
- 835, 835, 835, 841, 835, 835, 835, 835, 835, 835,
- 835, 835, 835, 835, 835, 835, 835, 835, 835, 835,
- 835, 835, 835, 835, 842, 835, 835, 835, 835, 835,
- 835, 835, 835, 843, 835, 844, 845, 846, 835, 835,
- 844, 835, 844, 844, 835, 835, 844, 835, 844, 844,
- 844, 847, 835, 844, 835, 848, 835, 847, 847, 847,
- 847, 847, 847, 847, 847, 847, 847, 847, 835, 844,
- 835, 844, 844, 849, 850, 851, 852, 853, 844, 835,
-
- 835, 854, 848, 855, 854, 854, 854, 854, 854, 854,
- 854, 854, 854, 854, 854, 835, 856, 99, 835, 848,
- 857, 857, 857, 857, 857, 835, 844, 844, 844, 848,
- 855, 854, 854, 835, 835, 858, 835, 835, 835, 835,
- 835, 835, 835, 835, 835, 835, 835, 835, 835, 835,
- 835, 835, 835, 835, 835, 835, 835, 835, 842, 835,
- 835, 835, 835, 835, 835, 835, 835, 843, 835, 841,
- 835, 835, 835, 835, 835, 835, 835, 835, 835, 835,
- 835, 835, 835, 835, 835, 835, 835, 835, 835, 835,
- 835, 835, 835, 835, 835, 835, 835, 835, 835, 835,
-
- 835, 835, 835, 835, 843, 835, 844, 845, 835, 859,
- 835, 860, 844, 844, 835, 835, 835, 861, 844, 835,
- 844, 862, 863, 848, 863, 862, 862, 862, 862, 862,
- 862, 862, 862, 862, 862, 862, 862, 862, 862, 862,
- 862, 862, 835, 864, 835, 865, 866, 866, 835, 867,
- 835, 867, 868, 835, 859, 835, 835, 835, 835, 835,
- 835, 869, 835, 854, 863, 870, 871, 854, 854, 854,
- 854, 854, 854, 854, 854, 854, 854, 854, 854, 854,
- 854, 854, 854, 854, 835, 859, 835, 835, 835, 835,
- 835, 863, 863, 863, 863, 863, 863, 863, 863, 863,
-
- 863, 863, 863, 863, 863, 863, 863, 872, 873, 873,
- 873, 873, 873, 835, 835, 854, 874, 835, 835, 835,
- 835, 835, 835, 835, 835, 835, 835, 835, 835, 835,
- 835, 835, 835, 835, 835, 835, 835, 835, 835, 835,
- 859, 835, 860, 860, 835, 860, 835, 835, 861, 863,
- 863, 862, 862, 862, 862, 862, 862, 862, 862, 862,
- 862, 862, 862, 862, 862, 862, 862, 862, 835, 864,
- 835, 864, 835, 835, 835, 835, 875, 835, 835, 869,
- 863, 863, 835, 870, 871, 854, 854, 854, 854, 854,
- 854, 854, 854, 854, 854, 854, 854, 854, 854, 854,
-
- 854, 854, 835, 835, 835, 835, 835, 835, 863, 863,
- 863, 863, 863, 863, 863, 863, 863, 863, 863, 863,
- 863, 863, 863, 863, 863, 863, 863, 863, 863, 863,
- 863, 863, 863, 863, 863, 863, 863, 863, 863, 863,
- 876, 873, 873, 835, 835, 835, 863, 862, 862, 862,
- 862, 862, 862, 862, 862, 862, 862, 862, 862, 862,
- 862, 862, 862, 835, 835, 835, 835, 835, 835, 835,
- 835, 835, 835, 875, 835, 835, 835, 835, 863, 863,
- 835, 835, 854, 854, 854, 854, 854, 854, 854, 854,
- 854, 854, 854, 854, 854, 854, 854, 854, 835, 835,
-
- 835, 863, 863, 863, 863, 863, 863, 863, 863, 863,
- 863, 863, 863, 863, 863, 863, 863, 863, 863, 863,
- 863, 863, 863, 863, 863, 863, 863, 863, 863, 863,
- 863, 876, 873, 835, 835, 863, 862, 862, 862, 862,
- 862, 862, 862, 862, 862, 862, 862, 835, 835, 835,
- 835, 835, 835, 835, 835, 835, 835, 835, 863, 863,
- 835, 854, 854, 854, 854, 854, 854, 854, 854, 854,
- 854, 854, 835, 835, 863, 863, 863, 863, 863, 863,
- 863, 863, 863, 863, 863, 863, 863, 863, 863, 863,
- 863, 863, 863, 863, 863, 863, 863, 863, 863, 863,
+ 837, 837, 838, 838, 839, 839, 836, 7, 840, 840,
+ 836, 11, 11, 13, 11, 15, 841, 841, 836, 19,
+ 836, 836, 836, 842, 836, 836, 836, 836, 836, 836,
+ 836, 836, 836, 836, 836, 836, 836, 836, 836, 836,
+ 836, 836, 836, 836, 843, 836, 836, 836, 836, 836,
+ 836, 836, 836, 844, 836, 845, 846, 847, 836, 836,
+ 845, 836, 845, 845, 836, 836, 845, 836, 845, 845,
+ 845, 848, 836, 845, 836, 849, 836, 848, 848, 848,
+ 848, 848, 848, 848, 848, 848, 848, 848, 836, 845,
+ 836, 845, 845, 850, 851, 852, 853, 854, 845, 836,
+
+ 836, 855, 849, 856, 855, 855, 855, 855, 855, 855,
+ 855, 855, 855, 855, 855, 836, 857, 99, 836, 849,
+ 858, 858, 858, 858, 858, 836, 845, 845, 845, 849,
+ 856, 855, 855, 836, 836, 859, 836, 836, 836, 836,
+ 836, 836, 836, 836, 836, 836, 836, 836, 836, 836,
+ 836, 836, 836, 836, 836, 836, 836, 836, 843, 836,
+ 836, 836, 836, 836, 836, 836, 836, 844, 836, 842,
+ 836, 836, 836, 836, 836, 836, 836, 836, 836, 836,
+ 836, 836, 836, 836, 836, 836, 836, 836, 836, 836,
+ 836, 836, 836, 836, 836, 836, 836, 836, 836, 836,
- 863, 863, 863, 862, 862, 862, 862, 862, 862, 862,
- 862, 862, 862, 835, 835, 835, 835, 835, 835, 835,
- 877, 863, 863, 854, 854, 854, 854, 854, 854, 854,
- 854, 854, 854, 863, 863, 863, 863, 863, 863, 863,
+ 836, 836, 836, 836, 844, 836, 845, 846, 836, 860,
+ 836, 861, 845, 845, 836, 836, 836, 862, 845, 836,
+ 845, 863, 864, 849, 864, 863, 863, 863, 863, 863,
863, 863, 863, 863, 863, 863, 863, 863, 863, 863,
+ 863, 863, 836, 865, 836, 866, 867, 867, 836, 868,
+ 836, 868, 869, 836, 860, 836, 836, 836, 836, 836,
+ 836, 870, 836, 855, 864, 871, 872, 855, 855, 855,
+ 855, 855, 855, 855, 855, 855, 855, 855, 855, 855,
+ 855, 855, 855, 855, 836, 860, 836, 836, 836, 836,
+ 836, 864, 864, 864, 864, 864, 864, 864, 864, 864,
+
+ 864, 864, 864, 864, 864, 864, 864, 873, 874, 874,
+ 874, 874, 874, 836, 836, 855, 875, 836, 836, 836,
+ 836, 836, 836, 836, 836, 836, 836, 836, 836, 836,
+ 836, 836, 836, 836, 836, 836, 836, 836, 836, 836,
+ 860, 836, 861, 861, 836, 861, 836, 836, 862, 864,
+ 864, 863, 863, 863, 863, 863, 863, 863, 863, 863,
+ 863, 863, 863, 863, 863, 863, 863, 863, 876, 865,
+ 836, 865, 836, 836, 836, 836, 877, 836, 836, 870,
+ 864, 864, 836, 871, 872, 855, 855, 855, 855, 855,
+ 855, 855, 855, 855, 855, 855, 855, 855, 855, 855,
+
+ 855, 855, 836, 836, 836, 836, 836, 836, 864, 864,
+ 864, 864, 864, 864, 864, 864, 864, 864, 864, 864,
+ 864, 864, 864, 864, 864, 864, 864, 864, 864, 864,
+ 864, 864, 864, 864, 864, 864, 864, 864, 864, 864,
+ 878, 874, 874, 836, 836, 836, 864, 863, 863, 863,
863, 863, 863, 863, 863, 863, 863, 863, 863, 863,
- 862, 862, 862, 862, 862, 835, 835, 835, 835, 835,
- 835, 835, 877, 835, 877, 863, 863, 854, 854, 854,
- 854, 854, 863, 863, 863, 863, 863, 863, 863, 863,
- 863, 863, 863, 863, 863, 863, 863, 863, 863, 863,
+ 863, 863, 863, 876, 464, 876, 876, 876, 876, 876,
+ 876, 836, 836, 836, 877, 836, 836, 836, 836, 864,
+ 864, 836, 836, 855, 855, 855, 855, 855, 855, 855,
+ 855, 855, 855, 855, 855, 855, 855, 855, 855, 836,
- 863, 862, 862, 862, 862, 835, 835, 835, 835, 835,
- 835, 835, 863, 863, 854, 854, 854, 854, 863, 863,
- 863, 863, 863, 863, 863, 863, 863, 863, 863, 863,
- 863, 863, 863, 863, 863, 863, 863, 862, 835, 878,
- 835, 835, 835, 835, 835, 863, 863, 854, 863, 863,
- 863, 863, 863, 863, 863, 863, 863, 863, 863, 863,
- 863, 863, 835, 878, 878, 835, 835, 835, 835, 863,
- 863, 863, 863, 863, 863, 863, 835, 878, 835, 835,
- 835, 835, 863, 863, 863, 835, 835, 878, 835, 835,
- 863, 863, 863, 835, 835, 835, 863, 863, 835, 835,
-
- 863, 863, 835, 835, 863, 835, 835, 863, 835, 835,
- 863, 835, 835, 863, 835, 835, 835, 835, 835, 835,
- 835, 835, 835, 835, 835, 835, 835, 835, 835, 835,
- 835, 835, 835, 835, 0, 835, 835, 835, 835, 835,
- 835, 835, 835, 835, 835, 835, 835, 835, 835, 835,
- 835, 835, 835, 835, 835, 835, 835, 835, 835, 835,
- 835, 835, 835, 835, 835, 835, 835, 835, 835, 835,
- 835, 835, 835, 835, 835, 835, 835, 835
+ 836, 836, 864, 864, 864, 864, 864, 864, 864, 864,
+ 864, 864, 864, 864, 864, 864, 864, 864, 864, 864,
+ 864, 864, 864, 864, 864, 864, 864, 864, 864, 864,
+ 864, 864, 878, 874, 836, 836, 864, 863, 863, 863,
+ 863, 863, 863, 863, 863, 863, 863, 863, 876, 876,
+ 876, 876, 876, 876, 876, 836, 836, 836, 836, 864,
+ 864, 836, 855, 855, 855, 855, 855, 855, 855, 855,
+ 855, 855, 855, 836, 836, 864, 864, 864, 864, 864,
+ 864, 864, 864, 864, 864, 864, 864, 864, 864, 864,
+ 864, 864, 864, 864, 864, 864, 864, 864, 864, 864,
+
+ 864, 864, 864, 864, 863, 863, 863, 863, 863, 863,
+ 863, 863, 863, 863, 876, 876, 876, 876, 876, 876,
+ 876, 879, 864, 864, 855, 855, 855, 855, 855, 855,
+ 855, 855, 855, 855, 864, 864, 864, 864, 864, 864,
+ 864, 864, 864, 864, 864, 864, 864, 864, 864, 864,
+ 864, 864, 864, 864, 864, 864, 864, 864, 864, 864,
+ 864, 863, 863, 863, 863, 863, 876, 876, 876, 876,
+ 876, 876, 876, 879, 836, 879, 864, 864, 855, 855,
+ 855, 855, 855, 864, 864, 864, 864, 864, 864, 864,
+ 864, 864, 864, 864, 864, 864, 864, 864, 864, 864,
+
+ 864, 864, 863, 863, 863, 863, 876, 876, 876, 876,
+ 876, 876, 876, 864, 864, 855, 855, 855, 855, 864,
+ 864, 864, 864, 864, 864, 864, 864, 864, 864, 864,
+ 864, 864, 864, 864, 864, 864, 864, 864, 863, 876,
+ 880, 876, 876, 876, 876, 876, 864, 864, 855, 864,
+ 864, 864, 864, 864, 864, 864, 864, 864, 864, 864,
+ 864, 864, 864, 876, 880, 880, 876, 876, 876, 876,
+ 864, 864, 864, 864, 864, 864, 864, 876, 880, 876,
+ 876, 876, 876, 864, 864, 864, 783, 836, 880, 783,
+ 783, 864, 864, 864, 783, 783, 783, 864, 864, 783,
+
+ 783, 864, 864, 836, 783, 864, 836, 783, 864, 836,
+ 783, 864, 836, 783, 864, 836, 836, 836, 836, 836,
+ 836, 836, 836, 836, 836, 836, 836, 836, 836, 836,
+ 836, 836, 836, 836, 836, 0, 836, 836, 836, 836,
+ 836, 836, 836, 836, 836, 836, 836, 836, 836, 836,
+ 836, 836, 836, 836, 836, 836, 836, 836, 836, 836,
+ 836, 836, 836, 836, 836, 836, 836, 836, 836, 836,
+ 836, 836, 836, 836, 836, 836, 836, 836, 836, 836
} ;
-static yyconst short int yy_nxt[2289] =
+static yyconst short int yy_nxt[2551] =
{ 0,
- 23, 23, 23, 23, 23, 23, 23, 23, 835, 263,
- 835, 25, 263, 308, 835, 25, 95, 95, 251, 204,
+ 23, 23, 23, 23, 23, 23, 23, 23, 836, 263,
+ 836, 25, 263, 308, 836, 25, 95, 95, 251, 204,
204, 204, 204, 204, 204, 135, 135, 135, 135, 248,
- 835, 137, 173, 173, 173, 173, 173, 173, 173, 135,
+ 836, 137, 173, 173, 173, 173, 173, 173, 173, 135,
135, 135, 135, 175, 177, 137, 179, 187, 180, 263,
- 192, 206, 206, 206, 206, 181, 244, 176, 835, 26,
+ 192, 206, 206, 206, 206, 181, 244, 176, 836, 26,
188, 178, 212, 26, 28, 182, 183, 184, 224, 28,
193, 185, 186, 263, 273, 226, 213, 29, 29, 29,
29, 29, 29, 29, 138, 227, 225, 96, 96, 252,
268, 263, 265, 241, 49, 50, 263, 51, 263, 52,
269, 53, 263, 54, 28, 263, 225, 263, 215, 28,
216, 216, 216, 216, 216, 216, 216, 29, 29, 29,
- 29, 29, 29, 29, 835, 263, 308, 257, 175, 192,
+ 29, 29, 29, 29, 836, 263, 308, 257, 175, 192,
30, 31, 32, 33, 34, 35, 36, 37, 381, 272,
- 382, 38, 176, 39, 278, 834, 270, 40, 41, 193,
+ 382, 38, 176, 39, 278, 835, 270, 40, 41, 193,
42, 43, 277, 206, 206, 206, 206, 44, 274, 45,
- 279, 177, 46, 47, 275, 276, 280, 48, 217, 631,
+ 279, 177, 46, 47, 275, 276, 280, 48, 217, 632,
355, 316, 371, 372, 49, 50, 218, 51, 178, 52,
356, 53, 310, 54, 22, 55, 55, 55, 55, 56,
57, 56, 56, 56, 56, 58, 59, 60, 61, 62,
111, 102, 112, 102, 113, 102, 114, 102, 102, 115,
102, 102, 89, 90, 91, 92, 116, 187, 206, 206,
- 206, 206, 833, 117, 285, 832, 56, 263, 118, 56,
+ 206, 206, 834, 117, 285, 833, 56, 263, 118, 56,
188, 119, 119, 119, 119, 119, 119, 119, 263, 308,
56, 263, 215, 56, 216, 216, 216, 216, 216, 216,
216, 212, 263, 333, 256, 257, 257, 257, 257, 257,
- 257, 179, 583, 180, 584, 213, 263, 308, 263, 263,
+ 257, 179, 584, 180, 585, 213, 263, 308, 263, 263,
181, 263, 263, 308, 120, 334, 121, 121, 122, 121,
121, 121, 121, 121, 123, 121, 124, 121, 121, 125,
121, 121, 121, 121, 121, 121, 121, 121, 121, 126,
271, 392, 258, 259, 313, 260, 260, 260, 260, 260,
260, 260, 287, 360, 288, 288, 288, 288, 288, 288,
288, 182, 183, 184, 361, 362, 56, 185, 186, 130,
- 131, 437, 829, 102, 132, 102, 414, 389, 102, 133,
+ 131, 437, 830, 102, 132, 102, 414, 389, 102, 133,
398, 102, 102, 438, 102, 397, 102, 390, 102, 391,
- 415, 102, 828, 393, 134, 56, 22, 127, 139, 140,
+ 415, 102, 829, 393, 134, 56, 22, 127, 139, 140,
140, 140, 140, 139, 141, 139, 139, 139, 139, 141,
139, 139, 139, 139, 142, 139, 139, 143, 143, 143,
139, 167, 139, 168, 139, 169, 139, 139, 139, 258,
263, 173, 173, 173, 173, 173, 173, 173, 263, 259,
263, 260, 260, 260, 260, 260, 260, 260, 195, 324,
- 325, 326, 327, 435, 196, 197, 827, 436, 826, 198,
+ 325, 326, 327, 435, 196, 197, 828, 436, 549, 198,
- 199, 263, 308, 263, 200, 204, 204, 204, 204, 204,
+ 199, 263, 308, 550, 200, 204, 204, 204, 204, 204,
204, 173, 173, 173, 173, 173, 173, 173, 204, 204,
204, 204, 204, 204, 206, 206, 206, 206, 344, 345,
346, 344, 263, 263, 281, 424, 425, 263, 263, 261,
- 282, 348, 348, 348, 348, 348, 348, 262, 490, 283,
+ 282, 348, 348, 348, 348, 348, 348, 262, 491, 283,
289, 401, 290, 347, 347, 347, 347, 347, 347, 347,
263, 426, 215, 291, 216, 216, 216, 216, 216, 216,
216, 379, 379, 379, 379, 379, 379, 292, 427, 293,
- 294, 567, 295, 825, 428, 296, 263, 297, 298, 299,
- 300, 301, 302, 824, 394, 303, 304, 305, 402, 306,
+ 294, 827, 295, 826, 428, 296, 263, 297, 298, 299,
+ 300, 301, 302, 825, 394, 303, 304, 305, 402, 306,
- 429, 823, 399, 258, 263, 395, 396, 224, 416, 417,
- 498, 265, 418, 287, 307, 257, 257, 257, 257, 257,
+ 429, 824, 399, 258, 263, 395, 396, 224, 416, 417,
+ 499, 265, 418, 287, 307, 257, 257, 257, 257, 257,
257, 257, 258, 263, 419, 225, 263, 308, 263, 308,
263, 308, 287, 395, 257, 257, 257, 257, 257, 257,
257, 378, 378, 378, 378, 378, 378, 378, 258, 405,
- 405, 405, 405, 405, 405, 405, 263, 308, 259, 484,
- 260, 260, 260, 260, 260, 260, 260, 371, 372, 487,
+ 405, 405, 405, 405, 405, 405, 263, 308, 259, 485,
+ 260, 260, 260, 260, 260, 260, 260, 371, 372, 488,
258, 371, 372, 376, 344, 345, 346, 344, 432, 409,
287, 377, 288, 288, 288, 288, 288, 288, 288, 410,
- 433, 263, 496, 411, 344, 345, 346, 344, 412, 442,
+ 433, 263, 497, 411, 344, 345, 346, 344, 412, 442,
445, 445, 445, 445, 443, 434, 263, 263, 413, 344,
345, 346, 344, 347, 347, 347, 347, 347, 347, 347,
348, 348, 348, 348, 348, 348, 464, 464, 464, 465,
- 446, 473, 473, 473, 473, 473, 473, 475, 263, 263,
- 263, 263, 263, 263, 263, 263, 520, 822, 485, 378,
- 378, 378, 378, 378, 378, 378, 503, 466, 263, 521,
- 467, 504, 446, 263, 477, 468, 476, 483, 488, 469,
- 475, 518, 505, 263, 308, 470, 379, 379, 379, 379,
- 379, 379, 405, 405, 405, 405, 405, 405, 405, 523,
- 519, 263, 308, 524, 263, 486, 263, 263, 476, 500,
-
- 263, 495, 263, 493, 489, 491, 497, 445, 445, 445,
- 445, 263, 608, 263, 534, 492, 534, 609, 494, 535,
- 535, 535, 535, 535, 535, 535, 464, 464, 464, 464,
- 477, 500, 263, 563, 533, 263, 562, 464, 464, 464,
- 464, 821, 473, 473, 473, 473, 473, 473, 263, 308,
- 674, 675, 820, 568, 790, 654, 263, 466, 819, 263,
- 467, 790, 263, 572, 263, 468, 565, 263, 466, 469,
- 564, 467, 566, 263, 548, 470, 468, 655, 263, 549,
- 469, 571, 557, 569, 557, 263, 470, 558, 558, 558,
- 558, 558, 558, 558, 818, 573, 817, 573, 626, 570,
-
- 574, 574, 574, 574, 574, 574, 574, 535, 535, 535,
- 535, 535, 535, 535, 535, 535, 535, 535, 535, 535,
- 535, 558, 558, 558, 558, 558, 558, 558, 475, 624,
- 627, 628, 625, 678, 632, 263, 629, 263, 263, 263,
- 558, 558, 558, 558, 558, 558, 558, 630, 475, 263,
- 633, 574, 574, 574, 574, 574, 574, 574, 674, 675,
- 574, 574, 574, 574, 574, 574, 574, 656, 656, 656,
- 656, 656, 656, 656, 656, 656, 656, 656, 656, 656,
- 656, 674, 675, 263, 263, 263, 263, 765, 730, 787,
- 788, 205, 349, 205, 349, 681, 680, 731, 732, 205,
-
- 349, 441, 441, 765, 679, 831, 816, 815, 682, 814,
- 813, 812, 715, 830, 830, 830, 830, 830, 830, 830,
- 830, 830, 830, 830, 830, 830, 830, 380, 474, 380,
- 474, 811, 810, 809, 808, 380, 474, 807, 806, 805,
- 804, 803, 802, 717, 716, 801, 800, 748, 718, 799,
- 798, 797, 796, 795, 765, 794, 793, 792, 791, 789,
- 778, 22, 22, 22, 22, 22, 22, 22, 22, 22,
+ 446, 474, 474, 474, 474, 474, 474, 476, 263, 263,
+ 263, 263, 263, 263, 263, 263, 521, 823, 486, 378,
+ 378, 378, 378, 378, 378, 378, 504, 466, 263, 522,
+ 468, 505, 446, 263, 478, 469, 477, 484, 489, 470,
+ 476, 519, 506, 263, 308, 471, 379, 379, 379, 379,
+ 379, 379, 405, 405, 405, 405, 405, 405, 405, 524,
+ 520, 263, 308, 525, 263, 487, 263, 263, 477, 501,
+
+ 263, 496, 263, 494, 490, 492, 498, 445, 445, 445,
+ 445, 263, 263, 263, 535, 493, 535, 263, 495, 536,
+ 536, 536, 536, 536, 536, 536, 464, 464, 464, 464,
+ 263, 501, 566, 564, 534, 836, 836, 836, 836, 836,
+ 836, 836, 836, 836, 836, 836, 836, 836, 836, 836,
+ 836, 836, 836, 836, 836, 263, 822, 466, 263, 308,
+ 468, 836, 836, 836, 836, 469, 567, 551, 569, 470,
+ 563, 478, 565, 821, 628, 471, 675, 676, 552, 571,
+ 568, 572, 554, 474, 474, 474, 474, 474, 474, 570,
+ 558, 553, 558, 627, 820, 559, 559, 559, 559, 559,
+
+ 559, 559, 819, 574, 263, 574, 263, 555, 575, 575,
+ 575, 575, 575, 575, 575, 263, 573, 536, 536, 536,
+ 536, 536, 536, 536, 536, 536, 536, 536, 536, 536,
+ 536, 609, 836, 836, 836, 836, 610, 836, 836, 836,
+ 836, 836, 836, 836, 836, 836, 836, 836, 836, 836,
+ 836, 836, 836, 263, 263, 836, 836, 836, 836, 836,
+ 836, 836, 836, 559, 559, 559, 559, 559, 559, 559,
+ 615, 476, 263, 625, 263, 263, 616, 818, 679, 263,
+ 626, 618, 655, 559, 559, 559, 559, 559, 559, 559,
+ 617, 619, 620, 476, 621, 575, 575, 575, 575, 575,
+
+ 575, 575, 263, 263, 656, 575, 575, 575, 575, 575,
+ 575, 575, 657, 657, 657, 657, 657, 657, 657, 766,
+ 629, 675, 676, 631, 817, 630, 836, 836, 836, 836,
+ 675, 676, 682, 633, 836, 836, 836, 836, 681, 634,
+ 836, 836, 836, 836, 836, 836, 836, 836, 836, 836,
+ 836, 836, 836, 836, 836, 836, 263, 263, 263, 667,
+ 836, 836, 836, 836, 657, 657, 657, 657, 657, 657,
+ 657, 680, 683, 836, 836, 836, 836, 263, 668, 836,
+ 836, 836, 836, 836, 836, 836, 836, 671, 816, 670,
+ 669, 672, 779, 673, 836, 836, 836, 836, 815, 836,
+
+ 836, 836, 836, 836, 836, 836, 836, 836, 836, 836,
+ 836, 731, 263, 813, 708, 441, 441, 718, 717, 716,
+ 732, 733, 836, 836, 836, 836, 836, 836, 836, 741,
+ 812, 709, 795, 796, 707, 810, 712, 467, 467, 809,
+ 719, 807, 710, 711, 467, 467, 713, 836, 836, 836,
+ 836, 836, 836, 836, 836, 836, 836, 836, 836, 836,
+ 836, 836, 836, 836, 836, 836, 836, 800, 740, 836,
+ 836, 836, 836, 749, 836, 836, 836, 836, 742, 836,
+ 836, 836, 836, 806, 467, 467, 743, 803, 802, 799,
+ 744, 467, 467, 798, 746, 836, 836, 836, 836, 836,
+
+ 836, 836, 836, 836, 836, 836, 836, 767, 836, 836,
+ 836, 836, 836, 836, 836, 836, 766, 764, 467, 794,
+ 745, 836, 836, 836, 836, 467, 793, 792, 768, 836,
+ 836, 836, 836, 836, 836, 836, 836, 788, 789, 778,
+ 836, 836, 836, 836, 804, 770, 836, 836, 836, 836,
+ 769, 766, 836, 836, 836, 836, 836, 836, 836, 836,
+ 797, 801, 780, 836, 836, 836, 836, 805, 467, 808,
+ 786, 781, 783, 782, 467, 467, 785, 787, 784, 467,
+ 766, 467, 467, 811, 814, 205, 467, 205, 467, 467,
+ 467, 777, 790, 205, 776, 467, 467, 467, 775, 774,
+
+ 773, 772, 263, 467, 831, 831, 831, 831, 831, 831,
+ 831, 832, 791, 349, 380, 349, 380, 771, 766, 791,
+ 763, 349, 380, 762, 761, 760, 831, 831, 831, 831,
+ 831, 831, 831, 22, 22, 22, 22, 22, 22, 22,
22, 22, 22, 22, 22, 22, 22, 22, 22, 22,
- 22, 24, 24, 24, 24, 24, 24, 24, 24, 24,
+ 22, 22, 22, 22, 22, 24, 24, 24, 24, 24,
24, 24, 24, 24, 24, 24, 24, 24, 24, 24,
-
- 24, 27, 27, 27, 27, 27, 27, 27, 27, 27,
+ 24, 24, 24, 24, 24, 24, 24, 27, 27, 27,
27, 27, 27, 27, 27, 27, 27, 27, 27, 27,
- 27, 94, 94, 94, 94, 94, 94, 94, 94, 94,
+ 27, 27, 27, 27, 27, 27, 27, 27, 27, 94,
+
+ 94, 94, 94, 94, 94, 94, 94, 94, 94, 94,
94, 94, 94, 94, 94, 94, 94, 94, 94, 94,
94, 136, 136, 136, 136, 136, 136, 136, 136, 136,
136, 136, 136, 136, 136, 136, 136, 136, 136, 136,
- 136, 170, 170, 170, 170, 170, 170, 170, 170, 170,
- 170, 170, 786, 170, 170, 170, 170, 170, 170, 203,
- 203, 203, 203, 203, 203, 207, 207, 207, 785, 784,
- 783, 207, 782, 781, 780, 207, 208, 208, 208, 208,
-
- 208, 208, 208, 208, 208, 208, 208, 779, 208, 208,
- 208, 208, 208, 208, 210, 210, 210, 210, 210, 210,
- 210, 210, 210, 210, 210, 765, 210, 210, 210, 210,
- 210, 210, 222, 777, 222, 776, 222, 222, 775, 774,
- 222, 773, 222, 222, 223, 223, 772, 771, 223, 263,
- 223, 223, 246, 246, 246, 246, 246, 246, 246, 770,
- 246, 246, 246, 246, 246, 246, 246, 246, 246, 246,
- 769, 246, 247, 247, 247, 247, 247, 247, 247, 247,
+ 136, 136, 136, 170, 170, 170, 170, 170, 170, 170,
+ 170, 170, 170, 170, 170, 759, 170, 170, 170, 170,
+ 170, 170, 203, 203, 203, 203, 203, 203, 207, 758,
+ 207, 207, 757, 756, 755, 207, 754, 753, 752, 207,
+ 208, 208, 208, 208, 208, 208, 208, 208, 208, 208,
+ 208, 208, 751, 208, 208, 208, 208, 208, 208, 210,
+
+ 210, 210, 210, 210, 210, 210, 210, 210, 210, 210,
+ 210, 750, 210, 210, 210, 210, 210, 210, 222, 475,
+ 222, 475, 222, 222, 263, 263, 222, 475, 222, 222,
+ 223, 223, 263, 748, 223, 747, 223, 223, 246, 246,
+ 246, 246, 246, 246, 246, 246, 246, 739, 246, 246,
+ 246, 246, 246, 246, 246, 246, 246, 246, 738, 246,
247, 247, 247, 247, 247, 247, 247, 247, 247, 247,
- 768, 247, 250, 250, 250, 250, 250, 250, 250, 250,
-
+ 247, 247, 247, 247, 247, 247, 247, 247, 247, 247,
+ 737, 247, 250, 250, 250, 250, 250, 250, 250, 250,
250, 250, 250, 250, 250, 250, 250, 250, 250, 250,
- 250, 253, 253, 253, 253, 253, 253, 253, 253, 253,
- 253, 253, 767, 253, 253, 253, 253, 253, 253, 255,
- 255, 255, 255, 255, 255, 255, 255, 255, 255, 255,
- 766, 255, 255, 255, 255, 255, 255, 264, 765, 264,
- 763, 264, 762, 264, 264, 761, 760, 264, 759, 264,
- 264, 266, 266, 758, 757, 756, 266, 266, 266, 286,
- 286, 286, 286, 755, 286, 286, 286, 286, 286, 286,
- 754, 286, 286, 286, 286, 286, 286, 309, 309, 309,
- 753, 309, 752, 309, 309, 751, 750, 309, 749, 309,
-
- 309, 317, 317, 317, 317, 317, 317, 317, 317, 317,
- 317, 317, 263, 317, 317, 317, 317, 317, 317, 341,
- 341, 341, 341, 341, 341, 341, 341, 341, 341, 341,
- 263, 341, 341, 341, 341, 341, 341, 343, 343, 343,
+
+ 250, 250, 250, 253, 253, 253, 253, 253, 253, 253,
+ 253, 253, 253, 253, 253, 736, 253, 253, 253, 253,
+ 253, 253, 255, 255, 255, 255, 255, 255, 255, 255,
+ 255, 255, 255, 255, 735, 255, 255, 255, 255, 255,
+ 255, 264, 734, 264, 730, 264, 729, 264, 264, 728,
+ 727, 264, 726, 264, 264, 266, 266, 725, 724, 723,
+ 266, 266, 266, 286, 286, 286, 286, 286, 722, 286,
+ 286, 286, 286, 286, 286, 721, 286, 286, 286, 286,
+ 286, 286, 309, 309, 309, 720, 309, 263, 309, 309,
+ 715, 714, 309, 706, 309, 309, 317, 317, 317, 317,
+
+ 317, 317, 317, 317, 317, 317, 317, 317, 705, 317,
+ 317, 317, 317, 317, 317, 341, 341, 341, 341, 341,
+ 341, 341, 341, 341, 341, 341, 341, 704, 341, 341,
+ 341, 341, 341, 341, 343, 343, 343, 343, 343, 343,
343, 343, 343, 343, 343, 343, 343, 343, 343, 343,
- 343, 343, 343, 343, 343, 343, 343, 222, 263, 222,
- 747, 222, 222, 746, 745, 222, 744, 222, 222, 350,
- 743, 350, 742, 350, 350, 741, 740, 350, 739, 350,
- 350, 370, 370, 370, 370, 370, 370, 370, 370, 370,
+ 343, 343, 343, 343, 343, 343, 222, 703, 222, 702,
+ 222, 222, 701, 700, 222, 699, 222, 222, 350, 698,
+ 350, 697, 350, 350, 696, 695, 350, 694, 350, 350,
+ 370, 370, 370, 370, 370, 370, 370, 370, 370, 370,
370, 370, 370, 370, 370, 370, 370, 370, 370, 370,
- 370, 246, 246, 246, 246, 246, 246, 246, 738, 246,
- 246, 246, 246, 246, 246, 246, 246, 246, 246, 737,
- 246, 247, 247, 247, 247, 247, 247, 247, 736, 247,
- 247, 247, 247, 247, 247, 247, 247, 247, 247, 250,
- 250, 250, 250, 250, 250, 250, 735, 250, 250, 250,
- 250, 250, 250, 250, 250, 250, 250, 253, 253, 253,
- 253, 253, 253, 253, 253, 253, 253, 253, 734, 253,
- 253, 253, 253, 253, 253, 384, 733, 384, 729, 384,
- 728, 384, 384, 727, 726, 384, 725, 384, 384, 385,
- 385, 385, 385, 385, 385, 724, 385, 385, 385, 385,
-
+ 370, 370, 246, 246, 246, 246, 246, 246, 246, 246,
+ 246, 693, 246, 246, 246, 246, 246, 246, 246, 246,
+ 246, 246, 692, 246, 247, 247, 247, 247, 247, 247,
+ 247, 247, 247, 691, 247, 247, 247, 247, 247, 247,
+ 247, 247, 247, 247, 250, 250, 250, 250, 250, 250,
+ 250, 250, 250, 690, 250, 250, 250, 250, 250, 250,
+ 250, 250, 250, 250, 253, 253, 253, 253, 253, 253,
+ 253, 253, 253, 253, 253, 253, 689, 253, 253, 253,
+ 253, 253, 253, 384, 688, 384, 687, 384, 686, 384,
+ 384, 685, 684, 384, 263, 384, 384, 385, 385, 385,
+
+ 385, 385, 385, 385, 385, 263, 385, 385, 385, 385,
385, 385, 385, 385, 385, 385, 385, 385, 385, 309,
- 309, 309, 723, 309, 722, 309, 309, 721, 720, 309,
- 719, 309, 309, 317, 317, 317, 317, 317, 317, 317,
- 317, 317, 317, 317, 263, 317, 317, 317, 317, 317,
- 317, 532, 714, 532, 713, 532, 532, 712, 711, 532,
- 710, 532, 532, 673, 673, 673, 673, 673, 673, 673,
- 673, 673, 673, 673, 673, 673, 673, 673, 673, 673,
- 673, 673, 673, 764, 709, 764, 764, 764, 764, 764,
- 764, 764, 764, 764, 764, 764, 764, 764, 764, 764,
- 764, 764, 764, 708, 707, 706, 705, 704, 703, 702,
-
- 701, 700, 699, 698, 697, 696, 695, 694, 693, 692,
- 691, 690, 689, 688, 687, 686, 685, 684, 683, 263,
- 263, 263, 263, 263, 677, 676, 672, 671, 670, 669,
- 668, 667, 666, 665, 664, 663, 662, 661, 660, 659,
- 658, 657, 653, 652, 651, 650, 649, 648, 647, 646,
- 645, 644, 643, 642, 641, 640, 639, 638, 637, 636,
- 635, 634, 263, 263, 623, 622, 621, 620, 619, 618,
- 617, 616, 615, 614, 613, 612, 611, 610, 607, 606,
- 605, 604, 603, 602, 601, 600, 599, 598, 597, 596,
- 595, 594, 593, 592, 591, 590, 589, 588, 587, 586,
-
- 585, 582, 581, 580, 579, 578, 577, 576, 575, 263,
- 263, 263, 263, 263, 561, 560, 559, 556, 478, 555,
- 554, 553, 552, 551, 550, 547, 546, 545, 544, 543,
- 542, 541, 540, 539, 538, 537, 536, 531, 530, 529,
- 528, 527, 526, 525, 522, 517, 516, 515, 514, 513,
- 512, 511, 510, 509, 508, 507, 506, 502, 501, 472,
- 499, 263, 482, 383, 481, 480, 479, 478, 472, 471,
- 463, 462, 461, 460, 459, 458, 457, 456, 455, 454,
- 453, 452, 451, 450, 449, 448, 447, 835, 319, 318,
- 444, 440, 439, 431, 430, 423, 422, 421, 420, 408,
-
- 407, 406, 404, 403, 263, 263, 263, 383, 263, 375,
- 374, 254, 252, 248, 373, 369, 368, 367, 366, 365,
- 364, 363, 359, 358, 357, 354, 353, 352, 351, 224,
- 342, 209, 340, 339, 338, 337, 336, 335, 332, 331,
- 330, 329, 328, 323, 322, 321, 172, 171, 314, 202,
- 201, 194, 191, 190, 189, 174, 212, 320, 319, 318,
- 314, 835, 224, 213, 315, 314, 267, 263, 211, 254,
- 243, 242, 238, 237, 236, 235, 231, 230, 221, 220,
- 219, 214, 211, 209, 202, 201, 194, 191, 190, 189,
- 174, 172, 171, 835, 93, 93, 21, 835, 835, 835,
-
- 835, 835, 835, 835, 835, 835, 835, 835, 835, 835,
- 835, 835, 835, 835, 835, 835, 835, 835, 835, 835,
- 835, 835, 835, 835, 835, 835, 835, 835, 835, 835,
- 835, 835, 835, 835, 835, 835, 835, 835, 835, 835,
- 835, 835, 835, 835, 835, 835, 835, 835, 835, 835,
- 835, 835, 835, 835, 835, 835, 835, 835, 835, 835,
- 835, 835, 835, 835, 835, 835, 835, 835, 835, 835,
- 835, 835, 835, 835, 835, 835, 835, 835, 835, 835,
- 835, 835, 835, 835, 835, 835, 835, 835
+ 309, 309, 263, 309, 263, 309, 309, 263, 678, 309,
+ 677, 309, 309, 317, 317, 317, 317, 317, 317, 317,
+ 317, 317, 317, 317, 317, 666, 317, 317, 317, 317,
+ 317, 317, 467, 467, 467, 665, 664, 663, 662, 661,
+ 660, 659, 658, 467, 467, 654, 653, 467, 533, 652,
+ 533, 651, 533, 533, 650, 649, 533, 648, 533, 533,
+ 674, 674, 674, 674, 674, 674, 674, 674, 674, 674,
+ 674, 674, 674, 674, 674, 674, 674, 674, 674, 674,
+
+ 674, 674, 765, 765, 647, 765, 765, 765, 765, 765,
+ 765, 765, 765, 765, 765, 765, 765, 765, 765, 765,
+ 765, 765, 765, 765, 646, 645, 644, 643, 642, 641,
+ 640, 639, 638, 637, 636, 635, 263, 263, 624, 623,
+ 622, 614, 613, 612, 611, 608, 607, 606, 605, 604,
+ 603, 602, 601, 600, 599, 598, 597, 596, 595, 594,
+ 593, 592, 591, 590, 589, 588, 587, 586, 583, 582,
+ 581, 580, 579, 578, 577, 576, 263, 263, 263, 263,
+ 263, 562, 561, 560, 557, 479, 556, 548, 547, 546,
+ 545, 544, 543, 542, 541, 540, 539, 538, 537, 532,
+
+ 531, 530, 529, 528, 527, 526, 523, 518, 517, 516,
+ 515, 514, 513, 512, 511, 510, 509, 508, 507, 503,
+ 502, 473, 500, 263, 483, 383, 482, 481, 480, 479,
+ 473, 472, 463, 462, 461, 460, 459, 458, 457, 456,
+ 455, 454, 453, 452, 451, 450, 449, 448, 447, 836,
+ 319, 318, 444, 440, 439, 431, 430, 423, 422, 421,
+ 420, 408, 407, 406, 404, 403, 263, 263, 263, 383,
+ 263, 375, 374, 254, 252, 248, 373, 369, 368, 367,
+ 366, 365, 364, 363, 359, 358, 357, 354, 353, 352,
+ 351, 224, 342, 209, 340, 339, 338, 337, 336, 335,
+
+ 332, 331, 330, 329, 328, 323, 322, 321, 172, 171,
+ 314, 202, 201, 194, 191, 190, 189, 174, 212, 320,
+ 319, 318, 314, 836, 224, 213, 315, 314, 267, 263,
+ 211, 254, 243, 242, 238, 237, 236, 235, 231, 230,
+ 221, 220, 219, 214, 211, 209, 202, 201, 194, 191,
+ 190, 189, 174, 172, 171, 836, 93, 93, 21, 836,
+ 836, 836, 836, 836, 836, 836, 836, 836, 836, 836,
+ 836, 836, 836, 836, 836, 836, 836, 836, 836, 836,
+ 836, 836, 836, 836, 836, 836, 836, 836, 836, 836,
+ 836, 836, 836, 836, 836, 836, 836, 836, 836, 836,
+
+ 836, 836, 836, 836, 836, 836, 836, 836, 836, 836,
+ 836, 836, 836, 836, 836, 836, 836, 836, 836, 836,
+ 836, 836, 836, 836, 836, 836, 836, 836, 836, 836,
+ 836, 836, 836, 836, 836, 836, 836, 836, 836, 836,
+ 836, 836, 836, 836, 836, 836, 836, 836, 836, 836
} ;
-static yyconst short int yy_chk[2289] =
+static yyconst short int yy_chk[2551] =
{ 0,
3, 3, 3, 3, 4, 4, 4, 4, 0, 108,
0, 3, 121, 121, 0, 4, 9, 10, 96, 50,
5, 5, 107, 115, 111, 41, 41, 5, 87, 5,
41, 41, 5, 5, 87, 41, 93, 5, 103, 132,
105, 110, 103, 87, 5, 5, 109, 5, 112, 5,
- 105, 5, 133, 5, 6, 113, 103, 569, 65, 6,
+ 105, 5, 133, 5, 6, 113, 103, 570, 65, 6,
65, 65, 65, 65, 65, 65, 65, 6, 6, 6,
6, 6, 6, 6, 118, 122, 122, 118, 145, 153,
6, 6, 6, 6, 6, 6, 6, 6, 265, 107,
- 265, 6, 145, 6, 111, 833, 132, 6, 6, 153,
+ 265, 6, 145, 6, 111, 834, 132, 6, 6, 153,
6, 6, 110, 140, 140, 140, 140, 6, 109, 6,
- 112, 146, 6, 6, 109, 109, 113, 6, 65, 569,
+ 112, 146, 6, 6, 109, 109, 113, 6, 65, 570,
229, 133, 244, 244, 6, 6, 65, 6, 146, 6,
229, 6, 122, 6, 7, 7, 7, 7, 7, 7,
7, 7, 7, 7, 7, 7, 7, 7, 7, 7,
11, 11, 11, 11, 11, 11, 11, 11, 11, 11,
11, 11, 11, 11, 11, 11, 13, 149, 116, 116,
- 116, 116, 832, 13, 116, 831, 13, 268, 13, 13,
+ 116, 116, 833, 13, 116, 832, 13, 268, 13, 13,
149, 13, 13, 13, 13, 13, 13, 13, 123, 123,
13, 270, 66, 13, 66, 66, 66, 66, 66, 66,
66, 99, 269, 186, 99, 99, 99, 99, 99, 99,
- 99, 147, 510, 147, 510, 99, 124, 124, 281, 106,
+ 99, 147, 511, 147, 511, 99, 124, 124, 281, 106,
147, 273, 125, 125, 13, 186, 13, 13, 13, 13,
13, 13, 13, 13, 13, 13, 13, 13, 13, 13,
13, 13, 13, 13, 13, 13, 13, 13, 13, 13,
106, 273, 119, 101, 125, 101, 101, 101, 101, 101,
101, 101, 119, 234, 119, 119, 119, 119, 119, 119,
119, 148, 148, 148, 234, 234, 15, 148, 148, 15,
- 15, 305, 828, 15, 15, 15, 293, 271, 15, 15,
+ 15, 305, 829, 15, 15, 15, 293, 271, 15, 15,
278, 15, 15, 305, 15, 277, 15, 271, 15, 272,
- 293, 15, 827, 275, 15, 15, 15, 15, 19, 19,
+ 293, 15, 828, 275, 15, 15, 15, 15, 19, 19,
19, 19, 19, 19, 19, 19, 19, 19, 19, 19,
19, 19, 19, 19, 19, 19, 19, 19, 19, 19,
19, 19, 19, 19, 19, 19, 19, 19, 19, 100,
114, 143, 143, 143, 143, 143, 143, 143, 393, 100,
283, 100, 100, 100, 100, 100, 100, 100, 155, 179,
- 179, 179, 179, 304, 155, 155, 826, 304, 825, 155,
+ 179, 179, 179, 304, 155, 155, 827, 304, 465, 155,
- 155, 309, 309, 491, 155, 164, 164, 164, 164, 164,
+ 155, 309, 309, 465, 155, 164, 164, 164, 164, 164,
164, 173, 173, 173, 173, 173, 173, 173, 204, 204,
204, 204, 204, 204, 206, 206, 206, 206, 212, 212,
212, 212, 276, 280, 114, 299, 299, 284, 402, 100,
120, 283, 120, 215, 215, 215, 215, 215, 215, 215,
316, 299, 216, 120, 216, 216, 216, 216, 216, 216,
216, 261, 261, 261, 261, 261, 261, 120, 300, 120,
- 120, 491, 120, 824, 300, 120, 387, 120, 120, 120,
- 120, 120, 120, 823, 276, 120, 120, 120, 284, 120,
+ 120, 826, 120, 825, 300, 120, 387, 120, 120, 120,
+ 120, 120, 120, 824, 276, 120, 120, 120, 284, 120,
- 300, 822, 280, 256, 390, 276, 276, 120, 294, 294,
+ 300, 823, 280, 256, 390, 276, 276, 120, 294, 294,
402, 120, 294, 256, 120, 256, 256, 256, 256, 256,
256, 256, 257, 400, 294, 120, 310, 310, 311, 311,
312, 312, 257, 316, 257, 257, 257, 257, 257, 257,
346, 346, 346, 347, 347, 347, 347, 347, 347, 347,
348, 348, 348, 348, 348, 348, 369, 369, 369, 369,
347, 376, 376, 376, 376, 376, 376, 378, 389, 392,
- 394, 395, 396, 398, 399, 401, 428, 821, 388, 378,
- 378, 378, 378, 378, 378, 378, 410, 369, 486, 428,
- 369, 410, 347, 484, 379, 369, 378, 386, 391, 369,
+ 394, 395, 396, 398, 399, 401, 428, 822, 388, 378,
+ 378, 378, 378, 378, 378, 378, 410, 369, 487, 428,
+ 369, 410, 347, 490, 379, 369, 378, 386, 391, 369,
405, 427, 410, 442, 442, 369, 379, 379, 379, 379,
379, 379, 405, 405, 405, 405, 405, 405, 405, 431,
- 427, 443, 443, 431, 487, 389, 492, 489, 378, 405,
+ 427, 443, 443, 431, 491, 389, 488, 485, 378, 405,
- 490, 399, 498, 396, 392, 394, 401, 445, 445, 445,
- 445, 493, 542, 495, 446, 395, 446, 542, 398, 446,
+ 567, 399, 492, 396, 392, 394, 401, 445, 445, 445,
+ 445, 493, 495, 496, 446, 395, 446, 494, 398, 446,
446, 446, 446, 446, 446, 446, 464, 464, 464, 464,
- 473, 405, 494, 486, 442, 565, 484, 465, 465, 465,
- 465, 820, 473, 473, 473, 473, 473, 473, 533, 533,
- 621, 621, 819, 492, 782, 598, 566, 464, 818, 624,
- 464, 782, 563, 498, 567, 464, 489, 564, 465, 464,
- 487, 465, 490, 570, 465, 464, 465, 598, 568, 465,
- 465, 495, 476, 493, 476, 571, 465, 476, 476, 476,
- 476, 476, 476, 476, 817, 500, 816, 500, 565, 494,
-
- 500, 500, 500, 500, 500, 500, 500, 534, 534, 534,
- 534, 534, 534, 534, 535, 535, 535, 535, 535, 535,
- 535, 557, 557, 557, 557, 557, 557, 557, 558, 563,
- 566, 567, 564, 624, 570, 625, 567, 630, 631, 633,
- 558, 558, 558, 558, 558, 558, 558, 568, 574, 679,
- 571, 573, 573, 573, 573, 573, 573, 573, 673, 673,
- 574, 574, 574, 574, 574, 574, 574, 599, 599, 599,
- 599, 599, 599, 599, 656, 656, 656, 656, 656, 656,
- 656, 675, 675, 680, 681, 682, 717, 765, 694, 778,
- 778, 843, 861, 843, 861, 631, 630, 694, 694, 843,
-
- 861, 872, 872, 778, 625, 830, 815, 812, 633, 811,
- 810, 809, 679, 829, 829, 829, 829, 829, 829, 829,
- 830, 830, 830, 830, 830, 830, 830, 869, 875, 869,
- 875, 808, 807, 806, 805, 869, 875, 804, 803, 802,
- 800, 799, 798, 681, 680, 797, 795, 717, 682, 794,
- 792, 791, 790, 789, 788, 786, 785, 784, 783, 781,
- 765, 836, 836, 836, 836, 836, 836, 836, 836, 836,
- 836, 836, 836, 836, 836, 836, 836, 836, 836, 836,
- 836, 837, 837, 837, 837, 837, 837, 837, 837, 837,
+ 566, 405, 490, 487, 442, 466, 466, 466, 466, 467,
+ 467, 467, 467, 468, 468, 468, 468, 469, 469, 469,
+ 469, 470, 470, 470, 470, 499, 821, 464, 534, 534,
+ 464, 471, 471, 471, 471, 464, 491, 466, 493, 464,
+ 485, 474, 488, 820, 567, 464, 622, 622, 468, 495,
+ 492, 496, 470, 474, 474, 474, 474, 474, 474, 494,
+ 477, 469, 477, 566, 819, 477, 477, 477, 477, 477,
+
+ 477, 477, 818, 501, 625, 501, 564, 471, 501, 501,
+ 501, 501, 501, 501, 501, 565, 499, 535, 535, 535,
+ 535, 535, 535, 535, 536, 536, 536, 536, 536, 536,
+ 536, 543, 549, 549, 549, 549, 543, 550, 550, 550,
+ 550, 551, 551, 551, 551, 552, 552, 552, 552, 553,
+ 553, 553, 553, 568, 569, 554, 554, 554, 554, 555,
+ 555, 555, 555, 558, 558, 558, 558, 558, 558, 558,
+ 549, 559, 571, 564, 572, 632, 550, 817, 625, 631,
+ 565, 552, 599, 559, 559, 559, 559, 559, 559, 559,
+ 551, 553, 554, 575, 555, 574, 574, 574, 574, 574,
+
+ 574, 574, 626, 634, 599, 575, 575, 575, 575, 575,
+ 575, 575, 600, 600, 600, 600, 600, 600, 600, 766,
+ 568, 674, 674, 569, 816, 568, 615, 615, 615, 615,
+ 676, 676, 632, 571, 616, 616, 616, 616, 631, 572,
+ 617, 617, 617, 617, 618, 618, 618, 618, 619, 619,
+ 619, 619, 620, 620, 620, 620, 680, 681, 682, 615,
+ 621, 621, 621, 621, 657, 657, 657, 657, 657, 657,
+ 657, 626, 634, 667, 667, 667, 667, 683, 616, 668,
+ 668, 668, 668, 669, 669, 669, 669, 619, 813, 618,
+ 617, 620, 766, 621, 670, 670, 670, 670, 812, 671,
+
+ 671, 671, 671, 672, 672, 672, 672, 673, 673, 673,
+ 673, 695, 718, 810, 668, 873, 873, 682, 681, 680,
+ 695, 695, 707, 707, 707, 707, 708, 708, 708, 708,
+ 809, 669, 787, 790, 667, 807, 672, 790, 787, 806,
+ 683, 804, 670, 671, 790, 787, 673, 709, 709, 709,
+ 709, 710, 710, 710, 710, 711, 711, 711, 711, 712,
+ 712, 712, 712, 713, 713, 713, 713, 795, 707, 740,
+ 740, 740, 740, 718, 742, 742, 742, 742, 709, 743,
+ 743, 743, 743, 803, 797, 795, 710, 799, 798, 793,
+ 711, 797, 795, 792, 713, 744, 744, 744, 744, 745,
+
+ 745, 745, 745, 746, 746, 746, 746, 742, 764, 764,
+ 764, 764, 767, 767, 767, 767, 789, 740, 814, 786,
+ 712, 768, 768, 768, 768, 814, 785, 784, 743, 769,
+ 769, 769, 769, 770, 770, 770, 770, 779, 779, 764,
+ 778, 778, 778, 778, 800, 746, 780, 780, 780, 780,
+ 745, 779, 781, 781, 781, 781, 782, 782, 782, 782,
+ 791, 796, 767, 783, 783, 783, 783, 801, 796, 805,
+ 777, 768, 770, 769, 791, 796, 776, 778, 773, 805,
+ 765, 791, 801, 808, 811, 844, 805, 844, 808, 801,
+ 800, 762, 782, 844, 761, 808, 811, 800, 760, 753,
+
+ 751, 750, 749, 811, 830, 830, 830, 830, 830, 830,
+ 830, 831, 783, 862, 870, 862, 870, 748, 741, 783,
+ 737, 862, 870, 736, 735, 734, 831, 831, 831, 831,
+ 831, 831, 831, 837, 837, 837, 837, 837, 837, 837,
837, 837, 837, 837, 837, 837, 837, 837, 837, 837,
-
- 837, 838, 838, 838, 838, 838, 838, 838, 838, 838,
+ 837, 837, 837, 837, 837, 838, 838, 838, 838, 838,
838, 838, 838, 838, 838, 838, 838, 838, 838, 838,
- 838, 839, 839, 839, 839, 839, 839, 839, 839, 839,
+ 838, 838, 838, 838, 838, 838, 838, 839, 839, 839,
839, 839, 839, 839, 839, 839, 839, 839, 839, 839,
- 839, 840, 840, 840, 840, 840, 840, 840, 840, 840,
+ 839, 839, 839, 839, 839, 839, 839, 839, 839, 840,
+
+ 840, 840, 840, 840, 840, 840, 840, 840, 840, 840,
840, 840, 840, 840, 840, 840, 840, 840, 840, 840,
840, 841, 841, 841, 841, 841, 841, 841, 841, 841,
- 841, 841, 777, 841, 841, 841, 841, 841, 841, 842,
- 842, 842, 842, 842, 842, 844, 844, 844, 776, 775,
- 772, 844, 769, 768, 767, 844, 845, 845, 845, 845,
-
- 845, 845, 845, 845, 845, 845, 845, 766, 845, 845,
- 845, 845, 845, 845, 846, 846, 846, 846, 846, 846,
- 846, 846, 846, 846, 846, 764, 846, 846, 846, 846,
- 846, 846, 847, 763, 847, 761, 847, 847, 760, 759,
- 847, 752, 847, 847, 848, 848, 750, 749, 848, 748,
- 848, 848, 849, 849, 849, 849, 849, 849, 849, 747,
- 849, 849, 849, 849, 849, 849, 849, 849, 849, 849,
- 745, 849, 850, 850, 850, 850, 850, 850, 850, 850,
- 850, 850, 850, 850, 850, 850, 850, 850, 850, 850,
- 744, 850, 851, 851, 851, 851, 851, 851, 851, 851,
-
+ 841, 841, 841, 841, 841, 841, 841, 841, 841, 841,
+ 841, 841, 841, 842, 842, 842, 842, 842, 842, 842,
+ 842, 842, 842, 842, 842, 733, 842, 842, 842, 842,
+ 842, 842, 843, 843, 843, 843, 843, 843, 845, 732,
+ 845, 845, 731, 729, 728, 845, 727, 726, 723, 845,
+ 846, 846, 846, 846, 846, 846, 846, 846, 846, 846,
+ 846, 846, 721, 846, 846, 846, 846, 846, 846, 847,
+
+ 847, 847, 847, 847, 847, 847, 847, 847, 847, 847,
+ 847, 720, 847, 847, 847, 847, 847, 847, 848, 877,
+ 848, 877, 848, 848, 719, 717, 848, 877, 848, 848,
+ 849, 849, 716, 715, 849, 714, 849, 849, 850, 850,
+ 850, 850, 850, 850, 850, 850, 850, 705, 850, 850,
+ 850, 850, 850, 850, 850, 850, 850, 850, 702, 850,
851, 851, 851, 851, 851, 851, 851, 851, 851, 851,
- 851, 852, 852, 852, 852, 852, 852, 852, 852, 852,
- 852, 852, 742, 852, 852, 852, 852, 852, 852, 853,
- 853, 853, 853, 853, 853, 853, 853, 853, 853, 853,
- 741, 853, 853, 853, 853, 853, 853, 854, 740, 854,
- 739, 854, 736, 854, 854, 735, 734, 854, 733, 854,
- 854, 855, 855, 732, 731, 730, 855, 855, 855, 856,
- 856, 856, 856, 728, 856, 856, 856, 856, 856, 856,
- 727, 856, 856, 856, 856, 856, 856, 857, 857, 857,
- 726, 857, 725, 857, 857, 722, 720, 857, 719, 857,
-
- 857, 858, 858, 858, 858, 858, 858, 858, 858, 858,
- 858, 858, 718, 858, 858, 858, 858, 858, 858, 859,
- 859, 859, 859, 859, 859, 859, 859, 859, 859, 859,
- 716, 859, 859, 859, 859, 859, 859, 860, 860, 860,
- 860, 860, 860, 860, 860, 860, 860, 860, 860, 860,
- 860, 860, 860, 860, 860, 860, 860, 862, 715, 862,
- 714, 862, 862, 713, 712, 862, 711, 862, 862, 863,
- 710, 863, 709, 863, 863, 708, 707, 863, 706, 863,
- 863, 864, 864, 864, 864, 864, 864, 864, 864, 864,
- 864, 864, 864, 864, 864, 864, 864, 864, 864, 864,
+ 851, 851, 851, 851, 851, 851, 851, 851, 851, 851,
+ 701, 851, 852, 852, 852, 852, 852, 852, 852, 852,
+ 852, 852, 852, 852, 852, 852, 852, 852, 852, 852,
+
+ 852, 852, 852, 853, 853, 853, 853, 853, 853, 853,
+ 853, 853, 853, 853, 853, 699, 853, 853, 853, 853,
+ 853, 853, 854, 854, 854, 854, 854, 854, 854, 854,
+ 854, 854, 854, 854, 697, 854, 854, 854, 854, 854,
+ 854, 855, 696, 855, 694, 855, 693, 855, 855, 692,
+ 691, 855, 690, 855, 855, 856, 856, 689, 688, 687,
+ 856, 856, 856, 857, 857, 857, 857, 857, 686, 857,
+ 857, 857, 857, 857, 857, 685, 857, 857, 857, 857,
+ 857, 857, 858, 858, 858, 684, 858, 679, 858, 858,
+ 678, 677, 858, 666, 858, 858, 859, 859, 859, 859,
+
+ 859, 859, 859, 859, 859, 859, 859, 859, 665, 859,
+ 859, 859, 859, 859, 859, 860, 860, 860, 860, 860,
+ 860, 860, 860, 860, 860, 860, 860, 664, 860, 860,
+ 860, 860, 860, 860, 861, 861, 861, 861, 861, 861,
+ 861, 861, 861, 861, 861, 861, 861, 861, 861, 861,
+ 861, 861, 861, 861, 861, 861, 863, 663, 863, 661,
+ 863, 863, 659, 658, 863, 655, 863, 863, 864, 654,
+ 864, 652, 864, 864, 650, 649, 864, 647, 864, 864,
+ 865, 865, 865, 865, 865, 865, 865, 865, 865, 865,
+ 865, 865, 865, 865, 865, 865, 865, 865, 865, 865,
+
+ 865, 865, 866, 866, 866, 866, 866, 866, 866, 866,
+ 866, 646, 866, 866, 866, 866, 866, 866, 866, 866,
+ 866, 866, 645, 866, 867, 867, 867, 867, 867, 867,
+ 867, 867, 867, 644, 867, 867, 867, 867, 867, 867,
+ 867, 867, 867, 867, 868, 868, 868, 868, 868, 868,
+ 868, 868, 868, 642, 868, 868, 868, 868, 868, 868,
+ 868, 868, 868, 868, 869, 869, 869, 869, 869, 869,
+ 869, 869, 869, 869, 869, 869, 640, 869, 869, 869,
+ 869, 869, 869, 871, 639, 871, 638, 871, 637, 871,
+ 871, 636, 635, 871, 633, 871, 871, 872, 872, 872,
+
+ 872, 872, 872, 872, 872, 630, 872, 872, 872, 872,
+ 872, 872, 872, 872, 872, 872, 872, 872, 872, 874,
+ 874, 874, 629, 874, 628, 874, 874, 627, 624, 874,
+ 623, 874, 874, 875, 875, 875, 875, 875, 875, 875,
+ 875, 875, 875, 875, 875, 614, 875, 875, 875, 875,
+ 875, 875, 876, 876, 876, 612, 611, 606, 605, 604,
+ 603, 602, 601, 876, 876, 598, 597, 876, 878, 596,
+ 878, 595, 878, 878, 594, 593, 878, 591, 878, 878,
+ 879, 879, 879, 879, 879, 879, 879, 879, 879, 879,
+ 879, 879, 879, 879, 879, 879, 879, 879, 879, 879,
+
+ 879, 879, 880, 880, 590, 880, 880, 880, 880, 880,
+ 880, 880, 880, 880, 880, 880, 880, 880, 880, 880,
+ 880, 880, 880, 880, 589, 588, 587, 586, 585, 584,
+ 583, 582, 581, 579, 578, 576, 573, 563, 561, 560,
+ 556, 547, 546, 545, 544, 542, 541, 540, 539, 532,
+ 531, 530, 529, 528, 527, 526, 525, 524, 523, 522,
+ 521, 519, 517, 516, 515, 514, 513, 512, 510, 509,
+ 508, 507, 506, 505, 504, 503, 498, 497, 489, 486,
+ 484, 483, 481, 480, 476, 475, 472, 463, 460, 459,
+ 458, 457, 456, 455, 454, 452, 451, 449, 447, 440,
+
+ 439, 437, 436, 435, 433, 432, 430, 425, 424, 423,
+ 421, 419, 418, 417, 416, 415, 414, 412, 411, 409,
+ 408, 404, 403, 397, 385, 384, 383, 382, 381, 380,
+ 375, 373, 368, 367, 366, 365, 364, 362, 361, 360,
+ 359, 358, 357, 356, 355, 354, 353, 352, 351, 341,
+ 318, 317, 315, 307, 306, 302, 301, 298, 297, 296,
+ 295, 291, 290, 289, 286, 285, 282, 279, 274, 266,
+ 264, 255, 254, 253, 252, 248, 245, 243, 242, 241,
+ 239, 238, 236, 235, 233, 231, 230, 228, 227, 226,
+ 225, 224, 210, 208, 200, 199, 198, 196, 193, 192,
+
+ 185, 184, 183, 181, 180, 177, 175, 174, 171, 170,
+ 169, 157, 156, 154, 152, 151, 150, 144, 142, 138,
+ 137, 136, 134, 131, 130, 129, 128, 126, 104, 102,
+ 98, 97, 89, 88, 86, 85, 84, 83, 81, 80,
+ 70, 69, 67, 64, 58, 57, 43, 42, 40, 38,
+ 37, 36, 30, 25, 24, 21, 12, 8, 836, 836,
+ 836, 836, 836, 836, 836, 836, 836, 836, 836, 836,
+ 836, 836, 836, 836, 836, 836, 836, 836, 836, 836,
+ 836, 836, 836, 836, 836, 836, 836, 836, 836, 836,
+ 836, 836, 836, 836, 836, 836, 836, 836, 836, 836,
- 864, 865, 865, 865, 865, 865, 865, 865, 704, 865,
- 865, 865, 865, 865, 865, 865, 865, 865, 865, 701,
- 865, 866, 866, 866, 866, 866, 866, 866, 700, 866,
- 866, 866, 866, 866, 866, 866, 866, 866, 866, 867,
- 867, 867, 867, 867, 867, 867, 698, 867, 867, 867,
- 867, 867, 867, 867, 867, 867, 867, 868, 868, 868,
- 868, 868, 868, 868, 868, 868, 868, 868, 696, 868,
- 868, 868, 868, 868, 868, 870, 695, 870, 693, 870,
- 692, 870, 870, 691, 690, 870, 689, 870, 870, 871,
- 871, 871, 871, 871, 871, 688, 871, 871, 871, 871,
-
- 871, 871, 871, 871, 871, 871, 871, 871, 871, 873,
- 873, 873, 687, 873, 686, 873, 873, 685, 684, 873,
- 683, 873, 873, 874, 874, 874, 874, 874, 874, 874,
- 874, 874, 874, 874, 678, 874, 874, 874, 874, 874,
- 874, 876, 677, 876, 676, 876, 876, 672, 671, 876,
- 670, 876, 876, 877, 877, 877, 877, 877, 877, 877,
- 877, 877, 877, 877, 877, 877, 877, 877, 877, 877,
- 877, 877, 877, 878, 669, 878, 878, 878, 878, 878,
- 878, 878, 878, 878, 878, 878, 878, 878, 878, 878,
- 878, 878, 878, 668, 667, 666, 665, 664, 663, 662,
-
- 660, 658, 657, 654, 653, 651, 649, 648, 646, 645,
- 644, 643, 641, 639, 638, 637, 636, 635, 634, 632,
- 629, 628, 627, 626, 623, 622, 620, 619, 618, 617,
- 616, 615, 614, 613, 611, 610, 605, 604, 603, 602,
- 601, 600, 597, 596, 595, 594, 593, 592, 590, 589,
- 588, 587, 586, 585, 584, 583, 582, 581, 580, 578,
- 577, 575, 572, 562, 560, 559, 555, 554, 553, 552,
- 551, 550, 549, 548, 546, 545, 544, 543, 541, 540,
- 539, 538, 531, 530, 529, 528, 527, 526, 525, 524,
- 523, 522, 521, 520, 518, 516, 515, 514, 513, 512,
-
- 511, 509, 508, 507, 506, 505, 504, 503, 502, 497,
- 496, 488, 485, 483, 482, 480, 479, 475, 474, 471,
- 470, 469, 468, 467, 466, 463, 460, 459, 458, 457,
- 456, 455, 454, 452, 451, 449, 447, 440, 439, 437,
- 436, 435, 433, 432, 430, 425, 424, 423, 421, 419,
- 418, 417, 416, 415, 414, 412, 411, 409, 408, 404,
- 403, 397, 385, 384, 383, 382, 381, 380, 375, 373,
- 368, 367, 366, 365, 364, 362, 361, 360, 359, 358,
- 357, 356, 355, 354, 353, 352, 351, 341, 318, 317,
- 315, 307, 306, 302, 301, 298, 297, 296, 295, 291,
-
- 290, 289, 286, 285, 282, 279, 274, 266, 264, 255,
- 254, 253, 252, 248, 245, 243, 242, 241, 239, 238,
- 236, 235, 233, 231, 230, 228, 227, 226, 225, 224,
- 210, 208, 200, 199, 198, 196, 193, 192, 185, 184,
- 183, 181, 180, 177, 175, 174, 171, 170, 169, 157,
- 156, 154, 152, 151, 150, 144, 142, 138, 137, 136,
- 134, 131, 130, 129, 128, 126, 104, 102, 98, 97,
- 89, 88, 86, 85, 84, 83, 81, 80, 70, 69,
- 67, 64, 58, 57, 43, 42, 40, 38, 37, 36,
- 30, 25, 24, 21, 12, 8, 835, 835, 835, 835,
-
- 835, 835, 835, 835, 835, 835, 835, 835, 835, 835,
- 835, 835, 835, 835, 835, 835, 835, 835, 835, 835,
- 835, 835, 835, 835, 835, 835, 835, 835, 835, 835,
- 835, 835, 835, 835, 835, 835, 835, 835, 835, 835,
- 835, 835, 835, 835, 835, 835, 835, 835, 835, 835,
- 835, 835, 835, 835, 835, 835, 835, 835, 835, 835,
- 835, 835, 835, 835, 835, 835, 835, 835, 835, 835,
- 835, 835, 835, 835, 835, 835, 835, 835, 835, 835,
- 835, 835, 835, 835, 835, 835, 835, 835
+ 836, 836, 836, 836, 836, 836, 836, 836, 836, 836,
+ 836, 836, 836, 836, 836, 836, 836, 836, 836, 836,
+ 836, 836, 836, 836, 836, 836, 836, 836, 836, 836,
+ 836, 836, 836, 836, 836, 836, 836, 836, 836, 836,
+ 836, 836, 836, 836, 836, 836, 836, 836, 836, 836
} ;
static yy_state_type yy_last_accepting_state;
while ( yy_chk[yy_base[yy_current_state] + yy_c] != yy_current_state )
{
yy_current_state = (int) yy_def[yy_current_state];
- if ( yy_current_state >= 836 )
+ if ( yy_current_state >= 837 )
yy_c = yy_meta[(unsigned int) yy_c];
}
yy_current_state = yy_nxt[yy_base[yy_current_state] + (unsigned int) yy_c];
++yy_cp;
}
- while ( yy_base[yy_current_state] != 2197 );
+ while ( yy_base[yy_current_state] != 2459 );
yy_find_action:
yy_act = yy_accept[yy_current_state];
case 52:
YY_RULE_SETUP
#line 390 "yaccParser/hslexer.flex"
+{
+ fprintf(stderr, "Warning: \"%s\", line %d: Unrecognised pragma '",
+ input_filename, hsplineno);
+ format_string(stderr, (unsigned char *) yytext, yyleng);
+ fputs("'\n", stderr);
+ nested_comments = 1;
+ PUSH_STATE(Comment);
+ }
+ YY_BREAK
+case 53:
+YY_RULE_SETUP
+#line 398 "yaccParser/hslexer.flex"
{ POP_STATE; RETURN(END_UPRAGMA); }
YY_BREAK
* intentionally accepted as a keyword even for normal <Code>.
*/
-case 53:
+case 54:
YY_RULE_SETUP
-#line 399 "yaccParser/hslexer.flex"
+#line 407 "yaccParser/hslexer.flex"
{ RETURN(CASE); }
YY_BREAK
-case 54:
+case 55:
YY_RULE_SETUP
-#line 400 "yaccParser/hslexer.flex"
+#line 408 "yaccParser/hslexer.flex"
{ RETURN(CLASS); }
YY_BREAK
-case 55:
+case 56:
YY_RULE_SETUP
-#line 401 "yaccParser/hslexer.flex"
+#line 409 "yaccParser/hslexer.flex"
{ RETURN(DATA); }
YY_BREAK
-case 56:
+case 57:
YY_RULE_SETUP
-#line 402 "yaccParser/hslexer.flex"
+#line 410 "yaccParser/hslexer.flex"
{ RETURN(DEFAULT); }
YY_BREAK
-case 57:
+case 58:
YY_RULE_SETUP
-#line 403 "yaccParser/hslexer.flex"
+#line 411 "yaccParser/hslexer.flex"
{ RETURN(DERIVING); }
YY_BREAK
-case 58:
+case 59:
YY_RULE_SETUP
-#line 404 "yaccParser/hslexer.flex"
+#line 412 "yaccParser/hslexer.flex"
{ RETURN(ELSE); }
YY_BREAK
-case 59:
+case 60:
YY_RULE_SETUP
-#line 405 "yaccParser/hslexer.flex"
+#line 413 "yaccParser/hslexer.flex"
{ RETURN(HIDING); }
YY_BREAK
-case 60:
+case 61:
YY_RULE_SETUP
-#line 406 "yaccParser/hslexer.flex"
+#line 414 "yaccParser/hslexer.flex"
{ RETURN(IF); }
YY_BREAK
-case 61:
+case 62:
YY_RULE_SETUP
-#line 407 "yaccParser/hslexer.flex"
+#line 415 "yaccParser/hslexer.flex"
{ RETURN(IMPORT); }
YY_BREAK
-case 62:
+case 63:
YY_RULE_SETUP
-#line 408 "yaccParser/hslexer.flex"
+#line 416 "yaccParser/hslexer.flex"
{ RETURN(INFIX); }
YY_BREAK
-case 63:
+case 64:
YY_RULE_SETUP
-#line 409 "yaccParser/hslexer.flex"
+#line 417 "yaccParser/hslexer.flex"
{ RETURN(INFIXL); }
YY_BREAK
-case 64:
+case 65:
YY_RULE_SETUP
-#line 410 "yaccParser/hslexer.flex"
+#line 418 "yaccParser/hslexer.flex"
{ RETURN(INFIXR); }
YY_BREAK
-case 65:
+case 66:
YY_RULE_SETUP
-#line 411 "yaccParser/hslexer.flex"
+#line 419 "yaccParser/hslexer.flex"
{ RETURN(INSTANCE); }
YY_BREAK
-case 66:
+case 67:
YY_RULE_SETUP
-#line 412 "yaccParser/hslexer.flex"
+#line 420 "yaccParser/hslexer.flex"
{ RETURN(INTERFACE); }
YY_BREAK
-case 67:
+case 68:
YY_RULE_SETUP
-#line 413 "yaccParser/hslexer.flex"
+#line 421 "yaccParser/hslexer.flex"
{ RETURN(MODULE); }
YY_BREAK
-case 68:
+case 69:
YY_RULE_SETUP
-#line 414 "yaccParser/hslexer.flex"
+#line 422 "yaccParser/hslexer.flex"
{ RETURN(OF); }
YY_BREAK
-case 69:
+case 70:
YY_RULE_SETUP
-#line 415 "yaccParser/hslexer.flex"
+#line 423 "yaccParser/hslexer.flex"
{ RETURN(RENAMING); }
YY_BREAK
-case 70:
+case 71:
YY_RULE_SETUP
-#line 416 "yaccParser/hslexer.flex"
+#line 424 "yaccParser/hslexer.flex"
{ RETURN(THEN); }
YY_BREAK
-case 71:
+case 72:
YY_RULE_SETUP
-#line 417 "yaccParser/hslexer.flex"
+#line 425 "yaccParser/hslexer.flex"
{ RETURN(TO); }
YY_BREAK
-case 72:
+case 73:
YY_RULE_SETUP
-#line 418 "yaccParser/hslexer.flex"
+#line 426 "yaccParser/hslexer.flex"
{ RETURN(TYPE); }
YY_BREAK
-case 73:
+case 74:
YY_RULE_SETUP
-#line 419 "yaccParser/hslexer.flex"
+#line 427 "yaccParser/hslexer.flex"
{ RETURN(WHERE); }
YY_BREAK
-case 74:
+case 75:
YY_RULE_SETUP
-#line 420 "yaccParser/hslexer.flex"
+#line 428 "yaccParser/hslexer.flex"
{ RETURN(IN); }
YY_BREAK
-case 75:
+case 76:
YY_RULE_SETUP
-#line 421 "yaccParser/hslexer.flex"
+#line 429 "yaccParser/hslexer.flex"
{ RETURN(LET); }
YY_BREAK
-case 76:
+case 77:
YY_RULE_SETUP
-#line 422 "yaccParser/hslexer.flex"
+#line 430 "yaccParser/hslexer.flex"
{ RETURN(CCALL); }
YY_BREAK
-case 77:
+case 78:
YY_RULE_SETUP
-#line 423 "yaccParser/hslexer.flex"
+#line 431 "yaccParser/hslexer.flex"
{ RETURN(CCALL_GC); }
YY_BREAK
-case 78:
+case 79:
YY_RULE_SETUP
-#line 424 "yaccParser/hslexer.flex"
+#line 432 "yaccParser/hslexer.flex"
{ RETURN(CASM); }
YY_BREAK
-case 79:
+case 80:
YY_RULE_SETUP
-#line 425 "yaccParser/hslexer.flex"
+#line 433 "yaccParser/hslexer.flex"
{ RETURN(CASM_GC); }
YY_BREAK
-case 80:
+case 81:
YY_RULE_SETUP
-#line 426 "yaccParser/hslexer.flex"
+#line 434 "yaccParser/hslexer.flex"
{ RETURN(SCC); }
YY_BREAK
-case 81:
+case 82:
YY_RULE_SETUP
-#line 427 "yaccParser/hslexer.flex"
+#line 435 "yaccParser/hslexer.flex"
{ RETURN(FORALL); }
YY_BREAK
* Haskell operators. Nothing special about these.
*/
-case 82:
+case 83:
YY_RULE_SETUP
-#line 435 "yaccParser/hslexer.flex"
+#line 443 "yaccParser/hslexer.flex"
{ RETURN(DOTDOT); }
YY_BREAK
-case 83:
+case 84:
YY_RULE_SETUP
-#line 436 "yaccParser/hslexer.flex"
+#line 444 "yaccParser/hslexer.flex"
{ RETURN(SEMI); }
YY_BREAK
-case 84:
+case 85:
YY_RULE_SETUP
-#line 437 "yaccParser/hslexer.flex"
+#line 445 "yaccParser/hslexer.flex"
{ RETURN(COMMA); }
YY_BREAK
-case 85:
+case 86:
YY_RULE_SETUP
-#line 438 "yaccParser/hslexer.flex"
+#line 446 "yaccParser/hslexer.flex"
{ RETURN(VBAR); }
YY_BREAK
-case 86:
+case 87:
YY_RULE_SETUP
-#line 439 "yaccParser/hslexer.flex"
+#line 447 "yaccParser/hslexer.flex"
{ RETURN(EQUAL); }
YY_BREAK
-case 87:
+case 88:
YY_RULE_SETUP
-#line 440 "yaccParser/hslexer.flex"
+#line 448 "yaccParser/hslexer.flex"
{ RETURN(LARROW); }
YY_BREAK
-case 88:
+case 89:
YY_RULE_SETUP
-#line 441 "yaccParser/hslexer.flex"
+#line 449 "yaccParser/hslexer.flex"
{ RETURN(RARROW); }
YY_BREAK
-case 89:
+case 90:
YY_RULE_SETUP
-#line 442 "yaccParser/hslexer.flex"
+#line 450 "yaccParser/hslexer.flex"
{ RETURN(DARROW); }
YY_BREAK
-case 90:
+case 91:
YY_RULE_SETUP
-#line 443 "yaccParser/hslexer.flex"
+#line 451 "yaccParser/hslexer.flex"
{ RETURN(DCOLON); }
YY_BREAK
-case 91:
+case 92:
YY_RULE_SETUP
-#line 444 "yaccParser/hslexer.flex"
+#line 452 "yaccParser/hslexer.flex"
{ RETURN(OPAREN); }
YY_BREAK
-case 92:
+case 93:
YY_RULE_SETUP
-#line 445 "yaccParser/hslexer.flex"
+#line 453 "yaccParser/hslexer.flex"
{ RETURN(CPAREN); }
YY_BREAK
-case 93:
+case 94:
YY_RULE_SETUP
-#line 446 "yaccParser/hslexer.flex"
+#line 454 "yaccParser/hslexer.flex"
{ RETURN(OBRACK); }
YY_BREAK
-case 94:
+case 95:
YY_RULE_SETUP
-#line 447 "yaccParser/hslexer.flex"
+#line 455 "yaccParser/hslexer.flex"
{ RETURN(CBRACK); }
YY_BREAK
-case 95:
+case 96:
YY_RULE_SETUP
-#line 448 "yaccParser/hslexer.flex"
+#line 456 "yaccParser/hslexer.flex"
{ RETURN(OCURLY); }
YY_BREAK
-case 96:
+case 97:
YY_RULE_SETUP
-#line 449 "yaccParser/hslexer.flex"
+#line 457 "yaccParser/hslexer.flex"
{ RETURN(CCURLY); }
YY_BREAK
-case 97:
+case 98:
YY_RULE_SETUP
-#line 450 "yaccParser/hslexer.flex"
+#line 458 "yaccParser/hslexer.flex"
{ RETURN(PLUS); }
YY_BREAK
-case 98:
+case 99:
YY_RULE_SETUP
-#line 451 "yaccParser/hslexer.flex"
+#line 459 "yaccParser/hslexer.flex"
{ RETURN(AT); }
YY_BREAK
-case 99:
+case 100:
YY_RULE_SETUP
-#line 452 "yaccParser/hslexer.flex"
+#line 460 "yaccParser/hslexer.flex"
{ RETURN(LAMBDA); }
YY_BREAK
-case 100:
+case 101:
YY_RULE_SETUP
-#line 453 "yaccParser/hslexer.flex"
+#line 461 "yaccParser/hslexer.flex"
{ RETURN(TYLAMBDA); }
YY_BREAK
-case 101:
+case 102:
YY_RULE_SETUP
-#line 454 "yaccParser/hslexer.flex"
+#line 462 "yaccParser/hslexer.flex"
{ RETURN(WILDCARD); }
YY_BREAK
-case 102:
+case 103:
YY_RULE_SETUP
-#line 455 "yaccParser/hslexer.flex"
+#line 463 "yaccParser/hslexer.flex"
{ RETURN(BQUOTE); }
YY_BREAK
-case 103:
+case 104:
YY_RULE_SETUP
-#line 456 "yaccParser/hslexer.flex"
+#line 464 "yaccParser/hslexer.flex"
{ RETURN(LAZY); }
YY_BREAK
-case 104:
+case 105:
YY_RULE_SETUP
-#line 457 "yaccParser/hslexer.flex"
+#line 465 "yaccParser/hslexer.flex"
{ RETURN(MINUS); }
YY_BREAK
* arbitrary precision numbers.
*/
-case 105:
+case 106:
YY_RULE_SETUP
-#line 467 "yaccParser/hslexer.flex"
+#line 475 "yaccParser/hslexer.flex"
{ /* octal */
yylval.uid = xstrndup(yytext, yyleng - 1);
RETURN(INTPRIM);
}
YY_BREAK
-case 106:
+case 107:
YY_RULE_SETUP
-#line 471 "yaccParser/hslexer.flex"
+#line 479 "yaccParser/hslexer.flex"
{ /* octal */
yylval.uid = xstrndup(yytext, yyleng);
RETURN(INTEGER);
}
YY_BREAK
-case 107:
+case 108:
YY_RULE_SETUP
-#line 475 "yaccParser/hslexer.flex"
+#line 483 "yaccParser/hslexer.flex"
{ /* hexadecimal */
yylval.uid = xstrndup(yytext, yyleng - 1);
RETURN(INTPRIM);
}
YY_BREAK
-case 108:
+case 109:
YY_RULE_SETUP
-#line 479 "yaccParser/hslexer.flex"
+#line 487 "yaccParser/hslexer.flex"
{ /* hexadecimal */
yylval.uid = xstrndup(yytext, yyleng);
RETURN(INTEGER);
}
YY_BREAK
-case 109:
+case 110:
YY_RULE_SETUP
-#line 483 "yaccParser/hslexer.flex"
+#line 491 "yaccParser/hslexer.flex"
{
yylval.uid = xstrndup(yytext, yyleng - 1);
RETURN(INTPRIM);
}
YY_BREAK
-case 110:
+case 111:
YY_RULE_SETUP
-#line 487 "yaccParser/hslexer.flex"
+#line 495 "yaccParser/hslexer.flex"
{
yylval.uid = xstrndup(yytext, yyleng);
RETURN(INTEGER);
* Floats and (for Glasgow extensions) primitive floats/doubles.
*/
-case 111:
+case 112:
YY_RULE_SETUP
-#line 498 "yaccParser/hslexer.flex"
+#line 506 "yaccParser/hslexer.flex"
{
yylval.uid = xstrndup(yytext, yyleng - 2);
RETURN(DOUBLEPRIM);
}
YY_BREAK
-case 112:
+case 113:
YY_RULE_SETUP
-#line 502 "yaccParser/hslexer.flex"
+#line 510 "yaccParser/hslexer.flex"
{
yylval.uid = xstrndup(yytext, yyleng - 1);
RETURN(FLOATPRIM);
}
YY_BREAK
-case 113:
+case 114:
YY_RULE_SETUP
-#line 506 "yaccParser/hslexer.flex"
+#line 514 "yaccParser/hslexer.flex"
{
yylval.uid = xstrndup(yytext, yyleng);
RETURN(FLOAT);
* Funky ``foo'' style C literals for Glasgow extensions
*/
-case 114:
+case 115:
YY_RULE_SETUP
-#line 517 "yaccParser/hslexer.flex"
+#line 525 "yaccParser/hslexer.flex"
{
hsnewid(yytext + 2, yyleng - 4);
RETURN(CLITLIT);
* for Glasgow extensions.
*/
-case 115:
+case 116:
YY_RULE_SETUP
-#line 529 "yaccParser/hslexer.flex"
+#line 537 "yaccParser/hslexer.flex"
{ hsnewid(yytext, yyleng); RETURN(CONID); }
YY_BREAK
-case 116:
+case 117:
YY_RULE_SETUP
-#line 530 "yaccParser/hslexer.flex"
+#line 538 "yaccParser/hslexer.flex"
{ hsnewid(yytext, yyleng); RETURN(CONID); }
YY_BREAK
-case 117:
+case 118:
YY_RULE_SETUP
-#line 531 "yaccParser/hslexer.flex"
+#line 539 "yaccParser/hslexer.flex"
{ hsnewid(yytext, yyleng); RETURN(TYVAR_TEMPLATE_ID); }
YY_BREAK
-case 118:
+case 119:
YY_RULE_SETUP
-#line 533 "yaccParser/hslexer.flex"
+#line 541 "yaccParser/hslexer.flex"
{
hsnewid(yytext, yyleng);
RETURN(_isconstr(yytext) ? CONID : VARID);
/* This SHOULDNAE work in "Code" (sigh) */
-case 119:
+case 120:
YY_RULE_SETUP
-#line 540 "yaccParser/hslexer.flex"
+#line 548 "yaccParser/hslexer.flex"
{
if (! (nonstandardFlag || in_interface)) {
char errbuf[ERR_BUF_SIZE];
/* NB: ^^^^^^^^ : not the macro! */
}
YY_BREAK
-case 120:
+case 121:
YY_RULE_SETUP
-#line 550 "yaccParser/hslexer.flex"
+#line 558 "yaccParser/hslexer.flex"
{
hsnewid(yytext, yyleng);
RETURN(_isconstr(yytext) ? CONID : VARID);
}
YY_BREAK
-case 121:
+case 122:
YY_RULE_SETUP
-#line 554 "yaccParser/hslexer.flex"
+#line 562 "yaccParser/hslexer.flex"
{
hsnewid(yytext, yyleng);
RETURN(_isconstr(yytext) ? CONSYM : VARSYM);
la-la land constructs as `{-a 900-line comment-} foo`. (WDP 94/12)
*/
-case 122:
+case 123:
YY_RULE_SETUP
-#line 569 "yaccParser/hslexer.flex"
+#line 577 "yaccParser/hslexer.flex"
{
hsnewid(yytext + 1, yyleng - 2);
RETURN(_isconstr(yytext+1) ? CONSYM : VARSYM);
* are ignored with a warning.
*/
-case 123:
+case 124:
YY_RULE_SETUP
-#line 588 "yaccParser/hslexer.flex"
+#line 596 "yaccParser/hslexer.flex"
{
yylval.uhstring = installHstring(1, yytext+1);
RETURN(CHARPRIM);
}
YY_BREAK
-case 124:
+case 125:
YY_RULE_SETUP
-#line 592 "yaccParser/hslexer.flex"
+#line 600 "yaccParser/hslexer.flex"
{
yylval.uhstring = installHstring(1, yytext+1);
RETURN(CHAR);
}
YY_BREAK
-case 125:
+case 126:
YY_RULE_SETUP
-#line 596 "yaccParser/hslexer.flex"
+#line 604 "yaccParser/hslexer.flex"
{char errbuf[ERR_BUF_SIZE];
sprintf(errbuf, "'' is not a valid character (or string) literal\n");
hsperror(errbuf);
}
YY_BREAK
-case 126:
+case 127:
YY_RULE_SETUP
-#line 600 "yaccParser/hslexer.flex"
+#line 608 "yaccParser/hslexer.flex"
{
hsmlcolno = hspcolno;
cleartext();
PUSH_STATE(Char);
}
YY_BREAK
-case 127:
+case 128:
YY_RULE_SETUP
-#line 606 "yaccParser/hslexer.flex"
+#line 614 "yaccParser/hslexer.flex"
{
unsigned length;
char *text;
RETURN(CHARPRIM);
}
YY_BREAK
-case 128:
+case 129:
YY_RULE_SETUP
-#line 631 "yaccParser/hslexer.flex"
+#line 639 "yaccParser/hslexer.flex"
{
unsigned length;
char *text;
RETURN(CHAR);
}
YY_BREAK
-case 129:
+case 130:
YY_RULE_SETUP
-#line 650 "yaccParser/hslexer.flex"
+#line 658 "yaccParser/hslexer.flex"
{ addtext(yytext, yyleng); }
YY_BREAK
* of normal characters and the close ".
*/
-case 130:
+case 131:
YY_RULE_SETUP
-#line 668 "yaccParser/hslexer.flex"
+#line 676 "yaccParser/hslexer.flex"
{
yylval.uhstring = installHstring(yyleng-3, yytext+1);
/* the -3 accounts for the " on front, "# on the end */
RETURN(STRINGPRIM);
}
YY_BREAK
-case 131:
+case 132:
YY_RULE_SETUP
-#line 673 "yaccParser/hslexer.flex"
+#line 681 "yaccParser/hslexer.flex"
{
yylval.uhstring = installHstring(yyleng-2, yytext+1);
RETURN(STRING);
}
YY_BREAK
-case 132:
+case 133:
YY_RULE_SETUP
-#line 677 "yaccParser/hslexer.flex"
+#line 685 "yaccParser/hslexer.flex"
{
hsmlcolno = hspcolno;
cleartext();
PUSH_STATE(String);
}
YY_BREAK
-case 133:
+case 134:
YY_RULE_SETUP
-#line 683 "yaccParser/hslexer.flex"
+#line 691 "yaccParser/hslexer.flex"
{
unsigned length;
char *text;
RETURN(STRINGPRIM);
}
YY_BREAK
-case 134:
+case 135:
YY_RULE_SETUP
-#line 701 "yaccParser/hslexer.flex"
+#line 709 "yaccParser/hslexer.flex"
{
unsigned length;
char *text;
RETURN(STRING);
}
YY_BREAK
-case 135:
+case 136:
YY_RULE_SETUP
-#line 713 "yaccParser/hslexer.flex"
+#line 721 "yaccParser/hslexer.flex"
{ addtext(yytext, yyleng); }
YY_BREAK
* also needs to be able to escape the escape character ('\\'). Sigh.
*/
-case 136:
+case 137:
YY_RULE_SETUP
-#line 731 "yaccParser/hslexer.flex"
+#line 739 "yaccParser/hslexer.flex"
{ PUSH_STATE(CharEsc); }
YY_BREAK
-case 137:
+case 138:
YY_RULE_SETUP
-#line 732 "yaccParser/hslexer.flex"
+#line 740 "yaccParser/hslexer.flex"
/* Ignore */ ;
YY_BREAK
-case 138:
+case 139:
YY_RULE_SETUP
-#line 733 "yaccParser/hslexer.flex"
+#line 741 "yaccParser/hslexer.flex"
{ PUSH_STATE(StringEsc); noGap = TRUE; }
YY_BREAK
-case 139:
+case 140:
YY_RULE_SETUP
-#line 735 "yaccParser/hslexer.flex"
+#line 743 "yaccParser/hslexer.flex"
{ addchar(*yytext); POP_STATE; }
YY_BREAK
-case 140:
+case 141:
YY_RULE_SETUP
-#line 736 "yaccParser/hslexer.flex"
+#line 744 "yaccParser/hslexer.flex"
{ if (noGap) { addchar(*yytext); } POP_STATE; }
YY_BREAK
-case 141:
+case 142:
YY_RULE_SETUP
-#line 738 "yaccParser/hslexer.flex"
+#line 746 "yaccParser/hslexer.flex"
{ addchar(*yytext); POP_STATE; }
YY_BREAK
-case 142:
+case 143:
YY_RULE_SETUP
-#line 739 "yaccParser/hslexer.flex"
+#line 747 "yaccParser/hslexer.flex"
{ addchar('\000'); POP_STATE; }
YY_BREAK
-case 143:
+case 144:
YY_RULE_SETUP
-#line 740 "yaccParser/hslexer.flex"
+#line 748 "yaccParser/hslexer.flex"
{ addchar('\001'); POP_STATE; }
YY_BREAK
-case 144:
+case 145:
YY_RULE_SETUP
-#line 741 "yaccParser/hslexer.flex"
+#line 749 "yaccParser/hslexer.flex"
{ addchar('\002'); POP_STATE; }
YY_BREAK
-case 145:
+case 146:
YY_RULE_SETUP
-#line 742 "yaccParser/hslexer.flex"
+#line 750 "yaccParser/hslexer.flex"
{ addchar('\003'); POP_STATE; }
YY_BREAK
-case 146:
+case 147:
YY_RULE_SETUP
-#line 743 "yaccParser/hslexer.flex"
+#line 751 "yaccParser/hslexer.flex"
{ addchar('\004'); POP_STATE; }
YY_BREAK
-case 147:
+case 148:
YY_RULE_SETUP
-#line 744 "yaccParser/hslexer.flex"
+#line 752 "yaccParser/hslexer.flex"
{ addchar('\005'); POP_STATE; }
YY_BREAK
-case 148:
+case 149:
YY_RULE_SETUP
-#line 745 "yaccParser/hslexer.flex"
+#line 753 "yaccParser/hslexer.flex"
{ addchar('\006'); POP_STATE; }
YY_BREAK
-case 149:
-#line 747 "yaccParser/hslexer.flex"
case 150:
+#line 755 "yaccParser/hslexer.flex"
+case 151:
YY_RULE_SETUP
-#line 747 "yaccParser/hslexer.flex"
+#line 755 "yaccParser/hslexer.flex"
{ addchar('\007'); POP_STATE; }
YY_BREAK
-case 151:
-#line 749 "yaccParser/hslexer.flex"
case 152:
+#line 757 "yaccParser/hslexer.flex"
+case 153:
YY_RULE_SETUP
-#line 749 "yaccParser/hslexer.flex"
+#line 757 "yaccParser/hslexer.flex"
{ addchar('\010'); POP_STATE; }
YY_BREAK
-case 153:
-#line 751 "yaccParser/hslexer.flex"
case 154:
+#line 759 "yaccParser/hslexer.flex"
+case 155:
YY_RULE_SETUP
-#line 751 "yaccParser/hslexer.flex"
+#line 759 "yaccParser/hslexer.flex"
{ addchar('\011'); POP_STATE; }
YY_BREAK
-case 155:
-#line 753 "yaccParser/hslexer.flex"
case 156:
+#line 761 "yaccParser/hslexer.flex"
+case 157:
YY_RULE_SETUP
-#line 753 "yaccParser/hslexer.flex"
+#line 761 "yaccParser/hslexer.flex"
{ addchar('\012'); POP_STATE; }
YY_BREAK
-case 157:
-#line 755 "yaccParser/hslexer.flex"
case 158:
+#line 763 "yaccParser/hslexer.flex"
+case 159:
YY_RULE_SETUP
-#line 755 "yaccParser/hslexer.flex"
+#line 763 "yaccParser/hslexer.flex"
{ addchar('\013'); POP_STATE; }
YY_BREAK
-case 159:
-#line 757 "yaccParser/hslexer.flex"
case 160:
+#line 765 "yaccParser/hslexer.flex"
+case 161:
YY_RULE_SETUP
-#line 757 "yaccParser/hslexer.flex"
+#line 765 "yaccParser/hslexer.flex"
{ addchar('\014'); POP_STATE; }
YY_BREAK
-case 161:
-#line 759 "yaccParser/hslexer.flex"
case 162:
+#line 767 "yaccParser/hslexer.flex"
+case 163:
YY_RULE_SETUP
-#line 759 "yaccParser/hslexer.flex"
+#line 767 "yaccParser/hslexer.flex"
{ addchar('\015'); POP_STATE; }
YY_BREAK
-case 163:
+case 164:
YY_RULE_SETUP
-#line 760 "yaccParser/hslexer.flex"
+#line 768 "yaccParser/hslexer.flex"
{ addchar('\016'); POP_STATE; }
YY_BREAK
-case 164:
+case 165:
YY_RULE_SETUP
-#line 761 "yaccParser/hslexer.flex"
+#line 769 "yaccParser/hslexer.flex"
{ addchar('\017'); POP_STATE; }
YY_BREAK
-case 165:
+case 166:
YY_RULE_SETUP
-#line 762 "yaccParser/hslexer.flex"
+#line 770 "yaccParser/hslexer.flex"
{ addchar('\020'); POP_STATE; }
YY_BREAK
-case 166:
+case 167:
YY_RULE_SETUP
-#line 763 "yaccParser/hslexer.flex"
+#line 771 "yaccParser/hslexer.flex"
{ addchar('\021'); POP_STATE; }
YY_BREAK
-case 167:
+case 168:
YY_RULE_SETUP
-#line 764 "yaccParser/hslexer.flex"
+#line 772 "yaccParser/hslexer.flex"
{ addchar('\022'); POP_STATE; }
YY_BREAK
-case 168:
+case 169:
YY_RULE_SETUP
-#line 765 "yaccParser/hslexer.flex"
+#line 773 "yaccParser/hslexer.flex"
{ addchar('\023'); POP_STATE; }
YY_BREAK
-case 169:
+case 170:
YY_RULE_SETUP
-#line 766 "yaccParser/hslexer.flex"
+#line 774 "yaccParser/hslexer.flex"
{ addchar('\024'); POP_STATE; }
YY_BREAK
-case 170:
+case 171:
YY_RULE_SETUP
-#line 767 "yaccParser/hslexer.flex"
+#line 775 "yaccParser/hslexer.flex"
{ addchar('\025'); POP_STATE; }
YY_BREAK
-case 171:
+case 172:
YY_RULE_SETUP
-#line 768 "yaccParser/hslexer.flex"
+#line 776 "yaccParser/hslexer.flex"
{ addchar('\026'); POP_STATE; }
YY_BREAK
-case 172:
+case 173:
YY_RULE_SETUP
-#line 769 "yaccParser/hslexer.flex"
+#line 777 "yaccParser/hslexer.flex"
{ addchar('\027'); POP_STATE; }
YY_BREAK
-case 173:
+case 174:
YY_RULE_SETUP
-#line 770 "yaccParser/hslexer.flex"
+#line 778 "yaccParser/hslexer.flex"
{ addchar('\030'); POP_STATE; }
YY_BREAK
-case 174:
+case 175:
YY_RULE_SETUP
-#line 771 "yaccParser/hslexer.flex"
+#line 779 "yaccParser/hslexer.flex"
{ addchar('\031'); POP_STATE; }
YY_BREAK
-case 175:
+case 176:
YY_RULE_SETUP
-#line 772 "yaccParser/hslexer.flex"
+#line 780 "yaccParser/hslexer.flex"
{ addchar('\032'); POP_STATE; }
YY_BREAK
-case 176:
+case 177:
YY_RULE_SETUP
-#line 773 "yaccParser/hslexer.flex"
+#line 781 "yaccParser/hslexer.flex"
{ addchar('\033'); POP_STATE; }
YY_BREAK
-case 177:
+case 178:
YY_RULE_SETUP
-#line 774 "yaccParser/hslexer.flex"
+#line 782 "yaccParser/hslexer.flex"
{ addchar('\034'); POP_STATE; }
YY_BREAK
-case 178:
+case 179:
YY_RULE_SETUP
-#line 775 "yaccParser/hslexer.flex"
+#line 783 "yaccParser/hslexer.flex"
{ addchar('\035'); POP_STATE; }
YY_BREAK
-case 179:
+case 180:
YY_RULE_SETUP
-#line 776 "yaccParser/hslexer.flex"
+#line 784 "yaccParser/hslexer.flex"
{ addchar('\036'); POP_STATE; }
YY_BREAK
-case 180:
+case 181:
YY_RULE_SETUP
-#line 777 "yaccParser/hslexer.flex"
+#line 785 "yaccParser/hslexer.flex"
{ addchar('\037'); POP_STATE; }
YY_BREAK
-case 181:
+case 182:
YY_RULE_SETUP
-#line 778 "yaccParser/hslexer.flex"
+#line 786 "yaccParser/hslexer.flex"
{ addchar('\040'); POP_STATE; }
YY_BREAK
-case 182:
+case 183:
YY_RULE_SETUP
-#line 779 "yaccParser/hslexer.flex"
+#line 787 "yaccParser/hslexer.flex"
{ addchar('\177'); POP_STATE; }
YY_BREAK
-case 183:
+case 184:
YY_RULE_SETUP
-#line 780 "yaccParser/hslexer.flex"
+#line 788 "yaccParser/hslexer.flex"
{ char c = yytext[1] - '@'; addchar(c); POP_STATE; }
YY_BREAK
-case 184:
+case 185:
YY_RULE_SETUP
-#line 781 "yaccParser/hslexer.flex"
+#line 789 "yaccParser/hslexer.flex"
{
int i = strtol(yytext, NULL, 10);
if (i < NCHARS) {
POP_STATE;
}
YY_BREAK
-case 185:
+case 186:
YY_RULE_SETUP
-#line 793 "yaccParser/hslexer.flex"
+#line 801 "yaccParser/hslexer.flex"
{
int i = strtol(yytext + 1, NULL, 8);
if (i < NCHARS) {
POP_STATE;
}
YY_BREAK
-case 186:
+case 187:
YY_RULE_SETUP
-#line 805 "yaccParser/hslexer.flex"
+#line 813 "yaccParser/hslexer.flex"
{
int i = strtol(yytext + 1, NULL, 16);
if (i < NCHARS) {
* to do. Reported by Rajiv Mirani. (WDP 95/08)
*/
-case 187:
-#line 831 "yaccParser/hslexer.flex"
case 188:
+#line 839 "yaccParser/hslexer.flex"
+case 189:
YY_RULE_SETUP
-#line 831 "yaccParser/hslexer.flex"
+#line 839 "yaccParser/hslexer.flex"
{ noGap = FALSE; }
YY_BREAK
* That's why the rules look so bizarre.
*/
-case 189:
+case 190:
YY_RULE_SETUP
-#line 841 "yaccParser/hslexer.flex"
+#line 849 "yaccParser/hslexer.flex"
{
noGap = FALSE; nested_comments = 1; PUSH_STATE(Comment);
}
YY_BREAK
-case 190:
-#line 846 "yaccParser/hslexer.flex"
case 191:
-#line 847 "yaccParser/hslexer.flex"
+#line 854 "yaccParser/hslexer.flex"
case 192:
+#line 855 "yaccParser/hslexer.flex"
+case 193:
YY_RULE_SETUP
-#line 847 "yaccParser/hslexer.flex"
+#line 855 "yaccParser/hslexer.flex"
;
YY_BREAK
-case 193:
+case 194:
YY_RULE_SETUP
-#line 848 "yaccParser/hslexer.flex"
+#line 856 "yaccParser/hslexer.flex"
{ nested_comments++; }
YY_BREAK
-case 194:
+case 195:
YY_RULE_SETUP
-#line 849 "yaccParser/hslexer.flex"
+#line 857 "yaccParser/hslexer.flex"
{ if (--nested_comments == 0) POP_STATE; }
YY_BREAK
-case 195:
+case 196:
YY_RULE_SETUP
-#line 850 "yaccParser/hslexer.flex"
+#line 858 "yaccParser/hslexer.flex"
;
YY_BREAK
* the error message.
*/
-case 196:
+case 197:
YY_RULE_SETUP
-#line 860 "yaccParser/hslexer.flex"
+#line 868 "yaccParser/hslexer.flex"
{
fprintf(stderr, "\"%s\", line %d, column %d: Illegal character: `",
input_filename, hsplineno, hspcolno + 1);
hsperror("");
}
YY_BREAK
-case 197:
+case 198:
YY_RULE_SETUP
-#line 867 "yaccParser/hslexer.flex"
+#line 875 "yaccParser/hslexer.flex"
{
fprintf(stderr, "\"%s\", line %d, column %d: Illegal character: `",
input_filename, hsplineno, hspcolno + 1);
hsperror("");
}
YY_BREAK
-case 198:
+case 199:
YY_RULE_SETUP
-#line 874 "yaccParser/hslexer.flex"
+#line 882 "yaccParser/hslexer.flex"
{
fprintf(stderr, "\"%s\", line %d, column %d: Illegal character escape: `\\",
input_filename, hsplineno, hspcolno + 1);
hsperror("");
}
YY_BREAK
-case 199:
+case 200:
YY_RULE_SETUP
-#line 881 "yaccParser/hslexer.flex"
+#line 889 "yaccParser/hslexer.flex"
{ if (nonstandardFlag) {
addtext(yytext, yyleng);
} else {
}
}
YY_BREAK
-case 200:
+case 201:
YY_RULE_SETUP
-#line 891 "yaccParser/hslexer.flex"
+#line 899 "yaccParser/hslexer.flex"
{
if (noGap) {
fprintf(stderr, "\"%s\", line %d, column %d: Illegal string escape: `\\",
case YY_STATE_EOF(Char):
case YY_STATE_EOF(CharEsc):
-#line 920 "yaccParser/hslexer.flex"
+#line 928 "yaccParser/hslexer.flex"
{
hsplineno = hslineno; hspcolno = hscolno;
hsperror("unterminated character literal");
}
YY_BREAK
case YY_STATE_EOF(Comment):
-#line 924 "yaccParser/hslexer.flex"
+#line 932 "yaccParser/hslexer.flex"
{
hsplineno = hslineno; hspcolno = hscolno;
hsperror("unterminated comment");
YY_BREAK
case YY_STATE_EOF(String):
case YY_STATE_EOF(StringEsc):
-#line 928 "yaccParser/hslexer.flex"
+#line 936 "yaccParser/hslexer.flex"
{
hsplineno = hslineno; hspcolno = hscolno;
hsperror("unterminated string literal");
}
YY_BREAK
case YY_STATE_EOF(GhcPragma):
-#line 932 "yaccParser/hslexer.flex"
+#line 940 "yaccParser/hslexer.flex"
{
hsplineno = hslineno; hspcolno = hscolno;
hsperror("unterminated interface pragma");
}
YY_BREAK
case YY_STATE_EOF(UserPragma):
-#line 936 "yaccParser/hslexer.flex"
+#line 944 "yaccParser/hslexer.flex"
{
hsplineno = hslineno; hspcolno = hscolno;
hsperror("unterminated user-specified pragma");
YY_BREAK
case YY_STATE_EOF(Code):
case YY_STATE_EOF(GlaExt):
-#line 940 "yaccParser/hslexer.flex"
+#line 948 "yaccParser/hslexer.flex"
{ hsplineno = hslineno; hspcolno = hscolno; return(EOF); }
YY_BREAK
-case 201:
+case 202:
YY_RULE_SETUP
-#line 942 "yaccParser/hslexer.flex"
+#line 950 "yaccParser/hslexer.flex"
YY_FATAL_ERROR( "flex scanner jammed" );
YY_BREAK
case YY_STATE_EOF(INITIAL):
while ( yy_chk[yy_base[yy_current_state] + yy_c] != yy_current_state )
{
yy_current_state = (int) yy_def[yy_current_state];
- if ( yy_current_state >= 836 )
+ if ( yy_current_state >= 837 )
yy_c = yy_meta[(unsigned int) yy_c];
}
yy_current_state = yy_nxt[yy_base[yy_current_state] + (unsigned int) yy_c];
while ( yy_chk[yy_base[yy_current_state] + yy_c] != yy_current_state )
{
yy_current_state = (int) yy_def[yy_current_state];
- if ( yy_current_state >= 836 )
+ if ( yy_current_state >= 837 )
yy_c = yy_meta[(unsigned int) yy_c];
}
yy_current_state = yy_nxt[yy_base[yy_current_state] + (unsigned int) yy_c];
- yy_is_jam = (yy_current_state == 835);
+ yy_is_jam = (yy_current_state == 836);
return yy_is_jam ? 0 : yy_current_state;
}
return 0;
}
#endif
-#line 942 "yaccParser/hslexer.flex"
+#line 950 "yaccParser/hslexer.flex"
/**********************************************************************
PUSH_STATE(UserPragma);
RETURN(ABSTRACT_UPRAGMA);
}
+<Code,GlaExt>"{-#"{WS}*[A-Z_]+ {
+ fprintf(stderr, "Warning: \"%s\", line %d: Unrecognised pragma '",
+ input_filename, hsplineno);
+ format_string(stderr, (unsigned char *) yytext, yyleng);
+ fputs("'\n", stderr);
+ nested_comments = 1;
+ PUSH_STATE(Comment);
+ }
<UserPragma>"#-}" { POP_STATE; RETURN(END_UPRAGMA); }
%{
extern int thisIfacePragmaVersion;
-
-#line 100 "yaccParser/hsparser.y"
+#line 99 "yaccParser/hsparser.y"
typedef union {
tree utree;
list ulist;
-#define YYFINAL 1094
+#define YYFINAL 1105
#define YYFLAG -32768
#define YYNTBASE 120
-#define YYTRANSLATE(x) ((unsigned)(x) <= 374 ? yytranslate[x] : 347)
+#define YYTRANSLATE(x) ((unsigned)(x) <= 374 ? yytranslate[x] : 343)
static const char yytranslate[] = { 0,
2, 2, 2, 2, 2, 2, 2, 2, 2, 2,
74, 78, 81, 85, 90, 93, 94, 96, 98, 102,
104, 106, 111, 116, 121, 125, 130, 134, 135, 138,
139, 141, 145, 149, 153, 154, 158, 159, 164, 165,
- 170, 176, 182, 183, 186, 187, 190, 194, 195, 197,
- 204, 206, 209, 211, 214, 216, 218, 220, 223, 227,
- 231, 232, 234, 237, 241, 243, 249, 251, 255, 257,
- 260, 262, 266, 272, 274, 278, 285, 287, 291, 293,
- 295, 296, 298, 300, 304, 308, 313, 318, 323, 330,
- 335, 339, 345, 352, 361, 368, 374, 376, 378, 382,
- 386, 387, 390, 396, 397, 400, 405, 407, 411, 413,
- 417, 421, 424, 429, 436, 443, 450, 452, 454, 456,
- 458, 462, 466, 470, 476, 483, 489, 492, 496, 500,
- 502, 504, 513, 522, 531, 540, 542, 543, 546, 552,
- 555, 559, 561, 565, 567, 569, 571, 574, 576, 580,
- 583, 587, 589, 593, 595, 597, 601, 603, 605, 606,
- 609, 610, 613, 614, 617, 619, 623, 624, 629, 632,
- 637, 640, 644, 646, 650, 654, 658, 659, 662, 664,
- 668, 674, 682, 683, 689, 695, 699, 705, 709, 710,
- 713, 715, 719, 720, 725, 726, 731, 732, 737, 738,
- 742, 743, 747, 748, 752, 754, 758, 760, 764, 766,
- 768, 770, 772, 774, 776, 781, 788, 793, 802, 809,
- 815, 819, 820, 825, 830, 837, 842, 843, 848, 853,
- 855, 859, 863, 866, 870, 876, 879, 885, 887, 889,
- 893, 900, 905, 911, 917, 923, 928, 933, 937, 941,
- 943, 944, 945, 947, 949, 953, 955, 959, 961, 965,
- 967, 969, 971, 973, 975, 976, 983, 988, 994, 1000,
- 1004, 1012, 1018, 1027, 1034, 1041, 1046, 1053, 1058, 1061,
- 1063, 1067, 1069, 1073, 1078, 1080, 1083, 1086, 1088, 1090,
- 1094, 1097, 1099, 1105, 1107, 1109, 1112, 1116, 1120, 1127,
- 1129, 1131, 1134, 1137, 1139, 1143, 1146, 1151, 1153, 1157,
- 1161, 1165, 1168, 1170, 1172, 1176, 1180, 1182, 1184, 1188,
- 1189, 1191, 1195, 1200, 1205, 1207, 1211, 1213, 1215, 1219,
- 1221, 1225, 1226, 1230, 1233, 1235, 1238, 1242, 1247, 1252,
- 1257, 1258, 1261, 1264, 1266, 1272, 1276, 1278, 1280, 1284,
- 1287, 1289, 1290, 1291, 1298, 1305, 1312, 1319, 1326, 1333,
- 1337, 1340, 1344, 1347, 1351, 1354, 1358, 1361, 1365, 1367,
- 1370, 1372, 1375, 1377, 1379, 1381, 1383, 1387, 1392, 1397,
- 1399, 1401, 1403, 1405, 1409, 1411, 1414, 1416, 1420, 1422,
- 1426, 1429, 1431, 1434, 1436, 1439, 1441, 1444, 1446, 1448,
- 1450, 1454, 1456, 1458, 1461, 1467, 1471, 1477, 1481, 1484,
- 1487, 1489, 1491, 1495, 1497, 1499, 1502, 1508, 1512, 1518,
- 1522, 1525, 1528, 1534, 1537, 1539, 1543, 1546, 1550, 1552,
- 1556, 1564, 1570, 1576, 1578, 1582, 1583, 1584, 1589, 1592,
- 1593, 1595, 1599, 1600, 1604, 1605, 1608, 1612, 1617, 1621,
- 1622, 1624, 1628, 1630, 1632, 1636, 1638, 1640, 1643, 1646,
- 1648, 1651, 1653, 1655, 1657, 1661, 1663, 1665, 1668, 1674,
- 1678, 1684, 1688, 1691, 1694, 1696, 1698, 1700, 1702, 1704,
- 1706, 1708, 1710, 1712, 1714, 1718, 1721, 1725, 1728, 1730,
- 1732, 1734, 1736, 1738, 1740, 1742, 1744, 1746, 1748, 1750,
- 1752, 1754, 1756, 1758, 1760, 1764, 1766, 1768, 1772, 1774,
- 1778, 1780, 1782, 1784, 1786, 1788, 1790, 1794, 1796, 1800,
- 1802, 1806, 1808, 1812, 1814, 1816, 1820, 1824, 1826, 1829,
- 1831, 1833, 1835, 1837, 1840, 1842, 1843, 1845, 1846, 1849,
- 1851
+ 170, 176, 177, 180, 181, 185, 186, 188, 195, 197,
+ 200, 202, 205, 207, 209, 211, 214, 218, 222, 223,
+ 225, 228, 232, 234, 240, 242, 246, 248, 251, 253,
+ 257, 263, 265, 269, 271, 273, 275, 279, 285, 289,
+ 294, 299, 304, 311, 316, 320, 326, 333, 342, 349,
+ 355, 357, 359, 363, 367, 368, 371, 377, 378, 381,
+ 386, 388, 392, 394, 398, 402, 405, 410, 417, 424,
+ 431, 433, 435, 437, 439, 443, 447, 451, 457, 464,
+ 470, 473, 477, 481, 483, 485, 494, 503, 512, 521,
+ 523, 524, 527, 533, 536, 540, 542, 546, 548, 550,
+ 552, 555, 557, 561, 564, 568, 570, 574, 576, 578,
+ 582, 584, 586, 587, 590, 591, 594, 595, 598, 600,
+ 604, 605, 610, 613, 618, 621, 625, 627, 631, 635,
+ 639, 640, 643, 645, 649, 655, 663, 664, 670, 676,
+ 680, 686, 690, 691, 694, 696, 700, 701, 706, 707,
+ 712, 713, 718, 719, 723, 724, 728, 729, 733, 735,
+ 739, 741, 745, 747, 749, 751, 753, 755, 757, 762,
+ 769, 774, 783, 790, 796, 800, 801, 806, 811, 818,
+ 823, 824, 829, 834, 836, 841, 847, 850, 854, 860,
+ 862, 867, 873, 876, 880, 886, 889, 895, 897, 899,
+ 903, 910, 915, 921, 927, 933, 938, 943, 947, 951,
+ 953, 954, 955, 957, 959, 963, 965, 969, 971, 975,
+ 977, 979, 981, 983, 985, 986, 993, 998, 1004, 1010,
+ 1014, 1022, 1028, 1037, 1044, 1051, 1056, 1063, 1068, 1071,
+ 1073, 1077, 1079, 1083, 1088, 1090, 1093, 1096, 1098, 1100,
+ 1104, 1107, 1109, 1115, 1117, 1119, 1122, 1126, 1130, 1137,
+ 1139, 1141, 1144, 1146, 1150, 1153, 1158, 1160, 1164, 1168,
+ 1172, 1175, 1177, 1179, 1183, 1187, 1189, 1191, 1195, 1196,
+ 1198, 1202, 1208, 1213, 1218, 1220, 1224, 1226, 1228, 1232,
+ 1234, 1238, 1239, 1243, 1246, 1248, 1251, 1255, 1260, 1265,
+ 1270, 1271, 1274, 1277, 1279, 1285, 1289, 1291, 1293, 1297,
+ 1300, 1302, 1303, 1304, 1311, 1318, 1325, 1332, 1339, 1346,
+ 1350, 1353, 1357, 1360, 1364, 1367, 1371, 1374, 1378, 1380,
+ 1383, 1385, 1388, 1390, 1392, 1394, 1396, 1400, 1405, 1410,
+ 1412, 1414, 1416, 1418, 1422, 1424, 1427, 1429, 1433, 1435,
+ 1439, 1442, 1444, 1447, 1449, 1452, 1454, 1457, 1459, 1461,
+ 1463, 1467, 1469, 1471, 1474, 1480, 1484, 1490, 1494, 1497,
+ 1500, 1502, 1504, 1508, 1510, 1512, 1515, 1521, 1525, 1531,
+ 1535, 1538, 1541, 1547, 1550, 1552, 1556, 1559, 1563, 1565,
+ 1569, 1577, 1583, 1589, 1591, 1595, 1596, 1597, 1602, 1605,
+ 1606, 1608, 1612, 1613, 1617, 1618, 1621, 1625, 1630, 1634,
+ 1635, 1637, 1641, 1643, 1645, 1649, 1651, 1653, 1656, 1659,
+ 1661, 1664, 1666, 1668, 1670, 1674, 1676, 1678, 1681, 1687,
+ 1691, 1697, 1701, 1704, 1707, 1709, 1711, 1713, 1715, 1717,
+ 1719, 1721, 1723, 1725, 1727, 1731, 1734, 1738, 1741, 1743,
+ 1745, 1747, 1749, 1751, 1753, 1755, 1757, 1759, 1761, 1763,
+ 1765, 1767, 1769, 1771, 1773, 1777, 1779, 1781, 1785, 1787,
+ 1791, 1793, 1795, 1797, 1799, 1801, 1803, 1807, 1809, 1813,
+ 1815, 1819, 1821, 1825, 1827, 1829, 1831, 1835, 1837, 1840,
+ 1842, 1844, 1846, 1848, 1851, 1853, 1854, 1856, 1857, 1860,
+ 1862
};
-static const short yyrhs[] = { 188,
- 190, 121, 0, 0, 317, 339, 125, 122, 41, 124,
- 0, 0, 123, 124, 0, 340, 192, 207, 217, 343,
- 0, 341, 192, 207, 217, 344, 0, 341, 193, 344,
- 0, 340, 193, 343, 0, 341, 192, 344, 0, 340,
- 192, 343, 0, 0, 24, 126, 25, 0, 127, 0,
- 126, 26, 127, 0, 329, 0, 338, 0, 338, 24,
- 32, 25, 0, 338, 24, 260, 25, 0, 338, 24,
- 258, 25, 0, 338, 24, 25, 0, 338, 32, 0,
+static const short yyrhs[] = { 184,
+ 186, 121, 0, 0, 313, 335, 125, 122, 41, 124,
+ 0, 0, 123, 124, 0, 336, 188, 203, 213, 339,
+ 0, 337, 188, 203, 213, 340, 0, 337, 189, 340,
+ 0, 336, 189, 339, 0, 337, 188, 340, 0, 336,
+ 188, 339, 0, 0, 24, 126, 25, 0, 127, 0,
+ 126, 26, 127, 0, 325, 0, 334, 0, 334, 24,
+ 32, 25, 0, 334, 24, 256, 25, 0, 334, 24,
+ 254, 25, 0, 334, 24, 25, 0, 334, 32, 0,
24, 130, 25, 0, 55, 24, 130, 25, 0, 24,
25, 0, 0, 128, 0, 131, 0, 130, 26, 131,
- 0, 329, 0, 338, 0, 338, 24, 32, 25, 0,
- 338, 24, 260, 25, 0, 338, 24, 258, 25, 0,
- 338, 24, 25, 0, 68, 250, 133, 69, 0, 68,
+ 0, 325, 0, 334, 0, 334, 24, 32, 25, 0,
+ 334, 24, 256, 25, 0, 334, 24, 254, 25, 0,
+ 334, 24, 25, 0, 68, 246, 133, 69, 0, 68,
133, 69, 0, 0, 73, 134, 0, 0, 135, 0,
- 134, 26, 135, 0, 22, 157, 23, 0, 68, 72,
- 69, 0, 0, 68, 151, 69, 0, 0, 68, 143,
- 143, 69, 0, 0, 68, 140, 143, 69, 0, 68,
- 140, 143, 160, 69, 0, 68, 140, 143, 141, 69,
- 0, 0, 74, 339, 0, 0, 73, 155, 0, 68,
- 143, 69, 0, 0, 71, 0, 144, 145, 146, 147,
- 149, 152, 0, 70, 0, 75, 8, 0, 70, 0,
- 76, 8, 0, 70, 0, 81, 0, 70, 0, 77,
- 89, 0, 77, 11, 148, 0, 18, 143, 19, 0,
- 0, 70, 0, 80, 330, 0, 79, 150, 162, 0,
- 107, 0, 108, 8, 8, 4, 8, 0, 143, 0,
- 151, 26, 143, 0, 70, 0, 73, 153, 0, 154,
- 0, 153, 26, 154, 0, 22, 157, 23, 8, 148,
- 0, 156, 0, 155, 26, 156, 0, 22, 157, 23,
- 8, 148, 159, 0, 158, 0, 157, 26, 158, 0,
- 70, 0, 242, 0, 0, 160, 0, 161, 0, 160,
- 26, 161, 0, 329, 30, 143, 0, 38, 176, 28,
- 162, 0, 88, 181, 28, 162, 0, 89, 331, 183,
- 178, 0, 89, 106, 339, 331, 183, 178, 0, 90,
- 175, 183, 178, 0, 91, 162, 178, 0, 92, 162,
- 18, 185, 19, 0, 42, 162, 43, 18, 163, 19,
- 0, 39, 18, 177, 30, 162, 19, 40, 162, 0,
- 98, 18, 169, 19, 40, 162, 0, 60, 18, 171,
- 19, 162, 0, 309, 0, 174, 0, 95, 164, 168,
- 0, 96, 166, 168, 0, 0, 164, 165, 0, 174,
- 176, 28, 162, 21, 0, 0, 166, 167, 0, 309,
- 28, 162, 21, 0, 97, 0, 177, 28, 162, 0,
- 170, 0, 169, 21, 170, 0, 177, 30, 162, 0,
- 112, 173, 0, 113, 11, 11, 173, 0, 114, 11,
- 11, 11, 173, 172, 0, 115, 174, 11, 11, 173,
- 172, 0, 116, 174, 11, 11, 173, 172, 0, 70,
- 0, 117, 0, 70, 0, 118, 0, 99, 338, 338,
- 0, 100, 338, 329, 0, 101, 338, 329, 0, 102,
- 338, 24, 185, 25, 0, 103, 338, 329, 24, 185,
- 25, 0, 104, 174, 22, 186, 23, 0, 105, 174,
- 0, 106, 339, 329, 0, 106, 339, 331, 0, 329,
- 0, 331, 0, 24, 56, 333, 18, 183, 185, 19,
- 25, 0, 24, 57, 333, 18, 183, 185, 19, 25,
- 0, 24, 58, 309, 18, 183, 185, 19, 25, 0,
- 24, 59, 309, 18, 183, 185, 19, 25, 0, 3,
- 0, 0, 176, 177, 0, 24, 3, 33, 185, 25,
- 0, 22, 23, 0, 22, 179, 23, 0, 180, 0,
- 179, 26, 180, 0, 309, 0, 174, 0, 3, 0,
- 181, 3, 0, 94, 0, 182, 26, 94, 0, 22,
- 23, 0, 22, 184, 23, 0, 185, 0, 184, 26,
- 185, 0, 242, 0, 187, 0, 186, 26, 187, 0,
- 70, 0, 185, 0, 0, 189, 197, 0, 0, 191,
- 197, 0, 0, 193, 21, 0, 194, 0, 193, 21,
- 194, 0, 0, 53, 339, 195, 196, 0, 197, 129,
- 0, 197, 129, 64, 198, 0, 204, 67, 0, 24,
- 199, 25, 0, 200, 0, 199, 26, 200, 0, 329,
- 66, 329, 0, 331, 66, 331, 0, 0, 202, 21,
- 0, 203, 0, 202, 21, 203, 0, 310, 339, 24,
- 130, 25, 0, 310, 339, 24, 130, 25, 64, 198,
- 0, 0, 54, 339, 205, 41, 206, 0, 340, 201,
- 207, 233, 343, 0, 340, 202, 343, 0, 341, 201,
- 207, 233, 344, 0, 341, 202, 344, 0, 0, 208,
- 21, 0, 209, 0, 208, 21, 209, 0, 0, 50,
- 8, 210, 216, 0, 0, 51, 8, 211, 216, 0,
- 0, 49, 8, 212, 216, 0, 0, 50, 213, 216,
- 0, 0, 51, 214, 216, 0, 0, 49, 215, 216,
- 0, 322, 0, 216, 26, 322, 0, 218, 0, 217,
- 21, 218, 0, 219, 0, 220, 0, 221, 0, 223,
- 0, 226, 0, 229, 0, 312, 248, 30, 242, 0,
- 311, 254, 31, 248, 30, 250, 0, 311, 248, 30,
- 250, 0, 311, 254, 31, 248, 30, 250, 65, 252,
- 0, 311, 248, 30, 250, 65, 252, 0, 315, 254,
- 31, 240, 222, 0, 315, 240, 222, 0, 0, 41,
- 340, 228, 343, 0, 41, 341, 228, 344, 0, 313,
- 254, 31, 337, 225, 224, 0, 313, 337, 225, 224,
- 0, 0, 41, 340, 256, 343, 0, 41, 341, 256,
- 344, 0, 338, 0, 24, 249, 25, 0, 24, 334,
- 25, 0, 24, 25, 0, 22, 246, 23, 0, 24,
- 246, 28, 246, 25, 0, 314, 227, 0, 24, 242,
- 26, 241, 25, 0, 245, 0, 229, 0, 228, 21,
- 229, 0, 258, 33, 242, 31, 242, 138, 0, 258,
- 33, 242, 138, 0, 82, 330, 33, 231, 87, 0,
- 82, 47, 4, 225, 87, 0, 82, 45, 338, 244,
- 87, 0, 83, 330, 230, 87, 0, 84, 330, 330,
- 87, 0, 86, 330, 87, 0, 85, 338, 87, 0,
- 261, 0, 0, 0, 4, 0, 232, 0, 231, 26,
- 232, 0, 242, 0, 242, 30, 330, 0, 234, 0,
- 233, 21, 234, 0, 236, 0, 237, 0, 238, 0,
- 239, 0, 235, 0, 0, 258, 33, 242, 31, 242,
- 142, 0, 258, 33, 242, 142, 0, 312, 248, 30,
- 242, 136, 0, 311, 254, 31, 248, 132, 0, 311,
- 248, 132, 0, 311, 254, 31, 248, 30, 250, 132,
- 0, 311, 248, 30, 250, 132, 0, 311, 254, 31,
- 248, 30, 250, 65, 252, 0, 311, 248, 30, 250,
- 65, 252, 0, 315, 254, 31, 240, 137, 222, 0,
- 315, 240, 137, 222, 0, 313, 254, 31, 337, 225,
- 139, 0, 313, 337, 225, 139, 0, 338, 336, 0,
- 242, 0, 241, 26, 242, 0, 243, 0, 243, 28,
- 242, 0, 93, 182, 31, 242, 0, 246, 0, 338,
- 244, 0, 244, 246, 0, 246, 0, 247, 0, 243,
- 28, 242, 0, 338, 244, 0, 247, 0, 24, 242,
- 26, 241, 25, 0, 336, 0, 338, 0, 24, 25,
- 0, 24, 242, 25, 0, 22, 242, 23, 0, 18,
- 18, 4, 242, 19, 19, 0, 94, 0, 338, 0,
- 338, 335, 0, 338, 244, 0, 251, 0, 250, 29,
- 251, 0, 338, 244, 0, 24, 6, 25, 244, 0,
- 338, 0, 24, 6, 25, 0, 243, 325, 243, 0,
- 24, 253, 25, 0, 24, 25, 0, 337, 0, 337,
- 0, 253, 26, 337, 0, 24, 255, 25, 0, 240,
- 0, 240, 0, 255, 26, 240, 0, 0, 257, 0,
- 256, 21, 257, 0, 83, 330, 230, 87, 0, 84,
- 330, 330, 87, 0, 261, 0, 330, 26, 259, 0,
- 330, 0, 329, 0, 259, 26, 329, 0, 331, 0,
- 260, 26, 331, 0, 0, 278, 262, 263, 0, 264,
- 266, 0, 265, 0, 30, 269, 0, 267, 30, 269,
- 0, 267, 30, 269, 265, 0, 41, 340, 228, 343,
- 0, 41, 341, 228, 344, 0, 0, 29, 270, 0,
- 307, 268, 0, 307, 0, 270, 33, 242, 31, 242,
- 0, 270, 33, 242, 0, 270, 0, 271, 0, 270,
- 322, 270, 0, 7, 272, 0, 272, 0, 0, 0,
- 38, 273, 268, 274, 28, 269, 0, 39, 340, 228,
- 343, 40, 269, 0, 39, 341, 228, 344, 40, 269,
- 0, 61, 269, 62, 269, 63, 269, 0, 42, 269,
- 43, 340, 297, 343, 0, 42, 269, 43, 341, 297,
- 344, 0, 56, 333, 276, 0, 56, 333, 0, 57,
- 333, 276, 0, 57, 333, 0, 58, 17, 276, 0,
- 58, 17, 0, 59, 17, 276, 0, 59, 17, 0,
- 60, 11, 269, 0, 275, 0, 275, 277, 0, 277,
- 0, 276, 277, 0, 277, 0, 329, 0, 331, 0,
- 309, 0, 24, 269, 25, 0, 24, 270, 322, 25,
- 0, 24, 321, 270, 25, 0, 286, 0, 288, 0,
- 290, 0, 291, 0, 329, 36, 277, 0, 35, 0,
- 37, 277, 0, 282, 0, 278, 322, 279, 0, 280,
- 0, 279, 322, 279, 0, 7, 281, 0, 281, 0,
- 281, 284, 0, 284, 0, 316, 281, 0, 283, 0,
- 283, 284, 0, 285, 0, 331, 0, 329, 0, 329,
- 36, 307, 0, 309, 0, 35, 0, 24, 25, 0,
- 24, 329, 119, 8, 25, 0, 24, 279, 25, 0,
- 24, 279, 26, 303, 25, 0, 22, 303, 23, 0,
- 22, 23, 0, 37, 307, 0, 332, 0, 330, 0,
- 330, 36, 307, 0, 309, 0, 35, 0, 318, 25,
- 0, 318, 329, 119, 8, 25, 0, 318, 279, 25,
- 0, 318, 279, 26, 303, 25, 0, 319, 303, 23,
- 0, 319, 23, 0, 320, 307, 0, 24, 269, 26,
- 287, 25, 0, 24, 25, 0, 269, 0, 269, 26,
- 287, 0, 22, 23, 0, 22, 289, 23, 0, 269,
- 0, 269, 26, 289, 0, 22, 269, 26, 269, 32,
- 302, 23, 0, 22, 269, 32, 302, 23, 0, 22,
- 269, 29, 292, 23, 0, 293, 0, 292, 26, 293,
- 0, 0, 0, 294, 269, 295, 296, 0, 34, 269,
- 0, 0, 298, 0, 297, 21, 298, 0, 0, 304,
- 299, 300, 0, 0, 301, 266, 0, 28, 269, 266,
- 0, 267, 28, 269, 301, 0, 267, 28, 269, 0,
- 0, 269, 0, 304, 26, 303, 0, 304, 0, 305,
- 0, 304, 325, 305, 0, 308, 0, 306, 0, 7,
- 8, 0, 7, 9, 0, 331, 0, 306, 307, 0,
- 331, 0, 308, 0, 329, 0, 329, 36, 307, 0,
- 309, 0, 35, 0, 24, 25, 0, 24, 329, 119,
- 8, 25, 0, 24, 304, 25, 0, 24, 304, 26,
- 303, 25, 0, 22, 303, 23, 0, 22, 23, 0,
- 37, 307, 0, 8, 0, 9, 0, 10, 0, 11,
- 0, 12, 0, 13, 0, 14, 0, 15, 0, 16,
- 0, 17, 0, 17, 78, 4, 0, 109, 8, 0,
- 110, 8, 8, 0, 111, 11, 0, 53, 0, 45,
- 0, 44, 0, 47, 0, 48, 0, 46, 0, 7,
- 0, 52, 0, 24, 0, 22, 0, 37, 0, 325,
- 0, 324, 0, 325, 0, 323, 0, 326, 0, 27,
- 3, 27, 0, 5, 0, 328, 0, 27, 3, 27,
- 0, 6, 0, 27, 4, 27, 0, 5, 0, 328,
- 0, 327, 0, 7, 0, 119, 0, 3, 0, 24,
- 326, 25, 0, 3, 0, 318, 326, 25, 0, 338,
- 0, 24, 6, 25, 0, 338, 0, 318, 6, 25,
- 0, 3, 0, 4, 0, 246, 26, 246, 0, 246,
- 26, 334, 0, 336, 0, 335, 336, 0, 3, 0,
- 338, 0, 4, 0, 4, 0, 342, 18, 0, 342,
- 0, 0, 19, 0, 0, 345, 346, 0, 20, 0,
- 1, 0
+ 134, 26, 135, 0, 22, 154, 23, 0, 68, 72,
+ 69, 0, 0, 68, 150, 69, 0, 0, 68, 142,
+ 142, 69, 0, 0, 68, 140, 142, 69, 0, 68,
+ 140, 142, 156, 69, 0, 0, 74, 335, 0, 0,
+ 68, 142, 69, 0, 0, 71, 0, 143, 144, 145,
+ 146, 148, 151, 0, 70, 0, 75, 8, 0, 70,
+ 0, 76, 8, 0, 70, 0, 81, 0, 70, 0,
+ 77, 89, 0, 77, 11, 147, 0, 18, 142, 19,
+ 0, 0, 70, 0, 80, 326, 0, 79, 149, 158,
+ 0, 107, 0, 108, 8, 8, 4, 8, 0, 142,
+ 0, 150, 26, 142, 0, 70, 0, 73, 152, 0,
+ 153, 0, 152, 26, 153, 0, 22, 154, 23, 8,
+ 147, 0, 155, 0, 154, 26, 155, 0, 70, 0,
+ 239, 0, 157, 0, 156, 26, 157, 0, 325, 30,
+ 18, 142, 19, 0, 325, 30, 142, 0, 38, 172,
+ 28, 158, 0, 88, 177, 28, 158, 0, 89, 327,
+ 179, 174, 0, 89, 106, 335, 327, 179, 174, 0,
+ 90, 171, 179, 174, 0, 91, 158, 174, 0, 92,
+ 158, 18, 181, 19, 0, 42, 158, 43, 18, 159,
+ 19, 0, 39, 18, 173, 30, 158, 19, 40, 158,
+ 0, 98, 18, 165, 19, 40, 158, 0, 60, 18,
+ 167, 19, 158, 0, 305, 0, 170, 0, 95, 160,
+ 164, 0, 96, 162, 164, 0, 0, 160, 161, 0,
+ 170, 172, 28, 158, 21, 0, 0, 162, 163, 0,
+ 305, 28, 158, 21, 0, 97, 0, 173, 28, 158,
+ 0, 166, 0, 165, 21, 166, 0, 173, 30, 158,
+ 0, 112, 169, 0, 113, 11, 11, 169, 0, 114,
+ 11, 11, 11, 169, 168, 0, 115, 170, 11, 11,
+ 169, 168, 0, 116, 170, 11, 11, 169, 168, 0,
+ 70, 0, 117, 0, 70, 0, 118, 0, 99, 334,
+ 334, 0, 100, 334, 325, 0, 101, 334, 325, 0,
+ 102, 334, 24, 181, 25, 0, 103, 334, 325, 24,
+ 181, 25, 0, 104, 170, 22, 182, 23, 0, 105,
+ 170, 0, 106, 335, 325, 0, 106, 335, 327, 0,
+ 325, 0, 327, 0, 24, 56, 329, 18, 179, 181,
+ 19, 25, 0, 24, 57, 329, 18, 179, 181, 19,
+ 25, 0, 24, 58, 305, 18, 179, 181, 19, 25,
+ 0, 24, 59, 305, 18, 179, 181, 19, 25, 0,
+ 3, 0, 0, 172, 173, 0, 24, 3, 33, 181,
+ 25, 0, 22, 23, 0, 22, 175, 23, 0, 176,
+ 0, 175, 26, 176, 0, 305, 0, 170, 0, 3,
+ 0, 177, 3, 0, 94, 0, 178, 26, 94, 0,
+ 22, 23, 0, 22, 180, 23, 0, 181, 0, 180,
+ 26, 181, 0, 239, 0, 183, 0, 182, 26, 183,
+ 0, 70, 0, 181, 0, 0, 185, 193, 0, 0,
+ 187, 193, 0, 0, 189, 21, 0, 190, 0, 189,
+ 21, 190, 0, 0, 53, 335, 191, 192, 0, 193,
+ 129, 0, 193, 129, 64, 194, 0, 200, 67, 0,
+ 24, 195, 25, 0, 196, 0, 195, 26, 196, 0,
+ 325, 66, 325, 0, 327, 66, 327, 0, 0, 198,
+ 21, 0, 199, 0, 198, 21, 199, 0, 306, 335,
+ 24, 130, 25, 0, 306, 335, 24, 130, 25, 64,
+ 194, 0, 0, 54, 335, 201, 41, 202, 0, 336,
+ 197, 203, 230, 339, 0, 336, 198, 339, 0, 337,
+ 197, 203, 230, 340, 0, 337, 198, 340, 0, 0,
+ 204, 21, 0, 205, 0, 204, 21, 205, 0, 0,
+ 50, 8, 206, 212, 0, 0, 51, 8, 207, 212,
+ 0, 0, 49, 8, 208, 212, 0, 0, 50, 209,
+ 212, 0, 0, 51, 210, 212, 0, 0, 49, 211,
+ 212, 0, 318, 0, 212, 26, 318, 0, 214, 0,
+ 213, 21, 214, 0, 215, 0, 216, 0, 217, 0,
+ 219, 0, 223, 0, 226, 0, 308, 245, 30, 239,
+ 0, 307, 250, 31, 245, 30, 246, 0, 307, 245,
+ 30, 246, 0, 307, 250, 31, 245, 30, 246, 65,
+ 248, 0, 307, 245, 30, 246, 65, 248, 0, 311,
+ 250, 31, 237, 218, 0, 311, 237, 218, 0, 0,
+ 41, 336, 225, 339, 0, 41, 337, 225, 340, 0,
+ 309, 250, 31, 333, 221, 220, 0, 309, 333, 222,
+ 220, 0, 0, 41, 336, 252, 339, 0, 41, 337,
+ 252, 340, 0, 334, 0, 24, 334, 331, 25, 0,
+ 24, 332, 26, 330, 25, 0, 24, 25, 0, 22,
+ 332, 23, 0, 24, 332, 28, 332, 25, 0, 334,
+ 0, 24, 334, 241, 25, 0, 24, 239, 26, 238,
+ 25, 0, 24, 25, 0, 22, 239, 23, 0, 24,
+ 240, 28, 239, 25, 0, 310, 224, 0, 24, 239,
+ 26, 238, 25, 0, 242, 0, 226, 0, 225, 21,
+ 226, 0, 254, 33, 239, 31, 239, 138, 0, 254,
+ 33, 239, 138, 0, 82, 326, 33, 228, 87, 0,
+ 82, 47, 4, 222, 87, 0, 82, 45, 334, 241,
+ 87, 0, 83, 326, 227, 87, 0, 84, 326, 326,
+ 87, 0, 86, 326, 87, 0, 85, 334, 87, 0,
+ 257, 0, 0, 0, 4, 0, 229, 0, 228, 26,
+ 229, 0, 239, 0, 239, 30, 326, 0, 231, 0,
+ 230, 21, 231, 0, 233, 0, 234, 0, 235, 0,
+ 236, 0, 232, 0, 0, 254, 33, 239, 31, 239,
+ 141, 0, 254, 33, 239, 141, 0, 308, 245, 30,
+ 239, 136, 0, 307, 250, 31, 245, 132, 0, 307,
+ 245, 132, 0, 307, 250, 31, 245, 30, 246, 132,
+ 0, 307, 245, 30, 246, 132, 0, 307, 250, 31,
+ 245, 30, 246, 65, 248, 0, 307, 245, 30, 246,
+ 65, 248, 0, 311, 250, 31, 237, 137, 218, 0,
+ 311, 237, 137, 218, 0, 309, 250, 31, 333, 222,
+ 139, 0, 309, 333, 222, 139, 0, 334, 332, 0,
+ 239, 0, 238, 26, 239, 0, 240, 0, 240, 28,
+ 239, 0, 93, 178, 31, 239, 0, 243, 0, 334,
+ 241, 0, 241, 243, 0, 243, 0, 244, 0, 240,
+ 28, 239, 0, 334, 241, 0, 244, 0, 24, 239,
+ 26, 238, 25, 0, 332, 0, 334, 0, 24, 25,
+ 0, 24, 239, 25, 0, 22, 239, 23, 0, 18,
+ 18, 4, 239, 19, 19, 0, 94, 0, 334, 0,
+ 334, 331, 0, 247, 0, 246, 29, 247, 0, 334,
+ 241, 0, 24, 6, 25, 241, 0, 334, 0, 24,
+ 6, 25, 0, 240, 321, 240, 0, 24, 249, 25,
+ 0, 24, 25, 0, 333, 0, 333, 0, 249, 26,
+ 333, 0, 24, 251, 25, 0, 237, 0, 237, 0,
+ 251, 26, 237, 0, 0, 253, 0, 252, 21, 253,
+ 0, 82, 326, 33, 228, 87, 0, 83, 326, 227,
+ 87, 0, 84, 326, 326, 87, 0, 257, 0, 326,
+ 26, 255, 0, 326, 0, 325, 0, 255, 26, 325,
+ 0, 327, 0, 256, 26, 327, 0, 0, 274, 258,
+ 259, 0, 260, 262, 0, 261, 0, 30, 265, 0,
+ 263, 30, 265, 0, 263, 30, 265, 261, 0, 41,
+ 336, 225, 339, 0, 41, 337, 225, 340, 0, 0,
+ 29, 266, 0, 303, 264, 0, 303, 0, 266, 33,
+ 239, 31, 239, 0, 266, 33, 239, 0, 266, 0,
+ 267, 0, 266, 318, 266, 0, 7, 268, 0, 268,
+ 0, 0, 0, 38, 269, 264, 270, 28, 265, 0,
+ 39, 336, 225, 339, 40, 265, 0, 39, 337, 225,
+ 340, 40, 265, 0, 61, 265, 62, 265, 63, 265,
+ 0, 42, 265, 43, 336, 293, 339, 0, 42, 265,
+ 43, 337, 293, 340, 0, 56, 329, 272, 0, 56,
+ 329, 0, 57, 329, 272, 0, 57, 329, 0, 58,
+ 17, 272, 0, 58, 17, 0, 59, 17, 272, 0,
+ 59, 17, 0, 60, 11, 265, 0, 271, 0, 271,
+ 273, 0, 273, 0, 272, 273, 0, 273, 0, 325,
+ 0, 327, 0, 305, 0, 24, 265, 25, 0, 24,
+ 266, 318, 25, 0, 24, 317, 266, 25, 0, 282,
+ 0, 284, 0, 286, 0, 287, 0, 325, 36, 273,
+ 0, 35, 0, 37, 273, 0, 278, 0, 274, 318,
+ 275, 0, 276, 0, 275, 318, 275, 0, 7, 277,
+ 0, 277, 0, 277, 280, 0, 280, 0, 312, 277,
+ 0, 279, 0, 279, 280, 0, 281, 0, 327, 0,
+ 325, 0, 325, 36, 303, 0, 305, 0, 35, 0,
+ 24, 25, 0, 24, 325, 119, 8, 25, 0, 24,
+ 275, 25, 0, 24, 275, 26, 299, 25, 0, 22,
+ 299, 23, 0, 22, 23, 0, 37, 303, 0, 328,
+ 0, 326, 0, 326, 36, 303, 0, 305, 0, 35,
+ 0, 314, 25, 0, 314, 325, 119, 8, 25, 0,
+ 314, 275, 25, 0, 314, 275, 26, 299, 25, 0,
+ 315, 299, 23, 0, 315, 23, 0, 316, 303, 0,
+ 24, 265, 26, 283, 25, 0, 24, 25, 0, 265,
+ 0, 265, 26, 283, 0, 22, 23, 0, 22, 285,
+ 23, 0, 265, 0, 265, 26, 285, 0, 22, 265,
+ 26, 265, 32, 298, 23, 0, 22, 265, 32, 298,
+ 23, 0, 22, 265, 29, 288, 23, 0, 289, 0,
+ 288, 26, 289, 0, 0, 0, 290, 265, 291, 292,
+ 0, 34, 265, 0, 0, 294, 0, 293, 21, 294,
+ 0, 0, 300, 295, 296, 0, 0, 297, 262, 0,
+ 28, 265, 262, 0, 263, 28, 265, 297, 0, 263,
+ 28, 265, 0, 0, 265, 0, 300, 26, 299, 0,
+ 300, 0, 301, 0, 300, 321, 301, 0, 304, 0,
+ 302, 0, 7, 8, 0, 7, 9, 0, 327, 0,
+ 302, 303, 0, 327, 0, 304, 0, 325, 0, 325,
+ 36, 303, 0, 305, 0, 35, 0, 24, 25, 0,
+ 24, 325, 119, 8, 25, 0, 24, 300, 25, 0,
+ 24, 300, 26, 299, 25, 0, 22, 299, 23, 0,
+ 22, 23, 0, 37, 303, 0, 8, 0, 9, 0,
+ 10, 0, 11, 0, 12, 0, 13, 0, 14, 0,
+ 15, 0, 16, 0, 17, 0, 17, 78, 4, 0,
+ 109, 8, 0, 110, 8, 8, 0, 111, 11, 0,
+ 53, 0, 45, 0, 44, 0, 47, 0, 48, 0,
+ 46, 0, 7, 0, 52, 0, 24, 0, 22, 0,
+ 37, 0, 321, 0, 320, 0, 321, 0, 319, 0,
+ 322, 0, 27, 3, 27, 0, 5, 0, 324, 0,
+ 27, 3, 27, 0, 6, 0, 27, 4, 27, 0,
+ 5, 0, 324, 0, 323, 0, 7, 0, 119, 0,
+ 3, 0, 24, 322, 25, 0, 3, 0, 314, 322,
+ 25, 0, 334, 0, 24, 6, 25, 0, 334, 0,
+ 314, 6, 25, 0, 3, 0, 4, 0, 332, 0,
+ 330, 26, 332, 0, 332, 0, 331, 332, 0, 3,
+ 0, 334, 0, 4, 0, 4, 0, 338, 18, 0,
+ 338, 0, 0, 19, 0, 0, 341, 342, 0, 20,
+ 0, 1, 0
};
#endif
#if YYDEBUG != 0
static const short yyrline[] = { 0,
- 331, 334, 336, 337, 339, 342, 346, 351, 355, 361,
- 365, 372, 373, 376, 378, 381, 383, 384, 385, 389,
- 393, 397, 404, 405, 406, 409, 410, 413, 415, 418,
- 420, 421, 422, 426, 430, 438, 441, 443, 446, 449,
- 452, 454, 458, 462, 464, 467, 469, 472, 475, 479,
- 483, 486, 489, 493, 496, 500, 503, 506, 510, 513,
- 517, 519, 522, 524, 527, 529, 532, 534, 537, 541,
- 543, 545, 547, 549, 553, 556, 560, 562, 565, 567,
- 570, 572, 575, 580, 582, 585, 590, 592, 595, 597,
- 600, 602, 605, 607, 610, 619, 622, 624, 626, 628,
- 630, 632, 634, 636, 638, 640, 642, 643, 646, 649,
- 653, 655, 658, 663, 665, 668, 672, 674, 677, 679,
- 682, 686, 688, 689, 691, 693, 696, 697, 699, 700,
- 702, 704, 705, 706, 708, 710, 712, 713, 714, 715,
- 716, 719, 722, 724, 726, 728, 731, 733, 736, 739,
- 741, 744, 746, 749, 751, 754, 756, 759, 761, 764,
- 766, 769, 771, 774, 794, 796, 799, 801, 806, 821,
- 828, 842, 849, 850, 853, 854, 857, 879, 885, 889,
- 893, 901, 904, 906, 909, 910, 913, 914, 917, 918,
- 921, 923, 928, 933, 946, 950, 954, 958, 964, 965,
- 969, 970, 973, 976, 976, 979, 979, 982, 982, 985,
- 985, 988, 988, 991, 993, 994, 997, 998, 1017, 1018,
- 1019, 1020, 1021, 1022, 1025, 1029, 1031, 1033, 1035, 1039,
- 1040, 1043, 1044, 1045, 1048, 1049, 1052, 1053, 1054, 1057,
- 1058, 1060, 1061, 1062, 1063, 1066, 1069, 1070, 1077, 1078,
- 1107, 1112, 1125, 1131, 1137, 1143, 1149, 1155, 1161, 1169,
- 1170, 1173, 1175, 1177, 1179, 1182, 1184, 1186, 1187, 1190,
- 1191, 1192, 1193, 1194, 1195, 1199, 1201, 1205, 1209, 1211,
- 1213, 1215, 1217, 1219, 1223, 1225, 1229, 1231, 1238, 1242,
- 1243, 1246, 1247, 1249, 1252, 1253, 1256, 1257, 1261, 1262,
- 1263, 1266, 1267, 1270, 1271, 1272, 1273, 1274, 1276, 1278,
- 1282, 1283, 1287, 1293, 1294, 1298, 1299, 1300, 1301, 1302,
- 1305, 1306, 1307, 1310, 1311, 1314, 1315, 1318, 1319, 1322,
- 1323, 1324, 1337, 1344, 1350, 1354, 1355, 1359, 1360, 1363,
- 1364, 1368, 1394, 1408, 1411, 1412, 1415, 1416, 1419, 1421,
- 1422, 1425, 1429, 1430, 1439, 1440, 1441, 1450, 1451, 1461,
- 1462, 1469, 1477, 1480, 1486, 1487, 1490, 1493, 1494, 1497,
- 1498, 1499, 1500, 1501, 1502, 1503, 1504, 1507, 1518, 1523,
- 1524, 1527, 1528, 1538, 1539, 1540, 1541, 1542, 1543, 1546,
- 1547, 1548, 1549, 1552, 1553, 1554, 1567, 1568, 1582, 1583,
- 1603, 1604, 1608, 1609, 1612, 1613, 1617, 1618, 1621, 1622,
- 1623, 1624, 1625, 1626, 1627, 1631, 1632, 1633, 1634, 1635,
- 1638, 1639, 1640, 1641, 1642, 1643, 1644, 1648, 1649, 1650,
- 1651, 1652, 1656, 1662, 1671, 1672, 1682, 1683, 1686, 1688,
- 1703, 1704, 1707, 1710, 1711, 1714, 1714, 1715, 1735, 1736,
- 1739, 1740, 1743, 1746, 1749, 1752, 1753, 1756, 1757, 1760,
- 1761, 1764, 1765, 1769, 1770, 1773, 1774, 1775, 1776, 1779,
- 1780, 1783, 1784, 1787, 1788, 1789, 1790, 1791, 1792, 1796,
- 1797, 1798, 1799, 1800, 1803, 1805, 1806, 1807, 1808, 1809,
- 1810, 1811, 1812, 1813, 1814, 1815, 1816, 1817, 1823, 1826,
- 1836, 1846, 1857, 1860, 1870, 1873, 1883, 1886, 1889, 1895,
- 1896, 1899, 1900, 1903, 1904, 1908, 1909, 1910, 1913, 1914,
- 1917, 1918, 1919, 1922, 1925, 1928, 1929, 1932, 1933, 1937,
- 1938, 1941, 1942, 1945, 1946, 1950, 1951, 1955, 1956, 1959,
- 1962, 1968, 1971, 1975, 1977, 1980, 1983, 1991, 1991, 1994,
- 2000
+ 329, 332, 334, 335, 337, 340, 344, 349, 353, 359,
+ 363, 370, 371, 374, 376, 379, 381, 382, 383, 387,
+ 391, 395, 402, 403, 404, 407, 408, 411, 413, 416,
+ 418, 419, 420, 424, 428, 436, 439, 441, 444, 447,
+ 450, 452, 456, 460, 462, 465, 467, 470, 473, 477,
+ 481, 484, 488, 491, 495, 498, 502, 505, 509, 511,
+ 514, 516, 519, 521, 524, 526, 529, 533, 535, 537,
+ 539, 541, 545, 548, 552, 554, 557, 559, 562, 564,
+ 567, 572, 574, 577, 579, 582, 584, 587, 598, 608,
+ 611, 613, 615, 617, 619, 621, 623, 625, 627, 629,
+ 631, 632, 635, 638, 642, 644, 647, 652, 654, 657,
+ 661, 663, 666, 668, 671, 675, 677, 678, 680, 682,
+ 685, 686, 688, 689, 691, 693, 694, 695, 697, 699,
+ 701, 702, 703, 704, 705, 708, 711, 713, 715, 717,
+ 720, 722, 725, 728, 730, 733, 735, 738, 740, 743,
+ 745, 748, 750, 753, 755, 758, 760, 763, 783, 785,
+ 788, 790, 795, 810, 817, 831, 838, 839, 842, 843,
+ 846, 868, 874, 878, 882, 890, 893, 895, 898, 899,
+ 902, 903, 906, 907, 910, 912, 917, 922, 935, 939,
+ 943, 947, 953, 954, 958, 959, 962, 965, 965, 968,
+ 968, 971, 971, 974, 974, 977, 977, 980, 982, 983,
+ 986, 987, 1006, 1007, 1008, 1009, 1010, 1011, 1014, 1018,
+ 1020, 1022, 1024, 1028, 1029, 1032, 1033, 1034, 1037, 1038,
+ 1041, 1042, 1043, 1046, 1047, 1048, 1049, 1050, 1051, 1054,
+ 1055, 1056, 1057, 1058, 1059, 1062, 1065, 1066, 1073, 1074,
+ 1103, 1108, 1121, 1127, 1133, 1139, 1145, 1151, 1157, 1165,
+ 1166, 1169, 1171, 1173, 1175, 1178, 1180, 1182, 1183, 1186,
+ 1187, 1188, 1189, 1190, 1191, 1195, 1197, 1201, 1205, 1207,
+ 1209, 1211, 1213, 1215, 1219, 1221, 1225, 1227, 1234, 1238,
+ 1239, 1242, 1243, 1245, 1248, 1249, 1252, 1253, 1257, 1258,
+ 1259, 1262, 1263, 1266, 1267, 1268, 1269, 1270, 1272, 1274,
+ 1278, 1279, 1282, 1283, 1287, 1288, 1289, 1290, 1291, 1294,
+ 1295, 1296, 1299, 1300, 1303, 1304, 1307, 1308, 1311, 1312,
+ 1313, 1326, 1333, 1339, 1345, 1349, 1350, 1353, 1354, 1357,
+ 1358, 1362, 1388, 1402, 1405, 1406, 1409, 1410, 1413, 1415,
+ 1416, 1419, 1423, 1424, 1434, 1435, 1436, 1445, 1446, 1456,
+ 1457, 1464, 1472, 1475, 1481, 1482, 1485, 1488, 1489, 1492,
+ 1493, 1494, 1495, 1496, 1497, 1498, 1499, 1502, 1513, 1518,
+ 1519, 1522, 1523, 1533, 1534, 1535, 1536, 1537, 1538, 1541,
+ 1542, 1543, 1544, 1547, 1548, 1549, 1562, 1563, 1577, 1578,
+ 1598, 1599, 1603, 1604, 1607, 1608, 1612, 1613, 1616, 1617,
+ 1618, 1619, 1620, 1621, 1622, 1626, 1627, 1628, 1629, 1630,
+ 1633, 1634, 1635, 1636, 1637, 1638, 1639, 1643, 1644, 1645,
+ 1646, 1647, 1651, 1657, 1666, 1667, 1677, 1678, 1681, 1683,
+ 1698, 1699, 1702, 1705, 1706, 1709, 1709, 1710, 1730, 1731,
+ 1734, 1735, 1738, 1741, 1744, 1747, 1748, 1751, 1752, 1755,
+ 1756, 1759, 1760, 1764, 1765, 1768, 1769, 1770, 1771, 1774,
+ 1775, 1778, 1779, 1782, 1783, 1784, 1785, 1786, 1787, 1791,
+ 1792, 1793, 1794, 1795, 1798, 1800, 1801, 1802, 1803, 1804,
+ 1805, 1806, 1807, 1808, 1809, 1810, 1811, 1812, 1818, 1821,
+ 1831, 1841, 1852, 1855, 1865, 1868, 1878, 1881, 1884, 1890,
+ 1891, 1894, 1895, 1898, 1899, 1903, 1904, 1905, 1908, 1909,
+ 1912, 1913, 1914, 1917, 1920, 1923, 1924, 1927, 1928, 1932,
+ 1933, 1936, 1937, 1940, 1941, 1944, 1945, 1948, 1949, 1952,
+ 1955, 1961, 1964, 1968, 1970, 1973, 1976, 1984, 1984, 1987,
+ 1993
};
static const char * const yytname[] = { "$","error","$undefined.","VARID",
"CO_CAF_CC","CO_DUPD_CC","PLUS","pmodule","module","@1","@2","body","maybeexports",
"export_list","export","impspec","maybeimpspec","import_list","import","idata_pragma",
"idata_pragma_specs","idata_pragma_specslist","idata_pragma_spectypes","itype_pragma",
-"iclas_pragma","iclasop_pragma","iinst_pragma","modname_pragma","restof_iinst_spec",
-"ival_pragma","gen_pragma","arity_pragma","update_pragma","deforest_pragma",
-"strictness_pragma","worker_info","unfolding_pragma","unfolding_guidance","gen_pragma_list",
-"type_pragma_pairs_maybe","type_pragma_pairs","type_pragma_pair","type_instpragma_pairs",
-"type_instpragma_pair","type_maybes","type_maybe","maybe_name_pragma_pairs",
-"name_pragma_pairs","name_pragma_pair","core_expr","core_case_alts","core_alg_alts",
-"core_alg_alt","core_prim_alts","core_prim_alt","core_default","corec_binds",
-"corec_bind","co_scc","co_caf","co_dupd","core_id","co_primop","core_binders",
-"core_binder","core_atoms","core_atom_list","core_atom","core_tyvars","core_tv_templates",
-"core_types","core_type_list","core_type","core_type_maybes","core_type_maybe",
-"readpreludecore","@3","readprelude","@4","maybeimpdecls","impdecls","impdecl",
-"@5","impdecl_rest","readinterface","renamings","renaming_list","renaming","maybeiimports",
-"iimports","iimport","interface","@6","ibody","maybefixes","fixes","fix","@7",
-"@8","@9","@10","@11","@12","ops","topdecls","topdecl","typed","datad","classd",
-"cbody","instd","rinst","inst","defaultd","dtypes","decls","decl","howto_inline_maybe",
-"types_and_maybe_ids","type_and_maybe_id","itopdecls","itopdecl","ivarsd","ityped",
-"idatad","iclassd","iinstd","class","types","type","btype","atypes","ttype",
-"atype","ntatype","simple","simple_long","constrs","constr","tyclses","tycls_list",
+"iclas_pragma","iclasop_pragma","iinst_pragma","modname_pragma","ival_pragma",
+"gen_pragma","arity_pragma","update_pragma","deforest_pragma","strictness_pragma",
+"worker_info","unfolding_pragma","unfolding_guidance","gen_pragma_list","type_pragma_pairs_maybe",
+"type_pragma_pairs","type_pragma_pair","type_maybes","type_maybe","name_pragma_pairs",
+"name_pragma_pair","core_expr","core_case_alts","core_alg_alts","core_alg_alt",
+"core_prim_alts","core_prim_alt","core_default","corec_binds","corec_bind","co_scc",
+"co_caf","co_dupd","core_id","co_primop","core_binders","core_binder","core_atoms",
+"core_atom_list","core_atom","core_tyvars","core_tv_templates","core_types",
+"core_type_list","core_type","core_type_maybes","core_type_maybe","readpreludecore",
+"@3","readprelude","@4","maybeimpdecls","impdecls","impdecl","@5","impdecl_rest",
+"readinterface","renamings","renaming_list","renaming","maybeiimports","iimports",
+"iimport","interface","@6","ibody","maybefixes","fixes","fix","@7","@8","@9",
+"@10","@11","@12","ops","topdecls","topdecl","typed","datad","classd","cbody",
+"instd","rinst","restrict_inst","general_inst","defaultd","dtypes","decls","decl",
+"howto_inline_maybe","types_and_maybe_ids","type_and_maybe_id","itopdecls","itopdecl",
+"ivarsd","ityped","idatad","iclassd","iinstd","class","types","type","btype",
+"atypes","ttype","atype","ntatype","simple","constrs","constr","tyclses","tycls_list",
"context","context_list","instdefs","instdef","vars","varsrest","cons","valdef",
"@13","valrhs","valrhs1","gdrhs","maybe_where","gd","lampats","exp","oexp","dexp",
"kexp","@14","@15","fexp","cexp","aexp","opatk","opat","dpat","fpat","dpatk",
"pats","pat","bpat","conpat","apat","apatc","lit_constant","importkey","datakey",
"typekey","instkey","defaultkey","classkey","minuskey","modulekey","oparenkey",
"obrackkey","lazykey","op1","op","varop","varop1","conop","varsym","minus","plus",
-"var","vark","con","conk","ccallid","atype_list","tyvars","tyvar","tycls","tycon",
+"var","vark","con","conk","ccallid","tyvar_list","tyvars","tyvar","tycls","tycon",
"modid","ocurly","vocurly","layout","ccurly","vccurly","@19","vccurly1",""
};
#endif
127, 127, 128, 128, 128, 129, 129, 130, 130, 131,
131, 131, 131, 131, 131, 132, 132, 132, 133, 133,
134, 134, 135, 136, 136, 137, 137, 138, 138, 139,
- 139, 139, 139, 140, 140, 141, 142, 142, 143, 143,
- 144, 144, 145, 145, 146, 146, 147, 147, 147, 148,
- 148, 149, 149, 149, 150, 150, 151, 151, 152, 152,
- 153, 153, 154, 155, 155, 156, 157, 157, 158, 158,
- 159, 159, 160, 160, 161, 162, 162, 162, 162, 162,
- 162, 162, 162, 162, 162, 162, 162, 162, 163, 163,
- 164, 164, 165, 166, 166, 167, 168, 168, 169, 169,
- 170, 171, 171, 171, 171, 171, 172, 172, 173, 173,
- 174, 174, 174, 174, 174, 174, 174, 174, 174, 174,
- 174, 175, 175, 175, 175, 175, 176, 176, 177, 178,
- 178, 179, 179, 180, 180, 181, 181, 182, 182, 183,
- 183, 184, 184, 185, 186, 186, 187, 187, 189, 188,
- 191, 190, 192, 192, 193, 193, 195, 194, 196, 196,
- 197, 198, 199, 199, 200, 200, 201, 201, 202, 202,
- 203, 203, 205, 204, 206, 206, 206, 206, 207, 207,
- 208, 208, 210, 209, 211, 209, 212, 209, 213, 209,
- 214, 209, 215, 209, 216, 216, 217, 217, 218, 218,
- 218, 218, 218, 218, 219, 220, 220, 220, 220, 221,
- 221, 222, 222, 222, 223, 223, 224, 224, 224, 225,
- 225, 225, 225, 225, 225, 226, 227, 227, 228, 228,
- 229, 229, 229, 229, 229, 229, 229, 229, 229, 229,
- 229, 230, 230, 231, 231, 232, 232, 233, 233, 234,
- 234, 234, 234, 234, 234, 235, 235, 236, 237, 237,
- 237, 237, 237, 237, 238, 238, 239, 239, 240, 241,
- 241, 242, 242, 242, 243, 243, 244, 244, 245, 245,
- 245, 246, 246, 247, 247, 247, 247, 247, 247, 247,
- 248, 248, 249, 250, 250, 251, 251, 251, 251, 251,
- 252, 252, 252, 253, 253, 254, 254, 255, 255, 256,
- 256, 256, 257, 257, 257, 258, 258, 259, 259, 260,
- 260, 262, 261, 263, 264, 264, 265, 265, 266, 266,
- 266, 267, 268, 268, 269, 269, 269, 270, 270, 271,
- 271, 273, 274, 272, 272, 272, 272, 272, 272, 272,
- 272, 272, 272, 272, 272, 272, 272, 272, 272, 275,
- 275, 276, 276, 277, 277, 277, 277, 277, 277, 277,
- 277, 277, 277, 277, 277, 277, 278, 278, 279, 279,
- 280, 280, 281, 281, 282, 282, 283, 283, 284, 284,
- 284, 284, 284, 284, 284, 284, 284, 284, 284, 284,
- 285, 285, 285, 285, 285, 285, 285, 285, 285, 285,
- 285, 285, 286, 286, 287, 287, 288, 288, 289, 289,
- 290, 290, 291, 292, 292, 294, 295, 293, 296, 296,
- 297, 297, 299, 298, 298, 300, 300, 301, 301, 302,
- 302, 303, 303, 304, 304, 305, 305, 305, 305, 306,
- 306, 307, 307, 308, 308, 308, 308, 308, 308, 308,
- 308, 308, 308, 308, 309, 309, 309, 309, 309, 309,
- 309, 309, 309, 309, 309, 309, 309, 309, 310, 311,
- 312, 313, 314, 315, 316, 317, 318, 319, 320, 321,
- 321, 322, 322, 323, 323, 324, 324, 324, 325, 325,
- 326, 326, 326, 327, 328, 329, 329, 330, 330, 331,
- 331, 332, 332, 333, 333, 334, 334, 335, 335, 336,
- 337, 338, 339, 340, 341, 342, 343, 345, 344, 346,
- 346
+ 139, 139, 140, 140, 141, 141, 142, 142, 143, 143,
+ 144, 144, 145, 145, 146, 146, 146, 147, 147, 148,
+ 148, 148, 149, 149, 150, 150, 151, 151, 152, 152,
+ 153, 154, 154, 155, 155, 156, 156, 157, 157, 158,
+ 158, 158, 158, 158, 158, 158, 158, 158, 158, 158,
+ 158, 158, 159, 159, 160, 160, 161, 162, 162, 163,
+ 164, 164, 165, 165, 166, 167, 167, 167, 167, 167,
+ 168, 168, 169, 169, 170, 170, 170, 170, 170, 170,
+ 170, 170, 170, 170, 170, 171, 171, 171, 171, 171,
+ 172, 172, 173, 174, 174, 175, 175, 176, 176, 177,
+ 177, 178, 178, 179, 179, 180, 180, 181, 182, 182,
+ 183, 183, 185, 184, 187, 186, 188, 188, 189, 189,
+ 191, 190, 192, 192, 193, 194, 195, 195, 196, 196,
+ 197, 197, 198, 198, 199, 199, 201, 200, 202, 202,
+ 202, 202, 203, 203, 204, 204, 206, 205, 207, 205,
+ 208, 205, 209, 205, 210, 205, 211, 205, 212, 212,
+ 213, 213, 214, 214, 214, 214, 214, 214, 215, 216,
+ 216, 216, 216, 217, 217, 218, 218, 218, 219, 219,
+ 220, 220, 220, 221, 221, 221, 221, 221, 221, 222,
+ 222, 222, 222, 222, 222, 223, 224, 224, 225, 225,
+ 226, 226, 226, 226, 226, 226, 226, 226, 226, 226,
+ 226, 227, 227, 228, 228, 229, 229, 230, 230, 231,
+ 231, 231, 231, 231, 231, 232, 232, 233, 234, 234,
+ 234, 234, 234, 234, 235, 235, 236, 236, 237, 238,
+ 238, 239, 239, 239, 240, 240, 241, 241, 242, 242,
+ 242, 243, 243, 244, 244, 244, 244, 244, 244, 244,
+ 245, 245, 246, 246, 247, 247, 247, 247, 247, 248,
+ 248, 248, 249, 249, 250, 250, 251, 251, 252, 252,
+ 252, 253, 253, 253, 253, 254, 254, 255, 255, 256,
+ 256, 258, 257, 259, 260, 260, 261, 261, 262, 262,
+ 262, 263, 264, 264, 265, 265, 265, 266, 266, 267,
+ 267, 269, 270, 268, 268, 268, 268, 268, 268, 268,
+ 268, 268, 268, 268, 268, 268, 268, 268, 268, 271,
+ 271, 272, 272, 273, 273, 273, 273, 273, 273, 273,
+ 273, 273, 273, 273, 273, 273, 274, 274, 275, 275,
+ 276, 276, 277, 277, 278, 278, 279, 279, 280, 280,
+ 280, 280, 280, 280, 280, 280, 280, 280, 280, 280,
+ 281, 281, 281, 281, 281, 281, 281, 281, 281, 281,
+ 281, 281, 282, 282, 283, 283, 284, 284, 285, 285,
+ 286, 286, 287, 288, 288, 290, 291, 289, 292, 292,
+ 293, 293, 295, 294, 294, 296, 296, 297, 297, 298,
+ 298, 299, 299, 300, 300, 301, 301, 301, 301, 302,
+ 302, 303, 303, 304, 304, 304, 304, 304, 304, 304,
+ 304, 304, 304, 304, 305, 305, 305, 305, 305, 305,
+ 305, 305, 305, 305, 305, 305, 305, 305, 306, 307,
+ 308, 309, 310, 311, 312, 313, 314, 315, 316, 317,
+ 317, 318, 318, 319, 319, 320, 320, 320, 321, 321,
+ 322, 322, 322, 323, 324, 325, 325, 326, 326, 327,
+ 327, 328, 328, 329, 329, 330, 330, 331, 331, 332,
+ 333, 334, 335, 336, 337, 338, 339, 341, 340, 342,
+ 342
};
static const short yyr2[] = { 0,
3, 2, 3, 4, 2, 0, 1, 1, 3, 1,
1, 4, 4, 4, 3, 4, 3, 0, 2, 0,
1, 3, 3, 3, 0, 3, 0, 4, 0, 4,
- 5, 5, 0, 2, 0, 2, 3, 0, 1, 6,
- 1, 2, 1, 2, 1, 1, 1, 2, 3, 3,
- 0, 1, 2, 3, 1, 5, 1, 3, 1, 2,
- 1, 3, 5, 1, 3, 6, 1, 3, 1, 1,
- 0, 1, 1, 3, 3, 4, 4, 4, 6, 4,
- 3, 5, 6, 8, 6, 5, 1, 1, 3, 3,
- 0, 2, 5, 0, 2, 4, 1, 3, 1, 3,
- 3, 2, 4, 6, 6, 6, 1, 1, 1, 1,
- 3, 3, 3, 5, 6, 5, 2, 3, 3, 1,
- 1, 8, 8, 8, 8, 1, 0, 2, 5, 2,
- 3, 1, 3, 1, 1, 1, 2, 1, 3, 2,
- 3, 1, 3, 1, 1, 3, 1, 1, 0, 2,
- 0, 2, 0, 2, 1, 3, 0, 4, 2, 4,
- 2, 3, 1, 3, 3, 3, 0, 2, 1, 3,
- 5, 7, 0, 5, 5, 3, 5, 3, 0, 2,
- 1, 3, 0, 4, 0, 4, 0, 4, 0, 3,
- 0, 3, 0, 3, 1, 3, 1, 3, 1, 1,
- 1, 1, 1, 1, 4, 6, 4, 8, 6, 5,
- 3, 0, 4, 4, 6, 4, 0, 4, 4, 1,
- 3, 3, 2, 3, 5, 2, 5, 1, 1, 3,
+ 5, 0, 2, 0, 3, 0, 1, 6, 1, 2,
+ 1, 2, 1, 1, 1, 2, 3, 3, 0, 1,
+ 2, 3, 1, 5, 1, 3, 1, 2, 1, 3,
+ 5, 1, 3, 1, 1, 1, 3, 5, 3, 4,
+ 4, 4, 6, 4, 3, 5, 6, 8, 6, 5,
+ 1, 1, 3, 3, 0, 2, 5, 0, 2, 4,
+ 1, 3, 1, 3, 3, 2, 4, 6, 6, 6,
+ 1, 1, 1, 1, 3, 3, 3, 5, 6, 5,
+ 2, 3, 3, 1, 1, 8, 8, 8, 8, 1,
+ 0, 2, 5, 2, 3, 1, 3, 1, 1, 1,
+ 2, 1, 3, 2, 3, 1, 3, 1, 1, 3,
+ 1, 1, 0, 2, 0, 2, 0, 2, 1, 3,
+ 0, 4, 2, 4, 2, 3, 1, 3, 3, 3,
+ 0, 2, 1, 3, 5, 7, 0, 5, 5, 3,
+ 5, 3, 0, 2, 1, 3, 0, 4, 0, 4,
+ 0, 4, 0, 3, 0, 3, 0, 3, 1, 3,
+ 1, 3, 1, 1, 1, 1, 1, 1, 4, 6,
+ 4, 8, 6, 5, 3, 0, 4, 4, 6, 4,
+ 0, 4, 4, 1, 4, 5, 2, 3, 5, 1,
+ 4, 5, 2, 3, 5, 2, 5, 1, 1, 3,
6, 4, 5, 5, 5, 4, 4, 3, 3, 1,
0, 0, 1, 1, 3, 1, 3, 1, 3, 1,
1, 1, 1, 1, 0, 6, 4, 5, 5, 3,
7, 5, 8, 6, 6, 4, 6, 4, 2, 1,
3, 1, 3, 4, 1, 2, 2, 1, 1, 3,
2, 1, 5, 1, 1, 2, 3, 3, 6, 1,
- 1, 2, 2, 1, 3, 2, 4, 1, 3, 3,
- 3, 2, 1, 1, 3, 3, 1, 1, 3, 0,
- 1, 3, 4, 4, 1, 3, 1, 1, 3, 1,
+ 1, 2, 1, 3, 2, 4, 1, 3, 3, 3,
+ 2, 1, 1, 3, 3, 1, 1, 3, 0, 1,
+ 3, 5, 4, 4, 1, 3, 1, 1, 3, 1,
3, 0, 3, 2, 1, 2, 3, 4, 4, 4,
0, 2, 2, 1, 5, 3, 1, 1, 3, 2,
1, 0, 0, 6, 6, 6, 6, 6, 6, 3,
1, 1, 1, 1, 1, 1, 1, 1, 1, 1,
1, 1, 1, 1, 3, 1, 1, 3, 1, 3,
1, 1, 1, 1, 1, 1, 3, 1, 3, 1,
- 3, 1, 3, 1, 1, 3, 3, 1, 2, 1,
+ 3, 1, 3, 1, 1, 1, 3, 1, 2, 1,
1, 1, 1, 2, 1, 0, 1, 0, 2, 1,
1
};
-static const short yydefact[] = { 169,
- 171, 0, 4, 0, 0, 170, 0, 506, 1, 546,
- 0, 172, 543, 193, 181, 5, 173, 173, 545, 12,
- 0, 0, 199, 0, 175, 199, 548, 544, 0, 2,
- 546, 177, 547, 213, 209, 211, 261, 0, 201, 11,
- 174, 9, 261, 10, 0, 8, 526, 542, 0, 0,
- 14, 16, 17, 0, 194, 187, 187, 0, 207, 0,
- 203, 0, 205, 0, 528, 505, 485, 486, 487, 488,
+static const short yydefact[] = { 163,
+ 165, 0, 4, 0, 0, 164, 0, 506, 1, 546,
+ 0, 166, 543, 187, 175, 5, 167, 167, 545, 12,
+ 0, 0, 193, 0, 169, 193, 548, 544, 0, 2,
+ 546, 171, 547, 207, 203, 205, 261, 0, 195, 11,
+ 168, 9, 261, 10, 0, 8, 526, 542, 0, 0,
+ 14, 16, 17, 0, 188, 181, 181, 0, 201, 0,
+ 197, 0, 199, 0, 528, 505, 485, 486, 487, 488,
489, 490, 491, 492, 493, 494, 508, 507, 425, 509,
501, 500, 504, 502, 503, 0, 0, 0, 0, 0,
- 0, 0, 0, 0, 217, 219, 220, 221, 222, 223,
- 224, 0, 260, 342, 397, 406, 408, 424, 0, 0,
+ 0, 0, 0, 0, 211, 213, 214, 215, 216, 217,
+ 218, 0, 260, 342, 397, 406, 408, 424, 0, 0,
0, 0, 0, 0, 0, 0, 0, 422, 421, 532,
- 200, 176, 548, 551, 550, 549, 521, 524, 525, 0,
- 523, 522, 13, 0, 0, 22, 546, 499, 199, 0,
- 189, 0, 199, 548, 178, 26, 0, 519, 0, 214,
- 215, 513, 512, 514, 0, 210, 0, 212, 0, 0,
+ 194, 170, 548, 551, 550, 549, 521, 524, 525, 0,
+ 523, 522, 13, 0, 0, 22, 546, 499, 193, 0,
+ 183, 0, 193, 548, 172, 26, 0, 519, 0, 208,
+ 209, 513, 512, 514, 0, 204, 0, 206, 0, 0,
0, 0, 0, 262, 0, 0, 0, 496, 0, 498,
261, 6, 0, 0, 0, 0, 0, 413, 0, 407,
- 412, 410, 409, 530, 0, 327, 0, 0, 311, 0,
+ 412, 410, 409, 530, 0, 326, 0, 0, 311, 0,
311, 0, 0, 541, 540, 0, 0, 0, 310, 246,
- 0, 248, 295, 299, 304, 305, 232, 0, 0, 405,
+ 0, 248, 295, 299, 304, 305, 226, 0, 0, 405,
404, 0, 524, 426, 0, 399, 402, 0, 410, 0,
0, 431, 0, 477, 0, 0, 463, 464, 467, 466,
- 476, 474, 470, 432, 473, 472, 0, 0, 202, 7,
+ 476, 474, 470, 432, 473, 472, 0, 0, 196, 7,
527, 15, 507, 21, 0, 0, 0, 337, 340, 3,
- 275, 188, 196, 0, 275, 198, 0, 0, 27, 179,
- 208, 0, 0, 0, 204, 206, 495, 0, 0, 0,
- 263, 0, 0, 259, 258, 497, 218, 0, 0, 49,
+ 275, 182, 190, 0, 275, 192, 0, 0, 27, 173,
+ 202, 0, 0, 0, 198, 200, 495, 0, 0, 0,
+ 263, 0, 0, 259, 258, 497, 212, 0, 0, 49,
292, 302, 305, 0, 0, 343, 351, 345, 0, 0,
- 398, 419, 0, 0, 414, 0, 410, 420, 0, 328,
+ 398, 419, 0, 0, 414, 0, 410, 420, 0, 327,
0, 0, 0, 312, 538, 0, 538, 0, 0, 0,
- 237, 240, 289, 0, 0, 306, 0, 0, 301, 298,
- 305, 546, 231, 0, 403, 533, 401, 428, 0, 0,
+ 231, 240, 289, 0, 0, 306, 0, 0, 301, 298,
+ 305, 546, 225, 0, 403, 533, 401, 428, 0, 0,
529, 0, 468, 469, 483, 0, 524, 478, 0, 474,
484, 430, 0, 0, 0, 471, 0, 336, 338, 423,
18, 20, 19, 0, 0, 268, 274, 270, 271, 272,
- 273, 0, 0, 0, 0, 0, 190, 0, 548, 25,
- 0, 28, 30, 31, 0, 0, 515, 520, 216, 0,
- 0, 0, 264, 266, 256, 257, 0, 158, 0, 0,
+ 273, 0, 0, 0, 0, 0, 184, 0, 548, 25,
+ 0, 28, 30, 31, 0, 0, 515, 520, 210, 0,
+ 0, 0, 264, 266, 256, 257, 0, 152, 0, 0,
0, 252, 0, 296, 0, 0, 0, 395, 0, 362,
546, 0, 0, 0, 0, 0, 0, 0, 352, 358,
361, 379, 381, 390, 391, 392, 393, 386, 384, 385,
346, 357, 546, 344, 0, 418, 531, 416, 0, 0,
- 411, 326, 0, 0, 0, 227, 314, 318, 0, 539,
- 225, 0, 541, 0, 243, 0, 0, 0, 305, 546,
- 236, 0, 308, 307, 0, 300, 297, 261, 261, 232,
- 0, 400, 0, 482, 480, 0, 0, 462, 465, 475,
- 0, 0, 341, 275, 195, 0, 38, 0, 0, 0,
- 0, 47, 0, 0, 197, 23, 0, 0, 0, 0,
- 180, 255, 254, 0, 253, 0, 0, 0, 0, 49,
- 61, 59, 0, 0, 0, 293, 360, 437, 439, 0,
- 516, 519, 524, 434, 0, 0, 357, 0, 511, 510,
- 517, 396, 0, 261, 261, 0, 534, 535, 371, 373,
- 375, 377, 0, 0, 0, 380, 0, 0, 261, 261,
- 347, 0, 0, 329, 0, 0, 0, 0, 316, 0,
- 237, 244, 0, 0, 241, 242, 313, 330, 330, 0,
- 0, 290, 0, 249, 548, 230, 429, 427, 0, 0,
- 339, 269, 58, 0, 40, 280, 0, 0, 0, 53,
- 0, 232, 0, 191, 29, 35, 0, 0, 0, 24,
- 0, 0, 183, 0, 0, 265, 267, 0, 159, 294,
- 251, 62, 0, 63, 0, 0, 0, 446, 460, 438,
+ 411, 325, 0, 0, 0, 221, 313, 317, 0, 539,
+ 219, 0, 541, 0, 243, 0, 292, 305, 546, 230,
+ 0, 308, 307, 0, 300, 297, 261, 261, 226, 0,
+ 400, 0, 482, 480, 0, 0, 462, 465, 475, 0,
+ 0, 341, 275, 189, 0, 38, 0, 0, 0, 0,
+ 47, 0, 0, 191, 23, 0, 0, 0, 0, 174,
+ 255, 254, 0, 253, 0, 0, 0, 0, 49, 59,
+ 57, 0, 0, 0, 293, 360, 437, 439, 0, 516,
+ 519, 524, 434, 0, 0, 357, 0, 511, 510, 517,
+ 396, 0, 261, 261, 0, 534, 535, 371, 373, 375,
+ 377, 0, 0, 0, 380, 0, 0, 261, 261, 347,
+ 0, 0, 328, 0, 0, 0, 0, 315, 0, 0,
+ 0, 231, 234, 244, 0, 0, 296, 329, 329, 0,
+ 0, 290, 0, 249, 548, 224, 429, 427, 0, 0,
+ 339, 269, 56, 0, 40, 280, 0, 0, 0, 52,
+ 0, 226, 0, 185, 29, 35, 0, 0, 0, 24,
+ 0, 0, 177, 0, 0, 265, 267, 0, 153, 294,
+ 251, 60, 0, 61, 0, 0, 0, 446, 460, 438,
0, 387, 0, 0, 0, 363, 354, 0, 548, 546,
370, 383, 372, 374, 376, 378, 0, 359, 394, 356,
- 0, 548, 348, 417, 415, 319, 320, 315, 0, 229,
- 323, 226, 235, 536, 537, 0, 0, 0, 0, 331,
- 335, 422, 548, 0, 247, 0, 261, 233, 234, 481,
- 479, 0, 0, 277, 38, 0, 0, 40, 38, 45,
- 0, 55, 288, 77, 0, 286, 47, 0, 32, 34,
- 33, 182, 0, 0, 0, 303, 48, 64, 65, 66,
- 0, 439, 440, 0, 444, 0, 461, 0, 518, 435,
- 0, 388, 389, 0, 353, 0, 0, 455, 455, 382,
- 0, 0, 349, 350, 317, 322, 0, 324, 0, 245,
- 262, 0, 0, 238, 239, 309, 291, 250, 58, 0,
- 0, 282, 0, 39, 41, 37, 0, 0, 279, 0,
- 278, 53, 0, 0, 0, 46, 232, 192, 184, 185,
- 186, 67, 0, 0, 0, 460, 443, 446, 447, 442,
- 0, 433, 0, 0, 0, 0, 451, 453, 548, 0,
- 355, 321, 0, 228, 0, 0, 332, 276, 57, 284,
- 89, 0, 87, 90, 0, 36, 38, 0, 287, 54,
- 0, 78, 285, 71, 68, 72, 0, 0, 0, 439,
- 0, 445, 450, 436, 364, 365, 366, 455, 368, 0,
- 369, 367, 325, 333, 334, 43, 0, 42, 0, 281,
- 44, 50, 0, 0, 0, 93, 0, 0, 69, 75,
- 0, 0, 73, 79, 0, 60, 441, 0, 448, 452,
- 0, 0, 454, 351, 88, 283, 0, 56, 84, 52,
- 0, 51, 0, 0, 0, 147, 0, 0, 0, 0,
- 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
- 0, 0, 0, 74, 108, 107, 140, 141, 0, 80,
- 81, 449, 351, 0, 456, 0, 0, 94, 95, 70,
- 0, 0, 0, 0, 0, 156, 0, 0, 0, 146,
- 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
- 0, 137, 0, 0, 0, 457, 459, 0, 85, 0,
- 0, 0, 148, 0, 0, 0, 0, 0, 0, 0,
- 0, 157, 0, 0, 0, 0, 0, 0, 0, 0,
- 0, 0, 101, 0, 0, 119, 0, 131, 132, 133,
- 0, 0, 0, 138, 139, 0, 82, 458, 71, 76,
- 0, 96, 0, 0, 129, 130, 122, 0, 0, 0,
- 0, 0, 97, 0, 160, 0, 162, 164, 98, 0,
- 0, 0, 0, 100, 150, 155, 0, 152, 154, 0,
- 0, 0, 0, 0, 0, 167, 168, 0, 165, 71,
- 91, 0, 0, 111, 114, 0, 0, 0, 0, 0,
- 106, 0, 161, 0, 0, 0, 0, 0, 151, 0,
- 102, 0, 120, 121, 134, 0, 136, 0, 83, 86,
- 92, 0, 0, 0, 0, 103, 123, 0, 0, 0,
- 99, 163, 0, 0, 0, 0, 153, 105, 135, 166,
- 149, 0, 0, 117, 112, 109, 147, 0, 115, 110,
- 0, 0, 0, 0, 0, 0, 0, 0, 104, 0,
- 0, 0, 127, 128, 124, 125, 126, 0, 0, 0,
- 0, 0, 118, 0, 142, 143, 144, 145, 0, 116,
- 113, 0, 0, 0
+ 0, 548, 348, 417, 415, 318, 319, 314, 0, 223,
+ 322, 220, 0, 237, 0, 0, 229, 0, 293, 241,
+ 0, 0, 0, 0, 330, 335, 422, 548, 0, 247,
+ 0, 261, 227, 228, 481, 479, 0, 0, 277, 38,
+ 0, 0, 40, 38, 45, 0, 54, 288, 75, 0,
+ 286, 47, 0, 32, 34, 33, 176, 0, 0, 0,
+ 303, 48, 62, 63, 64, 0, 439, 440, 0, 444,
+ 0, 461, 0, 518, 435, 0, 388, 389, 0, 353,
+ 0, 0, 455, 455, 382, 0, 0, 349, 350, 316,
+ 321, 0, 323, 0, 238, 0, 0, 0, 242, 245,
+ 0, 262, 0, 0, 232, 233, 309, 291, 250, 56,
+ 0, 0, 282, 0, 39, 41, 37, 0, 0, 279,
+ 0, 278, 52, 0, 0, 0, 46, 226, 186, 178,
+ 179, 180, 65, 0, 0, 0, 460, 443, 446, 447,
+ 442, 0, 433, 0, 0, 0, 0, 451, 453, 548,
+ 0, 355, 320, 0, 222, 0, 536, 0, 235, 0,
+ 0, 0, 331, 276, 55, 284, 84, 0, 82, 85,
+ 0, 36, 38, 0, 287, 53, 0, 76, 285, 69,
+ 66, 70, 0, 0, 0, 439, 0, 445, 450, 436,
+ 364, 365, 366, 455, 368, 0, 369, 367, 324, 236,
+ 0, 239, 0, 333, 334, 43, 0, 42, 0, 281,
+ 44, 50, 0, 86, 0, 0, 67, 73, 0, 0,
+ 71, 77, 0, 58, 441, 0, 448, 452, 0, 0,
+ 454, 351, 537, 332, 83, 283, 0, 51, 0, 0,
+ 0, 141, 0, 0, 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0, 0, 0, 0, 72,
+ 102, 101, 134, 135, 0, 78, 79, 449, 351, 0,
+ 456, 87, 0, 89, 68, 0, 0, 0, 0, 0,
+ 150, 0, 0, 0, 140, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0, 131, 0, 0, 0,
+ 457, 459, 0, 0, 0, 0, 142, 0, 0, 0,
+ 0, 0, 0, 0, 0, 151, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0, 95, 0, 0, 113,
+ 0, 125, 126, 127, 0, 0, 0, 132, 133, 0,
+ 80, 458, 88, 74, 0, 90, 0, 0, 123, 124,
+ 116, 0, 0, 0, 0, 0, 91, 0, 154, 0,
+ 156, 158, 92, 0, 0, 0, 0, 94, 144, 149,
+ 0, 146, 148, 0, 0, 0, 0, 0, 0, 161,
+ 162, 0, 159, 69, 0, 0, 105, 108, 0, 0,
+ 0, 0, 0, 100, 0, 155, 0, 0, 0, 0,
+ 0, 145, 0, 96, 0, 114, 115, 128, 0, 130,
+ 0, 81, 0, 0, 0, 0, 97, 117, 0, 0,
+ 0, 93, 157, 0, 0, 0, 0, 147, 99, 129,
+ 160, 143, 0, 0, 111, 106, 103, 141, 0, 109,
+ 104, 0, 0, 0, 0, 0, 0, 0, 0, 98,
+ 0, 0, 0, 121, 122, 118, 119, 120, 0, 0,
+ 0, 0, 0, 112, 0, 136, 137, 138, 139, 0,
+ 110, 107, 0, 0, 0
};
-static const short yydefgoto[] = { 1092,
+static const short yydefgoto[] = { 1103,
9, 54, 10, 16, 30, 50, 51, 259, 260, 371,
- 372, 576, 667, 734, 735, 741, 582, 392, 673, 744,
- 824, 664, 504, 505, 606, 691, 754, 829, 799, 832,
- 675, 836, 880, 881, 848, 849, 782, 783, 1030, 825,
- 826, 874, 1006, 1034, 1055, 1035, 1059, 1056, 945, 946,
- 931, 1075, 967, 875, 902, 892, 923, 943, 987, 988,
- 897, 389, 936, 976, 997, 998, 999, 1, 2, 3,
- 4, 23, 24, 25, 58, 145, 6, 491, 592, 593,
- 139, 140, 141, 7, 21, 55, 37, 38, 39, 155,
- 157, 147, 62, 64, 60, 150, 94, 95, 96, 97,
- 98, 323, 99, 451, 311, 100, 200, 563, 564, 272,
- 382, 383, 355, 356, 357, 358, 359, 360, 361, 186,
- 561, 978, 281, 319, 202, 203, 282, 187, 447, 436,
- 437, 640, 717, 188, 301, 649, 650, 102, 348, 247,
- 103, 174, 286, 287, 288, 424, 289, 616, 697, 422,
- 410, 411, 523, 704, 412, 621, 413, 104, 215, 216,
- 217, 105, 106, 211, 107, 414, 701, 415, 693, 416,
- 417, 694, 695, 696, 803, 839, 766, 767, 810, 843,
- 844, 698, 226, 227, 228, 229, 617, 230, 418, 142,
- 109, 110, 111, 112, 113, 114, 11, 162, 116, 117,
- 518, 151, 152, 519, 153, 154, 131, 132, 419, 118,
- 420, 119, 529, 448, 304, 205, 641, 184, 14, 17,
- 18, 19, 40, 44, 45, 126
+ 372, 576, 672, 745, 746, 752, 582, 392, 678, 755,
+ 669, 503, 504, 606, 696, 765, 847, 815, 850, 680,
+ 854, 896, 897, 798, 799, 843, 844, 890, 1019, 1045,
+ 1066, 1046, 1070, 1067, 959, 960, 945, 1086, 981, 891,
+ 917, 907, 937, 957, 1001, 1002, 912, 389, 950, 990,
+ 1011, 1012, 1013, 1, 2, 3, 4, 23, 24, 25,
+ 58, 145, 6, 490, 592, 593, 139, 140, 141, 7,
+ 21, 55, 37, 38, 39, 155, 157, 147, 62, 64,
+ 60, 150, 94, 95, 96, 97, 98, 323, 99, 450,
+ 552, 311, 100, 200, 563, 564, 272, 382, 383, 355,
+ 356, 357, 358, 359, 360, 361, 186, 561, 992, 281,
+ 319, 202, 203, 282, 187, 436, 437, 640, 722, 188,
+ 301, 654, 655, 102, 348, 247, 103, 174, 286, 287,
+ 288, 424, 289, 616, 702, 422, 410, 411, 522, 709,
+ 412, 621, 413, 104, 215, 216, 217, 105, 106, 211,
+ 107, 414, 706, 415, 698, 416, 417, 699, 700, 701,
+ 819, 857, 777, 778, 826, 861, 862, 703, 226, 227,
+ 228, 229, 617, 230, 418, 142, 109, 110, 111, 112,
+ 113, 114, 11, 162, 116, 117, 517, 151, 152, 518,
+ 153, 154, 131, 132, 419, 118, 420, 119, 528, 786,
+ 304, 205, 641, 184, 14, 17, 18, 19, 40, 44,
+ 45, 126
};
static const short yypact[] = {-32768,
--32768, 58, 15, 58, 140,-32768, 197,-32768,-32768,-32768,
- 140,-32768,-32768,-32768,-32768,-32768, 220, 220, 326, 342,
- 405, 140, 424, 358,-32768, 649, 400,-32768, 415,-32768,
--32768,-32768,-32768, 446, 480, 484, 1796, 487,-32768,-32768,
- 220,-32768, 1796,-32768, 433,-32768,-32768,-32768, 59, 579,
--32768,-32768, 409, 482,-32768, 486, 486, 58,-32768, 116,
--32768, 116,-32768, 116,-32768,-32768,-32768,-32768,-32768,-32768,
--32768,-32768,-32768,-32768,-32768, 452,-32768,-32768,-32768,-32768,
--32768,-32768,-32768,-32768,-32768, 272, 174, 174, 545, 174,
- 546, 576, 589, 577,-32768,-32768,-32768,-32768,-32768,-32768,
--32768, 578,-32768, 116,-32768, 1370,-32768,-32768, 291, 545,
- 291, 815, 291, 1370, 1086, 2359, 2549, 471,-32768,-32768,
- 649,-32768, 603,-32768,-32768,-32768,-32768,-32768,-32768, 614,
--32768,-32768,-32768, 415, 700,-32768,-32768,-32768, 649, 597,
--32768, 140, 649, 643,-32768, 199, 116,-32768, 656, 658,
--32768,-32768,-32768,-32768, 116, 658, 116, 658, 678, 545,
- 711, 59, 685, 732, 174, 644, 659,-32768, 759,-32768,
- 1796,-32768, 782, 648, 2472, 2402, 1152,-32768, 2549,-32768,
--32768, 728,-32768,-32768, 545,-32768, 757, 765, 787, 775,
- 787, 777, 333, 787,-32768, 799, 782, 672,-32768,-32768,
- 793,-32768,-32768, 800,-32768, 956, 500, 801, 787, 1370,
--32768, 811, 1370,-32768, 336,-32768, 1370, 830, -8, 733,
- 2437,-32768, 1550,-32768, 2549, 825, 359,-32768, 2549,-32768,
--32768, 824,-32768,-32768,-32768,-32768, 255, 2549,-32768,-32768,
--32768,-32768, 860,-32768, 844, 847, 719, 848,-32768,-32768,
- 511, 486,-32768, 856, 511,-32768, 497, 866,-32768, 835,
- 658, 870, 876, 116, 658, 658,-32768, 956, 333, 782,
--32768, 818, 827,-32768,-32768,-32768,-32768, 672, 814, 149,
- 883,-32768, 956, 1977, 1977,-32768, 879,-32768, 894, 1370,
--32768,-32768, 907, 906,-32768, 442, 44,-32768, 2549,-32768,
- 725, 1015, 545, 787, 908, 782,-32768, 545, 956, 944,
- 897,-32768,-32768, 937, 921,-32768, 727, 782, 918,-32768,
--32768,-32768,-32768, 545,-32768,-32768, 1370,-32768, 2514, 2472,
--32768, 943,-32768,-32768,-32768, 929, 733,-32768, 388, 48,
--32768,-32768, 2514, 949, 2514,-32768, 2549, 928,-32768,-32768,
--32768,-32768,-32768, 324, 613,-32768,-32768,-32768,-32768,-32768,
--32768, 922, 291, 545, 291, 291,-32768, 415, 942,-32768,
- 729,-32768,-32768, 946, 415, 947,-32768,-32768,-32768, 979,
- 880, 5,-32768, 945,-32768,-32768, 745,-32768, 159, 782,
- 544,-32768, 782, 956, 2106, 1852, 1491,-32768, 2584,-32768,
--32768, 1977, 769, 769, 962, 964, 973, 1977, 116,-32768,
--32768, 2584,-32768,-32768,-32768,-32768,-32768,-32768, 952,-32768,
--32768, 362,-32768,-32768, 1977,-32768,-32768,-32768, 2514, 965,
--32768,-32768, 545, 663, 374, 216,-32768, 303, 955,-32768,
--32768, 333,-32768, 967,-32768, 623, 969, 970, 956,-32768,
--32768, 782,-32768,-32768, 782,-32768,-32768, 2168, 2168, 951,
- 971,-32768, 974,-32768,-32768, 2514, 990,-32768,-32768,-32768,
- 255, 860,-32768, 511,-32768, 782, 66, 976, 972, 977,
- 333, 189, 980, 751,-32768,-32768, 415, 820, 758, 426,
--32768,-32768,-32768, 782,-32768, 174, 782, 910, 782, 932,
--32768,-32768, 1002, 544, 477,-32768,-32768,-32768, 536, 991,
- 992, 906, 2106,-32768, 789, 805, 362, 1977,-32768,-32768,
- 999,-32768, 2549, 2168, 2168, 982,-32768,-32768, 2584, 2584,
- 2584, 2584, 1977, 954, 1977,-32768, 2584, 782, 2168, 2168,
- 997, 1004, 1006,-32768, 1007, 956, 1015, 403, 867, 1015,
- 897,-32768, 956, 956,-32768,-32768, 956, 2324, 2324, 1008,
- 821,-32768, 652,-32768, 1013,-32768,-32768,-32768, 1011, 1016,
--32768,-32768, 198, 1015, 688,-32768, 545, 782, 545, 978,
- 544, 951, 545, 983,-32768,-32768, 1019, 1023, 828,-32768,
- 237, 833,-32768, 985, 986,-32768,-32768, 857,-32768,-32768,
--32768,-32768, 987,-32768, 1032, 207, 1977,-32768, 1977,-32768,
- 1022,-32768, 1977, 1916, 521,-32768, 2549, 652, 1013,-32768,
- 2584,-32768, 2584, 2584, 2584,-32768, 1977,-32768,-32768, 1026,
- 652, 1013,-32768,-32768,-32768, 956,-32768,-32768, 398,-32768,
--32768, 217,-32768, 1033,-32768, 1038, 174, 174, 674,-32768,
--32768, 1031, 1048, 1053, 1046, 782, 2168,-32768,-32768,-32768,
--32768, 782, 544,-32768, 106, 1065, 1035, 27, 86, 1020,
- 333, 1039,-32768,-32768, 49,-32768, 1037, 947,-32768,-32768,
--32768,-32768, 426, 255, 324,-32768,-32768,-32768,-32768,-32768,
- 13, 538,-32768, 134,-32768, 1977,-32768, 1083,-32768, 1081,
- 1087,-32768,-32768, 1091,-32768, 1074, 1082, 2514, 2514,-32768,
- 1061, 782,-32768,-32768, 956,-32768, 862,-32768, 403,-32768,
- 732, 174, 2324,-32768,-32768,-32768,-32768,-32768, 1057, 1059,
- 403,-32768, 705, 1100,-32768,-32768, 1060, 1015,-32768, 1058,
--32768, 978, 140, 544, 544,-32768, 951,-32768,-32768,-32768,
--32768,-32768, 36, 169, 1977, 1977,-32768,-32768,-32768,-32768,
- 1977,-32768, 1977, 1977, 1977, 686,-32768, 374, 1110, 1977,
--32768,-32768, 545,-32768, 1047, 1049,-32768,-32768,-32768,-32768,
--32768, 470,-32768,-32768, 1065,-32768, 261, 1064,-32768,-32768,
- 330,-32768,-32768, 1117,-32768,-32768, 788, 174, 547, 1111,
- 1115,-32768, 1105,-32768,-32768,-32768,-32768, 2514,-32768, 888,
--32768,-32768,-32768,-32768,-32768,-32768, 705,-32768, 403,-32768,
--32768,-32768, 1118, 1072, 50,-32768, 1113, 544,-32768,-32768,
- 1136, 1629,-32768,-32768, 1125,-32768,-32768, 1977,-32768,-32768,
- 1977, 1120,-32768, 879,-32768,-32768, 705, 1123,-32768,-32768,
- 255,-32768, 544, 1131, 1143,-32768, 1134, 1629, 1135, 1151,
- 39, 407, 1629, 1629, 1153, 545, 545, 545, 545, 545,
- 474, 474, 140,-32768,-32768,-32768,-32768,-32768, 705, 1144,
--32768,-32768, 879, 1977,-32768, 599, 1118,-32768,-32768,-32768,
- 1168, 227, 1149, 1132, 515,-32768, 99, 140, 1159,-32768,
- 533, 1159, 1160, 1165, 1149, 545, 255, 255, 1164, 255,
- 1162,-32768, 426, 615, 1125,-32768, 997, 1183,-32768, 1184,
- 1190, 1629,-32768, 1169, 1180, 11, 1189, 1191, 474, 474,
- 1187,-32768, 1629, 324, 563, 1160, 769, 769, 1069, 1069,
- 1160, 2185,-32768, 782, 709,-32768, 1173,-32768,-32768,-32768,
- 782, 1185, 756,-32768,-32768, 1200,-32768,-32768, 1117,-32768,
- 1179,-32768, 1629, 823,-32768,-32768,-32768, 1202, 1203, 1204,
- 1205, 1629,-32768, 1159,-32768, 635,-32768,-32768,-32768, 1199,
- 1211, 1212, 1213,-32768,-32768,-32768, 642,-32768,-32768, 1216,
- 1192, 1149, 1629, 1215, 782,-32768,-32768, 660,-32768, 1117,
- 255, 782, 1217,-32768,-32768, 1218, 11, 1227, 1230, 1231,
--32768, 1160,-32768, 782, 1159, 1159, 1159, 1159,-32768, 2215,
--32768, 1629,-32768,-32768,-32768, 1219,-32768, 756,-32768,-32768,
- 1221, 1223, 1220, 710, 1210,-32768,-32768, 11, 11, 11,
--32768,-32768, 782, 782, 782, 782,-32768,-32768,-32768,-32768,
--32768, 1629, 88,-32768,-32768,-32768,-32768, 1222,-32768,-32768,
- 1224, 3, 3, 3, 1238, 1239, 1240, 1245,-32768, 380,
- 1629, 1629,-32768,-32768,-32768,-32768,-32768, 1241, 1242, 1243,
- 1244, 1629,-32768, 1249,-32768,-32768,-32768,-32768, 1251,-32768,
--32768, 1265, 1273,-32768
+-32768, 35, 61, 35, 113,-32768, 163,-32768,-32768,-32768,
+ 113,-32768,-32768,-32768,-32768,-32768, 232, 232, 275, 287,
+ 346, 113, 470, 612,-32768, 747, 312,-32768, 546,-32768,
+-32768,-32768,-32768, 454, 466, 490, 1745, 353,-32768,-32768,
+ 232,-32768, 1745,-32768, 314,-32768,-32768,-32768, 194, 165,
+-32768,-32768, 338, 482,-32768, 458, 458, 35,-32768, 74,
+-32768, 74,-32768, 74,-32768,-32768,-32768,-32768,-32768,-32768,
+-32768,-32768,-32768,-32768,-32768, 467,-32768,-32768,-32768,-32768,
+-32768,-32768,-32768,-32768,-32768, 372, 301, 301, 564, 301,
+ 555, 567, 609, 661,-32768,-32768,-32768,-32768,-32768,-32768,
+-32768, 605,-32768, 74,-32768, 2552,-32768,-32768, 295, 564,
+ 295, 1056, 295, 2552, 1171, 2358, 2587, 404,-32768,-32768,
+ 747,-32768, 623,-32768,-32768,-32768,-32768,-32768,-32768, 627,
+-32768,-32768,-32768, 546, 755,-32768,-32768,-32768, 747, 667,
+-32768, 113, 747, 637,-32768, 221, 74,-32768, 687, 640,
+-32768,-32768,-32768,-32768, 74, 640, 74, 640, 679, 564,
+ 694, 194, 672, 709, 301, 647, 669,-32768, 744,-32768,
+ 1745,-32768, 1011, 691, 2475, 2405, 1455,-32768, 2587,-32768,
+-32768, 758,-32768,-32768, 564,-32768, 782, 778, 811, 807,
+ 811, 809, 409, 811,-32768, 831, 1011, 441,-32768,-32768,
+ 829,-32768,-32768, 857,-32768, 1097, 296, 852, 811, 2552,
+-32768, 870, 2552,-32768, 283,-32768, 2552, 877, 146, 731,
+ 2440,-32768, 1572,-32768, 2587, 883, 559,-32768, 2587,-32768,
+-32768, 887,-32768,-32768,-32768,-32768, 408, 2587,-32768,-32768,
+-32768,-32768, 903,-32768, 886, 906, 735, 902,-32768,-32768,
+ 321, 458,-32768, 921, 321,-32768, 537, 927,-32768, 895,
+ 640, 928, 931, 74, 640, 640,-32768, 1097, 409, 1011,
+-32768, 874, 876,-32768,-32768,-32768,-32768, 441, 871, 29,
+ 939,-32768, 1097, 2079, 2079,-32768, 930,-32768, 943, 2552,
+-32768,-32768, 945, 944,-32768, 474, 159,-32768, 2587,-32768,
+ 776, 1108, 564, 811, 949, 1011,-32768, 564, 1011, 711,
+ 933,-32768,-32768, 971, 958,-32768, 781, 1011, 983,-32768,
+-32768,-32768,-32768, 564,-32768,-32768, 2552,-32768, 2517, 2475,
+-32768, 974,-32768,-32768,-32768, 960, 731,-32768, 512, 177,
+-32768,-32768, 2517, 980, 2517,-32768, 2587, 962,-32768,-32768,
+-32768,-32768,-32768, 355, 697,-32768,-32768,-32768,-32768,-32768,
+-32768, 966, 295, 564, 295, 295,-32768, 546, 982,-32768,
+ 794,-32768,-32768, 978, 546, 985,-32768,-32768,-32768, 632,
+ 923, 57,-32768, 988,-32768,-32768, 827,-32768, 552, 1011,
+ 633,-32768, 1011, 1097, 2138, 1925, 1374,-32768, 2629,-32768,
+-32768, 2079, 851, 851, 995, 996, 1008, 2079, 74,-32768,
+-32768, 2629,-32768,-32768,-32768,-32768,-32768,-32768, 984,-32768,
+-32768, 128,-32768,-32768, 2079,-32768,-32768,-32768, 2517, 1013,
+-32768,-32768, 564, 706, 415, 63,-32768, 719, 994,-32768,
+-32768, 597,-32768, 1002,-32768, 1001, 1010, 1097,-32768,-32768,
+ 1011,-32768,-32768, 1011,-32768,-32768, 2197, 2197, 989, 1015,
+-32768, 1017,-32768,-32768, 2517, 1037,-32768,-32768,-32768, 408,
+ 903,-32768, 321,-32768, 1011, 89, 1021, 1016, 1024, 409,
+ 155, 1027, 845,-32768,-32768, 546, 786, 849, 570,-32768,
+-32768,-32768, 1011,-32768, 301, 1011, 967, 1011, 998,-32768,
+-32768, 1055, 633, 414,-32768,-32768,-32768, 613, 1044, 1043,
+ 944, 2138,-32768, 873, 855, 128, 2079,-32768,-32768, 1045,
+-32768, 2587, 2197, 2197, 1029,-32768,-32768, 2629, 2629, 2629,
+ 2629, 2079, 1031, 2079,-32768, 2629, 1011, 2197, 2197, 1050,
+ 1048, 1058,-32768, 1059, 1097, 1108, 568, 838, 1108, 811,
+ 339, 933,-32768,-32768, 1011, 1011, 1019, 2323, 2323, 1075,
+ 861,-32768, 734,-32768, 1074,-32768,-32768,-32768, 1071, 1077,
+-32768,-32768, 263, 1108, 1047,-32768, 564, 1011, 564, 1038,
+ 633, 989, 564, 1035,-32768,-32768, 1082, 1083, 872,-32768,
+ 250, 875,-32768, 1051, 1052,-32768,-32768, 879,-32768,-32768,
+-32768,-32768, 1040,-32768, 1102, 3, 2079,-32768, 2079,-32768,
+ 1087,-32768, 2079, 2002, 366,-32768, 2587, 734, 1074,-32768,
+ 2629,-32768, 2629, 2629, 2629,-32768, 2079,-32768,-32768, 1085,
+ 734, 1074,-32768,-32768,-32768, 1097,-32768,-32768, 444,-32768,
+-32768, 242, 1099,-32768, 590, 811,-32768, 891, 1098,-32768,
+ 301, 301, 301, 753,-32768,-32768, 1088, 1104, 1110, 1103,
+ 1011, 2197,-32768,-32768,-32768,-32768, 1011, 633,-32768, 387,
+ 1105, 1064, 18, 211, 1066, 409, 1061,-32768,-32768, 181,
+-32768, 1072, 985,-32768,-32768,-32768,-32768, 570, 408, 355,
+-32768,-32768,-32768,-32768,-32768, 41, 476,-32768, 220,-32768,
+ 2079,-32768, 1123,-32768, 1122, 1124,-32768,-32768, 1125,-32768,
+ 1111, 1112, 2517, 2517,-32768, 1092, 1011,-32768,-32768, 1097,
+-32768, 894,-32768, 568,-32768, 811, 811, 75,-32768,-32768,
+ 1127, 709, 301, 2323,-32768,-32768,-32768,-32768,-32768, 1090,
+ 1093, 568,-32768, 860, 1130,-32768,-32768, 1094, 1108,-32768,
+ 1089,-32768, 1038, 113, 633, 633,-32768, 989,-32768,-32768,
+-32768,-32768,-32768, 32, 477, 2079, 2079,-32768,-32768,-32768,
+-32768, 2079,-32768, 2079, 2079, 2079, 756,-32768, 415, 1143,
+ 2079,-32768,-32768, 564,-32768, 896,-32768, 1140,-32768, 1011,
+ 1079, 1080,-32768,-32768,-32768,-32768,-32768, 420,-32768,-32768,
+ 1105,-32768, 405, 1101,-32768,-32768, 43,-32768,-32768, 1150,
+-32768,-32768, 826, 301, 578, 1145, 1166,-32768, 1156,-32768,
+-32768,-32768,-32768, 2517,-32768, 907,-32768,-32768,-32768,-32768,
+ 811,-32768, 64,-32768,-32768,-32768, 860,-32768, 568,-32768,
+-32768,-32768, 261,-32768, 1162, 633,-32768,-32768, 1186, 1616,
+-32768,-32768, 1178,-32768,-32768, 2079,-32768,-32768, 2079, 1175,
+-32768, 930,-32768,-32768,-32768,-32768, 408,-32768, 333, 1185,
+ 1197,-32768, 1189, 1616, 1191, 1207, 174, 453, 1616, 1616,
+ 1193, 564, 564, 564, 564, 564, 573, 573, 113,-32768,
+-32768,-32768,-32768,-32768, 860, 1188,-32768,-32768, 930, 2079,
+-32768,-32768, 633,-32768,-32768, 1211, 360, 1192, 1176, 635,
+-32768, 329, 113, 1196,-32768, 777, 1196, 1198, 1204, 1192,
+ 564, 408, 408, 1199, 408, 1202,-32768, 570, 599, 1178,
+-32768, 1050, 1206, 1218, 1225, 1616,-32768, 1201, 1216, 59,
+ 1227, 1229, 573, 573, 1210,-32768, 1616, 355, 506, 1198,
+ 851, 851, 981, 981, 1198, 2155,-32768, 1011, 762,-32768,
+ 1212,-32768,-32768,-32768, 1011, 1217, 938,-32768,-32768, 1236,
+-32768,-32768,-32768,-32768, 1213,-32768, 1616, 842,-32768,-32768,
+-32768, 1237, 1238, 1239, 1241, 1616,-32768, 1196,-32768, 606,
+-32768,-32768,-32768, 1235, 1240, 1243, 1244,-32768,-32768,-32768,
+ 617,-32768,-32768, 1245, 1215, 1192, 1616, 1231, 1011,-32768,
+-32768, 641,-32768, 1150, 1011, 1247,-32768,-32768, 1248, 59,
+ 1246, 1252, 1257,-32768, 1198,-32768, 1011, 1196, 1196, 1196,
+ 1196,-32768, 2214,-32768, 1616,-32768,-32768,-32768, 1249,-32768,
+ 938,-32768, 1251, 1230, 665, 815,-32768,-32768, 59, 59,
+ 59,-32768,-32768, 1011, 1011, 1011, 1011,-32768,-32768,-32768,
+-32768,-32768, 1616, 119,-32768,-32768,-32768,-32768, 1250,-32768,
+-32768, 1255, 147, 147, 147, 1254, 1260, 1265, 1266,-32768,
+ 585, 1616, 1616,-32768,-32768,-32768,-32768,-32768, 1261, 1262,
+ 1263, 1264, 1616,-32768, 1270,-32768,-32768,-32768,-32768, 1271,
+-32768,-32768, 1269, 1293,-32768
};
static const short yypgoto[] = {-32768,
--32768,-32768,-32768, 1106,-32768,-32768, 1141,-32768,-32768, 95,
- 791, -604, 611,-32768, 495,-32768, 604, 783, 540,-32768,
--32768, 555, -477,-32768,-32768,-32768,-32768, -902,-32768,-32768,
--32768,-32768,-32768, 370,-32768, 399, -746, 472,-32768, 286,
- 437, -95,-32768,-32768,-32768,-32768,-32768, 258,-32768, 302,
--32768, -135, -527, -427,-32768, 238, -732, -652,-32768, 276,
--32768,-32768, -705,-32768, -401,-32768, 269,-32768,-32768,-32768,
--32768, 1285, 1286, 1267,-32768,-32768, 68, 634,-32768, 630,
- 1260, 1266, 1070,-32768,-32768,-32768, 52,-32768, 1207,-32768,
--32768,-32768,-32768,-32768,-32768, 235, 1281, 1154,-32768,-32768,
--32768, -442,-32768, 781, -243,-32768,-32768, -53, -22, 612,
--32768, 840, 1084, 863,-32768,-32768,-32768,-32768,-32768, -88,
- 839, -59, -90, -245,-32768, 353, 1226, -78,-32768, -505,
- 794, -657,-32768, -72,-32768, 784, 617, -100,-32768, 854,
- -508,-32768,-32768,-32768, 803, -662, -804, 730, -44, -255,
--32768, -355,-32768,-32768,-32768, 208, -159,-32768, -117,-32768,
- -60,-32768,-32768, -51,-32768,-32768, 584,-32768, 950,-32768,
--32768,-32768, 590,-32768,-32768,-32768, 641, 543,-32768,-32768,
- 436, 598, -142, -199, 1010,-32768, -73, -97, -7,-32768,
- -218, -209, -203,-32768, -202,-32768,-32768, -34,-32768,-32768,
--32768, 120,-32768,-32768, -208, -47,-32768, 960, -29, -76,
- 1139,-32768, -400, 806,-32768, 43, -103, 752, -6, -18,
- -14,-32768, -23, -20,-32768,-32768
+-32768,-32768,-32768, 1134,-32768,-32768, 1160,-32768,-32768, 22,
+ 810, -599, 622,-32768, 496,-32768, 616, 800, 547,-32768,
+ 561, -483,-32768,-32768,-32768,-32768, 290,-32768,-32768,-32768,
+-32768,-32768, 375, 411, 471,-32768, 440, -290,-32768,-32768,
+-32768,-32768,-32768, 264,-32768, 303,-32768, -131, -537, -785,
+-32768, 243, -826, -664,-32768, 280,-32768,-32768, -777,-32768,
+ -362,-32768, 273,-32768,-32768,-32768,-32768, 1297, 1301, 1279,
+-32768,-32768, 65, 639,-32768, 643, 1272, 1275, 1081,-32768,
+-32768,-32768, 24,-32768, 1219,-32768,-32768,-32768,-32768,-32768,
+-32768, 292, 1280, 1168,-32768,-32768,-32768, -430,-32768, 789,
+-32768, -247,-32768,-32768, -129, -34, 610, 553, 853, 1095,
+ 882,-32768,-32768,-32768,-32768,-32768, -89, -441, 71, -78,
+ -251,-32768, 34, 1232, -82, -510, 799, -666,-32768, -60,
+-32768, 788, 614, -95,-32768, 881, -497,-32768,-32768,-32768,
+ 819, -541, -789, 743, 10, -259,-32768, -338,-32768,-32768,
+-32768, 317, 76,-32768, -105,-32768, -48,-32768,-32768, -68,
+-32768,-32768, 589,-32768, 968,-32768,-32768,-32768, 594,-32768,
+-32768,-32768, 652, 548,-32768,-32768, 438, 604, -117, -210,
+ 1028,-32768, -63, -84, -7,-32768, -224, -207, -206,-32768,
+ -199,-32768,-32768, -32,-32768,-32768,-32768, -62,-32768,-32768,
+ -208, -47,-32768, 977, -29, -72, 1022,-32768, -397,-32768,
+ 729, -168, -103, 779, -10, -25, 4,-32768, -20, -17,
+-32768,-32768
};
-#define YYLAST 2695
+#define YYLAST 2740
static const short yytable[] = { 52,
- 42, 130, 115, 530, 20, 842, 46, 193, 115, 163,
- 164, 165, 56, 167, 101, 32, 57, 566, 345, 235,
- 101, 201, 380, 339, 207, 381, 603, 299, 409, 108,
- 494, 190, 363, 293, 246, 108, 363, 394, 192, 507,
- 208, 364, 48, 234, 642, 364, 794, 365, 366, 651,
- 651, 365, 366, 210, 180, 547, 1001, 291, 248, 296,
- 732, 774, 472, 127, 739, 128, 8, 218, 665, 668,
- 172, 12, 1073, 780, 745, 851, 182, 43, 336, 299,
- 965, 235, 752, 347, 182, 219, 232, 232, 273, 753,
- 961, 495, 127, 294, 128, 574, 300, 1029, 181, 666,
- 886, 932, 240, 674, 52, 298, 181, 181, 231, 231,
- 332, 5, 842, 280, 218, 738, 253, 746, 852, 1074,
- 127, 148, 128, 256, 795, 146, 933, 235, 966, 130,
- 345, 235, 914, 575, 547, 254, 115, 315, 317, 676,
- 235, 517, 149, 13, 898, 182, 232, 297, 101, 232,
- 362, 341, 327, 575, 362, 346, 757, 507, 325, 758,
- 924, 846, 430, 108, 350, 325, 467, 181, 231, 181,
- 731, 231, 947, 575, 248, 130, 65, 129, 248, 390,
- 182, 885, 820, 182, 498, 730, 461, 182, 520, 499,
- 251, 232, 549, 340, 255, 232, 941, 78, 551, 232,
- 468, 235, 181, 557, 442, 181, 129, 349, 232, 181,
- 384, 435, 462, 231, 651, 231, 391, 231, 387, -327,
- 916, 231, 257, 175, 439, 431, 546, 373, 662, 327,
- 231, 305, 787, 307, 129, 460, 313, 580, 796, 522,
- 421, 127, 294, 128, 547, 547, 441, 797, 798, 235,
- 921, 313, 536, 258, 922, 363, 581, 47, 456, 947,
- 182, 481, 615, 15, 364, 663, 791, 792, 1012, 232,
- 365, 366, 22, 470, 65, 325, 689, 482, 49, 628,
- 548, 719, 181, 979, 477, 479, 542, 690, 984, 547,
- 478, 231, 480, 483, 48, 78, 156, 182, 158, 232,
- 182, 1058, 1058, 458, 793, 195, 48, 459, -305, 1043,
- 1044, 1045, 1046, 232, 185, 232, 160, 232, 161, 181,
- 196, 231, 181, 569, 197, 819, 278, 48, 575, -305,
- 500, 475, 47, 506, 330, 231, 48, 231, 373, 231,
- 127, 148, 128, 28, 544, 373, 440, 472, 485, 130,
- 854, 509, 516, 49, 309, 129, 310, 526, 628, 1041,
- 328, 329, 149, 534, 148, 29, 127, 148, 128, 622,
- 622, 622, 622, 362, 387, 889, 33, 629, 41, 148,
- 541, 261, 524, 379, 343, 344, 525, 588, 149, 265,
- 715, 266, 560, 148, 538, 562, 199, 248, 822, 232,
- 344, 48, 823, 921, 539, 565, 48, 1082, 540, 900,
- 330, 248, 465, 466, 344, 330, 573, 47, 48, 597,
- 41, 231, 716, 115, 115, 235, 639, 742, 47, 48,
- 901, 558, 135, 124, 384, 559, 232, 562, 49, 600,
- 136, 571, 33, 911, 912, 31, 127, 148, 128, 591,
- 108, 108, 125, 59, 129, 637, 435, 373, 231, 435,
- 594, 710, 484, 710, 710, 710, 428, 429, 149, 489,
- 618, 619, 34, 35, 36, 671, 47, 48, 630, 1037,
- 129, 652, 652, 435, 435, 631, 632, 61, 626, 115,
- 115, 63, 816, 232, 677, 817, 237, 591, 669, 47,
- 48, 970, 971, -337, 115, 115, 238, 121, 768, 768,
- 1062, 1063, 1064, 65, 986, 231, 108, 108, 670, 235,
- 49, 370, 137, 115, 115, 127, 148, 128, 535, 159,
- -327, 108, 108, 977, 78, 718, 980, 981, 138, 658,
- 322, 535, 990, 130, 659, 703, 604, 149, 48, 994,
- 108, 108, 605, 168, 81, 82, 83, 84, 320, 345,
- 129, 607, 692, 755, 608, 195, 48, 609, 700, 756,
- 721, 722, 866, 867, 868, 869, 870, 871, 872, 873,
- 196, 330, 711, 169, 197, 975, 278, 232, 937, 938,
- 939, 940, 986, 1026, 706, 33, 727, 171, 707, 170,
- 1032, 708, 729, 133, 134, 709, 1057, 713, 768, 231,
- 173, 714, 1042, 501, 502, 33, 834, 252, 503, 835,
- 320, 918, 115, 171, 817, 724, 926, 927, 928, 929,
- 930, 33, 725, 474, 728, 320, 614, 956, 241, 129,
- 817, 1065, 1066, 1067, 1068, 776, 652, 435, 553, 108,
- 554, 759, 771, 594, 750, 279, 199, 1013, 262, 263,
- 1014, 444, 446, 252, 1019, 195, 48, 1020, 545, 813,
- 33, 457, 657, 784, 195, 48, 284, 285, 232, 232,
- 196, 267, 1027, 264, 197, 1028, 278, 316, 115, 196,
- 195, 48, 33, 197, 723, 278, 316, 34, 35, 36,
- 231, 231, 65, 48, 33, 196, 808, 195, 48, 197,
- 800, 434, 47, 48, 269, 108, 700, 270, 805, 806,
- 807, 833, 196, 243, 244, 812, 197, 991, 278, 992,
- 274, 245, 457, 1053, 535, 271, 790, 623, 624, 625,
- 333, 334, 809, 353, 354, 275, 457, 535, 811, 432,
- 433, 454, 455, 486, 487, 279, 199, 784, 195, 48,
- 666, 827, 894, 299, 279, 199, 276, 903, 904, 454,
- 497, 527, 528, 196, 781, 584, 487, 197, 232, 278,
- 53, 199, 590, 487, 195, 48, 302, 784, 120, 195,
- 320, 611, 263, 882, 120, 303, 883, 279, 199, 196,
- 231, 320, 877, 197, 306, 278, 1054, 308, 866, 867,
- 868, 869, 870, 871, 872, 873, 314, 195, 48, 784,
- 318, 827, 65, 48, 876, 996, 962, -302, 877, 612,
- 613, 324, 196, 877, 877, 326, 197, 973, 198, 917,
- 166, 877, 877, 243, 586, 655, 656, 342, 279, 199,
- 876, 587, 681, 354, 331, 876, 876, 682, 683, 347,
- 189, 191, 194, 206, 209, 294, 913, 1003, 351, 195,
- 48, 352, -296, 237, 279, 199, 1011, 949, 950, 368,
- 952, 686, 656, 954, 196, 53, 772, 773, 197, 375,
- 278, 934, 877, -296, 830, 831, 377, 1024, 376, 877,
- 877, 457, 378, 877, 385, 644, 646, 388, 199, 457,
- 393, 268, 877, 386, 876, 841, 284, 1004, 1005, 423,
- 195, 48, 120, 425, 283, 876, 1048, 1076, 1077, 426,
- 427, 982, 983, 877, 989, 196, 209, 450, -289, 197,
- 452, 278, 877, 453, 312, -296, 195, 48, 283, 283,
- 463, 464, 263, 471, 476, 876, 1069, 321, 195, 48,
- 199, 196, 474, 877, 876, 197, 493, 278, 445, 488,
- 490, 827, 543, 196, 496, 1083, 1084, 197, 531, 278,
- 532, 195, 48, 533, 550, 876, 1089, 537, 320, 552,
- 877, 322, 877, 555, 556, 567, 196, 570, 568, 391,
- 197, 578, 278, 599, 877, 130, 577, 579, 374, 602,
- 583, 199, 989, 610, 876, 627, -521, 195, 48, 321,
- 312, 283, 877, -522, 620, 284, 654, 1061, 634, 283,
- 635, 636, 196, 657, 321, 660, 197, 199, 434, 688,
- 661, 877, 877, 679, 876, 672, 678, 680, 699, 199,
- 684, 685, 877, 438, 191, 687, 712, 283, 553, 443,
- 321, 449, 720, 876, 876, 492, 238, 457, 723, 283,
- 321, 726, 199, -303, 876, 209, 67, 68, 69, 70,
- 71, 72, 73, 74, 75, 76, 733, 740, 47, 48,
- 127, 212, 213, 67, 68, 69, 70, 71, 72, 73,
- 74, 75, 76, 736, 581, 760, 761, 176, 199, 177,
- 214, 762, 743, 764, 189, 191, 194, 209, 763, 374,
- 178, 765, 179, 770, 663, 785, 374, 779, 786, 788,
- 808, 321, 821, 814, 828, 815, 755, 837, 838, 847,
- 850, 283, 853, 855, 283, 321, 879, 884, 887, 890,
- 891, 893, 895, 896, 47, 48, 127, 294, 213, 67,
- 68, 69, 70, 71, 72, 73, 74, 75, 76, 915,
- 905, 920, 921, 176, 925, 177, 295, 91, 92, 93,
- 935, 942, 944, 953, 209, 283, 178, 951, 179, 321,
- 959, 960, 961, 312, 91, 92, 93, 964, 963, 968,
- 321, 969, 993, 283, 129, 972, 283, 1000, 995, 120,
- 120, 1002, 1007, 1008, 1009, 1010, 1015, 67, 68, 69,
- 70, 71, 72, 73, 74, 75, 76, 283, 1016, 1017,
- 1018, 1022, 312, 921, 1021, 1033, 1036, 1038, 374, 1025,
- 1039, 1040, 250, 1049, 183, 283, 851, 1051, 283, 1071,
- 283, 1072, 183, 183, 233, 236, 1078, 1079, 1080, 1052,
- 91, 92, 93, 1081, 1093, 1085, 1086, 1087, 1088, 1090,
- 129, 1091, 1094, 249, 242, 120, 120, 585, 737, 818,
- 747, 789, 601, 778, 957, 919, 1031, 888, 845, 283,
- 120, 120, 1060, 1023, 1070, 1047, 1050, 283, 438, 443,
- 321, 438, 26, 27, 321, 321, 1054, 122, 321, 120,
- 120, 748, 749, 183, 233, 183, 143, 236, 91, 92,
- 93, 367, 144, 123, 277, 438, 438, 239, 191, 283,
- 443, 643, 775, 596, 209, 598, 572, 204, 369, 777,
- 638, 589, 653, 633, 804, 510, 705, 802, 183, 769,
- 840, 183, 958, 801, 469, 183, 521, 0, 645, 233,
- 0, 233, 0, 236, 0, 0, 0, 236, 0, 0,
- 0, 0, 47, 48, 0, 0, 236, 67, 68, 69,
- 70, 71, 72, 73, 74, 75, 76, 321, 0, 0,
- 443, 176, 0, 177, 0, 0, 0, 0, 0, 0,
- 0, 0, 0, 0, 178, 0, 179, 283, 120, 0,
- 0, 0, 0, 283, 0, 0, 0, 0, 0, 0,
- 0, 0, 312, 0, 0, 0, 0, 0, 183, 0,
- 0, 0, 0, 0, 0, 0, 0, 236, 0, 0,
+ 20, 130, 101, 42, 115, 56, 529, 193, 101, 46,
+ 115, 32, 339, 163, 164, 165, 380, 167, 345, 603,
+ 305, 381, 307, 207, 409, 313, 363, 190, 566, 108,
+ 363, 394, 235, 201, 57, 108, 860, 180, 642, 246,
+ 313, 175, 810, 364, 365, 47, 546, 364, 365, 43,
+ 192, 366, 208, 234, 598, 366, 506, 785, 293, 390,
+ 656, 656, 248, 670, 673, 210, 49, 218, 12, 291,
+ 743, 296, 694, 172, 750, 796, 182, 195, 127, 148,
+ 128, 938, 493, 695, 182, 219, 232, 232, 5, 493,
+ 671, 546, 273, 961, 235, 300, 391, 679, 181, 789,
+ 149, 926, 927, 336, 52, 240, 181, 181, 231, 231,
+ 763, 842, 8, 648, 218, 298, 13, 764, 574, 253,
+ 811, 975, 146, 127, 294, 128, 256, 547, 979, 130,
+ 345, 254, 127, 148, 128, 440, 101, 516, 115, 955,
+ 235, 325, 860, 494, 235, 182, 232, 297, 325, 232,
+ 864, 681, 330, 235, 149, 362, 575, 984, 985, 362,
+ 537, 341, 251, 108, 327, 346, 255, 181, 231, 181,
+ 1000, 231, 866, 506, 350, 130, 980, 48, 248, 961,
+ 182, 299, 248, 182, 741, -326, 548, 182, 519, 133,
+ 134, 232, 129, 340, 299, 232, 557, 471, 127, 232,
+ 128, 379, 181, 840, 442, 181, 756, 349, 232, 181,
+ 1025, 460, 347, 231, 235, 231, 1084, 231, 1069, 1069,
+ 439, 231, 581, 435, 461, 467, 545, 373, 330, 15,
+ 231, 447, 580, 330, 459, 431, 656, 129, 803, 320,
+ 749, 327, 768, 280, 257, 769, 129, 1000, 363, 757,
+ 1054, 1055, 1056, 1057, 127, 294, 128, 615, 325, 1068,
+ 182, 480, 235, 1085, 332, 364, 365, 315, 317, 232,
+ 546, 807, 808, 366, 628, 258, 481, 430, 575, 913,
+ 476, 478, 181, 469, 22, 993, 867, 127, 148, 128,
+ 998, 231, 28, 667, 421, 466, 457, 182, 48, 232,
+ 182, 320, 477, 65, 479, 482, 724, 328, 329, 149,
+ 29, 541, 129, 232, 124, 232, 320, 232, 185, 181,
+ 901, 231, 181, 65, 78, 458, -326, 809, 565, 868,
+ 668, 946, 41, 125, 474, 231, 322, 231, 373, 231,
+ 384, 195, 48, 543, 78, 373, 534, 569, 387, 130,
+ 903, 484, 456, 156, 628, 158, 947, 931, 48, 534,
+ 1052, 135, 870, 644, 81, 82, 83, 84, 129, 136,
+ 127, 148, 128, 121, 65, 523, 441, 362, 471, 444,
+ 446, 643, 645, 935, 720, 904, 31, 936, 455, 483,
+ 708, 588, 149, 618, 619, 78, 488, 538, 330, 232,
+ 248, 129, 500, 501, 524, 508, 515, 502, 631, 632,
+ 47, 525, 48, 456, 248, 546, 160, 533, 161, 933,
+ 148, 231, 597, 558, 115, 115, 539, 456, 753, 237,
+ 309, 49, 310, 546, 540, 232, -337, 235, 261, 238,
+ 571, 344, 836, 195, 48, 837, 265, 48, 266, 108,
+ 108, 742, 559, 614, 575, 915, 373, 231, 196, 594,
+ 499, 59, 197, 505, 278, 316, 637, 435, 721, 839,
+ 435, 320, 575, 61, 521, 676, 916, 307, 127, 148,
+ 128, 320, 1048, 604, 129, 657, 657, 535, 33, 605,
+ 115, 115, 232, 682, 674, 435, 435, 63, 428, 429,
+ 149, 766, 779, 779, 387, 115, 115, 767, 195, 48,
+ 138, 1073, 1074, 1075, 231, 108, 108, 148, 34, 35,
+ 36, 560, 137, 196, 562, 115, 115, 197, 989, 278,
+ 108, 108, 235, 279, 199, 723, 464, 465, 344, 47,
+ 48, 626, 663, 130, 159, 573, 812, 664, 47, 48,
+ 108, 108, 534, 994, 995, 813, 814, 787, 788, 440,
+ 49, 370, 168, 384, 148, 534, 562, 48, 600, 49,
+ 345, 48, 47, 48, 169, 47, 48, 497, 731, 732,
+ 733, 456, 498, 909, 343, 344, 991, 232, 918, 919,
+ 456, 639, 129, 591, 713, 1004, 591, 711, 279, 199,
+ 48, 712, 1008, 622, 622, 622, 622, 630, 935, 231,
+ 718, 629, 1093, 779, 719, 726, 697, 727, 550, 170,
+ 551, 970, 705, 714, 837, 562, 649, 739, 1026, 115,
+ 33, 1027, 41, 735, 195, 48, 716, 173, 607, 1032,
+ 736, 608, 1033, 171, 609, 976, 1039, 852, 675, 196,
+ 853, 241, 1043, 197, 108, 278, 987, 252, 594, 761,
+ 792, 657, 863, 1040, 1053, 264, 1041, 47, 48, 320,
+ 435, 882, 883, 884, 885, 886, 887, 888, 889, 33,
+ 829, 171, 267, 232, 232, 33, 1016, 252, 1064, 262,
+ 263, 1076, 1077, 1078, 1079, 1024, 715, 269, 715, 715,
+ 715, 115, 500, 501, 270, 231, 231, 502, 195, 48,
+ 770, 544, 271, 195, 48, 33, 1037, 473, 491, 284,
+ 285, 195, 48, 196, -305, 199, 108, 197, 196, 278,
+ 316, 738, 197, 274, 278, 445, 196, 740, 333, 334,
+ 197, 851, 278, 806, 1059, -305, 940, 941, 942, 943,
+ 944, 276, 33, 456, 662, 275, 825, 65, 48, 353,
+ 354, 1065, 827, 882, 883, 884, 885, 886, 887, 888,
+ 889, 33, 1080, 734, 33, 816, 824, 845, 243, 244,
+ 1005, 705, 1006, 821, 822, 823, 245, 782, 65, 48,
+ 828, 1094, 1095, 299, 232, 34, 35, 36, 279, 199,
+ 432, 433, 1100, 279, 199, 453, 454, 53, 303, 243,
+ 586, 302, 199, 195, 800, 120, 231, 587, 485, 486,
+ 893, 120, 67, 68, 69, 70, 71, 72, 73, 74,
+ 75, 76, 951, 952, 953, 954, 306, 845, 935, 308,
+ 195, 48, 892, -296, 893, 623, 624, 625, 314, 893,
+ 893, 453, 496, 526, 527, 196, 318, 893, 893, 197,
+ 384, 278, 195, 48, -296, 898, 892, 166, 899, 584,
+ 486, 892, 892, 590, 486, 611, 263, 196, 928, 612,
+ 613, 197, 324, 278, -302, 660, 661, 189, 191, 194,
+ 206, 209, 963, 964, 326, 966, 686, 354, 968, 687,
+ 688, 331, 948, 691, 661, 342, 893, 800, 294, 932,
+ 351, 1065, 53, 893, 893, 729, 661, 893, 783, 784,
+ 830, 831, 347, 91, 92, 93, 893, 237, 892, 797,
+ 352, 199, 848, 849, 859, 284, 1017, 1018, 268, 892,
+ 195, 48, 1087, 1088, 368, 996, 997, 893, 1003, 120,
+ 375, 283, 279, 199, 377, 196, 893, 378, 376, 197,
+ 385, 278, 386, 209, 388, 800, 393, 426, 427, 892,
+ 423, 312, 425, 449, 451, 283, 283, 893, 892, -289,
+ 452, 462, 463, 263, 321, 195, 48, 470, 67, 68,
+ 69, 70, 71, 72, 73, 74, 75, 76, 475, 892,
+ 196, 487, 473, 893, 197, 893, 278, 1010, 489, 492,
+ -296, 530, 531, 195, 48, 893, 130, 495, 532, 536,
+ 542, 195, 48, 549, 554, 1003, 555, 892, 196, 322,
+ 279, 199, 197, 893, 278, 374, 196, 556, 1072, 567,
+ 197, 568, 278, 650, 570, 578, 321, 312, 283, 195,
+ 48, 577, 893, 893, 579, 892, 283, 583, 195, 48,
+ 599, 321, 602, 893, 196, 391, 610, -521, 197, -522,
+ 434, 620, 634, 196, 892, 892, 199, 197, 284, 198,
+ 438, 191, 635, 636, 283, 892, 443, 283, 448, 91,
+ 92, 93, 627, 659, 662, 665, 283, 321, 683, 195,
+ 48, 666, 209, 279, 199, 677, 684, 685, 692, 693,
+ 195, 48, 199, 704, 196, 717, 689, 690, 197, 671,
+ 278, 725, 730, 238, 734, 196, 744, 183, 737, 197,
+ -303, 434, 747, 751, 754, 183, 183, 233, 236, 581,
+ 199, 189, 191, 194, 209, 771, 374, 772, 773, 199,
+ 775, 776, 774, 374, 781, 801, 249, 668, 321, 790,
+ 804, 795, 802, 824, 832, 834, 835, 846, 283, 841,
+ 766, 283, 321, 47, 48, 127, 212, 213, 67, 68,
+ 69, 70, 71, 72, 73, 74, 75, 76, 855, 856,
+ 199, 869, 176, 871, 177, 214, 183, 233, 183, 895,
+ 236, 199, 900, 905, 906, 178, 908, 179, 910, 911,
+ 920, 209, 283, 930, 934, 935, 321, 949, 939, 956,
+ 553, 958, 965, 967, 973, 974, 321, 975, 986, 283,
+ 977, 183, 283, 978, 183, 120, 120, 982, 183, 983,
+ 1009, 1007, 233, 1014, 233, 1015, 236, 1020, 1021, 1022,
+ 236, 1023, 1028, 283, 1035, 1038, 1049, 1029, 312, 236,
+ 1030, 1031, 1050, 1034, 374, 1044, 1047, 1051, 1104, 1063,
+ 250, 283, 1089, 1060, 283, 1062, 283, 1082, 1090, 91,
+ 92, 93, 1083, 1091, 1092, 1096, 1097, 1098, 1099, 129,
+ 1101, 1102, 1105, 242, 748, 585, 838, 758, 601, 805,
+ 794, 120, 120, 1042, 971, 929, 902, 865, 1036, 1071,
+ 1081, 183, 1058, 1061, 26, 283, 120, 120, 27, 122,
+ 236, 759, 123, 283, 438, 443, 321, 438, 143, 646,
+ 760, 144, 367, 283, 283, 321, 120, 120, 277, 239,
+ 647, 791, 833, 204, 638, 596, 658, 793, 183, 369,
+ 233, 183, 438, 438, 572, 191, 283, 443, 633, 710,
+ 820, 209, 818, 509, 233, 780, 233, 589, 236, 972,
+ 817, 858, 468, 520, 728, 472, 47, 48, 510, 511,
+ 512, 67, 68, 69, 70, 71, 72, 73, 74, 75,
+ 76, 0, 0, 0, 0, 396, 0, 397, 513, 0,
+ 514, 0, 0, 0, 0, 0, 0, 0, 398, 0,
+ 399, 400, 401, 0, 321, 402, 0, 443, 0, 0,
+ 0, 0, 0, 0, 0, 0, 0, 0, 0, 403,
+ 404, 405, 406, 407, 408, 0, 0, 0, 0, 283,
+ 120, 0, 0, 0, 0, 283, 0, 0, 0, 0,
+ 233, 0, 0, 0, 312, 0, 0, 47, 48, 127,
+ 294, 213, 67, 68, 69, 70, 71, 72, 73, 74,
+ 75, 76, 0, 0, 0, 0, 176, 0, 177, 295,
+ 0, 0, 91, 92, 93, 0, 233, 0, 0, 178,
+ 0, 179, 129, 0, 0, 283, 0, 0, 321, 0,
+ 0, 0, 443, 0, 0, 0, 0, 0, 249, 0,
+ 595, 0, 120, 0, 0, 0, 0, 0, 0, 0,
+ 443, 0, 283, 0, 0, 0, 0, 438, 0, 0,
0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 236, 0, 0, 0, 0, 0, 0,
0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
- 0, 0, 0, 283, 0, 183, 321, 233, 183, 0,
- 443, 0, 0, 0, 120, 0, 0, 0, 91, 92,
- 93, 233, 443, 233, 283, 236, 0, 0, 0, 438,
- 0, 0, 473, 47, 48, 511, 512, 513, 67, 68,
- 69, 70, 71, 72, 73, 74, 75, 76, 0, 0,
- 0, 0, 396, 0, 397, 514, 0, 515, 0, 0,
- 0, 0, 0, 0, 443, 398, 0, 399, 400, 401,
- 0, 0, 402, 0, 0, 0, 0, 0, 0, 0,
- 0, 0, 0, 0, 0, 0, 403, 404, 405, 406,
- 407, 408, 47, 48, 127, 294, 337, 67, 68, 69,
- 70, 71, 72, 73, 74, 75, 76, 233, 283, 0,
- 443, 221, 0, 223, 338, 0, 0, 0, 0, 0,
- 0, 0, 0, 0, 224, 0, 225, 0, 0, 0,
- 0, 0, 0, 0, 0, 0, 0, 0, 283, 91,
- 92, 93, 0, 0, 233, 0, 0, 0, 0, 129,
- 0, 0, 0, 0, 0, 0, 0, 906, 907, 908,
- 909, 910, 0, 0, 0, 0, 249, 0, 595, 0,
- 283, 47, 48, 0, 0, 0, 67, 68, 69, 70,
- 71, 72, 73, 74, 75, 76, 0, 0, 0, 0,
- 0, 0, 591, 0, 0, 0, 0, 948, 91, 92,
- 93, 236, 0, 0, 0, 0, 856, 857, 129, 0,
- 858, 0, 0, 0, 0, 0, 0, 0, 0, 0,
- 0, 0, 0, 0, 0, 0, 283, 0, 859, 0,
- 0, 0, 0, 0, 0, 283, 0, 0, 0, 0,
- 0, 0, 283, 0, 283, 0, 0, 0, 0, 0,
- 0, 0, 0, 0, 0, 0, 860, 861, 862, 863,
- 864, 0, 0, 0, 0, 0, 865, 866, 867, 868,
- 869, 870, 871, 872, 873, 0, 0, 91, 92, 93,
- 0, 0, 0, 0, 0, 0, 283, 0, 0, 0,
- 0, 0, 0, 283, 0, 236, 0, 0, 0, 0,
+ 0, 0, 443, 91, 92, 93, 0, 0, 283, 0,
+ 0, 0, 0, 129, 47, 48, 127, 294, 337, 67,
+ 68, 69, 70, 71, 72, 73, 74, 75, 76, 0,
+ 0, 0, 0, 221, 0, 223, 338, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0, 224, 0, 225, 0,
+ 0, 0, 0, 0, 0, 283, 0, 443, 47, 48,
+ 0, 0, 0, 67, 68, 69, 70, 71, 72, 73,
+ 74, 75, 76, 0, 0, 0, 0, 0, 236, 591,
+ 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 872, 873, 0, 0, 874, 0, 0,
+ 921, 922, 923, 924, 925, 0, 0, 0, 0, 0,
+ 0, 0, 0, 283, 0, 875, 0, 0, 0, 0,
+ 91, 92, 93, 0, 0, 0, 0, 0, 0, 0,
+ 129, 0, 0, 0, 0, 0, 0, 0, 0, 962,
+ 0, 0, 0, 876, 877, 878, 879, 880, 0, 595,
+ 0, 762, 0, 881, 882, 883, 884, 885, 886, 887,
+ 888, 889, 0, 0, 91, 92, 93, 283, 0, 0,
+ 0, 0, 0, 0, 233, 233, 283, 0, 0, 0,
+ 0, 0, 0, 283, 0, 283, 0, 65, 48, 0,
+ 0, 66, 67, 68, 69, 70, 71, 72, 73, 74,
+ 75, 76, 0, 0, 0, 0, 77, 0, 78, 0,
+ 0, 0, 0, 0, 0, 0, 0, 0, 0, 79,
+ 0, 80, 0, 0, 0, 0, 0, 283, 81, 82,
+ 83, 84, 85, 283, 0, 0, 0, 0, 0, 0,
0, 0, 0, 0, 0, 283, 0, 0, 0, 0,
0, 0, 0, 0, 0, 0, 0, 0, 0, 283,
+ 0, 0, 0, 0, 0, 0, 86, 87, 88, 89,
+ 90, 0, 283, 283, 283, 283, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 233, 0, 0, 0, 0,
+ 0, 0, 0, 91, 92, 93, 0, 0, 0, 0,
0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
- 0, 0, 0, 0, 283, 283, 283, 283, 65, 48,
- 0, 0, 66, 67, 68, 69, 70, 71, 72, 73,
- 74, 75, 76, 0, 0, 0, 0, 77, 0, 78,
- 0, 595, 0, 751, 0, 0, 0, 0, 0, 0,
- 79, 0, 80, 0, 0, 0, 0, 0, 0, 81,
- 82, 83, 84, 85, 0, 0, 233, 233, 0, 0,
- 0, 0, 0, 0, 47, 48, 0, 0, 395, 67,
- 68, 69, 70, 71, 72, 73, 74, 75, 76, 0,
- 0, 0, 0, 396, 508, 397, 0, 86, 87, 88,
- 89, 90, 0, 0, 0, 0, 398, 0, 399, 400,
- 401, 0, 0, 402, 0, 0, 0, 0, 0, 0,
- 0, 0, 0, 0, 91, 92, 93, 403, 404, 405,
- 406, 407, 408, 0, 0, 0, 0, 0, 47, 48,
- 0, 0, 395, 67, 68, 69, 70, 71, 72, 73,
- 74, 75, 76, 0, 0, 0, 0, 396, 0, 397,
- 702, 0, 0, 0, 0, 0, 233, 0, 0, 0,
- 398, 0, 399, 400, 401, 0, 0, 402, 0, 0,
- 91, 92, 93, 0, 0, 0, 0, 0, 0, 0,
- 878, 403, 404, 405, 406, 407, 408, 0, 0, 47,
- 48, 0, 0, 395, 67, 68, 69, 70, 71, 72,
- 73, 74, 75, 76, 0, 0, 878, 0, 396, 899,
- 397, 878, 878, 0, 0, 0, 0, 0, 0, 878,
- 878, 398, 0, 399, 400, 401, 0, 0, 402, 0,
- 0, 0, 0, 0, 91, 92, 93, 0, 0, 0,
- 0, 0, 403, 404, 405, 406, 407, 408, 0, 0,
+ 0, 894, 0, 0, 0, 0, 0, 0, 0, 0,
0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
- 0, 955, 0, 0, 0, 0, 0, 0, 0, 0,
- 878, 0, 0, 0, 0, 0, 0, 878, 878, 0,
- 0, 878, 974, 0, 0, 0, 0, 0, 0, 0,
- 878, 0, 0, 0, 0, 91, 92, 93, 0, 0,
+ 0, 0, 0, 0, 0, 894, 0, 0, 914, 0,
+ 894, 894, 0, 0, 0, 0, 0, 0, 894, 894,
0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
- 0, 878, 0, 0, 0, 0, 0, 0, 47, 48,
- 878, 0, 0, 67, 68, 69, 70, 71, 72, 73,
- 74, 75, 76, 0, 0, 0, 0, 396, 0, 397,
- 0, 878, 0, 0, 0, 0, 0, 0, 0, 0,
- 398, 0, 399, 400, 401, 0, 0, 402, 0, 0,
- 0, 0, 0, 0, 0, 0, 0, 0, 878, 0,
- 878, 403, 404, 405, 406, 407, 408, 0, 0, 0,
- 65, 48, 878, 0, 66, 67, 68, 69, 70, 71,
- 72, 73, 74, 75, 76, 0, 0, 47, 48, 77,
- 878, 78, 67, 68, 69, 70, 71, 72, 73, 74,
- 75, 76, 79, 0, 80, 0, 0, 985, 591, 878,
- 878, 0, 0, 0, 91, 92, 93, 47, 48, 0,
- 878, 0, 67, 68, 69, 70, 71, 72, 73, 74,
- 75, 76, 0, 0, 0, 0, 0, 0, 591, 0,
- 0, 0, 0, 0, 0, 0, 0, 0, 0, 86,
- 87, 88, 89, 90, 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0, 0, 47, 48, 0,
+ 0, 395, 67, 68, 69, 70, 71, 72, 73, 74,
+ 75, 76, 0, 0, 0, 0, 396, 507, 397, 969,
+ 0, 0, 0, 0, 0, 0, 0, 894, 0, 398,
+ 0, 399, 400, 401, 894, 894, 402, 0, 894, 988,
+ 0, 0, 0, 0, 0, 0, 0, 894, 0, 0,
+ 403, 404, 405, 406, 407, 408, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0, 0, 0, 894, 0,
+ 0, 0, 0, 0, 47, 48, 0, 894, 395, 67,
+ 68, 69, 70, 71, 72, 73, 74, 75, 76, 0,
+ 0, 0, 0, 396, 0, 397, 707, 0, 894, 0,
+ 0, 0, 0, 91, 92, 93, 398, 0, 399, 400,
+ 401, 0, 0, 402, 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 894, 0, 894, 403, 404, 405,
+ 406, 407, 408, 0, 0, 0, 894, 0, 0, 0,
0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
+ 0, 47, 48, 0, 894, 395, 67, 68, 69, 70,
+ 71, 72, 73, 74, 75, 76, 0, 0, 0, 0,
+ 396, 0, 397, 894, 894, 0, 0, 0, 0, 0,
+ 91, 92, 93, 398, 894, 399, 400, 401, 0, 0,
+ 402, 0, 0, 0, 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 403, 404, 405, 406, 407, 408,
+ 47, 48, 0, 0, 0, 67, 68, 69, 70, 71,
+ 72, 73, 74, 75, 76, 0, 0, 47, 48, 396,
+ 0, 397, 67, 68, 69, 70, 71, 72, 73, 74,
+ 75, 76, 398, 0, 399, 400, 401, 999, 591, 402,
+ 0, 0, 0, 0, 0, 0, 0, 91, 92, 93,
+ 0, 0, 0, 403, 404, 405, 406, 407, 408, 65,
+ 48, 0, 0, 66, 67, 68, 69, 70, 71, 72,
+ 73, 74, 75, 76, 0, 0, 47, 48, 77, 0,
+ 78, 67, 68, 69, 70, 71, 72, 73, 74, 75,
+ 76, 79, 0, 80, 0, 0, 0, 591, 0, 0,
0, 0, 0, 0, 0, 0, 91, 92, 93, 0,
- 0, 0, 0, 866, 867, 868, 869, 870, 871, 872,
- 873, 0, 0, 91, 92, 93, 0, 0, 0, 0,
+ 0, 0, 0, 882, 883, 884, 885, 886, 887, 888,
+ 889, 0, 0, 91, 92, 93, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0, 0, 0, 86, 87,
+ 88, 89, 90, 0, 0, 0, 0, 0, 0, 0,
0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
- 0, 0, 0, 866, 867, 868, 869, 870, 871, 872,
- 873, 0, 0, 91, 92, 93, 65, 48, 0, 0,
- 66, 67, 68, 69, 70, 71, 72, 73, 74, 75,
- 76, 0, 0, 0, 0, 77, 0, 78, 0, 0,
- 0, 0, 0, 0, 0, 0, 0, 0, 79, 0,
- 80, 47, 48, 0, 0, 220, 67, 68, 69, 70,
- 71, 72, 73, 74, 75, 76, 0, 0, 0, 0,
- 221, 222, 223, 0, 0, 0, 0, 0, 0, 0,
- 0, 0, 0, 224, 0, 225, 0, 0, 0, 0,
- 0, 0, 0, 0, 47, 48, 647, 648, 220, 67,
- 68, 69, 70, 71, 72, 73, 74, 75, 76, 0,
- 0, 0, 0, 221, 292, 223, 0, 0, 0, 0,
- 0, 0, 91, 92, 93, 0, 224, 0, 225, 47,
+ 0, 0, 0, 0, 0, 91, 92, 93, 0, 0,
+ 0, 0, 882, 883, 884, 885, 886, 887, 888, 889,
+ 0, 0, 91, 92, 93, 65, 48, 0, 0, 66,
+ 67, 68, 69, 70, 71, 72, 73, 74, 75, 76,
+ 0, 0, 0, 0, 77, 0, 78, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0, 0, 79, 0, 80,
+ 47, 48, 0, 0, 220, 67, 68, 69, 70, 71,
+ 72, 73, 74, 75, 76, 0, 0, 0, 0, 221,
+ 222, 223, 0, 0, 0, 0, 0, 0, 0, 0,
+ 0, 0, 224, 0, 225, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 651, 652, 653, 47, 48, 0,
+ 0, 220, 67, 68, 69, 70, 71, 72, 73, 74,
+ 75, 76, 0, 0, 0, 0, 221, 292, 223, 0,
+ 0, 91, 92, 93, 0, 0, 0, 0, 0, 224,
+ 0, 225, 47, 48, 0, 0, 220, 67, 68, 69,
+ 70, 71, 72, 73, 74, 75, 76, 0, 0, 0,
+ 0, 221, 335, 223, 0, 0, 91, 92, 93, 0,
+ 0, 0, 0, 0, 224, 0, 225, 47, 48, 0,
+ 0, 290, 67, 68, 69, 70, 71, 72, 73, 74,
+ 75, 76, 0, 0, 0, 0, 176, 0, 177, 0,
+ 0, 0, 0, 0, 0, 0, 0, 0, 0, 178,
+ 0, 179, 0, 91, 92, 93, 0, 0, 0, 47,
48, 0, 0, 220, 67, 68, 69, 70, 71, 72,
- 73, 74, 75, 76, 0, 0, 0, 0, 221, 335,
- 223, 0, 0, 0, 0, 0, 0, 91, 92, 93,
- 0, 224, 0, 225, 47, 48, 0, 0, 290, 67,
+ 73, 74, 75, 76, 0, 0, 0, 0, 221, 0,
+ 223, 0, 0, 0, 0, 0, 0, 0, 91, 92,
+ 93, 224, 0, 225, 47, 48, 0, 0, 0, 67,
68, 69, 70, 71, 72, 73, 74, 75, 76, 0,
0, 0, 0, 176, 0, 177, 0, 0, 0, 0,
- 0, 0, 0, 0, 0, 0, 178, 0, 179, 0,
- 91, 92, 93, 0, 0, 0, 47, 48, 0, 0,
- 220, 67, 68, 69, 70, 71, 72, 73, 74, 75,
- 76, 0, 0, 0, 0, 221, 0, 223, 0, 0,
- 0, 0, 0, 0, 0, 91, 92, 93, 224, 0,
- 225, 47, 48, 0, 0, 0, 67, 68, 69, 70,
+ 0, 0, 0, 91, 92, 93, 178, 0, 179, 47,
+ 48, 0, 0, 0, 67, 68, 69, 70, 71, 72,
+ 73, 74, 75, 76, 0, 0, 0, 0, 221, 0,
+ 223, 0, 0, 0, 0, 0, 0, 0, 0, 0,
+ 0, 224, 0, 225, 0, 91, 92, 93, 0, 0,
+ 0, 47, 48, 0, 0, 0, 67, 68, 69, 70,
71, 72, 73, 74, 75, 76, 0, 0, 0, 0,
- 221, 0, 223, 0, 0, 0, 0, 0, 0, 0,
- 91, 92, 93, 224, 0, 225, 47, 48, 0, 0,
- 0, 67, 68, 69, 70, 71, 72, 73, 74, 75,
- 76, 0, 0, 0, 0, 396, 0, 397, 0, 0,
- 0, 0, 0, 0, 0, 0, 0, 0, 398, 0,
- 399, 0, 91, 92, 93, 0, 0, 0, 0, 0,
+ 396, 0, 397, 0, 0, 0, 0, 0, 0, 0,
+ 91, 92, 93, 398, 0, 399, 0, 0, 0, 0,
0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
- 0, 0, 0, 0, 0, 0, 0, 91, 92, 93,
+ 0, 0, 0, 0, 0, 91, 92, 93, 0, 0,
0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
- 0, 0, 91, 92, 93
+ 0, 0, 0, 0, 0, 0, 0, 91, 92, 93
};
static const short yycheck[] = { 29,
- 24, 49, 37, 404, 11, 810, 27, 111, 43, 86,
- 87, 88, 31, 90, 37, 22, 31, 460, 227, 117,
- 43, 112, 268, 223, 113, 269, 504, 36, 284, 37,
- 26, 110, 251, 176, 135, 43, 255, 283, 111, 395,
- 113, 251, 4, 117, 550, 255, 11, 251, 251, 558,
- 559, 255, 255, 114, 106, 29, 959, 175, 135, 177,
- 665, 719, 24, 5, 669, 7, 52, 115, 574, 575,
- 94, 4, 70, 731, 26, 26, 106, 26, 221, 36,
- 70, 179, 70, 36, 114, 115, 116, 117, 165, 77,
- 3, 87, 5, 6, 7, 30, 185, 1000, 106, 73,
- 847, 3, 123, 581, 134, 179, 114, 115, 116, 117,
- 119, 54, 917, 173, 162, 30, 140, 69, 69, 117,
- 5, 6, 7, 144, 89, 58, 28, 225, 118, 177,
- 339, 229, 879, 68, 29, 142, 171, 197, 198, 582,
- 238, 397, 27, 4, 106, 175, 176, 177, 171, 179,
- 251, 225, 213, 68, 255, 229, 23, 513, 210, 26,
- 893, 819, 119, 171, 238, 217, 119, 175, 176, 177,
- 65, 179, 905, 68, 251, 223, 3, 119, 255, 31,
- 210, 844, 787, 213, 26, 663, 329, 217, 397, 31,
- 139, 221, 438, 223, 143, 225, 902, 24, 442, 229,
- 343, 299, 210, 449, 308, 213, 119, 237, 238, 217,
- 270, 302, 330, 221, 723, 223, 68, 225, 278, 31,
- 883, 229, 24, 104, 303, 299, 435, 257, 31, 290,
- 238, 189, 738, 191, 119, 324, 194, 481, 70, 399,
- 285, 5, 6, 7, 29, 29, 306, 79, 80, 347,
- 24, 209, 412, 55, 28, 474, 68, 3, 318, 992,
- 290, 365, 518, 67, 474, 68, 744, 745, 974, 299,
- 474, 474, 53, 347, 3, 327, 70, 366, 24, 535,
- 65, 65, 290, 936, 363, 364, 429, 81, 941, 29,
- 363, 299, 365, 366, 4, 24, 62, 327, 64, 329,
- 330, 1034, 1035, 322, 747, 3, 4, 322, 6, 1015,
- 1016, 1017, 1018, 343, 24, 345, 45, 347, 47, 327,
- 18, 329, 330, 466, 22, 65, 24, 4, 68, 27,
- 390, 355, 3, 393, 215, 343, 4, 345, 368, 347,
- 5, 6, 7, 18, 433, 375, 304, 24, 369, 397,
- 828, 396, 397, 24, 22, 119, 24, 402, 614, 1012,
- 25, 26, 27, 408, 6, 24, 5, 6, 7, 529,
- 530, 531, 532, 474, 434, 853, 19, 537, 21, 6,
- 425, 147, 401, 264, 26, 27, 401, 488, 27, 155,
- 636, 157, 452, 6, 33, 455, 94, 474, 69, 429,
- 27, 4, 73, 24, 423, 459, 4, 28, 423, 3,
- 291, 488, 25, 26, 27, 296, 476, 3, 4, 496,
- 21, 429, 25, 458, 459, 523, 24, 671, 3, 4,
- 24, 450, 24, 1, 494, 450, 466, 497, 24, 499,
- 32, 471, 19, 871, 872, 41, 5, 6, 7, 24,
- 458, 459, 20, 8, 119, 546, 547, 487, 466, 550,
- 490, 621, 368, 623, 624, 625, 25, 26, 27, 375,
- 524, 525, 49, 50, 51, 579, 3, 4, 538, 1007,
- 119, 558, 559, 574, 575, 539, 540, 8, 533, 524,
- 525, 8, 23, 523, 583, 26, 26, 24, 577, 3,
- 4, 929, 930, 33, 539, 540, 36, 21, 708, 709,
- 1038, 1039, 1040, 3, 942, 523, 524, 525, 578, 617,
- 24, 25, 41, 558, 559, 5, 6, 7, 409, 78,
- 31, 539, 540, 935, 24, 639, 937, 938, 53, 563,
- 41, 422, 944, 591, 565, 25, 70, 27, 4, 951,
- 558, 559, 76, 8, 44, 45, 46, 47, 206, 768,
- 119, 26, 607, 26, 29, 3, 4, 32, 613, 32,
- 647, 648, 99, 100, 101, 102, 103, 104, 105, 106,
- 18, 462, 627, 8, 22, 23, 24, 617, 56, 57,
- 58, 59, 1020, 995, 618, 19, 656, 21, 619, 11,
- 1002, 620, 662, 25, 26, 620, 1034, 631, 808, 617,
- 33, 632, 1014, 70, 71, 19, 70, 21, 75, 73,
- 268, 23, 657, 21, 26, 649, 112, 113, 114, 115,
- 116, 19, 653, 21, 657, 283, 517, 23, 25, 119,
- 26, 1043, 1044, 1045, 1046, 722, 723, 738, 26, 657,
- 28, 696, 712, 683, 684, 93, 94, 23, 3, 4,
- 26, 309, 310, 21, 23, 3, 4, 26, 6, 773,
- 19, 319, 21, 733, 3, 4, 29, 30, 708, 709,
- 18, 4, 23, 26, 22, 26, 24, 25, 723, 18,
- 3, 4, 19, 22, 21, 24, 25, 49, 50, 51,
- 708, 709, 3, 4, 19, 18, 21, 3, 4, 22,
- 755, 24, 3, 4, 4, 723, 761, 33, 763, 764,
- 765, 798, 18, 24, 25, 770, 22, 19, 24, 21,
- 87, 32, 380, 24, 615, 4, 743, 530, 531, 532,
- 8, 9, 766, 25, 26, 87, 394, 628, 769, 25,
- 26, 25, 26, 25, 26, 93, 94, 817, 3, 4,
- 73, 791, 858, 36, 93, 94, 8, 863, 864, 25,
- 26, 3, 4, 18, 70, 25, 26, 22, 808, 24,
- 29, 94, 25, 26, 3, 4, 30, 847, 37, 3,
- 438, 3, 4, 838, 43, 31, 841, 93, 94, 18,
- 808, 449, 832, 22, 30, 24, 97, 31, 99, 100,
- 101, 102, 103, 104, 105, 106, 18, 3, 4, 879,
- 28, 851, 3, 4, 832, 70, 922, 28, 858, 25,
- 26, 31, 18, 863, 864, 25, 22, 933, 24, 884,
- 89, 871, 872, 24, 25, 25, 26, 23, 93, 94,
- 858, 32, 25, 26, 25, 863, 864, 25, 26, 36,
- 109, 110, 111, 112, 113, 6, 873, 963, 25, 3,
- 4, 25, 6, 26, 93, 94, 972, 907, 908, 24,
- 910, 25, 26, 913, 18, 134, 25, 26, 22, 24,
- 24, 898, 922, 27, 107, 108, 27, 993, 64, 929,
- 930, 549, 27, 933, 87, 553, 554, 94, 94, 557,
- 28, 160, 942, 87, 922, 28, 29, 95, 96, 41,
- 3, 4, 171, 30, 173, 933, 1022, 1063, 1064, 23,
- 25, 939, 940, 963, 942, 18, 185, 41, 31, 22,
- 4, 24, 972, 23, 193, 28, 3, 4, 197, 198,
- 8, 23, 4, 26, 33, 963, 1052, 206, 3, 4,
- 94, 18, 21, 993, 972, 22, 87, 24, 25, 24,
- 24, 1001, 8, 18, 30, 1071, 1072, 22, 17, 24,
- 17, 3, 4, 11, 30, 993, 1082, 36, 636, 23,
- 1020, 41, 1022, 25, 25, 25, 18, 8, 25, 68,
- 22, 30, 24, 94, 1034, 1053, 31, 31, 257, 8,
- 31, 94, 1020, 23, 1022, 62, 25, 3, 4, 268,
- 269, 270, 1052, 25, 43, 29, 19, 1035, 25, 278,
- 25, 25, 18, 21, 283, 25, 22, 94, 24, 8,
- 25, 1071, 1072, 25, 1052, 68, 64, 25, 27, 94,
- 66, 66, 1082, 302, 303, 69, 31, 306, 26, 308,
- 309, 310, 25, 1071, 1072, 87, 36, 715, 21, 318,
- 319, 19, 94, 28, 1082, 324, 8, 9, 10, 11,
- 12, 13, 14, 15, 16, 17, 22, 68, 3, 4,
- 5, 6, 7, 8, 9, 10, 11, 12, 13, 14,
- 15, 16, 17, 69, 68, 23, 26, 22, 94, 24,
- 25, 25, 74, 40, 363, 364, 365, 366, 28, 368,
- 35, 40, 37, 63, 68, 26, 375, 69, 69, 72,
- 21, 380, 69, 87, 18, 87, 26, 23, 34, 22,
- 69, 390, 30, 8, 393, 394, 22, 28, 26, 19,
- 8, 18, 18, 3, 3, 4, 5, 6, 7, 8,
- 9, 10, 11, 12, 13, 14, 15, 16, 17, 26,
- 18, 4, 24, 22, 43, 24, 25, 109, 110, 111,
- 22, 22, 18, 22, 433, 434, 35, 24, 37, 438,
- 8, 8, 3, 442, 109, 110, 111, 18, 30, 11,
- 449, 11, 30, 452, 119, 19, 455, 8, 24, 458,
- 459, 33, 11, 11, 11, 11, 18, 8, 9, 10,
- 11, 12, 13, 14, 15, 16, 17, 476, 18, 18,
- 18, 40, 481, 24, 19, 19, 19, 11, 487, 25,
- 11, 11, 137, 25, 106, 494, 26, 25, 497, 28,
- 499, 28, 114, 115, 116, 117, 19, 19, 19, 40,
- 109, 110, 111, 19, 0, 25, 25, 25, 25, 21,
- 119, 21, 0, 135, 134, 524, 525, 487, 668, 785,
- 677, 742, 500, 729, 915, 887, 1001, 851, 817, 538,
- 539, 540, 1035, 992, 1057, 1020, 1028, 546, 547, 548,
- 549, 550, 18, 18, 553, 554, 97, 41, 557, 558,
- 559, 678, 683, 175, 176, 177, 57, 179, 109, 110,
- 111, 252, 57, 43, 171, 574, 575, 121, 577, 578,
- 579, 551, 721, 494, 583, 497, 474, 112, 255, 723,
- 547, 488, 559, 541, 761, 396, 617, 758, 210, 709,
- 808, 213, 917, 756, 345, 217, 397, -1, 553, 221,
- -1, 223, -1, 225, -1, -1, -1, 229, -1, -1,
- -1, -1, 3, 4, -1, -1, 238, 8, 9, 10,
- 11, 12, 13, 14, 15, 16, 17, 636, -1, -1,
- 639, 22, -1, 24, -1, -1, -1, -1, -1, -1,
- -1, -1, -1, -1, 35, -1, 37, 656, 657, -1,
- -1, -1, -1, 662, -1, -1, -1, -1, -1, -1,
- -1, -1, 671, -1, -1, -1, -1, -1, 290, -1,
- -1, -1, -1, -1, -1, -1, -1, 299, -1, -1,
- -1, -1, -1, -1, -1, -1, -1, -1, -1, -1,
+ 11, 49, 37, 24, 37, 31, 404, 111, 43, 27,
+ 43, 22, 223, 86, 87, 88, 268, 90, 227, 503,
+ 189, 269, 191, 113, 284, 194, 251, 110, 459, 37,
+ 255, 283, 117, 112, 31, 43, 826, 106, 549, 135,
+ 209, 104, 11, 251, 251, 3, 29, 255, 255, 26,
+ 111, 251, 113, 117, 496, 255, 395, 724, 176, 31,
+ 558, 559, 135, 574, 575, 114, 24, 115, 4, 175,
+ 670, 177, 70, 94, 674, 742, 106, 3, 5, 6,
+ 7, 908, 26, 81, 114, 115, 116, 117, 54, 26,
+ 73, 29, 165, 920, 179, 185, 68, 581, 106, 25,
+ 27, 887, 888, 221, 134, 123, 114, 115, 116, 117,
+ 70, 69, 52, 555, 162, 179, 4, 77, 30, 140,
+ 89, 3, 58, 5, 6, 7, 144, 65, 70, 177,
+ 339, 142, 5, 6, 7, 304, 171, 397, 171, 917,
+ 225, 210, 932, 87, 229, 175, 176, 177, 217, 179,
+ 87, 582, 215, 238, 27, 251, 68, 943, 944, 255,
+ 33, 225, 139, 171, 213, 229, 143, 175, 176, 177,
+ 956, 179, 839, 512, 238, 223, 118, 4, 251, 1006,
+ 210, 36, 255, 213, 668, 31, 438, 217, 397, 25,
+ 26, 221, 119, 223, 36, 225, 448, 24, 5, 229,
+ 7, 264, 210, 803, 308, 213, 26, 237, 238, 217,
+ 988, 329, 36, 221, 299, 223, 70, 225, 1045, 1046,
+ 303, 229, 68, 302, 330, 343, 435, 257, 291, 67,
+ 238, 310, 480, 296, 324, 299, 734, 119, 749, 206,
+ 30, 290, 23, 173, 24, 26, 119, 1033, 473, 69,
+ 1028, 1029, 1030, 1031, 5, 6, 7, 517, 327, 1045,
+ 290, 365, 347, 117, 119, 473, 473, 197, 198, 299,
+ 29, 755, 756, 473, 534, 55, 366, 119, 68, 106,
+ 363, 364, 290, 347, 53, 950, 26, 5, 6, 7,
+ 955, 299, 18, 31, 285, 119, 322, 327, 4, 329,
+ 330, 268, 363, 3, 365, 366, 65, 25, 26, 27,
+ 24, 429, 119, 343, 1, 345, 283, 347, 24, 327,
+ 862, 329, 330, 3, 24, 322, 31, 758, 458, 69,
+ 68, 3, 21, 20, 355, 343, 41, 345, 368, 347,
+ 270, 3, 4, 433, 24, 375, 409, 465, 278, 397,
+ 18, 369, 319, 62, 614, 64, 28, 899, 4, 422,
+ 1025, 24, 846, 25, 44, 45, 46, 47, 119, 32,
+ 5, 6, 7, 21, 3, 401, 306, 473, 24, 309,
+ 310, 550, 551, 24, 636, 869, 41, 28, 318, 368,
+ 25, 487, 27, 523, 524, 24, 375, 423, 461, 429,
+ 473, 119, 70, 71, 401, 396, 397, 75, 538, 539,
+ 3, 402, 4, 380, 487, 29, 45, 408, 47, 903,
+ 6, 429, 495, 449, 457, 458, 423, 394, 676, 26,
+ 22, 24, 24, 29, 425, 465, 33, 522, 147, 36,
+ 470, 27, 23, 3, 4, 26, 155, 4, 157, 457,
+ 458, 65, 449, 516, 68, 3, 486, 465, 18, 489,
+ 390, 8, 22, 393, 24, 25, 545, 546, 25, 65,
+ 549, 438, 68, 8, 399, 579, 24, 646, 5, 6,
+ 7, 448, 1020, 70, 119, 558, 559, 412, 19, 76,
+ 523, 524, 522, 583, 577, 574, 575, 8, 25, 26,
+ 27, 26, 713, 714, 434, 538, 539, 32, 3, 4,
+ 53, 1049, 1050, 1051, 522, 523, 524, 6, 49, 50,
+ 51, 451, 41, 18, 454, 558, 559, 22, 23, 24,
+ 538, 539, 617, 93, 94, 639, 25, 26, 27, 3,
+ 4, 532, 563, 591, 78, 475, 70, 565, 3, 4,
+ 558, 559, 615, 951, 952, 79, 80, 726, 727, 728,
+ 24, 25, 8, 493, 6, 628, 496, 4, 498, 24,
+ 779, 4, 3, 4, 8, 3, 4, 26, 651, 652,
+ 653, 548, 31, 874, 26, 27, 949, 617, 879, 880,
+ 557, 24, 119, 24, 620, 958, 24, 618, 93, 94,
+ 4, 619, 965, 528, 529, 530, 531, 537, 24, 617,
+ 631, 536, 28, 824, 632, 26, 607, 28, 22, 11,
+ 24, 23, 613, 620, 26, 555, 556, 662, 23, 662,
+ 19, 26, 21, 654, 3, 4, 627, 33, 26, 23,
+ 658, 29, 26, 21, 32, 936, 1009, 70, 578, 18,
+ 73, 25, 1015, 22, 662, 24, 947, 21, 688, 689,
+ 733, 734, 831, 23, 1027, 26, 26, 3, 4, 636,
+ 749, 99, 100, 101, 102, 103, 104, 105, 106, 19,
+ 784, 21, 4, 713, 714, 19, 977, 21, 24, 3,
+ 4, 1054, 1055, 1056, 1057, 986, 621, 4, 623, 624,
+ 625, 734, 70, 71, 33, 713, 714, 75, 3, 4,
+ 701, 6, 4, 3, 4, 19, 1007, 21, 87, 29,
+ 30, 3, 4, 18, 6, 94, 734, 22, 18, 24,
+ 25, 661, 22, 87, 24, 25, 18, 667, 8, 9,
+ 22, 814, 24, 754, 1035, 27, 112, 113, 114, 115,
+ 116, 8, 19, 720, 21, 87, 777, 3, 4, 25,
+ 26, 97, 780, 99, 100, 101, 102, 103, 104, 105,
+ 106, 19, 1063, 21, 19, 766, 21, 807, 24, 25,
+ 19, 772, 21, 774, 775, 776, 32, 717, 3, 4,
+ 781, 1082, 1083, 36, 824, 49, 50, 51, 93, 94,
+ 25, 26, 1093, 93, 94, 25, 26, 29, 31, 24,
+ 25, 30, 94, 3, 744, 37, 824, 32, 25, 26,
+ 850, 43, 8, 9, 10, 11, 12, 13, 14, 15,
+ 16, 17, 56, 57, 58, 59, 30, 867, 24, 31,
+ 3, 4, 850, 6, 874, 529, 530, 531, 18, 879,
+ 880, 25, 26, 3, 4, 18, 28, 887, 888, 22,
+ 790, 24, 3, 4, 27, 856, 874, 89, 859, 25,
+ 26, 879, 880, 25, 26, 3, 4, 18, 889, 25,
+ 26, 22, 31, 24, 28, 25, 26, 109, 110, 111,
+ 112, 113, 922, 923, 25, 925, 25, 26, 928, 25,
+ 26, 25, 913, 25, 26, 23, 936, 837, 6, 900,
+ 25, 97, 134, 943, 944, 25, 26, 947, 25, 26,
+ 25, 26, 36, 109, 110, 111, 956, 26, 936, 70,
+ 25, 94, 107, 108, 28, 29, 95, 96, 160, 947,
+ 3, 4, 1074, 1075, 24, 953, 954, 977, 956, 171,
+ 24, 173, 93, 94, 27, 18, 986, 27, 64, 22,
+ 87, 24, 87, 185, 94, 895, 28, 23, 25, 977,
+ 41, 193, 30, 41, 4, 197, 198, 1007, 986, 31,
+ 23, 8, 23, 4, 206, 3, 4, 26, 8, 9,
+ 10, 11, 12, 13, 14, 15, 16, 17, 33, 1007,
+ 18, 24, 21, 1033, 22, 1035, 24, 70, 24, 87,
+ 28, 17, 17, 3, 4, 1045, 1064, 30, 11, 36,
+ 8, 3, 4, 30, 23, 1033, 26, 1035, 18, 41,
+ 93, 94, 22, 1063, 24, 257, 18, 28, 1046, 25,
+ 22, 25, 24, 25, 8, 30, 268, 269, 270, 3,
+ 4, 31, 1082, 1083, 31, 1063, 278, 31, 3, 4,
+ 94, 283, 8, 1093, 18, 68, 23, 25, 22, 25,
+ 24, 43, 25, 18, 1082, 1083, 94, 22, 29, 24,
+ 302, 303, 25, 25, 306, 1093, 308, 309, 310, 109,
+ 110, 111, 62, 19, 21, 25, 318, 319, 64, 3,
+ 4, 25, 324, 93, 94, 68, 25, 25, 69, 8,
+ 3, 4, 94, 27, 18, 31, 66, 66, 22, 73,
+ 24, 23, 25, 36, 21, 18, 22, 106, 19, 22,
+ 28, 24, 69, 68, 74, 114, 115, 116, 117, 68,
+ 94, 363, 364, 365, 366, 23, 368, 26, 25, 94,
+ 40, 40, 28, 375, 63, 26, 135, 68, 380, 33,
+ 72, 69, 69, 21, 25, 87, 87, 18, 390, 69,
+ 26, 393, 394, 3, 4, 5, 6, 7, 8, 9,
+ 10, 11, 12, 13, 14, 15, 16, 17, 23, 34,
+ 94, 30, 22, 8, 24, 25, 175, 176, 177, 22,
+ 179, 94, 28, 19, 8, 35, 18, 37, 18, 3,
+ 18, 433, 434, 26, 4, 24, 438, 22, 43, 22,
+ 442, 18, 24, 22, 19, 8, 448, 3, 19, 451,
+ 30, 210, 454, 18, 213, 457, 458, 11, 217, 11,
+ 24, 30, 221, 8, 223, 33, 225, 11, 11, 11,
+ 229, 11, 18, 475, 40, 25, 11, 18, 480, 238,
+ 18, 18, 11, 19, 486, 19, 19, 11, 0, 40,
+ 137, 493, 19, 25, 496, 25, 498, 28, 19, 109,
+ 110, 111, 28, 19, 19, 25, 25, 25, 25, 119,
+ 21, 21, 0, 134, 673, 486, 801, 682, 499, 753,
+ 740, 523, 524, 1014, 930, 895, 867, 837, 1006, 1046,
+ 1068, 290, 1033, 1041, 18, 537, 538, 539, 18, 41,
+ 299, 683, 43, 545, 546, 547, 548, 549, 57, 551,
+ 688, 57, 252, 555, 556, 557, 558, 559, 171, 121,
+ 552, 732, 790, 112, 546, 493, 559, 734, 327, 255,
+ 329, 330, 574, 575, 473, 577, 578, 579, 540, 617,
+ 772, 583, 769, 396, 343, 714, 345, 487, 347, 932,
+ 767, 824, 345, 397, 646, 354, 3, 4, 5, 6,
+ 7, 8, 9, 10, 11, 12, 13, 14, 15, 16,
+ 17, -1, -1, -1, -1, 22, -1, 24, 25, -1,
+ 27, -1, -1, -1, -1, -1, -1, -1, 35, -1,
+ 37, 38, 39, -1, 636, 42, -1, 639, -1, -1,
+ -1, -1, -1, -1, -1, -1, -1, -1, -1, 56,
+ 57, 58, 59, 60, 61, -1, -1, -1, -1, 661,
+ 662, -1, -1, -1, -1, 667, -1, -1, -1, -1,
+ 429, -1, -1, -1, 676, -1, -1, 3, 4, 5,
+ 6, 7, 8, 9, 10, 11, 12, 13, 14, 15,
+ 16, 17, -1, -1, -1, -1, 22, -1, 24, 25,
+ -1, -1, 109, 110, 111, -1, 465, -1, -1, 35,
+ -1, 37, 119, -1, -1, 717, -1, -1, 720, -1,
+ -1, -1, 724, -1, -1, -1, -1, -1, 487, -1,
+ 489, -1, 734, -1, -1, -1, -1, -1, -1, -1,
+ 742, -1, 744, -1, -1, -1, -1, 749, -1, -1,
-1, -1, -1, -1, -1, -1, -1, -1, -1, -1,
- -1, -1, -1, 712, -1, 327, 715, 329, 330, -1,
- 719, -1, -1, -1, 723, -1, -1, -1, 109, 110,
- 111, 343, 731, 345, 733, 347, -1, -1, -1, 738,
- -1, -1, 354, 3, 4, 5, 6, 7, 8, 9,
- 10, 11, 12, 13, 14, 15, 16, 17, -1, -1,
- -1, -1, 22, -1, 24, 25, -1, 27, -1, -1,
- -1, -1, -1, -1, 773, 35, -1, 37, 38, 39,
- -1, -1, 42, -1, -1, -1, -1, -1, -1, -1,
- -1, -1, -1, -1, -1, -1, 56, 57, 58, 59,
- 60, 61, 3, 4, 5, 6, 7, 8, 9, 10,
- 11, 12, 13, 14, 15, 16, 17, 429, 817, -1,
- 819, 22, -1, 24, 25, -1, -1, -1, -1, -1,
- -1, -1, -1, -1, 35, -1, 37, -1, -1, -1,
- -1, -1, -1, -1, -1, -1, -1, -1, 847, 109,
- 110, 111, -1, -1, 466, -1, -1, -1, -1, 119,
- -1, -1, -1, -1, -1, -1, -1, 866, 867, 868,
- 869, 870, -1, -1, -1, -1, 488, -1, 490, -1,
- 879, 3, 4, -1, -1, -1, 8, 9, 10, 11,
- 12, 13, 14, 15, 16, 17, -1, -1, -1, -1,
- -1, -1, 24, -1, -1, -1, -1, 906, 109, 110,
- 111, 523, -1, -1, -1, -1, 38, 39, 119, -1,
- 42, -1, -1, -1, -1, -1, -1, -1, -1, -1,
- -1, -1, -1, -1, -1, -1, 935, -1, 60, -1,
- -1, -1, -1, -1, -1, 944, -1, -1, -1, -1,
- -1, -1, 951, -1, 953, -1, -1, -1, -1, -1,
- -1, -1, -1, -1, -1, -1, 88, 89, 90, 91,
- 92, -1, -1, -1, -1, -1, 98, 99, 100, 101,
- 102, 103, 104, 105, 106, -1, -1, 109, 110, 111,
- -1, -1, -1, -1, -1, -1, 995, -1, -1, -1,
- -1, -1, -1, 1002, -1, 617, -1, -1, -1, -1,
- -1, -1, -1, -1, -1, 1014, -1, -1, -1, -1,
- -1, -1, -1, -1, -1, -1, -1, -1, -1, 1028,
+ -1, -1, -1, 522, -1, -1, -1, -1, -1, -1,
-1, -1, -1, -1, -1, -1, -1, -1, -1, -1,
- -1, -1, -1, -1, 1043, 1044, 1045, 1046, 3, 4,
- -1, -1, 7, 8, 9, 10, 11, 12, 13, 14,
- 15, 16, 17, -1, -1, -1, -1, 22, -1, 24,
- -1, 683, -1, 685, -1, -1, -1, -1, -1, -1,
- 35, -1, 37, -1, -1, -1, -1, -1, -1, 44,
- 45, 46, 47, 48, -1, -1, 708, 709, -1, -1,
- -1, -1, -1, -1, 3, 4, -1, -1, 7, 8,
+ -1, -1, 784, 109, 110, 111, -1, -1, 790, -1,
+ -1, -1, -1, 119, 3, 4, 5, 6, 7, 8,
9, 10, 11, 12, 13, 14, 15, 16, 17, -1,
- -1, -1, -1, 22, 23, 24, -1, 82, 83, 84,
- 85, 86, -1, -1, -1, -1, 35, -1, 37, 38,
- 39, -1, -1, 42, -1, -1, -1, -1, -1, -1,
- -1, -1, -1, -1, 109, 110, 111, 56, 57, 58,
- 59, 60, 61, -1, -1, -1, -1, -1, 3, 4,
- -1, -1, 7, 8, 9, 10, 11, 12, 13, 14,
- 15, 16, 17, -1, -1, -1, -1, 22, -1, 24,
- 25, -1, -1, -1, -1, -1, 808, -1, -1, -1,
- 35, -1, 37, 38, 39, -1, -1, 42, -1, -1,
+ -1, -1, -1, 22, -1, 24, 25, -1, -1, -1,
+ -1, -1, -1, -1, -1, -1, 35, -1, 37, -1,
+ -1, -1, -1, -1, -1, 837, -1, 839, 3, 4,
+ -1, -1, -1, 8, 9, 10, 11, 12, 13, 14,
+ 15, 16, 17, -1, -1, -1, -1, -1, 617, 24,
+ -1, -1, -1, -1, -1, -1, -1, -1, -1, -1,
+ -1, -1, -1, 38, 39, -1, -1, 42, -1, -1,
+ 882, 883, 884, 885, 886, -1, -1, -1, -1, -1,
+ -1, -1, -1, 895, -1, 60, -1, -1, -1, -1,
109, 110, 111, -1, -1, -1, -1, -1, -1, -1,
- 832, 56, 57, 58, 59, 60, 61, -1, -1, 3,
- 4, -1, -1, 7, 8, 9, 10, 11, 12, 13,
- 14, 15, 16, 17, -1, -1, 858, -1, 22, 861,
- 24, 863, 864, -1, -1, -1, -1, -1, -1, 871,
- 872, 35, -1, 37, 38, 39, -1, -1, 42, -1,
- -1, -1, -1, -1, 109, 110, 111, -1, -1, -1,
- -1, -1, 56, 57, 58, 59, 60, 61, -1, -1,
+ 119, -1, -1, -1, -1, -1, -1, -1, -1, 921,
+ -1, -1, -1, 88, 89, 90, 91, 92, -1, 688,
+ -1, 690, -1, 98, 99, 100, 101, 102, 103, 104,
+ 105, 106, -1, -1, 109, 110, 111, 949, -1, -1,
+ -1, -1, -1, -1, 713, 714, 958, -1, -1, -1,
+ -1, -1, -1, 965, -1, 967, -1, 3, 4, -1,
+ -1, 7, 8, 9, 10, 11, 12, 13, 14, 15,
+ 16, 17, -1, -1, -1, -1, 22, -1, 24, -1,
+ -1, -1, -1, -1, -1, -1, -1, -1, -1, 35,
+ -1, 37, -1, -1, -1, -1, -1, 1009, 44, 45,
+ 46, 47, 48, 1015, -1, -1, -1, -1, -1, -1,
+ -1, -1, -1, -1, -1, 1027, -1, -1, -1, -1,
+ -1, -1, -1, -1, -1, -1, -1, -1, -1, 1041,
+ -1, -1, -1, -1, -1, -1, 82, 83, 84, 85,
+ 86, -1, 1054, 1055, 1056, 1057, -1, -1, -1, -1,
+ -1, -1, -1, -1, -1, 824, -1, -1, -1, -1,
+ -1, -1, -1, 109, 110, 111, -1, -1, -1, -1,
-1, -1, -1, -1, -1, -1, -1, -1, -1, -1,
- -1, 913, -1, -1, -1, -1, -1, -1, -1, -1,
- 922, -1, -1, -1, -1, -1, -1, 929, 930, -1,
- -1, 933, 934, -1, -1, -1, -1, -1, -1, -1,
- 942, -1, -1, -1, -1, 109, 110, 111, -1, -1,
+ -1, 850, -1, -1, -1, -1, -1, -1, -1, -1,
-1, -1, -1, -1, -1, -1, -1, -1, -1, -1,
- -1, 963, -1, -1, -1, -1, -1, -1, 3, 4,
- 972, -1, -1, 8, 9, 10, 11, 12, 13, 14,
- 15, 16, 17, -1, -1, -1, -1, 22, -1, 24,
- -1, 993, -1, -1, -1, -1, -1, -1, -1, -1,
- 35, -1, 37, 38, 39, -1, -1, 42, -1, -1,
- -1, -1, -1, -1, -1, -1, -1, -1, 1020, -1,
- 1022, 56, 57, 58, 59, 60, 61, -1, -1, -1,
- 3, 4, 1034, -1, 7, 8, 9, 10, 11, 12,
- 13, 14, 15, 16, 17, -1, -1, 3, 4, 22,
- 1052, 24, 8, 9, 10, 11, 12, 13, 14, 15,
- 16, 17, 35, -1, 37, -1, -1, 23, 24, 1071,
- 1072, -1, -1, -1, 109, 110, 111, 3, 4, -1,
- 1082, -1, 8, 9, 10, 11, 12, 13, 14, 15,
- 16, 17, -1, -1, -1, -1, -1, -1, 24, -1,
- -1, -1, -1, -1, -1, -1, -1, -1, -1, 82,
- 83, 84, 85, 86, -1, -1, -1, -1, -1, -1,
+ -1, -1, -1, -1, -1, 874, -1, -1, 877, -1,
+ 879, 880, -1, -1, -1, -1, -1, -1, 887, 888,
+ -1, -1, -1, -1, -1, -1, -1, -1, -1, -1,
+ -1, -1, -1, -1, -1, -1, -1, 3, 4, -1,
+ -1, 7, 8, 9, 10, 11, 12, 13, 14, 15,
+ 16, 17, -1, -1, -1, -1, 22, 23, 24, 928,
+ -1, -1, -1, -1, -1, -1, -1, 936, -1, 35,
+ -1, 37, 38, 39, 943, 944, 42, -1, 947, 948,
+ -1, -1, -1, -1, -1, -1, -1, 956, -1, -1,
+ 56, 57, 58, 59, 60, 61, -1, -1, -1, -1,
+ -1, -1, -1, -1, -1, -1, -1, -1, 977, -1,
+ -1, -1, -1, -1, 3, 4, -1, 986, 7, 8,
+ 9, 10, 11, 12, 13, 14, 15, 16, 17, -1,
+ -1, -1, -1, 22, -1, 24, 25, -1, 1007, -1,
+ -1, -1, -1, 109, 110, 111, 35, -1, 37, 38,
+ 39, -1, -1, 42, -1, -1, -1, -1, -1, -1,
+ -1, -1, -1, -1, 1033, -1, 1035, 56, 57, 58,
+ 59, 60, 61, -1, -1, -1, 1045, -1, -1, -1,
-1, -1, -1, -1, -1, -1, -1, -1, -1, -1,
+ -1, 3, 4, -1, 1063, 7, 8, 9, 10, 11,
+ 12, 13, 14, 15, 16, 17, -1, -1, -1, -1,
+ 22, -1, 24, 1082, 1083, -1, -1, -1, -1, -1,
+ 109, 110, 111, 35, 1093, 37, 38, 39, -1, -1,
+ 42, -1, -1, -1, -1, -1, -1, -1, -1, -1,
+ -1, -1, -1, -1, 56, 57, 58, 59, 60, 61,
+ 3, 4, -1, -1, -1, 8, 9, 10, 11, 12,
+ 13, 14, 15, 16, 17, -1, -1, 3, 4, 22,
+ -1, 24, 8, 9, 10, 11, 12, 13, 14, 15,
+ 16, 17, 35, -1, 37, 38, 39, 23, 24, 42,
+ -1, -1, -1, -1, -1, -1, -1, 109, 110, 111,
+ -1, -1, -1, 56, 57, 58, 59, 60, 61, 3,
+ 4, -1, -1, 7, 8, 9, 10, 11, 12, 13,
+ 14, 15, 16, 17, -1, -1, 3, 4, 22, -1,
+ 24, 8, 9, 10, 11, 12, 13, 14, 15, 16,
+ 17, 35, -1, 37, -1, -1, -1, 24, -1, -1,
-1, -1, -1, -1, -1, -1, 109, 110, 111, -1,
-1, -1, -1, 99, 100, 101, 102, 103, 104, 105,
106, -1, -1, 109, 110, 111, -1, -1, -1, -1,
+ -1, -1, -1, -1, -1, -1, -1, -1, 82, 83,
+ 84, 85, 86, -1, -1, -1, -1, -1, -1, -1,
-1, -1, -1, -1, -1, -1, -1, -1, -1, -1,
- -1, -1, -1, 99, 100, 101, 102, 103, 104, 105,
- 106, -1, -1, 109, 110, 111, 3, 4, -1, -1,
- 7, 8, 9, 10, 11, 12, 13, 14, 15, 16,
- 17, -1, -1, -1, -1, 22, -1, 24, -1, -1,
- -1, -1, -1, -1, -1, -1, -1, -1, 35, -1,
- 37, 3, 4, -1, -1, 7, 8, 9, 10, 11,
- 12, 13, 14, 15, 16, 17, -1, -1, -1, -1,
- 22, 23, 24, -1, -1, -1, -1, -1, -1, -1,
- -1, -1, -1, 35, -1, 37, -1, -1, -1, -1,
- -1, -1, -1, -1, 3, 4, 83, 84, 7, 8,
- 9, 10, 11, 12, 13, 14, 15, 16, 17, -1,
- -1, -1, -1, 22, 23, 24, -1, -1, -1, -1,
- -1, -1, 109, 110, 111, -1, 35, -1, 37, 3,
+ -1, -1, -1, -1, -1, 109, 110, 111, -1, -1,
+ -1, -1, 99, 100, 101, 102, 103, 104, 105, 106,
+ -1, -1, 109, 110, 111, 3, 4, -1, -1, 7,
+ 8, 9, 10, 11, 12, 13, 14, 15, 16, 17,
+ -1, -1, -1, -1, 22, -1, 24, -1, -1, -1,
+ -1, -1, -1, -1, -1, -1, -1, 35, -1, 37,
+ 3, 4, -1, -1, 7, 8, 9, 10, 11, 12,
+ 13, 14, 15, 16, 17, -1, -1, -1, -1, 22,
+ 23, 24, -1, -1, -1, -1, -1, -1, -1, -1,
+ -1, -1, 35, -1, 37, -1, -1, -1, -1, -1,
+ -1, -1, -1, -1, 82, 83, 84, 3, 4, -1,
+ -1, 7, 8, 9, 10, 11, 12, 13, 14, 15,
+ 16, 17, -1, -1, -1, -1, 22, 23, 24, -1,
+ -1, 109, 110, 111, -1, -1, -1, -1, -1, 35,
+ -1, 37, 3, 4, -1, -1, 7, 8, 9, 10,
+ 11, 12, 13, 14, 15, 16, 17, -1, -1, -1,
+ -1, 22, 23, 24, -1, -1, 109, 110, 111, -1,
+ -1, -1, -1, -1, 35, -1, 37, 3, 4, -1,
+ -1, 7, 8, 9, 10, 11, 12, 13, 14, 15,
+ 16, 17, -1, -1, -1, -1, 22, -1, 24, -1,
+ -1, -1, -1, -1, -1, -1, -1, -1, -1, 35,
+ -1, 37, -1, 109, 110, 111, -1, -1, -1, 3,
4, -1, -1, 7, 8, 9, 10, 11, 12, 13,
- 14, 15, 16, 17, -1, -1, -1, -1, 22, 23,
- 24, -1, -1, -1, -1, -1, -1, 109, 110, 111,
- -1, 35, -1, 37, 3, 4, -1, -1, 7, 8,
+ 14, 15, 16, 17, -1, -1, -1, -1, 22, -1,
+ 24, -1, -1, -1, -1, -1, -1, -1, 109, 110,
+ 111, 35, -1, 37, 3, 4, -1, -1, -1, 8,
9, 10, 11, 12, 13, 14, 15, 16, 17, -1,
-1, -1, -1, 22, -1, 24, -1, -1, -1, -1,
- -1, -1, -1, -1, -1, -1, 35, -1, 37, -1,
- 109, 110, 111, -1, -1, -1, 3, 4, -1, -1,
- 7, 8, 9, 10, 11, 12, 13, 14, 15, 16,
- 17, -1, -1, -1, -1, 22, -1, 24, -1, -1,
- -1, -1, -1, -1, -1, 109, 110, 111, 35, -1,
- 37, 3, 4, -1, -1, -1, 8, 9, 10, 11,
+ -1, -1, -1, 109, 110, 111, 35, -1, 37, 3,
+ 4, -1, -1, -1, 8, 9, 10, 11, 12, 13,
+ 14, 15, 16, 17, -1, -1, -1, -1, 22, -1,
+ 24, -1, -1, -1, -1, -1, -1, -1, -1, -1,
+ -1, 35, -1, 37, -1, 109, 110, 111, -1, -1,
+ -1, 3, 4, -1, -1, -1, 8, 9, 10, 11,
12, 13, 14, 15, 16, 17, -1, -1, -1, -1,
22, -1, 24, -1, -1, -1, -1, -1, -1, -1,
- 109, 110, 111, 35, -1, 37, 3, 4, -1, -1,
- -1, 8, 9, 10, 11, 12, 13, 14, 15, 16,
- 17, -1, -1, -1, -1, 22, -1, 24, -1, -1,
- -1, -1, -1, -1, -1, -1, -1, -1, 35, -1,
- 37, -1, 109, 110, 111, -1, -1, -1, -1, -1,
+ 109, 110, 111, 35, -1, 37, -1, -1, -1, -1,
-1, -1, -1, -1, -1, -1, -1, -1, -1, -1,
-1, -1, -1, -1, -1, -1, -1, -1, -1, -1,
- -1, -1, -1, -1, -1, -1, -1, 109, 110, 111,
+ -1, -1, -1, -1, -1, 109, 110, 111, -1, -1,
-1, -1, -1, -1, -1, -1, -1, -1, -1, -1,
-1, -1, -1, -1, -1, -1, -1, -1, -1, -1,
-1, -1, -1, -1, -1, -1, -1, -1, -1, -1,
- -1, -1, 109, 110, 111
+ -1, -1, -1, -1, -1, -1, -1, 109, 110, 111
};
/* -*-C-*- Note some compilers choke on comments on `#line' lines. */
#line 3 "/usr/local/gnu/share/bison.simple"
switch (yyn) {
case 2:
-#line 335 "yaccParser/hsparser.y"
+#line 333 "yaccParser/hsparser.y"
{ the_module_name = yyvsp[-1].uid; module_exports = yyvsp[0].ulist; ;
break;}
case 4:
-#line 337 "yaccParser/hsparser.y"
+#line 335 "yaccParser/hsparser.y"
{ the_module_name = install_literal("Main"); module_exports = Lnil; ;
break;}
case 6:
-#line 343 "yaccParser/hsparser.y"
+#line 341 "yaccParser/hsparser.y"
{
root = mkhmodule(the_module_name,lconc(prelude_imports,yyvsp[-3].ulist),module_exports,yyvsp[-1].ubinding,startlineno);
;
break;}
case 7:
-#line 347 "yaccParser/hsparser.y"
+#line 345 "yaccParser/hsparser.y"
{
root = mkhmodule(the_module_name,lconc(prelude_imports,yyvsp[-3].ulist),module_exports,yyvsp[-1].ubinding,startlineno);
;
break;}
case 8:
-#line 352 "yaccParser/hsparser.y"
+#line 350 "yaccParser/hsparser.y"
{
root = mkhmodule(the_module_name,lconc(prelude_imports,yyvsp[-1].ulist),module_exports,mknullbind(),startlineno);
;
break;}
case 9:
-#line 356 "yaccParser/hsparser.y"
+#line 354 "yaccParser/hsparser.y"
{
root = mkhmodule(the_module_name,lconc(prelude_imports,yyvsp[-1].ulist),module_exports,mknullbind(),startlineno);
;
break;}
case 10:
-#line 362 "yaccParser/hsparser.y"
+#line 360 "yaccParser/hsparser.y"
{
root = mkhmodule(the_module_name,lconc(prelude_imports,yyvsp[-1].ulist),module_exports,mknullbind(),startlineno);
;
break;}
case 11:
-#line 366 "yaccParser/hsparser.y"
+#line 364 "yaccParser/hsparser.y"
{
root = mkhmodule(the_module_name,lconc(prelude_imports,yyvsp[-1].ulist),module_exports,mknullbind(),startlineno);
;
break;}
case 12:
-#line 372 "yaccParser/hsparser.y"
+#line 370 "yaccParser/hsparser.y"
{ yyval.ulist = Lnil; ;
break;}
case 13:
-#line 373 "yaccParser/hsparser.y"
+#line 371 "yaccParser/hsparser.y"
{ yyval.ulist = yyvsp[-1].ulist; ;
break;}
case 14:
-#line 377 "yaccParser/hsparser.y"
+#line 375 "yaccParser/hsparser.y"
{ yyval.ulist = lsing(yyvsp[0].uentid); ;
break;}
case 15:
-#line 378 "yaccParser/hsparser.y"
+#line 376 "yaccParser/hsparser.y"
{ yyval.ulist = lapp(yyvsp[-2].ulist, yyvsp[0].uentid); ;
break;}
case 16:
-#line 382 "yaccParser/hsparser.y"
+#line 380 "yaccParser/hsparser.y"
{ yyval.uentid = mkentid(yyvsp[0].uid); ;
break;}
case 17:
-#line 383 "yaccParser/hsparser.y"
+#line 381 "yaccParser/hsparser.y"
{ yyval.uentid = mkenttype(yyvsp[0].uid); ;
break;}
case 18:
-#line 384 "yaccParser/hsparser.y"
+#line 382 "yaccParser/hsparser.y"
{ yyval.uentid = mkenttypeall(yyvsp[-3].uid); ;
break;}
case 19:
-#line 386 "yaccParser/hsparser.y"
+#line 384 "yaccParser/hsparser.y"
{ yyval.uentid = mkenttypecons(yyvsp[-3].uid,yyvsp[-1].ulist);
/* should be a datatype with cons representing all constructors */
;
break;}
case 20:
-#line 390 "yaccParser/hsparser.y"
+#line 388 "yaccParser/hsparser.y"
{ yyval.uentid = mkentclass(yyvsp[-3].uid,yyvsp[-1].ulist);
/* should be a class with vars representing all Class operations */
;
break;}
case 21:
-#line 394 "yaccParser/hsparser.y"
+#line 392 "yaccParser/hsparser.y"
{ yyval.uentid = mkentclass(yyvsp[-2].uid,Lnil);
/* "tycon" should be a class with no operations */
;
break;}
case 22:
-#line 398 "yaccParser/hsparser.y"
+#line 396 "yaccParser/hsparser.y"
{ yyval.uentid = mkentmod(yyvsp[-1].uid);
/* "tycon" is a module id (but "modid" is bad for your identifier's health [KH]) */
;
break;}
case 23:
-#line 404 "yaccParser/hsparser.y"
+#line 402 "yaccParser/hsparser.y"
{ yyval.ulist = yyvsp[-1].ulist; hidden = FALSE; ;
break;}
case 24:
-#line 405 "yaccParser/hsparser.y"
+#line 403 "yaccParser/hsparser.y"
{ yyval.ulist = yyvsp[-1].ulist; hidden = TRUE; ;
break;}
case 25:
-#line 406 "yaccParser/hsparser.y"
+#line 404 "yaccParser/hsparser.y"
{ yyval.ulist = Lnil; hidden = FALSE; ;
break;}
case 26:
-#line 409 "yaccParser/hsparser.y"
+#line 407 "yaccParser/hsparser.y"
{ yyval.ulist = Lnil; ;
break;}
case 27:
-#line 410 "yaccParser/hsparser.y"
+#line 408 "yaccParser/hsparser.y"
{ yyval.ulist = yyvsp[0].ulist; ;
break;}
case 28:
-#line 414 "yaccParser/hsparser.y"
+#line 412 "yaccParser/hsparser.y"
{ yyval.ulist = lsing(yyvsp[0].uentid); ;
break;}
case 29:
-#line 415 "yaccParser/hsparser.y"
+#line 413 "yaccParser/hsparser.y"
{ yyval.ulist = lapp(yyvsp[-2].ulist, yyvsp[0].uentid); ;
break;}
case 30:
-#line 419 "yaccParser/hsparser.y"
+#line 417 "yaccParser/hsparser.y"
{ yyval.uentid = mkentid(yyvsp[0].uid); ;
break;}
case 31:
-#line 420 "yaccParser/hsparser.y"
+#line 418 "yaccParser/hsparser.y"
{ yyval.uentid = mkenttype(yyvsp[0].uid); ;
break;}
case 32:
-#line 421 "yaccParser/hsparser.y"
+#line 419 "yaccParser/hsparser.y"
{ yyval.uentid = mkenttypeall(yyvsp[-3].uid); ;
break;}
case 33:
-#line 423 "yaccParser/hsparser.y"
+#line 421 "yaccParser/hsparser.y"
{ yyval.uentid = mkenttypecons(yyvsp[-3].uid,yyvsp[-1].ulist);
/* should be a datatype with cons representing all constructors */
;
break;}
case 34:
-#line 427 "yaccParser/hsparser.y"
+#line 425 "yaccParser/hsparser.y"
{ yyval.uentid = mkentclass(yyvsp[-3].uid,yyvsp[-1].ulist);
/* should be a class with vars representing all Class operations */
;
break;}
case 35:
-#line 431 "yaccParser/hsparser.y"
+#line 429 "yaccParser/hsparser.y"
{ yyval.uentid = mkentclass(yyvsp[-2].uid,Lnil);
/* "tycon" should be a class with no operations */
;
break;}
case 36:
-#line 440 "yaccParser/hsparser.y"
+#line 438 "yaccParser/hsparser.y"
{ yyval.uhpragma = mkidata_pragma(yyvsp[-2].ulist, yyvsp[-1].ulist); ;
break;}
case 37:
-#line 442 "yaccParser/hsparser.y"
+#line 440 "yaccParser/hsparser.y"
{ yyval.uhpragma = mkidata_pragma(Lnil, yyvsp[-1].ulist); ;
break;}
case 38:
-#line 443 "yaccParser/hsparser.y"
+#line 441 "yaccParser/hsparser.y"
{ yyval.uhpragma = mkno_pragma(); ;
break;}
case 39:
-#line 448 "yaccParser/hsparser.y"
+#line 446 "yaccParser/hsparser.y"
{ yyval.ulist = yyvsp[0].ulist; ;
break;}
case 40:
-#line 449 "yaccParser/hsparser.y"
+#line 447 "yaccParser/hsparser.y"
{ yyval.ulist = Lnil; ;
break;}
case 41:
-#line 453 "yaccParser/hsparser.y"
+#line 451 "yaccParser/hsparser.y"
{ yyval.ulist = lsing(yyvsp[0].uhpragma); ;
break;}
case 42:
-#line 455 "yaccParser/hsparser.y"
+#line 453 "yaccParser/hsparser.y"
{ yyval.ulist = lapp(yyvsp[-2].ulist, yyvsp[0].uhpragma); ;
break;}
case 43:
-#line 459 "yaccParser/hsparser.y"
+#line 457 "yaccParser/hsparser.y"
{ yyval.uhpragma = mkidata_pragma_4s(yyvsp[-1].ulist); ;
break;}
case 44:
-#line 463 "yaccParser/hsparser.y"
+#line 461 "yaccParser/hsparser.y"
{ yyval.uhpragma = mkitype_pragma(); ;
break;}
case 45:
-#line 464 "yaccParser/hsparser.y"
+#line 462 "yaccParser/hsparser.y"
{ yyval.uhpragma = mkno_pragma(); ;
break;}
case 46:
-#line 468 "yaccParser/hsparser.y"
+#line 466 "yaccParser/hsparser.y"
{ yyval.uhpragma = mkiclas_pragma(yyvsp[-1].ulist); ;
break;}
case 47:
-#line 469 "yaccParser/hsparser.y"
+#line 467 "yaccParser/hsparser.y"
{ yyval.uhpragma = mkno_pragma(); ;
break;}
case 48:
-#line 474 "yaccParser/hsparser.y"
+#line 472 "yaccParser/hsparser.y"
{ yyval.uhpragma = mkiclasop_pragma(yyvsp[-2].uhpragma, yyvsp[-1].uhpragma); ;
break;}
case 49:
-#line 476 "yaccParser/hsparser.y"
+#line 474 "yaccParser/hsparser.y"
{ yyval.uhpragma = mkno_pragma(); ;
break;}
case 50:
-#line 481 "yaccParser/hsparser.y"
+#line 479 "yaccParser/hsparser.y"
{ yyval.uhpragma = mkiinst_simpl_pragma(yyvsp[-2].uid, yyvsp[-1].uhpragma); ;
break;}
case 51:
-#line 484 "yaccParser/hsparser.y"
+#line 482 "yaccParser/hsparser.y"
{ yyval.uhpragma = mkiinst_const_pragma(yyvsp[-3].uid, yyvsp[-2].uhpragma, yyvsp[-1].ulist); ;
break;}
case 52:
-#line 487 "yaccParser/hsparser.y"
-{ yyval.uhpragma = mkiinst_spec_pragma(yyvsp[-3].uid, yyvsp[-2].uhpragma, yyvsp[-1].ulist); ;
+#line 485 "yaccParser/hsparser.y"
+{ yyval.uhpragma = mkno_pragma(); ;
break;}
case 53:
#line 490 "yaccParser/hsparser.y"
-{ yyval.uhpragma = mkno_pragma(); ;
+{ yyval.uid = yyvsp[0].uid; ;
break;}
case 54:
-#line 495 "yaccParser/hsparser.y"
-{ yyval.uid = yyvsp[0].uid; ;
+#line 492 "yaccParser/hsparser.y"
+{ yyval.uid = install_literal(""); ;
break;}
case 55:
#line 497 "yaccParser/hsparser.y"
-{ yyval.uid = install_literal(""); ;
+{ yyval.uhpragma = yyvsp[-1].uhpragma; ;
break;}
case 56:
-#line 500 "yaccParser/hsparser.y"
-{ yyval.ulist = yyvsp[0].ulist; ;
+#line 499 "yaccParser/hsparser.y"
+{ yyval.uhpragma = mkno_pragma(); ;
break;}
case 57:
-#line 505 "yaccParser/hsparser.y"
-{ yyval.uhpragma = yyvsp[-1].uhpragma; ;
+#line 504 "yaccParser/hsparser.y"
+{ yyval.uhpragma = mkno_pragma(); ;
break;}
case 58:
-#line 507 "yaccParser/hsparser.y"
-{ yyval.uhpragma = mkno_pragma(); ;
+#line 506 "yaccParser/hsparser.y"
+{ yyval.uhpragma = mkigen_pragma(yyvsp[-5].uhpragma, yyvsp[-4].uhpragma, yyvsp[-3].uhpragma, yyvsp[-2].uhpragma, yyvsp[-1].uhpragma, yyvsp[0].ulist); ;
break;}
case 59:
-#line 512 "yaccParser/hsparser.y"
+#line 510 "yaccParser/hsparser.y"
{ yyval.uhpragma = mkno_pragma(); ;
break;}
case 60:
-#line 514 "yaccParser/hsparser.y"
-{ yyval.uhpragma = mkigen_pragma(yyvsp[-5].uhpragma, yyvsp[-4].uhpragma, yyvsp[-3].uhpragma, yyvsp[-2].uhpragma, yyvsp[-1].uhpragma, yyvsp[0].ulist); ;
+#line 511 "yaccParser/hsparser.y"
+{ yyval.uhpragma = mkiarity_pragma(yyvsp[0].ustring); ;
break;}
case 61:
-#line 518 "yaccParser/hsparser.y"
+#line 515 "yaccParser/hsparser.y"
{ yyval.uhpragma = mkno_pragma(); ;
break;}
case 62:
-#line 519 "yaccParser/hsparser.y"
-{ yyval.uhpragma = mkiarity_pragma(yyvsp[0].ustring); ;
+#line 516 "yaccParser/hsparser.y"
+{ yyval.uhpragma = mkiupdate_pragma(yyvsp[0].ustring); ;
break;}
case 63:
-#line 523 "yaccParser/hsparser.y"
+#line 520 "yaccParser/hsparser.y"
{ yyval.uhpragma = mkno_pragma(); ;
break;}
case 64:
-#line 524 "yaccParser/hsparser.y"
-{ yyval.uhpragma = mkiupdate_pragma(yyvsp[0].ustring); ;
+#line 521 "yaccParser/hsparser.y"
+{ yyval.uhpragma = mkideforest_pragma(); ;
break;}
case 65:
-#line 528 "yaccParser/hsparser.y"
+#line 525 "yaccParser/hsparser.y"
{ yyval.uhpragma = mkno_pragma(); ;
break;}
case 66:
-#line 529 "yaccParser/hsparser.y"
-{ yyval.uhpragma = mkideforest_pragma(); ;
+#line 526 "yaccParser/hsparser.y"
+{ yyval.uhpragma = mkistrictness_pragma(installHstring(1, "B"),
+ /* _!_ = COCON = bottom */ mkno_pragma());
+ ;
break;}
case 67:
-#line 533 "yaccParser/hsparser.y"
-{ yyval.uhpragma = mkno_pragma(); ;
+#line 530 "yaccParser/hsparser.y"
+{ yyval.uhpragma = mkistrictness_pragma(yyvsp[-1].uhstring, yyvsp[0].uhpragma); ;
break;}
case 68:
#line 534 "yaccParser/hsparser.y"
-{ yyval.uhpragma = mkistrictness_pragma(installHstring(1, "B"),
- /* _!_ = COCON = bottom */ mkno_pragma());
- ;
+{ yyval.uhpragma = yyvsp[-1].uhpragma; ;
break;}
case 69:
-#line 538 "yaccParser/hsparser.y"
-{ yyval.uhpragma = mkistrictness_pragma(yyvsp[-1].uhstring, yyvsp[0].uhpragma); ;
+#line 535 "yaccParser/hsparser.y"
+{ yyval.uhpragma = mkno_pragma(); ;
break;}
case 70:
-#line 542 "yaccParser/hsparser.y"
-{ yyval.uhpragma = yyvsp[-1].uhpragma; ;
+#line 538 "yaccParser/hsparser.y"
+{ yyval.uhpragma = mkno_pragma(); ;
break;}
case 71:
-#line 543 "yaccParser/hsparser.y"
-{ yyval.uhpragma = mkno_pragma(); ;
+#line 540 "yaccParser/hsparser.y"
+{ yyval.uhpragma = mkimagic_unfolding_pragma(yyvsp[0].uid); ;
break;}
case 72:
-#line 546 "yaccParser/hsparser.y"
-{ yyval.uhpragma = mkno_pragma(); ;
+#line 542 "yaccParser/hsparser.y"
+{ yyval.uhpragma = mkiunfolding_pragma(yyvsp[-1].uhpragma, yyvsp[0].ucoresyn); ;
break;}
case 73:
-#line 548 "yaccParser/hsparser.y"
-{ yyval.uhpragma = mkimagic_unfolding_pragma(yyvsp[0].uid); ;
+#line 547 "yaccParser/hsparser.y"
+{ yyval.uhpragma = mkiunfold_always(); ;
break;}
case 74:
-#line 550 "yaccParser/hsparser.y"
-{ yyval.uhpragma = mkiunfolding_pragma(yyvsp[-1].uhpragma, yyvsp[0].ucoresyn); ;
+#line 549 "yaccParser/hsparser.y"
+{ yyval.uhpragma = mkiunfold_if_args(yyvsp[-3].ustring, yyvsp[-2].ustring, yyvsp[-1].uid, yyvsp[0].ustring); ;
break;}
case 75:
-#line 555 "yaccParser/hsparser.y"
-{ yyval.uhpragma = mkiunfold_always(); ;
+#line 553 "yaccParser/hsparser.y"
+{ yyval.ulist = lsing(yyvsp[0].uhpragma); ;
break;}
case 76:
-#line 557 "yaccParser/hsparser.y"
-{ yyval.uhpragma = mkiunfold_if_args(yyvsp[-3].ustring, yyvsp[-2].ustring, yyvsp[-1].uid, yyvsp[0].ustring); ;
+#line 554 "yaccParser/hsparser.y"
+{ yyval.ulist = lapp(yyvsp[-2].ulist, yyvsp[0].uhpragma); ;
break;}
case 77:
-#line 561 "yaccParser/hsparser.y"
-{ yyval.ulist = lsing(yyvsp[0].uhpragma); ;
+#line 558 "yaccParser/hsparser.y"
+{ yyval.ulist = Lnil; ;
break;}
case 78:
-#line 562 "yaccParser/hsparser.y"
-{ yyval.ulist = lapp(yyvsp[-2].ulist, yyvsp[0].uhpragma); ;
+#line 559 "yaccParser/hsparser.y"
+{ yyval.ulist = yyvsp[0].ulist; ;
break;}
case 79:
-#line 566 "yaccParser/hsparser.y"
-{ yyval.ulist = Lnil; ;
+#line 563 "yaccParser/hsparser.y"
+{ yyval.ulist = lsing(yyvsp[0].uhpragma); ;
break;}
case 80:
-#line 567 "yaccParser/hsparser.y"
-{ yyval.ulist = yyvsp[0].ulist; ;
+#line 564 "yaccParser/hsparser.y"
+{ yyval.ulist = lapp(yyvsp[-2].ulist, yyvsp[0].uhpragma); ;
break;}
case 81:
-#line 571 "yaccParser/hsparser.y"
-{ yyval.ulist = lsing(yyvsp[0].uhpragma); ;
+#line 569 "yaccParser/hsparser.y"
+{ yyval.uhpragma = mkitype_pragma_pr(yyvsp[-3].ulist, yyvsp[-1].ustring, yyvsp[0].uhpragma); ;
break;}
case 82:
-#line 572 "yaccParser/hsparser.y"
-{ yyval.ulist = lapp(yyvsp[-2].ulist, yyvsp[0].uhpragma); ;
+#line 573 "yaccParser/hsparser.y"
+{ yyval.ulist = lsing(yyvsp[0].uttype); ;
break;}
case 83:
-#line 577 "yaccParser/hsparser.y"
-{ yyval.uhpragma = mkitype_pragma_pr(yyvsp[-3].ulist, yyvsp[-1].ustring, yyvsp[0].uhpragma); ;
+#line 574 "yaccParser/hsparser.y"
+{ yyval.ulist = lapp(yyvsp[-2].ulist, yyvsp[0].uttype); ;
break;}
case 84:
-#line 581 "yaccParser/hsparser.y"
-{ yyval.ulist = lsing(yyvsp[0].uhpragma); ;
+#line 578 "yaccParser/hsparser.y"
+{ yyval.uttype = mkty_maybe_nothing(); ;
break;}
case 85:
-#line 582 "yaccParser/hsparser.y"
-{ yyval.ulist = lapp(yyvsp[-2].ulist,yyvsp[0].uhpragma); ;
+#line 579 "yaccParser/hsparser.y"
+{ yyval.uttype = mkty_maybe_just(yyvsp[0].uttype); ;
break;}
case 86:
-#line 587 "yaccParser/hsparser.y"
-{ yyval.uhpragma = mkiinst_pragma_3s(yyvsp[-4].ulist, yyvsp[-2].ustring, yyvsp[-1].uhpragma, yyvsp[0].ulist); ;
+#line 583 "yaccParser/hsparser.y"
+{ yyval.ulist = lsing(yyvsp[0].uhpragma); ;
break;}
case 87:
-#line 591 "yaccParser/hsparser.y"
-{ yyval.ulist = lsing(yyvsp[0].uttype); ;
+#line 584 "yaccParser/hsparser.y"
+{ yyval.ulist = lapp(yyvsp[-2].ulist, yyvsp[0].uhpragma); ;
break;}
case 88:
-#line 592 "yaccParser/hsparser.y"
-{ yyval.ulist = lapp(yyvsp[-2].ulist, yyvsp[0].uttype); ;
+#line 593 "yaccParser/hsparser.y"
+{ yyval.uhpragma = mkiname_pragma_pr(yyvsp[-4].uid, yyvsp[-1].uhpragma); ;
break;}
case 89:
-#line 596 "yaccParser/hsparser.y"
-{ yyval.uttype = mkty_maybe_nothing(); ;
+#line 599 "yaccParser/hsparser.y"
+{ yyval.uhpragma = mkiname_pragma_pr(yyvsp[-2].uid, yyvsp[0].uhpragma); ;
break;}
case 90:
-#line 597 "yaccParser/hsparser.y"
-{ yyval.uttype = mkty_maybe_just(yyvsp[0].uttype); ;
+#line 610 "yaccParser/hsparser.y"
+{ yyval.ucoresyn = mkcolam(yyvsp[-2].ulist, yyvsp[0].ucoresyn); ;
break;}
case 91:
-#line 601 "yaccParser/hsparser.y"
-{ yyval.ulist = Lnil; ;
+#line 612 "yaccParser/hsparser.y"
+{ yyval.ucoresyn = mkcotylam(yyvsp[-2].ulist, yyvsp[0].ucoresyn); ;
break;}
case 92:
-#line 602 "yaccParser/hsparser.y"
-{ yyval.ulist = yyvsp[0].ulist; ;
+#line 614 "yaccParser/hsparser.y"
+{ yyval.ucoresyn = mkcocon(mkco_id(yyvsp[-2].uid), yyvsp[-1].ulist, yyvsp[0].ulist); ;
break;}
case 93:
-#line 606 "yaccParser/hsparser.y"
-{ yyval.ulist = lsing(yyvsp[0].uhpragma); ;
+#line 616 "yaccParser/hsparser.y"
+{ yyval.ucoresyn = mkcocon(mkco_orig_id(yyvsp[-3].uid,yyvsp[-2].uid), yyvsp[-1].ulist, yyvsp[0].ulist); ;
break;}
case 94:
-#line 607 "yaccParser/hsparser.y"
-{ yyval.ulist = lapp(yyvsp[-2].ulist, yyvsp[0].uhpragma); ;
+#line 618 "yaccParser/hsparser.y"
+{ yyval.ucoresyn = mkcoprim(yyvsp[-2].ucoresyn, yyvsp[-1].ulist, yyvsp[0].ulist); ;
break;}
case 95:
-#line 612 "yaccParser/hsparser.y"
-{ yyval.uhpragma = mkiname_pragma_pr(yyvsp[-2].uid, yyvsp[0].uhpragma); ;
+#line 620 "yaccParser/hsparser.y"
+{ yyval.ucoresyn = mkcoapp(yyvsp[-1].ucoresyn, yyvsp[0].ulist); ;
break;}
case 96:
-#line 621 "yaccParser/hsparser.y"
-{ yyval.ucoresyn = mkcolam(yyvsp[-2].ulist, yyvsp[0].ucoresyn); ;
+#line 622 "yaccParser/hsparser.y"
+{ yyval.ucoresyn = mkcotyapp(yyvsp[-3].ucoresyn, yyvsp[-1].uttype); ;
break;}
case 97:
-#line 623 "yaccParser/hsparser.y"
-{ yyval.ucoresyn = mkcotylam(yyvsp[-2].ulist, yyvsp[0].ucoresyn); ;
+#line 624 "yaccParser/hsparser.y"
+{ yyval.ucoresyn = mkcocase(yyvsp[-4].ucoresyn, yyvsp[-1].ucoresyn); ;
break;}
case 98:
-#line 625 "yaccParser/hsparser.y"
-{ yyval.ucoresyn = mkcocon(mkco_id(yyvsp[-2].uid), yyvsp[-1].ulist, yyvsp[0].ulist); ;
+#line 626 "yaccParser/hsparser.y"
+{ yyval.ucoresyn = mkcolet(mkcononrec(yyvsp[-5].ucoresyn, yyvsp[-3].ucoresyn), yyvsp[0].ucoresyn); ;
break;}
case 99:
-#line 627 "yaccParser/hsparser.y"
-{ yyval.ucoresyn = mkcocon(mkco_orig_id(yyvsp[-3].uid,yyvsp[-2].uid), yyvsp[-1].ulist, yyvsp[0].ulist); ;
+#line 628 "yaccParser/hsparser.y"
+{ yyval.ucoresyn = mkcolet(mkcorec(yyvsp[-3].ulist), yyvsp[0].ucoresyn); ;
break;}
case 100:
-#line 629 "yaccParser/hsparser.y"
-{ yyval.ucoresyn = mkcoprim(yyvsp[-2].ucoresyn, yyvsp[-1].ulist, yyvsp[0].ulist); ;
+#line 630 "yaccParser/hsparser.y"
+{ yyval.ucoresyn = mkcoscc(yyvsp[-2].ucoresyn, yyvsp[0].ucoresyn); ;
break;}
case 101:
#line 631 "yaccParser/hsparser.y"
-{ yyval.ucoresyn = mkcoapp(yyvsp[-1].ucoresyn, yyvsp[0].ulist); ;
+{ yyval.ucoresyn = mkcoliteral(yyvsp[0].uliteral); ;
break;}
case 102:
-#line 633 "yaccParser/hsparser.y"
-{ yyval.ucoresyn = mkcotyapp(yyvsp[-3].ucoresyn, yyvsp[-1].uttype); ;
+#line 632 "yaccParser/hsparser.y"
+{ yyval.ucoresyn = mkcovar(yyvsp[0].ucoresyn); ;
break;}
case 103:
-#line 635 "yaccParser/hsparser.y"
-{ yyval.ucoresyn = mkcocase(yyvsp[-4].ucoresyn, yyvsp[-1].ucoresyn); ;
+#line 637 "yaccParser/hsparser.y"
+{ yyval.ucoresyn = mkcoalg_alts(yyvsp[-1].ulist, yyvsp[0].ucoresyn); ;
break;}
case 104:
-#line 637 "yaccParser/hsparser.y"
-{ yyval.ucoresyn = mkcolet(mkcononrec(yyvsp[-5].ucoresyn, yyvsp[-3].ucoresyn), yyvsp[0].ucoresyn); ;
+#line 639 "yaccParser/hsparser.y"
+{ yyval.ucoresyn = mkcoprim_alts(yyvsp[-1].ulist, yyvsp[0].ucoresyn); ;
break;}
case 105:
-#line 639 "yaccParser/hsparser.y"
-{ yyval.ucoresyn = mkcolet(mkcorec(yyvsp[-3].ulist), yyvsp[0].ucoresyn); ;
+#line 643 "yaccParser/hsparser.y"
+{ yyval.ulist = Lnil; ;
break;}
case 106:
-#line 641 "yaccParser/hsparser.y"
-{ yyval.ucoresyn = mkcoscc(yyvsp[-2].ucoresyn, yyvsp[0].ucoresyn); ;
+#line 644 "yaccParser/hsparser.y"
+{ yyval.ulist = lapp(yyvsp[-1].ulist, yyvsp[0].ucoresyn); ;
break;}
case 107:
-#line 642 "yaccParser/hsparser.y"
-{ yyval.ucoresyn = mkcoliteral(yyvsp[0].uliteral); ;
+#line 648 "yaccParser/hsparser.y"
+{ yyval.ucoresyn = mkcoalg_alt(yyvsp[-4].ucoresyn, yyvsp[-3].ulist, yyvsp[-1].ucoresyn); ;
break;}
case 108:
-#line 643 "yaccParser/hsparser.y"
-{ yyval.ucoresyn = mkcovar(yyvsp[0].ucoresyn); ;
+#line 653 "yaccParser/hsparser.y"
+{ yyval.ulist = Lnil; ;
break;}
case 109:
-#line 648 "yaccParser/hsparser.y"
-{ yyval.ucoresyn = mkcoalg_alts(yyvsp[-1].ulist, yyvsp[0].ucoresyn); ;
+#line 654 "yaccParser/hsparser.y"
+{ yyval.ulist = lapp(yyvsp[-1].ulist, yyvsp[0].ucoresyn); ;
break;}
case 110:
-#line 650 "yaccParser/hsparser.y"
-{ yyval.ucoresyn = mkcoprim_alts(yyvsp[-1].ulist, yyvsp[0].ucoresyn); ;
+#line 658 "yaccParser/hsparser.y"
+{ yyval.ucoresyn = mkcoprim_alt(yyvsp[-3].uliteral, yyvsp[-1].ucoresyn); ;
break;}
case 111:
-#line 654 "yaccParser/hsparser.y"
-{ yyval.ulist = Lnil; ;
+#line 662 "yaccParser/hsparser.y"
+{ yyval.ucoresyn = mkconodeflt(); ;
break;}
case 112:
-#line 655 "yaccParser/hsparser.y"
-{ yyval.ulist = lapp(yyvsp[-1].ulist, yyvsp[0].ucoresyn); ;
+#line 663 "yaccParser/hsparser.y"
+{ yyval.ucoresyn = mkcobinddeflt(yyvsp[-2].ucoresyn, yyvsp[0].ucoresyn); ;
break;}
case 113:
-#line 659 "yaccParser/hsparser.y"
-{ yyval.ucoresyn = mkcoalg_alt(yyvsp[-4].ucoresyn, yyvsp[-3].ulist, yyvsp[-1].ucoresyn); ;
+#line 667 "yaccParser/hsparser.y"
+{ yyval.ulist = lsing(yyvsp[0].ucoresyn); ;
break;}
case 114:
-#line 664 "yaccParser/hsparser.y"
-{ yyval.ulist = Lnil; ;
+#line 668 "yaccParser/hsparser.y"
+{ yyval.ulist = lapp(yyvsp[-2].ulist, yyvsp[0].ucoresyn); ;
break;}
case 115:
-#line 665 "yaccParser/hsparser.y"
-{ yyval.ulist = lapp(yyvsp[-1].ulist, yyvsp[0].ucoresyn); ;
+#line 672 "yaccParser/hsparser.y"
+{ yyval.ucoresyn = mkcorec_pair(yyvsp[-2].ucoresyn, yyvsp[0].ucoresyn); ;
break;}
case 116:
-#line 669 "yaccParser/hsparser.y"
-{ yyval.ucoresyn = mkcoprim_alt(yyvsp[-3].uliteral, yyvsp[-1].ucoresyn); ;
+#line 676 "yaccParser/hsparser.y"
+{ yyval.ucoresyn = mkco_preludedictscc(yyvsp[0].ucoresyn); ;
break;}
case 117:
-#line 673 "yaccParser/hsparser.y"
-{ yyval.ucoresyn = mkconodeflt(); ;
+#line 677 "yaccParser/hsparser.y"
+{ yyval.ucoresyn = mkco_alldictscc(yyvsp[-2].uhstring,yyvsp[-1].uhstring,yyvsp[0].ucoresyn); ;
break;}
case 118:
-#line 674 "yaccParser/hsparser.y"
-{ yyval.ucoresyn = mkcobinddeflt(yyvsp[-2].ucoresyn, yyvsp[0].ucoresyn); ;
+#line 679 "yaccParser/hsparser.y"
+{ yyval.ucoresyn = mkco_usercc(yyvsp[-4].uhstring,yyvsp[-3].uhstring,yyvsp[-2].uhstring,yyvsp[-1].ucoresyn,yyvsp[0].ucoresyn); ;
break;}
case 119:
-#line 678 "yaccParser/hsparser.y"
-{ yyval.ulist = lsing(yyvsp[0].ucoresyn); ;
+#line 681 "yaccParser/hsparser.y"
+{ yyval.ucoresyn = mkco_autocc(yyvsp[-4].ucoresyn,yyvsp[-3].uhstring,yyvsp[-2].uhstring,yyvsp[-1].ucoresyn,yyvsp[0].ucoresyn); ;
break;}
case 120:
-#line 679 "yaccParser/hsparser.y"
-{ yyval.ulist = lapp(yyvsp[-2].ulist, yyvsp[0].ucoresyn); ;
+#line 683 "yaccParser/hsparser.y"
+{ yyval.ucoresyn = mkco_dictcc(yyvsp[-4].ucoresyn,yyvsp[-3].uhstring,yyvsp[-2].uhstring,yyvsp[-1].ucoresyn,yyvsp[0].ucoresyn); ;
break;}
case 121:
-#line 683 "yaccParser/hsparser.y"
-{ yyval.ucoresyn = mkcorec_pair(yyvsp[-2].ucoresyn, yyvsp[0].ucoresyn); ;
+#line 685 "yaccParser/hsparser.y"
+{ yyval.ucoresyn = mkco_scc_noncaf(); ;
break;}
case 122:
-#line 687 "yaccParser/hsparser.y"
-{ yyval.ucoresyn = mkco_preludedictscc(yyvsp[0].ucoresyn); ;
+#line 686 "yaccParser/hsparser.y"
+{ yyval.ucoresyn = mkco_scc_caf(); ;
break;}
case 123:
#line 688 "yaccParser/hsparser.y"
-{ yyval.ucoresyn = mkco_alldictscc(yyvsp[-2].uhstring,yyvsp[-1].uhstring,yyvsp[0].ucoresyn); ;
+{ yyval.ucoresyn = mkco_scc_nondupd(); ;
break;}
case 124:
-#line 690 "yaccParser/hsparser.y"
-{ yyval.ucoresyn = mkco_usercc(yyvsp[-4].uhstring,yyvsp[-3].uhstring,yyvsp[-2].uhstring,yyvsp[-1].ucoresyn,yyvsp[0].ucoresyn); ;
+#line 689 "yaccParser/hsparser.y"
+{ yyval.ucoresyn = mkco_scc_dupd(); ;
break;}
case 125:
#line 692 "yaccParser/hsparser.y"
-{ yyval.ucoresyn = mkco_autocc(yyvsp[-4].ucoresyn,yyvsp[-3].uhstring,yyvsp[-2].uhstring,yyvsp[-1].ucoresyn,yyvsp[0].ucoresyn); ;
+{ yyval.ucoresyn = mkco_sdselid(yyvsp[-1].uid, yyvsp[0].uid); ;
break;}
case 126:
-#line 694 "yaccParser/hsparser.y"
-{ yyval.ucoresyn = mkco_dictcc(yyvsp[-4].ucoresyn,yyvsp[-3].uhstring,yyvsp[-2].uhstring,yyvsp[-1].ucoresyn,yyvsp[0].ucoresyn); ;
+#line 693 "yaccParser/hsparser.y"
+{ yyval.ucoresyn = mkco_classopid(yyvsp[-1].uid, yyvsp[0].uid); ;
break;}
case 127:
-#line 696 "yaccParser/hsparser.y"
-{ yyval.ucoresyn = mkco_scc_noncaf(); ;
+#line 694 "yaccParser/hsparser.y"
+{ yyval.ucoresyn = mkco_defmid(yyvsp[-1].uid, yyvsp[0].uid); ;
break;}
case 128:
-#line 697 "yaccParser/hsparser.y"
-{ yyval.ucoresyn = mkco_scc_caf(); ;
+#line 696 "yaccParser/hsparser.y"
+{ yyval.ucoresyn = mkco_dfunid(yyvsp[-3].uid, yyvsp[-1].uttype); ;
break;}
case 129:
-#line 699 "yaccParser/hsparser.y"
-{ yyval.ucoresyn = mkco_scc_nondupd(); ;
+#line 698 "yaccParser/hsparser.y"
+{ yyval.ucoresyn = mkco_constmid(yyvsp[-4].uid, yyvsp[-3].uid, yyvsp[-1].uttype); ;
break;}
case 130:
#line 700 "yaccParser/hsparser.y"
-{ yyval.ucoresyn = mkco_scc_dupd(); ;
+{ yyval.ucoresyn = mkco_specid(yyvsp[-3].ucoresyn, yyvsp[-1].ulist); ;
break;}
case 131:
-#line 703 "yaccParser/hsparser.y"
-{ yyval.ucoresyn = mkco_sdselid(yyvsp[-1].uid, yyvsp[0].uid); ;
+#line 701 "yaccParser/hsparser.y"
+{ yyval.ucoresyn = mkco_wrkrid(yyvsp[0].ucoresyn); ;
break;}
case 132:
-#line 704 "yaccParser/hsparser.y"
-{ yyval.ucoresyn = mkco_classopid(yyvsp[-1].uid, yyvsp[0].uid); ;
+#line 702 "yaccParser/hsparser.y"
+{ yyval.ucoresyn = mkco_orig_id(yyvsp[-1].uid, yyvsp[0].uid); ;
break;}
case 133:
-#line 705 "yaccParser/hsparser.y"
-{ yyval.ucoresyn = mkco_defmid(yyvsp[-1].uid, yyvsp[0].uid); ;
+#line 703 "yaccParser/hsparser.y"
+{ yyval.ucoresyn = mkco_orig_id(yyvsp[-1].uid, yyvsp[0].uid); ;
break;}
case 134:
-#line 707 "yaccParser/hsparser.y"
-{ yyval.ucoresyn = mkco_dfunid(yyvsp[-3].uid, yyvsp[-1].uttype); ;
+#line 704 "yaccParser/hsparser.y"
+{ yyval.ucoresyn = mkco_id(yyvsp[0].uid); ;
break;}
case 135:
-#line 709 "yaccParser/hsparser.y"
-{ yyval.ucoresyn = mkco_constmid(yyvsp[-4].uid, yyvsp[-3].uid, yyvsp[-1].uttype); ;
+#line 705 "yaccParser/hsparser.y"
+{ yyval.ucoresyn = mkco_id(yyvsp[0].uid); ;
break;}
case 136:
-#line 711 "yaccParser/hsparser.y"
-{ yyval.ucoresyn = mkco_specid(yyvsp[-3].ucoresyn, yyvsp[-1].ulist); ;
+#line 710 "yaccParser/hsparser.y"
+{ yyval.ucoresyn = mkco_ccall(yyvsp[-5].uid,0,yyvsp[-3].ulist,yyvsp[-2].uttype); ;
break;}
case 137:
#line 712 "yaccParser/hsparser.y"
-{ yyval.ucoresyn = mkco_wrkrid(yyvsp[0].ucoresyn); ;
+{ yyval.ucoresyn = mkco_ccall(yyvsp[-5].uid,1,yyvsp[-3].ulist,yyvsp[-2].uttype); ;
break;}
case 138:
-#line 713 "yaccParser/hsparser.y"
-{ yyval.ucoresyn = mkco_orig_id(yyvsp[-1].uid, yyvsp[0].uid); ;
- break;}
-case 139:
#line 714 "yaccParser/hsparser.y"
-{ yyval.ucoresyn = mkco_orig_id(yyvsp[-1].uid, yyvsp[0].uid); ;
- break;}
-case 140:
-#line 715 "yaccParser/hsparser.y"
-{ yyval.ucoresyn = mkco_id(yyvsp[0].uid); ;
- break;}
-case 141:
-#line 716 "yaccParser/hsparser.y"
-{ yyval.ucoresyn = mkco_id(yyvsp[0].uid); ;
- break;}
-case 142:
-#line 721 "yaccParser/hsparser.y"
-{ yyval.ucoresyn = mkco_ccall(yyvsp[-5].uid,0,yyvsp[-3].ulist,yyvsp[-2].uttype); ;
- break;}
-case 143:
-#line 723 "yaccParser/hsparser.y"
-{ yyval.ucoresyn = mkco_ccall(yyvsp[-5].uid,1,yyvsp[-3].ulist,yyvsp[-2].uttype); ;
- break;}
-case 144:
-#line 725 "yaccParser/hsparser.y"
{ yyval.ucoresyn = mkco_casm(yyvsp[-5].uliteral,0,yyvsp[-3].ulist,yyvsp[-2].uttype); ;
break;}
-case 145:
-#line 727 "yaccParser/hsparser.y"
+case 139:
+#line 716 "yaccParser/hsparser.y"
{ yyval.ucoresyn = mkco_casm(yyvsp[-5].uliteral,1,yyvsp[-3].ulist,yyvsp[-2].uttype); ;
break;}
-case 146:
-#line 728 "yaccParser/hsparser.y"
+case 140:
+#line 717 "yaccParser/hsparser.y"
{ yyval.ucoresyn = mkco_primop(yyvsp[0].uid); ;
break;}
-case 147:
-#line 732 "yaccParser/hsparser.y"
+case 141:
+#line 721 "yaccParser/hsparser.y"
{ yyval.ulist = Lnil; ;
break;}
-case 148:
-#line 733 "yaccParser/hsparser.y"
+case 142:
+#line 722 "yaccParser/hsparser.y"
{ yyval.ulist = lapp(yyvsp[-1].ulist, yyvsp[0].ucoresyn); ;
break;}
-case 149:
-#line 737 "yaccParser/hsparser.y"
+case 143:
+#line 726 "yaccParser/hsparser.y"
{ yyval.ucoresyn = mkcobinder(yyvsp[-3].uid, yyvsp[-1].uttype); ;
break;}
-case 150:
-#line 740 "yaccParser/hsparser.y"
+case 144:
+#line 729 "yaccParser/hsparser.y"
{ yyval.ulist = Lnil; ;
break;}
-case 151:
-#line 741 "yaccParser/hsparser.y"
+case 145:
+#line 730 "yaccParser/hsparser.y"
{ yyval.ulist = yyvsp[-1].ulist; ;
break;}
-case 152:
-#line 745 "yaccParser/hsparser.y"
+case 146:
+#line 734 "yaccParser/hsparser.y"
{ yyval.ulist = lsing(yyvsp[0].ucoresyn); ;
break;}
-case 153:
-#line 746 "yaccParser/hsparser.y"
+case 147:
+#line 735 "yaccParser/hsparser.y"
{ yyval.ulist = lapp(yyvsp[-2].ulist, yyvsp[0].ucoresyn); ;
break;}
-case 154:
-#line 750 "yaccParser/hsparser.y"
+case 148:
+#line 739 "yaccParser/hsparser.y"
{ yyval.ucoresyn = mkcolit(yyvsp[0].uliteral); ;
break;}
-case 155:
-#line 751 "yaccParser/hsparser.y"
+case 149:
+#line 740 "yaccParser/hsparser.y"
{ yyval.ucoresyn = mkcolocal(yyvsp[0].ucoresyn); ;
break;}
-case 156:
-#line 755 "yaccParser/hsparser.y"
+case 150:
+#line 744 "yaccParser/hsparser.y"
{ yyval.ulist = lsing(yyvsp[0].uid); ;
break;}
-case 157:
-#line 756 "yaccParser/hsparser.y"
+case 151:
+#line 745 "yaccParser/hsparser.y"
{ yyval.ulist = lapp(yyvsp[-1].ulist, yyvsp[0].uid); ;
break;}
-case 158:
-#line 760 "yaccParser/hsparser.y"
+case 152:
+#line 749 "yaccParser/hsparser.y"
{ yyval.ulist = lsing(yyvsp[0].uid); ;
break;}
-case 159:
-#line 761 "yaccParser/hsparser.y"
+case 153:
+#line 750 "yaccParser/hsparser.y"
{ yyval.ulist = lapp(yyvsp[-2].ulist, yyvsp[0].uid); ;
break;}
-case 160:
-#line 765 "yaccParser/hsparser.y"
+case 154:
+#line 754 "yaccParser/hsparser.y"
{ yyval.ulist = Lnil; ;
break;}
-case 161:
-#line 766 "yaccParser/hsparser.y"
+case 155:
+#line 755 "yaccParser/hsparser.y"
{ yyval.ulist = yyvsp[-1].ulist; ;
break;}
-case 162:
-#line 770 "yaccParser/hsparser.y"
+case 156:
+#line 759 "yaccParser/hsparser.y"
{ yyval.ulist = lsing(yyvsp[0].uttype); ;
break;}
-case 163:
-#line 771 "yaccParser/hsparser.y"
+case 157:
+#line 760 "yaccParser/hsparser.y"
{ yyval.ulist = lapp(yyvsp[-2].ulist, yyvsp[0].uttype); ;
break;}
-case 164:
-#line 775 "yaccParser/hsparser.y"
+case 158:
+#line 764 "yaccParser/hsparser.y"
{ yyval.uttype = yyvsp[0].uttype; ;
break;}
-case 165:
-#line 795 "yaccParser/hsparser.y"
+case 159:
+#line 784 "yaccParser/hsparser.y"
{ yyval.ulist = lsing(yyvsp[0].uttype); ;
break;}
-case 166:
-#line 796 "yaccParser/hsparser.y"
+case 160:
+#line 785 "yaccParser/hsparser.y"
{ yyval.ulist = lapp(yyvsp[-2].ulist, yyvsp[0].uttype); ;
break;}
-case 167:
-#line 800 "yaccParser/hsparser.y"
+case 161:
+#line 789 "yaccParser/hsparser.y"
{ yyval.uttype = mkty_maybe_nothing(); ;
break;}
-case 168:
-#line 801 "yaccParser/hsparser.y"
+case 162:
+#line 790 "yaccParser/hsparser.y"
{ yyval.uttype = mkty_maybe_just(yyvsp[0].uttype); ;
break;}
-case 169:
-#line 807 "yaccParser/hsparser.y"
+case 163:
+#line 796 "yaccParser/hsparser.y"
{
if ( implicitPrelude && !etags ) {
/* we try to avoid reading interfaces when etagging */
enteriscope();
;
break;}
-case 170:
-#line 821 "yaccParser/hsparser.y"
+case 164:
+#line 810 "yaccParser/hsparser.y"
{
binding prelude_core = mkimport(installid(iface_name),Lnil,Lnil,yyvsp[0].ubinding,xstrdup(interface_filename),hsplineno);
prelude_core_import = implicitPrelude? lsing(prelude_core): Lnil;
;
break;}
-case 171:
-#line 829 "yaccParser/hsparser.y"
+case 165:
+#line 818 "yaccParser/hsparser.y"
{
if ( implicitPrelude && !etags ) {
find_module_on_imports_dirlist(
enteriscope();
;
break;}
-case 172:
-#line 842 "yaccParser/hsparser.y"
+case 166:
+#line 831 "yaccParser/hsparser.y"
{
binding prelude = mkimport(installid(iface_name),Lnil,Lnil,yyvsp[0].ubinding,xstrdup(interface_filename),hsplineno);
prelude_imports = (! implicitPrelude) ? Lnil
: lconc(prelude_core_import,lsing(prelude));
;
break;}
-case 173:
-#line 849 "yaccParser/hsparser.y"
+case 167:
+#line 838 "yaccParser/hsparser.y"
{ yyval.ulist = Lnil; ;
break;}
-case 174:
-#line 850 "yaccParser/hsparser.y"
+case 168:
+#line 839 "yaccParser/hsparser.y"
{ yyval.ulist = yyvsp[-1].ulist; ;
break;}
-case 175:
-#line 853 "yaccParser/hsparser.y"
+case 169:
+#line 842 "yaccParser/hsparser.y"
{ yyval.ulist = yyvsp[0].ulist; ;
break;}
-case 176:
-#line 854 "yaccParser/hsparser.y"
+case 170:
+#line 843 "yaccParser/hsparser.y"
{ yyval.ulist = lconc(yyvsp[-2].ulist,yyvsp[0].ulist); ;
break;}
-case 177:
-#line 858 "yaccParser/hsparser.y"
+case 171:
+#line 847 "yaccParser/hsparser.y"
{ /* filename returned in "interface_filename" */
char *module_name = id_to_string(yyvsp[0].uid);
if ( ! etags ) {
}
;
break;}
-case 178:
-#line 879 "yaccParser/hsparser.y"
+case 172:
+#line 868 "yaccParser/hsparser.y"
{
if (hidden)
yyvsp[0].ubinding->tag = hiding;
yyval.ulist = lsing(yyvsp[0].ubinding);
;
break;}
-case 179:
-#line 887 "yaccParser/hsparser.y"
+case 173:
+#line 876 "yaccParser/hsparser.y"
{ yyval.ubinding = mkimport(installid(iface_name),yyvsp[0].ulist,Lnil,yyvsp[-1].ubinding,xstrdup(interface_filename),hsplineno); ;
break;}
-case 180:
-#line 890 "yaccParser/hsparser.y"
+case 174:
+#line 879 "yaccParser/hsparser.y"
{ yyval.ubinding = mkimport(installid(iface_name),yyvsp[-2].ulist,yyvsp[0].ulist,yyvsp[-3].ubinding,xstrdup(interface_filename),hsplineno); ;
break;}
-case 181:
-#line 895 "yaccParser/hsparser.y"
+case 175:
+#line 884 "yaccParser/hsparser.y"
{
exposeis(); /* partain: expose infix ops at level i+1 to level i */
yyval.ubinding = yyvsp[-1].ubinding;
;
break;}
-case 182:
-#line 901 "yaccParser/hsparser.y"
+case 176:
+#line 890 "yaccParser/hsparser.y"
{ yyval.ulist = yyvsp[-1].ulist; ;
break;}
-case 183:
-#line 905 "yaccParser/hsparser.y"
+case 177:
+#line 894 "yaccParser/hsparser.y"
{ yyval.ulist = lsing(yyvsp[0].ulist); ;
break;}
-case 184:
-#line 906 "yaccParser/hsparser.y"
+case 178:
+#line 895 "yaccParser/hsparser.y"
{ yyval.ulist = lapp(yyvsp[-2].ulist, yyvsp[0].ulist); ;
break;}
-case 185:
-#line 909 "yaccParser/hsparser.y"
+case 179:
+#line 898 "yaccParser/hsparser.y"
{ yyval.ulist = ldub(yyvsp[-2].uid,yyvsp[0].uid); ;
break;}
-case 186:
-#line 910 "yaccParser/hsparser.y"
+case 180:
+#line 899 "yaccParser/hsparser.y"
{ yyval.ulist = ldub(yyvsp[-2].uid,yyvsp[0].uid); ;
break;}
-case 187:
-#line 913 "yaccParser/hsparser.y"
+case 181:
+#line 902 "yaccParser/hsparser.y"
{ yyval.ubinding = mknullbind(); ;
break;}
-case 188:
-#line 914 "yaccParser/hsparser.y"
+case 182:
+#line 903 "yaccParser/hsparser.y"
{ yyval.ubinding = yyvsp[-1].ubinding; ;
break;}
-case 189:
-#line 917 "yaccParser/hsparser.y"
+case 183:
+#line 906 "yaccParser/hsparser.y"
{ yyval.ubinding = yyvsp[0].ubinding; ;
break;}
-case 190:
-#line 918 "yaccParser/hsparser.y"
+case 184:
+#line 907 "yaccParser/hsparser.y"
{ yyval.ubinding = mkabind(yyvsp[-2].ubinding,yyvsp[0].ubinding); ;
break;}
-case 191:
-#line 922 "yaccParser/hsparser.y"
+case 185:
+#line 911 "yaccParser/hsparser.y"
{ yyval.ubinding = mkmbind(yyvsp[-3].uid,yyvsp[-1].ulist,Lnil,startlineno); ;
break;}
-case 192:
-#line 924 "yaccParser/hsparser.y"
+case 186:
+#line 913 "yaccParser/hsparser.y"
{ yyval.ubinding = mkmbind(yyvsp[-5].uid,yyvsp[-3].ulist,yyvsp[0].ulist,startlineno); ;
break;}
-case 193:
-#line 930 "yaccParser/hsparser.y"
+case 187:
+#line 919 "yaccParser/hsparser.y"
{ /* OLD 95/08: fixlist = Lnil; */
strcpy(iface_name, id_to_string(yyvsp[0].uid));
;
break;}
-case 194:
-#line 934 "yaccParser/hsparser.y"
+case 188:
+#line 923 "yaccParser/hsparser.y"
{
/* WDP: not only do we not check the module name
but we take the one in the interface to be what we really want
yyval.ubinding = yyvsp[0].ubinding;
;
break;}
-case 195:
-#line 947 "yaccParser/hsparser.y"
+case 189:
+#line 936 "yaccParser/hsparser.y"
{
yyval.ubinding = mkabind(yyvsp[-3].ubinding,yyvsp[-1].ubinding);
;
break;}
-case 196:
-#line 951 "yaccParser/hsparser.y"
+case 190:
+#line 940 "yaccParser/hsparser.y"
{
yyval.ubinding = yyvsp[-1].ubinding;
;
break;}
-case 197:
-#line 955 "yaccParser/hsparser.y"
+case 191:
+#line 944 "yaccParser/hsparser.y"
{
yyval.ubinding = mkabind(yyvsp[-3].ubinding,yyvsp[-1].ubinding);
;
break;}
-case 198:
-#line 959 "yaccParser/hsparser.y"
+case 192:
+#line 948 "yaccParser/hsparser.y"
{
yyval.ubinding = yyvsp[-1].ubinding;
;
break;}
-case 203:
-#line 974 "yaccParser/hsparser.y"
+case 197:
+#line 963 "yaccParser/hsparser.y"
{ Precedence = checkfixity(yyvsp[0].ustring); Fixity = INFIXL; ;
break;}
-case 205:
-#line 977 "yaccParser/hsparser.y"
+case 199:
+#line 966 "yaccParser/hsparser.y"
{ Precedence = checkfixity(yyvsp[0].ustring); Fixity = INFIXR; ;
break;}
-case 207:
-#line 980 "yaccParser/hsparser.y"
+case 201:
+#line 969 "yaccParser/hsparser.y"
{ Precedence = checkfixity(yyvsp[0].ustring); Fixity = INFIX; ;
break;}
-case 209:
-#line 983 "yaccParser/hsparser.y"
+case 203:
+#line 972 "yaccParser/hsparser.y"
{ Fixity = INFIXL; Precedence = 9; ;
break;}
-case 211:
-#line 986 "yaccParser/hsparser.y"
+case 205:
+#line 975 "yaccParser/hsparser.y"
{ Fixity = INFIXR; Precedence = 9; ;
break;}
-case 213:
-#line 989 "yaccParser/hsparser.y"
+case 207:
+#line 978 "yaccParser/hsparser.y"
{ Fixity = INFIX; Precedence = 9; ;
break;}
-case 215:
-#line 993 "yaccParser/hsparser.y"
+case 209:
+#line 982 "yaccParser/hsparser.y"
{ makeinfix(id_to_string(yyvsp[0].uid),Fixity,Precedence); ;
break;}
-case 216:
-#line 994 "yaccParser/hsparser.y"
+case 210:
+#line 983 "yaccParser/hsparser.y"
{ makeinfix(id_to_string(yyvsp[0].uid),Fixity,Precedence); ;
break;}
-case 218:
-#line 999 "yaccParser/hsparser.y"
+case 212:
+#line 988 "yaccParser/hsparser.y"
{
if(yyvsp[-2].ubinding != NULL)
if(yyvsp[0].ubinding != NULL)
SAMEFN = 0;
;
break;}
-case 219:
-#line 1017 "yaccParser/hsparser.y"
+case 213:
+#line 1006 "yaccParser/hsparser.y"
{ yyval.ubinding = yyvsp[0].ubinding; ;
break;}
-case 220:
-#line 1018 "yaccParser/hsparser.y"
+case 214:
+#line 1007 "yaccParser/hsparser.y"
{ yyval.ubinding = yyvsp[0].ubinding; ;
break;}
-case 221:
-#line 1019 "yaccParser/hsparser.y"
+case 215:
+#line 1008 "yaccParser/hsparser.y"
{ yyval.ubinding = yyvsp[0].ubinding; ;
break;}
-case 222:
-#line 1020 "yaccParser/hsparser.y"
+case 216:
+#line 1009 "yaccParser/hsparser.y"
{ yyval.ubinding = yyvsp[0].ubinding; ;
break;}
-case 223:
-#line 1021 "yaccParser/hsparser.y"
+case 217:
+#line 1010 "yaccParser/hsparser.y"
{ yyval.ubinding = yyvsp[0].ubinding; ;
break;}
-case 224:
-#line 1022 "yaccParser/hsparser.y"
+case 218:
+#line 1011 "yaccParser/hsparser.y"
{ yyval.ubinding = yyvsp[0].ubinding; ;
break;}
-case 225:
-#line 1025 "yaccParser/hsparser.y"
+case 219:
+#line 1014 "yaccParser/hsparser.y"
{ yyval.ubinding = mknbind(yyvsp[-2].uttype,yyvsp[0].uttype,startlineno,mkno_pragma()); ;
break;}
-case 226:
-#line 1030 "yaccParser/hsparser.y"
+case 220:
+#line 1019 "yaccParser/hsparser.y"
{ yyval.ubinding = mktbind(yyvsp[-4].ulist,yyvsp[-2].uttype,yyvsp[0].ulist,all,startlineno,mkno_pragma()); ;
break;}
-case 227:
-#line 1032 "yaccParser/hsparser.y"
+case 221:
+#line 1021 "yaccParser/hsparser.y"
{ yyval.ubinding = mktbind(Lnil,yyvsp[-2].uttype,yyvsp[0].ulist,all,startlineno,mkno_pragma()); ;
break;}
+case 222:
+#line 1023 "yaccParser/hsparser.y"
+{ yyval.ubinding = mktbind(yyvsp[-6].ulist,yyvsp[-4].uttype,yyvsp[-2].ulist,yyvsp[0].ulist,startlineno,mkno_pragma()); ;
+ break;}
+case 223:
+#line 1025 "yaccParser/hsparser.y"
+{ yyval.ubinding = mktbind(Lnil,yyvsp[-4].uttype,yyvsp[-2].ulist,yyvsp[0].ulist,startlineno,mkno_pragma()); ;
+ break;}
+case 224:
+#line 1028 "yaccParser/hsparser.y"
+{ yyval.ubinding = mkcbind(yyvsp[-3].ulist,yyvsp[-1].uttype,yyvsp[0].ubinding,startlineno,mkno_pragma()); ;
+ break;}
+case 225:
+#line 1029 "yaccParser/hsparser.y"
+{ yyval.ubinding = mkcbind(Lnil,yyvsp[-1].uttype,yyvsp[0].ubinding,startlineno,mkno_pragma()); ;
+ break;}
+case 226:
+#line 1032 "yaccParser/hsparser.y"
+{ yyval.ubinding = mknullbind(); ;
+ break;}
+case 227:
+#line 1033 "yaccParser/hsparser.y"
+{ checkorder(yyvsp[-1].ubinding); yyval.ubinding = yyvsp[-1].ubinding; ;
+ break;}
case 228:
#line 1034 "yaccParser/hsparser.y"
-{ yyval.ubinding = mktbind(yyvsp[-6].ulist,yyvsp[-4].uttype,yyvsp[-2].ulist,yyvsp[0].ulist,startlineno,mkno_pragma()); ;
+{ checkorder(yyvsp[-1].ubinding); yyval.ubinding =yyvsp[-1].ubinding; ;
break;}
case 229:
-#line 1036 "yaccParser/hsparser.y"
-{ yyval.ubinding = mktbind(Lnil,yyvsp[-4].uttype,yyvsp[-2].ulist,yyvsp[0].ulist,startlineno,mkno_pragma()); ;
+#line 1037 "yaccParser/hsparser.y"
+{ yyval.ubinding = mkibind(yyvsp[-4].ulist,yyvsp[-2].uid,yyvsp[-1].uttype,yyvsp[0].ubinding,startlineno,mkno_pragma()); ;
break;}
case 230:
-#line 1039 "yaccParser/hsparser.y"
-{ yyval.ubinding = mkcbind(yyvsp[-3].ulist,yyvsp[-1].uttype,yyvsp[0].ubinding,startlineno,mkno_pragma()); ;
+#line 1038 "yaccParser/hsparser.y"
+{ yyval.ubinding = mkibind(Lnil,yyvsp[-2].uid,yyvsp[-1].uttype,yyvsp[0].ubinding,startlineno,mkno_pragma()); ;
break;}
case 231:
-#line 1040 "yaccParser/hsparser.y"
-{ yyval.ubinding = mkcbind(Lnil,yyvsp[-1].uttype,yyvsp[0].ubinding,startlineno,mkno_pragma()); ;
+#line 1041 "yaccParser/hsparser.y"
+{ yyval.ubinding = mknullbind(); ;
break;}
case 232:
-#line 1043 "yaccParser/hsparser.y"
-{ yyval.ubinding = mknullbind(); ;
+#line 1042 "yaccParser/hsparser.y"
+{ yyval.ubinding = yyvsp[-1].ubinding; ;
break;}
case 233:
-#line 1044 "yaccParser/hsparser.y"
-{ checkorder(yyvsp[-1].ubinding); yyval.ubinding = yyvsp[-1].ubinding; ;
+#line 1043 "yaccParser/hsparser.y"
+{ yyval.ubinding = yyvsp[-1].ubinding; ;
break;}
case 234:
-#line 1045 "yaccParser/hsparser.y"
-{ checkorder(yyvsp[-1].ubinding); yyval.ubinding =yyvsp[-1].ubinding; ;
+#line 1046 "yaccParser/hsparser.y"
+{ yyval.uttype = mktname(yyvsp[0].uid,Lnil); ;
break;}
case 235:
-#line 1048 "yaccParser/hsparser.y"
-{ yyval.ubinding = mkibind(yyvsp[-4].ulist,yyvsp[-2].uid,yyvsp[-1].uttype,yyvsp[0].ubinding,startlineno,mkno_pragma()); ;
+#line 1047 "yaccParser/hsparser.y"
+{ yyval.uttype = mktname(yyvsp[-2].uid,yyvsp[-1].ulist); ;
break;}
case 236:
-#line 1049 "yaccParser/hsparser.y"
-{ yyval.ubinding = mkibind(Lnil,yyvsp[-2].uid,yyvsp[-1].uttype,yyvsp[0].ubinding,startlineno,mkno_pragma()); ;
+#line 1048 "yaccParser/hsparser.y"
+{ yyval.uttype = mkttuple(mklcons(yyvsp[-3].uttype,yyvsp[-1].ulist)); ;
break;}
case 237:
-#line 1052 "yaccParser/hsparser.y"
-{ yyval.ubinding = mknullbind(); ;
+#line 1049 "yaccParser/hsparser.y"
+{ yyval.uttype = mkttuple(Lnil); ;
break;}
case 238:
-#line 1053 "yaccParser/hsparser.y"
-{ yyval.ubinding = yyvsp[-1].ubinding; ;
+#line 1050 "yaccParser/hsparser.y"
+{ yyval.uttype = mktllist(yyvsp[-1].uttype); ;
break;}
case 239:
-#line 1054 "yaccParser/hsparser.y"
-{ yyval.ubinding = yyvsp[-1].ubinding; ;
+#line 1051 "yaccParser/hsparser.y"
+{ yyval.uttype = mktfun(yyvsp[-3].uttype,yyvsp[-1].uttype); ;
break;}
case 240:
-#line 1057 "yaccParser/hsparser.y"
+#line 1054 "yaccParser/hsparser.y"
{ yyval.uttype = mktname(yyvsp[0].uid,Lnil); ;
break;}
case 241:
-#line 1058 "yaccParser/hsparser.y"
-{ yyval.uttype = yyvsp[-1].uttype; ;
+#line 1055 "yaccParser/hsparser.y"
+{ yyval.uttype = mktname(yyvsp[-2].uid,yyvsp[-1].ulist); ;
break;}
case 242:
-#line 1060 "yaccParser/hsparser.y"
-{ yyval.uttype = mkttuple(yyvsp[-1].ulist); ;
+#line 1056 "yaccParser/hsparser.y"
+{ yyval.uttype = mkttuple(mklcons(yyvsp[-3].uttype,yyvsp[-1].ulist)); ;
break;}
case 243:
-#line 1061 "yaccParser/hsparser.y"
+#line 1057 "yaccParser/hsparser.y"
{ yyval.uttype = mkttuple(Lnil); ;
break;}
case 244:
-#line 1062 "yaccParser/hsparser.y"
+#line 1058 "yaccParser/hsparser.y"
{ yyval.uttype = mktllist(yyvsp[-1].uttype); ;
break;}
case 245:
-#line 1063 "yaccParser/hsparser.y"
+#line 1059 "yaccParser/hsparser.y"
{ yyval.uttype = mktfun(yyvsp[-3].uttype,yyvsp[-1].uttype); ;
break;}
case 246:
-#line 1066 "yaccParser/hsparser.y"
+#line 1062 "yaccParser/hsparser.y"
{ yyval.ubinding = mkdbind(yyvsp[0].ulist,startlineno); ;
break;}
case 247:
-#line 1069 "yaccParser/hsparser.y"
+#line 1065 "yaccParser/hsparser.y"
{ yyval.ulist = mklcons(yyvsp[-3].uttype,yyvsp[-1].ulist); ;
break;}
case 248:
-#line 1070 "yaccParser/hsparser.y"
+#line 1066 "yaccParser/hsparser.y"
{ yyval.ulist = lsing(yyvsp[0].uttype); ;
break;}
case 250:
-#line 1079 "yaccParser/hsparser.y"
+#line 1075 "yaccParser/hsparser.y"
{
if(SAMEFN)
{
;
break;}
case 251:
-#line 1108 "yaccParser/hsparser.y"
+#line 1104 "yaccParser/hsparser.y"
{ /* type2context.c for code */
yyval.ubinding = mksbind(yyvsp[-5].ulist,mkcontext(type2context(yyvsp[-3].uttype),yyvsp[-1].uttype),startlineno,yyvsp[0].uhpragma);
PREVPATT = NULL; FN = NULL; SAMEFN = 0;
;
break;}
case 252:
-#line 1113 "yaccParser/hsparser.y"
+#line 1109 "yaccParser/hsparser.y"
{
yyval.ubinding = mksbind(yyvsp[-3].ulist,yyvsp[-1].uttype,startlineno,yyvsp[0].uhpragma);
PREVPATT = NULL; FN = NULL; SAMEFN = 0;
;
break;}
case 253:
-#line 1126 "yaccParser/hsparser.y"
+#line 1122 "yaccParser/hsparser.y"
{
yyval.ubinding = mkvspec_uprag(yyvsp[-3].uid, yyvsp[-1].ulist, startlineno);
PREVPATT = NULL; FN = NULL; SAMEFN = 0;
;
break;}
case 254:
-#line 1132 "yaccParser/hsparser.y"
+#line 1128 "yaccParser/hsparser.y"
{
yyval.ubinding = mkispec_uprag(yyvsp[-2].uid, yyvsp[-1].uttype, startlineno);
PREVPATT = NULL; FN = NULL; SAMEFN = 0;
;
break;}
case 255:
-#line 1138 "yaccParser/hsparser.y"
+#line 1134 "yaccParser/hsparser.y"
{
yyval.ubinding = mkdspec_uprag(yyvsp[-2].uid, yyvsp[-1].ulist, startlineno);
PREVPATT = NULL; FN = NULL; SAMEFN = 0;
;
break;}
case 256:
-#line 1144 "yaccParser/hsparser.y"
+#line 1140 "yaccParser/hsparser.y"
{
yyval.ubinding = mkinline_uprag(yyvsp[-2].uid, yyvsp[-1].ulist, startlineno);
PREVPATT = NULL; FN = NULL; SAMEFN = 0;
;
break;}
case 257:
-#line 1150 "yaccParser/hsparser.y"
+#line 1146 "yaccParser/hsparser.y"
{
yyval.ubinding = mkmagicuf_uprag(yyvsp[-2].uid, yyvsp[-1].uid, startlineno);
PREVPATT = NULL; FN = NULL; SAMEFN = 0;
;
break;}
case 258:
-#line 1156 "yaccParser/hsparser.y"
+#line 1152 "yaccParser/hsparser.y"
{
yyval.ubinding = mkdeforest_uprag(yyvsp[-1].uid, startlineno);
PREVPATT = NULL; FN = NULL; SAMEFN = 0;
;
break;}
case 259:
-#line 1162 "yaccParser/hsparser.y"
+#line 1158 "yaccParser/hsparser.y"
{
yyval.ubinding = mkabstract_uprag(yyvsp[-1].uid, startlineno);
PREVPATT = NULL; FN = NULL; SAMEFN = 0;
;
break;}
case 261:
-#line 1170 "yaccParser/hsparser.y"
+#line 1166 "yaccParser/hsparser.y"
{ yyval.ubinding = mknullbind(); PREVPATT = NULL; FN = NULL; SAMEFN = 0; ;
break;}
case 262:
-#line 1174 "yaccParser/hsparser.y"
+#line 1170 "yaccParser/hsparser.y"
{ yyval.ulist = Lnil; ;
break;}
case 263:
-#line 1175 "yaccParser/hsparser.y"
+#line 1171 "yaccParser/hsparser.y"
{ yyval.ulist = lsing(yyvsp[0].uid); ;
break;}
case 264:
-#line 1178 "yaccParser/hsparser.y"
+#line 1174 "yaccParser/hsparser.y"
{ yyval.ulist = lsing(yyvsp[0].ubinding); ;
break;}
case 265:
-#line 1179 "yaccParser/hsparser.y"
+#line 1175 "yaccParser/hsparser.y"
{ yyval.ulist = lapp(yyvsp[-2].ulist,yyvsp[0].ubinding); ;
break;}
case 266:
-#line 1183 "yaccParser/hsparser.y"
+#line 1179 "yaccParser/hsparser.y"
{ yyval.ubinding = mkvspec_ty_and_id(yyvsp[0].uttype,Lnil); ;
break;}
case 267:
-#line 1184 "yaccParser/hsparser.y"
+#line 1180 "yaccParser/hsparser.y"
{ yyval.ubinding = mkvspec_ty_and_id(yyvsp[-2].uttype,lsing(yyvsp[0].uid)); ;
break;}
case 268:
-#line 1186 "yaccParser/hsparser.y"
+#line 1182 "yaccParser/hsparser.y"
{ yyval.ubinding = yyvsp[0].ubinding; ;
break;}
case 269:
-#line 1187 "yaccParser/hsparser.y"
+#line 1183 "yaccParser/hsparser.y"
{ yyval.ubinding = mkabind(yyvsp[-2].ubinding,yyvsp[0].ubinding); ;
break;}
case 270:
-#line 1190 "yaccParser/hsparser.y"
+#line 1186 "yaccParser/hsparser.y"
{ yyval.ubinding = yyvsp[0].ubinding; ;
break;}
case 271:
-#line 1191 "yaccParser/hsparser.y"
+#line 1187 "yaccParser/hsparser.y"
{ yyval.ubinding = yyvsp[0].ubinding; ;
break;}
case 272:
-#line 1192 "yaccParser/hsparser.y"
+#line 1188 "yaccParser/hsparser.y"
{ yyval.ubinding = yyvsp[0].ubinding; ;
break;}
case 273:
-#line 1193 "yaccParser/hsparser.y"
+#line 1189 "yaccParser/hsparser.y"
{ yyval.ubinding = yyvsp[0].ubinding; ;
break;}
case 274:
-#line 1194 "yaccParser/hsparser.y"
+#line 1190 "yaccParser/hsparser.y"
{ yyval.ubinding = yyvsp[0].ubinding; ;
break;}
case 275:
-#line 1195 "yaccParser/hsparser.y"
+#line 1191 "yaccParser/hsparser.y"
{ yyval.ubinding = mknullbind(); ;
break;}
case 276:
-#line 1200 "yaccParser/hsparser.y"
+#line 1196 "yaccParser/hsparser.y"
{ yyval.ubinding = mksbind(yyvsp[-5].ulist,mkcontext(type2context(yyvsp[-3].uttype),yyvsp[-1].uttype),startlineno,yyvsp[0].uhpragma); ;
break;}
case 277:
-#line 1202 "yaccParser/hsparser.y"
+#line 1198 "yaccParser/hsparser.y"
{ yyval.ubinding = mksbind(yyvsp[-3].ulist,yyvsp[-1].uttype,startlineno,yyvsp[0].uhpragma); ;
break;}
case 278:
-#line 1206 "yaccParser/hsparser.y"
+#line 1202 "yaccParser/hsparser.y"
{ yyval.ubinding = mknbind(yyvsp[-3].uttype,yyvsp[-1].uttype,startlineno,yyvsp[0].uhpragma); ;
break;}
case 279:
-#line 1210 "yaccParser/hsparser.y"
+#line 1206 "yaccParser/hsparser.y"
{ yyval.ubinding = mktbind(yyvsp[-3].ulist,yyvsp[-1].uttype,Lnil,Lnil,startlineno,yyvsp[0].uhpragma); ;
break;}
case 280:
-#line 1212 "yaccParser/hsparser.y"
+#line 1208 "yaccParser/hsparser.y"
{ yyval.ubinding = mktbind(Lnil,yyvsp[-1].uttype,Lnil,Lnil,startlineno,yyvsp[0].uhpragma); ;
break;}
case 281:
-#line 1214 "yaccParser/hsparser.y"
+#line 1210 "yaccParser/hsparser.y"
{ yyval.ubinding = mktbind(yyvsp[-5].ulist,yyvsp[-3].uttype,yyvsp[-1].ulist,Lnil,startlineno,yyvsp[0].uhpragma); ;
break;}
case 282:
-#line 1216 "yaccParser/hsparser.y"
+#line 1212 "yaccParser/hsparser.y"
{ yyval.ubinding = mktbind(Lnil,yyvsp[-3].uttype,yyvsp[-1].ulist,Lnil,startlineno,yyvsp[0].uhpragma); ;
break;}
case 283:
-#line 1218 "yaccParser/hsparser.y"
+#line 1214 "yaccParser/hsparser.y"
{ yyval.ubinding = mktbind(yyvsp[-6].ulist,yyvsp[-4].uttype,yyvsp[-2].ulist,yyvsp[0].ulist,startlineno,mkno_pragma()); ;
break;}
case 284:
-#line 1220 "yaccParser/hsparser.y"
+#line 1216 "yaccParser/hsparser.y"
{ yyval.ubinding = mktbind(Lnil,yyvsp[-4].uttype,yyvsp[-2].ulist,yyvsp[0].ulist,startlineno,mkno_pragma()); ;
break;}
case 285:
-#line 1224 "yaccParser/hsparser.y"
+#line 1220 "yaccParser/hsparser.y"
{ yyval.ubinding = mkcbind(yyvsp[-4].ulist,yyvsp[-2].uttype,yyvsp[0].ubinding,startlineno,yyvsp[-1].uhpragma); ;
break;}
case 286:
-#line 1226 "yaccParser/hsparser.y"
+#line 1222 "yaccParser/hsparser.y"
{ yyval.ubinding = mkcbind(Lnil,yyvsp[-2].uttype,yyvsp[0].ubinding,startlineno,yyvsp[-1].uhpragma); ;
break;}
case 287:
-#line 1230 "yaccParser/hsparser.y"
+#line 1226 "yaccParser/hsparser.y"
{ yyval.ubinding = mkibind(yyvsp[-4].ulist,yyvsp[-2].uid,yyvsp[-1].uttype,mknullbind(),startlineno,yyvsp[0].uhpragma); ;
break;}
case 288:
-#line 1232 "yaccParser/hsparser.y"
+#line 1228 "yaccParser/hsparser.y"
{ yyval.ubinding = mkibind(Lnil,yyvsp[-2].uid,yyvsp[-1].uttype,mknullbind(),startlineno,yyvsp[0].uhpragma); ;
break;}
case 289:
-#line 1238 "yaccParser/hsparser.y"
+#line 1234 "yaccParser/hsparser.y"
{ yyval.uttype = mktname(yyvsp[-1].uid,lsing(yyvsp[0].uttype)); ;
break;}
case 290:
-#line 1242 "yaccParser/hsparser.y"
+#line 1238 "yaccParser/hsparser.y"
{ yyval.ulist = lsing(yyvsp[0].uttype); ;
break;}
case 291:
-#line 1243 "yaccParser/hsparser.y"
+#line 1239 "yaccParser/hsparser.y"
{ yyval.ulist = lapp(yyvsp[-2].ulist,yyvsp[0].uttype); ;
break;}
case 292:
-#line 1246 "yaccParser/hsparser.y"
+#line 1242 "yaccParser/hsparser.y"
{ yyval.uttype = yyvsp[0].uttype; ;
break;}
case 293:
-#line 1247 "yaccParser/hsparser.y"
+#line 1243 "yaccParser/hsparser.y"
{ yyval.uttype = mktfun(yyvsp[-2].uttype,yyvsp[0].uttype); ;
break;}
case 294:
-#line 1250 "yaccParser/hsparser.y"
+#line 1246 "yaccParser/hsparser.y"
{ yyval.uttype = mkuniforall(yyvsp[-2].ulist, yyvsp[0].uttype); ;
break;}
case 295:
-#line 1252 "yaccParser/hsparser.y"
+#line 1248 "yaccParser/hsparser.y"
{ yyval.uttype = yyvsp[0].uttype; ;
break;}
case 296:
-#line 1253 "yaccParser/hsparser.y"
+#line 1249 "yaccParser/hsparser.y"
{ yyval.uttype = mktname(yyvsp[-1].uid,yyvsp[0].ulist); ;
break;}
case 297:
-#line 1256 "yaccParser/hsparser.y"
+#line 1252 "yaccParser/hsparser.y"
{ yyval.ulist = lapp(yyvsp[-1].ulist,yyvsp[0].uttype); ;
break;}
case 298:
-#line 1257 "yaccParser/hsparser.y"
+#line 1253 "yaccParser/hsparser.y"
{ yyval.ulist = lsing(yyvsp[0].uttype); ;
break;}
case 299:
-#line 1261 "yaccParser/hsparser.y"
+#line 1257 "yaccParser/hsparser.y"
{ yyval.uttype = yyvsp[0].uttype; ;
break;}
case 300:
-#line 1262 "yaccParser/hsparser.y"
+#line 1258 "yaccParser/hsparser.y"
{ yyval.uttype = mktfun(yyvsp[-2].uttype,yyvsp[0].uttype); ;
break;}
case 301:
-#line 1263 "yaccParser/hsparser.y"
+#line 1259 "yaccParser/hsparser.y"
{ yyval.uttype = mktname(yyvsp[-1].uid,yyvsp[0].ulist); ;
break;}
case 303:
-#line 1267 "yaccParser/hsparser.y"
+#line 1263 "yaccParser/hsparser.y"
{ yyval.uttype = mkttuple(mklcons(yyvsp[-3].uttype,yyvsp[-1].ulist)); ;
break;}
case 304:
-#line 1270 "yaccParser/hsparser.y"
+#line 1266 "yaccParser/hsparser.y"
{ yyval.uttype = yyvsp[0].uttype; ;
break;}
case 305:
-#line 1271 "yaccParser/hsparser.y"
+#line 1267 "yaccParser/hsparser.y"
{ yyval.uttype = mktname(yyvsp[0].uid,Lnil); ;
break;}
case 306:
-#line 1272 "yaccParser/hsparser.y"
+#line 1268 "yaccParser/hsparser.y"
{ yyval.uttype = mkttuple(Lnil); ;
break;}
case 307:
-#line 1273 "yaccParser/hsparser.y"
+#line 1269 "yaccParser/hsparser.y"
{ yyval.uttype = yyvsp[-1].uttype; ;
break;}
case 308:
-#line 1274 "yaccParser/hsparser.y"
+#line 1270 "yaccParser/hsparser.y"
{ yyval.uttype = mktllist(yyvsp[-1].uttype); ;
break;}
case 309:
-#line 1277 "yaccParser/hsparser.y"
+#line 1273 "yaccParser/hsparser.y"
{ yyval.uttype = mkunidict(yyvsp[-3].uid, yyvsp[-2].uttype); ;
break;}
case 310:
-#line 1278 "yaccParser/hsparser.y"
+#line 1274 "yaccParser/hsparser.y"
{ yyval.uttype = mkunityvartemplate(yyvsp[0].uid); ;
break;}
case 311:
-#line 1282 "yaccParser/hsparser.y"
+#line 1278 "yaccParser/hsparser.y"
{ yyval.uttype = mktname(yyvsp[0].uid,Lnil); ;
break;}
case 312:
-#line 1283 "yaccParser/hsparser.y"
+#line 1279 "yaccParser/hsparser.y"
{ yyval.uttype = mktname(yyvsp[-1].uid,yyvsp[0].ulist); ;
break;}
case 313:
-#line 1287 "yaccParser/hsparser.y"
-{ yyval.uttype = mktname(yyvsp[-1].uid,yyvsp[0].ulist); ;
+#line 1282 "yaccParser/hsparser.y"
+{ yyval.ulist = lsing(yyvsp[0].uatype); ;
break;}
case 314:
-#line 1293 "yaccParser/hsparser.y"
-{ yyval.ulist = lsing(yyvsp[0].uatype); ;
+#line 1283 "yaccParser/hsparser.y"
+{ yyval.ulist = lapp(yyvsp[-2].ulist,yyvsp[0].uatype); ;
break;}
case 315:
-#line 1294 "yaccParser/hsparser.y"
-{ yyval.ulist = lapp(yyvsp[-2].ulist,yyvsp[0].uatype); ;
+#line 1287 "yaccParser/hsparser.y"
+{ yyval.uatype = mkatc(yyvsp[-1].uid,yyvsp[0].ulist,hsplineno); ;
break;}
case 316:
-#line 1298 "yaccParser/hsparser.y"
-{ yyval.uatype = mkatc(yyvsp[-1].uid,yyvsp[0].ulist,hsplineno); ;
+#line 1288 "yaccParser/hsparser.y"
+{ yyval.uatype = mkatc(yyvsp[-2].uid,yyvsp[0].ulist,hsplineno); ;
break;}
case 317:
-#line 1299 "yaccParser/hsparser.y"
-{ yyval.uatype = mkatc(yyvsp[-2].uid,yyvsp[0].ulist,hsplineno); ;
+#line 1289 "yaccParser/hsparser.y"
+{ yyval.uatype = mkatc(yyvsp[0].uid,Lnil,hsplineno); ;
break;}
case 318:
-#line 1300 "yaccParser/hsparser.y"
-{ yyval.uatype = mkatc(yyvsp[0].uid,Lnil,hsplineno); ;
+#line 1290 "yaccParser/hsparser.y"
+{ yyval.uatype = mkatc(yyvsp[-1].uid,Lnil,hsplineno); ;
break;}
case 319:
-#line 1301 "yaccParser/hsparser.y"
-{ yyval.uatype = mkatc(yyvsp[-1].uid,Lnil,hsplineno); ;
+#line 1291 "yaccParser/hsparser.y"
+{ yyval.uatype = mkatc(yyvsp[-1].uid, ldub(yyvsp[-2].uttype,yyvsp[0].uttype),hsplineno); ;
break;}
case 320:
-#line 1302 "yaccParser/hsparser.y"
-{ yyval.uatype = mkatc(yyvsp[-1].uid, ldub(yyvsp[-2].uttype,yyvsp[0].uttype),hsplineno); ;
+#line 1294 "yaccParser/hsparser.y"
+{ yyval.ulist = yyvsp[-1].ulist; ;
break;}
case 321:
-#line 1305 "yaccParser/hsparser.y"
-{ yyval.ulist = yyvsp[-1].ulist; ;
+#line 1295 "yaccParser/hsparser.y"
+{ yyval.ulist = Lnil; ;
break;}
case 322:
-#line 1306 "yaccParser/hsparser.y"
-{ yyval.ulist = Lnil; ;
+#line 1296 "yaccParser/hsparser.y"
+{ yyval.ulist = lsing(yyvsp[0].uid); ;
break;}
case 323:
-#line 1307 "yaccParser/hsparser.y"
+#line 1299 "yaccParser/hsparser.y"
{ yyval.ulist = lsing(yyvsp[0].uid); ;
break;}
case 324:
-#line 1310 "yaccParser/hsparser.y"
-{ yyval.ulist = lsing(yyvsp[0].uid); ;
+#line 1300 "yaccParser/hsparser.y"
+{ yyval.ulist = lapp(yyvsp[-2].ulist,yyvsp[0].uid); ;
break;}
case 325:
-#line 1311 "yaccParser/hsparser.y"
-{ yyval.ulist = lapp(yyvsp[-2].ulist,yyvsp[0].uid); ;
+#line 1303 "yaccParser/hsparser.y"
+{ yyval.ulist = yyvsp[-1].ulist; ;
break;}
case 326:
-#line 1314 "yaccParser/hsparser.y"
-{ yyval.ulist = yyvsp[-1].ulist; ;
+#line 1304 "yaccParser/hsparser.y"
+{ yyval.ulist = lsing(yyvsp[0].uttype); ;
break;}
case 327:
-#line 1315 "yaccParser/hsparser.y"
+#line 1307 "yaccParser/hsparser.y"
{ yyval.ulist = lsing(yyvsp[0].uttype); ;
break;}
case 328:
-#line 1318 "yaccParser/hsparser.y"
-{ yyval.ulist = lsing(yyvsp[0].uttype); ;
- break;}
-case 329:
-#line 1319 "yaccParser/hsparser.y"
+#line 1308 "yaccParser/hsparser.y"
{ yyval.ulist = lapp(yyvsp[-2].ulist,yyvsp[0].uttype); ;
break;}
-case 330:
-#line 1322 "yaccParser/hsparser.y"
+case 329:
+#line 1311 "yaccParser/hsparser.y"
{ yyval.ubinding = mknullbind(); ;
break;}
-case 331:
-#line 1323 "yaccParser/hsparser.y"
+case 330:
+#line 1312 "yaccParser/hsparser.y"
{ yyval.ubinding = yyvsp[0].ubinding; ;
break;}
-case 332:
-#line 1325 "yaccParser/hsparser.y"
+case 331:
+#line 1314 "yaccParser/hsparser.y"
{
if(SAMEFN)
{
yyval.ubinding = mkabind(yyvsp[-2].ubinding,yyvsp[0].ubinding);
;
break;}
+case 332:
+#line 1328 "yaccParser/hsparser.y"
+{
+ yyval.ubinding = mkvspec_uprag(yyvsp[-3].uid, yyvsp[-1].ulist, startlineno);
+ PREVPATT = NULL; FN = NULL; SAMEFN = 0;
+ ;
+ break;}
case 333:
-#line 1339 "yaccParser/hsparser.y"
+#line 1334 "yaccParser/hsparser.y"
{
yyval.ubinding = mkinline_uprag(yyvsp[-2].uid, yyvsp[-1].ulist, startlineno);
PREVPATT = NULL; FN = NULL; SAMEFN = 0;
;
break;}
case 334:
-#line 1345 "yaccParser/hsparser.y"
+#line 1340 "yaccParser/hsparser.y"
{
yyval.ubinding = mkmagicuf_uprag(yyvsp[-2].uid, yyvsp[-1].uid, startlineno);
PREVPATT = NULL; FN = NULL; SAMEFN = 0;
;
break;}
case 336:
-#line 1354 "yaccParser/hsparser.y"
+#line 1349 "yaccParser/hsparser.y"
{ yyval.ulist = mklcons(yyvsp[-2].uid,yyvsp[0].ulist); ;
break;}
case 337:
-#line 1355 "yaccParser/hsparser.y"
+#line 1350 "yaccParser/hsparser.y"
{ yyval.ulist = lsing(yyvsp[0].uid); ;
break;}
case 338:
-#line 1359 "yaccParser/hsparser.y"
+#line 1353 "yaccParser/hsparser.y"
{ yyval.ulist = lsing(yyvsp[0].uid); ;
break;}
case 339:
-#line 1360 "yaccParser/hsparser.y"
+#line 1354 "yaccParser/hsparser.y"
{ yyval.ulist = lapp(yyvsp[-2].ulist,yyvsp[0].uid); ;
break;}
case 340:
-#line 1363 "yaccParser/hsparser.y"
+#line 1357 "yaccParser/hsparser.y"
{ yyval.ulist = lsing(yyvsp[0].uid); ;
break;}
case 341:
-#line 1364 "yaccParser/hsparser.y"
+#line 1358 "yaccParser/hsparser.y"
{ yyval.ulist = lapp(yyvsp[-2].ulist,yyvsp[0].uid); ;
break;}
case 342:
-#line 1369 "yaccParser/hsparser.y"
+#line 1363 "yaccParser/hsparser.y"
{
tree fn = function(yyvsp[0].utree);
;
break;}
case 343:
-#line 1394 "yaccParser/hsparser.y"
+#line 1388 "yaccParser/hsparser.y"
{
if ( lhs_is_patt(yyvsp[-2].utree) )
{
;
break;}
case 344:
-#line 1408 "yaccParser/hsparser.y"
+#line 1402 "yaccParser/hsparser.y"
{ yyval.ulist = lsing(createpat(yyvsp[-1].ulist, yyvsp[0].ubinding)); ;
break;}
case 346:
-#line 1412 "yaccParser/hsparser.y"
+#line 1406 "yaccParser/hsparser.y"
{ yyval.ulist = lsing(mktruecase(yyvsp[0].utree)); ;
break;}
case 347:
-#line 1415 "yaccParser/hsparser.y"
+#line 1409 "yaccParser/hsparser.y"
{ yyval.ulist = lsing(ldub(yyvsp[-2].utree,yyvsp[0].utree)); ;
break;}
case 348:
-#line 1416 "yaccParser/hsparser.y"
+#line 1410 "yaccParser/hsparser.y"
{ yyval.ulist = mklcons(ldub(yyvsp[-3].utree,yyvsp[-1].utree),yyvsp[0].ulist); ;
break;}
case 349:
-#line 1420 "yaccParser/hsparser.y"
+#line 1414 "yaccParser/hsparser.y"
{ yyval.ubinding = yyvsp[-1].ubinding; ;
break;}
case 350:
-#line 1421 "yaccParser/hsparser.y"
+#line 1415 "yaccParser/hsparser.y"
{ yyval.ubinding = yyvsp[-1].ubinding; ;
break;}
case 351:
-#line 1422 "yaccParser/hsparser.y"
+#line 1416 "yaccParser/hsparser.y"
{ yyval.ubinding = mknullbind(); ;
break;}
case 352:
-#line 1425 "yaccParser/hsparser.y"
+#line 1419 "yaccParser/hsparser.y"
{ yyval.utree = yyvsp[0].utree; ;
break;}
case 353:
-#line 1429 "yaccParser/hsparser.y"
+#line 1423 "yaccParser/hsparser.y"
{ yyval.ulist = mklcons(yyvsp[-1].utree,yyvsp[0].ulist); ;
break;}
case 354:
-#line 1430 "yaccParser/hsparser.y"
+#line 1424 "yaccParser/hsparser.y"
{ yyval.ulist = lsing(yyvsp[0].utree); ;
break;}
case 355:
-#line 1439 "yaccParser/hsparser.y"
+#line 1434 "yaccParser/hsparser.y"
{ yyval.utree = mkrestr(yyvsp[-4].utree,mkcontext(type2context(yyvsp[-2].uttype),yyvsp[0].uttype)); ;
break;}
case 356:
-#line 1440 "yaccParser/hsparser.y"
+#line 1435 "yaccParser/hsparser.y"
{ yyval.utree = mkrestr(yyvsp[-2].utree,yyvsp[0].uttype); ;
break;}
case 359:
-#line 1452 "yaccParser/hsparser.y"
+#line 1447 "yaccParser/hsparser.y"
{ yyval.utree = mkinfixop(yyvsp[-1].uid,yyvsp[-2].utree,yyvsp[0].utree); precparse(yyval.utree); ;
break;}
case 360:
-#line 1461 "yaccParser/hsparser.y"
+#line 1456 "yaccParser/hsparser.y"
{ yyval.utree = mknegate(yyvsp[0].utree); ;
break;}
case 362:
-#line 1470 "yaccParser/hsparser.y"
+#line 1465 "yaccParser/hsparser.y"
{ /* enteriscope(); /? I don't understand this -- KH */
hsincindent(); /* added by partain; push new context for */
/* FN = NULL; not actually concerned about */
;
break;}
case 363:
-#line 1477 "yaccParser/hsparser.y"
+#line 1472 "yaccParser/hsparser.y"
{ hsendindent(); /* added by partain */
/* exitiscope(); /? Also not understood */
;
break;}
case 364:
-#line 1481 "yaccParser/hsparser.y"
+#line 1476 "yaccParser/hsparser.y"
{
yyval.utree = mklambda(yyvsp[-3].ulist, yyvsp[0].utree, yyvsp[-4].uint);
;
break;}
case 365:
-#line 1486 "yaccParser/hsparser.y"
+#line 1481 "yaccParser/hsparser.y"
{ yyval.utree = mklet(yyvsp[-3].ubinding,yyvsp[0].utree); ;
break;}
case 366:
-#line 1487 "yaccParser/hsparser.y"
+#line 1482 "yaccParser/hsparser.y"
{ yyval.utree = mklet(yyvsp[-3].ubinding,yyvsp[0].utree); ;
break;}
case 367:
-#line 1490 "yaccParser/hsparser.y"
+#line 1485 "yaccParser/hsparser.y"
{ yyval.utree = mkife(yyvsp[-4].utree,yyvsp[-2].utree,yyvsp[0].utree); ;
break;}
case 368:
-#line 1493 "yaccParser/hsparser.y"
+#line 1488 "yaccParser/hsparser.y"
{ yyval.utree = mkcasee(yyvsp[-4].utree,yyvsp[-1].ulist); ;
break;}
case 369:
-#line 1494 "yaccParser/hsparser.y"
+#line 1489 "yaccParser/hsparser.y"
{ yyval.utree = mkcasee(yyvsp[-4].utree,yyvsp[-1].ulist); ;
break;}
case 370:
-#line 1497 "yaccParser/hsparser.y"
+#line 1492 "yaccParser/hsparser.y"
{ yyval.utree = mkccall(yyvsp[-1].uid,installid("n"),yyvsp[0].ulist); ;
break;}
case 371:
-#line 1498 "yaccParser/hsparser.y"
+#line 1493 "yaccParser/hsparser.y"
{ yyval.utree = mkccall(yyvsp[0].uid,installid("n"),Lnil); ;
break;}
case 372:
-#line 1499 "yaccParser/hsparser.y"
+#line 1494 "yaccParser/hsparser.y"
{ yyval.utree = mkccall(yyvsp[-1].uid,installid("p"),yyvsp[0].ulist); ;
break;}
case 373:
-#line 1500 "yaccParser/hsparser.y"
+#line 1495 "yaccParser/hsparser.y"
{ yyval.utree = mkccall(yyvsp[0].uid,installid("p"),Lnil); ;
break;}
case 374:
-#line 1501 "yaccParser/hsparser.y"
+#line 1496 "yaccParser/hsparser.y"
{ yyval.utree = mkccall(yyvsp[-1].ustring,installid("N"),yyvsp[0].ulist); ;
break;}
case 375:
-#line 1502 "yaccParser/hsparser.y"
+#line 1497 "yaccParser/hsparser.y"
{ yyval.utree = mkccall(yyvsp[0].ustring,installid("N"),Lnil); ;
break;}
case 376:
-#line 1503 "yaccParser/hsparser.y"
+#line 1498 "yaccParser/hsparser.y"
{ yyval.utree = mkccall(yyvsp[-1].ustring,installid("P"),yyvsp[0].ulist); ;
break;}
case 377:
-#line 1504 "yaccParser/hsparser.y"
+#line 1499 "yaccParser/hsparser.y"
{ yyval.utree = mkccall(yyvsp[0].ustring,installid("P"),Lnil); ;
break;}
case 378:
-#line 1508 "yaccParser/hsparser.y"
+#line 1503 "yaccParser/hsparser.y"
{ if (ignoreSCC) {
if (warnSCC)
fprintf(stderr,
;
break;}
case 380:
-#line 1523 "yaccParser/hsparser.y"
+#line 1518 "yaccParser/hsparser.y"
{ yyval.utree = mkap(yyvsp[-1].utree,yyvsp[0].utree); ;
break;}
case 382:
-#line 1527 "yaccParser/hsparser.y"
+#line 1522 "yaccParser/hsparser.y"
{ yyval.ulist = lapp(yyvsp[-1].ulist,yyvsp[0].utree); ;
break;}
case 383:
-#line 1528 "yaccParser/hsparser.y"
+#line 1523 "yaccParser/hsparser.y"
{ yyval.ulist = lsing(yyvsp[0].utree); ;
break;}
case 384:
-#line 1538 "yaccParser/hsparser.y"
+#line 1533 "yaccParser/hsparser.y"
{ yyval.utree = mkident(yyvsp[0].uid); ;
break;}
case 385:
-#line 1539 "yaccParser/hsparser.y"
+#line 1534 "yaccParser/hsparser.y"
{ yyval.utree = mkident(yyvsp[0].uid); ;
break;}
case 386:
-#line 1540 "yaccParser/hsparser.y"
+#line 1535 "yaccParser/hsparser.y"
{ yyval.utree = mklit(yyvsp[0].uliteral); ;
break;}
case 387:
-#line 1541 "yaccParser/hsparser.y"
+#line 1536 "yaccParser/hsparser.y"
{ yyval.utree = mkpar(yyvsp[-1].utree); ;
break;}
case 388:
-#line 1542 "yaccParser/hsparser.y"
+#line 1537 "yaccParser/hsparser.y"
{ checkprec(yyvsp[-2].utree,yyvsp[-1].uid,FALSE); yyval.utree = mklsection(yyvsp[-2].utree,yyvsp[-1].uid); ;
break;}
case 389:
-#line 1543 "yaccParser/hsparser.y"
+#line 1538 "yaccParser/hsparser.y"
{ checkprec(yyvsp[-1].utree,yyvsp[-2].uid,TRUE); yyval.utree = mkrsection(yyvsp[-2].uid,yyvsp[-1].utree); ;
break;}
case 391:
-#line 1547 "yaccParser/hsparser.y"
+#line 1542 "yaccParser/hsparser.y"
{ yyval.utree = mkpar(yyvsp[0].utree); ;
break;}
case 392:
-#line 1548 "yaccParser/hsparser.y"
+#line 1543 "yaccParser/hsparser.y"
{ yyval.utree = mkpar(yyvsp[0].utree); ;
break;}
case 393:
-#line 1549 "yaccParser/hsparser.y"
+#line 1544 "yaccParser/hsparser.y"
{ yyval.utree = mkpar(yyvsp[0].utree); ;
break;}
case 394:
-#line 1552 "yaccParser/hsparser.y"
+#line 1547 "yaccParser/hsparser.y"
{ checkinpat(); yyval.utree = mkas(yyvsp[-2].uid,yyvsp[0].utree); ;
break;}
case 395:
-#line 1553 "yaccParser/hsparser.y"
+#line 1548 "yaccParser/hsparser.y"
{ checkinpat(); yyval.utree = mkwildp(); ;
break;}
case 396:
-#line 1554 "yaccParser/hsparser.y"
+#line 1549 "yaccParser/hsparser.y"
{ checkinpat(); yyval.utree = mklazyp(yyvsp[0].utree); ;
break;}
case 398:
-#line 1569 "yaccParser/hsparser.y"
+#line 1564 "yaccParser/hsparser.y"
{
yyval.utree = mkinfixop(yyvsp[-1].uid,yyvsp[-2].utree,yyvsp[0].utree);
;
break;}
case 400:
-#line 1584 "yaccParser/hsparser.y"
+#line 1579 "yaccParser/hsparser.y"
{
yyval.utree = mkinfixop(yyvsp[-1].uid,yyvsp[-2].utree,yyvsp[0].utree);
;
break;}
case 401:
-#line 1603 "yaccParser/hsparser.y"
+#line 1598 "yaccParser/hsparser.y"
{ yyval.utree = mknegate(yyvsp[0].utree); ;
break;}
case 403:
-#line 1608 "yaccParser/hsparser.y"
+#line 1603 "yaccParser/hsparser.y"
{ yyval.utree = mkap(yyvsp[-1].utree,yyvsp[0].utree); ;
break;}
case 405:
-#line 1612 "yaccParser/hsparser.y"
+#line 1607 "yaccParser/hsparser.y"
{ yyval.utree = mknegate(yyvsp[0].utree); ;
break;}
case 407:
-#line 1617 "yaccParser/hsparser.y"
+#line 1612 "yaccParser/hsparser.y"
{ yyval.utree = mkap(yyvsp[-1].utree,yyvsp[0].utree); ;
break;}
case 409:
-#line 1621 "yaccParser/hsparser.y"
+#line 1616 "yaccParser/hsparser.y"
{ yyval.utree = mkident(yyvsp[0].uid); ;
break;}
case 410:
-#line 1622 "yaccParser/hsparser.y"
+#line 1617 "yaccParser/hsparser.y"
{ yyval.utree = mkident(yyvsp[0].uid); ;
break;}
case 411:
-#line 1623 "yaccParser/hsparser.y"
+#line 1618 "yaccParser/hsparser.y"
{ yyval.utree = mkas(yyvsp[-2].uid,yyvsp[0].utree); ;
break;}
case 412:
-#line 1624 "yaccParser/hsparser.y"
+#line 1619 "yaccParser/hsparser.y"
{ yyval.utree = mklit(yyvsp[0].uliteral); ;
break;}
case 413:
-#line 1625 "yaccParser/hsparser.y"
+#line 1620 "yaccParser/hsparser.y"
{ yyval.utree = mkwildp(); ;
break;}
case 414:
-#line 1626 "yaccParser/hsparser.y"
+#line 1621 "yaccParser/hsparser.y"
{ yyval.utree = mktuple(Lnil); ;
break;}
case 415:
-#line 1627 "yaccParser/hsparser.y"
+#line 1622 "yaccParser/hsparser.y"
{ yyval.utree = mkplusp(mkident(yyvsp[-3].uid),mkinteger(yyvsp[-1].ustring)); ;
break;}
case 416:
-#line 1631 "yaccParser/hsparser.y"
+#line 1626 "yaccParser/hsparser.y"
{ yyval.utree = mkpar(yyvsp[-1].utree); ;
break;}
case 417:
-#line 1632 "yaccParser/hsparser.y"
+#line 1627 "yaccParser/hsparser.y"
{ yyval.utree = mktuple(mklcons(yyvsp[-3].utree,yyvsp[-1].ulist)); ;
break;}
case 418:
-#line 1633 "yaccParser/hsparser.y"
+#line 1628 "yaccParser/hsparser.y"
{ yyval.utree = mkllist(yyvsp[-1].ulist); ;
break;}
case 419:
-#line 1634 "yaccParser/hsparser.y"
+#line 1629 "yaccParser/hsparser.y"
{ yyval.utree = mkllist(Lnil); ;
break;}
case 420:
-#line 1635 "yaccParser/hsparser.y"
+#line 1630 "yaccParser/hsparser.y"
{ yyval.utree = mklazyp(yyvsp[0].utree); ;
break;}
case 421:
-#line 1638 "yaccParser/hsparser.y"
+#line 1633 "yaccParser/hsparser.y"
{ yyval.utree = mkident(yyvsp[0].uid); ;
break;}
case 422:
-#line 1639 "yaccParser/hsparser.y"
+#line 1634 "yaccParser/hsparser.y"
{ yyval.utree = mkident(yyvsp[0].uid); ;
break;}
case 423:
-#line 1640 "yaccParser/hsparser.y"
+#line 1635 "yaccParser/hsparser.y"
{ yyval.utree = mkas(yyvsp[-2].uid,yyvsp[0].utree); ;
break;}
case 424:
-#line 1641 "yaccParser/hsparser.y"
+#line 1636 "yaccParser/hsparser.y"
{ yyval.utree = mklit(yyvsp[0].uliteral); setstartlineno(); ;
break;}
case 425:
-#line 1642 "yaccParser/hsparser.y"
+#line 1637 "yaccParser/hsparser.y"
{ yyval.utree = mkwildp(); setstartlineno(); ;
break;}
case 426:
-#line 1643 "yaccParser/hsparser.y"
+#line 1638 "yaccParser/hsparser.y"
{ yyval.utree = mktuple(Lnil); ;
break;}
case 427:
-#line 1644 "yaccParser/hsparser.y"
+#line 1639 "yaccParser/hsparser.y"
{ yyval.utree = mkplusp(mkident(yyvsp[-3].uid),mkinteger(yyvsp[-1].ustring)); ;
break;}
case 428:
-#line 1648 "yaccParser/hsparser.y"
+#line 1643 "yaccParser/hsparser.y"
{ yyval.utree = mkpar(yyvsp[-1].utree); ;
break;}
case 429:
-#line 1649 "yaccParser/hsparser.y"
+#line 1644 "yaccParser/hsparser.y"
{ yyval.utree = mktuple(mklcons(yyvsp[-3].utree,yyvsp[-1].ulist)); ;
break;}
case 430:
-#line 1650 "yaccParser/hsparser.y"
+#line 1645 "yaccParser/hsparser.y"
{ yyval.utree = mkllist(yyvsp[-1].ulist); ;
break;}
case 431:
-#line 1651 "yaccParser/hsparser.y"
+#line 1646 "yaccParser/hsparser.y"
{ yyval.utree = mkllist(Lnil); ;
break;}
case 432:
-#line 1652 "yaccParser/hsparser.y"
+#line 1647 "yaccParser/hsparser.y"
{ yyval.utree = mklazyp(yyvsp[0].utree); ;
break;}
case 433:
-#line 1657 "yaccParser/hsparser.y"
+#line 1652 "yaccParser/hsparser.y"
{ if (ttree(yyvsp[-1].utree) == tuple)
yyval.utree = mktuple(mklcons(yyvsp[-3].utree, gtuplelist((struct Stuple *) yyvsp[-1].utree)));
else
;
break;}
case 434:
-#line 1663 "yaccParser/hsparser.y"
+#line 1658 "yaccParser/hsparser.y"
{ yyval.utree = mktuple(Lnil); ;
break;}
case 435:
-#line 1671 "yaccParser/hsparser.y"
+#line 1666 "yaccParser/hsparser.y"
{ yyval.utree = mkpar(yyvsp[0].utree); ;
break;}
case 436:
-#line 1673 "yaccParser/hsparser.y"
+#line 1668 "yaccParser/hsparser.y"
{ if (ttree(yyvsp[0].utree) == tuple)
yyval.utree = mktuple(mklcons(yyvsp[-2].utree, gtuplelist((struct Stuple *) yyvsp[0].utree)));
else
;
break;}
case 437:
-#line 1682 "yaccParser/hsparser.y"
+#line 1677 "yaccParser/hsparser.y"
{ yyval.utree = mkllist(Lnil); ;
break;}
case 438:
-#line 1683 "yaccParser/hsparser.y"
+#line 1678 "yaccParser/hsparser.y"
{ yyval.utree = mkllist(yyvsp[-1].ulist); ;
break;}
case 439:
-#line 1687 "yaccParser/hsparser.y"
+#line 1682 "yaccParser/hsparser.y"
{ yyval.ulist = lsing(yyvsp[0].utree); ;
break;}
case 440:
-#line 1688 "yaccParser/hsparser.y"
+#line 1683 "yaccParser/hsparser.y"
{ yyval.ulist = mklcons(yyvsp[-2].utree, yyvsp[0].ulist); ;
break;}
case 441:
-#line 1703 "yaccParser/hsparser.y"
+#line 1698 "yaccParser/hsparser.y"
{yyval.utree = mkeenum(yyvsp[-5].utree,lsing(yyvsp[-3].utree),yyvsp[-1].ulist);;
break;}
case 442:
-#line 1704 "yaccParser/hsparser.y"
+#line 1699 "yaccParser/hsparser.y"
{ yyval.utree = mkeenum(yyvsp[-3].utree,Lnil,yyvsp[-1].ulist); ;
break;}
case 443:
-#line 1707 "yaccParser/hsparser.y"
+#line 1702 "yaccParser/hsparser.y"
{ yyval.utree = mkcomprh(yyvsp[-3].utree,yyvsp[-1].ulist); ;
break;}
case 444:
-#line 1710 "yaccParser/hsparser.y"
+#line 1705 "yaccParser/hsparser.y"
{ yyval.ulist = lsing(yyvsp[0].utree); ;
break;}
case 445:
-#line 1711 "yaccParser/hsparser.y"
+#line 1706 "yaccParser/hsparser.y"
{ yyval.ulist = lapp(yyvsp[-2].ulist,yyvsp[0].utree); ;
break;}
case 446:
-#line 1714 "yaccParser/hsparser.y"
+#line 1709 "yaccParser/hsparser.y"
{ inpat = TRUE; ;
break;}
case 447:
-#line 1714 "yaccParser/hsparser.y"
+#line 1709 "yaccParser/hsparser.y"
{ inpat = FALSE; ;
break;}
case 448:
-#line 1715 "yaccParser/hsparser.y"
+#line 1710 "yaccParser/hsparser.y"
{ if (yyvsp[0].utree == NULL) {
patternOrExpr(/*wanted:*/ LEGIT_EXPR,yyvsp[-2].utree);
yyval.utree = mkguard(yyvsp[-2].utree);
;
break;}
case 449:
-#line 1735 "yaccParser/hsparser.y"
+#line 1730 "yaccParser/hsparser.y"
{ yyval.utree = yyvsp[0].utree; ;
break;}
case 450:
-#line 1736 "yaccParser/hsparser.y"
+#line 1731 "yaccParser/hsparser.y"
{ yyval.utree = NULL; ;
break;}
case 451:
-#line 1739 "yaccParser/hsparser.y"
+#line 1734 "yaccParser/hsparser.y"
{ yyval.ulist = yyvsp[0].ulist; ;
break;}
case 452:
-#line 1740 "yaccParser/hsparser.y"
+#line 1735 "yaccParser/hsparser.y"
{ yyval.ulist = lconc(yyvsp[-2].ulist,yyvsp[0].ulist); ;
break;}
case 453:
-#line 1744 "yaccParser/hsparser.y"
+#line 1739 "yaccParser/hsparser.y"
{ PREVPATT = yyvsp[0].utree; ;
break;}
case 454:
-#line 1746 "yaccParser/hsparser.y"
+#line 1741 "yaccParser/hsparser.y"
{ yyval.ulist = yyvsp[0].ulist;
PREVPATT = NULL;
;
break;}
case 455:
-#line 1749 "yaccParser/hsparser.y"
+#line 1744 "yaccParser/hsparser.y"
{ yyval.ulist = Lnil; ;
break;}
case 456:
-#line 1752 "yaccParser/hsparser.y"
+#line 1747 "yaccParser/hsparser.y"
{ yyval.ulist = lsing(createpat(yyvsp[-1].ulist, yyvsp[0].ubinding)); ;
break;}
case 457:
-#line 1753 "yaccParser/hsparser.y"
+#line 1748 "yaccParser/hsparser.y"
{ yyval.ulist = lsing(createpat(lsing(mktruecase(yyvsp[-1].utree)), yyvsp[0].ubinding)); ;
break;}
case 458:
-#line 1756 "yaccParser/hsparser.y"
+#line 1751 "yaccParser/hsparser.y"
{ yyval.ulist = mklcons(ldub(yyvsp[-3].utree,yyvsp[-1].utree),yyvsp[0].ulist); ;
break;}
case 459:
-#line 1757 "yaccParser/hsparser.y"
+#line 1752 "yaccParser/hsparser.y"
{ yyval.ulist = lsing(ldub(yyvsp[-2].utree,yyvsp[0].utree)); ;
break;}
case 460:
-#line 1760 "yaccParser/hsparser.y"
+#line 1755 "yaccParser/hsparser.y"
{ yyval.ulist = Lnil; ;
break;}
case 461:
-#line 1761 "yaccParser/hsparser.y"
+#line 1756 "yaccParser/hsparser.y"
{ yyval.ulist = lsing(yyvsp[0].utree); ;
break;}
case 462:
-#line 1764 "yaccParser/hsparser.y"
+#line 1759 "yaccParser/hsparser.y"
{ yyval.ulist = mklcons(yyvsp[-2].utree, yyvsp[0].ulist); ;
break;}
case 463:
-#line 1765 "yaccParser/hsparser.y"
+#line 1760 "yaccParser/hsparser.y"
{ yyval.ulist = lsing(yyvsp[0].utree); ;
break;}
case 465:
-#line 1770 "yaccParser/hsparser.y"
+#line 1765 "yaccParser/hsparser.y"
{ yyval.utree = mkinfixop(yyvsp[-1].uid,yyvsp[-2].utree,yyvsp[0].utree); precparse(yyval.utree); ;
break;}
case 468:
-#line 1775 "yaccParser/hsparser.y"
+#line 1770 "yaccParser/hsparser.y"
{ yyval.utree = mklit(mkinteger(ineg(yyvsp[0].ustring))); ;
break;}
case 469:
-#line 1776 "yaccParser/hsparser.y"
+#line 1771 "yaccParser/hsparser.y"
{ yyval.utree = mklit(mkfloatr(ineg(yyvsp[0].ustring))); ;
break;}
case 470:
-#line 1779 "yaccParser/hsparser.y"
+#line 1774 "yaccParser/hsparser.y"
{ yyval.utree = mkident(yyvsp[0].uid); ;
break;}
case 471:
-#line 1780 "yaccParser/hsparser.y"
+#line 1775 "yaccParser/hsparser.y"
{ yyval.utree = mkap(yyvsp[-1].utree,yyvsp[0].utree); ;
break;}
case 472:
-#line 1783 "yaccParser/hsparser.y"
+#line 1778 "yaccParser/hsparser.y"
{ yyval.utree = mkident(yyvsp[0].uid); ;
break;}
case 474:
-#line 1787 "yaccParser/hsparser.y"
+#line 1782 "yaccParser/hsparser.y"
{ yyval.utree = mkident(yyvsp[0].uid); ;
break;}
case 475:
-#line 1788 "yaccParser/hsparser.y"
+#line 1783 "yaccParser/hsparser.y"
{ yyval.utree = mkas(yyvsp[-2].uid,yyvsp[0].utree); ;
break;}
case 476:
-#line 1789 "yaccParser/hsparser.y"
+#line 1784 "yaccParser/hsparser.y"
{ yyval.utree = mklit(yyvsp[0].uliteral); ;
break;}
case 477:
-#line 1790 "yaccParser/hsparser.y"
+#line 1785 "yaccParser/hsparser.y"
{ yyval.utree = mkwildp(); ;
break;}
case 478:
-#line 1791 "yaccParser/hsparser.y"
+#line 1786 "yaccParser/hsparser.y"
{ yyval.utree = mktuple(Lnil); ;
break;}
case 479:
-#line 1792 "yaccParser/hsparser.y"
+#line 1787 "yaccParser/hsparser.y"
{ yyval.utree = mkplusp(mkident(yyvsp[-3].uid),mkinteger(yyvsp[-1].ustring)); ;
break;}
case 480:
-#line 1796 "yaccParser/hsparser.y"
+#line 1791 "yaccParser/hsparser.y"
{ yyval.utree = mkpar(yyvsp[-1].utree); ;
break;}
case 481:
-#line 1797 "yaccParser/hsparser.y"
+#line 1792 "yaccParser/hsparser.y"
{ yyval.utree = mktuple(mklcons(yyvsp[-3].utree,yyvsp[-1].ulist)); ;
break;}
case 482:
-#line 1798 "yaccParser/hsparser.y"
+#line 1793 "yaccParser/hsparser.y"
{ yyval.utree = mkllist(yyvsp[-1].ulist); ;
break;}
case 483:
-#line 1799 "yaccParser/hsparser.y"
+#line 1794 "yaccParser/hsparser.y"
{ yyval.utree = mkllist(Lnil); ;
break;}
case 484:
-#line 1800 "yaccParser/hsparser.y"
+#line 1795 "yaccParser/hsparser.y"
{ yyval.utree = mklazyp(yyvsp[0].utree); ;
break;}
case 485:
-#line 1804 "yaccParser/hsparser.y"
+#line 1799 "yaccParser/hsparser.y"
{ yyval.uliteral = mkinteger(yyvsp[0].ustring); ;
break;}
case 486:
-#line 1805 "yaccParser/hsparser.y"
+#line 1800 "yaccParser/hsparser.y"
{ yyval.uliteral = mkfloatr(yyvsp[0].ustring); ;
break;}
case 487:
-#line 1806 "yaccParser/hsparser.y"
+#line 1801 "yaccParser/hsparser.y"
{ yyval.uliteral = mkcharr(yyvsp[0].uhstring); ;
break;}
case 488:
-#line 1807 "yaccParser/hsparser.y"
+#line 1802 "yaccParser/hsparser.y"
{ yyval.uliteral = mkstring(yyvsp[0].uhstring); ;
break;}
case 489:
-#line 1808 "yaccParser/hsparser.y"
+#line 1803 "yaccParser/hsparser.y"
{ yyval.uliteral = mkcharprim(yyvsp[0].uhstring); ;
break;}
case 490:
-#line 1809 "yaccParser/hsparser.y"
+#line 1804 "yaccParser/hsparser.y"
{ yyval.uliteral = mkstringprim(yyvsp[0].uhstring); ;
break;}
case 491:
-#line 1810 "yaccParser/hsparser.y"
+#line 1805 "yaccParser/hsparser.y"
{ yyval.uliteral = mkintprim(yyvsp[0].ustring); ;
break;}
case 492:
-#line 1811 "yaccParser/hsparser.y"
+#line 1806 "yaccParser/hsparser.y"
{ yyval.uliteral = mkfloatprim(yyvsp[0].ustring); ;
break;}
case 493:
-#line 1812 "yaccParser/hsparser.y"
+#line 1807 "yaccParser/hsparser.y"
{ yyval.uliteral = mkdoubleprim(yyvsp[0].ustring); ;
break;}
case 494:
-#line 1813 "yaccParser/hsparser.y"
+#line 1808 "yaccParser/hsparser.y"
{ yyval.uliteral = mkclitlit(yyvsp[0].ustring, ""); ;
break;}
case 495:
-#line 1814 "yaccParser/hsparser.y"
+#line 1809 "yaccParser/hsparser.y"
{ yyval.uliteral = mkclitlit(yyvsp[-2].ustring, yyvsp[0].uid); ;
break;}
case 496:
-#line 1815 "yaccParser/hsparser.y"
+#line 1810 "yaccParser/hsparser.y"
{ yyval.uliteral = mknorepi(yyvsp[0].ustring); ;
break;}
case 497:
-#line 1816 "yaccParser/hsparser.y"
+#line 1811 "yaccParser/hsparser.y"
{ yyval.uliteral = mknorepr(yyvsp[-1].ustring, yyvsp[0].ustring); ;
break;}
case 498:
-#line 1817 "yaccParser/hsparser.y"
+#line 1812 "yaccParser/hsparser.y"
{ yyval.uliteral = mknoreps(yyvsp[0].uhstring); ;
break;}
case 499:
-#line 1823 "yaccParser/hsparser.y"
+#line 1818 "yaccParser/hsparser.y"
{ setstartlineno(); ;
break;}
case 500:
-#line 1826 "yaccParser/hsparser.y"
+#line 1821 "yaccParser/hsparser.y"
{ setstartlineno();
if(etags)
#if 1/*etags*/
;
break;}
case 501:
-#line 1836 "yaccParser/hsparser.y"
+#line 1831 "yaccParser/hsparser.y"
{ setstartlineno();
if(etags)
#if 1/*etags*/
;
break;}
case 502:
-#line 1846 "yaccParser/hsparser.y"
+#line 1841 "yaccParser/hsparser.y"
{ setstartlineno();
#if 1/*etags*/
/* OUT: if(etags)
;
break;}
case 503:
-#line 1857 "yaccParser/hsparser.y"
+#line 1852 "yaccParser/hsparser.y"
{ setstartlineno(); ;
break;}
case 504:
-#line 1860 "yaccParser/hsparser.y"
+#line 1855 "yaccParser/hsparser.y"
{ setstartlineno();
if(etags)
#if 1/*etags*/
;
break;}
case 505:
-#line 1870 "yaccParser/hsparser.y"
+#line 1865 "yaccParser/hsparser.y"
{ setstartlineno(); ;
break;}
case 506:
-#line 1873 "yaccParser/hsparser.y"
+#line 1868 "yaccParser/hsparser.y"
{ setstartlineno();
if(etags)
#if 1/*etags*/
;
break;}
case 507:
-#line 1883 "yaccParser/hsparser.y"
+#line 1878 "yaccParser/hsparser.y"
{ setstartlineno(); ;
break;}
case 508:
-#line 1886 "yaccParser/hsparser.y"
+#line 1881 "yaccParser/hsparser.y"
{ setstartlineno(); ;
break;}
case 509:
-#line 1889 "yaccParser/hsparser.y"
+#line 1884 "yaccParser/hsparser.y"
{ setstartlineno(); ;
break;}
case 515:
-#line 1904 "yaccParser/hsparser.y"
+#line 1899 "yaccParser/hsparser.y"
{ yyval.uid = yyvsp[-1].uid; ;
break;}
case 518:
-#line 1910 "yaccParser/hsparser.y"
+#line 1905 "yaccParser/hsparser.y"
{ yyval.uid = yyvsp[-1].uid; ;
break;}
case 520:
-#line 1914 "yaccParser/hsparser.y"
+#line 1909 "yaccParser/hsparser.y"
{ yyval.uid = yyvsp[-1].uid; ;
break;}
case 524:
-#line 1922 "yaccParser/hsparser.y"
+#line 1917 "yaccParser/hsparser.y"
{ yyval.uid = install_literal("-"); ;
break;}
case 525:
-#line 1925 "yaccParser/hsparser.y"
+#line 1920 "yaccParser/hsparser.y"
{ yyval.uid = install_literal("+"); ;
break;}
case 527:
-#line 1929 "yaccParser/hsparser.y"
+#line 1924 "yaccParser/hsparser.y"
{ yyval.uid = yyvsp[-1].uid; ;
break;}
case 528:
-#line 1932 "yaccParser/hsparser.y"
+#line 1927 "yaccParser/hsparser.y"
{ setstartlineno(); yyval.uid = yyvsp[0].uid; ;
break;}
case 529:
-#line 1933 "yaccParser/hsparser.y"
+#line 1928 "yaccParser/hsparser.y"
{ yyval.uid = yyvsp[-1].uid; ;
break;}
case 531:
-#line 1938 "yaccParser/hsparser.y"
+#line 1933 "yaccParser/hsparser.y"
{ yyval.uid = yyvsp[-1].uid; ;
break;}
case 532:
-#line 1941 "yaccParser/hsparser.y"
+#line 1936 "yaccParser/hsparser.y"
{ setstartlineno(); yyval.uid = yyvsp[0].uid; ;
break;}
case 533:
-#line 1942 "yaccParser/hsparser.y"
+#line 1937 "yaccParser/hsparser.y"
{ yyval.uid = yyvsp[-1].uid; ;
break;}
case 536:
-#line 1950 "yaccParser/hsparser.y"
-{ yyval.ulist = mklcons(yyvsp[-2].uttype,lsing(yyvsp[0].uttype)); ;
+#line 1944 "yaccParser/hsparser.y"
+{ yyval.ulist = lsing(yyvsp[0].uttype); ;
break;}
case 537:
-#line 1951 "yaccParser/hsparser.y"
-{ yyval.ulist = mklcons(yyvsp[-2].uttype,yyvsp[0].ulist); ;
+#line 1945 "yaccParser/hsparser.y"
+{ yyval.ulist = lapp(yyvsp[-2].ulist,yyvsp[0].uttype); ;
break;}
case 538:
-#line 1955 "yaccParser/hsparser.y"
+#line 1948 "yaccParser/hsparser.y"
{ yyval.ulist = lsing(yyvsp[0].uttype); ;
break;}
case 539:
-#line 1956 "yaccParser/hsparser.y"
+#line 1949 "yaccParser/hsparser.y"
{ yyval.ulist = lapp(yyvsp[-1].ulist, yyvsp[0].uttype); ;
break;}
case 540:
-#line 1959 "yaccParser/hsparser.y"
+#line 1952 "yaccParser/hsparser.y"
{ yyval.uttype = mknamedtvar(yyvsp[0].uid); ;
break;}
case 544:
-#line 1975 "yaccParser/hsparser.y"
+#line 1968 "yaccParser/hsparser.y"
{ hsincindent(); ;
break;}
case 545:
-#line 1977 "yaccParser/hsparser.y"
+#line 1970 "yaccParser/hsparser.y"
{ hssetindent(); ;
break;}
case 546:
-#line 1980 "yaccParser/hsparser.y"
+#line 1973 "yaccParser/hsparser.y"
{ hsindentoff(); ;
break;}
case 547:
-#line 1985 "yaccParser/hsparser.y"
+#line 1978 "yaccParser/hsparser.y"
{
FN = NULL; SAMEFN = 0; PREVPATT = NULL;
hsendindent();
;
break;}
case 548:
-#line 1991 "yaccParser/hsparser.y"
+#line 1984 "yaccParser/hsparser.y"
{ expect_ccurly = 1; ;
break;}
case 549:
-#line 1991 "yaccParser/hsparser.y"
+#line 1984 "yaccParser/hsparser.y"
{ expect_ccurly = 0; ;
break;}
case 550:
-#line 1996 "yaccParser/hsparser.y"
+#line 1989 "yaccParser/hsparser.y"
{
FN = NULL; SAMEFN = 0; PREVPATT = NULL;
hsendindent();
;
break;}
case 551:
-#line 2001 "yaccParser/hsparser.y"
+#line 1994 "yaccParser/hsparser.y"
{
yyerrok;
FN = NULL; SAMEFN = 0; PREVPATT = NULL;
yystate = yyn;
goto yynewstate;
}
-#line 2008 "yaccParser/hsparser.y"
+#line 2001 "yaccParser/hsparser.y"
/**********************************************************************
extern BOOLEAN haskell1_3Flag; /* True if we are attempting (proto)Haskell 1.3 */
extern int thisIfacePragmaVersion;
-
%}
%union {
%type <ulist> alt alts altrest quals vars varsrest cons
tyvars constrs dtypes types atypes
types_and_maybe_ids
- list_exps pats context context_list atype_list
+ list_exps pats context context_list tyvar_list
maybeexports export_list
impspec maybeimpspec import_list
impdecls maybeimpdecls impdecl
idata_pragma_specs idata_pragma_specslist
gen_pragma_list type_pragma_pairs
type_pragma_pairs_maybe name_pragma_pairs
- maybe_name_pragma_pairs type_instpragma_pairs
type_maybes
- restof_iinst_spec
howto_inline_maybe
core_binders core_tyvars core_tv_templates
core_types core_type_list
impdecl_rest
type_and_maybe_id
-%type <uttype> simple simple_long type atype btype ttype ntatype inst class
- tyvar core_type type_maybe core_type_maybe
+%type <uttype> simple type atype btype ttype ntatype
+ class restrict_inst general_inst tyvar type_maybe
+ core_type core_type_maybe
%type <uatype> constr
update_pragma strictness_pragma worker_info
deforest_pragma
unfolding_pragma unfolding_guidance type_pragma_pair
- type_instpragma_pair name_pragma_pair
+ name_pragma_pair
%type <ucoresyn> core_expr core_case_alts core_id core_binder core_atom
core_alg_alt core_prim_alt core_default corec_bind
| GHC_PRAGMA modname_pragma gen_pragma name_pragma_pairs END_PRAGMA
{ $$ = mkiinst_const_pragma($2, $3, $4); }
- | GHC_PRAGMA modname_pragma gen_pragma restof_iinst_spec END_PRAGMA
- { $$ = mkiinst_spec_pragma($2, $3, $4); }
-
| /* empty */
{ $$ = mkno_pragma(); }
;
{ $$ = install_literal(""); }
;
-restof_iinst_spec: SPECIALISE_PRAGMA type_instpragma_pairs { $$ = $2; }
- ;
-
ival_pragma:
GHC_PRAGMA gen_pragma END_PRAGMA
{ $$ = $2; }
{ $$ = mkitype_pragma_pr($2, $4, $5); }
;
-type_instpragma_pairs:
- type_instpragma_pair { $$ = lsing($1); }
- | type_instpragma_pairs COMMA type_instpragma_pair { $$ = lapp($1,$3); }
- ;
-
-type_instpragma_pair:
- OBRACK type_maybes CBRACK INTEGER worker_info maybe_name_pragma_pairs
- { $$ = mkiinst_pragma_3s($2, $4, $5, $6); }
- ;
-
type_maybes:
type_maybe { $$ = lsing($1); }
| type_maybes COMMA type_maybe { $$ = lapp($1, $3); }
| type { $$ = mkty_maybe_just($1); }
;
-maybe_name_pragma_pairs:
- /* empty */ { $$ = Lnil; }
- | name_pragma_pairs { $$ = $1; }
- ;
-
name_pragma_pairs:
name_pragma_pair { $$ = lsing($1); }
| name_pragma_pairs COMMA name_pragma_pair { $$ = lapp($1, $3); }
;
name_pragma_pair:
- var EQUAL gen_pragma
+ /* if the gen_pragma concludes with a *comma*- */
+ /* separated SPECs list, we get a parse error; */
+ /* we have to bracket the gen_pragma */
+
+ var EQUAL OCURLY gen_pragma CCURLY
+ { $$ = mkiname_pragma_pr($1, $4); }
+
+ /* we keep the old form for backwards compatability */
+ /* ToDo: rm */
+
+ | var EQUAL gen_pragma
{ $$ = mkiname_pragma_pr($1, $3); }
+
+ /* need bracketed form when we have spec pragmas to avoid list confusion */
;
/* -- end of interface pragma stuff ------------------------------- */
| WHERE vocurly decls vccurly { checkorder($3); $$ =$3; }
;
-instd : instkey context DARROW tycls inst rinst { $$ = mkibind($2,$4,$5,$6,startlineno,mkno_pragma()); }
- | instkey tycls inst rinst { $$ = mkibind(Lnil,$2,$3,$4,startlineno,mkno_pragma()); }
+instd : instkey context DARROW tycls restrict_inst rinst { $$ = mkibind($2,$4,$5,$6,startlineno,mkno_pragma()); }
+ | instkey tycls general_inst rinst { $$ = mkibind(Lnil,$2,$3,$4,startlineno,mkno_pragma()); }
;
rinst : /* empty */ { $$ = mknullbind(); }
| WHERE vocurly instdefs vccurly { $$ = $3; }
;
-inst : tycon { $$ = mktname($1,Lnil); }
- | OPAREN simple_long CPAREN { $$ = $2; }
- /* partain?: "simple" requires k >= 0, not k > 0 (hence "simple_long" hack) */
- | OPAREN atype_list CPAREN { $$ = mkttuple($2); }
+restrict_inst : tycon { $$ = mktname($1,Lnil); }
+ | OPAREN tycon tyvars CPAREN { $$ = mktname($2,$3); }
+ | OPAREN tyvar COMMA tyvar_list CPAREN { $$ = mkttuple(mklcons($2,$4)); }
| OPAREN CPAREN { $$ = mkttuple(Lnil); }
- | OBRACK atype CBRACK { $$ = mktllist($2); }
- | OPAREN atype RARROW atype CPAREN { $$ = mktfun($2,$4); }
+ | OBRACK tyvar CBRACK { $$ = mktllist($2); }
+ | OPAREN tyvar RARROW tyvar CPAREN { $$ = mktfun($2,$4); }
+ ;
+
+general_inst : tycon { $$ = mktname($1,Lnil); }
+ | OPAREN tycon atypes CPAREN { $$ = mktname($2,$3); }
+ | OPAREN type COMMA types CPAREN { $$ = mkttuple(mklcons($2,$4)); }
+ | OPAREN CPAREN { $$ = mkttuple(Lnil); }
+ | OBRACK type CBRACK { $$ = mktllist($2); }
+ | OPAREN btype RARROW type CPAREN { $$ = mktfun($2,$4); }
;
defaultd: defaultkey dtypes { $$ = mkdbind($2,startlineno); }
PREVPATT = NULL; FN = NULL; SAMEFN = 0;
}
- | SPECIALISE_UPRAGMA INSTANCE CONID inst END_UPRAGMA
+ | SPECIALISE_UPRAGMA INSTANCE CONID general_inst END_UPRAGMA
{
$$ = mkispec_uprag($3, $4, startlineno);
PREVPATT = NULL; FN = NULL; SAMEFN = 0;
{ $$ = mkcbind(Lnil,$2,$4,startlineno,$3); }
;
-iinstd : instkey context DARROW tycls inst iinst_pragma
+iinstd : instkey context DARROW tycls general_inst iinst_pragma
{ $$ = mkibind($2,$4,$5,mknullbind(),startlineno,$6); }
- | instkey tycls inst iinst_pragma
+ | instkey tycls general_inst iinst_pragma
{ $$ = mkibind(Lnil,$2,$3,mknullbind(),startlineno,$4); }
;
| tycon tyvars { $$ = mktname($1,$2); }
;
-
-simple_long : tycon atypes { $$ = mktname($1,$2); }
- ; /* partain: see comment in "inst" */
- /* partain: "atypes" should be "tyvars" if you want to
- avoid "extended instances" by syntactic means. */
-
-
constrs : constr { $$ = lsing($1); }
| constrs VBAR constr { $$ = lapp($1,$3); }
;
/* instdef: same as valdef, except certain user-pragmas may appear */
instdef :
- INLINE_UPRAGMA vark howto_inline_maybe END_UPRAGMA
+ SPECIALISE_UPRAGMA vark DCOLON types_and_maybe_ids END_UPRAGMA
+ {
+ $$ = mkvspec_uprag($2, $4, startlineno);
+ PREVPATT = NULL; FN = NULL; SAMEFN = 0;
+ }
+
+ | INLINE_UPRAGMA vark howto_inline_maybe END_UPRAGMA
{
$$ = mkinline_uprag($2, $3, startlineno);
PREVPATT = NULL; FN = NULL; SAMEFN = 0;
vars : vark COMMA varsrest { $$ = mklcons($1,$3); }
| vark { $$ = lsing($1); }
- /* right recursion ? WDP */
;
varsrest: var { $$ = lsing($1); }
lampats : apat lampats { $$ = mklcons($1,$2); }
| apat { $$ = lsing($1); }
- ; /* right recursion? (WDP) */
+ /* right recursion? (WDP) */
+ ;
/*
| CONID
;
-/* partain: "atype_list" must be at least 2 elements long (defn of "inst") */
-atype_list: atype COMMA atype { $$ = mklcons($1,lsing($3)); }
- | atype COMMA atype_list { $$ = mklcons($1,$3); }
- /* right recursion? WDP */
+tyvar_list: tyvar { $$ = lsing($1); }
+ | tyvar_list COMMA tyvar { $$ = lapp($1,$3); }
;
-tyvars : tyvar { $$ = lsing($1); }
- | tyvars tyvar { $$ = lapp($1, $2); }
+tyvars : tyvar { $$ = lsing($1); }
+ | tyvars tyvar { $$ = lapp($1, $2); }
;
-tyvar : VARID { $$ = mknamedtvar($1); }
+tyvar : VARID { $$ = mknamedtvar($1); }
;
tycls : tycon
ppragma(gprag_dfun_const(p));
plist(ppragma, gprag_constms(p));
break;
- case iinst_spec_pragma: PUTTAGSTR("PiS");
- pid(gprag_imod_spec(p));
- ppragma(gprag_dfun_spec(p));
- plist(ppragma, gprag_inst_specs(p));
- break;
case igen_pragma: PUTTAGSTR("Pg");
ppragma(gprag_arity(p));
pid(gprag_type_pr2(p));
ppragma(gprag_type_pr3(p));
break;
- case iinst_pragma_3s: PUTTAGSTR("P3");
- plist(pttype, gprag_inst_pt1(p));
- pid(gprag_inst_pt2(p));
- ppragma(gprag_inst_pt3(p));
- plist(ppragma,gprag_inst_pt4(p));
- break;
case idata_pragma_4s: PUTTAGSTR("P4");
plist(pttype, gprag_data_spec(p));
#include "constants.h"
#include "utils.h"
-#ifndef DPH
-#define PARSER_VERSION "0.26"
-#else
-#define PARSER_VERSION "0.26 -- for Data Parallel Haskell"
-#endif
+#define PARSER_VERSION "0.27"
tree root; /* The root of the built syntax tree. */
list Lnil;
version 0.
*/
int minAcceptablePragmaVersion = 5; /* 0.26 or greater ONLY */
-int maxAcceptablePragmaVersion = 5; /* 0.26+ */
+int maxAcceptablePragmaVersion = 6; /* 0.28+ */
int thisIfacePragmaVersion = 0;
static char *input_file_dir; /* The directory where the input file is. */
$_ = <TMPI>;
}
print TMPO "__STG_SPLIT_MARKER(1)\n";
- print TMPO $_ if ! /\/\* SPLIT \*\//;
+ print TMPO $_ if ! /^\s*\/\* SPLIT \*\/\s*$/;
+
+ # Have to be a bit careful detecting /* SPLIT */ comments
+ # since a progam may use a string containing "/* SPLIT */"
+ # We check that there is nothing else on the line
while (<TMPI>) {
- if (/\/\* SPLIT \*\//) {
+ if (/^\s*\/\* SPLIT \*\/\s*$/) {
$marker_no++;
print TMPO "__STG_SPLIT_MARKER($marker_no)\n";
next;
$str =~ s/^\.stabs "(ghc\d+\.c)"/.stabs "$ifile_root.hc"/g; # HACK HACK
# remove/record any literal constants defined here
- while ( $str =~ /(\t\.align .\n(LC\d+):\n\t\.ascii.*\n)/ ) {
+ while ( $str =~ /(\t\.align .\n(LC\d+):\n(\t\.ascii.*\n)+)/ ) {
local($label) = $2;
local($body) = $1;
$LocalConstant{$label} = $body;
- $str =~ s/\t\.align .\nLC\d+:\n\t\.ascii.*\n//;
+ $str =~ s/\t\.align .\nLC\d+:\n(\t\.ascii.*\n)+//;
}
# inject definitions for any local constants now used herein
%
-% (c) The GRASP/AQUA Project, Glasgow University, 1992-1995
+% (c) The GRASP/AQUA Project, Glasgow University, 1992-1996
%
% *** MSUB does some substitutions here ***
% *** grep for $( ***
( $(INSTALLING) ) ? "$InstLibDirGhc/hscpp"
: "$TopPwd/$(CURRENT_DIR)/$(GHC_HSCPP)";
@HsCpp_flags = ();
+$genSPECS_flag = ''; # See ../utils/hscpp/hscpp.prl
$HsP = ( $(INSTALLING) ) ? "$InstLibDirGhc/hsp"
: "$TopPwd/$(CURRENT_DIR)/$(GHC_HSP)";
$Oopt_FinalStgProfilingMassage = '';
$Oopt_StgStats = '';
$Oopt_SpecialiseUnboxed = '';
+$Oopt_DoSpecialise = '-fspecialise';
$Oopt_FoldrBuild = 1; # On by default!
$Oopt_FB_Support = '-fdo-new-occur-anal -fdo-arity-expand';
#$Oopt_FoldrBuildWW = 0; # Off by default
# GranSim
'_mg', '$StkChkByPageFaultOK = 0;
push(@HsC_flags, \'-fconcurrent\');
-#???????????? push(@HsCpp_flags,\'-D__PARALLEL_HASKELL__\', \'-DPAR\');
push(@Cpp_define, \'-D__CONCURRENT_HASKELL__\', \'-DCONCURRENT\', \'-DGRAN\');',
'_2s', 'push (@CcBoth_flags, \'-DGC2s\');',
Now slurp through the arguments.
\begin{code}
+
+#---------- user defined prelude ---------------------------------------
+
+if (grep(/^-user-prelude$/, @ARGV)) {
+
+ # If ARGV contains -user-prelude we are compiling a piece of
+ # prelude for the user, probably with additional specialise pragmas
+
+ # We strip out the -O -f and -user-prelude flags provided on
+ # the command line and add the ones used to compile the prelude
+ # ToDo: get these options from a common definition in mkworld
+
+ # We also enable any options forced through with -user-prelude-force
+
+ # Hey, Check out this grep statement ;-) (PS)
+
+ @ARGV = grep((!/^-O/ && !/^-f/ && !/^-user-prelude$/) || s/^-user-prelude-force//,
+ @ARGV);
+
+ unshift(@ARGV,
+ '-prelude',
+ '-O',
+ '-fshow-pragma-name-errs',
+ '-fshow-import-specs',
+ '-fomit-reexported-instances',
+ '-fglasgow-exts',
+ '-genSPECS',
+ '-DUSE_FOLDR_BUILD',
+ '-dcore-lint');
+
+ print STDERR "ghc: -user-prelude options:\n", "@ARGV", "\n";
+}
+
# can't use getopt(s); what we want is too complicated
arg: while($_ = $ARGV[0]) {
shift(@ARGV);
/^-D(.*)/ && do { push(@HsCpp_flags, "'-D".&grab_arg_arg('-D',$1)."'"); next arg; };
/^-U(.*)/ && do { push(@HsCpp_flags, "'-U".&grab_arg_arg('-U',$1)."'"); next arg; };
+ /^-genSPECS/ && do { $Cpp_flag_set = 1;
+ $genSPECS_flag = $_;
+ next arg; };
+
#---------- Haskell parser (hsp) ---------------------------------------
/^-ddump-parser$/ && do { $Dump_parser_output = 1; next arg; };
/^-prelude$/ && do { $CompilingPrelude = 1;
push(@HsC_flags, $_); next arg; };
+ /^-user-prelude-force/ && do { # ignore if not -user-prelude
+ next arg; };
+
/^-split-objs(.*)/ && do {
local($sname) = &grab_arg_arg('-split-objs', $1);
$sname =~ s/ //g; # no spaces
if ( $TargetPlatform =~ /^(alpha|hppa1\.1|i386|m68k|mips|powerpc|sparc)-/ ) {
$SplitObjFiles = 1;
+ $ProduceS = '';
+ $ProduceC = 1;
+
push(@HsC_flags, "-fglobalise-toplev-names$sname");
push(@CcBoth_flags, '-DUSE_SPLIT_MARKERS');
}
next arg; };
- /^-fglobalise-toplev-names$/&& do { push(@HsC_flags, $_); next arg; };
-
/^-f(hide-builtin-names|min-builtin-names)$/
&& do { push(@HsC_flags, $_);
push(@HsP_flags, '-P'); # don't read Prelude.hi
}
next arg; };
- /^-fspecialise-unboxed$/
- && do { $Oopt_SpecialiseUnboxed = '-fspecialise-unboxed';
+ /^-fspeciali[sz]e-unboxed$/
+ && do { $Oopt_DoSpecialise = '-fspecialise';
+ $Oopt_SpecialiseUnboxed = '-fspecialise-unboxed';
+ next arg; };
+ /^-fspeciali[sz]e$/
+ && do { $Oopt_DoSpecialise = '-fspecialise';
next arg; };
+ /^-fno-speciali[sz]e$/
+ && do { $Oopt_DoSpecialise = '';
+ next arg; };
+
# Now the foldr/build options, which are *on* by default (for -O).
/^-fno-foldr-build-rule$/
&& do { $Oopt_FoldrBuild = 0;
- next arg; };
+ next arg; };
/^-fno-enable-tech$/
&& do { $Oopt_FB_Support = '';
/^-d(dump|ppr)-/ && do { push(@HsC_flags, $_); next arg; };
/^-dverbose-(simpl|stg)/ && do { push(@HsC_flags, $_); next arg; };
+ /^-dshow-passes/ && do { push(@HsC_flags, $_); next arg; };
+ /^-dsource-stats/ && do { push(@HsC_flags, $_); next arg; };
/^-dsimplifier-stats/ && do { push(@HsC_flags, $_); next arg; };
/^-dstg-stats/ && do { $Oopt_StgStats = $_; next arg; };
close(OFILE);
next arg; };
- /^-debug$/ && do { # all this does is mark a .hc/.o as "debugging"
- # in the consistency info
- $DEBUGging = 'd';
- next arg; };
+ /^-debug$/ && do { # all this does is mark a .hc/.o as "debugging"
+ # in the consistency info
+ $DEBUGging = 'd';
+ next arg; };
+
+ #---------- linking .a file --------------------------------------------
+
+ /^-Main(.*)/ && do {
+ # specifies main or mainPrimIO to be linked
+ $Ld_main = $1;
+ next arg; };
#---------- catch unrecognized flags -----------------------------------
next arg; };
#---------- anything else is considered an input file ------------------
- # (well, .o files are immediately queued up as linker fodder..)
- if (/\.o$/) {
+ # (well, .o and .a files are immediately queued up as linker fodder..)
+ if (/\.[oa]$/) {
push(@Link_file, $_);
} else {
push(@Input_file, $_);
@HsC_minusO_flags # NOTE: used for *both* -O and -O2 (some conditional bits)
= (
- # core2core passes
- # initial simplify: mk specialiser happy: minimum effort please
+ # initial simplify: mk specialiser and autoscc happy: minimum effort please
'-fsimplify',
'\(',
"$Oopt_FB_Support",
- '-fkeep-spec-pragma-ids',
+ '-fkeep-spec-pragma-ids', # required before specialisation
'-fsimpl-uf-use-threshold0',
'-fessential-unfoldings-only',
'-fmax-simplifier-iterations1',
"$Oopt_PedanticBottoms",
'\)',
- $Oopt_AddAutoSccs, # dangerous to do with *no* simplification...
+ $Oopt_AddAutoSccs, # need some basic simplification first
- '-fspecialise-overloaded',
- $Oopt_SpecialiseUnboxed,
- '-fspecialise',
+ ($Oopt_DoSpecialise) ? (
+ '-fspecialise-overloaded',
+ $Oopt_SpecialiseUnboxed,
+ $Oopt_DoSpecialise,
+ ) : (),
- '-fsimplify', # need tossing before calc-i...
- '\(',
+ '-fsimplify', # need dependency anal after specialiser ...
+ '\(', # need tossing before calc-inlinings ...
"$Oopt_FB_Support",
'-ffloat-lets-exposing-whnf',
'-ffloat-primops-ok',
'-fdo-eta-reduction',
'-fdo-lambda-eta-expansion',
'-freuse-con',
-# '-flet-to-case', # no point, before strictness analysis
"$Oopt_PedanticBottoms",
"$Oopt_MonadEtaExpansion",
"$Oopt_UnfoldingUseThreshold",
# '-fdo-eta-reduction',
# '-fdo-lambda-eta-expansion',
# '-freuse-con',
-## '-flet-to-case', # no point, before strictness analysis
# "$Oopt_PedanticBottoms",
# "$Oopt_MonadEtaExpansion",
# "$Oopt_UnfoldingUseThreshold",
'-ffull-laziness',
($Oopt_FoldrBuild) ? (
+ '-ffoldr-build-on', # desugar list comprehensions for foldr/build
+
'-fsimplify',
'\(',
'-fignore-inline-pragma', # **** NB!
'-fdo-eta-reduction',
'-fdo-lambda-eta-expansion',
'-freuse-con',
- # '-flet-to-case', # no point, before strictness analysis
"$Oopt_PedanticBottoms",
"$Oopt_MonadEtaExpansion",
"$Oopt_UnfoldingUseThreshold",
'-fdo-eta-reduction',
'-fdo-lambda-eta-expansion',
'-freuse-con',
-# '-flet-to-case', # no point, before strictness analysis
- '-fdo-inline-foldr-build',
- # you need to inline foldr!
+ '-fdo-inline-foldr-build', # foldr/build done so inline
"$Oopt_PedanticBottoms",
"$Oopt_MonadEtaExpansion",
"$Oopt_UnfoldingUseThreshold",
'-fdo-eta-reduction',
'-fdo-lambda-eta-expansion',
'-freuse-con',
- '-flet-to-case', # Aha!
+ '-flet-to-case', # Aha! Only done after strictness analysis
"$Oopt_PedanticBottoms",
"$Oopt_MonadEtaExpansion",
"$Oopt_UnfoldingUseThreshold",
"$Oopt_MaxSimplifierIterations",
'\)',
-# '-fstatic-args',
+ # '-fstatic-args',
+
'-fcalc-inlinings2',
# stg2stg passes
# flags for stg2stg
'-flet-no-escape',
- # how do we desugar list comprehensions ?
- (($Oopt_FoldrBuild) ? '-ffoldr-build-on' : '' ),
-
# SPECIAL FLAGS for -O2
- (($OptLevel == 2) ? '-fsemi-tagging' : '')
+ ($OptLevel == 2) ? (
+ '-fsemi-tagging',
+ ) : (),
);
\end{code}
|| $TargetPlatform =~ /^powerpc-/
|| $TargetPlatform =~ /-solaris/
)
- ? ('-u', 'unsafePerformPrimIO_fast1',
+ ? (($Ld_main) ? (
+ '-u', 'Main_' . $Ld_main . '_closure',
+ ) : (),
+ '-u', 'unsafePerformPrimIO_fast1',
'-u', 'Nil_closure',
'-u', 'IZh_static_info',
'-u', 'False_inregs_info',
'-u', 'DEBUG_REGS') # just for fun, now...
# nice friendly a.out machines...
- : ('-u', '_unsafePerformPrimIO_fast1',
+ : (($Ld_main) ? (
+ '-u', '_Main_' . $Ld_main . '_closure',
+ ) : (),
+ '-u', '_unsafePerformPrimIO_fast1',
'-u', '_Nil_closure',
'-u', '_IZh_static_info',
'-u', '_False_inregs_info',
local($lnkr) = ( $Lnkr ) ? $Lnkr : ($RegisteriseC ? $CcRegd : $CcUnregd );
local($output)= ($Specific_output_file ne '') ? "-o $Specific_output_file" : '';
- @Files_to_tidy = ( ($Specific_output_file ne '') ? "$Specific_output_file" : 'a.out' );
+ @Files_to_tidy = ($Specific_output_file ne '') ? "$Specific_output_file" : 'a.out';
local($to_do) = "$lnkr $Verbose @Ld_flags $output @Link_file $TopClosureFile $libdirs @UserLibrary @SysLibrary";
&run_something($to_do, 'Linker');
} else {
local($includes) = '-I' . join(' -I',@Include_dir);
local($to_do) = "echo '#line 1 \"$in_lit2pgm\"' > $hscpp_hsp; ".
- "$HsCpp $Verbose @HsCpp_flags -D__HASKELL1__=$haskell1_version -D__GLASGOW_HASKELL__=$ghc_version_info $includes $lit2pgm_hscpp >> $hscpp_hsp";
+ "$HsCpp $Verbose $genSPECS_flag @HsCpp_flags -D__HASKELL1__=$haskell1_version -D__GLASGOW_HASKELL__=$ghc_version_info $includes $lit2pgm_hscpp >> $hscpp_hsp";
@Files_to_tidy = ( $hscpp_hsp );
&run_something($to_do, 'Haskellised C pre-processor');
}
%* *
%************************************************************************
-\tr{r13}--\tr{r31} are wonderful callee-save registers.
-\tr{r4}--\tr{r8}, \tr{r10}, and \tr{r11} are caller-save registers.
+\tr{r14}--\tr{r31} are wonderful callee-save registers.
+\tr{r0}--\tr{r13} are caller-save registers.
\tr{%fr14}--\tr{%fr31} are callee-save floating-point registers.
\begin{code}
#if powerpc_TARGET_ARCH
-#define REG(x) __asm__("%" #x)
+#define REG(x) __asm__(#x)
#if defined(MARK_REG_MAP)
-#define REG_Mark r13
-#define REG_MStack r14
-#define REG_MRoot r15
-#define REG_BitArray r16
-#define REG_HeapBase r17
-#define REG_HeapLim r18
+#define REG_Mark r14
+#define REG_MStack r15
+#define REG_MRoot r16
+#define REG_BitArray r17
+#define REG_HeapBase r18
+#define REG_HeapLim r19
#else
#if defined(SCAN_REG_MAP)
-#define REG_Scan r13
-#define REG_New r14
-#define REG_LinkLim r15
+#define REG_Scan r14
+#define REG_New r15
+#define REG_LinkLim r16
#else
#if defined(SCAV_REG_MAP)
-#define REG_Scav r13
-#define REG_ToHp r14
+#define REG_Scav r14
+#define REG_ToHp r15
#if defined(GCap) || defined(GCgn)
-#define REG_OldGen r15
+#define REG_OldGen r16
#endif /* GCap || GCgn */
#else /* default: MAIN_REG_MAP */
#define CALLEE_SAVES_R7
#define CALLEE_SAVES_R8
-#define REG_R1 r13
-#define REG_R2 r14
-#define REG_R3 r15
-#define REG_R4 r16
-#define REG_R5 r17
-#define REG_R6 r18
-#define REG_R7 r19
-#define REG_R8 r20
+#define REG_R1 r14
+#define REG_R2 r15
+#define REG_R3 r16
+#define REG_R4 r17
+#define REG_R5 r18
+#define REG_R6 r19
+#define REG_R7 r20
+#define REG_R8 r21
#define REG_Flt1 fr14
#define REG_Flt2 fr15
#define REG_Dbl1 fr18
#define REG_Dbl2 fr19
-#define REG_SpA r21
-#define REG_SuA r22
-#define REG_SpB r23
-#define REG_SuB r24
+#define REG_SpA r22
+#define REG_SuA r23
+#define REG_SpB r24
+#define REG_SuB r25
-#define REG_Hp r25
-#define REG_HpLim r26
+#define REG_Hp r26
+#define REG_HpLim r27
-#define REG_Ret r27
+#define REG_Ret r28
-#define REG_StkStub r28
+#define REG_StkStub r29
#endif /* SCAV_REG_MAP */
#endif /* SCAN_REG_MAP */
/* The driver will give warnings if -split-objs,
but that's cool...
*/
-GHC_OPTS=-iprelude:glaExts -dcore-lint \
- -fshow-pragma-name-errs -fshow-import-specs \
- -optP-genSPECS0 -cpp -fglasgow-exts \
- -DUSE_FOLDR_BUILD -D__OVERLAPPING_INSTANCES__ \
- HcMaxHeapFlag $(EXTRA_HC_OPTS)
+GHC_OPTS=-iprelude:glaExts \
+ -dcore-lint \
+ -fshow-pragma-name-errs \
+ -fshow-import-specs \
+ -fomit-default-instance-methods \
+ -cpp -fglasgow-exts -genSPECS \
+ -DUSE_FOLDR_BUILD -D__OVERLAPPING_INSTANCES__ \
+ HcMaxHeapFlag $(EXTRA_HC_OPTS)
+
+/* For building with unboxed stuff add:
+
+ -fspecialise-unboxed -genSPECSunboxed -D__UNBOXED_INSTANCES__ -D__UNBOXED_SPECS__
+
+ This is currently done using -user-way-b = -unboxed-specialisation
+*/
/* For the "Prelude" bits: mostly we do not want it to pick
up interface information from anywhere except *here*.
ghc/MatchPS.hi \
ghc/Pretty.hi \
ghc/Set.hi \
- ghc/Util.hi __readline_hi __sockets_hi
+ ghc/Util.hi
ONE3_HIs = haskell-1.3/LibSystem.hi \
haskell-1.3/LibCPUTime.hi \
CompilePreludishly(prelude/TyIO,hs, $(PREL_OPTS) -split-objs TyIO -fmin-builtin-names -ohi prelude/TyIO.hi)
CompilePreludishly(prelude/TyRatio,hs, $(PREL_OPTS) -split-objs TyRatio -fmin-builtin-names -nohi)
-CompilePreludishly(prelude/IArray,hs, $(PREL_OPTS) -split-objs IArray -H14m -ohi prelude/IArray.hi)
+CompilePreludishly(prelude/IArray,hs, $(PREL_OPTS) -split-objs IArray -H18m -ohi prelude/IArray.hi)
CompilePreludishly(prelude/IBool,hs, $(PREL_OPTS) -split-objs IBool -ohi prelude/IBool.hi)
CompilePreludishly(prelude/IChar,hs, $(PREL_OPTS) -split-objs IChar -ohi prelude/IChar.hi)
CompilePreludishly(prelude/IComplex,hs, $(PREL_OPTS) -split-objs IComplex -H16m -ohi prelude/IComplex.hi)
CompilePreludishly(prelude/IFloat,hs, $(PREL_OPTS) -split-objs IFloat -ohi prelude/IFloat.hi)
CompilePreludishly(prelude/IInt,hs, $(PREL_OPTS) -split-objs IInt -ohi prelude/IInt.hi -monly-4-regs)
CompilePreludishly(prelude/IInteger,hs, $(PREL_OPTS) -split-objs IInteger -ohi prelude/IInteger.hi)
-CompilePreludishly(prelude/IList,hs, $(PREL_OPTS) -split-objs IList -ohi prelude/IList.hi)
+CompilePreludishly(prelude/IList,hs, $(PREL_OPTS) -split-objs IList -H12m -ohi prelude/IList.hi)
CompilePreludishly(prelude/IRatio,hs, $(PREL_OPTS) -split-objs IRatio -H16m -ohi prelude/IRatio.hi)
CompilePreludishly(prelude/ITup0,hs, $(PREL_OPTS) -split-objs ITup0 -ohi prelude/ITup0.hi)
-CompilePreludishly(prelude/ITup2,hs, $(PREL_OPTS) -split-objs ITup2 -ohi prelude/ITup2.hi)
+CompilePreludishly(prelude/ITup2,hs, $(PREL_OPTS) -split-objs ITup2 -H40m -K2m -ohi prelude/ITup2.hi)
CompilePreludishly(prelude/ITup3,hs, $(PREL_OPTS) -split-objs ITup3 -ohi prelude/ITup3.hi)
CompilePreludishly(prelude/ITup4,hs, $(PREL_OPTS) -split-objs ITup4 -H16m -ohi prelude/ITup4.hi)
CompilePreludishly(prelude/ITup5,hs, $(PREL_OPTS) -split-objs ITup5 -H24m -ohi prelude/ITup5.hi)
CompilePreludishly(prelude/Cls,hs, $(PREL_OPTS) -split-objs Cls -H24m -fmin-builtin-names -ohi prelude/Cls.hi)
CompilePreludishly(prelude/Builtin,hs, $(PREL_OPTS) -split-objs Builtin -ohi prelude/Builtin.hi)
-CompilePreludishly(prelude/Core,hs, $(PREL_OPTS) -split-objs Core -ohi prelude/Core.hi)
+CompilePreludishly(prelude/Core,hs, $(PREL_OPTS) -split-objs Core -H24m -ohi prelude/Core.hi)
CompilePreludishly(prelude/IO,hs, $(PREL_OPTS) -split-objs IO -ohi prelude/IO.hi)
-CompilePreludishly(prelude/List,hs, $(PREL_OPTS) -split-objs List -H14m -ohi prelude/List.hi)
+CompilePreludishly(prelude/List,hs, $(PREL_OPTS) -split-objs List -H24m -ohi prelude/List.hi)
CompilePreludishly(prelude/PS,lhs, $(PREL_OPTS) -split-objs PS -ohi prelude/PS.hi -monly-2-regs)
CompilePreludishly(prelude/Prel,hs, $(PREL_OPTS) -split-objs Prel -H14m -ohi prelude/Prel.hi -monly-2-regs)
-CompilePreludishly(prelude/Text,hs, $(PREL_OPTS) -split-objs Text -H14m -ohi prelude/Text.hi -monly-4-regs)
+CompilePreludishly(prelude/Text,hs, $(PREL_OPTS) -split-objs Text -H30m -ohi prelude/Text.hi -monly-4-regs)
CompilePreludishly(prelude/FoldrBuild,hs, $(PREL_OPTS) -split-objs FoldrBuild -nohi)
/* --- 1.3 I/O support --- */
CompilePreludishly(haskell-1.3/LibSystem,lhs, -fhaskell-1.3 -split-objs LibSystem '-#include"stgio.h"')
CompilePreludishly(haskell-1.3/LibCPUTime,lhs, -fhaskell-1.3 -split-objs LibCPUTime '-#include"stgio.h"')
CompilePreludishly(haskell-1.3/LibDirectory,lhs, -fhaskell-1.3 -split-objs LibDirectory '-#include"stgio.h"' -monly-3-regs)
-CompilePreludishly(haskell-1.3/LibTime,lhs, -fhaskell-1.3 -split-objs LibTime '-#include"stgio.h"' '-#include"timezone.h"' -H12m -monly-3-regs -optcO-DNON_POSIX_SOURCE)
+CompilePreludishly(haskell-1.3/LibTime,lhs, -fhaskell-1.3 -split-objs LibTime '-#include"stgio.h"' '-#include"timezone.h"' -H12m -K2m -monly-3-regs)
CompilePreludishly(haskell-1.3/LibPosix,lhs, -fhaskell-1.3 -split-objs LibPosix '-#include"stgio.h"' '-#include"libposix.h"')
CompilePreludishly(haskell-1.3/LibPosixDB,lhs, -fhaskell-1.3 -split-objs LibPosixDB '-#include"stgio.h"' '-#include"libposix.h"')
CompilePreludishly(ghc/CError,lhs, -ighc -fhaskell-1.3 -K2m -fomit-derived-read)
#endif
CompilePreludishly(ghc/Set,lhs, -ighc -fhaskell-1.3)
-CompilePreludishly(ghc/Util,lhs, -ighc -fhaskell-1.3)
+CompilePreludishly(ghc/Util,lhs, -H12m -ighc -fhaskell-1.3)
/* --- HBC-compatibility library --- */
CompilePreludishly(hbc/ListUtil,hs, -ihbc -fhaskell-1.3)
CompilePreludishly(hbc/Miranda,hs, -ihbc)
CompilePreludishly(hbc/NameSupply,hs, )
-CompilePreludishly(hbc/Native,hs, -ihbc -fhaskell-1.3)
-CompilePreludishly(hbc/Number,hs, )
-CompilePreludishly(hbc/Parse,hs, -ihbc -fhaskell-1.3)
+CompilePreludishly(hbc/Native,hs, -H12m -ihbc -fhaskell-1.3 -fno-omit-default-instance-methods)
+CompilePreludishly(hbc/Number,hs, -H12m -K2m -fno-omit-default-instance-methods)
+CompilePreludishly(hbc/Parse,hs, -H12m -ihbc -fhaskell-1.3)
CompilePreludishly(hbc/Polynomial,hs, -ihbc) /* this code could not ever have worked */
CompilePreludishly(hbc/Pretty,hs, )
-CompilePreludishly(hbc/Printf,hs, )
+CompilePreludishly(hbc/Printf,hs, -H12m)
CompilePreludishly(hbc/QSort,hs, )
CompilePreludishly(hbc/Random,hs, -monly-4-regs)
CompilePreludishly(hbc/SimpleLex,hs, )
-CompilePreludishly(hbc/Time,hs, )
+CompilePreludishly(hbc/Time,hs, -H12m)
CompilePreludishly(hbc/Trace,hs, -fglasgow-exts)
-CompilePreludishly(hbc/Word,hs, -K2m -monly-4-regs)
+CompilePreludishly(hbc/Word,hs, -H12m -K2m -monly-4-regs)
/****************************************************************
* *
-{-# GHC_PRAGMA INTERFACE VERSION 5 #-}
+{-# GHC_PRAGMA INTERFACE VERSION 6 #-}
interface BSD where
import PreludeIOError(IOError13)
import PreludeMonadicIO(Either)
{-# GHC_PRAGMA _A_ 2 _U_ 12 _N_ _S_ "EL" _N_ _N_ #-}
instance Eq Family
{-# GHC_PRAGMA _M_ SocketPrim {-dfun-} _A_ 0 _N_ _N_ _N_ _F_ _IF_ARGS_ 0 0 X 3 _!_ _TUP_2 [(Family -> Family -> Bool), (Family -> Family -> Bool)] [_CONSTM_ Eq (==) (Family), _CONSTM_ Eq (/=) (Family)] _N_
- (==) = _A_ 2 _U_ 11 _N_ _S_ "EE" _N_ _N_,
- (/=) = _A_ 2 _U_ 11 _N_ _S_ "EE" _N_ _N_ #-}
+ (==) = { _A_ 2 _U_ 11 _N_ _S_ "EE" _N_ _N_ },
+ (/=) = { _A_ 2 _U_ 11 _N_ _S_ "EE" _N_ _N_ } #-}
instance Ix Family
{-# GHC_PRAGMA _M_ SocketPrim {-dfun-} _A_ 0 _N_ _N_ _N_ _F_ _IF_ARGS_ 0 0 X 5 _!_ _TUP_4 [{{Ord Family}}, ((Family, Family) -> [Family]), ((Family, Family) -> Family -> Int), ((Family, Family) -> Family -> Bool)] [_DFUN_ Ord (Family), _CONSTM_ Ix range (Family), _CONSTM_ Ix index (Family), _CONSTM_ Ix inRange (Family)] _N_
- range = _A_ 1 _U_ 1 _N_ _S_ "U(EE)" {_A_ 2 _U_ 11 _N_ _N_ _N_ _N_} _N_ _N_,
- index = _A_ 2 _U_ 12 _N_ _S_ "U(EE)E" {_A_ 3 _U_ 212 _N_ _N_ _N_ _N_} _N_ _N_,
- inRange = _A_ 2 _U_ 11 _N_ _S_ "U(EE)E" {_A_ 3 _U_ 111 _N_ _N_ _N_ _N_} _N_ _N_ #-}
+ range = { _A_ 1 _U_ 1 _N_ _S_ "U(EE)" {_A_ 2 _U_ 11 _N_ _N_ _N_ _N_} _N_ _N_ },
+ index = { _A_ 2 _U_ 12 _N_ _S_ "U(EE)E" {_A_ 3 _U_ 212 _N_ _N_ _N_ _N_} _N_ _N_ },
+ inRange = { _A_ 2 _U_ 11 _N_ _S_ "U(EE)E" {_A_ 3 _U_ 111 _N_ _N_ _N_ _N_} _N_ _N_ } #-}
instance Ord Family
{-# GHC_PRAGMA _M_ SocketPrim {-dfun-} _A_ 0 _N_ _N_ _N_ _F_ _IF_ARGS_ 0 0 X 9 _!_ _TUP_8 [{{Eq Family}}, (Family -> Family -> Bool), (Family -> Family -> Bool), (Family -> Family -> Bool), (Family -> Family -> Bool), (Family -> Family -> Family), (Family -> Family -> Family), (Family -> Family -> _CMP_TAG)] [_DFUN_ Eq (Family), _CONSTM_ Ord (<) (Family), _CONSTM_ Ord (<=) (Family), _CONSTM_ Ord (>=) (Family), _CONSTM_ Ord (>) (Family), _CONSTM_ Ord max (Family), _CONSTM_ Ord min (Family), _CONSTM_ Ord _tagCmp (Family)] _N_
- (<) = _A_ 2 _U_ 11 _N_ _S_ "EE" _N_ _N_,
- (<=) = _A_ 2 _U_ 11 _N_ _S_ "EE" _N_ _N_,
- (>=) = _A_ 2 _U_ 11 _N_ _S_ "EE" _N_ _N_,
- (>) = _A_ 2 _U_ 11 _N_ _S_ "EE" _N_ _N_,
- max = _A_ 2 _U_ 22 _N_ _S_ "EE" _N_ _N_,
- min = _A_ 2 _U_ 22 _N_ _S_ "EE" _N_ _N_,
- _tagCmp = _A_ 2 _U_ 11 _N_ _S_ "EE" _N_ _N_ #-}
+ (<) = { _A_ 2 _U_ 11 _N_ _S_ "EE" _N_ _N_ },
+ (<=) = { _A_ 2 _U_ 11 _N_ _S_ "EE" _N_ _N_ },
+ (>=) = { _A_ 2 _U_ 11 _N_ _S_ "EE" _N_ _N_ },
+ (>) = { _A_ 2 _U_ 11 _N_ _S_ "EE" _N_ _N_ },
+ max = { _A_ 2 _U_ 22 _N_ _S_ "EE" _N_ _N_ },
+ min = { _A_ 2 _U_ 22 _N_ _S_ "EE" _N_ _N_ },
+ _tagCmp = { _A_ 2 _U_ 11 _N_ _S_ "EE" _N_ _N_ } #-}
instance Text Family
{-# GHC_PRAGMA _M_ SocketPrim {-dfun-} _A_ 0 _N_ _N_ _N_ _F_ _IF_ARGS_ 0 0 X 5 _!_ _TUP_4 [(Int -> [Char] -> [(Family, [Char])]), (Int -> Family -> [Char] -> [Char]), ([Char] -> [([Family], [Char])]), ([Family] -> [Char] -> [Char])] [_CONSTM_ Text readsPrec (Family), _CONSTM_ Text showsPrec (Family), _CONSTM_ Text readList (Family), _CONSTM_ Text showList (Family)] _N_
- readsPrec = _A_ 2 _U_ 02 _N_ _S_ "AL" {_A_ 1 _U_ 2 _N_ _N_ _N_ _N_} _N_ _N_,
- showsPrec = _A_ 3 _U_ 012 _N_ _S_ "AEL" {_A_ 2 _U_ 12 _N_ _N_ _N_ _N_} _N_ _N_,
- readList = _A_ 0 _U_ 2 _N_ _N_ _N_ _N_,
- showList = _A_ 0 _U_ 12 _N_ _N_ _N_ _N_ #-}
+ readsPrec = { _A_ 2 _U_ 02 _N_ _S_ "AL" {_A_ 1 _U_ 2 _N_ _N_ _N_ _N_} _N_ _N_ },
+ showsPrec = { _A_ 3 _U_ 012 _N_ _S_ "AEL" {_A_ 2 _U_ 12 _N_ _N_ _N_ _N_} _N_ _N_ },
+ readList = { _A_ 0 _U_ 2 _N_ _N_ _N_ _N_ },
+ showList = { _A_ 1 _U_ 12 _N_ _N_ _F_ _IF_ARGS_ 0 1 X 3 \ (u0 :: [Family]) -> _APP_ _TYAPP_ _ORIG_ PreludeCore _showList { Family } [ _WRKR_ _CONSTM_ Text showsPrec (Family), u0 ] _N_ } #-}
-{-# GHC_PRAGMA INTERFACE VERSION 5 #-}
+{-# GHC_PRAGMA INTERFACE VERSION 6 #-}
interface BSD where
import PreludeIOError(IOError13)
import PreludeMonadicIO(Either)
{-# GHC_PRAGMA _A_ 2 _U_ 12 _N_ _S_ "EL" _N_ _N_ #-}
instance Eq Family
{-# GHC_PRAGMA _M_ SocketPrim {-dfun-} _A_ 0 _N_ _N_ _N_ _F_ _IF_ARGS_ 0 0 X 3 _!_ _TUP_2 [(Family -> Family -> Bool), (Family -> Family -> Bool)] [_CONSTM_ Eq (==) (Family), _CONSTM_ Eq (/=) (Family)] _N_
- (==) = _A_ 2 _U_ 11 _N_ _S_ "EE" _N_ _N_,
- (/=) = _A_ 2 _U_ 11 _N_ _S_ "EE" _N_ _N_ #-}
+ (==) = { _A_ 2 _U_ 11 _N_ _S_ "EE" _N_ _N_ },
+ (/=) = { _A_ 2 _U_ 11 _N_ _S_ "EE" _N_ _N_ } #-}
instance Ix Family
{-# GHC_PRAGMA _M_ SocketPrim {-dfun-} _A_ 0 _N_ _N_ _N_ _F_ _IF_ARGS_ 0 0 X 5 _!_ _TUP_4 [{{Ord Family}}, ((Family, Family) -> [Family]), ((Family, Family) -> Family -> Int), ((Family, Family) -> Family -> Bool)] [_DFUN_ Ord (Family), _CONSTM_ Ix range (Family), _CONSTM_ Ix index (Family), _CONSTM_ Ix inRange (Family)] _N_
- range = _A_ 1 _U_ 1 _N_ _S_ "U(EE)" {_A_ 2 _U_ 11 _N_ _N_ _N_ _N_} _N_ _N_,
- index = _A_ 2 _U_ 12 _N_ _S_ "U(EE)E" {_A_ 3 _U_ 212 _N_ _N_ _N_ _N_} _N_ _N_,
- inRange = _A_ 2 _U_ 11 _N_ _S_ "U(EE)E" {_A_ 3 _U_ 111 _N_ _N_ _N_ _N_} _N_ _N_ #-}
+ range = { _A_ 1 _U_ 1 _N_ _S_ "U(EE)" {_A_ 2 _U_ 11 _N_ _N_ _N_ _N_} _N_ _N_ },
+ index = { _A_ 2 _U_ 12 _N_ _S_ "U(EE)E" {_A_ 3 _U_ 212 _N_ _N_ _N_ _N_} _N_ _N_ },
+ inRange = { _A_ 2 _U_ 11 _N_ _S_ "U(EE)E" {_A_ 3 _U_ 111 _N_ _N_ _N_ _N_} _N_ _N_ } #-}
instance Ord Family
{-# GHC_PRAGMA _M_ SocketPrim {-dfun-} _A_ 0 _N_ _N_ _N_ _F_ _IF_ARGS_ 0 0 X 9 _!_ _TUP_8 [{{Eq Family}}, (Family -> Family -> Bool), (Family -> Family -> Bool), (Family -> Family -> Bool), (Family -> Family -> Bool), (Family -> Family -> Family), (Family -> Family -> Family), (Family -> Family -> _CMP_TAG)] [_DFUN_ Eq (Family), _CONSTM_ Ord (<) (Family), _CONSTM_ Ord (<=) (Family), _CONSTM_ Ord (>=) (Family), _CONSTM_ Ord (>) (Family), _CONSTM_ Ord max (Family), _CONSTM_ Ord min (Family), _CONSTM_ Ord _tagCmp (Family)] _N_
- (<) = _A_ 2 _U_ 11 _N_ _S_ "EE" _N_ _N_,
- (<=) = _A_ 2 _U_ 11 _N_ _S_ "EE" _N_ _N_,
- (>=) = _A_ 2 _U_ 11 _N_ _S_ "EE" _N_ _N_,
- (>) = _A_ 2 _U_ 11 _N_ _S_ "EE" _N_ _N_,
- max = _A_ 2 _U_ 22 _N_ _S_ "EE" _N_ _N_,
- min = _A_ 2 _U_ 22 _N_ _S_ "EE" _N_ _N_,
- _tagCmp = _A_ 2 _U_ 11 _N_ _S_ "EE" _N_ _N_ #-}
+ (<) = { _A_ 2 _U_ 11 _N_ _S_ "EE" _N_ _N_ },
+ (<=) = { _A_ 2 _U_ 11 _N_ _S_ "EE" _N_ _N_ },
+ (>=) = { _A_ 2 _U_ 11 _N_ _S_ "EE" _N_ _N_ },
+ (>) = { _A_ 2 _U_ 11 _N_ _S_ "EE" _N_ _N_ },
+ max = { _A_ 2 _U_ 22 _N_ _S_ "EE" _N_ _N_ },
+ min = { _A_ 2 _U_ 22 _N_ _S_ "EE" _N_ _N_ },
+ _tagCmp = { _A_ 2 _U_ 11 _N_ _S_ "EE" _N_ _N_ } #-}
instance Text Family
{-# GHC_PRAGMA _M_ SocketPrim {-dfun-} _A_ 0 _N_ _N_ _N_ _F_ _IF_ARGS_ 0 0 X 5 _!_ _TUP_4 [(Int -> [Char] -> [(Family, [Char])]), (Int -> Family -> [Char] -> [Char]), ([Char] -> [([Family], [Char])]), ([Family] -> [Char] -> [Char])] [_CONSTM_ Text readsPrec (Family), _CONSTM_ Text showsPrec (Family), _CONSTM_ Text readList (Family), _CONSTM_ Text showList (Family)] _N_
- readsPrec = _A_ 2 _U_ 02 _N_ _S_ "AL" {_A_ 1 _U_ 2 _N_ _N_ _N_ _N_} _N_ _N_,
- showsPrec = _A_ 3 _U_ 012 _N_ _S_ "AEL" {_A_ 2 _U_ 12 _N_ _N_ _N_ _N_} _N_ _N_,
- readList = _A_ 0 _U_ 2 _N_ _N_ _N_ _N_,
- showList = _A_ 0 _U_ 12 _N_ _N_ _N_ _N_ #-}
+ readsPrec = { _A_ 2 _U_ 02 _N_ _S_ "AL" {_A_ 1 _U_ 2 _N_ _N_ _N_ _N_} _N_ _N_ },
+ showsPrec = { _A_ 3 _U_ 012 _N_ _S_ "AEL" {_A_ 2 _U_ 12 _N_ _N_ _N_ _N_} _N_ _N_ },
+ readList = { _A_ 0 _U_ 2 _N_ _N_ _N_ _N_ },
+ showList = { _A_ 1 _U_ 12 _N_ _N_ _F_ _IF_ARGS_ 0 1 X 3 \ (u0 :: [Family]) -> _APP_ _TYAPP_ _ORIG_ PreludeCore _showList { Family } [ _WRKR_ _CONSTM_ Text showsPrec (Family), u0 ] _N_ } #-}
-{-# GHC_PRAGMA INTERFACE VERSION 5 #-}
+{-# GHC_PRAGMA INTERFACE VERSION 6 #-}
interface BSD where
import PreludeIOError(IOError13)
import PreludeMonadicIO(Either)
{-# GHC_PRAGMA _A_ 2 _U_ 12 _N_ _S_ "EL" _N_ _N_ #-}
instance Eq Family
{-# GHC_PRAGMA _M_ SocketPrim {-dfun-} _A_ 0 _N_ _N_ _N_ _F_ _IF_ARGS_ 0 0 X 3 _!_ _TUP_2 [(Family -> Family -> Bool), (Family -> Family -> Bool)] [_CONSTM_ Eq (==) (Family), _CONSTM_ Eq (/=) (Family)] _N_
- (==) = _A_ 2 _U_ 11 _N_ _S_ "EE" _N_ _N_,
- (/=) = _A_ 2 _U_ 11 _N_ _S_ "EE" _N_ _N_ #-}
+ (==) = { _A_ 2 _U_ 11 _N_ _S_ "EE" _N_ _N_ },
+ (/=) = { _A_ 2 _U_ 11 _N_ _S_ "EE" _N_ _N_ } #-}
instance Ix Family
{-# GHC_PRAGMA _M_ SocketPrim {-dfun-} _A_ 0 _N_ _N_ _N_ _F_ _IF_ARGS_ 0 0 X 5 _!_ _TUP_4 [{{Ord Family}}, ((Family, Family) -> [Family]), ((Family, Family) -> Family -> Int), ((Family, Family) -> Family -> Bool)] [_DFUN_ Ord (Family), _CONSTM_ Ix range (Family), _CONSTM_ Ix index (Family), _CONSTM_ Ix inRange (Family)] _N_
- range = _A_ 1 _U_ 1 _N_ _S_ "U(EE)" {_A_ 2 _U_ 11 _N_ _N_ _N_ _N_} _N_ _N_,
- index = _A_ 2 _U_ 12 _N_ _S_ "U(EE)E" {_A_ 3 _U_ 212 _N_ _N_ _N_ _N_} _N_ _N_,
- inRange = _A_ 2 _U_ 11 _N_ _S_ "U(EE)E" {_A_ 3 _U_ 111 _N_ _N_ _N_ _N_} _N_ _N_ #-}
+ range = { _A_ 1 _U_ 1 _N_ _S_ "U(EE)" {_A_ 2 _U_ 11 _N_ _N_ _N_ _N_} _N_ _N_ },
+ index = { _A_ 2 _U_ 12 _N_ _S_ "U(EE)E" {_A_ 3 _U_ 212 _N_ _N_ _N_ _N_} _N_ _N_ },
+ inRange = { _A_ 2 _U_ 11 _N_ _S_ "U(EE)E" {_A_ 3 _U_ 111 _N_ _N_ _N_ _N_} _N_ _N_ } #-}
instance Ord Family
{-# GHC_PRAGMA _M_ SocketPrim {-dfun-} _A_ 0 _N_ _N_ _N_ _F_ _IF_ARGS_ 0 0 X 9 _!_ _TUP_8 [{{Eq Family}}, (Family -> Family -> Bool), (Family -> Family -> Bool), (Family -> Family -> Bool), (Family -> Family -> Bool), (Family -> Family -> Family), (Family -> Family -> Family), (Family -> Family -> _CMP_TAG)] [_DFUN_ Eq (Family), _CONSTM_ Ord (<) (Family), _CONSTM_ Ord (<=) (Family), _CONSTM_ Ord (>=) (Family), _CONSTM_ Ord (>) (Family), _CONSTM_ Ord max (Family), _CONSTM_ Ord min (Family), _CONSTM_ Ord _tagCmp (Family)] _N_
- (<) = _A_ 2 _U_ 11 _N_ _S_ "EE" _N_ _N_,
- (<=) = _A_ 2 _U_ 11 _N_ _S_ "EE" _N_ _N_,
- (>=) = _A_ 2 _U_ 11 _N_ _S_ "EE" _N_ _N_,
- (>) = _A_ 2 _U_ 11 _N_ _S_ "EE" _N_ _N_,
- max = _A_ 2 _U_ 22 _N_ _S_ "EE" _N_ _N_,
- min = _A_ 2 _U_ 22 _N_ _S_ "EE" _N_ _N_,
- _tagCmp = _A_ 2 _U_ 11 _N_ _S_ "EE" _N_ _N_ #-}
+ (<) = { _A_ 2 _U_ 11 _N_ _S_ "EE" _N_ _N_ },
+ (<=) = { _A_ 2 _U_ 11 _N_ _S_ "EE" _N_ _N_ },
+ (>=) = { _A_ 2 _U_ 11 _N_ _S_ "EE" _N_ _N_ },
+ (>) = { _A_ 2 _U_ 11 _N_ _S_ "EE" _N_ _N_ },
+ max = { _A_ 2 _U_ 22 _N_ _S_ "EE" _N_ _N_ },
+ min = { _A_ 2 _U_ 22 _N_ _S_ "EE" _N_ _N_ },
+ _tagCmp = { _A_ 2 _U_ 11 _N_ _S_ "EE" _N_ _N_ } #-}
instance Text Family
{-# GHC_PRAGMA _M_ SocketPrim {-dfun-} _A_ 0 _N_ _N_ _N_ _F_ _IF_ARGS_ 0 0 X 5 _!_ _TUP_4 [(Int -> [Char] -> [(Family, [Char])]), (Int -> Family -> [Char] -> [Char]), ([Char] -> [([Family], [Char])]), ([Family] -> [Char] -> [Char])] [_CONSTM_ Text readsPrec (Family), _CONSTM_ Text showsPrec (Family), _CONSTM_ Text readList (Family), _CONSTM_ Text showList (Family)] _N_
- readsPrec = _A_ 2 _U_ 02 _N_ _S_ "AL" {_A_ 1 _U_ 2 _N_ _N_ _N_ _N_} _N_ _N_,
- showsPrec = _A_ 3 _U_ 012 _N_ _S_ "AEL" {_A_ 2 _U_ 12 _N_ _N_ _N_ _N_} _N_ _N_,
- readList = _A_ 0 _U_ 2 _N_ _N_ _N_ _N_,
- showList = _A_ 0 _U_ 12 _N_ _N_ _N_ _N_ #-}
+ readsPrec = { _A_ 2 _U_ 02 _N_ _S_ "AL" {_A_ 1 _U_ 2 _N_ _N_ _N_ _N_} _N_ _N_ },
+ showsPrec = { _A_ 3 _U_ 012 _N_ _S_ "AEL" {_A_ 2 _U_ 12 _N_ _N_ _N_ _N_} _N_ _N_ },
+ readList = { _A_ 0 _U_ 2 _N_ _N_ _N_ _N_ },
+ showList = { _A_ 1 _U_ 12 _N_ _N_ _F_ _IF_ARGS_ 0 1 X 3 \ (u0 :: [Family]) -> _APP_ _TYAPP_ _ORIG_ PreludeCore _showList { Family } [ _WRKR_ _CONSTM_ Text showsPrec (Family), u0 ] _N_ } #-}
-{-# GHC_PRAGMA INTERFACE VERSION 5 #-}
+{-# GHC_PRAGMA INTERFACE VERSION 6 #-}
interface BSD where
import PreludeIOError(IOError13)
import PreludeMonadicIO(Either)
{-# GHC_PRAGMA _A_ 2 _U_ 12 _N_ _S_ "EL" _N_ _N_ #-}
instance Eq Family
{-# GHC_PRAGMA _M_ SocketPrim {-dfun-} _A_ 0 _N_ _N_ _N_ _F_ _IF_ARGS_ 0 0 X 3 _!_ _TUP_2 [(Family -> Family -> Bool), (Family -> Family -> Bool)] [_CONSTM_ Eq (==) (Family), _CONSTM_ Eq (/=) (Family)] _N_
- (==) = _A_ 2 _U_ 11 _N_ _S_ "EE" _N_ _N_,
- (/=) = _A_ 2 _U_ 11 _N_ _S_ "EE" _N_ _N_ #-}
+ (==) = { _A_ 2 _U_ 11 _N_ _S_ "EE" _N_ _N_ },
+ (/=) = { _A_ 2 _U_ 11 _N_ _S_ "EE" _N_ _N_ } #-}
instance Ix Family
{-# GHC_PRAGMA _M_ SocketPrim {-dfun-} _A_ 0 _N_ _N_ _N_ _F_ _IF_ARGS_ 0 0 X 5 _!_ _TUP_4 [{{Ord Family}}, ((Family, Family) -> [Family]), ((Family, Family) -> Family -> Int), ((Family, Family) -> Family -> Bool)] [_DFUN_ Ord (Family), _CONSTM_ Ix range (Family), _CONSTM_ Ix index (Family), _CONSTM_ Ix inRange (Family)] _N_
- range = _A_ 1 _U_ 1 _N_ _S_ "U(EE)" {_A_ 2 _U_ 11 _N_ _N_ _N_ _N_} _N_ _N_,
- index = _A_ 2 _U_ 12 _N_ _S_ "U(EE)E" {_A_ 3 _U_ 212 _N_ _N_ _N_ _N_} _N_ _N_,
- inRange = _A_ 2 _U_ 11 _N_ _S_ "U(EE)E" {_A_ 3 _U_ 111 _N_ _N_ _N_ _N_} _N_ _N_ #-}
+ range = { _A_ 1 _U_ 1 _N_ _S_ "U(EE)" {_A_ 2 _U_ 11 _N_ _N_ _N_ _N_} _N_ _N_ },
+ index = { _A_ 2 _U_ 12 _N_ _S_ "U(EE)E" {_A_ 3 _U_ 212 _N_ _N_ _N_ _N_} _N_ _N_ },
+ inRange = { _A_ 2 _U_ 11 _N_ _S_ "U(EE)E" {_A_ 3 _U_ 111 _N_ _N_ _N_ _N_} _N_ _N_ } #-}
instance Ord Family
{-# GHC_PRAGMA _M_ SocketPrim {-dfun-} _A_ 0 _N_ _N_ _N_ _F_ _IF_ARGS_ 0 0 X 9 _!_ _TUP_8 [{{Eq Family}}, (Family -> Family -> Bool), (Family -> Family -> Bool), (Family -> Family -> Bool), (Family -> Family -> Bool), (Family -> Family -> Family), (Family -> Family -> Family), (Family -> Family -> _CMP_TAG)] [_DFUN_ Eq (Family), _CONSTM_ Ord (<) (Family), _CONSTM_ Ord (<=) (Family), _CONSTM_ Ord (>=) (Family), _CONSTM_ Ord (>) (Family), _CONSTM_ Ord max (Family), _CONSTM_ Ord min (Family), _CONSTM_ Ord _tagCmp (Family)] _N_
- (<) = _A_ 2 _U_ 11 _N_ _S_ "EE" _N_ _N_,
- (<=) = _A_ 2 _U_ 11 _N_ _S_ "EE" _N_ _N_,
- (>=) = _A_ 2 _U_ 11 _N_ _S_ "EE" _N_ _N_,
- (>) = _A_ 2 _U_ 11 _N_ _S_ "EE" _N_ _N_,
- max = _A_ 2 _U_ 22 _N_ _S_ "EE" _N_ _N_,
- min = _A_ 2 _U_ 22 _N_ _S_ "EE" _N_ _N_,
- _tagCmp = _A_ 2 _U_ 11 _N_ _S_ "EE" _N_ _N_ #-}
+ (<) = { _A_ 2 _U_ 11 _N_ _S_ "EE" _N_ _N_ },
+ (<=) = { _A_ 2 _U_ 11 _N_ _S_ "EE" _N_ _N_ },
+ (>=) = { _A_ 2 _U_ 11 _N_ _S_ "EE" _N_ _N_ },
+ (>) = { _A_ 2 _U_ 11 _N_ _S_ "EE" _N_ _N_ },
+ max = { _A_ 2 _U_ 22 _N_ _S_ "EE" _N_ _N_ },
+ min = { _A_ 2 _U_ 22 _N_ _S_ "EE" _N_ _N_ },
+ _tagCmp = { _A_ 2 _U_ 11 _N_ _S_ "EE" _N_ _N_ } #-}
instance Text Family
{-# GHC_PRAGMA _M_ SocketPrim {-dfun-} _A_ 0 _N_ _N_ _N_ _F_ _IF_ARGS_ 0 0 X 5 _!_ _TUP_4 [(Int -> [Char] -> [(Family, [Char])]), (Int -> Family -> [Char] -> [Char]), ([Char] -> [([Family], [Char])]), ([Family] -> [Char] -> [Char])] [_CONSTM_ Text readsPrec (Family), _CONSTM_ Text showsPrec (Family), _CONSTM_ Text readList (Family), _CONSTM_ Text showList (Family)] _N_
- readsPrec = _A_ 2 _U_ 02 _N_ _S_ "AL" {_A_ 1 _U_ 2 _N_ _N_ _N_ _N_} _N_ _N_,
- showsPrec = _A_ 3 _U_ 012 _N_ _S_ "AEL" {_A_ 2 _U_ 12 _N_ _N_ _N_ _N_} _N_ _N_,
- readList = _A_ 0 _U_ 2 _N_ _N_ _N_ _N_,
- showList = _A_ 0 _U_ 12 _N_ _N_ _N_ _N_ #-}
+ readsPrec = { _A_ 2 _U_ 02 _N_ _S_ "AL" {_A_ 1 _U_ 2 _N_ _N_ _N_ _N_} _N_ _N_ },
+ showsPrec = { _A_ 3 _U_ 012 _N_ _S_ "AEL" {_A_ 2 _U_ 12 _N_ _N_ _N_ _N_} _N_ _N_ },
+ readList = { _A_ 0 _U_ 2 _N_ _N_ _N_ _N_ },
+ showList = { _A_ 1 _U_ 12 _N_ _N_ _F_ _IF_ARGS_ 0 1 X 3 \ (u0 :: [Family]) -> _APP_ _TYAPP_ _ORIG_ PreludeCore _showList { Family } [ _WRKR_ _CONSTM_ Text showsPrec (Family), u0 ] _N_ } #-}
-{-# GHC_PRAGMA INTERFACE VERSION 5 #-}
+{-# GHC_PRAGMA INTERFACE VERSION 6 #-}
interface BSD where
import PreludeIOError(IOError13)
import PreludeMonadicIO(Either)
{-# GHC_PRAGMA _A_ 2 _U_ 12 _N_ _S_ "EL" _N_ _N_ #-}
instance Eq Family
{-# GHC_PRAGMA _M_ SocketPrim {-dfun-} _A_ 0 _N_ _N_ _N_ _F_ _IF_ARGS_ 0 0 X 3 _!_ _TUP_2 [(Family -> Family -> Bool), (Family -> Family -> Bool)] [_CONSTM_ Eq (==) (Family), _CONSTM_ Eq (/=) (Family)] _N_
- (==) = _A_ 2 _U_ 11 _N_ _S_ "EE" _N_ _N_,
- (/=) = _A_ 2 _U_ 11 _N_ _S_ "EE" _N_ _N_ #-}
+ (==) = { _A_ 2 _U_ 11 _N_ _S_ "EE" _N_ _N_ },
+ (/=) = { _A_ 2 _U_ 11 _N_ _S_ "EE" _N_ _N_ } #-}
instance Ix Family
{-# GHC_PRAGMA _M_ SocketPrim {-dfun-} _A_ 0 _N_ _N_ _N_ _F_ _IF_ARGS_ 0 0 X 5 _!_ _TUP_4 [{{Ord Family}}, ((Family, Family) -> [Family]), ((Family, Family) -> Family -> Int), ((Family, Family) -> Family -> Bool)] [_DFUN_ Ord (Family), _CONSTM_ Ix range (Family), _CONSTM_ Ix index (Family), _CONSTM_ Ix inRange (Family)] _N_
- range = _A_ 1 _U_ 1 _N_ _S_ "U(EE)" {_A_ 2 _U_ 11 _N_ _N_ _N_ _N_} _N_ _N_,
- index = _A_ 2 _U_ 12 _N_ _S_ "U(EE)E" {_A_ 3 _U_ 212 _N_ _N_ _N_ _N_} _N_ _N_,
- inRange = _A_ 2 _U_ 11 _N_ _S_ "U(EE)E" {_A_ 3 _U_ 111 _N_ _N_ _N_ _N_} _N_ _N_ #-}
+ range = { _A_ 1 _U_ 1 _N_ _S_ "U(EE)" {_A_ 2 _U_ 11 _N_ _N_ _N_ _N_} _N_ _N_ },
+ index = { _A_ 2 _U_ 12 _N_ _S_ "U(EE)E" {_A_ 3 _U_ 212 _N_ _N_ _N_ _N_} _N_ _N_ },
+ inRange = { _A_ 2 _U_ 11 _N_ _S_ "U(EE)E" {_A_ 3 _U_ 111 _N_ _N_ _N_ _N_} _N_ _N_ } #-}
instance Ord Family
{-# GHC_PRAGMA _M_ SocketPrim {-dfun-} _A_ 0 _N_ _N_ _N_ _F_ _IF_ARGS_ 0 0 X 9 _!_ _TUP_8 [{{Eq Family}}, (Family -> Family -> Bool), (Family -> Family -> Bool), (Family -> Family -> Bool), (Family -> Family -> Bool), (Family -> Family -> Family), (Family -> Family -> Family), (Family -> Family -> _CMP_TAG)] [_DFUN_ Eq (Family), _CONSTM_ Ord (<) (Family), _CONSTM_ Ord (<=) (Family), _CONSTM_ Ord (>=) (Family), _CONSTM_ Ord (>) (Family), _CONSTM_ Ord max (Family), _CONSTM_ Ord min (Family), _CONSTM_ Ord _tagCmp (Family)] _N_
- (<) = _A_ 2 _U_ 11 _N_ _S_ "EE" _N_ _N_,
- (<=) = _A_ 2 _U_ 11 _N_ _S_ "EE" _N_ _N_,
- (>=) = _A_ 2 _U_ 11 _N_ _S_ "EE" _N_ _N_,
- (>) = _A_ 2 _U_ 11 _N_ _S_ "EE" _N_ _N_,
- max = _A_ 2 _U_ 22 _N_ _S_ "EE" _N_ _N_,
- min = _A_ 2 _U_ 22 _N_ _S_ "EE" _N_ _N_,
- _tagCmp = _A_ 2 _U_ 11 _N_ _S_ "EE" _N_ _N_ #-}
+ (<) = { _A_ 2 _U_ 11 _N_ _S_ "EE" _N_ _N_ },
+ (<=) = { _A_ 2 _U_ 11 _N_ _S_ "EE" _N_ _N_ },
+ (>=) = { _A_ 2 _U_ 11 _N_ _S_ "EE" _N_ _N_ },
+ (>) = { _A_ 2 _U_ 11 _N_ _S_ "EE" _N_ _N_ },
+ max = { _A_ 2 _U_ 22 _N_ _S_ "EE" _N_ _N_ },
+ min = { _A_ 2 _U_ 22 _N_ _S_ "EE" _N_ _N_ },
+ _tagCmp = { _A_ 2 _U_ 11 _N_ _S_ "EE" _N_ _N_ } #-}
instance Text Family
{-# GHC_PRAGMA _M_ SocketPrim {-dfun-} _A_ 0 _N_ _N_ _N_ _F_ _IF_ARGS_ 0 0 X 5 _!_ _TUP_4 [(Int -> [Char] -> [(Family, [Char])]), (Int -> Family -> [Char] -> [Char]), ([Char] -> [([Family], [Char])]), ([Family] -> [Char] -> [Char])] [_CONSTM_ Text readsPrec (Family), _CONSTM_ Text showsPrec (Family), _CONSTM_ Text readList (Family), _CONSTM_ Text showList (Family)] _N_
- readsPrec = _A_ 2 _U_ 02 _N_ _S_ "AL" {_A_ 1 _U_ 2 _N_ _N_ _N_ _N_} _N_ _N_,
- showsPrec = _A_ 3 _U_ 012 _N_ _S_ "AEL" {_A_ 2 _U_ 12 _N_ _N_ _N_ _N_} _N_ _N_,
- readList = _A_ 0 _U_ 2 _N_ _N_ _N_ _N_,
- showList = _A_ 0 _U_ 12 _N_ _N_ _N_ _N_ #-}
+ readsPrec = { _A_ 2 _U_ 02 _N_ _S_ "AL" {_A_ 1 _U_ 2 _N_ _N_ _N_ _N_} _N_ _N_ },
+ showsPrec = { _A_ 3 _U_ 012 _N_ _S_ "AEL" {_A_ 2 _U_ 12 _N_ _N_ _N_ _N_} _N_ _N_ },
+ readList = { _A_ 0 _U_ 2 _N_ _N_ _N_ _N_ },
+ showList = { _A_ 1 _U_ 12 _N_ _N_ _F_ _IF_ARGS_ 0 1 X 3 \ (u0 :: [Family]) -> _APP_ _TYAPP_ _ORIG_ PreludeCore _showList { Family } [ _WRKR_ _CONSTM_ Text showsPrec (Family), u0 ] _N_ } #-}
-{-# GHC_PRAGMA INTERFACE VERSION 5 #-}
+{-# GHC_PRAGMA INTERFACE VERSION 6 #-}
interface CError where
data CErrorCode
= NOERROR | EPERM | ENOENT | ESRCH | EINTR | EIO | ENXIO | E2BIG | ENOEXEC | EBADF | ECHILD | EAGAIN | ENOMEM | EACCES | EFAULT | ENOTBLK | EBUSY | EEXIST | EXDEV | ENODEV | ENOTDIR | EISDIR | EINVAL | ENFILE | EMFILE | ENOTTY | ETXTBSY | EFBIG | ENOSPC | ESPIPE | EROFS | EMLINK | EPIPE | EDOM | ERANGE | EWOULDBLOCK | EINPROGRESS | EALREADY | ENOTSOCK | EDESTADDRREQ | EMSGSIZE | EPROTOTYPE | ENOPROTOOPT | EPROTONOSUPPOR | ESOCKTNOSUPPORT | EOPNOTSUPP | EPFNOSUPPORT | EAFNOSUPPORT | EADDRINUSE | EADDRNOTAVAIL | ENETDOWN | ENETUNREACH | ENETRESET | ECONNABORTED | ECONNRESET | ENOBUFS | EISCONN | ENOTCONN | ESHUTDOWN | ETOOMANYREFS | ETIMEDOUT | ECONNREFUSED | ELOOP | ENAMETOOLONG | EHOSTDOWN | EHOSTUNREACH | ENOTEMPTY | EPROCLIM | EUSERS | EDQUOT | ESTALE | EREMOTE | ENOSTR | ETIME | ENOSR | ENOMSG | EBADMSG | EIDRM | EDEADLK | ENOLCK | ENONET | ERREMOTE | ENOLINK | EADV | ESRMNT | ECOMM | EPROTO | EMULTIHOP | EDOTDOT | EREMCHG | ENOSYS
{-# GHC_PRAGMA _A_ 2 _U_ 21 _N_ _S_ "EU(P)" {_A_ 2 _U_ 22 _N_ _N_ _N_ _N_} _N_ _N_ #-}
instance Eq CErrorCode
{-# GHC_PRAGMA _M_ CError {-dfun-} _A_ 0 _N_ _N_ _N_ _F_ _IF_ARGS_ 0 0 X 3 _!_ _TUP_2 [(CErrorCode -> CErrorCode -> Bool), (CErrorCode -> CErrorCode -> Bool)] [_CONSTM_ Eq (==) (CErrorCode), _CONSTM_ Eq (/=) (CErrorCode)] _N_
- (==) = _A_ 2 _U_ 11 _N_ _S_ "EE" _N_ _N_,
- (/=) = _A_ 2 _U_ 11 _N_ _S_ "EE" _N_ _N_ #-}
+ (==) = { _A_ 2 _U_ 11 _N_ _S_ "EE" _N_ _N_ },
+ (/=) = { _A_ 2 _U_ 11 _N_ _S_ "EE" _N_ _N_ } #-}
instance Ix CErrorCode
{-# GHC_PRAGMA _M_ CError {-dfun-} _A_ 0 _N_ _N_ _N_ _F_ _IF_ARGS_ 0 0 X 5 _!_ _TUP_4 [{{Ord CErrorCode}}, ((CErrorCode, CErrorCode) -> [CErrorCode]), ((CErrorCode, CErrorCode) -> CErrorCode -> Int), ((CErrorCode, CErrorCode) -> CErrorCode -> Bool)] [_DFUN_ Ord (CErrorCode), _CONSTM_ Ix range (CErrorCode), _CONSTM_ Ix index (CErrorCode), _CONSTM_ Ix inRange (CErrorCode)] _N_
- range = _A_ 1 _U_ 1 _N_ _S_ "U(EE)" {_A_ 2 _U_ 11 _N_ _N_ _N_ _N_} _N_ _N_,
- index = _A_ 2 _U_ 12 _N_ _S_ "U(EE)E" {_A_ 3 _U_ 212 _N_ _N_ _N_ _N_} _N_ _N_,
- inRange = _A_ 2 _U_ 11 _N_ _S_ "U(EE)E" {_A_ 3 _U_ 111 _N_ _N_ _N_ _N_} _N_ _N_ #-}
+ range = { _A_ 1 _U_ 1 _N_ _S_ "U(EE)" {_A_ 2 _U_ 11 _N_ _N_ _N_ _N_} _N_ _N_ },
+ index = { _A_ 2 _U_ 12 _N_ _S_ "U(EE)E" {_A_ 3 _U_ 212 _N_ _N_ _N_ _N_} _N_ _N_ },
+ inRange = { _A_ 2 _U_ 11 _N_ _S_ "U(EE)E" {_A_ 3 _U_ 111 _N_ _N_ _N_ _N_} _N_ _N_ } #-}
instance Ord CErrorCode
{-# GHC_PRAGMA _M_ CError {-dfun-} _A_ 0 _N_ _N_ _N_ _F_ _IF_ARGS_ 0 0 X 9 _!_ _TUP_8 [{{Eq CErrorCode}}, (CErrorCode -> CErrorCode -> Bool), (CErrorCode -> CErrorCode -> Bool), (CErrorCode -> CErrorCode -> Bool), (CErrorCode -> CErrorCode -> Bool), (CErrorCode -> CErrorCode -> CErrorCode), (CErrorCode -> CErrorCode -> CErrorCode), (CErrorCode -> CErrorCode -> _CMP_TAG)] [_DFUN_ Eq (CErrorCode), _CONSTM_ Ord (<) (CErrorCode), _CONSTM_ Ord (<=) (CErrorCode), _CONSTM_ Ord (>=) (CErrorCode), _CONSTM_ Ord (>) (CErrorCode), _CONSTM_ Ord max (CErrorCode), _CONSTM_ Ord min (CErrorCode), _CONSTM_ Ord _tagCmp (CErrorCode)] _N_
- (<) = _A_ 2 _U_ 11 _N_ _S_ "EE" _N_ _N_,
- (<=) = _A_ 2 _U_ 11 _N_ _S_ "EE" _N_ _N_,
- (>=) = _A_ 2 _U_ 11 _N_ _S_ "EE" _N_ _N_,
- (>) = _A_ 2 _U_ 11 _N_ _S_ "EE" _N_ _N_,
- max = _A_ 2 _U_ 22 _N_ _S_ "EE" _N_ _N_,
- min = _A_ 2 _U_ 22 _N_ _S_ "EE" _N_ _N_,
- _tagCmp = _A_ 2 _U_ 11 _N_ _S_ "EE" _N_ _N_ #-}
+ (<) = { _A_ 2 _U_ 11 _N_ _S_ "EE" _N_ _N_ },
+ (<=) = { _A_ 2 _U_ 11 _N_ _S_ "EE" _N_ _N_ },
+ (>=) = { _A_ 2 _U_ 11 _N_ _S_ "EE" _N_ _N_ },
+ (>) = { _A_ 2 _U_ 11 _N_ _S_ "EE" _N_ _N_ },
+ max = { _A_ 2 _U_ 22 _N_ _S_ "EE" _N_ _N_ },
+ min = { _A_ 2 _U_ 22 _N_ _S_ "EE" _N_ _N_ },
+ _tagCmp = { _A_ 2 _U_ 11 _N_ _S_ "EE" _N_ _N_ } #-}
instance Text CErrorCode
{-# GHC_PRAGMA _M_ CError {-dfun-} _A_ 0 _N_ _N_ _N_ _F_ _IF_ARGS_ 0 0 X 5 _!_ _TUP_4 [(Int -> [Char] -> [(CErrorCode, [Char])]), (Int -> CErrorCode -> [Char] -> [Char]), ([Char] -> [([CErrorCode], [Char])]), ([CErrorCode] -> [Char] -> [Char])] [_CONSTM_ Text readsPrec (CErrorCode), _CONSTM_ Text showsPrec (CErrorCode), _CONSTM_ Text readList (CErrorCode), _CONSTM_ Text showList (CErrorCode)] _N_
- readsPrec = _A_ 2 _U_ 22 _N_ _S_ _!_ _F_ _IF_ARGS_ 0 2 XX 4 \ (u0 :: Int) (u1 :: [Char]) -> _APP_ _TYAPP_ patError# { (Int -> [Char] -> [(CErrorCode, [Char])]) } [ _NOREP_S_ "%DPreludeCore.Text.readsPrec\"", u0, u1 ] _N_,
- showsPrec = _A_ 3 _U_ 012 _N_ _S_ "AEL" {_A_ 2 _U_ 12 _N_ _N_ _N_ _N_} _N_ _N_,
- readList = _A_ 0 _U_ 2 _N_ _N_ _N_ _N_,
- showList = _A_ 0 _U_ 12 _N_ _N_ _N_ _N_ #-}
+ readsPrec = { _A_ 2 _U_ 22 _N_ _S_ _!_ _N_ _N_ },
+ showsPrec = { _A_ 3 _U_ 012 _N_ _S_ "AEL" {_A_ 2 _U_ 12 _N_ _N_ _N_ _N_} _N_ _N_ },
+ readList = { _A_ 1 _U_ 2 _N_ _S_ _!_ _N_ _N_ },
+ showList = { _A_ 1 _U_ 12 _N_ _N_ _F_ _IF_ARGS_ 0 1 X 3 \ (u0 :: [CErrorCode]) -> _APP_ _TYAPP_ _ORIG_ PreludeCore _showList { CErrorCode } [ _WRKR_ _CONSTM_ Text showsPrec (CErrorCode), u0 ] _N_ } #-}
-{-# GHC_PRAGMA INTERFACE VERSION 5 #-}
+{-# GHC_PRAGMA INTERFACE VERSION 6 #-}
interface CError where
data CErrorCode
= NOERROR | EPERM | ENOENT | ESRCH | EINTR | EIO | ENXIO | E2BIG | ENOEXEC | EBADF | ECHILD | EAGAIN | ENOMEM | EACCES | EFAULT | ENOTBLK | EBUSY | EEXIST | EXDEV | ENODEV | ENOTDIR | EISDIR | EINVAL | ENFILE | EMFILE | ENOTTY | ETXTBSY | EFBIG | ENOSPC | ESPIPE | EROFS | EMLINK | EPIPE | EDOM | ERANGE | EWOULDBLOCK | EINPROGRESS | EALREADY | ENOTSOCK | EDESTADDRREQ | EMSGSIZE | EPROTOTYPE | ENOPROTOOPT | EPROTONOSUPPOR | ESOCKTNOSUPPORT | EOPNOTSUPP | EPFNOSUPPORT | EAFNOSUPPORT | EADDRINUSE | EADDRNOTAVAIL | ENETDOWN | ENETUNREACH | ENETRESET | ECONNABORTED | ECONNRESET | ENOBUFS | EISCONN | ENOTCONN | ESHUTDOWN | ETOOMANYREFS | ETIMEDOUT | ECONNREFUSED | ELOOP | ENAMETOOLONG | EHOSTDOWN | EHOSTUNREACH | ENOTEMPTY | EPROCLIM | EUSERS | EDQUOT | ESTALE | EREMOTE | ENOSTR | ETIME | ENOSR | ENOMSG | EBADMSG | EIDRM | EDEADLK | ENOLCK | ENONET | ERREMOTE | ENOLINK | EADV | ESRMNT | ECOMM | EPROTO | EMULTIHOP | EDOTDOT | EREMCHG | ENOSYS
{-# GHC_PRAGMA _A_ 2 _U_ 21 _N_ _S_ "EU(P)" {_A_ 2 _U_ 22 _N_ _N_ _N_ _N_} _N_ _N_ #-}
instance Eq CErrorCode
{-# GHC_PRAGMA _M_ CError {-dfun-} _A_ 0 _N_ _N_ _N_ _F_ _IF_ARGS_ 0 0 X 3 _!_ _TUP_2 [(CErrorCode -> CErrorCode -> Bool), (CErrorCode -> CErrorCode -> Bool)] [_CONSTM_ Eq (==) (CErrorCode), _CONSTM_ Eq (/=) (CErrorCode)] _N_
- (==) = _A_ 2 _U_ 11 _N_ _S_ "EE" _N_ _N_,
- (/=) = _A_ 2 _U_ 11 _N_ _S_ "EE" _N_ _N_ #-}
+ (==) = { _A_ 2 _U_ 11 _N_ _S_ "EE" _N_ _N_ },
+ (/=) = { _A_ 2 _U_ 11 _N_ _S_ "EE" _N_ _N_ } #-}
instance Ix CErrorCode
{-# GHC_PRAGMA _M_ CError {-dfun-} _A_ 0 _N_ _N_ _N_ _F_ _IF_ARGS_ 0 0 X 5 _!_ _TUP_4 [{{Ord CErrorCode}}, ((CErrorCode, CErrorCode) -> [CErrorCode]), ((CErrorCode, CErrorCode) -> CErrorCode -> Int), ((CErrorCode, CErrorCode) -> CErrorCode -> Bool)] [_DFUN_ Ord (CErrorCode), _CONSTM_ Ix range (CErrorCode), _CONSTM_ Ix index (CErrorCode), _CONSTM_ Ix inRange (CErrorCode)] _N_
- range = _A_ 1 _U_ 1 _N_ _S_ "U(EE)" {_A_ 2 _U_ 11 _N_ _N_ _N_ _N_} _N_ _N_,
- index = _A_ 2 _U_ 12 _N_ _S_ "U(EE)E" {_A_ 3 _U_ 212 _N_ _N_ _N_ _N_} _N_ _N_,
- inRange = _A_ 2 _U_ 11 _N_ _S_ "U(EE)E" {_A_ 3 _U_ 111 _N_ _N_ _N_ _N_} _N_ _N_ #-}
+ range = { _A_ 1 _U_ 1 _N_ _S_ "U(EE)" {_A_ 2 _U_ 11 _N_ _N_ _N_ _N_} _N_ _N_ },
+ index = { _A_ 2 _U_ 12 _N_ _S_ "U(EE)E" {_A_ 3 _U_ 212 _N_ _N_ _N_ _N_} _N_ _N_ },
+ inRange = { _A_ 2 _U_ 11 _N_ _S_ "U(EE)E" {_A_ 3 _U_ 111 _N_ _N_ _N_ _N_} _N_ _N_ } #-}
instance Ord CErrorCode
{-# GHC_PRAGMA _M_ CError {-dfun-} _A_ 0 _N_ _N_ _N_ _F_ _IF_ARGS_ 0 0 X 9 _!_ _TUP_8 [{{Eq CErrorCode}}, (CErrorCode -> CErrorCode -> Bool), (CErrorCode -> CErrorCode -> Bool), (CErrorCode -> CErrorCode -> Bool), (CErrorCode -> CErrorCode -> Bool), (CErrorCode -> CErrorCode -> CErrorCode), (CErrorCode -> CErrorCode -> CErrorCode), (CErrorCode -> CErrorCode -> _CMP_TAG)] [_DFUN_ Eq (CErrorCode), _CONSTM_ Ord (<) (CErrorCode), _CONSTM_ Ord (<=) (CErrorCode), _CONSTM_ Ord (>=) (CErrorCode), _CONSTM_ Ord (>) (CErrorCode), _CONSTM_ Ord max (CErrorCode), _CONSTM_ Ord min (CErrorCode), _CONSTM_ Ord _tagCmp (CErrorCode)] _N_
- (<) = _A_ 2 _U_ 11 _N_ _S_ "EE" _N_ _N_,
- (<=) = _A_ 2 _U_ 11 _N_ _S_ "EE" _N_ _N_,
- (>=) = _A_ 2 _U_ 11 _N_ _S_ "EE" _N_ _N_,
- (>) = _A_ 2 _U_ 11 _N_ _S_ "EE" _N_ _N_,
- max = _A_ 2 _U_ 22 _N_ _S_ "EE" _N_ _N_,
- min = _A_ 2 _U_ 22 _N_ _S_ "EE" _N_ _N_,
- _tagCmp = _A_ 2 _U_ 11 _N_ _S_ "EE" _N_ _N_ #-}
+ (<) = { _A_ 2 _U_ 11 _N_ _S_ "EE" _N_ _N_ },
+ (<=) = { _A_ 2 _U_ 11 _N_ _S_ "EE" _N_ _N_ },
+ (>=) = { _A_ 2 _U_ 11 _N_ _S_ "EE" _N_ _N_ },
+ (>) = { _A_ 2 _U_ 11 _N_ _S_ "EE" _N_ _N_ },
+ max = { _A_ 2 _U_ 22 _N_ _S_ "EE" _N_ _N_ },
+ min = { _A_ 2 _U_ 22 _N_ _S_ "EE" _N_ _N_ },
+ _tagCmp = { _A_ 2 _U_ 11 _N_ _S_ "EE" _N_ _N_ } #-}
instance Text CErrorCode
{-# GHC_PRAGMA _M_ CError {-dfun-} _A_ 0 _N_ _N_ _N_ _F_ _IF_ARGS_ 0 0 X 5 _!_ _TUP_4 [(Int -> [Char] -> [(CErrorCode, [Char])]), (Int -> CErrorCode -> [Char] -> [Char]), ([Char] -> [([CErrorCode], [Char])]), ([CErrorCode] -> [Char] -> [Char])] [_CONSTM_ Text readsPrec (CErrorCode), _CONSTM_ Text showsPrec (CErrorCode), _CONSTM_ Text readList (CErrorCode), _CONSTM_ Text showList (CErrorCode)] _N_
- readsPrec = _A_ 2 _U_ 22 _N_ _S_ _!_ _F_ _IF_ARGS_ 0 2 XX 4 \ (u0 :: Int) (u1 :: [Char]) -> _APP_ _TYAPP_ patError# { (Int -> [Char] -> [(CErrorCode, [Char])]) } [ _NOREP_S_ "%DPreludeCore.Text.readsPrec\"", u0, u1 ] _N_,
- showsPrec = _A_ 3 _U_ 012 _N_ _S_ "AEL" {_A_ 2 _U_ 12 _N_ _N_ _N_ _N_} _N_ _N_,
- readList = _A_ 0 _U_ 2 _N_ _N_ _N_ _N_,
- showList = _A_ 0 _U_ 12 _N_ _N_ _N_ _N_ #-}
+ readsPrec = { _A_ 2 _U_ 22 _N_ _S_ _!_ _N_ _N_ },
+ showsPrec = { _A_ 3 _U_ 012 _N_ _S_ "AEL" {_A_ 2 _U_ 12 _N_ _N_ _N_ _N_} _N_ _N_ },
+ readList = { _A_ 1 _U_ 2 _N_ _S_ _!_ _N_ _N_ },
+ showList = { _A_ 1 _U_ 12 _N_ _N_ _F_ _IF_ARGS_ 0 1 X 3 \ (u0 :: [CErrorCode]) -> _APP_ _TYAPP_ _ORIG_ PreludeCore _showList { CErrorCode } [ _WRKR_ _CONSTM_ Text showsPrec (CErrorCode), u0 ] _N_ } #-}
-{-# GHC_PRAGMA INTERFACE VERSION 5 #-}
+{-# GHC_PRAGMA INTERFACE VERSION 6 #-}
interface CError where
data CErrorCode
= NOERROR | EPERM | ENOENT | ESRCH | EINTR | EIO | ENXIO | E2BIG | ENOEXEC | EBADF | ECHILD | EAGAIN | ENOMEM | EACCES | EFAULT | ENOTBLK | EBUSY | EEXIST | EXDEV | ENODEV | ENOTDIR | EISDIR | EINVAL | ENFILE | EMFILE | ENOTTY | ETXTBSY | EFBIG | ENOSPC | ESPIPE | EROFS | EMLINK | EPIPE | EDOM | ERANGE | EWOULDBLOCK | EINPROGRESS | EALREADY | ENOTSOCK | EDESTADDRREQ | EMSGSIZE | EPROTOTYPE | ENOPROTOOPT | EPROTONOSUPPOR | ESOCKTNOSUPPORT | EOPNOTSUPP | EPFNOSUPPORT | EAFNOSUPPORT | EADDRINUSE | EADDRNOTAVAIL | ENETDOWN | ENETUNREACH | ENETRESET | ECONNABORTED | ECONNRESET | ENOBUFS | EISCONN | ENOTCONN | ESHUTDOWN | ETOOMANYREFS | ETIMEDOUT | ECONNREFUSED | ELOOP | ENAMETOOLONG | EHOSTDOWN | EHOSTUNREACH | ENOTEMPTY | EPROCLIM | EUSERS | EDQUOT | ESTALE | EREMOTE | ENOSTR | ETIME | ENOSR | ENOMSG | EBADMSG | EIDRM | EDEADLK | ENOLCK | ENONET | ERREMOTE | ENOLINK | EADV | ESRMNT | ECOMM | EPROTO | EMULTIHOP | EDOTDOT | EREMCHG | ENOSYS
{-# GHC_PRAGMA _A_ 2 _U_ 21 _N_ _S_ "EU(P)" {_A_ 2 _U_ 22 _N_ _N_ _N_ _N_} _N_ _N_ #-}
instance Eq CErrorCode
{-# GHC_PRAGMA _M_ CError {-dfun-} _A_ 0 _N_ _N_ _N_ _F_ _IF_ARGS_ 0 0 X 3 _!_ _TUP_2 [(CErrorCode -> CErrorCode -> Bool), (CErrorCode -> CErrorCode -> Bool)] [_CONSTM_ Eq (==) (CErrorCode), _CONSTM_ Eq (/=) (CErrorCode)] _N_
- (==) = _A_ 2 _U_ 11 _N_ _S_ "EE" _N_ _N_,
- (/=) = _A_ 2 _U_ 11 _N_ _S_ "EE" _N_ _N_ #-}
+ (==) = { _A_ 2 _U_ 11 _N_ _S_ "EE" _N_ _N_ },
+ (/=) = { _A_ 2 _U_ 11 _N_ _S_ "EE" _N_ _N_ } #-}
instance Ix CErrorCode
{-# GHC_PRAGMA _M_ CError {-dfun-} _A_ 0 _N_ _N_ _N_ _F_ _IF_ARGS_ 0 0 X 5 _!_ _TUP_4 [{{Ord CErrorCode}}, ((CErrorCode, CErrorCode) -> [CErrorCode]), ((CErrorCode, CErrorCode) -> CErrorCode -> Int), ((CErrorCode, CErrorCode) -> CErrorCode -> Bool)] [_DFUN_ Ord (CErrorCode), _CONSTM_ Ix range (CErrorCode), _CONSTM_ Ix index (CErrorCode), _CONSTM_ Ix inRange (CErrorCode)] _N_
- range = _A_ 1 _U_ 1 _N_ _S_ "U(EE)" {_A_ 2 _U_ 11 _N_ _N_ _N_ _N_} _N_ _N_,
- index = _A_ 2 _U_ 12 _N_ _S_ "U(EE)E" {_A_ 3 _U_ 212 _N_ _N_ _N_ _N_} _N_ _N_,
- inRange = _A_ 2 _U_ 11 _N_ _S_ "U(EE)E" {_A_ 3 _U_ 111 _N_ _N_ _N_ _N_} _N_ _N_ #-}
+ range = { _A_ 1 _U_ 1 _N_ _S_ "U(EE)" {_A_ 2 _U_ 11 _N_ _N_ _N_ _N_} _N_ _N_ },
+ index = { _A_ 2 _U_ 12 _N_ _S_ "U(EE)E" {_A_ 3 _U_ 212 _N_ _N_ _N_ _N_} _N_ _N_ },
+ inRange = { _A_ 2 _U_ 11 _N_ _S_ "U(EE)E" {_A_ 3 _U_ 111 _N_ _N_ _N_ _N_} _N_ _N_ } #-}
instance Ord CErrorCode
{-# GHC_PRAGMA _M_ CError {-dfun-} _A_ 0 _N_ _N_ _N_ _F_ _IF_ARGS_ 0 0 X 9 _!_ _TUP_8 [{{Eq CErrorCode}}, (CErrorCode -> CErrorCode -> Bool), (CErrorCode -> CErrorCode -> Bool), (CErrorCode -> CErrorCode -> Bool), (CErrorCode -> CErrorCode -> Bool), (CErrorCode -> CErrorCode -> CErrorCode), (CErrorCode -> CErrorCode -> CErrorCode), (CErrorCode -> CErrorCode -> _CMP_TAG)] [_DFUN_ Eq (CErrorCode), _CONSTM_ Ord (<) (CErrorCode), _CONSTM_ Ord (<=) (CErrorCode), _CONSTM_ Ord (>=) (CErrorCode), _CONSTM_ Ord (>) (CErrorCode), _CONSTM_ Ord max (CErrorCode), _CONSTM_ Ord min (CErrorCode), _CONSTM_ Ord _tagCmp (CErrorCode)] _N_
- (<) = _A_ 2 _U_ 11 _N_ _S_ "EE" _N_ _N_,
- (<=) = _A_ 2 _U_ 11 _N_ _S_ "EE" _N_ _N_,
- (>=) = _A_ 2 _U_ 11 _N_ _S_ "EE" _N_ _N_,
- (>) = _A_ 2 _U_ 11 _N_ _S_ "EE" _N_ _N_,
- max = _A_ 2 _U_ 22 _N_ _S_ "EE" _N_ _N_,
- min = _A_ 2 _U_ 22 _N_ _S_ "EE" _N_ _N_,
- _tagCmp = _A_ 2 _U_ 11 _N_ _S_ "EE" _N_ _N_ #-}
+ (<) = { _A_ 2 _U_ 11 _N_ _S_ "EE" _N_ _N_ },
+ (<=) = { _A_ 2 _U_ 11 _N_ _S_ "EE" _N_ _N_ },
+ (>=) = { _A_ 2 _U_ 11 _N_ _S_ "EE" _N_ _N_ },
+ (>) = { _A_ 2 _U_ 11 _N_ _S_ "EE" _N_ _N_ },
+ max = { _A_ 2 _U_ 22 _N_ _S_ "EE" _N_ _N_ },
+ min = { _A_ 2 _U_ 22 _N_ _S_ "EE" _N_ _N_ },
+ _tagCmp = { _A_ 2 _U_ 11 _N_ _S_ "EE" _N_ _N_ } #-}
instance Text CErrorCode
{-# GHC_PRAGMA _M_ CError {-dfun-} _A_ 0 _N_ _N_ _N_ _F_ _IF_ARGS_ 0 0 X 5 _!_ _TUP_4 [(Int -> [Char] -> [(CErrorCode, [Char])]), (Int -> CErrorCode -> [Char] -> [Char]), ([Char] -> [([CErrorCode], [Char])]), ([CErrorCode] -> [Char] -> [Char])] [_CONSTM_ Text readsPrec (CErrorCode), _CONSTM_ Text showsPrec (CErrorCode), _CONSTM_ Text readList (CErrorCode), _CONSTM_ Text showList (CErrorCode)] _N_
- readsPrec = _A_ 2 _U_ 22 _N_ _S_ _!_ _F_ _IF_ARGS_ 0 2 XX 4 \ (u0 :: Int) (u1 :: [Char]) -> _APP_ _TYAPP_ patError# { (Int -> [Char] -> [(CErrorCode, [Char])]) } [ _NOREP_S_ "%DPreludeCore.Text.readsPrec\"", u0, u1 ] _N_,
- showsPrec = _A_ 3 _U_ 012 _N_ _S_ "AEL" {_A_ 2 _U_ 12 _N_ _N_ _N_ _N_} _N_ _N_,
- readList = _A_ 0 _U_ 2 _N_ _N_ _N_ _N_,
- showList = _A_ 0 _U_ 12 _N_ _N_ _N_ _N_ #-}
+ readsPrec = { _A_ 2 _U_ 22 _N_ _S_ _!_ _N_ _N_ },
+ showsPrec = { _A_ 3 _U_ 012 _N_ _S_ "AEL" {_A_ 2 _U_ 12 _N_ _N_ _N_ _N_} _N_ _N_ },
+ readList = { _A_ 1 _U_ 2 _N_ _S_ _!_ _N_ _N_ },
+ showList = { _A_ 1 _U_ 12 _N_ _N_ _F_ _IF_ARGS_ 0 1 X 3 \ (u0 :: [CErrorCode]) -> _APP_ _TYAPP_ _ORIG_ PreludeCore _showList { CErrorCode } [ _WRKR_ _CONSTM_ Text showsPrec (CErrorCode), u0 ] _N_ } #-}
-{-# GHC_PRAGMA INTERFACE VERSION 5 #-}
+{-# GHC_PRAGMA INTERFACE VERSION 6 #-}
interface CError where
data CErrorCode
= NOERROR | EPERM | ENOENT | ESRCH | EINTR | EIO | ENXIO | E2BIG | ENOEXEC | EBADF | ECHILD | EAGAIN | ENOMEM | EACCES | EFAULT | ENOTBLK | EBUSY | EEXIST | EXDEV | ENODEV | ENOTDIR | EISDIR | EINVAL | ENFILE | EMFILE | ENOTTY | ETXTBSY | EFBIG | ENOSPC | ESPIPE | EROFS | EMLINK | EPIPE | EDOM | ERANGE | EWOULDBLOCK | EINPROGRESS | EALREADY | ENOTSOCK | EDESTADDRREQ | EMSGSIZE | EPROTOTYPE | ENOPROTOOPT | EPROTONOSUPPOR | ESOCKTNOSUPPORT | EOPNOTSUPP | EPFNOSUPPORT | EAFNOSUPPORT | EADDRINUSE | EADDRNOTAVAIL | ENETDOWN | ENETUNREACH | ENETRESET | ECONNABORTED | ECONNRESET | ENOBUFS | EISCONN | ENOTCONN | ESHUTDOWN | ETOOMANYREFS | ETIMEDOUT | ECONNREFUSED | ELOOP | ENAMETOOLONG | EHOSTDOWN | EHOSTUNREACH | ENOTEMPTY | EPROCLIM | EUSERS | EDQUOT | ESTALE | EREMOTE | ENOSTR | ETIME | ENOSR | ENOMSG | EBADMSG | EIDRM | EDEADLK | ENOLCK | ENONET | ERREMOTE | ENOLINK | EADV | ESRMNT | ECOMM | EPROTO | EMULTIHOP | EDOTDOT | EREMCHG | ENOSYS
{-# GHC_PRAGMA _A_ 2 _U_ 21 _N_ _S_ "EU(P)" {_A_ 2 _U_ 22 _N_ _N_ _N_ _N_} _N_ _N_ #-}
instance Eq CErrorCode
{-# GHC_PRAGMA _M_ CError {-dfun-} _A_ 0 _N_ _N_ _N_ _F_ _IF_ARGS_ 0 0 X 3 _!_ _TUP_2 [(CErrorCode -> CErrorCode -> Bool), (CErrorCode -> CErrorCode -> Bool)] [_CONSTM_ Eq (==) (CErrorCode), _CONSTM_ Eq (/=) (CErrorCode)] _N_
- (==) = _A_ 2 _U_ 11 _N_ _S_ "EE" _N_ _N_,
- (/=) = _A_ 2 _U_ 11 _N_ _S_ "EE" _N_ _N_ #-}
+ (==) = { _A_ 2 _U_ 11 _N_ _S_ "EE" _N_ _N_ },
+ (/=) = { _A_ 2 _U_ 11 _N_ _S_ "EE" _N_ _N_ } #-}
instance Ix CErrorCode
{-# GHC_PRAGMA _M_ CError {-dfun-} _A_ 0 _N_ _N_ _N_ _F_ _IF_ARGS_ 0 0 X 5 _!_ _TUP_4 [{{Ord CErrorCode}}, ((CErrorCode, CErrorCode) -> [CErrorCode]), ((CErrorCode, CErrorCode) -> CErrorCode -> Int), ((CErrorCode, CErrorCode) -> CErrorCode -> Bool)] [_DFUN_ Ord (CErrorCode), _CONSTM_ Ix range (CErrorCode), _CONSTM_ Ix index (CErrorCode), _CONSTM_ Ix inRange (CErrorCode)] _N_
- range = _A_ 1 _U_ 1 _N_ _S_ "U(EE)" {_A_ 2 _U_ 11 _N_ _N_ _N_ _N_} _N_ _N_,
- index = _A_ 2 _U_ 12 _N_ _S_ "U(EE)E" {_A_ 3 _U_ 212 _N_ _N_ _N_ _N_} _N_ _N_,
- inRange = _A_ 2 _U_ 11 _N_ _S_ "U(EE)E" {_A_ 3 _U_ 111 _N_ _N_ _N_ _N_} _N_ _N_ #-}
+ range = { _A_ 1 _U_ 1 _N_ _S_ "U(EE)" {_A_ 2 _U_ 11 _N_ _N_ _N_ _N_} _N_ _N_ },
+ index = { _A_ 2 _U_ 12 _N_ _S_ "U(EE)E" {_A_ 3 _U_ 212 _N_ _N_ _N_ _N_} _N_ _N_ },
+ inRange = { _A_ 2 _U_ 11 _N_ _S_ "U(EE)E" {_A_ 3 _U_ 111 _N_ _N_ _N_ _N_} _N_ _N_ } #-}
instance Ord CErrorCode
{-# GHC_PRAGMA _M_ CError {-dfun-} _A_ 0 _N_ _N_ _N_ _F_ _IF_ARGS_ 0 0 X 9 _!_ _TUP_8 [{{Eq CErrorCode}}, (CErrorCode -> CErrorCode -> Bool), (CErrorCode -> CErrorCode -> Bool), (CErrorCode -> CErrorCode -> Bool), (CErrorCode -> CErrorCode -> Bool), (CErrorCode -> CErrorCode -> CErrorCode), (CErrorCode -> CErrorCode -> CErrorCode), (CErrorCode -> CErrorCode -> _CMP_TAG)] [_DFUN_ Eq (CErrorCode), _CONSTM_ Ord (<) (CErrorCode), _CONSTM_ Ord (<=) (CErrorCode), _CONSTM_ Ord (>=) (CErrorCode), _CONSTM_ Ord (>) (CErrorCode), _CONSTM_ Ord max (CErrorCode), _CONSTM_ Ord min (CErrorCode), _CONSTM_ Ord _tagCmp (CErrorCode)] _N_
- (<) = _A_ 2 _U_ 11 _N_ _S_ "EE" _N_ _N_,
- (<=) = _A_ 2 _U_ 11 _N_ _S_ "EE" _N_ _N_,
- (>=) = _A_ 2 _U_ 11 _N_ _S_ "EE" _N_ _N_,
- (>) = _A_ 2 _U_ 11 _N_ _S_ "EE" _N_ _N_,
- max = _A_ 2 _U_ 22 _N_ _S_ "EE" _N_ _N_,
- min = _A_ 2 _U_ 22 _N_ _S_ "EE" _N_ _N_,
- _tagCmp = _A_ 2 _U_ 11 _N_ _S_ "EE" _N_ _N_ #-}
+ (<) = { _A_ 2 _U_ 11 _N_ _S_ "EE" _N_ _N_ },
+ (<=) = { _A_ 2 _U_ 11 _N_ _S_ "EE" _N_ _N_ },
+ (>=) = { _A_ 2 _U_ 11 _N_ _S_ "EE" _N_ _N_ },
+ (>) = { _A_ 2 _U_ 11 _N_ _S_ "EE" _N_ _N_ },
+ max = { _A_ 2 _U_ 22 _N_ _S_ "EE" _N_ _N_ },
+ min = { _A_ 2 _U_ 22 _N_ _S_ "EE" _N_ _N_ },
+ _tagCmp = { _A_ 2 _U_ 11 _N_ _S_ "EE" _N_ _N_ } #-}
instance Text CErrorCode
{-# GHC_PRAGMA _M_ CError {-dfun-} _A_ 0 _N_ _N_ _N_ _F_ _IF_ARGS_ 0 0 X 5 _!_ _TUP_4 [(Int -> [Char] -> [(CErrorCode, [Char])]), (Int -> CErrorCode -> [Char] -> [Char]), ([Char] -> [([CErrorCode], [Char])]), ([CErrorCode] -> [Char] -> [Char])] [_CONSTM_ Text readsPrec (CErrorCode), _CONSTM_ Text showsPrec (CErrorCode), _CONSTM_ Text readList (CErrorCode), _CONSTM_ Text showList (CErrorCode)] _N_
- readsPrec = _A_ 2 _U_ 22 _N_ _S_ _!_ _F_ _IF_ARGS_ 0 2 XX 4 \ (u0 :: Int) (u1 :: [Char]) -> _APP_ _TYAPP_ patError# { (Int -> [Char] -> [(CErrorCode, [Char])]) } [ _NOREP_S_ "%DPreludeCore.Text.readsPrec\"", u0, u1 ] _N_,
- showsPrec = _A_ 3 _U_ 012 _N_ _S_ "AEL" {_A_ 2 _U_ 12 _N_ _N_ _N_ _N_} _N_ _N_,
- readList = _A_ 0 _U_ 2 _N_ _N_ _N_ _N_,
- showList = _A_ 0 _U_ 12 _N_ _N_ _N_ _N_ #-}
+ readsPrec = { _A_ 2 _U_ 22 _N_ _S_ _!_ _N_ _N_ },
+ showsPrec = { _A_ 3 _U_ 012 _N_ _S_ "AEL" {_A_ 2 _U_ 12 _N_ _N_ _N_ _N_} _N_ _N_ },
+ readList = { _A_ 1 _U_ 2 _N_ _S_ _!_ _N_ _N_ },
+ showList = { _A_ 1 _U_ 12 _N_ _N_ _F_ _IF_ARGS_ 0 1 X 3 \ (u0 :: [CErrorCode]) -> _APP_ _TYAPP_ _ORIG_ PreludeCore _showList { CErrorCode } [ _WRKR_ _CONSTM_ Text showsPrec (CErrorCode), u0 ] _N_ } #-}
-{-# GHC_PRAGMA INTERFACE VERSION 5 #-}
+{-# GHC_PRAGMA INTERFACE VERSION 6 #-}
interface CError where
data CErrorCode
= NOERROR | EPERM | ENOENT | ESRCH | EINTR | EIO | ENXIO | E2BIG | ENOEXEC | EBADF | ECHILD | EAGAIN | ENOMEM | EACCES | EFAULT | ENOTBLK | EBUSY | EEXIST | EXDEV | ENODEV | ENOTDIR | EISDIR | EINVAL | ENFILE | EMFILE | ENOTTY | ETXTBSY | EFBIG | ENOSPC | ESPIPE | EROFS | EMLINK | EPIPE | EDOM | ERANGE | EWOULDBLOCK | EINPROGRESS | EALREADY | ENOTSOCK | EDESTADDRREQ | EMSGSIZE | EPROTOTYPE | ENOPROTOOPT | EPROTONOSUPPOR | ESOCKTNOSUPPORT | EOPNOTSUPP | EPFNOSUPPORT | EAFNOSUPPORT | EADDRINUSE | EADDRNOTAVAIL | ENETDOWN | ENETUNREACH | ENETRESET | ECONNABORTED | ECONNRESET | ENOBUFS | EISCONN | ENOTCONN | ESHUTDOWN | ETOOMANYREFS | ETIMEDOUT | ECONNREFUSED | ELOOP | ENAMETOOLONG | EHOSTDOWN | EHOSTUNREACH | ENOTEMPTY | EPROCLIM | EUSERS | EDQUOT | ESTALE | EREMOTE | ENOSTR | ETIME | ENOSR | ENOMSG | EBADMSG | EIDRM | EDEADLK | ENOLCK | ENONET | ERREMOTE | ENOLINK | EADV | ESRMNT | ECOMM | EPROTO | EMULTIHOP | EDOTDOT | EREMCHG | ENOSYS
{-# GHC_PRAGMA _A_ 2 _U_ 21 _N_ _S_ "EU(P)" {_A_ 2 _U_ 22 _N_ _N_ _N_ _N_} _N_ _N_ #-}
instance Eq CErrorCode
{-# GHC_PRAGMA _M_ CError {-dfun-} _A_ 0 _N_ _N_ _N_ _F_ _IF_ARGS_ 0 0 X 3 _!_ _TUP_2 [(CErrorCode -> CErrorCode -> Bool), (CErrorCode -> CErrorCode -> Bool)] [_CONSTM_ Eq (==) (CErrorCode), _CONSTM_ Eq (/=) (CErrorCode)] _N_
- (==) = _A_ 2 _U_ 11 _N_ _S_ "EE" _N_ _N_,
- (/=) = _A_ 2 _U_ 11 _N_ _S_ "EE" _N_ _N_ #-}
+ (==) = { _A_ 2 _U_ 11 _N_ _S_ "EE" _N_ _N_ },
+ (/=) = { _A_ 2 _U_ 11 _N_ _S_ "EE" _N_ _N_ } #-}
instance Ix CErrorCode
{-# GHC_PRAGMA _M_ CError {-dfun-} _A_ 0 _N_ _N_ _N_ _F_ _IF_ARGS_ 0 0 X 5 _!_ _TUP_4 [{{Ord CErrorCode}}, ((CErrorCode, CErrorCode) -> [CErrorCode]), ((CErrorCode, CErrorCode) -> CErrorCode -> Int), ((CErrorCode, CErrorCode) -> CErrorCode -> Bool)] [_DFUN_ Ord (CErrorCode), _CONSTM_ Ix range (CErrorCode), _CONSTM_ Ix index (CErrorCode), _CONSTM_ Ix inRange (CErrorCode)] _N_
- range = _A_ 1 _U_ 1 _N_ _S_ "U(EE)" {_A_ 2 _U_ 11 _N_ _N_ _N_ _N_} _N_ _N_,
- index = _A_ 2 _U_ 12 _N_ _S_ "U(EE)E" {_A_ 3 _U_ 212 _N_ _N_ _N_ _N_} _N_ _N_,
- inRange = _A_ 2 _U_ 11 _N_ _S_ "U(EE)E" {_A_ 3 _U_ 111 _N_ _N_ _N_ _N_} _N_ _N_ #-}
+ range = { _A_ 1 _U_ 1 _N_ _S_ "U(EE)" {_A_ 2 _U_ 11 _N_ _N_ _N_ _N_} _N_ _N_ },
+ index = { _A_ 2 _U_ 12 _N_ _S_ "U(EE)E" {_A_ 3 _U_ 212 _N_ _N_ _N_ _N_} _N_ _N_ },
+ inRange = { _A_ 2 _U_ 11 _N_ _S_ "U(EE)E" {_A_ 3 _U_ 111 _N_ _N_ _N_ _N_} _N_ _N_ } #-}
instance Ord CErrorCode
{-# GHC_PRAGMA _M_ CError {-dfun-} _A_ 0 _N_ _N_ _N_ _F_ _IF_ARGS_ 0 0 X 9 _!_ _TUP_8 [{{Eq CErrorCode}}, (CErrorCode -> CErrorCode -> Bool), (CErrorCode -> CErrorCode -> Bool), (CErrorCode -> CErrorCode -> Bool), (CErrorCode -> CErrorCode -> Bool), (CErrorCode -> CErrorCode -> CErrorCode), (CErrorCode -> CErrorCode -> CErrorCode), (CErrorCode -> CErrorCode -> _CMP_TAG)] [_DFUN_ Eq (CErrorCode), _CONSTM_ Ord (<) (CErrorCode), _CONSTM_ Ord (<=) (CErrorCode), _CONSTM_ Ord (>=) (CErrorCode), _CONSTM_ Ord (>) (CErrorCode), _CONSTM_ Ord max (CErrorCode), _CONSTM_ Ord min (CErrorCode), _CONSTM_ Ord _tagCmp (CErrorCode)] _N_
- (<) = _A_ 2 _U_ 11 _N_ _S_ "EE" _N_ _N_,
- (<=) = _A_ 2 _U_ 11 _N_ _S_ "EE" _N_ _N_,
- (>=) = _A_ 2 _U_ 11 _N_ _S_ "EE" _N_ _N_,
- (>) = _A_ 2 _U_ 11 _N_ _S_ "EE" _N_ _N_,
- max = _A_ 2 _U_ 22 _N_ _S_ "EE" _N_ _N_,
- min = _A_ 2 _U_ 22 _N_ _S_ "EE" _N_ _N_,
- _tagCmp = _A_ 2 _U_ 11 _N_ _S_ "EE" _N_ _N_ #-}
+ (<) = { _A_ 2 _U_ 11 _N_ _S_ "EE" _N_ _N_ },
+ (<=) = { _A_ 2 _U_ 11 _N_ _S_ "EE" _N_ _N_ },
+ (>=) = { _A_ 2 _U_ 11 _N_ _S_ "EE" _N_ _N_ },
+ (>) = { _A_ 2 _U_ 11 _N_ _S_ "EE" _N_ _N_ },
+ max = { _A_ 2 _U_ 22 _N_ _S_ "EE" _N_ _N_ },
+ min = { _A_ 2 _U_ 22 _N_ _S_ "EE" _N_ _N_ },
+ _tagCmp = { _A_ 2 _U_ 11 _N_ _S_ "EE" _N_ _N_ } #-}
instance Text CErrorCode
{-# GHC_PRAGMA _M_ CError {-dfun-} _A_ 0 _N_ _N_ _N_ _F_ _IF_ARGS_ 0 0 X 5 _!_ _TUP_4 [(Int -> [Char] -> [(CErrorCode, [Char])]), (Int -> CErrorCode -> [Char] -> [Char]), ([Char] -> [([CErrorCode], [Char])]), ([CErrorCode] -> [Char] -> [Char])] [_CONSTM_ Text readsPrec (CErrorCode), _CONSTM_ Text showsPrec (CErrorCode), _CONSTM_ Text readList (CErrorCode), _CONSTM_ Text showList (CErrorCode)] _N_
- readsPrec = _A_ 2 _U_ 22 _N_ _S_ _!_ _F_ _IF_ARGS_ 0 2 XX 4 \ (u0 :: Int) (u1 :: [Char]) -> _APP_ _TYAPP_ patError# { (Int -> [Char] -> [(CErrorCode, [Char])]) } [ _NOREP_S_ "%DPreludeCore.Text.readsPrec\"", u0, u1 ] _N_,
- showsPrec = _A_ 3 _U_ 012 _N_ _S_ "AEL" {_A_ 2 _U_ 12 _N_ _N_ _N_ _N_} _N_ _N_,
- readList = _A_ 0 _U_ 2 _N_ _N_ _N_ _N_,
- showList = _A_ 0 _U_ 12 _N_ _N_ _N_ _N_ #-}
+ readsPrec = { _A_ 2 _U_ 22 _N_ _S_ _!_ _N_ _N_ },
+ showsPrec = { _A_ 3 _U_ 012 _N_ _S_ "AEL" {_A_ 2 _U_ 12 _N_ _N_ _N_ _N_} _N_ _N_ },
+ readList = { _A_ 1 _U_ 2 _N_ _S_ _!_ _N_ _N_ },
+ showList = { _A_ 1 _U_ 12 _N_ _N_ _F_ _IF_ARGS_ 0 1 X 3 \ (u0 :: [CErrorCode]) -> _APP_ _TYAPP_ _ORIG_ PreludeCore _showList { CErrorCode } [ _WRKR_ _CONSTM_ Text showsPrec (CErrorCode), u0 ] _N_ } #-}
-{-# GHC_PRAGMA INTERFACE VERSION 5 #-}
+{-# GHC_PRAGMA INTERFACE VERSION 6 #-}
interface MatchPS where
import PreludeArray(Array)
import PreludePS(_PackedString)
import Regex
+import Core -- alas ...
+
\end{code}
_tailPS and _dropPS in PS.lhs are not to my liking, use
-{-# GHC_PRAGMA INTERFACE VERSION 5 #-}
+{-# GHC_PRAGMA INTERFACE VERSION 6 #-}
interface MatchPS where
import PreludeArray(Array)
import PreludePS(_PackedString)
-{-# GHC_PRAGMA INTERFACE VERSION 5 #-}
+{-# GHC_PRAGMA INTERFACE VERSION 6 #-}
interface MatchPS where
import PreludeArray(Array)
import PreludePS(_PackedString)
-{-# GHC_PRAGMA INTERFACE VERSION 5 #-}
+{-# GHC_PRAGMA INTERFACE VERSION 6 #-}
interface MatchPS where
import PreludeArray(Array)
import PreludePS(_PackedString)
-{-# GHC_PRAGMA INTERFACE VERSION 5 #-}
+{-# GHC_PRAGMA INTERFACE VERSION 6 #-}
interface MatchPS where
import PreludeArray(Array)
import PreludePS(_PackedString)
-{-# GHC_PRAGMA INTERFACE VERSION 5 #-}
+{-# GHC_PRAGMA INTERFACE VERSION 6 #-}
interface PackedString where
import PreludeArray(_ByteArray)
import PreludePS(_PackedString)
-{-# GHC_PRAGMA INTERFACE VERSION 5 #-}
+{-# GHC_PRAGMA INTERFACE VERSION 6 #-}
interface Readline where
import PreludeIOError(IOError13)
import PreludeMonadicIO(Either)
-{-# GHC_PRAGMA INTERFACE VERSION 5 #-}
+{-# GHC_PRAGMA INTERFACE VERSION 6 #-}
interface Readline where
import PreludeIOError(IOError13)
import PreludeMonadicIO(Either)
-{-# GHC_PRAGMA INTERFACE VERSION 5 #-}
+{-# GHC_PRAGMA INTERFACE VERSION 6 #-}
interface Readline where
import PreludeIOError(IOError13)
import PreludeMonadicIO(Either)
-{-# GHC_PRAGMA INTERFACE VERSION 5 #-}
+{-# GHC_PRAGMA INTERFACE VERSION 6 #-}
interface Readline where
import PreludeIOError(IOError13)
import PreludeMonadicIO(Either)
-{-# GHC_PRAGMA INTERFACE VERSION 5 #-}
+{-# GHC_PRAGMA INTERFACE VERSION 6 #-}
interface Readline where
import PreludeIOError(IOError13)
import PreludeMonadicIO(Either)
-{-# GHC_PRAGMA INTERFACE VERSION 5 #-}
+{-# GHC_PRAGMA INTERFACE VERSION 6 #-}
interface Regex where
import PreludeArray(Array)
import PreludePS(_PackedString)
-{-# GHC_PRAGMA INTERFACE VERSION 5 #-}
+{-# GHC_PRAGMA INTERFACE VERSION 6 #-}
interface Regex where
import PreludeArray(Array)
import PreludePS(_PackedString)
-{-# GHC_PRAGMA INTERFACE VERSION 5 #-}
+{-# GHC_PRAGMA INTERFACE VERSION 6 #-}
interface Regex where
import PreludeArray(Array)
import PreludePS(_PackedString)
-{-# GHC_PRAGMA INTERFACE VERSION 5 #-}
+{-# GHC_PRAGMA INTERFACE VERSION 6 #-}
interface Regex where
import PreludeArray(Array)
import PreludePS(_PackedString)
-{-# GHC_PRAGMA INTERFACE VERSION 5 #-}
+{-# GHC_PRAGMA INTERFACE VERSION 6 #-}
interface Regex where
import PreludeArray(Array)
import PreludePS(_PackedString)
-{-# GHC_PRAGMA INTERFACE VERSION 5 #-}
+{-# GHC_PRAGMA INTERFACE VERSION 6 #-}
interface Socket where
import PreludeIOError(IOError13)
import PreludeMonadicIO(Either)
-{-# GHC_PRAGMA INTERFACE VERSION 5 #-}
+{-# GHC_PRAGMA INTERFACE VERSION 6 #-}
interface SocketPrim where
import PreludeGlaST(_MutableArray, _MutableByteArray)
import PreludeIOError(IOError13)
{-# GHC_PRAGMA _A_ 0 _U_ 122 _N_ _N_ _N_ _N_ #-}
instance Eq Family
{-# GHC_PRAGMA _M_ SocketPrim {-dfun-} _A_ 0 _N_ _N_ _N_ _F_ _IF_ARGS_ 0 0 X 3 _!_ _TUP_2 [(Family -> Family -> Bool), (Family -> Family -> Bool)] [_CONSTM_ Eq (==) (Family), _CONSTM_ Eq (/=) (Family)] _N_
- (==) = _A_ 2 _U_ 11 _N_ _S_ "EE" _N_ _N_,
- (/=) = _A_ 2 _U_ 11 _N_ _S_ "EE" _N_ _N_ #-}
+ (==) = { _A_ 2 _U_ 11 _N_ _S_ "EE" _N_ _N_ },
+ (/=) = { _A_ 2 _U_ 11 _N_ _S_ "EE" _N_ _N_ } #-}
instance Eq SockAddr
{-# GHC_PRAGMA _M_ SocketPrim {-dfun-} _A_ 0 _N_ _N_ _N_ _F_ _IF_ARGS_ 0 0 X 3 _!_ _TUP_2 [(SockAddr -> SockAddr -> Bool), (SockAddr -> SockAddr -> Bool)] [_CONSTM_ Eq (==) (SockAddr), _CONSTM_ Eq (/=) (SockAddr)] _N_
- (==) = _A_ 2 _U_ 11 _N_ _S_ "SS" _N_ _N_,
- (/=) = _A_ 2 _U_ 11 _N_ _S_ "SS" _N_ _N_ #-}
+ (==) = { _A_ 2 _U_ 11 _N_ _S_ "SS" _N_ _N_ },
+ (/=) = { _A_ 2 _U_ 11 _N_ _S_ "SS" _N_ _N_ } #-}
instance Eq SocketType
{-# GHC_PRAGMA _M_ SocketPrim {-dfun-} _A_ 0 _N_ _N_ _N_ _F_ _IF_ARGS_ 0 0 X 3 _!_ _TUP_2 [(SocketType -> SocketType -> Bool), (SocketType -> SocketType -> Bool)] [_CONSTM_ Eq (==) (SocketType), _CONSTM_ Eq (/=) (SocketType)] _N_
- (==) = _A_ 2 _U_ 11 _N_ _S_ "EE" _N_ _N_,
- (/=) = _A_ 2 _U_ 11 _N_ _S_ "EE" _N_ _N_ #-}
+ (==) = { _A_ 2 _U_ 11 _N_ _S_ "EE" _N_ _N_ },
+ (/=) = { _A_ 2 _U_ 11 _N_ _S_ "EE" _N_ _N_ } #-}
instance Ix Family
{-# GHC_PRAGMA _M_ SocketPrim {-dfun-} _A_ 0 _N_ _N_ _N_ _F_ _IF_ARGS_ 0 0 X 5 _!_ _TUP_4 [{{Ord Family}}, ((Family, Family) -> [Family]), ((Family, Family) -> Family -> Int), ((Family, Family) -> Family -> Bool)] [_DFUN_ Ord (Family), _CONSTM_ Ix range (Family), _CONSTM_ Ix index (Family), _CONSTM_ Ix inRange (Family)] _N_
- range = _A_ 1 _U_ 1 _N_ _S_ "U(EE)" {_A_ 2 _U_ 11 _N_ _N_ _N_ _N_} _N_ _N_,
- index = _A_ 2 _U_ 12 _N_ _S_ "U(EE)E" {_A_ 3 _U_ 212 _N_ _N_ _N_ _N_} _N_ _N_,
- inRange = _A_ 2 _U_ 11 _N_ _S_ "U(EE)E" {_A_ 3 _U_ 111 _N_ _N_ _N_ _N_} _N_ _N_ #-}
+ range = { _A_ 1 _U_ 1 _N_ _S_ "U(EE)" {_A_ 2 _U_ 11 _N_ _N_ _N_ _N_} _N_ _N_ },
+ index = { _A_ 2 _U_ 12 _N_ _S_ "U(EE)E" {_A_ 3 _U_ 212 _N_ _N_ _N_ _N_} _N_ _N_ },
+ inRange = { _A_ 2 _U_ 11 _N_ _S_ "U(EE)E" {_A_ 3 _U_ 111 _N_ _N_ _N_ _N_} _N_ _N_ } #-}
instance Ix SocketType
{-# GHC_PRAGMA _M_ SocketPrim {-dfun-} _A_ 0 _N_ _N_ _N_ _F_ _IF_ARGS_ 0 0 X 5 _!_ _TUP_4 [{{Ord SocketType}}, ((SocketType, SocketType) -> [SocketType]), ((SocketType, SocketType) -> SocketType -> Int), ((SocketType, SocketType) -> SocketType -> Bool)] [_DFUN_ Ord (SocketType), _CONSTM_ Ix range (SocketType), _CONSTM_ Ix index (SocketType), _CONSTM_ Ix inRange (SocketType)] _N_
- range = _A_ 1 _U_ 1 _N_ _S_ "U(EE)" {_A_ 2 _U_ 11 _N_ _N_ _N_ _N_} _N_ _N_,
- index = _A_ 2 _U_ 12 _N_ _S_ "U(EE)E" {_A_ 3 _U_ 212 _N_ _N_ _N_ _N_} _N_ _N_,
- inRange = _A_ 2 _U_ 11 _N_ _S_ "U(EE)E" {_A_ 3 _U_ 111 _N_ _N_ _N_ _N_} _N_ _N_ #-}
+ range = { _A_ 1 _U_ 1 _N_ _S_ "U(EE)" {_A_ 2 _U_ 11 _N_ _N_ _N_ _N_} _N_ _N_ },
+ index = { _A_ 2 _U_ 12 _N_ _S_ "U(EE)E" {_A_ 3 _U_ 212 _N_ _N_ _N_ _N_} _N_ _N_ },
+ inRange = { _A_ 2 _U_ 11 _N_ _S_ "U(EE)E" {_A_ 3 _U_ 111 _N_ _N_ _N_ _N_} _N_ _N_ } #-}
instance Ord Family
{-# GHC_PRAGMA _M_ SocketPrim {-dfun-} _A_ 0 _N_ _N_ _N_ _F_ _IF_ARGS_ 0 0 X 9 _!_ _TUP_8 [{{Eq Family}}, (Family -> Family -> Bool), (Family -> Family -> Bool), (Family -> Family -> Bool), (Family -> Family -> Bool), (Family -> Family -> Family), (Family -> Family -> Family), (Family -> Family -> _CMP_TAG)] [_DFUN_ Eq (Family), _CONSTM_ Ord (<) (Family), _CONSTM_ Ord (<=) (Family), _CONSTM_ Ord (>=) (Family), _CONSTM_ Ord (>) (Family), _CONSTM_ Ord max (Family), _CONSTM_ Ord min (Family), _CONSTM_ Ord _tagCmp (Family)] _N_
- (<) = _A_ 2 _U_ 11 _N_ _S_ "EE" _N_ _N_,
- (<=) = _A_ 2 _U_ 11 _N_ _S_ "EE" _N_ _N_,
- (>=) = _A_ 2 _U_ 11 _N_ _S_ "EE" _N_ _N_,
- (>) = _A_ 2 _U_ 11 _N_ _S_ "EE" _N_ _N_,
- max = _A_ 2 _U_ 22 _N_ _S_ "EE" _N_ _N_,
- min = _A_ 2 _U_ 22 _N_ _S_ "EE" _N_ _N_,
- _tagCmp = _A_ 2 _U_ 11 _N_ _S_ "EE" _N_ _N_ #-}
+ (<) = { _A_ 2 _U_ 11 _N_ _S_ "EE" _N_ _N_ },
+ (<=) = { _A_ 2 _U_ 11 _N_ _S_ "EE" _N_ _N_ },
+ (>=) = { _A_ 2 _U_ 11 _N_ _S_ "EE" _N_ _N_ },
+ (>) = { _A_ 2 _U_ 11 _N_ _S_ "EE" _N_ _N_ },
+ max = { _A_ 2 _U_ 22 _N_ _S_ "EE" _N_ _N_ },
+ min = { _A_ 2 _U_ 22 _N_ _S_ "EE" _N_ _N_ },
+ _tagCmp = { _A_ 2 _U_ 11 _N_ _S_ "EE" _N_ _N_ } #-}
instance Ord SocketType
{-# GHC_PRAGMA _M_ SocketPrim {-dfun-} _A_ 0 _N_ _N_ _N_ _F_ _IF_ARGS_ 0 0 X 9 _!_ _TUP_8 [{{Eq SocketType}}, (SocketType -> SocketType -> Bool), (SocketType -> SocketType -> Bool), (SocketType -> SocketType -> Bool), (SocketType -> SocketType -> Bool), (SocketType -> SocketType -> SocketType), (SocketType -> SocketType -> SocketType), (SocketType -> SocketType -> _CMP_TAG)] [_DFUN_ Eq (SocketType), _CONSTM_ Ord (<) (SocketType), _CONSTM_ Ord (<=) (SocketType), _CONSTM_ Ord (>=) (SocketType), _CONSTM_ Ord (>) (SocketType), _CONSTM_ Ord max (SocketType), _CONSTM_ Ord min (SocketType), _CONSTM_ Ord _tagCmp (SocketType)] _N_
- (<) = _A_ 2 _U_ 11 _N_ _S_ "EE" _N_ _N_,
- (<=) = _A_ 2 _U_ 11 _N_ _S_ "EE" _N_ _N_,
- (>=) = _A_ 2 _U_ 11 _N_ _S_ "EE" _N_ _N_,
- (>) = _A_ 2 _U_ 11 _N_ _S_ "EE" _N_ _N_,
- max = _A_ 2 _U_ 22 _N_ _S_ "EE" _N_ _N_,
- min = _A_ 2 _U_ 22 _N_ _S_ "EE" _N_ _N_,
- _tagCmp = _A_ 2 _U_ 11 _N_ _S_ "EE" _N_ _N_ #-}
+ (<) = { _A_ 2 _U_ 11 _N_ _S_ "EE" _N_ _N_ },
+ (<=) = { _A_ 2 _U_ 11 _N_ _S_ "EE" _N_ _N_ },
+ (>=) = { _A_ 2 _U_ 11 _N_ _S_ "EE" _N_ _N_ },
+ (>) = { _A_ 2 _U_ 11 _N_ _S_ "EE" _N_ _N_ },
+ max = { _A_ 2 _U_ 22 _N_ _S_ "EE" _N_ _N_ },
+ min = { _A_ 2 _U_ 22 _N_ _S_ "EE" _N_ _N_ },
+ _tagCmp = { _A_ 2 _U_ 11 _N_ _S_ "EE" _N_ _N_ } #-}
instance Text Family
{-# GHC_PRAGMA _M_ SocketPrim {-dfun-} _A_ 0 _N_ _N_ _N_ _F_ _IF_ARGS_ 0 0 X 5 _!_ _TUP_4 [(Int -> [Char] -> [(Family, [Char])]), (Int -> Family -> [Char] -> [Char]), ([Char] -> [([Family], [Char])]), ([Family] -> [Char] -> [Char])] [_CONSTM_ Text readsPrec (Family), _CONSTM_ Text showsPrec (Family), _CONSTM_ Text readList (Family), _CONSTM_ Text showList (Family)] _N_
- readsPrec = _A_ 2 _U_ 02 _N_ _S_ "AL" {_A_ 1 _U_ 2 _N_ _N_ _N_ _N_} _N_ _N_,
- showsPrec = _A_ 3 _U_ 012 _N_ _S_ "AEL" {_A_ 2 _U_ 12 _N_ _N_ _N_ _N_} _N_ _N_,
- readList = _A_ 0 _U_ 2 _N_ _N_ _N_ _N_,
- showList = _A_ 0 _U_ 12 _N_ _N_ _N_ _N_ #-}
+ readsPrec = { _A_ 2 _U_ 02 _N_ _S_ "AL" {_A_ 1 _U_ 2 _N_ _N_ _N_ _N_} _N_ _N_ },
+ showsPrec = { _A_ 3 _U_ 012 _N_ _S_ "AEL" {_A_ 2 _U_ 12 _N_ _N_ _N_ _N_} _N_ _N_ },
+ readList = { _A_ 0 _U_ 2 _N_ _N_ _N_ _N_ },
+ showList = { _A_ 1 _U_ 12 _N_ _N_ _F_ _IF_ARGS_ 0 1 X 3 \ (u0 :: [Family]) -> _APP_ _TYAPP_ _ORIG_ PreludeCore _showList { Family } [ _WRKR_ _CONSTM_ Text showsPrec (Family), u0 ] _N_ } #-}
instance Text SocketType
{-# GHC_PRAGMA _M_ SocketPrim {-dfun-} _A_ 0 _N_ _N_ _N_ _F_ _IF_ARGS_ 0 0 X 5 _!_ _TUP_4 [(Int -> [Char] -> [(SocketType, [Char])]), (Int -> SocketType -> [Char] -> [Char]), ([Char] -> [([SocketType], [Char])]), ([SocketType] -> [Char] -> [Char])] [_CONSTM_ Text readsPrec (SocketType), _CONSTM_ Text showsPrec (SocketType), _CONSTM_ Text readList (SocketType), _CONSTM_ Text showList (SocketType)] _N_
- readsPrec = _A_ 2 _U_ 02 _N_ _S_ "AL" {_A_ 1 _U_ 2 _N_ _N_ _N_ _N_} _N_ _N_,
- showsPrec = _A_ 3 _U_ 012 _N_ _S_ "AEL" {_A_ 2 _U_ 12 _N_ _N_ _N_ _N_} _N_ _N_,
- readList = _A_ 0 _U_ 2 _N_ _N_ _N_ _N_,
- showList = _A_ 0 _U_ 12 _N_ _N_ _N_ _N_ #-}
+ readsPrec = { _A_ 2 _U_ 02 _N_ _S_ "AL" {_A_ 1 _U_ 2 _N_ _N_ _N_ _N_} _N_ _N_ },
+ showsPrec = { _A_ 3 _U_ 012 _N_ _S_ "AEL" {_A_ 2 _U_ 12 _N_ _N_ _N_ _N_} _N_ _N_ },
+ readList = { _A_ 0 _U_ 2 _N_ _N_ _N_ _N_ },
+ showList = { _A_ 1 _U_ 12 _N_ _N_ _F_ _IF_ARGS_ 0 1 X 3 \ (u0 :: [SocketType]) -> _APP_ _TYAPP_ _ORIG_ PreludeCore _showList { SocketType } [ _WRKR_ _CONSTM_ Text showsPrec (SocketType), u0 ] _N_ } #-}
-{-# GHC_PRAGMA INTERFACE VERSION 5 #-}
+{-# GHC_PRAGMA INTERFACE VERSION 6 #-}
interface SocketPrim where
import PreludeGlaST(_MutableArray, _MutableByteArray)
import PreludeIOError(IOError13)
{-# GHC_PRAGMA _A_ 0 _U_ 122 _N_ _N_ _N_ _N_ #-}
instance Eq Family
{-# GHC_PRAGMA _M_ SocketPrim {-dfun-} _A_ 0 _N_ _N_ _N_ _F_ _IF_ARGS_ 0 0 X 3 _!_ _TUP_2 [(Family -> Family -> Bool), (Family -> Family -> Bool)] [_CONSTM_ Eq (==) (Family), _CONSTM_ Eq (/=) (Family)] _N_
- (==) = _A_ 2 _U_ 11 _N_ _S_ "EE" _N_ _N_,
- (/=) = _A_ 2 _U_ 11 _N_ _S_ "EE" _N_ _N_ #-}
+ (==) = { _A_ 2 _U_ 11 _N_ _S_ "EE" _N_ _N_ },
+ (/=) = { _A_ 2 _U_ 11 _N_ _S_ "EE" _N_ _N_ } #-}
instance Eq SockAddr
{-# GHC_PRAGMA _M_ SocketPrim {-dfun-} _A_ 0 _N_ _N_ _N_ _F_ _IF_ARGS_ 0 0 X 3 _!_ _TUP_2 [(SockAddr -> SockAddr -> Bool), (SockAddr -> SockAddr -> Bool)] [_CONSTM_ Eq (==) (SockAddr), _CONSTM_ Eq (/=) (SockAddr)] _N_
- (==) = _A_ 2 _U_ 11 _N_ _S_ "SS" _N_ _N_,
- (/=) = _A_ 2 _U_ 11 _N_ _S_ "SS" _N_ _N_ #-}
+ (==) = { _A_ 2 _U_ 11 _N_ _S_ "SS" _N_ _N_ },
+ (/=) = { _A_ 2 _U_ 11 _N_ _S_ "SS" _N_ _N_ } #-}
instance Eq SocketType
{-# GHC_PRAGMA _M_ SocketPrim {-dfun-} _A_ 0 _N_ _N_ _N_ _F_ _IF_ARGS_ 0 0 X 3 _!_ _TUP_2 [(SocketType -> SocketType -> Bool), (SocketType -> SocketType -> Bool)] [_CONSTM_ Eq (==) (SocketType), _CONSTM_ Eq (/=) (SocketType)] _N_
- (==) = _A_ 2 _U_ 11 _N_ _S_ "EE" _N_ _N_,
- (/=) = _A_ 2 _U_ 11 _N_ _S_ "EE" _N_ _N_ #-}
+ (==) = { _A_ 2 _U_ 11 _N_ _S_ "EE" _N_ _N_ },
+ (/=) = { _A_ 2 _U_ 11 _N_ _S_ "EE" _N_ _N_ } #-}
instance Ix Family
{-# GHC_PRAGMA _M_ SocketPrim {-dfun-} _A_ 0 _N_ _N_ _N_ _F_ _IF_ARGS_ 0 0 X 5 _!_ _TUP_4 [{{Ord Family}}, ((Family, Family) -> [Family]), ((Family, Family) -> Family -> Int), ((Family, Family) -> Family -> Bool)] [_DFUN_ Ord (Family), _CONSTM_ Ix range (Family), _CONSTM_ Ix index (Family), _CONSTM_ Ix inRange (Family)] _N_
- range = _A_ 1 _U_ 1 _N_ _S_ "U(EE)" {_A_ 2 _U_ 11 _N_ _N_ _N_ _N_} _N_ _N_,
- index = _A_ 2 _U_ 12 _N_ _S_ "U(EE)E" {_A_ 3 _U_ 212 _N_ _N_ _N_ _N_} _N_ _N_,
- inRange = _A_ 2 _U_ 11 _N_ _S_ "U(EE)E" {_A_ 3 _U_ 111 _N_ _N_ _N_ _N_} _N_ _N_ #-}
+ range = { _A_ 1 _U_ 1 _N_ _S_ "U(EE)" {_A_ 2 _U_ 11 _N_ _N_ _N_ _N_} _N_ _N_ },
+ index = { _A_ 2 _U_ 12 _N_ _S_ "U(EE)E" {_A_ 3 _U_ 212 _N_ _N_ _N_ _N_} _N_ _N_ },
+ inRange = { _A_ 2 _U_ 11 _N_ _S_ "U(EE)E" {_A_ 3 _U_ 111 _N_ _N_ _N_ _N_} _N_ _N_ } #-}
instance Ix SocketType
{-# GHC_PRAGMA _M_ SocketPrim {-dfun-} _A_ 0 _N_ _N_ _N_ _F_ _IF_ARGS_ 0 0 X 5 _!_ _TUP_4 [{{Ord SocketType}}, ((SocketType, SocketType) -> [SocketType]), ((SocketType, SocketType) -> SocketType -> Int), ((SocketType, SocketType) -> SocketType -> Bool)] [_DFUN_ Ord (SocketType), _CONSTM_ Ix range (SocketType), _CONSTM_ Ix index (SocketType), _CONSTM_ Ix inRange (SocketType)] _N_
- range = _A_ 1 _U_ 1 _N_ _S_ "U(EE)" {_A_ 2 _U_ 11 _N_ _N_ _N_ _N_} _N_ _N_,
- index = _A_ 2 _U_ 12 _N_ _S_ "U(EE)E" {_A_ 3 _U_ 212 _N_ _N_ _N_ _N_} _N_ _N_,
- inRange = _A_ 2 _U_ 11 _N_ _S_ "U(EE)E" {_A_ 3 _U_ 111 _N_ _N_ _N_ _N_} _N_ _N_ #-}
+ range = { _A_ 1 _U_ 1 _N_ _S_ "U(EE)" {_A_ 2 _U_ 11 _N_ _N_ _N_ _N_} _N_ _N_ },
+ index = { _A_ 2 _U_ 12 _N_ _S_ "U(EE)E" {_A_ 3 _U_ 212 _N_ _N_ _N_ _N_} _N_ _N_ },
+ inRange = { _A_ 2 _U_ 11 _N_ _S_ "U(EE)E" {_A_ 3 _U_ 111 _N_ _N_ _N_ _N_} _N_ _N_ } #-}
instance Ord Family
{-# GHC_PRAGMA _M_ SocketPrim {-dfun-} _A_ 0 _N_ _N_ _N_ _F_ _IF_ARGS_ 0 0 X 9 _!_ _TUP_8 [{{Eq Family}}, (Family -> Family -> Bool), (Family -> Family -> Bool), (Family -> Family -> Bool), (Family -> Family -> Bool), (Family -> Family -> Family), (Family -> Family -> Family), (Family -> Family -> _CMP_TAG)] [_DFUN_ Eq (Family), _CONSTM_ Ord (<) (Family), _CONSTM_ Ord (<=) (Family), _CONSTM_ Ord (>=) (Family), _CONSTM_ Ord (>) (Family), _CONSTM_ Ord max (Family), _CONSTM_ Ord min (Family), _CONSTM_ Ord _tagCmp (Family)] _N_
- (<) = _A_ 2 _U_ 11 _N_ _S_ "EE" _N_ _N_,
- (<=) = _A_ 2 _U_ 11 _N_ _S_ "EE" _N_ _N_,
- (>=) = _A_ 2 _U_ 11 _N_ _S_ "EE" _N_ _N_,
- (>) = _A_ 2 _U_ 11 _N_ _S_ "EE" _N_ _N_,
- max = _A_ 2 _U_ 22 _N_ _S_ "EE" _N_ _N_,
- min = _A_ 2 _U_ 22 _N_ _S_ "EE" _N_ _N_,
- _tagCmp = _A_ 2 _U_ 11 _N_ _S_ "EE" _N_ _N_ #-}
+ (<) = { _A_ 2 _U_ 11 _N_ _S_ "EE" _N_ _N_ },
+ (<=) = { _A_ 2 _U_ 11 _N_ _S_ "EE" _N_ _N_ },
+ (>=) = { _A_ 2 _U_ 11 _N_ _S_ "EE" _N_ _N_ },
+ (>) = { _A_ 2 _U_ 11 _N_ _S_ "EE" _N_ _N_ },
+ max = { _A_ 2 _U_ 22 _N_ _S_ "EE" _N_ _N_ },
+ min = { _A_ 2 _U_ 22 _N_ _S_ "EE" _N_ _N_ },
+ _tagCmp = { _A_ 2 _U_ 11 _N_ _S_ "EE" _N_ _N_ } #-}
instance Ord SocketType
{-# GHC_PRAGMA _M_ SocketPrim {-dfun-} _A_ 0 _N_ _N_ _N_ _F_ _IF_ARGS_ 0 0 X 9 _!_ _TUP_8 [{{Eq SocketType}}, (SocketType -> SocketType -> Bool), (SocketType -> SocketType -> Bool), (SocketType -> SocketType -> Bool), (SocketType -> SocketType -> Bool), (SocketType -> SocketType -> SocketType), (SocketType -> SocketType -> SocketType), (SocketType -> SocketType -> _CMP_TAG)] [_DFUN_ Eq (SocketType), _CONSTM_ Ord (<) (SocketType), _CONSTM_ Ord (<=) (SocketType), _CONSTM_ Ord (>=) (SocketType), _CONSTM_ Ord (>) (SocketType), _CONSTM_ Ord max (SocketType), _CONSTM_ Ord min (SocketType), _CONSTM_ Ord _tagCmp (SocketType)] _N_
- (<) = _A_ 2 _U_ 11 _N_ _S_ "EE" _N_ _N_,
- (<=) = _A_ 2 _U_ 11 _N_ _S_ "EE" _N_ _N_,
- (>=) = _A_ 2 _U_ 11 _N_ _S_ "EE" _N_ _N_,
- (>) = _A_ 2 _U_ 11 _N_ _S_ "EE" _N_ _N_,
- max = _A_ 2 _U_ 22 _N_ _S_ "EE" _N_ _N_,
- min = _A_ 2 _U_ 22 _N_ _S_ "EE" _N_ _N_,
- _tagCmp = _A_ 2 _U_ 11 _N_ _S_ "EE" _N_ _N_ #-}
+ (<) = { _A_ 2 _U_ 11 _N_ _S_ "EE" _N_ _N_ },
+ (<=) = { _A_ 2 _U_ 11 _N_ _S_ "EE" _N_ _N_ },
+ (>=) = { _A_ 2 _U_ 11 _N_ _S_ "EE" _N_ _N_ },
+ (>) = { _A_ 2 _U_ 11 _N_ _S_ "EE" _N_ _N_ },
+ max = { _A_ 2 _U_ 22 _N_ _S_ "EE" _N_ _N_ },
+ min = { _A_ 2 _U_ 22 _N_ _S_ "EE" _N_ _N_ },
+ _tagCmp = { _A_ 2 _U_ 11 _N_ _S_ "EE" _N_ _N_ } #-}
instance Text Family
{-# GHC_PRAGMA _M_ SocketPrim {-dfun-} _A_ 0 _N_ _N_ _N_ _F_ _IF_ARGS_ 0 0 X 5 _!_ _TUP_4 [(Int -> [Char] -> [(Family, [Char])]), (Int -> Family -> [Char] -> [Char]), ([Char] -> [([Family], [Char])]), ([Family] -> [Char] -> [Char])] [_CONSTM_ Text readsPrec (Family), _CONSTM_ Text showsPrec (Family), _CONSTM_ Text readList (Family), _CONSTM_ Text showList (Family)] _N_
- readsPrec = _A_ 2 _U_ 02 _N_ _S_ "AL" {_A_ 1 _U_ 2 _N_ _N_ _N_ _N_} _N_ _N_,
- showsPrec = _A_ 3 _U_ 012 _N_ _S_ "AEL" {_A_ 2 _U_ 12 _N_ _N_ _N_ _N_} _N_ _N_,
- readList = _A_ 0 _U_ 2 _N_ _N_ _N_ _N_,
- showList = _A_ 0 _U_ 12 _N_ _N_ _N_ _N_ #-}
+ readsPrec = { _A_ 2 _U_ 02 _N_ _S_ "AL" {_A_ 1 _U_ 2 _N_ _N_ _N_ _N_} _N_ _N_ },
+ showsPrec = { _A_ 3 _U_ 012 _N_ _S_ "AEL" {_A_ 2 _U_ 12 _N_ _N_ _N_ _N_} _N_ _N_ },
+ readList = { _A_ 0 _U_ 2 _N_ _N_ _N_ _N_ },
+ showList = { _A_ 1 _U_ 12 _N_ _N_ _F_ _IF_ARGS_ 0 1 X 3 \ (u0 :: [Family]) -> _APP_ _TYAPP_ _ORIG_ PreludeCore _showList { Family } [ _WRKR_ _CONSTM_ Text showsPrec (Family), u0 ] _N_ } #-}
instance Text SocketType
{-# GHC_PRAGMA _M_ SocketPrim {-dfun-} _A_ 0 _N_ _N_ _N_ _F_ _IF_ARGS_ 0 0 X 5 _!_ _TUP_4 [(Int -> [Char] -> [(SocketType, [Char])]), (Int -> SocketType -> [Char] -> [Char]), ([Char] -> [([SocketType], [Char])]), ([SocketType] -> [Char] -> [Char])] [_CONSTM_ Text readsPrec (SocketType), _CONSTM_ Text showsPrec (SocketType), _CONSTM_ Text readList (SocketType), _CONSTM_ Text showList (SocketType)] _N_
- readsPrec = _A_ 2 _U_ 02 _N_ _S_ "AL" {_A_ 1 _U_ 2 _N_ _N_ _N_ _N_} _N_ _N_,
- showsPrec = _A_ 3 _U_ 012 _N_ _S_ "AEL" {_A_ 2 _U_ 12 _N_ _N_ _N_ _N_} _N_ _N_,
- readList = _A_ 0 _U_ 2 _N_ _N_ _N_ _N_,
- showList = _A_ 0 _U_ 12 _N_ _N_ _N_ _N_ #-}
+ readsPrec = { _A_ 2 _U_ 02 _N_ _S_ "AL" {_A_ 1 _U_ 2 _N_ _N_ _N_ _N_} _N_ _N_ },
+ showsPrec = { _A_ 3 _U_ 012 _N_ _S_ "AEL" {_A_ 2 _U_ 12 _N_ _N_ _N_ _N_} _N_ _N_ },
+ readList = { _A_ 0 _U_ 2 _N_ _N_ _N_ _N_ },
+ showList = { _A_ 1 _U_ 12 _N_ _N_ _F_ _IF_ARGS_ 0 1 X 3 \ (u0 :: [SocketType]) -> _APP_ _TYAPP_ _ORIG_ PreludeCore _showList { SocketType } [ _WRKR_ _CONSTM_ Text showsPrec (SocketType), u0 ] _N_ } #-}
-{-# GHC_PRAGMA INTERFACE VERSION 5 #-}
+{-# GHC_PRAGMA INTERFACE VERSION 6 #-}
interface SocketPrim where
import PreludeGlaST(_MutableArray, _MutableByteArray)
import PreludeIOError(IOError13)
{-# GHC_PRAGMA _A_ 0 _U_ 122 _N_ _N_ _N_ _N_ #-}
instance Eq Family
{-# GHC_PRAGMA _M_ SocketPrim {-dfun-} _A_ 0 _N_ _N_ _N_ _F_ _IF_ARGS_ 0 0 X 3 _!_ _TUP_2 [(Family -> Family -> Bool), (Family -> Family -> Bool)] [_CONSTM_ Eq (==) (Family), _CONSTM_ Eq (/=) (Family)] _N_
- (==) = _A_ 2 _U_ 11 _N_ _S_ "EE" _N_ _N_,
- (/=) = _A_ 2 _U_ 11 _N_ _S_ "EE" _N_ _N_ #-}
+ (==) = { _A_ 2 _U_ 11 _N_ _S_ "EE" _N_ _N_ },
+ (/=) = { _A_ 2 _U_ 11 _N_ _S_ "EE" _N_ _N_ } #-}
instance Eq SockAddr
{-# GHC_PRAGMA _M_ SocketPrim {-dfun-} _A_ 0 _N_ _N_ _N_ _F_ _IF_ARGS_ 0 0 X 3 _!_ _TUP_2 [(SockAddr -> SockAddr -> Bool), (SockAddr -> SockAddr -> Bool)] [_CONSTM_ Eq (==) (SockAddr), _CONSTM_ Eq (/=) (SockAddr)] _N_
- (==) = _A_ 2 _U_ 11 _N_ _S_ "SS" _N_ _N_,
- (/=) = _A_ 2 _U_ 11 _N_ _S_ "SS" _N_ _N_ #-}
+ (==) = { _A_ 2 _U_ 11 _N_ _S_ "SS" _N_ _N_ },
+ (/=) = { _A_ 2 _U_ 11 _N_ _S_ "SS" _N_ _N_ } #-}
instance Eq SocketType
{-# GHC_PRAGMA _M_ SocketPrim {-dfun-} _A_ 0 _N_ _N_ _N_ _F_ _IF_ARGS_ 0 0 X 3 _!_ _TUP_2 [(SocketType -> SocketType -> Bool), (SocketType -> SocketType -> Bool)] [_CONSTM_ Eq (==) (SocketType), _CONSTM_ Eq (/=) (SocketType)] _N_
- (==) = _A_ 2 _U_ 11 _N_ _S_ "EE" _N_ _N_,
- (/=) = _A_ 2 _U_ 11 _N_ _S_ "EE" _N_ _N_ #-}
+ (==) = { _A_ 2 _U_ 11 _N_ _S_ "EE" _N_ _N_ },
+ (/=) = { _A_ 2 _U_ 11 _N_ _S_ "EE" _N_ _N_ } #-}
instance Ix Family
{-# GHC_PRAGMA _M_ SocketPrim {-dfun-} _A_ 0 _N_ _N_ _N_ _F_ _IF_ARGS_ 0 0 X 5 _!_ _TUP_4 [{{Ord Family}}, ((Family, Family) -> [Family]), ((Family, Family) -> Family -> Int), ((Family, Family) -> Family -> Bool)] [_DFUN_ Ord (Family), _CONSTM_ Ix range (Family), _CONSTM_ Ix index (Family), _CONSTM_ Ix inRange (Family)] _N_
- range = _A_ 1 _U_ 1 _N_ _S_ "U(EE)" {_A_ 2 _U_ 11 _N_ _N_ _N_ _N_} _N_ _N_,
- index = _A_ 2 _U_ 12 _N_ _S_ "U(EE)E" {_A_ 3 _U_ 212 _N_ _N_ _N_ _N_} _N_ _N_,
- inRange = _A_ 2 _U_ 11 _N_ _S_ "U(EE)E" {_A_ 3 _U_ 111 _N_ _N_ _N_ _N_} _N_ _N_ #-}
+ range = { _A_ 1 _U_ 1 _N_ _S_ "U(EE)" {_A_ 2 _U_ 11 _N_ _N_ _N_ _N_} _N_ _N_ },
+ index = { _A_ 2 _U_ 12 _N_ _S_ "U(EE)E" {_A_ 3 _U_ 212 _N_ _N_ _N_ _N_} _N_ _N_ },
+ inRange = { _A_ 2 _U_ 11 _N_ _S_ "U(EE)E" {_A_ 3 _U_ 111 _N_ _N_ _N_ _N_} _N_ _N_ } #-}
instance Ix SocketType
{-# GHC_PRAGMA _M_ SocketPrim {-dfun-} _A_ 0 _N_ _N_ _N_ _F_ _IF_ARGS_ 0 0 X 5 _!_ _TUP_4 [{{Ord SocketType}}, ((SocketType, SocketType) -> [SocketType]), ((SocketType, SocketType) -> SocketType -> Int), ((SocketType, SocketType) -> SocketType -> Bool)] [_DFUN_ Ord (SocketType), _CONSTM_ Ix range (SocketType), _CONSTM_ Ix index (SocketType), _CONSTM_ Ix inRange (SocketType)] _N_
- range = _A_ 1 _U_ 1 _N_ _S_ "U(EE)" {_A_ 2 _U_ 11 _N_ _N_ _N_ _N_} _N_ _N_,
- index = _A_ 2 _U_ 12 _N_ _S_ "U(EE)E" {_A_ 3 _U_ 212 _N_ _N_ _N_ _N_} _N_ _N_,
- inRange = _A_ 2 _U_ 11 _N_ _S_ "U(EE)E" {_A_ 3 _U_ 111 _N_ _N_ _N_ _N_} _N_ _N_ #-}
+ range = { _A_ 1 _U_ 1 _N_ _S_ "U(EE)" {_A_ 2 _U_ 11 _N_ _N_ _N_ _N_} _N_ _N_ },
+ index = { _A_ 2 _U_ 12 _N_ _S_ "U(EE)E" {_A_ 3 _U_ 212 _N_ _N_ _N_ _N_} _N_ _N_ },
+ inRange = { _A_ 2 _U_ 11 _N_ _S_ "U(EE)E" {_A_ 3 _U_ 111 _N_ _N_ _N_ _N_} _N_ _N_ } #-}
instance Ord Family
{-# GHC_PRAGMA _M_ SocketPrim {-dfun-} _A_ 0 _N_ _N_ _N_ _F_ _IF_ARGS_ 0 0 X 9 _!_ _TUP_8 [{{Eq Family}}, (Family -> Family -> Bool), (Family -> Family -> Bool), (Family -> Family -> Bool), (Family -> Family -> Bool), (Family -> Family -> Family), (Family -> Family -> Family), (Family -> Family -> _CMP_TAG)] [_DFUN_ Eq (Family), _CONSTM_ Ord (<) (Family), _CONSTM_ Ord (<=) (Family), _CONSTM_ Ord (>=) (Family), _CONSTM_ Ord (>) (Family), _CONSTM_ Ord max (Family), _CONSTM_ Ord min (Family), _CONSTM_ Ord _tagCmp (Family)] _N_
- (<) = _A_ 2 _U_ 11 _N_ _S_ "EE" _N_ _N_,
- (<=) = _A_ 2 _U_ 11 _N_ _S_ "EE" _N_ _N_,
- (>=) = _A_ 2 _U_ 11 _N_ _S_ "EE" _N_ _N_,
- (>) = _A_ 2 _U_ 11 _N_ _S_ "EE" _N_ _N_,
- max = _A_ 2 _U_ 22 _N_ _S_ "EE" _N_ _N_,
- min = _A_ 2 _U_ 22 _N_ _S_ "EE" _N_ _N_,
- _tagCmp = _A_ 2 _U_ 11 _N_ _S_ "EE" _N_ _N_ #-}
+ (<) = { _A_ 2 _U_ 11 _N_ _S_ "EE" _N_ _N_ },
+ (<=) = { _A_ 2 _U_ 11 _N_ _S_ "EE" _N_ _N_ },
+ (>=) = { _A_ 2 _U_ 11 _N_ _S_ "EE" _N_ _N_ },
+ (>) = { _A_ 2 _U_ 11 _N_ _S_ "EE" _N_ _N_ },
+ max = { _A_ 2 _U_ 22 _N_ _S_ "EE" _N_ _N_ },
+ min = { _A_ 2 _U_ 22 _N_ _S_ "EE" _N_ _N_ },
+ _tagCmp = { _A_ 2 _U_ 11 _N_ _S_ "EE" _N_ _N_ } #-}
instance Ord SocketType
{-# GHC_PRAGMA _M_ SocketPrim {-dfun-} _A_ 0 _N_ _N_ _N_ _F_ _IF_ARGS_ 0 0 X 9 _!_ _TUP_8 [{{Eq SocketType}}, (SocketType -> SocketType -> Bool), (SocketType -> SocketType -> Bool), (SocketType -> SocketType -> Bool), (SocketType -> SocketType -> Bool), (SocketType -> SocketType -> SocketType), (SocketType -> SocketType -> SocketType), (SocketType -> SocketType -> _CMP_TAG)] [_DFUN_ Eq (SocketType), _CONSTM_ Ord (<) (SocketType), _CONSTM_ Ord (<=) (SocketType), _CONSTM_ Ord (>=) (SocketType), _CONSTM_ Ord (>) (SocketType), _CONSTM_ Ord max (SocketType), _CONSTM_ Ord min (SocketType), _CONSTM_ Ord _tagCmp (SocketType)] _N_
- (<) = _A_ 2 _U_ 11 _N_ _S_ "EE" _N_ _N_,
- (<=) = _A_ 2 _U_ 11 _N_ _S_ "EE" _N_ _N_,
- (>=) = _A_ 2 _U_ 11 _N_ _S_ "EE" _N_ _N_,
- (>) = _A_ 2 _U_ 11 _N_ _S_ "EE" _N_ _N_,
- max = _A_ 2 _U_ 22 _N_ _S_ "EE" _N_ _N_,
- min = _A_ 2 _U_ 22 _N_ _S_ "EE" _N_ _N_,
- _tagCmp = _A_ 2 _U_ 11 _N_ _S_ "EE" _N_ _N_ #-}
+ (<) = { _A_ 2 _U_ 11 _N_ _S_ "EE" _N_ _N_ },
+ (<=) = { _A_ 2 _U_ 11 _N_ _S_ "EE" _N_ _N_ },
+ (>=) = { _A_ 2 _U_ 11 _N_ _S_ "EE" _N_ _N_ },
+ (>) = { _A_ 2 _U_ 11 _N_ _S_ "EE" _N_ _N_ },
+ max = { _A_ 2 _U_ 22 _N_ _S_ "EE" _N_ _N_ },
+ min = { _A_ 2 _U_ 22 _N_ _S_ "EE" _N_ _N_ },
+ _tagCmp = { _A_ 2 _U_ 11 _N_ _S_ "EE" _N_ _N_ } #-}
instance Text Family
{-# GHC_PRAGMA _M_ SocketPrim {-dfun-} _A_ 0 _N_ _N_ _N_ _F_ _IF_ARGS_ 0 0 X 5 _!_ _TUP_4 [(Int -> [Char] -> [(Family, [Char])]), (Int -> Family -> [Char] -> [Char]), ([Char] -> [([Family], [Char])]), ([Family] -> [Char] -> [Char])] [_CONSTM_ Text readsPrec (Family), _CONSTM_ Text showsPrec (Family), _CONSTM_ Text readList (Family), _CONSTM_ Text showList (Family)] _N_
- readsPrec = _A_ 2 _U_ 02 _N_ _S_ "AL" {_A_ 1 _U_ 2 _N_ _N_ _N_ _N_} _N_ _N_,
- showsPrec = _A_ 3 _U_ 012 _N_ _S_ "AEL" {_A_ 2 _U_ 12 _N_ _N_ _N_ _N_} _N_ _N_,
- readList = _A_ 0 _U_ 2 _N_ _N_ _N_ _N_,
- showList = _A_ 0 _U_ 12 _N_ _N_ _N_ _N_ #-}
+ readsPrec = { _A_ 2 _U_ 02 _N_ _S_ "AL" {_A_ 1 _U_ 2 _N_ _N_ _N_ _N_} _N_ _N_ },
+ showsPrec = { _A_ 3 _U_ 012 _N_ _S_ "AEL" {_A_ 2 _U_ 12 _N_ _N_ _N_ _N_} _N_ _N_ },
+ readList = { _A_ 0 _U_ 2 _N_ _N_ _N_ _N_ },
+ showList = { _A_ 1 _U_ 12 _N_ _N_ _F_ _IF_ARGS_ 0 1 X 3 \ (u0 :: [Family]) -> _APP_ _TYAPP_ _ORIG_ PreludeCore _showList { Family } [ _WRKR_ _CONSTM_ Text showsPrec (Family), u0 ] _N_ } #-}
instance Text SocketType
{-# GHC_PRAGMA _M_ SocketPrim {-dfun-} _A_ 0 _N_ _N_ _N_ _F_ _IF_ARGS_ 0 0 X 5 _!_ _TUP_4 [(Int -> [Char] -> [(SocketType, [Char])]), (Int -> SocketType -> [Char] -> [Char]), ([Char] -> [([SocketType], [Char])]), ([SocketType] -> [Char] -> [Char])] [_CONSTM_ Text readsPrec (SocketType), _CONSTM_ Text showsPrec (SocketType), _CONSTM_ Text readList (SocketType), _CONSTM_ Text showList (SocketType)] _N_
- readsPrec = _A_ 2 _U_ 02 _N_ _S_ "AL" {_A_ 1 _U_ 2 _N_ _N_ _N_ _N_} _N_ _N_,
- showsPrec = _A_ 3 _U_ 012 _N_ _S_ "AEL" {_A_ 2 _U_ 12 _N_ _N_ _N_ _N_} _N_ _N_,
- readList = _A_ 0 _U_ 2 _N_ _N_ _N_ _N_,
- showList = _A_ 0 _U_ 12 _N_ _N_ _N_ _N_ #-}
+ readsPrec = { _A_ 2 _U_ 02 _N_ _S_ "AL" {_A_ 1 _U_ 2 _N_ _N_ _N_ _N_} _N_ _N_ },
+ showsPrec = { _A_ 3 _U_ 012 _N_ _S_ "AEL" {_A_ 2 _U_ 12 _N_ _N_ _N_ _N_} _N_ _N_ },
+ readList = { _A_ 0 _U_ 2 _N_ _N_ _N_ _N_ },
+ showList = { _A_ 1 _U_ 12 _N_ _N_ _F_ _IF_ARGS_ 0 1 X 3 \ (u0 :: [SocketType]) -> _APP_ _TYAPP_ _ORIG_ PreludeCore _showList { SocketType } [ _WRKR_ _CONSTM_ Text showsPrec (SocketType), u0 ] _N_ } #-}
-{-# GHC_PRAGMA INTERFACE VERSION 5 #-}
+{-# GHC_PRAGMA INTERFACE VERSION 6 #-}
interface SocketPrim where
import PreludeGlaST(_MutableArray, _MutableByteArray)
import PreludeIOError(IOError13)
{-# GHC_PRAGMA _A_ 0 _U_ 122 _N_ _N_ _N_ _N_ #-}
instance Eq Family
{-# GHC_PRAGMA _M_ SocketPrim {-dfun-} _A_ 0 _N_ _N_ _N_ _F_ _IF_ARGS_ 0 0 X 3 _!_ _TUP_2 [(Family -> Family -> Bool), (Family -> Family -> Bool)] [_CONSTM_ Eq (==) (Family), _CONSTM_ Eq (/=) (Family)] _N_
- (==) = _A_ 2 _U_ 11 _N_ _S_ "EE" _N_ _N_,
- (/=) = _A_ 2 _U_ 11 _N_ _S_ "EE" _N_ _N_ #-}
+ (==) = { _A_ 2 _U_ 11 _N_ _S_ "EE" _N_ _N_ },
+ (/=) = { _A_ 2 _U_ 11 _N_ _S_ "EE" _N_ _N_ } #-}
instance Eq SockAddr
{-# GHC_PRAGMA _M_ SocketPrim {-dfun-} _A_ 0 _N_ _N_ _N_ _F_ _IF_ARGS_ 0 0 X 3 _!_ _TUP_2 [(SockAddr -> SockAddr -> Bool), (SockAddr -> SockAddr -> Bool)] [_CONSTM_ Eq (==) (SockAddr), _CONSTM_ Eq (/=) (SockAddr)] _N_
- (==) = _A_ 2 _U_ 11 _N_ _S_ "SS" _N_ _N_,
- (/=) = _A_ 2 _U_ 11 _N_ _S_ "SS" _N_ _N_ #-}
+ (==) = { _A_ 2 _U_ 11 _N_ _S_ "SS" _N_ _N_ },
+ (/=) = { _A_ 2 _U_ 11 _N_ _S_ "SS" _N_ _N_ } #-}
instance Eq SocketType
{-# GHC_PRAGMA _M_ SocketPrim {-dfun-} _A_ 0 _N_ _N_ _N_ _F_ _IF_ARGS_ 0 0 X 3 _!_ _TUP_2 [(SocketType -> SocketType -> Bool), (SocketType -> SocketType -> Bool)] [_CONSTM_ Eq (==) (SocketType), _CONSTM_ Eq (/=) (SocketType)] _N_
- (==) = _A_ 2 _U_ 11 _N_ _S_ "EE" _N_ _N_,
- (/=) = _A_ 2 _U_ 11 _N_ _S_ "EE" _N_ _N_ #-}
+ (==) = { _A_ 2 _U_ 11 _N_ _S_ "EE" _N_ _N_ },
+ (/=) = { _A_ 2 _U_ 11 _N_ _S_ "EE" _N_ _N_ } #-}
instance Ix Family
{-# GHC_PRAGMA _M_ SocketPrim {-dfun-} _A_ 0 _N_ _N_ _N_ _F_ _IF_ARGS_ 0 0 X 5 _!_ _TUP_4 [{{Ord Family}}, ((Family, Family) -> [Family]), ((Family, Family) -> Family -> Int), ((Family, Family) -> Family -> Bool)] [_DFUN_ Ord (Family), _CONSTM_ Ix range (Family), _CONSTM_ Ix index (Family), _CONSTM_ Ix inRange (Family)] _N_
- range = _A_ 1 _U_ 1 _N_ _S_ "U(EE)" {_A_ 2 _U_ 11 _N_ _N_ _N_ _N_} _N_ _N_,
- index = _A_ 2 _U_ 12 _N_ _S_ "U(EE)E" {_A_ 3 _U_ 212 _N_ _N_ _N_ _N_} _N_ _N_,
- inRange = _A_ 2 _U_ 11 _N_ _S_ "U(EE)E" {_A_ 3 _U_ 111 _N_ _N_ _N_ _N_} _N_ _N_ #-}
+ range = { _A_ 1 _U_ 1 _N_ _S_ "U(EE)" {_A_ 2 _U_ 11 _N_ _N_ _N_ _N_} _N_ _N_ },
+ index = { _A_ 2 _U_ 12 _N_ _S_ "U(EE)E" {_A_ 3 _U_ 212 _N_ _N_ _N_ _N_} _N_ _N_ },
+ inRange = { _A_ 2 _U_ 11 _N_ _S_ "U(EE)E" {_A_ 3 _U_ 111 _N_ _N_ _N_ _N_} _N_ _N_ } #-}
instance Ix SocketType
{-# GHC_PRAGMA _M_ SocketPrim {-dfun-} _A_ 0 _N_ _N_ _N_ _F_ _IF_ARGS_ 0 0 X 5 _!_ _TUP_4 [{{Ord SocketType}}, ((SocketType, SocketType) -> [SocketType]), ((SocketType, SocketType) -> SocketType -> Int), ((SocketType, SocketType) -> SocketType -> Bool)] [_DFUN_ Ord (SocketType), _CONSTM_ Ix range (SocketType), _CONSTM_ Ix index (SocketType), _CONSTM_ Ix inRange (SocketType)] _N_
- range = _A_ 1 _U_ 1 _N_ _S_ "U(EE)" {_A_ 2 _U_ 11 _N_ _N_ _N_ _N_} _N_ _N_,
- index = _A_ 2 _U_ 12 _N_ _S_ "U(EE)E" {_A_ 3 _U_ 212 _N_ _N_ _N_ _N_} _N_ _N_,
- inRange = _A_ 2 _U_ 11 _N_ _S_ "U(EE)E" {_A_ 3 _U_ 111 _N_ _N_ _N_ _N_} _N_ _N_ #-}
+ range = { _A_ 1 _U_ 1 _N_ _S_ "U(EE)" {_A_ 2 _U_ 11 _N_ _N_ _N_ _N_} _N_ _N_ },
+ index = { _A_ 2 _U_ 12 _N_ _S_ "U(EE)E" {_A_ 3 _U_ 212 _N_ _N_ _N_ _N_} _N_ _N_ },
+ inRange = { _A_ 2 _U_ 11 _N_ _S_ "U(EE)E" {_A_ 3 _U_ 111 _N_ _N_ _N_ _N_} _N_ _N_ } #-}
instance Ord Family
{-# GHC_PRAGMA _M_ SocketPrim {-dfun-} _A_ 0 _N_ _N_ _N_ _F_ _IF_ARGS_ 0 0 X 9 _!_ _TUP_8 [{{Eq Family}}, (Family -> Family -> Bool), (Family -> Family -> Bool), (Family -> Family -> Bool), (Family -> Family -> Bool), (Family -> Family -> Family), (Family -> Family -> Family), (Family -> Family -> _CMP_TAG)] [_DFUN_ Eq (Family), _CONSTM_ Ord (<) (Family), _CONSTM_ Ord (<=) (Family), _CONSTM_ Ord (>=) (Family), _CONSTM_ Ord (>) (Family), _CONSTM_ Ord max (Family), _CONSTM_ Ord min (Family), _CONSTM_ Ord _tagCmp (Family)] _N_
- (<) = _A_ 2 _U_ 11 _N_ _S_ "EE" _N_ _N_,
- (<=) = _A_ 2 _U_ 11 _N_ _S_ "EE" _N_ _N_,
- (>=) = _A_ 2 _U_ 11 _N_ _S_ "EE" _N_ _N_,
- (>) = _A_ 2 _U_ 11 _N_ _S_ "EE" _N_ _N_,
- max = _A_ 2 _U_ 22 _N_ _S_ "EE" _N_ _N_,
- min = _A_ 2 _U_ 22 _N_ _S_ "EE" _N_ _N_,
- _tagCmp = _A_ 2 _U_ 11 _N_ _S_ "EE" _N_ _N_ #-}
+ (<) = { _A_ 2 _U_ 11 _N_ _S_ "EE" _N_ _N_ },
+ (<=) = { _A_ 2 _U_ 11 _N_ _S_ "EE" _N_ _N_ },
+ (>=) = { _A_ 2 _U_ 11 _N_ _S_ "EE" _N_ _N_ },
+ (>) = { _A_ 2 _U_ 11 _N_ _S_ "EE" _N_ _N_ },
+ max = { _A_ 2 _U_ 22 _N_ _S_ "EE" _N_ _N_ },
+ min = { _A_ 2 _U_ 22 _N_ _S_ "EE" _N_ _N_ },
+ _tagCmp = { _A_ 2 _U_ 11 _N_ _S_ "EE" _N_ _N_ } #-}
instance Ord SocketType
{-# GHC_PRAGMA _M_ SocketPrim {-dfun-} _A_ 0 _N_ _N_ _N_ _F_ _IF_ARGS_ 0 0 X 9 _!_ _TUP_8 [{{Eq SocketType}}, (SocketType -> SocketType -> Bool), (SocketType -> SocketType -> Bool), (SocketType -> SocketType -> Bool), (SocketType -> SocketType -> Bool), (SocketType -> SocketType -> SocketType), (SocketType -> SocketType -> SocketType), (SocketType -> SocketType -> _CMP_TAG)] [_DFUN_ Eq (SocketType), _CONSTM_ Ord (<) (SocketType), _CONSTM_ Ord (<=) (SocketType), _CONSTM_ Ord (>=) (SocketType), _CONSTM_ Ord (>) (SocketType), _CONSTM_ Ord max (SocketType), _CONSTM_ Ord min (SocketType), _CONSTM_ Ord _tagCmp (SocketType)] _N_
- (<) = _A_ 2 _U_ 11 _N_ _S_ "EE" _N_ _N_,
- (<=) = _A_ 2 _U_ 11 _N_ _S_ "EE" _N_ _N_,
- (>=) = _A_ 2 _U_ 11 _N_ _S_ "EE" _N_ _N_,
- (>) = _A_ 2 _U_ 11 _N_ _S_ "EE" _N_ _N_,
- max = _A_ 2 _U_ 22 _N_ _S_ "EE" _N_ _N_,
- min = _A_ 2 _U_ 22 _N_ _S_ "EE" _N_ _N_,
- _tagCmp = _A_ 2 _U_ 11 _N_ _S_ "EE" _N_ _N_ #-}
+ (<) = { _A_ 2 _U_ 11 _N_ _S_ "EE" _N_ _N_ },
+ (<=) = { _A_ 2 _U_ 11 _N_ _S_ "EE" _N_ _N_ },
+ (>=) = { _A_ 2 _U_ 11 _N_ _S_ "EE" _N_ _N_ },
+ (>) = { _A_ 2 _U_ 11 _N_ _S_ "EE" _N_ _N_ },
+ max = { _A_ 2 _U_ 22 _N_ _S_ "EE" _N_ _N_ },
+ min = { _A_ 2 _U_ 22 _N_ _S_ "EE" _N_ _N_ },
+ _tagCmp = { _A_ 2 _U_ 11 _N_ _S_ "EE" _N_ _N_ } #-}
instance Text Family
{-# GHC_PRAGMA _M_ SocketPrim {-dfun-} _A_ 0 _N_ _N_ _N_ _F_ _IF_ARGS_ 0 0 X 5 _!_ _TUP_4 [(Int -> [Char] -> [(Family, [Char])]), (Int -> Family -> [Char] -> [Char]), ([Char] -> [([Family], [Char])]), ([Family] -> [Char] -> [Char])] [_CONSTM_ Text readsPrec (Family), _CONSTM_ Text showsPrec (Family), _CONSTM_ Text readList (Family), _CONSTM_ Text showList (Family)] _N_
- readsPrec = _A_ 2 _U_ 02 _N_ _S_ "AL" {_A_ 1 _U_ 2 _N_ _N_ _N_ _N_} _N_ _N_,
- showsPrec = _A_ 3 _U_ 012 _N_ _S_ "AEL" {_A_ 2 _U_ 12 _N_ _N_ _N_ _N_} _N_ _N_,
- readList = _A_ 0 _U_ 2 _N_ _N_ _N_ _N_,
- showList = _A_ 0 _U_ 12 _N_ _N_ _N_ _N_ #-}
+ readsPrec = { _A_ 2 _U_ 02 _N_ _S_ "AL" {_A_ 1 _U_ 2 _N_ _N_ _N_ _N_} _N_ _N_ },
+ showsPrec = { _A_ 3 _U_ 012 _N_ _S_ "AEL" {_A_ 2 _U_ 12 _N_ _N_ _N_ _N_} _N_ _N_ },
+ readList = { _A_ 0 _U_ 2 _N_ _N_ _N_ _N_ },
+ showList = { _A_ 1 _U_ 12 _N_ _N_ _F_ _IF_ARGS_ 0 1 X 3 \ (u0 :: [Family]) -> _APP_ _TYAPP_ _ORIG_ PreludeCore _showList { Family } [ _WRKR_ _CONSTM_ Text showsPrec (Family), u0 ] _N_ } #-}
instance Text SocketType
{-# GHC_PRAGMA _M_ SocketPrim {-dfun-} _A_ 0 _N_ _N_ _N_ _F_ _IF_ARGS_ 0 0 X 5 _!_ _TUP_4 [(Int -> [Char] -> [(SocketType, [Char])]), (Int -> SocketType -> [Char] -> [Char]), ([Char] -> [([SocketType], [Char])]), ([SocketType] -> [Char] -> [Char])] [_CONSTM_ Text readsPrec (SocketType), _CONSTM_ Text showsPrec (SocketType), _CONSTM_ Text readList (SocketType), _CONSTM_ Text showList (SocketType)] _N_
- readsPrec = _A_ 2 _U_ 02 _N_ _S_ "AL" {_A_ 1 _U_ 2 _N_ _N_ _N_ _N_} _N_ _N_,
- showsPrec = _A_ 3 _U_ 012 _N_ _S_ "AEL" {_A_ 2 _U_ 12 _N_ _N_ _N_ _N_} _N_ _N_,
- readList = _A_ 0 _U_ 2 _N_ _N_ _N_ _N_,
- showList = _A_ 0 _U_ 12 _N_ _N_ _N_ _N_ #-}
+ readsPrec = { _A_ 2 _U_ 02 _N_ _S_ "AL" {_A_ 1 _U_ 2 _N_ _N_ _N_ _N_} _N_ _N_ },
+ showsPrec = { _A_ 3 _U_ 012 _N_ _S_ "AEL" {_A_ 2 _U_ 12 _N_ _N_ _N_ _N_} _N_ _N_ },
+ readList = { _A_ 0 _U_ 2 _N_ _N_ _N_ _N_ },
+ showList = { _A_ 1 _U_ 12 _N_ _N_ _F_ _IF_ARGS_ 0 1 X 3 \ (u0 :: [SocketType]) -> _APP_ _TYAPP_ _ORIG_ PreludeCore _showList { SocketType } [ _WRKR_ _CONSTM_ Text showsPrec (SocketType), u0 ] _N_ } #-}
-{-# GHC_PRAGMA INTERFACE VERSION 5 #-}
+{-# GHC_PRAGMA INTERFACE VERSION 6 #-}
interface SocketPrim where
import PreludeGlaST(_MutableArray, _MutableByteArray)
import PreludeIOError(IOError13)
{-# GHC_PRAGMA _A_ 0 _U_ 122 _N_ _N_ _N_ _N_ #-}
instance Eq Family
{-# GHC_PRAGMA _M_ SocketPrim {-dfun-} _A_ 0 _N_ _N_ _N_ _F_ _IF_ARGS_ 0 0 X 3 _!_ _TUP_2 [(Family -> Family -> Bool), (Family -> Family -> Bool)] [_CONSTM_ Eq (==) (Family), _CONSTM_ Eq (/=) (Family)] _N_
- (==) = _A_ 2 _U_ 11 _N_ _S_ "EE" _N_ _N_,
- (/=) = _A_ 2 _U_ 11 _N_ _S_ "EE" _N_ _N_ #-}
+ (==) = { _A_ 2 _U_ 11 _N_ _S_ "EE" _N_ _N_ },
+ (/=) = { _A_ 2 _U_ 11 _N_ _S_ "EE" _N_ _N_ } #-}
instance Eq SockAddr
{-# GHC_PRAGMA _M_ SocketPrim {-dfun-} _A_ 0 _N_ _N_ _N_ _F_ _IF_ARGS_ 0 0 X 3 _!_ _TUP_2 [(SockAddr -> SockAddr -> Bool), (SockAddr -> SockAddr -> Bool)] [_CONSTM_ Eq (==) (SockAddr), _CONSTM_ Eq (/=) (SockAddr)] _N_
- (==) = _A_ 2 _U_ 11 _N_ _S_ "SS" _N_ _N_,
- (/=) = _A_ 2 _U_ 11 _N_ _S_ "SS" _N_ _N_ #-}
+ (==) = { _A_ 2 _U_ 11 _N_ _S_ "SS" _N_ _N_ },
+ (/=) = { _A_ 2 _U_ 11 _N_ _S_ "SS" _N_ _N_ } #-}
instance Eq SocketType
{-# GHC_PRAGMA _M_ SocketPrim {-dfun-} _A_ 0 _N_ _N_ _N_ _F_ _IF_ARGS_ 0 0 X 3 _!_ _TUP_2 [(SocketType -> SocketType -> Bool), (SocketType -> SocketType -> Bool)] [_CONSTM_ Eq (==) (SocketType), _CONSTM_ Eq (/=) (SocketType)] _N_
- (==) = _A_ 2 _U_ 11 _N_ _S_ "EE" _N_ _N_,
- (/=) = _A_ 2 _U_ 11 _N_ _S_ "EE" _N_ _N_ #-}
+ (==) = { _A_ 2 _U_ 11 _N_ _S_ "EE" _N_ _N_ },
+ (/=) = { _A_ 2 _U_ 11 _N_ _S_ "EE" _N_ _N_ } #-}
instance Ix Family
{-# GHC_PRAGMA _M_ SocketPrim {-dfun-} _A_ 0 _N_ _N_ _N_ _F_ _IF_ARGS_ 0 0 X 5 _!_ _TUP_4 [{{Ord Family}}, ((Family, Family) -> [Family]), ((Family, Family) -> Family -> Int), ((Family, Family) -> Family -> Bool)] [_DFUN_ Ord (Family), _CONSTM_ Ix range (Family), _CONSTM_ Ix index (Family), _CONSTM_ Ix inRange (Family)] _N_
- range = _A_ 1 _U_ 1 _N_ _S_ "U(EE)" {_A_ 2 _U_ 11 _N_ _N_ _N_ _N_} _N_ _N_,
- index = _A_ 2 _U_ 12 _N_ _S_ "U(EE)E" {_A_ 3 _U_ 212 _N_ _N_ _N_ _N_} _N_ _N_,
- inRange = _A_ 2 _U_ 11 _N_ _S_ "U(EE)E" {_A_ 3 _U_ 111 _N_ _N_ _N_ _N_} _N_ _N_ #-}
+ range = { _A_ 1 _U_ 1 _N_ _S_ "U(EE)" {_A_ 2 _U_ 11 _N_ _N_ _N_ _N_} _N_ _N_ },
+ index = { _A_ 2 _U_ 12 _N_ _S_ "U(EE)E" {_A_ 3 _U_ 212 _N_ _N_ _N_ _N_} _N_ _N_ },
+ inRange = { _A_ 2 _U_ 11 _N_ _S_ "U(EE)E" {_A_ 3 _U_ 111 _N_ _N_ _N_ _N_} _N_ _N_ } #-}
instance Ix SocketType
{-# GHC_PRAGMA _M_ SocketPrim {-dfun-} _A_ 0 _N_ _N_ _N_ _F_ _IF_ARGS_ 0 0 X 5 _!_ _TUP_4 [{{Ord SocketType}}, ((SocketType, SocketType) -> [SocketType]), ((SocketType, SocketType) -> SocketType -> Int), ((SocketType, SocketType) -> SocketType -> Bool)] [_DFUN_ Ord (SocketType), _CONSTM_ Ix range (SocketType), _CONSTM_ Ix index (SocketType), _CONSTM_ Ix inRange (SocketType)] _N_
- range = _A_ 1 _U_ 1 _N_ _S_ "U(EE)" {_A_ 2 _U_ 11 _N_ _N_ _N_ _N_} _N_ _N_,
- index = _A_ 2 _U_ 12 _N_ _S_ "U(EE)E" {_A_ 3 _U_ 212 _N_ _N_ _N_ _N_} _N_ _N_,
- inRange = _A_ 2 _U_ 11 _N_ _S_ "U(EE)E" {_A_ 3 _U_ 111 _N_ _N_ _N_ _N_} _N_ _N_ #-}
+ range = { _A_ 1 _U_ 1 _N_ _S_ "U(EE)" {_A_ 2 _U_ 11 _N_ _N_ _N_ _N_} _N_ _N_ },
+ index = { _A_ 2 _U_ 12 _N_ _S_ "U(EE)E" {_A_ 3 _U_ 212 _N_ _N_ _N_ _N_} _N_ _N_ },
+ inRange = { _A_ 2 _U_ 11 _N_ _S_ "U(EE)E" {_A_ 3 _U_ 111 _N_ _N_ _N_ _N_} _N_ _N_ } #-}
instance Ord Family
{-# GHC_PRAGMA _M_ SocketPrim {-dfun-} _A_ 0 _N_ _N_ _N_ _F_ _IF_ARGS_ 0 0 X 9 _!_ _TUP_8 [{{Eq Family}}, (Family -> Family -> Bool), (Family -> Family -> Bool), (Family -> Family -> Bool), (Family -> Family -> Bool), (Family -> Family -> Family), (Family -> Family -> Family), (Family -> Family -> _CMP_TAG)] [_DFUN_ Eq (Family), _CONSTM_ Ord (<) (Family), _CONSTM_ Ord (<=) (Family), _CONSTM_ Ord (>=) (Family), _CONSTM_ Ord (>) (Family), _CONSTM_ Ord max (Family), _CONSTM_ Ord min (Family), _CONSTM_ Ord _tagCmp (Family)] _N_
- (<) = _A_ 2 _U_ 11 _N_ _S_ "EE" _N_ _N_,
- (<=) = _A_ 2 _U_ 11 _N_ _S_ "EE" _N_ _N_,
- (>=) = _A_ 2 _U_ 11 _N_ _S_ "EE" _N_ _N_,
- (>) = _A_ 2 _U_ 11 _N_ _S_ "EE" _N_ _N_,
- max = _A_ 2 _U_ 22 _N_ _S_ "EE" _N_ _N_,
- min = _A_ 2 _U_ 22 _N_ _S_ "EE" _N_ _N_,
- _tagCmp = _A_ 2 _U_ 11 _N_ _S_ "EE" _N_ _N_ #-}
+ (<) = { _A_ 2 _U_ 11 _N_ _S_ "EE" _N_ _N_ },
+ (<=) = { _A_ 2 _U_ 11 _N_ _S_ "EE" _N_ _N_ },
+ (>=) = { _A_ 2 _U_ 11 _N_ _S_ "EE" _N_ _N_ },
+ (>) = { _A_ 2 _U_ 11 _N_ _S_ "EE" _N_ _N_ },
+ max = { _A_ 2 _U_ 22 _N_ _S_ "EE" _N_ _N_ },
+ min = { _A_ 2 _U_ 22 _N_ _S_ "EE" _N_ _N_ },
+ _tagCmp = { _A_ 2 _U_ 11 _N_ _S_ "EE" _N_ _N_ } #-}
instance Ord SocketType
{-# GHC_PRAGMA _M_ SocketPrim {-dfun-} _A_ 0 _N_ _N_ _N_ _F_ _IF_ARGS_ 0 0 X 9 _!_ _TUP_8 [{{Eq SocketType}}, (SocketType -> SocketType -> Bool), (SocketType -> SocketType -> Bool), (SocketType -> SocketType -> Bool), (SocketType -> SocketType -> Bool), (SocketType -> SocketType -> SocketType), (SocketType -> SocketType -> SocketType), (SocketType -> SocketType -> _CMP_TAG)] [_DFUN_ Eq (SocketType), _CONSTM_ Ord (<) (SocketType), _CONSTM_ Ord (<=) (SocketType), _CONSTM_ Ord (>=) (SocketType), _CONSTM_ Ord (>) (SocketType), _CONSTM_ Ord max (SocketType), _CONSTM_ Ord min (SocketType), _CONSTM_ Ord _tagCmp (SocketType)] _N_
- (<) = _A_ 2 _U_ 11 _N_ _S_ "EE" _N_ _N_,
- (<=) = _A_ 2 _U_ 11 _N_ _S_ "EE" _N_ _N_,
- (>=) = _A_ 2 _U_ 11 _N_ _S_ "EE" _N_ _N_,
- (>) = _A_ 2 _U_ 11 _N_ _S_ "EE" _N_ _N_,
- max = _A_ 2 _U_ 22 _N_ _S_ "EE" _N_ _N_,
- min = _A_ 2 _U_ 22 _N_ _S_ "EE" _N_ _N_,
- _tagCmp = _A_ 2 _U_ 11 _N_ _S_ "EE" _N_ _N_ #-}
+ (<) = { _A_ 2 _U_ 11 _N_ _S_ "EE" _N_ _N_ },
+ (<=) = { _A_ 2 _U_ 11 _N_ _S_ "EE" _N_ _N_ },
+ (>=) = { _A_ 2 _U_ 11 _N_ _S_ "EE" _N_ _N_ },
+ (>) = { _A_ 2 _U_ 11 _N_ _S_ "EE" _N_ _N_ },
+ max = { _A_ 2 _U_ 22 _N_ _S_ "EE" _N_ _N_ },
+ min = { _A_ 2 _U_ 22 _N_ _S_ "EE" _N_ _N_ },
+ _tagCmp = { _A_ 2 _U_ 11 _N_ _S_ "EE" _N_ _N_ } #-}
instance Text Family
{-# GHC_PRAGMA _M_ SocketPrim {-dfun-} _A_ 0 _N_ _N_ _N_ _F_ _IF_ARGS_ 0 0 X 5 _!_ _TUP_4 [(Int -> [Char] -> [(Family, [Char])]), (Int -> Family -> [Char] -> [Char]), ([Char] -> [([Family], [Char])]), ([Family] -> [Char] -> [Char])] [_CONSTM_ Text readsPrec (Family), _CONSTM_ Text showsPrec (Family), _CONSTM_ Text readList (Family), _CONSTM_ Text showList (Family)] _N_
- readsPrec = _A_ 2 _U_ 02 _N_ _S_ "AL" {_A_ 1 _U_ 2 _N_ _N_ _N_ _N_} _N_ _N_,
- showsPrec = _A_ 3 _U_ 012 _N_ _S_ "AEL" {_A_ 2 _U_ 12 _N_ _N_ _N_ _N_} _N_ _N_,
- readList = _A_ 0 _U_ 2 _N_ _N_ _N_ _N_,
- showList = _A_ 0 _U_ 12 _N_ _N_ _N_ _N_ #-}
+ readsPrec = { _A_ 2 _U_ 02 _N_ _S_ "AL" {_A_ 1 _U_ 2 _N_ _N_ _N_ _N_} _N_ _N_ },
+ showsPrec = { _A_ 3 _U_ 012 _N_ _S_ "AEL" {_A_ 2 _U_ 12 _N_ _N_ _N_ _N_} _N_ _N_ },
+ readList = { _A_ 0 _U_ 2 _N_ _N_ _N_ _N_ },
+ showList = { _A_ 1 _U_ 12 _N_ _N_ _F_ _IF_ARGS_ 0 1 X 3 \ (u0 :: [Family]) -> _APP_ _TYAPP_ _ORIG_ PreludeCore _showList { Family } [ _WRKR_ _CONSTM_ Text showsPrec (Family), u0 ] _N_ } #-}
instance Text SocketType
{-# GHC_PRAGMA _M_ SocketPrim {-dfun-} _A_ 0 _N_ _N_ _N_ _F_ _IF_ARGS_ 0 0 X 5 _!_ _TUP_4 [(Int -> [Char] -> [(SocketType, [Char])]), (Int -> SocketType -> [Char] -> [Char]), ([Char] -> [([SocketType], [Char])]), ([SocketType] -> [Char] -> [Char])] [_CONSTM_ Text readsPrec (SocketType), _CONSTM_ Text showsPrec (SocketType), _CONSTM_ Text readList (SocketType), _CONSTM_ Text showList (SocketType)] _N_
- readsPrec = _A_ 2 _U_ 02 _N_ _S_ "AL" {_A_ 1 _U_ 2 _N_ _N_ _N_ _N_} _N_ _N_,
- showsPrec = _A_ 3 _U_ 012 _N_ _S_ "AEL" {_A_ 2 _U_ 12 _N_ _N_ _N_ _N_} _N_ _N_,
- readList = _A_ 0 _U_ 2 _N_ _N_ _N_ _N_,
- showList = _A_ 0 _U_ 12 _N_ _N_ _N_ _N_ #-}
+ readsPrec = { _A_ 2 _U_ 02 _N_ _S_ "AL" {_A_ 1 _U_ 2 _N_ _N_ _N_ _N_} _N_ _N_ },
+ showsPrec = { _A_ 3 _U_ 012 _N_ _S_ "AEL" {_A_ 2 _U_ 12 _N_ _N_ _N_ _N_} _N_ _N_ },
+ readList = { _A_ 0 _U_ 2 _N_ _N_ _N_ _N_ },
+ showList = { _A_ 1 _U_ 12 _N_ _N_ _F_ _IF_ARGS_ 0 1 X 3 \ (u0 :: [SocketType]) -> _APP_ _TYAPP_ _ORIG_ PreludeCore _showList { SocketType } [ _WRKR_ _CONSTM_ Text showsPrec (SocketType), u0 ] _N_ } #-}
-{-# GHC_PRAGMA INTERFACE VERSION 5 #-}
+{-# GHC_PRAGMA INTERFACE VERSION 6 #-}
interface Socket where
import PreludeIOError(IOError13)
import PreludeMonadicIO(Either)
-{-# GHC_PRAGMA INTERFACE VERSION 5 #-}
+{-# GHC_PRAGMA INTERFACE VERSION 6 #-}
interface Socket where
import PreludeIOError(IOError13)
import PreludeMonadicIO(Either)
-{-# GHC_PRAGMA INTERFACE VERSION 5 #-}
+{-# GHC_PRAGMA INTERFACE VERSION 6 #-}
interface Socket where
import PreludeIOError(IOError13)
import PreludeMonadicIO(Either)
-{-# GHC_PRAGMA INTERFACE VERSION 5 #-}
+{-# GHC_PRAGMA INTERFACE VERSION 6 #-}
interface Socket where
import PreludeIOError(IOError13)
import PreludeMonadicIO(Either)
-{-# GHC_PRAGMA INTERFACE VERSION 5 #-}
+{-# GHC_PRAGMA INTERFACE VERSION 6 #-}
interface ByteOps where
import PreludeBuiltin(Char(..), Double(..), Float(..), Int(..), List(..), Tuple2)
bytesToDouble :: [Char] -> (Double, [Char])
import Prel ( chr )
import PS ( _PackedString, _unpackPS )
import TyArray ( Array(..) )
+import TyComplex
import PreludeGlaST
import Text
\end{code}
-{-# GHC_PRAGMA INTERFACE VERSION 5 #-}
+{-# GHC_PRAGMA INTERFACE VERSION 6 #-}
interface ByteOps where
import PreludeBuiltin(Char(..), Double(..), Float(..), Int(..), List(..), Tuple2)
bytesToDouble :: [Char] -> (Double, [Char])
-{-# GHC_PRAGMA INTERFACE VERSION 5 #-}
+{-# GHC_PRAGMA INTERFACE VERSION 6 #-}
interface ByteOps where
import PreludeBuiltin(Char(..), Double(..), Float(..), Int(..), List(..), Tuple2)
bytesToDouble :: [Char] -> (Double, [Char])
-{-# GHC_PRAGMA INTERFACE VERSION 5 #-}
+{-# GHC_PRAGMA INTERFACE VERSION 6 #-}
interface ByteOps where
import PreludeBuiltin(Char(..), Double(..), Float(..), Int(..), List(..), Tuple2)
bytesToDouble :: [Char] -> (Double, [Char])
-{-# GHC_PRAGMA INTERFACE VERSION 5 #-}
+{-# GHC_PRAGMA INTERFACE VERSION 6 #-}
interface ByteOps where
import PreludeBuiltin(Char(..), Double(..), Float(..), Int(..), List(..), Tuple2)
bytesToDouble :: [Char] -> (Double, [Char])
-{-# GHC_PRAGMA INTERFACE VERSION 5 #-}
+{-# GHC_PRAGMA INTERFACE VERSION 6 #-}
interface Main where
import PreludeBuiltin(Tuple0, Tuple2, _RealWorld(..), _State(..))
mainPrimIO13 :: _State _RealWorld -> ((), _State _RealWorld)
import Prel ( (.), not )
import PS ( _PackedString, _unpackPS )
import Text
+import TyComplex
+import TyArray
mainPrimIO13 :: PrimIO ()
= case (main s) of { (result, s2@(S# _)) ->
case result of
Right () -> ( (), s2 )
- Left err -> error ("I/O error: "++shows err "\n")
+ Left err -> error ("I/O error: "++showsPrec 0 err "\n")
}
\end{code}
-{-# GHC_PRAGMA INTERFACE VERSION 5 #-}
+{-# GHC_PRAGMA INTERFACE VERSION 6 #-}
interface Main where
import PreludeBuiltin(Tuple0, Tuple2, _RealWorld(..), _State(..))
mainPrimIO13 :: _State _RealWorld -> ((), _State _RealWorld)
-{-# GHC_PRAGMA INTERFACE VERSION 5 #-}
+{-# GHC_PRAGMA INTERFACE VERSION 6 #-}
interface Main where
import PreludeBuiltin(Tuple0, Tuple2, _RealWorld(..), _State(..))
mainPrimIO13 :: _State _RealWorld -> ((), _State _RealWorld)
-{-# GHC_PRAGMA INTERFACE VERSION 5 #-}
+{-# GHC_PRAGMA INTERFACE VERSION 6 #-}
interface Main where
import PreludeBuiltin(Tuple0, Tuple2, _RealWorld(..), _State(..))
mainPrimIO13 :: _State _RealWorld -> ((), _State _RealWorld)
-{-# GHC_PRAGMA INTERFACE VERSION 5 #-}
+{-# GHC_PRAGMA INTERFACE VERSION 6 #-}
interface Main where
import PreludeBuiltin(Tuple0, Tuple2, _RealWorld(..), _State(..))
mainPrimIO13 :: _State _RealWorld -> ((), _State _RealWorld)
-{-# GHC_PRAGMA INTERFACE VERSION 5 #-}
+{-# GHC_PRAGMA INTERFACE VERSION 6 #-}
interface PreludeDialogueIO where
import PreludeBuiltin(Char(..), Int(..), List(..), Tuple0, Tuple2, _Addr(..), _RealWorld(..), _State(..))
import PreludeCore(Bool(..))
import Stdio ( fopen, fclose, fflush, _FILE )
import Text
import TyArray ( Array(..) )
+import TyComplex
import TyIO
\end{code}
-{-# GHC_PRAGMA INTERFACE VERSION 5 #-}
+{-# GHC_PRAGMA INTERFACE VERSION 6 #-}
interface PreludeDialogueIO where
import PreludeBuiltin(Char(..), Int(..), List(..), Tuple0, Tuple2, _Addr(..), _RealWorld(..), _State(..))
import PreludeCore(Bool(..))
-{-# GHC_PRAGMA INTERFACE VERSION 5 #-}
+{-# GHC_PRAGMA INTERFACE VERSION 6 #-}
interface PreludeDialogueIO where
import PreludeBuiltin(Char(..), Int(..), List(..), Tuple0, Tuple2, _Addr(..), _RealWorld(..), _State(..))
import PreludeCore(Bool(..))
-{-# GHC_PRAGMA INTERFACE VERSION 5 #-}
+{-# GHC_PRAGMA INTERFACE VERSION 6 #-}
interface PreludeDialogueIO where
import PreludeBuiltin(Char(..), Int(..), List(..), Tuple0, Tuple2, _Addr(..), _RealWorld(..), _State(..))
import PreludeCore(Bool(..))
-{-# GHC_PRAGMA INTERFACE VERSION 5 #-}
+{-# GHC_PRAGMA INTERFACE VERSION 6 #-}
interface PreludeDialogueIO where
import PreludeBuiltin(Char(..), Int(..), List(..), Tuple0, Tuple2, _Addr(..), _RealWorld(..), _State(..))
import PreludeCore(Bool(..))
-{-# GHC_PRAGMA INTERFACE VERSION 5 #-}
+{-# GHC_PRAGMA INTERFACE VERSION 6 #-}
interface PreludeGlaMisc where
import PreludeBuiltin(Int(..), Tuple0, Tuple2, _Addr(..), _RealWorld(..), _State(..))
import PreludeCore(Bool(..), Eq(..))
{-# GHC_PRAGMA _A_ 1 _U_ 1 _N_ _S_ "S" _F_ _ALWAYS_ \ (u0 :: _State _RealWorld) -> case u0 of { _ALG_ S# (u1 :: State# _RealWorld) -> case _#_ (_ccall_GC_ StgPerformGarbageCollection { [(State# _RealWorld)] (_State _RealWorld) }) [] [u1] of { _ALG_ S# (u2 :: State# _RealWorld) -> let {(u3 :: _State _RealWorld) = _!_ S# [_RealWorld] [u2]} in _!_ _TUP_2 [(), (_State _RealWorld)] [_TUP_0, u3]; _NO_DEFLT_ }; _NO_DEFLT_ } _N_ #-}
instance Eq _MallocPtr
{-# GHC_PRAGMA _M_ PreludeGlaMisc {-dfun-} _A_ 0 _N_ _N_ _N_ _F_ _IF_ARGS_ 0 0 X 3 _!_ _TUP_2 [(_MallocPtr -> _MallocPtr -> Bool), (_MallocPtr -> _MallocPtr -> Bool)] [_ORIG_ PreludeGlaMisc eqMallocPtr, _CONSTM_ Eq (/=) (_MallocPtr)] _N_
- (==) = _A_ 2 _U_ 11 _N_ _N_ _F_ _IF_ARGS_ 0 0 X 1 _ORIG_ PreludeGlaMisc eqMallocPtr _N_,
- (/=) = _A_ 2 _U_ 11 _N_ _S_ "U(P)U(P)" {_A_ 2 _U_ 22 _N_ _N_ _N_ _N_} _N_ _N_ #-}
+ (==) = { _A_ 2 _U_ 11 _N_ _N_ _F_ _IF_ARGS_ 0 0 X 1 _ORIG_ PreludeGlaMisc eqMallocPtr _N_ },
+ (/=) = { _A_ 2 _U_ 11 _N_ _S_ "U(P)U(P)" {_A_ 2 _U_ 22 _N_ _N_ _N_ _N_} _N_ _N_ } #-}
import PreludeGlaST
import PS ( _PackedString, _unpackPS )
import TyArray ( Array(..) )
+import TyComplex
import Text
\end{code}
-{-# GHC_PRAGMA INTERFACE VERSION 5 #-}
+{-# GHC_PRAGMA INTERFACE VERSION 6 #-}
interface PreludeGlaMisc where
import PreludeBuiltin(Int(..), Tuple0, Tuple2, _Addr(..), _RealWorld(..), _State(..))
import PreludeCore(Bool(..), Eq(..))
{-# GHC_PRAGMA _A_ 1 _U_ 1 _N_ _S_ "S" _F_ _ALWAYS_ \ (u0 :: _State _RealWorld) -> case u0 of { _ALG_ S# (u1 :: State# _RealWorld) -> case _#_ (_ccall_GC_ StgPerformGarbageCollection { [(State# _RealWorld)] (_State _RealWorld) }) [] [u1] of { _ALG_ S# (u2 :: State# _RealWorld) -> let {(u3 :: _State _RealWorld) = _!_ S# [_RealWorld] [u2]} in _!_ _TUP_2 [(), (_State _RealWorld)] [_TUP_0, u3]; _NO_DEFLT_ }; _NO_DEFLT_ } _N_ #-}
instance Eq _MallocPtr
{-# GHC_PRAGMA _M_ PreludeGlaMisc {-dfun-} _A_ 0 _N_ _N_ _N_ _F_ _IF_ARGS_ 0 0 X 3 _!_ _TUP_2 [(_MallocPtr -> _MallocPtr -> Bool), (_MallocPtr -> _MallocPtr -> Bool)] [_ORIG_ PreludeGlaMisc eqMallocPtr, _CONSTM_ Eq (/=) (_MallocPtr)] _N_
- (==) = _A_ 2 _U_ 11 _N_ _N_ _F_ _IF_ARGS_ 0 0 X 1 _ORIG_ PreludeGlaMisc eqMallocPtr _N_,
- (/=) = _A_ 2 _U_ 11 _N_ _S_ "U(P)U(P)" {_A_ 2 _U_ 22 _N_ _N_ _N_ _N_} _N_ _N_ #-}
+ (==) = { _A_ 2 _U_ 11 _N_ _N_ _F_ _IF_ARGS_ 0 0 X 1 _ORIG_ PreludeGlaMisc eqMallocPtr _N_ },
+ (/=) = { _A_ 2 _U_ 11 _N_ _S_ "U(P)U(P)" {_A_ 2 _U_ 22 _N_ _N_ _N_ _N_} _N_ _N_ } #-}
-{-# GHC_PRAGMA INTERFACE VERSION 5 #-}
+{-# GHC_PRAGMA INTERFACE VERSION 6 #-}
interface PreludeGlaMisc where
import PreludeBuiltin(Int(..), _Addr(..))
addr2Int :: _Addr -> Int
-{-# GHC_PRAGMA INTERFACE VERSION 5 #-}
+{-# GHC_PRAGMA INTERFACE VERSION 6 #-}
interface PreludeGlaMisc where
import PreludeBuiltin(Int(..), Tuple0, Tuple2, _Addr(..), _RealWorld(..), _State(..))
import PreludeCore(Bool(..), Eq(..))
{-# GHC_PRAGMA _A_ 1 _U_ 1 _N_ _S_ "S" _F_ _ALWAYS_ \ (u0 :: _State _RealWorld) -> case u0 of { _ALG_ S# (u1 :: State# _RealWorld) -> case _#_ (_ccall_GC_ StgPerformGarbageCollection { [(State# _RealWorld)] (_State _RealWorld) }) [] [u1] of { _ALG_ S# (u2 :: State# _RealWorld) -> let {(u3 :: _State _RealWorld) = _!_ S# [_RealWorld] [u2]} in _!_ _TUP_2 [(), (_State _RealWorld)] [_TUP_0, u3]; _NO_DEFLT_ }; _NO_DEFLT_ } _N_ #-}
instance Eq _MallocPtr
{-# GHC_PRAGMA _M_ PreludeGlaMisc {-dfun-} _A_ 0 _N_ _N_ _N_ _F_ _IF_ARGS_ 0 0 X 3 _!_ _TUP_2 [(_MallocPtr -> _MallocPtr -> Bool), (_MallocPtr -> _MallocPtr -> Bool)] [_ORIG_ PreludeGlaMisc eqMallocPtr, _CONSTM_ Eq (/=) (_MallocPtr)] _N_
- (==) = _A_ 2 _U_ 11 _N_ _N_ _F_ _IF_ARGS_ 0 0 X 1 _ORIG_ PreludeGlaMisc eqMallocPtr _N_,
- (/=) = _A_ 2 _U_ 11 _N_ _S_ "U(P)U(P)" {_A_ 2 _U_ 22 _N_ _N_ _N_ _N_} _N_ _N_ #-}
+ (==) = { _A_ 2 _U_ 11 _N_ _N_ _F_ _IF_ARGS_ 0 0 X 1 _ORIG_ PreludeGlaMisc eqMallocPtr _N_ },
+ (/=) = { _A_ 2 _U_ 11 _N_ _S_ "U(P)U(P)" {_A_ 2 _U_ 22 _N_ _N_ _N_ _N_} _N_ _N_ } #-}
-{-# GHC_PRAGMA INTERFACE VERSION 5 #-}
+{-# GHC_PRAGMA INTERFACE VERSION 6 #-}
interface PreludeGlaMisc where
import PreludeBuiltin(Int(..), Tuple0, Tuple2, _Addr(..), _RealWorld(..), _State(..))
import PreludeCore(Bool(..), Eq(..))
{-# GHC_PRAGMA _A_ 1 _U_ 1 _N_ _S_ "S" _F_ _ALWAYS_ \ (u0 :: _State _RealWorld) -> case u0 of { _ALG_ S# (u1 :: State# _RealWorld) -> case _#_ (_ccall_GC_ StgPerformGarbageCollection { [(State# _RealWorld)] (_State _RealWorld) }) [] [u1] of { _ALG_ S# (u2 :: State# _RealWorld) -> let {(u3 :: _State _RealWorld) = _!_ S# [_RealWorld] [u2]} in _!_ _TUP_2 [(), (_State _RealWorld)] [_TUP_0, u3]; _NO_DEFLT_ }; _NO_DEFLT_ } _N_ #-}
instance Eq _MallocPtr
{-# GHC_PRAGMA _M_ PreludeGlaMisc {-dfun-} _A_ 0 _N_ _N_ _N_ _F_ _IF_ARGS_ 0 0 X 3 _!_ _TUP_2 [(_MallocPtr -> _MallocPtr -> Bool), (_MallocPtr -> _MallocPtr -> Bool)] [_ORIG_ PreludeGlaMisc eqMallocPtr, _CONSTM_ Eq (/=) (_MallocPtr)] _N_
- (==) = _A_ 2 _U_ 11 _N_ _N_ _F_ _IF_ARGS_ 0 0 X 1 _ORIG_ PreludeGlaMisc eqMallocPtr _N_,
- (/=) = _A_ 2 _U_ 11 _N_ _S_ "U(P)U(P)" {_A_ 2 _U_ 22 _N_ _N_ _N_ _N_} _N_ _N_ #-}
+ (==) = { _A_ 2 _U_ 11 _N_ _N_ _F_ _IF_ARGS_ 0 0 X 1 _ORIG_ PreludeGlaMisc eqMallocPtr _N_ },
+ (/=) = { _A_ 2 _U_ 11 _N_ _S_ "U(P)U(P)" {_A_ 2 _U_ 22 _N_ _N_ _N_ _N_} _N_ _N_ } #-}
-{-# GHC_PRAGMA INTERFACE VERSION 5 #-}
+{-# GHC_PRAGMA INTERFACE VERSION 6 #-}
interface PreludeGlaST where
import PreludeArray(Array(..), _ByteArray(..))
import PreludeBuiltin(Char(..), Double(..), Float(..), Int(..), List(..), Tuple0, Tuple2, _Addr(..), _RealWorld(..), _State(..))
{-# GHC_PRAGMA _A_ 2 _U_ 22 _N_ _N_ _N_ _N_ #-}
fixST :: (b -> _State a -> (b, _State a)) -> _State a -> (b, _State a)
{-# GHC_PRAGMA _A_ 2 _U_ 22 _N_ _S_ "SL" _N_ _N_ #-}
-forkPrimIO :: (_State _RealWorld -> ((), _State _RealWorld)) -> _State _RealWorld -> ((), _State _RealWorld)
- {-# GHC_PRAGMA _A_ 1 _U_ 12 _N_ _N_ _F_ _IF_ARGS_ 0 0 X 1 _TYAPP_ _ORIG_ PreludeGlaST forkST { _RealWorld } _N_ #-}
-forkST :: (_State a -> ((), _State a)) -> _State a -> ((), _State a)
- {-# GHC_PRAGMA _A_ 1 _U_ 12 _N_ _S_ "S" _F_ _IF_ARGS_ 1 1 X 1 _/\_ u0 -> \ (u1 :: _State u0 -> ((), _State u0)) -> u1 _N_ #-}
+forkPrimIO :: (_State _RealWorld -> (a, _State _RealWorld)) -> _State _RealWorld -> (a, _State _RealWorld)
+ {-# GHC_PRAGMA _A_ 1 _U_ 12 _N_ _N_ _F_ _IF_ARGS_ 1 0 X 1 _/\_ u0 -> _TYAPP_ _TYAPP_ _ORIG_ PreludeGlaST forkST { _RealWorld } { u0 } _N_ #-}
+forkST :: (_State a -> (b, _State a)) -> _State a -> (b, _State a)
+ {-# GHC_PRAGMA _A_ 1 _U_ 12 _N_ _S_ "S" _F_ _IF_ARGS_ 2 1 X 1 _/\_ u0 u1 -> \ (u2 :: _State u0 -> (u1, _State u0)) -> u2 _N_ #-}
freezeAddrArray :: Ix b => _MutableByteArray a b -> _State a -> (_ByteArray b, _State a)
{-# GHC_PRAGMA _A_ 3 _U_ 111 _N_ _S_ "U(ASLA)U(U(LL)P)U(P)" {_A_ 5 _U_ 11222 _N_ _N_ _N_ _N_} _N_ _N_ #-}
freezeArray :: Ix b => _MutableArray a b c -> _State a -> (Array b c, _State a)
newDoubleArray :: Ix b => (b, b) -> _State a -> (_MutableByteArray a b, _State a)
{-# GHC_PRAGMA _A_ 3 _U_ 111 _N_ _S_ "U(ASLA)U(LL)U(P)" {_A_ 5 _U_ 11222 _N_ _N_ _N_ _N_} _N_ _SPECIALISE_ [ _N_, Int ] 1 { _A_ 2 _U_ 11 _N_ _S_ "U(U(P)U(P))U(P)" {_A_ 3 _U_ 222 _N_ _N_ _N_ _N_} _N_ _N_ } #-}
newFloatArray :: Ix b => (b, b) -> _State a -> (_MutableByteArray a b, _State a)
- {-# GHC_PRAGMA _A_ 3 _U_ 111 _N_ _S_ "U(ASLA)U(LL)U(P)" {_A_ 5 _U_ 11222 _N_ _N_ _N_ _N_} _N_ _N_ #-}
+ {-# GHC_PRAGMA _A_ 3 _U_ 111 _N_ _S_ "U(ASLA)U(LL)U(P)" {_A_ 5 _U_ 11222 _N_ _N_ _N_ _N_} _N_ _SPECIALISE_ [ _N_, Int ] 1 { _A_ 2 _U_ 11 _N_ _S_ "U(U(P)U(P))U(P)" {_A_ 3 _U_ 222 _N_ _N_ _N_ _N_} _N_ _N_ } #-}
newIntArray :: Ix b => (b, b) -> _State a -> (_MutableByteArray a b, _State a)
{-# GHC_PRAGMA _A_ 3 _U_ 111 _N_ _S_ "U(ASLA)U(LL)U(P)" {_A_ 5 _U_ 11222 _N_ _N_ _N_ _N_} _N_ _SPECIALISE_ [ _N_, Int ] 1 { _A_ 2 _U_ 11 _N_ _S_ "U(U(P)U(P))U(P)" {_A_ 3 _U_ 222 _N_ _N_ _N_ _N_} _N_ _N_ } #-}
newVar :: b -> _State a -> (_MutableArray a Int b, _State a)
{-# GHC_PRAGMA _A_ 3 _U_ 121 _N_ _S_ "U(AP)LU(P)" {_A_ 3 _U_ 222 _N_ _N_ _N_ _N_} _N_ _N_ #-}
instance Eq _FILE
{-# GHC_PRAGMA _M_ Stdio {-dfun-} _A_ 0 _N_ _N_ _N_ _F_ _IF_ARGS_ 0 0 X 3 _!_ _TUP_2 [(_FILE -> _FILE -> Bool), (_FILE -> _FILE -> Bool)] [_CONSTM_ Eq (==) (_FILE), _CONSTM_ Eq (/=) (_FILE)] _N_
- (==) = _A_ 2 _U_ 11 _N_ _S_ "U(P)U(P)" {_A_ 2 _U_ 22 _N_ _N_ _F_ _IF_ARGS_ 0 2 XX 1 \ (u0 :: Addr#) (u1 :: Addr#) -> _#_ eqAddr# [] [u0, u1] _N_} _F_ _IF_ARGS_ 0 2 CC 3 \ (u0 :: _FILE) (u1 :: _FILE) -> case u0 of { _ALG_ _ORIG_ Stdio _FILE (u2 :: Addr#) -> case u1 of { _ALG_ _ORIG_ Stdio _FILE (u3 :: Addr#) -> _#_ eqAddr# [] [u2, u3]; _NO_DEFLT_ }; _NO_DEFLT_ } _N_,
- (/=) = _A_ 2 _U_ 11 _N_ _S_ "U(P)U(P)" {_A_ 2 _U_ 22 _N_ _N_ _F_ _IF_ARGS_ 0 2 XX 5 \ (u0 :: Addr#) (u1 :: Addr#) -> case _#_ eqAddr# [] [u0, u1] of { _ALG_ True -> _!_ False [] []; False -> _!_ True [] []; _NO_DEFLT_ } _N_} _F_ _IF_ARGS_ 0 2 CC 7 \ (u0 :: _FILE) (u1 :: _FILE) -> case u0 of { _ALG_ _ORIG_ Stdio _FILE (u2 :: Addr#) -> case u1 of { _ALG_ _ORIG_ Stdio _FILE (u3 :: Addr#) -> case _#_ eqAddr# [] [u2, u3] of { _ALG_ True -> _!_ False [] []; False -> _!_ True [] []; _NO_DEFLT_ }; _NO_DEFLT_ }; _NO_DEFLT_ } _N_ #-}
+ (==) = { _A_ 2 _U_ 11 _N_ _S_ "U(P)U(P)" {_A_ 2 _U_ 22 _N_ _N_ _F_ _IF_ARGS_ 0 2 XX 1 \ (u0 :: Addr#) (u1 :: Addr#) -> _#_ eqAddr# [] [u0, u1] _N_} _F_ _IF_ARGS_ 0 2 CC 3 \ (u0 :: _FILE) (u1 :: _FILE) -> case u0 of { _ALG_ _ORIG_ Stdio _FILE (u2 :: Addr#) -> case u1 of { _ALG_ _ORIG_ Stdio _FILE (u3 :: Addr#) -> _#_ eqAddr# [] [u2, u3]; _NO_DEFLT_ }; _NO_DEFLT_ } _N_ },
+ (/=) = { _A_ 2 _U_ 11 _N_ _S_ "U(P)U(P)" {_A_ 2 _U_ 22 _N_ _N_ _F_ _IF_ARGS_ 0 2 XX 5 \ (u0 :: Addr#) (u1 :: Addr#) -> case _#_ eqAddr# [] [u0, u1] of { _ALG_ True -> _!_ False [] []; False -> _!_ True [] []; _NO_DEFLT_ } _N_} _F_ _IF_ARGS_ 0 2 CC 7 \ (u0 :: _FILE) (u1 :: _FILE) -> case u0 of { _ALG_ _ORIG_ Stdio _FILE (u2 :: Addr#) -> case u1 of { _ALG_ _ORIG_ Stdio _FILE (u3 :: Addr#) -> case _#_ eqAddr# [] [u2, u3] of { _ALG_ True -> _!_ False [] []; False -> _!_ True [] []; _NO_DEFLT_ }; _NO_DEFLT_ }; _NO_DEFLT_ } _N_ } #-}
instance _CCallable _FILE
{-# GHC_PRAGMA _M_ Stdio {-dfun-} _A_ 0 _N_ _N_ _N_ _F_ _IF_ARGS_ 0 0 X 1 _!_ _TUP_0 [] [] _N_ #-}
instance _CCallable (_ByteArray a)
import List ( map, null, foldr, (++) )
import PS ( _PackedString, _unpackPS )
import TyArray ( Array(..), _ByteArray(..) )
+import TyComplex
import Text
infixr 9 `thenST`, `thenStrictlyST`, `seqST`, `seqStrictlyST`
{-# INLINE thenStrictlyST #-}
{-# INLINE seqStrictlyST #-}
-returnST, returnStrictlyST :: a -> _ST s a
+returnST :: a -> _ST s a
returnST a s = (a, s)
-thenST, thenStrictlyST :: _ST s a -> (a -> _ST s b) -> _ST s b
+thenST :: _ST s a -> (a -> _ST s b) -> _ST s b
thenST m k s = let (r,new_s) = m s
in
k r new_s
-fixST :: (a -> _ST s a) -> _ST s a
-fixST k s = let ans = k r s
- (r,new_s) = ans
- in
- ans
+seqST :: _ST s a -> _ST s b -> _ST s b
+seqST m1 m2 = m1 `thenST` (\ _ -> m2)
--- BUILT-IN: _runST (see Builtin.hs)
-unsafeInterleaveST :: _ST s a -> _ST s a -- ToDo: put in state-interface.tex
+{-# GENERATE_SPECS returnStrictlyST a #-}
+returnStrictlyST :: a -> _ST s a
-unsafeInterleaveST m s
- = let
- (r, new_s) = m s
- in
- (r, s)
+{-# GENERATE_SPECS thenStrictlyST a b #-}
+thenStrictlyST :: _ST s a -> (a -> _ST s b) -> _ST s b
+
+{-# GENERATE_SPECS seqStrictlyST a b #-}
+seqStrictlyST :: _ST s a -> _ST s b -> _ST s b
-seqST, seqStrictlyST :: _ST s a -> _ST s b -> _ST s b
-seqST m1 m2 = m1 `thenST` (\ _ -> m2)
returnStrictlyST a s@(S# _) = (a, s)
= case (m s) of { (_, new_s) ->
k new_s }
-listST :: [_ST s a] -> _ST s [a]
+-- BUILT-IN: _runST (see Builtin.hs)
+
+unsafeInterleaveST :: _ST s a -> _ST s a -- ToDo: put in state-interface.tex
+unsafeInterleaveST m s
+ = let
+ (r, new_s) = m s
+ in
+ (r, s)
+
+
+fixST :: (a -> _ST s a) -> _ST s a
+fixST k s = let ans = k r s
+ (r,new_s) = ans
+ in
+ ans
+
+listST :: [_ST s a] -> _ST s [a]
listST [] = returnST []
listST (m:ms) = m `thenST` \ x ->
listST ms `thenST` \ xs ->
mapAndUnzipST f ms `thenST` \ (rs1, rs2) ->
returnST (r1:rs1, r2:rs2)
--- not exported
-forkST :: ST s () -> ST s ()
+forkST :: ST s a -> ST s a
#ifndef __CONCURRENT_HASKELL__
forkST x = x
#else
forkST action s
- = let
- (_, new_s) = action s
- in
- new_s `_fork_` ((), s)
+ = let
+ (r, new_s) = action s
+ in
+ new_s `_fork_` (r, s)
where
_fork_ x y = case (fork# x) of { 0# -> parError#; _ -> y }
-#endif {- __CONCURRENT_HASKELL__ -}
+#endif {- concurrent -}
-forkPrimIO :: PrimIO () -> PrimIO ()
+forkPrimIO :: PrimIO a -> PrimIO a
forkPrimIO = forkST
\end{code}
{-# SPECIALIZE newCharArray :: IPr -> _ST s (_MutableByteArray s Int) #-}
{-# SPECIALIZE newIntArray :: IPr -> _ST s (_MutableByteArray s Int) #-}
{-# SPECIALIZE newAddrArray :: IPr -> _ST s (_MutableByteArray s Int) #-}
---NO:{-# SPECIALIZE newFloatArray :: IPr -> _ST s (_MutableByteArray s Int) #-}
+{-# SPECIALIZE newFloatArray :: IPr -> _ST s (_MutableByteArray s Int) #-}
{-# SPECIALIZE newDoubleArray :: IPr -> _ST s (_MutableByteArray s Int) #-}
newArray ixs@(ix_start, ix_end) init (S# s#)
readCharArray :: Ix ix => _MutableByteArray s ix -> ix -> _ST s Char
readIntArray :: Ix ix => _MutableByteArray s ix -> ix -> _ST s Int
readAddrArray :: Ix ix => _MutableByteArray s ix -> ix -> _ST s _Addr
---NO:readFloatArray :: Ix ix => _MutableByteArray s ix -> ix -> _ST s Float
+readFloatArray :: Ix ix => _MutableByteArray s ix -> ix -> _ST s Float
readDoubleArray :: Ix ix => _MutableByteArray s ix -> ix -> _ST s Double
{-# SPECIALIZE readArray :: _MutableArray s Int elt -> Int -> _ST s elt,
-{-# GHC_PRAGMA INTERFACE VERSION 5 #-}
+{-# GHC_PRAGMA INTERFACE VERSION 6 #-}
interface PreludeGlaST where
import PreludeArray(Array(..), _ByteArray(..))
import PreludeBuiltin(Char(..), Double(..), Float(..), Int(..), List(..), Tuple0, Tuple2, _Addr(..), _RealWorld(..), _State(..))
{-# GHC_PRAGMA _A_ 2 _U_ 22 _N_ _N_ _N_ _N_ #-}
fixST :: (b -> _State a -> (b, _State a)) -> _State a -> (b, _State a)
{-# GHC_PRAGMA _A_ 2 _U_ 22 _N_ _S_ "SL" _N_ _N_ #-}
-forkPrimIO :: (_State _RealWorld -> ((), _State _RealWorld)) -> _State _RealWorld -> ((), _State _RealWorld)
- {-# GHC_PRAGMA _A_ 2 _U_ 12 _N_ _N_ _F_ _IF_ARGS_ 0 0 X 1 _TYAPP_ _ORIG_ PreludeGlaST forkST { _RealWorld } _N_ #-}
-forkST :: (_State a -> ((), _State a)) -> _State a -> ((), _State a)
+forkPrimIO :: (_State _RealWorld -> (a, _State _RealWorld)) -> _State _RealWorld -> (a, _State _RealWorld)
+ {-# GHC_PRAGMA _A_ 2 _U_ 12 _N_ _N_ _F_ _IF_ARGS_ 1 0 X 1 _/\_ u0 -> _TYAPP_ _TYAPP_ _ORIG_ PreludeGlaST forkST { _RealWorld } { u0 } _N_ #-}
+forkST :: (_State a -> (b, _State a)) -> _State a -> (b, _State a)
{-# GHC_PRAGMA _A_ 2 _U_ 12 _N_ _N_ _N_ _N_ #-}
freezeAddrArray :: Ix b => _MutableByteArray a b -> _State a -> (_ByteArray b, _State a)
{-# GHC_PRAGMA _A_ 3 _U_ 111 _N_ _S_ "U(ASLA)U(U(LL)P)U(P)" {_A_ 5 _U_ 11222 _N_ _N_ _N_ _N_} _N_ _N_ #-}
newDoubleArray :: Ix b => (b, b) -> _State a -> (_MutableByteArray a b, _State a)
{-# GHC_PRAGMA _A_ 3 _U_ 111 _N_ _S_ "U(ASLA)U(LL)U(P)" {_A_ 5 _U_ 11222 _N_ _N_ _N_ _N_} _N_ _SPECIALISE_ [ _N_, Int ] 1 { _A_ 2 _U_ 11 _N_ _S_ "U(U(P)U(P))U(P)" {_A_ 3 _U_ 222 _N_ _N_ _N_ _N_} _N_ _N_ } #-}
newFloatArray :: Ix b => (b, b) -> _State a -> (_MutableByteArray a b, _State a)
- {-# GHC_PRAGMA _A_ 3 _U_ 111 _N_ _S_ "U(ASLA)U(LL)U(P)" {_A_ 5 _U_ 11222 _N_ _N_ _N_ _N_} _N_ _N_ #-}
+ {-# GHC_PRAGMA _A_ 3 _U_ 111 _N_ _S_ "U(ASLA)U(LL)U(P)" {_A_ 5 _U_ 11222 _N_ _N_ _N_ _N_} _N_ _SPECIALISE_ [ _N_, Int ] 1 { _A_ 2 _U_ 11 _N_ _S_ "U(U(P)U(P))U(P)" {_A_ 3 _U_ 222 _N_ _N_ _N_ _N_} _N_ _N_ } #-}
newIntArray :: Ix b => (b, b) -> _State a -> (_MutableByteArray a b, _State a)
{-# GHC_PRAGMA _A_ 3 _U_ 111 _N_ _S_ "U(ASLA)U(LL)U(P)" {_A_ 5 _U_ 11222 _N_ _N_ _N_ _N_} _N_ _SPECIALISE_ [ _N_, Int ] 1 { _A_ 2 _U_ 11 _N_ _S_ "U(U(P)U(P))U(P)" {_A_ 3 _U_ 222 _N_ _N_ _N_ _N_} _N_ _N_ } #-}
newVar :: b -> _State a -> (_MutableArray a Int b, _State a)
{-# GHC_PRAGMA _A_ 3 _U_ 121 _N_ _S_ "U(AP)LU(P)" {_A_ 3 _U_ 222 _N_ _N_ _N_ _N_} _N_ _N_ #-}
instance Eq _FILE
{-# GHC_PRAGMA _M_ Stdio {-dfun-} _A_ 0 _N_ _N_ _N_ _F_ _IF_ARGS_ 0 0 X 3 _!_ _TUP_2 [(_FILE -> _FILE -> Bool), (_FILE -> _FILE -> Bool)] [_CONSTM_ Eq (==) (_FILE), _CONSTM_ Eq (/=) (_FILE)] _N_
- (==) = _A_ 2 _U_ 11 _N_ _S_ "U(P)U(P)" {_A_ 2 _U_ 22 _N_ _N_ _F_ _IF_ARGS_ 0 2 XX 1 \ (u0 :: Addr#) (u1 :: Addr#) -> _#_ eqAddr# [] [u0, u1] _N_} _F_ _IF_ARGS_ 0 2 CC 3 \ (u0 :: _FILE) (u1 :: _FILE) -> case u0 of { _ALG_ _ORIG_ Stdio _FILE (u2 :: Addr#) -> case u1 of { _ALG_ _ORIG_ Stdio _FILE (u3 :: Addr#) -> _#_ eqAddr# [] [u2, u3]; _NO_DEFLT_ }; _NO_DEFLT_ } _N_,
- (/=) = _A_ 2 _U_ 11 _N_ _S_ "U(P)U(P)" {_A_ 2 _U_ 22 _N_ _N_ _F_ _IF_ARGS_ 0 2 XX 5 \ (u0 :: Addr#) (u1 :: Addr#) -> case _#_ eqAddr# [] [u0, u1] of { _ALG_ True -> _!_ False [] []; False -> _!_ True [] []; _NO_DEFLT_ } _N_} _F_ _IF_ARGS_ 0 2 CC 7 \ (u0 :: _FILE) (u1 :: _FILE) -> case u0 of { _ALG_ _ORIG_ Stdio _FILE (u2 :: Addr#) -> case u1 of { _ALG_ _ORIG_ Stdio _FILE (u3 :: Addr#) -> case _#_ eqAddr# [] [u2, u3] of { _ALG_ True -> _!_ False [] []; False -> _!_ True [] []; _NO_DEFLT_ }; _NO_DEFLT_ }; _NO_DEFLT_ } _N_ #-}
+ (==) = { _A_ 2 _U_ 11 _N_ _S_ "U(P)U(P)" {_A_ 2 _U_ 22 _N_ _N_ _F_ _IF_ARGS_ 0 2 XX 1 \ (u0 :: Addr#) (u1 :: Addr#) -> _#_ eqAddr# [] [u0, u1] _N_} _F_ _IF_ARGS_ 0 2 CC 3 \ (u0 :: _FILE) (u1 :: _FILE) -> case u0 of { _ALG_ _ORIG_ Stdio _FILE (u2 :: Addr#) -> case u1 of { _ALG_ _ORIG_ Stdio _FILE (u3 :: Addr#) -> _#_ eqAddr# [] [u2, u3]; _NO_DEFLT_ }; _NO_DEFLT_ } _N_ },
+ (/=) = { _A_ 2 _U_ 11 _N_ _S_ "U(P)U(P)" {_A_ 2 _U_ 22 _N_ _N_ _F_ _IF_ARGS_ 0 2 XX 5 \ (u0 :: Addr#) (u1 :: Addr#) -> case _#_ eqAddr# [] [u0, u1] of { _ALG_ True -> _!_ False [] []; False -> _!_ True [] []; _NO_DEFLT_ } _N_} _F_ _IF_ARGS_ 0 2 CC 7 \ (u0 :: _FILE) (u1 :: _FILE) -> case u0 of { _ALG_ _ORIG_ Stdio _FILE (u2 :: Addr#) -> case u1 of { _ALG_ _ORIG_ Stdio _FILE (u3 :: Addr#) -> case _#_ eqAddr# [] [u2, u3] of { _ALG_ True -> _!_ False [] []; False -> _!_ True [] []; _NO_DEFLT_ }; _NO_DEFLT_ }; _NO_DEFLT_ } _N_ } #-}
instance _CCallable _FILE
{-# GHC_PRAGMA _M_ Stdio {-dfun-} _A_ 0 _N_ _N_ _N_ _F_ _IF_ARGS_ 0 0 X 1 _!_ _TUP_0 [] [] _N_ #-}
instance _CCallable (_ByteArray a)
-{-# GHC_PRAGMA INTERFACE VERSION 5 #-}
+{-# GHC_PRAGMA INTERFACE VERSION 6 #-}
interface PreludeGlaST where
import PreludeArray(Array(..), _ByteArray(..))
import PreludeBuiltin(Char(..), Double(..), Float(..), Int(..), List(..), Tuple0, Tuple2, _Addr(..), _RealWorld(..), _State(..))
{-# GHC_PRAGMA _A_ 2 _U_ 22 _N_ _N_ _N_ _N_ #-}
fixST :: (b -> _State a -> (b, _State a)) -> _State a -> (b, _State a)
{-# GHC_PRAGMA _A_ 2 _U_ 22 _N_ _S_ "SL" _N_ _N_ #-}
-forkPrimIO :: (_State _RealWorld -> ((), _State _RealWorld)) -> _State _RealWorld -> ((), _State _RealWorld)
- {-# GHC_PRAGMA _A_ 1 _U_ 12 _N_ _N_ _F_ _IF_ARGS_ 0 0 X 1 _TYAPP_ _ORIG_ PreludeGlaST forkST { _RealWorld } _N_ #-}
-forkST :: (_State a -> ((), _State a)) -> _State a -> ((), _State a)
- {-# GHC_PRAGMA _A_ 1 _U_ 12 _N_ _S_ "S" _F_ _IF_ARGS_ 1 1 X 1 _/\_ u0 -> \ (u1 :: _State u0 -> ((), _State u0)) -> u1 _N_ #-}
+forkPrimIO :: (_State _RealWorld -> (a, _State _RealWorld)) -> _State _RealWorld -> (a, _State _RealWorld)
+ {-# GHC_PRAGMA _A_ 1 _U_ 12 _N_ _N_ _F_ _IF_ARGS_ 1 0 X 1 _/\_ u0 -> _TYAPP_ _TYAPP_ _ORIG_ PreludeGlaST forkST { _RealWorld } { u0 } _N_ #-}
+forkST :: (_State a -> (b, _State a)) -> _State a -> (b, _State a)
+ {-# GHC_PRAGMA _A_ 1 _U_ 12 _N_ _S_ "S" _F_ _IF_ARGS_ 2 1 X 1 _/\_ u0 u1 -> \ (u2 :: _State u0 -> (u1, _State u0)) -> u2 _N_ #-}
freezeAddrArray :: Ix b => _MutableByteArray a b -> _State a -> (_ByteArray b, _State a)
{-# GHC_PRAGMA _A_ 3 _U_ 111 _N_ _S_ "U(ASLA)U(U(LL)P)U(P)" {_A_ 5 _U_ 11222 _N_ _N_ _N_ _N_} _N_ _N_ #-}
freezeArray :: Ix b => _MutableArray a b c -> _State a -> (Array b c, _State a)
newDoubleArray :: Ix b => (b, b) -> _State a -> (_MutableByteArray a b, _State a)
{-# GHC_PRAGMA _A_ 3 _U_ 111 _N_ _S_ "U(ASLA)U(LL)U(P)" {_A_ 5 _U_ 11222 _N_ _N_ _N_ _N_} _N_ _SPECIALISE_ [ _N_, Int ] 1 { _A_ 2 _U_ 11 _N_ _S_ "U(U(P)U(P))U(P)" {_A_ 3 _U_ 222 _N_ _N_ _N_ _N_} _N_ _N_ } #-}
newFloatArray :: Ix b => (b, b) -> _State a -> (_MutableByteArray a b, _State a)
- {-# GHC_PRAGMA _A_ 3 _U_ 111 _N_ _S_ "U(ASLA)U(LL)U(P)" {_A_ 5 _U_ 11222 _N_ _N_ _N_ _N_} _N_ _N_ #-}
+ {-# GHC_PRAGMA _A_ 3 _U_ 111 _N_ _S_ "U(ASLA)U(LL)U(P)" {_A_ 5 _U_ 11222 _N_ _N_ _N_ _N_} _N_ _SPECIALISE_ [ _N_, Int ] 1 { _A_ 2 _U_ 11 _N_ _S_ "U(U(P)U(P))U(P)" {_A_ 3 _U_ 222 _N_ _N_ _N_ _N_} _N_ _N_ } #-}
newIntArray :: Ix b => (b, b) -> _State a -> (_MutableByteArray a b, _State a)
{-# GHC_PRAGMA _A_ 3 _U_ 111 _N_ _S_ "U(ASLA)U(LL)U(P)" {_A_ 5 _U_ 11222 _N_ _N_ _N_ _N_} _N_ _SPECIALISE_ [ _N_, Int ] 1 { _A_ 2 _U_ 11 _N_ _S_ "U(U(P)U(P))U(P)" {_A_ 3 _U_ 222 _N_ _N_ _N_ _N_} _N_ _N_ } #-}
newVar :: b -> _State a -> (_MutableArray a Int b, _State a)
{-# GHC_PRAGMA _A_ 3 _U_ 121 _N_ _S_ "U(AP)LU(P)" {_A_ 3 _U_ 222 _N_ _N_ _N_ _N_} _N_ _N_ #-}
instance Eq _FILE
{-# GHC_PRAGMA _M_ Stdio {-dfun-} _A_ 0 _N_ _N_ _N_ _F_ _IF_ARGS_ 0 0 X 3 _!_ _TUP_2 [(_FILE -> _FILE -> Bool), (_FILE -> _FILE -> Bool)] [_CONSTM_ Eq (==) (_FILE), _CONSTM_ Eq (/=) (_FILE)] _N_
- (==) = _A_ 2 _U_ 11 _N_ _S_ "U(P)U(P)" {_A_ 2 _U_ 22 _N_ _N_ _F_ _IF_ARGS_ 0 2 XX 1 \ (u0 :: Addr#) (u1 :: Addr#) -> _#_ eqAddr# [] [u0, u1] _N_} _F_ _IF_ARGS_ 0 2 CC 3 \ (u0 :: _FILE) (u1 :: _FILE) -> case u0 of { _ALG_ _ORIG_ Stdio _FILE (u2 :: Addr#) -> case u1 of { _ALG_ _ORIG_ Stdio _FILE (u3 :: Addr#) -> _#_ eqAddr# [] [u2, u3]; _NO_DEFLT_ }; _NO_DEFLT_ } _N_,
- (/=) = _A_ 2 _U_ 11 _N_ _S_ "U(P)U(P)" {_A_ 2 _U_ 22 _N_ _N_ _F_ _IF_ARGS_ 0 2 XX 5 \ (u0 :: Addr#) (u1 :: Addr#) -> case _#_ eqAddr# [] [u0, u1] of { _ALG_ True -> _!_ False [] []; False -> _!_ True [] []; _NO_DEFLT_ } _N_} _F_ _IF_ARGS_ 0 2 CC 7 \ (u0 :: _FILE) (u1 :: _FILE) -> case u0 of { _ALG_ _ORIG_ Stdio _FILE (u2 :: Addr#) -> case u1 of { _ALG_ _ORIG_ Stdio _FILE (u3 :: Addr#) -> case _#_ eqAddr# [] [u2, u3] of { _ALG_ True -> _!_ False [] []; False -> _!_ True [] []; _NO_DEFLT_ }; _NO_DEFLT_ }; _NO_DEFLT_ } _N_ #-}
+ (==) = { _A_ 2 _U_ 11 _N_ _S_ "U(P)U(P)" {_A_ 2 _U_ 22 _N_ _N_ _F_ _IF_ARGS_ 0 2 XX 1 \ (u0 :: Addr#) (u1 :: Addr#) -> _#_ eqAddr# [] [u0, u1] _N_} _F_ _IF_ARGS_ 0 2 CC 3 \ (u0 :: _FILE) (u1 :: _FILE) -> case u0 of { _ALG_ _ORIG_ Stdio _FILE (u2 :: Addr#) -> case u1 of { _ALG_ _ORIG_ Stdio _FILE (u3 :: Addr#) -> _#_ eqAddr# [] [u2, u3]; _NO_DEFLT_ }; _NO_DEFLT_ } _N_ },
+ (/=) = { _A_ 2 _U_ 11 _N_ _S_ "U(P)U(P)" {_A_ 2 _U_ 22 _N_ _N_ _F_ _IF_ARGS_ 0 2 XX 5 \ (u0 :: Addr#) (u1 :: Addr#) -> case _#_ eqAddr# [] [u0, u1] of { _ALG_ True -> _!_ False [] []; False -> _!_ True [] []; _NO_DEFLT_ } _N_} _F_ _IF_ARGS_ 0 2 CC 7 \ (u0 :: _FILE) (u1 :: _FILE) -> case u0 of { _ALG_ _ORIG_ Stdio _FILE (u2 :: Addr#) -> case u1 of { _ALG_ _ORIG_ Stdio _FILE (u3 :: Addr#) -> case _#_ eqAddr# [] [u2, u3] of { _ALG_ True -> _!_ False [] []; False -> _!_ True [] []; _NO_DEFLT_ }; _NO_DEFLT_ }; _NO_DEFLT_ } _N_ } #-}
instance _CCallable _FILE
{-# GHC_PRAGMA _M_ Stdio {-dfun-} _A_ 0 _N_ _N_ _N_ _F_ _IF_ARGS_ 0 0 X 1 _!_ _TUP_0 [] [] _N_ #-}
instance _CCallable (_ByteArray a)
-{-# GHC_PRAGMA INTERFACE VERSION 5 #-}
+{-# GHC_PRAGMA INTERFACE VERSION 6 #-}
interface PreludeGlaST where
import PreludeArray(Array(..), _ByteArray(..))
import PreludeBuiltin(Char(..), Double(..), Float(..), Int(..), List(..), Tuple0, Tuple2, _Addr(..), _RealWorld(..), _State(..))
{-# GHC_PRAGMA _A_ 2 _U_ 22 _N_ _N_ _N_ _N_ #-}
fixST :: (b -> _State a -> (b, _State a)) -> _State a -> (b, _State a)
{-# GHC_PRAGMA _A_ 2 _U_ 22 _N_ _S_ "SL" _N_ _N_ #-}
-forkPrimIO :: (_State _RealWorld -> ((), _State _RealWorld)) -> _State _RealWorld -> ((), _State _RealWorld)
- {-# GHC_PRAGMA _A_ 1 _U_ 12 _N_ _N_ _F_ _IF_ARGS_ 0 0 X 1 _TYAPP_ _ORIG_ PreludeGlaST forkST { _RealWorld } _N_ #-}
-forkST :: (_State a -> ((), _State a)) -> _State a -> ((), _State a)
- {-# GHC_PRAGMA _A_ 1 _U_ 12 _N_ _S_ "S" _F_ _IF_ARGS_ 1 1 X 1 _/\_ u0 -> \ (u1 :: _State u0 -> ((), _State u0)) -> u1 _N_ #-}
+forkPrimIO :: (_State _RealWorld -> (a, _State _RealWorld)) -> _State _RealWorld -> (a, _State _RealWorld)
+ {-# GHC_PRAGMA _A_ 1 _U_ 12 _N_ _N_ _F_ _IF_ARGS_ 1 0 X 1 _/\_ u0 -> _TYAPP_ _TYAPP_ _ORIG_ PreludeGlaST forkST { _RealWorld } { u0 } _N_ #-}
+forkST :: (_State a -> (b, _State a)) -> _State a -> (b, _State a)
+ {-# GHC_PRAGMA _A_ 1 _U_ 12 _N_ _S_ "S" _F_ _IF_ARGS_ 2 1 X 1 _/\_ u0 u1 -> \ (u2 :: _State u0 -> (u1, _State u0)) -> u2 _N_ #-}
freezeAddrArray :: Ix b => _MutableByteArray a b -> _State a -> (_ByteArray b, _State a)
{-# GHC_PRAGMA _A_ 3 _U_ 111 _N_ _S_ "U(ASLA)U(U(LL)P)U(P)" {_A_ 5 _U_ 11222 _N_ _N_ _N_ _N_} _N_ _N_ #-}
freezeArray :: Ix b => _MutableArray a b c -> _State a -> (Array b c, _State a)
newDoubleArray :: Ix b => (b, b) -> _State a -> (_MutableByteArray a b, _State a)
{-# GHC_PRAGMA _A_ 3 _U_ 111 _N_ _S_ "U(ASLA)U(LL)U(P)" {_A_ 5 _U_ 11222 _N_ _N_ _N_ _N_} _N_ _SPECIALISE_ [ _N_, Int ] 1 { _A_ 2 _U_ 11 _N_ _S_ "U(U(P)U(P))U(P)" {_A_ 3 _U_ 222 _N_ _N_ _N_ _N_} _N_ _N_ } #-}
newFloatArray :: Ix b => (b, b) -> _State a -> (_MutableByteArray a b, _State a)
- {-# GHC_PRAGMA _A_ 3 _U_ 111 _N_ _S_ "U(ASLA)U(LL)U(P)" {_A_ 5 _U_ 11222 _N_ _N_ _N_ _N_} _N_ _N_ #-}
+ {-# GHC_PRAGMA _A_ 3 _U_ 111 _N_ _S_ "U(ASLA)U(LL)U(P)" {_A_ 5 _U_ 11222 _N_ _N_ _N_ _N_} _N_ _SPECIALISE_ [ _N_, Int ] 1 { _A_ 2 _U_ 11 _N_ _S_ "U(U(P)U(P))U(P)" {_A_ 3 _U_ 222 _N_ _N_ _N_ _N_} _N_ _N_ } #-}
newIntArray :: Ix b => (b, b) -> _State a -> (_MutableByteArray a b, _State a)
{-# GHC_PRAGMA _A_ 3 _U_ 111 _N_ _S_ "U(ASLA)U(LL)U(P)" {_A_ 5 _U_ 11222 _N_ _N_ _N_ _N_} _N_ _SPECIALISE_ [ _N_, Int ] 1 { _A_ 2 _U_ 11 _N_ _S_ "U(U(P)U(P))U(P)" {_A_ 3 _U_ 222 _N_ _N_ _N_ _N_} _N_ _N_ } #-}
newVar :: b -> _State a -> (_MutableArray a Int b, _State a)
{-# GHC_PRAGMA _A_ 3 _U_ 121 _N_ _S_ "U(AP)LU(P)" {_A_ 3 _U_ 222 _N_ _N_ _N_ _N_} _N_ _N_ #-}
instance Eq _FILE
{-# GHC_PRAGMA _M_ Stdio {-dfun-} _A_ 0 _N_ _N_ _N_ _F_ _IF_ARGS_ 0 0 X 3 _!_ _TUP_2 [(_FILE -> _FILE -> Bool), (_FILE -> _FILE -> Bool)] [_CONSTM_ Eq (==) (_FILE), _CONSTM_ Eq (/=) (_FILE)] _N_
- (==) = _A_ 2 _U_ 11 _N_ _S_ "U(P)U(P)" {_A_ 2 _U_ 22 _N_ _N_ _F_ _IF_ARGS_ 0 2 XX 1 \ (u0 :: Addr#) (u1 :: Addr#) -> _#_ eqAddr# [] [u0, u1] _N_} _F_ _IF_ARGS_ 0 2 CC 3 \ (u0 :: _FILE) (u1 :: _FILE) -> case u0 of { _ALG_ _ORIG_ Stdio _FILE (u2 :: Addr#) -> case u1 of { _ALG_ _ORIG_ Stdio _FILE (u3 :: Addr#) -> _#_ eqAddr# [] [u2, u3]; _NO_DEFLT_ }; _NO_DEFLT_ } _N_,
- (/=) = _A_ 2 _U_ 11 _N_ _S_ "U(P)U(P)" {_A_ 2 _U_ 22 _N_ _N_ _F_ _IF_ARGS_ 0 2 XX 5 \ (u0 :: Addr#) (u1 :: Addr#) -> case _#_ eqAddr# [] [u0, u1] of { _ALG_ True -> _!_ False [] []; False -> _!_ True [] []; _NO_DEFLT_ } _N_} _F_ _IF_ARGS_ 0 2 CC 7 \ (u0 :: _FILE) (u1 :: _FILE) -> case u0 of { _ALG_ _ORIG_ Stdio _FILE (u2 :: Addr#) -> case u1 of { _ALG_ _ORIG_ Stdio _FILE (u3 :: Addr#) -> case _#_ eqAddr# [] [u2, u3] of { _ALG_ True -> _!_ False [] []; False -> _!_ True [] []; _NO_DEFLT_ }; _NO_DEFLT_ }; _NO_DEFLT_ } _N_ #-}
+ (==) = { _A_ 2 _U_ 11 _N_ _S_ "U(P)U(P)" {_A_ 2 _U_ 22 _N_ _N_ _F_ _IF_ARGS_ 0 2 XX 1 \ (u0 :: Addr#) (u1 :: Addr#) -> _#_ eqAddr# [] [u0, u1] _N_} _F_ _IF_ARGS_ 0 2 CC 3 \ (u0 :: _FILE) (u1 :: _FILE) -> case u0 of { _ALG_ _ORIG_ Stdio _FILE (u2 :: Addr#) -> case u1 of { _ALG_ _ORIG_ Stdio _FILE (u3 :: Addr#) -> _#_ eqAddr# [] [u2, u3]; _NO_DEFLT_ }; _NO_DEFLT_ } _N_ },
+ (/=) = { _A_ 2 _U_ 11 _N_ _S_ "U(P)U(P)" {_A_ 2 _U_ 22 _N_ _N_ _F_ _IF_ARGS_ 0 2 XX 5 \ (u0 :: Addr#) (u1 :: Addr#) -> case _#_ eqAddr# [] [u0, u1] of { _ALG_ True -> _!_ False [] []; False -> _!_ True [] []; _NO_DEFLT_ } _N_} _F_ _IF_ARGS_ 0 2 CC 7 \ (u0 :: _FILE) (u1 :: _FILE) -> case u0 of { _ALG_ _ORIG_ Stdio _FILE (u2 :: Addr#) -> case u1 of { _ALG_ _ORIG_ Stdio _FILE (u3 :: Addr#) -> case _#_ eqAddr# [] [u2, u3] of { _ALG_ True -> _!_ False [] []; False -> _!_ True [] []; _NO_DEFLT_ }; _NO_DEFLT_ }; _NO_DEFLT_ } _N_ } #-}
instance _CCallable _FILE
{-# GHC_PRAGMA _M_ Stdio {-dfun-} _A_ 0 _N_ _N_ _N_ _F_ _IF_ARGS_ 0 0 X 1 _!_ _TUP_0 [] [] _N_ #-}
instance _CCallable (_ByteArray a)
-{-# GHC_PRAGMA INTERFACE VERSION 5 #-}
+{-# GHC_PRAGMA INTERFACE VERSION 6 #-}
interface PreludeGlaST where
import PreludeArray(Array(..), _ByteArray(..))
import PreludeBuiltin(Char(..), Double(..), Float(..), Int(..), List(..), Tuple0, Tuple2, _Addr(..), _RealWorld(..), _State(..))
{-# GHC_PRAGMA _A_ 2 _U_ 22 _N_ _N_ _N_ _N_ #-}
fixST :: (b -> _State a -> (b, _State a)) -> _State a -> (b, _State a)
{-# GHC_PRAGMA _A_ 2 _U_ 22 _N_ _S_ "SL" _N_ _N_ #-}
-forkPrimIO :: (_State _RealWorld -> ((), _State _RealWorld)) -> _State _RealWorld -> ((), _State _RealWorld)
- {-# GHC_PRAGMA _A_ 1 _U_ 12 _N_ _N_ _F_ _IF_ARGS_ 0 0 X 1 _TYAPP_ _ORIG_ PreludeGlaST forkST { _RealWorld } _N_ #-}
-forkST :: (_State a -> ((), _State a)) -> _State a -> ((), _State a)
- {-# GHC_PRAGMA _A_ 1 _U_ 12 _N_ _S_ "S" _F_ _IF_ARGS_ 1 1 X 1 _/\_ u0 -> \ (u1 :: _State u0 -> ((), _State u0)) -> u1 _N_ #-}
+forkPrimIO :: (_State _RealWorld -> (a, _State _RealWorld)) -> _State _RealWorld -> (a, _State _RealWorld)
+ {-# GHC_PRAGMA _A_ 1 _U_ 12 _N_ _N_ _F_ _IF_ARGS_ 1 0 X 1 _/\_ u0 -> _TYAPP_ _TYAPP_ _ORIG_ PreludeGlaST forkST { _RealWorld } { u0 } _N_ #-}
+forkST :: (_State a -> (b, _State a)) -> _State a -> (b, _State a)
+ {-# GHC_PRAGMA _A_ 1 _U_ 12 _N_ _S_ "S" _F_ _IF_ARGS_ 2 1 X 1 _/\_ u0 u1 -> \ (u2 :: _State u0 -> (u1, _State u0)) -> u2 _N_ #-}
freezeAddrArray :: Ix b => _MutableByteArray a b -> _State a -> (_ByteArray b, _State a)
{-# GHC_PRAGMA _A_ 3 _U_ 111 _N_ _S_ "U(ASLA)U(U(LL)P)U(P)" {_A_ 5 _U_ 11222 _N_ _N_ _N_ _N_} _N_ _N_ #-}
freezeArray :: Ix b => _MutableArray a b c -> _State a -> (Array b c, _State a)
newDoubleArray :: Ix b => (b, b) -> _State a -> (_MutableByteArray a b, _State a)
{-# GHC_PRAGMA _A_ 3 _U_ 111 _N_ _S_ "U(ASLA)U(LL)U(P)" {_A_ 5 _U_ 11222 _N_ _N_ _N_ _N_} _N_ _SPECIALISE_ [ _N_, Int ] 1 { _A_ 2 _U_ 11 _N_ _S_ "U(U(P)U(P))U(P)" {_A_ 3 _U_ 222 _N_ _N_ _N_ _N_} _N_ _N_ } #-}
newFloatArray :: Ix b => (b, b) -> _State a -> (_MutableByteArray a b, _State a)
- {-# GHC_PRAGMA _A_ 3 _U_ 111 _N_ _S_ "U(ASLA)U(LL)U(P)" {_A_ 5 _U_ 11222 _N_ _N_ _N_ _N_} _N_ _N_ #-}
+ {-# GHC_PRAGMA _A_ 3 _U_ 111 _N_ _S_ "U(ASLA)U(LL)U(P)" {_A_ 5 _U_ 11222 _N_ _N_ _N_ _N_} _N_ _SPECIALISE_ [ _N_, Int ] 1 { _A_ 2 _U_ 11 _N_ _S_ "U(U(P)U(P))U(P)" {_A_ 3 _U_ 222 _N_ _N_ _N_ _N_} _N_ _N_ } #-}
newIntArray :: Ix b => (b, b) -> _State a -> (_MutableByteArray a b, _State a)
{-# GHC_PRAGMA _A_ 3 _U_ 111 _N_ _S_ "U(ASLA)U(LL)U(P)" {_A_ 5 _U_ 11222 _N_ _N_ _N_ _N_} _N_ _SPECIALISE_ [ _N_, Int ] 1 { _A_ 2 _U_ 11 _N_ _S_ "U(U(P)U(P))U(P)" {_A_ 3 _U_ 222 _N_ _N_ _N_ _N_} _N_ _N_ } #-}
newVar :: b -> _State a -> (_MutableArray a Int b, _State a)
{-# GHC_PRAGMA _A_ 3 _U_ 121 _N_ _S_ "U(AP)LU(P)" {_A_ 3 _U_ 222 _N_ _N_ _N_ _N_} _N_ _N_ #-}
instance Eq _FILE
{-# GHC_PRAGMA _M_ Stdio {-dfun-} _A_ 0 _N_ _N_ _N_ _F_ _IF_ARGS_ 0 0 X 3 _!_ _TUP_2 [(_FILE -> _FILE -> Bool), (_FILE -> _FILE -> Bool)] [_CONSTM_ Eq (==) (_FILE), _CONSTM_ Eq (/=) (_FILE)] _N_
- (==) = _A_ 2 _U_ 11 _N_ _S_ "U(P)U(P)" {_A_ 2 _U_ 22 _N_ _N_ _F_ _IF_ARGS_ 0 2 XX 1 \ (u0 :: Addr#) (u1 :: Addr#) -> _#_ eqAddr# [] [u0, u1] _N_} _F_ _IF_ARGS_ 0 2 CC 3 \ (u0 :: _FILE) (u1 :: _FILE) -> case u0 of { _ALG_ _ORIG_ Stdio _FILE (u2 :: Addr#) -> case u1 of { _ALG_ _ORIG_ Stdio _FILE (u3 :: Addr#) -> _#_ eqAddr# [] [u2, u3]; _NO_DEFLT_ }; _NO_DEFLT_ } _N_,
- (/=) = _A_ 2 _U_ 11 _N_ _S_ "U(P)U(P)" {_A_ 2 _U_ 22 _N_ _N_ _F_ _IF_ARGS_ 0 2 XX 5 \ (u0 :: Addr#) (u1 :: Addr#) -> case _#_ eqAddr# [] [u0, u1] of { _ALG_ True -> _!_ False [] []; False -> _!_ True [] []; _NO_DEFLT_ } _N_} _F_ _IF_ARGS_ 0 2 CC 7 \ (u0 :: _FILE) (u1 :: _FILE) -> case u0 of { _ALG_ _ORIG_ Stdio _FILE (u2 :: Addr#) -> case u1 of { _ALG_ _ORIG_ Stdio _FILE (u3 :: Addr#) -> case _#_ eqAddr# [] [u2, u3] of { _ALG_ True -> _!_ False [] []; False -> _!_ True [] []; _NO_DEFLT_ }; _NO_DEFLT_ }; _NO_DEFLT_ } _N_ #-}
+ (==) = { _A_ 2 _U_ 11 _N_ _S_ "U(P)U(P)" {_A_ 2 _U_ 22 _N_ _N_ _F_ _IF_ARGS_ 0 2 XX 1 \ (u0 :: Addr#) (u1 :: Addr#) -> _#_ eqAddr# [] [u0, u1] _N_} _F_ _IF_ARGS_ 0 2 CC 3 \ (u0 :: _FILE) (u1 :: _FILE) -> case u0 of { _ALG_ _ORIG_ Stdio _FILE (u2 :: Addr#) -> case u1 of { _ALG_ _ORIG_ Stdio _FILE (u3 :: Addr#) -> _#_ eqAddr# [] [u2, u3]; _NO_DEFLT_ }; _NO_DEFLT_ } _N_ },
+ (/=) = { _A_ 2 _U_ 11 _N_ _S_ "U(P)U(P)" {_A_ 2 _U_ 22 _N_ _N_ _F_ _IF_ARGS_ 0 2 XX 5 \ (u0 :: Addr#) (u1 :: Addr#) -> case _#_ eqAddr# [] [u0, u1] of { _ALG_ True -> _!_ False [] []; False -> _!_ True [] []; _NO_DEFLT_ } _N_} _F_ _IF_ARGS_ 0 2 CC 7 \ (u0 :: _FILE) (u1 :: _FILE) -> case u0 of { _ALG_ _ORIG_ Stdio _FILE (u2 :: Addr#) -> case u1 of { _ALG_ _ORIG_ Stdio _FILE (u3 :: Addr#) -> case _#_ eqAddr# [] [u2, u3] of { _ALG_ True -> _!_ False [] []; False -> _!_ True [] []; _NO_DEFLT_ }; _NO_DEFLT_ }; _NO_DEFLT_ } _N_ } #-}
instance _CCallable _FILE
{-# GHC_PRAGMA _M_ Stdio {-dfun-} _A_ 0 _N_ _N_ _N_ _F_ _IF_ARGS_ 0 0 X 1 _!_ _TUP_0 [] [] _N_ #-}
instance _CCallable (_ByteArray a)
-{-# GHC_PRAGMA INTERFACE VERSION 5 #-}
+{-# GHC_PRAGMA INTERFACE VERSION 6 #-}
interface PreludePrimIO where
import PreludeArray(_ByteArray)
import PreludeBuiltin(Char(..), Int(..), List(..), Tuple0, Tuple2, _RealWorld(..), _State(..))
import Core
import List ( (++), map )
import PreludeDialogueIO ( processIORequest )
+import PS ( _PackedString, _unpackPS )
+import TyComplex
import TyIO
import Stdio
The usual business:
\begin{code}
+{-# GENERATE_SPECS returnPrimIO a #-}
returnPrimIO :: a -> PrimIO a
+
+{-# GENERATE_SPECS thenPrimIO b #-}
thenPrimIO :: PrimIO a -> (a -> PrimIO b) -> PrimIO b
+
+{-# GENERATE_SPECS seqPrimIO b #-}
seqPrimIO :: PrimIO a -> PrimIO b -> PrimIO b
+
fixPrimIO :: (a -> PrimIO a) -> PrimIO a
listPrimIO :: [PrimIO a] -> PrimIO [a]
mapPrimIO :: (a -> PrimIO b) -> [a] -> PrimIO [b]
\end{code}
\begin{code}
+{-# GENERATE_SPECS unsafePerformPrimIO a #-}
unsafePerformPrimIO :: PrimIO a -> a
+
unsafeInterleavePrimIO :: PrimIO a -> PrimIO a
unsafePerformPrimIO k = case (k (S# realWorld#)) of (r, _) -> r
-{-# GHC_PRAGMA INTERFACE VERSION 5 #-}
+{-# GHC_PRAGMA INTERFACE VERSION 6 #-}
interface PreludePrimIO where
import PreludeArray(_ByteArray)
import PreludeBuiltin(Char(..), Int(..), List(..), Tuple0, Tuple2, _RealWorld(..), _State(..))
-{-# GHC_PRAGMA INTERFACE VERSION 5 #-}
+{-# GHC_PRAGMA INTERFACE VERSION 6 #-}
interface PreludePrimIO where
import PreludeArray(_ByteArray)
import PreludeBuiltin(Char(..), Int(..), List(..), Tuple0, Tuple2, _RealWorld(..), _State(..))
-{-# GHC_PRAGMA INTERFACE VERSION 5 #-}
+{-# GHC_PRAGMA INTERFACE VERSION 6 #-}
interface PreludePrimIO where
import PreludeArray(_ByteArray)
import PreludeBuiltin(Char(..), Int(..), List(..), Tuple0, Tuple2, _RealWorld(..), _State(..))
-{-# GHC_PRAGMA INTERFACE VERSION 5 #-}
+{-# GHC_PRAGMA INTERFACE VERSION 6 #-}
interface PreludePrimIO where
import PreludeArray(_ByteArray)
import PreludeBuiltin(Char(..), Int(..), List(..), Tuple0, Tuple2, _RealWorld(..), _State(..))
-{-# GHC_PRAGMA INTERFACE VERSION 5 #-}
+{-# GHC_PRAGMA INTERFACE VERSION 6 #-}
interface Stdio where
import PreludeArray(_ByteArray)
import PreludeBuiltin(Char(..), Int(..), List(..), Tuple2, _RealWorld(..), _State(..))
{-# GHC_PRAGMA _A_ 5 _U_ 11111 _N_ _S_ "U(AP)U(P)U(P)U(P)U(P)" {_A_ 5 _U_ 22222 _N_ _N_ _N_ _N_} _N_ _N_ #-}
instance Eq _FILE
{-# GHC_PRAGMA _M_ Stdio {-dfun-} _A_ 0 _N_ _N_ _N_ _F_ _IF_ARGS_ 0 0 X 3 _!_ _TUP_2 [(_FILE -> _FILE -> Bool), (_FILE -> _FILE -> Bool)] [_CONSTM_ Eq (==) (_FILE), _CONSTM_ Eq (/=) (_FILE)] _N_
- (==) = _A_ 2 _U_ 11 _N_ _S_ "U(P)U(P)" {_A_ 2 _U_ 22 _N_ _N_ _F_ _IF_ARGS_ 0 2 XX 1 \ (u0 :: Addr#) (u1 :: Addr#) -> _#_ eqAddr# [] [u0, u1] _N_} _F_ _IF_ARGS_ 0 2 CC 3 \ (u0 :: _FILE) (u1 :: _FILE) -> case u0 of { _ALG_ _ORIG_ Stdio _FILE (u2 :: Addr#) -> case u1 of { _ALG_ _ORIG_ Stdio _FILE (u3 :: Addr#) -> _#_ eqAddr# [] [u2, u3]; _NO_DEFLT_ }; _NO_DEFLT_ } _N_,
- (/=) = _A_ 2 _U_ 11 _N_ _S_ "U(P)U(P)" {_A_ 2 _U_ 22 _N_ _N_ _F_ _IF_ARGS_ 0 2 XX 5 \ (u0 :: Addr#) (u1 :: Addr#) -> case _#_ eqAddr# [] [u0, u1] of { _ALG_ True -> _!_ False [] []; False -> _!_ True [] []; _NO_DEFLT_ } _N_} _F_ _IF_ARGS_ 0 2 CC 7 \ (u0 :: _FILE) (u1 :: _FILE) -> case u0 of { _ALG_ _ORIG_ Stdio _FILE (u2 :: Addr#) -> case u1 of { _ALG_ _ORIG_ Stdio _FILE (u3 :: Addr#) -> case _#_ eqAddr# [] [u2, u3] of { _ALG_ True -> _!_ False [] []; False -> _!_ True [] []; _NO_DEFLT_ }; _NO_DEFLT_ }; _NO_DEFLT_ } _N_ #-}
+ (==) = { _A_ 2 _U_ 11 _N_ _S_ "U(P)U(P)" {_A_ 2 _U_ 22 _N_ _N_ _F_ _IF_ARGS_ 0 2 XX 1 \ (u0 :: Addr#) (u1 :: Addr#) -> _#_ eqAddr# [] [u0, u1] _N_} _F_ _IF_ARGS_ 0 2 CC 3 \ (u0 :: _FILE) (u1 :: _FILE) -> case u0 of { _ALG_ _ORIG_ Stdio _FILE (u2 :: Addr#) -> case u1 of { _ALG_ _ORIG_ Stdio _FILE (u3 :: Addr#) -> _#_ eqAddr# [] [u2, u3]; _NO_DEFLT_ }; _NO_DEFLT_ } _N_ },
+ (/=) = { _A_ 2 _U_ 11 _N_ _S_ "U(P)U(P)" {_A_ 2 _U_ 22 _N_ _N_ _F_ _IF_ARGS_ 0 2 XX 5 \ (u0 :: Addr#) (u1 :: Addr#) -> case _#_ eqAddr# [] [u0, u1] of { _ALG_ True -> _!_ False [] []; False -> _!_ True [] []; _NO_DEFLT_ } _N_} _F_ _IF_ARGS_ 0 2 CC 7 \ (u0 :: _FILE) (u1 :: _FILE) -> case u0 of { _ALG_ _ORIG_ Stdio _FILE (u2 :: Addr#) -> case u1 of { _ALG_ _ORIG_ Stdio _FILE (u3 :: Addr#) -> case _#_ eqAddr# [] [u2, u3] of { _ALG_ True -> _!_ False [] []; False -> _!_ True [] []; _NO_DEFLT_ }; _NO_DEFLT_ }; _NO_DEFLT_ } _N_ } #-}
instance _CCallable _FILE
{-# GHC_PRAGMA _M_ Stdio {-dfun-} _A_ 0 _N_ _N_ _N_ _F_ _IF_ARGS_ 0 0 X 1 _!_ _TUP_0 [] [] _N_ #-}
instance _CReturnable _FILE
import TyArray
import PreludeGlaST
import Text
+import TyComplex
data _FILE = _FILE Addr#
instance _CCallable _FILE
-{-# GHC_PRAGMA INTERFACE VERSION 5 #-}
+{-# GHC_PRAGMA INTERFACE VERSION 6 #-}
interface Stdio where
import PreludeArray(_ByteArray)
import PreludeBuiltin(Char(..), Int(..), List(..), Tuple2, _RealWorld(..), _State(..))
{-# GHC_PRAGMA _A_ 5 _U_ 11111 _N_ _S_ "U(AP)U(P)U(P)U(P)U(P)" {_A_ 5 _U_ 22222 _N_ _N_ _N_ _N_} _N_ _N_ #-}
instance Eq _FILE
{-# GHC_PRAGMA _M_ Stdio {-dfun-} _A_ 0 _N_ _N_ _N_ _F_ _IF_ARGS_ 0 0 X 3 _!_ _TUP_2 [(_FILE -> _FILE -> Bool), (_FILE -> _FILE -> Bool)] [_CONSTM_ Eq (==) (_FILE), _CONSTM_ Eq (/=) (_FILE)] _N_
- (==) = _A_ 2 _U_ 11 _N_ _S_ "U(P)U(P)" {_A_ 2 _U_ 22 _N_ _N_ _F_ _IF_ARGS_ 0 2 XX 1 \ (u0 :: Addr#) (u1 :: Addr#) -> _#_ eqAddr# [] [u0, u1] _N_} _F_ _IF_ARGS_ 0 2 CC 3 \ (u0 :: _FILE) (u1 :: _FILE) -> case u0 of { _ALG_ _ORIG_ Stdio _FILE (u2 :: Addr#) -> case u1 of { _ALG_ _ORIG_ Stdio _FILE (u3 :: Addr#) -> _#_ eqAddr# [] [u2, u3]; _NO_DEFLT_ }; _NO_DEFLT_ } _N_,
- (/=) = _A_ 2 _U_ 11 _N_ _S_ "U(P)U(P)" {_A_ 2 _U_ 22 _N_ _N_ _F_ _IF_ARGS_ 0 2 XX 5 \ (u0 :: Addr#) (u1 :: Addr#) -> case _#_ eqAddr# [] [u0, u1] of { _ALG_ True -> _!_ False [] []; False -> _!_ True [] []; _NO_DEFLT_ } _N_} _F_ _IF_ARGS_ 0 2 CC 7 \ (u0 :: _FILE) (u1 :: _FILE) -> case u0 of { _ALG_ _ORIG_ Stdio _FILE (u2 :: Addr#) -> case u1 of { _ALG_ _ORIG_ Stdio _FILE (u3 :: Addr#) -> case _#_ eqAddr# [] [u2, u3] of { _ALG_ True -> _!_ False [] []; False -> _!_ True [] []; _NO_DEFLT_ }; _NO_DEFLT_ }; _NO_DEFLT_ } _N_ #-}
+ (==) = { _A_ 2 _U_ 11 _N_ _S_ "U(P)U(P)" {_A_ 2 _U_ 22 _N_ _N_ _F_ _IF_ARGS_ 0 2 XX 1 \ (u0 :: Addr#) (u1 :: Addr#) -> _#_ eqAddr# [] [u0, u1] _N_} _F_ _IF_ARGS_ 0 2 CC 3 \ (u0 :: _FILE) (u1 :: _FILE) -> case u0 of { _ALG_ _ORIG_ Stdio _FILE (u2 :: Addr#) -> case u1 of { _ALG_ _ORIG_ Stdio _FILE (u3 :: Addr#) -> _#_ eqAddr# [] [u2, u3]; _NO_DEFLT_ }; _NO_DEFLT_ } _N_ },
+ (/=) = { _A_ 2 _U_ 11 _N_ _S_ "U(P)U(P)" {_A_ 2 _U_ 22 _N_ _N_ _F_ _IF_ARGS_ 0 2 XX 5 \ (u0 :: Addr#) (u1 :: Addr#) -> case _#_ eqAddr# [] [u0, u1] of { _ALG_ True -> _!_ False [] []; False -> _!_ True [] []; _NO_DEFLT_ } _N_} _F_ _IF_ARGS_ 0 2 CC 7 \ (u0 :: _FILE) (u1 :: _FILE) -> case u0 of { _ALG_ _ORIG_ Stdio _FILE (u2 :: Addr#) -> case u1 of { _ALG_ _ORIG_ Stdio _FILE (u3 :: Addr#) -> case _#_ eqAddr# [] [u2, u3] of { _ALG_ True -> _!_ False [] []; False -> _!_ True [] []; _NO_DEFLT_ }; _NO_DEFLT_ }; _NO_DEFLT_ } _N_ } #-}
instance _CCallable _FILE
{-# GHC_PRAGMA _M_ Stdio {-dfun-} _A_ 0 _N_ _N_ _N_ _F_ _IF_ARGS_ 0 0 X 1 _!_ _TUP_0 [] [] _N_ #-}
instance _CReturnable _FILE
-{-# GHC_PRAGMA INTERFACE VERSION 5 #-}
+{-# GHC_PRAGMA INTERFACE VERSION 6 #-}
interface Stdio where
import PreludeArray(_ByteArray)
import PreludeBuiltin(Char(..), Int(..), List(..), Tuple2, _RealWorld(..), _State(..))
{-# GHC_PRAGMA _A_ 5 _U_ 11111 _N_ _S_ "U(AP)U(P)U(P)U(P)U(P)" {_A_ 5 _U_ 22222 _N_ _N_ _N_ _N_} _N_ _N_ #-}
instance Eq _FILE
{-# GHC_PRAGMA _M_ Stdio {-dfun-} _A_ 0 _N_ _N_ _N_ _F_ _IF_ARGS_ 0 0 X 3 _!_ _TUP_2 [(_FILE -> _FILE -> Bool), (_FILE -> _FILE -> Bool)] [_CONSTM_ Eq (==) (_FILE), _CONSTM_ Eq (/=) (_FILE)] _N_
- (==) = _A_ 2 _U_ 11 _N_ _S_ "U(P)U(P)" {_A_ 2 _U_ 22 _N_ _N_ _F_ _IF_ARGS_ 0 2 XX 1 \ (u0 :: Addr#) (u1 :: Addr#) -> _#_ eqAddr# [] [u0, u1] _N_} _F_ _IF_ARGS_ 0 2 CC 3 \ (u0 :: _FILE) (u1 :: _FILE) -> case u0 of { _ALG_ _ORIG_ Stdio _FILE (u2 :: Addr#) -> case u1 of { _ALG_ _ORIG_ Stdio _FILE (u3 :: Addr#) -> _#_ eqAddr# [] [u2, u3]; _NO_DEFLT_ }; _NO_DEFLT_ } _N_,
- (/=) = _A_ 2 _U_ 11 _N_ _S_ "U(P)U(P)" {_A_ 2 _U_ 22 _N_ _N_ _F_ _IF_ARGS_ 0 2 XX 5 \ (u0 :: Addr#) (u1 :: Addr#) -> case _#_ eqAddr# [] [u0, u1] of { _ALG_ True -> _!_ False [] []; False -> _!_ True [] []; _NO_DEFLT_ } _N_} _F_ _IF_ARGS_ 0 2 CC 7 \ (u0 :: _FILE) (u1 :: _FILE) -> case u0 of { _ALG_ _ORIG_ Stdio _FILE (u2 :: Addr#) -> case u1 of { _ALG_ _ORIG_ Stdio _FILE (u3 :: Addr#) -> case _#_ eqAddr# [] [u2, u3] of { _ALG_ True -> _!_ False [] []; False -> _!_ True [] []; _NO_DEFLT_ }; _NO_DEFLT_ }; _NO_DEFLT_ } _N_ #-}
+ (==) = { _A_ 2 _U_ 11 _N_ _S_ "U(P)U(P)" {_A_ 2 _U_ 22 _N_ _N_ _F_ _IF_ARGS_ 0 2 XX 1 \ (u0 :: Addr#) (u1 :: Addr#) -> _#_ eqAddr# [] [u0, u1] _N_} _F_ _IF_ARGS_ 0 2 CC 3 \ (u0 :: _FILE) (u1 :: _FILE) -> case u0 of { _ALG_ _ORIG_ Stdio _FILE (u2 :: Addr#) -> case u1 of { _ALG_ _ORIG_ Stdio _FILE (u3 :: Addr#) -> _#_ eqAddr# [] [u2, u3]; _NO_DEFLT_ }; _NO_DEFLT_ } _N_ },
+ (/=) = { _A_ 2 _U_ 11 _N_ _S_ "U(P)U(P)" {_A_ 2 _U_ 22 _N_ _N_ _F_ _IF_ARGS_ 0 2 XX 5 \ (u0 :: Addr#) (u1 :: Addr#) -> case _#_ eqAddr# [] [u0, u1] of { _ALG_ True -> _!_ False [] []; False -> _!_ True [] []; _NO_DEFLT_ } _N_} _F_ _IF_ARGS_ 0 2 CC 7 \ (u0 :: _FILE) (u1 :: _FILE) -> case u0 of { _ALG_ _ORIG_ Stdio _FILE (u2 :: Addr#) -> case u1 of { _ALG_ _ORIG_ Stdio _FILE (u3 :: Addr#) -> case _#_ eqAddr# [] [u2, u3] of { _ALG_ True -> _!_ False [] []; False -> _!_ True [] []; _NO_DEFLT_ }; _NO_DEFLT_ }; _NO_DEFLT_ } _N_ } #-}
instance _CCallable _FILE
{-# GHC_PRAGMA _M_ Stdio {-dfun-} _A_ 0 _N_ _N_ _N_ _F_ _IF_ARGS_ 0 0 X 1 _!_ _TUP_0 [] [] _N_ #-}
instance _CReturnable _FILE
-{-# GHC_PRAGMA INTERFACE VERSION 5 #-}
+{-# GHC_PRAGMA INTERFACE VERSION 6 #-}
interface Stdio where
import PreludeArray(_ByteArray)
import PreludeBuiltin(Char(..), Int(..), List(..), Tuple2, _RealWorld(..), _State(..))
{-# GHC_PRAGMA _A_ 5 _U_ 11111 _N_ _S_ "U(AP)U(P)U(P)U(P)U(P)" {_A_ 5 _U_ 22222 _N_ _N_ _N_ _N_} _N_ _N_ #-}
instance Eq _FILE
{-# GHC_PRAGMA _M_ Stdio {-dfun-} _A_ 0 _N_ _N_ _N_ _F_ _IF_ARGS_ 0 0 X 3 _!_ _TUP_2 [(_FILE -> _FILE -> Bool), (_FILE -> _FILE -> Bool)] [_CONSTM_ Eq (==) (_FILE), _CONSTM_ Eq (/=) (_FILE)] _N_
- (==) = _A_ 2 _U_ 11 _N_ _S_ "U(P)U(P)" {_A_ 2 _U_ 22 _N_ _N_ _F_ _IF_ARGS_ 0 2 XX 1 \ (u0 :: Addr#) (u1 :: Addr#) -> _#_ eqAddr# [] [u0, u1] _N_} _F_ _IF_ARGS_ 0 2 CC 3 \ (u0 :: _FILE) (u1 :: _FILE) -> case u0 of { _ALG_ _ORIG_ Stdio _FILE (u2 :: Addr#) -> case u1 of { _ALG_ _ORIG_ Stdio _FILE (u3 :: Addr#) -> _#_ eqAddr# [] [u2, u3]; _NO_DEFLT_ }; _NO_DEFLT_ } _N_,
- (/=) = _A_ 2 _U_ 11 _N_ _S_ "U(P)U(P)" {_A_ 2 _U_ 22 _N_ _N_ _F_ _IF_ARGS_ 0 2 XX 5 \ (u0 :: Addr#) (u1 :: Addr#) -> case _#_ eqAddr# [] [u0, u1] of { _ALG_ True -> _!_ False [] []; False -> _!_ True [] []; _NO_DEFLT_ } _N_} _F_ _IF_ARGS_ 0 2 CC 7 \ (u0 :: _FILE) (u1 :: _FILE) -> case u0 of { _ALG_ _ORIG_ Stdio _FILE (u2 :: Addr#) -> case u1 of { _ALG_ _ORIG_ Stdio _FILE (u3 :: Addr#) -> case _#_ eqAddr# [] [u2, u3] of { _ALG_ True -> _!_ False [] []; False -> _!_ True [] []; _NO_DEFLT_ }; _NO_DEFLT_ }; _NO_DEFLT_ } _N_ #-}
+ (==) = { _A_ 2 _U_ 11 _N_ _S_ "U(P)U(P)" {_A_ 2 _U_ 22 _N_ _N_ _F_ _IF_ARGS_ 0 2 XX 1 \ (u0 :: Addr#) (u1 :: Addr#) -> _#_ eqAddr# [] [u0, u1] _N_} _F_ _IF_ARGS_ 0 2 CC 3 \ (u0 :: _FILE) (u1 :: _FILE) -> case u0 of { _ALG_ _ORIG_ Stdio _FILE (u2 :: Addr#) -> case u1 of { _ALG_ _ORIG_ Stdio _FILE (u3 :: Addr#) -> _#_ eqAddr# [] [u2, u3]; _NO_DEFLT_ }; _NO_DEFLT_ } _N_ },
+ (/=) = { _A_ 2 _U_ 11 _N_ _S_ "U(P)U(P)" {_A_ 2 _U_ 22 _N_ _N_ _F_ _IF_ARGS_ 0 2 XX 5 \ (u0 :: Addr#) (u1 :: Addr#) -> case _#_ eqAddr# [] [u0, u1] of { _ALG_ True -> _!_ False [] []; False -> _!_ True [] []; _NO_DEFLT_ } _N_} _F_ _IF_ARGS_ 0 2 CC 7 \ (u0 :: _FILE) (u1 :: _FILE) -> case u0 of { _ALG_ _ORIG_ Stdio _FILE (u2 :: Addr#) -> case u1 of { _ALG_ _ORIG_ Stdio _FILE (u3 :: Addr#) -> case _#_ eqAddr# [] [u2, u3] of { _ALG_ True -> _!_ False [] []; False -> _!_ True [] []; _NO_DEFLT_ }; _NO_DEFLT_ }; _NO_DEFLT_ } _N_ } #-}
instance _CCallable _FILE
{-# GHC_PRAGMA _M_ Stdio {-dfun-} _A_ 0 _N_ _N_ _N_ _F_ _IF_ARGS_ 0 0 X 1 _!_ _TUP_0 [] [] _N_ #-}
instance _CReturnable _FILE
-{-# GHC_PRAGMA INTERFACE VERSION 5 #-}
+{-# GHC_PRAGMA INTERFACE VERSION 6 #-}
interface Stdio where
import PreludeArray(_ByteArray)
import PreludeBuiltin(Char(..), Int(..), List(..), Tuple2, _RealWorld(..), _State(..))
{-# GHC_PRAGMA _A_ 5 _U_ 11111 _N_ _S_ "U(AP)U(P)U(P)U(P)U(P)" {_A_ 5 _U_ 22222 _N_ _N_ _N_ _N_} _N_ _N_ #-}
instance Eq _FILE
{-# GHC_PRAGMA _M_ Stdio {-dfun-} _A_ 0 _N_ _N_ _N_ _F_ _IF_ARGS_ 0 0 X 3 _!_ _TUP_2 [(_FILE -> _FILE -> Bool), (_FILE -> _FILE -> Bool)] [_CONSTM_ Eq (==) (_FILE), _CONSTM_ Eq (/=) (_FILE)] _N_
- (==) = _A_ 2 _U_ 11 _N_ _S_ "U(P)U(P)" {_A_ 2 _U_ 22 _N_ _N_ _F_ _IF_ARGS_ 0 2 XX 1 \ (u0 :: Addr#) (u1 :: Addr#) -> _#_ eqAddr# [] [u0, u1] _N_} _F_ _IF_ARGS_ 0 2 CC 3 \ (u0 :: _FILE) (u1 :: _FILE) -> case u0 of { _ALG_ _ORIG_ Stdio _FILE (u2 :: Addr#) -> case u1 of { _ALG_ _ORIG_ Stdio _FILE (u3 :: Addr#) -> _#_ eqAddr# [] [u2, u3]; _NO_DEFLT_ }; _NO_DEFLT_ } _N_,
- (/=) = _A_ 2 _U_ 11 _N_ _S_ "U(P)U(P)" {_A_ 2 _U_ 22 _N_ _N_ _F_ _IF_ARGS_ 0 2 XX 5 \ (u0 :: Addr#) (u1 :: Addr#) -> case _#_ eqAddr# [] [u0, u1] of { _ALG_ True -> _!_ False [] []; False -> _!_ True [] []; _NO_DEFLT_ } _N_} _F_ _IF_ARGS_ 0 2 CC 7 \ (u0 :: _FILE) (u1 :: _FILE) -> case u0 of { _ALG_ _ORIG_ Stdio _FILE (u2 :: Addr#) -> case u1 of { _ALG_ _ORIG_ Stdio _FILE (u3 :: Addr#) -> case _#_ eqAddr# [] [u2, u3] of { _ALG_ True -> _!_ False [] []; False -> _!_ True [] []; _NO_DEFLT_ }; _NO_DEFLT_ }; _NO_DEFLT_ } _N_ #-}
+ (==) = { _A_ 2 _U_ 11 _N_ _S_ "U(P)U(P)" {_A_ 2 _U_ 22 _N_ _N_ _F_ _IF_ARGS_ 0 2 XX 1 \ (u0 :: Addr#) (u1 :: Addr#) -> _#_ eqAddr# [] [u0, u1] _N_} _F_ _IF_ARGS_ 0 2 CC 3 \ (u0 :: _FILE) (u1 :: _FILE) -> case u0 of { _ALG_ _ORIG_ Stdio _FILE (u2 :: Addr#) -> case u1 of { _ALG_ _ORIG_ Stdio _FILE (u3 :: Addr#) -> _#_ eqAddr# [] [u2, u3]; _NO_DEFLT_ }; _NO_DEFLT_ } _N_ },
+ (/=) = { _A_ 2 _U_ 11 _N_ _S_ "U(P)U(P)" {_A_ 2 _U_ 22 _N_ _N_ _F_ _IF_ARGS_ 0 2 XX 5 \ (u0 :: Addr#) (u1 :: Addr#) -> case _#_ eqAddr# [] [u0, u1] of { _ALG_ True -> _!_ False [] []; False -> _!_ True [] []; _NO_DEFLT_ } _N_} _F_ _IF_ARGS_ 0 2 CC 7 \ (u0 :: _FILE) (u1 :: _FILE) -> case u0 of { _ALG_ _ORIG_ Stdio _FILE (u2 :: Addr#) -> case u1 of { _ALG_ _ORIG_ Stdio _FILE (u3 :: Addr#) -> case _#_ eqAddr# [] [u2, u3] of { _ALG_ True -> _!_ False [] []; False -> _!_ True [] []; _NO_DEFLT_ }; _NO_DEFLT_ }; _NO_DEFLT_ } _N_ } #-}
instance _CCallable _FILE
{-# GHC_PRAGMA _M_ Stdio {-dfun-} _A_ 0 _N_ _N_ _N_ _F_ _IF_ARGS_ 0 0 X 1 _!_ _TUP_0 [] [] _N_ #-}
instance _CReturnable _FILE
-{-# GHC_PRAGMA INTERFACE VERSION 5 #-}
+{-# GHC_PRAGMA INTERFACE VERSION 6 #-}
interface LibCPUTime where
import PreludeIOError(IOError13)
import PreludeMonadicIO(Either)
-{-# GHC_PRAGMA INTERFACE VERSION 5 #-}
+{-# GHC_PRAGMA INTERFACE VERSION 6 #-}
interface LibCPUTime where
import PreludeIOError(IOError13)
import PreludeMonadicIO(Either)
-{-# GHC_PRAGMA INTERFACE VERSION 5 #-}
+{-# GHC_PRAGMA INTERFACE VERSION 6 #-}
interface LibCPUTime where
import PreludeIOError(IOError13)
import PreludeMonadicIO(Either)
-{-# GHC_PRAGMA INTERFACE VERSION 5 #-}
+{-# GHC_PRAGMA INTERFACE VERSION 6 #-}
interface LibCPUTime where
import PreludeIOError(IOError13)
import PreludeMonadicIO(Either)
-{-# GHC_PRAGMA INTERFACE VERSION 5 #-}
+{-# GHC_PRAGMA INTERFACE VERSION 6 #-}
interface LibCPUTime where
import PreludeIOError(IOError13)
import PreludeMonadicIO(Either)
-{-# GHC_PRAGMA INTERFACE VERSION 5 #-}
+{-# GHC_PRAGMA INTERFACE VERSION 6 #-}
interface LibDirectory where
import PreludeIOError(IOError13)
import PreludeMonadicIO(Either)
-{-# GHC_PRAGMA INTERFACE VERSION 5 #-}
+{-# GHC_PRAGMA INTERFACE VERSION 6 #-}
interface LibDirectory where
import PreludeIOError(IOError13)
import PreludeMonadicIO(Either)
-{-# GHC_PRAGMA INTERFACE VERSION 5 #-}
+{-# GHC_PRAGMA INTERFACE VERSION 6 #-}
interface LibDirectory where
import PreludeIOError(IOError13)
import PreludeMonadicIO(Either)
-{-# GHC_PRAGMA INTERFACE VERSION 5 #-}
+{-# GHC_PRAGMA INTERFACE VERSION 6 #-}
interface LibDirectory where
import PreludeIOError(IOError13)
import PreludeMonadicIO(Either)
-{-# GHC_PRAGMA INTERFACE VERSION 5 #-}
+{-# GHC_PRAGMA INTERFACE VERSION 6 #-}
interface LibDirectory where
import PreludeIOError(IOError13)
import PreludeMonadicIO(Either)
-{-# GHC_PRAGMA INTERFACE VERSION 5 #-}
+{-# GHC_PRAGMA INTERFACE VERSION 6 #-}
interface LibPosix where
import LibDirectory(getCurrentDirectory, removeDirectory, setCurrentDirectory)
import LibPosixDB(GroupEntry(..), UserEntry(..), getGroupEntryForID, getGroupEntryForName, getUserEntryForID, getUserEntryForName, groupID, groupMembers, groupName, homeDirectory, userGroupID, userID, userName, userShell)
{-# GHC_PRAGMA _A_ 2 _U_ 11 _N_ _S_ "U(AP)E" {_A_ 2 _U_ 21 _N_ _N_ _N_ _N_} _N_ _N_ #-}
instance Eq ProcessStatus
{-# GHC_PRAGMA _M_ LibPosixProcPrim {-dfun-} _A_ 0 _N_ _N_ _N_ _F_ _IF_ARGS_ 0 0 X 3 _!_ _TUP_2 [(ProcessStatus -> ProcessStatus -> Bool), (ProcessStatus -> ProcessStatus -> Bool)] [_CONSTM_ Eq (==) (ProcessStatus), _CONSTM_ Eq (/=) (ProcessStatus)] _N_
- (==) = _A_ 2 _U_ 11 _N_ _S_ "SS" _N_ _N_,
- (/=) = _A_ 2 _U_ 11 _N_ _S_ "SS" _N_ _N_ #-}
+ (==) = { _A_ 2 _U_ 11 _N_ _S_ "SS" _N_ _N_ },
+ (/=) = { _A_ 2 _U_ 11 _N_ _S_ "SS" _N_ _N_ } #-}
instance Eq ExitCode
{-# GHC_PRAGMA _M_ LibSystem {-dfun-} _A_ 0 _N_ _N_ _N_ _F_ _IF_ARGS_ 0 0 X 3 _!_ _TUP_2 [(ExitCode -> ExitCode -> Bool), (ExitCode -> ExitCode -> Bool)] [_CONSTM_ Eq (==) (ExitCode), _CONSTM_ Eq (/=) (ExitCode)] _N_
- (==) = _A_ 2 _U_ 22 _N_ _S_ "SS" _N_ _N_,
- (/=) = _A_ 2 _U_ 22 _N_ _S_ "SS" _N_ _N_ #-}
+ (==) = { _A_ 2 _U_ 22 _N_ _S_ "SS" _N_ _N_ },
+ (/=) = { _A_ 2 _U_ 22 _N_ _S_ "SS" _N_ _N_ } #-}
instance Ord ProcessStatus
{-# GHC_PRAGMA _M_ LibPosixProcPrim {-dfun-} _A_ 0 _N_ _N_ _N_ _F_ _IF_ARGS_ 0 0 X 9 _!_ _TUP_8 [{{Eq ProcessStatus}}, (ProcessStatus -> ProcessStatus -> Bool), (ProcessStatus -> ProcessStatus -> Bool), (ProcessStatus -> ProcessStatus -> Bool), (ProcessStatus -> ProcessStatus -> Bool), (ProcessStatus -> ProcessStatus -> ProcessStatus), (ProcessStatus -> ProcessStatus -> ProcessStatus), (ProcessStatus -> ProcessStatus -> _CMP_TAG)] [_DFUN_ Eq (ProcessStatus), _CONSTM_ Ord (<) (ProcessStatus), _CONSTM_ Ord (<=) (ProcessStatus), _CONSTM_ Ord (>=) (ProcessStatus), _CONSTM_ Ord (>) (ProcessStatus), _CONSTM_ Ord max (ProcessStatus), _CONSTM_ Ord min (ProcessStatus), _CONSTM_ Ord _tagCmp (ProcessStatus)] _N_
- (<) = _A_ 2 _U_ 22 _N_ _S_ "SS" _N_ _N_,
- (<=) = _A_ 2 _U_ 22 _N_ _S_ "SS" _N_ _N_,
- (>=) = _A_ 2 _U_ 22 _N_ _S_ "SS" _N_ _N_,
- (>) = _A_ 2 _U_ 22 _N_ _S_ "SS" _N_ _N_,
- max = _A_ 2 _U_ 22 _N_ _S_ "SS" _N_ _N_,
- min = _A_ 2 _U_ 22 _N_ _S_ "SS" _N_ _N_,
- _tagCmp = _A_ 2 _U_ 22 _N_ _S_ "SS" _N_ _N_ #-}
+ (<) = { _A_ 2 _U_ 22 _N_ _S_ "SS" _N_ _N_ },
+ (<=) = { _A_ 2 _U_ 22 _N_ _S_ "SS" _N_ _N_ },
+ (>=) = { _A_ 2 _U_ 22 _N_ _S_ "SS" _N_ _N_ },
+ (>) = { _A_ 2 _U_ 22 _N_ _S_ "SS" _N_ _N_ },
+ max = { _A_ 2 _U_ 22 _N_ _S_ "SS" _N_ _N_ },
+ min = { _A_ 2 _U_ 22 _N_ _S_ "SS" _N_ _N_ },
+ _tagCmp = { _A_ 2 _U_ 22 _N_ _S_ "SS" _N_ _N_ } #-}
instance Ord ExitCode
{-# GHC_PRAGMA _M_ LibSystem {-dfun-} _A_ 0 _N_ _N_ _N_ _F_ _IF_ARGS_ 0 0 X 9 _!_ _TUP_8 [{{Eq ExitCode}}, (ExitCode -> ExitCode -> Bool), (ExitCode -> ExitCode -> Bool), (ExitCode -> ExitCode -> Bool), (ExitCode -> ExitCode -> Bool), (ExitCode -> ExitCode -> ExitCode), (ExitCode -> ExitCode -> ExitCode), (ExitCode -> ExitCode -> _CMP_TAG)] [_DFUN_ Eq (ExitCode), _CONSTM_ Ord (<) (ExitCode), _CONSTM_ Ord (<=) (ExitCode), _CONSTM_ Ord (>=) (ExitCode), _CONSTM_ Ord (>) (ExitCode), _CONSTM_ Ord max (ExitCode), _CONSTM_ Ord min (ExitCode), _CONSTM_ Ord _tagCmp (ExitCode)] _N_
- (<) = _A_ 2 _U_ 22 _N_ _S_ "SS" _N_ _N_,
- (<=) = _A_ 2 _U_ 22 _N_ _S_ "SS" _N_ _N_,
- (>=) = _A_ 2 _U_ 22 _N_ _S_ "SS" _N_ _N_,
- (>) = _A_ 2 _U_ 22 _N_ _S_ "SS" _N_ _N_,
- max = _A_ 2 _U_ 22 _N_ _S_ "SS" _N_ _N_,
- min = _A_ 2 _U_ 22 _N_ _S_ "SS" _N_ _N_,
- _tagCmp = _A_ 2 _U_ 22 _N_ _S_ "SS" _N_ _N_ #-}
+ (<) = { _A_ 2 _U_ 22 _N_ _S_ "SS" _N_ _N_ },
+ (<=) = { _A_ 2 _U_ 22 _N_ _S_ "SS" _N_ _N_ },
+ (>=) = { _A_ 2 _U_ 22 _N_ _S_ "SS" _N_ _N_ },
+ (>) = { _A_ 2 _U_ 22 _N_ _S_ "SS" _N_ _N_ },
+ max = { _A_ 2 _U_ 22 _N_ _S_ "SS" _N_ _N_ },
+ min = { _A_ 2 _U_ 22 _N_ _S_ "SS" _N_ _N_ },
+ _tagCmp = { _A_ 2 _U_ 22 _N_ _S_ "SS" _N_ _N_ } #-}
instance Text ProcessStatus
{-# GHC_PRAGMA _M_ LibPosixProcPrim {-dfun-} _A_ 0 _N_ _N_ _N_ _F_ _IF_ARGS_ 0 0 X 5 _!_ _TUP_4 [(Int -> [Char] -> [(ProcessStatus, [Char])]), (Int -> ProcessStatus -> [Char] -> [Char]), ([Char] -> [([ProcessStatus], [Char])]), ([ProcessStatus] -> [Char] -> [Char])] [_CONSTM_ Text readsPrec (ProcessStatus), _CONSTM_ Text showsPrec (ProcessStatus), _CONSTM_ Text readList (ProcessStatus), _CONSTM_ Text showList (ProcessStatus)] _N_
- readsPrec = _A_ 2 _U_ 12 _N_ _S_ "U(P)L" {_A_ 2 _U_ 22 _N_ _N_ _N_ _N_} _N_ _N_,
- showsPrec = _A_ 2 _U_ 112 _N_ _S_ "LS" _N_ _N_,
- readList = _A_ 0 _U_ 2 _N_ _N_ _N_ _N_,
- showList = _A_ 0 _U_ 12 _N_ _N_ _N_ _N_ #-}
+ readsPrec = { _A_ 2 _U_ 12 _N_ _S_ "U(P)L" {_A_ 2 _U_ 22 _N_ _N_ _N_ _N_} _N_ _N_ },
+ showsPrec = { _A_ 2 _U_ 112 _N_ _S_ "LS" _N_ _N_ },
+ readList = { _A_ 0 _U_ 2 _N_ _N_ _N_ _N_ },
+ showList = { _A_ 0 _U_ 12 _N_ _N_ _N_ _N_ } #-}
instance Text ExitCode
{-# GHC_PRAGMA _M_ LibSystem {-dfun-} _A_ 0 _N_ _N_ _N_ _F_ _IF_ARGS_ 0 0 X 5 _!_ _TUP_4 [(Int -> [Char] -> [(ExitCode, [Char])]), (Int -> ExitCode -> [Char] -> [Char]), ([Char] -> [([ExitCode], [Char])]), ([ExitCode] -> [Char] -> [Char])] [_CONSTM_ Text readsPrec (ExitCode), _CONSTM_ Text showsPrec (ExitCode), _CONSTM_ Text readList (ExitCode), _CONSTM_ Text showList (ExitCode)] _N_
- readsPrec = _A_ 2 _U_ 12 _N_ _N_ _N_ _N_,
- showsPrec = _A_ 2 _U_ 112 _N_ _S_ "LS" _N_ _N_,
- readList = _A_ 0 _U_ 2 _N_ _N_ _N_ _N_,
- showList = _A_ 0 _U_ 12 _N_ _N_ _N_ _N_ #-}
+ readsPrec = { _A_ 2 _U_ 12 _N_ _N_ _N_ _N_ },
+ showsPrec = { _A_ 2 _U_ 112 _N_ _S_ "LS" _N_ _N_ },
+ readList = { _A_ 0 _U_ 2 _N_ _N_ _N_ _N_ },
+ showList = { _A_ 0 _U_ 12 _N_ _N_ _N_ _N_ } #-}
-{-# GHC_PRAGMA INTERFACE VERSION 5 #-}
+{-# GHC_PRAGMA INTERFACE VERSION 6 #-}
interface LibPosixDB where
import PreludeIOError(IOError13)
import PreludeMonadicIO(Either)
-{-# GHC_PRAGMA INTERFACE VERSION 5 #-}
+{-# GHC_PRAGMA INTERFACE VERSION 6 #-}
interface LibPosixDB where
import PreludeIOError(IOError13)
import PreludeMonadicIO(Either)
-{-# GHC_PRAGMA INTERFACE VERSION 5 #-}
+{-# GHC_PRAGMA INTERFACE VERSION 6 #-}
interface LibPosixDB where
import PreludeIOError(IOError13)
import PreludeMonadicIO(Either)
-{-# GHC_PRAGMA INTERFACE VERSION 5 #-}
+{-# GHC_PRAGMA INTERFACE VERSION 6 #-}
interface LibPosixDB where
import PreludeIOError(IOError13)
import PreludeMonadicIO(Either)
-{-# GHC_PRAGMA INTERFACE VERSION 5 #-}
+{-# GHC_PRAGMA INTERFACE VERSION 6 #-}
interface LibPosixDB where
import PreludeIOError(IOError13)
import PreludeMonadicIO(Either)
-{-# GHC_PRAGMA INTERFACE VERSION 5 #-}
+{-# GHC_PRAGMA INTERFACE VERSION 6 #-}
interface LibPosixErr where
import PreludeIOError(IOError13)
import PreludeMonadicIO(Either)
-{-# GHC_PRAGMA INTERFACE VERSION 5 #-}
+{-# GHC_PRAGMA INTERFACE VERSION 6 #-}
interface LibPosixErr where
import PreludeIOError(IOError13)
import PreludeMonadicIO(Either)
-{-# GHC_PRAGMA INTERFACE VERSION 5 #-}
+{-# GHC_PRAGMA INTERFACE VERSION 6 #-}
interface LibPosixErr where
import PreludeIOError(IOError13)
import PreludeMonadicIO(Either)
-{-# GHC_PRAGMA INTERFACE VERSION 5 #-}
+{-# GHC_PRAGMA INTERFACE VERSION 6 #-}
interface LibPosixErr where
import PreludeIOError(IOError13)
import PreludeMonadicIO(Either)
-{-# GHC_PRAGMA INTERFACE VERSION 5 #-}
+{-# GHC_PRAGMA INTERFACE VERSION 6 #-}
interface LibPosixErr where
import PreludeIOError(IOError13)
import PreludeMonadicIO(Either)
-{-# GHC_PRAGMA INTERFACE VERSION 5 #-}
+{-# GHC_PRAGMA INTERFACE VERSION 6 #-}
interface LibPosixFiles where
import LibDirectory(removeDirectory)
import PreludeArray(_ByteArray)
-{-# GHC_PRAGMA INTERFACE VERSION 5 #-}
+{-# GHC_PRAGMA INTERFACE VERSION 6 #-}
interface LibPosixFiles where
import LibDirectory(removeDirectory)
import PreludeArray(_ByteArray)
-{-# GHC_PRAGMA INTERFACE VERSION 5 #-}
+{-# GHC_PRAGMA INTERFACE VERSION 6 #-}
interface LibPosixFiles where
import LibDirectory(removeDirectory)
import PreludeArray(_ByteArray)
-{-# GHC_PRAGMA INTERFACE VERSION 5 #-}
+{-# GHC_PRAGMA INTERFACE VERSION 6 #-}
interface LibPosixFiles where
import LibDirectory(removeDirectory)
import PreludeArray(_ByteArray)
-{-# GHC_PRAGMA INTERFACE VERSION 5 #-}
+{-# GHC_PRAGMA INTERFACE VERSION 6 #-}
interface LibPosixFiles where
import LibDirectory(removeDirectory)
import PreludeArray(_ByteArray)
-{-# GHC_PRAGMA INTERFACE VERSION 5 #-}
+{-# GHC_PRAGMA INTERFACE VERSION 6 #-}
interface LibPosixIO where
import PreludeIOError(IOError13)
import PreludeMonadicIO(Either)
-{-# GHC_PRAGMA INTERFACE VERSION 5 #-}
+{-# GHC_PRAGMA INTERFACE VERSION 6 #-}
interface LibPosixIO where
import PreludeIOError(IOError13)
import PreludeMonadicIO(Either)
-{-# GHC_PRAGMA INTERFACE VERSION 5 #-}
+{-# GHC_PRAGMA INTERFACE VERSION 6 #-}
interface LibPosixIO where
import PreludeIOError(IOError13)
import PreludeMonadicIO(Either)
-{-# GHC_PRAGMA INTERFACE VERSION 5 #-}
+{-# GHC_PRAGMA INTERFACE VERSION 6 #-}
interface LibPosixIO where
import PreludeIOError(IOError13)
import PreludeMonadicIO(Either)
-{-# GHC_PRAGMA INTERFACE VERSION 5 #-}
+{-# GHC_PRAGMA INTERFACE VERSION 6 #-}
interface LibPosixIO where
import PreludeIOError(IOError13)
import PreludeMonadicIO(Either)
-{-# GHC_PRAGMA INTERFACE VERSION 5 #-}
+{-# GHC_PRAGMA INTERFACE VERSION 6 #-}
interface LibPosixProcEnv where
import PreludeArray(_ByteArray)
import PreludeIOError(IOError13)
-{-# GHC_PRAGMA INTERFACE VERSION 5 #-}
+{-# GHC_PRAGMA INTERFACE VERSION 6 #-}
interface LibPosixProcEnv where
import PreludeArray(_ByteArray)
import PreludeIOError(IOError13)
-{-# GHC_PRAGMA INTERFACE VERSION 5 #-}
+{-# GHC_PRAGMA INTERFACE VERSION 6 #-}
interface LibPosixProcEnv where
import PreludeArray(_ByteArray)
import PreludeIOError(IOError13)
-{-# GHC_PRAGMA INTERFACE VERSION 5 #-}
+{-# GHC_PRAGMA INTERFACE VERSION 6 #-}
interface LibPosixProcEnv where
import PreludeArray(_ByteArray)
import PreludeIOError(IOError13)
-{-# GHC_PRAGMA INTERFACE VERSION 5 #-}
+{-# GHC_PRAGMA INTERFACE VERSION 6 #-}
interface LibPosixProcEnv where
import PreludeArray(_ByteArray)
import PreludeIOError(IOError13)
-{-# GHC_PRAGMA INTERFACE VERSION 5 #-}
+{-# GHC_PRAGMA INTERFACE VERSION 6 #-}
interface LibPosixProcPrim where
import LibSystem(ExitCode)
import PreludeArray(_ByteArray)
{-# GHC_PRAGMA _A_ 0 _N_ _N_ _N_ _N_ _N_ #-}
instance Eq ProcessStatus
{-# GHC_PRAGMA _M_ LibPosixProcPrim {-dfun-} _A_ 0 _N_ _N_ _N_ _F_ _IF_ARGS_ 0 0 X 3 _!_ _TUP_2 [(ProcessStatus -> ProcessStatus -> Bool), (ProcessStatus -> ProcessStatus -> Bool)] [_CONSTM_ Eq (==) (ProcessStatus), _CONSTM_ Eq (/=) (ProcessStatus)] _N_
- (==) = _A_ 2 _U_ 11 _N_ _S_ "SS" _N_ _N_,
- (/=) = _A_ 2 _U_ 11 _N_ _S_ "SS" _N_ _N_ #-}
+ (==) = { _A_ 2 _U_ 11 _N_ _S_ "SS" _N_ _N_ },
+ (/=) = { _A_ 2 _U_ 11 _N_ _S_ "SS" _N_ _N_ } #-}
instance Eq ExitCode
{-# GHC_PRAGMA _M_ LibSystem {-dfun-} _A_ 0 _N_ _N_ _N_ _F_ _IF_ARGS_ 0 0 X 3 _!_ _TUP_2 [(ExitCode -> ExitCode -> Bool), (ExitCode -> ExitCode -> Bool)] [_CONSTM_ Eq (==) (ExitCode), _CONSTM_ Eq (/=) (ExitCode)] _N_
- (==) = _A_ 2 _U_ 22 _N_ _S_ "SS" _N_ _N_,
- (/=) = _A_ 2 _U_ 22 _N_ _S_ "SS" _N_ _N_ #-}
+ (==) = { _A_ 2 _U_ 22 _N_ _S_ "SS" _N_ _N_ },
+ (/=) = { _A_ 2 _U_ 22 _N_ _S_ "SS" _N_ _N_ } #-}
instance Ord ProcessStatus
{-# GHC_PRAGMA _M_ LibPosixProcPrim {-dfun-} _A_ 0 _N_ _N_ _N_ _F_ _IF_ARGS_ 0 0 X 9 _!_ _TUP_8 [{{Eq ProcessStatus}}, (ProcessStatus -> ProcessStatus -> Bool), (ProcessStatus -> ProcessStatus -> Bool), (ProcessStatus -> ProcessStatus -> Bool), (ProcessStatus -> ProcessStatus -> Bool), (ProcessStatus -> ProcessStatus -> ProcessStatus), (ProcessStatus -> ProcessStatus -> ProcessStatus), (ProcessStatus -> ProcessStatus -> _CMP_TAG)] [_DFUN_ Eq (ProcessStatus), _CONSTM_ Ord (<) (ProcessStatus), _CONSTM_ Ord (<=) (ProcessStatus), _CONSTM_ Ord (>=) (ProcessStatus), _CONSTM_ Ord (>) (ProcessStatus), _CONSTM_ Ord max (ProcessStatus), _CONSTM_ Ord min (ProcessStatus), _CONSTM_ Ord _tagCmp (ProcessStatus)] _N_
- (<) = _A_ 2 _U_ 22 _N_ _S_ "SS" _N_ _N_,
- (<=) = _A_ 2 _U_ 22 _N_ _S_ "SS" _N_ _N_,
- (>=) = _A_ 2 _U_ 22 _N_ _S_ "SS" _N_ _N_,
- (>) = _A_ 2 _U_ 22 _N_ _S_ "SS" _N_ _N_,
- max = _A_ 2 _U_ 22 _N_ _S_ "SS" _N_ _N_,
- min = _A_ 2 _U_ 22 _N_ _S_ "SS" _N_ _N_,
- _tagCmp = _A_ 2 _U_ 22 _N_ _S_ "SS" _N_ _N_ #-}
+ (<) = { _A_ 2 _U_ 22 _N_ _S_ "SS" _N_ _N_ },
+ (<=) = { _A_ 2 _U_ 22 _N_ _S_ "SS" _N_ _N_ },
+ (>=) = { _A_ 2 _U_ 22 _N_ _S_ "SS" _N_ _N_ },
+ (>) = { _A_ 2 _U_ 22 _N_ _S_ "SS" _N_ _N_ },
+ max = { _A_ 2 _U_ 22 _N_ _S_ "SS" _N_ _N_ },
+ min = { _A_ 2 _U_ 22 _N_ _S_ "SS" _N_ _N_ },
+ _tagCmp = { _A_ 2 _U_ 22 _N_ _S_ "SS" _N_ _N_ } #-}
instance Ord ExitCode
{-# GHC_PRAGMA _M_ LibSystem {-dfun-} _A_ 0 _N_ _N_ _N_ _F_ _IF_ARGS_ 0 0 X 9 _!_ _TUP_8 [{{Eq ExitCode}}, (ExitCode -> ExitCode -> Bool), (ExitCode -> ExitCode -> Bool), (ExitCode -> ExitCode -> Bool), (ExitCode -> ExitCode -> Bool), (ExitCode -> ExitCode -> ExitCode), (ExitCode -> ExitCode -> ExitCode), (ExitCode -> ExitCode -> _CMP_TAG)] [_DFUN_ Eq (ExitCode), _CONSTM_ Ord (<) (ExitCode), _CONSTM_ Ord (<=) (ExitCode), _CONSTM_ Ord (>=) (ExitCode), _CONSTM_ Ord (>) (ExitCode), _CONSTM_ Ord max (ExitCode), _CONSTM_ Ord min (ExitCode), _CONSTM_ Ord _tagCmp (ExitCode)] _N_
- (<) = _A_ 2 _U_ 22 _N_ _S_ "SS" _N_ _N_,
- (<=) = _A_ 2 _U_ 22 _N_ _S_ "SS" _N_ _N_,
- (>=) = _A_ 2 _U_ 22 _N_ _S_ "SS" _N_ _N_,
- (>) = _A_ 2 _U_ 22 _N_ _S_ "SS" _N_ _N_,
- max = _A_ 2 _U_ 22 _N_ _S_ "SS" _N_ _N_,
- min = _A_ 2 _U_ 22 _N_ _S_ "SS" _N_ _N_,
- _tagCmp = _A_ 2 _U_ 22 _N_ _S_ "SS" _N_ _N_ #-}
+ (<) = { _A_ 2 _U_ 22 _N_ _S_ "SS" _N_ _N_ },
+ (<=) = { _A_ 2 _U_ 22 _N_ _S_ "SS" _N_ _N_ },
+ (>=) = { _A_ 2 _U_ 22 _N_ _S_ "SS" _N_ _N_ },
+ (>) = { _A_ 2 _U_ 22 _N_ _S_ "SS" _N_ _N_ },
+ max = { _A_ 2 _U_ 22 _N_ _S_ "SS" _N_ _N_ },
+ min = { _A_ 2 _U_ 22 _N_ _S_ "SS" _N_ _N_ },
+ _tagCmp = { _A_ 2 _U_ 22 _N_ _S_ "SS" _N_ _N_ } #-}
instance Text ProcessStatus
{-# GHC_PRAGMA _M_ LibPosixProcPrim {-dfun-} _A_ 0 _N_ _N_ _N_ _F_ _IF_ARGS_ 0 0 X 5 _!_ _TUP_4 [(Int -> [Char] -> [(ProcessStatus, [Char])]), (Int -> ProcessStatus -> [Char] -> [Char]), ([Char] -> [([ProcessStatus], [Char])]), ([ProcessStatus] -> [Char] -> [Char])] [_CONSTM_ Text readsPrec (ProcessStatus), _CONSTM_ Text showsPrec (ProcessStatus), _CONSTM_ Text readList (ProcessStatus), _CONSTM_ Text showList (ProcessStatus)] _N_
- readsPrec = _A_ 2 _U_ 12 _N_ _S_ "U(P)L" {_A_ 2 _U_ 22 _N_ _N_ _N_ _N_} _N_ _N_,
- showsPrec = _A_ 2 _U_ 112 _N_ _S_ "LS" _N_ _N_,
- readList = _A_ 0 _U_ 2 _N_ _N_ _N_ _N_,
- showList = _A_ 0 _U_ 12 _N_ _N_ _N_ _N_ #-}
+ readsPrec = { _A_ 2 _U_ 12 _N_ _S_ "U(P)L" {_A_ 2 _U_ 22 _N_ _N_ _N_ _N_} _N_ _N_ },
+ showsPrec = { _A_ 2 _U_ 112 _N_ _S_ "LS" _N_ _N_ },
+ readList = { _A_ 0 _U_ 2 _N_ _N_ _N_ _N_ },
+ showList = { _A_ 0 _U_ 12 _N_ _N_ _N_ _N_ } #-}
instance Text ExitCode
{-# GHC_PRAGMA _M_ LibSystem {-dfun-} _A_ 0 _N_ _N_ _N_ _F_ _IF_ARGS_ 0 0 X 5 _!_ _TUP_4 [(Int -> [Char] -> [(ExitCode, [Char])]), (Int -> ExitCode -> [Char] -> [Char]), ([Char] -> [([ExitCode], [Char])]), ([ExitCode] -> [Char] -> [Char])] [_CONSTM_ Text readsPrec (ExitCode), _CONSTM_ Text showsPrec (ExitCode), _CONSTM_ Text readList (ExitCode), _CONSTM_ Text showList (ExitCode)] _N_
- readsPrec = _A_ 2 _U_ 12 _N_ _N_ _N_ _N_,
- showsPrec = _A_ 2 _U_ 112 _N_ _S_ "LS" _N_ _N_,
- readList = _A_ 0 _U_ 2 _N_ _N_ _N_ _N_,
- showList = _A_ 0 _U_ 12 _N_ _N_ _N_ _N_ #-}
+ readsPrec = { _A_ 2 _U_ 12 _N_ _N_ _N_ _N_ },
+ showsPrec = { _A_ 2 _U_ 112 _N_ _S_ "LS" _N_ _N_ },
+ readList = { _A_ 0 _U_ 2 _N_ _N_ _N_ _N_ },
+ showList = { _A_ 0 _U_ 12 _N_ _N_ _N_ _N_ } #-}
-{-# GHC_PRAGMA INTERFACE VERSION 5 #-}
+{-# GHC_PRAGMA INTERFACE VERSION 6 #-}
interface LibPosixProcPrim where
import LibSystem(ExitCode)
import PreludeArray(_ByteArray)
{-# GHC_PRAGMA _A_ 0 _N_ _N_ _N_ _N_ _N_ #-}
instance Eq ProcessStatus
{-# GHC_PRAGMA _M_ LibPosixProcPrim {-dfun-} _A_ 0 _N_ _N_ _N_ _F_ _IF_ARGS_ 0 0 X 3 _!_ _TUP_2 [(ProcessStatus -> ProcessStatus -> Bool), (ProcessStatus -> ProcessStatus -> Bool)] [_CONSTM_ Eq (==) (ProcessStatus), _CONSTM_ Eq (/=) (ProcessStatus)] _N_
- (==) = _A_ 2 _U_ 11 _N_ _S_ "SS" _N_ _N_,
- (/=) = _A_ 2 _U_ 11 _N_ _S_ "SS" _N_ _N_ #-}
+ (==) = { _A_ 2 _U_ 11 _N_ _S_ "SS" _N_ _N_ },
+ (/=) = { _A_ 2 _U_ 11 _N_ _S_ "SS" _N_ _N_ } #-}
instance Eq ExitCode
{-# GHC_PRAGMA _M_ LibSystem {-dfun-} _A_ 0 _N_ _N_ _N_ _F_ _IF_ARGS_ 0 0 X 3 _!_ _TUP_2 [(ExitCode -> ExitCode -> Bool), (ExitCode -> ExitCode -> Bool)] [_CONSTM_ Eq (==) (ExitCode), _CONSTM_ Eq (/=) (ExitCode)] _N_
- (==) = _A_ 2 _U_ 22 _N_ _S_ "SS" _N_ _N_,
- (/=) = _A_ 2 _U_ 22 _N_ _S_ "SS" _N_ _N_ #-}
+ (==) = { _A_ 2 _U_ 22 _N_ _S_ "SS" _N_ _N_ },
+ (/=) = { _A_ 2 _U_ 22 _N_ _S_ "SS" _N_ _N_ } #-}
instance Ord ProcessStatus
{-# GHC_PRAGMA _M_ LibPosixProcPrim {-dfun-} _A_ 0 _N_ _N_ _N_ _F_ _IF_ARGS_ 0 0 X 9 _!_ _TUP_8 [{{Eq ProcessStatus}}, (ProcessStatus -> ProcessStatus -> Bool), (ProcessStatus -> ProcessStatus -> Bool), (ProcessStatus -> ProcessStatus -> Bool), (ProcessStatus -> ProcessStatus -> Bool), (ProcessStatus -> ProcessStatus -> ProcessStatus), (ProcessStatus -> ProcessStatus -> ProcessStatus), (ProcessStatus -> ProcessStatus -> _CMP_TAG)] [_DFUN_ Eq (ProcessStatus), _CONSTM_ Ord (<) (ProcessStatus), _CONSTM_ Ord (<=) (ProcessStatus), _CONSTM_ Ord (>=) (ProcessStatus), _CONSTM_ Ord (>) (ProcessStatus), _CONSTM_ Ord max (ProcessStatus), _CONSTM_ Ord min (ProcessStatus), _CONSTM_ Ord _tagCmp (ProcessStatus)] _N_
- (<) = _A_ 2 _U_ 22 _N_ _S_ "SS" _N_ _N_,
- (<=) = _A_ 2 _U_ 22 _N_ _S_ "SS" _N_ _N_,
- (>=) = _A_ 2 _U_ 22 _N_ _S_ "SS" _N_ _N_,
- (>) = _A_ 2 _U_ 22 _N_ _S_ "SS" _N_ _N_,
- max = _A_ 2 _U_ 22 _N_ _S_ "SS" _N_ _N_,
- min = _A_ 2 _U_ 22 _N_ _S_ "SS" _N_ _N_,
- _tagCmp = _A_ 2 _U_ 22 _N_ _S_ "SS" _N_ _N_ #-}
+ (<) = { _A_ 2 _U_ 22 _N_ _S_ "SS" _N_ _N_ },
+ (<=) = { _A_ 2 _U_ 22 _N_ _S_ "SS" _N_ _N_ },
+ (>=) = { _A_ 2 _U_ 22 _N_ _S_ "SS" _N_ _N_ },
+ (>) = { _A_ 2 _U_ 22 _N_ _S_ "SS" _N_ _N_ },
+ max = { _A_ 2 _U_ 22 _N_ _S_ "SS" _N_ _N_ },
+ min = { _A_ 2 _U_ 22 _N_ _S_ "SS" _N_ _N_ },
+ _tagCmp = { _A_ 2 _U_ 22 _N_ _S_ "SS" _N_ _N_ } #-}
instance Ord ExitCode
{-# GHC_PRAGMA _M_ LibSystem {-dfun-} _A_ 0 _N_ _N_ _N_ _F_ _IF_ARGS_ 0 0 X 9 _!_ _TUP_8 [{{Eq ExitCode}}, (ExitCode -> ExitCode -> Bool), (ExitCode -> ExitCode -> Bool), (ExitCode -> ExitCode -> Bool), (ExitCode -> ExitCode -> Bool), (ExitCode -> ExitCode -> ExitCode), (ExitCode -> ExitCode -> ExitCode), (ExitCode -> ExitCode -> _CMP_TAG)] [_DFUN_ Eq (ExitCode), _CONSTM_ Ord (<) (ExitCode), _CONSTM_ Ord (<=) (ExitCode), _CONSTM_ Ord (>=) (ExitCode), _CONSTM_ Ord (>) (ExitCode), _CONSTM_ Ord max (ExitCode), _CONSTM_ Ord min (ExitCode), _CONSTM_ Ord _tagCmp (ExitCode)] _N_
- (<) = _A_ 2 _U_ 22 _N_ _S_ "SS" _N_ _N_,
- (<=) = _A_ 2 _U_ 22 _N_ _S_ "SS" _N_ _N_,
- (>=) = _A_ 2 _U_ 22 _N_ _S_ "SS" _N_ _N_,
- (>) = _A_ 2 _U_ 22 _N_ _S_ "SS" _N_ _N_,
- max = _A_ 2 _U_ 22 _N_ _S_ "SS" _N_ _N_,
- min = _A_ 2 _U_ 22 _N_ _S_ "SS" _N_ _N_,
- _tagCmp = _A_ 2 _U_ 22 _N_ _S_ "SS" _N_ _N_ #-}
+ (<) = { _A_ 2 _U_ 22 _N_ _S_ "SS" _N_ _N_ },
+ (<=) = { _A_ 2 _U_ 22 _N_ _S_ "SS" _N_ _N_ },
+ (>=) = { _A_ 2 _U_ 22 _N_ _S_ "SS" _N_ _N_ },
+ (>) = { _A_ 2 _U_ 22 _N_ _S_ "SS" _N_ _N_ },
+ max = { _A_ 2 _U_ 22 _N_ _S_ "SS" _N_ _N_ },
+ min = { _A_ 2 _U_ 22 _N_ _S_ "SS" _N_ _N_ },
+ _tagCmp = { _A_ 2 _U_ 22 _N_ _S_ "SS" _N_ _N_ } #-}
instance Text ProcessStatus
{-# GHC_PRAGMA _M_ LibPosixProcPrim {-dfun-} _A_ 0 _N_ _N_ _N_ _F_ _IF_ARGS_ 0 0 X 5 _!_ _TUP_4 [(Int -> [Char] -> [(ProcessStatus, [Char])]), (Int -> ProcessStatus -> [Char] -> [Char]), ([Char] -> [([ProcessStatus], [Char])]), ([ProcessStatus] -> [Char] -> [Char])] [_CONSTM_ Text readsPrec (ProcessStatus), _CONSTM_ Text showsPrec (ProcessStatus), _CONSTM_ Text readList (ProcessStatus), _CONSTM_ Text showList (ProcessStatus)] _N_
- readsPrec = _A_ 2 _U_ 12 _N_ _S_ "U(P)L" {_A_ 2 _U_ 22 _N_ _N_ _N_ _N_} _N_ _N_,
- showsPrec = _A_ 2 _U_ 112 _N_ _S_ "LS" _N_ _N_,
- readList = _A_ 0 _U_ 2 _N_ _N_ _N_ _N_,
- showList = _A_ 0 _U_ 12 _N_ _N_ _N_ _N_ #-}
+ readsPrec = { _A_ 2 _U_ 12 _N_ _S_ "U(P)L" {_A_ 2 _U_ 22 _N_ _N_ _N_ _N_} _N_ _N_ },
+ showsPrec = { _A_ 2 _U_ 112 _N_ _S_ "LS" _N_ _N_ },
+ readList = { _A_ 0 _U_ 2 _N_ _N_ _N_ _N_ },
+ showList = { _A_ 0 _U_ 12 _N_ _N_ _N_ _N_ } #-}
instance Text ExitCode
{-# GHC_PRAGMA _M_ LibSystem {-dfun-} _A_ 0 _N_ _N_ _N_ _F_ _IF_ARGS_ 0 0 X 5 _!_ _TUP_4 [(Int -> [Char] -> [(ExitCode, [Char])]), (Int -> ExitCode -> [Char] -> [Char]), ([Char] -> [([ExitCode], [Char])]), ([ExitCode] -> [Char] -> [Char])] [_CONSTM_ Text readsPrec (ExitCode), _CONSTM_ Text showsPrec (ExitCode), _CONSTM_ Text readList (ExitCode), _CONSTM_ Text showList (ExitCode)] _N_
- readsPrec = _A_ 2 _U_ 12 _N_ _N_ _N_ _N_,
- showsPrec = _A_ 2 _U_ 112 _N_ _S_ "LS" _N_ _N_,
- readList = _A_ 0 _U_ 2 _N_ _N_ _N_ _N_,
- showList = _A_ 0 _U_ 12 _N_ _N_ _N_ _N_ #-}
+ readsPrec = { _A_ 2 _U_ 12 _N_ _N_ _N_ _N_ },
+ showsPrec = { _A_ 2 _U_ 112 _N_ _S_ "LS" _N_ _N_ },
+ readList = { _A_ 0 _U_ 2 _N_ _N_ _N_ _N_ },
+ showList = { _A_ 0 _U_ 12 _N_ _N_ _N_ _N_ } #-}
-{-# GHC_PRAGMA INTERFACE VERSION 5 #-}
+{-# GHC_PRAGMA INTERFACE VERSION 6 #-}
interface LibPosixProcPrim where
import LibSystem(ExitCode)
import PreludeArray(_ByteArray)
inSignalSet :: Int -> _ByteArray () -> Bool
{-# GHC_PRAGMA _A_ 2 _U_ 11 _N_ _S_ "U(P)U(AP)" {_A_ 2 _U_ 22 _N_ _N_ _N_ _N_} _N_ _N_ #-}
installHandler :: Int -> Handler -> Maybe (_ByteArray ()) -> _State _RealWorld -> (Either IOError13 Handler, _State _RealWorld)
- {-# GHC_PRAGMA _A_ 4 _U_ 2222 _N_ _S_ _!_ _F_ _IF_ARGS_ 0 4 XXXX 6 \ (u0 :: Int) (u1 :: Handler) (u2 :: Maybe (_ByteArray ())) (u3 :: _State _RealWorld) -> _APP_ _TYAPP_ error { (Int -> Handler -> Maybe (_ByteArray ()) -> _State _RealWorld -> (Either IOError13 Handler, _State _RealWorld)) } [ _NOREP_S_ "installHandler: not available for Parallel Haskell", u0, u1, u2, u3 ] _N_ #-}
+ {-# GHC_PRAGMA _A_ 4 _U_ 2222 _N_ _S_ _!_ _N_ _N_ #-}
internalAbort :: Int
{-# GHC_PRAGMA _A_ 0 _N_ _N_ _N_ _N_ _N_ #-}
keyboardSignal :: Int
{-# GHC_PRAGMA _A_ 0 _N_ _N_ _N_ _N_ _N_ #-}
instance Eq ProcessStatus
{-# GHC_PRAGMA _M_ LibPosixProcPrim {-dfun-} _A_ 0 _N_ _N_ _N_ _F_ _IF_ARGS_ 0 0 X 3 _!_ _TUP_2 [(ProcessStatus -> ProcessStatus -> Bool), (ProcessStatus -> ProcessStatus -> Bool)] [_CONSTM_ Eq (==) (ProcessStatus), _CONSTM_ Eq (/=) (ProcessStatus)] _N_
- (==) = _A_ 2 _U_ 11 _N_ _S_ "SS" _N_ _N_,
- (/=) = _A_ 2 _U_ 11 _N_ _S_ "SS" _N_ _N_ #-}
+ (==) = { _A_ 2 _U_ 11 _N_ _S_ "SS" _N_ _N_ },
+ (/=) = { _A_ 2 _U_ 11 _N_ _S_ "SS" _N_ _N_ } #-}
instance Eq ExitCode
{-# GHC_PRAGMA _M_ LibSystem {-dfun-} _A_ 0 _N_ _N_ _N_ _F_ _IF_ARGS_ 0 0 X 3 _!_ _TUP_2 [(ExitCode -> ExitCode -> Bool), (ExitCode -> ExitCode -> Bool)] [_CONSTM_ Eq (==) (ExitCode), _CONSTM_ Eq (/=) (ExitCode)] _N_
- (==) = _A_ 2 _U_ 22 _N_ _S_ "SS" _N_ _N_,
- (/=) = _A_ 2 _U_ 22 _N_ _S_ "SS" _N_ _N_ #-}
+ (==) = { _A_ 2 _U_ 22 _N_ _S_ "SS" _N_ _N_ },
+ (/=) = { _A_ 2 _U_ 22 _N_ _S_ "SS" _N_ _N_ } #-}
instance Ord ProcessStatus
{-# GHC_PRAGMA _M_ LibPosixProcPrim {-dfun-} _A_ 0 _N_ _N_ _N_ _F_ _IF_ARGS_ 0 0 X 9 _!_ _TUP_8 [{{Eq ProcessStatus}}, (ProcessStatus -> ProcessStatus -> Bool), (ProcessStatus -> ProcessStatus -> Bool), (ProcessStatus -> ProcessStatus -> Bool), (ProcessStatus -> ProcessStatus -> Bool), (ProcessStatus -> ProcessStatus -> ProcessStatus), (ProcessStatus -> ProcessStatus -> ProcessStatus), (ProcessStatus -> ProcessStatus -> _CMP_TAG)] [_DFUN_ Eq (ProcessStatus), _CONSTM_ Ord (<) (ProcessStatus), _CONSTM_ Ord (<=) (ProcessStatus), _CONSTM_ Ord (>=) (ProcessStatus), _CONSTM_ Ord (>) (ProcessStatus), _CONSTM_ Ord max (ProcessStatus), _CONSTM_ Ord min (ProcessStatus), _CONSTM_ Ord _tagCmp (ProcessStatus)] _N_
- (<) = _A_ 2 _U_ 22 _N_ _S_ "SS" _N_ _N_,
- (<=) = _A_ 2 _U_ 22 _N_ _S_ "SS" _N_ _N_,
- (>=) = _A_ 2 _U_ 22 _N_ _S_ "SS" _N_ _N_,
- (>) = _A_ 2 _U_ 22 _N_ _S_ "SS" _N_ _N_,
- max = _A_ 2 _U_ 22 _N_ _S_ "SS" _N_ _N_,
- min = _A_ 2 _U_ 22 _N_ _S_ "SS" _N_ _N_,
- _tagCmp = _A_ 2 _U_ 22 _N_ _S_ "SS" _N_ _N_ #-}
+ (<) = { _A_ 2 _U_ 22 _N_ _S_ "SS" _N_ _N_ },
+ (<=) = { _A_ 2 _U_ 22 _N_ _S_ "SS" _N_ _N_ },
+ (>=) = { _A_ 2 _U_ 22 _N_ _S_ "SS" _N_ _N_ },
+ (>) = { _A_ 2 _U_ 22 _N_ _S_ "SS" _N_ _N_ },
+ max = { _A_ 2 _U_ 22 _N_ _S_ "SS" _N_ _N_ },
+ min = { _A_ 2 _U_ 22 _N_ _S_ "SS" _N_ _N_ },
+ _tagCmp = { _A_ 2 _U_ 22 _N_ _S_ "SS" _N_ _N_ } #-}
instance Ord ExitCode
{-# GHC_PRAGMA _M_ LibSystem {-dfun-} _A_ 0 _N_ _N_ _N_ _F_ _IF_ARGS_ 0 0 X 9 _!_ _TUP_8 [{{Eq ExitCode}}, (ExitCode -> ExitCode -> Bool), (ExitCode -> ExitCode -> Bool), (ExitCode -> ExitCode -> Bool), (ExitCode -> ExitCode -> Bool), (ExitCode -> ExitCode -> ExitCode), (ExitCode -> ExitCode -> ExitCode), (ExitCode -> ExitCode -> _CMP_TAG)] [_DFUN_ Eq (ExitCode), _CONSTM_ Ord (<) (ExitCode), _CONSTM_ Ord (<=) (ExitCode), _CONSTM_ Ord (>=) (ExitCode), _CONSTM_ Ord (>) (ExitCode), _CONSTM_ Ord max (ExitCode), _CONSTM_ Ord min (ExitCode), _CONSTM_ Ord _tagCmp (ExitCode)] _N_
- (<) = _A_ 2 _U_ 22 _N_ _S_ "SS" _N_ _N_,
- (<=) = _A_ 2 _U_ 22 _N_ _S_ "SS" _N_ _N_,
- (>=) = _A_ 2 _U_ 22 _N_ _S_ "SS" _N_ _N_,
- (>) = _A_ 2 _U_ 22 _N_ _S_ "SS" _N_ _N_,
- max = _A_ 2 _U_ 22 _N_ _S_ "SS" _N_ _N_,
- min = _A_ 2 _U_ 22 _N_ _S_ "SS" _N_ _N_,
- _tagCmp = _A_ 2 _U_ 22 _N_ _S_ "SS" _N_ _N_ #-}
+ (<) = { _A_ 2 _U_ 22 _N_ _S_ "SS" _N_ _N_ },
+ (<=) = { _A_ 2 _U_ 22 _N_ _S_ "SS" _N_ _N_ },
+ (>=) = { _A_ 2 _U_ 22 _N_ _S_ "SS" _N_ _N_ },
+ (>) = { _A_ 2 _U_ 22 _N_ _S_ "SS" _N_ _N_ },
+ max = { _A_ 2 _U_ 22 _N_ _S_ "SS" _N_ _N_ },
+ min = { _A_ 2 _U_ 22 _N_ _S_ "SS" _N_ _N_ },
+ _tagCmp = { _A_ 2 _U_ 22 _N_ _S_ "SS" _N_ _N_ } #-}
instance Text ProcessStatus
{-# GHC_PRAGMA _M_ LibPosixProcPrim {-dfun-} _A_ 0 _N_ _N_ _N_ _F_ _IF_ARGS_ 0 0 X 5 _!_ _TUP_4 [(Int -> [Char] -> [(ProcessStatus, [Char])]), (Int -> ProcessStatus -> [Char] -> [Char]), ([Char] -> [([ProcessStatus], [Char])]), ([ProcessStatus] -> [Char] -> [Char])] [_CONSTM_ Text readsPrec (ProcessStatus), _CONSTM_ Text showsPrec (ProcessStatus), _CONSTM_ Text readList (ProcessStatus), _CONSTM_ Text showList (ProcessStatus)] _N_
- readsPrec = _A_ 2 _U_ 12 _N_ _S_ "U(P)L" {_A_ 2 _U_ 22 _N_ _N_ _N_ _N_} _N_ _N_,
- showsPrec = _A_ 2 _U_ 112 _N_ _S_ "LS" _N_ _N_,
- readList = _A_ 0 _U_ 2 _N_ _N_ _N_ _N_,
- showList = _A_ 0 _U_ 12 _N_ _N_ _N_ _N_ #-}
+ readsPrec = { _A_ 2 _U_ 12 _N_ _S_ "U(P)L" {_A_ 2 _U_ 22 _N_ _N_ _N_ _N_} _N_ _N_ },
+ showsPrec = { _A_ 2 _U_ 112 _N_ _S_ "LS" _N_ _N_ },
+ readList = { _A_ 0 _U_ 2 _N_ _N_ _N_ _N_ },
+ showList = { _A_ 0 _U_ 12 _N_ _N_ _N_ _N_ } #-}
instance Text ExitCode
{-# GHC_PRAGMA _M_ LibSystem {-dfun-} _A_ 0 _N_ _N_ _N_ _F_ _IF_ARGS_ 0 0 X 5 _!_ _TUP_4 [(Int -> [Char] -> [(ExitCode, [Char])]), (Int -> ExitCode -> [Char] -> [Char]), ([Char] -> [([ExitCode], [Char])]), ([ExitCode] -> [Char] -> [Char])] [_CONSTM_ Text readsPrec (ExitCode), _CONSTM_ Text showsPrec (ExitCode), _CONSTM_ Text readList (ExitCode), _CONSTM_ Text showList (ExitCode)] _N_
- readsPrec = _A_ 2 _U_ 12 _N_ _N_ _N_ _N_,
- showsPrec = _A_ 2 _U_ 112 _N_ _S_ "LS" _N_ _N_,
- readList = _A_ 0 _U_ 2 _N_ _N_ _N_ _N_,
- showList = _A_ 0 _U_ 12 _N_ _N_ _N_ _N_ #-}
+ readsPrec = { _A_ 2 _U_ 12 _N_ _N_ _N_ _N_ },
+ showsPrec = { _A_ 2 _U_ 112 _N_ _S_ "LS" _N_ _N_ },
+ readList = { _A_ 0 _U_ 2 _N_ _N_ _N_ _N_ },
+ showList = { _A_ 0 _U_ 12 _N_ _N_ _N_ _N_ } #-}
-{-# GHC_PRAGMA INTERFACE VERSION 5 #-}
+{-# GHC_PRAGMA INTERFACE VERSION 6 #-}
interface LibPosixProcPrim where
import LibSystem(ExitCode)
import PreludeArray(_ByteArray)
{-# GHC_PRAGMA _A_ 0 _N_ _N_ _N_ _N_ _N_ #-}
instance Eq ProcessStatus
{-# GHC_PRAGMA _M_ LibPosixProcPrim {-dfun-} _A_ 0 _N_ _N_ _N_ _F_ _IF_ARGS_ 0 0 X 3 _!_ _TUP_2 [(ProcessStatus -> ProcessStatus -> Bool), (ProcessStatus -> ProcessStatus -> Bool)] [_CONSTM_ Eq (==) (ProcessStatus), _CONSTM_ Eq (/=) (ProcessStatus)] _N_
- (==) = _A_ 2 _U_ 11 _N_ _S_ "SS" _N_ _N_,
- (/=) = _A_ 2 _U_ 11 _N_ _S_ "SS" _N_ _N_ #-}
+ (==) = { _A_ 2 _U_ 11 _N_ _S_ "SS" _N_ _N_ },
+ (/=) = { _A_ 2 _U_ 11 _N_ _S_ "SS" _N_ _N_ } #-}
instance Eq ExitCode
{-# GHC_PRAGMA _M_ LibSystem {-dfun-} _A_ 0 _N_ _N_ _N_ _F_ _IF_ARGS_ 0 0 X 3 _!_ _TUP_2 [(ExitCode -> ExitCode -> Bool), (ExitCode -> ExitCode -> Bool)] [_CONSTM_ Eq (==) (ExitCode), _CONSTM_ Eq (/=) (ExitCode)] _N_
- (==) = _A_ 2 _U_ 22 _N_ _S_ "SS" _N_ _N_,
- (/=) = _A_ 2 _U_ 22 _N_ _S_ "SS" _N_ _N_ #-}
+ (==) = { _A_ 2 _U_ 22 _N_ _S_ "SS" _N_ _N_ },
+ (/=) = { _A_ 2 _U_ 22 _N_ _S_ "SS" _N_ _N_ } #-}
instance Ord ProcessStatus
{-# GHC_PRAGMA _M_ LibPosixProcPrim {-dfun-} _A_ 0 _N_ _N_ _N_ _F_ _IF_ARGS_ 0 0 X 9 _!_ _TUP_8 [{{Eq ProcessStatus}}, (ProcessStatus -> ProcessStatus -> Bool), (ProcessStatus -> ProcessStatus -> Bool), (ProcessStatus -> ProcessStatus -> Bool), (ProcessStatus -> ProcessStatus -> Bool), (ProcessStatus -> ProcessStatus -> ProcessStatus), (ProcessStatus -> ProcessStatus -> ProcessStatus), (ProcessStatus -> ProcessStatus -> _CMP_TAG)] [_DFUN_ Eq (ProcessStatus), _CONSTM_ Ord (<) (ProcessStatus), _CONSTM_ Ord (<=) (ProcessStatus), _CONSTM_ Ord (>=) (ProcessStatus), _CONSTM_ Ord (>) (ProcessStatus), _CONSTM_ Ord max (ProcessStatus), _CONSTM_ Ord min (ProcessStatus), _CONSTM_ Ord _tagCmp (ProcessStatus)] _N_
- (<) = _A_ 2 _U_ 22 _N_ _S_ "SS" _N_ _N_,
- (<=) = _A_ 2 _U_ 22 _N_ _S_ "SS" _N_ _N_,
- (>=) = _A_ 2 _U_ 22 _N_ _S_ "SS" _N_ _N_,
- (>) = _A_ 2 _U_ 22 _N_ _S_ "SS" _N_ _N_,
- max = _A_ 2 _U_ 22 _N_ _S_ "SS" _N_ _N_,
- min = _A_ 2 _U_ 22 _N_ _S_ "SS" _N_ _N_,
- _tagCmp = _A_ 2 _U_ 22 _N_ _S_ "SS" _N_ _N_ #-}
+ (<) = { _A_ 2 _U_ 22 _N_ _S_ "SS" _N_ _N_ },
+ (<=) = { _A_ 2 _U_ 22 _N_ _S_ "SS" _N_ _N_ },
+ (>=) = { _A_ 2 _U_ 22 _N_ _S_ "SS" _N_ _N_ },
+ (>) = { _A_ 2 _U_ 22 _N_ _S_ "SS" _N_ _N_ },
+ max = { _A_ 2 _U_ 22 _N_ _S_ "SS" _N_ _N_ },
+ min = { _A_ 2 _U_ 22 _N_ _S_ "SS" _N_ _N_ },
+ _tagCmp = { _A_ 2 _U_ 22 _N_ _S_ "SS" _N_ _N_ } #-}
instance Ord ExitCode
{-# GHC_PRAGMA _M_ LibSystem {-dfun-} _A_ 0 _N_ _N_ _N_ _F_ _IF_ARGS_ 0 0 X 9 _!_ _TUP_8 [{{Eq ExitCode}}, (ExitCode -> ExitCode -> Bool), (ExitCode -> ExitCode -> Bool), (ExitCode -> ExitCode -> Bool), (ExitCode -> ExitCode -> Bool), (ExitCode -> ExitCode -> ExitCode), (ExitCode -> ExitCode -> ExitCode), (ExitCode -> ExitCode -> _CMP_TAG)] [_DFUN_ Eq (ExitCode), _CONSTM_ Ord (<) (ExitCode), _CONSTM_ Ord (<=) (ExitCode), _CONSTM_ Ord (>=) (ExitCode), _CONSTM_ Ord (>) (ExitCode), _CONSTM_ Ord max (ExitCode), _CONSTM_ Ord min (ExitCode), _CONSTM_ Ord _tagCmp (ExitCode)] _N_
- (<) = _A_ 2 _U_ 22 _N_ _S_ "SS" _N_ _N_,
- (<=) = _A_ 2 _U_ 22 _N_ _S_ "SS" _N_ _N_,
- (>=) = _A_ 2 _U_ 22 _N_ _S_ "SS" _N_ _N_,
- (>) = _A_ 2 _U_ 22 _N_ _S_ "SS" _N_ _N_,
- max = _A_ 2 _U_ 22 _N_ _S_ "SS" _N_ _N_,
- min = _A_ 2 _U_ 22 _N_ _S_ "SS" _N_ _N_,
- _tagCmp = _A_ 2 _U_ 22 _N_ _S_ "SS" _N_ _N_ #-}
+ (<) = { _A_ 2 _U_ 22 _N_ _S_ "SS" _N_ _N_ },
+ (<=) = { _A_ 2 _U_ 22 _N_ _S_ "SS" _N_ _N_ },
+ (>=) = { _A_ 2 _U_ 22 _N_ _S_ "SS" _N_ _N_ },
+ (>) = { _A_ 2 _U_ 22 _N_ _S_ "SS" _N_ _N_ },
+ max = { _A_ 2 _U_ 22 _N_ _S_ "SS" _N_ _N_ },
+ min = { _A_ 2 _U_ 22 _N_ _S_ "SS" _N_ _N_ },
+ _tagCmp = { _A_ 2 _U_ 22 _N_ _S_ "SS" _N_ _N_ } #-}
instance Text ProcessStatus
{-# GHC_PRAGMA _M_ LibPosixProcPrim {-dfun-} _A_ 0 _N_ _N_ _N_ _F_ _IF_ARGS_ 0 0 X 5 _!_ _TUP_4 [(Int -> [Char] -> [(ProcessStatus, [Char])]), (Int -> ProcessStatus -> [Char] -> [Char]), ([Char] -> [([ProcessStatus], [Char])]), ([ProcessStatus] -> [Char] -> [Char])] [_CONSTM_ Text readsPrec (ProcessStatus), _CONSTM_ Text showsPrec (ProcessStatus), _CONSTM_ Text readList (ProcessStatus), _CONSTM_ Text showList (ProcessStatus)] _N_
- readsPrec = _A_ 2 _U_ 12 _N_ _S_ "U(P)L" {_A_ 2 _U_ 22 _N_ _N_ _N_ _N_} _N_ _N_,
- showsPrec = _A_ 2 _U_ 112 _N_ _S_ "LS" _N_ _N_,
- readList = _A_ 0 _U_ 2 _N_ _N_ _N_ _N_,
- showList = _A_ 0 _U_ 12 _N_ _N_ _N_ _N_ #-}
+ readsPrec = { _A_ 2 _U_ 12 _N_ _S_ "U(P)L" {_A_ 2 _U_ 22 _N_ _N_ _N_ _N_} _N_ _N_ },
+ showsPrec = { _A_ 2 _U_ 112 _N_ _S_ "LS" _N_ _N_ },
+ readList = { _A_ 0 _U_ 2 _N_ _N_ _N_ _N_ },
+ showList = { _A_ 0 _U_ 12 _N_ _N_ _N_ _N_ } #-}
instance Text ExitCode
{-# GHC_PRAGMA _M_ LibSystem {-dfun-} _A_ 0 _N_ _N_ _N_ _F_ _IF_ARGS_ 0 0 X 5 _!_ _TUP_4 [(Int -> [Char] -> [(ExitCode, [Char])]), (Int -> ExitCode -> [Char] -> [Char]), ([Char] -> [([ExitCode], [Char])]), ([ExitCode] -> [Char] -> [Char])] [_CONSTM_ Text readsPrec (ExitCode), _CONSTM_ Text showsPrec (ExitCode), _CONSTM_ Text readList (ExitCode), _CONSTM_ Text showList (ExitCode)] _N_
- readsPrec = _A_ 2 _U_ 12 _N_ _N_ _N_ _N_,
- showsPrec = _A_ 2 _U_ 112 _N_ _S_ "LS" _N_ _N_,
- readList = _A_ 0 _U_ 2 _N_ _N_ _N_ _N_,
- showList = _A_ 0 _U_ 12 _N_ _N_ _N_ _N_ #-}
+ readsPrec = { _A_ 2 _U_ 12 _N_ _N_ _N_ _N_ },
+ showsPrec = { _A_ 2 _U_ 112 _N_ _S_ "LS" _N_ _N_ },
+ readList = { _A_ 0 _U_ 2 _N_ _N_ _N_ _N_ },
+ showList = { _A_ 0 _U_ 12 _N_ _N_ _N_ _N_ } #-}
-{-# GHC_PRAGMA INTERFACE VERSION 5 #-}
+{-# GHC_PRAGMA INTERFACE VERSION 6 #-}
interface LibPosixProcPrim where
import LibSystem(ExitCode)
import PreludeArray(_ByteArray)
{-# GHC_PRAGMA _A_ 0 _N_ _N_ _N_ _N_ _N_ #-}
instance Eq ProcessStatus
{-# GHC_PRAGMA _M_ LibPosixProcPrim {-dfun-} _A_ 0 _N_ _N_ _N_ _F_ _IF_ARGS_ 0 0 X 3 _!_ _TUP_2 [(ProcessStatus -> ProcessStatus -> Bool), (ProcessStatus -> ProcessStatus -> Bool)] [_CONSTM_ Eq (==) (ProcessStatus), _CONSTM_ Eq (/=) (ProcessStatus)] _N_
- (==) = _A_ 2 _U_ 11 _N_ _S_ "SS" _N_ _N_,
- (/=) = _A_ 2 _U_ 11 _N_ _S_ "SS" _N_ _N_ #-}
+ (==) = { _A_ 2 _U_ 11 _N_ _S_ "SS" _N_ _N_ },
+ (/=) = { _A_ 2 _U_ 11 _N_ _S_ "SS" _N_ _N_ } #-}
instance Eq ExitCode
{-# GHC_PRAGMA _M_ LibSystem {-dfun-} _A_ 0 _N_ _N_ _N_ _F_ _IF_ARGS_ 0 0 X 3 _!_ _TUP_2 [(ExitCode -> ExitCode -> Bool), (ExitCode -> ExitCode -> Bool)] [_CONSTM_ Eq (==) (ExitCode), _CONSTM_ Eq (/=) (ExitCode)] _N_
- (==) = _A_ 2 _U_ 22 _N_ _S_ "SS" _N_ _N_,
- (/=) = _A_ 2 _U_ 22 _N_ _S_ "SS" _N_ _N_ #-}
+ (==) = { _A_ 2 _U_ 22 _N_ _S_ "SS" _N_ _N_ },
+ (/=) = { _A_ 2 _U_ 22 _N_ _S_ "SS" _N_ _N_ } #-}
instance Ord ProcessStatus
{-# GHC_PRAGMA _M_ LibPosixProcPrim {-dfun-} _A_ 0 _N_ _N_ _N_ _F_ _IF_ARGS_ 0 0 X 9 _!_ _TUP_8 [{{Eq ProcessStatus}}, (ProcessStatus -> ProcessStatus -> Bool), (ProcessStatus -> ProcessStatus -> Bool), (ProcessStatus -> ProcessStatus -> Bool), (ProcessStatus -> ProcessStatus -> Bool), (ProcessStatus -> ProcessStatus -> ProcessStatus), (ProcessStatus -> ProcessStatus -> ProcessStatus), (ProcessStatus -> ProcessStatus -> _CMP_TAG)] [_DFUN_ Eq (ProcessStatus), _CONSTM_ Ord (<) (ProcessStatus), _CONSTM_ Ord (<=) (ProcessStatus), _CONSTM_ Ord (>=) (ProcessStatus), _CONSTM_ Ord (>) (ProcessStatus), _CONSTM_ Ord max (ProcessStatus), _CONSTM_ Ord min (ProcessStatus), _CONSTM_ Ord _tagCmp (ProcessStatus)] _N_
- (<) = _A_ 2 _U_ 22 _N_ _S_ "SS" _N_ _N_,
- (<=) = _A_ 2 _U_ 22 _N_ _S_ "SS" _N_ _N_,
- (>=) = _A_ 2 _U_ 22 _N_ _S_ "SS" _N_ _N_,
- (>) = _A_ 2 _U_ 22 _N_ _S_ "SS" _N_ _N_,
- max = _A_ 2 _U_ 22 _N_ _S_ "SS" _N_ _N_,
- min = _A_ 2 _U_ 22 _N_ _S_ "SS" _N_ _N_,
- _tagCmp = _A_ 2 _U_ 22 _N_ _S_ "SS" _N_ _N_ #-}
+ (<) = { _A_ 2 _U_ 22 _N_ _S_ "SS" _N_ _N_ },
+ (<=) = { _A_ 2 _U_ 22 _N_ _S_ "SS" _N_ _N_ },
+ (>=) = { _A_ 2 _U_ 22 _N_ _S_ "SS" _N_ _N_ },
+ (>) = { _A_ 2 _U_ 22 _N_ _S_ "SS" _N_ _N_ },
+ max = { _A_ 2 _U_ 22 _N_ _S_ "SS" _N_ _N_ },
+ min = { _A_ 2 _U_ 22 _N_ _S_ "SS" _N_ _N_ },
+ _tagCmp = { _A_ 2 _U_ 22 _N_ _S_ "SS" _N_ _N_ } #-}
instance Ord ExitCode
{-# GHC_PRAGMA _M_ LibSystem {-dfun-} _A_ 0 _N_ _N_ _N_ _F_ _IF_ARGS_ 0 0 X 9 _!_ _TUP_8 [{{Eq ExitCode}}, (ExitCode -> ExitCode -> Bool), (ExitCode -> ExitCode -> Bool), (ExitCode -> ExitCode -> Bool), (ExitCode -> ExitCode -> Bool), (ExitCode -> ExitCode -> ExitCode), (ExitCode -> ExitCode -> ExitCode), (ExitCode -> ExitCode -> _CMP_TAG)] [_DFUN_ Eq (ExitCode), _CONSTM_ Ord (<) (ExitCode), _CONSTM_ Ord (<=) (ExitCode), _CONSTM_ Ord (>=) (ExitCode), _CONSTM_ Ord (>) (ExitCode), _CONSTM_ Ord max (ExitCode), _CONSTM_ Ord min (ExitCode), _CONSTM_ Ord _tagCmp (ExitCode)] _N_
- (<) = _A_ 2 _U_ 22 _N_ _S_ "SS" _N_ _N_,
- (<=) = _A_ 2 _U_ 22 _N_ _S_ "SS" _N_ _N_,
- (>=) = _A_ 2 _U_ 22 _N_ _S_ "SS" _N_ _N_,
- (>) = _A_ 2 _U_ 22 _N_ _S_ "SS" _N_ _N_,
- max = _A_ 2 _U_ 22 _N_ _S_ "SS" _N_ _N_,
- min = _A_ 2 _U_ 22 _N_ _S_ "SS" _N_ _N_,
- _tagCmp = _A_ 2 _U_ 22 _N_ _S_ "SS" _N_ _N_ #-}
+ (<) = { _A_ 2 _U_ 22 _N_ _S_ "SS" _N_ _N_ },
+ (<=) = { _A_ 2 _U_ 22 _N_ _S_ "SS" _N_ _N_ },
+ (>=) = { _A_ 2 _U_ 22 _N_ _S_ "SS" _N_ _N_ },
+ (>) = { _A_ 2 _U_ 22 _N_ _S_ "SS" _N_ _N_ },
+ max = { _A_ 2 _U_ 22 _N_ _S_ "SS" _N_ _N_ },
+ min = { _A_ 2 _U_ 22 _N_ _S_ "SS" _N_ _N_ },
+ _tagCmp = { _A_ 2 _U_ 22 _N_ _S_ "SS" _N_ _N_ } #-}
instance Text ProcessStatus
{-# GHC_PRAGMA _M_ LibPosixProcPrim {-dfun-} _A_ 0 _N_ _N_ _N_ _F_ _IF_ARGS_ 0 0 X 5 _!_ _TUP_4 [(Int -> [Char] -> [(ProcessStatus, [Char])]), (Int -> ProcessStatus -> [Char] -> [Char]), ([Char] -> [([ProcessStatus], [Char])]), ([ProcessStatus] -> [Char] -> [Char])] [_CONSTM_ Text readsPrec (ProcessStatus), _CONSTM_ Text showsPrec (ProcessStatus), _CONSTM_ Text readList (ProcessStatus), _CONSTM_ Text showList (ProcessStatus)] _N_
- readsPrec = _A_ 2 _U_ 12 _N_ _S_ "U(P)L" {_A_ 2 _U_ 22 _N_ _N_ _N_ _N_} _N_ _N_,
- showsPrec = _A_ 2 _U_ 112 _N_ _S_ "LS" _N_ _N_,
- readList = _A_ 0 _U_ 2 _N_ _N_ _N_ _N_,
- showList = _A_ 0 _U_ 12 _N_ _N_ _N_ _N_ #-}
+ readsPrec = { _A_ 2 _U_ 12 _N_ _S_ "U(P)L" {_A_ 2 _U_ 22 _N_ _N_ _N_ _N_} _N_ _N_ },
+ showsPrec = { _A_ 2 _U_ 112 _N_ _S_ "LS" _N_ _N_ },
+ readList = { _A_ 0 _U_ 2 _N_ _N_ _N_ _N_ },
+ showList = { _A_ 0 _U_ 12 _N_ _N_ _N_ _N_ } #-}
instance Text ExitCode
{-# GHC_PRAGMA _M_ LibSystem {-dfun-} _A_ 0 _N_ _N_ _N_ _F_ _IF_ARGS_ 0 0 X 5 _!_ _TUP_4 [(Int -> [Char] -> [(ExitCode, [Char])]), (Int -> ExitCode -> [Char] -> [Char]), ([Char] -> [([ExitCode], [Char])]), ([ExitCode] -> [Char] -> [Char])] [_CONSTM_ Text readsPrec (ExitCode), _CONSTM_ Text showsPrec (ExitCode), _CONSTM_ Text readList (ExitCode), _CONSTM_ Text showList (ExitCode)] _N_
- readsPrec = _A_ 2 _U_ 12 _N_ _N_ _N_ _N_,
- showsPrec = _A_ 2 _U_ 112 _N_ _S_ "LS" _N_ _N_,
- readList = _A_ 0 _U_ 2 _N_ _N_ _N_ _N_,
- showList = _A_ 0 _U_ 12 _N_ _N_ _N_ _N_ #-}
+ readsPrec = { _A_ 2 _U_ 12 _N_ _N_ _N_ _N_ },
+ showsPrec = { _A_ 2 _U_ 112 _N_ _S_ "LS" _N_ _N_ },
+ readList = { _A_ 0 _U_ 2 _N_ _N_ _N_ _N_ },
+ showList = { _A_ 0 _U_ 12 _N_ _N_ _N_ _N_ } #-}
-{-# GHC_PRAGMA INTERFACE VERSION 5 #-}
+{-# GHC_PRAGMA INTERFACE VERSION 6 #-}
interface LibPosixTTY where
import PreludeArray(_ByteArray)
import PreludeIOError(IOError13)
-{-# GHC_PRAGMA INTERFACE VERSION 5 #-}
+{-# GHC_PRAGMA INTERFACE VERSION 6 #-}
interface LibPosixTTY where
import PreludeArray(_ByteArray)
import PreludeIOError(IOError13)
-{-# GHC_PRAGMA INTERFACE VERSION 5 #-}
+{-# GHC_PRAGMA INTERFACE VERSION 6 #-}
interface LibPosixTTY where
import PreludeArray(_ByteArray)
import PreludeIOError(IOError13)
-{-# GHC_PRAGMA INTERFACE VERSION 5 #-}
+{-# GHC_PRAGMA INTERFACE VERSION 6 #-}
interface LibPosixTTY where
import PreludeArray(_ByteArray)
import PreludeIOError(IOError13)
-{-# GHC_PRAGMA INTERFACE VERSION 5 #-}
+{-# GHC_PRAGMA INTERFACE VERSION 6 #-}
interface LibPosixTTY where
import PreludeArray(_ByteArray)
import PreludeIOError(IOError13)
-{-# GHC_PRAGMA INTERFACE VERSION 5 #-}
+{-# GHC_PRAGMA INTERFACE VERSION 6 #-}
interface LibPosixUtil where
import PreludeArray(_ByteArray)
import PreludeGlaST(_MutableByteArray)
-{-# GHC_PRAGMA INTERFACE VERSION 5 #-}
+{-# GHC_PRAGMA INTERFACE VERSION 6 #-}
interface LibPosixUtil where
import PreludeArray(_ByteArray)
import PreludeGlaST(_MutableByteArray)
-{-# GHC_PRAGMA INTERFACE VERSION 5 #-}
+{-# GHC_PRAGMA INTERFACE VERSION 6 #-}
interface LibPosixUtil where
import PreludeArray(_ByteArray)
import PreludeGlaST(_MutableByteArray)
-{-# GHC_PRAGMA INTERFACE VERSION 5 #-}
+{-# GHC_PRAGMA INTERFACE VERSION 6 #-}
interface LibPosixUtil where
import PreludeArray(_ByteArray)
import PreludeGlaST(_MutableByteArray)
-{-# GHC_PRAGMA INTERFACE VERSION 5 #-}
+{-# GHC_PRAGMA INTERFACE VERSION 6 #-}
interface LibPosixUtil where
import PreludeArray(_ByteArray)
import PreludeGlaST(_MutableByteArray)
-{-# GHC_PRAGMA INTERFACE VERSION 5 #-}
+{-# GHC_PRAGMA INTERFACE VERSION 6 #-}
interface LibPosix where
import LibDirectory(getCurrentDirectory, removeDirectory, setCurrentDirectory)
import LibPosixDB(GroupEntry(..), UserEntry(..), getGroupEntryForID, getGroupEntryForName, getUserEntryForID, getUserEntryForName, groupID, groupMembers, groupName, homeDirectory, userGroupID, userID, userName, userShell)
{-# GHC_PRAGMA _A_ 2 _U_ 11 _N_ _S_ "U(AP)E" {_A_ 2 _U_ 21 _N_ _N_ _N_ _N_} _N_ _N_ #-}
instance Eq ProcessStatus
{-# GHC_PRAGMA _M_ LibPosixProcPrim {-dfun-} _A_ 0 _N_ _N_ _N_ _F_ _IF_ARGS_ 0 0 X 3 _!_ _TUP_2 [(ProcessStatus -> ProcessStatus -> Bool), (ProcessStatus -> ProcessStatus -> Bool)] [_CONSTM_ Eq (==) (ProcessStatus), _CONSTM_ Eq (/=) (ProcessStatus)] _N_
- (==) = _A_ 2 _U_ 11 _N_ _S_ "SS" _N_ _N_,
- (/=) = _A_ 2 _U_ 11 _N_ _S_ "SS" _N_ _N_ #-}
+ (==) = { _A_ 2 _U_ 11 _N_ _S_ "SS" _N_ _N_ },
+ (/=) = { _A_ 2 _U_ 11 _N_ _S_ "SS" _N_ _N_ } #-}
instance Eq ExitCode
{-# GHC_PRAGMA _M_ LibSystem {-dfun-} _A_ 0 _N_ _N_ _N_ _F_ _IF_ARGS_ 0 0 X 3 _!_ _TUP_2 [(ExitCode -> ExitCode -> Bool), (ExitCode -> ExitCode -> Bool)] [_CONSTM_ Eq (==) (ExitCode), _CONSTM_ Eq (/=) (ExitCode)] _N_
- (==) = _A_ 2 _U_ 22 _N_ _S_ "SS" _N_ _N_,
- (/=) = _A_ 2 _U_ 22 _N_ _S_ "SS" _N_ _N_ #-}
+ (==) = { _A_ 2 _U_ 22 _N_ _S_ "SS" _N_ _N_ },
+ (/=) = { _A_ 2 _U_ 22 _N_ _S_ "SS" _N_ _N_ } #-}
instance Ord ProcessStatus
{-# GHC_PRAGMA _M_ LibPosixProcPrim {-dfun-} _A_ 0 _N_ _N_ _N_ _F_ _IF_ARGS_ 0 0 X 9 _!_ _TUP_8 [{{Eq ProcessStatus}}, (ProcessStatus -> ProcessStatus -> Bool), (ProcessStatus -> ProcessStatus -> Bool), (ProcessStatus -> ProcessStatus -> Bool), (ProcessStatus -> ProcessStatus -> Bool), (ProcessStatus -> ProcessStatus -> ProcessStatus), (ProcessStatus -> ProcessStatus -> ProcessStatus), (ProcessStatus -> ProcessStatus -> _CMP_TAG)] [_DFUN_ Eq (ProcessStatus), _CONSTM_ Ord (<) (ProcessStatus), _CONSTM_ Ord (<=) (ProcessStatus), _CONSTM_ Ord (>=) (ProcessStatus), _CONSTM_ Ord (>) (ProcessStatus), _CONSTM_ Ord max (ProcessStatus), _CONSTM_ Ord min (ProcessStatus), _CONSTM_ Ord _tagCmp (ProcessStatus)] _N_
- (<) = _A_ 2 _U_ 22 _N_ _S_ "SS" _N_ _N_,
- (<=) = _A_ 2 _U_ 22 _N_ _S_ "SS" _N_ _N_,
- (>=) = _A_ 2 _U_ 22 _N_ _S_ "SS" _N_ _N_,
- (>) = _A_ 2 _U_ 22 _N_ _S_ "SS" _N_ _N_,
- max = _A_ 2 _U_ 22 _N_ _S_ "SS" _N_ _N_,
- min = _A_ 2 _U_ 22 _N_ _S_ "SS" _N_ _N_,
- _tagCmp = _A_ 2 _U_ 22 _N_ _S_ "SS" _N_ _N_ #-}
+ (<) = { _A_ 2 _U_ 22 _N_ _S_ "SS" _N_ _N_ },
+ (<=) = { _A_ 2 _U_ 22 _N_ _S_ "SS" _N_ _N_ },
+ (>=) = { _A_ 2 _U_ 22 _N_ _S_ "SS" _N_ _N_ },
+ (>) = { _A_ 2 _U_ 22 _N_ _S_ "SS" _N_ _N_ },
+ max = { _A_ 2 _U_ 22 _N_ _S_ "SS" _N_ _N_ },
+ min = { _A_ 2 _U_ 22 _N_ _S_ "SS" _N_ _N_ },
+ _tagCmp = { _A_ 2 _U_ 22 _N_ _S_ "SS" _N_ _N_ } #-}
instance Ord ExitCode
{-# GHC_PRAGMA _M_ LibSystem {-dfun-} _A_ 0 _N_ _N_ _N_ _F_ _IF_ARGS_ 0 0 X 9 _!_ _TUP_8 [{{Eq ExitCode}}, (ExitCode -> ExitCode -> Bool), (ExitCode -> ExitCode -> Bool), (ExitCode -> ExitCode -> Bool), (ExitCode -> ExitCode -> Bool), (ExitCode -> ExitCode -> ExitCode), (ExitCode -> ExitCode -> ExitCode), (ExitCode -> ExitCode -> _CMP_TAG)] [_DFUN_ Eq (ExitCode), _CONSTM_ Ord (<) (ExitCode), _CONSTM_ Ord (<=) (ExitCode), _CONSTM_ Ord (>=) (ExitCode), _CONSTM_ Ord (>) (ExitCode), _CONSTM_ Ord max (ExitCode), _CONSTM_ Ord min (ExitCode), _CONSTM_ Ord _tagCmp (ExitCode)] _N_
- (<) = _A_ 2 _U_ 22 _N_ _S_ "SS" _N_ _N_,
- (<=) = _A_ 2 _U_ 22 _N_ _S_ "SS" _N_ _N_,
- (>=) = _A_ 2 _U_ 22 _N_ _S_ "SS" _N_ _N_,
- (>) = _A_ 2 _U_ 22 _N_ _S_ "SS" _N_ _N_,
- max = _A_ 2 _U_ 22 _N_ _S_ "SS" _N_ _N_,
- min = _A_ 2 _U_ 22 _N_ _S_ "SS" _N_ _N_,
- _tagCmp = _A_ 2 _U_ 22 _N_ _S_ "SS" _N_ _N_ #-}
+ (<) = { _A_ 2 _U_ 22 _N_ _S_ "SS" _N_ _N_ },
+ (<=) = { _A_ 2 _U_ 22 _N_ _S_ "SS" _N_ _N_ },
+ (>=) = { _A_ 2 _U_ 22 _N_ _S_ "SS" _N_ _N_ },
+ (>) = { _A_ 2 _U_ 22 _N_ _S_ "SS" _N_ _N_ },
+ max = { _A_ 2 _U_ 22 _N_ _S_ "SS" _N_ _N_ },
+ min = { _A_ 2 _U_ 22 _N_ _S_ "SS" _N_ _N_ },
+ _tagCmp = { _A_ 2 _U_ 22 _N_ _S_ "SS" _N_ _N_ } #-}
instance Text ProcessStatus
{-# GHC_PRAGMA _M_ LibPosixProcPrim {-dfun-} _A_ 0 _N_ _N_ _N_ _F_ _IF_ARGS_ 0 0 X 5 _!_ _TUP_4 [(Int -> [Char] -> [(ProcessStatus, [Char])]), (Int -> ProcessStatus -> [Char] -> [Char]), ([Char] -> [([ProcessStatus], [Char])]), ([ProcessStatus] -> [Char] -> [Char])] [_CONSTM_ Text readsPrec (ProcessStatus), _CONSTM_ Text showsPrec (ProcessStatus), _CONSTM_ Text readList (ProcessStatus), _CONSTM_ Text showList (ProcessStatus)] _N_
- readsPrec = _A_ 2 _U_ 12 _N_ _S_ "U(P)L" {_A_ 2 _U_ 22 _N_ _N_ _N_ _N_} _N_ _N_,
- showsPrec = _A_ 2 _U_ 112 _N_ _S_ "LS" _N_ _N_,
- readList = _A_ 0 _U_ 2 _N_ _N_ _N_ _N_,
- showList = _A_ 0 _U_ 12 _N_ _N_ _N_ _N_ #-}
+ readsPrec = { _A_ 2 _U_ 12 _N_ _S_ "U(P)L" {_A_ 2 _U_ 22 _N_ _N_ _N_ _N_} _N_ _N_ },
+ showsPrec = { _A_ 2 _U_ 112 _N_ _S_ "LS" _N_ _N_ },
+ readList = { _A_ 0 _U_ 2 _N_ _N_ _N_ _N_ },
+ showList = { _A_ 0 _U_ 12 _N_ _N_ _N_ _N_ } #-}
instance Text ExitCode
{-# GHC_PRAGMA _M_ LibSystem {-dfun-} _A_ 0 _N_ _N_ _N_ _F_ _IF_ARGS_ 0 0 X 5 _!_ _TUP_4 [(Int -> [Char] -> [(ExitCode, [Char])]), (Int -> ExitCode -> [Char] -> [Char]), ([Char] -> [([ExitCode], [Char])]), ([ExitCode] -> [Char] -> [Char])] [_CONSTM_ Text readsPrec (ExitCode), _CONSTM_ Text showsPrec (ExitCode), _CONSTM_ Text readList (ExitCode), _CONSTM_ Text showList (ExitCode)] _N_
- readsPrec = _A_ 2 _U_ 12 _N_ _N_ _N_ _N_,
- showsPrec = _A_ 2 _U_ 112 _N_ _S_ "LS" _N_ _N_,
- readList = _A_ 0 _U_ 2 _N_ _N_ _N_ _N_,
- showList = _A_ 0 _U_ 12 _N_ _N_ _N_ _N_ #-}
+ readsPrec = { _A_ 2 _U_ 12 _N_ _N_ _N_ _N_ },
+ showsPrec = { _A_ 2 _U_ 112 _N_ _S_ "LS" _N_ _N_ },
+ readList = { _A_ 0 _U_ 2 _N_ _N_ _N_ _N_ },
+ showList = { _A_ 0 _U_ 12 _N_ _N_ _N_ _N_ } #-}
-{-# GHC_PRAGMA INTERFACE VERSION 5 #-}
+{-# GHC_PRAGMA INTERFACE VERSION 6 #-}
interface LibPosix where
import LibDirectory(getCurrentDirectory, removeDirectory, setCurrentDirectory)
import LibPosixDB(GroupEntry(..), UserEntry(..), getGroupEntryForID, getGroupEntryForName, getUserEntryForID, getUserEntryForName, groupID, groupMembers, groupName, homeDirectory, userGroupID, userID, userName, userShell)
inSignalSet :: Int -> _ByteArray () -> Bool
{-# GHC_PRAGMA _A_ 2 _U_ 11 _N_ _S_ "U(P)U(AP)" {_A_ 2 _U_ 22 _N_ _N_ _N_ _N_} _N_ _N_ #-}
installHandler :: Int -> Handler -> Maybe (_ByteArray ()) -> _State _RealWorld -> (Either IOError13 Handler, _State _RealWorld)
- {-# GHC_PRAGMA _A_ 4 _U_ 2222 _N_ _S_ _!_ _F_ _IF_ARGS_ 0 4 XXXX 6 \ (u0 :: Int) (u1 :: Handler) (u2 :: Maybe (_ByteArray ())) (u3 :: _State _RealWorld) -> _APP_ _TYAPP_ error { (Int -> Handler -> Maybe (_ByteArray ()) -> _State _RealWorld -> (Either IOError13 Handler, _State _RealWorld)) } [ _NOREP_S_ "installHandler: not available for Parallel Haskell", u0, u1, u2, u3 ] _N_ #-}
+ {-# GHC_PRAGMA _A_ 4 _U_ 2222 _N_ _S_ _!_ _N_ _N_ #-}
internalAbort :: Int
{-# GHC_PRAGMA _A_ 0 _N_ _N_ _N_ _N_ _N_ #-}
keyboardSignal :: Int
{-# GHC_PRAGMA _A_ 2 _U_ 11 _N_ _S_ "U(AP)E" {_A_ 2 _U_ 21 _N_ _N_ _N_ _N_} _N_ _N_ #-}
instance Eq ProcessStatus
{-# GHC_PRAGMA _M_ LibPosixProcPrim {-dfun-} _A_ 0 _N_ _N_ _N_ _F_ _IF_ARGS_ 0 0 X 3 _!_ _TUP_2 [(ProcessStatus -> ProcessStatus -> Bool), (ProcessStatus -> ProcessStatus -> Bool)] [_CONSTM_ Eq (==) (ProcessStatus), _CONSTM_ Eq (/=) (ProcessStatus)] _N_
- (==) = _A_ 2 _U_ 11 _N_ _S_ "SS" _N_ _N_,
- (/=) = _A_ 2 _U_ 11 _N_ _S_ "SS" _N_ _N_ #-}
+ (==) = { _A_ 2 _U_ 11 _N_ _S_ "SS" _N_ _N_ },
+ (/=) = { _A_ 2 _U_ 11 _N_ _S_ "SS" _N_ _N_ } #-}
instance Eq ExitCode
{-# GHC_PRAGMA _M_ LibSystem {-dfun-} _A_ 0 _N_ _N_ _N_ _F_ _IF_ARGS_ 0 0 X 3 _!_ _TUP_2 [(ExitCode -> ExitCode -> Bool), (ExitCode -> ExitCode -> Bool)] [_CONSTM_ Eq (==) (ExitCode), _CONSTM_ Eq (/=) (ExitCode)] _N_
- (==) = _A_ 2 _U_ 22 _N_ _S_ "SS" _N_ _N_,
- (/=) = _A_ 2 _U_ 22 _N_ _S_ "SS" _N_ _N_ #-}
+ (==) = { _A_ 2 _U_ 22 _N_ _S_ "SS" _N_ _N_ },
+ (/=) = { _A_ 2 _U_ 22 _N_ _S_ "SS" _N_ _N_ } #-}
instance Ord ProcessStatus
{-# GHC_PRAGMA _M_ LibPosixProcPrim {-dfun-} _A_ 0 _N_ _N_ _N_ _F_ _IF_ARGS_ 0 0 X 9 _!_ _TUP_8 [{{Eq ProcessStatus}}, (ProcessStatus -> ProcessStatus -> Bool), (ProcessStatus -> ProcessStatus -> Bool), (ProcessStatus -> ProcessStatus -> Bool), (ProcessStatus -> ProcessStatus -> Bool), (ProcessStatus -> ProcessStatus -> ProcessStatus), (ProcessStatus -> ProcessStatus -> ProcessStatus), (ProcessStatus -> ProcessStatus -> _CMP_TAG)] [_DFUN_ Eq (ProcessStatus), _CONSTM_ Ord (<) (ProcessStatus), _CONSTM_ Ord (<=) (ProcessStatus), _CONSTM_ Ord (>=) (ProcessStatus), _CONSTM_ Ord (>) (ProcessStatus), _CONSTM_ Ord max (ProcessStatus), _CONSTM_ Ord min (ProcessStatus), _CONSTM_ Ord _tagCmp (ProcessStatus)] _N_
- (<) = _A_ 2 _U_ 22 _N_ _S_ "SS" _N_ _N_,
- (<=) = _A_ 2 _U_ 22 _N_ _S_ "SS" _N_ _N_,
- (>=) = _A_ 2 _U_ 22 _N_ _S_ "SS" _N_ _N_,
- (>) = _A_ 2 _U_ 22 _N_ _S_ "SS" _N_ _N_,
- max = _A_ 2 _U_ 22 _N_ _S_ "SS" _N_ _N_,
- min = _A_ 2 _U_ 22 _N_ _S_ "SS" _N_ _N_,
- _tagCmp = _A_ 2 _U_ 22 _N_ _S_ "SS" _N_ _N_ #-}
+ (<) = { _A_ 2 _U_ 22 _N_ _S_ "SS" _N_ _N_ },
+ (<=) = { _A_ 2 _U_ 22 _N_ _S_ "SS" _N_ _N_ },
+ (>=) = { _A_ 2 _U_ 22 _N_ _S_ "SS" _N_ _N_ },
+ (>) = { _A_ 2 _U_ 22 _N_ _S_ "SS" _N_ _N_ },
+ max = { _A_ 2 _U_ 22 _N_ _S_ "SS" _N_ _N_ },
+ min = { _A_ 2 _U_ 22 _N_ _S_ "SS" _N_ _N_ },
+ _tagCmp = { _A_ 2 _U_ 22 _N_ _S_ "SS" _N_ _N_ } #-}
instance Ord ExitCode
{-# GHC_PRAGMA _M_ LibSystem {-dfun-} _A_ 0 _N_ _N_ _N_ _F_ _IF_ARGS_ 0 0 X 9 _!_ _TUP_8 [{{Eq ExitCode}}, (ExitCode -> ExitCode -> Bool), (ExitCode -> ExitCode -> Bool), (ExitCode -> ExitCode -> Bool), (ExitCode -> ExitCode -> Bool), (ExitCode -> ExitCode -> ExitCode), (ExitCode -> ExitCode -> ExitCode), (ExitCode -> ExitCode -> _CMP_TAG)] [_DFUN_ Eq (ExitCode), _CONSTM_ Ord (<) (ExitCode), _CONSTM_ Ord (<=) (ExitCode), _CONSTM_ Ord (>=) (ExitCode), _CONSTM_ Ord (>) (ExitCode), _CONSTM_ Ord max (ExitCode), _CONSTM_ Ord min (ExitCode), _CONSTM_ Ord _tagCmp (ExitCode)] _N_
- (<) = _A_ 2 _U_ 22 _N_ _S_ "SS" _N_ _N_,
- (<=) = _A_ 2 _U_ 22 _N_ _S_ "SS" _N_ _N_,
- (>=) = _A_ 2 _U_ 22 _N_ _S_ "SS" _N_ _N_,
- (>) = _A_ 2 _U_ 22 _N_ _S_ "SS" _N_ _N_,
- max = _A_ 2 _U_ 22 _N_ _S_ "SS" _N_ _N_,
- min = _A_ 2 _U_ 22 _N_ _S_ "SS" _N_ _N_,
- _tagCmp = _A_ 2 _U_ 22 _N_ _S_ "SS" _N_ _N_ #-}
+ (<) = { _A_ 2 _U_ 22 _N_ _S_ "SS" _N_ _N_ },
+ (<=) = { _A_ 2 _U_ 22 _N_ _S_ "SS" _N_ _N_ },
+ (>=) = { _A_ 2 _U_ 22 _N_ _S_ "SS" _N_ _N_ },
+ (>) = { _A_ 2 _U_ 22 _N_ _S_ "SS" _N_ _N_ },
+ max = { _A_ 2 _U_ 22 _N_ _S_ "SS" _N_ _N_ },
+ min = { _A_ 2 _U_ 22 _N_ _S_ "SS" _N_ _N_ },
+ _tagCmp = { _A_ 2 _U_ 22 _N_ _S_ "SS" _N_ _N_ } #-}
instance Text ProcessStatus
{-# GHC_PRAGMA _M_ LibPosixProcPrim {-dfun-} _A_ 0 _N_ _N_ _N_ _F_ _IF_ARGS_ 0 0 X 5 _!_ _TUP_4 [(Int -> [Char] -> [(ProcessStatus, [Char])]), (Int -> ProcessStatus -> [Char] -> [Char]), ([Char] -> [([ProcessStatus], [Char])]), ([ProcessStatus] -> [Char] -> [Char])] [_CONSTM_ Text readsPrec (ProcessStatus), _CONSTM_ Text showsPrec (ProcessStatus), _CONSTM_ Text readList (ProcessStatus), _CONSTM_ Text showList (ProcessStatus)] _N_
- readsPrec = _A_ 2 _U_ 12 _N_ _S_ "U(P)L" {_A_ 2 _U_ 22 _N_ _N_ _N_ _N_} _N_ _N_,
- showsPrec = _A_ 2 _U_ 112 _N_ _S_ "LS" _N_ _N_,
- readList = _A_ 0 _U_ 2 _N_ _N_ _N_ _N_,
- showList = _A_ 0 _U_ 12 _N_ _N_ _N_ _N_ #-}
+ readsPrec = { _A_ 2 _U_ 12 _N_ _S_ "U(P)L" {_A_ 2 _U_ 22 _N_ _N_ _N_ _N_} _N_ _N_ },
+ showsPrec = { _A_ 2 _U_ 112 _N_ _S_ "LS" _N_ _N_ },
+ readList = { _A_ 0 _U_ 2 _N_ _N_ _N_ _N_ },
+ showList = { _A_ 0 _U_ 12 _N_ _N_ _N_ _N_ } #-}
instance Text ExitCode
{-# GHC_PRAGMA _M_ LibSystem {-dfun-} _A_ 0 _N_ _N_ _N_ _F_ _IF_ARGS_ 0 0 X 5 _!_ _TUP_4 [(Int -> [Char] -> [(ExitCode, [Char])]), (Int -> ExitCode -> [Char] -> [Char]), ([Char] -> [([ExitCode], [Char])]), ([ExitCode] -> [Char] -> [Char])] [_CONSTM_ Text readsPrec (ExitCode), _CONSTM_ Text showsPrec (ExitCode), _CONSTM_ Text readList (ExitCode), _CONSTM_ Text showList (ExitCode)] _N_
- readsPrec = _A_ 2 _U_ 12 _N_ _N_ _N_ _N_,
- showsPrec = _A_ 2 _U_ 112 _N_ _S_ "LS" _N_ _N_,
- readList = _A_ 0 _U_ 2 _N_ _N_ _N_ _N_,
- showList = _A_ 0 _U_ 12 _N_ _N_ _N_ _N_ #-}
+ readsPrec = { _A_ 2 _U_ 12 _N_ _N_ _N_ _N_ },
+ showsPrec = { _A_ 2 _U_ 112 _N_ _S_ "LS" _N_ _N_ },
+ readList = { _A_ 0 _U_ 2 _N_ _N_ _N_ _N_ },
+ showList = { _A_ 0 _U_ 12 _N_ _N_ _N_ _N_ } #-}
-{-# GHC_PRAGMA INTERFACE VERSION 5 #-}
+{-# GHC_PRAGMA INTERFACE VERSION 6 #-}
interface LibPosix where
import LibDirectory(getCurrentDirectory, removeDirectory, setCurrentDirectory)
import LibPosixDB(GroupEntry(..), UserEntry(..), getGroupEntryForID, getGroupEntryForName, getUserEntryForID, getUserEntryForName, groupID, groupMembers, groupName, homeDirectory, userGroupID, userID, userName, userShell)
{-# GHC_PRAGMA _A_ 2 _U_ 11 _N_ _S_ "U(AP)E" {_A_ 2 _U_ 21 _N_ _N_ _N_ _N_} _N_ _N_ #-}
instance Eq ProcessStatus
{-# GHC_PRAGMA _M_ LibPosixProcPrim {-dfun-} _A_ 0 _N_ _N_ _N_ _F_ _IF_ARGS_ 0 0 X 3 _!_ _TUP_2 [(ProcessStatus -> ProcessStatus -> Bool), (ProcessStatus -> ProcessStatus -> Bool)] [_CONSTM_ Eq (==) (ProcessStatus), _CONSTM_ Eq (/=) (ProcessStatus)] _N_
- (==) = _A_ 2 _U_ 11 _N_ _S_ "SS" _N_ _N_,
- (/=) = _A_ 2 _U_ 11 _N_ _S_ "SS" _N_ _N_ #-}
+ (==) = { _A_ 2 _U_ 11 _N_ _S_ "SS" _N_ _N_ },
+ (/=) = { _A_ 2 _U_ 11 _N_ _S_ "SS" _N_ _N_ } #-}
instance Eq ExitCode
{-# GHC_PRAGMA _M_ LibSystem {-dfun-} _A_ 0 _N_ _N_ _N_ _F_ _IF_ARGS_ 0 0 X 3 _!_ _TUP_2 [(ExitCode -> ExitCode -> Bool), (ExitCode -> ExitCode -> Bool)] [_CONSTM_ Eq (==) (ExitCode), _CONSTM_ Eq (/=) (ExitCode)] _N_
- (==) = _A_ 2 _U_ 22 _N_ _S_ "SS" _N_ _N_,
- (/=) = _A_ 2 _U_ 22 _N_ _S_ "SS" _N_ _N_ #-}
+ (==) = { _A_ 2 _U_ 22 _N_ _S_ "SS" _N_ _N_ },
+ (/=) = { _A_ 2 _U_ 22 _N_ _S_ "SS" _N_ _N_ } #-}
instance Ord ProcessStatus
{-# GHC_PRAGMA _M_ LibPosixProcPrim {-dfun-} _A_ 0 _N_ _N_ _N_ _F_ _IF_ARGS_ 0 0 X 9 _!_ _TUP_8 [{{Eq ProcessStatus}}, (ProcessStatus -> ProcessStatus -> Bool), (ProcessStatus -> ProcessStatus -> Bool), (ProcessStatus -> ProcessStatus -> Bool), (ProcessStatus -> ProcessStatus -> Bool), (ProcessStatus -> ProcessStatus -> ProcessStatus), (ProcessStatus -> ProcessStatus -> ProcessStatus), (ProcessStatus -> ProcessStatus -> _CMP_TAG)] [_DFUN_ Eq (ProcessStatus), _CONSTM_ Ord (<) (ProcessStatus), _CONSTM_ Ord (<=) (ProcessStatus), _CONSTM_ Ord (>=) (ProcessStatus), _CONSTM_ Ord (>) (ProcessStatus), _CONSTM_ Ord max (ProcessStatus), _CONSTM_ Ord min (ProcessStatus), _CONSTM_ Ord _tagCmp (ProcessStatus)] _N_
- (<) = _A_ 2 _U_ 22 _N_ _S_ "SS" _N_ _N_,
- (<=) = _A_ 2 _U_ 22 _N_ _S_ "SS" _N_ _N_,
- (>=) = _A_ 2 _U_ 22 _N_ _S_ "SS" _N_ _N_,
- (>) = _A_ 2 _U_ 22 _N_ _S_ "SS" _N_ _N_,
- max = _A_ 2 _U_ 22 _N_ _S_ "SS" _N_ _N_,
- min = _A_ 2 _U_ 22 _N_ _S_ "SS" _N_ _N_,
- _tagCmp = _A_ 2 _U_ 22 _N_ _S_ "SS" _N_ _N_ #-}
+ (<) = { _A_ 2 _U_ 22 _N_ _S_ "SS" _N_ _N_ },
+ (<=) = { _A_ 2 _U_ 22 _N_ _S_ "SS" _N_ _N_ },
+ (>=) = { _A_ 2 _U_ 22 _N_ _S_ "SS" _N_ _N_ },
+ (>) = { _A_ 2 _U_ 22 _N_ _S_ "SS" _N_ _N_ },
+ max = { _A_ 2 _U_ 22 _N_ _S_ "SS" _N_ _N_ },
+ min = { _A_ 2 _U_ 22 _N_ _S_ "SS" _N_ _N_ },
+ _tagCmp = { _A_ 2 _U_ 22 _N_ _S_ "SS" _N_ _N_ } #-}
instance Ord ExitCode
{-# GHC_PRAGMA _M_ LibSystem {-dfun-} _A_ 0 _N_ _N_ _N_ _F_ _IF_ARGS_ 0 0 X 9 _!_ _TUP_8 [{{Eq ExitCode}}, (ExitCode -> ExitCode -> Bool), (ExitCode -> ExitCode -> Bool), (ExitCode -> ExitCode -> Bool), (ExitCode -> ExitCode -> Bool), (ExitCode -> ExitCode -> ExitCode), (ExitCode -> ExitCode -> ExitCode), (ExitCode -> ExitCode -> _CMP_TAG)] [_DFUN_ Eq (ExitCode), _CONSTM_ Ord (<) (ExitCode), _CONSTM_ Ord (<=) (ExitCode), _CONSTM_ Ord (>=) (ExitCode), _CONSTM_ Ord (>) (ExitCode), _CONSTM_ Ord max (ExitCode), _CONSTM_ Ord min (ExitCode), _CONSTM_ Ord _tagCmp (ExitCode)] _N_
- (<) = _A_ 2 _U_ 22 _N_ _S_ "SS" _N_ _N_,
- (<=) = _A_ 2 _U_ 22 _N_ _S_ "SS" _N_ _N_,
- (>=) = _A_ 2 _U_ 22 _N_ _S_ "SS" _N_ _N_,
- (>) = _A_ 2 _U_ 22 _N_ _S_ "SS" _N_ _N_,
- max = _A_ 2 _U_ 22 _N_ _S_ "SS" _N_ _N_,
- min = _A_ 2 _U_ 22 _N_ _S_ "SS" _N_ _N_,
- _tagCmp = _A_ 2 _U_ 22 _N_ _S_ "SS" _N_ _N_ #-}
+ (<) = { _A_ 2 _U_ 22 _N_ _S_ "SS" _N_ _N_ },
+ (<=) = { _A_ 2 _U_ 22 _N_ _S_ "SS" _N_ _N_ },
+ (>=) = { _A_ 2 _U_ 22 _N_ _S_ "SS" _N_ _N_ },
+ (>) = { _A_ 2 _U_ 22 _N_ _S_ "SS" _N_ _N_ },
+ max = { _A_ 2 _U_ 22 _N_ _S_ "SS" _N_ _N_ },
+ min = { _A_ 2 _U_ 22 _N_ _S_ "SS" _N_ _N_ },
+ _tagCmp = { _A_ 2 _U_ 22 _N_ _S_ "SS" _N_ _N_ } #-}
instance Text ProcessStatus
{-# GHC_PRAGMA _M_ LibPosixProcPrim {-dfun-} _A_ 0 _N_ _N_ _N_ _F_ _IF_ARGS_ 0 0 X 5 _!_ _TUP_4 [(Int -> [Char] -> [(ProcessStatus, [Char])]), (Int -> ProcessStatus -> [Char] -> [Char]), ([Char] -> [([ProcessStatus], [Char])]), ([ProcessStatus] -> [Char] -> [Char])] [_CONSTM_ Text readsPrec (ProcessStatus), _CONSTM_ Text showsPrec (ProcessStatus), _CONSTM_ Text readList (ProcessStatus), _CONSTM_ Text showList (ProcessStatus)] _N_
- readsPrec = _A_ 2 _U_ 12 _N_ _S_ "U(P)L" {_A_ 2 _U_ 22 _N_ _N_ _N_ _N_} _N_ _N_,
- showsPrec = _A_ 2 _U_ 112 _N_ _S_ "LS" _N_ _N_,
- readList = _A_ 0 _U_ 2 _N_ _N_ _N_ _N_,
- showList = _A_ 0 _U_ 12 _N_ _N_ _N_ _N_ #-}
+ readsPrec = { _A_ 2 _U_ 12 _N_ _S_ "U(P)L" {_A_ 2 _U_ 22 _N_ _N_ _N_ _N_} _N_ _N_ },
+ showsPrec = { _A_ 2 _U_ 112 _N_ _S_ "LS" _N_ _N_ },
+ readList = { _A_ 0 _U_ 2 _N_ _N_ _N_ _N_ },
+ showList = { _A_ 0 _U_ 12 _N_ _N_ _N_ _N_ } #-}
instance Text ExitCode
{-# GHC_PRAGMA _M_ LibSystem {-dfun-} _A_ 0 _N_ _N_ _N_ _F_ _IF_ARGS_ 0 0 X 5 _!_ _TUP_4 [(Int -> [Char] -> [(ExitCode, [Char])]), (Int -> ExitCode -> [Char] -> [Char]), ([Char] -> [([ExitCode], [Char])]), ([ExitCode] -> [Char] -> [Char])] [_CONSTM_ Text readsPrec (ExitCode), _CONSTM_ Text showsPrec (ExitCode), _CONSTM_ Text readList (ExitCode), _CONSTM_ Text showList (ExitCode)] _N_
- readsPrec = _A_ 2 _U_ 12 _N_ _N_ _N_ _N_,
- showsPrec = _A_ 2 _U_ 112 _N_ _S_ "LS" _N_ _N_,
- readList = _A_ 0 _U_ 2 _N_ _N_ _N_ _N_,
- showList = _A_ 0 _U_ 12 _N_ _N_ _N_ _N_ #-}
+ readsPrec = { _A_ 2 _U_ 12 _N_ _N_ _N_ _N_ },
+ showsPrec = { _A_ 2 _U_ 112 _N_ _S_ "LS" _N_ _N_ },
+ readList = { _A_ 0 _U_ 2 _N_ _N_ _N_ _N_ },
+ showList = { _A_ 0 _U_ 12 _N_ _N_ _N_ _N_ } #-}
-{-# GHC_PRAGMA INTERFACE VERSION 5 #-}
+{-# GHC_PRAGMA INTERFACE VERSION 6 #-}
interface LibPosix where
import LibDirectory(getCurrentDirectory, removeDirectory, setCurrentDirectory)
import LibPosixDB(GroupEntry(..), UserEntry(..), getGroupEntryForID, getGroupEntryForName, getUserEntryForID, getUserEntryForName, groupID, groupMembers, groupName, homeDirectory, userGroupID, userID, userName, userShell)
{-# GHC_PRAGMA _A_ 2 _U_ 11 _N_ _S_ "U(AP)E" {_A_ 2 _U_ 21 _N_ _N_ _N_ _N_} _N_ _N_ #-}
instance Eq ProcessStatus
{-# GHC_PRAGMA _M_ LibPosixProcPrim {-dfun-} _A_ 0 _N_ _N_ _N_ _F_ _IF_ARGS_ 0 0 X 3 _!_ _TUP_2 [(ProcessStatus -> ProcessStatus -> Bool), (ProcessStatus -> ProcessStatus -> Bool)] [_CONSTM_ Eq (==) (ProcessStatus), _CONSTM_ Eq (/=) (ProcessStatus)] _N_
- (==) = _A_ 2 _U_ 11 _N_ _S_ "SS" _N_ _N_,
- (/=) = _A_ 2 _U_ 11 _N_ _S_ "SS" _N_ _N_ #-}
+ (==) = { _A_ 2 _U_ 11 _N_ _S_ "SS" _N_ _N_ },
+ (/=) = { _A_ 2 _U_ 11 _N_ _S_ "SS" _N_ _N_ } #-}
instance Eq ExitCode
{-# GHC_PRAGMA _M_ LibSystem {-dfun-} _A_ 0 _N_ _N_ _N_ _F_ _IF_ARGS_ 0 0 X 3 _!_ _TUP_2 [(ExitCode -> ExitCode -> Bool), (ExitCode -> ExitCode -> Bool)] [_CONSTM_ Eq (==) (ExitCode), _CONSTM_ Eq (/=) (ExitCode)] _N_
- (==) = _A_ 2 _U_ 22 _N_ _S_ "SS" _N_ _N_,
- (/=) = _A_ 2 _U_ 22 _N_ _S_ "SS" _N_ _N_ #-}
+ (==) = { _A_ 2 _U_ 22 _N_ _S_ "SS" _N_ _N_ },
+ (/=) = { _A_ 2 _U_ 22 _N_ _S_ "SS" _N_ _N_ } #-}
instance Ord ProcessStatus
{-# GHC_PRAGMA _M_ LibPosixProcPrim {-dfun-} _A_ 0 _N_ _N_ _N_ _F_ _IF_ARGS_ 0 0 X 9 _!_ _TUP_8 [{{Eq ProcessStatus}}, (ProcessStatus -> ProcessStatus -> Bool), (ProcessStatus -> ProcessStatus -> Bool), (ProcessStatus -> ProcessStatus -> Bool), (ProcessStatus -> ProcessStatus -> Bool), (ProcessStatus -> ProcessStatus -> ProcessStatus), (ProcessStatus -> ProcessStatus -> ProcessStatus), (ProcessStatus -> ProcessStatus -> _CMP_TAG)] [_DFUN_ Eq (ProcessStatus), _CONSTM_ Ord (<) (ProcessStatus), _CONSTM_ Ord (<=) (ProcessStatus), _CONSTM_ Ord (>=) (ProcessStatus), _CONSTM_ Ord (>) (ProcessStatus), _CONSTM_ Ord max (ProcessStatus), _CONSTM_ Ord min (ProcessStatus), _CONSTM_ Ord _tagCmp (ProcessStatus)] _N_
- (<) = _A_ 2 _U_ 22 _N_ _S_ "SS" _N_ _N_,
- (<=) = _A_ 2 _U_ 22 _N_ _S_ "SS" _N_ _N_,
- (>=) = _A_ 2 _U_ 22 _N_ _S_ "SS" _N_ _N_,
- (>) = _A_ 2 _U_ 22 _N_ _S_ "SS" _N_ _N_,
- max = _A_ 2 _U_ 22 _N_ _S_ "SS" _N_ _N_,
- min = _A_ 2 _U_ 22 _N_ _S_ "SS" _N_ _N_,
- _tagCmp = _A_ 2 _U_ 22 _N_ _S_ "SS" _N_ _N_ #-}
+ (<) = { _A_ 2 _U_ 22 _N_ _S_ "SS" _N_ _N_ },
+ (<=) = { _A_ 2 _U_ 22 _N_ _S_ "SS" _N_ _N_ },
+ (>=) = { _A_ 2 _U_ 22 _N_ _S_ "SS" _N_ _N_ },
+ (>) = { _A_ 2 _U_ 22 _N_ _S_ "SS" _N_ _N_ },
+ max = { _A_ 2 _U_ 22 _N_ _S_ "SS" _N_ _N_ },
+ min = { _A_ 2 _U_ 22 _N_ _S_ "SS" _N_ _N_ },
+ _tagCmp = { _A_ 2 _U_ 22 _N_ _S_ "SS" _N_ _N_ } #-}
instance Ord ExitCode
{-# GHC_PRAGMA _M_ LibSystem {-dfun-} _A_ 0 _N_ _N_ _N_ _F_ _IF_ARGS_ 0 0 X 9 _!_ _TUP_8 [{{Eq ExitCode}}, (ExitCode -> ExitCode -> Bool), (ExitCode -> ExitCode -> Bool), (ExitCode -> ExitCode -> Bool), (ExitCode -> ExitCode -> Bool), (ExitCode -> ExitCode -> ExitCode), (ExitCode -> ExitCode -> ExitCode), (ExitCode -> ExitCode -> _CMP_TAG)] [_DFUN_ Eq (ExitCode), _CONSTM_ Ord (<) (ExitCode), _CONSTM_ Ord (<=) (ExitCode), _CONSTM_ Ord (>=) (ExitCode), _CONSTM_ Ord (>) (ExitCode), _CONSTM_ Ord max (ExitCode), _CONSTM_ Ord min (ExitCode), _CONSTM_ Ord _tagCmp (ExitCode)] _N_
- (<) = _A_ 2 _U_ 22 _N_ _S_ "SS" _N_ _N_,
- (<=) = _A_ 2 _U_ 22 _N_ _S_ "SS" _N_ _N_,
- (>=) = _A_ 2 _U_ 22 _N_ _S_ "SS" _N_ _N_,
- (>) = _A_ 2 _U_ 22 _N_ _S_ "SS" _N_ _N_,
- max = _A_ 2 _U_ 22 _N_ _S_ "SS" _N_ _N_,
- min = _A_ 2 _U_ 22 _N_ _S_ "SS" _N_ _N_,
- _tagCmp = _A_ 2 _U_ 22 _N_ _S_ "SS" _N_ _N_ #-}
+ (<) = { _A_ 2 _U_ 22 _N_ _S_ "SS" _N_ _N_ },
+ (<=) = { _A_ 2 _U_ 22 _N_ _S_ "SS" _N_ _N_ },
+ (>=) = { _A_ 2 _U_ 22 _N_ _S_ "SS" _N_ _N_ },
+ (>) = { _A_ 2 _U_ 22 _N_ _S_ "SS" _N_ _N_ },
+ max = { _A_ 2 _U_ 22 _N_ _S_ "SS" _N_ _N_ },
+ min = { _A_ 2 _U_ 22 _N_ _S_ "SS" _N_ _N_ },
+ _tagCmp = { _A_ 2 _U_ 22 _N_ _S_ "SS" _N_ _N_ } #-}
instance Text ProcessStatus
{-# GHC_PRAGMA _M_ LibPosixProcPrim {-dfun-} _A_ 0 _N_ _N_ _N_ _F_ _IF_ARGS_ 0 0 X 5 _!_ _TUP_4 [(Int -> [Char] -> [(ProcessStatus, [Char])]), (Int -> ProcessStatus -> [Char] -> [Char]), ([Char] -> [([ProcessStatus], [Char])]), ([ProcessStatus] -> [Char] -> [Char])] [_CONSTM_ Text readsPrec (ProcessStatus), _CONSTM_ Text showsPrec (ProcessStatus), _CONSTM_ Text readList (ProcessStatus), _CONSTM_ Text showList (ProcessStatus)] _N_
- readsPrec = _A_ 2 _U_ 12 _N_ _S_ "U(P)L" {_A_ 2 _U_ 22 _N_ _N_ _N_ _N_} _N_ _N_,
- showsPrec = _A_ 2 _U_ 112 _N_ _S_ "LS" _N_ _N_,
- readList = _A_ 0 _U_ 2 _N_ _N_ _N_ _N_,
- showList = _A_ 0 _U_ 12 _N_ _N_ _N_ _N_ #-}
+ readsPrec = { _A_ 2 _U_ 12 _N_ _S_ "U(P)L" {_A_ 2 _U_ 22 _N_ _N_ _N_ _N_} _N_ _N_ },
+ showsPrec = { _A_ 2 _U_ 112 _N_ _S_ "LS" _N_ _N_ },
+ readList = { _A_ 0 _U_ 2 _N_ _N_ _N_ _N_ },
+ showList = { _A_ 0 _U_ 12 _N_ _N_ _N_ _N_ } #-}
instance Text ExitCode
{-# GHC_PRAGMA _M_ LibSystem {-dfun-} _A_ 0 _N_ _N_ _N_ _F_ _IF_ARGS_ 0 0 X 5 _!_ _TUP_4 [(Int -> [Char] -> [(ExitCode, [Char])]), (Int -> ExitCode -> [Char] -> [Char]), ([Char] -> [([ExitCode], [Char])]), ([ExitCode] -> [Char] -> [Char])] [_CONSTM_ Text readsPrec (ExitCode), _CONSTM_ Text showsPrec (ExitCode), _CONSTM_ Text readList (ExitCode), _CONSTM_ Text showList (ExitCode)] _N_
- readsPrec = _A_ 2 _U_ 12 _N_ _N_ _N_ _N_,
- showsPrec = _A_ 2 _U_ 112 _N_ _S_ "LS" _N_ _N_,
- readList = _A_ 0 _U_ 2 _N_ _N_ _N_ _N_,
- showList = _A_ 0 _U_ 12 _N_ _N_ _N_ _N_ #-}
+ readsPrec = { _A_ 2 _U_ 12 _N_ _N_ _N_ _N_ },
+ showsPrec = { _A_ 2 _U_ 112 _N_ _S_ "LS" _N_ _N_ },
+ readList = { _A_ 0 _U_ 2 _N_ _N_ _N_ _N_ },
+ showList = { _A_ 0 _U_ 12 _N_ _N_ _N_ _N_ } #-}
-{-# GHC_PRAGMA INTERFACE VERSION 5 #-}
+{-# GHC_PRAGMA INTERFACE VERSION 6 #-}
interface LibSystem where
import PreludeIOError(IOError13)
import PreludeMonadicIO(Either)
{-# GHC_PRAGMA _A_ 2 _U_ 21 _N_ _S_ "SU(P)" {_A_ 2 _U_ 22 _N_ _N_ _N_ _N_} _N_ _N_ #-}
instance Eq ExitCode
{-# GHC_PRAGMA _M_ LibSystem {-dfun-} _A_ 0 _N_ _N_ _N_ _F_ _IF_ARGS_ 0 0 X 3 _!_ _TUP_2 [(ExitCode -> ExitCode -> Bool), (ExitCode -> ExitCode -> Bool)] [_CONSTM_ Eq (==) (ExitCode), _CONSTM_ Eq (/=) (ExitCode)] _N_
- (==) = _A_ 2 _U_ 22 _N_ _S_ "SS" _N_ _N_,
- (/=) = _A_ 2 _U_ 22 _N_ _S_ "SS" _N_ _N_ #-}
+ (==) = { _A_ 2 _U_ 22 _N_ _S_ "SS" _N_ _N_ },
+ (/=) = { _A_ 2 _U_ 22 _N_ _S_ "SS" _N_ _N_ } #-}
instance Ord ExitCode
{-# GHC_PRAGMA _M_ LibSystem {-dfun-} _A_ 0 _N_ _N_ _N_ _F_ _IF_ARGS_ 0 0 X 9 _!_ _TUP_8 [{{Eq ExitCode}}, (ExitCode -> ExitCode -> Bool), (ExitCode -> ExitCode -> Bool), (ExitCode -> ExitCode -> Bool), (ExitCode -> ExitCode -> Bool), (ExitCode -> ExitCode -> ExitCode), (ExitCode -> ExitCode -> ExitCode), (ExitCode -> ExitCode -> _CMP_TAG)] [_DFUN_ Eq (ExitCode), _CONSTM_ Ord (<) (ExitCode), _CONSTM_ Ord (<=) (ExitCode), _CONSTM_ Ord (>=) (ExitCode), _CONSTM_ Ord (>) (ExitCode), _CONSTM_ Ord max (ExitCode), _CONSTM_ Ord min (ExitCode), _CONSTM_ Ord _tagCmp (ExitCode)] _N_
- (<) = _A_ 2 _U_ 22 _N_ _S_ "SS" _N_ _N_,
- (<=) = _A_ 2 _U_ 22 _N_ _S_ "SS" _N_ _N_,
- (>=) = _A_ 2 _U_ 22 _N_ _S_ "SS" _N_ _N_,
- (>) = _A_ 2 _U_ 22 _N_ _S_ "SS" _N_ _N_,
- max = _A_ 2 _U_ 22 _N_ _S_ "SS" _N_ _N_,
- min = _A_ 2 _U_ 22 _N_ _S_ "SS" _N_ _N_,
- _tagCmp = _A_ 2 _U_ 22 _N_ _S_ "SS" _N_ _N_ #-}
+ (<) = { _A_ 2 _U_ 22 _N_ _S_ "SS" _N_ _N_ },
+ (<=) = { _A_ 2 _U_ 22 _N_ _S_ "SS" _N_ _N_ },
+ (>=) = { _A_ 2 _U_ 22 _N_ _S_ "SS" _N_ _N_ },
+ (>) = { _A_ 2 _U_ 22 _N_ _S_ "SS" _N_ _N_ },
+ max = { _A_ 2 _U_ 22 _N_ _S_ "SS" _N_ _N_ },
+ min = { _A_ 2 _U_ 22 _N_ _S_ "SS" _N_ _N_ },
+ _tagCmp = { _A_ 2 _U_ 22 _N_ _S_ "SS" _N_ _N_ } #-}
instance Text ExitCode
{-# GHC_PRAGMA _M_ LibSystem {-dfun-} _A_ 0 _N_ _N_ _N_ _F_ _IF_ARGS_ 0 0 X 5 _!_ _TUP_4 [(Int -> [Char] -> [(ExitCode, [Char])]), (Int -> ExitCode -> [Char] -> [Char]), ([Char] -> [([ExitCode], [Char])]), ([ExitCode] -> [Char] -> [Char])] [_CONSTM_ Text readsPrec (ExitCode), _CONSTM_ Text showsPrec (ExitCode), _CONSTM_ Text readList (ExitCode), _CONSTM_ Text showList (ExitCode)] _N_
- readsPrec = _A_ 2 _U_ 12 _N_ _N_ _N_ _N_,
- showsPrec = _A_ 2 _U_ 112 _N_ _S_ "LS" _N_ _N_,
- readList = _A_ 0 _U_ 2 _N_ _N_ _N_ _N_,
- showList = _A_ 0 _U_ 12 _N_ _N_ _N_ _N_ #-}
+ readsPrec = { _A_ 2 _U_ 12 _N_ _N_ _N_ _N_ },
+ showsPrec = { _A_ 2 _U_ 112 _N_ _S_ "LS" _N_ _N_ },
+ readList = { _A_ 0 _U_ 2 _N_ _N_ _N_ _N_ },
+ showList = { _A_ 0 _U_ 12 _N_ _N_ _N_ _N_ } #-}
-{-# GHC_PRAGMA INTERFACE VERSION 5 #-}
+{-# GHC_PRAGMA INTERFACE VERSION 6 #-}
interface LibSystem where
import PreludeIOError(IOError13)
import PreludeMonadicIO(Either)
{-# GHC_PRAGMA _A_ 2 _U_ 21 _N_ _S_ "SU(P)" {_A_ 2 _U_ 22 _N_ _N_ _N_ _N_} _N_ _N_ #-}
instance Eq ExitCode
{-# GHC_PRAGMA _M_ LibSystem {-dfun-} _A_ 0 _N_ _N_ _N_ _F_ _IF_ARGS_ 0 0 X 3 _!_ _TUP_2 [(ExitCode -> ExitCode -> Bool), (ExitCode -> ExitCode -> Bool)] [_CONSTM_ Eq (==) (ExitCode), _CONSTM_ Eq (/=) (ExitCode)] _N_
- (==) = _A_ 2 _U_ 22 _N_ _S_ "SS" _N_ _N_,
- (/=) = _A_ 2 _U_ 22 _N_ _S_ "SS" _N_ _N_ #-}
+ (==) = { _A_ 2 _U_ 22 _N_ _S_ "SS" _N_ _N_ },
+ (/=) = { _A_ 2 _U_ 22 _N_ _S_ "SS" _N_ _N_ } #-}
instance Ord ExitCode
{-# GHC_PRAGMA _M_ LibSystem {-dfun-} _A_ 0 _N_ _N_ _N_ _F_ _IF_ARGS_ 0 0 X 9 _!_ _TUP_8 [{{Eq ExitCode}}, (ExitCode -> ExitCode -> Bool), (ExitCode -> ExitCode -> Bool), (ExitCode -> ExitCode -> Bool), (ExitCode -> ExitCode -> Bool), (ExitCode -> ExitCode -> ExitCode), (ExitCode -> ExitCode -> ExitCode), (ExitCode -> ExitCode -> _CMP_TAG)] [_DFUN_ Eq (ExitCode), _CONSTM_ Ord (<) (ExitCode), _CONSTM_ Ord (<=) (ExitCode), _CONSTM_ Ord (>=) (ExitCode), _CONSTM_ Ord (>) (ExitCode), _CONSTM_ Ord max (ExitCode), _CONSTM_ Ord min (ExitCode), _CONSTM_ Ord _tagCmp (ExitCode)] _N_
- (<) = _A_ 2 _U_ 22 _N_ _S_ "SS" _N_ _N_,
- (<=) = _A_ 2 _U_ 22 _N_ _S_ "SS" _N_ _N_,
- (>=) = _A_ 2 _U_ 22 _N_ _S_ "SS" _N_ _N_,
- (>) = _A_ 2 _U_ 22 _N_ _S_ "SS" _N_ _N_,
- max = _A_ 2 _U_ 22 _N_ _S_ "SS" _N_ _N_,
- min = _A_ 2 _U_ 22 _N_ _S_ "SS" _N_ _N_,
- _tagCmp = _A_ 2 _U_ 22 _N_ _S_ "SS" _N_ _N_ #-}
+ (<) = { _A_ 2 _U_ 22 _N_ _S_ "SS" _N_ _N_ },
+ (<=) = { _A_ 2 _U_ 22 _N_ _S_ "SS" _N_ _N_ },
+ (>=) = { _A_ 2 _U_ 22 _N_ _S_ "SS" _N_ _N_ },
+ (>) = { _A_ 2 _U_ 22 _N_ _S_ "SS" _N_ _N_ },
+ max = { _A_ 2 _U_ 22 _N_ _S_ "SS" _N_ _N_ },
+ min = { _A_ 2 _U_ 22 _N_ _S_ "SS" _N_ _N_ },
+ _tagCmp = { _A_ 2 _U_ 22 _N_ _S_ "SS" _N_ _N_ } #-}
instance Text ExitCode
{-# GHC_PRAGMA _M_ LibSystem {-dfun-} _A_ 0 _N_ _N_ _N_ _F_ _IF_ARGS_ 0 0 X 5 _!_ _TUP_4 [(Int -> [Char] -> [(ExitCode, [Char])]), (Int -> ExitCode -> [Char] -> [Char]), ([Char] -> [([ExitCode], [Char])]), ([ExitCode] -> [Char] -> [Char])] [_CONSTM_ Text readsPrec (ExitCode), _CONSTM_ Text showsPrec (ExitCode), _CONSTM_ Text readList (ExitCode), _CONSTM_ Text showList (ExitCode)] _N_
- readsPrec = _A_ 2 _U_ 12 _N_ _N_ _N_ _N_,
- showsPrec = _A_ 2 _U_ 112 _N_ _S_ "LS" _N_ _N_,
- readList = _A_ 0 _U_ 2 _N_ _N_ _N_ _N_,
- showList = _A_ 0 _U_ 12 _N_ _N_ _N_ _N_ #-}
+ readsPrec = { _A_ 2 _U_ 12 _N_ _N_ _N_ _N_ },
+ showsPrec = { _A_ 2 _U_ 112 _N_ _S_ "LS" _N_ _N_ },
+ readList = { _A_ 0 _U_ 2 _N_ _N_ _N_ _N_ },
+ showList = { _A_ 0 _U_ 12 _N_ _N_ _N_ _N_ } #-}
-{-# GHC_PRAGMA INTERFACE VERSION 5 #-}
+{-# GHC_PRAGMA INTERFACE VERSION 6 #-}
interface LibSystem where
import PreludeIOError(IOError13)
import PreludeMonadicIO(Either)
{-# GHC_PRAGMA _A_ 2 _U_ 21 _N_ _S_ "SU(P)" {_A_ 2 _U_ 22 _N_ _N_ _N_ _N_} _N_ _N_ #-}
instance Eq ExitCode
{-# GHC_PRAGMA _M_ LibSystem {-dfun-} _A_ 0 _N_ _N_ _N_ _F_ _IF_ARGS_ 0 0 X 3 _!_ _TUP_2 [(ExitCode -> ExitCode -> Bool), (ExitCode -> ExitCode -> Bool)] [_CONSTM_ Eq (==) (ExitCode), _CONSTM_ Eq (/=) (ExitCode)] _N_
- (==) = _A_ 2 _U_ 22 _N_ _S_ "SS" _N_ _N_,
- (/=) = _A_ 2 _U_ 22 _N_ _S_ "SS" _N_ _N_ #-}
+ (==) = { _A_ 2 _U_ 22 _N_ _S_ "SS" _N_ _N_ },
+ (/=) = { _A_ 2 _U_ 22 _N_ _S_ "SS" _N_ _N_ } #-}
instance Ord ExitCode
{-# GHC_PRAGMA _M_ LibSystem {-dfun-} _A_ 0 _N_ _N_ _N_ _F_ _IF_ARGS_ 0 0 X 9 _!_ _TUP_8 [{{Eq ExitCode}}, (ExitCode -> ExitCode -> Bool), (ExitCode -> ExitCode -> Bool), (ExitCode -> ExitCode -> Bool), (ExitCode -> ExitCode -> Bool), (ExitCode -> ExitCode -> ExitCode), (ExitCode -> ExitCode -> ExitCode), (ExitCode -> ExitCode -> _CMP_TAG)] [_DFUN_ Eq (ExitCode), _CONSTM_ Ord (<) (ExitCode), _CONSTM_ Ord (<=) (ExitCode), _CONSTM_ Ord (>=) (ExitCode), _CONSTM_ Ord (>) (ExitCode), _CONSTM_ Ord max (ExitCode), _CONSTM_ Ord min (ExitCode), _CONSTM_ Ord _tagCmp (ExitCode)] _N_
- (<) = _A_ 2 _U_ 22 _N_ _S_ "SS" _N_ _N_,
- (<=) = _A_ 2 _U_ 22 _N_ _S_ "SS" _N_ _N_,
- (>=) = _A_ 2 _U_ 22 _N_ _S_ "SS" _N_ _N_,
- (>) = _A_ 2 _U_ 22 _N_ _S_ "SS" _N_ _N_,
- max = _A_ 2 _U_ 22 _N_ _S_ "SS" _N_ _N_,
- min = _A_ 2 _U_ 22 _N_ _S_ "SS" _N_ _N_,
- _tagCmp = _A_ 2 _U_ 22 _N_ _S_ "SS" _N_ _N_ #-}
+ (<) = { _A_ 2 _U_ 22 _N_ _S_ "SS" _N_ _N_ },
+ (<=) = { _A_ 2 _U_ 22 _N_ _S_ "SS" _N_ _N_ },
+ (>=) = { _A_ 2 _U_ 22 _N_ _S_ "SS" _N_ _N_ },
+ (>) = { _A_ 2 _U_ 22 _N_ _S_ "SS" _N_ _N_ },
+ max = { _A_ 2 _U_ 22 _N_ _S_ "SS" _N_ _N_ },
+ min = { _A_ 2 _U_ 22 _N_ _S_ "SS" _N_ _N_ },
+ _tagCmp = { _A_ 2 _U_ 22 _N_ _S_ "SS" _N_ _N_ } #-}
instance Text ExitCode
{-# GHC_PRAGMA _M_ LibSystem {-dfun-} _A_ 0 _N_ _N_ _N_ _F_ _IF_ARGS_ 0 0 X 5 _!_ _TUP_4 [(Int -> [Char] -> [(ExitCode, [Char])]), (Int -> ExitCode -> [Char] -> [Char]), ([Char] -> [([ExitCode], [Char])]), ([ExitCode] -> [Char] -> [Char])] [_CONSTM_ Text readsPrec (ExitCode), _CONSTM_ Text showsPrec (ExitCode), _CONSTM_ Text readList (ExitCode), _CONSTM_ Text showList (ExitCode)] _N_
- readsPrec = _A_ 2 _U_ 12 _N_ _N_ _N_ _N_,
- showsPrec = _A_ 2 _U_ 112 _N_ _S_ "LS" _N_ _N_,
- readList = _A_ 0 _U_ 2 _N_ _N_ _N_ _N_,
- showList = _A_ 0 _U_ 12 _N_ _N_ _N_ _N_ #-}
+ readsPrec = { _A_ 2 _U_ 12 _N_ _N_ _N_ _N_ },
+ showsPrec = { _A_ 2 _U_ 112 _N_ _S_ "LS" _N_ _N_ },
+ readList = { _A_ 0 _U_ 2 _N_ _N_ _N_ _N_ },
+ showList = { _A_ 0 _U_ 12 _N_ _N_ _N_ _N_ } #-}
-{-# GHC_PRAGMA INTERFACE VERSION 5 #-}
+{-# GHC_PRAGMA INTERFACE VERSION 6 #-}
interface LibSystem where
import PreludeIOError(IOError13)
import PreludeMonadicIO(Either)
{-# GHC_PRAGMA _A_ 2 _U_ 21 _N_ _S_ "SU(P)" {_A_ 2 _U_ 22 _N_ _N_ _N_ _N_} _N_ _N_ #-}
instance Eq ExitCode
{-# GHC_PRAGMA _M_ LibSystem {-dfun-} _A_ 0 _N_ _N_ _N_ _F_ _IF_ARGS_ 0 0 X 3 _!_ _TUP_2 [(ExitCode -> ExitCode -> Bool), (ExitCode -> ExitCode -> Bool)] [_CONSTM_ Eq (==) (ExitCode), _CONSTM_ Eq (/=) (ExitCode)] _N_
- (==) = _A_ 2 _U_ 22 _N_ _S_ "SS" _N_ _N_,
- (/=) = _A_ 2 _U_ 22 _N_ _S_ "SS" _N_ _N_ #-}
+ (==) = { _A_ 2 _U_ 22 _N_ _S_ "SS" _N_ _N_ },
+ (/=) = { _A_ 2 _U_ 22 _N_ _S_ "SS" _N_ _N_ } #-}
instance Ord ExitCode
{-# GHC_PRAGMA _M_ LibSystem {-dfun-} _A_ 0 _N_ _N_ _N_ _F_ _IF_ARGS_ 0 0 X 9 _!_ _TUP_8 [{{Eq ExitCode}}, (ExitCode -> ExitCode -> Bool), (ExitCode -> ExitCode -> Bool), (ExitCode -> ExitCode -> Bool), (ExitCode -> ExitCode -> Bool), (ExitCode -> ExitCode -> ExitCode), (ExitCode -> ExitCode -> ExitCode), (ExitCode -> ExitCode -> _CMP_TAG)] [_DFUN_ Eq (ExitCode), _CONSTM_ Ord (<) (ExitCode), _CONSTM_ Ord (<=) (ExitCode), _CONSTM_ Ord (>=) (ExitCode), _CONSTM_ Ord (>) (ExitCode), _CONSTM_ Ord max (ExitCode), _CONSTM_ Ord min (ExitCode), _CONSTM_ Ord _tagCmp (ExitCode)] _N_
- (<) = _A_ 2 _U_ 22 _N_ _S_ "SS" _N_ _N_,
- (<=) = _A_ 2 _U_ 22 _N_ _S_ "SS" _N_ _N_,
- (>=) = _A_ 2 _U_ 22 _N_ _S_ "SS" _N_ _N_,
- (>) = _A_ 2 _U_ 22 _N_ _S_ "SS" _N_ _N_,
- max = _A_ 2 _U_ 22 _N_ _S_ "SS" _N_ _N_,
- min = _A_ 2 _U_ 22 _N_ _S_ "SS" _N_ _N_,
- _tagCmp = _A_ 2 _U_ 22 _N_ _S_ "SS" _N_ _N_ #-}
+ (<) = { _A_ 2 _U_ 22 _N_ _S_ "SS" _N_ _N_ },
+ (<=) = { _A_ 2 _U_ 22 _N_ _S_ "SS" _N_ _N_ },
+ (>=) = { _A_ 2 _U_ 22 _N_ _S_ "SS" _N_ _N_ },
+ (>) = { _A_ 2 _U_ 22 _N_ _S_ "SS" _N_ _N_ },
+ max = { _A_ 2 _U_ 22 _N_ _S_ "SS" _N_ _N_ },
+ min = { _A_ 2 _U_ 22 _N_ _S_ "SS" _N_ _N_ },
+ _tagCmp = { _A_ 2 _U_ 22 _N_ _S_ "SS" _N_ _N_ } #-}
instance Text ExitCode
{-# GHC_PRAGMA _M_ LibSystem {-dfun-} _A_ 0 _N_ _N_ _N_ _F_ _IF_ARGS_ 0 0 X 5 _!_ _TUP_4 [(Int -> [Char] -> [(ExitCode, [Char])]), (Int -> ExitCode -> [Char] -> [Char]), ([Char] -> [([ExitCode], [Char])]), ([ExitCode] -> [Char] -> [Char])] [_CONSTM_ Text readsPrec (ExitCode), _CONSTM_ Text showsPrec (ExitCode), _CONSTM_ Text readList (ExitCode), _CONSTM_ Text showList (ExitCode)] _N_
- readsPrec = _A_ 2 _U_ 12 _N_ _N_ _N_ _N_,
- showsPrec = _A_ 2 _U_ 112 _N_ _S_ "LS" _N_ _N_,
- readList = _A_ 0 _U_ 2 _N_ _N_ _N_ _N_,
- showList = _A_ 0 _U_ 12 _N_ _N_ _N_ _N_ #-}
+ readsPrec = { _A_ 2 _U_ 12 _N_ _N_ _N_ _N_ },
+ showsPrec = { _A_ 2 _U_ 112 _N_ _S_ "LS" _N_ _N_ },
+ readList = { _A_ 0 _U_ 2 _N_ _N_ _N_ _N_ },
+ showList = { _A_ 0 _U_ 12 _N_ _N_ _N_ _N_ } #-}
-{-# GHC_PRAGMA INTERFACE VERSION 5 #-}
+{-# GHC_PRAGMA INTERFACE VERSION 6 #-}
interface LibSystem where
import PreludeIOError(IOError13)
import PreludeMonadicIO(Either)
{-# GHC_PRAGMA _A_ 2 _U_ 21 _N_ _S_ "SU(P)" {_A_ 2 _U_ 22 _N_ _N_ _N_ _N_} _N_ _N_ #-}
instance Eq ExitCode
{-# GHC_PRAGMA _M_ LibSystem {-dfun-} _A_ 0 _N_ _N_ _N_ _F_ _IF_ARGS_ 0 0 X 3 _!_ _TUP_2 [(ExitCode -> ExitCode -> Bool), (ExitCode -> ExitCode -> Bool)] [_CONSTM_ Eq (==) (ExitCode), _CONSTM_ Eq (/=) (ExitCode)] _N_
- (==) = _A_ 2 _U_ 22 _N_ _S_ "SS" _N_ _N_,
- (/=) = _A_ 2 _U_ 22 _N_ _S_ "SS" _N_ _N_ #-}
+ (==) = { _A_ 2 _U_ 22 _N_ _S_ "SS" _N_ _N_ },
+ (/=) = { _A_ 2 _U_ 22 _N_ _S_ "SS" _N_ _N_ } #-}
instance Ord ExitCode
{-# GHC_PRAGMA _M_ LibSystem {-dfun-} _A_ 0 _N_ _N_ _N_ _F_ _IF_ARGS_ 0 0 X 9 _!_ _TUP_8 [{{Eq ExitCode}}, (ExitCode -> ExitCode -> Bool), (ExitCode -> ExitCode -> Bool), (ExitCode -> ExitCode -> Bool), (ExitCode -> ExitCode -> Bool), (ExitCode -> ExitCode -> ExitCode), (ExitCode -> ExitCode -> ExitCode), (ExitCode -> ExitCode -> _CMP_TAG)] [_DFUN_ Eq (ExitCode), _CONSTM_ Ord (<) (ExitCode), _CONSTM_ Ord (<=) (ExitCode), _CONSTM_ Ord (>=) (ExitCode), _CONSTM_ Ord (>) (ExitCode), _CONSTM_ Ord max (ExitCode), _CONSTM_ Ord min (ExitCode), _CONSTM_ Ord _tagCmp (ExitCode)] _N_
- (<) = _A_ 2 _U_ 22 _N_ _S_ "SS" _N_ _N_,
- (<=) = _A_ 2 _U_ 22 _N_ _S_ "SS" _N_ _N_,
- (>=) = _A_ 2 _U_ 22 _N_ _S_ "SS" _N_ _N_,
- (>) = _A_ 2 _U_ 22 _N_ _S_ "SS" _N_ _N_,
- max = _A_ 2 _U_ 22 _N_ _S_ "SS" _N_ _N_,
- min = _A_ 2 _U_ 22 _N_ _S_ "SS" _N_ _N_,
- _tagCmp = _A_ 2 _U_ 22 _N_ _S_ "SS" _N_ _N_ #-}
+ (<) = { _A_ 2 _U_ 22 _N_ _S_ "SS" _N_ _N_ },
+ (<=) = { _A_ 2 _U_ 22 _N_ _S_ "SS" _N_ _N_ },
+ (>=) = { _A_ 2 _U_ 22 _N_ _S_ "SS" _N_ _N_ },
+ (>) = { _A_ 2 _U_ 22 _N_ _S_ "SS" _N_ _N_ },
+ max = { _A_ 2 _U_ 22 _N_ _S_ "SS" _N_ _N_ },
+ min = { _A_ 2 _U_ 22 _N_ _S_ "SS" _N_ _N_ },
+ _tagCmp = { _A_ 2 _U_ 22 _N_ _S_ "SS" _N_ _N_ } #-}
instance Text ExitCode
{-# GHC_PRAGMA _M_ LibSystem {-dfun-} _A_ 0 _N_ _N_ _N_ _F_ _IF_ARGS_ 0 0 X 5 _!_ _TUP_4 [(Int -> [Char] -> [(ExitCode, [Char])]), (Int -> ExitCode -> [Char] -> [Char]), ([Char] -> [([ExitCode], [Char])]), ([ExitCode] -> [Char] -> [Char])] [_CONSTM_ Text readsPrec (ExitCode), _CONSTM_ Text showsPrec (ExitCode), _CONSTM_ Text readList (ExitCode), _CONSTM_ Text showList (ExitCode)] _N_
- readsPrec = _A_ 2 _U_ 12 _N_ _N_ _N_ _N_,
- showsPrec = _A_ 2 _U_ 112 _N_ _S_ "LS" _N_ _N_,
- readList = _A_ 0 _U_ 2 _N_ _N_ _N_ _N_,
- showList = _A_ 0 _U_ 12 _N_ _N_ _N_ _N_ #-}
+ readsPrec = { _A_ 2 _U_ 12 _N_ _N_ _N_ _N_ },
+ showsPrec = { _A_ 2 _U_ 112 _N_ _S_ "LS" _N_ _N_ },
+ readList = { _A_ 0 _U_ 2 _N_ _N_ _N_ _N_ },
+ showList = { _A_ 0 _U_ 12 _N_ _N_ _N_ _N_ } #-}
-{-# GHC_PRAGMA INTERFACE VERSION 5 #-}
+{-# GHC_PRAGMA INTERFACE VERSION 6 #-}
interface LibTime where
import PreludeIOError(IOError13)
import PreludeMonadicIO(Either)
data ClockTime {-# GHC_PRAGMA TOD Integer Integer #-}
data TimeDiff = TimeDiff Int Int Int Int Int Int Integer
addToClockTime :: TimeDiff -> ClockTime -> ClockTime
- {-# GHC_PRAGMA _A_ 2 _U_ 00 _N_ _S_ _!_ _F_ _IF_ARGS_ 0 2 XX 2 \ (u0 :: TimeDiff) (u1 :: ClockTime) -> _APP_ _TYAPP_ error { ClockTime } [ _NOREP_S_ "addToClockTime unimplemented" ] _N_ #-}
+ {-# GHC_PRAGMA _A_ 2 _U_ 00 _N_ _S_ _!_ _N_ _N_ #-}
diffClockTimes :: ClockTime -> ClockTime -> TimeDiff
- {-# GHC_PRAGMA _A_ 2 _U_ 00 _N_ _S_ _!_ _F_ _IF_ARGS_ 0 2 XX 2 \ (u0 :: ClockTime) (u1 :: ClockTime) -> _APP_ _TYAPP_ error { TimeDiff } [ _NOREP_S_ "diffClockTimes unimplemented" ] _N_ #-}
+ {-# GHC_PRAGMA _A_ 2 _U_ 00 _N_ _S_ _!_ _N_ _N_ #-}
getClockTime :: _State _RealWorld -> (Either IOError13 ClockTime, _State _RealWorld)
{-# GHC_PRAGMA _A_ 1 _U_ 1 _N_ _S_ "U(P)" {_A_ 1 _U_ 2 _N_ _N_ _N_ _N_} _N_ _N_ #-}
toCalendarTime :: ClockTime -> CalendarTime
{-# GHC_PRAGMA _A_ 1 _U_ 1 _N_ _S_ "U(U(PPP)L)" {_A_ 4 _U_ 0222 _N_ _N_ _N_ _N_} _N_ _N_ #-}
instance Eq ClockTime
{-# GHC_PRAGMA _M_ LibTime {-dfun-} _A_ 0 _N_ _N_ _N_ _F_ _IF_ARGS_ 0 0 X 3 _!_ _TUP_2 [(ClockTime -> ClockTime -> Bool), (ClockTime -> ClockTime -> Bool)] [_CONSTM_ Eq (==) (ClockTime), _CONSTM_ Eq (/=) (ClockTime)] _N_
- (==) = _A_ 2 _U_ 11 _N_ _S_ "U(U(PPP)L)U(U(PPP)L)" {_A_ 5 _U_ 22211 _N_ _N_ _F_ _IF_ARGS_ 0 5 XXXCC 9 \ (u0 :: Int#) (u1 :: Int#) (u2 :: ByteArray#) (u3 :: Integer) (u4 :: ClockTime) -> case u4 of { _ALG_ _ORIG_ LibTime TOD (u5 :: Integer) (u6 :: Integer) -> case u5 of { _ALG_ J# (u7 :: Int#) (u8 :: Int#) (u9 :: ByteArray#) -> case _#_ cmpInteger# [] [u0, u1, u2, u7, u8, u9] of { _PRIM_ 0# -> case u3 of { _ALG_ J# (ua :: Int#) (ub :: Int#) (uc :: ByteArray#) -> case u6 of { _ALG_ J# (ud :: Int#) (ue :: Int#) (uf :: ByteArray#) -> case _#_ cmpInteger# [] [ua, ub, uc, ud, ue, uf] of { _PRIM_ 0# -> _!_ True [] []; (ug :: Int#) -> _!_ False [] [] }; _NO_DEFLT_ }; _NO_DEFLT_ }; (uh :: Int#) -> _!_ False [] [] }; _NO_DEFLT_ }; _NO_DEFLT_ } _N_} _N_ _N_,
- (/=) = _A_ 2 _U_ 11 _N_ _S_ "U(U(PPP)L)U(U(PPP)L)" {_A_ 5 _U_ 22211 _N_ _N_ _N_ _N_} _N_ _N_ #-}
+ (==) = { _A_ 2 _U_ 11 _N_ _S_ "U(U(PPP)L)U(U(PPP)L)" {_A_ 5 _U_ 22211 _N_ _N_ _F_ _IF_ARGS_ 0 5 XXXCC 9 \ (u0 :: Int#) (u1 :: Int#) (u2 :: ByteArray#) (u3 :: Integer) (u4 :: ClockTime) -> case u4 of { _ALG_ _ORIG_ LibTime TOD (u5 :: Integer) (u6 :: Integer) -> case u5 of { _ALG_ J# (u7 :: Int#) (u8 :: Int#) (u9 :: ByteArray#) -> case _#_ cmpInteger# [] [u0, u1, u2, u7, u8, u9] of { _PRIM_ 0# -> case u3 of { _ALG_ J# (ua :: Int#) (ub :: Int#) (uc :: ByteArray#) -> case u6 of { _ALG_ J# (ud :: Int#) (ue :: Int#) (uf :: ByteArray#) -> case _#_ cmpInteger# [] [ua, ub, uc, ud, ue, uf] of { _PRIM_ 0# -> _!_ True [] []; (ug :: Int#) -> _!_ False [] [] }; _NO_DEFLT_ }; _NO_DEFLT_ }; (uh :: Int#) -> _!_ False [] [] }; _NO_DEFLT_ }; _NO_DEFLT_ } _N_} _N_ _N_ },
+ (/=) = { _A_ 2 _U_ 11 _N_ _S_ "U(U(PPP)L)U(U(PPP)L)" {_A_ 5 _U_ 22211 _N_ _N_ _N_ _N_} _N_ _N_ } #-}
instance Eq TimeDiff
{-# GHC_PRAGMA _M_ LibTime {-dfun-} _A_ 0 _N_ _N_ _N_ _F_ _IF_ARGS_ 0 0 X 3 _!_ _TUP_2 [(TimeDiff -> TimeDiff -> Bool), (TimeDiff -> TimeDiff -> Bool)] [_CONSTM_ Eq (==) (TimeDiff), _CONSTM_ Eq (/=) (TimeDiff)] _N_
- (==) = _A_ 2 _U_ 11 _N_ _S_ "U(U(P)LLLLLL)U(U(P)LLLLLL)" _N_ _N_,
- (/=) = _A_ 2 _U_ 11 _N_ _S_ "U(U(P)LLLLLL)U(U(P)LLLLLL)" _N_ _N_ #-}
+ (==) = { _A_ 2 _U_ 11 _N_ _S_ "U(U(P)LLLLLL)U(U(P)LLLLLL)" _N_ _N_ },
+ (/=) = { _A_ 2 _U_ 11 _N_ _S_ "U(U(P)LLLLLL)U(U(P)LLLLLL)" _N_ _N_ } #-}
instance Ord ClockTime
{-# GHC_PRAGMA _M_ LibTime {-dfun-} _A_ 0 _N_ _N_ _N_ _F_ _IF_ARGS_ 0 0 X 9 _!_ _TUP_8 [{{Eq ClockTime}}, (ClockTime -> ClockTime -> Bool), (ClockTime -> ClockTime -> Bool), (ClockTime -> ClockTime -> Bool), (ClockTime -> ClockTime -> Bool), (ClockTime -> ClockTime -> ClockTime), (ClockTime -> ClockTime -> ClockTime), (ClockTime -> ClockTime -> _CMP_TAG)] [_DFUN_ Eq (ClockTime), _CONSTM_ Ord (<) (ClockTime), _CONSTM_ Ord (<=) (ClockTime), _CONSTM_ Ord (>=) (ClockTime), _CONSTM_ Ord (>) (ClockTime), _CONSTM_ Ord max (ClockTime), _CONSTM_ Ord min (ClockTime), _CONSTM_ Ord _tagCmp (ClockTime)] _N_
- (<) = _A_ 2 _U_ 11 _N_ _S_ "U(U(PPP)L)U(U(PPP)L)" {_A_ 5 _U_ 22211 _N_ _N_ _N_ _N_} _N_ _N_,
- (<=) = _A_ 2 _U_ 11 _N_ _S_ "U(U(PPP)L)U(U(PPP)L)" {_A_ 5 _U_ 22211 _N_ _N_ _N_ _N_} _N_ _N_,
- (>=) = _A_ 2 _U_ 11 _N_ _S_ "U(U(PPP)L)U(U(PPP)L)" {_A_ 5 _U_ 22211 _N_ _N_ _N_ _N_} _N_ _N_,
- (>) = _A_ 2 _U_ 11 _N_ _S_ "U(U(PPP)L)U(U(PPP)L)" {_A_ 5 _U_ 22211 _N_ _N_ _N_ _N_} _N_ _N_,
- max = _A_ 2 _U_ 12 _N_ _S_ "U(U(PPP)L)U(U(PPP)L)" {_A_ 5 _U_ 22222 _N_ _N_ _N_ _N_} _N_ _N_,
- min = _A_ 2 _U_ 12 _N_ _S_ "U(U(PPP)L)U(U(PPP)L)" {_A_ 5 _U_ 22222 _N_ _N_ _N_ _N_} _N_ _N_,
- _tagCmp = _A_ 2 _U_ 11 _N_ _S_ "U(U(PPP)L)U(U(PPP)L)" {_A_ 5 _U_ 22211 _N_ _N_ _N_ _N_} _N_ _N_ #-}
+ (<) = { _A_ 2 _U_ 11 _N_ _S_ "U(U(PPP)L)U(U(PPP)L)" {_A_ 5 _U_ 22211 _N_ _N_ _N_ _N_} _N_ _N_ },
+ (<=) = { _A_ 2 _U_ 11 _N_ _S_ "U(U(PPP)L)U(U(PPP)L)" {_A_ 5 _U_ 22211 _N_ _N_ _N_ _N_} _N_ _N_ },
+ (>=) = { _A_ 2 _U_ 11 _N_ _S_ "U(U(PPP)L)U(U(PPP)L)" {_A_ 5 _U_ 22211 _N_ _N_ _N_ _N_} _N_ _N_ },
+ (>) = { _A_ 2 _U_ 11 _N_ _S_ "U(U(PPP)L)U(U(PPP)L)" {_A_ 5 _U_ 22211 _N_ _N_ _N_ _N_} _N_ _N_ },
+ max = { _A_ 2 _U_ 12 _N_ _S_ "U(U(PPP)L)U(U(PPP)L)" {_A_ 5 _U_ 22222 _N_ _N_ _N_ _N_} _N_ _N_ },
+ min = { _A_ 2 _U_ 12 _N_ _S_ "U(U(PPP)L)U(U(PPP)L)" {_A_ 5 _U_ 22222 _N_ _N_ _N_ _N_} _N_ _N_ },
+ _tagCmp = { _A_ 2 _U_ 11 _N_ _S_ "U(U(PPP)L)U(U(PPP)L)" {_A_ 5 _U_ 22211 _N_ _N_ _N_ _N_} _N_ _N_ } #-}
instance Ord TimeDiff
{-# GHC_PRAGMA _M_ LibTime {-dfun-} _A_ 0 _N_ _N_ _N_ _F_ _IF_ARGS_ 0 0 X 9 _!_ _TUP_8 [{{Eq TimeDiff}}, (TimeDiff -> TimeDiff -> Bool), (TimeDiff -> TimeDiff -> Bool), (TimeDiff -> TimeDiff -> Bool), (TimeDiff -> TimeDiff -> Bool), (TimeDiff -> TimeDiff -> TimeDiff), (TimeDiff -> TimeDiff -> TimeDiff), (TimeDiff -> TimeDiff -> _CMP_TAG)] [_DFUN_ Eq (TimeDiff), _CONSTM_ Ord (<) (TimeDiff), _CONSTM_ Ord (<=) (TimeDiff), _CONSTM_ Ord (>=) (TimeDiff), _CONSTM_ Ord (>) (TimeDiff), _CONSTM_ Ord max (TimeDiff), _CONSTM_ Ord min (TimeDiff), _CONSTM_ Ord _tagCmp (TimeDiff)] _N_
- (<) = _A_ 2 _U_ 11 _N_ _S_ "U(U(P)LLLLLL)U(U(P)LLLLLL)" _N_ _N_,
- (<=) = _A_ 2 _U_ 11 _N_ _S_ "U(U(P)LLLLLL)U(U(P)LLLLLL)" _N_ _N_,
- (>=) = _A_ 2 _U_ 11 _N_ _S_ "U(U(P)LLLLLL)U(U(P)LLLLLL)" _N_ _N_,
- (>) = _A_ 2 _U_ 11 _N_ _S_ "U(U(P)LLLLLL)U(U(P)LLLLLL)" _N_ _N_,
- max = _A_ 2 _U_ 22 _N_ _S_ "U(U(P)LLLLLL)U(U(P)LLLLLL)" _N_ _N_,
- min = _A_ 2 _U_ 22 _N_ _S_ "U(U(P)LLLLLL)U(U(P)LLLLLL)" _N_ _N_,
- _tagCmp = _A_ 2 _U_ 11 _N_ _S_ "U(U(P)LLLLLL)U(U(P)LLLLLL)" _N_ _N_ #-}
+ (<) = { _A_ 2 _U_ 11 _N_ _S_ "U(U(P)LLLLLL)U(U(P)LLLLLL)" _N_ _N_ },
+ (<=) = { _A_ 2 _U_ 11 _N_ _S_ "U(U(P)LLLLLL)U(U(P)LLLLLL)" _N_ _N_ },
+ (>=) = { _A_ 2 _U_ 11 _N_ _S_ "U(U(P)LLLLLL)U(U(P)LLLLLL)" _N_ _N_ },
+ (>) = { _A_ 2 _U_ 11 _N_ _S_ "U(U(P)LLLLLL)U(U(P)LLLLLL)" _N_ _N_ },
+ max = { _A_ 2 _U_ 22 _N_ _S_ "U(U(P)LLLLLL)U(U(P)LLLLLL)" _N_ _N_ },
+ min = { _A_ 2 _U_ 22 _N_ _S_ "U(U(P)LLLLLL)U(U(P)LLLLLL)" _N_ _N_ },
+ _tagCmp = { _A_ 2 _U_ 11 _N_ _S_ "U(U(P)LLLLLL)U(U(P)LLLLLL)" _N_ _N_ } #-}
instance Text ClockTime
{-# GHC_PRAGMA _M_ LibTime {-dfun-} _A_ 0 _N_ _N_ _N_ _F_ _IF_ARGS_ 0 0 X 5 _!_ _TUP_4 [(Int -> [Char] -> [(ClockTime, [Char])]), (Int -> ClockTime -> [Char] -> [Char]), ([Char] -> [([ClockTime], [Char])]), ([ClockTime] -> [Char] -> [Char])] [_CONSTM_ Text readsPrec (ClockTime), _CONSTM_ Text showsPrec (ClockTime), _CONSTM_ Text readList (ClockTime), _CONSTM_ Text showList (ClockTime)] _N_
- readsPrec = _A_ 2 _U_ 22 _N_ _S_ _!_ _F_ _IF_ARGS_ 0 2 XX 4 \ (u0 :: Int) (u1 :: [Char]) -> _APP_ _TYAPP_ patError# { (Int -> [Char] -> [(ClockTime, [Char])]) } [ _NOREP_S_ "%DPreludeCore.Text.readsPrec\"", u0, u1 ] _N_,
- showsPrec = _A_ 2 _U_ 012 _N_ _S_ "AU(U(PPP)A)" {_A_ 3 _U_ 0222 _N_ _N_ _N_ _N_} _N_ _N_,
- readList = _A_ 0 _U_ 2 _N_ _N_ _N_ _N_,
- showList = _A_ 0 _U_ 12 _N_ _N_ _N_ _N_ #-}
+ readsPrec = { _A_ 2 _U_ 22 _N_ _S_ _!_ _N_ _N_ },
+ showsPrec = { _A_ 2 _U_ 012 _N_ _S_ "AU(U(PPP)A)" {_A_ 3 _U_ 0222 _N_ _N_ _N_ _N_} _N_ _N_ },
+ readList = { _A_ 1 _U_ 2 _N_ _S_ _!_ _N_ _N_ },
+ showList = { _A_ 1 _U_ 12 _N_ _N_ _N_ _N_ } #-}
_ccall_ strlen str `thenPrimIO` \ len ->
_packCBytesST len str `thenStrictlyST` \ ps ->
returnPrimIO (_unpackPS ps)))
+
+ showList = _showList (showsPrec 0)
\end{code}
-{-# GHC_PRAGMA INTERFACE VERSION 5 #-}
+{-# GHC_PRAGMA INTERFACE VERSION 6 #-}
interface LibTime where
import PreludeIOError(IOError13)
import PreludeMonadicIO(Either)
data ClockTime {-# GHC_PRAGMA TOD Integer Integer #-}
data TimeDiff = TimeDiff Int Int Int Int Int Int Integer
addToClockTime :: TimeDiff -> ClockTime -> ClockTime
- {-# GHC_PRAGMA _A_ 2 _U_ 00 _N_ _S_ _!_ _F_ _IF_ARGS_ 0 2 XX 2 \ (u0 :: TimeDiff) (u1 :: ClockTime) -> _APP_ _TYAPP_ error { ClockTime } [ _NOREP_S_ "addToClockTime unimplemented" ] _N_ #-}
+ {-# GHC_PRAGMA _A_ 2 _U_ 00 _N_ _S_ _!_ _N_ _N_ #-}
diffClockTimes :: ClockTime -> ClockTime -> TimeDiff
- {-# GHC_PRAGMA _A_ 2 _U_ 00 _N_ _S_ _!_ _F_ _IF_ARGS_ 0 2 XX 2 \ (u0 :: ClockTime) (u1 :: ClockTime) -> _APP_ _TYAPP_ error { TimeDiff } [ _NOREP_S_ "diffClockTimes unimplemented" ] _N_ #-}
+ {-# GHC_PRAGMA _A_ 2 _U_ 00 _N_ _S_ _!_ _N_ _N_ #-}
getClockTime :: _State _RealWorld -> (Either IOError13 ClockTime, _State _RealWorld)
{-# GHC_PRAGMA _A_ 1 _U_ 1 _N_ _S_ "U(P)" {_A_ 1 _U_ 2 _N_ _N_ _N_ _N_} _N_ _N_ #-}
toCalendarTime :: ClockTime -> CalendarTime
{-# GHC_PRAGMA _A_ 1 _U_ 1 _N_ _S_ "U(U(PPP)L)" {_A_ 4 _U_ 0222 _N_ _N_ _N_ _N_} _N_ _N_ #-}
instance Eq ClockTime
{-# GHC_PRAGMA _M_ LibTime {-dfun-} _A_ 0 _N_ _N_ _N_ _F_ _IF_ARGS_ 0 0 X 3 _!_ _TUP_2 [(ClockTime -> ClockTime -> Bool), (ClockTime -> ClockTime -> Bool)] [_CONSTM_ Eq (==) (ClockTime), _CONSTM_ Eq (/=) (ClockTime)] _N_
- (==) = _A_ 2 _U_ 11 _N_ _S_ "U(U(PPP)L)U(U(PPP)L)" {_A_ 5 _U_ 22211 _N_ _N_ _F_ _IF_ARGS_ 0 5 XXXCC 9 \ (u0 :: Int#) (u1 :: Int#) (u2 :: ByteArray#) (u3 :: Integer) (u4 :: ClockTime) -> case u4 of { _ALG_ _ORIG_ LibTime TOD (u5 :: Integer) (u6 :: Integer) -> case u5 of { _ALG_ J# (u7 :: Int#) (u8 :: Int#) (u9 :: ByteArray#) -> case _#_ cmpInteger# [] [u0, u1, u2, u7, u8, u9] of { _PRIM_ 0# -> case u3 of { _ALG_ J# (ua :: Int#) (ub :: Int#) (uc :: ByteArray#) -> case u6 of { _ALG_ J# (ud :: Int#) (ue :: Int#) (uf :: ByteArray#) -> case _#_ cmpInteger# [] [ua, ub, uc, ud, ue, uf] of { _PRIM_ 0# -> _!_ True [] []; (ug :: Int#) -> _!_ False [] [] }; _NO_DEFLT_ }; _NO_DEFLT_ }; (uh :: Int#) -> _!_ False [] [] }; _NO_DEFLT_ }; _NO_DEFLT_ } _N_} _N_ _N_,
- (/=) = _A_ 2 _U_ 11 _N_ _S_ "U(U(PPP)L)U(U(PPP)L)" {_A_ 5 _U_ 22211 _N_ _N_ _N_ _N_} _N_ _N_ #-}
+ (==) = { _A_ 2 _U_ 11 _N_ _S_ "U(U(PPP)L)U(U(PPP)L)" {_A_ 5 _U_ 22211 _N_ _N_ _F_ _IF_ARGS_ 0 5 XXXCC 9 \ (u0 :: Int#) (u1 :: Int#) (u2 :: ByteArray#) (u3 :: Integer) (u4 :: ClockTime) -> case u4 of { _ALG_ _ORIG_ LibTime TOD (u5 :: Integer) (u6 :: Integer) -> case u5 of { _ALG_ J# (u7 :: Int#) (u8 :: Int#) (u9 :: ByteArray#) -> case _#_ cmpInteger# [] [u0, u1, u2, u7, u8, u9] of { _PRIM_ 0# -> case u3 of { _ALG_ J# (ua :: Int#) (ub :: Int#) (uc :: ByteArray#) -> case u6 of { _ALG_ J# (ud :: Int#) (ue :: Int#) (uf :: ByteArray#) -> case _#_ cmpInteger# [] [ua, ub, uc, ud, ue, uf] of { _PRIM_ 0# -> _!_ True [] []; (ug :: Int#) -> _!_ False [] [] }; _NO_DEFLT_ }; _NO_DEFLT_ }; (uh :: Int#) -> _!_ False [] [] }; _NO_DEFLT_ }; _NO_DEFLT_ } _N_} _N_ _N_ },
+ (/=) = { _A_ 2 _U_ 11 _N_ _S_ "U(U(PPP)L)U(U(PPP)L)" {_A_ 5 _U_ 22211 _N_ _N_ _N_ _N_} _N_ _N_ } #-}
instance Eq TimeDiff
{-# GHC_PRAGMA _M_ LibTime {-dfun-} _A_ 0 _N_ _N_ _N_ _F_ _IF_ARGS_ 0 0 X 3 _!_ _TUP_2 [(TimeDiff -> TimeDiff -> Bool), (TimeDiff -> TimeDiff -> Bool)] [_CONSTM_ Eq (==) (TimeDiff), _CONSTM_ Eq (/=) (TimeDiff)] _N_
- (==) = _A_ 2 _U_ 11 _N_ _S_ "U(U(P)LLLLLL)U(U(P)LLLLLL)" _N_ _N_,
- (/=) = _A_ 2 _U_ 11 _N_ _S_ "U(U(P)LLLLLL)U(U(P)LLLLLL)" _N_ _N_ #-}
+ (==) = { _A_ 2 _U_ 11 _N_ _S_ "U(U(P)LLLLLL)U(U(P)LLLLLL)" _N_ _N_ },
+ (/=) = { _A_ 2 _U_ 11 _N_ _S_ "U(U(P)LLLLLL)U(U(P)LLLLLL)" _N_ _N_ } #-}
instance Ord ClockTime
{-# GHC_PRAGMA _M_ LibTime {-dfun-} _A_ 0 _N_ _N_ _N_ _F_ _IF_ARGS_ 0 0 X 9 _!_ _TUP_8 [{{Eq ClockTime}}, (ClockTime -> ClockTime -> Bool), (ClockTime -> ClockTime -> Bool), (ClockTime -> ClockTime -> Bool), (ClockTime -> ClockTime -> Bool), (ClockTime -> ClockTime -> ClockTime), (ClockTime -> ClockTime -> ClockTime), (ClockTime -> ClockTime -> _CMP_TAG)] [_DFUN_ Eq (ClockTime), _CONSTM_ Ord (<) (ClockTime), _CONSTM_ Ord (<=) (ClockTime), _CONSTM_ Ord (>=) (ClockTime), _CONSTM_ Ord (>) (ClockTime), _CONSTM_ Ord max (ClockTime), _CONSTM_ Ord min (ClockTime), _CONSTM_ Ord _tagCmp (ClockTime)] _N_
- (<) = _A_ 2 _U_ 11 _N_ _S_ "U(U(PPP)L)U(U(PPP)L)" {_A_ 5 _U_ 22211 _N_ _N_ _N_ _N_} _N_ _N_,
- (<=) = _A_ 2 _U_ 11 _N_ _S_ "U(U(PPP)L)U(U(PPP)L)" {_A_ 5 _U_ 22211 _N_ _N_ _N_ _N_} _N_ _N_,
- (>=) = _A_ 2 _U_ 11 _N_ _S_ "U(U(PPP)L)U(U(PPP)L)" {_A_ 5 _U_ 22211 _N_ _N_ _N_ _N_} _N_ _N_,
- (>) = _A_ 2 _U_ 11 _N_ _S_ "U(U(PPP)L)U(U(PPP)L)" {_A_ 5 _U_ 22211 _N_ _N_ _N_ _N_} _N_ _N_,
- max = _A_ 2 _U_ 12 _N_ _S_ "U(U(PPP)L)U(U(PPP)L)" {_A_ 5 _U_ 22222 _N_ _N_ _N_ _N_} _N_ _N_,
- min = _A_ 2 _U_ 12 _N_ _S_ "U(U(PPP)L)U(U(PPP)L)" {_A_ 5 _U_ 22222 _N_ _N_ _N_ _N_} _N_ _N_,
- _tagCmp = _A_ 2 _U_ 11 _N_ _S_ "U(U(PPP)L)U(U(PPP)L)" {_A_ 5 _U_ 22211 _N_ _N_ _N_ _N_} _N_ _N_ #-}
+ (<) = { _A_ 2 _U_ 11 _N_ _S_ "U(U(PPP)L)U(U(PPP)L)" {_A_ 5 _U_ 22211 _N_ _N_ _N_ _N_} _N_ _N_ },
+ (<=) = { _A_ 2 _U_ 11 _N_ _S_ "U(U(PPP)L)U(U(PPP)L)" {_A_ 5 _U_ 22211 _N_ _N_ _N_ _N_} _N_ _N_ },
+ (>=) = { _A_ 2 _U_ 11 _N_ _S_ "U(U(PPP)L)U(U(PPP)L)" {_A_ 5 _U_ 22211 _N_ _N_ _N_ _N_} _N_ _N_ },
+ (>) = { _A_ 2 _U_ 11 _N_ _S_ "U(U(PPP)L)U(U(PPP)L)" {_A_ 5 _U_ 22211 _N_ _N_ _N_ _N_} _N_ _N_ },
+ max = { _A_ 2 _U_ 12 _N_ _S_ "U(U(PPP)L)U(U(PPP)L)" {_A_ 5 _U_ 22222 _N_ _N_ _N_ _N_} _N_ _N_ },
+ min = { _A_ 2 _U_ 12 _N_ _S_ "U(U(PPP)L)U(U(PPP)L)" {_A_ 5 _U_ 22222 _N_ _N_ _N_ _N_} _N_ _N_ },
+ _tagCmp = { _A_ 2 _U_ 11 _N_ _S_ "U(U(PPP)L)U(U(PPP)L)" {_A_ 5 _U_ 22211 _N_ _N_ _N_ _N_} _N_ _N_ } #-}
instance Ord TimeDiff
{-# GHC_PRAGMA _M_ LibTime {-dfun-} _A_ 0 _N_ _N_ _N_ _F_ _IF_ARGS_ 0 0 X 9 _!_ _TUP_8 [{{Eq TimeDiff}}, (TimeDiff -> TimeDiff -> Bool), (TimeDiff -> TimeDiff -> Bool), (TimeDiff -> TimeDiff -> Bool), (TimeDiff -> TimeDiff -> Bool), (TimeDiff -> TimeDiff -> TimeDiff), (TimeDiff -> TimeDiff -> TimeDiff), (TimeDiff -> TimeDiff -> _CMP_TAG)] [_DFUN_ Eq (TimeDiff), _CONSTM_ Ord (<) (TimeDiff), _CONSTM_ Ord (<=) (TimeDiff), _CONSTM_ Ord (>=) (TimeDiff), _CONSTM_ Ord (>) (TimeDiff), _CONSTM_ Ord max (TimeDiff), _CONSTM_ Ord min (TimeDiff), _CONSTM_ Ord _tagCmp (TimeDiff)] _N_
- (<) = _A_ 2 _U_ 11 _N_ _S_ "U(U(P)LLLLLL)U(U(P)LLLLLL)" _N_ _N_,
- (<=) = _A_ 2 _U_ 11 _N_ _S_ "U(U(P)LLLLLL)U(U(P)LLLLLL)" _N_ _N_,
- (>=) = _A_ 2 _U_ 11 _N_ _S_ "U(U(P)LLLLLL)U(U(P)LLLLLL)" _N_ _N_,
- (>) = _A_ 2 _U_ 11 _N_ _S_ "U(U(P)LLLLLL)U(U(P)LLLLLL)" _N_ _N_,
- max = _A_ 2 _U_ 22 _N_ _S_ "U(U(P)LLLLLL)U(U(P)LLLLLL)" _N_ _N_,
- min = _A_ 2 _U_ 22 _N_ _S_ "U(U(P)LLLLLL)U(U(P)LLLLLL)" _N_ _N_,
- _tagCmp = _A_ 2 _U_ 11 _N_ _S_ "U(U(P)LLLLLL)U(U(P)LLLLLL)" _N_ _N_ #-}
+ (<) = { _A_ 2 _U_ 11 _N_ _S_ "U(U(P)LLLLLL)U(U(P)LLLLLL)" _N_ _N_ },
+ (<=) = { _A_ 2 _U_ 11 _N_ _S_ "U(U(P)LLLLLL)U(U(P)LLLLLL)" _N_ _N_ },
+ (>=) = { _A_ 2 _U_ 11 _N_ _S_ "U(U(P)LLLLLL)U(U(P)LLLLLL)" _N_ _N_ },
+ (>) = { _A_ 2 _U_ 11 _N_ _S_ "U(U(P)LLLLLL)U(U(P)LLLLLL)" _N_ _N_ },
+ max = { _A_ 2 _U_ 22 _N_ _S_ "U(U(P)LLLLLL)U(U(P)LLLLLL)" _N_ _N_ },
+ min = { _A_ 2 _U_ 22 _N_ _S_ "U(U(P)LLLLLL)U(U(P)LLLLLL)" _N_ _N_ },
+ _tagCmp = { _A_ 2 _U_ 11 _N_ _S_ "U(U(P)LLLLLL)U(U(P)LLLLLL)" _N_ _N_ } #-}
instance Text ClockTime
{-# GHC_PRAGMA _M_ LibTime {-dfun-} _A_ 0 _N_ _N_ _N_ _F_ _IF_ARGS_ 0 0 X 5 _!_ _TUP_4 [(Int -> [Char] -> [(ClockTime, [Char])]), (Int -> ClockTime -> [Char] -> [Char]), ([Char] -> [([ClockTime], [Char])]), ([ClockTime] -> [Char] -> [Char])] [_CONSTM_ Text readsPrec (ClockTime), _CONSTM_ Text showsPrec (ClockTime), _CONSTM_ Text readList (ClockTime), _CONSTM_ Text showList (ClockTime)] _N_
- readsPrec = _A_ 2 _U_ 22 _N_ _S_ _!_ _F_ _IF_ARGS_ 0 2 XX 4 \ (u0 :: Int) (u1 :: [Char]) -> _APP_ _TYAPP_ patError# { (Int -> [Char] -> [(ClockTime, [Char])]) } [ _NOREP_S_ "%DPreludeCore.Text.readsPrec\"", u0, u1 ] _N_,
- showsPrec = _A_ 2 _U_ 012 _N_ _S_ "AU(U(PPP)A)" {_A_ 3 _U_ 0222 _N_ _N_ _N_ _N_} _N_ _N_,
- readList = _A_ 0 _U_ 2 _N_ _N_ _N_ _N_,
- showList = _A_ 0 _U_ 12 _N_ _N_ _N_ _N_ #-}
+ readsPrec = { _A_ 2 _U_ 22 _N_ _S_ _!_ _N_ _N_ },
+ showsPrec = { _A_ 2 _U_ 012 _N_ _S_ "AU(U(PPP)A)" {_A_ 3 _U_ 0222 _N_ _N_ _N_ _N_} _N_ _N_ },
+ readList = { _A_ 1 _U_ 2 _N_ _S_ _!_ _N_ _N_ },
+ showList = { _A_ 1 _U_ 12 _N_ _N_ _N_ _N_ } #-}
-{-# GHC_PRAGMA INTERFACE VERSION 5 #-}
+{-# GHC_PRAGMA INTERFACE VERSION 6 #-}
interface LibTime where
import PreludeIOError(IOError13)
import PreludeMonadicIO(Either)
data ClockTime {-# GHC_PRAGMA TOD Integer Integer #-}
data TimeDiff = TimeDiff Int Int Int Int Int Int Integer
addToClockTime :: TimeDiff -> ClockTime -> ClockTime
- {-# GHC_PRAGMA _A_ 2 _U_ 00 _N_ _S_ _!_ _F_ _IF_ARGS_ 0 2 XX 2 \ (u0 :: TimeDiff) (u1 :: ClockTime) -> _APP_ _TYAPP_ error { ClockTime } [ _NOREP_S_ "addToClockTime unimplemented" ] _N_ #-}
+ {-# GHC_PRAGMA _A_ 2 _U_ 00 _N_ _S_ _!_ _N_ _N_ #-}
diffClockTimes :: ClockTime -> ClockTime -> TimeDiff
- {-# GHC_PRAGMA _A_ 2 _U_ 00 _N_ _S_ _!_ _F_ _IF_ARGS_ 0 2 XX 2 \ (u0 :: ClockTime) (u1 :: ClockTime) -> _APP_ _TYAPP_ error { TimeDiff } [ _NOREP_S_ "diffClockTimes unimplemented" ] _N_ #-}
+ {-# GHC_PRAGMA _A_ 2 _U_ 00 _N_ _S_ _!_ _N_ _N_ #-}
getClockTime :: _State _RealWorld -> (Either IOError13 ClockTime, _State _RealWorld)
{-# GHC_PRAGMA _A_ 1 _U_ 1 _N_ _S_ "U(P)" {_A_ 1 _U_ 2 _N_ _N_ _N_ _N_} _N_ _N_ #-}
toCalendarTime :: ClockTime -> CalendarTime
{-# GHC_PRAGMA _A_ 1 _U_ 1 _N_ _S_ "U(U(PPP)L)" {_A_ 4 _U_ 0222 _N_ _N_ _N_ _N_} _N_ _N_ #-}
instance Eq ClockTime
{-# GHC_PRAGMA _M_ LibTime {-dfun-} _A_ 0 _N_ _N_ _N_ _F_ _IF_ARGS_ 0 0 X 3 _!_ _TUP_2 [(ClockTime -> ClockTime -> Bool), (ClockTime -> ClockTime -> Bool)] [_CONSTM_ Eq (==) (ClockTime), _CONSTM_ Eq (/=) (ClockTime)] _N_
- (==) = _A_ 2 _U_ 11 _N_ _S_ "U(U(PPP)L)U(U(PPP)L)" {_A_ 5 _U_ 22211 _N_ _N_ _F_ _IF_ARGS_ 0 5 XXXCC 9 \ (u0 :: Int#) (u1 :: Int#) (u2 :: ByteArray#) (u3 :: Integer) (u4 :: ClockTime) -> case u4 of { _ALG_ _ORIG_ LibTime TOD (u5 :: Integer) (u6 :: Integer) -> case u5 of { _ALG_ J# (u7 :: Int#) (u8 :: Int#) (u9 :: ByteArray#) -> case _#_ cmpInteger# [] [u0, u1, u2, u7, u8, u9] of { _PRIM_ 0# -> case u3 of { _ALG_ J# (ua :: Int#) (ub :: Int#) (uc :: ByteArray#) -> case u6 of { _ALG_ J# (ud :: Int#) (ue :: Int#) (uf :: ByteArray#) -> case _#_ cmpInteger# [] [ua, ub, uc, ud, ue, uf] of { _PRIM_ 0# -> _!_ True [] []; (ug :: Int#) -> _!_ False [] [] }; _NO_DEFLT_ }; _NO_DEFLT_ }; (uh :: Int#) -> _!_ False [] [] }; _NO_DEFLT_ }; _NO_DEFLT_ } _N_} _N_ _N_,
- (/=) = _A_ 2 _U_ 11 _N_ _S_ "U(U(PPP)L)U(U(PPP)L)" {_A_ 5 _U_ 22211 _N_ _N_ _N_ _N_} _N_ _N_ #-}
+ (==) = { _A_ 2 _U_ 11 _N_ _S_ "U(U(PPP)L)U(U(PPP)L)" {_A_ 5 _U_ 22211 _N_ _N_ _F_ _IF_ARGS_ 0 5 XXXCC 9 \ (u0 :: Int#) (u1 :: Int#) (u2 :: ByteArray#) (u3 :: Integer) (u4 :: ClockTime) -> case u4 of { _ALG_ _ORIG_ LibTime TOD (u5 :: Integer) (u6 :: Integer) -> case u5 of { _ALG_ J# (u7 :: Int#) (u8 :: Int#) (u9 :: ByteArray#) -> case _#_ cmpInteger# [] [u0, u1, u2, u7, u8, u9] of { _PRIM_ 0# -> case u3 of { _ALG_ J# (ua :: Int#) (ub :: Int#) (uc :: ByteArray#) -> case u6 of { _ALG_ J# (ud :: Int#) (ue :: Int#) (uf :: ByteArray#) -> case _#_ cmpInteger# [] [ua, ub, uc, ud, ue, uf] of { _PRIM_ 0# -> _!_ True [] []; (ug :: Int#) -> _!_ False [] [] }; _NO_DEFLT_ }; _NO_DEFLT_ }; (uh :: Int#) -> _!_ False [] [] }; _NO_DEFLT_ }; _NO_DEFLT_ } _N_} _N_ _N_ },
+ (/=) = { _A_ 2 _U_ 11 _N_ _S_ "U(U(PPP)L)U(U(PPP)L)" {_A_ 5 _U_ 22211 _N_ _N_ _N_ _N_} _N_ _N_ } #-}
instance Eq TimeDiff
{-# GHC_PRAGMA _M_ LibTime {-dfun-} _A_ 0 _N_ _N_ _N_ _F_ _IF_ARGS_ 0 0 X 3 _!_ _TUP_2 [(TimeDiff -> TimeDiff -> Bool), (TimeDiff -> TimeDiff -> Bool)] [_CONSTM_ Eq (==) (TimeDiff), _CONSTM_ Eq (/=) (TimeDiff)] _N_
- (==) = _A_ 2 _U_ 11 _N_ _S_ "U(U(P)LLLLLL)U(U(P)LLLLLL)" _N_ _N_,
- (/=) = _A_ 2 _U_ 11 _N_ _S_ "U(U(P)LLLLLL)U(U(P)LLLLLL)" _N_ _N_ #-}
+ (==) = { _A_ 2 _U_ 11 _N_ _S_ "U(U(P)LLLLLL)U(U(P)LLLLLL)" _N_ _N_ },
+ (/=) = { _A_ 2 _U_ 11 _N_ _S_ "U(U(P)LLLLLL)U(U(P)LLLLLL)" _N_ _N_ } #-}
instance Ord ClockTime
{-# GHC_PRAGMA _M_ LibTime {-dfun-} _A_ 0 _N_ _N_ _N_ _F_ _IF_ARGS_ 0 0 X 9 _!_ _TUP_8 [{{Eq ClockTime}}, (ClockTime -> ClockTime -> Bool), (ClockTime -> ClockTime -> Bool), (ClockTime -> ClockTime -> Bool), (ClockTime -> ClockTime -> Bool), (ClockTime -> ClockTime -> ClockTime), (ClockTime -> ClockTime -> ClockTime), (ClockTime -> ClockTime -> _CMP_TAG)] [_DFUN_ Eq (ClockTime), _CONSTM_ Ord (<) (ClockTime), _CONSTM_ Ord (<=) (ClockTime), _CONSTM_ Ord (>=) (ClockTime), _CONSTM_ Ord (>) (ClockTime), _CONSTM_ Ord max (ClockTime), _CONSTM_ Ord min (ClockTime), _CONSTM_ Ord _tagCmp (ClockTime)] _N_
- (<) = _A_ 2 _U_ 11 _N_ _S_ "U(U(PPP)L)U(U(PPP)L)" {_A_ 5 _U_ 22211 _N_ _N_ _N_ _N_} _N_ _N_,
- (<=) = _A_ 2 _U_ 11 _N_ _S_ "U(U(PPP)L)U(U(PPP)L)" {_A_ 5 _U_ 22211 _N_ _N_ _N_ _N_} _N_ _N_,
- (>=) = _A_ 2 _U_ 11 _N_ _S_ "U(U(PPP)L)U(U(PPP)L)" {_A_ 5 _U_ 22211 _N_ _N_ _N_ _N_} _N_ _N_,
- (>) = _A_ 2 _U_ 11 _N_ _S_ "U(U(PPP)L)U(U(PPP)L)" {_A_ 5 _U_ 22211 _N_ _N_ _N_ _N_} _N_ _N_,
- max = _A_ 2 _U_ 12 _N_ _S_ "U(U(PPP)L)U(U(PPP)L)" {_A_ 5 _U_ 22222 _N_ _N_ _N_ _N_} _N_ _N_,
- min = _A_ 2 _U_ 12 _N_ _S_ "U(U(PPP)L)U(U(PPP)L)" {_A_ 5 _U_ 22222 _N_ _N_ _N_ _N_} _N_ _N_,
- _tagCmp = _A_ 2 _U_ 11 _N_ _S_ "U(U(PPP)L)U(U(PPP)L)" {_A_ 5 _U_ 22211 _N_ _N_ _N_ _N_} _N_ _N_ #-}
+ (<) = { _A_ 2 _U_ 11 _N_ _S_ "U(U(PPP)L)U(U(PPP)L)" {_A_ 5 _U_ 22211 _N_ _N_ _N_ _N_} _N_ _N_ },
+ (<=) = { _A_ 2 _U_ 11 _N_ _S_ "U(U(PPP)L)U(U(PPP)L)" {_A_ 5 _U_ 22211 _N_ _N_ _N_ _N_} _N_ _N_ },
+ (>=) = { _A_ 2 _U_ 11 _N_ _S_ "U(U(PPP)L)U(U(PPP)L)" {_A_ 5 _U_ 22211 _N_ _N_ _N_ _N_} _N_ _N_ },
+ (>) = { _A_ 2 _U_ 11 _N_ _S_ "U(U(PPP)L)U(U(PPP)L)" {_A_ 5 _U_ 22211 _N_ _N_ _N_ _N_} _N_ _N_ },
+ max = { _A_ 2 _U_ 12 _N_ _S_ "U(U(PPP)L)U(U(PPP)L)" {_A_ 5 _U_ 22222 _N_ _N_ _N_ _N_} _N_ _N_ },
+ min = { _A_ 2 _U_ 12 _N_ _S_ "U(U(PPP)L)U(U(PPP)L)" {_A_ 5 _U_ 22222 _N_ _N_ _N_ _N_} _N_ _N_ },
+ _tagCmp = { _A_ 2 _U_ 11 _N_ _S_ "U(U(PPP)L)U(U(PPP)L)" {_A_ 5 _U_ 22211 _N_ _N_ _N_ _N_} _N_ _N_ } #-}
instance Ord TimeDiff
{-# GHC_PRAGMA _M_ LibTime {-dfun-} _A_ 0 _N_ _N_ _N_ _F_ _IF_ARGS_ 0 0 X 9 _!_ _TUP_8 [{{Eq TimeDiff}}, (TimeDiff -> TimeDiff -> Bool), (TimeDiff -> TimeDiff -> Bool), (TimeDiff -> TimeDiff -> Bool), (TimeDiff -> TimeDiff -> Bool), (TimeDiff -> TimeDiff -> TimeDiff), (TimeDiff -> TimeDiff -> TimeDiff), (TimeDiff -> TimeDiff -> _CMP_TAG)] [_DFUN_ Eq (TimeDiff), _CONSTM_ Ord (<) (TimeDiff), _CONSTM_ Ord (<=) (TimeDiff), _CONSTM_ Ord (>=) (TimeDiff), _CONSTM_ Ord (>) (TimeDiff), _CONSTM_ Ord max (TimeDiff), _CONSTM_ Ord min (TimeDiff), _CONSTM_ Ord _tagCmp (TimeDiff)] _N_
- (<) = _A_ 2 _U_ 11 _N_ _S_ "U(U(P)LLLLLL)U(U(P)LLLLLL)" _N_ _N_,
- (<=) = _A_ 2 _U_ 11 _N_ _S_ "U(U(P)LLLLLL)U(U(P)LLLLLL)" _N_ _N_,
- (>=) = _A_ 2 _U_ 11 _N_ _S_ "U(U(P)LLLLLL)U(U(P)LLLLLL)" _N_ _N_,
- (>) = _A_ 2 _U_ 11 _N_ _S_ "U(U(P)LLLLLL)U(U(P)LLLLLL)" _N_ _N_,
- max = _A_ 2 _U_ 22 _N_ _S_ "U(U(P)LLLLLL)U(U(P)LLLLLL)" _N_ _N_,
- min = _A_ 2 _U_ 22 _N_ _S_ "U(U(P)LLLLLL)U(U(P)LLLLLL)" _N_ _N_,
- _tagCmp = _A_ 2 _U_ 11 _N_ _S_ "U(U(P)LLLLLL)U(U(P)LLLLLL)" _N_ _N_ #-}
+ (<) = { _A_ 2 _U_ 11 _N_ _S_ "U(U(P)LLLLLL)U(U(P)LLLLLL)" _N_ _N_ },
+ (<=) = { _A_ 2 _U_ 11 _N_ _S_ "U(U(P)LLLLLL)U(U(P)LLLLLL)" _N_ _N_ },
+ (>=) = { _A_ 2 _U_ 11 _N_ _S_ "U(U(P)LLLLLL)U(U(P)LLLLLL)" _N_ _N_ },
+ (>) = { _A_ 2 _U_ 11 _N_ _S_ "U(U(P)LLLLLL)U(U(P)LLLLLL)" _N_ _N_ },
+ max = { _A_ 2 _U_ 22 _N_ _S_ "U(U(P)LLLLLL)U(U(P)LLLLLL)" _N_ _N_ },
+ min = { _A_ 2 _U_ 22 _N_ _S_ "U(U(P)LLLLLL)U(U(P)LLLLLL)" _N_ _N_ },
+ _tagCmp = { _A_ 2 _U_ 11 _N_ _S_ "U(U(P)LLLLLL)U(U(P)LLLLLL)" _N_ _N_ } #-}
instance Text ClockTime
{-# GHC_PRAGMA _M_ LibTime {-dfun-} _A_ 0 _N_ _N_ _N_ _F_ _IF_ARGS_ 0 0 X 5 _!_ _TUP_4 [(Int -> [Char] -> [(ClockTime, [Char])]), (Int -> ClockTime -> [Char] -> [Char]), ([Char] -> [([ClockTime], [Char])]), ([ClockTime] -> [Char] -> [Char])] [_CONSTM_ Text readsPrec (ClockTime), _CONSTM_ Text showsPrec (ClockTime), _CONSTM_ Text readList (ClockTime), _CONSTM_ Text showList (ClockTime)] _N_
- readsPrec = _A_ 2 _U_ 22 _N_ _S_ _!_ _F_ _IF_ARGS_ 0 2 XX 4 \ (u0 :: Int) (u1 :: [Char]) -> _APP_ _TYAPP_ patError# { (Int -> [Char] -> [(ClockTime, [Char])]) } [ _NOREP_S_ "%DPreludeCore.Text.readsPrec\"", u0, u1 ] _N_,
- showsPrec = _A_ 2 _U_ 012 _N_ _S_ "AU(U(PPP)A)" {_A_ 3 _U_ 0222 _N_ _N_ _N_ _N_} _N_ _N_,
- readList = _A_ 0 _U_ 2 _N_ _N_ _N_ _N_,
- showList = _A_ 0 _U_ 12 _N_ _N_ _N_ _N_ #-}
+ readsPrec = { _A_ 2 _U_ 22 _N_ _S_ _!_ _N_ _N_ },
+ showsPrec = { _A_ 2 _U_ 012 _N_ _S_ "AU(U(PPP)A)" {_A_ 3 _U_ 0222 _N_ _N_ _N_ _N_} _N_ _N_ },
+ readList = { _A_ 1 _U_ 2 _N_ _S_ _!_ _N_ _N_ },
+ showList = { _A_ 1 _U_ 12 _N_ _N_ _N_ _N_ } #-}
-{-# GHC_PRAGMA INTERFACE VERSION 5 #-}
+{-# GHC_PRAGMA INTERFACE VERSION 6 #-}
interface LibTime where
import PreludeIOError(IOError13)
import PreludeMonadicIO(Either)
data ClockTime {-# GHC_PRAGMA TOD Integer Integer #-}
data TimeDiff = TimeDiff Int Int Int Int Int Int Integer
addToClockTime :: TimeDiff -> ClockTime -> ClockTime
- {-# GHC_PRAGMA _A_ 2 _U_ 00 _N_ _S_ _!_ _F_ _IF_ARGS_ 0 2 XX 2 \ (u0 :: TimeDiff) (u1 :: ClockTime) -> _APP_ _TYAPP_ error { ClockTime } [ _NOREP_S_ "addToClockTime unimplemented" ] _N_ #-}
+ {-# GHC_PRAGMA _A_ 2 _U_ 00 _N_ _S_ _!_ _N_ _N_ #-}
diffClockTimes :: ClockTime -> ClockTime -> TimeDiff
- {-# GHC_PRAGMA _A_ 2 _U_ 00 _N_ _S_ _!_ _F_ _IF_ARGS_ 0 2 XX 2 \ (u0 :: ClockTime) (u1 :: ClockTime) -> _APP_ _TYAPP_ error { TimeDiff } [ _NOREP_S_ "diffClockTimes unimplemented" ] _N_ #-}
+ {-# GHC_PRAGMA _A_ 2 _U_ 00 _N_ _S_ _!_ _N_ _N_ #-}
getClockTime :: _State _RealWorld -> (Either IOError13 ClockTime, _State _RealWorld)
{-# GHC_PRAGMA _A_ 1 _U_ 1 _N_ _S_ "U(P)" {_A_ 1 _U_ 2 _N_ _N_ _N_ _N_} _N_ _N_ #-}
toCalendarTime :: ClockTime -> CalendarTime
{-# GHC_PRAGMA _A_ 1 _U_ 1 _N_ _S_ "U(U(PPP)L)" {_A_ 4 _U_ 0222 _N_ _N_ _N_ _N_} _N_ _N_ #-}
instance Eq ClockTime
{-# GHC_PRAGMA _M_ LibTime {-dfun-} _A_ 0 _N_ _N_ _N_ _F_ _IF_ARGS_ 0 0 X 3 _!_ _TUP_2 [(ClockTime -> ClockTime -> Bool), (ClockTime -> ClockTime -> Bool)] [_CONSTM_ Eq (==) (ClockTime), _CONSTM_ Eq (/=) (ClockTime)] _N_
- (==) = _A_ 2 _U_ 11 _N_ _S_ "U(U(PPP)L)U(U(PPP)L)" {_A_ 5 _U_ 22211 _N_ _N_ _F_ _IF_ARGS_ 0 5 XXXCC 9 \ (u0 :: Int#) (u1 :: Int#) (u2 :: ByteArray#) (u3 :: Integer) (u4 :: ClockTime) -> case u4 of { _ALG_ _ORIG_ LibTime TOD (u5 :: Integer) (u6 :: Integer) -> case u5 of { _ALG_ J# (u7 :: Int#) (u8 :: Int#) (u9 :: ByteArray#) -> case _#_ cmpInteger# [] [u0, u1, u2, u7, u8, u9] of { _PRIM_ 0# -> case u3 of { _ALG_ J# (ua :: Int#) (ub :: Int#) (uc :: ByteArray#) -> case u6 of { _ALG_ J# (ud :: Int#) (ue :: Int#) (uf :: ByteArray#) -> case _#_ cmpInteger# [] [ua, ub, uc, ud, ue, uf] of { _PRIM_ 0# -> _!_ True [] []; (ug :: Int#) -> _!_ False [] [] }; _NO_DEFLT_ }; _NO_DEFLT_ }; (uh :: Int#) -> _!_ False [] [] }; _NO_DEFLT_ }; _NO_DEFLT_ } _N_} _N_ _N_,
- (/=) = _A_ 2 _U_ 11 _N_ _S_ "U(U(PPP)L)U(U(PPP)L)" {_A_ 5 _U_ 22211 _N_ _N_ _N_ _N_} _N_ _N_ #-}
+ (==) = { _A_ 2 _U_ 11 _N_ _S_ "U(U(PPP)L)U(U(PPP)L)" {_A_ 5 _U_ 22211 _N_ _N_ _F_ _IF_ARGS_ 0 5 XXXCC 9 \ (u0 :: Int#) (u1 :: Int#) (u2 :: ByteArray#) (u3 :: Integer) (u4 :: ClockTime) -> case u4 of { _ALG_ _ORIG_ LibTime TOD (u5 :: Integer) (u6 :: Integer) -> case u5 of { _ALG_ J# (u7 :: Int#) (u8 :: Int#) (u9 :: ByteArray#) -> case _#_ cmpInteger# [] [u0, u1, u2, u7, u8, u9] of { _PRIM_ 0# -> case u3 of { _ALG_ J# (ua :: Int#) (ub :: Int#) (uc :: ByteArray#) -> case u6 of { _ALG_ J# (ud :: Int#) (ue :: Int#) (uf :: ByteArray#) -> case _#_ cmpInteger# [] [ua, ub, uc, ud, ue, uf] of { _PRIM_ 0# -> _!_ True [] []; (ug :: Int#) -> _!_ False [] [] }; _NO_DEFLT_ }; _NO_DEFLT_ }; (uh :: Int#) -> _!_ False [] [] }; _NO_DEFLT_ }; _NO_DEFLT_ } _N_} _N_ _N_ },
+ (/=) = { _A_ 2 _U_ 11 _N_ _S_ "U(U(PPP)L)U(U(PPP)L)" {_A_ 5 _U_ 22211 _N_ _N_ _N_ _N_} _N_ _N_ } #-}
instance Eq TimeDiff
{-# GHC_PRAGMA _M_ LibTime {-dfun-} _A_ 0 _N_ _N_ _N_ _F_ _IF_ARGS_ 0 0 X 3 _!_ _TUP_2 [(TimeDiff -> TimeDiff -> Bool), (TimeDiff -> TimeDiff -> Bool)] [_CONSTM_ Eq (==) (TimeDiff), _CONSTM_ Eq (/=) (TimeDiff)] _N_
- (==) = _A_ 2 _U_ 11 _N_ _S_ "U(U(P)LLLLLL)U(U(P)LLLLLL)" _N_ _N_,
- (/=) = _A_ 2 _U_ 11 _N_ _S_ "U(U(P)LLLLLL)U(U(P)LLLLLL)" _N_ _N_ #-}
+ (==) = { _A_ 2 _U_ 11 _N_ _S_ "U(U(P)LLLLLL)U(U(P)LLLLLL)" _N_ _N_ },
+ (/=) = { _A_ 2 _U_ 11 _N_ _S_ "U(U(P)LLLLLL)U(U(P)LLLLLL)" _N_ _N_ } #-}
instance Ord ClockTime
{-# GHC_PRAGMA _M_ LibTime {-dfun-} _A_ 0 _N_ _N_ _N_ _F_ _IF_ARGS_ 0 0 X 9 _!_ _TUP_8 [{{Eq ClockTime}}, (ClockTime -> ClockTime -> Bool), (ClockTime -> ClockTime -> Bool), (ClockTime -> ClockTime -> Bool), (ClockTime -> ClockTime -> Bool), (ClockTime -> ClockTime -> ClockTime), (ClockTime -> ClockTime -> ClockTime), (ClockTime -> ClockTime -> _CMP_TAG)] [_DFUN_ Eq (ClockTime), _CONSTM_ Ord (<) (ClockTime), _CONSTM_ Ord (<=) (ClockTime), _CONSTM_ Ord (>=) (ClockTime), _CONSTM_ Ord (>) (ClockTime), _CONSTM_ Ord max (ClockTime), _CONSTM_ Ord min (ClockTime), _CONSTM_ Ord _tagCmp (ClockTime)] _N_
- (<) = _A_ 2 _U_ 11 _N_ _S_ "U(U(PPP)L)U(U(PPP)L)" {_A_ 5 _U_ 22211 _N_ _N_ _N_ _N_} _N_ _N_,
- (<=) = _A_ 2 _U_ 11 _N_ _S_ "U(U(PPP)L)U(U(PPP)L)" {_A_ 5 _U_ 22211 _N_ _N_ _N_ _N_} _N_ _N_,
- (>=) = _A_ 2 _U_ 11 _N_ _S_ "U(U(PPP)L)U(U(PPP)L)" {_A_ 5 _U_ 22211 _N_ _N_ _N_ _N_} _N_ _N_,
- (>) = _A_ 2 _U_ 11 _N_ _S_ "U(U(PPP)L)U(U(PPP)L)" {_A_ 5 _U_ 22211 _N_ _N_ _N_ _N_} _N_ _N_,
- max = _A_ 2 _U_ 12 _N_ _S_ "U(U(PPP)L)U(U(PPP)L)" {_A_ 5 _U_ 22222 _N_ _N_ _N_ _N_} _N_ _N_,
- min = _A_ 2 _U_ 12 _N_ _S_ "U(U(PPP)L)U(U(PPP)L)" {_A_ 5 _U_ 22222 _N_ _N_ _N_ _N_} _N_ _N_,
- _tagCmp = _A_ 2 _U_ 11 _N_ _S_ "U(U(PPP)L)U(U(PPP)L)" {_A_ 5 _U_ 22211 _N_ _N_ _N_ _N_} _N_ _N_ #-}
+ (<) = { _A_ 2 _U_ 11 _N_ _S_ "U(U(PPP)L)U(U(PPP)L)" {_A_ 5 _U_ 22211 _N_ _N_ _N_ _N_} _N_ _N_ },
+ (<=) = { _A_ 2 _U_ 11 _N_ _S_ "U(U(PPP)L)U(U(PPP)L)" {_A_ 5 _U_ 22211 _N_ _N_ _N_ _N_} _N_ _N_ },
+ (>=) = { _A_ 2 _U_ 11 _N_ _S_ "U(U(PPP)L)U(U(PPP)L)" {_A_ 5 _U_ 22211 _N_ _N_ _N_ _N_} _N_ _N_ },
+ (>) = { _A_ 2 _U_ 11 _N_ _S_ "U(U(PPP)L)U(U(PPP)L)" {_A_ 5 _U_ 22211 _N_ _N_ _N_ _N_} _N_ _N_ },
+ max = { _A_ 2 _U_ 12 _N_ _S_ "U(U(PPP)L)U(U(PPP)L)" {_A_ 5 _U_ 22222 _N_ _N_ _N_ _N_} _N_ _N_ },
+ min = { _A_ 2 _U_ 12 _N_ _S_ "U(U(PPP)L)U(U(PPP)L)" {_A_ 5 _U_ 22222 _N_ _N_ _N_ _N_} _N_ _N_ },
+ _tagCmp = { _A_ 2 _U_ 11 _N_ _S_ "U(U(PPP)L)U(U(PPP)L)" {_A_ 5 _U_ 22211 _N_ _N_ _N_ _N_} _N_ _N_ } #-}
instance Ord TimeDiff
{-# GHC_PRAGMA _M_ LibTime {-dfun-} _A_ 0 _N_ _N_ _N_ _F_ _IF_ARGS_ 0 0 X 9 _!_ _TUP_8 [{{Eq TimeDiff}}, (TimeDiff -> TimeDiff -> Bool), (TimeDiff -> TimeDiff -> Bool), (TimeDiff -> TimeDiff -> Bool), (TimeDiff -> TimeDiff -> Bool), (TimeDiff -> TimeDiff -> TimeDiff), (TimeDiff -> TimeDiff -> TimeDiff), (TimeDiff -> TimeDiff -> _CMP_TAG)] [_DFUN_ Eq (TimeDiff), _CONSTM_ Ord (<) (TimeDiff), _CONSTM_ Ord (<=) (TimeDiff), _CONSTM_ Ord (>=) (TimeDiff), _CONSTM_ Ord (>) (TimeDiff), _CONSTM_ Ord max (TimeDiff), _CONSTM_ Ord min (TimeDiff), _CONSTM_ Ord _tagCmp (TimeDiff)] _N_
- (<) = _A_ 2 _U_ 11 _N_ _S_ "U(U(P)LLLLLL)U(U(P)LLLLLL)" _N_ _N_,
- (<=) = _A_ 2 _U_ 11 _N_ _S_ "U(U(P)LLLLLL)U(U(P)LLLLLL)" _N_ _N_,
- (>=) = _A_ 2 _U_ 11 _N_ _S_ "U(U(P)LLLLLL)U(U(P)LLLLLL)" _N_ _N_,
- (>) = _A_ 2 _U_ 11 _N_ _S_ "U(U(P)LLLLLL)U(U(P)LLLLLL)" _N_ _N_,
- max = _A_ 2 _U_ 22 _N_ _S_ "U(U(P)LLLLLL)U(U(P)LLLLLL)" _N_ _N_,
- min = _A_ 2 _U_ 22 _N_ _S_ "U(U(P)LLLLLL)U(U(P)LLLLLL)" _N_ _N_,
- _tagCmp = _A_ 2 _U_ 11 _N_ _S_ "U(U(P)LLLLLL)U(U(P)LLLLLL)" _N_ _N_ #-}
+ (<) = { _A_ 2 _U_ 11 _N_ _S_ "U(U(P)LLLLLL)U(U(P)LLLLLL)" _N_ _N_ },
+ (<=) = { _A_ 2 _U_ 11 _N_ _S_ "U(U(P)LLLLLL)U(U(P)LLLLLL)" _N_ _N_ },
+ (>=) = { _A_ 2 _U_ 11 _N_ _S_ "U(U(P)LLLLLL)U(U(P)LLLLLL)" _N_ _N_ },
+ (>) = { _A_ 2 _U_ 11 _N_ _S_ "U(U(P)LLLLLL)U(U(P)LLLLLL)" _N_ _N_ },
+ max = { _A_ 2 _U_ 22 _N_ _S_ "U(U(P)LLLLLL)U(U(P)LLLLLL)" _N_ _N_ },
+ min = { _A_ 2 _U_ 22 _N_ _S_ "U(U(P)LLLLLL)U(U(P)LLLLLL)" _N_ _N_ },
+ _tagCmp = { _A_ 2 _U_ 11 _N_ _S_ "U(U(P)LLLLLL)U(U(P)LLLLLL)" _N_ _N_ } #-}
instance Text ClockTime
{-# GHC_PRAGMA _M_ LibTime {-dfun-} _A_ 0 _N_ _N_ _N_ _F_ _IF_ARGS_ 0 0 X 5 _!_ _TUP_4 [(Int -> [Char] -> [(ClockTime, [Char])]), (Int -> ClockTime -> [Char] -> [Char]), ([Char] -> [([ClockTime], [Char])]), ([ClockTime] -> [Char] -> [Char])] [_CONSTM_ Text readsPrec (ClockTime), _CONSTM_ Text showsPrec (ClockTime), _CONSTM_ Text readList (ClockTime), _CONSTM_ Text showList (ClockTime)] _N_
- readsPrec = _A_ 2 _U_ 22 _N_ _S_ _!_ _F_ _IF_ARGS_ 0 2 XX 4 \ (u0 :: Int) (u1 :: [Char]) -> _APP_ _TYAPP_ patError# { (Int -> [Char] -> [(ClockTime, [Char])]) } [ _NOREP_S_ "%DPreludeCore.Text.readsPrec\"", u0, u1 ] _N_,
- showsPrec = _A_ 2 _U_ 012 _N_ _S_ "AU(U(PPP)A)" {_A_ 3 _U_ 0222 _N_ _N_ _N_ _N_} _N_ _N_,
- readList = _A_ 0 _U_ 2 _N_ _N_ _N_ _N_,
- showList = _A_ 0 _U_ 12 _N_ _N_ _N_ _N_ #-}
+ readsPrec = { _A_ 2 _U_ 22 _N_ _S_ _!_ _N_ _N_ },
+ showsPrec = { _A_ 2 _U_ 012 _N_ _S_ "AU(U(PPP)A)" {_A_ 3 _U_ 0222 _N_ _N_ _N_ _N_} _N_ _N_ },
+ readList = { _A_ 1 _U_ 2 _N_ _S_ _!_ _N_ _N_ },
+ showList = { _A_ 1 _U_ 12 _N_ _N_ _N_ _N_ } #-}
-{-# GHC_PRAGMA INTERFACE VERSION 5 #-}
+{-# GHC_PRAGMA INTERFACE VERSION 6 #-}
interface LibTime where
import PreludeIOError(IOError13)
import PreludeMonadicIO(Either)
data ClockTime {-# GHC_PRAGMA TOD Integer Integer #-}
data TimeDiff = TimeDiff Int Int Int Int Int Int Integer
addToClockTime :: TimeDiff -> ClockTime -> ClockTime
- {-# GHC_PRAGMA _A_ 2 _U_ 00 _N_ _S_ _!_ _F_ _IF_ARGS_ 0 2 XX 2 \ (u0 :: TimeDiff) (u1 :: ClockTime) -> _APP_ _TYAPP_ error { ClockTime } [ _NOREP_S_ "addToClockTime unimplemented" ] _N_ #-}
+ {-# GHC_PRAGMA _A_ 2 _U_ 00 _N_ _S_ _!_ _N_ _N_ #-}
diffClockTimes :: ClockTime -> ClockTime -> TimeDiff
- {-# GHC_PRAGMA _A_ 2 _U_ 00 _N_ _S_ _!_ _F_ _IF_ARGS_ 0 2 XX 2 \ (u0 :: ClockTime) (u1 :: ClockTime) -> _APP_ _TYAPP_ error { TimeDiff } [ _NOREP_S_ "diffClockTimes unimplemented" ] _N_ #-}
+ {-# GHC_PRAGMA _A_ 2 _U_ 00 _N_ _S_ _!_ _N_ _N_ #-}
getClockTime :: _State _RealWorld -> (Either IOError13 ClockTime, _State _RealWorld)
{-# GHC_PRAGMA _A_ 1 _U_ 1 _N_ _S_ "U(P)" {_A_ 1 _U_ 2 _N_ _N_ _N_ _N_} _N_ _N_ #-}
toCalendarTime :: ClockTime -> CalendarTime
{-# GHC_PRAGMA _A_ 1 _U_ 1 _N_ _S_ "U(U(PPP)L)" {_A_ 4 _U_ 0222 _N_ _N_ _N_ _N_} _N_ _N_ #-}
instance Eq ClockTime
{-# GHC_PRAGMA _M_ LibTime {-dfun-} _A_ 0 _N_ _N_ _N_ _F_ _IF_ARGS_ 0 0 X 3 _!_ _TUP_2 [(ClockTime -> ClockTime -> Bool), (ClockTime -> ClockTime -> Bool)] [_CONSTM_ Eq (==) (ClockTime), _CONSTM_ Eq (/=) (ClockTime)] _N_
- (==) = _A_ 2 _U_ 11 _N_ _S_ "U(U(PPP)L)U(U(PPP)L)" {_A_ 5 _U_ 22211 _N_ _N_ _F_ _IF_ARGS_ 0 5 XXXCC 9 \ (u0 :: Int#) (u1 :: Int#) (u2 :: ByteArray#) (u3 :: Integer) (u4 :: ClockTime) -> case u4 of { _ALG_ _ORIG_ LibTime TOD (u5 :: Integer) (u6 :: Integer) -> case u5 of { _ALG_ J# (u7 :: Int#) (u8 :: Int#) (u9 :: ByteArray#) -> case _#_ cmpInteger# [] [u0, u1, u2, u7, u8, u9] of { _PRIM_ 0# -> case u3 of { _ALG_ J# (ua :: Int#) (ub :: Int#) (uc :: ByteArray#) -> case u6 of { _ALG_ J# (ud :: Int#) (ue :: Int#) (uf :: ByteArray#) -> case _#_ cmpInteger# [] [ua, ub, uc, ud, ue, uf] of { _PRIM_ 0# -> _!_ True [] []; (ug :: Int#) -> _!_ False [] [] }; _NO_DEFLT_ }; _NO_DEFLT_ }; (uh :: Int#) -> _!_ False [] [] }; _NO_DEFLT_ }; _NO_DEFLT_ } _N_} _N_ _N_,
- (/=) = _A_ 2 _U_ 11 _N_ _S_ "U(U(PPP)L)U(U(PPP)L)" {_A_ 5 _U_ 22211 _N_ _N_ _N_ _N_} _N_ _N_ #-}
+ (==) = { _A_ 2 _U_ 11 _N_ _S_ "U(U(PPP)L)U(U(PPP)L)" {_A_ 5 _U_ 22211 _N_ _N_ _F_ _IF_ARGS_ 0 5 XXXCC 9 \ (u0 :: Int#) (u1 :: Int#) (u2 :: ByteArray#) (u3 :: Integer) (u4 :: ClockTime) -> case u4 of { _ALG_ _ORIG_ LibTime TOD (u5 :: Integer) (u6 :: Integer) -> case u5 of { _ALG_ J# (u7 :: Int#) (u8 :: Int#) (u9 :: ByteArray#) -> case _#_ cmpInteger# [] [u0, u1, u2, u7, u8, u9] of { _PRIM_ 0# -> case u3 of { _ALG_ J# (ua :: Int#) (ub :: Int#) (uc :: ByteArray#) -> case u6 of { _ALG_ J# (ud :: Int#) (ue :: Int#) (uf :: ByteArray#) -> case _#_ cmpInteger# [] [ua, ub, uc, ud, ue, uf] of { _PRIM_ 0# -> _!_ True [] []; (ug :: Int#) -> _!_ False [] [] }; _NO_DEFLT_ }; _NO_DEFLT_ }; (uh :: Int#) -> _!_ False [] [] }; _NO_DEFLT_ }; _NO_DEFLT_ } _N_} _N_ _N_ },
+ (/=) = { _A_ 2 _U_ 11 _N_ _S_ "U(U(PPP)L)U(U(PPP)L)" {_A_ 5 _U_ 22211 _N_ _N_ _N_ _N_} _N_ _N_ } #-}
instance Eq TimeDiff
{-# GHC_PRAGMA _M_ LibTime {-dfun-} _A_ 0 _N_ _N_ _N_ _F_ _IF_ARGS_ 0 0 X 3 _!_ _TUP_2 [(TimeDiff -> TimeDiff -> Bool), (TimeDiff -> TimeDiff -> Bool)] [_CONSTM_ Eq (==) (TimeDiff), _CONSTM_ Eq (/=) (TimeDiff)] _N_
- (==) = _A_ 2 _U_ 11 _N_ _S_ "U(U(P)LLLLLL)U(U(P)LLLLLL)" _N_ _N_,
- (/=) = _A_ 2 _U_ 11 _N_ _S_ "U(U(P)LLLLLL)U(U(P)LLLLLL)" _N_ _N_ #-}
+ (==) = { _A_ 2 _U_ 11 _N_ _S_ "U(U(P)LLLLLL)U(U(P)LLLLLL)" _N_ _N_ },
+ (/=) = { _A_ 2 _U_ 11 _N_ _S_ "U(U(P)LLLLLL)U(U(P)LLLLLL)" _N_ _N_ } #-}
instance Ord ClockTime
{-# GHC_PRAGMA _M_ LibTime {-dfun-} _A_ 0 _N_ _N_ _N_ _F_ _IF_ARGS_ 0 0 X 9 _!_ _TUP_8 [{{Eq ClockTime}}, (ClockTime -> ClockTime -> Bool), (ClockTime -> ClockTime -> Bool), (ClockTime -> ClockTime -> Bool), (ClockTime -> ClockTime -> Bool), (ClockTime -> ClockTime -> ClockTime), (ClockTime -> ClockTime -> ClockTime), (ClockTime -> ClockTime -> _CMP_TAG)] [_DFUN_ Eq (ClockTime), _CONSTM_ Ord (<) (ClockTime), _CONSTM_ Ord (<=) (ClockTime), _CONSTM_ Ord (>=) (ClockTime), _CONSTM_ Ord (>) (ClockTime), _CONSTM_ Ord max (ClockTime), _CONSTM_ Ord min (ClockTime), _CONSTM_ Ord _tagCmp (ClockTime)] _N_
- (<) = _A_ 2 _U_ 11 _N_ _S_ "U(U(PPP)L)U(U(PPP)L)" {_A_ 5 _U_ 22211 _N_ _N_ _N_ _N_} _N_ _N_,
- (<=) = _A_ 2 _U_ 11 _N_ _S_ "U(U(PPP)L)U(U(PPP)L)" {_A_ 5 _U_ 22211 _N_ _N_ _N_ _N_} _N_ _N_,
- (>=) = _A_ 2 _U_ 11 _N_ _S_ "U(U(PPP)L)U(U(PPP)L)" {_A_ 5 _U_ 22211 _N_ _N_ _N_ _N_} _N_ _N_,
- (>) = _A_ 2 _U_ 11 _N_ _S_ "U(U(PPP)L)U(U(PPP)L)" {_A_ 5 _U_ 22211 _N_ _N_ _N_ _N_} _N_ _N_,
- max = _A_ 2 _U_ 12 _N_ _S_ "U(U(PPP)L)U(U(PPP)L)" {_A_ 5 _U_ 22222 _N_ _N_ _N_ _N_} _N_ _N_,
- min = _A_ 2 _U_ 12 _N_ _S_ "U(U(PPP)L)U(U(PPP)L)" {_A_ 5 _U_ 22222 _N_ _N_ _N_ _N_} _N_ _N_,
- _tagCmp = _A_ 2 _U_ 11 _N_ _S_ "U(U(PPP)L)U(U(PPP)L)" {_A_ 5 _U_ 22211 _N_ _N_ _N_ _N_} _N_ _N_ #-}
+ (<) = { _A_ 2 _U_ 11 _N_ _S_ "U(U(PPP)L)U(U(PPP)L)" {_A_ 5 _U_ 22211 _N_ _N_ _N_ _N_} _N_ _N_ },
+ (<=) = { _A_ 2 _U_ 11 _N_ _S_ "U(U(PPP)L)U(U(PPP)L)" {_A_ 5 _U_ 22211 _N_ _N_ _N_ _N_} _N_ _N_ },
+ (>=) = { _A_ 2 _U_ 11 _N_ _S_ "U(U(PPP)L)U(U(PPP)L)" {_A_ 5 _U_ 22211 _N_ _N_ _N_ _N_} _N_ _N_ },
+ (>) = { _A_ 2 _U_ 11 _N_ _S_ "U(U(PPP)L)U(U(PPP)L)" {_A_ 5 _U_ 22211 _N_ _N_ _N_ _N_} _N_ _N_ },
+ max = { _A_ 2 _U_ 12 _N_ _S_ "U(U(PPP)L)U(U(PPP)L)" {_A_ 5 _U_ 22222 _N_ _N_ _N_ _N_} _N_ _N_ },
+ min = { _A_ 2 _U_ 12 _N_ _S_ "U(U(PPP)L)U(U(PPP)L)" {_A_ 5 _U_ 22222 _N_ _N_ _N_ _N_} _N_ _N_ },
+ _tagCmp = { _A_ 2 _U_ 11 _N_ _S_ "U(U(PPP)L)U(U(PPP)L)" {_A_ 5 _U_ 22211 _N_ _N_ _N_ _N_} _N_ _N_ } #-}
instance Ord TimeDiff
{-# GHC_PRAGMA _M_ LibTime {-dfun-} _A_ 0 _N_ _N_ _N_ _F_ _IF_ARGS_ 0 0 X 9 _!_ _TUP_8 [{{Eq TimeDiff}}, (TimeDiff -> TimeDiff -> Bool), (TimeDiff -> TimeDiff -> Bool), (TimeDiff -> TimeDiff -> Bool), (TimeDiff -> TimeDiff -> Bool), (TimeDiff -> TimeDiff -> TimeDiff), (TimeDiff -> TimeDiff -> TimeDiff), (TimeDiff -> TimeDiff -> _CMP_TAG)] [_DFUN_ Eq (TimeDiff), _CONSTM_ Ord (<) (TimeDiff), _CONSTM_ Ord (<=) (TimeDiff), _CONSTM_ Ord (>=) (TimeDiff), _CONSTM_ Ord (>) (TimeDiff), _CONSTM_ Ord max (TimeDiff), _CONSTM_ Ord min (TimeDiff), _CONSTM_ Ord _tagCmp (TimeDiff)] _N_
- (<) = _A_ 2 _U_ 11 _N_ _S_ "U(U(P)LLLLLL)U(U(P)LLLLLL)" _N_ _N_,
- (<=) = _A_ 2 _U_ 11 _N_ _S_ "U(U(P)LLLLLL)U(U(P)LLLLLL)" _N_ _N_,
- (>=) = _A_ 2 _U_ 11 _N_ _S_ "U(U(P)LLLLLL)U(U(P)LLLLLL)" _N_ _N_,
- (>) = _A_ 2 _U_ 11 _N_ _S_ "U(U(P)LLLLLL)U(U(P)LLLLLL)" _N_ _N_,
- max = _A_ 2 _U_ 22 _N_ _S_ "U(U(P)LLLLLL)U(U(P)LLLLLL)" _N_ _N_,
- min = _A_ 2 _U_ 22 _N_ _S_ "U(U(P)LLLLLL)U(U(P)LLLLLL)" _N_ _N_,
- _tagCmp = _A_ 2 _U_ 11 _N_ _S_ "U(U(P)LLLLLL)U(U(P)LLLLLL)" _N_ _N_ #-}
+ (<) = { _A_ 2 _U_ 11 _N_ _S_ "U(U(P)LLLLLL)U(U(P)LLLLLL)" _N_ _N_ },
+ (<=) = { _A_ 2 _U_ 11 _N_ _S_ "U(U(P)LLLLLL)U(U(P)LLLLLL)" _N_ _N_ },
+ (>=) = { _A_ 2 _U_ 11 _N_ _S_ "U(U(P)LLLLLL)U(U(P)LLLLLL)" _N_ _N_ },
+ (>) = { _A_ 2 _U_ 11 _N_ _S_ "U(U(P)LLLLLL)U(U(P)LLLLLL)" _N_ _N_ },
+ max = { _A_ 2 _U_ 22 _N_ _S_ "U(U(P)LLLLLL)U(U(P)LLLLLL)" _N_ _N_ },
+ min = { _A_ 2 _U_ 22 _N_ _S_ "U(U(P)LLLLLL)U(U(P)LLLLLL)" _N_ _N_ },
+ _tagCmp = { _A_ 2 _U_ 11 _N_ _S_ "U(U(P)LLLLLL)U(U(P)LLLLLL)" _N_ _N_ } #-}
instance Text ClockTime
{-# GHC_PRAGMA _M_ LibTime {-dfun-} _A_ 0 _N_ _N_ _N_ _F_ _IF_ARGS_ 0 0 X 5 _!_ _TUP_4 [(Int -> [Char] -> [(ClockTime, [Char])]), (Int -> ClockTime -> [Char] -> [Char]), ([Char] -> [([ClockTime], [Char])]), ([ClockTime] -> [Char] -> [Char])] [_CONSTM_ Text readsPrec (ClockTime), _CONSTM_ Text showsPrec (ClockTime), _CONSTM_ Text readList (ClockTime), _CONSTM_ Text showList (ClockTime)] _N_
- readsPrec = _A_ 2 _U_ 22 _N_ _S_ _!_ _F_ _IF_ARGS_ 0 2 XX 4 \ (u0 :: Int) (u1 :: [Char]) -> _APP_ _TYAPP_ patError# { (Int -> [Char] -> [(ClockTime, [Char])]) } [ _NOREP_S_ "%DPreludeCore.Text.readsPrec\"", u0, u1 ] _N_,
- showsPrec = _A_ 2 _U_ 012 _N_ _S_ "AU(U(PPP)A)" {_A_ 3 _U_ 0222 _N_ _N_ _N_ _N_} _N_ _N_,
- readList = _A_ 0 _U_ 2 _N_ _N_ _N_ _N_,
- showList = _A_ 0 _U_ 12 _N_ _N_ _N_ _N_ #-}
+ readsPrec = { _A_ 2 _U_ 22 _N_ _S_ _!_ _N_ _N_ },
+ showsPrec = { _A_ 2 _U_ 012 _N_ _S_ "AU(U(PPP)A)" {_A_ 3 _U_ 0222 _N_ _N_ _N_ _N_} _N_ _N_ },
+ readList = { _A_ 1 _U_ 2 _N_ _S_ _!_ _N_ _N_ },
+ showList = { _A_ 1 _U_ 12 _N_ _N_ _N_ _N_ } #-}
-{-# GHC_PRAGMA INTERFACE VERSION 5 #-}
+{-# GHC_PRAGMA INTERFACE VERSION 6 #-}
interface Hash where
import PreludeArray(Array, Assoc)
import PreludeComplex(Complex)
class Hashable a where
hash :: a -> Int
{-# GHC_PRAGMA {-meth-} _A_ 1 _U_ 12 _N_ _S_ "S" _F_ _IF_ARGS_ 1 1 X 1 _/\_ u0 -> \ (u1 :: u0 -> Int) -> u1 _N_
- {-defm-} _A_ 2 _U_ 02 _N_ _S_ _!_ _F_ _IF_ARGS_ 1 2 XX 3 _/\_ u0 -> \ (u1 :: {{Hashable u0}}) (u2 :: u0) -> _APP_ _TYAPP_ patError# { (u0 -> Int) } [ _NOREP_S_ "%DHash.Hashable.hash\"", u2 ] _N_ #-}
+ {-defm-} _A_ 2 _U_ 02 _N_ _S_ _!_ _N_ _N_ #-}
hashToMax :: Hashable a => Int -> a -> Int
{-# GHC_PRAGMA _A_ 3 _U_ 122 _N_ _S_ "SLL" _N_ _N_ #-}
instance Hashable ()
{-# GHC_PRAGMA _M_ Hash {-dfun-} _A_ 1 _N_ _N_ _N_ _F_ _IF_ARGS_ 0 0 X 1 _CONSTM_ Hashable hash (()) _N_
- hash = _A_ 1 _U_ 0 _N_ _S_ "A" {_A_ 0 _N_ _N_ _N_ _F_ _IF_ARGS_ 0 0 X 2 _!_ I# [] [0#] _N_} _F_ _IF_ARGS_ 0 1 X 2 \ (u0 :: ()) -> _!_ I# [] [0#] _N_ #-}
+ hash = { _A_ 1 _U_ 0 _N_ _S_ "A" {_A_ 0 _N_ _N_ _N_ _F_ _IF_ARGS_ 0 0 X 2 _!_ I# [] [0#] _N_} _F_ _IF_ARGS_ 0 1 X 2 \ (u0 :: ()) -> _!_ I# [] [0#] _N_ } #-}
instance (Hashable a, Hashable b) => Hashable (a, b)
{-# GHC_PRAGMA _M_ Hash {-dfun-} _A_ 3 _U_ 22 _N_ _S_ "SSS" _N_ _N_ #-}
instance (Hashable a, Hashable b, Hashable c) => Hashable (a, b, c)
{-# GHC_PRAGMA _M_ Hash {-dfun-} _A_ 3 _U_ 22 _N_ _S_ "SSS" _N_ _N_ #-}
instance Hashable Bin
{-# GHC_PRAGMA _M_ Hash {-dfun-} _A_ 1 _N_ _N_ _N_ _F_ _IF_ARGS_ 0 0 X 1 _CONSTM_ Hashable hash (Bin) _N_
- hash = _A_ 1 _U_ 0 _N_ _S_ "A" {_A_ 0 _N_ _N_ _N_ _F_ _IF_ARGS_ 0 0 X 2 _!_ I# [] [0#] _N_} _F_ _IF_ARGS_ 0 1 X 2 \ (u0 :: Bin) -> _!_ I# [] [0#] _N_ #-}
+ hash = { _A_ 1 _U_ 0 _N_ _S_ "A" {_A_ 0 _N_ _N_ _N_ _F_ _IF_ARGS_ 0 0 X 2 _!_ I# [] [0#] _N_} _F_ _IF_ARGS_ 0 1 X 2 \ (u0 :: Bin) -> _!_ I# [] [0#] _N_ } #-}
instance Hashable Bool
{-# GHC_PRAGMA _M_ Hash {-dfun-} _A_ 1 _N_ _N_ _N_ _F_ _IF_ARGS_ 0 0 X 1 _CONSTM_ Hashable hash (Bool) _N_
- hash = _A_ 1 _U_ 1 _N_ _S_ "E" _F_ _IF_ARGS_ 0 1 C 6 \ (u0 :: Bool) -> case u0 of { _ALG_ False -> _!_ I# [] [0#]; True -> _!_ I# [] [1#]; _NO_DEFLT_ } _N_ #-}
+ hash = { _A_ 1 _U_ 1 _N_ _S_ "E" _F_ _IF_ARGS_ 0 1 C 6 \ (u0 :: Bool) -> case u0 of { _ALG_ False -> _!_ I# [] [0#]; True -> _!_ I# [] [1#]; _NO_DEFLT_ } _N_ } #-}
instance Hashable Char
{-# GHC_PRAGMA _M_ Hash {-dfun-} _A_ 1 _N_ _N_ _N_ _F_ _IF_ARGS_ 0 0 X 1 _CONSTM_ Hashable hash (Char) _N_
- hash = _A_ 1 _U_ 1 _N_ _S_ "U(P)" {_A_ 1 _U_ 2 _N_ _N_ _F_ _IF_ARGS_ 0 1 X 3 \ (u0 :: Char#) -> case _#_ ord# [] [u0] of { _PRIM_ (u1 :: Int#) -> _!_ I# [] [u1] } _N_} _F_ _IF_ARGS_ 0 1 C 4 \ (u0 :: Char) -> case u0 of { _ALG_ C# (u1 :: Char#) -> case _#_ ord# [] [u1] of { _PRIM_ (u2 :: Int#) -> _!_ I# [] [u2] }; _NO_DEFLT_ } _N_ #-}
+ hash = { _A_ 1 _U_ 1 _N_ _S_ "U(P)" {_A_ 1 _U_ 2 _N_ _N_ _F_ _IF_ARGS_ 0 1 X 3 \ (u0 :: Char#) -> case _#_ ord# [] [u0] of { _PRIM_ (u1 :: Int#) -> _!_ I# [] [u1] } _N_} _F_ _IF_ARGS_ 0 1 C 4 \ (u0 :: Char) -> case u0 of { _ALG_ C# (u1 :: Char#) -> case _#_ ord# [] [u1] of { _PRIM_ (u2 :: Int#) -> _!_ I# [] [u2] }; _NO_DEFLT_ } _N_ } #-}
instance (RealFloat a, Hashable a) => Hashable (Complex a)
{-# GHC_PRAGMA _M_ Hash {-dfun-} _A_ 3 _U_ 22 _N_ _S_ "LSS" _N_ _N_ #-}
instance Hashable Double
- {-# GHC_PRAGMA _M_ Hash {-dfun-} _A_ 0 _N_ _N_ _N_ _N_ _N_
- hash = _A_ 0 _U_ 2 _N_ _N_ _N_ _N_ #-}
+ {-# GHC_PRAGMA _M_ Hash {-dfun-} _A_ 1 _N_ _N_ _N_ _F_ _IF_ARGS_ 0 0 X 1 _CONSTM_ Hashable hash (Double) _N_
+ hash = { _A_ 1 _U_ 1 _N_ _S_ "U(P)" {_A_ 1 _U_ 2 _N_ _N_ _F_ _IF_ARGS_ 0 1 X 4 \ (u0 :: Double#) -> case _APP_ _WRKR_ _SPEC_ _CONSTM_ RealFrac properFraction (Double) [ (Int) ] [ u0 ] of { _ALG_ _TUP_2 (u1 :: Int) (u2 :: Double) -> u1; _NO_DEFLT_ } _N_} _F_ _IF_ARGS_ 0 1 C 5 \ (u0 :: Double) -> case u0 of { _ALG_ D# (u1 :: Double#) -> case _APP_ _WRKR_ _SPEC_ _CONSTM_ RealFrac properFraction (Double) [ (Int) ] [ u1 ] of { _ALG_ _TUP_2 (u2 :: Int) (u3 :: Double) -> u2; _NO_DEFLT_ }; _NO_DEFLT_ } _N_ } #-}
instance Hashable Float
- {-# GHC_PRAGMA _M_ Hash {-dfun-} _A_ 0 _N_ _N_ _N_ _N_ _N_
- hash = _A_ 0 _U_ 2 _N_ _N_ _N_ _N_ #-}
+ {-# GHC_PRAGMA _M_ Hash {-dfun-} _A_ 1 _N_ _N_ _N_ _F_ _IF_ARGS_ 0 0 X 1 _CONSTM_ Hashable hash (Float) _N_
+ hash = { _A_ 1 _U_ 1 _N_ _S_ "U(P)" {_A_ 1 _U_ 2 _N_ _N_ _F_ _IF_ARGS_ 0 1 X 4 \ (u0 :: Float#) -> case _APP_ _WRKR_ _SPEC_ _CONSTM_ RealFrac properFraction (Float) [ (Int) ] [ u0 ] of { _ALG_ _TUP_2 (u1 :: Int) (u2 :: Float) -> u1; _NO_DEFLT_ } _N_} _F_ _IF_ARGS_ 0 1 C 5 \ (u0 :: Float) -> case u0 of { _ALG_ F# (u1 :: Float#) -> case _APP_ _WRKR_ _SPEC_ _CONSTM_ RealFrac properFraction (Float) [ (Int) ] [ u1 ] of { _ALG_ _TUP_2 (u2 :: Int) (u3 :: Float) -> u2; _NO_DEFLT_ }; _NO_DEFLT_ } _N_ } #-}
instance Hashable IOError
{-# GHC_PRAGMA _M_ Hash {-dfun-} _A_ 1 _N_ _N_ _N_ _F_ _IF_ARGS_ 0 0 X 1 _CONSTM_ Hashable hash (IOError) _N_
- hash = _A_ 1 _U_ 0 _N_ _S_ "A" {_A_ 0 _N_ _N_ _N_ _F_ _IF_ARGS_ 0 0 X 2 _!_ I# [] [0#] _N_} _F_ _IF_ARGS_ 0 1 X 2 \ (u0 :: IOError) -> _!_ I# [] [0#] _N_ #-}
+ hash = { _A_ 1 _U_ 0 _N_ _S_ "A" {_A_ 0 _N_ _N_ _N_ _F_ _IF_ARGS_ 0 0 X 2 _!_ I# [] [0#] _N_} _F_ _IF_ARGS_ 0 1 X 2 \ (u0 :: IOError) -> _!_ I# [] [0#] _N_ } #-}
instance Hashable Int
{-# GHC_PRAGMA _M_ Hash {-dfun-} _A_ 1 _N_ _N_ _N_ _F_ _IF_ARGS_ 0 0 X 1 _CONSTM_ Hashable hash (Int) _N_
- hash = _A_ 1 _U_ 1 _N_ _S_ "U(P)" {_A_ 1 _U_ 2 _N_ _N_ _F_ _IF_ARGS_ 0 1 X 2 \ (u0 :: Int#) -> _!_ I# [] [u0] _N_} _F_ _IF_ARGS_ 0 1 X 1 \ (u0 :: Int) -> u0 _N_ #-}
+ hash = { _A_ 1 _U_ 1 _N_ _S_ "U(P)" {_A_ 1 _U_ 2 _N_ _N_ _F_ _IF_ARGS_ 0 1 X 2 \ (u0 :: Int#) -> _!_ I# [] [u0] _N_} _F_ _IF_ARGS_ 0 1 X 1 \ (u0 :: Int) -> u0 _N_ } #-}
instance Hashable Integer
{-# GHC_PRAGMA _M_ Hash {-dfun-} _A_ 1 _N_ _N_ _N_ _F_ _IF_ARGS_ 0 0 X 1 _CONSTM_ Hashable hash (Integer) _N_
- hash = _A_ 1 _U_ 1 _N_ _S_ "U(PPP)" {_A_ 3 _U_ 222 _N_ _N_ _F_ _IF_ARGS_ 0 3 XXX 3 \ (u0 :: Int#) (u1 :: Int#) (u2 :: ByteArray#) -> case _#_ integer2Int# [] [u0, u1, u2] of { _PRIM_ (u3 :: Int#) -> _!_ I# [] [u3] } _N_} _F_ _IF_ARGS_ 0 1 C 4 \ (u0 :: Integer) -> case u0 of { _ALG_ J# (u1 :: Int#) (u2 :: Int#) (u3 :: ByteArray#) -> case _#_ integer2Int# [] [u1, u2, u3] of { _PRIM_ (u4 :: Int#) -> _!_ I# [] [u4] }; _NO_DEFLT_ } _N_ #-}
+ hash = { _A_ 1 _U_ 1 _N_ _S_ "U(PPP)" {_A_ 3 _U_ 222 _N_ _N_ _F_ _IF_ARGS_ 0 3 XXX 3 \ (u0 :: Int#) (u1 :: Int#) (u2 :: ByteArray#) -> case _#_ integer2Int# [] [u0, u1, u2] of { _PRIM_ (u3 :: Int#) -> _!_ I# [] [u3] } _N_} _F_ _IF_ARGS_ 0 1 C 4 \ (u0 :: Integer) -> case u0 of { _ALG_ J# (u1 :: Int#) (u2 :: Int#) (u3 :: ByteArray#) -> case _#_ integer2Int# [] [u1, u2, u3] of { _PRIM_ (u4 :: Int#) -> _!_ I# [] [u4] }; _NO_DEFLT_ } _N_ } #-}
instance (Integral a, Hashable a) => Hashable (Ratio a)
{-# GHC_PRAGMA _M_ Hash {-dfun-} _A_ 3 _U_ 22 _N_ _S_ "LSL" _N_ _N_ #-}
instance Hashable Request
{-# GHC_PRAGMA _M_ Hash {-dfun-} _A_ 1 _N_ _N_ _N_ _F_ _IF_ARGS_ 0 0 X 1 _CONSTM_ Hashable hash (Request) _N_
- hash = _A_ 1 _U_ 0 _N_ _S_ "A" {_A_ 0 _N_ _N_ _N_ _F_ _IF_ARGS_ 0 0 X 2 _!_ I# [] [0#] _N_} _F_ _IF_ARGS_ 0 1 X 2 \ (u0 :: Request) -> _!_ I# [] [0#] _N_ #-}
+ hash = { _A_ 1 _U_ 0 _N_ _S_ "A" {_A_ 0 _N_ _N_ _N_ _F_ _IF_ARGS_ 0 0 X 2 _!_ I# [] [0#] _N_} _F_ _IF_ARGS_ 0 1 X 2 \ (u0 :: Request) -> _!_ I# [] [0#] _N_ } #-}
instance Hashable Response
{-# GHC_PRAGMA _M_ Hash {-dfun-} _A_ 1 _N_ _N_ _N_ _F_ _IF_ARGS_ 0 0 X 1 _CONSTM_ Hashable hash (Response) _N_
- hash = _A_ 1 _U_ 0 _N_ _S_ "A" {_A_ 0 _N_ _N_ _N_ _F_ _IF_ARGS_ 0 0 X 2 _!_ I# [] [0#] _N_} _F_ _IF_ARGS_ 0 1 X 2 \ (u0 :: Response) -> _!_ I# [] [0#] _N_ #-}
+ hash = { _A_ 1 _U_ 0 _N_ _S_ "A" {_A_ 0 _N_ _N_ _N_ _F_ _IF_ARGS_ 0 0 X 2 _!_ I# [] [0#] _N_} _F_ _IF_ARGS_ 0 1 X 2 \ (u0 :: Response) -> _!_ I# [] [0#] _N_ } #-}
instance Hashable a => Hashable [a]
{-# GHC_PRAGMA _M_ Hash {-dfun-} _A_ 2 _U_ 2 _N_ _S_ "LS" _N_ _N_ #-}
instance Hashable [Char]
{-# GHC_PRAGMA _M_ Hash {-dfun-} _A_ 1 _N_ _N_ _N_ _F_ _IF_ARGS_ 0 0 X 1 _CONSTM_ Hashable hash ([Char]) _N_
- hash = _A_ 1 _U_ 1 _N_ _S_ "S" _N_ _N_ #-}
+ hash = { _A_ 1 _U_ 1 _N_ _S_ "S" _N_ _N_ } #-}
f [] r = r
f (c:cs) r = f cs (3*r + hash c)
-#if defined(__OVERLAPPING_INSTANCES__)
-instance Hashable [Char] where
- hash l = f l 0
- where f :: String -> Int -> Int
- f [] r = r
- f (c:cs) r = f cs (3*r + ord c)
-#endif
+{-# SPECIALISE instance Hashable [Char] #-}
instance (Hashable a, Hashable b) => Hashable (a,b) where
hash (a,b) = hash a + 3 * hash b
-{-# GHC_PRAGMA INTERFACE VERSION 5 #-}
+{-# GHC_PRAGMA INTERFACE VERSION 6 #-}
interface Hash where
import PreludeArray(Array, Assoc)
import PreludeComplex(Complex)
class Hashable a where
hash :: a -> Int
{-# GHC_PRAGMA {-meth-} _A_ 1 _U_ 12 _N_ _S_ "S" _F_ _IF_ARGS_ 1 1 X 1 _/\_ u0 -> \ (u1 :: u0 -> Int) -> u1 _N_
- {-defm-} _A_ 2 _U_ 02 _N_ _S_ _!_ _F_ _IF_ARGS_ 1 2 XX 3 _/\_ u0 -> \ (u1 :: {{Hashable u0}}) (u2 :: u0) -> _APP_ _TYAPP_ patError# { (u0 -> Int) } [ _NOREP_S_ "%DHash.Hashable.hash\"", u2 ] _N_ #-}
+ {-defm-} _A_ 2 _U_ 02 _N_ _S_ _!_ _N_ _N_ #-}
hashToMax :: Hashable a => Int -> a -> Int
{-# GHC_PRAGMA _A_ 3 _U_ 122 _N_ _S_ "SLL" _N_ _N_ #-}
instance Hashable ()
{-# GHC_PRAGMA _M_ Hash {-dfun-} _A_ 1 _N_ _N_ _N_ _F_ _IF_ARGS_ 0 0 X 1 _CONSTM_ Hashable hash (()) _N_
- hash = _A_ 1 _U_ 0 _N_ _S_ "A" {_A_ 0 _N_ _N_ _N_ _F_ _IF_ARGS_ 0 0 X 2 _!_ I# [] [0#] _N_} _F_ _IF_ARGS_ 0 1 X 2 \ (u0 :: ()) -> _!_ I# [] [0#] _N_ #-}
+ hash = { _A_ 1 _U_ 0 _N_ _S_ "A" {_A_ 0 _N_ _N_ _N_ _F_ _IF_ARGS_ 0 0 X 2 _!_ I# [] [0#] _N_} _F_ _IF_ARGS_ 0 1 X 2 \ (u0 :: ()) -> _!_ I# [] [0#] _N_ } #-}
instance (Hashable a, Hashable b) => Hashable (a, b)
{-# GHC_PRAGMA _M_ Hash {-dfun-} _A_ 3 _U_ 22 _N_ _S_ "SSS" _N_ _N_ #-}
instance (Hashable a, Hashable b, Hashable c) => Hashable (a, b, c)
{-# GHC_PRAGMA _M_ Hash {-dfun-} _A_ 3 _U_ 22 _N_ _S_ "SSS" _N_ _N_ #-}
instance Hashable Bin
{-# GHC_PRAGMA _M_ Hash {-dfun-} _A_ 1 _N_ _N_ _N_ _F_ _IF_ARGS_ 0 0 X 1 _CONSTM_ Hashable hash (Bin) _N_
- hash = _A_ 1 _U_ 0 _N_ _S_ "A" {_A_ 0 _N_ _N_ _N_ _F_ _IF_ARGS_ 0 0 X 2 _!_ I# [] [0#] _N_} _F_ _IF_ARGS_ 0 1 X 2 \ (u0 :: Bin) -> _!_ I# [] [0#] _N_ #-}
+ hash = { _A_ 1 _U_ 0 _N_ _S_ "A" {_A_ 0 _N_ _N_ _N_ _F_ _IF_ARGS_ 0 0 X 2 _!_ I# [] [0#] _N_} _F_ _IF_ARGS_ 0 1 X 2 \ (u0 :: Bin) -> _!_ I# [] [0#] _N_ } #-}
instance Hashable Bool
{-# GHC_PRAGMA _M_ Hash {-dfun-} _A_ 1 _N_ _N_ _N_ _F_ _IF_ARGS_ 0 0 X 1 _CONSTM_ Hashable hash (Bool) _N_
- hash = _A_ 1 _U_ 1 _N_ _S_ "E" _F_ _IF_ARGS_ 0 1 C 6 \ (u0 :: Bool) -> case u0 of { _ALG_ False -> _!_ I# [] [0#]; True -> _!_ I# [] [1#]; _NO_DEFLT_ } _N_ #-}
+ hash = { _A_ 1 _U_ 1 _N_ _S_ "E" _F_ _IF_ARGS_ 0 1 C 6 \ (u0 :: Bool) -> case u0 of { _ALG_ False -> _!_ I# [] [0#]; True -> _!_ I# [] [1#]; _NO_DEFLT_ } _N_ } #-}
instance Hashable Char
{-# GHC_PRAGMA _M_ Hash {-dfun-} _A_ 1 _N_ _N_ _N_ _F_ _IF_ARGS_ 0 0 X 1 _CONSTM_ Hashable hash (Char) _N_
- hash = _A_ 1 _U_ 1 _N_ _S_ "U(P)" {_A_ 1 _U_ 2 _N_ _N_ _F_ _IF_ARGS_ 0 1 X 3 \ (u0 :: Char#) -> case _#_ ord# [] [u0] of { _PRIM_ (u1 :: Int#) -> _!_ I# [] [u1] } _N_} _F_ _IF_ARGS_ 0 1 C 4 \ (u0 :: Char) -> case u0 of { _ALG_ C# (u1 :: Char#) -> case _#_ ord# [] [u1] of { _PRIM_ (u2 :: Int#) -> _!_ I# [] [u2] }; _NO_DEFLT_ } _N_ #-}
+ hash = { _A_ 1 _U_ 1 _N_ _S_ "U(P)" {_A_ 1 _U_ 2 _N_ _N_ _F_ _IF_ARGS_ 0 1 X 3 \ (u0 :: Char#) -> case _#_ ord# [] [u0] of { _PRIM_ (u1 :: Int#) -> _!_ I# [] [u1] } _N_} _F_ _IF_ARGS_ 0 1 C 4 \ (u0 :: Char) -> case u0 of { _ALG_ C# (u1 :: Char#) -> case _#_ ord# [] [u1] of { _PRIM_ (u2 :: Int#) -> _!_ I# [] [u2] }; _NO_DEFLT_ } _N_ } #-}
instance (RealFloat a, Hashable a) => Hashable (Complex a)
{-# GHC_PRAGMA _M_ Hash {-dfun-} _A_ 3 _U_ 22 _N_ _S_ "LSS" _N_ _N_ #-}
instance Hashable Double
{-# GHC_PRAGMA _M_ Hash {-dfun-} _A_ 0 _N_ _N_ _N_ _N_ _N_
- hash = _A_ 0 _U_ 2 _N_ _N_ _N_ _N_ #-}
+ hash = { _A_ 0 _U_ 2 _N_ _N_ _N_ _N_ } #-}
instance Hashable Float
{-# GHC_PRAGMA _M_ Hash {-dfun-} _A_ 0 _N_ _N_ _N_ _N_ _N_
- hash = _A_ 0 _U_ 2 _N_ _N_ _N_ _N_ #-}
+ hash = { _A_ 0 _U_ 2 _N_ _N_ _N_ _N_ } #-}
instance Hashable IOError
{-# GHC_PRAGMA _M_ Hash {-dfun-} _A_ 1 _N_ _N_ _N_ _F_ _IF_ARGS_ 0 0 X 1 _CONSTM_ Hashable hash (IOError) _N_
- hash = _A_ 1 _U_ 0 _N_ _S_ "A" {_A_ 0 _N_ _N_ _N_ _F_ _IF_ARGS_ 0 0 X 2 _!_ I# [] [0#] _N_} _F_ _IF_ARGS_ 0 1 X 2 \ (u0 :: IOError) -> _!_ I# [] [0#] _N_ #-}
+ hash = { _A_ 1 _U_ 0 _N_ _S_ "A" {_A_ 0 _N_ _N_ _N_ _F_ _IF_ARGS_ 0 0 X 2 _!_ I# [] [0#] _N_} _F_ _IF_ARGS_ 0 1 X 2 \ (u0 :: IOError) -> _!_ I# [] [0#] _N_ } #-}
instance Hashable Int
{-# GHC_PRAGMA _M_ Hash {-dfun-} _A_ 1 _N_ _N_ _N_ _F_ _IF_ARGS_ 0 0 X 1 _CONSTM_ Hashable hash (Int) _N_
- hash = _A_ 1 _U_ 1 _N_ _S_ "U(P)" {_A_ 1 _U_ 2 _N_ _N_ _F_ _IF_ARGS_ 0 1 X 2 \ (u0 :: Int#) -> _!_ I# [] [u0] _N_} _F_ _IF_ARGS_ 0 1 X 1 \ (u0 :: Int) -> u0 _N_ #-}
+ hash = { _A_ 1 _U_ 1 _N_ _S_ "U(P)" {_A_ 1 _U_ 2 _N_ _N_ _F_ _IF_ARGS_ 0 1 X 2 \ (u0 :: Int#) -> _!_ I# [] [u0] _N_} _F_ _IF_ARGS_ 0 1 X 1 \ (u0 :: Int) -> u0 _N_ } #-}
instance Hashable Integer
{-# GHC_PRAGMA _M_ Hash {-dfun-} _A_ 1 _N_ _N_ _N_ _F_ _IF_ARGS_ 0 0 X 1 _CONSTM_ Hashable hash (Integer) _N_
- hash = _A_ 1 _U_ 1 _N_ _S_ "U(PPP)" {_A_ 3 _U_ 222 _N_ _N_ _F_ _IF_ARGS_ 0 3 XXX 3 \ (u0 :: Int#) (u1 :: Int#) (u2 :: ByteArray#) -> case _#_ integer2Int# [] [u0, u1, u2] of { _PRIM_ (u3 :: Int#) -> _!_ I# [] [u3] } _N_} _F_ _IF_ARGS_ 0 1 C 4 \ (u0 :: Integer) -> case u0 of { _ALG_ J# (u1 :: Int#) (u2 :: Int#) (u3 :: ByteArray#) -> case _#_ integer2Int# [] [u1, u2, u3] of { _PRIM_ (u4 :: Int#) -> _!_ I# [] [u4] }; _NO_DEFLT_ } _N_ #-}
+ hash = { _A_ 1 _U_ 1 _N_ _S_ "U(PPP)" {_A_ 3 _U_ 222 _N_ _N_ _F_ _IF_ARGS_ 0 3 XXX 3 \ (u0 :: Int#) (u1 :: Int#) (u2 :: ByteArray#) -> case _#_ integer2Int# [] [u0, u1, u2] of { _PRIM_ (u3 :: Int#) -> _!_ I# [] [u3] } _N_} _F_ _IF_ARGS_ 0 1 C 4 \ (u0 :: Integer) -> case u0 of { _ALG_ J# (u1 :: Int#) (u2 :: Int#) (u3 :: ByteArray#) -> case _#_ integer2Int# [] [u1, u2, u3] of { _PRIM_ (u4 :: Int#) -> _!_ I# [] [u4] }; _NO_DEFLT_ } _N_ } #-}
instance (Integral a, Hashable a) => Hashable (Ratio a)
{-# GHC_PRAGMA _M_ Hash {-dfun-} _A_ 3 _U_ 22 _N_ _S_ "LSL" _N_ _N_ #-}
instance Hashable Request
{-# GHC_PRAGMA _M_ Hash {-dfun-} _A_ 1 _N_ _N_ _N_ _F_ _IF_ARGS_ 0 0 X 1 _CONSTM_ Hashable hash (Request) _N_
- hash = _A_ 1 _U_ 0 _N_ _S_ "A" {_A_ 0 _N_ _N_ _N_ _F_ _IF_ARGS_ 0 0 X 2 _!_ I# [] [0#] _N_} _F_ _IF_ARGS_ 0 1 X 2 \ (u0 :: Request) -> _!_ I# [] [0#] _N_ #-}
+ hash = { _A_ 1 _U_ 0 _N_ _S_ "A" {_A_ 0 _N_ _N_ _N_ _F_ _IF_ARGS_ 0 0 X 2 _!_ I# [] [0#] _N_} _F_ _IF_ARGS_ 0 1 X 2 \ (u0 :: Request) -> _!_ I# [] [0#] _N_ } #-}
instance Hashable Response
{-# GHC_PRAGMA _M_ Hash {-dfun-} _A_ 1 _N_ _N_ _N_ _F_ _IF_ARGS_ 0 0 X 1 _CONSTM_ Hashable hash (Response) _N_
- hash = _A_ 1 _U_ 0 _N_ _S_ "A" {_A_ 0 _N_ _N_ _N_ _F_ _IF_ARGS_ 0 0 X 2 _!_ I# [] [0#] _N_} _F_ _IF_ARGS_ 0 1 X 2 \ (u0 :: Response) -> _!_ I# [] [0#] _N_ #-}
+ hash = { _A_ 1 _U_ 0 _N_ _S_ "A" {_A_ 0 _N_ _N_ _N_ _F_ _IF_ARGS_ 0 0 X 2 _!_ I# [] [0#] _N_} _F_ _IF_ARGS_ 0 1 X 2 \ (u0 :: Response) -> _!_ I# [] [0#] _N_ } #-}
instance Hashable a => Hashable [a]
{-# GHC_PRAGMA _M_ Hash {-dfun-} _A_ 2 _U_ 2 _N_ _S_ "LS" _N_ _N_ #-}
instance Hashable [Char]
{-# GHC_PRAGMA _M_ Hash {-dfun-} _A_ 1 _N_ _N_ _N_ _F_ _IF_ARGS_ 0 0 X 1 _CONSTM_ Hashable hash ([Char]) _N_
- hash = _A_ 1 _U_ 1 _N_ _S_ "S" _N_ _N_ #-}
+ hash = { _A_ 1 _U_ 1 _N_ _S_ "S" _N_ _N_ } #-}
-{-# GHC_PRAGMA INTERFACE VERSION 5 #-}
+{-# GHC_PRAGMA INTERFACE VERSION 6 #-}
interface Hash where
import PreludeArray(Array, Assoc)
import PreludeComplex(Complex)
class Hashable a where
hash :: a -> Int
{-# GHC_PRAGMA {-meth-} _A_ 1 _U_ 12 _N_ _S_ "S" _F_ _IF_ARGS_ 1 1 X 1 _/\_ u0 -> \ (u1 :: u0 -> Int) -> u1 _N_
- {-defm-} _A_ 2 _U_ 02 _N_ _S_ _!_ _F_ _IF_ARGS_ 1 2 XX 3 _/\_ u0 -> \ (u1 :: {{Hashable u0}}) (u2 :: u0) -> _APP_ _TYAPP_ patError# { (u0 -> Int) } [ _NOREP_S_ "%DHash.Hashable.hash\"", u2 ] _N_ #-}
+ {-defm-} _A_ 2 _U_ 02 _N_ _S_ _!_ _N_ _N_ #-}
hashToMax :: Hashable a => Int -> a -> Int
{-# GHC_PRAGMA _A_ 3 _U_ 122 _N_ _S_ "SLL" _N_ _N_ #-}
instance Hashable ()
{-# GHC_PRAGMA _M_ Hash {-dfun-} _A_ 1 _N_ _N_ _N_ _F_ _IF_ARGS_ 0 0 X 1 _CONSTM_ Hashable hash (()) _N_
- hash = _A_ 1 _U_ 0 _N_ _S_ "A" {_A_ 0 _N_ _N_ _N_ _F_ _IF_ARGS_ 0 0 X 2 _!_ I# [] [0#] _N_} _F_ _IF_ARGS_ 0 1 X 2 \ (u0 :: ()) -> _!_ I# [] [0#] _N_ #-}
+ hash = { _A_ 1 _U_ 0 _N_ _S_ "A" {_A_ 0 _N_ _N_ _N_ _F_ _IF_ARGS_ 0 0 X 2 _!_ I# [] [0#] _N_} _F_ _IF_ARGS_ 0 1 X 2 \ (u0 :: ()) -> _!_ I# [] [0#] _N_ } #-}
instance (Hashable a, Hashable b) => Hashable (a, b)
{-# GHC_PRAGMA _M_ Hash {-dfun-} _A_ 3 _U_ 22 _N_ _S_ "SSS" _N_ _N_ #-}
instance (Hashable a, Hashable b, Hashable c) => Hashable (a, b, c)
{-# GHC_PRAGMA _M_ Hash {-dfun-} _A_ 3 _U_ 22 _N_ _S_ "SSS" _N_ _N_ #-}
instance Hashable Bin
{-# GHC_PRAGMA _M_ Hash {-dfun-} _A_ 1 _N_ _N_ _N_ _F_ _IF_ARGS_ 0 0 X 1 _CONSTM_ Hashable hash (Bin) _N_
- hash = _A_ 1 _U_ 0 _N_ _S_ "A" {_A_ 0 _N_ _N_ _N_ _F_ _IF_ARGS_ 0 0 X 2 _!_ I# [] [0#] _N_} _F_ _IF_ARGS_ 0 1 X 2 \ (u0 :: Bin) -> _!_ I# [] [0#] _N_ #-}
+ hash = { _A_ 1 _U_ 0 _N_ _S_ "A" {_A_ 0 _N_ _N_ _N_ _F_ _IF_ARGS_ 0 0 X 2 _!_ I# [] [0#] _N_} _F_ _IF_ARGS_ 0 1 X 2 \ (u0 :: Bin) -> _!_ I# [] [0#] _N_ } #-}
instance Hashable Bool
{-# GHC_PRAGMA _M_ Hash {-dfun-} _A_ 1 _N_ _N_ _N_ _F_ _IF_ARGS_ 0 0 X 1 _CONSTM_ Hashable hash (Bool) _N_
- hash = _A_ 1 _U_ 1 _N_ _S_ "E" _F_ _IF_ARGS_ 0 1 C 6 \ (u0 :: Bool) -> case u0 of { _ALG_ False -> _!_ I# [] [0#]; True -> _!_ I# [] [1#]; _NO_DEFLT_ } _N_ #-}
+ hash = { _A_ 1 _U_ 1 _N_ _S_ "E" _F_ _IF_ARGS_ 0 1 C 6 \ (u0 :: Bool) -> case u0 of { _ALG_ False -> _!_ I# [] [0#]; True -> _!_ I# [] [1#]; _NO_DEFLT_ } _N_ } #-}
instance Hashable Char
{-# GHC_PRAGMA _M_ Hash {-dfun-} _A_ 1 _N_ _N_ _N_ _F_ _IF_ARGS_ 0 0 X 1 _CONSTM_ Hashable hash (Char) _N_
- hash = _A_ 1 _U_ 1 _N_ _S_ "U(P)" {_A_ 1 _U_ 2 _N_ _N_ _F_ _IF_ARGS_ 0 1 X 3 \ (u0 :: Char#) -> case _#_ ord# [] [u0] of { _PRIM_ (u1 :: Int#) -> _!_ I# [] [u1] } _N_} _F_ _IF_ARGS_ 0 1 C 4 \ (u0 :: Char) -> case u0 of { _ALG_ C# (u1 :: Char#) -> case _#_ ord# [] [u1] of { _PRIM_ (u2 :: Int#) -> _!_ I# [] [u2] }; _NO_DEFLT_ } _N_ #-}
+ hash = { _A_ 1 _U_ 1 _N_ _S_ "U(P)" {_A_ 1 _U_ 2 _N_ _N_ _F_ _IF_ARGS_ 0 1 X 3 \ (u0 :: Char#) -> case _#_ ord# [] [u0] of { _PRIM_ (u1 :: Int#) -> _!_ I# [] [u1] } _N_} _F_ _IF_ARGS_ 0 1 C 4 \ (u0 :: Char) -> case u0 of { _ALG_ C# (u1 :: Char#) -> case _#_ ord# [] [u1] of { _PRIM_ (u2 :: Int#) -> _!_ I# [] [u2] }; _NO_DEFLT_ } _N_ } #-}
instance (RealFloat a, Hashable a) => Hashable (Complex a)
{-# GHC_PRAGMA _M_ Hash {-dfun-} _A_ 3 _U_ 22 _N_ _S_ "LSS" _N_ _N_ #-}
instance Hashable Double
{-# GHC_PRAGMA _M_ Hash {-dfun-} _A_ 0 _N_ _N_ _N_ _N_ _N_
- hash = _A_ 0 _U_ 2 _N_ _N_ _N_ _N_ #-}
+ hash = { _A_ 0 _U_ 2 _N_ _N_ _N_ _N_ } #-}
instance Hashable Float
{-# GHC_PRAGMA _M_ Hash {-dfun-} _A_ 0 _N_ _N_ _N_ _N_ _N_
- hash = _A_ 0 _U_ 2 _N_ _N_ _N_ _N_ #-}
+ hash = { _A_ 0 _U_ 2 _N_ _N_ _N_ _N_ } #-}
instance Hashable IOError
{-# GHC_PRAGMA _M_ Hash {-dfun-} _A_ 1 _N_ _N_ _N_ _F_ _IF_ARGS_ 0 0 X 1 _CONSTM_ Hashable hash (IOError) _N_
- hash = _A_ 1 _U_ 0 _N_ _S_ "A" {_A_ 0 _N_ _N_ _N_ _F_ _IF_ARGS_ 0 0 X 2 _!_ I# [] [0#] _N_} _F_ _IF_ARGS_ 0 1 X 2 \ (u0 :: IOError) -> _!_ I# [] [0#] _N_ #-}
+ hash = { _A_ 1 _U_ 0 _N_ _S_ "A" {_A_ 0 _N_ _N_ _N_ _F_ _IF_ARGS_ 0 0 X 2 _!_ I# [] [0#] _N_} _F_ _IF_ARGS_ 0 1 X 2 \ (u0 :: IOError) -> _!_ I# [] [0#] _N_ } #-}
instance Hashable Int
{-# GHC_PRAGMA _M_ Hash {-dfun-} _A_ 1 _N_ _N_ _N_ _F_ _IF_ARGS_ 0 0 X 1 _CONSTM_ Hashable hash (Int) _N_
- hash = _A_ 1 _U_ 1 _N_ _S_ "U(P)" {_A_ 1 _U_ 2 _N_ _N_ _F_ _IF_ARGS_ 0 1 X 2 \ (u0 :: Int#) -> _!_ I# [] [u0] _N_} _F_ _IF_ARGS_ 0 1 X 1 \ (u0 :: Int) -> u0 _N_ #-}
+ hash = { _A_ 1 _U_ 1 _N_ _S_ "U(P)" {_A_ 1 _U_ 2 _N_ _N_ _F_ _IF_ARGS_ 0 1 X 2 \ (u0 :: Int#) -> _!_ I# [] [u0] _N_} _F_ _IF_ARGS_ 0 1 X 1 \ (u0 :: Int) -> u0 _N_ } #-}
instance Hashable Integer
{-# GHC_PRAGMA _M_ Hash {-dfun-} _A_ 1 _N_ _N_ _N_ _F_ _IF_ARGS_ 0 0 X 1 _CONSTM_ Hashable hash (Integer) _N_
- hash = _A_ 1 _U_ 1 _N_ _S_ "U(PPP)" {_A_ 3 _U_ 222 _N_ _N_ _F_ _IF_ARGS_ 0 3 XXX 3 \ (u0 :: Int#) (u1 :: Int#) (u2 :: ByteArray#) -> case _#_ integer2Int# [] [u0, u1, u2] of { _PRIM_ (u3 :: Int#) -> _!_ I# [] [u3] } _N_} _F_ _IF_ARGS_ 0 1 C 4 \ (u0 :: Integer) -> case u0 of { _ALG_ J# (u1 :: Int#) (u2 :: Int#) (u3 :: ByteArray#) -> case _#_ integer2Int# [] [u1, u2, u3] of { _PRIM_ (u4 :: Int#) -> _!_ I# [] [u4] }; _NO_DEFLT_ } _N_ #-}
+ hash = { _A_ 1 _U_ 1 _N_ _S_ "U(PPP)" {_A_ 3 _U_ 222 _N_ _N_ _F_ _IF_ARGS_ 0 3 XXX 3 \ (u0 :: Int#) (u1 :: Int#) (u2 :: ByteArray#) -> case _#_ integer2Int# [] [u0, u1, u2] of { _PRIM_ (u3 :: Int#) -> _!_ I# [] [u3] } _N_} _F_ _IF_ARGS_ 0 1 C 4 \ (u0 :: Integer) -> case u0 of { _ALG_ J# (u1 :: Int#) (u2 :: Int#) (u3 :: ByteArray#) -> case _#_ integer2Int# [] [u1, u2, u3] of { _PRIM_ (u4 :: Int#) -> _!_ I# [] [u4] }; _NO_DEFLT_ } _N_ } #-}
instance (Integral a, Hashable a) => Hashable (Ratio a)
{-# GHC_PRAGMA _M_ Hash {-dfun-} _A_ 3 _U_ 22 _N_ _S_ "LSL" _N_ _N_ #-}
instance Hashable Request
{-# GHC_PRAGMA _M_ Hash {-dfun-} _A_ 1 _N_ _N_ _N_ _F_ _IF_ARGS_ 0 0 X 1 _CONSTM_ Hashable hash (Request) _N_
- hash = _A_ 1 _U_ 0 _N_ _S_ "A" {_A_ 0 _N_ _N_ _N_ _F_ _IF_ARGS_ 0 0 X 2 _!_ I# [] [0#] _N_} _F_ _IF_ARGS_ 0 1 X 2 \ (u0 :: Request) -> _!_ I# [] [0#] _N_ #-}
+ hash = { _A_ 1 _U_ 0 _N_ _S_ "A" {_A_ 0 _N_ _N_ _N_ _F_ _IF_ARGS_ 0 0 X 2 _!_ I# [] [0#] _N_} _F_ _IF_ARGS_ 0 1 X 2 \ (u0 :: Request) -> _!_ I# [] [0#] _N_ } #-}
instance Hashable Response
{-# GHC_PRAGMA _M_ Hash {-dfun-} _A_ 1 _N_ _N_ _N_ _F_ _IF_ARGS_ 0 0 X 1 _CONSTM_ Hashable hash (Response) _N_
- hash = _A_ 1 _U_ 0 _N_ _S_ "A" {_A_ 0 _N_ _N_ _N_ _F_ _IF_ARGS_ 0 0 X 2 _!_ I# [] [0#] _N_} _F_ _IF_ARGS_ 0 1 X 2 \ (u0 :: Response) -> _!_ I# [] [0#] _N_ #-}
+ hash = { _A_ 1 _U_ 0 _N_ _S_ "A" {_A_ 0 _N_ _N_ _N_ _F_ _IF_ARGS_ 0 0 X 2 _!_ I# [] [0#] _N_} _F_ _IF_ARGS_ 0 1 X 2 \ (u0 :: Response) -> _!_ I# [] [0#] _N_ } #-}
instance Hashable a => Hashable [a]
{-# GHC_PRAGMA _M_ Hash {-dfun-} _A_ 2 _U_ 2 _N_ _S_ "LS" _N_ _N_ #-}
instance Hashable [Char]
{-# GHC_PRAGMA _M_ Hash {-dfun-} _A_ 1 _N_ _N_ _N_ _F_ _IF_ARGS_ 0 0 X 1 _CONSTM_ Hashable hash ([Char]) _N_
- hash = _A_ 1 _U_ 1 _N_ _S_ "S" _N_ _N_ #-}
+ hash = { _A_ 1 _U_ 1 _N_ _S_ "S" _N_ _N_ } #-}
-{-# GHC_PRAGMA INTERFACE VERSION 5 #-}
+{-# GHC_PRAGMA INTERFACE VERSION 6 #-}
interface Hash where
import PreludeArray(Array, Assoc)
import PreludeComplex(Complex)
class Hashable a where
hash :: a -> Int
{-# GHC_PRAGMA {-meth-} _A_ 1 _U_ 12 _N_ _S_ "S" _F_ _IF_ARGS_ 1 1 X 1 _/\_ u0 -> \ (u1 :: u0 -> Int) -> u1 _N_
- {-defm-} _A_ 2 _U_ 02 _N_ _S_ _!_ _F_ _IF_ARGS_ 1 2 XX 3 _/\_ u0 -> \ (u1 :: {{Hashable u0}}) (u2 :: u0) -> _APP_ _TYAPP_ patError# { (u0 -> Int) } [ _NOREP_S_ "%DHash.Hashable.hash\"", u2 ] _N_ #-}
+ {-defm-} _A_ 2 _U_ 02 _N_ _S_ _!_ _N_ _N_ #-}
hashToMax :: Hashable a => Int -> a -> Int
{-# GHC_PRAGMA _A_ 3 _U_ 122 _N_ _S_ "SLL" _N_ _N_ #-}
instance Hashable ()
{-# GHC_PRAGMA _M_ Hash {-dfun-} _A_ 1 _N_ _N_ _N_ _F_ _IF_ARGS_ 0 0 X 1 _CONSTM_ Hashable hash (()) _N_
- hash = _A_ 1 _U_ 0 _N_ _S_ "A" {_A_ 0 _N_ _N_ _N_ _F_ _IF_ARGS_ 0 0 X 2 _!_ I# [] [0#] _N_} _F_ _IF_ARGS_ 0 1 X 2 \ (u0 :: ()) -> _!_ I# [] [0#] _N_ #-}
+ hash = { _A_ 1 _U_ 0 _N_ _S_ "A" {_A_ 0 _N_ _N_ _N_ _F_ _IF_ARGS_ 0 0 X 2 _!_ I# [] [0#] _N_} _F_ _IF_ARGS_ 0 1 X 2 \ (u0 :: ()) -> _!_ I# [] [0#] _N_ } #-}
instance (Hashable a, Hashable b) => Hashable (a, b)
{-# GHC_PRAGMA _M_ Hash {-dfun-} _A_ 3 _U_ 22 _N_ _S_ "SSS" _N_ _N_ #-}
instance (Hashable a, Hashable b, Hashable c) => Hashable (a, b, c)
{-# GHC_PRAGMA _M_ Hash {-dfun-} _A_ 3 _U_ 22 _N_ _S_ "SSS" _N_ _N_ #-}
instance Hashable Bin
{-# GHC_PRAGMA _M_ Hash {-dfun-} _A_ 1 _N_ _N_ _N_ _F_ _IF_ARGS_ 0 0 X 1 _CONSTM_ Hashable hash (Bin) _N_
- hash = _A_ 1 _U_ 0 _N_ _S_ "A" {_A_ 0 _N_ _N_ _N_ _F_ _IF_ARGS_ 0 0 X 2 _!_ I# [] [0#] _N_} _F_ _IF_ARGS_ 0 1 X 2 \ (u0 :: Bin) -> _!_ I# [] [0#] _N_ #-}
+ hash = { _A_ 1 _U_ 0 _N_ _S_ "A" {_A_ 0 _N_ _N_ _N_ _F_ _IF_ARGS_ 0 0 X 2 _!_ I# [] [0#] _N_} _F_ _IF_ARGS_ 0 1 X 2 \ (u0 :: Bin) -> _!_ I# [] [0#] _N_ } #-}
instance Hashable Bool
{-# GHC_PRAGMA _M_ Hash {-dfun-} _A_ 1 _N_ _N_ _N_ _F_ _IF_ARGS_ 0 0 X 1 _CONSTM_ Hashable hash (Bool) _N_
- hash = _A_ 1 _U_ 1 _N_ _S_ "E" _F_ _IF_ARGS_ 0 1 C 6 \ (u0 :: Bool) -> case u0 of { _ALG_ False -> _!_ I# [] [0#]; True -> _!_ I# [] [1#]; _NO_DEFLT_ } _N_ #-}
+ hash = { _A_ 1 _U_ 1 _N_ _S_ "E" _F_ _IF_ARGS_ 0 1 C 6 \ (u0 :: Bool) -> case u0 of { _ALG_ False -> _!_ I# [] [0#]; True -> _!_ I# [] [1#]; _NO_DEFLT_ } _N_ } #-}
instance Hashable Char
{-# GHC_PRAGMA _M_ Hash {-dfun-} _A_ 1 _N_ _N_ _N_ _F_ _IF_ARGS_ 0 0 X 1 _CONSTM_ Hashable hash (Char) _N_
- hash = _A_ 1 _U_ 1 _N_ _S_ "U(P)" {_A_ 1 _U_ 2 _N_ _N_ _F_ _IF_ARGS_ 0 1 X 3 \ (u0 :: Char#) -> case _#_ ord# [] [u0] of { _PRIM_ (u1 :: Int#) -> _!_ I# [] [u1] } _N_} _F_ _IF_ARGS_ 0 1 C 4 \ (u0 :: Char) -> case u0 of { _ALG_ C# (u1 :: Char#) -> case _#_ ord# [] [u1] of { _PRIM_ (u2 :: Int#) -> _!_ I# [] [u2] }; _NO_DEFLT_ } _N_ #-}
+ hash = { _A_ 1 _U_ 1 _N_ _S_ "U(P)" {_A_ 1 _U_ 2 _N_ _N_ _F_ _IF_ARGS_ 0 1 X 3 \ (u0 :: Char#) -> case _#_ ord# [] [u0] of { _PRIM_ (u1 :: Int#) -> _!_ I# [] [u1] } _N_} _F_ _IF_ARGS_ 0 1 C 4 \ (u0 :: Char) -> case u0 of { _ALG_ C# (u1 :: Char#) -> case _#_ ord# [] [u1] of { _PRIM_ (u2 :: Int#) -> _!_ I# [] [u2] }; _NO_DEFLT_ } _N_ } #-}
instance (RealFloat a, Hashable a) => Hashable (Complex a)
{-# GHC_PRAGMA _M_ Hash {-dfun-} _A_ 3 _U_ 22 _N_ _S_ "LSS" _N_ _N_ #-}
instance Hashable Double
{-# GHC_PRAGMA _M_ Hash {-dfun-} _A_ 0 _N_ _N_ _N_ _N_ _N_
- hash = _A_ 0 _U_ 2 _N_ _N_ _N_ _N_ #-}
+ hash = { _A_ 0 _U_ 2 _N_ _N_ _N_ _N_ } #-}
instance Hashable Float
{-# GHC_PRAGMA _M_ Hash {-dfun-} _A_ 0 _N_ _N_ _N_ _N_ _N_
- hash = _A_ 0 _U_ 2 _N_ _N_ _N_ _N_ #-}
+ hash = { _A_ 0 _U_ 2 _N_ _N_ _N_ _N_ } #-}
instance Hashable IOError
{-# GHC_PRAGMA _M_ Hash {-dfun-} _A_ 1 _N_ _N_ _N_ _F_ _IF_ARGS_ 0 0 X 1 _CONSTM_ Hashable hash (IOError) _N_
- hash = _A_ 1 _U_ 0 _N_ _S_ "A" {_A_ 0 _N_ _N_ _N_ _F_ _IF_ARGS_ 0 0 X 2 _!_ I# [] [0#] _N_} _F_ _IF_ARGS_ 0 1 X 2 \ (u0 :: IOError) -> _!_ I# [] [0#] _N_ #-}
+ hash = { _A_ 1 _U_ 0 _N_ _S_ "A" {_A_ 0 _N_ _N_ _N_ _F_ _IF_ARGS_ 0 0 X 2 _!_ I# [] [0#] _N_} _F_ _IF_ARGS_ 0 1 X 2 \ (u0 :: IOError) -> _!_ I# [] [0#] _N_ } #-}
instance Hashable Int
{-# GHC_PRAGMA _M_ Hash {-dfun-} _A_ 1 _N_ _N_ _N_ _F_ _IF_ARGS_ 0 0 X 1 _CONSTM_ Hashable hash (Int) _N_
- hash = _A_ 1 _U_ 1 _N_ _S_ "U(P)" {_A_ 1 _U_ 2 _N_ _N_ _F_ _IF_ARGS_ 0 1 X 2 \ (u0 :: Int#) -> _!_ I# [] [u0] _N_} _F_ _IF_ARGS_ 0 1 X 1 \ (u0 :: Int) -> u0 _N_ #-}
+ hash = { _A_ 1 _U_ 1 _N_ _S_ "U(P)" {_A_ 1 _U_ 2 _N_ _N_ _F_ _IF_ARGS_ 0 1 X 2 \ (u0 :: Int#) -> _!_ I# [] [u0] _N_} _F_ _IF_ARGS_ 0 1 X 1 \ (u0 :: Int) -> u0 _N_ } #-}
instance Hashable Integer
{-# GHC_PRAGMA _M_ Hash {-dfun-} _A_ 1 _N_ _N_ _N_ _F_ _IF_ARGS_ 0 0 X 1 _CONSTM_ Hashable hash (Integer) _N_
- hash = _A_ 1 _U_ 1 _N_ _S_ "U(PPP)" {_A_ 3 _U_ 222 _N_ _N_ _F_ _IF_ARGS_ 0 3 XXX 3 \ (u0 :: Int#) (u1 :: Int#) (u2 :: ByteArray#) -> case _#_ integer2Int# [] [u0, u1, u2] of { _PRIM_ (u3 :: Int#) -> _!_ I# [] [u3] } _N_} _F_ _IF_ARGS_ 0 1 C 4 \ (u0 :: Integer) -> case u0 of { _ALG_ J# (u1 :: Int#) (u2 :: Int#) (u3 :: ByteArray#) -> case _#_ integer2Int# [] [u1, u2, u3] of { _PRIM_ (u4 :: Int#) -> _!_ I# [] [u4] }; _NO_DEFLT_ } _N_ #-}
+ hash = { _A_ 1 _U_ 1 _N_ _S_ "U(PPP)" {_A_ 3 _U_ 222 _N_ _N_ _F_ _IF_ARGS_ 0 3 XXX 3 \ (u0 :: Int#) (u1 :: Int#) (u2 :: ByteArray#) -> case _#_ integer2Int# [] [u0, u1, u2] of { _PRIM_ (u3 :: Int#) -> _!_ I# [] [u3] } _N_} _F_ _IF_ARGS_ 0 1 C 4 \ (u0 :: Integer) -> case u0 of { _ALG_ J# (u1 :: Int#) (u2 :: Int#) (u3 :: ByteArray#) -> case _#_ integer2Int# [] [u1, u2, u3] of { _PRIM_ (u4 :: Int#) -> _!_ I# [] [u4] }; _NO_DEFLT_ } _N_ } #-}
instance (Integral a, Hashable a) => Hashable (Ratio a)
{-# GHC_PRAGMA _M_ Hash {-dfun-} _A_ 3 _U_ 22 _N_ _S_ "LSL" _N_ _N_ #-}
instance Hashable Request
{-# GHC_PRAGMA _M_ Hash {-dfun-} _A_ 1 _N_ _N_ _N_ _F_ _IF_ARGS_ 0 0 X 1 _CONSTM_ Hashable hash (Request) _N_
- hash = _A_ 1 _U_ 0 _N_ _S_ "A" {_A_ 0 _N_ _N_ _N_ _F_ _IF_ARGS_ 0 0 X 2 _!_ I# [] [0#] _N_} _F_ _IF_ARGS_ 0 1 X 2 \ (u0 :: Request) -> _!_ I# [] [0#] _N_ #-}
+ hash = { _A_ 1 _U_ 0 _N_ _S_ "A" {_A_ 0 _N_ _N_ _N_ _F_ _IF_ARGS_ 0 0 X 2 _!_ I# [] [0#] _N_} _F_ _IF_ARGS_ 0 1 X 2 \ (u0 :: Request) -> _!_ I# [] [0#] _N_ } #-}
instance Hashable Response
{-# GHC_PRAGMA _M_ Hash {-dfun-} _A_ 1 _N_ _N_ _N_ _F_ _IF_ARGS_ 0 0 X 1 _CONSTM_ Hashable hash (Response) _N_
- hash = _A_ 1 _U_ 0 _N_ _S_ "A" {_A_ 0 _N_ _N_ _N_ _F_ _IF_ARGS_ 0 0 X 2 _!_ I# [] [0#] _N_} _F_ _IF_ARGS_ 0 1 X 2 \ (u0 :: Response) -> _!_ I# [] [0#] _N_ #-}
+ hash = { _A_ 1 _U_ 0 _N_ _S_ "A" {_A_ 0 _N_ _N_ _N_ _F_ _IF_ARGS_ 0 0 X 2 _!_ I# [] [0#] _N_} _F_ _IF_ARGS_ 0 1 X 2 \ (u0 :: Response) -> _!_ I# [] [0#] _N_ } #-}
instance Hashable a => Hashable [a]
{-# GHC_PRAGMA _M_ Hash {-dfun-} _A_ 2 _U_ 2 _N_ _S_ "LS" _N_ _N_ #-}
instance Hashable [Char]
{-# GHC_PRAGMA _M_ Hash {-dfun-} _A_ 1 _N_ _N_ _N_ _F_ _IF_ARGS_ 0 0 X 1 _CONSTM_ Hashable hash ([Char]) _N_
- hash = _A_ 1 _U_ 1 _N_ _S_ "S" _N_ _N_ #-}
+ hash = { _A_ 1 _U_ 1 _N_ _S_ "S" _N_ _N_ } #-}
-{-# GHC_PRAGMA INTERFACE VERSION 5 #-}
+{-# GHC_PRAGMA INTERFACE VERSION 6 #-}
interface Hash where
import PreludeArray(Array, Assoc)
import PreludeComplex(Complex)
class Hashable a where
hash :: a -> Int
{-# GHC_PRAGMA {-meth-} _A_ 1 _U_ 12 _N_ _S_ "S" _F_ _IF_ARGS_ 1 1 X 1 _/\_ u0 -> \ (u1 :: u0 -> Int) -> u1 _N_
- {-defm-} _A_ 2 _U_ 02 _N_ _S_ _!_ _F_ _IF_ARGS_ 1 2 XX 3 _/\_ u0 -> \ (u1 :: {{Hashable u0}}) (u2 :: u0) -> _APP_ _TYAPP_ patError# { (u0 -> Int) } [ _NOREP_S_ "%DHash.Hashable.hash\"", u2 ] _N_ #-}
+ {-defm-} _A_ 2 _U_ 02 _N_ _S_ _!_ _N_ _N_ #-}
hashToMax :: Hashable a => Int -> a -> Int
{-# GHC_PRAGMA _A_ 3 _U_ 122 _N_ _S_ "SLL" _N_ _N_ #-}
instance Hashable ()
{-# GHC_PRAGMA _M_ Hash {-dfun-} _A_ 1 _N_ _N_ _N_ _F_ _IF_ARGS_ 0 0 X 1 _CONSTM_ Hashable hash (()) _N_
- hash = _A_ 1 _U_ 0 _N_ _S_ "A" {_A_ 0 _N_ _N_ _N_ _F_ _IF_ARGS_ 0 0 X 2 _!_ I# [] [0#] _N_} _F_ _IF_ARGS_ 0 1 X 2 \ (u0 :: ()) -> _!_ I# [] [0#] _N_ #-}
+ hash = { _A_ 1 _U_ 0 _N_ _S_ "A" {_A_ 0 _N_ _N_ _N_ _F_ _IF_ARGS_ 0 0 X 2 _!_ I# [] [0#] _N_} _F_ _IF_ARGS_ 0 1 X 2 \ (u0 :: ()) -> _!_ I# [] [0#] _N_ } #-}
instance (Hashable a, Hashable b) => Hashable (a, b)
{-# GHC_PRAGMA _M_ Hash {-dfun-} _A_ 3 _U_ 22 _N_ _S_ "SSS" _N_ _N_ #-}
instance (Hashable a, Hashable b, Hashable c) => Hashable (a, b, c)
{-# GHC_PRAGMA _M_ Hash {-dfun-} _A_ 3 _U_ 22 _N_ _S_ "SSS" _N_ _N_ #-}
instance Hashable Bin
{-# GHC_PRAGMA _M_ Hash {-dfun-} _A_ 1 _N_ _N_ _N_ _F_ _IF_ARGS_ 0 0 X 1 _CONSTM_ Hashable hash (Bin) _N_
- hash = _A_ 1 _U_ 0 _N_ _S_ "A" {_A_ 0 _N_ _N_ _N_ _F_ _IF_ARGS_ 0 0 X 2 _!_ I# [] [0#] _N_} _F_ _IF_ARGS_ 0 1 X 2 \ (u0 :: Bin) -> _!_ I# [] [0#] _N_ #-}
+ hash = { _A_ 1 _U_ 0 _N_ _S_ "A" {_A_ 0 _N_ _N_ _N_ _F_ _IF_ARGS_ 0 0 X 2 _!_ I# [] [0#] _N_} _F_ _IF_ARGS_ 0 1 X 2 \ (u0 :: Bin) -> _!_ I# [] [0#] _N_ } #-}
instance Hashable Bool
{-# GHC_PRAGMA _M_ Hash {-dfun-} _A_ 1 _N_ _N_ _N_ _F_ _IF_ARGS_ 0 0 X 1 _CONSTM_ Hashable hash (Bool) _N_
- hash = _A_ 1 _U_ 1 _N_ _S_ "E" _F_ _IF_ARGS_ 0 1 C 6 \ (u0 :: Bool) -> case u0 of { _ALG_ False -> _!_ I# [] [0#]; True -> _!_ I# [] [1#]; _NO_DEFLT_ } _N_ #-}
+ hash = { _A_ 1 _U_ 1 _N_ _S_ "E" _F_ _IF_ARGS_ 0 1 C 6 \ (u0 :: Bool) -> case u0 of { _ALG_ False -> _!_ I# [] [0#]; True -> _!_ I# [] [1#]; _NO_DEFLT_ } _N_ } #-}
instance Hashable Char
{-# GHC_PRAGMA _M_ Hash {-dfun-} _A_ 1 _N_ _N_ _N_ _F_ _IF_ARGS_ 0 0 X 1 _CONSTM_ Hashable hash (Char) _N_
- hash = _A_ 1 _U_ 1 _N_ _S_ "U(P)" {_A_ 1 _U_ 2 _N_ _N_ _F_ _IF_ARGS_ 0 1 X 3 \ (u0 :: Char#) -> case _#_ ord# [] [u0] of { _PRIM_ (u1 :: Int#) -> _!_ I# [] [u1] } _N_} _F_ _IF_ARGS_ 0 1 C 4 \ (u0 :: Char) -> case u0 of { _ALG_ C# (u1 :: Char#) -> case _#_ ord# [] [u1] of { _PRIM_ (u2 :: Int#) -> _!_ I# [] [u2] }; _NO_DEFLT_ } _N_ #-}
+ hash = { _A_ 1 _U_ 1 _N_ _S_ "U(P)" {_A_ 1 _U_ 2 _N_ _N_ _F_ _IF_ARGS_ 0 1 X 3 \ (u0 :: Char#) -> case _#_ ord# [] [u0] of { _PRIM_ (u1 :: Int#) -> _!_ I# [] [u1] } _N_} _F_ _IF_ARGS_ 0 1 C 4 \ (u0 :: Char) -> case u0 of { _ALG_ C# (u1 :: Char#) -> case _#_ ord# [] [u1] of { _PRIM_ (u2 :: Int#) -> _!_ I# [] [u2] }; _NO_DEFLT_ } _N_ } #-}
instance (RealFloat a, Hashable a) => Hashable (Complex a)
{-# GHC_PRAGMA _M_ Hash {-dfun-} _A_ 3 _U_ 22 _N_ _S_ "LSS" _N_ _N_ #-}
instance Hashable Double
{-# GHC_PRAGMA _M_ Hash {-dfun-} _A_ 0 _N_ _N_ _N_ _N_ _N_
- hash = _A_ 0 _U_ 2 _N_ _N_ _N_ _N_ #-}
+ hash = { _A_ 0 _U_ 2 _N_ _N_ _N_ _N_ } #-}
instance Hashable Float
{-# GHC_PRAGMA _M_ Hash {-dfun-} _A_ 0 _N_ _N_ _N_ _N_ _N_
- hash = _A_ 0 _U_ 2 _N_ _N_ _N_ _N_ #-}
+ hash = { _A_ 0 _U_ 2 _N_ _N_ _N_ _N_ } #-}
instance Hashable IOError
{-# GHC_PRAGMA _M_ Hash {-dfun-} _A_ 1 _N_ _N_ _N_ _F_ _IF_ARGS_ 0 0 X 1 _CONSTM_ Hashable hash (IOError) _N_
- hash = _A_ 1 _U_ 0 _N_ _S_ "A" {_A_ 0 _N_ _N_ _N_ _F_ _IF_ARGS_ 0 0 X 2 _!_ I# [] [0#] _N_} _F_ _IF_ARGS_ 0 1 X 2 \ (u0 :: IOError) -> _!_ I# [] [0#] _N_ #-}
+ hash = { _A_ 1 _U_ 0 _N_ _S_ "A" {_A_ 0 _N_ _N_ _N_ _F_ _IF_ARGS_ 0 0 X 2 _!_ I# [] [0#] _N_} _F_ _IF_ARGS_ 0 1 X 2 \ (u0 :: IOError) -> _!_ I# [] [0#] _N_ } #-}
instance Hashable Int
{-# GHC_PRAGMA _M_ Hash {-dfun-} _A_ 1 _N_ _N_ _N_ _F_ _IF_ARGS_ 0 0 X 1 _CONSTM_ Hashable hash (Int) _N_
- hash = _A_ 1 _U_ 1 _N_ _S_ "U(P)" {_A_ 1 _U_ 2 _N_ _N_ _F_ _IF_ARGS_ 0 1 X 2 \ (u0 :: Int#) -> _!_ I# [] [u0] _N_} _F_ _IF_ARGS_ 0 1 X 1 \ (u0 :: Int) -> u0 _N_ #-}
+ hash = { _A_ 1 _U_ 1 _N_ _S_ "U(P)" {_A_ 1 _U_ 2 _N_ _N_ _F_ _IF_ARGS_ 0 1 X 2 \ (u0 :: Int#) -> _!_ I# [] [u0] _N_} _F_ _IF_ARGS_ 0 1 X 1 \ (u0 :: Int) -> u0 _N_ } #-}
instance Hashable Integer
{-# GHC_PRAGMA _M_ Hash {-dfun-} _A_ 1 _N_ _N_ _N_ _F_ _IF_ARGS_ 0 0 X 1 _CONSTM_ Hashable hash (Integer) _N_
- hash = _A_ 1 _U_ 1 _N_ _S_ "U(PPP)" {_A_ 3 _U_ 222 _N_ _N_ _F_ _IF_ARGS_ 0 3 XXX 3 \ (u0 :: Int#) (u1 :: Int#) (u2 :: ByteArray#) -> case _#_ integer2Int# [] [u0, u1, u2] of { _PRIM_ (u3 :: Int#) -> _!_ I# [] [u3] } _N_} _F_ _IF_ARGS_ 0 1 C 4 \ (u0 :: Integer) -> case u0 of { _ALG_ J# (u1 :: Int#) (u2 :: Int#) (u3 :: ByteArray#) -> case _#_ integer2Int# [] [u1, u2, u3] of { _PRIM_ (u4 :: Int#) -> _!_ I# [] [u4] }; _NO_DEFLT_ } _N_ #-}
+ hash = { _A_ 1 _U_ 1 _N_ _S_ "U(PPP)" {_A_ 3 _U_ 222 _N_ _N_ _F_ _IF_ARGS_ 0 3 XXX 3 \ (u0 :: Int#) (u1 :: Int#) (u2 :: ByteArray#) -> case _#_ integer2Int# [] [u0, u1, u2] of { _PRIM_ (u3 :: Int#) -> _!_ I# [] [u3] } _N_} _F_ _IF_ARGS_ 0 1 C 4 \ (u0 :: Integer) -> case u0 of { _ALG_ J# (u1 :: Int#) (u2 :: Int#) (u3 :: ByteArray#) -> case _#_ integer2Int# [] [u1, u2, u3] of { _PRIM_ (u4 :: Int#) -> _!_ I# [] [u4] }; _NO_DEFLT_ } _N_ } #-}
instance (Integral a, Hashable a) => Hashable (Ratio a)
{-# GHC_PRAGMA _M_ Hash {-dfun-} _A_ 3 _U_ 22 _N_ _S_ "LSL" _N_ _N_ #-}
instance Hashable Request
{-# GHC_PRAGMA _M_ Hash {-dfun-} _A_ 1 _N_ _N_ _N_ _F_ _IF_ARGS_ 0 0 X 1 _CONSTM_ Hashable hash (Request) _N_
- hash = _A_ 1 _U_ 0 _N_ _S_ "A" {_A_ 0 _N_ _N_ _N_ _F_ _IF_ARGS_ 0 0 X 2 _!_ I# [] [0#] _N_} _F_ _IF_ARGS_ 0 1 X 2 \ (u0 :: Request) -> _!_ I# [] [0#] _N_ #-}
+ hash = { _A_ 1 _U_ 0 _N_ _S_ "A" {_A_ 0 _N_ _N_ _N_ _F_ _IF_ARGS_ 0 0 X 2 _!_ I# [] [0#] _N_} _F_ _IF_ARGS_ 0 1 X 2 \ (u0 :: Request) -> _!_ I# [] [0#] _N_ } #-}
instance Hashable Response
{-# GHC_PRAGMA _M_ Hash {-dfun-} _A_ 1 _N_ _N_ _N_ _F_ _IF_ARGS_ 0 0 X 1 _CONSTM_ Hashable hash (Response) _N_
- hash = _A_ 1 _U_ 0 _N_ _S_ "A" {_A_ 0 _N_ _N_ _N_ _F_ _IF_ARGS_ 0 0 X 2 _!_ I# [] [0#] _N_} _F_ _IF_ARGS_ 0 1 X 2 \ (u0 :: Response) -> _!_ I# [] [0#] _N_ #-}
+ hash = { _A_ 1 _U_ 0 _N_ _S_ "A" {_A_ 0 _N_ _N_ _N_ _F_ _IF_ARGS_ 0 0 X 2 _!_ I# [] [0#] _N_} _F_ _IF_ARGS_ 0 1 X 2 \ (u0 :: Response) -> _!_ I# [] [0#] _N_ } #-}
instance Hashable a => Hashable [a]
{-# GHC_PRAGMA _M_ Hash {-dfun-} _A_ 2 _U_ 2 _N_ _S_ "LS" _N_ _N_ #-}
instance Hashable [Char]
{-# GHC_PRAGMA _M_ Hash {-dfun-} _A_ 1 _N_ _N_ _N_ _F_ _IF_ARGS_ 0 0 X 1 _CONSTM_ Hashable hash ([Char]) _N_
- hash = _A_ 1 _U_ 1 _N_ _S_ "S" _N_ _N_ #-}
+ hash = { _A_ 1 _U_ 1 _N_ _S_ "S" _N_ _N_ } #-}
-{-# GHC_PRAGMA INTERFACE VERSION 5 #-}
+{-# GHC_PRAGMA INTERFACE VERSION 6 #-}
interface NameSupply where
type Name = Int
data NameSupply {-# GHC_PRAGMA NameSupply Int NameSupply NameSupply #-}
-{-# GHC_PRAGMA INTERFACE VERSION 5 #-}
+{-# GHC_PRAGMA INTERFACE VERSION 6 #-}
interface NameSupply where
type Name = Int
data NameSupply {-# GHC_PRAGMA NameSupply Int NameSupply NameSupply #-}
-{-# GHC_PRAGMA INTERFACE VERSION 5 #-}
+{-# GHC_PRAGMA INTERFACE VERSION 6 #-}
interface NameSupply where
type Name = Int
data NameSupply {-# GHC_PRAGMA NameSupply Int NameSupply NameSupply #-}
-{-# GHC_PRAGMA INTERFACE VERSION 5 #-}
+{-# GHC_PRAGMA INTERFACE VERSION 6 #-}
interface NameSupply where
type Name = Int
data NameSupply {-# GHC_PRAGMA NameSupply Int NameSupply NameSupply #-}
-{-# GHC_PRAGMA INTERFACE VERSION 5 #-}
+{-# GHC_PRAGMA INTERFACE VERSION 6 #-}
interface NameSupply where
type Name = Int
data NameSupply {-# GHC_PRAGMA NameSupply Int NameSupply NameSupply #-}
-{-# GHC_PRAGMA INTERFACE VERSION 5 #-}
+{-# GHC_PRAGMA INTERFACE VERSION 6 #-}
interface Native where
import PreludeArray(Array)
import PreludeStdIO(Maybe)
class Native a where
showBytes :: a -> [Char] -> [Char]
{-# GHC_PRAGMA {-meth-} _A_ 1 _U_ 122 _N_ _S_ "U(SAAA)" {_A_ 1 _U_ 122 _N_ _N_ _F_ _IF_ARGS_ 1 1 X 1 _/\_ u0 -> \ (u1 :: u0 -> [Char] -> [Char]) -> u1 _N_} _F_ _IF_ARGS_ 1 1 C 2 _/\_ u0 -> \ (u1 :: (u0 -> [Char] -> [Char], [Char] -> Maybe (u0, [Char]), [u0] -> [Char] -> [Char], Int -> [Char] -> Maybe ([u0], [Char]))) -> case u1 of { _ALG_ _TUP_4 (u2 :: u0 -> [Char] -> [Char]) (u3 :: [Char] -> Maybe (u0, [Char])) (u4 :: [u0] -> [Char] -> [Char]) (u5 :: Int -> [Char] -> Maybe ([u0], [Char])) -> u2; _NO_DEFLT_ } _N_
- {-defm-} _A_ 3 _U_ 022 _N_ _S_ _!_ _F_ _IF_ARGS_ 1 3 XXX 4 _/\_ u0 -> \ (u1 :: {{Native u0}}) (u2 :: u0) (u3 :: [Char]) -> _APP_ _TYAPP_ patError# { (u0 -> [Char] -> [Char]) } [ _NOREP_S_ "%DNative.Native.showBytes\"", u2, u3 ] _N_ #-}
+ {-defm-} _A_ 3 _U_ 022 _N_ _S_ _!_ _N_ _N_ #-}
readBytes :: [Char] -> Maybe (a, [Char])
{-# GHC_PRAGMA {-meth-} _A_ 1 _U_ 12 _N_ _S_ "U(ASAA)" {_A_ 1 _U_ 12 _N_ _N_ _F_ _IF_ARGS_ 1 1 X 1 _/\_ u0 -> \ (u1 :: [Char] -> Maybe (u0, [Char])) -> u1 _N_} _F_ _IF_ARGS_ 1 1 C 2 _/\_ u0 -> \ (u1 :: (u0 -> [Char] -> [Char], [Char] -> Maybe (u0, [Char]), [u0] -> [Char] -> [Char], Int -> [Char] -> Maybe ([u0], [Char]))) -> case u1 of { _ALG_ _TUP_4 (u2 :: u0 -> [Char] -> [Char]) (u3 :: [Char] -> Maybe (u0, [Char])) (u4 :: [u0] -> [Char] -> [Char]) (u5 :: Int -> [Char] -> Maybe ([u0], [Char])) -> u3; _NO_DEFLT_ } _N_
- {-defm-} _A_ 2 _U_ 02 _N_ _S_ _!_ _F_ _IF_ARGS_ 1 2 XX 3 _/\_ u0 -> \ (u1 :: {{Native u0}}) (u2 :: [Char]) -> _APP_ _TYAPP_ patError# { ([Char] -> Maybe (u0, [Char])) } [ _NOREP_S_ "%DNative.Native.readBytes\"", u2 ] _N_ #-}
+ {-defm-} _A_ 2 _U_ 02 _N_ _S_ _!_ _N_ _N_ #-}
listShowBytes :: [a] -> [Char] -> [Char]
{-# GHC_PRAGMA {-meth-} _A_ 1 _U_ 122 _N_ _S_ "U(AASA)" {_A_ 1 _U_ 122 _N_ _N_ _F_ _IF_ARGS_ 1 1 X 1 _/\_ u0 -> \ (u1 :: [u0] -> [Char] -> [Char]) -> u1 _N_} _F_ _IF_ARGS_ 1 1 C 2 _/\_ u0 -> \ (u1 :: (u0 -> [Char] -> [Char], [Char] -> Maybe (u0, [Char]), [u0] -> [Char] -> [Char], Int -> [Char] -> Maybe ([u0], [Char]))) -> case u1 of { _ALG_ _TUP_4 (u2 :: u0 -> [Char] -> [Char]) (u3 :: [Char] -> Maybe (u0, [Char])) (u4 :: [u0] -> [Char] -> [Char]) (u5 :: Int -> [Char] -> Maybe ([u0], [Char])) -> u4; _NO_DEFLT_ } _N_
{-defm-} _A_ 3 _U_ 112 _N_ _S_ "LSL" _N_ _N_ #-}
{-# GHC_PRAGMA _M_ Native {-dfun-} _A_ 3 _U_ 222 _N_ _N_ _N_ _N_ #-}
instance Native Bool
{-# GHC_PRAGMA _M_ Native {-dfun-} _A_ 0 _N_ _N_ _N_ _F_ _IF_ARGS_ 0 0 X 5 _!_ _TUP_4 [(Bool -> [Char] -> [Char]), ([Char] -> Maybe (Bool, [Char])), ([Bool] -> [Char] -> [Char]), (Int -> [Char] -> Maybe ([Bool], [Char]))] [_CONSTM_ Native showBytes (Bool), _CONSTM_ Native readBytes (Bool), _CONSTM_ Native listShowBytes (Bool), _CONSTM_ Native listReadBytes (Bool)] _N_
- showBytes = _A_ 2 _U_ 12 _N_ _S_ "EL" _N_ _N_,
- readBytes = _A_ 1 _U_ 1 _N_ _S_ "S" _N_ _N_,
- listShowBytes = _A_ 2 _U_ 12 _N_ _N_ _N_ _N_,
- listReadBytes = _A_ 2 _U_ 12 _N_ _N_ _N_ _N_ #-}
+ showBytes = { _A_ 2 _U_ 12 _N_ _S_ "EL" _N_ _N_ },
+ readBytes = { _A_ 1 _U_ 1 _N_ _S_ "S" _N_ _N_ },
+ listShowBytes = { _A_ 2 _U_ 12 _N_ _N_ _N_ _N_ },
+ listReadBytes = { _A_ 2 _U_ 12 _N_ _N_ _N_ _N_ } #-}
instance Native Char
{-# GHC_PRAGMA _M_ Native {-dfun-} _A_ 0 _N_ _N_ _N_ _F_ _IF_ARGS_ 0 0 X 5 _!_ _TUP_4 [(Char -> [Char] -> [Char]), ([Char] -> Maybe (Char, [Char])), ([Char] -> [Char] -> [Char]), (Int -> [Char] -> Maybe ([Char], [Char]))] [_CONSTM_ Native showBytes (Char), _CONSTM_ Native readBytes (Char), _CONSTM_ Native listShowBytes (Char), _CONSTM_ Native listReadBytes (Char)] _N_
- showBytes = _A_ 2 _U_ 22 _N_ _N_ _F_ _IF_ARGS_ 0 2 XX 3 \ (u0 :: Char) (u1 :: [Char]) -> _!_ (:) [Char] [u0, u1] _N_,
- readBytes = _A_ 1 _U_ 1 _N_ _S_ "S" _N_ _N_,
- listShowBytes = _A_ 2 _U_ 12 _N_ _N_ _N_ _N_,
- listReadBytes = _A_ 2 _U_ 12 _N_ _S_ "U(P)L" {_A_ 2 _U_ 22 _N_ _N_ _N_ _N_} _N_ _N_ #-}
+ showBytes = { _A_ 2 _U_ 22 _N_ _N_ _F_ _IF_ARGS_ 0 2 XX 3 \ (u0 :: Char) (u1 :: [Char]) -> _!_ (:) [Char] [u0, u1] _N_ },
+ readBytes = { _A_ 1 _U_ 1 _N_ _S_ "S" _N_ _N_ },
+ listShowBytes = { _A_ 2 _U_ 12 _N_ _N_ _N_ _N_ },
+ listReadBytes = { _A_ 2 _U_ 12 _N_ _S_ "U(P)L" {_A_ 2 _U_ 22 _N_ _N_ _N_ _N_} _N_ _N_ } #-}
instance Native Double
{-# GHC_PRAGMA _M_ Native {-dfun-} _A_ 0 _N_ _N_ _N_ _F_ _IF_ARGS_ 0 0 X 5 _!_ _TUP_4 [(Double -> [Char] -> [Char]), ([Char] -> Maybe (Double, [Char])), ([Double] -> [Char] -> [Char]), (Int -> [Char] -> Maybe ([Double], [Char]))] [_CONSTM_ Native showBytes (Double), _CONSTM_ Native readBytes (Double), _CONSTM_ Native listShowBytes (Double), _CONSTM_ Native listReadBytes (Double)] _N_
- showBytes = _A_ 2 _U_ 12 _N_ _S_ "U(P)L" {_A_ 2 _U_ 22 _N_ _N_ _N_ _N_} _N_ _N_,
- readBytes = _A_ 1 _U_ 2 _N_ _N_ _N_ _N_,
- listShowBytes = _A_ 2 _U_ 12 _N_ _N_ _N_ _N_,
- listReadBytes = _A_ 2 _U_ 12 _N_ _N_ _N_ _N_ #-}
+ showBytes = { _A_ 2 _U_ 12 _N_ _S_ "U(P)L" {_A_ 2 _U_ 22 _N_ _N_ _N_ _N_} _N_ _N_ },
+ readBytes = { _A_ 1 _U_ 2 _N_ _N_ _N_ _N_ },
+ listShowBytes = { _A_ 2 _U_ 12 _N_ _N_ _N_ _N_ },
+ listReadBytes = { _A_ 2 _U_ 12 _N_ _N_ _N_ _N_ } #-}
instance Native Float
{-# GHC_PRAGMA _M_ Native {-dfun-} _A_ 0 _N_ _N_ _N_ _F_ _IF_ARGS_ 0 0 X 5 _!_ _TUP_4 [(Float -> [Char] -> [Char]), ([Char] -> Maybe (Float, [Char])), ([Float] -> [Char] -> [Char]), (Int -> [Char] -> Maybe ([Float], [Char]))] [_CONSTM_ Native showBytes (Float), _CONSTM_ Native readBytes (Float), _CONSTM_ Native listShowBytes (Float), _CONSTM_ Native listReadBytes (Float)] _N_
- showBytes = _A_ 2 _U_ 12 _N_ _S_ "U(P)L" {_A_ 2 _U_ 22 _N_ _N_ _N_ _N_} _N_ _N_,
- readBytes = _A_ 1 _U_ 2 _N_ _N_ _N_ _N_,
- listShowBytes = _A_ 2 _U_ 12 _N_ _N_ _N_ _N_,
- listReadBytes = _A_ 2 _U_ 12 _N_ _N_ _N_ _N_ #-}
+ showBytes = { _A_ 2 _U_ 12 _N_ _S_ "U(P)L" {_A_ 2 _U_ 22 _N_ _N_ _N_ _N_} _N_ _N_ },
+ readBytes = { _A_ 1 _U_ 2 _N_ _N_ _N_ _N_ },
+ listShowBytes = { _A_ 2 _U_ 12 _N_ _N_ _N_ _N_ },
+ listReadBytes = { _A_ 2 _U_ 12 _N_ _N_ _N_ _N_ } #-}
instance Native Int
{-# GHC_PRAGMA _M_ Native {-dfun-} _A_ 0 _N_ _N_ _N_ _F_ _IF_ARGS_ 0 0 X 5 _!_ _TUP_4 [(Int -> [Char] -> [Char]), ([Char] -> Maybe (Int, [Char])), ([Int] -> [Char] -> [Char]), (Int -> [Char] -> Maybe ([Int], [Char]))] [_CONSTM_ Native showBytes (Int), _CONSTM_ Native readBytes (Int), _CONSTM_ Native listShowBytes (Int), _CONSTM_ Native listReadBytes (Int)] _N_
- showBytes = _A_ 2 _U_ 12 _N_ _S_ "U(P)L" {_A_ 2 _U_ 22 _N_ _N_ _N_ _N_} _N_ _N_,
- readBytes = _A_ 1 _U_ 2 _N_ _N_ _N_ _N_,
- listShowBytes = _A_ 2 _U_ 12 _N_ _N_ _N_ _N_,
- listReadBytes = _A_ 2 _U_ 12 _N_ _N_ _N_ _N_ #-}
+ showBytes = { _A_ 2 _U_ 12 _N_ _S_ "U(P)L" {_A_ 2 _U_ 22 _N_ _N_ _N_ _N_} _N_ _N_ },
+ readBytes = { _A_ 1 _U_ 2 _N_ _N_ _N_ _N_ },
+ listShowBytes = { _A_ 2 _U_ 12 _N_ _N_ _N_ _N_ },
+ listReadBytes = { _A_ 2 _U_ 12 _N_ _N_ _N_ _N_ } #-}
instance Native a => Native (Maybe a)
{-# GHC_PRAGMA _M_ Native {-dfun-} _A_ 1 _U_ 2 _N_ _N_ _N_ _N_ #-}
instance Native a => Native [a]
-{-# GHC_PRAGMA INTERFACE VERSION 5 #-}
+{-# GHC_PRAGMA INTERFACE VERSION 6 #-}
interface Native where
import PreludeArray(Array)
import PreludeStdIO(Maybe)
class Native a where
showBytes :: a -> [Char] -> [Char]
{-# GHC_PRAGMA {-meth-} _A_ 1 _U_ 122 _N_ _S_ "U(SAAA)" {_A_ 1 _U_ 122 _N_ _N_ _F_ _IF_ARGS_ 1 1 X 1 _/\_ u0 -> \ (u1 :: u0 -> [Char] -> [Char]) -> u1 _N_} _F_ _IF_ARGS_ 1 1 C 2 _/\_ u0 -> \ (u1 :: (u0 -> [Char] -> [Char], [Char] -> Maybe (u0, [Char]), [u0] -> [Char] -> [Char], Int -> [Char] -> Maybe ([u0], [Char]))) -> case u1 of { _ALG_ _TUP_4 (u2 :: u0 -> [Char] -> [Char]) (u3 :: [Char] -> Maybe (u0, [Char])) (u4 :: [u0] -> [Char] -> [Char]) (u5 :: Int -> [Char] -> Maybe ([u0], [Char])) -> u2; _NO_DEFLT_ } _N_
- {-defm-} _A_ 3 _U_ 022 _N_ _S_ _!_ _F_ _IF_ARGS_ 1 3 XXX 4 _/\_ u0 -> \ (u1 :: {{Native u0}}) (u2 :: u0) (u3 :: [Char]) -> _APP_ _TYAPP_ patError# { (u0 -> [Char] -> [Char]) } [ _NOREP_S_ "%DNative.Native.showBytes\"", u2, u3 ] _N_ #-}
+ {-defm-} _A_ 3 _U_ 022 _N_ _S_ _!_ _N_ _N_ #-}
readBytes :: [Char] -> Maybe (a, [Char])
{-# GHC_PRAGMA {-meth-} _A_ 1 _U_ 12 _N_ _S_ "U(ASAA)" {_A_ 1 _U_ 12 _N_ _N_ _F_ _IF_ARGS_ 1 1 X 1 _/\_ u0 -> \ (u1 :: [Char] -> Maybe (u0, [Char])) -> u1 _N_} _F_ _IF_ARGS_ 1 1 C 2 _/\_ u0 -> \ (u1 :: (u0 -> [Char] -> [Char], [Char] -> Maybe (u0, [Char]), [u0] -> [Char] -> [Char], Int -> [Char] -> Maybe ([u0], [Char]))) -> case u1 of { _ALG_ _TUP_4 (u2 :: u0 -> [Char] -> [Char]) (u3 :: [Char] -> Maybe (u0, [Char])) (u4 :: [u0] -> [Char] -> [Char]) (u5 :: Int -> [Char] -> Maybe ([u0], [Char])) -> u3; _NO_DEFLT_ } _N_
- {-defm-} _A_ 2 _U_ 02 _N_ _S_ _!_ _F_ _IF_ARGS_ 1 2 XX 3 _/\_ u0 -> \ (u1 :: {{Native u0}}) (u2 :: [Char]) -> _APP_ _TYAPP_ patError# { ([Char] -> Maybe (u0, [Char])) } [ _NOREP_S_ "%DNative.Native.readBytes\"", u2 ] _N_ #-}
+ {-defm-} _A_ 2 _U_ 02 _N_ _S_ _!_ _N_ _N_ #-}
listShowBytes :: [a] -> [Char] -> [Char]
{-# GHC_PRAGMA {-meth-} _A_ 1 _U_ 122 _N_ _S_ "U(AASA)" {_A_ 1 _U_ 122 _N_ _N_ _F_ _IF_ARGS_ 1 1 X 1 _/\_ u0 -> \ (u1 :: [u0] -> [Char] -> [Char]) -> u1 _N_} _F_ _IF_ARGS_ 1 1 C 2 _/\_ u0 -> \ (u1 :: (u0 -> [Char] -> [Char], [Char] -> Maybe (u0, [Char]), [u0] -> [Char] -> [Char], Int -> [Char] -> Maybe ([u0], [Char]))) -> case u1 of { _ALG_ _TUP_4 (u2 :: u0 -> [Char] -> [Char]) (u3 :: [Char] -> Maybe (u0, [Char])) (u4 :: [u0] -> [Char] -> [Char]) (u5 :: Int -> [Char] -> Maybe ([u0], [Char])) -> u4; _NO_DEFLT_ } _N_
{-defm-} _A_ 3 _U_ 112 _N_ _S_ "LSL" _N_ _N_ #-}
{-# GHC_PRAGMA _M_ Native {-dfun-} _A_ 3 _U_ 222 _N_ _N_ _N_ _N_ #-}
instance Native Bool
{-# GHC_PRAGMA _M_ Native {-dfun-} _A_ 0 _N_ _N_ _N_ _F_ _IF_ARGS_ 0 0 X 5 _!_ _TUP_4 [(Bool -> [Char] -> [Char]), ([Char] -> Maybe (Bool, [Char])), ([Bool] -> [Char] -> [Char]), (Int -> [Char] -> Maybe ([Bool], [Char]))] [_CONSTM_ Native showBytes (Bool), _CONSTM_ Native readBytes (Bool), _CONSTM_ Native listShowBytes (Bool), _CONSTM_ Native listReadBytes (Bool)] _N_
- showBytes = _A_ 2 _U_ 12 _N_ _S_ "EL" _N_ _N_,
- readBytes = _A_ 1 _U_ 1 _N_ _S_ "S" _N_ _N_,
- listShowBytes = _A_ 2 _U_ 12 _N_ _N_ _N_ _N_,
- listReadBytes = _A_ 2 _U_ 12 _N_ _N_ _N_ _N_ #-}
+ showBytes = { _A_ 2 _U_ 12 _N_ _S_ "EL" _N_ _N_ },
+ readBytes = { _A_ 1 _U_ 1 _N_ _S_ "S" _N_ _N_ },
+ listShowBytes = { _A_ 2 _U_ 12 _N_ _N_ _N_ _N_ },
+ listReadBytes = { _A_ 2 _U_ 12 _N_ _N_ _N_ _N_ } #-}
instance Native Char
{-# GHC_PRAGMA _M_ Native {-dfun-} _A_ 0 _N_ _N_ _N_ _F_ _IF_ARGS_ 0 0 X 5 _!_ _TUP_4 [(Char -> [Char] -> [Char]), ([Char] -> Maybe (Char, [Char])), ([Char] -> [Char] -> [Char]), (Int -> [Char] -> Maybe ([Char], [Char]))] [_CONSTM_ Native showBytes (Char), _CONSTM_ Native readBytes (Char), _CONSTM_ Native listShowBytes (Char), _CONSTM_ Native listReadBytes (Char)] _N_
- showBytes = _A_ 2 _U_ 22 _N_ _N_ _F_ _IF_ARGS_ 0 2 XX 3 \ (u0 :: Char) (u1 :: [Char]) -> _!_ (:) [Char] [u0, u1] _N_,
- readBytes = _A_ 1 _U_ 1 _N_ _S_ "S" _N_ _N_,
- listShowBytes = _A_ 2 _U_ 12 _N_ _N_ _N_ _N_,
- listReadBytes = _A_ 2 _U_ 12 _N_ _S_ "U(P)L" {_A_ 2 _U_ 22 _N_ _N_ _N_ _N_} _N_ _N_ #-}
+ showBytes = { _A_ 2 _U_ 22 _N_ _N_ _F_ _IF_ARGS_ 0 2 XX 3 \ (u0 :: Char) (u1 :: [Char]) -> _!_ (:) [Char] [u0, u1] _N_ },
+ readBytes = { _A_ 1 _U_ 1 _N_ _S_ "S" _N_ _N_ },
+ listShowBytes = { _A_ 2 _U_ 12 _N_ _N_ _N_ _N_ },
+ listReadBytes = { _A_ 2 _U_ 12 _N_ _S_ "U(P)L" {_A_ 2 _U_ 22 _N_ _N_ _N_ _N_} _N_ _N_ } #-}
instance Native Double
{-# GHC_PRAGMA _M_ Native {-dfun-} _A_ 0 _N_ _N_ _N_ _F_ _IF_ARGS_ 0 0 X 5 _!_ _TUP_4 [(Double -> [Char] -> [Char]), ([Char] -> Maybe (Double, [Char])), ([Double] -> [Char] -> [Char]), (Int -> [Char] -> Maybe ([Double], [Char]))] [_CONSTM_ Native showBytes (Double), _CONSTM_ Native readBytes (Double), _CONSTM_ Native listShowBytes (Double), _CONSTM_ Native listReadBytes (Double)] _N_
- showBytes = _A_ 2 _U_ 12 _N_ _S_ "U(P)L" {_A_ 2 _U_ 22 _N_ _N_ _N_ _N_} _N_ _N_,
- readBytes = _A_ 1 _U_ 2 _N_ _N_ _N_ _N_,
- listShowBytes = _A_ 2 _U_ 12 _N_ _N_ _N_ _N_,
- listReadBytes = _A_ 2 _U_ 12 _N_ _N_ _N_ _N_ #-}
+ showBytes = { _A_ 2 _U_ 12 _N_ _S_ "U(P)L" {_A_ 2 _U_ 22 _N_ _N_ _N_ _N_} _N_ _N_ },
+ readBytes = { _A_ 1 _U_ 2 _N_ _N_ _N_ _N_ },
+ listShowBytes = { _A_ 2 _U_ 12 _N_ _N_ _N_ _N_ },
+ listReadBytes = { _A_ 2 _U_ 12 _N_ _N_ _N_ _N_ } #-}
instance Native Float
{-# GHC_PRAGMA _M_ Native {-dfun-} _A_ 0 _N_ _N_ _N_ _F_ _IF_ARGS_ 0 0 X 5 _!_ _TUP_4 [(Float -> [Char] -> [Char]), ([Char] -> Maybe (Float, [Char])), ([Float] -> [Char] -> [Char]), (Int -> [Char] -> Maybe ([Float], [Char]))] [_CONSTM_ Native showBytes (Float), _CONSTM_ Native readBytes (Float), _CONSTM_ Native listShowBytes (Float), _CONSTM_ Native listReadBytes (Float)] _N_
- showBytes = _A_ 2 _U_ 12 _N_ _S_ "U(P)L" {_A_ 2 _U_ 22 _N_ _N_ _N_ _N_} _N_ _N_,
- readBytes = _A_ 1 _U_ 2 _N_ _N_ _N_ _N_,
- listShowBytes = _A_ 2 _U_ 12 _N_ _N_ _N_ _N_,
- listReadBytes = _A_ 2 _U_ 12 _N_ _N_ _N_ _N_ #-}
+ showBytes = { _A_ 2 _U_ 12 _N_ _S_ "U(P)L" {_A_ 2 _U_ 22 _N_ _N_ _N_ _N_} _N_ _N_ },
+ readBytes = { _A_ 1 _U_ 2 _N_ _N_ _N_ _N_ },
+ listShowBytes = { _A_ 2 _U_ 12 _N_ _N_ _N_ _N_ },
+ listReadBytes = { _A_ 2 _U_ 12 _N_ _N_ _N_ _N_ } #-}
instance Native Int
{-# GHC_PRAGMA _M_ Native {-dfun-} _A_ 0 _N_ _N_ _N_ _F_ _IF_ARGS_ 0 0 X 5 _!_ _TUP_4 [(Int -> [Char] -> [Char]), ([Char] -> Maybe (Int, [Char])), ([Int] -> [Char] -> [Char]), (Int -> [Char] -> Maybe ([Int], [Char]))] [_CONSTM_ Native showBytes (Int), _CONSTM_ Native readBytes (Int), _CONSTM_ Native listShowBytes (Int), _CONSTM_ Native listReadBytes (Int)] _N_
- showBytes = _A_ 2 _U_ 12 _N_ _S_ "U(P)L" {_A_ 2 _U_ 22 _N_ _N_ _N_ _N_} _N_ _N_,
- readBytes = _A_ 1 _U_ 2 _N_ _N_ _N_ _N_,
- listShowBytes = _A_ 2 _U_ 12 _N_ _N_ _N_ _N_,
- listReadBytes = _A_ 2 _U_ 12 _N_ _N_ _N_ _N_ #-}
+ showBytes = { _A_ 2 _U_ 12 _N_ _S_ "U(P)L" {_A_ 2 _U_ 22 _N_ _N_ _N_ _N_} _N_ _N_ },
+ readBytes = { _A_ 1 _U_ 2 _N_ _N_ _N_ _N_ },
+ listShowBytes = { _A_ 2 _U_ 12 _N_ _N_ _N_ _N_ },
+ listReadBytes = { _A_ 2 _U_ 12 _N_ _N_ _N_ _N_ } #-}
instance Native a => Native (Maybe a)
{-# GHC_PRAGMA _M_ Native {-dfun-} _A_ 1 _U_ 2 _N_ _N_ _N_ _N_ #-}
instance Native a => Native [a]
-{-# GHC_PRAGMA INTERFACE VERSION 5 #-}
+{-# GHC_PRAGMA INTERFACE VERSION 6 #-}
interface Native where
import PreludeArray(Array)
import PreludeStdIO(Maybe)
class Native a where
showBytes :: a -> [Char] -> [Char]
{-# GHC_PRAGMA {-meth-} _A_ 1 _U_ 122 _N_ _S_ "U(SAAA)" {_A_ 1 _U_ 122 _N_ _N_ _F_ _IF_ARGS_ 1 1 X 1 _/\_ u0 -> \ (u1 :: u0 -> [Char] -> [Char]) -> u1 _N_} _F_ _IF_ARGS_ 1 1 C 2 _/\_ u0 -> \ (u1 :: (u0 -> [Char] -> [Char], [Char] -> Maybe (u0, [Char]), [u0] -> [Char] -> [Char], Int -> [Char] -> Maybe ([u0], [Char]))) -> case u1 of { _ALG_ _TUP_4 (u2 :: u0 -> [Char] -> [Char]) (u3 :: [Char] -> Maybe (u0, [Char])) (u4 :: [u0] -> [Char] -> [Char]) (u5 :: Int -> [Char] -> Maybe ([u0], [Char])) -> u2; _NO_DEFLT_ } _N_
- {-defm-} _A_ 3 _U_ 022 _N_ _S_ _!_ _F_ _IF_ARGS_ 1 3 XXX 4 _/\_ u0 -> \ (u1 :: {{Native u0}}) (u2 :: u0) (u3 :: [Char]) -> _APP_ _TYAPP_ patError# { (u0 -> [Char] -> [Char]) } [ _NOREP_S_ "%DNative.Native.showBytes\"", u2, u3 ] _N_ #-}
+ {-defm-} _A_ 3 _U_ 022 _N_ _S_ _!_ _N_ _N_ #-}
readBytes :: [Char] -> Maybe (a, [Char])
{-# GHC_PRAGMA {-meth-} _A_ 1 _U_ 12 _N_ _S_ "U(ASAA)" {_A_ 1 _U_ 12 _N_ _N_ _F_ _IF_ARGS_ 1 1 X 1 _/\_ u0 -> \ (u1 :: [Char] -> Maybe (u0, [Char])) -> u1 _N_} _F_ _IF_ARGS_ 1 1 C 2 _/\_ u0 -> \ (u1 :: (u0 -> [Char] -> [Char], [Char] -> Maybe (u0, [Char]), [u0] -> [Char] -> [Char], Int -> [Char] -> Maybe ([u0], [Char]))) -> case u1 of { _ALG_ _TUP_4 (u2 :: u0 -> [Char] -> [Char]) (u3 :: [Char] -> Maybe (u0, [Char])) (u4 :: [u0] -> [Char] -> [Char]) (u5 :: Int -> [Char] -> Maybe ([u0], [Char])) -> u3; _NO_DEFLT_ } _N_
- {-defm-} _A_ 2 _U_ 02 _N_ _S_ _!_ _F_ _IF_ARGS_ 1 2 XX 3 _/\_ u0 -> \ (u1 :: {{Native u0}}) (u2 :: [Char]) -> _APP_ _TYAPP_ patError# { ([Char] -> Maybe (u0, [Char])) } [ _NOREP_S_ "%DNative.Native.readBytes\"", u2 ] _N_ #-}
+ {-defm-} _A_ 2 _U_ 02 _N_ _S_ _!_ _N_ _N_ #-}
listShowBytes :: [a] -> [Char] -> [Char]
{-# GHC_PRAGMA {-meth-} _A_ 1 _U_ 122 _N_ _S_ "U(AASA)" {_A_ 1 _U_ 122 _N_ _N_ _F_ _IF_ARGS_ 1 1 X 1 _/\_ u0 -> \ (u1 :: [u0] -> [Char] -> [Char]) -> u1 _N_} _F_ _IF_ARGS_ 1 1 C 2 _/\_ u0 -> \ (u1 :: (u0 -> [Char] -> [Char], [Char] -> Maybe (u0, [Char]), [u0] -> [Char] -> [Char], Int -> [Char] -> Maybe ([u0], [Char]))) -> case u1 of { _ALG_ _TUP_4 (u2 :: u0 -> [Char] -> [Char]) (u3 :: [Char] -> Maybe (u0, [Char])) (u4 :: [u0] -> [Char] -> [Char]) (u5 :: Int -> [Char] -> Maybe ([u0], [Char])) -> u4; _NO_DEFLT_ } _N_
{-defm-} _A_ 3 _U_ 112 _N_ _S_ "LSL" _N_ _N_ #-}
{-# GHC_PRAGMA _M_ Native {-dfun-} _A_ 3 _U_ 222 _N_ _N_ _N_ _N_ #-}
instance Native Bool
{-# GHC_PRAGMA _M_ Native {-dfun-} _A_ 0 _N_ _N_ _N_ _F_ _IF_ARGS_ 0 0 X 5 _!_ _TUP_4 [(Bool -> [Char] -> [Char]), ([Char] -> Maybe (Bool, [Char])), ([Bool] -> [Char] -> [Char]), (Int -> [Char] -> Maybe ([Bool], [Char]))] [_CONSTM_ Native showBytes (Bool), _CONSTM_ Native readBytes (Bool), _CONSTM_ Native listShowBytes (Bool), _CONSTM_ Native listReadBytes (Bool)] _N_
- showBytes = _A_ 2 _U_ 12 _N_ _S_ "EL" _N_ _N_,
- readBytes = _A_ 1 _U_ 1 _N_ _S_ "S" _N_ _N_,
- listShowBytes = _A_ 2 _U_ 12 _N_ _N_ _N_ _N_,
- listReadBytes = _A_ 2 _U_ 12 _N_ _N_ _N_ _N_ #-}
+ showBytes = { _A_ 2 _U_ 12 _N_ _S_ "EL" _N_ _N_ },
+ readBytes = { _A_ 1 _U_ 1 _N_ _S_ "S" _N_ _N_ },
+ listShowBytes = { _A_ 2 _U_ 12 _N_ _N_ _N_ _N_ },
+ listReadBytes = { _A_ 2 _U_ 12 _N_ _N_ _N_ _N_ } #-}
instance Native Char
{-# GHC_PRAGMA _M_ Native {-dfun-} _A_ 0 _N_ _N_ _N_ _F_ _IF_ARGS_ 0 0 X 5 _!_ _TUP_4 [(Char -> [Char] -> [Char]), ([Char] -> Maybe (Char, [Char])), ([Char] -> [Char] -> [Char]), (Int -> [Char] -> Maybe ([Char], [Char]))] [_CONSTM_ Native showBytes (Char), _CONSTM_ Native readBytes (Char), _CONSTM_ Native listShowBytes (Char), _CONSTM_ Native listReadBytes (Char)] _N_
- showBytes = _A_ 2 _U_ 22 _N_ _N_ _F_ _IF_ARGS_ 0 2 XX 3 \ (u0 :: Char) (u1 :: [Char]) -> _!_ (:) [Char] [u0, u1] _N_,
- readBytes = _A_ 1 _U_ 1 _N_ _S_ "S" _N_ _N_,
- listShowBytes = _A_ 2 _U_ 12 _N_ _N_ _N_ _N_,
- listReadBytes = _A_ 2 _U_ 12 _N_ _S_ "U(P)L" {_A_ 2 _U_ 22 _N_ _N_ _N_ _N_} _N_ _N_ #-}
+ showBytes = { _A_ 2 _U_ 22 _N_ _N_ _F_ _IF_ARGS_ 0 2 XX 3 \ (u0 :: Char) (u1 :: [Char]) -> _!_ (:) [Char] [u0, u1] _N_ },
+ readBytes = { _A_ 1 _U_ 1 _N_ _S_ "S" _N_ _N_ },
+ listShowBytes = { _A_ 2 _U_ 12 _N_ _N_ _N_ _N_ },
+ listReadBytes = { _A_ 2 _U_ 12 _N_ _S_ "U(P)L" {_A_ 2 _U_ 22 _N_ _N_ _N_ _N_} _N_ _N_ } #-}
instance Native Double
{-# GHC_PRAGMA _M_ Native {-dfun-} _A_ 0 _N_ _N_ _N_ _F_ _IF_ARGS_ 0 0 X 5 _!_ _TUP_4 [(Double -> [Char] -> [Char]), ([Char] -> Maybe (Double, [Char])), ([Double] -> [Char] -> [Char]), (Int -> [Char] -> Maybe ([Double], [Char]))] [_CONSTM_ Native showBytes (Double), _CONSTM_ Native readBytes (Double), _CONSTM_ Native listShowBytes (Double), _CONSTM_ Native listReadBytes (Double)] _N_
- showBytes = _A_ 2 _U_ 12 _N_ _S_ "U(P)L" {_A_ 2 _U_ 22 _N_ _N_ _N_ _N_} _N_ _N_,
- readBytes = _A_ 1 _U_ 2 _N_ _N_ _N_ _N_,
- listShowBytes = _A_ 2 _U_ 12 _N_ _N_ _N_ _N_,
- listReadBytes = _A_ 2 _U_ 12 _N_ _N_ _N_ _N_ #-}
+ showBytes = { _A_ 2 _U_ 12 _N_ _S_ "U(P)L" {_A_ 2 _U_ 22 _N_ _N_ _N_ _N_} _N_ _N_ },
+ readBytes = { _A_ 1 _U_ 2 _N_ _N_ _N_ _N_ },
+ listShowBytes = { _A_ 2 _U_ 12 _N_ _N_ _N_ _N_ },
+ listReadBytes = { _A_ 2 _U_ 12 _N_ _N_ _N_ _N_ } #-}
instance Native Float
{-# GHC_PRAGMA _M_ Native {-dfun-} _A_ 0 _N_ _N_ _N_ _F_ _IF_ARGS_ 0 0 X 5 _!_ _TUP_4 [(Float -> [Char] -> [Char]), ([Char] -> Maybe (Float, [Char])), ([Float] -> [Char] -> [Char]), (Int -> [Char] -> Maybe ([Float], [Char]))] [_CONSTM_ Native showBytes (Float), _CONSTM_ Native readBytes (Float), _CONSTM_ Native listShowBytes (Float), _CONSTM_ Native listReadBytes (Float)] _N_
- showBytes = _A_ 2 _U_ 12 _N_ _S_ "U(P)L" {_A_ 2 _U_ 22 _N_ _N_ _N_ _N_} _N_ _N_,
- readBytes = _A_ 1 _U_ 2 _N_ _N_ _N_ _N_,
- listShowBytes = _A_ 2 _U_ 12 _N_ _N_ _N_ _N_,
- listReadBytes = _A_ 2 _U_ 12 _N_ _N_ _N_ _N_ #-}
+ showBytes = { _A_ 2 _U_ 12 _N_ _S_ "U(P)L" {_A_ 2 _U_ 22 _N_ _N_ _N_ _N_} _N_ _N_ },
+ readBytes = { _A_ 1 _U_ 2 _N_ _N_ _N_ _N_ },
+ listShowBytes = { _A_ 2 _U_ 12 _N_ _N_ _N_ _N_ },
+ listReadBytes = { _A_ 2 _U_ 12 _N_ _N_ _N_ _N_ } #-}
instance Native Int
{-# GHC_PRAGMA _M_ Native {-dfun-} _A_ 0 _N_ _N_ _N_ _F_ _IF_ARGS_ 0 0 X 5 _!_ _TUP_4 [(Int -> [Char] -> [Char]), ([Char] -> Maybe (Int, [Char])), ([Int] -> [Char] -> [Char]), (Int -> [Char] -> Maybe ([Int], [Char]))] [_CONSTM_ Native showBytes (Int), _CONSTM_ Native readBytes (Int), _CONSTM_ Native listShowBytes (Int), _CONSTM_ Native listReadBytes (Int)] _N_
- showBytes = _A_ 2 _U_ 12 _N_ _S_ "U(P)L" {_A_ 2 _U_ 22 _N_ _N_ _N_ _N_} _N_ _N_,
- readBytes = _A_ 1 _U_ 2 _N_ _N_ _N_ _N_,
- listShowBytes = _A_ 2 _U_ 12 _N_ _N_ _N_ _N_,
- listReadBytes = _A_ 2 _U_ 12 _N_ _N_ _N_ _N_ #-}
+ showBytes = { _A_ 2 _U_ 12 _N_ _S_ "U(P)L" {_A_ 2 _U_ 22 _N_ _N_ _N_ _N_} _N_ _N_ },
+ readBytes = { _A_ 1 _U_ 2 _N_ _N_ _N_ _N_ },
+ listShowBytes = { _A_ 2 _U_ 12 _N_ _N_ _N_ _N_ },
+ listReadBytes = { _A_ 2 _U_ 12 _N_ _N_ _N_ _N_ } #-}
instance Native a => Native (Maybe a)
{-# GHC_PRAGMA _M_ Native {-dfun-} _A_ 1 _U_ 2 _N_ _N_ _N_ _N_ #-}
instance Native a => Native [a]
-{-# GHC_PRAGMA INTERFACE VERSION 5 #-}
+{-# GHC_PRAGMA INTERFACE VERSION 6 #-}
interface Native where
import PreludeArray(Array)
import PreludeStdIO(Maybe)
class Native a where
showBytes :: a -> [Char] -> [Char]
{-# GHC_PRAGMA {-meth-} _A_ 1 _U_ 122 _N_ _S_ "U(SAAA)" {_A_ 1 _U_ 122 _N_ _N_ _F_ _IF_ARGS_ 1 1 X 1 _/\_ u0 -> \ (u1 :: u0 -> [Char] -> [Char]) -> u1 _N_} _F_ _IF_ARGS_ 1 1 C 2 _/\_ u0 -> \ (u1 :: (u0 -> [Char] -> [Char], [Char] -> Maybe (u0, [Char]), [u0] -> [Char] -> [Char], Int -> [Char] -> Maybe ([u0], [Char]))) -> case u1 of { _ALG_ _TUP_4 (u2 :: u0 -> [Char] -> [Char]) (u3 :: [Char] -> Maybe (u0, [Char])) (u4 :: [u0] -> [Char] -> [Char]) (u5 :: Int -> [Char] -> Maybe ([u0], [Char])) -> u2; _NO_DEFLT_ } _N_
- {-defm-} _A_ 3 _U_ 022 _N_ _S_ _!_ _F_ _IF_ARGS_ 1 3 XXX 4 _/\_ u0 -> \ (u1 :: {{Native u0}}) (u2 :: u0) (u3 :: [Char]) -> _APP_ _TYAPP_ patError# { (u0 -> [Char] -> [Char]) } [ _NOREP_S_ "%DNative.Native.showBytes\"", u2, u3 ] _N_ #-}
+ {-defm-} _A_ 3 _U_ 022 _N_ _S_ _!_ _N_ _N_ #-}
readBytes :: [Char] -> Maybe (a, [Char])
{-# GHC_PRAGMA {-meth-} _A_ 1 _U_ 12 _N_ _S_ "U(ASAA)" {_A_ 1 _U_ 12 _N_ _N_ _F_ _IF_ARGS_ 1 1 X 1 _/\_ u0 -> \ (u1 :: [Char] -> Maybe (u0, [Char])) -> u1 _N_} _F_ _IF_ARGS_ 1 1 C 2 _/\_ u0 -> \ (u1 :: (u0 -> [Char] -> [Char], [Char] -> Maybe (u0, [Char]), [u0] -> [Char] -> [Char], Int -> [Char] -> Maybe ([u0], [Char]))) -> case u1 of { _ALG_ _TUP_4 (u2 :: u0 -> [Char] -> [Char]) (u3 :: [Char] -> Maybe (u0, [Char])) (u4 :: [u0] -> [Char] -> [Char]) (u5 :: Int -> [Char] -> Maybe ([u0], [Char])) -> u3; _NO_DEFLT_ } _N_
- {-defm-} _A_ 2 _U_ 02 _N_ _S_ _!_ _F_ _IF_ARGS_ 1 2 XX 3 _/\_ u0 -> \ (u1 :: {{Native u0}}) (u2 :: [Char]) -> _APP_ _TYAPP_ patError# { ([Char] -> Maybe (u0, [Char])) } [ _NOREP_S_ "%DNative.Native.readBytes\"", u2 ] _N_ #-}
+ {-defm-} _A_ 2 _U_ 02 _N_ _S_ _!_ _N_ _N_ #-}
listShowBytes :: [a] -> [Char] -> [Char]
{-# GHC_PRAGMA {-meth-} _A_ 1 _U_ 122 _N_ _S_ "U(AASA)" {_A_ 1 _U_ 122 _N_ _N_ _F_ _IF_ARGS_ 1 1 X 1 _/\_ u0 -> \ (u1 :: [u0] -> [Char] -> [Char]) -> u1 _N_} _F_ _IF_ARGS_ 1 1 C 2 _/\_ u0 -> \ (u1 :: (u0 -> [Char] -> [Char], [Char] -> Maybe (u0, [Char]), [u0] -> [Char] -> [Char], Int -> [Char] -> Maybe ([u0], [Char]))) -> case u1 of { _ALG_ _TUP_4 (u2 :: u0 -> [Char] -> [Char]) (u3 :: [Char] -> Maybe (u0, [Char])) (u4 :: [u0] -> [Char] -> [Char]) (u5 :: Int -> [Char] -> Maybe ([u0], [Char])) -> u4; _NO_DEFLT_ } _N_
{-defm-} _A_ 3 _U_ 112 _N_ _S_ "LSL" _N_ _N_ #-}
{-# GHC_PRAGMA _M_ Native {-dfun-} _A_ 3 _U_ 222 _N_ _N_ _N_ _N_ #-}
instance Native Bool
{-# GHC_PRAGMA _M_ Native {-dfun-} _A_ 0 _N_ _N_ _N_ _F_ _IF_ARGS_ 0 0 X 5 _!_ _TUP_4 [(Bool -> [Char] -> [Char]), ([Char] -> Maybe (Bool, [Char])), ([Bool] -> [Char] -> [Char]), (Int -> [Char] -> Maybe ([Bool], [Char]))] [_CONSTM_ Native showBytes (Bool), _CONSTM_ Native readBytes (Bool), _CONSTM_ Native listShowBytes (Bool), _CONSTM_ Native listReadBytes (Bool)] _N_
- showBytes = _A_ 2 _U_ 12 _N_ _S_ "EL" _N_ _N_,
- readBytes = _A_ 1 _U_ 1 _N_ _S_ "S" _N_ _N_,
- listShowBytes = _A_ 2 _U_ 12 _N_ _N_ _N_ _N_,
- listReadBytes = _A_ 2 _U_ 12 _N_ _N_ _N_ _N_ #-}
+ showBytes = { _A_ 2 _U_ 12 _N_ _S_ "EL" _N_ _N_ },
+ readBytes = { _A_ 1 _U_ 1 _N_ _S_ "S" _N_ _N_ },
+ listShowBytes = { _A_ 2 _U_ 12 _N_ _N_ _N_ _N_ },
+ listReadBytes = { _A_ 2 _U_ 12 _N_ _N_ _N_ _N_ } #-}
instance Native Char
{-# GHC_PRAGMA _M_ Native {-dfun-} _A_ 0 _N_ _N_ _N_ _F_ _IF_ARGS_ 0 0 X 5 _!_ _TUP_4 [(Char -> [Char] -> [Char]), ([Char] -> Maybe (Char, [Char])), ([Char] -> [Char] -> [Char]), (Int -> [Char] -> Maybe ([Char], [Char]))] [_CONSTM_ Native showBytes (Char), _CONSTM_ Native readBytes (Char), _CONSTM_ Native listShowBytes (Char), _CONSTM_ Native listReadBytes (Char)] _N_
- showBytes = _A_ 2 _U_ 22 _N_ _N_ _F_ _IF_ARGS_ 0 2 XX 3 \ (u0 :: Char) (u1 :: [Char]) -> _!_ (:) [Char] [u0, u1] _N_,
- readBytes = _A_ 1 _U_ 1 _N_ _S_ "S" _N_ _N_,
- listShowBytes = _A_ 2 _U_ 12 _N_ _N_ _N_ _N_,
- listReadBytes = _A_ 2 _U_ 12 _N_ _S_ "U(P)L" {_A_ 2 _U_ 22 _N_ _N_ _N_ _N_} _N_ _N_ #-}
+ showBytes = { _A_ 2 _U_ 22 _N_ _N_ _F_ _IF_ARGS_ 0 2 XX 3 \ (u0 :: Char) (u1 :: [Char]) -> _!_ (:) [Char] [u0, u1] _N_ },
+ readBytes = { _A_ 1 _U_ 1 _N_ _S_ "S" _N_ _N_ },
+ listShowBytes = { _A_ 2 _U_ 12 _N_ _N_ _N_ _N_ },
+ listReadBytes = { _A_ 2 _U_ 12 _N_ _S_ "U(P)L" {_A_ 2 _U_ 22 _N_ _N_ _N_ _N_} _N_ _N_ } #-}
instance Native Double
{-# GHC_PRAGMA _M_ Native {-dfun-} _A_ 0 _N_ _N_ _N_ _F_ _IF_ARGS_ 0 0 X 5 _!_ _TUP_4 [(Double -> [Char] -> [Char]), ([Char] -> Maybe (Double, [Char])), ([Double] -> [Char] -> [Char]), (Int -> [Char] -> Maybe ([Double], [Char]))] [_CONSTM_ Native showBytes (Double), _CONSTM_ Native readBytes (Double), _CONSTM_ Native listShowBytes (Double), _CONSTM_ Native listReadBytes (Double)] _N_
- showBytes = _A_ 2 _U_ 12 _N_ _S_ "U(P)L" {_A_ 2 _U_ 22 _N_ _N_ _N_ _N_} _N_ _N_,
- readBytes = _A_ 1 _U_ 2 _N_ _N_ _N_ _N_,
- listShowBytes = _A_ 2 _U_ 12 _N_ _N_ _N_ _N_,
- listReadBytes = _A_ 2 _U_ 12 _N_ _N_ _N_ _N_ #-}
+ showBytes = { _A_ 2 _U_ 12 _N_ _S_ "U(P)L" {_A_ 2 _U_ 22 _N_ _N_ _N_ _N_} _N_ _N_ },
+ readBytes = { _A_ 1 _U_ 2 _N_ _N_ _N_ _N_ },
+ listShowBytes = { _A_ 2 _U_ 12 _N_ _N_ _N_ _N_ },
+ listReadBytes = { _A_ 2 _U_ 12 _N_ _N_ _N_ _N_ } #-}
instance Native Float
{-# GHC_PRAGMA _M_ Native {-dfun-} _A_ 0 _N_ _N_ _N_ _F_ _IF_ARGS_ 0 0 X 5 _!_ _TUP_4 [(Float -> [Char] -> [Char]), ([Char] -> Maybe (Float, [Char])), ([Float] -> [Char] -> [Char]), (Int -> [Char] -> Maybe ([Float], [Char]))] [_CONSTM_ Native showBytes (Float), _CONSTM_ Native readBytes (Float), _CONSTM_ Native listShowBytes (Float), _CONSTM_ Native listReadBytes (Float)] _N_
- showBytes = _A_ 2 _U_ 12 _N_ _S_ "U(P)L" {_A_ 2 _U_ 22 _N_ _N_ _N_ _N_} _N_ _N_,
- readBytes = _A_ 1 _U_ 2 _N_ _N_ _N_ _N_,
- listShowBytes = _A_ 2 _U_ 12 _N_ _N_ _N_ _N_,
- listReadBytes = _A_ 2 _U_ 12 _N_ _N_ _N_ _N_ #-}
+ showBytes = { _A_ 2 _U_ 12 _N_ _S_ "U(P)L" {_A_ 2 _U_ 22 _N_ _N_ _N_ _N_} _N_ _N_ },
+ readBytes = { _A_ 1 _U_ 2 _N_ _N_ _N_ _N_ },
+ listShowBytes = { _A_ 2 _U_ 12 _N_ _N_ _N_ _N_ },
+ listReadBytes = { _A_ 2 _U_ 12 _N_ _N_ _N_ _N_ } #-}
instance Native Int
{-# GHC_PRAGMA _M_ Native {-dfun-} _A_ 0 _N_ _N_ _N_ _F_ _IF_ARGS_ 0 0 X 5 _!_ _TUP_4 [(Int -> [Char] -> [Char]), ([Char] -> Maybe (Int, [Char])), ([Int] -> [Char] -> [Char]), (Int -> [Char] -> Maybe ([Int], [Char]))] [_CONSTM_ Native showBytes (Int), _CONSTM_ Native readBytes (Int), _CONSTM_ Native listShowBytes (Int), _CONSTM_ Native listReadBytes (Int)] _N_
- showBytes = _A_ 2 _U_ 12 _N_ _S_ "U(P)L" {_A_ 2 _U_ 22 _N_ _N_ _N_ _N_} _N_ _N_,
- readBytes = _A_ 1 _U_ 2 _N_ _N_ _N_ _N_,
- listShowBytes = _A_ 2 _U_ 12 _N_ _N_ _N_ _N_,
- listReadBytes = _A_ 2 _U_ 12 _N_ _N_ _N_ _N_ #-}
+ showBytes = { _A_ 2 _U_ 12 _N_ _S_ "U(P)L" {_A_ 2 _U_ 22 _N_ _N_ _N_ _N_} _N_ _N_ },
+ readBytes = { _A_ 1 _U_ 2 _N_ _N_ _N_ _N_ },
+ listShowBytes = { _A_ 2 _U_ 12 _N_ _N_ _N_ _N_ },
+ listReadBytes = { _A_ 2 _U_ 12 _N_ _N_ _N_ _N_ } #-}
instance Native a => Native (Maybe a)
{-# GHC_PRAGMA _M_ Native {-dfun-} _A_ 1 _U_ 2 _N_ _N_ _N_ _N_ #-}
instance Native a => Native [a]
-{-# GHC_PRAGMA INTERFACE VERSION 5 #-}
+{-# GHC_PRAGMA INTERFACE VERSION 6 #-}
interface Native where
import PreludeArray(Array)
import PreludeStdIO(Maybe)
class Native a where
showBytes :: a -> [Char] -> [Char]
{-# GHC_PRAGMA {-meth-} _A_ 1 _U_ 122 _N_ _S_ "U(SAAA)" {_A_ 1 _U_ 122 _N_ _N_ _F_ _IF_ARGS_ 1 1 X 1 _/\_ u0 -> \ (u1 :: u0 -> [Char] -> [Char]) -> u1 _N_} _F_ _IF_ARGS_ 1 1 C 2 _/\_ u0 -> \ (u1 :: (u0 -> [Char] -> [Char], [Char] -> Maybe (u0, [Char]), [u0] -> [Char] -> [Char], Int -> [Char] -> Maybe ([u0], [Char]))) -> case u1 of { _ALG_ _TUP_4 (u2 :: u0 -> [Char] -> [Char]) (u3 :: [Char] -> Maybe (u0, [Char])) (u4 :: [u0] -> [Char] -> [Char]) (u5 :: Int -> [Char] -> Maybe ([u0], [Char])) -> u2; _NO_DEFLT_ } _N_
- {-defm-} _A_ 3 _U_ 022 _N_ _S_ _!_ _F_ _IF_ARGS_ 1 3 XXX 4 _/\_ u0 -> \ (u1 :: {{Native u0}}) (u2 :: u0) (u3 :: [Char]) -> _APP_ _TYAPP_ patError# { (u0 -> [Char] -> [Char]) } [ _NOREP_S_ "%DNative.Native.showBytes\"", u2, u3 ] _N_ #-}
+ {-defm-} _A_ 3 _U_ 022 _N_ _S_ _!_ _N_ _N_ #-}
readBytes :: [Char] -> Maybe (a, [Char])
{-# GHC_PRAGMA {-meth-} _A_ 1 _U_ 12 _N_ _S_ "U(ASAA)" {_A_ 1 _U_ 12 _N_ _N_ _F_ _IF_ARGS_ 1 1 X 1 _/\_ u0 -> \ (u1 :: [Char] -> Maybe (u0, [Char])) -> u1 _N_} _F_ _IF_ARGS_ 1 1 C 2 _/\_ u0 -> \ (u1 :: (u0 -> [Char] -> [Char], [Char] -> Maybe (u0, [Char]), [u0] -> [Char] -> [Char], Int -> [Char] -> Maybe ([u0], [Char]))) -> case u1 of { _ALG_ _TUP_4 (u2 :: u0 -> [Char] -> [Char]) (u3 :: [Char] -> Maybe (u0, [Char])) (u4 :: [u0] -> [Char] -> [Char]) (u5 :: Int -> [Char] -> Maybe ([u0], [Char])) -> u3; _NO_DEFLT_ } _N_
- {-defm-} _A_ 2 _U_ 02 _N_ _S_ _!_ _F_ _IF_ARGS_ 1 2 XX 3 _/\_ u0 -> \ (u1 :: {{Native u0}}) (u2 :: [Char]) -> _APP_ _TYAPP_ patError# { ([Char] -> Maybe (u0, [Char])) } [ _NOREP_S_ "%DNative.Native.readBytes\"", u2 ] _N_ #-}
+ {-defm-} _A_ 2 _U_ 02 _N_ _S_ _!_ _N_ _N_ #-}
listShowBytes :: [a] -> [Char] -> [Char]
{-# GHC_PRAGMA {-meth-} _A_ 1 _U_ 122 _N_ _S_ "U(AASA)" {_A_ 1 _U_ 122 _N_ _N_ _F_ _IF_ARGS_ 1 1 X 1 _/\_ u0 -> \ (u1 :: [u0] -> [Char] -> [Char]) -> u1 _N_} _F_ _IF_ARGS_ 1 1 C 2 _/\_ u0 -> \ (u1 :: (u0 -> [Char] -> [Char], [Char] -> Maybe (u0, [Char]), [u0] -> [Char] -> [Char], Int -> [Char] -> Maybe ([u0], [Char]))) -> case u1 of { _ALG_ _TUP_4 (u2 :: u0 -> [Char] -> [Char]) (u3 :: [Char] -> Maybe (u0, [Char])) (u4 :: [u0] -> [Char] -> [Char]) (u5 :: Int -> [Char] -> Maybe ([u0], [Char])) -> u4; _NO_DEFLT_ } _N_
{-defm-} _A_ 3 _U_ 112 _N_ _S_ "LSL" _N_ _N_ #-}
{-# GHC_PRAGMA _M_ Native {-dfun-} _A_ 3 _U_ 222 _N_ _N_ _N_ _N_ #-}
instance Native Bool
{-# GHC_PRAGMA _M_ Native {-dfun-} _A_ 0 _N_ _N_ _N_ _F_ _IF_ARGS_ 0 0 X 5 _!_ _TUP_4 [(Bool -> [Char] -> [Char]), ([Char] -> Maybe (Bool, [Char])), ([Bool] -> [Char] -> [Char]), (Int -> [Char] -> Maybe ([Bool], [Char]))] [_CONSTM_ Native showBytes (Bool), _CONSTM_ Native readBytes (Bool), _CONSTM_ Native listShowBytes (Bool), _CONSTM_ Native listReadBytes (Bool)] _N_
- showBytes = _A_ 2 _U_ 12 _N_ _S_ "EL" _N_ _N_,
- readBytes = _A_ 1 _U_ 1 _N_ _S_ "S" _N_ _N_,
- listShowBytes = _A_ 2 _U_ 12 _N_ _N_ _N_ _N_,
- listReadBytes = _A_ 2 _U_ 12 _N_ _N_ _N_ _N_ #-}
+ showBytes = { _A_ 2 _U_ 12 _N_ _S_ "EL" _N_ _N_ },
+ readBytes = { _A_ 1 _U_ 1 _N_ _S_ "S" _N_ _N_ },
+ listShowBytes = { _A_ 2 _U_ 12 _N_ _N_ _N_ _N_ },
+ listReadBytes = { _A_ 2 _U_ 12 _N_ _N_ _N_ _N_ } #-}
instance Native Char
{-# GHC_PRAGMA _M_ Native {-dfun-} _A_ 0 _N_ _N_ _N_ _F_ _IF_ARGS_ 0 0 X 5 _!_ _TUP_4 [(Char -> [Char] -> [Char]), ([Char] -> Maybe (Char, [Char])), ([Char] -> [Char] -> [Char]), (Int -> [Char] -> Maybe ([Char], [Char]))] [_CONSTM_ Native showBytes (Char), _CONSTM_ Native readBytes (Char), _CONSTM_ Native listShowBytes (Char), _CONSTM_ Native listReadBytes (Char)] _N_
- showBytes = _A_ 2 _U_ 22 _N_ _N_ _F_ _IF_ARGS_ 0 2 XX 3 \ (u0 :: Char) (u1 :: [Char]) -> _!_ (:) [Char] [u0, u1] _N_,
- readBytes = _A_ 1 _U_ 1 _N_ _S_ "S" _N_ _N_,
- listShowBytes = _A_ 2 _U_ 12 _N_ _N_ _N_ _N_,
- listReadBytes = _A_ 2 _U_ 12 _N_ _S_ "U(P)L" {_A_ 2 _U_ 22 _N_ _N_ _N_ _N_} _N_ _N_ #-}
+ showBytes = { _A_ 2 _U_ 22 _N_ _N_ _F_ _IF_ARGS_ 0 2 XX 3 \ (u0 :: Char) (u1 :: [Char]) -> _!_ (:) [Char] [u0, u1] _N_ },
+ readBytes = { _A_ 1 _U_ 1 _N_ _S_ "S" _N_ _N_ },
+ listShowBytes = { _A_ 2 _U_ 12 _N_ _N_ _N_ _N_ },
+ listReadBytes = { _A_ 2 _U_ 12 _N_ _S_ "U(P)L" {_A_ 2 _U_ 22 _N_ _N_ _N_ _N_} _N_ _N_ } #-}
instance Native Double
{-# GHC_PRAGMA _M_ Native {-dfun-} _A_ 0 _N_ _N_ _N_ _F_ _IF_ARGS_ 0 0 X 5 _!_ _TUP_4 [(Double -> [Char] -> [Char]), ([Char] -> Maybe (Double, [Char])), ([Double] -> [Char] -> [Char]), (Int -> [Char] -> Maybe ([Double], [Char]))] [_CONSTM_ Native showBytes (Double), _CONSTM_ Native readBytes (Double), _CONSTM_ Native listShowBytes (Double), _CONSTM_ Native listReadBytes (Double)] _N_
- showBytes = _A_ 2 _U_ 12 _N_ _S_ "U(P)L" {_A_ 2 _U_ 22 _N_ _N_ _N_ _N_} _N_ _N_,
- readBytes = _A_ 1 _U_ 2 _N_ _N_ _N_ _N_,
- listShowBytes = _A_ 2 _U_ 12 _N_ _N_ _N_ _N_,
- listReadBytes = _A_ 2 _U_ 12 _N_ _N_ _N_ _N_ #-}
+ showBytes = { _A_ 2 _U_ 12 _N_ _S_ "U(P)L" {_A_ 2 _U_ 22 _N_ _N_ _N_ _N_} _N_ _N_ },
+ readBytes = { _A_ 1 _U_ 2 _N_ _N_ _N_ _N_ },
+ listShowBytes = { _A_ 2 _U_ 12 _N_ _N_ _N_ _N_ },
+ listReadBytes = { _A_ 2 _U_ 12 _N_ _N_ _N_ _N_ } #-}
instance Native Float
{-# GHC_PRAGMA _M_ Native {-dfun-} _A_ 0 _N_ _N_ _N_ _F_ _IF_ARGS_ 0 0 X 5 _!_ _TUP_4 [(Float -> [Char] -> [Char]), ([Char] -> Maybe (Float, [Char])), ([Float] -> [Char] -> [Char]), (Int -> [Char] -> Maybe ([Float], [Char]))] [_CONSTM_ Native showBytes (Float), _CONSTM_ Native readBytes (Float), _CONSTM_ Native listShowBytes (Float), _CONSTM_ Native listReadBytes (Float)] _N_
- showBytes = _A_ 2 _U_ 12 _N_ _S_ "U(P)L" {_A_ 2 _U_ 22 _N_ _N_ _N_ _N_} _N_ _N_,
- readBytes = _A_ 1 _U_ 2 _N_ _N_ _N_ _N_,
- listShowBytes = _A_ 2 _U_ 12 _N_ _N_ _N_ _N_,
- listReadBytes = _A_ 2 _U_ 12 _N_ _N_ _N_ _N_ #-}
+ showBytes = { _A_ 2 _U_ 12 _N_ _S_ "U(P)L" {_A_ 2 _U_ 22 _N_ _N_ _N_ _N_} _N_ _N_ },
+ readBytes = { _A_ 1 _U_ 2 _N_ _N_ _N_ _N_ },
+ listShowBytes = { _A_ 2 _U_ 12 _N_ _N_ _N_ _N_ },
+ listReadBytes = { _A_ 2 _U_ 12 _N_ _N_ _N_ _N_ } #-}
instance Native Int
{-# GHC_PRAGMA _M_ Native {-dfun-} _A_ 0 _N_ _N_ _N_ _F_ _IF_ARGS_ 0 0 X 5 _!_ _TUP_4 [(Int -> [Char] -> [Char]), ([Char] -> Maybe (Int, [Char])), ([Int] -> [Char] -> [Char]), (Int -> [Char] -> Maybe ([Int], [Char]))] [_CONSTM_ Native showBytes (Int), _CONSTM_ Native readBytes (Int), _CONSTM_ Native listShowBytes (Int), _CONSTM_ Native listReadBytes (Int)] _N_
- showBytes = _A_ 2 _U_ 12 _N_ _S_ "U(P)L" {_A_ 2 _U_ 22 _N_ _N_ _N_ _N_} _N_ _N_,
- readBytes = _A_ 1 _U_ 2 _N_ _N_ _N_ _N_,
- listShowBytes = _A_ 2 _U_ 12 _N_ _N_ _N_ _N_,
- listReadBytes = _A_ 2 _U_ 12 _N_ _N_ _N_ _N_ #-}
+ showBytes = { _A_ 2 _U_ 12 _N_ _S_ "U(P)L" {_A_ 2 _U_ 22 _N_ _N_ _N_ _N_} _N_ _N_ },
+ readBytes = { _A_ 1 _U_ 2 _N_ _N_ _N_ _N_ },
+ listShowBytes = { _A_ 2 _U_ 12 _N_ _N_ _N_ _N_ },
+ listReadBytes = { _A_ 2 _U_ 12 _N_ _N_ _N_ _N_ } #-}
instance Native a => Native (Maybe a)
{-# GHC_PRAGMA _M_ Native {-dfun-} _A_ 1 _U_ 2 _N_ _N_ _N_ _N_ #-}
instance Native a => Native [a]
-{-# GHC_PRAGMA INTERFACE VERSION 5 #-}
+{-# GHC_PRAGMA INTERFACE VERSION 6 #-}
interface Printf where
data UPrintf = UChar Char | UString [Char] | UInt Int | UInteger Integer | UFloat Float | UDouble Double
printf :: [Char] -> [UPrintf] -> [Char]
-{-# GHC_PRAGMA INTERFACE VERSION 5 #-}
+{-# GHC_PRAGMA INTERFACE VERSION 6 #-}
interface Printf where
data UPrintf = UChar Char | UString [Char] | UInt Int | UInteger Integer | UFloat Float | UDouble Double
printf :: [Char] -> [UPrintf] -> [Char]
-{-# GHC_PRAGMA INTERFACE VERSION 5 #-}
+{-# GHC_PRAGMA INTERFACE VERSION 6 #-}
interface Printf where
data UPrintf = UChar Char | UString [Char] | UInt Int | UInteger Integer | UFloat Float | UDouble Double
printf :: [Char] -> [UPrintf] -> [Char]
-{-# GHC_PRAGMA INTERFACE VERSION 5 #-}
+{-# GHC_PRAGMA INTERFACE VERSION 6 #-}
interface Printf where
data UPrintf = UChar Char | UString [Char] | UInt Int | UInteger Integer | UFloat Float | UDouble Double
printf :: [Char] -> [UPrintf] -> [Char]
-{-# GHC_PRAGMA INTERFACE VERSION 5 #-}
+{-# GHC_PRAGMA INTERFACE VERSION 6 #-}
interface Printf where
data UPrintf = UChar Char | UString [Char] | UInt Int | UInteger Integer | UFloat Float | UDouble Double
printf :: [Char] -> [UPrintf] -> [Char]
-{-# GHC_PRAGMA INTERFACE VERSION 5 #-}
+{-# GHC_PRAGMA INTERFACE VERSION 6 #-}
interface PreludeBuiltin where
_runST :: (_State _RealWorld -> (b, a)) -> b
{-# GHC_PRAGMA _A_ 1 _U_ 1 _N_ _S_ "S" _N_ _N_ #-}
_trace :: [Char] -> a -> a
{-# GHC_PRAGMA _A_ 2 _U_ 22 _N_ _S_ "SL" _N_ _N_ #-}
absent# :: a
- {-# GHC_PRAGMA _A_ 0 _N_ _N_ _S_ _!_ _F_ _IF_ARGS_ 1 0 X 2 _/\_ u0 -> _APP_ _TYAPP_ _ORIG_ PreludeBuiltin error { u0 } [ _NOREP_S_ "Oops! The program has entered an `absent' argument!\n" ] _N_ #-}
+ {-# GHC_PRAGMA _A_ 0 _N_ _N_ _S_ _!_ _N_ _N_ #-}
error :: [Char] -> a
{-# GHC_PRAGMA _A_ 1 _U_ 2 _N_ _S_ _!_ _N_ _N_ #-}
parError# :: a
- {-# GHC_PRAGMA _A_ 0 _N_ _N_ _S_ _!_ _F_ _IF_ARGS_ 1 0 X 2 _/\_ u0 -> _APP_ _TYAPP_ _ORIG_ PreludeBuiltin error { u0 } [ _NOREP_S_ "Oops! Entered parError# (a GHC bug -- please report it!)\n" ] _N_ #-}
+ {-# GHC_PRAGMA _A_ 0 _N_ _N_ _S_ _!_ _N_ _N_ #-}
patError# :: [Char] -> a
{-# GHC_PRAGMA _A_ 1 _U_ 1 _N_ _S_ _!_ _N_ _N_ #-}
import PS ( _PackedString, _unpackPS )
import Stdio ( _FILE )
import Text
+import TyComplex
---------------------------------------------------------------
{- OLD:
= case next of
'%' -> "%"
'D' -> "No default method for \""
+ 'E' -> "No explicit method for \""
'N' -> ": non-exhaustive guards"
'F' -> "incomplete pattern(s) to match in function \""
'L' -> "pattern-matching failed in lambda"
---------------------------------------------------------------
-- ******** defn of `_trace' using Glasgow IO *******
---{-# GENERATE_SPECS _trace a #-}
+{-# GENERATE_SPECS _trace a #-}
_trace :: String -> a -> a
_trace string expr
= unsafePerformPrimIO (
((_ccall_ PreTraceHook sTDERR{-msg-})::PrimIO ()) `seqPrimIO`
- appendChan# sTDERR string `seqPrimIO`
+ appendChan# sTDERR string `seqPrimIO`
((_ccall_ PostTraceHook sTDERR{-msg-})::PrimIO ()) `seqPrimIO`
returnPrimIO expr )
where
-{-# GHC_PRAGMA INTERFACE VERSION 5 #-}
+{-# GHC_PRAGMA INTERFACE VERSION 6 #-}
interface PreludeBuiltin where
_runST :: (_State _RealWorld -> (b, a)) -> b
{-# GHC_PRAGMA _A_ 1 _U_ 1 _N_ _S_ "S" _N_ _N_ #-}
_trace :: [Char] -> a -> a
{-# GHC_PRAGMA _A_ 2 _U_ 22 _N_ _S_ "SL" _N_ _N_ #-}
absent# :: a
- {-# GHC_PRAGMA _A_ 0 _N_ _N_ _S_ _!_ _F_ _IF_ARGS_ 1 0 X 2 _/\_ u0 -> _APP_ _TYAPP_ _ORIG_ PreludeBuiltin error { u0 } [ _NOREP_S_ "Oops! The program has entered an `absent' argument!\n" ] _N_ #-}
+ {-# GHC_PRAGMA _A_ 0 _N_ _N_ _S_ _!_ _N_ _N_ #-}
error :: [Char] -> a
{-# GHC_PRAGMA _A_ 1 _U_ 2 _N_ _S_ _!_ _N_ _N_ #-}
parError# :: a
- {-# GHC_PRAGMA _A_ 0 _N_ _N_ _S_ _!_ _F_ _IF_ARGS_ 1 0 X 2 _/\_ u0 -> _APP_ _TYAPP_ _ORIG_ PreludeBuiltin error { u0 } [ _NOREP_S_ "Oops! Entered parError# (a GHC bug -- please report it!)\n" ] _N_ #-}
+ {-# GHC_PRAGMA _A_ 0 _N_ _N_ _S_ _!_ _N_ _N_ #-}
patError# :: [Char] -> a
{-# GHC_PRAGMA _A_ 1 _U_ 1 _N_ _S_ _!_ _N_ _N_ #-}
-{-# GHC_PRAGMA INTERFACE VERSION 5 #-}
+{-# GHC_PRAGMA INTERFACE VERSION 6 #-}
interface PreludeBuiltin where
_runST :: (_State _RealWorld -> (b, a)) -> b
{-# GHC_PRAGMA _A_ 1 _U_ 1 _N_ _S_ "S" _N_ _N_ #-}
_trace :: [Char] -> a -> a
{-# GHC_PRAGMA _A_ 2 _U_ 22 _N_ _S_ "SL" _N_ _N_ #-}
absent# :: a
- {-# GHC_PRAGMA _A_ 0 _N_ _N_ _S_ _!_ _F_ _IF_ARGS_ 1 0 X 2 _/\_ u0 -> _APP_ _TYAPP_ _ORIG_ PreludeBuiltin error { u0 } [ _NOREP_S_ "Oops! The program has entered an `absent' argument!\n" ] _N_ #-}
+ {-# GHC_PRAGMA _A_ 0 _N_ _N_ _S_ _!_ _N_ _N_ #-}
error :: [Char] -> a
{-# GHC_PRAGMA _A_ 1 _U_ 2 _N_ _S_ _!_ _N_ _N_ #-}
parError# :: a
- {-# GHC_PRAGMA _A_ 0 _N_ _N_ _S_ _!_ _F_ _IF_ARGS_ 1 0 X 2 _/\_ u0 -> _APP_ _TYAPP_ _ORIG_ PreludeBuiltin error { u0 } [ _NOREP_S_ "Oops! Entered parError# (a GHC bug -- please report it!)\n" ] _N_ #-}
+ {-# GHC_PRAGMA _A_ 0 _N_ _N_ _S_ _!_ _N_ _N_ #-}
patError# :: [Char] -> a
{-# GHC_PRAGMA _A_ 1 _U_ 1 _N_ _S_ _!_ _N_ _N_ #-}
-{-# GHC_PRAGMA INTERFACE VERSION 5 #-}
+{-# GHC_PRAGMA INTERFACE VERSION 6 #-}
interface PreludeBuiltin where
_runST :: (_State _RealWorld -> (b, a)) -> b
{-# GHC_PRAGMA _A_ 1 _U_ 1 _N_ _S_ "S" _N_ _N_ #-}
_trace :: [Char] -> a -> a
{-# GHC_PRAGMA _A_ 2 _U_ 22 _N_ _S_ "SL" _N_ _N_ #-}
absent# :: a
- {-# GHC_PRAGMA _A_ 0 _N_ _N_ _S_ _!_ _F_ _IF_ARGS_ 1 0 X 2 _/\_ u0 -> _APP_ _TYAPP_ _ORIG_ PreludeBuiltin error { u0 } [ _NOREP_S_ "Oops! The program has entered an `absent' argument!\n" ] _N_ #-}
+ {-# GHC_PRAGMA _A_ 0 _N_ _N_ _S_ _!_ _N_ _N_ #-}
error :: [Char] -> a
{-# GHC_PRAGMA _A_ 1 _U_ 2 _N_ _S_ _!_ _N_ _N_ #-}
parError# :: a
- {-# GHC_PRAGMA _A_ 0 _N_ _N_ _S_ _!_ _F_ _IF_ARGS_ 1 0 X 2 _/\_ u0 -> _APP_ _TYAPP_ _ORIG_ PreludeBuiltin error { u0 } [ _NOREP_S_ "Oops! Entered parError# (a GHC bug -- please report it!)\n" ] _N_ #-}
+ {-# GHC_PRAGMA _A_ 0 _N_ _N_ _S_ _!_ _N_ _N_ #-}
patError# :: [Char] -> a
{-# GHC_PRAGMA _A_ 1 _U_ 1 _N_ _S_ _!_ _N_ _N_ #-}
-{-# GHC_PRAGMA INTERFACE VERSION 5 #-}
+{-# GHC_PRAGMA INTERFACE VERSION 6 #-}
interface PreludeBuiltin where
_runST :: (_State _RealWorld -> (b, a)) -> b
{-# GHC_PRAGMA _A_ 1 _U_ 1 _N_ _S_ "S" _N_ _N_ #-}
_trace :: [Char] -> a -> a
{-# GHC_PRAGMA _A_ 2 _U_ 22 _N_ _S_ "SL" _N_ _N_ #-}
absent# :: a
- {-# GHC_PRAGMA _A_ 0 _N_ _N_ _S_ _!_ _F_ _IF_ARGS_ 1 0 X 2 _/\_ u0 -> _APP_ _TYAPP_ _ORIG_ PreludeBuiltin error { u0 } [ _NOREP_S_ "Oops! The program has entered an `absent' argument!\n" ] _N_ #-}
+ {-# GHC_PRAGMA _A_ 0 _N_ _N_ _S_ _!_ _N_ _N_ #-}
error :: [Char] -> a
{-# GHC_PRAGMA _A_ 1 _U_ 2 _N_ _S_ _!_ _N_ _N_ #-}
parError# :: a
- {-# GHC_PRAGMA _A_ 0 _N_ _N_ _S_ _!_ _F_ _IF_ARGS_ 1 0 X 2 _/\_ u0 -> _APP_ _TYAPP_ _ORIG_ PreludeBuiltin error { u0 } [ _NOREP_S_ "Oops! Entered parError# (a GHC bug -- please report it!)\n" ] _N_ #-}
+ {-# GHC_PRAGMA _A_ 0 _N_ _N_ _S_ _!_ _N_ _N_ #-}
patError# :: [Char] -> a
{-# GHC_PRAGMA _A_ 1 _U_ 1 _N_ _S_ _!_ _N_ _N_ #-}
-{-# GHC_PRAGMA INTERFACE VERSION 5 #-}
+{-# GHC_PRAGMA INTERFACE VERSION 6 #-}
interface Channel where
import PreludeIOError(IOError13)
import PreludeMonadicIO(Either)
-{-# GHC_PRAGMA INTERFACE VERSION 5 #-}
+{-# GHC_PRAGMA INTERFACE VERSION 6 #-}
interface ChannelVar where
import PreludeIOError(IOError13)
import PreludeMonadicIO(Either)
-{-# GHC_PRAGMA INTERFACE VERSION 5 #-}
+{-# GHC_PRAGMA INTERFACE VERSION 6 #-}
interface ChannelVar where
import PreludeIOError(IOError13)
import PreludeMonadicIO(Either)
-{-# GHC_PRAGMA INTERFACE VERSION 5 #-}
+{-# GHC_PRAGMA INTERFACE VERSION 6 #-}
interface ChannelVar where
import PreludeIOError(IOError13)
import PreludeMonadicIO(Either)
-{-# GHC_PRAGMA INTERFACE VERSION 5 #-}
+{-# GHC_PRAGMA INTERFACE VERSION 6 #-}
interface ChannelVar where
import PreludeIOError(IOError13)
import PreludeMonadicIO(Either)
-{-# GHC_PRAGMA INTERFACE VERSION 5 #-}
+{-# GHC_PRAGMA INTERFACE VERSION 6 #-}
interface ChannelVar where
import PreludeIOError(IOError13)
import PreludeMonadicIO(Either)
-{-# GHC_PRAGMA INTERFACE VERSION 5 #-}
+{-# GHC_PRAGMA INTERFACE VERSION 6 #-}
interface Channel where
import PreludeIOError(IOError13)
import PreludeMonadicIO(Either)
-{-# GHC_PRAGMA INTERFACE VERSION 5 #-}
+{-# GHC_PRAGMA INTERFACE VERSION 6 #-}
interface Channel where
import PreludeIOError(IOError13)
import PreludeMonadicIO(Either)
-{-# GHC_PRAGMA INTERFACE VERSION 5 #-}
+{-# GHC_PRAGMA INTERFACE VERSION 6 #-}
interface Channel where
import PreludeIOError(IOError13)
import PreludeMonadicIO(Either)
-{-# GHC_PRAGMA INTERFACE VERSION 5 #-}
+{-# GHC_PRAGMA INTERFACE VERSION 6 #-}
interface Channel where
import PreludeIOError(IOError13)
import PreludeMonadicIO(Either)
-{-# GHC_PRAGMA INTERFACE VERSION 5 #-}
+{-# GHC_PRAGMA INTERFACE VERSION 6 #-}
interface PreludeCore where
import PreludeBuiltin(Bin, Char(..), Int(..), Integer(..), List(..), Tuple2, _CMP_TAG(..))
import PreludeRatio(Ratio(..))
class Binary a where
readBin :: Bin -> (a, Bin)
{-# GHC_PRAGMA {-meth-} _A_ 1 _U_ 12 _N_ _S_ "U(SA)" {_A_ 1 _U_ 12 _N_ _N_ _F_ _IF_ARGS_ 1 1 X 1 _/\_ u0 -> \ (u1 :: Bin -> (u0, Bin)) -> u1 _N_} _F_ _IF_ARGS_ 1 1 C 2 _/\_ u0 -> \ (u1 :: (Bin -> (u0, Bin), u0 -> Bin -> Bin)) -> case u1 of { _ALG_ _TUP_2 (u2 :: Bin -> (u0, Bin)) (u3 :: u0 -> Bin -> Bin) -> u2; _NO_DEFLT_ } _N_
- {-defm-} _A_ 2 _U_ 02 _N_ _S_ _!_ _F_ _IF_ARGS_ 1 2 XX 3 _/\_ u0 -> \ (u1 :: {{Binary u0}}) (u2 :: Bin) -> _APP_ _TYAPP_ patError# { (Bin -> (u0, Bin)) } [ _NOREP_S_ "%DPreludeCore.Binary.readBin\"", u2 ] _N_ #-}
+ {-defm-} _A_ 2 _U_ 02 _N_ _S_ _!_ _N_ _N_ #-}
showBin :: a -> Bin -> Bin
{-# GHC_PRAGMA {-meth-} _A_ 1 _U_ 122 _N_ _S_ "U(AS)" {_A_ 1 _U_ 122 _N_ _N_ _F_ _IF_ARGS_ 1 1 X 1 _/\_ u0 -> \ (u1 :: u0 -> Bin -> Bin) -> u1 _N_} _F_ _IF_ARGS_ 1 1 C 2 _/\_ u0 -> \ (u1 :: (Bin -> (u0, Bin), u0 -> Bin -> Bin)) -> case u1 of { _ALG_ _TUP_2 (u2 :: Bin -> (u0, Bin)) (u3 :: u0 -> Bin -> Bin) -> u3; _NO_DEFLT_ } _N_
- {-defm-} _A_ 3 _U_ 022 _N_ _S_ _!_ _F_ _IF_ARGS_ 1 3 XXX 4 _/\_ u0 -> \ (u1 :: {{Binary u0}}) (u2 :: u0) (u3 :: Bin) -> _APP_ _TYAPP_ patError# { (u0 -> Bin -> Bin) } [ _NOREP_S_ "%DPreludeCore.Binary.showBin\"", u2, u3 ] _N_ #-}
+ {-defm-} _A_ 3 _U_ 022 _N_ _S_ _!_ _N_ _N_ #-}
class (Ord a) => Enum a {-# GHC_PRAGMA {-superdicts-} _A_ 1 _U_ 1 _N_ _S_ "U(U(LLLLLLLL)AAAA)" {_A_ 1 _U_ 1 _N_ _N_ _F_ _IF_ARGS_ 1 1 X 1 _/\_ u0 -> \ (u1 :: {{Ord u0}}) -> u1 _N_} _F_ _IF_ARGS_ 1 1 C 2 _/\_ u0 -> \ (u1 :: ({{Ord u0}}, u0 -> [u0], u0 -> u0 -> [u0], u0 -> u0 -> [u0], u0 -> u0 -> u0 -> [u0])) -> case u1 of { _ALG_ _TUP_5 (u2 :: {{Ord u0}}) (u3 :: u0 -> [u0]) (u4 :: u0 -> u0 -> [u0]) (u5 :: u0 -> u0 -> [u0]) (u6 :: u0 -> u0 -> u0 -> [u0]) -> u2; _NO_DEFLT_ } _N_ #-} where
enumFrom :: a -> [a]
{-# GHC_PRAGMA {-meth-} _A_ 1 _U_ 12 _N_ _S_ "U(ASAAA)" {_A_ 1 _U_ 12 _N_ _N_ _F_ _IF_ARGS_ 1 1 X 1 _/\_ u0 -> \ (u1 :: u0 -> [u0]) -> u1 _N_} _F_ _IF_ARGS_ 1 1 C 2 _/\_ u0 -> \ (u1 :: ({{Ord u0}}, u0 -> [u0], u0 -> u0 -> [u0], u0 -> u0 -> [u0], u0 -> u0 -> u0 -> [u0])) -> case u1 of { _ALG_ _TUP_5 (u2 :: {{Ord u0}}) (u3 :: u0 -> [u0]) (u4 :: u0 -> u0 -> [u0]) (u5 :: u0 -> u0 -> [u0]) (u6 :: u0 -> u0 -> u0 -> [u0]) -> u3; _NO_DEFLT_ } _N_
- {-defm-} _A_ 2 _U_ 02 _N_ _S_ _!_ _F_ _IF_ARGS_ 1 2 XX 3 _/\_ u0 -> \ (u1 :: {{Enum u0}}) (u2 :: u0) -> _APP_ _TYAPP_ patError# { (u0 -> [u0]) } [ _NOREP_S_ "%DPreludeCore.Enum.enumFrom\"", u2 ] _N_ #-}
+ {-defm-} _A_ 2 _U_ 02 _N_ _S_ _!_ _N_ _N_ #-}
enumFromThen :: a -> a -> [a]
{-# GHC_PRAGMA {-meth-} _A_ 1 _U_ 122 _N_ _S_ "U(AASAA)" {_A_ 1 _U_ 122 _N_ _N_ _F_ _IF_ARGS_ 1 1 X 1 _/\_ u0 -> \ (u1 :: u0 -> u0 -> [u0]) -> u1 _N_} _F_ _IF_ARGS_ 1 1 C 2 _/\_ u0 -> \ (u1 :: ({{Ord u0}}, u0 -> [u0], u0 -> u0 -> [u0], u0 -> u0 -> [u0], u0 -> u0 -> u0 -> [u0])) -> case u1 of { _ALG_ _TUP_5 (u2 :: {{Ord u0}}) (u3 :: u0 -> [u0]) (u4 :: u0 -> u0 -> [u0]) (u5 :: u0 -> u0 -> [u0]) (u6 :: u0 -> u0 -> u0 -> [u0]) -> u4; _NO_DEFLT_ } _N_
- {-defm-} _A_ 3 _U_ 022 _N_ _S_ _!_ _F_ _IF_ARGS_ 1 3 XXX 4 _/\_ u0 -> \ (u1 :: {{Enum u0}}) (u2 :: u0) (u3 :: u0) -> _APP_ _TYAPP_ patError# { (u0 -> u0 -> [u0]) } [ _NOREP_S_ "%DPreludeCore.Enum.enumFromThen\"", u2, u3 ] _N_ #-}
+ {-defm-} _A_ 3 _U_ 022 _N_ _S_ _!_ _N_ _N_ #-}
enumFromTo :: a -> a -> [a]
{-# GHC_PRAGMA {-meth-} _A_ 1 _U_ 122 _N_ _S_ "U(AAASA)" {_A_ 1 _U_ 122 _N_ _N_ _F_ _IF_ARGS_ 1 1 X 1 _/\_ u0 -> \ (u1 :: u0 -> u0 -> [u0]) -> u1 _N_} _F_ _IF_ARGS_ 1 1 C 2 _/\_ u0 -> \ (u1 :: ({{Ord u0}}, u0 -> [u0], u0 -> u0 -> [u0], u0 -> u0 -> [u0], u0 -> u0 -> u0 -> [u0])) -> case u1 of { _ALG_ _TUP_5 (u2 :: {{Ord u0}}) (u3 :: u0 -> [u0]) (u4 :: u0 -> u0 -> [u0]) (u5 :: u0 -> u0 -> [u0]) (u6 :: u0 -> u0 -> u0 -> [u0]) -> u5; _NO_DEFLT_ } _N_
{-defm-} _A_ 3 _U_ 122 _N_ _S_ "U(LSAAA)LL" {_A_ 4 _U_ 1122 _N_ _N_ _N_ _N_} _N_ _N_ #-}
class Eq a where
(==) :: a -> a -> Bool
{-# GHC_PRAGMA {-meth-} _A_ 1 _U_ 122 _N_ _S_ "U(SA)" {_A_ 1 _U_ 122 _N_ _N_ _F_ _IF_ARGS_ 1 1 X 1 _/\_ u0 -> \ (u1 :: u0 -> u0 -> Bool) -> u1 _N_} _F_ _IF_ARGS_ 1 1 C 2 _/\_ u0 -> \ (u1 :: (u0 -> u0 -> Bool, u0 -> u0 -> Bool)) -> case u1 of { _ALG_ _TUP_2 (u2 :: u0 -> u0 -> Bool) (u3 :: u0 -> u0 -> Bool) -> u2; _NO_DEFLT_ } _N_
- {-defm-} _A_ 3 _U_ 022 _N_ _S_ _!_ _F_ _IF_ARGS_ 1 3 XXX 4 _/\_ u0 -> \ (u1 :: {{Eq u0}}) (u2 :: u0) (u3 :: u0) -> _APP_ _TYAPP_ patError# { (u0 -> u0 -> Bool) } [ _NOREP_S_ "%DPreludeCore.Eq.(==)\"", u2, u3 ] _N_ #-}
+ {-defm-} _A_ 3 _U_ 022 _N_ _S_ _!_ _N_ _N_ #-}
(/=) :: a -> a -> Bool
{-# GHC_PRAGMA {-meth-} _A_ 1 _U_ 122 _N_ _S_ "U(AS)" {_A_ 1 _U_ 122 _N_ _N_ _F_ _IF_ARGS_ 1 1 X 1 _/\_ u0 -> \ (u1 :: u0 -> u0 -> Bool) -> u1 _N_} _F_ _IF_ARGS_ 1 1 C 2 _/\_ u0 -> \ (u1 :: (u0 -> u0 -> Bool, u0 -> u0 -> Bool)) -> case u1 of { _ALG_ _TUP_2 (u2 :: u0 -> u0 -> Bool) (u3 :: u0 -> u0 -> Bool) -> u3; _NO_DEFLT_ } _N_
{-defm-} _A_ 3 _U_ 122 _N_ _S_ "U(SA)LL" {_A_ 3 _U_ 122 _N_ _N_ _N_ _N_} _N_ _N_ #-}
class (Fractional a) => Floating a {-# GHC_PRAGMA {-superdicts-} _A_ 1 _U_ 1 _N_ _S_ "U(U(LLLL)AAAAAAAAAAAAAAAAAA)" {_A_ 4 _U_ 2222 _N_ _N_ _F_ _IF_ARGS_ 1 4 XXXX 5 _/\_ u0 -> \ (u1 :: {{Num u0}}) (u2 :: u0 -> u0 -> u0) (u3 :: u0 -> u0) (u4 :: Ratio Integer -> u0) -> _!_ _TUP_4 [{{Num u0}}, (u0 -> u0 -> u0), (u0 -> u0), (Ratio Integer -> u0)] [u1, u2, u3, u4] _N_} _F_ _IF_ARGS_ 1 1 C 2 _/\_ u0 -> \ (u1 :: ({{Fractional u0}}, u0, u0 -> u0, u0 -> u0, u0 -> u0, u0 -> u0 -> u0, u0 -> u0 -> u0, u0 -> u0, u0 -> u0, u0 -> u0, u0 -> u0, u0 -> u0, u0 -> u0, u0 -> u0, u0 -> u0, u0 -> u0, u0 -> u0, u0 -> u0, u0 -> u0)) -> case u1 of { _ALG_ _TUP_19 (u2 :: {{Fractional u0}}) (u3 :: u0) (u4 :: u0 -> u0) (u5 :: u0 -> u0) (u6 :: u0 -> u0) (u7 :: u0 -> u0 -> u0) (u8 :: u0 -> u0 -> u0) (u9 :: u0 -> u0) (ua :: u0 -> u0) (ub :: u0 -> u0) (uc :: u0 -> u0) (ud :: u0 -> u0) (ue :: u0 -> u0) (uf :: u0 -> u0) (ug :: u0 -> u0) (uh :: u0 -> u0) (ui :: u0 -> u0) (uj :: u0 -> u0) (uk :: u0 -> u0) -> u2; _NO_DEFLT_ } _N_ #-} where
pi :: a
{-# GHC_PRAGMA {-meth-} _A_ 1 _U_ 1 _N_ _S_ "U(ASAAAAAAAAAAAAAAAAA)" {_A_ 1 _U_ 1 _N_ _N_ _F_ _IF_ARGS_ 1 1 X 1 _/\_ u0 -> \ (u1 :: u0) -> u1 _N_} _F_ _IF_ARGS_ 1 1 C 2 _/\_ u0 -> \ (u1 :: ({{Fractional u0}}, u0, u0 -> u0, u0 -> u0, u0 -> u0, u0 -> u0 -> u0, u0 -> u0 -> u0, u0 -> u0, u0 -> u0, u0 -> u0, u0 -> u0, u0 -> u0, u0 -> u0, u0 -> u0, u0 -> u0, u0 -> u0, u0 -> u0, u0 -> u0, u0 -> u0)) -> case u1 of { _ALG_ _TUP_19 (u2 :: {{Fractional u0}}) (u3 :: u0) (u4 :: u0 -> u0) (u5 :: u0 -> u0) (u6 :: u0 -> u0) (u7 :: u0 -> u0 -> u0) (u8 :: u0 -> u0 -> u0) (u9 :: u0 -> u0) (ua :: u0 -> u0) (ub :: u0 -> u0) (uc :: u0 -> u0) (ud :: u0 -> u0) (ue :: u0 -> u0) (uf :: u0 -> u0) (ug :: u0 -> u0) (uh :: u0 -> u0) (ui :: u0 -> u0) (uj :: u0 -> u0) (uk :: u0 -> u0) -> u3; _NO_DEFLT_ } _N_
- {-defm-} _A_ 1 _U_ 0 _N_ _S_ _!_ _F_ _IF_ARGS_ 1 1 X 2 _/\_ u0 -> \ (u1 :: {{Floating u0}}) -> _APP_ _TYAPP_ patError# { u0 } [ _NOREP_S_ "%DPreludeCore.Floating.pi\"" ] _N_ #-}
+ {-defm-} _A_ 1 _U_ 0 _N_ _S_ _!_ _N_ _N_ #-}
exp :: a -> a
{-# GHC_PRAGMA {-meth-} _A_ 1 _U_ 12 _N_ _S_ "U(AASAAAAAAAAAAAAAAAA)" {_A_ 1 _U_ 12 _N_ _N_ _F_ _IF_ARGS_ 1 1 X 1 _/\_ u0 -> \ (u1 :: u0 -> u0) -> u1 _N_} _F_ _IF_ARGS_ 1 1 C 2 _/\_ u0 -> \ (u1 :: ({{Fractional u0}}, u0, u0 -> u0, u0 -> u0, u0 -> u0, u0 -> u0 -> u0, u0 -> u0 -> u0, u0 -> u0, u0 -> u0, u0 -> u0, u0 -> u0, u0 -> u0, u0 -> u0, u0 -> u0, u0 -> u0, u0 -> u0, u0 -> u0, u0 -> u0, u0 -> u0)) -> case u1 of { _ALG_ _TUP_19 (u2 :: {{Fractional u0}}) (u3 :: u0) (u4 :: u0 -> u0) (u5 :: u0 -> u0) (u6 :: u0 -> u0) (u7 :: u0 -> u0 -> u0) (u8 :: u0 -> u0 -> u0) (u9 :: u0 -> u0) (ua :: u0 -> u0) (ub :: u0 -> u0) (uc :: u0 -> u0) (ud :: u0 -> u0) (ue :: u0 -> u0) (uf :: u0 -> u0) (ug :: u0 -> u0) (uh :: u0 -> u0) (ui :: u0 -> u0) (uj :: u0 -> u0) (uk :: u0 -> u0) -> u4; _NO_DEFLT_ } _N_
- {-defm-} _A_ 2 _U_ 02 _N_ _S_ _!_ _F_ _IF_ARGS_ 1 2 XX 3 _/\_ u0 -> \ (u1 :: {{Floating u0}}) (u2 :: u0) -> _APP_ _TYAPP_ patError# { (u0 -> u0) } [ _NOREP_S_ "%DPreludeCore.Floating.exp\"", u2 ] _N_ #-}
+ {-defm-} _A_ 2 _U_ 02 _N_ _S_ _!_ _N_ _N_ #-}
log :: a -> a
{-# GHC_PRAGMA {-meth-} _A_ 1 _U_ 12 _N_ _S_ "U(AAASAAAAAAAAAAAAAAA)" {_A_ 1 _U_ 12 _N_ _N_ _F_ _IF_ARGS_ 1 1 X 1 _/\_ u0 -> \ (u1 :: u0 -> u0) -> u1 _N_} _F_ _IF_ARGS_ 1 1 C 2 _/\_ u0 -> \ (u1 :: ({{Fractional u0}}, u0, u0 -> u0, u0 -> u0, u0 -> u0, u0 -> u0 -> u0, u0 -> u0 -> u0, u0 -> u0, u0 -> u0, u0 -> u0, u0 -> u0, u0 -> u0, u0 -> u0, u0 -> u0, u0 -> u0, u0 -> u0, u0 -> u0, u0 -> u0, u0 -> u0)) -> case u1 of { _ALG_ _TUP_19 (u2 :: {{Fractional u0}}) (u3 :: u0) (u4 :: u0 -> u0) (u5 :: u0 -> u0) (u6 :: u0 -> u0) (u7 :: u0 -> u0 -> u0) (u8 :: u0 -> u0 -> u0) (u9 :: u0 -> u0) (ua :: u0 -> u0) (ub :: u0 -> u0) (uc :: u0 -> u0) (ud :: u0 -> u0) (ue :: u0 -> u0) (uf :: u0 -> u0) (ug :: u0 -> u0) (uh :: u0 -> u0) (ui :: u0 -> u0) (uj :: u0 -> u0) (uk :: u0 -> u0) -> u5; _NO_DEFLT_ } _N_
- {-defm-} _A_ 2 _U_ 02 _N_ _S_ _!_ _F_ _IF_ARGS_ 1 2 XX 3 _/\_ u0 -> \ (u1 :: {{Floating u0}}) (u2 :: u0) -> _APP_ _TYAPP_ patError# { (u0 -> u0) } [ _NOREP_S_ "%DPreludeCore.Floating.log\"", u2 ] _N_ #-}
+ {-defm-} _A_ 2 _U_ 02 _N_ _S_ _!_ _N_ _N_ #-}
sqrt :: a -> a
{-# GHC_PRAGMA {-meth-} _A_ 1 _U_ 12 _N_ _S_ "U(AAAASAAAAAAAAAAAAAA)" {_A_ 1 _U_ 12 _N_ _N_ _F_ _IF_ARGS_ 1 1 X 1 _/\_ u0 -> \ (u1 :: u0 -> u0) -> u1 _N_} _F_ _IF_ARGS_ 1 1 C 2 _/\_ u0 -> \ (u1 :: ({{Fractional u0}}, u0, u0 -> u0, u0 -> u0, u0 -> u0, u0 -> u0 -> u0, u0 -> u0 -> u0, u0 -> u0, u0 -> u0, u0 -> u0, u0 -> u0, u0 -> u0, u0 -> u0, u0 -> u0, u0 -> u0, u0 -> u0, u0 -> u0, u0 -> u0, u0 -> u0)) -> case u1 of { _ALG_ _TUP_19 (u2 :: {{Fractional u0}}) (u3 :: u0) (u4 :: u0 -> u0) (u5 :: u0 -> u0) (u6 :: u0 -> u0) (u7 :: u0 -> u0 -> u0) (u8 :: u0 -> u0 -> u0) (u9 :: u0 -> u0) (ua :: u0 -> u0) (ub :: u0 -> u0) (uc :: u0 -> u0) (ud :: u0 -> u0) (ue :: u0 -> u0) (uf :: u0 -> u0) (ug :: u0 -> u0) (uh :: u0 -> u0) (ui :: u0 -> u0) (uj :: u0 -> u0) (uk :: u0 -> u0) -> u6; _NO_DEFLT_ } _N_
{-defm-} _A_ 1 _U_ 12 _N_ _S_ "U(LAAAASAAAAAAAAAAAAA)" {_A_ 2 _U_ 112 _N_ _N_ _N_ _N_} _N_ _N_ #-}
{-defm-} _A_ 3 _U_ 122 _N_ _S_ "U(U(ASAA)AALAAAAAAAAAAAAAAA)LL" {_A_ 4 _U_ 1222 _N_ _N_ _N_ _N_} _N_ _N_ #-}
sin :: a -> a
{-# GHC_PRAGMA {-meth-} _A_ 1 _U_ 12 _N_ _S_ "U(AAAAAAASAAAAAAAAAAA)" {_A_ 1 _U_ 12 _N_ _N_ _F_ _IF_ARGS_ 1 1 X 1 _/\_ u0 -> \ (u1 :: u0 -> u0) -> u1 _N_} _F_ _IF_ARGS_ 1 1 C 2 _/\_ u0 -> \ (u1 :: ({{Fractional u0}}, u0, u0 -> u0, u0 -> u0, u0 -> u0, u0 -> u0 -> u0, u0 -> u0 -> u0, u0 -> u0, u0 -> u0, u0 -> u0, u0 -> u0, u0 -> u0, u0 -> u0, u0 -> u0, u0 -> u0, u0 -> u0, u0 -> u0, u0 -> u0, u0 -> u0)) -> case u1 of { _ALG_ _TUP_19 (u2 :: {{Fractional u0}}) (u3 :: u0) (u4 :: u0 -> u0) (u5 :: u0 -> u0) (u6 :: u0 -> u0) (u7 :: u0 -> u0 -> u0) (u8 :: u0 -> u0 -> u0) (u9 :: u0 -> u0) (ua :: u0 -> u0) (ub :: u0 -> u0) (uc :: u0 -> u0) (ud :: u0 -> u0) (ue :: u0 -> u0) (uf :: u0 -> u0) (ug :: u0 -> u0) (uh :: u0 -> u0) (ui :: u0 -> u0) (uj :: u0 -> u0) (uk :: u0 -> u0) -> u9; _NO_DEFLT_ } _N_
- {-defm-} _A_ 2 _U_ 02 _N_ _S_ _!_ _F_ _IF_ARGS_ 1 2 XX 3 _/\_ u0 -> \ (u1 :: {{Floating u0}}) (u2 :: u0) -> _APP_ _TYAPP_ patError# { (u0 -> u0) } [ _NOREP_S_ "%DPreludeCore.Floating.sin\"", u2 ] _N_ #-}
+ {-defm-} _A_ 2 _U_ 02 _N_ _S_ _!_ _N_ _N_ #-}
cos :: a -> a
{-# GHC_PRAGMA {-meth-} _A_ 1 _U_ 12 _N_ _S_ "U(AAAAAAAASAAAAAAAAAA)" {_A_ 1 _U_ 12 _N_ _N_ _F_ _IF_ARGS_ 1 1 X 1 _/\_ u0 -> \ (u1 :: u0 -> u0) -> u1 _N_} _F_ _IF_ARGS_ 1 1 C 2 _/\_ u0 -> \ (u1 :: ({{Fractional u0}}, u0, u0 -> u0, u0 -> u0, u0 -> u0, u0 -> u0 -> u0, u0 -> u0 -> u0, u0 -> u0, u0 -> u0, u0 -> u0, u0 -> u0, u0 -> u0, u0 -> u0, u0 -> u0, u0 -> u0, u0 -> u0, u0 -> u0, u0 -> u0, u0 -> u0)) -> case u1 of { _ALG_ _TUP_19 (u2 :: {{Fractional u0}}) (u3 :: u0) (u4 :: u0 -> u0) (u5 :: u0 -> u0) (u6 :: u0 -> u0) (u7 :: u0 -> u0 -> u0) (u8 :: u0 -> u0 -> u0) (u9 :: u0 -> u0) (ua :: u0 -> u0) (ub :: u0 -> u0) (uc :: u0 -> u0) (ud :: u0 -> u0) (ue :: u0 -> u0) (uf :: u0 -> u0) (ug :: u0 -> u0) (uh :: u0 -> u0) (ui :: u0 -> u0) (uj :: u0 -> u0) (uk :: u0 -> u0) -> ua; _NO_DEFLT_ } _N_
- {-defm-} _A_ 2 _U_ 02 _N_ _S_ _!_ _F_ _IF_ARGS_ 1 2 XX 3 _/\_ u0 -> \ (u1 :: {{Floating u0}}) (u2 :: u0) -> _APP_ _TYAPP_ patError# { (u0 -> u0) } [ _NOREP_S_ "%DPreludeCore.Floating.cos\"", u2 ] _N_ #-}
+ {-defm-} _A_ 2 _U_ 02 _N_ _S_ _!_ _N_ _N_ #-}
tan :: a -> a
{-# GHC_PRAGMA {-meth-} _A_ 1 _U_ 12 _N_ _S_ "U(AAAAAAAAASAAAAAAAAA)" {_A_ 1 _U_ 12 _N_ _N_ _F_ _IF_ARGS_ 1 1 X 1 _/\_ u0 -> \ (u1 :: u0 -> u0) -> u1 _N_} _F_ _IF_ARGS_ 1 1 C 2 _/\_ u0 -> \ (u1 :: ({{Fractional u0}}, u0, u0 -> u0, u0 -> u0, u0 -> u0, u0 -> u0 -> u0, u0 -> u0 -> u0, u0 -> u0, u0 -> u0, u0 -> u0, u0 -> u0, u0 -> u0, u0 -> u0, u0 -> u0, u0 -> u0, u0 -> u0, u0 -> u0, u0 -> u0, u0 -> u0)) -> case u1 of { _ALG_ _TUP_19 (u2 :: {{Fractional u0}}) (u3 :: u0) (u4 :: u0 -> u0) (u5 :: u0 -> u0) (u6 :: u0 -> u0) (u7 :: u0 -> u0 -> u0) (u8 :: u0 -> u0 -> u0) (u9 :: u0 -> u0) (ua :: u0 -> u0) (ub :: u0 -> u0) (uc :: u0 -> u0) (ud :: u0 -> u0) (ue :: u0 -> u0) (uf :: u0 -> u0) (ug :: u0 -> u0) (uh :: u0 -> u0) (ui :: u0 -> u0) (uj :: u0 -> u0) (uk :: u0 -> u0) -> ub; _NO_DEFLT_ } _N_
{-defm-} _A_ 2 _U_ 12 _N_ _S_ "U(U(ASAA)AAAAAALLAAAAAAAAAA)L" {_A_ 4 _U_ 1112 _N_ _N_ _N_ _N_} _N_ _N_ #-}
asin :: a -> a
{-# GHC_PRAGMA {-meth-} _A_ 1 _U_ 12 _N_ _S_ "U(AAAAAAAAAASAAAAAAAA)" {_A_ 1 _U_ 12 _N_ _N_ _F_ _IF_ARGS_ 1 1 X 1 _/\_ u0 -> \ (u1 :: u0 -> u0) -> u1 _N_} _F_ _IF_ARGS_ 1 1 C 2 _/\_ u0 -> \ (u1 :: ({{Fractional u0}}, u0, u0 -> u0, u0 -> u0, u0 -> u0, u0 -> u0 -> u0, u0 -> u0 -> u0, u0 -> u0, u0 -> u0, u0 -> u0, u0 -> u0, u0 -> u0, u0 -> u0, u0 -> u0, u0 -> u0, u0 -> u0, u0 -> u0, u0 -> u0, u0 -> u0)) -> case u1 of { _ALG_ _TUP_19 (u2 :: {{Fractional u0}}) (u3 :: u0) (u4 :: u0 -> u0) (u5 :: u0 -> u0) (u6 :: u0 -> u0) (u7 :: u0 -> u0 -> u0) (u8 :: u0 -> u0 -> u0) (u9 :: u0 -> u0) (ua :: u0 -> u0) (ub :: u0 -> u0) (uc :: u0 -> u0) (ud :: u0 -> u0) (ue :: u0 -> u0) (uf :: u0 -> u0) (ug :: u0 -> u0) (uh :: u0 -> u0) (ui :: u0 -> u0) (uj :: u0 -> u0) (uk :: u0 -> u0) -> uc; _NO_DEFLT_ } _N_
- {-defm-} _A_ 2 _U_ 02 _N_ _S_ _!_ _F_ _IF_ARGS_ 1 2 XX 3 _/\_ u0 -> \ (u1 :: {{Floating u0}}) (u2 :: u0) -> _APP_ _TYAPP_ patError# { (u0 -> u0) } [ _NOREP_S_ "%DPreludeCore.Floating.asin\"", u2 ] _N_ #-}
+ {-defm-} _A_ 2 _U_ 02 _N_ _S_ _!_ _N_ _N_ #-}
acos :: a -> a
{-# GHC_PRAGMA {-meth-} _A_ 1 _U_ 12 _N_ _S_ "U(AAAAAAAAAAASAAAAAAA)" {_A_ 1 _U_ 12 _N_ _N_ _F_ _IF_ARGS_ 1 1 X 1 _/\_ u0 -> \ (u1 :: u0 -> u0) -> u1 _N_} _F_ _IF_ARGS_ 1 1 C 2 _/\_ u0 -> \ (u1 :: ({{Fractional u0}}, u0, u0 -> u0, u0 -> u0, u0 -> u0, u0 -> u0 -> u0, u0 -> u0 -> u0, u0 -> u0, u0 -> u0, u0 -> u0, u0 -> u0, u0 -> u0, u0 -> u0, u0 -> u0, u0 -> u0, u0 -> u0, u0 -> u0, u0 -> u0, u0 -> u0)) -> case u1 of { _ALG_ _TUP_19 (u2 :: {{Fractional u0}}) (u3 :: u0) (u4 :: u0 -> u0) (u5 :: u0 -> u0) (u6 :: u0 -> u0) (u7 :: u0 -> u0 -> u0) (u8 :: u0 -> u0 -> u0) (u9 :: u0 -> u0) (ua :: u0 -> u0) (ub :: u0 -> u0) (uc :: u0 -> u0) (ud :: u0 -> u0) (ue :: u0 -> u0) (uf :: u0 -> u0) (ug :: u0 -> u0) (uh :: u0 -> u0) (ui :: u0 -> u0) (uj :: u0 -> u0) (uk :: u0 -> u0) -> ud; _NO_DEFLT_ } _N_
- {-defm-} _A_ 2 _U_ 02 _N_ _S_ _!_ _F_ _IF_ARGS_ 1 2 XX 3 _/\_ u0 -> \ (u1 :: {{Floating u0}}) (u2 :: u0) -> _APP_ _TYAPP_ patError# { (u0 -> u0) } [ _NOREP_S_ "%DPreludeCore.Floating.acos\"", u2 ] _N_ #-}
+ {-defm-} _A_ 2 _U_ 02 _N_ _S_ _!_ _N_ _N_ #-}
atan :: a -> a
{-# GHC_PRAGMA {-meth-} _A_ 1 _U_ 12 _N_ _S_ "U(AAAAAAAAAAAASAAAAAA)" {_A_ 1 _U_ 12 _N_ _N_ _F_ _IF_ARGS_ 1 1 X 1 _/\_ u0 -> \ (u1 :: u0 -> u0) -> u1 _N_} _F_ _IF_ARGS_ 1 1 C 2 _/\_ u0 -> \ (u1 :: ({{Fractional u0}}, u0, u0 -> u0, u0 -> u0, u0 -> u0, u0 -> u0 -> u0, u0 -> u0 -> u0, u0 -> u0, u0 -> u0, u0 -> u0, u0 -> u0, u0 -> u0, u0 -> u0, u0 -> u0, u0 -> u0, u0 -> u0, u0 -> u0, u0 -> u0, u0 -> u0)) -> case u1 of { _ALG_ _TUP_19 (u2 :: {{Fractional u0}}) (u3 :: u0) (u4 :: u0 -> u0) (u5 :: u0 -> u0) (u6 :: u0 -> u0) (u7 :: u0 -> u0 -> u0) (u8 :: u0 -> u0 -> u0) (u9 :: u0 -> u0) (ua :: u0 -> u0) (ub :: u0 -> u0) (uc :: u0 -> u0) (ud :: u0 -> u0) (ue :: u0 -> u0) (uf :: u0 -> u0) (ug :: u0 -> u0) (uh :: u0 -> u0) (ui :: u0 -> u0) (uj :: u0 -> u0) (uk :: u0 -> u0) -> ue; _NO_DEFLT_ } _N_
- {-defm-} _A_ 2 _U_ 02 _N_ _S_ _!_ _F_ _IF_ARGS_ 1 2 XX 3 _/\_ u0 -> \ (u1 :: {{Floating u0}}) (u2 :: u0) -> _APP_ _TYAPP_ patError# { (u0 -> u0) } [ _NOREP_S_ "%DPreludeCore.Floating.atan\"", u2 ] _N_ #-}
+ {-defm-} _A_ 2 _U_ 02 _N_ _S_ _!_ _N_ _N_ #-}
sinh :: a -> a
{-# GHC_PRAGMA {-meth-} _A_ 1 _U_ 12 _N_ _S_ "U(AAAAAAAAAAAAASAAAAA)" {_A_ 1 _U_ 12 _N_ _N_ _F_ _IF_ARGS_ 1 1 X 1 _/\_ u0 -> \ (u1 :: u0 -> u0) -> u1 _N_} _F_ _IF_ARGS_ 1 1 C 2 _/\_ u0 -> \ (u1 :: ({{Fractional u0}}, u0, u0 -> u0, u0 -> u0, u0 -> u0, u0 -> u0 -> u0, u0 -> u0 -> u0, u0 -> u0, u0 -> u0, u0 -> u0, u0 -> u0, u0 -> u0, u0 -> u0, u0 -> u0, u0 -> u0, u0 -> u0, u0 -> u0, u0 -> u0, u0 -> u0)) -> case u1 of { _ALG_ _TUP_19 (u2 :: {{Fractional u0}}) (u3 :: u0) (u4 :: u0 -> u0) (u5 :: u0 -> u0) (u6 :: u0 -> u0) (u7 :: u0 -> u0 -> u0) (u8 :: u0 -> u0 -> u0) (u9 :: u0 -> u0) (ua :: u0 -> u0) (ub :: u0 -> u0) (uc :: u0 -> u0) (ud :: u0 -> u0) (ue :: u0 -> u0) (uf :: u0 -> u0) (ug :: u0 -> u0) (uh :: u0 -> u0) (ui :: u0 -> u0) (uj :: u0 -> u0) (uk :: u0 -> u0) -> uf; _NO_DEFLT_ } _N_
- {-defm-} _A_ 2 _U_ 02 _N_ _S_ _!_ _F_ _IF_ARGS_ 1 2 XX 3 _/\_ u0 -> \ (u1 :: {{Floating u0}}) (u2 :: u0) -> _APP_ _TYAPP_ patError# { (u0 -> u0) } [ _NOREP_S_ "%DPreludeCore.Floating.sinh\"", u2 ] _N_ #-}
+ {-defm-} _A_ 2 _U_ 02 _N_ _S_ _!_ _N_ _N_ #-}
cosh :: a -> a
{-# GHC_PRAGMA {-meth-} _A_ 1 _U_ 12 _N_ _S_ "U(AAAAAAAAAAAAAASAAAA)" {_A_ 1 _U_ 12 _N_ _N_ _F_ _IF_ARGS_ 1 1 X 1 _/\_ u0 -> \ (u1 :: u0 -> u0) -> u1 _N_} _F_ _IF_ARGS_ 1 1 C 2 _/\_ u0 -> \ (u1 :: ({{Fractional u0}}, u0, u0 -> u0, u0 -> u0, u0 -> u0, u0 -> u0 -> u0, u0 -> u0 -> u0, u0 -> u0, u0 -> u0, u0 -> u0, u0 -> u0, u0 -> u0, u0 -> u0, u0 -> u0, u0 -> u0, u0 -> u0, u0 -> u0, u0 -> u0, u0 -> u0)) -> case u1 of { _ALG_ _TUP_19 (u2 :: {{Fractional u0}}) (u3 :: u0) (u4 :: u0 -> u0) (u5 :: u0 -> u0) (u6 :: u0 -> u0) (u7 :: u0 -> u0 -> u0) (u8 :: u0 -> u0 -> u0) (u9 :: u0 -> u0) (ua :: u0 -> u0) (ub :: u0 -> u0) (uc :: u0 -> u0) (ud :: u0 -> u0) (ue :: u0 -> u0) (uf :: u0 -> u0) (ug :: u0 -> u0) (uh :: u0 -> u0) (ui :: u0 -> u0) (uj :: u0 -> u0) (uk :: u0 -> u0) -> ug; _NO_DEFLT_ } _N_
- {-defm-} _A_ 2 _U_ 02 _N_ _S_ _!_ _F_ _IF_ARGS_ 1 2 XX 3 _/\_ u0 -> \ (u1 :: {{Floating u0}}) (u2 :: u0) -> _APP_ _TYAPP_ patError# { (u0 -> u0) } [ _NOREP_S_ "%DPreludeCore.Floating.cosh\"", u2 ] _N_ #-}
+ {-defm-} _A_ 2 _U_ 02 _N_ _S_ _!_ _N_ _N_ #-}
tanh :: a -> a
{-# GHC_PRAGMA {-meth-} _A_ 1 _U_ 12 _N_ _S_ "U(AAAAAAAAAAAAAAASAAA)" {_A_ 1 _U_ 12 _N_ _N_ _F_ _IF_ARGS_ 1 1 X 1 _/\_ u0 -> \ (u1 :: u0 -> u0) -> u1 _N_} _F_ _IF_ARGS_ 1 1 C 2 _/\_ u0 -> \ (u1 :: ({{Fractional u0}}, u0, u0 -> u0, u0 -> u0, u0 -> u0, u0 -> u0 -> u0, u0 -> u0 -> u0, u0 -> u0, u0 -> u0, u0 -> u0, u0 -> u0, u0 -> u0, u0 -> u0, u0 -> u0, u0 -> u0, u0 -> u0, u0 -> u0, u0 -> u0, u0 -> u0)) -> case u1 of { _ALG_ _TUP_19 (u2 :: {{Fractional u0}}) (u3 :: u0) (u4 :: u0 -> u0) (u5 :: u0 -> u0) (u6 :: u0 -> u0) (u7 :: u0 -> u0 -> u0) (u8 :: u0 -> u0 -> u0) (u9 :: u0 -> u0) (ua :: u0 -> u0) (ub :: u0 -> u0) (uc :: u0 -> u0) (ud :: u0 -> u0) (ue :: u0 -> u0) (uf :: u0 -> u0) (ug :: u0 -> u0) (uh :: u0 -> u0) (ui :: u0 -> u0) (uj :: u0 -> u0) (uk :: u0 -> u0) -> uh; _NO_DEFLT_ } _N_
{-defm-} _A_ 2 _U_ 12 _N_ _S_ "U(U(ASAA)AAAAAAAAAAAALLAAAA)L" {_A_ 4 _U_ 1112 _N_ _N_ _N_ _N_} _N_ _N_ #-}
asinh :: a -> a
{-# GHC_PRAGMA {-meth-} _A_ 1 _U_ 12 _N_ _S_ "U(AAAAAAAAAAAAAAAASAA)" {_A_ 1 _U_ 12 _N_ _N_ _F_ _IF_ARGS_ 1 1 X 1 _/\_ u0 -> \ (u1 :: u0 -> u0) -> u1 _N_} _F_ _IF_ARGS_ 1 1 C 2 _/\_ u0 -> \ (u1 :: ({{Fractional u0}}, u0, u0 -> u0, u0 -> u0, u0 -> u0, u0 -> u0 -> u0, u0 -> u0 -> u0, u0 -> u0, u0 -> u0, u0 -> u0, u0 -> u0, u0 -> u0, u0 -> u0, u0 -> u0, u0 -> u0, u0 -> u0, u0 -> u0, u0 -> u0, u0 -> u0)) -> case u1 of { _ALG_ _TUP_19 (u2 :: {{Fractional u0}}) (u3 :: u0) (u4 :: u0 -> u0) (u5 :: u0 -> u0) (u6 :: u0 -> u0) (u7 :: u0 -> u0 -> u0) (u8 :: u0 -> u0 -> u0) (u9 :: u0 -> u0) (ua :: u0 -> u0) (ub :: u0 -> u0) (uc :: u0 -> u0) (ud :: u0 -> u0) (ue :: u0 -> u0) (uf :: u0 -> u0) (ug :: u0 -> u0) (uh :: u0 -> u0) (ui :: u0 -> u0) (uj :: u0 -> u0) (uk :: u0 -> u0) -> ui; _NO_DEFLT_ } _N_
- {-defm-} _A_ 2 _U_ 02 _N_ _S_ _!_ _F_ _IF_ARGS_ 1 2 XX 3 _/\_ u0 -> \ (u1 :: {{Floating u0}}) (u2 :: u0) -> _APP_ _TYAPP_ patError# { (u0 -> u0) } [ _NOREP_S_ "%DPreludeCore.Floating.asinh\"", u2 ] _N_ #-}
+ {-defm-} _A_ 2 _U_ 02 _N_ _S_ _!_ _N_ _N_ #-}
acosh :: a -> a
{-# GHC_PRAGMA {-meth-} _A_ 1 _U_ 12 _N_ _S_ "U(AAAAAAAAAAAAAAAAASA)" {_A_ 1 _U_ 12 _N_ _N_ _F_ _IF_ARGS_ 1 1 X 1 _/\_ u0 -> \ (u1 :: u0 -> u0) -> u1 _N_} _F_ _IF_ARGS_ 1 1 C 2 _/\_ u0 -> \ (u1 :: ({{Fractional u0}}, u0, u0 -> u0, u0 -> u0, u0 -> u0, u0 -> u0 -> u0, u0 -> u0 -> u0, u0 -> u0, u0 -> u0, u0 -> u0, u0 -> u0, u0 -> u0, u0 -> u0, u0 -> u0, u0 -> u0, u0 -> u0, u0 -> u0, u0 -> u0, u0 -> u0)) -> case u1 of { _ALG_ _TUP_19 (u2 :: {{Fractional u0}}) (u3 :: u0) (u4 :: u0 -> u0) (u5 :: u0 -> u0) (u6 :: u0 -> u0) (u7 :: u0 -> u0 -> u0) (u8 :: u0 -> u0 -> u0) (u9 :: u0 -> u0) (ua :: u0 -> u0) (ub :: u0 -> u0) (uc :: u0 -> u0) (ud :: u0 -> u0) (ue :: u0 -> u0) (uf :: u0 -> u0) (ug :: u0 -> u0) (uh :: u0 -> u0) (ui :: u0 -> u0) (uj :: u0 -> u0) (uk :: u0 -> u0) -> uj; _NO_DEFLT_ } _N_
- {-defm-} _A_ 2 _U_ 02 _N_ _S_ _!_ _F_ _IF_ARGS_ 1 2 XX 3 _/\_ u0 -> \ (u1 :: {{Floating u0}}) (u2 :: u0) -> _APP_ _TYAPP_ patError# { (u0 -> u0) } [ _NOREP_S_ "%DPreludeCore.Floating.acosh\"", u2 ] _N_ #-}
+ {-defm-} _A_ 2 _U_ 02 _N_ _S_ _!_ _N_ _N_ #-}
atanh :: a -> a
{-# GHC_PRAGMA {-meth-} _A_ 1 _U_ 12 _N_ _S_ "U(AAAAAAAAAAAAAAAAAAS)" {_A_ 1 _U_ 12 _N_ _N_ _F_ _IF_ARGS_ 1 1 X 1 _/\_ u0 -> \ (u1 :: u0 -> u0) -> u1 _N_} _F_ _IF_ARGS_ 1 1 C 2 _/\_ u0 -> \ (u1 :: ({{Fractional u0}}, u0, u0 -> u0, u0 -> u0, u0 -> u0, u0 -> u0 -> u0, u0 -> u0 -> u0, u0 -> u0, u0 -> u0, u0 -> u0, u0 -> u0, u0 -> u0, u0 -> u0, u0 -> u0, u0 -> u0, u0 -> u0, u0 -> u0, u0 -> u0, u0 -> u0)) -> case u1 of { _ALG_ _TUP_19 (u2 :: {{Fractional u0}}) (u3 :: u0) (u4 :: u0 -> u0) (u5 :: u0 -> u0) (u6 :: u0 -> u0) (u7 :: u0 -> u0 -> u0) (u8 :: u0 -> u0 -> u0) (u9 :: u0 -> u0) (ua :: u0 -> u0) (ub :: u0 -> u0) (uc :: u0 -> u0) (ud :: u0 -> u0) (ue :: u0 -> u0) (uf :: u0 -> u0) (ug :: u0 -> u0) (uh :: u0 -> u0) (ui :: u0 -> u0) (uj :: u0 -> u0) (uk :: u0 -> u0) -> uk; _NO_DEFLT_ } _N_
- {-defm-} _A_ 2 _U_ 02 _N_ _S_ _!_ _F_ _IF_ARGS_ 1 2 XX 3 _/\_ u0 -> \ (u1 :: {{Floating u0}}) (u2 :: u0) -> _APP_ _TYAPP_ patError# { (u0 -> u0) } [ _NOREP_S_ "%DPreludeCore.Floating.atanh\"", u2 ] _N_ #-}
+ {-defm-} _A_ 2 _U_ 02 _N_ _S_ _!_ _N_ _N_ #-}
class (Num a) => Fractional a {-# GHC_PRAGMA {-superdicts-} _A_ 1 _U_ 1 _N_ _S_ "U(U(LLLLLLLLLL)AAA)" {_A_ 1 _U_ 1 _N_ _N_ _F_ _IF_ARGS_ 1 1 X 1 _/\_ u0 -> \ (u1 :: {{Num u0}}) -> u1 _N_} _F_ _IF_ARGS_ 1 1 C 2 _/\_ u0 -> \ (u1 :: ({{Num u0}}, u0 -> u0 -> u0, u0 -> u0, Ratio Integer -> u0)) -> case u1 of { _ALG_ _TUP_4 (u2 :: {{Num u0}}) (u3 :: u0 -> u0 -> u0) (u4 :: u0 -> u0) (u5 :: Ratio Integer -> u0) -> u2; _NO_DEFLT_ } _N_ #-} where
(/) :: a -> a -> a
{-# GHC_PRAGMA {-meth-} _A_ 1 _U_ 122 _N_ _S_ "U(ASAA)" {_A_ 1 _U_ 122 _N_ _N_ _F_ _IF_ARGS_ 1 1 X 1 _/\_ u0 -> \ (u1 :: u0 -> u0 -> u0) -> u1 _N_} _F_ _IF_ARGS_ 1 1 C 2 _/\_ u0 -> \ (u1 :: ({{Num u0}}, u0 -> u0 -> u0, u0 -> u0, Ratio Integer -> u0)) -> case u1 of { _ALG_ _TUP_4 (u2 :: {{Num u0}}) (u3 :: u0 -> u0 -> u0) (u4 :: u0 -> u0) (u5 :: Ratio Integer -> u0) -> u3; _NO_DEFLT_ } _N_
- {-defm-} _A_ 3 _U_ 022 _N_ _S_ _!_ _F_ _IF_ARGS_ 1 3 XXX 4 _/\_ u0 -> \ (u1 :: {{Fractional u0}}) (u2 :: u0) (u3 :: u0) -> _APP_ _TYAPP_ patError# { (u0 -> u0 -> u0) } [ _NOREP_S_ "%DPreludeCore.Fractional.(/)\"", u2, u3 ] _N_ #-}
+ {-defm-} _A_ 3 _U_ 022 _N_ _S_ _!_ _N_ _N_ #-}
recip :: a -> a
{-# GHC_PRAGMA {-meth-} _A_ 1 _U_ 12 _N_ _S_ "U(AASA)" {_A_ 1 _U_ 12 _N_ _N_ _F_ _IF_ARGS_ 1 1 X 1 _/\_ u0 -> \ (u1 :: u0 -> u0) -> u1 _N_} _F_ _IF_ARGS_ 1 1 C 2 _/\_ u0 -> \ (u1 :: ({{Num u0}}, u0 -> u0 -> u0, u0 -> u0, Ratio Integer -> u0)) -> case u1 of { _ALG_ _TUP_4 (u2 :: {{Num u0}}) (u3 :: u0 -> u0 -> u0) (u4 :: u0 -> u0) (u5 :: Ratio Integer -> u0) -> u4; _NO_DEFLT_ } _N_
- {-defm-} _A_ 1 _U_ 12 _N_ _S_ "U(ASAL)" {_A_ 2 _U_ 122 _N_ _N_ _N_ _N_} _N_ _N_ #-}
+ {-defm-} _A_ 1 _U_ 12 _N_ _S_ "U(LSAA)" {_A_ 2 _U_ 112 _N_ _N_ _N_ _N_} _N_ _N_ #-}
fromRational :: Ratio Integer -> a
{-# GHC_PRAGMA {-meth-} _A_ 1 _U_ 12 _N_ _S_ "U(AAAS)" {_A_ 1 _U_ 12 _N_ _N_ _F_ _IF_ARGS_ 1 1 X 1 _/\_ u0 -> \ (u1 :: Ratio Integer -> u0) -> u1 _N_} _F_ _IF_ARGS_ 1 1 C 2 _/\_ u0 -> \ (u1 :: ({{Num u0}}, u0 -> u0 -> u0, u0 -> u0, Ratio Integer -> u0)) -> case u1 of { _ALG_ _TUP_4 (u2 :: {{Num u0}}) (u3 :: u0 -> u0 -> u0) (u4 :: u0 -> u0) (u5 :: Ratio Integer -> u0) -> u5; _NO_DEFLT_ } _N_
- {-defm-} _A_ 2 _U_ 02 _N_ _S_ _!_ _F_ _IF_ARGS_ 1 2 XX 3 _/\_ u0 -> \ (u1 :: {{Fractional u0}}) (u2 :: Ratio Integer) -> _APP_ _TYAPP_ patError# { (Ratio Integer -> u0) } [ _NOREP_S_ "%DPreludeCore.Fractional.fromRational\"", u2 ] _N_ #-}
+ {-defm-} _A_ 2 _U_ 02 _N_ _S_ _!_ _N_ _N_ #-}
class (Real a, Ix a) => Integral a {-# GHC_PRAGMA {-superdicts-} _A_ 1 _U_ 1 _N_ _S_ "U(U(LLL)AAAAAAAAAAA)" {_A_ 3 _U_ 222 _N_ _N_ _F_ _IF_ARGS_ 1 3 XXX 4 _/\_ u0 -> \ (u1 :: {{Num u0}}) (u2 :: {{Enum u0}}) (u3 :: u0 -> Ratio Integer) -> _!_ _TUP_3 [{{Num u0}}, {{Enum u0}}, (u0 -> Ratio Integer)] [u1, u2, u3] _N_} _F_ _IF_ARGS_ 1 1 C 2 _/\_ u0 -> \ (u1 :: ({{Real u0}}, {{Ix u0}}, u0 -> u0 -> u0, u0 -> u0 -> u0, u0 -> u0 -> u0, u0 -> u0 -> u0, u0 -> u0 -> (u0, u0), u0 -> u0 -> (u0, u0), u0 -> Bool, u0 -> Bool, u0 -> Integer, u0 -> Int)) -> case u1 of { _ALG_ _TUP_12 (u2 :: {{Real u0}}) (u3 :: {{Ix u0}}) (u4 :: u0 -> u0 -> u0) (u5 :: u0 -> u0 -> u0) (u6 :: u0 -> u0 -> u0) (u7 :: u0 -> u0 -> u0) (u8 :: u0 -> u0 -> (u0, u0)) (u9 :: u0 -> u0 -> (u0, u0)) (ua :: u0 -> Bool) (ub :: u0 -> Bool) (uc :: u0 -> Integer) (ud :: u0 -> Int) -> u2; _NO_DEFLT_ } _N_, _A_ 1 _U_ 1 _N_ _S_ "U(AU(LLLL)AAAAAAAAAA)" {_A_ 4 _U_ 2222 _N_ _N_ _F_ _IF_ARGS_ 1 4 XXXX 5 _/\_ u0 -> \ (u1 :: {{Ord u0}}) (u2 :: (u0, u0) -> [u0]) (u3 :: (u0, u0) -> u0 -> Int) (u4 :: (u0, u0) -> u0 -> Bool) -> _!_ _TUP_4 [{{Ord u0}}, ((u0, u0) -> [u0]), ((u0, u0) -> u0 -> Int), ((u0, u0) -> u0 -> Bool)] [u1, u2, u3, u4] _N_} _F_ _IF_ARGS_ 1 1 C 2 _/\_ u0 -> \ (u1 :: ({{Real u0}}, {{Ix u0}}, u0 -> u0 -> u0, u0 -> u0 -> u0, u0 -> u0 -> u0, u0 -> u0 -> u0, u0 -> u0 -> (u0, u0), u0 -> u0 -> (u0, u0), u0 -> Bool, u0 -> Bool, u0 -> Integer, u0 -> Int)) -> case u1 of { _ALG_ _TUP_12 (u2 :: {{Real u0}}) (u3 :: {{Ix u0}}) (u4 :: u0 -> u0 -> u0) (u5 :: u0 -> u0 -> u0) (u6 :: u0 -> u0 -> u0) (u7 :: u0 -> u0 -> u0) (u8 :: u0 -> u0 -> (u0, u0)) (u9 :: u0 -> u0 -> (u0, u0)) (ua :: u0 -> Bool) (ub :: u0 -> Bool) (uc :: u0 -> Integer) (ud :: u0 -> Int) -> u3; _NO_DEFLT_ } _N_ #-} where
quot :: a -> a -> a
{-# GHC_PRAGMA {-meth-} _A_ 1 _U_ 122 _N_ _S_ "U(AASAAAAAAAAA)" {_A_ 1 _U_ 122 _N_ _N_ _F_ _IF_ARGS_ 1 1 X 1 _/\_ u0 -> \ (u1 :: u0 -> u0 -> u0) -> u1 _N_} _F_ _IF_ARGS_ 1 1 C 2 _/\_ u0 -> \ (u1 :: ({{Real u0}}, {{Ix u0}}, u0 -> u0 -> u0, u0 -> u0 -> u0, u0 -> u0 -> u0, u0 -> u0 -> u0, u0 -> u0 -> (u0, u0), u0 -> u0 -> (u0, u0), u0 -> Bool, u0 -> Bool, u0 -> Integer, u0 -> Int)) -> case u1 of { _ALG_ _TUP_12 (u2 :: {{Real u0}}) (u3 :: {{Ix u0}}) (u4 :: u0 -> u0 -> u0) (u5 :: u0 -> u0 -> u0) (u6 :: u0 -> u0 -> u0) (u7 :: u0 -> u0 -> u0) (u8 :: u0 -> u0 -> (u0, u0)) (u9 :: u0 -> u0 -> (u0, u0)) (ua :: u0 -> Bool) (ub :: u0 -> Bool) (uc :: u0 -> Integer) (ud :: u0 -> Int) -> u4; _NO_DEFLT_ } _N_
{-defm-} _A_ 3 _U_ 122 _N_ _S_ "U(AAAAAAASAAAA)LL" {_A_ 3 _U_ 122 _N_ _N_ _F_ _IF_ARGS_ 1 3 XXX 5 _/\_ u0 -> \ (u1 :: u0 -> u0 -> (u0, u0)) (u2 :: u0) (u3 :: u0) -> case _APP_ u1 [ u2, u3 ] of { _ALG_ _TUP_2 (u4 :: u0) (u5 :: u0) -> u5; _NO_DEFLT_ } _N_} _F_ _IF_ARGS_ 1 3 CXX 6 _/\_ u0 -> \ (u1 :: {{Integral u0}}) (u2 :: u0) (u3 :: u0) -> case case u1 of { _ALG_ _TUP_12 (u4 :: {{Real u0}}) (u5 :: {{Ix u0}}) (u6 :: u0 -> u0 -> u0) (u7 :: u0 -> u0 -> u0) (u8 :: u0 -> u0 -> u0) (u9 :: u0 -> u0 -> u0) (ua :: u0 -> u0 -> (u0, u0)) (ub :: u0 -> u0 -> (u0, u0)) (uc :: u0 -> Bool) (ud :: u0 -> Bool) (ue :: u0 -> Integer) (uf :: u0 -> Int) -> _APP_ ub [ u2, u3 ]; _NO_DEFLT_ } of { _ALG_ _TUP_2 (ug :: u0) (uh :: u0) -> uh; _NO_DEFLT_ } _N_ #-}
quotRem :: a -> a -> (a, a)
{-# GHC_PRAGMA {-meth-} _A_ 1 _U_ 122 _N_ _S_ "U(AAAAAASAAAAA)" {_A_ 1 _U_ 122 _N_ _N_ _F_ _IF_ARGS_ 1 1 X 1 _/\_ u0 -> \ (u1 :: u0 -> u0 -> (u0, u0)) -> u1 _N_} _F_ _IF_ARGS_ 1 1 C 2 _/\_ u0 -> \ (u1 :: ({{Real u0}}, {{Ix u0}}, u0 -> u0 -> u0, u0 -> u0 -> u0, u0 -> u0 -> u0, u0 -> u0 -> u0, u0 -> u0 -> (u0, u0), u0 -> u0 -> (u0, u0), u0 -> Bool, u0 -> Bool, u0 -> Integer, u0 -> Int)) -> case u1 of { _ALG_ _TUP_12 (u2 :: {{Real u0}}) (u3 :: {{Ix u0}}) (u4 :: u0 -> u0 -> u0) (u5 :: u0 -> u0 -> u0) (u6 :: u0 -> u0 -> u0) (u7 :: u0 -> u0 -> u0) (u8 :: u0 -> u0 -> (u0, u0)) (u9 :: u0 -> u0 -> (u0, u0)) (ua :: u0 -> Bool) (ub :: u0 -> Bool) (uc :: u0 -> Integer) (ud :: u0 -> Int) -> u8; _NO_DEFLT_ } _N_
- {-defm-} _A_ 3 _U_ 022 _N_ _S_ _!_ _F_ _IF_ARGS_ 1 3 XXX 4 _/\_ u0 -> \ (u1 :: {{Integral u0}}) (u2 :: u0) (u3 :: u0) -> _APP_ _TYAPP_ patError# { (u0 -> u0 -> (u0, u0)) } [ _NOREP_S_ "%DPreludeCore.Integral.quotRem\"", u2, u3 ] _N_ #-}
+ {-defm-} _A_ 3 _U_ 022 _N_ _S_ _!_ _N_ _N_ #-}
divMod :: a -> a -> (a, a)
{-# GHC_PRAGMA {-meth-} _A_ 1 _U_ 122 _N_ _S_ "U(AAAAAAASAAAA)" {_A_ 1 _U_ 122 _N_ _N_ _F_ _IF_ARGS_ 1 1 X 1 _/\_ u0 -> \ (u1 :: u0 -> u0 -> (u0, u0)) -> u1 _N_} _F_ _IF_ARGS_ 1 1 C 2 _/\_ u0 -> \ (u1 :: ({{Real u0}}, {{Ix u0}}, u0 -> u0 -> u0, u0 -> u0 -> u0, u0 -> u0 -> u0, u0 -> u0 -> u0, u0 -> u0 -> (u0, u0), u0 -> u0 -> (u0, u0), u0 -> Bool, u0 -> Bool, u0 -> Integer, u0 -> Int)) -> case u1 of { _ALG_ _TUP_12 (u2 :: {{Real u0}}) (u3 :: {{Ix u0}}) (u4 :: u0 -> u0 -> u0) (u5 :: u0 -> u0 -> u0) (u6 :: u0 -> u0 -> u0) (u7 :: u0 -> u0 -> u0) (u8 :: u0 -> u0 -> (u0, u0)) (u9 :: u0 -> u0 -> (u0, u0)) (ua :: u0 -> Bool) (ub :: u0 -> Bool) (uc :: u0 -> Integer) (ud :: u0 -> Int) -> u9; _NO_DEFLT_ } _N_
- {-defm-} _A_ 1 _U_ 122 _N_ _S_ "U(U(U(U(SA)ALLALALLA)AA)AAAAALAAAAA)" {_A_ 2 _U_ 1222 _N_ _N_ _N_ _N_} _N_ _N_ #-}
+ {-defm-} _A_ 1 _U_ 122 _N_ _S_ "U(U(U(U(SA)ALLALALAL)AA)AAAAALAAAAA)" {_A_ 2 _U_ 1222 _N_ _N_ _N_ _N_} _N_ _N_ #-}
even :: a -> Bool
{-# GHC_PRAGMA {-meth-} _A_ 1 _U_ 12 _N_ _S_ "U(AAAAAAAASAAA)" {_A_ 1 _U_ 12 _N_ _N_ _F_ _IF_ARGS_ 1 1 X 1 _/\_ u0 -> \ (u1 :: u0 -> Bool) -> u1 _N_} _F_ _IF_ARGS_ 1 1 C 2 _/\_ u0 -> \ (u1 :: ({{Real u0}}, {{Ix u0}}, u0 -> u0 -> u0, u0 -> u0 -> u0, u0 -> u0 -> u0, u0 -> u0 -> u0, u0 -> u0 -> (u0, u0), u0 -> u0 -> (u0, u0), u0 -> Bool, u0 -> Bool, u0 -> Integer, u0 -> Int)) -> case u1 of { _ALG_ _TUP_12 (u2 :: {{Real u0}}) (u3 :: {{Ix u0}}) (u4 :: u0 -> u0 -> u0) (u5 :: u0 -> u0 -> u0) (u6 :: u0 -> u0 -> u0) (u7 :: u0 -> u0 -> u0) (u8 :: u0 -> u0 -> (u0, u0)) (u9 :: u0 -> u0 -> (u0, u0)) (ua :: u0 -> Bool) (ub :: u0 -> Bool) (uc :: u0 -> Integer) (ud :: u0 -> Int) -> ua; _NO_DEFLT_ } _N_
- {-defm-} _A_ 1 _U_ 12 _N_ _S_ "U(U(U(U(SA)AAAAAAALA)AA)AALAAAAAAAA)" {_A_ 3 _U_ 1212 _N_ _N_ _N_ _N_} _N_ _N_ #-}
+ {-defm-} _A_ 1 _U_ 12 _N_ _S_ "U(U(U(U(SA)AAAAAAAAL)AA)AALAAAAAAAA)" {_A_ 3 _U_ 1212 _N_ _N_ _N_ _N_} _N_ _N_ #-}
odd :: a -> Bool
{-# GHC_PRAGMA {-meth-} _A_ 1 _U_ 12 _N_ _S_ "U(AAAAAAAAASAA)" {_A_ 1 _U_ 12 _N_ _N_ _F_ _IF_ARGS_ 1 1 X 1 _/\_ u0 -> \ (u1 :: u0 -> Bool) -> u1 _N_} _F_ _IF_ARGS_ 1 1 C 2 _/\_ u0 -> \ (u1 :: ({{Real u0}}, {{Ix u0}}, u0 -> u0 -> u0, u0 -> u0 -> u0, u0 -> u0 -> u0, u0 -> u0 -> u0, u0 -> u0 -> (u0, u0), u0 -> u0 -> (u0, u0), u0 -> Bool, u0 -> Bool, u0 -> Integer, u0 -> Int)) -> case u1 of { _ALG_ _TUP_12 (u2 :: {{Real u0}}) (u3 :: {{Ix u0}}) (u4 :: u0 -> u0 -> u0) (u5 :: u0 -> u0 -> u0) (u6 :: u0 -> u0 -> u0) (u7 :: u0 -> u0 -> u0) (u8 :: u0 -> u0 -> (u0, u0)) (u9 :: u0 -> u0 -> (u0, u0)) (ua :: u0 -> Bool) (ub :: u0 -> Bool) (uc :: u0 -> Integer) (ud :: u0 -> Int) -> ub; _NO_DEFLT_ } _N_
- {-defm-} _A_ 1 _U_ 12 _N_ _S_ "U(U(U(U(AS)AAAAAAALA)AA)AALAAAAAAAA)" {_A_ 3 _U_ 1212 _N_ _N_ _N_ _N_} _N_ _N_ #-}
+ {-defm-} _A_ 1 _U_ 12 _N_ _S_ "U(U(U(U(AS)AAAAAAAAL)AA)AALAAAAAAAA)" {_A_ 3 _U_ 1212 _N_ _N_ _N_ _N_} _N_ _N_ #-}
toInteger :: a -> Integer
{-# GHC_PRAGMA {-meth-} _A_ 1 _U_ 12 _N_ _S_ "U(AAAAAAAAAASA)" {_A_ 1 _U_ 12 _N_ _N_ _F_ _IF_ARGS_ 1 1 X 1 _/\_ u0 -> \ (u1 :: u0 -> Integer) -> u1 _N_} _F_ _IF_ARGS_ 1 1 C 2 _/\_ u0 -> \ (u1 :: ({{Real u0}}, {{Ix u0}}, u0 -> u0 -> u0, u0 -> u0 -> u0, u0 -> u0 -> u0, u0 -> u0 -> u0, u0 -> u0 -> (u0, u0), u0 -> u0 -> (u0, u0), u0 -> Bool, u0 -> Bool, u0 -> Integer, u0 -> Int)) -> case u1 of { _ALG_ _TUP_12 (u2 :: {{Real u0}}) (u3 :: {{Ix u0}}) (u4 :: u0 -> u0 -> u0) (u5 :: u0 -> u0 -> u0) (u6 :: u0 -> u0 -> u0) (u7 :: u0 -> u0 -> u0) (u8 :: u0 -> u0 -> (u0, u0)) (u9 :: u0 -> u0 -> (u0, u0)) (ua :: u0 -> Bool) (ub :: u0 -> Bool) (uc :: u0 -> Integer) (ud :: u0 -> Int) -> uc; _NO_DEFLT_ } _N_
- {-defm-} _A_ 2 _U_ 02 _N_ _S_ _!_ _F_ _IF_ARGS_ 1 2 XX 3 _/\_ u0 -> \ (u1 :: {{Integral u0}}) (u2 :: u0) -> _APP_ _TYAPP_ patError# { (u0 -> Integer) } [ _NOREP_S_ "%DPreludeCore.Integral.toInteger\"", u2 ] _N_ #-}
+ {-defm-} _A_ 2 _U_ 02 _N_ _S_ _!_ _N_ _N_ #-}
toInt :: a -> Int
{-# GHC_PRAGMA {-meth-} _A_ 1 _U_ 12 _N_ _S_ "U(AAAAAAAAAAAS)" {_A_ 1 _U_ 12 _N_ _N_ _F_ _IF_ARGS_ 1 1 X 1 _/\_ u0 -> \ (u1 :: u0 -> Int) -> u1 _N_} _F_ _IF_ARGS_ 1 1 C 2 _/\_ u0 -> \ (u1 :: ({{Real u0}}, {{Ix u0}}, u0 -> u0 -> u0, u0 -> u0 -> u0, u0 -> u0 -> u0, u0 -> u0 -> u0, u0 -> u0 -> (u0, u0), u0 -> u0 -> (u0, u0), u0 -> Bool, u0 -> Bool, u0 -> Integer, u0 -> Int)) -> case u1 of { _ALG_ _TUP_12 (u2 :: {{Real u0}}) (u3 :: {{Ix u0}}) (u4 :: u0 -> u0 -> u0) (u5 :: u0 -> u0 -> u0) (u6 :: u0 -> u0 -> u0) (u7 :: u0 -> u0 -> u0) (u8 :: u0 -> u0 -> (u0, u0)) (u9 :: u0 -> u0 -> (u0, u0)) (ua :: u0 -> Bool) (ub :: u0 -> Bool) (uc :: u0 -> Integer) (ud :: u0 -> Int) -> ud; _NO_DEFLT_ } _N_
- {-defm-} _A_ 2 _U_ 02 _N_ _S_ _!_ _F_ _IF_ARGS_ 1 2 XX 3 _/\_ u0 -> \ (u1 :: {{Integral u0}}) (u2 :: u0) -> _APP_ _TYAPP_ patError# { (u0 -> Int) } [ _NOREP_S_ "%DPreludeCore.Integral.toInt\"", u2 ] _N_ #-}
+ {-defm-} _A_ 2 _U_ 02 _N_ _S_ _!_ _N_ _N_ #-}
class (Ord a) => Ix a {-# GHC_PRAGMA {-superdicts-} _A_ 1 _U_ 1 _N_ _S_ "U(U(LLLLLLLL)AAA)" {_A_ 1 _U_ 1 _N_ _N_ _F_ _IF_ARGS_ 1 1 X 1 _/\_ u0 -> \ (u1 :: {{Ord u0}}) -> u1 _N_} _F_ _IF_ARGS_ 1 1 C 2 _/\_ u0 -> \ (u1 :: ({{Ord u0}}, (u0, u0) -> [u0], (u0, u0) -> u0 -> Int, (u0, u0) -> u0 -> Bool)) -> case u1 of { _ALG_ _TUP_4 (u2 :: {{Ord u0}}) (u3 :: (u0, u0) -> [u0]) (u4 :: (u0, u0) -> u0 -> Int) (u5 :: (u0, u0) -> u0 -> Bool) -> u2; _NO_DEFLT_ } _N_ #-} where
range :: (a, a) -> [a]
{-# GHC_PRAGMA {-meth-} _A_ 1 _U_ 12 _N_ _S_ "U(ASAA)" {_A_ 1 _U_ 12 _N_ _N_ _F_ _IF_ARGS_ 1 1 X 1 _/\_ u0 -> \ (u1 :: (u0, u0) -> [u0]) -> u1 _N_} _F_ _IF_ARGS_ 1 1 C 2 _/\_ u0 -> \ (u1 :: ({{Ord u0}}, (u0, u0) -> [u0], (u0, u0) -> u0 -> Int, (u0, u0) -> u0 -> Bool)) -> case u1 of { _ALG_ _TUP_4 (u2 :: {{Ord u0}}) (u3 :: (u0, u0) -> [u0]) (u4 :: (u0, u0) -> u0 -> Int) (u5 :: (u0, u0) -> u0 -> Bool) -> u3; _NO_DEFLT_ } _N_
- {-defm-} _A_ 2 _U_ 02 _N_ _S_ _!_ _F_ _IF_ARGS_ 1 2 XX 3 _/\_ u0 -> \ (u1 :: {{Ix u0}}) (u2 :: (u0, u0)) -> _APP_ _TYAPP_ patError# { ((u0, u0) -> [u0]) } [ _NOREP_S_ "%DPreludeCore.Ix.range\"", u2 ] _N_ #-}
+ {-defm-} _A_ 2 _U_ 02 _N_ _S_ _!_ _N_ _N_ #-}
index :: (a, a) -> a -> Int
{-# GHC_PRAGMA {-meth-} _A_ 1 _U_ 122 _N_ _S_ "U(AASA)" {_A_ 1 _U_ 122 _N_ _N_ _F_ _IF_ARGS_ 1 1 X 1 _/\_ u0 -> \ (u1 :: (u0, u0) -> u0 -> Int) -> u1 _N_} _F_ _IF_ARGS_ 1 1 C 2 _/\_ u0 -> \ (u1 :: ({{Ord u0}}, (u0, u0) -> [u0], (u0, u0) -> u0 -> Int, (u0, u0) -> u0 -> Bool)) -> case u1 of { _ALG_ _TUP_4 (u2 :: {{Ord u0}}) (u3 :: (u0, u0) -> [u0]) (u4 :: (u0, u0) -> u0 -> Int) (u5 :: (u0, u0) -> u0 -> Bool) -> u4; _NO_DEFLT_ } _N_
- {-defm-} _A_ 3 _U_ 022 _N_ _S_ _!_ _F_ _IF_ARGS_ 1 3 XXX 4 _/\_ u0 -> \ (u1 :: {{Ix u0}}) (u2 :: (u0, u0)) (u3 :: u0) -> _APP_ _TYAPP_ patError# { ((u0, u0) -> u0 -> Int) } [ _NOREP_S_ "%DPreludeCore.Ix.index\"", u2, u3 ] _N_ #-}
+ {-defm-} _A_ 3 _U_ 022 _N_ _S_ _!_ _N_ _N_ #-}
inRange :: (a, a) -> a -> Bool
{-# GHC_PRAGMA {-meth-} _A_ 1 _U_ 122 _N_ _S_ "U(AAAS)" {_A_ 1 _U_ 122 _N_ _N_ _F_ _IF_ARGS_ 1 1 X 1 _/\_ u0 -> \ (u1 :: (u0, u0) -> u0 -> Bool) -> u1 _N_} _F_ _IF_ARGS_ 1 1 C 2 _/\_ u0 -> \ (u1 :: ({{Ord u0}}, (u0, u0) -> [u0], (u0, u0) -> u0 -> Int, (u0, u0) -> u0 -> Bool)) -> case u1 of { _ALG_ _TUP_4 (u2 :: {{Ord u0}}) (u3 :: (u0, u0) -> [u0]) (u4 :: (u0, u0) -> u0 -> Int) (u5 :: (u0, u0) -> u0 -> Bool) -> u5; _NO_DEFLT_ } _N_
- {-defm-} _A_ 3 _U_ 022 _N_ _S_ _!_ _F_ _IF_ARGS_ 1 3 XXX 4 _/\_ u0 -> \ (u1 :: {{Ix u0}}) (u2 :: (u0, u0)) (u3 :: u0) -> _APP_ _TYAPP_ patError# { ((u0, u0) -> u0 -> Bool) } [ _NOREP_S_ "%DPreludeCore.Ix.inRange\"", u2, u3 ] _N_ #-}
+ {-defm-} _A_ 3 _U_ 022 _N_ _S_ _!_ _N_ _N_ #-}
class (Eq a, Text a) => Num a {-# GHC_PRAGMA {-superdicts-} _A_ 1 _U_ 1 _N_ _S_ "U(U(LL)AAAAAAAAA)" {_A_ 2 _U_ 22 _N_ _N_ _F_ _IF_ARGS_ 1 2 XX 3 _/\_ u0 -> \ (u1 :: u0 -> u0 -> Bool) (u2 :: u0 -> u0 -> Bool) -> _!_ _TUP_2 [(u0 -> u0 -> Bool), (u0 -> u0 -> Bool)] [u1, u2] _N_} _F_ _IF_ARGS_ 1 1 C 2 _/\_ u0 -> \ (u1 :: ({{Eq u0}}, {{Text u0}}, u0 -> u0 -> u0, u0 -> u0 -> u0, u0 -> u0 -> u0, u0 -> u0, u0 -> u0, u0 -> u0, Integer -> u0, Int -> u0)) -> case u1 of { _ALG_ _TUP_10 (u2 :: {{Eq u0}}) (u3 :: {{Text u0}}) (u4 :: u0 -> u0 -> u0) (u5 :: u0 -> u0 -> u0) (u6 :: u0 -> u0 -> u0) (u7 :: u0 -> u0) (u8 :: u0 -> u0) (u9 :: u0 -> u0) (ua :: Integer -> u0) (ub :: Int -> u0) -> u2; _NO_DEFLT_ } _N_, _A_ 1 _U_ 1 _N_ _S_ "U(AU(LLLL)AAAAAAAA)" {_A_ 4 _U_ 2222 _N_ _N_ _F_ _IF_ARGS_ 1 4 XXXX 5 _/\_ u0 -> \ (u1 :: Int -> [Char] -> [(u0, [Char])]) (u2 :: Int -> u0 -> [Char] -> [Char]) (u3 :: [Char] -> [([u0], [Char])]) (u4 :: [u0] -> [Char] -> [Char]) -> _!_ _TUP_4 [(Int -> [Char] -> [(u0, [Char])]), (Int -> u0 -> [Char] -> [Char]), ([Char] -> [([u0], [Char])]), ([u0] -> [Char] -> [Char])] [u1, u2, u3, u4] _N_} _F_ _IF_ARGS_ 1 1 C 2 _/\_ u0 -> \ (u1 :: ({{Eq u0}}, {{Text u0}}, u0 -> u0 -> u0, u0 -> u0 -> u0, u0 -> u0 -> u0, u0 -> u0, u0 -> u0, u0 -> u0, Integer -> u0, Int -> u0)) -> case u1 of { _ALG_ _TUP_10 (u2 :: {{Eq u0}}) (u3 :: {{Text u0}}) (u4 :: u0 -> u0 -> u0) (u5 :: u0 -> u0 -> u0) (u6 :: u0 -> u0 -> u0) (u7 :: u0 -> u0) (u8 :: u0 -> u0) (u9 :: u0 -> u0) (ua :: Integer -> u0) (ub :: Int -> u0) -> u3; _NO_DEFLT_ } _N_ #-} where
(+) :: a -> a -> a
{-# GHC_PRAGMA {-meth-} _A_ 1 _U_ 122 _N_ _S_ "U(AASAAAAAAA)" {_A_ 1 _U_ 122 _N_ _N_ _F_ _IF_ARGS_ 1 1 X 1 _/\_ u0 -> \ (u1 :: u0 -> u0 -> u0) -> u1 _N_} _F_ _IF_ARGS_ 1 1 C 2 _/\_ u0 -> \ (u1 :: ({{Eq u0}}, {{Text u0}}, u0 -> u0 -> u0, u0 -> u0 -> u0, u0 -> u0 -> u0, u0 -> u0, u0 -> u0, u0 -> u0, Integer -> u0, Int -> u0)) -> case u1 of { _ALG_ _TUP_10 (u2 :: {{Eq u0}}) (u3 :: {{Text u0}}) (u4 :: u0 -> u0 -> u0) (u5 :: u0 -> u0 -> u0) (u6 :: u0 -> u0 -> u0) (u7 :: u0 -> u0) (u8 :: u0 -> u0) (u9 :: u0 -> u0) (ua :: Integer -> u0) (ub :: Int -> u0) -> u4; _NO_DEFLT_ } _N_
- {-defm-} _A_ 3 _U_ 022 _N_ _S_ _!_ _F_ _IF_ARGS_ 1 3 XXX 4 _/\_ u0 -> \ (u1 :: {{Num u0}}) (u2 :: u0) (u3 :: u0) -> _APP_ _TYAPP_ patError# { (u0 -> u0 -> u0) } [ _NOREP_S_ "%DPreludeCore.Num.(+)\"", u2, u3 ] _N_ #-}
+ {-defm-} _A_ 3 _U_ 022 _N_ _S_ _!_ _N_ _N_ #-}
(-) :: a -> a -> a
{-# GHC_PRAGMA {-meth-} _A_ 1 _U_ 122 _N_ _S_ "U(AAASAAAAAA)" {_A_ 1 _U_ 122 _N_ _N_ _F_ _IF_ARGS_ 1 1 X 1 _/\_ u0 -> \ (u1 :: u0 -> u0 -> u0) -> u1 _N_} _F_ _IF_ARGS_ 1 1 C 2 _/\_ u0 -> \ (u1 :: ({{Eq u0}}, {{Text u0}}, u0 -> u0 -> u0, u0 -> u0 -> u0, u0 -> u0 -> u0, u0 -> u0, u0 -> u0, u0 -> u0, Integer -> u0, Int -> u0)) -> case u1 of { _ALG_ _TUP_10 (u2 :: {{Eq u0}}) (u3 :: {{Text u0}}) (u4 :: u0 -> u0 -> u0) (u5 :: u0 -> u0 -> u0) (u6 :: u0 -> u0 -> u0) (u7 :: u0 -> u0) (u8 :: u0 -> u0) (u9 :: u0 -> u0) (ua :: Integer -> u0) (ub :: Int -> u0) -> u5; _NO_DEFLT_ } _N_
{-defm-} _A_ 3 _U_ 122 _N_ _S_ "U(AASAALAAAA)LL" {_A_ 4 _U_ 1122 _N_ _N_ _F_ _IF_ARGS_ 1 4 XXXX 6 _/\_ u0 -> \ (u1 :: u0 -> u0 -> u0) (u2 :: u0 -> u0) (u3 :: u0) (u4 :: u0) -> let {(u5 :: u0) = _APP_ u2 [ u4 ]} in _APP_ u1 [ u3, u5 ] _N_} _F_ _ALWAYS_ _/\_ u0 -> \ (u1 :: {{Num u0}}) (u2 :: u0) (u3 :: u0) -> case u1 of { _ALG_ _TUP_10 (u4 :: {{Eq u0}}) (u5 :: {{Text u0}}) (u6 :: u0 -> u0 -> u0) (u7 :: u0 -> u0 -> u0) (u8 :: u0 -> u0 -> u0) (u9 :: u0 -> u0) (ua :: u0 -> u0) (ub :: u0 -> u0) (uc :: Integer -> u0) (ud :: Int -> u0) -> let {(ue :: u0) = _APP_ u9 [ u3 ]} in _APP_ u6 [ u2, ue ]; _NO_DEFLT_ } _N_ #-}
(*) :: a -> a -> a
{-# GHC_PRAGMA {-meth-} _A_ 1 _U_ 122 _N_ _S_ "U(AAAASAAAAA)" {_A_ 1 _U_ 122 _N_ _N_ _F_ _IF_ARGS_ 1 1 X 1 _/\_ u0 -> \ (u1 :: u0 -> u0 -> u0) -> u1 _N_} _F_ _IF_ARGS_ 1 1 C 2 _/\_ u0 -> \ (u1 :: ({{Eq u0}}, {{Text u0}}, u0 -> u0 -> u0, u0 -> u0 -> u0, u0 -> u0 -> u0, u0 -> u0, u0 -> u0, u0 -> u0, Integer -> u0, Int -> u0)) -> case u1 of { _ALG_ _TUP_10 (u2 :: {{Eq u0}}) (u3 :: {{Text u0}}) (u4 :: u0 -> u0 -> u0) (u5 :: u0 -> u0 -> u0) (u6 :: u0 -> u0 -> u0) (u7 :: u0 -> u0) (u8 :: u0 -> u0) (u9 :: u0 -> u0) (ua :: Integer -> u0) (ub :: Int -> u0) -> u6; _NO_DEFLT_ } _N_
- {-defm-} _A_ 3 _U_ 022 _N_ _S_ _!_ _F_ _IF_ARGS_ 1 3 XXX 4 _/\_ u0 -> \ (u1 :: {{Num u0}}) (u2 :: u0) (u3 :: u0) -> _APP_ _TYAPP_ patError# { (u0 -> u0 -> u0) } [ _NOREP_S_ "%DPreludeCore.Num.(*)\"", u2, u3 ] _N_ #-}
+ {-defm-} _A_ 3 _U_ 022 _N_ _S_ _!_ _N_ _N_ #-}
negate :: a -> a
{-# GHC_PRAGMA {-meth-} _A_ 1 _U_ 12 _N_ _S_ "U(AAAAASAAAA)" {_A_ 1 _U_ 12 _N_ _N_ _F_ _IF_ARGS_ 1 1 X 1 _/\_ u0 -> \ (u1 :: u0 -> u0) -> u1 _N_} _F_ _IF_ARGS_ 1 1 C 2 _/\_ u0 -> \ (u1 :: ({{Eq u0}}, {{Text u0}}, u0 -> u0 -> u0, u0 -> u0 -> u0, u0 -> u0 -> u0, u0 -> u0, u0 -> u0, u0 -> u0, Integer -> u0, Int -> u0)) -> case u1 of { _ALG_ _TUP_10 (u2 :: {{Eq u0}}) (u3 :: {{Text u0}}) (u4 :: u0 -> u0 -> u0) (u5 :: u0 -> u0 -> u0) (u6 :: u0 -> u0 -> u0) (u7 :: u0 -> u0) (u8 :: u0 -> u0) (u9 :: u0 -> u0) (ua :: Integer -> u0) (ub :: Int -> u0) -> u7; _NO_DEFLT_ } _N_
- {-defm-} _A_ 2 _U_ 02 _N_ _S_ _!_ _F_ _IF_ARGS_ 1 2 XX 3 _/\_ u0 -> \ (u1 :: {{Num u0}}) (u2 :: u0) -> _APP_ _TYAPP_ patError# { (u0 -> u0) } [ _NOREP_S_ "%DPreludeCore.Num.negate\"", u2 ] _N_ #-}
+ {-defm-} _A_ 2 _U_ 02 _N_ _S_ _!_ _N_ _N_ #-}
abs :: a -> a
{-# GHC_PRAGMA {-meth-} _A_ 1 _U_ 12 _N_ _S_ "U(AAAAAASAAA)" {_A_ 1 _U_ 12 _N_ _N_ _F_ _IF_ARGS_ 1 1 X 1 _/\_ u0 -> \ (u1 :: u0 -> u0) -> u1 _N_} _F_ _IF_ARGS_ 1 1 C 2 _/\_ u0 -> \ (u1 :: ({{Eq u0}}, {{Text u0}}, u0 -> u0 -> u0, u0 -> u0 -> u0, u0 -> u0 -> u0, u0 -> u0, u0 -> u0, u0 -> u0, Integer -> u0, Int -> u0)) -> case u1 of { _ALG_ _TUP_10 (u2 :: {{Eq u0}}) (u3 :: {{Text u0}}) (u4 :: u0 -> u0 -> u0) (u5 :: u0 -> u0 -> u0) (u6 :: u0 -> u0 -> u0) (u7 :: u0 -> u0) (u8 :: u0 -> u0) (u9 :: u0 -> u0) (ua :: Integer -> u0) (ub :: Int -> u0) -> u8; _NO_DEFLT_ } _N_
- {-defm-} _A_ 2 _U_ 02 _N_ _S_ _!_ _F_ _IF_ARGS_ 1 2 XX 3 _/\_ u0 -> \ (u1 :: {{Num u0}}) (u2 :: u0) -> _APP_ _TYAPP_ patError# { (u0 -> u0) } [ _NOREP_S_ "%DPreludeCore.Num.abs\"", u2 ] _N_ #-}
+ {-defm-} _A_ 2 _U_ 02 _N_ _S_ _!_ _N_ _N_ #-}
signum :: a -> a
{-# GHC_PRAGMA {-meth-} _A_ 1 _U_ 12 _N_ _S_ "U(AAAAAAASAA)" {_A_ 1 _U_ 12 _N_ _N_ _F_ _IF_ARGS_ 1 1 X 1 _/\_ u0 -> \ (u1 :: u0 -> u0) -> u1 _N_} _F_ _IF_ARGS_ 1 1 C 2 _/\_ u0 -> \ (u1 :: ({{Eq u0}}, {{Text u0}}, u0 -> u0 -> u0, u0 -> u0 -> u0, u0 -> u0 -> u0, u0 -> u0, u0 -> u0, u0 -> u0, Integer -> u0, Int -> u0)) -> case u1 of { _ALG_ _TUP_10 (u2 :: {{Eq u0}}) (u3 :: {{Text u0}}) (u4 :: u0 -> u0 -> u0) (u5 :: u0 -> u0 -> u0) (u6 :: u0 -> u0 -> u0) (u7 :: u0 -> u0) (u8 :: u0 -> u0) (u9 :: u0 -> u0) (ua :: Integer -> u0) (ub :: Int -> u0) -> u9; _NO_DEFLT_ } _N_
- {-defm-} _A_ 2 _U_ 02 _N_ _S_ _!_ _F_ _IF_ARGS_ 1 2 XX 3 _/\_ u0 -> \ (u1 :: {{Num u0}}) (u2 :: u0) -> _APP_ _TYAPP_ patError# { (u0 -> u0) } [ _NOREP_S_ "%DPreludeCore.Num.signum\"", u2 ] _N_ #-}
+ {-defm-} _A_ 2 _U_ 02 _N_ _S_ _!_ _N_ _N_ #-}
fromInteger :: Integer -> a
{-# GHC_PRAGMA {-meth-} _A_ 1 _U_ 12 _N_ _S_ "U(AAAAAAAASA)" {_A_ 1 _U_ 12 _N_ _N_ _F_ _IF_ARGS_ 1 1 X 1 _/\_ u0 -> \ (u1 :: Integer -> u0) -> u1 _N_} _F_ _IF_ARGS_ 1 1 C 2 _/\_ u0 -> \ (u1 :: ({{Eq u0}}, {{Text u0}}, u0 -> u0 -> u0, u0 -> u0 -> u0, u0 -> u0 -> u0, u0 -> u0, u0 -> u0, u0 -> u0, Integer -> u0, Int -> u0)) -> case u1 of { _ALG_ _TUP_10 (u2 :: {{Eq u0}}) (u3 :: {{Text u0}}) (u4 :: u0 -> u0 -> u0) (u5 :: u0 -> u0 -> u0) (u6 :: u0 -> u0 -> u0) (u7 :: u0 -> u0) (u8 :: u0 -> u0) (u9 :: u0 -> u0) (ua :: Integer -> u0) (ub :: Int -> u0) -> ua; _NO_DEFLT_ } _N_
- {-defm-} _A_ 2 _U_ 02 _N_ _S_ _!_ _F_ _IF_ARGS_ 1 2 XX 3 _/\_ u0 -> \ (u1 :: {{Num u0}}) (u2 :: Integer) -> _APP_ _TYAPP_ patError# { (Integer -> u0) } [ _NOREP_S_ "%DPreludeCore.Num.fromInteger\"", u2 ] _N_ #-}
+ {-defm-} _A_ 2 _U_ 02 _N_ _S_ _!_ _N_ _N_ #-}
fromInt :: Int -> a
{-# GHC_PRAGMA {-meth-} _A_ 1 _U_ 12 _N_ _S_ "U(AAAAAAAAAS)" {_A_ 1 _U_ 12 _N_ _N_ _F_ _IF_ARGS_ 1 1 X 1 _/\_ u0 -> \ (u1 :: Int -> u0) -> u1 _N_} _F_ _IF_ARGS_ 1 1 C 2 _/\_ u0 -> \ (u1 :: ({{Eq u0}}, {{Text u0}}, u0 -> u0 -> u0, u0 -> u0 -> u0, u0 -> u0 -> u0, u0 -> u0, u0 -> u0, u0 -> u0, Integer -> u0, Int -> u0)) -> case u1 of { _ALG_ _TUP_10 (u2 :: {{Eq u0}}) (u3 :: {{Text u0}}) (u4 :: u0 -> u0 -> u0) (u5 :: u0 -> u0 -> u0) (u6 :: u0 -> u0 -> u0) (u7 :: u0 -> u0) (u8 :: u0 -> u0) (u9 :: u0 -> u0) (ua :: Integer -> u0) (ub :: Int -> u0) -> ub; _NO_DEFLT_ } _N_
{-defm-} _A_ 2 _U_ 11 _N_ _S_ "U(AAAAAAAASA)L" {_A_ 2 _U_ 11 _N_ _N_ _F_ _IF_ARGS_ 1 2 XC 5 _/\_ u0 -> \ (u1 :: Integer -> u0) (u2 :: Int) -> let {(u4 :: Integer) = case u2 of { _ALG_ I# (u3 :: Int#) -> _#_ int2Integer# [] [u3]; _NO_DEFLT_ }} in _APP_ u1 [ u4 ] _N_} _F_ _IF_ARGS_ 1 2 CC 6 _/\_ u0 -> \ (u1 :: {{Num u0}}) (u2 :: Int) -> let {(u4 :: Integer) = case u2 of { _ALG_ I# (u3 :: Int#) -> _#_ int2Integer# [] [u3]; _NO_DEFLT_ }} in case u1 of { _ALG_ _TUP_10 (u5 :: {{Eq u0}}) (u6 :: {{Text u0}}) (u7 :: u0 -> u0 -> u0) (u8 :: u0 -> u0 -> u0) (u9 :: u0 -> u0 -> u0) (ua :: u0 -> u0) (ub :: u0 -> u0) (uc :: u0 -> u0) (ud :: Integer -> u0) (ue :: Int -> u0) -> _APP_ ud [ u4 ]; _NO_DEFLT_ } _N_ #-}
{-defm-} _A_ 3 _U_ 122 _N_ _S_ "U(LASAAAAA)LL" {_A_ 4 _U_ 1122 _N_ _N_ _N_ _N_} _N_ _N_ #-}
(<=) :: a -> a -> Bool
{-# GHC_PRAGMA {-meth-} _A_ 1 _U_ 122 _N_ _S_ "U(AASAAAAA)" {_A_ 1 _U_ 122 _N_ _N_ _F_ _IF_ARGS_ 1 1 X 1 _/\_ u0 -> \ (u1 :: u0 -> u0 -> Bool) -> u1 _N_} _F_ _IF_ARGS_ 1 1 C 2 _/\_ u0 -> \ (u1 :: ({{Eq u0}}, u0 -> u0 -> Bool, u0 -> u0 -> Bool, u0 -> u0 -> Bool, u0 -> u0 -> Bool, u0 -> u0 -> u0, u0 -> u0 -> u0, u0 -> u0 -> _CMP_TAG)) -> case u1 of { _ALG_ _TUP_8 (u2 :: {{Eq u0}}) (u3 :: u0 -> u0 -> Bool) (u4 :: u0 -> u0 -> Bool) (u5 :: u0 -> u0 -> Bool) (u6 :: u0 -> u0 -> Bool) (u7 :: u0 -> u0 -> u0) (u8 :: u0 -> u0 -> u0) (u9 :: u0 -> u0 -> _CMP_TAG) -> u4; _NO_DEFLT_ } _N_
- {-defm-} _A_ 3 _U_ 022 _N_ _S_ _!_ _F_ _IF_ARGS_ 1 3 XXX 4 _/\_ u0 -> \ (u1 :: {{Ord u0}}) (u2 :: u0) (u3 :: u0) -> _APP_ _TYAPP_ patError# { (u0 -> u0 -> Bool) } [ _NOREP_S_ "%DPreludeCore.Ord.(<=)\"", u2, u3 ] _N_ #-}
+ {-defm-} _A_ 3 _U_ 022 _N_ _S_ _!_ _N_ _N_ #-}
(>=) :: a -> a -> Bool
{-# GHC_PRAGMA {-meth-} _A_ 1 _U_ 122 _N_ _S_ "U(AAASAAAA)" {_A_ 1 _U_ 122 _N_ _N_ _F_ _IF_ARGS_ 1 1 X 1 _/\_ u0 -> \ (u1 :: u0 -> u0 -> Bool) -> u1 _N_} _F_ _IF_ARGS_ 1 1 C 2 _/\_ u0 -> \ (u1 :: ({{Eq u0}}, u0 -> u0 -> Bool, u0 -> u0 -> Bool, u0 -> u0 -> Bool, u0 -> u0 -> Bool, u0 -> u0 -> u0, u0 -> u0 -> u0, u0 -> u0 -> _CMP_TAG)) -> case u1 of { _ALG_ _TUP_8 (u2 :: {{Eq u0}}) (u3 :: u0 -> u0 -> Bool) (u4 :: u0 -> u0 -> Bool) (u5 :: u0 -> u0 -> Bool) (u6 :: u0 -> u0 -> Bool) (u7 :: u0 -> u0 -> u0) (u8 :: u0 -> u0 -> u0) (u9 :: u0 -> u0 -> _CMP_TAG) -> u5; _NO_DEFLT_ } _N_
{-defm-} _A_ 3 _U_ 122 _N_ _S_ "U(AASAAAAA)LL" {_A_ 3 _U_ 122 _N_ _N_ _F_ _IF_ARGS_ 1 3 XXX 3 _/\_ u0 -> \ (u1 :: u0 -> u0 -> Bool) (u2 :: u0) (u3 :: u0) -> _APP_ u1 [ u3, u2 ] _N_} _F_ _IF_ARGS_ 1 3 CXX 4 _/\_ u0 -> \ (u1 :: {{Ord u0}}) (u2 :: u0) (u3 :: u0) -> case u1 of { _ALG_ _TUP_8 (u4 :: {{Eq u0}}) (u5 :: u0 -> u0 -> Bool) (u6 :: u0 -> u0 -> Bool) (u7 :: u0 -> u0 -> Bool) (u8 :: u0 -> u0 -> Bool) (u9 :: u0 -> u0 -> u0) (ua :: u0 -> u0 -> u0) (ub :: u0 -> u0 -> _CMP_TAG) -> _APP_ u6 [ u3, u2 ]; _NO_DEFLT_ } _N_ #-}
class (Num a, Enum a) => Real a {-# GHC_PRAGMA {-superdicts-} _A_ 1 _U_ 1 _N_ _S_ "U(U(LLLLLLLLLL)AA)" {_A_ 1 _U_ 1 _N_ _N_ _F_ _IF_ARGS_ 1 1 X 1 _/\_ u0 -> \ (u1 :: {{Num u0}}) -> u1 _N_} _F_ _IF_ARGS_ 1 1 C 2 _/\_ u0 -> \ (u1 :: ({{Num u0}}, {{Enum u0}}, u0 -> Ratio Integer)) -> case u1 of { _ALG_ _TUP_3 (u2 :: {{Num u0}}) (u3 :: {{Enum u0}}) (u4 :: u0 -> Ratio Integer) -> u2; _NO_DEFLT_ } _N_, _A_ 1 _U_ 1 _N_ _S_ "U(AU(LLLLL)A)" {_A_ 5 _U_ 22222 _N_ _N_ _F_ _IF_ARGS_ 1 5 XXXXX 6 _/\_ u0 -> \ (u1 :: {{Ord u0}}) (u2 :: u0 -> [u0]) (u3 :: u0 -> u0 -> [u0]) (u4 :: u0 -> u0 -> [u0]) (u5 :: u0 -> u0 -> u0 -> [u0]) -> _!_ _TUP_5 [{{Ord u0}}, (u0 -> [u0]), (u0 -> u0 -> [u0]), (u0 -> u0 -> [u0]), (u0 -> u0 -> u0 -> [u0])] [u1, u2, u3, u4, u5] _N_} _F_ _IF_ARGS_ 1 1 C 2 _/\_ u0 -> \ (u1 :: ({{Num u0}}, {{Enum u0}}, u0 -> Ratio Integer)) -> case u1 of { _ALG_ _TUP_3 (u2 :: {{Num u0}}) (u3 :: {{Enum u0}}) (u4 :: u0 -> Ratio Integer) -> u3; _NO_DEFLT_ } _N_ #-} where
toRational :: a -> Ratio Integer
{-# GHC_PRAGMA {-meth-} _A_ 1 _U_ 12 _N_ _S_ "U(AAS)" {_A_ 1 _U_ 12 _N_ _N_ _F_ _IF_ARGS_ 1 1 X 1 _/\_ u0 -> \ (u1 :: u0 -> Ratio Integer) -> u1 _N_} _F_ _IF_ARGS_ 1 1 C 2 _/\_ u0 -> \ (u1 :: ({{Num u0}}, {{Enum u0}}, u0 -> Ratio Integer)) -> case u1 of { _ALG_ _TUP_3 (u2 :: {{Num u0}}) (u3 :: {{Enum u0}}) (u4 :: u0 -> Ratio Integer) -> u4; _NO_DEFLT_ } _N_
- {-defm-} _A_ 2 _U_ 02 _N_ _S_ _!_ _F_ _IF_ARGS_ 1 2 XX 3 _/\_ u0 -> \ (u1 :: {{Real u0}}) (u2 :: u0) -> _APP_ _TYAPP_ patError# { (u0 -> Ratio Integer) } [ _NOREP_S_ "%DPreludeCore.Real.toRational\"", u2 ] _N_ #-}
+ {-defm-} _A_ 2 _U_ 02 _N_ _S_ _!_ _N_ _N_ #-}
class (RealFrac a, Floating a) => RealFloat a {-# GHC_PRAGMA {-superdicts-} _A_ 1 _U_ 1 _N_ _S_ "U(U(LLLLLLL)AAAAAAAAA)" {_A_ 1 _U_ 1 _N_ _N_ _F_ _IF_ARGS_ 1 1 X 1 _/\_ u0 -> \ (u1 :: {{RealFrac u0}}) -> u1 _N_} _F_ _IF_ARGS_ 1 1 C 2 _/\_ u0 -> \ (u1 :: ({{RealFrac u0}}, {{Floating u0}}, u0 -> Integer, u0 -> Int, u0 -> (Int, Int), u0 -> (Integer, Int), Integer -> Int -> u0, u0 -> Int, u0 -> u0, Int -> u0 -> u0)) -> case u1 of { _ALG_ _TUP_10 (u2 :: {{RealFrac u0}}) (u3 :: {{Floating u0}}) (u4 :: u0 -> Integer) (u5 :: u0 -> Int) (u6 :: u0 -> (Int, Int)) (u7 :: u0 -> (Integer, Int)) (u8 :: Integer -> Int -> u0) (u9 :: u0 -> Int) (ua :: u0 -> u0) (ub :: Int -> u0 -> u0) -> u2; _NO_DEFLT_ } _N_, _A_ 1 _U_ 1 _N_ _S_ "U(AU(LLLLLLLLLLLLLLLLLLL)AAAAAAAA)" {_A_ 1 _U_ 1 _N_ _N_ _F_ _IF_ARGS_ 1 1 X 1 _/\_ u0 -> \ (u1 :: {{Floating u0}}) -> u1 _N_} _F_ _IF_ARGS_ 1 1 C 2 _/\_ u0 -> \ (u1 :: ({{RealFrac u0}}, {{Floating u0}}, u0 -> Integer, u0 -> Int, u0 -> (Int, Int), u0 -> (Integer, Int), Integer -> Int -> u0, u0 -> Int, u0 -> u0, Int -> u0 -> u0)) -> case u1 of { _ALG_ _TUP_10 (u2 :: {{RealFrac u0}}) (u3 :: {{Floating u0}}) (u4 :: u0 -> Integer) (u5 :: u0 -> Int) (u6 :: u0 -> (Int, Int)) (u7 :: u0 -> (Integer, Int)) (u8 :: Integer -> Int -> u0) (u9 :: u0 -> Int) (ua :: u0 -> u0) (ub :: Int -> u0 -> u0) -> u3; _NO_DEFLT_ } _N_ #-} where
floatRadix :: a -> Integer
{-# GHC_PRAGMA {-meth-} _A_ 1 _U_ 12 _N_ _S_ "U(AASAAAAAAA)" {_A_ 1 _U_ 12 _N_ _N_ _F_ _IF_ARGS_ 1 1 X 1 _/\_ u0 -> \ (u1 :: u0 -> Integer) -> u1 _N_} _F_ _IF_ARGS_ 1 1 C 2 _/\_ u0 -> \ (u1 :: ({{RealFrac u0}}, {{Floating u0}}, u0 -> Integer, u0 -> Int, u0 -> (Int, Int), u0 -> (Integer, Int), Integer -> Int -> u0, u0 -> Int, u0 -> u0, Int -> u0 -> u0)) -> case u1 of { _ALG_ _TUP_10 (u2 :: {{RealFrac u0}}) (u3 :: {{Floating u0}}) (u4 :: u0 -> Integer) (u5 :: u0 -> Int) (u6 :: u0 -> (Int, Int)) (u7 :: u0 -> (Integer, Int)) (u8 :: Integer -> Int -> u0) (u9 :: u0 -> Int) (ua :: u0 -> u0) (ub :: Int -> u0 -> u0) -> u4; _NO_DEFLT_ } _N_
- {-defm-} _A_ 2 _U_ 02 _N_ _S_ _!_ _F_ _IF_ARGS_ 1 2 XX 3 _/\_ u0 -> \ (u1 :: {{RealFloat u0}}) (u2 :: u0) -> _APP_ _TYAPP_ patError# { (u0 -> Integer) } [ _NOREP_S_ "%DPreludeCore.RealFloat.floatRadix\"", u2 ] _N_ #-}
+ {-defm-} _A_ 2 _U_ 02 _N_ _S_ _!_ _N_ _N_ #-}
floatDigits :: a -> Int
{-# GHC_PRAGMA {-meth-} _A_ 1 _U_ 12 _N_ _S_ "U(AAASAAAAAA)" {_A_ 1 _U_ 12 _N_ _N_ _F_ _IF_ARGS_ 1 1 X 1 _/\_ u0 -> \ (u1 :: u0 -> Int) -> u1 _N_} _F_ _IF_ARGS_ 1 1 C 2 _/\_ u0 -> \ (u1 :: ({{RealFrac u0}}, {{Floating u0}}, u0 -> Integer, u0 -> Int, u0 -> (Int, Int), u0 -> (Integer, Int), Integer -> Int -> u0, u0 -> Int, u0 -> u0, Int -> u0 -> u0)) -> case u1 of { _ALG_ _TUP_10 (u2 :: {{RealFrac u0}}) (u3 :: {{Floating u0}}) (u4 :: u0 -> Integer) (u5 :: u0 -> Int) (u6 :: u0 -> (Int, Int)) (u7 :: u0 -> (Integer, Int)) (u8 :: Integer -> Int -> u0) (u9 :: u0 -> Int) (ua :: u0 -> u0) (ub :: Int -> u0 -> u0) -> u5; _NO_DEFLT_ } _N_
- {-defm-} _A_ 2 _U_ 02 _N_ _S_ _!_ _F_ _IF_ARGS_ 1 2 XX 3 _/\_ u0 -> \ (u1 :: {{RealFloat u0}}) (u2 :: u0) -> _APP_ _TYAPP_ patError# { (u0 -> Int) } [ _NOREP_S_ "%DPreludeCore.RealFloat.floatDigits\"", u2 ] _N_ #-}
+ {-defm-} _A_ 2 _U_ 02 _N_ _S_ _!_ _N_ _N_ #-}
floatRange :: a -> (Int, Int)
{-# GHC_PRAGMA {-meth-} _A_ 1 _U_ 12 _N_ _S_ "U(AAAASAAAAA)" {_A_ 1 _U_ 12 _N_ _N_ _F_ _IF_ARGS_ 1 1 X 1 _/\_ u0 -> \ (u1 :: u0 -> (Int, Int)) -> u1 _N_} _F_ _IF_ARGS_ 1 1 C 2 _/\_ u0 -> \ (u1 :: ({{RealFrac u0}}, {{Floating u0}}, u0 -> Integer, u0 -> Int, u0 -> (Int, Int), u0 -> (Integer, Int), Integer -> Int -> u0, u0 -> Int, u0 -> u0, Int -> u0 -> u0)) -> case u1 of { _ALG_ _TUP_10 (u2 :: {{RealFrac u0}}) (u3 :: {{Floating u0}}) (u4 :: u0 -> Integer) (u5 :: u0 -> Int) (u6 :: u0 -> (Int, Int)) (u7 :: u0 -> (Integer, Int)) (u8 :: Integer -> Int -> u0) (u9 :: u0 -> Int) (ua :: u0 -> u0) (ub :: Int -> u0 -> u0) -> u6; _NO_DEFLT_ } _N_
- {-defm-} _A_ 2 _U_ 02 _N_ _S_ _!_ _F_ _IF_ARGS_ 1 2 XX 3 _/\_ u0 -> \ (u1 :: {{RealFloat u0}}) (u2 :: u0) -> _APP_ _TYAPP_ patError# { (u0 -> (Int, Int)) } [ _NOREP_S_ "%DPreludeCore.RealFloat.floatRange\"", u2 ] _N_ #-}
+ {-defm-} _A_ 2 _U_ 02 _N_ _S_ _!_ _N_ _N_ #-}
decodeFloat :: a -> (Integer, Int)
{-# GHC_PRAGMA {-meth-} _A_ 1 _U_ 12 _N_ _S_ "U(AAAAASAAAA)" {_A_ 1 _U_ 12 _N_ _N_ _F_ _IF_ARGS_ 1 1 X 1 _/\_ u0 -> \ (u1 :: u0 -> (Integer, Int)) -> u1 _N_} _F_ _IF_ARGS_ 1 1 C 2 _/\_ u0 -> \ (u1 :: ({{RealFrac u0}}, {{Floating u0}}, u0 -> Integer, u0 -> Int, u0 -> (Int, Int), u0 -> (Integer, Int), Integer -> Int -> u0, u0 -> Int, u0 -> u0, Int -> u0 -> u0)) -> case u1 of { _ALG_ _TUP_10 (u2 :: {{RealFrac u0}}) (u3 :: {{Floating u0}}) (u4 :: u0 -> Integer) (u5 :: u0 -> Int) (u6 :: u0 -> (Int, Int)) (u7 :: u0 -> (Integer, Int)) (u8 :: Integer -> Int -> u0) (u9 :: u0 -> Int) (ua :: u0 -> u0) (ub :: Int -> u0 -> u0) -> u7; _NO_DEFLT_ } _N_
- {-defm-} _A_ 2 _U_ 02 _N_ _S_ _!_ _F_ _IF_ARGS_ 1 2 XX 3 _/\_ u0 -> \ (u1 :: {{RealFloat u0}}) (u2 :: u0) -> _APP_ _TYAPP_ patError# { (u0 -> (Integer, Int)) } [ _NOREP_S_ "%DPreludeCore.RealFloat.decodeFloat\"", u2 ] _N_ #-}
+ {-defm-} _A_ 2 _U_ 02 _N_ _S_ _!_ _N_ _N_ #-}
encodeFloat :: Integer -> Int -> a
{-# GHC_PRAGMA {-meth-} _A_ 1 _U_ 122 _N_ _S_ "U(AAAAAASAAA)" {_A_ 1 _U_ 122 _N_ _N_ _F_ _IF_ARGS_ 1 1 X 1 _/\_ u0 -> \ (u1 :: Integer -> Int -> u0) -> u1 _N_} _F_ _IF_ARGS_ 1 1 C 2 _/\_ u0 -> \ (u1 :: ({{RealFrac u0}}, {{Floating u0}}, u0 -> Integer, u0 -> Int, u0 -> (Int, Int), u0 -> (Integer, Int), Integer -> Int -> u0, u0 -> Int, u0 -> u0, Int -> u0 -> u0)) -> case u1 of { _ALG_ _TUP_10 (u2 :: {{RealFrac u0}}) (u3 :: {{Floating u0}}) (u4 :: u0 -> Integer) (u5 :: u0 -> Int) (u6 :: u0 -> (Int, Int)) (u7 :: u0 -> (Integer, Int)) (u8 :: Integer -> Int -> u0) (u9 :: u0 -> Int) (ua :: u0 -> u0) (ub :: Int -> u0 -> u0) -> u8; _NO_DEFLT_ } _N_
- {-defm-} _A_ 3 _U_ 022 _N_ _S_ _!_ _F_ _IF_ARGS_ 1 3 XXX 4 _/\_ u0 -> \ (u1 :: {{RealFloat u0}}) (u2 :: Integer) (u3 :: Int) -> _APP_ _TYAPP_ patError# { (Integer -> Int -> u0) } [ _NOREP_S_ "%DPreludeCore.RealFloat.encodeFloat\"", u2, u3 ] _N_ #-}
+ {-defm-} _A_ 3 _U_ 022 _N_ _S_ _!_ _N_ _N_ #-}
exponent :: a -> Int
{-# GHC_PRAGMA {-meth-} _A_ 1 _U_ 12 _N_ _S_ "U(AAAAAAASAA)" {_A_ 1 _U_ 12 _N_ _N_ _F_ _IF_ARGS_ 1 1 X 1 _/\_ u0 -> \ (u1 :: u0 -> Int) -> u1 _N_} _F_ _IF_ARGS_ 1 1 C 2 _/\_ u0 -> \ (u1 :: ({{RealFrac u0}}, {{Floating u0}}, u0 -> Integer, u0 -> Int, u0 -> (Int, Int), u0 -> (Integer, Int), Integer -> Int -> u0, u0 -> Int, u0 -> u0, Int -> u0 -> u0)) -> case u1 of { _ALG_ _TUP_10 (u2 :: {{RealFrac u0}}) (u3 :: {{Floating u0}}) (u4 :: u0 -> Integer) (u5 :: u0 -> Int) (u6 :: u0 -> (Int, Int)) (u7 :: u0 -> (Integer, Int)) (u8 :: Integer -> Int -> u0) (u9 :: u0 -> Int) (ua :: u0 -> u0) (ub :: Int -> u0 -> u0) -> u9; _NO_DEFLT_ } _N_
{-defm-} _A_ 2 _U_ 12 _N_ _S_ "U(AAALASAAAA)L" {_A_ 3 _U_ 112 _N_ _N_ _N_ _N_} _N_ _N_ #-}
class (Real a, Fractional a) => RealFrac a {-# GHC_PRAGMA {-superdicts-} _A_ 1 _U_ 1 _N_ _S_ "U(U(LLL)AAAAAA)" {_A_ 3 _U_ 222 _N_ _N_ _F_ _IF_ARGS_ 1 3 XXX 4 _/\_ u0 -> \ (u1 :: {{Num u0}}) (u2 :: {{Enum u0}}) (u3 :: u0 -> Ratio Integer) -> _!_ _TUP_3 [{{Num u0}}, {{Enum u0}}, (u0 -> Ratio Integer)] [u1, u2, u3] _N_} _F_ _IF_ARGS_ 1 1 C 2 _/\_ u0 -> \ (u1 :: ({{Real u0}}, {{Fractional u0}}, (_forall_ z$z1 =>{{Integral z$z1}} -> u0 -> (z$z1, u0)), (_forall_ z$z1 =>{{Integral z$z1}} -> u0 -> z$z1), (_forall_ z$z1 =>{{Integral z$z1}} -> u0 -> z$z1), (_forall_ z$z1 =>{{Integral z$z1}} -> u0 -> z$z1), (_forall_ z$z1 =>{{Integral z$z1}} -> u0 -> z$z1))) -> case u1 of { _ALG_ _TUP_7 (u2 :: {{Real u0}}) (u3 :: {{Fractional u0}}) (u4 :: _forall_ a$z1 =>{{Integral a$z1}} -> u0 -> (a$z1, u0)) (u5 :: _forall_ a$z1 =>{{Integral a$z1}} -> u0 -> a$z1) (u6 :: _forall_ a$z1 =>{{Integral a$z1}} -> u0 -> a$z1) (u7 :: _forall_ a$z1 =>{{Integral a$z1}} -> u0 -> a$z1) (u8 :: _forall_ a$z1 =>{{Integral a$z1}} -> u0 -> a$z1) -> u2; _NO_DEFLT_ } _N_, _A_ 1 _U_ 1 _N_ _S_ "U(AU(LLLL)AAAAA)" {_A_ 4 _U_ 2222 _N_ _N_ _F_ _IF_ARGS_ 1 4 XXXX 5 _/\_ u0 -> \ (u1 :: {{Num u0}}) (u2 :: u0 -> u0 -> u0) (u3 :: u0 -> u0) (u4 :: Ratio Integer -> u0) -> _!_ _TUP_4 [{{Num u0}}, (u0 -> u0 -> u0), (u0 -> u0), (Ratio Integer -> u0)] [u1, u2, u3, u4] _N_} _F_ _IF_ARGS_ 1 1 C 2 _/\_ u0 -> \ (u1 :: ({{Real u0}}, {{Fractional u0}}, (_forall_ z$z1 =>{{Integral z$z1}} -> u0 -> (z$z1, u0)), (_forall_ z$z1 =>{{Integral z$z1}} -> u0 -> z$z1), (_forall_ z$z1 =>{{Integral z$z1}} -> u0 -> z$z1), (_forall_ z$z1 =>{{Integral z$z1}} -> u0 -> z$z1), (_forall_ z$z1 =>{{Integral z$z1}} -> u0 -> z$z1))) -> case u1 of { _ALG_ _TUP_7 (u2 :: {{Real u0}}) (u3 :: {{Fractional u0}}) (u4 :: _forall_ a$z1 =>{{Integral a$z1}} -> u0 -> (a$z1, u0)) (u5 :: _forall_ a$z1 =>{{Integral a$z1}} -> u0 -> a$z1) (u6 :: _forall_ a$z1 =>{{Integral a$z1}} -> u0 -> a$z1) (u7 :: _forall_ a$z1 =>{{Integral a$z1}} -> u0 -> a$z1) (u8 :: _forall_ a$z1 =>{{Integral a$z1}} -> u0 -> a$z1) -> u3; _NO_DEFLT_ } _N_ #-} where
properFraction :: Integral b => a -> (b, a)
{-# GHC_PRAGMA {-meth-} _A_ 2 _U_ 122 _N_ _S_ "U(AASAAAA)L" {_A_ 2 _U_ 122 _N_ _N_ _F_ _IF_ARGS_ 2 2 XX 2 _/\_ u0 u1 -> \ (u2 :: _forall_ a$z1 =>{{Integral a$z1}} -> u0 -> (a$z1, u0)) (u3 :: {{Integral u1}}) -> _APP_ _TYAPP_ u2 { u1 } [ u3 ] _N_} _F_ _IF_ARGS_ 2 2 CX 3 _/\_ u0 u1 -> \ (u2 :: ({{Real u0}}, {{Fractional u0}}, (_forall_ z$z1 =>{{Integral z$z1}} -> u0 -> (z$z1, u0)), (_forall_ z$z1 =>{{Integral z$z1}} -> u0 -> z$z1), (_forall_ z$z1 =>{{Integral z$z1}} -> u0 -> z$z1), (_forall_ z$z1 =>{{Integral z$z1}} -> u0 -> z$z1), (_forall_ z$z1 =>{{Integral z$z1}} -> u0 -> z$z1))) (u3 :: {{Integral u1}}) -> case u2 of { _ALG_ _TUP_7 (u4 :: {{Real u0}}) (u5 :: {{Fractional u0}}) (u6 :: _forall_ a$z1 =>{{Integral a$z1}} -> u0 -> (a$z1, u0)) (u7 :: _forall_ a$z1 =>{{Integral a$z1}} -> u0 -> a$z1) (u8 :: _forall_ a$z1 =>{{Integral a$z1}} -> u0 -> a$z1) (u9 :: _forall_ a$z1 =>{{Integral a$z1}} -> u0 -> a$z1) (ua :: _forall_ a$z1 =>{{Integral a$z1}} -> u0 -> a$z1) -> _APP_ _TYAPP_ u6 { u1 } [ u3 ]; _NO_DEFLT_ } _N_
- {-defm-} _A_ 3 _U_ 002 _N_ _S_ _!_ _F_ _IF_ARGS_ 2 3 XXX 3 _/\_ u0 u1 -> \ (u2 :: {{RealFrac u0}}) (u3 :: {{Integral u1}}) (u4 :: u0) -> _APP_ _TYAPP_ patError# { (u0 -> (u1, u0)) } [ _NOREP_S_ "%DPreludeCore.RealFrac.properFraction\"", u4 ] _N_ #-}
+ {-defm-} _A_ 3 _U_ 002 _N_ _S_ _!_ _N_ _N_ #-}
truncate :: Integral b => a -> b
{-# GHC_PRAGMA {-meth-} _A_ 2 _U_ 122 _N_ _S_ "U(AAASAAA)L" {_A_ 2 _U_ 122 _N_ _N_ _F_ _IF_ARGS_ 2 2 XX 2 _/\_ u0 u1 -> \ (u2 :: _forall_ a$z1 =>{{Integral a$z1}} -> u0 -> a$z1) (u3 :: {{Integral u1}}) -> _APP_ _TYAPP_ u2 { u1 } [ u3 ] _N_} _F_ _IF_ARGS_ 2 2 CX 3 _/\_ u0 u1 -> \ (u2 :: ({{Real u0}}, {{Fractional u0}}, (_forall_ z$z1 =>{{Integral z$z1}} -> u0 -> (z$z1, u0)), (_forall_ z$z1 =>{{Integral z$z1}} -> u0 -> z$z1), (_forall_ z$z1 =>{{Integral z$z1}} -> u0 -> z$z1), (_forall_ z$z1 =>{{Integral z$z1}} -> u0 -> z$z1), (_forall_ z$z1 =>{{Integral z$z1}} -> u0 -> z$z1))) (u3 :: {{Integral u1}}) -> case u2 of { _ALG_ _TUP_7 (u4 :: {{Real u0}}) (u5 :: {{Fractional u0}}) (u6 :: _forall_ a$z1 =>{{Integral a$z1}} -> u0 -> (a$z1, u0)) (u7 :: _forall_ a$z1 =>{{Integral a$z1}} -> u0 -> a$z1) (u8 :: _forall_ a$z1 =>{{Integral a$z1}} -> u0 -> a$z1) (u9 :: _forall_ a$z1 =>{{Integral a$z1}} -> u0 -> a$z1) (ua :: _forall_ a$z1 =>{{Integral a$z1}} -> u0 -> a$z1) -> _APP_ _TYAPP_ u7 { u1 } [ u3 ]; _NO_DEFLT_ } _N_
- {-defm-} _A_ 2 _U_ 122 _N_ _S_ "U(AASAAAA)L" {_A_ 2 _U_ 222 _N_ _N_ _N_ _N_} _N_ _N_ #-}
+ {-defm-} _A_ 2 _U_ 122 _N_ _S_ "U(AASAAAA)L" {_A_ 2 _U_ 122 _N_ _N_ _N_ _N_} _N_ _N_ #-}
round :: Integral b => a -> b
{-# GHC_PRAGMA {-meth-} _A_ 2 _U_ 122 _N_ _S_ "U(AAAASAA)L" {_A_ 2 _U_ 122 _N_ _N_ _F_ _IF_ARGS_ 2 2 XX 2 _/\_ u0 u1 -> \ (u2 :: _forall_ a$z1 =>{{Integral a$z1}} -> u0 -> a$z1) (u3 :: {{Integral u1}}) -> _APP_ _TYAPP_ u2 { u1 } [ u3 ] _N_} _F_ _IF_ARGS_ 2 2 CX 3 _/\_ u0 u1 -> \ (u2 :: ({{Real u0}}, {{Fractional u0}}, (_forall_ z$z1 =>{{Integral z$z1}} -> u0 -> (z$z1, u0)), (_forall_ z$z1 =>{{Integral z$z1}} -> u0 -> z$z1), (_forall_ z$z1 =>{{Integral z$z1}} -> u0 -> z$z1), (_forall_ z$z1 =>{{Integral z$z1}} -> u0 -> z$z1), (_forall_ z$z1 =>{{Integral z$z1}} -> u0 -> z$z1))) (u3 :: {{Integral u1}}) -> case u2 of { _ALG_ _TUP_7 (u4 :: {{Real u0}}) (u5 :: {{Fractional u0}}) (u6 :: _forall_ a$z1 =>{{Integral a$z1}} -> u0 -> (a$z1, u0)) (u7 :: _forall_ a$z1 =>{{Integral a$z1}} -> u0 -> a$z1) (u8 :: _forall_ a$z1 =>{{Integral a$z1}} -> u0 -> a$z1) (u9 :: _forall_ a$z1 =>{{Integral a$z1}} -> u0 -> a$z1) (ua :: _forall_ a$z1 =>{{Integral a$z1}} -> u0 -> a$z1) -> _APP_ _TYAPP_ u8 { u1 } [ u3 ]; _NO_DEFLT_ } _N_
- {-defm-} _A_ 2 _U_ 122 _N_ _S_ "U(U(AU(U(ALAAAAAS)AAAA)A)LSAAAA)L" {_A_ 5 _U_ 222222 _N_ _N_ _N_ _N_} _N_ _N_ #-}
+ {-defm-} _A_ 2 _U_ 122 _N_ _S_ "U(U(AU(U(ALAAAAAS)AAAA)A)LSAAAA)L" {_A_ 5 _U_ 112122 _N_ _N_ _N_ _N_} _N_ _N_ #-}
ceiling :: Integral b => a -> b
{-# GHC_PRAGMA {-meth-} _A_ 2 _U_ 122 _N_ _S_ "U(AAAAASA)L" {_A_ 2 _U_ 122 _N_ _N_ _F_ _IF_ARGS_ 2 2 XX 2 _/\_ u0 u1 -> \ (u2 :: _forall_ a$z1 =>{{Integral a$z1}} -> u0 -> a$z1) (u3 :: {{Integral u1}}) -> _APP_ _TYAPP_ u2 { u1 } [ u3 ] _N_} _F_ _IF_ARGS_ 2 2 CX 3 _/\_ u0 u1 -> \ (u2 :: ({{Real u0}}, {{Fractional u0}}, (_forall_ z$z1 =>{{Integral z$z1}} -> u0 -> (z$z1, u0)), (_forall_ z$z1 =>{{Integral z$z1}} -> u0 -> z$z1), (_forall_ z$z1 =>{{Integral z$z1}} -> u0 -> z$z1), (_forall_ z$z1 =>{{Integral z$z1}} -> u0 -> z$z1), (_forall_ z$z1 =>{{Integral z$z1}} -> u0 -> z$z1))) (u3 :: {{Integral u1}}) -> case u2 of { _ALG_ _TUP_7 (u4 :: {{Real u0}}) (u5 :: {{Fractional u0}}) (u6 :: _forall_ a$z1 =>{{Integral a$z1}} -> u0 -> (a$z1, u0)) (u7 :: _forall_ a$z1 =>{{Integral a$z1}} -> u0 -> a$z1) (u8 :: _forall_ a$z1 =>{{Integral a$z1}} -> u0 -> a$z1) (u9 :: _forall_ a$z1 =>{{Integral a$z1}} -> u0 -> a$z1) (ua :: _forall_ a$z1 =>{{Integral a$z1}} -> u0 -> a$z1) -> _APP_ _TYAPP_ u9 { u1 } [ u3 ]; _NO_DEFLT_ } _N_
- {-defm-} _A_ 2 _U_ 122 _N_ _S_ "U(U(AU(U(AAAASAAA)AAAA)A)LSAAAA)L" {_A_ 4 _U_ 22222 _N_ _N_ _N_ _N_} _N_ _N_ #-}
+ {-defm-} _A_ 2 _U_ 122 _N_ _S_ "U(U(LU(U(AAAASAAA)AAAA)A)ASAAAA)L" {_A_ 4 _U_ 11122 _N_ _N_ _N_ _N_} _N_ _N_ #-}
floor :: Integral b => a -> b
{-# GHC_PRAGMA {-meth-} _A_ 2 _U_ 122 _N_ _S_ "U(AAAAAAS)L" {_A_ 2 _U_ 122 _N_ _N_ _F_ _IF_ARGS_ 2 2 XX 2 _/\_ u0 u1 -> \ (u2 :: _forall_ a$z1 =>{{Integral a$z1}} -> u0 -> a$z1) (u3 :: {{Integral u1}}) -> _APP_ _TYAPP_ u2 { u1 } [ u3 ] _N_} _F_ _IF_ARGS_ 2 2 CX 3 _/\_ u0 u1 -> \ (u2 :: ({{Real u0}}, {{Fractional u0}}, (_forall_ z$z1 =>{{Integral z$z1}} -> u0 -> (z$z1, u0)), (_forall_ z$z1 =>{{Integral z$z1}} -> u0 -> z$z1), (_forall_ z$z1 =>{{Integral z$z1}} -> u0 -> z$z1), (_forall_ z$z1 =>{{Integral z$z1}} -> u0 -> z$z1), (_forall_ z$z1 =>{{Integral z$z1}} -> u0 -> z$z1))) (u3 :: {{Integral u1}}) -> case u2 of { _ALG_ _TUP_7 (u4 :: {{Real u0}}) (u5 :: {{Fractional u0}}) (u6 :: _forall_ a$z1 =>{{Integral a$z1}} -> u0 -> (a$z1, u0)) (u7 :: _forall_ a$z1 =>{{Integral a$z1}} -> u0 -> a$z1) (u8 :: _forall_ a$z1 =>{{Integral a$z1}} -> u0 -> a$z1) (u9 :: _forall_ a$z1 =>{{Integral a$z1}} -> u0 -> a$z1) (ua :: _forall_ a$z1 =>{{Integral a$z1}} -> u0 -> a$z1) -> _APP_ _TYAPP_ ua { u1 } [ u3 ]; _NO_DEFLT_ } _N_
- {-defm-} _A_ 2 _U_ 122 _N_ _S_ "U(U(AU(U(ASAAAAAA)AAAA)A)LSAAAA)L" {_A_ 4 _U_ 22222 _N_ _N_ _N_ _N_} _N_ _N_ #-}
+ {-defm-} _A_ 2 _U_ 122 _N_ _S_ "U(U(LU(U(ASAAAAAA)AAAA)A)ASAAAA)L" {_A_ 4 _U_ 11122 _N_ _N_ _N_ _N_} _N_ _N_ #-}
class Text a where
readsPrec :: Int -> [Char] -> [(a, [Char])]
{-# GHC_PRAGMA {-meth-} _A_ 1 _U_ 122 _N_ _S_ "U(SAAA)" {_A_ 1 _U_ 122 _N_ _N_ _F_ _IF_ARGS_ 1 1 X 1 _/\_ u0 -> \ (u1 :: Int -> [Char] -> [(u0, [Char])]) -> u1 _N_} _F_ _IF_ARGS_ 1 1 C 2 _/\_ u0 -> \ (u1 :: (Int -> [Char] -> [(u0, [Char])], Int -> u0 -> [Char] -> [Char], [Char] -> [([u0], [Char])], [u0] -> [Char] -> [Char])) -> case u1 of { _ALG_ _TUP_4 (u2 :: Int -> [Char] -> [(u0, [Char])]) (u3 :: Int -> u0 -> [Char] -> [Char]) (u4 :: [Char] -> [([u0], [Char])]) (u5 :: [u0] -> [Char] -> [Char]) -> u2; _NO_DEFLT_ } _N_
- {-defm-} _A_ 3 _U_ 022 _N_ _S_ _!_ _F_ _IF_ARGS_ 1 3 XXX 4 _/\_ u0 -> \ (u1 :: {{Text u0}}) (u2 :: Int) (u3 :: [Char]) -> _APP_ _TYAPP_ patError# { (Int -> [Char] -> [(u0, [Char])]) } [ _NOREP_S_ "%DPreludeCore.Text.readsPrec\"", u2, u3 ] _N_ #-}
+ {-defm-} _A_ 3 _U_ 022 _N_ _S_ _!_ _N_ _N_ #-}
showsPrec :: Int -> a -> [Char] -> [Char]
{-# GHC_PRAGMA {-meth-} _A_ 1 _U_ 1222 _N_ _S_ "U(ASAA)" {_A_ 1 _U_ 1222 _N_ _N_ _F_ _IF_ARGS_ 1 1 X 1 _/\_ u0 -> \ (u1 :: Int -> u0 -> [Char] -> [Char]) -> u1 _N_} _F_ _IF_ARGS_ 1 1 C 2 _/\_ u0 -> \ (u1 :: (Int -> [Char] -> [(u0, [Char])], Int -> u0 -> [Char] -> [Char], [Char] -> [([u0], [Char])], [u0] -> [Char] -> [Char])) -> case u1 of { _ALG_ _TUP_4 (u2 :: Int -> [Char] -> [(u0, [Char])]) (u3 :: Int -> u0 -> [Char] -> [Char]) (u4 :: [Char] -> [([u0], [Char])]) (u5 :: [u0] -> [Char] -> [Char]) -> u3; _NO_DEFLT_ } _N_
- {-defm-} _A_ 4 _U_ 0222 _N_ _S_ _!_ _F_ _IF_ARGS_ 1 4 XXXX 5 _/\_ u0 -> \ (u1 :: {{Text u0}}) (u2 :: Int) (u3 :: u0) (u4 :: [Char]) -> _APP_ _TYAPP_ patError# { (Int -> u0 -> [Char] -> [Char]) } [ _NOREP_S_ "%DPreludeCore.Text.showsPrec\"", u2, u3, u4 ] _N_ #-}
+ {-defm-} _A_ 4 _U_ 0222 _N_ _S_ _!_ _N_ _N_ #-}
readList :: [Char] -> [([a], [Char])]
{-# GHC_PRAGMA {-meth-} _A_ 1 _U_ 12 _N_ _S_ "U(AASA)" {_A_ 1 _U_ 12 _N_ _N_ _F_ _IF_ARGS_ 1 1 X 1 _/\_ u0 -> \ (u1 :: [Char] -> [([u0], [Char])]) -> u1 _N_} _F_ _IF_ARGS_ 1 1 C 2 _/\_ u0 -> \ (u1 :: (Int -> [Char] -> [(u0, [Char])], Int -> u0 -> [Char] -> [Char], [Char] -> [([u0], [Char])], [u0] -> [Char] -> [Char])) -> case u1 of { _ALG_ _TUP_4 (u2 :: Int -> [Char] -> [(u0, [Char])]) (u3 :: Int -> u0 -> [Char] -> [Char]) (u4 :: [Char] -> [([u0], [Char])]) (u5 :: [u0] -> [Char] -> [Char]) -> u4; _NO_DEFLT_ } _N_
- {-defm-} _A_ 1 _U_ 22 _N_ _N_ _F_ _IF_ARGS_ 0 0 X 1 _ORIG_ PreludeCore _readList _N_ #-}
+ {-defm-} _A_ 1 _U_ 12 _N_ _N_ _N_ _N_ #-}
showList :: [a] -> [Char] -> [Char]
{-# GHC_PRAGMA {-meth-} _A_ 1 _U_ 122 _N_ _S_ "U(AAAS)" {_A_ 1 _U_ 122 _N_ _N_ _F_ _IF_ARGS_ 1 1 X 1 _/\_ u0 -> \ (u1 :: [u0] -> [Char] -> [Char]) -> u1 _N_} _F_ _IF_ARGS_ 1 1 C 2 _/\_ u0 -> \ (u1 :: (Int -> [Char] -> [(u0, [Char])], Int -> u0 -> [Char] -> [Char], [Char] -> [([u0], [Char])], [u0] -> [Char] -> [Char])) -> case u1 of { _ALG_ _TUP_4 (u2 :: Int -> [Char] -> [(u0, [Char])]) (u3 :: Int -> u0 -> [Char] -> [Char]) (u4 :: [Char] -> [([u0], [Char])]) (u5 :: [u0] -> [Char] -> [Char]) -> u5; _NO_DEFLT_ } _N_
- {-defm-} _A_ 1 _U_ 212 _N_ _N_ _F_ _IF_ARGS_ 0 0 X 1 _ORIG_ PreludeCore _showList _N_ #-}
+ {-defm-} _A_ 1 _U_ 112 _N_ _N_ _N_ _N_ #-}
class _CCallable a
class _CReturnable a
data Bin
import UTypes
import Core
+import IChar
import IInt ( Int )
-import IInteger ( int2Integer, Integer )
+import IInteger ( __integer1, Integer )
import List ( takeWhile, (++), foldr )
import Prel ( (&&), (.), otherwise )
import PS ( _PackedString, _unpackPS )
import Text
+import TyArray
+import TyComplex
{- We have to do something unpleasant about overloaded constants
herein. Those constants are automagically wrapped in applications
(The builtin class information is "turned off" for compiling this
file, but that does not help w/ the from{Integer,Rational} Ids,
which are reached-out-and-grabbed from thin air.
-
- We can subvert this process by wrapping the constants in explicit
- from{Integer,Rational} calls (the ones defined herein). I have put
- in a little CPPery, just to reduce typing.
+
+ Instead the overloaded constants are declared in Core.hs
-}
-- class declarations from PreludeCore
x - y = x + negate y
fromInt i = fromInteger (int2Integer i)
+ where
+ int2Integer (I# i#) = int2Integer# i#
-- Go via the standard class-op if the
-- non-standard one ain't provided
n `rem` d = r where (q,r) = quotRem n d
n `div` d = q where (q,r) = divMod n d
n `mod` d = r where (q,r) = divMod n d
- divMod n d = if signum r == - signum d then (q - i1__, r+d) else qr
+ divMod n d = if signum r == - signum d then (q - __i1, r+d) else qr
where qr@(q,r) = quotRem n d
- even n = n `rem` i2__ == i0__
- odd n = n `rem` i2__ /= i0__
+ even n = n `rem` __i2 == __i0
+ odd n = n `rem` __i2 /= __i0
class (Num a) => Fractional a where
(/) :: a -> a -> a
recip :: a -> a
fromRational :: Rational -> a
- recip x = r1__ / x
+ recip x = __i1 / x
class (Fractional a) => Floating a where
pi :: a
x ** y = exp (log x * y)
logBase x y = log y / log x
- sqrt x = x ** rhalf__
+ sqrt x = x ** __rhalf
tan x = sin x / cos x
tanh x = sinh x / cosh x
truncate, round :: (Integral b) => a -> b
ceiling, floor :: (Integral b) => a -> b
- -- just call the versions in Core.hs
- truncate x = _truncate x
- round x = _round x
- ceiling x = _ceiling x
- floor x = _floor x
+ truncate x = case properFraction x of
+ (n,_) -> n
+
+ round x = case properFraction x of
+ (n,r) -> let
+ m = if r < __i0 then n - __i1 else n + __i1
+ half_down = abs r - __rhalf
+ in
+ case (_tagCmp half_down __i0) of
+ _LT -> n
+ _EQ -> if even n then n else m
+ _GT -> m
+
+ ceiling x = case properFraction x of
+ (n,r) -> if r > __i0 then n + __i1 else n
+
+ floor x = case properFraction x of
+ (n,r) -> if r < __i0 then n - __i1 else n
+
class (RealFrac a, Floating a) => RealFloat a where
floatRadix :: a -> Integer
significand :: a -> a
scaleFloat :: Int -> a -> a
- exponent x = if m == i0__ then i0__ else n + floatDigits x
+ exponent x = if m == __i0 then __i0 else n + floatDigits x
where (m,n) = decodeFloat x
significand x = encodeFloat m (- (floatDigits x))
readList :: ReadS [a]
showList :: [a] -> ShowS
- readList = _readList
- showList = _showList
-{-MOVED to Core.hs:
- readList = readParen False (\r -> [pr | ("[",s) <- lex r,
- pr <- readl s])
- where readl s = [([],t) | ("]",t) <- lex s] ++
- [(x:xs,u) | (x,t) <- reads s,
- (xs,u) <- readl2 t]
- readl2 s = [([],t) | ("]",t) <- lex s] ++
- [(x:xs,v) | (",",t) <- lex s,
- (x,u) <- reads t,
- (xs,v) <- readl2 u]
- showList [] = showString "[]"
- showList (x:xs)
- = showChar '[' . shows x . showl xs
- where showl [] = showChar ']'
- showl (x:xs) = showString ", " . shows x . showl xs
--}
+ readList = _readList (readsPrec 0)
+ showList = _showList (showsPrec 0)
-- Well, we've got to put it somewhere...
instance Text (a -> b) where
readsPrec p s = error "readsPrec{PreludeCore}: Cannot read functions."
showsPrec p f = showString "<<function>>"
+ readList = _readList (readsPrec 0)
+ showList = _showList (showsPrec 0)
class Binary a where
readBin :: Bin -> (a,Bin)
-{-# GHC_PRAGMA INTERFACE VERSION 5 #-}
+{-# GHC_PRAGMA INTERFACE VERSION 6 #-}
interface PreludeCore where
import PreludeBuiltin(Bin, Char(..), Int(..), Integer(..), List(..), Tuple2, _CMP_TAG(..))
import PreludeRatio(Ratio(..))
class Binary a where
readBin :: Bin -> (a, Bin)
{-# GHC_PRAGMA {-meth-} _A_ 1 _U_ 12 _N_ _S_ "U(SA)" {_A_ 1 _U_ 12 _N_ _N_ _F_ _IF_ARGS_ 1 1 X 1 _/\_ u0 -> \ (u1 :: Bin -> (u0, Bin)) -> u1 _N_} _F_ _IF_ARGS_ 1 1 C 2 _/\_ u0 -> \ (u1 :: (Bin -> (u0, Bin), u0 -> Bin -> Bin)) -> case u1 of { _ALG_ _TUP_2 (u2 :: Bin -> (u0, Bin)) (u3 :: u0 -> Bin -> Bin) -> u2; _NO_DEFLT_ } _N_
- {-defm-} _A_ 2 _U_ 02 _N_ _S_ _!_ _F_ _IF_ARGS_ 1 2 XX 3 _/\_ u0 -> \ (u1 :: {{Binary u0}}) (u2 :: Bin) -> _APP_ _TYAPP_ patError# { (Bin -> (u0, Bin)) } [ _NOREP_S_ "%DPreludeCore.Binary.readBin\"", u2 ] _N_ #-}
+ {-defm-} _A_ 2 _U_ 02 _N_ _S_ _!_ _N_ _N_ #-}
showBin :: a -> Bin -> Bin
{-# GHC_PRAGMA {-meth-} _A_ 1 _U_ 122 _N_ _S_ "U(AS)" {_A_ 1 _U_ 122 _N_ _N_ _F_ _IF_ARGS_ 1 1 X 1 _/\_ u0 -> \ (u1 :: u0 -> Bin -> Bin) -> u1 _N_} _F_ _IF_ARGS_ 1 1 C 2 _/\_ u0 -> \ (u1 :: (Bin -> (u0, Bin), u0 -> Bin -> Bin)) -> case u1 of { _ALG_ _TUP_2 (u2 :: Bin -> (u0, Bin)) (u3 :: u0 -> Bin -> Bin) -> u3; _NO_DEFLT_ } _N_
- {-defm-} _A_ 3 _U_ 022 _N_ _S_ _!_ _F_ _IF_ARGS_ 1 3 XXX 4 _/\_ u0 -> \ (u1 :: {{Binary u0}}) (u2 :: u0) (u3 :: Bin) -> _APP_ _TYAPP_ patError# { (u0 -> Bin -> Bin) } [ _NOREP_S_ "%DPreludeCore.Binary.showBin\"", u2, u3 ] _N_ #-}
+ {-defm-} _A_ 3 _U_ 022 _N_ _S_ _!_ _N_ _N_ #-}
class (Ord a) => Enum a {-# GHC_PRAGMA {-superdicts-} _A_ 1 _U_ 1 _N_ _S_ "U(U(LLLLLLLL)AAAA)" {_A_ 1 _U_ 1 _N_ _N_ _F_ _IF_ARGS_ 1 1 X 1 _/\_ u0 -> \ (u1 :: {{Ord u0}}) -> u1 _N_} _F_ _IF_ARGS_ 1 1 C 2 _/\_ u0 -> \ (u1 :: ({{Ord u0}}, u0 -> [u0], u0 -> u0 -> [u0], u0 -> u0 -> [u0], u0 -> u0 -> u0 -> [u0])) -> case u1 of { _ALG_ _TUP_5 (u2 :: {{Ord u0}}) (u3 :: u0 -> [u0]) (u4 :: u0 -> u0 -> [u0]) (u5 :: u0 -> u0 -> [u0]) (u6 :: u0 -> u0 -> u0 -> [u0]) -> u2; _NO_DEFLT_ } _N_ #-} where
enumFrom :: a -> [a]
{-# GHC_PRAGMA {-meth-} _A_ 1 _U_ 12 _N_ _S_ "U(ASAAA)" {_A_ 1 _U_ 12 _N_ _N_ _F_ _IF_ARGS_ 1 1 X 1 _/\_ u0 -> \ (u1 :: u0 -> [u0]) -> u1 _N_} _F_ _IF_ARGS_ 1 1 C 2 _/\_ u0 -> \ (u1 :: ({{Ord u0}}, u0 -> [u0], u0 -> u0 -> [u0], u0 -> u0 -> [u0], u0 -> u0 -> u0 -> [u0])) -> case u1 of { _ALG_ _TUP_5 (u2 :: {{Ord u0}}) (u3 :: u0 -> [u0]) (u4 :: u0 -> u0 -> [u0]) (u5 :: u0 -> u0 -> [u0]) (u6 :: u0 -> u0 -> u0 -> [u0]) -> u3; _NO_DEFLT_ } _N_
- {-defm-} _A_ 2 _U_ 02 _N_ _S_ _!_ _F_ _IF_ARGS_ 1 2 XX 3 _/\_ u0 -> \ (u1 :: {{Enum u0}}) (u2 :: u0) -> _APP_ _TYAPP_ patError# { (u0 -> [u0]) } [ _NOREP_S_ "%DPreludeCore.Enum.enumFrom\"", u2 ] _N_ #-}
+ {-defm-} _A_ 2 _U_ 02 _N_ _S_ _!_ _N_ _N_ #-}
enumFromThen :: a -> a -> [a]
{-# GHC_PRAGMA {-meth-} _A_ 1 _U_ 122 _N_ _S_ "U(AASAA)" {_A_ 1 _U_ 122 _N_ _N_ _F_ _IF_ARGS_ 1 1 X 1 _/\_ u0 -> \ (u1 :: u0 -> u0 -> [u0]) -> u1 _N_} _F_ _IF_ARGS_ 1 1 C 2 _/\_ u0 -> \ (u1 :: ({{Ord u0}}, u0 -> [u0], u0 -> u0 -> [u0], u0 -> u0 -> [u0], u0 -> u0 -> u0 -> [u0])) -> case u1 of { _ALG_ _TUP_5 (u2 :: {{Ord u0}}) (u3 :: u0 -> [u0]) (u4 :: u0 -> u0 -> [u0]) (u5 :: u0 -> u0 -> [u0]) (u6 :: u0 -> u0 -> u0 -> [u0]) -> u4; _NO_DEFLT_ } _N_
- {-defm-} _A_ 3 _U_ 022 _N_ _S_ _!_ _F_ _IF_ARGS_ 1 3 XXX 4 _/\_ u0 -> \ (u1 :: {{Enum u0}}) (u2 :: u0) (u3 :: u0) -> _APP_ _TYAPP_ patError# { (u0 -> u0 -> [u0]) } [ _NOREP_S_ "%DPreludeCore.Enum.enumFromThen\"", u2, u3 ] _N_ #-}
+ {-defm-} _A_ 3 _U_ 022 _N_ _S_ _!_ _N_ _N_ #-}
enumFromTo :: a -> a -> [a]
{-# GHC_PRAGMA {-meth-} _A_ 1 _U_ 122 _N_ _S_ "U(AAASA)" {_A_ 1 _U_ 122 _N_ _N_ _F_ _IF_ARGS_ 1 1 X 1 _/\_ u0 -> \ (u1 :: u0 -> u0 -> [u0]) -> u1 _N_} _F_ _IF_ARGS_ 1 1 C 2 _/\_ u0 -> \ (u1 :: ({{Ord u0}}, u0 -> [u0], u0 -> u0 -> [u0], u0 -> u0 -> [u0], u0 -> u0 -> u0 -> [u0])) -> case u1 of { _ALG_ _TUP_5 (u2 :: {{Ord u0}}) (u3 :: u0 -> [u0]) (u4 :: u0 -> u0 -> [u0]) (u5 :: u0 -> u0 -> [u0]) (u6 :: u0 -> u0 -> u0 -> [u0]) -> u5; _NO_DEFLT_ } _N_
{-defm-} _A_ 3 _U_ 122 _N_ _S_ "U(LSAAA)LL" {_A_ 4 _U_ 1122 _N_ _N_ _N_ _N_} _N_ _N_ #-}
class Eq a where
(==) :: a -> a -> Bool
{-# GHC_PRAGMA {-meth-} _A_ 1 _U_ 122 _N_ _S_ "U(SA)" {_A_ 1 _U_ 122 _N_ _N_ _F_ _IF_ARGS_ 1 1 X 1 _/\_ u0 -> \ (u1 :: u0 -> u0 -> Bool) -> u1 _N_} _F_ _IF_ARGS_ 1 1 C 2 _/\_ u0 -> \ (u1 :: (u0 -> u0 -> Bool, u0 -> u0 -> Bool)) -> case u1 of { _ALG_ _TUP_2 (u2 :: u0 -> u0 -> Bool) (u3 :: u0 -> u0 -> Bool) -> u2; _NO_DEFLT_ } _N_
- {-defm-} _A_ 3 _U_ 022 _N_ _S_ _!_ _F_ _IF_ARGS_ 1 3 XXX 4 _/\_ u0 -> \ (u1 :: {{Eq u0}}) (u2 :: u0) (u3 :: u0) -> _APP_ _TYAPP_ patError# { (u0 -> u0 -> Bool) } [ _NOREP_S_ "%DPreludeCore.Eq.(==)\"", u2, u3 ] _N_ #-}
+ {-defm-} _A_ 3 _U_ 022 _N_ _S_ _!_ _N_ _N_ #-}
(/=) :: a -> a -> Bool
{-# GHC_PRAGMA {-meth-} _A_ 1 _U_ 122 _N_ _S_ "U(AS)" {_A_ 1 _U_ 122 _N_ _N_ _F_ _IF_ARGS_ 1 1 X 1 _/\_ u0 -> \ (u1 :: u0 -> u0 -> Bool) -> u1 _N_} _F_ _IF_ARGS_ 1 1 C 2 _/\_ u0 -> \ (u1 :: (u0 -> u0 -> Bool, u0 -> u0 -> Bool)) -> case u1 of { _ALG_ _TUP_2 (u2 :: u0 -> u0 -> Bool) (u3 :: u0 -> u0 -> Bool) -> u3; _NO_DEFLT_ } _N_
{-defm-} _A_ 3 _U_ 122 _N_ _S_ "U(SA)LL" {_A_ 3 _U_ 122 _N_ _N_ _N_ _N_} _N_ _N_ #-}
class (Fractional a) => Floating a {-# GHC_PRAGMA {-superdicts-} _A_ 1 _U_ 1 _N_ _S_ "U(U(LLLL)AAAAAAAAAAAAAAAAAA)" {_A_ 4 _U_ 2222 _N_ _N_ _F_ _IF_ARGS_ 1 4 XXXX 5 _/\_ u0 -> \ (u1 :: {{Num u0}}) (u2 :: u0 -> u0 -> u0) (u3 :: u0 -> u0) (u4 :: Ratio Integer -> u0) -> _!_ _TUP_4 [{{Num u0}}, (u0 -> u0 -> u0), (u0 -> u0), (Ratio Integer -> u0)] [u1, u2, u3, u4] _N_} _F_ _IF_ARGS_ 1 1 C 2 _/\_ u0 -> \ (u1 :: ({{Fractional u0}}, u0, u0 -> u0, u0 -> u0, u0 -> u0, u0 -> u0 -> u0, u0 -> u0 -> u0, u0 -> u0, u0 -> u0, u0 -> u0, u0 -> u0, u0 -> u0, u0 -> u0, u0 -> u0, u0 -> u0, u0 -> u0, u0 -> u0, u0 -> u0, u0 -> u0)) -> case u1 of { _ALG_ _TUP_19 (u2 :: {{Fractional u0}}) (u3 :: u0) (u4 :: u0 -> u0) (u5 :: u0 -> u0) (u6 :: u0 -> u0) (u7 :: u0 -> u0 -> u0) (u8 :: u0 -> u0 -> u0) (u9 :: u0 -> u0) (ua :: u0 -> u0) (ub :: u0 -> u0) (uc :: u0 -> u0) (ud :: u0 -> u0) (ue :: u0 -> u0) (uf :: u0 -> u0) (ug :: u0 -> u0) (uh :: u0 -> u0) (ui :: u0 -> u0) (uj :: u0 -> u0) (uk :: u0 -> u0) -> u2; _NO_DEFLT_ } _N_ #-} where
pi :: a
{-# GHC_PRAGMA {-meth-} _A_ 1 _U_ 1 _N_ _S_ "U(ASAAAAAAAAAAAAAAAAA)" {_A_ 1 _U_ 1 _N_ _N_ _F_ _IF_ARGS_ 1 1 X 1 _/\_ u0 -> \ (u1 :: u0) -> u1 _N_} _F_ _IF_ARGS_ 1 1 C 2 _/\_ u0 -> \ (u1 :: ({{Fractional u0}}, u0, u0 -> u0, u0 -> u0, u0 -> u0, u0 -> u0 -> u0, u0 -> u0 -> u0, u0 -> u0, u0 -> u0, u0 -> u0, u0 -> u0, u0 -> u0, u0 -> u0, u0 -> u0, u0 -> u0, u0 -> u0, u0 -> u0, u0 -> u0, u0 -> u0)) -> case u1 of { _ALG_ _TUP_19 (u2 :: {{Fractional u0}}) (u3 :: u0) (u4 :: u0 -> u0) (u5 :: u0 -> u0) (u6 :: u0 -> u0) (u7 :: u0 -> u0 -> u0) (u8 :: u0 -> u0 -> u0) (u9 :: u0 -> u0) (ua :: u0 -> u0) (ub :: u0 -> u0) (uc :: u0 -> u0) (ud :: u0 -> u0) (ue :: u0 -> u0) (uf :: u0 -> u0) (ug :: u0 -> u0) (uh :: u0 -> u0) (ui :: u0 -> u0) (uj :: u0 -> u0) (uk :: u0 -> u0) -> u3; _NO_DEFLT_ } _N_
- {-defm-} _A_ 1 _U_ 0 _N_ _S_ _!_ _F_ _IF_ARGS_ 1 1 X 2 _/\_ u0 -> \ (u1 :: {{Floating u0}}) -> _APP_ _TYAPP_ patError# { u0 } [ _NOREP_S_ "%DPreludeCore.Floating.pi\"" ] _N_ #-}
+ {-defm-} _A_ 1 _U_ 0 _N_ _S_ _!_ _N_ _N_ #-}
exp :: a -> a
{-# GHC_PRAGMA {-meth-} _A_ 1 _U_ 12 _N_ _S_ "U(AASAAAAAAAAAAAAAAAA)" {_A_ 1 _U_ 12 _N_ _N_ _F_ _IF_ARGS_ 1 1 X 1 _/\_ u0 -> \ (u1 :: u0 -> u0) -> u1 _N_} _F_ _IF_ARGS_ 1 1 C 2 _/\_ u0 -> \ (u1 :: ({{Fractional u0}}, u0, u0 -> u0, u0 -> u0, u0 -> u0, u0 -> u0 -> u0, u0 -> u0 -> u0, u0 -> u0, u0 -> u0, u0 -> u0, u0 -> u0, u0 -> u0, u0 -> u0, u0 -> u0, u0 -> u0, u0 -> u0, u0 -> u0, u0 -> u0, u0 -> u0)) -> case u1 of { _ALG_ _TUP_19 (u2 :: {{Fractional u0}}) (u3 :: u0) (u4 :: u0 -> u0) (u5 :: u0 -> u0) (u6 :: u0 -> u0) (u7 :: u0 -> u0 -> u0) (u8 :: u0 -> u0 -> u0) (u9 :: u0 -> u0) (ua :: u0 -> u0) (ub :: u0 -> u0) (uc :: u0 -> u0) (ud :: u0 -> u0) (ue :: u0 -> u0) (uf :: u0 -> u0) (ug :: u0 -> u0) (uh :: u0 -> u0) (ui :: u0 -> u0) (uj :: u0 -> u0) (uk :: u0 -> u0) -> u4; _NO_DEFLT_ } _N_
- {-defm-} _A_ 2 _U_ 02 _N_ _S_ _!_ _F_ _IF_ARGS_ 1 2 XX 3 _/\_ u0 -> \ (u1 :: {{Floating u0}}) (u2 :: u0) -> _APP_ _TYAPP_ patError# { (u0 -> u0) } [ _NOREP_S_ "%DPreludeCore.Floating.exp\"", u2 ] _N_ #-}
+ {-defm-} _A_ 2 _U_ 02 _N_ _S_ _!_ _N_ _N_ #-}
log :: a -> a
{-# GHC_PRAGMA {-meth-} _A_ 1 _U_ 12 _N_ _S_ "U(AAASAAAAAAAAAAAAAAA)" {_A_ 1 _U_ 12 _N_ _N_ _F_ _IF_ARGS_ 1 1 X 1 _/\_ u0 -> \ (u1 :: u0 -> u0) -> u1 _N_} _F_ _IF_ARGS_ 1 1 C 2 _/\_ u0 -> \ (u1 :: ({{Fractional u0}}, u0, u0 -> u0, u0 -> u0, u0 -> u0, u0 -> u0 -> u0, u0 -> u0 -> u0, u0 -> u0, u0 -> u0, u0 -> u0, u0 -> u0, u0 -> u0, u0 -> u0, u0 -> u0, u0 -> u0, u0 -> u0, u0 -> u0, u0 -> u0, u0 -> u0)) -> case u1 of { _ALG_ _TUP_19 (u2 :: {{Fractional u0}}) (u3 :: u0) (u4 :: u0 -> u0) (u5 :: u0 -> u0) (u6 :: u0 -> u0) (u7 :: u0 -> u0 -> u0) (u8 :: u0 -> u0 -> u0) (u9 :: u0 -> u0) (ua :: u0 -> u0) (ub :: u0 -> u0) (uc :: u0 -> u0) (ud :: u0 -> u0) (ue :: u0 -> u0) (uf :: u0 -> u0) (ug :: u0 -> u0) (uh :: u0 -> u0) (ui :: u0 -> u0) (uj :: u0 -> u0) (uk :: u0 -> u0) -> u5; _NO_DEFLT_ } _N_
- {-defm-} _A_ 2 _U_ 02 _N_ _S_ _!_ _F_ _IF_ARGS_ 1 2 XX 3 _/\_ u0 -> \ (u1 :: {{Floating u0}}) (u2 :: u0) -> _APP_ _TYAPP_ patError# { (u0 -> u0) } [ _NOREP_S_ "%DPreludeCore.Floating.log\"", u2 ] _N_ #-}
+ {-defm-} _A_ 2 _U_ 02 _N_ _S_ _!_ _N_ _N_ #-}
sqrt :: a -> a
{-# GHC_PRAGMA {-meth-} _A_ 1 _U_ 12 _N_ _S_ "U(AAAASAAAAAAAAAAAAAA)" {_A_ 1 _U_ 12 _N_ _N_ _F_ _IF_ARGS_ 1 1 X 1 _/\_ u0 -> \ (u1 :: u0 -> u0) -> u1 _N_} _F_ _IF_ARGS_ 1 1 C 2 _/\_ u0 -> \ (u1 :: ({{Fractional u0}}, u0, u0 -> u0, u0 -> u0, u0 -> u0, u0 -> u0 -> u0, u0 -> u0 -> u0, u0 -> u0, u0 -> u0, u0 -> u0, u0 -> u0, u0 -> u0, u0 -> u0, u0 -> u0, u0 -> u0, u0 -> u0, u0 -> u0, u0 -> u0, u0 -> u0)) -> case u1 of { _ALG_ _TUP_19 (u2 :: {{Fractional u0}}) (u3 :: u0) (u4 :: u0 -> u0) (u5 :: u0 -> u0) (u6 :: u0 -> u0) (u7 :: u0 -> u0 -> u0) (u8 :: u0 -> u0 -> u0) (u9 :: u0 -> u0) (ua :: u0 -> u0) (ub :: u0 -> u0) (uc :: u0 -> u0) (ud :: u0 -> u0) (ue :: u0 -> u0) (uf :: u0 -> u0) (ug :: u0 -> u0) (uh :: u0 -> u0) (ui :: u0 -> u0) (uj :: u0 -> u0) (uk :: u0 -> u0) -> u6; _NO_DEFLT_ } _N_
{-defm-} _A_ 1 _U_ 12 _N_ _S_ "U(LAAAASAAAAAAAAAAAAA)" {_A_ 2 _U_ 112 _N_ _N_ _N_ _N_} _N_ _N_ #-}
{-defm-} _A_ 3 _U_ 122 _N_ _S_ "U(U(ASAA)AALAAAAAAAAAAAAAAA)LL" {_A_ 4 _U_ 1222 _N_ _N_ _N_ _N_} _N_ _N_ #-}
sin :: a -> a
{-# GHC_PRAGMA {-meth-} _A_ 1 _U_ 12 _N_ _S_ "U(AAAAAAASAAAAAAAAAAA)" {_A_ 1 _U_ 12 _N_ _N_ _F_ _IF_ARGS_ 1 1 X 1 _/\_ u0 -> \ (u1 :: u0 -> u0) -> u1 _N_} _F_ _IF_ARGS_ 1 1 C 2 _/\_ u0 -> \ (u1 :: ({{Fractional u0}}, u0, u0 -> u0, u0 -> u0, u0 -> u0, u0 -> u0 -> u0, u0 -> u0 -> u0, u0 -> u0, u0 -> u0, u0 -> u0, u0 -> u0, u0 -> u0, u0 -> u0, u0 -> u0, u0 -> u0, u0 -> u0, u0 -> u0, u0 -> u0, u0 -> u0)) -> case u1 of { _ALG_ _TUP_19 (u2 :: {{Fractional u0}}) (u3 :: u0) (u4 :: u0 -> u0) (u5 :: u0 -> u0) (u6 :: u0 -> u0) (u7 :: u0 -> u0 -> u0) (u8 :: u0 -> u0 -> u0) (u9 :: u0 -> u0) (ua :: u0 -> u0) (ub :: u0 -> u0) (uc :: u0 -> u0) (ud :: u0 -> u0) (ue :: u0 -> u0) (uf :: u0 -> u0) (ug :: u0 -> u0) (uh :: u0 -> u0) (ui :: u0 -> u0) (uj :: u0 -> u0) (uk :: u0 -> u0) -> u9; _NO_DEFLT_ } _N_
- {-defm-} _A_ 2 _U_ 02 _N_ _S_ _!_ _F_ _IF_ARGS_ 1 2 XX 3 _/\_ u0 -> \ (u1 :: {{Floating u0}}) (u2 :: u0) -> _APP_ _TYAPP_ patError# { (u0 -> u0) } [ _NOREP_S_ "%DPreludeCore.Floating.sin\"", u2 ] _N_ #-}
+ {-defm-} _A_ 2 _U_ 02 _N_ _S_ _!_ _N_ _N_ #-}
cos :: a -> a
{-# GHC_PRAGMA {-meth-} _A_ 1 _U_ 12 _N_ _S_ "U(AAAAAAAASAAAAAAAAAA)" {_A_ 1 _U_ 12 _N_ _N_ _F_ _IF_ARGS_ 1 1 X 1 _/\_ u0 -> \ (u1 :: u0 -> u0) -> u1 _N_} _F_ _IF_ARGS_ 1 1 C 2 _/\_ u0 -> \ (u1 :: ({{Fractional u0}}, u0, u0 -> u0, u0 -> u0, u0 -> u0, u0 -> u0 -> u0, u0 -> u0 -> u0, u0 -> u0, u0 -> u0, u0 -> u0, u0 -> u0, u0 -> u0, u0 -> u0, u0 -> u0, u0 -> u0, u0 -> u0, u0 -> u0, u0 -> u0, u0 -> u0)) -> case u1 of { _ALG_ _TUP_19 (u2 :: {{Fractional u0}}) (u3 :: u0) (u4 :: u0 -> u0) (u5 :: u0 -> u0) (u6 :: u0 -> u0) (u7 :: u0 -> u0 -> u0) (u8 :: u0 -> u0 -> u0) (u9 :: u0 -> u0) (ua :: u0 -> u0) (ub :: u0 -> u0) (uc :: u0 -> u0) (ud :: u0 -> u0) (ue :: u0 -> u0) (uf :: u0 -> u0) (ug :: u0 -> u0) (uh :: u0 -> u0) (ui :: u0 -> u0) (uj :: u0 -> u0) (uk :: u0 -> u0) -> ua; _NO_DEFLT_ } _N_
- {-defm-} _A_ 2 _U_ 02 _N_ _S_ _!_ _F_ _IF_ARGS_ 1 2 XX 3 _/\_ u0 -> \ (u1 :: {{Floating u0}}) (u2 :: u0) -> _APP_ _TYAPP_ patError# { (u0 -> u0) } [ _NOREP_S_ "%DPreludeCore.Floating.cos\"", u2 ] _N_ #-}
+ {-defm-} _A_ 2 _U_ 02 _N_ _S_ _!_ _N_ _N_ #-}
tan :: a -> a
{-# GHC_PRAGMA {-meth-} _A_ 1 _U_ 12 _N_ _S_ "U(AAAAAAAAASAAAAAAAAA)" {_A_ 1 _U_ 12 _N_ _N_ _F_ _IF_ARGS_ 1 1 X 1 _/\_ u0 -> \ (u1 :: u0 -> u0) -> u1 _N_} _F_ _IF_ARGS_ 1 1 C 2 _/\_ u0 -> \ (u1 :: ({{Fractional u0}}, u0, u0 -> u0, u0 -> u0, u0 -> u0, u0 -> u0 -> u0, u0 -> u0 -> u0, u0 -> u0, u0 -> u0, u0 -> u0, u0 -> u0, u0 -> u0, u0 -> u0, u0 -> u0, u0 -> u0, u0 -> u0, u0 -> u0, u0 -> u0, u0 -> u0)) -> case u1 of { _ALG_ _TUP_19 (u2 :: {{Fractional u0}}) (u3 :: u0) (u4 :: u0 -> u0) (u5 :: u0 -> u0) (u6 :: u0 -> u0) (u7 :: u0 -> u0 -> u0) (u8 :: u0 -> u0 -> u0) (u9 :: u0 -> u0) (ua :: u0 -> u0) (ub :: u0 -> u0) (uc :: u0 -> u0) (ud :: u0 -> u0) (ue :: u0 -> u0) (uf :: u0 -> u0) (ug :: u0 -> u0) (uh :: u0 -> u0) (ui :: u0 -> u0) (uj :: u0 -> u0) (uk :: u0 -> u0) -> ub; _NO_DEFLT_ } _N_
{-defm-} _A_ 2 _U_ 12 _N_ _S_ "U(U(ASAA)AAAAAALLAAAAAAAAAA)L" {_A_ 4 _U_ 1112 _N_ _N_ _N_ _N_} _N_ _N_ #-}
asin :: a -> a
{-# GHC_PRAGMA {-meth-} _A_ 1 _U_ 12 _N_ _S_ "U(AAAAAAAAAASAAAAAAAA)" {_A_ 1 _U_ 12 _N_ _N_ _F_ _IF_ARGS_ 1 1 X 1 _/\_ u0 -> \ (u1 :: u0 -> u0) -> u1 _N_} _F_ _IF_ARGS_ 1 1 C 2 _/\_ u0 -> \ (u1 :: ({{Fractional u0}}, u0, u0 -> u0, u0 -> u0, u0 -> u0, u0 -> u0 -> u0, u0 -> u0 -> u0, u0 -> u0, u0 -> u0, u0 -> u0, u0 -> u0, u0 -> u0, u0 -> u0, u0 -> u0, u0 -> u0, u0 -> u0, u0 -> u0, u0 -> u0, u0 -> u0)) -> case u1 of { _ALG_ _TUP_19 (u2 :: {{Fractional u0}}) (u3 :: u0) (u4 :: u0 -> u0) (u5 :: u0 -> u0) (u6 :: u0 -> u0) (u7 :: u0 -> u0 -> u0) (u8 :: u0 -> u0 -> u0) (u9 :: u0 -> u0) (ua :: u0 -> u0) (ub :: u0 -> u0) (uc :: u0 -> u0) (ud :: u0 -> u0) (ue :: u0 -> u0) (uf :: u0 -> u0) (ug :: u0 -> u0) (uh :: u0 -> u0) (ui :: u0 -> u0) (uj :: u0 -> u0) (uk :: u0 -> u0) -> uc; _NO_DEFLT_ } _N_
- {-defm-} _A_ 2 _U_ 02 _N_ _S_ _!_ _F_ _IF_ARGS_ 1 2 XX 3 _/\_ u0 -> \ (u1 :: {{Floating u0}}) (u2 :: u0) -> _APP_ _TYAPP_ patError# { (u0 -> u0) } [ _NOREP_S_ "%DPreludeCore.Floating.asin\"", u2 ] _N_ #-}
+ {-defm-} _A_ 2 _U_ 02 _N_ _S_ _!_ _N_ _N_ #-}
acos :: a -> a
{-# GHC_PRAGMA {-meth-} _A_ 1 _U_ 12 _N_ _S_ "U(AAAAAAAAAAASAAAAAAA)" {_A_ 1 _U_ 12 _N_ _N_ _F_ _IF_ARGS_ 1 1 X 1 _/\_ u0 -> \ (u1 :: u0 -> u0) -> u1 _N_} _F_ _IF_ARGS_ 1 1 C 2 _/\_ u0 -> \ (u1 :: ({{Fractional u0}}, u0, u0 -> u0, u0 -> u0, u0 -> u0, u0 -> u0 -> u0, u0 -> u0 -> u0, u0 -> u0, u0 -> u0, u0 -> u0, u0 -> u0, u0 -> u0, u0 -> u0, u0 -> u0, u0 -> u0, u0 -> u0, u0 -> u0, u0 -> u0, u0 -> u0)) -> case u1 of { _ALG_ _TUP_19 (u2 :: {{Fractional u0}}) (u3 :: u0) (u4 :: u0 -> u0) (u5 :: u0 -> u0) (u6 :: u0 -> u0) (u7 :: u0 -> u0 -> u0) (u8 :: u0 -> u0 -> u0) (u9 :: u0 -> u0) (ua :: u0 -> u0) (ub :: u0 -> u0) (uc :: u0 -> u0) (ud :: u0 -> u0) (ue :: u0 -> u0) (uf :: u0 -> u0) (ug :: u0 -> u0) (uh :: u0 -> u0) (ui :: u0 -> u0) (uj :: u0 -> u0) (uk :: u0 -> u0) -> ud; _NO_DEFLT_ } _N_
- {-defm-} _A_ 2 _U_ 02 _N_ _S_ _!_ _F_ _IF_ARGS_ 1 2 XX 3 _/\_ u0 -> \ (u1 :: {{Floating u0}}) (u2 :: u0) -> _APP_ _TYAPP_ patError# { (u0 -> u0) } [ _NOREP_S_ "%DPreludeCore.Floating.acos\"", u2 ] _N_ #-}
+ {-defm-} _A_ 2 _U_ 02 _N_ _S_ _!_ _N_ _N_ #-}
atan :: a -> a
{-# GHC_PRAGMA {-meth-} _A_ 1 _U_ 12 _N_ _S_ "U(AAAAAAAAAAAASAAAAAA)" {_A_ 1 _U_ 12 _N_ _N_ _F_ _IF_ARGS_ 1 1 X 1 _/\_ u0 -> \ (u1 :: u0 -> u0) -> u1 _N_} _F_ _IF_ARGS_ 1 1 C 2 _/\_ u0 -> \ (u1 :: ({{Fractional u0}}, u0, u0 -> u0, u0 -> u0, u0 -> u0, u0 -> u0 -> u0, u0 -> u0 -> u0, u0 -> u0, u0 -> u0, u0 -> u0, u0 -> u0, u0 -> u0, u0 -> u0, u0 -> u0, u0 -> u0, u0 -> u0, u0 -> u0, u0 -> u0, u0 -> u0)) -> case u1 of { _ALG_ _TUP_19 (u2 :: {{Fractional u0}}) (u3 :: u0) (u4 :: u0 -> u0) (u5 :: u0 -> u0) (u6 :: u0 -> u0) (u7 :: u0 -> u0 -> u0) (u8 :: u0 -> u0 -> u0) (u9 :: u0 -> u0) (ua :: u0 -> u0) (ub :: u0 -> u0) (uc :: u0 -> u0) (ud :: u0 -> u0) (ue :: u0 -> u0) (uf :: u0 -> u0) (ug :: u0 -> u0) (uh :: u0 -> u0) (ui :: u0 -> u0) (uj :: u0 -> u0) (uk :: u0 -> u0) -> ue; _NO_DEFLT_ } _N_
- {-defm-} _A_ 2 _U_ 02 _N_ _S_ _!_ _F_ _IF_ARGS_ 1 2 XX 3 _/\_ u0 -> \ (u1 :: {{Floating u0}}) (u2 :: u0) -> _APP_ _TYAPP_ patError# { (u0 -> u0) } [ _NOREP_S_ "%DPreludeCore.Floating.atan\"", u2 ] _N_ #-}
+ {-defm-} _A_ 2 _U_ 02 _N_ _S_ _!_ _N_ _N_ #-}
sinh :: a -> a
{-# GHC_PRAGMA {-meth-} _A_ 1 _U_ 12 _N_ _S_ "U(AAAAAAAAAAAAASAAAAA)" {_A_ 1 _U_ 12 _N_ _N_ _F_ _IF_ARGS_ 1 1 X 1 _/\_ u0 -> \ (u1 :: u0 -> u0) -> u1 _N_} _F_ _IF_ARGS_ 1 1 C 2 _/\_ u0 -> \ (u1 :: ({{Fractional u0}}, u0, u0 -> u0, u0 -> u0, u0 -> u0, u0 -> u0 -> u0, u0 -> u0 -> u0, u0 -> u0, u0 -> u0, u0 -> u0, u0 -> u0, u0 -> u0, u0 -> u0, u0 -> u0, u0 -> u0, u0 -> u0, u0 -> u0, u0 -> u0, u0 -> u0)) -> case u1 of { _ALG_ _TUP_19 (u2 :: {{Fractional u0}}) (u3 :: u0) (u4 :: u0 -> u0) (u5 :: u0 -> u0) (u6 :: u0 -> u0) (u7 :: u0 -> u0 -> u0) (u8 :: u0 -> u0 -> u0) (u9 :: u0 -> u0) (ua :: u0 -> u0) (ub :: u0 -> u0) (uc :: u0 -> u0) (ud :: u0 -> u0) (ue :: u0 -> u0) (uf :: u0 -> u0) (ug :: u0 -> u0) (uh :: u0 -> u0) (ui :: u0 -> u0) (uj :: u0 -> u0) (uk :: u0 -> u0) -> uf; _NO_DEFLT_ } _N_
- {-defm-} _A_ 2 _U_ 02 _N_ _S_ _!_ _F_ _IF_ARGS_ 1 2 XX 3 _/\_ u0 -> \ (u1 :: {{Floating u0}}) (u2 :: u0) -> _APP_ _TYAPP_ patError# { (u0 -> u0) } [ _NOREP_S_ "%DPreludeCore.Floating.sinh\"", u2 ] _N_ #-}
+ {-defm-} _A_ 2 _U_ 02 _N_ _S_ _!_ _N_ _N_ #-}
cosh :: a -> a
{-# GHC_PRAGMA {-meth-} _A_ 1 _U_ 12 _N_ _S_ "U(AAAAAAAAAAAAAASAAAA)" {_A_ 1 _U_ 12 _N_ _N_ _F_ _IF_ARGS_ 1 1 X 1 _/\_ u0 -> \ (u1 :: u0 -> u0) -> u1 _N_} _F_ _IF_ARGS_ 1 1 C 2 _/\_ u0 -> \ (u1 :: ({{Fractional u0}}, u0, u0 -> u0, u0 -> u0, u0 -> u0, u0 -> u0 -> u0, u0 -> u0 -> u0, u0 -> u0, u0 -> u0, u0 -> u0, u0 -> u0, u0 -> u0, u0 -> u0, u0 -> u0, u0 -> u0, u0 -> u0, u0 -> u0, u0 -> u0, u0 -> u0)) -> case u1 of { _ALG_ _TUP_19 (u2 :: {{Fractional u0}}) (u3 :: u0) (u4 :: u0 -> u0) (u5 :: u0 -> u0) (u6 :: u0 -> u0) (u7 :: u0 -> u0 -> u0) (u8 :: u0 -> u0 -> u0) (u9 :: u0 -> u0) (ua :: u0 -> u0) (ub :: u0 -> u0) (uc :: u0 -> u0) (ud :: u0 -> u0) (ue :: u0 -> u0) (uf :: u0 -> u0) (ug :: u0 -> u0) (uh :: u0 -> u0) (ui :: u0 -> u0) (uj :: u0 -> u0) (uk :: u0 -> u0) -> ug; _NO_DEFLT_ } _N_
- {-defm-} _A_ 2 _U_ 02 _N_ _S_ _!_ _F_ _IF_ARGS_ 1 2 XX 3 _/\_ u0 -> \ (u1 :: {{Floating u0}}) (u2 :: u0) -> _APP_ _TYAPP_ patError# { (u0 -> u0) } [ _NOREP_S_ "%DPreludeCore.Floating.cosh\"", u2 ] _N_ #-}
+ {-defm-} _A_ 2 _U_ 02 _N_ _S_ _!_ _N_ _N_ #-}
tanh :: a -> a
{-# GHC_PRAGMA {-meth-} _A_ 1 _U_ 12 _N_ _S_ "U(AAAAAAAAAAAAAAASAAA)" {_A_ 1 _U_ 12 _N_ _N_ _F_ _IF_ARGS_ 1 1 X 1 _/\_ u0 -> \ (u1 :: u0 -> u0) -> u1 _N_} _F_ _IF_ARGS_ 1 1 C 2 _/\_ u0 -> \ (u1 :: ({{Fractional u0}}, u0, u0 -> u0, u0 -> u0, u0 -> u0, u0 -> u0 -> u0, u0 -> u0 -> u0, u0 -> u0, u0 -> u0, u0 -> u0, u0 -> u0, u0 -> u0, u0 -> u0, u0 -> u0, u0 -> u0, u0 -> u0, u0 -> u0, u0 -> u0, u0 -> u0)) -> case u1 of { _ALG_ _TUP_19 (u2 :: {{Fractional u0}}) (u3 :: u0) (u4 :: u0 -> u0) (u5 :: u0 -> u0) (u6 :: u0 -> u0) (u7 :: u0 -> u0 -> u0) (u8 :: u0 -> u0 -> u0) (u9 :: u0 -> u0) (ua :: u0 -> u0) (ub :: u0 -> u0) (uc :: u0 -> u0) (ud :: u0 -> u0) (ue :: u0 -> u0) (uf :: u0 -> u0) (ug :: u0 -> u0) (uh :: u0 -> u0) (ui :: u0 -> u0) (uj :: u0 -> u0) (uk :: u0 -> u0) -> uh; _NO_DEFLT_ } _N_
{-defm-} _A_ 2 _U_ 12 _N_ _S_ "U(U(ASAA)AAAAAAAAAAAALLAAAA)L" {_A_ 4 _U_ 1112 _N_ _N_ _N_ _N_} _N_ _N_ #-}
asinh :: a -> a
{-# GHC_PRAGMA {-meth-} _A_ 1 _U_ 12 _N_ _S_ "U(AAAAAAAAAAAAAAAASAA)" {_A_ 1 _U_ 12 _N_ _N_ _F_ _IF_ARGS_ 1 1 X 1 _/\_ u0 -> \ (u1 :: u0 -> u0) -> u1 _N_} _F_ _IF_ARGS_ 1 1 C 2 _/\_ u0 -> \ (u1 :: ({{Fractional u0}}, u0, u0 -> u0, u0 -> u0, u0 -> u0, u0 -> u0 -> u0, u0 -> u0 -> u0, u0 -> u0, u0 -> u0, u0 -> u0, u0 -> u0, u0 -> u0, u0 -> u0, u0 -> u0, u0 -> u0, u0 -> u0, u0 -> u0, u0 -> u0, u0 -> u0)) -> case u1 of { _ALG_ _TUP_19 (u2 :: {{Fractional u0}}) (u3 :: u0) (u4 :: u0 -> u0) (u5 :: u0 -> u0) (u6 :: u0 -> u0) (u7 :: u0 -> u0 -> u0) (u8 :: u0 -> u0 -> u0) (u9 :: u0 -> u0) (ua :: u0 -> u0) (ub :: u0 -> u0) (uc :: u0 -> u0) (ud :: u0 -> u0) (ue :: u0 -> u0) (uf :: u0 -> u0) (ug :: u0 -> u0) (uh :: u0 -> u0) (ui :: u0 -> u0) (uj :: u0 -> u0) (uk :: u0 -> u0) -> ui; _NO_DEFLT_ } _N_
- {-defm-} _A_ 2 _U_ 02 _N_ _S_ _!_ _F_ _IF_ARGS_ 1 2 XX 3 _/\_ u0 -> \ (u1 :: {{Floating u0}}) (u2 :: u0) -> _APP_ _TYAPP_ patError# { (u0 -> u0) } [ _NOREP_S_ "%DPreludeCore.Floating.asinh\"", u2 ] _N_ #-}
+ {-defm-} _A_ 2 _U_ 02 _N_ _S_ _!_ _N_ _N_ #-}
acosh :: a -> a
{-# GHC_PRAGMA {-meth-} _A_ 1 _U_ 12 _N_ _S_ "U(AAAAAAAAAAAAAAAAASA)" {_A_ 1 _U_ 12 _N_ _N_ _F_ _IF_ARGS_ 1 1 X 1 _/\_ u0 -> \ (u1 :: u0 -> u0) -> u1 _N_} _F_ _IF_ARGS_ 1 1 C 2 _/\_ u0 -> \ (u1 :: ({{Fractional u0}}, u0, u0 -> u0, u0 -> u0, u0 -> u0, u0 -> u0 -> u0, u0 -> u0 -> u0, u0 -> u0, u0 -> u0, u0 -> u0, u0 -> u0, u0 -> u0, u0 -> u0, u0 -> u0, u0 -> u0, u0 -> u0, u0 -> u0, u0 -> u0, u0 -> u0)) -> case u1 of { _ALG_ _TUP_19 (u2 :: {{Fractional u0}}) (u3 :: u0) (u4 :: u0 -> u0) (u5 :: u0 -> u0) (u6 :: u0 -> u0) (u7 :: u0 -> u0 -> u0) (u8 :: u0 -> u0 -> u0) (u9 :: u0 -> u0) (ua :: u0 -> u0) (ub :: u0 -> u0) (uc :: u0 -> u0) (ud :: u0 -> u0) (ue :: u0 -> u0) (uf :: u0 -> u0) (ug :: u0 -> u0) (uh :: u0 -> u0) (ui :: u0 -> u0) (uj :: u0 -> u0) (uk :: u0 -> u0) -> uj; _NO_DEFLT_ } _N_
- {-defm-} _A_ 2 _U_ 02 _N_ _S_ _!_ _F_ _IF_ARGS_ 1 2 XX 3 _/\_ u0 -> \ (u1 :: {{Floating u0}}) (u2 :: u0) -> _APP_ _TYAPP_ patError# { (u0 -> u0) } [ _NOREP_S_ "%DPreludeCore.Floating.acosh\"", u2 ] _N_ #-}
+ {-defm-} _A_ 2 _U_ 02 _N_ _S_ _!_ _N_ _N_ #-}
atanh :: a -> a
{-# GHC_PRAGMA {-meth-} _A_ 1 _U_ 12 _N_ _S_ "U(AAAAAAAAAAAAAAAAAAS)" {_A_ 1 _U_ 12 _N_ _N_ _F_ _IF_ARGS_ 1 1 X 1 _/\_ u0 -> \ (u1 :: u0 -> u0) -> u1 _N_} _F_ _IF_ARGS_ 1 1 C 2 _/\_ u0 -> \ (u1 :: ({{Fractional u0}}, u0, u0 -> u0, u0 -> u0, u0 -> u0, u0 -> u0 -> u0, u0 -> u0 -> u0, u0 -> u0, u0 -> u0, u0 -> u0, u0 -> u0, u0 -> u0, u0 -> u0, u0 -> u0, u0 -> u0, u0 -> u0, u0 -> u0, u0 -> u0, u0 -> u0)) -> case u1 of { _ALG_ _TUP_19 (u2 :: {{Fractional u0}}) (u3 :: u0) (u4 :: u0 -> u0) (u5 :: u0 -> u0) (u6 :: u0 -> u0) (u7 :: u0 -> u0 -> u0) (u8 :: u0 -> u0 -> u0) (u9 :: u0 -> u0) (ua :: u0 -> u0) (ub :: u0 -> u0) (uc :: u0 -> u0) (ud :: u0 -> u0) (ue :: u0 -> u0) (uf :: u0 -> u0) (ug :: u0 -> u0) (uh :: u0 -> u0) (ui :: u0 -> u0) (uj :: u0 -> u0) (uk :: u0 -> u0) -> uk; _NO_DEFLT_ } _N_
- {-defm-} _A_ 2 _U_ 02 _N_ _S_ _!_ _F_ _IF_ARGS_ 1 2 XX 3 _/\_ u0 -> \ (u1 :: {{Floating u0}}) (u2 :: u0) -> _APP_ _TYAPP_ patError# { (u0 -> u0) } [ _NOREP_S_ "%DPreludeCore.Floating.atanh\"", u2 ] _N_ #-}
+ {-defm-} _A_ 2 _U_ 02 _N_ _S_ _!_ _N_ _N_ #-}
class (Num a) => Fractional a {-# GHC_PRAGMA {-superdicts-} _A_ 1 _U_ 1 _N_ _S_ "U(U(LLLLLLLLLL)AAA)" {_A_ 1 _U_ 1 _N_ _N_ _F_ _IF_ARGS_ 1 1 X 1 _/\_ u0 -> \ (u1 :: {{Num u0}}) -> u1 _N_} _F_ _IF_ARGS_ 1 1 C 2 _/\_ u0 -> \ (u1 :: ({{Num u0}}, u0 -> u0 -> u0, u0 -> u0, Ratio Integer -> u0)) -> case u1 of { _ALG_ _TUP_4 (u2 :: {{Num u0}}) (u3 :: u0 -> u0 -> u0) (u4 :: u0 -> u0) (u5 :: Ratio Integer -> u0) -> u2; _NO_DEFLT_ } _N_ #-} where
(/) :: a -> a -> a
{-# GHC_PRAGMA {-meth-} _A_ 1 _U_ 122 _N_ _S_ "U(ASAA)" {_A_ 1 _U_ 122 _N_ _N_ _F_ _IF_ARGS_ 1 1 X 1 _/\_ u0 -> \ (u1 :: u0 -> u0 -> u0) -> u1 _N_} _F_ _IF_ARGS_ 1 1 C 2 _/\_ u0 -> \ (u1 :: ({{Num u0}}, u0 -> u0 -> u0, u0 -> u0, Ratio Integer -> u0)) -> case u1 of { _ALG_ _TUP_4 (u2 :: {{Num u0}}) (u3 :: u0 -> u0 -> u0) (u4 :: u0 -> u0) (u5 :: Ratio Integer -> u0) -> u3; _NO_DEFLT_ } _N_
- {-defm-} _A_ 3 _U_ 022 _N_ _S_ _!_ _F_ _IF_ARGS_ 1 3 XXX 4 _/\_ u0 -> \ (u1 :: {{Fractional u0}}) (u2 :: u0) (u3 :: u0) -> _APP_ _TYAPP_ patError# { (u0 -> u0 -> u0) } [ _NOREP_S_ "%DPreludeCore.Fractional.(/)\"", u2, u3 ] _N_ #-}
+ {-defm-} _A_ 3 _U_ 022 _N_ _S_ _!_ _N_ _N_ #-}
recip :: a -> a
{-# GHC_PRAGMA {-meth-} _A_ 1 _U_ 12 _N_ _S_ "U(AASA)" {_A_ 1 _U_ 12 _N_ _N_ _F_ _IF_ARGS_ 1 1 X 1 _/\_ u0 -> \ (u1 :: u0 -> u0) -> u1 _N_} _F_ _IF_ARGS_ 1 1 C 2 _/\_ u0 -> \ (u1 :: ({{Num u0}}, u0 -> u0 -> u0, u0 -> u0, Ratio Integer -> u0)) -> case u1 of { _ALG_ _TUP_4 (u2 :: {{Num u0}}) (u3 :: u0 -> u0 -> u0) (u4 :: u0 -> u0) (u5 :: Ratio Integer -> u0) -> u4; _NO_DEFLT_ } _N_
- {-defm-} _A_ 1 _U_ 12 _N_ _S_ "U(ASAL)" {_A_ 2 _U_ 122 _N_ _N_ _N_ _N_} _N_ _N_ #-}
+ {-defm-} _A_ 1 _U_ 12 _N_ _S_ "U(LSAA)" {_A_ 2 _U_ 112 _N_ _N_ _N_ _N_} _N_ _N_ #-}
fromRational :: Ratio Integer -> a
{-# GHC_PRAGMA {-meth-} _A_ 1 _U_ 12 _N_ _S_ "U(AAAS)" {_A_ 1 _U_ 12 _N_ _N_ _F_ _IF_ARGS_ 1 1 X 1 _/\_ u0 -> \ (u1 :: Ratio Integer -> u0) -> u1 _N_} _F_ _IF_ARGS_ 1 1 C 2 _/\_ u0 -> \ (u1 :: ({{Num u0}}, u0 -> u0 -> u0, u0 -> u0, Ratio Integer -> u0)) -> case u1 of { _ALG_ _TUP_4 (u2 :: {{Num u0}}) (u3 :: u0 -> u0 -> u0) (u4 :: u0 -> u0) (u5 :: Ratio Integer -> u0) -> u5; _NO_DEFLT_ } _N_
- {-defm-} _A_ 2 _U_ 02 _N_ _S_ _!_ _F_ _IF_ARGS_ 1 2 XX 3 _/\_ u0 -> \ (u1 :: {{Fractional u0}}) (u2 :: Ratio Integer) -> _APP_ _TYAPP_ patError# { (Ratio Integer -> u0) } [ _NOREP_S_ "%DPreludeCore.Fractional.fromRational\"", u2 ] _N_ #-}
+ {-defm-} _A_ 2 _U_ 02 _N_ _S_ _!_ _N_ _N_ #-}
class (Real a, Ix a) => Integral a {-# GHC_PRAGMA {-superdicts-} _A_ 1 _U_ 1 _N_ _S_ "U(U(LLL)AAAAAAAAAAA)" {_A_ 3 _U_ 222 _N_ _N_ _F_ _IF_ARGS_ 1 3 XXX 4 _/\_ u0 -> \ (u1 :: {{Num u0}}) (u2 :: {{Enum u0}}) (u3 :: u0 -> Ratio Integer) -> _!_ _TUP_3 [{{Num u0}}, {{Enum u0}}, (u0 -> Ratio Integer)] [u1, u2, u3] _N_} _F_ _IF_ARGS_ 1 1 C 2 _/\_ u0 -> \ (u1 :: ({{Real u0}}, {{Ix u0}}, u0 -> u0 -> u0, u0 -> u0 -> u0, u0 -> u0 -> u0, u0 -> u0 -> u0, u0 -> u0 -> (u0, u0), u0 -> u0 -> (u0, u0), u0 -> Bool, u0 -> Bool, u0 -> Integer, u0 -> Int)) -> case u1 of { _ALG_ _TUP_12 (u2 :: {{Real u0}}) (u3 :: {{Ix u0}}) (u4 :: u0 -> u0 -> u0) (u5 :: u0 -> u0 -> u0) (u6 :: u0 -> u0 -> u0) (u7 :: u0 -> u0 -> u0) (u8 :: u0 -> u0 -> (u0, u0)) (u9 :: u0 -> u0 -> (u0, u0)) (ua :: u0 -> Bool) (ub :: u0 -> Bool) (uc :: u0 -> Integer) (ud :: u0 -> Int) -> u2; _NO_DEFLT_ } _N_, _A_ 1 _U_ 1 _N_ _S_ "U(AU(LLLL)AAAAAAAAAA)" {_A_ 4 _U_ 2222 _N_ _N_ _F_ _IF_ARGS_ 1 4 XXXX 5 _/\_ u0 -> \ (u1 :: {{Ord u0}}) (u2 :: (u0, u0) -> [u0]) (u3 :: (u0, u0) -> u0 -> Int) (u4 :: (u0, u0) -> u0 -> Bool) -> _!_ _TUP_4 [{{Ord u0}}, ((u0, u0) -> [u0]), ((u0, u0) -> u0 -> Int), ((u0, u0) -> u0 -> Bool)] [u1, u2, u3, u4] _N_} _F_ _IF_ARGS_ 1 1 C 2 _/\_ u0 -> \ (u1 :: ({{Real u0}}, {{Ix u0}}, u0 -> u0 -> u0, u0 -> u0 -> u0, u0 -> u0 -> u0, u0 -> u0 -> u0, u0 -> u0 -> (u0, u0), u0 -> u0 -> (u0, u0), u0 -> Bool, u0 -> Bool, u0 -> Integer, u0 -> Int)) -> case u1 of { _ALG_ _TUP_12 (u2 :: {{Real u0}}) (u3 :: {{Ix u0}}) (u4 :: u0 -> u0 -> u0) (u5 :: u0 -> u0 -> u0) (u6 :: u0 -> u0 -> u0) (u7 :: u0 -> u0 -> u0) (u8 :: u0 -> u0 -> (u0, u0)) (u9 :: u0 -> u0 -> (u0, u0)) (ua :: u0 -> Bool) (ub :: u0 -> Bool) (uc :: u0 -> Integer) (ud :: u0 -> Int) -> u3; _NO_DEFLT_ } _N_ #-} where
quot :: a -> a -> a
{-# GHC_PRAGMA {-meth-} _A_ 1 _U_ 122 _N_ _S_ "U(AASAAAAAAAAA)" {_A_ 1 _U_ 122 _N_ _N_ _F_ _IF_ARGS_ 1 1 X 1 _/\_ u0 -> \ (u1 :: u0 -> u0 -> u0) -> u1 _N_} _F_ _IF_ARGS_ 1 1 C 2 _/\_ u0 -> \ (u1 :: ({{Real u0}}, {{Ix u0}}, u0 -> u0 -> u0, u0 -> u0 -> u0, u0 -> u0 -> u0, u0 -> u0 -> u0, u0 -> u0 -> (u0, u0), u0 -> u0 -> (u0, u0), u0 -> Bool, u0 -> Bool, u0 -> Integer, u0 -> Int)) -> case u1 of { _ALG_ _TUP_12 (u2 :: {{Real u0}}) (u3 :: {{Ix u0}}) (u4 :: u0 -> u0 -> u0) (u5 :: u0 -> u0 -> u0) (u6 :: u0 -> u0 -> u0) (u7 :: u0 -> u0 -> u0) (u8 :: u0 -> u0 -> (u0, u0)) (u9 :: u0 -> u0 -> (u0, u0)) (ua :: u0 -> Bool) (ub :: u0 -> Bool) (uc :: u0 -> Integer) (ud :: u0 -> Int) -> u4; _NO_DEFLT_ } _N_
{-defm-} _A_ 3 _U_ 122 _N_ _S_ "U(AAAAAAASAAAA)LL" {_A_ 3 _U_ 122 _N_ _N_ _F_ _IF_ARGS_ 1 3 XXX 5 _/\_ u0 -> \ (u1 :: u0 -> u0 -> (u0, u0)) (u2 :: u0) (u3 :: u0) -> case _APP_ u1 [ u2, u3 ] of { _ALG_ _TUP_2 (u4 :: u0) (u5 :: u0) -> u5; _NO_DEFLT_ } _N_} _F_ _IF_ARGS_ 1 3 CXX 6 _/\_ u0 -> \ (u1 :: {{Integral u0}}) (u2 :: u0) (u3 :: u0) -> case case u1 of { _ALG_ _TUP_12 (u4 :: {{Real u0}}) (u5 :: {{Ix u0}}) (u6 :: u0 -> u0 -> u0) (u7 :: u0 -> u0 -> u0) (u8 :: u0 -> u0 -> u0) (u9 :: u0 -> u0 -> u0) (ua :: u0 -> u0 -> (u0, u0)) (ub :: u0 -> u0 -> (u0, u0)) (uc :: u0 -> Bool) (ud :: u0 -> Bool) (ue :: u0 -> Integer) (uf :: u0 -> Int) -> _APP_ ub [ u2, u3 ]; _NO_DEFLT_ } of { _ALG_ _TUP_2 (ug :: u0) (uh :: u0) -> uh; _NO_DEFLT_ } _N_ #-}
quotRem :: a -> a -> (a, a)
{-# GHC_PRAGMA {-meth-} _A_ 1 _U_ 122 _N_ _S_ "U(AAAAAASAAAAA)" {_A_ 1 _U_ 122 _N_ _N_ _F_ _IF_ARGS_ 1 1 X 1 _/\_ u0 -> \ (u1 :: u0 -> u0 -> (u0, u0)) -> u1 _N_} _F_ _IF_ARGS_ 1 1 C 2 _/\_ u0 -> \ (u1 :: ({{Real u0}}, {{Ix u0}}, u0 -> u0 -> u0, u0 -> u0 -> u0, u0 -> u0 -> u0, u0 -> u0 -> u0, u0 -> u0 -> (u0, u0), u0 -> u0 -> (u0, u0), u0 -> Bool, u0 -> Bool, u0 -> Integer, u0 -> Int)) -> case u1 of { _ALG_ _TUP_12 (u2 :: {{Real u0}}) (u3 :: {{Ix u0}}) (u4 :: u0 -> u0 -> u0) (u5 :: u0 -> u0 -> u0) (u6 :: u0 -> u0 -> u0) (u7 :: u0 -> u0 -> u0) (u8 :: u0 -> u0 -> (u0, u0)) (u9 :: u0 -> u0 -> (u0, u0)) (ua :: u0 -> Bool) (ub :: u0 -> Bool) (uc :: u0 -> Integer) (ud :: u0 -> Int) -> u8; _NO_DEFLT_ } _N_
- {-defm-} _A_ 3 _U_ 022 _N_ _S_ _!_ _F_ _IF_ARGS_ 1 3 XXX 4 _/\_ u0 -> \ (u1 :: {{Integral u0}}) (u2 :: u0) (u3 :: u0) -> _APP_ _TYAPP_ patError# { (u0 -> u0 -> (u0, u0)) } [ _NOREP_S_ "%DPreludeCore.Integral.quotRem\"", u2, u3 ] _N_ #-}
+ {-defm-} _A_ 3 _U_ 022 _N_ _S_ _!_ _N_ _N_ #-}
divMod :: a -> a -> (a, a)
{-# GHC_PRAGMA {-meth-} _A_ 1 _U_ 122 _N_ _S_ "U(AAAAAAASAAAA)" {_A_ 1 _U_ 122 _N_ _N_ _F_ _IF_ARGS_ 1 1 X 1 _/\_ u0 -> \ (u1 :: u0 -> u0 -> (u0, u0)) -> u1 _N_} _F_ _IF_ARGS_ 1 1 C 2 _/\_ u0 -> \ (u1 :: ({{Real u0}}, {{Ix u0}}, u0 -> u0 -> u0, u0 -> u0 -> u0, u0 -> u0 -> u0, u0 -> u0 -> u0, u0 -> u0 -> (u0, u0), u0 -> u0 -> (u0, u0), u0 -> Bool, u0 -> Bool, u0 -> Integer, u0 -> Int)) -> case u1 of { _ALG_ _TUP_12 (u2 :: {{Real u0}}) (u3 :: {{Ix u0}}) (u4 :: u0 -> u0 -> u0) (u5 :: u0 -> u0 -> u0) (u6 :: u0 -> u0 -> u0) (u7 :: u0 -> u0 -> u0) (u8 :: u0 -> u0 -> (u0, u0)) (u9 :: u0 -> u0 -> (u0, u0)) (ua :: u0 -> Bool) (ub :: u0 -> Bool) (uc :: u0 -> Integer) (ud :: u0 -> Int) -> u9; _NO_DEFLT_ } _N_
- {-defm-} _A_ 1 _U_ 122 _N_ _S_ "U(U(U(U(SA)ALLALALLA)AA)AAAAALAAAAA)" {_A_ 2 _U_ 1222 _N_ _N_ _N_ _N_} _N_ _N_ #-}
+ {-defm-} _A_ 1 _U_ 122 _N_ _S_ "U(U(U(U(SA)ALLALALAL)AA)AAAAALAAAAA)" {_A_ 2 _U_ 1222 _N_ _N_ _N_ _N_} _N_ _N_ #-}
even :: a -> Bool
{-# GHC_PRAGMA {-meth-} _A_ 1 _U_ 12 _N_ _S_ "U(AAAAAAAASAAA)" {_A_ 1 _U_ 12 _N_ _N_ _F_ _IF_ARGS_ 1 1 X 1 _/\_ u0 -> \ (u1 :: u0 -> Bool) -> u1 _N_} _F_ _IF_ARGS_ 1 1 C 2 _/\_ u0 -> \ (u1 :: ({{Real u0}}, {{Ix u0}}, u0 -> u0 -> u0, u0 -> u0 -> u0, u0 -> u0 -> u0, u0 -> u0 -> u0, u0 -> u0 -> (u0, u0), u0 -> u0 -> (u0, u0), u0 -> Bool, u0 -> Bool, u0 -> Integer, u0 -> Int)) -> case u1 of { _ALG_ _TUP_12 (u2 :: {{Real u0}}) (u3 :: {{Ix u0}}) (u4 :: u0 -> u0 -> u0) (u5 :: u0 -> u0 -> u0) (u6 :: u0 -> u0 -> u0) (u7 :: u0 -> u0 -> u0) (u8 :: u0 -> u0 -> (u0, u0)) (u9 :: u0 -> u0 -> (u0, u0)) (ua :: u0 -> Bool) (ub :: u0 -> Bool) (uc :: u0 -> Integer) (ud :: u0 -> Int) -> ua; _NO_DEFLT_ } _N_
- {-defm-} _A_ 1 _U_ 12 _N_ _S_ "U(U(U(U(SA)AAAAAAALA)AA)AALAAAAAAAA)" {_A_ 3 _U_ 1212 _N_ _N_ _N_ _N_} _N_ _N_ #-}
+ {-defm-} _A_ 1 _U_ 12 _N_ _S_ "U(U(U(U(SA)AAAAAAAAL)AA)AALAAAAAAAA)" {_A_ 3 _U_ 1212 _N_ _N_ _N_ _N_} _N_ _N_ #-}
odd :: a -> Bool
{-# GHC_PRAGMA {-meth-} _A_ 1 _U_ 12 _N_ _S_ "U(AAAAAAAAASAA)" {_A_ 1 _U_ 12 _N_ _N_ _F_ _IF_ARGS_ 1 1 X 1 _/\_ u0 -> \ (u1 :: u0 -> Bool) -> u1 _N_} _F_ _IF_ARGS_ 1 1 C 2 _/\_ u0 -> \ (u1 :: ({{Real u0}}, {{Ix u0}}, u0 -> u0 -> u0, u0 -> u0 -> u0, u0 -> u0 -> u0, u0 -> u0 -> u0, u0 -> u0 -> (u0, u0), u0 -> u0 -> (u0, u0), u0 -> Bool, u0 -> Bool, u0 -> Integer, u0 -> Int)) -> case u1 of { _ALG_ _TUP_12 (u2 :: {{Real u0}}) (u3 :: {{Ix u0}}) (u4 :: u0 -> u0 -> u0) (u5 :: u0 -> u0 -> u0) (u6 :: u0 -> u0 -> u0) (u7 :: u0 -> u0 -> u0) (u8 :: u0 -> u0 -> (u0, u0)) (u9 :: u0 -> u0 -> (u0, u0)) (ua :: u0 -> Bool) (ub :: u0 -> Bool) (uc :: u0 -> Integer) (ud :: u0 -> Int) -> ub; _NO_DEFLT_ } _N_
- {-defm-} _A_ 1 _U_ 12 _N_ _S_ "U(U(U(U(AS)AAAAAAALA)AA)AALAAAAAAAA)" {_A_ 3 _U_ 1212 _N_ _N_ _N_ _N_} _N_ _N_ #-}
+ {-defm-} _A_ 1 _U_ 12 _N_ _S_ "U(U(U(U(AS)AAAAAAAAL)AA)AALAAAAAAAA)" {_A_ 3 _U_ 1212 _N_ _N_ _N_ _N_} _N_ _N_ #-}
toInteger :: a -> Integer
{-# GHC_PRAGMA {-meth-} _A_ 1 _U_ 12 _N_ _S_ "U(AAAAAAAAAASA)" {_A_ 1 _U_ 12 _N_ _N_ _F_ _IF_ARGS_ 1 1 X 1 _/\_ u0 -> \ (u1 :: u0 -> Integer) -> u1 _N_} _F_ _IF_ARGS_ 1 1 C 2 _/\_ u0 -> \ (u1 :: ({{Real u0}}, {{Ix u0}}, u0 -> u0 -> u0, u0 -> u0 -> u0, u0 -> u0 -> u0, u0 -> u0 -> u0, u0 -> u0 -> (u0, u0), u0 -> u0 -> (u0, u0), u0 -> Bool, u0 -> Bool, u0 -> Integer, u0 -> Int)) -> case u1 of { _ALG_ _TUP_12 (u2 :: {{Real u0}}) (u3 :: {{Ix u0}}) (u4 :: u0 -> u0 -> u0) (u5 :: u0 -> u0 -> u0) (u6 :: u0 -> u0 -> u0) (u7 :: u0 -> u0 -> u0) (u8 :: u0 -> u0 -> (u0, u0)) (u9 :: u0 -> u0 -> (u0, u0)) (ua :: u0 -> Bool) (ub :: u0 -> Bool) (uc :: u0 -> Integer) (ud :: u0 -> Int) -> uc; _NO_DEFLT_ } _N_
- {-defm-} _A_ 2 _U_ 02 _N_ _S_ _!_ _F_ _IF_ARGS_ 1 2 XX 3 _/\_ u0 -> \ (u1 :: {{Integral u0}}) (u2 :: u0) -> _APP_ _TYAPP_ patError# { (u0 -> Integer) } [ _NOREP_S_ "%DPreludeCore.Integral.toInteger\"", u2 ] _N_ #-}
+ {-defm-} _A_ 2 _U_ 02 _N_ _S_ _!_ _N_ _N_ #-}
toInt :: a -> Int
{-# GHC_PRAGMA {-meth-} _A_ 1 _U_ 12 _N_ _S_ "U(AAAAAAAAAAAS)" {_A_ 1 _U_ 12 _N_ _N_ _F_ _IF_ARGS_ 1 1 X 1 _/\_ u0 -> \ (u1 :: u0 -> Int) -> u1 _N_} _F_ _IF_ARGS_ 1 1 C 2 _/\_ u0 -> \ (u1 :: ({{Real u0}}, {{Ix u0}}, u0 -> u0 -> u0, u0 -> u0 -> u0, u0 -> u0 -> u0, u0 -> u0 -> u0, u0 -> u0 -> (u0, u0), u0 -> u0 -> (u0, u0), u0 -> Bool, u0 -> Bool, u0 -> Integer, u0 -> Int)) -> case u1 of { _ALG_ _TUP_12 (u2 :: {{Real u0}}) (u3 :: {{Ix u0}}) (u4 :: u0 -> u0 -> u0) (u5 :: u0 -> u0 -> u0) (u6 :: u0 -> u0 -> u0) (u7 :: u0 -> u0 -> u0) (u8 :: u0 -> u0 -> (u0, u0)) (u9 :: u0 -> u0 -> (u0, u0)) (ua :: u0 -> Bool) (ub :: u0 -> Bool) (uc :: u0 -> Integer) (ud :: u0 -> Int) -> ud; _NO_DEFLT_ } _N_
- {-defm-} _A_ 2 _U_ 02 _N_ _S_ _!_ _F_ _IF_ARGS_ 1 2 XX 3 _/\_ u0 -> \ (u1 :: {{Integral u0}}) (u2 :: u0) -> _APP_ _TYAPP_ patError# { (u0 -> Int) } [ _NOREP_S_ "%DPreludeCore.Integral.toInt\"", u2 ] _N_ #-}
+ {-defm-} _A_ 2 _U_ 02 _N_ _S_ _!_ _N_ _N_ #-}
class (Ord a) => Ix a {-# GHC_PRAGMA {-superdicts-} _A_ 1 _U_ 1 _N_ _S_ "U(U(LLLLLLLL)AAA)" {_A_ 1 _U_ 1 _N_ _N_ _F_ _IF_ARGS_ 1 1 X 1 _/\_ u0 -> \ (u1 :: {{Ord u0}}) -> u1 _N_} _F_ _IF_ARGS_ 1 1 C 2 _/\_ u0 -> \ (u1 :: ({{Ord u0}}, (u0, u0) -> [u0], (u0, u0) -> u0 -> Int, (u0, u0) -> u0 -> Bool)) -> case u1 of { _ALG_ _TUP_4 (u2 :: {{Ord u0}}) (u3 :: (u0, u0) -> [u0]) (u4 :: (u0, u0) -> u0 -> Int) (u5 :: (u0, u0) -> u0 -> Bool) -> u2; _NO_DEFLT_ } _N_ #-} where
range :: (a, a) -> [a]
{-# GHC_PRAGMA {-meth-} _A_ 1 _U_ 12 _N_ _S_ "U(ASAA)" {_A_ 1 _U_ 12 _N_ _N_ _F_ _IF_ARGS_ 1 1 X 1 _/\_ u0 -> \ (u1 :: (u0, u0) -> [u0]) -> u1 _N_} _F_ _IF_ARGS_ 1 1 C 2 _/\_ u0 -> \ (u1 :: ({{Ord u0}}, (u0, u0) -> [u0], (u0, u0) -> u0 -> Int, (u0, u0) -> u0 -> Bool)) -> case u1 of { _ALG_ _TUP_4 (u2 :: {{Ord u0}}) (u3 :: (u0, u0) -> [u0]) (u4 :: (u0, u0) -> u0 -> Int) (u5 :: (u0, u0) -> u0 -> Bool) -> u3; _NO_DEFLT_ } _N_
- {-defm-} _A_ 2 _U_ 02 _N_ _S_ _!_ _F_ _IF_ARGS_ 1 2 XX 3 _/\_ u0 -> \ (u1 :: {{Ix u0}}) (u2 :: (u0, u0)) -> _APP_ _TYAPP_ patError# { ((u0, u0) -> [u0]) } [ _NOREP_S_ "%DPreludeCore.Ix.range\"", u2 ] _N_ #-}
+ {-defm-} _A_ 2 _U_ 02 _N_ _S_ _!_ _N_ _N_ #-}
index :: (a, a) -> a -> Int
{-# GHC_PRAGMA {-meth-} _A_ 1 _U_ 122 _N_ _S_ "U(AASA)" {_A_ 1 _U_ 122 _N_ _N_ _F_ _IF_ARGS_ 1 1 X 1 _/\_ u0 -> \ (u1 :: (u0, u0) -> u0 -> Int) -> u1 _N_} _F_ _IF_ARGS_ 1 1 C 2 _/\_ u0 -> \ (u1 :: ({{Ord u0}}, (u0, u0) -> [u0], (u0, u0) -> u0 -> Int, (u0, u0) -> u0 -> Bool)) -> case u1 of { _ALG_ _TUP_4 (u2 :: {{Ord u0}}) (u3 :: (u0, u0) -> [u0]) (u4 :: (u0, u0) -> u0 -> Int) (u5 :: (u0, u0) -> u0 -> Bool) -> u4; _NO_DEFLT_ } _N_
- {-defm-} _A_ 3 _U_ 022 _N_ _S_ _!_ _F_ _IF_ARGS_ 1 3 XXX 4 _/\_ u0 -> \ (u1 :: {{Ix u0}}) (u2 :: (u0, u0)) (u3 :: u0) -> _APP_ _TYAPP_ patError# { ((u0, u0) -> u0 -> Int) } [ _NOREP_S_ "%DPreludeCore.Ix.index\"", u2, u3 ] _N_ #-}
+ {-defm-} _A_ 3 _U_ 022 _N_ _S_ _!_ _N_ _N_ #-}
inRange :: (a, a) -> a -> Bool
{-# GHC_PRAGMA {-meth-} _A_ 1 _U_ 122 _N_ _S_ "U(AAAS)" {_A_ 1 _U_ 122 _N_ _N_ _F_ _IF_ARGS_ 1 1 X 1 _/\_ u0 -> \ (u1 :: (u0, u0) -> u0 -> Bool) -> u1 _N_} _F_ _IF_ARGS_ 1 1 C 2 _/\_ u0 -> \ (u1 :: ({{Ord u0}}, (u0, u0) -> [u0], (u0, u0) -> u0 -> Int, (u0, u0) -> u0 -> Bool)) -> case u1 of { _ALG_ _TUP_4 (u2 :: {{Ord u0}}) (u3 :: (u0, u0) -> [u0]) (u4 :: (u0, u0) -> u0 -> Int) (u5 :: (u0, u0) -> u0 -> Bool) -> u5; _NO_DEFLT_ } _N_
- {-defm-} _A_ 3 _U_ 022 _N_ _S_ _!_ _F_ _IF_ARGS_ 1 3 XXX 4 _/\_ u0 -> \ (u1 :: {{Ix u0}}) (u2 :: (u0, u0)) (u3 :: u0) -> _APP_ _TYAPP_ patError# { ((u0, u0) -> u0 -> Bool) } [ _NOREP_S_ "%DPreludeCore.Ix.inRange\"", u2, u3 ] _N_ #-}
+ {-defm-} _A_ 3 _U_ 022 _N_ _S_ _!_ _N_ _N_ #-}
class (Eq a, Text a) => Num a {-# GHC_PRAGMA {-superdicts-} _A_ 1 _U_ 1 _N_ _S_ "U(U(LL)AAAAAAAAA)" {_A_ 2 _U_ 22 _N_ _N_ _F_ _IF_ARGS_ 1 2 XX 3 _/\_ u0 -> \ (u1 :: u0 -> u0 -> Bool) (u2 :: u0 -> u0 -> Bool) -> _!_ _TUP_2 [(u0 -> u0 -> Bool), (u0 -> u0 -> Bool)] [u1, u2] _N_} _F_ _IF_ARGS_ 1 1 C 2 _/\_ u0 -> \ (u1 :: ({{Eq u0}}, {{Text u0}}, u0 -> u0 -> u0, u0 -> u0 -> u0, u0 -> u0 -> u0, u0 -> u0, u0 -> u0, u0 -> u0, Integer -> u0, Int -> u0)) -> case u1 of { _ALG_ _TUP_10 (u2 :: {{Eq u0}}) (u3 :: {{Text u0}}) (u4 :: u0 -> u0 -> u0) (u5 :: u0 -> u0 -> u0) (u6 :: u0 -> u0 -> u0) (u7 :: u0 -> u0) (u8 :: u0 -> u0) (u9 :: u0 -> u0) (ua :: Integer -> u0) (ub :: Int -> u0) -> u2; _NO_DEFLT_ } _N_, _A_ 1 _U_ 1 _N_ _S_ "U(AU(LLLL)AAAAAAAA)" {_A_ 4 _U_ 2222 _N_ _N_ _F_ _IF_ARGS_ 1 4 XXXX 5 _/\_ u0 -> \ (u1 :: Int -> [Char] -> [(u0, [Char])]) (u2 :: Int -> u0 -> [Char] -> [Char]) (u3 :: [Char] -> [([u0], [Char])]) (u4 :: [u0] -> [Char] -> [Char]) -> _!_ _TUP_4 [(Int -> [Char] -> [(u0, [Char])]), (Int -> u0 -> [Char] -> [Char]), ([Char] -> [([u0], [Char])]), ([u0] -> [Char] -> [Char])] [u1, u2, u3, u4] _N_} _F_ _IF_ARGS_ 1 1 C 2 _/\_ u0 -> \ (u1 :: ({{Eq u0}}, {{Text u0}}, u0 -> u0 -> u0, u0 -> u0 -> u0, u0 -> u0 -> u0, u0 -> u0, u0 -> u0, u0 -> u0, Integer -> u0, Int -> u0)) -> case u1 of { _ALG_ _TUP_10 (u2 :: {{Eq u0}}) (u3 :: {{Text u0}}) (u4 :: u0 -> u0 -> u0) (u5 :: u0 -> u0 -> u0) (u6 :: u0 -> u0 -> u0) (u7 :: u0 -> u0) (u8 :: u0 -> u0) (u9 :: u0 -> u0) (ua :: Integer -> u0) (ub :: Int -> u0) -> u3; _NO_DEFLT_ } _N_ #-} where
(+) :: a -> a -> a
{-# GHC_PRAGMA {-meth-} _A_ 1 _U_ 122 _N_ _S_ "U(AASAAAAAAA)" {_A_ 1 _U_ 122 _N_ _N_ _F_ _IF_ARGS_ 1 1 X 1 _/\_ u0 -> \ (u1 :: u0 -> u0 -> u0) -> u1 _N_} _F_ _IF_ARGS_ 1 1 C 2 _/\_ u0 -> \ (u1 :: ({{Eq u0}}, {{Text u0}}, u0 -> u0 -> u0, u0 -> u0 -> u0, u0 -> u0 -> u0, u0 -> u0, u0 -> u0, u0 -> u0, Integer -> u0, Int -> u0)) -> case u1 of { _ALG_ _TUP_10 (u2 :: {{Eq u0}}) (u3 :: {{Text u0}}) (u4 :: u0 -> u0 -> u0) (u5 :: u0 -> u0 -> u0) (u6 :: u0 -> u0 -> u0) (u7 :: u0 -> u0) (u8 :: u0 -> u0) (u9 :: u0 -> u0) (ua :: Integer -> u0) (ub :: Int -> u0) -> u4; _NO_DEFLT_ } _N_
- {-defm-} _A_ 3 _U_ 022 _N_ _S_ _!_ _F_ _IF_ARGS_ 1 3 XXX 4 _/\_ u0 -> \ (u1 :: {{Num u0}}) (u2 :: u0) (u3 :: u0) -> _APP_ _TYAPP_ patError# { (u0 -> u0 -> u0) } [ _NOREP_S_ "%DPreludeCore.Num.(+)\"", u2, u3 ] _N_ #-}
+ {-defm-} _A_ 3 _U_ 022 _N_ _S_ _!_ _N_ _N_ #-}
(-) :: a -> a -> a
{-# GHC_PRAGMA {-meth-} _A_ 1 _U_ 122 _N_ _S_ "U(AAASAAAAAA)" {_A_ 1 _U_ 122 _N_ _N_ _F_ _IF_ARGS_ 1 1 X 1 _/\_ u0 -> \ (u1 :: u0 -> u0 -> u0) -> u1 _N_} _F_ _IF_ARGS_ 1 1 C 2 _/\_ u0 -> \ (u1 :: ({{Eq u0}}, {{Text u0}}, u0 -> u0 -> u0, u0 -> u0 -> u0, u0 -> u0 -> u0, u0 -> u0, u0 -> u0, u0 -> u0, Integer -> u0, Int -> u0)) -> case u1 of { _ALG_ _TUP_10 (u2 :: {{Eq u0}}) (u3 :: {{Text u0}}) (u4 :: u0 -> u0 -> u0) (u5 :: u0 -> u0 -> u0) (u6 :: u0 -> u0 -> u0) (u7 :: u0 -> u0) (u8 :: u0 -> u0) (u9 :: u0 -> u0) (ua :: Integer -> u0) (ub :: Int -> u0) -> u5; _NO_DEFLT_ } _N_
{-defm-} _A_ 3 _U_ 122 _N_ _S_ "U(AASAALAAAA)LL" {_A_ 4 _U_ 1122 _N_ _N_ _F_ _IF_ARGS_ 1 4 XXXX 6 _/\_ u0 -> \ (u1 :: u0 -> u0 -> u0) (u2 :: u0 -> u0) (u3 :: u0) (u4 :: u0) -> let {(u5 :: u0) = _APP_ u2 [ u4 ]} in _APP_ u1 [ u3, u5 ] _N_} _F_ _ALWAYS_ _/\_ u0 -> \ (u1 :: {{Num u0}}) (u2 :: u0) (u3 :: u0) -> case u1 of { _ALG_ _TUP_10 (u4 :: {{Eq u0}}) (u5 :: {{Text u0}}) (u6 :: u0 -> u0 -> u0) (u7 :: u0 -> u0 -> u0) (u8 :: u0 -> u0 -> u0) (u9 :: u0 -> u0) (ua :: u0 -> u0) (ub :: u0 -> u0) (uc :: Integer -> u0) (ud :: Int -> u0) -> let {(ue :: u0) = _APP_ u9 [ u3 ]} in _APP_ u6 [ u2, ue ]; _NO_DEFLT_ } _N_ #-}
(*) :: a -> a -> a
{-# GHC_PRAGMA {-meth-} _A_ 1 _U_ 122 _N_ _S_ "U(AAAASAAAAA)" {_A_ 1 _U_ 122 _N_ _N_ _F_ _IF_ARGS_ 1 1 X 1 _/\_ u0 -> \ (u1 :: u0 -> u0 -> u0) -> u1 _N_} _F_ _IF_ARGS_ 1 1 C 2 _/\_ u0 -> \ (u1 :: ({{Eq u0}}, {{Text u0}}, u0 -> u0 -> u0, u0 -> u0 -> u0, u0 -> u0 -> u0, u0 -> u0, u0 -> u0, u0 -> u0, Integer -> u0, Int -> u0)) -> case u1 of { _ALG_ _TUP_10 (u2 :: {{Eq u0}}) (u3 :: {{Text u0}}) (u4 :: u0 -> u0 -> u0) (u5 :: u0 -> u0 -> u0) (u6 :: u0 -> u0 -> u0) (u7 :: u0 -> u0) (u8 :: u0 -> u0) (u9 :: u0 -> u0) (ua :: Integer -> u0) (ub :: Int -> u0) -> u6; _NO_DEFLT_ } _N_
- {-defm-} _A_ 3 _U_ 022 _N_ _S_ _!_ _F_ _IF_ARGS_ 1 3 XXX 4 _/\_ u0 -> \ (u1 :: {{Num u0}}) (u2 :: u0) (u3 :: u0) -> _APP_ _TYAPP_ patError# { (u0 -> u0 -> u0) } [ _NOREP_S_ "%DPreludeCore.Num.(*)\"", u2, u3 ] _N_ #-}
+ {-defm-} _A_ 3 _U_ 022 _N_ _S_ _!_ _N_ _N_ #-}
negate :: a -> a
{-# GHC_PRAGMA {-meth-} _A_ 1 _U_ 12 _N_ _S_ "U(AAAAASAAAA)" {_A_ 1 _U_ 12 _N_ _N_ _F_ _IF_ARGS_ 1 1 X 1 _/\_ u0 -> \ (u1 :: u0 -> u0) -> u1 _N_} _F_ _IF_ARGS_ 1 1 C 2 _/\_ u0 -> \ (u1 :: ({{Eq u0}}, {{Text u0}}, u0 -> u0 -> u0, u0 -> u0 -> u0, u0 -> u0 -> u0, u0 -> u0, u0 -> u0, u0 -> u0, Integer -> u0, Int -> u0)) -> case u1 of { _ALG_ _TUP_10 (u2 :: {{Eq u0}}) (u3 :: {{Text u0}}) (u4 :: u0 -> u0 -> u0) (u5 :: u0 -> u0 -> u0) (u6 :: u0 -> u0 -> u0) (u7 :: u0 -> u0) (u8 :: u0 -> u0) (u9 :: u0 -> u0) (ua :: Integer -> u0) (ub :: Int -> u0) -> u7; _NO_DEFLT_ } _N_
- {-defm-} _A_ 2 _U_ 02 _N_ _S_ _!_ _F_ _IF_ARGS_ 1 2 XX 3 _/\_ u0 -> \ (u1 :: {{Num u0}}) (u2 :: u0) -> _APP_ _TYAPP_ patError# { (u0 -> u0) } [ _NOREP_S_ "%DPreludeCore.Num.negate\"", u2 ] _N_ #-}
+ {-defm-} _A_ 2 _U_ 02 _N_ _S_ _!_ _N_ _N_ #-}
abs :: a -> a
{-# GHC_PRAGMA {-meth-} _A_ 1 _U_ 12 _N_ _S_ "U(AAAAAASAAA)" {_A_ 1 _U_ 12 _N_ _N_ _F_ _IF_ARGS_ 1 1 X 1 _/\_ u0 -> \ (u1 :: u0 -> u0) -> u1 _N_} _F_ _IF_ARGS_ 1 1 C 2 _/\_ u0 -> \ (u1 :: ({{Eq u0}}, {{Text u0}}, u0 -> u0 -> u0, u0 -> u0 -> u0, u0 -> u0 -> u0, u0 -> u0, u0 -> u0, u0 -> u0, Integer -> u0, Int -> u0)) -> case u1 of { _ALG_ _TUP_10 (u2 :: {{Eq u0}}) (u3 :: {{Text u0}}) (u4 :: u0 -> u0 -> u0) (u5 :: u0 -> u0 -> u0) (u6 :: u0 -> u0 -> u0) (u7 :: u0 -> u0) (u8 :: u0 -> u0) (u9 :: u0 -> u0) (ua :: Integer -> u0) (ub :: Int -> u0) -> u8; _NO_DEFLT_ } _N_
- {-defm-} _A_ 2 _U_ 02 _N_ _S_ _!_ _F_ _IF_ARGS_ 1 2 XX 3 _/\_ u0 -> \ (u1 :: {{Num u0}}) (u2 :: u0) -> _APP_ _TYAPP_ patError# { (u0 -> u0) } [ _NOREP_S_ "%DPreludeCore.Num.abs\"", u2 ] _N_ #-}
+ {-defm-} _A_ 2 _U_ 02 _N_ _S_ _!_ _N_ _N_ #-}
signum :: a -> a
{-# GHC_PRAGMA {-meth-} _A_ 1 _U_ 12 _N_ _S_ "U(AAAAAAASAA)" {_A_ 1 _U_ 12 _N_ _N_ _F_ _IF_ARGS_ 1 1 X 1 _/\_ u0 -> \ (u1 :: u0 -> u0) -> u1 _N_} _F_ _IF_ARGS_ 1 1 C 2 _/\_ u0 -> \ (u1 :: ({{Eq u0}}, {{Text u0}}, u0 -> u0 -> u0, u0 -> u0 -> u0, u0 -> u0 -> u0, u0 -> u0, u0 -> u0, u0 -> u0, Integer -> u0, Int -> u0)) -> case u1 of { _ALG_ _TUP_10 (u2 :: {{Eq u0}}) (u3 :: {{Text u0}}) (u4 :: u0 -> u0 -> u0) (u5 :: u0 -> u0 -> u0) (u6 :: u0 -> u0 -> u0) (u7 :: u0 -> u0) (u8 :: u0 -> u0) (u9 :: u0 -> u0) (ua :: Integer -> u0) (ub :: Int -> u0) -> u9; _NO_DEFLT_ } _N_
- {-defm-} _A_ 2 _U_ 02 _N_ _S_ _!_ _F_ _IF_ARGS_ 1 2 XX 3 _/\_ u0 -> \ (u1 :: {{Num u0}}) (u2 :: u0) -> _APP_ _TYAPP_ patError# { (u0 -> u0) } [ _NOREP_S_ "%DPreludeCore.Num.signum\"", u2 ] _N_ #-}
+ {-defm-} _A_ 2 _U_ 02 _N_ _S_ _!_ _N_ _N_ #-}
fromInteger :: Integer -> a
{-# GHC_PRAGMA {-meth-} _A_ 1 _U_ 12 _N_ _S_ "U(AAAAAAAASA)" {_A_ 1 _U_ 12 _N_ _N_ _F_ _IF_ARGS_ 1 1 X 1 _/\_ u0 -> \ (u1 :: Integer -> u0) -> u1 _N_} _F_ _IF_ARGS_ 1 1 C 2 _/\_ u0 -> \ (u1 :: ({{Eq u0}}, {{Text u0}}, u0 -> u0 -> u0, u0 -> u0 -> u0, u0 -> u0 -> u0, u0 -> u0, u0 -> u0, u0 -> u0, Integer -> u0, Int -> u0)) -> case u1 of { _ALG_ _TUP_10 (u2 :: {{Eq u0}}) (u3 :: {{Text u0}}) (u4 :: u0 -> u0 -> u0) (u5 :: u0 -> u0 -> u0) (u6 :: u0 -> u0 -> u0) (u7 :: u0 -> u0) (u8 :: u0 -> u0) (u9 :: u0 -> u0) (ua :: Integer -> u0) (ub :: Int -> u0) -> ua; _NO_DEFLT_ } _N_
- {-defm-} _A_ 2 _U_ 02 _N_ _S_ _!_ _F_ _IF_ARGS_ 1 2 XX 3 _/\_ u0 -> \ (u1 :: {{Num u0}}) (u2 :: Integer) -> _APP_ _TYAPP_ patError# { (Integer -> u0) } [ _NOREP_S_ "%DPreludeCore.Num.fromInteger\"", u2 ] _N_ #-}
+ {-defm-} _A_ 2 _U_ 02 _N_ _S_ _!_ _N_ _N_ #-}
fromInt :: Int -> a
{-# GHC_PRAGMA {-meth-} _A_ 1 _U_ 12 _N_ _S_ "U(AAAAAAAAAS)" {_A_ 1 _U_ 12 _N_ _N_ _F_ _IF_ARGS_ 1 1 X 1 _/\_ u0 -> \ (u1 :: Int -> u0) -> u1 _N_} _F_ _IF_ARGS_ 1 1 C 2 _/\_ u0 -> \ (u1 :: ({{Eq u0}}, {{Text u0}}, u0 -> u0 -> u0, u0 -> u0 -> u0, u0 -> u0 -> u0, u0 -> u0, u0 -> u0, u0 -> u0, Integer -> u0, Int -> u0)) -> case u1 of { _ALG_ _TUP_10 (u2 :: {{Eq u0}}) (u3 :: {{Text u0}}) (u4 :: u0 -> u0 -> u0) (u5 :: u0 -> u0 -> u0) (u6 :: u0 -> u0 -> u0) (u7 :: u0 -> u0) (u8 :: u0 -> u0) (u9 :: u0 -> u0) (ua :: Integer -> u0) (ub :: Int -> u0) -> ub; _NO_DEFLT_ } _N_
{-defm-} _A_ 2 _U_ 11 _N_ _S_ "U(AAAAAAAASA)L" {_A_ 2 _U_ 11 _N_ _N_ _F_ _IF_ARGS_ 1 2 XC 5 _/\_ u0 -> \ (u1 :: Integer -> u0) (u2 :: Int) -> let {(u4 :: Integer) = case u2 of { _ALG_ I# (u3 :: Int#) -> _#_ int2Integer# [] [u3]; _NO_DEFLT_ }} in _APP_ u1 [ u4 ] _N_} _F_ _IF_ARGS_ 1 2 CC 6 _/\_ u0 -> \ (u1 :: {{Num u0}}) (u2 :: Int) -> let {(u4 :: Integer) = case u2 of { _ALG_ I# (u3 :: Int#) -> _#_ int2Integer# [] [u3]; _NO_DEFLT_ }} in case u1 of { _ALG_ _TUP_10 (u5 :: {{Eq u0}}) (u6 :: {{Text u0}}) (u7 :: u0 -> u0 -> u0) (u8 :: u0 -> u0 -> u0) (u9 :: u0 -> u0 -> u0) (ua :: u0 -> u0) (ub :: u0 -> u0) (uc :: u0 -> u0) (ud :: Integer -> u0) (ue :: Int -> u0) -> _APP_ ud [ u4 ]; _NO_DEFLT_ } _N_ #-}
{-defm-} _A_ 3 _U_ 122 _N_ _S_ "U(LASAAAAA)LL" {_A_ 4 _U_ 1122 _N_ _N_ _N_ _N_} _N_ _N_ #-}
(<=) :: a -> a -> Bool
{-# GHC_PRAGMA {-meth-} _A_ 1 _U_ 122 _N_ _S_ "U(AASAAAAA)" {_A_ 1 _U_ 122 _N_ _N_ _F_ _IF_ARGS_ 1 1 X 1 _/\_ u0 -> \ (u1 :: u0 -> u0 -> Bool) -> u1 _N_} _F_ _IF_ARGS_ 1 1 C 2 _/\_ u0 -> \ (u1 :: ({{Eq u0}}, u0 -> u0 -> Bool, u0 -> u0 -> Bool, u0 -> u0 -> Bool, u0 -> u0 -> Bool, u0 -> u0 -> u0, u0 -> u0 -> u0, u0 -> u0 -> _CMP_TAG)) -> case u1 of { _ALG_ _TUP_8 (u2 :: {{Eq u0}}) (u3 :: u0 -> u0 -> Bool) (u4 :: u0 -> u0 -> Bool) (u5 :: u0 -> u0 -> Bool) (u6 :: u0 -> u0 -> Bool) (u7 :: u0 -> u0 -> u0) (u8 :: u0 -> u0 -> u0) (u9 :: u0 -> u0 -> _CMP_TAG) -> u4; _NO_DEFLT_ } _N_
- {-defm-} _A_ 3 _U_ 022 _N_ _S_ _!_ _F_ _IF_ARGS_ 1 3 XXX 4 _/\_ u0 -> \ (u1 :: {{Ord u0}}) (u2 :: u0) (u3 :: u0) -> _APP_ _TYAPP_ patError# { (u0 -> u0 -> Bool) } [ _NOREP_S_ "%DPreludeCore.Ord.(<=)\"", u2, u3 ] _N_ #-}
+ {-defm-} _A_ 3 _U_ 022 _N_ _S_ _!_ _N_ _N_ #-}
(>=) :: a -> a -> Bool
{-# GHC_PRAGMA {-meth-} _A_ 1 _U_ 122 _N_ _S_ "U(AAASAAAA)" {_A_ 1 _U_ 122 _N_ _N_ _F_ _IF_ARGS_ 1 1 X 1 _/\_ u0 -> \ (u1 :: u0 -> u0 -> Bool) -> u1 _N_} _F_ _IF_ARGS_ 1 1 C 2 _/\_ u0 -> \ (u1 :: ({{Eq u0}}, u0 -> u0 -> Bool, u0 -> u0 -> Bool, u0 -> u0 -> Bool, u0 -> u0 -> Bool, u0 -> u0 -> u0, u0 -> u0 -> u0, u0 -> u0 -> _CMP_TAG)) -> case u1 of { _ALG_ _TUP_8 (u2 :: {{Eq u0}}) (u3 :: u0 -> u0 -> Bool) (u4 :: u0 -> u0 -> Bool) (u5 :: u0 -> u0 -> Bool) (u6 :: u0 -> u0 -> Bool) (u7 :: u0 -> u0 -> u0) (u8 :: u0 -> u0 -> u0) (u9 :: u0 -> u0 -> _CMP_TAG) -> u5; _NO_DEFLT_ } _N_
{-defm-} _A_ 3 _U_ 122 _N_ _S_ "U(AASAAAAA)LL" {_A_ 3 _U_ 122 _N_ _N_ _F_ _IF_ARGS_ 1 3 XXX 3 _/\_ u0 -> \ (u1 :: u0 -> u0 -> Bool) (u2 :: u0) (u3 :: u0) -> _APP_ u1 [ u3, u2 ] _N_} _F_ _IF_ARGS_ 1 3 CXX 4 _/\_ u0 -> \ (u1 :: {{Ord u0}}) (u2 :: u0) (u3 :: u0) -> case u1 of { _ALG_ _TUP_8 (u4 :: {{Eq u0}}) (u5 :: u0 -> u0 -> Bool) (u6 :: u0 -> u0 -> Bool) (u7 :: u0 -> u0 -> Bool) (u8 :: u0 -> u0 -> Bool) (u9 :: u0 -> u0 -> u0) (ua :: u0 -> u0 -> u0) (ub :: u0 -> u0 -> _CMP_TAG) -> _APP_ u6 [ u3, u2 ]; _NO_DEFLT_ } _N_ #-}
class (Num a, Enum a) => Real a {-# GHC_PRAGMA {-superdicts-} _A_ 1 _U_ 1 _N_ _S_ "U(U(LLLLLLLLLL)AA)" {_A_ 1 _U_ 1 _N_ _N_ _F_ _IF_ARGS_ 1 1 X 1 _/\_ u0 -> \ (u1 :: {{Num u0}}) -> u1 _N_} _F_ _IF_ARGS_ 1 1 C 2 _/\_ u0 -> \ (u1 :: ({{Num u0}}, {{Enum u0}}, u0 -> Ratio Integer)) -> case u1 of { _ALG_ _TUP_3 (u2 :: {{Num u0}}) (u3 :: {{Enum u0}}) (u4 :: u0 -> Ratio Integer) -> u2; _NO_DEFLT_ } _N_, _A_ 1 _U_ 1 _N_ _S_ "U(AU(LLLLL)A)" {_A_ 5 _U_ 22222 _N_ _N_ _F_ _IF_ARGS_ 1 5 XXXXX 6 _/\_ u0 -> \ (u1 :: {{Ord u0}}) (u2 :: u0 -> [u0]) (u3 :: u0 -> u0 -> [u0]) (u4 :: u0 -> u0 -> [u0]) (u5 :: u0 -> u0 -> u0 -> [u0]) -> _!_ _TUP_5 [{{Ord u0}}, (u0 -> [u0]), (u0 -> u0 -> [u0]), (u0 -> u0 -> [u0]), (u0 -> u0 -> u0 -> [u0])] [u1, u2, u3, u4, u5] _N_} _F_ _IF_ARGS_ 1 1 C 2 _/\_ u0 -> \ (u1 :: ({{Num u0}}, {{Enum u0}}, u0 -> Ratio Integer)) -> case u1 of { _ALG_ _TUP_3 (u2 :: {{Num u0}}) (u3 :: {{Enum u0}}) (u4 :: u0 -> Ratio Integer) -> u3; _NO_DEFLT_ } _N_ #-} where
toRational :: a -> Ratio Integer
{-# GHC_PRAGMA {-meth-} _A_ 1 _U_ 12 _N_ _S_ "U(AAS)" {_A_ 1 _U_ 12 _N_ _N_ _F_ _IF_ARGS_ 1 1 X 1 _/\_ u0 -> \ (u1 :: u0 -> Ratio Integer) -> u1 _N_} _F_ _IF_ARGS_ 1 1 C 2 _/\_ u0 -> \ (u1 :: ({{Num u0}}, {{Enum u0}}, u0 -> Ratio Integer)) -> case u1 of { _ALG_ _TUP_3 (u2 :: {{Num u0}}) (u3 :: {{Enum u0}}) (u4 :: u0 -> Ratio Integer) -> u4; _NO_DEFLT_ } _N_
- {-defm-} _A_ 2 _U_ 02 _N_ _S_ _!_ _F_ _IF_ARGS_ 1 2 XX 3 _/\_ u0 -> \ (u1 :: {{Real u0}}) (u2 :: u0) -> _APP_ _TYAPP_ patError# { (u0 -> Ratio Integer) } [ _NOREP_S_ "%DPreludeCore.Real.toRational\"", u2 ] _N_ #-}
+ {-defm-} _A_ 2 _U_ 02 _N_ _S_ _!_ _N_ _N_ #-}
class (RealFrac a, Floating a) => RealFloat a {-# GHC_PRAGMA {-superdicts-} _A_ 1 _U_ 1 _N_ _S_ "U(U(LLLLLLL)AAAAAAAAA)" {_A_ 1 _U_ 1 _N_ _N_ _F_ _IF_ARGS_ 1 1 X 1 _/\_ u0 -> \ (u1 :: {{RealFrac u0}}) -> u1 _N_} _F_ _IF_ARGS_ 1 1 C 2 _/\_ u0 -> \ (u1 :: ({{RealFrac u0}}, {{Floating u0}}, u0 -> Integer, u0 -> Int, u0 -> (Int, Int), u0 -> (Integer, Int), Integer -> Int -> u0, u0 -> Int, u0 -> u0, Int -> u0 -> u0)) -> case u1 of { _ALG_ _TUP_10 (u2 :: {{RealFrac u0}}) (u3 :: {{Floating u0}}) (u4 :: u0 -> Integer) (u5 :: u0 -> Int) (u6 :: u0 -> (Int, Int)) (u7 :: u0 -> (Integer, Int)) (u8 :: Integer -> Int -> u0) (u9 :: u0 -> Int) (ua :: u0 -> u0) (ub :: Int -> u0 -> u0) -> u2; _NO_DEFLT_ } _N_, _A_ 1 _U_ 1 _N_ _S_ "U(AU(LLLLLLLLLLLLLLLLLLL)AAAAAAAA)" {_A_ 1 _U_ 1 _N_ _N_ _F_ _IF_ARGS_ 1 1 X 1 _/\_ u0 -> \ (u1 :: {{Floating u0}}) -> u1 _N_} _F_ _IF_ARGS_ 1 1 C 2 _/\_ u0 -> \ (u1 :: ({{RealFrac u0}}, {{Floating u0}}, u0 -> Integer, u0 -> Int, u0 -> (Int, Int), u0 -> (Integer, Int), Integer -> Int -> u0, u0 -> Int, u0 -> u0, Int -> u0 -> u0)) -> case u1 of { _ALG_ _TUP_10 (u2 :: {{RealFrac u0}}) (u3 :: {{Floating u0}}) (u4 :: u0 -> Integer) (u5 :: u0 -> Int) (u6 :: u0 -> (Int, Int)) (u7 :: u0 -> (Integer, Int)) (u8 :: Integer -> Int -> u0) (u9 :: u0 -> Int) (ua :: u0 -> u0) (ub :: Int -> u0 -> u0) -> u3; _NO_DEFLT_ } _N_ #-} where
floatRadix :: a -> Integer
{-# GHC_PRAGMA {-meth-} _A_ 1 _U_ 12 _N_ _S_ "U(AASAAAAAAA)" {_A_ 1 _U_ 12 _N_ _N_ _F_ _IF_ARGS_ 1 1 X 1 _/\_ u0 -> \ (u1 :: u0 -> Integer) -> u1 _N_} _F_ _IF_ARGS_ 1 1 C 2 _/\_ u0 -> \ (u1 :: ({{RealFrac u0}}, {{Floating u0}}, u0 -> Integer, u0 -> Int, u0 -> (Int, Int), u0 -> (Integer, Int), Integer -> Int -> u0, u0 -> Int, u0 -> u0, Int -> u0 -> u0)) -> case u1 of { _ALG_ _TUP_10 (u2 :: {{RealFrac u0}}) (u3 :: {{Floating u0}}) (u4 :: u0 -> Integer) (u5 :: u0 -> Int) (u6 :: u0 -> (Int, Int)) (u7 :: u0 -> (Integer, Int)) (u8 :: Integer -> Int -> u0) (u9 :: u0 -> Int) (ua :: u0 -> u0) (ub :: Int -> u0 -> u0) -> u4; _NO_DEFLT_ } _N_
- {-defm-} _A_ 2 _U_ 02 _N_ _S_ _!_ _F_ _IF_ARGS_ 1 2 XX 3 _/\_ u0 -> \ (u1 :: {{RealFloat u0}}) (u2 :: u0) -> _APP_ _TYAPP_ patError# { (u0 -> Integer) } [ _NOREP_S_ "%DPreludeCore.RealFloat.floatRadix\"", u2 ] _N_ #-}
+ {-defm-} _A_ 2 _U_ 02 _N_ _S_ _!_ _N_ _N_ #-}
floatDigits :: a -> Int
{-# GHC_PRAGMA {-meth-} _A_ 1 _U_ 12 _N_ _S_ "U(AAASAAAAAA)" {_A_ 1 _U_ 12 _N_ _N_ _F_ _IF_ARGS_ 1 1 X 1 _/\_ u0 -> \ (u1 :: u0 -> Int) -> u1 _N_} _F_ _IF_ARGS_ 1 1 C 2 _/\_ u0 -> \ (u1 :: ({{RealFrac u0}}, {{Floating u0}}, u0 -> Integer, u0 -> Int, u0 -> (Int, Int), u0 -> (Integer, Int), Integer -> Int -> u0, u0 -> Int, u0 -> u0, Int -> u0 -> u0)) -> case u1 of { _ALG_ _TUP_10 (u2 :: {{RealFrac u0}}) (u3 :: {{Floating u0}}) (u4 :: u0 -> Integer) (u5 :: u0 -> Int) (u6 :: u0 -> (Int, Int)) (u7 :: u0 -> (Integer, Int)) (u8 :: Integer -> Int -> u0) (u9 :: u0 -> Int) (ua :: u0 -> u0) (ub :: Int -> u0 -> u0) -> u5; _NO_DEFLT_ } _N_
- {-defm-} _A_ 2 _U_ 02 _N_ _S_ _!_ _F_ _IF_ARGS_ 1 2 XX 3 _/\_ u0 -> \ (u1 :: {{RealFloat u0}}) (u2 :: u0) -> _APP_ _TYAPP_ patError# { (u0 -> Int) } [ _NOREP_S_ "%DPreludeCore.RealFloat.floatDigits\"", u2 ] _N_ #-}
+ {-defm-} _A_ 2 _U_ 02 _N_ _S_ _!_ _N_ _N_ #-}
floatRange :: a -> (Int, Int)
{-# GHC_PRAGMA {-meth-} _A_ 1 _U_ 12 _N_ _S_ "U(AAAASAAAAA)" {_A_ 1 _U_ 12 _N_ _N_ _F_ _IF_ARGS_ 1 1 X 1 _/\_ u0 -> \ (u1 :: u0 -> (Int, Int)) -> u1 _N_} _F_ _IF_ARGS_ 1 1 C 2 _/\_ u0 -> \ (u1 :: ({{RealFrac u0}}, {{Floating u0}}, u0 -> Integer, u0 -> Int, u0 -> (Int, Int), u0 -> (Integer, Int), Integer -> Int -> u0, u0 -> Int, u0 -> u0, Int -> u0 -> u0)) -> case u1 of { _ALG_ _TUP_10 (u2 :: {{RealFrac u0}}) (u3 :: {{Floating u0}}) (u4 :: u0 -> Integer) (u5 :: u0 -> Int) (u6 :: u0 -> (Int, Int)) (u7 :: u0 -> (Integer, Int)) (u8 :: Integer -> Int -> u0) (u9 :: u0 -> Int) (ua :: u0 -> u0) (ub :: Int -> u0 -> u0) -> u6; _NO_DEFLT_ } _N_
- {-defm-} _A_ 2 _U_ 02 _N_ _S_ _!_ _F_ _IF_ARGS_ 1 2 XX 3 _/\_ u0 -> \ (u1 :: {{RealFloat u0}}) (u2 :: u0) -> _APP_ _TYAPP_ patError# { (u0 -> (Int, Int)) } [ _NOREP_S_ "%DPreludeCore.RealFloat.floatRange\"", u2 ] _N_ #-}
+ {-defm-} _A_ 2 _U_ 02 _N_ _S_ _!_ _N_ _N_ #-}
decodeFloat :: a -> (Integer, Int)
{-# GHC_PRAGMA {-meth-} _A_ 1 _U_ 12 _N_ _S_ "U(AAAAASAAAA)" {_A_ 1 _U_ 12 _N_ _N_ _F_ _IF_ARGS_ 1 1 X 1 _/\_ u0 -> \ (u1 :: u0 -> (Integer, Int)) -> u1 _N_} _F_ _IF_ARGS_ 1 1 C 2 _/\_ u0 -> \ (u1 :: ({{RealFrac u0}}, {{Floating u0}}, u0 -> Integer, u0 -> Int, u0 -> (Int, Int), u0 -> (Integer, Int), Integer -> Int -> u0, u0 -> Int, u0 -> u0, Int -> u0 -> u0)) -> case u1 of { _ALG_ _TUP_10 (u2 :: {{RealFrac u0}}) (u3 :: {{Floating u0}}) (u4 :: u0 -> Integer) (u5 :: u0 -> Int) (u6 :: u0 -> (Int, Int)) (u7 :: u0 -> (Integer, Int)) (u8 :: Integer -> Int -> u0) (u9 :: u0 -> Int) (ua :: u0 -> u0) (ub :: Int -> u0 -> u0) -> u7; _NO_DEFLT_ } _N_
- {-defm-} _A_ 2 _U_ 02 _N_ _S_ _!_ _F_ _IF_ARGS_ 1 2 XX 3 _/\_ u0 -> \ (u1 :: {{RealFloat u0}}) (u2 :: u0) -> _APP_ _TYAPP_ patError# { (u0 -> (Integer, Int)) } [ _NOREP_S_ "%DPreludeCore.RealFloat.decodeFloat\"", u2 ] _N_ #-}
+ {-defm-} _A_ 2 _U_ 02 _N_ _S_ _!_ _N_ _N_ #-}
encodeFloat :: Integer -> Int -> a
{-# GHC_PRAGMA {-meth-} _A_ 1 _U_ 122 _N_ _S_ "U(AAAAAASAAA)" {_A_ 1 _U_ 122 _N_ _N_ _F_ _IF_ARGS_ 1 1 X 1 _/\_ u0 -> \ (u1 :: Integer -> Int -> u0) -> u1 _N_} _F_ _IF_ARGS_ 1 1 C 2 _/\_ u0 -> \ (u1 :: ({{RealFrac u0}}, {{Floating u0}}, u0 -> Integer, u0 -> Int, u0 -> (Int, Int), u0 -> (Integer, Int), Integer -> Int -> u0, u0 -> Int, u0 -> u0, Int -> u0 -> u0)) -> case u1 of { _ALG_ _TUP_10 (u2 :: {{RealFrac u0}}) (u3 :: {{Floating u0}}) (u4 :: u0 -> Integer) (u5 :: u0 -> Int) (u6 :: u0 -> (Int, Int)) (u7 :: u0 -> (Integer, Int)) (u8 :: Integer -> Int -> u0) (u9 :: u0 -> Int) (ua :: u0 -> u0) (ub :: Int -> u0 -> u0) -> u8; _NO_DEFLT_ } _N_
- {-defm-} _A_ 3 _U_ 022 _N_ _S_ _!_ _F_ _IF_ARGS_ 1 3 XXX 4 _/\_ u0 -> \ (u1 :: {{RealFloat u0}}) (u2 :: Integer) (u3 :: Int) -> _APP_ _TYAPP_ patError# { (Integer -> Int -> u0) } [ _NOREP_S_ "%DPreludeCore.RealFloat.encodeFloat\"", u2, u3 ] _N_ #-}
+ {-defm-} _A_ 3 _U_ 022 _N_ _S_ _!_ _N_ _N_ #-}
exponent :: a -> Int
{-# GHC_PRAGMA {-meth-} _A_ 1 _U_ 12 _N_ _S_ "U(AAAAAAASAA)" {_A_ 1 _U_ 12 _N_ _N_ _F_ _IF_ARGS_ 1 1 X 1 _/\_ u0 -> \ (u1 :: u0 -> Int) -> u1 _N_} _F_ _IF_ARGS_ 1 1 C 2 _/\_ u0 -> \ (u1 :: ({{RealFrac u0}}, {{Floating u0}}, u0 -> Integer, u0 -> Int, u0 -> (Int, Int), u0 -> (Integer, Int), Integer -> Int -> u0, u0 -> Int, u0 -> u0, Int -> u0 -> u0)) -> case u1 of { _ALG_ _TUP_10 (u2 :: {{RealFrac u0}}) (u3 :: {{Floating u0}}) (u4 :: u0 -> Integer) (u5 :: u0 -> Int) (u6 :: u0 -> (Int, Int)) (u7 :: u0 -> (Integer, Int)) (u8 :: Integer -> Int -> u0) (u9 :: u0 -> Int) (ua :: u0 -> u0) (ub :: Int -> u0 -> u0) -> u9; _NO_DEFLT_ } _N_
{-defm-} _A_ 2 _U_ 12 _N_ _S_ "U(AAALASAAAA)L" {_A_ 3 _U_ 112 _N_ _N_ _N_ _N_} _N_ _N_ #-}
class (Real a, Fractional a) => RealFrac a {-# GHC_PRAGMA {-superdicts-} _A_ 1 _U_ 1 _N_ _S_ "U(U(LLL)AAAAAA)" {_A_ 3 _U_ 222 _N_ _N_ _F_ _IF_ARGS_ 1 3 XXX 4 _/\_ u0 -> \ (u1 :: {{Num u0}}) (u2 :: {{Enum u0}}) (u3 :: u0 -> Ratio Integer) -> _!_ _TUP_3 [{{Num u0}}, {{Enum u0}}, (u0 -> Ratio Integer)] [u1, u2, u3] _N_} _F_ _IF_ARGS_ 1 1 C 2 _/\_ u0 -> \ (u1 :: ({{Real u0}}, {{Fractional u0}}, (_forall_ z$z1 =>{{Integral z$z1}} -> u0 -> (z$z1, u0)), (_forall_ z$z1 =>{{Integral z$z1}} -> u0 -> z$z1), (_forall_ z$z1 =>{{Integral z$z1}} -> u0 -> z$z1), (_forall_ z$z1 =>{{Integral z$z1}} -> u0 -> z$z1), (_forall_ z$z1 =>{{Integral z$z1}} -> u0 -> z$z1))) -> case u1 of { _ALG_ _TUP_7 (u2 :: {{Real u0}}) (u3 :: {{Fractional u0}}) (u4 :: _forall_ a$z1 =>{{Integral a$z1}} -> u0 -> (a$z1, u0)) (u5 :: _forall_ a$z1 =>{{Integral a$z1}} -> u0 -> a$z1) (u6 :: _forall_ a$z1 =>{{Integral a$z1}} -> u0 -> a$z1) (u7 :: _forall_ a$z1 =>{{Integral a$z1}} -> u0 -> a$z1) (u8 :: _forall_ a$z1 =>{{Integral a$z1}} -> u0 -> a$z1) -> u2; _NO_DEFLT_ } _N_, _A_ 1 _U_ 1 _N_ _S_ "U(AU(LLLL)AAAAA)" {_A_ 4 _U_ 2222 _N_ _N_ _F_ _IF_ARGS_ 1 4 XXXX 5 _/\_ u0 -> \ (u1 :: {{Num u0}}) (u2 :: u0 -> u0 -> u0) (u3 :: u0 -> u0) (u4 :: Ratio Integer -> u0) -> _!_ _TUP_4 [{{Num u0}}, (u0 -> u0 -> u0), (u0 -> u0), (Ratio Integer -> u0)] [u1, u2, u3, u4] _N_} _F_ _IF_ARGS_ 1 1 C 2 _/\_ u0 -> \ (u1 :: ({{Real u0}}, {{Fractional u0}}, (_forall_ z$z1 =>{{Integral z$z1}} -> u0 -> (z$z1, u0)), (_forall_ z$z1 =>{{Integral z$z1}} -> u0 -> z$z1), (_forall_ z$z1 =>{{Integral z$z1}} -> u0 -> z$z1), (_forall_ z$z1 =>{{Integral z$z1}} -> u0 -> z$z1), (_forall_ z$z1 =>{{Integral z$z1}} -> u0 -> z$z1))) -> case u1 of { _ALG_ _TUP_7 (u2 :: {{Real u0}}) (u3 :: {{Fractional u0}}) (u4 :: _forall_ a$z1 =>{{Integral a$z1}} -> u0 -> (a$z1, u0)) (u5 :: _forall_ a$z1 =>{{Integral a$z1}} -> u0 -> a$z1) (u6 :: _forall_ a$z1 =>{{Integral a$z1}} -> u0 -> a$z1) (u7 :: _forall_ a$z1 =>{{Integral a$z1}} -> u0 -> a$z1) (u8 :: _forall_ a$z1 =>{{Integral a$z1}} -> u0 -> a$z1) -> u3; _NO_DEFLT_ } _N_ #-} where
properFraction :: Integral b => a -> (b, a)
{-# GHC_PRAGMA {-meth-} _A_ 2 _U_ 122 _N_ _S_ "U(AASAAAA)L" {_A_ 2 _U_ 122 _N_ _N_ _F_ _IF_ARGS_ 2 2 XX 2 _/\_ u0 u1 -> \ (u2 :: _forall_ a$z1 =>{{Integral a$z1}} -> u0 -> (a$z1, u0)) (u3 :: {{Integral u1}}) -> _APP_ _TYAPP_ u2 { u1 } [ u3 ] _N_} _F_ _IF_ARGS_ 2 2 CX 3 _/\_ u0 u1 -> \ (u2 :: ({{Real u0}}, {{Fractional u0}}, (_forall_ z$z1 =>{{Integral z$z1}} -> u0 -> (z$z1, u0)), (_forall_ z$z1 =>{{Integral z$z1}} -> u0 -> z$z1), (_forall_ z$z1 =>{{Integral z$z1}} -> u0 -> z$z1), (_forall_ z$z1 =>{{Integral z$z1}} -> u0 -> z$z1), (_forall_ z$z1 =>{{Integral z$z1}} -> u0 -> z$z1))) (u3 :: {{Integral u1}}) -> case u2 of { _ALG_ _TUP_7 (u4 :: {{Real u0}}) (u5 :: {{Fractional u0}}) (u6 :: _forall_ a$z1 =>{{Integral a$z1}} -> u0 -> (a$z1, u0)) (u7 :: _forall_ a$z1 =>{{Integral a$z1}} -> u0 -> a$z1) (u8 :: _forall_ a$z1 =>{{Integral a$z1}} -> u0 -> a$z1) (u9 :: _forall_ a$z1 =>{{Integral a$z1}} -> u0 -> a$z1) (ua :: _forall_ a$z1 =>{{Integral a$z1}} -> u0 -> a$z1) -> _APP_ _TYAPP_ u6 { u1 } [ u3 ]; _NO_DEFLT_ } _N_
- {-defm-} _A_ 3 _U_ 002 _N_ _S_ _!_ _F_ _IF_ARGS_ 2 3 XXX 3 _/\_ u0 u1 -> \ (u2 :: {{RealFrac u0}}) (u3 :: {{Integral u1}}) (u4 :: u0) -> _APP_ _TYAPP_ patError# { (u0 -> (u1, u0)) } [ _NOREP_S_ "%DPreludeCore.RealFrac.properFraction\"", u4 ] _N_ #-}
+ {-defm-} _A_ 3 _U_ 002 _N_ _S_ _!_ _N_ _N_ #-}
truncate :: Integral b => a -> b
{-# GHC_PRAGMA {-meth-} _A_ 2 _U_ 122 _N_ _S_ "U(AAASAAA)L" {_A_ 2 _U_ 122 _N_ _N_ _F_ _IF_ARGS_ 2 2 XX 2 _/\_ u0 u1 -> \ (u2 :: _forall_ a$z1 =>{{Integral a$z1}} -> u0 -> a$z1) (u3 :: {{Integral u1}}) -> _APP_ _TYAPP_ u2 { u1 } [ u3 ] _N_} _F_ _IF_ARGS_ 2 2 CX 3 _/\_ u0 u1 -> \ (u2 :: ({{Real u0}}, {{Fractional u0}}, (_forall_ z$z1 =>{{Integral z$z1}} -> u0 -> (z$z1, u0)), (_forall_ z$z1 =>{{Integral z$z1}} -> u0 -> z$z1), (_forall_ z$z1 =>{{Integral z$z1}} -> u0 -> z$z1), (_forall_ z$z1 =>{{Integral z$z1}} -> u0 -> z$z1), (_forall_ z$z1 =>{{Integral z$z1}} -> u0 -> z$z1))) (u3 :: {{Integral u1}}) -> case u2 of { _ALG_ _TUP_7 (u4 :: {{Real u0}}) (u5 :: {{Fractional u0}}) (u6 :: _forall_ a$z1 =>{{Integral a$z1}} -> u0 -> (a$z1, u0)) (u7 :: _forall_ a$z1 =>{{Integral a$z1}} -> u0 -> a$z1) (u8 :: _forall_ a$z1 =>{{Integral a$z1}} -> u0 -> a$z1) (u9 :: _forall_ a$z1 =>{{Integral a$z1}} -> u0 -> a$z1) (ua :: _forall_ a$z1 =>{{Integral a$z1}} -> u0 -> a$z1) -> _APP_ _TYAPP_ u7 { u1 } [ u3 ]; _NO_DEFLT_ } _N_
- {-defm-} _A_ 2 _U_ 122 _N_ _S_ "U(AASAAAA)L" {_A_ 2 _U_ 222 _N_ _N_ _N_ _N_} _N_ _N_ #-}
+ {-defm-} _A_ 2 _U_ 122 _N_ _S_ "U(AASAAAA)L" {_A_ 2 _U_ 122 _N_ _N_ _N_ _N_} _N_ _N_ #-}
round :: Integral b => a -> b
{-# GHC_PRAGMA {-meth-} _A_ 2 _U_ 122 _N_ _S_ "U(AAAASAA)L" {_A_ 2 _U_ 122 _N_ _N_ _F_ _IF_ARGS_ 2 2 XX 2 _/\_ u0 u1 -> \ (u2 :: _forall_ a$z1 =>{{Integral a$z1}} -> u0 -> a$z1) (u3 :: {{Integral u1}}) -> _APP_ _TYAPP_ u2 { u1 } [ u3 ] _N_} _F_ _IF_ARGS_ 2 2 CX 3 _/\_ u0 u1 -> \ (u2 :: ({{Real u0}}, {{Fractional u0}}, (_forall_ z$z1 =>{{Integral z$z1}} -> u0 -> (z$z1, u0)), (_forall_ z$z1 =>{{Integral z$z1}} -> u0 -> z$z1), (_forall_ z$z1 =>{{Integral z$z1}} -> u0 -> z$z1), (_forall_ z$z1 =>{{Integral z$z1}} -> u0 -> z$z1), (_forall_ z$z1 =>{{Integral z$z1}} -> u0 -> z$z1))) (u3 :: {{Integral u1}}) -> case u2 of { _ALG_ _TUP_7 (u4 :: {{Real u0}}) (u5 :: {{Fractional u0}}) (u6 :: _forall_ a$z1 =>{{Integral a$z1}} -> u0 -> (a$z1, u0)) (u7 :: _forall_ a$z1 =>{{Integral a$z1}} -> u0 -> a$z1) (u8 :: _forall_ a$z1 =>{{Integral a$z1}} -> u0 -> a$z1) (u9 :: _forall_ a$z1 =>{{Integral a$z1}} -> u0 -> a$z1) (ua :: _forall_ a$z1 =>{{Integral a$z1}} -> u0 -> a$z1) -> _APP_ _TYAPP_ u8 { u1 } [ u3 ]; _NO_DEFLT_ } _N_
- {-defm-} _A_ 2 _U_ 122 _N_ _S_ "U(U(AU(U(ALAAAAAS)AAAA)A)LSAAAA)L" {_A_ 5 _U_ 222222 _N_ _N_ _N_ _N_} _N_ _N_ #-}
+ {-defm-} _A_ 2 _U_ 122 _N_ _S_ "U(U(AU(U(ALAAAAAS)AAAA)A)LSAAAA)L" {_A_ 5 _U_ 112122 _N_ _N_ _N_ _N_} _N_ _N_ #-}
ceiling :: Integral b => a -> b
{-# GHC_PRAGMA {-meth-} _A_ 2 _U_ 122 _N_ _S_ "U(AAAAASA)L" {_A_ 2 _U_ 122 _N_ _N_ _F_ _IF_ARGS_ 2 2 XX 2 _/\_ u0 u1 -> \ (u2 :: _forall_ a$z1 =>{{Integral a$z1}} -> u0 -> a$z1) (u3 :: {{Integral u1}}) -> _APP_ _TYAPP_ u2 { u1 } [ u3 ] _N_} _F_ _IF_ARGS_ 2 2 CX 3 _/\_ u0 u1 -> \ (u2 :: ({{Real u0}}, {{Fractional u0}}, (_forall_ z$z1 =>{{Integral z$z1}} -> u0 -> (z$z1, u0)), (_forall_ z$z1 =>{{Integral z$z1}} -> u0 -> z$z1), (_forall_ z$z1 =>{{Integral z$z1}} -> u0 -> z$z1), (_forall_ z$z1 =>{{Integral z$z1}} -> u0 -> z$z1), (_forall_ z$z1 =>{{Integral z$z1}} -> u0 -> z$z1))) (u3 :: {{Integral u1}}) -> case u2 of { _ALG_ _TUP_7 (u4 :: {{Real u0}}) (u5 :: {{Fractional u0}}) (u6 :: _forall_ a$z1 =>{{Integral a$z1}} -> u0 -> (a$z1, u0)) (u7 :: _forall_ a$z1 =>{{Integral a$z1}} -> u0 -> a$z1) (u8 :: _forall_ a$z1 =>{{Integral a$z1}} -> u0 -> a$z1) (u9 :: _forall_ a$z1 =>{{Integral a$z1}} -> u0 -> a$z1) (ua :: _forall_ a$z1 =>{{Integral a$z1}} -> u0 -> a$z1) -> _APP_ _TYAPP_ u9 { u1 } [ u3 ]; _NO_DEFLT_ } _N_
- {-defm-} _A_ 2 _U_ 122 _N_ _S_ "U(U(AU(U(AAAASAAA)AAAA)A)LSAAAA)L" {_A_ 4 _U_ 22222 _N_ _N_ _N_ _N_} _N_ _N_ #-}
+ {-defm-} _A_ 2 _U_ 122 _N_ _S_ "U(U(LU(U(AAAASAAA)AAAA)A)ASAAAA)L" {_A_ 4 _U_ 11122 _N_ _N_ _N_ _N_} _N_ _N_ #-}
floor :: Integral b => a -> b
{-# GHC_PRAGMA {-meth-} _A_ 2 _U_ 122 _N_ _S_ "U(AAAAAAS)L" {_A_ 2 _U_ 122 _N_ _N_ _F_ _IF_ARGS_ 2 2 XX 2 _/\_ u0 u1 -> \ (u2 :: _forall_ a$z1 =>{{Integral a$z1}} -> u0 -> a$z1) (u3 :: {{Integral u1}}) -> _APP_ _TYAPP_ u2 { u1 } [ u3 ] _N_} _F_ _IF_ARGS_ 2 2 CX 3 _/\_ u0 u1 -> \ (u2 :: ({{Real u0}}, {{Fractional u0}}, (_forall_ z$z1 =>{{Integral z$z1}} -> u0 -> (z$z1, u0)), (_forall_ z$z1 =>{{Integral z$z1}} -> u0 -> z$z1), (_forall_ z$z1 =>{{Integral z$z1}} -> u0 -> z$z1), (_forall_ z$z1 =>{{Integral z$z1}} -> u0 -> z$z1), (_forall_ z$z1 =>{{Integral z$z1}} -> u0 -> z$z1))) (u3 :: {{Integral u1}}) -> case u2 of { _ALG_ _TUP_7 (u4 :: {{Real u0}}) (u5 :: {{Fractional u0}}) (u6 :: _forall_ a$z1 =>{{Integral a$z1}} -> u0 -> (a$z1, u0)) (u7 :: _forall_ a$z1 =>{{Integral a$z1}} -> u0 -> a$z1) (u8 :: _forall_ a$z1 =>{{Integral a$z1}} -> u0 -> a$z1) (u9 :: _forall_ a$z1 =>{{Integral a$z1}} -> u0 -> a$z1) (ua :: _forall_ a$z1 =>{{Integral a$z1}} -> u0 -> a$z1) -> _APP_ _TYAPP_ ua { u1 } [ u3 ]; _NO_DEFLT_ } _N_
- {-defm-} _A_ 2 _U_ 122 _N_ _S_ "U(U(AU(U(ASAAAAAA)AAAA)A)LSAAAA)L" {_A_ 4 _U_ 22222 _N_ _N_ _N_ _N_} _N_ _N_ #-}
+ {-defm-} _A_ 2 _U_ 122 _N_ _S_ "U(U(LU(U(ASAAAAAA)AAAA)A)ASAAAA)L" {_A_ 4 _U_ 11122 _N_ _N_ _N_ _N_} _N_ _N_ #-}
class Text a where
readsPrec :: Int -> [Char] -> [(a, [Char])]
{-# GHC_PRAGMA {-meth-} _A_ 1 _U_ 122 _N_ _S_ "U(SAAA)" {_A_ 1 _U_ 122 _N_ _N_ _F_ _IF_ARGS_ 1 1 X 1 _/\_ u0 -> \ (u1 :: Int -> [Char] -> [(u0, [Char])]) -> u1 _N_} _F_ _IF_ARGS_ 1 1 C 2 _/\_ u0 -> \ (u1 :: (Int -> [Char] -> [(u0, [Char])], Int -> u0 -> [Char] -> [Char], [Char] -> [([u0], [Char])], [u0] -> [Char] -> [Char])) -> case u1 of { _ALG_ _TUP_4 (u2 :: Int -> [Char] -> [(u0, [Char])]) (u3 :: Int -> u0 -> [Char] -> [Char]) (u4 :: [Char] -> [([u0], [Char])]) (u5 :: [u0] -> [Char] -> [Char]) -> u2; _NO_DEFLT_ } _N_
- {-defm-} _A_ 3 _U_ 022 _N_ _S_ _!_ _F_ _IF_ARGS_ 1 3 XXX 4 _/\_ u0 -> \ (u1 :: {{Text u0}}) (u2 :: Int) (u3 :: [Char]) -> _APP_ _TYAPP_ patError# { (Int -> [Char] -> [(u0, [Char])]) } [ _NOREP_S_ "%DPreludeCore.Text.readsPrec\"", u2, u3 ] _N_ #-}
+ {-defm-} _A_ 3 _U_ 022 _N_ _S_ _!_ _N_ _N_ #-}
showsPrec :: Int -> a -> [Char] -> [Char]
{-# GHC_PRAGMA {-meth-} _A_ 1 _U_ 1222 _N_ _S_ "U(ASAA)" {_A_ 1 _U_ 1222 _N_ _N_ _F_ _IF_ARGS_ 1 1 X 1 _/\_ u0 -> \ (u1 :: Int -> u0 -> [Char] -> [Char]) -> u1 _N_} _F_ _IF_ARGS_ 1 1 C 2 _/\_ u0 -> \ (u1 :: (Int -> [Char] -> [(u0, [Char])], Int -> u0 -> [Char] -> [Char], [Char] -> [([u0], [Char])], [u0] -> [Char] -> [Char])) -> case u1 of { _ALG_ _TUP_4 (u2 :: Int -> [Char] -> [(u0, [Char])]) (u3 :: Int -> u0 -> [Char] -> [Char]) (u4 :: [Char] -> [([u0], [Char])]) (u5 :: [u0] -> [Char] -> [Char]) -> u3; _NO_DEFLT_ } _N_
- {-defm-} _A_ 4 _U_ 0222 _N_ _S_ _!_ _F_ _IF_ARGS_ 1 4 XXXX 5 _/\_ u0 -> \ (u1 :: {{Text u0}}) (u2 :: Int) (u3 :: u0) (u4 :: [Char]) -> _APP_ _TYAPP_ patError# { (Int -> u0 -> [Char] -> [Char]) } [ _NOREP_S_ "%DPreludeCore.Text.showsPrec\"", u2, u3, u4 ] _N_ #-}
+ {-defm-} _A_ 4 _U_ 0222 _N_ _S_ _!_ _N_ _N_ #-}
readList :: [Char] -> [([a], [Char])]
{-# GHC_PRAGMA {-meth-} _A_ 1 _U_ 12 _N_ _S_ "U(AASA)" {_A_ 1 _U_ 12 _N_ _N_ _F_ _IF_ARGS_ 1 1 X 1 _/\_ u0 -> \ (u1 :: [Char] -> [([u0], [Char])]) -> u1 _N_} _F_ _IF_ARGS_ 1 1 C 2 _/\_ u0 -> \ (u1 :: (Int -> [Char] -> [(u0, [Char])], Int -> u0 -> [Char] -> [Char], [Char] -> [([u0], [Char])], [u0] -> [Char] -> [Char])) -> case u1 of { _ALG_ _TUP_4 (u2 :: Int -> [Char] -> [(u0, [Char])]) (u3 :: Int -> u0 -> [Char] -> [Char]) (u4 :: [Char] -> [([u0], [Char])]) (u5 :: [u0] -> [Char] -> [Char]) -> u4; _NO_DEFLT_ } _N_
- {-defm-} _A_ 1 _U_ 22 _N_ _N_ _F_ _IF_ARGS_ 0 0 X 1 _ORIG_ PreludeCore _readList _N_ #-}
+ {-defm-} _A_ 1 _U_ 12 _N_ _N_ _N_ _N_ #-}
showList :: [a] -> [Char] -> [Char]
{-# GHC_PRAGMA {-meth-} _A_ 1 _U_ 122 _N_ _S_ "U(AAAS)" {_A_ 1 _U_ 122 _N_ _N_ _F_ _IF_ARGS_ 1 1 X 1 _/\_ u0 -> \ (u1 :: [u0] -> [Char] -> [Char]) -> u1 _N_} _F_ _IF_ARGS_ 1 1 C 2 _/\_ u0 -> \ (u1 :: (Int -> [Char] -> [(u0, [Char])], Int -> u0 -> [Char] -> [Char], [Char] -> [([u0], [Char])], [u0] -> [Char] -> [Char])) -> case u1 of { _ALG_ _TUP_4 (u2 :: Int -> [Char] -> [(u0, [Char])]) (u3 :: Int -> u0 -> [Char] -> [Char]) (u4 :: [Char] -> [([u0], [Char])]) (u5 :: [u0] -> [Char] -> [Char]) -> u5; _NO_DEFLT_ } _N_
- {-defm-} _A_ 1 _U_ 212 _N_ _N_ _F_ _IF_ARGS_ 0 0 X 1 _ORIG_ PreludeCore _showList _N_ #-}
+ {-defm-} _A_ 1 _U_ 112 _N_ _N_ _N_ _N_ #-}
class _CCallable a
class _CReturnable a
data Bin
-{-# GHC_PRAGMA INTERFACE VERSION 5 #-}
+{-# GHC_PRAGMA INTERFACE VERSION 6 #-}
interface PreludeCore where
import PreludeBuiltin(Bin, Char(..), Int(..), Integer(..), List(..), Tuple2, _CMP_TAG(..))
import PreludeRatio(Ratio(..))
class Binary a where
readBin :: Bin -> (a, Bin)
{-# GHC_PRAGMA {-meth-} _A_ 1 _U_ 12 _N_ _S_ "U(SA)" {_A_ 1 _U_ 12 _N_ _N_ _F_ _IF_ARGS_ 1 1 X 1 _/\_ u0 -> \ (u1 :: Bin -> (u0, Bin)) -> u1 _N_} _F_ _IF_ARGS_ 1 1 C 2 _/\_ u0 -> \ (u1 :: (Bin -> (u0, Bin), u0 -> Bin -> Bin)) -> case u1 of { _ALG_ _TUP_2 (u2 :: Bin -> (u0, Bin)) (u3 :: u0 -> Bin -> Bin) -> u2; _NO_DEFLT_ } _N_
- {-defm-} _A_ 2 _U_ 02 _N_ _S_ _!_ _F_ _IF_ARGS_ 1 2 XX 3 _/\_ u0 -> \ (u1 :: {{Binary u0}}) (u2 :: Bin) -> _APP_ _TYAPP_ patError# { (Bin -> (u0, Bin)) } [ _NOREP_S_ "%DPreludeCore.Binary.readBin\"", u2 ] _N_ #-}
+ {-defm-} _A_ 2 _U_ 02 _N_ _S_ _!_ _N_ _N_ #-}
showBin :: a -> Bin -> Bin
{-# GHC_PRAGMA {-meth-} _A_ 1 _U_ 122 _N_ _S_ "U(AS)" {_A_ 1 _U_ 122 _N_ _N_ _F_ _IF_ARGS_ 1 1 X 1 _/\_ u0 -> \ (u1 :: u0 -> Bin -> Bin) -> u1 _N_} _F_ _IF_ARGS_ 1 1 C 2 _/\_ u0 -> \ (u1 :: (Bin -> (u0, Bin), u0 -> Bin -> Bin)) -> case u1 of { _ALG_ _TUP_2 (u2 :: Bin -> (u0, Bin)) (u3 :: u0 -> Bin -> Bin) -> u3; _NO_DEFLT_ } _N_
- {-defm-} _A_ 3 _U_ 022 _N_ _S_ _!_ _F_ _IF_ARGS_ 1 3 XXX 4 _/\_ u0 -> \ (u1 :: {{Binary u0}}) (u2 :: u0) (u3 :: Bin) -> _APP_ _TYAPP_ patError# { (u0 -> Bin -> Bin) } [ _NOREP_S_ "%DPreludeCore.Binary.showBin\"", u2, u3 ] _N_ #-}
+ {-defm-} _A_ 3 _U_ 022 _N_ _S_ _!_ _N_ _N_ #-}
class (Ord a) => Enum a {-# GHC_PRAGMA {-superdicts-} _A_ 1 _U_ 1 _N_ _S_ "U(U(LLLLLLLL)AAAA)" {_A_ 1 _U_ 1 _N_ _N_ _F_ _IF_ARGS_ 1 1 X 1 _/\_ u0 -> \ (u1 :: {{Ord u0}}) -> u1 _N_} _F_ _IF_ARGS_ 1 1 C 2 _/\_ u0 -> \ (u1 :: ({{Ord u0}}, u0 -> [u0], u0 -> u0 -> [u0], u0 -> u0 -> [u0], u0 -> u0 -> u0 -> [u0])) -> case u1 of { _ALG_ _TUP_5 (u2 :: {{Ord u0}}) (u3 :: u0 -> [u0]) (u4 :: u0 -> u0 -> [u0]) (u5 :: u0 -> u0 -> [u0]) (u6 :: u0 -> u0 -> u0 -> [u0]) -> u2; _NO_DEFLT_ } _N_ #-} where
enumFrom :: a -> [a]
{-# GHC_PRAGMA {-meth-} _A_ 1 _U_ 12 _N_ _S_ "U(ASAAA)" {_A_ 1 _U_ 12 _N_ _N_ _F_ _IF_ARGS_ 1 1 X 1 _/\_ u0 -> \ (u1 :: u0 -> [u0]) -> u1 _N_} _F_ _IF_ARGS_ 1 1 C 2 _/\_ u0 -> \ (u1 :: ({{Ord u0}}, u0 -> [u0], u0 -> u0 -> [u0], u0 -> u0 -> [u0], u0 -> u0 -> u0 -> [u0])) -> case u1 of { _ALG_ _TUP_5 (u2 :: {{Ord u0}}) (u3 :: u0 -> [u0]) (u4 :: u0 -> u0 -> [u0]) (u5 :: u0 -> u0 -> [u0]) (u6 :: u0 -> u0 -> u0 -> [u0]) -> u3; _NO_DEFLT_ } _N_
- {-defm-} _A_ 2 _U_ 02 _N_ _S_ _!_ _F_ _IF_ARGS_ 1 2 XX 3 _/\_ u0 -> \ (u1 :: {{Enum u0}}) (u2 :: u0) -> _APP_ _TYAPP_ patError# { (u0 -> [u0]) } [ _NOREP_S_ "%DPreludeCore.Enum.enumFrom\"", u2 ] _N_ #-}
+ {-defm-} _A_ 2 _U_ 02 _N_ _S_ _!_ _N_ _N_ #-}
enumFromThen :: a -> a -> [a]
{-# GHC_PRAGMA {-meth-} _A_ 1 _U_ 122 _N_ _S_ "U(AASAA)" {_A_ 1 _U_ 122 _N_ _N_ _F_ _IF_ARGS_ 1 1 X 1 _/\_ u0 -> \ (u1 :: u0 -> u0 -> [u0]) -> u1 _N_} _F_ _IF_ARGS_ 1 1 C 2 _/\_ u0 -> \ (u1 :: ({{Ord u0}}, u0 -> [u0], u0 -> u0 -> [u0], u0 -> u0 -> [u0], u0 -> u0 -> u0 -> [u0])) -> case u1 of { _ALG_ _TUP_5 (u2 :: {{Ord u0}}) (u3 :: u0 -> [u0]) (u4 :: u0 -> u0 -> [u0]) (u5 :: u0 -> u0 -> [u0]) (u6 :: u0 -> u0 -> u0 -> [u0]) -> u4; _NO_DEFLT_ } _N_
- {-defm-} _A_ 3 _U_ 022 _N_ _S_ _!_ _F_ _IF_ARGS_ 1 3 XXX 4 _/\_ u0 -> \ (u1 :: {{Enum u0}}) (u2 :: u0) (u3 :: u0) -> _APP_ _TYAPP_ patError# { (u0 -> u0 -> [u0]) } [ _NOREP_S_ "%DPreludeCore.Enum.enumFromThen\"", u2, u3 ] _N_ #-}
+ {-defm-} _A_ 3 _U_ 022 _N_ _S_ _!_ _N_ _N_ #-}
enumFromTo :: a -> a -> [a]
{-# GHC_PRAGMA {-meth-} _A_ 1 _U_ 122 _N_ _S_ "U(AAASA)" {_A_ 1 _U_ 122 _N_ _N_ _F_ _IF_ARGS_ 1 1 X 1 _/\_ u0 -> \ (u1 :: u0 -> u0 -> [u0]) -> u1 _N_} _F_ _IF_ARGS_ 1 1 C 2 _/\_ u0 -> \ (u1 :: ({{Ord u0}}, u0 -> [u0], u0 -> u0 -> [u0], u0 -> u0 -> [u0], u0 -> u0 -> u0 -> [u0])) -> case u1 of { _ALG_ _TUP_5 (u2 :: {{Ord u0}}) (u3 :: u0 -> [u0]) (u4 :: u0 -> u0 -> [u0]) (u5 :: u0 -> u0 -> [u0]) (u6 :: u0 -> u0 -> u0 -> [u0]) -> u5; _NO_DEFLT_ } _N_
{-defm-} _A_ 3 _U_ 122 _N_ _S_ "U(LSAAA)LL" {_A_ 4 _U_ 1122 _N_ _N_ _N_ _N_} _N_ _N_ #-}
class Eq a where
(==) :: a -> a -> Bool
{-# GHC_PRAGMA {-meth-} _A_ 1 _U_ 122 _N_ _S_ "U(SA)" {_A_ 1 _U_ 122 _N_ _N_ _F_ _IF_ARGS_ 1 1 X 1 _/\_ u0 -> \ (u1 :: u0 -> u0 -> Bool) -> u1 _N_} _F_ _IF_ARGS_ 1 1 C 2 _/\_ u0 -> \ (u1 :: (u0 -> u0 -> Bool, u0 -> u0 -> Bool)) -> case u1 of { _ALG_ _TUP_2 (u2 :: u0 -> u0 -> Bool) (u3 :: u0 -> u0 -> Bool) -> u2; _NO_DEFLT_ } _N_
- {-defm-} _A_ 3 _U_ 022 _N_ _S_ _!_ _F_ _IF_ARGS_ 1 3 XXX 4 _/\_ u0 -> \ (u1 :: {{Eq u0}}) (u2 :: u0) (u3 :: u0) -> _APP_ _TYAPP_ patError# { (u0 -> u0 -> Bool) } [ _NOREP_S_ "%DPreludeCore.Eq.(==)\"", u2, u3 ] _N_ #-}
+ {-defm-} _A_ 3 _U_ 022 _N_ _S_ _!_ _N_ _N_ #-}
(/=) :: a -> a -> Bool
{-# GHC_PRAGMA {-meth-} _A_ 1 _U_ 122 _N_ _S_ "U(AS)" {_A_ 1 _U_ 122 _N_ _N_ _F_ _IF_ARGS_ 1 1 X 1 _/\_ u0 -> \ (u1 :: u0 -> u0 -> Bool) -> u1 _N_} _F_ _IF_ARGS_ 1 1 C 2 _/\_ u0 -> \ (u1 :: (u0 -> u0 -> Bool, u0 -> u0 -> Bool)) -> case u1 of { _ALG_ _TUP_2 (u2 :: u0 -> u0 -> Bool) (u3 :: u0 -> u0 -> Bool) -> u3; _NO_DEFLT_ } _N_
{-defm-} _A_ 3 _U_ 122 _N_ _S_ "U(SA)LL" {_A_ 3 _U_ 122 _N_ _N_ _N_ _N_} _N_ _N_ #-}
class (Fractional a) => Floating a {-# GHC_PRAGMA {-superdicts-} _A_ 1 _U_ 1 _N_ _S_ "U(U(LLLL)AAAAAAAAAAAAAAAAAA)" {_A_ 4 _U_ 2222 _N_ _N_ _F_ _IF_ARGS_ 1 4 XXXX 5 _/\_ u0 -> \ (u1 :: {{Num u0}}) (u2 :: u0 -> u0 -> u0) (u3 :: u0 -> u0) (u4 :: Ratio Integer -> u0) -> _!_ _TUP_4 [{{Num u0}}, (u0 -> u0 -> u0), (u0 -> u0), (Ratio Integer -> u0)] [u1, u2, u3, u4] _N_} _F_ _IF_ARGS_ 1 1 C 2 _/\_ u0 -> \ (u1 :: ({{Fractional u0}}, u0, u0 -> u0, u0 -> u0, u0 -> u0, u0 -> u0 -> u0, u0 -> u0 -> u0, u0 -> u0, u0 -> u0, u0 -> u0, u0 -> u0, u0 -> u0, u0 -> u0, u0 -> u0, u0 -> u0, u0 -> u0, u0 -> u0, u0 -> u0, u0 -> u0)) -> case u1 of { _ALG_ _TUP_19 (u2 :: {{Fractional u0}}) (u3 :: u0) (u4 :: u0 -> u0) (u5 :: u0 -> u0) (u6 :: u0 -> u0) (u7 :: u0 -> u0 -> u0) (u8 :: u0 -> u0 -> u0) (u9 :: u0 -> u0) (ua :: u0 -> u0) (ub :: u0 -> u0) (uc :: u0 -> u0) (ud :: u0 -> u0) (ue :: u0 -> u0) (uf :: u0 -> u0) (ug :: u0 -> u0) (uh :: u0 -> u0) (ui :: u0 -> u0) (uj :: u0 -> u0) (uk :: u0 -> u0) -> u2; _NO_DEFLT_ } _N_ #-} where
pi :: a
{-# GHC_PRAGMA {-meth-} _A_ 1 _U_ 1 _N_ _S_ "U(ASAAAAAAAAAAAAAAAAA)" {_A_ 1 _U_ 1 _N_ _N_ _F_ _IF_ARGS_ 1 1 X 1 _/\_ u0 -> \ (u1 :: u0) -> u1 _N_} _F_ _IF_ARGS_ 1 1 C 2 _/\_ u0 -> \ (u1 :: ({{Fractional u0}}, u0, u0 -> u0, u0 -> u0, u0 -> u0, u0 -> u0 -> u0, u0 -> u0 -> u0, u0 -> u0, u0 -> u0, u0 -> u0, u0 -> u0, u0 -> u0, u0 -> u0, u0 -> u0, u0 -> u0, u0 -> u0, u0 -> u0, u0 -> u0, u0 -> u0)) -> case u1 of { _ALG_ _TUP_19 (u2 :: {{Fractional u0}}) (u3 :: u0) (u4 :: u0 -> u0) (u5 :: u0 -> u0) (u6 :: u0 -> u0) (u7 :: u0 -> u0 -> u0) (u8 :: u0 -> u0 -> u0) (u9 :: u0 -> u0) (ua :: u0 -> u0) (ub :: u0 -> u0) (uc :: u0 -> u0) (ud :: u0 -> u0) (ue :: u0 -> u0) (uf :: u0 -> u0) (ug :: u0 -> u0) (uh :: u0 -> u0) (ui :: u0 -> u0) (uj :: u0 -> u0) (uk :: u0 -> u0) -> u3; _NO_DEFLT_ } _N_
- {-defm-} _A_ 1 _U_ 0 _N_ _S_ _!_ _F_ _IF_ARGS_ 1 1 X 2 _/\_ u0 -> \ (u1 :: {{Floating u0}}) -> _APP_ _TYAPP_ patError# { u0 } [ _NOREP_S_ "%DPreludeCore.Floating.pi\"" ] _N_ #-}
+ {-defm-} _A_ 1 _U_ 0 _N_ _S_ _!_ _N_ _N_ #-}
exp :: a -> a
{-# GHC_PRAGMA {-meth-} _A_ 1 _U_ 12 _N_ _S_ "U(AASAAAAAAAAAAAAAAAA)" {_A_ 1 _U_ 12 _N_ _N_ _F_ _IF_ARGS_ 1 1 X 1 _/\_ u0 -> \ (u1 :: u0 -> u0) -> u1 _N_} _F_ _IF_ARGS_ 1 1 C 2 _/\_ u0 -> \ (u1 :: ({{Fractional u0}}, u0, u0 -> u0, u0 -> u0, u0 -> u0, u0 -> u0 -> u0, u0 -> u0 -> u0, u0 -> u0, u0 -> u0, u0 -> u0, u0 -> u0, u0 -> u0, u0 -> u0, u0 -> u0, u0 -> u0, u0 -> u0, u0 -> u0, u0 -> u0, u0 -> u0)) -> case u1 of { _ALG_ _TUP_19 (u2 :: {{Fractional u0}}) (u3 :: u0) (u4 :: u0 -> u0) (u5 :: u0 -> u0) (u6 :: u0 -> u0) (u7 :: u0 -> u0 -> u0) (u8 :: u0 -> u0 -> u0) (u9 :: u0 -> u0) (ua :: u0 -> u0) (ub :: u0 -> u0) (uc :: u0 -> u0) (ud :: u0 -> u0) (ue :: u0 -> u0) (uf :: u0 -> u0) (ug :: u0 -> u0) (uh :: u0 -> u0) (ui :: u0 -> u0) (uj :: u0 -> u0) (uk :: u0 -> u0) -> u4; _NO_DEFLT_ } _N_
- {-defm-} _A_ 2 _U_ 02 _N_ _S_ _!_ _F_ _IF_ARGS_ 1 2 XX 3 _/\_ u0 -> \ (u1 :: {{Floating u0}}) (u2 :: u0) -> _APP_ _TYAPP_ patError# { (u0 -> u0) } [ _NOREP_S_ "%DPreludeCore.Floating.exp\"", u2 ] _N_ #-}
+ {-defm-} _A_ 2 _U_ 02 _N_ _S_ _!_ _N_ _N_ #-}
log :: a -> a
{-# GHC_PRAGMA {-meth-} _A_ 1 _U_ 12 _N_ _S_ "U(AAASAAAAAAAAAAAAAAA)" {_A_ 1 _U_ 12 _N_ _N_ _F_ _IF_ARGS_ 1 1 X 1 _/\_ u0 -> \ (u1 :: u0 -> u0) -> u1 _N_} _F_ _IF_ARGS_ 1 1 C 2 _/\_ u0 -> \ (u1 :: ({{Fractional u0}}, u0, u0 -> u0, u0 -> u0, u0 -> u0, u0 -> u0 -> u0, u0 -> u0 -> u0, u0 -> u0, u0 -> u0, u0 -> u0, u0 -> u0, u0 -> u0, u0 -> u0, u0 -> u0, u0 -> u0, u0 -> u0, u0 -> u0, u0 -> u0, u0 -> u0)) -> case u1 of { _ALG_ _TUP_19 (u2 :: {{Fractional u0}}) (u3 :: u0) (u4 :: u0 -> u0) (u5 :: u0 -> u0) (u6 :: u0 -> u0) (u7 :: u0 -> u0 -> u0) (u8 :: u0 -> u0 -> u0) (u9 :: u0 -> u0) (ua :: u0 -> u0) (ub :: u0 -> u0) (uc :: u0 -> u0) (ud :: u0 -> u0) (ue :: u0 -> u0) (uf :: u0 -> u0) (ug :: u0 -> u0) (uh :: u0 -> u0) (ui :: u0 -> u0) (uj :: u0 -> u0) (uk :: u0 -> u0) -> u5; _NO_DEFLT_ } _N_
- {-defm-} _A_ 2 _U_ 02 _N_ _S_ _!_ _F_ _IF_ARGS_ 1 2 XX 3 _/\_ u0 -> \ (u1 :: {{Floating u0}}) (u2 :: u0) -> _APP_ _TYAPP_ patError# { (u0 -> u0) } [ _NOREP_S_ "%DPreludeCore.Floating.log\"", u2 ] _N_ #-}
+ {-defm-} _A_ 2 _U_ 02 _N_ _S_ _!_ _N_ _N_ #-}
sqrt :: a -> a
{-# GHC_PRAGMA {-meth-} _A_ 1 _U_ 12 _N_ _S_ "U(AAAASAAAAAAAAAAAAAA)" {_A_ 1 _U_ 12 _N_ _N_ _F_ _IF_ARGS_ 1 1 X 1 _/\_ u0 -> \ (u1 :: u0 -> u0) -> u1 _N_} _F_ _IF_ARGS_ 1 1 C 2 _/\_ u0 -> \ (u1 :: ({{Fractional u0}}, u0, u0 -> u0, u0 -> u0, u0 -> u0, u0 -> u0 -> u0, u0 -> u0 -> u0, u0 -> u0, u0 -> u0, u0 -> u0, u0 -> u0, u0 -> u0, u0 -> u0, u0 -> u0, u0 -> u0, u0 -> u0, u0 -> u0, u0 -> u0, u0 -> u0)) -> case u1 of { _ALG_ _TUP_19 (u2 :: {{Fractional u0}}) (u3 :: u0) (u4 :: u0 -> u0) (u5 :: u0 -> u0) (u6 :: u0 -> u0) (u7 :: u0 -> u0 -> u0) (u8 :: u0 -> u0 -> u0) (u9 :: u0 -> u0) (ua :: u0 -> u0) (ub :: u0 -> u0) (uc :: u0 -> u0) (ud :: u0 -> u0) (ue :: u0 -> u0) (uf :: u0 -> u0) (ug :: u0 -> u0) (uh :: u0 -> u0) (ui :: u0 -> u0) (uj :: u0 -> u0) (uk :: u0 -> u0) -> u6; _NO_DEFLT_ } _N_
{-defm-} _A_ 1 _U_ 12 _N_ _S_ "U(LAAAASAAAAAAAAAAAAA)" {_A_ 2 _U_ 112 _N_ _N_ _N_ _N_} _N_ _N_ #-}
{-defm-} _A_ 3 _U_ 122 _N_ _S_ "U(U(ASAA)AALAAAAAAAAAAAAAAA)LL" {_A_ 4 _U_ 1222 _N_ _N_ _N_ _N_} _N_ _N_ #-}
sin :: a -> a
{-# GHC_PRAGMA {-meth-} _A_ 1 _U_ 12 _N_ _S_ "U(AAAAAAASAAAAAAAAAAA)" {_A_ 1 _U_ 12 _N_ _N_ _F_ _IF_ARGS_ 1 1 X 1 _/\_ u0 -> \ (u1 :: u0 -> u0) -> u1 _N_} _F_ _IF_ARGS_ 1 1 C 2 _/\_ u0 -> \ (u1 :: ({{Fractional u0}}, u0, u0 -> u0, u0 -> u0, u0 -> u0, u0 -> u0 -> u0, u0 -> u0 -> u0, u0 -> u0, u0 -> u0, u0 -> u0, u0 -> u0, u0 -> u0, u0 -> u0, u0 -> u0, u0 -> u0, u0 -> u0, u0 -> u0, u0 -> u0, u0 -> u0)) -> case u1 of { _ALG_ _TUP_19 (u2 :: {{Fractional u0}}) (u3 :: u0) (u4 :: u0 -> u0) (u5 :: u0 -> u0) (u6 :: u0 -> u0) (u7 :: u0 -> u0 -> u0) (u8 :: u0 -> u0 -> u0) (u9 :: u0 -> u0) (ua :: u0 -> u0) (ub :: u0 -> u0) (uc :: u0 -> u0) (ud :: u0 -> u0) (ue :: u0 -> u0) (uf :: u0 -> u0) (ug :: u0 -> u0) (uh :: u0 -> u0) (ui :: u0 -> u0) (uj :: u0 -> u0) (uk :: u0 -> u0) -> u9; _NO_DEFLT_ } _N_
- {-defm-} _A_ 2 _U_ 02 _N_ _S_ _!_ _F_ _IF_ARGS_ 1 2 XX 3 _/\_ u0 -> \ (u1 :: {{Floating u0}}) (u2 :: u0) -> _APP_ _TYAPP_ patError# { (u0 -> u0) } [ _NOREP_S_ "%DPreludeCore.Floating.sin\"", u2 ] _N_ #-}
+ {-defm-} _A_ 2 _U_ 02 _N_ _S_ _!_ _N_ _N_ #-}
cos :: a -> a
{-# GHC_PRAGMA {-meth-} _A_ 1 _U_ 12 _N_ _S_ "U(AAAAAAAASAAAAAAAAAA)" {_A_ 1 _U_ 12 _N_ _N_ _F_ _IF_ARGS_ 1 1 X 1 _/\_ u0 -> \ (u1 :: u0 -> u0) -> u1 _N_} _F_ _IF_ARGS_ 1 1 C 2 _/\_ u0 -> \ (u1 :: ({{Fractional u0}}, u0, u0 -> u0, u0 -> u0, u0 -> u0, u0 -> u0 -> u0, u0 -> u0 -> u0, u0 -> u0, u0 -> u0, u0 -> u0, u0 -> u0, u0 -> u0, u0 -> u0, u0 -> u0, u0 -> u0, u0 -> u0, u0 -> u0, u0 -> u0, u0 -> u0)) -> case u1 of { _ALG_ _TUP_19 (u2 :: {{Fractional u0}}) (u3 :: u0) (u4 :: u0 -> u0) (u5 :: u0 -> u0) (u6 :: u0 -> u0) (u7 :: u0 -> u0 -> u0) (u8 :: u0 -> u0 -> u0) (u9 :: u0 -> u0) (ua :: u0 -> u0) (ub :: u0 -> u0) (uc :: u0 -> u0) (ud :: u0 -> u0) (ue :: u0 -> u0) (uf :: u0 -> u0) (ug :: u0 -> u0) (uh :: u0 -> u0) (ui :: u0 -> u0) (uj :: u0 -> u0) (uk :: u0 -> u0) -> ua; _NO_DEFLT_ } _N_
- {-defm-} _A_ 2 _U_ 02 _N_ _S_ _!_ _F_ _IF_ARGS_ 1 2 XX 3 _/\_ u0 -> \ (u1 :: {{Floating u0}}) (u2 :: u0) -> _APP_ _TYAPP_ patError# { (u0 -> u0) } [ _NOREP_S_ "%DPreludeCore.Floating.cos\"", u2 ] _N_ #-}
+ {-defm-} _A_ 2 _U_ 02 _N_ _S_ _!_ _N_ _N_ #-}
tan :: a -> a
{-# GHC_PRAGMA {-meth-} _A_ 1 _U_ 12 _N_ _S_ "U(AAAAAAAAASAAAAAAAAA)" {_A_ 1 _U_ 12 _N_ _N_ _F_ _IF_ARGS_ 1 1 X 1 _/\_ u0 -> \ (u1 :: u0 -> u0) -> u1 _N_} _F_ _IF_ARGS_ 1 1 C 2 _/\_ u0 -> \ (u1 :: ({{Fractional u0}}, u0, u0 -> u0, u0 -> u0, u0 -> u0, u0 -> u0 -> u0, u0 -> u0 -> u0, u0 -> u0, u0 -> u0, u0 -> u0, u0 -> u0, u0 -> u0, u0 -> u0, u0 -> u0, u0 -> u0, u0 -> u0, u0 -> u0, u0 -> u0, u0 -> u0)) -> case u1 of { _ALG_ _TUP_19 (u2 :: {{Fractional u0}}) (u3 :: u0) (u4 :: u0 -> u0) (u5 :: u0 -> u0) (u6 :: u0 -> u0) (u7 :: u0 -> u0 -> u0) (u8 :: u0 -> u0 -> u0) (u9 :: u0 -> u0) (ua :: u0 -> u0) (ub :: u0 -> u0) (uc :: u0 -> u0) (ud :: u0 -> u0) (ue :: u0 -> u0) (uf :: u0 -> u0) (ug :: u0 -> u0) (uh :: u0 -> u0) (ui :: u0 -> u0) (uj :: u0 -> u0) (uk :: u0 -> u0) -> ub; _NO_DEFLT_ } _N_
{-defm-} _A_ 2 _U_ 12 _N_ _S_ "U(U(ASAA)AAAAAALLAAAAAAAAAA)L" {_A_ 4 _U_ 1112 _N_ _N_ _N_ _N_} _N_ _N_ #-}
asin :: a -> a
{-# GHC_PRAGMA {-meth-} _A_ 1 _U_ 12 _N_ _S_ "U(AAAAAAAAAASAAAAAAAA)" {_A_ 1 _U_ 12 _N_ _N_ _F_ _IF_ARGS_ 1 1 X 1 _/\_ u0 -> \ (u1 :: u0 -> u0) -> u1 _N_} _F_ _IF_ARGS_ 1 1 C 2 _/\_ u0 -> \ (u1 :: ({{Fractional u0}}, u0, u0 -> u0, u0 -> u0, u0 -> u0, u0 -> u0 -> u0, u0 -> u0 -> u0, u0 -> u0, u0 -> u0, u0 -> u0, u0 -> u0, u0 -> u0, u0 -> u0, u0 -> u0, u0 -> u0, u0 -> u0, u0 -> u0, u0 -> u0, u0 -> u0)) -> case u1 of { _ALG_ _TUP_19 (u2 :: {{Fractional u0}}) (u3 :: u0) (u4 :: u0 -> u0) (u5 :: u0 -> u0) (u6 :: u0 -> u0) (u7 :: u0 -> u0 -> u0) (u8 :: u0 -> u0 -> u0) (u9 :: u0 -> u0) (ua :: u0 -> u0) (ub :: u0 -> u0) (uc :: u0 -> u0) (ud :: u0 -> u0) (ue :: u0 -> u0) (uf :: u0 -> u0) (ug :: u0 -> u0) (uh :: u0 -> u0) (ui :: u0 -> u0) (uj :: u0 -> u0) (uk :: u0 -> u0) -> uc; _NO_DEFLT_ } _N_
- {-defm-} _A_ 2 _U_ 02 _N_ _S_ _!_ _F_ _IF_ARGS_ 1 2 XX 3 _/\_ u0 -> \ (u1 :: {{Floating u0}}) (u2 :: u0) -> _APP_ _TYAPP_ patError# { (u0 -> u0) } [ _NOREP_S_ "%DPreludeCore.Floating.asin\"", u2 ] _N_ #-}
+ {-defm-} _A_ 2 _U_ 02 _N_ _S_ _!_ _N_ _N_ #-}
acos :: a -> a
{-# GHC_PRAGMA {-meth-} _A_ 1 _U_ 12 _N_ _S_ "U(AAAAAAAAAAASAAAAAAA)" {_A_ 1 _U_ 12 _N_ _N_ _F_ _IF_ARGS_ 1 1 X 1 _/\_ u0 -> \ (u1 :: u0 -> u0) -> u1 _N_} _F_ _IF_ARGS_ 1 1 C 2 _/\_ u0 -> \ (u1 :: ({{Fractional u0}}, u0, u0 -> u0, u0 -> u0, u0 -> u0, u0 -> u0 -> u0, u0 -> u0 -> u0, u0 -> u0, u0 -> u0, u0 -> u0, u0 -> u0, u0 -> u0, u0 -> u0, u0 -> u0, u0 -> u0, u0 -> u0, u0 -> u0, u0 -> u0, u0 -> u0)) -> case u1 of { _ALG_ _TUP_19 (u2 :: {{Fractional u0}}) (u3 :: u0) (u4 :: u0 -> u0) (u5 :: u0 -> u0) (u6 :: u0 -> u0) (u7 :: u0 -> u0 -> u0) (u8 :: u0 -> u0 -> u0) (u9 :: u0 -> u0) (ua :: u0 -> u0) (ub :: u0 -> u0) (uc :: u0 -> u0) (ud :: u0 -> u0) (ue :: u0 -> u0) (uf :: u0 -> u0) (ug :: u0 -> u0) (uh :: u0 -> u0) (ui :: u0 -> u0) (uj :: u0 -> u0) (uk :: u0 -> u0) -> ud; _NO_DEFLT_ } _N_
- {-defm-} _A_ 2 _U_ 02 _N_ _S_ _!_ _F_ _IF_ARGS_ 1 2 XX 3 _/\_ u0 -> \ (u1 :: {{Floating u0}}) (u2 :: u0) -> _APP_ _TYAPP_ patError# { (u0 -> u0) } [ _NOREP_S_ "%DPreludeCore.Floating.acos\"", u2 ] _N_ #-}
+ {-defm-} _A_ 2 _U_ 02 _N_ _S_ _!_ _N_ _N_ #-}
atan :: a -> a
{-# GHC_PRAGMA {-meth-} _A_ 1 _U_ 12 _N_ _S_ "U(AAAAAAAAAAAASAAAAAA)" {_A_ 1 _U_ 12 _N_ _N_ _F_ _IF_ARGS_ 1 1 X 1 _/\_ u0 -> \ (u1 :: u0 -> u0) -> u1 _N_} _F_ _IF_ARGS_ 1 1 C 2 _/\_ u0 -> \ (u1 :: ({{Fractional u0}}, u0, u0 -> u0, u0 -> u0, u0 -> u0, u0 -> u0 -> u0, u0 -> u0 -> u0, u0 -> u0, u0 -> u0, u0 -> u0, u0 -> u0, u0 -> u0, u0 -> u0, u0 -> u0, u0 -> u0, u0 -> u0, u0 -> u0, u0 -> u0, u0 -> u0)) -> case u1 of { _ALG_ _TUP_19 (u2 :: {{Fractional u0}}) (u3 :: u0) (u4 :: u0 -> u0) (u5 :: u0 -> u0) (u6 :: u0 -> u0) (u7 :: u0 -> u0 -> u0) (u8 :: u0 -> u0 -> u0) (u9 :: u0 -> u0) (ua :: u0 -> u0) (ub :: u0 -> u0) (uc :: u0 -> u0) (ud :: u0 -> u0) (ue :: u0 -> u0) (uf :: u0 -> u0) (ug :: u0 -> u0) (uh :: u0 -> u0) (ui :: u0 -> u0) (uj :: u0 -> u0) (uk :: u0 -> u0) -> ue; _NO_DEFLT_ } _N_
- {-defm-} _A_ 2 _U_ 02 _N_ _S_ _!_ _F_ _IF_ARGS_ 1 2 XX 3 _/\_ u0 -> \ (u1 :: {{Floating u0}}) (u2 :: u0) -> _APP_ _TYAPP_ patError# { (u0 -> u0) } [ _NOREP_S_ "%DPreludeCore.Floating.atan\"", u2 ] _N_ #-}
+ {-defm-} _A_ 2 _U_ 02 _N_ _S_ _!_ _N_ _N_ #-}
sinh :: a -> a
{-# GHC_PRAGMA {-meth-} _A_ 1 _U_ 12 _N_ _S_ "U(AAAAAAAAAAAAASAAAAA)" {_A_ 1 _U_ 12 _N_ _N_ _F_ _IF_ARGS_ 1 1 X 1 _/\_ u0 -> \ (u1 :: u0 -> u0) -> u1 _N_} _F_ _IF_ARGS_ 1 1 C 2 _/\_ u0 -> \ (u1 :: ({{Fractional u0}}, u0, u0 -> u0, u0 -> u0, u0 -> u0, u0 -> u0 -> u0, u0 -> u0 -> u0, u0 -> u0, u0 -> u0, u0 -> u0, u0 -> u0, u0 -> u0, u0 -> u0, u0 -> u0, u0 -> u0, u0 -> u0, u0 -> u0, u0 -> u0, u0 -> u0)) -> case u1 of { _ALG_ _TUP_19 (u2 :: {{Fractional u0}}) (u3 :: u0) (u4 :: u0 -> u0) (u5 :: u0 -> u0) (u6 :: u0 -> u0) (u7 :: u0 -> u0 -> u0) (u8 :: u0 -> u0 -> u0) (u9 :: u0 -> u0) (ua :: u0 -> u0) (ub :: u0 -> u0) (uc :: u0 -> u0) (ud :: u0 -> u0) (ue :: u0 -> u0) (uf :: u0 -> u0) (ug :: u0 -> u0) (uh :: u0 -> u0) (ui :: u0 -> u0) (uj :: u0 -> u0) (uk :: u0 -> u0) -> uf; _NO_DEFLT_ } _N_
- {-defm-} _A_ 2 _U_ 02 _N_ _S_ _!_ _F_ _IF_ARGS_ 1 2 XX 3 _/\_ u0 -> \ (u1 :: {{Floating u0}}) (u2 :: u0) -> _APP_ _TYAPP_ patError# { (u0 -> u0) } [ _NOREP_S_ "%DPreludeCore.Floating.sinh\"", u2 ] _N_ #-}
+ {-defm-} _A_ 2 _U_ 02 _N_ _S_ _!_ _N_ _N_ #-}
cosh :: a -> a
{-# GHC_PRAGMA {-meth-} _A_ 1 _U_ 12 _N_ _S_ "U(AAAAAAAAAAAAAASAAAA)" {_A_ 1 _U_ 12 _N_ _N_ _F_ _IF_ARGS_ 1 1 X 1 _/\_ u0 -> \ (u1 :: u0 -> u0) -> u1 _N_} _F_ _IF_ARGS_ 1 1 C 2 _/\_ u0 -> \ (u1 :: ({{Fractional u0}}, u0, u0 -> u0, u0 -> u0, u0 -> u0, u0 -> u0 -> u0, u0 -> u0 -> u0, u0 -> u0, u0 -> u0, u0 -> u0, u0 -> u0, u0 -> u0, u0 -> u0, u0 -> u0, u0 -> u0, u0 -> u0, u0 -> u0, u0 -> u0, u0 -> u0)) -> case u1 of { _ALG_ _TUP_19 (u2 :: {{Fractional u0}}) (u3 :: u0) (u4 :: u0 -> u0) (u5 :: u0 -> u0) (u6 :: u0 -> u0) (u7 :: u0 -> u0 -> u0) (u8 :: u0 -> u0 -> u0) (u9 :: u0 -> u0) (ua :: u0 -> u0) (ub :: u0 -> u0) (uc :: u0 -> u0) (ud :: u0 -> u0) (ue :: u0 -> u0) (uf :: u0 -> u0) (ug :: u0 -> u0) (uh :: u0 -> u0) (ui :: u0 -> u0) (uj :: u0 -> u0) (uk :: u0 -> u0) -> ug; _NO_DEFLT_ } _N_
- {-defm-} _A_ 2 _U_ 02 _N_ _S_ _!_ _F_ _IF_ARGS_ 1 2 XX 3 _/\_ u0 -> \ (u1 :: {{Floating u0}}) (u2 :: u0) -> _APP_ _TYAPP_ patError# { (u0 -> u0) } [ _NOREP_S_ "%DPreludeCore.Floating.cosh\"", u2 ] _N_ #-}
+ {-defm-} _A_ 2 _U_ 02 _N_ _S_ _!_ _N_ _N_ #-}
tanh :: a -> a
{-# GHC_PRAGMA {-meth-} _A_ 1 _U_ 12 _N_ _S_ "U(AAAAAAAAAAAAAAASAAA)" {_A_ 1 _U_ 12 _N_ _N_ _F_ _IF_ARGS_ 1 1 X 1 _/\_ u0 -> \ (u1 :: u0 -> u0) -> u1 _N_} _F_ _IF_ARGS_ 1 1 C 2 _/\_ u0 -> \ (u1 :: ({{Fractional u0}}, u0, u0 -> u0, u0 -> u0, u0 -> u0, u0 -> u0 -> u0, u0 -> u0 -> u0, u0 -> u0, u0 -> u0, u0 -> u0, u0 -> u0, u0 -> u0, u0 -> u0, u0 -> u0, u0 -> u0, u0 -> u0, u0 -> u0, u0 -> u0, u0 -> u0)) -> case u1 of { _ALG_ _TUP_19 (u2 :: {{Fractional u0}}) (u3 :: u0) (u4 :: u0 -> u0) (u5 :: u0 -> u0) (u6 :: u0 -> u0) (u7 :: u0 -> u0 -> u0) (u8 :: u0 -> u0 -> u0) (u9 :: u0 -> u0) (ua :: u0 -> u0) (ub :: u0 -> u0) (uc :: u0 -> u0) (ud :: u0 -> u0) (ue :: u0 -> u0) (uf :: u0 -> u0) (ug :: u0 -> u0) (uh :: u0 -> u0) (ui :: u0 -> u0) (uj :: u0 -> u0) (uk :: u0 -> u0) -> uh; _NO_DEFLT_ } _N_
{-defm-} _A_ 2 _U_ 12 _N_ _S_ "U(U(ASAA)AAAAAAAAAAAALLAAAA)L" {_A_ 4 _U_ 1112 _N_ _N_ _N_ _N_} _N_ _N_ #-}
asinh :: a -> a
{-# GHC_PRAGMA {-meth-} _A_ 1 _U_ 12 _N_ _S_ "U(AAAAAAAAAAAAAAAASAA)" {_A_ 1 _U_ 12 _N_ _N_ _F_ _IF_ARGS_ 1 1 X 1 _/\_ u0 -> \ (u1 :: u0 -> u0) -> u1 _N_} _F_ _IF_ARGS_ 1 1 C 2 _/\_ u0 -> \ (u1 :: ({{Fractional u0}}, u0, u0 -> u0, u0 -> u0, u0 -> u0, u0 -> u0 -> u0, u0 -> u0 -> u0, u0 -> u0, u0 -> u0, u0 -> u0, u0 -> u0, u0 -> u0, u0 -> u0, u0 -> u0, u0 -> u0, u0 -> u0, u0 -> u0, u0 -> u0, u0 -> u0)) -> case u1 of { _ALG_ _TUP_19 (u2 :: {{Fractional u0}}) (u3 :: u0) (u4 :: u0 -> u0) (u5 :: u0 -> u0) (u6 :: u0 -> u0) (u7 :: u0 -> u0 -> u0) (u8 :: u0 -> u0 -> u0) (u9 :: u0 -> u0) (ua :: u0 -> u0) (ub :: u0 -> u0) (uc :: u0 -> u0) (ud :: u0 -> u0) (ue :: u0 -> u0) (uf :: u0 -> u0) (ug :: u0 -> u0) (uh :: u0 -> u0) (ui :: u0 -> u0) (uj :: u0 -> u0) (uk :: u0 -> u0) -> ui; _NO_DEFLT_ } _N_
- {-defm-} _A_ 2 _U_ 02 _N_ _S_ _!_ _F_ _IF_ARGS_ 1 2 XX 3 _/\_ u0 -> \ (u1 :: {{Floating u0}}) (u2 :: u0) -> _APP_ _TYAPP_ patError# { (u0 -> u0) } [ _NOREP_S_ "%DPreludeCore.Floating.asinh\"", u2 ] _N_ #-}
+ {-defm-} _A_ 2 _U_ 02 _N_ _S_ _!_ _N_ _N_ #-}
acosh :: a -> a
{-# GHC_PRAGMA {-meth-} _A_ 1 _U_ 12 _N_ _S_ "U(AAAAAAAAAAAAAAAAASA)" {_A_ 1 _U_ 12 _N_ _N_ _F_ _IF_ARGS_ 1 1 X 1 _/\_ u0 -> \ (u1 :: u0 -> u0) -> u1 _N_} _F_ _IF_ARGS_ 1 1 C 2 _/\_ u0 -> \ (u1 :: ({{Fractional u0}}, u0, u0 -> u0, u0 -> u0, u0 -> u0, u0 -> u0 -> u0, u0 -> u0 -> u0, u0 -> u0, u0 -> u0, u0 -> u0, u0 -> u0, u0 -> u0, u0 -> u0, u0 -> u0, u0 -> u0, u0 -> u0, u0 -> u0, u0 -> u0, u0 -> u0)) -> case u1 of { _ALG_ _TUP_19 (u2 :: {{Fractional u0}}) (u3 :: u0) (u4 :: u0 -> u0) (u5 :: u0 -> u0) (u6 :: u0 -> u0) (u7 :: u0 -> u0 -> u0) (u8 :: u0 -> u0 -> u0) (u9 :: u0 -> u0) (ua :: u0 -> u0) (ub :: u0 -> u0) (uc :: u0 -> u0) (ud :: u0 -> u0) (ue :: u0 -> u0) (uf :: u0 -> u0) (ug :: u0 -> u0) (uh :: u0 -> u0) (ui :: u0 -> u0) (uj :: u0 -> u0) (uk :: u0 -> u0) -> uj; _NO_DEFLT_ } _N_
- {-defm-} _A_ 2 _U_ 02 _N_ _S_ _!_ _F_ _IF_ARGS_ 1 2 XX 3 _/\_ u0 -> \ (u1 :: {{Floating u0}}) (u2 :: u0) -> _APP_ _TYAPP_ patError# { (u0 -> u0) } [ _NOREP_S_ "%DPreludeCore.Floating.acosh\"", u2 ] _N_ #-}
+ {-defm-} _A_ 2 _U_ 02 _N_ _S_ _!_ _N_ _N_ #-}
atanh :: a -> a
{-# GHC_PRAGMA {-meth-} _A_ 1 _U_ 12 _N_ _S_ "U(AAAAAAAAAAAAAAAAAAS)" {_A_ 1 _U_ 12 _N_ _N_ _F_ _IF_ARGS_ 1 1 X 1 _/\_ u0 -> \ (u1 :: u0 -> u0) -> u1 _N_} _F_ _IF_ARGS_ 1 1 C 2 _/\_ u0 -> \ (u1 :: ({{Fractional u0}}, u0, u0 -> u0, u0 -> u0, u0 -> u0, u0 -> u0 -> u0, u0 -> u0 -> u0, u0 -> u0, u0 -> u0, u0 -> u0, u0 -> u0, u0 -> u0, u0 -> u0, u0 -> u0, u0 -> u0, u0 -> u0, u0 -> u0, u0 -> u0, u0 -> u0)) -> case u1 of { _ALG_ _TUP_19 (u2 :: {{Fractional u0}}) (u3 :: u0) (u4 :: u0 -> u0) (u5 :: u0 -> u0) (u6 :: u0 -> u0) (u7 :: u0 -> u0 -> u0) (u8 :: u0 -> u0 -> u0) (u9 :: u0 -> u0) (ua :: u0 -> u0) (ub :: u0 -> u0) (uc :: u0 -> u0) (ud :: u0 -> u0) (ue :: u0 -> u0) (uf :: u0 -> u0) (ug :: u0 -> u0) (uh :: u0 -> u0) (ui :: u0 -> u0) (uj :: u0 -> u0) (uk :: u0 -> u0) -> uk; _NO_DEFLT_ } _N_
- {-defm-} _A_ 2 _U_ 02 _N_ _S_ _!_ _F_ _IF_ARGS_ 1 2 XX 3 _/\_ u0 -> \ (u1 :: {{Floating u0}}) (u2 :: u0) -> _APP_ _TYAPP_ patError# { (u0 -> u0) } [ _NOREP_S_ "%DPreludeCore.Floating.atanh\"", u2 ] _N_ #-}
+ {-defm-} _A_ 2 _U_ 02 _N_ _S_ _!_ _N_ _N_ #-}
class (Num a) => Fractional a {-# GHC_PRAGMA {-superdicts-} _A_ 1 _U_ 1 _N_ _S_ "U(U(LLLLLLLLLL)AAA)" {_A_ 1 _U_ 1 _N_ _N_ _F_ _IF_ARGS_ 1 1 X 1 _/\_ u0 -> \ (u1 :: {{Num u0}}) -> u1 _N_} _F_ _IF_ARGS_ 1 1 C 2 _/\_ u0 -> \ (u1 :: ({{Num u0}}, u0 -> u0 -> u0, u0 -> u0, Ratio Integer -> u0)) -> case u1 of { _ALG_ _TUP_4 (u2 :: {{Num u0}}) (u3 :: u0 -> u0 -> u0) (u4 :: u0 -> u0) (u5 :: Ratio Integer -> u0) -> u2; _NO_DEFLT_ } _N_ #-} where
(/) :: a -> a -> a
{-# GHC_PRAGMA {-meth-} _A_ 1 _U_ 122 _N_ _S_ "U(ASAA)" {_A_ 1 _U_ 122 _N_ _N_ _F_ _IF_ARGS_ 1 1 X 1 _/\_ u0 -> \ (u1 :: u0 -> u0 -> u0) -> u1 _N_} _F_ _IF_ARGS_ 1 1 C 2 _/\_ u0 -> \ (u1 :: ({{Num u0}}, u0 -> u0 -> u0, u0 -> u0, Ratio Integer -> u0)) -> case u1 of { _ALG_ _TUP_4 (u2 :: {{Num u0}}) (u3 :: u0 -> u0 -> u0) (u4 :: u0 -> u0) (u5 :: Ratio Integer -> u0) -> u3; _NO_DEFLT_ } _N_
- {-defm-} _A_ 3 _U_ 022 _N_ _S_ _!_ _F_ _IF_ARGS_ 1 3 XXX 4 _/\_ u0 -> \ (u1 :: {{Fractional u0}}) (u2 :: u0) (u3 :: u0) -> _APP_ _TYAPP_ patError# { (u0 -> u0 -> u0) } [ _NOREP_S_ "%DPreludeCore.Fractional.(/)\"", u2, u3 ] _N_ #-}
+ {-defm-} _A_ 3 _U_ 022 _N_ _S_ _!_ _N_ _N_ #-}
recip :: a -> a
{-# GHC_PRAGMA {-meth-} _A_ 1 _U_ 12 _N_ _S_ "U(AASA)" {_A_ 1 _U_ 12 _N_ _N_ _F_ _IF_ARGS_ 1 1 X 1 _/\_ u0 -> \ (u1 :: u0 -> u0) -> u1 _N_} _F_ _IF_ARGS_ 1 1 C 2 _/\_ u0 -> \ (u1 :: ({{Num u0}}, u0 -> u0 -> u0, u0 -> u0, Ratio Integer -> u0)) -> case u1 of { _ALG_ _TUP_4 (u2 :: {{Num u0}}) (u3 :: u0 -> u0 -> u0) (u4 :: u0 -> u0) (u5 :: Ratio Integer -> u0) -> u4; _NO_DEFLT_ } _N_
- {-defm-} _A_ 1 _U_ 12 _N_ _S_ "U(ASAL)" {_A_ 2 _U_ 122 _N_ _N_ _N_ _N_} _N_ _N_ #-}
+ {-defm-} _A_ 1 _U_ 12 _N_ _S_ "U(LSAA)" {_A_ 2 _U_ 112 _N_ _N_ _N_ _N_} _N_ _N_ #-}
fromRational :: Ratio Integer -> a
{-# GHC_PRAGMA {-meth-} _A_ 1 _U_ 12 _N_ _S_ "U(AAAS)" {_A_ 1 _U_ 12 _N_ _N_ _F_ _IF_ARGS_ 1 1 X 1 _/\_ u0 -> \ (u1 :: Ratio Integer -> u0) -> u1 _N_} _F_ _IF_ARGS_ 1 1 C 2 _/\_ u0 -> \ (u1 :: ({{Num u0}}, u0 -> u0 -> u0, u0 -> u0, Ratio Integer -> u0)) -> case u1 of { _ALG_ _TUP_4 (u2 :: {{Num u0}}) (u3 :: u0 -> u0 -> u0) (u4 :: u0 -> u0) (u5 :: Ratio Integer -> u0) -> u5; _NO_DEFLT_ } _N_
- {-defm-} _A_ 2 _U_ 02 _N_ _S_ _!_ _F_ _IF_ARGS_ 1 2 XX 3 _/\_ u0 -> \ (u1 :: {{Fractional u0}}) (u2 :: Ratio Integer) -> _APP_ _TYAPP_ patError# { (Ratio Integer -> u0) } [ _NOREP_S_ "%DPreludeCore.Fractional.fromRational\"", u2 ] _N_ #-}
+ {-defm-} _A_ 2 _U_ 02 _N_ _S_ _!_ _N_ _N_ #-}
class (Real a, Ix a) => Integral a {-# GHC_PRAGMA {-superdicts-} _A_ 1 _U_ 1 _N_ _S_ "U(U(LLL)AAAAAAAAAAA)" {_A_ 3 _U_ 222 _N_ _N_ _F_ _IF_ARGS_ 1 3 XXX 4 _/\_ u0 -> \ (u1 :: {{Num u0}}) (u2 :: {{Enum u0}}) (u3 :: u0 -> Ratio Integer) -> _!_ _TUP_3 [{{Num u0}}, {{Enum u0}}, (u0 -> Ratio Integer)] [u1, u2, u3] _N_} _F_ _IF_ARGS_ 1 1 C 2 _/\_ u0 -> \ (u1 :: ({{Real u0}}, {{Ix u0}}, u0 -> u0 -> u0, u0 -> u0 -> u0, u0 -> u0 -> u0, u0 -> u0 -> u0, u0 -> u0 -> (u0, u0), u0 -> u0 -> (u0, u0), u0 -> Bool, u0 -> Bool, u0 -> Integer, u0 -> Int)) -> case u1 of { _ALG_ _TUP_12 (u2 :: {{Real u0}}) (u3 :: {{Ix u0}}) (u4 :: u0 -> u0 -> u0) (u5 :: u0 -> u0 -> u0) (u6 :: u0 -> u0 -> u0) (u7 :: u0 -> u0 -> u0) (u8 :: u0 -> u0 -> (u0, u0)) (u9 :: u0 -> u0 -> (u0, u0)) (ua :: u0 -> Bool) (ub :: u0 -> Bool) (uc :: u0 -> Integer) (ud :: u0 -> Int) -> u2; _NO_DEFLT_ } _N_, _A_ 1 _U_ 1 _N_ _S_ "U(AU(LLLL)AAAAAAAAAA)" {_A_ 4 _U_ 2222 _N_ _N_ _F_ _IF_ARGS_ 1 4 XXXX 5 _/\_ u0 -> \ (u1 :: {{Ord u0}}) (u2 :: (u0, u0) -> [u0]) (u3 :: (u0, u0) -> u0 -> Int) (u4 :: (u0, u0) -> u0 -> Bool) -> _!_ _TUP_4 [{{Ord u0}}, ((u0, u0) -> [u0]), ((u0, u0) -> u0 -> Int), ((u0, u0) -> u0 -> Bool)] [u1, u2, u3, u4] _N_} _F_ _IF_ARGS_ 1 1 C 2 _/\_ u0 -> \ (u1 :: ({{Real u0}}, {{Ix u0}}, u0 -> u0 -> u0, u0 -> u0 -> u0, u0 -> u0 -> u0, u0 -> u0 -> u0, u0 -> u0 -> (u0, u0), u0 -> u0 -> (u0, u0), u0 -> Bool, u0 -> Bool, u0 -> Integer, u0 -> Int)) -> case u1 of { _ALG_ _TUP_12 (u2 :: {{Real u0}}) (u3 :: {{Ix u0}}) (u4 :: u0 -> u0 -> u0) (u5 :: u0 -> u0 -> u0) (u6 :: u0 -> u0 -> u0) (u7 :: u0 -> u0 -> u0) (u8 :: u0 -> u0 -> (u0, u0)) (u9 :: u0 -> u0 -> (u0, u0)) (ua :: u0 -> Bool) (ub :: u0 -> Bool) (uc :: u0 -> Integer) (ud :: u0 -> Int) -> u3; _NO_DEFLT_ } _N_ #-} where
quot :: a -> a -> a
{-# GHC_PRAGMA {-meth-} _A_ 1 _U_ 122 _N_ _S_ "U(AASAAAAAAAAA)" {_A_ 1 _U_ 122 _N_ _N_ _F_ _IF_ARGS_ 1 1 X 1 _/\_ u0 -> \ (u1 :: u0 -> u0 -> u0) -> u1 _N_} _F_ _IF_ARGS_ 1 1 C 2 _/\_ u0 -> \ (u1 :: ({{Real u0}}, {{Ix u0}}, u0 -> u0 -> u0, u0 -> u0 -> u0, u0 -> u0 -> u0, u0 -> u0 -> u0, u0 -> u0 -> (u0, u0), u0 -> u0 -> (u0, u0), u0 -> Bool, u0 -> Bool, u0 -> Integer, u0 -> Int)) -> case u1 of { _ALG_ _TUP_12 (u2 :: {{Real u0}}) (u3 :: {{Ix u0}}) (u4 :: u0 -> u0 -> u0) (u5 :: u0 -> u0 -> u0) (u6 :: u0 -> u0 -> u0) (u7 :: u0 -> u0 -> u0) (u8 :: u0 -> u0 -> (u0, u0)) (u9 :: u0 -> u0 -> (u0, u0)) (ua :: u0 -> Bool) (ub :: u0 -> Bool) (uc :: u0 -> Integer) (ud :: u0 -> Int) -> u4; _NO_DEFLT_ } _N_
{-defm-} _A_ 3 _U_ 122 _N_ _S_ "U(AAAAAAASAAAA)LL" {_A_ 3 _U_ 122 _N_ _N_ _F_ _IF_ARGS_ 1 3 XXX 5 _/\_ u0 -> \ (u1 :: u0 -> u0 -> (u0, u0)) (u2 :: u0) (u3 :: u0) -> case _APP_ u1 [ u2, u3 ] of { _ALG_ _TUP_2 (u4 :: u0) (u5 :: u0) -> u5; _NO_DEFLT_ } _N_} _F_ _IF_ARGS_ 1 3 CXX 6 _/\_ u0 -> \ (u1 :: {{Integral u0}}) (u2 :: u0) (u3 :: u0) -> case case u1 of { _ALG_ _TUP_12 (u4 :: {{Real u0}}) (u5 :: {{Ix u0}}) (u6 :: u0 -> u0 -> u0) (u7 :: u0 -> u0 -> u0) (u8 :: u0 -> u0 -> u0) (u9 :: u0 -> u0 -> u0) (ua :: u0 -> u0 -> (u0, u0)) (ub :: u0 -> u0 -> (u0, u0)) (uc :: u0 -> Bool) (ud :: u0 -> Bool) (ue :: u0 -> Integer) (uf :: u0 -> Int) -> _APP_ ub [ u2, u3 ]; _NO_DEFLT_ } of { _ALG_ _TUP_2 (ug :: u0) (uh :: u0) -> uh; _NO_DEFLT_ } _N_ #-}
quotRem :: a -> a -> (a, a)
{-# GHC_PRAGMA {-meth-} _A_ 1 _U_ 122 _N_ _S_ "U(AAAAAASAAAAA)" {_A_ 1 _U_ 122 _N_ _N_ _F_ _IF_ARGS_ 1 1 X 1 _/\_ u0 -> \ (u1 :: u0 -> u0 -> (u0, u0)) -> u1 _N_} _F_ _IF_ARGS_ 1 1 C 2 _/\_ u0 -> \ (u1 :: ({{Real u0}}, {{Ix u0}}, u0 -> u0 -> u0, u0 -> u0 -> u0, u0 -> u0 -> u0, u0 -> u0 -> u0, u0 -> u0 -> (u0, u0), u0 -> u0 -> (u0, u0), u0 -> Bool, u0 -> Bool, u0 -> Integer, u0 -> Int)) -> case u1 of { _ALG_ _TUP_12 (u2 :: {{Real u0}}) (u3 :: {{Ix u0}}) (u4 :: u0 -> u0 -> u0) (u5 :: u0 -> u0 -> u0) (u6 :: u0 -> u0 -> u0) (u7 :: u0 -> u0 -> u0) (u8 :: u0 -> u0 -> (u0, u0)) (u9 :: u0 -> u0 -> (u0, u0)) (ua :: u0 -> Bool) (ub :: u0 -> Bool) (uc :: u0 -> Integer) (ud :: u0 -> Int) -> u8; _NO_DEFLT_ } _N_
- {-defm-} _A_ 3 _U_ 022 _N_ _S_ _!_ _F_ _IF_ARGS_ 1 3 XXX 4 _/\_ u0 -> \ (u1 :: {{Integral u0}}) (u2 :: u0) (u3 :: u0) -> _APP_ _TYAPP_ patError# { (u0 -> u0 -> (u0, u0)) } [ _NOREP_S_ "%DPreludeCore.Integral.quotRem\"", u2, u3 ] _N_ #-}
+ {-defm-} _A_ 3 _U_ 022 _N_ _S_ _!_ _N_ _N_ #-}
divMod :: a -> a -> (a, a)
{-# GHC_PRAGMA {-meth-} _A_ 1 _U_ 122 _N_ _S_ "U(AAAAAAASAAAA)" {_A_ 1 _U_ 122 _N_ _N_ _F_ _IF_ARGS_ 1 1 X 1 _/\_ u0 -> \ (u1 :: u0 -> u0 -> (u0, u0)) -> u1 _N_} _F_ _IF_ARGS_ 1 1 C 2 _/\_ u0 -> \ (u1 :: ({{Real u0}}, {{Ix u0}}, u0 -> u0 -> u0, u0 -> u0 -> u0, u0 -> u0 -> u0, u0 -> u0 -> u0, u0 -> u0 -> (u0, u0), u0 -> u0 -> (u0, u0), u0 -> Bool, u0 -> Bool, u0 -> Integer, u0 -> Int)) -> case u1 of { _ALG_ _TUP_12 (u2 :: {{Real u0}}) (u3 :: {{Ix u0}}) (u4 :: u0 -> u0 -> u0) (u5 :: u0 -> u0 -> u0) (u6 :: u0 -> u0 -> u0) (u7 :: u0 -> u0 -> u0) (u8 :: u0 -> u0 -> (u0, u0)) (u9 :: u0 -> u0 -> (u0, u0)) (ua :: u0 -> Bool) (ub :: u0 -> Bool) (uc :: u0 -> Integer) (ud :: u0 -> Int) -> u9; _NO_DEFLT_ } _N_
- {-defm-} _A_ 1 _U_ 122 _N_ _S_ "U(U(U(U(SA)ALLALALLA)AA)AAAAALAAAAA)" {_A_ 2 _U_ 1222 _N_ _N_ _N_ _N_} _N_ _N_ #-}
+ {-defm-} _A_ 1 _U_ 122 _N_ _S_ "U(U(U(U(SA)ALLALALAL)AA)AAAAALAAAAA)" {_A_ 2 _U_ 1222 _N_ _N_ _N_ _N_} _N_ _N_ #-}
even :: a -> Bool
{-# GHC_PRAGMA {-meth-} _A_ 1 _U_ 12 _N_ _S_ "U(AAAAAAAASAAA)" {_A_ 1 _U_ 12 _N_ _N_ _F_ _IF_ARGS_ 1 1 X 1 _/\_ u0 -> \ (u1 :: u0 -> Bool) -> u1 _N_} _F_ _IF_ARGS_ 1 1 C 2 _/\_ u0 -> \ (u1 :: ({{Real u0}}, {{Ix u0}}, u0 -> u0 -> u0, u0 -> u0 -> u0, u0 -> u0 -> u0, u0 -> u0 -> u0, u0 -> u0 -> (u0, u0), u0 -> u0 -> (u0, u0), u0 -> Bool, u0 -> Bool, u0 -> Integer, u0 -> Int)) -> case u1 of { _ALG_ _TUP_12 (u2 :: {{Real u0}}) (u3 :: {{Ix u0}}) (u4 :: u0 -> u0 -> u0) (u5 :: u0 -> u0 -> u0) (u6 :: u0 -> u0 -> u0) (u7 :: u0 -> u0 -> u0) (u8 :: u0 -> u0 -> (u0, u0)) (u9 :: u0 -> u0 -> (u0, u0)) (ua :: u0 -> Bool) (ub :: u0 -> Bool) (uc :: u0 -> Integer) (ud :: u0 -> Int) -> ua; _NO_DEFLT_ } _N_
- {-defm-} _A_ 1 _U_ 12 _N_ _S_ "U(U(U(U(SA)AAAAAAALA)AA)AALAAAAAAAA)" {_A_ 3 _U_ 1212 _N_ _N_ _N_ _N_} _N_ _N_ #-}
+ {-defm-} _A_ 1 _U_ 12 _N_ _S_ "U(U(U(U(SA)AAAAAAAAL)AA)AALAAAAAAAA)" {_A_ 3 _U_ 1212 _N_ _N_ _N_ _N_} _N_ _N_ #-}
odd :: a -> Bool
{-# GHC_PRAGMA {-meth-} _A_ 1 _U_ 12 _N_ _S_ "U(AAAAAAAAASAA)" {_A_ 1 _U_ 12 _N_ _N_ _F_ _IF_ARGS_ 1 1 X 1 _/\_ u0 -> \ (u1 :: u0 -> Bool) -> u1 _N_} _F_ _IF_ARGS_ 1 1 C 2 _/\_ u0 -> \ (u1 :: ({{Real u0}}, {{Ix u0}}, u0 -> u0 -> u0, u0 -> u0 -> u0, u0 -> u0 -> u0, u0 -> u0 -> u0, u0 -> u0 -> (u0, u0), u0 -> u0 -> (u0, u0), u0 -> Bool, u0 -> Bool, u0 -> Integer, u0 -> Int)) -> case u1 of { _ALG_ _TUP_12 (u2 :: {{Real u0}}) (u3 :: {{Ix u0}}) (u4 :: u0 -> u0 -> u0) (u5 :: u0 -> u0 -> u0) (u6 :: u0 -> u0 -> u0) (u7 :: u0 -> u0 -> u0) (u8 :: u0 -> u0 -> (u0, u0)) (u9 :: u0 -> u0 -> (u0, u0)) (ua :: u0 -> Bool) (ub :: u0 -> Bool) (uc :: u0 -> Integer) (ud :: u0 -> Int) -> ub; _NO_DEFLT_ } _N_
- {-defm-} _A_ 1 _U_ 12 _N_ _S_ "U(U(U(U(AS)AAAAAAALA)AA)AALAAAAAAAA)" {_A_ 3 _U_ 1212 _N_ _N_ _N_ _N_} _N_ _N_ #-}
+ {-defm-} _A_ 1 _U_ 12 _N_ _S_ "U(U(U(U(AS)AAAAAAAAL)AA)AALAAAAAAAA)" {_A_ 3 _U_ 1212 _N_ _N_ _N_ _N_} _N_ _N_ #-}
toInteger :: a -> Integer
{-# GHC_PRAGMA {-meth-} _A_ 1 _U_ 12 _N_ _S_ "U(AAAAAAAAAASA)" {_A_ 1 _U_ 12 _N_ _N_ _F_ _IF_ARGS_ 1 1 X 1 _/\_ u0 -> \ (u1 :: u0 -> Integer) -> u1 _N_} _F_ _IF_ARGS_ 1 1 C 2 _/\_ u0 -> \ (u1 :: ({{Real u0}}, {{Ix u0}}, u0 -> u0 -> u0, u0 -> u0 -> u0, u0 -> u0 -> u0, u0 -> u0 -> u0, u0 -> u0 -> (u0, u0), u0 -> u0 -> (u0, u0), u0 -> Bool, u0 -> Bool, u0 -> Integer, u0 -> Int)) -> case u1 of { _ALG_ _TUP_12 (u2 :: {{Real u0}}) (u3 :: {{Ix u0}}) (u4 :: u0 -> u0 -> u0) (u5 :: u0 -> u0 -> u0) (u6 :: u0 -> u0 -> u0) (u7 :: u0 -> u0 -> u0) (u8 :: u0 -> u0 -> (u0, u0)) (u9 :: u0 -> u0 -> (u0, u0)) (ua :: u0 -> Bool) (ub :: u0 -> Bool) (uc :: u0 -> Integer) (ud :: u0 -> Int) -> uc; _NO_DEFLT_ } _N_
- {-defm-} _A_ 2 _U_ 02 _N_ _S_ _!_ _F_ _IF_ARGS_ 1 2 XX 3 _/\_ u0 -> \ (u1 :: {{Integral u0}}) (u2 :: u0) -> _APP_ _TYAPP_ patError# { (u0 -> Integer) } [ _NOREP_S_ "%DPreludeCore.Integral.toInteger\"", u2 ] _N_ #-}
+ {-defm-} _A_ 2 _U_ 02 _N_ _S_ _!_ _N_ _N_ #-}
toInt :: a -> Int
{-# GHC_PRAGMA {-meth-} _A_ 1 _U_ 12 _N_ _S_ "U(AAAAAAAAAAAS)" {_A_ 1 _U_ 12 _N_ _N_ _F_ _IF_ARGS_ 1 1 X 1 _/\_ u0 -> \ (u1 :: u0 -> Int) -> u1 _N_} _F_ _IF_ARGS_ 1 1 C 2 _/\_ u0 -> \ (u1 :: ({{Real u0}}, {{Ix u0}}, u0 -> u0 -> u0, u0 -> u0 -> u0, u0 -> u0 -> u0, u0 -> u0 -> u0, u0 -> u0 -> (u0, u0), u0 -> u0 -> (u0, u0), u0 -> Bool, u0 -> Bool, u0 -> Integer, u0 -> Int)) -> case u1 of { _ALG_ _TUP_12 (u2 :: {{Real u0}}) (u3 :: {{Ix u0}}) (u4 :: u0 -> u0 -> u0) (u5 :: u0 -> u0 -> u0) (u6 :: u0 -> u0 -> u0) (u7 :: u0 -> u0 -> u0) (u8 :: u0 -> u0 -> (u0, u0)) (u9 :: u0 -> u0 -> (u0, u0)) (ua :: u0 -> Bool) (ub :: u0 -> Bool) (uc :: u0 -> Integer) (ud :: u0 -> Int) -> ud; _NO_DEFLT_ } _N_
- {-defm-} _A_ 2 _U_ 02 _N_ _S_ _!_ _F_ _IF_ARGS_ 1 2 XX 3 _/\_ u0 -> \ (u1 :: {{Integral u0}}) (u2 :: u0) -> _APP_ _TYAPP_ patError# { (u0 -> Int) } [ _NOREP_S_ "%DPreludeCore.Integral.toInt\"", u2 ] _N_ #-}
+ {-defm-} _A_ 2 _U_ 02 _N_ _S_ _!_ _N_ _N_ #-}
class (Ord a) => Ix a {-# GHC_PRAGMA {-superdicts-} _A_ 1 _U_ 1 _N_ _S_ "U(U(LLLLLLLL)AAA)" {_A_ 1 _U_ 1 _N_ _N_ _F_ _IF_ARGS_ 1 1 X 1 _/\_ u0 -> \ (u1 :: {{Ord u0}}) -> u1 _N_} _F_ _IF_ARGS_ 1 1 C 2 _/\_ u0 -> \ (u1 :: ({{Ord u0}}, (u0, u0) -> [u0], (u0, u0) -> u0 -> Int, (u0, u0) -> u0 -> Bool)) -> case u1 of { _ALG_ _TUP_4 (u2 :: {{Ord u0}}) (u3 :: (u0, u0) -> [u0]) (u4 :: (u0, u0) -> u0 -> Int) (u5 :: (u0, u0) -> u0 -> Bool) -> u2; _NO_DEFLT_ } _N_ #-} where
range :: (a, a) -> [a]
{-# GHC_PRAGMA {-meth-} _A_ 1 _U_ 12 _N_ _S_ "U(ASAA)" {_A_ 1 _U_ 12 _N_ _N_ _F_ _IF_ARGS_ 1 1 X 1 _/\_ u0 -> \ (u1 :: (u0, u0) -> [u0]) -> u1 _N_} _F_ _IF_ARGS_ 1 1 C 2 _/\_ u0 -> \ (u1 :: ({{Ord u0}}, (u0, u0) -> [u0], (u0, u0) -> u0 -> Int, (u0, u0) -> u0 -> Bool)) -> case u1 of { _ALG_ _TUP_4 (u2 :: {{Ord u0}}) (u3 :: (u0, u0) -> [u0]) (u4 :: (u0, u0) -> u0 -> Int) (u5 :: (u0, u0) -> u0 -> Bool) -> u3; _NO_DEFLT_ } _N_
- {-defm-} _A_ 2 _U_ 02 _N_ _S_ _!_ _F_ _IF_ARGS_ 1 2 XX 3 _/\_ u0 -> \ (u1 :: {{Ix u0}}) (u2 :: (u0, u0)) -> _APP_ _TYAPP_ patError# { ((u0, u0) -> [u0]) } [ _NOREP_S_ "%DPreludeCore.Ix.range\"", u2 ] _N_ #-}
+ {-defm-} _A_ 2 _U_ 02 _N_ _S_ _!_ _N_ _N_ #-}
index :: (a, a) -> a -> Int
{-# GHC_PRAGMA {-meth-} _A_ 1 _U_ 122 _N_ _S_ "U(AASA)" {_A_ 1 _U_ 122 _N_ _N_ _F_ _IF_ARGS_ 1 1 X 1 _/\_ u0 -> \ (u1 :: (u0, u0) -> u0 -> Int) -> u1 _N_} _F_ _IF_ARGS_ 1 1 C 2 _/\_ u0 -> \ (u1 :: ({{Ord u0}}, (u0, u0) -> [u0], (u0, u0) -> u0 -> Int, (u0, u0) -> u0 -> Bool)) -> case u1 of { _ALG_ _TUP_4 (u2 :: {{Ord u0}}) (u3 :: (u0, u0) -> [u0]) (u4 :: (u0, u0) -> u0 -> Int) (u5 :: (u0, u0) -> u0 -> Bool) -> u4; _NO_DEFLT_ } _N_
- {-defm-} _A_ 3 _U_ 022 _N_ _S_ _!_ _F_ _IF_ARGS_ 1 3 XXX 4 _/\_ u0 -> \ (u1 :: {{Ix u0}}) (u2 :: (u0, u0)) (u3 :: u0) -> _APP_ _TYAPP_ patError# { ((u0, u0) -> u0 -> Int) } [ _NOREP_S_ "%DPreludeCore.Ix.index\"", u2, u3 ] _N_ #-}
+ {-defm-} _A_ 3 _U_ 022 _N_ _S_ _!_ _N_ _N_ #-}
inRange :: (a, a) -> a -> Bool
{-# GHC_PRAGMA {-meth-} _A_ 1 _U_ 122 _N_ _S_ "U(AAAS)" {_A_ 1 _U_ 122 _N_ _N_ _F_ _IF_ARGS_ 1 1 X 1 _/\_ u0 -> \ (u1 :: (u0, u0) -> u0 -> Bool) -> u1 _N_} _F_ _IF_ARGS_ 1 1 C 2 _/\_ u0 -> \ (u1 :: ({{Ord u0}}, (u0, u0) -> [u0], (u0, u0) -> u0 -> Int, (u0, u0) -> u0 -> Bool)) -> case u1 of { _ALG_ _TUP_4 (u2 :: {{Ord u0}}) (u3 :: (u0, u0) -> [u0]) (u4 :: (u0, u0) -> u0 -> Int) (u5 :: (u0, u0) -> u0 -> Bool) -> u5; _NO_DEFLT_ } _N_
- {-defm-} _A_ 3 _U_ 022 _N_ _S_ _!_ _F_ _IF_ARGS_ 1 3 XXX 4 _/\_ u0 -> \ (u1 :: {{Ix u0}}) (u2 :: (u0, u0)) (u3 :: u0) -> _APP_ _TYAPP_ patError# { ((u0, u0) -> u0 -> Bool) } [ _NOREP_S_ "%DPreludeCore.Ix.inRange\"", u2, u3 ] _N_ #-}
+ {-defm-} _A_ 3 _U_ 022 _N_ _S_ _!_ _N_ _N_ #-}
class (Eq a, Text a) => Num a {-# GHC_PRAGMA {-superdicts-} _A_ 1 _U_ 1 _N_ _S_ "U(U(LL)AAAAAAAAA)" {_A_ 2 _U_ 22 _N_ _N_ _F_ _IF_ARGS_ 1 2 XX 3 _/\_ u0 -> \ (u1 :: u0 -> u0 -> Bool) (u2 :: u0 -> u0 -> Bool) -> _!_ _TUP_2 [(u0 -> u0 -> Bool), (u0 -> u0 -> Bool)] [u1, u2] _N_} _F_ _IF_ARGS_ 1 1 C 2 _/\_ u0 -> \ (u1 :: ({{Eq u0}}, {{Text u0}}, u0 -> u0 -> u0, u0 -> u0 -> u0, u0 -> u0 -> u0, u0 -> u0, u0 -> u0, u0 -> u0, Integer -> u0, Int -> u0)) -> case u1 of { _ALG_ _TUP_10 (u2 :: {{Eq u0}}) (u3 :: {{Text u0}}) (u4 :: u0 -> u0 -> u0) (u5 :: u0 -> u0 -> u0) (u6 :: u0 -> u0 -> u0) (u7 :: u0 -> u0) (u8 :: u0 -> u0) (u9 :: u0 -> u0) (ua :: Integer -> u0) (ub :: Int -> u0) -> u2; _NO_DEFLT_ } _N_, _A_ 1 _U_ 1 _N_ _S_ "U(AU(LLLL)AAAAAAAA)" {_A_ 4 _U_ 2222 _N_ _N_ _F_ _IF_ARGS_ 1 4 XXXX 5 _/\_ u0 -> \ (u1 :: Int -> [Char] -> [(u0, [Char])]) (u2 :: Int -> u0 -> [Char] -> [Char]) (u3 :: [Char] -> [([u0], [Char])]) (u4 :: [u0] -> [Char] -> [Char]) -> _!_ _TUP_4 [(Int -> [Char] -> [(u0, [Char])]), (Int -> u0 -> [Char] -> [Char]), ([Char] -> [([u0], [Char])]), ([u0] -> [Char] -> [Char])] [u1, u2, u3, u4] _N_} _F_ _IF_ARGS_ 1 1 C 2 _/\_ u0 -> \ (u1 :: ({{Eq u0}}, {{Text u0}}, u0 -> u0 -> u0, u0 -> u0 -> u0, u0 -> u0 -> u0, u0 -> u0, u0 -> u0, u0 -> u0, Integer -> u0, Int -> u0)) -> case u1 of { _ALG_ _TUP_10 (u2 :: {{Eq u0}}) (u3 :: {{Text u0}}) (u4 :: u0 -> u0 -> u0) (u5 :: u0 -> u0 -> u0) (u6 :: u0 -> u0 -> u0) (u7 :: u0 -> u0) (u8 :: u0 -> u0) (u9 :: u0 -> u0) (ua :: Integer -> u0) (ub :: Int -> u0) -> u3; _NO_DEFLT_ } _N_ #-} where
(+) :: a -> a -> a
{-# GHC_PRAGMA {-meth-} _A_ 1 _U_ 122 _N_ _S_ "U(AASAAAAAAA)" {_A_ 1 _U_ 122 _N_ _N_ _F_ _IF_ARGS_ 1 1 X 1 _/\_ u0 -> \ (u1 :: u0 -> u0 -> u0) -> u1 _N_} _F_ _IF_ARGS_ 1 1 C 2 _/\_ u0 -> \ (u1 :: ({{Eq u0}}, {{Text u0}}, u0 -> u0 -> u0, u0 -> u0 -> u0, u0 -> u0 -> u0, u0 -> u0, u0 -> u0, u0 -> u0, Integer -> u0, Int -> u0)) -> case u1 of { _ALG_ _TUP_10 (u2 :: {{Eq u0}}) (u3 :: {{Text u0}}) (u4 :: u0 -> u0 -> u0) (u5 :: u0 -> u0 -> u0) (u6 :: u0 -> u0 -> u0) (u7 :: u0 -> u0) (u8 :: u0 -> u0) (u9 :: u0 -> u0) (ua :: Integer -> u0) (ub :: Int -> u0) -> u4; _NO_DEFLT_ } _N_
- {-defm-} _A_ 3 _U_ 022 _N_ _S_ _!_ _F_ _IF_ARGS_ 1 3 XXX 4 _/\_ u0 -> \ (u1 :: {{Num u0}}) (u2 :: u0) (u3 :: u0) -> _APP_ _TYAPP_ patError# { (u0 -> u0 -> u0) } [ _NOREP_S_ "%DPreludeCore.Num.(+)\"", u2, u3 ] _N_ #-}
+ {-defm-} _A_ 3 _U_ 022 _N_ _S_ _!_ _N_ _N_ #-}
(-) :: a -> a -> a
{-# GHC_PRAGMA {-meth-} _A_ 1 _U_ 122 _N_ _S_ "U(AAASAAAAAA)" {_A_ 1 _U_ 122 _N_ _N_ _F_ _IF_ARGS_ 1 1 X 1 _/\_ u0 -> \ (u1 :: u0 -> u0 -> u0) -> u1 _N_} _F_ _IF_ARGS_ 1 1 C 2 _/\_ u0 -> \ (u1 :: ({{Eq u0}}, {{Text u0}}, u0 -> u0 -> u0, u0 -> u0 -> u0, u0 -> u0 -> u0, u0 -> u0, u0 -> u0, u0 -> u0, Integer -> u0, Int -> u0)) -> case u1 of { _ALG_ _TUP_10 (u2 :: {{Eq u0}}) (u3 :: {{Text u0}}) (u4 :: u0 -> u0 -> u0) (u5 :: u0 -> u0 -> u0) (u6 :: u0 -> u0 -> u0) (u7 :: u0 -> u0) (u8 :: u0 -> u0) (u9 :: u0 -> u0) (ua :: Integer -> u0) (ub :: Int -> u0) -> u5; _NO_DEFLT_ } _N_
{-defm-} _A_ 3 _U_ 122 _N_ _S_ "U(AASAALAAAA)LL" {_A_ 4 _U_ 1122 _N_ _N_ _F_ _IF_ARGS_ 1 4 XXXX 6 _/\_ u0 -> \ (u1 :: u0 -> u0 -> u0) (u2 :: u0 -> u0) (u3 :: u0) (u4 :: u0) -> let {(u5 :: u0) = _APP_ u2 [ u4 ]} in _APP_ u1 [ u3, u5 ] _N_} _F_ _ALWAYS_ _/\_ u0 -> \ (u1 :: {{Num u0}}) (u2 :: u0) (u3 :: u0) -> case u1 of { _ALG_ _TUP_10 (u4 :: {{Eq u0}}) (u5 :: {{Text u0}}) (u6 :: u0 -> u0 -> u0) (u7 :: u0 -> u0 -> u0) (u8 :: u0 -> u0 -> u0) (u9 :: u0 -> u0) (ua :: u0 -> u0) (ub :: u0 -> u0) (uc :: Integer -> u0) (ud :: Int -> u0) -> let {(ue :: u0) = _APP_ u9 [ u3 ]} in _APP_ u6 [ u2, ue ]; _NO_DEFLT_ } _N_ #-}
(*) :: a -> a -> a
{-# GHC_PRAGMA {-meth-} _A_ 1 _U_ 122 _N_ _S_ "U(AAAASAAAAA)" {_A_ 1 _U_ 122 _N_ _N_ _F_ _IF_ARGS_ 1 1 X 1 _/\_ u0 -> \ (u1 :: u0 -> u0 -> u0) -> u1 _N_} _F_ _IF_ARGS_ 1 1 C 2 _/\_ u0 -> \ (u1 :: ({{Eq u0}}, {{Text u0}}, u0 -> u0 -> u0, u0 -> u0 -> u0, u0 -> u0 -> u0, u0 -> u0, u0 -> u0, u0 -> u0, Integer -> u0, Int -> u0)) -> case u1 of { _ALG_ _TUP_10 (u2 :: {{Eq u0}}) (u3 :: {{Text u0}}) (u4 :: u0 -> u0 -> u0) (u5 :: u0 -> u0 -> u0) (u6 :: u0 -> u0 -> u0) (u7 :: u0 -> u0) (u8 :: u0 -> u0) (u9 :: u0 -> u0) (ua :: Integer -> u0) (ub :: Int -> u0) -> u6; _NO_DEFLT_ } _N_
- {-defm-} _A_ 3 _U_ 022 _N_ _S_ _!_ _F_ _IF_ARGS_ 1 3 XXX 4 _/\_ u0 -> \ (u1 :: {{Num u0}}) (u2 :: u0) (u3 :: u0) -> _APP_ _TYAPP_ patError# { (u0 -> u0 -> u0) } [ _NOREP_S_ "%DPreludeCore.Num.(*)\"", u2, u3 ] _N_ #-}
+ {-defm-} _A_ 3 _U_ 022 _N_ _S_ _!_ _N_ _N_ #-}
negate :: a -> a
{-# GHC_PRAGMA {-meth-} _A_ 1 _U_ 12 _N_ _S_ "U(AAAAASAAAA)" {_A_ 1 _U_ 12 _N_ _N_ _F_ _IF_ARGS_ 1 1 X 1 _/\_ u0 -> \ (u1 :: u0 -> u0) -> u1 _N_} _F_ _IF_ARGS_ 1 1 C 2 _/\_ u0 -> \ (u1 :: ({{Eq u0}}, {{Text u0}}, u0 -> u0 -> u0, u0 -> u0 -> u0, u0 -> u0 -> u0, u0 -> u0, u0 -> u0, u0 -> u0, Integer -> u0, Int -> u0)) -> case u1 of { _ALG_ _TUP_10 (u2 :: {{Eq u0}}) (u3 :: {{Text u0}}) (u4 :: u0 -> u0 -> u0) (u5 :: u0 -> u0 -> u0) (u6 :: u0 -> u0 -> u0) (u7 :: u0 -> u0) (u8 :: u0 -> u0) (u9 :: u0 -> u0) (ua :: Integer -> u0) (ub :: Int -> u0) -> u7; _NO_DEFLT_ } _N_
- {-defm-} _A_ 2 _U_ 02 _N_ _S_ _!_ _F_ _IF_ARGS_ 1 2 XX 3 _/\_ u0 -> \ (u1 :: {{Num u0}}) (u2 :: u0) -> _APP_ _TYAPP_ patError# { (u0 -> u0) } [ _NOREP_S_ "%DPreludeCore.Num.negate\"", u2 ] _N_ #-}
+ {-defm-} _A_ 2 _U_ 02 _N_ _S_ _!_ _N_ _N_ #-}
abs :: a -> a
{-# GHC_PRAGMA {-meth-} _A_ 1 _U_ 12 _N_ _S_ "U(AAAAAASAAA)" {_A_ 1 _U_ 12 _N_ _N_ _F_ _IF_ARGS_ 1 1 X 1 _/\_ u0 -> \ (u1 :: u0 -> u0) -> u1 _N_} _F_ _IF_ARGS_ 1 1 C 2 _/\_ u0 -> \ (u1 :: ({{Eq u0}}, {{Text u0}}, u0 -> u0 -> u0, u0 -> u0 -> u0, u0 -> u0 -> u0, u0 -> u0, u0 -> u0, u0 -> u0, Integer -> u0, Int -> u0)) -> case u1 of { _ALG_ _TUP_10 (u2 :: {{Eq u0}}) (u3 :: {{Text u0}}) (u4 :: u0 -> u0 -> u0) (u5 :: u0 -> u0 -> u0) (u6 :: u0 -> u0 -> u0) (u7 :: u0 -> u0) (u8 :: u0 -> u0) (u9 :: u0 -> u0) (ua :: Integer -> u0) (ub :: Int -> u0) -> u8; _NO_DEFLT_ } _N_
- {-defm-} _A_ 2 _U_ 02 _N_ _S_ _!_ _F_ _IF_ARGS_ 1 2 XX 3 _/\_ u0 -> \ (u1 :: {{Num u0}}) (u2 :: u0) -> _APP_ _TYAPP_ patError# { (u0 -> u0) } [ _NOREP_S_ "%DPreludeCore.Num.abs\"", u2 ] _N_ #-}
+ {-defm-} _A_ 2 _U_ 02 _N_ _S_ _!_ _N_ _N_ #-}
signum :: a -> a
{-# GHC_PRAGMA {-meth-} _A_ 1 _U_ 12 _N_ _S_ "U(AAAAAAASAA)" {_A_ 1 _U_ 12 _N_ _N_ _F_ _IF_ARGS_ 1 1 X 1 _/\_ u0 -> \ (u1 :: u0 -> u0) -> u1 _N_} _F_ _IF_ARGS_ 1 1 C 2 _/\_ u0 -> \ (u1 :: ({{Eq u0}}, {{Text u0}}, u0 -> u0 -> u0, u0 -> u0 -> u0, u0 -> u0 -> u0, u0 -> u0, u0 -> u0, u0 -> u0, Integer -> u0, Int -> u0)) -> case u1 of { _ALG_ _TUP_10 (u2 :: {{Eq u0}}) (u3 :: {{Text u0}}) (u4 :: u0 -> u0 -> u0) (u5 :: u0 -> u0 -> u0) (u6 :: u0 -> u0 -> u0) (u7 :: u0 -> u0) (u8 :: u0 -> u0) (u9 :: u0 -> u0) (ua :: Integer -> u0) (ub :: Int -> u0) -> u9; _NO_DEFLT_ } _N_
- {-defm-} _A_ 2 _U_ 02 _N_ _S_ _!_ _F_ _IF_ARGS_ 1 2 XX 3 _/\_ u0 -> \ (u1 :: {{Num u0}}) (u2 :: u0) -> _APP_ _TYAPP_ patError# { (u0 -> u0) } [ _NOREP_S_ "%DPreludeCore.Num.signum\"", u2 ] _N_ #-}
+ {-defm-} _A_ 2 _U_ 02 _N_ _S_ _!_ _N_ _N_ #-}
fromInteger :: Integer -> a
{-# GHC_PRAGMA {-meth-} _A_ 1 _U_ 12 _N_ _S_ "U(AAAAAAAASA)" {_A_ 1 _U_ 12 _N_ _N_ _F_ _IF_ARGS_ 1 1 X 1 _/\_ u0 -> \ (u1 :: Integer -> u0) -> u1 _N_} _F_ _IF_ARGS_ 1 1 C 2 _/\_ u0 -> \ (u1 :: ({{Eq u0}}, {{Text u0}}, u0 -> u0 -> u0, u0 -> u0 -> u0, u0 -> u0 -> u0, u0 -> u0, u0 -> u0, u0 -> u0, Integer -> u0, Int -> u0)) -> case u1 of { _ALG_ _TUP_10 (u2 :: {{Eq u0}}) (u3 :: {{Text u0}}) (u4 :: u0 -> u0 -> u0) (u5 :: u0 -> u0 -> u0) (u6 :: u0 -> u0 -> u0) (u7 :: u0 -> u0) (u8 :: u0 -> u0) (u9 :: u0 -> u0) (ua :: Integer -> u0) (ub :: Int -> u0) -> ua; _NO_DEFLT_ } _N_
- {-defm-} _A_ 2 _U_ 02 _N_ _S_ _!_ _F_ _IF_ARGS_ 1 2 XX 3 _/\_ u0 -> \ (u1 :: {{Num u0}}) (u2 :: Integer) -> _APP_ _TYAPP_ patError# { (Integer -> u0) } [ _NOREP_S_ "%DPreludeCore.Num.fromInteger\"", u2 ] _N_ #-}
+ {-defm-} _A_ 2 _U_ 02 _N_ _S_ _!_ _N_ _N_ #-}
fromInt :: Int -> a
{-# GHC_PRAGMA {-meth-} _A_ 1 _U_ 12 _N_ _S_ "U(AAAAAAAAAS)" {_A_ 1 _U_ 12 _N_ _N_ _F_ _IF_ARGS_ 1 1 X 1 _/\_ u0 -> \ (u1 :: Int -> u0) -> u1 _N_} _F_ _IF_ARGS_ 1 1 C 2 _/\_ u0 -> \ (u1 :: ({{Eq u0}}, {{Text u0}}, u0 -> u0 -> u0, u0 -> u0 -> u0, u0 -> u0 -> u0, u0 -> u0, u0 -> u0, u0 -> u0, Integer -> u0, Int -> u0)) -> case u1 of { _ALG_ _TUP_10 (u2 :: {{Eq u0}}) (u3 :: {{Text u0}}) (u4 :: u0 -> u0 -> u0) (u5 :: u0 -> u0 -> u0) (u6 :: u0 -> u0 -> u0) (u7 :: u0 -> u0) (u8 :: u0 -> u0) (u9 :: u0 -> u0) (ua :: Integer -> u0) (ub :: Int -> u0) -> ub; _NO_DEFLT_ } _N_
{-defm-} _A_ 2 _U_ 11 _N_ _S_ "U(AAAAAAAASA)L" {_A_ 2 _U_ 11 _N_ _N_ _F_ _IF_ARGS_ 1 2 XC 5 _/\_ u0 -> \ (u1 :: Integer -> u0) (u2 :: Int) -> let {(u4 :: Integer) = case u2 of { _ALG_ I# (u3 :: Int#) -> _#_ int2Integer# [] [u3]; _NO_DEFLT_ }} in _APP_ u1 [ u4 ] _N_} _F_ _IF_ARGS_ 1 2 CC 6 _/\_ u0 -> \ (u1 :: {{Num u0}}) (u2 :: Int) -> let {(u4 :: Integer) = case u2 of { _ALG_ I# (u3 :: Int#) -> _#_ int2Integer# [] [u3]; _NO_DEFLT_ }} in case u1 of { _ALG_ _TUP_10 (u5 :: {{Eq u0}}) (u6 :: {{Text u0}}) (u7 :: u0 -> u0 -> u0) (u8 :: u0 -> u0 -> u0) (u9 :: u0 -> u0 -> u0) (ua :: u0 -> u0) (ub :: u0 -> u0) (uc :: u0 -> u0) (ud :: Integer -> u0) (ue :: Int -> u0) -> _APP_ ud [ u4 ]; _NO_DEFLT_ } _N_ #-}
{-defm-} _A_ 3 _U_ 122 _N_ _S_ "U(LASAAAAA)LL" {_A_ 4 _U_ 1122 _N_ _N_ _N_ _N_} _N_ _N_ #-}
(<=) :: a -> a -> Bool
{-# GHC_PRAGMA {-meth-} _A_ 1 _U_ 122 _N_ _S_ "U(AASAAAAA)" {_A_ 1 _U_ 122 _N_ _N_ _F_ _IF_ARGS_ 1 1 X 1 _/\_ u0 -> \ (u1 :: u0 -> u0 -> Bool) -> u1 _N_} _F_ _IF_ARGS_ 1 1 C 2 _/\_ u0 -> \ (u1 :: ({{Eq u0}}, u0 -> u0 -> Bool, u0 -> u0 -> Bool, u0 -> u0 -> Bool, u0 -> u0 -> Bool, u0 -> u0 -> u0, u0 -> u0 -> u0, u0 -> u0 -> _CMP_TAG)) -> case u1 of { _ALG_ _TUP_8 (u2 :: {{Eq u0}}) (u3 :: u0 -> u0 -> Bool) (u4 :: u0 -> u0 -> Bool) (u5 :: u0 -> u0 -> Bool) (u6 :: u0 -> u0 -> Bool) (u7 :: u0 -> u0 -> u0) (u8 :: u0 -> u0 -> u0) (u9 :: u0 -> u0 -> _CMP_TAG) -> u4; _NO_DEFLT_ } _N_
- {-defm-} _A_ 3 _U_ 022 _N_ _S_ _!_ _F_ _IF_ARGS_ 1 3 XXX 4 _/\_ u0 -> \ (u1 :: {{Ord u0}}) (u2 :: u0) (u3 :: u0) -> _APP_ _TYAPP_ patError# { (u0 -> u0 -> Bool) } [ _NOREP_S_ "%DPreludeCore.Ord.(<=)\"", u2, u3 ] _N_ #-}
+ {-defm-} _A_ 3 _U_ 022 _N_ _S_ _!_ _N_ _N_ #-}
(>=) :: a -> a -> Bool
{-# GHC_PRAGMA {-meth-} _A_ 1 _U_ 122 _N_ _S_ "U(AAASAAAA)" {_A_ 1 _U_ 122 _N_ _N_ _F_ _IF_ARGS_ 1 1 X 1 _/\_ u0 -> \ (u1 :: u0 -> u0 -> Bool) -> u1 _N_} _F_ _IF_ARGS_ 1 1 C 2 _/\_ u0 -> \ (u1 :: ({{Eq u0}}, u0 -> u0 -> Bool, u0 -> u0 -> Bool, u0 -> u0 -> Bool, u0 -> u0 -> Bool, u0 -> u0 -> u0, u0 -> u0 -> u0, u0 -> u0 -> _CMP_TAG)) -> case u1 of { _ALG_ _TUP_8 (u2 :: {{Eq u0}}) (u3 :: u0 -> u0 -> Bool) (u4 :: u0 -> u0 -> Bool) (u5 :: u0 -> u0 -> Bool) (u6 :: u0 -> u0 -> Bool) (u7 :: u0 -> u0 -> u0) (u8 :: u0 -> u0 -> u0) (u9 :: u0 -> u0 -> _CMP_TAG) -> u5; _NO_DEFLT_ } _N_
{-defm-} _A_ 3 _U_ 122 _N_ _S_ "U(AASAAAAA)LL" {_A_ 3 _U_ 122 _N_ _N_ _F_ _IF_ARGS_ 1 3 XXX 3 _/\_ u0 -> \ (u1 :: u0 -> u0 -> Bool) (u2 :: u0) (u3 :: u0) -> _APP_ u1 [ u3, u2 ] _N_} _F_ _IF_ARGS_ 1 3 CXX 4 _/\_ u0 -> \ (u1 :: {{Ord u0}}) (u2 :: u0) (u3 :: u0) -> case u1 of { _ALG_ _TUP_8 (u4 :: {{Eq u0}}) (u5 :: u0 -> u0 -> Bool) (u6 :: u0 -> u0 -> Bool) (u7 :: u0 -> u0 -> Bool) (u8 :: u0 -> u0 -> Bool) (u9 :: u0 -> u0 -> u0) (ua :: u0 -> u0 -> u0) (ub :: u0 -> u0 -> _CMP_TAG) -> _APP_ u6 [ u3, u2 ]; _NO_DEFLT_ } _N_ #-}
class (Num a, Enum a) => Real a {-# GHC_PRAGMA {-superdicts-} _A_ 1 _U_ 1 _N_ _S_ "U(U(LLLLLLLLLL)AA)" {_A_ 1 _U_ 1 _N_ _N_ _F_ _IF_ARGS_ 1 1 X 1 _/\_ u0 -> \ (u1 :: {{Num u0}}) -> u1 _N_} _F_ _IF_ARGS_ 1 1 C 2 _/\_ u0 -> \ (u1 :: ({{Num u0}}, {{Enum u0}}, u0 -> Ratio Integer)) -> case u1 of { _ALG_ _TUP_3 (u2 :: {{Num u0}}) (u3 :: {{Enum u0}}) (u4 :: u0 -> Ratio Integer) -> u2; _NO_DEFLT_ } _N_, _A_ 1 _U_ 1 _N_ _S_ "U(AU(LLLLL)A)" {_A_ 5 _U_ 22222 _N_ _N_ _F_ _IF_ARGS_ 1 5 XXXXX 6 _/\_ u0 -> \ (u1 :: {{Ord u0}}) (u2 :: u0 -> [u0]) (u3 :: u0 -> u0 -> [u0]) (u4 :: u0 -> u0 -> [u0]) (u5 :: u0 -> u0 -> u0 -> [u0]) -> _!_ _TUP_5 [{{Ord u0}}, (u0 -> [u0]), (u0 -> u0 -> [u0]), (u0 -> u0 -> [u0]), (u0 -> u0 -> u0 -> [u0])] [u1, u2, u3, u4, u5] _N_} _F_ _IF_ARGS_ 1 1 C 2 _/\_ u0 -> \ (u1 :: ({{Num u0}}, {{Enum u0}}, u0 -> Ratio Integer)) -> case u1 of { _ALG_ _TUP_3 (u2 :: {{Num u0}}) (u3 :: {{Enum u0}}) (u4 :: u0 -> Ratio Integer) -> u3; _NO_DEFLT_ } _N_ #-} where
toRational :: a -> Ratio Integer
{-# GHC_PRAGMA {-meth-} _A_ 1 _U_ 12 _N_ _S_ "U(AAS)" {_A_ 1 _U_ 12 _N_ _N_ _F_ _IF_ARGS_ 1 1 X 1 _/\_ u0 -> \ (u1 :: u0 -> Ratio Integer) -> u1 _N_} _F_ _IF_ARGS_ 1 1 C 2 _/\_ u0 -> \ (u1 :: ({{Num u0}}, {{Enum u0}}, u0 -> Ratio Integer)) -> case u1 of { _ALG_ _TUP_3 (u2 :: {{Num u0}}) (u3 :: {{Enum u0}}) (u4 :: u0 -> Ratio Integer) -> u4; _NO_DEFLT_ } _N_
- {-defm-} _A_ 2 _U_ 02 _N_ _S_ _!_ _F_ _IF_ARGS_ 1 2 XX 3 _/\_ u0 -> \ (u1 :: {{Real u0}}) (u2 :: u0) -> _APP_ _TYAPP_ patError# { (u0 -> Ratio Integer) } [ _NOREP_S_ "%DPreludeCore.Real.toRational\"", u2 ] _N_ #-}
+ {-defm-} _A_ 2 _U_ 02 _N_ _S_ _!_ _N_ _N_ #-}
class (RealFrac a, Floating a) => RealFloat a {-# GHC_PRAGMA {-superdicts-} _A_ 1 _U_ 1 _N_ _S_ "U(U(LLLLLLL)AAAAAAAAA)" {_A_ 1 _U_ 1 _N_ _N_ _F_ _IF_ARGS_ 1 1 X 1 _/\_ u0 -> \ (u1 :: {{RealFrac u0}}) -> u1 _N_} _F_ _IF_ARGS_ 1 1 C 2 _/\_ u0 -> \ (u1 :: ({{RealFrac u0}}, {{Floating u0}}, u0 -> Integer, u0 -> Int, u0 -> (Int, Int), u0 -> (Integer, Int), Integer -> Int -> u0, u0 -> Int, u0 -> u0, Int -> u0 -> u0)) -> case u1 of { _ALG_ _TUP_10 (u2 :: {{RealFrac u0}}) (u3 :: {{Floating u0}}) (u4 :: u0 -> Integer) (u5 :: u0 -> Int) (u6 :: u0 -> (Int, Int)) (u7 :: u0 -> (Integer, Int)) (u8 :: Integer -> Int -> u0) (u9 :: u0 -> Int) (ua :: u0 -> u0) (ub :: Int -> u0 -> u0) -> u2; _NO_DEFLT_ } _N_, _A_ 1 _U_ 1 _N_ _S_ "U(AU(LLLLLLLLLLLLLLLLLLL)AAAAAAAA)" {_A_ 1 _U_ 1 _N_ _N_ _F_ _IF_ARGS_ 1 1 X 1 _/\_ u0 -> \ (u1 :: {{Floating u0}}) -> u1 _N_} _F_ _IF_ARGS_ 1 1 C 2 _/\_ u0 -> \ (u1 :: ({{RealFrac u0}}, {{Floating u0}}, u0 -> Integer, u0 -> Int, u0 -> (Int, Int), u0 -> (Integer, Int), Integer -> Int -> u0, u0 -> Int, u0 -> u0, Int -> u0 -> u0)) -> case u1 of { _ALG_ _TUP_10 (u2 :: {{RealFrac u0}}) (u3 :: {{Floating u0}}) (u4 :: u0 -> Integer) (u5 :: u0 -> Int) (u6 :: u0 -> (Int, Int)) (u7 :: u0 -> (Integer, Int)) (u8 :: Integer -> Int -> u0) (u9 :: u0 -> Int) (ua :: u0 -> u0) (ub :: Int -> u0 -> u0) -> u3; _NO_DEFLT_ } _N_ #-} where
floatRadix :: a -> Integer
{-# GHC_PRAGMA {-meth-} _A_ 1 _U_ 12 _N_ _S_ "U(AASAAAAAAA)" {_A_ 1 _U_ 12 _N_ _N_ _F_ _IF_ARGS_ 1 1 X 1 _/\_ u0 -> \ (u1 :: u0 -> Integer) -> u1 _N_} _F_ _IF_ARGS_ 1 1 C 2 _/\_ u0 -> \ (u1 :: ({{RealFrac u0}}, {{Floating u0}}, u0 -> Integer, u0 -> Int, u0 -> (Int, Int), u0 -> (Integer, Int), Integer -> Int -> u0, u0 -> Int, u0 -> u0, Int -> u0 -> u0)) -> case u1 of { _ALG_ _TUP_10 (u2 :: {{RealFrac u0}}) (u3 :: {{Floating u0}}) (u4 :: u0 -> Integer) (u5 :: u0 -> Int) (u6 :: u0 -> (Int, Int)) (u7 :: u0 -> (Integer, Int)) (u8 :: Integer -> Int -> u0) (u9 :: u0 -> Int) (ua :: u0 -> u0) (ub :: Int -> u0 -> u0) -> u4; _NO_DEFLT_ } _N_
- {-defm-} _A_ 2 _U_ 02 _N_ _S_ _!_ _F_ _IF_ARGS_ 1 2 XX 3 _/\_ u0 -> \ (u1 :: {{RealFloat u0}}) (u2 :: u0) -> _APP_ _TYAPP_ patError# { (u0 -> Integer) } [ _NOREP_S_ "%DPreludeCore.RealFloat.floatRadix\"", u2 ] _N_ #-}
+ {-defm-} _A_ 2 _U_ 02 _N_ _S_ _!_ _N_ _N_ #-}
floatDigits :: a -> Int
{-# GHC_PRAGMA {-meth-} _A_ 1 _U_ 12 _N_ _S_ "U(AAASAAAAAA)" {_A_ 1 _U_ 12 _N_ _N_ _F_ _IF_ARGS_ 1 1 X 1 _/\_ u0 -> \ (u1 :: u0 -> Int) -> u1 _N_} _F_ _IF_ARGS_ 1 1 C 2 _/\_ u0 -> \ (u1 :: ({{RealFrac u0}}, {{Floating u0}}, u0 -> Integer, u0 -> Int, u0 -> (Int, Int), u0 -> (Integer, Int), Integer -> Int -> u0, u0 -> Int, u0 -> u0, Int -> u0 -> u0)) -> case u1 of { _ALG_ _TUP_10 (u2 :: {{RealFrac u0}}) (u3 :: {{Floating u0}}) (u4 :: u0 -> Integer) (u5 :: u0 -> Int) (u6 :: u0 -> (Int, Int)) (u7 :: u0 -> (Integer, Int)) (u8 :: Integer -> Int -> u0) (u9 :: u0 -> Int) (ua :: u0 -> u0) (ub :: Int -> u0 -> u0) -> u5; _NO_DEFLT_ } _N_
- {-defm-} _A_ 2 _U_ 02 _N_ _S_ _!_ _F_ _IF_ARGS_ 1 2 XX 3 _/\_ u0 -> \ (u1 :: {{RealFloat u0}}) (u2 :: u0) -> _APP_ _TYAPP_ patError# { (u0 -> Int) } [ _NOREP_S_ "%DPreludeCore.RealFloat.floatDigits\"", u2 ] _N_ #-}
+ {-defm-} _A_ 2 _U_ 02 _N_ _S_ _!_ _N_ _N_ #-}
floatRange :: a -> (Int, Int)
{-# GHC_PRAGMA {-meth-} _A_ 1 _U_ 12 _N_ _S_ "U(AAAASAAAAA)" {_A_ 1 _U_ 12 _N_ _N_ _F_ _IF_ARGS_ 1 1 X 1 _/\_ u0 -> \ (u1 :: u0 -> (Int, Int)) -> u1 _N_} _F_ _IF_ARGS_ 1 1 C 2 _/\_ u0 -> \ (u1 :: ({{RealFrac u0}}, {{Floating u0}}, u0 -> Integer, u0 -> Int, u0 -> (Int, Int), u0 -> (Integer, Int), Integer -> Int -> u0, u0 -> Int, u0 -> u0, Int -> u0 -> u0)) -> case u1 of { _ALG_ _TUP_10 (u2 :: {{RealFrac u0}}) (u3 :: {{Floating u0}}) (u4 :: u0 -> Integer) (u5 :: u0 -> Int) (u6 :: u0 -> (Int, Int)) (u7 :: u0 -> (Integer, Int)) (u8 :: Integer -> Int -> u0) (u9 :: u0 -> Int) (ua :: u0 -> u0) (ub :: Int -> u0 -> u0) -> u6; _NO_DEFLT_ } _N_
- {-defm-} _A_ 2 _U_ 02 _N_ _S_ _!_ _F_ _IF_ARGS_ 1 2 XX 3 _/\_ u0 -> \ (u1 :: {{RealFloat u0}}) (u2 :: u0) -> _APP_ _TYAPP_ patError# { (u0 -> (Int, Int)) } [ _NOREP_S_ "%DPreludeCore.RealFloat.floatRange\"", u2 ] _N_ #-}
+ {-defm-} _A_ 2 _U_ 02 _N_ _S_ _!_ _N_ _N_ #-}
decodeFloat :: a -> (Integer, Int)
{-# GHC_PRAGMA {-meth-} _A_ 1 _U_ 12 _N_ _S_ "U(AAAAASAAAA)" {_A_ 1 _U_ 12 _N_ _N_ _F_ _IF_ARGS_ 1 1 X 1 _/\_ u0 -> \ (u1 :: u0 -> (Integer, Int)) -> u1 _N_} _F_ _IF_ARGS_ 1 1 C 2 _/\_ u0 -> \ (u1 :: ({{RealFrac u0}}, {{Floating u0}}, u0 -> Integer, u0 -> Int, u0 -> (Int, Int), u0 -> (Integer, Int), Integer -> Int -> u0, u0 -> Int, u0 -> u0, Int -> u0 -> u0)) -> case u1 of { _ALG_ _TUP_10 (u2 :: {{RealFrac u0}}) (u3 :: {{Floating u0}}) (u4 :: u0 -> Integer) (u5 :: u0 -> Int) (u6 :: u0 -> (Int, Int)) (u7 :: u0 -> (Integer, Int)) (u8 :: Integer -> Int -> u0) (u9 :: u0 -> Int) (ua :: u0 -> u0) (ub :: Int -> u0 -> u0) -> u7; _NO_DEFLT_ } _N_
- {-defm-} _A_ 2 _U_ 02 _N_ _S_ _!_ _F_ _IF_ARGS_ 1 2 XX 3 _/\_ u0 -> \ (u1 :: {{RealFloat u0}}) (u2 :: u0) -> _APP_ _TYAPP_ patError# { (u0 -> (Integer, Int)) } [ _NOREP_S_ "%DPreludeCore.RealFloat.decodeFloat\"", u2 ] _N_ #-}
+ {-defm-} _A_ 2 _U_ 02 _N_ _S_ _!_ _N_ _N_ #-}
encodeFloat :: Integer -> Int -> a
{-# GHC_PRAGMA {-meth-} _A_ 1 _U_ 122 _N_ _S_ "U(AAAAAASAAA)" {_A_ 1 _U_ 122 _N_ _N_ _F_ _IF_ARGS_ 1 1 X 1 _/\_ u0 -> \ (u1 :: Integer -> Int -> u0) -> u1 _N_} _F_ _IF_ARGS_ 1 1 C 2 _/\_ u0 -> \ (u1 :: ({{RealFrac u0}}, {{Floating u0}}, u0 -> Integer, u0 -> Int, u0 -> (Int, Int), u0 -> (Integer, Int), Integer -> Int -> u0, u0 -> Int, u0 -> u0, Int -> u0 -> u0)) -> case u1 of { _ALG_ _TUP_10 (u2 :: {{RealFrac u0}}) (u3 :: {{Floating u0}}) (u4 :: u0 -> Integer) (u5 :: u0 -> Int) (u6 :: u0 -> (Int, Int)) (u7 :: u0 -> (Integer, Int)) (u8 :: Integer -> Int -> u0) (u9 :: u0 -> Int) (ua :: u0 -> u0) (ub :: Int -> u0 -> u0) -> u8; _NO_DEFLT_ } _N_
- {-defm-} _A_ 3 _U_ 022 _N_ _S_ _!_ _F_ _IF_ARGS_ 1 3 XXX 4 _/\_ u0 -> \ (u1 :: {{RealFloat u0}}) (u2 :: Integer) (u3 :: Int) -> _APP_ _TYAPP_ patError# { (Integer -> Int -> u0) } [ _NOREP_S_ "%DPreludeCore.RealFloat.encodeFloat\"", u2, u3 ] _N_ #-}
+ {-defm-} _A_ 3 _U_ 022 _N_ _S_ _!_ _N_ _N_ #-}
exponent :: a -> Int
{-# GHC_PRAGMA {-meth-} _A_ 1 _U_ 12 _N_ _S_ "U(AAAAAAASAA)" {_A_ 1 _U_ 12 _N_ _N_ _F_ _IF_ARGS_ 1 1 X 1 _/\_ u0 -> \ (u1 :: u0 -> Int) -> u1 _N_} _F_ _IF_ARGS_ 1 1 C 2 _/\_ u0 -> \ (u1 :: ({{RealFrac u0}}, {{Floating u0}}, u0 -> Integer, u0 -> Int, u0 -> (Int, Int), u0 -> (Integer, Int), Integer -> Int -> u0, u0 -> Int, u0 -> u0, Int -> u0 -> u0)) -> case u1 of { _ALG_ _TUP_10 (u2 :: {{RealFrac u0}}) (u3 :: {{Floating u0}}) (u4 :: u0 -> Integer) (u5 :: u0 -> Int) (u6 :: u0 -> (Int, Int)) (u7 :: u0 -> (Integer, Int)) (u8 :: Integer -> Int -> u0) (u9 :: u0 -> Int) (ua :: u0 -> u0) (ub :: Int -> u0 -> u0) -> u9; _NO_DEFLT_ } _N_
{-defm-} _A_ 2 _U_ 12 _N_ _S_ "U(AAALASAAAA)L" {_A_ 3 _U_ 112 _N_ _N_ _N_ _N_} _N_ _N_ #-}
class (Real a, Fractional a) => RealFrac a {-# GHC_PRAGMA {-superdicts-} _A_ 1 _U_ 1 _N_ _S_ "U(U(LLL)AAAAAA)" {_A_ 3 _U_ 222 _N_ _N_ _F_ _IF_ARGS_ 1 3 XXX 4 _/\_ u0 -> \ (u1 :: {{Num u0}}) (u2 :: {{Enum u0}}) (u3 :: u0 -> Ratio Integer) -> _!_ _TUP_3 [{{Num u0}}, {{Enum u0}}, (u0 -> Ratio Integer)] [u1, u2, u3] _N_} _F_ _IF_ARGS_ 1 1 C 2 _/\_ u0 -> \ (u1 :: ({{Real u0}}, {{Fractional u0}}, (_forall_ z$z1 =>{{Integral z$z1}} -> u0 -> (z$z1, u0)), (_forall_ z$z1 =>{{Integral z$z1}} -> u0 -> z$z1), (_forall_ z$z1 =>{{Integral z$z1}} -> u0 -> z$z1), (_forall_ z$z1 =>{{Integral z$z1}} -> u0 -> z$z1), (_forall_ z$z1 =>{{Integral z$z1}} -> u0 -> z$z1))) -> case u1 of { _ALG_ _TUP_7 (u2 :: {{Real u0}}) (u3 :: {{Fractional u0}}) (u4 :: _forall_ a$z1 =>{{Integral a$z1}} -> u0 -> (a$z1, u0)) (u5 :: _forall_ a$z1 =>{{Integral a$z1}} -> u0 -> a$z1) (u6 :: _forall_ a$z1 =>{{Integral a$z1}} -> u0 -> a$z1) (u7 :: _forall_ a$z1 =>{{Integral a$z1}} -> u0 -> a$z1) (u8 :: _forall_ a$z1 =>{{Integral a$z1}} -> u0 -> a$z1) -> u2; _NO_DEFLT_ } _N_, _A_ 1 _U_ 1 _N_ _S_ "U(AU(LLLL)AAAAA)" {_A_ 4 _U_ 2222 _N_ _N_ _F_ _IF_ARGS_ 1 4 XXXX 5 _/\_ u0 -> \ (u1 :: {{Num u0}}) (u2 :: u0 -> u0 -> u0) (u3 :: u0 -> u0) (u4 :: Ratio Integer -> u0) -> _!_ _TUP_4 [{{Num u0}}, (u0 -> u0 -> u0), (u0 -> u0), (Ratio Integer -> u0)] [u1, u2, u3, u4] _N_} _F_ _IF_ARGS_ 1 1 C 2 _/\_ u0 -> \ (u1 :: ({{Real u0}}, {{Fractional u0}}, (_forall_ z$z1 =>{{Integral z$z1}} -> u0 -> (z$z1, u0)), (_forall_ z$z1 =>{{Integral z$z1}} -> u0 -> z$z1), (_forall_ z$z1 =>{{Integral z$z1}} -> u0 -> z$z1), (_forall_ z$z1 =>{{Integral z$z1}} -> u0 -> z$z1), (_forall_ z$z1 =>{{Integral z$z1}} -> u0 -> z$z1))) -> case u1 of { _ALG_ _TUP_7 (u2 :: {{Real u0}}) (u3 :: {{Fractional u0}}) (u4 :: _forall_ a$z1 =>{{Integral a$z1}} -> u0 -> (a$z1, u0)) (u5 :: _forall_ a$z1 =>{{Integral a$z1}} -> u0 -> a$z1) (u6 :: _forall_ a$z1 =>{{Integral a$z1}} -> u0 -> a$z1) (u7 :: _forall_ a$z1 =>{{Integral a$z1}} -> u0 -> a$z1) (u8 :: _forall_ a$z1 =>{{Integral a$z1}} -> u0 -> a$z1) -> u3; _NO_DEFLT_ } _N_ #-} where
properFraction :: Integral b => a -> (b, a)
{-# GHC_PRAGMA {-meth-} _A_ 2 _U_ 122 _N_ _S_ "U(AASAAAA)L" {_A_ 2 _U_ 122 _N_ _N_ _F_ _IF_ARGS_ 2 2 XX 2 _/\_ u0 u1 -> \ (u2 :: _forall_ a$z1 =>{{Integral a$z1}} -> u0 -> (a$z1, u0)) (u3 :: {{Integral u1}}) -> _APP_ _TYAPP_ u2 { u1 } [ u3 ] _N_} _F_ _IF_ARGS_ 2 2 CX 3 _/\_ u0 u1 -> \ (u2 :: ({{Real u0}}, {{Fractional u0}}, (_forall_ z$z1 =>{{Integral z$z1}} -> u0 -> (z$z1, u0)), (_forall_ z$z1 =>{{Integral z$z1}} -> u0 -> z$z1), (_forall_ z$z1 =>{{Integral z$z1}} -> u0 -> z$z1), (_forall_ z$z1 =>{{Integral z$z1}} -> u0 -> z$z1), (_forall_ z$z1 =>{{Integral z$z1}} -> u0 -> z$z1))) (u3 :: {{Integral u1}}) -> case u2 of { _ALG_ _TUP_7 (u4 :: {{Real u0}}) (u5 :: {{Fractional u0}}) (u6 :: _forall_ a$z1 =>{{Integral a$z1}} -> u0 -> (a$z1, u0)) (u7 :: _forall_ a$z1 =>{{Integral a$z1}} -> u0 -> a$z1) (u8 :: _forall_ a$z1 =>{{Integral a$z1}} -> u0 -> a$z1) (u9 :: _forall_ a$z1 =>{{Integral a$z1}} -> u0 -> a$z1) (ua :: _forall_ a$z1 =>{{Integral a$z1}} -> u0 -> a$z1) -> _APP_ _TYAPP_ u6 { u1 } [ u3 ]; _NO_DEFLT_ } _N_
- {-defm-} _A_ 3 _U_ 002 _N_ _S_ _!_ _F_ _IF_ARGS_ 2 3 XXX 3 _/\_ u0 u1 -> \ (u2 :: {{RealFrac u0}}) (u3 :: {{Integral u1}}) (u4 :: u0) -> _APP_ _TYAPP_ patError# { (u0 -> (u1, u0)) } [ _NOREP_S_ "%DPreludeCore.RealFrac.properFraction\"", u4 ] _N_ #-}
+ {-defm-} _A_ 3 _U_ 002 _N_ _S_ _!_ _N_ _N_ #-}
truncate :: Integral b => a -> b
{-# GHC_PRAGMA {-meth-} _A_ 2 _U_ 122 _N_ _S_ "U(AAASAAA)L" {_A_ 2 _U_ 122 _N_ _N_ _F_ _IF_ARGS_ 2 2 XX 2 _/\_ u0 u1 -> \ (u2 :: _forall_ a$z1 =>{{Integral a$z1}} -> u0 -> a$z1) (u3 :: {{Integral u1}}) -> _APP_ _TYAPP_ u2 { u1 } [ u3 ] _N_} _F_ _IF_ARGS_ 2 2 CX 3 _/\_ u0 u1 -> \ (u2 :: ({{Real u0}}, {{Fractional u0}}, (_forall_ z$z1 =>{{Integral z$z1}} -> u0 -> (z$z1, u0)), (_forall_ z$z1 =>{{Integral z$z1}} -> u0 -> z$z1), (_forall_ z$z1 =>{{Integral z$z1}} -> u0 -> z$z1), (_forall_ z$z1 =>{{Integral z$z1}} -> u0 -> z$z1), (_forall_ z$z1 =>{{Integral z$z1}} -> u0 -> z$z1))) (u3 :: {{Integral u1}}) -> case u2 of { _ALG_ _TUP_7 (u4 :: {{Real u0}}) (u5 :: {{Fractional u0}}) (u6 :: _forall_ a$z1 =>{{Integral a$z1}} -> u0 -> (a$z1, u0)) (u7 :: _forall_ a$z1 =>{{Integral a$z1}} -> u0 -> a$z1) (u8 :: _forall_ a$z1 =>{{Integral a$z1}} -> u0 -> a$z1) (u9 :: _forall_ a$z1 =>{{Integral a$z1}} -> u0 -> a$z1) (ua :: _forall_ a$z1 =>{{Integral a$z1}} -> u0 -> a$z1) -> _APP_ _TYAPP_ u7 { u1 } [ u3 ]; _NO_DEFLT_ } _N_
- {-defm-} _A_ 2 _U_ 122 _N_ _S_ "U(AASAAAA)L" {_A_ 2 _U_ 222 _N_ _N_ _N_ _N_} _N_ _N_ #-}
+ {-defm-} _A_ 2 _U_ 122 _N_ _S_ "U(AASAAAA)L" {_A_ 2 _U_ 122 _N_ _N_ _N_ _N_} _N_ _N_ #-}
round :: Integral b => a -> b
{-# GHC_PRAGMA {-meth-} _A_ 2 _U_ 122 _N_ _S_ "U(AAAASAA)L" {_A_ 2 _U_ 122 _N_ _N_ _F_ _IF_ARGS_ 2 2 XX 2 _/\_ u0 u1 -> \ (u2 :: _forall_ a$z1 =>{{Integral a$z1}} -> u0 -> a$z1) (u3 :: {{Integral u1}}) -> _APP_ _TYAPP_ u2 { u1 } [ u3 ] _N_} _F_ _IF_ARGS_ 2 2 CX 3 _/\_ u0 u1 -> \ (u2 :: ({{Real u0}}, {{Fractional u0}}, (_forall_ z$z1 =>{{Integral z$z1}} -> u0 -> (z$z1, u0)), (_forall_ z$z1 =>{{Integral z$z1}} -> u0 -> z$z1), (_forall_ z$z1 =>{{Integral z$z1}} -> u0 -> z$z1), (_forall_ z$z1 =>{{Integral z$z1}} -> u0 -> z$z1), (_forall_ z$z1 =>{{Integral z$z1}} -> u0 -> z$z1))) (u3 :: {{Integral u1}}) -> case u2 of { _ALG_ _TUP_7 (u4 :: {{Real u0}}) (u5 :: {{Fractional u0}}) (u6 :: _forall_ a$z1 =>{{Integral a$z1}} -> u0 -> (a$z1, u0)) (u7 :: _forall_ a$z1 =>{{Integral a$z1}} -> u0 -> a$z1) (u8 :: _forall_ a$z1 =>{{Integral a$z1}} -> u0 -> a$z1) (u9 :: _forall_ a$z1 =>{{Integral a$z1}} -> u0 -> a$z1) (ua :: _forall_ a$z1 =>{{Integral a$z1}} -> u0 -> a$z1) -> _APP_ _TYAPP_ u8 { u1 } [ u3 ]; _NO_DEFLT_ } _N_
- {-defm-} _A_ 2 _U_ 122 _N_ _S_ "U(U(AU(U(ALAAAAAS)AAAA)A)LSAAAA)L" {_A_ 5 _U_ 222222 _N_ _N_ _N_ _N_} _N_ _N_ #-}
+ {-defm-} _A_ 2 _U_ 122 _N_ _S_ "U(U(AU(U(ALAAAAAS)AAAA)A)LSAAAA)L" {_A_ 5 _U_ 112122 _N_ _N_ _N_ _N_} _N_ _N_ #-}
ceiling :: Integral b => a -> b
{-# GHC_PRAGMA {-meth-} _A_ 2 _U_ 122 _N_ _S_ "U(AAAAASA)L" {_A_ 2 _U_ 122 _N_ _N_ _F_ _IF_ARGS_ 2 2 XX 2 _/\_ u0 u1 -> \ (u2 :: _forall_ a$z1 =>{{Integral a$z1}} -> u0 -> a$z1) (u3 :: {{Integral u1}}) -> _APP_ _TYAPP_ u2 { u1 } [ u3 ] _N_} _F_ _IF_ARGS_ 2 2 CX 3 _/\_ u0 u1 -> \ (u2 :: ({{Real u0}}, {{Fractional u0}}, (_forall_ z$z1 =>{{Integral z$z1}} -> u0 -> (z$z1, u0)), (_forall_ z$z1 =>{{Integral z$z1}} -> u0 -> z$z1), (_forall_ z$z1 =>{{Integral z$z1}} -> u0 -> z$z1), (_forall_ z$z1 =>{{Integral z$z1}} -> u0 -> z$z1), (_forall_ z$z1 =>{{Integral z$z1}} -> u0 -> z$z1))) (u3 :: {{Integral u1}}) -> case u2 of { _ALG_ _TUP_7 (u4 :: {{Real u0}}) (u5 :: {{Fractional u0}}) (u6 :: _forall_ a$z1 =>{{Integral a$z1}} -> u0 -> (a$z1, u0)) (u7 :: _forall_ a$z1 =>{{Integral a$z1}} -> u0 -> a$z1) (u8 :: _forall_ a$z1 =>{{Integral a$z1}} -> u0 -> a$z1) (u9 :: _forall_ a$z1 =>{{Integral a$z1}} -> u0 -> a$z1) (ua :: _forall_ a$z1 =>{{Integral a$z1}} -> u0 -> a$z1) -> _APP_ _TYAPP_ u9 { u1 } [ u3 ]; _NO_DEFLT_ } _N_
- {-defm-} _A_ 2 _U_ 122 _N_ _S_ "U(U(AU(U(AAAASAAA)AAAA)A)LSAAAA)L" {_A_ 4 _U_ 22222 _N_ _N_ _N_ _N_} _N_ _N_ #-}
+ {-defm-} _A_ 2 _U_ 122 _N_ _S_ "U(U(LU(U(AAAASAAA)AAAA)A)ASAAAA)L" {_A_ 4 _U_ 11122 _N_ _N_ _N_ _N_} _N_ _N_ #-}
floor :: Integral b => a -> b
{-# GHC_PRAGMA {-meth-} _A_ 2 _U_ 122 _N_ _S_ "U(AAAAAAS)L" {_A_ 2 _U_ 122 _N_ _N_ _F_ _IF_ARGS_ 2 2 XX 2 _/\_ u0 u1 -> \ (u2 :: _forall_ a$z1 =>{{Integral a$z1}} -> u0 -> a$z1) (u3 :: {{Integral u1}}) -> _APP_ _TYAPP_ u2 { u1 } [ u3 ] _N_} _F_ _IF_ARGS_ 2 2 CX 3 _/\_ u0 u1 -> \ (u2 :: ({{Real u0}}, {{Fractional u0}}, (_forall_ z$z1 =>{{Integral z$z1}} -> u0 -> (z$z1, u0)), (_forall_ z$z1 =>{{Integral z$z1}} -> u0 -> z$z1), (_forall_ z$z1 =>{{Integral z$z1}} -> u0 -> z$z1), (_forall_ z$z1 =>{{Integral z$z1}} -> u0 -> z$z1), (_forall_ z$z1 =>{{Integral z$z1}} -> u0 -> z$z1))) (u3 :: {{Integral u1}}) -> case u2 of { _ALG_ _TUP_7 (u4 :: {{Real u0}}) (u5 :: {{Fractional u0}}) (u6 :: _forall_ a$z1 =>{{Integral a$z1}} -> u0 -> (a$z1, u0)) (u7 :: _forall_ a$z1 =>{{Integral a$z1}} -> u0 -> a$z1) (u8 :: _forall_ a$z1 =>{{Integral a$z1}} -> u0 -> a$z1) (u9 :: _forall_ a$z1 =>{{Integral a$z1}} -> u0 -> a$z1) (ua :: _forall_ a$z1 =>{{Integral a$z1}} -> u0 -> a$z1) -> _APP_ _TYAPP_ ua { u1 } [ u3 ]; _NO_DEFLT_ } _N_
- {-defm-} _A_ 2 _U_ 122 _N_ _S_ "U(U(AU(U(ASAAAAAA)AAAA)A)LSAAAA)L" {_A_ 4 _U_ 22222 _N_ _N_ _N_ _N_} _N_ _N_ #-}
+ {-defm-} _A_ 2 _U_ 122 _N_ _S_ "U(U(LU(U(ASAAAAAA)AAAA)A)ASAAAA)L" {_A_ 4 _U_ 11122 _N_ _N_ _N_ _N_} _N_ _N_ #-}
class Text a where
readsPrec :: Int -> [Char] -> [(a, [Char])]
{-# GHC_PRAGMA {-meth-} _A_ 1 _U_ 122 _N_ _S_ "U(SAAA)" {_A_ 1 _U_ 122 _N_ _N_ _F_ _IF_ARGS_ 1 1 X 1 _/\_ u0 -> \ (u1 :: Int -> [Char] -> [(u0, [Char])]) -> u1 _N_} _F_ _IF_ARGS_ 1 1 C 2 _/\_ u0 -> \ (u1 :: (Int -> [Char] -> [(u0, [Char])], Int -> u0 -> [Char] -> [Char], [Char] -> [([u0], [Char])], [u0] -> [Char] -> [Char])) -> case u1 of { _ALG_ _TUP_4 (u2 :: Int -> [Char] -> [(u0, [Char])]) (u3 :: Int -> u0 -> [Char] -> [Char]) (u4 :: [Char] -> [([u0], [Char])]) (u5 :: [u0] -> [Char] -> [Char]) -> u2; _NO_DEFLT_ } _N_
- {-defm-} _A_ 3 _U_ 022 _N_ _S_ _!_ _F_ _IF_ARGS_ 1 3 XXX 4 _/\_ u0 -> \ (u1 :: {{Text u0}}) (u2 :: Int) (u3 :: [Char]) -> _APP_ _TYAPP_ patError# { (Int -> [Char] -> [(u0, [Char])]) } [ _NOREP_S_ "%DPreludeCore.Text.readsPrec\"", u2, u3 ] _N_ #-}
+ {-defm-} _A_ 3 _U_ 022 _N_ _S_ _!_ _N_ _N_ #-}
showsPrec :: Int -> a -> [Char] -> [Char]
{-# GHC_PRAGMA {-meth-} _A_ 1 _U_ 1222 _N_ _S_ "U(ASAA)" {_A_ 1 _U_ 1222 _N_ _N_ _F_ _IF_ARGS_ 1 1 X 1 _/\_ u0 -> \ (u1 :: Int -> u0 -> [Char] -> [Char]) -> u1 _N_} _F_ _IF_ARGS_ 1 1 C 2 _/\_ u0 -> \ (u1 :: (Int -> [Char] -> [(u0, [Char])], Int -> u0 -> [Char] -> [Char], [Char] -> [([u0], [Char])], [u0] -> [Char] -> [Char])) -> case u1 of { _ALG_ _TUP_4 (u2 :: Int -> [Char] -> [(u0, [Char])]) (u3 :: Int -> u0 -> [Char] -> [Char]) (u4 :: [Char] -> [([u0], [Char])]) (u5 :: [u0] -> [Char] -> [Char]) -> u3; _NO_DEFLT_ } _N_
- {-defm-} _A_ 4 _U_ 0222 _N_ _S_ _!_ _F_ _IF_ARGS_ 1 4 XXXX 5 _/\_ u0 -> \ (u1 :: {{Text u0}}) (u2 :: Int) (u3 :: u0) (u4 :: [Char]) -> _APP_ _TYAPP_ patError# { (Int -> u0 -> [Char] -> [Char]) } [ _NOREP_S_ "%DPreludeCore.Text.showsPrec\"", u2, u3, u4 ] _N_ #-}
+ {-defm-} _A_ 4 _U_ 0222 _N_ _S_ _!_ _N_ _N_ #-}
readList :: [Char] -> [([a], [Char])]
{-# GHC_PRAGMA {-meth-} _A_ 1 _U_ 12 _N_ _S_ "U(AASA)" {_A_ 1 _U_ 12 _N_ _N_ _F_ _IF_ARGS_ 1 1 X 1 _/\_ u0 -> \ (u1 :: [Char] -> [([u0], [Char])]) -> u1 _N_} _F_ _IF_ARGS_ 1 1 C 2 _/\_ u0 -> \ (u1 :: (Int -> [Char] -> [(u0, [Char])], Int -> u0 -> [Char] -> [Char], [Char] -> [([u0], [Char])], [u0] -> [Char] -> [Char])) -> case u1 of { _ALG_ _TUP_4 (u2 :: Int -> [Char] -> [(u0, [Char])]) (u3 :: Int -> u0 -> [Char] -> [Char]) (u4 :: [Char] -> [([u0], [Char])]) (u5 :: [u0] -> [Char] -> [Char]) -> u4; _NO_DEFLT_ } _N_
- {-defm-} _A_ 1 _U_ 22 _N_ _N_ _F_ _IF_ARGS_ 0 0 X 1 _ORIG_ PreludeCore _readList _N_ #-}
+ {-defm-} _A_ 1 _U_ 12 _N_ _N_ _N_ _N_ #-}
showList :: [a] -> [Char] -> [Char]
{-# GHC_PRAGMA {-meth-} _A_ 1 _U_ 122 _N_ _S_ "U(AAAS)" {_A_ 1 _U_ 122 _N_ _N_ _F_ _IF_ARGS_ 1 1 X 1 _/\_ u0 -> \ (u1 :: [u0] -> [Char] -> [Char]) -> u1 _N_} _F_ _IF_ARGS_ 1 1 C 2 _/\_ u0 -> \ (u1 :: (Int -> [Char] -> [(u0, [Char])], Int -> u0 -> [Char] -> [Char], [Char] -> [([u0], [Char])], [u0] -> [Char] -> [Char])) -> case u1 of { _ALG_ _TUP_4 (u2 :: Int -> [Char] -> [(u0, [Char])]) (u3 :: Int -> u0 -> [Char] -> [Char]) (u4 :: [Char] -> [([u0], [Char])]) (u5 :: [u0] -> [Char] -> [Char]) -> u5; _NO_DEFLT_ } _N_
- {-defm-} _A_ 1 _U_ 212 _N_ _N_ _F_ _IF_ARGS_ 0 0 X 1 _ORIG_ PreludeCore _showList _N_ #-}
+ {-defm-} _A_ 1 _U_ 112 _N_ _N_ _N_ _N_ #-}
class _CCallable a
class _CReturnable a
data Bin
-{-# GHC_PRAGMA INTERFACE VERSION 5 #-}
+{-# GHC_PRAGMA INTERFACE VERSION 6 #-}
interface PreludeCore where
import PreludeBuiltin(Bin, Char(..), Int(..), Integer(..), List(..), Tuple2, _CMP_TAG(..))
import PreludeRatio(Ratio(..))
class Binary a where
readBin :: Bin -> (a, Bin)
{-# GHC_PRAGMA {-meth-} _A_ 1 _U_ 12 _N_ _S_ "U(SA)" {_A_ 1 _U_ 12 _N_ _N_ _F_ _IF_ARGS_ 1 1 X 1 _/\_ u0 -> \ (u1 :: Bin -> (u0, Bin)) -> u1 _N_} _F_ _IF_ARGS_ 1 1 C 2 _/\_ u0 -> \ (u1 :: (Bin -> (u0, Bin), u0 -> Bin -> Bin)) -> case u1 of { _ALG_ _TUP_2 (u2 :: Bin -> (u0, Bin)) (u3 :: u0 -> Bin -> Bin) -> u2; _NO_DEFLT_ } _N_
- {-defm-} _A_ 2 _U_ 02 _N_ _S_ _!_ _F_ _IF_ARGS_ 1 2 XX 3 _/\_ u0 -> \ (u1 :: {{Binary u0}}) (u2 :: Bin) -> _APP_ _TYAPP_ patError# { (Bin -> (u0, Bin)) } [ _NOREP_S_ "%DPreludeCore.Binary.readBin\"", u2 ] _N_ #-}
+ {-defm-} _A_ 2 _U_ 02 _N_ _S_ _!_ _N_ _N_ #-}
showBin :: a -> Bin -> Bin
{-# GHC_PRAGMA {-meth-} _A_ 1 _U_ 122 _N_ _S_ "U(AS)" {_A_ 1 _U_ 122 _N_ _N_ _F_ _IF_ARGS_ 1 1 X 1 _/\_ u0 -> \ (u1 :: u0 -> Bin -> Bin) -> u1 _N_} _F_ _IF_ARGS_ 1 1 C 2 _/\_ u0 -> \ (u1 :: (Bin -> (u0, Bin), u0 -> Bin -> Bin)) -> case u1 of { _ALG_ _TUP_2 (u2 :: Bin -> (u0, Bin)) (u3 :: u0 -> Bin -> Bin) -> u3; _NO_DEFLT_ } _N_
- {-defm-} _A_ 3 _U_ 022 _N_ _S_ _!_ _F_ _IF_ARGS_ 1 3 XXX 4 _/\_ u0 -> \ (u1 :: {{Binary u0}}) (u2 :: u0) (u3 :: Bin) -> _APP_ _TYAPP_ patError# { (u0 -> Bin -> Bin) } [ _NOREP_S_ "%DPreludeCore.Binary.showBin\"", u2, u3 ] _N_ #-}
+ {-defm-} _A_ 3 _U_ 022 _N_ _S_ _!_ _N_ _N_ #-}
class (Ord a) => Enum a {-# GHC_PRAGMA {-superdicts-} _A_ 1 _U_ 1 _N_ _S_ "U(U(LLLLLLLL)AAAA)" {_A_ 1 _U_ 1 _N_ _N_ _F_ _IF_ARGS_ 1 1 X 1 _/\_ u0 -> \ (u1 :: {{Ord u0}}) -> u1 _N_} _F_ _IF_ARGS_ 1 1 C 2 _/\_ u0 -> \ (u1 :: ({{Ord u0}}, u0 -> [u0], u0 -> u0 -> [u0], u0 -> u0 -> [u0], u0 -> u0 -> u0 -> [u0])) -> case u1 of { _ALG_ _TUP_5 (u2 :: {{Ord u0}}) (u3 :: u0 -> [u0]) (u4 :: u0 -> u0 -> [u0]) (u5 :: u0 -> u0 -> [u0]) (u6 :: u0 -> u0 -> u0 -> [u0]) -> u2; _NO_DEFLT_ } _N_ #-} where
enumFrom :: a -> [a]
{-# GHC_PRAGMA {-meth-} _A_ 1 _U_ 12 _N_ _S_ "U(ASAAA)" {_A_ 1 _U_ 12 _N_ _N_ _F_ _IF_ARGS_ 1 1 X 1 _/\_ u0 -> \ (u1 :: u0 -> [u0]) -> u1 _N_} _F_ _IF_ARGS_ 1 1 C 2 _/\_ u0 -> \ (u1 :: ({{Ord u0}}, u0 -> [u0], u0 -> u0 -> [u0], u0 -> u0 -> [u0], u0 -> u0 -> u0 -> [u0])) -> case u1 of { _ALG_ _TUP_5 (u2 :: {{Ord u0}}) (u3 :: u0 -> [u0]) (u4 :: u0 -> u0 -> [u0]) (u5 :: u0 -> u0 -> [u0]) (u6 :: u0 -> u0 -> u0 -> [u0]) -> u3; _NO_DEFLT_ } _N_
- {-defm-} _A_ 2 _U_ 02 _N_ _S_ _!_ _F_ _IF_ARGS_ 1 2 XX 3 _/\_ u0 -> \ (u1 :: {{Enum u0}}) (u2 :: u0) -> _APP_ _TYAPP_ patError# { (u0 -> [u0]) } [ _NOREP_S_ "%DPreludeCore.Enum.enumFrom\"", u2 ] _N_ #-}
+ {-defm-} _A_ 2 _U_ 02 _N_ _S_ _!_ _N_ _N_ #-}
enumFromThen :: a -> a -> [a]
{-# GHC_PRAGMA {-meth-} _A_ 1 _U_ 122 _N_ _S_ "U(AASAA)" {_A_ 1 _U_ 122 _N_ _N_ _F_ _IF_ARGS_ 1 1 X 1 _/\_ u0 -> \ (u1 :: u0 -> u0 -> [u0]) -> u1 _N_} _F_ _IF_ARGS_ 1 1 C 2 _/\_ u0 -> \ (u1 :: ({{Ord u0}}, u0 -> [u0], u0 -> u0 -> [u0], u0 -> u0 -> [u0], u0 -> u0 -> u0 -> [u0])) -> case u1 of { _ALG_ _TUP_5 (u2 :: {{Ord u0}}) (u3 :: u0 -> [u0]) (u4 :: u0 -> u0 -> [u0]) (u5 :: u0 -> u0 -> [u0]) (u6 :: u0 -> u0 -> u0 -> [u0]) -> u4; _NO_DEFLT_ } _N_
- {-defm-} _A_ 3 _U_ 022 _N_ _S_ _!_ _F_ _IF_ARGS_ 1 3 XXX 4 _/\_ u0 -> \ (u1 :: {{Enum u0}}) (u2 :: u0) (u3 :: u0) -> _APP_ _TYAPP_ patError# { (u0 -> u0 -> [u0]) } [ _NOREP_S_ "%DPreludeCore.Enum.enumFromThen\"", u2, u3 ] _N_ #-}
+ {-defm-} _A_ 3 _U_ 022 _N_ _S_ _!_ _N_ _N_ #-}
enumFromTo :: a -> a -> [a]
{-# GHC_PRAGMA {-meth-} _A_ 1 _U_ 122 _N_ _S_ "U(AAASA)" {_A_ 1 _U_ 122 _N_ _N_ _F_ _IF_ARGS_ 1 1 X 1 _/\_ u0 -> \ (u1 :: u0 -> u0 -> [u0]) -> u1 _N_} _F_ _IF_ARGS_ 1 1 C 2 _/\_ u0 -> \ (u1 :: ({{Ord u0}}, u0 -> [u0], u0 -> u0 -> [u0], u0 -> u0 -> [u0], u0 -> u0 -> u0 -> [u0])) -> case u1 of { _ALG_ _TUP_5 (u2 :: {{Ord u0}}) (u3 :: u0 -> [u0]) (u4 :: u0 -> u0 -> [u0]) (u5 :: u0 -> u0 -> [u0]) (u6 :: u0 -> u0 -> u0 -> [u0]) -> u5; _NO_DEFLT_ } _N_
{-defm-} _A_ 3 _U_ 122 _N_ _S_ "U(LSAAA)LL" {_A_ 4 _U_ 1122 _N_ _N_ _N_ _N_} _N_ _N_ #-}
class Eq a where
(==) :: a -> a -> Bool
{-# GHC_PRAGMA {-meth-} _A_ 1 _U_ 122 _N_ _S_ "U(SA)" {_A_ 1 _U_ 122 _N_ _N_ _F_ _IF_ARGS_ 1 1 X 1 _/\_ u0 -> \ (u1 :: u0 -> u0 -> Bool) -> u1 _N_} _F_ _IF_ARGS_ 1 1 C 2 _/\_ u0 -> \ (u1 :: (u0 -> u0 -> Bool, u0 -> u0 -> Bool)) -> case u1 of { _ALG_ _TUP_2 (u2 :: u0 -> u0 -> Bool) (u3 :: u0 -> u0 -> Bool) -> u2; _NO_DEFLT_ } _N_
- {-defm-} _A_ 3 _U_ 022 _N_ _S_ _!_ _F_ _IF_ARGS_ 1 3 XXX 4 _/\_ u0 -> \ (u1 :: {{Eq u0}}) (u2 :: u0) (u3 :: u0) -> _APP_ _TYAPP_ patError# { (u0 -> u0 -> Bool) } [ _NOREP_S_ "%DPreludeCore.Eq.(==)\"", u2, u3 ] _N_ #-}
+ {-defm-} _A_ 3 _U_ 022 _N_ _S_ _!_ _N_ _N_ #-}
(/=) :: a -> a -> Bool
{-# GHC_PRAGMA {-meth-} _A_ 1 _U_ 122 _N_ _S_ "U(AS)" {_A_ 1 _U_ 122 _N_ _N_ _F_ _IF_ARGS_ 1 1 X 1 _/\_ u0 -> \ (u1 :: u0 -> u0 -> Bool) -> u1 _N_} _F_ _IF_ARGS_ 1 1 C 2 _/\_ u0 -> \ (u1 :: (u0 -> u0 -> Bool, u0 -> u0 -> Bool)) -> case u1 of { _ALG_ _TUP_2 (u2 :: u0 -> u0 -> Bool) (u3 :: u0 -> u0 -> Bool) -> u3; _NO_DEFLT_ } _N_
{-defm-} _A_ 3 _U_ 122 _N_ _S_ "U(SA)LL" {_A_ 3 _U_ 122 _N_ _N_ _N_ _N_} _N_ _N_ #-}
class (Fractional a) => Floating a {-# GHC_PRAGMA {-superdicts-} _A_ 1 _U_ 1 _N_ _S_ "U(U(LLLL)AAAAAAAAAAAAAAAAAA)" {_A_ 4 _U_ 2222 _N_ _N_ _F_ _IF_ARGS_ 1 4 XXXX 5 _/\_ u0 -> \ (u1 :: {{Num u0}}) (u2 :: u0 -> u0 -> u0) (u3 :: u0 -> u0) (u4 :: Ratio Integer -> u0) -> _!_ _TUP_4 [{{Num u0}}, (u0 -> u0 -> u0), (u0 -> u0), (Ratio Integer -> u0)] [u1, u2, u3, u4] _N_} _F_ _IF_ARGS_ 1 1 C 2 _/\_ u0 -> \ (u1 :: ({{Fractional u0}}, u0, u0 -> u0, u0 -> u0, u0 -> u0, u0 -> u0 -> u0, u0 -> u0 -> u0, u0 -> u0, u0 -> u0, u0 -> u0, u0 -> u0, u0 -> u0, u0 -> u0, u0 -> u0, u0 -> u0, u0 -> u0, u0 -> u0, u0 -> u0, u0 -> u0)) -> case u1 of { _ALG_ _TUP_19 (u2 :: {{Fractional u0}}) (u3 :: u0) (u4 :: u0 -> u0) (u5 :: u0 -> u0) (u6 :: u0 -> u0) (u7 :: u0 -> u0 -> u0) (u8 :: u0 -> u0 -> u0) (u9 :: u0 -> u0) (ua :: u0 -> u0) (ub :: u0 -> u0) (uc :: u0 -> u0) (ud :: u0 -> u0) (ue :: u0 -> u0) (uf :: u0 -> u0) (ug :: u0 -> u0) (uh :: u0 -> u0) (ui :: u0 -> u0) (uj :: u0 -> u0) (uk :: u0 -> u0) -> u2; _NO_DEFLT_ } _N_ #-} where
pi :: a
{-# GHC_PRAGMA {-meth-} _A_ 1 _U_ 1 _N_ _S_ "U(ASAAAAAAAAAAAAAAAAA)" {_A_ 1 _U_ 1 _N_ _N_ _F_ _IF_ARGS_ 1 1 X 1 _/\_ u0 -> \ (u1 :: u0) -> u1 _N_} _F_ _IF_ARGS_ 1 1 C 2 _/\_ u0 -> \ (u1 :: ({{Fractional u0}}, u0, u0 -> u0, u0 -> u0, u0 -> u0, u0 -> u0 -> u0, u0 -> u0 -> u0, u0 -> u0, u0 -> u0, u0 -> u0, u0 -> u0, u0 -> u0, u0 -> u0, u0 -> u0, u0 -> u0, u0 -> u0, u0 -> u0, u0 -> u0, u0 -> u0)) -> case u1 of { _ALG_ _TUP_19 (u2 :: {{Fractional u0}}) (u3 :: u0) (u4 :: u0 -> u0) (u5 :: u0 -> u0) (u6 :: u0 -> u0) (u7 :: u0 -> u0 -> u0) (u8 :: u0 -> u0 -> u0) (u9 :: u0 -> u0) (ua :: u0 -> u0) (ub :: u0 -> u0) (uc :: u0 -> u0) (ud :: u0 -> u0) (ue :: u0 -> u0) (uf :: u0 -> u0) (ug :: u0 -> u0) (uh :: u0 -> u0) (ui :: u0 -> u0) (uj :: u0 -> u0) (uk :: u0 -> u0) -> u3; _NO_DEFLT_ } _N_
- {-defm-} _A_ 1 _U_ 0 _N_ _S_ _!_ _F_ _IF_ARGS_ 1 1 X 2 _/\_ u0 -> \ (u1 :: {{Floating u0}}) -> _APP_ _TYAPP_ patError# { u0 } [ _NOREP_S_ "%DPreludeCore.Floating.pi\"" ] _N_ #-}
+ {-defm-} _A_ 1 _U_ 0 _N_ _S_ _!_ _N_ _N_ #-}
exp :: a -> a
{-# GHC_PRAGMA {-meth-} _A_ 1 _U_ 12 _N_ _S_ "U(AASAAAAAAAAAAAAAAAA)" {_A_ 1 _U_ 12 _N_ _N_ _F_ _IF_ARGS_ 1 1 X 1 _/\_ u0 -> \ (u1 :: u0 -> u0) -> u1 _N_} _F_ _IF_ARGS_ 1 1 C 2 _/\_ u0 -> \ (u1 :: ({{Fractional u0}}, u0, u0 -> u0, u0 -> u0, u0 -> u0, u0 -> u0 -> u0, u0 -> u0 -> u0, u0 -> u0, u0 -> u0, u0 -> u0, u0 -> u0, u0 -> u0, u0 -> u0, u0 -> u0, u0 -> u0, u0 -> u0, u0 -> u0, u0 -> u0, u0 -> u0)) -> case u1 of { _ALG_ _TUP_19 (u2 :: {{Fractional u0}}) (u3 :: u0) (u4 :: u0 -> u0) (u5 :: u0 -> u0) (u6 :: u0 -> u0) (u7 :: u0 -> u0 -> u0) (u8 :: u0 -> u0 -> u0) (u9 :: u0 -> u0) (ua :: u0 -> u0) (ub :: u0 -> u0) (uc :: u0 -> u0) (ud :: u0 -> u0) (ue :: u0 -> u0) (uf :: u0 -> u0) (ug :: u0 -> u0) (uh :: u0 -> u0) (ui :: u0 -> u0) (uj :: u0 -> u0) (uk :: u0 -> u0) -> u4; _NO_DEFLT_ } _N_
- {-defm-} _A_ 2 _U_ 02 _N_ _S_ _!_ _F_ _IF_ARGS_ 1 2 XX 3 _/\_ u0 -> \ (u1 :: {{Floating u0}}) (u2 :: u0) -> _APP_ _TYAPP_ patError# { (u0 -> u0) } [ _NOREP_S_ "%DPreludeCore.Floating.exp\"", u2 ] _N_ #-}
+ {-defm-} _A_ 2 _U_ 02 _N_ _S_ _!_ _N_ _N_ #-}
log :: a -> a
{-# GHC_PRAGMA {-meth-} _A_ 1 _U_ 12 _N_ _S_ "U(AAASAAAAAAAAAAAAAAA)" {_A_ 1 _U_ 12 _N_ _N_ _F_ _IF_ARGS_ 1 1 X 1 _/\_ u0 -> \ (u1 :: u0 -> u0) -> u1 _N_} _F_ _IF_ARGS_ 1 1 C 2 _/\_ u0 -> \ (u1 :: ({{Fractional u0}}, u0, u0 -> u0, u0 -> u0, u0 -> u0, u0 -> u0 -> u0, u0 -> u0 -> u0, u0 -> u0, u0 -> u0, u0 -> u0, u0 -> u0, u0 -> u0, u0 -> u0, u0 -> u0, u0 -> u0, u0 -> u0, u0 -> u0, u0 -> u0, u0 -> u0)) -> case u1 of { _ALG_ _TUP_19 (u2 :: {{Fractional u0}}) (u3 :: u0) (u4 :: u0 -> u0) (u5 :: u0 -> u0) (u6 :: u0 -> u0) (u7 :: u0 -> u0 -> u0) (u8 :: u0 -> u0 -> u0) (u9 :: u0 -> u0) (ua :: u0 -> u0) (ub :: u0 -> u0) (uc :: u0 -> u0) (ud :: u0 -> u0) (ue :: u0 -> u0) (uf :: u0 -> u0) (ug :: u0 -> u0) (uh :: u0 -> u0) (ui :: u0 -> u0) (uj :: u0 -> u0) (uk :: u0 -> u0) -> u5; _NO_DEFLT_ } _N_
- {-defm-} _A_ 2 _U_ 02 _N_ _S_ _!_ _F_ _IF_ARGS_ 1 2 XX 3 _/\_ u0 -> \ (u1 :: {{Floating u0}}) (u2 :: u0) -> _APP_ _TYAPP_ patError# { (u0 -> u0) } [ _NOREP_S_ "%DPreludeCore.Floating.log\"", u2 ] _N_ #-}
+ {-defm-} _A_ 2 _U_ 02 _N_ _S_ _!_ _N_ _N_ #-}
sqrt :: a -> a
{-# GHC_PRAGMA {-meth-} _A_ 1 _U_ 12 _N_ _S_ "U(AAAASAAAAAAAAAAAAAA)" {_A_ 1 _U_ 12 _N_ _N_ _F_ _IF_ARGS_ 1 1 X 1 _/\_ u0 -> \ (u1 :: u0 -> u0) -> u1 _N_} _F_ _IF_ARGS_ 1 1 C 2 _/\_ u0 -> \ (u1 :: ({{Fractional u0}}, u0, u0 -> u0, u0 -> u0, u0 -> u0, u0 -> u0 -> u0, u0 -> u0 -> u0, u0 -> u0, u0 -> u0, u0 -> u0, u0 -> u0, u0 -> u0, u0 -> u0, u0 -> u0, u0 -> u0, u0 -> u0, u0 -> u0, u0 -> u0, u0 -> u0)) -> case u1 of { _ALG_ _TUP_19 (u2 :: {{Fractional u0}}) (u3 :: u0) (u4 :: u0 -> u0) (u5 :: u0 -> u0) (u6 :: u0 -> u0) (u7 :: u0 -> u0 -> u0) (u8 :: u0 -> u0 -> u0) (u9 :: u0 -> u0) (ua :: u0 -> u0) (ub :: u0 -> u0) (uc :: u0 -> u0) (ud :: u0 -> u0) (ue :: u0 -> u0) (uf :: u0 -> u0) (ug :: u0 -> u0) (uh :: u0 -> u0) (ui :: u0 -> u0) (uj :: u0 -> u0) (uk :: u0 -> u0) -> u6; _NO_DEFLT_ } _N_
{-defm-} _A_ 1 _U_ 12 _N_ _S_ "U(LAAAASAAAAAAAAAAAAA)" {_A_ 2 _U_ 112 _N_ _N_ _N_ _N_} _N_ _N_ #-}
{-defm-} _A_ 3 _U_ 122 _N_ _S_ "U(U(ASAA)AALAAAAAAAAAAAAAAA)LL" {_A_ 4 _U_ 1222 _N_ _N_ _N_ _N_} _N_ _N_ #-}
sin :: a -> a
{-# GHC_PRAGMA {-meth-} _A_ 1 _U_ 12 _N_ _S_ "U(AAAAAAASAAAAAAAAAAA)" {_A_ 1 _U_ 12 _N_ _N_ _F_ _IF_ARGS_ 1 1 X 1 _/\_ u0 -> \ (u1 :: u0 -> u0) -> u1 _N_} _F_ _IF_ARGS_ 1 1 C 2 _/\_ u0 -> \ (u1 :: ({{Fractional u0}}, u0, u0 -> u0, u0 -> u0, u0 -> u0, u0 -> u0 -> u0, u0 -> u0 -> u0, u0 -> u0, u0 -> u0, u0 -> u0, u0 -> u0, u0 -> u0, u0 -> u0, u0 -> u0, u0 -> u0, u0 -> u0, u0 -> u0, u0 -> u0, u0 -> u0)) -> case u1 of { _ALG_ _TUP_19 (u2 :: {{Fractional u0}}) (u3 :: u0) (u4 :: u0 -> u0) (u5 :: u0 -> u0) (u6 :: u0 -> u0) (u7 :: u0 -> u0 -> u0) (u8 :: u0 -> u0 -> u0) (u9 :: u0 -> u0) (ua :: u0 -> u0) (ub :: u0 -> u0) (uc :: u0 -> u0) (ud :: u0 -> u0) (ue :: u0 -> u0) (uf :: u0 -> u0) (ug :: u0 -> u0) (uh :: u0 -> u0) (ui :: u0 -> u0) (uj :: u0 -> u0) (uk :: u0 -> u0) -> u9; _NO_DEFLT_ } _N_
- {-defm-} _A_ 2 _U_ 02 _N_ _S_ _!_ _F_ _IF_ARGS_ 1 2 XX 3 _/\_ u0 -> \ (u1 :: {{Floating u0}}) (u2 :: u0) -> _APP_ _TYAPP_ patError# { (u0 -> u0) } [ _NOREP_S_ "%DPreludeCore.Floating.sin\"", u2 ] _N_ #-}
+ {-defm-} _A_ 2 _U_ 02 _N_ _S_ _!_ _N_ _N_ #-}
cos :: a -> a
{-# GHC_PRAGMA {-meth-} _A_ 1 _U_ 12 _N_ _S_ "U(AAAAAAAASAAAAAAAAAA)" {_A_ 1 _U_ 12 _N_ _N_ _F_ _IF_ARGS_ 1 1 X 1 _/\_ u0 -> \ (u1 :: u0 -> u0) -> u1 _N_} _F_ _IF_ARGS_ 1 1 C 2 _/\_ u0 -> \ (u1 :: ({{Fractional u0}}, u0, u0 -> u0, u0 -> u0, u0 -> u0, u0 -> u0 -> u0, u0 -> u0 -> u0, u0 -> u0, u0 -> u0, u0 -> u0, u0 -> u0, u0 -> u0, u0 -> u0, u0 -> u0, u0 -> u0, u0 -> u0, u0 -> u0, u0 -> u0, u0 -> u0)) -> case u1 of { _ALG_ _TUP_19 (u2 :: {{Fractional u0}}) (u3 :: u0) (u4 :: u0 -> u0) (u5 :: u0 -> u0) (u6 :: u0 -> u0) (u7 :: u0 -> u0 -> u0) (u8 :: u0 -> u0 -> u0) (u9 :: u0 -> u0) (ua :: u0 -> u0) (ub :: u0 -> u0) (uc :: u0 -> u0) (ud :: u0 -> u0) (ue :: u0 -> u0) (uf :: u0 -> u0) (ug :: u0 -> u0) (uh :: u0 -> u0) (ui :: u0 -> u0) (uj :: u0 -> u0) (uk :: u0 -> u0) -> ua; _NO_DEFLT_ } _N_
- {-defm-} _A_ 2 _U_ 02 _N_ _S_ _!_ _F_ _IF_ARGS_ 1 2 XX 3 _/\_ u0 -> \ (u1 :: {{Floating u0}}) (u2 :: u0) -> _APP_ _TYAPP_ patError# { (u0 -> u0) } [ _NOREP_S_ "%DPreludeCore.Floating.cos\"", u2 ] _N_ #-}
+ {-defm-} _A_ 2 _U_ 02 _N_ _S_ _!_ _N_ _N_ #-}
tan :: a -> a
{-# GHC_PRAGMA {-meth-} _A_ 1 _U_ 12 _N_ _S_ "U(AAAAAAAAASAAAAAAAAA)" {_A_ 1 _U_ 12 _N_ _N_ _F_ _IF_ARGS_ 1 1 X 1 _/\_ u0 -> \ (u1 :: u0 -> u0) -> u1 _N_} _F_ _IF_ARGS_ 1 1 C 2 _/\_ u0 -> \ (u1 :: ({{Fractional u0}}, u0, u0 -> u0, u0 -> u0, u0 -> u0, u0 -> u0 -> u0, u0 -> u0 -> u0, u0 -> u0, u0 -> u0, u0 -> u0, u0 -> u0, u0 -> u0, u0 -> u0, u0 -> u0, u0 -> u0, u0 -> u0, u0 -> u0, u0 -> u0, u0 -> u0)) -> case u1 of { _ALG_ _TUP_19 (u2 :: {{Fractional u0}}) (u3 :: u0) (u4 :: u0 -> u0) (u5 :: u0 -> u0) (u6 :: u0 -> u0) (u7 :: u0 -> u0 -> u0) (u8 :: u0 -> u0 -> u0) (u9 :: u0 -> u0) (ua :: u0 -> u0) (ub :: u0 -> u0) (uc :: u0 -> u0) (ud :: u0 -> u0) (ue :: u0 -> u0) (uf :: u0 -> u0) (ug :: u0 -> u0) (uh :: u0 -> u0) (ui :: u0 -> u0) (uj :: u0 -> u0) (uk :: u0 -> u0) -> ub; _NO_DEFLT_ } _N_
{-defm-} _A_ 2 _U_ 12 _N_ _S_ "U(U(ASAA)AAAAAALLAAAAAAAAAA)L" {_A_ 4 _U_ 1112 _N_ _N_ _N_ _N_} _N_ _N_ #-}
asin :: a -> a
{-# GHC_PRAGMA {-meth-} _A_ 1 _U_ 12 _N_ _S_ "U(AAAAAAAAAASAAAAAAAA)" {_A_ 1 _U_ 12 _N_ _N_ _F_ _IF_ARGS_ 1 1 X 1 _/\_ u0 -> \ (u1 :: u0 -> u0) -> u1 _N_} _F_ _IF_ARGS_ 1 1 C 2 _/\_ u0 -> \ (u1 :: ({{Fractional u0}}, u0, u0 -> u0, u0 -> u0, u0 -> u0, u0 -> u0 -> u0, u0 -> u0 -> u0, u0 -> u0, u0 -> u0, u0 -> u0, u0 -> u0, u0 -> u0, u0 -> u0, u0 -> u0, u0 -> u0, u0 -> u0, u0 -> u0, u0 -> u0, u0 -> u0)) -> case u1 of { _ALG_ _TUP_19 (u2 :: {{Fractional u0}}) (u3 :: u0) (u4 :: u0 -> u0) (u5 :: u0 -> u0) (u6 :: u0 -> u0) (u7 :: u0 -> u0 -> u0) (u8 :: u0 -> u0 -> u0) (u9 :: u0 -> u0) (ua :: u0 -> u0) (ub :: u0 -> u0) (uc :: u0 -> u0) (ud :: u0 -> u0) (ue :: u0 -> u0) (uf :: u0 -> u0) (ug :: u0 -> u0) (uh :: u0 -> u0) (ui :: u0 -> u0) (uj :: u0 -> u0) (uk :: u0 -> u0) -> uc; _NO_DEFLT_ } _N_
- {-defm-} _A_ 2 _U_ 02 _N_ _S_ _!_ _F_ _IF_ARGS_ 1 2 XX 3 _/\_ u0 -> \ (u1 :: {{Floating u0}}) (u2 :: u0) -> _APP_ _TYAPP_ patError# { (u0 -> u0) } [ _NOREP_S_ "%DPreludeCore.Floating.asin\"", u2 ] _N_ #-}
+ {-defm-} _A_ 2 _U_ 02 _N_ _S_ _!_ _N_ _N_ #-}
acos :: a -> a
{-# GHC_PRAGMA {-meth-} _A_ 1 _U_ 12 _N_ _S_ "U(AAAAAAAAAAASAAAAAAA)" {_A_ 1 _U_ 12 _N_ _N_ _F_ _IF_ARGS_ 1 1 X 1 _/\_ u0 -> \ (u1 :: u0 -> u0) -> u1 _N_} _F_ _IF_ARGS_ 1 1 C 2 _/\_ u0 -> \ (u1 :: ({{Fractional u0}}, u0, u0 -> u0, u0 -> u0, u0 -> u0, u0 -> u0 -> u0, u0 -> u0 -> u0, u0 -> u0, u0 -> u0, u0 -> u0, u0 -> u0, u0 -> u0, u0 -> u0, u0 -> u0, u0 -> u0, u0 -> u0, u0 -> u0, u0 -> u0, u0 -> u0)) -> case u1 of { _ALG_ _TUP_19 (u2 :: {{Fractional u0}}) (u3 :: u0) (u4 :: u0 -> u0) (u5 :: u0 -> u0) (u6 :: u0 -> u0) (u7 :: u0 -> u0 -> u0) (u8 :: u0 -> u0 -> u0) (u9 :: u0 -> u0) (ua :: u0 -> u0) (ub :: u0 -> u0) (uc :: u0 -> u0) (ud :: u0 -> u0) (ue :: u0 -> u0) (uf :: u0 -> u0) (ug :: u0 -> u0) (uh :: u0 -> u0) (ui :: u0 -> u0) (uj :: u0 -> u0) (uk :: u0 -> u0) -> ud; _NO_DEFLT_ } _N_
- {-defm-} _A_ 2 _U_ 02 _N_ _S_ _!_ _F_ _IF_ARGS_ 1 2 XX 3 _/\_ u0 -> \ (u1 :: {{Floating u0}}) (u2 :: u0) -> _APP_ _TYAPP_ patError# { (u0 -> u0) } [ _NOREP_S_ "%DPreludeCore.Floating.acos\"", u2 ] _N_ #-}
+ {-defm-} _A_ 2 _U_ 02 _N_ _S_ _!_ _N_ _N_ #-}
atan :: a -> a
{-# GHC_PRAGMA {-meth-} _A_ 1 _U_ 12 _N_ _S_ "U(AAAAAAAAAAAASAAAAAA)" {_A_ 1 _U_ 12 _N_ _N_ _F_ _IF_ARGS_ 1 1 X 1 _/\_ u0 -> \ (u1 :: u0 -> u0) -> u1 _N_} _F_ _IF_ARGS_ 1 1 C 2 _/\_ u0 -> \ (u1 :: ({{Fractional u0}}, u0, u0 -> u0, u0 -> u0, u0 -> u0, u0 -> u0 -> u0, u0 -> u0 -> u0, u0 -> u0, u0 -> u0, u0 -> u0, u0 -> u0, u0 -> u0, u0 -> u0, u0 -> u0, u0 -> u0, u0 -> u0, u0 -> u0, u0 -> u0, u0 -> u0)) -> case u1 of { _ALG_ _TUP_19 (u2 :: {{Fractional u0}}) (u3 :: u0) (u4 :: u0 -> u0) (u5 :: u0 -> u0) (u6 :: u0 -> u0) (u7 :: u0 -> u0 -> u0) (u8 :: u0 -> u0 -> u0) (u9 :: u0 -> u0) (ua :: u0 -> u0) (ub :: u0 -> u0) (uc :: u0 -> u0) (ud :: u0 -> u0) (ue :: u0 -> u0) (uf :: u0 -> u0) (ug :: u0 -> u0) (uh :: u0 -> u0) (ui :: u0 -> u0) (uj :: u0 -> u0) (uk :: u0 -> u0) -> ue; _NO_DEFLT_ } _N_
- {-defm-} _A_ 2 _U_ 02 _N_ _S_ _!_ _F_ _IF_ARGS_ 1 2 XX 3 _/\_ u0 -> \ (u1 :: {{Floating u0}}) (u2 :: u0) -> _APP_ _TYAPP_ patError# { (u0 -> u0) } [ _NOREP_S_ "%DPreludeCore.Floating.atan\"", u2 ] _N_ #-}
+ {-defm-} _A_ 2 _U_ 02 _N_ _S_ _!_ _N_ _N_ #-}
sinh :: a -> a
{-# GHC_PRAGMA {-meth-} _A_ 1 _U_ 12 _N_ _S_ "U(AAAAAAAAAAAAASAAAAA)" {_A_ 1 _U_ 12 _N_ _N_ _F_ _IF_ARGS_ 1 1 X 1 _/\_ u0 -> \ (u1 :: u0 -> u0) -> u1 _N_} _F_ _IF_ARGS_ 1 1 C 2 _/\_ u0 -> \ (u1 :: ({{Fractional u0}}, u0, u0 -> u0, u0 -> u0, u0 -> u0, u0 -> u0 -> u0, u0 -> u0 -> u0, u0 -> u0, u0 -> u0, u0 -> u0, u0 -> u0, u0 -> u0, u0 -> u0, u0 -> u0, u0 -> u0, u0 -> u0, u0 -> u0, u0 -> u0, u0 -> u0)) -> case u1 of { _ALG_ _TUP_19 (u2 :: {{Fractional u0}}) (u3 :: u0) (u4 :: u0 -> u0) (u5 :: u0 -> u0) (u6 :: u0 -> u0) (u7 :: u0 -> u0 -> u0) (u8 :: u0 -> u0 -> u0) (u9 :: u0 -> u0) (ua :: u0 -> u0) (ub :: u0 -> u0) (uc :: u0 -> u0) (ud :: u0 -> u0) (ue :: u0 -> u0) (uf :: u0 -> u0) (ug :: u0 -> u0) (uh :: u0 -> u0) (ui :: u0 -> u0) (uj :: u0 -> u0) (uk :: u0 -> u0) -> uf; _NO_DEFLT_ } _N_
- {-defm-} _A_ 2 _U_ 02 _N_ _S_ _!_ _F_ _IF_ARGS_ 1 2 XX 3 _/\_ u0 -> \ (u1 :: {{Floating u0}}) (u2 :: u0) -> _APP_ _TYAPP_ patError# { (u0 -> u0) } [ _NOREP_S_ "%DPreludeCore.Floating.sinh\"", u2 ] _N_ #-}
+ {-defm-} _A_ 2 _U_ 02 _N_ _S_ _!_ _N_ _N_ #-}
cosh :: a -> a
{-# GHC_PRAGMA {-meth-} _A_ 1 _U_ 12 _N_ _S_ "U(AAAAAAAAAAAAAASAAAA)" {_A_ 1 _U_ 12 _N_ _N_ _F_ _IF_ARGS_ 1 1 X 1 _/\_ u0 -> \ (u1 :: u0 -> u0) -> u1 _N_} _F_ _IF_ARGS_ 1 1 C 2 _/\_ u0 -> \ (u1 :: ({{Fractional u0}}, u0, u0 -> u0, u0 -> u0, u0 -> u0, u0 -> u0 -> u0, u0 -> u0 -> u0, u0 -> u0, u0 -> u0, u0 -> u0, u0 -> u0, u0 -> u0, u0 -> u0, u0 -> u0, u0 -> u0, u0 -> u0, u0 -> u0, u0 -> u0, u0 -> u0)) -> case u1 of { _ALG_ _TUP_19 (u2 :: {{Fractional u0}}) (u3 :: u0) (u4 :: u0 -> u0) (u5 :: u0 -> u0) (u6 :: u0 -> u0) (u7 :: u0 -> u0 -> u0) (u8 :: u0 -> u0 -> u0) (u9 :: u0 -> u0) (ua :: u0 -> u0) (ub :: u0 -> u0) (uc :: u0 -> u0) (ud :: u0 -> u0) (ue :: u0 -> u0) (uf :: u0 -> u0) (ug :: u0 -> u0) (uh :: u0 -> u0) (ui :: u0 -> u0) (uj :: u0 -> u0) (uk :: u0 -> u0) -> ug; _NO_DEFLT_ } _N_
- {-defm-} _A_ 2 _U_ 02 _N_ _S_ _!_ _F_ _IF_ARGS_ 1 2 XX 3 _/\_ u0 -> \ (u1 :: {{Floating u0}}) (u2 :: u0) -> _APP_ _TYAPP_ patError# { (u0 -> u0) } [ _NOREP_S_ "%DPreludeCore.Floating.cosh\"", u2 ] _N_ #-}
+ {-defm-} _A_ 2 _U_ 02 _N_ _S_ _!_ _N_ _N_ #-}
tanh :: a -> a
{-# GHC_PRAGMA {-meth-} _A_ 1 _U_ 12 _N_ _S_ "U(AAAAAAAAAAAAAAASAAA)" {_A_ 1 _U_ 12 _N_ _N_ _F_ _IF_ARGS_ 1 1 X 1 _/\_ u0 -> \ (u1 :: u0 -> u0) -> u1 _N_} _F_ _IF_ARGS_ 1 1 C 2 _/\_ u0 -> \ (u1 :: ({{Fractional u0}}, u0, u0 -> u0, u0 -> u0, u0 -> u0, u0 -> u0 -> u0, u0 -> u0 -> u0, u0 -> u0, u0 -> u0, u0 -> u0, u0 -> u0, u0 -> u0, u0 -> u0, u0 -> u0, u0 -> u0, u0 -> u0, u0 -> u0, u0 -> u0, u0 -> u0)) -> case u1 of { _ALG_ _TUP_19 (u2 :: {{Fractional u0}}) (u3 :: u0) (u4 :: u0 -> u0) (u5 :: u0 -> u0) (u6 :: u0 -> u0) (u7 :: u0 -> u0 -> u0) (u8 :: u0 -> u0 -> u0) (u9 :: u0 -> u0) (ua :: u0 -> u0) (ub :: u0 -> u0) (uc :: u0 -> u0) (ud :: u0 -> u0) (ue :: u0 -> u0) (uf :: u0 -> u0) (ug :: u0 -> u0) (uh :: u0 -> u0) (ui :: u0 -> u0) (uj :: u0 -> u0) (uk :: u0 -> u0) -> uh; _NO_DEFLT_ } _N_
{-defm-} _A_ 2 _U_ 12 _N_ _S_ "U(U(ASAA)AAAAAAAAAAAALLAAAA)L" {_A_ 4 _U_ 1112 _N_ _N_ _N_ _N_} _N_ _N_ #-}
asinh :: a -> a
{-# GHC_PRAGMA {-meth-} _A_ 1 _U_ 12 _N_ _S_ "U(AAAAAAAAAAAAAAAASAA)" {_A_ 1 _U_ 12 _N_ _N_ _F_ _IF_ARGS_ 1 1 X 1 _/\_ u0 -> \ (u1 :: u0 -> u0) -> u1 _N_} _F_ _IF_ARGS_ 1 1 C 2 _/\_ u0 -> \ (u1 :: ({{Fractional u0}}, u0, u0 -> u0, u0 -> u0, u0 -> u0, u0 -> u0 -> u0, u0 -> u0 -> u0, u0 -> u0, u0 -> u0, u0 -> u0, u0 -> u0, u0 -> u0, u0 -> u0, u0 -> u0, u0 -> u0, u0 -> u0, u0 -> u0, u0 -> u0, u0 -> u0)) -> case u1 of { _ALG_ _TUP_19 (u2 :: {{Fractional u0}}) (u3 :: u0) (u4 :: u0 -> u0) (u5 :: u0 -> u0) (u6 :: u0 -> u0) (u7 :: u0 -> u0 -> u0) (u8 :: u0 -> u0 -> u0) (u9 :: u0 -> u0) (ua :: u0 -> u0) (ub :: u0 -> u0) (uc :: u0 -> u0) (ud :: u0 -> u0) (ue :: u0 -> u0) (uf :: u0 -> u0) (ug :: u0 -> u0) (uh :: u0 -> u0) (ui :: u0 -> u0) (uj :: u0 -> u0) (uk :: u0 -> u0) -> ui; _NO_DEFLT_ } _N_
- {-defm-} _A_ 2 _U_ 02 _N_ _S_ _!_ _F_ _IF_ARGS_ 1 2 XX 3 _/\_ u0 -> \ (u1 :: {{Floating u0}}) (u2 :: u0) -> _APP_ _TYAPP_ patError# { (u0 -> u0) } [ _NOREP_S_ "%DPreludeCore.Floating.asinh\"", u2 ] _N_ #-}
+ {-defm-} _A_ 2 _U_ 02 _N_ _S_ _!_ _N_ _N_ #-}
acosh :: a -> a
{-# GHC_PRAGMA {-meth-} _A_ 1 _U_ 12 _N_ _S_ "U(AAAAAAAAAAAAAAAAASA)" {_A_ 1 _U_ 12 _N_ _N_ _F_ _IF_ARGS_ 1 1 X 1 _/\_ u0 -> \ (u1 :: u0 -> u0) -> u1 _N_} _F_ _IF_ARGS_ 1 1 C 2 _/\_ u0 -> \ (u1 :: ({{Fractional u0}}, u0, u0 -> u0, u0 -> u0, u0 -> u0, u0 -> u0 -> u0, u0 -> u0 -> u0, u0 -> u0, u0 -> u0, u0 -> u0, u0 -> u0, u0 -> u0, u0 -> u0, u0 -> u0, u0 -> u0, u0 -> u0, u0 -> u0, u0 -> u0, u0 -> u0)) -> case u1 of { _ALG_ _TUP_19 (u2 :: {{Fractional u0}}) (u3 :: u0) (u4 :: u0 -> u0) (u5 :: u0 -> u0) (u6 :: u0 -> u0) (u7 :: u0 -> u0 -> u0) (u8 :: u0 -> u0 -> u0) (u9 :: u0 -> u0) (ua :: u0 -> u0) (ub :: u0 -> u0) (uc :: u0 -> u0) (ud :: u0 -> u0) (ue :: u0 -> u0) (uf :: u0 -> u0) (ug :: u0 -> u0) (uh :: u0 -> u0) (ui :: u0 -> u0) (uj :: u0 -> u0) (uk :: u0 -> u0) -> uj; _NO_DEFLT_ } _N_
- {-defm-} _A_ 2 _U_ 02 _N_ _S_ _!_ _F_ _IF_ARGS_ 1 2 XX 3 _/\_ u0 -> \ (u1 :: {{Floating u0}}) (u2 :: u0) -> _APP_ _TYAPP_ patError# { (u0 -> u0) } [ _NOREP_S_ "%DPreludeCore.Floating.acosh\"", u2 ] _N_ #-}
+ {-defm-} _A_ 2 _U_ 02 _N_ _S_ _!_ _N_ _N_ #-}
atanh :: a -> a
{-# GHC_PRAGMA {-meth-} _A_ 1 _U_ 12 _N_ _S_ "U(AAAAAAAAAAAAAAAAAAS)" {_A_ 1 _U_ 12 _N_ _N_ _F_ _IF_ARGS_ 1 1 X 1 _/\_ u0 -> \ (u1 :: u0 -> u0) -> u1 _N_} _F_ _IF_ARGS_ 1 1 C 2 _/\_ u0 -> \ (u1 :: ({{Fractional u0}}, u0, u0 -> u0, u0 -> u0, u0 -> u0, u0 -> u0 -> u0, u0 -> u0 -> u0, u0 -> u0, u0 -> u0, u0 -> u0, u0 -> u0, u0 -> u0, u0 -> u0, u0 -> u0, u0 -> u0, u0 -> u0, u0 -> u0, u0 -> u0, u0 -> u0)) -> case u1 of { _ALG_ _TUP_19 (u2 :: {{Fractional u0}}) (u3 :: u0) (u4 :: u0 -> u0) (u5 :: u0 -> u0) (u6 :: u0 -> u0) (u7 :: u0 -> u0 -> u0) (u8 :: u0 -> u0 -> u0) (u9 :: u0 -> u0) (ua :: u0 -> u0) (ub :: u0 -> u0) (uc :: u0 -> u0) (ud :: u0 -> u0) (ue :: u0 -> u0) (uf :: u0 -> u0) (ug :: u0 -> u0) (uh :: u0 -> u0) (ui :: u0 -> u0) (uj :: u0 -> u0) (uk :: u0 -> u0) -> uk; _NO_DEFLT_ } _N_
- {-defm-} _A_ 2 _U_ 02 _N_ _S_ _!_ _F_ _IF_ARGS_ 1 2 XX 3 _/\_ u0 -> \ (u1 :: {{Floating u0}}) (u2 :: u0) -> _APP_ _TYAPP_ patError# { (u0 -> u0) } [ _NOREP_S_ "%DPreludeCore.Floating.atanh\"", u2 ] _N_ #-}
+ {-defm-} _A_ 2 _U_ 02 _N_ _S_ _!_ _N_ _N_ #-}
class (Num a) => Fractional a {-# GHC_PRAGMA {-superdicts-} _A_ 1 _U_ 1 _N_ _S_ "U(U(LLLLLLLLLL)AAA)" {_A_ 1 _U_ 1 _N_ _N_ _F_ _IF_ARGS_ 1 1 X 1 _/\_ u0 -> \ (u1 :: {{Num u0}}) -> u1 _N_} _F_ _IF_ARGS_ 1 1 C 2 _/\_ u0 -> \ (u1 :: ({{Num u0}}, u0 -> u0 -> u0, u0 -> u0, Ratio Integer -> u0)) -> case u1 of { _ALG_ _TUP_4 (u2 :: {{Num u0}}) (u3 :: u0 -> u0 -> u0) (u4 :: u0 -> u0) (u5 :: Ratio Integer -> u0) -> u2; _NO_DEFLT_ } _N_ #-} where
(/) :: a -> a -> a
{-# GHC_PRAGMA {-meth-} _A_ 1 _U_ 122 _N_ _S_ "U(ASAA)" {_A_ 1 _U_ 122 _N_ _N_ _F_ _IF_ARGS_ 1 1 X 1 _/\_ u0 -> \ (u1 :: u0 -> u0 -> u0) -> u1 _N_} _F_ _IF_ARGS_ 1 1 C 2 _/\_ u0 -> \ (u1 :: ({{Num u0}}, u0 -> u0 -> u0, u0 -> u0, Ratio Integer -> u0)) -> case u1 of { _ALG_ _TUP_4 (u2 :: {{Num u0}}) (u3 :: u0 -> u0 -> u0) (u4 :: u0 -> u0) (u5 :: Ratio Integer -> u0) -> u3; _NO_DEFLT_ } _N_
- {-defm-} _A_ 3 _U_ 022 _N_ _S_ _!_ _F_ _IF_ARGS_ 1 3 XXX 4 _/\_ u0 -> \ (u1 :: {{Fractional u0}}) (u2 :: u0) (u3 :: u0) -> _APP_ _TYAPP_ patError# { (u0 -> u0 -> u0) } [ _NOREP_S_ "%DPreludeCore.Fractional.(/)\"", u2, u3 ] _N_ #-}
+ {-defm-} _A_ 3 _U_ 022 _N_ _S_ _!_ _N_ _N_ #-}
recip :: a -> a
{-# GHC_PRAGMA {-meth-} _A_ 1 _U_ 12 _N_ _S_ "U(AASA)" {_A_ 1 _U_ 12 _N_ _N_ _F_ _IF_ARGS_ 1 1 X 1 _/\_ u0 -> \ (u1 :: u0 -> u0) -> u1 _N_} _F_ _IF_ARGS_ 1 1 C 2 _/\_ u0 -> \ (u1 :: ({{Num u0}}, u0 -> u0 -> u0, u0 -> u0, Ratio Integer -> u0)) -> case u1 of { _ALG_ _TUP_4 (u2 :: {{Num u0}}) (u3 :: u0 -> u0 -> u0) (u4 :: u0 -> u0) (u5 :: Ratio Integer -> u0) -> u4; _NO_DEFLT_ } _N_
- {-defm-} _A_ 1 _U_ 12 _N_ _S_ "U(ASAL)" {_A_ 2 _U_ 122 _N_ _N_ _N_ _N_} _N_ _N_ #-}
+ {-defm-} _A_ 1 _U_ 12 _N_ _S_ "U(LSAA)" {_A_ 2 _U_ 112 _N_ _N_ _N_ _N_} _N_ _N_ #-}
fromRational :: Ratio Integer -> a
{-# GHC_PRAGMA {-meth-} _A_ 1 _U_ 12 _N_ _S_ "U(AAAS)" {_A_ 1 _U_ 12 _N_ _N_ _F_ _IF_ARGS_ 1 1 X 1 _/\_ u0 -> \ (u1 :: Ratio Integer -> u0) -> u1 _N_} _F_ _IF_ARGS_ 1 1 C 2 _/\_ u0 -> \ (u1 :: ({{Num u0}}, u0 -> u0 -> u0, u0 -> u0, Ratio Integer -> u0)) -> case u1 of { _ALG_ _TUP_4 (u2 :: {{Num u0}}) (u3 :: u0 -> u0 -> u0) (u4 :: u0 -> u0) (u5 :: Ratio Integer -> u0) -> u5; _NO_DEFLT_ } _N_
- {-defm-} _A_ 2 _U_ 02 _N_ _S_ _!_ _F_ _IF_ARGS_ 1 2 XX 3 _/\_ u0 -> \ (u1 :: {{Fractional u0}}) (u2 :: Ratio Integer) -> _APP_ _TYAPP_ patError# { (Ratio Integer -> u0) } [ _NOREP_S_ "%DPreludeCore.Fractional.fromRational\"", u2 ] _N_ #-}
+ {-defm-} _A_ 2 _U_ 02 _N_ _S_ _!_ _N_ _N_ #-}
class (Real a, Ix a) => Integral a {-# GHC_PRAGMA {-superdicts-} _A_ 1 _U_ 1 _N_ _S_ "U(U(LLL)AAAAAAAAAAA)" {_A_ 3 _U_ 222 _N_ _N_ _F_ _IF_ARGS_ 1 3 XXX 4 _/\_ u0 -> \ (u1 :: {{Num u0}}) (u2 :: {{Enum u0}}) (u3 :: u0 -> Ratio Integer) -> _!_ _TUP_3 [{{Num u0}}, {{Enum u0}}, (u0 -> Ratio Integer)] [u1, u2, u3] _N_} _F_ _IF_ARGS_ 1 1 C 2 _/\_ u0 -> \ (u1 :: ({{Real u0}}, {{Ix u0}}, u0 -> u0 -> u0, u0 -> u0 -> u0, u0 -> u0 -> u0, u0 -> u0 -> u0, u0 -> u0 -> (u0, u0), u0 -> u0 -> (u0, u0), u0 -> Bool, u0 -> Bool, u0 -> Integer, u0 -> Int)) -> case u1 of { _ALG_ _TUP_12 (u2 :: {{Real u0}}) (u3 :: {{Ix u0}}) (u4 :: u0 -> u0 -> u0) (u5 :: u0 -> u0 -> u0) (u6 :: u0 -> u0 -> u0) (u7 :: u0 -> u0 -> u0) (u8 :: u0 -> u0 -> (u0, u0)) (u9 :: u0 -> u0 -> (u0, u0)) (ua :: u0 -> Bool) (ub :: u0 -> Bool) (uc :: u0 -> Integer) (ud :: u0 -> Int) -> u2; _NO_DEFLT_ } _N_, _A_ 1 _U_ 1 _N_ _S_ "U(AU(LLLL)AAAAAAAAAA)" {_A_ 4 _U_ 2222 _N_ _N_ _F_ _IF_ARGS_ 1 4 XXXX 5 _/\_ u0 -> \ (u1 :: {{Ord u0}}) (u2 :: (u0, u0) -> [u0]) (u3 :: (u0, u0) -> u0 -> Int) (u4 :: (u0, u0) -> u0 -> Bool) -> _!_ _TUP_4 [{{Ord u0}}, ((u0, u0) -> [u0]), ((u0, u0) -> u0 -> Int), ((u0, u0) -> u0 -> Bool)] [u1, u2, u3, u4] _N_} _F_ _IF_ARGS_ 1 1 C 2 _/\_ u0 -> \ (u1 :: ({{Real u0}}, {{Ix u0}}, u0 -> u0 -> u0, u0 -> u0 -> u0, u0 -> u0 -> u0, u0 -> u0 -> u0, u0 -> u0 -> (u0, u0), u0 -> u0 -> (u0, u0), u0 -> Bool, u0 -> Bool, u0 -> Integer, u0 -> Int)) -> case u1 of { _ALG_ _TUP_12 (u2 :: {{Real u0}}) (u3 :: {{Ix u0}}) (u4 :: u0 -> u0 -> u0) (u5 :: u0 -> u0 -> u0) (u6 :: u0 -> u0 -> u0) (u7 :: u0 -> u0 -> u0) (u8 :: u0 -> u0 -> (u0, u0)) (u9 :: u0 -> u0 -> (u0, u0)) (ua :: u0 -> Bool) (ub :: u0 -> Bool) (uc :: u0 -> Integer) (ud :: u0 -> Int) -> u3; _NO_DEFLT_ } _N_ #-} where
quot :: a -> a -> a
{-# GHC_PRAGMA {-meth-} _A_ 1 _U_ 122 _N_ _S_ "U(AASAAAAAAAAA)" {_A_ 1 _U_ 122 _N_ _N_ _F_ _IF_ARGS_ 1 1 X 1 _/\_ u0 -> \ (u1 :: u0 -> u0 -> u0) -> u1 _N_} _F_ _IF_ARGS_ 1 1 C 2 _/\_ u0 -> \ (u1 :: ({{Real u0}}, {{Ix u0}}, u0 -> u0 -> u0, u0 -> u0 -> u0, u0 -> u0 -> u0, u0 -> u0 -> u0, u0 -> u0 -> (u0, u0), u0 -> u0 -> (u0, u0), u0 -> Bool, u0 -> Bool, u0 -> Integer, u0 -> Int)) -> case u1 of { _ALG_ _TUP_12 (u2 :: {{Real u0}}) (u3 :: {{Ix u0}}) (u4 :: u0 -> u0 -> u0) (u5 :: u0 -> u0 -> u0) (u6 :: u0 -> u0 -> u0) (u7 :: u0 -> u0 -> u0) (u8 :: u0 -> u0 -> (u0, u0)) (u9 :: u0 -> u0 -> (u0, u0)) (ua :: u0 -> Bool) (ub :: u0 -> Bool) (uc :: u0 -> Integer) (ud :: u0 -> Int) -> u4; _NO_DEFLT_ } _N_
{-defm-} _A_ 3 _U_ 122 _N_ _S_ "U(AAAAAAASAAAA)LL" {_A_ 3 _U_ 122 _N_ _N_ _F_ _IF_ARGS_ 1 3 XXX 5 _/\_ u0 -> \ (u1 :: u0 -> u0 -> (u0, u0)) (u2 :: u0) (u3 :: u0) -> case _APP_ u1 [ u2, u3 ] of { _ALG_ _TUP_2 (u4 :: u0) (u5 :: u0) -> u5; _NO_DEFLT_ } _N_} _F_ _IF_ARGS_ 1 3 CXX 6 _/\_ u0 -> \ (u1 :: {{Integral u0}}) (u2 :: u0) (u3 :: u0) -> case case u1 of { _ALG_ _TUP_12 (u4 :: {{Real u0}}) (u5 :: {{Ix u0}}) (u6 :: u0 -> u0 -> u0) (u7 :: u0 -> u0 -> u0) (u8 :: u0 -> u0 -> u0) (u9 :: u0 -> u0 -> u0) (ua :: u0 -> u0 -> (u0, u0)) (ub :: u0 -> u0 -> (u0, u0)) (uc :: u0 -> Bool) (ud :: u0 -> Bool) (ue :: u0 -> Integer) (uf :: u0 -> Int) -> _APP_ ub [ u2, u3 ]; _NO_DEFLT_ } of { _ALG_ _TUP_2 (ug :: u0) (uh :: u0) -> uh; _NO_DEFLT_ } _N_ #-}
quotRem :: a -> a -> (a, a)
{-# GHC_PRAGMA {-meth-} _A_ 1 _U_ 122 _N_ _S_ "U(AAAAAASAAAAA)" {_A_ 1 _U_ 122 _N_ _N_ _F_ _IF_ARGS_ 1 1 X 1 _/\_ u0 -> \ (u1 :: u0 -> u0 -> (u0, u0)) -> u1 _N_} _F_ _IF_ARGS_ 1 1 C 2 _/\_ u0 -> \ (u1 :: ({{Real u0}}, {{Ix u0}}, u0 -> u0 -> u0, u0 -> u0 -> u0, u0 -> u0 -> u0, u0 -> u0 -> u0, u0 -> u0 -> (u0, u0), u0 -> u0 -> (u0, u0), u0 -> Bool, u0 -> Bool, u0 -> Integer, u0 -> Int)) -> case u1 of { _ALG_ _TUP_12 (u2 :: {{Real u0}}) (u3 :: {{Ix u0}}) (u4 :: u0 -> u0 -> u0) (u5 :: u0 -> u0 -> u0) (u6 :: u0 -> u0 -> u0) (u7 :: u0 -> u0 -> u0) (u8 :: u0 -> u0 -> (u0, u0)) (u9 :: u0 -> u0 -> (u0, u0)) (ua :: u0 -> Bool) (ub :: u0 -> Bool) (uc :: u0 -> Integer) (ud :: u0 -> Int) -> u8; _NO_DEFLT_ } _N_
- {-defm-} _A_ 3 _U_ 022 _N_ _S_ _!_ _F_ _IF_ARGS_ 1 3 XXX 4 _/\_ u0 -> \ (u1 :: {{Integral u0}}) (u2 :: u0) (u3 :: u0) -> _APP_ _TYAPP_ patError# { (u0 -> u0 -> (u0, u0)) } [ _NOREP_S_ "%DPreludeCore.Integral.quotRem\"", u2, u3 ] _N_ #-}
+ {-defm-} _A_ 3 _U_ 022 _N_ _S_ _!_ _N_ _N_ #-}
divMod :: a -> a -> (a, a)
{-# GHC_PRAGMA {-meth-} _A_ 1 _U_ 122 _N_ _S_ "U(AAAAAAASAAAA)" {_A_ 1 _U_ 122 _N_ _N_ _F_ _IF_ARGS_ 1 1 X 1 _/\_ u0 -> \ (u1 :: u0 -> u0 -> (u0, u0)) -> u1 _N_} _F_ _IF_ARGS_ 1 1 C 2 _/\_ u0 -> \ (u1 :: ({{Real u0}}, {{Ix u0}}, u0 -> u0 -> u0, u0 -> u0 -> u0, u0 -> u0 -> u0, u0 -> u0 -> u0, u0 -> u0 -> (u0, u0), u0 -> u0 -> (u0, u0), u0 -> Bool, u0 -> Bool, u0 -> Integer, u0 -> Int)) -> case u1 of { _ALG_ _TUP_12 (u2 :: {{Real u0}}) (u3 :: {{Ix u0}}) (u4 :: u0 -> u0 -> u0) (u5 :: u0 -> u0 -> u0) (u6 :: u0 -> u0 -> u0) (u7 :: u0 -> u0 -> u0) (u8 :: u0 -> u0 -> (u0, u0)) (u9 :: u0 -> u0 -> (u0, u0)) (ua :: u0 -> Bool) (ub :: u0 -> Bool) (uc :: u0 -> Integer) (ud :: u0 -> Int) -> u9; _NO_DEFLT_ } _N_
- {-defm-} _A_ 1 _U_ 122 _N_ _S_ "U(U(U(U(SA)ALLALALLA)AA)AAAAALAAAAA)" {_A_ 2 _U_ 1222 _N_ _N_ _N_ _N_} _N_ _N_ #-}
+ {-defm-} _A_ 1 _U_ 122 _N_ _S_ "U(U(U(U(SA)ALLALALAL)AA)AAAAALAAAAA)" {_A_ 2 _U_ 1222 _N_ _N_ _N_ _N_} _N_ _N_ #-}
even :: a -> Bool
{-# GHC_PRAGMA {-meth-} _A_ 1 _U_ 12 _N_ _S_ "U(AAAAAAAASAAA)" {_A_ 1 _U_ 12 _N_ _N_ _F_ _IF_ARGS_ 1 1 X 1 _/\_ u0 -> \ (u1 :: u0 -> Bool) -> u1 _N_} _F_ _IF_ARGS_ 1 1 C 2 _/\_ u0 -> \ (u1 :: ({{Real u0}}, {{Ix u0}}, u0 -> u0 -> u0, u0 -> u0 -> u0, u0 -> u0 -> u0, u0 -> u0 -> u0, u0 -> u0 -> (u0, u0), u0 -> u0 -> (u0, u0), u0 -> Bool, u0 -> Bool, u0 -> Integer, u0 -> Int)) -> case u1 of { _ALG_ _TUP_12 (u2 :: {{Real u0}}) (u3 :: {{Ix u0}}) (u4 :: u0 -> u0 -> u0) (u5 :: u0 -> u0 -> u0) (u6 :: u0 -> u0 -> u0) (u7 :: u0 -> u0 -> u0) (u8 :: u0 -> u0 -> (u0, u0)) (u9 :: u0 -> u0 -> (u0, u0)) (ua :: u0 -> Bool) (ub :: u0 -> Bool) (uc :: u0 -> Integer) (ud :: u0 -> Int) -> ua; _NO_DEFLT_ } _N_
- {-defm-} _A_ 1 _U_ 12 _N_ _S_ "U(U(U(U(SA)AAAAAAALA)AA)AALAAAAAAAA)" {_A_ 3 _U_ 1212 _N_ _N_ _N_ _N_} _N_ _N_ #-}
+ {-defm-} _A_ 1 _U_ 12 _N_ _S_ "U(U(U(U(SA)AAAAAAAAL)AA)AALAAAAAAAA)" {_A_ 3 _U_ 1212 _N_ _N_ _N_ _N_} _N_ _N_ #-}
odd :: a -> Bool
{-# GHC_PRAGMA {-meth-} _A_ 1 _U_ 12 _N_ _S_ "U(AAAAAAAAASAA)" {_A_ 1 _U_ 12 _N_ _N_ _F_ _IF_ARGS_ 1 1 X 1 _/\_ u0 -> \ (u1 :: u0 -> Bool) -> u1 _N_} _F_ _IF_ARGS_ 1 1 C 2 _/\_ u0 -> \ (u1 :: ({{Real u0}}, {{Ix u0}}, u0 -> u0 -> u0, u0 -> u0 -> u0, u0 -> u0 -> u0, u0 -> u0 -> u0, u0 -> u0 -> (u0, u0), u0 -> u0 -> (u0, u0), u0 -> Bool, u0 -> Bool, u0 -> Integer, u0 -> Int)) -> case u1 of { _ALG_ _TUP_12 (u2 :: {{Real u0}}) (u3 :: {{Ix u0}}) (u4 :: u0 -> u0 -> u0) (u5 :: u0 -> u0 -> u0) (u6 :: u0 -> u0 -> u0) (u7 :: u0 -> u0 -> u0) (u8 :: u0 -> u0 -> (u0, u0)) (u9 :: u0 -> u0 -> (u0, u0)) (ua :: u0 -> Bool) (ub :: u0 -> Bool) (uc :: u0 -> Integer) (ud :: u0 -> Int) -> ub; _NO_DEFLT_ } _N_
- {-defm-} _A_ 1 _U_ 12 _N_ _S_ "U(U(U(U(AS)AAAAAAALA)AA)AALAAAAAAAA)" {_A_ 3 _U_ 1212 _N_ _N_ _N_ _N_} _N_ _N_ #-}
+ {-defm-} _A_ 1 _U_ 12 _N_ _S_ "U(U(U(U(AS)AAAAAAAAL)AA)AALAAAAAAAA)" {_A_ 3 _U_ 1212 _N_ _N_ _N_ _N_} _N_ _N_ #-}
toInteger :: a -> Integer
{-# GHC_PRAGMA {-meth-} _A_ 1 _U_ 12 _N_ _S_ "U(AAAAAAAAAASA)" {_A_ 1 _U_ 12 _N_ _N_ _F_ _IF_ARGS_ 1 1 X 1 _/\_ u0 -> \ (u1 :: u0 -> Integer) -> u1 _N_} _F_ _IF_ARGS_ 1 1 C 2 _/\_ u0 -> \ (u1 :: ({{Real u0}}, {{Ix u0}}, u0 -> u0 -> u0, u0 -> u0 -> u0, u0 -> u0 -> u0, u0 -> u0 -> u0, u0 -> u0 -> (u0, u0), u0 -> u0 -> (u0, u0), u0 -> Bool, u0 -> Bool, u0 -> Integer, u0 -> Int)) -> case u1 of { _ALG_ _TUP_12 (u2 :: {{Real u0}}) (u3 :: {{Ix u0}}) (u4 :: u0 -> u0 -> u0) (u5 :: u0 -> u0 -> u0) (u6 :: u0 -> u0 -> u0) (u7 :: u0 -> u0 -> u0) (u8 :: u0 -> u0 -> (u0, u0)) (u9 :: u0 -> u0 -> (u0, u0)) (ua :: u0 -> Bool) (ub :: u0 -> Bool) (uc :: u0 -> Integer) (ud :: u0 -> Int) -> uc; _NO_DEFLT_ } _N_
- {-defm-} _A_ 2 _U_ 02 _N_ _S_ _!_ _F_ _IF_ARGS_ 1 2 XX 3 _/\_ u0 -> \ (u1 :: {{Integral u0}}) (u2 :: u0) -> _APP_ _TYAPP_ patError# { (u0 -> Integer) } [ _NOREP_S_ "%DPreludeCore.Integral.toInteger\"", u2 ] _N_ #-}
+ {-defm-} _A_ 2 _U_ 02 _N_ _S_ _!_ _N_ _N_ #-}
toInt :: a -> Int
{-# GHC_PRAGMA {-meth-} _A_ 1 _U_ 12 _N_ _S_ "U(AAAAAAAAAAAS)" {_A_ 1 _U_ 12 _N_ _N_ _F_ _IF_ARGS_ 1 1 X 1 _/\_ u0 -> \ (u1 :: u0 -> Int) -> u1 _N_} _F_ _IF_ARGS_ 1 1 C 2 _/\_ u0 -> \ (u1 :: ({{Real u0}}, {{Ix u0}}, u0 -> u0 -> u0, u0 -> u0 -> u0, u0 -> u0 -> u0, u0 -> u0 -> u0, u0 -> u0 -> (u0, u0), u0 -> u0 -> (u0, u0), u0 -> Bool, u0 -> Bool, u0 -> Integer, u0 -> Int)) -> case u1 of { _ALG_ _TUP_12 (u2 :: {{Real u0}}) (u3 :: {{Ix u0}}) (u4 :: u0 -> u0 -> u0) (u5 :: u0 -> u0 -> u0) (u6 :: u0 -> u0 -> u0) (u7 :: u0 -> u0 -> u0) (u8 :: u0 -> u0 -> (u0, u0)) (u9 :: u0 -> u0 -> (u0, u0)) (ua :: u0 -> Bool) (ub :: u0 -> Bool) (uc :: u0 -> Integer) (ud :: u0 -> Int) -> ud; _NO_DEFLT_ } _N_
- {-defm-} _A_ 2 _U_ 02 _N_ _S_ _!_ _F_ _IF_ARGS_ 1 2 XX 3 _/\_ u0 -> \ (u1 :: {{Integral u0}}) (u2 :: u0) -> _APP_ _TYAPP_ patError# { (u0 -> Int) } [ _NOREP_S_ "%DPreludeCore.Integral.toInt\"", u2 ] _N_ #-}
+ {-defm-} _A_ 2 _U_ 02 _N_ _S_ _!_ _N_ _N_ #-}
class (Ord a) => Ix a {-# GHC_PRAGMA {-superdicts-} _A_ 1 _U_ 1 _N_ _S_ "U(U(LLLLLLLL)AAA)" {_A_ 1 _U_ 1 _N_ _N_ _F_ _IF_ARGS_ 1 1 X 1 _/\_ u0 -> \ (u1 :: {{Ord u0}}) -> u1 _N_} _F_ _IF_ARGS_ 1 1 C 2 _/\_ u0 -> \ (u1 :: ({{Ord u0}}, (u0, u0) -> [u0], (u0, u0) -> u0 -> Int, (u0, u0) -> u0 -> Bool)) -> case u1 of { _ALG_ _TUP_4 (u2 :: {{Ord u0}}) (u3 :: (u0, u0) -> [u0]) (u4 :: (u0, u0) -> u0 -> Int) (u5 :: (u0, u0) -> u0 -> Bool) -> u2; _NO_DEFLT_ } _N_ #-} where
range :: (a, a) -> [a]
{-# GHC_PRAGMA {-meth-} _A_ 1 _U_ 12 _N_ _S_ "U(ASAA)" {_A_ 1 _U_ 12 _N_ _N_ _F_ _IF_ARGS_ 1 1 X 1 _/\_ u0 -> \ (u1 :: (u0, u0) -> [u0]) -> u1 _N_} _F_ _IF_ARGS_ 1 1 C 2 _/\_ u0 -> \ (u1 :: ({{Ord u0}}, (u0, u0) -> [u0], (u0, u0) -> u0 -> Int, (u0, u0) -> u0 -> Bool)) -> case u1 of { _ALG_ _TUP_4 (u2 :: {{Ord u0}}) (u3 :: (u0, u0) -> [u0]) (u4 :: (u0, u0) -> u0 -> Int) (u5 :: (u0, u0) -> u0 -> Bool) -> u3; _NO_DEFLT_ } _N_
- {-defm-} _A_ 2 _U_ 02 _N_ _S_ _!_ _F_ _IF_ARGS_ 1 2 XX 3 _/\_ u0 -> \ (u1 :: {{Ix u0}}) (u2 :: (u0, u0)) -> _APP_ _TYAPP_ patError# { ((u0, u0) -> [u0]) } [ _NOREP_S_ "%DPreludeCore.Ix.range\"", u2 ] _N_ #-}
+ {-defm-} _A_ 2 _U_ 02 _N_ _S_ _!_ _N_ _N_ #-}
index :: (a, a) -> a -> Int
{-# GHC_PRAGMA {-meth-} _A_ 1 _U_ 122 _N_ _S_ "U(AASA)" {_A_ 1 _U_ 122 _N_ _N_ _F_ _IF_ARGS_ 1 1 X 1 _/\_ u0 -> \ (u1 :: (u0, u0) -> u0 -> Int) -> u1 _N_} _F_ _IF_ARGS_ 1 1 C 2 _/\_ u0 -> \ (u1 :: ({{Ord u0}}, (u0, u0) -> [u0], (u0, u0) -> u0 -> Int, (u0, u0) -> u0 -> Bool)) -> case u1 of { _ALG_ _TUP_4 (u2 :: {{Ord u0}}) (u3 :: (u0, u0) -> [u0]) (u4 :: (u0, u0) -> u0 -> Int) (u5 :: (u0, u0) -> u0 -> Bool) -> u4; _NO_DEFLT_ } _N_
- {-defm-} _A_ 3 _U_ 022 _N_ _S_ _!_ _F_ _IF_ARGS_ 1 3 XXX 4 _/\_ u0 -> \ (u1 :: {{Ix u0}}) (u2 :: (u0, u0)) (u3 :: u0) -> _APP_ _TYAPP_ patError# { ((u0, u0) -> u0 -> Int) } [ _NOREP_S_ "%DPreludeCore.Ix.index\"", u2, u3 ] _N_ #-}
+ {-defm-} _A_ 3 _U_ 022 _N_ _S_ _!_ _N_ _N_ #-}
inRange :: (a, a) -> a -> Bool
{-# GHC_PRAGMA {-meth-} _A_ 1 _U_ 122 _N_ _S_ "U(AAAS)" {_A_ 1 _U_ 122 _N_ _N_ _F_ _IF_ARGS_ 1 1 X 1 _/\_ u0 -> \ (u1 :: (u0, u0) -> u0 -> Bool) -> u1 _N_} _F_ _IF_ARGS_ 1 1 C 2 _/\_ u0 -> \ (u1 :: ({{Ord u0}}, (u0, u0) -> [u0], (u0, u0) -> u0 -> Int, (u0, u0) -> u0 -> Bool)) -> case u1 of { _ALG_ _TUP_4 (u2 :: {{Ord u0}}) (u3 :: (u0, u0) -> [u0]) (u4 :: (u0, u0) -> u0 -> Int) (u5 :: (u0, u0) -> u0 -> Bool) -> u5; _NO_DEFLT_ } _N_
- {-defm-} _A_ 3 _U_ 022 _N_ _S_ _!_ _F_ _IF_ARGS_ 1 3 XXX 4 _/\_ u0 -> \ (u1 :: {{Ix u0}}) (u2 :: (u0, u0)) (u3 :: u0) -> _APP_ _TYAPP_ patError# { ((u0, u0) -> u0 -> Bool) } [ _NOREP_S_ "%DPreludeCore.Ix.inRange\"", u2, u3 ] _N_ #-}
+ {-defm-} _A_ 3 _U_ 022 _N_ _S_ _!_ _N_ _N_ #-}
class (Eq a, Text a) => Num a {-# GHC_PRAGMA {-superdicts-} _A_ 1 _U_ 1 _N_ _S_ "U(U(LL)AAAAAAAAA)" {_A_ 2 _U_ 22 _N_ _N_ _F_ _IF_ARGS_ 1 2 XX 3 _/\_ u0 -> \ (u1 :: u0 -> u0 -> Bool) (u2 :: u0 -> u0 -> Bool) -> _!_ _TUP_2 [(u0 -> u0 -> Bool), (u0 -> u0 -> Bool)] [u1, u2] _N_} _F_ _IF_ARGS_ 1 1 C 2 _/\_ u0 -> \ (u1 :: ({{Eq u0}}, {{Text u0}}, u0 -> u0 -> u0, u0 -> u0 -> u0, u0 -> u0 -> u0, u0 -> u0, u0 -> u0, u0 -> u0, Integer -> u0, Int -> u0)) -> case u1 of { _ALG_ _TUP_10 (u2 :: {{Eq u0}}) (u3 :: {{Text u0}}) (u4 :: u0 -> u0 -> u0) (u5 :: u0 -> u0 -> u0) (u6 :: u0 -> u0 -> u0) (u7 :: u0 -> u0) (u8 :: u0 -> u0) (u9 :: u0 -> u0) (ua :: Integer -> u0) (ub :: Int -> u0) -> u2; _NO_DEFLT_ } _N_, _A_ 1 _U_ 1 _N_ _S_ "U(AU(LLLL)AAAAAAAA)" {_A_ 4 _U_ 2222 _N_ _N_ _F_ _IF_ARGS_ 1 4 XXXX 5 _/\_ u0 -> \ (u1 :: Int -> [Char] -> [(u0, [Char])]) (u2 :: Int -> u0 -> [Char] -> [Char]) (u3 :: [Char] -> [([u0], [Char])]) (u4 :: [u0] -> [Char] -> [Char]) -> _!_ _TUP_4 [(Int -> [Char] -> [(u0, [Char])]), (Int -> u0 -> [Char] -> [Char]), ([Char] -> [([u0], [Char])]), ([u0] -> [Char] -> [Char])] [u1, u2, u3, u4] _N_} _F_ _IF_ARGS_ 1 1 C 2 _/\_ u0 -> \ (u1 :: ({{Eq u0}}, {{Text u0}}, u0 -> u0 -> u0, u0 -> u0 -> u0, u0 -> u0 -> u0, u0 -> u0, u0 -> u0, u0 -> u0, Integer -> u0, Int -> u0)) -> case u1 of { _ALG_ _TUP_10 (u2 :: {{Eq u0}}) (u3 :: {{Text u0}}) (u4 :: u0 -> u0 -> u0) (u5 :: u0 -> u0 -> u0) (u6 :: u0 -> u0 -> u0) (u7 :: u0 -> u0) (u8 :: u0 -> u0) (u9 :: u0 -> u0) (ua :: Integer -> u0) (ub :: Int -> u0) -> u3; _NO_DEFLT_ } _N_ #-} where
(+) :: a -> a -> a
{-# GHC_PRAGMA {-meth-} _A_ 1 _U_ 122 _N_ _S_ "U(AASAAAAAAA)" {_A_ 1 _U_ 122 _N_ _N_ _F_ _IF_ARGS_ 1 1 X 1 _/\_ u0 -> \ (u1 :: u0 -> u0 -> u0) -> u1 _N_} _F_ _IF_ARGS_ 1 1 C 2 _/\_ u0 -> \ (u1 :: ({{Eq u0}}, {{Text u0}}, u0 -> u0 -> u0, u0 -> u0 -> u0, u0 -> u0 -> u0, u0 -> u0, u0 -> u0, u0 -> u0, Integer -> u0, Int -> u0)) -> case u1 of { _ALG_ _TUP_10 (u2 :: {{Eq u0}}) (u3 :: {{Text u0}}) (u4 :: u0 -> u0 -> u0) (u5 :: u0 -> u0 -> u0) (u6 :: u0 -> u0 -> u0) (u7 :: u0 -> u0) (u8 :: u0 -> u0) (u9 :: u0 -> u0) (ua :: Integer -> u0) (ub :: Int -> u0) -> u4; _NO_DEFLT_ } _N_
- {-defm-} _A_ 3 _U_ 022 _N_ _S_ _!_ _F_ _IF_ARGS_ 1 3 XXX 4 _/\_ u0 -> \ (u1 :: {{Num u0}}) (u2 :: u0) (u3 :: u0) -> _APP_ _TYAPP_ patError# { (u0 -> u0 -> u0) } [ _NOREP_S_ "%DPreludeCore.Num.(+)\"", u2, u3 ] _N_ #-}
+ {-defm-} _A_ 3 _U_ 022 _N_ _S_ _!_ _N_ _N_ #-}
(-) :: a -> a -> a
{-# GHC_PRAGMA {-meth-} _A_ 1 _U_ 122 _N_ _S_ "U(AAASAAAAAA)" {_A_ 1 _U_ 122 _N_ _N_ _F_ _IF_ARGS_ 1 1 X 1 _/\_ u0 -> \ (u1 :: u0 -> u0 -> u0) -> u1 _N_} _F_ _IF_ARGS_ 1 1 C 2 _/\_ u0 -> \ (u1 :: ({{Eq u0}}, {{Text u0}}, u0 -> u0 -> u0, u0 -> u0 -> u0, u0 -> u0 -> u0, u0 -> u0, u0 -> u0, u0 -> u0, Integer -> u0, Int -> u0)) -> case u1 of { _ALG_ _TUP_10 (u2 :: {{Eq u0}}) (u3 :: {{Text u0}}) (u4 :: u0 -> u0 -> u0) (u5 :: u0 -> u0 -> u0) (u6 :: u0 -> u0 -> u0) (u7 :: u0 -> u0) (u8 :: u0 -> u0) (u9 :: u0 -> u0) (ua :: Integer -> u0) (ub :: Int -> u0) -> u5; _NO_DEFLT_ } _N_
{-defm-} _A_ 3 _U_ 122 _N_ _S_ "U(AASAALAAAA)LL" {_A_ 4 _U_ 1122 _N_ _N_ _F_ _IF_ARGS_ 1 4 XXXX 6 _/\_ u0 -> \ (u1 :: u0 -> u0 -> u0) (u2 :: u0 -> u0) (u3 :: u0) (u4 :: u0) -> let {(u5 :: u0) = _APP_ u2 [ u4 ]} in _APP_ u1 [ u3, u5 ] _N_} _F_ _ALWAYS_ _/\_ u0 -> \ (u1 :: {{Num u0}}) (u2 :: u0) (u3 :: u0) -> case u1 of { _ALG_ _TUP_10 (u4 :: {{Eq u0}}) (u5 :: {{Text u0}}) (u6 :: u0 -> u0 -> u0) (u7 :: u0 -> u0 -> u0) (u8 :: u0 -> u0 -> u0) (u9 :: u0 -> u0) (ua :: u0 -> u0) (ub :: u0 -> u0) (uc :: Integer -> u0) (ud :: Int -> u0) -> let {(ue :: u0) = _APP_ u9 [ u3 ]} in _APP_ u6 [ u2, ue ]; _NO_DEFLT_ } _N_ #-}
(*) :: a -> a -> a
{-# GHC_PRAGMA {-meth-} _A_ 1 _U_ 122 _N_ _S_ "U(AAAASAAAAA)" {_A_ 1 _U_ 122 _N_ _N_ _F_ _IF_ARGS_ 1 1 X 1 _/\_ u0 -> \ (u1 :: u0 -> u0 -> u0) -> u1 _N_} _F_ _IF_ARGS_ 1 1 C 2 _/\_ u0 -> \ (u1 :: ({{Eq u0}}, {{Text u0}}, u0 -> u0 -> u0, u0 -> u0 -> u0, u0 -> u0 -> u0, u0 -> u0, u0 -> u0, u0 -> u0, Integer -> u0, Int -> u0)) -> case u1 of { _ALG_ _TUP_10 (u2 :: {{Eq u0}}) (u3 :: {{Text u0}}) (u4 :: u0 -> u0 -> u0) (u5 :: u0 -> u0 -> u0) (u6 :: u0 -> u0 -> u0) (u7 :: u0 -> u0) (u8 :: u0 -> u0) (u9 :: u0 -> u0) (ua :: Integer -> u0) (ub :: Int -> u0) -> u6; _NO_DEFLT_ } _N_
- {-defm-} _A_ 3 _U_ 022 _N_ _S_ _!_ _F_ _IF_ARGS_ 1 3 XXX 4 _/\_ u0 -> \ (u1 :: {{Num u0}}) (u2 :: u0) (u3 :: u0) -> _APP_ _TYAPP_ patError# { (u0 -> u0 -> u0) } [ _NOREP_S_ "%DPreludeCore.Num.(*)\"", u2, u3 ] _N_ #-}
+ {-defm-} _A_ 3 _U_ 022 _N_ _S_ _!_ _N_ _N_ #-}
negate :: a -> a
{-# GHC_PRAGMA {-meth-} _A_ 1 _U_ 12 _N_ _S_ "U(AAAAASAAAA)" {_A_ 1 _U_ 12 _N_ _N_ _F_ _IF_ARGS_ 1 1 X 1 _/\_ u0 -> \ (u1 :: u0 -> u0) -> u1 _N_} _F_ _IF_ARGS_ 1 1 C 2 _/\_ u0 -> \ (u1 :: ({{Eq u0}}, {{Text u0}}, u0 -> u0 -> u0, u0 -> u0 -> u0, u0 -> u0 -> u0, u0 -> u0, u0 -> u0, u0 -> u0, Integer -> u0, Int -> u0)) -> case u1 of { _ALG_ _TUP_10 (u2 :: {{Eq u0}}) (u3 :: {{Text u0}}) (u4 :: u0 -> u0 -> u0) (u5 :: u0 -> u0 -> u0) (u6 :: u0 -> u0 -> u0) (u7 :: u0 -> u0) (u8 :: u0 -> u0) (u9 :: u0 -> u0) (ua :: Integer -> u0) (ub :: Int -> u0) -> u7; _NO_DEFLT_ } _N_
- {-defm-} _A_ 2 _U_ 02 _N_ _S_ _!_ _F_ _IF_ARGS_ 1 2 XX 3 _/\_ u0 -> \ (u1 :: {{Num u0}}) (u2 :: u0) -> _APP_ _TYAPP_ patError# { (u0 -> u0) } [ _NOREP_S_ "%DPreludeCore.Num.negate\"", u2 ] _N_ #-}
+ {-defm-} _A_ 2 _U_ 02 _N_ _S_ _!_ _N_ _N_ #-}
abs :: a -> a
{-# GHC_PRAGMA {-meth-} _A_ 1 _U_ 12 _N_ _S_ "U(AAAAAASAAA)" {_A_ 1 _U_ 12 _N_ _N_ _F_ _IF_ARGS_ 1 1 X 1 _/\_ u0 -> \ (u1 :: u0 -> u0) -> u1 _N_} _F_ _IF_ARGS_ 1 1 C 2 _/\_ u0 -> \ (u1 :: ({{Eq u0}}, {{Text u0}}, u0 -> u0 -> u0, u0 -> u0 -> u0, u0 -> u0 -> u0, u0 -> u0, u0 -> u0, u0 -> u0, Integer -> u0, Int -> u0)) -> case u1 of { _ALG_ _TUP_10 (u2 :: {{Eq u0}}) (u3 :: {{Text u0}}) (u4 :: u0 -> u0 -> u0) (u5 :: u0 -> u0 -> u0) (u6 :: u0 -> u0 -> u0) (u7 :: u0 -> u0) (u8 :: u0 -> u0) (u9 :: u0 -> u0) (ua :: Integer -> u0) (ub :: Int -> u0) -> u8; _NO_DEFLT_ } _N_
- {-defm-} _A_ 2 _U_ 02 _N_ _S_ _!_ _F_ _IF_ARGS_ 1 2 XX 3 _/\_ u0 -> \ (u1 :: {{Num u0}}) (u2 :: u0) -> _APP_ _TYAPP_ patError# { (u0 -> u0) } [ _NOREP_S_ "%DPreludeCore.Num.abs\"", u2 ] _N_ #-}
+ {-defm-} _A_ 2 _U_ 02 _N_ _S_ _!_ _N_ _N_ #-}
signum :: a -> a
{-# GHC_PRAGMA {-meth-} _A_ 1 _U_ 12 _N_ _S_ "U(AAAAAAASAA)" {_A_ 1 _U_ 12 _N_ _N_ _F_ _IF_ARGS_ 1 1 X 1 _/\_ u0 -> \ (u1 :: u0 -> u0) -> u1 _N_} _F_ _IF_ARGS_ 1 1 C 2 _/\_ u0 -> \ (u1 :: ({{Eq u0}}, {{Text u0}}, u0 -> u0 -> u0, u0 -> u0 -> u0, u0 -> u0 -> u0, u0 -> u0, u0 -> u0, u0 -> u0, Integer -> u0, Int -> u0)) -> case u1 of { _ALG_ _TUP_10 (u2 :: {{Eq u0}}) (u3 :: {{Text u0}}) (u4 :: u0 -> u0 -> u0) (u5 :: u0 -> u0 -> u0) (u6 :: u0 -> u0 -> u0) (u7 :: u0 -> u0) (u8 :: u0 -> u0) (u9 :: u0 -> u0) (ua :: Integer -> u0) (ub :: Int -> u0) -> u9; _NO_DEFLT_ } _N_
- {-defm-} _A_ 2 _U_ 02 _N_ _S_ _!_ _F_ _IF_ARGS_ 1 2 XX 3 _/\_ u0 -> \ (u1 :: {{Num u0}}) (u2 :: u0) -> _APP_ _TYAPP_ patError# { (u0 -> u0) } [ _NOREP_S_ "%DPreludeCore.Num.signum\"", u2 ] _N_ #-}
+ {-defm-} _A_ 2 _U_ 02 _N_ _S_ _!_ _N_ _N_ #-}
fromInteger :: Integer -> a
{-# GHC_PRAGMA {-meth-} _A_ 1 _U_ 12 _N_ _S_ "U(AAAAAAAASA)" {_A_ 1 _U_ 12 _N_ _N_ _F_ _IF_ARGS_ 1 1 X 1 _/\_ u0 -> \ (u1 :: Integer -> u0) -> u1 _N_} _F_ _IF_ARGS_ 1 1 C 2 _/\_ u0 -> \ (u1 :: ({{Eq u0}}, {{Text u0}}, u0 -> u0 -> u0, u0 -> u0 -> u0, u0 -> u0 -> u0, u0 -> u0, u0 -> u0, u0 -> u0, Integer -> u0, Int -> u0)) -> case u1 of { _ALG_ _TUP_10 (u2 :: {{Eq u0}}) (u3 :: {{Text u0}}) (u4 :: u0 -> u0 -> u0) (u5 :: u0 -> u0 -> u0) (u6 :: u0 -> u0 -> u0) (u7 :: u0 -> u0) (u8 :: u0 -> u0) (u9 :: u0 -> u0) (ua :: Integer -> u0) (ub :: Int -> u0) -> ua; _NO_DEFLT_ } _N_
- {-defm-} _A_ 2 _U_ 02 _N_ _S_ _!_ _F_ _IF_ARGS_ 1 2 XX 3 _/\_ u0 -> \ (u1 :: {{Num u0}}) (u2 :: Integer) -> _APP_ _TYAPP_ patError# { (Integer -> u0) } [ _NOREP_S_ "%DPreludeCore.Num.fromInteger\"", u2 ] _N_ #-}
+ {-defm-} _A_ 2 _U_ 02 _N_ _S_ _!_ _N_ _N_ #-}
fromInt :: Int -> a
{-# GHC_PRAGMA {-meth-} _A_ 1 _U_ 12 _N_ _S_ "U(AAAAAAAAAS)" {_A_ 1 _U_ 12 _N_ _N_ _F_ _IF_ARGS_ 1 1 X 1 _/\_ u0 -> \ (u1 :: Int -> u0) -> u1 _N_} _F_ _IF_ARGS_ 1 1 C 2 _/\_ u0 -> \ (u1 :: ({{Eq u0}}, {{Text u0}}, u0 -> u0 -> u0, u0 -> u0 -> u0, u0 -> u0 -> u0, u0 -> u0, u0 -> u0, u0 -> u0, Integer -> u0, Int -> u0)) -> case u1 of { _ALG_ _TUP_10 (u2 :: {{Eq u0}}) (u3 :: {{Text u0}}) (u4 :: u0 -> u0 -> u0) (u5 :: u0 -> u0 -> u0) (u6 :: u0 -> u0 -> u0) (u7 :: u0 -> u0) (u8 :: u0 -> u0) (u9 :: u0 -> u0) (ua :: Integer -> u0) (ub :: Int -> u0) -> ub; _NO_DEFLT_ } _N_
{-defm-} _A_ 2 _U_ 11 _N_ _S_ "U(AAAAAAAASA)L" {_A_ 2 _U_ 11 _N_ _N_ _F_ _IF_ARGS_ 1 2 XC 5 _/\_ u0 -> \ (u1 :: Integer -> u0) (u2 :: Int) -> let {(u4 :: Integer) = case u2 of { _ALG_ I# (u3 :: Int#) -> _#_ int2Integer# [] [u3]; _NO_DEFLT_ }} in _APP_ u1 [ u4 ] _N_} _F_ _IF_ARGS_ 1 2 CC 6 _/\_ u0 -> \ (u1 :: {{Num u0}}) (u2 :: Int) -> let {(u4 :: Integer) = case u2 of { _ALG_ I# (u3 :: Int#) -> _#_ int2Integer# [] [u3]; _NO_DEFLT_ }} in case u1 of { _ALG_ _TUP_10 (u5 :: {{Eq u0}}) (u6 :: {{Text u0}}) (u7 :: u0 -> u0 -> u0) (u8 :: u0 -> u0 -> u0) (u9 :: u0 -> u0 -> u0) (ua :: u0 -> u0) (ub :: u0 -> u0) (uc :: u0 -> u0) (ud :: Integer -> u0) (ue :: Int -> u0) -> _APP_ ud [ u4 ]; _NO_DEFLT_ } _N_ #-}
{-defm-} _A_ 3 _U_ 122 _N_ _S_ "U(LASAAAAA)LL" {_A_ 4 _U_ 1122 _N_ _N_ _N_ _N_} _N_ _N_ #-}
(<=) :: a -> a -> Bool
{-# GHC_PRAGMA {-meth-} _A_ 1 _U_ 122 _N_ _S_ "U(AASAAAAA)" {_A_ 1 _U_ 122 _N_ _N_ _F_ _IF_ARGS_ 1 1 X 1 _/\_ u0 -> \ (u1 :: u0 -> u0 -> Bool) -> u1 _N_} _F_ _IF_ARGS_ 1 1 C 2 _/\_ u0 -> \ (u1 :: ({{Eq u0}}, u0 -> u0 -> Bool, u0 -> u0 -> Bool, u0 -> u0 -> Bool, u0 -> u0 -> Bool, u0 -> u0 -> u0, u0 -> u0 -> u0, u0 -> u0 -> _CMP_TAG)) -> case u1 of { _ALG_ _TUP_8 (u2 :: {{Eq u0}}) (u3 :: u0 -> u0 -> Bool) (u4 :: u0 -> u0 -> Bool) (u5 :: u0 -> u0 -> Bool) (u6 :: u0 -> u0 -> Bool) (u7 :: u0 -> u0 -> u0) (u8 :: u0 -> u0 -> u0) (u9 :: u0 -> u0 -> _CMP_TAG) -> u4; _NO_DEFLT_ } _N_
- {-defm-} _A_ 3 _U_ 022 _N_ _S_ _!_ _F_ _IF_ARGS_ 1 3 XXX 4 _/\_ u0 -> \ (u1 :: {{Ord u0}}) (u2 :: u0) (u3 :: u0) -> _APP_ _TYAPP_ patError# { (u0 -> u0 -> Bool) } [ _NOREP_S_ "%DPreludeCore.Ord.(<=)\"", u2, u3 ] _N_ #-}
+ {-defm-} _A_ 3 _U_ 022 _N_ _S_ _!_ _N_ _N_ #-}
(>=) :: a -> a -> Bool
{-# GHC_PRAGMA {-meth-} _A_ 1 _U_ 122 _N_ _S_ "U(AAASAAAA)" {_A_ 1 _U_ 122 _N_ _N_ _F_ _IF_ARGS_ 1 1 X 1 _/\_ u0 -> \ (u1 :: u0 -> u0 -> Bool) -> u1 _N_} _F_ _IF_ARGS_ 1 1 C 2 _/\_ u0 -> \ (u1 :: ({{Eq u0}}, u0 -> u0 -> Bool, u0 -> u0 -> Bool, u0 -> u0 -> Bool, u0 -> u0 -> Bool, u0 -> u0 -> u0, u0 -> u0 -> u0, u0 -> u0 -> _CMP_TAG)) -> case u1 of { _ALG_ _TUP_8 (u2 :: {{Eq u0}}) (u3 :: u0 -> u0 -> Bool) (u4 :: u0 -> u0 -> Bool) (u5 :: u0 -> u0 -> Bool) (u6 :: u0 -> u0 -> Bool) (u7 :: u0 -> u0 -> u0) (u8 :: u0 -> u0 -> u0) (u9 :: u0 -> u0 -> _CMP_TAG) -> u5; _NO_DEFLT_ } _N_
{-defm-} _A_ 3 _U_ 122 _N_ _S_ "U(AASAAAAA)LL" {_A_ 3 _U_ 122 _N_ _N_ _F_ _IF_ARGS_ 1 3 XXX 3 _/\_ u0 -> \ (u1 :: u0 -> u0 -> Bool) (u2 :: u0) (u3 :: u0) -> _APP_ u1 [ u3, u2 ] _N_} _F_ _IF_ARGS_ 1 3 CXX 4 _/\_ u0 -> \ (u1 :: {{Ord u0}}) (u2 :: u0) (u3 :: u0) -> case u1 of { _ALG_ _TUP_8 (u4 :: {{Eq u0}}) (u5 :: u0 -> u0 -> Bool) (u6 :: u0 -> u0 -> Bool) (u7 :: u0 -> u0 -> Bool) (u8 :: u0 -> u0 -> Bool) (u9 :: u0 -> u0 -> u0) (ua :: u0 -> u0 -> u0) (ub :: u0 -> u0 -> _CMP_TAG) -> _APP_ u6 [ u3, u2 ]; _NO_DEFLT_ } _N_ #-}
class (Num a, Enum a) => Real a {-# GHC_PRAGMA {-superdicts-} _A_ 1 _U_ 1 _N_ _S_ "U(U(LLLLLLLLLL)AA)" {_A_ 1 _U_ 1 _N_ _N_ _F_ _IF_ARGS_ 1 1 X 1 _/\_ u0 -> \ (u1 :: {{Num u0}}) -> u1 _N_} _F_ _IF_ARGS_ 1 1 C 2 _/\_ u0 -> \ (u1 :: ({{Num u0}}, {{Enum u0}}, u0 -> Ratio Integer)) -> case u1 of { _ALG_ _TUP_3 (u2 :: {{Num u0}}) (u3 :: {{Enum u0}}) (u4 :: u0 -> Ratio Integer) -> u2; _NO_DEFLT_ } _N_, _A_ 1 _U_ 1 _N_ _S_ "U(AU(LLLLL)A)" {_A_ 5 _U_ 22222 _N_ _N_ _F_ _IF_ARGS_ 1 5 XXXXX 6 _/\_ u0 -> \ (u1 :: {{Ord u0}}) (u2 :: u0 -> [u0]) (u3 :: u0 -> u0 -> [u0]) (u4 :: u0 -> u0 -> [u0]) (u5 :: u0 -> u0 -> u0 -> [u0]) -> _!_ _TUP_5 [{{Ord u0}}, (u0 -> [u0]), (u0 -> u0 -> [u0]), (u0 -> u0 -> [u0]), (u0 -> u0 -> u0 -> [u0])] [u1, u2, u3, u4, u5] _N_} _F_ _IF_ARGS_ 1 1 C 2 _/\_ u0 -> \ (u1 :: ({{Num u0}}, {{Enum u0}}, u0 -> Ratio Integer)) -> case u1 of { _ALG_ _TUP_3 (u2 :: {{Num u0}}) (u3 :: {{Enum u0}}) (u4 :: u0 -> Ratio Integer) -> u3; _NO_DEFLT_ } _N_ #-} where
toRational :: a -> Ratio Integer
{-# GHC_PRAGMA {-meth-} _A_ 1 _U_ 12 _N_ _S_ "U(AAS)" {_A_ 1 _U_ 12 _N_ _N_ _F_ _IF_ARGS_ 1 1 X 1 _/\_ u0 -> \ (u1 :: u0 -> Ratio Integer) -> u1 _N_} _F_ _IF_ARGS_ 1 1 C 2 _/\_ u0 -> \ (u1 :: ({{Num u0}}, {{Enum u0}}, u0 -> Ratio Integer)) -> case u1 of { _ALG_ _TUP_3 (u2 :: {{Num u0}}) (u3 :: {{Enum u0}}) (u4 :: u0 -> Ratio Integer) -> u4; _NO_DEFLT_ } _N_
- {-defm-} _A_ 2 _U_ 02 _N_ _S_ _!_ _F_ _IF_ARGS_ 1 2 XX 3 _/\_ u0 -> \ (u1 :: {{Real u0}}) (u2 :: u0) -> _APP_ _TYAPP_ patError# { (u0 -> Ratio Integer) } [ _NOREP_S_ "%DPreludeCore.Real.toRational\"", u2 ] _N_ #-}
+ {-defm-} _A_ 2 _U_ 02 _N_ _S_ _!_ _N_ _N_ #-}
class (RealFrac a, Floating a) => RealFloat a {-# GHC_PRAGMA {-superdicts-} _A_ 1 _U_ 1 _N_ _S_ "U(U(LLLLLLL)AAAAAAAAA)" {_A_ 1 _U_ 1 _N_ _N_ _F_ _IF_ARGS_ 1 1 X 1 _/\_ u0 -> \ (u1 :: {{RealFrac u0}}) -> u1 _N_} _F_ _IF_ARGS_ 1 1 C 2 _/\_ u0 -> \ (u1 :: ({{RealFrac u0}}, {{Floating u0}}, u0 -> Integer, u0 -> Int, u0 -> (Int, Int), u0 -> (Integer, Int), Integer -> Int -> u0, u0 -> Int, u0 -> u0, Int -> u0 -> u0)) -> case u1 of { _ALG_ _TUP_10 (u2 :: {{RealFrac u0}}) (u3 :: {{Floating u0}}) (u4 :: u0 -> Integer) (u5 :: u0 -> Int) (u6 :: u0 -> (Int, Int)) (u7 :: u0 -> (Integer, Int)) (u8 :: Integer -> Int -> u0) (u9 :: u0 -> Int) (ua :: u0 -> u0) (ub :: Int -> u0 -> u0) -> u2; _NO_DEFLT_ } _N_, _A_ 1 _U_ 1 _N_ _S_ "U(AU(LLLLLLLLLLLLLLLLLLL)AAAAAAAA)" {_A_ 1 _U_ 1 _N_ _N_ _F_ _IF_ARGS_ 1 1 X 1 _/\_ u0 -> \ (u1 :: {{Floating u0}}) -> u1 _N_} _F_ _IF_ARGS_ 1 1 C 2 _/\_ u0 -> \ (u1 :: ({{RealFrac u0}}, {{Floating u0}}, u0 -> Integer, u0 -> Int, u0 -> (Int, Int), u0 -> (Integer, Int), Integer -> Int -> u0, u0 -> Int, u0 -> u0, Int -> u0 -> u0)) -> case u1 of { _ALG_ _TUP_10 (u2 :: {{RealFrac u0}}) (u3 :: {{Floating u0}}) (u4 :: u0 -> Integer) (u5 :: u0 -> Int) (u6 :: u0 -> (Int, Int)) (u7 :: u0 -> (Integer, Int)) (u8 :: Integer -> Int -> u0) (u9 :: u0 -> Int) (ua :: u0 -> u0) (ub :: Int -> u0 -> u0) -> u3; _NO_DEFLT_ } _N_ #-} where
floatRadix :: a -> Integer
{-# GHC_PRAGMA {-meth-} _A_ 1 _U_ 12 _N_ _S_ "U(AASAAAAAAA)" {_A_ 1 _U_ 12 _N_ _N_ _F_ _IF_ARGS_ 1 1 X 1 _/\_ u0 -> \ (u1 :: u0 -> Integer) -> u1 _N_} _F_ _IF_ARGS_ 1 1 C 2 _/\_ u0 -> \ (u1 :: ({{RealFrac u0}}, {{Floating u0}}, u0 -> Integer, u0 -> Int, u0 -> (Int, Int), u0 -> (Integer, Int), Integer -> Int -> u0, u0 -> Int, u0 -> u0, Int -> u0 -> u0)) -> case u1 of { _ALG_ _TUP_10 (u2 :: {{RealFrac u0}}) (u3 :: {{Floating u0}}) (u4 :: u0 -> Integer) (u5 :: u0 -> Int) (u6 :: u0 -> (Int, Int)) (u7 :: u0 -> (Integer, Int)) (u8 :: Integer -> Int -> u0) (u9 :: u0 -> Int) (ua :: u0 -> u0) (ub :: Int -> u0 -> u0) -> u4; _NO_DEFLT_ } _N_
- {-defm-} _A_ 2 _U_ 02 _N_ _S_ _!_ _F_ _IF_ARGS_ 1 2 XX 3 _/\_ u0 -> \ (u1 :: {{RealFloat u0}}) (u2 :: u0) -> _APP_ _TYAPP_ patError# { (u0 -> Integer) } [ _NOREP_S_ "%DPreludeCore.RealFloat.floatRadix\"", u2 ] _N_ #-}
+ {-defm-} _A_ 2 _U_ 02 _N_ _S_ _!_ _N_ _N_ #-}
floatDigits :: a -> Int
{-# GHC_PRAGMA {-meth-} _A_ 1 _U_ 12 _N_ _S_ "U(AAASAAAAAA)" {_A_ 1 _U_ 12 _N_ _N_ _F_ _IF_ARGS_ 1 1 X 1 _/\_ u0 -> \ (u1 :: u0 -> Int) -> u1 _N_} _F_ _IF_ARGS_ 1 1 C 2 _/\_ u0 -> \ (u1 :: ({{RealFrac u0}}, {{Floating u0}}, u0 -> Integer, u0 -> Int, u0 -> (Int, Int), u0 -> (Integer, Int), Integer -> Int -> u0, u0 -> Int, u0 -> u0, Int -> u0 -> u0)) -> case u1 of { _ALG_ _TUP_10 (u2 :: {{RealFrac u0}}) (u3 :: {{Floating u0}}) (u4 :: u0 -> Integer) (u5 :: u0 -> Int) (u6 :: u0 -> (Int, Int)) (u7 :: u0 -> (Integer, Int)) (u8 :: Integer -> Int -> u0) (u9 :: u0 -> Int) (ua :: u0 -> u0) (ub :: Int -> u0 -> u0) -> u5; _NO_DEFLT_ } _N_
- {-defm-} _A_ 2 _U_ 02 _N_ _S_ _!_ _F_ _IF_ARGS_ 1 2 XX 3 _/\_ u0 -> \ (u1 :: {{RealFloat u0}}) (u2 :: u0) -> _APP_ _TYAPP_ patError# { (u0 -> Int) } [ _NOREP_S_ "%DPreludeCore.RealFloat.floatDigits\"", u2 ] _N_ #-}
+ {-defm-} _A_ 2 _U_ 02 _N_ _S_ _!_ _N_ _N_ #-}
floatRange :: a -> (Int, Int)
{-# GHC_PRAGMA {-meth-} _A_ 1 _U_ 12 _N_ _S_ "U(AAAASAAAAA)" {_A_ 1 _U_ 12 _N_ _N_ _F_ _IF_ARGS_ 1 1 X 1 _/\_ u0 -> \ (u1 :: u0 -> (Int, Int)) -> u1 _N_} _F_ _IF_ARGS_ 1 1 C 2 _/\_ u0 -> \ (u1 :: ({{RealFrac u0}}, {{Floating u0}}, u0 -> Integer, u0 -> Int, u0 -> (Int, Int), u0 -> (Integer, Int), Integer -> Int -> u0, u0 -> Int, u0 -> u0, Int -> u0 -> u0)) -> case u1 of { _ALG_ _TUP_10 (u2 :: {{RealFrac u0}}) (u3 :: {{Floating u0}}) (u4 :: u0 -> Integer) (u5 :: u0 -> Int) (u6 :: u0 -> (Int, Int)) (u7 :: u0 -> (Integer, Int)) (u8 :: Integer -> Int -> u0) (u9 :: u0 -> Int) (ua :: u0 -> u0) (ub :: Int -> u0 -> u0) -> u6; _NO_DEFLT_ } _N_
- {-defm-} _A_ 2 _U_ 02 _N_ _S_ _!_ _F_ _IF_ARGS_ 1 2 XX 3 _/\_ u0 -> \ (u1 :: {{RealFloat u0}}) (u2 :: u0) -> _APP_ _TYAPP_ patError# { (u0 -> (Int, Int)) } [ _NOREP_S_ "%DPreludeCore.RealFloat.floatRange\"", u2 ] _N_ #-}
+ {-defm-} _A_ 2 _U_ 02 _N_ _S_ _!_ _N_ _N_ #-}
decodeFloat :: a -> (Integer, Int)
{-# GHC_PRAGMA {-meth-} _A_ 1 _U_ 12 _N_ _S_ "U(AAAAASAAAA)" {_A_ 1 _U_ 12 _N_ _N_ _F_ _IF_ARGS_ 1 1 X 1 _/\_ u0 -> \ (u1 :: u0 -> (Integer, Int)) -> u1 _N_} _F_ _IF_ARGS_ 1 1 C 2 _/\_ u0 -> \ (u1 :: ({{RealFrac u0}}, {{Floating u0}}, u0 -> Integer, u0 -> Int, u0 -> (Int, Int), u0 -> (Integer, Int), Integer -> Int -> u0, u0 -> Int, u0 -> u0, Int -> u0 -> u0)) -> case u1 of { _ALG_ _TUP_10 (u2 :: {{RealFrac u0}}) (u3 :: {{Floating u0}}) (u4 :: u0 -> Integer) (u5 :: u0 -> Int) (u6 :: u0 -> (Int, Int)) (u7 :: u0 -> (Integer, Int)) (u8 :: Integer -> Int -> u0) (u9 :: u0 -> Int) (ua :: u0 -> u0) (ub :: Int -> u0 -> u0) -> u7; _NO_DEFLT_ } _N_
- {-defm-} _A_ 2 _U_ 02 _N_ _S_ _!_ _F_ _IF_ARGS_ 1 2 XX 3 _/\_ u0 -> \ (u1 :: {{RealFloat u0}}) (u2 :: u0) -> _APP_ _TYAPP_ patError# { (u0 -> (Integer, Int)) } [ _NOREP_S_ "%DPreludeCore.RealFloat.decodeFloat\"", u2 ] _N_ #-}
+ {-defm-} _A_ 2 _U_ 02 _N_ _S_ _!_ _N_ _N_ #-}
encodeFloat :: Integer -> Int -> a
{-# GHC_PRAGMA {-meth-} _A_ 1 _U_ 122 _N_ _S_ "U(AAAAAASAAA)" {_A_ 1 _U_ 122 _N_ _N_ _F_ _IF_ARGS_ 1 1 X 1 _/\_ u0 -> \ (u1 :: Integer -> Int -> u0) -> u1 _N_} _F_ _IF_ARGS_ 1 1 C 2 _/\_ u0 -> \ (u1 :: ({{RealFrac u0}}, {{Floating u0}}, u0 -> Integer, u0 -> Int, u0 -> (Int, Int), u0 -> (Integer, Int), Integer -> Int -> u0, u0 -> Int, u0 -> u0, Int -> u0 -> u0)) -> case u1 of { _ALG_ _TUP_10 (u2 :: {{RealFrac u0}}) (u3 :: {{Floating u0}}) (u4 :: u0 -> Integer) (u5 :: u0 -> Int) (u6 :: u0 -> (Int, Int)) (u7 :: u0 -> (Integer, Int)) (u8 :: Integer -> Int -> u0) (u9 :: u0 -> Int) (ua :: u0 -> u0) (ub :: Int -> u0 -> u0) -> u8; _NO_DEFLT_ } _N_
- {-defm-} _A_ 3 _U_ 022 _N_ _S_ _!_ _F_ _IF_ARGS_ 1 3 XXX 4 _/\_ u0 -> \ (u1 :: {{RealFloat u0}}) (u2 :: Integer) (u3 :: Int) -> _APP_ _TYAPP_ patError# { (Integer -> Int -> u0) } [ _NOREP_S_ "%DPreludeCore.RealFloat.encodeFloat\"", u2, u3 ] _N_ #-}
+ {-defm-} _A_ 3 _U_ 022 _N_ _S_ _!_ _N_ _N_ #-}
exponent :: a -> Int
{-# GHC_PRAGMA {-meth-} _A_ 1 _U_ 12 _N_ _S_ "U(AAAAAAASAA)" {_A_ 1 _U_ 12 _N_ _N_ _F_ _IF_ARGS_ 1 1 X 1 _/\_ u0 -> \ (u1 :: u0 -> Int) -> u1 _N_} _F_ _IF_ARGS_ 1 1 C 2 _/\_ u0 -> \ (u1 :: ({{RealFrac u0}}, {{Floating u0}}, u0 -> Integer, u0 -> Int, u0 -> (Int, Int), u0 -> (Integer, Int), Integer -> Int -> u0, u0 -> Int, u0 -> u0, Int -> u0 -> u0)) -> case u1 of { _ALG_ _TUP_10 (u2 :: {{RealFrac u0}}) (u3 :: {{Floating u0}}) (u4 :: u0 -> Integer) (u5 :: u0 -> Int) (u6 :: u0 -> (Int, Int)) (u7 :: u0 -> (Integer, Int)) (u8 :: Integer -> Int -> u0) (u9 :: u0 -> Int) (ua :: u0 -> u0) (ub :: Int -> u0 -> u0) -> u9; _NO_DEFLT_ } _N_
{-defm-} _A_ 2 _U_ 12 _N_ _S_ "U(AAALASAAAA)L" {_A_ 3 _U_ 112 _N_ _N_ _N_ _N_} _N_ _N_ #-}
class (Real a, Fractional a) => RealFrac a {-# GHC_PRAGMA {-superdicts-} _A_ 1 _U_ 1 _N_ _S_ "U(U(LLL)AAAAAA)" {_A_ 3 _U_ 222 _N_ _N_ _F_ _IF_ARGS_ 1 3 XXX 4 _/\_ u0 -> \ (u1 :: {{Num u0}}) (u2 :: {{Enum u0}}) (u3 :: u0 -> Ratio Integer) -> _!_ _TUP_3 [{{Num u0}}, {{Enum u0}}, (u0 -> Ratio Integer)] [u1, u2, u3] _N_} _F_ _IF_ARGS_ 1 1 C 2 _/\_ u0 -> \ (u1 :: ({{Real u0}}, {{Fractional u0}}, (_forall_ z$z1 =>{{Integral z$z1}} -> u0 -> (z$z1, u0)), (_forall_ z$z1 =>{{Integral z$z1}} -> u0 -> z$z1), (_forall_ z$z1 =>{{Integral z$z1}} -> u0 -> z$z1), (_forall_ z$z1 =>{{Integral z$z1}} -> u0 -> z$z1), (_forall_ z$z1 =>{{Integral z$z1}} -> u0 -> z$z1))) -> case u1 of { _ALG_ _TUP_7 (u2 :: {{Real u0}}) (u3 :: {{Fractional u0}}) (u4 :: _forall_ a$z1 =>{{Integral a$z1}} -> u0 -> (a$z1, u0)) (u5 :: _forall_ a$z1 =>{{Integral a$z1}} -> u0 -> a$z1) (u6 :: _forall_ a$z1 =>{{Integral a$z1}} -> u0 -> a$z1) (u7 :: _forall_ a$z1 =>{{Integral a$z1}} -> u0 -> a$z1) (u8 :: _forall_ a$z1 =>{{Integral a$z1}} -> u0 -> a$z1) -> u2; _NO_DEFLT_ } _N_, _A_ 1 _U_ 1 _N_ _S_ "U(AU(LLLL)AAAAA)" {_A_ 4 _U_ 2222 _N_ _N_ _F_ _IF_ARGS_ 1 4 XXXX 5 _/\_ u0 -> \ (u1 :: {{Num u0}}) (u2 :: u0 -> u0 -> u0) (u3 :: u0 -> u0) (u4 :: Ratio Integer -> u0) -> _!_ _TUP_4 [{{Num u0}}, (u0 -> u0 -> u0), (u0 -> u0), (Ratio Integer -> u0)] [u1, u2, u3, u4] _N_} _F_ _IF_ARGS_ 1 1 C 2 _/\_ u0 -> \ (u1 :: ({{Real u0}}, {{Fractional u0}}, (_forall_ z$z1 =>{{Integral z$z1}} -> u0 -> (z$z1, u0)), (_forall_ z$z1 =>{{Integral z$z1}} -> u0 -> z$z1), (_forall_ z$z1 =>{{Integral z$z1}} -> u0 -> z$z1), (_forall_ z$z1 =>{{Integral z$z1}} -> u0 -> z$z1), (_forall_ z$z1 =>{{Integral z$z1}} -> u0 -> z$z1))) -> case u1 of { _ALG_ _TUP_7 (u2 :: {{Real u0}}) (u3 :: {{Fractional u0}}) (u4 :: _forall_ a$z1 =>{{Integral a$z1}} -> u0 -> (a$z1, u0)) (u5 :: _forall_ a$z1 =>{{Integral a$z1}} -> u0 -> a$z1) (u6 :: _forall_ a$z1 =>{{Integral a$z1}} -> u0 -> a$z1) (u7 :: _forall_ a$z1 =>{{Integral a$z1}} -> u0 -> a$z1) (u8 :: _forall_ a$z1 =>{{Integral a$z1}} -> u0 -> a$z1) -> u3; _NO_DEFLT_ } _N_ #-} where
properFraction :: Integral b => a -> (b, a)
{-# GHC_PRAGMA {-meth-} _A_ 2 _U_ 122 _N_ _S_ "U(AASAAAA)L" {_A_ 2 _U_ 122 _N_ _N_ _F_ _IF_ARGS_ 2 2 XX 2 _/\_ u0 u1 -> \ (u2 :: _forall_ a$z1 =>{{Integral a$z1}} -> u0 -> (a$z1, u0)) (u3 :: {{Integral u1}}) -> _APP_ _TYAPP_ u2 { u1 } [ u3 ] _N_} _F_ _IF_ARGS_ 2 2 CX 3 _/\_ u0 u1 -> \ (u2 :: ({{Real u0}}, {{Fractional u0}}, (_forall_ z$z1 =>{{Integral z$z1}} -> u0 -> (z$z1, u0)), (_forall_ z$z1 =>{{Integral z$z1}} -> u0 -> z$z1), (_forall_ z$z1 =>{{Integral z$z1}} -> u0 -> z$z1), (_forall_ z$z1 =>{{Integral z$z1}} -> u0 -> z$z1), (_forall_ z$z1 =>{{Integral z$z1}} -> u0 -> z$z1))) (u3 :: {{Integral u1}}) -> case u2 of { _ALG_ _TUP_7 (u4 :: {{Real u0}}) (u5 :: {{Fractional u0}}) (u6 :: _forall_ a$z1 =>{{Integral a$z1}} -> u0 -> (a$z1, u0)) (u7 :: _forall_ a$z1 =>{{Integral a$z1}} -> u0 -> a$z1) (u8 :: _forall_ a$z1 =>{{Integral a$z1}} -> u0 -> a$z1) (u9 :: _forall_ a$z1 =>{{Integral a$z1}} -> u0 -> a$z1) (ua :: _forall_ a$z1 =>{{Integral a$z1}} -> u0 -> a$z1) -> _APP_ _TYAPP_ u6 { u1 } [ u3 ]; _NO_DEFLT_ } _N_
- {-defm-} _A_ 3 _U_ 002 _N_ _S_ _!_ _F_ _IF_ARGS_ 2 3 XXX 3 _/\_ u0 u1 -> \ (u2 :: {{RealFrac u0}}) (u3 :: {{Integral u1}}) (u4 :: u0) -> _APP_ _TYAPP_ patError# { (u0 -> (u1, u0)) } [ _NOREP_S_ "%DPreludeCore.RealFrac.properFraction\"", u4 ] _N_ #-}
+ {-defm-} _A_ 3 _U_ 002 _N_ _S_ _!_ _N_ _N_ #-}
truncate :: Integral b => a -> b
{-# GHC_PRAGMA {-meth-} _A_ 2 _U_ 122 _N_ _S_ "U(AAASAAA)L" {_A_ 2 _U_ 122 _N_ _N_ _F_ _IF_ARGS_ 2 2 XX 2 _/\_ u0 u1 -> \ (u2 :: _forall_ a$z1 =>{{Integral a$z1}} -> u0 -> a$z1) (u3 :: {{Integral u1}}) -> _APP_ _TYAPP_ u2 { u1 } [ u3 ] _N_} _F_ _IF_ARGS_ 2 2 CX 3 _/\_ u0 u1 -> \ (u2 :: ({{Real u0}}, {{Fractional u0}}, (_forall_ z$z1 =>{{Integral z$z1}} -> u0 -> (z$z1, u0)), (_forall_ z$z1 =>{{Integral z$z1}} -> u0 -> z$z1), (_forall_ z$z1 =>{{Integral z$z1}} -> u0 -> z$z1), (_forall_ z$z1 =>{{Integral z$z1}} -> u0 -> z$z1), (_forall_ z$z1 =>{{Integral z$z1}} -> u0 -> z$z1))) (u3 :: {{Integral u1}}) -> case u2 of { _ALG_ _TUP_7 (u4 :: {{Real u0}}) (u5 :: {{Fractional u0}}) (u6 :: _forall_ a$z1 =>{{Integral a$z1}} -> u0 -> (a$z1, u0)) (u7 :: _forall_ a$z1 =>{{Integral a$z1}} -> u0 -> a$z1) (u8 :: _forall_ a$z1 =>{{Integral a$z1}} -> u0 -> a$z1) (u9 :: _forall_ a$z1 =>{{Integral a$z1}} -> u0 -> a$z1) (ua :: _forall_ a$z1 =>{{Integral a$z1}} -> u0 -> a$z1) -> _APP_ _TYAPP_ u7 { u1 } [ u3 ]; _NO_DEFLT_ } _N_
- {-defm-} _A_ 2 _U_ 122 _N_ _S_ "U(AASAAAA)L" {_A_ 2 _U_ 222 _N_ _N_ _N_ _N_} _N_ _N_ #-}
+ {-defm-} _A_ 2 _U_ 122 _N_ _S_ "U(AASAAAA)L" {_A_ 2 _U_ 122 _N_ _N_ _N_ _N_} _N_ _N_ #-}
round :: Integral b => a -> b
{-# GHC_PRAGMA {-meth-} _A_ 2 _U_ 122 _N_ _S_ "U(AAAASAA)L" {_A_ 2 _U_ 122 _N_ _N_ _F_ _IF_ARGS_ 2 2 XX 2 _/\_ u0 u1 -> \ (u2 :: _forall_ a$z1 =>{{Integral a$z1}} -> u0 -> a$z1) (u3 :: {{Integral u1}}) -> _APP_ _TYAPP_ u2 { u1 } [ u3 ] _N_} _F_ _IF_ARGS_ 2 2 CX 3 _/\_ u0 u1 -> \ (u2 :: ({{Real u0}}, {{Fractional u0}}, (_forall_ z$z1 =>{{Integral z$z1}} -> u0 -> (z$z1, u0)), (_forall_ z$z1 =>{{Integral z$z1}} -> u0 -> z$z1), (_forall_ z$z1 =>{{Integral z$z1}} -> u0 -> z$z1), (_forall_ z$z1 =>{{Integral z$z1}} -> u0 -> z$z1), (_forall_ z$z1 =>{{Integral z$z1}} -> u0 -> z$z1))) (u3 :: {{Integral u1}}) -> case u2 of { _ALG_ _TUP_7 (u4 :: {{Real u0}}) (u5 :: {{Fractional u0}}) (u6 :: _forall_ a$z1 =>{{Integral a$z1}} -> u0 -> (a$z1, u0)) (u7 :: _forall_ a$z1 =>{{Integral a$z1}} -> u0 -> a$z1) (u8 :: _forall_ a$z1 =>{{Integral a$z1}} -> u0 -> a$z1) (u9 :: _forall_ a$z1 =>{{Integral a$z1}} -> u0 -> a$z1) (ua :: _forall_ a$z1 =>{{Integral a$z1}} -> u0 -> a$z1) -> _APP_ _TYAPP_ u8 { u1 } [ u3 ]; _NO_DEFLT_ } _N_
- {-defm-} _A_ 2 _U_ 122 _N_ _S_ "U(U(AU(U(ALAAAAAS)AAAA)A)LSAAAA)L" {_A_ 5 _U_ 222222 _N_ _N_ _N_ _N_} _N_ _N_ #-}
+ {-defm-} _A_ 2 _U_ 122 _N_ _S_ "U(U(AU(U(ALAAAAAS)AAAA)A)LSAAAA)L" {_A_ 5 _U_ 112122 _N_ _N_ _N_ _N_} _N_ _N_ #-}
ceiling :: Integral b => a -> b
{-# GHC_PRAGMA {-meth-} _A_ 2 _U_ 122 _N_ _S_ "U(AAAAASA)L" {_A_ 2 _U_ 122 _N_ _N_ _F_ _IF_ARGS_ 2 2 XX 2 _/\_ u0 u1 -> \ (u2 :: _forall_ a$z1 =>{{Integral a$z1}} -> u0 -> a$z1) (u3 :: {{Integral u1}}) -> _APP_ _TYAPP_ u2 { u1 } [ u3 ] _N_} _F_ _IF_ARGS_ 2 2 CX 3 _/\_ u0 u1 -> \ (u2 :: ({{Real u0}}, {{Fractional u0}}, (_forall_ z$z1 =>{{Integral z$z1}} -> u0 -> (z$z1, u0)), (_forall_ z$z1 =>{{Integral z$z1}} -> u0 -> z$z1), (_forall_ z$z1 =>{{Integral z$z1}} -> u0 -> z$z1), (_forall_ z$z1 =>{{Integral z$z1}} -> u0 -> z$z1), (_forall_ z$z1 =>{{Integral z$z1}} -> u0 -> z$z1))) (u3 :: {{Integral u1}}) -> case u2 of { _ALG_ _TUP_7 (u4 :: {{Real u0}}) (u5 :: {{Fractional u0}}) (u6 :: _forall_ a$z1 =>{{Integral a$z1}} -> u0 -> (a$z1, u0)) (u7 :: _forall_ a$z1 =>{{Integral a$z1}} -> u0 -> a$z1) (u8 :: _forall_ a$z1 =>{{Integral a$z1}} -> u0 -> a$z1) (u9 :: _forall_ a$z1 =>{{Integral a$z1}} -> u0 -> a$z1) (ua :: _forall_ a$z1 =>{{Integral a$z1}} -> u0 -> a$z1) -> _APP_ _TYAPP_ u9 { u1 } [ u3 ]; _NO_DEFLT_ } _N_
- {-defm-} _A_ 2 _U_ 122 _N_ _S_ "U(U(AU(U(AAAASAAA)AAAA)A)LSAAAA)L" {_A_ 4 _U_ 22222 _N_ _N_ _N_ _N_} _N_ _N_ #-}
+ {-defm-} _A_ 2 _U_ 122 _N_ _S_ "U(U(LU(U(AAAASAAA)AAAA)A)ASAAAA)L" {_A_ 4 _U_ 11122 _N_ _N_ _N_ _N_} _N_ _N_ #-}
floor :: Integral b => a -> b
{-# GHC_PRAGMA {-meth-} _A_ 2 _U_ 122 _N_ _S_ "U(AAAAAAS)L" {_A_ 2 _U_ 122 _N_ _N_ _F_ _IF_ARGS_ 2 2 XX 2 _/\_ u0 u1 -> \ (u2 :: _forall_ a$z1 =>{{Integral a$z1}} -> u0 -> a$z1) (u3 :: {{Integral u1}}) -> _APP_ _TYAPP_ u2 { u1 } [ u3 ] _N_} _F_ _IF_ARGS_ 2 2 CX 3 _/\_ u0 u1 -> \ (u2 :: ({{Real u0}}, {{Fractional u0}}, (_forall_ z$z1 =>{{Integral z$z1}} -> u0 -> (z$z1, u0)), (_forall_ z$z1 =>{{Integral z$z1}} -> u0 -> z$z1), (_forall_ z$z1 =>{{Integral z$z1}} -> u0 -> z$z1), (_forall_ z$z1 =>{{Integral z$z1}} -> u0 -> z$z1), (_forall_ z$z1 =>{{Integral z$z1}} -> u0 -> z$z1))) (u3 :: {{Integral u1}}) -> case u2 of { _ALG_ _TUP_7 (u4 :: {{Real u0}}) (u5 :: {{Fractional u0}}) (u6 :: _forall_ a$z1 =>{{Integral a$z1}} -> u0 -> (a$z1, u0)) (u7 :: _forall_ a$z1 =>{{Integral a$z1}} -> u0 -> a$z1) (u8 :: _forall_ a$z1 =>{{Integral a$z1}} -> u0 -> a$z1) (u9 :: _forall_ a$z1 =>{{Integral a$z1}} -> u0 -> a$z1) (ua :: _forall_ a$z1 =>{{Integral a$z1}} -> u0 -> a$z1) -> _APP_ _TYAPP_ ua { u1 } [ u3 ]; _NO_DEFLT_ } _N_
- {-defm-} _A_ 2 _U_ 122 _N_ _S_ "U(U(AU(U(ASAAAAAA)AAAA)A)LSAAAA)L" {_A_ 4 _U_ 22222 _N_ _N_ _N_ _N_} _N_ _N_ #-}
+ {-defm-} _A_ 2 _U_ 122 _N_ _S_ "U(U(LU(U(ASAAAAAA)AAAA)A)ASAAAA)L" {_A_ 4 _U_ 11122 _N_ _N_ _N_ _N_} _N_ _N_ #-}
class Text a where
readsPrec :: Int -> [Char] -> [(a, [Char])]
{-# GHC_PRAGMA {-meth-} _A_ 1 _U_ 122 _N_ _S_ "U(SAAA)" {_A_ 1 _U_ 122 _N_ _N_ _F_ _IF_ARGS_ 1 1 X 1 _/\_ u0 -> \ (u1 :: Int -> [Char] -> [(u0, [Char])]) -> u1 _N_} _F_ _IF_ARGS_ 1 1 C 2 _/\_ u0 -> \ (u1 :: (Int -> [Char] -> [(u0, [Char])], Int -> u0 -> [Char] -> [Char], [Char] -> [([u0], [Char])], [u0] -> [Char] -> [Char])) -> case u1 of { _ALG_ _TUP_4 (u2 :: Int -> [Char] -> [(u0, [Char])]) (u3 :: Int -> u0 -> [Char] -> [Char]) (u4 :: [Char] -> [([u0], [Char])]) (u5 :: [u0] -> [Char] -> [Char]) -> u2; _NO_DEFLT_ } _N_
- {-defm-} _A_ 3 _U_ 022 _N_ _S_ _!_ _F_ _IF_ARGS_ 1 3 XXX 4 _/\_ u0 -> \ (u1 :: {{Text u0}}) (u2 :: Int) (u3 :: [Char]) -> _APP_ _TYAPP_ patError# { (Int -> [Char] -> [(u0, [Char])]) } [ _NOREP_S_ "%DPreludeCore.Text.readsPrec\"", u2, u3 ] _N_ #-}
+ {-defm-} _A_ 3 _U_ 022 _N_ _S_ _!_ _N_ _N_ #-}
showsPrec :: Int -> a -> [Char] -> [Char]
{-# GHC_PRAGMA {-meth-} _A_ 1 _U_ 1222 _N_ _S_ "U(ASAA)" {_A_ 1 _U_ 1222 _N_ _N_ _F_ _IF_ARGS_ 1 1 X 1 _/\_ u0 -> \ (u1 :: Int -> u0 -> [Char] -> [Char]) -> u1 _N_} _F_ _IF_ARGS_ 1 1 C 2 _/\_ u0 -> \ (u1 :: (Int -> [Char] -> [(u0, [Char])], Int -> u0 -> [Char] -> [Char], [Char] -> [([u0], [Char])], [u0] -> [Char] -> [Char])) -> case u1 of { _ALG_ _TUP_4 (u2 :: Int -> [Char] -> [(u0, [Char])]) (u3 :: Int -> u0 -> [Char] -> [Char]) (u4 :: [Char] -> [([u0], [Char])]) (u5 :: [u0] -> [Char] -> [Char]) -> u3; _NO_DEFLT_ } _N_
- {-defm-} _A_ 4 _U_ 0222 _N_ _S_ _!_ _F_ _IF_ARGS_ 1 4 XXXX 5 _/\_ u0 -> \ (u1 :: {{Text u0}}) (u2 :: Int) (u3 :: u0) (u4 :: [Char]) -> _APP_ _TYAPP_ patError# { (Int -> u0 -> [Char] -> [Char]) } [ _NOREP_S_ "%DPreludeCore.Text.showsPrec\"", u2, u3, u4 ] _N_ #-}
+ {-defm-} _A_ 4 _U_ 0222 _N_ _S_ _!_ _N_ _N_ #-}
readList :: [Char] -> [([a], [Char])]
{-# GHC_PRAGMA {-meth-} _A_ 1 _U_ 12 _N_ _S_ "U(AASA)" {_A_ 1 _U_ 12 _N_ _N_ _F_ _IF_ARGS_ 1 1 X 1 _/\_ u0 -> \ (u1 :: [Char] -> [([u0], [Char])]) -> u1 _N_} _F_ _IF_ARGS_ 1 1 C 2 _/\_ u0 -> \ (u1 :: (Int -> [Char] -> [(u0, [Char])], Int -> u0 -> [Char] -> [Char], [Char] -> [([u0], [Char])], [u0] -> [Char] -> [Char])) -> case u1 of { _ALG_ _TUP_4 (u2 :: Int -> [Char] -> [(u0, [Char])]) (u3 :: Int -> u0 -> [Char] -> [Char]) (u4 :: [Char] -> [([u0], [Char])]) (u5 :: [u0] -> [Char] -> [Char]) -> u4; _NO_DEFLT_ } _N_
- {-defm-} _A_ 1 _U_ 22 _N_ _N_ _F_ _IF_ARGS_ 0 0 X 1 _ORIG_ PreludeCore _readList _N_ #-}
+ {-defm-} _A_ 1 _U_ 12 _N_ _N_ _N_ _N_ #-}
showList :: [a] -> [Char] -> [Char]
{-# GHC_PRAGMA {-meth-} _A_ 1 _U_ 122 _N_ _S_ "U(AAAS)" {_A_ 1 _U_ 122 _N_ _N_ _F_ _IF_ARGS_ 1 1 X 1 _/\_ u0 -> \ (u1 :: [u0] -> [Char] -> [Char]) -> u1 _N_} _F_ _IF_ARGS_ 1 1 C 2 _/\_ u0 -> \ (u1 :: (Int -> [Char] -> [(u0, [Char])], Int -> u0 -> [Char] -> [Char], [Char] -> [([u0], [Char])], [u0] -> [Char] -> [Char])) -> case u1 of { _ALG_ _TUP_4 (u2 :: Int -> [Char] -> [(u0, [Char])]) (u3 :: Int -> u0 -> [Char] -> [Char]) (u4 :: [Char] -> [([u0], [Char])]) (u5 :: [u0] -> [Char] -> [Char]) -> u5; _NO_DEFLT_ } _N_
- {-defm-} _A_ 1 _U_ 212 _N_ _N_ _F_ _IF_ARGS_ 0 0 X 1 _ORIG_ PreludeCore _showList _N_ #-}
+ {-defm-} _A_ 1 _U_ 112 _N_ _N_ _N_ _N_ #-}
class _CCallable a
class _CReturnable a
data Bin
-{-# GHC_PRAGMA INTERFACE VERSION 5 #-}
+{-# GHC_PRAGMA INTERFACE VERSION 6 #-}
interface PreludeCore where
import PreludeBuiltin(Bin, Char(..), Int(..), Integer(..), List(..), Tuple2, _CMP_TAG(..))
import PreludeRatio(Ratio(..))
class Binary a where
readBin :: Bin -> (a, Bin)
{-# GHC_PRAGMA {-meth-} _A_ 1 _U_ 12 _N_ _S_ "U(SA)" {_A_ 1 _U_ 12 _N_ _N_ _F_ _IF_ARGS_ 1 1 X 1 _/\_ u0 -> \ (u1 :: Bin -> (u0, Bin)) -> u1 _N_} _F_ _IF_ARGS_ 1 1 C 2 _/\_ u0 -> \ (u1 :: (Bin -> (u0, Bin), u0 -> Bin -> Bin)) -> case u1 of { _ALG_ _TUP_2 (u2 :: Bin -> (u0, Bin)) (u3 :: u0 -> Bin -> Bin) -> u2; _NO_DEFLT_ } _N_
- {-defm-} _A_ 2 _U_ 02 _N_ _S_ _!_ _F_ _IF_ARGS_ 1 2 XX 3 _/\_ u0 -> \ (u1 :: {{Binary u0}}) (u2 :: Bin) -> _APP_ _TYAPP_ patError# { (Bin -> (u0, Bin)) } [ _NOREP_S_ "%DPreludeCore.Binary.readBin\"", u2 ] _N_ #-}
+ {-defm-} _A_ 2 _U_ 02 _N_ _S_ _!_ _N_ _N_ #-}
showBin :: a -> Bin -> Bin
{-# GHC_PRAGMA {-meth-} _A_ 1 _U_ 122 _N_ _S_ "U(AS)" {_A_ 1 _U_ 122 _N_ _N_ _F_ _IF_ARGS_ 1 1 X 1 _/\_ u0 -> \ (u1 :: u0 -> Bin -> Bin) -> u1 _N_} _F_ _IF_ARGS_ 1 1 C 2 _/\_ u0 -> \ (u1 :: (Bin -> (u0, Bin), u0 -> Bin -> Bin)) -> case u1 of { _ALG_ _TUP_2 (u2 :: Bin -> (u0, Bin)) (u3 :: u0 -> Bin -> Bin) -> u3; _NO_DEFLT_ } _N_
- {-defm-} _A_ 3 _U_ 022 _N_ _S_ _!_ _F_ _IF_ARGS_ 1 3 XXX 4 _/\_ u0 -> \ (u1 :: {{Binary u0}}) (u2 :: u0) (u3 :: Bin) -> _APP_ _TYAPP_ patError# { (u0 -> Bin -> Bin) } [ _NOREP_S_ "%DPreludeCore.Binary.showBin\"", u2, u3 ] _N_ #-}
+ {-defm-} _A_ 3 _U_ 022 _N_ _S_ _!_ _N_ _N_ #-}
class (Ord a) => Enum a {-# GHC_PRAGMA {-superdicts-} _A_ 1 _U_ 1 _N_ _S_ "U(U(LLLLLLLL)AAAA)" {_A_ 1 _U_ 1 _N_ _N_ _F_ _IF_ARGS_ 1 1 X 1 _/\_ u0 -> \ (u1 :: {{Ord u0}}) -> u1 _N_} _F_ _IF_ARGS_ 1 1 C 2 _/\_ u0 -> \ (u1 :: ({{Ord u0}}, u0 -> [u0], u0 -> u0 -> [u0], u0 -> u0 -> [u0], u0 -> u0 -> u0 -> [u0])) -> case u1 of { _ALG_ _TUP_5 (u2 :: {{Ord u0}}) (u3 :: u0 -> [u0]) (u4 :: u0 -> u0 -> [u0]) (u5 :: u0 -> u0 -> [u0]) (u6 :: u0 -> u0 -> u0 -> [u0]) -> u2; _NO_DEFLT_ } _N_ #-} where
enumFrom :: a -> [a]
{-# GHC_PRAGMA {-meth-} _A_ 1 _U_ 12 _N_ _S_ "U(ASAAA)" {_A_ 1 _U_ 12 _N_ _N_ _F_ _IF_ARGS_ 1 1 X 1 _/\_ u0 -> \ (u1 :: u0 -> [u0]) -> u1 _N_} _F_ _IF_ARGS_ 1 1 C 2 _/\_ u0 -> \ (u1 :: ({{Ord u0}}, u0 -> [u0], u0 -> u0 -> [u0], u0 -> u0 -> [u0], u0 -> u0 -> u0 -> [u0])) -> case u1 of { _ALG_ _TUP_5 (u2 :: {{Ord u0}}) (u3 :: u0 -> [u0]) (u4 :: u0 -> u0 -> [u0]) (u5 :: u0 -> u0 -> [u0]) (u6 :: u0 -> u0 -> u0 -> [u0]) -> u3; _NO_DEFLT_ } _N_
- {-defm-} _A_ 2 _U_ 02 _N_ _S_ _!_ _F_ _IF_ARGS_ 1 2 XX 3 _/\_ u0 -> \ (u1 :: {{Enum u0}}) (u2 :: u0) -> _APP_ _TYAPP_ patError# { (u0 -> [u0]) } [ _NOREP_S_ "%DPreludeCore.Enum.enumFrom\"", u2 ] _N_ #-}
+ {-defm-} _A_ 2 _U_ 02 _N_ _S_ _!_ _N_ _N_ #-}
enumFromThen :: a -> a -> [a]
{-# GHC_PRAGMA {-meth-} _A_ 1 _U_ 122 _N_ _S_ "U(AASAA)" {_A_ 1 _U_ 122 _N_ _N_ _F_ _IF_ARGS_ 1 1 X 1 _/\_ u0 -> \ (u1 :: u0 -> u0 -> [u0]) -> u1 _N_} _F_ _IF_ARGS_ 1 1 C 2 _/\_ u0 -> \ (u1 :: ({{Ord u0}}, u0 -> [u0], u0 -> u0 -> [u0], u0 -> u0 -> [u0], u0 -> u0 -> u0 -> [u0])) -> case u1 of { _ALG_ _TUP_5 (u2 :: {{Ord u0}}) (u3 :: u0 -> [u0]) (u4 :: u0 -> u0 -> [u0]) (u5 :: u0 -> u0 -> [u0]) (u6 :: u0 -> u0 -> u0 -> [u0]) -> u4; _NO_DEFLT_ } _N_
- {-defm-} _A_ 3 _U_ 022 _N_ _S_ _!_ _F_ _IF_ARGS_ 1 3 XXX 4 _/\_ u0 -> \ (u1 :: {{Enum u0}}) (u2 :: u0) (u3 :: u0) -> _APP_ _TYAPP_ patError# { (u0 -> u0 -> [u0]) } [ _NOREP_S_ "%DPreludeCore.Enum.enumFromThen\"", u2, u3 ] _N_ #-}
+ {-defm-} _A_ 3 _U_ 022 _N_ _S_ _!_ _N_ _N_ #-}
enumFromTo :: a -> a -> [a]
{-# GHC_PRAGMA {-meth-} _A_ 1 _U_ 122 _N_ _S_ "U(AAASA)" {_A_ 1 _U_ 122 _N_ _N_ _F_ _IF_ARGS_ 1 1 X 1 _/\_ u0 -> \ (u1 :: u0 -> u0 -> [u0]) -> u1 _N_} _F_ _IF_ARGS_ 1 1 C 2 _/\_ u0 -> \ (u1 :: ({{Ord u0}}, u0 -> [u0], u0 -> u0 -> [u0], u0 -> u0 -> [u0], u0 -> u0 -> u0 -> [u0])) -> case u1 of { _ALG_ _TUP_5 (u2 :: {{Ord u0}}) (u3 :: u0 -> [u0]) (u4 :: u0 -> u0 -> [u0]) (u5 :: u0 -> u0 -> [u0]) (u6 :: u0 -> u0 -> u0 -> [u0]) -> u5; _NO_DEFLT_ } _N_
{-defm-} _A_ 3 _U_ 122 _N_ _S_ "U(LSAAA)LL" {_A_ 4 _U_ 1122 _N_ _N_ _N_ _N_} _N_ _N_ #-}
class Eq a where
(==) :: a -> a -> Bool
{-# GHC_PRAGMA {-meth-} _A_ 1 _U_ 122 _N_ _S_ "U(SA)" {_A_ 1 _U_ 122 _N_ _N_ _F_ _IF_ARGS_ 1 1 X 1 _/\_ u0 -> \ (u1 :: u0 -> u0 -> Bool) -> u1 _N_} _F_ _IF_ARGS_ 1 1 C 2 _/\_ u0 -> \ (u1 :: (u0 -> u0 -> Bool, u0 -> u0 -> Bool)) -> case u1 of { _ALG_ _TUP_2 (u2 :: u0 -> u0 -> Bool) (u3 :: u0 -> u0 -> Bool) -> u2; _NO_DEFLT_ } _N_
- {-defm-} _A_ 3 _U_ 022 _N_ _S_ _!_ _F_ _IF_ARGS_ 1 3 XXX 4 _/\_ u0 -> \ (u1 :: {{Eq u0}}) (u2 :: u0) (u3 :: u0) -> _APP_ _TYAPP_ patError# { (u0 -> u0 -> Bool) } [ _NOREP_S_ "%DPreludeCore.Eq.(==)\"", u2, u3 ] _N_ #-}
+ {-defm-} _A_ 3 _U_ 022 _N_ _S_ _!_ _N_ _N_ #-}
(/=) :: a -> a -> Bool
{-# GHC_PRAGMA {-meth-} _A_ 1 _U_ 122 _N_ _S_ "U(AS)" {_A_ 1 _U_ 122 _N_ _N_ _F_ _IF_ARGS_ 1 1 X 1 _/\_ u0 -> \ (u1 :: u0 -> u0 -> Bool) -> u1 _N_} _F_ _IF_ARGS_ 1 1 C 2 _/\_ u0 -> \ (u1 :: (u0 -> u0 -> Bool, u0 -> u0 -> Bool)) -> case u1 of { _ALG_ _TUP_2 (u2 :: u0 -> u0 -> Bool) (u3 :: u0 -> u0 -> Bool) -> u3; _NO_DEFLT_ } _N_
{-defm-} _A_ 3 _U_ 122 _N_ _S_ "U(SA)LL" {_A_ 3 _U_ 122 _N_ _N_ _N_ _N_} _N_ _N_ #-}
class (Fractional a) => Floating a {-# GHC_PRAGMA {-superdicts-} _A_ 1 _U_ 1 _N_ _S_ "U(U(LLLL)AAAAAAAAAAAAAAAAAA)" {_A_ 4 _U_ 2222 _N_ _N_ _F_ _IF_ARGS_ 1 4 XXXX 5 _/\_ u0 -> \ (u1 :: {{Num u0}}) (u2 :: u0 -> u0 -> u0) (u3 :: u0 -> u0) (u4 :: Ratio Integer -> u0) -> _!_ _TUP_4 [{{Num u0}}, (u0 -> u0 -> u0), (u0 -> u0), (Ratio Integer -> u0)] [u1, u2, u3, u4] _N_} _F_ _IF_ARGS_ 1 1 C 2 _/\_ u0 -> \ (u1 :: ({{Fractional u0}}, u0, u0 -> u0, u0 -> u0, u0 -> u0, u0 -> u0 -> u0, u0 -> u0 -> u0, u0 -> u0, u0 -> u0, u0 -> u0, u0 -> u0, u0 -> u0, u0 -> u0, u0 -> u0, u0 -> u0, u0 -> u0, u0 -> u0, u0 -> u0, u0 -> u0)) -> case u1 of { _ALG_ _TUP_19 (u2 :: {{Fractional u0}}) (u3 :: u0) (u4 :: u0 -> u0) (u5 :: u0 -> u0) (u6 :: u0 -> u0) (u7 :: u0 -> u0 -> u0) (u8 :: u0 -> u0 -> u0) (u9 :: u0 -> u0) (ua :: u0 -> u0) (ub :: u0 -> u0) (uc :: u0 -> u0) (ud :: u0 -> u0) (ue :: u0 -> u0) (uf :: u0 -> u0) (ug :: u0 -> u0) (uh :: u0 -> u0) (ui :: u0 -> u0) (uj :: u0 -> u0) (uk :: u0 -> u0) -> u2; _NO_DEFLT_ } _N_ #-} where
pi :: a
{-# GHC_PRAGMA {-meth-} _A_ 1 _U_ 1 _N_ _S_ "U(ASAAAAAAAAAAAAAAAAA)" {_A_ 1 _U_ 1 _N_ _N_ _F_ _IF_ARGS_ 1 1 X 1 _/\_ u0 -> \ (u1 :: u0) -> u1 _N_} _F_ _IF_ARGS_ 1 1 C 2 _/\_ u0 -> \ (u1 :: ({{Fractional u0}}, u0, u0 -> u0, u0 -> u0, u0 -> u0, u0 -> u0 -> u0, u0 -> u0 -> u0, u0 -> u0, u0 -> u0, u0 -> u0, u0 -> u0, u0 -> u0, u0 -> u0, u0 -> u0, u0 -> u0, u0 -> u0, u0 -> u0, u0 -> u0, u0 -> u0)) -> case u1 of { _ALG_ _TUP_19 (u2 :: {{Fractional u0}}) (u3 :: u0) (u4 :: u0 -> u0) (u5 :: u0 -> u0) (u6 :: u0 -> u0) (u7 :: u0 -> u0 -> u0) (u8 :: u0 -> u0 -> u0) (u9 :: u0 -> u0) (ua :: u0 -> u0) (ub :: u0 -> u0) (uc :: u0 -> u0) (ud :: u0 -> u0) (ue :: u0 -> u0) (uf :: u0 -> u0) (ug :: u0 -> u0) (uh :: u0 -> u0) (ui :: u0 -> u0) (uj :: u0 -> u0) (uk :: u0 -> u0) -> u3; _NO_DEFLT_ } _N_
- {-defm-} _A_ 1 _U_ 0 _N_ _S_ _!_ _F_ _IF_ARGS_ 1 1 X 2 _/\_ u0 -> \ (u1 :: {{Floating u0}}) -> _APP_ _TYAPP_ patError# { u0 } [ _NOREP_S_ "%DPreludeCore.Floating.pi\"" ] _N_ #-}
+ {-defm-} _A_ 1 _U_ 0 _N_ _S_ _!_ _N_ _N_ #-}
exp :: a -> a
{-# GHC_PRAGMA {-meth-} _A_ 1 _U_ 12 _N_ _S_ "U(AASAAAAAAAAAAAAAAAA)" {_A_ 1 _U_ 12 _N_ _N_ _F_ _IF_ARGS_ 1 1 X 1 _/\_ u0 -> \ (u1 :: u0 -> u0) -> u1 _N_} _F_ _IF_ARGS_ 1 1 C 2 _/\_ u0 -> \ (u1 :: ({{Fractional u0}}, u0, u0 -> u0, u0 -> u0, u0 -> u0, u0 -> u0 -> u0, u0 -> u0 -> u0, u0 -> u0, u0 -> u0, u0 -> u0, u0 -> u0, u0 -> u0, u0 -> u0, u0 -> u0, u0 -> u0, u0 -> u0, u0 -> u0, u0 -> u0, u0 -> u0)) -> case u1 of { _ALG_ _TUP_19 (u2 :: {{Fractional u0}}) (u3 :: u0) (u4 :: u0 -> u0) (u5 :: u0 -> u0) (u6 :: u0 -> u0) (u7 :: u0 -> u0 -> u0) (u8 :: u0 -> u0 -> u0) (u9 :: u0 -> u0) (ua :: u0 -> u0) (ub :: u0 -> u0) (uc :: u0 -> u0) (ud :: u0 -> u0) (ue :: u0 -> u0) (uf :: u0 -> u0) (ug :: u0 -> u0) (uh :: u0 -> u0) (ui :: u0 -> u0) (uj :: u0 -> u0) (uk :: u0 -> u0) -> u4; _NO_DEFLT_ } _N_
- {-defm-} _A_ 2 _U_ 02 _N_ _S_ _!_ _F_ _IF_ARGS_ 1 2 XX 3 _/\_ u0 -> \ (u1 :: {{Floating u0}}) (u2 :: u0) -> _APP_ _TYAPP_ patError# { (u0 -> u0) } [ _NOREP_S_ "%DPreludeCore.Floating.exp\"", u2 ] _N_ #-}
+ {-defm-} _A_ 2 _U_ 02 _N_ _S_ _!_ _N_ _N_ #-}
log :: a -> a
{-# GHC_PRAGMA {-meth-} _A_ 1 _U_ 12 _N_ _S_ "U(AAASAAAAAAAAAAAAAAA)" {_A_ 1 _U_ 12 _N_ _N_ _F_ _IF_ARGS_ 1 1 X 1 _/\_ u0 -> \ (u1 :: u0 -> u0) -> u1 _N_} _F_ _IF_ARGS_ 1 1 C 2 _/\_ u0 -> \ (u1 :: ({{Fractional u0}}, u0, u0 -> u0, u0 -> u0, u0 -> u0, u0 -> u0 -> u0, u0 -> u0 -> u0, u0 -> u0, u0 -> u0, u0 -> u0, u0 -> u0, u0 -> u0, u0 -> u0, u0 -> u0, u0 -> u0, u0 -> u0, u0 -> u0, u0 -> u0, u0 -> u0)) -> case u1 of { _ALG_ _TUP_19 (u2 :: {{Fractional u0}}) (u3 :: u0) (u4 :: u0 -> u0) (u5 :: u0 -> u0) (u6 :: u0 -> u0) (u7 :: u0 -> u0 -> u0) (u8 :: u0 -> u0 -> u0) (u9 :: u0 -> u0) (ua :: u0 -> u0) (ub :: u0 -> u0) (uc :: u0 -> u0) (ud :: u0 -> u0) (ue :: u0 -> u0) (uf :: u0 -> u0) (ug :: u0 -> u0) (uh :: u0 -> u0) (ui :: u0 -> u0) (uj :: u0 -> u0) (uk :: u0 -> u0) -> u5; _NO_DEFLT_ } _N_
- {-defm-} _A_ 2 _U_ 02 _N_ _S_ _!_ _F_ _IF_ARGS_ 1 2 XX 3 _/\_ u0 -> \ (u1 :: {{Floating u0}}) (u2 :: u0) -> _APP_ _TYAPP_ patError# { (u0 -> u0) } [ _NOREP_S_ "%DPreludeCore.Floating.log\"", u2 ] _N_ #-}
+ {-defm-} _A_ 2 _U_ 02 _N_ _S_ _!_ _N_ _N_ #-}
sqrt :: a -> a
{-# GHC_PRAGMA {-meth-} _A_ 1 _U_ 12 _N_ _S_ "U(AAAASAAAAAAAAAAAAAA)" {_A_ 1 _U_ 12 _N_ _N_ _F_ _IF_ARGS_ 1 1 X 1 _/\_ u0 -> \ (u1 :: u0 -> u0) -> u1 _N_} _F_ _IF_ARGS_ 1 1 C 2 _/\_ u0 -> \ (u1 :: ({{Fractional u0}}, u0, u0 -> u0, u0 -> u0, u0 -> u0, u0 -> u0 -> u0, u0 -> u0 -> u0, u0 -> u0, u0 -> u0, u0 -> u0, u0 -> u0, u0 -> u0, u0 -> u0, u0 -> u0, u0 -> u0, u0 -> u0, u0 -> u0, u0 -> u0, u0 -> u0)) -> case u1 of { _ALG_ _TUP_19 (u2 :: {{Fractional u0}}) (u3 :: u0) (u4 :: u0 -> u0) (u5 :: u0 -> u0) (u6 :: u0 -> u0) (u7 :: u0 -> u0 -> u0) (u8 :: u0 -> u0 -> u0) (u9 :: u0 -> u0) (ua :: u0 -> u0) (ub :: u0 -> u0) (uc :: u0 -> u0) (ud :: u0 -> u0) (ue :: u0 -> u0) (uf :: u0 -> u0) (ug :: u0 -> u0) (uh :: u0 -> u0) (ui :: u0 -> u0) (uj :: u0 -> u0) (uk :: u0 -> u0) -> u6; _NO_DEFLT_ } _N_
{-defm-} _A_ 1 _U_ 12 _N_ _S_ "U(LAAAASAAAAAAAAAAAAA)" {_A_ 2 _U_ 112 _N_ _N_ _N_ _N_} _N_ _N_ #-}
{-defm-} _A_ 3 _U_ 122 _N_ _S_ "U(U(ASAA)AALAAAAAAAAAAAAAAA)LL" {_A_ 4 _U_ 1222 _N_ _N_ _N_ _N_} _N_ _N_ #-}
sin :: a -> a
{-# GHC_PRAGMA {-meth-} _A_ 1 _U_ 12 _N_ _S_ "U(AAAAAAASAAAAAAAAAAA)" {_A_ 1 _U_ 12 _N_ _N_ _F_ _IF_ARGS_ 1 1 X 1 _/\_ u0 -> \ (u1 :: u0 -> u0) -> u1 _N_} _F_ _IF_ARGS_ 1 1 C 2 _/\_ u0 -> \ (u1 :: ({{Fractional u0}}, u0, u0 -> u0, u0 -> u0, u0 -> u0, u0 -> u0 -> u0, u0 -> u0 -> u0, u0 -> u0, u0 -> u0, u0 -> u0, u0 -> u0, u0 -> u0, u0 -> u0, u0 -> u0, u0 -> u0, u0 -> u0, u0 -> u0, u0 -> u0, u0 -> u0)) -> case u1 of { _ALG_ _TUP_19 (u2 :: {{Fractional u0}}) (u3 :: u0) (u4 :: u0 -> u0) (u5 :: u0 -> u0) (u6 :: u0 -> u0) (u7 :: u0 -> u0 -> u0) (u8 :: u0 -> u0 -> u0) (u9 :: u0 -> u0) (ua :: u0 -> u0) (ub :: u0 -> u0) (uc :: u0 -> u0) (ud :: u0 -> u0) (ue :: u0 -> u0) (uf :: u0 -> u0) (ug :: u0 -> u0) (uh :: u0 -> u0) (ui :: u0 -> u0) (uj :: u0 -> u0) (uk :: u0 -> u0) -> u9; _NO_DEFLT_ } _N_
- {-defm-} _A_ 2 _U_ 02 _N_ _S_ _!_ _F_ _IF_ARGS_ 1 2 XX 3 _/\_ u0 -> \ (u1 :: {{Floating u0}}) (u2 :: u0) -> _APP_ _TYAPP_ patError# { (u0 -> u0) } [ _NOREP_S_ "%DPreludeCore.Floating.sin\"", u2 ] _N_ #-}
+ {-defm-} _A_ 2 _U_ 02 _N_ _S_ _!_ _N_ _N_ #-}
cos :: a -> a
{-# GHC_PRAGMA {-meth-} _A_ 1 _U_ 12 _N_ _S_ "U(AAAAAAAASAAAAAAAAAA)" {_A_ 1 _U_ 12 _N_ _N_ _F_ _IF_ARGS_ 1 1 X 1 _/\_ u0 -> \ (u1 :: u0 -> u0) -> u1 _N_} _F_ _IF_ARGS_ 1 1 C 2 _/\_ u0 -> \ (u1 :: ({{Fractional u0}}, u0, u0 -> u0, u0 -> u0, u0 -> u0, u0 -> u0 -> u0, u0 -> u0 -> u0, u0 -> u0, u0 -> u0, u0 -> u0, u0 -> u0, u0 -> u0, u0 -> u0, u0 -> u0, u0 -> u0, u0 -> u0, u0 -> u0, u0 -> u0, u0 -> u0)) -> case u1 of { _ALG_ _TUP_19 (u2 :: {{Fractional u0}}) (u3 :: u0) (u4 :: u0 -> u0) (u5 :: u0 -> u0) (u6 :: u0 -> u0) (u7 :: u0 -> u0 -> u0) (u8 :: u0 -> u0 -> u0) (u9 :: u0 -> u0) (ua :: u0 -> u0) (ub :: u0 -> u0) (uc :: u0 -> u0) (ud :: u0 -> u0) (ue :: u0 -> u0) (uf :: u0 -> u0) (ug :: u0 -> u0) (uh :: u0 -> u0) (ui :: u0 -> u0) (uj :: u0 -> u0) (uk :: u0 -> u0) -> ua; _NO_DEFLT_ } _N_
- {-defm-} _A_ 2 _U_ 02 _N_ _S_ _!_ _F_ _IF_ARGS_ 1 2 XX 3 _/\_ u0 -> \ (u1 :: {{Floating u0}}) (u2 :: u0) -> _APP_ _TYAPP_ patError# { (u0 -> u0) } [ _NOREP_S_ "%DPreludeCore.Floating.cos\"", u2 ] _N_ #-}
+ {-defm-} _A_ 2 _U_ 02 _N_ _S_ _!_ _N_ _N_ #-}
tan :: a -> a
{-# GHC_PRAGMA {-meth-} _A_ 1 _U_ 12 _N_ _S_ "U(AAAAAAAAASAAAAAAAAA)" {_A_ 1 _U_ 12 _N_ _N_ _F_ _IF_ARGS_ 1 1 X 1 _/\_ u0 -> \ (u1 :: u0 -> u0) -> u1 _N_} _F_ _IF_ARGS_ 1 1 C 2 _/\_ u0 -> \ (u1 :: ({{Fractional u0}}, u0, u0 -> u0, u0 -> u0, u0 -> u0, u0 -> u0 -> u0, u0 -> u0 -> u0, u0 -> u0, u0 -> u0, u0 -> u0, u0 -> u0, u0 -> u0, u0 -> u0, u0 -> u0, u0 -> u0, u0 -> u0, u0 -> u0, u0 -> u0, u0 -> u0)) -> case u1 of { _ALG_ _TUP_19 (u2 :: {{Fractional u0}}) (u3 :: u0) (u4 :: u0 -> u0) (u5 :: u0 -> u0) (u6 :: u0 -> u0) (u7 :: u0 -> u0 -> u0) (u8 :: u0 -> u0 -> u0) (u9 :: u0 -> u0) (ua :: u0 -> u0) (ub :: u0 -> u0) (uc :: u0 -> u0) (ud :: u0 -> u0) (ue :: u0 -> u0) (uf :: u0 -> u0) (ug :: u0 -> u0) (uh :: u0 -> u0) (ui :: u0 -> u0) (uj :: u0 -> u0) (uk :: u0 -> u0) -> ub; _NO_DEFLT_ } _N_
{-defm-} _A_ 2 _U_ 12 _N_ _S_ "U(U(ASAA)AAAAAALLAAAAAAAAAA)L" {_A_ 4 _U_ 1112 _N_ _N_ _N_ _N_} _N_ _N_ #-}
asin :: a -> a
{-# GHC_PRAGMA {-meth-} _A_ 1 _U_ 12 _N_ _S_ "U(AAAAAAAAAASAAAAAAAA)" {_A_ 1 _U_ 12 _N_ _N_ _F_ _IF_ARGS_ 1 1 X 1 _/\_ u0 -> \ (u1 :: u0 -> u0) -> u1 _N_} _F_ _IF_ARGS_ 1 1 C 2 _/\_ u0 -> \ (u1 :: ({{Fractional u0}}, u0, u0 -> u0, u0 -> u0, u0 -> u0, u0 -> u0 -> u0, u0 -> u0 -> u0, u0 -> u0, u0 -> u0, u0 -> u0, u0 -> u0, u0 -> u0, u0 -> u0, u0 -> u0, u0 -> u0, u0 -> u0, u0 -> u0, u0 -> u0, u0 -> u0)) -> case u1 of { _ALG_ _TUP_19 (u2 :: {{Fractional u0}}) (u3 :: u0) (u4 :: u0 -> u0) (u5 :: u0 -> u0) (u6 :: u0 -> u0) (u7 :: u0 -> u0 -> u0) (u8 :: u0 -> u0 -> u0) (u9 :: u0 -> u0) (ua :: u0 -> u0) (ub :: u0 -> u0) (uc :: u0 -> u0) (ud :: u0 -> u0) (ue :: u0 -> u0) (uf :: u0 -> u0) (ug :: u0 -> u0) (uh :: u0 -> u0) (ui :: u0 -> u0) (uj :: u0 -> u0) (uk :: u0 -> u0) -> uc; _NO_DEFLT_ } _N_
- {-defm-} _A_ 2 _U_ 02 _N_ _S_ _!_ _F_ _IF_ARGS_ 1 2 XX 3 _/\_ u0 -> \ (u1 :: {{Floating u0}}) (u2 :: u0) -> _APP_ _TYAPP_ patError# { (u0 -> u0) } [ _NOREP_S_ "%DPreludeCore.Floating.asin\"", u2 ] _N_ #-}
+ {-defm-} _A_ 2 _U_ 02 _N_ _S_ _!_ _N_ _N_ #-}
acos :: a -> a
{-# GHC_PRAGMA {-meth-} _A_ 1 _U_ 12 _N_ _S_ "U(AAAAAAAAAAASAAAAAAA)" {_A_ 1 _U_ 12 _N_ _N_ _F_ _IF_ARGS_ 1 1 X 1 _/\_ u0 -> \ (u1 :: u0 -> u0) -> u1 _N_} _F_ _IF_ARGS_ 1 1 C 2 _/\_ u0 -> \ (u1 :: ({{Fractional u0}}, u0, u0 -> u0, u0 -> u0, u0 -> u0, u0 -> u0 -> u0, u0 -> u0 -> u0, u0 -> u0, u0 -> u0, u0 -> u0, u0 -> u0, u0 -> u0, u0 -> u0, u0 -> u0, u0 -> u0, u0 -> u0, u0 -> u0, u0 -> u0, u0 -> u0)) -> case u1 of { _ALG_ _TUP_19 (u2 :: {{Fractional u0}}) (u3 :: u0) (u4 :: u0 -> u0) (u5 :: u0 -> u0) (u6 :: u0 -> u0) (u7 :: u0 -> u0 -> u0) (u8 :: u0 -> u0 -> u0) (u9 :: u0 -> u0) (ua :: u0 -> u0) (ub :: u0 -> u0) (uc :: u0 -> u0) (ud :: u0 -> u0) (ue :: u0 -> u0) (uf :: u0 -> u0) (ug :: u0 -> u0) (uh :: u0 -> u0) (ui :: u0 -> u0) (uj :: u0 -> u0) (uk :: u0 -> u0) -> ud; _NO_DEFLT_ } _N_
- {-defm-} _A_ 2 _U_ 02 _N_ _S_ _!_ _F_ _IF_ARGS_ 1 2 XX 3 _/\_ u0 -> \ (u1 :: {{Floating u0}}) (u2 :: u0) -> _APP_ _TYAPP_ patError# { (u0 -> u0) } [ _NOREP_S_ "%DPreludeCore.Floating.acos\"", u2 ] _N_ #-}
+ {-defm-} _A_ 2 _U_ 02 _N_ _S_ _!_ _N_ _N_ #-}
atan :: a -> a
{-# GHC_PRAGMA {-meth-} _A_ 1 _U_ 12 _N_ _S_ "U(AAAAAAAAAAAASAAAAAA)" {_A_ 1 _U_ 12 _N_ _N_ _F_ _IF_ARGS_ 1 1 X 1 _/\_ u0 -> \ (u1 :: u0 -> u0) -> u1 _N_} _F_ _IF_ARGS_ 1 1 C 2 _/\_ u0 -> \ (u1 :: ({{Fractional u0}}, u0, u0 -> u0, u0 -> u0, u0 -> u0, u0 -> u0 -> u0, u0 -> u0 -> u0, u0 -> u0, u0 -> u0, u0 -> u0, u0 -> u0, u0 -> u0, u0 -> u0, u0 -> u0, u0 -> u0, u0 -> u0, u0 -> u0, u0 -> u0, u0 -> u0)) -> case u1 of { _ALG_ _TUP_19 (u2 :: {{Fractional u0}}) (u3 :: u0) (u4 :: u0 -> u0) (u5 :: u0 -> u0) (u6 :: u0 -> u0) (u7 :: u0 -> u0 -> u0) (u8 :: u0 -> u0 -> u0) (u9 :: u0 -> u0) (ua :: u0 -> u0) (ub :: u0 -> u0) (uc :: u0 -> u0) (ud :: u0 -> u0) (ue :: u0 -> u0) (uf :: u0 -> u0) (ug :: u0 -> u0) (uh :: u0 -> u0) (ui :: u0 -> u0) (uj :: u0 -> u0) (uk :: u0 -> u0) -> ue; _NO_DEFLT_ } _N_
- {-defm-} _A_ 2 _U_ 02 _N_ _S_ _!_ _F_ _IF_ARGS_ 1 2 XX 3 _/\_ u0 -> \ (u1 :: {{Floating u0}}) (u2 :: u0) -> _APP_ _TYAPP_ patError# { (u0 -> u0) } [ _NOREP_S_ "%DPreludeCore.Floating.atan\"", u2 ] _N_ #-}
+ {-defm-} _A_ 2 _U_ 02 _N_ _S_ _!_ _N_ _N_ #-}
sinh :: a -> a
{-# GHC_PRAGMA {-meth-} _A_ 1 _U_ 12 _N_ _S_ "U(AAAAAAAAAAAAASAAAAA)" {_A_ 1 _U_ 12 _N_ _N_ _F_ _IF_ARGS_ 1 1 X 1 _/\_ u0 -> \ (u1 :: u0 -> u0) -> u1 _N_} _F_ _IF_ARGS_ 1 1 C 2 _/\_ u0 -> \ (u1 :: ({{Fractional u0}}, u0, u0 -> u0, u0 -> u0, u0 -> u0, u0 -> u0 -> u0, u0 -> u0 -> u0, u0 -> u0, u0 -> u0, u0 -> u0, u0 -> u0, u0 -> u0, u0 -> u0, u0 -> u0, u0 -> u0, u0 -> u0, u0 -> u0, u0 -> u0, u0 -> u0)) -> case u1 of { _ALG_ _TUP_19 (u2 :: {{Fractional u0}}) (u3 :: u0) (u4 :: u0 -> u0) (u5 :: u0 -> u0) (u6 :: u0 -> u0) (u7 :: u0 -> u0 -> u0) (u8 :: u0 -> u0 -> u0) (u9 :: u0 -> u0) (ua :: u0 -> u0) (ub :: u0 -> u0) (uc :: u0 -> u0) (ud :: u0 -> u0) (ue :: u0 -> u0) (uf :: u0 -> u0) (ug :: u0 -> u0) (uh :: u0 -> u0) (ui :: u0 -> u0) (uj :: u0 -> u0) (uk :: u0 -> u0) -> uf; _NO_DEFLT_ } _N_
- {-defm-} _A_ 2 _U_ 02 _N_ _S_ _!_ _F_ _IF_ARGS_ 1 2 XX 3 _/\_ u0 -> \ (u1 :: {{Floating u0}}) (u2 :: u0) -> _APP_ _TYAPP_ patError# { (u0 -> u0) } [ _NOREP_S_ "%DPreludeCore.Floating.sinh\"", u2 ] _N_ #-}
+ {-defm-} _A_ 2 _U_ 02 _N_ _S_ _!_ _N_ _N_ #-}
cosh :: a -> a
{-# GHC_PRAGMA {-meth-} _A_ 1 _U_ 12 _N_ _S_ "U(AAAAAAAAAAAAAASAAAA)" {_A_ 1 _U_ 12 _N_ _N_ _F_ _IF_ARGS_ 1 1 X 1 _/\_ u0 -> \ (u1 :: u0 -> u0) -> u1 _N_} _F_ _IF_ARGS_ 1 1 C 2 _/\_ u0 -> \ (u1 :: ({{Fractional u0}}, u0, u0 -> u0, u0 -> u0, u0 -> u0, u0 -> u0 -> u0, u0 -> u0 -> u0, u0 -> u0, u0 -> u0, u0 -> u0, u0 -> u0, u0 -> u0, u0 -> u0, u0 -> u0, u0 -> u0, u0 -> u0, u0 -> u0, u0 -> u0, u0 -> u0)) -> case u1 of { _ALG_ _TUP_19 (u2 :: {{Fractional u0}}) (u3 :: u0) (u4 :: u0 -> u0) (u5 :: u0 -> u0) (u6 :: u0 -> u0) (u7 :: u0 -> u0 -> u0) (u8 :: u0 -> u0 -> u0) (u9 :: u0 -> u0) (ua :: u0 -> u0) (ub :: u0 -> u0) (uc :: u0 -> u0) (ud :: u0 -> u0) (ue :: u0 -> u0) (uf :: u0 -> u0) (ug :: u0 -> u0) (uh :: u0 -> u0) (ui :: u0 -> u0) (uj :: u0 -> u0) (uk :: u0 -> u0) -> ug; _NO_DEFLT_ } _N_
- {-defm-} _A_ 2 _U_ 02 _N_ _S_ _!_ _F_ _IF_ARGS_ 1 2 XX 3 _/\_ u0 -> \ (u1 :: {{Floating u0}}) (u2 :: u0) -> _APP_ _TYAPP_ patError# { (u0 -> u0) } [ _NOREP_S_ "%DPreludeCore.Floating.cosh\"", u2 ] _N_ #-}
+ {-defm-} _A_ 2 _U_ 02 _N_ _S_ _!_ _N_ _N_ #-}
tanh :: a -> a
{-# GHC_PRAGMA {-meth-} _A_ 1 _U_ 12 _N_ _S_ "U(AAAAAAAAAAAAAAASAAA)" {_A_ 1 _U_ 12 _N_ _N_ _F_ _IF_ARGS_ 1 1 X 1 _/\_ u0 -> \ (u1 :: u0 -> u0) -> u1 _N_} _F_ _IF_ARGS_ 1 1 C 2 _/\_ u0 -> \ (u1 :: ({{Fractional u0}}, u0, u0 -> u0, u0 -> u0, u0 -> u0, u0 -> u0 -> u0, u0 -> u0 -> u0, u0 -> u0, u0 -> u0, u0 -> u0, u0 -> u0, u0 -> u0, u0 -> u0, u0 -> u0, u0 -> u0, u0 -> u0, u0 -> u0, u0 -> u0, u0 -> u0)) -> case u1 of { _ALG_ _TUP_19 (u2 :: {{Fractional u0}}) (u3 :: u0) (u4 :: u0 -> u0) (u5 :: u0 -> u0) (u6 :: u0 -> u0) (u7 :: u0 -> u0 -> u0) (u8 :: u0 -> u0 -> u0) (u9 :: u0 -> u0) (ua :: u0 -> u0) (ub :: u0 -> u0) (uc :: u0 -> u0) (ud :: u0 -> u0) (ue :: u0 -> u0) (uf :: u0 -> u0) (ug :: u0 -> u0) (uh :: u0 -> u0) (ui :: u0 -> u0) (uj :: u0 -> u0) (uk :: u0 -> u0) -> uh; _NO_DEFLT_ } _N_
{-defm-} _A_ 2 _U_ 12 _N_ _S_ "U(U(ASAA)AAAAAAAAAAAALLAAAA)L" {_A_ 4 _U_ 1112 _N_ _N_ _N_ _N_} _N_ _N_ #-}
asinh :: a -> a
{-# GHC_PRAGMA {-meth-} _A_ 1 _U_ 12 _N_ _S_ "U(AAAAAAAAAAAAAAAASAA)" {_A_ 1 _U_ 12 _N_ _N_ _F_ _IF_ARGS_ 1 1 X 1 _/\_ u0 -> \ (u1 :: u0 -> u0) -> u1 _N_} _F_ _IF_ARGS_ 1 1 C 2 _/\_ u0 -> \ (u1 :: ({{Fractional u0}}, u0, u0 -> u0, u0 -> u0, u0 -> u0, u0 -> u0 -> u0, u0 -> u0 -> u0, u0 -> u0, u0 -> u0, u0 -> u0, u0 -> u0, u0 -> u0, u0 -> u0, u0 -> u0, u0 -> u0, u0 -> u0, u0 -> u0, u0 -> u0, u0 -> u0)) -> case u1 of { _ALG_ _TUP_19 (u2 :: {{Fractional u0}}) (u3 :: u0) (u4 :: u0 -> u0) (u5 :: u0 -> u0) (u6 :: u0 -> u0) (u7 :: u0 -> u0 -> u0) (u8 :: u0 -> u0 -> u0) (u9 :: u0 -> u0) (ua :: u0 -> u0) (ub :: u0 -> u0) (uc :: u0 -> u0) (ud :: u0 -> u0) (ue :: u0 -> u0) (uf :: u0 -> u0) (ug :: u0 -> u0) (uh :: u0 -> u0) (ui :: u0 -> u0) (uj :: u0 -> u0) (uk :: u0 -> u0) -> ui; _NO_DEFLT_ } _N_
- {-defm-} _A_ 2 _U_ 02 _N_ _S_ _!_ _F_ _IF_ARGS_ 1 2 XX 3 _/\_ u0 -> \ (u1 :: {{Floating u0}}) (u2 :: u0) -> _APP_ _TYAPP_ patError# { (u0 -> u0) } [ _NOREP_S_ "%DPreludeCore.Floating.asinh\"", u2 ] _N_ #-}
+ {-defm-} _A_ 2 _U_ 02 _N_ _S_ _!_ _N_ _N_ #-}
acosh :: a -> a
{-# GHC_PRAGMA {-meth-} _A_ 1 _U_ 12 _N_ _S_ "U(AAAAAAAAAAAAAAAAASA)" {_A_ 1 _U_ 12 _N_ _N_ _F_ _IF_ARGS_ 1 1 X 1 _/\_ u0 -> \ (u1 :: u0 -> u0) -> u1 _N_} _F_ _IF_ARGS_ 1 1 C 2 _/\_ u0 -> \ (u1 :: ({{Fractional u0}}, u0, u0 -> u0, u0 -> u0, u0 -> u0, u0 -> u0 -> u0, u0 -> u0 -> u0, u0 -> u0, u0 -> u0, u0 -> u0, u0 -> u0, u0 -> u0, u0 -> u0, u0 -> u0, u0 -> u0, u0 -> u0, u0 -> u0, u0 -> u0, u0 -> u0)) -> case u1 of { _ALG_ _TUP_19 (u2 :: {{Fractional u0}}) (u3 :: u0) (u4 :: u0 -> u0) (u5 :: u0 -> u0) (u6 :: u0 -> u0) (u7 :: u0 -> u0 -> u0) (u8 :: u0 -> u0 -> u0) (u9 :: u0 -> u0) (ua :: u0 -> u0) (ub :: u0 -> u0) (uc :: u0 -> u0) (ud :: u0 -> u0) (ue :: u0 -> u0) (uf :: u0 -> u0) (ug :: u0 -> u0) (uh :: u0 -> u0) (ui :: u0 -> u0) (uj :: u0 -> u0) (uk :: u0 -> u0) -> uj; _NO_DEFLT_ } _N_
- {-defm-} _A_ 2 _U_ 02 _N_ _S_ _!_ _F_ _IF_ARGS_ 1 2 XX 3 _/\_ u0 -> \ (u1 :: {{Floating u0}}) (u2 :: u0) -> _APP_ _TYAPP_ patError# { (u0 -> u0) } [ _NOREP_S_ "%DPreludeCore.Floating.acosh\"", u2 ] _N_ #-}
+ {-defm-} _A_ 2 _U_ 02 _N_ _S_ _!_ _N_ _N_ #-}
atanh :: a -> a
{-# GHC_PRAGMA {-meth-} _A_ 1 _U_ 12 _N_ _S_ "U(AAAAAAAAAAAAAAAAAAS)" {_A_ 1 _U_ 12 _N_ _N_ _F_ _IF_ARGS_ 1 1 X 1 _/\_ u0 -> \ (u1 :: u0 -> u0) -> u1 _N_} _F_ _IF_ARGS_ 1 1 C 2 _/\_ u0 -> \ (u1 :: ({{Fractional u0}}, u0, u0 -> u0, u0 -> u0, u0 -> u0, u0 -> u0 -> u0, u0 -> u0 -> u0, u0 -> u0, u0 -> u0, u0 -> u0, u0 -> u0, u0 -> u0, u0 -> u0, u0 -> u0, u0 -> u0, u0 -> u0, u0 -> u0, u0 -> u0, u0 -> u0)) -> case u1 of { _ALG_ _TUP_19 (u2 :: {{Fractional u0}}) (u3 :: u0) (u4 :: u0 -> u0) (u5 :: u0 -> u0) (u6 :: u0 -> u0) (u7 :: u0 -> u0 -> u0) (u8 :: u0 -> u0 -> u0) (u9 :: u0 -> u0) (ua :: u0 -> u0) (ub :: u0 -> u0) (uc :: u0 -> u0) (ud :: u0 -> u0) (ue :: u0 -> u0) (uf :: u0 -> u0) (ug :: u0 -> u0) (uh :: u0 -> u0) (ui :: u0 -> u0) (uj :: u0 -> u0) (uk :: u0 -> u0) -> uk; _NO_DEFLT_ } _N_
- {-defm-} _A_ 2 _U_ 02 _N_ _S_ _!_ _F_ _IF_ARGS_ 1 2 XX 3 _/\_ u0 -> \ (u1 :: {{Floating u0}}) (u2 :: u0) -> _APP_ _TYAPP_ patError# { (u0 -> u0) } [ _NOREP_S_ "%DPreludeCore.Floating.atanh\"", u2 ] _N_ #-}
+ {-defm-} _A_ 2 _U_ 02 _N_ _S_ _!_ _N_ _N_ #-}
class (Num a) => Fractional a {-# GHC_PRAGMA {-superdicts-} _A_ 1 _U_ 1 _N_ _S_ "U(U(LLLLLLLLLL)AAA)" {_A_ 1 _U_ 1 _N_ _N_ _F_ _IF_ARGS_ 1 1 X 1 _/\_ u0 -> \ (u1 :: {{Num u0}}) -> u1 _N_} _F_ _IF_ARGS_ 1 1 C 2 _/\_ u0 -> \ (u1 :: ({{Num u0}}, u0 -> u0 -> u0, u0 -> u0, Ratio Integer -> u0)) -> case u1 of { _ALG_ _TUP_4 (u2 :: {{Num u0}}) (u3 :: u0 -> u0 -> u0) (u4 :: u0 -> u0) (u5 :: Ratio Integer -> u0) -> u2; _NO_DEFLT_ } _N_ #-} where
(/) :: a -> a -> a
{-# GHC_PRAGMA {-meth-} _A_ 1 _U_ 122 _N_ _S_ "U(ASAA)" {_A_ 1 _U_ 122 _N_ _N_ _F_ _IF_ARGS_ 1 1 X 1 _/\_ u0 -> \ (u1 :: u0 -> u0 -> u0) -> u1 _N_} _F_ _IF_ARGS_ 1 1 C 2 _/\_ u0 -> \ (u1 :: ({{Num u0}}, u0 -> u0 -> u0, u0 -> u0, Ratio Integer -> u0)) -> case u1 of { _ALG_ _TUP_4 (u2 :: {{Num u0}}) (u3 :: u0 -> u0 -> u0) (u4 :: u0 -> u0) (u5 :: Ratio Integer -> u0) -> u3; _NO_DEFLT_ } _N_
- {-defm-} _A_ 3 _U_ 022 _N_ _S_ _!_ _F_ _IF_ARGS_ 1 3 XXX 4 _/\_ u0 -> \ (u1 :: {{Fractional u0}}) (u2 :: u0) (u3 :: u0) -> _APP_ _TYAPP_ patError# { (u0 -> u0 -> u0) } [ _NOREP_S_ "%DPreludeCore.Fractional.(/)\"", u2, u3 ] _N_ #-}
+ {-defm-} _A_ 3 _U_ 022 _N_ _S_ _!_ _N_ _N_ #-}
recip :: a -> a
{-# GHC_PRAGMA {-meth-} _A_ 1 _U_ 12 _N_ _S_ "U(AASA)" {_A_ 1 _U_ 12 _N_ _N_ _F_ _IF_ARGS_ 1 1 X 1 _/\_ u0 -> \ (u1 :: u0 -> u0) -> u1 _N_} _F_ _IF_ARGS_ 1 1 C 2 _/\_ u0 -> \ (u1 :: ({{Num u0}}, u0 -> u0 -> u0, u0 -> u0, Ratio Integer -> u0)) -> case u1 of { _ALG_ _TUP_4 (u2 :: {{Num u0}}) (u3 :: u0 -> u0 -> u0) (u4 :: u0 -> u0) (u5 :: Ratio Integer -> u0) -> u4; _NO_DEFLT_ } _N_
- {-defm-} _A_ 1 _U_ 12 _N_ _S_ "U(ASAL)" {_A_ 2 _U_ 122 _N_ _N_ _N_ _N_} _N_ _N_ #-}
+ {-defm-} _A_ 1 _U_ 12 _N_ _S_ "U(LSAA)" {_A_ 2 _U_ 112 _N_ _N_ _N_ _N_} _N_ _N_ #-}
fromRational :: Ratio Integer -> a
{-# GHC_PRAGMA {-meth-} _A_ 1 _U_ 12 _N_ _S_ "U(AAAS)" {_A_ 1 _U_ 12 _N_ _N_ _F_ _IF_ARGS_ 1 1 X 1 _/\_ u0 -> \ (u1 :: Ratio Integer -> u0) -> u1 _N_} _F_ _IF_ARGS_ 1 1 C 2 _/\_ u0 -> \ (u1 :: ({{Num u0}}, u0 -> u0 -> u0, u0 -> u0, Ratio Integer -> u0)) -> case u1 of { _ALG_ _TUP_4 (u2 :: {{Num u0}}) (u3 :: u0 -> u0 -> u0) (u4 :: u0 -> u0) (u5 :: Ratio Integer -> u0) -> u5; _NO_DEFLT_ } _N_
- {-defm-} _A_ 2 _U_ 02 _N_ _S_ _!_ _F_ _IF_ARGS_ 1 2 XX 3 _/\_ u0 -> \ (u1 :: {{Fractional u0}}) (u2 :: Ratio Integer) -> _APP_ _TYAPP_ patError# { (Ratio Integer -> u0) } [ _NOREP_S_ "%DPreludeCore.Fractional.fromRational\"", u2 ] _N_ #-}
+ {-defm-} _A_ 2 _U_ 02 _N_ _S_ _!_ _N_ _N_ #-}
class (Real a, Ix a) => Integral a {-# GHC_PRAGMA {-superdicts-} _A_ 1 _U_ 1 _N_ _S_ "U(U(LLL)AAAAAAAAAAA)" {_A_ 3 _U_ 222 _N_ _N_ _F_ _IF_ARGS_ 1 3 XXX 4 _/\_ u0 -> \ (u1 :: {{Num u0}}) (u2 :: {{Enum u0}}) (u3 :: u0 -> Ratio Integer) -> _!_ _TUP_3 [{{Num u0}}, {{Enum u0}}, (u0 -> Ratio Integer)] [u1, u2, u3] _N_} _F_ _IF_ARGS_ 1 1 C 2 _/\_ u0 -> \ (u1 :: ({{Real u0}}, {{Ix u0}}, u0 -> u0 -> u0, u0 -> u0 -> u0, u0 -> u0 -> u0, u0 -> u0 -> u0, u0 -> u0 -> (u0, u0), u0 -> u0 -> (u0, u0), u0 -> Bool, u0 -> Bool, u0 -> Integer, u0 -> Int)) -> case u1 of { _ALG_ _TUP_12 (u2 :: {{Real u0}}) (u3 :: {{Ix u0}}) (u4 :: u0 -> u0 -> u0) (u5 :: u0 -> u0 -> u0) (u6 :: u0 -> u0 -> u0) (u7 :: u0 -> u0 -> u0) (u8 :: u0 -> u0 -> (u0, u0)) (u9 :: u0 -> u0 -> (u0, u0)) (ua :: u0 -> Bool) (ub :: u0 -> Bool) (uc :: u0 -> Integer) (ud :: u0 -> Int) -> u2; _NO_DEFLT_ } _N_, _A_ 1 _U_ 1 _N_ _S_ "U(AU(LLLL)AAAAAAAAAA)" {_A_ 4 _U_ 2222 _N_ _N_ _F_ _IF_ARGS_ 1 4 XXXX 5 _/\_ u0 -> \ (u1 :: {{Ord u0}}) (u2 :: (u0, u0) -> [u0]) (u3 :: (u0, u0) -> u0 -> Int) (u4 :: (u0, u0) -> u0 -> Bool) -> _!_ _TUP_4 [{{Ord u0}}, ((u0, u0) -> [u0]), ((u0, u0) -> u0 -> Int), ((u0, u0) -> u0 -> Bool)] [u1, u2, u3, u4] _N_} _F_ _IF_ARGS_ 1 1 C 2 _/\_ u0 -> \ (u1 :: ({{Real u0}}, {{Ix u0}}, u0 -> u0 -> u0, u0 -> u0 -> u0, u0 -> u0 -> u0, u0 -> u0 -> u0, u0 -> u0 -> (u0, u0), u0 -> u0 -> (u0, u0), u0 -> Bool, u0 -> Bool, u0 -> Integer, u0 -> Int)) -> case u1 of { _ALG_ _TUP_12 (u2 :: {{Real u0}}) (u3 :: {{Ix u0}}) (u4 :: u0 -> u0 -> u0) (u5 :: u0 -> u0 -> u0) (u6 :: u0 -> u0 -> u0) (u7 :: u0 -> u0 -> u0) (u8 :: u0 -> u0 -> (u0, u0)) (u9 :: u0 -> u0 -> (u0, u0)) (ua :: u0 -> Bool) (ub :: u0 -> Bool) (uc :: u0 -> Integer) (ud :: u0 -> Int) -> u3; _NO_DEFLT_ } _N_ #-} where
quot :: a -> a -> a
{-# GHC_PRAGMA {-meth-} _A_ 1 _U_ 122 _N_ _S_ "U(AASAAAAAAAAA)" {_A_ 1 _U_ 122 _N_ _N_ _F_ _IF_ARGS_ 1 1 X 1 _/\_ u0 -> \ (u1 :: u0 -> u0 -> u0) -> u1 _N_} _F_ _IF_ARGS_ 1 1 C 2 _/\_ u0 -> \ (u1 :: ({{Real u0}}, {{Ix u0}}, u0 -> u0 -> u0, u0 -> u0 -> u0, u0 -> u0 -> u0, u0 -> u0 -> u0, u0 -> u0 -> (u0, u0), u0 -> u0 -> (u0, u0), u0 -> Bool, u0 -> Bool, u0 -> Integer, u0 -> Int)) -> case u1 of { _ALG_ _TUP_12 (u2 :: {{Real u0}}) (u3 :: {{Ix u0}}) (u4 :: u0 -> u0 -> u0) (u5 :: u0 -> u0 -> u0) (u6 :: u0 -> u0 -> u0) (u7 :: u0 -> u0 -> u0) (u8 :: u0 -> u0 -> (u0, u0)) (u9 :: u0 -> u0 -> (u0, u0)) (ua :: u0 -> Bool) (ub :: u0 -> Bool) (uc :: u0 -> Integer) (ud :: u0 -> Int) -> u4; _NO_DEFLT_ } _N_
{-defm-} _A_ 3 _U_ 122 _N_ _S_ "U(AAAAAAASAAAA)LL" {_A_ 3 _U_ 122 _N_ _N_ _F_ _IF_ARGS_ 1 3 XXX 5 _/\_ u0 -> \ (u1 :: u0 -> u0 -> (u0, u0)) (u2 :: u0) (u3 :: u0) -> case _APP_ u1 [ u2, u3 ] of { _ALG_ _TUP_2 (u4 :: u0) (u5 :: u0) -> u5; _NO_DEFLT_ } _N_} _F_ _IF_ARGS_ 1 3 CXX 6 _/\_ u0 -> \ (u1 :: {{Integral u0}}) (u2 :: u0) (u3 :: u0) -> case case u1 of { _ALG_ _TUP_12 (u4 :: {{Real u0}}) (u5 :: {{Ix u0}}) (u6 :: u0 -> u0 -> u0) (u7 :: u0 -> u0 -> u0) (u8 :: u0 -> u0 -> u0) (u9 :: u0 -> u0 -> u0) (ua :: u0 -> u0 -> (u0, u0)) (ub :: u0 -> u0 -> (u0, u0)) (uc :: u0 -> Bool) (ud :: u0 -> Bool) (ue :: u0 -> Integer) (uf :: u0 -> Int) -> _APP_ ub [ u2, u3 ]; _NO_DEFLT_ } of { _ALG_ _TUP_2 (ug :: u0) (uh :: u0) -> uh; _NO_DEFLT_ } _N_ #-}
quotRem :: a -> a -> (a, a)
{-# GHC_PRAGMA {-meth-} _A_ 1 _U_ 122 _N_ _S_ "U(AAAAAASAAAAA)" {_A_ 1 _U_ 122 _N_ _N_ _F_ _IF_ARGS_ 1 1 X 1 _/\_ u0 -> \ (u1 :: u0 -> u0 -> (u0, u0)) -> u1 _N_} _F_ _IF_ARGS_ 1 1 C 2 _/\_ u0 -> \ (u1 :: ({{Real u0}}, {{Ix u0}}, u0 -> u0 -> u0, u0 -> u0 -> u0, u0 -> u0 -> u0, u0 -> u0 -> u0, u0 -> u0 -> (u0, u0), u0 -> u0 -> (u0, u0), u0 -> Bool, u0 -> Bool, u0 -> Integer, u0 -> Int)) -> case u1 of { _ALG_ _TUP_12 (u2 :: {{Real u0}}) (u3 :: {{Ix u0}}) (u4 :: u0 -> u0 -> u0) (u5 :: u0 -> u0 -> u0) (u6 :: u0 -> u0 -> u0) (u7 :: u0 -> u0 -> u0) (u8 :: u0 -> u0 -> (u0, u0)) (u9 :: u0 -> u0 -> (u0, u0)) (ua :: u0 -> Bool) (ub :: u0 -> Bool) (uc :: u0 -> Integer) (ud :: u0 -> Int) -> u8; _NO_DEFLT_ } _N_
- {-defm-} _A_ 3 _U_ 022 _N_ _S_ _!_ _F_ _IF_ARGS_ 1 3 XXX 4 _/\_ u0 -> \ (u1 :: {{Integral u0}}) (u2 :: u0) (u3 :: u0) -> _APP_ _TYAPP_ patError# { (u0 -> u0 -> (u0, u0)) } [ _NOREP_S_ "%DPreludeCore.Integral.quotRem\"", u2, u3 ] _N_ #-}
+ {-defm-} _A_ 3 _U_ 022 _N_ _S_ _!_ _N_ _N_ #-}
divMod :: a -> a -> (a, a)
{-# GHC_PRAGMA {-meth-} _A_ 1 _U_ 122 _N_ _S_ "U(AAAAAAASAAAA)" {_A_ 1 _U_ 122 _N_ _N_ _F_ _IF_ARGS_ 1 1 X 1 _/\_ u0 -> \ (u1 :: u0 -> u0 -> (u0, u0)) -> u1 _N_} _F_ _IF_ARGS_ 1 1 C 2 _/\_ u0 -> \ (u1 :: ({{Real u0}}, {{Ix u0}}, u0 -> u0 -> u0, u0 -> u0 -> u0, u0 -> u0 -> u0, u0 -> u0 -> u0, u0 -> u0 -> (u0, u0), u0 -> u0 -> (u0, u0), u0 -> Bool, u0 -> Bool, u0 -> Integer, u0 -> Int)) -> case u1 of { _ALG_ _TUP_12 (u2 :: {{Real u0}}) (u3 :: {{Ix u0}}) (u4 :: u0 -> u0 -> u0) (u5 :: u0 -> u0 -> u0) (u6 :: u0 -> u0 -> u0) (u7 :: u0 -> u0 -> u0) (u8 :: u0 -> u0 -> (u0, u0)) (u9 :: u0 -> u0 -> (u0, u0)) (ua :: u0 -> Bool) (ub :: u0 -> Bool) (uc :: u0 -> Integer) (ud :: u0 -> Int) -> u9; _NO_DEFLT_ } _N_
- {-defm-} _A_ 1 _U_ 122 _N_ _S_ "U(U(U(U(SA)ALLALALLA)AA)AAAAALAAAAA)" {_A_ 2 _U_ 1222 _N_ _N_ _N_ _N_} _N_ _N_ #-}
+ {-defm-} _A_ 1 _U_ 122 _N_ _S_ "U(U(U(U(SA)ALLALALAL)AA)AAAAALAAAAA)" {_A_ 2 _U_ 1222 _N_ _N_ _N_ _N_} _N_ _N_ #-}
even :: a -> Bool
{-# GHC_PRAGMA {-meth-} _A_ 1 _U_ 12 _N_ _S_ "U(AAAAAAAASAAA)" {_A_ 1 _U_ 12 _N_ _N_ _F_ _IF_ARGS_ 1 1 X 1 _/\_ u0 -> \ (u1 :: u0 -> Bool) -> u1 _N_} _F_ _IF_ARGS_ 1 1 C 2 _/\_ u0 -> \ (u1 :: ({{Real u0}}, {{Ix u0}}, u0 -> u0 -> u0, u0 -> u0 -> u0, u0 -> u0 -> u0, u0 -> u0 -> u0, u0 -> u0 -> (u0, u0), u0 -> u0 -> (u0, u0), u0 -> Bool, u0 -> Bool, u0 -> Integer, u0 -> Int)) -> case u1 of { _ALG_ _TUP_12 (u2 :: {{Real u0}}) (u3 :: {{Ix u0}}) (u4 :: u0 -> u0 -> u0) (u5 :: u0 -> u0 -> u0) (u6 :: u0 -> u0 -> u0) (u7 :: u0 -> u0 -> u0) (u8 :: u0 -> u0 -> (u0, u0)) (u9 :: u0 -> u0 -> (u0, u0)) (ua :: u0 -> Bool) (ub :: u0 -> Bool) (uc :: u0 -> Integer) (ud :: u0 -> Int) -> ua; _NO_DEFLT_ } _N_
- {-defm-} _A_ 1 _U_ 12 _N_ _S_ "U(U(U(U(SA)AAAAAAALA)AA)AALAAAAAAAA)" {_A_ 3 _U_ 1212 _N_ _N_ _N_ _N_} _N_ _N_ #-}
+ {-defm-} _A_ 1 _U_ 12 _N_ _S_ "U(U(U(U(SA)AAAAAAAAL)AA)AALAAAAAAAA)" {_A_ 3 _U_ 1212 _N_ _N_ _N_ _N_} _N_ _N_ #-}
odd :: a -> Bool
{-# GHC_PRAGMA {-meth-} _A_ 1 _U_ 12 _N_ _S_ "U(AAAAAAAAASAA)" {_A_ 1 _U_ 12 _N_ _N_ _F_ _IF_ARGS_ 1 1 X 1 _/\_ u0 -> \ (u1 :: u0 -> Bool) -> u1 _N_} _F_ _IF_ARGS_ 1 1 C 2 _/\_ u0 -> \ (u1 :: ({{Real u0}}, {{Ix u0}}, u0 -> u0 -> u0, u0 -> u0 -> u0, u0 -> u0 -> u0, u0 -> u0 -> u0, u0 -> u0 -> (u0, u0), u0 -> u0 -> (u0, u0), u0 -> Bool, u0 -> Bool, u0 -> Integer, u0 -> Int)) -> case u1 of { _ALG_ _TUP_12 (u2 :: {{Real u0}}) (u3 :: {{Ix u0}}) (u4 :: u0 -> u0 -> u0) (u5 :: u0 -> u0 -> u0) (u6 :: u0 -> u0 -> u0) (u7 :: u0 -> u0 -> u0) (u8 :: u0 -> u0 -> (u0, u0)) (u9 :: u0 -> u0 -> (u0, u0)) (ua :: u0 -> Bool) (ub :: u0 -> Bool) (uc :: u0 -> Integer) (ud :: u0 -> Int) -> ub; _NO_DEFLT_ } _N_
- {-defm-} _A_ 1 _U_ 12 _N_ _S_ "U(U(U(U(AS)AAAAAAALA)AA)AALAAAAAAAA)" {_A_ 3 _U_ 1212 _N_ _N_ _N_ _N_} _N_ _N_ #-}
+ {-defm-} _A_ 1 _U_ 12 _N_ _S_ "U(U(U(U(AS)AAAAAAAAL)AA)AALAAAAAAAA)" {_A_ 3 _U_ 1212 _N_ _N_ _N_ _N_} _N_ _N_ #-}
toInteger :: a -> Integer
{-# GHC_PRAGMA {-meth-} _A_ 1 _U_ 12 _N_ _S_ "U(AAAAAAAAAASA)" {_A_ 1 _U_ 12 _N_ _N_ _F_ _IF_ARGS_ 1 1 X 1 _/\_ u0 -> \ (u1 :: u0 -> Integer) -> u1 _N_} _F_ _IF_ARGS_ 1 1 C 2 _/\_ u0 -> \ (u1 :: ({{Real u0}}, {{Ix u0}}, u0 -> u0 -> u0, u0 -> u0 -> u0, u0 -> u0 -> u0, u0 -> u0 -> u0, u0 -> u0 -> (u0, u0), u0 -> u0 -> (u0, u0), u0 -> Bool, u0 -> Bool, u0 -> Integer, u0 -> Int)) -> case u1 of { _ALG_ _TUP_12 (u2 :: {{Real u0}}) (u3 :: {{Ix u0}}) (u4 :: u0 -> u0 -> u0) (u5 :: u0 -> u0 -> u0) (u6 :: u0 -> u0 -> u0) (u7 :: u0 -> u0 -> u0) (u8 :: u0 -> u0 -> (u0, u0)) (u9 :: u0 -> u0 -> (u0, u0)) (ua :: u0 -> Bool) (ub :: u0 -> Bool) (uc :: u0 -> Integer) (ud :: u0 -> Int) -> uc; _NO_DEFLT_ } _N_
- {-defm-} _A_ 2 _U_ 02 _N_ _S_ _!_ _F_ _IF_ARGS_ 1 2 XX 3 _/\_ u0 -> \ (u1 :: {{Integral u0}}) (u2 :: u0) -> _APP_ _TYAPP_ patError# { (u0 -> Integer) } [ _NOREP_S_ "%DPreludeCore.Integral.toInteger\"", u2 ] _N_ #-}
+ {-defm-} _A_ 2 _U_ 02 _N_ _S_ _!_ _N_ _N_ #-}
toInt :: a -> Int
{-# GHC_PRAGMA {-meth-} _A_ 1 _U_ 12 _N_ _S_ "U(AAAAAAAAAAAS)" {_A_ 1 _U_ 12 _N_ _N_ _F_ _IF_ARGS_ 1 1 X 1 _/\_ u0 -> \ (u1 :: u0 -> Int) -> u1 _N_} _F_ _IF_ARGS_ 1 1 C 2 _/\_ u0 -> \ (u1 :: ({{Real u0}}, {{Ix u0}}, u0 -> u0 -> u0, u0 -> u0 -> u0, u0 -> u0 -> u0, u0 -> u0 -> u0, u0 -> u0 -> (u0, u0), u0 -> u0 -> (u0, u0), u0 -> Bool, u0 -> Bool, u0 -> Integer, u0 -> Int)) -> case u1 of { _ALG_ _TUP_12 (u2 :: {{Real u0}}) (u3 :: {{Ix u0}}) (u4 :: u0 -> u0 -> u0) (u5 :: u0 -> u0 -> u0) (u6 :: u0 -> u0 -> u0) (u7 :: u0 -> u0 -> u0) (u8 :: u0 -> u0 -> (u0, u0)) (u9 :: u0 -> u0 -> (u0, u0)) (ua :: u0 -> Bool) (ub :: u0 -> Bool) (uc :: u0 -> Integer) (ud :: u0 -> Int) -> ud; _NO_DEFLT_ } _N_
- {-defm-} _A_ 2 _U_ 02 _N_ _S_ _!_ _F_ _IF_ARGS_ 1 2 XX 3 _/\_ u0 -> \ (u1 :: {{Integral u0}}) (u2 :: u0) -> _APP_ _TYAPP_ patError# { (u0 -> Int) } [ _NOREP_S_ "%DPreludeCore.Integral.toInt\"", u2 ] _N_ #-}
+ {-defm-} _A_ 2 _U_ 02 _N_ _S_ _!_ _N_ _N_ #-}
class (Ord a) => Ix a {-# GHC_PRAGMA {-superdicts-} _A_ 1 _U_ 1 _N_ _S_ "U(U(LLLLLLLL)AAA)" {_A_ 1 _U_ 1 _N_ _N_ _F_ _IF_ARGS_ 1 1 X 1 _/\_ u0 -> \ (u1 :: {{Ord u0}}) -> u1 _N_} _F_ _IF_ARGS_ 1 1 C 2 _/\_ u0 -> \ (u1 :: ({{Ord u0}}, (u0, u0) -> [u0], (u0, u0) -> u0 -> Int, (u0, u0) -> u0 -> Bool)) -> case u1 of { _ALG_ _TUP_4 (u2 :: {{Ord u0}}) (u3 :: (u0, u0) -> [u0]) (u4 :: (u0, u0) -> u0 -> Int) (u5 :: (u0, u0) -> u0 -> Bool) -> u2; _NO_DEFLT_ } _N_ #-} where
range :: (a, a) -> [a]
{-# GHC_PRAGMA {-meth-} _A_ 1 _U_ 12 _N_ _S_ "U(ASAA)" {_A_ 1 _U_ 12 _N_ _N_ _F_ _IF_ARGS_ 1 1 X 1 _/\_ u0 -> \ (u1 :: (u0, u0) -> [u0]) -> u1 _N_} _F_ _IF_ARGS_ 1 1 C 2 _/\_ u0 -> \ (u1 :: ({{Ord u0}}, (u0, u0) -> [u0], (u0, u0) -> u0 -> Int, (u0, u0) -> u0 -> Bool)) -> case u1 of { _ALG_ _TUP_4 (u2 :: {{Ord u0}}) (u3 :: (u0, u0) -> [u0]) (u4 :: (u0, u0) -> u0 -> Int) (u5 :: (u0, u0) -> u0 -> Bool) -> u3; _NO_DEFLT_ } _N_
- {-defm-} _A_ 2 _U_ 02 _N_ _S_ _!_ _F_ _IF_ARGS_ 1 2 XX 3 _/\_ u0 -> \ (u1 :: {{Ix u0}}) (u2 :: (u0, u0)) -> _APP_ _TYAPP_ patError# { ((u0, u0) -> [u0]) } [ _NOREP_S_ "%DPreludeCore.Ix.range\"", u2 ] _N_ #-}
+ {-defm-} _A_ 2 _U_ 02 _N_ _S_ _!_ _N_ _N_ #-}
index :: (a, a) -> a -> Int
{-# GHC_PRAGMA {-meth-} _A_ 1 _U_ 122 _N_ _S_ "U(AASA)" {_A_ 1 _U_ 122 _N_ _N_ _F_ _IF_ARGS_ 1 1 X 1 _/\_ u0 -> \ (u1 :: (u0, u0) -> u0 -> Int) -> u1 _N_} _F_ _IF_ARGS_ 1 1 C 2 _/\_ u0 -> \ (u1 :: ({{Ord u0}}, (u0, u0) -> [u0], (u0, u0) -> u0 -> Int, (u0, u0) -> u0 -> Bool)) -> case u1 of { _ALG_ _TUP_4 (u2 :: {{Ord u0}}) (u3 :: (u0, u0) -> [u0]) (u4 :: (u0, u0) -> u0 -> Int) (u5 :: (u0, u0) -> u0 -> Bool) -> u4; _NO_DEFLT_ } _N_
- {-defm-} _A_ 3 _U_ 022 _N_ _S_ _!_ _F_ _IF_ARGS_ 1 3 XXX 4 _/\_ u0 -> \ (u1 :: {{Ix u0}}) (u2 :: (u0, u0)) (u3 :: u0) -> _APP_ _TYAPP_ patError# { ((u0, u0) -> u0 -> Int) } [ _NOREP_S_ "%DPreludeCore.Ix.index\"", u2, u3 ] _N_ #-}
+ {-defm-} _A_ 3 _U_ 022 _N_ _S_ _!_ _N_ _N_ #-}
inRange :: (a, a) -> a -> Bool
{-# GHC_PRAGMA {-meth-} _A_ 1 _U_ 122 _N_ _S_ "U(AAAS)" {_A_ 1 _U_ 122 _N_ _N_ _F_ _IF_ARGS_ 1 1 X 1 _/\_ u0 -> \ (u1 :: (u0, u0) -> u0 -> Bool) -> u1 _N_} _F_ _IF_ARGS_ 1 1 C 2 _/\_ u0 -> \ (u1 :: ({{Ord u0}}, (u0, u0) -> [u0], (u0, u0) -> u0 -> Int, (u0, u0) -> u0 -> Bool)) -> case u1 of { _ALG_ _TUP_4 (u2 :: {{Ord u0}}) (u3 :: (u0, u0) -> [u0]) (u4 :: (u0, u0) -> u0 -> Int) (u5 :: (u0, u0) -> u0 -> Bool) -> u5; _NO_DEFLT_ } _N_
- {-defm-} _A_ 3 _U_ 022 _N_ _S_ _!_ _F_ _IF_ARGS_ 1 3 XXX 4 _/\_ u0 -> \ (u1 :: {{Ix u0}}) (u2 :: (u0, u0)) (u3 :: u0) -> _APP_ _TYAPP_ patError# { ((u0, u0) -> u0 -> Bool) } [ _NOREP_S_ "%DPreludeCore.Ix.inRange\"", u2, u3 ] _N_ #-}
+ {-defm-} _A_ 3 _U_ 022 _N_ _S_ _!_ _N_ _N_ #-}
class (Eq a, Text a) => Num a {-# GHC_PRAGMA {-superdicts-} _A_ 1 _U_ 1 _N_ _S_ "U(U(LL)AAAAAAAAA)" {_A_ 2 _U_ 22 _N_ _N_ _F_ _IF_ARGS_ 1 2 XX 3 _/\_ u0 -> \ (u1 :: u0 -> u0 -> Bool) (u2 :: u0 -> u0 -> Bool) -> _!_ _TUP_2 [(u0 -> u0 -> Bool), (u0 -> u0 -> Bool)] [u1, u2] _N_} _F_ _IF_ARGS_ 1 1 C 2 _/\_ u0 -> \ (u1 :: ({{Eq u0}}, {{Text u0}}, u0 -> u0 -> u0, u0 -> u0 -> u0, u0 -> u0 -> u0, u0 -> u0, u0 -> u0, u0 -> u0, Integer -> u0, Int -> u0)) -> case u1 of { _ALG_ _TUP_10 (u2 :: {{Eq u0}}) (u3 :: {{Text u0}}) (u4 :: u0 -> u0 -> u0) (u5 :: u0 -> u0 -> u0) (u6 :: u0 -> u0 -> u0) (u7 :: u0 -> u0) (u8 :: u0 -> u0) (u9 :: u0 -> u0) (ua :: Integer -> u0) (ub :: Int -> u0) -> u2; _NO_DEFLT_ } _N_, _A_ 1 _U_ 1 _N_ _S_ "U(AU(LLLL)AAAAAAAA)" {_A_ 4 _U_ 2222 _N_ _N_ _F_ _IF_ARGS_ 1 4 XXXX 5 _/\_ u0 -> \ (u1 :: Int -> [Char] -> [(u0, [Char])]) (u2 :: Int -> u0 -> [Char] -> [Char]) (u3 :: [Char] -> [([u0], [Char])]) (u4 :: [u0] -> [Char] -> [Char]) -> _!_ _TUP_4 [(Int -> [Char] -> [(u0, [Char])]), (Int -> u0 -> [Char] -> [Char]), ([Char] -> [([u0], [Char])]), ([u0] -> [Char] -> [Char])] [u1, u2, u3, u4] _N_} _F_ _IF_ARGS_ 1 1 C 2 _/\_ u0 -> \ (u1 :: ({{Eq u0}}, {{Text u0}}, u0 -> u0 -> u0, u0 -> u0 -> u0, u0 -> u0 -> u0, u0 -> u0, u0 -> u0, u0 -> u0, Integer -> u0, Int -> u0)) -> case u1 of { _ALG_ _TUP_10 (u2 :: {{Eq u0}}) (u3 :: {{Text u0}}) (u4 :: u0 -> u0 -> u0) (u5 :: u0 -> u0 -> u0) (u6 :: u0 -> u0 -> u0) (u7 :: u0 -> u0) (u8 :: u0 -> u0) (u9 :: u0 -> u0) (ua :: Integer -> u0) (ub :: Int -> u0) -> u3; _NO_DEFLT_ } _N_ #-} where
(+) :: a -> a -> a
{-# GHC_PRAGMA {-meth-} _A_ 1 _U_ 122 _N_ _S_ "U(AASAAAAAAA)" {_A_ 1 _U_ 122 _N_ _N_ _F_ _IF_ARGS_ 1 1 X 1 _/\_ u0 -> \ (u1 :: u0 -> u0 -> u0) -> u1 _N_} _F_ _IF_ARGS_ 1 1 C 2 _/\_ u0 -> \ (u1 :: ({{Eq u0}}, {{Text u0}}, u0 -> u0 -> u0, u0 -> u0 -> u0, u0 -> u0 -> u0, u0 -> u0, u0 -> u0, u0 -> u0, Integer -> u0, Int -> u0)) -> case u1 of { _ALG_ _TUP_10 (u2 :: {{Eq u0}}) (u3 :: {{Text u0}}) (u4 :: u0 -> u0 -> u0) (u5 :: u0 -> u0 -> u0) (u6 :: u0 -> u0 -> u0) (u7 :: u0 -> u0) (u8 :: u0 -> u0) (u9 :: u0 -> u0) (ua :: Integer -> u0) (ub :: Int -> u0) -> u4; _NO_DEFLT_ } _N_
- {-defm-} _A_ 3 _U_ 022 _N_ _S_ _!_ _F_ _IF_ARGS_ 1 3 XXX 4 _/\_ u0 -> \ (u1 :: {{Num u0}}) (u2 :: u0) (u3 :: u0) -> _APP_ _TYAPP_ patError# { (u0 -> u0 -> u0) } [ _NOREP_S_ "%DPreludeCore.Num.(+)\"", u2, u3 ] _N_ #-}
+ {-defm-} _A_ 3 _U_ 022 _N_ _S_ _!_ _N_ _N_ #-}
(-) :: a -> a -> a
{-# GHC_PRAGMA {-meth-} _A_ 1 _U_ 122 _N_ _S_ "U(AAASAAAAAA)" {_A_ 1 _U_ 122 _N_ _N_ _F_ _IF_ARGS_ 1 1 X 1 _/\_ u0 -> \ (u1 :: u0 -> u0 -> u0) -> u1 _N_} _F_ _IF_ARGS_ 1 1 C 2 _/\_ u0 -> \ (u1 :: ({{Eq u0}}, {{Text u0}}, u0 -> u0 -> u0, u0 -> u0 -> u0, u0 -> u0 -> u0, u0 -> u0, u0 -> u0, u0 -> u0, Integer -> u0, Int -> u0)) -> case u1 of { _ALG_ _TUP_10 (u2 :: {{Eq u0}}) (u3 :: {{Text u0}}) (u4 :: u0 -> u0 -> u0) (u5 :: u0 -> u0 -> u0) (u6 :: u0 -> u0 -> u0) (u7 :: u0 -> u0) (u8 :: u0 -> u0) (u9 :: u0 -> u0) (ua :: Integer -> u0) (ub :: Int -> u0) -> u5; _NO_DEFLT_ } _N_
{-defm-} _A_ 3 _U_ 122 _N_ _S_ "U(AASAALAAAA)LL" {_A_ 4 _U_ 1122 _N_ _N_ _F_ _IF_ARGS_ 1 4 XXXX 6 _/\_ u0 -> \ (u1 :: u0 -> u0 -> u0) (u2 :: u0 -> u0) (u3 :: u0) (u4 :: u0) -> let {(u5 :: u0) = _APP_ u2 [ u4 ]} in _APP_ u1 [ u3, u5 ] _N_} _F_ _ALWAYS_ _/\_ u0 -> \ (u1 :: {{Num u0}}) (u2 :: u0) (u3 :: u0) -> case u1 of { _ALG_ _TUP_10 (u4 :: {{Eq u0}}) (u5 :: {{Text u0}}) (u6 :: u0 -> u0 -> u0) (u7 :: u0 -> u0 -> u0) (u8 :: u0 -> u0 -> u0) (u9 :: u0 -> u0) (ua :: u0 -> u0) (ub :: u0 -> u0) (uc :: Integer -> u0) (ud :: Int -> u0) -> let {(ue :: u0) = _APP_ u9 [ u3 ]} in _APP_ u6 [ u2, ue ]; _NO_DEFLT_ } _N_ #-}
(*) :: a -> a -> a
{-# GHC_PRAGMA {-meth-} _A_ 1 _U_ 122 _N_ _S_ "U(AAAASAAAAA)" {_A_ 1 _U_ 122 _N_ _N_ _F_ _IF_ARGS_ 1 1 X 1 _/\_ u0 -> \ (u1 :: u0 -> u0 -> u0) -> u1 _N_} _F_ _IF_ARGS_ 1 1 C 2 _/\_ u0 -> \ (u1 :: ({{Eq u0}}, {{Text u0}}, u0 -> u0 -> u0, u0 -> u0 -> u0, u0 -> u0 -> u0, u0 -> u0, u0 -> u0, u0 -> u0, Integer -> u0, Int -> u0)) -> case u1 of { _ALG_ _TUP_10 (u2 :: {{Eq u0}}) (u3 :: {{Text u0}}) (u4 :: u0 -> u0 -> u0) (u5 :: u0 -> u0 -> u0) (u6 :: u0 -> u0 -> u0) (u7 :: u0 -> u0) (u8 :: u0 -> u0) (u9 :: u0 -> u0) (ua :: Integer -> u0) (ub :: Int -> u0) -> u6; _NO_DEFLT_ } _N_
- {-defm-} _A_ 3 _U_ 022 _N_ _S_ _!_ _F_ _IF_ARGS_ 1 3 XXX 4 _/\_ u0 -> \ (u1 :: {{Num u0}}) (u2 :: u0) (u3 :: u0) -> _APP_ _TYAPP_ patError# { (u0 -> u0 -> u0) } [ _NOREP_S_ "%DPreludeCore.Num.(*)\"", u2, u3 ] _N_ #-}
+ {-defm-} _A_ 3 _U_ 022 _N_ _S_ _!_ _N_ _N_ #-}
negate :: a -> a
{-# GHC_PRAGMA {-meth-} _A_ 1 _U_ 12 _N_ _S_ "U(AAAAASAAAA)" {_A_ 1 _U_ 12 _N_ _N_ _F_ _IF_ARGS_ 1 1 X 1 _/\_ u0 -> \ (u1 :: u0 -> u0) -> u1 _N_} _F_ _IF_ARGS_ 1 1 C 2 _/\_ u0 -> \ (u1 :: ({{Eq u0}}, {{Text u0}}, u0 -> u0 -> u0, u0 -> u0 -> u0, u0 -> u0 -> u0, u0 -> u0, u0 -> u0, u0 -> u0, Integer -> u0, Int -> u0)) -> case u1 of { _ALG_ _TUP_10 (u2 :: {{Eq u0}}) (u3 :: {{Text u0}}) (u4 :: u0 -> u0 -> u0) (u5 :: u0 -> u0 -> u0) (u6 :: u0 -> u0 -> u0) (u7 :: u0 -> u0) (u8 :: u0 -> u0) (u9 :: u0 -> u0) (ua :: Integer -> u0) (ub :: Int -> u0) -> u7; _NO_DEFLT_ } _N_
- {-defm-} _A_ 2 _U_ 02 _N_ _S_ _!_ _F_ _IF_ARGS_ 1 2 XX 3 _/\_ u0 -> \ (u1 :: {{Num u0}}) (u2 :: u0) -> _APP_ _TYAPP_ patError# { (u0 -> u0) } [ _NOREP_S_ "%DPreludeCore.Num.negate\"", u2 ] _N_ #-}
+ {-defm-} _A_ 2 _U_ 02 _N_ _S_ _!_ _N_ _N_ #-}
abs :: a -> a
{-# GHC_PRAGMA {-meth-} _A_ 1 _U_ 12 _N_ _S_ "U(AAAAAASAAA)" {_A_ 1 _U_ 12 _N_ _N_ _F_ _IF_ARGS_ 1 1 X 1 _/\_ u0 -> \ (u1 :: u0 -> u0) -> u1 _N_} _F_ _IF_ARGS_ 1 1 C 2 _/\_ u0 -> \ (u1 :: ({{Eq u0}}, {{Text u0}}, u0 -> u0 -> u0, u0 -> u0 -> u0, u0 -> u0 -> u0, u0 -> u0, u0 -> u0, u0 -> u0, Integer -> u0, Int -> u0)) -> case u1 of { _ALG_ _TUP_10 (u2 :: {{Eq u0}}) (u3 :: {{Text u0}}) (u4 :: u0 -> u0 -> u0) (u5 :: u0 -> u0 -> u0) (u6 :: u0 -> u0 -> u0) (u7 :: u0 -> u0) (u8 :: u0 -> u0) (u9 :: u0 -> u0) (ua :: Integer -> u0) (ub :: Int -> u0) -> u8; _NO_DEFLT_ } _N_
- {-defm-} _A_ 2 _U_ 02 _N_ _S_ _!_ _F_ _IF_ARGS_ 1 2 XX 3 _/\_ u0 -> \ (u1 :: {{Num u0}}) (u2 :: u0) -> _APP_ _TYAPP_ patError# { (u0 -> u0) } [ _NOREP_S_ "%DPreludeCore.Num.abs\"", u2 ] _N_ #-}
+ {-defm-} _A_ 2 _U_ 02 _N_ _S_ _!_ _N_ _N_ #-}
signum :: a -> a
{-# GHC_PRAGMA {-meth-} _A_ 1 _U_ 12 _N_ _S_ "U(AAAAAAASAA)" {_A_ 1 _U_ 12 _N_ _N_ _F_ _IF_ARGS_ 1 1 X 1 _/\_ u0 -> \ (u1 :: u0 -> u0) -> u1 _N_} _F_ _IF_ARGS_ 1 1 C 2 _/\_ u0 -> \ (u1 :: ({{Eq u0}}, {{Text u0}}, u0 -> u0 -> u0, u0 -> u0 -> u0, u0 -> u0 -> u0, u0 -> u0, u0 -> u0, u0 -> u0, Integer -> u0, Int -> u0)) -> case u1 of { _ALG_ _TUP_10 (u2 :: {{Eq u0}}) (u3 :: {{Text u0}}) (u4 :: u0 -> u0 -> u0) (u5 :: u0 -> u0 -> u0) (u6 :: u0 -> u0 -> u0) (u7 :: u0 -> u0) (u8 :: u0 -> u0) (u9 :: u0 -> u0) (ua :: Integer -> u0) (ub :: Int -> u0) -> u9; _NO_DEFLT_ } _N_
- {-defm-} _A_ 2 _U_ 02 _N_ _S_ _!_ _F_ _IF_ARGS_ 1 2 XX 3 _/\_ u0 -> \ (u1 :: {{Num u0}}) (u2 :: u0) -> _APP_ _TYAPP_ patError# { (u0 -> u0) } [ _NOREP_S_ "%DPreludeCore.Num.signum\"", u2 ] _N_ #-}
+ {-defm-} _A_ 2 _U_ 02 _N_ _S_ _!_ _N_ _N_ #-}
fromInteger :: Integer -> a
{-# GHC_PRAGMA {-meth-} _A_ 1 _U_ 12 _N_ _S_ "U(AAAAAAAASA)" {_A_ 1 _U_ 12 _N_ _N_ _F_ _IF_ARGS_ 1 1 X 1 _/\_ u0 -> \ (u1 :: Integer -> u0) -> u1 _N_} _F_ _IF_ARGS_ 1 1 C 2 _/\_ u0 -> \ (u1 :: ({{Eq u0}}, {{Text u0}}, u0 -> u0 -> u0, u0 -> u0 -> u0, u0 -> u0 -> u0, u0 -> u0, u0 -> u0, u0 -> u0, Integer -> u0, Int -> u0)) -> case u1 of { _ALG_ _TUP_10 (u2 :: {{Eq u0}}) (u3 :: {{Text u0}}) (u4 :: u0 -> u0 -> u0) (u5 :: u0 -> u0 -> u0) (u6 :: u0 -> u0 -> u0) (u7 :: u0 -> u0) (u8 :: u0 -> u0) (u9 :: u0 -> u0) (ua :: Integer -> u0) (ub :: Int -> u0) -> ua; _NO_DEFLT_ } _N_
- {-defm-} _A_ 2 _U_ 02 _N_ _S_ _!_ _F_ _IF_ARGS_ 1 2 XX 3 _/\_ u0 -> \ (u1 :: {{Num u0}}) (u2 :: Integer) -> _APP_ _TYAPP_ patError# { (Integer -> u0) } [ _NOREP_S_ "%DPreludeCore.Num.fromInteger\"", u2 ] _N_ #-}
+ {-defm-} _A_ 2 _U_ 02 _N_ _S_ _!_ _N_ _N_ #-}
fromInt :: Int -> a
{-# GHC_PRAGMA {-meth-} _A_ 1 _U_ 12 _N_ _S_ "U(AAAAAAAAAS)" {_A_ 1 _U_ 12 _N_ _N_ _F_ _IF_ARGS_ 1 1 X 1 _/\_ u0 -> \ (u1 :: Int -> u0) -> u1 _N_} _F_ _IF_ARGS_ 1 1 C 2 _/\_ u0 -> \ (u1 :: ({{Eq u0}}, {{Text u0}}, u0 -> u0 -> u0, u0 -> u0 -> u0, u0 -> u0 -> u0, u0 -> u0, u0 -> u0, u0 -> u0, Integer -> u0, Int -> u0)) -> case u1 of { _ALG_ _TUP_10 (u2 :: {{Eq u0}}) (u3 :: {{Text u0}}) (u4 :: u0 -> u0 -> u0) (u5 :: u0 -> u0 -> u0) (u6 :: u0 -> u0 -> u0) (u7 :: u0 -> u0) (u8 :: u0 -> u0) (u9 :: u0 -> u0) (ua :: Integer -> u0) (ub :: Int -> u0) -> ub; _NO_DEFLT_ } _N_
{-defm-} _A_ 2 _U_ 11 _N_ _S_ "U(AAAAAAAASA)L" {_A_ 2 _U_ 11 _N_ _N_ _F_ _IF_ARGS_ 1 2 XC 5 _/\_ u0 -> \ (u1 :: Integer -> u0) (u2 :: Int) -> let {(u4 :: Integer) = case u2 of { _ALG_ I# (u3 :: Int#) -> _#_ int2Integer# [] [u3]; _NO_DEFLT_ }} in _APP_ u1 [ u4 ] _N_} _F_ _IF_ARGS_ 1 2 CC 6 _/\_ u0 -> \ (u1 :: {{Num u0}}) (u2 :: Int) -> let {(u4 :: Integer) = case u2 of { _ALG_ I# (u3 :: Int#) -> _#_ int2Integer# [] [u3]; _NO_DEFLT_ }} in case u1 of { _ALG_ _TUP_10 (u5 :: {{Eq u0}}) (u6 :: {{Text u0}}) (u7 :: u0 -> u0 -> u0) (u8 :: u0 -> u0 -> u0) (u9 :: u0 -> u0 -> u0) (ua :: u0 -> u0) (ub :: u0 -> u0) (uc :: u0 -> u0) (ud :: Integer -> u0) (ue :: Int -> u0) -> _APP_ ud [ u4 ]; _NO_DEFLT_ } _N_ #-}
{-defm-} _A_ 3 _U_ 122 _N_ _S_ "U(LASAAAAA)LL" {_A_ 4 _U_ 1122 _N_ _N_ _N_ _N_} _N_ _N_ #-}
(<=) :: a -> a -> Bool
{-# GHC_PRAGMA {-meth-} _A_ 1 _U_ 122 _N_ _S_ "U(AASAAAAA)" {_A_ 1 _U_ 122 _N_ _N_ _F_ _IF_ARGS_ 1 1 X 1 _/\_ u0 -> \ (u1 :: u0 -> u0 -> Bool) -> u1 _N_} _F_ _IF_ARGS_ 1 1 C 2 _/\_ u0 -> \ (u1 :: ({{Eq u0}}, u0 -> u0 -> Bool, u0 -> u0 -> Bool, u0 -> u0 -> Bool, u0 -> u0 -> Bool, u0 -> u0 -> u0, u0 -> u0 -> u0, u0 -> u0 -> _CMP_TAG)) -> case u1 of { _ALG_ _TUP_8 (u2 :: {{Eq u0}}) (u3 :: u0 -> u0 -> Bool) (u4 :: u0 -> u0 -> Bool) (u5 :: u0 -> u0 -> Bool) (u6 :: u0 -> u0 -> Bool) (u7 :: u0 -> u0 -> u0) (u8 :: u0 -> u0 -> u0) (u9 :: u0 -> u0 -> _CMP_TAG) -> u4; _NO_DEFLT_ } _N_
- {-defm-} _A_ 3 _U_ 022 _N_ _S_ _!_ _F_ _IF_ARGS_ 1 3 XXX 4 _/\_ u0 -> \ (u1 :: {{Ord u0}}) (u2 :: u0) (u3 :: u0) -> _APP_ _TYAPP_ patError# { (u0 -> u0 -> Bool) } [ _NOREP_S_ "%DPreludeCore.Ord.(<=)\"", u2, u3 ] _N_ #-}
+ {-defm-} _A_ 3 _U_ 022 _N_ _S_ _!_ _N_ _N_ #-}
(>=) :: a -> a -> Bool
{-# GHC_PRAGMA {-meth-} _A_ 1 _U_ 122 _N_ _S_ "U(AAASAAAA)" {_A_ 1 _U_ 122 _N_ _N_ _F_ _IF_ARGS_ 1 1 X 1 _/\_ u0 -> \ (u1 :: u0 -> u0 -> Bool) -> u1 _N_} _F_ _IF_ARGS_ 1 1 C 2 _/\_ u0 -> \ (u1 :: ({{Eq u0}}, u0 -> u0 -> Bool, u0 -> u0 -> Bool, u0 -> u0 -> Bool, u0 -> u0 -> Bool, u0 -> u0 -> u0, u0 -> u0 -> u0, u0 -> u0 -> _CMP_TAG)) -> case u1 of { _ALG_ _TUP_8 (u2 :: {{Eq u0}}) (u3 :: u0 -> u0 -> Bool) (u4 :: u0 -> u0 -> Bool) (u5 :: u0 -> u0 -> Bool) (u6 :: u0 -> u0 -> Bool) (u7 :: u0 -> u0 -> u0) (u8 :: u0 -> u0 -> u0) (u9 :: u0 -> u0 -> _CMP_TAG) -> u5; _NO_DEFLT_ } _N_
{-defm-} _A_ 3 _U_ 122 _N_ _S_ "U(AASAAAAA)LL" {_A_ 3 _U_ 122 _N_ _N_ _F_ _IF_ARGS_ 1 3 XXX 3 _/\_ u0 -> \ (u1 :: u0 -> u0 -> Bool) (u2 :: u0) (u3 :: u0) -> _APP_ u1 [ u3, u2 ] _N_} _F_ _IF_ARGS_ 1 3 CXX 4 _/\_ u0 -> \ (u1 :: {{Ord u0}}) (u2 :: u0) (u3 :: u0) -> case u1 of { _ALG_ _TUP_8 (u4 :: {{Eq u0}}) (u5 :: u0 -> u0 -> Bool) (u6 :: u0 -> u0 -> Bool) (u7 :: u0 -> u0 -> Bool) (u8 :: u0 -> u0 -> Bool) (u9 :: u0 -> u0 -> u0) (ua :: u0 -> u0 -> u0) (ub :: u0 -> u0 -> _CMP_TAG) -> _APP_ u6 [ u3, u2 ]; _NO_DEFLT_ } _N_ #-}
class (Num a, Enum a) => Real a {-# GHC_PRAGMA {-superdicts-} _A_ 1 _U_ 1 _N_ _S_ "U(U(LLLLLLLLLL)AA)" {_A_ 1 _U_ 1 _N_ _N_ _F_ _IF_ARGS_ 1 1 X 1 _/\_ u0 -> \ (u1 :: {{Num u0}}) -> u1 _N_} _F_ _IF_ARGS_ 1 1 C 2 _/\_ u0 -> \ (u1 :: ({{Num u0}}, {{Enum u0}}, u0 -> Ratio Integer)) -> case u1 of { _ALG_ _TUP_3 (u2 :: {{Num u0}}) (u3 :: {{Enum u0}}) (u4 :: u0 -> Ratio Integer) -> u2; _NO_DEFLT_ } _N_, _A_ 1 _U_ 1 _N_ _S_ "U(AU(LLLLL)A)" {_A_ 5 _U_ 22222 _N_ _N_ _F_ _IF_ARGS_ 1 5 XXXXX 6 _/\_ u0 -> \ (u1 :: {{Ord u0}}) (u2 :: u0 -> [u0]) (u3 :: u0 -> u0 -> [u0]) (u4 :: u0 -> u0 -> [u0]) (u5 :: u0 -> u0 -> u0 -> [u0]) -> _!_ _TUP_5 [{{Ord u0}}, (u0 -> [u0]), (u0 -> u0 -> [u0]), (u0 -> u0 -> [u0]), (u0 -> u0 -> u0 -> [u0])] [u1, u2, u3, u4, u5] _N_} _F_ _IF_ARGS_ 1 1 C 2 _/\_ u0 -> \ (u1 :: ({{Num u0}}, {{Enum u0}}, u0 -> Ratio Integer)) -> case u1 of { _ALG_ _TUP_3 (u2 :: {{Num u0}}) (u3 :: {{Enum u0}}) (u4 :: u0 -> Ratio Integer) -> u3; _NO_DEFLT_ } _N_ #-} where
toRational :: a -> Ratio Integer
{-# GHC_PRAGMA {-meth-} _A_ 1 _U_ 12 _N_ _S_ "U(AAS)" {_A_ 1 _U_ 12 _N_ _N_ _F_ _IF_ARGS_ 1 1 X 1 _/\_ u0 -> \ (u1 :: u0 -> Ratio Integer) -> u1 _N_} _F_ _IF_ARGS_ 1 1 C 2 _/\_ u0 -> \ (u1 :: ({{Num u0}}, {{Enum u0}}, u0 -> Ratio Integer)) -> case u1 of { _ALG_ _TUP_3 (u2 :: {{Num u0}}) (u3 :: {{Enum u0}}) (u4 :: u0 -> Ratio Integer) -> u4; _NO_DEFLT_ } _N_
- {-defm-} _A_ 2 _U_ 02 _N_ _S_ _!_ _F_ _IF_ARGS_ 1 2 XX 3 _/\_ u0 -> \ (u1 :: {{Real u0}}) (u2 :: u0) -> _APP_ _TYAPP_ patError# { (u0 -> Ratio Integer) } [ _NOREP_S_ "%DPreludeCore.Real.toRational\"", u2 ] _N_ #-}
+ {-defm-} _A_ 2 _U_ 02 _N_ _S_ _!_ _N_ _N_ #-}
class (RealFrac a, Floating a) => RealFloat a {-# GHC_PRAGMA {-superdicts-} _A_ 1 _U_ 1 _N_ _S_ "U(U(LLLLLLL)AAAAAAAAA)" {_A_ 1 _U_ 1 _N_ _N_ _F_ _IF_ARGS_ 1 1 X 1 _/\_ u0 -> \ (u1 :: {{RealFrac u0}}) -> u1 _N_} _F_ _IF_ARGS_ 1 1 C 2 _/\_ u0 -> \ (u1 :: ({{RealFrac u0}}, {{Floating u0}}, u0 -> Integer, u0 -> Int, u0 -> (Int, Int), u0 -> (Integer, Int), Integer -> Int -> u0, u0 -> Int, u0 -> u0, Int -> u0 -> u0)) -> case u1 of { _ALG_ _TUP_10 (u2 :: {{RealFrac u0}}) (u3 :: {{Floating u0}}) (u4 :: u0 -> Integer) (u5 :: u0 -> Int) (u6 :: u0 -> (Int, Int)) (u7 :: u0 -> (Integer, Int)) (u8 :: Integer -> Int -> u0) (u9 :: u0 -> Int) (ua :: u0 -> u0) (ub :: Int -> u0 -> u0) -> u2; _NO_DEFLT_ } _N_, _A_ 1 _U_ 1 _N_ _S_ "U(AU(LLLLLLLLLLLLLLLLLLL)AAAAAAAA)" {_A_ 1 _U_ 1 _N_ _N_ _F_ _IF_ARGS_ 1 1 X 1 _/\_ u0 -> \ (u1 :: {{Floating u0}}) -> u1 _N_} _F_ _IF_ARGS_ 1 1 C 2 _/\_ u0 -> \ (u1 :: ({{RealFrac u0}}, {{Floating u0}}, u0 -> Integer, u0 -> Int, u0 -> (Int, Int), u0 -> (Integer, Int), Integer -> Int -> u0, u0 -> Int, u0 -> u0, Int -> u0 -> u0)) -> case u1 of { _ALG_ _TUP_10 (u2 :: {{RealFrac u0}}) (u3 :: {{Floating u0}}) (u4 :: u0 -> Integer) (u5 :: u0 -> Int) (u6 :: u0 -> (Int, Int)) (u7 :: u0 -> (Integer, Int)) (u8 :: Integer -> Int -> u0) (u9 :: u0 -> Int) (ua :: u0 -> u0) (ub :: Int -> u0 -> u0) -> u3; _NO_DEFLT_ } _N_ #-} where
floatRadix :: a -> Integer
{-# GHC_PRAGMA {-meth-} _A_ 1 _U_ 12 _N_ _S_ "U(AASAAAAAAA)" {_A_ 1 _U_ 12 _N_ _N_ _F_ _IF_ARGS_ 1 1 X 1 _/\_ u0 -> \ (u1 :: u0 -> Integer) -> u1 _N_} _F_ _IF_ARGS_ 1 1 C 2 _/\_ u0 -> \ (u1 :: ({{RealFrac u0}}, {{Floating u0}}, u0 -> Integer, u0 -> Int, u0 -> (Int, Int), u0 -> (Integer, Int), Integer -> Int -> u0, u0 -> Int, u0 -> u0, Int -> u0 -> u0)) -> case u1 of { _ALG_ _TUP_10 (u2 :: {{RealFrac u0}}) (u3 :: {{Floating u0}}) (u4 :: u0 -> Integer) (u5 :: u0 -> Int) (u6 :: u0 -> (Int, Int)) (u7 :: u0 -> (Integer, Int)) (u8 :: Integer -> Int -> u0) (u9 :: u0 -> Int) (ua :: u0 -> u0) (ub :: Int -> u0 -> u0) -> u4; _NO_DEFLT_ } _N_
- {-defm-} _A_ 2 _U_ 02 _N_ _S_ _!_ _F_ _IF_ARGS_ 1 2 XX 3 _/\_ u0 -> \ (u1 :: {{RealFloat u0}}) (u2 :: u0) -> _APP_ _TYAPP_ patError# { (u0 -> Integer) } [ _NOREP_S_ "%DPreludeCore.RealFloat.floatRadix\"", u2 ] _N_ #-}
+ {-defm-} _A_ 2 _U_ 02 _N_ _S_ _!_ _N_ _N_ #-}
floatDigits :: a -> Int
{-# GHC_PRAGMA {-meth-} _A_ 1 _U_ 12 _N_ _S_ "U(AAASAAAAAA)" {_A_ 1 _U_ 12 _N_ _N_ _F_ _IF_ARGS_ 1 1 X 1 _/\_ u0 -> \ (u1 :: u0 -> Int) -> u1 _N_} _F_ _IF_ARGS_ 1 1 C 2 _/\_ u0 -> \ (u1 :: ({{RealFrac u0}}, {{Floating u0}}, u0 -> Integer, u0 -> Int, u0 -> (Int, Int), u0 -> (Integer, Int), Integer -> Int -> u0, u0 -> Int, u0 -> u0, Int -> u0 -> u0)) -> case u1 of { _ALG_ _TUP_10 (u2 :: {{RealFrac u0}}) (u3 :: {{Floating u0}}) (u4 :: u0 -> Integer) (u5 :: u0 -> Int) (u6 :: u0 -> (Int, Int)) (u7 :: u0 -> (Integer, Int)) (u8 :: Integer -> Int -> u0) (u9 :: u0 -> Int) (ua :: u0 -> u0) (ub :: Int -> u0 -> u0) -> u5; _NO_DEFLT_ } _N_
- {-defm-} _A_ 2 _U_ 02 _N_ _S_ _!_ _F_ _IF_ARGS_ 1 2 XX 3 _/\_ u0 -> \ (u1 :: {{RealFloat u0}}) (u2 :: u0) -> _APP_ _TYAPP_ patError# { (u0 -> Int) } [ _NOREP_S_ "%DPreludeCore.RealFloat.floatDigits\"", u2 ] _N_ #-}
+ {-defm-} _A_ 2 _U_ 02 _N_ _S_ _!_ _N_ _N_ #-}
floatRange :: a -> (Int, Int)
{-# GHC_PRAGMA {-meth-} _A_ 1 _U_ 12 _N_ _S_ "U(AAAASAAAAA)" {_A_ 1 _U_ 12 _N_ _N_ _F_ _IF_ARGS_ 1 1 X 1 _/\_ u0 -> \ (u1 :: u0 -> (Int, Int)) -> u1 _N_} _F_ _IF_ARGS_ 1 1 C 2 _/\_ u0 -> \ (u1 :: ({{RealFrac u0}}, {{Floating u0}}, u0 -> Integer, u0 -> Int, u0 -> (Int, Int), u0 -> (Integer, Int), Integer -> Int -> u0, u0 -> Int, u0 -> u0, Int -> u0 -> u0)) -> case u1 of { _ALG_ _TUP_10 (u2 :: {{RealFrac u0}}) (u3 :: {{Floating u0}}) (u4 :: u0 -> Integer) (u5 :: u0 -> Int) (u6 :: u0 -> (Int, Int)) (u7 :: u0 -> (Integer, Int)) (u8 :: Integer -> Int -> u0) (u9 :: u0 -> Int) (ua :: u0 -> u0) (ub :: Int -> u0 -> u0) -> u6; _NO_DEFLT_ } _N_
- {-defm-} _A_ 2 _U_ 02 _N_ _S_ _!_ _F_ _IF_ARGS_ 1 2 XX 3 _/\_ u0 -> \ (u1 :: {{RealFloat u0}}) (u2 :: u0) -> _APP_ _TYAPP_ patError# { (u0 -> (Int, Int)) } [ _NOREP_S_ "%DPreludeCore.RealFloat.floatRange\"", u2 ] _N_ #-}
+ {-defm-} _A_ 2 _U_ 02 _N_ _S_ _!_ _N_ _N_ #-}
decodeFloat :: a -> (Integer, Int)
{-# GHC_PRAGMA {-meth-} _A_ 1 _U_ 12 _N_ _S_ "U(AAAAASAAAA)" {_A_ 1 _U_ 12 _N_ _N_ _F_ _IF_ARGS_ 1 1 X 1 _/\_ u0 -> \ (u1 :: u0 -> (Integer, Int)) -> u1 _N_} _F_ _IF_ARGS_ 1 1 C 2 _/\_ u0 -> \ (u1 :: ({{RealFrac u0}}, {{Floating u0}}, u0 -> Integer, u0 -> Int, u0 -> (Int, Int), u0 -> (Integer, Int), Integer -> Int -> u0, u0 -> Int, u0 -> u0, Int -> u0 -> u0)) -> case u1 of { _ALG_ _TUP_10 (u2 :: {{RealFrac u0}}) (u3 :: {{Floating u0}}) (u4 :: u0 -> Integer) (u5 :: u0 -> Int) (u6 :: u0 -> (Int, Int)) (u7 :: u0 -> (Integer, Int)) (u8 :: Integer -> Int -> u0) (u9 :: u0 -> Int) (ua :: u0 -> u0) (ub :: Int -> u0 -> u0) -> u7; _NO_DEFLT_ } _N_
- {-defm-} _A_ 2 _U_ 02 _N_ _S_ _!_ _F_ _IF_ARGS_ 1 2 XX 3 _/\_ u0 -> \ (u1 :: {{RealFloat u0}}) (u2 :: u0) -> _APP_ _TYAPP_ patError# { (u0 -> (Integer, Int)) } [ _NOREP_S_ "%DPreludeCore.RealFloat.decodeFloat\"", u2 ] _N_ #-}
+ {-defm-} _A_ 2 _U_ 02 _N_ _S_ _!_ _N_ _N_ #-}
encodeFloat :: Integer -> Int -> a
{-# GHC_PRAGMA {-meth-} _A_ 1 _U_ 122 _N_ _S_ "U(AAAAAASAAA)" {_A_ 1 _U_ 122 _N_ _N_ _F_ _IF_ARGS_ 1 1 X 1 _/\_ u0 -> \ (u1 :: Integer -> Int -> u0) -> u1 _N_} _F_ _IF_ARGS_ 1 1 C 2 _/\_ u0 -> \ (u1 :: ({{RealFrac u0}}, {{Floating u0}}, u0 -> Integer, u0 -> Int, u0 -> (Int, Int), u0 -> (Integer, Int), Integer -> Int -> u0, u0 -> Int, u0 -> u0, Int -> u0 -> u0)) -> case u1 of { _ALG_ _TUP_10 (u2 :: {{RealFrac u0}}) (u3 :: {{Floating u0}}) (u4 :: u0 -> Integer) (u5 :: u0 -> Int) (u6 :: u0 -> (Int, Int)) (u7 :: u0 -> (Integer, Int)) (u8 :: Integer -> Int -> u0) (u9 :: u0 -> Int) (ua :: u0 -> u0) (ub :: Int -> u0 -> u0) -> u8; _NO_DEFLT_ } _N_
- {-defm-} _A_ 3 _U_ 022 _N_ _S_ _!_ _F_ _IF_ARGS_ 1 3 XXX 4 _/\_ u0 -> \ (u1 :: {{RealFloat u0}}) (u2 :: Integer) (u3 :: Int) -> _APP_ _TYAPP_ patError# { (Integer -> Int -> u0) } [ _NOREP_S_ "%DPreludeCore.RealFloat.encodeFloat\"", u2, u3 ] _N_ #-}
+ {-defm-} _A_ 3 _U_ 022 _N_ _S_ _!_ _N_ _N_ #-}
exponent :: a -> Int
{-# GHC_PRAGMA {-meth-} _A_ 1 _U_ 12 _N_ _S_ "U(AAAAAAASAA)" {_A_ 1 _U_ 12 _N_ _N_ _F_ _IF_ARGS_ 1 1 X 1 _/\_ u0 -> \ (u1 :: u0 -> Int) -> u1 _N_} _F_ _IF_ARGS_ 1 1 C 2 _/\_ u0 -> \ (u1 :: ({{RealFrac u0}}, {{Floating u0}}, u0 -> Integer, u0 -> Int, u0 -> (Int, Int), u0 -> (Integer, Int), Integer -> Int -> u0, u0 -> Int, u0 -> u0, Int -> u0 -> u0)) -> case u1 of { _ALG_ _TUP_10 (u2 :: {{RealFrac u0}}) (u3 :: {{Floating u0}}) (u4 :: u0 -> Integer) (u5 :: u0 -> Int) (u6 :: u0 -> (Int, Int)) (u7 :: u0 -> (Integer, Int)) (u8 :: Integer -> Int -> u0) (u9 :: u0 -> Int) (ua :: u0 -> u0) (ub :: Int -> u0 -> u0) -> u9; _NO_DEFLT_ } _N_
{-defm-} _A_ 2 _U_ 12 _N_ _S_ "U(AAALASAAAA)L" {_A_ 3 _U_ 112 _N_ _N_ _N_ _N_} _N_ _N_ #-}
class (Real a, Fractional a) => RealFrac a {-# GHC_PRAGMA {-superdicts-} _A_ 1 _U_ 1 _N_ _S_ "U(U(LLL)AAAAAA)" {_A_ 3 _U_ 222 _N_ _N_ _F_ _IF_ARGS_ 1 3 XXX 4 _/\_ u0 -> \ (u1 :: {{Num u0}}) (u2 :: {{Enum u0}}) (u3 :: u0 -> Ratio Integer) -> _!_ _TUP_3 [{{Num u0}}, {{Enum u0}}, (u0 -> Ratio Integer)] [u1, u2, u3] _N_} _F_ _IF_ARGS_ 1 1 C 2 _/\_ u0 -> \ (u1 :: ({{Real u0}}, {{Fractional u0}}, (_forall_ z$z1 =>{{Integral z$z1}} -> u0 -> (z$z1, u0)), (_forall_ z$z1 =>{{Integral z$z1}} -> u0 -> z$z1), (_forall_ z$z1 =>{{Integral z$z1}} -> u0 -> z$z1), (_forall_ z$z1 =>{{Integral z$z1}} -> u0 -> z$z1), (_forall_ z$z1 =>{{Integral z$z1}} -> u0 -> z$z1))) -> case u1 of { _ALG_ _TUP_7 (u2 :: {{Real u0}}) (u3 :: {{Fractional u0}}) (u4 :: _forall_ a$z1 =>{{Integral a$z1}} -> u0 -> (a$z1, u0)) (u5 :: _forall_ a$z1 =>{{Integral a$z1}} -> u0 -> a$z1) (u6 :: _forall_ a$z1 =>{{Integral a$z1}} -> u0 -> a$z1) (u7 :: _forall_ a$z1 =>{{Integral a$z1}} -> u0 -> a$z1) (u8 :: _forall_ a$z1 =>{{Integral a$z1}} -> u0 -> a$z1) -> u2; _NO_DEFLT_ } _N_, _A_ 1 _U_ 1 _N_ _S_ "U(AU(LLLL)AAAAA)" {_A_ 4 _U_ 2222 _N_ _N_ _F_ _IF_ARGS_ 1 4 XXXX 5 _/\_ u0 -> \ (u1 :: {{Num u0}}) (u2 :: u0 -> u0 -> u0) (u3 :: u0 -> u0) (u4 :: Ratio Integer -> u0) -> _!_ _TUP_4 [{{Num u0}}, (u0 -> u0 -> u0), (u0 -> u0), (Ratio Integer -> u0)] [u1, u2, u3, u4] _N_} _F_ _IF_ARGS_ 1 1 C 2 _/\_ u0 -> \ (u1 :: ({{Real u0}}, {{Fractional u0}}, (_forall_ z$z1 =>{{Integral z$z1}} -> u0 -> (z$z1, u0)), (_forall_ z$z1 =>{{Integral z$z1}} -> u0 -> z$z1), (_forall_ z$z1 =>{{Integral z$z1}} -> u0 -> z$z1), (_forall_ z$z1 =>{{Integral z$z1}} -> u0 -> z$z1), (_forall_ z$z1 =>{{Integral z$z1}} -> u0 -> z$z1))) -> case u1 of { _ALG_ _TUP_7 (u2 :: {{Real u0}}) (u3 :: {{Fractional u0}}) (u4 :: _forall_ a$z1 =>{{Integral a$z1}} -> u0 -> (a$z1, u0)) (u5 :: _forall_ a$z1 =>{{Integral a$z1}} -> u0 -> a$z1) (u6 :: _forall_ a$z1 =>{{Integral a$z1}} -> u0 -> a$z1) (u7 :: _forall_ a$z1 =>{{Integral a$z1}} -> u0 -> a$z1) (u8 :: _forall_ a$z1 =>{{Integral a$z1}} -> u0 -> a$z1) -> u3; _NO_DEFLT_ } _N_ #-} where
properFraction :: Integral b => a -> (b, a)
{-# GHC_PRAGMA {-meth-} _A_ 2 _U_ 122 _N_ _S_ "U(AASAAAA)L" {_A_ 2 _U_ 122 _N_ _N_ _F_ _IF_ARGS_ 2 2 XX 2 _/\_ u0 u1 -> \ (u2 :: _forall_ a$z1 =>{{Integral a$z1}} -> u0 -> (a$z1, u0)) (u3 :: {{Integral u1}}) -> _APP_ _TYAPP_ u2 { u1 } [ u3 ] _N_} _F_ _IF_ARGS_ 2 2 CX 3 _/\_ u0 u1 -> \ (u2 :: ({{Real u0}}, {{Fractional u0}}, (_forall_ z$z1 =>{{Integral z$z1}} -> u0 -> (z$z1, u0)), (_forall_ z$z1 =>{{Integral z$z1}} -> u0 -> z$z1), (_forall_ z$z1 =>{{Integral z$z1}} -> u0 -> z$z1), (_forall_ z$z1 =>{{Integral z$z1}} -> u0 -> z$z1), (_forall_ z$z1 =>{{Integral z$z1}} -> u0 -> z$z1))) (u3 :: {{Integral u1}}) -> case u2 of { _ALG_ _TUP_7 (u4 :: {{Real u0}}) (u5 :: {{Fractional u0}}) (u6 :: _forall_ a$z1 =>{{Integral a$z1}} -> u0 -> (a$z1, u0)) (u7 :: _forall_ a$z1 =>{{Integral a$z1}} -> u0 -> a$z1) (u8 :: _forall_ a$z1 =>{{Integral a$z1}} -> u0 -> a$z1) (u9 :: _forall_ a$z1 =>{{Integral a$z1}} -> u0 -> a$z1) (ua :: _forall_ a$z1 =>{{Integral a$z1}} -> u0 -> a$z1) -> _APP_ _TYAPP_ u6 { u1 } [ u3 ]; _NO_DEFLT_ } _N_
- {-defm-} _A_ 3 _U_ 002 _N_ _S_ _!_ _F_ _IF_ARGS_ 2 3 XXX 3 _/\_ u0 u1 -> \ (u2 :: {{RealFrac u0}}) (u3 :: {{Integral u1}}) (u4 :: u0) -> _APP_ _TYAPP_ patError# { (u0 -> (u1, u0)) } [ _NOREP_S_ "%DPreludeCore.RealFrac.properFraction\"", u4 ] _N_ #-}
+ {-defm-} _A_ 3 _U_ 002 _N_ _S_ _!_ _N_ _N_ #-}
truncate :: Integral b => a -> b
{-# GHC_PRAGMA {-meth-} _A_ 2 _U_ 122 _N_ _S_ "U(AAASAAA)L" {_A_ 2 _U_ 122 _N_ _N_ _F_ _IF_ARGS_ 2 2 XX 2 _/\_ u0 u1 -> \ (u2 :: _forall_ a$z1 =>{{Integral a$z1}} -> u0 -> a$z1) (u3 :: {{Integral u1}}) -> _APP_ _TYAPP_ u2 { u1 } [ u3 ] _N_} _F_ _IF_ARGS_ 2 2 CX 3 _/\_ u0 u1 -> \ (u2 :: ({{Real u0}}, {{Fractional u0}}, (_forall_ z$z1 =>{{Integral z$z1}} -> u0 -> (z$z1, u0)), (_forall_ z$z1 =>{{Integral z$z1}} -> u0 -> z$z1), (_forall_ z$z1 =>{{Integral z$z1}} -> u0 -> z$z1), (_forall_ z$z1 =>{{Integral z$z1}} -> u0 -> z$z1), (_forall_ z$z1 =>{{Integral z$z1}} -> u0 -> z$z1))) (u3 :: {{Integral u1}}) -> case u2 of { _ALG_ _TUP_7 (u4 :: {{Real u0}}) (u5 :: {{Fractional u0}}) (u6 :: _forall_ a$z1 =>{{Integral a$z1}} -> u0 -> (a$z1, u0)) (u7 :: _forall_ a$z1 =>{{Integral a$z1}} -> u0 -> a$z1) (u8 :: _forall_ a$z1 =>{{Integral a$z1}} -> u0 -> a$z1) (u9 :: _forall_ a$z1 =>{{Integral a$z1}} -> u0 -> a$z1) (ua :: _forall_ a$z1 =>{{Integral a$z1}} -> u0 -> a$z1) -> _APP_ _TYAPP_ u7 { u1 } [ u3 ]; _NO_DEFLT_ } _N_
- {-defm-} _A_ 2 _U_ 122 _N_ _S_ "U(AASAAAA)L" {_A_ 2 _U_ 222 _N_ _N_ _N_ _N_} _N_ _N_ #-}
+ {-defm-} _A_ 2 _U_ 122 _N_ _S_ "U(AASAAAA)L" {_A_ 2 _U_ 122 _N_ _N_ _N_ _N_} _N_ _N_ #-}
round :: Integral b => a -> b
{-# GHC_PRAGMA {-meth-} _A_ 2 _U_ 122 _N_ _S_ "U(AAAASAA)L" {_A_ 2 _U_ 122 _N_ _N_ _F_ _IF_ARGS_ 2 2 XX 2 _/\_ u0 u1 -> \ (u2 :: _forall_ a$z1 =>{{Integral a$z1}} -> u0 -> a$z1) (u3 :: {{Integral u1}}) -> _APP_ _TYAPP_ u2 { u1 } [ u3 ] _N_} _F_ _IF_ARGS_ 2 2 CX 3 _/\_ u0 u1 -> \ (u2 :: ({{Real u0}}, {{Fractional u0}}, (_forall_ z$z1 =>{{Integral z$z1}} -> u0 -> (z$z1, u0)), (_forall_ z$z1 =>{{Integral z$z1}} -> u0 -> z$z1), (_forall_ z$z1 =>{{Integral z$z1}} -> u0 -> z$z1), (_forall_ z$z1 =>{{Integral z$z1}} -> u0 -> z$z1), (_forall_ z$z1 =>{{Integral z$z1}} -> u0 -> z$z1))) (u3 :: {{Integral u1}}) -> case u2 of { _ALG_ _TUP_7 (u4 :: {{Real u0}}) (u5 :: {{Fractional u0}}) (u6 :: _forall_ a$z1 =>{{Integral a$z1}} -> u0 -> (a$z1, u0)) (u7 :: _forall_ a$z1 =>{{Integral a$z1}} -> u0 -> a$z1) (u8 :: _forall_ a$z1 =>{{Integral a$z1}} -> u0 -> a$z1) (u9 :: _forall_ a$z1 =>{{Integral a$z1}} -> u0 -> a$z1) (ua :: _forall_ a$z1 =>{{Integral a$z1}} -> u0 -> a$z1) -> _APP_ _TYAPP_ u8 { u1 } [ u3 ]; _NO_DEFLT_ } _N_
- {-defm-} _A_ 2 _U_ 122 _N_ _S_ "U(U(AU(U(ALAAAAAS)AAAA)A)LSAAAA)L" {_A_ 5 _U_ 222222 _N_ _N_ _N_ _N_} _N_ _N_ #-}
+ {-defm-} _A_ 2 _U_ 122 _N_ _S_ "U(U(AU(U(ALAAAAAS)AAAA)A)LSAAAA)L" {_A_ 5 _U_ 112122 _N_ _N_ _N_ _N_} _N_ _N_ #-}
ceiling :: Integral b => a -> b
{-# GHC_PRAGMA {-meth-} _A_ 2 _U_ 122 _N_ _S_ "U(AAAAASA)L" {_A_ 2 _U_ 122 _N_ _N_ _F_ _IF_ARGS_ 2 2 XX 2 _/\_ u0 u1 -> \ (u2 :: _forall_ a$z1 =>{{Integral a$z1}} -> u0 -> a$z1) (u3 :: {{Integral u1}}) -> _APP_ _TYAPP_ u2 { u1 } [ u3 ] _N_} _F_ _IF_ARGS_ 2 2 CX 3 _/\_ u0 u1 -> \ (u2 :: ({{Real u0}}, {{Fractional u0}}, (_forall_ z$z1 =>{{Integral z$z1}} -> u0 -> (z$z1, u0)), (_forall_ z$z1 =>{{Integral z$z1}} -> u0 -> z$z1), (_forall_ z$z1 =>{{Integral z$z1}} -> u0 -> z$z1), (_forall_ z$z1 =>{{Integral z$z1}} -> u0 -> z$z1), (_forall_ z$z1 =>{{Integral z$z1}} -> u0 -> z$z1))) (u3 :: {{Integral u1}}) -> case u2 of { _ALG_ _TUP_7 (u4 :: {{Real u0}}) (u5 :: {{Fractional u0}}) (u6 :: _forall_ a$z1 =>{{Integral a$z1}} -> u0 -> (a$z1, u0)) (u7 :: _forall_ a$z1 =>{{Integral a$z1}} -> u0 -> a$z1) (u8 :: _forall_ a$z1 =>{{Integral a$z1}} -> u0 -> a$z1) (u9 :: _forall_ a$z1 =>{{Integral a$z1}} -> u0 -> a$z1) (ua :: _forall_ a$z1 =>{{Integral a$z1}} -> u0 -> a$z1) -> _APP_ _TYAPP_ u9 { u1 } [ u3 ]; _NO_DEFLT_ } _N_
- {-defm-} _A_ 2 _U_ 122 _N_ _S_ "U(U(AU(U(AAAASAAA)AAAA)A)LSAAAA)L" {_A_ 4 _U_ 22222 _N_ _N_ _N_ _N_} _N_ _N_ #-}
+ {-defm-} _A_ 2 _U_ 122 _N_ _S_ "U(U(LU(U(AAAASAAA)AAAA)A)ASAAAA)L" {_A_ 4 _U_ 11122 _N_ _N_ _N_ _N_} _N_ _N_ #-}
floor :: Integral b => a -> b
{-# GHC_PRAGMA {-meth-} _A_ 2 _U_ 122 _N_ _S_ "U(AAAAAAS)L" {_A_ 2 _U_ 122 _N_ _N_ _F_ _IF_ARGS_ 2 2 XX 2 _/\_ u0 u1 -> \ (u2 :: _forall_ a$z1 =>{{Integral a$z1}} -> u0 -> a$z1) (u3 :: {{Integral u1}}) -> _APP_ _TYAPP_ u2 { u1 } [ u3 ] _N_} _F_ _IF_ARGS_ 2 2 CX 3 _/\_ u0 u1 -> \ (u2 :: ({{Real u0}}, {{Fractional u0}}, (_forall_ z$z1 =>{{Integral z$z1}} -> u0 -> (z$z1, u0)), (_forall_ z$z1 =>{{Integral z$z1}} -> u0 -> z$z1), (_forall_ z$z1 =>{{Integral z$z1}} -> u0 -> z$z1), (_forall_ z$z1 =>{{Integral z$z1}} -> u0 -> z$z1), (_forall_ z$z1 =>{{Integral z$z1}} -> u0 -> z$z1))) (u3 :: {{Integral u1}}) -> case u2 of { _ALG_ _TUP_7 (u4 :: {{Real u0}}) (u5 :: {{Fractional u0}}) (u6 :: _forall_ a$z1 =>{{Integral a$z1}} -> u0 -> (a$z1, u0)) (u7 :: _forall_ a$z1 =>{{Integral a$z1}} -> u0 -> a$z1) (u8 :: _forall_ a$z1 =>{{Integral a$z1}} -> u0 -> a$z1) (u9 :: _forall_ a$z1 =>{{Integral a$z1}} -> u0 -> a$z1) (ua :: _forall_ a$z1 =>{{Integral a$z1}} -> u0 -> a$z1) -> _APP_ _TYAPP_ ua { u1 } [ u3 ]; _NO_DEFLT_ } _N_
- {-defm-} _A_ 2 _U_ 122 _N_ _S_ "U(U(AU(U(ASAAAAAA)AAAA)A)LSAAAA)L" {_A_ 4 _U_ 22222 _N_ _N_ _N_ _N_} _N_ _N_ #-}
+ {-defm-} _A_ 2 _U_ 122 _N_ _S_ "U(U(LU(U(ASAAAAAA)AAAA)A)ASAAAA)L" {_A_ 4 _U_ 11122 _N_ _N_ _N_ _N_} _N_ _N_ #-}
class Text a where
readsPrec :: Int -> [Char] -> [(a, [Char])]
{-# GHC_PRAGMA {-meth-} _A_ 1 _U_ 122 _N_ _S_ "U(SAAA)" {_A_ 1 _U_ 122 _N_ _N_ _F_ _IF_ARGS_ 1 1 X 1 _/\_ u0 -> \ (u1 :: Int -> [Char] -> [(u0, [Char])]) -> u1 _N_} _F_ _IF_ARGS_ 1 1 C 2 _/\_ u0 -> \ (u1 :: (Int -> [Char] -> [(u0, [Char])], Int -> u0 -> [Char] -> [Char], [Char] -> [([u0], [Char])], [u0] -> [Char] -> [Char])) -> case u1 of { _ALG_ _TUP_4 (u2 :: Int -> [Char] -> [(u0, [Char])]) (u3 :: Int -> u0 -> [Char] -> [Char]) (u4 :: [Char] -> [([u0], [Char])]) (u5 :: [u0] -> [Char] -> [Char]) -> u2; _NO_DEFLT_ } _N_
- {-defm-} _A_ 3 _U_ 022 _N_ _S_ _!_ _F_ _IF_ARGS_ 1 3 XXX 4 _/\_ u0 -> \ (u1 :: {{Text u0}}) (u2 :: Int) (u3 :: [Char]) -> _APP_ _TYAPP_ patError# { (Int -> [Char] -> [(u0, [Char])]) } [ _NOREP_S_ "%DPreludeCore.Text.readsPrec\"", u2, u3 ] _N_ #-}
+ {-defm-} _A_ 3 _U_ 022 _N_ _S_ _!_ _N_ _N_ #-}
showsPrec :: Int -> a -> [Char] -> [Char]
{-# GHC_PRAGMA {-meth-} _A_ 1 _U_ 1222 _N_ _S_ "U(ASAA)" {_A_ 1 _U_ 1222 _N_ _N_ _F_ _IF_ARGS_ 1 1 X 1 _/\_ u0 -> \ (u1 :: Int -> u0 -> [Char] -> [Char]) -> u1 _N_} _F_ _IF_ARGS_ 1 1 C 2 _/\_ u0 -> \ (u1 :: (Int -> [Char] -> [(u0, [Char])], Int -> u0 -> [Char] -> [Char], [Char] -> [([u0], [Char])], [u0] -> [Char] -> [Char])) -> case u1 of { _ALG_ _TUP_4 (u2 :: Int -> [Char] -> [(u0, [Char])]) (u3 :: Int -> u0 -> [Char] -> [Char]) (u4 :: [Char] -> [([u0], [Char])]) (u5 :: [u0] -> [Char] -> [Char]) -> u3; _NO_DEFLT_ } _N_
- {-defm-} _A_ 4 _U_ 0222 _N_ _S_ _!_ _F_ _IF_ARGS_ 1 4 XXXX 5 _/\_ u0 -> \ (u1 :: {{Text u0}}) (u2 :: Int) (u3 :: u0) (u4 :: [Char]) -> _APP_ _TYAPP_ patError# { (Int -> u0 -> [Char] -> [Char]) } [ _NOREP_S_ "%DPreludeCore.Text.showsPrec\"", u2, u3, u4 ] _N_ #-}
+ {-defm-} _A_ 4 _U_ 0222 _N_ _S_ _!_ _N_ _N_ #-}
readList :: [Char] -> [([a], [Char])]
{-# GHC_PRAGMA {-meth-} _A_ 1 _U_ 12 _N_ _S_ "U(AASA)" {_A_ 1 _U_ 12 _N_ _N_ _F_ _IF_ARGS_ 1 1 X 1 _/\_ u0 -> \ (u1 :: [Char] -> [([u0], [Char])]) -> u1 _N_} _F_ _IF_ARGS_ 1 1 C 2 _/\_ u0 -> \ (u1 :: (Int -> [Char] -> [(u0, [Char])], Int -> u0 -> [Char] -> [Char], [Char] -> [([u0], [Char])], [u0] -> [Char] -> [Char])) -> case u1 of { _ALG_ _TUP_4 (u2 :: Int -> [Char] -> [(u0, [Char])]) (u3 :: Int -> u0 -> [Char] -> [Char]) (u4 :: [Char] -> [([u0], [Char])]) (u5 :: [u0] -> [Char] -> [Char]) -> u4; _NO_DEFLT_ } _N_
- {-defm-} _A_ 1 _U_ 22 _N_ _N_ _F_ _IF_ARGS_ 0 0 X 1 _ORIG_ PreludeCore _readList _N_ #-}
+ {-defm-} _A_ 1 _U_ 12 _N_ _N_ _N_ _N_ #-}
showList :: [a] -> [Char] -> [Char]
{-# GHC_PRAGMA {-meth-} _A_ 1 _U_ 122 _N_ _S_ "U(AAAS)" {_A_ 1 _U_ 122 _N_ _N_ _F_ _IF_ARGS_ 1 1 X 1 _/\_ u0 -> \ (u1 :: [u0] -> [Char] -> [Char]) -> u1 _N_} _F_ _IF_ARGS_ 1 1 C 2 _/\_ u0 -> \ (u1 :: (Int -> [Char] -> [(u0, [Char])], Int -> u0 -> [Char] -> [Char], [Char] -> [([u0], [Char])], [u0] -> [Char] -> [Char])) -> case u1 of { _ALG_ _TUP_4 (u2 :: Int -> [Char] -> [(u0, [Char])]) (u3 :: Int -> u0 -> [Char] -> [Char]) (u4 :: [Char] -> [([u0], [Char])]) (u5 :: [u0] -> [Char] -> [Char]) -> u5; _NO_DEFLT_ } _N_
- {-defm-} _A_ 1 _U_ 212 _N_ _N_ _F_ _IF_ARGS_ 0 0 X 1 _ORIG_ PreludeCore _showList _N_ #-}
+ {-defm-} _A_ 1 _U_ 112 _N_ _N_ _N_ _N_ #-}
class _CCallable a
class _CReturnable a
data Bin
-{-# GHC_PRAGMA INTERFACE VERSION 5 #-}
+{-# GHC_PRAGMA INTERFACE VERSION 6 #-}
interface Concurrent where
import Channel(Chan(..), dupChan, getChan, getChanContents, newChan, putChan, putList2Chan, unGetChan)
import ChannelVar(CVar(..), getCVar, newCVar, putCVar)
-{-# GHC_PRAGMA INTERFACE VERSION 5 #-}
+{-# GHC_PRAGMA INTERFACE VERSION 6 #-}
interface Concurrent where
import Channel(Chan(..), dupChan, getChan, getChanContents, newChan, putChan, putList2Chan, unGetChan)
import ChannelVar(CVar(..), getCVar, newCVar, putCVar)
-{-# GHC_PRAGMA INTERFACE VERSION 5 #-}
+{-# GHC_PRAGMA INTERFACE VERSION 6 #-}
interface Concurrent where
import Channel(Chan(..), dupChan, getChan, getChanContents, newChan, putChan, putList2Chan, unGetChan)
import ChannelVar(CVar(..), getCVar, newCVar, putCVar)
-{-# GHC_PRAGMA INTERFACE VERSION 5 #-}
+{-# GHC_PRAGMA INTERFACE VERSION 6 #-}
interface Concurrent where
import Channel(Chan(..), dupChan, getChan, getChanContents, newChan, putChan, putList2Chan, unGetChan)
import ChannelVar(CVar(..), getCVar, newCVar, putCVar)
-{-# GHC_PRAGMA INTERFACE VERSION 5 #-}
+{-# GHC_PRAGMA INTERFACE VERSION 6 #-}
interface Concurrent where
import Channel(Chan(..), dupChan, getChan, getChanContents, newChan, putChan, putList2Chan, unGetChan)
import ChannelVar(CVar(..), getCVar, newCVar, putCVar)
-{-# GHC_PRAGMA INTERFACE VERSION 5 #-}
+{-# GHC_PRAGMA INTERFACE VERSION 6 #-}
interface PreludeCore where
import PreludeBuiltin(Char(..), Int(..), Integer(..), List(..), Tuple2)
import PreludeRatio(Ratio(..))
-_ceiling :: (RealFrac a, Integral b) => a -> b
- {-# GHC_PRAGMA _A_ 2 _U_ 122 _N_ _S_ "U(U(AU(U(AAAASAAA)AAAA)A)LSAAAA)L" {_A_ 4 _U_ 11122 _N_ _N_ _N_ _N_} _N_ _SPECIALISE_ [ Double, Int ] 2 { _A_ 0 _U_ 2 _N_ _N_ _N_ _N_ } #-}
-_floor :: (RealFrac a, Integral b) => a -> b
- {-# GHC_PRAGMA _A_ 2 _U_ 122 _N_ _S_ "U(U(AU(U(ASAAAAAA)AAAA)A)LSAAAA)L" {_A_ 4 _U_ 11122 _N_ _N_ _N_ _N_} _N_ _SPECIALISE_ [ Double, Int ] 2 { _A_ 0 _U_ 2 _N_ _N_ _N_ _N_ } #-}
-_integer_0 :: Integer
- {-# GHC_PRAGMA _A_ 0 _N_ _N_ _N_ _F_ _IF_ARGS_ 0 0 X 1 _#_ int2Integer# [] [0#] _N_ #-}
-_integer_1 :: Integer
- {-# GHC_PRAGMA _A_ 0 _N_ _N_ _N_ _F_ _IF_ARGS_ 0 0 X 1 _#_ int2Integer# [] [1#] _N_ #-}
-_integer_m1 :: Integer
- {-# GHC_PRAGMA _A_ 0 _N_ _N_ _N_ _N_ _N_ #-}
-_properFraction :: (RealFloat b, Integral a) => b -> (a, b)
- {-# GHC_PRAGMA _A_ 2 _U_ 112 _N_ _S_ "U(ALLAASLAAA)L" {_A_ 5 _U_ 111112 _N_ _N_ _N_ _N_} _N_ _SPECIALISE_ [ Int, Double ] 2 { _A_ 1 _U_ 1 _N_ _S_ "U(P)" {_A_ 1 _U_ 2 _N_ _N_ _N_ _N_} _N_ _N_ } #-}
-_readList :: Text a => [Char] -> [([a], [Char])]
+__i0 :: Num a => a
+ {-# GHC_PRAGMA _A_ 1 _U_ 1 _N_ _S_ "U(AAAAAAAAAS)" {_A_ 1 _U_ 1 _N_ _N_ _N_ _N_} _N_ _SPECIALISE_ [ Double ] 1 { _A_ 0 _N_ _N_ _N_ _F_ _IF_ARGS_ 0 0 X 2 _!_ D# [] [0.0000000000000000##] _N_ }, [ Int ] 1 { _A_ 0 _N_ _N_ _N_ _F_ _IF_ARGS_ 0 0 X 2 _!_ I# [] [0#] _N_ }, [ Integer ] 1 { _A_ 0 _N_ _N_ _N_ _N_ _N_ }, [ (Ratio Integer) ] 1 { _A_ 0 _N_ _N_ _N_ _N_ _N_ }, [ (Complex Double) ] 1 { _A_ 0 _N_ _N_ _N_ _N_ _N_ } #-}
+__i1 :: Num a => a
+ {-# GHC_PRAGMA _A_ 1 _U_ 1 _N_ _S_ "U(AAAAAAAAAS)" {_A_ 1 _U_ 1 _N_ _N_ _N_ _N_} _N_ _SPECIALISE_ [ Double ] 1 { _A_ 0 _N_ _N_ _N_ _F_ _IF_ARGS_ 0 0 X 2 _!_ D# [] [1.0000000000000000##] _N_ }, [ Int ] 1 { _A_ 0 _N_ _N_ _N_ _F_ _IF_ARGS_ 0 0 X 2 _!_ I# [] [1#] _N_ }, [ Integer ] 1 { _A_ 0 _N_ _N_ _N_ _N_ _N_ }, [ (Ratio Integer) ] 1 { _A_ 0 _N_ _N_ _N_ _N_ _N_ }, [ (Complex Double) ] 1 { _A_ 0 _N_ _N_ _N_ _N_ _N_ } #-}
+__i10 :: Num a => a
+ {-# GHC_PRAGMA _A_ 1 _U_ 1 _N_ _S_ "U(AAAAAAAAAS)" {_A_ 1 _U_ 1 _N_ _N_ _N_ _N_} _N_ _SPECIALISE_ [ Double ] 1 { _A_ 0 _N_ _N_ _N_ _F_ _IF_ARGS_ 0 0 X 2 _!_ D# [] [10.000000000000000##] _N_ }, [ Int ] 1 { _A_ 0 _N_ _N_ _N_ _F_ _IF_ARGS_ 0 0 X 2 _!_ I# [] [10#] _N_ }, [ Integer ] 1 { _A_ 0 _N_ _N_ _N_ _N_ _N_ }, [ (Ratio Integer) ] 1 { _A_ 0 _N_ _N_ _N_ _N_ _N_ }, [ (Complex Double) ] 1 { _A_ 0 _N_ _N_ _N_ _N_ _N_ } #-}
+__i16 :: Num a => a
+ {-# GHC_PRAGMA _A_ 1 _U_ 1 _N_ _S_ "U(AAAAAAAAAS)" {_A_ 1 _U_ 1 _N_ _N_ _N_ _N_} _N_ _SPECIALISE_ [ Double ] 1 { _A_ 0 _N_ _N_ _N_ _F_ _IF_ARGS_ 0 0 X 2 _!_ D# [] [16.000000000000000##] _N_ }, [ Int ] 1 { _A_ 0 _N_ _N_ _N_ _F_ _IF_ARGS_ 0 0 X 2 _!_ I# [] [16#] _N_ }, [ Integer ] 1 { _A_ 0 _N_ _N_ _N_ _N_ _N_ }, [ (Ratio Integer) ] 1 { _A_ 0 _N_ _N_ _N_ _N_ _N_ }, [ (Complex Double) ] 1 { _A_ 0 _N_ _N_ _N_ _N_ _N_ } #-}
+__i2 :: Num a => a
+ {-# GHC_PRAGMA _A_ 1 _U_ 1 _N_ _S_ "U(AAAAAAAAAS)" {_A_ 1 _U_ 1 _N_ _N_ _N_ _N_} _N_ _SPECIALISE_ [ Double ] 1 { _A_ 0 _N_ _N_ _N_ _F_ _IF_ARGS_ 0 0 X 2 _!_ D# [] [2.0000000000000000##] _N_ }, [ Int ] 1 { _A_ 0 _N_ _N_ _N_ _F_ _IF_ARGS_ 0 0 X 2 _!_ I# [] [2#] _N_ }, [ Integer ] 1 { _A_ 0 _N_ _N_ _N_ _N_ _N_ }, [ (Ratio Integer) ] 1 { _A_ 0 _N_ _N_ _N_ _N_ _N_ }, [ (Complex Double) ] 1 { _A_ 0 _N_ _N_ _N_ _N_ _N_ } #-}
+__i8 :: Num a => a
+ {-# GHC_PRAGMA _A_ 1 _U_ 1 _N_ _S_ "U(AAAAAAAAAS)" {_A_ 1 _U_ 1 _N_ _N_ _N_ _N_} _N_ _SPECIALISE_ [ Double ] 1 { _A_ 0 _N_ _N_ _N_ _F_ _IF_ARGS_ 0 0 X 2 _!_ D# [] [8.0000000000000000##] _N_ }, [ Int ] 1 { _A_ 0 _N_ _N_ _N_ _F_ _IF_ARGS_ 0 0 X 2 _!_ I# [] [8#] _N_ }, [ Integer ] 1 { _A_ 0 _N_ _N_ _N_ _N_ _N_ }, [ (Ratio Integer) ] 1 { _A_ 0 _N_ _N_ _N_ _N_ _N_ }, [ (Complex Double) ] 1 { _A_ 0 _N_ _N_ _N_ _N_ _N_ } #-}
+__im1 :: Num a => a
+ {-# GHC_PRAGMA _A_ 1 _U_ 1 _N_ _S_ "U(AAAAAAAAAS)" {_A_ 1 _U_ 1 _N_ _N_ _N_ _N_} _N_ _SPECIALISE_ [ Double ] 1 { _A_ 0 _N_ _N_ _N_ _F_ _IF_ARGS_ 0 0 X 2 _!_ D# [] [-1.0000000000000000##] _N_ }, [ Int ] 1 { _A_ 0 _N_ _N_ _N_ _F_ _IF_ARGS_ 0 0 X 2 _!_ I# [] [-1#] _N_ }, [ Integer ] 1 { _A_ 0 _N_ _N_ _N_ _N_ _N_ }, [ (Ratio Integer) ] 1 { _A_ 0 _N_ _N_ _N_ _N_ _N_ }, [ (Complex Double) ] 1 { _A_ 0 _N_ _N_ _N_ _N_ _N_ } #-}
+__rhalf :: Fractional a => a
+ {-# GHC_PRAGMA _A_ 1 _U_ 1 _N_ _S_ "U(AAAS)" {_A_ 1 _U_ 1 _N_ _N_ _N_ _N_} _N_ _SPECIALISE_ [ Double ] 1 { _A_ 0 _N_ _N_ _N_ _N_ _N_ }, [ (Ratio Integer) ] 1 { _A_ 0 _N_ _N_ _N_ _F_ _IF_ARGS_ 0 0 X 3 _!_ (:%) [Integer] [_SPEC_ _ORIG_ PreludeCore __i1 [ (Integer) ], _SPEC_ _ORIG_ PreludeCore __i2 [ (Integer) ]] _N_ }, [ (Complex Double) ] 1 { _A_ 0 _N_ _N_ _N_ _N_ _N_ } #-}
+_fromRational :: RealFloat a => Ratio Integer -> a
+ {-# GHC_PRAGMA _A_ 2 _U_ 22 _N_ _N_ _N_ _SPECIALISE_ [ Double ] 1 { _A_ 1 _U_ 1 _N_ _S_ "U(U(PPP)U(PPP))" {_A_ 4 _U_ 2221 _N_ _N_ _N_ _N_} _N_ _N_ } #-}
+_readList :: ([Char] -> [(a, [Char])]) -> [Char] -> [([a], [Char])]
{-# GHC_PRAGMA _A_ 1 _U_ 22 _N_ _N_ _N_ _N_ #-}
-_round :: (RealFrac a, Integral b) => a -> b
- {-# GHC_PRAGMA _A_ 2 _U_ 122 _N_ _S_ "U(U(AU(U(ALAAAAAS)AAAA)A)LSAAAA)L" {_A_ 5 _U_ 112122 _N_ _N_ _N_ _N_} _N_ _SPECIALISE_ [ Double, Int ] 2 { _A_ 0 _U_ 2 _N_ _N_ _N_ _N_ }, [ (Ratio Integer), Integer ] 2 { _A_ 1 _U_ 1 _N_ _S_ "U(LL)" {_A_ 2 _U_ 22 _N_ _N_ _N_ _N_} _N_ _N_ } #-}
-_showList :: Text a => [a] -> [Char] -> [Char]
- {-# GHC_PRAGMA _A_ 1 _U_ 212 _N_ _N_ _N_ _N_ #-}
+_showList :: (a -> [Char] -> [Char]) -> [a] -> [Char] -> [Char]
+ {-# GHC_PRAGMA _A_ 2 _U_ 212 _N_ _S_ "LS" _N_ _N_ #-}
_showRational :: Int -> Ratio Integer -> [Char]
{-# GHC_PRAGMA _A_ 2 _U_ 21 _N_ _S_ "LU(U(PPP)L)" {_A_ 5 _U_ 22222 _N_ _N_ _N_ _N_} _N_ _N_ #-}
-_truncate :: (RealFrac a, Integral b) => a -> b
- {-# GHC_PRAGMA _A_ 2 _U_ 122 _N_ _S_ "U(AASAAAA)L" {_A_ 2 _U_ 122 _N_ _N_ _N_ _N_} _N_ _SPECIALISE_ [ Double, Int ] 2 { _A_ 0 _U_ 2 _N_ _N_ _N_ _N_ } #-}
-fromRationalX :: RealFloat a => Ratio Integer -> a
- {-# GHC_PRAGMA _A_ 0 _U_ 22 _N_ _N_ _N_ _N_ #-}
-i0__ :: Num a => a
- {-# GHC_PRAGMA _A_ 1 _U_ 1 _N_ _S_ "U(AAAAAAAASA)" {_A_ 1 _U_ 1 _N_ _N_ _N_ _N_} _F_ _IF_ARGS_ 1 1 C 5 _/\_ u0 -> \ (u1 :: {{Num u0}}) -> let {(u2 :: Integer) = _#_ int2Integer# [] [0#]} in case u1 of { _ALG_ _TUP_10 (u3 :: {{Eq u0}}) (u4 :: {{Text u0}}) (u5 :: u0 -> u0 -> u0) (u6 :: u0 -> u0 -> u0) (u7 :: u0 -> u0 -> u0) (u8 :: u0 -> u0) (u9 :: u0 -> u0) (ua :: u0 -> u0) (ub :: Integer -> u0) (uc :: Int -> u0) -> _APP_ ub [ u2 ]; _NO_DEFLT_ } _SPECIALISE_ [ Int ] 1 { _A_ 0 _N_ _N_ _N_ _N_ _N_ }, [ Integer ] 1 { _A_ 0 _N_ _N_ _N_ _F_ _IF_ARGS_ 0 0 X 1 _#_ int2Integer# [] [0#] _N_ } #-}
-i1__ :: Num a => a
- {-# GHC_PRAGMA _A_ 1 _U_ 1 _N_ _S_ "U(AAAAAAAASA)" {_A_ 1 _U_ 1 _N_ _N_ _N_ _N_} _F_ _IF_ARGS_ 1 1 C 5 _/\_ u0 -> \ (u1 :: {{Num u0}}) -> let {(u2 :: Integer) = _#_ int2Integer# [] [1#]} in case u1 of { _ALG_ _TUP_10 (u3 :: {{Eq u0}}) (u4 :: {{Text u0}}) (u5 :: u0 -> u0 -> u0) (u6 :: u0 -> u0 -> u0) (u7 :: u0 -> u0 -> u0) (u8 :: u0 -> u0) (u9 :: u0 -> u0) (ua :: u0 -> u0) (ub :: Integer -> u0) (uc :: Int -> u0) -> _APP_ ub [ u2 ]; _NO_DEFLT_ } _SPECIALISE_ [ Int ] 1 { _A_ 0 _N_ _N_ _N_ _N_ _N_ }, [ Integer ] 1 { _A_ 0 _N_ _N_ _N_ _F_ _IF_ARGS_ 0 0 X 1 _#_ int2Integer# [] [1#] _N_ } #-}
-i2__ :: Num a => a
- {-# GHC_PRAGMA _A_ 1 _U_ 1 _N_ _S_ "U(AAAAAAAASA)" {_A_ 1 _U_ 1 _N_ _N_ _N_ _N_} _F_ _IF_ARGS_ 1 1 C 5 _/\_ u0 -> \ (u1 :: {{Num u0}}) -> let {(u2 :: Integer) = _#_ int2Integer# [] [2#]} in case u1 of { _ALG_ _TUP_10 (u3 :: {{Eq u0}}) (u4 :: {{Text u0}}) (u5 :: u0 -> u0 -> u0) (u6 :: u0 -> u0 -> u0) (u7 :: u0 -> u0 -> u0) (u8 :: u0 -> u0) (u9 :: u0 -> u0) (ua :: u0 -> u0) (ub :: Integer -> u0) (uc :: Int -> u0) -> _APP_ ub [ u2 ]; _NO_DEFLT_ } _N_ #-}
-iminus1__ :: Num a => a
- {-# GHC_PRAGMA _A_ 1 _U_ 1 _N_ _S_ "U(AAAAAAAASA)" {_A_ 1 _U_ 1 _N_ _N_ _N_ _N_} _N_ _N_ #-}
-int2Integer :: Int -> Integer
- {-# GHC_PRAGMA _A_ 1 _U_ 1 _N_ _S_ "U(P)" {_A_ 1 _U_ 2 _N_ _N_ _F_ _IF_ARGS_ 0 1 X 1 \ (u0 :: Int#) -> _#_ int2Integer# [] [u0] _N_} _F_ _IF_ARGS_ 0 1 C 2 \ (u0 :: Int) -> case u0 of { _ALG_ I# (u1 :: Int#) -> _#_ int2Integer# [] [u1]; _NO_DEFLT_ } _N_ #-}
-r0__ :: Fractional a => a
- {-# GHC_PRAGMA _A_ 1 _U_ 1 _N_ _S_ "U(AAAS)" {_A_ 1 _U_ 1 _N_ _N_ _N_ _N_} _N_ _SPECIALISE_ [ Double ] 1 { _A_ 0 _N_ _N_ _N_ _N_ _N_ }, [ (Ratio Integer) ] 1 { _A_ 0 _N_ _N_ _N_ _N_ _N_ } #-}
-r1__ :: Fractional a => a
- {-# GHC_PRAGMA _A_ 1 _U_ 1 _N_ _S_ "U(AAAS)" {_A_ 1 _U_ 1 _N_ _N_ _N_ _N_} _N_ _N_ #-}
-rhalf__ :: Fractional a => a
- {-# GHC_PRAGMA _A_ 1 _U_ 1 _N_ _S_ "U(AAAS)" {_A_ 1 _U_ 1 _N_ _N_ _N_ _N_} _N_ _SPECIALISE_ [ Double ] 1 { _A_ 0 _N_ _N_ _N_ _N_ _N_ }, [ (Ratio Integer) ] 1 { _A_ 0 _N_ _N_ _N_ _N_ _N_ } #-}
module PreludeCore (
- _integer_0,
- _integer_1,
- _integer_m1,
- fromRationalX,
- i0__,
- i1__,
- i2__,
- iminus1__,
- int2Integer,
+ __i0,
+ __i1,
+ __i2,
+ __im1,
+ __i8,
+ __i10,
+ __i16,
+ __rhalf,
+ _fromRational,
_showRational,
- r0__,
- r1__,
- rhalf__,
- _readList, _showList,
- _properFraction, _truncate, _round, _ceiling, _floor
+ _readList,
+ _showList
) where
import Cls
-import IChar -- instances
+import IChar
+import IComplex
import IDouble
import IFloat
import IInt
import IList
import IRatio
import List ( reverse, dropWhile, take, drop, repeat, (++), head, tail )
-import Prel ( (&&), (^^), (^), not, otherwise, asTypeOf, const, (.) )
+import Prel ( (&&), (^^), (^), not, otherwise, asTypeOf, const, (.), atan2, maxInt )
import PS ( _PackedString, _unpackPS )
import Text
-import TyComplex -- for pragmas
+import TyComplex
+import TyArray
-----------------------------------------------------------------
-- some *** NON-STANDARD *** constants (to help compiling Cls.hs)
-i0__, iminus1__, i1__, i2__ :: Num a => a
-{-# SPECIALIZE i0__ :: Int, Integer #-}
-
-i0__ = fromInteger 0
-iminus1__ = fromInteger (-1)
-i1__ = fromInteger 1
-i2__ = fromInteger 2
-
-r0__, rhalf__, r1__ :: Fractional a => a
-
-r0__ = fromRational 0
-rhalf__ = fromRational 0.5
-r1__ = fromRational 1
-
--- other bits of PreludeCore that aren't classes, instances, etc.
-
-{- OLD:
-absReal :: (Real a) => a -> a
-absReal x | x >= 0 = x
- | otherwise = - x
-
-signumReal :: (Real a) => a -> a
-signumReal x | x == 0 = 0
- | x > 0 = 1
- | otherwise = -1
--}
-
-{- *RAW PRELUDE*: NOT REALLY USED:
-numericEnumFrom :: (Real a) => a -> [a]
-numericEnumFromThen :: (Real a) => a -> a -> [a]
-numericEnumFrom = iterate (+1)
-numericEnumFromThen n m = iterate (+(m-n)) n
--}
-
-{- OLD:
-realFloatToRational :: (RealFloat a) => a -> Rational
-realFloatToRational x = (m%1)*(b%1)^^n
- where (m,n) = decodeFloat x
- b = floatRadix x
--}
+{-# GENERATE_SPECS __i0 a{Int#,Double#,Int,Integer,Double,Complex(Double#),Complex(Double),Rational} #-}
+__i0 :: Num a => a
+{-# GENERATE_SPECS __i1 a{Int#,Double#,Int,Integer,Double,Complex(Double#),Complex(Double),Rational} #-}
+__i1 :: Num a => a
+{-# GENERATE_SPECS __i2 a{Int#,Double#,Int,Integer,Double,Complex(Double#),Complex(Double),Rational} #-}
+__i2 :: Num a => a
+{-# GENERATE_SPECS __im1 a{Int#,Double#,Int,Integer,Double,Complex(Double#),Complex(Double),Rational} #-}
+__im1 :: Num a => a
+{-# GENERATE_SPECS __i8 a{Int#,Double#,Int,Integer,Double,Complex(Double#),Complex(Double),Rational} #-}
+__i8 :: Num a => a
+{-# GENERATE_SPECS __i10 a{Int#,Double#,Int,Integer,Double,Complex(Double#),Complex(Double),Rational} #-}
+__i10 :: Num a => a
+{-# GENERATE_SPECS __i16 a{Int#,Double#,Int,Integer,Double,Complex(Double#),Complex(Double),Rational} #-}
+__i16 :: Num a => a
+
+__i0 = fromInt 0
+__i1 = fromInt 1
+__i2 = fromInt 2
+__im1 = fromInt (-1)
+__i8 = fromInt 8
+__i10 = fromInt 10
+__i16 = fromInt 16
+
+{-# GENERATE_SPECS __rhalf a{Double#,Double,Complex(Double#),Complex(Double),Rational} #-}
+__rhalf :: Fractional a => a
+__rhalf = fromRational (__i1:%__i2)
+
+
+-- bits of PreludeCore that aren't classes, instances, etc.
{-
[In response to a request by simonpj, Joe Fasel writes:]
How's this?
---Joe
+Joe
-}
---{-# GENERATE_SPECS rationalToRealFloat a{Double#,Double} #-}
-rationalToRealFloat :: (RealFloat a) => Rational -> a
-
-rationalToRealFloat x = x'
- where x' = f e
+{-# GENERATE_SPECS _fromRational a{Double#,Double} #-}
+_fromRational :: (RealFloat a) => Rational -> a
+_fromRational x = x'
+ where x' = f e
-- If the exponent of the nearest floating-point number to x
-- is e, then the significand is the integer nearest xb^(-e),
-- not, one more iteration is needed.
f e = if e' == e then y else f e'
- where y = encodeFloat (round (x * (1%b)^^e)) e
+ where y = encodeFloat (round (x * (__i1 % b)^^e)) e
(_,e') = decodeFloat y
b = floatRadix x'
(s,e) = decodeFloat (fromInteger (numerator x) `asTypeOf` x'
/ fromInteger (denominator x))
--------------------------------------------------------------------------
--- These RealFrac things are here so we can
--- SPECIALIZE the tapookies out of them.
--- Also: get rid of gratuitous lazy pattern matching.
-
-_properFraction :: (RealFloat a, Integral b) => a -> (b,a)
-_truncate, _round :: (RealFrac a, Integral b) => a -> b
-_ceiling, _floor :: (RealFrac a, Integral b) => a -> b
-
-{-# SPECIALIZE _properFraction
- :: Double -> (Int, Double)
- #-}
-{-# SPECIALIZE _truncate
- :: Double -> Int
- #-}
-{-# SPECIALIZE _round
- :: Double -> Int,
- Rational -> Integer
- #-}
-{-# SPECIALIZE _ceiling
- :: Double -> Int
- #-}
-{-# SPECIALIZE _floor
- :: Double -> Int
- #-}
-
-_properFraction x
- = case (decodeFloat x) of { (m,n) ->
- let b = floatRadix x in
- if n >= 0 then
- (fromInteger m * fromInteger b ^ n, 0)
- else
- case (quotRem m (b^(-n))) of { (w,r) ->
- (fromInteger w, encodeFloat r n)
- }
- }
-
-_truncate x = case (properFraction x) of { (m, _) -> m }
-
-_round x
- -- this defn differs from that in the report; uses _tagCmp
- --
- = case (properFraction x) of { (n,r) ->
- let
- m = if r < r0__ then n - i1__ else n + i1__
- sign = signum (abs r - rhalf__) --UNUSED!
-
- half_down = abs r - rhalf__
- in
- case (_tagCmp half_down r0__) of
- _LT -> n
- _EQ -> if even n then n else m
- _GT -> m
-{- OLD:
- if sign == iminus1__ then n
- else if sign == i0__ then (if even n then n else m)
- else if sign == i1__ then m
- else error "_round{PreludeCore}: no match in sign\n"
--}
- }
-
-_ceiling x
- = case (properFraction x) of { (n,r) ->
- if r > r0__ then n + i1__ else n }
-_floor x
- = case (properFraction x) of { (n,r) ->
- if r < r0__ then n - i1__ else n }
-
--------------------------------------------------------------------------
--- from/by Lennart, 94/09/26
+{- Hmmm...
---module Rational(prRational, fromRationalX, tinyDouble, tinyFloat, hugeDouble, hugeFloat, tiny, huge, integerLogBase) where
+-- Another version of _fromRational which is floating around ...
+-- Any idea what is the true story ? (PS)
--- Convert a Rational to a string that looks like a floating point number,
--- but without converting to any floating type (because of the possible overflow).
-_showRational :: Int -> Rational -> String
-_showRational n r =
- if r == 0 then
- "0.0"
- else
- let (r', e) = normalize r
- in prR n r' e
-
-startExpExp = 4 :: Int
-
--- make sure 1 <= r < 10
-normalize :: Rational -> (Rational, Int)
-normalize r = if r < 1 then case norm startExpExp (1 / r) 0 of (r', e) -> (10 / r', -e-1) else norm startExpExp r 0
- where norm :: Int -> Rational -> Int -> (Rational, Int)
- -- Invariant: r*10^e == original r
- norm 0 r e = (r, e)
- norm ee r e =
- let n = 10^ee
- tn = 10^n
- in if r >= tn then norm ee (r/tn) (e+n) else norm (ee-1) r e
-
-drop0 "" = ""
-drop0 (c:cs) = c : reverse (dropWhile (=='0') (reverse cs))
-
-prR :: Int -> Rational -> Int -> String
-prR n r e | r < 1 = prR n (r*10) (e-1) -- final adjustment
-prR n r e | r >= 10 = prR n (r/10) (e+1)
-prR n r e0 =
- let s = show ((_round (r * 10^n))::Integer)
- e = e0+1
- in if e > 0 && e < 8 then
- take e s ++ "." ++ drop0 (drop e s)
- else if e <= 0 && e > -3 then
- "0." ++ take (-e) (repeat '0') ++ drop0 s
- else
- head s : "."++ drop0 (tail s) ++ "e" ++ show e0
-
-------------
-
--- The Prelude version of fromRational is broken; if the denominator or nominator is
--- out of range it fails. So we use this (very expensive!) version instead.
-
-fromRationalX :: (RealFloat a) => Rational -> a
-
-fromRationalX r =
- rationalToRealFloat r
-{- Hmmm...
+_fromRational :: (RealFloat a) => Rational -> a
+_fromRational r
let
h = ceiling (huge `asTypeOf` x)
b = toInteger (floatRadix x)
-- we use the "old" Prelude code.
{--} )
in x
--}
-- Compute the discrete log of i in base b.
-- Simplest way would be just divide i by b until it's smaller then b, but that would
x = encodeFloat (floatRadix x ^ d - 1) (u - d)
in x
-tinyDouble = tiny :: Double
-tinyFloat = tiny :: Float
-hugeDouble = huge :: Double
-hugeFloat = huge :: Float
+...mmmH -}
+
+-------------------------------------------------------------------------
+-- from/by Lennart, 94/09/26
+
+-- Convert a Rational to a string that looks like a floating point number,
+-- but without converting to any floating type (because of the possible overflow).
+_showRational :: Int -> Rational -> String
+_showRational n r =
+ if r == __i0 then
+ "0.0"
+ else
+ let (r', e) = normalize r
+ in prR n r' e
+
+startExpExp = 4 :: Int
+
+-- make sure 1 <= r < 10
+normalize :: Rational -> (Rational, Int)
+normalize r = if r < __i1 then
+ case norm startExpExp (__i1 / r) 0 of (r', e) -> (__i10 / r', -e-1)
+ else
+ norm startExpExp r 0
+ where norm :: Int -> Rational -> Int -> (Rational, Int)
+ -- Invariant: r*10^e == original r
+ norm 0 r e = (r, e)
+ norm ee r e =
+ let n = 10^ee
+ tn = __i10^n
+ in if r >= tn then norm ee (r/tn) (e+n) else norm (ee-1) r e
+
+drop0 "" = ""
+drop0 (c:cs) = c : reverse (dropWhile (=='0') (reverse cs))
+
+prR :: Int -> Rational -> Int -> String
+prR n r e | r < __i1 = prR n (r*__i10) (e-1) -- final adjustment
+prR n r e | r >= __i10 = prR n (r/__i10) (e+1)
+prR n r e0 =
+ let s = show ((round (r * __i10^n))::Integer)
+ e = e0+1
+ in if e > 0 && e < 8 then
+ take e s ++ "." ++ drop0 (drop e s)
+ else if e <= 0 && e > -3 then
+ "0." ++ take (-e) (repeat '0') ++ drop0 s
+ else
+ head s : "."++ drop0 (tail s) ++ "e" ++ show e0
-----------------------------------------------------------------
--- It is problematic having this in Cls.hs
--- (You really don't want to know why -- WDP 94/12)
---
-_readList :: Text a => ReadS [a]
-
-_readList = readParen False (\r -> [pr | ("[",s) <- lex r,
- pr <- readl s])
- where readl s = [([],t) | ("]",t) <- lex s] ++
- [(x:xs,u) | (x,t) <- reads s,
- (xs,u) <- readl2 t]
- readl2 s = [([],t) | ("]",t) <- lex s] ++
- [(x:xs,v) | (",",t) <- lex s,
- (x,u) <- reads t,
- (xs,v) <- readl2 u]
-
-_showList :: Text a => [a] -> ShowS
-
-_showList [] = showString "[]"
-_showList (x:xs)
- = showChar '[' . shows x . showl xs
+
+{-# GENERATE_SPECS _readList a #-}
+_readList :: ReadS a -> ReadS [a]
+
+_readList readx = readParen False (\r -> [pr | ("[",s) <- lex r,
+ pr <- readl s])
+ where readl s = [([],t) | ("]",t) <- lex s] ++
+ [(x:xs,u) | (x,t) <- readx s,
+ (xs,u) <- readl2 t]
+ readl2 s = [([],t) | ("]",t) <- lex s] ++
+ [(x:xs,v) | (",",t) <- lex s,
+ (x,u) <- readx t,
+ (xs,v) <- readl2 u]
+
+{-# GENERATE_SPECS _showList a #-}
+_showList :: (a -> ShowS) -> [a] -> ShowS
+
+_showList showx [] = showString "[]"
+_showList showx (x:xs)
+ = showChar '[' . showx x . showl xs
where showl [] = showChar ']'
- showl (x:xs) = showString ", " . shows x . showl xs
+ showl (x:xs) = showString ", " . showx x . showl xs
-{-# GHC_PRAGMA INTERFACE VERSION 5 #-}
+{-# GHC_PRAGMA INTERFACE VERSION 6 #-}
interface PreludeCore where
import PreludeBuiltin(Char(..), Int(..), Integer(..), List(..), Tuple2)
import PreludeRatio(Ratio(..))
-_ceiling :: (RealFrac a, Integral b) => a -> b
- {-# GHC_PRAGMA _A_ 2 _U_ 122 _N_ _S_ "U(U(AU(U(AAAASAAA)AAAA)A)LSAAAA)L" {_A_ 4 _U_ 11122 _N_ _N_ _N_ _N_} _N_ _SPECIALISE_ [ Double, Int ] 2 { _A_ 0 _U_ 2 _N_ _N_ _N_ _N_ } #-}
-_floor :: (RealFrac a, Integral b) => a -> b
- {-# GHC_PRAGMA _A_ 2 _U_ 122 _N_ _S_ "U(U(AU(U(ASAAAAAA)AAAA)A)LSAAAA)L" {_A_ 4 _U_ 11122 _N_ _N_ _N_ _N_} _N_ _SPECIALISE_ [ Double, Int ] 2 { _A_ 0 _U_ 2 _N_ _N_ _N_ _N_ } #-}
-_integer_0 :: Integer
- {-# GHC_PRAGMA _A_ 0 _N_ _N_ _N_ _F_ _IF_ARGS_ 0 0 X 1 _#_ int2Integer# [] [0#] _N_ #-}
-_integer_1 :: Integer
- {-# GHC_PRAGMA _A_ 0 _N_ _N_ _N_ _F_ _IF_ARGS_ 0 0 X 1 _#_ int2Integer# [] [1#] _N_ #-}
-_integer_m1 :: Integer
- {-# GHC_PRAGMA _A_ 0 _N_ _N_ _N_ _N_ _N_ #-}
-_properFraction :: (RealFloat b, Integral a) => b -> (a, b)
- {-# GHC_PRAGMA _A_ 2 _U_ 112 _N_ _S_ "U(ALLAASLAAA)L" {_A_ 5 _U_ 111112 _N_ _N_ _N_ _N_} _N_ _SPECIALISE_ [ Int, Double ] 2 { _A_ 1 _U_ 1 _N_ _S_ "U(P)" {_A_ 1 _U_ 2 _N_ _N_ _N_ _N_} _N_ _N_ } #-}
-_readList :: Text a => [Char] -> [([a], [Char])]
+__i0 :: Num a => a
+ {-# GHC_PRAGMA _A_ 1 _U_ 1 _N_ _S_ "U(AAAAAAAAAS)" {_A_ 1 _U_ 1 _N_ _N_ _N_ _N_} _N_ _SPECIALISE_ [ Double ] 1 { _A_ 0 _N_ _N_ _N_ _F_ _IF_ARGS_ 0 0 X 2 _!_ D# [] [0.0000000000000000##] _N_ }, [ Int ] 1 { _A_ 0 _N_ _N_ _N_ _F_ _IF_ARGS_ 0 0 X 2 _!_ I# [] [0#] _N_ }, [ Integer ] 1 { _A_ 0 _N_ _N_ _N_ _N_ _N_ }, [ (Ratio Integer) ] 1 { _A_ 0 _N_ _N_ _N_ _N_ _N_ }, [ (Complex Double) ] 1 { _A_ 0 _N_ _N_ _N_ _N_ _N_ } #-}
+__i1 :: Num a => a
+ {-# GHC_PRAGMA _A_ 1 _U_ 1 _N_ _S_ "U(AAAAAAAAAS)" {_A_ 1 _U_ 1 _N_ _N_ _N_ _N_} _N_ _SPECIALISE_ [ Double ] 1 { _A_ 0 _N_ _N_ _N_ _F_ _IF_ARGS_ 0 0 X 2 _!_ D# [] [1.0000000000000000##] _N_ }, [ Int ] 1 { _A_ 0 _N_ _N_ _N_ _F_ _IF_ARGS_ 0 0 X 2 _!_ I# [] [1#] _N_ }, [ Integer ] 1 { _A_ 0 _N_ _N_ _N_ _N_ _N_ }, [ (Ratio Integer) ] 1 { _A_ 0 _N_ _N_ _N_ _N_ _N_ }, [ (Complex Double) ] 1 { _A_ 0 _N_ _N_ _N_ _N_ _N_ } #-}
+__i10 :: Num a => a
+ {-# GHC_PRAGMA _A_ 1 _U_ 1 _N_ _S_ "U(AAAAAAAAAS)" {_A_ 1 _U_ 1 _N_ _N_ _N_ _N_} _N_ _SPECIALISE_ [ Double ] 1 { _A_ 0 _N_ _N_ _N_ _F_ _IF_ARGS_ 0 0 X 2 _!_ D# [] [10.000000000000000##] _N_ }, [ Int ] 1 { _A_ 0 _N_ _N_ _N_ _F_ _IF_ARGS_ 0 0 X 2 _!_ I# [] [10#] _N_ }, [ Integer ] 1 { _A_ 0 _N_ _N_ _N_ _N_ _N_ }, [ (Ratio Integer) ] 1 { _A_ 0 _N_ _N_ _N_ _N_ _N_ }, [ (Complex Double) ] 1 { _A_ 0 _N_ _N_ _N_ _N_ _N_ } #-}
+__i16 :: Num a => a
+ {-# GHC_PRAGMA _A_ 1 _U_ 1 _N_ _S_ "U(AAAAAAAAAS)" {_A_ 1 _U_ 1 _N_ _N_ _N_ _N_} _N_ _SPECIALISE_ [ Double ] 1 { _A_ 0 _N_ _N_ _N_ _F_ _IF_ARGS_ 0 0 X 2 _!_ D# [] [16.000000000000000##] _N_ }, [ Int ] 1 { _A_ 0 _N_ _N_ _N_ _F_ _IF_ARGS_ 0 0 X 2 _!_ I# [] [16#] _N_ }, [ Integer ] 1 { _A_ 0 _N_ _N_ _N_ _N_ _N_ }, [ (Ratio Integer) ] 1 { _A_ 0 _N_ _N_ _N_ _N_ _N_ }, [ (Complex Double) ] 1 { _A_ 0 _N_ _N_ _N_ _N_ _N_ } #-}
+__i2 :: Num a => a
+ {-# GHC_PRAGMA _A_ 1 _U_ 1 _N_ _S_ "U(AAAAAAAAAS)" {_A_ 1 _U_ 1 _N_ _N_ _N_ _N_} _N_ _SPECIALISE_ [ Double ] 1 { _A_ 0 _N_ _N_ _N_ _F_ _IF_ARGS_ 0 0 X 2 _!_ D# [] [2.0000000000000000##] _N_ }, [ Int ] 1 { _A_ 0 _N_ _N_ _N_ _F_ _IF_ARGS_ 0 0 X 2 _!_ I# [] [2#] _N_ }, [ Integer ] 1 { _A_ 0 _N_ _N_ _N_ _N_ _N_ }, [ (Ratio Integer) ] 1 { _A_ 0 _N_ _N_ _N_ _N_ _N_ }, [ (Complex Double) ] 1 { _A_ 0 _N_ _N_ _N_ _N_ _N_ } #-}
+__i8 :: Num a => a
+ {-# GHC_PRAGMA _A_ 1 _U_ 1 _N_ _S_ "U(AAAAAAAAAS)" {_A_ 1 _U_ 1 _N_ _N_ _N_ _N_} _N_ _SPECIALISE_ [ Double ] 1 { _A_ 0 _N_ _N_ _N_ _F_ _IF_ARGS_ 0 0 X 2 _!_ D# [] [8.0000000000000000##] _N_ }, [ Int ] 1 { _A_ 0 _N_ _N_ _N_ _F_ _IF_ARGS_ 0 0 X 2 _!_ I# [] [8#] _N_ }, [ Integer ] 1 { _A_ 0 _N_ _N_ _N_ _N_ _N_ }, [ (Ratio Integer) ] 1 { _A_ 0 _N_ _N_ _N_ _N_ _N_ }, [ (Complex Double) ] 1 { _A_ 0 _N_ _N_ _N_ _N_ _N_ } #-}
+__im1 :: Num a => a
+ {-# GHC_PRAGMA _A_ 1 _U_ 1 _N_ _S_ "U(AAAAAAAAAS)" {_A_ 1 _U_ 1 _N_ _N_ _N_ _N_} _N_ _SPECIALISE_ [ Double ] 1 { _A_ 0 _N_ _N_ _N_ _F_ _IF_ARGS_ 0 0 X 2 _!_ D# [] [-1.0000000000000000##] _N_ }, [ Int ] 1 { _A_ 0 _N_ _N_ _N_ _F_ _IF_ARGS_ 0 0 X 2 _!_ I# [] [-1#] _N_ }, [ Integer ] 1 { _A_ 0 _N_ _N_ _N_ _N_ _N_ }, [ (Ratio Integer) ] 1 { _A_ 0 _N_ _N_ _N_ _N_ _N_ }, [ (Complex Double) ] 1 { _A_ 0 _N_ _N_ _N_ _N_ _N_ } #-}
+__rhalf :: Fractional a => a
+ {-# GHC_PRAGMA _A_ 1 _U_ 1 _N_ _S_ "U(AAAS)" {_A_ 1 _U_ 1 _N_ _N_ _N_ _N_} _N_ _SPECIALISE_ [ Double ] 1 { _A_ 0 _N_ _N_ _N_ _N_ _N_ }, [ (Ratio Integer) ] 1 { _A_ 0 _N_ _N_ _N_ _F_ _IF_ARGS_ 0 0 X 3 _!_ (:%) [Integer] [_SPEC_ _ORIG_ PreludeCore __i1 [ (Integer) ], _SPEC_ _ORIG_ PreludeCore __i2 [ (Integer) ]] _N_ }, [ (Complex Double) ] 1 { _A_ 0 _N_ _N_ _N_ _N_ _N_ } #-}
+_fromRational :: RealFloat a => Ratio Integer -> a
+ {-# GHC_PRAGMA _A_ 2 _U_ 22 _N_ _N_ _N_ _SPECIALISE_ [ Double ] 1 { _A_ 1 _U_ 1 _N_ _S_ "U(U(PPP)U(PPP))" {_A_ 4 _U_ 2221 _N_ _N_ _N_ _N_} _N_ _N_ } #-}
+_readList :: ([Char] -> [(a, [Char])]) -> [Char] -> [([a], [Char])]
{-# GHC_PRAGMA _A_ 1 _U_ 22 _N_ _N_ _N_ _N_ #-}
-_round :: (RealFrac a, Integral b) => a -> b
- {-# GHC_PRAGMA _A_ 2 _U_ 122 _N_ _S_ "U(U(AU(U(ALAAAAAS)AAAA)A)LSAAAA)L" {_A_ 5 _U_ 112122 _N_ _N_ _N_ _N_} _N_ _SPECIALISE_ [ Double, Int ] 2 { _A_ 0 _U_ 2 _N_ _N_ _N_ _N_ }, [ (Ratio Integer), Integer ] 2 { _A_ 1 _U_ 1 _N_ _S_ "U(LL)" {_A_ 2 _U_ 22 _N_ _N_ _N_ _N_} _N_ _N_ } #-}
-_showList :: Text a => [a] -> [Char] -> [Char]
- {-# GHC_PRAGMA _A_ 1 _U_ 212 _N_ _N_ _N_ _N_ #-}
+_showList :: (a -> [Char] -> [Char]) -> [a] -> [Char] -> [Char]
+ {-# GHC_PRAGMA _A_ 2 _U_ 212 _N_ _S_ "LS" _N_ _N_ #-}
_showRational :: Int -> Ratio Integer -> [Char]
{-# GHC_PRAGMA _A_ 2 _U_ 21 _N_ _S_ "LU(U(PPP)L)" {_A_ 5 _U_ 22222 _N_ _N_ _N_ _N_} _N_ _N_ #-}
-_truncate :: (RealFrac a, Integral b) => a -> b
- {-# GHC_PRAGMA _A_ 2 _U_ 122 _N_ _S_ "U(AASAAAA)L" {_A_ 2 _U_ 122 _N_ _N_ _N_ _N_} _N_ _SPECIALISE_ [ Double, Int ] 2 { _A_ 0 _U_ 2 _N_ _N_ _N_ _N_ } #-}
-fromRationalX :: RealFloat a => Ratio Integer -> a
- {-# GHC_PRAGMA _A_ 0 _U_ 22 _N_ _N_ _N_ _N_ #-}
-i0__ :: Num a => a
- {-# GHC_PRAGMA _A_ 1 _U_ 1 _N_ _S_ "U(AAAAAAAASA)" {_A_ 1 _U_ 1 _N_ _N_ _N_ _N_} _F_ _IF_ARGS_ 1 1 C 5 _/\_ u0 -> \ (u1 :: {{Num u0}}) -> let {(u2 :: Integer) = _#_ int2Integer# [] [0#]} in case u1 of { _ALG_ _TUP_10 (u3 :: {{Eq u0}}) (u4 :: {{Text u0}}) (u5 :: u0 -> u0 -> u0) (u6 :: u0 -> u0 -> u0) (u7 :: u0 -> u0 -> u0) (u8 :: u0 -> u0) (u9 :: u0 -> u0) (ua :: u0 -> u0) (ub :: Integer -> u0) (uc :: Int -> u0) -> _APP_ ub [ u2 ]; _NO_DEFLT_ } _SPECIALISE_ [ Int ] 1 { _A_ 0 _N_ _N_ _N_ _N_ _N_ }, [ Integer ] 1 { _A_ 0 _N_ _N_ _N_ _F_ _IF_ARGS_ 0 0 X 1 _#_ int2Integer# [] [0#] _N_ } #-}
-i1__ :: Num a => a
- {-# GHC_PRAGMA _A_ 1 _U_ 1 _N_ _S_ "U(AAAAAAAASA)" {_A_ 1 _U_ 1 _N_ _N_ _N_ _N_} _F_ _IF_ARGS_ 1 1 C 5 _/\_ u0 -> \ (u1 :: {{Num u0}}) -> let {(u2 :: Integer) = _#_ int2Integer# [] [1#]} in case u1 of { _ALG_ _TUP_10 (u3 :: {{Eq u0}}) (u4 :: {{Text u0}}) (u5 :: u0 -> u0 -> u0) (u6 :: u0 -> u0 -> u0) (u7 :: u0 -> u0 -> u0) (u8 :: u0 -> u0) (u9 :: u0 -> u0) (ua :: u0 -> u0) (ub :: Integer -> u0) (uc :: Int -> u0) -> _APP_ ub [ u2 ]; _NO_DEFLT_ } _SPECIALISE_ [ Int ] 1 { _A_ 0 _N_ _N_ _N_ _N_ _N_ }, [ Integer ] 1 { _A_ 0 _N_ _N_ _N_ _F_ _IF_ARGS_ 0 0 X 1 _#_ int2Integer# [] [1#] _N_ } #-}
-i2__ :: Num a => a
- {-# GHC_PRAGMA _A_ 1 _U_ 1 _N_ _S_ "U(AAAAAAAASA)" {_A_ 1 _U_ 1 _N_ _N_ _N_ _N_} _F_ _IF_ARGS_ 1 1 C 5 _/\_ u0 -> \ (u1 :: {{Num u0}}) -> let {(u2 :: Integer) = _#_ int2Integer# [] [2#]} in case u1 of { _ALG_ _TUP_10 (u3 :: {{Eq u0}}) (u4 :: {{Text u0}}) (u5 :: u0 -> u0 -> u0) (u6 :: u0 -> u0 -> u0) (u7 :: u0 -> u0 -> u0) (u8 :: u0 -> u0) (u9 :: u0 -> u0) (ua :: u0 -> u0) (ub :: Integer -> u0) (uc :: Int -> u0) -> _APP_ ub [ u2 ]; _NO_DEFLT_ } _N_ #-}
-iminus1__ :: Num a => a
- {-# GHC_PRAGMA _A_ 1 _U_ 1 _N_ _S_ "U(AAAAAAAASA)" {_A_ 1 _U_ 1 _N_ _N_ _N_ _N_} _N_ _N_ #-}
-int2Integer :: Int -> Integer
- {-# GHC_PRAGMA _A_ 1 _U_ 1 _N_ _S_ "U(P)" {_A_ 1 _U_ 2 _N_ _N_ _F_ _IF_ARGS_ 0 1 X 1 \ (u0 :: Int#) -> _#_ int2Integer# [] [u0] _N_} _F_ _IF_ARGS_ 0 1 C 2 \ (u0 :: Int) -> case u0 of { _ALG_ I# (u1 :: Int#) -> _#_ int2Integer# [] [u1]; _NO_DEFLT_ } _N_ #-}
-r0__ :: Fractional a => a
- {-# GHC_PRAGMA _A_ 1 _U_ 1 _N_ _S_ "U(AAAS)" {_A_ 1 _U_ 1 _N_ _N_ _N_ _N_} _N_ _SPECIALISE_ [ Double ] 1 { _A_ 0 _N_ _N_ _N_ _N_ _N_ }, [ (Ratio Integer) ] 1 { _A_ 0 _N_ _N_ _N_ _N_ _N_ } #-}
-r1__ :: Fractional a => a
- {-# GHC_PRAGMA _A_ 1 _U_ 1 _N_ _S_ "U(AAAS)" {_A_ 1 _U_ 1 _N_ _N_ _N_ _N_} _N_ _N_ #-}
-rhalf__ :: Fractional a => a
- {-# GHC_PRAGMA _A_ 1 _U_ 1 _N_ _S_ "U(AAAS)" {_A_ 1 _U_ 1 _N_ _N_ _N_ _N_} _N_ _SPECIALISE_ [ Double ] 1 { _A_ 0 _N_ _N_ _N_ _N_ _N_ }, [ (Ratio Integer) ] 1 { _A_ 0 _N_ _N_ _N_ _N_ _N_ } #-}
-{-# GHC_PRAGMA INTERFACE VERSION 5 #-}
+{-# GHC_PRAGMA INTERFACE VERSION 6 #-}
interface PreludeCore where
import PreludeBuiltin(Char(..), Int(..), Integer(..), List(..), Tuple2)
import PreludeRatio(Ratio(..))
-_ceiling :: (RealFrac a, Integral b) => a -> b
- {-# GHC_PRAGMA _A_ 2 _U_ 122 _N_ _S_ "U(U(AU(U(AAAASAAA)AAAA)A)LSAAAA)L" {_A_ 4 _U_ 11122 _N_ _N_ _N_ _N_} _N_ _SPECIALISE_ [ Double, Int ] 2 { _A_ 0 _U_ 2 _N_ _N_ _N_ _N_ } #-}
-_floor :: (RealFrac a, Integral b) => a -> b
- {-# GHC_PRAGMA _A_ 2 _U_ 122 _N_ _S_ "U(U(AU(U(ASAAAAAA)AAAA)A)LSAAAA)L" {_A_ 4 _U_ 11122 _N_ _N_ _N_ _N_} _N_ _SPECIALISE_ [ Double, Int ] 2 { _A_ 0 _U_ 2 _N_ _N_ _N_ _N_ } #-}
-_integer_0 :: Integer
- {-# GHC_PRAGMA _A_ 0 _N_ _N_ _N_ _F_ _IF_ARGS_ 0 0 X 1 _#_ int2Integer# [] [0#] _N_ #-}
-_integer_1 :: Integer
- {-# GHC_PRAGMA _A_ 0 _N_ _N_ _N_ _F_ _IF_ARGS_ 0 0 X 1 _#_ int2Integer# [] [1#] _N_ #-}
-_integer_m1 :: Integer
- {-# GHC_PRAGMA _A_ 0 _N_ _N_ _N_ _N_ _N_ #-}
-_properFraction :: (RealFloat b, Integral a) => b -> (a, b)
- {-# GHC_PRAGMA _A_ 2 _U_ 112 _N_ _S_ "U(ALLAASLAAA)L" {_A_ 5 _U_ 111112 _N_ _N_ _N_ _N_} _N_ _SPECIALISE_ [ Int, Double ] 2 { _A_ 1 _U_ 1 _N_ _S_ "U(P)" {_A_ 1 _U_ 2 _N_ _N_ _N_ _N_} _N_ _N_ } #-}
-_readList :: Text a => [Char] -> [([a], [Char])]
- {-# GHC_PRAGMA _A_ 1 _U_ 22 _N_ _N_ _N_ _N_ #-}
-_round :: (RealFrac a, Integral b) => a -> b
- {-# GHC_PRAGMA _A_ 2 _U_ 122 _N_ _S_ "U(U(AU(U(ALAAAAAS)AAAA)A)LSAAAA)L" {_A_ 5 _U_ 112122 _N_ _N_ _N_ _N_} _N_ _SPECIALISE_ [ Double, Int ] 2 { _A_ 0 _U_ 2 _N_ _N_ _N_ _N_ }, [ (Ratio Integer), Integer ] 2 { _A_ 1 _U_ 1 _N_ _S_ "U(LL)" {_A_ 2 _U_ 22 _N_ _N_ _N_ _N_} _N_ _N_ } #-}
-_showList :: Text a => [a] -> [Char] -> [Char]
- {-# GHC_PRAGMA _A_ 1 _U_ 212 _N_ _N_ _N_ _N_ #-}
+__i0 :: Num a => a
+ {-# GHC_PRAGMA _A_ 1 _N_ _N_ _S_ "U(AAAAAAAAAS)" {_A_ 1 _N_ _N_ _N_ _N_ _N_} _N_ _SPECIALISE_ [ Double ] 1 { _A_ 0 _N_ _N_ _N_ _F_ _IF_ARGS_ 0 0 X 2 _!_ D# [] [0.0000000000000000##] _N_ }, [ Int ] 1 { _A_ 0 _N_ _N_ _N_ _F_ _IF_ARGS_ 0 0 X 2 _!_ I# [] [0#] _N_ }, [ Integer ] 1 { _A_ 0 _N_ _N_ _N_ _N_ _N_ }, [ (Ratio Integer) ] 1 { _A_ 0 _N_ _N_ _N_ _N_ _N_ }, [ (Complex Double) ] 1 { _A_ 0 _N_ _N_ _N_ _N_ _N_ } #-}
+__i1 :: Num a => a
+ {-# GHC_PRAGMA _A_ 1 _N_ _N_ _S_ "U(AAAAAAAAAS)" {_A_ 1 _N_ _N_ _N_ _N_ _N_} _N_ _SPECIALISE_ [ Double ] 1 { _A_ 0 _N_ _N_ _N_ _F_ _IF_ARGS_ 0 0 X 2 _!_ D# [] [1.0000000000000000##] _N_ }, [ Int ] 1 { _A_ 0 _N_ _N_ _N_ _F_ _IF_ARGS_ 0 0 X 2 _!_ I# [] [1#] _N_ }, [ Integer ] 1 { _A_ 0 _N_ _N_ _N_ _N_ _N_ }, [ (Ratio Integer) ] 1 { _A_ 0 _N_ _N_ _N_ _N_ _N_ }, [ (Complex Double) ] 1 { _A_ 0 _N_ _N_ _N_ _N_ _N_ } #-}
+__i10 :: Num a => a
+ {-# GHC_PRAGMA _A_ 1 _N_ _N_ _S_ "U(AAAAAAAAAS)" {_A_ 1 _N_ _N_ _N_ _N_ _N_} _N_ _SPECIALISE_ [ Double ] 1 { _A_ 0 _N_ _N_ _N_ _F_ _IF_ARGS_ 0 0 X 2 _!_ D# [] [10.000000000000000##] _N_ }, [ Int ] 1 { _A_ 0 _N_ _N_ _N_ _F_ _IF_ARGS_ 0 0 X 2 _!_ I# [] [10#] _N_ }, [ Integer ] 1 { _A_ 0 _N_ _N_ _N_ _N_ _N_ }, [ (Ratio Integer) ] 1 { _A_ 0 _N_ _N_ _N_ _N_ _N_ }, [ (Complex Double) ] 1 { _A_ 0 _N_ _N_ _N_ _N_ _N_ } #-}
+__i16 :: Num a => a
+ {-# GHC_PRAGMA _A_ 1 _N_ _N_ _S_ "U(AAAAAAAAAS)" {_A_ 1 _N_ _N_ _N_ _N_ _N_} _N_ _SPECIALISE_ [ Double ] 1 { _A_ 0 _N_ _N_ _N_ _F_ _IF_ARGS_ 0 0 X 2 _!_ D# [] [16.000000000000000##] _N_ }, [ Int ] 1 { _A_ 0 _N_ _N_ _N_ _F_ _IF_ARGS_ 0 0 X 2 _!_ I# [] [16#] _N_ }, [ Integer ] 1 { _A_ 0 _N_ _N_ _N_ _N_ _N_ }, [ (Ratio Integer) ] 1 { _A_ 0 _N_ _N_ _N_ _N_ _N_ }, [ (Complex Double) ] 1 { _A_ 0 _N_ _N_ _N_ _N_ _N_ } #-}
+__i2 :: Num a => a
+ {-# GHC_PRAGMA _A_ 1 _N_ _N_ _S_ "U(AAAAAAAAAS)" {_A_ 1 _N_ _N_ _N_ _N_ _N_} _N_ _SPECIALISE_ [ Double ] 1 { _A_ 0 _N_ _N_ _N_ _F_ _IF_ARGS_ 0 0 X 2 _!_ D# [] [2.0000000000000000##] _N_ }, [ Int ] 1 { _A_ 0 _N_ _N_ _N_ _F_ _IF_ARGS_ 0 0 X 2 _!_ I# [] [2#] _N_ }, [ Integer ] 1 { _A_ 0 _N_ _N_ _N_ _N_ _N_ }, [ (Ratio Integer) ] 1 { _A_ 0 _N_ _N_ _N_ _N_ _N_ }, [ (Complex Double) ] 1 { _A_ 0 _N_ _N_ _N_ _N_ _N_ } #-}
+__i8 :: Num a => a
+ {-# GHC_PRAGMA _A_ 1 _N_ _N_ _S_ "U(AAAAAAAAAS)" {_A_ 1 _N_ _N_ _N_ _N_ _N_} _N_ _SPECIALISE_ [ Double ] 1 { _A_ 0 _N_ _N_ _N_ _F_ _IF_ARGS_ 0 0 X 2 _!_ D# [] [8.0000000000000000##] _N_ }, [ Int ] 1 { _A_ 0 _N_ _N_ _N_ _F_ _IF_ARGS_ 0 0 X 2 _!_ I# [] [8#] _N_ }, [ Integer ] 1 { _A_ 0 _N_ _N_ _N_ _N_ _N_ }, [ (Ratio Integer) ] 1 { _A_ 0 _N_ _N_ _N_ _N_ _N_ }, [ (Complex Double) ] 1 { _A_ 0 _N_ _N_ _N_ _N_ _N_ } #-}
+__im1 :: Num a => a
+ {-# GHC_PRAGMA _A_ 1 _N_ _N_ _S_ "U(AAAAAAAAAS)" {_A_ 1 _N_ _N_ _N_ _N_ _N_} _N_ _SPECIALISE_ [ Double ] 1 { _A_ 0 _N_ _N_ _N_ _F_ _IF_ARGS_ 0 0 X 2 _!_ D# [] [-1.0000000000000000##] _N_ }, [ Int ] 1 { _A_ 0 _N_ _N_ _N_ _F_ _IF_ARGS_ 0 0 X 2 _!_ I# [] [-1#] _N_ }, [ Integer ] 1 { _A_ 0 _N_ _N_ _N_ _N_ _N_ }, [ (Ratio Integer) ] 1 { _A_ 0 _N_ _N_ _N_ _N_ _N_ }, [ (Complex Double) ] 1 { _A_ 0 _N_ _N_ _N_ _N_ _N_ } #-}
+__rhalf :: Fractional a => a
+ {-# GHC_PRAGMA _A_ 1 _N_ _N_ _S_ "U(AAAS)" {_A_ 1 _N_ _N_ _N_ _N_ _N_} _N_ _SPECIALISE_ [ Double ] 1 { _A_ 0 _N_ _N_ _N_ _N_ _N_ }, [ (Ratio Integer) ] 1 { _A_ 0 _N_ _N_ _N_ _F_ _IF_ARGS_ 0 0 X 3 _!_ (:%) [Integer] [_SPEC_ _ORIG_ PreludeCore __i1 [ (Integer) ], _SPEC_ _ORIG_ PreludeCore __i2 [ (Integer) ]] _N_ }, [ (Complex Double) ] 1 { _A_ 0 _N_ _N_ _N_ _N_ _N_ } #-}
+_fromRational :: RealFloat a => Ratio Integer -> a
+ {-# GHC_PRAGMA _A_ 2 _N_ _N_ _N_ _N_ _SPECIALISE_ [ Double ] 1 { _A_ 1 _N_ _N_ _S_ "U(U(PPP)U(PPP))" {_A_ 4 _N_ _N_ _N_ _N_ _N_} _N_ _N_ } #-}
+_readList :: ([Char] -> [(a, [Char])]) -> [Char] -> [([a], [Char])]
+ {-# GHC_PRAGMA _A_ 1 _N_ _N_ _N_ _N_ _N_ #-}
+_showList :: (a -> [Char] -> [Char]) -> [a] -> [Char] -> [Char]
+ {-# GHC_PRAGMA _A_ 2 _N_ _N_ _S_ "LS" _N_ _N_ #-}
_showRational :: Int -> Ratio Integer -> [Char]
- {-# GHC_PRAGMA _A_ 2 _U_ 21 _N_ _S_ "LU(U(PPP)L)" {_A_ 5 _U_ 22222 _N_ _N_ _N_ _N_} _N_ _N_ #-}
-_truncate :: (RealFrac a, Integral b) => a -> b
- {-# GHC_PRAGMA _A_ 2 _U_ 122 _N_ _S_ "U(AASAAAA)L" {_A_ 2 _U_ 122 _N_ _N_ _N_ _N_} _N_ _SPECIALISE_ [ Double, Int ] 2 { _A_ 0 _U_ 2 _N_ _N_ _N_ _N_ } #-}
-fromRationalX :: RealFloat a => Ratio Integer -> a
- {-# GHC_PRAGMA _A_ 0 _U_ 22 _N_ _N_ _N_ _N_ #-}
-i0__ :: Num a => a
- {-# GHC_PRAGMA _A_ 1 _U_ 1 _N_ _S_ "U(AAAAAAAASA)" {_A_ 1 _U_ 1 _N_ _N_ _N_ _N_} _F_ _IF_ARGS_ 1 1 C 5 _/\_ u0 -> \ (u1 :: {{Num u0}}) -> let {(u2 :: Integer) = _#_ int2Integer# [] [0#]} in case u1 of { _ALG_ _TUP_10 (u3 :: {{Eq u0}}) (u4 :: {{Text u0}}) (u5 :: u0 -> u0 -> u0) (u6 :: u0 -> u0 -> u0) (u7 :: u0 -> u0 -> u0) (u8 :: u0 -> u0) (u9 :: u0 -> u0) (ua :: u0 -> u0) (ub :: Integer -> u0) (uc :: Int -> u0) -> _APP_ ub [ u2 ]; _NO_DEFLT_ } _SPECIALISE_ [ Int ] 1 { _A_ 0 _N_ _N_ _N_ _N_ _N_ }, [ Integer ] 1 { _A_ 0 _N_ _N_ _N_ _F_ _IF_ARGS_ 0 0 X 1 _#_ int2Integer# [] [0#] _N_ } #-}
-i1__ :: Num a => a
- {-# GHC_PRAGMA _A_ 1 _U_ 1 _N_ _S_ "U(AAAAAAAASA)" {_A_ 1 _U_ 1 _N_ _N_ _N_ _N_} _F_ _IF_ARGS_ 1 1 C 5 _/\_ u0 -> \ (u1 :: {{Num u0}}) -> let {(u2 :: Integer) = _#_ int2Integer# [] [1#]} in case u1 of { _ALG_ _TUP_10 (u3 :: {{Eq u0}}) (u4 :: {{Text u0}}) (u5 :: u0 -> u0 -> u0) (u6 :: u0 -> u0 -> u0) (u7 :: u0 -> u0 -> u0) (u8 :: u0 -> u0) (u9 :: u0 -> u0) (ua :: u0 -> u0) (ub :: Integer -> u0) (uc :: Int -> u0) -> _APP_ ub [ u2 ]; _NO_DEFLT_ } _SPECIALISE_ [ Int ] 1 { _A_ 0 _N_ _N_ _N_ _N_ _N_ }, [ Integer ] 1 { _A_ 0 _N_ _N_ _N_ _F_ _IF_ARGS_ 0 0 X 1 _#_ int2Integer# [] [1#] _N_ } #-}
-i2__ :: Num a => a
- {-# GHC_PRAGMA _A_ 1 _U_ 1 _N_ _S_ "U(AAAAAAAASA)" {_A_ 1 _U_ 1 _N_ _N_ _N_ _N_} _F_ _IF_ARGS_ 1 1 C 5 _/\_ u0 -> \ (u1 :: {{Num u0}}) -> let {(u2 :: Integer) = _#_ int2Integer# [] [2#]} in case u1 of { _ALG_ _TUP_10 (u3 :: {{Eq u0}}) (u4 :: {{Text u0}}) (u5 :: u0 -> u0 -> u0) (u6 :: u0 -> u0 -> u0) (u7 :: u0 -> u0 -> u0) (u8 :: u0 -> u0) (u9 :: u0 -> u0) (ua :: u0 -> u0) (ub :: Integer -> u0) (uc :: Int -> u0) -> _APP_ ub [ u2 ]; _NO_DEFLT_ } _N_ #-}
-iminus1__ :: Num a => a
- {-# GHC_PRAGMA _A_ 1 _U_ 1 _N_ _S_ "U(AAAAAAAASA)" {_A_ 1 _U_ 1 _N_ _N_ _N_ _N_} _N_ _N_ #-}
+ {-# GHC_PRAGMA _A_ 2 _N_ _N_ _S_ "LU(U(PPP)L)" {_A_ 5 _N_ _N_ _N_ _N_ _N_} _N_ _N_ #-}
int2Integer :: Int -> Integer
- {-# GHC_PRAGMA _A_ 1 _U_ 1 _N_ _S_ "U(P)" {_A_ 1 _U_ 2 _N_ _N_ _F_ _IF_ARGS_ 0 1 X 1 \ (u0 :: Int#) -> _#_ int2Integer# [] [u0] _N_} _F_ _IF_ARGS_ 0 1 C 2 \ (u0 :: Int) -> case u0 of { _ALG_ I# (u1 :: Int#) -> _#_ int2Integer# [] [u1]; _NO_DEFLT_ } _N_ #-}
-r0__ :: Fractional a => a
- {-# GHC_PRAGMA _A_ 1 _U_ 1 _N_ _S_ "U(AAAS)" {_A_ 1 _U_ 1 _N_ _N_ _N_ _N_} _N_ _SPECIALISE_ [ Double ] 1 { _A_ 0 _N_ _N_ _N_ _N_ _N_ }, [ (Ratio Integer) ] 1 { _A_ 0 _N_ _N_ _N_ _N_ _N_ } #-}
-r1__ :: Fractional a => a
- {-# GHC_PRAGMA _A_ 1 _U_ 1 _N_ _S_ "U(AAAS)" {_A_ 1 _U_ 1 _N_ _N_ _N_ _N_} _N_ _N_ #-}
-rhalf__ :: Fractional a => a
- {-# GHC_PRAGMA _A_ 1 _U_ 1 _N_ _S_ "U(AAAS)" {_A_ 1 _U_ 1 _N_ _N_ _N_ _N_} _N_ _SPECIALISE_ [ Double ] 1 { _A_ 0 _N_ _N_ _N_ _N_ _N_ }, [ (Ratio Integer) ] 1 { _A_ 0 _N_ _N_ _N_ _N_ _N_ } #-}
+ {-# GHC_PRAGMA _A_ 1 _N_ _N_ _S_ "U(P)" {_A_ 1 _N_ _N_ _N_ _F_ _IF_ARGS_ 0 1 X 1 \ (u0 :: Int#) -> _#_ int2Integer# [] [u0] _N_} _F_ _IF_ARGS_ 0 1 C 2 \ (u0 :: Int) -> case u0 of { _ALG_ I# (u1 :: Int#) -> _#_ int2Integer# [] [u1]; _NO_DEFLT_ } _N_ #-}
-{-# GHC_PRAGMA INTERFACE VERSION 5 #-}
+{-# GHC_PRAGMA INTERFACE VERSION 6 #-}
interface PreludeCore where
import PreludeBuiltin(Char(..), Int(..), Integer(..), List(..), Tuple2)
import PreludeRatio(Ratio(..))
-_ceiling :: (RealFrac a, Integral b) => a -> b
- {-# GHC_PRAGMA _A_ 2 _U_ 122 _N_ _S_ "U(U(AU(U(AAAASAAA)AAAA)A)LSAAAA)L" {_A_ 4 _U_ 11122 _N_ _N_ _N_ _N_} _N_ _SPECIALISE_ [ Double, Int ] 2 { _A_ 0 _U_ 2 _N_ _N_ _N_ _N_ } #-}
-_floor :: (RealFrac a, Integral b) => a -> b
- {-# GHC_PRAGMA _A_ 2 _U_ 122 _N_ _S_ "U(U(AU(U(ASAAAAAA)AAAA)A)LSAAAA)L" {_A_ 4 _U_ 11122 _N_ _N_ _N_ _N_} _N_ _SPECIALISE_ [ Double, Int ] 2 { _A_ 0 _U_ 2 _N_ _N_ _N_ _N_ } #-}
-_integer_0 :: Integer
- {-# GHC_PRAGMA _A_ 0 _N_ _N_ _N_ _F_ _IF_ARGS_ 0 0 X 1 _#_ int2Integer# [] [0#] _N_ #-}
-_integer_1 :: Integer
- {-# GHC_PRAGMA _A_ 0 _N_ _N_ _N_ _F_ _IF_ARGS_ 0 0 X 1 _#_ int2Integer# [] [1#] _N_ #-}
-_integer_m1 :: Integer
- {-# GHC_PRAGMA _A_ 0 _N_ _N_ _N_ _N_ _N_ #-}
-_properFraction :: (RealFloat b, Integral a) => b -> (a, b)
- {-# GHC_PRAGMA _A_ 2 _U_ 112 _N_ _S_ "U(ALLAASLAAA)L" {_A_ 5 _U_ 111112 _N_ _N_ _N_ _N_} _N_ _SPECIALISE_ [ Int, Double ] 2 { _A_ 1 _U_ 1 _N_ _S_ "U(P)" {_A_ 1 _U_ 2 _N_ _N_ _N_ _N_} _N_ _N_ } #-}
-_readList :: Text a => [Char] -> [([a], [Char])]
+__i0 :: Num a => a
+ {-# GHC_PRAGMA _A_ 1 _U_ 1 _N_ _S_ "U(AAAAAAAAAS)" {_A_ 1 _U_ 1 _N_ _N_ _N_ _N_} _N_ _SPECIALISE_ [ Double ] 1 { _A_ 0 _N_ _N_ _N_ _F_ _IF_ARGS_ 0 0 X 2 _!_ D# [] [0.0000000000000000##] _N_ }, [ Int ] 1 { _A_ 0 _N_ _N_ _N_ _F_ _IF_ARGS_ 0 0 X 2 _!_ I# [] [0#] _N_ }, [ Integer ] 1 { _A_ 0 _N_ _N_ _N_ _N_ _N_ }, [ (Ratio Integer) ] 1 { _A_ 0 _N_ _N_ _N_ _N_ _N_ }, [ (Complex Double) ] 1 { _A_ 0 _N_ _N_ _N_ _N_ _N_ } #-}
+__i1 :: Num a => a
+ {-# GHC_PRAGMA _A_ 1 _U_ 1 _N_ _S_ "U(AAAAAAAAAS)" {_A_ 1 _U_ 1 _N_ _N_ _N_ _N_} _N_ _SPECIALISE_ [ Double ] 1 { _A_ 0 _N_ _N_ _N_ _F_ _IF_ARGS_ 0 0 X 2 _!_ D# [] [1.0000000000000000##] _N_ }, [ Int ] 1 { _A_ 0 _N_ _N_ _N_ _F_ _IF_ARGS_ 0 0 X 2 _!_ I# [] [1#] _N_ }, [ Integer ] 1 { _A_ 0 _N_ _N_ _N_ _N_ _N_ }, [ (Ratio Integer) ] 1 { _A_ 0 _N_ _N_ _N_ _N_ _N_ }, [ (Complex Double) ] 1 { _A_ 0 _N_ _N_ _N_ _N_ _N_ } #-}
+__i10 :: Num a => a
+ {-# GHC_PRAGMA _A_ 1 _U_ 1 _N_ _S_ "U(AAAAAAAAAS)" {_A_ 1 _U_ 1 _N_ _N_ _N_ _N_} _N_ _SPECIALISE_ [ Double ] 1 { _A_ 0 _N_ _N_ _N_ _F_ _IF_ARGS_ 0 0 X 2 _!_ D# [] [10.000000000000000##] _N_ }, [ Int ] 1 { _A_ 0 _N_ _N_ _N_ _F_ _IF_ARGS_ 0 0 X 2 _!_ I# [] [10#] _N_ }, [ Integer ] 1 { _A_ 0 _N_ _N_ _N_ _N_ _N_ }, [ (Ratio Integer) ] 1 { _A_ 0 _N_ _N_ _N_ _N_ _N_ }, [ (Complex Double) ] 1 { _A_ 0 _N_ _N_ _N_ _N_ _N_ } #-}
+__i16 :: Num a => a
+ {-# GHC_PRAGMA _A_ 1 _U_ 1 _N_ _S_ "U(AAAAAAAAAS)" {_A_ 1 _U_ 1 _N_ _N_ _N_ _N_} _N_ _SPECIALISE_ [ Double ] 1 { _A_ 0 _N_ _N_ _N_ _F_ _IF_ARGS_ 0 0 X 2 _!_ D# [] [16.000000000000000##] _N_ }, [ Int ] 1 { _A_ 0 _N_ _N_ _N_ _F_ _IF_ARGS_ 0 0 X 2 _!_ I# [] [16#] _N_ }, [ Integer ] 1 { _A_ 0 _N_ _N_ _N_ _N_ _N_ }, [ (Ratio Integer) ] 1 { _A_ 0 _N_ _N_ _N_ _N_ _N_ }, [ (Complex Double) ] 1 { _A_ 0 _N_ _N_ _N_ _N_ _N_ } #-}
+__i2 :: Num a => a
+ {-# GHC_PRAGMA _A_ 1 _U_ 1 _N_ _S_ "U(AAAAAAAAAS)" {_A_ 1 _U_ 1 _N_ _N_ _N_ _N_} _N_ _SPECIALISE_ [ Double ] 1 { _A_ 0 _N_ _N_ _N_ _F_ _IF_ARGS_ 0 0 X 2 _!_ D# [] [2.0000000000000000##] _N_ }, [ Int ] 1 { _A_ 0 _N_ _N_ _N_ _F_ _IF_ARGS_ 0 0 X 2 _!_ I# [] [2#] _N_ }, [ Integer ] 1 { _A_ 0 _N_ _N_ _N_ _N_ _N_ }, [ (Ratio Integer) ] 1 { _A_ 0 _N_ _N_ _N_ _N_ _N_ }, [ (Complex Double) ] 1 { _A_ 0 _N_ _N_ _N_ _N_ _N_ } #-}
+__i8 :: Num a => a
+ {-# GHC_PRAGMA _A_ 1 _U_ 1 _N_ _S_ "U(AAAAAAAAAS)" {_A_ 1 _U_ 1 _N_ _N_ _N_ _N_} _N_ _SPECIALISE_ [ Double ] 1 { _A_ 0 _N_ _N_ _N_ _F_ _IF_ARGS_ 0 0 X 2 _!_ D# [] [8.0000000000000000##] _N_ }, [ Int ] 1 { _A_ 0 _N_ _N_ _N_ _F_ _IF_ARGS_ 0 0 X 2 _!_ I# [] [8#] _N_ }, [ Integer ] 1 { _A_ 0 _N_ _N_ _N_ _N_ _N_ }, [ (Ratio Integer) ] 1 { _A_ 0 _N_ _N_ _N_ _N_ _N_ }, [ (Complex Double) ] 1 { _A_ 0 _N_ _N_ _N_ _N_ _N_ } #-}
+__im1 :: Num a => a
+ {-# GHC_PRAGMA _A_ 1 _U_ 1 _N_ _S_ "U(AAAAAAAAAS)" {_A_ 1 _U_ 1 _N_ _N_ _N_ _N_} _N_ _SPECIALISE_ [ Double ] 1 { _A_ 0 _N_ _N_ _N_ _F_ _IF_ARGS_ 0 0 X 2 _!_ D# [] [-1.0000000000000000##] _N_ }, [ Int ] 1 { _A_ 0 _N_ _N_ _N_ _F_ _IF_ARGS_ 0 0 X 2 _!_ I# [] [-1#] _N_ }, [ Integer ] 1 { _A_ 0 _N_ _N_ _N_ _N_ _N_ }, [ (Ratio Integer) ] 1 { _A_ 0 _N_ _N_ _N_ _N_ _N_ }, [ (Complex Double) ] 1 { _A_ 0 _N_ _N_ _N_ _N_ _N_ } #-}
+__rhalf :: Fractional a => a
+ {-# GHC_PRAGMA _A_ 1 _U_ 1 _N_ _S_ "U(AAAS)" {_A_ 1 _U_ 1 _N_ _N_ _N_ _N_} _N_ _SPECIALISE_ [ Double ] 1 { _A_ 0 _N_ _N_ _N_ _N_ _N_ }, [ (Ratio Integer) ] 1 { _A_ 0 _N_ _N_ _N_ _F_ _IF_ARGS_ 0 0 X 3 _!_ (:%) [Integer] [_SPEC_ _ORIG_ PreludeCore __i1 [ (Integer) ], _SPEC_ _ORIG_ PreludeCore __i2 [ (Integer) ]] _N_ }, [ (Complex Double) ] 1 { _A_ 0 _N_ _N_ _N_ _N_ _N_ } #-}
+_fromRational :: RealFloat a => Ratio Integer -> a
+ {-# GHC_PRAGMA _A_ 2 _U_ 22 _N_ _N_ _N_ _SPECIALISE_ [ Double ] 1 { _A_ 1 _U_ 1 _N_ _S_ "U(U(PPP)U(PPP))" {_A_ 4 _U_ 2221 _N_ _N_ _N_ _N_} _N_ _N_ } #-}
+_readList :: ([Char] -> [(a, [Char])]) -> [Char] -> [([a], [Char])]
{-# GHC_PRAGMA _A_ 1 _U_ 22 _N_ _N_ _N_ _N_ #-}
-_round :: (RealFrac a, Integral b) => a -> b
- {-# GHC_PRAGMA _A_ 2 _U_ 122 _N_ _S_ "U(U(AU(U(ALAAAAAS)AAAA)A)LSAAAA)L" {_A_ 5 _U_ 112122 _N_ _N_ _N_ _N_} _N_ _SPECIALISE_ [ Double, Int ] 2 { _A_ 0 _U_ 2 _N_ _N_ _N_ _N_ }, [ (Ratio Integer), Integer ] 2 { _A_ 1 _U_ 1 _N_ _S_ "U(LL)" {_A_ 2 _U_ 22 _N_ _N_ _N_ _N_} _N_ _N_ } #-}
-_showList :: Text a => [a] -> [Char] -> [Char]
- {-# GHC_PRAGMA _A_ 1 _U_ 212 _N_ _N_ _N_ _N_ #-}
+_showList :: (a -> [Char] -> [Char]) -> [a] -> [Char] -> [Char]
+ {-# GHC_PRAGMA _A_ 2 _U_ 212 _N_ _S_ "LS" _N_ _N_ #-}
_showRational :: Int -> Ratio Integer -> [Char]
{-# GHC_PRAGMA _A_ 2 _U_ 21 _N_ _S_ "LU(U(PPP)L)" {_A_ 5 _U_ 22222 _N_ _N_ _N_ _N_} _N_ _N_ #-}
-_truncate :: (RealFrac a, Integral b) => a -> b
- {-# GHC_PRAGMA _A_ 2 _U_ 122 _N_ _S_ "U(AASAAAA)L" {_A_ 2 _U_ 122 _N_ _N_ _N_ _N_} _N_ _SPECIALISE_ [ Double, Int ] 2 { _A_ 0 _U_ 2 _N_ _N_ _N_ _N_ } #-}
-fromRationalX :: RealFloat a => Ratio Integer -> a
- {-# GHC_PRAGMA _A_ 0 _U_ 22 _N_ _N_ _N_ _N_ #-}
-i0__ :: Num a => a
- {-# GHC_PRAGMA _A_ 1 _U_ 1 _N_ _S_ "U(AAAAAAAASA)" {_A_ 1 _U_ 1 _N_ _N_ _N_ _N_} _F_ _IF_ARGS_ 1 1 C 5 _/\_ u0 -> \ (u1 :: {{Num u0}}) -> let {(u2 :: Integer) = _#_ int2Integer# [] [0#]} in case u1 of { _ALG_ _TUP_10 (u3 :: {{Eq u0}}) (u4 :: {{Text u0}}) (u5 :: u0 -> u0 -> u0) (u6 :: u0 -> u0 -> u0) (u7 :: u0 -> u0 -> u0) (u8 :: u0 -> u0) (u9 :: u0 -> u0) (ua :: u0 -> u0) (ub :: Integer -> u0) (uc :: Int -> u0) -> _APP_ ub [ u2 ]; _NO_DEFLT_ } _SPECIALISE_ [ Int ] 1 { _A_ 0 _N_ _N_ _N_ _N_ _N_ }, [ Integer ] 1 { _A_ 0 _N_ _N_ _N_ _F_ _IF_ARGS_ 0 0 X 1 _#_ int2Integer# [] [0#] _N_ } #-}
-i1__ :: Num a => a
- {-# GHC_PRAGMA _A_ 1 _U_ 1 _N_ _S_ "U(AAAAAAAASA)" {_A_ 1 _U_ 1 _N_ _N_ _N_ _N_} _F_ _IF_ARGS_ 1 1 C 5 _/\_ u0 -> \ (u1 :: {{Num u0}}) -> let {(u2 :: Integer) = _#_ int2Integer# [] [1#]} in case u1 of { _ALG_ _TUP_10 (u3 :: {{Eq u0}}) (u4 :: {{Text u0}}) (u5 :: u0 -> u0 -> u0) (u6 :: u0 -> u0 -> u0) (u7 :: u0 -> u0 -> u0) (u8 :: u0 -> u0) (u9 :: u0 -> u0) (ua :: u0 -> u0) (ub :: Integer -> u0) (uc :: Int -> u0) -> _APP_ ub [ u2 ]; _NO_DEFLT_ } _SPECIALISE_ [ Int ] 1 { _A_ 0 _N_ _N_ _N_ _N_ _N_ }, [ Integer ] 1 { _A_ 0 _N_ _N_ _N_ _F_ _IF_ARGS_ 0 0 X 1 _#_ int2Integer# [] [1#] _N_ } #-}
-i2__ :: Num a => a
- {-# GHC_PRAGMA _A_ 1 _U_ 1 _N_ _S_ "U(AAAAAAAASA)" {_A_ 1 _U_ 1 _N_ _N_ _N_ _N_} _F_ _IF_ARGS_ 1 1 C 5 _/\_ u0 -> \ (u1 :: {{Num u0}}) -> let {(u2 :: Integer) = _#_ int2Integer# [] [2#]} in case u1 of { _ALG_ _TUP_10 (u3 :: {{Eq u0}}) (u4 :: {{Text u0}}) (u5 :: u0 -> u0 -> u0) (u6 :: u0 -> u0 -> u0) (u7 :: u0 -> u0 -> u0) (u8 :: u0 -> u0) (u9 :: u0 -> u0) (ua :: u0 -> u0) (ub :: Integer -> u0) (uc :: Int -> u0) -> _APP_ ub [ u2 ]; _NO_DEFLT_ } _N_ #-}
-iminus1__ :: Num a => a
- {-# GHC_PRAGMA _A_ 1 _U_ 1 _N_ _S_ "U(AAAAAAAASA)" {_A_ 1 _U_ 1 _N_ _N_ _N_ _N_} _N_ _N_ #-}
-int2Integer :: Int -> Integer
- {-# GHC_PRAGMA _A_ 1 _U_ 1 _N_ _S_ "U(P)" {_A_ 1 _U_ 2 _N_ _N_ _F_ _IF_ARGS_ 0 1 X 1 \ (u0 :: Int#) -> _#_ int2Integer# [] [u0] _N_} _F_ _IF_ARGS_ 0 1 C 2 \ (u0 :: Int) -> case u0 of { _ALG_ I# (u1 :: Int#) -> _#_ int2Integer# [] [u1]; _NO_DEFLT_ } _N_ #-}
-r0__ :: Fractional a => a
- {-# GHC_PRAGMA _A_ 1 _U_ 1 _N_ _S_ "U(AAAS)" {_A_ 1 _U_ 1 _N_ _N_ _N_ _N_} _N_ _SPECIALISE_ [ Double ] 1 { _A_ 0 _N_ _N_ _N_ _N_ _N_ }, [ (Ratio Integer) ] 1 { _A_ 0 _N_ _N_ _N_ _N_ _N_ } #-}
-r1__ :: Fractional a => a
- {-# GHC_PRAGMA _A_ 1 _U_ 1 _N_ _S_ "U(AAAS)" {_A_ 1 _U_ 1 _N_ _N_ _N_ _N_} _N_ _N_ #-}
-rhalf__ :: Fractional a => a
- {-# GHC_PRAGMA _A_ 1 _U_ 1 _N_ _S_ "U(AAAS)" {_A_ 1 _U_ 1 _N_ _N_ _N_ _N_} _N_ _SPECIALISE_ [ Double ] 1 { _A_ 0 _N_ _N_ _N_ _N_ _N_ }, [ (Ratio Integer) ] 1 { _A_ 0 _N_ _N_ _N_ _N_ _N_ } #-}
-{-# GHC_PRAGMA INTERFACE VERSION 5 #-}
+{-# GHC_PRAGMA INTERFACE VERSION 6 #-}
interface PreludeCore where
import PreludeBuiltin(Char(..), Int(..), Integer(..), List(..), Tuple2)
import PreludeRatio(Ratio(..))
-_ceiling :: (RealFrac a, Integral b) => a -> b
- {-# GHC_PRAGMA _A_ 2 _U_ 122 _N_ _S_ "U(U(AU(U(AAAASAAA)AAAA)A)LSAAAA)L" {_A_ 4 _U_ 11122 _N_ _N_ _N_ _N_} _N_ _SPECIALISE_ [ Double, Int ] 2 { _A_ 0 _U_ 2 _N_ _N_ _N_ _N_ } #-}
-_floor :: (RealFrac a, Integral b) => a -> b
- {-# GHC_PRAGMA _A_ 2 _U_ 122 _N_ _S_ "U(U(AU(U(ASAAAAAA)AAAA)A)LSAAAA)L" {_A_ 4 _U_ 11122 _N_ _N_ _N_ _N_} _N_ _SPECIALISE_ [ Double, Int ] 2 { _A_ 0 _U_ 2 _N_ _N_ _N_ _N_ } #-}
-_integer_0 :: Integer
- {-# GHC_PRAGMA _A_ 0 _N_ _N_ _N_ _F_ _IF_ARGS_ 0 0 X 1 _#_ int2Integer# [] [0#] _N_ #-}
-_integer_1 :: Integer
- {-# GHC_PRAGMA _A_ 0 _N_ _N_ _N_ _F_ _IF_ARGS_ 0 0 X 1 _#_ int2Integer# [] [1#] _N_ #-}
-_integer_m1 :: Integer
- {-# GHC_PRAGMA _A_ 0 _N_ _N_ _N_ _N_ _N_ #-}
-_properFraction :: (RealFloat b, Integral a) => b -> (a, b)
- {-# GHC_PRAGMA _A_ 2 _U_ 112 _N_ _S_ "U(ALLAASLAAA)L" {_A_ 5 _U_ 111112 _N_ _N_ _N_ _N_} _N_ _SPECIALISE_ [ Int, Double ] 2 { _A_ 1 _U_ 1 _N_ _S_ "U(P)" {_A_ 1 _U_ 2 _N_ _N_ _N_ _N_} _N_ _N_ } #-}
-_readList :: Text a => [Char] -> [([a], [Char])]
- {-# GHC_PRAGMA _A_ 1 _U_ 22 _N_ _N_ _N_ _N_ #-}
-_round :: (RealFrac a, Integral b) => a -> b
- {-# GHC_PRAGMA _A_ 2 _U_ 122 _N_ _S_ "U(U(AU(U(ALAAAAAS)AAAA)A)LSAAAA)L" {_A_ 5 _U_ 112122 _N_ _N_ _N_ _N_} _N_ _SPECIALISE_ [ Double, Int ] 2 { _A_ 0 _U_ 2 _N_ _N_ _N_ _N_ }, [ (Ratio Integer), Integer ] 2 { _A_ 1 _U_ 1 _N_ _S_ "U(LL)" {_A_ 2 _U_ 22 _N_ _N_ _N_ _N_} _N_ _N_ } #-}
-_showList :: Text a => [a] -> [Char] -> [Char]
- {-# GHC_PRAGMA _A_ 1 _U_ 212 _N_ _N_ _N_ _N_ #-}
+__i0 :: Num a => a
+ {-# GHC_PRAGMA _A_ 1 _N_ _N_ _S_ "U(AAAAAAAAAS)" {_A_ 1 _N_ _N_ _N_ _N_ _N_} _N_ _SPECIALISE_ [ Double ] 1 { _A_ 0 _N_ _N_ _N_ _F_ _IF_ARGS_ 0 0 X 2 _!_ D# [] [0.0000000000000000##] _N_ }, [ Int ] 1 { _A_ 0 _N_ _N_ _N_ _F_ _IF_ARGS_ 0 0 X 2 _!_ I# [] [0#] _N_ }, [ Integer ] 1 { _A_ 0 _N_ _N_ _N_ _N_ _N_ }, [ (Ratio Integer) ] 1 { _A_ 0 _N_ _N_ _N_ _N_ _N_ }, [ (Complex Double) ] 1 { _A_ 0 _N_ _N_ _N_ _N_ _N_ } #-}
+__i1 :: Num a => a
+ {-# GHC_PRAGMA _A_ 1 _N_ _N_ _S_ "U(AAAAAAAAAS)" {_A_ 1 _N_ _N_ _N_ _N_ _N_} _N_ _SPECIALISE_ [ Double ] 1 { _A_ 0 _N_ _N_ _N_ _F_ _IF_ARGS_ 0 0 X 2 _!_ D# [] [1.0000000000000000##] _N_ }, [ Int ] 1 { _A_ 0 _N_ _N_ _N_ _F_ _IF_ARGS_ 0 0 X 2 _!_ I# [] [1#] _N_ }, [ Integer ] 1 { _A_ 0 _N_ _N_ _N_ _N_ _N_ }, [ (Ratio Integer) ] 1 { _A_ 0 _N_ _N_ _N_ _N_ _N_ }, [ (Complex Double) ] 1 { _A_ 0 _N_ _N_ _N_ _N_ _N_ } #-}
+__i10 :: Num a => a
+ {-# GHC_PRAGMA _A_ 1 _N_ _N_ _S_ "U(AAAAAAAAAS)" {_A_ 1 _N_ _N_ _N_ _N_ _N_} _N_ _SPECIALISE_ [ Double ] 1 { _A_ 0 _N_ _N_ _N_ _F_ _IF_ARGS_ 0 0 X 2 _!_ D# [] [10.000000000000000##] _N_ }, [ Int ] 1 { _A_ 0 _N_ _N_ _N_ _F_ _IF_ARGS_ 0 0 X 2 _!_ I# [] [10#] _N_ }, [ Integer ] 1 { _A_ 0 _N_ _N_ _N_ _N_ _N_ }, [ (Ratio Integer) ] 1 { _A_ 0 _N_ _N_ _N_ _N_ _N_ }, [ (Complex Double) ] 1 { _A_ 0 _N_ _N_ _N_ _N_ _N_ } #-}
+__i16 :: Num a => a
+ {-# GHC_PRAGMA _A_ 1 _N_ _N_ _S_ "U(AAAAAAAAAS)" {_A_ 1 _N_ _N_ _N_ _N_ _N_} _N_ _SPECIALISE_ [ Double ] 1 { _A_ 0 _N_ _N_ _N_ _F_ _IF_ARGS_ 0 0 X 2 _!_ D# [] [16.000000000000000##] _N_ }, [ Int ] 1 { _A_ 0 _N_ _N_ _N_ _F_ _IF_ARGS_ 0 0 X 2 _!_ I# [] [16#] _N_ }, [ Integer ] 1 { _A_ 0 _N_ _N_ _N_ _N_ _N_ }, [ (Ratio Integer) ] 1 { _A_ 0 _N_ _N_ _N_ _N_ _N_ }, [ (Complex Double) ] 1 { _A_ 0 _N_ _N_ _N_ _N_ _N_ } #-}
+__i2 :: Num a => a
+ {-# GHC_PRAGMA _A_ 1 _N_ _N_ _S_ "U(AAAAAAAAAS)" {_A_ 1 _N_ _N_ _N_ _N_ _N_} _N_ _SPECIALISE_ [ Double ] 1 { _A_ 0 _N_ _N_ _N_ _F_ _IF_ARGS_ 0 0 X 2 _!_ D# [] [2.0000000000000000##] _N_ }, [ Int ] 1 { _A_ 0 _N_ _N_ _N_ _F_ _IF_ARGS_ 0 0 X 2 _!_ I# [] [2#] _N_ }, [ Integer ] 1 { _A_ 0 _N_ _N_ _N_ _N_ _N_ }, [ (Ratio Integer) ] 1 { _A_ 0 _N_ _N_ _N_ _N_ _N_ }, [ (Complex Double) ] 1 { _A_ 0 _N_ _N_ _N_ _N_ _N_ } #-}
+__i8 :: Num a => a
+ {-# GHC_PRAGMA _A_ 1 _N_ _N_ _S_ "U(AAAAAAAAAS)" {_A_ 1 _N_ _N_ _N_ _N_ _N_} _N_ _SPECIALISE_ [ Double ] 1 { _A_ 0 _N_ _N_ _N_ _F_ _IF_ARGS_ 0 0 X 2 _!_ D# [] [8.0000000000000000##] _N_ }, [ Int ] 1 { _A_ 0 _N_ _N_ _N_ _F_ _IF_ARGS_ 0 0 X 2 _!_ I# [] [8#] _N_ }, [ Integer ] 1 { _A_ 0 _N_ _N_ _N_ _N_ _N_ }, [ (Ratio Integer) ] 1 { _A_ 0 _N_ _N_ _N_ _N_ _N_ }, [ (Complex Double) ] 1 { _A_ 0 _N_ _N_ _N_ _N_ _N_ } #-}
+__im1 :: Num a => a
+ {-# GHC_PRAGMA _A_ 1 _N_ _N_ _S_ "U(AAAAAAAAAS)" {_A_ 1 _N_ _N_ _N_ _N_ _N_} _N_ _SPECIALISE_ [ Double ] 1 { _A_ 0 _N_ _N_ _N_ _F_ _IF_ARGS_ 0 0 X 2 _!_ D# [] [-1.0000000000000000##] _N_ }, [ Int ] 1 { _A_ 0 _N_ _N_ _N_ _F_ _IF_ARGS_ 0 0 X 2 _!_ I# [] [-1#] _N_ }, [ Integer ] 1 { _A_ 0 _N_ _N_ _N_ _N_ _N_ }, [ (Ratio Integer) ] 1 { _A_ 0 _N_ _N_ _N_ _N_ _N_ }, [ (Complex Double) ] 1 { _A_ 0 _N_ _N_ _N_ _N_ _N_ } #-}
+__rhalf :: Fractional a => a
+ {-# GHC_PRAGMA _A_ 1 _N_ _N_ _S_ "U(AAAS)" {_A_ 1 _N_ _N_ _N_ _N_ _N_} _N_ _SPECIALISE_ [ Double ] 1 { _A_ 0 _N_ _N_ _N_ _N_ _N_ }, [ (Ratio Integer) ] 1 { _A_ 0 _N_ _N_ _N_ _F_ _IF_ARGS_ 0 0 X 3 _!_ (:%) [Integer] [_SPEC_ _ORIG_ PreludeCore __i1 [ (Integer) ], _SPEC_ _ORIG_ PreludeCore __i2 [ (Integer) ]] _N_ }, [ (Complex Double) ] 1 { _A_ 0 _N_ _N_ _N_ _N_ _N_ } #-}
+_fromRational :: RealFloat a => Ratio Integer -> a
+ {-# GHC_PRAGMA _A_ 2 _N_ _N_ _N_ _N_ _SPECIALISE_ [ Double ] 1 { _A_ 1 _N_ _N_ _S_ "U(U(PPP)U(PPP))" {_A_ 4 _N_ _N_ _N_ _N_ _N_} _N_ _N_ } #-}
+_readList :: ([Char] -> [(a, [Char])]) -> [Char] -> [([a], [Char])]
+ {-# GHC_PRAGMA _A_ 1 _N_ _N_ _N_ _N_ _N_ #-}
+_showList :: (a -> [Char] -> [Char]) -> [a] -> [Char] -> [Char]
+ {-# GHC_PRAGMA _A_ 2 _N_ _N_ _S_ "LS" _N_ _N_ #-}
_showRational :: Int -> Ratio Integer -> [Char]
- {-# GHC_PRAGMA _A_ 2 _U_ 21 _N_ _S_ "LU(U(PPP)L)" {_A_ 5 _U_ 22222 _N_ _N_ _N_ _N_} _N_ _N_ #-}
-_truncate :: (RealFrac a, Integral b) => a -> b
- {-# GHC_PRAGMA _A_ 2 _U_ 122 _N_ _S_ "U(AASAAAA)L" {_A_ 2 _U_ 122 _N_ _N_ _N_ _N_} _N_ _SPECIALISE_ [ Double, Int ] 2 { _A_ 0 _U_ 2 _N_ _N_ _N_ _N_ } #-}
-fromRationalX :: RealFloat a => Ratio Integer -> a
- {-# GHC_PRAGMA _A_ 0 _U_ 22 _N_ _N_ _N_ _N_ #-}
-i0__ :: Num a => a
- {-# GHC_PRAGMA _A_ 1 _U_ 1 _N_ _S_ "U(AAAAAAAASA)" {_A_ 1 _U_ 1 _N_ _N_ _N_ _N_} _F_ _IF_ARGS_ 1 1 C 5 _/\_ u0 -> \ (u1 :: {{Num u0}}) -> let {(u2 :: Integer) = _#_ int2Integer# [] [0#]} in case u1 of { _ALG_ _TUP_10 (u3 :: {{Eq u0}}) (u4 :: {{Text u0}}) (u5 :: u0 -> u0 -> u0) (u6 :: u0 -> u0 -> u0) (u7 :: u0 -> u0 -> u0) (u8 :: u0 -> u0) (u9 :: u0 -> u0) (ua :: u0 -> u0) (ub :: Integer -> u0) (uc :: Int -> u0) -> _APP_ ub [ u2 ]; _NO_DEFLT_ } _SPECIALISE_ [ Int ] 1 { _A_ 0 _N_ _N_ _N_ _N_ _N_ }, [ Integer ] 1 { _A_ 0 _N_ _N_ _N_ _F_ _IF_ARGS_ 0 0 X 1 _#_ int2Integer# [] [0#] _N_ } #-}
-i1__ :: Num a => a
- {-# GHC_PRAGMA _A_ 1 _U_ 1 _N_ _S_ "U(AAAAAAAASA)" {_A_ 1 _U_ 1 _N_ _N_ _N_ _N_} _F_ _IF_ARGS_ 1 1 C 5 _/\_ u0 -> \ (u1 :: {{Num u0}}) -> let {(u2 :: Integer) = _#_ int2Integer# [] [1#]} in case u1 of { _ALG_ _TUP_10 (u3 :: {{Eq u0}}) (u4 :: {{Text u0}}) (u5 :: u0 -> u0 -> u0) (u6 :: u0 -> u0 -> u0) (u7 :: u0 -> u0 -> u0) (u8 :: u0 -> u0) (u9 :: u0 -> u0) (ua :: u0 -> u0) (ub :: Integer -> u0) (uc :: Int -> u0) -> _APP_ ub [ u2 ]; _NO_DEFLT_ } _SPECIALISE_ [ Int ] 1 { _A_ 0 _N_ _N_ _N_ _N_ _N_ }, [ Integer ] 1 { _A_ 0 _N_ _N_ _N_ _F_ _IF_ARGS_ 0 0 X 1 _#_ int2Integer# [] [1#] _N_ } #-}
-i2__ :: Num a => a
- {-# GHC_PRAGMA _A_ 1 _U_ 1 _N_ _S_ "U(AAAAAAAASA)" {_A_ 1 _U_ 1 _N_ _N_ _N_ _N_} _F_ _IF_ARGS_ 1 1 C 5 _/\_ u0 -> \ (u1 :: {{Num u0}}) -> let {(u2 :: Integer) = _#_ int2Integer# [] [2#]} in case u1 of { _ALG_ _TUP_10 (u3 :: {{Eq u0}}) (u4 :: {{Text u0}}) (u5 :: u0 -> u0 -> u0) (u6 :: u0 -> u0 -> u0) (u7 :: u0 -> u0 -> u0) (u8 :: u0 -> u0) (u9 :: u0 -> u0) (ua :: u0 -> u0) (ub :: Integer -> u0) (uc :: Int -> u0) -> _APP_ ub [ u2 ]; _NO_DEFLT_ } _N_ #-}
-iminus1__ :: Num a => a
- {-# GHC_PRAGMA _A_ 1 _U_ 1 _N_ _S_ "U(AAAAAAAASA)" {_A_ 1 _U_ 1 _N_ _N_ _N_ _N_} _N_ _N_ #-}
+ {-# GHC_PRAGMA _A_ 2 _N_ _N_ _S_ "LU(U(PPP)L)" {_A_ 5 _N_ _N_ _N_ _N_ _N_} _N_ _N_ #-}
int2Integer :: Int -> Integer
- {-# GHC_PRAGMA _A_ 1 _U_ 1 _N_ _S_ "U(P)" {_A_ 1 _U_ 2 _N_ _N_ _F_ _IF_ARGS_ 0 1 X 1 \ (u0 :: Int#) -> _#_ int2Integer# [] [u0] _N_} _F_ _IF_ARGS_ 0 1 C 2 \ (u0 :: Int) -> case u0 of { _ALG_ I# (u1 :: Int#) -> _#_ int2Integer# [] [u1]; _NO_DEFLT_ } _N_ #-}
-r0__ :: Fractional a => a
- {-# GHC_PRAGMA _A_ 1 _U_ 1 _N_ _S_ "U(AAAS)" {_A_ 1 _U_ 1 _N_ _N_ _N_ _N_} _N_ _SPECIALISE_ [ Double ] 1 { _A_ 0 _N_ _N_ _N_ _N_ _N_ }, [ (Ratio Integer) ] 1 { _A_ 0 _N_ _N_ _N_ _N_ _N_ } #-}
-r1__ :: Fractional a => a
- {-# GHC_PRAGMA _A_ 1 _U_ 1 _N_ _S_ "U(AAAS)" {_A_ 1 _U_ 1 _N_ _N_ _N_ _N_} _N_ _N_ #-}
-rhalf__ :: Fractional a => a
- {-# GHC_PRAGMA _A_ 1 _U_ 1 _N_ _S_ "U(AAAS)" {_A_ 1 _U_ 1 _N_ _N_ _N_ _N_} _N_ _SPECIALISE_ [ Double ] 1 { _A_ 0 _N_ _N_ _N_ _N_ _N_ }, [ (Ratio Integer) ] 1 { _A_ 0 _N_ _N_ _N_ _N_ _N_ } #-}
+ {-# GHC_PRAGMA _A_ 1 _N_ _N_ _S_ "U(P)" {_A_ 1 _N_ _N_ _N_ _F_ _IF_ARGS_ 0 1 X 1 \ (u0 :: Int#) -> _#_ int2Integer# [] [u0] _N_} _F_ _IF_ARGS_ 0 1 C 2 \ (u0 :: Int) -> case u0 of { _ALG_ I# (u1 :: Int#) -> _#_ int2Integer# [] [u1]; _NO_DEFLT_ } _N_ #-}
-{-# GHC_PRAGMA INTERFACE VERSION 5 #-}
+{-# GHC_PRAGMA INTERFACE VERSION 6 #-}
interface PreludeCore where
import PreludeBuiltin(Char(..), Int(..), Integer(..), List(..), Tuple2)
import PreludeRatio(Ratio(..))
-_ceiling :: (RealFrac a, Integral b) => a -> b
- {-# GHC_PRAGMA _A_ 2 _U_ 122 _N_ _S_ "U(U(AU(U(AAAASAAA)AAAA)A)LSAAAA)L" {_A_ 4 _U_ 11122 _N_ _N_ _N_ _N_} _N_ _SPECIALISE_ [ Double, Int ] 2 { _A_ 0 _U_ 2 _N_ _N_ _N_ _N_ } #-}
-_floor :: (RealFrac a, Integral b) => a -> b
- {-# GHC_PRAGMA _A_ 2 _U_ 122 _N_ _S_ "U(U(AU(U(ASAAAAAA)AAAA)A)LSAAAA)L" {_A_ 4 _U_ 11122 _N_ _N_ _N_ _N_} _N_ _SPECIALISE_ [ Double, Int ] 2 { _A_ 0 _U_ 2 _N_ _N_ _N_ _N_ } #-}
-_integer_0 :: Integer
- {-# GHC_PRAGMA _A_ 0 _N_ _N_ _N_ _F_ _IF_ARGS_ 0 0 X 1 _#_ int2Integer# [] [0#] _N_ #-}
-_integer_1 :: Integer
- {-# GHC_PRAGMA _A_ 0 _N_ _N_ _N_ _F_ _IF_ARGS_ 0 0 X 1 _#_ int2Integer# [] [1#] _N_ #-}
-_integer_m1 :: Integer
- {-# GHC_PRAGMA _A_ 0 _N_ _N_ _N_ _N_ _N_ #-}
-_properFraction :: (RealFloat b, Integral a) => b -> (a, b)
- {-# GHC_PRAGMA _A_ 2 _U_ 112 _N_ _S_ "U(ALLAASLAAA)L" {_A_ 5 _U_ 111112 _N_ _N_ _N_ _N_} _N_ _SPECIALISE_ [ Int, Double ] 2 { _A_ 1 _U_ 1 _N_ _S_ "U(P)" {_A_ 1 _U_ 2 _N_ _N_ _N_ _N_} _N_ _N_ } #-}
-_readList :: Text a => [Char] -> [([a], [Char])]
- {-# GHC_PRAGMA _A_ 1 _U_ 22 _N_ _N_ _N_ _N_ #-}
-_round :: (RealFrac a, Integral b) => a -> b
- {-# GHC_PRAGMA _A_ 2 _U_ 122 _N_ _S_ "U(U(AU(U(ALAAAAAS)AAAA)A)LSAAAA)L" {_A_ 5 _U_ 112122 _N_ _N_ _N_ _N_} _N_ _SPECIALISE_ [ Double, Int ] 2 { _A_ 0 _U_ 2 _N_ _N_ _N_ _N_ }, [ (Ratio Integer), Integer ] 2 { _A_ 1 _U_ 1 _N_ _S_ "U(LL)" {_A_ 2 _U_ 22 _N_ _N_ _N_ _N_} _N_ _N_ } #-}
-_showList :: Text a => [a] -> [Char] -> [Char]
- {-# GHC_PRAGMA _A_ 1 _U_ 212 _N_ _N_ _N_ _N_ #-}
+__i0 :: Num a => a
+ {-# GHC_PRAGMA _A_ 1 _N_ _N_ _S_ "U(AAAAAAAAAS)" {_A_ 1 _N_ _N_ _N_ _N_ _N_} _N_ _SPECIALISE_ [ Double ] 1 { _A_ 0 _N_ _N_ _N_ _F_ _IF_ARGS_ 0 0 X 2 _!_ D# [] [0.0000000000000000##] _N_ }, [ Int ] 1 { _A_ 0 _N_ _N_ _N_ _F_ _IF_ARGS_ 0 0 X 2 _!_ I# [] [0#] _N_ }, [ Integer ] 1 { _A_ 0 _N_ _N_ _N_ _N_ _N_ }, [ (Ratio Integer) ] 1 { _A_ 0 _N_ _N_ _N_ _N_ _N_ }, [ (Complex Double) ] 1 { _A_ 0 _N_ _N_ _N_ _N_ _N_ } #-}
+__i1 :: Num a => a
+ {-# GHC_PRAGMA _A_ 1 _N_ _N_ _S_ "U(AAAAAAAAAS)" {_A_ 1 _N_ _N_ _N_ _N_ _N_} _N_ _SPECIALISE_ [ Double ] 1 { _A_ 0 _N_ _N_ _N_ _F_ _IF_ARGS_ 0 0 X 2 _!_ D# [] [1.0000000000000000##] _N_ }, [ Int ] 1 { _A_ 0 _N_ _N_ _N_ _F_ _IF_ARGS_ 0 0 X 2 _!_ I# [] [1#] _N_ }, [ Integer ] 1 { _A_ 0 _N_ _N_ _N_ _N_ _N_ }, [ (Ratio Integer) ] 1 { _A_ 0 _N_ _N_ _N_ _N_ _N_ }, [ (Complex Double) ] 1 { _A_ 0 _N_ _N_ _N_ _N_ _N_ } #-}
+__i10 :: Num a => a
+ {-# GHC_PRAGMA _A_ 1 _N_ _N_ _S_ "U(AAAAAAAAAS)" {_A_ 1 _N_ _N_ _N_ _N_ _N_} _N_ _SPECIALISE_ [ Double ] 1 { _A_ 0 _N_ _N_ _N_ _F_ _IF_ARGS_ 0 0 X 2 _!_ D# [] [10.000000000000000##] _N_ }, [ Int ] 1 { _A_ 0 _N_ _N_ _N_ _F_ _IF_ARGS_ 0 0 X 2 _!_ I# [] [10#] _N_ }, [ Integer ] 1 { _A_ 0 _N_ _N_ _N_ _N_ _N_ }, [ (Ratio Integer) ] 1 { _A_ 0 _N_ _N_ _N_ _N_ _N_ }, [ (Complex Double) ] 1 { _A_ 0 _N_ _N_ _N_ _N_ _N_ } #-}
+__i16 :: Num a => a
+ {-# GHC_PRAGMA _A_ 1 _N_ _N_ _S_ "U(AAAAAAAAAS)" {_A_ 1 _N_ _N_ _N_ _N_ _N_} _N_ _SPECIALISE_ [ Double ] 1 { _A_ 0 _N_ _N_ _N_ _F_ _IF_ARGS_ 0 0 X 2 _!_ D# [] [16.000000000000000##] _N_ }, [ Int ] 1 { _A_ 0 _N_ _N_ _N_ _F_ _IF_ARGS_ 0 0 X 2 _!_ I# [] [16#] _N_ }, [ Integer ] 1 { _A_ 0 _N_ _N_ _N_ _N_ _N_ }, [ (Ratio Integer) ] 1 { _A_ 0 _N_ _N_ _N_ _N_ _N_ }, [ (Complex Double) ] 1 { _A_ 0 _N_ _N_ _N_ _N_ _N_ } #-}
+__i2 :: Num a => a
+ {-# GHC_PRAGMA _A_ 1 _N_ _N_ _S_ "U(AAAAAAAAAS)" {_A_ 1 _N_ _N_ _N_ _N_ _N_} _N_ _SPECIALISE_ [ Double ] 1 { _A_ 0 _N_ _N_ _N_ _F_ _IF_ARGS_ 0 0 X 2 _!_ D# [] [2.0000000000000000##] _N_ }, [ Int ] 1 { _A_ 0 _N_ _N_ _N_ _F_ _IF_ARGS_ 0 0 X 2 _!_ I# [] [2#] _N_ }, [ Integer ] 1 { _A_ 0 _N_ _N_ _N_ _N_ _N_ }, [ (Ratio Integer) ] 1 { _A_ 0 _N_ _N_ _N_ _N_ _N_ }, [ (Complex Double) ] 1 { _A_ 0 _N_ _N_ _N_ _N_ _N_ } #-}
+__i8 :: Num a => a
+ {-# GHC_PRAGMA _A_ 1 _N_ _N_ _S_ "U(AAAAAAAAAS)" {_A_ 1 _N_ _N_ _N_ _N_ _N_} _N_ _SPECIALISE_ [ Double ] 1 { _A_ 0 _N_ _N_ _N_ _F_ _IF_ARGS_ 0 0 X 2 _!_ D# [] [8.0000000000000000##] _N_ }, [ Int ] 1 { _A_ 0 _N_ _N_ _N_ _F_ _IF_ARGS_ 0 0 X 2 _!_ I# [] [8#] _N_ }, [ Integer ] 1 { _A_ 0 _N_ _N_ _N_ _N_ _N_ }, [ (Ratio Integer) ] 1 { _A_ 0 _N_ _N_ _N_ _N_ _N_ }, [ (Complex Double) ] 1 { _A_ 0 _N_ _N_ _N_ _N_ _N_ } #-}
+__im1 :: Num a => a
+ {-# GHC_PRAGMA _A_ 1 _N_ _N_ _S_ "U(AAAAAAAAAS)" {_A_ 1 _N_ _N_ _N_ _N_ _N_} _N_ _SPECIALISE_ [ Double ] 1 { _A_ 0 _N_ _N_ _N_ _F_ _IF_ARGS_ 0 0 X 2 _!_ D# [] [-1.0000000000000000##] _N_ }, [ Int ] 1 { _A_ 0 _N_ _N_ _N_ _F_ _IF_ARGS_ 0 0 X 2 _!_ I# [] [-1#] _N_ }, [ Integer ] 1 { _A_ 0 _N_ _N_ _N_ _N_ _N_ }, [ (Ratio Integer) ] 1 { _A_ 0 _N_ _N_ _N_ _N_ _N_ }, [ (Complex Double) ] 1 { _A_ 0 _N_ _N_ _N_ _N_ _N_ } #-}
+__rhalf :: Fractional a => a
+ {-# GHC_PRAGMA _A_ 1 _N_ _N_ _S_ "U(AAAS)" {_A_ 1 _N_ _N_ _N_ _N_ _N_} _N_ _SPECIALISE_ [ Double ] 1 { _A_ 0 _N_ _N_ _N_ _N_ _N_ }, [ (Ratio Integer) ] 1 { _A_ 0 _N_ _N_ _N_ _F_ _IF_ARGS_ 0 0 X 3 _!_ (:%) [Integer] [_SPEC_ _ORIG_ PreludeCore __i1 [ (Integer) ], _SPEC_ _ORIG_ PreludeCore __i2 [ (Integer) ]] _N_ }, [ (Complex Double) ] 1 { _A_ 0 _N_ _N_ _N_ _N_ _N_ } #-}
+_fromRational :: RealFloat a => Ratio Integer -> a
+ {-# GHC_PRAGMA _A_ 2 _N_ _N_ _N_ _N_ _SPECIALISE_ [ Double ] 1 { _A_ 1 _N_ _N_ _S_ "U(U(PPP)U(PPP))" {_A_ 4 _N_ _N_ _N_ _N_ _N_} _N_ _N_ } #-}
+_readList :: ([Char] -> [(a, [Char])]) -> [Char] -> [([a], [Char])]
+ {-# GHC_PRAGMA _A_ 1 _N_ _N_ _N_ _N_ _N_ #-}
+_showList :: (a -> [Char] -> [Char]) -> [a] -> [Char] -> [Char]
+ {-# GHC_PRAGMA _A_ 2 _N_ _N_ _S_ "LS" _N_ _N_ #-}
_showRational :: Int -> Ratio Integer -> [Char]
- {-# GHC_PRAGMA _A_ 2 _U_ 21 _N_ _S_ "LU(U(PPP)L)" {_A_ 5 _U_ 22222 _N_ _N_ _N_ _N_} _N_ _N_ #-}
-_truncate :: (RealFrac a, Integral b) => a -> b
- {-# GHC_PRAGMA _A_ 2 _U_ 122 _N_ _S_ "U(AASAAAA)L" {_A_ 2 _U_ 122 _N_ _N_ _N_ _N_} _N_ _SPECIALISE_ [ Double, Int ] 2 { _A_ 0 _U_ 2 _N_ _N_ _N_ _N_ } #-}
-fromRationalX :: RealFloat a => Ratio Integer -> a
- {-# GHC_PRAGMA _A_ 0 _U_ 22 _N_ _N_ _N_ _N_ #-}
-i0__ :: Num a => a
- {-# GHC_PRAGMA _A_ 1 _U_ 1 _N_ _S_ "U(AAAAAAAASA)" {_A_ 1 _U_ 1 _N_ _N_ _N_ _N_} _F_ _IF_ARGS_ 1 1 C 5 _/\_ u0 -> \ (u1 :: {{Num u0}}) -> let {(u2 :: Integer) = _#_ int2Integer# [] [0#]} in case u1 of { _ALG_ _TUP_10 (u3 :: {{Eq u0}}) (u4 :: {{Text u0}}) (u5 :: u0 -> u0 -> u0) (u6 :: u0 -> u0 -> u0) (u7 :: u0 -> u0 -> u0) (u8 :: u0 -> u0) (u9 :: u0 -> u0) (ua :: u0 -> u0) (ub :: Integer -> u0) (uc :: Int -> u0) -> _APP_ ub [ u2 ]; _NO_DEFLT_ } _SPECIALISE_ [ Int ] 1 { _A_ 0 _N_ _N_ _N_ _N_ _N_ }, [ Integer ] 1 { _A_ 0 _N_ _N_ _N_ _F_ _IF_ARGS_ 0 0 X 1 _#_ int2Integer# [] [0#] _N_ } #-}
-i1__ :: Num a => a
- {-# GHC_PRAGMA _A_ 1 _U_ 1 _N_ _S_ "U(AAAAAAAASA)" {_A_ 1 _U_ 1 _N_ _N_ _N_ _N_} _F_ _IF_ARGS_ 1 1 C 5 _/\_ u0 -> \ (u1 :: {{Num u0}}) -> let {(u2 :: Integer) = _#_ int2Integer# [] [1#]} in case u1 of { _ALG_ _TUP_10 (u3 :: {{Eq u0}}) (u4 :: {{Text u0}}) (u5 :: u0 -> u0 -> u0) (u6 :: u0 -> u0 -> u0) (u7 :: u0 -> u0 -> u0) (u8 :: u0 -> u0) (u9 :: u0 -> u0) (ua :: u0 -> u0) (ub :: Integer -> u0) (uc :: Int -> u0) -> _APP_ ub [ u2 ]; _NO_DEFLT_ } _SPECIALISE_ [ Int ] 1 { _A_ 0 _N_ _N_ _N_ _N_ _N_ }, [ Integer ] 1 { _A_ 0 _N_ _N_ _N_ _F_ _IF_ARGS_ 0 0 X 1 _#_ int2Integer# [] [1#] _N_ } #-}
-i2__ :: Num a => a
- {-# GHC_PRAGMA _A_ 1 _U_ 1 _N_ _S_ "U(AAAAAAAASA)" {_A_ 1 _U_ 1 _N_ _N_ _N_ _N_} _F_ _IF_ARGS_ 1 1 C 5 _/\_ u0 -> \ (u1 :: {{Num u0}}) -> let {(u2 :: Integer) = _#_ int2Integer# [] [2#]} in case u1 of { _ALG_ _TUP_10 (u3 :: {{Eq u0}}) (u4 :: {{Text u0}}) (u5 :: u0 -> u0 -> u0) (u6 :: u0 -> u0 -> u0) (u7 :: u0 -> u0 -> u0) (u8 :: u0 -> u0) (u9 :: u0 -> u0) (ua :: u0 -> u0) (ub :: Integer -> u0) (uc :: Int -> u0) -> _APP_ ub [ u2 ]; _NO_DEFLT_ } _N_ #-}
-iminus1__ :: Num a => a
- {-# GHC_PRAGMA _A_ 1 _U_ 1 _N_ _S_ "U(AAAAAAAASA)" {_A_ 1 _U_ 1 _N_ _N_ _N_ _N_} _N_ _N_ #-}
+ {-# GHC_PRAGMA _A_ 2 _N_ _N_ _S_ "LU(U(PPP)L)" {_A_ 5 _N_ _N_ _N_ _N_ _N_} _N_ _N_ #-}
int2Integer :: Int -> Integer
- {-# GHC_PRAGMA _A_ 1 _U_ 1 _N_ _S_ "U(P)" {_A_ 1 _U_ 2 _N_ _N_ _F_ _IF_ARGS_ 0 1 X 1 \ (u0 :: Int#) -> _#_ int2Integer# [] [u0] _N_} _F_ _IF_ARGS_ 0 1 C 2 \ (u0 :: Int) -> case u0 of { _ALG_ I# (u1 :: Int#) -> _#_ int2Integer# [] [u1]; _NO_DEFLT_ } _N_ #-}
-r0__ :: Fractional a => a
- {-# GHC_PRAGMA _A_ 1 _U_ 1 _N_ _S_ "U(AAAS)" {_A_ 1 _U_ 1 _N_ _N_ _N_ _N_} _N_ _SPECIALISE_ [ Double ] 1 { _A_ 0 _N_ _N_ _N_ _N_ _N_ }, [ (Ratio Integer) ] 1 { _A_ 0 _N_ _N_ _N_ _N_ _N_ } #-}
-r1__ :: Fractional a => a
- {-# GHC_PRAGMA _A_ 1 _U_ 1 _N_ _S_ "U(AAAS)" {_A_ 1 _U_ 1 _N_ _N_ _N_ _N_} _N_ _N_ #-}
-rhalf__ :: Fractional a => a
- {-# GHC_PRAGMA _A_ 1 _U_ 1 _N_ _S_ "U(AAAS)" {_A_ 1 _U_ 1 _N_ _N_ _N_ _N_} _N_ _SPECIALISE_ [ Double ] 1 { _A_ 0 _N_ _N_ _N_ _N_ _N_ }, [ (Ratio Integer) ] 1 { _A_ 0 _N_ _N_ _N_ _N_ _N_ } #-}
+ {-# GHC_PRAGMA _A_ 1 _N_ _N_ _S_ "U(P)" {_A_ 1 _N_ _N_ _N_ _F_ _IF_ARGS_ 0 1 X 1 \ (u0 :: Int#) -> _#_ int2Integer# [] [u0] _N_} _F_ _IF_ARGS_ 0 1 C 2 \ (u0 :: Int) -> case u0 of { _ALG_ I# (u1 :: Int#) -> _#_ int2Integer# [] [u1]; _NO_DEFLT_ } _N_ #-}
-{-# GHC_PRAGMA INTERFACE VERSION 5 #-}
+{-# GHC_PRAGMA INTERFACE VERSION 6 #-}
interface PreludeCore where
import PreludeBuiltin(Char(..), Int(..), Integer(..), List(..), Tuple2)
import PreludeRatio(Ratio(..))
-_ceiling :: (RealFrac a, Integral b) => a -> b
- {-# GHC_PRAGMA _A_ 2 _U_ 122 _N_ _S_ "U(U(AU(U(AAAASAAA)AAAA)A)LSAAAA)L" {_A_ 4 _U_ 11122 _N_ _N_ _N_ _N_} _N_ _SPECIALISE_ [ Double, Int ] 2 { _A_ 0 _U_ 2 _N_ _N_ _N_ _N_ } #-}
-_floor :: (RealFrac a, Integral b) => a -> b
- {-# GHC_PRAGMA _A_ 2 _U_ 122 _N_ _S_ "U(U(AU(U(ASAAAAAA)AAAA)A)LSAAAA)L" {_A_ 4 _U_ 11122 _N_ _N_ _N_ _N_} _N_ _SPECIALISE_ [ Double, Int ] 2 { _A_ 0 _U_ 2 _N_ _N_ _N_ _N_ } #-}
-_integer_0 :: Integer
- {-# GHC_PRAGMA _A_ 0 _N_ _N_ _N_ _F_ _IF_ARGS_ 0 0 X 1 _#_ int2Integer# [] [0#] _N_ #-}
-_integer_1 :: Integer
- {-# GHC_PRAGMA _A_ 0 _N_ _N_ _N_ _F_ _IF_ARGS_ 0 0 X 1 _#_ int2Integer# [] [1#] _N_ #-}
-_integer_m1 :: Integer
- {-# GHC_PRAGMA _A_ 0 _N_ _N_ _N_ _N_ _N_ #-}
-_properFraction :: (RealFloat b, Integral a) => b -> (a, b)
- {-# GHC_PRAGMA _A_ 2 _U_ 112 _N_ _S_ "U(ALLAASLAAA)L" {_A_ 5 _U_ 111112 _N_ _N_ _N_ _N_} _N_ _SPECIALISE_ [ Int, Double ] 2 { _A_ 1 _U_ 1 _N_ _S_ "U(P)" {_A_ 1 _U_ 2 _N_ _N_ _N_ _N_} _N_ _N_ } #-}
-_readList :: Text a => [Char] -> [([a], [Char])]
+__i0 :: Num a => a
+ {-# GHC_PRAGMA _A_ 1 _U_ 1 _N_ _S_ "U(AAAAAAAAAS)" {_A_ 1 _U_ 1 _N_ _N_ _N_ _N_} _N_ _SPECIALISE_ [ Double ] 1 { _A_ 0 _N_ _N_ _N_ _F_ _IF_ARGS_ 0 0 X 2 _!_ D# [] [0.0000000000000000##] _N_ }, [ Int ] 1 { _A_ 0 _N_ _N_ _N_ _F_ _IF_ARGS_ 0 0 X 2 _!_ I# [] [0#] _N_ }, [ Integer ] 1 { _A_ 0 _N_ _N_ _N_ _N_ _N_ }, [ (Ratio Integer) ] 1 { _A_ 0 _N_ _N_ _N_ _N_ _N_ }, [ (Complex Double) ] 1 { _A_ 0 _N_ _N_ _N_ _N_ _N_ } #-}
+__i1 :: Num a => a
+ {-# GHC_PRAGMA _A_ 1 _U_ 1 _N_ _S_ "U(AAAAAAAAAS)" {_A_ 1 _U_ 1 _N_ _N_ _N_ _N_} _N_ _SPECIALISE_ [ Double ] 1 { _A_ 0 _N_ _N_ _N_ _F_ _IF_ARGS_ 0 0 X 2 _!_ D# [] [1.0000000000000000##] _N_ }, [ Int ] 1 { _A_ 0 _N_ _N_ _N_ _F_ _IF_ARGS_ 0 0 X 2 _!_ I# [] [1#] _N_ }, [ Integer ] 1 { _A_ 0 _N_ _N_ _N_ _N_ _N_ }, [ (Ratio Integer) ] 1 { _A_ 0 _N_ _N_ _N_ _N_ _N_ }, [ (Complex Double) ] 1 { _A_ 0 _N_ _N_ _N_ _N_ _N_ } #-}
+__i10 :: Num a => a
+ {-# GHC_PRAGMA _A_ 1 _U_ 1 _N_ _S_ "U(AAAAAAAAAS)" {_A_ 1 _U_ 1 _N_ _N_ _N_ _N_} _N_ _SPECIALISE_ [ Double ] 1 { _A_ 0 _N_ _N_ _N_ _F_ _IF_ARGS_ 0 0 X 2 _!_ D# [] [10.000000000000000##] _N_ }, [ Int ] 1 { _A_ 0 _N_ _N_ _N_ _F_ _IF_ARGS_ 0 0 X 2 _!_ I# [] [10#] _N_ }, [ Integer ] 1 { _A_ 0 _N_ _N_ _N_ _N_ _N_ }, [ (Ratio Integer) ] 1 { _A_ 0 _N_ _N_ _N_ _N_ _N_ }, [ (Complex Double) ] 1 { _A_ 0 _N_ _N_ _N_ _N_ _N_ } #-}
+__i16 :: Num a => a
+ {-# GHC_PRAGMA _A_ 1 _U_ 1 _N_ _S_ "U(AAAAAAAAAS)" {_A_ 1 _U_ 1 _N_ _N_ _N_ _N_} _N_ _SPECIALISE_ [ Double ] 1 { _A_ 0 _N_ _N_ _N_ _F_ _IF_ARGS_ 0 0 X 2 _!_ D# [] [16.000000000000000##] _N_ }, [ Int ] 1 { _A_ 0 _N_ _N_ _N_ _F_ _IF_ARGS_ 0 0 X 2 _!_ I# [] [16#] _N_ }, [ Integer ] 1 { _A_ 0 _N_ _N_ _N_ _N_ _N_ }, [ (Ratio Integer) ] 1 { _A_ 0 _N_ _N_ _N_ _N_ _N_ }, [ (Complex Double) ] 1 { _A_ 0 _N_ _N_ _N_ _N_ _N_ } #-}
+__i2 :: Num a => a
+ {-# GHC_PRAGMA _A_ 1 _U_ 1 _N_ _S_ "U(AAAAAAAAAS)" {_A_ 1 _U_ 1 _N_ _N_ _N_ _N_} _N_ _SPECIALISE_ [ Double ] 1 { _A_ 0 _N_ _N_ _N_ _F_ _IF_ARGS_ 0 0 X 2 _!_ D# [] [2.0000000000000000##] _N_ }, [ Int ] 1 { _A_ 0 _N_ _N_ _N_ _F_ _IF_ARGS_ 0 0 X 2 _!_ I# [] [2#] _N_ }, [ Integer ] 1 { _A_ 0 _N_ _N_ _N_ _N_ _N_ }, [ (Ratio Integer) ] 1 { _A_ 0 _N_ _N_ _N_ _N_ _N_ }, [ (Complex Double) ] 1 { _A_ 0 _N_ _N_ _N_ _N_ _N_ } #-}
+__i8 :: Num a => a
+ {-# GHC_PRAGMA _A_ 1 _U_ 1 _N_ _S_ "U(AAAAAAAAAS)" {_A_ 1 _U_ 1 _N_ _N_ _N_ _N_} _N_ _SPECIALISE_ [ Double ] 1 { _A_ 0 _N_ _N_ _N_ _F_ _IF_ARGS_ 0 0 X 2 _!_ D# [] [8.0000000000000000##] _N_ }, [ Int ] 1 { _A_ 0 _N_ _N_ _N_ _F_ _IF_ARGS_ 0 0 X 2 _!_ I# [] [8#] _N_ }, [ Integer ] 1 { _A_ 0 _N_ _N_ _N_ _N_ _N_ }, [ (Ratio Integer) ] 1 { _A_ 0 _N_ _N_ _N_ _N_ _N_ }, [ (Complex Double) ] 1 { _A_ 0 _N_ _N_ _N_ _N_ _N_ } #-}
+__im1 :: Num a => a
+ {-# GHC_PRAGMA _A_ 1 _U_ 1 _N_ _S_ "U(AAAAAAAAAS)" {_A_ 1 _U_ 1 _N_ _N_ _N_ _N_} _N_ _SPECIALISE_ [ Double ] 1 { _A_ 0 _N_ _N_ _N_ _F_ _IF_ARGS_ 0 0 X 2 _!_ D# [] [-1.0000000000000000##] _N_ }, [ Int ] 1 { _A_ 0 _N_ _N_ _N_ _F_ _IF_ARGS_ 0 0 X 2 _!_ I# [] [-1#] _N_ }, [ Integer ] 1 { _A_ 0 _N_ _N_ _N_ _N_ _N_ }, [ (Ratio Integer) ] 1 { _A_ 0 _N_ _N_ _N_ _N_ _N_ }, [ (Complex Double) ] 1 { _A_ 0 _N_ _N_ _N_ _N_ _N_ } #-}
+__rhalf :: Fractional a => a
+ {-# GHC_PRAGMA _A_ 1 _U_ 1 _N_ _S_ "U(AAAS)" {_A_ 1 _U_ 1 _N_ _N_ _N_ _N_} _N_ _SPECIALISE_ [ Double ] 1 { _A_ 0 _N_ _N_ _N_ _N_ _N_ }, [ (Ratio Integer) ] 1 { _A_ 0 _N_ _N_ _N_ _F_ _IF_ARGS_ 0 0 X 3 _!_ (:%) [Integer] [_SPEC_ _ORIG_ PreludeCore __i1 [ (Integer) ], _SPEC_ _ORIG_ PreludeCore __i2 [ (Integer) ]] _N_ }, [ (Complex Double) ] 1 { _A_ 0 _N_ _N_ _N_ _N_ _N_ } #-}
+_fromRational :: RealFloat a => Ratio Integer -> a
+ {-# GHC_PRAGMA _A_ 2 _U_ 22 _N_ _N_ _N_ _SPECIALISE_ [ Double ] 1 { _A_ 1 _U_ 1 _N_ _S_ "U(U(PPP)U(PPP))" {_A_ 4 _U_ 2221 _N_ _N_ _N_ _N_} _N_ _N_ } #-}
+_readList :: ([Char] -> [(a, [Char])]) -> [Char] -> [([a], [Char])]
{-# GHC_PRAGMA _A_ 1 _U_ 22 _N_ _N_ _N_ _N_ #-}
-_round :: (RealFrac a, Integral b) => a -> b
- {-# GHC_PRAGMA _A_ 2 _U_ 122 _N_ _S_ "U(U(AU(U(ALAAAAAS)AAAA)A)LSAAAA)L" {_A_ 5 _U_ 112122 _N_ _N_ _N_ _N_} _N_ _SPECIALISE_ [ Double, Int ] 2 { _A_ 0 _U_ 2 _N_ _N_ _N_ _N_ }, [ (Ratio Integer), Integer ] 2 { _A_ 1 _U_ 1 _N_ _S_ "U(LL)" {_A_ 2 _U_ 22 _N_ _N_ _N_ _N_} _N_ _N_ } #-}
-_showList :: Text a => [a] -> [Char] -> [Char]
- {-# GHC_PRAGMA _A_ 1 _U_ 212 _N_ _N_ _N_ _N_ #-}
+_showList :: (a -> [Char] -> [Char]) -> [a] -> [Char] -> [Char]
+ {-# GHC_PRAGMA _A_ 2 _U_ 212 _N_ _S_ "LS" _N_ _N_ #-}
_showRational :: Int -> Ratio Integer -> [Char]
{-# GHC_PRAGMA _A_ 2 _U_ 21 _N_ _S_ "LU(U(PPP)L)" {_A_ 5 _U_ 22222 _N_ _N_ _N_ _N_} _N_ _N_ #-}
-_truncate :: (RealFrac a, Integral b) => a -> b
- {-# GHC_PRAGMA _A_ 2 _U_ 122 _N_ _S_ "U(AASAAAA)L" {_A_ 2 _U_ 122 _N_ _N_ _N_ _N_} _N_ _SPECIALISE_ [ Double, Int ] 2 { _A_ 0 _U_ 2 _N_ _N_ _N_ _N_ } #-}
-fromRationalX :: RealFloat a => Ratio Integer -> a
- {-# GHC_PRAGMA _A_ 0 _U_ 22 _N_ _N_ _N_ _N_ #-}
-i0__ :: Num a => a
- {-# GHC_PRAGMA _A_ 1 _U_ 1 _N_ _S_ "U(AAAAAAAASA)" {_A_ 1 _U_ 1 _N_ _N_ _N_ _N_} _F_ _IF_ARGS_ 1 1 C 5 _/\_ u0 -> \ (u1 :: {{Num u0}}) -> let {(u2 :: Integer) = _#_ int2Integer# [] [0#]} in case u1 of { _ALG_ _TUP_10 (u3 :: {{Eq u0}}) (u4 :: {{Text u0}}) (u5 :: u0 -> u0 -> u0) (u6 :: u0 -> u0 -> u0) (u7 :: u0 -> u0 -> u0) (u8 :: u0 -> u0) (u9 :: u0 -> u0) (ua :: u0 -> u0) (ub :: Integer -> u0) (uc :: Int -> u0) -> _APP_ ub [ u2 ]; _NO_DEFLT_ } _SPECIALISE_ [ Int ] 1 { _A_ 0 _N_ _N_ _N_ _N_ _N_ }, [ Integer ] 1 { _A_ 0 _N_ _N_ _N_ _F_ _IF_ARGS_ 0 0 X 1 _#_ int2Integer# [] [0#] _N_ } #-}
-i1__ :: Num a => a
- {-# GHC_PRAGMA _A_ 1 _U_ 1 _N_ _S_ "U(AAAAAAAASA)" {_A_ 1 _U_ 1 _N_ _N_ _N_ _N_} _F_ _IF_ARGS_ 1 1 C 5 _/\_ u0 -> \ (u1 :: {{Num u0}}) -> let {(u2 :: Integer) = _#_ int2Integer# [] [1#]} in case u1 of { _ALG_ _TUP_10 (u3 :: {{Eq u0}}) (u4 :: {{Text u0}}) (u5 :: u0 -> u0 -> u0) (u6 :: u0 -> u0 -> u0) (u7 :: u0 -> u0 -> u0) (u8 :: u0 -> u0) (u9 :: u0 -> u0) (ua :: u0 -> u0) (ub :: Integer -> u0) (uc :: Int -> u0) -> _APP_ ub [ u2 ]; _NO_DEFLT_ } _SPECIALISE_ [ Int ] 1 { _A_ 0 _N_ _N_ _N_ _N_ _N_ }, [ Integer ] 1 { _A_ 0 _N_ _N_ _N_ _F_ _IF_ARGS_ 0 0 X 1 _#_ int2Integer# [] [1#] _N_ } #-}
-i2__ :: Num a => a
- {-# GHC_PRAGMA _A_ 1 _U_ 1 _N_ _S_ "U(AAAAAAAASA)" {_A_ 1 _U_ 1 _N_ _N_ _N_ _N_} _F_ _IF_ARGS_ 1 1 C 5 _/\_ u0 -> \ (u1 :: {{Num u0}}) -> let {(u2 :: Integer) = _#_ int2Integer# [] [2#]} in case u1 of { _ALG_ _TUP_10 (u3 :: {{Eq u0}}) (u4 :: {{Text u0}}) (u5 :: u0 -> u0 -> u0) (u6 :: u0 -> u0 -> u0) (u7 :: u0 -> u0 -> u0) (u8 :: u0 -> u0) (u9 :: u0 -> u0) (ua :: u0 -> u0) (ub :: Integer -> u0) (uc :: Int -> u0) -> _APP_ ub [ u2 ]; _NO_DEFLT_ } _N_ #-}
-iminus1__ :: Num a => a
- {-# GHC_PRAGMA _A_ 1 _U_ 1 _N_ _S_ "U(AAAAAAAASA)" {_A_ 1 _U_ 1 _N_ _N_ _N_ _N_} _N_ _N_ #-}
-int2Integer :: Int -> Integer
- {-# GHC_PRAGMA _A_ 1 _U_ 1 _N_ _S_ "U(P)" {_A_ 1 _U_ 2 _N_ _N_ _F_ _IF_ARGS_ 0 1 X 1 \ (u0 :: Int#) -> _#_ int2Integer# [] [u0] _N_} _F_ _IF_ARGS_ 0 1 C 2 \ (u0 :: Int) -> case u0 of { _ALG_ I# (u1 :: Int#) -> _#_ int2Integer# [] [u1]; _NO_DEFLT_ } _N_ #-}
-r0__ :: Fractional a => a
- {-# GHC_PRAGMA _A_ 1 _U_ 1 _N_ _S_ "U(AAAS)" {_A_ 1 _U_ 1 _N_ _N_ _N_ _N_} _N_ _SPECIALISE_ [ Double ] 1 { _A_ 0 _N_ _N_ _N_ _N_ _N_ }, [ (Ratio Integer) ] 1 { _A_ 0 _N_ _N_ _N_ _N_ _N_ } #-}
-r1__ :: Fractional a => a
- {-# GHC_PRAGMA _A_ 1 _U_ 1 _N_ _S_ "U(AAAS)" {_A_ 1 _U_ 1 _N_ _N_ _N_ _N_} _N_ _N_ #-}
-rhalf__ :: Fractional a => a
- {-# GHC_PRAGMA _A_ 1 _U_ 1 _N_ _S_ "U(AAAS)" {_A_ 1 _U_ 1 _N_ _N_ _N_ _N_} _N_ _SPECIALISE_ [ Double ] 1 { _A_ 0 _N_ _N_ _N_ _N_ _N_ }, [ (Ratio Integer) ] 1 { _A_ 0 _N_ _N_ _N_ _N_ _N_ } #-}
-{-# GHC_PRAGMA INTERFACE VERSION 5 #-}
+{-# GHC_PRAGMA INTERFACE VERSION 6 #-}
interface PreludeCore where
import PreludeBuiltin(Char(..), Int(..), Integer(..), List(..), Tuple2)
import PreludeRatio(Ratio(..))
-_ceiling :: (RealFrac a, Integral b) => a -> b
- {-# GHC_PRAGMA _A_ 2 _U_ 122 _N_ _S_ "U(U(AU(U(AAAASAAA)AAAA)A)LSAAAA)L" {_A_ 4 _U_ 11122 _N_ _N_ _N_ _N_} _N_ _SPECIALISE_ [ Double, Int ] 2 { _A_ 0 _U_ 2 _N_ _N_ _N_ _N_ } #-}
-_floor :: (RealFrac a, Integral b) => a -> b
- {-# GHC_PRAGMA _A_ 2 _U_ 122 _N_ _S_ "U(U(AU(U(ASAAAAAA)AAAA)A)LSAAAA)L" {_A_ 4 _U_ 11122 _N_ _N_ _N_ _N_} _N_ _SPECIALISE_ [ Double, Int ] 2 { _A_ 0 _U_ 2 _N_ _N_ _N_ _N_ } #-}
-_integer_0 :: Integer
- {-# GHC_PRAGMA _A_ 0 _N_ _N_ _N_ _F_ _IF_ARGS_ 0 0 X 1 _#_ int2Integer# [] [0#] _N_ #-}
-_integer_1 :: Integer
- {-# GHC_PRAGMA _A_ 0 _N_ _N_ _N_ _F_ _IF_ARGS_ 0 0 X 1 _#_ int2Integer# [] [1#] _N_ #-}
-_integer_m1 :: Integer
- {-# GHC_PRAGMA _A_ 0 _N_ _N_ _N_ _N_ _N_ #-}
-_properFraction :: (RealFloat b, Integral a) => b -> (a, b)
- {-# GHC_PRAGMA _A_ 2 _U_ 112 _N_ _S_ "U(ALLAASLAAA)L" {_A_ 5 _U_ 111112 _N_ _N_ _N_ _N_} _N_ _SPECIALISE_ [ Int, Double ] 2 { _A_ 1 _U_ 1 _N_ _S_ "U(P)" {_A_ 1 _U_ 2 _N_ _N_ _N_ _N_} _N_ _N_ } #-}
-_readList :: Text a => [Char] -> [([a], [Char])]
+__i0 :: Num a => a
+ {-# GHC_PRAGMA _A_ 1 _U_ 1 _N_ _S_ "U(AAAAAAAAAS)" {_A_ 1 _U_ 1 _N_ _N_ _N_ _N_} _N_ _SPECIALISE_ [ Double ] 1 { _A_ 0 _N_ _N_ _N_ _F_ _IF_ARGS_ 0 0 X 2 _!_ D# [] [0.0000000000000000##] _N_ }, [ Int ] 1 { _A_ 0 _N_ _N_ _N_ _F_ _IF_ARGS_ 0 0 X 2 _!_ I# [] [0#] _N_ }, [ Integer ] 1 { _A_ 0 _N_ _N_ _N_ _N_ _N_ }, [ (Ratio Integer) ] 1 { _A_ 0 _N_ _N_ _N_ _N_ _N_ }, [ (Complex Double) ] 1 { _A_ 0 _N_ _N_ _N_ _N_ _N_ } #-}
+__i1 :: Num a => a
+ {-# GHC_PRAGMA _A_ 1 _U_ 1 _N_ _S_ "U(AAAAAAAAAS)" {_A_ 1 _U_ 1 _N_ _N_ _N_ _N_} _N_ _SPECIALISE_ [ Double ] 1 { _A_ 0 _N_ _N_ _N_ _F_ _IF_ARGS_ 0 0 X 2 _!_ D# [] [1.0000000000000000##] _N_ }, [ Int ] 1 { _A_ 0 _N_ _N_ _N_ _F_ _IF_ARGS_ 0 0 X 2 _!_ I# [] [1#] _N_ }, [ Integer ] 1 { _A_ 0 _N_ _N_ _N_ _N_ _N_ }, [ (Ratio Integer) ] 1 { _A_ 0 _N_ _N_ _N_ _N_ _N_ }, [ (Complex Double) ] 1 { _A_ 0 _N_ _N_ _N_ _N_ _N_ } #-}
+__i10 :: Num a => a
+ {-# GHC_PRAGMA _A_ 1 _U_ 1 _N_ _S_ "U(AAAAAAAAAS)" {_A_ 1 _U_ 1 _N_ _N_ _N_ _N_} _N_ _SPECIALISE_ [ Double ] 1 { _A_ 0 _N_ _N_ _N_ _F_ _IF_ARGS_ 0 0 X 2 _!_ D# [] [10.000000000000000##] _N_ }, [ Int ] 1 { _A_ 0 _N_ _N_ _N_ _F_ _IF_ARGS_ 0 0 X 2 _!_ I# [] [10#] _N_ }, [ Integer ] 1 { _A_ 0 _N_ _N_ _N_ _N_ _N_ }, [ (Ratio Integer) ] 1 { _A_ 0 _N_ _N_ _N_ _N_ _N_ }, [ (Complex Double) ] 1 { _A_ 0 _N_ _N_ _N_ _N_ _N_ } #-}
+__i16 :: Num a => a
+ {-# GHC_PRAGMA _A_ 1 _U_ 1 _N_ _S_ "U(AAAAAAAAAS)" {_A_ 1 _U_ 1 _N_ _N_ _N_ _N_} _N_ _SPECIALISE_ [ Double ] 1 { _A_ 0 _N_ _N_ _N_ _F_ _IF_ARGS_ 0 0 X 2 _!_ D# [] [16.000000000000000##] _N_ }, [ Int ] 1 { _A_ 0 _N_ _N_ _N_ _F_ _IF_ARGS_ 0 0 X 2 _!_ I# [] [16#] _N_ }, [ Integer ] 1 { _A_ 0 _N_ _N_ _N_ _N_ _N_ }, [ (Ratio Integer) ] 1 { _A_ 0 _N_ _N_ _N_ _N_ _N_ }, [ (Complex Double) ] 1 { _A_ 0 _N_ _N_ _N_ _N_ _N_ } #-}
+__i2 :: Num a => a
+ {-# GHC_PRAGMA _A_ 1 _U_ 1 _N_ _S_ "U(AAAAAAAAAS)" {_A_ 1 _U_ 1 _N_ _N_ _N_ _N_} _N_ _SPECIALISE_ [ Double ] 1 { _A_ 0 _N_ _N_ _N_ _F_ _IF_ARGS_ 0 0 X 2 _!_ D# [] [2.0000000000000000##] _N_ }, [ Int ] 1 { _A_ 0 _N_ _N_ _N_ _F_ _IF_ARGS_ 0 0 X 2 _!_ I# [] [2#] _N_ }, [ Integer ] 1 { _A_ 0 _N_ _N_ _N_ _N_ _N_ }, [ (Ratio Integer) ] 1 { _A_ 0 _N_ _N_ _N_ _N_ _N_ }, [ (Complex Double) ] 1 { _A_ 0 _N_ _N_ _N_ _N_ _N_ } #-}
+__i8 :: Num a => a
+ {-# GHC_PRAGMA _A_ 1 _U_ 1 _N_ _S_ "U(AAAAAAAAAS)" {_A_ 1 _U_ 1 _N_ _N_ _N_ _N_} _N_ _SPECIALISE_ [ Double ] 1 { _A_ 0 _N_ _N_ _N_ _F_ _IF_ARGS_ 0 0 X 2 _!_ D# [] [8.0000000000000000##] _N_ }, [ Int ] 1 { _A_ 0 _N_ _N_ _N_ _F_ _IF_ARGS_ 0 0 X 2 _!_ I# [] [8#] _N_ }, [ Integer ] 1 { _A_ 0 _N_ _N_ _N_ _N_ _N_ }, [ (Ratio Integer) ] 1 { _A_ 0 _N_ _N_ _N_ _N_ _N_ }, [ (Complex Double) ] 1 { _A_ 0 _N_ _N_ _N_ _N_ _N_ } #-}
+__im1 :: Num a => a
+ {-# GHC_PRAGMA _A_ 1 _U_ 1 _N_ _S_ "U(AAAAAAAAAS)" {_A_ 1 _U_ 1 _N_ _N_ _N_ _N_} _N_ _SPECIALISE_ [ Double ] 1 { _A_ 0 _N_ _N_ _N_ _F_ _IF_ARGS_ 0 0 X 2 _!_ D# [] [-1.0000000000000000##] _N_ }, [ Int ] 1 { _A_ 0 _N_ _N_ _N_ _F_ _IF_ARGS_ 0 0 X 2 _!_ I# [] [-1#] _N_ }, [ Integer ] 1 { _A_ 0 _N_ _N_ _N_ _N_ _N_ }, [ (Ratio Integer) ] 1 { _A_ 0 _N_ _N_ _N_ _N_ _N_ }, [ (Complex Double) ] 1 { _A_ 0 _N_ _N_ _N_ _N_ _N_ } #-}
+__rhalf :: Fractional a => a
+ {-# GHC_PRAGMA _A_ 1 _U_ 1 _N_ _S_ "U(AAAS)" {_A_ 1 _U_ 1 _N_ _N_ _N_ _N_} _N_ _SPECIALISE_ [ Double ] 1 { _A_ 0 _N_ _N_ _N_ _N_ _N_ }, [ (Ratio Integer) ] 1 { _A_ 0 _N_ _N_ _N_ _F_ _IF_ARGS_ 0 0 X 3 _!_ (:%) [Integer] [_SPEC_ _ORIG_ PreludeCore __i1 [ (Integer) ], _SPEC_ _ORIG_ PreludeCore __i2 [ (Integer) ]] _N_ }, [ (Complex Double) ] 1 { _A_ 0 _N_ _N_ _N_ _N_ _N_ } #-}
+_fromRational :: RealFloat a => Ratio Integer -> a
+ {-# GHC_PRAGMA _A_ 2 _U_ 22 _N_ _N_ _N_ _SPECIALISE_ [ Double ] 1 { _A_ 1 _U_ 1 _N_ _S_ "U(U(PPP)U(PPP))" {_A_ 4 _U_ 2221 _N_ _N_ _N_ _N_} _N_ _N_ } #-}
+_readList :: ([Char] -> [(a, [Char])]) -> [Char] -> [([a], [Char])]
{-# GHC_PRAGMA _A_ 1 _U_ 22 _N_ _N_ _N_ _N_ #-}
-_round :: (RealFrac a, Integral b) => a -> b
- {-# GHC_PRAGMA _A_ 2 _U_ 122 _N_ _S_ "U(U(AU(U(ALAAAAAS)AAAA)A)LSAAAA)L" {_A_ 5 _U_ 112122 _N_ _N_ _N_ _N_} _N_ _SPECIALISE_ [ Double, Int ] 2 { _A_ 0 _U_ 2 _N_ _N_ _N_ _N_ }, [ (Ratio Integer), Integer ] 2 { _A_ 1 _U_ 1 _N_ _S_ "U(LL)" {_A_ 2 _U_ 22 _N_ _N_ _N_ _N_} _N_ _N_ } #-}
-_showList :: Text a => [a] -> [Char] -> [Char]
- {-# GHC_PRAGMA _A_ 1 _U_ 212 _N_ _N_ _N_ _N_ #-}
+_showList :: (a -> [Char] -> [Char]) -> [a] -> [Char] -> [Char]
+ {-# GHC_PRAGMA _A_ 2 _U_ 212 _N_ _S_ "LS" _N_ _N_ #-}
_showRational :: Int -> Ratio Integer -> [Char]
{-# GHC_PRAGMA _A_ 2 _U_ 21 _N_ _S_ "LU(U(PPP)L)" {_A_ 5 _U_ 22222 _N_ _N_ _N_ _N_} _N_ _N_ #-}
-_truncate :: (RealFrac a, Integral b) => a -> b
- {-# GHC_PRAGMA _A_ 2 _U_ 122 _N_ _S_ "U(AASAAAA)L" {_A_ 2 _U_ 122 _N_ _N_ _N_ _N_} _N_ _SPECIALISE_ [ Double, Int ] 2 { _A_ 0 _U_ 2 _N_ _N_ _N_ _N_ } #-}
-fromRationalX :: RealFloat a => Ratio Integer -> a
- {-# GHC_PRAGMA _A_ 0 _U_ 22 _N_ _N_ _N_ _N_ #-}
-i0__ :: Num a => a
- {-# GHC_PRAGMA _A_ 1 _U_ 1 _N_ _S_ "U(AAAAAAAASA)" {_A_ 1 _U_ 1 _N_ _N_ _N_ _N_} _F_ _IF_ARGS_ 1 1 C 5 _/\_ u0 -> \ (u1 :: {{Num u0}}) -> let {(u2 :: Integer) = _#_ int2Integer# [] [0#]} in case u1 of { _ALG_ _TUP_10 (u3 :: {{Eq u0}}) (u4 :: {{Text u0}}) (u5 :: u0 -> u0 -> u0) (u6 :: u0 -> u0 -> u0) (u7 :: u0 -> u0 -> u0) (u8 :: u0 -> u0) (u9 :: u0 -> u0) (ua :: u0 -> u0) (ub :: Integer -> u0) (uc :: Int -> u0) -> _APP_ ub [ u2 ]; _NO_DEFLT_ } _SPECIALISE_ [ Int ] 1 { _A_ 0 _N_ _N_ _N_ _N_ _N_ }, [ Integer ] 1 { _A_ 0 _N_ _N_ _N_ _F_ _IF_ARGS_ 0 0 X 1 _#_ int2Integer# [] [0#] _N_ } #-}
-i1__ :: Num a => a
- {-# GHC_PRAGMA _A_ 1 _U_ 1 _N_ _S_ "U(AAAAAAAASA)" {_A_ 1 _U_ 1 _N_ _N_ _N_ _N_} _F_ _IF_ARGS_ 1 1 C 5 _/\_ u0 -> \ (u1 :: {{Num u0}}) -> let {(u2 :: Integer) = _#_ int2Integer# [] [1#]} in case u1 of { _ALG_ _TUP_10 (u3 :: {{Eq u0}}) (u4 :: {{Text u0}}) (u5 :: u0 -> u0 -> u0) (u6 :: u0 -> u0 -> u0) (u7 :: u0 -> u0 -> u0) (u8 :: u0 -> u0) (u9 :: u0 -> u0) (ua :: u0 -> u0) (ub :: Integer -> u0) (uc :: Int -> u0) -> _APP_ ub [ u2 ]; _NO_DEFLT_ } _SPECIALISE_ [ Int ] 1 { _A_ 0 _N_ _N_ _N_ _N_ _N_ }, [ Integer ] 1 { _A_ 0 _N_ _N_ _N_ _F_ _IF_ARGS_ 0 0 X 1 _#_ int2Integer# [] [1#] _N_ } #-}
-i2__ :: Num a => a
- {-# GHC_PRAGMA _A_ 1 _U_ 1 _N_ _S_ "U(AAAAAAAASA)" {_A_ 1 _U_ 1 _N_ _N_ _N_ _N_} _F_ _IF_ARGS_ 1 1 C 5 _/\_ u0 -> \ (u1 :: {{Num u0}}) -> let {(u2 :: Integer) = _#_ int2Integer# [] [2#]} in case u1 of { _ALG_ _TUP_10 (u3 :: {{Eq u0}}) (u4 :: {{Text u0}}) (u5 :: u0 -> u0 -> u0) (u6 :: u0 -> u0 -> u0) (u7 :: u0 -> u0 -> u0) (u8 :: u0 -> u0) (u9 :: u0 -> u0) (ua :: u0 -> u0) (ub :: Integer -> u0) (uc :: Int -> u0) -> _APP_ ub [ u2 ]; _NO_DEFLT_ } _N_ #-}
-iminus1__ :: Num a => a
- {-# GHC_PRAGMA _A_ 1 _U_ 1 _N_ _S_ "U(AAAAAAAASA)" {_A_ 1 _U_ 1 _N_ _N_ _N_ _N_} _N_ _N_ #-}
-int2Integer :: Int -> Integer
- {-# GHC_PRAGMA _A_ 1 _U_ 1 _N_ _S_ "U(P)" {_A_ 1 _U_ 2 _N_ _N_ _F_ _IF_ARGS_ 0 1 X 1 \ (u0 :: Int#) -> _#_ int2Integer# [] [u0] _N_} _F_ _IF_ARGS_ 0 1 C 2 \ (u0 :: Int) -> case u0 of { _ALG_ I# (u1 :: Int#) -> _#_ int2Integer# [] [u1]; _NO_DEFLT_ } _N_ #-}
-r0__ :: Fractional a => a
- {-# GHC_PRAGMA _A_ 1 _U_ 1 _N_ _S_ "U(AAAS)" {_A_ 1 _U_ 1 _N_ _N_ _N_ _N_} _N_ _SPECIALISE_ [ Double ] 1 { _A_ 0 _N_ _N_ _N_ _N_ _N_ }, [ (Ratio Integer) ] 1 { _A_ 0 _N_ _N_ _N_ _N_ _N_ } #-}
-r1__ :: Fractional a => a
- {-# GHC_PRAGMA _A_ 1 _U_ 1 _N_ _S_ "U(AAAS)" {_A_ 1 _U_ 1 _N_ _N_ _N_ _N_} _N_ _N_ #-}
-rhalf__ :: Fractional a => a
- {-# GHC_PRAGMA _A_ 1 _U_ 1 _N_ _S_ "U(AAAS)" {_A_ 1 _U_ 1 _N_ _N_ _N_ _N_} _N_ _SPECIALISE_ [ Double ] 1 { _A_ 0 _N_ _N_ _N_ _N_ _N_ }, [ (Ratio Integer) ] 1 { _A_ 0 _N_ _N_ _N_ _N_ _N_ } #-}
-- NOTE: no foldr/build's are done on the module that foldr is defined in.
{-# MAGIC_UNFOLDING foldr foldr #-}
+{-# GENERATE_SPECS foldr a b #-}
foldr :: (a -> b -> b) -> b -> [a] -> b
foldr f z [] = z
foldr f z (x:xs) = f x (foldr f z xs)
{-# MAGIC_UNFOLDING foldl foldl #-}
---{-# GENERATE_SPECS foldl a b #-}
+{-# GENERATE_SPECS foldl a b #-}
foldl :: (a -> b -> a) -> a -> [b] -> a
foldl f z [] = z
foldl f z (x:xs) = foldl f (f z x) xs
+-- HACK: Magic unfoldings not implemented for unboxed lists
+-- Need to define a _build to avoid undefined symbol
+
+{-# GENERATE_SPECS _build a #-}
+_build :: ((a -> [a] -> [a]) -> [a] -> [a]) -> [a]
+_build g = g (:) []
+
+
-{-# GHC_PRAGMA INTERFACE VERSION 5 #-}
+{-# GHC_PRAGMA INTERFACE VERSION 6 #-}
interface PreludeArray where
-import PreludeBuiltin(List(..), Tuple2)
+import PreludeBuiltin(Double(..), Int(..), List(..), Tuple2)
import PreludeCore(Eq(..), Ix(..), Ord(..), Text(..))
data Array a b {-# GHC_PRAGMA _Array (a, a) (Array# b) #-}
data Assoc a b {-# GHC_PRAGMA (:=) a b #-}
{-# GHC_PRAGMA _M_ PreludeArray {-dfun-} _A_ 3 _U_ 222 _N_ _N_ _N_ _N_ #-}
instance (Ord a, Ord b) => Ord (Assoc a b)
{-# GHC_PRAGMA _M_ PreludeArray {-dfun-} _A_ 3 _U_ 112 _N_ _N_ _N_ _N_ #-}
+instance Text (Array (Int, Int) Double)
+ {-# GHC_PRAGMA _M_ PreludeArray {-dfun-} _A_ 0 _N_ _N_ _N_ _F_ _IF_ARGS_ 0 0 X 5 _!_ _TUP_4 [(Int -> [Char] -> [(Array (Int, Int) Double, [Char])]), (Int -> Array (Int, Int) Double -> [Char] -> [Char]), ([Char] -> [([Array (Int, Int) Double], [Char])]), ([Array (Int, Int) Double] -> [Char] -> [Char])] [_CONSTM_ Text readsPrec (Array (Int, Int) Double), _CONSTM_ Text showsPrec (Array (Int, Int) Double), _CONSTM_ Text readList (Array (Int, Int) Double), _CONSTM_ Text showList (Array (Int, Int) Double)] _N_
+ readsPrec = { _A_ 1 _U_ 12 _N_ _S_ "U(P)" {_A_ 1 _U_ 22 _N_ _N_ _N_ _N_} _N_ _N_ },
+ showsPrec = { _A_ 2 _U_ 122 _N_ _N_ _N_ _N_ },
+ readList = { _A_ 0 _U_ 2 _N_ _N_ _N_ _N_ },
+ showList = { _A_ 0 _U_ 12 _N_ _N_ _N_ _N_ } #-}
instance (Ix a, Text a, Text b) => Text (Array a b)
{-# GHC_PRAGMA _M_ PreludeArray {-dfun-} _A_ 3 _U_ 222 _N_ _N_ _N_ _N_ #-}
+instance Text (Array Int Double)
+ {-# GHC_PRAGMA _M_ PreludeArray {-dfun-} _A_ 0 _N_ _N_ _N_ _F_ _IF_ARGS_ 0 0 X 5 _!_ _TUP_4 [(Int -> [Char] -> [(Array Int Double, [Char])]), (Int -> Array Int Double -> [Char] -> [Char]), ([Char] -> [([Array Int Double], [Char])]), ([Array Int Double] -> [Char] -> [Char])] [_CONSTM_ Text readsPrec (Array Int Double), _CONSTM_ Text showsPrec (Array Int Double), _CONSTM_ Text readList (Array Int Double), _CONSTM_ Text showList (Array Int Double)] _N_
+ readsPrec = { _A_ 1 _U_ 12 _N_ _S_ "U(P)" {_A_ 1 _U_ 22 _N_ _N_ _N_ _N_} _N_ _N_ },
+ showsPrec = { _A_ 2 _U_ 122 _N_ _N_ _N_ _N_ },
+ readList = { _A_ 0 _U_ 2 _N_ _N_ _N_ _N_ },
+ showList = { _A_ 0 _U_ 12 _N_ _N_ _N_ _N_ } #-}
instance (Text a, Text b) => Text (Assoc a b)
{-# GHC_PRAGMA _M_ PreludeArray {-dfun-} _A_ 2 _U_ 22 _N_ _N_ _N_ _N_ #-}
import Core
import IChar
import IInt -- instances
+import IDouble
import IList
import ITup2
import List ( (++), zipWith, foldr )
import PS ( _PackedString, _unpackPS )
import Text
import TyArray ( Array(..), Assoc(..) )
+import TyComplex
import PreludeGlaST
-- Hey! This isn't wimp Haskell-report code! This is
= showParen (d > 1)
(showsPrec 2 a . showString " := " . showsPrec 2 b)
+ readList = _readList (readsPrec 0)
+ showList = _showList (showsPrec 0)
+
-- ToDo: *** Binary
-----------------------------------------------------------
instance (Ix a, Text a, Text b) => Text (Array a b) where
showsPrec p a = showParen (p > 9) (
showString "array " .
- shows (bounds a) . showChar ' ' .
- shows (assocs a) )
+ showsPrec 0 (bounds a) . showChar ' ' .
+ showList (assocs a) )
readsPrec p = readParen (p > 9)
(\r -> [(array b as, u) | ("array",s) <- lex r,
- (b,t) <- reads s,
- (as,u) <- reads t ]
+ (b,t) <- readsPrec 0 s,
+ (as,u) <- readList t ]
++
[(listArray b xs, u) | ("listArray",s) <- lex r,
- (b,t) <- reads s,
- (xs,u) <- reads t ])
+ (b,t) <- readsPrec 0 s,
+ (xs,u) <- readList t ])
+
+ readList = _readList (readsPrec 0)
+ showList = _showList (showsPrec 0)
+
+
+{-# SPECIALIZE instance Text (Array Int Double) #-}
+{-# SPECIALIZE instance Text (Array (Int,Int) Double) #-}
{- **** OMITTED **** (ToDo)
instance (Ix a, Binary a, Binary b) => Binary (Array a b) where
-- {-# GENERATE_SPECS instance a{Int#} b{Int#,Double#} :: Ord (Array a b) #-}
-- {-# GENERATE_SPECS instance a{Int#} b{Int#,Double#} :: Text (Array a b) #-}
-
--- {-# GENERATE_SPECS instance a{Int} b{} :: Eq (Array a b) #-}
-This raises the question of ambiguous specialised instances:
-Which instance would be chosen for Array Int Int# ?
-Array Int b or Array a Int# ?
-
-- {-# GENERATE_SPECS instance a{Int#} b{Int#,Double#} :: Eq (Assoc a b) #-}
-- {-# GENERATE_SPECS instance a{Int#} b{Int#,Double#} :: Ord (Assoc a b) #-}
-- {-# GENERATE_SPECS instance a{Int#} b{Int#,Double#} :: Ix (Assoc a b) #-}
-{-# GHC_PRAGMA INTERFACE VERSION 5 #-}
+{-# GHC_PRAGMA INTERFACE VERSION 6 #-}
interface PreludeArray where
-import PreludeBuiltin(List(..), Tuple2)
+import PreludeBuiltin(Double(..), Int(..), List(..), Tuple2)
import PreludeCore(Eq(..), Ix(..), Ord(..), Text(..))
data Array a b {-# GHC_PRAGMA _Array (a, a) (Array# b) #-}
data Assoc a b {-# GHC_PRAGMA (:=) a b #-}
{-# GHC_PRAGMA _M_ PreludeArray {-dfun-} _A_ 3 _U_ 222 _N_ _N_ _N_ _N_ #-}
instance (Ord a, Ord b) => Ord (Assoc a b)
{-# GHC_PRAGMA _M_ PreludeArray {-dfun-} _A_ 3 _U_ 112 _N_ _N_ _N_ _N_ #-}
+instance Text (Array (Int, Int) Double)
+ {-# GHC_PRAGMA _M_ PreludeArray {-dfun-} _A_ 0 _N_ _N_ _N_ _F_ _IF_ARGS_ 0 0 X 5 _!_ _TUP_4 [(Int -> [Char] -> [(Array (Int, Int) Double, [Char])]), (Int -> Array (Int, Int) Double -> [Char] -> [Char]), ([Char] -> [([Array (Int, Int) Double], [Char])]), ([Array (Int, Int) Double] -> [Char] -> [Char])] [_CONSTM_ Text readsPrec (Array (Int, Int) Double), _CONSTM_ Text showsPrec (Array (Int, Int) Double), _CONSTM_ Text readList (Array (Int, Int) Double), _CONSTM_ Text showList (Array (Int, Int) Double)] _N_
+ readsPrec = { _A_ 1 _U_ 12 _N_ _S_ "U(P)" {_A_ 1 _U_ 22 _N_ _N_ _N_ _N_} _N_ _N_ },
+ showsPrec = { _A_ 2 _U_ 122 _N_ _N_ _N_ _N_ },
+ readList = { _A_ 0 _U_ 2 _N_ _N_ _N_ _N_ },
+ showList = { _A_ 0 _U_ 12 _N_ _N_ _N_ _N_ } #-}
instance (Ix a, Text a, Text b) => Text (Array a b)
{-# GHC_PRAGMA _M_ PreludeArray {-dfun-} _A_ 3 _U_ 222 _N_ _N_ _N_ _N_ #-}
+instance Text (Array Int Double)
+ {-# GHC_PRAGMA _M_ PreludeArray {-dfun-} _A_ 0 _N_ _N_ _N_ _F_ _IF_ARGS_ 0 0 X 5 _!_ _TUP_4 [(Int -> [Char] -> [(Array Int Double, [Char])]), (Int -> Array Int Double -> [Char] -> [Char]), ([Char] -> [([Array Int Double], [Char])]), ([Array Int Double] -> [Char] -> [Char])] [_CONSTM_ Text readsPrec (Array Int Double), _CONSTM_ Text showsPrec (Array Int Double), _CONSTM_ Text readList (Array Int Double), _CONSTM_ Text showList (Array Int Double)] _N_
+ readsPrec = { _A_ 1 _U_ 12 _N_ _S_ "U(P)" {_A_ 1 _U_ 22 _N_ _N_ _N_ _N_} _N_ _N_ },
+ showsPrec = { _A_ 2 _U_ 122 _N_ _N_ _N_ _N_ },
+ readList = { _A_ 0 _U_ 2 _N_ _N_ _N_ _N_ },
+ showList = { _A_ 0 _U_ 12 _N_ _N_ _N_ _N_ } #-}
instance (Text a, Text b) => Text (Assoc a b)
{-# GHC_PRAGMA _M_ PreludeArray {-dfun-} _A_ 2 _U_ 22 _N_ _N_ _N_ _N_ #-}
-{-# GHC_PRAGMA INTERFACE VERSION 5 #-}
+{-# GHC_PRAGMA INTERFACE VERSION 6 #-}
interface PreludeArray where
-import PreludeBuiltin(List(..), Tuple2)
+import PreludeBuiltin(Double(..), Int(..), List(..), Tuple2)
import PreludeCore(Eq(..), Ix(..), Ord(..), Text(..))
data Array a b {-# GHC_PRAGMA _Array (a, a) (Array# b) #-}
data Assoc a b {-# GHC_PRAGMA (:=) a b #-}
{-# GHC_PRAGMA _M_ PreludeArray {-dfun-} _A_ 3 _U_ 222 _N_ _N_ _N_ _N_ #-}
instance (Ord a, Ord b) => Ord (Assoc a b)
{-# GHC_PRAGMA _M_ PreludeArray {-dfun-} _A_ 3 _U_ 112 _N_ _N_ _N_ _N_ #-}
+instance Text (Array (Int, Int) Double)
+ {-# GHC_PRAGMA _M_ PreludeArray {-dfun-} _A_ 0 _N_ _N_ _N_ _F_ _IF_ARGS_ 0 0 X 5 _!_ _TUP_4 [(Int -> [Char] -> [(Array (Int, Int) Double, [Char])]), (Int -> Array (Int, Int) Double -> [Char] -> [Char]), ([Char] -> [([Array (Int, Int) Double], [Char])]), ([Array (Int, Int) Double] -> [Char] -> [Char])] [_CONSTM_ Text readsPrec (Array (Int, Int) Double), _CONSTM_ Text showsPrec (Array (Int, Int) Double), _CONSTM_ Text readList (Array (Int, Int) Double), _CONSTM_ Text showList (Array (Int, Int) Double)] _N_
+ readsPrec = { _A_ 1 _U_ 12 _N_ _S_ "U(P)" {_A_ 1 _U_ 22 _N_ _N_ _N_ _N_} _N_ _N_ },
+ showsPrec = { _A_ 2 _U_ 122 _N_ _N_ _N_ _N_ },
+ readList = { _A_ 0 _U_ 2 _N_ _N_ _N_ _N_ },
+ showList = { _A_ 0 _U_ 12 _N_ _N_ _N_ _N_ } #-}
instance (Ix a, Text a, Text b) => Text (Array a b)
{-# GHC_PRAGMA _M_ PreludeArray {-dfun-} _A_ 3 _U_ 222 _N_ _N_ _N_ _N_ #-}
+instance Text (Array Int Double)
+ {-# GHC_PRAGMA _M_ PreludeArray {-dfun-} _A_ 0 _N_ _N_ _N_ _F_ _IF_ARGS_ 0 0 X 5 _!_ _TUP_4 [(Int -> [Char] -> [(Array Int Double, [Char])]), (Int -> Array Int Double -> [Char] -> [Char]), ([Char] -> [([Array Int Double], [Char])]), ([Array Int Double] -> [Char] -> [Char])] [_CONSTM_ Text readsPrec (Array Int Double), _CONSTM_ Text showsPrec (Array Int Double), _CONSTM_ Text readList (Array Int Double), _CONSTM_ Text showList (Array Int Double)] _N_
+ readsPrec = { _A_ 1 _U_ 12 _N_ _S_ "U(P)" {_A_ 1 _U_ 22 _N_ _N_ _N_ _N_} _N_ _N_ },
+ showsPrec = { _A_ 2 _U_ 122 _N_ _N_ _N_ _N_ },
+ readList = { _A_ 0 _U_ 2 _N_ _N_ _N_ _N_ },
+ showList = { _A_ 0 _U_ 12 _N_ _N_ _N_ _N_ } #-}
instance (Text a, Text b) => Text (Assoc a b)
{-# GHC_PRAGMA _M_ PreludeArray {-dfun-} _A_ 2 _U_ 22 _N_ _N_ _N_ _N_ #-}
-{-# GHC_PRAGMA INTERFACE VERSION 5 #-}
+{-# GHC_PRAGMA INTERFACE VERSION 6 #-}
interface PreludeArray where
-import PreludeBuiltin(List(..), Tuple2)
+import PreludeBuiltin(Double(..), Int(..), List(..), Tuple2)
import PreludeCore(Eq(..), Ix(..), Ord(..), Text(..))
data Array a b {-# GHC_PRAGMA _Array (a, a) (Array# b) #-}
data Assoc a b {-# GHC_PRAGMA (:=) a b #-}
{-# GHC_PRAGMA _M_ PreludeArray {-dfun-} _A_ 3 _U_ 222 _N_ _N_ _N_ _N_ #-}
instance (Ord a, Ord b) => Ord (Assoc a b)
{-# GHC_PRAGMA _M_ PreludeArray {-dfun-} _A_ 3 _U_ 112 _N_ _N_ _N_ _N_ #-}
+instance Text (Array (Int, Int) Double)
+ {-# GHC_PRAGMA _M_ PreludeArray {-dfun-} _A_ 0 _N_ _N_ _N_ _F_ _IF_ARGS_ 0 0 X 5 _!_ _TUP_4 [(Int -> [Char] -> [(Array (Int, Int) Double, [Char])]), (Int -> Array (Int, Int) Double -> [Char] -> [Char]), ([Char] -> [([Array (Int, Int) Double], [Char])]), ([Array (Int, Int) Double] -> [Char] -> [Char])] [_CONSTM_ Text readsPrec (Array (Int, Int) Double), _CONSTM_ Text showsPrec (Array (Int, Int) Double), _CONSTM_ Text readList (Array (Int, Int) Double), _CONSTM_ Text showList (Array (Int, Int) Double)] _N_
+ readsPrec = { _A_ 1 _U_ 12 _N_ _S_ "U(P)" {_A_ 1 _U_ 22 _N_ _N_ _N_ _N_} _N_ _N_ },
+ showsPrec = { _A_ 2 _U_ 122 _N_ _N_ _N_ _N_ },
+ readList = { _A_ 0 _U_ 2 _N_ _N_ _N_ _N_ },
+ showList = { _A_ 0 _U_ 12 _N_ _N_ _N_ _N_ } #-}
instance (Ix a, Text a, Text b) => Text (Array a b)
{-# GHC_PRAGMA _M_ PreludeArray {-dfun-} _A_ 3 _U_ 222 _N_ _N_ _N_ _N_ #-}
+instance Text (Array Int Double)
+ {-# GHC_PRAGMA _M_ PreludeArray {-dfun-} _A_ 0 _N_ _N_ _N_ _F_ _IF_ARGS_ 0 0 X 5 _!_ _TUP_4 [(Int -> [Char] -> [(Array Int Double, [Char])]), (Int -> Array Int Double -> [Char] -> [Char]), ([Char] -> [([Array Int Double], [Char])]), ([Array Int Double] -> [Char] -> [Char])] [_CONSTM_ Text readsPrec (Array Int Double), _CONSTM_ Text showsPrec (Array Int Double), _CONSTM_ Text readList (Array Int Double), _CONSTM_ Text showList (Array Int Double)] _N_
+ readsPrec = { _A_ 1 _U_ 12 _N_ _S_ "U(P)" {_A_ 1 _U_ 22 _N_ _N_ _N_ _N_} _N_ _N_ },
+ showsPrec = { _A_ 2 _U_ 122 _N_ _N_ _N_ _N_ },
+ readList = { _A_ 0 _U_ 2 _N_ _N_ _N_ _N_ },
+ showList = { _A_ 0 _U_ 12 _N_ _N_ _N_ _N_ } #-}
instance (Text a, Text b) => Text (Assoc a b)
{-# GHC_PRAGMA _M_ PreludeArray {-dfun-} _A_ 2 _U_ 22 _N_ _N_ _N_ _N_ #-}
-{-# GHC_PRAGMA INTERFACE VERSION 5 #-}
+{-# GHC_PRAGMA INTERFACE VERSION 6 #-}
interface PreludeArray where
-import PreludeBuiltin(List(..), Tuple2)
+import PreludeBuiltin(Double(..), Int(..), List(..), Tuple2)
import PreludeCore(Eq(..), Ix(..), Ord(..), Text(..))
data Array a b {-# GHC_PRAGMA _Array (a, a) (Array# b) #-}
data Assoc a b {-# GHC_PRAGMA (:=) a b #-}
{-# GHC_PRAGMA _M_ PreludeArray {-dfun-} _A_ 3 _U_ 222 _N_ _N_ _N_ _N_ #-}
instance (Ord a, Ord b) => Ord (Assoc a b)
{-# GHC_PRAGMA _M_ PreludeArray {-dfun-} _A_ 3 _U_ 112 _N_ _N_ _N_ _N_ #-}
+instance Text (Array (Int, Int) Double)
+ {-# GHC_PRAGMA _M_ PreludeArray {-dfun-} _A_ 0 _N_ _N_ _N_ _F_ _IF_ARGS_ 0 0 X 5 _!_ _TUP_4 [(Int -> [Char] -> [(Array (Int, Int) Double, [Char])]), (Int -> Array (Int, Int) Double -> [Char] -> [Char]), ([Char] -> [([Array (Int, Int) Double], [Char])]), ([Array (Int, Int) Double] -> [Char] -> [Char])] [_CONSTM_ Text readsPrec (Array (Int, Int) Double), _CONSTM_ Text showsPrec (Array (Int, Int) Double), _CONSTM_ Text readList (Array (Int, Int) Double), _CONSTM_ Text showList (Array (Int, Int) Double)] _N_
+ readsPrec = { _A_ 1 _U_ 12 _N_ _S_ "U(P)" {_A_ 1 _U_ 22 _N_ _N_ _N_ _N_} _N_ _N_ },
+ showsPrec = { _A_ 2 _U_ 122 _N_ _N_ _N_ _N_ },
+ readList = { _A_ 0 _U_ 2 _N_ _N_ _N_ _N_ },
+ showList = { _A_ 0 _U_ 12 _N_ _N_ _N_ _N_ } #-}
instance (Ix a, Text a, Text b) => Text (Array a b)
{-# GHC_PRAGMA _M_ PreludeArray {-dfun-} _A_ 3 _U_ 222 _N_ _N_ _N_ _N_ #-}
+instance Text (Array Int Double)
+ {-# GHC_PRAGMA _M_ PreludeArray {-dfun-} _A_ 0 _N_ _N_ _N_ _F_ _IF_ARGS_ 0 0 X 5 _!_ _TUP_4 [(Int -> [Char] -> [(Array Int Double, [Char])]), (Int -> Array Int Double -> [Char] -> [Char]), ([Char] -> [([Array Int Double], [Char])]), ([Array Int Double] -> [Char] -> [Char])] [_CONSTM_ Text readsPrec (Array Int Double), _CONSTM_ Text showsPrec (Array Int Double), _CONSTM_ Text readList (Array Int Double), _CONSTM_ Text showList (Array Int Double)] _N_
+ readsPrec = { _A_ 1 _U_ 12 _N_ _S_ "U(P)" {_A_ 1 _U_ 22 _N_ _N_ _N_ _N_} _N_ _N_ },
+ showsPrec = { _A_ 2 _U_ 122 _N_ _N_ _N_ _N_ },
+ readList = { _A_ 0 _U_ 2 _N_ _N_ _N_ _N_ },
+ showList = { _A_ 0 _U_ 12 _N_ _N_ _N_ _N_ } #-}
instance (Text a, Text b) => Text (Assoc a b)
{-# GHC_PRAGMA _M_ PreludeArray {-dfun-} _A_ 2 _U_ 22 _N_ _N_ _N_ _N_ #-}
-{-# GHC_PRAGMA INTERFACE VERSION 5 #-}
+{-# GHC_PRAGMA INTERFACE VERSION 6 #-}
interface PreludeCore where
instance Enum Bool
{-# GHC_PRAGMA _M_ PreludeCore {-dfun-} _A_ 0 _N_ _N_ _N_ _F_ _IF_ARGS_ 0 0 X 6 _!_ _TUP_5 [{{Ord Bool}}, (Bool -> [Bool]), (Bool -> Bool -> [Bool]), (Bool -> Bool -> [Bool]), (Bool -> Bool -> Bool -> [Bool])] [_DFUN_ Ord (Bool), _CONSTM_ Enum enumFrom (Bool), _CONSTM_ Enum enumFromThen (Bool), _CONSTM_ Enum enumFromTo (Bool), _CONSTM_ Enum enumFromThenTo (Bool)] _N_
- enumFrom = _A_ 1 _U_ 2 _N_ _S_ "E" _N_ _N_,
- enumFromThen = _A_ 2 _U_ 22 _N_ _S_ "EE" _N_ _N_,
- enumFromTo = _A_ 2 _U_ 22 _N_ _N_ _N_ _N_,
- enumFromThenTo = _A_ 3 _U_ 222 _N_ _N_ _N_ _N_ #-}
+ enumFrom = { _A_ 1 _U_ 2 _N_ _S_ "E" _N_ _N_ },
+ enumFromThen = { _A_ 2 _U_ 22 _N_ _S_ "EE" _N_ _N_ },
+ enumFromTo = { _A_ 2 _U_ 22 _N_ _S_ "EL" _N_ _N_ },
+ enumFromThenTo = { _A_ 3 _U_ 222 _N_ _S_ "EEL" _N_ _N_ } #-}
instance Eq Bool
{-# GHC_PRAGMA _M_ PreludeCore {-dfun-} _A_ 0 _N_ _N_ _N_ _F_ _IF_ARGS_ 0 0 X 3 _!_ _TUP_2 [(Bool -> Bool -> Bool), (Bool -> Bool -> Bool)] [_CONSTM_ Eq (==) (Bool), _CONSTM_ Eq (/=) (Bool)] _N_
- (==) = _A_ 2 _U_ 11 _N_ _S_ "EE" _F_ _IF_ARGS_ 0 2 CC 7 \ (u0 :: Bool) (u1 :: Bool) -> case u0 of { _ALG_ True -> u1; False -> case u1 of { _ALG_ True -> _!_ False [] []; False -> _!_ True [] []; _NO_DEFLT_ }; _NO_DEFLT_ } _N_,
- (/=) = _A_ 2 _U_ 11 _N_ _S_ "EE" _F_ _IF_ARGS_ 0 2 CC 7 \ (u0 :: Bool) (u1 :: Bool) -> case u0 of { _ALG_ True -> case u1 of { _ALG_ True -> _!_ False [] []; False -> _!_ True [] []; _NO_DEFLT_ }; False -> u1; _NO_DEFLT_ } _N_ #-}
+ (==) = { _A_ 2 _U_ 11 _N_ _S_ "EE" _F_ _IF_ARGS_ 0 2 CC 7 \ (u0 :: Bool) (u1 :: Bool) -> case u0 of { _ALG_ True -> u1; False -> case u1 of { _ALG_ True -> _!_ False [] []; False -> _!_ True [] []; _NO_DEFLT_ }; _NO_DEFLT_ } _N_ },
+ (/=) = { _A_ 2 _U_ 11 _N_ _S_ "EE" _F_ _IF_ARGS_ 0 2 CC 7 \ (u0 :: Bool) (u1 :: Bool) -> case u0 of { _ALG_ True -> case u1 of { _ALG_ True -> _!_ False [] []; False -> _!_ True [] []; _NO_DEFLT_ }; False -> u1; _NO_DEFLT_ } _N_ } #-}
instance Ix Bool
{-# GHC_PRAGMA _M_ PreludeCore {-dfun-} _A_ 0 _N_ _N_ _N_ _F_ _IF_ARGS_ 0 0 X 5 _!_ _TUP_4 [{{Ord Bool}}, ((Bool, Bool) -> [Bool]), ((Bool, Bool) -> Bool -> Int), ((Bool, Bool) -> Bool -> Bool)] [_DFUN_ Ord (Bool), _CONSTM_ Ix range (Bool), _CONSTM_ Ix index (Bool), _CONSTM_ Ix inRange (Bool)] _N_
- range = _A_ 1 _U_ 1 _N_ _S_ "U(EE)" {_A_ 2 _U_ 11 _N_ _N_ _N_ _N_} _N_ _N_,
- index = _A_ 2 _U_ 11 _N_ _S_ "U(EA)E" {_A_ 2 _U_ 11 _N_ _N_ _N_ _N_} _N_ _N_,
- inRange = _A_ 2 _U_ 12 _N_ _S_ "U(EL)E" {_A_ 3 _U_ 112 _N_ _N_ _N_ _N_} _N_ _N_ #-}
+ range = { _A_ 1 _U_ 1 _N_ _S_ "U(EE)" {_A_ 2 _U_ 11 _N_ _N_ _N_ _N_} _N_ _N_ },
+ index = { _A_ 2 _U_ 11 _N_ _S_ "U(EA)E" {_A_ 2 _U_ 11 _N_ _N_ _N_ _N_} _N_ _N_ },
+ inRange = { _A_ 2 _U_ 12 _N_ _S_ "U(EL)E" {_A_ 3 _U_ 112 _N_ _N_ _N_ _N_} _N_ _N_ } #-}
instance Ord Bool
{-# GHC_PRAGMA _M_ PreludeCore {-dfun-} _A_ 0 _N_ _N_ _N_ _F_ _IF_ARGS_ 0 0 X 9 _!_ _TUP_8 [{{Eq Bool}}, (Bool -> Bool -> Bool), (Bool -> Bool -> Bool), (Bool -> Bool -> Bool), (Bool -> Bool -> Bool), (Bool -> Bool -> Bool), (Bool -> Bool -> Bool), (Bool -> Bool -> _CMP_TAG)] [_DFUN_ Eq (Bool), _CONSTM_ Ord (<) (Bool), _CONSTM_ Ord (<=) (Bool), _CONSTM_ Ord (>=) (Bool), _CONSTM_ Ord (>) (Bool), _CONSTM_ Ord max (Bool), _CONSTM_ Ord min (Bool), _CONSTM_ Ord _tagCmp (Bool)] _N_
- (<) = _A_ 2 _U_ 11 _N_ _S_ "EE" _N_ _N_,
- (<=) = _A_ 2 _U_ 11 _N_ _S_ "EE" _N_ _N_,
- (>=) = _A_ 2 _U_ 11 _N_ _S_ "EE" _N_ _N_,
- (>) = _A_ 2 _U_ 11 _N_ _S_ "EE" _N_ _N_,
- max = _A_ 2 _U_ 22 _N_ _S_ "EE" _N_ _N_,
- min = _A_ 2 _U_ 22 _N_ _S_ "EE" _N_ _N_,
- _tagCmp = _A_ 2 _U_ 11 _N_ _S_ "EE" _N_ _N_ #-}
+ (<) = { _A_ 2 _U_ 11 _N_ _S_ "EE" _N_ _N_ },
+ (<=) = { _A_ 2 _U_ 11 _N_ _S_ "EE" _N_ _N_ },
+ (>=) = { _A_ 2 _U_ 11 _N_ _S_ "EE" _N_ _N_ },
+ (>) = { _A_ 2 _U_ 11 _N_ _S_ "EE" _N_ _N_ },
+ max = { _A_ 2 _U_ 22 _N_ _S_ "EE" _N_ _N_ },
+ min = { _A_ 2 _U_ 22 _N_ _S_ "EE" _N_ _N_ },
+ _tagCmp = { _A_ 2 _U_ 11 _N_ _S_ "EE" _N_ _N_ } #-}
instance Text Bool
{-# GHC_PRAGMA _M_ PreludeCore {-dfun-} _A_ 0 _N_ _N_ _N_ _F_ _IF_ARGS_ 0 0 X 5 _!_ _TUP_4 [(Int -> [Char] -> [(Bool, [Char])]), (Int -> Bool -> [Char] -> [Char]), ([Char] -> [([Bool], [Char])]), ([Bool] -> [Char] -> [Char])] [_CONSTM_ Text readsPrec (Bool), _CONSTM_ Text showsPrec (Bool), _CONSTM_ Text readList (Bool), _CONSTM_ Text showList (Bool)] _N_
- readsPrec = _A_ 2 _U_ 02 _N_ _S_ "AL" {_A_ 1 _U_ 2 _N_ _N_ _N_ _N_} _N_ _N_,
- showsPrec = _A_ 3 _U_ 012 _N_ _S_ "AEL" {_A_ 2 _U_ 12 _N_ _N_ _N_ _N_} _N_ _N_,
- readList = _A_ 0 _U_ 2 _N_ _N_ _N_ _N_,
- showList = _A_ 0 _U_ 12 _N_ _N_ _N_ _N_ #-}
+ readsPrec = { _A_ 2 _U_ 02 _N_ _S_ "AL" {_A_ 1 _U_ 2 _N_ _N_ _N_ _N_} _N_ _N_ },
+ showsPrec = { _A_ 3 _U_ 012 _N_ _S_ "AEL" {_A_ 2 _U_ 12 _N_ _N_ _N_ _N_} _N_ _N_ },
+ readList = { _A_ 0 _U_ 2 _N_ _N_ _N_ _N_ },
+ showList = { _A_ 1 _U_ 12 _N_ _N_ _F_ _IF_ARGS_ 0 1 X 3 \ (u0 :: [Bool]) -> _APP_ _TYAPP_ _ORIG_ PreludeCore _showList { Bool } [ _WRKR_ _CONSTM_ Text showsPrec (Bool), u0 ] _N_ } #-}
import IChar
import IInt
import IList
-import List ( (++), map, foldr )
+import List ( (++), map, foldr, takeWhile )
import PS ( _PackedString, _unpackPS )
import Text
+import TyArray
+import TyComplex
----------------------------------------------------------------------
instance Eq Bool where
enumFromThen True False = [True, False]
enumFromThen b _ = bs where bs = b : bs
+ enumFromTo n m = takeWhile (<= m) (enumFrom n)
+ enumFromThenTo n m p = takeWhile (if m >= n then (<= p) else (>= p))
+ (enumFromThen n m)
+
----------------------------------------------------------------------
instance Text Bool where
readsPrec p r
showsPrec d p = showString (if p then "True" else "False")
+ readList = _readList (readsPrec 0)
+ showList = _showList (showsPrec 0)
+
-- ToDo: Binary
-{-# GHC_PRAGMA INTERFACE VERSION 5 #-}
+{-# GHC_PRAGMA INTERFACE VERSION 6 #-}
interface PreludeCore where
instance Enum Bool
{-# GHC_PRAGMA _M_ PreludeCore {-dfun-} _A_ 0 _N_ _N_ _N_ _F_ _IF_ARGS_ 0 0 X 6 _!_ _TUP_5 [{{Ord Bool}}, (Bool -> [Bool]), (Bool -> Bool -> [Bool]), (Bool -> Bool -> [Bool]), (Bool -> Bool -> Bool -> [Bool])] [_DFUN_ Ord (Bool), _CONSTM_ Enum enumFrom (Bool), _CONSTM_ Enum enumFromThen (Bool), _CONSTM_ Enum enumFromTo (Bool), _CONSTM_ Enum enumFromThenTo (Bool)] _N_
- enumFrom = _A_ 1 _U_ 2 _N_ _S_ "E" _N_ _N_,
- enumFromThen = _A_ 2 _U_ 22 _N_ _S_ "EE" _N_ _N_,
- enumFromTo = _A_ 2 _U_ 22 _N_ _N_ _N_ _N_,
- enumFromThenTo = _A_ 3 _U_ 222 _N_ _N_ _N_ _N_ #-}
+ enumFrom = { _A_ 1 _U_ 2 _N_ _S_ "E" _N_ _N_ },
+ enumFromThen = { _A_ 2 _U_ 22 _N_ _S_ "EE" _N_ _N_ },
+ enumFromTo = { _A_ 2 _U_ 22 _N_ _S_ "EL" _N_ _N_ },
+ enumFromThenTo = { _A_ 3 _U_ 222 _N_ _S_ "EEL" _N_ _N_ } #-}
instance Eq Bool
{-# GHC_PRAGMA _M_ PreludeCore {-dfun-} _A_ 0 _N_ _N_ _N_ _F_ _IF_ARGS_ 0 0 X 3 _!_ _TUP_2 [(Bool -> Bool -> Bool), (Bool -> Bool -> Bool)] [_CONSTM_ Eq (==) (Bool), _CONSTM_ Eq (/=) (Bool)] _N_
- (==) = _A_ 2 _U_ 11 _N_ _S_ "EE" _F_ _IF_ARGS_ 0 2 CC 7 \ (u0 :: Bool) (u1 :: Bool) -> case u0 of { _ALG_ True -> u1; False -> case u1 of { _ALG_ True -> _!_ False [] []; False -> _!_ True [] []; _NO_DEFLT_ }; _NO_DEFLT_ } _N_,
- (/=) = _A_ 2 _U_ 11 _N_ _S_ "EE" _F_ _IF_ARGS_ 0 2 CC 7 \ (u0 :: Bool) (u1 :: Bool) -> case u0 of { _ALG_ True -> case u1 of { _ALG_ True -> _!_ False [] []; False -> _!_ True [] []; _NO_DEFLT_ }; False -> u1; _NO_DEFLT_ } _N_ #-}
+ (==) = { _A_ 2 _U_ 11 _N_ _S_ "EE" _F_ _IF_ARGS_ 0 2 CC 7 \ (u0 :: Bool) (u1 :: Bool) -> case u0 of { _ALG_ True -> u1; False -> case u1 of { _ALG_ True -> _!_ False [] []; False -> _!_ True [] []; _NO_DEFLT_ }; _NO_DEFLT_ } _N_ },
+ (/=) = { _A_ 2 _U_ 11 _N_ _S_ "EE" _F_ _IF_ARGS_ 0 2 CC 7 \ (u0 :: Bool) (u1 :: Bool) -> case u0 of { _ALG_ True -> case u1 of { _ALG_ True -> _!_ False [] []; False -> _!_ True [] []; _NO_DEFLT_ }; False -> u1; _NO_DEFLT_ } _N_ } #-}
instance Ix Bool
{-# GHC_PRAGMA _M_ PreludeCore {-dfun-} _A_ 0 _N_ _N_ _N_ _F_ _IF_ARGS_ 0 0 X 5 _!_ _TUP_4 [{{Ord Bool}}, ((Bool, Bool) -> [Bool]), ((Bool, Bool) -> Bool -> Int), ((Bool, Bool) -> Bool -> Bool)] [_DFUN_ Ord (Bool), _CONSTM_ Ix range (Bool), _CONSTM_ Ix index (Bool), _CONSTM_ Ix inRange (Bool)] _N_
- range = _A_ 1 _U_ 1 _N_ _S_ "U(EE)" {_A_ 2 _U_ 11 _N_ _N_ _N_ _N_} _N_ _N_,
- index = _A_ 2 _U_ 11 _N_ _S_ "U(EA)E" {_A_ 2 _U_ 11 _N_ _N_ _N_ _N_} _N_ _N_,
- inRange = _A_ 2 _U_ 12 _N_ _S_ "U(EL)E" {_A_ 3 _U_ 112 _N_ _N_ _N_ _N_} _N_ _N_ #-}
+ range = { _A_ 1 _U_ 1 _N_ _S_ "U(EE)" {_A_ 2 _U_ 11 _N_ _N_ _N_ _N_} _N_ _N_ },
+ index = { _A_ 2 _U_ 11 _N_ _S_ "U(EA)E" {_A_ 2 _U_ 11 _N_ _N_ _N_ _N_} _N_ _N_ },
+ inRange = { _A_ 2 _U_ 12 _N_ _S_ "U(EL)E" {_A_ 3 _U_ 112 _N_ _N_ _N_ _N_} _N_ _N_ } #-}
instance Ord Bool
{-# GHC_PRAGMA _M_ PreludeCore {-dfun-} _A_ 0 _N_ _N_ _N_ _F_ _IF_ARGS_ 0 0 X 9 _!_ _TUP_8 [{{Eq Bool}}, (Bool -> Bool -> Bool), (Bool -> Bool -> Bool), (Bool -> Bool -> Bool), (Bool -> Bool -> Bool), (Bool -> Bool -> Bool), (Bool -> Bool -> Bool), (Bool -> Bool -> _CMP_TAG)] [_DFUN_ Eq (Bool), _CONSTM_ Ord (<) (Bool), _CONSTM_ Ord (<=) (Bool), _CONSTM_ Ord (>=) (Bool), _CONSTM_ Ord (>) (Bool), _CONSTM_ Ord max (Bool), _CONSTM_ Ord min (Bool), _CONSTM_ Ord _tagCmp (Bool)] _N_
- (<) = _A_ 2 _U_ 11 _N_ _S_ "EE" _N_ _N_,
- (<=) = _A_ 2 _U_ 11 _N_ _S_ "EE" _N_ _N_,
- (>=) = _A_ 2 _U_ 11 _N_ _S_ "EE" _N_ _N_,
- (>) = _A_ 2 _U_ 11 _N_ _S_ "EE" _N_ _N_,
- max = _A_ 2 _U_ 22 _N_ _S_ "EE" _N_ _N_,
- min = _A_ 2 _U_ 22 _N_ _S_ "EE" _N_ _N_,
- _tagCmp = _A_ 2 _U_ 11 _N_ _S_ "EE" _N_ _N_ #-}
+ (<) = { _A_ 2 _U_ 11 _N_ _S_ "EE" _N_ _N_ },
+ (<=) = { _A_ 2 _U_ 11 _N_ _S_ "EE" _N_ _N_ },
+ (>=) = { _A_ 2 _U_ 11 _N_ _S_ "EE" _N_ _N_ },
+ (>) = { _A_ 2 _U_ 11 _N_ _S_ "EE" _N_ _N_ },
+ max = { _A_ 2 _U_ 22 _N_ _S_ "EE" _N_ _N_ },
+ min = { _A_ 2 _U_ 22 _N_ _S_ "EE" _N_ _N_ },
+ _tagCmp = { _A_ 2 _U_ 11 _N_ _S_ "EE" _N_ _N_ } #-}
instance Text Bool
{-# GHC_PRAGMA _M_ PreludeCore {-dfun-} _A_ 0 _N_ _N_ _N_ _F_ _IF_ARGS_ 0 0 X 5 _!_ _TUP_4 [(Int -> [Char] -> [(Bool, [Char])]), (Int -> Bool -> [Char] -> [Char]), ([Char] -> [([Bool], [Char])]), ([Bool] -> [Char] -> [Char])] [_CONSTM_ Text readsPrec (Bool), _CONSTM_ Text showsPrec (Bool), _CONSTM_ Text readList (Bool), _CONSTM_ Text showList (Bool)] _N_
- readsPrec = _A_ 2 _U_ 02 _N_ _S_ "AL" {_A_ 1 _U_ 2 _N_ _N_ _N_ _N_} _N_ _N_,
- showsPrec = _A_ 3 _U_ 012 _N_ _S_ "AEL" {_A_ 2 _U_ 12 _N_ _N_ _N_ _N_} _N_ _N_,
- readList = _A_ 0 _U_ 2 _N_ _N_ _N_ _N_,
- showList = _A_ 0 _U_ 12 _N_ _N_ _N_ _N_ #-}
+ readsPrec = { _A_ 2 _U_ 02 _N_ _S_ "AL" {_A_ 1 _U_ 2 _N_ _N_ _N_ _N_} _N_ _N_ },
+ showsPrec = { _A_ 3 _U_ 012 _N_ _S_ "AEL" {_A_ 2 _U_ 12 _N_ _N_ _N_ _N_} _N_ _N_ },
+ readList = { _A_ 0 _U_ 2 _N_ _N_ _N_ _N_ },
+ showList = { _A_ 1 _U_ 12 _N_ _N_ _F_ _IF_ARGS_ 0 1 X 3 \ (u0 :: [Bool]) -> _APP_ _TYAPP_ _ORIG_ PreludeCore _showList { Bool } [ _WRKR_ _CONSTM_ Text showsPrec (Bool), u0 ] _N_ } #-}
-{-# GHC_PRAGMA INTERFACE VERSION 5 #-}
+{-# GHC_PRAGMA INTERFACE VERSION 6 #-}
interface PreludeCore where
instance Enum Bool
{-# GHC_PRAGMA _M_ PreludeCore {-dfun-} _A_ 0 _N_ _N_ _N_ _F_ _IF_ARGS_ 0 0 X 6 _!_ _TUP_5 [{{Ord Bool}}, (Bool -> [Bool]), (Bool -> Bool -> [Bool]), (Bool -> Bool -> [Bool]), (Bool -> Bool -> Bool -> [Bool])] [_DFUN_ Ord (Bool), _CONSTM_ Enum enumFrom (Bool), _CONSTM_ Enum enumFromThen (Bool), _CONSTM_ Enum enumFromTo (Bool), _CONSTM_ Enum enumFromThenTo (Bool)] _N_
- enumFrom = _A_ 1 _U_ 2 _N_ _S_ "E" _N_ _N_,
- enumFromThen = _A_ 2 _U_ 22 _N_ _S_ "EE" _N_ _N_,
- enumFromTo = _A_ 2 _U_ 22 _N_ _N_ _N_ _N_,
- enumFromThenTo = _A_ 3 _U_ 222 _N_ _N_ _N_ _N_ #-}
+ enumFrom = { _A_ 1 _U_ 2 _N_ _S_ "E" _N_ _N_ },
+ enumFromThen = { _A_ 2 _U_ 22 _N_ _S_ "EE" _N_ _N_ },
+ enumFromTo = { _A_ 2 _U_ 22 _N_ _S_ "EL" _N_ _N_ },
+ enumFromThenTo = { _A_ 3 _U_ 222 _N_ _S_ "EEL" _N_ _N_ } #-}
instance Eq Bool
{-# GHC_PRAGMA _M_ PreludeCore {-dfun-} _A_ 0 _N_ _N_ _N_ _F_ _IF_ARGS_ 0 0 X 3 _!_ _TUP_2 [(Bool -> Bool -> Bool), (Bool -> Bool -> Bool)] [_CONSTM_ Eq (==) (Bool), _CONSTM_ Eq (/=) (Bool)] _N_
- (==) = _A_ 2 _U_ 11 _N_ _S_ "EE" _F_ _IF_ARGS_ 0 2 CC 7 \ (u0 :: Bool) (u1 :: Bool) -> case u0 of { _ALG_ True -> u1; False -> case u1 of { _ALG_ True -> _!_ False [] []; False -> _!_ True [] []; _NO_DEFLT_ }; _NO_DEFLT_ } _N_,
- (/=) = _A_ 2 _U_ 11 _N_ _S_ "EE" _F_ _IF_ARGS_ 0 2 CC 7 \ (u0 :: Bool) (u1 :: Bool) -> case u0 of { _ALG_ True -> case u1 of { _ALG_ True -> _!_ False [] []; False -> _!_ True [] []; _NO_DEFLT_ }; False -> u1; _NO_DEFLT_ } _N_ #-}
+ (==) = { _A_ 2 _U_ 11 _N_ _S_ "EE" _F_ _IF_ARGS_ 0 2 CC 7 \ (u0 :: Bool) (u1 :: Bool) -> case u0 of { _ALG_ True -> u1; False -> case u1 of { _ALG_ True -> _!_ False [] []; False -> _!_ True [] []; _NO_DEFLT_ }; _NO_DEFLT_ } _N_ },
+ (/=) = { _A_ 2 _U_ 11 _N_ _S_ "EE" _F_ _IF_ARGS_ 0 2 CC 7 \ (u0 :: Bool) (u1 :: Bool) -> case u0 of { _ALG_ True -> case u1 of { _ALG_ True -> _!_ False [] []; False -> _!_ True [] []; _NO_DEFLT_ }; False -> u1; _NO_DEFLT_ } _N_ } #-}
instance Ix Bool
{-# GHC_PRAGMA _M_ PreludeCore {-dfun-} _A_ 0 _N_ _N_ _N_ _F_ _IF_ARGS_ 0 0 X 5 _!_ _TUP_4 [{{Ord Bool}}, ((Bool, Bool) -> [Bool]), ((Bool, Bool) -> Bool -> Int), ((Bool, Bool) -> Bool -> Bool)] [_DFUN_ Ord (Bool), _CONSTM_ Ix range (Bool), _CONSTM_ Ix index (Bool), _CONSTM_ Ix inRange (Bool)] _N_
- range = _A_ 1 _U_ 1 _N_ _S_ "U(EE)" {_A_ 2 _U_ 11 _N_ _N_ _N_ _N_} _N_ _N_,
- index = _A_ 2 _U_ 11 _N_ _S_ "U(EA)E" {_A_ 2 _U_ 11 _N_ _N_ _N_ _N_} _N_ _N_,
- inRange = _A_ 2 _U_ 12 _N_ _S_ "U(EL)E" {_A_ 3 _U_ 112 _N_ _N_ _N_ _N_} _N_ _N_ #-}
+ range = { _A_ 1 _U_ 1 _N_ _S_ "U(EE)" {_A_ 2 _U_ 11 _N_ _N_ _N_ _N_} _N_ _N_ },
+ index = { _A_ 2 _U_ 11 _N_ _S_ "U(EA)E" {_A_ 2 _U_ 11 _N_ _N_ _N_ _N_} _N_ _N_ },
+ inRange = { _A_ 2 _U_ 12 _N_ _S_ "U(EL)E" {_A_ 3 _U_ 112 _N_ _N_ _N_ _N_} _N_ _N_ } #-}
instance Ord Bool
{-# GHC_PRAGMA _M_ PreludeCore {-dfun-} _A_ 0 _N_ _N_ _N_ _F_ _IF_ARGS_ 0 0 X 9 _!_ _TUP_8 [{{Eq Bool}}, (Bool -> Bool -> Bool), (Bool -> Bool -> Bool), (Bool -> Bool -> Bool), (Bool -> Bool -> Bool), (Bool -> Bool -> Bool), (Bool -> Bool -> Bool), (Bool -> Bool -> _CMP_TAG)] [_DFUN_ Eq (Bool), _CONSTM_ Ord (<) (Bool), _CONSTM_ Ord (<=) (Bool), _CONSTM_ Ord (>=) (Bool), _CONSTM_ Ord (>) (Bool), _CONSTM_ Ord max (Bool), _CONSTM_ Ord min (Bool), _CONSTM_ Ord _tagCmp (Bool)] _N_
- (<) = _A_ 2 _U_ 11 _N_ _S_ "EE" _N_ _N_,
- (<=) = _A_ 2 _U_ 11 _N_ _S_ "EE" _N_ _N_,
- (>=) = _A_ 2 _U_ 11 _N_ _S_ "EE" _N_ _N_,
- (>) = _A_ 2 _U_ 11 _N_ _S_ "EE" _N_ _N_,
- max = _A_ 2 _U_ 22 _N_ _S_ "EE" _N_ _N_,
- min = _A_ 2 _U_ 22 _N_ _S_ "EE" _N_ _N_,
- _tagCmp = _A_ 2 _U_ 11 _N_ _S_ "EE" _N_ _N_ #-}
+ (<) = { _A_ 2 _U_ 11 _N_ _S_ "EE" _N_ _N_ },
+ (<=) = { _A_ 2 _U_ 11 _N_ _S_ "EE" _N_ _N_ },
+ (>=) = { _A_ 2 _U_ 11 _N_ _S_ "EE" _N_ _N_ },
+ (>) = { _A_ 2 _U_ 11 _N_ _S_ "EE" _N_ _N_ },
+ max = { _A_ 2 _U_ 22 _N_ _S_ "EE" _N_ _N_ },
+ min = { _A_ 2 _U_ 22 _N_ _S_ "EE" _N_ _N_ },
+ _tagCmp = { _A_ 2 _U_ 11 _N_ _S_ "EE" _N_ _N_ } #-}
instance Text Bool
{-# GHC_PRAGMA _M_ PreludeCore {-dfun-} _A_ 0 _N_ _N_ _N_ _F_ _IF_ARGS_ 0 0 X 5 _!_ _TUP_4 [(Int -> [Char] -> [(Bool, [Char])]), (Int -> Bool -> [Char] -> [Char]), ([Char] -> [([Bool], [Char])]), ([Bool] -> [Char] -> [Char])] [_CONSTM_ Text readsPrec (Bool), _CONSTM_ Text showsPrec (Bool), _CONSTM_ Text readList (Bool), _CONSTM_ Text showList (Bool)] _N_
- readsPrec = _A_ 2 _U_ 02 _N_ _S_ "AL" {_A_ 1 _U_ 2 _N_ _N_ _N_ _N_} _N_ _N_,
- showsPrec = _A_ 3 _U_ 012 _N_ _S_ "AEL" {_A_ 2 _U_ 12 _N_ _N_ _N_ _N_} _N_ _N_,
- readList = _A_ 0 _U_ 2 _N_ _N_ _N_ _N_,
- showList = _A_ 0 _U_ 12 _N_ _N_ _N_ _N_ #-}
+ readsPrec = { _A_ 2 _U_ 02 _N_ _S_ "AL" {_A_ 1 _U_ 2 _N_ _N_ _N_ _N_} _N_ _N_ },
+ showsPrec = { _A_ 3 _U_ 012 _N_ _S_ "AEL" {_A_ 2 _U_ 12 _N_ _N_ _N_ _N_} _N_ _N_ },
+ readList = { _A_ 0 _U_ 2 _N_ _N_ _N_ _N_ },
+ showList = { _A_ 1 _U_ 12 _N_ _N_ _F_ _IF_ARGS_ 0 1 X 3 \ (u0 :: [Bool]) -> _APP_ _TYAPP_ _ORIG_ PreludeCore _showList { Bool } [ _WRKR_ _CONSTM_ Text showsPrec (Bool), u0 ] _N_ } #-}
-{-# GHC_PRAGMA INTERFACE VERSION 5 #-}
+{-# GHC_PRAGMA INTERFACE VERSION 6 #-}
interface PreludeCore where
instance Enum Bool
{-# GHC_PRAGMA _M_ PreludeCore {-dfun-} _A_ 0 _N_ _N_ _N_ _F_ _IF_ARGS_ 0 0 X 6 _!_ _TUP_5 [{{Ord Bool}}, (Bool -> [Bool]), (Bool -> Bool -> [Bool]), (Bool -> Bool -> [Bool]), (Bool -> Bool -> Bool -> [Bool])] [_DFUN_ Ord (Bool), _CONSTM_ Enum enumFrom (Bool), _CONSTM_ Enum enumFromThen (Bool), _CONSTM_ Enum enumFromTo (Bool), _CONSTM_ Enum enumFromThenTo (Bool)] _N_
- enumFrom = _A_ 1 _U_ 2 _N_ _S_ "E" _N_ _N_,
- enumFromThen = _A_ 2 _U_ 22 _N_ _S_ "EE" _N_ _N_,
- enumFromTo = _A_ 2 _U_ 22 _N_ _N_ _N_ _N_,
- enumFromThenTo = _A_ 3 _U_ 222 _N_ _N_ _N_ _N_ #-}
+ enumFrom = { _A_ 1 _U_ 2 _N_ _S_ "E" _N_ _N_ },
+ enumFromThen = { _A_ 2 _U_ 22 _N_ _S_ "EE" _N_ _N_ },
+ enumFromTo = { _A_ 2 _U_ 22 _N_ _S_ "EL" _N_ _N_ },
+ enumFromThenTo = { _A_ 3 _U_ 222 _N_ _S_ "EEL" _N_ _N_ } #-}
instance Eq Bool
{-# GHC_PRAGMA _M_ PreludeCore {-dfun-} _A_ 0 _N_ _N_ _N_ _F_ _IF_ARGS_ 0 0 X 3 _!_ _TUP_2 [(Bool -> Bool -> Bool), (Bool -> Bool -> Bool)] [_CONSTM_ Eq (==) (Bool), _CONSTM_ Eq (/=) (Bool)] _N_
- (==) = _A_ 2 _U_ 11 _N_ _S_ "EE" _F_ _IF_ARGS_ 0 2 CC 7 \ (u0 :: Bool) (u1 :: Bool) -> case u0 of { _ALG_ True -> u1; False -> case u1 of { _ALG_ True -> _!_ False [] []; False -> _!_ True [] []; _NO_DEFLT_ }; _NO_DEFLT_ } _N_,
- (/=) = _A_ 2 _U_ 11 _N_ _S_ "EE" _F_ _IF_ARGS_ 0 2 CC 7 \ (u0 :: Bool) (u1 :: Bool) -> case u0 of { _ALG_ True -> case u1 of { _ALG_ True -> _!_ False [] []; False -> _!_ True [] []; _NO_DEFLT_ }; False -> u1; _NO_DEFLT_ } _N_ #-}
+ (==) = { _A_ 2 _U_ 11 _N_ _S_ "EE" _F_ _IF_ARGS_ 0 2 CC 7 \ (u0 :: Bool) (u1 :: Bool) -> case u0 of { _ALG_ True -> u1; False -> case u1 of { _ALG_ True -> _!_ False [] []; False -> _!_ True [] []; _NO_DEFLT_ }; _NO_DEFLT_ } _N_ },
+ (/=) = { _A_ 2 _U_ 11 _N_ _S_ "EE" _F_ _IF_ARGS_ 0 2 CC 7 \ (u0 :: Bool) (u1 :: Bool) -> case u0 of { _ALG_ True -> case u1 of { _ALG_ True -> _!_ False [] []; False -> _!_ True [] []; _NO_DEFLT_ }; False -> u1; _NO_DEFLT_ } _N_ } #-}
instance Ix Bool
{-# GHC_PRAGMA _M_ PreludeCore {-dfun-} _A_ 0 _N_ _N_ _N_ _F_ _IF_ARGS_ 0 0 X 5 _!_ _TUP_4 [{{Ord Bool}}, ((Bool, Bool) -> [Bool]), ((Bool, Bool) -> Bool -> Int), ((Bool, Bool) -> Bool -> Bool)] [_DFUN_ Ord (Bool), _CONSTM_ Ix range (Bool), _CONSTM_ Ix index (Bool), _CONSTM_ Ix inRange (Bool)] _N_
- range = _A_ 1 _U_ 1 _N_ _S_ "U(EE)" {_A_ 2 _U_ 11 _N_ _N_ _N_ _N_} _N_ _N_,
- index = _A_ 2 _U_ 11 _N_ _S_ "U(EA)E" {_A_ 2 _U_ 11 _N_ _N_ _N_ _N_} _N_ _N_,
- inRange = _A_ 2 _U_ 12 _N_ _S_ "U(EL)E" {_A_ 3 _U_ 112 _N_ _N_ _N_ _N_} _N_ _N_ #-}
+ range = { _A_ 1 _U_ 1 _N_ _S_ "U(EE)" {_A_ 2 _U_ 11 _N_ _N_ _N_ _N_} _N_ _N_ },
+ index = { _A_ 2 _U_ 11 _N_ _S_ "U(EA)E" {_A_ 2 _U_ 11 _N_ _N_ _N_ _N_} _N_ _N_ },
+ inRange = { _A_ 2 _U_ 12 _N_ _S_ "U(EL)E" {_A_ 3 _U_ 112 _N_ _N_ _N_ _N_} _N_ _N_ } #-}
instance Ord Bool
{-# GHC_PRAGMA _M_ PreludeCore {-dfun-} _A_ 0 _N_ _N_ _N_ _F_ _IF_ARGS_ 0 0 X 9 _!_ _TUP_8 [{{Eq Bool}}, (Bool -> Bool -> Bool), (Bool -> Bool -> Bool), (Bool -> Bool -> Bool), (Bool -> Bool -> Bool), (Bool -> Bool -> Bool), (Bool -> Bool -> Bool), (Bool -> Bool -> _CMP_TAG)] [_DFUN_ Eq (Bool), _CONSTM_ Ord (<) (Bool), _CONSTM_ Ord (<=) (Bool), _CONSTM_ Ord (>=) (Bool), _CONSTM_ Ord (>) (Bool), _CONSTM_ Ord max (Bool), _CONSTM_ Ord min (Bool), _CONSTM_ Ord _tagCmp (Bool)] _N_
- (<) = _A_ 2 _U_ 11 _N_ _S_ "EE" _N_ _N_,
- (<=) = _A_ 2 _U_ 11 _N_ _S_ "EE" _N_ _N_,
- (>=) = _A_ 2 _U_ 11 _N_ _S_ "EE" _N_ _N_,
- (>) = _A_ 2 _U_ 11 _N_ _S_ "EE" _N_ _N_,
- max = _A_ 2 _U_ 22 _N_ _S_ "EE" _N_ _N_,
- min = _A_ 2 _U_ 22 _N_ _S_ "EE" _N_ _N_,
- _tagCmp = _A_ 2 _U_ 11 _N_ _S_ "EE" _N_ _N_ #-}
+ (<) = { _A_ 2 _U_ 11 _N_ _S_ "EE" _N_ _N_ },
+ (<=) = { _A_ 2 _U_ 11 _N_ _S_ "EE" _N_ _N_ },
+ (>=) = { _A_ 2 _U_ 11 _N_ _S_ "EE" _N_ _N_ },
+ (>) = { _A_ 2 _U_ 11 _N_ _S_ "EE" _N_ _N_ },
+ max = { _A_ 2 _U_ 22 _N_ _S_ "EE" _N_ _N_ },
+ min = { _A_ 2 _U_ 22 _N_ _S_ "EE" _N_ _N_ },
+ _tagCmp = { _A_ 2 _U_ 11 _N_ _S_ "EE" _N_ _N_ } #-}
instance Text Bool
{-# GHC_PRAGMA _M_ PreludeCore {-dfun-} _A_ 0 _N_ _N_ _N_ _F_ _IF_ARGS_ 0 0 X 5 _!_ _TUP_4 [(Int -> [Char] -> [(Bool, [Char])]), (Int -> Bool -> [Char] -> [Char]), ([Char] -> [([Bool], [Char])]), ([Bool] -> [Char] -> [Char])] [_CONSTM_ Text readsPrec (Bool), _CONSTM_ Text showsPrec (Bool), _CONSTM_ Text readList (Bool), _CONSTM_ Text showList (Bool)] _N_
- readsPrec = _A_ 2 _U_ 02 _N_ _S_ "AL" {_A_ 1 _U_ 2 _N_ _N_ _N_ _N_} _N_ _N_,
- showsPrec = _A_ 3 _U_ 012 _N_ _S_ "AEL" {_A_ 2 _U_ 12 _N_ _N_ _N_ _N_} _N_ _N_,
- readList = _A_ 0 _U_ 2 _N_ _N_ _N_ _N_,
- showList = _A_ 0 _U_ 12 _N_ _N_ _N_ _N_ #-}
+ readsPrec = { _A_ 2 _U_ 02 _N_ _S_ "AL" {_A_ 1 _U_ 2 _N_ _N_ _N_ _N_} _N_ _N_ },
+ showsPrec = { _A_ 3 _U_ 012 _N_ _S_ "AEL" {_A_ 2 _U_ 12 _N_ _N_ _N_ _N_} _N_ _N_ },
+ readList = { _A_ 0 _U_ 2 _N_ _N_ _N_ _N_ },
+ showList = { _A_ 1 _U_ 12 _N_ _N_ _F_ _IF_ARGS_ 0 1 X 3 \ (u0 :: [Bool]) -> _APP_ _TYAPP_ _ORIG_ PreludeCore _showList { Bool } [ _WRKR_ _CONSTM_ Text showsPrec (Bool), u0 ] _N_ } #-}
-{-# GHC_PRAGMA INTERFACE VERSION 5 #-}
+{-# GHC_PRAGMA INTERFACE VERSION 6 #-}
interface PreludeCore where
instance Enum Bool
{-# GHC_PRAGMA _M_ PreludeCore {-dfun-} _A_ 0 _N_ _N_ _N_ _F_ _IF_ARGS_ 0 0 X 6 _!_ _TUP_5 [{{Ord Bool}}, (Bool -> [Bool]), (Bool -> Bool -> [Bool]), (Bool -> Bool -> [Bool]), (Bool -> Bool -> Bool -> [Bool])] [_DFUN_ Ord (Bool), _CONSTM_ Enum enumFrom (Bool), _CONSTM_ Enum enumFromThen (Bool), _CONSTM_ Enum enumFromTo (Bool), _CONSTM_ Enum enumFromThenTo (Bool)] _N_
- enumFrom = _A_ 1 _U_ 2 _N_ _S_ "E" _N_ _N_,
- enumFromThen = _A_ 2 _U_ 22 _N_ _S_ "EE" _N_ _N_,
- enumFromTo = _A_ 2 _U_ 22 _N_ _N_ _N_ _N_,
- enumFromThenTo = _A_ 3 _U_ 222 _N_ _N_ _N_ _N_ #-}
+ enumFrom = { _A_ 1 _U_ 2 _N_ _S_ "E" _N_ _N_ },
+ enumFromThen = { _A_ 2 _U_ 22 _N_ _S_ "EE" _N_ _N_ },
+ enumFromTo = { _A_ 2 _U_ 22 _N_ _S_ "EL" _N_ _N_ },
+ enumFromThenTo = { _A_ 3 _U_ 222 _N_ _S_ "EEL" _N_ _N_ } #-}
instance Eq Bool
{-# GHC_PRAGMA _M_ PreludeCore {-dfun-} _A_ 0 _N_ _N_ _N_ _F_ _IF_ARGS_ 0 0 X 3 _!_ _TUP_2 [(Bool -> Bool -> Bool), (Bool -> Bool -> Bool)] [_CONSTM_ Eq (==) (Bool), _CONSTM_ Eq (/=) (Bool)] _N_
- (==) = _A_ 2 _U_ 11 _N_ _S_ "EE" _F_ _IF_ARGS_ 0 2 CC 7 \ (u0 :: Bool) (u1 :: Bool) -> case u0 of { _ALG_ True -> u1; False -> case u1 of { _ALG_ True -> _!_ False [] []; False -> _!_ True [] []; _NO_DEFLT_ }; _NO_DEFLT_ } _N_,
- (/=) = _A_ 2 _U_ 11 _N_ _S_ "EE" _F_ _IF_ARGS_ 0 2 CC 7 \ (u0 :: Bool) (u1 :: Bool) -> case u0 of { _ALG_ True -> case u1 of { _ALG_ True -> _!_ False [] []; False -> _!_ True [] []; _NO_DEFLT_ }; False -> u1; _NO_DEFLT_ } _N_ #-}
+ (==) = { _A_ 2 _U_ 11 _N_ _S_ "EE" _F_ _IF_ARGS_ 0 2 CC 7 \ (u0 :: Bool) (u1 :: Bool) -> case u0 of { _ALG_ True -> u1; False -> case u1 of { _ALG_ True -> _!_ False [] []; False -> _!_ True [] []; _NO_DEFLT_ }; _NO_DEFLT_ } _N_ },
+ (/=) = { _A_ 2 _U_ 11 _N_ _S_ "EE" _F_ _IF_ARGS_ 0 2 CC 7 \ (u0 :: Bool) (u1 :: Bool) -> case u0 of { _ALG_ True -> case u1 of { _ALG_ True -> _!_ False [] []; False -> _!_ True [] []; _NO_DEFLT_ }; False -> u1; _NO_DEFLT_ } _N_ } #-}
instance Ix Bool
{-# GHC_PRAGMA _M_ PreludeCore {-dfun-} _A_ 0 _N_ _N_ _N_ _F_ _IF_ARGS_ 0 0 X 5 _!_ _TUP_4 [{{Ord Bool}}, ((Bool, Bool) -> [Bool]), ((Bool, Bool) -> Bool -> Int), ((Bool, Bool) -> Bool -> Bool)] [_DFUN_ Ord (Bool), _CONSTM_ Ix range (Bool), _CONSTM_ Ix index (Bool), _CONSTM_ Ix inRange (Bool)] _N_
- range = _A_ 1 _U_ 1 _N_ _S_ "U(EE)" {_A_ 2 _U_ 11 _N_ _N_ _N_ _N_} _N_ _N_,
- index = _A_ 2 _U_ 11 _N_ _S_ "U(EA)E" {_A_ 2 _U_ 11 _N_ _N_ _N_ _N_} _N_ _N_,
- inRange = _A_ 2 _U_ 12 _N_ _S_ "U(EL)E" {_A_ 3 _U_ 112 _N_ _N_ _N_ _N_} _N_ _N_ #-}
+ range = { _A_ 1 _U_ 1 _N_ _S_ "U(EE)" {_A_ 2 _U_ 11 _N_ _N_ _N_ _N_} _N_ _N_ },
+ index = { _A_ 2 _U_ 11 _N_ _S_ "U(EA)E" {_A_ 2 _U_ 11 _N_ _N_ _N_ _N_} _N_ _N_ },
+ inRange = { _A_ 2 _U_ 12 _N_ _S_ "U(EL)E" {_A_ 3 _U_ 112 _N_ _N_ _N_ _N_} _N_ _N_ } #-}
instance Ord Bool
{-# GHC_PRAGMA _M_ PreludeCore {-dfun-} _A_ 0 _N_ _N_ _N_ _F_ _IF_ARGS_ 0 0 X 9 _!_ _TUP_8 [{{Eq Bool}}, (Bool -> Bool -> Bool), (Bool -> Bool -> Bool), (Bool -> Bool -> Bool), (Bool -> Bool -> Bool), (Bool -> Bool -> Bool), (Bool -> Bool -> Bool), (Bool -> Bool -> _CMP_TAG)] [_DFUN_ Eq (Bool), _CONSTM_ Ord (<) (Bool), _CONSTM_ Ord (<=) (Bool), _CONSTM_ Ord (>=) (Bool), _CONSTM_ Ord (>) (Bool), _CONSTM_ Ord max (Bool), _CONSTM_ Ord min (Bool), _CONSTM_ Ord _tagCmp (Bool)] _N_
- (<) = _A_ 2 _U_ 11 _N_ _S_ "EE" _N_ _N_,
- (<=) = _A_ 2 _U_ 11 _N_ _S_ "EE" _N_ _N_,
- (>=) = _A_ 2 _U_ 11 _N_ _S_ "EE" _N_ _N_,
- (>) = _A_ 2 _U_ 11 _N_ _S_ "EE" _N_ _N_,
- max = _A_ 2 _U_ 22 _N_ _S_ "EE" _N_ _N_,
- min = _A_ 2 _U_ 22 _N_ _S_ "EE" _N_ _N_,
- _tagCmp = _A_ 2 _U_ 11 _N_ _S_ "EE" _N_ _N_ #-}
+ (<) = { _A_ 2 _U_ 11 _N_ _S_ "EE" _N_ _N_ },
+ (<=) = { _A_ 2 _U_ 11 _N_ _S_ "EE" _N_ _N_ },
+ (>=) = { _A_ 2 _U_ 11 _N_ _S_ "EE" _N_ _N_ },
+ (>) = { _A_ 2 _U_ 11 _N_ _S_ "EE" _N_ _N_ },
+ max = { _A_ 2 _U_ 22 _N_ _S_ "EE" _N_ _N_ },
+ min = { _A_ 2 _U_ 22 _N_ _S_ "EE" _N_ _N_ },
+ _tagCmp = { _A_ 2 _U_ 11 _N_ _S_ "EE" _N_ _N_ } #-}
instance Text Bool
{-# GHC_PRAGMA _M_ PreludeCore {-dfun-} _A_ 0 _N_ _N_ _N_ _F_ _IF_ARGS_ 0 0 X 5 _!_ _TUP_4 [(Int -> [Char] -> [(Bool, [Char])]), (Int -> Bool -> [Char] -> [Char]), ([Char] -> [([Bool], [Char])]), ([Bool] -> [Char] -> [Char])] [_CONSTM_ Text readsPrec (Bool), _CONSTM_ Text showsPrec (Bool), _CONSTM_ Text readList (Bool), _CONSTM_ Text showList (Bool)] _N_
- readsPrec = _A_ 2 _U_ 02 _N_ _S_ "AL" {_A_ 1 _U_ 2 _N_ _N_ _N_ _N_} _N_ _N_,
- showsPrec = _A_ 3 _U_ 012 _N_ _S_ "AEL" {_A_ 2 _U_ 12 _N_ _N_ _N_ _N_} _N_ _N_,
- readList = _A_ 0 _U_ 2 _N_ _N_ _N_ _N_,
- showList = _A_ 0 _U_ 12 _N_ _N_ _N_ _N_ #-}
+ readsPrec = { _A_ 2 _U_ 02 _N_ _S_ "AL" {_A_ 1 _U_ 2 _N_ _N_ _N_ _N_} _N_ _N_ },
+ showsPrec = { _A_ 3 _U_ 012 _N_ _S_ "AEL" {_A_ 2 _U_ 12 _N_ _N_ _N_ _N_} _N_ _N_ },
+ readList = { _A_ 0 _U_ 2 _N_ _N_ _N_ _N_ },
+ showList = { _A_ 1 _U_ 12 _N_ _N_ _F_ _IF_ARGS_ 0 1 X 3 \ (u0 :: [Bool]) -> _APP_ _TYAPP_ _ORIG_ PreludeCore _showList { Bool } [ _WRKR_ _CONSTM_ Text showsPrec (Bool), u0 ] _N_ } #-}
-{-# GHC_PRAGMA INTERFACE VERSION 5 #-}
+{-# GHC_PRAGMA INTERFACE VERSION 6 #-}
interface PreludeCore where
import PreludeBuiltin(Char(..))
instance Enum Char
{-# GHC_PRAGMA _M_ PreludeCore {-dfun-} _A_ 0 _N_ _N_ _N_ _F_ _IF_ARGS_ 0 0 X 6 _!_ _TUP_5 [{{Ord Char}}, (Char -> [Char]), (Char -> Char -> [Char]), (Char -> Char -> [Char]), (Char -> Char -> Char -> [Char])] [_DFUN_ Ord (Char), _CONSTM_ Enum enumFrom (Char), _CONSTM_ Enum enumFromThen (Char), _CONSTM_ Enum enumFromTo (Char), _CONSTM_ Enum enumFromThenTo (Char)] _N_
- enumFrom = _A_ 1 _U_ 1 _N_ _S_ "U(P)" {_A_ 1 _U_ 2 _N_ _N_ _N_ _N_} _N_ _N_,
- enumFromThen = _A_ 2 _U_ 22 _N_ _N_ _N_ _N_,
- enumFromTo = _A_ 2 _U_ 22 _N_ _N_ _N_ _N_,
- enumFromThenTo = _A_ 3 _U_ 222 _N_ _N_ _N_ _N_ #-}
+ enumFrom = { _A_ 1 _U_ 1 _N_ _S_ "U(P)" {_A_ 1 _U_ 2 _N_ _N_ _N_ _N_} _N_ _N_ },
+ enumFromThen = { _A_ 2 _U_ 22 _N_ _N_ _N_ _N_ },
+ enumFromTo = { _A_ 2 _U_ 12 _N_ _S_ "U(P)L" {_A_ 2 _U_ 22 _N_ _N_ _N_ _N_} _N_ _N_ },
+ enumFromThenTo = { _A_ 3 _U_ 222 _N_ _N_ _N_ _N_ } #-}
instance Eq Char
{-# GHC_PRAGMA _M_ PreludeCore {-dfun-} _A_ 0 _N_ _N_ _N_ _F_ _IF_ARGS_ 0 0 X 3 _!_ _TUP_2 [(Char -> Char -> Bool), (Char -> Char -> Bool)] [_CONSTM_ Eq (==) (Char), _CONSTM_ Eq (/=) (Char)] _N_
- (==) = _A_ 2 _U_ 11 _N_ _S_ "U(P)U(P)" {_A_ 2 _U_ 22 _N_ _N_ _F_ _IF_ARGS_ 0 2 XX 1 \ (u0 :: Char#) (u1 :: Char#) -> _#_ eqChar# [] [u0, u1] _N_} _F_ _IF_ARGS_ 0 2 CC 3 \ (u0 :: Char) (u1 :: Char) -> case u0 of { _ALG_ C# (u2 :: Char#) -> case u1 of { _ALG_ C# (u3 :: Char#) -> _#_ eqChar# [] [u2, u3]; _NO_DEFLT_ }; _NO_DEFLT_ } _N_,
- (/=) = _A_ 2 _U_ 11 _N_ _S_ "U(P)U(P)" {_A_ 2 _U_ 22 _N_ _N_ _F_ _IF_ARGS_ 0 2 XX 1 \ (u0 :: Char#) (u1 :: Char#) -> _#_ neChar# [] [u0, u1] _N_} _F_ _IF_ARGS_ 0 2 CC 3 \ (u0 :: Char) (u1 :: Char) -> case u0 of { _ALG_ C# (u2 :: Char#) -> case u1 of { _ALG_ C# (u3 :: Char#) -> _#_ neChar# [] [u2, u3]; _NO_DEFLT_ }; _NO_DEFLT_ } _N_ #-}
+ (==) = { _A_ 2 _U_ 11 _N_ _S_ "U(P)U(P)" {_A_ 2 _U_ 22 _N_ _N_ _F_ _IF_ARGS_ 0 2 XX 1 \ (u0 :: Char#) (u1 :: Char#) -> _#_ eqChar# [] [u0, u1] _N_} _F_ _IF_ARGS_ 0 2 CC 3 \ (u0 :: Char) (u1 :: Char) -> case u0 of { _ALG_ C# (u2 :: Char#) -> case u1 of { _ALG_ C# (u3 :: Char#) -> _#_ eqChar# [] [u2, u3]; _NO_DEFLT_ }; _NO_DEFLT_ } _N_ },
+ (/=) = { _A_ 2 _U_ 11 _N_ _S_ "U(P)U(P)" {_A_ 2 _U_ 22 _N_ _N_ _F_ _IF_ARGS_ 0 2 XX 1 \ (u0 :: Char#) (u1 :: Char#) -> _#_ neChar# [] [u0, u1] _N_} _F_ _IF_ARGS_ 0 2 CC 3 \ (u0 :: Char) (u1 :: Char) -> case u0 of { _ALG_ C# (u2 :: Char#) -> case u1 of { _ALG_ C# (u3 :: Char#) -> _#_ neChar# [] [u2, u3]; _NO_DEFLT_ }; _NO_DEFLT_ } _N_ } #-}
instance Ix Char
{-# GHC_PRAGMA _M_ PreludeCore {-dfun-} _A_ 0 _N_ _N_ _N_ _F_ _IF_ARGS_ 0 0 X 5 _!_ _TUP_4 [{{Ord Char}}, ((Char, Char) -> [Char]), ((Char, Char) -> Char -> Int), ((Char, Char) -> Char -> Bool)] [_DFUN_ Ord (Char), _CONSTM_ Ix range (Char), _CONSTM_ Ix index (Char), _CONSTM_ Ix inRange (Char)] _N_
- range = _A_ 1 _U_ 1 _N_ _S_ "U(LL)" {_A_ 2 _U_ 22 _N_ _N_ _F_ _IF_ARGS_ 0 0 X 1 _CONSTM_ Enum enumFromTo (Char) _N_} _F_ _IF_ARGS_ 0 1 C 4 \ (u0 :: (Char, Char)) -> case u0 of { _ALG_ _TUP_2 (u1 :: Char) (u2 :: Char) -> _APP_ _CONSTM_ Enum enumFromTo (Char) [ u1, u2 ]; _NO_DEFLT_ } _N_,
- index = _A_ 2 _U_ 11 _N_ _S_ "U(U(P)L)U(P)" {_A_ 3 _U_ 212 _N_ _N_ _N_ _N_} _N_ _N_,
- inRange = _A_ 2 _U_ 11 _N_ _S_ "U(U(P)L)U(P)" {_A_ 3 _U_ 212 _N_ _N_ _N_ _N_} _N_ _N_ #-}
+ range = { _A_ 1 _U_ 1 _N_ _S_ "U(U(P)L)" {_A_ 2 _U_ 22 _N_ _N_ _N_ _N_} _F_ _IF_ARGS_ 0 1 C 4 \ (u0 :: (Char, Char)) -> case u0 of { _ALG_ _TUP_2 (u1 :: Char) (u2 :: Char) -> _APP_ _CONSTM_ Enum enumFromTo (Char) [ u1, u2 ]; _NO_DEFLT_ } _N_ },
+ index = { _A_ 2 _U_ 11 _N_ _S_ "U(U(P)L)U(P)" {_A_ 3 _U_ 212 _N_ _N_ _N_ _N_} _N_ _N_ },
+ inRange = { _A_ 2 _U_ 11 _N_ _S_ "U(U(P)L)U(P)" {_A_ 3 _U_ 212 _N_ _N_ _N_ _N_} _N_ _N_ } #-}
instance Ord Char
{-# GHC_PRAGMA _M_ PreludeCore {-dfun-} _A_ 0 _N_ _N_ _N_ _F_ _IF_ARGS_ 0 0 X 9 _!_ _TUP_8 [{{Eq Char}}, (Char -> Char -> Bool), (Char -> Char -> Bool), (Char -> Char -> Bool), (Char -> Char -> Bool), (Char -> Char -> Char), (Char -> Char -> Char), (Char -> Char -> _CMP_TAG)] [_DFUN_ Eq (Char), _CONSTM_ Ord (<) (Char), _CONSTM_ Ord (<=) (Char), _CONSTM_ Ord (>=) (Char), _CONSTM_ Ord (>) (Char), _CONSTM_ Ord max (Char), _CONSTM_ Ord min (Char), _CONSTM_ Ord _tagCmp (Char)] _N_
- (<) = _A_ 2 _U_ 11 _N_ _S_ "U(P)U(P)" {_A_ 2 _U_ 22 _N_ _N_ _F_ _IF_ARGS_ 0 2 XX 1 \ (u0 :: Char#) (u1 :: Char#) -> _#_ ltChar# [] [u0, u1] _N_} _F_ _IF_ARGS_ 0 2 CC 3 \ (u0 :: Char) (u1 :: Char) -> case u0 of { _ALG_ C# (u2 :: Char#) -> case u1 of { _ALG_ C# (u3 :: Char#) -> _#_ ltChar# [] [u2, u3]; _NO_DEFLT_ }; _NO_DEFLT_ } _N_,
- (<=) = _A_ 2 _U_ 11 _N_ _S_ "U(P)U(P)" {_A_ 2 _U_ 22 _N_ _N_ _F_ _IF_ARGS_ 0 2 XX 1 \ (u0 :: Char#) (u1 :: Char#) -> _#_ leChar# [] [u0, u1] _N_} _F_ _IF_ARGS_ 0 2 CC 3 \ (u0 :: Char) (u1 :: Char) -> case u0 of { _ALG_ C# (u2 :: Char#) -> case u1 of { _ALG_ C# (u3 :: Char#) -> _#_ leChar# [] [u2, u3]; _NO_DEFLT_ }; _NO_DEFLT_ } _N_,
- (>=) = _A_ 2 _U_ 11 _N_ _S_ "U(P)U(P)" {_A_ 2 _U_ 22 _N_ _N_ _F_ _IF_ARGS_ 0 2 XX 1 \ (u0 :: Char#) (u1 :: Char#) -> _#_ geChar# [] [u0, u1] _N_} _F_ _IF_ARGS_ 0 2 CC 3 \ (u0 :: Char) (u1 :: Char) -> case u0 of { _ALG_ C# (u2 :: Char#) -> case u1 of { _ALG_ C# (u3 :: Char#) -> _#_ geChar# [] [u2, u3]; _NO_DEFLT_ }; _NO_DEFLT_ } _N_,
- (>) = _A_ 2 _U_ 11 _N_ _S_ "U(P)U(P)" {_A_ 2 _U_ 22 _N_ _N_ _F_ _IF_ARGS_ 0 2 XX 1 \ (u0 :: Char#) (u1 :: Char#) -> _#_ gtChar# [] [u0, u1] _N_} _F_ _IF_ARGS_ 0 2 CC 3 \ (u0 :: Char) (u1 :: Char) -> case u0 of { _ALG_ C# (u2 :: Char#) -> case u1 of { _ALG_ C# (u3 :: Char#) -> _#_ gtChar# [] [u2, u3]; _NO_DEFLT_ }; _NO_DEFLT_ } _N_,
- max = _A_ 2 _U_ 11 _N_ _S_ "U(P)U(P)" {_A_ 2 _U_ 22 _N_ _N_ _N_ _N_} _N_ _N_,
- min = _A_ 2 _U_ 11 _N_ _S_ "U(P)U(P)" {_A_ 2 _U_ 22 _N_ _N_ _N_ _N_} _N_ _N_,
- _tagCmp = _A_ 2 _U_ 11 _N_ _S_ "U(P)U(P)" {_A_ 2 _U_ 22 _N_ _N_ _N_ _N_} _N_ _N_ #-}
+ (<) = { _A_ 2 _U_ 11 _N_ _S_ "U(P)U(P)" {_A_ 2 _U_ 22 _N_ _N_ _F_ _IF_ARGS_ 0 2 XX 1 \ (u0 :: Char#) (u1 :: Char#) -> _#_ ltChar# [] [u0, u1] _N_} _F_ _IF_ARGS_ 0 2 CC 3 \ (u0 :: Char) (u1 :: Char) -> case u0 of { _ALG_ C# (u2 :: Char#) -> case u1 of { _ALG_ C# (u3 :: Char#) -> _#_ ltChar# [] [u2, u3]; _NO_DEFLT_ }; _NO_DEFLT_ } _N_ },
+ (<=) = { _A_ 2 _U_ 11 _N_ _S_ "U(P)U(P)" {_A_ 2 _U_ 22 _N_ _N_ _F_ _IF_ARGS_ 0 2 XX 1 \ (u0 :: Char#) (u1 :: Char#) -> _#_ leChar# [] [u0, u1] _N_} _F_ _IF_ARGS_ 0 2 CC 3 \ (u0 :: Char) (u1 :: Char) -> case u0 of { _ALG_ C# (u2 :: Char#) -> case u1 of { _ALG_ C# (u3 :: Char#) -> _#_ leChar# [] [u2, u3]; _NO_DEFLT_ }; _NO_DEFLT_ } _N_ },
+ (>=) = { _A_ 2 _U_ 11 _N_ _S_ "U(P)U(P)" {_A_ 2 _U_ 22 _N_ _N_ _F_ _IF_ARGS_ 0 2 XX 1 \ (u0 :: Char#) (u1 :: Char#) -> _#_ geChar# [] [u0, u1] _N_} _F_ _IF_ARGS_ 0 2 CC 3 \ (u0 :: Char) (u1 :: Char) -> case u0 of { _ALG_ C# (u2 :: Char#) -> case u1 of { _ALG_ C# (u3 :: Char#) -> _#_ geChar# [] [u2, u3]; _NO_DEFLT_ }; _NO_DEFLT_ } _N_ },
+ (>) = { _A_ 2 _U_ 11 _N_ _S_ "U(P)U(P)" {_A_ 2 _U_ 22 _N_ _N_ _F_ _IF_ARGS_ 0 2 XX 1 \ (u0 :: Char#) (u1 :: Char#) -> _#_ gtChar# [] [u0, u1] _N_} _F_ _IF_ARGS_ 0 2 CC 3 \ (u0 :: Char) (u1 :: Char) -> case u0 of { _ALG_ C# (u2 :: Char#) -> case u1 of { _ALG_ C# (u3 :: Char#) -> _#_ gtChar# [] [u2, u3]; _NO_DEFLT_ }; _NO_DEFLT_ } _N_ },
+ max = { _A_ 2 _U_ 11 _N_ _S_ "U(P)U(P)" {_A_ 2 _U_ 22 _N_ _N_ _N_ _N_} _N_ _N_ },
+ min = { _A_ 2 _U_ 11 _N_ _S_ "U(P)U(P)" {_A_ 2 _U_ 22 _N_ _N_ _N_ _N_} _N_ _N_ },
+ _tagCmp = { _A_ 2 _U_ 11 _N_ _S_ "U(P)U(P)" {_A_ 2 _U_ 22 _N_ _N_ _N_ _N_} _N_ _N_ } #-}
instance Text Char
{-# GHC_PRAGMA _M_ PreludeCore {-dfun-} _A_ 0 _N_ _N_ _N_ _F_ _IF_ARGS_ 0 0 X 5 _!_ _TUP_4 [(Int -> [Char] -> [(Char, [Char])]), (Int -> Char -> [Char] -> [Char]), ([Char] -> [([Char], [Char])]), ([Char] -> [Char] -> [Char])] [_CONSTM_ Text readsPrec (Char), _CONSTM_ Text showsPrec (Char), _CONSTM_ Text readList (Char), _CONSTM_ Text showList (Char)] _N_
- readsPrec = _A_ 1 _U_ 02 _N_ _S_ "A" {_A_ 0 _U_ 2 _N_ _N_ _N_ _N_} _N_ _N_,
- showsPrec = _A_ 3 _U_ 012 _N_ _S_ "AU(P)L" {_A_ 2 _U_ 22 _N_ _N_ _N_ _N_} _N_ _N_,
- readList = _A_ 0 _U_ 2 _N_ _N_ _N_ _N_,
- showList = _A_ 1 _U_ 22 _N_ _N_ _N_ _N_ #-}
+ readsPrec = { _A_ 1 _U_ 02 _N_ _S_ "A" {_A_ 0 _U_ 2 _N_ _N_ _N_ _N_} _N_ _N_ },
+ showsPrec = { _A_ 3 _U_ 012 _N_ _S_ "AU(P)L" {_A_ 2 _U_ 22 _N_ _N_ _N_ _N_} _N_ _N_ },
+ readList = { _A_ 0 _U_ 2 _N_ _N_ _N_ _N_ },
+ showList = { _A_ 1 _U_ 22 _N_ _N_ _N_ _N_ } #-}
instance _CCallable Char
{-# GHC_PRAGMA _M_ PreludeCore {-dfun-} _A_ 0 _N_ _N_ _N_ _F_ _IF_ARGS_ 0 0 X 1 _!_ _TUP_0 [] [] _N_ #-}
instance _CReturnable Char
import Core
import IInt
import IList
-import List ( map, (++), foldr )
+import List ( (++), map, takeWhile )
import PS ( _PackedString, _unpackPS )
import Text
+import TyArray
+import TyComplex
gtChar (C# x) (C# y) = gtChar# x y
geChar (C# x) (C# y) = geChar# x y
where i = ord ci
instance Enum Char where
- enumFrom c = map chr [ord c .. ord maxChar]
- enumFromThen c c' = map chr [ord c, ord c' .. ord lastChar]
- where lastChar = if c' < c then minChar else maxChar
+ enumFrom c = map chr [ord c .. ord maxChar]
+ enumFromThen c c' = map chr [ord c, ord c' .. ord lastChar]
+ where lastChar = if c' < c then minChar else maxChar
+ enumFromTo n m = takeWhile (<= m) (enumFrom n)
+ enumFromThenTo n m p = takeWhile (if m >= n then (<= p) else (>= p))
+ (enumFromThen n m)
instance Text Char where
readsPrec p = readParen False
enumFrom c = map chr# [ord# c .. ord# '\255'#]
enumFromThen c c' = map chr# [ord# c, ord# c' .. ord# lastChar#]
where lastChar# = if c' < c then '\0'# else '\255'#
- -- default methods not specialised!
enumFromTo n m = takeWhile (<= m) (enumFrom n)
enumFromThenTo n m p = takeWhile (if m >= n then (<= p) else (>= p))
(enumFromThen n m)
instance Text Char# where
readsPrec p s = map (\ (C# c#, s) -> (c#, s)) (readsPrec p s)
showsPrec p c = showsPrec p (C# c)
- readList s = map (\ (x, s) -> (map (\ (C# c#) -> c#) x, s)) (readList s)
- showList l = showList (map C# l)
+ readList = _readList (readsPrec 0)
+ showList = _showList (showsPrec 0)
instance _CCallable Char#
instance _CReturnable Char#
-{-# GHC_PRAGMA INTERFACE VERSION 5 #-}
+{-# GHC_PRAGMA INTERFACE VERSION 6 #-}
interface PreludeCore where
import PreludeBuiltin(Char(..))
instance Enum Char
{-# GHC_PRAGMA _M_ PreludeCore {-dfun-} _A_ 0 _N_ _N_ _N_ _F_ _IF_ARGS_ 0 0 X 6 _!_ _TUP_5 [{{Ord Char}}, (Char -> [Char]), (Char -> Char -> [Char]), (Char -> Char -> [Char]), (Char -> Char -> Char -> [Char])] [_DFUN_ Ord (Char), _CONSTM_ Enum enumFrom (Char), _CONSTM_ Enum enumFromThen (Char), _CONSTM_ Enum enumFromTo (Char), _CONSTM_ Enum enumFromThenTo (Char)] _N_
- enumFrom = _A_ 1 _U_ 1 _N_ _S_ "U(P)" {_A_ 1 _U_ 2 _N_ _N_ _N_ _N_} _N_ _N_,
- enumFromThen = _A_ 2 _U_ 22 _N_ _N_ _N_ _N_,
- enumFromTo = _A_ 2 _U_ 22 _N_ _N_ _N_ _N_,
- enumFromThenTo = _A_ 3 _U_ 222 _N_ _N_ _N_ _N_ #-}
+ enumFrom = { _A_ 1 _U_ 1 _N_ _S_ "U(P)" {_A_ 1 _U_ 2 _N_ _N_ _N_ _N_} _N_ _N_ },
+ enumFromThen = { _A_ 2 _U_ 22 _N_ _N_ _N_ _N_ },
+ enumFromTo = { _A_ 2 _U_ 12 _N_ _S_ "U(P)L" {_A_ 2 _U_ 22 _N_ _N_ _N_ _N_} _N_ _N_ },
+ enumFromThenTo = { _A_ 3 _U_ 222 _N_ _N_ _N_ _N_ } #-}
instance Eq Char
{-# GHC_PRAGMA _M_ PreludeCore {-dfun-} _A_ 0 _N_ _N_ _N_ _F_ _IF_ARGS_ 0 0 X 3 _!_ _TUP_2 [(Char -> Char -> Bool), (Char -> Char -> Bool)] [_CONSTM_ Eq (==) (Char), _CONSTM_ Eq (/=) (Char)] _N_
- (==) = _A_ 2 _U_ 11 _N_ _S_ "U(P)U(P)" {_A_ 2 _U_ 22 _N_ _N_ _F_ _IF_ARGS_ 0 2 XX 1 \ (u0 :: Char#) (u1 :: Char#) -> _#_ eqChar# [] [u0, u1] _N_} _F_ _IF_ARGS_ 0 2 CC 3 \ (u0 :: Char) (u1 :: Char) -> case u0 of { _ALG_ C# (u2 :: Char#) -> case u1 of { _ALG_ C# (u3 :: Char#) -> _#_ eqChar# [] [u2, u3]; _NO_DEFLT_ }; _NO_DEFLT_ } _N_,
- (/=) = _A_ 2 _U_ 11 _N_ _S_ "U(P)U(P)" {_A_ 2 _U_ 22 _N_ _N_ _F_ _IF_ARGS_ 0 2 XX 1 \ (u0 :: Char#) (u1 :: Char#) -> _#_ neChar# [] [u0, u1] _N_} _F_ _IF_ARGS_ 0 2 CC 3 \ (u0 :: Char) (u1 :: Char) -> case u0 of { _ALG_ C# (u2 :: Char#) -> case u1 of { _ALG_ C# (u3 :: Char#) -> _#_ neChar# [] [u2, u3]; _NO_DEFLT_ }; _NO_DEFLT_ } _N_ #-}
+ (==) = { _A_ 2 _U_ 11 _N_ _S_ "U(P)U(P)" {_A_ 2 _U_ 22 _N_ _N_ _F_ _IF_ARGS_ 0 2 XX 1 \ (u0 :: Char#) (u1 :: Char#) -> _#_ eqChar# [] [u0, u1] _N_} _F_ _IF_ARGS_ 0 2 CC 3 \ (u0 :: Char) (u1 :: Char) -> case u0 of { _ALG_ C# (u2 :: Char#) -> case u1 of { _ALG_ C# (u3 :: Char#) -> _#_ eqChar# [] [u2, u3]; _NO_DEFLT_ }; _NO_DEFLT_ } _N_ },
+ (/=) = { _A_ 2 _U_ 11 _N_ _S_ "U(P)U(P)" {_A_ 2 _U_ 22 _N_ _N_ _F_ _IF_ARGS_ 0 2 XX 1 \ (u0 :: Char#) (u1 :: Char#) -> _#_ neChar# [] [u0, u1] _N_} _F_ _IF_ARGS_ 0 2 CC 3 \ (u0 :: Char) (u1 :: Char) -> case u0 of { _ALG_ C# (u2 :: Char#) -> case u1 of { _ALG_ C# (u3 :: Char#) -> _#_ neChar# [] [u2, u3]; _NO_DEFLT_ }; _NO_DEFLT_ } _N_ } #-}
instance Ix Char
{-# GHC_PRAGMA _M_ PreludeCore {-dfun-} _A_ 0 _N_ _N_ _N_ _F_ _IF_ARGS_ 0 0 X 5 _!_ _TUP_4 [{{Ord Char}}, ((Char, Char) -> [Char]), ((Char, Char) -> Char -> Int), ((Char, Char) -> Char -> Bool)] [_DFUN_ Ord (Char), _CONSTM_ Ix range (Char), _CONSTM_ Ix index (Char), _CONSTM_ Ix inRange (Char)] _N_
- range = _A_ 1 _U_ 1 _N_ _S_ "U(LL)" {_A_ 2 _U_ 22 _N_ _N_ _F_ _IF_ARGS_ 0 0 X 1 _CONSTM_ Enum enumFromTo (Char) _N_} _F_ _IF_ARGS_ 0 1 C 4 \ (u0 :: (Char, Char)) -> case u0 of { _ALG_ _TUP_2 (u1 :: Char) (u2 :: Char) -> _APP_ _CONSTM_ Enum enumFromTo (Char) [ u1, u2 ]; _NO_DEFLT_ } _N_,
- index = _A_ 2 _U_ 11 _N_ _S_ "U(U(P)L)U(P)" {_A_ 3 _U_ 212 _N_ _N_ _N_ _N_} _N_ _N_,
- inRange = _A_ 2 _U_ 11 _N_ _S_ "U(U(P)L)U(P)" {_A_ 3 _U_ 212 _N_ _N_ _N_ _N_} _N_ _N_ #-}
+ range = { _A_ 1 _U_ 1 _N_ _S_ "U(U(P)L)" {_A_ 2 _U_ 22 _N_ _N_ _N_ _N_} _F_ _IF_ARGS_ 0 1 C 4 \ (u0 :: (Char, Char)) -> case u0 of { _ALG_ _TUP_2 (u1 :: Char) (u2 :: Char) -> _APP_ _CONSTM_ Enum enumFromTo (Char) [ u1, u2 ]; _NO_DEFLT_ } _N_ },
+ index = { _A_ 2 _U_ 11 _N_ _S_ "U(U(P)L)U(P)" {_A_ 3 _U_ 212 _N_ _N_ _N_ _N_} _N_ _N_ },
+ inRange = { _A_ 2 _U_ 11 _N_ _S_ "U(U(P)L)U(P)" {_A_ 3 _U_ 212 _N_ _N_ _N_ _N_} _N_ _N_ } #-}
instance Ord Char
{-# GHC_PRAGMA _M_ PreludeCore {-dfun-} _A_ 0 _N_ _N_ _N_ _F_ _IF_ARGS_ 0 0 X 9 _!_ _TUP_8 [{{Eq Char}}, (Char -> Char -> Bool), (Char -> Char -> Bool), (Char -> Char -> Bool), (Char -> Char -> Bool), (Char -> Char -> Char), (Char -> Char -> Char), (Char -> Char -> _CMP_TAG)] [_DFUN_ Eq (Char), _CONSTM_ Ord (<) (Char), _CONSTM_ Ord (<=) (Char), _CONSTM_ Ord (>=) (Char), _CONSTM_ Ord (>) (Char), _CONSTM_ Ord max (Char), _CONSTM_ Ord min (Char), _CONSTM_ Ord _tagCmp (Char)] _N_
- (<) = _A_ 2 _U_ 11 _N_ _S_ "U(P)U(P)" {_A_ 2 _U_ 22 _N_ _N_ _F_ _IF_ARGS_ 0 2 XX 1 \ (u0 :: Char#) (u1 :: Char#) -> _#_ ltChar# [] [u0, u1] _N_} _F_ _IF_ARGS_ 0 2 CC 3 \ (u0 :: Char) (u1 :: Char) -> case u0 of { _ALG_ C# (u2 :: Char#) -> case u1 of { _ALG_ C# (u3 :: Char#) -> _#_ ltChar# [] [u2, u3]; _NO_DEFLT_ }; _NO_DEFLT_ } _N_,
- (<=) = _A_ 2 _U_ 11 _N_ _S_ "U(P)U(P)" {_A_ 2 _U_ 22 _N_ _N_ _F_ _IF_ARGS_ 0 2 XX 1 \ (u0 :: Char#) (u1 :: Char#) -> _#_ leChar# [] [u0, u1] _N_} _F_ _IF_ARGS_ 0 2 CC 3 \ (u0 :: Char) (u1 :: Char) -> case u0 of { _ALG_ C# (u2 :: Char#) -> case u1 of { _ALG_ C# (u3 :: Char#) -> _#_ leChar# [] [u2, u3]; _NO_DEFLT_ }; _NO_DEFLT_ } _N_,
- (>=) = _A_ 2 _U_ 11 _N_ _S_ "U(P)U(P)" {_A_ 2 _U_ 22 _N_ _N_ _F_ _IF_ARGS_ 0 2 XX 1 \ (u0 :: Char#) (u1 :: Char#) -> _#_ geChar# [] [u0, u1] _N_} _F_ _IF_ARGS_ 0 2 CC 3 \ (u0 :: Char) (u1 :: Char) -> case u0 of { _ALG_ C# (u2 :: Char#) -> case u1 of { _ALG_ C# (u3 :: Char#) -> _#_ geChar# [] [u2, u3]; _NO_DEFLT_ }; _NO_DEFLT_ } _N_,
- (>) = _A_ 2 _U_ 11 _N_ _S_ "U(P)U(P)" {_A_ 2 _U_ 22 _N_ _N_ _F_ _IF_ARGS_ 0 2 XX 1 \ (u0 :: Char#) (u1 :: Char#) -> _#_ gtChar# [] [u0, u1] _N_} _F_ _IF_ARGS_ 0 2 CC 3 \ (u0 :: Char) (u1 :: Char) -> case u0 of { _ALG_ C# (u2 :: Char#) -> case u1 of { _ALG_ C# (u3 :: Char#) -> _#_ gtChar# [] [u2, u3]; _NO_DEFLT_ }; _NO_DEFLT_ } _N_,
- max = _A_ 2 _U_ 11 _N_ _S_ "U(P)U(P)" {_A_ 2 _U_ 22 _N_ _N_ _N_ _N_} _N_ _N_,
- min = _A_ 2 _U_ 11 _N_ _S_ "U(P)U(P)" {_A_ 2 _U_ 22 _N_ _N_ _N_ _N_} _N_ _N_,
- _tagCmp = _A_ 2 _U_ 11 _N_ _S_ "U(P)U(P)" {_A_ 2 _U_ 22 _N_ _N_ _N_ _N_} _N_ _N_ #-}
+ (<) = { _A_ 2 _U_ 11 _N_ _S_ "U(P)U(P)" {_A_ 2 _U_ 22 _N_ _N_ _F_ _IF_ARGS_ 0 2 XX 1 \ (u0 :: Char#) (u1 :: Char#) -> _#_ ltChar# [] [u0, u1] _N_} _F_ _IF_ARGS_ 0 2 CC 3 \ (u0 :: Char) (u1 :: Char) -> case u0 of { _ALG_ C# (u2 :: Char#) -> case u1 of { _ALG_ C# (u3 :: Char#) -> _#_ ltChar# [] [u2, u3]; _NO_DEFLT_ }; _NO_DEFLT_ } _N_ },
+ (<=) = { _A_ 2 _U_ 11 _N_ _S_ "U(P)U(P)" {_A_ 2 _U_ 22 _N_ _N_ _F_ _IF_ARGS_ 0 2 XX 1 \ (u0 :: Char#) (u1 :: Char#) -> _#_ leChar# [] [u0, u1] _N_} _F_ _IF_ARGS_ 0 2 CC 3 \ (u0 :: Char) (u1 :: Char) -> case u0 of { _ALG_ C# (u2 :: Char#) -> case u1 of { _ALG_ C# (u3 :: Char#) -> _#_ leChar# [] [u2, u3]; _NO_DEFLT_ }; _NO_DEFLT_ } _N_ },
+ (>=) = { _A_ 2 _U_ 11 _N_ _S_ "U(P)U(P)" {_A_ 2 _U_ 22 _N_ _N_ _F_ _IF_ARGS_ 0 2 XX 1 \ (u0 :: Char#) (u1 :: Char#) -> _#_ geChar# [] [u0, u1] _N_} _F_ _IF_ARGS_ 0 2 CC 3 \ (u0 :: Char) (u1 :: Char) -> case u0 of { _ALG_ C# (u2 :: Char#) -> case u1 of { _ALG_ C# (u3 :: Char#) -> _#_ geChar# [] [u2, u3]; _NO_DEFLT_ }; _NO_DEFLT_ } _N_ },
+ (>) = { _A_ 2 _U_ 11 _N_ _S_ "U(P)U(P)" {_A_ 2 _U_ 22 _N_ _N_ _F_ _IF_ARGS_ 0 2 XX 1 \ (u0 :: Char#) (u1 :: Char#) -> _#_ gtChar# [] [u0, u1] _N_} _F_ _IF_ARGS_ 0 2 CC 3 \ (u0 :: Char) (u1 :: Char) -> case u0 of { _ALG_ C# (u2 :: Char#) -> case u1 of { _ALG_ C# (u3 :: Char#) -> _#_ gtChar# [] [u2, u3]; _NO_DEFLT_ }; _NO_DEFLT_ } _N_ },
+ max = { _A_ 2 _U_ 11 _N_ _S_ "U(P)U(P)" {_A_ 2 _U_ 22 _N_ _N_ _N_ _N_} _N_ _N_ },
+ min = { _A_ 2 _U_ 11 _N_ _S_ "U(P)U(P)" {_A_ 2 _U_ 22 _N_ _N_ _N_ _N_} _N_ _N_ },
+ _tagCmp = { _A_ 2 _U_ 11 _N_ _S_ "U(P)U(P)" {_A_ 2 _U_ 22 _N_ _N_ _N_ _N_} _N_ _N_ } #-}
instance Text Char
{-# GHC_PRAGMA _M_ PreludeCore {-dfun-} _A_ 0 _N_ _N_ _N_ _F_ _IF_ARGS_ 0 0 X 5 _!_ _TUP_4 [(Int -> [Char] -> [(Char, [Char])]), (Int -> Char -> [Char] -> [Char]), ([Char] -> [([Char], [Char])]), ([Char] -> [Char] -> [Char])] [_CONSTM_ Text readsPrec (Char), _CONSTM_ Text showsPrec (Char), _CONSTM_ Text readList (Char), _CONSTM_ Text showList (Char)] _N_
- readsPrec = _A_ 1 _U_ 02 _N_ _S_ "A" {_A_ 0 _U_ 2 _N_ _N_ _N_ _N_} _N_ _N_,
- showsPrec = _A_ 3 _U_ 012 _N_ _S_ "AU(P)L" {_A_ 2 _U_ 22 _N_ _N_ _N_ _N_} _N_ _N_,
- readList = _A_ 0 _U_ 2 _N_ _N_ _N_ _N_,
- showList = _A_ 1 _U_ 22 _N_ _N_ _N_ _N_ #-}
+ readsPrec = { _A_ 1 _U_ 02 _N_ _S_ "A" {_A_ 0 _U_ 2 _N_ _N_ _N_ _N_} _N_ _N_ },
+ showsPrec = { _A_ 3 _U_ 012 _N_ _S_ "AU(P)L" {_A_ 2 _U_ 22 _N_ _N_ _N_ _N_} _N_ _N_ },
+ readList = { _A_ 0 _U_ 2 _N_ _N_ _N_ _N_ },
+ showList = { _A_ 1 _U_ 22 _N_ _N_ _N_ _N_ } #-}
instance _CCallable Char
{-# GHC_PRAGMA _M_ PreludeCore {-dfun-} _A_ 0 _N_ _N_ _N_ _F_ _IF_ARGS_ 0 0 X 1 _!_ _TUP_0 [] [] _N_ #-}
instance _CReturnable Char
-{-# GHC_PRAGMA INTERFACE VERSION 5 #-}
+{-# GHC_PRAGMA INTERFACE VERSION 6 #-}
interface PreludeCore where
import PreludeBuiltin(Char(..))
instance Enum Char
{-# GHC_PRAGMA _M_ PreludeCore {-dfun-} _A_ 0 _N_ _N_ _N_ _F_ _IF_ARGS_ 0 0 X 6 _!_ _TUP_5 [{{Ord Char}}, (Char -> [Char]), (Char -> Char -> [Char]), (Char -> Char -> [Char]), (Char -> Char -> Char -> [Char])] [_DFUN_ Ord (Char), _CONSTM_ Enum enumFrom (Char), _CONSTM_ Enum enumFromThen (Char), _CONSTM_ Enum enumFromTo (Char), _CONSTM_ Enum enumFromThenTo (Char)] _N_
- enumFrom = _A_ 1 _U_ 1 _N_ _S_ "U(P)" {_A_ 1 _U_ 2 _N_ _N_ _N_ _N_} _N_ _N_,
- enumFromThen = _A_ 2 _U_ 22 _N_ _N_ _N_ _N_,
- enumFromTo = _A_ 2 _U_ 22 _N_ _N_ _N_ _N_,
- enumFromThenTo = _A_ 3 _U_ 222 _N_ _N_ _N_ _N_ #-}
+ enumFrom = { _A_ 1 _U_ 1 _N_ _S_ "U(P)" {_A_ 1 _U_ 2 _N_ _N_ _N_ _N_} _N_ _N_ },
+ enumFromThen = { _A_ 2 _U_ 22 _N_ _N_ _N_ _N_ },
+ enumFromTo = { _A_ 2 _U_ 12 _N_ _S_ "U(P)L" {_A_ 2 _U_ 22 _N_ _N_ _N_ _N_} _N_ _N_ },
+ enumFromThenTo = { _A_ 3 _U_ 222 _N_ _N_ _N_ _N_ } #-}
instance Eq Char
{-# GHC_PRAGMA _M_ PreludeCore {-dfun-} _A_ 0 _N_ _N_ _N_ _F_ _IF_ARGS_ 0 0 X 3 _!_ _TUP_2 [(Char -> Char -> Bool), (Char -> Char -> Bool)] [_CONSTM_ Eq (==) (Char), _CONSTM_ Eq (/=) (Char)] _N_
- (==) = _A_ 2 _U_ 11 _N_ _S_ "U(P)U(P)" {_A_ 2 _U_ 22 _N_ _N_ _F_ _IF_ARGS_ 0 2 XX 1 \ (u0 :: Char#) (u1 :: Char#) -> _#_ eqChar# [] [u0, u1] _N_} _F_ _IF_ARGS_ 0 2 CC 3 \ (u0 :: Char) (u1 :: Char) -> case u0 of { _ALG_ C# (u2 :: Char#) -> case u1 of { _ALG_ C# (u3 :: Char#) -> _#_ eqChar# [] [u2, u3]; _NO_DEFLT_ }; _NO_DEFLT_ } _N_,
- (/=) = _A_ 2 _U_ 11 _N_ _S_ "U(P)U(P)" {_A_ 2 _U_ 22 _N_ _N_ _F_ _IF_ARGS_ 0 2 XX 1 \ (u0 :: Char#) (u1 :: Char#) -> _#_ neChar# [] [u0, u1] _N_} _F_ _IF_ARGS_ 0 2 CC 3 \ (u0 :: Char) (u1 :: Char) -> case u0 of { _ALG_ C# (u2 :: Char#) -> case u1 of { _ALG_ C# (u3 :: Char#) -> _#_ neChar# [] [u2, u3]; _NO_DEFLT_ }; _NO_DEFLT_ } _N_ #-}
+ (==) = { _A_ 2 _U_ 11 _N_ _S_ "U(P)U(P)" {_A_ 2 _U_ 22 _N_ _N_ _F_ _IF_ARGS_ 0 2 XX 1 \ (u0 :: Char#) (u1 :: Char#) -> _#_ eqChar# [] [u0, u1] _N_} _F_ _IF_ARGS_ 0 2 CC 3 \ (u0 :: Char) (u1 :: Char) -> case u0 of { _ALG_ C# (u2 :: Char#) -> case u1 of { _ALG_ C# (u3 :: Char#) -> _#_ eqChar# [] [u2, u3]; _NO_DEFLT_ }; _NO_DEFLT_ } _N_ },
+ (/=) = { _A_ 2 _U_ 11 _N_ _S_ "U(P)U(P)" {_A_ 2 _U_ 22 _N_ _N_ _F_ _IF_ARGS_ 0 2 XX 1 \ (u0 :: Char#) (u1 :: Char#) -> _#_ neChar# [] [u0, u1] _N_} _F_ _IF_ARGS_ 0 2 CC 3 \ (u0 :: Char) (u1 :: Char) -> case u0 of { _ALG_ C# (u2 :: Char#) -> case u1 of { _ALG_ C# (u3 :: Char#) -> _#_ neChar# [] [u2, u3]; _NO_DEFLT_ }; _NO_DEFLT_ } _N_ } #-}
instance Ix Char
{-# GHC_PRAGMA _M_ PreludeCore {-dfun-} _A_ 0 _N_ _N_ _N_ _F_ _IF_ARGS_ 0 0 X 5 _!_ _TUP_4 [{{Ord Char}}, ((Char, Char) -> [Char]), ((Char, Char) -> Char -> Int), ((Char, Char) -> Char -> Bool)] [_DFUN_ Ord (Char), _CONSTM_ Ix range (Char), _CONSTM_ Ix index (Char), _CONSTM_ Ix inRange (Char)] _N_
- range = _A_ 1 _U_ 1 _N_ _S_ "U(LL)" {_A_ 2 _U_ 22 _N_ _N_ _F_ _IF_ARGS_ 0 0 X 1 _CONSTM_ Enum enumFromTo (Char) _N_} _F_ _IF_ARGS_ 0 1 C 4 \ (u0 :: (Char, Char)) -> case u0 of { _ALG_ _TUP_2 (u1 :: Char) (u2 :: Char) -> _APP_ _CONSTM_ Enum enumFromTo (Char) [ u1, u2 ]; _NO_DEFLT_ } _N_,
- index = _A_ 2 _U_ 11 _N_ _S_ "U(U(P)L)U(P)" {_A_ 3 _U_ 212 _N_ _N_ _N_ _N_} _N_ _N_,
- inRange = _A_ 2 _U_ 11 _N_ _S_ "U(U(P)L)U(P)" {_A_ 3 _U_ 212 _N_ _N_ _N_ _N_} _N_ _N_ #-}
+ range = { _A_ 1 _U_ 1 _N_ _S_ "U(U(P)L)" {_A_ 2 _U_ 22 _N_ _N_ _N_ _N_} _F_ _IF_ARGS_ 0 1 C 4 \ (u0 :: (Char, Char)) -> case u0 of { _ALG_ _TUP_2 (u1 :: Char) (u2 :: Char) -> _APP_ _CONSTM_ Enum enumFromTo (Char) [ u1, u2 ]; _NO_DEFLT_ } _N_ },
+ index = { _A_ 2 _U_ 11 _N_ _S_ "U(U(P)L)U(P)" {_A_ 3 _U_ 212 _N_ _N_ _N_ _N_} _N_ _N_ },
+ inRange = { _A_ 2 _U_ 11 _N_ _S_ "U(U(P)L)U(P)" {_A_ 3 _U_ 212 _N_ _N_ _N_ _N_} _N_ _N_ } #-}
instance Ord Char
{-# GHC_PRAGMA _M_ PreludeCore {-dfun-} _A_ 0 _N_ _N_ _N_ _F_ _IF_ARGS_ 0 0 X 9 _!_ _TUP_8 [{{Eq Char}}, (Char -> Char -> Bool), (Char -> Char -> Bool), (Char -> Char -> Bool), (Char -> Char -> Bool), (Char -> Char -> Char), (Char -> Char -> Char), (Char -> Char -> _CMP_TAG)] [_DFUN_ Eq (Char), _CONSTM_ Ord (<) (Char), _CONSTM_ Ord (<=) (Char), _CONSTM_ Ord (>=) (Char), _CONSTM_ Ord (>) (Char), _CONSTM_ Ord max (Char), _CONSTM_ Ord min (Char), _CONSTM_ Ord _tagCmp (Char)] _N_
- (<) = _A_ 2 _U_ 11 _N_ _S_ "U(P)U(P)" {_A_ 2 _U_ 22 _N_ _N_ _F_ _IF_ARGS_ 0 2 XX 1 \ (u0 :: Char#) (u1 :: Char#) -> _#_ ltChar# [] [u0, u1] _N_} _F_ _IF_ARGS_ 0 2 CC 3 \ (u0 :: Char) (u1 :: Char) -> case u0 of { _ALG_ C# (u2 :: Char#) -> case u1 of { _ALG_ C# (u3 :: Char#) -> _#_ ltChar# [] [u2, u3]; _NO_DEFLT_ }; _NO_DEFLT_ } _N_,
- (<=) = _A_ 2 _U_ 11 _N_ _S_ "U(P)U(P)" {_A_ 2 _U_ 22 _N_ _N_ _F_ _IF_ARGS_ 0 2 XX 1 \ (u0 :: Char#) (u1 :: Char#) -> _#_ leChar# [] [u0, u1] _N_} _F_ _IF_ARGS_ 0 2 CC 3 \ (u0 :: Char) (u1 :: Char) -> case u0 of { _ALG_ C# (u2 :: Char#) -> case u1 of { _ALG_ C# (u3 :: Char#) -> _#_ leChar# [] [u2, u3]; _NO_DEFLT_ }; _NO_DEFLT_ } _N_,
- (>=) = _A_ 2 _U_ 11 _N_ _S_ "U(P)U(P)" {_A_ 2 _U_ 22 _N_ _N_ _F_ _IF_ARGS_ 0 2 XX 1 \ (u0 :: Char#) (u1 :: Char#) -> _#_ geChar# [] [u0, u1] _N_} _F_ _IF_ARGS_ 0 2 CC 3 \ (u0 :: Char) (u1 :: Char) -> case u0 of { _ALG_ C# (u2 :: Char#) -> case u1 of { _ALG_ C# (u3 :: Char#) -> _#_ geChar# [] [u2, u3]; _NO_DEFLT_ }; _NO_DEFLT_ } _N_,
- (>) = _A_ 2 _U_ 11 _N_ _S_ "U(P)U(P)" {_A_ 2 _U_ 22 _N_ _N_ _F_ _IF_ARGS_ 0 2 XX 1 \ (u0 :: Char#) (u1 :: Char#) -> _#_ gtChar# [] [u0, u1] _N_} _F_ _IF_ARGS_ 0 2 CC 3 \ (u0 :: Char) (u1 :: Char) -> case u0 of { _ALG_ C# (u2 :: Char#) -> case u1 of { _ALG_ C# (u3 :: Char#) -> _#_ gtChar# [] [u2, u3]; _NO_DEFLT_ }; _NO_DEFLT_ } _N_,
- max = _A_ 2 _U_ 11 _N_ _S_ "U(P)U(P)" {_A_ 2 _U_ 22 _N_ _N_ _N_ _N_} _N_ _N_,
- min = _A_ 2 _U_ 11 _N_ _S_ "U(P)U(P)" {_A_ 2 _U_ 22 _N_ _N_ _N_ _N_} _N_ _N_,
- _tagCmp = _A_ 2 _U_ 11 _N_ _S_ "U(P)U(P)" {_A_ 2 _U_ 22 _N_ _N_ _N_ _N_} _N_ _N_ #-}
+ (<) = { _A_ 2 _U_ 11 _N_ _S_ "U(P)U(P)" {_A_ 2 _U_ 22 _N_ _N_ _F_ _IF_ARGS_ 0 2 XX 1 \ (u0 :: Char#) (u1 :: Char#) -> _#_ ltChar# [] [u0, u1] _N_} _F_ _IF_ARGS_ 0 2 CC 3 \ (u0 :: Char) (u1 :: Char) -> case u0 of { _ALG_ C# (u2 :: Char#) -> case u1 of { _ALG_ C# (u3 :: Char#) -> _#_ ltChar# [] [u2, u3]; _NO_DEFLT_ }; _NO_DEFLT_ } _N_ },
+ (<=) = { _A_ 2 _U_ 11 _N_ _S_ "U(P)U(P)" {_A_ 2 _U_ 22 _N_ _N_ _F_ _IF_ARGS_ 0 2 XX 1 \ (u0 :: Char#) (u1 :: Char#) -> _#_ leChar# [] [u0, u1] _N_} _F_ _IF_ARGS_ 0 2 CC 3 \ (u0 :: Char) (u1 :: Char) -> case u0 of { _ALG_ C# (u2 :: Char#) -> case u1 of { _ALG_ C# (u3 :: Char#) -> _#_ leChar# [] [u2, u3]; _NO_DEFLT_ }; _NO_DEFLT_ } _N_ },
+ (>=) = { _A_ 2 _U_ 11 _N_ _S_ "U(P)U(P)" {_A_ 2 _U_ 22 _N_ _N_ _F_ _IF_ARGS_ 0 2 XX 1 \ (u0 :: Char#) (u1 :: Char#) -> _#_ geChar# [] [u0, u1] _N_} _F_ _IF_ARGS_ 0 2 CC 3 \ (u0 :: Char) (u1 :: Char) -> case u0 of { _ALG_ C# (u2 :: Char#) -> case u1 of { _ALG_ C# (u3 :: Char#) -> _#_ geChar# [] [u2, u3]; _NO_DEFLT_ }; _NO_DEFLT_ } _N_ },
+ (>) = { _A_ 2 _U_ 11 _N_ _S_ "U(P)U(P)" {_A_ 2 _U_ 22 _N_ _N_ _F_ _IF_ARGS_ 0 2 XX 1 \ (u0 :: Char#) (u1 :: Char#) -> _#_ gtChar# [] [u0, u1] _N_} _F_ _IF_ARGS_ 0 2 CC 3 \ (u0 :: Char) (u1 :: Char) -> case u0 of { _ALG_ C# (u2 :: Char#) -> case u1 of { _ALG_ C# (u3 :: Char#) -> _#_ gtChar# [] [u2, u3]; _NO_DEFLT_ }; _NO_DEFLT_ } _N_ },
+ max = { _A_ 2 _U_ 11 _N_ _S_ "U(P)U(P)" {_A_ 2 _U_ 22 _N_ _N_ _N_ _N_} _N_ _N_ },
+ min = { _A_ 2 _U_ 11 _N_ _S_ "U(P)U(P)" {_A_ 2 _U_ 22 _N_ _N_ _N_ _N_} _N_ _N_ },
+ _tagCmp = { _A_ 2 _U_ 11 _N_ _S_ "U(P)U(P)" {_A_ 2 _U_ 22 _N_ _N_ _N_ _N_} _N_ _N_ } #-}
instance Text Char
{-# GHC_PRAGMA _M_ PreludeCore {-dfun-} _A_ 0 _N_ _N_ _N_ _F_ _IF_ARGS_ 0 0 X 5 _!_ _TUP_4 [(Int -> [Char] -> [(Char, [Char])]), (Int -> Char -> [Char] -> [Char]), ([Char] -> [([Char], [Char])]), ([Char] -> [Char] -> [Char])] [_CONSTM_ Text readsPrec (Char), _CONSTM_ Text showsPrec (Char), _CONSTM_ Text readList (Char), _CONSTM_ Text showList (Char)] _N_
- readsPrec = _A_ 1 _U_ 02 _N_ _S_ "A" {_A_ 0 _U_ 2 _N_ _N_ _N_ _N_} _N_ _N_,
- showsPrec = _A_ 3 _U_ 012 _N_ _S_ "AU(P)L" {_A_ 2 _U_ 22 _N_ _N_ _N_ _N_} _N_ _N_,
- readList = _A_ 0 _U_ 2 _N_ _N_ _N_ _N_,
- showList = _A_ 1 _U_ 22 _N_ _N_ _N_ _N_ #-}
+ readsPrec = { _A_ 1 _U_ 02 _N_ _S_ "A" {_A_ 0 _U_ 2 _N_ _N_ _N_ _N_} _N_ _N_ },
+ showsPrec = { _A_ 3 _U_ 012 _N_ _S_ "AU(P)L" {_A_ 2 _U_ 22 _N_ _N_ _N_ _N_} _N_ _N_ },
+ readList = { _A_ 0 _U_ 2 _N_ _N_ _N_ _N_ },
+ showList = { _A_ 1 _U_ 22 _N_ _N_ _N_ _N_ } #-}
instance _CCallable Char
{-# GHC_PRAGMA _M_ PreludeCore {-dfun-} _A_ 0 _N_ _N_ _N_ _F_ _IF_ARGS_ 0 0 X 1 _!_ _TUP_0 [] [] _N_ #-}
instance _CReturnable Char
-{-# GHC_PRAGMA INTERFACE VERSION 5 #-}
+{-# GHC_PRAGMA INTERFACE VERSION 6 #-}
interface PreludeCore where
import PreludeBuiltin(Char(..))
instance Enum Char
{-# GHC_PRAGMA _M_ PreludeCore {-dfun-} _A_ 0 _N_ _N_ _N_ _F_ _IF_ARGS_ 0 0 X 6 _!_ _TUP_5 [{{Ord Char}}, (Char -> [Char]), (Char -> Char -> [Char]), (Char -> Char -> [Char]), (Char -> Char -> Char -> [Char])] [_DFUN_ Ord (Char), _CONSTM_ Enum enumFrom (Char), _CONSTM_ Enum enumFromThen (Char), _CONSTM_ Enum enumFromTo (Char), _CONSTM_ Enum enumFromThenTo (Char)] _N_
- enumFrom = _A_ 1 _U_ 1 _N_ _S_ "U(P)" {_A_ 1 _U_ 2 _N_ _N_ _N_ _N_} _N_ _N_,
- enumFromThen = _A_ 2 _U_ 22 _N_ _N_ _N_ _N_,
- enumFromTo = _A_ 2 _U_ 22 _N_ _N_ _N_ _N_,
- enumFromThenTo = _A_ 3 _U_ 222 _N_ _N_ _N_ _N_ #-}
+ enumFrom = { _A_ 1 _U_ 1 _N_ _S_ "U(P)" {_A_ 1 _U_ 2 _N_ _N_ _N_ _N_} _N_ _N_ },
+ enumFromThen = { _A_ 2 _U_ 22 _N_ _N_ _N_ _N_ },
+ enumFromTo = { _A_ 2 _U_ 12 _N_ _S_ "U(P)L" {_A_ 2 _U_ 22 _N_ _N_ _N_ _N_} _N_ _N_ },
+ enumFromThenTo = { _A_ 3 _U_ 222 _N_ _N_ _N_ _N_ } #-}
instance Eq Char
{-# GHC_PRAGMA _M_ PreludeCore {-dfun-} _A_ 0 _N_ _N_ _N_ _F_ _IF_ARGS_ 0 0 X 3 _!_ _TUP_2 [(Char -> Char -> Bool), (Char -> Char -> Bool)] [_CONSTM_ Eq (==) (Char), _CONSTM_ Eq (/=) (Char)] _N_
- (==) = _A_ 2 _U_ 11 _N_ _S_ "U(P)U(P)" {_A_ 2 _U_ 22 _N_ _N_ _F_ _IF_ARGS_ 0 2 XX 1 \ (u0 :: Char#) (u1 :: Char#) -> _#_ eqChar# [] [u0, u1] _N_} _F_ _IF_ARGS_ 0 2 CC 3 \ (u0 :: Char) (u1 :: Char) -> case u0 of { _ALG_ C# (u2 :: Char#) -> case u1 of { _ALG_ C# (u3 :: Char#) -> _#_ eqChar# [] [u2, u3]; _NO_DEFLT_ }; _NO_DEFLT_ } _N_,
- (/=) = _A_ 2 _U_ 11 _N_ _S_ "U(P)U(P)" {_A_ 2 _U_ 22 _N_ _N_ _F_ _IF_ARGS_ 0 2 XX 1 \ (u0 :: Char#) (u1 :: Char#) -> _#_ neChar# [] [u0, u1] _N_} _F_ _IF_ARGS_ 0 2 CC 3 \ (u0 :: Char) (u1 :: Char) -> case u0 of { _ALG_ C# (u2 :: Char#) -> case u1 of { _ALG_ C# (u3 :: Char#) -> _#_ neChar# [] [u2, u3]; _NO_DEFLT_ }; _NO_DEFLT_ } _N_ #-}
+ (==) = { _A_ 2 _U_ 11 _N_ _S_ "U(P)U(P)" {_A_ 2 _U_ 22 _N_ _N_ _F_ _IF_ARGS_ 0 2 XX 1 \ (u0 :: Char#) (u1 :: Char#) -> _#_ eqChar# [] [u0, u1] _N_} _F_ _IF_ARGS_ 0 2 CC 3 \ (u0 :: Char) (u1 :: Char) -> case u0 of { _ALG_ C# (u2 :: Char#) -> case u1 of { _ALG_ C# (u3 :: Char#) -> _#_ eqChar# [] [u2, u3]; _NO_DEFLT_ }; _NO_DEFLT_ } _N_ },
+ (/=) = { _A_ 2 _U_ 11 _N_ _S_ "U(P)U(P)" {_A_ 2 _U_ 22 _N_ _N_ _F_ _IF_ARGS_ 0 2 XX 1 \ (u0 :: Char#) (u1 :: Char#) -> _#_ neChar# [] [u0, u1] _N_} _F_ _IF_ARGS_ 0 2 CC 3 \ (u0 :: Char) (u1 :: Char) -> case u0 of { _ALG_ C# (u2 :: Char#) -> case u1 of { _ALG_ C# (u3 :: Char#) -> _#_ neChar# [] [u2, u3]; _NO_DEFLT_ }; _NO_DEFLT_ } _N_ } #-}
instance Ix Char
{-# GHC_PRAGMA _M_ PreludeCore {-dfun-} _A_ 0 _N_ _N_ _N_ _F_ _IF_ARGS_ 0 0 X 5 _!_ _TUP_4 [{{Ord Char}}, ((Char, Char) -> [Char]), ((Char, Char) -> Char -> Int), ((Char, Char) -> Char -> Bool)] [_DFUN_ Ord (Char), _CONSTM_ Ix range (Char), _CONSTM_ Ix index (Char), _CONSTM_ Ix inRange (Char)] _N_
- range = _A_ 1 _U_ 1 _N_ _S_ "U(LL)" {_A_ 2 _U_ 22 _N_ _N_ _F_ _IF_ARGS_ 0 0 X 1 _CONSTM_ Enum enumFromTo (Char) _N_} _F_ _IF_ARGS_ 0 1 C 4 \ (u0 :: (Char, Char)) -> case u0 of { _ALG_ _TUP_2 (u1 :: Char) (u2 :: Char) -> _APP_ _CONSTM_ Enum enumFromTo (Char) [ u1, u2 ]; _NO_DEFLT_ } _N_,
- index = _A_ 2 _U_ 11 _N_ _S_ "U(U(P)L)U(P)" {_A_ 3 _U_ 212 _N_ _N_ _N_ _N_} _N_ _N_,
- inRange = _A_ 2 _U_ 11 _N_ _S_ "U(U(P)L)U(P)" {_A_ 3 _U_ 212 _N_ _N_ _N_ _N_} _N_ _N_ #-}
+ range = { _A_ 1 _U_ 1 _N_ _S_ "U(U(P)L)" {_A_ 2 _U_ 22 _N_ _N_ _N_ _N_} _F_ _IF_ARGS_ 0 1 C 4 \ (u0 :: (Char, Char)) -> case u0 of { _ALG_ _TUP_2 (u1 :: Char) (u2 :: Char) -> _APP_ _CONSTM_ Enum enumFromTo (Char) [ u1, u2 ]; _NO_DEFLT_ } _N_ },
+ index = { _A_ 2 _U_ 11 _N_ _S_ "U(U(P)L)U(P)" {_A_ 3 _U_ 212 _N_ _N_ _N_ _N_} _N_ _N_ },
+ inRange = { _A_ 2 _U_ 11 _N_ _S_ "U(U(P)L)U(P)" {_A_ 3 _U_ 212 _N_ _N_ _N_ _N_} _N_ _N_ } #-}
instance Ord Char
{-# GHC_PRAGMA _M_ PreludeCore {-dfun-} _A_ 0 _N_ _N_ _N_ _F_ _IF_ARGS_ 0 0 X 9 _!_ _TUP_8 [{{Eq Char}}, (Char -> Char -> Bool), (Char -> Char -> Bool), (Char -> Char -> Bool), (Char -> Char -> Bool), (Char -> Char -> Char), (Char -> Char -> Char), (Char -> Char -> _CMP_TAG)] [_DFUN_ Eq (Char), _CONSTM_ Ord (<) (Char), _CONSTM_ Ord (<=) (Char), _CONSTM_ Ord (>=) (Char), _CONSTM_ Ord (>) (Char), _CONSTM_ Ord max (Char), _CONSTM_ Ord min (Char), _CONSTM_ Ord _tagCmp (Char)] _N_
- (<) = _A_ 2 _U_ 11 _N_ _S_ "U(P)U(P)" {_A_ 2 _U_ 22 _N_ _N_ _F_ _IF_ARGS_ 0 2 XX 1 \ (u0 :: Char#) (u1 :: Char#) -> _#_ ltChar# [] [u0, u1] _N_} _F_ _IF_ARGS_ 0 2 CC 3 \ (u0 :: Char) (u1 :: Char) -> case u0 of { _ALG_ C# (u2 :: Char#) -> case u1 of { _ALG_ C# (u3 :: Char#) -> _#_ ltChar# [] [u2, u3]; _NO_DEFLT_ }; _NO_DEFLT_ } _N_,
- (<=) = _A_ 2 _U_ 11 _N_ _S_ "U(P)U(P)" {_A_ 2 _U_ 22 _N_ _N_ _F_ _IF_ARGS_ 0 2 XX 1 \ (u0 :: Char#) (u1 :: Char#) -> _#_ leChar# [] [u0, u1] _N_} _F_ _IF_ARGS_ 0 2 CC 3 \ (u0 :: Char) (u1 :: Char) -> case u0 of { _ALG_ C# (u2 :: Char#) -> case u1 of { _ALG_ C# (u3 :: Char#) -> _#_ leChar# [] [u2, u3]; _NO_DEFLT_ }; _NO_DEFLT_ } _N_,
- (>=) = _A_ 2 _U_ 11 _N_ _S_ "U(P)U(P)" {_A_ 2 _U_ 22 _N_ _N_ _F_ _IF_ARGS_ 0 2 XX 1 \ (u0 :: Char#) (u1 :: Char#) -> _#_ geChar# [] [u0, u1] _N_} _F_ _IF_ARGS_ 0 2 CC 3 \ (u0 :: Char) (u1 :: Char) -> case u0 of { _ALG_ C# (u2 :: Char#) -> case u1 of { _ALG_ C# (u3 :: Char#) -> _#_ geChar# [] [u2, u3]; _NO_DEFLT_ }; _NO_DEFLT_ } _N_,
- (>) = _A_ 2 _U_ 11 _N_ _S_ "U(P)U(P)" {_A_ 2 _U_ 22 _N_ _N_ _F_ _IF_ARGS_ 0 2 XX 1 \ (u0 :: Char#) (u1 :: Char#) -> _#_ gtChar# [] [u0, u1] _N_} _F_ _IF_ARGS_ 0 2 CC 3 \ (u0 :: Char) (u1 :: Char) -> case u0 of { _ALG_ C# (u2 :: Char#) -> case u1 of { _ALG_ C# (u3 :: Char#) -> _#_ gtChar# [] [u2, u3]; _NO_DEFLT_ }; _NO_DEFLT_ } _N_,
- max = _A_ 2 _U_ 11 _N_ _S_ "U(P)U(P)" {_A_ 2 _U_ 22 _N_ _N_ _N_ _N_} _N_ _N_,
- min = _A_ 2 _U_ 11 _N_ _S_ "U(P)U(P)" {_A_ 2 _U_ 22 _N_ _N_ _N_ _N_} _N_ _N_,
- _tagCmp = _A_ 2 _U_ 11 _N_ _S_ "U(P)U(P)" {_A_ 2 _U_ 22 _N_ _N_ _N_ _N_} _N_ _N_ #-}
+ (<) = { _A_ 2 _U_ 11 _N_ _S_ "U(P)U(P)" {_A_ 2 _U_ 22 _N_ _N_ _F_ _IF_ARGS_ 0 2 XX 1 \ (u0 :: Char#) (u1 :: Char#) -> _#_ ltChar# [] [u0, u1] _N_} _F_ _IF_ARGS_ 0 2 CC 3 \ (u0 :: Char) (u1 :: Char) -> case u0 of { _ALG_ C# (u2 :: Char#) -> case u1 of { _ALG_ C# (u3 :: Char#) -> _#_ ltChar# [] [u2, u3]; _NO_DEFLT_ }; _NO_DEFLT_ } _N_ },
+ (<=) = { _A_ 2 _U_ 11 _N_ _S_ "U(P)U(P)" {_A_ 2 _U_ 22 _N_ _N_ _F_ _IF_ARGS_ 0 2 XX 1 \ (u0 :: Char#) (u1 :: Char#) -> _#_ leChar# [] [u0, u1] _N_} _F_ _IF_ARGS_ 0 2 CC 3 \ (u0 :: Char) (u1 :: Char) -> case u0 of { _ALG_ C# (u2 :: Char#) -> case u1 of { _ALG_ C# (u3 :: Char#) -> _#_ leChar# [] [u2, u3]; _NO_DEFLT_ }; _NO_DEFLT_ } _N_ },
+ (>=) = { _A_ 2 _U_ 11 _N_ _S_ "U(P)U(P)" {_A_ 2 _U_ 22 _N_ _N_ _F_ _IF_ARGS_ 0 2 XX 1 \ (u0 :: Char#) (u1 :: Char#) -> _#_ geChar# [] [u0, u1] _N_} _F_ _IF_ARGS_ 0 2 CC 3 \ (u0 :: Char) (u1 :: Char) -> case u0 of { _ALG_ C# (u2 :: Char#) -> case u1 of { _ALG_ C# (u3 :: Char#) -> _#_ geChar# [] [u2, u3]; _NO_DEFLT_ }; _NO_DEFLT_ } _N_ },
+ (>) = { _A_ 2 _U_ 11 _N_ _S_ "U(P)U(P)" {_A_ 2 _U_ 22 _N_ _N_ _F_ _IF_ARGS_ 0 2 XX 1 \ (u0 :: Char#) (u1 :: Char#) -> _#_ gtChar# [] [u0, u1] _N_} _F_ _IF_ARGS_ 0 2 CC 3 \ (u0 :: Char) (u1 :: Char) -> case u0 of { _ALG_ C# (u2 :: Char#) -> case u1 of { _ALG_ C# (u3 :: Char#) -> _#_ gtChar# [] [u2, u3]; _NO_DEFLT_ }; _NO_DEFLT_ } _N_ },
+ max = { _A_ 2 _U_ 11 _N_ _S_ "U(P)U(P)" {_A_ 2 _U_ 22 _N_ _N_ _N_ _N_} _N_ _N_ },
+ min = { _A_ 2 _U_ 11 _N_ _S_ "U(P)U(P)" {_A_ 2 _U_ 22 _N_ _N_ _N_ _N_} _N_ _N_ },
+ _tagCmp = { _A_ 2 _U_ 11 _N_ _S_ "U(P)U(P)" {_A_ 2 _U_ 22 _N_ _N_ _N_ _N_} _N_ _N_ } #-}
instance Text Char
{-# GHC_PRAGMA _M_ PreludeCore {-dfun-} _A_ 0 _N_ _N_ _N_ _F_ _IF_ARGS_ 0 0 X 5 _!_ _TUP_4 [(Int -> [Char] -> [(Char, [Char])]), (Int -> Char -> [Char] -> [Char]), ([Char] -> [([Char], [Char])]), ([Char] -> [Char] -> [Char])] [_CONSTM_ Text readsPrec (Char), _CONSTM_ Text showsPrec (Char), _CONSTM_ Text readList (Char), _CONSTM_ Text showList (Char)] _N_
- readsPrec = _A_ 1 _U_ 02 _N_ _S_ "A" {_A_ 0 _U_ 2 _N_ _N_ _N_ _N_} _N_ _N_,
- showsPrec = _A_ 3 _U_ 012 _N_ _S_ "AU(P)L" {_A_ 2 _U_ 22 _N_ _N_ _N_ _N_} _N_ _N_,
- readList = _A_ 0 _U_ 2 _N_ _N_ _N_ _N_,
- showList = _A_ 1 _U_ 22 _N_ _N_ _N_ _N_ #-}
+ readsPrec = { _A_ 1 _U_ 02 _N_ _S_ "A" {_A_ 0 _U_ 2 _N_ _N_ _N_ _N_} _N_ _N_ },
+ showsPrec = { _A_ 3 _U_ 012 _N_ _S_ "AU(P)L" {_A_ 2 _U_ 22 _N_ _N_ _N_ _N_} _N_ _N_ },
+ readList = { _A_ 0 _U_ 2 _N_ _N_ _N_ _N_ },
+ showList = { _A_ 1 _U_ 22 _N_ _N_ _N_ _N_ } #-}
instance _CCallable Char
{-# GHC_PRAGMA _M_ PreludeCore {-dfun-} _A_ 0 _N_ _N_ _N_ _F_ _IF_ARGS_ 0 0 X 1 _!_ _TUP_0 [] [] _N_ #-}
instance _CReturnable Char
-{-# GHC_PRAGMA INTERFACE VERSION 5 #-}
+{-# GHC_PRAGMA INTERFACE VERSION 6 #-}
interface PreludeCore where
import PreludeBuiltin(Char(..))
instance Enum Char
{-# GHC_PRAGMA _M_ PreludeCore {-dfun-} _A_ 0 _N_ _N_ _N_ _F_ _IF_ARGS_ 0 0 X 6 _!_ _TUP_5 [{{Ord Char}}, (Char -> [Char]), (Char -> Char -> [Char]), (Char -> Char -> [Char]), (Char -> Char -> Char -> [Char])] [_DFUN_ Ord (Char), _CONSTM_ Enum enumFrom (Char), _CONSTM_ Enum enumFromThen (Char), _CONSTM_ Enum enumFromTo (Char), _CONSTM_ Enum enumFromThenTo (Char)] _N_
- enumFrom = _A_ 1 _U_ 1 _N_ _S_ "U(P)" {_A_ 1 _U_ 2 _N_ _N_ _N_ _N_} _N_ _N_,
- enumFromThen = _A_ 2 _U_ 22 _N_ _N_ _N_ _N_,
- enumFromTo = _A_ 2 _U_ 22 _N_ _N_ _N_ _N_,
- enumFromThenTo = _A_ 3 _U_ 222 _N_ _N_ _N_ _N_ #-}
+ enumFrom = { _A_ 1 _U_ 1 _N_ _S_ "U(P)" {_A_ 1 _U_ 2 _N_ _N_ _N_ _N_} _N_ _N_ },
+ enumFromThen = { _A_ 2 _U_ 22 _N_ _N_ _N_ _N_ },
+ enumFromTo = { _A_ 2 _U_ 12 _N_ _S_ "U(P)L" {_A_ 2 _U_ 22 _N_ _N_ _N_ _N_} _N_ _N_ },
+ enumFromThenTo = { _A_ 3 _U_ 222 _N_ _N_ _N_ _N_ } #-}
instance Eq Char
{-# GHC_PRAGMA _M_ PreludeCore {-dfun-} _A_ 0 _N_ _N_ _N_ _F_ _IF_ARGS_ 0 0 X 3 _!_ _TUP_2 [(Char -> Char -> Bool), (Char -> Char -> Bool)] [_CONSTM_ Eq (==) (Char), _CONSTM_ Eq (/=) (Char)] _N_
- (==) = _A_ 2 _U_ 11 _N_ _S_ "U(P)U(P)" {_A_ 2 _U_ 22 _N_ _N_ _F_ _IF_ARGS_ 0 2 XX 1 \ (u0 :: Char#) (u1 :: Char#) -> _#_ eqChar# [] [u0, u1] _N_} _F_ _IF_ARGS_ 0 2 CC 3 \ (u0 :: Char) (u1 :: Char) -> case u0 of { _ALG_ C# (u2 :: Char#) -> case u1 of { _ALG_ C# (u3 :: Char#) -> _#_ eqChar# [] [u2, u3]; _NO_DEFLT_ }; _NO_DEFLT_ } _N_,
- (/=) = _A_ 2 _U_ 11 _N_ _S_ "U(P)U(P)" {_A_ 2 _U_ 22 _N_ _N_ _F_ _IF_ARGS_ 0 2 XX 1 \ (u0 :: Char#) (u1 :: Char#) -> _#_ neChar# [] [u0, u1] _N_} _F_ _IF_ARGS_ 0 2 CC 3 \ (u0 :: Char) (u1 :: Char) -> case u0 of { _ALG_ C# (u2 :: Char#) -> case u1 of { _ALG_ C# (u3 :: Char#) -> _#_ neChar# [] [u2, u3]; _NO_DEFLT_ }; _NO_DEFLT_ } _N_ #-}
+ (==) = { _A_ 2 _U_ 11 _N_ _S_ "U(P)U(P)" {_A_ 2 _U_ 22 _N_ _N_ _F_ _IF_ARGS_ 0 2 XX 1 \ (u0 :: Char#) (u1 :: Char#) -> _#_ eqChar# [] [u0, u1] _N_} _F_ _IF_ARGS_ 0 2 CC 3 \ (u0 :: Char) (u1 :: Char) -> case u0 of { _ALG_ C# (u2 :: Char#) -> case u1 of { _ALG_ C# (u3 :: Char#) -> _#_ eqChar# [] [u2, u3]; _NO_DEFLT_ }; _NO_DEFLT_ } _N_ },
+ (/=) = { _A_ 2 _U_ 11 _N_ _S_ "U(P)U(P)" {_A_ 2 _U_ 22 _N_ _N_ _F_ _IF_ARGS_ 0 2 XX 1 \ (u0 :: Char#) (u1 :: Char#) -> _#_ neChar# [] [u0, u1] _N_} _F_ _IF_ARGS_ 0 2 CC 3 \ (u0 :: Char) (u1 :: Char) -> case u0 of { _ALG_ C# (u2 :: Char#) -> case u1 of { _ALG_ C# (u3 :: Char#) -> _#_ neChar# [] [u2, u3]; _NO_DEFLT_ }; _NO_DEFLT_ } _N_ } #-}
instance Ix Char
{-# GHC_PRAGMA _M_ PreludeCore {-dfun-} _A_ 0 _N_ _N_ _N_ _F_ _IF_ARGS_ 0 0 X 5 _!_ _TUP_4 [{{Ord Char}}, ((Char, Char) -> [Char]), ((Char, Char) -> Char -> Int), ((Char, Char) -> Char -> Bool)] [_DFUN_ Ord (Char), _CONSTM_ Ix range (Char), _CONSTM_ Ix index (Char), _CONSTM_ Ix inRange (Char)] _N_
- range = _A_ 1 _U_ 1 _N_ _S_ "U(LL)" {_A_ 2 _U_ 22 _N_ _N_ _F_ _IF_ARGS_ 0 0 X 1 _CONSTM_ Enum enumFromTo (Char) _N_} _F_ _IF_ARGS_ 0 1 C 4 \ (u0 :: (Char, Char)) -> case u0 of { _ALG_ _TUP_2 (u1 :: Char) (u2 :: Char) -> _APP_ _CONSTM_ Enum enumFromTo (Char) [ u1, u2 ]; _NO_DEFLT_ } _N_,
- index = _A_ 2 _U_ 11 _N_ _S_ "U(U(P)L)U(P)" {_A_ 3 _U_ 212 _N_ _N_ _N_ _N_} _N_ _N_,
- inRange = _A_ 2 _U_ 11 _N_ _S_ "U(U(P)L)U(P)" {_A_ 3 _U_ 212 _N_ _N_ _N_ _N_} _N_ _N_ #-}
+ range = { _A_ 1 _U_ 1 _N_ _S_ "U(U(P)L)" {_A_ 2 _U_ 22 _N_ _N_ _N_ _N_} _F_ _IF_ARGS_ 0 1 C 4 \ (u0 :: (Char, Char)) -> case u0 of { _ALG_ _TUP_2 (u1 :: Char) (u2 :: Char) -> _APP_ _CONSTM_ Enum enumFromTo (Char) [ u1, u2 ]; _NO_DEFLT_ } _N_ },
+ index = { _A_ 2 _U_ 11 _N_ _S_ "U(U(P)L)U(P)" {_A_ 3 _U_ 212 _N_ _N_ _N_ _N_} _N_ _N_ },
+ inRange = { _A_ 2 _U_ 11 _N_ _S_ "U(U(P)L)U(P)" {_A_ 3 _U_ 212 _N_ _N_ _N_ _N_} _N_ _N_ } #-}
instance Ord Char
{-# GHC_PRAGMA _M_ PreludeCore {-dfun-} _A_ 0 _N_ _N_ _N_ _F_ _IF_ARGS_ 0 0 X 9 _!_ _TUP_8 [{{Eq Char}}, (Char -> Char -> Bool), (Char -> Char -> Bool), (Char -> Char -> Bool), (Char -> Char -> Bool), (Char -> Char -> Char), (Char -> Char -> Char), (Char -> Char -> _CMP_TAG)] [_DFUN_ Eq (Char), _CONSTM_ Ord (<) (Char), _CONSTM_ Ord (<=) (Char), _CONSTM_ Ord (>=) (Char), _CONSTM_ Ord (>) (Char), _CONSTM_ Ord max (Char), _CONSTM_ Ord min (Char), _CONSTM_ Ord _tagCmp (Char)] _N_
- (<) = _A_ 2 _U_ 11 _N_ _S_ "U(P)U(P)" {_A_ 2 _U_ 22 _N_ _N_ _F_ _IF_ARGS_ 0 2 XX 1 \ (u0 :: Char#) (u1 :: Char#) -> _#_ ltChar# [] [u0, u1] _N_} _F_ _IF_ARGS_ 0 2 CC 3 \ (u0 :: Char) (u1 :: Char) -> case u0 of { _ALG_ C# (u2 :: Char#) -> case u1 of { _ALG_ C# (u3 :: Char#) -> _#_ ltChar# [] [u2, u3]; _NO_DEFLT_ }; _NO_DEFLT_ } _N_,
- (<=) = _A_ 2 _U_ 11 _N_ _S_ "U(P)U(P)" {_A_ 2 _U_ 22 _N_ _N_ _F_ _IF_ARGS_ 0 2 XX 1 \ (u0 :: Char#) (u1 :: Char#) -> _#_ leChar# [] [u0, u1] _N_} _F_ _IF_ARGS_ 0 2 CC 3 \ (u0 :: Char) (u1 :: Char) -> case u0 of { _ALG_ C# (u2 :: Char#) -> case u1 of { _ALG_ C# (u3 :: Char#) -> _#_ leChar# [] [u2, u3]; _NO_DEFLT_ }; _NO_DEFLT_ } _N_,
- (>=) = _A_ 2 _U_ 11 _N_ _S_ "U(P)U(P)" {_A_ 2 _U_ 22 _N_ _N_ _F_ _IF_ARGS_ 0 2 XX 1 \ (u0 :: Char#) (u1 :: Char#) -> _#_ geChar# [] [u0, u1] _N_} _F_ _IF_ARGS_ 0 2 CC 3 \ (u0 :: Char) (u1 :: Char) -> case u0 of { _ALG_ C# (u2 :: Char#) -> case u1 of { _ALG_ C# (u3 :: Char#) -> _#_ geChar# [] [u2, u3]; _NO_DEFLT_ }; _NO_DEFLT_ } _N_,
- (>) = _A_ 2 _U_ 11 _N_ _S_ "U(P)U(P)" {_A_ 2 _U_ 22 _N_ _N_ _F_ _IF_ARGS_ 0 2 XX 1 \ (u0 :: Char#) (u1 :: Char#) -> _#_ gtChar# [] [u0, u1] _N_} _F_ _IF_ARGS_ 0 2 CC 3 \ (u0 :: Char) (u1 :: Char) -> case u0 of { _ALG_ C# (u2 :: Char#) -> case u1 of { _ALG_ C# (u3 :: Char#) -> _#_ gtChar# [] [u2, u3]; _NO_DEFLT_ }; _NO_DEFLT_ } _N_,
- max = _A_ 2 _U_ 11 _N_ _S_ "U(P)U(P)" {_A_ 2 _U_ 22 _N_ _N_ _N_ _N_} _N_ _N_,
- min = _A_ 2 _U_ 11 _N_ _S_ "U(P)U(P)" {_A_ 2 _U_ 22 _N_ _N_ _N_ _N_} _N_ _N_,
- _tagCmp = _A_ 2 _U_ 11 _N_ _S_ "U(P)U(P)" {_A_ 2 _U_ 22 _N_ _N_ _N_ _N_} _N_ _N_ #-}
+ (<) = { _A_ 2 _U_ 11 _N_ _S_ "U(P)U(P)" {_A_ 2 _U_ 22 _N_ _N_ _F_ _IF_ARGS_ 0 2 XX 1 \ (u0 :: Char#) (u1 :: Char#) -> _#_ ltChar# [] [u0, u1] _N_} _F_ _IF_ARGS_ 0 2 CC 3 \ (u0 :: Char) (u1 :: Char) -> case u0 of { _ALG_ C# (u2 :: Char#) -> case u1 of { _ALG_ C# (u3 :: Char#) -> _#_ ltChar# [] [u2, u3]; _NO_DEFLT_ }; _NO_DEFLT_ } _N_ },
+ (<=) = { _A_ 2 _U_ 11 _N_ _S_ "U(P)U(P)" {_A_ 2 _U_ 22 _N_ _N_ _F_ _IF_ARGS_ 0 2 XX 1 \ (u0 :: Char#) (u1 :: Char#) -> _#_ leChar# [] [u0, u1] _N_} _F_ _IF_ARGS_ 0 2 CC 3 \ (u0 :: Char) (u1 :: Char) -> case u0 of { _ALG_ C# (u2 :: Char#) -> case u1 of { _ALG_ C# (u3 :: Char#) -> _#_ leChar# [] [u2, u3]; _NO_DEFLT_ }; _NO_DEFLT_ } _N_ },
+ (>=) = { _A_ 2 _U_ 11 _N_ _S_ "U(P)U(P)" {_A_ 2 _U_ 22 _N_ _N_ _F_ _IF_ARGS_ 0 2 XX 1 \ (u0 :: Char#) (u1 :: Char#) -> _#_ geChar# [] [u0, u1] _N_} _F_ _IF_ARGS_ 0 2 CC 3 \ (u0 :: Char) (u1 :: Char) -> case u0 of { _ALG_ C# (u2 :: Char#) -> case u1 of { _ALG_ C# (u3 :: Char#) -> _#_ geChar# [] [u2, u3]; _NO_DEFLT_ }; _NO_DEFLT_ } _N_ },
+ (>) = { _A_ 2 _U_ 11 _N_ _S_ "U(P)U(P)" {_A_ 2 _U_ 22 _N_ _N_ _F_ _IF_ARGS_ 0 2 XX 1 \ (u0 :: Char#) (u1 :: Char#) -> _#_ gtChar# [] [u0, u1] _N_} _F_ _IF_ARGS_ 0 2 CC 3 \ (u0 :: Char) (u1 :: Char) -> case u0 of { _ALG_ C# (u2 :: Char#) -> case u1 of { _ALG_ C# (u3 :: Char#) -> _#_ gtChar# [] [u2, u3]; _NO_DEFLT_ }; _NO_DEFLT_ } _N_ },
+ max = { _A_ 2 _U_ 11 _N_ _S_ "U(P)U(P)" {_A_ 2 _U_ 22 _N_ _N_ _N_ _N_} _N_ _N_ },
+ min = { _A_ 2 _U_ 11 _N_ _S_ "U(P)U(P)" {_A_ 2 _U_ 22 _N_ _N_ _N_ _N_} _N_ _N_ },
+ _tagCmp = { _A_ 2 _U_ 11 _N_ _S_ "U(P)U(P)" {_A_ 2 _U_ 22 _N_ _N_ _N_ _N_} _N_ _N_ } #-}
instance Text Char
{-# GHC_PRAGMA _M_ PreludeCore {-dfun-} _A_ 0 _N_ _N_ _N_ _F_ _IF_ARGS_ 0 0 X 5 _!_ _TUP_4 [(Int -> [Char] -> [(Char, [Char])]), (Int -> Char -> [Char] -> [Char]), ([Char] -> [([Char], [Char])]), ([Char] -> [Char] -> [Char])] [_CONSTM_ Text readsPrec (Char), _CONSTM_ Text showsPrec (Char), _CONSTM_ Text readList (Char), _CONSTM_ Text showList (Char)] _N_
- readsPrec = _A_ 1 _U_ 02 _N_ _S_ "A" {_A_ 0 _U_ 2 _N_ _N_ _N_ _N_} _N_ _N_,
- showsPrec = _A_ 3 _U_ 012 _N_ _S_ "AU(P)L" {_A_ 2 _U_ 22 _N_ _N_ _N_ _N_} _N_ _N_,
- readList = _A_ 0 _U_ 2 _N_ _N_ _N_ _N_,
- showList = _A_ 1 _U_ 22 _N_ _N_ _N_ _N_ #-}
+ readsPrec = { _A_ 1 _U_ 02 _N_ _S_ "A" {_A_ 0 _U_ 2 _N_ _N_ _N_ _N_} _N_ _N_ },
+ showsPrec = { _A_ 3 _U_ 012 _N_ _S_ "AU(P)L" {_A_ 2 _U_ 22 _N_ _N_ _N_ _N_} _N_ _N_ },
+ readList = { _A_ 0 _U_ 2 _N_ _N_ _N_ _N_ },
+ showList = { _A_ 1 _U_ 22 _N_ _N_ _N_ _N_ } #-}
instance _CCallable Char
{-# GHC_PRAGMA _M_ PreludeCore {-dfun-} _A_ 0 _N_ _N_ _N_ _F_ _IF_ARGS_ 0 0 X 1 _!_ _TUP_0 [] [] _N_ #-}
instance _CReturnable Char
-{-# GHC_PRAGMA INTERFACE VERSION 5 #-}
+{-# GHC_PRAGMA INTERFACE VERSION 6 #-}
interface PreludeComplex where
import PreludeBuiltin(Double(..), Tuple2)
import PreludeCore(Eq(..), Floating(..), Fractional(..), Num(..), RealFloat(..), Text(..))
imagPart :: Complex a -> a
{-# GHC_PRAGMA _A_ 1 _U_ 1 _N_ _S_ "U(AS)" {_A_ 1 _U_ 1 _N_ _N_ _F_ _IF_ARGS_ 1 1 X 1 _/\_ u0 -> \ (u1 :: u0) -> u1 _N_} _F_ _IF_ARGS_ 1 1 C 2 _/\_ u0 -> \ (u1 :: Complex u0) -> case u1 of { _ALG_ (:+) (u2 :: u0) (u3 :: u0) -> u3; _NO_DEFLT_ } _N_ #-}
magnitude :: RealFloat a => Complex a -> a
- {-# GHC_PRAGMA _A_ 1 _U_ 12 _N_ _S_ "U(ALAAAAALAS)" {_A_ 3 _U_ 2221 _N_ _N_ _N_ _N_} _N_ _SPECIALISE_ [ Double ] 1 { _A_ 1 _U_ 1 _N_ _S_ "U(LL)" {_A_ 2 _U_ 22 _N_ _N_ _N_ _N_} _N_ _N_ } #-}
+ {-# GHC_PRAGMA _A_ 1 _U_ 12 _N_ _S_ "U(ALAAAAALAS)" {_A_ 3 _U_ 2221 _N_ _N_ _N_ _N_} _N_ _SPECIALISE_ [ Double ] 1 { _A_ 1 _U_ 1 _N_ _S_ "U(U(P)U(P))" {_A_ 2 _U_ 22 _N_ _N_ _N_ _N_} _N_ _N_ } #-}
mkPolar :: RealFloat a => a -> a -> Complex a
{-# GHC_PRAGMA _A_ 3 _U_ 122 _N_ _N_ _N_ _SPECIALISE_ [ Double ] 1 { _A_ 2 _U_ 22 _N_ _N_ _N_ _N_ } #-}
phase :: RealFloat a => Complex a -> a
{-# GHC_PRAGMA _M_ PreludeComplex {-dfun-} _A_ 1 _U_ 2 _N_ _N_ _N_ _N_ #-}
instance Eq (Complex Double)
{-# GHC_PRAGMA _M_ PreludeComplex {-dfun-} _A_ 0 _N_ _N_ _N_ _F_ _IF_ARGS_ 0 0 X 3 _!_ _TUP_2 [(Complex Double -> Complex Double -> Bool), (Complex Double -> Complex Double -> Bool)] [_CONSTM_ Eq (==) (Complex Double), _CONSTM_ Eq (/=) (Complex Double)] _N_
- (==) = _A_ 2 _U_ 11 _N_ _S_ "U(U(P)L)U(U(P)L)" {_A_ 4 _U_ 2121 _N_ _N_ _F_ _IF_ARGS_ 0 4 XCXC 7 \ (u0 :: Double#) (u1 :: Double) (u2 :: Double#) (u3 :: Double) -> case _#_ eqDouble# [] [u0, u2] of { _ALG_ True -> case u1 of { _ALG_ D# (u4 :: Double#) -> case u3 of { _ALG_ D# (u5 :: Double#) -> _#_ eqDouble# [] [u4, u5]; _NO_DEFLT_ }; _NO_DEFLT_ }; False -> _!_ False [] []; _NO_DEFLT_ } _N_} _F_ _ALWAYS_ \ (u0 :: Complex Double) (u1 :: Complex Double) -> case u0 of { _ALG_ (:+) (u2 :: Double) (u3 :: Double) -> case u2 of { _ALG_ D# (u4 :: Double#) -> case u1 of { _ALG_ (:+) (u5 :: Double) (u6 :: Double) -> case u5 of { _ALG_ D# (u7 :: Double#) -> case _#_ eqDouble# [] [u4, u7] of { _ALG_ True -> case u3 of { _ALG_ D# (u8 :: Double#) -> case u6 of { _ALG_ D# (u9 :: Double#) -> _#_ eqDouble# [] [u8, u9]; _NO_DEFLT_ }; _NO_DEFLT_ }; False -> _!_ False [] []; _NO_DEFLT_ }; _NO_DEFLT_ }; _NO_DEFLT_ }; _NO_DEFLT_ }; _NO_DEFLT_ } _N_,
- (/=) = _A_ 2 _U_ 11 _N_ _S_ "U(U(P)L)U(U(P)L)" {_A_ 4 _U_ 2121 _N_ _N_ _F_ _IF_ARGS_ 0 4 XCXC 7 \ (u0 :: Double#) (u1 :: Double) (u2 :: Double#) (u3 :: Double) -> case _#_ neDouble# [] [u0, u2] of { _ALG_ True -> _!_ True [] []; False -> case u1 of { _ALG_ D# (u4 :: Double#) -> case u3 of { _ALG_ D# (u5 :: Double#) -> _#_ neDouble# [] [u4, u5]; _NO_DEFLT_ }; _NO_DEFLT_ }; _NO_DEFLT_ } _N_} _F_ _ALWAYS_ \ (u0 :: Complex Double) (u1 :: Complex Double) -> case u0 of { _ALG_ (:+) (u2 :: Double) (u3 :: Double) -> case u2 of { _ALG_ D# (u4 :: Double#) -> case u1 of { _ALG_ (:+) (u5 :: Double) (u6 :: Double) -> case u5 of { _ALG_ D# (u7 :: Double#) -> case _#_ neDouble# [] [u4, u7] of { _ALG_ True -> _!_ True [] []; False -> case u3 of { _ALG_ D# (u8 :: Double#) -> case u6 of { _ALG_ D# (u9 :: Double#) -> _#_ neDouble# [] [u8, u9]; _NO_DEFLT_ }; _NO_DEFLT_ }; _NO_DEFLT_ }; _NO_DEFLT_ }; _NO_DEFLT_ }; _NO_DEFLT_ }; _NO_DEFLT_ } _N_ #-}
+ (==) = { _A_ 2 _U_ 11 _N_ _S_ "U(U(P)L)U(U(P)L)" {_A_ 4 _U_ 2121 _N_ _N_ _F_ _IF_ARGS_ 0 4 XCXC 7 \ (u0 :: Double#) (u1 :: Double) (u2 :: Double#) (u3 :: Double) -> case _#_ eqDouble# [] [u0, u2] of { _ALG_ True -> case u1 of { _ALG_ D# (u4 :: Double#) -> case u3 of { _ALG_ D# (u5 :: Double#) -> _#_ eqDouble# [] [u4, u5]; _NO_DEFLT_ }; _NO_DEFLT_ }; False -> _!_ False [] []; _NO_DEFLT_ } _N_} _F_ _ALWAYS_ \ (u0 :: Complex Double) (u1 :: Complex Double) -> case u0 of { _ALG_ (:+) (u2 :: Double) (u3 :: Double) -> case u2 of { _ALG_ D# (u4 :: Double#) -> case u1 of { _ALG_ (:+) (u5 :: Double) (u6 :: Double) -> case u5 of { _ALG_ D# (u7 :: Double#) -> case _#_ eqDouble# [] [u4, u7] of { _ALG_ True -> case u3 of { _ALG_ D# (u8 :: Double#) -> case u6 of { _ALG_ D# (u9 :: Double#) -> _#_ eqDouble# [] [u8, u9]; _NO_DEFLT_ }; _NO_DEFLT_ }; False -> _!_ False [] []; _NO_DEFLT_ }; _NO_DEFLT_ }; _NO_DEFLT_ }; _NO_DEFLT_ }; _NO_DEFLT_ } _N_ },
+ (/=) = { _A_ 2 _U_ 11 _N_ _S_ "U(U(P)L)U(U(P)L)" {_A_ 4 _U_ 2121 _N_ _N_ _F_ _IF_ARGS_ 0 4 XCXC 7 \ (u0 :: Double#) (u1 :: Double) (u2 :: Double#) (u3 :: Double) -> case _#_ neDouble# [] [u0, u2] of { _ALG_ True -> _!_ True [] []; False -> case u1 of { _ALG_ D# (u4 :: Double#) -> case u3 of { _ALG_ D# (u5 :: Double#) -> _#_ neDouble# [] [u4, u5]; _NO_DEFLT_ }; _NO_DEFLT_ }; _NO_DEFLT_ } _N_} _F_ _ALWAYS_ \ (u0 :: Complex Double) (u1 :: Complex Double) -> case u0 of { _ALG_ (:+) (u2 :: Double) (u3 :: Double) -> case u2 of { _ALG_ D# (u4 :: Double#) -> case u1 of { _ALG_ (:+) (u5 :: Double) (u6 :: Double) -> case u5 of { _ALG_ D# (u7 :: Double#) -> case _#_ neDouble# [] [u4, u7] of { _ALG_ True -> _!_ True [] []; False -> case u3 of { _ALG_ D# (u8 :: Double#) -> case u6 of { _ALG_ D# (u9 :: Double#) -> _#_ neDouble# [] [u8, u9]; _NO_DEFLT_ }; _NO_DEFLT_ }; _NO_DEFLT_ }; _NO_DEFLT_ }; _NO_DEFLT_ }; _NO_DEFLT_ }; _NO_DEFLT_ } _N_ } #-}
instance RealFloat a => Floating (Complex a)
{-# GHC_PRAGMA _M_ PreludeComplex {-dfun-} _A_ 2 _U_ 22 _N_ _N_ _N_ _N_ #-}
instance Floating (Complex Double)
{-# GHC_PRAGMA _M_ PreludeComplex {-dfun-} _A_ 0 _N_ _N_ _N_ _F_ _IF_ARGS_ 0 0 X 20 _!_ _TUP_19 [{{Fractional (Complex Double)}}, (Complex Double), (Complex Double -> Complex Double), (Complex Double -> Complex Double), (Complex Double -> Complex Double), (Complex Double -> Complex Double -> Complex Double), (Complex Double -> Complex Double -> Complex Double), (Complex Double -> Complex Double), (Complex Double -> Complex Double), (Complex Double -> Complex Double), (Complex Double -> Complex Double), (Complex Double -> Complex Double), (Complex Double -> Complex Double), (Complex Double -> Complex Double), (Complex Double -> Complex Double), (Complex Double -> Complex Double), (Complex Double -> Complex Double), (Complex Double -> Complex Double), (Complex Double -> Complex Double)] [_DFUN_ Fractional (Complex Double), _CONSTM_ Floating pi (Complex Double), _CONSTM_ Floating exp (Complex Double), _CONSTM_ Floating log (Complex Double), _CONSTM_ Floating sqrt (Complex Double), _CONSTM_ Floating (**) (Complex Double), _CONSTM_ Floating logBase (Complex Double), _CONSTM_ Floating sin (Complex Double), _CONSTM_ Floating cos (Complex Double), _CONSTM_ Floating tan (Complex Double), _CONSTM_ Floating asin (Complex Double), _CONSTM_ Floating acos (Complex Double), _CONSTM_ Floating atan (Complex Double), _CONSTM_ Floating sinh (Complex Double), _CONSTM_ Floating cosh (Complex Double), _CONSTM_ Floating tanh (Complex Double), _CONSTM_ Floating asinh (Complex Double), _CONSTM_ Floating acosh (Complex Double), _CONSTM_ Floating atanh (Complex Double)] _N_
- pi = _A_ 0 _N_ _N_ _N_ _N_ _N_,
- exp = _A_ 1 _U_ 1 _N_ _S_ "U(LL)" {_A_ 2 _U_ 12 _N_ _N_ _N_ _N_} _N_ _N_,
- log = _A_ 1 _U_ 2 _N_ _N_ _N_ _N_,
- sqrt = _A_ 1 _U_ 1 _N_ _S_ "U(U(P)L)" {_A_ 2 _U_ 22 _N_ _N_ _N_ _N_} _N_ _N_,
- (**) = _A_ 2 _U_ 21 _N_ _S_ "LU(LL)" {_A_ 3 _U_ 222 _N_ _N_ _N_ _N_} _N_ _N_,
- logBase = _A_ 2 _U_ 22 _N_ _N_ _N_ _N_,
- sin = _A_ 1 _U_ 1 _N_ _S_ "U(LL)" {_A_ 2 _U_ 22 _N_ _N_ _N_ _N_} _N_ _N_,
- cos = _A_ 1 _U_ 1 _N_ _S_ "U(LL)" {_A_ 2 _U_ 22 _N_ _N_ _N_ _N_} _N_ _N_,
- tan = _A_ 1 _U_ 1 _N_ _S_ "U(LL)" {_A_ 2 _U_ 22 _N_ _N_ _N_ _N_} _N_ _N_,
- asin = _A_ 1 _U_ 1 _N_ _S_ "U(LL)" {_A_ 2 _U_ 22 _N_ _N_ _N_ _N_} _N_ _N_,
- acos = _A_ 1 _U_ 1 _N_ _S_ "U(LL)" {_A_ 2 _U_ 22 _N_ _N_ _N_ _N_} _N_ _N_,
- atan = _A_ 1 _U_ 1 _N_ _S_ "U(LL)" {_A_ 2 _U_ 22 _N_ _N_ _N_ _N_} _N_ _N_,
- sinh = _A_ 1 _U_ 1 _N_ _S_ "U(LL)" {_A_ 2 _U_ 22 _N_ _N_ _N_ _N_} _N_ _N_,
- cosh = _A_ 1 _U_ 1 _N_ _S_ "U(LL)" {_A_ 2 _U_ 22 _N_ _N_ _N_ _N_} _N_ _N_,
- tanh = _A_ 1 _U_ 1 _N_ _S_ "U(LL)" {_A_ 2 _U_ 22 _N_ _N_ _N_ _N_} _N_ _N_,
- asinh = _A_ 1 _U_ 1 _N_ _N_ _N_ _N_,
- acosh = _A_ 1 _U_ 1 _N_ _N_ _N_ _N_,
- atanh = _A_ 1 _U_ 1 _N_ _N_ _N_ _N_ #-}
+ pi = { _A_ 0 _N_ _N_ _N_ _F_ _IF_ARGS_ 0 0 X 3 _!_ (:+) [Double] [_CONSTM_ Floating pi (Double), _SPEC_ _ORIG_ PreludeCore __i0 [ (Double) ]] _N_ },
+ exp = { _A_ 1 _U_ 1 _N_ _S_ "U(LL)" {_A_ 2 _U_ 12 _N_ _N_ _N_ _N_} _N_ _N_ },
+ log = { _A_ 1 _U_ 2 _N_ _N_ _N_ _N_ },
+ sqrt = { _A_ 1 _U_ 1 _N_ _S_ "U(U(P)L)" {_A_ 2 _U_ 22 _N_ _N_ _N_ _N_} _N_ _N_ },
+ (**) = { _A_ 2 _U_ 21 _N_ _S_ "LU(LL)" {_A_ 3 _U_ 222 _N_ _N_ _N_ _N_} _N_ _N_ },
+ logBase = { _A_ 2 _U_ 22 _N_ _N_ _N_ _N_ },
+ sin = { _A_ 1 _U_ 1 _N_ _S_ "U(LL)" {_A_ 2 _U_ 22 _N_ _N_ _N_ _N_} _N_ _N_ },
+ cos = { _A_ 1 _U_ 1 _N_ _S_ "U(LL)" {_A_ 2 _U_ 22 _N_ _N_ _N_ _N_} _N_ _N_ },
+ tan = { _A_ 1 _U_ 1 _N_ _S_ "U(LL)" {_A_ 2 _U_ 22 _N_ _N_ _N_ _N_} _N_ _N_ },
+ asin = { _A_ 1 _U_ 1 _N_ _S_ "U(LL)" {_A_ 2 _U_ 22 _N_ _N_ _N_ _N_} _N_ _N_ },
+ acos = { _A_ 1 _U_ 1 _N_ _S_ "U(LL)" {_A_ 2 _U_ 22 _N_ _N_ _N_ _N_} _N_ _N_ },
+ atan = { _A_ 1 _U_ 1 _N_ _S_ "U(LL)" {_A_ 2 _U_ 22 _N_ _N_ _N_ _N_} _N_ _N_ },
+ sinh = { _A_ 1 _U_ 1 _N_ _S_ "U(LL)" {_A_ 2 _U_ 22 _N_ _N_ _N_ _N_} _N_ _N_ },
+ cosh = { _A_ 1 _U_ 1 _N_ _S_ "U(LL)" {_A_ 2 _U_ 22 _N_ _N_ _N_ _N_} _N_ _N_ },
+ tanh = { _A_ 1 _U_ 1 _N_ _S_ "U(LL)" {_A_ 2 _U_ 22 _N_ _N_ _N_ _N_} _N_ _N_ },
+ asinh = { _A_ 1 _U_ 1 _N_ _N_ _N_ _N_ },
+ acosh = { _A_ 1 _U_ 1 _N_ _N_ _N_ _N_ },
+ atanh = { _A_ 1 _U_ 1 _N_ _N_ _N_ _N_ } #-}
instance RealFloat a => Fractional (Complex a)
{-# GHC_PRAGMA _M_ PreludeComplex {-dfun-} _A_ 2 _U_ 22 _N_ _N_ _N_ _N_ #-}
instance Fractional (Complex Double)
{-# GHC_PRAGMA _M_ PreludeComplex {-dfun-} _A_ 0 _N_ _N_ _N_ _F_ _IF_ARGS_ 0 0 X 5 _!_ _TUP_4 [{{Num (Complex Double)}}, (Complex Double -> Complex Double -> Complex Double), (Complex Double -> Complex Double), (Ratio Integer -> Complex Double)] [_DFUN_ Num (Complex Double), _CONSTM_ Fractional (/) (Complex Double), _CONSTM_ Fractional recip (Complex Double), _CONSTM_ Fractional fromRational (Complex Double)] _N_
- (/) = _A_ 2 _U_ 11 _N_ _S_ "U(LL)U(LL)" {_A_ 4 _U_ 2222 _N_ _N_ _N_ _N_} _N_ _N_,
- recip = _A_ 1 _U_ 1 _N_ _S_ "U(LL)" {_A_ 2 _U_ 22 _N_ _N_ _N_ _N_} _N_ _N_,
- fromRational = _A_ 1 _U_ 2 _N_ _N_ _N_ _N_ #-}
+ (/) = { _A_ 2 _U_ 11 _N_ _S_ "U(LL)U(LL)" {_A_ 4 _U_ 2222 _N_ _N_ _N_ _N_} _N_ _N_ },
+ recip = { _A_ 1 _U_ 1 _N_ _S_ "U(LL)" {_A_ 2 _U_ 22 _N_ _N_ _N_ _N_} _F_ _IF_ARGS_ 0 1 X 3 \ (u0 :: Complex Double) -> _APP_ _CONSTM_ Fractional (/) (Complex Double) [ _SPEC_ _ORIG_ PreludeCore __i1 [ (Complex Double) ], u0 ] _N_ },
+ fromRational = { _A_ 1 _U_ 1 _N_ _N_ _N_ _N_ } #-}
instance RealFloat a => Num (Complex a)
{-# GHC_PRAGMA _M_ PreludeComplex {-dfun-} _A_ 3 _U_ 222 _N_ _N_ _N_ _N_ #-}
instance Num (Complex Double)
- {-# GHC_PRAGMA _M_ PreludeComplex {-dfun-} _A_ 0 _N_ _N_ _N_ _N_ _N_
- (+) = _A_ 2 _U_ 11 _N_ _S_ "U(LL)U(LL)" {_A_ 4 _U_ 1111 _N_ _N_ _N_ _N_} _N_ _N_,
- (-) = _A_ 2 _U_ 11 _N_ _S_ "U(LL)U(LL)" {_A_ 4 _U_ 1111 _N_ _N_ _N_ _N_} _N_ _N_,
- (*) = _A_ 2 _U_ 11 _N_ _S_ "U(LL)U(LL)" {_A_ 4 _U_ 2222 _N_ _N_ _N_ _N_} _N_ _N_,
- negate = _A_ 1 _U_ 1 _N_ _S_ "U(LL)" {_A_ 2 _U_ 11 _N_ _N_ _N_ _N_} _N_ _N_,
- abs = _A_ 1 _U_ 1 _N_ _N_ _N_ _N_,
- signum = _A_ 1 _U_ 1 _N_ _S_ "U(U(P)L)" {_A_ 2 _U_ 22 _N_ _N_ _N_ _N_} _N_ _N_,
- fromInteger = _A_ 1 _U_ 1 _N_ _N_ _N_ _N_,
- fromInt = _A_ 1 _U_ 1 _N_ _N_ _N_ _N_ #-}
+ {-# GHC_PRAGMA _M_ PreludeComplex {-dfun-} _A_ 0 _N_ _N_ _N_ _F_ _IF_ARGS_ 0 0 X 11 _!_ _TUP_10 [{{Eq (Complex Double)}}, {{Text (Complex Double)}}, (Complex Double -> Complex Double -> Complex Double), (Complex Double -> Complex Double -> Complex Double), (Complex Double -> Complex Double -> Complex Double), (Complex Double -> Complex Double), (Complex Double -> Complex Double), (Complex Double -> Complex Double), (Integer -> Complex Double), (Int -> Complex Double)] [_DFUN_ Eq (Complex Double), _DFUN_ Text (Complex Double), _CONSTM_ Num (+) (Complex Double), _CONSTM_ Num (-) (Complex Double), _CONSTM_ Num (*) (Complex Double), _CONSTM_ Num negate (Complex Double), _CONSTM_ Num abs (Complex Double), _CONSTM_ Num signum (Complex Double), _CONSTM_ Num fromInteger (Complex Double), _CONSTM_ Num fromInt (Complex Double)] _N_
+ (+) = { _A_ 2 _U_ 11 _N_ _S_ "U(LL)U(LL)" {_A_ 4 _U_ 1111 _N_ _N_ _N_ _N_} _N_ _N_ },
+ (-) = { _A_ 2 _U_ 11 _N_ _S_ "U(LL)U(LL)" {_A_ 4 _U_ 1111 _N_ _N_ _N_ _N_} _N_ _N_ },
+ (*) = { _A_ 2 _U_ 11 _N_ _S_ "U(LL)U(LL)" {_A_ 4 _U_ 2222 _N_ _N_ _N_ _N_} _N_ _N_ },
+ negate = { _A_ 1 _U_ 1 _N_ _S_ "U(LL)" {_A_ 2 _U_ 11 _N_ _N_ _N_ _N_} _N_ _N_ },
+ abs = { _A_ 1 _U_ 1 _N_ _N_ _N_ _N_ },
+ signum = { _A_ 1 _U_ 1 _N_ _S_ "U(U(P)L)" {_A_ 2 _U_ 22 _N_ _N_ _N_ _N_} _N_ _N_ },
+ fromInteger = { _A_ 1 _U_ 1 _N_ _N_ _N_ _N_ },
+ fromInt = { _A_ 1 _U_ 1 _N_ _N_ _N_ _N_ } #-}
instance Text a => Text (Complex a)
{-# GHC_PRAGMA _M_ PreludeComplex {-dfun-} _A_ 1 _U_ 2 _N_ _N_ _N_ _N_ #-}
+instance Text (Complex Double)
+ {-# GHC_PRAGMA _M_ PreludeComplex {-dfun-} _A_ 0 _N_ _N_ _N_ _F_ _IF_ARGS_ 0 0 X 5 _!_ _TUP_4 [(Int -> [Char] -> [(Complex Double, [Char])]), (Int -> Complex Double -> [Char] -> [Char]), ([Char] -> [([Complex Double], [Char])]), ([Complex Double] -> [Char] -> [Char])] [_CONSTM_ Text readsPrec (Complex Double), _CONSTM_ Text showsPrec (Complex Double), _CONSTM_ Text readList (Complex Double), _CONSTM_ Text showList (Complex Double)] _N_
+ readsPrec = { _A_ 1 _U_ 12 _N_ _S_ "U(P)" {_A_ 1 _U_ 22 _N_ _N_ _N_ _N_} _N_ _N_ },
+ showsPrec = { _A_ 2 _U_ 112 _N_ _S_ "LU(LL)" {_A_ 3 _U_ 1222 _N_ _N_ _N_ _N_} _N_ _N_ },
+ readList = { _A_ 0 _U_ 2 _N_ _N_ _N_ _N_ },
+ showList = { _A_ 1 _U_ 12 _N_ _N_ _N_ _N_ } #-}
import IInteger
import IList
import List ( (++), foldr )
-import Prel ( (.), (&&), (||), (^), atan2 )
+import Prel ( (.), (&&), (||), (^), atan2, otherwise )
import PS ( _PackedString, _unpackPS )
import Text
+import TyArray
import TyComplex
-- infix 6 :+
(x:+y) - (x2:+y2) = (x-x2) :+ (y-y2)
(x:+y) * (x2:+y2) = (x*x2-y*y2) :+ (x*y2+y*x2)
negate (x:+y) = negate x :+ negate y
- abs z = magnitude z :+ 0
- signum 0 = 0
+ abs z = magnitude z :+ __i0
+ signum 0 = __i0
signum z@(x:+y) = x/r :+ y/r where { r = magnitude z }
- fromInteger n = fromInteger n :+ 0
- fromInt n = fromInt n :+ 0
+ fromInteger n = fromInteger n :+ __i0
+ fromInt n = fromInt n :+ __i0
instance (RealFloat a) => Fractional (Complex a) where
(x:+y) / (x2:+y2) = (x*x3+y*y3) / d :+ (y*x3-x*y3) / d
y3 = scaleFloat k y2
k = - max (exponent x2) (exponent y2)
d = x2*x3 + y2*y3
- fromRational a = fromRational a :+ 0
- recip a = (1 :+ 0) / a
+ fromRational a = fromRational a :+ __i0
+ recip a = __i1 / a
instance (RealFloat a) => Floating (Complex a) where
- pi = pi :+ 0
+ pi = pi :+ __i0
exp (x:+y) = expx * cos y :+ expx * sin y
where expx = exp x
log z = log (magnitude z) :+ phase z
(**) a b = exp (log a * b)
logBase a b = log b / log a
- sqrt 0 = 0
- sqrt z@(x:+y) = u :+ (if y < 0 then -v else v)
- where (u,v) = if x < 0 then (v2,u2) else (u2,v2)
- v2 = abs y / (u2*2)
- u2 = sqrt ((magnitude z + abs x) / 2)
+ sqrt z@(x:+y) | z == __i0
+ = __i0
+ | otherwise
+ = u :+ (if y < __i0 then -v else v)
+ where (u,v) = if x < __i0 then (v2,u2) else (u2,v2)
+ v2 = abs y / (u2 * __i2)
+ u2 = sqrt ((magnitude z + abs x) / __i2)
sin (x:+y) = sin x * cosh y :+ cos x * sinh y
cos (x:+y) = cos x * cosh y :+ (- sin x * sinh y)
coshx = cosh x
asin z@(x:+y) = y2:+(-x2)
- where (x2:+y2) = log (((-y):+x) + sqrt (1 - z*z))
+ where (x2:+y2) = log (((-y):+x) + sqrt (__i1 - z*z))
acos z@(x:+y) = y3:+(-x3)
where (x3:+y3) = log (z + ((-y2):+x2))
- (x2:+y2) = sqrt (1 - z*z)
+ (x2:+y2) = sqrt (__i1 - z*z)
atan z@(x:+y) = y2:+(-x2)
- where (x2:+y2) = log (((1-y):+x) / sqrt (1+z*z))
+ where (x2:+y2) = log (((__i1 - y):+x) / sqrt (__i1 + z*z))
- asinh z = log (z + sqrt (1+z*z))
- acosh z = log (z + (z+1) * sqrt ((z-1)/(z+1)))
- atanh z = log ((1+z) / sqrt (1-z*z))
+ asinh z = log (z + sqrt (__i1 + z*z))
+ acosh z = log (z + (z + __i1) * sqrt ((z - __i1)/(z + __i1)))
+ atanh z = log ((__i1 + z) / sqrt (__i1 - z*z))
instance (Text a) => Text (Complex a) where
= showParen (d > 6)
(showsPrec 7 a . showString " :+ " . showsPrec 7 b)
+ readList = _readList (readsPrec 0)
+ showList = _showList (showsPrec 0)
+
{-# SPECIALIZE instance Eq (Complex Double) #-}
{-# SPECIALIZE instance Num (Complex Double) #-}
{-# SPECIALIZE instance Fractional (Complex Double) #-}
{-# SPECIALIZE instance Floating (Complex Double) #-}
+{-# SPECIALIZE instance Text (Complex Double) #-}
---NO:{-# SPECIALIZE instance Eq (Complex Float) #-}
---NO:{-# SPECIALIZE instance Num (Complex Float) #-}
---NO:{-# SPECIALIZE instance Fractional (Complex Float) #-}
---NO:{-# SPECIALIZE instance Floating (Complex Float) #-}
-
#if defined(__UNBOXED_INSTANCES__)
{-# SPECIALIZE instance Eq (Complex Double#) #-}
-- ToDo: Complex Double# s/a{/a{Double#,?/
---{-# GENERATE_SPECS realPart a{Double#} #-}
+{-# GENERATE_SPECS realPart a{Double#} #-}
realPart :: Complex a -> a
realPart (x:+y) = x
---{-# GENERATE_SPECS imagPart a{Double#} #-}
+{-# GENERATE_SPECS imagPart a{Double#} #-}
imagPart :: Complex a -> a
imagPart (x:+y) = y
---{-# GENERATE_SPECS conjugate a{Double#,Double} #-}
-{-# GENERATE_SPECS conjugate a{Double} #-}
+{-# GENERATE_SPECS conjugate a{Double#,Double} #-}
conjugate :: (RealFloat a) => Complex a -> Complex a
conjugate (x:+y) = x :+ (-y)
---{-# GENERATE_SPECS mkPolar a{Double#,Double} #-}
-{-# GENERATE_SPECS mkPolar a{Double} #-}
+{-# GENERATE_SPECS mkPolar a{Double#,Double} #-}
mkPolar :: (RealFloat a) => a -> a -> Complex a
mkPolar r theta = r * cos theta :+ r * sin theta
---{-# GENERATE_SPECS cis a{Double#,Double} #-}
-{-# GENERATE_SPECS cis a{Double} #-}
+{-# GENERATE_SPECS cis a{Double#,Double} #-}
cis :: (RealFloat a) => a -> Complex a
cis theta = cos theta :+ sin theta
---{-# GENERATE_SPECS polar a{Double#,Double} #-}
-{-# GENERATE_SPECS polar a{Double} #-}
+{-# GENERATE_SPECS polar a{Double#,Double} #-}
polar :: (RealFloat a) => Complex a -> (a,a)
polar z = (magnitude z, phase z)
---{-# GENERATE_SPECS magnitude a{Double#,Double} #-}
-{-# GENERATE_SPECS magnitude a{Double} #-}
+{-# GENERATE_SPECS magnitude a{Double#,Double} #-}
magnitude :: (RealFloat a) => Complex a -> a
magnitude (x:+y) = scaleFloat k
- (sqrt ((scaleFloat mk x)^2 + (scaleFloat mk y)^2))
+ (sqrt ((scaleFloat mk x)^2 + (scaleFloat mk y)^2))
where k = max (exponent x) (exponent y)
mk = - k
---{-# GENERATE_SPECS phase a{Double#,Double} #-}
-{-# GENERATE_SPECS phase a{Double} #-}
+{-# GENERATE_SPECS phase a{Double#,Double} #-}
phase :: (RealFloat a) => Complex a -> a
phase (x:+y) = atan2 y x
-{-# GHC_PRAGMA INTERFACE VERSION 5 #-}
+{-# GHC_PRAGMA INTERFACE VERSION 6 #-}
interface PreludeComplex where
import PreludeBuiltin(Double(..), Tuple2)
import PreludeCore(Eq(..), Floating(..), Fractional(..), Num(..), RealFloat(..), Text(..))
imagPart :: Complex a -> a
{-# GHC_PRAGMA _A_ 1 _U_ 1 _N_ _S_ "U(AS)" {_A_ 1 _U_ 1 _N_ _N_ _F_ _IF_ARGS_ 1 1 X 1 _/\_ u0 -> \ (u1 :: u0) -> u1 _N_} _F_ _IF_ARGS_ 1 1 C 2 _/\_ u0 -> \ (u1 :: Complex u0) -> case u1 of { _ALG_ (:+) (u2 :: u0) (u3 :: u0) -> u3; _NO_DEFLT_ } _N_ #-}
magnitude :: RealFloat a => Complex a -> a
- {-# GHC_PRAGMA _A_ 1 _U_ 12 _N_ _S_ "U(ALAAAAALAS)" {_A_ 3 _U_ 2221 _N_ _N_ _N_ _N_} _N_ _SPECIALISE_ [ Double ] 1 { _A_ 1 _U_ 1 _N_ _S_ "U(LL)" {_A_ 2 _U_ 22 _N_ _N_ _N_ _N_} _N_ _N_ } #-}
+ {-# GHC_PRAGMA _A_ 1 _U_ 12 _N_ _S_ "U(ALAAAAALAS)" {_A_ 3 _U_ 2221 _N_ _N_ _N_ _N_} _N_ _SPECIALISE_ [ Double ] 1 { _A_ 1 _U_ 1 _N_ _S_ "U(U(P)U(P))" {_A_ 2 _U_ 22 _N_ _N_ _N_ _N_} _N_ _N_ } #-}
mkPolar :: RealFloat a => a -> a -> Complex a
{-# GHC_PRAGMA _A_ 3 _U_ 122 _N_ _N_ _N_ _SPECIALISE_ [ Double ] 1 { _A_ 2 _U_ 22 _N_ _N_ _N_ _N_ } #-}
phase :: RealFloat a => Complex a -> a
{-# GHC_PRAGMA _M_ PreludeComplex {-dfun-} _A_ 1 _U_ 2 _N_ _N_ _N_ _N_ #-}
instance Eq (Complex Double)
{-# GHC_PRAGMA _M_ PreludeComplex {-dfun-} _A_ 0 _N_ _N_ _N_ _F_ _IF_ARGS_ 0 0 X 3 _!_ _TUP_2 [(Complex Double -> Complex Double -> Bool), (Complex Double -> Complex Double -> Bool)] [_CONSTM_ Eq (==) (Complex Double), _CONSTM_ Eq (/=) (Complex Double)] _N_
- (==) = _A_ 2 _U_ 11 _N_ _S_ "U(U(P)L)U(U(P)L)" {_A_ 4 _U_ 2121 _N_ _N_ _F_ _IF_ARGS_ 0 4 XCXC 7 \ (u0 :: Double#) (u1 :: Double) (u2 :: Double#) (u3 :: Double) -> case _#_ eqDouble# [] [u0, u2] of { _ALG_ True -> case u1 of { _ALG_ D# (u4 :: Double#) -> case u3 of { _ALG_ D# (u5 :: Double#) -> _#_ eqDouble# [] [u4, u5]; _NO_DEFLT_ }; _NO_DEFLT_ }; False -> _!_ False [] []; _NO_DEFLT_ } _N_} _F_ _ALWAYS_ \ (u0 :: Complex Double) (u1 :: Complex Double) -> case u0 of { _ALG_ (:+) (u2 :: Double) (u3 :: Double) -> case u2 of { _ALG_ D# (u4 :: Double#) -> case u1 of { _ALG_ (:+) (u5 :: Double) (u6 :: Double) -> case u5 of { _ALG_ D# (u7 :: Double#) -> case _#_ eqDouble# [] [u4, u7] of { _ALG_ True -> case u3 of { _ALG_ D# (u8 :: Double#) -> case u6 of { _ALG_ D# (u9 :: Double#) -> _#_ eqDouble# [] [u8, u9]; _NO_DEFLT_ }; _NO_DEFLT_ }; False -> _!_ False [] []; _NO_DEFLT_ }; _NO_DEFLT_ }; _NO_DEFLT_ }; _NO_DEFLT_ }; _NO_DEFLT_ } _N_,
- (/=) = _A_ 2 _U_ 11 _N_ _S_ "U(U(P)L)U(U(P)L)" {_A_ 4 _U_ 2121 _N_ _N_ _F_ _IF_ARGS_ 0 4 XCXC 7 \ (u0 :: Double#) (u1 :: Double) (u2 :: Double#) (u3 :: Double) -> case _#_ neDouble# [] [u0, u2] of { _ALG_ True -> _!_ True [] []; False -> case u1 of { _ALG_ D# (u4 :: Double#) -> case u3 of { _ALG_ D# (u5 :: Double#) -> _#_ neDouble# [] [u4, u5]; _NO_DEFLT_ }; _NO_DEFLT_ }; _NO_DEFLT_ } _N_} _F_ _ALWAYS_ \ (u0 :: Complex Double) (u1 :: Complex Double) -> case u0 of { _ALG_ (:+) (u2 :: Double) (u3 :: Double) -> case u2 of { _ALG_ D# (u4 :: Double#) -> case u1 of { _ALG_ (:+) (u5 :: Double) (u6 :: Double) -> case u5 of { _ALG_ D# (u7 :: Double#) -> case _#_ neDouble# [] [u4, u7] of { _ALG_ True -> _!_ True [] []; False -> case u3 of { _ALG_ D# (u8 :: Double#) -> case u6 of { _ALG_ D# (u9 :: Double#) -> _#_ neDouble# [] [u8, u9]; _NO_DEFLT_ }; _NO_DEFLT_ }; _NO_DEFLT_ }; _NO_DEFLT_ }; _NO_DEFLT_ }; _NO_DEFLT_ }; _NO_DEFLT_ } _N_ #-}
+ (==) = { _A_ 2 _U_ 11 _N_ _S_ "U(U(P)L)U(U(P)L)" {_A_ 4 _U_ 2121 _N_ _N_ _F_ _IF_ARGS_ 0 4 XCXC 7 \ (u0 :: Double#) (u1 :: Double) (u2 :: Double#) (u3 :: Double) -> case _#_ eqDouble# [] [u0, u2] of { _ALG_ True -> case u1 of { _ALG_ D# (u4 :: Double#) -> case u3 of { _ALG_ D# (u5 :: Double#) -> _#_ eqDouble# [] [u4, u5]; _NO_DEFLT_ }; _NO_DEFLT_ }; False -> _!_ False [] []; _NO_DEFLT_ } _N_} _F_ _ALWAYS_ \ (u0 :: Complex Double) (u1 :: Complex Double) -> case u0 of { _ALG_ (:+) (u2 :: Double) (u3 :: Double) -> case u2 of { _ALG_ D# (u4 :: Double#) -> case u1 of { _ALG_ (:+) (u5 :: Double) (u6 :: Double) -> case u5 of { _ALG_ D# (u7 :: Double#) -> case _#_ eqDouble# [] [u4, u7] of { _ALG_ True -> case u3 of { _ALG_ D# (u8 :: Double#) -> case u6 of { _ALG_ D# (u9 :: Double#) -> _#_ eqDouble# [] [u8, u9]; _NO_DEFLT_ }; _NO_DEFLT_ }; False -> _!_ False [] []; _NO_DEFLT_ }; _NO_DEFLT_ }; _NO_DEFLT_ }; _NO_DEFLT_ }; _NO_DEFLT_ } _N_ },
+ (/=) = { _A_ 2 _U_ 11 _N_ _S_ "U(U(P)L)U(U(P)L)" {_A_ 4 _U_ 2121 _N_ _N_ _F_ _IF_ARGS_ 0 4 XCXC 7 \ (u0 :: Double#) (u1 :: Double) (u2 :: Double#) (u3 :: Double) -> case _#_ neDouble# [] [u0, u2] of { _ALG_ True -> _!_ True [] []; False -> case u1 of { _ALG_ D# (u4 :: Double#) -> case u3 of { _ALG_ D# (u5 :: Double#) -> _#_ neDouble# [] [u4, u5]; _NO_DEFLT_ }; _NO_DEFLT_ }; _NO_DEFLT_ } _N_} _F_ _ALWAYS_ \ (u0 :: Complex Double) (u1 :: Complex Double) -> case u0 of { _ALG_ (:+) (u2 :: Double) (u3 :: Double) -> case u2 of { _ALG_ D# (u4 :: Double#) -> case u1 of { _ALG_ (:+) (u5 :: Double) (u6 :: Double) -> case u5 of { _ALG_ D# (u7 :: Double#) -> case _#_ neDouble# [] [u4, u7] of { _ALG_ True -> _!_ True [] []; False -> case u3 of { _ALG_ D# (u8 :: Double#) -> case u6 of { _ALG_ D# (u9 :: Double#) -> _#_ neDouble# [] [u8, u9]; _NO_DEFLT_ }; _NO_DEFLT_ }; _NO_DEFLT_ }; _NO_DEFLT_ }; _NO_DEFLT_ }; _NO_DEFLT_ }; _NO_DEFLT_ } _N_ } #-}
instance RealFloat a => Floating (Complex a)
{-# GHC_PRAGMA _M_ PreludeComplex {-dfun-} _A_ 2 _U_ 22 _N_ _N_ _N_ _N_ #-}
instance Floating (Complex Double)
{-# GHC_PRAGMA _M_ PreludeComplex {-dfun-} _A_ 0 _N_ _N_ _N_ _F_ _IF_ARGS_ 0 0 X 20 _!_ _TUP_19 [{{Fractional (Complex Double)}}, (Complex Double), (Complex Double -> Complex Double), (Complex Double -> Complex Double), (Complex Double -> Complex Double), (Complex Double -> Complex Double -> Complex Double), (Complex Double -> Complex Double -> Complex Double), (Complex Double -> Complex Double), (Complex Double -> Complex Double), (Complex Double -> Complex Double), (Complex Double -> Complex Double), (Complex Double -> Complex Double), (Complex Double -> Complex Double), (Complex Double -> Complex Double), (Complex Double -> Complex Double), (Complex Double -> Complex Double), (Complex Double -> Complex Double), (Complex Double -> Complex Double), (Complex Double -> Complex Double)] [_DFUN_ Fractional (Complex Double), _CONSTM_ Floating pi (Complex Double), _CONSTM_ Floating exp (Complex Double), _CONSTM_ Floating log (Complex Double), _CONSTM_ Floating sqrt (Complex Double), _CONSTM_ Floating (**) (Complex Double), _CONSTM_ Floating logBase (Complex Double), _CONSTM_ Floating sin (Complex Double), _CONSTM_ Floating cos (Complex Double), _CONSTM_ Floating tan (Complex Double), _CONSTM_ Floating asin (Complex Double), _CONSTM_ Floating acos (Complex Double), _CONSTM_ Floating atan (Complex Double), _CONSTM_ Floating sinh (Complex Double), _CONSTM_ Floating cosh (Complex Double), _CONSTM_ Floating tanh (Complex Double), _CONSTM_ Floating asinh (Complex Double), _CONSTM_ Floating acosh (Complex Double), _CONSTM_ Floating atanh (Complex Double)] _N_
- pi = _A_ 0 _N_ _N_ _N_ _N_ _N_,
- exp = _A_ 1 _U_ 1 _N_ _S_ "U(LL)" {_A_ 2 _U_ 12 _N_ _N_ _N_ _N_} _N_ _N_,
- log = _A_ 1 _U_ 2 _N_ _N_ _N_ _N_,
- sqrt = _A_ 1 _U_ 1 _N_ _S_ "U(U(P)L)" {_A_ 2 _U_ 22 _N_ _N_ _N_ _N_} _N_ _N_,
- (**) = _A_ 2 _U_ 21 _N_ _S_ "LU(LL)" {_A_ 3 _U_ 222 _N_ _N_ _N_ _N_} _N_ _N_,
- logBase = _A_ 2 _U_ 22 _N_ _N_ _N_ _N_,
- sin = _A_ 1 _U_ 1 _N_ _S_ "U(LL)" {_A_ 2 _U_ 22 _N_ _N_ _N_ _N_} _N_ _N_,
- cos = _A_ 1 _U_ 1 _N_ _S_ "U(LL)" {_A_ 2 _U_ 22 _N_ _N_ _N_ _N_} _N_ _N_,
- tan = _A_ 1 _U_ 1 _N_ _S_ "U(LL)" {_A_ 2 _U_ 22 _N_ _N_ _N_ _N_} _N_ _N_,
- asin = _A_ 1 _U_ 1 _N_ _S_ "U(LL)" {_A_ 2 _U_ 22 _N_ _N_ _N_ _N_} _N_ _N_,
- acos = _A_ 1 _U_ 1 _N_ _S_ "U(LL)" {_A_ 2 _U_ 22 _N_ _N_ _N_ _N_} _N_ _N_,
- atan = _A_ 1 _U_ 1 _N_ _S_ "U(LL)" {_A_ 2 _U_ 22 _N_ _N_ _N_ _N_} _N_ _N_,
- sinh = _A_ 1 _U_ 1 _N_ _S_ "U(LL)" {_A_ 2 _U_ 22 _N_ _N_ _N_ _N_} _N_ _N_,
- cosh = _A_ 1 _U_ 1 _N_ _S_ "U(LL)" {_A_ 2 _U_ 22 _N_ _N_ _N_ _N_} _N_ _N_,
- tanh = _A_ 1 _U_ 1 _N_ _S_ "U(LL)" {_A_ 2 _U_ 22 _N_ _N_ _N_ _N_} _N_ _N_,
- asinh = _A_ 1 _U_ 1 _N_ _N_ _N_ _N_,
- acosh = _A_ 1 _U_ 1 _N_ _N_ _N_ _N_,
- atanh = _A_ 1 _U_ 1 _N_ _N_ _N_ _N_ #-}
+ pi = { _A_ 0 _N_ _N_ _N_ _F_ _IF_ARGS_ 0 0 X 3 _!_ (:+) [Double] [_CONSTM_ Floating pi (Double), _SPEC_ _ORIG_ PreludeCore __i0 [ (Double) ]] _N_ },
+ exp = { _A_ 1 _U_ 1 _N_ _S_ "U(LL)" {_A_ 2 _U_ 12 _N_ _N_ _N_ _N_} _N_ _N_ },
+ log = { _A_ 1 _U_ 2 _N_ _N_ _N_ _N_ },
+ sqrt = { _A_ 1 _U_ 1 _N_ _S_ "U(U(P)L)" {_A_ 2 _U_ 22 _N_ _N_ _N_ _N_} _N_ _N_ },
+ (**) = { _A_ 2 _U_ 21 _N_ _S_ "LU(LL)" {_A_ 3 _U_ 222 _N_ _N_ _N_ _N_} _N_ _N_ },
+ logBase = { _A_ 2 _U_ 22 _N_ _N_ _N_ _N_ },
+ sin = { _A_ 1 _U_ 1 _N_ _S_ "U(LL)" {_A_ 2 _U_ 22 _N_ _N_ _N_ _N_} _N_ _N_ },
+ cos = { _A_ 1 _U_ 1 _N_ _S_ "U(LL)" {_A_ 2 _U_ 22 _N_ _N_ _N_ _N_} _N_ _N_ },
+ tan = { _A_ 1 _U_ 1 _N_ _S_ "U(LL)" {_A_ 2 _U_ 22 _N_ _N_ _N_ _N_} _N_ _N_ },
+ asin = { _A_ 1 _U_ 1 _N_ _S_ "U(LL)" {_A_ 2 _U_ 22 _N_ _N_ _N_ _N_} _N_ _N_ },
+ acos = { _A_ 1 _U_ 1 _N_ _S_ "U(LL)" {_A_ 2 _U_ 22 _N_ _N_ _N_ _N_} _N_ _N_ },
+ atan = { _A_ 1 _U_ 1 _N_ _S_ "U(LL)" {_A_ 2 _U_ 22 _N_ _N_ _N_ _N_} _N_ _N_ },
+ sinh = { _A_ 1 _U_ 1 _N_ _S_ "U(LL)" {_A_ 2 _U_ 22 _N_ _N_ _N_ _N_} _N_ _N_ },
+ cosh = { _A_ 1 _U_ 1 _N_ _S_ "U(LL)" {_A_ 2 _U_ 22 _N_ _N_ _N_ _N_} _N_ _N_ },
+ tanh = { _A_ 1 _U_ 1 _N_ _S_ "U(LL)" {_A_ 2 _U_ 22 _N_ _N_ _N_ _N_} _N_ _N_ },
+ asinh = { _A_ 1 _U_ 1 _N_ _N_ _N_ _N_ },
+ acosh = { _A_ 1 _U_ 1 _N_ _N_ _N_ _N_ },
+ atanh = { _A_ 1 _U_ 1 _N_ _N_ _N_ _N_ } #-}
instance RealFloat a => Fractional (Complex a)
{-# GHC_PRAGMA _M_ PreludeComplex {-dfun-} _A_ 2 _U_ 22 _N_ _N_ _N_ _N_ #-}
instance Fractional (Complex Double)
{-# GHC_PRAGMA _M_ PreludeComplex {-dfun-} _A_ 0 _N_ _N_ _N_ _F_ _IF_ARGS_ 0 0 X 5 _!_ _TUP_4 [{{Num (Complex Double)}}, (Complex Double -> Complex Double -> Complex Double), (Complex Double -> Complex Double), (Ratio Integer -> Complex Double)] [_DFUN_ Num (Complex Double), _CONSTM_ Fractional (/) (Complex Double), _CONSTM_ Fractional recip (Complex Double), _CONSTM_ Fractional fromRational (Complex Double)] _N_
- (/) = _A_ 2 _U_ 11 _N_ _S_ "U(LL)U(LL)" {_A_ 4 _U_ 2222 _N_ _N_ _N_ _N_} _N_ _N_,
- recip = _A_ 1 _U_ 1 _N_ _S_ "U(LL)" {_A_ 2 _U_ 22 _N_ _N_ _N_ _N_} _N_ _N_,
- fromRational = _A_ 1 _U_ 2 _N_ _N_ _N_ _N_ #-}
+ (/) = { _A_ 2 _U_ 11 _N_ _S_ "U(LL)U(LL)" {_A_ 4 _U_ 2222 _N_ _N_ _N_ _N_} _N_ _N_ },
+ recip = { _A_ 1 _U_ 1 _N_ _S_ "U(LL)" {_A_ 2 _U_ 22 _N_ _N_ _N_ _N_} _F_ _IF_ARGS_ 0 1 X 3 \ (u0 :: Complex Double) -> _APP_ _CONSTM_ Fractional (/) (Complex Double) [ _SPEC_ _ORIG_ PreludeCore __i1 [ (Complex Double) ], u0 ] _N_ },
+ fromRational = { _A_ 1 _U_ 1 _N_ _N_ _N_ _N_ } #-}
instance RealFloat a => Num (Complex a)
{-# GHC_PRAGMA _M_ PreludeComplex {-dfun-} _A_ 3 _U_ 222 _N_ _N_ _N_ _N_ #-}
instance Num (Complex Double)
- {-# GHC_PRAGMA _M_ PreludeComplex {-dfun-} _A_ 0 _N_ _N_ _N_ _N_ _N_
- (+) = _A_ 2 _U_ 11 _N_ _S_ "U(LL)U(LL)" {_A_ 4 _U_ 1111 _N_ _N_ _N_ _N_} _N_ _N_,
- (-) = _A_ 2 _U_ 11 _N_ _S_ "U(LL)U(LL)" {_A_ 4 _U_ 1111 _N_ _N_ _N_ _N_} _N_ _N_,
- (*) = _A_ 2 _U_ 11 _N_ _S_ "U(LL)U(LL)" {_A_ 4 _U_ 2222 _N_ _N_ _N_ _N_} _N_ _N_,
- negate = _A_ 1 _U_ 1 _N_ _S_ "U(LL)" {_A_ 2 _U_ 11 _N_ _N_ _N_ _N_} _N_ _N_,
- abs = _A_ 1 _U_ 1 _N_ _N_ _N_ _N_,
- signum = _A_ 1 _U_ 1 _N_ _S_ "U(U(P)L)" {_A_ 2 _U_ 22 _N_ _N_ _N_ _N_} _N_ _N_,
- fromInteger = _A_ 1 _U_ 1 _N_ _N_ _N_ _N_,
- fromInt = _A_ 1 _U_ 1 _N_ _N_ _N_ _N_ #-}
+ {-# GHC_PRAGMA _M_ PreludeComplex {-dfun-} _A_ 0 _N_ _N_ _N_ _F_ _IF_ARGS_ 0 0 X 11 _!_ _TUP_10 [{{Eq (Complex Double)}}, {{Text (Complex Double)}}, (Complex Double -> Complex Double -> Complex Double), (Complex Double -> Complex Double -> Complex Double), (Complex Double -> Complex Double -> Complex Double), (Complex Double -> Complex Double), (Complex Double -> Complex Double), (Complex Double -> Complex Double), (Integer -> Complex Double), (Int -> Complex Double)] [_DFUN_ Eq (Complex Double), _DFUN_ Text (Complex Double), _CONSTM_ Num (+) (Complex Double), _CONSTM_ Num (-) (Complex Double), _CONSTM_ Num (*) (Complex Double), _CONSTM_ Num negate (Complex Double), _CONSTM_ Num abs (Complex Double), _CONSTM_ Num signum (Complex Double), _CONSTM_ Num fromInteger (Complex Double), _CONSTM_ Num fromInt (Complex Double)] _N_
+ (+) = { _A_ 2 _U_ 11 _N_ _S_ "U(LL)U(LL)" {_A_ 4 _U_ 1111 _N_ _N_ _N_ _N_} _N_ _N_ },
+ (-) = { _A_ 2 _U_ 11 _N_ _S_ "U(LL)U(LL)" {_A_ 4 _U_ 1111 _N_ _N_ _N_ _N_} _N_ _N_ },
+ (*) = { _A_ 2 _U_ 11 _N_ _S_ "U(LL)U(LL)" {_A_ 4 _U_ 2222 _N_ _N_ _N_ _N_} _N_ _N_ },
+ negate = { _A_ 1 _U_ 1 _N_ _S_ "U(LL)" {_A_ 2 _U_ 11 _N_ _N_ _N_ _N_} _N_ _N_ },
+ abs = { _A_ 1 _U_ 1 _N_ _N_ _N_ _N_ },
+ signum = { _A_ 1 _U_ 1 _N_ _S_ "U(U(P)L)" {_A_ 2 _U_ 22 _N_ _N_ _N_ _N_} _N_ _N_ },
+ fromInteger = { _A_ 1 _U_ 1 _N_ _N_ _N_ _N_ },
+ fromInt = { _A_ 1 _U_ 1 _N_ _N_ _N_ _N_ } #-}
instance Text a => Text (Complex a)
{-# GHC_PRAGMA _M_ PreludeComplex {-dfun-} _A_ 1 _U_ 2 _N_ _N_ _N_ _N_ #-}
+instance Text (Complex Double)
+ {-# GHC_PRAGMA _M_ PreludeComplex {-dfun-} _A_ 0 _N_ _N_ _N_ _F_ _IF_ARGS_ 0 0 X 5 _!_ _TUP_4 [(Int -> [Char] -> [(Complex Double, [Char])]), (Int -> Complex Double -> [Char] -> [Char]), ([Char] -> [([Complex Double], [Char])]), ([Complex Double] -> [Char] -> [Char])] [_CONSTM_ Text readsPrec (Complex Double), _CONSTM_ Text showsPrec (Complex Double), _CONSTM_ Text readList (Complex Double), _CONSTM_ Text showList (Complex Double)] _N_
+ readsPrec = { _A_ 1 _U_ 12 _N_ _S_ "U(P)" {_A_ 1 _U_ 22 _N_ _N_ _N_ _N_} _N_ _N_ },
+ showsPrec = { _A_ 2 _U_ 112 _N_ _S_ "LU(LL)" {_A_ 3 _U_ 1222 _N_ _N_ _N_ _N_} _N_ _N_ },
+ readList = { _A_ 0 _U_ 2 _N_ _N_ _N_ _N_ },
+ showList = { _A_ 1 _U_ 12 _N_ _N_ _N_ _N_ } #-}
-{-# GHC_PRAGMA INTERFACE VERSION 5 #-}
+{-# GHC_PRAGMA INTERFACE VERSION 6 #-}
interface PreludeComplex where
import PreludeBuiltin(Double(..), Tuple2)
import PreludeCore(Eq(..), Floating(..), Fractional(..), Num(..), RealFloat(..), Text(..))
imagPart :: Complex a -> a
{-# GHC_PRAGMA _A_ 1 _U_ 1 _N_ _S_ "U(AS)" {_A_ 1 _U_ 1 _N_ _N_ _F_ _IF_ARGS_ 1 1 X 1 _/\_ u0 -> \ (u1 :: u0) -> u1 _N_} _F_ _IF_ARGS_ 1 1 C 2 _/\_ u0 -> \ (u1 :: Complex u0) -> case u1 of { _ALG_ (:+) (u2 :: u0) (u3 :: u0) -> u3; _NO_DEFLT_ } _N_ #-}
magnitude :: RealFloat a => Complex a -> a
- {-# GHC_PRAGMA _A_ 1 _U_ 12 _N_ _S_ "U(ALAAAAALAS)" {_A_ 3 _U_ 2221 _N_ _N_ _N_ _N_} _N_ _SPECIALISE_ [ Double ] 1 { _A_ 1 _U_ 1 _N_ _S_ "U(LL)" {_A_ 2 _U_ 22 _N_ _N_ _N_ _N_} _N_ _N_ } #-}
+ {-# GHC_PRAGMA _A_ 1 _U_ 12 _N_ _S_ "U(ALAAAAALAS)" {_A_ 3 _U_ 2221 _N_ _N_ _N_ _N_} _N_ _SPECIALISE_ [ Double ] 1 { _A_ 1 _U_ 1 _N_ _S_ "U(U(P)U(P))" {_A_ 2 _U_ 22 _N_ _N_ _N_ _N_} _N_ _N_ } #-}
mkPolar :: RealFloat a => a -> a -> Complex a
{-# GHC_PRAGMA _A_ 3 _U_ 122 _N_ _N_ _N_ _SPECIALISE_ [ Double ] 1 { _A_ 2 _U_ 22 _N_ _N_ _N_ _N_ } #-}
phase :: RealFloat a => Complex a -> a
{-# GHC_PRAGMA _M_ PreludeComplex {-dfun-} _A_ 1 _U_ 2 _N_ _N_ _N_ _N_ #-}
instance Eq (Complex Double)
{-# GHC_PRAGMA _M_ PreludeComplex {-dfun-} _A_ 0 _N_ _N_ _N_ _F_ _IF_ARGS_ 0 0 X 3 _!_ _TUP_2 [(Complex Double -> Complex Double -> Bool), (Complex Double -> Complex Double -> Bool)] [_CONSTM_ Eq (==) (Complex Double), _CONSTM_ Eq (/=) (Complex Double)] _N_
- (==) = _A_ 2 _U_ 11 _N_ _S_ "U(U(P)L)U(U(P)L)" {_A_ 4 _U_ 2121 _N_ _N_ _F_ _IF_ARGS_ 0 4 XCXC 7 \ (u0 :: Double#) (u1 :: Double) (u2 :: Double#) (u3 :: Double) -> case _#_ eqDouble# [] [u0, u2] of { _ALG_ True -> case u1 of { _ALG_ D# (u4 :: Double#) -> case u3 of { _ALG_ D# (u5 :: Double#) -> _#_ eqDouble# [] [u4, u5]; _NO_DEFLT_ }; _NO_DEFLT_ }; False -> _!_ False [] []; _NO_DEFLT_ } _N_} _F_ _ALWAYS_ \ (u0 :: Complex Double) (u1 :: Complex Double) -> case u0 of { _ALG_ (:+) (u2 :: Double) (u3 :: Double) -> case u2 of { _ALG_ D# (u4 :: Double#) -> case u1 of { _ALG_ (:+) (u5 :: Double) (u6 :: Double) -> case u5 of { _ALG_ D# (u7 :: Double#) -> case _#_ eqDouble# [] [u4, u7] of { _ALG_ True -> case u3 of { _ALG_ D# (u8 :: Double#) -> case u6 of { _ALG_ D# (u9 :: Double#) -> _#_ eqDouble# [] [u8, u9]; _NO_DEFLT_ }; _NO_DEFLT_ }; False -> _!_ False [] []; _NO_DEFLT_ }; _NO_DEFLT_ }; _NO_DEFLT_ }; _NO_DEFLT_ }; _NO_DEFLT_ } _N_,
- (/=) = _A_ 2 _U_ 11 _N_ _S_ "U(U(P)L)U(U(P)L)" {_A_ 4 _U_ 2121 _N_ _N_ _F_ _IF_ARGS_ 0 4 XCXC 7 \ (u0 :: Double#) (u1 :: Double) (u2 :: Double#) (u3 :: Double) -> case _#_ neDouble# [] [u0, u2] of { _ALG_ True -> _!_ True [] []; False -> case u1 of { _ALG_ D# (u4 :: Double#) -> case u3 of { _ALG_ D# (u5 :: Double#) -> _#_ neDouble# [] [u4, u5]; _NO_DEFLT_ }; _NO_DEFLT_ }; _NO_DEFLT_ } _N_} _F_ _ALWAYS_ \ (u0 :: Complex Double) (u1 :: Complex Double) -> case u0 of { _ALG_ (:+) (u2 :: Double) (u3 :: Double) -> case u2 of { _ALG_ D# (u4 :: Double#) -> case u1 of { _ALG_ (:+) (u5 :: Double) (u6 :: Double) -> case u5 of { _ALG_ D# (u7 :: Double#) -> case _#_ neDouble# [] [u4, u7] of { _ALG_ True -> _!_ True [] []; False -> case u3 of { _ALG_ D# (u8 :: Double#) -> case u6 of { _ALG_ D# (u9 :: Double#) -> _#_ neDouble# [] [u8, u9]; _NO_DEFLT_ }; _NO_DEFLT_ }; _NO_DEFLT_ }; _NO_DEFLT_ }; _NO_DEFLT_ }; _NO_DEFLT_ }; _NO_DEFLT_ } _N_ #-}
+ (==) = { _A_ 2 _U_ 11 _N_ _S_ "U(U(P)L)U(U(P)L)" {_A_ 4 _U_ 2121 _N_ _N_ _F_ _IF_ARGS_ 0 4 XCXC 7 \ (u0 :: Double#) (u1 :: Double) (u2 :: Double#) (u3 :: Double) -> case _#_ eqDouble# [] [u0, u2] of { _ALG_ True -> case u1 of { _ALG_ D# (u4 :: Double#) -> case u3 of { _ALG_ D# (u5 :: Double#) -> _#_ eqDouble# [] [u4, u5]; _NO_DEFLT_ }; _NO_DEFLT_ }; False -> _!_ False [] []; _NO_DEFLT_ } _N_} _F_ _ALWAYS_ \ (u0 :: Complex Double) (u1 :: Complex Double) -> case u0 of { _ALG_ (:+) (u2 :: Double) (u3 :: Double) -> case u2 of { _ALG_ D# (u4 :: Double#) -> case u1 of { _ALG_ (:+) (u5 :: Double) (u6 :: Double) -> case u5 of { _ALG_ D# (u7 :: Double#) -> case _#_ eqDouble# [] [u4, u7] of { _ALG_ True -> case u3 of { _ALG_ D# (u8 :: Double#) -> case u6 of { _ALG_ D# (u9 :: Double#) -> _#_ eqDouble# [] [u8, u9]; _NO_DEFLT_ }; _NO_DEFLT_ }; False -> _!_ False [] []; _NO_DEFLT_ }; _NO_DEFLT_ }; _NO_DEFLT_ }; _NO_DEFLT_ }; _NO_DEFLT_ } _N_ },
+ (/=) = { _A_ 2 _U_ 11 _N_ _S_ "U(U(P)L)U(U(P)L)" {_A_ 4 _U_ 2121 _N_ _N_ _F_ _IF_ARGS_ 0 4 XCXC 7 \ (u0 :: Double#) (u1 :: Double) (u2 :: Double#) (u3 :: Double) -> case _#_ neDouble# [] [u0, u2] of { _ALG_ True -> _!_ True [] []; False -> case u1 of { _ALG_ D# (u4 :: Double#) -> case u3 of { _ALG_ D# (u5 :: Double#) -> _#_ neDouble# [] [u4, u5]; _NO_DEFLT_ }; _NO_DEFLT_ }; _NO_DEFLT_ } _N_} _F_ _ALWAYS_ \ (u0 :: Complex Double) (u1 :: Complex Double) -> case u0 of { _ALG_ (:+) (u2 :: Double) (u3 :: Double) -> case u2 of { _ALG_ D# (u4 :: Double#) -> case u1 of { _ALG_ (:+) (u5 :: Double) (u6 :: Double) -> case u5 of { _ALG_ D# (u7 :: Double#) -> case _#_ neDouble# [] [u4, u7] of { _ALG_ True -> _!_ True [] []; False -> case u3 of { _ALG_ D# (u8 :: Double#) -> case u6 of { _ALG_ D# (u9 :: Double#) -> _#_ neDouble# [] [u8, u9]; _NO_DEFLT_ }; _NO_DEFLT_ }; _NO_DEFLT_ }; _NO_DEFLT_ }; _NO_DEFLT_ }; _NO_DEFLT_ }; _NO_DEFLT_ } _N_ } #-}
instance RealFloat a => Floating (Complex a)
{-# GHC_PRAGMA _M_ PreludeComplex {-dfun-} _A_ 2 _U_ 22 _N_ _N_ _N_ _N_ #-}
instance Floating (Complex Double)
{-# GHC_PRAGMA _M_ PreludeComplex {-dfun-} _A_ 0 _N_ _N_ _N_ _F_ _IF_ARGS_ 0 0 X 20 _!_ _TUP_19 [{{Fractional (Complex Double)}}, (Complex Double), (Complex Double -> Complex Double), (Complex Double -> Complex Double), (Complex Double -> Complex Double), (Complex Double -> Complex Double -> Complex Double), (Complex Double -> Complex Double -> Complex Double), (Complex Double -> Complex Double), (Complex Double -> Complex Double), (Complex Double -> Complex Double), (Complex Double -> Complex Double), (Complex Double -> Complex Double), (Complex Double -> Complex Double), (Complex Double -> Complex Double), (Complex Double -> Complex Double), (Complex Double -> Complex Double), (Complex Double -> Complex Double), (Complex Double -> Complex Double), (Complex Double -> Complex Double)] [_DFUN_ Fractional (Complex Double), _CONSTM_ Floating pi (Complex Double), _CONSTM_ Floating exp (Complex Double), _CONSTM_ Floating log (Complex Double), _CONSTM_ Floating sqrt (Complex Double), _CONSTM_ Floating (**) (Complex Double), _CONSTM_ Floating logBase (Complex Double), _CONSTM_ Floating sin (Complex Double), _CONSTM_ Floating cos (Complex Double), _CONSTM_ Floating tan (Complex Double), _CONSTM_ Floating asin (Complex Double), _CONSTM_ Floating acos (Complex Double), _CONSTM_ Floating atan (Complex Double), _CONSTM_ Floating sinh (Complex Double), _CONSTM_ Floating cosh (Complex Double), _CONSTM_ Floating tanh (Complex Double), _CONSTM_ Floating asinh (Complex Double), _CONSTM_ Floating acosh (Complex Double), _CONSTM_ Floating atanh (Complex Double)] _N_
- pi = _A_ 0 _N_ _N_ _N_ _N_ _N_,
- exp = _A_ 1 _U_ 1 _N_ _S_ "U(LL)" {_A_ 2 _U_ 12 _N_ _N_ _N_ _N_} _N_ _N_,
- log = _A_ 1 _U_ 2 _N_ _N_ _N_ _N_,
- sqrt = _A_ 1 _U_ 1 _N_ _S_ "U(U(P)L)" {_A_ 2 _U_ 22 _N_ _N_ _N_ _N_} _N_ _N_,
- (**) = _A_ 2 _U_ 21 _N_ _S_ "LU(LL)" {_A_ 3 _U_ 222 _N_ _N_ _N_ _N_} _N_ _N_,
- logBase = _A_ 2 _U_ 22 _N_ _N_ _N_ _N_,
- sin = _A_ 1 _U_ 1 _N_ _S_ "U(LL)" {_A_ 2 _U_ 22 _N_ _N_ _N_ _N_} _N_ _N_,
- cos = _A_ 1 _U_ 1 _N_ _S_ "U(LL)" {_A_ 2 _U_ 22 _N_ _N_ _N_ _N_} _N_ _N_,
- tan = _A_ 1 _U_ 1 _N_ _S_ "U(LL)" {_A_ 2 _U_ 22 _N_ _N_ _N_ _N_} _N_ _N_,
- asin = _A_ 1 _U_ 1 _N_ _S_ "U(LL)" {_A_ 2 _U_ 22 _N_ _N_ _N_ _N_} _N_ _N_,
- acos = _A_ 1 _U_ 1 _N_ _S_ "U(LL)" {_A_ 2 _U_ 22 _N_ _N_ _N_ _N_} _N_ _N_,
- atan = _A_ 1 _U_ 1 _N_ _S_ "U(LL)" {_A_ 2 _U_ 22 _N_ _N_ _N_ _N_} _N_ _N_,
- sinh = _A_ 1 _U_ 1 _N_ _S_ "U(LL)" {_A_ 2 _U_ 22 _N_ _N_ _N_ _N_} _N_ _N_,
- cosh = _A_ 1 _U_ 1 _N_ _S_ "U(LL)" {_A_ 2 _U_ 22 _N_ _N_ _N_ _N_} _N_ _N_,
- tanh = _A_ 1 _U_ 1 _N_ _S_ "U(LL)" {_A_ 2 _U_ 22 _N_ _N_ _N_ _N_} _N_ _N_,
- asinh = _A_ 1 _U_ 1 _N_ _N_ _N_ _N_,
- acosh = _A_ 1 _U_ 1 _N_ _N_ _N_ _N_,
- atanh = _A_ 1 _U_ 1 _N_ _N_ _N_ _N_ #-}
+ pi = { _A_ 0 _N_ _N_ _N_ _F_ _IF_ARGS_ 0 0 X 3 _!_ (:+) [Double] [_CONSTM_ Floating pi (Double), _SPEC_ _ORIG_ PreludeCore __i0 [ (Double) ]] _N_ },
+ exp = { _A_ 1 _U_ 1 _N_ _S_ "U(LL)" {_A_ 2 _U_ 12 _N_ _N_ _N_ _N_} _N_ _N_ },
+ log = { _A_ 1 _U_ 2 _N_ _N_ _N_ _N_ },
+ sqrt = { _A_ 1 _U_ 1 _N_ _S_ "U(U(P)L)" {_A_ 2 _U_ 22 _N_ _N_ _N_ _N_} _N_ _N_ },
+ (**) = { _A_ 2 _U_ 21 _N_ _S_ "LU(LL)" {_A_ 3 _U_ 222 _N_ _N_ _N_ _N_} _N_ _N_ },
+ logBase = { _A_ 2 _U_ 22 _N_ _N_ _N_ _N_ },
+ sin = { _A_ 1 _U_ 1 _N_ _S_ "U(LL)" {_A_ 2 _U_ 22 _N_ _N_ _N_ _N_} _N_ _N_ },
+ cos = { _A_ 1 _U_ 1 _N_ _S_ "U(LL)" {_A_ 2 _U_ 22 _N_ _N_ _N_ _N_} _N_ _N_ },
+ tan = { _A_ 1 _U_ 1 _N_ _S_ "U(LL)" {_A_ 2 _U_ 22 _N_ _N_ _N_ _N_} _N_ _N_ },
+ asin = { _A_ 1 _U_ 1 _N_ _S_ "U(LL)" {_A_ 2 _U_ 22 _N_ _N_ _N_ _N_} _N_ _N_ },
+ acos = { _A_ 1 _U_ 1 _N_ _S_ "U(LL)" {_A_ 2 _U_ 22 _N_ _N_ _N_ _N_} _N_ _N_ },
+ atan = { _A_ 1 _U_ 1 _N_ _S_ "U(LL)" {_A_ 2 _U_ 22 _N_ _N_ _N_ _N_} _N_ _N_ },
+ sinh = { _A_ 1 _U_ 1 _N_ _S_ "U(LL)" {_A_ 2 _U_ 22 _N_ _N_ _N_ _N_} _N_ _N_ },
+ cosh = { _A_ 1 _U_ 1 _N_ _S_ "U(LL)" {_A_ 2 _U_ 22 _N_ _N_ _N_ _N_} _N_ _N_ },
+ tanh = { _A_ 1 _U_ 1 _N_ _S_ "U(LL)" {_A_ 2 _U_ 22 _N_ _N_ _N_ _N_} _N_ _N_ },
+ asinh = { _A_ 1 _U_ 1 _N_ _N_ _N_ _N_ },
+ acosh = { _A_ 1 _U_ 1 _N_ _N_ _N_ _N_ },
+ atanh = { _A_ 1 _U_ 1 _N_ _N_ _N_ _N_ } #-}
instance RealFloat a => Fractional (Complex a)
{-# GHC_PRAGMA _M_ PreludeComplex {-dfun-} _A_ 2 _U_ 22 _N_ _N_ _N_ _N_ #-}
instance Fractional (Complex Double)
{-# GHC_PRAGMA _M_ PreludeComplex {-dfun-} _A_ 0 _N_ _N_ _N_ _F_ _IF_ARGS_ 0 0 X 5 _!_ _TUP_4 [{{Num (Complex Double)}}, (Complex Double -> Complex Double -> Complex Double), (Complex Double -> Complex Double), (Ratio Integer -> Complex Double)] [_DFUN_ Num (Complex Double), _CONSTM_ Fractional (/) (Complex Double), _CONSTM_ Fractional recip (Complex Double), _CONSTM_ Fractional fromRational (Complex Double)] _N_
- (/) = _A_ 2 _U_ 11 _N_ _S_ "U(LL)U(LL)" {_A_ 4 _U_ 2222 _N_ _N_ _N_ _N_} _N_ _N_,
- recip = _A_ 1 _U_ 1 _N_ _S_ "U(LL)" {_A_ 2 _U_ 22 _N_ _N_ _N_ _N_} _N_ _N_,
- fromRational = _A_ 1 _U_ 2 _N_ _N_ _N_ _N_ #-}
+ (/) = { _A_ 2 _U_ 11 _N_ _S_ "U(LL)U(LL)" {_A_ 4 _U_ 2222 _N_ _N_ _N_ _N_} _N_ _N_ },
+ recip = { _A_ 1 _U_ 1 _N_ _S_ "U(LL)" {_A_ 2 _U_ 22 _N_ _N_ _N_ _N_} _F_ _IF_ARGS_ 0 1 X 3 \ (u0 :: Complex Double) -> _APP_ _CONSTM_ Fractional (/) (Complex Double) [ _SPEC_ _ORIG_ PreludeCore __i1 [ (Complex Double) ], u0 ] _N_ },
+ fromRational = { _A_ 1 _U_ 1 _N_ _N_ _N_ _N_ } #-}
instance RealFloat a => Num (Complex a)
{-# GHC_PRAGMA _M_ PreludeComplex {-dfun-} _A_ 3 _U_ 222 _N_ _N_ _N_ _N_ #-}
instance Num (Complex Double)
- {-# GHC_PRAGMA _M_ PreludeComplex {-dfun-} _A_ 0 _N_ _N_ _N_ _N_ _N_
- (+) = _A_ 2 _U_ 11 _N_ _S_ "U(LL)U(LL)" {_A_ 4 _U_ 1111 _N_ _N_ _N_ _N_} _N_ _N_,
- (-) = _A_ 2 _U_ 11 _N_ _S_ "U(LL)U(LL)" {_A_ 4 _U_ 1111 _N_ _N_ _N_ _N_} _N_ _N_,
- (*) = _A_ 2 _U_ 11 _N_ _S_ "U(LL)U(LL)" {_A_ 4 _U_ 2222 _N_ _N_ _N_ _N_} _N_ _N_,
- negate = _A_ 1 _U_ 1 _N_ _S_ "U(LL)" {_A_ 2 _U_ 11 _N_ _N_ _N_ _N_} _N_ _N_,
- abs = _A_ 1 _U_ 1 _N_ _N_ _N_ _N_,
- signum = _A_ 1 _U_ 1 _N_ _S_ "U(U(P)L)" {_A_ 2 _U_ 22 _N_ _N_ _N_ _N_} _N_ _N_,
- fromInteger = _A_ 1 _U_ 1 _N_ _N_ _N_ _N_,
- fromInt = _A_ 1 _U_ 1 _N_ _N_ _N_ _N_ #-}
+ {-# GHC_PRAGMA _M_ PreludeComplex {-dfun-} _A_ 0 _N_ _N_ _N_ _F_ _IF_ARGS_ 0 0 X 11 _!_ _TUP_10 [{{Eq (Complex Double)}}, {{Text (Complex Double)}}, (Complex Double -> Complex Double -> Complex Double), (Complex Double -> Complex Double -> Complex Double), (Complex Double -> Complex Double -> Complex Double), (Complex Double -> Complex Double), (Complex Double -> Complex Double), (Complex Double -> Complex Double), (Integer -> Complex Double), (Int -> Complex Double)] [_DFUN_ Eq (Complex Double), _DFUN_ Text (Complex Double), _CONSTM_ Num (+) (Complex Double), _CONSTM_ Num (-) (Complex Double), _CONSTM_ Num (*) (Complex Double), _CONSTM_ Num negate (Complex Double), _CONSTM_ Num abs (Complex Double), _CONSTM_ Num signum (Complex Double), _CONSTM_ Num fromInteger (Complex Double), _CONSTM_ Num fromInt (Complex Double)] _N_
+ (+) = { _A_ 2 _U_ 11 _N_ _S_ "U(LL)U(LL)" {_A_ 4 _U_ 1111 _N_ _N_ _N_ _N_} _N_ _N_ },
+ (-) = { _A_ 2 _U_ 11 _N_ _S_ "U(LL)U(LL)" {_A_ 4 _U_ 1111 _N_ _N_ _N_ _N_} _N_ _N_ },
+ (*) = { _A_ 2 _U_ 11 _N_ _S_ "U(LL)U(LL)" {_A_ 4 _U_ 2222 _N_ _N_ _N_ _N_} _N_ _N_ },
+ negate = { _A_ 1 _U_ 1 _N_ _S_ "U(LL)" {_A_ 2 _U_ 11 _N_ _N_ _N_ _N_} _N_ _N_ },
+ abs = { _A_ 1 _U_ 1 _N_ _N_ _N_ _N_ },
+ signum = { _A_ 1 _U_ 1 _N_ _S_ "U(U(P)L)" {_A_ 2 _U_ 22 _N_ _N_ _N_ _N_} _N_ _N_ },
+ fromInteger = { _A_ 1 _U_ 1 _N_ _N_ _N_ _N_ },
+ fromInt = { _A_ 1 _U_ 1 _N_ _N_ _N_ _N_ } #-}
instance Text a => Text (Complex a)
{-# GHC_PRAGMA _M_ PreludeComplex {-dfun-} _A_ 1 _U_ 2 _N_ _N_ _N_ _N_ #-}
+instance Text (Complex Double)
+ {-# GHC_PRAGMA _M_ PreludeComplex {-dfun-} _A_ 0 _N_ _N_ _N_ _F_ _IF_ARGS_ 0 0 X 5 _!_ _TUP_4 [(Int -> [Char] -> [(Complex Double, [Char])]), (Int -> Complex Double -> [Char] -> [Char]), ([Char] -> [([Complex Double], [Char])]), ([Complex Double] -> [Char] -> [Char])] [_CONSTM_ Text readsPrec (Complex Double), _CONSTM_ Text showsPrec (Complex Double), _CONSTM_ Text readList (Complex Double), _CONSTM_ Text showList (Complex Double)] _N_
+ readsPrec = { _A_ 1 _U_ 12 _N_ _S_ "U(P)" {_A_ 1 _U_ 22 _N_ _N_ _N_ _N_} _N_ _N_ },
+ showsPrec = { _A_ 2 _U_ 112 _N_ _S_ "LU(LL)" {_A_ 3 _U_ 1222 _N_ _N_ _N_ _N_} _N_ _N_ },
+ readList = { _A_ 0 _U_ 2 _N_ _N_ _N_ _N_ },
+ showList = { _A_ 1 _U_ 12 _N_ _N_ _N_ _N_ } #-}
-{-# GHC_PRAGMA INTERFACE VERSION 5 #-}
+{-# GHC_PRAGMA INTERFACE VERSION 6 #-}
interface PreludeComplex where
import PreludeBuiltin(Double(..), Tuple2)
import PreludeCore(Eq(..), Floating(..), Fractional(..), Num(..), RealFloat(..), Text(..))
imagPart :: Complex a -> a
{-# GHC_PRAGMA _A_ 1 _U_ 1 _N_ _S_ "U(AS)" {_A_ 1 _U_ 1 _N_ _N_ _F_ _IF_ARGS_ 1 1 X 1 _/\_ u0 -> \ (u1 :: u0) -> u1 _N_} _F_ _IF_ARGS_ 1 1 C 2 _/\_ u0 -> \ (u1 :: Complex u0) -> case u1 of { _ALG_ (:+) (u2 :: u0) (u3 :: u0) -> u3; _NO_DEFLT_ } _N_ #-}
magnitude :: RealFloat a => Complex a -> a
- {-# GHC_PRAGMA _A_ 1 _U_ 12 _N_ _S_ "U(ALAAAAALAS)" {_A_ 3 _U_ 2221 _N_ _N_ _N_ _N_} _N_ _SPECIALISE_ [ Double ] 1 { _A_ 1 _U_ 1 _N_ _S_ "U(LL)" {_A_ 2 _U_ 22 _N_ _N_ _N_ _N_} _N_ _N_ } #-}
+ {-# GHC_PRAGMA _A_ 1 _U_ 12 _N_ _S_ "U(ALAAAAALAS)" {_A_ 3 _U_ 2221 _N_ _N_ _N_ _N_} _N_ _SPECIALISE_ [ Double ] 1 { _A_ 1 _U_ 1 _N_ _S_ "U(U(P)U(P))" {_A_ 2 _U_ 22 _N_ _N_ _N_ _N_} _N_ _N_ } #-}
mkPolar :: RealFloat a => a -> a -> Complex a
{-# GHC_PRAGMA _A_ 3 _U_ 122 _N_ _N_ _N_ _SPECIALISE_ [ Double ] 1 { _A_ 2 _U_ 22 _N_ _N_ _N_ _N_ } #-}
phase :: RealFloat a => Complex a -> a
{-# GHC_PRAGMA _M_ PreludeComplex {-dfun-} _A_ 1 _U_ 2 _N_ _N_ _N_ _N_ #-}
instance Eq (Complex Double)
{-# GHC_PRAGMA _M_ PreludeComplex {-dfun-} _A_ 0 _N_ _N_ _N_ _F_ _IF_ARGS_ 0 0 X 3 _!_ _TUP_2 [(Complex Double -> Complex Double -> Bool), (Complex Double -> Complex Double -> Bool)] [_CONSTM_ Eq (==) (Complex Double), _CONSTM_ Eq (/=) (Complex Double)] _N_
- (==) = _A_ 2 _U_ 11 _N_ _S_ "U(U(P)L)U(U(P)L)" {_A_ 4 _U_ 2121 _N_ _N_ _F_ _IF_ARGS_ 0 4 XCXC 7 \ (u0 :: Double#) (u1 :: Double) (u2 :: Double#) (u3 :: Double) -> case _#_ eqDouble# [] [u0, u2] of { _ALG_ True -> case u1 of { _ALG_ D# (u4 :: Double#) -> case u3 of { _ALG_ D# (u5 :: Double#) -> _#_ eqDouble# [] [u4, u5]; _NO_DEFLT_ }; _NO_DEFLT_ }; False -> _!_ False [] []; _NO_DEFLT_ } _N_} _F_ _ALWAYS_ \ (u0 :: Complex Double) (u1 :: Complex Double) -> case u0 of { _ALG_ (:+) (u2 :: Double) (u3 :: Double) -> case u2 of { _ALG_ D# (u4 :: Double#) -> case u1 of { _ALG_ (:+) (u5 :: Double) (u6 :: Double) -> case u5 of { _ALG_ D# (u7 :: Double#) -> case _#_ eqDouble# [] [u4, u7] of { _ALG_ True -> case u3 of { _ALG_ D# (u8 :: Double#) -> case u6 of { _ALG_ D# (u9 :: Double#) -> _#_ eqDouble# [] [u8, u9]; _NO_DEFLT_ }; _NO_DEFLT_ }; False -> _!_ False [] []; _NO_DEFLT_ }; _NO_DEFLT_ }; _NO_DEFLT_ }; _NO_DEFLT_ }; _NO_DEFLT_ } _N_,
- (/=) = _A_ 2 _U_ 11 _N_ _S_ "U(U(P)L)U(U(P)L)" {_A_ 4 _U_ 2121 _N_ _N_ _F_ _IF_ARGS_ 0 4 XCXC 7 \ (u0 :: Double#) (u1 :: Double) (u2 :: Double#) (u3 :: Double) -> case _#_ neDouble# [] [u0, u2] of { _ALG_ True -> _!_ True [] []; False -> case u1 of { _ALG_ D# (u4 :: Double#) -> case u3 of { _ALG_ D# (u5 :: Double#) -> _#_ neDouble# [] [u4, u5]; _NO_DEFLT_ }; _NO_DEFLT_ }; _NO_DEFLT_ } _N_} _F_ _ALWAYS_ \ (u0 :: Complex Double) (u1 :: Complex Double) -> case u0 of { _ALG_ (:+) (u2 :: Double) (u3 :: Double) -> case u2 of { _ALG_ D# (u4 :: Double#) -> case u1 of { _ALG_ (:+) (u5 :: Double) (u6 :: Double) -> case u5 of { _ALG_ D# (u7 :: Double#) -> case _#_ neDouble# [] [u4, u7] of { _ALG_ True -> _!_ True [] []; False -> case u3 of { _ALG_ D# (u8 :: Double#) -> case u6 of { _ALG_ D# (u9 :: Double#) -> _#_ neDouble# [] [u8, u9]; _NO_DEFLT_ }; _NO_DEFLT_ }; _NO_DEFLT_ }; _NO_DEFLT_ }; _NO_DEFLT_ }; _NO_DEFLT_ }; _NO_DEFLT_ } _N_ #-}
+ (==) = { _A_ 2 _U_ 11 _N_ _S_ "U(U(P)L)U(U(P)L)" {_A_ 4 _U_ 2121 _N_ _N_ _F_ _IF_ARGS_ 0 4 XCXC 7 \ (u0 :: Double#) (u1 :: Double) (u2 :: Double#) (u3 :: Double) -> case _#_ eqDouble# [] [u0, u2] of { _ALG_ True -> case u1 of { _ALG_ D# (u4 :: Double#) -> case u3 of { _ALG_ D# (u5 :: Double#) -> _#_ eqDouble# [] [u4, u5]; _NO_DEFLT_ }; _NO_DEFLT_ }; False -> _!_ False [] []; _NO_DEFLT_ } _N_} _F_ _ALWAYS_ \ (u0 :: Complex Double) (u1 :: Complex Double) -> case u0 of { _ALG_ (:+) (u2 :: Double) (u3 :: Double) -> case u2 of { _ALG_ D# (u4 :: Double#) -> case u1 of { _ALG_ (:+) (u5 :: Double) (u6 :: Double) -> case u5 of { _ALG_ D# (u7 :: Double#) -> case _#_ eqDouble# [] [u4, u7] of { _ALG_ True -> case u3 of { _ALG_ D# (u8 :: Double#) -> case u6 of { _ALG_ D# (u9 :: Double#) -> _#_ eqDouble# [] [u8, u9]; _NO_DEFLT_ }; _NO_DEFLT_ }; False -> _!_ False [] []; _NO_DEFLT_ }; _NO_DEFLT_ }; _NO_DEFLT_ }; _NO_DEFLT_ }; _NO_DEFLT_ } _N_ },
+ (/=) = { _A_ 2 _U_ 11 _N_ _S_ "U(U(P)L)U(U(P)L)" {_A_ 4 _U_ 2121 _N_ _N_ _F_ _IF_ARGS_ 0 4 XCXC 7 \ (u0 :: Double#) (u1 :: Double) (u2 :: Double#) (u3 :: Double) -> case _#_ neDouble# [] [u0, u2] of { _ALG_ True -> _!_ True [] []; False -> case u1 of { _ALG_ D# (u4 :: Double#) -> case u3 of { _ALG_ D# (u5 :: Double#) -> _#_ neDouble# [] [u4, u5]; _NO_DEFLT_ }; _NO_DEFLT_ }; _NO_DEFLT_ } _N_} _F_ _ALWAYS_ \ (u0 :: Complex Double) (u1 :: Complex Double) -> case u0 of { _ALG_ (:+) (u2 :: Double) (u3 :: Double) -> case u2 of { _ALG_ D# (u4 :: Double#) -> case u1 of { _ALG_ (:+) (u5 :: Double) (u6 :: Double) -> case u5 of { _ALG_ D# (u7 :: Double#) -> case _#_ neDouble# [] [u4, u7] of { _ALG_ True -> _!_ True [] []; False -> case u3 of { _ALG_ D# (u8 :: Double#) -> case u6 of { _ALG_ D# (u9 :: Double#) -> _#_ neDouble# [] [u8, u9]; _NO_DEFLT_ }; _NO_DEFLT_ }; _NO_DEFLT_ }; _NO_DEFLT_ }; _NO_DEFLT_ }; _NO_DEFLT_ }; _NO_DEFLT_ } _N_ } #-}
instance RealFloat a => Floating (Complex a)
{-# GHC_PRAGMA _M_ PreludeComplex {-dfun-} _A_ 2 _U_ 22 _N_ _N_ _N_ _N_ #-}
instance Floating (Complex Double)
{-# GHC_PRAGMA _M_ PreludeComplex {-dfun-} _A_ 0 _N_ _N_ _N_ _F_ _IF_ARGS_ 0 0 X 20 _!_ _TUP_19 [{{Fractional (Complex Double)}}, (Complex Double), (Complex Double -> Complex Double), (Complex Double -> Complex Double), (Complex Double -> Complex Double), (Complex Double -> Complex Double -> Complex Double), (Complex Double -> Complex Double -> Complex Double), (Complex Double -> Complex Double), (Complex Double -> Complex Double), (Complex Double -> Complex Double), (Complex Double -> Complex Double), (Complex Double -> Complex Double), (Complex Double -> Complex Double), (Complex Double -> Complex Double), (Complex Double -> Complex Double), (Complex Double -> Complex Double), (Complex Double -> Complex Double), (Complex Double -> Complex Double), (Complex Double -> Complex Double)] [_DFUN_ Fractional (Complex Double), _CONSTM_ Floating pi (Complex Double), _CONSTM_ Floating exp (Complex Double), _CONSTM_ Floating log (Complex Double), _CONSTM_ Floating sqrt (Complex Double), _CONSTM_ Floating (**) (Complex Double), _CONSTM_ Floating logBase (Complex Double), _CONSTM_ Floating sin (Complex Double), _CONSTM_ Floating cos (Complex Double), _CONSTM_ Floating tan (Complex Double), _CONSTM_ Floating asin (Complex Double), _CONSTM_ Floating acos (Complex Double), _CONSTM_ Floating atan (Complex Double), _CONSTM_ Floating sinh (Complex Double), _CONSTM_ Floating cosh (Complex Double), _CONSTM_ Floating tanh (Complex Double), _CONSTM_ Floating asinh (Complex Double), _CONSTM_ Floating acosh (Complex Double), _CONSTM_ Floating atanh (Complex Double)] _N_
- pi = _A_ 0 _N_ _N_ _N_ _N_ _N_,
- exp = _A_ 1 _U_ 1 _N_ _S_ "U(LL)" {_A_ 2 _U_ 12 _N_ _N_ _N_ _N_} _N_ _N_,
- log = _A_ 1 _U_ 2 _N_ _N_ _N_ _N_,
- sqrt = _A_ 1 _U_ 1 _N_ _S_ "U(U(P)L)" {_A_ 2 _U_ 22 _N_ _N_ _N_ _N_} _N_ _N_,
- (**) = _A_ 2 _U_ 21 _N_ _S_ "LU(LL)" {_A_ 3 _U_ 222 _N_ _N_ _N_ _N_} _N_ _N_,
- logBase = _A_ 2 _U_ 22 _N_ _N_ _N_ _N_,
- sin = _A_ 1 _U_ 1 _N_ _S_ "U(LL)" {_A_ 2 _U_ 22 _N_ _N_ _N_ _N_} _N_ _N_,
- cos = _A_ 1 _U_ 1 _N_ _S_ "U(LL)" {_A_ 2 _U_ 22 _N_ _N_ _N_ _N_} _N_ _N_,
- tan = _A_ 1 _U_ 1 _N_ _S_ "U(LL)" {_A_ 2 _U_ 22 _N_ _N_ _N_ _N_} _N_ _N_,
- asin = _A_ 1 _U_ 1 _N_ _S_ "U(LL)" {_A_ 2 _U_ 22 _N_ _N_ _N_ _N_} _N_ _N_,
- acos = _A_ 1 _U_ 1 _N_ _S_ "U(LL)" {_A_ 2 _U_ 22 _N_ _N_ _N_ _N_} _N_ _N_,
- atan = _A_ 1 _U_ 1 _N_ _S_ "U(LL)" {_A_ 2 _U_ 22 _N_ _N_ _N_ _N_} _N_ _N_,
- sinh = _A_ 1 _U_ 1 _N_ _S_ "U(LL)" {_A_ 2 _U_ 22 _N_ _N_ _N_ _N_} _N_ _N_,
- cosh = _A_ 1 _U_ 1 _N_ _S_ "U(LL)" {_A_ 2 _U_ 22 _N_ _N_ _N_ _N_} _N_ _N_,
- tanh = _A_ 1 _U_ 1 _N_ _S_ "U(LL)" {_A_ 2 _U_ 22 _N_ _N_ _N_ _N_} _N_ _N_,
- asinh = _A_ 1 _U_ 1 _N_ _N_ _N_ _N_,
- acosh = _A_ 1 _U_ 1 _N_ _N_ _N_ _N_,
- atanh = _A_ 1 _U_ 1 _N_ _N_ _N_ _N_ #-}
+ pi = { _A_ 0 _N_ _N_ _N_ _F_ _IF_ARGS_ 0 0 X 3 _!_ (:+) [Double] [_CONSTM_ Floating pi (Double), _SPEC_ _ORIG_ PreludeCore __i0 [ (Double) ]] _N_ },
+ exp = { _A_ 1 _U_ 1 _N_ _S_ "U(LL)" {_A_ 2 _U_ 12 _N_ _N_ _N_ _N_} _N_ _N_ },
+ log = { _A_ 1 _U_ 2 _N_ _N_ _N_ _N_ },
+ sqrt = { _A_ 1 _U_ 1 _N_ _S_ "U(U(P)L)" {_A_ 2 _U_ 22 _N_ _N_ _N_ _N_} _N_ _N_ },
+ (**) = { _A_ 2 _U_ 21 _N_ _S_ "LU(LL)" {_A_ 3 _U_ 222 _N_ _N_ _N_ _N_} _N_ _N_ },
+ logBase = { _A_ 2 _U_ 22 _N_ _N_ _N_ _N_ },
+ sin = { _A_ 1 _U_ 1 _N_ _S_ "U(LL)" {_A_ 2 _U_ 22 _N_ _N_ _N_ _N_} _N_ _N_ },
+ cos = { _A_ 1 _U_ 1 _N_ _S_ "U(LL)" {_A_ 2 _U_ 22 _N_ _N_ _N_ _N_} _N_ _N_ },
+ tan = { _A_ 1 _U_ 1 _N_ _S_ "U(LL)" {_A_ 2 _U_ 22 _N_ _N_ _N_ _N_} _N_ _N_ },
+ asin = { _A_ 1 _U_ 1 _N_ _S_ "U(LL)" {_A_ 2 _U_ 22 _N_ _N_ _N_ _N_} _N_ _N_ },
+ acos = { _A_ 1 _U_ 1 _N_ _S_ "U(LL)" {_A_ 2 _U_ 22 _N_ _N_ _N_ _N_} _N_ _N_ },
+ atan = { _A_ 1 _U_ 1 _N_ _S_ "U(LL)" {_A_ 2 _U_ 22 _N_ _N_ _N_ _N_} _N_ _N_ },
+ sinh = { _A_ 1 _U_ 1 _N_ _S_ "U(LL)" {_A_ 2 _U_ 22 _N_ _N_ _N_ _N_} _N_ _N_ },
+ cosh = { _A_ 1 _U_ 1 _N_ _S_ "U(LL)" {_A_ 2 _U_ 22 _N_ _N_ _N_ _N_} _N_ _N_ },
+ tanh = { _A_ 1 _U_ 1 _N_ _S_ "U(LL)" {_A_ 2 _U_ 22 _N_ _N_ _N_ _N_} _N_ _N_ },
+ asinh = { _A_ 1 _U_ 1 _N_ _N_ _N_ _N_ },
+ acosh = { _A_ 1 _U_ 1 _N_ _N_ _N_ _N_ },
+ atanh = { _A_ 1 _U_ 1 _N_ _N_ _N_ _N_ } #-}
instance RealFloat a => Fractional (Complex a)
{-# GHC_PRAGMA _M_ PreludeComplex {-dfun-} _A_ 2 _U_ 22 _N_ _N_ _N_ _N_ #-}
instance Fractional (Complex Double)
{-# GHC_PRAGMA _M_ PreludeComplex {-dfun-} _A_ 0 _N_ _N_ _N_ _F_ _IF_ARGS_ 0 0 X 5 _!_ _TUP_4 [{{Num (Complex Double)}}, (Complex Double -> Complex Double -> Complex Double), (Complex Double -> Complex Double), (Ratio Integer -> Complex Double)] [_DFUN_ Num (Complex Double), _CONSTM_ Fractional (/) (Complex Double), _CONSTM_ Fractional recip (Complex Double), _CONSTM_ Fractional fromRational (Complex Double)] _N_
- (/) = _A_ 2 _U_ 11 _N_ _S_ "U(LL)U(LL)" {_A_ 4 _U_ 2222 _N_ _N_ _N_ _N_} _N_ _N_,
- recip = _A_ 1 _U_ 1 _N_ _S_ "U(LL)" {_A_ 2 _U_ 22 _N_ _N_ _N_ _N_} _N_ _N_,
- fromRational = _A_ 1 _U_ 2 _N_ _N_ _N_ _N_ #-}
+ (/) = { _A_ 2 _U_ 11 _N_ _S_ "U(LL)U(LL)" {_A_ 4 _U_ 2222 _N_ _N_ _N_ _N_} _N_ _N_ },
+ recip = { _A_ 1 _U_ 1 _N_ _S_ "U(LL)" {_A_ 2 _U_ 22 _N_ _N_ _N_ _N_} _F_ _IF_ARGS_ 0 1 X 3 \ (u0 :: Complex Double) -> _APP_ _CONSTM_ Fractional (/) (Complex Double) [ _SPEC_ _ORIG_ PreludeCore __i1 [ (Complex Double) ], u0 ] _N_ },
+ fromRational = { _A_ 1 _U_ 1 _N_ _N_ _N_ _N_ } #-}
instance RealFloat a => Num (Complex a)
{-# GHC_PRAGMA _M_ PreludeComplex {-dfun-} _A_ 3 _U_ 222 _N_ _N_ _N_ _N_ #-}
instance Num (Complex Double)
- {-# GHC_PRAGMA _M_ PreludeComplex {-dfun-} _A_ 0 _N_ _N_ _N_ _N_ _N_
- (+) = _A_ 2 _U_ 11 _N_ _S_ "U(LL)U(LL)" {_A_ 4 _U_ 1111 _N_ _N_ _N_ _N_} _N_ _N_,
- (-) = _A_ 2 _U_ 11 _N_ _S_ "U(LL)U(LL)" {_A_ 4 _U_ 1111 _N_ _N_ _N_ _N_} _N_ _N_,
- (*) = _A_ 2 _U_ 11 _N_ _S_ "U(LL)U(LL)" {_A_ 4 _U_ 2222 _N_ _N_ _N_ _N_} _N_ _N_,
- negate = _A_ 1 _U_ 1 _N_ _S_ "U(LL)" {_A_ 2 _U_ 11 _N_ _N_ _N_ _N_} _N_ _N_,
- abs = _A_ 1 _U_ 1 _N_ _N_ _N_ _N_,
- signum = _A_ 1 _U_ 1 _N_ _S_ "U(U(P)L)" {_A_ 2 _U_ 22 _N_ _N_ _N_ _N_} _N_ _N_,
- fromInteger = _A_ 1 _U_ 1 _N_ _N_ _N_ _N_,
- fromInt = _A_ 1 _U_ 1 _N_ _N_ _N_ _N_ #-}
+ {-# GHC_PRAGMA _M_ PreludeComplex {-dfun-} _A_ 0 _N_ _N_ _N_ _F_ _IF_ARGS_ 0 0 X 11 _!_ _TUP_10 [{{Eq (Complex Double)}}, {{Text (Complex Double)}}, (Complex Double -> Complex Double -> Complex Double), (Complex Double -> Complex Double -> Complex Double), (Complex Double -> Complex Double -> Complex Double), (Complex Double -> Complex Double), (Complex Double -> Complex Double), (Complex Double -> Complex Double), (Integer -> Complex Double), (Int -> Complex Double)] [_DFUN_ Eq (Complex Double), _DFUN_ Text (Complex Double), _CONSTM_ Num (+) (Complex Double), _CONSTM_ Num (-) (Complex Double), _CONSTM_ Num (*) (Complex Double), _CONSTM_ Num negate (Complex Double), _CONSTM_ Num abs (Complex Double), _CONSTM_ Num signum (Complex Double), _CONSTM_ Num fromInteger (Complex Double), _CONSTM_ Num fromInt (Complex Double)] _N_
+ (+) = { _A_ 2 _U_ 11 _N_ _S_ "U(LL)U(LL)" {_A_ 4 _U_ 1111 _N_ _N_ _N_ _N_} _N_ _N_ },
+ (-) = { _A_ 2 _U_ 11 _N_ _S_ "U(LL)U(LL)" {_A_ 4 _U_ 1111 _N_ _N_ _N_ _N_} _N_ _N_ },
+ (*) = { _A_ 2 _U_ 11 _N_ _S_ "U(LL)U(LL)" {_A_ 4 _U_ 2222 _N_ _N_ _N_ _N_} _N_ _N_ },
+ negate = { _A_ 1 _U_ 1 _N_ _S_ "U(LL)" {_A_ 2 _U_ 11 _N_ _N_ _N_ _N_} _N_ _N_ },
+ abs = { _A_ 1 _U_ 1 _N_ _N_ _N_ _N_ },
+ signum = { _A_ 1 _U_ 1 _N_ _S_ "U(U(P)L)" {_A_ 2 _U_ 22 _N_ _N_ _N_ _N_} _N_ _N_ },
+ fromInteger = { _A_ 1 _U_ 1 _N_ _N_ _N_ _N_ },
+ fromInt = { _A_ 1 _U_ 1 _N_ _N_ _N_ _N_ } #-}
instance Text a => Text (Complex a)
{-# GHC_PRAGMA _M_ PreludeComplex {-dfun-} _A_ 1 _U_ 2 _N_ _N_ _N_ _N_ #-}
+instance Text (Complex Double)
+ {-# GHC_PRAGMA _M_ PreludeComplex {-dfun-} _A_ 0 _N_ _N_ _N_ _F_ _IF_ARGS_ 0 0 X 5 _!_ _TUP_4 [(Int -> [Char] -> [(Complex Double, [Char])]), (Int -> Complex Double -> [Char] -> [Char]), ([Char] -> [([Complex Double], [Char])]), ([Complex Double] -> [Char] -> [Char])] [_CONSTM_ Text readsPrec (Complex Double), _CONSTM_ Text showsPrec (Complex Double), _CONSTM_ Text readList (Complex Double), _CONSTM_ Text showList (Complex Double)] _N_
+ readsPrec = { _A_ 1 _U_ 12 _N_ _S_ "U(P)" {_A_ 1 _U_ 22 _N_ _N_ _N_ _N_} _N_ _N_ },
+ showsPrec = { _A_ 2 _U_ 112 _N_ _S_ "LU(LL)" {_A_ 3 _U_ 1222 _N_ _N_ _N_ _N_} _N_ _N_ },
+ readList = { _A_ 0 _U_ 2 _N_ _N_ _N_ _N_ },
+ showList = { _A_ 1 _U_ 12 _N_ _N_ _N_ _N_ } #-}
-{-# GHC_PRAGMA INTERFACE VERSION 5 #-}
+{-# GHC_PRAGMA INTERFACE VERSION 6 #-}
interface PreludeComplex where
import PreludeBuiltin(Double(..), Tuple2)
import PreludeCore(Eq(..), Floating(..), Fractional(..), Num(..), RealFloat(..), Text(..))
imagPart :: Complex a -> a
{-# GHC_PRAGMA _A_ 1 _U_ 1 _N_ _S_ "U(AS)" {_A_ 1 _U_ 1 _N_ _N_ _F_ _IF_ARGS_ 1 1 X 1 _/\_ u0 -> \ (u1 :: u0) -> u1 _N_} _F_ _IF_ARGS_ 1 1 C 2 _/\_ u0 -> \ (u1 :: Complex u0) -> case u1 of { _ALG_ (:+) (u2 :: u0) (u3 :: u0) -> u3; _NO_DEFLT_ } _N_ #-}
magnitude :: RealFloat a => Complex a -> a
- {-# GHC_PRAGMA _A_ 1 _U_ 12 _N_ _S_ "U(ALAAAAALAS)" {_A_ 3 _U_ 2221 _N_ _N_ _N_ _N_} _N_ _SPECIALISE_ [ Double ] 1 { _A_ 1 _U_ 1 _N_ _S_ "U(LL)" {_A_ 2 _U_ 22 _N_ _N_ _N_ _N_} _N_ _N_ } #-}
+ {-# GHC_PRAGMA _A_ 1 _U_ 12 _N_ _S_ "U(ALAAAAALAS)" {_A_ 3 _U_ 2221 _N_ _N_ _N_ _N_} _N_ _SPECIALISE_ [ Double ] 1 { _A_ 1 _U_ 1 _N_ _S_ "U(U(P)U(P))" {_A_ 2 _U_ 22 _N_ _N_ _N_ _N_} _N_ _N_ } #-}
mkPolar :: RealFloat a => a -> a -> Complex a
{-# GHC_PRAGMA _A_ 3 _U_ 122 _N_ _N_ _N_ _SPECIALISE_ [ Double ] 1 { _A_ 2 _U_ 22 _N_ _N_ _N_ _N_ } #-}
phase :: RealFloat a => Complex a -> a
{-# GHC_PRAGMA _M_ PreludeComplex {-dfun-} _A_ 1 _U_ 2 _N_ _N_ _N_ _N_ #-}
instance Eq (Complex Double)
{-# GHC_PRAGMA _M_ PreludeComplex {-dfun-} _A_ 0 _N_ _N_ _N_ _F_ _IF_ARGS_ 0 0 X 3 _!_ _TUP_2 [(Complex Double -> Complex Double -> Bool), (Complex Double -> Complex Double -> Bool)] [_CONSTM_ Eq (==) (Complex Double), _CONSTM_ Eq (/=) (Complex Double)] _N_
- (==) = _A_ 2 _U_ 11 _N_ _S_ "U(U(P)L)U(U(P)L)" {_A_ 4 _U_ 2121 _N_ _N_ _F_ _IF_ARGS_ 0 4 XCXC 7 \ (u0 :: Double#) (u1 :: Double) (u2 :: Double#) (u3 :: Double) -> case _#_ eqDouble# [] [u0, u2] of { _ALG_ True -> case u1 of { _ALG_ D# (u4 :: Double#) -> case u3 of { _ALG_ D# (u5 :: Double#) -> _#_ eqDouble# [] [u4, u5]; _NO_DEFLT_ }; _NO_DEFLT_ }; False -> _!_ False [] []; _NO_DEFLT_ } _N_} _F_ _ALWAYS_ \ (u0 :: Complex Double) (u1 :: Complex Double) -> case u0 of { _ALG_ (:+) (u2 :: Double) (u3 :: Double) -> case u2 of { _ALG_ D# (u4 :: Double#) -> case u1 of { _ALG_ (:+) (u5 :: Double) (u6 :: Double) -> case u5 of { _ALG_ D# (u7 :: Double#) -> case _#_ eqDouble# [] [u4, u7] of { _ALG_ True -> case u3 of { _ALG_ D# (u8 :: Double#) -> case u6 of { _ALG_ D# (u9 :: Double#) -> _#_ eqDouble# [] [u8, u9]; _NO_DEFLT_ }; _NO_DEFLT_ }; False -> _!_ False [] []; _NO_DEFLT_ }; _NO_DEFLT_ }; _NO_DEFLT_ }; _NO_DEFLT_ }; _NO_DEFLT_ } _N_,
- (/=) = _A_ 2 _U_ 11 _N_ _S_ "U(U(P)L)U(U(P)L)" {_A_ 4 _U_ 2121 _N_ _N_ _F_ _IF_ARGS_ 0 4 XCXC 7 \ (u0 :: Double#) (u1 :: Double) (u2 :: Double#) (u3 :: Double) -> case _#_ neDouble# [] [u0, u2] of { _ALG_ True -> _!_ True [] []; False -> case u1 of { _ALG_ D# (u4 :: Double#) -> case u3 of { _ALG_ D# (u5 :: Double#) -> _#_ neDouble# [] [u4, u5]; _NO_DEFLT_ }; _NO_DEFLT_ }; _NO_DEFLT_ } _N_} _F_ _ALWAYS_ \ (u0 :: Complex Double) (u1 :: Complex Double) -> case u0 of { _ALG_ (:+) (u2 :: Double) (u3 :: Double) -> case u2 of { _ALG_ D# (u4 :: Double#) -> case u1 of { _ALG_ (:+) (u5 :: Double) (u6 :: Double) -> case u5 of { _ALG_ D# (u7 :: Double#) -> case _#_ neDouble# [] [u4, u7] of { _ALG_ True -> _!_ True [] []; False -> case u3 of { _ALG_ D# (u8 :: Double#) -> case u6 of { _ALG_ D# (u9 :: Double#) -> _#_ neDouble# [] [u8, u9]; _NO_DEFLT_ }; _NO_DEFLT_ }; _NO_DEFLT_ }; _NO_DEFLT_ }; _NO_DEFLT_ }; _NO_DEFLT_ }; _NO_DEFLT_ } _N_ #-}
+ (==) = { _A_ 2 _U_ 11 _N_ _S_ "U(U(P)L)U(U(P)L)" {_A_ 4 _U_ 2121 _N_ _N_ _F_ _IF_ARGS_ 0 4 XCXC 7 \ (u0 :: Double#) (u1 :: Double) (u2 :: Double#) (u3 :: Double) -> case _#_ eqDouble# [] [u0, u2] of { _ALG_ True -> case u1 of { _ALG_ D# (u4 :: Double#) -> case u3 of { _ALG_ D# (u5 :: Double#) -> _#_ eqDouble# [] [u4, u5]; _NO_DEFLT_ }; _NO_DEFLT_ }; False -> _!_ False [] []; _NO_DEFLT_ } _N_} _F_ _ALWAYS_ \ (u0 :: Complex Double) (u1 :: Complex Double) -> case u0 of { _ALG_ (:+) (u2 :: Double) (u3 :: Double) -> case u2 of { _ALG_ D# (u4 :: Double#) -> case u1 of { _ALG_ (:+) (u5 :: Double) (u6 :: Double) -> case u5 of { _ALG_ D# (u7 :: Double#) -> case _#_ eqDouble# [] [u4, u7] of { _ALG_ True -> case u3 of { _ALG_ D# (u8 :: Double#) -> case u6 of { _ALG_ D# (u9 :: Double#) -> _#_ eqDouble# [] [u8, u9]; _NO_DEFLT_ }; _NO_DEFLT_ }; False -> _!_ False [] []; _NO_DEFLT_ }; _NO_DEFLT_ }; _NO_DEFLT_ }; _NO_DEFLT_ }; _NO_DEFLT_ } _N_ },
+ (/=) = { _A_ 2 _U_ 11 _N_ _S_ "U(U(P)L)U(U(P)L)" {_A_ 4 _U_ 2121 _N_ _N_ _F_ _IF_ARGS_ 0 4 XCXC 7 \ (u0 :: Double#) (u1 :: Double) (u2 :: Double#) (u3 :: Double) -> case _#_ neDouble# [] [u0, u2] of { _ALG_ True -> _!_ True [] []; False -> case u1 of { _ALG_ D# (u4 :: Double#) -> case u3 of { _ALG_ D# (u5 :: Double#) -> _#_ neDouble# [] [u4, u5]; _NO_DEFLT_ }; _NO_DEFLT_ }; _NO_DEFLT_ } _N_} _F_ _ALWAYS_ \ (u0 :: Complex Double) (u1 :: Complex Double) -> case u0 of { _ALG_ (:+) (u2 :: Double) (u3 :: Double) -> case u2 of { _ALG_ D# (u4 :: Double#) -> case u1 of { _ALG_ (:+) (u5 :: Double) (u6 :: Double) -> case u5 of { _ALG_ D# (u7 :: Double#) -> case _#_ neDouble# [] [u4, u7] of { _ALG_ True -> _!_ True [] []; False -> case u3 of { _ALG_ D# (u8 :: Double#) -> case u6 of { _ALG_ D# (u9 :: Double#) -> _#_ neDouble# [] [u8, u9]; _NO_DEFLT_ }; _NO_DEFLT_ }; _NO_DEFLT_ }; _NO_DEFLT_ }; _NO_DEFLT_ }; _NO_DEFLT_ }; _NO_DEFLT_ } _N_ } #-}
instance RealFloat a => Floating (Complex a)
{-# GHC_PRAGMA _M_ PreludeComplex {-dfun-} _A_ 2 _U_ 22 _N_ _N_ _N_ _N_ #-}
instance Floating (Complex Double)
{-# GHC_PRAGMA _M_ PreludeComplex {-dfun-} _A_ 0 _N_ _N_ _N_ _F_ _IF_ARGS_ 0 0 X 20 _!_ _TUP_19 [{{Fractional (Complex Double)}}, (Complex Double), (Complex Double -> Complex Double), (Complex Double -> Complex Double), (Complex Double -> Complex Double), (Complex Double -> Complex Double -> Complex Double), (Complex Double -> Complex Double -> Complex Double), (Complex Double -> Complex Double), (Complex Double -> Complex Double), (Complex Double -> Complex Double), (Complex Double -> Complex Double), (Complex Double -> Complex Double), (Complex Double -> Complex Double), (Complex Double -> Complex Double), (Complex Double -> Complex Double), (Complex Double -> Complex Double), (Complex Double -> Complex Double), (Complex Double -> Complex Double), (Complex Double -> Complex Double)] [_DFUN_ Fractional (Complex Double), _CONSTM_ Floating pi (Complex Double), _CONSTM_ Floating exp (Complex Double), _CONSTM_ Floating log (Complex Double), _CONSTM_ Floating sqrt (Complex Double), _CONSTM_ Floating (**) (Complex Double), _CONSTM_ Floating logBase (Complex Double), _CONSTM_ Floating sin (Complex Double), _CONSTM_ Floating cos (Complex Double), _CONSTM_ Floating tan (Complex Double), _CONSTM_ Floating asin (Complex Double), _CONSTM_ Floating acos (Complex Double), _CONSTM_ Floating atan (Complex Double), _CONSTM_ Floating sinh (Complex Double), _CONSTM_ Floating cosh (Complex Double), _CONSTM_ Floating tanh (Complex Double), _CONSTM_ Floating asinh (Complex Double), _CONSTM_ Floating acosh (Complex Double), _CONSTM_ Floating atanh (Complex Double)] _N_
- pi = _A_ 0 _N_ _N_ _N_ _N_ _N_,
- exp = _A_ 1 _U_ 1 _N_ _S_ "U(LL)" {_A_ 2 _U_ 12 _N_ _N_ _N_ _N_} _N_ _N_,
- log = _A_ 1 _U_ 2 _N_ _N_ _N_ _N_,
- sqrt = _A_ 1 _U_ 1 _N_ _S_ "U(U(P)L)" {_A_ 2 _U_ 22 _N_ _N_ _N_ _N_} _N_ _N_,
- (**) = _A_ 2 _U_ 21 _N_ _S_ "LU(LL)" {_A_ 3 _U_ 222 _N_ _N_ _N_ _N_} _N_ _N_,
- logBase = _A_ 2 _U_ 22 _N_ _N_ _N_ _N_,
- sin = _A_ 1 _U_ 1 _N_ _S_ "U(LL)" {_A_ 2 _U_ 22 _N_ _N_ _N_ _N_} _N_ _N_,
- cos = _A_ 1 _U_ 1 _N_ _S_ "U(LL)" {_A_ 2 _U_ 22 _N_ _N_ _N_ _N_} _N_ _N_,
- tan = _A_ 1 _U_ 1 _N_ _S_ "U(LL)" {_A_ 2 _U_ 22 _N_ _N_ _N_ _N_} _N_ _N_,
- asin = _A_ 1 _U_ 1 _N_ _S_ "U(LL)" {_A_ 2 _U_ 22 _N_ _N_ _N_ _N_} _N_ _N_,
- acos = _A_ 1 _U_ 1 _N_ _S_ "U(LL)" {_A_ 2 _U_ 22 _N_ _N_ _N_ _N_} _N_ _N_,
- atan = _A_ 1 _U_ 1 _N_ _S_ "U(LL)" {_A_ 2 _U_ 22 _N_ _N_ _N_ _N_} _N_ _N_,
- sinh = _A_ 1 _U_ 1 _N_ _S_ "U(LL)" {_A_ 2 _U_ 22 _N_ _N_ _N_ _N_} _N_ _N_,
- cosh = _A_ 1 _U_ 1 _N_ _S_ "U(LL)" {_A_ 2 _U_ 22 _N_ _N_ _N_ _N_} _N_ _N_,
- tanh = _A_ 1 _U_ 1 _N_ _S_ "U(LL)" {_A_ 2 _U_ 22 _N_ _N_ _N_ _N_} _N_ _N_,
- asinh = _A_ 1 _U_ 1 _N_ _N_ _N_ _N_,
- acosh = _A_ 1 _U_ 1 _N_ _N_ _N_ _N_,
- atanh = _A_ 1 _U_ 1 _N_ _N_ _N_ _N_ #-}
+ pi = { _A_ 0 _N_ _N_ _N_ _F_ _IF_ARGS_ 0 0 X 3 _!_ (:+) [Double] [_CONSTM_ Floating pi (Double), _SPEC_ _ORIG_ PreludeCore __i0 [ (Double) ]] _N_ },
+ exp = { _A_ 1 _U_ 1 _N_ _S_ "U(LL)" {_A_ 2 _U_ 12 _N_ _N_ _N_ _N_} _N_ _N_ },
+ log = { _A_ 1 _U_ 2 _N_ _N_ _N_ _N_ },
+ sqrt = { _A_ 1 _U_ 1 _N_ _S_ "U(U(P)L)" {_A_ 2 _U_ 22 _N_ _N_ _N_ _N_} _N_ _N_ },
+ (**) = { _A_ 2 _U_ 21 _N_ _S_ "LU(LL)" {_A_ 3 _U_ 222 _N_ _N_ _N_ _N_} _N_ _N_ },
+ logBase = { _A_ 2 _U_ 22 _N_ _N_ _N_ _N_ },
+ sin = { _A_ 1 _U_ 1 _N_ _S_ "U(LL)" {_A_ 2 _U_ 22 _N_ _N_ _N_ _N_} _N_ _N_ },
+ cos = { _A_ 1 _U_ 1 _N_ _S_ "U(LL)" {_A_ 2 _U_ 22 _N_ _N_ _N_ _N_} _N_ _N_ },
+ tan = { _A_ 1 _U_ 1 _N_ _S_ "U(LL)" {_A_ 2 _U_ 22 _N_ _N_ _N_ _N_} _N_ _N_ },
+ asin = { _A_ 1 _U_ 1 _N_ _S_ "U(LL)" {_A_ 2 _U_ 22 _N_ _N_ _N_ _N_} _N_ _N_ },
+ acos = { _A_ 1 _U_ 1 _N_ _S_ "U(LL)" {_A_ 2 _U_ 22 _N_ _N_ _N_ _N_} _N_ _N_ },
+ atan = { _A_ 1 _U_ 1 _N_ _S_ "U(LL)" {_A_ 2 _U_ 22 _N_ _N_ _N_ _N_} _N_ _N_ },
+ sinh = { _A_ 1 _U_ 1 _N_ _S_ "U(LL)" {_A_ 2 _U_ 22 _N_ _N_ _N_ _N_} _N_ _N_ },
+ cosh = { _A_ 1 _U_ 1 _N_ _S_ "U(LL)" {_A_ 2 _U_ 22 _N_ _N_ _N_ _N_} _N_ _N_ },
+ tanh = { _A_ 1 _U_ 1 _N_ _S_ "U(LL)" {_A_ 2 _U_ 22 _N_ _N_ _N_ _N_} _N_ _N_ },
+ asinh = { _A_ 1 _U_ 1 _N_ _N_ _N_ _N_ },
+ acosh = { _A_ 1 _U_ 1 _N_ _N_ _N_ _N_ },
+ atanh = { _A_ 1 _U_ 1 _N_ _N_ _N_ _N_ } #-}
instance RealFloat a => Fractional (Complex a)
{-# GHC_PRAGMA _M_ PreludeComplex {-dfun-} _A_ 2 _U_ 22 _N_ _N_ _N_ _N_ #-}
instance Fractional (Complex Double)
{-# GHC_PRAGMA _M_ PreludeComplex {-dfun-} _A_ 0 _N_ _N_ _N_ _F_ _IF_ARGS_ 0 0 X 5 _!_ _TUP_4 [{{Num (Complex Double)}}, (Complex Double -> Complex Double -> Complex Double), (Complex Double -> Complex Double), (Ratio Integer -> Complex Double)] [_DFUN_ Num (Complex Double), _CONSTM_ Fractional (/) (Complex Double), _CONSTM_ Fractional recip (Complex Double), _CONSTM_ Fractional fromRational (Complex Double)] _N_
- (/) = _A_ 2 _U_ 11 _N_ _S_ "U(LL)U(LL)" {_A_ 4 _U_ 2222 _N_ _N_ _N_ _N_} _N_ _N_,
- recip = _A_ 1 _U_ 1 _N_ _S_ "U(LL)" {_A_ 2 _U_ 22 _N_ _N_ _N_ _N_} _N_ _N_,
- fromRational = _A_ 1 _U_ 2 _N_ _N_ _N_ _N_ #-}
+ (/) = { _A_ 2 _U_ 11 _N_ _S_ "U(LL)U(LL)" {_A_ 4 _U_ 2222 _N_ _N_ _N_ _N_} _N_ _N_ },
+ recip = { _A_ 1 _U_ 1 _N_ _S_ "U(LL)" {_A_ 2 _U_ 22 _N_ _N_ _N_ _N_} _F_ _IF_ARGS_ 0 1 X 3 \ (u0 :: Complex Double) -> _APP_ _CONSTM_ Fractional (/) (Complex Double) [ _SPEC_ _ORIG_ PreludeCore __i1 [ (Complex Double) ], u0 ] _N_ },
+ fromRational = { _A_ 1 _U_ 1 _N_ _N_ _N_ _N_ } #-}
instance RealFloat a => Num (Complex a)
{-# GHC_PRAGMA _M_ PreludeComplex {-dfun-} _A_ 3 _U_ 222 _N_ _N_ _N_ _N_ #-}
instance Num (Complex Double)
- {-# GHC_PRAGMA _M_ PreludeComplex {-dfun-} _A_ 0 _N_ _N_ _N_ _N_ _N_
- (+) = _A_ 2 _U_ 11 _N_ _S_ "U(LL)U(LL)" {_A_ 4 _U_ 1111 _N_ _N_ _N_ _N_} _N_ _N_,
- (-) = _A_ 2 _U_ 11 _N_ _S_ "U(LL)U(LL)" {_A_ 4 _U_ 1111 _N_ _N_ _N_ _N_} _N_ _N_,
- (*) = _A_ 2 _U_ 11 _N_ _S_ "U(LL)U(LL)" {_A_ 4 _U_ 2222 _N_ _N_ _N_ _N_} _N_ _N_,
- negate = _A_ 1 _U_ 1 _N_ _S_ "U(LL)" {_A_ 2 _U_ 11 _N_ _N_ _N_ _N_} _N_ _N_,
- abs = _A_ 1 _U_ 1 _N_ _N_ _N_ _N_,
- signum = _A_ 1 _U_ 1 _N_ _S_ "U(U(P)L)" {_A_ 2 _U_ 22 _N_ _N_ _N_ _N_} _N_ _N_,
- fromInteger = _A_ 1 _U_ 1 _N_ _N_ _N_ _N_,
- fromInt = _A_ 1 _U_ 1 _N_ _N_ _N_ _N_ #-}
+ {-# GHC_PRAGMA _M_ PreludeComplex {-dfun-} _A_ 0 _N_ _N_ _N_ _F_ _IF_ARGS_ 0 0 X 11 _!_ _TUP_10 [{{Eq (Complex Double)}}, {{Text (Complex Double)}}, (Complex Double -> Complex Double -> Complex Double), (Complex Double -> Complex Double -> Complex Double), (Complex Double -> Complex Double -> Complex Double), (Complex Double -> Complex Double), (Complex Double -> Complex Double), (Complex Double -> Complex Double), (Integer -> Complex Double), (Int -> Complex Double)] [_DFUN_ Eq (Complex Double), _DFUN_ Text (Complex Double), _CONSTM_ Num (+) (Complex Double), _CONSTM_ Num (-) (Complex Double), _CONSTM_ Num (*) (Complex Double), _CONSTM_ Num negate (Complex Double), _CONSTM_ Num abs (Complex Double), _CONSTM_ Num signum (Complex Double), _CONSTM_ Num fromInteger (Complex Double), _CONSTM_ Num fromInt (Complex Double)] _N_
+ (+) = { _A_ 2 _U_ 11 _N_ _S_ "U(LL)U(LL)" {_A_ 4 _U_ 1111 _N_ _N_ _N_ _N_} _N_ _N_ },
+ (-) = { _A_ 2 _U_ 11 _N_ _S_ "U(LL)U(LL)" {_A_ 4 _U_ 1111 _N_ _N_ _N_ _N_} _N_ _N_ },
+ (*) = { _A_ 2 _U_ 11 _N_ _S_ "U(LL)U(LL)" {_A_ 4 _U_ 2222 _N_ _N_ _N_ _N_} _N_ _N_ },
+ negate = { _A_ 1 _U_ 1 _N_ _S_ "U(LL)" {_A_ 2 _U_ 11 _N_ _N_ _N_ _N_} _N_ _N_ },
+ abs = { _A_ 1 _U_ 1 _N_ _N_ _N_ _N_ },
+ signum = { _A_ 1 _U_ 1 _N_ _S_ "U(U(P)L)" {_A_ 2 _U_ 22 _N_ _N_ _N_ _N_} _N_ _N_ },
+ fromInteger = { _A_ 1 _U_ 1 _N_ _N_ _N_ _N_ },
+ fromInt = { _A_ 1 _U_ 1 _N_ _N_ _N_ _N_ } #-}
instance Text a => Text (Complex a)
{-# GHC_PRAGMA _M_ PreludeComplex {-dfun-} _A_ 1 _U_ 2 _N_ _N_ _N_ _N_ #-}
+instance Text (Complex Double)
+ {-# GHC_PRAGMA _M_ PreludeComplex {-dfun-} _A_ 0 _N_ _N_ _N_ _F_ _IF_ARGS_ 0 0 X 5 _!_ _TUP_4 [(Int -> [Char] -> [(Complex Double, [Char])]), (Int -> Complex Double -> [Char] -> [Char]), ([Char] -> [([Complex Double], [Char])]), ([Complex Double] -> [Char] -> [Char])] [_CONSTM_ Text readsPrec (Complex Double), _CONSTM_ Text showsPrec (Complex Double), _CONSTM_ Text readList (Complex Double), _CONSTM_ Text showList (Complex Double)] _N_
+ readsPrec = { _A_ 1 _U_ 12 _N_ _S_ "U(P)" {_A_ 1 _U_ 22 _N_ _N_ _N_ _N_} _N_ _N_ },
+ showsPrec = { _A_ 2 _U_ 112 _N_ _S_ "LU(LL)" {_A_ 3 _U_ 1222 _N_ _N_ _N_ _N_} _N_ _N_ },
+ readList = { _A_ 0 _U_ 2 _N_ _N_ _N_ _N_ },
+ showList = { _A_ 1 _U_ 12 _N_ _N_ _N_ _N_ } #-}
-{-# GHC_PRAGMA INTERFACE VERSION 5 #-}
+{-# GHC_PRAGMA INTERFACE VERSION 6 #-}
interface PreludeCore where
import PreludeBuiltin(Double(..))
instance Enum Double
{-# GHC_PRAGMA _M_ PreludeCore {-dfun-} _A_ 0 _N_ _N_ _N_ _F_ _IF_ARGS_ 0 0 X 6 _!_ _TUP_5 [{{Ord Double}}, (Double -> [Double]), (Double -> Double -> [Double]), (Double -> Double -> [Double]), (Double -> Double -> Double -> [Double])] [_DFUN_ Ord (Double), _CONSTM_ Enum enumFrom (Double), _CONSTM_ Enum enumFromThen (Double), _CONSTM_ Enum enumFromTo (Double), _CONSTM_ Enum enumFromThenTo (Double)] _N_
- enumFrom = _A_ 1 _U_ 2 _N_ _N_ _N_ _N_,
- enumFromThen = _A_ 2 _U_ 21 _N_ _N_ _N_ _N_,
- enumFromTo = _A_ 2 _U_ 22 _N_ _N_ _N_ _N_,
- enumFromThenTo = _A_ 3 _U_ 222 _N_ _N_ _N_ _N_ #-}
+ enumFrom = { _A_ 1 _U_ 2 _N_ _N_ _N_ _N_ },
+ enumFromThen = { _A_ 2 _U_ 21 _N_ _N_ _N_ _N_ },
+ enumFromTo = { _A_ 2 _U_ 22 _N_ _N_ _N_ _N_ },
+ enumFromThenTo = { _A_ 3 _U_ 222 _N_ _N_ _N_ _N_ } #-}
instance Eq Double
{-# GHC_PRAGMA _M_ PreludeCore {-dfun-} _A_ 0 _N_ _N_ _N_ _F_ _IF_ARGS_ 0 0 X 3 _!_ _TUP_2 [(Double -> Double -> Bool), (Double -> Double -> Bool)] [_CONSTM_ Eq (==) (Double), _CONSTM_ Eq (/=) (Double)] _N_
- (==) = _A_ 2 _U_ 11 _N_ _S_ "U(P)U(P)" {_A_ 2 _U_ 22 _N_ _N_ _F_ _IF_ARGS_ 0 2 XX 1 \ (u0 :: Double#) (u1 :: Double#) -> _#_ eqDouble# [] [u0, u1] _N_} _F_ _IF_ARGS_ 0 2 CC 3 \ (u0 :: Double) (u1 :: Double) -> case u0 of { _ALG_ D# (u2 :: Double#) -> case u1 of { _ALG_ D# (u3 :: Double#) -> _#_ eqDouble# [] [u2, u3]; _NO_DEFLT_ }; _NO_DEFLT_ } _N_,
- (/=) = _A_ 2 _U_ 11 _N_ _S_ "U(P)U(P)" {_A_ 2 _U_ 22 _N_ _N_ _F_ _IF_ARGS_ 0 2 XX 1 \ (u0 :: Double#) (u1 :: Double#) -> _#_ neDouble# [] [u0, u1] _N_} _F_ _IF_ARGS_ 0 2 CC 3 \ (u0 :: Double) (u1 :: Double) -> case u0 of { _ALG_ D# (u2 :: Double#) -> case u1 of { _ALG_ D# (u3 :: Double#) -> _#_ neDouble# [] [u2, u3]; _NO_DEFLT_ }; _NO_DEFLT_ } _N_ #-}
+ (==) = { _A_ 2 _U_ 11 _N_ _S_ "U(P)U(P)" {_A_ 2 _U_ 22 _N_ _N_ _F_ _IF_ARGS_ 0 2 XX 1 \ (u0 :: Double#) (u1 :: Double#) -> _#_ eqDouble# [] [u0, u1] _N_} _F_ _IF_ARGS_ 0 2 CC 3 \ (u0 :: Double) (u1 :: Double) -> case u0 of { _ALG_ D# (u2 :: Double#) -> case u1 of { _ALG_ D# (u3 :: Double#) -> _#_ eqDouble# [] [u2, u3]; _NO_DEFLT_ }; _NO_DEFLT_ } _N_ },
+ (/=) = { _A_ 2 _U_ 11 _N_ _S_ "U(P)U(P)" {_A_ 2 _U_ 22 _N_ _N_ _F_ _IF_ARGS_ 0 2 XX 1 \ (u0 :: Double#) (u1 :: Double#) -> _#_ neDouble# [] [u0, u1] _N_} _F_ _IF_ARGS_ 0 2 CC 3 \ (u0 :: Double) (u1 :: Double) -> case u0 of { _ALG_ D# (u2 :: Double#) -> case u1 of { _ALG_ D# (u3 :: Double#) -> _#_ neDouble# [] [u2, u3]; _NO_DEFLT_ }; _NO_DEFLT_ } _N_ } #-}
instance Floating Double
{-# GHC_PRAGMA _M_ PreludeCore {-dfun-} _A_ 0 _N_ _N_ _N_ _F_ _IF_ARGS_ 0 0 X 20 _!_ _TUP_19 [{{Fractional Double}}, Double, (Double -> Double), (Double -> Double), (Double -> Double), (Double -> Double -> Double), (Double -> Double -> Double), (Double -> Double), (Double -> Double), (Double -> Double), (Double -> Double), (Double -> Double), (Double -> Double), (Double -> Double), (Double -> Double), (Double -> Double), (Double -> Double), (Double -> Double), (Double -> Double)] [_DFUN_ Fractional (Double), _CONSTM_ Floating pi (Double), _CONSTM_ Floating exp (Double), _CONSTM_ Floating log (Double), _CONSTM_ Floating sqrt (Double), _CONSTM_ Floating (**) (Double), _CONSTM_ Floating logBase (Double), _CONSTM_ Floating sin (Double), _CONSTM_ Floating cos (Double), _CONSTM_ Floating tan (Double), _CONSTM_ Floating asin (Double), _CONSTM_ Floating acos (Double), _CONSTM_ Floating atan (Double), _CONSTM_ Floating sinh (Double), _CONSTM_ Floating cosh (Double), _CONSTM_ Floating tanh (Double), _CONSTM_ Floating asinh (Double), _CONSTM_ Floating acosh (Double), _CONSTM_ Floating atanh (Double)] _N_
- pi = _A_ 0 _N_ _N_ _N_ _F_ _IF_ARGS_ 0 0 X 2 _!_ D# [] [3.1415926535897931##] _N_,
- exp = _A_ 1 _U_ 1 _N_ _S_ "U(P)" {_A_ 1 _U_ 2 _N_ _N_ _F_ _IF_ARGS_ 0 1 X 3 \ (u0 :: Double#) -> case _#_ expDouble# [] [u0] of { _PRIM_ (u1 :: Double#) -> _!_ D# [] [u1] } _N_} _F_ _IF_ARGS_ 0 1 C 4 \ (u0 :: Double) -> case u0 of { _ALG_ D# (u1 :: Double#) -> case _#_ expDouble# [] [u1] of { _PRIM_ (u2 :: Double#) -> _!_ D# [] [u2] }; _NO_DEFLT_ } _N_,
- log = _A_ 1 _U_ 1 _N_ _S_ "U(P)" {_A_ 1 _U_ 2 _N_ _N_ _F_ _IF_ARGS_ 0 1 X 3 \ (u0 :: Double#) -> case _#_ logDouble# [] [u0] of { _PRIM_ (u1 :: Double#) -> _!_ D# [] [u1] } _N_} _F_ _IF_ARGS_ 0 1 C 4 \ (u0 :: Double) -> case u0 of { _ALG_ D# (u1 :: Double#) -> case _#_ logDouble# [] [u1] of { _PRIM_ (u2 :: Double#) -> _!_ D# [] [u2] }; _NO_DEFLT_ } _N_,
- sqrt = _A_ 1 _U_ 1 _N_ _S_ "U(P)" {_A_ 1 _U_ 2 _N_ _N_ _F_ _IF_ARGS_ 0 1 X 3 \ (u0 :: Double#) -> case _#_ sqrtDouble# [] [u0] of { _PRIM_ (u1 :: Double#) -> _!_ D# [] [u1] } _N_} _F_ _IF_ARGS_ 0 1 C 4 \ (u0 :: Double) -> case u0 of { _ALG_ D# (u1 :: Double#) -> case _#_ sqrtDouble# [] [u1] of { _PRIM_ (u2 :: Double#) -> _!_ D# [] [u2] }; _NO_DEFLT_ } _N_,
- (**) = _A_ 2 _U_ 11 _N_ _S_ "U(P)U(P)" {_A_ 2 _U_ 22 _N_ _N_ _F_ _IF_ARGS_ 0 2 XX 3 \ (u0 :: Double#) (u1 :: Double#) -> case _#_ powerDouble# [] [u0, u1] of { _PRIM_ (u2 :: Double#) -> _!_ D# [] [u2] } _N_} _F_ _IF_ARGS_ 0 2 CC 5 \ (u0 :: Double) (u1 :: Double) -> case u0 of { _ALG_ D# (u2 :: Double#) -> case u1 of { _ALG_ D# (u3 :: Double#) -> case _#_ powerDouble# [] [u2, u3] of { _PRIM_ (u4 :: Double#) -> _!_ D# [] [u4] }; _NO_DEFLT_ }; _NO_DEFLT_ } _N_,
- logBase = _A_ 2 _U_ 11 _N_ _S_ "U(P)U(P)" {_A_ 2 _U_ 22 _N_ _N_ _F_ _IF_ARGS_ 0 2 XX 5 \ (u0 :: Double#) (u1 :: Double#) -> case _#_ logDouble# [] [u1] of { _PRIM_ (u2 :: Double#) -> case _#_ logDouble# [] [u0] of { _PRIM_ (u3 :: Double#) -> case _#_ divideDouble# [] [u2, u3] of { _PRIM_ (u4 :: Double#) -> _!_ D# [] [u4] } } } _N_} _F_ _IF_ARGS_ 0 2 CC 7 \ (u0 :: Double) (u1 :: Double) -> case u1 of { _ALG_ D# (u2 :: Double#) -> case _#_ logDouble# [] [u2] of { _PRIM_ (u3 :: Double#) -> case u0 of { _ALG_ D# (u4 :: Double#) -> case _#_ logDouble# [] [u4] of { _PRIM_ (u5 :: Double#) -> case _#_ divideDouble# [] [u3, u5] of { _PRIM_ (u6 :: Double#) -> _!_ D# [] [u6] } }; _NO_DEFLT_ } }; _NO_DEFLT_ } _N_,
- sin = _A_ 1 _U_ 1 _N_ _S_ "U(P)" {_A_ 1 _U_ 2 _N_ _N_ _F_ _IF_ARGS_ 0 1 X 3 \ (u0 :: Double#) -> case _#_ sinDouble# [] [u0] of { _PRIM_ (u1 :: Double#) -> _!_ D# [] [u1] } _N_} _F_ _IF_ARGS_ 0 1 C 4 \ (u0 :: Double) -> case u0 of { _ALG_ D# (u1 :: Double#) -> case _#_ sinDouble# [] [u1] of { _PRIM_ (u2 :: Double#) -> _!_ D# [] [u2] }; _NO_DEFLT_ } _N_,
- cos = _A_ 1 _U_ 1 _N_ _S_ "U(P)" {_A_ 1 _U_ 2 _N_ _N_ _F_ _IF_ARGS_ 0 1 X 3 \ (u0 :: Double#) -> case _#_ cosDouble# [] [u0] of { _PRIM_ (u1 :: Double#) -> _!_ D# [] [u1] } _N_} _F_ _IF_ARGS_ 0 1 C 4 \ (u0 :: Double) -> case u0 of { _ALG_ D# (u1 :: Double#) -> case _#_ cosDouble# [] [u1] of { _PRIM_ (u2 :: Double#) -> _!_ D# [] [u2] }; _NO_DEFLT_ } _N_,
- tan = _A_ 1 _U_ 1 _N_ _S_ "U(P)" {_A_ 1 _U_ 2 _N_ _N_ _F_ _IF_ARGS_ 0 1 X 3 \ (u0 :: Double#) -> case _#_ tanDouble# [] [u0] of { _PRIM_ (u1 :: Double#) -> _!_ D# [] [u1] } _N_} _F_ _IF_ARGS_ 0 1 C 4 \ (u0 :: Double) -> case u0 of { _ALG_ D# (u1 :: Double#) -> case _#_ tanDouble# [] [u1] of { _PRIM_ (u2 :: Double#) -> _!_ D# [] [u2] }; _NO_DEFLT_ } _N_,
- asin = _A_ 1 _U_ 1 _N_ _S_ "U(P)" {_A_ 1 _U_ 2 _N_ _N_ _F_ _IF_ARGS_ 0 1 X 3 \ (u0 :: Double#) -> case _#_ asinDouble# [] [u0] of { _PRIM_ (u1 :: Double#) -> _!_ D# [] [u1] } _N_} _F_ _IF_ARGS_ 0 1 C 4 \ (u0 :: Double) -> case u0 of { _ALG_ D# (u1 :: Double#) -> case _#_ asinDouble# [] [u1] of { _PRIM_ (u2 :: Double#) -> _!_ D# [] [u2] }; _NO_DEFLT_ } _N_,
- acos = _A_ 1 _U_ 1 _N_ _S_ "U(P)" {_A_ 1 _U_ 2 _N_ _N_ _F_ _IF_ARGS_ 0 1 X 3 \ (u0 :: Double#) -> case _#_ acosDouble# [] [u0] of { _PRIM_ (u1 :: Double#) -> _!_ D# [] [u1] } _N_} _F_ _IF_ARGS_ 0 1 C 4 \ (u0 :: Double) -> case u0 of { _ALG_ D# (u1 :: Double#) -> case _#_ acosDouble# [] [u1] of { _PRIM_ (u2 :: Double#) -> _!_ D# [] [u2] }; _NO_DEFLT_ } _N_,
- atan = _A_ 1 _U_ 1 _N_ _S_ "U(P)" {_A_ 1 _U_ 2 _N_ _N_ _F_ _IF_ARGS_ 0 1 X 3 \ (u0 :: Double#) -> case _#_ atanDouble# [] [u0] of { _PRIM_ (u1 :: Double#) -> _!_ D# [] [u1] } _N_} _F_ _IF_ARGS_ 0 1 C 4 \ (u0 :: Double) -> case u0 of { _ALG_ D# (u1 :: Double#) -> case _#_ atanDouble# [] [u1] of { _PRIM_ (u2 :: Double#) -> _!_ D# [] [u2] }; _NO_DEFLT_ } _N_,
- sinh = _A_ 1 _U_ 1 _N_ _S_ "U(P)" {_A_ 1 _U_ 2 _N_ _N_ _F_ _IF_ARGS_ 0 1 X 3 \ (u0 :: Double#) -> case _#_ sinhDouble# [] [u0] of { _PRIM_ (u1 :: Double#) -> _!_ D# [] [u1] } _N_} _F_ _IF_ARGS_ 0 1 C 4 \ (u0 :: Double) -> case u0 of { _ALG_ D# (u1 :: Double#) -> case _#_ sinhDouble# [] [u1] of { _PRIM_ (u2 :: Double#) -> _!_ D# [] [u2] }; _NO_DEFLT_ } _N_,
- cosh = _A_ 1 _U_ 1 _N_ _S_ "U(P)" {_A_ 1 _U_ 2 _N_ _N_ _F_ _IF_ARGS_ 0 1 X 3 \ (u0 :: Double#) -> case _#_ coshDouble# [] [u0] of { _PRIM_ (u1 :: Double#) -> _!_ D# [] [u1] } _N_} _F_ _IF_ARGS_ 0 1 C 4 \ (u0 :: Double) -> case u0 of { _ALG_ D# (u1 :: Double#) -> case _#_ coshDouble# [] [u1] of { _PRIM_ (u2 :: Double#) -> _!_ D# [] [u2] }; _NO_DEFLT_ } _N_,
- tanh = _A_ 1 _U_ 1 _N_ _S_ "U(P)" {_A_ 1 _U_ 2 _N_ _N_ _F_ _IF_ARGS_ 0 1 X 3 \ (u0 :: Double#) -> case _#_ tanhDouble# [] [u0] of { _PRIM_ (u1 :: Double#) -> _!_ D# [] [u1] } _N_} _F_ _IF_ARGS_ 0 1 C 4 \ (u0 :: Double) -> case u0 of { _ALG_ D# (u1 :: Double#) -> case _#_ tanhDouble# [] [u1] of { _PRIM_ (u2 :: Double#) -> _!_ D# [] [u2] }; _NO_DEFLT_ } _N_,
- asinh = _A_ 1 _U_ 1 _N_ _S_ "U(P)" {_A_ 1 _U_ 2 _N_ _N_ _N_ _N_} _N_ _N_,
- acosh = _A_ 1 _U_ 1 _N_ _S_ "U(P)" {_A_ 1 _U_ 2 _N_ _N_ _N_ _N_} _N_ _N_,
- atanh = _A_ 1 _U_ 1 _N_ _S_ "U(P)" {_A_ 1 _U_ 2 _N_ _N_ _N_ _N_} _N_ _N_ #-}
+ pi = { _A_ 0 _N_ _N_ _N_ _F_ _IF_ARGS_ 0 0 X 2 _!_ D# [] [3.1415926535897931##] _N_ },
+ exp = { _A_ 1 _U_ 1 _N_ _S_ "U(P)" {_A_ 1 _U_ 2 _N_ _N_ _F_ _IF_ARGS_ 0 1 X 3 \ (u0 :: Double#) -> case _#_ expDouble# [] [u0] of { _PRIM_ (u1 :: Double#) -> _!_ D# [] [u1] } _N_} _F_ _IF_ARGS_ 0 1 C 4 \ (u0 :: Double) -> case u0 of { _ALG_ D# (u1 :: Double#) -> case _#_ expDouble# [] [u1] of { _PRIM_ (u2 :: Double#) -> _!_ D# [] [u2] }; _NO_DEFLT_ } _N_ },
+ log = { _A_ 1 _U_ 1 _N_ _S_ "U(P)" {_A_ 1 _U_ 2 _N_ _N_ _F_ _IF_ARGS_ 0 1 X 3 \ (u0 :: Double#) -> case _#_ logDouble# [] [u0] of { _PRIM_ (u1 :: Double#) -> _!_ D# [] [u1] } _N_} _F_ _IF_ARGS_ 0 1 C 4 \ (u0 :: Double) -> case u0 of { _ALG_ D# (u1 :: Double#) -> case _#_ logDouble# [] [u1] of { _PRIM_ (u2 :: Double#) -> _!_ D# [] [u2] }; _NO_DEFLT_ } _N_ },
+ sqrt = { _A_ 1 _U_ 1 _N_ _S_ "U(P)" {_A_ 1 _U_ 2 _N_ _N_ _F_ _IF_ARGS_ 0 1 X 3 \ (u0 :: Double#) -> case _#_ sqrtDouble# [] [u0] of { _PRIM_ (u1 :: Double#) -> _!_ D# [] [u1] } _N_} _F_ _IF_ARGS_ 0 1 C 4 \ (u0 :: Double) -> case u0 of { _ALG_ D# (u1 :: Double#) -> case _#_ sqrtDouble# [] [u1] of { _PRIM_ (u2 :: Double#) -> _!_ D# [] [u2] }; _NO_DEFLT_ } _N_ },
+ (**) = { _A_ 2 _U_ 11 _N_ _S_ "U(P)U(P)" {_A_ 2 _U_ 22 _N_ _N_ _F_ _IF_ARGS_ 0 2 XX 3 \ (u0 :: Double#) (u1 :: Double#) -> case _#_ powerDouble# [] [u0, u1] of { _PRIM_ (u2 :: Double#) -> _!_ D# [] [u2] } _N_} _F_ _IF_ARGS_ 0 2 CC 5 \ (u0 :: Double) (u1 :: Double) -> case u0 of { _ALG_ D# (u2 :: Double#) -> case u1 of { _ALG_ D# (u3 :: Double#) -> case _#_ powerDouble# [] [u2, u3] of { _PRIM_ (u4 :: Double#) -> _!_ D# [] [u4] }; _NO_DEFLT_ }; _NO_DEFLT_ } _N_ },
+ logBase = { _A_ 2 _U_ 11 _N_ _S_ "U(P)U(P)" {_A_ 2 _U_ 22 _N_ _N_ _F_ _IF_ARGS_ 0 2 XX 5 \ (u0 :: Double#) (u1 :: Double#) -> case _#_ logDouble# [] [u1] of { _PRIM_ (u2 :: Double#) -> case _#_ logDouble# [] [u0] of { _PRIM_ (u3 :: Double#) -> case _#_ divideDouble# [] [u2, u3] of { _PRIM_ (u4 :: Double#) -> _!_ D# [] [u4] } } } _N_} _F_ _IF_ARGS_ 0 2 CC 7 \ (u0 :: Double) (u1 :: Double) -> case u1 of { _ALG_ D# (u2 :: Double#) -> case _#_ logDouble# [] [u2] of { _PRIM_ (u3 :: Double#) -> case u0 of { _ALG_ D# (u4 :: Double#) -> case _#_ logDouble# [] [u4] of { _PRIM_ (u5 :: Double#) -> case _#_ divideDouble# [] [u3, u5] of { _PRIM_ (u6 :: Double#) -> _!_ D# [] [u6] } }; _NO_DEFLT_ } }; _NO_DEFLT_ } _N_ },
+ sin = { _A_ 1 _U_ 1 _N_ _S_ "U(P)" {_A_ 1 _U_ 2 _N_ _N_ _F_ _IF_ARGS_ 0 1 X 3 \ (u0 :: Double#) -> case _#_ sinDouble# [] [u0] of { _PRIM_ (u1 :: Double#) -> _!_ D# [] [u1] } _N_} _F_ _IF_ARGS_ 0 1 C 4 \ (u0 :: Double) -> case u0 of { _ALG_ D# (u1 :: Double#) -> case _#_ sinDouble# [] [u1] of { _PRIM_ (u2 :: Double#) -> _!_ D# [] [u2] }; _NO_DEFLT_ } _N_ },
+ cos = { _A_ 1 _U_ 1 _N_ _S_ "U(P)" {_A_ 1 _U_ 2 _N_ _N_ _F_ _IF_ARGS_ 0 1 X 3 \ (u0 :: Double#) -> case _#_ cosDouble# [] [u0] of { _PRIM_ (u1 :: Double#) -> _!_ D# [] [u1] } _N_} _F_ _IF_ARGS_ 0 1 C 4 \ (u0 :: Double) -> case u0 of { _ALG_ D# (u1 :: Double#) -> case _#_ cosDouble# [] [u1] of { _PRIM_ (u2 :: Double#) -> _!_ D# [] [u2] }; _NO_DEFLT_ } _N_ },
+ tan = { _A_ 1 _U_ 1 _N_ _S_ "U(P)" {_A_ 1 _U_ 2 _N_ _N_ _F_ _IF_ARGS_ 0 1 X 3 \ (u0 :: Double#) -> case _#_ tanDouble# [] [u0] of { _PRIM_ (u1 :: Double#) -> _!_ D# [] [u1] } _N_} _F_ _IF_ARGS_ 0 1 C 4 \ (u0 :: Double) -> case u0 of { _ALG_ D# (u1 :: Double#) -> case _#_ tanDouble# [] [u1] of { _PRIM_ (u2 :: Double#) -> _!_ D# [] [u2] }; _NO_DEFLT_ } _N_ },
+ asin = { _A_ 1 _U_ 1 _N_ _S_ "U(P)" {_A_ 1 _U_ 2 _N_ _N_ _F_ _IF_ARGS_ 0 1 X 3 \ (u0 :: Double#) -> case _#_ asinDouble# [] [u0] of { _PRIM_ (u1 :: Double#) -> _!_ D# [] [u1] } _N_} _F_ _IF_ARGS_ 0 1 C 4 \ (u0 :: Double) -> case u0 of { _ALG_ D# (u1 :: Double#) -> case _#_ asinDouble# [] [u1] of { _PRIM_ (u2 :: Double#) -> _!_ D# [] [u2] }; _NO_DEFLT_ } _N_ },
+ acos = { _A_ 1 _U_ 1 _N_ _S_ "U(P)" {_A_ 1 _U_ 2 _N_ _N_ _F_ _IF_ARGS_ 0 1 X 3 \ (u0 :: Double#) -> case _#_ acosDouble# [] [u0] of { _PRIM_ (u1 :: Double#) -> _!_ D# [] [u1] } _N_} _F_ _IF_ARGS_ 0 1 C 4 \ (u0 :: Double) -> case u0 of { _ALG_ D# (u1 :: Double#) -> case _#_ acosDouble# [] [u1] of { _PRIM_ (u2 :: Double#) -> _!_ D# [] [u2] }; _NO_DEFLT_ } _N_ },
+ atan = { _A_ 1 _U_ 1 _N_ _S_ "U(P)" {_A_ 1 _U_ 2 _N_ _N_ _F_ _IF_ARGS_ 0 1 X 3 \ (u0 :: Double#) -> case _#_ atanDouble# [] [u0] of { _PRIM_ (u1 :: Double#) -> _!_ D# [] [u1] } _N_} _F_ _IF_ARGS_ 0 1 C 4 \ (u0 :: Double) -> case u0 of { _ALG_ D# (u1 :: Double#) -> case _#_ atanDouble# [] [u1] of { _PRIM_ (u2 :: Double#) -> _!_ D# [] [u2] }; _NO_DEFLT_ } _N_ },
+ sinh = { _A_ 1 _U_ 1 _N_ _S_ "U(P)" {_A_ 1 _U_ 2 _N_ _N_ _F_ _IF_ARGS_ 0 1 X 3 \ (u0 :: Double#) -> case _#_ sinhDouble# [] [u0] of { _PRIM_ (u1 :: Double#) -> _!_ D# [] [u1] } _N_} _F_ _IF_ARGS_ 0 1 C 4 \ (u0 :: Double) -> case u0 of { _ALG_ D# (u1 :: Double#) -> case _#_ sinhDouble# [] [u1] of { _PRIM_ (u2 :: Double#) -> _!_ D# [] [u2] }; _NO_DEFLT_ } _N_ },
+ cosh = { _A_ 1 _U_ 1 _N_ _S_ "U(P)" {_A_ 1 _U_ 2 _N_ _N_ _F_ _IF_ARGS_ 0 1 X 3 \ (u0 :: Double#) -> case _#_ coshDouble# [] [u0] of { _PRIM_ (u1 :: Double#) -> _!_ D# [] [u1] } _N_} _F_ _IF_ARGS_ 0 1 C 4 \ (u0 :: Double) -> case u0 of { _ALG_ D# (u1 :: Double#) -> case _#_ coshDouble# [] [u1] of { _PRIM_ (u2 :: Double#) -> _!_ D# [] [u2] }; _NO_DEFLT_ } _N_ },
+ tanh = { _A_ 1 _U_ 1 _N_ _S_ "U(P)" {_A_ 1 _U_ 2 _N_ _N_ _F_ _IF_ARGS_ 0 1 X 3 \ (u0 :: Double#) -> case _#_ tanhDouble# [] [u0] of { _PRIM_ (u1 :: Double#) -> _!_ D# [] [u1] } _N_} _F_ _IF_ARGS_ 0 1 C 4 \ (u0 :: Double) -> case u0 of { _ALG_ D# (u1 :: Double#) -> case _#_ tanhDouble# [] [u1] of { _PRIM_ (u2 :: Double#) -> _!_ D# [] [u2] }; _NO_DEFLT_ } _N_ },
+ asinh = { _A_ 1 _U_ 1 _N_ _S_ "U(P)" {_A_ 1 _U_ 2 _N_ _N_ _N_ _N_} _N_ _N_ },
+ acosh = { _A_ 1 _U_ 1 _N_ _S_ "U(P)" {_A_ 1 _U_ 2 _N_ _N_ _N_ _N_} _N_ _N_ },
+ atanh = { _A_ 1 _U_ 1 _N_ _S_ "U(P)" {_A_ 1 _U_ 2 _N_ _N_ _N_ _N_} _N_ _N_ } #-}
instance Fractional Double
{-# GHC_PRAGMA _M_ PreludeCore {-dfun-} _A_ 0 _N_ _N_ _N_ _F_ _IF_ARGS_ 0 0 X 5 _!_ _TUP_4 [{{Num Double}}, (Double -> Double -> Double), (Double -> Double), (Ratio Integer -> Double)] [_DFUN_ Num (Double), _CONSTM_ Fractional (/) (Double), _CONSTM_ Fractional recip (Double), _CONSTM_ Fractional fromRational (Double)] _N_
- (/) = _A_ 2 _U_ 11 _N_ _S_ "U(P)U(P)" {_A_ 2 _U_ 22 _N_ _N_ _F_ _IF_ARGS_ 0 2 XX 3 \ (u0 :: Double#) (u1 :: Double#) -> case _#_ divideDouble# [] [u0, u1] of { _PRIM_ (u2 :: Double#) -> _!_ D# [] [u2] } _N_} _F_ _IF_ARGS_ 0 2 CC 5 \ (u0 :: Double) (u1 :: Double) -> case u0 of { _ALG_ D# (u2 :: Double#) -> case u1 of { _ALG_ D# (u3 :: Double#) -> case _#_ divideDouble# [] [u2, u3] of { _PRIM_ (u4 :: Double#) -> _!_ D# [] [u4] }; _NO_DEFLT_ }; _NO_DEFLT_ } _N_,
- recip = _A_ 1 _U_ 1 _N_ _S_ "U(P)" {_A_ 1 _U_ 2 _N_ _N_ _F_ _IF_ARGS_ 0 1 X 3 \ (u0 :: Double#) -> case _#_ divideDouble# [] [1.0000000000000000##, u0] of { _PRIM_ (u1 :: Double#) -> _!_ D# [] [u1] } _N_} _F_ _IF_ARGS_ 0 1 C 4 \ (u0 :: Double) -> case u0 of { _ALG_ D# (u1 :: Double#) -> case _#_ divideDouble# [] [1.0000000000000000##, u1] of { _PRIM_ (u2 :: Double#) -> _!_ D# [] [u2] }; _NO_DEFLT_ } _N_,
- fromRational = _A_ 0 _U_ 2 _N_ _N_ _N_ _N_ #-}
+ (/) = { _A_ 2 _U_ 11 _N_ _S_ "U(P)U(P)" {_A_ 2 _U_ 22 _N_ _N_ _F_ _IF_ARGS_ 0 2 XX 3 \ (u0 :: Double#) (u1 :: Double#) -> case _#_ divideDouble# [] [u0, u1] of { _PRIM_ (u2 :: Double#) -> _!_ D# [] [u2] } _N_} _F_ _IF_ARGS_ 0 2 CC 5 \ (u0 :: Double) (u1 :: Double) -> case u0 of { _ALG_ D# (u2 :: Double#) -> case u1 of { _ALG_ D# (u3 :: Double#) -> case _#_ divideDouble# [] [u2, u3] of { _PRIM_ (u4 :: Double#) -> _!_ D# [] [u4] }; _NO_DEFLT_ }; _NO_DEFLT_ } _N_ },
+ recip = { _A_ 1 _U_ 1 _N_ _S_ "U(P)" {_A_ 1 _U_ 2 _N_ _N_ _F_ _IF_ARGS_ 0 1 X 3 \ (u0 :: Double#) -> case _#_ divideDouble# [] [1.0000000000000000##, u0] of { _PRIM_ (u1 :: Double#) -> _!_ D# [] [u1] } _N_} _F_ _IF_ARGS_ 0 1 C 4 \ (u0 :: Double) -> case u0 of { _ALG_ D# (u1 :: Double#) -> case _#_ divideDouble# [] [1.0000000000000000##, u1] of { _PRIM_ (u2 :: Double#) -> _!_ D# [] [u2] }; _NO_DEFLT_ } _N_ },
+ fromRational = { _A_ 1 _U_ 1 _N_ _S_ "U(U(PPP)U(PPP))" {_A_ 4 _U_ 2222 _N_ _N_ _N_ _N_} _N_ _N_ } #-}
instance Num Double
{-# GHC_PRAGMA _M_ PreludeCore {-dfun-} _A_ 0 _N_ _N_ _N_ _F_ _IF_ARGS_ 0 0 X 11 _!_ _TUP_10 [{{Eq Double}}, {{Text Double}}, (Double -> Double -> Double), (Double -> Double -> Double), (Double -> Double -> Double), (Double -> Double), (Double -> Double), (Double -> Double), (Integer -> Double), (Int -> Double)] [_DFUN_ Eq (Double), _DFUN_ Text (Double), _CONSTM_ Num (+) (Double), _CONSTM_ Num (-) (Double), _CONSTM_ Num (*) (Double), _CONSTM_ Num negate (Double), _CONSTM_ Num abs (Double), _CONSTM_ Num signum (Double), _CONSTM_ Num fromInteger (Double), _CONSTM_ Num fromInt (Double)] _N_
- (+) = _A_ 2 _U_ 11 _N_ _S_ "U(P)U(P)" {_A_ 2 _U_ 22 _N_ _N_ _F_ _IF_ARGS_ 0 2 XX 3 \ (u0 :: Double#) (u1 :: Double#) -> case _#_ plusDouble# [] [u0, u1] of { _PRIM_ (u2 :: Double#) -> _!_ D# [] [u2] } _N_} _F_ _IF_ARGS_ 0 2 CC 5 \ (u0 :: Double) (u1 :: Double) -> case u0 of { _ALG_ D# (u2 :: Double#) -> case u1 of { _ALG_ D# (u3 :: Double#) -> case _#_ plusDouble# [] [u2, u3] of { _PRIM_ (u4 :: Double#) -> _!_ D# [] [u4] }; _NO_DEFLT_ }; _NO_DEFLT_ } _N_,
- (-) = _A_ 2 _U_ 11 _N_ _S_ "U(P)U(P)" {_A_ 2 _U_ 22 _N_ _N_ _F_ _IF_ARGS_ 0 2 XX 3 \ (u0 :: Double#) (u1 :: Double#) -> case _#_ minusDouble# [] [u0, u1] of { _PRIM_ (u2 :: Double#) -> _!_ D# [] [u2] } _N_} _F_ _IF_ARGS_ 0 2 CC 5 \ (u0 :: Double) (u1 :: Double) -> case u0 of { _ALG_ D# (u2 :: Double#) -> case u1 of { _ALG_ D# (u3 :: Double#) -> case _#_ minusDouble# [] [u2, u3] of { _PRIM_ (u4 :: Double#) -> _!_ D# [] [u4] }; _NO_DEFLT_ }; _NO_DEFLT_ } _N_,
- (*) = _A_ 2 _U_ 11 _N_ _S_ "U(P)U(P)" {_A_ 2 _U_ 22 _N_ _N_ _F_ _IF_ARGS_ 0 2 XX 3 \ (u0 :: Double#) (u1 :: Double#) -> case _#_ timesDouble# [] [u0, u1] of { _PRIM_ (u2 :: Double#) -> _!_ D# [] [u2] } _N_} _F_ _IF_ARGS_ 0 2 CC 5 \ (u0 :: Double) (u1 :: Double) -> case u0 of { _ALG_ D# (u2 :: Double#) -> case u1 of { _ALG_ D# (u3 :: Double#) -> case _#_ timesDouble# [] [u2, u3] of { _PRIM_ (u4 :: Double#) -> _!_ D# [] [u4] }; _NO_DEFLT_ }; _NO_DEFLT_ } _N_,
- negate = _A_ 1 _U_ 1 _N_ _S_ "U(P)" {_A_ 1 _U_ 2 _N_ _N_ _F_ _IF_ARGS_ 0 1 X 3 \ (u0 :: Double#) -> case _#_ negateDouble# [] [u0] of { _PRIM_ (u1 :: Double#) -> _!_ D# [] [u1] } _N_} _F_ _IF_ARGS_ 0 1 C 4 \ (u0 :: Double) -> case u0 of { _ALG_ D# (u1 :: Double#) -> case _#_ negateDouble# [] [u1] of { _PRIM_ (u2 :: Double#) -> _!_ D# [] [u2] }; _NO_DEFLT_ } _N_,
- abs = _A_ 1 _U_ 1 _N_ _S_ "U(P)" {_A_ 1 _U_ 2 _N_ _N_ _N_ _N_} _N_ _N_,
- signum = _A_ 1 _U_ 1 _N_ _S_ "U(P)" {_A_ 1 _U_ 2 _N_ _N_ _N_ _N_} _N_ _N_,
- fromInteger = _A_ 1 _U_ 1 _N_ _S_ "U(PPP)" {_A_ 3 _U_ 222 _N_ _N_ _F_ _IF_ARGS_ 0 3 XXX 3 \ (u0 :: Int#) (u1 :: Int#) (u2 :: ByteArray#) -> case _#_ encodeDouble# [] [u0, u1, u2, 0#] of { _PRIM_ (u3 :: Double#) -> _!_ D# [] [u3] } _N_} _F_ _IF_ARGS_ 0 1 C 4 \ (u0 :: Integer) -> case u0 of { _ALG_ J# (u1 :: Int#) (u2 :: Int#) (u3 :: ByteArray#) -> case _#_ encodeDouble# [] [u1, u2, u3, 0#] of { _PRIM_ (u4 :: Double#) -> _!_ D# [] [u4] }; _NO_DEFLT_ } _N_,
- fromInt = _A_ 1 _U_ 1 _N_ _S_ "U(P)" {_A_ 1 _U_ 2 _N_ _N_ _F_ _IF_ARGS_ 0 1 X 3 \ (u0 :: Int#) -> case _#_ int2Double# [] [u0] of { _PRIM_ (u1 :: Double#) -> _!_ D# [] [u1] } _N_} _F_ _IF_ARGS_ 0 1 C 4 \ (u0 :: Int) -> case u0 of { _ALG_ I# (u1 :: Int#) -> case _#_ int2Double# [] [u1] of { _PRIM_ (u2 :: Double#) -> _!_ D# [] [u2] }; _NO_DEFLT_ } _N_ #-}
+ (+) = { _A_ 2 _U_ 11 _N_ _S_ "U(P)U(P)" {_A_ 2 _U_ 22 _N_ _N_ _F_ _IF_ARGS_ 0 2 XX 3 \ (u0 :: Double#) (u1 :: Double#) -> case _#_ plusDouble# [] [u0, u1] of { _PRIM_ (u2 :: Double#) -> _!_ D# [] [u2] } _N_} _F_ _IF_ARGS_ 0 2 CC 5 \ (u0 :: Double) (u1 :: Double) -> case u0 of { _ALG_ D# (u2 :: Double#) -> case u1 of { _ALG_ D# (u3 :: Double#) -> case _#_ plusDouble# [] [u2, u3] of { _PRIM_ (u4 :: Double#) -> _!_ D# [] [u4] }; _NO_DEFLT_ }; _NO_DEFLT_ } _N_ },
+ (-) = { _A_ 2 _U_ 11 _N_ _S_ "U(P)U(P)" {_A_ 2 _U_ 22 _N_ _N_ _F_ _IF_ARGS_ 0 2 XX 3 \ (u0 :: Double#) (u1 :: Double#) -> case _#_ minusDouble# [] [u0, u1] of { _PRIM_ (u2 :: Double#) -> _!_ D# [] [u2] } _N_} _F_ _IF_ARGS_ 0 2 CC 5 \ (u0 :: Double) (u1 :: Double) -> case u0 of { _ALG_ D# (u2 :: Double#) -> case u1 of { _ALG_ D# (u3 :: Double#) -> case _#_ minusDouble# [] [u2, u3] of { _PRIM_ (u4 :: Double#) -> _!_ D# [] [u4] }; _NO_DEFLT_ }; _NO_DEFLT_ } _N_ },
+ (*) = { _A_ 2 _U_ 11 _N_ _S_ "U(P)U(P)" {_A_ 2 _U_ 22 _N_ _N_ _F_ _IF_ARGS_ 0 2 XX 3 \ (u0 :: Double#) (u1 :: Double#) -> case _#_ timesDouble# [] [u0, u1] of { _PRIM_ (u2 :: Double#) -> _!_ D# [] [u2] } _N_} _F_ _IF_ARGS_ 0 2 CC 5 \ (u0 :: Double) (u1 :: Double) -> case u0 of { _ALG_ D# (u2 :: Double#) -> case u1 of { _ALG_ D# (u3 :: Double#) -> case _#_ timesDouble# [] [u2, u3] of { _PRIM_ (u4 :: Double#) -> _!_ D# [] [u4] }; _NO_DEFLT_ }; _NO_DEFLT_ } _N_ },
+ negate = { _A_ 1 _U_ 1 _N_ _S_ "U(P)" {_A_ 1 _U_ 2 _N_ _N_ _F_ _IF_ARGS_ 0 1 X 3 \ (u0 :: Double#) -> case _#_ negateDouble# [] [u0] of { _PRIM_ (u1 :: Double#) -> _!_ D# [] [u1] } _N_} _F_ _IF_ARGS_ 0 1 C 4 \ (u0 :: Double) -> case u0 of { _ALG_ D# (u1 :: Double#) -> case _#_ negateDouble# [] [u1] of { _PRIM_ (u2 :: Double#) -> _!_ D# [] [u2] }; _NO_DEFLT_ } _N_ },
+ abs = { _A_ 1 _U_ 1 _N_ _S_ "U(P)" {_A_ 1 _U_ 2 _N_ _N_ _N_ _N_} _N_ _N_ },
+ signum = { _A_ 1 _U_ 1 _N_ _S_ "U(P)" {_A_ 1 _U_ 2 _N_ _N_ _N_ _N_} _N_ _N_ },
+ fromInteger = { _A_ 1 _U_ 1 _N_ _S_ "U(PPP)" {_A_ 3 _U_ 222 _N_ _N_ _F_ _IF_ARGS_ 0 3 XXX 3 \ (u0 :: Int#) (u1 :: Int#) (u2 :: ByteArray#) -> case _#_ encodeDouble# [] [u0, u1, u2, 0#] of { _PRIM_ (u3 :: Double#) -> _!_ D# [] [u3] } _N_} _F_ _IF_ARGS_ 0 1 C 4 \ (u0 :: Integer) -> case u0 of { _ALG_ J# (u1 :: Int#) (u2 :: Int#) (u3 :: ByteArray#) -> case _#_ encodeDouble# [] [u1, u2, u3, 0#] of { _PRIM_ (u4 :: Double#) -> _!_ D# [] [u4] }; _NO_DEFLT_ } _N_ },
+ fromInt = { _A_ 1 _U_ 1 _N_ _S_ "U(P)" {_A_ 1 _U_ 2 _N_ _N_ _F_ _IF_ARGS_ 0 1 X 3 \ (u0 :: Int#) -> case _#_ int2Double# [] [u0] of { _PRIM_ (u1 :: Double#) -> _!_ D# [] [u1] } _N_} _F_ _IF_ARGS_ 0 1 C 4 \ (u0 :: Int) -> case u0 of { _ALG_ I# (u1 :: Int#) -> case _#_ int2Double# [] [u1] of { _PRIM_ (u2 :: Double#) -> _!_ D# [] [u2] }; _NO_DEFLT_ } _N_ } #-}
instance Ord Double
{-# GHC_PRAGMA _M_ PreludeCore {-dfun-} _A_ 0 _N_ _N_ _N_ _F_ _IF_ARGS_ 0 0 X 9 _!_ _TUP_8 [{{Eq Double}}, (Double -> Double -> Bool), (Double -> Double -> Bool), (Double -> Double -> Bool), (Double -> Double -> Bool), (Double -> Double -> Double), (Double -> Double -> Double), (Double -> Double -> _CMP_TAG)] [_DFUN_ Eq (Double), _CONSTM_ Ord (<) (Double), _CONSTM_ Ord (<=) (Double), _CONSTM_ Ord (>=) (Double), _CONSTM_ Ord (>) (Double), _CONSTM_ Ord max (Double), _CONSTM_ Ord min (Double), _CONSTM_ Ord _tagCmp (Double)] _N_
- (<) = _A_ 2 _U_ 11 _N_ _S_ "U(P)U(P)" {_A_ 2 _U_ 22 _N_ _N_ _F_ _IF_ARGS_ 0 2 XX 1 \ (u0 :: Double#) (u1 :: Double#) -> _#_ ltDouble# [] [u0, u1] _N_} _F_ _IF_ARGS_ 0 2 CC 3 \ (u0 :: Double) (u1 :: Double) -> case u0 of { _ALG_ D# (u2 :: Double#) -> case u1 of { _ALG_ D# (u3 :: Double#) -> _#_ ltDouble# [] [u2, u3]; _NO_DEFLT_ }; _NO_DEFLT_ } _N_,
- (<=) = _A_ 2 _U_ 11 _N_ _S_ "U(P)U(P)" {_A_ 2 _U_ 22 _N_ _N_ _F_ _IF_ARGS_ 0 2 XX 1 \ (u0 :: Double#) (u1 :: Double#) -> _#_ leDouble# [] [u0, u1] _N_} _F_ _IF_ARGS_ 0 2 CC 3 \ (u0 :: Double) (u1 :: Double) -> case u0 of { _ALG_ D# (u2 :: Double#) -> case u1 of { _ALG_ D# (u3 :: Double#) -> _#_ leDouble# [] [u2, u3]; _NO_DEFLT_ }; _NO_DEFLT_ } _N_,
- (>=) = _A_ 2 _U_ 11 _N_ _S_ "U(P)U(P)" {_A_ 2 _U_ 22 _N_ _N_ _F_ _IF_ARGS_ 0 2 XX 1 \ (u0 :: Double#) (u1 :: Double#) -> _#_ geDouble# [] [u0, u1] _N_} _F_ _IF_ARGS_ 0 2 CC 3 \ (u0 :: Double) (u1 :: Double) -> case u0 of { _ALG_ D# (u2 :: Double#) -> case u1 of { _ALG_ D# (u3 :: Double#) -> _#_ geDouble# [] [u2, u3]; _NO_DEFLT_ }; _NO_DEFLT_ } _N_,
- (>) = _A_ 2 _U_ 11 _N_ _S_ "U(P)U(P)" {_A_ 2 _U_ 22 _N_ _N_ _F_ _IF_ARGS_ 0 2 XX 1 \ (u0 :: Double#) (u1 :: Double#) -> _#_ gtDouble# [] [u0, u1] _N_} _F_ _IF_ARGS_ 0 2 CC 3 \ (u0 :: Double) (u1 :: Double) -> case u0 of { _ALG_ D# (u2 :: Double#) -> case u1 of { _ALG_ D# (u3 :: Double#) -> _#_ gtDouble# [] [u2, u3]; _NO_DEFLT_ }; _NO_DEFLT_ } _N_,
- max = _A_ 2 _U_ 11 _N_ _S_ "U(P)U(P)" {_A_ 2 _U_ 22 _N_ _N_ _N_ _N_} _N_ _N_,
- min = _A_ 2 _U_ 11 _N_ _S_ "U(P)U(P)" {_A_ 2 _U_ 22 _N_ _N_ _N_ _N_} _N_ _N_,
- _tagCmp = _A_ 2 _U_ 11 _N_ _S_ "U(P)U(P)" {_A_ 2 _U_ 22 _N_ _N_ _N_ _N_} _N_ _N_ #-}
+ (<) = { _A_ 2 _U_ 11 _N_ _S_ "U(P)U(P)" {_A_ 2 _U_ 22 _N_ _N_ _F_ _IF_ARGS_ 0 2 XX 1 \ (u0 :: Double#) (u1 :: Double#) -> _#_ ltDouble# [] [u0, u1] _N_} _F_ _IF_ARGS_ 0 2 CC 3 \ (u0 :: Double) (u1 :: Double) -> case u0 of { _ALG_ D# (u2 :: Double#) -> case u1 of { _ALG_ D# (u3 :: Double#) -> _#_ ltDouble# [] [u2, u3]; _NO_DEFLT_ }; _NO_DEFLT_ } _N_ },
+ (<=) = { _A_ 2 _U_ 11 _N_ _S_ "U(P)U(P)" {_A_ 2 _U_ 22 _N_ _N_ _F_ _IF_ARGS_ 0 2 XX 1 \ (u0 :: Double#) (u1 :: Double#) -> _#_ leDouble# [] [u0, u1] _N_} _F_ _IF_ARGS_ 0 2 CC 3 \ (u0 :: Double) (u1 :: Double) -> case u0 of { _ALG_ D# (u2 :: Double#) -> case u1 of { _ALG_ D# (u3 :: Double#) -> _#_ leDouble# [] [u2, u3]; _NO_DEFLT_ }; _NO_DEFLT_ } _N_ },
+ (>=) = { _A_ 2 _U_ 11 _N_ _S_ "U(P)U(P)" {_A_ 2 _U_ 22 _N_ _N_ _F_ _IF_ARGS_ 0 2 XX 1 \ (u0 :: Double#) (u1 :: Double#) -> _#_ geDouble# [] [u0, u1] _N_} _F_ _IF_ARGS_ 0 2 CC 3 \ (u0 :: Double) (u1 :: Double) -> case u0 of { _ALG_ D# (u2 :: Double#) -> case u1 of { _ALG_ D# (u3 :: Double#) -> _#_ geDouble# [] [u2, u3]; _NO_DEFLT_ }; _NO_DEFLT_ } _N_ },
+ (>) = { _A_ 2 _U_ 11 _N_ _S_ "U(P)U(P)" {_A_ 2 _U_ 22 _N_ _N_ _F_ _IF_ARGS_ 0 2 XX 1 \ (u0 :: Double#) (u1 :: Double#) -> _#_ gtDouble# [] [u0, u1] _N_} _F_ _IF_ARGS_ 0 2 CC 3 \ (u0 :: Double) (u1 :: Double) -> case u0 of { _ALG_ D# (u2 :: Double#) -> case u1 of { _ALG_ D# (u3 :: Double#) -> _#_ gtDouble# [] [u2, u3]; _NO_DEFLT_ }; _NO_DEFLT_ } _N_ },
+ max = { _A_ 2 _U_ 11 _N_ _S_ "U(P)U(P)" {_A_ 2 _U_ 22 _N_ _N_ _N_ _N_} _N_ _N_ },
+ min = { _A_ 2 _U_ 11 _N_ _S_ "U(P)U(P)" {_A_ 2 _U_ 22 _N_ _N_ _N_ _N_} _N_ _N_ },
+ _tagCmp = { _A_ 2 _U_ 11 _N_ _S_ "U(P)U(P)" {_A_ 2 _U_ 22 _N_ _N_ _N_ _N_} _N_ _N_ } #-}
instance Real Double
{-# GHC_PRAGMA _M_ PreludeCore {-dfun-} _A_ 0 _N_ _N_ _N_ _F_ _IF_ARGS_ 0 0 X 4 _!_ _TUP_3 [{{Num Double}}, {{Enum Double}}, (Double -> Ratio Integer)] [_DFUN_ Num (Double), _DFUN_ Enum (Double), _CONSTM_ Real toRational (Double)] _N_
- toRational = _A_ 1 _U_ 1 _N_ _S_ "U(P)" {_A_ 1 _U_ 2 _N_ _N_ _N_ _N_} _N_ _N_ #-}
+ toRational = { _A_ 1 _U_ 1 _N_ _S_ "U(P)" {_A_ 1 _U_ 2 _N_ _N_ _N_ _N_} _N_ _N_ } #-}
instance RealFloat Double
{-# GHC_PRAGMA _M_ PreludeCore {-dfun-} _A_ 0 _N_ _N_ _N_ _F_ _IF_ARGS_ 0 0 X 11 _!_ _TUP_10 [{{RealFrac Double}}, {{Floating Double}}, (Double -> Integer), (Double -> Int), (Double -> (Int, Int)), (Double -> (Integer, Int)), (Integer -> Int -> Double), (Double -> Int), (Double -> Double), (Int -> Double -> Double)] [_DFUN_ RealFrac (Double), _DFUN_ Floating (Double), _CONSTM_ RealFloat floatRadix (Double), _CONSTM_ RealFloat floatDigits (Double), _CONSTM_ RealFloat floatRange (Double), _CONSTM_ RealFloat decodeFloat (Double), _CONSTM_ RealFloat encodeFloat (Double), _CONSTM_ RealFloat exponent (Double), _CONSTM_ RealFloat significand (Double), _CONSTM_ RealFloat scaleFloat (Double)] _N_
- floatRadix = _A_ 1 _U_ 0 _N_ _S_ "A" {_A_ 0 _N_ _N_ _N_ _F_ _IF_ARGS_ 0 0 X 1 _#_ int2Integer# [] [2#] _N_} _N_ _N_,
- floatDigits = _A_ 1 _U_ 0 _N_ _S_ "A" {_A_ 0 _N_ _N_ _N_ _F_ _IF_ARGS_ 0 0 X 2 _!_ I# [] [53#] _N_} _F_ _IF_ARGS_ 0 1 X 2 \ (u0 :: Double) -> _!_ I# [] [53#] _N_,
- floatRange = _A_ 1 _U_ 0 _N_ _S_ "A" {_A_ 0 _N_ _N_ _N_ _N_ _N_} _N_ _N_,
- decodeFloat = _A_ 1 _U_ 1 _N_ _S_ "U(P)" {_A_ 1 _U_ 2 _N_ _N_ _N_ _N_} _N_ _N_,
- encodeFloat = _A_ 2 _U_ 11 _N_ _S_ "U(PPP)U(P)" {_A_ 4 _U_ 2222 _N_ _N_ _F_ _IF_ARGS_ 0 4 XXXX 3 \ (u0 :: Int#) (u1 :: Int#) (u2 :: ByteArray#) (u3 :: Int#) -> case _#_ encodeDouble# [] [u0, u1, u2, u3] of { _PRIM_ (u4 :: Double#) -> _!_ D# [] [u4] } _N_} _F_ _IF_ARGS_ 0 2 CC 5 \ (u0 :: Integer) (u1 :: Int) -> case u0 of { _ALG_ J# (u2 :: Int#) (u3 :: Int#) (u4 :: ByteArray#) -> case u1 of { _ALG_ I# (u5 :: Int#) -> case _#_ encodeDouble# [] [u2, u3, u4, u5] of { _PRIM_ (u6 :: Double#) -> _!_ D# [] [u6] }; _NO_DEFLT_ }; _NO_DEFLT_ } _N_,
- exponent = _A_ 1 _U_ 2 _N_ _N_ _N_ _N_,
- significand = _A_ 1 _U_ 2 _N_ _N_ _N_ _N_,
- scaleFloat = _A_ 2 _U_ 22 _N_ _N_ _N_ _N_ #-}
+ floatRadix = { _A_ 1 _U_ 0 _N_ _S_ "A" {_A_ 0 _N_ _N_ _N_ _N_ _N_} _N_ _N_ },
+ floatDigits = { _A_ 1 _U_ 0 _N_ _S_ "A" {_A_ 0 _N_ _N_ _N_ _F_ _IF_ARGS_ 0 0 X 2 _!_ I# [] [53#] _N_} _F_ _IF_ARGS_ 0 1 X 2 \ (u0 :: Double) -> _!_ I# [] [53#] _N_ },
+ floatRange = { _A_ 1 _U_ 0 _N_ _S_ "A" {_A_ 0 _N_ _N_ _N_ _N_ _N_} _N_ _N_ },
+ decodeFloat = { _A_ 1 _U_ 1 _N_ _S_ "U(P)" {_A_ 1 _U_ 2 _N_ _N_ _N_ _N_} _N_ _N_ },
+ encodeFloat = { _A_ 2 _U_ 11 _N_ _S_ "U(PPP)U(P)" {_A_ 4 _U_ 2222 _N_ _N_ _F_ _IF_ARGS_ 0 4 XXXX 3 \ (u0 :: Int#) (u1 :: Int#) (u2 :: ByteArray#) (u3 :: Int#) -> case _#_ encodeDouble# [] [u0, u1, u2, u3] of { _PRIM_ (u4 :: Double#) -> _!_ D# [] [u4] } _N_} _F_ _IF_ARGS_ 0 2 CC 5 \ (u0 :: Integer) (u1 :: Int) -> case u0 of { _ALG_ J# (u2 :: Int#) (u3 :: Int#) (u4 :: ByteArray#) -> case u1 of { _ALG_ I# (u5 :: Int#) -> case _#_ encodeDouble# [] [u2, u3, u4, u5] of { _PRIM_ (u6 :: Double#) -> _!_ D# [] [u6] }; _NO_DEFLT_ }; _NO_DEFLT_ } _N_ },
+ exponent = { _A_ 1 _U_ 1 _N_ _S_ "U(P)" {_A_ 1 _U_ 2 _N_ _N_ _N_ _N_} _N_ _N_ },
+ significand = { _A_ 1 _U_ 1 _N_ _S_ "U(P)" {_A_ 1 _U_ 2 _N_ _N_ _N_ _N_} _N_ _N_ },
+ scaleFloat = { _A_ 2 _U_ 11 _N_ _S_ "U(P)U(P)" {_A_ 2 _U_ 22 _N_ _N_ _N_ _N_} _N_ _N_ } #-}
instance RealFrac Double
{-# GHC_PRAGMA _M_ PreludeCore {-dfun-} _A_ 0 _N_ _N_ _N_ _F_ _IF_ARGS_ 0 0 X 8 _!_ _TUP_7 [{{Real Double}}, {{Fractional Double}}, _forall_ a$z1 =>{{Integral a$z1}} -> (Double -> (a$z1, Double)), _forall_ a$z1 =>{{Integral a$z1}} -> (Double -> a$z1), _forall_ a$z1 =>{{Integral a$z1}} -> (Double -> a$z1), _forall_ a$z1 =>{{Integral a$z1}} -> (Double -> a$z1), _forall_ a$z1 =>{{Integral a$z1}} -> (Double -> a$z1)] [_DFUN_ Real (Double), _DFUN_ Fractional (Double), _CONSTM_ RealFrac properFraction (Double), _CONSTM_ RealFrac truncate (Double), _CONSTM_ RealFrac round (Double), _CONSTM_ RealFrac ceiling (Double), _CONSTM_ RealFrac floor (Double)] _N_
- properFraction = _A_ 1 _U_ 22 _N_ _N_ _N_ _N_,
- truncate = _A_ 1 _U_ 22 _N_ _N_ _N_ _N_,
- round = _A_ 1 _U_ 22 _N_ _N_ _N_ _N_,
- ceiling = _A_ 1 _U_ 22 _N_ _N_ _N_ _N_,
- floor = _A_ 1 _U_ 22 _N_ _N_ _N_ _N_ #-}
+ properFraction = { _A_ 1 _U_ 11 _N_ _N_ _N_ _SPECIALISE_ [ Int ] 1 { _A_ 1 _U_ 1 _N_ _S_ "U(P)" {_A_ 1 _U_ 2 _N_ _N_ _N_ _N_} _N_ _N_ }, [ Integer ] 1 { _A_ 1 _U_ 1 _N_ _S_ "U(P)" {_A_ 1 _U_ 2 _N_ _N_ _N_ _N_} _N_ _N_ } },
+ truncate = { _A_ 1 _U_ 11 _N_ _N_ _N_ _SPECIALISE_ [ Int ] 1 { _A_ 1 _U_ 1 _N_ _S_ "U(P)" {_A_ 1 _U_ 2 _N_ _N_ _F_ _IF_ARGS_ 0 1 X 4 \ (u0 :: Double#) -> case _APP_ _WRKR_ _SPEC_ _CONSTM_ RealFrac properFraction (Double) [ (Int) ] [ u0 ] of { _ALG_ _TUP_2 (u1 :: Int) (u2 :: Double) -> u1; _NO_DEFLT_ } _N_} _F_ _IF_ARGS_ 0 1 X 4 \ (u0 :: Double) -> case _APP_ _SPEC_ _CONSTM_ RealFrac properFraction (Double) [ (Int) ] [ u0 ] of { _ALG_ _TUP_2 (u1 :: Int) (u2 :: Double) -> u1; _NO_DEFLT_ } _N_ }, [ Integer ] 1 { _A_ 1 _U_ 1 _N_ _S_ "U(P)" {_A_ 1 _U_ 2 _N_ _N_ _F_ _IF_ARGS_ 0 1 X 4 \ (u0 :: Double#) -> case _APP_ _WRKR_ _SPEC_ _CONSTM_ RealFrac properFraction (Double) [ (Integer) ] [ u0 ] of { _ALG_ _TUP_2 (u1 :: Integer) (u2 :: Double) -> u1; _NO_DEFLT_ } _N_} _F_ _IF_ARGS_ 0 1 X 4 \ (u0 :: Double) -> case _APP_ _SPEC_ _CONSTM_ RealFrac properFraction (Double) [ (Integer) ] [ u0 ] of { _ALG_ _TUP_2 (u1 :: Integer) (u2 :: Double) -> u1; _NO_DEFLT_ } _N_ } },
+ round = { _A_ 1 _U_ 21 _N_ _N_ _N_ _SPECIALISE_ [ Int ] 1 { _A_ 1 _U_ 1 _N_ _S_ "U(P)" {_A_ 1 _U_ 2 _N_ _N_ _N_ _N_} _N_ _N_ }, [ Integer ] 1 { _A_ 1 _U_ 1 _N_ _S_ "U(P)" {_A_ 1 _U_ 2 _N_ _N_ _N_ _N_} _N_ _N_ } },
+ ceiling = { _A_ 1 _U_ 21 _N_ _N_ _N_ _SPECIALISE_ [ Int ] 1 { _A_ 1 _U_ 1 _N_ _S_ "U(P)" {_A_ 1 _U_ 2 _N_ _N_ _N_ _N_} _N_ _N_ }, [ Integer ] 1 { _A_ 1 _U_ 1 _N_ _S_ "U(P)" {_A_ 1 _U_ 2 _N_ _N_ _N_ _N_} _N_ _N_ } },
+ floor = { _A_ 1 _U_ 21 _N_ _N_ _N_ _SPECIALISE_ [ Int ] 1 { _A_ 1 _U_ 1 _N_ _S_ "U(P)" {_A_ 1 _U_ 2 _N_ _N_ _N_ _N_} _N_ _N_ }, [ Integer ] 1 { _A_ 1 _U_ 1 _N_ _S_ "U(P)" {_A_ 1 _U_ 2 _N_ _N_ _N_ _N_} _N_ _N_ } } #-}
instance Text Double
{-# GHC_PRAGMA _M_ PreludeCore {-dfun-} _A_ 0 _N_ _N_ _N_ _F_ _IF_ARGS_ 0 0 X 5 _!_ _TUP_4 [(Int -> [Char] -> [(Double, [Char])]), (Int -> Double -> [Char] -> [Char]), ([Char] -> [([Double], [Char])]), ([Double] -> [Char] -> [Char])] [_CONSTM_ Text readsPrec (Double), _CONSTM_ Text showsPrec (Double), _CONSTM_ Text readList (Double), _CONSTM_ Text showList (Double)] _N_
- readsPrec = _A_ 2 _U_ 02 _N_ _S_ "AL" {_A_ 1 _U_ 2 _N_ _N_ _F_ _IF_ARGS_ 0 1 X 3 \ (u0 :: [Char]) -> _APP_ _SPEC_ _ORIG_ PreludeText readSigned [ (Double) ] [ _SPEC_ _ORIG_ PreludeText readFloat [ (Double) ], u0 ] _N_} _F_ _IF_ARGS_ 0 2 XX 3 \ (u0 :: Int) (u1 :: [Char]) -> _APP_ _SPEC_ _ORIG_ PreludeText readSigned [ (Double) ] [ _SPEC_ _ORIG_ PreludeText readFloat [ (Double) ], u1 ] _N_,
- showsPrec = _A_ 2 _U_ 212 _N_ _S_ "LU(P)" {_A_ 2 _U_ 222 _N_ _N_ _F_ _IF_ARGS_ 0 2 XX 4 \ (u0 :: Int) (u1 :: Double#) -> _APP_ _WRKR_ _SPEC_ _ORIG_ PreludeText showSigned [ (Double) ] [ _SPEC_ _ORIG_ PreludeText showFloat [ (Double) ], u0, u1 ] _N_} _F_ _IF_ARGS_ 0 2 XC 5 \ (u0 :: Int) (u1 :: Double) -> case u1 of { _ALG_ D# (u2 :: Double#) -> _APP_ _WRKR_ _SPEC_ _ORIG_ PreludeText showSigned [ (Double) ] [ _SPEC_ _ORIG_ PreludeText showFloat [ (Double) ], u0, u2 ]; _NO_DEFLT_ } _N_,
- readList = _A_ 0 _U_ 2 _N_ _N_ _N_ _N_,
- showList = _A_ 0 _U_ 12 _N_ _N_ _N_ _N_ #-}
+ readsPrec = { _A_ 2 _U_ 02 _N_ _S_ "AL" {_A_ 1 _U_ 2 _N_ _N_ _F_ _IF_ARGS_ 0 1 X 3 \ (u0 :: [Char]) -> _APP_ _SPEC_ _ORIG_ PreludeText readSigned [ (Double) ] [ _SPEC_ _ORIG_ PreludeText readFloat [ (Double) ], u0 ] _N_} _F_ _IF_ARGS_ 0 2 XX 3 \ (u0 :: Int) (u1 :: [Char]) -> _APP_ _SPEC_ _ORIG_ PreludeText readSigned [ (Double) ] [ _SPEC_ _ORIG_ PreludeText readFloat [ (Double) ], u1 ] _N_ },
+ showsPrec = { _A_ 2 _U_ 212 _N_ _S_ "LU(P)" {_A_ 2 _U_ 222 _N_ _N_ _F_ _IF_ARGS_ 0 2 XX 4 \ (u0 :: Int) (u1 :: Double#) -> _APP_ _WRKR_ _SPEC_ _ORIG_ PreludeText showSigned [ (Double) ] [ _SPEC_ _ORIG_ PreludeText showFloat [ (Double) ], u0, u1 ] _N_} _F_ _IF_ARGS_ 0 2 XC 5 \ (u0 :: Int) (u1 :: Double) -> case u1 of { _ALG_ D# (u2 :: Double#) -> _APP_ _WRKR_ _SPEC_ _ORIG_ PreludeText showSigned [ (Double) ] [ _SPEC_ _ORIG_ PreludeText showFloat [ (Double) ], u0, u2 ]; _NO_DEFLT_ } _N_ },
+ readList = { _A_ 0 _U_ 2 _N_ _N_ _N_ _N_ },
+ showList = { _A_ 1 _U_ 12 _N_ _N_ _N_ _N_ } #-}
instance _CCallable Double
{-# GHC_PRAGMA _M_ PreludeCore {-dfun-} _A_ 0 _N_ _N_ _N_ _F_ _IF_ARGS_ 0 0 X 1 _!_ _TUP_0 [] [] _N_ #-}
instance _CReturnable Double
import IInt
import IInteger
import IRatio
-import List ( (++) )
+import List ( (++), map, takeWhile )
import Prel ( (^), (^^), otherwise )
import PS ( _PackedString, _unpackPS )
import Text
-import TyComplex -- for pragmas only
+import TyArray
+import TyComplex
-- definitions of the boxed PrimOps; these will be
-- used in the case of partial applications, etc.
(-) x y = minusDouble x y
negate x = negateDouble x
(*) x y = timesDouble x y
- abs x | x >= 0 = x
+ abs x | x >= 0.0 = x
| otherwise = negateDouble x
- signum x | x == 0 = 0
- | x > 0 = 1
+ signum x | x == 0.0 = 0
+ | x > 0.0 = 1
| otherwise = -1
fromInteger n = encodeFloat n 0
fromInt (I# n#) = case (int2Double# n#) of { d# -> D# d# }
instance Real Double where
- toRational x = (m%1)*(b%1)^^n -- i.e., realFloatToRational x
+ toRational x = (m%__i1)*(b%__i1)^^n
where (m,n) = decodeFloat x
b = floatRadix x
instance Fractional Double where
(/) x y = divideDouble x y
- fromRational x = fromRationalX x --ORIG: rationalToRealFloat x
- recip x = 1 / x
+ fromRational x = _fromRational x
+ recip x = 1.0 / x
instance Floating Double where
pi = 3.141592653589793238
(**) x y = powerDouble x y
logBase x y = log y / log x
-{- WAS: but not all machines have these in their math library:
- asinh = asinhDouble
- acosh = acoshDouble
- atanh = atanhDouble
--}
- asinh x = log (x + sqrt (1+x*x))
- acosh x = log (x + (x+1) * sqrt ((x-1)/(x+1)))
- atanh x = log ((x+1) / sqrt (1 - x*x))
-
+ asinh x = log (x + sqrt (1.0+x*x))
+ acosh x = log (x + (x+1.0) * sqrt ((x-1.0)/(x+1.0)))
+ atanh x = log ((x+1.0) / sqrt (1.0-x*x))
instance RealFrac Double where
- properFraction x = _properFraction x
-
- -- just call the versions in Core.hs
- truncate x = _truncate x
- round x = _round x
- ceiling x = _ceiling x
- floor x = _floor x
-{- OLD:
+
+ {-# SPECIALIZE properFraction :: Double -> (Int, Double) #-}
+ {-# SPECIALIZE truncate :: Double -> Int #-}
+ {-# SPECIALIZE round :: Double -> Int #-}
+ {-# SPECIALIZE ceiling :: Double -> Int #-}
+ {-# SPECIALIZE floor :: Double -> Int #-}
+
+ {-# SPECIALIZE properFraction :: Double -> (Integer, Double) #-}
+ {-# SPECIALIZE truncate :: Double -> Integer #-}
+ {-# SPECIALIZE round :: Double -> Integer #-}
+ {-# SPECIALIZE ceiling :: Double -> Integer #-}
+ {-# SPECIALIZE floor :: Double -> Integer #-}
+
+#if defined(__UNBOXED_INSTANCES__)
+ {-# SPECIALIZE properFraction :: Double -> (Int#, Double) #-}
+ {-# SPECIALIZE truncate :: Double -> Int# #-}
+ {-# SPECIALIZE round :: Double -> Int# #-}
+ {-# SPECIALIZE ceiling :: Double -> Int# #-}
+ {-# SPECIALIZE floor :: Double -> Int# #-}
+#endif
+
properFraction x
- | n >= 0 = (fromInteger m * fromInteger b ^ n, 0)
- | otherwise = (fromInteger w, encodeFloat r n)
- where (m,n) = decodeFloat x
- b = floatRadix x
- (w,r) = quotRem m (b^(-n))
--}
+ = case (decodeFloat x) of { (m,n) ->
+ let b = floatRadix x in
+ if n >= 0 then
+ (fromInteger m * fromInteger b ^ n, 0.0)
+ else
+ case (quotRem m (b^(-n))) of { (w,r) ->
+ (fromInteger w, encodeFloat r n)
+ }
+ }
+
+ truncate x = case properFraction x of
+ (n,_) -> n
+
+ round x = case properFraction x of
+ (n,r) -> let
+ m = if r < 0.0 then n - __i1 else n + __i1
+ half_down = abs r - 0.5
+ in
+ case (_tagCmp half_down 0.0) of
+ _LT -> n
+ _EQ -> if even n then n else m
+ _GT -> m
+
+ ceiling x = case properFraction x of
+ (n,r) -> if r > 0.0 then n + __i1 else n
+
+ floor x = case properFraction x of
+ (n,r) -> if r < 0.0 then n - __i1 else n
instance RealFloat Double where
floatRadix _ = FLT_RADIX -- from float.h
encodeFloat (J# a# s# d#) (I# e#)
= case encodeDouble# a# s# d# e# of { dbl# -> D# dbl# }
+ exponent x = case decodeFloat x of
+ (m,n) -> if m == __i0 then 0 else n + floatDigits x
+
+ significand x = case decodeFloat x of
+ (m,_) -> encodeFloat m (- (floatDigits x))
+
+ scaleFloat k x = case decodeFloat x of
+ (m,n) -> encodeFloat m (n+k)
+
instance Enum Double where
-{- *** RAW PRELUDE ***
- enumFrom = numericEnumFrom
- enumFromThen = numericEnumFromThen
--}
- enumFrom x = x : enumFrom (x `plusDouble` 1.0)
- enumFromThen m n = en' m (n `minusDouble` m)
- where en' m n = m : en' (m `plusDouble` n) n
+ enumFrom x = x : enumFrom (x `plusDouble` 1.0)
+ enumFromThen m n = en' m (n `minusDouble` m)
+ where en' m n = m : en' (m `plusDouble` n) n
+ enumFromTo n m = takeWhile (<= m) (enumFrom n)
+ enumFromThenTo n m p = takeWhile (if m >= n then (<= p) else (>= p))
+ (enumFromThen n m)
instance Text Double where
readsPrec p x = readSigned readFloat x
showsPrec x = showSigned showFloat x
+ readList = _readList (readsPrec 0)
+ showList = _showList (showsPrec 0)
instance _CCallable Double
instance _CReturnable Double
(-) x y = minusDouble# x y
negate x = negateDouble# x
(*) x y = timesDouble# x y
- abs x | x >= 0 = x
+ abs x | x >= 0.0 = x
| otherwise = negateDouble# x
- signum x | x == 0 = 0
- | x > 0 = 1
+ signum x | x == 0.0 = 0
+ | x > 0.0 = 1
| otherwise = -1
fromInteger n = encodeFloat n 0
fromInt (I# n#) = int2Double# n#
instance Real Double# where
- toRational x = (m%1)*(b%1)^^n -- i.e., realFloatToRational x
+ toRational x = (m%__i1)*(b%__i1)^^n
where (m,n) = decodeFloat x
b = floatRadix x
instance Fractional Double# where
(/) x y = divideDouble# x y
- fromRational x = _fromRational x --ORIG: rationalToRealFloat x
- recip x = 1 / x
+ fromRational x = _fromRational x
+ recip x = 1.0 / x
instance Floating Double# where
pi = 3.141592653589793238##
(**) x y = powerDouble# x y
logBase x y = log y / log x
-{- WAS: but not all machines have these in their math library:
- asinh = asinhDouble#
- acosh = acoshDouble#
- atanh = atanhDouble#
--}
- asinh x = log (x + sqrt (1+x*x))
- acosh x = log (x + (x+1) * sqrt ((x-1)/(x+1)))
- atanh x = log ((x+1) / sqrt (1 - x*x))
+ asinh x = log (x + sqrt (1.0+x*x))
+ acosh x = log (x + (x+1) * sqrt ((x-1.0)/(x+1.0)))
+ atanh x = log ((x+1.0) / sqrt (1.0-x*x))
instance RealFrac Double# where
- -- REPORT:
- -- properFraction = floatProperFraction
+
+ {-# SPECIALIZE properFraction :: Double# -> (Int, Double#) #-}
+ {-# SPECIALIZE truncate :: Double# -> Int #-}
+ {-# SPECIALIZE round :: Double# -> Int #-}
+ {-# SPECIALIZE ceiling :: Double# -> Int #-}
+ {-# SPECIALIZE floor :: Double# -> Int #-}
+
+ {-# SPECIALIZE properFraction :: Double# -> (Integer, Double#) #-}
+ {-# SPECIALIZE truncate :: Double# -> Integer #-}
+ {-# SPECIALIZE round :: Double# -> Integer #-}
+ {-# SPECIALIZE ceiling :: Double# -> Integer #-}
+ {-# SPECIALIZE floor :: Double# -> Integer #-}
+
+ {-# SPECIALIZE properFraction :: Double# -> (Int#, Double#) #-}
+ {-# SPECIALIZE truncate :: Double# -> Int# #-}
+ {-# SPECIALIZE round :: Double# -> Int# #-}
+ {-# SPECIALIZE ceiling :: Double# -> Int# #-}
+ {-# SPECIALIZE floor :: Double# -> Int# #-}
properFraction x
- | n >= 0 = (fromInteger m * fromInteger b ^ n, 0)
- | otherwise = (fromInteger w, encodeFloat r n)
- where (m,n) = decodeFloat x
- b = floatRadix x
- (w,r) = quotRem m (b^(-n))
-
- -- No default methods for unboxed values ...
- -- just call the versions in Core.hs
- truncate x = _truncate x
- round x = _round x
- ceiling x = _ceiling x
- floor x = _floor x
+ = case (decodeFloat x) of { (m,n) ->
+ let b = floatRadix x in
+ if n >= 0 then
+ (fromInteger m * fromInteger b ^ n, 0.0)
+ else
+ case (quotRem m (b^(-n))) of { (w,r) ->
+ (fromInteger w, encodeFloat r n)
+ }
+ }
+
+ truncate x = case properFraction x of
+ (n,_) -> n
+
+ round x = case properFraction x of
+ (n,r) -> let
+ m = if r < 0.0 then n - __i1 else n + __i1
+ half_down = abs r - 0.5
+ in
+ case (_tagCmp half_down 0.0) of
+ _LT -> n
+ _EQ -> if even n then n else m
+ _GT -> m
+
+ ceiling x = case properFraction x of
+ (n,r) -> if r > 0.0 then n + __i1 else n
+
+ floor x = case properFraction x of
+ (n,r) -> if r < 0.0 then n - __i1 else n
+
instance RealFloat Double# where
floatRadix _ = FLT_RADIX -- from float.h
encodeFloat (J# a# s# d#) (I# e#)
= encodeDouble# a# s# d# e#
- -- No default methods for unboxed values ...
- exponent x = if m == 0 then 0 else n + floatDigits x
- where (m,n) = decodeFloat x
+ exponent x = case decodeFloat x of
+ (m,n) -> if m == __i0 then 0 else n + floatDigits x
- significand x = encodeFloat m (- (floatDigits x))
- where (m,_) = decodeFloat x
+ significand x = case decodeFloat x of
+ (m,_) -> encodeFloat m (- (floatDigits x))
- scaleFloat k x = encodeFloat m (n+k)
- where (m,n) = decodeFloat x
+ scaleFloat k x = case decodeFloat x of
+ (m,n) -> encodeFloat m (n+k)
instance Enum Double# where
- enumFrom x = x : enumFrom (x `plusDouble#` 1.0##)
+ enumFrom x = x : enumFrom (x `plusDouble#` 1.0)
enumFromThen m n = en' m (n `minusDouble#` m)
where en' m n = m : en' (m `plusDouble#` n) n
- -- default methods not specialised!
enumFromTo n m = takeWhile (<= m) (enumFrom n)
enumFromThenTo n m p = takeWhile (if m >= n then (<= p) else (>= p))
(enumFromThen n m)
instance Text Double# where
readsPrec p s = map (\ (D# d#, s) -> (d#, s)) (readsPrec p s)
showsPrec p x = showsPrec p (D# x)
- readList s = map (\ (x, s) -> (map (\ (D# d#) -> d#) x, s)) (readList s)
- showList l = showList (map D# l)
+ readList = _readList (readsPrec 0)
+ showList = _showList (showsPrec 0)
instance _CCallable Double#
instance _CReturnable Double#
-{-# GHC_PRAGMA INTERFACE VERSION 5 #-}
+{-# GHC_PRAGMA INTERFACE VERSION 6 #-}
interface PreludeCore where
import PreludeBuiltin(Double(..))
instance Enum Double
{-# GHC_PRAGMA _M_ PreludeCore {-dfun-} _A_ 0 _N_ _N_ _N_ _F_ _IF_ARGS_ 0 0 X 6 _!_ _TUP_5 [{{Ord Double}}, (Double -> [Double]), (Double -> Double -> [Double]), (Double -> Double -> [Double]), (Double -> Double -> Double -> [Double])] [_DFUN_ Ord (Double), _CONSTM_ Enum enumFrom (Double), _CONSTM_ Enum enumFromThen (Double), _CONSTM_ Enum enumFromTo (Double), _CONSTM_ Enum enumFromThenTo (Double)] _N_
- enumFrom = _A_ 1 _U_ 2 _N_ _N_ _N_ _N_,
- enumFromThen = _A_ 2 _U_ 21 _N_ _N_ _N_ _N_,
- enumFromTo = _A_ 2 _U_ 22 _N_ _N_ _N_ _N_,
- enumFromThenTo = _A_ 3 _U_ 222 _N_ _N_ _N_ _N_ #-}
+ enumFrom = { _A_ 1 _U_ 2 _N_ _N_ _N_ _N_ },
+ enumFromThen = { _A_ 2 _U_ 21 _N_ _N_ _N_ _N_ },
+ enumFromTo = { _A_ 2 _U_ 22 _N_ _N_ _N_ _N_ },
+ enumFromThenTo = { _A_ 3 _U_ 222 _N_ _N_ _N_ _N_ } #-}
instance Eq Double
{-# GHC_PRAGMA _M_ PreludeCore {-dfun-} _A_ 0 _N_ _N_ _N_ _F_ _IF_ARGS_ 0 0 X 3 _!_ _TUP_2 [(Double -> Double -> Bool), (Double -> Double -> Bool)] [_CONSTM_ Eq (==) (Double), _CONSTM_ Eq (/=) (Double)] _N_
- (==) = _A_ 2 _U_ 11 _N_ _S_ "U(P)U(P)" {_A_ 2 _U_ 22 _N_ _N_ _F_ _IF_ARGS_ 0 2 XX 1 \ (u0 :: Double#) (u1 :: Double#) -> _#_ eqDouble# [] [u0, u1] _N_} _F_ _IF_ARGS_ 0 2 CC 3 \ (u0 :: Double) (u1 :: Double) -> case u0 of { _ALG_ D# (u2 :: Double#) -> case u1 of { _ALG_ D# (u3 :: Double#) -> _#_ eqDouble# [] [u2, u3]; _NO_DEFLT_ }; _NO_DEFLT_ } _N_,
- (/=) = _A_ 2 _U_ 11 _N_ _S_ "U(P)U(P)" {_A_ 2 _U_ 22 _N_ _N_ _F_ _IF_ARGS_ 0 2 XX 1 \ (u0 :: Double#) (u1 :: Double#) -> _#_ neDouble# [] [u0, u1] _N_} _F_ _IF_ARGS_ 0 2 CC 3 \ (u0 :: Double) (u1 :: Double) -> case u0 of { _ALG_ D# (u2 :: Double#) -> case u1 of { _ALG_ D# (u3 :: Double#) -> _#_ neDouble# [] [u2, u3]; _NO_DEFLT_ }; _NO_DEFLT_ } _N_ #-}
+ (==) = { _A_ 2 _U_ 11 _N_ _S_ "U(P)U(P)" {_A_ 2 _U_ 22 _N_ _N_ _F_ _IF_ARGS_ 0 2 XX 1 \ (u0 :: Double#) (u1 :: Double#) -> _#_ eqDouble# [] [u0, u1] _N_} _F_ _IF_ARGS_ 0 2 CC 3 \ (u0 :: Double) (u1 :: Double) -> case u0 of { _ALG_ D# (u2 :: Double#) -> case u1 of { _ALG_ D# (u3 :: Double#) -> _#_ eqDouble# [] [u2, u3]; _NO_DEFLT_ }; _NO_DEFLT_ } _N_ },
+ (/=) = { _A_ 2 _U_ 11 _N_ _S_ "U(P)U(P)" {_A_ 2 _U_ 22 _N_ _N_ _F_ _IF_ARGS_ 0 2 XX 1 \ (u0 :: Double#) (u1 :: Double#) -> _#_ neDouble# [] [u0, u1] _N_} _F_ _IF_ARGS_ 0 2 CC 3 \ (u0 :: Double) (u1 :: Double) -> case u0 of { _ALG_ D# (u2 :: Double#) -> case u1 of { _ALG_ D# (u3 :: Double#) -> _#_ neDouble# [] [u2, u3]; _NO_DEFLT_ }; _NO_DEFLT_ } _N_ } #-}
instance Floating Double
{-# GHC_PRAGMA _M_ PreludeCore {-dfun-} _A_ 0 _N_ _N_ _N_ _F_ _IF_ARGS_ 0 0 X 20 _!_ _TUP_19 [{{Fractional Double}}, Double, (Double -> Double), (Double -> Double), (Double -> Double), (Double -> Double -> Double), (Double -> Double -> Double), (Double -> Double), (Double -> Double), (Double -> Double), (Double -> Double), (Double -> Double), (Double -> Double), (Double -> Double), (Double -> Double), (Double -> Double), (Double -> Double), (Double -> Double), (Double -> Double)] [_DFUN_ Fractional (Double), _CONSTM_ Floating pi (Double), _CONSTM_ Floating exp (Double), _CONSTM_ Floating log (Double), _CONSTM_ Floating sqrt (Double), _CONSTM_ Floating (**) (Double), _CONSTM_ Floating logBase (Double), _CONSTM_ Floating sin (Double), _CONSTM_ Floating cos (Double), _CONSTM_ Floating tan (Double), _CONSTM_ Floating asin (Double), _CONSTM_ Floating acos (Double), _CONSTM_ Floating atan (Double), _CONSTM_ Floating sinh (Double), _CONSTM_ Floating cosh (Double), _CONSTM_ Floating tanh (Double), _CONSTM_ Floating asinh (Double), _CONSTM_ Floating acosh (Double), _CONSTM_ Floating atanh (Double)] _N_
- pi = _A_ 0 _N_ _N_ _N_ _F_ _IF_ARGS_ 0 0 X 2 _!_ D# [] [3.1415926535897931##] _N_,
- exp = _A_ 1 _U_ 1 _N_ _S_ "U(P)" {_A_ 1 _U_ 2 _N_ _N_ _F_ _IF_ARGS_ 0 1 X 3 \ (u0 :: Double#) -> case _#_ expDouble# [] [u0] of { _PRIM_ (u1 :: Double#) -> _!_ D# [] [u1] } _N_} _F_ _IF_ARGS_ 0 1 C 4 \ (u0 :: Double) -> case u0 of { _ALG_ D# (u1 :: Double#) -> case _#_ expDouble# [] [u1] of { _PRIM_ (u2 :: Double#) -> _!_ D# [] [u2] }; _NO_DEFLT_ } _N_,
- log = _A_ 1 _U_ 1 _N_ _S_ "U(P)" {_A_ 1 _U_ 2 _N_ _N_ _F_ _IF_ARGS_ 0 1 X 3 \ (u0 :: Double#) -> case _#_ logDouble# [] [u0] of { _PRIM_ (u1 :: Double#) -> _!_ D# [] [u1] } _N_} _F_ _IF_ARGS_ 0 1 C 4 \ (u0 :: Double) -> case u0 of { _ALG_ D# (u1 :: Double#) -> case _#_ logDouble# [] [u1] of { _PRIM_ (u2 :: Double#) -> _!_ D# [] [u2] }; _NO_DEFLT_ } _N_,
- sqrt = _A_ 1 _U_ 1 _N_ _S_ "U(P)" {_A_ 1 _U_ 2 _N_ _N_ _F_ _IF_ARGS_ 0 1 X 3 \ (u0 :: Double#) -> case _#_ sqrtDouble# [] [u0] of { _PRIM_ (u1 :: Double#) -> _!_ D# [] [u1] } _N_} _F_ _IF_ARGS_ 0 1 C 4 \ (u0 :: Double) -> case u0 of { _ALG_ D# (u1 :: Double#) -> case _#_ sqrtDouble# [] [u1] of { _PRIM_ (u2 :: Double#) -> _!_ D# [] [u2] }; _NO_DEFLT_ } _N_,
- (**) = _A_ 2 _U_ 11 _N_ _S_ "U(P)U(P)" {_A_ 2 _U_ 22 _N_ _N_ _F_ _IF_ARGS_ 0 2 XX 3 \ (u0 :: Double#) (u1 :: Double#) -> case _#_ powerDouble# [] [u0, u1] of { _PRIM_ (u2 :: Double#) -> _!_ D# [] [u2] } _N_} _F_ _IF_ARGS_ 0 2 CC 5 \ (u0 :: Double) (u1 :: Double) -> case u0 of { _ALG_ D# (u2 :: Double#) -> case u1 of { _ALG_ D# (u3 :: Double#) -> case _#_ powerDouble# [] [u2, u3] of { _PRIM_ (u4 :: Double#) -> _!_ D# [] [u4] }; _NO_DEFLT_ }; _NO_DEFLT_ } _N_,
- logBase = _A_ 2 _U_ 11 _N_ _S_ "U(P)U(P)" {_A_ 2 _U_ 22 _N_ _N_ _F_ _IF_ARGS_ 0 2 XX 5 \ (u0 :: Double#) (u1 :: Double#) -> case _#_ logDouble# [] [u1] of { _PRIM_ (u2 :: Double#) -> case _#_ logDouble# [] [u0] of { _PRIM_ (u3 :: Double#) -> case _#_ divideDouble# [] [u2, u3] of { _PRIM_ (u4 :: Double#) -> _!_ D# [] [u4] } } } _N_} _F_ _IF_ARGS_ 0 2 CC 7 \ (u0 :: Double) (u1 :: Double) -> case u1 of { _ALG_ D# (u2 :: Double#) -> case _#_ logDouble# [] [u2] of { _PRIM_ (u3 :: Double#) -> case u0 of { _ALG_ D# (u4 :: Double#) -> case _#_ logDouble# [] [u4] of { _PRIM_ (u5 :: Double#) -> case _#_ divideDouble# [] [u3, u5] of { _PRIM_ (u6 :: Double#) -> _!_ D# [] [u6] } }; _NO_DEFLT_ } }; _NO_DEFLT_ } _N_,
- sin = _A_ 1 _U_ 1 _N_ _S_ "U(P)" {_A_ 1 _U_ 2 _N_ _N_ _F_ _IF_ARGS_ 0 1 X 3 \ (u0 :: Double#) -> case _#_ sinDouble# [] [u0] of { _PRIM_ (u1 :: Double#) -> _!_ D# [] [u1] } _N_} _F_ _IF_ARGS_ 0 1 C 4 \ (u0 :: Double) -> case u0 of { _ALG_ D# (u1 :: Double#) -> case _#_ sinDouble# [] [u1] of { _PRIM_ (u2 :: Double#) -> _!_ D# [] [u2] }; _NO_DEFLT_ } _N_,
- cos = _A_ 1 _U_ 1 _N_ _S_ "U(P)" {_A_ 1 _U_ 2 _N_ _N_ _F_ _IF_ARGS_ 0 1 X 3 \ (u0 :: Double#) -> case _#_ cosDouble# [] [u0] of { _PRIM_ (u1 :: Double#) -> _!_ D# [] [u1] } _N_} _F_ _IF_ARGS_ 0 1 C 4 \ (u0 :: Double) -> case u0 of { _ALG_ D# (u1 :: Double#) -> case _#_ cosDouble# [] [u1] of { _PRIM_ (u2 :: Double#) -> _!_ D# [] [u2] }; _NO_DEFLT_ } _N_,
- tan = _A_ 1 _U_ 1 _N_ _S_ "U(P)" {_A_ 1 _U_ 2 _N_ _N_ _F_ _IF_ARGS_ 0 1 X 3 \ (u0 :: Double#) -> case _#_ tanDouble# [] [u0] of { _PRIM_ (u1 :: Double#) -> _!_ D# [] [u1] } _N_} _F_ _IF_ARGS_ 0 1 C 4 \ (u0 :: Double) -> case u0 of { _ALG_ D# (u1 :: Double#) -> case _#_ tanDouble# [] [u1] of { _PRIM_ (u2 :: Double#) -> _!_ D# [] [u2] }; _NO_DEFLT_ } _N_,
- asin = _A_ 1 _U_ 1 _N_ _S_ "U(P)" {_A_ 1 _U_ 2 _N_ _N_ _F_ _IF_ARGS_ 0 1 X 3 \ (u0 :: Double#) -> case _#_ asinDouble# [] [u0] of { _PRIM_ (u1 :: Double#) -> _!_ D# [] [u1] } _N_} _F_ _IF_ARGS_ 0 1 C 4 \ (u0 :: Double) -> case u0 of { _ALG_ D# (u1 :: Double#) -> case _#_ asinDouble# [] [u1] of { _PRIM_ (u2 :: Double#) -> _!_ D# [] [u2] }; _NO_DEFLT_ } _N_,
- acos = _A_ 1 _U_ 1 _N_ _S_ "U(P)" {_A_ 1 _U_ 2 _N_ _N_ _F_ _IF_ARGS_ 0 1 X 3 \ (u0 :: Double#) -> case _#_ acosDouble# [] [u0] of { _PRIM_ (u1 :: Double#) -> _!_ D# [] [u1] } _N_} _F_ _IF_ARGS_ 0 1 C 4 \ (u0 :: Double) -> case u0 of { _ALG_ D# (u1 :: Double#) -> case _#_ acosDouble# [] [u1] of { _PRIM_ (u2 :: Double#) -> _!_ D# [] [u2] }; _NO_DEFLT_ } _N_,
- atan = _A_ 1 _U_ 1 _N_ _S_ "U(P)" {_A_ 1 _U_ 2 _N_ _N_ _F_ _IF_ARGS_ 0 1 X 3 \ (u0 :: Double#) -> case _#_ atanDouble# [] [u0] of { _PRIM_ (u1 :: Double#) -> _!_ D# [] [u1] } _N_} _F_ _IF_ARGS_ 0 1 C 4 \ (u0 :: Double) -> case u0 of { _ALG_ D# (u1 :: Double#) -> case _#_ atanDouble# [] [u1] of { _PRIM_ (u2 :: Double#) -> _!_ D# [] [u2] }; _NO_DEFLT_ } _N_,
- sinh = _A_ 1 _U_ 1 _N_ _S_ "U(P)" {_A_ 1 _U_ 2 _N_ _N_ _F_ _IF_ARGS_ 0 1 X 3 \ (u0 :: Double#) -> case _#_ sinhDouble# [] [u0] of { _PRIM_ (u1 :: Double#) -> _!_ D# [] [u1] } _N_} _F_ _IF_ARGS_ 0 1 C 4 \ (u0 :: Double) -> case u0 of { _ALG_ D# (u1 :: Double#) -> case _#_ sinhDouble# [] [u1] of { _PRIM_ (u2 :: Double#) -> _!_ D# [] [u2] }; _NO_DEFLT_ } _N_,
- cosh = _A_ 1 _U_ 1 _N_ _S_ "U(P)" {_A_ 1 _U_ 2 _N_ _N_ _F_ _IF_ARGS_ 0 1 X 3 \ (u0 :: Double#) -> case _#_ coshDouble# [] [u0] of { _PRIM_ (u1 :: Double#) -> _!_ D# [] [u1] } _N_} _F_ _IF_ARGS_ 0 1 C 4 \ (u0 :: Double) -> case u0 of { _ALG_ D# (u1 :: Double#) -> case _#_ coshDouble# [] [u1] of { _PRIM_ (u2 :: Double#) -> _!_ D# [] [u2] }; _NO_DEFLT_ } _N_,
- tanh = _A_ 1 _U_ 1 _N_ _S_ "U(P)" {_A_ 1 _U_ 2 _N_ _N_ _F_ _IF_ARGS_ 0 1 X 3 \ (u0 :: Double#) -> case _#_ tanhDouble# [] [u0] of { _PRIM_ (u1 :: Double#) -> _!_ D# [] [u1] } _N_} _F_ _IF_ARGS_ 0 1 C 4 \ (u0 :: Double) -> case u0 of { _ALG_ D# (u1 :: Double#) -> case _#_ tanhDouble# [] [u1] of { _PRIM_ (u2 :: Double#) -> _!_ D# [] [u2] }; _NO_DEFLT_ } _N_,
- asinh = _A_ 1 _U_ 1 _N_ _S_ "U(P)" {_A_ 1 _U_ 2 _N_ _N_ _N_ _N_} _N_ _N_,
- acosh = _A_ 1 _U_ 1 _N_ _S_ "U(P)" {_A_ 1 _U_ 2 _N_ _N_ _N_ _N_} _N_ _N_,
- atanh = _A_ 1 _U_ 1 _N_ _S_ "U(P)" {_A_ 1 _U_ 2 _N_ _N_ _N_ _N_} _N_ _N_ #-}
+ pi = { _A_ 0 _N_ _N_ _N_ _F_ _IF_ARGS_ 0 0 X 2 _!_ D# [] [3.1415926535897931##] _N_ },
+ exp = { _A_ 1 _U_ 1 _N_ _S_ "U(P)" {_A_ 1 _U_ 2 _N_ _N_ _F_ _IF_ARGS_ 0 1 X 3 \ (u0 :: Double#) -> case _#_ expDouble# [] [u0] of { _PRIM_ (u1 :: Double#) -> _!_ D# [] [u1] } _N_} _F_ _IF_ARGS_ 0 1 C 4 \ (u0 :: Double) -> case u0 of { _ALG_ D# (u1 :: Double#) -> case _#_ expDouble# [] [u1] of { _PRIM_ (u2 :: Double#) -> _!_ D# [] [u2] }; _NO_DEFLT_ } _N_ },
+ log = { _A_ 1 _U_ 1 _N_ _S_ "U(P)" {_A_ 1 _U_ 2 _N_ _N_ _F_ _IF_ARGS_ 0 1 X 3 \ (u0 :: Double#) -> case _#_ logDouble# [] [u0] of { _PRIM_ (u1 :: Double#) -> _!_ D# [] [u1] } _N_} _F_ _IF_ARGS_ 0 1 C 4 \ (u0 :: Double) -> case u0 of { _ALG_ D# (u1 :: Double#) -> case _#_ logDouble# [] [u1] of { _PRIM_ (u2 :: Double#) -> _!_ D# [] [u2] }; _NO_DEFLT_ } _N_ },
+ sqrt = { _A_ 1 _U_ 1 _N_ _S_ "U(P)" {_A_ 1 _U_ 2 _N_ _N_ _F_ _IF_ARGS_ 0 1 X 3 \ (u0 :: Double#) -> case _#_ sqrtDouble# [] [u0] of { _PRIM_ (u1 :: Double#) -> _!_ D# [] [u1] } _N_} _F_ _IF_ARGS_ 0 1 C 4 \ (u0 :: Double) -> case u0 of { _ALG_ D# (u1 :: Double#) -> case _#_ sqrtDouble# [] [u1] of { _PRIM_ (u2 :: Double#) -> _!_ D# [] [u2] }; _NO_DEFLT_ } _N_ },
+ (**) = { _A_ 2 _U_ 11 _N_ _S_ "U(P)U(P)" {_A_ 2 _U_ 22 _N_ _N_ _F_ _IF_ARGS_ 0 2 XX 3 \ (u0 :: Double#) (u1 :: Double#) -> case _#_ powerDouble# [] [u0, u1] of { _PRIM_ (u2 :: Double#) -> _!_ D# [] [u2] } _N_} _F_ _IF_ARGS_ 0 2 CC 5 \ (u0 :: Double) (u1 :: Double) -> case u0 of { _ALG_ D# (u2 :: Double#) -> case u1 of { _ALG_ D# (u3 :: Double#) -> case _#_ powerDouble# [] [u2, u3] of { _PRIM_ (u4 :: Double#) -> _!_ D# [] [u4] }; _NO_DEFLT_ }; _NO_DEFLT_ } _N_ },
+ logBase = { _A_ 2 _U_ 11 _N_ _S_ "U(P)U(P)" {_A_ 2 _U_ 22 _N_ _N_ _F_ _IF_ARGS_ 0 2 XX 5 \ (u0 :: Double#) (u1 :: Double#) -> case _#_ logDouble# [] [u1] of { _PRIM_ (u2 :: Double#) -> case _#_ logDouble# [] [u0] of { _PRIM_ (u3 :: Double#) -> case _#_ divideDouble# [] [u2, u3] of { _PRIM_ (u4 :: Double#) -> _!_ D# [] [u4] } } } _N_} _F_ _IF_ARGS_ 0 2 CC 7 \ (u0 :: Double) (u1 :: Double) -> case u1 of { _ALG_ D# (u2 :: Double#) -> case _#_ logDouble# [] [u2] of { _PRIM_ (u3 :: Double#) -> case u0 of { _ALG_ D# (u4 :: Double#) -> case _#_ logDouble# [] [u4] of { _PRIM_ (u5 :: Double#) -> case _#_ divideDouble# [] [u3, u5] of { _PRIM_ (u6 :: Double#) -> _!_ D# [] [u6] } }; _NO_DEFLT_ } }; _NO_DEFLT_ } _N_ },
+ sin = { _A_ 1 _U_ 1 _N_ _S_ "U(P)" {_A_ 1 _U_ 2 _N_ _N_ _F_ _IF_ARGS_ 0 1 X 3 \ (u0 :: Double#) -> case _#_ sinDouble# [] [u0] of { _PRIM_ (u1 :: Double#) -> _!_ D# [] [u1] } _N_} _F_ _IF_ARGS_ 0 1 C 4 \ (u0 :: Double) -> case u0 of { _ALG_ D# (u1 :: Double#) -> case _#_ sinDouble# [] [u1] of { _PRIM_ (u2 :: Double#) -> _!_ D# [] [u2] }; _NO_DEFLT_ } _N_ },
+ cos = { _A_ 1 _U_ 1 _N_ _S_ "U(P)" {_A_ 1 _U_ 2 _N_ _N_ _F_ _IF_ARGS_ 0 1 X 3 \ (u0 :: Double#) -> case _#_ cosDouble# [] [u0] of { _PRIM_ (u1 :: Double#) -> _!_ D# [] [u1] } _N_} _F_ _IF_ARGS_ 0 1 C 4 \ (u0 :: Double) -> case u0 of { _ALG_ D# (u1 :: Double#) -> case _#_ cosDouble# [] [u1] of { _PRIM_ (u2 :: Double#) -> _!_ D# [] [u2] }; _NO_DEFLT_ } _N_ },
+ tan = { _A_ 1 _U_ 1 _N_ _S_ "U(P)" {_A_ 1 _U_ 2 _N_ _N_ _F_ _IF_ARGS_ 0 1 X 3 \ (u0 :: Double#) -> case _#_ tanDouble# [] [u0] of { _PRIM_ (u1 :: Double#) -> _!_ D# [] [u1] } _N_} _F_ _IF_ARGS_ 0 1 C 4 \ (u0 :: Double) -> case u0 of { _ALG_ D# (u1 :: Double#) -> case _#_ tanDouble# [] [u1] of { _PRIM_ (u2 :: Double#) -> _!_ D# [] [u2] }; _NO_DEFLT_ } _N_ },
+ asin = { _A_ 1 _U_ 1 _N_ _S_ "U(P)" {_A_ 1 _U_ 2 _N_ _N_ _F_ _IF_ARGS_ 0 1 X 3 \ (u0 :: Double#) -> case _#_ asinDouble# [] [u0] of { _PRIM_ (u1 :: Double#) -> _!_ D# [] [u1] } _N_} _F_ _IF_ARGS_ 0 1 C 4 \ (u0 :: Double) -> case u0 of { _ALG_ D# (u1 :: Double#) -> case _#_ asinDouble# [] [u1] of { _PRIM_ (u2 :: Double#) -> _!_ D# [] [u2] }; _NO_DEFLT_ } _N_ },
+ acos = { _A_ 1 _U_ 1 _N_ _S_ "U(P)" {_A_ 1 _U_ 2 _N_ _N_ _F_ _IF_ARGS_ 0 1 X 3 \ (u0 :: Double#) -> case _#_ acosDouble# [] [u0] of { _PRIM_ (u1 :: Double#) -> _!_ D# [] [u1] } _N_} _F_ _IF_ARGS_ 0 1 C 4 \ (u0 :: Double) -> case u0 of { _ALG_ D# (u1 :: Double#) -> case _#_ acosDouble# [] [u1] of { _PRIM_ (u2 :: Double#) -> _!_ D# [] [u2] }; _NO_DEFLT_ } _N_ },
+ atan = { _A_ 1 _U_ 1 _N_ _S_ "U(P)" {_A_ 1 _U_ 2 _N_ _N_ _F_ _IF_ARGS_ 0 1 X 3 \ (u0 :: Double#) -> case _#_ atanDouble# [] [u0] of { _PRIM_ (u1 :: Double#) -> _!_ D# [] [u1] } _N_} _F_ _IF_ARGS_ 0 1 C 4 \ (u0 :: Double) -> case u0 of { _ALG_ D# (u1 :: Double#) -> case _#_ atanDouble# [] [u1] of { _PRIM_ (u2 :: Double#) -> _!_ D# [] [u2] }; _NO_DEFLT_ } _N_ },
+ sinh = { _A_ 1 _U_ 1 _N_ _S_ "U(P)" {_A_ 1 _U_ 2 _N_ _N_ _F_ _IF_ARGS_ 0 1 X 3 \ (u0 :: Double#) -> case _#_ sinhDouble# [] [u0] of { _PRIM_ (u1 :: Double#) -> _!_ D# [] [u1] } _N_} _F_ _IF_ARGS_ 0 1 C 4 \ (u0 :: Double) -> case u0 of { _ALG_ D# (u1 :: Double#) -> case _#_ sinhDouble# [] [u1] of { _PRIM_ (u2 :: Double#) -> _!_ D# [] [u2] }; _NO_DEFLT_ } _N_ },
+ cosh = { _A_ 1 _U_ 1 _N_ _S_ "U(P)" {_A_ 1 _U_ 2 _N_ _N_ _F_ _IF_ARGS_ 0 1 X 3 \ (u0 :: Double#) -> case _#_ coshDouble# [] [u0] of { _PRIM_ (u1 :: Double#) -> _!_ D# [] [u1] } _N_} _F_ _IF_ARGS_ 0 1 C 4 \ (u0 :: Double) -> case u0 of { _ALG_ D# (u1 :: Double#) -> case _#_ coshDouble# [] [u1] of { _PRIM_ (u2 :: Double#) -> _!_ D# [] [u2] }; _NO_DEFLT_ } _N_ },
+ tanh = { _A_ 1 _U_ 1 _N_ _S_ "U(P)" {_A_ 1 _U_ 2 _N_ _N_ _F_ _IF_ARGS_ 0 1 X 3 \ (u0 :: Double#) -> case _#_ tanhDouble# [] [u0] of { _PRIM_ (u1 :: Double#) -> _!_ D# [] [u1] } _N_} _F_ _IF_ARGS_ 0 1 C 4 \ (u0 :: Double) -> case u0 of { _ALG_ D# (u1 :: Double#) -> case _#_ tanhDouble# [] [u1] of { _PRIM_ (u2 :: Double#) -> _!_ D# [] [u2] }; _NO_DEFLT_ } _N_ },
+ asinh = { _A_ 1 _U_ 1 _N_ _S_ "U(P)" {_A_ 1 _U_ 2 _N_ _N_ _N_ _N_} _N_ _N_ },
+ acosh = { _A_ 1 _U_ 1 _N_ _S_ "U(P)" {_A_ 1 _U_ 2 _N_ _N_ _N_ _N_} _N_ _N_ },
+ atanh = { _A_ 1 _U_ 1 _N_ _S_ "U(P)" {_A_ 1 _U_ 2 _N_ _N_ _N_ _N_} _N_ _N_ } #-}
instance Fractional Double
{-# GHC_PRAGMA _M_ PreludeCore {-dfun-} _A_ 0 _N_ _N_ _N_ _F_ _IF_ARGS_ 0 0 X 5 _!_ _TUP_4 [{{Num Double}}, (Double -> Double -> Double), (Double -> Double), (Ratio Integer -> Double)] [_DFUN_ Num (Double), _CONSTM_ Fractional (/) (Double), _CONSTM_ Fractional recip (Double), _CONSTM_ Fractional fromRational (Double)] _N_
- (/) = _A_ 2 _U_ 11 _N_ _S_ "U(P)U(P)" {_A_ 2 _U_ 22 _N_ _N_ _F_ _IF_ARGS_ 0 2 XX 3 \ (u0 :: Double#) (u1 :: Double#) -> case _#_ divideDouble# [] [u0, u1] of { _PRIM_ (u2 :: Double#) -> _!_ D# [] [u2] } _N_} _F_ _IF_ARGS_ 0 2 CC 5 \ (u0 :: Double) (u1 :: Double) -> case u0 of { _ALG_ D# (u2 :: Double#) -> case u1 of { _ALG_ D# (u3 :: Double#) -> case _#_ divideDouble# [] [u2, u3] of { _PRIM_ (u4 :: Double#) -> _!_ D# [] [u4] }; _NO_DEFLT_ }; _NO_DEFLT_ } _N_,
- recip = _A_ 1 _U_ 1 _N_ _S_ "U(P)" {_A_ 1 _U_ 2 _N_ _N_ _F_ _IF_ARGS_ 0 1 X 3 \ (u0 :: Double#) -> case _#_ divideDouble# [] [1.0000000000000000##, u0] of { _PRIM_ (u1 :: Double#) -> _!_ D# [] [u1] } _N_} _F_ _IF_ARGS_ 0 1 C 4 \ (u0 :: Double) -> case u0 of { _ALG_ D# (u1 :: Double#) -> case _#_ divideDouble# [] [1.0000000000000000##, u1] of { _PRIM_ (u2 :: Double#) -> _!_ D# [] [u2] }; _NO_DEFLT_ } _N_,
- fromRational = _A_ 0 _U_ 2 _N_ _N_ _N_ _N_ #-}
+ (/) = { _A_ 2 _U_ 11 _N_ _S_ "U(P)U(P)" {_A_ 2 _U_ 22 _N_ _N_ _F_ _IF_ARGS_ 0 2 XX 3 \ (u0 :: Double#) (u1 :: Double#) -> case _#_ divideDouble# [] [u0, u1] of { _PRIM_ (u2 :: Double#) -> _!_ D# [] [u2] } _N_} _F_ _IF_ARGS_ 0 2 CC 5 \ (u0 :: Double) (u1 :: Double) -> case u0 of { _ALG_ D# (u2 :: Double#) -> case u1 of { _ALG_ D# (u3 :: Double#) -> case _#_ divideDouble# [] [u2, u3] of { _PRIM_ (u4 :: Double#) -> _!_ D# [] [u4] }; _NO_DEFLT_ }; _NO_DEFLT_ } _N_ },
+ recip = { _A_ 1 _U_ 1 _N_ _S_ "U(P)" {_A_ 1 _U_ 2 _N_ _N_ _F_ _IF_ARGS_ 0 1 X 3 \ (u0 :: Double#) -> case _#_ divideDouble# [] [1.0000000000000000##, u0] of { _PRIM_ (u1 :: Double#) -> _!_ D# [] [u1] } _N_} _F_ _IF_ARGS_ 0 1 C 4 \ (u0 :: Double) -> case u0 of { _ALG_ D# (u1 :: Double#) -> case _#_ divideDouble# [] [1.0000000000000000##, u1] of { _PRIM_ (u2 :: Double#) -> _!_ D# [] [u2] }; _NO_DEFLT_ } _N_ },
+ fromRational = { _A_ 1 _U_ 1 _N_ _S_ "U(U(PPP)U(PPP))" {_A_ 4 _U_ 2222 _N_ _N_ _N_ _N_} _N_ _N_ } #-}
instance Num Double
{-# GHC_PRAGMA _M_ PreludeCore {-dfun-} _A_ 0 _N_ _N_ _N_ _F_ _IF_ARGS_ 0 0 X 11 _!_ _TUP_10 [{{Eq Double}}, {{Text Double}}, (Double -> Double -> Double), (Double -> Double -> Double), (Double -> Double -> Double), (Double -> Double), (Double -> Double), (Double -> Double), (Integer -> Double), (Int -> Double)] [_DFUN_ Eq (Double), _DFUN_ Text (Double), _CONSTM_ Num (+) (Double), _CONSTM_ Num (-) (Double), _CONSTM_ Num (*) (Double), _CONSTM_ Num negate (Double), _CONSTM_ Num abs (Double), _CONSTM_ Num signum (Double), _CONSTM_ Num fromInteger (Double), _CONSTM_ Num fromInt (Double)] _N_
- (+) = _A_ 2 _U_ 11 _N_ _S_ "U(P)U(P)" {_A_ 2 _U_ 22 _N_ _N_ _F_ _IF_ARGS_ 0 2 XX 3 \ (u0 :: Double#) (u1 :: Double#) -> case _#_ plusDouble# [] [u0, u1] of { _PRIM_ (u2 :: Double#) -> _!_ D# [] [u2] } _N_} _F_ _IF_ARGS_ 0 2 CC 5 \ (u0 :: Double) (u1 :: Double) -> case u0 of { _ALG_ D# (u2 :: Double#) -> case u1 of { _ALG_ D# (u3 :: Double#) -> case _#_ plusDouble# [] [u2, u3] of { _PRIM_ (u4 :: Double#) -> _!_ D# [] [u4] }; _NO_DEFLT_ }; _NO_DEFLT_ } _N_,
- (-) = _A_ 2 _U_ 11 _N_ _S_ "U(P)U(P)" {_A_ 2 _U_ 22 _N_ _N_ _F_ _IF_ARGS_ 0 2 XX 3 \ (u0 :: Double#) (u1 :: Double#) -> case _#_ minusDouble# [] [u0, u1] of { _PRIM_ (u2 :: Double#) -> _!_ D# [] [u2] } _N_} _F_ _IF_ARGS_ 0 2 CC 5 \ (u0 :: Double) (u1 :: Double) -> case u0 of { _ALG_ D# (u2 :: Double#) -> case u1 of { _ALG_ D# (u3 :: Double#) -> case _#_ minusDouble# [] [u2, u3] of { _PRIM_ (u4 :: Double#) -> _!_ D# [] [u4] }; _NO_DEFLT_ }; _NO_DEFLT_ } _N_,
- (*) = _A_ 2 _U_ 11 _N_ _S_ "U(P)U(P)" {_A_ 2 _U_ 22 _N_ _N_ _F_ _IF_ARGS_ 0 2 XX 3 \ (u0 :: Double#) (u1 :: Double#) -> case _#_ timesDouble# [] [u0, u1] of { _PRIM_ (u2 :: Double#) -> _!_ D# [] [u2] } _N_} _F_ _IF_ARGS_ 0 2 CC 5 \ (u0 :: Double) (u1 :: Double) -> case u0 of { _ALG_ D# (u2 :: Double#) -> case u1 of { _ALG_ D# (u3 :: Double#) -> case _#_ timesDouble# [] [u2, u3] of { _PRIM_ (u4 :: Double#) -> _!_ D# [] [u4] }; _NO_DEFLT_ }; _NO_DEFLT_ } _N_,
- negate = _A_ 1 _U_ 1 _N_ _S_ "U(P)" {_A_ 1 _U_ 2 _N_ _N_ _F_ _IF_ARGS_ 0 1 X 3 \ (u0 :: Double#) -> case _#_ negateDouble# [] [u0] of { _PRIM_ (u1 :: Double#) -> _!_ D# [] [u1] } _N_} _F_ _IF_ARGS_ 0 1 C 4 \ (u0 :: Double) -> case u0 of { _ALG_ D# (u1 :: Double#) -> case _#_ negateDouble# [] [u1] of { _PRIM_ (u2 :: Double#) -> _!_ D# [] [u2] }; _NO_DEFLT_ } _N_,
- abs = _A_ 1 _U_ 1 _N_ _S_ "U(P)" {_A_ 1 _U_ 2 _N_ _N_ _N_ _N_} _N_ _N_,
- signum = _A_ 1 _U_ 1 _N_ _S_ "U(P)" {_A_ 1 _U_ 2 _N_ _N_ _N_ _N_} _N_ _N_,
- fromInteger = _A_ 1 _U_ 1 _N_ _S_ "U(PPP)" {_A_ 3 _U_ 222 _N_ _N_ _F_ _IF_ARGS_ 0 3 XXX 3 \ (u0 :: Int#) (u1 :: Int#) (u2 :: ByteArray#) -> case _#_ encodeDouble# [] [u0, u1, u2, 0#] of { _PRIM_ (u3 :: Double#) -> _!_ D# [] [u3] } _N_} _F_ _IF_ARGS_ 0 1 C 4 \ (u0 :: Integer) -> case u0 of { _ALG_ J# (u1 :: Int#) (u2 :: Int#) (u3 :: ByteArray#) -> case _#_ encodeDouble# [] [u1, u2, u3, 0#] of { _PRIM_ (u4 :: Double#) -> _!_ D# [] [u4] }; _NO_DEFLT_ } _N_,
- fromInt = _A_ 1 _U_ 1 _N_ _S_ "U(P)" {_A_ 1 _U_ 2 _N_ _N_ _F_ _IF_ARGS_ 0 1 X 3 \ (u0 :: Int#) -> case _#_ int2Double# [] [u0] of { _PRIM_ (u1 :: Double#) -> _!_ D# [] [u1] } _N_} _F_ _IF_ARGS_ 0 1 C 4 \ (u0 :: Int) -> case u0 of { _ALG_ I# (u1 :: Int#) -> case _#_ int2Double# [] [u1] of { _PRIM_ (u2 :: Double#) -> _!_ D# [] [u2] }; _NO_DEFLT_ } _N_ #-}
+ (+) = { _A_ 2 _U_ 11 _N_ _S_ "U(P)U(P)" {_A_ 2 _U_ 22 _N_ _N_ _F_ _IF_ARGS_ 0 2 XX 3 \ (u0 :: Double#) (u1 :: Double#) -> case _#_ plusDouble# [] [u0, u1] of { _PRIM_ (u2 :: Double#) -> _!_ D# [] [u2] } _N_} _F_ _IF_ARGS_ 0 2 CC 5 \ (u0 :: Double) (u1 :: Double) -> case u0 of { _ALG_ D# (u2 :: Double#) -> case u1 of { _ALG_ D# (u3 :: Double#) -> case _#_ plusDouble# [] [u2, u3] of { _PRIM_ (u4 :: Double#) -> _!_ D# [] [u4] }; _NO_DEFLT_ }; _NO_DEFLT_ } _N_ },
+ (-) = { _A_ 2 _U_ 11 _N_ _S_ "U(P)U(P)" {_A_ 2 _U_ 22 _N_ _N_ _F_ _IF_ARGS_ 0 2 XX 3 \ (u0 :: Double#) (u1 :: Double#) -> case _#_ minusDouble# [] [u0, u1] of { _PRIM_ (u2 :: Double#) -> _!_ D# [] [u2] } _N_} _F_ _IF_ARGS_ 0 2 CC 5 \ (u0 :: Double) (u1 :: Double) -> case u0 of { _ALG_ D# (u2 :: Double#) -> case u1 of { _ALG_ D# (u3 :: Double#) -> case _#_ minusDouble# [] [u2, u3] of { _PRIM_ (u4 :: Double#) -> _!_ D# [] [u4] }; _NO_DEFLT_ }; _NO_DEFLT_ } _N_ },
+ (*) = { _A_ 2 _U_ 11 _N_ _S_ "U(P)U(P)" {_A_ 2 _U_ 22 _N_ _N_ _F_ _IF_ARGS_ 0 2 XX 3 \ (u0 :: Double#) (u1 :: Double#) -> case _#_ timesDouble# [] [u0, u1] of { _PRIM_ (u2 :: Double#) -> _!_ D# [] [u2] } _N_} _F_ _IF_ARGS_ 0 2 CC 5 \ (u0 :: Double) (u1 :: Double) -> case u0 of { _ALG_ D# (u2 :: Double#) -> case u1 of { _ALG_ D# (u3 :: Double#) -> case _#_ timesDouble# [] [u2, u3] of { _PRIM_ (u4 :: Double#) -> _!_ D# [] [u4] }; _NO_DEFLT_ }; _NO_DEFLT_ } _N_ },
+ negate = { _A_ 1 _U_ 1 _N_ _S_ "U(P)" {_A_ 1 _U_ 2 _N_ _N_ _F_ _IF_ARGS_ 0 1 X 3 \ (u0 :: Double#) -> case _#_ negateDouble# [] [u0] of { _PRIM_ (u1 :: Double#) -> _!_ D# [] [u1] } _N_} _F_ _IF_ARGS_ 0 1 C 4 \ (u0 :: Double) -> case u0 of { _ALG_ D# (u1 :: Double#) -> case _#_ negateDouble# [] [u1] of { _PRIM_ (u2 :: Double#) -> _!_ D# [] [u2] }; _NO_DEFLT_ } _N_ },
+ abs = { _A_ 1 _U_ 1 _N_ _S_ "U(P)" {_A_ 1 _U_ 2 _N_ _N_ _N_ _N_} _N_ _N_ },
+ signum = { _A_ 1 _U_ 1 _N_ _S_ "U(P)" {_A_ 1 _U_ 2 _N_ _N_ _N_ _N_} _N_ _N_ },
+ fromInteger = { _A_ 1 _U_ 1 _N_ _S_ "U(PPP)" {_A_ 3 _U_ 222 _N_ _N_ _F_ _IF_ARGS_ 0 3 XXX 3 \ (u0 :: Int#) (u1 :: Int#) (u2 :: ByteArray#) -> case _#_ encodeDouble# [] [u0, u1, u2, 0#] of { _PRIM_ (u3 :: Double#) -> _!_ D# [] [u3] } _N_} _F_ _IF_ARGS_ 0 1 C 4 \ (u0 :: Integer) -> case u0 of { _ALG_ J# (u1 :: Int#) (u2 :: Int#) (u3 :: ByteArray#) -> case _#_ encodeDouble# [] [u1, u2, u3, 0#] of { _PRIM_ (u4 :: Double#) -> _!_ D# [] [u4] }; _NO_DEFLT_ } _N_ },
+ fromInt = { _A_ 1 _U_ 1 _N_ _S_ "U(P)" {_A_ 1 _U_ 2 _N_ _N_ _F_ _IF_ARGS_ 0 1 X 3 \ (u0 :: Int#) -> case _#_ int2Double# [] [u0] of { _PRIM_ (u1 :: Double#) -> _!_ D# [] [u1] } _N_} _F_ _IF_ARGS_ 0 1 C 4 \ (u0 :: Int) -> case u0 of { _ALG_ I# (u1 :: Int#) -> case _#_ int2Double# [] [u1] of { _PRIM_ (u2 :: Double#) -> _!_ D# [] [u2] }; _NO_DEFLT_ } _N_ } #-}
instance Ord Double
{-# GHC_PRAGMA _M_ PreludeCore {-dfun-} _A_ 0 _N_ _N_ _N_ _F_ _IF_ARGS_ 0 0 X 9 _!_ _TUP_8 [{{Eq Double}}, (Double -> Double -> Bool), (Double -> Double -> Bool), (Double -> Double -> Bool), (Double -> Double -> Bool), (Double -> Double -> Double), (Double -> Double -> Double), (Double -> Double -> _CMP_TAG)] [_DFUN_ Eq (Double), _CONSTM_ Ord (<) (Double), _CONSTM_ Ord (<=) (Double), _CONSTM_ Ord (>=) (Double), _CONSTM_ Ord (>) (Double), _CONSTM_ Ord max (Double), _CONSTM_ Ord min (Double), _CONSTM_ Ord _tagCmp (Double)] _N_
- (<) = _A_ 2 _U_ 11 _N_ _S_ "U(P)U(P)" {_A_ 2 _U_ 22 _N_ _N_ _F_ _IF_ARGS_ 0 2 XX 1 \ (u0 :: Double#) (u1 :: Double#) -> _#_ ltDouble# [] [u0, u1] _N_} _F_ _IF_ARGS_ 0 2 CC 3 \ (u0 :: Double) (u1 :: Double) -> case u0 of { _ALG_ D# (u2 :: Double#) -> case u1 of { _ALG_ D# (u3 :: Double#) -> _#_ ltDouble# [] [u2, u3]; _NO_DEFLT_ }; _NO_DEFLT_ } _N_,
- (<=) = _A_ 2 _U_ 11 _N_ _S_ "U(P)U(P)" {_A_ 2 _U_ 22 _N_ _N_ _F_ _IF_ARGS_ 0 2 XX 1 \ (u0 :: Double#) (u1 :: Double#) -> _#_ leDouble# [] [u0, u1] _N_} _F_ _IF_ARGS_ 0 2 CC 3 \ (u0 :: Double) (u1 :: Double) -> case u0 of { _ALG_ D# (u2 :: Double#) -> case u1 of { _ALG_ D# (u3 :: Double#) -> _#_ leDouble# [] [u2, u3]; _NO_DEFLT_ }; _NO_DEFLT_ } _N_,
- (>=) = _A_ 2 _U_ 11 _N_ _S_ "U(P)U(P)" {_A_ 2 _U_ 22 _N_ _N_ _F_ _IF_ARGS_ 0 2 XX 1 \ (u0 :: Double#) (u1 :: Double#) -> _#_ geDouble# [] [u0, u1] _N_} _F_ _IF_ARGS_ 0 2 CC 3 \ (u0 :: Double) (u1 :: Double) -> case u0 of { _ALG_ D# (u2 :: Double#) -> case u1 of { _ALG_ D# (u3 :: Double#) -> _#_ geDouble# [] [u2, u3]; _NO_DEFLT_ }; _NO_DEFLT_ } _N_,
- (>) = _A_ 2 _U_ 11 _N_ _S_ "U(P)U(P)" {_A_ 2 _U_ 22 _N_ _N_ _F_ _IF_ARGS_ 0 2 XX 1 \ (u0 :: Double#) (u1 :: Double#) -> _#_ gtDouble# [] [u0, u1] _N_} _F_ _IF_ARGS_ 0 2 CC 3 \ (u0 :: Double) (u1 :: Double) -> case u0 of { _ALG_ D# (u2 :: Double#) -> case u1 of { _ALG_ D# (u3 :: Double#) -> _#_ gtDouble# [] [u2, u3]; _NO_DEFLT_ }; _NO_DEFLT_ } _N_,
- max = _A_ 2 _U_ 11 _N_ _S_ "U(P)U(P)" {_A_ 2 _U_ 22 _N_ _N_ _N_ _N_} _N_ _N_,
- min = _A_ 2 _U_ 11 _N_ _S_ "U(P)U(P)" {_A_ 2 _U_ 22 _N_ _N_ _N_ _N_} _N_ _N_,
- _tagCmp = _A_ 2 _U_ 11 _N_ _S_ "U(P)U(P)" {_A_ 2 _U_ 22 _N_ _N_ _N_ _N_} _N_ _N_ #-}
+ (<) = { _A_ 2 _U_ 11 _N_ _S_ "U(P)U(P)" {_A_ 2 _U_ 22 _N_ _N_ _F_ _IF_ARGS_ 0 2 XX 1 \ (u0 :: Double#) (u1 :: Double#) -> _#_ ltDouble# [] [u0, u1] _N_} _F_ _IF_ARGS_ 0 2 CC 3 \ (u0 :: Double) (u1 :: Double) -> case u0 of { _ALG_ D# (u2 :: Double#) -> case u1 of { _ALG_ D# (u3 :: Double#) -> _#_ ltDouble# [] [u2, u3]; _NO_DEFLT_ }; _NO_DEFLT_ } _N_ },
+ (<=) = { _A_ 2 _U_ 11 _N_ _S_ "U(P)U(P)" {_A_ 2 _U_ 22 _N_ _N_ _F_ _IF_ARGS_ 0 2 XX 1 \ (u0 :: Double#) (u1 :: Double#) -> _#_ leDouble# [] [u0, u1] _N_} _F_ _IF_ARGS_ 0 2 CC 3 \ (u0 :: Double) (u1 :: Double) -> case u0 of { _ALG_ D# (u2 :: Double#) -> case u1 of { _ALG_ D# (u3 :: Double#) -> _#_ leDouble# [] [u2, u3]; _NO_DEFLT_ }; _NO_DEFLT_ } _N_ },
+ (>=) = { _A_ 2 _U_ 11 _N_ _S_ "U(P)U(P)" {_A_ 2 _U_ 22 _N_ _N_ _F_ _IF_ARGS_ 0 2 XX 1 \ (u0 :: Double#) (u1 :: Double#) -> _#_ geDouble# [] [u0, u1] _N_} _F_ _IF_ARGS_ 0 2 CC 3 \ (u0 :: Double) (u1 :: Double) -> case u0 of { _ALG_ D# (u2 :: Double#) -> case u1 of { _ALG_ D# (u3 :: Double#) -> _#_ geDouble# [] [u2, u3]; _NO_DEFLT_ }; _NO_DEFLT_ } _N_ },
+ (>) = { _A_ 2 _U_ 11 _N_ _S_ "U(P)U(P)" {_A_ 2 _U_ 22 _N_ _N_ _F_ _IF_ARGS_ 0 2 XX 1 \ (u0 :: Double#) (u1 :: Double#) -> _#_ gtDouble# [] [u0, u1] _N_} _F_ _IF_ARGS_ 0 2 CC 3 \ (u0 :: Double) (u1 :: Double) -> case u0 of { _ALG_ D# (u2 :: Double#) -> case u1 of { _ALG_ D# (u3 :: Double#) -> _#_ gtDouble# [] [u2, u3]; _NO_DEFLT_ }; _NO_DEFLT_ } _N_ },
+ max = { _A_ 2 _U_ 11 _N_ _S_ "U(P)U(P)" {_A_ 2 _U_ 22 _N_ _N_ _N_ _N_} _N_ _N_ },
+ min = { _A_ 2 _U_ 11 _N_ _S_ "U(P)U(P)" {_A_ 2 _U_ 22 _N_ _N_ _N_ _N_} _N_ _N_ },
+ _tagCmp = { _A_ 2 _U_ 11 _N_ _S_ "U(P)U(P)" {_A_ 2 _U_ 22 _N_ _N_ _N_ _N_} _N_ _N_ } #-}
instance Real Double
{-# GHC_PRAGMA _M_ PreludeCore {-dfun-} _A_ 0 _N_ _N_ _N_ _F_ _IF_ARGS_ 0 0 X 4 _!_ _TUP_3 [{{Num Double}}, {{Enum Double}}, (Double -> Ratio Integer)] [_DFUN_ Num (Double), _DFUN_ Enum (Double), _CONSTM_ Real toRational (Double)] _N_
- toRational = _A_ 1 _U_ 1 _N_ _S_ "U(P)" {_A_ 1 _U_ 2 _N_ _N_ _N_ _N_} _N_ _N_ #-}
+ toRational = { _A_ 1 _U_ 1 _N_ _S_ "U(P)" {_A_ 1 _U_ 2 _N_ _N_ _N_ _N_} _N_ _N_ } #-}
instance RealFloat Double
{-# GHC_PRAGMA _M_ PreludeCore {-dfun-} _A_ 0 _N_ _N_ _N_ _F_ _IF_ARGS_ 0 0 X 11 _!_ _TUP_10 [{{RealFrac Double}}, {{Floating Double}}, (Double -> Integer), (Double -> Int), (Double -> (Int, Int)), (Double -> (Integer, Int)), (Integer -> Int -> Double), (Double -> Int), (Double -> Double), (Int -> Double -> Double)] [_DFUN_ RealFrac (Double), _DFUN_ Floating (Double), _CONSTM_ RealFloat floatRadix (Double), _CONSTM_ RealFloat floatDigits (Double), _CONSTM_ RealFloat floatRange (Double), _CONSTM_ RealFloat decodeFloat (Double), _CONSTM_ RealFloat encodeFloat (Double), _CONSTM_ RealFloat exponent (Double), _CONSTM_ RealFloat significand (Double), _CONSTM_ RealFloat scaleFloat (Double)] _N_
- floatRadix = _A_ 1 _U_ 0 _N_ _S_ "A" {_A_ 0 _N_ _N_ _N_ _F_ _IF_ARGS_ 0 0 X 1 _#_ int2Integer# [] [2#] _N_} _N_ _N_,
- floatDigits = _A_ 1 _U_ 0 _N_ _S_ "A" {_A_ 0 _N_ _N_ _N_ _F_ _IF_ARGS_ 0 0 X 2 _!_ I# [] [53#] _N_} _F_ _IF_ARGS_ 0 1 X 2 \ (u0 :: Double) -> _!_ I# [] [53#] _N_,
- floatRange = _A_ 1 _U_ 0 _N_ _S_ "A" {_A_ 0 _N_ _N_ _N_ _N_ _N_} _N_ _N_,
- decodeFloat = _A_ 1 _U_ 1 _N_ _S_ "U(P)" {_A_ 1 _U_ 2 _N_ _N_ _N_ _N_} _N_ _N_,
- encodeFloat = _A_ 2 _U_ 11 _N_ _S_ "U(PPP)U(P)" {_A_ 4 _U_ 2222 _N_ _N_ _F_ _IF_ARGS_ 0 4 XXXX 3 \ (u0 :: Int#) (u1 :: Int#) (u2 :: ByteArray#) (u3 :: Int#) -> case _#_ encodeDouble# [] [u0, u1, u2, u3] of { _PRIM_ (u4 :: Double#) -> _!_ D# [] [u4] } _N_} _F_ _IF_ARGS_ 0 2 CC 5 \ (u0 :: Integer) (u1 :: Int) -> case u0 of { _ALG_ J# (u2 :: Int#) (u3 :: Int#) (u4 :: ByteArray#) -> case u1 of { _ALG_ I# (u5 :: Int#) -> case _#_ encodeDouble# [] [u2, u3, u4, u5] of { _PRIM_ (u6 :: Double#) -> _!_ D# [] [u6] }; _NO_DEFLT_ }; _NO_DEFLT_ } _N_,
- exponent = _A_ 1 _U_ 2 _N_ _N_ _N_ _N_,
- significand = _A_ 1 _U_ 2 _N_ _N_ _N_ _N_,
- scaleFloat = _A_ 2 _U_ 22 _N_ _N_ _N_ _N_ #-}
+ floatRadix = { _A_ 1 _U_ 0 _N_ _S_ "A" {_A_ 0 _N_ _N_ _N_ _N_ _N_} _N_ _N_ },
+ floatDigits = { _A_ 1 _U_ 0 _N_ _S_ "A" {_A_ 0 _N_ _N_ _N_ _F_ _IF_ARGS_ 0 0 X 2 _!_ I# [] [53#] _N_} _F_ _IF_ARGS_ 0 1 X 2 \ (u0 :: Double) -> _!_ I# [] [53#] _N_ },
+ floatRange = { _A_ 1 _U_ 0 _N_ _S_ "A" {_A_ 0 _N_ _N_ _N_ _N_ _N_} _N_ _N_ },
+ decodeFloat = { _A_ 1 _U_ 1 _N_ _S_ "U(P)" {_A_ 1 _U_ 2 _N_ _N_ _N_ _N_} _N_ _N_ },
+ encodeFloat = { _A_ 2 _U_ 11 _N_ _S_ "U(PPP)U(P)" {_A_ 4 _U_ 2222 _N_ _N_ _F_ _IF_ARGS_ 0 4 XXXX 3 \ (u0 :: Int#) (u1 :: Int#) (u2 :: ByteArray#) (u3 :: Int#) -> case _#_ encodeDouble# [] [u0, u1, u2, u3] of { _PRIM_ (u4 :: Double#) -> _!_ D# [] [u4] } _N_} _F_ _IF_ARGS_ 0 2 CC 5 \ (u0 :: Integer) (u1 :: Int) -> case u0 of { _ALG_ J# (u2 :: Int#) (u3 :: Int#) (u4 :: ByteArray#) -> case u1 of { _ALG_ I# (u5 :: Int#) -> case _#_ encodeDouble# [] [u2, u3, u4, u5] of { _PRIM_ (u6 :: Double#) -> _!_ D# [] [u6] }; _NO_DEFLT_ }; _NO_DEFLT_ } _N_ },
+ exponent = { _A_ 1 _U_ 1 _N_ _S_ "U(P)" {_A_ 1 _U_ 2 _N_ _N_ _N_ _N_} _N_ _N_ },
+ significand = { _A_ 1 _U_ 1 _N_ _S_ "U(P)" {_A_ 1 _U_ 2 _N_ _N_ _N_ _N_} _N_ _N_ },
+ scaleFloat = { _A_ 2 _U_ 11 _N_ _S_ "U(P)U(P)" {_A_ 2 _U_ 22 _N_ _N_ _N_ _N_} _N_ _N_ } #-}
instance RealFrac Double
{-# GHC_PRAGMA _M_ PreludeCore {-dfun-} _A_ 0 _N_ _N_ _N_ _F_ _IF_ARGS_ 0 0 X 8 _!_ _TUP_7 [{{Real Double}}, {{Fractional Double}}, _forall_ a$z1 =>{{Integral a$z1}} -> (Double -> (a$z1, Double)), _forall_ a$z1 =>{{Integral a$z1}} -> (Double -> a$z1), _forall_ a$z1 =>{{Integral a$z1}} -> (Double -> a$z1), _forall_ a$z1 =>{{Integral a$z1}} -> (Double -> a$z1), _forall_ a$z1 =>{{Integral a$z1}} -> (Double -> a$z1)] [_DFUN_ Real (Double), _DFUN_ Fractional (Double), _CONSTM_ RealFrac properFraction (Double), _CONSTM_ RealFrac truncate (Double), _CONSTM_ RealFrac round (Double), _CONSTM_ RealFrac ceiling (Double), _CONSTM_ RealFrac floor (Double)] _N_
- properFraction = _A_ 1 _U_ 22 _N_ _N_ _N_ _N_,
- truncate = _A_ 1 _U_ 22 _N_ _N_ _N_ _N_,
- round = _A_ 1 _U_ 22 _N_ _N_ _N_ _N_,
- ceiling = _A_ 1 _U_ 22 _N_ _N_ _N_ _N_,
- floor = _A_ 1 _U_ 22 _N_ _N_ _N_ _N_ #-}
+ properFraction = { _A_ 1 _U_ 11 _N_ _N_ _N_ _SPECIALISE_ [ Int ] 1 { _A_ 1 _U_ 1 _N_ _S_ "U(P)" {_A_ 1 _U_ 2 _N_ _N_ _N_ _N_} _N_ _N_ }, [ Integer ] 1 { _A_ 1 _U_ 1 _N_ _S_ "U(P)" {_A_ 1 _U_ 2 _N_ _N_ _N_ _N_} _N_ _N_ } },
+ truncate = { _A_ 1 _U_ 11 _N_ _N_ _N_ _SPECIALISE_ [ Int ] 1 { _A_ 1 _U_ 1 _N_ _S_ "U(P)" {_A_ 1 _U_ 2 _N_ _N_ _F_ _IF_ARGS_ 0 1 X 4 \ (u0 :: Double#) -> case _APP_ _WRKR_ _SPEC_ _CONSTM_ RealFrac properFraction (Double) [ (Int) ] [ u0 ] of { _ALG_ _TUP_2 (u1 :: Int) (u2 :: Double) -> u1; _NO_DEFLT_ } _N_} _F_ _IF_ARGS_ 0 1 X 4 \ (u0 :: Double) -> case _APP_ _SPEC_ _CONSTM_ RealFrac properFraction (Double) [ (Int) ] [ u0 ] of { _ALG_ _TUP_2 (u1 :: Int) (u2 :: Double) -> u1; _NO_DEFLT_ } _N_ }, [ Integer ] 1 { _A_ 1 _U_ 1 _N_ _S_ "U(P)" {_A_ 1 _U_ 2 _N_ _N_ _F_ _IF_ARGS_ 0 1 X 4 \ (u0 :: Double#) -> case _APP_ _WRKR_ _SPEC_ _CONSTM_ RealFrac properFraction (Double) [ (Integer) ] [ u0 ] of { _ALG_ _TUP_2 (u1 :: Integer) (u2 :: Double) -> u1; _NO_DEFLT_ } _N_} _F_ _IF_ARGS_ 0 1 X 4 \ (u0 :: Double) -> case _APP_ _SPEC_ _CONSTM_ RealFrac properFraction (Double) [ (Integer) ] [ u0 ] of { _ALG_ _TUP_2 (u1 :: Integer) (u2 :: Double) -> u1; _NO_DEFLT_ } _N_ } },
+ round = { _A_ 1 _U_ 21 _N_ _N_ _N_ _SPECIALISE_ [ Int ] 1 { _A_ 1 _U_ 1 _N_ _S_ "U(P)" {_A_ 1 _U_ 2 _N_ _N_ _N_ _N_} _N_ _N_ }, [ Integer ] 1 { _A_ 1 _U_ 1 _N_ _S_ "U(P)" {_A_ 1 _U_ 2 _N_ _N_ _N_ _N_} _N_ _N_ } },
+ ceiling = { _A_ 1 _U_ 21 _N_ _N_ _N_ _SPECIALISE_ [ Int ] 1 { _A_ 1 _U_ 1 _N_ _S_ "U(P)" {_A_ 1 _U_ 2 _N_ _N_ _N_ _N_} _N_ _N_ }, [ Integer ] 1 { _A_ 1 _U_ 1 _N_ _S_ "U(P)" {_A_ 1 _U_ 2 _N_ _N_ _N_ _N_} _N_ _N_ } },
+ floor = { _A_ 1 _U_ 21 _N_ _N_ _N_ _SPECIALISE_ [ Int ] 1 { _A_ 1 _U_ 1 _N_ _S_ "U(P)" {_A_ 1 _U_ 2 _N_ _N_ _N_ _N_} _N_ _N_ }, [ Integer ] 1 { _A_ 1 _U_ 1 _N_ _S_ "U(P)" {_A_ 1 _U_ 2 _N_ _N_ _N_ _N_} _N_ _N_ } } #-}
instance Text Double
{-# GHC_PRAGMA _M_ PreludeCore {-dfun-} _A_ 0 _N_ _N_ _N_ _F_ _IF_ARGS_ 0 0 X 5 _!_ _TUP_4 [(Int -> [Char] -> [(Double, [Char])]), (Int -> Double -> [Char] -> [Char]), ([Char] -> [([Double], [Char])]), ([Double] -> [Char] -> [Char])] [_CONSTM_ Text readsPrec (Double), _CONSTM_ Text showsPrec (Double), _CONSTM_ Text readList (Double), _CONSTM_ Text showList (Double)] _N_
- readsPrec = _A_ 2 _U_ 02 _N_ _S_ "AL" {_A_ 1 _U_ 2 _N_ _N_ _F_ _IF_ARGS_ 0 1 X 3 \ (u0 :: [Char]) -> _APP_ _SPEC_ _ORIG_ PreludeText readSigned [ (Double) ] [ _SPEC_ _ORIG_ PreludeText readFloat [ (Double) ], u0 ] _N_} _F_ _IF_ARGS_ 0 2 XX 3 \ (u0 :: Int) (u1 :: [Char]) -> _APP_ _SPEC_ _ORIG_ PreludeText readSigned [ (Double) ] [ _SPEC_ _ORIG_ PreludeText readFloat [ (Double) ], u1 ] _N_,
- showsPrec = _A_ 2 _U_ 212 _N_ _S_ "LU(P)" {_A_ 2 _U_ 222 _N_ _N_ _F_ _IF_ARGS_ 0 2 XX 4 \ (u0 :: Int) (u1 :: Double#) -> _APP_ _WRKR_ _SPEC_ _ORIG_ PreludeText showSigned [ (Double) ] [ _SPEC_ _ORIG_ PreludeText showFloat [ (Double) ], u0, u1 ] _N_} _F_ _IF_ARGS_ 0 2 XC 5 \ (u0 :: Int) (u1 :: Double) -> case u1 of { _ALG_ D# (u2 :: Double#) -> _APP_ _WRKR_ _SPEC_ _ORIG_ PreludeText showSigned [ (Double) ] [ _SPEC_ _ORIG_ PreludeText showFloat [ (Double) ], u0, u2 ]; _NO_DEFLT_ } _N_,
- readList = _A_ 0 _U_ 2 _N_ _N_ _N_ _N_,
- showList = _A_ 0 _U_ 12 _N_ _N_ _N_ _N_ #-}
+ readsPrec = { _A_ 2 _U_ 02 _N_ _S_ "AL" {_A_ 1 _U_ 2 _N_ _N_ _F_ _IF_ARGS_ 0 1 X 3 \ (u0 :: [Char]) -> _APP_ _SPEC_ _ORIG_ PreludeText readSigned [ (Double) ] [ _SPEC_ _ORIG_ PreludeText readFloat [ (Double) ], u0 ] _N_} _F_ _IF_ARGS_ 0 2 XX 3 \ (u0 :: Int) (u1 :: [Char]) -> _APP_ _SPEC_ _ORIG_ PreludeText readSigned [ (Double) ] [ _SPEC_ _ORIG_ PreludeText readFloat [ (Double) ], u1 ] _N_ },
+ showsPrec = { _A_ 2 _U_ 212 _N_ _S_ "LU(P)" {_A_ 2 _U_ 222 _N_ _N_ _F_ _IF_ARGS_ 0 2 XX 4 \ (u0 :: Int) (u1 :: Double#) -> _APP_ _WRKR_ _SPEC_ _ORIG_ PreludeText showSigned [ (Double) ] [ _SPEC_ _ORIG_ PreludeText showFloat [ (Double) ], u0, u1 ] _N_} _F_ _IF_ARGS_ 0 2 XC 5 \ (u0 :: Int) (u1 :: Double) -> case u1 of { _ALG_ D# (u2 :: Double#) -> _APP_ _WRKR_ _SPEC_ _ORIG_ PreludeText showSigned [ (Double) ] [ _SPEC_ _ORIG_ PreludeText showFloat [ (Double) ], u0, u2 ]; _NO_DEFLT_ } _N_ },
+ readList = { _A_ 0 _U_ 2 _N_ _N_ _N_ _N_ },
+ showList = { _A_ 1 _U_ 12 _N_ _N_ _N_ _N_ } #-}
instance _CCallable Double
{-# GHC_PRAGMA _M_ PreludeCore {-dfun-} _A_ 0 _N_ _N_ _N_ _F_ _IF_ARGS_ 0 0 X 1 _!_ _TUP_0 [] [] _N_ #-}
instance _CReturnable Double
-{-# GHC_PRAGMA INTERFACE VERSION 5 #-}
+{-# GHC_PRAGMA INTERFACE VERSION 6 #-}
interface PreludeCore where
import PreludeBuiltin(Double(..))
instance Enum Double
{-# GHC_PRAGMA _M_ PreludeCore {-dfun-} _A_ 0 _N_ _N_ _N_ _F_ _IF_ARGS_ 0 0 X 6 _!_ _TUP_5 [{{Ord Double}}, (Double -> [Double]), (Double -> Double -> [Double]), (Double -> Double -> [Double]), (Double -> Double -> Double -> [Double])] [_DFUN_ Ord (Double), _CONSTM_ Enum enumFrom (Double), _CONSTM_ Enum enumFromThen (Double), _CONSTM_ Enum enumFromTo (Double), _CONSTM_ Enum enumFromThenTo (Double)] _N_
- enumFrom = _A_ 1 _U_ 2 _N_ _N_ _N_ _N_,
- enumFromThen = _A_ 2 _U_ 21 _N_ _N_ _N_ _N_,
- enumFromTo = _A_ 2 _U_ 22 _N_ _N_ _N_ _N_,
- enumFromThenTo = _A_ 3 _U_ 222 _N_ _N_ _N_ _N_ #-}
+ enumFrom = { _A_ 1 _U_ 2 _N_ _N_ _N_ _N_ },
+ enumFromThen = { _A_ 2 _U_ 21 _N_ _N_ _N_ _N_ },
+ enumFromTo = { _A_ 2 _U_ 22 _N_ _N_ _N_ _N_ },
+ enumFromThenTo = { _A_ 3 _U_ 222 _N_ _N_ _N_ _N_ } #-}
instance Eq Double
{-# GHC_PRAGMA _M_ PreludeCore {-dfun-} _A_ 0 _N_ _N_ _N_ _F_ _IF_ARGS_ 0 0 X 3 _!_ _TUP_2 [(Double -> Double -> Bool), (Double -> Double -> Bool)] [_CONSTM_ Eq (==) (Double), _CONSTM_ Eq (/=) (Double)] _N_
- (==) = _A_ 2 _U_ 11 _N_ _S_ "U(P)U(P)" {_A_ 2 _U_ 22 _N_ _N_ _F_ _IF_ARGS_ 0 2 XX 1 \ (u0 :: Double#) (u1 :: Double#) -> _#_ eqDouble# [] [u0, u1] _N_} _F_ _IF_ARGS_ 0 2 CC 3 \ (u0 :: Double) (u1 :: Double) -> case u0 of { _ALG_ D# (u2 :: Double#) -> case u1 of { _ALG_ D# (u3 :: Double#) -> _#_ eqDouble# [] [u2, u3]; _NO_DEFLT_ }; _NO_DEFLT_ } _N_,
- (/=) = _A_ 2 _U_ 11 _N_ _S_ "U(P)U(P)" {_A_ 2 _U_ 22 _N_ _N_ _F_ _IF_ARGS_ 0 2 XX 1 \ (u0 :: Double#) (u1 :: Double#) -> _#_ neDouble# [] [u0, u1] _N_} _F_ _IF_ARGS_ 0 2 CC 3 \ (u0 :: Double) (u1 :: Double) -> case u0 of { _ALG_ D# (u2 :: Double#) -> case u1 of { _ALG_ D# (u3 :: Double#) -> _#_ neDouble# [] [u2, u3]; _NO_DEFLT_ }; _NO_DEFLT_ } _N_ #-}
+ (==) = { _A_ 2 _U_ 11 _N_ _S_ "U(P)U(P)" {_A_ 2 _U_ 22 _N_ _N_ _F_ _IF_ARGS_ 0 2 XX 1 \ (u0 :: Double#) (u1 :: Double#) -> _#_ eqDouble# [] [u0, u1] _N_} _F_ _IF_ARGS_ 0 2 CC 3 \ (u0 :: Double) (u1 :: Double) -> case u0 of { _ALG_ D# (u2 :: Double#) -> case u1 of { _ALG_ D# (u3 :: Double#) -> _#_ eqDouble# [] [u2, u3]; _NO_DEFLT_ }; _NO_DEFLT_ } _N_ },
+ (/=) = { _A_ 2 _U_ 11 _N_ _S_ "U(P)U(P)" {_A_ 2 _U_ 22 _N_ _N_ _F_ _IF_ARGS_ 0 2 XX 1 \ (u0 :: Double#) (u1 :: Double#) -> _#_ neDouble# [] [u0, u1] _N_} _F_ _IF_ARGS_ 0 2 CC 3 \ (u0 :: Double) (u1 :: Double) -> case u0 of { _ALG_ D# (u2 :: Double#) -> case u1 of { _ALG_ D# (u3 :: Double#) -> _#_ neDouble# [] [u2, u3]; _NO_DEFLT_ }; _NO_DEFLT_ } _N_ } #-}
instance Floating Double
{-# GHC_PRAGMA _M_ PreludeCore {-dfun-} _A_ 0 _N_ _N_ _N_ _F_ _IF_ARGS_ 0 0 X 20 _!_ _TUP_19 [{{Fractional Double}}, Double, (Double -> Double), (Double -> Double), (Double -> Double), (Double -> Double -> Double), (Double -> Double -> Double), (Double -> Double), (Double -> Double), (Double -> Double), (Double -> Double), (Double -> Double), (Double -> Double), (Double -> Double), (Double -> Double), (Double -> Double), (Double -> Double), (Double -> Double), (Double -> Double)] [_DFUN_ Fractional (Double), _CONSTM_ Floating pi (Double), _CONSTM_ Floating exp (Double), _CONSTM_ Floating log (Double), _CONSTM_ Floating sqrt (Double), _CONSTM_ Floating (**) (Double), _CONSTM_ Floating logBase (Double), _CONSTM_ Floating sin (Double), _CONSTM_ Floating cos (Double), _CONSTM_ Floating tan (Double), _CONSTM_ Floating asin (Double), _CONSTM_ Floating acos (Double), _CONSTM_ Floating atan (Double), _CONSTM_ Floating sinh (Double), _CONSTM_ Floating cosh (Double), _CONSTM_ Floating tanh (Double), _CONSTM_ Floating asinh (Double), _CONSTM_ Floating acosh (Double), _CONSTM_ Floating atanh (Double)] _N_
- pi = _A_ 0 _N_ _N_ _N_ _F_ _IF_ARGS_ 0 0 X 2 _!_ D# [] [3.1415926535897931##] _N_,
- exp = _A_ 1 _U_ 1 _N_ _S_ "U(P)" {_A_ 1 _U_ 2 _N_ _N_ _F_ _IF_ARGS_ 0 1 X 3 \ (u0 :: Double#) -> case _#_ expDouble# [] [u0] of { _PRIM_ (u1 :: Double#) -> _!_ D# [] [u1] } _N_} _F_ _IF_ARGS_ 0 1 C 4 \ (u0 :: Double) -> case u0 of { _ALG_ D# (u1 :: Double#) -> case _#_ expDouble# [] [u1] of { _PRIM_ (u2 :: Double#) -> _!_ D# [] [u2] }; _NO_DEFLT_ } _N_,
- log = _A_ 1 _U_ 1 _N_ _S_ "U(P)" {_A_ 1 _U_ 2 _N_ _N_ _F_ _IF_ARGS_ 0 1 X 3 \ (u0 :: Double#) -> case _#_ logDouble# [] [u0] of { _PRIM_ (u1 :: Double#) -> _!_ D# [] [u1] } _N_} _F_ _IF_ARGS_ 0 1 C 4 \ (u0 :: Double) -> case u0 of { _ALG_ D# (u1 :: Double#) -> case _#_ logDouble# [] [u1] of { _PRIM_ (u2 :: Double#) -> _!_ D# [] [u2] }; _NO_DEFLT_ } _N_,
- sqrt = _A_ 1 _U_ 1 _N_ _S_ "U(P)" {_A_ 1 _U_ 2 _N_ _N_ _F_ _IF_ARGS_ 0 1 X 3 \ (u0 :: Double#) -> case _#_ sqrtDouble# [] [u0] of { _PRIM_ (u1 :: Double#) -> _!_ D# [] [u1] } _N_} _F_ _IF_ARGS_ 0 1 C 4 \ (u0 :: Double) -> case u0 of { _ALG_ D# (u1 :: Double#) -> case _#_ sqrtDouble# [] [u1] of { _PRIM_ (u2 :: Double#) -> _!_ D# [] [u2] }; _NO_DEFLT_ } _N_,
- (**) = _A_ 2 _U_ 11 _N_ _S_ "U(P)U(P)" {_A_ 2 _U_ 22 _N_ _N_ _F_ _IF_ARGS_ 0 2 XX 3 \ (u0 :: Double#) (u1 :: Double#) -> case _#_ powerDouble# [] [u0, u1] of { _PRIM_ (u2 :: Double#) -> _!_ D# [] [u2] } _N_} _F_ _IF_ARGS_ 0 2 CC 5 \ (u0 :: Double) (u1 :: Double) -> case u0 of { _ALG_ D# (u2 :: Double#) -> case u1 of { _ALG_ D# (u3 :: Double#) -> case _#_ powerDouble# [] [u2, u3] of { _PRIM_ (u4 :: Double#) -> _!_ D# [] [u4] }; _NO_DEFLT_ }; _NO_DEFLT_ } _N_,
- logBase = _A_ 2 _U_ 11 _N_ _S_ "U(P)U(P)" {_A_ 2 _U_ 22 _N_ _N_ _F_ _IF_ARGS_ 0 2 XX 5 \ (u0 :: Double#) (u1 :: Double#) -> case _#_ logDouble# [] [u1] of { _PRIM_ (u2 :: Double#) -> case _#_ logDouble# [] [u0] of { _PRIM_ (u3 :: Double#) -> case _#_ divideDouble# [] [u2, u3] of { _PRIM_ (u4 :: Double#) -> _!_ D# [] [u4] } } } _N_} _F_ _IF_ARGS_ 0 2 CC 7 \ (u0 :: Double) (u1 :: Double) -> case u1 of { _ALG_ D# (u2 :: Double#) -> case _#_ logDouble# [] [u2] of { _PRIM_ (u3 :: Double#) -> case u0 of { _ALG_ D# (u4 :: Double#) -> case _#_ logDouble# [] [u4] of { _PRIM_ (u5 :: Double#) -> case _#_ divideDouble# [] [u3, u5] of { _PRIM_ (u6 :: Double#) -> _!_ D# [] [u6] } }; _NO_DEFLT_ } }; _NO_DEFLT_ } _N_,
- sin = _A_ 1 _U_ 1 _N_ _S_ "U(P)" {_A_ 1 _U_ 2 _N_ _N_ _F_ _IF_ARGS_ 0 1 X 3 \ (u0 :: Double#) -> case _#_ sinDouble# [] [u0] of { _PRIM_ (u1 :: Double#) -> _!_ D# [] [u1] } _N_} _F_ _IF_ARGS_ 0 1 C 4 \ (u0 :: Double) -> case u0 of { _ALG_ D# (u1 :: Double#) -> case _#_ sinDouble# [] [u1] of { _PRIM_ (u2 :: Double#) -> _!_ D# [] [u2] }; _NO_DEFLT_ } _N_,
- cos = _A_ 1 _U_ 1 _N_ _S_ "U(P)" {_A_ 1 _U_ 2 _N_ _N_ _F_ _IF_ARGS_ 0 1 X 3 \ (u0 :: Double#) -> case _#_ cosDouble# [] [u0] of { _PRIM_ (u1 :: Double#) -> _!_ D# [] [u1] } _N_} _F_ _IF_ARGS_ 0 1 C 4 \ (u0 :: Double) -> case u0 of { _ALG_ D# (u1 :: Double#) -> case _#_ cosDouble# [] [u1] of { _PRIM_ (u2 :: Double#) -> _!_ D# [] [u2] }; _NO_DEFLT_ } _N_,
- tan = _A_ 1 _U_ 1 _N_ _S_ "U(P)" {_A_ 1 _U_ 2 _N_ _N_ _F_ _IF_ARGS_ 0 1 X 3 \ (u0 :: Double#) -> case _#_ tanDouble# [] [u0] of { _PRIM_ (u1 :: Double#) -> _!_ D# [] [u1] } _N_} _F_ _IF_ARGS_ 0 1 C 4 \ (u0 :: Double) -> case u0 of { _ALG_ D# (u1 :: Double#) -> case _#_ tanDouble# [] [u1] of { _PRIM_ (u2 :: Double#) -> _!_ D# [] [u2] }; _NO_DEFLT_ } _N_,
- asin = _A_ 1 _U_ 1 _N_ _S_ "U(P)" {_A_ 1 _U_ 2 _N_ _N_ _F_ _IF_ARGS_ 0 1 X 3 \ (u0 :: Double#) -> case _#_ asinDouble# [] [u0] of { _PRIM_ (u1 :: Double#) -> _!_ D# [] [u1] } _N_} _F_ _IF_ARGS_ 0 1 C 4 \ (u0 :: Double) -> case u0 of { _ALG_ D# (u1 :: Double#) -> case _#_ asinDouble# [] [u1] of { _PRIM_ (u2 :: Double#) -> _!_ D# [] [u2] }; _NO_DEFLT_ } _N_,
- acos = _A_ 1 _U_ 1 _N_ _S_ "U(P)" {_A_ 1 _U_ 2 _N_ _N_ _F_ _IF_ARGS_ 0 1 X 3 \ (u0 :: Double#) -> case _#_ acosDouble# [] [u0] of { _PRIM_ (u1 :: Double#) -> _!_ D# [] [u1] } _N_} _F_ _IF_ARGS_ 0 1 C 4 \ (u0 :: Double) -> case u0 of { _ALG_ D# (u1 :: Double#) -> case _#_ acosDouble# [] [u1] of { _PRIM_ (u2 :: Double#) -> _!_ D# [] [u2] }; _NO_DEFLT_ } _N_,
- atan = _A_ 1 _U_ 1 _N_ _S_ "U(P)" {_A_ 1 _U_ 2 _N_ _N_ _F_ _IF_ARGS_ 0 1 X 3 \ (u0 :: Double#) -> case _#_ atanDouble# [] [u0] of { _PRIM_ (u1 :: Double#) -> _!_ D# [] [u1] } _N_} _F_ _IF_ARGS_ 0 1 C 4 \ (u0 :: Double) -> case u0 of { _ALG_ D# (u1 :: Double#) -> case _#_ atanDouble# [] [u1] of { _PRIM_ (u2 :: Double#) -> _!_ D# [] [u2] }; _NO_DEFLT_ } _N_,
- sinh = _A_ 1 _U_ 1 _N_ _S_ "U(P)" {_A_ 1 _U_ 2 _N_ _N_ _F_ _IF_ARGS_ 0 1 X 3 \ (u0 :: Double#) -> case _#_ sinhDouble# [] [u0] of { _PRIM_ (u1 :: Double#) -> _!_ D# [] [u1] } _N_} _F_ _IF_ARGS_ 0 1 C 4 \ (u0 :: Double) -> case u0 of { _ALG_ D# (u1 :: Double#) -> case _#_ sinhDouble# [] [u1] of { _PRIM_ (u2 :: Double#) -> _!_ D# [] [u2] }; _NO_DEFLT_ } _N_,
- cosh = _A_ 1 _U_ 1 _N_ _S_ "U(P)" {_A_ 1 _U_ 2 _N_ _N_ _F_ _IF_ARGS_ 0 1 X 3 \ (u0 :: Double#) -> case _#_ coshDouble# [] [u0] of { _PRIM_ (u1 :: Double#) -> _!_ D# [] [u1] } _N_} _F_ _IF_ARGS_ 0 1 C 4 \ (u0 :: Double) -> case u0 of { _ALG_ D# (u1 :: Double#) -> case _#_ coshDouble# [] [u1] of { _PRIM_ (u2 :: Double#) -> _!_ D# [] [u2] }; _NO_DEFLT_ } _N_,
- tanh = _A_ 1 _U_ 1 _N_ _S_ "U(P)" {_A_ 1 _U_ 2 _N_ _N_ _F_ _IF_ARGS_ 0 1 X 3 \ (u0 :: Double#) -> case _#_ tanhDouble# [] [u0] of { _PRIM_ (u1 :: Double#) -> _!_ D# [] [u1] } _N_} _F_ _IF_ARGS_ 0 1 C 4 \ (u0 :: Double) -> case u0 of { _ALG_ D# (u1 :: Double#) -> case _#_ tanhDouble# [] [u1] of { _PRIM_ (u2 :: Double#) -> _!_ D# [] [u2] }; _NO_DEFLT_ } _N_,
- asinh = _A_ 1 _U_ 1 _N_ _S_ "U(P)" {_A_ 1 _U_ 2 _N_ _N_ _N_ _N_} _N_ _N_,
- acosh = _A_ 1 _U_ 1 _N_ _S_ "U(P)" {_A_ 1 _U_ 2 _N_ _N_ _N_ _N_} _N_ _N_,
- atanh = _A_ 1 _U_ 1 _N_ _S_ "U(P)" {_A_ 1 _U_ 2 _N_ _N_ _N_ _N_} _N_ _N_ #-}
+ pi = { _A_ 0 _N_ _N_ _N_ _F_ _IF_ARGS_ 0 0 X 2 _!_ D# [] [3.1415926535897931##] _N_ },
+ exp = { _A_ 1 _U_ 1 _N_ _S_ "U(P)" {_A_ 1 _U_ 2 _N_ _N_ _F_ _IF_ARGS_ 0 1 X 3 \ (u0 :: Double#) -> case _#_ expDouble# [] [u0] of { _PRIM_ (u1 :: Double#) -> _!_ D# [] [u1] } _N_} _F_ _IF_ARGS_ 0 1 C 4 \ (u0 :: Double) -> case u0 of { _ALG_ D# (u1 :: Double#) -> case _#_ expDouble# [] [u1] of { _PRIM_ (u2 :: Double#) -> _!_ D# [] [u2] }; _NO_DEFLT_ } _N_ },
+ log = { _A_ 1 _U_ 1 _N_ _S_ "U(P)" {_A_ 1 _U_ 2 _N_ _N_ _F_ _IF_ARGS_ 0 1 X 3 \ (u0 :: Double#) -> case _#_ logDouble# [] [u0] of { _PRIM_ (u1 :: Double#) -> _!_ D# [] [u1] } _N_} _F_ _IF_ARGS_ 0 1 C 4 \ (u0 :: Double) -> case u0 of { _ALG_ D# (u1 :: Double#) -> case _#_ logDouble# [] [u1] of { _PRIM_ (u2 :: Double#) -> _!_ D# [] [u2] }; _NO_DEFLT_ } _N_ },
+ sqrt = { _A_ 1 _U_ 1 _N_ _S_ "U(P)" {_A_ 1 _U_ 2 _N_ _N_ _F_ _IF_ARGS_ 0 1 X 3 \ (u0 :: Double#) -> case _#_ sqrtDouble# [] [u0] of { _PRIM_ (u1 :: Double#) -> _!_ D# [] [u1] } _N_} _F_ _IF_ARGS_ 0 1 C 4 \ (u0 :: Double) -> case u0 of { _ALG_ D# (u1 :: Double#) -> case _#_ sqrtDouble# [] [u1] of { _PRIM_ (u2 :: Double#) -> _!_ D# [] [u2] }; _NO_DEFLT_ } _N_ },
+ (**) = { _A_ 2 _U_ 11 _N_ _S_ "U(P)U(P)" {_A_ 2 _U_ 22 _N_ _N_ _F_ _IF_ARGS_ 0 2 XX 3 \ (u0 :: Double#) (u1 :: Double#) -> case _#_ powerDouble# [] [u0, u1] of { _PRIM_ (u2 :: Double#) -> _!_ D# [] [u2] } _N_} _F_ _IF_ARGS_ 0 2 CC 5 \ (u0 :: Double) (u1 :: Double) -> case u0 of { _ALG_ D# (u2 :: Double#) -> case u1 of { _ALG_ D# (u3 :: Double#) -> case _#_ powerDouble# [] [u2, u3] of { _PRIM_ (u4 :: Double#) -> _!_ D# [] [u4] }; _NO_DEFLT_ }; _NO_DEFLT_ } _N_ },
+ logBase = { _A_ 2 _U_ 11 _N_ _S_ "U(P)U(P)" {_A_ 2 _U_ 22 _N_ _N_ _F_ _IF_ARGS_ 0 2 XX 5 \ (u0 :: Double#) (u1 :: Double#) -> case _#_ logDouble# [] [u1] of { _PRIM_ (u2 :: Double#) -> case _#_ logDouble# [] [u0] of { _PRIM_ (u3 :: Double#) -> case _#_ divideDouble# [] [u2, u3] of { _PRIM_ (u4 :: Double#) -> _!_ D# [] [u4] } } } _N_} _F_ _IF_ARGS_ 0 2 CC 7 \ (u0 :: Double) (u1 :: Double) -> case u1 of { _ALG_ D# (u2 :: Double#) -> case _#_ logDouble# [] [u2] of { _PRIM_ (u3 :: Double#) -> case u0 of { _ALG_ D# (u4 :: Double#) -> case _#_ logDouble# [] [u4] of { _PRIM_ (u5 :: Double#) -> case _#_ divideDouble# [] [u3, u5] of { _PRIM_ (u6 :: Double#) -> _!_ D# [] [u6] } }; _NO_DEFLT_ } }; _NO_DEFLT_ } _N_ },
+ sin = { _A_ 1 _U_ 1 _N_ _S_ "U(P)" {_A_ 1 _U_ 2 _N_ _N_ _F_ _IF_ARGS_ 0 1 X 3 \ (u0 :: Double#) -> case _#_ sinDouble# [] [u0] of { _PRIM_ (u1 :: Double#) -> _!_ D# [] [u1] } _N_} _F_ _IF_ARGS_ 0 1 C 4 \ (u0 :: Double) -> case u0 of { _ALG_ D# (u1 :: Double#) -> case _#_ sinDouble# [] [u1] of { _PRIM_ (u2 :: Double#) -> _!_ D# [] [u2] }; _NO_DEFLT_ } _N_ },
+ cos = { _A_ 1 _U_ 1 _N_ _S_ "U(P)" {_A_ 1 _U_ 2 _N_ _N_ _F_ _IF_ARGS_ 0 1 X 3 \ (u0 :: Double#) -> case _#_ cosDouble# [] [u0] of { _PRIM_ (u1 :: Double#) -> _!_ D# [] [u1] } _N_} _F_ _IF_ARGS_ 0 1 C 4 \ (u0 :: Double) -> case u0 of { _ALG_ D# (u1 :: Double#) -> case _#_ cosDouble# [] [u1] of { _PRIM_ (u2 :: Double#) -> _!_ D# [] [u2] }; _NO_DEFLT_ } _N_ },
+ tan = { _A_ 1 _U_ 1 _N_ _S_ "U(P)" {_A_ 1 _U_ 2 _N_ _N_ _F_ _IF_ARGS_ 0 1 X 3 \ (u0 :: Double#) -> case _#_ tanDouble# [] [u0] of { _PRIM_ (u1 :: Double#) -> _!_ D# [] [u1] } _N_} _F_ _IF_ARGS_ 0 1 C 4 \ (u0 :: Double) -> case u0 of { _ALG_ D# (u1 :: Double#) -> case _#_ tanDouble# [] [u1] of { _PRIM_ (u2 :: Double#) -> _!_ D# [] [u2] }; _NO_DEFLT_ } _N_ },
+ asin = { _A_ 1 _U_ 1 _N_ _S_ "U(P)" {_A_ 1 _U_ 2 _N_ _N_ _F_ _IF_ARGS_ 0 1 X 3 \ (u0 :: Double#) -> case _#_ asinDouble# [] [u0] of { _PRIM_ (u1 :: Double#) -> _!_ D# [] [u1] } _N_} _F_ _IF_ARGS_ 0 1 C 4 \ (u0 :: Double) -> case u0 of { _ALG_ D# (u1 :: Double#) -> case _#_ asinDouble# [] [u1] of { _PRIM_ (u2 :: Double#) -> _!_ D# [] [u2] }; _NO_DEFLT_ } _N_ },
+ acos = { _A_ 1 _U_ 1 _N_ _S_ "U(P)" {_A_ 1 _U_ 2 _N_ _N_ _F_ _IF_ARGS_ 0 1 X 3 \ (u0 :: Double#) -> case _#_ acosDouble# [] [u0] of { _PRIM_ (u1 :: Double#) -> _!_ D# [] [u1] } _N_} _F_ _IF_ARGS_ 0 1 C 4 \ (u0 :: Double) -> case u0 of { _ALG_ D# (u1 :: Double#) -> case _#_ acosDouble# [] [u1] of { _PRIM_ (u2 :: Double#) -> _!_ D# [] [u2] }; _NO_DEFLT_ } _N_ },
+ atan = { _A_ 1 _U_ 1 _N_ _S_ "U(P)" {_A_ 1 _U_ 2 _N_ _N_ _F_ _IF_ARGS_ 0 1 X 3 \ (u0 :: Double#) -> case _#_ atanDouble# [] [u0] of { _PRIM_ (u1 :: Double#) -> _!_ D# [] [u1] } _N_} _F_ _IF_ARGS_ 0 1 C 4 \ (u0 :: Double) -> case u0 of { _ALG_ D# (u1 :: Double#) -> case _#_ atanDouble# [] [u1] of { _PRIM_ (u2 :: Double#) -> _!_ D# [] [u2] }; _NO_DEFLT_ } _N_ },
+ sinh = { _A_ 1 _U_ 1 _N_ _S_ "U(P)" {_A_ 1 _U_ 2 _N_ _N_ _F_ _IF_ARGS_ 0 1 X 3 \ (u0 :: Double#) -> case _#_ sinhDouble# [] [u0] of { _PRIM_ (u1 :: Double#) -> _!_ D# [] [u1] } _N_} _F_ _IF_ARGS_ 0 1 C 4 \ (u0 :: Double) -> case u0 of { _ALG_ D# (u1 :: Double#) -> case _#_ sinhDouble# [] [u1] of { _PRIM_ (u2 :: Double#) -> _!_ D# [] [u2] }; _NO_DEFLT_ } _N_ },
+ cosh = { _A_ 1 _U_ 1 _N_ _S_ "U(P)" {_A_ 1 _U_ 2 _N_ _N_ _F_ _IF_ARGS_ 0 1 X 3 \ (u0 :: Double#) -> case _#_ coshDouble# [] [u0] of { _PRIM_ (u1 :: Double#) -> _!_ D# [] [u1] } _N_} _F_ _IF_ARGS_ 0 1 C 4 \ (u0 :: Double) -> case u0 of { _ALG_ D# (u1 :: Double#) -> case _#_ coshDouble# [] [u1] of { _PRIM_ (u2 :: Double#) -> _!_ D# [] [u2] }; _NO_DEFLT_ } _N_ },
+ tanh = { _A_ 1 _U_ 1 _N_ _S_ "U(P)" {_A_ 1 _U_ 2 _N_ _N_ _F_ _IF_ARGS_ 0 1 X 3 \ (u0 :: Double#) -> case _#_ tanhDouble# [] [u0] of { _PRIM_ (u1 :: Double#) -> _!_ D# [] [u1] } _N_} _F_ _IF_ARGS_ 0 1 C 4 \ (u0 :: Double) -> case u0 of { _ALG_ D# (u1 :: Double#) -> case _#_ tanhDouble# [] [u1] of { _PRIM_ (u2 :: Double#) -> _!_ D# [] [u2] }; _NO_DEFLT_ } _N_ },
+ asinh = { _A_ 1 _U_ 1 _N_ _S_ "U(P)" {_A_ 1 _U_ 2 _N_ _N_ _N_ _N_} _N_ _N_ },
+ acosh = { _A_ 1 _U_ 1 _N_ _S_ "U(P)" {_A_ 1 _U_ 2 _N_ _N_ _N_ _N_} _N_ _N_ },
+ atanh = { _A_ 1 _U_ 1 _N_ _S_ "U(P)" {_A_ 1 _U_ 2 _N_ _N_ _N_ _N_} _N_ _N_ } #-}
instance Fractional Double
{-# GHC_PRAGMA _M_ PreludeCore {-dfun-} _A_ 0 _N_ _N_ _N_ _F_ _IF_ARGS_ 0 0 X 5 _!_ _TUP_4 [{{Num Double}}, (Double -> Double -> Double), (Double -> Double), (Ratio Integer -> Double)] [_DFUN_ Num (Double), _CONSTM_ Fractional (/) (Double), _CONSTM_ Fractional recip (Double), _CONSTM_ Fractional fromRational (Double)] _N_
- (/) = _A_ 2 _U_ 11 _N_ _S_ "U(P)U(P)" {_A_ 2 _U_ 22 _N_ _N_ _F_ _IF_ARGS_ 0 2 XX 3 \ (u0 :: Double#) (u1 :: Double#) -> case _#_ divideDouble# [] [u0, u1] of { _PRIM_ (u2 :: Double#) -> _!_ D# [] [u2] } _N_} _F_ _IF_ARGS_ 0 2 CC 5 \ (u0 :: Double) (u1 :: Double) -> case u0 of { _ALG_ D# (u2 :: Double#) -> case u1 of { _ALG_ D# (u3 :: Double#) -> case _#_ divideDouble# [] [u2, u3] of { _PRIM_ (u4 :: Double#) -> _!_ D# [] [u4] }; _NO_DEFLT_ }; _NO_DEFLT_ } _N_,
- recip = _A_ 1 _U_ 1 _N_ _S_ "U(P)" {_A_ 1 _U_ 2 _N_ _N_ _F_ _IF_ARGS_ 0 1 X 3 \ (u0 :: Double#) -> case _#_ divideDouble# [] [1.0000000000000000##, u0] of { _PRIM_ (u1 :: Double#) -> _!_ D# [] [u1] } _N_} _F_ _IF_ARGS_ 0 1 C 4 \ (u0 :: Double) -> case u0 of { _ALG_ D# (u1 :: Double#) -> case _#_ divideDouble# [] [1.0000000000000000##, u1] of { _PRIM_ (u2 :: Double#) -> _!_ D# [] [u2] }; _NO_DEFLT_ } _N_,
- fromRational = _A_ 0 _U_ 2 _N_ _N_ _N_ _N_ #-}
+ (/) = { _A_ 2 _U_ 11 _N_ _S_ "U(P)U(P)" {_A_ 2 _U_ 22 _N_ _N_ _F_ _IF_ARGS_ 0 2 XX 3 \ (u0 :: Double#) (u1 :: Double#) -> case _#_ divideDouble# [] [u0, u1] of { _PRIM_ (u2 :: Double#) -> _!_ D# [] [u2] } _N_} _F_ _IF_ARGS_ 0 2 CC 5 \ (u0 :: Double) (u1 :: Double) -> case u0 of { _ALG_ D# (u2 :: Double#) -> case u1 of { _ALG_ D# (u3 :: Double#) -> case _#_ divideDouble# [] [u2, u3] of { _PRIM_ (u4 :: Double#) -> _!_ D# [] [u4] }; _NO_DEFLT_ }; _NO_DEFLT_ } _N_ },
+ recip = { _A_ 1 _U_ 1 _N_ _S_ "U(P)" {_A_ 1 _U_ 2 _N_ _N_ _F_ _IF_ARGS_ 0 1 X 3 \ (u0 :: Double#) -> case _#_ divideDouble# [] [1.0000000000000000##, u0] of { _PRIM_ (u1 :: Double#) -> _!_ D# [] [u1] } _N_} _F_ _IF_ARGS_ 0 1 C 4 \ (u0 :: Double) -> case u0 of { _ALG_ D# (u1 :: Double#) -> case _#_ divideDouble# [] [1.0000000000000000##, u1] of { _PRIM_ (u2 :: Double#) -> _!_ D# [] [u2] }; _NO_DEFLT_ } _N_ },
+ fromRational = { _A_ 1 _U_ 1 _N_ _S_ "U(U(PPP)U(PPP))" {_A_ 4 _U_ 2222 _N_ _N_ _N_ _N_} _N_ _N_ } #-}
instance Num Double
{-# GHC_PRAGMA _M_ PreludeCore {-dfun-} _A_ 0 _N_ _N_ _N_ _F_ _IF_ARGS_ 0 0 X 11 _!_ _TUP_10 [{{Eq Double}}, {{Text Double}}, (Double -> Double -> Double), (Double -> Double -> Double), (Double -> Double -> Double), (Double -> Double), (Double -> Double), (Double -> Double), (Integer -> Double), (Int -> Double)] [_DFUN_ Eq (Double), _DFUN_ Text (Double), _CONSTM_ Num (+) (Double), _CONSTM_ Num (-) (Double), _CONSTM_ Num (*) (Double), _CONSTM_ Num negate (Double), _CONSTM_ Num abs (Double), _CONSTM_ Num signum (Double), _CONSTM_ Num fromInteger (Double), _CONSTM_ Num fromInt (Double)] _N_
- (+) = _A_ 2 _U_ 11 _N_ _S_ "U(P)U(P)" {_A_ 2 _U_ 22 _N_ _N_ _F_ _IF_ARGS_ 0 2 XX 3 \ (u0 :: Double#) (u1 :: Double#) -> case _#_ plusDouble# [] [u0, u1] of { _PRIM_ (u2 :: Double#) -> _!_ D# [] [u2] } _N_} _F_ _IF_ARGS_ 0 2 CC 5 \ (u0 :: Double) (u1 :: Double) -> case u0 of { _ALG_ D# (u2 :: Double#) -> case u1 of { _ALG_ D# (u3 :: Double#) -> case _#_ plusDouble# [] [u2, u3] of { _PRIM_ (u4 :: Double#) -> _!_ D# [] [u4] }; _NO_DEFLT_ }; _NO_DEFLT_ } _N_,
- (-) = _A_ 2 _U_ 11 _N_ _S_ "U(P)U(P)" {_A_ 2 _U_ 22 _N_ _N_ _F_ _IF_ARGS_ 0 2 XX 3 \ (u0 :: Double#) (u1 :: Double#) -> case _#_ minusDouble# [] [u0, u1] of { _PRIM_ (u2 :: Double#) -> _!_ D# [] [u2] } _N_} _F_ _IF_ARGS_ 0 2 CC 5 \ (u0 :: Double) (u1 :: Double) -> case u0 of { _ALG_ D# (u2 :: Double#) -> case u1 of { _ALG_ D# (u3 :: Double#) -> case _#_ minusDouble# [] [u2, u3] of { _PRIM_ (u4 :: Double#) -> _!_ D# [] [u4] }; _NO_DEFLT_ }; _NO_DEFLT_ } _N_,
- (*) = _A_ 2 _U_ 11 _N_ _S_ "U(P)U(P)" {_A_ 2 _U_ 22 _N_ _N_ _F_ _IF_ARGS_ 0 2 XX 3 \ (u0 :: Double#) (u1 :: Double#) -> case _#_ timesDouble# [] [u0, u1] of { _PRIM_ (u2 :: Double#) -> _!_ D# [] [u2] } _N_} _F_ _IF_ARGS_ 0 2 CC 5 \ (u0 :: Double) (u1 :: Double) -> case u0 of { _ALG_ D# (u2 :: Double#) -> case u1 of { _ALG_ D# (u3 :: Double#) -> case _#_ timesDouble# [] [u2, u3] of { _PRIM_ (u4 :: Double#) -> _!_ D# [] [u4] }; _NO_DEFLT_ }; _NO_DEFLT_ } _N_,
- negate = _A_ 1 _U_ 1 _N_ _S_ "U(P)" {_A_ 1 _U_ 2 _N_ _N_ _F_ _IF_ARGS_ 0 1 X 3 \ (u0 :: Double#) -> case _#_ negateDouble# [] [u0] of { _PRIM_ (u1 :: Double#) -> _!_ D# [] [u1] } _N_} _F_ _IF_ARGS_ 0 1 C 4 \ (u0 :: Double) -> case u0 of { _ALG_ D# (u1 :: Double#) -> case _#_ negateDouble# [] [u1] of { _PRIM_ (u2 :: Double#) -> _!_ D# [] [u2] }; _NO_DEFLT_ } _N_,
- abs = _A_ 1 _U_ 1 _N_ _S_ "U(P)" {_A_ 1 _U_ 2 _N_ _N_ _N_ _N_} _N_ _N_,
- signum = _A_ 1 _U_ 1 _N_ _S_ "U(P)" {_A_ 1 _U_ 2 _N_ _N_ _N_ _N_} _N_ _N_,
- fromInteger = _A_ 1 _U_ 1 _N_ _S_ "U(PPP)" {_A_ 3 _U_ 222 _N_ _N_ _F_ _IF_ARGS_ 0 3 XXX 3 \ (u0 :: Int#) (u1 :: Int#) (u2 :: ByteArray#) -> case _#_ encodeDouble# [] [u0, u1, u2, 0#] of { _PRIM_ (u3 :: Double#) -> _!_ D# [] [u3] } _N_} _F_ _IF_ARGS_ 0 1 C 4 \ (u0 :: Integer) -> case u0 of { _ALG_ J# (u1 :: Int#) (u2 :: Int#) (u3 :: ByteArray#) -> case _#_ encodeDouble# [] [u1, u2, u3, 0#] of { _PRIM_ (u4 :: Double#) -> _!_ D# [] [u4] }; _NO_DEFLT_ } _N_,
- fromInt = _A_ 1 _U_ 1 _N_ _S_ "U(P)" {_A_ 1 _U_ 2 _N_ _N_ _F_ _IF_ARGS_ 0 1 X 3 \ (u0 :: Int#) -> case _#_ int2Double# [] [u0] of { _PRIM_ (u1 :: Double#) -> _!_ D# [] [u1] } _N_} _F_ _IF_ARGS_ 0 1 C 4 \ (u0 :: Int) -> case u0 of { _ALG_ I# (u1 :: Int#) -> case _#_ int2Double# [] [u1] of { _PRIM_ (u2 :: Double#) -> _!_ D# [] [u2] }; _NO_DEFLT_ } _N_ #-}
+ (+) = { _A_ 2 _U_ 11 _N_ _S_ "U(P)U(P)" {_A_ 2 _U_ 22 _N_ _N_ _F_ _IF_ARGS_ 0 2 XX 3 \ (u0 :: Double#) (u1 :: Double#) -> case _#_ plusDouble# [] [u0, u1] of { _PRIM_ (u2 :: Double#) -> _!_ D# [] [u2] } _N_} _F_ _IF_ARGS_ 0 2 CC 5 \ (u0 :: Double) (u1 :: Double) -> case u0 of { _ALG_ D# (u2 :: Double#) -> case u1 of { _ALG_ D# (u3 :: Double#) -> case _#_ plusDouble# [] [u2, u3] of { _PRIM_ (u4 :: Double#) -> _!_ D# [] [u4] }; _NO_DEFLT_ }; _NO_DEFLT_ } _N_ },
+ (-) = { _A_ 2 _U_ 11 _N_ _S_ "U(P)U(P)" {_A_ 2 _U_ 22 _N_ _N_ _F_ _IF_ARGS_ 0 2 XX 3 \ (u0 :: Double#) (u1 :: Double#) -> case _#_ minusDouble# [] [u0, u1] of { _PRIM_ (u2 :: Double#) -> _!_ D# [] [u2] } _N_} _F_ _IF_ARGS_ 0 2 CC 5 \ (u0 :: Double) (u1 :: Double) -> case u0 of { _ALG_ D# (u2 :: Double#) -> case u1 of { _ALG_ D# (u3 :: Double#) -> case _#_ minusDouble# [] [u2, u3] of { _PRIM_ (u4 :: Double#) -> _!_ D# [] [u4] }; _NO_DEFLT_ }; _NO_DEFLT_ } _N_ },
+ (*) = { _A_ 2 _U_ 11 _N_ _S_ "U(P)U(P)" {_A_ 2 _U_ 22 _N_ _N_ _F_ _IF_ARGS_ 0 2 XX 3 \ (u0 :: Double#) (u1 :: Double#) -> case _#_ timesDouble# [] [u0, u1] of { _PRIM_ (u2 :: Double#) -> _!_ D# [] [u2] } _N_} _F_ _IF_ARGS_ 0 2 CC 5 \ (u0 :: Double) (u1 :: Double) -> case u0 of { _ALG_ D# (u2 :: Double#) -> case u1 of { _ALG_ D# (u3 :: Double#) -> case _#_ timesDouble# [] [u2, u3] of { _PRIM_ (u4 :: Double#) -> _!_ D# [] [u4] }; _NO_DEFLT_ }; _NO_DEFLT_ } _N_ },
+ negate = { _A_ 1 _U_ 1 _N_ _S_ "U(P)" {_A_ 1 _U_ 2 _N_ _N_ _F_ _IF_ARGS_ 0 1 X 3 \ (u0 :: Double#) -> case _#_ negateDouble# [] [u0] of { _PRIM_ (u1 :: Double#) -> _!_ D# [] [u1] } _N_} _F_ _IF_ARGS_ 0 1 C 4 \ (u0 :: Double) -> case u0 of { _ALG_ D# (u1 :: Double#) -> case _#_ negateDouble# [] [u1] of { _PRIM_ (u2 :: Double#) -> _!_ D# [] [u2] }; _NO_DEFLT_ } _N_ },
+ abs = { _A_ 1 _U_ 1 _N_ _S_ "U(P)" {_A_ 1 _U_ 2 _N_ _N_ _N_ _N_} _N_ _N_ },
+ signum = { _A_ 1 _U_ 1 _N_ _S_ "U(P)" {_A_ 1 _U_ 2 _N_ _N_ _N_ _N_} _N_ _N_ },
+ fromInteger = { _A_ 1 _U_ 1 _N_ _S_ "U(PPP)" {_A_ 3 _U_ 222 _N_ _N_ _F_ _IF_ARGS_ 0 3 XXX 3 \ (u0 :: Int#) (u1 :: Int#) (u2 :: ByteArray#) -> case _#_ encodeDouble# [] [u0, u1, u2, 0#] of { _PRIM_ (u3 :: Double#) -> _!_ D# [] [u3] } _N_} _F_ _IF_ARGS_ 0 1 C 4 \ (u0 :: Integer) -> case u0 of { _ALG_ J# (u1 :: Int#) (u2 :: Int#) (u3 :: ByteArray#) -> case _#_ encodeDouble# [] [u1, u2, u3, 0#] of { _PRIM_ (u4 :: Double#) -> _!_ D# [] [u4] }; _NO_DEFLT_ } _N_ },
+ fromInt = { _A_ 1 _U_ 1 _N_ _S_ "U(P)" {_A_ 1 _U_ 2 _N_ _N_ _F_ _IF_ARGS_ 0 1 X 3 \ (u0 :: Int#) -> case _#_ int2Double# [] [u0] of { _PRIM_ (u1 :: Double#) -> _!_ D# [] [u1] } _N_} _F_ _IF_ARGS_ 0 1 C 4 \ (u0 :: Int) -> case u0 of { _ALG_ I# (u1 :: Int#) -> case _#_ int2Double# [] [u1] of { _PRIM_ (u2 :: Double#) -> _!_ D# [] [u2] }; _NO_DEFLT_ } _N_ } #-}
instance Ord Double
{-# GHC_PRAGMA _M_ PreludeCore {-dfun-} _A_ 0 _N_ _N_ _N_ _F_ _IF_ARGS_ 0 0 X 9 _!_ _TUP_8 [{{Eq Double}}, (Double -> Double -> Bool), (Double -> Double -> Bool), (Double -> Double -> Bool), (Double -> Double -> Bool), (Double -> Double -> Double), (Double -> Double -> Double), (Double -> Double -> _CMP_TAG)] [_DFUN_ Eq (Double), _CONSTM_ Ord (<) (Double), _CONSTM_ Ord (<=) (Double), _CONSTM_ Ord (>=) (Double), _CONSTM_ Ord (>) (Double), _CONSTM_ Ord max (Double), _CONSTM_ Ord min (Double), _CONSTM_ Ord _tagCmp (Double)] _N_
- (<) = _A_ 2 _U_ 11 _N_ _S_ "U(P)U(P)" {_A_ 2 _U_ 22 _N_ _N_ _F_ _IF_ARGS_ 0 2 XX 1 \ (u0 :: Double#) (u1 :: Double#) -> _#_ ltDouble# [] [u0, u1] _N_} _F_ _IF_ARGS_ 0 2 CC 3 \ (u0 :: Double) (u1 :: Double) -> case u0 of { _ALG_ D# (u2 :: Double#) -> case u1 of { _ALG_ D# (u3 :: Double#) -> _#_ ltDouble# [] [u2, u3]; _NO_DEFLT_ }; _NO_DEFLT_ } _N_,
- (<=) = _A_ 2 _U_ 11 _N_ _S_ "U(P)U(P)" {_A_ 2 _U_ 22 _N_ _N_ _F_ _IF_ARGS_ 0 2 XX 1 \ (u0 :: Double#) (u1 :: Double#) -> _#_ leDouble# [] [u0, u1] _N_} _F_ _IF_ARGS_ 0 2 CC 3 \ (u0 :: Double) (u1 :: Double) -> case u0 of { _ALG_ D# (u2 :: Double#) -> case u1 of { _ALG_ D# (u3 :: Double#) -> _#_ leDouble# [] [u2, u3]; _NO_DEFLT_ }; _NO_DEFLT_ } _N_,
- (>=) = _A_ 2 _U_ 11 _N_ _S_ "U(P)U(P)" {_A_ 2 _U_ 22 _N_ _N_ _F_ _IF_ARGS_ 0 2 XX 1 \ (u0 :: Double#) (u1 :: Double#) -> _#_ geDouble# [] [u0, u1] _N_} _F_ _IF_ARGS_ 0 2 CC 3 \ (u0 :: Double) (u1 :: Double) -> case u0 of { _ALG_ D# (u2 :: Double#) -> case u1 of { _ALG_ D# (u3 :: Double#) -> _#_ geDouble# [] [u2, u3]; _NO_DEFLT_ }; _NO_DEFLT_ } _N_,
- (>) = _A_ 2 _U_ 11 _N_ _S_ "U(P)U(P)" {_A_ 2 _U_ 22 _N_ _N_ _F_ _IF_ARGS_ 0 2 XX 1 \ (u0 :: Double#) (u1 :: Double#) -> _#_ gtDouble# [] [u0, u1] _N_} _F_ _IF_ARGS_ 0 2 CC 3 \ (u0 :: Double) (u1 :: Double) -> case u0 of { _ALG_ D# (u2 :: Double#) -> case u1 of { _ALG_ D# (u3 :: Double#) -> _#_ gtDouble# [] [u2, u3]; _NO_DEFLT_ }; _NO_DEFLT_ } _N_,
- max = _A_ 2 _U_ 11 _N_ _S_ "U(P)U(P)" {_A_ 2 _U_ 22 _N_ _N_ _N_ _N_} _N_ _N_,
- min = _A_ 2 _U_ 11 _N_ _S_ "U(P)U(P)" {_A_ 2 _U_ 22 _N_ _N_ _N_ _N_} _N_ _N_,
- _tagCmp = _A_ 2 _U_ 11 _N_ _S_ "U(P)U(P)" {_A_ 2 _U_ 22 _N_ _N_ _N_ _N_} _N_ _N_ #-}
+ (<) = { _A_ 2 _U_ 11 _N_ _S_ "U(P)U(P)" {_A_ 2 _U_ 22 _N_ _N_ _F_ _IF_ARGS_ 0 2 XX 1 \ (u0 :: Double#) (u1 :: Double#) -> _#_ ltDouble# [] [u0, u1] _N_} _F_ _IF_ARGS_ 0 2 CC 3 \ (u0 :: Double) (u1 :: Double) -> case u0 of { _ALG_ D# (u2 :: Double#) -> case u1 of { _ALG_ D# (u3 :: Double#) -> _#_ ltDouble# [] [u2, u3]; _NO_DEFLT_ }; _NO_DEFLT_ } _N_ },
+ (<=) = { _A_ 2 _U_ 11 _N_ _S_ "U(P)U(P)" {_A_ 2 _U_ 22 _N_ _N_ _F_ _IF_ARGS_ 0 2 XX 1 \ (u0 :: Double#) (u1 :: Double#) -> _#_ leDouble# [] [u0, u1] _N_} _F_ _IF_ARGS_ 0 2 CC 3 \ (u0 :: Double) (u1 :: Double) -> case u0 of { _ALG_ D# (u2 :: Double#) -> case u1 of { _ALG_ D# (u3 :: Double#) -> _#_ leDouble# [] [u2, u3]; _NO_DEFLT_ }; _NO_DEFLT_ } _N_ },
+ (>=) = { _A_ 2 _U_ 11 _N_ _S_ "U(P)U(P)" {_A_ 2 _U_ 22 _N_ _N_ _F_ _IF_ARGS_ 0 2 XX 1 \ (u0 :: Double#) (u1 :: Double#) -> _#_ geDouble# [] [u0, u1] _N_} _F_ _IF_ARGS_ 0 2 CC 3 \ (u0 :: Double) (u1 :: Double) -> case u0 of { _ALG_ D# (u2 :: Double#) -> case u1 of { _ALG_ D# (u3 :: Double#) -> _#_ geDouble# [] [u2, u3]; _NO_DEFLT_ }; _NO_DEFLT_ } _N_ },
+ (>) = { _A_ 2 _U_ 11 _N_ _S_ "U(P)U(P)" {_A_ 2 _U_ 22 _N_ _N_ _F_ _IF_ARGS_ 0 2 XX 1 \ (u0 :: Double#) (u1 :: Double#) -> _#_ gtDouble# [] [u0, u1] _N_} _F_ _IF_ARGS_ 0 2 CC 3 \ (u0 :: Double) (u1 :: Double) -> case u0 of { _ALG_ D# (u2 :: Double#) -> case u1 of { _ALG_ D# (u3 :: Double#) -> _#_ gtDouble# [] [u2, u3]; _NO_DEFLT_ }; _NO_DEFLT_ } _N_ },
+ max = { _A_ 2 _U_ 11 _N_ _S_ "U(P)U(P)" {_A_ 2 _U_ 22 _N_ _N_ _N_ _N_} _N_ _N_ },
+ min = { _A_ 2 _U_ 11 _N_ _S_ "U(P)U(P)" {_A_ 2 _U_ 22 _N_ _N_ _N_ _N_} _N_ _N_ },
+ _tagCmp = { _A_ 2 _U_ 11 _N_ _S_ "U(P)U(P)" {_A_ 2 _U_ 22 _N_ _N_ _N_ _N_} _N_ _N_ } #-}
instance Real Double
{-# GHC_PRAGMA _M_ PreludeCore {-dfun-} _A_ 0 _N_ _N_ _N_ _F_ _IF_ARGS_ 0 0 X 4 _!_ _TUP_3 [{{Num Double}}, {{Enum Double}}, (Double -> Ratio Integer)] [_DFUN_ Num (Double), _DFUN_ Enum (Double), _CONSTM_ Real toRational (Double)] _N_
- toRational = _A_ 1 _U_ 1 _N_ _S_ "U(P)" {_A_ 1 _U_ 2 _N_ _N_ _N_ _N_} _N_ _N_ #-}
+ toRational = { _A_ 1 _U_ 1 _N_ _S_ "U(P)" {_A_ 1 _U_ 2 _N_ _N_ _N_ _N_} _N_ _N_ } #-}
instance RealFloat Double
{-# GHC_PRAGMA _M_ PreludeCore {-dfun-} _A_ 0 _N_ _N_ _N_ _F_ _IF_ARGS_ 0 0 X 11 _!_ _TUP_10 [{{RealFrac Double}}, {{Floating Double}}, (Double -> Integer), (Double -> Int), (Double -> (Int, Int)), (Double -> (Integer, Int)), (Integer -> Int -> Double), (Double -> Int), (Double -> Double), (Int -> Double -> Double)] [_DFUN_ RealFrac (Double), _DFUN_ Floating (Double), _CONSTM_ RealFloat floatRadix (Double), _CONSTM_ RealFloat floatDigits (Double), _CONSTM_ RealFloat floatRange (Double), _CONSTM_ RealFloat decodeFloat (Double), _CONSTM_ RealFloat encodeFloat (Double), _CONSTM_ RealFloat exponent (Double), _CONSTM_ RealFloat significand (Double), _CONSTM_ RealFloat scaleFloat (Double)] _N_
- floatRadix = _A_ 1 _U_ 0 _N_ _S_ "A" {_A_ 0 _N_ _N_ _N_ _F_ _IF_ARGS_ 0 0 X 1 _#_ int2Integer# [] [2#] _N_} _N_ _N_,
- floatDigits = _A_ 1 _U_ 0 _N_ _S_ "A" {_A_ 0 _N_ _N_ _N_ _F_ _IF_ARGS_ 0 0 X 2 _!_ I# [] [53#] _N_} _F_ _IF_ARGS_ 0 1 X 2 \ (u0 :: Double) -> _!_ I# [] [53#] _N_,
- floatRange = _A_ 1 _U_ 0 _N_ _S_ "A" {_A_ 0 _N_ _N_ _N_ _N_ _N_} _N_ _N_,
- decodeFloat = _A_ 1 _U_ 1 _N_ _S_ "U(P)" {_A_ 1 _U_ 2 _N_ _N_ _N_ _N_} _N_ _N_,
- encodeFloat = _A_ 2 _U_ 11 _N_ _S_ "U(PPP)U(P)" {_A_ 4 _U_ 2222 _N_ _N_ _F_ _IF_ARGS_ 0 4 XXXX 3 \ (u0 :: Int#) (u1 :: Int#) (u2 :: ByteArray#) (u3 :: Int#) -> case _#_ encodeDouble# [] [u0, u1, u2, u3] of { _PRIM_ (u4 :: Double#) -> _!_ D# [] [u4] } _N_} _F_ _IF_ARGS_ 0 2 CC 5 \ (u0 :: Integer) (u1 :: Int) -> case u0 of { _ALG_ J# (u2 :: Int#) (u3 :: Int#) (u4 :: ByteArray#) -> case u1 of { _ALG_ I# (u5 :: Int#) -> case _#_ encodeDouble# [] [u2, u3, u4, u5] of { _PRIM_ (u6 :: Double#) -> _!_ D# [] [u6] }; _NO_DEFLT_ }; _NO_DEFLT_ } _N_,
- exponent = _A_ 1 _U_ 2 _N_ _N_ _N_ _N_,
- significand = _A_ 1 _U_ 2 _N_ _N_ _N_ _N_,
- scaleFloat = _A_ 2 _U_ 22 _N_ _N_ _N_ _N_ #-}
+ floatRadix = { _A_ 1 _U_ 0 _N_ _S_ "A" {_A_ 0 _N_ _N_ _N_ _N_ _N_} _N_ _N_ },
+ floatDigits = { _A_ 1 _U_ 0 _N_ _S_ "A" {_A_ 0 _N_ _N_ _N_ _F_ _IF_ARGS_ 0 0 X 2 _!_ I# [] [53#] _N_} _F_ _IF_ARGS_ 0 1 X 2 \ (u0 :: Double) -> _!_ I# [] [53#] _N_ },
+ floatRange = { _A_ 1 _U_ 0 _N_ _S_ "A" {_A_ 0 _N_ _N_ _N_ _N_ _N_} _N_ _N_ },
+ decodeFloat = { _A_ 1 _U_ 1 _N_ _S_ "U(P)" {_A_ 1 _U_ 2 _N_ _N_ _N_ _N_} _N_ _N_ },
+ encodeFloat = { _A_ 2 _U_ 11 _N_ _S_ "U(PPP)U(P)" {_A_ 4 _U_ 2222 _N_ _N_ _F_ _IF_ARGS_ 0 4 XXXX 3 \ (u0 :: Int#) (u1 :: Int#) (u2 :: ByteArray#) (u3 :: Int#) -> case _#_ encodeDouble# [] [u0, u1, u2, u3] of { _PRIM_ (u4 :: Double#) -> _!_ D# [] [u4] } _N_} _F_ _IF_ARGS_ 0 2 CC 5 \ (u0 :: Integer) (u1 :: Int) -> case u0 of { _ALG_ J# (u2 :: Int#) (u3 :: Int#) (u4 :: ByteArray#) -> case u1 of { _ALG_ I# (u5 :: Int#) -> case _#_ encodeDouble# [] [u2, u3, u4, u5] of { _PRIM_ (u6 :: Double#) -> _!_ D# [] [u6] }; _NO_DEFLT_ }; _NO_DEFLT_ } _N_ },
+ exponent = { _A_ 1 _U_ 1 _N_ _S_ "U(P)" {_A_ 1 _U_ 2 _N_ _N_ _N_ _N_} _N_ _N_ },
+ significand = { _A_ 1 _U_ 1 _N_ _S_ "U(P)" {_A_ 1 _U_ 2 _N_ _N_ _N_ _N_} _N_ _N_ },
+ scaleFloat = { _A_ 2 _U_ 11 _N_ _S_ "U(P)U(P)" {_A_ 2 _U_ 22 _N_ _N_ _N_ _N_} _N_ _N_ } #-}
instance RealFrac Double
{-# GHC_PRAGMA _M_ PreludeCore {-dfun-} _A_ 0 _N_ _N_ _N_ _F_ _IF_ARGS_ 0 0 X 8 _!_ _TUP_7 [{{Real Double}}, {{Fractional Double}}, _forall_ a$z1 =>{{Integral a$z1}} -> (Double -> (a$z1, Double)), _forall_ a$z1 =>{{Integral a$z1}} -> (Double -> a$z1), _forall_ a$z1 =>{{Integral a$z1}} -> (Double -> a$z1), _forall_ a$z1 =>{{Integral a$z1}} -> (Double -> a$z1), _forall_ a$z1 =>{{Integral a$z1}} -> (Double -> a$z1)] [_DFUN_ Real (Double), _DFUN_ Fractional (Double), _CONSTM_ RealFrac properFraction (Double), _CONSTM_ RealFrac truncate (Double), _CONSTM_ RealFrac round (Double), _CONSTM_ RealFrac ceiling (Double), _CONSTM_ RealFrac floor (Double)] _N_
- properFraction = _A_ 1 _U_ 22 _N_ _N_ _N_ _N_,
- truncate = _A_ 1 _U_ 22 _N_ _N_ _N_ _N_,
- round = _A_ 1 _U_ 22 _N_ _N_ _N_ _N_,
- ceiling = _A_ 1 _U_ 22 _N_ _N_ _N_ _N_,
- floor = _A_ 1 _U_ 22 _N_ _N_ _N_ _N_ #-}
+ properFraction = { _A_ 1 _U_ 11 _N_ _N_ _N_ _SPECIALISE_ [ Int ] 1 { _A_ 1 _U_ 1 _N_ _S_ "U(P)" {_A_ 1 _U_ 2 _N_ _N_ _N_ _N_} _N_ _N_ }, [ Integer ] 1 { _A_ 1 _U_ 1 _N_ _S_ "U(P)" {_A_ 1 _U_ 2 _N_ _N_ _N_ _N_} _N_ _N_ } },
+ truncate = { _A_ 1 _U_ 11 _N_ _N_ _N_ _SPECIALISE_ [ Int ] 1 { _A_ 1 _U_ 1 _N_ _S_ "U(P)" {_A_ 1 _U_ 2 _N_ _N_ _F_ _IF_ARGS_ 0 1 X 4 \ (u0 :: Double#) -> case _APP_ _WRKR_ _SPEC_ _CONSTM_ RealFrac properFraction (Double) [ (Int) ] [ u0 ] of { _ALG_ _TUP_2 (u1 :: Int) (u2 :: Double) -> u1; _NO_DEFLT_ } _N_} _F_ _IF_ARGS_ 0 1 X 4 \ (u0 :: Double) -> case _APP_ _SPEC_ _CONSTM_ RealFrac properFraction (Double) [ (Int) ] [ u0 ] of { _ALG_ _TUP_2 (u1 :: Int) (u2 :: Double) -> u1; _NO_DEFLT_ } _N_ }, [ Integer ] 1 { _A_ 1 _U_ 1 _N_ _S_ "U(P)" {_A_ 1 _U_ 2 _N_ _N_ _F_ _IF_ARGS_ 0 1 X 4 \ (u0 :: Double#) -> case _APP_ _WRKR_ _SPEC_ _CONSTM_ RealFrac properFraction (Double) [ (Integer) ] [ u0 ] of { _ALG_ _TUP_2 (u1 :: Integer) (u2 :: Double) -> u1; _NO_DEFLT_ } _N_} _F_ _IF_ARGS_ 0 1 X 4 \ (u0 :: Double) -> case _APP_ _SPEC_ _CONSTM_ RealFrac properFraction (Double) [ (Integer) ] [ u0 ] of { _ALG_ _TUP_2 (u1 :: Integer) (u2 :: Double) -> u1; _NO_DEFLT_ } _N_ } },
+ round = { _A_ 1 _U_ 21 _N_ _N_ _N_ _SPECIALISE_ [ Int ] 1 { _A_ 1 _U_ 1 _N_ _S_ "U(P)" {_A_ 1 _U_ 2 _N_ _N_ _N_ _N_} _N_ _N_ }, [ Integer ] 1 { _A_ 1 _U_ 1 _N_ _S_ "U(P)" {_A_ 1 _U_ 2 _N_ _N_ _N_ _N_} _N_ _N_ } },
+ ceiling = { _A_ 1 _U_ 21 _N_ _N_ _N_ _SPECIALISE_ [ Int ] 1 { _A_ 1 _U_ 1 _N_ _S_ "U(P)" {_A_ 1 _U_ 2 _N_ _N_ _N_ _N_} _N_ _N_ }, [ Integer ] 1 { _A_ 1 _U_ 1 _N_ _S_ "U(P)" {_A_ 1 _U_ 2 _N_ _N_ _N_ _N_} _N_ _N_ } },
+ floor = { _A_ 1 _U_ 21 _N_ _N_ _N_ _SPECIALISE_ [ Int ] 1 { _A_ 1 _U_ 1 _N_ _S_ "U(P)" {_A_ 1 _U_ 2 _N_ _N_ _N_ _N_} _N_ _N_ }, [ Integer ] 1 { _A_ 1 _U_ 1 _N_ _S_ "U(P)" {_A_ 1 _U_ 2 _N_ _N_ _N_ _N_} _N_ _N_ } } #-}
instance Text Double
{-# GHC_PRAGMA _M_ PreludeCore {-dfun-} _A_ 0 _N_ _N_ _N_ _F_ _IF_ARGS_ 0 0 X 5 _!_ _TUP_4 [(Int -> [Char] -> [(Double, [Char])]), (Int -> Double -> [Char] -> [Char]), ([Char] -> [([Double], [Char])]), ([Double] -> [Char] -> [Char])] [_CONSTM_ Text readsPrec (Double), _CONSTM_ Text showsPrec (Double), _CONSTM_ Text readList (Double), _CONSTM_ Text showList (Double)] _N_
- readsPrec = _A_ 2 _U_ 02 _N_ _S_ "AL" {_A_ 1 _U_ 2 _N_ _N_ _F_ _IF_ARGS_ 0 1 X 3 \ (u0 :: [Char]) -> _APP_ _SPEC_ _ORIG_ PreludeText readSigned [ (Double) ] [ _SPEC_ _ORIG_ PreludeText readFloat [ (Double) ], u0 ] _N_} _F_ _IF_ARGS_ 0 2 XX 3 \ (u0 :: Int) (u1 :: [Char]) -> _APP_ _SPEC_ _ORIG_ PreludeText readSigned [ (Double) ] [ _SPEC_ _ORIG_ PreludeText readFloat [ (Double) ], u1 ] _N_,
- showsPrec = _A_ 2 _U_ 212 _N_ _S_ "LU(P)" {_A_ 2 _U_ 222 _N_ _N_ _F_ _IF_ARGS_ 0 2 XX 4 \ (u0 :: Int) (u1 :: Double#) -> _APP_ _WRKR_ _SPEC_ _ORIG_ PreludeText showSigned [ (Double) ] [ _SPEC_ _ORIG_ PreludeText showFloat [ (Double) ], u0, u1 ] _N_} _F_ _IF_ARGS_ 0 2 XC 5 \ (u0 :: Int) (u1 :: Double) -> case u1 of { _ALG_ D# (u2 :: Double#) -> _APP_ _WRKR_ _SPEC_ _ORIG_ PreludeText showSigned [ (Double) ] [ _SPEC_ _ORIG_ PreludeText showFloat [ (Double) ], u0, u2 ]; _NO_DEFLT_ } _N_,
- readList = _A_ 0 _U_ 2 _N_ _N_ _N_ _N_,
- showList = _A_ 0 _U_ 12 _N_ _N_ _N_ _N_ #-}
+ readsPrec = { _A_ 2 _U_ 02 _N_ _S_ "AL" {_A_ 1 _U_ 2 _N_ _N_ _F_ _IF_ARGS_ 0 1 X 3 \ (u0 :: [Char]) -> _APP_ _SPEC_ _ORIG_ PreludeText readSigned [ (Double) ] [ _SPEC_ _ORIG_ PreludeText readFloat [ (Double) ], u0 ] _N_} _F_ _IF_ARGS_ 0 2 XX 3 \ (u0 :: Int) (u1 :: [Char]) -> _APP_ _SPEC_ _ORIG_ PreludeText readSigned [ (Double) ] [ _SPEC_ _ORIG_ PreludeText readFloat [ (Double) ], u1 ] _N_ },
+ showsPrec = { _A_ 2 _U_ 212 _N_ _S_ "LU(P)" {_A_ 2 _U_ 222 _N_ _N_ _F_ _IF_ARGS_ 0 2 XX 4 \ (u0 :: Int) (u1 :: Double#) -> _APP_ _WRKR_ _SPEC_ _ORIG_ PreludeText showSigned [ (Double) ] [ _SPEC_ _ORIG_ PreludeText showFloat [ (Double) ], u0, u1 ] _N_} _F_ _IF_ARGS_ 0 2 XC 5 \ (u0 :: Int) (u1 :: Double) -> case u1 of { _ALG_ D# (u2 :: Double#) -> _APP_ _WRKR_ _SPEC_ _ORIG_ PreludeText showSigned [ (Double) ] [ _SPEC_ _ORIG_ PreludeText showFloat [ (Double) ], u0, u2 ]; _NO_DEFLT_ } _N_ },
+ readList = { _A_ 0 _U_ 2 _N_ _N_ _N_ _N_ },
+ showList = { _A_ 1 _U_ 12 _N_ _N_ _N_ _N_ } #-}
instance _CCallable Double
{-# GHC_PRAGMA _M_ PreludeCore {-dfun-} _A_ 0 _N_ _N_ _N_ _F_ _IF_ARGS_ 0 0 X 1 _!_ _TUP_0 [] [] _N_ #-}
instance _CReturnable Double
-{-# GHC_PRAGMA INTERFACE VERSION 5 #-}
+{-# GHC_PRAGMA INTERFACE VERSION 6 #-}
interface PreludeCore where
import PreludeBuiltin(Double(..))
instance Enum Double
{-# GHC_PRAGMA _M_ PreludeCore {-dfun-} _A_ 0 _N_ _N_ _N_ _F_ _IF_ARGS_ 0 0 X 6 _!_ _TUP_5 [{{Ord Double}}, (Double -> [Double]), (Double -> Double -> [Double]), (Double -> Double -> [Double]), (Double -> Double -> Double -> [Double])] [_DFUN_ Ord (Double), _CONSTM_ Enum enumFrom (Double), _CONSTM_ Enum enumFromThen (Double), _CONSTM_ Enum enumFromTo (Double), _CONSTM_ Enum enumFromThenTo (Double)] _N_
- enumFrom = _A_ 1 _U_ 2 _N_ _N_ _N_ _N_,
- enumFromThen = _A_ 2 _U_ 21 _N_ _N_ _N_ _N_,
- enumFromTo = _A_ 2 _U_ 22 _N_ _N_ _N_ _N_,
- enumFromThenTo = _A_ 3 _U_ 222 _N_ _N_ _N_ _N_ #-}
+ enumFrom = { _A_ 1 _U_ 2 _N_ _N_ _N_ _N_ },
+ enumFromThen = { _A_ 2 _U_ 21 _N_ _N_ _N_ _N_ },
+ enumFromTo = { _A_ 2 _U_ 22 _N_ _N_ _N_ _N_ },
+ enumFromThenTo = { _A_ 3 _U_ 222 _N_ _N_ _N_ _N_ } #-}
instance Eq Double
{-# GHC_PRAGMA _M_ PreludeCore {-dfun-} _A_ 0 _N_ _N_ _N_ _F_ _IF_ARGS_ 0 0 X 3 _!_ _TUP_2 [(Double -> Double -> Bool), (Double -> Double -> Bool)] [_CONSTM_ Eq (==) (Double), _CONSTM_ Eq (/=) (Double)] _N_
- (==) = _A_ 2 _U_ 11 _N_ _S_ "U(P)U(P)" {_A_ 2 _U_ 22 _N_ _N_ _F_ _IF_ARGS_ 0 2 XX 1 \ (u0 :: Double#) (u1 :: Double#) -> _#_ eqDouble# [] [u0, u1] _N_} _F_ _IF_ARGS_ 0 2 CC 3 \ (u0 :: Double) (u1 :: Double) -> case u0 of { _ALG_ D# (u2 :: Double#) -> case u1 of { _ALG_ D# (u3 :: Double#) -> _#_ eqDouble# [] [u2, u3]; _NO_DEFLT_ }; _NO_DEFLT_ } _N_,
- (/=) = _A_ 2 _U_ 11 _N_ _S_ "U(P)U(P)" {_A_ 2 _U_ 22 _N_ _N_ _F_ _IF_ARGS_ 0 2 XX 1 \ (u0 :: Double#) (u1 :: Double#) -> _#_ neDouble# [] [u0, u1] _N_} _F_ _IF_ARGS_ 0 2 CC 3 \ (u0 :: Double) (u1 :: Double) -> case u0 of { _ALG_ D# (u2 :: Double#) -> case u1 of { _ALG_ D# (u3 :: Double#) -> _#_ neDouble# [] [u2, u3]; _NO_DEFLT_ }; _NO_DEFLT_ } _N_ #-}
+ (==) = { _A_ 2 _U_ 11 _N_ _S_ "U(P)U(P)" {_A_ 2 _U_ 22 _N_ _N_ _F_ _IF_ARGS_ 0 2 XX 1 \ (u0 :: Double#) (u1 :: Double#) -> _#_ eqDouble# [] [u0, u1] _N_} _F_ _IF_ARGS_ 0 2 CC 3 \ (u0 :: Double) (u1 :: Double) -> case u0 of { _ALG_ D# (u2 :: Double#) -> case u1 of { _ALG_ D# (u3 :: Double#) -> _#_ eqDouble# [] [u2, u3]; _NO_DEFLT_ }; _NO_DEFLT_ } _N_ },
+ (/=) = { _A_ 2 _U_ 11 _N_ _S_ "U(P)U(P)" {_A_ 2 _U_ 22 _N_ _N_ _F_ _IF_ARGS_ 0 2 XX 1 \ (u0 :: Double#) (u1 :: Double#) -> _#_ neDouble# [] [u0, u1] _N_} _F_ _IF_ARGS_ 0 2 CC 3 \ (u0 :: Double) (u1 :: Double) -> case u0 of { _ALG_ D# (u2 :: Double#) -> case u1 of { _ALG_ D# (u3 :: Double#) -> _#_ neDouble# [] [u2, u3]; _NO_DEFLT_ }; _NO_DEFLT_ } _N_ } #-}
instance Floating Double
{-# GHC_PRAGMA _M_ PreludeCore {-dfun-} _A_ 0 _N_ _N_ _N_ _F_ _IF_ARGS_ 0 0 X 20 _!_ _TUP_19 [{{Fractional Double}}, Double, (Double -> Double), (Double -> Double), (Double -> Double), (Double -> Double -> Double), (Double -> Double -> Double), (Double -> Double), (Double -> Double), (Double -> Double), (Double -> Double), (Double -> Double), (Double -> Double), (Double -> Double), (Double -> Double), (Double -> Double), (Double -> Double), (Double -> Double), (Double -> Double)] [_DFUN_ Fractional (Double), _CONSTM_ Floating pi (Double), _CONSTM_ Floating exp (Double), _CONSTM_ Floating log (Double), _CONSTM_ Floating sqrt (Double), _CONSTM_ Floating (**) (Double), _CONSTM_ Floating logBase (Double), _CONSTM_ Floating sin (Double), _CONSTM_ Floating cos (Double), _CONSTM_ Floating tan (Double), _CONSTM_ Floating asin (Double), _CONSTM_ Floating acos (Double), _CONSTM_ Floating atan (Double), _CONSTM_ Floating sinh (Double), _CONSTM_ Floating cosh (Double), _CONSTM_ Floating tanh (Double), _CONSTM_ Floating asinh (Double), _CONSTM_ Floating acosh (Double), _CONSTM_ Floating atanh (Double)] _N_
- pi = _A_ 0 _N_ _N_ _N_ _F_ _IF_ARGS_ 0 0 X 2 _!_ D# [] [3.1415926535897931##] _N_,
- exp = _A_ 1 _U_ 1 _N_ _S_ "U(P)" {_A_ 1 _U_ 2 _N_ _N_ _F_ _IF_ARGS_ 0 1 X 3 \ (u0 :: Double#) -> case _#_ expDouble# [] [u0] of { _PRIM_ (u1 :: Double#) -> _!_ D# [] [u1] } _N_} _F_ _IF_ARGS_ 0 1 C 4 \ (u0 :: Double) -> case u0 of { _ALG_ D# (u1 :: Double#) -> case _#_ expDouble# [] [u1] of { _PRIM_ (u2 :: Double#) -> _!_ D# [] [u2] }; _NO_DEFLT_ } _N_,
- log = _A_ 1 _U_ 1 _N_ _S_ "U(P)" {_A_ 1 _U_ 2 _N_ _N_ _F_ _IF_ARGS_ 0 1 X 3 \ (u0 :: Double#) -> case _#_ logDouble# [] [u0] of { _PRIM_ (u1 :: Double#) -> _!_ D# [] [u1] } _N_} _F_ _IF_ARGS_ 0 1 C 4 \ (u0 :: Double) -> case u0 of { _ALG_ D# (u1 :: Double#) -> case _#_ logDouble# [] [u1] of { _PRIM_ (u2 :: Double#) -> _!_ D# [] [u2] }; _NO_DEFLT_ } _N_,
- sqrt = _A_ 1 _U_ 1 _N_ _S_ "U(P)" {_A_ 1 _U_ 2 _N_ _N_ _F_ _IF_ARGS_ 0 1 X 3 \ (u0 :: Double#) -> case _#_ sqrtDouble# [] [u0] of { _PRIM_ (u1 :: Double#) -> _!_ D# [] [u1] } _N_} _F_ _IF_ARGS_ 0 1 C 4 \ (u0 :: Double) -> case u0 of { _ALG_ D# (u1 :: Double#) -> case _#_ sqrtDouble# [] [u1] of { _PRIM_ (u2 :: Double#) -> _!_ D# [] [u2] }; _NO_DEFLT_ } _N_,
- (**) = _A_ 2 _U_ 11 _N_ _S_ "U(P)U(P)" {_A_ 2 _U_ 22 _N_ _N_ _F_ _IF_ARGS_ 0 2 XX 3 \ (u0 :: Double#) (u1 :: Double#) -> case _#_ powerDouble# [] [u0, u1] of { _PRIM_ (u2 :: Double#) -> _!_ D# [] [u2] } _N_} _F_ _IF_ARGS_ 0 2 CC 5 \ (u0 :: Double) (u1 :: Double) -> case u0 of { _ALG_ D# (u2 :: Double#) -> case u1 of { _ALG_ D# (u3 :: Double#) -> case _#_ powerDouble# [] [u2, u3] of { _PRIM_ (u4 :: Double#) -> _!_ D# [] [u4] }; _NO_DEFLT_ }; _NO_DEFLT_ } _N_,
- logBase = _A_ 2 _U_ 11 _N_ _S_ "U(P)U(P)" {_A_ 2 _U_ 22 _N_ _N_ _F_ _IF_ARGS_ 0 2 XX 5 \ (u0 :: Double#) (u1 :: Double#) -> case _#_ logDouble# [] [u1] of { _PRIM_ (u2 :: Double#) -> case _#_ logDouble# [] [u0] of { _PRIM_ (u3 :: Double#) -> case _#_ divideDouble# [] [u2, u3] of { _PRIM_ (u4 :: Double#) -> _!_ D# [] [u4] } } } _N_} _F_ _IF_ARGS_ 0 2 CC 7 \ (u0 :: Double) (u1 :: Double) -> case u1 of { _ALG_ D# (u2 :: Double#) -> case _#_ logDouble# [] [u2] of { _PRIM_ (u3 :: Double#) -> case u0 of { _ALG_ D# (u4 :: Double#) -> case _#_ logDouble# [] [u4] of { _PRIM_ (u5 :: Double#) -> case _#_ divideDouble# [] [u3, u5] of { _PRIM_ (u6 :: Double#) -> _!_ D# [] [u6] } }; _NO_DEFLT_ } }; _NO_DEFLT_ } _N_,
- sin = _A_ 1 _U_ 1 _N_ _S_ "U(P)" {_A_ 1 _U_ 2 _N_ _N_ _F_ _IF_ARGS_ 0 1 X 3 \ (u0 :: Double#) -> case _#_ sinDouble# [] [u0] of { _PRIM_ (u1 :: Double#) -> _!_ D# [] [u1] } _N_} _F_ _IF_ARGS_ 0 1 C 4 \ (u0 :: Double) -> case u0 of { _ALG_ D# (u1 :: Double#) -> case _#_ sinDouble# [] [u1] of { _PRIM_ (u2 :: Double#) -> _!_ D# [] [u2] }; _NO_DEFLT_ } _N_,
- cos = _A_ 1 _U_ 1 _N_ _S_ "U(P)" {_A_ 1 _U_ 2 _N_ _N_ _F_ _IF_ARGS_ 0 1 X 3 \ (u0 :: Double#) -> case _#_ cosDouble# [] [u0] of { _PRIM_ (u1 :: Double#) -> _!_ D# [] [u1] } _N_} _F_ _IF_ARGS_ 0 1 C 4 \ (u0 :: Double) -> case u0 of { _ALG_ D# (u1 :: Double#) -> case _#_ cosDouble# [] [u1] of { _PRIM_ (u2 :: Double#) -> _!_ D# [] [u2] }; _NO_DEFLT_ } _N_,
- tan = _A_ 1 _U_ 1 _N_ _S_ "U(P)" {_A_ 1 _U_ 2 _N_ _N_ _F_ _IF_ARGS_ 0 1 X 3 \ (u0 :: Double#) -> case _#_ tanDouble# [] [u0] of { _PRIM_ (u1 :: Double#) -> _!_ D# [] [u1] } _N_} _F_ _IF_ARGS_ 0 1 C 4 \ (u0 :: Double) -> case u0 of { _ALG_ D# (u1 :: Double#) -> case _#_ tanDouble# [] [u1] of { _PRIM_ (u2 :: Double#) -> _!_ D# [] [u2] }; _NO_DEFLT_ } _N_,
- asin = _A_ 1 _U_ 1 _N_ _S_ "U(P)" {_A_ 1 _U_ 2 _N_ _N_ _F_ _IF_ARGS_ 0 1 X 3 \ (u0 :: Double#) -> case _#_ asinDouble# [] [u0] of { _PRIM_ (u1 :: Double#) -> _!_ D# [] [u1] } _N_} _F_ _IF_ARGS_ 0 1 C 4 \ (u0 :: Double) -> case u0 of { _ALG_ D# (u1 :: Double#) -> case _#_ asinDouble# [] [u1] of { _PRIM_ (u2 :: Double#) -> _!_ D# [] [u2] }; _NO_DEFLT_ } _N_,
- acos = _A_ 1 _U_ 1 _N_ _S_ "U(P)" {_A_ 1 _U_ 2 _N_ _N_ _F_ _IF_ARGS_ 0 1 X 3 \ (u0 :: Double#) -> case _#_ acosDouble# [] [u0] of { _PRIM_ (u1 :: Double#) -> _!_ D# [] [u1] } _N_} _F_ _IF_ARGS_ 0 1 C 4 \ (u0 :: Double) -> case u0 of { _ALG_ D# (u1 :: Double#) -> case _#_ acosDouble# [] [u1] of { _PRIM_ (u2 :: Double#) -> _!_ D# [] [u2] }; _NO_DEFLT_ } _N_,
- atan = _A_ 1 _U_ 1 _N_ _S_ "U(P)" {_A_ 1 _U_ 2 _N_ _N_ _F_ _IF_ARGS_ 0 1 X 3 \ (u0 :: Double#) -> case _#_ atanDouble# [] [u0] of { _PRIM_ (u1 :: Double#) -> _!_ D# [] [u1] } _N_} _F_ _IF_ARGS_ 0 1 C 4 \ (u0 :: Double) -> case u0 of { _ALG_ D# (u1 :: Double#) -> case _#_ atanDouble# [] [u1] of { _PRIM_ (u2 :: Double#) -> _!_ D# [] [u2] }; _NO_DEFLT_ } _N_,
- sinh = _A_ 1 _U_ 1 _N_ _S_ "U(P)" {_A_ 1 _U_ 2 _N_ _N_ _F_ _IF_ARGS_ 0 1 X 3 \ (u0 :: Double#) -> case _#_ sinhDouble# [] [u0] of { _PRIM_ (u1 :: Double#) -> _!_ D# [] [u1] } _N_} _F_ _IF_ARGS_ 0 1 C 4 \ (u0 :: Double) -> case u0 of { _ALG_ D# (u1 :: Double#) -> case _#_ sinhDouble# [] [u1] of { _PRIM_ (u2 :: Double#) -> _!_ D# [] [u2] }; _NO_DEFLT_ } _N_,
- cosh = _A_ 1 _U_ 1 _N_ _S_ "U(P)" {_A_ 1 _U_ 2 _N_ _N_ _F_ _IF_ARGS_ 0 1 X 3 \ (u0 :: Double#) -> case _#_ coshDouble# [] [u0] of { _PRIM_ (u1 :: Double#) -> _!_ D# [] [u1] } _N_} _F_ _IF_ARGS_ 0 1 C 4 \ (u0 :: Double) -> case u0 of { _ALG_ D# (u1 :: Double#) -> case _#_ coshDouble# [] [u1] of { _PRIM_ (u2 :: Double#) -> _!_ D# [] [u2] }; _NO_DEFLT_ } _N_,
- tanh = _A_ 1 _U_ 1 _N_ _S_ "U(P)" {_A_ 1 _U_ 2 _N_ _N_ _F_ _IF_ARGS_ 0 1 X 3 \ (u0 :: Double#) -> case _#_ tanhDouble# [] [u0] of { _PRIM_ (u1 :: Double#) -> _!_ D# [] [u1] } _N_} _F_ _IF_ARGS_ 0 1 C 4 \ (u0 :: Double) -> case u0 of { _ALG_ D# (u1 :: Double#) -> case _#_ tanhDouble# [] [u1] of { _PRIM_ (u2 :: Double#) -> _!_ D# [] [u2] }; _NO_DEFLT_ } _N_,
- asinh = _A_ 1 _U_ 1 _N_ _S_ "U(P)" {_A_ 1 _U_ 2 _N_ _N_ _N_ _N_} _N_ _N_,
- acosh = _A_ 1 _U_ 1 _N_ _S_ "U(P)" {_A_ 1 _U_ 2 _N_ _N_ _N_ _N_} _N_ _N_,
- atanh = _A_ 1 _U_ 1 _N_ _S_ "U(P)" {_A_ 1 _U_ 2 _N_ _N_ _N_ _N_} _N_ _N_ #-}
+ pi = { _A_ 0 _N_ _N_ _N_ _F_ _IF_ARGS_ 0 0 X 2 _!_ D# [] [3.1415926535897931##] _N_ },
+ exp = { _A_ 1 _U_ 1 _N_ _S_ "U(P)" {_A_ 1 _U_ 2 _N_ _N_ _F_ _IF_ARGS_ 0 1 X 3 \ (u0 :: Double#) -> case _#_ expDouble# [] [u0] of { _PRIM_ (u1 :: Double#) -> _!_ D# [] [u1] } _N_} _F_ _IF_ARGS_ 0 1 C 4 \ (u0 :: Double) -> case u0 of { _ALG_ D# (u1 :: Double#) -> case _#_ expDouble# [] [u1] of { _PRIM_ (u2 :: Double#) -> _!_ D# [] [u2] }; _NO_DEFLT_ } _N_ },
+ log = { _A_ 1 _U_ 1 _N_ _S_ "U(P)" {_A_ 1 _U_ 2 _N_ _N_ _F_ _IF_ARGS_ 0 1 X 3 \ (u0 :: Double#) -> case _#_ logDouble# [] [u0] of { _PRIM_ (u1 :: Double#) -> _!_ D# [] [u1] } _N_} _F_ _IF_ARGS_ 0 1 C 4 \ (u0 :: Double) -> case u0 of { _ALG_ D# (u1 :: Double#) -> case _#_ logDouble# [] [u1] of { _PRIM_ (u2 :: Double#) -> _!_ D# [] [u2] }; _NO_DEFLT_ } _N_ },
+ sqrt = { _A_ 1 _U_ 1 _N_ _S_ "U(P)" {_A_ 1 _U_ 2 _N_ _N_ _F_ _IF_ARGS_ 0 1 X 3 \ (u0 :: Double#) -> case _#_ sqrtDouble# [] [u0] of { _PRIM_ (u1 :: Double#) -> _!_ D# [] [u1] } _N_} _F_ _IF_ARGS_ 0 1 C 4 \ (u0 :: Double) -> case u0 of { _ALG_ D# (u1 :: Double#) -> case _#_ sqrtDouble# [] [u1] of { _PRIM_ (u2 :: Double#) -> _!_ D# [] [u2] }; _NO_DEFLT_ } _N_ },
+ (**) = { _A_ 2 _U_ 11 _N_ _S_ "U(P)U(P)" {_A_ 2 _U_ 22 _N_ _N_ _F_ _IF_ARGS_ 0 2 XX 3 \ (u0 :: Double#) (u1 :: Double#) -> case _#_ powerDouble# [] [u0, u1] of { _PRIM_ (u2 :: Double#) -> _!_ D# [] [u2] } _N_} _F_ _IF_ARGS_ 0 2 CC 5 \ (u0 :: Double) (u1 :: Double) -> case u0 of { _ALG_ D# (u2 :: Double#) -> case u1 of { _ALG_ D# (u3 :: Double#) -> case _#_ powerDouble# [] [u2, u3] of { _PRIM_ (u4 :: Double#) -> _!_ D# [] [u4] }; _NO_DEFLT_ }; _NO_DEFLT_ } _N_ },
+ logBase = { _A_ 2 _U_ 11 _N_ _S_ "U(P)U(P)" {_A_ 2 _U_ 22 _N_ _N_ _F_ _IF_ARGS_ 0 2 XX 5 \ (u0 :: Double#) (u1 :: Double#) -> case _#_ logDouble# [] [u1] of { _PRIM_ (u2 :: Double#) -> case _#_ logDouble# [] [u0] of { _PRIM_ (u3 :: Double#) -> case _#_ divideDouble# [] [u2, u3] of { _PRIM_ (u4 :: Double#) -> _!_ D# [] [u4] } } } _N_} _F_ _IF_ARGS_ 0 2 CC 7 \ (u0 :: Double) (u1 :: Double) -> case u1 of { _ALG_ D# (u2 :: Double#) -> case _#_ logDouble# [] [u2] of { _PRIM_ (u3 :: Double#) -> case u0 of { _ALG_ D# (u4 :: Double#) -> case _#_ logDouble# [] [u4] of { _PRIM_ (u5 :: Double#) -> case _#_ divideDouble# [] [u3, u5] of { _PRIM_ (u6 :: Double#) -> _!_ D# [] [u6] } }; _NO_DEFLT_ } }; _NO_DEFLT_ } _N_ },
+ sin = { _A_ 1 _U_ 1 _N_ _S_ "U(P)" {_A_ 1 _U_ 2 _N_ _N_ _F_ _IF_ARGS_ 0 1 X 3 \ (u0 :: Double#) -> case _#_ sinDouble# [] [u0] of { _PRIM_ (u1 :: Double#) -> _!_ D# [] [u1] } _N_} _F_ _IF_ARGS_ 0 1 C 4 \ (u0 :: Double) -> case u0 of { _ALG_ D# (u1 :: Double#) -> case _#_ sinDouble# [] [u1] of { _PRIM_ (u2 :: Double#) -> _!_ D# [] [u2] }; _NO_DEFLT_ } _N_ },
+ cos = { _A_ 1 _U_ 1 _N_ _S_ "U(P)" {_A_ 1 _U_ 2 _N_ _N_ _F_ _IF_ARGS_ 0 1 X 3 \ (u0 :: Double#) -> case _#_ cosDouble# [] [u0] of { _PRIM_ (u1 :: Double#) -> _!_ D# [] [u1] } _N_} _F_ _IF_ARGS_ 0 1 C 4 \ (u0 :: Double) -> case u0 of { _ALG_ D# (u1 :: Double#) -> case _#_ cosDouble# [] [u1] of { _PRIM_ (u2 :: Double#) -> _!_ D# [] [u2] }; _NO_DEFLT_ } _N_ },
+ tan = { _A_ 1 _U_ 1 _N_ _S_ "U(P)" {_A_ 1 _U_ 2 _N_ _N_ _F_ _IF_ARGS_ 0 1 X 3 \ (u0 :: Double#) -> case _#_ tanDouble# [] [u0] of { _PRIM_ (u1 :: Double#) -> _!_ D# [] [u1] } _N_} _F_ _IF_ARGS_ 0 1 C 4 \ (u0 :: Double) -> case u0 of { _ALG_ D# (u1 :: Double#) -> case _#_ tanDouble# [] [u1] of { _PRIM_ (u2 :: Double#) -> _!_ D# [] [u2] }; _NO_DEFLT_ } _N_ },
+ asin = { _A_ 1 _U_ 1 _N_ _S_ "U(P)" {_A_ 1 _U_ 2 _N_ _N_ _F_ _IF_ARGS_ 0 1 X 3 \ (u0 :: Double#) -> case _#_ asinDouble# [] [u0] of { _PRIM_ (u1 :: Double#) -> _!_ D# [] [u1] } _N_} _F_ _IF_ARGS_ 0 1 C 4 \ (u0 :: Double) -> case u0 of { _ALG_ D# (u1 :: Double#) -> case _#_ asinDouble# [] [u1] of { _PRIM_ (u2 :: Double#) -> _!_ D# [] [u2] }; _NO_DEFLT_ } _N_ },
+ acos = { _A_ 1 _U_ 1 _N_ _S_ "U(P)" {_A_ 1 _U_ 2 _N_ _N_ _F_ _IF_ARGS_ 0 1 X 3 \ (u0 :: Double#) -> case _#_ acosDouble# [] [u0] of { _PRIM_ (u1 :: Double#) -> _!_ D# [] [u1] } _N_} _F_ _IF_ARGS_ 0 1 C 4 \ (u0 :: Double) -> case u0 of { _ALG_ D# (u1 :: Double#) -> case _#_ acosDouble# [] [u1] of { _PRIM_ (u2 :: Double#) -> _!_ D# [] [u2] }; _NO_DEFLT_ } _N_ },
+ atan = { _A_ 1 _U_ 1 _N_ _S_ "U(P)" {_A_ 1 _U_ 2 _N_ _N_ _F_ _IF_ARGS_ 0 1 X 3 \ (u0 :: Double#) -> case _#_ atanDouble# [] [u0] of { _PRIM_ (u1 :: Double#) -> _!_ D# [] [u1] } _N_} _F_ _IF_ARGS_ 0 1 C 4 \ (u0 :: Double) -> case u0 of { _ALG_ D# (u1 :: Double#) -> case _#_ atanDouble# [] [u1] of { _PRIM_ (u2 :: Double#) -> _!_ D# [] [u2] }; _NO_DEFLT_ } _N_ },
+ sinh = { _A_ 1 _U_ 1 _N_ _S_ "U(P)" {_A_ 1 _U_ 2 _N_ _N_ _F_ _IF_ARGS_ 0 1 X 3 \ (u0 :: Double#) -> case _#_ sinhDouble# [] [u0] of { _PRIM_ (u1 :: Double#) -> _!_ D# [] [u1] } _N_} _F_ _IF_ARGS_ 0 1 C 4 \ (u0 :: Double) -> case u0 of { _ALG_ D# (u1 :: Double#) -> case _#_ sinhDouble# [] [u1] of { _PRIM_ (u2 :: Double#) -> _!_ D# [] [u2] }; _NO_DEFLT_ } _N_ },
+ cosh = { _A_ 1 _U_ 1 _N_ _S_ "U(P)" {_A_ 1 _U_ 2 _N_ _N_ _F_ _IF_ARGS_ 0 1 X 3 \ (u0 :: Double#) -> case _#_ coshDouble# [] [u0] of { _PRIM_ (u1 :: Double#) -> _!_ D# [] [u1] } _N_} _F_ _IF_ARGS_ 0 1 C 4 \ (u0 :: Double) -> case u0 of { _ALG_ D# (u1 :: Double#) -> case _#_ coshDouble# [] [u1] of { _PRIM_ (u2 :: Double#) -> _!_ D# [] [u2] }; _NO_DEFLT_ } _N_ },
+ tanh = { _A_ 1 _U_ 1 _N_ _S_ "U(P)" {_A_ 1 _U_ 2 _N_ _N_ _F_ _IF_ARGS_ 0 1 X 3 \ (u0 :: Double#) -> case _#_ tanhDouble# [] [u0] of { _PRIM_ (u1 :: Double#) -> _!_ D# [] [u1] } _N_} _F_ _IF_ARGS_ 0 1 C 4 \ (u0 :: Double) -> case u0 of { _ALG_ D# (u1 :: Double#) -> case _#_ tanhDouble# [] [u1] of { _PRIM_ (u2 :: Double#) -> _!_ D# [] [u2] }; _NO_DEFLT_ } _N_ },
+ asinh = { _A_ 1 _U_ 1 _N_ _S_ "U(P)" {_A_ 1 _U_ 2 _N_ _N_ _N_ _N_} _N_ _N_ },
+ acosh = { _A_ 1 _U_ 1 _N_ _S_ "U(P)" {_A_ 1 _U_ 2 _N_ _N_ _N_ _N_} _N_ _N_ },
+ atanh = { _A_ 1 _U_ 1 _N_ _S_ "U(P)" {_A_ 1 _U_ 2 _N_ _N_ _N_ _N_} _N_ _N_ } #-}
instance Fractional Double
{-# GHC_PRAGMA _M_ PreludeCore {-dfun-} _A_ 0 _N_ _N_ _N_ _F_ _IF_ARGS_ 0 0 X 5 _!_ _TUP_4 [{{Num Double}}, (Double -> Double -> Double), (Double -> Double), (Ratio Integer -> Double)] [_DFUN_ Num (Double), _CONSTM_ Fractional (/) (Double), _CONSTM_ Fractional recip (Double), _CONSTM_ Fractional fromRational (Double)] _N_
- (/) = _A_ 2 _U_ 11 _N_ _S_ "U(P)U(P)" {_A_ 2 _U_ 22 _N_ _N_ _F_ _IF_ARGS_ 0 2 XX 3 \ (u0 :: Double#) (u1 :: Double#) -> case _#_ divideDouble# [] [u0, u1] of { _PRIM_ (u2 :: Double#) -> _!_ D# [] [u2] } _N_} _F_ _IF_ARGS_ 0 2 CC 5 \ (u0 :: Double) (u1 :: Double) -> case u0 of { _ALG_ D# (u2 :: Double#) -> case u1 of { _ALG_ D# (u3 :: Double#) -> case _#_ divideDouble# [] [u2, u3] of { _PRIM_ (u4 :: Double#) -> _!_ D# [] [u4] }; _NO_DEFLT_ }; _NO_DEFLT_ } _N_,
- recip = _A_ 1 _U_ 1 _N_ _S_ "U(P)" {_A_ 1 _U_ 2 _N_ _N_ _F_ _IF_ARGS_ 0 1 X 3 \ (u0 :: Double#) -> case _#_ divideDouble# [] [1.0000000000000000##, u0] of { _PRIM_ (u1 :: Double#) -> _!_ D# [] [u1] } _N_} _F_ _IF_ARGS_ 0 1 C 4 \ (u0 :: Double) -> case u0 of { _ALG_ D# (u1 :: Double#) -> case _#_ divideDouble# [] [1.0000000000000000##, u1] of { _PRIM_ (u2 :: Double#) -> _!_ D# [] [u2] }; _NO_DEFLT_ } _N_,
- fromRational = _A_ 0 _U_ 2 _N_ _N_ _N_ _N_ #-}
+ (/) = { _A_ 2 _U_ 11 _N_ _S_ "U(P)U(P)" {_A_ 2 _U_ 22 _N_ _N_ _F_ _IF_ARGS_ 0 2 XX 3 \ (u0 :: Double#) (u1 :: Double#) -> case _#_ divideDouble# [] [u0, u1] of { _PRIM_ (u2 :: Double#) -> _!_ D# [] [u2] } _N_} _F_ _IF_ARGS_ 0 2 CC 5 \ (u0 :: Double) (u1 :: Double) -> case u0 of { _ALG_ D# (u2 :: Double#) -> case u1 of { _ALG_ D# (u3 :: Double#) -> case _#_ divideDouble# [] [u2, u3] of { _PRIM_ (u4 :: Double#) -> _!_ D# [] [u4] }; _NO_DEFLT_ }; _NO_DEFLT_ } _N_ },
+ recip = { _A_ 1 _U_ 1 _N_ _S_ "U(P)" {_A_ 1 _U_ 2 _N_ _N_ _F_ _IF_ARGS_ 0 1 X 3 \ (u0 :: Double#) -> case _#_ divideDouble# [] [1.0000000000000000##, u0] of { _PRIM_ (u1 :: Double#) -> _!_ D# [] [u1] } _N_} _F_ _IF_ARGS_ 0 1 C 4 \ (u0 :: Double) -> case u0 of { _ALG_ D# (u1 :: Double#) -> case _#_ divideDouble# [] [1.0000000000000000##, u1] of { _PRIM_ (u2 :: Double#) -> _!_ D# [] [u2] }; _NO_DEFLT_ } _N_ },
+ fromRational = { _A_ 1 _U_ 1 _N_ _S_ "U(U(PPP)U(PPP))" {_A_ 4 _U_ 2222 _N_ _N_ _N_ _N_} _N_ _N_ } #-}
instance Num Double
{-# GHC_PRAGMA _M_ PreludeCore {-dfun-} _A_ 0 _N_ _N_ _N_ _F_ _IF_ARGS_ 0 0 X 11 _!_ _TUP_10 [{{Eq Double}}, {{Text Double}}, (Double -> Double -> Double), (Double -> Double -> Double), (Double -> Double -> Double), (Double -> Double), (Double -> Double), (Double -> Double), (Integer -> Double), (Int -> Double)] [_DFUN_ Eq (Double), _DFUN_ Text (Double), _CONSTM_ Num (+) (Double), _CONSTM_ Num (-) (Double), _CONSTM_ Num (*) (Double), _CONSTM_ Num negate (Double), _CONSTM_ Num abs (Double), _CONSTM_ Num signum (Double), _CONSTM_ Num fromInteger (Double), _CONSTM_ Num fromInt (Double)] _N_
- (+) = _A_ 2 _U_ 11 _N_ _S_ "U(P)U(P)" {_A_ 2 _U_ 22 _N_ _N_ _F_ _IF_ARGS_ 0 2 XX 3 \ (u0 :: Double#) (u1 :: Double#) -> case _#_ plusDouble# [] [u0, u1] of { _PRIM_ (u2 :: Double#) -> _!_ D# [] [u2] } _N_} _F_ _IF_ARGS_ 0 2 CC 5 \ (u0 :: Double) (u1 :: Double) -> case u0 of { _ALG_ D# (u2 :: Double#) -> case u1 of { _ALG_ D# (u3 :: Double#) -> case _#_ plusDouble# [] [u2, u3] of { _PRIM_ (u4 :: Double#) -> _!_ D# [] [u4] }; _NO_DEFLT_ }; _NO_DEFLT_ } _N_,
- (-) = _A_ 2 _U_ 11 _N_ _S_ "U(P)U(P)" {_A_ 2 _U_ 22 _N_ _N_ _F_ _IF_ARGS_ 0 2 XX 3 \ (u0 :: Double#) (u1 :: Double#) -> case _#_ minusDouble# [] [u0, u1] of { _PRIM_ (u2 :: Double#) -> _!_ D# [] [u2] } _N_} _F_ _IF_ARGS_ 0 2 CC 5 \ (u0 :: Double) (u1 :: Double) -> case u0 of { _ALG_ D# (u2 :: Double#) -> case u1 of { _ALG_ D# (u3 :: Double#) -> case _#_ minusDouble# [] [u2, u3] of { _PRIM_ (u4 :: Double#) -> _!_ D# [] [u4] }; _NO_DEFLT_ }; _NO_DEFLT_ } _N_,
- (*) = _A_ 2 _U_ 11 _N_ _S_ "U(P)U(P)" {_A_ 2 _U_ 22 _N_ _N_ _F_ _IF_ARGS_ 0 2 XX 3 \ (u0 :: Double#) (u1 :: Double#) -> case _#_ timesDouble# [] [u0, u1] of { _PRIM_ (u2 :: Double#) -> _!_ D# [] [u2] } _N_} _F_ _IF_ARGS_ 0 2 CC 5 \ (u0 :: Double) (u1 :: Double) -> case u0 of { _ALG_ D# (u2 :: Double#) -> case u1 of { _ALG_ D# (u3 :: Double#) -> case _#_ timesDouble# [] [u2, u3] of { _PRIM_ (u4 :: Double#) -> _!_ D# [] [u4] }; _NO_DEFLT_ }; _NO_DEFLT_ } _N_,
- negate = _A_ 1 _U_ 1 _N_ _S_ "U(P)" {_A_ 1 _U_ 2 _N_ _N_ _F_ _IF_ARGS_ 0 1 X 3 \ (u0 :: Double#) -> case _#_ negateDouble# [] [u0] of { _PRIM_ (u1 :: Double#) -> _!_ D# [] [u1] } _N_} _F_ _IF_ARGS_ 0 1 C 4 \ (u0 :: Double) -> case u0 of { _ALG_ D# (u1 :: Double#) -> case _#_ negateDouble# [] [u1] of { _PRIM_ (u2 :: Double#) -> _!_ D# [] [u2] }; _NO_DEFLT_ } _N_,
- abs = _A_ 1 _U_ 1 _N_ _S_ "U(P)" {_A_ 1 _U_ 2 _N_ _N_ _N_ _N_} _N_ _N_,
- signum = _A_ 1 _U_ 1 _N_ _S_ "U(P)" {_A_ 1 _U_ 2 _N_ _N_ _N_ _N_} _N_ _N_,
- fromInteger = _A_ 1 _U_ 1 _N_ _S_ "U(PPP)" {_A_ 3 _U_ 222 _N_ _N_ _F_ _IF_ARGS_ 0 3 XXX 3 \ (u0 :: Int#) (u1 :: Int#) (u2 :: ByteArray#) -> case _#_ encodeDouble# [] [u0, u1, u2, 0#] of { _PRIM_ (u3 :: Double#) -> _!_ D# [] [u3] } _N_} _F_ _IF_ARGS_ 0 1 C 4 \ (u0 :: Integer) -> case u0 of { _ALG_ J# (u1 :: Int#) (u2 :: Int#) (u3 :: ByteArray#) -> case _#_ encodeDouble# [] [u1, u2, u3, 0#] of { _PRIM_ (u4 :: Double#) -> _!_ D# [] [u4] }; _NO_DEFLT_ } _N_,
- fromInt = _A_ 1 _U_ 1 _N_ _S_ "U(P)" {_A_ 1 _U_ 2 _N_ _N_ _F_ _IF_ARGS_ 0 1 X 3 \ (u0 :: Int#) -> case _#_ int2Double# [] [u0] of { _PRIM_ (u1 :: Double#) -> _!_ D# [] [u1] } _N_} _F_ _IF_ARGS_ 0 1 C 4 \ (u0 :: Int) -> case u0 of { _ALG_ I# (u1 :: Int#) -> case _#_ int2Double# [] [u1] of { _PRIM_ (u2 :: Double#) -> _!_ D# [] [u2] }; _NO_DEFLT_ } _N_ #-}
+ (+) = { _A_ 2 _U_ 11 _N_ _S_ "U(P)U(P)" {_A_ 2 _U_ 22 _N_ _N_ _F_ _IF_ARGS_ 0 2 XX 3 \ (u0 :: Double#) (u1 :: Double#) -> case _#_ plusDouble# [] [u0, u1] of { _PRIM_ (u2 :: Double#) -> _!_ D# [] [u2] } _N_} _F_ _IF_ARGS_ 0 2 CC 5 \ (u0 :: Double) (u1 :: Double) -> case u0 of { _ALG_ D# (u2 :: Double#) -> case u1 of { _ALG_ D# (u3 :: Double#) -> case _#_ plusDouble# [] [u2, u3] of { _PRIM_ (u4 :: Double#) -> _!_ D# [] [u4] }; _NO_DEFLT_ }; _NO_DEFLT_ } _N_ },
+ (-) = { _A_ 2 _U_ 11 _N_ _S_ "U(P)U(P)" {_A_ 2 _U_ 22 _N_ _N_ _F_ _IF_ARGS_ 0 2 XX 3 \ (u0 :: Double#) (u1 :: Double#) -> case _#_ minusDouble# [] [u0, u1] of { _PRIM_ (u2 :: Double#) -> _!_ D# [] [u2] } _N_} _F_ _IF_ARGS_ 0 2 CC 5 \ (u0 :: Double) (u1 :: Double) -> case u0 of { _ALG_ D# (u2 :: Double#) -> case u1 of { _ALG_ D# (u3 :: Double#) -> case _#_ minusDouble# [] [u2, u3] of { _PRIM_ (u4 :: Double#) -> _!_ D# [] [u4] }; _NO_DEFLT_ }; _NO_DEFLT_ } _N_ },
+ (*) = { _A_ 2 _U_ 11 _N_ _S_ "U(P)U(P)" {_A_ 2 _U_ 22 _N_ _N_ _F_ _IF_ARGS_ 0 2 XX 3 \ (u0 :: Double#) (u1 :: Double#) -> case _#_ timesDouble# [] [u0, u1] of { _PRIM_ (u2 :: Double#) -> _!_ D# [] [u2] } _N_} _F_ _IF_ARGS_ 0 2 CC 5 \ (u0 :: Double) (u1 :: Double) -> case u0 of { _ALG_ D# (u2 :: Double#) -> case u1 of { _ALG_ D# (u3 :: Double#) -> case _#_ timesDouble# [] [u2, u3] of { _PRIM_ (u4 :: Double#) -> _!_ D# [] [u4] }; _NO_DEFLT_ }; _NO_DEFLT_ } _N_ },
+ negate = { _A_ 1 _U_ 1 _N_ _S_ "U(P)" {_A_ 1 _U_ 2 _N_ _N_ _F_ _IF_ARGS_ 0 1 X 3 \ (u0 :: Double#) -> case _#_ negateDouble# [] [u0] of { _PRIM_ (u1 :: Double#) -> _!_ D# [] [u1] } _N_} _F_ _IF_ARGS_ 0 1 C 4 \ (u0 :: Double) -> case u0 of { _ALG_ D# (u1 :: Double#) -> case _#_ negateDouble# [] [u1] of { _PRIM_ (u2 :: Double#) -> _!_ D# [] [u2] }; _NO_DEFLT_ } _N_ },
+ abs = { _A_ 1 _U_ 1 _N_ _S_ "U(P)" {_A_ 1 _U_ 2 _N_ _N_ _N_ _N_} _N_ _N_ },
+ signum = { _A_ 1 _U_ 1 _N_ _S_ "U(P)" {_A_ 1 _U_ 2 _N_ _N_ _N_ _N_} _N_ _N_ },
+ fromInteger = { _A_ 1 _U_ 1 _N_ _S_ "U(PPP)" {_A_ 3 _U_ 222 _N_ _N_ _F_ _IF_ARGS_ 0 3 XXX 3 \ (u0 :: Int#) (u1 :: Int#) (u2 :: ByteArray#) -> case _#_ encodeDouble# [] [u0, u1, u2, 0#] of { _PRIM_ (u3 :: Double#) -> _!_ D# [] [u3] } _N_} _F_ _IF_ARGS_ 0 1 C 4 \ (u0 :: Integer) -> case u0 of { _ALG_ J# (u1 :: Int#) (u2 :: Int#) (u3 :: ByteArray#) -> case _#_ encodeDouble# [] [u1, u2, u3, 0#] of { _PRIM_ (u4 :: Double#) -> _!_ D# [] [u4] }; _NO_DEFLT_ } _N_ },
+ fromInt = { _A_ 1 _U_ 1 _N_ _S_ "U(P)" {_A_ 1 _U_ 2 _N_ _N_ _F_ _IF_ARGS_ 0 1 X 3 \ (u0 :: Int#) -> case _#_ int2Double# [] [u0] of { _PRIM_ (u1 :: Double#) -> _!_ D# [] [u1] } _N_} _F_ _IF_ARGS_ 0 1 C 4 \ (u0 :: Int) -> case u0 of { _ALG_ I# (u1 :: Int#) -> case _#_ int2Double# [] [u1] of { _PRIM_ (u2 :: Double#) -> _!_ D# [] [u2] }; _NO_DEFLT_ } _N_ } #-}
instance Ord Double
{-# GHC_PRAGMA _M_ PreludeCore {-dfun-} _A_ 0 _N_ _N_ _N_ _F_ _IF_ARGS_ 0 0 X 9 _!_ _TUP_8 [{{Eq Double}}, (Double -> Double -> Bool), (Double -> Double -> Bool), (Double -> Double -> Bool), (Double -> Double -> Bool), (Double -> Double -> Double), (Double -> Double -> Double), (Double -> Double -> _CMP_TAG)] [_DFUN_ Eq (Double), _CONSTM_ Ord (<) (Double), _CONSTM_ Ord (<=) (Double), _CONSTM_ Ord (>=) (Double), _CONSTM_ Ord (>) (Double), _CONSTM_ Ord max (Double), _CONSTM_ Ord min (Double), _CONSTM_ Ord _tagCmp (Double)] _N_
- (<) = _A_ 2 _U_ 11 _N_ _S_ "U(P)U(P)" {_A_ 2 _U_ 22 _N_ _N_ _F_ _IF_ARGS_ 0 2 XX 1 \ (u0 :: Double#) (u1 :: Double#) -> _#_ ltDouble# [] [u0, u1] _N_} _F_ _IF_ARGS_ 0 2 CC 3 \ (u0 :: Double) (u1 :: Double) -> case u0 of { _ALG_ D# (u2 :: Double#) -> case u1 of { _ALG_ D# (u3 :: Double#) -> _#_ ltDouble# [] [u2, u3]; _NO_DEFLT_ }; _NO_DEFLT_ } _N_,
- (<=) = _A_ 2 _U_ 11 _N_ _S_ "U(P)U(P)" {_A_ 2 _U_ 22 _N_ _N_ _F_ _IF_ARGS_ 0 2 XX 1 \ (u0 :: Double#) (u1 :: Double#) -> _#_ leDouble# [] [u0, u1] _N_} _F_ _IF_ARGS_ 0 2 CC 3 \ (u0 :: Double) (u1 :: Double) -> case u0 of { _ALG_ D# (u2 :: Double#) -> case u1 of { _ALG_ D# (u3 :: Double#) -> _#_ leDouble# [] [u2, u3]; _NO_DEFLT_ }; _NO_DEFLT_ } _N_,
- (>=) = _A_ 2 _U_ 11 _N_ _S_ "U(P)U(P)" {_A_ 2 _U_ 22 _N_ _N_ _F_ _IF_ARGS_ 0 2 XX 1 \ (u0 :: Double#) (u1 :: Double#) -> _#_ geDouble# [] [u0, u1] _N_} _F_ _IF_ARGS_ 0 2 CC 3 \ (u0 :: Double) (u1 :: Double) -> case u0 of { _ALG_ D# (u2 :: Double#) -> case u1 of { _ALG_ D# (u3 :: Double#) -> _#_ geDouble# [] [u2, u3]; _NO_DEFLT_ }; _NO_DEFLT_ } _N_,
- (>) = _A_ 2 _U_ 11 _N_ _S_ "U(P)U(P)" {_A_ 2 _U_ 22 _N_ _N_ _F_ _IF_ARGS_ 0 2 XX 1 \ (u0 :: Double#) (u1 :: Double#) -> _#_ gtDouble# [] [u0, u1] _N_} _F_ _IF_ARGS_ 0 2 CC 3 \ (u0 :: Double) (u1 :: Double) -> case u0 of { _ALG_ D# (u2 :: Double#) -> case u1 of { _ALG_ D# (u3 :: Double#) -> _#_ gtDouble# [] [u2, u3]; _NO_DEFLT_ }; _NO_DEFLT_ } _N_,
- max = _A_ 2 _U_ 11 _N_ _S_ "U(P)U(P)" {_A_ 2 _U_ 22 _N_ _N_ _N_ _N_} _N_ _N_,
- min = _A_ 2 _U_ 11 _N_ _S_ "U(P)U(P)" {_A_ 2 _U_ 22 _N_ _N_ _N_ _N_} _N_ _N_,
- _tagCmp = _A_ 2 _U_ 11 _N_ _S_ "U(P)U(P)" {_A_ 2 _U_ 22 _N_ _N_ _N_ _N_} _N_ _N_ #-}
+ (<) = { _A_ 2 _U_ 11 _N_ _S_ "U(P)U(P)" {_A_ 2 _U_ 22 _N_ _N_ _F_ _IF_ARGS_ 0 2 XX 1 \ (u0 :: Double#) (u1 :: Double#) -> _#_ ltDouble# [] [u0, u1] _N_} _F_ _IF_ARGS_ 0 2 CC 3 \ (u0 :: Double) (u1 :: Double) -> case u0 of { _ALG_ D# (u2 :: Double#) -> case u1 of { _ALG_ D# (u3 :: Double#) -> _#_ ltDouble# [] [u2, u3]; _NO_DEFLT_ }; _NO_DEFLT_ } _N_ },
+ (<=) = { _A_ 2 _U_ 11 _N_ _S_ "U(P)U(P)" {_A_ 2 _U_ 22 _N_ _N_ _F_ _IF_ARGS_ 0 2 XX 1 \ (u0 :: Double#) (u1 :: Double#) -> _#_ leDouble# [] [u0, u1] _N_} _F_ _IF_ARGS_ 0 2 CC 3 \ (u0 :: Double) (u1 :: Double) -> case u0 of { _ALG_ D# (u2 :: Double#) -> case u1 of { _ALG_ D# (u3 :: Double#) -> _#_ leDouble# [] [u2, u3]; _NO_DEFLT_ }; _NO_DEFLT_ } _N_ },
+ (>=) = { _A_ 2 _U_ 11 _N_ _S_ "U(P)U(P)" {_A_ 2 _U_ 22 _N_ _N_ _F_ _IF_ARGS_ 0 2 XX 1 \ (u0 :: Double#) (u1 :: Double#) -> _#_ geDouble# [] [u0, u1] _N_} _F_ _IF_ARGS_ 0 2 CC 3 \ (u0 :: Double) (u1 :: Double) -> case u0 of { _ALG_ D# (u2 :: Double#) -> case u1 of { _ALG_ D# (u3 :: Double#) -> _#_ geDouble# [] [u2, u3]; _NO_DEFLT_ }; _NO_DEFLT_ } _N_ },
+ (>) = { _A_ 2 _U_ 11 _N_ _S_ "U(P)U(P)" {_A_ 2 _U_ 22 _N_ _N_ _F_ _IF_ARGS_ 0 2 XX 1 \ (u0 :: Double#) (u1 :: Double#) -> _#_ gtDouble# [] [u0, u1] _N_} _F_ _IF_ARGS_ 0 2 CC 3 \ (u0 :: Double) (u1 :: Double) -> case u0 of { _ALG_ D# (u2 :: Double#) -> case u1 of { _ALG_ D# (u3 :: Double#) -> _#_ gtDouble# [] [u2, u3]; _NO_DEFLT_ }; _NO_DEFLT_ } _N_ },
+ max = { _A_ 2 _U_ 11 _N_ _S_ "U(P)U(P)" {_A_ 2 _U_ 22 _N_ _N_ _N_ _N_} _N_ _N_ },
+ min = { _A_ 2 _U_ 11 _N_ _S_ "U(P)U(P)" {_A_ 2 _U_ 22 _N_ _N_ _N_ _N_} _N_ _N_ },
+ _tagCmp = { _A_ 2 _U_ 11 _N_ _S_ "U(P)U(P)" {_A_ 2 _U_ 22 _N_ _N_ _N_ _N_} _N_ _N_ } #-}
instance Real Double
{-# GHC_PRAGMA _M_ PreludeCore {-dfun-} _A_ 0 _N_ _N_ _N_ _F_ _IF_ARGS_ 0 0 X 4 _!_ _TUP_3 [{{Num Double}}, {{Enum Double}}, (Double -> Ratio Integer)] [_DFUN_ Num (Double), _DFUN_ Enum (Double), _CONSTM_ Real toRational (Double)] _N_
- toRational = _A_ 1 _U_ 1 _N_ _S_ "U(P)" {_A_ 1 _U_ 2 _N_ _N_ _N_ _N_} _N_ _N_ #-}
+ toRational = { _A_ 1 _U_ 1 _N_ _S_ "U(P)" {_A_ 1 _U_ 2 _N_ _N_ _N_ _N_} _N_ _N_ } #-}
instance RealFloat Double
{-# GHC_PRAGMA _M_ PreludeCore {-dfun-} _A_ 0 _N_ _N_ _N_ _F_ _IF_ARGS_ 0 0 X 11 _!_ _TUP_10 [{{RealFrac Double}}, {{Floating Double}}, (Double -> Integer), (Double -> Int), (Double -> (Int, Int)), (Double -> (Integer, Int)), (Integer -> Int -> Double), (Double -> Int), (Double -> Double), (Int -> Double -> Double)] [_DFUN_ RealFrac (Double), _DFUN_ Floating (Double), _CONSTM_ RealFloat floatRadix (Double), _CONSTM_ RealFloat floatDigits (Double), _CONSTM_ RealFloat floatRange (Double), _CONSTM_ RealFloat decodeFloat (Double), _CONSTM_ RealFloat encodeFloat (Double), _CONSTM_ RealFloat exponent (Double), _CONSTM_ RealFloat significand (Double), _CONSTM_ RealFloat scaleFloat (Double)] _N_
- floatRadix = _A_ 1 _U_ 0 _N_ _S_ "A" {_A_ 0 _N_ _N_ _N_ _F_ _IF_ARGS_ 0 0 X 1 _#_ int2Integer# [] [2#] _N_} _N_ _N_,
- floatDigits = _A_ 1 _U_ 0 _N_ _S_ "A" {_A_ 0 _N_ _N_ _N_ _F_ _IF_ARGS_ 0 0 X 2 _!_ I# [] [53#] _N_} _F_ _IF_ARGS_ 0 1 X 2 \ (u0 :: Double) -> _!_ I# [] [53#] _N_,
- floatRange = _A_ 1 _U_ 0 _N_ _S_ "A" {_A_ 0 _N_ _N_ _N_ _N_ _N_} _N_ _N_,
- decodeFloat = _A_ 1 _U_ 1 _N_ _S_ "U(P)" {_A_ 1 _U_ 2 _N_ _N_ _N_ _N_} _N_ _N_,
- encodeFloat = _A_ 2 _U_ 11 _N_ _S_ "U(PPP)U(P)" {_A_ 4 _U_ 2222 _N_ _N_ _F_ _IF_ARGS_ 0 4 XXXX 3 \ (u0 :: Int#) (u1 :: Int#) (u2 :: ByteArray#) (u3 :: Int#) -> case _#_ encodeDouble# [] [u0, u1, u2, u3] of { _PRIM_ (u4 :: Double#) -> _!_ D# [] [u4] } _N_} _F_ _IF_ARGS_ 0 2 CC 5 \ (u0 :: Integer) (u1 :: Int) -> case u0 of { _ALG_ J# (u2 :: Int#) (u3 :: Int#) (u4 :: ByteArray#) -> case u1 of { _ALG_ I# (u5 :: Int#) -> case _#_ encodeDouble# [] [u2, u3, u4, u5] of { _PRIM_ (u6 :: Double#) -> _!_ D# [] [u6] }; _NO_DEFLT_ }; _NO_DEFLT_ } _N_,
- exponent = _A_ 1 _U_ 2 _N_ _N_ _N_ _N_,
- significand = _A_ 1 _U_ 2 _N_ _N_ _N_ _N_,
- scaleFloat = _A_ 2 _U_ 22 _N_ _N_ _N_ _N_ #-}
+ floatRadix = { _A_ 1 _U_ 0 _N_ _S_ "A" {_A_ 0 _N_ _N_ _N_ _N_ _N_} _N_ _N_ },
+ floatDigits = { _A_ 1 _U_ 0 _N_ _S_ "A" {_A_ 0 _N_ _N_ _N_ _F_ _IF_ARGS_ 0 0 X 2 _!_ I# [] [53#] _N_} _F_ _IF_ARGS_ 0 1 X 2 \ (u0 :: Double) -> _!_ I# [] [53#] _N_ },
+ floatRange = { _A_ 1 _U_ 0 _N_ _S_ "A" {_A_ 0 _N_ _N_ _N_ _N_ _N_} _N_ _N_ },
+ decodeFloat = { _A_ 1 _U_ 1 _N_ _S_ "U(P)" {_A_ 1 _U_ 2 _N_ _N_ _N_ _N_} _N_ _N_ },
+ encodeFloat = { _A_ 2 _U_ 11 _N_ _S_ "U(PPP)U(P)" {_A_ 4 _U_ 2222 _N_ _N_ _F_ _IF_ARGS_ 0 4 XXXX 3 \ (u0 :: Int#) (u1 :: Int#) (u2 :: ByteArray#) (u3 :: Int#) -> case _#_ encodeDouble# [] [u0, u1, u2, u3] of { _PRIM_ (u4 :: Double#) -> _!_ D# [] [u4] } _N_} _F_ _IF_ARGS_ 0 2 CC 5 \ (u0 :: Integer) (u1 :: Int) -> case u0 of { _ALG_ J# (u2 :: Int#) (u3 :: Int#) (u4 :: ByteArray#) -> case u1 of { _ALG_ I# (u5 :: Int#) -> case _#_ encodeDouble# [] [u2, u3, u4, u5] of { _PRIM_ (u6 :: Double#) -> _!_ D# [] [u6] }; _NO_DEFLT_ }; _NO_DEFLT_ } _N_ },
+ exponent = { _A_ 1 _U_ 1 _N_ _S_ "U(P)" {_A_ 1 _U_ 2 _N_ _N_ _N_ _N_} _N_ _N_ },
+ significand = { _A_ 1 _U_ 1 _N_ _S_ "U(P)" {_A_ 1 _U_ 2 _N_ _N_ _N_ _N_} _N_ _N_ },
+ scaleFloat = { _A_ 2 _U_ 11 _N_ _S_ "U(P)U(P)" {_A_ 2 _U_ 22 _N_ _N_ _N_ _N_} _N_ _N_ } #-}
instance RealFrac Double
{-# GHC_PRAGMA _M_ PreludeCore {-dfun-} _A_ 0 _N_ _N_ _N_ _F_ _IF_ARGS_ 0 0 X 8 _!_ _TUP_7 [{{Real Double}}, {{Fractional Double}}, _forall_ a$z1 =>{{Integral a$z1}} -> (Double -> (a$z1, Double)), _forall_ a$z1 =>{{Integral a$z1}} -> (Double -> a$z1), _forall_ a$z1 =>{{Integral a$z1}} -> (Double -> a$z1), _forall_ a$z1 =>{{Integral a$z1}} -> (Double -> a$z1), _forall_ a$z1 =>{{Integral a$z1}} -> (Double -> a$z1)] [_DFUN_ Real (Double), _DFUN_ Fractional (Double), _CONSTM_ RealFrac properFraction (Double), _CONSTM_ RealFrac truncate (Double), _CONSTM_ RealFrac round (Double), _CONSTM_ RealFrac ceiling (Double), _CONSTM_ RealFrac floor (Double)] _N_
- properFraction = _A_ 1 _U_ 22 _N_ _N_ _N_ _N_,
- truncate = _A_ 1 _U_ 22 _N_ _N_ _N_ _N_,
- round = _A_ 1 _U_ 22 _N_ _N_ _N_ _N_,
- ceiling = _A_ 1 _U_ 22 _N_ _N_ _N_ _N_,
- floor = _A_ 1 _U_ 22 _N_ _N_ _N_ _N_ #-}
+ properFraction = { _A_ 1 _U_ 11 _N_ _N_ _N_ _SPECIALISE_ [ Int ] 1 { _A_ 1 _U_ 1 _N_ _S_ "U(P)" {_A_ 1 _U_ 2 _N_ _N_ _N_ _N_} _N_ _N_ }, [ Integer ] 1 { _A_ 1 _U_ 1 _N_ _S_ "U(P)" {_A_ 1 _U_ 2 _N_ _N_ _N_ _N_} _N_ _N_ } },
+ truncate = { _A_ 1 _U_ 11 _N_ _N_ _N_ _SPECIALISE_ [ Int ] 1 { _A_ 1 _U_ 1 _N_ _S_ "U(P)" {_A_ 1 _U_ 2 _N_ _N_ _F_ _IF_ARGS_ 0 1 X 4 \ (u0 :: Double#) -> case _APP_ _WRKR_ _SPEC_ _CONSTM_ RealFrac properFraction (Double) [ (Int) ] [ u0 ] of { _ALG_ _TUP_2 (u1 :: Int) (u2 :: Double) -> u1; _NO_DEFLT_ } _N_} _F_ _IF_ARGS_ 0 1 X 4 \ (u0 :: Double) -> case _APP_ _SPEC_ _CONSTM_ RealFrac properFraction (Double) [ (Int) ] [ u0 ] of { _ALG_ _TUP_2 (u1 :: Int) (u2 :: Double) -> u1; _NO_DEFLT_ } _N_ }, [ Integer ] 1 { _A_ 1 _U_ 1 _N_ _S_ "U(P)" {_A_ 1 _U_ 2 _N_ _N_ _F_ _IF_ARGS_ 0 1 X 4 \ (u0 :: Double#) -> case _APP_ _WRKR_ _SPEC_ _CONSTM_ RealFrac properFraction (Double) [ (Integer) ] [ u0 ] of { _ALG_ _TUP_2 (u1 :: Integer) (u2 :: Double) -> u1; _NO_DEFLT_ } _N_} _F_ _IF_ARGS_ 0 1 X 4 \ (u0 :: Double) -> case _APP_ _SPEC_ _CONSTM_ RealFrac properFraction (Double) [ (Integer) ] [ u0 ] of { _ALG_ _TUP_2 (u1 :: Integer) (u2 :: Double) -> u1; _NO_DEFLT_ } _N_ } },
+ round = { _A_ 1 _U_ 21 _N_ _N_ _N_ _SPECIALISE_ [ Int ] 1 { _A_ 1 _U_ 1 _N_ _S_ "U(P)" {_A_ 1 _U_ 2 _N_ _N_ _N_ _N_} _N_ _N_ }, [ Integer ] 1 { _A_ 1 _U_ 1 _N_ _S_ "U(P)" {_A_ 1 _U_ 2 _N_ _N_ _N_ _N_} _N_ _N_ } },
+ ceiling = { _A_ 1 _U_ 21 _N_ _N_ _N_ _SPECIALISE_ [ Int ] 1 { _A_ 1 _U_ 1 _N_ _S_ "U(P)" {_A_ 1 _U_ 2 _N_ _N_ _N_ _N_} _N_ _N_ }, [ Integer ] 1 { _A_ 1 _U_ 1 _N_ _S_ "U(P)" {_A_ 1 _U_ 2 _N_ _N_ _N_ _N_} _N_ _N_ } },
+ floor = { _A_ 1 _U_ 21 _N_ _N_ _N_ _SPECIALISE_ [ Int ] 1 { _A_ 1 _U_ 1 _N_ _S_ "U(P)" {_A_ 1 _U_ 2 _N_ _N_ _N_ _N_} _N_ _N_ }, [ Integer ] 1 { _A_ 1 _U_ 1 _N_ _S_ "U(P)" {_A_ 1 _U_ 2 _N_ _N_ _N_ _N_} _N_ _N_ } } #-}
instance Text Double
{-# GHC_PRAGMA _M_ PreludeCore {-dfun-} _A_ 0 _N_ _N_ _N_ _F_ _IF_ARGS_ 0 0 X 5 _!_ _TUP_4 [(Int -> [Char] -> [(Double, [Char])]), (Int -> Double -> [Char] -> [Char]), ([Char] -> [([Double], [Char])]), ([Double] -> [Char] -> [Char])] [_CONSTM_ Text readsPrec (Double), _CONSTM_ Text showsPrec (Double), _CONSTM_ Text readList (Double), _CONSTM_ Text showList (Double)] _N_
- readsPrec = _A_ 2 _U_ 02 _N_ _S_ "AL" {_A_ 1 _U_ 2 _N_ _N_ _F_ _IF_ARGS_ 0 1 X 3 \ (u0 :: [Char]) -> _APP_ _SPEC_ _ORIG_ PreludeText readSigned [ (Double) ] [ _SPEC_ _ORIG_ PreludeText readFloat [ (Double) ], u0 ] _N_} _F_ _IF_ARGS_ 0 2 XX 3 \ (u0 :: Int) (u1 :: [Char]) -> _APP_ _SPEC_ _ORIG_ PreludeText readSigned [ (Double) ] [ _SPEC_ _ORIG_ PreludeText readFloat [ (Double) ], u1 ] _N_,
- showsPrec = _A_ 2 _U_ 212 _N_ _S_ "LU(P)" {_A_ 2 _U_ 222 _N_ _N_ _F_ _IF_ARGS_ 0 2 XX 4 \ (u0 :: Int) (u1 :: Double#) -> _APP_ _WRKR_ _SPEC_ _ORIG_ PreludeText showSigned [ (Double) ] [ _SPEC_ _ORIG_ PreludeText showFloat [ (Double) ], u0, u1 ] _N_} _F_ _IF_ARGS_ 0 2 XC 5 \ (u0 :: Int) (u1 :: Double) -> case u1 of { _ALG_ D# (u2 :: Double#) -> _APP_ _WRKR_ _SPEC_ _ORIG_ PreludeText showSigned [ (Double) ] [ _SPEC_ _ORIG_ PreludeText showFloat [ (Double) ], u0, u2 ]; _NO_DEFLT_ } _N_,
- readList = _A_ 0 _U_ 2 _N_ _N_ _N_ _N_,
- showList = _A_ 0 _U_ 12 _N_ _N_ _N_ _N_ #-}
+ readsPrec = { _A_ 2 _U_ 02 _N_ _S_ "AL" {_A_ 1 _U_ 2 _N_ _N_ _F_ _IF_ARGS_ 0 1 X 3 \ (u0 :: [Char]) -> _APP_ _SPEC_ _ORIG_ PreludeText readSigned [ (Double) ] [ _SPEC_ _ORIG_ PreludeText readFloat [ (Double) ], u0 ] _N_} _F_ _IF_ARGS_ 0 2 XX 3 \ (u0 :: Int) (u1 :: [Char]) -> _APP_ _SPEC_ _ORIG_ PreludeText readSigned [ (Double) ] [ _SPEC_ _ORIG_ PreludeText readFloat [ (Double) ], u1 ] _N_ },
+ showsPrec = { _A_ 2 _U_ 212 _N_ _S_ "LU(P)" {_A_ 2 _U_ 222 _N_ _N_ _F_ _IF_ARGS_ 0 2 XX 4 \ (u0 :: Int) (u1 :: Double#) -> _APP_ _WRKR_ _SPEC_ _ORIG_ PreludeText showSigned [ (Double) ] [ _SPEC_ _ORIG_ PreludeText showFloat [ (Double) ], u0, u1 ] _N_} _F_ _IF_ARGS_ 0 2 XC 5 \ (u0 :: Int) (u1 :: Double) -> case u1 of { _ALG_ D# (u2 :: Double#) -> _APP_ _WRKR_ _SPEC_ _ORIG_ PreludeText showSigned [ (Double) ] [ _SPEC_ _ORIG_ PreludeText showFloat [ (Double) ], u0, u2 ]; _NO_DEFLT_ } _N_ },
+ readList = { _A_ 0 _U_ 2 _N_ _N_ _N_ _N_ },
+ showList = { _A_ 1 _U_ 12 _N_ _N_ _N_ _N_ } #-}
instance _CCallable Double
{-# GHC_PRAGMA _M_ PreludeCore {-dfun-} _A_ 0 _N_ _N_ _N_ _F_ _IF_ARGS_ 0 0 X 1 _!_ _TUP_0 [] [] _N_ #-}
instance _CReturnable Double
-{-# GHC_PRAGMA INTERFACE VERSION 5 #-}
+{-# GHC_PRAGMA INTERFACE VERSION 6 #-}
interface PreludeCore where
import PreludeBuiltin(Double(..))
instance Enum Double
{-# GHC_PRAGMA _M_ PreludeCore {-dfun-} _A_ 0 _N_ _N_ _N_ _F_ _IF_ARGS_ 0 0 X 6 _!_ _TUP_5 [{{Ord Double}}, (Double -> [Double]), (Double -> Double -> [Double]), (Double -> Double -> [Double]), (Double -> Double -> Double -> [Double])] [_DFUN_ Ord (Double), _CONSTM_ Enum enumFrom (Double), _CONSTM_ Enum enumFromThen (Double), _CONSTM_ Enum enumFromTo (Double), _CONSTM_ Enum enumFromThenTo (Double)] _N_
- enumFrom = _A_ 1 _U_ 2 _N_ _N_ _N_ _N_,
- enumFromThen = _A_ 2 _U_ 21 _N_ _N_ _N_ _N_,
- enumFromTo = _A_ 2 _U_ 22 _N_ _N_ _N_ _N_,
- enumFromThenTo = _A_ 3 _U_ 222 _N_ _N_ _N_ _N_ #-}
+ enumFrom = { _A_ 1 _U_ 2 _N_ _N_ _N_ _N_ },
+ enumFromThen = { _A_ 2 _U_ 21 _N_ _N_ _N_ _N_ },
+ enumFromTo = { _A_ 2 _U_ 22 _N_ _N_ _N_ _N_ },
+ enumFromThenTo = { _A_ 3 _U_ 222 _N_ _N_ _N_ _N_ } #-}
instance Eq Double
{-# GHC_PRAGMA _M_ PreludeCore {-dfun-} _A_ 0 _N_ _N_ _N_ _F_ _IF_ARGS_ 0 0 X 3 _!_ _TUP_2 [(Double -> Double -> Bool), (Double -> Double -> Bool)] [_CONSTM_ Eq (==) (Double), _CONSTM_ Eq (/=) (Double)] _N_
- (==) = _A_ 2 _U_ 11 _N_ _S_ "U(P)U(P)" {_A_ 2 _U_ 22 _N_ _N_ _F_ _IF_ARGS_ 0 2 XX 1 \ (u0 :: Double#) (u1 :: Double#) -> _#_ eqDouble# [] [u0, u1] _N_} _F_ _IF_ARGS_ 0 2 CC 3 \ (u0 :: Double) (u1 :: Double) -> case u0 of { _ALG_ D# (u2 :: Double#) -> case u1 of { _ALG_ D# (u3 :: Double#) -> _#_ eqDouble# [] [u2, u3]; _NO_DEFLT_ }; _NO_DEFLT_ } _N_,
- (/=) = _A_ 2 _U_ 11 _N_ _S_ "U(P)U(P)" {_A_ 2 _U_ 22 _N_ _N_ _F_ _IF_ARGS_ 0 2 XX 1 \ (u0 :: Double#) (u1 :: Double#) -> _#_ neDouble# [] [u0, u1] _N_} _F_ _IF_ARGS_ 0 2 CC 3 \ (u0 :: Double) (u1 :: Double) -> case u0 of { _ALG_ D# (u2 :: Double#) -> case u1 of { _ALG_ D# (u3 :: Double#) -> _#_ neDouble# [] [u2, u3]; _NO_DEFLT_ }; _NO_DEFLT_ } _N_ #-}
+ (==) = { _A_ 2 _U_ 11 _N_ _S_ "U(P)U(P)" {_A_ 2 _U_ 22 _N_ _N_ _F_ _IF_ARGS_ 0 2 XX 1 \ (u0 :: Double#) (u1 :: Double#) -> _#_ eqDouble# [] [u0, u1] _N_} _F_ _IF_ARGS_ 0 2 CC 3 \ (u0 :: Double) (u1 :: Double) -> case u0 of { _ALG_ D# (u2 :: Double#) -> case u1 of { _ALG_ D# (u3 :: Double#) -> _#_ eqDouble# [] [u2, u3]; _NO_DEFLT_ }; _NO_DEFLT_ } _N_ },
+ (/=) = { _A_ 2 _U_ 11 _N_ _S_ "U(P)U(P)" {_A_ 2 _U_ 22 _N_ _N_ _F_ _IF_ARGS_ 0 2 XX 1 \ (u0 :: Double#) (u1 :: Double#) -> _#_ neDouble# [] [u0, u1] _N_} _F_ _IF_ARGS_ 0 2 CC 3 \ (u0 :: Double) (u1 :: Double) -> case u0 of { _ALG_ D# (u2 :: Double#) -> case u1 of { _ALG_ D# (u3 :: Double#) -> _#_ neDouble# [] [u2, u3]; _NO_DEFLT_ }; _NO_DEFLT_ } _N_ } #-}
instance Floating Double
{-# GHC_PRAGMA _M_ PreludeCore {-dfun-} _A_ 0 _N_ _N_ _N_ _F_ _IF_ARGS_ 0 0 X 20 _!_ _TUP_19 [{{Fractional Double}}, Double, (Double -> Double), (Double -> Double), (Double -> Double), (Double -> Double -> Double), (Double -> Double -> Double), (Double -> Double), (Double -> Double), (Double -> Double), (Double -> Double), (Double -> Double), (Double -> Double), (Double -> Double), (Double -> Double), (Double -> Double), (Double -> Double), (Double -> Double), (Double -> Double)] [_DFUN_ Fractional (Double), _CONSTM_ Floating pi (Double), _CONSTM_ Floating exp (Double), _CONSTM_ Floating log (Double), _CONSTM_ Floating sqrt (Double), _CONSTM_ Floating (**) (Double), _CONSTM_ Floating logBase (Double), _CONSTM_ Floating sin (Double), _CONSTM_ Floating cos (Double), _CONSTM_ Floating tan (Double), _CONSTM_ Floating asin (Double), _CONSTM_ Floating acos (Double), _CONSTM_ Floating atan (Double), _CONSTM_ Floating sinh (Double), _CONSTM_ Floating cosh (Double), _CONSTM_ Floating tanh (Double), _CONSTM_ Floating asinh (Double), _CONSTM_ Floating acosh (Double), _CONSTM_ Floating atanh (Double)] _N_
- pi = _A_ 0 _N_ _N_ _N_ _F_ _IF_ARGS_ 0 0 X 2 _!_ D# [] [3.1415926535897931##] _N_,
- exp = _A_ 1 _U_ 1 _N_ _S_ "U(P)" {_A_ 1 _U_ 2 _N_ _N_ _F_ _IF_ARGS_ 0 1 X 3 \ (u0 :: Double#) -> case _#_ expDouble# [] [u0] of { _PRIM_ (u1 :: Double#) -> _!_ D# [] [u1] } _N_} _F_ _IF_ARGS_ 0 1 C 4 \ (u0 :: Double) -> case u0 of { _ALG_ D# (u1 :: Double#) -> case _#_ expDouble# [] [u1] of { _PRIM_ (u2 :: Double#) -> _!_ D# [] [u2] }; _NO_DEFLT_ } _N_,
- log = _A_ 1 _U_ 1 _N_ _S_ "U(P)" {_A_ 1 _U_ 2 _N_ _N_ _F_ _IF_ARGS_ 0 1 X 3 \ (u0 :: Double#) -> case _#_ logDouble# [] [u0] of { _PRIM_ (u1 :: Double#) -> _!_ D# [] [u1] } _N_} _F_ _IF_ARGS_ 0 1 C 4 \ (u0 :: Double) -> case u0 of { _ALG_ D# (u1 :: Double#) -> case _#_ logDouble# [] [u1] of { _PRIM_ (u2 :: Double#) -> _!_ D# [] [u2] }; _NO_DEFLT_ } _N_,
- sqrt = _A_ 1 _U_ 1 _N_ _S_ "U(P)" {_A_ 1 _U_ 2 _N_ _N_ _F_ _IF_ARGS_ 0 1 X 3 \ (u0 :: Double#) -> case _#_ sqrtDouble# [] [u0] of { _PRIM_ (u1 :: Double#) -> _!_ D# [] [u1] } _N_} _F_ _IF_ARGS_ 0 1 C 4 \ (u0 :: Double) -> case u0 of { _ALG_ D# (u1 :: Double#) -> case _#_ sqrtDouble# [] [u1] of { _PRIM_ (u2 :: Double#) -> _!_ D# [] [u2] }; _NO_DEFLT_ } _N_,
- (**) = _A_ 2 _U_ 11 _N_ _S_ "U(P)U(P)" {_A_ 2 _U_ 22 _N_ _N_ _F_ _IF_ARGS_ 0 2 XX 3 \ (u0 :: Double#) (u1 :: Double#) -> case _#_ powerDouble# [] [u0, u1] of { _PRIM_ (u2 :: Double#) -> _!_ D# [] [u2] } _N_} _F_ _IF_ARGS_ 0 2 CC 5 \ (u0 :: Double) (u1 :: Double) -> case u0 of { _ALG_ D# (u2 :: Double#) -> case u1 of { _ALG_ D# (u3 :: Double#) -> case _#_ powerDouble# [] [u2, u3] of { _PRIM_ (u4 :: Double#) -> _!_ D# [] [u4] }; _NO_DEFLT_ }; _NO_DEFLT_ } _N_,
- logBase = _A_ 2 _U_ 11 _N_ _S_ "U(P)U(P)" {_A_ 2 _U_ 22 _N_ _N_ _F_ _IF_ARGS_ 0 2 XX 5 \ (u0 :: Double#) (u1 :: Double#) -> case _#_ logDouble# [] [u1] of { _PRIM_ (u2 :: Double#) -> case _#_ logDouble# [] [u0] of { _PRIM_ (u3 :: Double#) -> case _#_ divideDouble# [] [u2, u3] of { _PRIM_ (u4 :: Double#) -> _!_ D# [] [u4] } } } _N_} _F_ _IF_ARGS_ 0 2 CC 7 \ (u0 :: Double) (u1 :: Double) -> case u1 of { _ALG_ D# (u2 :: Double#) -> case _#_ logDouble# [] [u2] of { _PRIM_ (u3 :: Double#) -> case u0 of { _ALG_ D# (u4 :: Double#) -> case _#_ logDouble# [] [u4] of { _PRIM_ (u5 :: Double#) -> case _#_ divideDouble# [] [u3, u5] of { _PRIM_ (u6 :: Double#) -> _!_ D# [] [u6] } }; _NO_DEFLT_ } }; _NO_DEFLT_ } _N_,
- sin = _A_ 1 _U_ 1 _N_ _S_ "U(P)" {_A_ 1 _U_ 2 _N_ _N_ _F_ _IF_ARGS_ 0 1 X 3 \ (u0 :: Double#) -> case _#_ sinDouble# [] [u0] of { _PRIM_ (u1 :: Double#) -> _!_ D# [] [u1] } _N_} _F_ _IF_ARGS_ 0 1 C 4 \ (u0 :: Double) -> case u0 of { _ALG_ D# (u1 :: Double#) -> case _#_ sinDouble# [] [u1] of { _PRIM_ (u2 :: Double#) -> _!_ D# [] [u2] }; _NO_DEFLT_ } _N_,
- cos = _A_ 1 _U_ 1 _N_ _S_ "U(P)" {_A_ 1 _U_ 2 _N_ _N_ _F_ _IF_ARGS_ 0 1 X 3 \ (u0 :: Double#) -> case _#_ cosDouble# [] [u0] of { _PRIM_ (u1 :: Double#) -> _!_ D# [] [u1] } _N_} _F_ _IF_ARGS_ 0 1 C 4 \ (u0 :: Double) -> case u0 of { _ALG_ D# (u1 :: Double#) -> case _#_ cosDouble# [] [u1] of { _PRIM_ (u2 :: Double#) -> _!_ D# [] [u2] }; _NO_DEFLT_ } _N_,
- tan = _A_ 1 _U_ 1 _N_ _S_ "U(P)" {_A_ 1 _U_ 2 _N_ _N_ _F_ _IF_ARGS_ 0 1 X 3 \ (u0 :: Double#) -> case _#_ tanDouble# [] [u0] of { _PRIM_ (u1 :: Double#) -> _!_ D# [] [u1] } _N_} _F_ _IF_ARGS_ 0 1 C 4 \ (u0 :: Double) -> case u0 of { _ALG_ D# (u1 :: Double#) -> case _#_ tanDouble# [] [u1] of { _PRIM_ (u2 :: Double#) -> _!_ D# [] [u2] }; _NO_DEFLT_ } _N_,
- asin = _A_ 1 _U_ 1 _N_ _S_ "U(P)" {_A_ 1 _U_ 2 _N_ _N_ _F_ _IF_ARGS_ 0 1 X 3 \ (u0 :: Double#) -> case _#_ asinDouble# [] [u0] of { _PRIM_ (u1 :: Double#) -> _!_ D# [] [u1] } _N_} _F_ _IF_ARGS_ 0 1 C 4 \ (u0 :: Double) -> case u0 of { _ALG_ D# (u1 :: Double#) -> case _#_ asinDouble# [] [u1] of { _PRIM_ (u2 :: Double#) -> _!_ D# [] [u2] }; _NO_DEFLT_ } _N_,
- acos = _A_ 1 _U_ 1 _N_ _S_ "U(P)" {_A_ 1 _U_ 2 _N_ _N_ _F_ _IF_ARGS_ 0 1 X 3 \ (u0 :: Double#) -> case _#_ acosDouble# [] [u0] of { _PRIM_ (u1 :: Double#) -> _!_ D# [] [u1] } _N_} _F_ _IF_ARGS_ 0 1 C 4 \ (u0 :: Double) -> case u0 of { _ALG_ D# (u1 :: Double#) -> case _#_ acosDouble# [] [u1] of { _PRIM_ (u2 :: Double#) -> _!_ D# [] [u2] }; _NO_DEFLT_ } _N_,
- atan = _A_ 1 _U_ 1 _N_ _S_ "U(P)" {_A_ 1 _U_ 2 _N_ _N_ _F_ _IF_ARGS_ 0 1 X 3 \ (u0 :: Double#) -> case _#_ atanDouble# [] [u0] of { _PRIM_ (u1 :: Double#) -> _!_ D# [] [u1] } _N_} _F_ _IF_ARGS_ 0 1 C 4 \ (u0 :: Double) -> case u0 of { _ALG_ D# (u1 :: Double#) -> case _#_ atanDouble# [] [u1] of { _PRIM_ (u2 :: Double#) -> _!_ D# [] [u2] }; _NO_DEFLT_ } _N_,
- sinh = _A_ 1 _U_ 1 _N_ _S_ "U(P)" {_A_ 1 _U_ 2 _N_ _N_ _F_ _IF_ARGS_ 0 1 X 3 \ (u0 :: Double#) -> case _#_ sinhDouble# [] [u0] of { _PRIM_ (u1 :: Double#) -> _!_ D# [] [u1] } _N_} _F_ _IF_ARGS_ 0 1 C 4 \ (u0 :: Double) -> case u0 of { _ALG_ D# (u1 :: Double#) -> case _#_ sinhDouble# [] [u1] of { _PRIM_ (u2 :: Double#) -> _!_ D# [] [u2] }; _NO_DEFLT_ } _N_,
- cosh = _A_ 1 _U_ 1 _N_ _S_ "U(P)" {_A_ 1 _U_ 2 _N_ _N_ _F_ _IF_ARGS_ 0 1 X 3 \ (u0 :: Double#) -> case _#_ coshDouble# [] [u0] of { _PRIM_ (u1 :: Double#) -> _!_ D# [] [u1] } _N_} _F_ _IF_ARGS_ 0 1 C 4 \ (u0 :: Double) -> case u0 of { _ALG_ D# (u1 :: Double#) -> case _#_ coshDouble# [] [u1] of { _PRIM_ (u2 :: Double#) -> _!_ D# [] [u2] }; _NO_DEFLT_ } _N_,
- tanh = _A_ 1 _U_ 1 _N_ _S_ "U(P)" {_A_ 1 _U_ 2 _N_ _N_ _F_ _IF_ARGS_ 0 1 X 3 \ (u0 :: Double#) -> case _#_ tanhDouble# [] [u0] of { _PRIM_ (u1 :: Double#) -> _!_ D# [] [u1] } _N_} _F_ _IF_ARGS_ 0 1 C 4 \ (u0 :: Double) -> case u0 of { _ALG_ D# (u1 :: Double#) -> case _#_ tanhDouble# [] [u1] of { _PRIM_ (u2 :: Double#) -> _!_ D# [] [u2] }; _NO_DEFLT_ } _N_,
- asinh = _A_ 1 _U_ 1 _N_ _S_ "U(P)" {_A_ 1 _U_ 2 _N_ _N_ _N_ _N_} _N_ _N_,
- acosh = _A_ 1 _U_ 1 _N_ _S_ "U(P)" {_A_ 1 _U_ 2 _N_ _N_ _N_ _N_} _N_ _N_,
- atanh = _A_ 1 _U_ 1 _N_ _S_ "U(P)" {_A_ 1 _U_ 2 _N_ _N_ _N_ _N_} _N_ _N_ #-}
+ pi = { _A_ 0 _N_ _N_ _N_ _F_ _IF_ARGS_ 0 0 X 2 _!_ D# [] [3.1415926535897931##] _N_ },
+ exp = { _A_ 1 _U_ 1 _N_ _S_ "U(P)" {_A_ 1 _U_ 2 _N_ _N_ _F_ _IF_ARGS_ 0 1 X 3 \ (u0 :: Double#) -> case _#_ expDouble# [] [u0] of { _PRIM_ (u1 :: Double#) -> _!_ D# [] [u1] } _N_} _F_ _IF_ARGS_ 0 1 C 4 \ (u0 :: Double) -> case u0 of { _ALG_ D# (u1 :: Double#) -> case _#_ expDouble# [] [u1] of { _PRIM_ (u2 :: Double#) -> _!_ D# [] [u2] }; _NO_DEFLT_ } _N_ },
+ log = { _A_ 1 _U_ 1 _N_ _S_ "U(P)" {_A_ 1 _U_ 2 _N_ _N_ _F_ _IF_ARGS_ 0 1 X 3 \ (u0 :: Double#) -> case _#_ logDouble# [] [u0] of { _PRIM_ (u1 :: Double#) -> _!_ D# [] [u1] } _N_} _F_ _IF_ARGS_ 0 1 C 4 \ (u0 :: Double) -> case u0 of { _ALG_ D# (u1 :: Double#) -> case _#_ logDouble# [] [u1] of { _PRIM_ (u2 :: Double#) -> _!_ D# [] [u2] }; _NO_DEFLT_ } _N_ },
+ sqrt = { _A_ 1 _U_ 1 _N_ _S_ "U(P)" {_A_ 1 _U_ 2 _N_ _N_ _F_ _IF_ARGS_ 0 1 X 3 \ (u0 :: Double#) -> case _#_ sqrtDouble# [] [u0] of { _PRIM_ (u1 :: Double#) -> _!_ D# [] [u1] } _N_} _F_ _IF_ARGS_ 0 1 C 4 \ (u0 :: Double) -> case u0 of { _ALG_ D# (u1 :: Double#) -> case _#_ sqrtDouble# [] [u1] of { _PRIM_ (u2 :: Double#) -> _!_ D# [] [u2] }; _NO_DEFLT_ } _N_ },
+ (**) = { _A_ 2 _U_ 11 _N_ _S_ "U(P)U(P)" {_A_ 2 _U_ 22 _N_ _N_ _F_ _IF_ARGS_ 0 2 XX 3 \ (u0 :: Double#) (u1 :: Double#) -> case _#_ powerDouble# [] [u0, u1] of { _PRIM_ (u2 :: Double#) -> _!_ D# [] [u2] } _N_} _F_ _IF_ARGS_ 0 2 CC 5 \ (u0 :: Double) (u1 :: Double) -> case u0 of { _ALG_ D# (u2 :: Double#) -> case u1 of { _ALG_ D# (u3 :: Double#) -> case _#_ powerDouble# [] [u2, u3] of { _PRIM_ (u4 :: Double#) -> _!_ D# [] [u4] }; _NO_DEFLT_ }; _NO_DEFLT_ } _N_ },
+ logBase = { _A_ 2 _U_ 11 _N_ _S_ "U(P)U(P)" {_A_ 2 _U_ 22 _N_ _N_ _F_ _IF_ARGS_ 0 2 XX 5 \ (u0 :: Double#) (u1 :: Double#) -> case _#_ logDouble# [] [u1] of { _PRIM_ (u2 :: Double#) -> case _#_ logDouble# [] [u0] of { _PRIM_ (u3 :: Double#) -> case _#_ divideDouble# [] [u2, u3] of { _PRIM_ (u4 :: Double#) -> _!_ D# [] [u4] } } } _N_} _F_ _IF_ARGS_ 0 2 CC 7 \ (u0 :: Double) (u1 :: Double) -> case u1 of { _ALG_ D# (u2 :: Double#) -> case _#_ logDouble# [] [u2] of { _PRIM_ (u3 :: Double#) -> case u0 of { _ALG_ D# (u4 :: Double#) -> case _#_ logDouble# [] [u4] of { _PRIM_ (u5 :: Double#) -> case _#_ divideDouble# [] [u3, u5] of { _PRIM_ (u6 :: Double#) -> _!_ D# [] [u6] } }; _NO_DEFLT_ } }; _NO_DEFLT_ } _N_ },
+ sin = { _A_ 1 _U_ 1 _N_ _S_ "U(P)" {_A_ 1 _U_ 2 _N_ _N_ _F_ _IF_ARGS_ 0 1 X 3 \ (u0 :: Double#) -> case _#_ sinDouble# [] [u0] of { _PRIM_ (u1 :: Double#) -> _!_ D# [] [u1] } _N_} _F_ _IF_ARGS_ 0 1 C 4 \ (u0 :: Double) -> case u0 of { _ALG_ D# (u1 :: Double#) -> case _#_ sinDouble# [] [u1] of { _PRIM_ (u2 :: Double#) -> _!_ D# [] [u2] }; _NO_DEFLT_ } _N_ },
+ cos = { _A_ 1 _U_ 1 _N_ _S_ "U(P)" {_A_ 1 _U_ 2 _N_ _N_ _F_ _IF_ARGS_ 0 1 X 3 \ (u0 :: Double#) -> case _#_ cosDouble# [] [u0] of { _PRIM_ (u1 :: Double#) -> _!_ D# [] [u1] } _N_} _F_ _IF_ARGS_ 0 1 C 4 \ (u0 :: Double) -> case u0 of { _ALG_ D# (u1 :: Double#) -> case _#_ cosDouble# [] [u1] of { _PRIM_ (u2 :: Double#) -> _!_ D# [] [u2] }; _NO_DEFLT_ } _N_ },
+ tan = { _A_ 1 _U_ 1 _N_ _S_ "U(P)" {_A_ 1 _U_ 2 _N_ _N_ _F_ _IF_ARGS_ 0 1 X 3 \ (u0 :: Double#) -> case _#_ tanDouble# [] [u0] of { _PRIM_ (u1 :: Double#) -> _!_ D# [] [u1] } _N_} _F_ _IF_ARGS_ 0 1 C 4 \ (u0 :: Double) -> case u0 of { _ALG_ D# (u1 :: Double#) -> case _#_ tanDouble# [] [u1] of { _PRIM_ (u2 :: Double#) -> _!_ D# [] [u2] }; _NO_DEFLT_ } _N_ },
+ asin = { _A_ 1 _U_ 1 _N_ _S_ "U(P)" {_A_ 1 _U_ 2 _N_ _N_ _F_ _IF_ARGS_ 0 1 X 3 \ (u0 :: Double#) -> case _#_ asinDouble# [] [u0] of { _PRIM_ (u1 :: Double#) -> _!_ D# [] [u1] } _N_} _F_ _IF_ARGS_ 0 1 C 4 \ (u0 :: Double) -> case u0 of { _ALG_ D# (u1 :: Double#) -> case _#_ asinDouble# [] [u1] of { _PRIM_ (u2 :: Double#) -> _!_ D# [] [u2] }; _NO_DEFLT_ } _N_ },
+ acos = { _A_ 1 _U_ 1 _N_ _S_ "U(P)" {_A_ 1 _U_ 2 _N_ _N_ _F_ _IF_ARGS_ 0 1 X 3 \ (u0 :: Double#) -> case _#_ acosDouble# [] [u0] of { _PRIM_ (u1 :: Double#) -> _!_ D# [] [u1] } _N_} _F_ _IF_ARGS_ 0 1 C 4 \ (u0 :: Double) -> case u0 of { _ALG_ D# (u1 :: Double#) -> case _#_ acosDouble# [] [u1] of { _PRIM_ (u2 :: Double#) -> _!_ D# [] [u2] }; _NO_DEFLT_ } _N_ },
+ atan = { _A_ 1 _U_ 1 _N_ _S_ "U(P)" {_A_ 1 _U_ 2 _N_ _N_ _F_ _IF_ARGS_ 0 1 X 3 \ (u0 :: Double#) -> case _#_ atanDouble# [] [u0] of { _PRIM_ (u1 :: Double#) -> _!_ D# [] [u1] } _N_} _F_ _IF_ARGS_ 0 1 C 4 \ (u0 :: Double) -> case u0 of { _ALG_ D# (u1 :: Double#) -> case _#_ atanDouble# [] [u1] of { _PRIM_ (u2 :: Double#) -> _!_ D# [] [u2] }; _NO_DEFLT_ } _N_ },
+ sinh = { _A_ 1 _U_ 1 _N_ _S_ "U(P)" {_A_ 1 _U_ 2 _N_ _N_ _F_ _IF_ARGS_ 0 1 X 3 \ (u0 :: Double#) -> case _#_ sinhDouble# [] [u0] of { _PRIM_ (u1 :: Double#) -> _!_ D# [] [u1] } _N_} _F_ _IF_ARGS_ 0 1 C 4 \ (u0 :: Double) -> case u0 of { _ALG_ D# (u1 :: Double#) -> case _#_ sinhDouble# [] [u1] of { _PRIM_ (u2 :: Double#) -> _!_ D# [] [u2] }; _NO_DEFLT_ } _N_ },
+ cosh = { _A_ 1 _U_ 1 _N_ _S_ "U(P)" {_A_ 1 _U_ 2 _N_ _N_ _F_ _IF_ARGS_ 0 1 X 3 \ (u0 :: Double#) -> case _#_ coshDouble# [] [u0] of { _PRIM_ (u1 :: Double#) -> _!_ D# [] [u1] } _N_} _F_ _IF_ARGS_ 0 1 C 4 \ (u0 :: Double) -> case u0 of { _ALG_ D# (u1 :: Double#) -> case _#_ coshDouble# [] [u1] of { _PRIM_ (u2 :: Double#) -> _!_ D# [] [u2] }; _NO_DEFLT_ } _N_ },
+ tanh = { _A_ 1 _U_ 1 _N_ _S_ "U(P)" {_A_ 1 _U_ 2 _N_ _N_ _F_ _IF_ARGS_ 0 1 X 3 \ (u0 :: Double#) -> case _#_ tanhDouble# [] [u0] of { _PRIM_ (u1 :: Double#) -> _!_ D# [] [u1] } _N_} _F_ _IF_ARGS_ 0 1 C 4 \ (u0 :: Double) -> case u0 of { _ALG_ D# (u1 :: Double#) -> case _#_ tanhDouble# [] [u1] of { _PRIM_ (u2 :: Double#) -> _!_ D# [] [u2] }; _NO_DEFLT_ } _N_ },
+ asinh = { _A_ 1 _U_ 1 _N_ _S_ "U(P)" {_A_ 1 _U_ 2 _N_ _N_ _N_ _N_} _N_ _N_ },
+ acosh = { _A_ 1 _U_ 1 _N_ _S_ "U(P)" {_A_ 1 _U_ 2 _N_ _N_ _N_ _N_} _N_ _N_ },
+ atanh = { _A_ 1 _U_ 1 _N_ _S_ "U(P)" {_A_ 1 _U_ 2 _N_ _N_ _N_ _N_} _N_ _N_ } #-}
instance Fractional Double
{-# GHC_PRAGMA _M_ PreludeCore {-dfun-} _A_ 0 _N_ _N_ _N_ _F_ _IF_ARGS_ 0 0 X 5 _!_ _TUP_4 [{{Num Double}}, (Double -> Double -> Double), (Double -> Double), (Ratio Integer -> Double)] [_DFUN_ Num (Double), _CONSTM_ Fractional (/) (Double), _CONSTM_ Fractional recip (Double), _CONSTM_ Fractional fromRational (Double)] _N_
- (/) = _A_ 2 _U_ 11 _N_ _S_ "U(P)U(P)" {_A_ 2 _U_ 22 _N_ _N_ _F_ _IF_ARGS_ 0 2 XX 3 \ (u0 :: Double#) (u1 :: Double#) -> case _#_ divideDouble# [] [u0, u1] of { _PRIM_ (u2 :: Double#) -> _!_ D# [] [u2] } _N_} _F_ _IF_ARGS_ 0 2 CC 5 \ (u0 :: Double) (u1 :: Double) -> case u0 of { _ALG_ D# (u2 :: Double#) -> case u1 of { _ALG_ D# (u3 :: Double#) -> case _#_ divideDouble# [] [u2, u3] of { _PRIM_ (u4 :: Double#) -> _!_ D# [] [u4] }; _NO_DEFLT_ }; _NO_DEFLT_ } _N_,
- recip = _A_ 1 _U_ 1 _N_ _S_ "U(P)" {_A_ 1 _U_ 2 _N_ _N_ _F_ _IF_ARGS_ 0 1 X 3 \ (u0 :: Double#) -> case _#_ divideDouble# [] [1.0000000000000000##, u0] of { _PRIM_ (u1 :: Double#) -> _!_ D# [] [u1] } _N_} _F_ _IF_ARGS_ 0 1 C 4 \ (u0 :: Double) -> case u0 of { _ALG_ D# (u1 :: Double#) -> case _#_ divideDouble# [] [1.0000000000000000##, u1] of { _PRIM_ (u2 :: Double#) -> _!_ D# [] [u2] }; _NO_DEFLT_ } _N_,
- fromRational = _A_ 0 _U_ 2 _N_ _N_ _N_ _N_ #-}
+ (/) = { _A_ 2 _U_ 11 _N_ _S_ "U(P)U(P)" {_A_ 2 _U_ 22 _N_ _N_ _F_ _IF_ARGS_ 0 2 XX 3 \ (u0 :: Double#) (u1 :: Double#) -> case _#_ divideDouble# [] [u0, u1] of { _PRIM_ (u2 :: Double#) -> _!_ D# [] [u2] } _N_} _F_ _IF_ARGS_ 0 2 CC 5 \ (u0 :: Double) (u1 :: Double) -> case u0 of { _ALG_ D# (u2 :: Double#) -> case u1 of { _ALG_ D# (u3 :: Double#) -> case _#_ divideDouble# [] [u2, u3] of { _PRIM_ (u4 :: Double#) -> _!_ D# [] [u4] }; _NO_DEFLT_ }; _NO_DEFLT_ } _N_ },
+ recip = { _A_ 1 _U_ 1 _N_ _S_ "U(P)" {_A_ 1 _U_ 2 _N_ _N_ _F_ _IF_ARGS_ 0 1 X 3 \ (u0 :: Double#) -> case _#_ divideDouble# [] [1.0000000000000000##, u0] of { _PRIM_ (u1 :: Double#) -> _!_ D# [] [u1] } _N_} _F_ _IF_ARGS_ 0 1 C 4 \ (u0 :: Double) -> case u0 of { _ALG_ D# (u1 :: Double#) -> case _#_ divideDouble# [] [1.0000000000000000##, u1] of { _PRIM_ (u2 :: Double#) -> _!_ D# [] [u2] }; _NO_DEFLT_ } _N_ },
+ fromRational = { _A_ 1 _U_ 1 _N_ _S_ "U(U(PPP)U(PPP))" {_A_ 4 _U_ 2222 _N_ _N_ _N_ _N_} _N_ _N_ } #-}
instance Num Double
{-# GHC_PRAGMA _M_ PreludeCore {-dfun-} _A_ 0 _N_ _N_ _N_ _F_ _IF_ARGS_ 0 0 X 11 _!_ _TUP_10 [{{Eq Double}}, {{Text Double}}, (Double -> Double -> Double), (Double -> Double -> Double), (Double -> Double -> Double), (Double -> Double), (Double -> Double), (Double -> Double), (Integer -> Double), (Int -> Double)] [_DFUN_ Eq (Double), _DFUN_ Text (Double), _CONSTM_ Num (+) (Double), _CONSTM_ Num (-) (Double), _CONSTM_ Num (*) (Double), _CONSTM_ Num negate (Double), _CONSTM_ Num abs (Double), _CONSTM_ Num signum (Double), _CONSTM_ Num fromInteger (Double), _CONSTM_ Num fromInt (Double)] _N_
- (+) = _A_ 2 _U_ 11 _N_ _S_ "U(P)U(P)" {_A_ 2 _U_ 22 _N_ _N_ _F_ _IF_ARGS_ 0 2 XX 3 \ (u0 :: Double#) (u1 :: Double#) -> case _#_ plusDouble# [] [u0, u1] of { _PRIM_ (u2 :: Double#) -> _!_ D# [] [u2] } _N_} _F_ _IF_ARGS_ 0 2 CC 5 \ (u0 :: Double) (u1 :: Double) -> case u0 of { _ALG_ D# (u2 :: Double#) -> case u1 of { _ALG_ D# (u3 :: Double#) -> case _#_ plusDouble# [] [u2, u3] of { _PRIM_ (u4 :: Double#) -> _!_ D# [] [u4] }; _NO_DEFLT_ }; _NO_DEFLT_ } _N_,
- (-) = _A_ 2 _U_ 11 _N_ _S_ "U(P)U(P)" {_A_ 2 _U_ 22 _N_ _N_ _F_ _IF_ARGS_ 0 2 XX 3 \ (u0 :: Double#) (u1 :: Double#) -> case _#_ minusDouble# [] [u0, u1] of { _PRIM_ (u2 :: Double#) -> _!_ D# [] [u2] } _N_} _F_ _IF_ARGS_ 0 2 CC 5 \ (u0 :: Double) (u1 :: Double) -> case u0 of { _ALG_ D# (u2 :: Double#) -> case u1 of { _ALG_ D# (u3 :: Double#) -> case _#_ minusDouble# [] [u2, u3] of { _PRIM_ (u4 :: Double#) -> _!_ D# [] [u4] }; _NO_DEFLT_ }; _NO_DEFLT_ } _N_,
- (*) = _A_ 2 _U_ 11 _N_ _S_ "U(P)U(P)" {_A_ 2 _U_ 22 _N_ _N_ _F_ _IF_ARGS_ 0 2 XX 3 \ (u0 :: Double#) (u1 :: Double#) -> case _#_ timesDouble# [] [u0, u1] of { _PRIM_ (u2 :: Double#) -> _!_ D# [] [u2] } _N_} _F_ _IF_ARGS_ 0 2 CC 5 \ (u0 :: Double) (u1 :: Double) -> case u0 of { _ALG_ D# (u2 :: Double#) -> case u1 of { _ALG_ D# (u3 :: Double#) -> case _#_ timesDouble# [] [u2, u3] of { _PRIM_ (u4 :: Double#) -> _!_ D# [] [u4] }; _NO_DEFLT_ }; _NO_DEFLT_ } _N_,
- negate = _A_ 1 _U_ 1 _N_ _S_ "U(P)" {_A_ 1 _U_ 2 _N_ _N_ _F_ _IF_ARGS_ 0 1 X 3 \ (u0 :: Double#) -> case _#_ negateDouble# [] [u0] of { _PRIM_ (u1 :: Double#) -> _!_ D# [] [u1] } _N_} _F_ _IF_ARGS_ 0 1 C 4 \ (u0 :: Double) -> case u0 of { _ALG_ D# (u1 :: Double#) -> case _#_ negateDouble# [] [u1] of { _PRIM_ (u2 :: Double#) -> _!_ D# [] [u2] }; _NO_DEFLT_ } _N_,
- abs = _A_ 1 _U_ 1 _N_ _S_ "U(P)" {_A_ 1 _U_ 2 _N_ _N_ _N_ _N_} _N_ _N_,
- signum = _A_ 1 _U_ 1 _N_ _S_ "U(P)" {_A_ 1 _U_ 2 _N_ _N_ _N_ _N_} _N_ _N_,
- fromInteger = _A_ 1 _U_ 1 _N_ _S_ "U(PPP)" {_A_ 3 _U_ 222 _N_ _N_ _F_ _IF_ARGS_ 0 3 XXX 3 \ (u0 :: Int#) (u1 :: Int#) (u2 :: ByteArray#) -> case _#_ encodeDouble# [] [u0, u1, u2, 0#] of { _PRIM_ (u3 :: Double#) -> _!_ D# [] [u3] } _N_} _F_ _IF_ARGS_ 0 1 C 4 \ (u0 :: Integer) -> case u0 of { _ALG_ J# (u1 :: Int#) (u2 :: Int#) (u3 :: ByteArray#) -> case _#_ encodeDouble# [] [u1, u2, u3, 0#] of { _PRIM_ (u4 :: Double#) -> _!_ D# [] [u4] }; _NO_DEFLT_ } _N_,
- fromInt = _A_ 1 _U_ 1 _N_ _S_ "U(P)" {_A_ 1 _U_ 2 _N_ _N_ _F_ _IF_ARGS_ 0 1 X 3 \ (u0 :: Int#) -> case _#_ int2Double# [] [u0] of { _PRIM_ (u1 :: Double#) -> _!_ D# [] [u1] } _N_} _F_ _IF_ARGS_ 0 1 C 4 \ (u0 :: Int) -> case u0 of { _ALG_ I# (u1 :: Int#) -> case _#_ int2Double# [] [u1] of { _PRIM_ (u2 :: Double#) -> _!_ D# [] [u2] }; _NO_DEFLT_ } _N_ #-}
+ (+) = { _A_ 2 _U_ 11 _N_ _S_ "U(P)U(P)" {_A_ 2 _U_ 22 _N_ _N_ _F_ _IF_ARGS_ 0 2 XX 3 \ (u0 :: Double#) (u1 :: Double#) -> case _#_ plusDouble# [] [u0, u1] of { _PRIM_ (u2 :: Double#) -> _!_ D# [] [u2] } _N_} _F_ _IF_ARGS_ 0 2 CC 5 \ (u0 :: Double) (u1 :: Double) -> case u0 of { _ALG_ D# (u2 :: Double#) -> case u1 of { _ALG_ D# (u3 :: Double#) -> case _#_ plusDouble# [] [u2, u3] of { _PRIM_ (u4 :: Double#) -> _!_ D# [] [u4] }; _NO_DEFLT_ }; _NO_DEFLT_ } _N_ },
+ (-) = { _A_ 2 _U_ 11 _N_ _S_ "U(P)U(P)" {_A_ 2 _U_ 22 _N_ _N_ _F_ _IF_ARGS_ 0 2 XX 3 \ (u0 :: Double#) (u1 :: Double#) -> case _#_ minusDouble# [] [u0, u1] of { _PRIM_ (u2 :: Double#) -> _!_ D# [] [u2] } _N_} _F_ _IF_ARGS_ 0 2 CC 5 \ (u0 :: Double) (u1 :: Double) -> case u0 of { _ALG_ D# (u2 :: Double#) -> case u1 of { _ALG_ D# (u3 :: Double#) -> case _#_ minusDouble# [] [u2, u3] of { _PRIM_ (u4 :: Double#) -> _!_ D# [] [u4] }; _NO_DEFLT_ }; _NO_DEFLT_ } _N_ },
+ (*) = { _A_ 2 _U_ 11 _N_ _S_ "U(P)U(P)" {_A_ 2 _U_ 22 _N_ _N_ _F_ _IF_ARGS_ 0 2 XX 3 \ (u0 :: Double#) (u1 :: Double#) -> case _#_ timesDouble# [] [u0, u1] of { _PRIM_ (u2 :: Double#) -> _!_ D# [] [u2] } _N_} _F_ _IF_ARGS_ 0 2 CC 5 \ (u0 :: Double) (u1 :: Double) -> case u0 of { _ALG_ D# (u2 :: Double#) -> case u1 of { _ALG_ D# (u3 :: Double#) -> case _#_ timesDouble# [] [u2, u3] of { _PRIM_ (u4 :: Double#) -> _!_ D# [] [u4] }; _NO_DEFLT_ }; _NO_DEFLT_ } _N_ },
+ negate = { _A_ 1 _U_ 1 _N_ _S_ "U(P)" {_A_ 1 _U_ 2 _N_ _N_ _F_ _IF_ARGS_ 0 1 X 3 \ (u0 :: Double#) -> case _#_ negateDouble# [] [u0] of { _PRIM_ (u1 :: Double#) -> _!_ D# [] [u1] } _N_} _F_ _IF_ARGS_ 0 1 C 4 \ (u0 :: Double) -> case u0 of { _ALG_ D# (u1 :: Double#) -> case _#_ negateDouble# [] [u1] of { _PRIM_ (u2 :: Double#) -> _!_ D# [] [u2] }; _NO_DEFLT_ } _N_ },
+ abs = { _A_ 1 _U_ 1 _N_ _S_ "U(P)" {_A_ 1 _U_ 2 _N_ _N_ _N_ _N_} _N_ _N_ },
+ signum = { _A_ 1 _U_ 1 _N_ _S_ "U(P)" {_A_ 1 _U_ 2 _N_ _N_ _N_ _N_} _N_ _N_ },
+ fromInteger = { _A_ 1 _U_ 1 _N_ _S_ "U(PPP)" {_A_ 3 _U_ 222 _N_ _N_ _F_ _IF_ARGS_ 0 3 XXX 3 \ (u0 :: Int#) (u1 :: Int#) (u2 :: ByteArray#) -> case _#_ encodeDouble# [] [u0, u1, u2, 0#] of { _PRIM_ (u3 :: Double#) -> _!_ D# [] [u3] } _N_} _F_ _IF_ARGS_ 0 1 C 4 \ (u0 :: Integer) -> case u0 of { _ALG_ J# (u1 :: Int#) (u2 :: Int#) (u3 :: ByteArray#) -> case _#_ encodeDouble# [] [u1, u2, u3, 0#] of { _PRIM_ (u4 :: Double#) -> _!_ D# [] [u4] }; _NO_DEFLT_ } _N_ },
+ fromInt = { _A_ 1 _U_ 1 _N_ _S_ "U(P)" {_A_ 1 _U_ 2 _N_ _N_ _F_ _IF_ARGS_ 0 1 X 3 \ (u0 :: Int#) -> case _#_ int2Double# [] [u0] of { _PRIM_ (u1 :: Double#) -> _!_ D# [] [u1] } _N_} _F_ _IF_ARGS_ 0 1 C 4 \ (u0 :: Int) -> case u0 of { _ALG_ I# (u1 :: Int#) -> case _#_ int2Double# [] [u1] of { _PRIM_ (u2 :: Double#) -> _!_ D# [] [u2] }; _NO_DEFLT_ } _N_ } #-}
instance Ord Double
{-# GHC_PRAGMA _M_ PreludeCore {-dfun-} _A_ 0 _N_ _N_ _N_ _F_ _IF_ARGS_ 0 0 X 9 _!_ _TUP_8 [{{Eq Double}}, (Double -> Double -> Bool), (Double -> Double -> Bool), (Double -> Double -> Bool), (Double -> Double -> Bool), (Double -> Double -> Double), (Double -> Double -> Double), (Double -> Double -> _CMP_TAG)] [_DFUN_ Eq (Double), _CONSTM_ Ord (<) (Double), _CONSTM_ Ord (<=) (Double), _CONSTM_ Ord (>=) (Double), _CONSTM_ Ord (>) (Double), _CONSTM_ Ord max (Double), _CONSTM_ Ord min (Double), _CONSTM_ Ord _tagCmp (Double)] _N_
- (<) = _A_ 2 _U_ 11 _N_ _S_ "U(P)U(P)" {_A_ 2 _U_ 22 _N_ _N_ _F_ _IF_ARGS_ 0 2 XX 1 \ (u0 :: Double#) (u1 :: Double#) -> _#_ ltDouble# [] [u0, u1] _N_} _F_ _IF_ARGS_ 0 2 CC 3 \ (u0 :: Double) (u1 :: Double) -> case u0 of { _ALG_ D# (u2 :: Double#) -> case u1 of { _ALG_ D# (u3 :: Double#) -> _#_ ltDouble# [] [u2, u3]; _NO_DEFLT_ }; _NO_DEFLT_ } _N_,
- (<=) = _A_ 2 _U_ 11 _N_ _S_ "U(P)U(P)" {_A_ 2 _U_ 22 _N_ _N_ _F_ _IF_ARGS_ 0 2 XX 1 \ (u0 :: Double#) (u1 :: Double#) -> _#_ leDouble# [] [u0, u1] _N_} _F_ _IF_ARGS_ 0 2 CC 3 \ (u0 :: Double) (u1 :: Double) -> case u0 of { _ALG_ D# (u2 :: Double#) -> case u1 of { _ALG_ D# (u3 :: Double#) -> _#_ leDouble# [] [u2, u3]; _NO_DEFLT_ }; _NO_DEFLT_ } _N_,
- (>=) = _A_ 2 _U_ 11 _N_ _S_ "U(P)U(P)" {_A_ 2 _U_ 22 _N_ _N_ _F_ _IF_ARGS_ 0 2 XX 1 \ (u0 :: Double#) (u1 :: Double#) -> _#_ geDouble# [] [u0, u1] _N_} _F_ _IF_ARGS_ 0 2 CC 3 \ (u0 :: Double) (u1 :: Double) -> case u0 of { _ALG_ D# (u2 :: Double#) -> case u1 of { _ALG_ D# (u3 :: Double#) -> _#_ geDouble# [] [u2, u3]; _NO_DEFLT_ }; _NO_DEFLT_ } _N_,
- (>) = _A_ 2 _U_ 11 _N_ _S_ "U(P)U(P)" {_A_ 2 _U_ 22 _N_ _N_ _F_ _IF_ARGS_ 0 2 XX 1 \ (u0 :: Double#) (u1 :: Double#) -> _#_ gtDouble# [] [u0, u1] _N_} _F_ _IF_ARGS_ 0 2 CC 3 \ (u0 :: Double) (u1 :: Double) -> case u0 of { _ALG_ D# (u2 :: Double#) -> case u1 of { _ALG_ D# (u3 :: Double#) -> _#_ gtDouble# [] [u2, u3]; _NO_DEFLT_ }; _NO_DEFLT_ } _N_,
- max = _A_ 2 _U_ 11 _N_ _S_ "U(P)U(P)" {_A_ 2 _U_ 22 _N_ _N_ _N_ _N_} _N_ _N_,
- min = _A_ 2 _U_ 11 _N_ _S_ "U(P)U(P)" {_A_ 2 _U_ 22 _N_ _N_ _N_ _N_} _N_ _N_,
- _tagCmp = _A_ 2 _U_ 11 _N_ _S_ "U(P)U(P)" {_A_ 2 _U_ 22 _N_ _N_ _N_ _N_} _N_ _N_ #-}
+ (<) = { _A_ 2 _U_ 11 _N_ _S_ "U(P)U(P)" {_A_ 2 _U_ 22 _N_ _N_ _F_ _IF_ARGS_ 0 2 XX 1 \ (u0 :: Double#) (u1 :: Double#) -> _#_ ltDouble# [] [u0, u1] _N_} _F_ _IF_ARGS_ 0 2 CC 3 \ (u0 :: Double) (u1 :: Double) -> case u0 of { _ALG_ D# (u2 :: Double#) -> case u1 of { _ALG_ D# (u3 :: Double#) -> _#_ ltDouble# [] [u2, u3]; _NO_DEFLT_ }; _NO_DEFLT_ } _N_ },
+ (<=) = { _A_ 2 _U_ 11 _N_ _S_ "U(P)U(P)" {_A_ 2 _U_ 22 _N_ _N_ _F_ _IF_ARGS_ 0 2 XX 1 \ (u0 :: Double#) (u1 :: Double#) -> _#_ leDouble# [] [u0, u1] _N_} _F_ _IF_ARGS_ 0 2 CC 3 \ (u0 :: Double) (u1 :: Double) -> case u0 of { _ALG_ D# (u2 :: Double#) -> case u1 of { _ALG_ D# (u3 :: Double#) -> _#_ leDouble# [] [u2, u3]; _NO_DEFLT_ }; _NO_DEFLT_ } _N_ },
+ (>=) = { _A_ 2 _U_ 11 _N_ _S_ "U(P)U(P)" {_A_ 2 _U_ 22 _N_ _N_ _F_ _IF_ARGS_ 0 2 XX 1 \ (u0 :: Double#) (u1 :: Double#) -> _#_ geDouble# [] [u0, u1] _N_} _F_ _IF_ARGS_ 0 2 CC 3 \ (u0 :: Double) (u1 :: Double) -> case u0 of { _ALG_ D# (u2 :: Double#) -> case u1 of { _ALG_ D# (u3 :: Double#) -> _#_ geDouble# [] [u2, u3]; _NO_DEFLT_ }; _NO_DEFLT_ } _N_ },
+ (>) = { _A_ 2 _U_ 11 _N_ _S_ "U(P)U(P)" {_A_ 2 _U_ 22 _N_ _N_ _F_ _IF_ARGS_ 0 2 XX 1 \ (u0 :: Double#) (u1 :: Double#) -> _#_ gtDouble# [] [u0, u1] _N_} _F_ _IF_ARGS_ 0 2 CC 3 \ (u0 :: Double) (u1 :: Double) -> case u0 of { _ALG_ D# (u2 :: Double#) -> case u1 of { _ALG_ D# (u3 :: Double#) -> _#_ gtDouble# [] [u2, u3]; _NO_DEFLT_ }; _NO_DEFLT_ } _N_ },
+ max = { _A_ 2 _U_ 11 _N_ _S_ "U(P)U(P)" {_A_ 2 _U_ 22 _N_ _N_ _N_ _N_} _N_ _N_ },
+ min = { _A_ 2 _U_ 11 _N_ _S_ "U(P)U(P)" {_A_ 2 _U_ 22 _N_ _N_ _N_ _N_} _N_ _N_ },
+ _tagCmp = { _A_ 2 _U_ 11 _N_ _S_ "U(P)U(P)" {_A_ 2 _U_ 22 _N_ _N_ _N_ _N_} _N_ _N_ } #-}
instance Real Double
{-# GHC_PRAGMA _M_ PreludeCore {-dfun-} _A_ 0 _N_ _N_ _N_ _F_ _IF_ARGS_ 0 0 X 4 _!_ _TUP_3 [{{Num Double}}, {{Enum Double}}, (Double -> Ratio Integer)] [_DFUN_ Num (Double), _DFUN_ Enum (Double), _CONSTM_ Real toRational (Double)] _N_
- toRational = _A_ 1 _U_ 1 _N_ _S_ "U(P)" {_A_ 1 _U_ 2 _N_ _N_ _N_ _N_} _N_ _N_ #-}
+ toRational = { _A_ 1 _U_ 1 _N_ _S_ "U(P)" {_A_ 1 _U_ 2 _N_ _N_ _N_ _N_} _N_ _N_ } #-}
instance RealFloat Double
{-# GHC_PRAGMA _M_ PreludeCore {-dfun-} _A_ 0 _N_ _N_ _N_ _F_ _IF_ARGS_ 0 0 X 11 _!_ _TUP_10 [{{RealFrac Double}}, {{Floating Double}}, (Double -> Integer), (Double -> Int), (Double -> (Int, Int)), (Double -> (Integer, Int)), (Integer -> Int -> Double), (Double -> Int), (Double -> Double), (Int -> Double -> Double)] [_DFUN_ RealFrac (Double), _DFUN_ Floating (Double), _CONSTM_ RealFloat floatRadix (Double), _CONSTM_ RealFloat floatDigits (Double), _CONSTM_ RealFloat floatRange (Double), _CONSTM_ RealFloat decodeFloat (Double), _CONSTM_ RealFloat encodeFloat (Double), _CONSTM_ RealFloat exponent (Double), _CONSTM_ RealFloat significand (Double), _CONSTM_ RealFloat scaleFloat (Double)] _N_
- floatRadix = _A_ 1 _U_ 0 _N_ _S_ "A" {_A_ 0 _N_ _N_ _N_ _F_ _IF_ARGS_ 0 0 X 1 _#_ int2Integer# [] [2#] _N_} _N_ _N_,
- floatDigits = _A_ 1 _U_ 0 _N_ _S_ "A" {_A_ 0 _N_ _N_ _N_ _F_ _IF_ARGS_ 0 0 X 2 _!_ I# [] [53#] _N_} _F_ _IF_ARGS_ 0 1 X 2 \ (u0 :: Double) -> _!_ I# [] [53#] _N_,
- floatRange = _A_ 1 _U_ 0 _N_ _S_ "A" {_A_ 0 _N_ _N_ _N_ _N_ _N_} _N_ _N_,
- decodeFloat = _A_ 1 _U_ 1 _N_ _S_ "U(P)" {_A_ 1 _U_ 2 _N_ _N_ _N_ _N_} _N_ _N_,
- encodeFloat = _A_ 2 _U_ 11 _N_ _S_ "U(PPP)U(P)" {_A_ 4 _U_ 2222 _N_ _N_ _F_ _IF_ARGS_ 0 4 XXXX 3 \ (u0 :: Int#) (u1 :: Int#) (u2 :: ByteArray#) (u3 :: Int#) -> case _#_ encodeDouble# [] [u0, u1, u2, u3] of { _PRIM_ (u4 :: Double#) -> _!_ D# [] [u4] } _N_} _F_ _IF_ARGS_ 0 2 CC 5 \ (u0 :: Integer) (u1 :: Int) -> case u0 of { _ALG_ J# (u2 :: Int#) (u3 :: Int#) (u4 :: ByteArray#) -> case u1 of { _ALG_ I# (u5 :: Int#) -> case _#_ encodeDouble# [] [u2, u3, u4, u5] of { _PRIM_ (u6 :: Double#) -> _!_ D# [] [u6] }; _NO_DEFLT_ }; _NO_DEFLT_ } _N_,
- exponent = _A_ 1 _U_ 2 _N_ _N_ _N_ _N_,
- significand = _A_ 1 _U_ 2 _N_ _N_ _N_ _N_,
- scaleFloat = _A_ 2 _U_ 22 _N_ _N_ _N_ _N_ #-}
+ floatRadix = { _A_ 1 _U_ 0 _N_ _S_ "A" {_A_ 0 _N_ _N_ _N_ _N_ _N_} _N_ _N_ },
+ floatDigits = { _A_ 1 _U_ 0 _N_ _S_ "A" {_A_ 0 _N_ _N_ _N_ _F_ _IF_ARGS_ 0 0 X 2 _!_ I# [] [53#] _N_} _F_ _IF_ARGS_ 0 1 X 2 \ (u0 :: Double) -> _!_ I# [] [53#] _N_ },
+ floatRange = { _A_ 1 _U_ 0 _N_ _S_ "A" {_A_ 0 _N_ _N_ _N_ _N_ _N_} _N_ _N_ },
+ decodeFloat = { _A_ 1 _U_ 1 _N_ _S_ "U(P)" {_A_ 1 _U_ 2 _N_ _N_ _N_ _N_} _N_ _N_ },
+ encodeFloat = { _A_ 2 _U_ 11 _N_ _S_ "U(PPP)U(P)" {_A_ 4 _U_ 2222 _N_ _N_ _F_ _IF_ARGS_ 0 4 XXXX 3 \ (u0 :: Int#) (u1 :: Int#) (u2 :: ByteArray#) (u3 :: Int#) -> case _#_ encodeDouble# [] [u0, u1, u2, u3] of { _PRIM_ (u4 :: Double#) -> _!_ D# [] [u4] } _N_} _F_ _IF_ARGS_ 0 2 CC 5 \ (u0 :: Integer) (u1 :: Int) -> case u0 of { _ALG_ J# (u2 :: Int#) (u3 :: Int#) (u4 :: ByteArray#) -> case u1 of { _ALG_ I# (u5 :: Int#) -> case _#_ encodeDouble# [] [u2, u3, u4, u5] of { _PRIM_ (u6 :: Double#) -> _!_ D# [] [u6] }; _NO_DEFLT_ }; _NO_DEFLT_ } _N_ },
+ exponent = { _A_ 1 _U_ 1 _N_ _S_ "U(P)" {_A_ 1 _U_ 2 _N_ _N_ _N_ _N_} _N_ _N_ },
+ significand = { _A_ 1 _U_ 1 _N_ _S_ "U(P)" {_A_ 1 _U_ 2 _N_ _N_ _N_ _N_} _N_ _N_ },
+ scaleFloat = { _A_ 2 _U_ 11 _N_ _S_ "U(P)U(P)" {_A_ 2 _U_ 22 _N_ _N_ _N_ _N_} _N_ _N_ } #-}
instance RealFrac Double
{-# GHC_PRAGMA _M_ PreludeCore {-dfun-} _A_ 0 _N_ _N_ _N_ _F_ _IF_ARGS_ 0 0 X 8 _!_ _TUP_7 [{{Real Double}}, {{Fractional Double}}, _forall_ a$z1 =>{{Integral a$z1}} -> (Double -> (a$z1, Double)), _forall_ a$z1 =>{{Integral a$z1}} -> (Double -> a$z1), _forall_ a$z1 =>{{Integral a$z1}} -> (Double -> a$z1), _forall_ a$z1 =>{{Integral a$z1}} -> (Double -> a$z1), _forall_ a$z1 =>{{Integral a$z1}} -> (Double -> a$z1)] [_DFUN_ Real (Double), _DFUN_ Fractional (Double), _CONSTM_ RealFrac properFraction (Double), _CONSTM_ RealFrac truncate (Double), _CONSTM_ RealFrac round (Double), _CONSTM_ RealFrac ceiling (Double), _CONSTM_ RealFrac floor (Double)] _N_
- properFraction = _A_ 1 _U_ 22 _N_ _N_ _N_ _N_,
- truncate = _A_ 1 _U_ 22 _N_ _N_ _N_ _N_,
- round = _A_ 1 _U_ 22 _N_ _N_ _N_ _N_,
- ceiling = _A_ 1 _U_ 22 _N_ _N_ _N_ _N_,
- floor = _A_ 1 _U_ 22 _N_ _N_ _N_ _N_ #-}
+ properFraction = { _A_ 1 _U_ 11 _N_ _N_ _N_ _SPECIALISE_ [ Int ] 1 { _A_ 1 _U_ 1 _N_ _S_ "U(P)" {_A_ 1 _U_ 2 _N_ _N_ _N_ _N_} _N_ _N_ }, [ Integer ] 1 { _A_ 1 _U_ 1 _N_ _S_ "U(P)" {_A_ 1 _U_ 2 _N_ _N_ _N_ _N_} _N_ _N_ } },
+ truncate = { _A_ 1 _U_ 11 _N_ _N_ _N_ _SPECIALISE_ [ Int ] 1 { _A_ 1 _U_ 1 _N_ _S_ "U(P)" {_A_ 1 _U_ 2 _N_ _N_ _F_ _IF_ARGS_ 0 1 X 4 \ (u0 :: Double#) -> case _APP_ _WRKR_ _SPEC_ _CONSTM_ RealFrac properFraction (Double) [ (Int) ] [ u0 ] of { _ALG_ _TUP_2 (u1 :: Int) (u2 :: Double) -> u1; _NO_DEFLT_ } _N_} _F_ _IF_ARGS_ 0 1 X 4 \ (u0 :: Double) -> case _APP_ _SPEC_ _CONSTM_ RealFrac properFraction (Double) [ (Int) ] [ u0 ] of { _ALG_ _TUP_2 (u1 :: Int) (u2 :: Double) -> u1; _NO_DEFLT_ } _N_ }, [ Integer ] 1 { _A_ 1 _U_ 1 _N_ _S_ "U(P)" {_A_ 1 _U_ 2 _N_ _N_ _F_ _IF_ARGS_ 0 1 X 4 \ (u0 :: Double#) -> case _APP_ _WRKR_ _SPEC_ _CONSTM_ RealFrac properFraction (Double) [ (Integer) ] [ u0 ] of { _ALG_ _TUP_2 (u1 :: Integer) (u2 :: Double) -> u1; _NO_DEFLT_ } _N_} _F_ _IF_ARGS_ 0 1 X 4 \ (u0 :: Double) -> case _APP_ _SPEC_ _CONSTM_ RealFrac properFraction (Double) [ (Integer) ] [ u0 ] of { _ALG_ _TUP_2 (u1 :: Integer) (u2 :: Double) -> u1; _NO_DEFLT_ } _N_ } },
+ round = { _A_ 1 _U_ 21 _N_ _N_ _N_ _SPECIALISE_ [ Int ] 1 { _A_ 1 _U_ 1 _N_ _S_ "U(P)" {_A_ 1 _U_ 2 _N_ _N_ _N_ _N_} _N_ _N_ }, [ Integer ] 1 { _A_ 1 _U_ 1 _N_ _S_ "U(P)" {_A_ 1 _U_ 2 _N_ _N_ _N_ _N_} _N_ _N_ } },
+ ceiling = { _A_ 1 _U_ 21 _N_ _N_ _N_ _SPECIALISE_ [ Int ] 1 { _A_ 1 _U_ 1 _N_ _S_ "U(P)" {_A_ 1 _U_ 2 _N_ _N_ _N_ _N_} _N_ _N_ }, [ Integer ] 1 { _A_ 1 _U_ 1 _N_ _S_ "U(P)" {_A_ 1 _U_ 2 _N_ _N_ _N_ _N_} _N_ _N_ } },
+ floor = { _A_ 1 _U_ 21 _N_ _N_ _N_ _SPECIALISE_ [ Int ] 1 { _A_ 1 _U_ 1 _N_ _S_ "U(P)" {_A_ 1 _U_ 2 _N_ _N_ _N_ _N_} _N_ _N_ }, [ Integer ] 1 { _A_ 1 _U_ 1 _N_ _S_ "U(P)" {_A_ 1 _U_ 2 _N_ _N_ _N_ _N_} _N_ _N_ } } #-}
instance Text Double
{-# GHC_PRAGMA _M_ PreludeCore {-dfun-} _A_ 0 _N_ _N_ _N_ _F_ _IF_ARGS_ 0 0 X 5 _!_ _TUP_4 [(Int -> [Char] -> [(Double, [Char])]), (Int -> Double -> [Char] -> [Char]), ([Char] -> [([Double], [Char])]), ([Double] -> [Char] -> [Char])] [_CONSTM_ Text readsPrec (Double), _CONSTM_ Text showsPrec (Double), _CONSTM_ Text readList (Double), _CONSTM_ Text showList (Double)] _N_
- readsPrec = _A_ 2 _U_ 02 _N_ _S_ "AL" {_A_ 1 _U_ 2 _N_ _N_ _F_ _IF_ARGS_ 0 1 X 3 \ (u0 :: [Char]) -> _APP_ _SPEC_ _ORIG_ PreludeText readSigned [ (Double) ] [ _SPEC_ _ORIG_ PreludeText readFloat [ (Double) ], u0 ] _N_} _F_ _IF_ARGS_ 0 2 XX 3 \ (u0 :: Int) (u1 :: [Char]) -> _APP_ _SPEC_ _ORIG_ PreludeText readSigned [ (Double) ] [ _SPEC_ _ORIG_ PreludeText readFloat [ (Double) ], u1 ] _N_,
- showsPrec = _A_ 2 _U_ 212 _N_ _S_ "LU(P)" {_A_ 2 _U_ 222 _N_ _N_ _F_ _IF_ARGS_ 0 2 XX 4 \ (u0 :: Int) (u1 :: Double#) -> _APP_ _WRKR_ _SPEC_ _ORIG_ PreludeText showSigned [ (Double) ] [ _SPEC_ _ORIG_ PreludeText showFloat [ (Double) ], u0, u1 ] _N_} _F_ _IF_ARGS_ 0 2 XC 5 \ (u0 :: Int) (u1 :: Double) -> case u1 of { _ALG_ D# (u2 :: Double#) -> _APP_ _WRKR_ _SPEC_ _ORIG_ PreludeText showSigned [ (Double) ] [ _SPEC_ _ORIG_ PreludeText showFloat [ (Double) ], u0, u2 ]; _NO_DEFLT_ } _N_,
- readList = _A_ 0 _U_ 2 _N_ _N_ _N_ _N_,
- showList = _A_ 0 _U_ 12 _N_ _N_ _N_ _N_ #-}
+ readsPrec = { _A_ 2 _U_ 02 _N_ _S_ "AL" {_A_ 1 _U_ 2 _N_ _N_ _F_ _IF_ARGS_ 0 1 X 3 \ (u0 :: [Char]) -> _APP_ _SPEC_ _ORIG_ PreludeText readSigned [ (Double) ] [ _SPEC_ _ORIG_ PreludeText readFloat [ (Double) ], u0 ] _N_} _F_ _IF_ARGS_ 0 2 XX 3 \ (u0 :: Int) (u1 :: [Char]) -> _APP_ _SPEC_ _ORIG_ PreludeText readSigned [ (Double) ] [ _SPEC_ _ORIG_ PreludeText readFloat [ (Double) ], u1 ] _N_ },
+ showsPrec = { _A_ 2 _U_ 212 _N_ _S_ "LU(P)" {_A_ 2 _U_ 222 _N_ _N_ _F_ _IF_ARGS_ 0 2 XX 4 \ (u0 :: Int) (u1 :: Double#) -> _APP_ _WRKR_ _SPEC_ _ORIG_ PreludeText showSigned [ (Double) ] [ _SPEC_ _ORIG_ PreludeText showFloat [ (Double) ], u0, u1 ] _N_} _F_ _IF_ARGS_ 0 2 XC 5 \ (u0 :: Int) (u1 :: Double) -> case u1 of { _ALG_ D# (u2 :: Double#) -> _APP_ _WRKR_ _SPEC_ _ORIG_ PreludeText showSigned [ (Double) ] [ _SPEC_ _ORIG_ PreludeText showFloat [ (Double) ], u0, u2 ]; _NO_DEFLT_ } _N_ },
+ readList = { _A_ 0 _U_ 2 _N_ _N_ _N_ _N_ },
+ showList = { _A_ 1 _U_ 12 _N_ _N_ _N_ _N_ } #-}
instance _CCallable Double
{-# GHC_PRAGMA _M_ PreludeCore {-dfun-} _A_ 0 _N_ _N_ _N_ _F_ _IF_ARGS_ 0 0 X 1 _!_ _TUP_0 [] [] _N_ #-}
instance _CReturnable Double
-{-# GHC_PRAGMA INTERFACE VERSION 5 #-}
+{-# GHC_PRAGMA INTERFACE VERSION 6 #-}
interface PreludeCore where
import PreludeBuiltin(Float(..))
instance Enum Float
{-# GHC_PRAGMA _M_ PreludeCore {-dfun-} _A_ 0 _N_ _N_ _N_ _F_ _IF_ARGS_ 0 0 X 6 _!_ _TUP_5 [{{Ord Float}}, (Float -> [Float]), (Float -> Float -> [Float]), (Float -> Float -> [Float]), (Float -> Float -> Float -> [Float])] [_DFUN_ Ord (Float), _CONSTM_ Enum enumFrom (Float), _CONSTM_ Enum enumFromThen (Float), _CONSTM_ Enum enumFromTo (Float), _CONSTM_ Enum enumFromThenTo (Float)] _N_
- enumFrom = _A_ 1 _U_ 2 _N_ _N_ _N_ _N_,
- enumFromThen = _A_ 2 _U_ 21 _N_ _N_ _N_ _N_,
- enumFromTo = _A_ 2 _U_ 22 _N_ _N_ _N_ _N_,
- enumFromThenTo = _A_ 3 _U_ 222 _N_ _N_ _N_ _N_ #-}
+ enumFrom = { _A_ 1 _U_ 2 _N_ _N_ _N_ _N_ },
+ enumFromThen = { _A_ 2 _U_ 21 _N_ _N_ _N_ _N_ },
+ enumFromTo = { _A_ 2 _U_ 22 _N_ _N_ _N_ _N_ },
+ enumFromThenTo = { _A_ 3 _U_ 222 _N_ _N_ _N_ _N_ } #-}
instance Eq Float
{-# GHC_PRAGMA _M_ PreludeCore {-dfun-} _A_ 0 _N_ _N_ _N_ _F_ _IF_ARGS_ 0 0 X 3 _!_ _TUP_2 [(Float -> Float -> Bool), (Float -> Float -> Bool)] [_CONSTM_ Eq (==) (Float), _CONSTM_ Eq (/=) (Float)] _N_
- (==) = _A_ 2 _U_ 11 _N_ _S_ "U(P)U(P)" {_A_ 2 _U_ 22 _N_ _N_ _F_ _IF_ARGS_ 0 2 XX 1 \ (u0 :: Float#) (u1 :: Float#) -> _#_ eqFloat# [] [u0, u1] _N_} _F_ _IF_ARGS_ 0 2 CC 3 \ (u0 :: Float) (u1 :: Float) -> case u0 of { _ALG_ F# (u2 :: Float#) -> case u1 of { _ALG_ F# (u3 :: Float#) -> _#_ eqFloat# [] [u2, u3]; _NO_DEFLT_ }; _NO_DEFLT_ } _N_,
- (/=) = _A_ 2 _U_ 11 _N_ _S_ "U(P)U(P)" {_A_ 2 _U_ 22 _N_ _N_ _F_ _IF_ARGS_ 0 2 XX 1 \ (u0 :: Float#) (u1 :: Float#) -> _#_ neFloat# [] [u0, u1] _N_} _F_ _IF_ARGS_ 0 2 CC 3 \ (u0 :: Float) (u1 :: Float) -> case u0 of { _ALG_ F# (u2 :: Float#) -> case u1 of { _ALG_ F# (u3 :: Float#) -> _#_ neFloat# [] [u2, u3]; _NO_DEFLT_ }; _NO_DEFLT_ } _N_ #-}
+ (==) = { _A_ 2 _U_ 11 _N_ _S_ "U(P)U(P)" {_A_ 2 _U_ 22 _N_ _N_ _F_ _IF_ARGS_ 0 2 XX 1 \ (u0 :: Float#) (u1 :: Float#) -> _#_ eqFloat# [] [u0, u1] _N_} _F_ _IF_ARGS_ 0 2 CC 3 \ (u0 :: Float) (u1 :: Float) -> case u0 of { _ALG_ F# (u2 :: Float#) -> case u1 of { _ALG_ F# (u3 :: Float#) -> _#_ eqFloat# [] [u2, u3]; _NO_DEFLT_ }; _NO_DEFLT_ } _N_ },
+ (/=) = { _A_ 2 _U_ 11 _N_ _S_ "U(P)U(P)" {_A_ 2 _U_ 22 _N_ _N_ _F_ _IF_ARGS_ 0 2 XX 1 \ (u0 :: Float#) (u1 :: Float#) -> _#_ neFloat# [] [u0, u1] _N_} _F_ _IF_ARGS_ 0 2 CC 3 \ (u0 :: Float) (u1 :: Float) -> case u0 of { _ALG_ F# (u2 :: Float#) -> case u1 of { _ALG_ F# (u3 :: Float#) -> _#_ neFloat# [] [u2, u3]; _NO_DEFLT_ }; _NO_DEFLT_ } _N_ } #-}
instance Floating Float
{-# GHC_PRAGMA _M_ PreludeCore {-dfun-} _A_ 0 _N_ _N_ _N_ _F_ _IF_ARGS_ 0 0 X 20 _!_ _TUP_19 [{{Fractional Float}}, Float, (Float -> Float), (Float -> Float), (Float -> Float), (Float -> Float -> Float), (Float -> Float -> Float), (Float -> Float), (Float -> Float), (Float -> Float), (Float -> Float), (Float -> Float), (Float -> Float), (Float -> Float), (Float -> Float), (Float -> Float), (Float -> Float), (Float -> Float), (Float -> Float)] [_DFUN_ Fractional (Float), _CONSTM_ Floating pi (Float), _CONSTM_ Floating exp (Float), _CONSTM_ Floating log (Float), _CONSTM_ Floating sqrt (Float), _CONSTM_ Floating (**) (Float), _CONSTM_ Floating logBase (Float), _CONSTM_ Floating sin (Float), _CONSTM_ Floating cos (Float), _CONSTM_ Floating tan (Float), _CONSTM_ Floating asin (Float), _CONSTM_ Floating acos (Float), _CONSTM_ Floating atan (Float), _CONSTM_ Floating sinh (Float), _CONSTM_ Floating cosh (Float), _CONSTM_ Floating tanh (Float), _CONSTM_ Floating asinh (Float), _CONSTM_ Floating acosh (Float), _CONSTM_ Floating atanh (Float)] _N_
- pi = _A_ 0 _N_ _N_ _N_ _F_ _IF_ARGS_ 0 0 X 2 _!_ F# [] [3.1415926535897931#] _N_,
- exp = _A_ 1 _U_ 1 _N_ _S_ "U(P)" {_A_ 1 _U_ 2 _N_ _N_ _F_ _IF_ARGS_ 0 1 X 3 \ (u0 :: Float#) -> case _#_ expFloat# [] [u0] of { _PRIM_ (u1 :: Float#) -> _!_ F# [] [u1] } _N_} _F_ _IF_ARGS_ 0 1 C 4 \ (u0 :: Float) -> case u0 of { _ALG_ F# (u1 :: Float#) -> case _#_ expFloat# [] [u1] of { _PRIM_ (u2 :: Float#) -> _!_ F# [] [u2] }; _NO_DEFLT_ } _N_,
- log = _A_ 1 _U_ 1 _N_ _S_ "U(P)" {_A_ 1 _U_ 2 _N_ _N_ _F_ _IF_ARGS_ 0 1 X 3 \ (u0 :: Float#) -> case _#_ logFloat# [] [u0] of { _PRIM_ (u1 :: Float#) -> _!_ F# [] [u1] } _N_} _F_ _IF_ARGS_ 0 1 C 4 \ (u0 :: Float) -> case u0 of { _ALG_ F# (u1 :: Float#) -> case _#_ logFloat# [] [u1] of { _PRIM_ (u2 :: Float#) -> _!_ F# [] [u2] }; _NO_DEFLT_ } _N_,
- sqrt = _A_ 1 _U_ 1 _N_ _S_ "U(P)" {_A_ 1 _U_ 2 _N_ _N_ _F_ _IF_ARGS_ 0 1 X 3 \ (u0 :: Float#) -> case _#_ sqrtFloat# [] [u0] of { _PRIM_ (u1 :: Float#) -> _!_ F# [] [u1] } _N_} _F_ _IF_ARGS_ 0 1 C 4 \ (u0 :: Float) -> case u0 of { _ALG_ F# (u1 :: Float#) -> case _#_ sqrtFloat# [] [u1] of { _PRIM_ (u2 :: Float#) -> _!_ F# [] [u2] }; _NO_DEFLT_ } _N_,
- (**) = _A_ 2 _U_ 11 _N_ _S_ "U(P)U(P)" {_A_ 2 _U_ 22 _N_ _N_ _F_ _IF_ARGS_ 0 2 XX 3 \ (u0 :: Float#) (u1 :: Float#) -> case _#_ powerFloat# [] [u0, u1] of { _PRIM_ (u2 :: Float#) -> _!_ F# [] [u2] } _N_} _F_ _IF_ARGS_ 0 2 CC 5 \ (u0 :: Float) (u1 :: Float) -> case u0 of { _ALG_ F# (u2 :: Float#) -> case u1 of { _ALG_ F# (u3 :: Float#) -> case _#_ powerFloat# [] [u2, u3] of { _PRIM_ (u4 :: Float#) -> _!_ F# [] [u4] }; _NO_DEFLT_ }; _NO_DEFLT_ } _N_,
- logBase = _A_ 2 _U_ 22 _N_ _N_ _N_ _N_,
- sin = _A_ 1 _U_ 1 _N_ _S_ "U(P)" {_A_ 1 _U_ 2 _N_ _N_ _F_ _IF_ARGS_ 0 1 X 3 \ (u0 :: Float#) -> case _#_ sinFloat# [] [u0] of { _PRIM_ (u1 :: Float#) -> _!_ F# [] [u1] } _N_} _F_ _IF_ARGS_ 0 1 C 4 \ (u0 :: Float) -> case u0 of { _ALG_ F# (u1 :: Float#) -> case _#_ sinFloat# [] [u1] of { _PRIM_ (u2 :: Float#) -> _!_ F# [] [u2] }; _NO_DEFLT_ } _N_,
- cos = _A_ 1 _U_ 1 _N_ _S_ "U(P)" {_A_ 1 _U_ 2 _N_ _N_ _F_ _IF_ARGS_ 0 1 X 3 \ (u0 :: Float#) -> case _#_ cosFloat# [] [u0] of { _PRIM_ (u1 :: Float#) -> _!_ F# [] [u1] } _N_} _F_ _IF_ARGS_ 0 1 C 4 \ (u0 :: Float) -> case u0 of { _ALG_ F# (u1 :: Float#) -> case _#_ cosFloat# [] [u1] of { _PRIM_ (u2 :: Float#) -> _!_ F# [] [u2] }; _NO_DEFLT_ } _N_,
- tan = _A_ 1 _U_ 1 _N_ _S_ "U(P)" {_A_ 1 _U_ 2 _N_ _N_ _F_ _IF_ARGS_ 0 1 X 3 \ (u0 :: Float#) -> case _#_ tanFloat# [] [u0] of { _PRIM_ (u1 :: Float#) -> _!_ F# [] [u1] } _N_} _F_ _IF_ARGS_ 0 1 C 4 \ (u0 :: Float) -> case u0 of { _ALG_ F# (u1 :: Float#) -> case _#_ tanFloat# [] [u1] of { _PRIM_ (u2 :: Float#) -> _!_ F# [] [u2] }; _NO_DEFLT_ } _N_,
- asin = _A_ 1 _U_ 1 _N_ _S_ "U(P)" {_A_ 1 _U_ 2 _N_ _N_ _F_ _IF_ARGS_ 0 1 X 3 \ (u0 :: Float#) -> case _#_ asinFloat# [] [u0] of { _PRIM_ (u1 :: Float#) -> _!_ F# [] [u1] } _N_} _F_ _IF_ARGS_ 0 1 C 4 \ (u0 :: Float) -> case u0 of { _ALG_ F# (u1 :: Float#) -> case _#_ asinFloat# [] [u1] of { _PRIM_ (u2 :: Float#) -> _!_ F# [] [u2] }; _NO_DEFLT_ } _N_,
- acos = _A_ 1 _U_ 1 _N_ _S_ "U(P)" {_A_ 1 _U_ 2 _N_ _N_ _F_ _IF_ARGS_ 0 1 X 3 \ (u0 :: Float#) -> case _#_ acosFloat# [] [u0] of { _PRIM_ (u1 :: Float#) -> _!_ F# [] [u1] } _N_} _F_ _IF_ARGS_ 0 1 C 4 \ (u0 :: Float) -> case u0 of { _ALG_ F# (u1 :: Float#) -> case _#_ acosFloat# [] [u1] of { _PRIM_ (u2 :: Float#) -> _!_ F# [] [u2] }; _NO_DEFLT_ } _N_,
- atan = _A_ 1 _U_ 1 _N_ _S_ "U(P)" {_A_ 1 _U_ 2 _N_ _N_ _F_ _IF_ARGS_ 0 1 X 3 \ (u0 :: Float#) -> case _#_ atanFloat# [] [u0] of { _PRIM_ (u1 :: Float#) -> _!_ F# [] [u1] } _N_} _F_ _IF_ARGS_ 0 1 C 4 \ (u0 :: Float) -> case u0 of { _ALG_ F# (u1 :: Float#) -> case _#_ atanFloat# [] [u1] of { _PRIM_ (u2 :: Float#) -> _!_ F# [] [u2] }; _NO_DEFLT_ } _N_,
- sinh = _A_ 1 _U_ 1 _N_ _S_ "U(P)" {_A_ 1 _U_ 2 _N_ _N_ _F_ _IF_ARGS_ 0 1 X 3 \ (u0 :: Float#) -> case _#_ sinhFloat# [] [u0] of { _PRIM_ (u1 :: Float#) -> _!_ F# [] [u1] } _N_} _F_ _IF_ARGS_ 0 1 C 4 \ (u0 :: Float) -> case u0 of { _ALG_ F# (u1 :: Float#) -> case _#_ sinhFloat# [] [u1] of { _PRIM_ (u2 :: Float#) -> _!_ F# [] [u2] }; _NO_DEFLT_ } _N_,
- cosh = _A_ 1 _U_ 1 _N_ _S_ "U(P)" {_A_ 1 _U_ 2 _N_ _N_ _F_ _IF_ARGS_ 0 1 X 3 \ (u0 :: Float#) -> case _#_ coshFloat# [] [u0] of { _PRIM_ (u1 :: Float#) -> _!_ F# [] [u1] } _N_} _F_ _IF_ARGS_ 0 1 C 4 \ (u0 :: Float) -> case u0 of { _ALG_ F# (u1 :: Float#) -> case _#_ coshFloat# [] [u1] of { _PRIM_ (u2 :: Float#) -> _!_ F# [] [u2] }; _NO_DEFLT_ } _N_,
- tanh = _A_ 1 _U_ 1 _N_ _S_ "U(P)" {_A_ 1 _U_ 2 _N_ _N_ _F_ _IF_ARGS_ 0 1 X 3 \ (u0 :: Float#) -> case _#_ tanhFloat# [] [u0] of { _PRIM_ (u1 :: Float#) -> _!_ F# [] [u1] } _N_} _F_ _IF_ARGS_ 0 1 C 4 \ (u0 :: Float) -> case u0 of { _ALG_ F# (u1 :: Float#) -> case _#_ tanhFloat# [] [u1] of { _PRIM_ (u2 :: Float#) -> _!_ F# [] [u2] }; _NO_DEFLT_ } _N_,
- asinh = _A_ 1 _U_ 1 _N_ _S_ "U(P)" {_A_ 1 _U_ 2 _N_ _N_ _N_ _N_} _N_ _N_,
- acosh = _A_ 1 _U_ 1 _N_ _S_ "U(P)" {_A_ 1 _U_ 2 _N_ _N_ _N_ _N_} _N_ _N_,
- atanh = _A_ 1 _U_ 1 _N_ _S_ "U(P)" {_A_ 1 _U_ 2 _N_ _N_ _N_ _N_} _N_ _N_ #-}
+ pi = { _A_ 0 _N_ _N_ _N_ _F_ _IF_ARGS_ 0 0 X 2 _!_ F# [] [3.1415926535897931#] _N_ },
+ exp = { _A_ 1 _U_ 1 _N_ _S_ "U(P)" {_A_ 1 _U_ 2 _N_ _N_ _F_ _IF_ARGS_ 0 1 X 3 \ (u0 :: Float#) -> case _#_ expFloat# [] [u0] of { _PRIM_ (u1 :: Float#) -> _!_ F# [] [u1] } _N_} _F_ _IF_ARGS_ 0 1 C 4 \ (u0 :: Float) -> case u0 of { _ALG_ F# (u1 :: Float#) -> case _#_ expFloat# [] [u1] of { _PRIM_ (u2 :: Float#) -> _!_ F# [] [u2] }; _NO_DEFLT_ } _N_ },
+ log = { _A_ 1 _U_ 1 _N_ _S_ "U(P)" {_A_ 1 _U_ 2 _N_ _N_ _F_ _IF_ARGS_ 0 1 X 3 \ (u0 :: Float#) -> case _#_ logFloat# [] [u0] of { _PRIM_ (u1 :: Float#) -> _!_ F# [] [u1] } _N_} _F_ _IF_ARGS_ 0 1 C 4 \ (u0 :: Float) -> case u0 of { _ALG_ F# (u1 :: Float#) -> case _#_ logFloat# [] [u1] of { _PRIM_ (u2 :: Float#) -> _!_ F# [] [u2] }; _NO_DEFLT_ } _N_ },
+ sqrt = { _A_ 1 _U_ 1 _N_ _S_ "U(P)" {_A_ 1 _U_ 2 _N_ _N_ _F_ _IF_ARGS_ 0 1 X 3 \ (u0 :: Float#) -> case _#_ sqrtFloat# [] [u0] of { _PRIM_ (u1 :: Float#) -> _!_ F# [] [u1] } _N_} _F_ _IF_ARGS_ 0 1 C 4 \ (u0 :: Float) -> case u0 of { _ALG_ F# (u1 :: Float#) -> case _#_ sqrtFloat# [] [u1] of { _PRIM_ (u2 :: Float#) -> _!_ F# [] [u2] }; _NO_DEFLT_ } _N_ },
+ (**) = { _A_ 2 _U_ 11 _N_ _S_ "U(P)U(P)" {_A_ 2 _U_ 22 _N_ _N_ _F_ _IF_ARGS_ 0 2 XX 3 \ (u0 :: Float#) (u1 :: Float#) -> case _#_ powerFloat# [] [u0, u1] of { _PRIM_ (u2 :: Float#) -> _!_ F# [] [u2] } _N_} _F_ _IF_ARGS_ 0 2 CC 5 \ (u0 :: Float) (u1 :: Float) -> case u0 of { _ALG_ F# (u2 :: Float#) -> case u1 of { _ALG_ F# (u3 :: Float#) -> case _#_ powerFloat# [] [u2, u3] of { _PRIM_ (u4 :: Float#) -> _!_ F# [] [u4] }; _NO_DEFLT_ }; _NO_DEFLT_ } _N_ },
+ logBase = { _A_ 2 _U_ 11 _N_ _S_ "U(P)U(P)" {_A_ 2 _U_ 22 _N_ _N_ _F_ _IF_ARGS_ 0 2 XX 5 \ (u0 :: Float#) (u1 :: Float#) -> case _#_ logFloat# [] [u1] of { _PRIM_ (u2 :: Float#) -> case _#_ logFloat# [] [u0] of { _PRIM_ (u3 :: Float#) -> case _#_ divideFloat# [] [u2, u3] of { _PRIM_ (u4 :: Float#) -> _!_ F# [] [u4] } } } _N_} _F_ _IF_ARGS_ 0 2 CC 7 \ (u0 :: Float) (u1 :: Float) -> case u1 of { _ALG_ F# (u2 :: Float#) -> case _#_ logFloat# [] [u2] of { _PRIM_ (u3 :: Float#) -> case u0 of { _ALG_ F# (u4 :: Float#) -> case _#_ logFloat# [] [u4] of { _PRIM_ (u5 :: Float#) -> case _#_ divideFloat# [] [u3, u5] of { _PRIM_ (u6 :: Float#) -> _!_ F# [] [u6] } }; _NO_DEFLT_ } }; _NO_DEFLT_ } _N_ },
+ sin = { _A_ 1 _U_ 1 _N_ _S_ "U(P)" {_A_ 1 _U_ 2 _N_ _N_ _F_ _IF_ARGS_ 0 1 X 3 \ (u0 :: Float#) -> case _#_ sinFloat# [] [u0] of { _PRIM_ (u1 :: Float#) -> _!_ F# [] [u1] } _N_} _F_ _IF_ARGS_ 0 1 C 4 \ (u0 :: Float) -> case u0 of { _ALG_ F# (u1 :: Float#) -> case _#_ sinFloat# [] [u1] of { _PRIM_ (u2 :: Float#) -> _!_ F# [] [u2] }; _NO_DEFLT_ } _N_ },
+ cos = { _A_ 1 _U_ 1 _N_ _S_ "U(P)" {_A_ 1 _U_ 2 _N_ _N_ _F_ _IF_ARGS_ 0 1 X 3 \ (u0 :: Float#) -> case _#_ cosFloat# [] [u0] of { _PRIM_ (u1 :: Float#) -> _!_ F# [] [u1] } _N_} _F_ _IF_ARGS_ 0 1 C 4 \ (u0 :: Float) -> case u0 of { _ALG_ F# (u1 :: Float#) -> case _#_ cosFloat# [] [u1] of { _PRIM_ (u2 :: Float#) -> _!_ F# [] [u2] }; _NO_DEFLT_ } _N_ },
+ tan = { _A_ 1 _U_ 1 _N_ _S_ "U(P)" {_A_ 1 _U_ 2 _N_ _N_ _F_ _IF_ARGS_ 0 1 X 3 \ (u0 :: Float#) -> case _#_ tanFloat# [] [u0] of { _PRIM_ (u1 :: Float#) -> _!_ F# [] [u1] } _N_} _F_ _IF_ARGS_ 0 1 C 4 \ (u0 :: Float) -> case u0 of { _ALG_ F# (u1 :: Float#) -> case _#_ tanFloat# [] [u1] of { _PRIM_ (u2 :: Float#) -> _!_ F# [] [u2] }; _NO_DEFLT_ } _N_ },
+ asin = { _A_ 1 _U_ 1 _N_ _S_ "U(P)" {_A_ 1 _U_ 2 _N_ _N_ _F_ _IF_ARGS_ 0 1 X 3 \ (u0 :: Float#) -> case _#_ asinFloat# [] [u0] of { _PRIM_ (u1 :: Float#) -> _!_ F# [] [u1] } _N_} _F_ _IF_ARGS_ 0 1 C 4 \ (u0 :: Float) -> case u0 of { _ALG_ F# (u1 :: Float#) -> case _#_ asinFloat# [] [u1] of { _PRIM_ (u2 :: Float#) -> _!_ F# [] [u2] }; _NO_DEFLT_ } _N_ },
+ acos = { _A_ 1 _U_ 1 _N_ _S_ "U(P)" {_A_ 1 _U_ 2 _N_ _N_ _F_ _IF_ARGS_ 0 1 X 3 \ (u0 :: Float#) -> case _#_ acosFloat# [] [u0] of { _PRIM_ (u1 :: Float#) -> _!_ F# [] [u1] } _N_} _F_ _IF_ARGS_ 0 1 C 4 \ (u0 :: Float) -> case u0 of { _ALG_ F# (u1 :: Float#) -> case _#_ acosFloat# [] [u1] of { _PRIM_ (u2 :: Float#) -> _!_ F# [] [u2] }; _NO_DEFLT_ } _N_ },
+ atan = { _A_ 1 _U_ 1 _N_ _S_ "U(P)" {_A_ 1 _U_ 2 _N_ _N_ _F_ _IF_ARGS_ 0 1 X 3 \ (u0 :: Float#) -> case _#_ atanFloat# [] [u0] of { _PRIM_ (u1 :: Float#) -> _!_ F# [] [u1] } _N_} _F_ _IF_ARGS_ 0 1 C 4 \ (u0 :: Float) -> case u0 of { _ALG_ F# (u1 :: Float#) -> case _#_ atanFloat# [] [u1] of { _PRIM_ (u2 :: Float#) -> _!_ F# [] [u2] }; _NO_DEFLT_ } _N_ },
+ sinh = { _A_ 1 _U_ 1 _N_ _S_ "U(P)" {_A_ 1 _U_ 2 _N_ _N_ _F_ _IF_ARGS_ 0 1 X 3 \ (u0 :: Float#) -> case _#_ sinhFloat# [] [u0] of { _PRIM_ (u1 :: Float#) -> _!_ F# [] [u1] } _N_} _F_ _IF_ARGS_ 0 1 C 4 \ (u0 :: Float) -> case u0 of { _ALG_ F# (u1 :: Float#) -> case _#_ sinhFloat# [] [u1] of { _PRIM_ (u2 :: Float#) -> _!_ F# [] [u2] }; _NO_DEFLT_ } _N_ },
+ cosh = { _A_ 1 _U_ 1 _N_ _S_ "U(P)" {_A_ 1 _U_ 2 _N_ _N_ _F_ _IF_ARGS_ 0 1 X 3 \ (u0 :: Float#) -> case _#_ coshFloat# [] [u0] of { _PRIM_ (u1 :: Float#) -> _!_ F# [] [u1] } _N_} _F_ _IF_ARGS_ 0 1 C 4 \ (u0 :: Float) -> case u0 of { _ALG_ F# (u1 :: Float#) -> case _#_ coshFloat# [] [u1] of { _PRIM_ (u2 :: Float#) -> _!_ F# [] [u2] }; _NO_DEFLT_ } _N_ },
+ tanh = { _A_ 1 _U_ 1 _N_ _S_ "U(P)" {_A_ 1 _U_ 2 _N_ _N_ _F_ _IF_ARGS_ 0 1 X 3 \ (u0 :: Float#) -> case _#_ tanhFloat# [] [u0] of { _PRIM_ (u1 :: Float#) -> _!_ F# [] [u1] } _N_} _F_ _IF_ARGS_ 0 1 C 4 \ (u0 :: Float) -> case u0 of { _ALG_ F# (u1 :: Float#) -> case _#_ tanhFloat# [] [u1] of { _PRIM_ (u2 :: Float#) -> _!_ F# [] [u2] }; _NO_DEFLT_ } _N_ },
+ asinh = { _A_ 1 _U_ 1 _N_ _S_ "U(P)" {_A_ 1 _U_ 2 _N_ _N_ _N_ _N_} _N_ _N_ },
+ acosh = { _A_ 1 _U_ 1 _N_ _S_ "U(P)" {_A_ 1 _U_ 2 _N_ _N_ _N_ _N_} _N_ _N_ },
+ atanh = { _A_ 1 _U_ 1 _N_ _S_ "U(P)" {_A_ 1 _U_ 2 _N_ _N_ _N_ _N_} _N_ _N_ } #-}
instance Fractional Float
{-# GHC_PRAGMA _M_ PreludeCore {-dfun-} _A_ 0 _N_ _N_ _N_ _F_ _IF_ARGS_ 0 0 X 5 _!_ _TUP_4 [{{Num Float}}, (Float -> Float -> Float), (Float -> Float), (Ratio Integer -> Float)] [_DFUN_ Num (Float), _CONSTM_ Fractional (/) (Float), _CONSTM_ Fractional recip (Float), _CONSTM_ Fractional fromRational (Float)] _N_
- (/) = _A_ 2 _U_ 11 _N_ _S_ "U(P)U(P)" {_A_ 2 _U_ 22 _N_ _N_ _F_ _IF_ARGS_ 0 2 XX 3 \ (u0 :: Float#) (u1 :: Float#) -> case _#_ divideFloat# [] [u0, u1] of { _PRIM_ (u2 :: Float#) -> _!_ F# [] [u2] } _N_} _F_ _IF_ARGS_ 0 2 CC 5 \ (u0 :: Float) (u1 :: Float) -> case u0 of { _ALG_ F# (u2 :: Float#) -> case u1 of { _ALG_ F# (u3 :: Float#) -> case _#_ divideFloat# [] [u2, u3] of { _PRIM_ (u4 :: Float#) -> _!_ F# [] [u4] }; _NO_DEFLT_ }; _NO_DEFLT_ } _N_,
- recip = _A_ 0 _U_ 2 _N_ _N_ _N_ _N_,
- fromRational = _A_ 0 _U_ 2 _N_ _N_ _N_ _N_ #-}
+ (/) = { _A_ 2 _U_ 11 _N_ _S_ "U(P)U(P)" {_A_ 2 _U_ 22 _N_ _N_ _F_ _IF_ARGS_ 0 2 XX 3 \ (u0 :: Float#) (u1 :: Float#) -> case _#_ divideFloat# [] [u0, u1] of { _PRIM_ (u2 :: Float#) -> _!_ F# [] [u2] } _N_} _F_ _IF_ARGS_ 0 2 CC 5 \ (u0 :: Float) (u1 :: Float) -> case u0 of { _ALG_ F# (u2 :: Float#) -> case u1 of { _ALG_ F# (u3 :: Float#) -> case _#_ divideFloat# [] [u2, u3] of { _PRIM_ (u4 :: Float#) -> _!_ F# [] [u4] }; _NO_DEFLT_ }; _NO_DEFLT_ } _N_ },
+ recip = { _A_ 1 _U_ 1 _N_ _S_ "U(P)" {_A_ 1 _U_ 2 _N_ _N_ _F_ _IF_ARGS_ 0 1 X 3 \ (u0 :: Float#) -> case _#_ divideFloat# [] [1.0000000000000000#, u0] of { _PRIM_ (u1 :: Float#) -> _!_ F# [] [u1] } _N_} _F_ _IF_ARGS_ 0 1 C 4 \ (u0 :: Float) -> case u0 of { _ALG_ F# (u1 :: Float#) -> case _#_ divideFloat# [] [1.0000000000000000#, u1] of { _PRIM_ (u2 :: Float#) -> _!_ F# [] [u2] }; _NO_DEFLT_ } _N_ },
+ fromRational = { _A_ 1 _U_ 2 _N_ _N_ _N_ _N_ } #-}
instance Num Float
{-# GHC_PRAGMA _M_ PreludeCore {-dfun-} _A_ 0 _N_ _N_ _N_ _F_ _IF_ARGS_ 0 0 X 11 _!_ _TUP_10 [{{Eq Float}}, {{Text Float}}, (Float -> Float -> Float), (Float -> Float -> Float), (Float -> Float -> Float), (Float -> Float), (Float -> Float), (Float -> Float), (Integer -> Float), (Int -> Float)] [_DFUN_ Eq (Float), _DFUN_ Text (Float), _CONSTM_ Num (+) (Float), _CONSTM_ Num (-) (Float), _CONSTM_ Num (*) (Float), _CONSTM_ Num negate (Float), _CONSTM_ Num abs (Float), _CONSTM_ Num signum (Float), _CONSTM_ Num fromInteger (Float), _CONSTM_ Num fromInt (Float)] _N_
- (+) = _A_ 2 _U_ 11 _N_ _S_ "U(P)U(P)" {_A_ 2 _U_ 22 _N_ _N_ _F_ _IF_ARGS_ 0 2 XX 3 \ (u0 :: Float#) (u1 :: Float#) -> case _#_ plusFloat# [] [u0, u1] of { _PRIM_ (u2 :: Float#) -> _!_ F# [] [u2] } _N_} _F_ _IF_ARGS_ 0 2 CC 5 \ (u0 :: Float) (u1 :: Float) -> case u0 of { _ALG_ F# (u2 :: Float#) -> case u1 of { _ALG_ F# (u3 :: Float#) -> case _#_ plusFloat# [] [u2, u3] of { _PRIM_ (u4 :: Float#) -> _!_ F# [] [u4] }; _NO_DEFLT_ }; _NO_DEFLT_ } _N_,
- (-) = _A_ 2 _U_ 11 _N_ _S_ "U(P)U(P)" {_A_ 2 _U_ 22 _N_ _N_ _F_ _IF_ARGS_ 0 2 XX 3 \ (u0 :: Float#) (u1 :: Float#) -> case _#_ minusFloat# [] [u0, u1] of { _PRIM_ (u2 :: Float#) -> _!_ F# [] [u2] } _N_} _F_ _IF_ARGS_ 0 2 CC 5 \ (u0 :: Float) (u1 :: Float) -> case u0 of { _ALG_ F# (u2 :: Float#) -> case u1 of { _ALG_ F# (u3 :: Float#) -> case _#_ minusFloat# [] [u2, u3] of { _PRIM_ (u4 :: Float#) -> _!_ F# [] [u4] }; _NO_DEFLT_ }; _NO_DEFLT_ } _N_,
- (*) = _A_ 2 _U_ 11 _N_ _S_ "U(P)U(P)" {_A_ 2 _U_ 22 _N_ _N_ _F_ _IF_ARGS_ 0 2 XX 3 \ (u0 :: Float#) (u1 :: Float#) -> case _#_ timesFloat# [] [u0, u1] of { _PRIM_ (u2 :: Float#) -> _!_ F# [] [u2] } _N_} _F_ _IF_ARGS_ 0 2 CC 5 \ (u0 :: Float) (u1 :: Float) -> case u0 of { _ALG_ F# (u2 :: Float#) -> case u1 of { _ALG_ F# (u3 :: Float#) -> case _#_ timesFloat# [] [u2, u3] of { _PRIM_ (u4 :: Float#) -> _!_ F# [] [u4] }; _NO_DEFLT_ }; _NO_DEFLT_ } _N_,
- negate = _A_ 1 _U_ 1 _N_ _S_ "U(P)" {_A_ 1 _U_ 2 _N_ _N_ _F_ _IF_ARGS_ 0 1 X 3 \ (u0 :: Float#) -> case _#_ negateFloat# [] [u0] of { _PRIM_ (u1 :: Float#) -> _!_ F# [] [u1] } _N_} _F_ _IF_ARGS_ 0 1 C 4 \ (u0 :: Float) -> case u0 of { _ALG_ F# (u1 :: Float#) -> case _#_ negateFloat# [] [u1] of { _PRIM_ (u2 :: Float#) -> _!_ F# [] [u2] }; _NO_DEFLT_ } _N_,
- abs = _A_ 1 _U_ 1 _N_ _S_ "U(P)" {_A_ 1 _U_ 2 _N_ _N_ _N_ _N_} _N_ _N_,
- signum = _A_ 1 _U_ 1 _N_ _S_ "U(P)" {_A_ 1 _U_ 2 _N_ _N_ _N_ _N_} _N_ _N_,
- fromInteger = _A_ 1 _U_ 1 _N_ _S_ "U(PPP)" {_A_ 3 _U_ 222 _N_ _N_ _F_ _IF_ARGS_ 0 3 XXX 3 \ (u0 :: Int#) (u1 :: Int#) (u2 :: ByteArray#) -> case _#_ encodeFloat# [] [u0, u1, u2, 0#] of { _PRIM_ (u3 :: Float#) -> _!_ F# [] [u3] } _N_} _F_ _IF_ARGS_ 0 1 C 4 \ (u0 :: Integer) -> case u0 of { _ALG_ J# (u1 :: Int#) (u2 :: Int#) (u3 :: ByteArray#) -> case _#_ encodeFloat# [] [u1, u2, u3, 0#] of { _PRIM_ (u4 :: Float#) -> _!_ F# [] [u4] }; _NO_DEFLT_ } _N_,
- fromInt = _A_ 1 _U_ 1 _N_ _S_ "U(P)" {_A_ 1 _U_ 2 _N_ _N_ _F_ _IF_ARGS_ 0 1 X 3 \ (u0 :: Int#) -> case _#_ int2Float# [] [u0] of { _PRIM_ (u1 :: Float#) -> _!_ F# [] [u1] } _N_} _F_ _IF_ARGS_ 0 1 C 4 \ (u0 :: Int) -> case u0 of { _ALG_ I# (u1 :: Int#) -> case _#_ int2Float# [] [u1] of { _PRIM_ (u2 :: Float#) -> _!_ F# [] [u2] }; _NO_DEFLT_ } _N_ #-}
+ (+) = { _A_ 2 _U_ 11 _N_ _S_ "U(P)U(P)" {_A_ 2 _U_ 22 _N_ _N_ _F_ _IF_ARGS_ 0 2 XX 3 \ (u0 :: Float#) (u1 :: Float#) -> case _#_ plusFloat# [] [u0, u1] of { _PRIM_ (u2 :: Float#) -> _!_ F# [] [u2] } _N_} _F_ _IF_ARGS_ 0 2 CC 5 \ (u0 :: Float) (u1 :: Float) -> case u0 of { _ALG_ F# (u2 :: Float#) -> case u1 of { _ALG_ F# (u3 :: Float#) -> case _#_ plusFloat# [] [u2, u3] of { _PRIM_ (u4 :: Float#) -> _!_ F# [] [u4] }; _NO_DEFLT_ }; _NO_DEFLT_ } _N_ },
+ (-) = { _A_ 2 _U_ 11 _N_ _S_ "U(P)U(P)" {_A_ 2 _U_ 22 _N_ _N_ _F_ _IF_ARGS_ 0 2 XX 3 \ (u0 :: Float#) (u1 :: Float#) -> case _#_ minusFloat# [] [u0, u1] of { _PRIM_ (u2 :: Float#) -> _!_ F# [] [u2] } _N_} _F_ _IF_ARGS_ 0 2 CC 5 \ (u0 :: Float) (u1 :: Float) -> case u0 of { _ALG_ F# (u2 :: Float#) -> case u1 of { _ALG_ F# (u3 :: Float#) -> case _#_ minusFloat# [] [u2, u3] of { _PRIM_ (u4 :: Float#) -> _!_ F# [] [u4] }; _NO_DEFLT_ }; _NO_DEFLT_ } _N_ },
+ (*) = { _A_ 2 _U_ 11 _N_ _S_ "U(P)U(P)" {_A_ 2 _U_ 22 _N_ _N_ _F_ _IF_ARGS_ 0 2 XX 3 \ (u0 :: Float#) (u1 :: Float#) -> case _#_ timesFloat# [] [u0, u1] of { _PRIM_ (u2 :: Float#) -> _!_ F# [] [u2] } _N_} _F_ _IF_ARGS_ 0 2 CC 5 \ (u0 :: Float) (u1 :: Float) -> case u0 of { _ALG_ F# (u2 :: Float#) -> case u1 of { _ALG_ F# (u3 :: Float#) -> case _#_ timesFloat# [] [u2, u3] of { _PRIM_ (u4 :: Float#) -> _!_ F# [] [u4] }; _NO_DEFLT_ }; _NO_DEFLT_ } _N_ },
+ negate = { _A_ 1 _U_ 1 _N_ _S_ "U(P)" {_A_ 1 _U_ 2 _N_ _N_ _F_ _IF_ARGS_ 0 1 X 3 \ (u0 :: Float#) -> case _#_ negateFloat# [] [u0] of { _PRIM_ (u1 :: Float#) -> _!_ F# [] [u1] } _N_} _F_ _IF_ARGS_ 0 1 C 4 \ (u0 :: Float) -> case u0 of { _ALG_ F# (u1 :: Float#) -> case _#_ negateFloat# [] [u1] of { _PRIM_ (u2 :: Float#) -> _!_ F# [] [u2] }; _NO_DEFLT_ } _N_ },
+ abs = { _A_ 1 _U_ 1 _N_ _S_ "U(P)" {_A_ 1 _U_ 2 _N_ _N_ _N_ _N_} _N_ _N_ },
+ signum = { _A_ 1 _U_ 1 _N_ _S_ "U(P)" {_A_ 1 _U_ 2 _N_ _N_ _N_ _N_} _N_ _N_ },
+ fromInteger = { _A_ 1 _U_ 1 _N_ _S_ "U(PPP)" {_A_ 3 _U_ 222 _N_ _N_ _F_ _IF_ARGS_ 0 3 XXX 3 \ (u0 :: Int#) (u1 :: Int#) (u2 :: ByteArray#) -> case _#_ encodeFloat# [] [u0, u1, u2, 0#] of { _PRIM_ (u3 :: Float#) -> _!_ F# [] [u3] } _N_} _F_ _IF_ARGS_ 0 1 C 4 \ (u0 :: Integer) -> case u0 of { _ALG_ J# (u1 :: Int#) (u2 :: Int#) (u3 :: ByteArray#) -> case _#_ encodeFloat# [] [u1, u2, u3, 0#] of { _PRIM_ (u4 :: Float#) -> _!_ F# [] [u4] }; _NO_DEFLT_ } _N_ },
+ fromInt = { _A_ 1 _U_ 1 _N_ _S_ "U(P)" {_A_ 1 _U_ 2 _N_ _N_ _F_ _IF_ARGS_ 0 1 X 3 \ (u0 :: Int#) -> case _#_ int2Float# [] [u0] of { _PRIM_ (u1 :: Float#) -> _!_ F# [] [u1] } _N_} _F_ _IF_ARGS_ 0 1 C 4 \ (u0 :: Int) -> case u0 of { _ALG_ I# (u1 :: Int#) -> case _#_ int2Float# [] [u1] of { _PRIM_ (u2 :: Float#) -> _!_ F# [] [u2] }; _NO_DEFLT_ } _N_ } #-}
instance Ord Float
{-# GHC_PRAGMA _M_ PreludeCore {-dfun-} _A_ 0 _N_ _N_ _N_ _F_ _IF_ARGS_ 0 0 X 9 _!_ _TUP_8 [{{Eq Float}}, (Float -> Float -> Bool), (Float -> Float -> Bool), (Float -> Float -> Bool), (Float -> Float -> Bool), (Float -> Float -> Float), (Float -> Float -> Float), (Float -> Float -> _CMP_TAG)] [_DFUN_ Eq (Float), _CONSTM_ Ord (<) (Float), _CONSTM_ Ord (<=) (Float), _CONSTM_ Ord (>=) (Float), _CONSTM_ Ord (>) (Float), _CONSTM_ Ord max (Float), _CONSTM_ Ord min (Float), _CONSTM_ Ord _tagCmp (Float)] _N_
- (<) = _A_ 2 _U_ 11 _N_ _S_ "U(P)U(P)" {_A_ 2 _U_ 22 _N_ _N_ _F_ _IF_ARGS_ 0 2 XX 1 \ (u0 :: Float#) (u1 :: Float#) -> _#_ ltFloat# [] [u0, u1] _N_} _F_ _IF_ARGS_ 0 2 CC 3 \ (u0 :: Float) (u1 :: Float) -> case u0 of { _ALG_ F# (u2 :: Float#) -> case u1 of { _ALG_ F# (u3 :: Float#) -> _#_ ltFloat# [] [u2, u3]; _NO_DEFLT_ }; _NO_DEFLT_ } _N_,
- (<=) = _A_ 2 _U_ 11 _N_ _S_ "U(P)U(P)" {_A_ 2 _U_ 22 _N_ _N_ _F_ _IF_ARGS_ 0 2 XX 1 \ (u0 :: Float#) (u1 :: Float#) -> _#_ leFloat# [] [u0, u1] _N_} _F_ _IF_ARGS_ 0 2 CC 3 \ (u0 :: Float) (u1 :: Float) -> case u0 of { _ALG_ F# (u2 :: Float#) -> case u1 of { _ALG_ F# (u3 :: Float#) -> _#_ leFloat# [] [u2, u3]; _NO_DEFLT_ }; _NO_DEFLT_ } _N_,
- (>=) = _A_ 2 _U_ 11 _N_ _S_ "U(P)U(P)" {_A_ 2 _U_ 22 _N_ _N_ _F_ _IF_ARGS_ 0 2 XX 1 \ (u0 :: Float#) (u1 :: Float#) -> _#_ geFloat# [] [u0, u1] _N_} _F_ _IF_ARGS_ 0 2 CC 3 \ (u0 :: Float) (u1 :: Float) -> case u0 of { _ALG_ F# (u2 :: Float#) -> case u1 of { _ALG_ F# (u3 :: Float#) -> _#_ geFloat# [] [u2, u3]; _NO_DEFLT_ }; _NO_DEFLT_ } _N_,
- (>) = _A_ 2 _U_ 11 _N_ _S_ "U(P)U(P)" {_A_ 2 _U_ 22 _N_ _N_ _F_ _IF_ARGS_ 0 2 XX 1 \ (u0 :: Float#) (u1 :: Float#) -> _#_ gtFloat# [] [u0, u1] _N_} _F_ _IF_ARGS_ 0 2 CC 3 \ (u0 :: Float) (u1 :: Float) -> case u0 of { _ALG_ F# (u2 :: Float#) -> case u1 of { _ALG_ F# (u3 :: Float#) -> _#_ gtFloat# [] [u2, u3]; _NO_DEFLT_ }; _NO_DEFLT_ } _N_,
- max = _A_ 2 _U_ 11 _N_ _S_ "U(P)U(P)" {_A_ 2 _U_ 22 _N_ _N_ _N_ _N_} _N_ _N_,
- min = _A_ 2 _U_ 11 _N_ _S_ "U(P)U(P)" {_A_ 2 _U_ 22 _N_ _N_ _N_ _N_} _N_ _N_,
- _tagCmp = _A_ 2 _U_ 11 _N_ _S_ "U(P)U(P)" {_A_ 2 _U_ 22 _N_ _N_ _N_ _N_} _N_ _N_ #-}
+ (<) = { _A_ 2 _U_ 11 _N_ _S_ "U(P)U(P)" {_A_ 2 _U_ 22 _N_ _N_ _F_ _IF_ARGS_ 0 2 XX 1 \ (u0 :: Float#) (u1 :: Float#) -> _#_ ltFloat# [] [u0, u1] _N_} _F_ _IF_ARGS_ 0 2 CC 3 \ (u0 :: Float) (u1 :: Float) -> case u0 of { _ALG_ F# (u2 :: Float#) -> case u1 of { _ALG_ F# (u3 :: Float#) -> _#_ ltFloat# [] [u2, u3]; _NO_DEFLT_ }; _NO_DEFLT_ } _N_ },
+ (<=) = { _A_ 2 _U_ 11 _N_ _S_ "U(P)U(P)" {_A_ 2 _U_ 22 _N_ _N_ _F_ _IF_ARGS_ 0 2 XX 1 \ (u0 :: Float#) (u1 :: Float#) -> _#_ leFloat# [] [u0, u1] _N_} _F_ _IF_ARGS_ 0 2 CC 3 \ (u0 :: Float) (u1 :: Float) -> case u0 of { _ALG_ F# (u2 :: Float#) -> case u1 of { _ALG_ F# (u3 :: Float#) -> _#_ leFloat# [] [u2, u3]; _NO_DEFLT_ }; _NO_DEFLT_ } _N_ },
+ (>=) = { _A_ 2 _U_ 11 _N_ _S_ "U(P)U(P)" {_A_ 2 _U_ 22 _N_ _N_ _F_ _IF_ARGS_ 0 2 XX 1 \ (u0 :: Float#) (u1 :: Float#) -> _#_ geFloat# [] [u0, u1] _N_} _F_ _IF_ARGS_ 0 2 CC 3 \ (u0 :: Float) (u1 :: Float) -> case u0 of { _ALG_ F# (u2 :: Float#) -> case u1 of { _ALG_ F# (u3 :: Float#) -> _#_ geFloat# [] [u2, u3]; _NO_DEFLT_ }; _NO_DEFLT_ } _N_ },
+ (>) = { _A_ 2 _U_ 11 _N_ _S_ "U(P)U(P)" {_A_ 2 _U_ 22 _N_ _N_ _F_ _IF_ARGS_ 0 2 XX 1 \ (u0 :: Float#) (u1 :: Float#) -> _#_ gtFloat# [] [u0, u1] _N_} _F_ _IF_ARGS_ 0 2 CC 3 \ (u0 :: Float) (u1 :: Float) -> case u0 of { _ALG_ F# (u2 :: Float#) -> case u1 of { _ALG_ F# (u3 :: Float#) -> _#_ gtFloat# [] [u2, u3]; _NO_DEFLT_ }; _NO_DEFLT_ } _N_ },
+ max = { _A_ 2 _U_ 11 _N_ _S_ "U(P)U(P)" {_A_ 2 _U_ 22 _N_ _N_ _N_ _N_} _N_ _N_ },
+ min = { _A_ 2 _U_ 11 _N_ _S_ "U(P)U(P)" {_A_ 2 _U_ 22 _N_ _N_ _N_ _N_} _N_ _N_ },
+ _tagCmp = { _A_ 2 _U_ 11 _N_ _S_ "U(P)U(P)" {_A_ 2 _U_ 22 _N_ _N_ _N_ _N_} _N_ _N_ } #-}
instance Real Float
{-# GHC_PRAGMA _M_ PreludeCore {-dfun-} _A_ 0 _N_ _N_ _N_ _F_ _IF_ARGS_ 0 0 X 4 _!_ _TUP_3 [{{Num Float}}, {{Enum Float}}, (Float -> Ratio Integer)] [_DFUN_ Num (Float), _DFUN_ Enum (Float), _CONSTM_ Real toRational (Float)] _N_
- toRational = _A_ 1 _U_ 1 _N_ _S_ "U(P)" {_A_ 1 _U_ 2 _N_ _N_ _N_ _N_} _N_ _N_ #-}
+ toRational = { _A_ 1 _U_ 1 _N_ _S_ "U(P)" {_A_ 1 _U_ 2 _N_ _N_ _N_ _N_} _N_ _N_ } #-}
instance RealFloat Float
{-# GHC_PRAGMA _M_ PreludeCore {-dfun-} _A_ 0 _N_ _N_ _N_ _F_ _IF_ARGS_ 0 0 X 11 _!_ _TUP_10 [{{RealFrac Float}}, {{Floating Float}}, (Float -> Integer), (Float -> Int), (Float -> (Int, Int)), (Float -> (Integer, Int)), (Integer -> Int -> Float), (Float -> Int), (Float -> Float), (Int -> Float -> Float)] [_DFUN_ RealFrac (Float), _DFUN_ Floating (Float), _CONSTM_ RealFloat floatRadix (Float), _CONSTM_ RealFloat floatDigits (Float), _CONSTM_ RealFloat floatRange (Float), _CONSTM_ RealFloat decodeFloat (Float), _CONSTM_ RealFloat encodeFloat (Float), _CONSTM_ RealFloat exponent (Float), _CONSTM_ RealFloat significand (Float), _CONSTM_ RealFloat scaleFloat (Float)] _N_
- floatRadix = _A_ 1 _U_ 0 _N_ _S_ "A" {_A_ 0 _N_ _N_ _N_ _F_ _IF_ARGS_ 0 0 X 1 _#_ int2Integer# [] [2#] _N_} _N_ _N_,
- floatDigits = _A_ 1 _U_ 0 _N_ _S_ "A" {_A_ 0 _N_ _N_ _N_ _F_ _IF_ARGS_ 0 0 X 2 _!_ I# [] [24#] _N_} _F_ _IF_ARGS_ 0 1 X 2 \ (u0 :: Float) -> _!_ I# [] [24#] _N_,
- floatRange = _A_ 1 _U_ 0 _N_ _S_ "A" {_A_ 0 _N_ _N_ _N_ _N_ _N_} _N_ _N_,
- decodeFloat = _A_ 1 _U_ 1 _N_ _S_ "U(P)" {_A_ 1 _U_ 2 _N_ _N_ _N_ _N_} _N_ _N_,
- encodeFloat = _A_ 2 _U_ 11 _N_ _S_ "U(PPP)U(P)" {_A_ 4 _U_ 2222 _N_ _N_ _F_ _IF_ARGS_ 0 4 XXXX 3 \ (u0 :: Int#) (u1 :: Int#) (u2 :: ByteArray#) (u3 :: Int#) -> case _#_ encodeFloat# [] [u0, u1, u2, u3] of { _PRIM_ (u4 :: Float#) -> _!_ F# [] [u4] } _N_} _F_ _IF_ARGS_ 0 2 CC 5 \ (u0 :: Integer) (u1 :: Int) -> case u0 of { _ALG_ J# (u2 :: Int#) (u3 :: Int#) (u4 :: ByteArray#) -> case u1 of { _ALG_ I# (u5 :: Int#) -> case _#_ encodeFloat# [] [u2, u3, u4, u5] of { _PRIM_ (u6 :: Float#) -> _!_ F# [] [u6] }; _NO_DEFLT_ }; _NO_DEFLT_ } _N_,
- exponent = _A_ 1 _U_ 2 _N_ _N_ _N_ _N_,
- significand = _A_ 1 _U_ 2 _N_ _N_ _N_ _N_,
- scaleFloat = _A_ 2 _U_ 22 _N_ _N_ _N_ _N_ #-}
+ floatRadix = { _A_ 1 _U_ 0 _N_ _S_ "A" {_A_ 0 _N_ _N_ _N_ _N_ _N_} _N_ _N_ },
+ floatDigits = { _A_ 1 _U_ 0 _N_ _S_ "A" {_A_ 0 _N_ _N_ _N_ _F_ _IF_ARGS_ 0 0 X 2 _!_ I# [] [24#] _N_} _F_ _IF_ARGS_ 0 1 X 2 \ (u0 :: Float) -> _!_ I# [] [24#] _N_ },
+ floatRange = { _A_ 1 _U_ 0 _N_ _S_ "A" {_A_ 0 _N_ _N_ _N_ _N_ _N_} _N_ _N_ },
+ decodeFloat = { _A_ 1 _U_ 1 _N_ _S_ "U(P)" {_A_ 1 _U_ 2 _N_ _N_ _N_ _N_} _N_ _N_ },
+ encodeFloat = { _A_ 2 _U_ 11 _N_ _S_ "U(PPP)U(P)" {_A_ 4 _U_ 2222 _N_ _N_ _F_ _IF_ARGS_ 0 4 XXXX 3 \ (u0 :: Int#) (u1 :: Int#) (u2 :: ByteArray#) (u3 :: Int#) -> case _#_ encodeFloat# [] [u0, u1, u2, u3] of { _PRIM_ (u4 :: Float#) -> _!_ F# [] [u4] } _N_} _F_ _IF_ARGS_ 0 2 CC 5 \ (u0 :: Integer) (u1 :: Int) -> case u0 of { _ALG_ J# (u2 :: Int#) (u3 :: Int#) (u4 :: ByteArray#) -> case u1 of { _ALG_ I# (u5 :: Int#) -> case _#_ encodeFloat# [] [u2, u3, u4, u5] of { _PRIM_ (u6 :: Float#) -> _!_ F# [] [u6] }; _NO_DEFLT_ }; _NO_DEFLT_ } _N_ },
+ exponent = { _A_ 1 _U_ 1 _N_ _S_ "U(P)" {_A_ 1 _U_ 2 _N_ _N_ _N_ _N_} _N_ _N_ },
+ significand = { _A_ 1 _U_ 1 _N_ _S_ "U(P)" {_A_ 1 _U_ 2 _N_ _N_ _N_ _N_} _N_ _N_ },
+ scaleFloat = { _A_ 2 _U_ 11 _N_ _S_ "U(P)U(P)" {_A_ 2 _U_ 22 _N_ _N_ _N_ _N_} _N_ _N_ } #-}
instance RealFrac Float
{-# GHC_PRAGMA _M_ PreludeCore {-dfun-} _A_ 0 _N_ _N_ _N_ _F_ _IF_ARGS_ 0 0 X 8 _!_ _TUP_7 [{{Real Float}}, {{Fractional Float}}, _forall_ a$z1 =>{{Integral a$z1}} -> (Float -> (a$z1, Float)), _forall_ a$z1 =>{{Integral a$z1}} -> (Float -> a$z1), _forall_ a$z1 =>{{Integral a$z1}} -> (Float -> a$z1), _forall_ a$z1 =>{{Integral a$z1}} -> (Float -> a$z1), _forall_ a$z1 =>{{Integral a$z1}} -> (Float -> a$z1)] [_DFUN_ Real (Float), _DFUN_ Fractional (Float), _CONSTM_ RealFrac properFraction (Float), _CONSTM_ RealFrac truncate (Float), _CONSTM_ RealFrac round (Float), _CONSTM_ RealFrac ceiling (Float), _CONSTM_ RealFrac floor (Float)] _N_
- properFraction = _A_ 1 _U_ 22 _N_ _N_ _N_ _N_,
- truncate = _A_ 1 _U_ 22 _N_ _N_ _N_ _N_,
- round = _A_ 1 _U_ 22 _N_ _N_ _N_ _N_,
- ceiling = _A_ 1 _U_ 22 _N_ _N_ _N_ _N_,
- floor = _A_ 1 _U_ 22 _N_ _N_ _N_ _N_ #-}
+ properFraction = { _A_ 1 _U_ 11 _N_ _N_ _N_ _SPECIALISE_ [ Int ] 1 { _A_ 1 _U_ 1 _N_ _S_ "U(P)" {_A_ 1 _U_ 2 _N_ _N_ _N_ _N_} _N_ _N_ }, [ Integer ] 1 { _A_ 1 _U_ 1 _N_ _S_ "U(P)" {_A_ 1 _U_ 2 _N_ _N_ _N_ _N_} _N_ _N_ } },
+ truncate = { _A_ 1 _U_ 11 _N_ _N_ _N_ _SPECIALISE_ [ Int ] 1 { _A_ 1 _U_ 1 _N_ _S_ "U(P)" {_A_ 1 _U_ 2 _N_ _N_ _F_ _IF_ARGS_ 0 1 X 4 \ (u0 :: Float#) -> case _APP_ _WRKR_ _SPEC_ _CONSTM_ RealFrac properFraction (Float) [ (Int) ] [ u0 ] of { _ALG_ _TUP_2 (u1 :: Int) (u2 :: Float) -> u1; _NO_DEFLT_ } _N_} _F_ _IF_ARGS_ 0 1 X 4 \ (u0 :: Float) -> case _APP_ _SPEC_ _CONSTM_ RealFrac properFraction (Float) [ (Int) ] [ u0 ] of { _ALG_ _TUP_2 (u1 :: Int) (u2 :: Float) -> u1; _NO_DEFLT_ } _N_ }, [ Integer ] 1 { _A_ 1 _U_ 1 _N_ _S_ "U(P)" {_A_ 1 _U_ 2 _N_ _N_ _F_ _IF_ARGS_ 0 1 X 4 \ (u0 :: Float#) -> case _APP_ _WRKR_ _SPEC_ _CONSTM_ RealFrac properFraction (Float) [ (Integer) ] [ u0 ] of { _ALG_ _TUP_2 (u1 :: Integer) (u2 :: Float) -> u1; _NO_DEFLT_ } _N_} _F_ _IF_ARGS_ 0 1 X 4 \ (u0 :: Float) -> case _APP_ _SPEC_ _CONSTM_ RealFrac properFraction (Float) [ (Integer) ] [ u0 ] of { _ALG_ _TUP_2 (u1 :: Integer) (u2 :: Float) -> u1; _NO_DEFLT_ } _N_ } },
+ round = { _A_ 1 _U_ 21 _N_ _N_ _N_ _SPECIALISE_ [ Int ] 1 { _A_ 1 _U_ 1 _N_ _S_ "U(P)" {_A_ 1 _U_ 2 _N_ _N_ _N_ _N_} _N_ _N_ }, [ Integer ] 1 { _A_ 1 _U_ 1 _N_ _S_ "U(P)" {_A_ 1 _U_ 2 _N_ _N_ _N_ _N_} _N_ _N_ } },
+ ceiling = { _A_ 1 _U_ 21 _N_ _N_ _N_ _SPECIALISE_ [ Int ] 1 { _A_ 1 _U_ 1 _N_ _S_ "U(P)" {_A_ 1 _U_ 2 _N_ _N_ _N_ _N_} _N_ _N_ }, [ Integer ] 1 { _A_ 1 _U_ 1 _N_ _S_ "U(P)" {_A_ 1 _U_ 2 _N_ _N_ _N_ _N_} _N_ _N_ } },
+ floor = { _A_ 1 _U_ 21 _N_ _N_ _N_ _SPECIALISE_ [ Int ] 1 { _A_ 1 _U_ 1 _N_ _S_ "U(P)" {_A_ 1 _U_ 2 _N_ _N_ _N_ _N_} _N_ _N_ }, [ Integer ] 1 { _A_ 1 _U_ 1 _N_ _S_ "U(P)" {_A_ 1 _U_ 2 _N_ _N_ _N_ _N_} _N_ _N_ } } #-}
instance Text Float
{-# GHC_PRAGMA _M_ PreludeCore {-dfun-} _A_ 0 _N_ _N_ _N_ _F_ _IF_ARGS_ 0 0 X 5 _!_ _TUP_4 [(Int -> [Char] -> [(Float, [Char])]), (Int -> Float -> [Char] -> [Char]), ([Char] -> [([Float], [Char])]), ([Float] -> [Char] -> [Char])] [_CONSTM_ Text readsPrec (Float), _CONSTM_ Text showsPrec (Float), _CONSTM_ Text readList (Float), _CONSTM_ Text showList (Float)] _N_
- readsPrec = _A_ 2 _U_ 02 _N_ _S_ "AL" {_A_ 1 _U_ 2 _N_ _N_ _N_ _N_} _N_ _N_,
- showsPrec = _A_ 1 _U_ 222 _N_ _N_ _N_ _N_,
- readList = _A_ 0 _U_ 2 _N_ _N_ _N_ _N_,
- showList = _A_ 0 _U_ 12 _N_ _N_ _N_ _N_ #-}
+ readsPrec = { _A_ 2 _U_ 02 _N_ _S_ "AL" {_A_ 1 _U_ 2 _N_ _N_ _N_ _N_} _N_ _N_ },
+ showsPrec = { _A_ 1 _U_ 222 _N_ _N_ _N_ _N_ },
+ readList = { _A_ 0 _U_ 2 _N_ _N_ _N_ _N_ },
+ showList = { _A_ 0 _U_ 12 _N_ _N_ _N_ _N_ } #-}
instance _CCallable Float
{-# GHC_PRAGMA _M_ PreludeCore {-dfun-} _A_ 0 _N_ _N_ _N_ _F_ _IF_ARGS_ 0 0 X 1 _!_ _TUP_0 [] [] _N_ #-}
instance _CReturnable Float
import IInt
import IInteger
import IRatio
-import List ( (++) )
+import List ( (++), takeWhile )
import Prel ( (^), (^^), otherwise )
import PS ( _PackedString, _unpackPS )
import Text
-import TyComplex -- for pragmas only
+import TyArray
+import TyComplex
-- definitions of the boxed PrimOps; these will be
-- used in the case of partial applications, etc.
else if (ltFloat# a# b#) then _LT else _GT
instance Num Float where
- (+) x y = plusFloat x y
- (-) x y = minusFloat x y
- negate x = negateFloat x
- (*) x y = timesFloat x y
- abs x | x >= 0 = x
+ (+) x y = plusFloat x y
+ (-) x y = minusFloat x y
+ negate x = negateFloat x
+ (*) x y = timesFloat x y
+ abs x | x >= 0.0 = x
| otherwise = negateFloat x
- signum x | x == 0 = 0
- | x > 0 = 1
+ signum x | x == 0.0 = 0
+ | x > 0.0 = 1
| otherwise = -1
-
- fromInteger n = encodeFloat n 0
- fromInt i = int2Float i
+ fromInteger n = encodeFloat n 0
+ fromInt i = int2Float i
instance Real Float where
- toRational x = (m%1)*(b%1)^^n -- i.e., realFloatToRational x
+ toRational x = (m%__i1)*(b%__i1)^^n
where (m,n) = decodeFloat x
b = floatRadix x
instance Fractional Float where
(/) x y = divideFloat x y
- fromRational x = fromRationalX x -- ORIG: rationalToRealFloat x
+ fromRational x = _fromRational x
+ recip x = 1.0 / x
instance Floating Float where
pi = 3.141592653589793238
cosh x = coshFloat x
tanh x = tanhFloat x
(**) x y = powerFloat x y
+ logBase x y = log y / log x
-{- WAS: but not all machines have these in their math library:
- asinh = asinhFloat
- acosh = acoshFloat
- atanh = atanhFloat
--}
- asinh x = log (x + sqrt (1+x*x))
- acosh x = log (x + (x+1) * sqrt ((x-1)/(x+1)))
- atanh x = log ((x+1) / sqrt (1 - x*x))
+ asinh x = log (x + sqrt (1.0+x*x))
+ acosh x = log (x + (x+1.0) * sqrt ((x-1.0)/(x+1.0)))
+ atanh x = log ((x+1.0) / sqrt (1.0-x*x))
instance RealFrac Float where
- properFraction x = _properFraction x
- -- just call the versions in Core.hs
- truncate x = _truncate x
- round x = _round x
- ceiling x = _ceiling x
- floor x = _floor x
+ {-# SPECIALIZE properFraction :: Float -> (Int, Float) #-}
+ {-# SPECIALIZE truncate :: Float -> Int #-}
+ {-# SPECIALIZE round :: Float -> Int #-}
+ {-# SPECIALIZE ceiling :: Float -> Int #-}
+ {-# SPECIALIZE floor :: Float -> Int #-}
+
+ {-# SPECIALIZE properFraction :: Float -> (Integer, Float) #-}
+ {-# SPECIALIZE truncate :: Float -> Integer #-}
+ {-# SPECIALIZE round :: Float -> Integer #-}
+ {-# SPECIALIZE ceiling :: Float -> Integer #-}
+ {-# SPECIALIZE floor :: Float -> Integer #-}
+
+ properFraction x
+ = case (decodeFloat x) of { (m,n) ->
+ let b = floatRadix x in
+ if n >= 0 then
+ (fromInteger m * fromInteger b ^ n, 0.0)
+ else
+ case (quotRem m (b^(-n))) of { (w,r) ->
+ (fromInteger w, encodeFloat r n)
+ }
+ }
+
+ truncate x = case properFraction x of
+ (n,_) -> n
+
+ round x = case properFraction x of
+ (n,r) -> let
+ m = if r < 0.0 then n - __i1 else n + __i1
+ half_down = abs r - 0.5
+ in
+ case (_tagCmp half_down 0.0) of
+ _LT -> n
+ _EQ -> if even n then n else m
+ _GT -> m
+
+ ceiling x = case properFraction x of
+ (n,r) -> if r > 0.0 then n + __i1 else n
+
+ floor x = case properFraction x of
+ (n,r) -> if r < 0.0 then n - __i1 else n
instance RealFloat Float where
floatRadix _ = FLT_RADIX -- from float.h
encodeFloat (J# a# s# d#) (I# e#)
= case encodeFloat# a# s# d# e# of { flt# -> F# flt# }
+ exponent x = case decodeFloat x of
+ (m,n) -> if m == __i0 then 0 else n + floatDigits x
+
+ significand x = case decodeFloat x of
+ (m,_) -> encodeFloat m (- (floatDigits x))
+
+ scaleFloat k x = case decodeFloat x of
+ (m,n) -> encodeFloat m (n+k)
+
instance Enum Float where
-{- *** RAW PRELUDE ***
- enumFrom = numericEnumFrom
- enumFromThen = numericEnumFromThen
--}
- enumFrom x = x : enumFrom (x `plusFloat` 1.0)
- enumFromThen m n = en' m (n `minusFloat` m)
- where en' m n = m : en' (m `plusFloat` n) n
+ enumFrom x = x : enumFrom (x `plusFloat` 1.0)
+ enumFromThen m n = en' m (n `minusFloat` m)
+ where en' m n = m : en' (m `plusFloat` n) n
+ enumFromTo n m = takeWhile (<= m) (enumFrom n)
+ enumFromThenTo n m p = takeWhile (if m >= n then (<= p) else (>= p))
+ (enumFromThen n m)
instance Text Float where
readsPrec p x = readSigned readFloat x
showsPrec x = showSigned showFloat x
+ readList = _readList (readsPrec 0)
+ showList = _showList (showsPrec 0)
---------------------------------------------------------------
instance _CCallable Float
-{-# GHC_PRAGMA INTERFACE VERSION 5 #-}
+{-# GHC_PRAGMA INTERFACE VERSION 6 #-}
interface PreludeCore where
import PreludeBuiltin(Float(..))
instance Enum Float
{-# GHC_PRAGMA _M_ PreludeCore {-dfun-} _A_ 0 _N_ _N_ _N_ _F_ _IF_ARGS_ 0 0 X 6 _!_ _TUP_5 [{{Ord Float}}, (Float -> [Float]), (Float -> Float -> [Float]), (Float -> Float -> [Float]), (Float -> Float -> Float -> [Float])] [_DFUN_ Ord (Float), _CONSTM_ Enum enumFrom (Float), _CONSTM_ Enum enumFromThen (Float), _CONSTM_ Enum enumFromTo (Float), _CONSTM_ Enum enumFromThenTo (Float)] _N_
- enumFrom = _A_ 1 _U_ 2 _N_ _N_ _N_ _N_,
- enumFromThen = _A_ 2 _U_ 21 _N_ _N_ _N_ _N_,
- enumFromTo = _A_ 2 _U_ 22 _N_ _N_ _N_ _N_,
- enumFromThenTo = _A_ 3 _U_ 222 _N_ _N_ _N_ _N_ #-}
+ enumFrom = { _A_ 1 _U_ 2 _N_ _N_ _N_ _N_ },
+ enumFromThen = { _A_ 2 _U_ 21 _N_ _N_ _N_ _N_ },
+ enumFromTo = { _A_ 2 _U_ 22 _N_ _N_ _N_ _N_ },
+ enumFromThenTo = { _A_ 3 _U_ 222 _N_ _N_ _N_ _N_ } #-}
instance Eq Float
{-# GHC_PRAGMA _M_ PreludeCore {-dfun-} _A_ 0 _N_ _N_ _N_ _F_ _IF_ARGS_ 0 0 X 3 _!_ _TUP_2 [(Float -> Float -> Bool), (Float -> Float -> Bool)] [_CONSTM_ Eq (==) (Float), _CONSTM_ Eq (/=) (Float)] _N_
- (==) = _A_ 2 _U_ 11 _N_ _S_ "U(P)U(P)" {_A_ 2 _U_ 22 _N_ _N_ _F_ _IF_ARGS_ 0 2 XX 1 \ (u0 :: Float#) (u1 :: Float#) -> _#_ eqFloat# [] [u0, u1] _N_} _F_ _IF_ARGS_ 0 2 CC 3 \ (u0 :: Float) (u1 :: Float) -> case u0 of { _ALG_ F# (u2 :: Float#) -> case u1 of { _ALG_ F# (u3 :: Float#) -> _#_ eqFloat# [] [u2, u3]; _NO_DEFLT_ }; _NO_DEFLT_ } _N_,
- (/=) = _A_ 2 _U_ 11 _N_ _S_ "U(P)U(P)" {_A_ 2 _U_ 22 _N_ _N_ _F_ _IF_ARGS_ 0 2 XX 1 \ (u0 :: Float#) (u1 :: Float#) -> _#_ neFloat# [] [u0, u1] _N_} _F_ _IF_ARGS_ 0 2 CC 3 \ (u0 :: Float) (u1 :: Float) -> case u0 of { _ALG_ F# (u2 :: Float#) -> case u1 of { _ALG_ F# (u3 :: Float#) -> _#_ neFloat# [] [u2, u3]; _NO_DEFLT_ }; _NO_DEFLT_ } _N_ #-}
+ (==) = { _A_ 2 _U_ 11 _N_ _S_ "U(P)U(P)" {_A_ 2 _U_ 22 _N_ _N_ _F_ _IF_ARGS_ 0 2 XX 1 \ (u0 :: Float#) (u1 :: Float#) -> _#_ eqFloat# [] [u0, u1] _N_} _F_ _IF_ARGS_ 0 2 CC 3 \ (u0 :: Float) (u1 :: Float) -> case u0 of { _ALG_ F# (u2 :: Float#) -> case u1 of { _ALG_ F# (u3 :: Float#) -> _#_ eqFloat# [] [u2, u3]; _NO_DEFLT_ }; _NO_DEFLT_ } _N_ },
+ (/=) = { _A_ 2 _U_ 11 _N_ _S_ "U(P)U(P)" {_A_ 2 _U_ 22 _N_ _N_ _F_ _IF_ARGS_ 0 2 XX 1 \ (u0 :: Float#) (u1 :: Float#) -> _#_ neFloat# [] [u0, u1] _N_} _F_ _IF_ARGS_ 0 2 CC 3 \ (u0 :: Float) (u1 :: Float) -> case u0 of { _ALG_ F# (u2 :: Float#) -> case u1 of { _ALG_ F# (u3 :: Float#) -> _#_ neFloat# [] [u2, u3]; _NO_DEFLT_ }; _NO_DEFLT_ } _N_ } #-}
instance Floating Float
{-# GHC_PRAGMA _M_ PreludeCore {-dfun-} _A_ 0 _N_ _N_ _N_ _F_ _IF_ARGS_ 0 0 X 20 _!_ _TUP_19 [{{Fractional Float}}, Float, (Float -> Float), (Float -> Float), (Float -> Float), (Float -> Float -> Float), (Float -> Float -> Float), (Float -> Float), (Float -> Float), (Float -> Float), (Float -> Float), (Float -> Float), (Float -> Float), (Float -> Float), (Float -> Float), (Float -> Float), (Float -> Float), (Float -> Float), (Float -> Float)] [_DFUN_ Fractional (Float), _CONSTM_ Floating pi (Float), _CONSTM_ Floating exp (Float), _CONSTM_ Floating log (Float), _CONSTM_ Floating sqrt (Float), _CONSTM_ Floating (**) (Float), _CONSTM_ Floating logBase (Float), _CONSTM_ Floating sin (Float), _CONSTM_ Floating cos (Float), _CONSTM_ Floating tan (Float), _CONSTM_ Floating asin (Float), _CONSTM_ Floating acos (Float), _CONSTM_ Floating atan (Float), _CONSTM_ Floating sinh (Float), _CONSTM_ Floating cosh (Float), _CONSTM_ Floating tanh (Float), _CONSTM_ Floating asinh (Float), _CONSTM_ Floating acosh (Float), _CONSTM_ Floating atanh (Float)] _N_
- pi = _A_ 0 _N_ _N_ _N_ _F_ _IF_ARGS_ 0 0 X 2 _!_ F# [] [3.1415926535897931#] _N_,
- exp = _A_ 1 _U_ 1 _N_ _S_ "U(P)" {_A_ 1 _U_ 2 _N_ _N_ _F_ _IF_ARGS_ 0 1 X 3 \ (u0 :: Float#) -> case _#_ expFloat# [] [u0] of { _PRIM_ (u1 :: Float#) -> _!_ F# [] [u1] } _N_} _F_ _IF_ARGS_ 0 1 C 4 \ (u0 :: Float) -> case u0 of { _ALG_ F# (u1 :: Float#) -> case _#_ expFloat# [] [u1] of { _PRIM_ (u2 :: Float#) -> _!_ F# [] [u2] }; _NO_DEFLT_ } _N_,
- log = _A_ 1 _U_ 1 _N_ _S_ "U(P)" {_A_ 1 _U_ 2 _N_ _N_ _F_ _IF_ARGS_ 0 1 X 3 \ (u0 :: Float#) -> case _#_ logFloat# [] [u0] of { _PRIM_ (u1 :: Float#) -> _!_ F# [] [u1] } _N_} _F_ _IF_ARGS_ 0 1 C 4 \ (u0 :: Float) -> case u0 of { _ALG_ F# (u1 :: Float#) -> case _#_ logFloat# [] [u1] of { _PRIM_ (u2 :: Float#) -> _!_ F# [] [u2] }; _NO_DEFLT_ } _N_,
- sqrt = _A_ 1 _U_ 1 _N_ _S_ "U(P)" {_A_ 1 _U_ 2 _N_ _N_ _F_ _IF_ARGS_ 0 1 X 3 \ (u0 :: Float#) -> case _#_ sqrtFloat# [] [u0] of { _PRIM_ (u1 :: Float#) -> _!_ F# [] [u1] } _N_} _F_ _IF_ARGS_ 0 1 C 4 \ (u0 :: Float) -> case u0 of { _ALG_ F# (u1 :: Float#) -> case _#_ sqrtFloat# [] [u1] of { _PRIM_ (u2 :: Float#) -> _!_ F# [] [u2] }; _NO_DEFLT_ } _N_,
- (**) = _A_ 2 _U_ 11 _N_ _S_ "U(P)U(P)" {_A_ 2 _U_ 22 _N_ _N_ _F_ _IF_ARGS_ 0 2 XX 3 \ (u0 :: Float#) (u1 :: Float#) -> case _#_ powerFloat# [] [u0, u1] of { _PRIM_ (u2 :: Float#) -> _!_ F# [] [u2] } _N_} _F_ _IF_ARGS_ 0 2 CC 5 \ (u0 :: Float) (u1 :: Float) -> case u0 of { _ALG_ F# (u2 :: Float#) -> case u1 of { _ALG_ F# (u3 :: Float#) -> case _#_ powerFloat# [] [u2, u3] of { _PRIM_ (u4 :: Float#) -> _!_ F# [] [u4] }; _NO_DEFLT_ }; _NO_DEFLT_ } _N_,
- logBase = _A_ 2 _U_ 22 _N_ _N_ _N_ _N_,
- sin = _A_ 1 _U_ 1 _N_ _S_ "U(P)" {_A_ 1 _U_ 2 _N_ _N_ _F_ _IF_ARGS_ 0 1 X 3 \ (u0 :: Float#) -> case _#_ sinFloat# [] [u0] of { _PRIM_ (u1 :: Float#) -> _!_ F# [] [u1] } _N_} _F_ _IF_ARGS_ 0 1 C 4 \ (u0 :: Float) -> case u0 of { _ALG_ F# (u1 :: Float#) -> case _#_ sinFloat# [] [u1] of { _PRIM_ (u2 :: Float#) -> _!_ F# [] [u2] }; _NO_DEFLT_ } _N_,
- cos = _A_ 1 _U_ 1 _N_ _S_ "U(P)" {_A_ 1 _U_ 2 _N_ _N_ _F_ _IF_ARGS_ 0 1 X 3 \ (u0 :: Float#) -> case _#_ cosFloat# [] [u0] of { _PRIM_ (u1 :: Float#) -> _!_ F# [] [u1] } _N_} _F_ _IF_ARGS_ 0 1 C 4 \ (u0 :: Float) -> case u0 of { _ALG_ F# (u1 :: Float#) -> case _#_ cosFloat# [] [u1] of { _PRIM_ (u2 :: Float#) -> _!_ F# [] [u2] }; _NO_DEFLT_ } _N_,
- tan = _A_ 1 _U_ 1 _N_ _S_ "U(P)" {_A_ 1 _U_ 2 _N_ _N_ _F_ _IF_ARGS_ 0 1 X 3 \ (u0 :: Float#) -> case _#_ tanFloat# [] [u0] of { _PRIM_ (u1 :: Float#) -> _!_ F# [] [u1] } _N_} _F_ _IF_ARGS_ 0 1 C 4 \ (u0 :: Float) -> case u0 of { _ALG_ F# (u1 :: Float#) -> case _#_ tanFloat# [] [u1] of { _PRIM_ (u2 :: Float#) -> _!_ F# [] [u2] }; _NO_DEFLT_ } _N_,
- asin = _A_ 1 _U_ 1 _N_ _S_ "U(P)" {_A_ 1 _U_ 2 _N_ _N_ _F_ _IF_ARGS_ 0 1 X 3 \ (u0 :: Float#) -> case _#_ asinFloat# [] [u0] of { _PRIM_ (u1 :: Float#) -> _!_ F# [] [u1] } _N_} _F_ _IF_ARGS_ 0 1 C 4 \ (u0 :: Float) -> case u0 of { _ALG_ F# (u1 :: Float#) -> case _#_ asinFloat# [] [u1] of { _PRIM_ (u2 :: Float#) -> _!_ F# [] [u2] }; _NO_DEFLT_ } _N_,
- acos = _A_ 1 _U_ 1 _N_ _S_ "U(P)" {_A_ 1 _U_ 2 _N_ _N_ _F_ _IF_ARGS_ 0 1 X 3 \ (u0 :: Float#) -> case _#_ acosFloat# [] [u0] of { _PRIM_ (u1 :: Float#) -> _!_ F# [] [u1] } _N_} _F_ _IF_ARGS_ 0 1 C 4 \ (u0 :: Float) -> case u0 of { _ALG_ F# (u1 :: Float#) -> case _#_ acosFloat# [] [u1] of { _PRIM_ (u2 :: Float#) -> _!_ F# [] [u2] }; _NO_DEFLT_ } _N_,
- atan = _A_ 1 _U_ 1 _N_ _S_ "U(P)" {_A_ 1 _U_ 2 _N_ _N_ _F_ _IF_ARGS_ 0 1 X 3 \ (u0 :: Float#) -> case _#_ atanFloat# [] [u0] of { _PRIM_ (u1 :: Float#) -> _!_ F# [] [u1] } _N_} _F_ _IF_ARGS_ 0 1 C 4 \ (u0 :: Float) -> case u0 of { _ALG_ F# (u1 :: Float#) -> case _#_ atanFloat# [] [u1] of { _PRIM_ (u2 :: Float#) -> _!_ F# [] [u2] }; _NO_DEFLT_ } _N_,
- sinh = _A_ 1 _U_ 1 _N_ _S_ "U(P)" {_A_ 1 _U_ 2 _N_ _N_ _F_ _IF_ARGS_ 0 1 X 3 \ (u0 :: Float#) -> case _#_ sinhFloat# [] [u0] of { _PRIM_ (u1 :: Float#) -> _!_ F# [] [u1] } _N_} _F_ _IF_ARGS_ 0 1 C 4 \ (u0 :: Float) -> case u0 of { _ALG_ F# (u1 :: Float#) -> case _#_ sinhFloat# [] [u1] of { _PRIM_ (u2 :: Float#) -> _!_ F# [] [u2] }; _NO_DEFLT_ } _N_,
- cosh = _A_ 1 _U_ 1 _N_ _S_ "U(P)" {_A_ 1 _U_ 2 _N_ _N_ _F_ _IF_ARGS_ 0 1 X 3 \ (u0 :: Float#) -> case _#_ coshFloat# [] [u0] of { _PRIM_ (u1 :: Float#) -> _!_ F# [] [u1] } _N_} _F_ _IF_ARGS_ 0 1 C 4 \ (u0 :: Float) -> case u0 of { _ALG_ F# (u1 :: Float#) -> case _#_ coshFloat# [] [u1] of { _PRIM_ (u2 :: Float#) -> _!_ F# [] [u2] }; _NO_DEFLT_ } _N_,
- tanh = _A_ 1 _U_ 1 _N_ _S_ "U(P)" {_A_ 1 _U_ 2 _N_ _N_ _F_ _IF_ARGS_ 0 1 X 3 \ (u0 :: Float#) -> case _#_ tanhFloat# [] [u0] of { _PRIM_ (u1 :: Float#) -> _!_ F# [] [u1] } _N_} _F_ _IF_ARGS_ 0 1 C 4 \ (u0 :: Float) -> case u0 of { _ALG_ F# (u1 :: Float#) -> case _#_ tanhFloat# [] [u1] of { _PRIM_ (u2 :: Float#) -> _!_ F# [] [u2] }; _NO_DEFLT_ } _N_,
- asinh = _A_ 1 _U_ 1 _N_ _S_ "U(P)" {_A_ 1 _U_ 2 _N_ _N_ _N_ _N_} _N_ _N_,
- acosh = _A_ 1 _U_ 1 _N_ _S_ "U(P)" {_A_ 1 _U_ 2 _N_ _N_ _N_ _N_} _N_ _N_,
- atanh = _A_ 1 _U_ 1 _N_ _S_ "U(P)" {_A_ 1 _U_ 2 _N_ _N_ _N_ _N_} _N_ _N_ #-}
+ pi = { _A_ 0 _N_ _N_ _N_ _F_ _IF_ARGS_ 0 0 X 2 _!_ F# [] [3.1415926535897931#] _N_ },
+ exp = { _A_ 1 _U_ 1 _N_ _S_ "U(P)" {_A_ 1 _U_ 2 _N_ _N_ _F_ _IF_ARGS_ 0 1 X 3 \ (u0 :: Float#) -> case _#_ expFloat# [] [u0] of { _PRIM_ (u1 :: Float#) -> _!_ F# [] [u1] } _N_} _F_ _IF_ARGS_ 0 1 C 4 \ (u0 :: Float) -> case u0 of { _ALG_ F# (u1 :: Float#) -> case _#_ expFloat# [] [u1] of { _PRIM_ (u2 :: Float#) -> _!_ F# [] [u2] }; _NO_DEFLT_ } _N_ },
+ log = { _A_ 1 _U_ 1 _N_ _S_ "U(P)" {_A_ 1 _U_ 2 _N_ _N_ _F_ _IF_ARGS_ 0 1 X 3 \ (u0 :: Float#) -> case _#_ logFloat# [] [u0] of { _PRIM_ (u1 :: Float#) -> _!_ F# [] [u1] } _N_} _F_ _IF_ARGS_ 0 1 C 4 \ (u0 :: Float) -> case u0 of { _ALG_ F# (u1 :: Float#) -> case _#_ logFloat# [] [u1] of { _PRIM_ (u2 :: Float#) -> _!_ F# [] [u2] }; _NO_DEFLT_ } _N_ },
+ sqrt = { _A_ 1 _U_ 1 _N_ _S_ "U(P)" {_A_ 1 _U_ 2 _N_ _N_ _F_ _IF_ARGS_ 0 1 X 3 \ (u0 :: Float#) -> case _#_ sqrtFloat# [] [u0] of { _PRIM_ (u1 :: Float#) -> _!_ F# [] [u1] } _N_} _F_ _IF_ARGS_ 0 1 C 4 \ (u0 :: Float) -> case u0 of { _ALG_ F# (u1 :: Float#) -> case _#_ sqrtFloat# [] [u1] of { _PRIM_ (u2 :: Float#) -> _!_ F# [] [u2] }; _NO_DEFLT_ } _N_ },
+ (**) = { _A_ 2 _U_ 11 _N_ _S_ "U(P)U(P)" {_A_ 2 _U_ 22 _N_ _N_ _F_ _IF_ARGS_ 0 2 XX 3 \ (u0 :: Float#) (u1 :: Float#) -> case _#_ powerFloat# [] [u0, u1] of { _PRIM_ (u2 :: Float#) -> _!_ F# [] [u2] } _N_} _F_ _IF_ARGS_ 0 2 CC 5 \ (u0 :: Float) (u1 :: Float) -> case u0 of { _ALG_ F# (u2 :: Float#) -> case u1 of { _ALG_ F# (u3 :: Float#) -> case _#_ powerFloat# [] [u2, u3] of { _PRIM_ (u4 :: Float#) -> _!_ F# [] [u4] }; _NO_DEFLT_ }; _NO_DEFLT_ } _N_ },
+ logBase = { _A_ 2 _U_ 11 _N_ _S_ "U(P)U(P)" {_A_ 2 _U_ 22 _N_ _N_ _F_ _IF_ARGS_ 0 2 XX 5 \ (u0 :: Float#) (u1 :: Float#) -> case _#_ logFloat# [] [u1] of { _PRIM_ (u2 :: Float#) -> case _#_ logFloat# [] [u0] of { _PRIM_ (u3 :: Float#) -> case _#_ divideFloat# [] [u2, u3] of { _PRIM_ (u4 :: Float#) -> _!_ F# [] [u4] } } } _N_} _F_ _IF_ARGS_ 0 2 CC 7 \ (u0 :: Float) (u1 :: Float) -> case u1 of { _ALG_ F# (u2 :: Float#) -> case _#_ logFloat# [] [u2] of { _PRIM_ (u3 :: Float#) -> case u0 of { _ALG_ F# (u4 :: Float#) -> case _#_ logFloat# [] [u4] of { _PRIM_ (u5 :: Float#) -> case _#_ divideFloat# [] [u3, u5] of { _PRIM_ (u6 :: Float#) -> _!_ F# [] [u6] } }; _NO_DEFLT_ } }; _NO_DEFLT_ } _N_ },
+ sin = { _A_ 1 _U_ 1 _N_ _S_ "U(P)" {_A_ 1 _U_ 2 _N_ _N_ _F_ _IF_ARGS_ 0 1 X 3 \ (u0 :: Float#) -> case _#_ sinFloat# [] [u0] of { _PRIM_ (u1 :: Float#) -> _!_ F# [] [u1] } _N_} _F_ _IF_ARGS_ 0 1 C 4 \ (u0 :: Float) -> case u0 of { _ALG_ F# (u1 :: Float#) -> case _#_ sinFloat# [] [u1] of { _PRIM_ (u2 :: Float#) -> _!_ F# [] [u2] }; _NO_DEFLT_ } _N_ },
+ cos = { _A_ 1 _U_ 1 _N_ _S_ "U(P)" {_A_ 1 _U_ 2 _N_ _N_ _F_ _IF_ARGS_ 0 1 X 3 \ (u0 :: Float#) -> case _#_ cosFloat# [] [u0] of { _PRIM_ (u1 :: Float#) -> _!_ F# [] [u1] } _N_} _F_ _IF_ARGS_ 0 1 C 4 \ (u0 :: Float) -> case u0 of { _ALG_ F# (u1 :: Float#) -> case _#_ cosFloat# [] [u1] of { _PRIM_ (u2 :: Float#) -> _!_ F# [] [u2] }; _NO_DEFLT_ } _N_ },
+ tan = { _A_ 1 _U_ 1 _N_ _S_ "U(P)" {_A_ 1 _U_ 2 _N_ _N_ _F_ _IF_ARGS_ 0 1 X 3 \ (u0 :: Float#) -> case _#_ tanFloat# [] [u0] of { _PRIM_ (u1 :: Float#) -> _!_ F# [] [u1] } _N_} _F_ _IF_ARGS_ 0 1 C 4 \ (u0 :: Float) -> case u0 of { _ALG_ F# (u1 :: Float#) -> case _#_ tanFloat# [] [u1] of { _PRIM_ (u2 :: Float#) -> _!_ F# [] [u2] }; _NO_DEFLT_ } _N_ },
+ asin = { _A_ 1 _U_ 1 _N_ _S_ "U(P)" {_A_ 1 _U_ 2 _N_ _N_ _F_ _IF_ARGS_ 0 1 X 3 \ (u0 :: Float#) -> case _#_ asinFloat# [] [u0] of { _PRIM_ (u1 :: Float#) -> _!_ F# [] [u1] } _N_} _F_ _IF_ARGS_ 0 1 C 4 \ (u0 :: Float) -> case u0 of { _ALG_ F# (u1 :: Float#) -> case _#_ asinFloat# [] [u1] of { _PRIM_ (u2 :: Float#) -> _!_ F# [] [u2] }; _NO_DEFLT_ } _N_ },
+ acos = { _A_ 1 _U_ 1 _N_ _S_ "U(P)" {_A_ 1 _U_ 2 _N_ _N_ _F_ _IF_ARGS_ 0 1 X 3 \ (u0 :: Float#) -> case _#_ acosFloat# [] [u0] of { _PRIM_ (u1 :: Float#) -> _!_ F# [] [u1] } _N_} _F_ _IF_ARGS_ 0 1 C 4 \ (u0 :: Float) -> case u0 of { _ALG_ F# (u1 :: Float#) -> case _#_ acosFloat# [] [u1] of { _PRIM_ (u2 :: Float#) -> _!_ F# [] [u2] }; _NO_DEFLT_ } _N_ },
+ atan = { _A_ 1 _U_ 1 _N_ _S_ "U(P)" {_A_ 1 _U_ 2 _N_ _N_ _F_ _IF_ARGS_ 0 1 X 3 \ (u0 :: Float#) -> case _#_ atanFloat# [] [u0] of { _PRIM_ (u1 :: Float#) -> _!_ F# [] [u1] } _N_} _F_ _IF_ARGS_ 0 1 C 4 \ (u0 :: Float) -> case u0 of { _ALG_ F# (u1 :: Float#) -> case _#_ atanFloat# [] [u1] of { _PRIM_ (u2 :: Float#) -> _!_ F# [] [u2] }; _NO_DEFLT_ } _N_ },
+ sinh = { _A_ 1 _U_ 1 _N_ _S_ "U(P)" {_A_ 1 _U_ 2 _N_ _N_ _F_ _IF_ARGS_ 0 1 X 3 \ (u0 :: Float#) -> case _#_ sinhFloat# [] [u0] of { _PRIM_ (u1 :: Float#) -> _!_ F# [] [u1] } _N_} _F_ _IF_ARGS_ 0 1 C 4 \ (u0 :: Float) -> case u0 of { _ALG_ F# (u1 :: Float#) -> case _#_ sinhFloat# [] [u1] of { _PRIM_ (u2 :: Float#) -> _!_ F# [] [u2] }; _NO_DEFLT_ } _N_ },
+ cosh = { _A_ 1 _U_ 1 _N_ _S_ "U(P)" {_A_ 1 _U_ 2 _N_ _N_ _F_ _IF_ARGS_ 0 1 X 3 \ (u0 :: Float#) -> case _#_ coshFloat# [] [u0] of { _PRIM_ (u1 :: Float#) -> _!_ F# [] [u1] } _N_} _F_ _IF_ARGS_ 0 1 C 4 \ (u0 :: Float) -> case u0 of { _ALG_ F# (u1 :: Float#) -> case _#_ coshFloat# [] [u1] of { _PRIM_ (u2 :: Float#) -> _!_ F# [] [u2] }; _NO_DEFLT_ } _N_ },
+ tanh = { _A_ 1 _U_ 1 _N_ _S_ "U(P)" {_A_ 1 _U_ 2 _N_ _N_ _F_ _IF_ARGS_ 0 1 X 3 \ (u0 :: Float#) -> case _#_ tanhFloat# [] [u0] of { _PRIM_ (u1 :: Float#) -> _!_ F# [] [u1] } _N_} _F_ _IF_ARGS_ 0 1 C 4 \ (u0 :: Float) -> case u0 of { _ALG_ F# (u1 :: Float#) -> case _#_ tanhFloat# [] [u1] of { _PRIM_ (u2 :: Float#) -> _!_ F# [] [u2] }; _NO_DEFLT_ } _N_ },
+ asinh = { _A_ 1 _U_ 1 _N_ _S_ "U(P)" {_A_ 1 _U_ 2 _N_ _N_ _N_ _N_} _N_ _N_ },
+ acosh = { _A_ 1 _U_ 1 _N_ _S_ "U(P)" {_A_ 1 _U_ 2 _N_ _N_ _N_ _N_} _N_ _N_ },
+ atanh = { _A_ 1 _U_ 1 _N_ _S_ "U(P)" {_A_ 1 _U_ 2 _N_ _N_ _N_ _N_} _N_ _N_ } #-}
instance Fractional Float
{-# GHC_PRAGMA _M_ PreludeCore {-dfun-} _A_ 0 _N_ _N_ _N_ _F_ _IF_ARGS_ 0 0 X 5 _!_ _TUP_4 [{{Num Float}}, (Float -> Float -> Float), (Float -> Float), (Ratio Integer -> Float)] [_DFUN_ Num (Float), _CONSTM_ Fractional (/) (Float), _CONSTM_ Fractional recip (Float), _CONSTM_ Fractional fromRational (Float)] _N_
- (/) = _A_ 2 _U_ 11 _N_ _S_ "U(P)U(P)" {_A_ 2 _U_ 22 _N_ _N_ _F_ _IF_ARGS_ 0 2 XX 3 \ (u0 :: Float#) (u1 :: Float#) -> case _#_ divideFloat# [] [u0, u1] of { _PRIM_ (u2 :: Float#) -> _!_ F# [] [u2] } _N_} _F_ _IF_ARGS_ 0 2 CC 5 \ (u0 :: Float) (u1 :: Float) -> case u0 of { _ALG_ F# (u2 :: Float#) -> case u1 of { _ALG_ F# (u3 :: Float#) -> case _#_ divideFloat# [] [u2, u3] of { _PRIM_ (u4 :: Float#) -> _!_ F# [] [u4] }; _NO_DEFLT_ }; _NO_DEFLT_ } _N_,
- recip = _A_ 0 _U_ 2 _N_ _N_ _N_ _N_,
- fromRational = _A_ 0 _U_ 2 _N_ _N_ _N_ _N_ #-}
+ (/) = { _A_ 2 _U_ 11 _N_ _S_ "U(P)U(P)" {_A_ 2 _U_ 22 _N_ _N_ _F_ _IF_ARGS_ 0 2 XX 3 \ (u0 :: Float#) (u1 :: Float#) -> case _#_ divideFloat# [] [u0, u1] of { _PRIM_ (u2 :: Float#) -> _!_ F# [] [u2] } _N_} _F_ _IF_ARGS_ 0 2 CC 5 \ (u0 :: Float) (u1 :: Float) -> case u0 of { _ALG_ F# (u2 :: Float#) -> case u1 of { _ALG_ F# (u3 :: Float#) -> case _#_ divideFloat# [] [u2, u3] of { _PRIM_ (u4 :: Float#) -> _!_ F# [] [u4] }; _NO_DEFLT_ }; _NO_DEFLT_ } _N_ },
+ recip = { _A_ 1 _U_ 1 _N_ _S_ "U(P)" {_A_ 1 _U_ 2 _N_ _N_ _F_ _IF_ARGS_ 0 1 X 3 \ (u0 :: Float#) -> case _#_ divideFloat# [] [1.0000000000000000#, u0] of { _PRIM_ (u1 :: Float#) -> _!_ F# [] [u1] } _N_} _F_ _IF_ARGS_ 0 1 C 4 \ (u0 :: Float) -> case u0 of { _ALG_ F# (u1 :: Float#) -> case _#_ divideFloat# [] [1.0000000000000000#, u1] of { _PRIM_ (u2 :: Float#) -> _!_ F# [] [u2] }; _NO_DEFLT_ } _N_ },
+ fromRational = { _A_ 1 _U_ 2 _N_ _N_ _N_ _N_ } #-}
instance Num Float
{-# GHC_PRAGMA _M_ PreludeCore {-dfun-} _A_ 0 _N_ _N_ _N_ _F_ _IF_ARGS_ 0 0 X 11 _!_ _TUP_10 [{{Eq Float}}, {{Text Float}}, (Float -> Float -> Float), (Float -> Float -> Float), (Float -> Float -> Float), (Float -> Float), (Float -> Float), (Float -> Float), (Integer -> Float), (Int -> Float)] [_DFUN_ Eq (Float), _DFUN_ Text (Float), _CONSTM_ Num (+) (Float), _CONSTM_ Num (-) (Float), _CONSTM_ Num (*) (Float), _CONSTM_ Num negate (Float), _CONSTM_ Num abs (Float), _CONSTM_ Num signum (Float), _CONSTM_ Num fromInteger (Float), _CONSTM_ Num fromInt (Float)] _N_
- (+) = _A_ 2 _U_ 11 _N_ _S_ "U(P)U(P)" {_A_ 2 _U_ 22 _N_ _N_ _F_ _IF_ARGS_ 0 2 XX 3 \ (u0 :: Float#) (u1 :: Float#) -> case _#_ plusFloat# [] [u0, u1] of { _PRIM_ (u2 :: Float#) -> _!_ F# [] [u2] } _N_} _F_ _IF_ARGS_ 0 2 CC 5 \ (u0 :: Float) (u1 :: Float) -> case u0 of { _ALG_ F# (u2 :: Float#) -> case u1 of { _ALG_ F# (u3 :: Float#) -> case _#_ plusFloat# [] [u2, u3] of { _PRIM_ (u4 :: Float#) -> _!_ F# [] [u4] }; _NO_DEFLT_ }; _NO_DEFLT_ } _N_,
- (-) = _A_ 2 _U_ 11 _N_ _S_ "U(P)U(P)" {_A_ 2 _U_ 22 _N_ _N_ _F_ _IF_ARGS_ 0 2 XX 3 \ (u0 :: Float#) (u1 :: Float#) -> case _#_ minusFloat# [] [u0, u1] of { _PRIM_ (u2 :: Float#) -> _!_ F# [] [u2] } _N_} _F_ _IF_ARGS_ 0 2 CC 5 \ (u0 :: Float) (u1 :: Float) -> case u0 of { _ALG_ F# (u2 :: Float#) -> case u1 of { _ALG_ F# (u3 :: Float#) -> case _#_ minusFloat# [] [u2, u3] of { _PRIM_ (u4 :: Float#) -> _!_ F# [] [u4] }; _NO_DEFLT_ }; _NO_DEFLT_ } _N_,
- (*) = _A_ 2 _U_ 11 _N_ _S_ "U(P)U(P)" {_A_ 2 _U_ 22 _N_ _N_ _F_ _IF_ARGS_ 0 2 XX 3 \ (u0 :: Float#) (u1 :: Float#) -> case _#_ timesFloat# [] [u0, u1] of { _PRIM_ (u2 :: Float#) -> _!_ F# [] [u2] } _N_} _F_ _IF_ARGS_ 0 2 CC 5 \ (u0 :: Float) (u1 :: Float) -> case u0 of { _ALG_ F# (u2 :: Float#) -> case u1 of { _ALG_ F# (u3 :: Float#) -> case _#_ timesFloat# [] [u2, u3] of { _PRIM_ (u4 :: Float#) -> _!_ F# [] [u4] }; _NO_DEFLT_ }; _NO_DEFLT_ } _N_,
- negate = _A_ 1 _U_ 1 _N_ _S_ "U(P)" {_A_ 1 _U_ 2 _N_ _N_ _F_ _IF_ARGS_ 0 1 X 3 \ (u0 :: Float#) -> case _#_ negateFloat# [] [u0] of { _PRIM_ (u1 :: Float#) -> _!_ F# [] [u1] } _N_} _F_ _IF_ARGS_ 0 1 C 4 \ (u0 :: Float) -> case u0 of { _ALG_ F# (u1 :: Float#) -> case _#_ negateFloat# [] [u1] of { _PRIM_ (u2 :: Float#) -> _!_ F# [] [u2] }; _NO_DEFLT_ } _N_,
- abs = _A_ 1 _U_ 1 _N_ _S_ "U(P)" {_A_ 1 _U_ 2 _N_ _N_ _N_ _N_} _N_ _N_,
- signum = _A_ 1 _U_ 1 _N_ _S_ "U(P)" {_A_ 1 _U_ 2 _N_ _N_ _N_ _N_} _N_ _N_,
- fromInteger = _A_ 1 _U_ 1 _N_ _S_ "U(PPP)" {_A_ 3 _U_ 222 _N_ _N_ _F_ _IF_ARGS_ 0 3 XXX 3 \ (u0 :: Int#) (u1 :: Int#) (u2 :: ByteArray#) -> case _#_ encodeFloat# [] [u0, u1, u2, 0#] of { _PRIM_ (u3 :: Float#) -> _!_ F# [] [u3] } _N_} _F_ _IF_ARGS_ 0 1 C 4 \ (u0 :: Integer) -> case u0 of { _ALG_ J# (u1 :: Int#) (u2 :: Int#) (u3 :: ByteArray#) -> case _#_ encodeFloat# [] [u1, u2, u3, 0#] of { _PRIM_ (u4 :: Float#) -> _!_ F# [] [u4] }; _NO_DEFLT_ } _N_,
- fromInt = _A_ 1 _U_ 1 _N_ _S_ "U(P)" {_A_ 1 _U_ 2 _N_ _N_ _F_ _IF_ARGS_ 0 1 X 3 \ (u0 :: Int#) -> case _#_ int2Float# [] [u0] of { _PRIM_ (u1 :: Float#) -> _!_ F# [] [u1] } _N_} _F_ _IF_ARGS_ 0 1 C 4 \ (u0 :: Int) -> case u0 of { _ALG_ I# (u1 :: Int#) -> case _#_ int2Float# [] [u1] of { _PRIM_ (u2 :: Float#) -> _!_ F# [] [u2] }; _NO_DEFLT_ } _N_ #-}
+ (+) = { _A_ 2 _U_ 11 _N_ _S_ "U(P)U(P)" {_A_ 2 _U_ 22 _N_ _N_ _F_ _IF_ARGS_ 0 2 XX 3 \ (u0 :: Float#) (u1 :: Float#) -> case _#_ plusFloat# [] [u0, u1] of { _PRIM_ (u2 :: Float#) -> _!_ F# [] [u2] } _N_} _F_ _IF_ARGS_ 0 2 CC 5 \ (u0 :: Float) (u1 :: Float) -> case u0 of { _ALG_ F# (u2 :: Float#) -> case u1 of { _ALG_ F# (u3 :: Float#) -> case _#_ plusFloat# [] [u2, u3] of { _PRIM_ (u4 :: Float#) -> _!_ F# [] [u4] }; _NO_DEFLT_ }; _NO_DEFLT_ } _N_ },
+ (-) = { _A_ 2 _U_ 11 _N_ _S_ "U(P)U(P)" {_A_ 2 _U_ 22 _N_ _N_ _F_ _IF_ARGS_ 0 2 XX 3 \ (u0 :: Float#) (u1 :: Float#) -> case _#_ minusFloat# [] [u0, u1] of { _PRIM_ (u2 :: Float#) -> _!_ F# [] [u2] } _N_} _F_ _IF_ARGS_ 0 2 CC 5 \ (u0 :: Float) (u1 :: Float) -> case u0 of { _ALG_ F# (u2 :: Float#) -> case u1 of { _ALG_ F# (u3 :: Float#) -> case _#_ minusFloat# [] [u2, u3] of { _PRIM_ (u4 :: Float#) -> _!_ F# [] [u4] }; _NO_DEFLT_ }; _NO_DEFLT_ } _N_ },
+ (*) = { _A_ 2 _U_ 11 _N_ _S_ "U(P)U(P)" {_A_ 2 _U_ 22 _N_ _N_ _F_ _IF_ARGS_ 0 2 XX 3 \ (u0 :: Float#) (u1 :: Float#) -> case _#_ timesFloat# [] [u0, u1] of { _PRIM_ (u2 :: Float#) -> _!_ F# [] [u2] } _N_} _F_ _IF_ARGS_ 0 2 CC 5 \ (u0 :: Float) (u1 :: Float) -> case u0 of { _ALG_ F# (u2 :: Float#) -> case u1 of { _ALG_ F# (u3 :: Float#) -> case _#_ timesFloat# [] [u2, u3] of { _PRIM_ (u4 :: Float#) -> _!_ F# [] [u4] }; _NO_DEFLT_ }; _NO_DEFLT_ } _N_ },
+ negate = { _A_ 1 _U_ 1 _N_ _S_ "U(P)" {_A_ 1 _U_ 2 _N_ _N_ _F_ _IF_ARGS_ 0 1 X 3 \ (u0 :: Float#) -> case _#_ negateFloat# [] [u0] of { _PRIM_ (u1 :: Float#) -> _!_ F# [] [u1] } _N_} _F_ _IF_ARGS_ 0 1 C 4 \ (u0 :: Float) -> case u0 of { _ALG_ F# (u1 :: Float#) -> case _#_ negateFloat# [] [u1] of { _PRIM_ (u2 :: Float#) -> _!_ F# [] [u2] }; _NO_DEFLT_ } _N_ },
+ abs = { _A_ 1 _U_ 1 _N_ _S_ "U(P)" {_A_ 1 _U_ 2 _N_ _N_ _N_ _N_} _N_ _N_ },
+ signum = { _A_ 1 _U_ 1 _N_ _S_ "U(P)" {_A_ 1 _U_ 2 _N_ _N_ _N_ _N_} _N_ _N_ },
+ fromInteger = { _A_ 1 _U_ 1 _N_ _S_ "U(PPP)" {_A_ 3 _U_ 222 _N_ _N_ _F_ _IF_ARGS_ 0 3 XXX 3 \ (u0 :: Int#) (u1 :: Int#) (u2 :: ByteArray#) -> case _#_ encodeFloat# [] [u0, u1, u2, 0#] of { _PRIM_ (u3 :: Float#) -> _!_ F# [] [u3] } _N_} _F_ _IF_ARGS_ 0 1 C 4 \ (u0 :: Integer) -> case u0 of { _ALG_ J# (u1 :: Int#) (u2 :: Int#) (u3 :: ByteArray#) -> case _#_ encodeFloat# [] [u1, u2, u3, 0#] of { _PRIM_ (u4 :: Float#) -> _!_ F# [] [u4] }; _NO_DEFLT_ } _N_ },
+ fromInt = { _A_ 1 _U_ 1 _N_ _S_ "U(P)" {_A_ 1 _U_ 2 _N_ _N_ _F_ _IF_ARGS_ 0 1 X 3 \ (u0 :: Int#) -> case _#_ int2Float# [] [u0] of { _PRIM_ (u1 :: Float#) -> _!_ F# [] [u1] } _N_} _F_ _IF_ARGS_ 0 1 C 4 \ (u0 :: Int) -> case u0 of { _ALG_ I# (u1 :: Int#) -> case _#_ int2Float# [] [u1] of { _PRIM_ (u2 :: Float#) -> _!_ F# [] [u2] }; _NO_DEFLT_ } _N_ } #-}
instance Ord Float
{-# GHC_PRAGMA _M_ PreludeCore {-dfun-} _A_ 0 _N_ _N_ _N_ _F_ _IF_ARGS_ 0 0 X 9 _!_ _TUP_8 [{{Eq Float}}, (Float -> Float -> Bool), (Float -> Float -> Bool), (Float -> Float -> Bool), (Float -> Float -> Bool), (Float -> Float -> Float), (Float -> Float -> Float), (Float -> Float -> _CMP_TAG)] [_DFUN_ Eq (Float), _CONSTM_ Ord (<) (Float), _CONSTM_ Ord (<=) (Float), _CONSTM_ Ord (>=) (Float), _CONSTM_ Ord (>) (Float), _CONSTM_ Ord max (Float), _CONSTM_ Ord min (Float), _CONSTM_ Ord _tagCmp (Float)] _N_
- (<) = _A_ 2 _U_ 11 _N_ _S_ "U(P)U(P)" {_A_ 2 _U_ 22 _N_ _N_ _F_ _IF_ARGS_ 0 2 XX 1 \ (u0 :: Float#) (u1 :: Float#) -> _#_ ltFloat# [] [u0, u1] _N_} _F_ _IF_ARGS_ 0 2 CC 3 \ (u0 :: Float) (u1 :: Float) -> case u0 of { _ALG_ F# (u2 :: Float#) -> case u1 of { _ALG_ F# (u3 :: Float#) -> _#_ ltFloat# [] [u2, u3]; _NO_DEFLT_ }; _NO_DEFLT_ } _N_,
- (<=) = _A_ 2 _U_ 11 _N_ _S_ "U(P)U(P)" {_A_ 2 _U_ 22 _N_ _N_ _F_ _IF_ARGS_ 0 2 XX 1 \ (u0 :: Float#) (u1 :: Float#) -> _#_ leFloat# [] [u0, u1] _N_} _F_ _IF_ARGS_ 0 2 CC 3 \ (u0 :: Float) (u1 :: Float) -> case u0 of { _ALG_ F# (u2 :: Float#) -> case u1 of { _ALG_ F# (u3 :: Float#) -> _#_ leFloat# [] [u2, u3]; _NO_DEFLT_ }; _NO_DEFLT_ } _N_,
- (>=) = _A_ 2 _U_ 11 _N_ _S_ "U(P)U(P)" {_A_ 2 _U_ 22 _N_ _N_ _F_ _IF_ARGS_ 0 2 XX 1 \ (u0 :: Float#) (u1 :: Float#) -> _#_ geFloat# [] [u0, u1] _N_} _F_ _IF_ARGS_ 0 2 CC 3 \ (u0 :: Float) (u1 :: Float) -> case u0 of { _ALG_ F# (u2 :: Float#) -> case u1 of { _ALG_ F# (u3 :: Float#) -> _#_ geFloat# [] [u2, u3]; _NO_DEFLT_ }; _NO_DEFLT_ } _N_,
- (>) = _A_ 2 _U_ 11 _N_ _S_ "U(P)U(P)" {_A_ 2 _U_ 22 _N_ _N_ _F_ _IF_ARGS_ 0 2 XX 1 \ (u0 :: Float#) (u1 :: Float#) -> _#_ gtFloat# [] [u0, u1] _N_} _F_ _IF_ARGS_ 0 2 CC 3 \ (u0 :: Float) (u1 :: Float) -> case u0 of { _ALG_ F# (u2 :: Float#) -> case u1 of { _ALG_ F# (u3 :: Float#) -> _#_ gtFloat# [] [u2, u3]; _NO_DEFLT_ }; _NO_DEFLT_ } _N_,
- max = _A_ 2 _U_ 11 _N_ _S_ "U(P)U(P)" {_A_ 2 _U_ 22 _N_ _N_ _N_ _N_} _N_ _N_,
- min = _A_ 2 _U_ 11 _N_ _S_ "U(P)U(P)" {_A_ 2 _U_ 22 _N_ _N_ _N_ _N_} _N_ _N_,
- _tagCmp = _A_ 2 _U_ 11 _N_ _S_ "U(P)U(P)" {_A_ 2 _U_ 22 _N_ _N_ _N_ _N_} _N_ _N_ #-}
+ (<) = { _A_ 2 _U_ 11 _N_ _S_ "U(P)U(P)" {_A_ 2 _U_ 22 _N_ _N_ _F_ _IF_ARGS_ 0 2 XX 1 \ (u0 :: Float#) (u1 :: Float#) -> _#_ ltFloat# [] [u0, u1] _N_} _F_ _IF_ARGS_ 0 2 CC 3 \ (u0 :: Float) (u1 :: Float) -> case u0 of { _ALG_ F# (u2 :: Float#) -> case u1 of { _ALG_ F# (u3 :: Float#) -> _#_ ltFloat# [] [u2, u3]; _NO_DEFLT_ }; _NO_DEFLT_ } _N_ },
+ (<=) = { _A_ 2 _U_ 11 _N_ _S_ "U(P)U(P)" {_A_ 2 _U_ 22 _N_ _N_ _F_ _IF_ARGS_ 0 2 XX 1 \ (u0 :: Float#) (u1 :: Float#) -> _#_ leFloat# [] [u0, u1] _N_} _F_ _IF_ARGS_ 0 2 CC 3 \ (u0 :: Float) (u1 :: Float) -> case u0 of { _ALG_ F# (u2 :: Float#) -> case u1 of { _ALG_ F# (u3 :: Float#) -> _#_ leFloat# [] [u2, u3]; _NO_DEFLT_ }; _NO_DEFLT_ } _N_ },
+ (>=) = { _A_ 2 _U_ 11 _N_ _S_ "U(P)U(P)" {_A_ 2 _U_ 22 _N_ _N_ _F_ _IF_ARGS_ 0 2 XX 1 \ (u0 :: Float#) (u1 :: Float#) -> _#_ geFloat# [] [u0, u1] _N_} _F_ _IF_ARGS_ 0 2 CC 3 \ (u0 :: Float) (u1 :: Float) -> case u0 of { _ALG_ F# (u2 :: Float#) -> case u1 of { _ALG_ F# (u3 :: Float#) -> _#_ geFloat# [] [u2, u3]; _NO_DEFLT_ }; _NO_DEFLT_ } _N_ },
+ (>) = { _A_ 2 _U_ 11 _N_ _S_ "U(P)U(P)" {_A_ 2 _U_ 22 _N_ _N_ _F_ _IF_ARGS_ 0 2 XX 1 \ (u0 :: Float#) (u1 :: Float#) -> _#_ gtFloat# [] [u0, u1] _N_} _F_ _IF_ARGS_ 0 2 CC 3 \ (u0 :: Float) (u1 :: Float) -> case u0 of { _ALG_ F# (u2 :: Float#) -> case u1 of { _ALG_ F# (u3 :: Float#) -> _#_ gtFloat# [] [u2, u3]; _NO_DEFLT_ }; _NO_DEFLT_ } _N_ },
+ max = { _A_ 2 _U_ 11 _N_ _S_ "U(P)U(P)" {_A_ 2 _U_ 22 _N_ _N_ _N_ _N_} _N_ _N_ },
+ min = { _A_ 2 _U_ 11 _N_ _S_ "U(P)U(P)" {_A_ 2 _U_ 22 _N_ _N_ _N_ _N_} _N_ _N_ },
+ _tagCmp = { _A_ 2 _U_ 11 _N_ _S_ "U(P)U(P)" {_A_ 2 _U_ 22 _N_ _N_ _N_ _N_} _N_ _N_ } #-}
instance Real Float
{-# GHC_PRAGMA _M_ PreludeCore {-dfun-} _A_ 0 _N_ _N_ _N_ _F_ _IF_ARGS_ 0 0 X 4 _!_ _TUP_3 [{{Num Float}}, {{Enum Float}}, (Float -> Ratio Integer)] [_DFUN_ Num (Float), _DFUN_ Enum (Float), _CONSTM_ Real toRational (Float)] _N_
- toRational = _A_ 1 _U_ 1 _N_ _S_ "U(P)" {_A_ 1 _U_ 2 _N_ _N_ _N_ _N_} _N_ _N_ #-}
+ toRational = { _A_ 1 _U_ 1 _N_ _S_ "U(P)" {_A_ 1 _U_ 2 _N_ _N_ _N_ _N_} _N_ _N_ } #-}
instance RealFloat Float
{-# GHC_PRAGMA _M_ PreludeCore {-dfun-} _A_ 0 _N_ _N_ _N_ _F_ _IF_ARGS_ 0 0 X 11 _!_ _TUP_10 [{{RealFrac Float}}, {{Floating Float}}, (Float -> Integer), (Float -> Int), (Float -> (Int, Int)), (Float -> (Integer, Int)), (Integer -> Int -> Float), (Float -> Int), (Float -> Float), (Int -> Float -> Float)] [_DFUN_ RealFrac (Float), _DFUN_ Floating (Float), _CONSTM_ RealFloat floatRadix (Float), _CONSTM_ RealFloat floatDigits (Float), _CONSTM_ RealFloat floatRange (Float), _CONSTM_ RealFloat decodeFloat (Float), _CONSTM_ RealFloat encodeFloat (Float), _CONSTM_ RealFloat exponent (Float), _CONSTM_ RealFloat significand (Float), _CONSTM_ RealFloat scaleFloat (Float)] _N_
- floatRadix = _A_ 1 _U_ 0 _N_ _S_ "A" {_A_ 0 _N_ _N_ _N_ _F_ _IF_ARGS_ 0 0 X 1 _#_ int2Integer# [] [2#] _N_} _N_ _N_,
- floatDigits = _A_ 1 _U_ 0 _N_ _S_ "A" {_A_ 0 _N_ _N_ _N_ _F_ _IF_ARGS_ 0 0 X 2 _!_ I# [] [24#] _N_} _F_ _IF_ARGS_ 0 1 X 2 \ (u0 :: Float) -> _!_ I# [] [24#] _N_,
- floatRange = _A_ 1 _U_ 0 _N_ _S_ "A" {_A_ 0 _N_ _N_ _N_ _N_ _N_} _N_ _N_,
- decodeFloat = _A_ 1 _U_ 1 _N_ _S_ "U(P)" {_A_ 1 _U_ 2 _N_ _N_ _N_ _N_} _N_ _N_,
- encodeFloat = _A_ 2 _U_ 11 _N_ _S_ "U(PPP)U(P)" {_A_ 4 _U_ 2222 _N_ _N_ _F_ _IF_ARGS_ 0 4 XXXX 3 \ (u0 :: Int#) (u1 :: Int#) (u2 :: ByteArray#) (u3 :: Int#) -> case _#_ encodeFloat# [] [u0, u1, u2, u3] of { _PRIM_ (u4 :: Float#) -> _!_ F# [] [u4] } _N_} _F_ _IF_ARGS_ 0 2 CC 5 \ (u0 :: Integer) (u1 :: Int) -> case u0 of { _ALG_ J# (u2 :: Int#) (u3 :: Int#) (u4 :: ByteArray#) -> case u1 of { _ALG_ I# (u5 :: Int#) -> case _#_ encodeFloat# [] [u2, u3, u4, u5] of { _PRIM_ (u6 :: Float#) -> _!_ F# [] [u6] }; _NO_DEFLT_ }; _NO_DEFLT_ } _N_,
- exponent = _A_ 1 _U_ 2 _N_ _N_ _N_ _N_,
- significand = _A_ 1 _U_ 2 _N_ _N_ _N_ _N_,
- scaleFloat = _A_ 2 _U_ 22 _N_ _N_ _N_ _N_ #-}
+ floatRadix = { _A_ 1 _U_ 0 _N_ _S_ "A" {_A_ 0 _N_ _N_ _N_ _N_ _N_} _N_ _N_ },
+ floatDigits = { _A_ 1 _U_ 0 _N_ _S_ "A" {_A_ 0 _N_ _N_ _N_ _F_ _IF_ARGS_ 0 0 X 2 _!_ I# [] [24#] _N_} _F_ _IF_ARGS_ 0 1 X 2 \ (u0 :: Float) -> _!_ I# [] [24#] _N_ },
+ floatRange = { _A_ 1 _U_ 0 _N_ _S_ "A" {_A_ 0 _N_ _N_ _N_ _N_ _N_} _N_ _N_ },
+ decodeFloat = { _A_ 1 _U_ 1 _N_ _S_ "U(P)" {_A_ 1 _U_ 2 _N_ _N_ _N_ _N_} _N_ _N_ },
+ encodeFloat = { _A_ 2 _U_ 11 _N_ _S_ "U(PPP)U(P)" {_A_ 4 _U_ 2222 _N_ _N_ _F_ _IF_ARGS_ 0 4 XXXX 3 \ (u0 :: Int#) (u1 :: Int#) (u2 :: ByteArray#) (u3 :: Int#) -> case _#_ encodeFloat# [] [u0, u1, u2, u3] of { _PRIM_ (u4 :: Float#) -> _!_ F# [] [u4] } _N_} _F_ _IF_ARGS_ 0 2 CC 5 \ (u0 :: Integer) (u1 :: Int) -> case u0 of { _ALG_ J# (u2 :: Int#) (u3 :: Int#) (u4 :: ByteArray#) -> case u1 of { _ALG_ I# (u5 :: Int#) -> case _#_ encodeFloat# [] [u2, u3, u4, u5] of { _PRIM_ (u6 :: Float#) -> _!_ F# [] [u6] }; _NO_DEFLT_ }; _NO_DEFLT_ } _N_ },
+ exponent = { _A_ 1 _U_ 1 _N_ _S_ "U(P)" {_A_ 1 _U_ 2 _N_ _N_ _N_ _N_} _N_ _N_ },
+ significand = { _A_ 1 _U_ 1 _N_ _S_ "U(P)" {_A_ 1 _U_ 2 _N_ _N_ _N_ _N_} _N_ _N_ },
+ scaleFloat = { _A_ 2 _U_ 11 _N_ _S_ "U(P)U(P)" {_A_ 2 _U_ 22 _N_ _N_ _N_ _N_} _N_ _N_ } #-}
instance RealFrac Float
{-# GHC_PRAGMA _M_ PreludeCore {-dfun-} _A_ 0 _N_ _N_ _N_ _F_ _IF_ARGS_ 0 0 X 8 _!_ _TUP_7 [{{Real Float}}, {{Fractional Float}}, _forall_ a$z1 =>{{Integral a$z1}} -> (Float -> (a$z1, Float)), _forall_ a$z1 =>{{Integral a$z1}} -> (Float -> a$z1), _forall_ a$z1 =>{{Integral a$z1}} -> (Float -> a$z1), _forall_ a$z1 =>{{Integral a$z1}} -> (Float -> a$z1), _forall_ a$z1 =>{{Integral a$z1}} -> (Float -> a$z1)] [_DFUN_ Real (Float), _DFUN_ Fractional (Float), _CONSTM_ RealFrac properFraction (Float), _CONSTM_ RealFrac truncate (Float), _CONSTM_ RealFrac round (Float), _CONSTM_ RealFrac ceiling (Float), _CONSTM_ RealFrac floor (Float)] _N_
- properFraction = _A_ 1 _U_ 22 _N_ _N_ _N_ _N_,
- truncate = _A_ 1 _U_ 22 _N_ _N_ _N_ _N_,
- round = _A_ 1 _U_ 22 _N_ _N_ _N_ _N_,
- ceiling = _A_ 1 _U_ 22 _N_ _N_ _N_ _N_,
- floor = _A_ 1 _U_ 22 _N_ _N_ _N_ _N_ #-}
+ properFraction = { _A_ 1 _U_ 11 _N_ _N_ _N_ _SPECIALISE_ [ Int ] 1 { _A_ 1 _U_ 1 _N_ _S_ "U(P)" {_A_ 1 _U_ 2 _N_ _N_ _N_ _N_} _N_ _N_ }, [ Integer ] 1 { _A_ 1 _U_ 1 _N_ _S_ "U(P)" {_A_ 1 _U_ 2 _N_ _N_ _N_ _N_} _N_ _N_ } },
+ truncate = { _A_ 1 _U_ 11 _N_ _N_ _N_ _SPECIALISE_ [ Int ] 1 { _A_ 1 _U_ 1 _N_ _S_ "U(P)" {_A_ 1 _U_ 2 _N_ _N_ _F_ _IF_ARGS_ 0 1 X 4 \ (u0 :: Float#) -> case _APP_ _WRKR_ _SPEC_ _CONSTM_ RealFrac properFraction (Float) [ (Int) ] [ u0 ] of { _ALG_ _TUP_2 (u1 :: Int) (u2 :: Float) -> u1; _NO_DEFLT_ } _N_} _F_ _IF_ARGS_ 0 1 X 4 \ (u0 :: Float) -> case _APP_ _SPEC_ _CONSTM_ RealFrac properFraction (Float) [ (Int) ] [ u0 ] of { _ALG_ _TUP_2 (u1 :: Int) (u2 :: Float) -> u1; _NO_DEFLT_ } _N_ }, [ Integer ] 1 { _A_ 1 _U_ 1 _N_ _S_ "U(P)" {_A_ 1 _U_ 2 _N_ _N_ _F_ _IF_ARGS_ 0 1 X 4 \ (u0 :: Float#) -> case _APP_ _WRKR_ _SPEC_ _CONSTM_ RealFrac properFraction (Float) [ (Integer) ] [ u0 ] of { _ALG_ _TUP_2 (u1 :: Integer) (u2 :: Float) -> u1; _NO_DEFLT_ } _N_} _F_ _IF_ARGS_ 0 1 X 4 \ (u0 :: Float) -> case _APP_ _SPEC_ _CONSTM_ RealFrac properFraction (Float) [ (Integer) ] [ u0 ] of { _ALG_ _TUP_2 (u1 :: Integer) (u2 :: Float) -> u1; _NO_DEFLT_ } _N_ } },
+ round = { _A_ 1 _U_ 21 _N_ _N_ _N_ _SPECIALISE_ [ Int ] 1 { _A_ 1 _U_ 1 _N_ _S_ "U(P)" {_A_ 1 _U_ 2 _N_ _N_ _N_ _N_} _N_ _N_ }, [ Integer ] 1 { _A_ 1 _U_ 1 _N_ _S_ "U(P)" {_A_ 1 _U_ 2 _N_ _N_ _N_ _N_} _N_ _N_ } },
+ ceiling = { _A_ 1 _U_ 21 _N_ _N_ _N_ _SPECIALISE_ [ Int ] 1 { _A_ 1 _U_ 1 _N_ _S_ "U(P)" {_A_ 1 _U_ 2 _N_ _N_ _N_ _N_} _N_ _N_ }, [ Integer ] 1 { _A_ 1 _U_ 1 _N_ _S_ "U(P)" {_A_ 1 _U_ 2 _N_ _N_ _N_ _N_} _N_ _N_ } },
+ floor = { _A_ 1 _U_ 21 _N_ _N_ _N_ _SPECIALISE_ [ Int ] 1 { _A_ 1 _U_ 1 _N_ _S_ "U(P)" {_A_ 1 _U_ 2 _N_ _N_ _N_ _N_} _N_ _N_ }, [ Integer ] 1 { _A_ 1 _U_ 1 _N_ _S_ "U(P)" {_A_ 1 _U_ 2 _N_ _N_ _N_ _N_} _N_ _N_ } } #-}
instance Text Float
{-# GHC_PRAGMA _M_ PreludeCore {-dfun-} _A_ 0 _N_ _N_ _N_ _F_ _IF_ARGS_ 0 0 X 5 _!_ _TUP_4 [(Int -> [Char] -> [(Float, [Char])]), (Int -> Float -> [Char] -> [Char]), ([Char] -> [([Float], [Char])]), ([Float] -> [Char] -> [Char])] [_CONSTM_ Text readsPrec (Float), _CONSTM_ Text showsPrec (Float), _CONSTM_ Text readList (Float), _CONSTM_ Text showList (Float)] _N_
- readsPrec = _A_ 2 _U_ 02 _N_ _S_ "AL" {_A_ 1 _U_ 2 _N_ _N_ _N_ _N_} _N_ _N_,
- showsPrec = _A_ 1 _U_ 222 _N_ _N_ _N_ _N_,
- readList = _A_ 0 _U_ 2 _N_ _N_ _N_ _N_,
- showList = _A_ 0 _U_ 12 _N_ _N_ _N_ _N_ #-}
+ readsPrec = { _A_ 2 _U_ 02 _N_ _S_ "AL" {_A_ 1 _U_ 2 _N_ _N_ _N_ _N_} _N_ _N_ },
+ showsPrec = { _A_ 1 _U_ 222 _N_ _N_ _N_ _N_ },
+ readList = { _A_ 0 _U_ 2 _N_ _N_ _N_ _N_ },
+ showList = { _A_ 0 _U_ 12 _N_ _N_ _N_ _N_ } #-}
instance _CCallable Float
{-# GHC_PRAGMA _M_ PreludeCore {-dfun-} _A_ 0 _N_ _N_ _N_ _F_ _IF_ARGS_ 0 0 X 1 _!_ _TUP_0 [] [] _N_ #-}
instance _CReturnable Float
-{-# GHC_PRAGMA INTERFACE VERSION 5 #-}
+{-# GHC_PRAGMA INTERFACE VERSION 6 #-}
interface PreludeCore where
import PreludeBuiltin(Float(..))
instance Enum Float
{-# GHC_PRAGMA _M_ PreludeCore {-dfun-} _A_ 0 _N_ _N_ _N_ _F_ _IF_ARGS_ 0 0 X 6 _!_ _TUP_5 [{{Ord Float}}, (Float -> [Float]), (Float -> Float -> [Float]), (Float -> Float -> [Float]), (Float -> Float -> Float -> [Float])] [_DFUN_ Ord (Float), _CONSTM_ Enum enumFrom (Float), _CONSTM_ Enum enumFromThen (Float), _CONSTM_ Enum enumFromTo (Float), _CONSTM_ Enum enumFromThenTo (Float)] _N_
- enumFrom = _A_ 1 _U_ 2 _N_ _N_ _N_ _N_,
- enumFromThen = _A_ 2 _U_ 21 _N_ _N_ _N_ _N_,
- enumFromTo = _A_ 2 _U_ 22 _N_ _N_ _N_ _N_,
- enumFromThenTo = _A_ 3 _U_ 222 _N_ _N_ _N_ _N_ #-}
+ enumFrom = { _A_ 1 _U_ 2 _N_ _N_ _N_ _N_ },
+ enumFromThen = { _A_ 2 _U_ 21 _N_ _N_ _N_ _N_ },
+ enumFromTo = { _A_ 2 _U_ 22 _N_ _N_ _N_ _N_ },
+ enumFromThenTo = { _A_ 3 _U_ 222 _N_ _N_ _N_ _N_ } #-}
instance Eq Float
{-# GHC_PRAGMA _M_ PreludeCore {-dfun-} _A_ 0 _N_ _N_ _N_ _F_ _IF_ARGS_ 0 0 X 3 _!_ _TUP_2 [(Float -> Float -> Bool), (Float -> Float -> Bool)] [_CONSTM_ Eq (==) (Float), _CONSTM_ Eq (/=) (Float)] _N_
- (==) = _A_ 2 _U_ 11 _N_ _S_ "U(P)U(P)" {_A_ 2 _U_ 22 _N_ _N_ _F_ _IF_ARGS_ 0 2 XX 1 \ (u0 :: Float#) (u1 :: Float#) -> _#_ eqFloat# [] [u0, u1] _N_} _F_ _IF_ARGS_ 0 2 CC 3 \ (u0 :: Float) (u1 :: Float) -> case u0 of { _ALG_ F# (u2 :: Float#) -> case u1 of { _ALG_ F# (u3 :: Float#) -> _#_ eqFloat# [] [u2, u3]; _NO_DEFLT_ }; _NO_DEFLT_ } _N_,
- (/=) = _A_ 2 _U_ 11 _N_ _S_ "U(P)U(P)" {_A_ 2 _U_ 22 _N_ _N_ _F_ _IF_ARGS_ 0 2 XX 1 \ (u0 :: Float#) (u1 :: Float#) -> _#_ neFloat# [] [u0, u1] _N_} _F_ _IF_ARGS_ 0 2 CC 3 \ (u0 :: Float) (u1 :: Float) -> case u0 of { _ALG_ F# (u2 :: Float#) -> case u1 of { _ALG_ F# (u3 :: Float#) -> _#_ neFloat# [] [u2, u3]; _NO_DEFLT_ }; _NO_DEFLT_ } _N_ #-}
+ (==) = { _A_ 2 _U_ 11 _N_ _S_ "U(P)U(P)" {_A_ 2 _U_ 22 _N_ _N_ _F_ _IF_ARGS_ 0 2 XX 1 \ (u0 :: Float#) (u1 :: Float#) -> _#_ eqFloat# [] [u0, u1] _N_} _F_ _IF_ARGS_ 0 2 CC 3 \ (u0 :: Float) (u1 :: Float) -> case u0 of { _ALG_ F# (u2 :: Float#) -> case u1 of { _ALG_ F# (u3 :: Float#) -> _#_ eqFloat# [] [u2, u3]; _NO_DEFLT_ }; _NO_DEFLT_ } _N_ },
+ (/=) = { _A_ 2 _U_ 11 _N_ _S_ "U(P)U(P)" {_A_ 2 _U_ 22 _N_ _N_ _F_ _IF_ARGS_ 0 2 XX 1 \ (u0 :: Float#) (u1 :: Float#) -> _#_ neFloat# [] [u0, u1] _N_} _F_ _IF_ARGS_ 0 2 CC 3 \ (u0 :: Float) (u1 :: Float) -> case u0 of { _ALG_ F# (u2 :: Float#) -> case u1 of { _ALG_ F# (u3 :: Float#) -> _#_ neFloat# [] [u2, u3]; _NO_DEFLT_ }; _NO_DEFLT_ } _N_ } #-}
instance Floating Float
{-# GHC_PRAGMA _M_ PreludeCore {-dfun-} _A_ 0 _N_ _N_ _N_ _F_ _IF_ARGS_ 0 0 X 20 _!_ _TUP_19 [{{Fractional Float}}, Float, (Float -> Float), (Float -> Float), (Float -> Float), (Float -> Float -> Float), (Float -> Float -> Float), (Float -> Float), (Float -> Float), (Float -> Float), (Float -> Float), (Float -> Float), (Float -> Float), (Float -> Float), (Float -> Float), (Float -> Float), (Float -> Float), (Float -> Float), (Float -> Float)] [_DFUN_ Fractional (Float), _CONSTM_ Floating pi (Float), _CONSTM_ Floating exp (Float), _CONSTM_ Floating log (Float), _CONSTM_ Floating sqrt (Float), _CONSTM_ Floating (**) (Float), _CONSTM_ Floating logBase (Float), _CONSTM_ Floating sin (Float), _CONSTM_ Floating cos (Float), _CONSTM_ Floating tan (Float), _CONSTM_ Floating asin (Float), _CONSTM_ Floating acos (Float), _CONSTM_ Floating atan (Float), _CONSTM_ Floating sinh (Float), _CONSTM_ Floating cosh (Float), _CONSTM_ Floating tanh (Float), _CONSTM_ Floating asinh (Float), _CONSTM_ Floating acosh (Float), _CONSTM_ Floating atanh (Float)] _N_
- pi = _A_ 0 _N_ _N_ _N_ _F_ _IF_ARGS_ 0 0 X 2 _!_ F# [] [3.1415926535897931#] _N_,
- exp = _A_ 1 _U_ 1 _N_ _S_ "U(P)" {_A_ 1 _U_ 2 _N_ _N_ _F_ _IF_ARGS_ 0 1 X 3 \ (u0 :: Float#) -> case _#_ expFloat# [] [u0] of { _PRIM_ (u1 :: Float#) -> _!_ F# [] [u1] } _N_} _F_ _IF_ARGS_ 0 1 C 4 \ (u0 :: Float) -> case u0 of { _ALG_ F# (u1 :: Float#) -> case _#_ expFloat# [] [u1] of { _PRIM_ (u2 :: Float#) -> _!_ F# [] [u2] }; _NO_DEFLT_ } _N_,
- log = _A_ 1 _U_ 1 _N_ _S_ "U(P)" {_A_ 1 _U_ 2 _N_ _N_ _F_ _IF_ARGS_ 0 1 X 3 \ (u0 :: Float#) -> case _#_ logFloat# [] [u0] of { _PRIM_ (u1 :: Float#) -> _!_ F# [] [u1] } _N_} _F_ _IF_ARGS_ 0 1 C 4 \ (u0 :: Float) -> case u0 of { _ALG_ F# (u1 :: Float#) -> case _#_ logFloat# [] [u1] of { _PRIM_ (u2 :: Float#) -> _!_ F# [] [u2] }; _NO_DEFLT_ } _N_,
- sqrt = _A_ 1 _U_ 1 _N_ _S_ "U(P)" {_A_ 1 _U_ 2 _N_ _N_ _F_ _IF_ARGS_ 0 1 X 3 \ (u0 :: Float#) -> case _#_ sqrtFloat# [] [u0] of { _PRIM_ (u1 :: Float#) -> _!_ F# [] [u1] } _N_} _F_ _IF_ARGS_ 0 1 C 4 \ (u0 :: Float) -> case u0 of { _ALG_ F# (u1 :: Float#) -> case _#_ sqrtFloat# [] [u1] of { _PRIM_ (u2 :: Float#) -> _!_ F# [] [u2] }; _NO_DEFLT_ } _N_,
- (**) = _A_ 2 _U_ 11 _N_ _S_ "U(P)U(P)" {_A_ 2 _U_ 22 _N_ _N_ _F_ _IF_ARGS_ 0 2 XX 3 \ (u0 :: Float#) (u1 :: Float#) -> case _#_ powerFloat# [] [u0, u1] of { _PRIM_ (u2 :: Float#) -> _!_ F# [] [u2] } _N_} _F_ _IF_ARGS_ 0 2 CC 5 \ (u0 :: Float) (u1 :: Float) -> case u0 of { _ALG_ F# (u2 :: Float#) -> case u1 of { _ALG_ F# (u3 :: Float#) -> case _#_ powerFloat# [] [u2, u3] of { _PRIM_ (u4 :: Float#) -> _!_ F# [] [u4] }; _NO_DEFLT_ }; _NO_DEFLT_ } _N_,
- logBase = _A_ 2 _U_ 22 _N_ _N_ _N_ _N_,
- sin = _A_ 1 _U_ 1 _N_ _S_ "U(P)" {_A_ 1 _U_ 2 _N_ _N_ _F_ _IF_ARGS_ 0 1 X 3 \ (u0 :: Float#) -> case _#_ sinFloat# [] [u0] of { _PRIM_ (u1 :: Float#) -> _!_ F# [] [u1] } _N_} _F_ _IF_ARGS_ 0 1 C 4 \ (u0 :: Float) -> case u0 of { _ALG_ F# (u1 :: Float#) -> case _#_ sinFloat# [] [u1] of { _PRIM_ (u2 :: Float#) -> _!_ F# [] [u2] }; _NO_DEFLT_ } _N_,
- cos = _A_ 1 _U_ 1 _N_ _S_ "U(P)" {_A_ 1 _U_ 2 _N_ _N_ _F_ _IF_ARGS_ 0 1 X 3 \ (u0 :: Float#) -> case _#_ cosFloat# [] [u0] of { _PRIM_ (u1 :: Float#) -> _!_ F# [] [u1] } _N_} _F_ _IF_ARGS_ 0 1 C 4 \ (u0 :: Float) -> case u0 of { _ALG_ F# (u1 :: Float#) -> case _#_ cosFloat# [] [u1] of { _PRIM_ (u2 :: Float#) -> _!_ F# [] [u2] }; _NO_DEFLT_ } _N_,
- tan = _A_ 1 _U_ 1 _N_ _S_ "U(P)" {_A_ 1 _U_ 2 _N_ _N_ _F_ _IF_ARGS_ 0 1 X 3 \ (u0 :: Float#) -> case _#_ tanFloat# [] [u0] of { _PRIM_ (u1 :: Float#) -> _!_ F# [] [u1] } _N_} _F_ _IF_ARGS_ 0 1 C 4 \ (u0 :: Float) -> case u0 of { _ALG_ F# (u1 :: Float#) -> case _#_ tanFloat# [] [u1] of { _PRIM_ (u2 :: Float#) -> _!_ F# [] [u2] }; _NO_DEFLT_ } _N_,
- asin = _A_ 1 _U_ 1 _N_ _S_ "U(P)" {_A_ 1 _U_ 2 _N_ _N_ _F_ _IF_ARGS_ 0 1 X 3 \ (u0 :: Float#) -> case _#_ asinFloat# [] [u0] of { _PRIM_ (u1 :: Float#) -> _!_ F# [] [u1] } _N_} _F_ _IF_ARGS_ 0 1 C 4 \ (u0 :: Float) -> case u0 of { _ALG_ F# (u1 :: Float#) -> case _#_ asinFloat# [] [u1] of { _PRIM_ (u2 :: Float#) -> _!_ F# [] [u2] }; _NO_DEFLT_ } _N_,
- acos = _A_ 1 _U_ 1 _N_ _S_ "U(P)" {_A_ 1 _U_ 2 _N_ _N_ _F_ _IF_ARGS_ 0 1 X 3 \ (u0 :: Float#) -> case _#_ acosFloat# [] [u0] of { _PRIM_ (u1 :: Float#) -> _!_ F# [] [u1] } _N_} _F_ _IF_ARGS_ 0 1 C 4 \ (u0 :: Float) -> case u0 of { _ALG_ F# (u1 :: Float#) -> case _#_ acosFloat# [] [u1] of { _PRIM_ (u2 :: Float#) -> _!_ F# [] [u2] }; _NO_DEFLT_ } _N_,
- atan = _A_ 1 _U_ 1 _N_ _S_ "U(P)" {_A_ 1 _U_ 2 _N_ _N_ _F_ _IF_ARGS_ 0 1 X 3 \ (u0 :: Float#) -> case _#_ atanFloat# [] [u0] of { _PRIM_ (u1 :: Float#) -> _!_ F# [] [u1] } _N_} _F_ _IF_ARGS_ 0 1 C 4 \ (u0 :: Float) -> case u0 of { _ALG_ F# (u1 :: Float#) -> case _#_ atanFloat# [] [u1] of { _PRIM_ (u2 :: Float#) -> _!_ F# [] [u2] }; _NO_DEFLT_ } _N_,
- sinh = _A_ 1 _U_ 1 _N_ _S_ "U(P)" {_A_ 1 _U_ 2 _N_ _N_ _F_ _IF_ARGS_ 0 1 X 3 \ (u0 :: Float#) -> case _#_ sinhFloat# [] [u0] of { _PRIM_ (u1 :: Float#) -> _!_ F# [] [u1] } _N_} _F_ _IF_ARGS_ 0 1 C 4 \ (u0 :: Float) -> case u0 of { _ALG_ F# (u1 :: Float#) -> case _#_ sinhFloat# [] [u1] of { _PRIM_ (u2 :: Float#) -> _!_ F# [] [u2] }; _NO_DEFLT_ } _N_,
- cosh = _A_ 1 _U_ 1 _N_ _S_ "U(P)" {_A_ 1 _U_ 2 _N_ _N_ _F_ _IF_ARGS_ 0 1 X 3 \ (u0 :: Float#) -> case _#_ coshFloat# [] [u0] of { _PRIM_ (u1 :: Float#) -> _!_ F# [] [u1] } _N_} _F_ _IF_ARGS_ 0 1 C 4 \ (u0 :: Float) -> case u0 of { _ALG_ F# (u1 :: Float#) -> case _#_ coshFloat# [] [u1] of { _PRIM_ (u2 :: Float#) -> _!_ F# [] [u2] }; _NO_DEFLT_ } _N_,
- tanh = _A_ 1 _U_ 1 _N_ _S_ "U(P)" {_A_ 1 _U_ 2 _N_ _N_ _F_ _IF_ARGS_ 0 1 X 3 \ (u0 :: Float#) -> case _#_ tanhFloat# [] [u0] of { _PRIM_ (u1 :: Float#) -> _!_ F# [] [u1] } _N_} _F_ _IF_ARGS_ 0 1 C 4 \ (u0 :: Float) -> case u0 of { _ALG_ F# (u1 :: Float#) -> case _#_ tanhFloat# [] [u1] of { _PRIM_ (u2 :: Float#) -> _!_ F# [] [u2] }; _NO_DEFLT_ } _N_,
- asinh = _A_ 1 _U_ 1 _N_ _S_ "U(P)" {_A_ 1 _U_ 2 _N_ _N_ _N_ _N_} _N_ _N_,
- acosh = _A_ 1 _U_ 1 _N_ _S_ "U(P)" {_A_ 1 _U_ 2 _N_ _N_ _N_ _N_} _N_ _N_,
- atanh = _A_ 1 _U_ 1 _N_ _S_ "U(P)" {_A_ 1 _U_ 2 _N_ _N_ _N_ _N_} _N_ _N_ #-}
+ pi = { _A_ 0 _N_ _N_ _N_ _F_ _IF_ARGS_ 0 0 X 2 _!_ F# [] [3.1415926535897931#] _N_ },
+ exp = { _A_ 1 _U_ 1 _N_ _S_ "U(P)" {_A_ 1 _U_ 2 _N_ _N_ _F_ _IF_ARGS_ 0 1 X 3 \ (u0 :: Float#) -> case _#_ expFloat# [] [u0] of { _PRIM_ (u1 :: Float#) -> _!_ F# [] [u1] } _N_} _F_ _IF_ARGS_ 0 1 C 4 \ (u0 :: Float) -> case u0 of { _ALG_ F# (u1 :: Float#) -> case _#_ expFloat# [] [u1] of { _PRIM_ (u2 :: Float#) -> _!_ F# [] [u2] }; _NO_DEFLT_ } _N_ },
+ log = { _A_ 1 _U_ 1 _N_ _S_ "U(P)" {_A_ 1 _U_ 2 _N_ _N_ _F_ _IF_ARGS_ 0 1 X 3 \ (u0 :: Float#) -> case _#_ logFloat# [] [u0] of { _PRIM_ (u1 :: Float#) -> _!_ F# [] [u1] } _N_} _F_ _IF_ARGS_ 0 1 C 4 \ (u0 :: Float) -> case u0 of { _ALG_ F# (u1 :: Float#) -> case _#_ logFloat# [] [u1] of { _PRIM_ (u2 :: Float#) -> _!_ F# [] [u2] }; _NO_DEFLT_ } _N_ },
+ sqrt = { _A_ 1 _U_ 1 _N_ _S_ "U(P)" {_A_ 1 _U_ 2 _N_ _N_ _F_ _IF_ARGS_ 0 1 X 3 \ (u0 :: Float#) -> case _#_ sqrtFloat# [] [u0] of { _PRIM_ (u1 :: Float#) -> _!_ F# [] [u1] } _N_} _F_ _IF_ARGS_ 0 1 C 4 \ (u0 :: Float) -> case u0 of { _ALG_ F# (u1 :: Float#) -> case _#_ sqrtFloat# [] [u1] of { _PRIM_ (u2 :: Float#) -> _!_ F# [] [u2] }; _NO_DEFLT_ } _N_ },
+ (**) = { _A_ 2 _U_ 11 _N_ _S_ "U(P)U(P)" {_A_ 2 _U_ 22 _N_ _N_ _F_ _IF_ARGS_ 0 2 XX 3 \ (u0 :: Float#) (u1 :: Float#) -> case _#_ powerFloat# [] [u0, u1] of { _PRIM_ (u2 :: Float#) -> _!_ F# [] [u2] } _N_} _F_ _IF_ARGS_ 0 2 CC 5 \ (u0 :: Float) (u1 :: Float) -> case u0 of { _ALG_ F# (u2 :: Float#) -> case u1 of { _ALG_ F# (u3 :: Float#) -> case _#_ powerFloat# [] [u2, u3] of { _PRIM_ (u4 :: Float#) -> _!_ F# [] [u4] }; _NO_DEFLT_ }; _NO_DEFLT_ } _N_ },
+ logBase = { _A_ 2 _U_ 11 _N_ _S_ "U(P)U(P)" {_A_ 2 _U_ 22 _N_ _N_ _F_ _IF_ARGS_ 0 2 XX 5 \ (u0 :: Float#) (u1 :: Float#) -> case _#_ logFloat# [] [u1] of { _PRIM_ (u2 :: Float#) -> case _#_ logFloat# [] [u0] of { _PRIM_ (u3 :: Float#) -> case _#_ divideFloat# [] [u2, u3] of { _PRIM_ (u4 :: Float#) -> _!_ F# [] [u4] } } } _N_} _F_ _IF_ARGS_ 0 2 CC 7 \ (u0 :: Float) (u1 :: Float) -> case u1 of { _ALG_ F# (u2 :: Float#) -> case _#_ logFloat# [] [u2] of { _PRIM_ (u3 :: Float#) -> case u0 of { _ALG_ F# (u4 :: Float#) -> case _#_ logFloat# [] [u4] of { _PRIM_ (u5 :: Float#) -> case _#_ divideFloat# [] [u3, u5] of { _PRIM_ (u6 :: Float#) -> _!_ F# [] [u6] } }; _NO_DEFLT_ } }; _NO_DEFLT_ } _N_ },
+ sin = { _A_ 1 _U_ 1 _N_ _S_ "U(P)" {_A_ 1 _U_ 2 _N_ _N_ _F_ _IF_ARGS_ 0 1 X 3 \ (u0 :: Float#) -> case _#_ sinFloat# [] [u0] of { _PRIM_ (u1 :: Float#) -> _!_ F# [] [u1] } _N_} _F_ _IF_ARGS_ 0 1 C 4 \ (u0 :: Float) -> case u0 of { _ALG_ F# (u1 :: Float#) -> case _#_ sinFloat# [] [u1] of { _PRIM_ (u2 :: Float#) -> _!_ F# [] [u2] }; _NO_DEFLT_ } _N_ },
+ cos = { _A_ 1 _U_ 1 _N_ _S_ "U(P)" {_A_ 1 _U_ 2 _N_ _N_ _F_ _IF_ARGS_ 0 1 X 3 \ (u0 :: Float#) -> case _#_ cosFloat# [] [u0] of { _PRIM_ (u1 :: Float#) -> _!_ F# [] [u1] } _N_} _F_ _IF_ARGS_ 0 1 C 4 \ (u0 :: Float) -> case u0 of { _ALG_ F# (u1 :: Float#) -> case _#_ cosFloat# [] [u1] of { _PRIM_ (u2 :: Float#) -> _!_ F# [] [u2] }; _NO_DEFLT_ } _N_ },
+ tan = { _A_ 1 _U_ 1 _N_ _S_ "U(P)" {_A_ 1 _U_ 2 _N_ _N_ _F_ _IF_ARGS_ 0 1 X 3 \ (u0 :: Float#) -> case _#_ tanFloat# [] [u0] of { _PRIM_ (u1 :: Float#) -> _!_ F# [] [u1] } _N_} _F_ _IF_ARGS_ 0 1 C 4 \ (u0 :: Float) -> case u0 of { _ALG_ F# (u1 :: Float#) -> case _#_ tanFloat# [] [u1] of { _PRIM_ (u2 :: Float#) -> _!_ F# [] [u2] }; _NO_DEFLT_ } _N_ },
+ asin = { _A_ 1 _U_ 1 _N_ _S_ "U(P)" {_A_ 1 _U_ 2 _N_ _N_ _F_ _IF_ARGS_ 0 1 X 3 \ (u0 :: Float#) -> case _#_ asinFloat# [] [u0] of { _PRIM_ (u1 :: Float#) -> _!_ F# [] [u1] } _N_} _F_ _IF_ARGS_ 0 1 C 4 \ (u0 :: Float) -> case u0 of { _ALG_ F# (u1 :: Float#) -> case _#_ asinFloat# [] [u1] of { _PRIM_ (u2 :: Float#) -> _!_ F# [] [u2] }; _NO_DEFLT_ } _N_ },
+ acos = { _A_ 1 _U_ 1 _N_ _S_ "U(P)" {_A_ 1 _U_ 2 _N_ _N_ _F_ _IF_ARGS_ 0 1 X 3 \ (u0 :: Float#) -> case _#_ acosFloat# [] [u0] of { _PRIM_ (u1 :: Float#) -> _!_ F# [] [u1] } _N_} _F_ _IF_ARGS_ 0 1 C 4 \ (u0 :: Float) -> case u0 of { _ALG_ F# (u1 :: Float#) -> case _#_ acosFloat# [] [u1] of { _PRIM_ (u2 :: Float#) -> _!_ F# [] [u2] }; _NO_DEFLT_ } _N_ },
+ atan = { _A_ 1 _U_ 1 _N_ _S_ "U(P)" {_A_ 1 _U_ 2 _N_ _N_ _F_ _IF_ARGS_ 0 1 X 3 \ (u0 :: Float#) -> case _#_ atanFloat# [] [u0] of { _PRIM_ (u1 :: Float#) -> _!_ F# [] [u1] } _N_} _F_ _IF_ARGS_ 0 1 C 4 \ (u0 :: Float) -> case u0 of { _ALG_ F# (u1 :: Float#) -> case _#_ atanFloat# [] [u1] of { _PRIM_ (u2 :: Float#) -> _!_ F# [] [u2] }; _NO_DEFLT_ } _N_ },
+ sinh = { _A_ 1 _U_ 1 _N_ _S_ "U(P)" {_A_ 1 _U_ 2 _N_ _N_ _F_ _IF_ARGS_ 0 1 X 3 \ (u0 :: Float#) -> case _#_ sinhFloat# [] [u0] of { _PRIM_ (u1 :: Float#) -> _!_ F# [] [u1] } _N_} _F_ _IF_ARGS_ 0 1 C 4 \ (u0 :: Float) -> case u0 of { _ALG_ F# (u1 :: Float#) -> case _#_ sinhFloat# [] [u1] of { _PRIM_ (u2 :: Float#) -> _!_ F# [] [u2] }; _NO_DEFLT_ } _N_ },
+ cosh = { _A_ 1 _U_ 1 _N_ _S_ "U(P)" {_A_ 1 _U_ 2 _N_ _N_ _F_ _IF_ARGS_ 0 1 X 3 \ (u0 :: Float#) -> case _#_ coshFloat# [] [u0] of { _PRIM_ (u1 :: Float#) -> _!_ F# [] [u1] } _N_} _F_ _IF_ARGS_ 0 1 C 4 \ (u0 :: Float) -> case u0 of { _ALG_ F# (u1 :: Float#) -> case _#_ coshFloat# [] [u1] of { _PRIM_ (u2 :: Float#) -> _!_ F# [] [u2] }; _NO_DEFLT_ } _N_ },
+ tanh = { _A_ 1 _U_ 1 _N_ _S_ "U(P)" {_A_ 1 _U_ 2 _N_ _N_ _F_ _IF_ARGS_ 0 1 X 3 \ (u0 :: Float#) -> case _#_ tanhFloat# [] [u0] of { _PRIM_ (u1 :: Float#) -> _!_ F# [] [u1] } _N_} _F_ _IF_ARGS_ 0 1 C 4 \ (u0 :: Float) -> case u0 of { _ALG_ F# (u1 :: Float#) -> case _#_ tanhFloat# [] [u1] of { _PRIM_ (u2 :: Float#) -> _!_ F# [] [u2] }; _NO_DEFLT_ } _N_ },
+ asinh = { _A_ 1 _U_ 1 _N_ _S_ "U(P)" {_A_ 1 _U_ 2 _N_ _N_ _N_ _N_} _N_ _N_ },
+ acosh = { _A_ 1 _U_ 1 _N_ _S_ "U(P)" {_A_ 1 _U_ 2 _N_ _N_ _N_ _N_} _N_ _N_ },
+ atanh = { _A_ 1 _U_ 1 _N_ _S_ "U(P)" {_A_ 1 _U_ 2 _N_ _N_ _N_ _N_} _N_ _N_ } #-}
instance Fractional Float
{-# GHC_PRAGMA _M_ PreludeCore {-dfun-} _A_ 0 _N_ _N_ _N_ _F_ _IF_ARGS_ 0 0 X 5 _!_ _TUP_4 [{{Num Float}}, (Float -> Float -> Float), (Float -> Float), (Ratio Integer -> Float)] [_DFUN_ Num (Float), _CONSTM_ Fractional (/) (Float), _CONSTM_ Fractional recip (Float), _CONSTM_ Fractional fromRational (Float)] _N_
- (/) = _A_ 2 _U_ 11 _N_ _S_ "U(P)U(P)" {_A_ 2 _U_ 22 _N_ _N_ _F_ _IF_ARGS_ 0 2 XX 3 \ (u0 :: Float#) (u1 :: Float#) -> case _#_ divideFloat# [] [u0, u1] of { _PRIM_ (u2 :: Float#) -> _!_ F# [] [u2] } _N_} _F_ _IF_ARGS_ 0 2 CC 5 \ (u0 :: Float) (u1 :: Float) -> case u0 of { _ALG_ F# (u2 :: Float#) -> case u1 of { _ALG_ F# (u3 :: Float#) -> case _#_ divideFloat# [] [u2, u3] of { _PRIM_ (u4 :: Float#) -> _!_ F# [] [u4] }; _NO_DEFLT_ }; _NO_DEFLT_ } _N_,
- recip = _A_ 0 _U_ 2 _N_ _N_ _N_ _N_,
- fromRational = _A_ 0 _U_ 2 _N_ _N_ _N_ _N_ #-}
+ (/) = { _A_ 2 _U_ 11 _N_ _S_ "U(P)U(P)" {_A_ 2 _U_ 22 _N_ _N_ _F_ _IF_ARGS_ 0 2 XX 3 \ (u0 :: Float#) (u1 :: Float#) -> case _#_ divideFloat# [] [u0, u1] of { _PRIM_ (u2 :: Float#) -> _!_ F# [] [u2] } _N_} _F_ _IF_ARGS_ 0 2 CC 5 \ (u0 :: Float) (u1 :: Float) -> case u0 of { _ALG_ F# (u2 :: Float#) -> case u1 of { _ALG_ F# (u3 :: Float#) -> case _#_ divideFloat# [] [u2, u3] of { _PRIM_ (u4 :: Float#) -> _!_ F# [] [u4] }; _NO_DEFLT_ }; _NO_DEFLT_ } _N_ },
+ recip = { _A_ 1 _U_ 1 _N_ _S_ "U(P)" {_A_ 1 _U_ 2 _N_ _N_ _F_ _IF_ARGS_ 0 1 X 3 \ (u0 :: Float#) -> case _#_ divideFloat# [] [1.0000000000000000#, u0] of { _PRIM_ (u1 :: Float#) -> _!_ F# [] [u1] } _N_} _F_ _IF_ARGS_ 0 1 C 4 \ (u0 :: Float) -> case u0 of { _ALG_ F# (u1 :: Float#) -> case _#_ divideFloat# [] [1.0000000000000000#, u1] of { _PRIM_ (u2 :: Float#) -> _!_ F# [] [u2] }; _NO_DEFLT_ } _N_ },
+ fromRational = { _A_ 1 _U_ 2 _N_ _N_ _N_ _N_ } #-}
instance Num Float
{-# GHC_PRAGMA _M_ PreludeCore {-dfun-} _A_ 0 _N_ _N_ _N_ _F_ _IF_ARGS_ 0 0 X 11 _!_ _TUP_10 [{{Eq Float}}, {{Text Float}}, (Float -> Float -> Float), (Float -> Float -> Float), (Float -> Float -> Float), (Float -> Float), (Float -> Float), (Float -> Float), (Integer -> Float), (Int -> Float)] [_DFUN_ Eq (Float), _DFUN_ Text (Float), _CONSTM_ Num (+) (Float), _CONSTM_ Num (-) (Float), _CONSTM_ Num (*) (Float), _CONSTM_ Num negate (Float), _CONSTM_ Num abs (Float), _CONSTM_ Num signum (Float), _CONSTM_ Num fromInteger (Float), _CONSTM_ Num fromInt (Float)] _N_
- (+) = _A_ 2 _U_ 11 _N_ _S_ "U(P)U(P)" {_A_ 2 _U_ 22 _N_ _N_ _F_ _IF_ARGS_ 0 2 XX 3 \ (u0 :: Float#) (u1 :: Float#) -> case _#_ plusFloat# [] [u0, u1] of { _PRIM_ (u2 :: Float#) -> _!_ F# [] [u2] } _N_} _F_ _IF_ARGS_ 0 2 CC 5 \ (u0 :: Float) (u1 :: Float) -> case u0 of { _ALG_ F# (u2 :: Float#) -> case u1 of { _ALG_ F# (u3 :: Float#) -> case _#_ plusFloat# [] [u2, u3] of { _PRIM_ (u4 :: Float#) -> _!_ F# [] [u4] }; _NO_DEFLT_ }; _NO_DEFLT_ } _N_,
- (-) = _A_ 2 _U_ 11 _N_ _S_ "U(P)U(P)" {_A_ 2 _U_ 22 _N_ _N_ _F_ _IF_ARGS_ 0 2 XX 3 \ (u0 :: Float#) (u1 :: Float#) -> case _#_ minusFloat# [] [u0, u1] of { _PRIM_ (u2 :: Float#) -> _!_ F# [] [u2] } _N_} _F_ _IF_ARGS_ 0 2 CC 5 \ (u0 :: Float) (u1 :: Float) -> case u0 of { _ALG_ F# (u2 :: Float#) -> case u1 of { _ALG_ F# (u3 :: Float#) -> case _#_ minusFloat# [] [u2, u3] of { _PRIM_ (u4 :: Float#) -> _!_ F# [] [u4] }; _NO_DEFLT_ }; _NO_DEFLT_ } _N_,
- (*) = _A_ 2 _U_ 11 _N_ _S_ "U(P)U(P)" {_A_ 2 _U_ 22 _N_ _N_ _F_ _IF_ARGS_ 0 2 XX 3 \ (u0 :: Float#) (u1 :: Float#) -> case _#_ timesFloat# [] [u0, u1] of { _PRIM_ (u2 :: Float#) -> _!_ F# [] [u2] } _N_} _F_ _IF_ARGS_ 0 2 CC 5 \ (u0 :: Float) (u1 :: Float) -> case u0 of { _ALG_ F# (u2 :: Float#) -> case u1 of { _ALG_ F# (u3 :: Float#) -> case _#_ timesFloat# [] [u2, u3] of { _PRIM_ (u4 :: Float#) -> _!_ F# [] [u4] }; _NO_DEFLT_ }; _NO_DEFLT_ } _N_,
- negate = _A_ 1 _U_ 1 _N_ _S_ "U(P)" {_A_ 1 _U_ 2 _N_ _N_ _F_ _IF_ARGS_ 0 1 X 3 \ (u0 :: Float#) -> case _#_ negateFloat# [] [u0] of { _PRIM_ (u1 :: Float#) -> _!_ F# [] [u1] } _N_} _F_ _IF_ARGS_ 0 1 C 4 \ (u0 :: Float) -> case u0 of { _ALG_ F# (u1 :: Float#) -> case _#_ negateFloat# [] [u1] of { _PRIM_ (u2 :: Float#) -> _!_ F# [] [u2] }; _NO_DEFLT_ } _N_,
- abs = _A_ 1 _U_ 1 _N_ _S_ "U(P)" {_A_ 1 _U_ 2 _N_ _N_ _N_ _N_} _N_ _N_,
- signum = _A_ 1 _U_ 1 _N_ _S_ "U(P)" {_A_ 1 _U_ 2 _N_ _N_ _N_ _N_} _N_ _N_,
- fromInteger = _A_ 1 _U_ 1 _N_ _S_ "U(PPP)" {_A_ 3 _U_ 222 _N_ _N_ _F_ _IF_ARGS_ 0 3 XXX 3 \ (u0 :: Int#) (u1 :: Int#) (u2 :: ByteArray#) -> case _#_ encodeFloat# [] [u0, u1, u2, 0#] of { _PRIM_ (u3 :: Float#) -> _!_ F# [] [u3] } _N_} _F_ _IF_ARGS_ 0 1 C 4 \ (u0 :: Integer) -> case u0 of { _ALG_ J# (u1 :: Int#) (u2 :: Int#) (u3 :: ByteArray#) -> case _#_ encodeFloat# [] [u1, u2, u3, 0#] of { _PRIM_ (u4 :: Float#) -> _!_ F# [] [u4] }; _NO_DEFLT_ } _N_,
- fromInt = _A_ 1 _U_ 1 _N_ _S_ "U(P)" {_A_ 1 _U_ 2 _N_ _N_ _F_ _IF_ARGS_ 0 1 X 3 \ (u0 :: Int#) -> case _#_ int2Float# [] [u0] of { _PRIM_ (u1 :: Float#) -> _!_ F# [] [u1] } _N_} _F_ _IF_ARGS_ 0 1 C 4 \ (u0 :: Int) -> case u0 of { _ALG_ I# (u1 :: Int#) -> case _#_ int2Float# [] [u1] of { _PRIM_ (u2 :: Float#) -> _!_ F# [] [u2] }; _NO_DEFLT_ } _N_ #-}
+ (+) = { _A_ 2 _U_ 11 _N_ _S_ "U(P)U(P)" {_A_ 2 _U_ 22 _N_ _N_ _F_ _IF_ARGS_ 0 2 XX 3 \ (u0 :: Float#) (u1 :: Float#) -> case _#_ plusFloat# [] [u0, u1] of { _PRIM_ (u2 :: Float#) -> _!_ F# [] [u2] } _N_} _F_ _IF_ARGS_ 0 2 CC 5 \ (u0 :: Float) (u1 :: Float) -> case u0 of { _ALG_ F# (u2 :: Float#) -> case u1 of { _ALG_ F# (u3 :: Float#) -> case _#_ plusFloat# [] [u2, u3] of { _PRIM_ (u4 :: Float#) -> _!_ F# [] [u4] }; _NO_DEFLT_ }; _NO_DEFLT_ } _N_ },
+ (-) = { _A_ 2 _U_ 11 _N_ _S_ "U(P)U(P)" {_A_ 2 _U_ 22 _N_ _N_ _F_ _IF_ARGS_ 0 2 XX 3 \ (u0 :: Float#) (u1 :: Float#) -> case _#_ minusFloat# [] [u0, u1] of { _PRIM_ (u2 :: Float#) -> _!_ F# [] [u2] } _N_} _F_ _IF_ARGS_ 0 2 CC 5 \ (u0 :: Float) (u1 :: Float) -> case u0 of { _ALG_ F# (u2 :: Float#) -> case u1 of { _ALG_ F# (u3 :: Float#) -> case _#_ minusFloat# [] [u2, u3] of { _PRIM_ (u4 :: Float#) -> _!_ F# [] [u4] }; _NO_DEFLT_ }; _NO_DEFLT_ } _N_ },
+ (*) = { _A_ 2 _U_ 11 _N_ _S_ "U(P)U(P)" {_A_ 2 _U_ 22 _N_ _N_ _F_ _IF_ARGS_ 0 2 XX 3 \ (u0 :: Float#) (u1 :: Float#) -> case _#_ timesFloat# [] [u0, u1] of { _PRIM_ (u2 :: Float#) -> _!_ F# [] [u2] } _N_} _F_ _IF_ARGS_ 0 2 CC 5 \ (u0 :: Float) (u1 :: Float) -> case u0 of { _ALG_ F# (u2 :: Float#) -> case u1 of { _ALG_ F# (u3 :: Float#) -> case _#_ timesFloat# [] [u2, u3] of { _PRIM_ (u4 :: Float#) -> _!_ F# [] [u4] }; _NO_DEFLT_ }; _NO_DEFLT_ } _N_ },
+ negate = { _A_ 1 _U_ 1 _N_ _S_ "U(P)" {_A_ 1 _U_ 2 _N_ _N_ _F_ _IF_ARGS_ 0 1 X 3 \ (u0 :: Float#) -> case _#_ negateFloat# [] [u0] of { _PRIM_ (u1 :: Float#) -> _!_ F# [] [u1] } _N_} _F_ _IF_ARGS_ 0 1 C 4 \ (u0 :: Float) -> case u0 of { _ALG_ F# (u1 :: Float#) -> case _#_ negateFloat# [] [u1] of { _PRIM_ (u2 :: Float#) -> _!_ F# [] [u2] }; _NO_DEFLT_ } _N_ },
+ abs = { _A_ 1 _U_ 1 _N_ _S_ "U(P)" {_A_ 1 _U_ 2 _N_ _N_ _N_ _N_} _N_ _N_ },
+ signum = { _A_ 1 _U_ 1 _N_ _S_ "U(P)" {_A_ 1 _U_ 2 _N_ _N_ _N_ _N_} _N_ _N_ },
+ fromInteger = { _A_ 1 _U_ 1 _N_ _S_ "U(PPP)" {_A_ 3 _U_ 222 _N_ _N_ _F_ _IF_ARGS_ 0 3 XXX 3 \ (u0 :: Int#) (u1 :: Int#) (u2 :: ByteArray#) -> case _#_ encodeFloat# [] [u0, u1, u2, 0#] of { _PRIM_ (u3 :: Float#) -> _!_ F# [] [u3] } _N_} _F_ _IF_ARGS_ 0 1 C 4 \ (u0 :: Integer) -> case u0 of { _ALG_ J# (u1 :: Int#) (u2 :: Int#) (u3 :: ByteArray#) -> case _#_ encodeFloat# [] [u1, u2, u3, 0#] of { _PRIM_ (u4 :: Float#) -> _!_ F# [] [u4] }; _NO_DEFLT_ } _N_ },
+ fromInt = { _A_ 1 _U_ 1 _N_ _S_ "U(P)" {_A_ 1 _U_ 2 _N_ _N_ _F_ _IF_ARGS_ 0 1 X 3 \ (u0 :: Int#) -> case _#_ int2Float# [] [u0] of { _PRIM_ (u1 :: Float#) -> _!_ F# [] [u1] } _N_} _F_ _IF_ARGS_ 0 1 C 4 \ (u0 :: Int) -> case u0 of { _ALG_ I# (u1 :: Int#) -> case _#_ int2Float# [] [u1] of { _PRIM_ (u2 :: Float#) -> _!_ F# [] [u2] }; _NO_DEFLT_ } _N_ } #-}
instance Ord Float
{-# GHC_PRAGMA _M_ PreludeCore {-dfun-} _A_ 0 _N_ _N_ _N_ _F_ _IF_ARGS_ 0 0 X 9 _!_ _TUP_8 [{{Eq Float}}, (Float -> Float -> Bool), (Float -> Float -> Bool), (Float -> Float -> Bool), (Float -> Float -> Bool), (Float -> Float -> Float), (Float -> Float -> Float), (Float -> Float -> _CMP_TAG)] [_DFUN_ Eq (Float), _CONSTM_ Ord (<) (Float), _CONSTM_ Ord (<=) (Float), _CONSTM_ Ord (>=) (Float), _CONSTM_ Ord (>) (Float), _CONSTM_ Ord max (Float), _CONSTM_ Ord min (Float), _CONSTM_ Ord _tagCmp (Float)] _N_
- (<) = _A_ 2 _U_ 11 _N_ _S_ "U(P)U(P)" {_A_ 2 _U_ 22 _N_ _N_ _F_ _IF_ARGS_ 0 2 XX 1 \ (u0 :: Float#) (u1 :: Float#) -> _#_ ltFloat# [] [u0, u1] _N_} _F_ _IF_ARGS_ 0 2 CC 3 \ (u0 :: Float) (u1 :: Float) -> case u0 of { _ALG_ F# (u2 :: Float#) -> case u1 of { _ALG_ F# (u3 :: Float#) -> _#_ ltFloat# [] [u2, u3]; _NO_DEFLT_ }; _NO_DEFLT_ } _N_,
- (<=) = _A_ 2 _U_ 11 _N_ _S_ "U(P)U(P)" {_A_ 2 _U_ 22 _N_ _N_ _F_ _IF_ARGS_ 0 2 XX 1 \ (u0 :: Float#) (u1 :: Float#) -> _#_ leFloat# [] [u0, u1] _N_} _F_ _IF_ARGS_ 0 2 CC 3 \ (u0 :: Float) (u1 :: Float) -> case u0 of { _ALG_ F# (u2 :: Float#) -> case u1 of { _ALG_ F# (u3 :: Float#) -> _#_ leFloat# [] [u2, u3]; _NO_DEFLT_ }; _NO_DEFLT_ } _N_,
- (>=) = _A_ 2 _U_ 11 _N_ _S_ "U(P)U(P)" {_A_ 2 _U_ 22 _N_ _N_ _F_ _IF_ARGS_ 0 2 XX 1 \ (u0 :: Float#) (u1 :: Float#) -> _#_ geFloat# [] [u0, u1] _N_} _F_ _IF_ARGS_ 0 2 CC 3 \ (u0 :: Float) (u1 :: Float) -> case u0 of { _ALG_ F# (u2 :: Float#) -> case u1 of { _ALG_ F# (u3 :: Float#) -> _#_ geFloat# [] [u2, u3]; _NO_DEFLT_ }; _NO_DEFLT_ } _N_,
- (>) = _A_ 2 _U_ 11 _N_ _S_ "U(P)U(P)" {_A_ 2 _U_ 22 _N_ _N_ _F_ _IF_ARGS_ 0 2 XX 1 \ (u0 :: Float#) (u1 :: Float#) -> _#_ gtFloat# [] [u0, u1] _N_} _F_ _IF_ARGS_ 0 2 CC 3 \ (u0 :: Float) (u1 :: Float) -> case u0 of { _ALG_ F# (u2 :: Float#) -> case u1 of { _ALG_ F# (u3 :: Float#) -> _#_ gtFloat# [] [u2, u3]; _NO_DEFLT_ }; _NO_DEFLT_ } _N_,
- max = _A_ 2 _U_ 11 _N_ _S_ "U(P)U(P)" {_A_ 2 _U_ 22 _N_ _N_ _N_ _N_} _N_ _N_,
- min = _A_ 2 _U_ 11 _N_ _S_ "U(P)U(P)" {_A_ 2 _U_ 22 _N_ _N_ _N_ _N_} _N_ _N_,
- _tagCmp = _A_ 2 _U_ 11 _N_ _S_ "U(P)U(P)" {_A_ 2 _U_ 22 _N_ _N_ _N_ _N_} _N_ _N_ #-}
+ (<) = { _A_ 2 _U_ 11 _N_ _S_ "U(P)U(P)" {_A_ 2 _U_ 22 _N_ _N_ _F_ _IF_ARGS_ 0 2 XX 1 \ (u0 :: Float#) (u1 :: Float#) -> _#_ ltFloat# [] [u0, u1] _N_} _F_ _IF_ARGS_ 0 2 CC 3 \ (u0 :: Float) (u1 :: Float) -> case u0 of { _ALG_ F# (u2 :: Float#) -> case u1 of { _ALG_ F# (u3 :: Float#) -> _#_ ltFloat# [] [u2, u3]; _NO_DEFLT_ }; _NO_DEFLT_ } _N_ },
+ (<=) = { _A_ 2 _U_ 11 _N_ _S_ "U(P)U(P)" {_A_ 2 _U_ 22 _N_ _N_ _F_ _IF_ARGS_ 0 2 XX 1 \ (u0 :: Float#) (u1 :: Float#) -> _#_ leFloat# [] [u0, u1] _N_} _F_ _IF_ARGS_ 0 2 CC 3 \ (u0 :: Float) (u1 :: Float) -> case u0 of { _ALG_ F# (u2 :: Float#) -> case u1 of { _ALG_ F# (u3 :: Float#) -> _#_ leFloat# [] [u2, u3]; _NO_DEFLT_ }; _NO_DEFLT_ } _N_ },
+ (>=) = { _A_ 2 _U_ 11 _N_ _S_ "U(P)U(P)" {_A_ 2 _U_ 22 _N_ _N_ _F_ _IF_ARGS_ 0 2 XX 1 \ (u0 :: Float#) (u1 :: Float#) -> _#_ geFloat# [] [u0, u1] _N_} _F_ _IF_ARGS_ 0 2 CC 3 \ (u0 :: Float) (u1 :: Float) -> case u0 of { _ALG_ F# (u2 :: Float#) -> case u1 of { _ALG_ F# (u3 :: Float#) -> _#_ geFloat# [] [u2, u3]; _NO_DEFLT_ }; _NO_DEFLT_ } _N_ },
+ (>) = { _A_ 2 _U_ 11 _N_ _S_ "U(P)U(P)" {_A_ 2 _U_ 22 _N_ _N_ _F_ _IF_ARGS_ 0 2 XX 1 \ (u0 :: Float#) (u1 :: Float#) -> _#_ gtFloat# [] [u0, u1] _N_} _F_ _IF_ARGS_ 0 2 CC 3 \ (u0 :: Float) (u1 :: Float) -> case u0 of { _ALG_ F# (u2 :: Float#) -> case u1 of { _ALG_ F# (u3 :: Float#) -> _#_ gtFloat# [] [u2, u3]; _NO_DEFLT_ }; _NO_DEFLT_ } _N_ },
+ max = { _A_ 2 _U_ 11 _N_ _S_ "U(P)U(P)" {_A_ 2 _U_ 22 _N_ _N_ _N_ _N_} _N_ _N_ },
+ min = { _A_ 2 _U_ 11 _N_ _S_ "U(P)U(P)" {_A_ 2 _U_ 22 _N_ _N_ _N_ _N_} _N_ _N_ },
+ _tagCmp = { _A_ 2 _U_ 11 _N_ _S_ "U(P)U(P)" {_A_ 2 _U_ 22 _N_ _N_ _N_ _N_} _N_ _N_ } #-}
instance Real Float
{-# GHC_PRAGMA _M_ PreludeCore {-dfun-} _A_ 0 _N_ _N_ _N_ _F_ _IF_ARGS_ 0 0 X 4 _!_ _TUP_3 [{{Num Float}}, {{Enum Float}}, (Float -> Ratio Integer)] [_DFUN_ Num (Float), _DFUN_ Enum (Float), _CONSTM_ Real toRational (Float)] _N_
- toRational = _A_ 1 _U_ 1 _N_ _S_ "U(P)" {_A_ 1 _U_ 2 _N_ _N_ _N_ _N_} _N_ _N_ #-}
+ toRational = { _A_ 1 _U_ 1 _N_ _S_ "U(P)" {_A_ 1 _U_ 2 _N_ _N_ _N_ _N_} _N_ _N_ } #-}
instance RealFloat Float
{-# GHC_PRAGMA _M_ PreludeCore {-dfun-} _A_ 0 _N_ _N_ _N_ _F_ _IF_ARGS_ 0 0 X 11 _!_ _TUP_10 [{{RealFrac Float}}, {{Floating Float}}, (Float -> Integer), (Float -> Int), (Float -> (Int, Int)), (Float -> (Integer, Int)), (Integer -> Int -> Float), (Float -> Int), (Float -> Float), (Int -> Float -> Float)] [_DFUN_ RealFrac (Float), _DFUN_ Floating (Float), _CONSTM_ RealFloat floatRadix (Float), _CONSTM_ RealFloat floatDigits (Float), _CONSTM_ RealFloat floatRange (Float), _CONSTM_ RealFloat decodeFloat (Float), _CONSTM_ RealFloat encodeFloat (Float), _CONSTM_ RealFloat exponent (Float), _CONSTM_ RealFloat significand (Float), _CONSTM_ RealFloat scaleFloat (Float)] _N_
- floatRadix = _A_ 1 _U_ 0 _N_ _S_ "A" {_A_ 0 _N_ _N_ _N_ _F_ _IF_ARGS_ 0 0 X 1 _#_ int2Integer# [] [2#] _N_} _N_ _N_,
- floatDigits = _A_ 1 _U_ 0 _N_ _S_ "A" {_A_ 0 _N_ _N_ _N_ _F_ _IF_ARGS_ 0 0 X 2 _!_ I# [] [24#] _N_} _F_ _IF_ARGS_ 0 1 X 2 \ (u0 :: Float) -> _!_ I# [] [24#] _N_,
- floatRange = _A_ 1 _U_ 0 _N_ _S_ "A" {_A_ 0 _N_ _N_ _N_ _N_ _N_} _N_ _N_,
- decodeFloat = _A_ 1 _U_ 1 _N_ _S_ "U(P)" {_A_ 1 _U_ 2 _N_ _N_ _N_ _N_} _N_ _N_,
- encodeFloat = _A_ 2 _U_ 11 _N_ _S_ "U(PPP)U(P)" {_A_ 4 _U_ 2222 _N_ _N_ _F_ _IF_ARGS_ 0 4 XXXX 3 \ (u0 :: Int#) (u1 :: Int#) (u2 :: ByteArray#) (u3 :: Int#) -> case _#_ encodeFloat# [] [u0, u1, u2, u3] of { _PRIM_ (u4 :: Float#) -> _!_ F# [] [u4] } _N_} _F_ _IF_ARGS_ 0 2 CC 5 \ (u0 :: Integer) (u1 :: Int) -> case u0 of { _ALG_ J# (u2 :: Int#) (u3 :: Int#) (u4 :: ByteArray#) -> case u1 of { _ALG_ I# (u5 :: Int#) -> case _#_ encodeFloat# [] [u2, u3, u4, u5] of { _PRIM_ (u6 :: Float#) -> _!_ F# [] [u6] }; _NO_DEFLT_ }; _NO_DEFLT_ } _N_,
- exponent = _A_ 1 _U_ 2 _N_ _N_ _N_ _N_,
- significand = _A_ 1 _U_ 2 _N_ _N_ _N_ _N_,
- scaleFloat = _A_ 2 _U_ 22 _N_ _N_ _N_ _N_ #-}
+ floatRadix = { _A_ 1 _U_ 0 _N_ _S_ "A" {_A_ 0 _N_ _N_ _N_ _N_ _N_} _N_ _N_ },
+ floatDigits = { _A_ 1 _U_ 0 _N_ _S_ "A" {_A_ 0 _N_ _N_ _N_ _F_ _IF_ARGS_ 0 0 X 2 _!_ I# [] [24#] _N_} _F_ _IF_ARGS_ 0 1 X 2 \ (u0 :: Float) -> _!_ I# [] [24#] _N_ },
+ floatRange = { _A_ 1 _U_ 0 _N_ _S_ "A" {_A_ 0 _N_ _N_ _N_ _N_ _N_} _N_ _N_ },
+ decodeFloat = { _A_ 1 _U_ 1 _N_ _S_ "U(P)" {_A_ 1 _U_ 2 _N_ _N_ _N_ _N_} _N_ _N_ },
+ encodeFloat = { _A_ 2 _U_ 11 _N_ _S_ "U(PPP)U(P)" {_A_ 4 _U_ 2222 _N_ _N_ _F_ _IF_ARGS_ 0 4 XXXX 3 \ (u0 :: Int#) (u1 :: Int#) (u2 :: ByteArray#) (u3 :: Int#) -> case _#_ encodeFloat# [] [u0, u1, u2, u3] of { _PRIM_ (u4 :: Float#) -> _!_ F# [] [u4] } _N_} _F_ _IF_ARGS_ 0 2 CC 5 \ (u0 :: Integer) (u1 :: Int) -> case u0 of { _ALG_ J# (u2 :: Int#) (u3 :: Int#) (u4 :: ByteArray#) -> case u1 of { _ALG_ I# (u5 :: Int#) -> case _#_ encodeFloat# [] [u2, u3, u4, u5] of { _PRIM_ (u6 :: Float#) -> _!_ F# [] [u6] }; _NO_DEFLT_ }; _NO_DEFLT_ } _N_ },
+ exponent = { _A_ 1 _U_ 1 _N_ _S_ "U(P)" {_A_ 1 _U_ 2 _N_ _N_ _N_ _N_} _N_ _N_ },
+ significand = { _A_ 1 _U_ 1 _N_ _S_ "U(P)" {_A_ 1 _U_ 2 _N_ _N_ _N_ _N_} _N_ _N_ },
+ scaleFloat = { _A_ 2 _U_ 11 _N_ _S_ "U(P)U(P)" {_A_ 2 _U_ 22 _N_ _N_ _N_ _N_} _N_ _N_ } #-}
instance RealFrac Float
{-# GHC_PRAGMA _M_ PreludeCore {-dfun-} _A_ 0 _N_ _N_ _N_ _F_ _IF_ARGS_ 0 0 X 8 _!_ _TUP_7 [{{Real Float}}, {{Fractional Float}}, _forall_ a$z1 =>{{Integral a$z1}} -> (Float -> (a$z1, Float)), _forall_ a$z1 =>{{Integral a$z1}} -> (Float -> a$z1), _forall_ a$z1 =>{{Integral a$z1}} -> (Float -> a$z1), _forall_ a$z1 =>{{Integral a$z1}} -> (Float -> a$z1), _forall_ a$z1 =>{{Integral a$z1}} -> (Float -> a$z1)] [_DFUN_ Real (Float), _DFUN_ Fractional (Float), _CONSTM_ RealFrac properFraction (Float), _CONSTM_ RealFrac truncate (Float), _CONSTM_ RealFrac round (Float), _CONSTM_ RealFrac ceiling (Float), _CONSTM_ RealFrac floor (Float)] _N_
- properFraction = _A_ 1 _U_ 22 _N_ _N_ _N_ _N_,
- truncate = _A_ 1 _U_ 22 _N_ _N_ _N_ _N_,
- round = _A_ 1 _U_ 22 _N_ _N_ _N_ _N_,
- ceiling = _A_ 1 _U_ 22 _N_ _N_ _N_ _N_,
- floor = _A_ 1 _U_ 22 _N_ _N_ _N_ _N_ #-}
+ properFraction = { _A_ 1 _U_ 11 _N_ _N_ _N_ _SPECIALISE_ [ Int ] 1 { _A_ 1 _U_ 1 _N_ _S_ "U(P)" {_A_ 1 _U_ 2 _N_ _N_ _N_ _N_} _N_ _N_ }, [ Integer ] 1 { _A_ 1 _U_ 1 _N_ _S_ "U(P)" {_A_ 1 _U_ 2 _N_ _N_ _N_ _N_} _N_ _N_ } },
+ truncate = { _A_ 1 _U_ 11 _N_ _N_ _N_ _SPECIALISE_ [ Int ] 1 { _A_ 1 _U_ 1 _N_ _S_ "U(P)" {_A_ 1 _U_ 2 _N_ _N_ _F_ _IF_ARGS_ 0 1 X 4 \ (u0 :: Float#) -> case _APP_ _WRKR_ _SPEC_ _CONSTM_ RealFrac properFraction (Float) [ (Int) ] [ u0 ] of { _ALG_ _TUP_2 (u1 :: Int) (u2 :: Float) -> u1; _NO_DEFLT_ } _N_} _F_ _IF_ARGS_ 0 1 X 4 \ (u0 :: Float) -> case _APP_ _SPEC_ _CONSTM_ RealFrac properFraction (Float) [ (Int) ] [ u0 ] of { _ALG_ _TUP_2 (u1 :: Int) (u2 :: Float) -> u1; _NO_DEFLT_ } _N_ }, [ Integer ] 1 { _A_ 1 _U_ 1 _N_ _S_ "U(P)" {_A_ 1 _U_ 2 _N_ _N_ _F_ _IF_ARGS_ 0 1 X 4 \ (u0 :: Float#) -> case _APP_ _WRKR_ _SPEC_ _CONSTM_ RealFrac properFraction (Float) [ (Integer) ] [ u0 ] of { _ALG_ _TUP_2 (u1 :: Integer) (u2 :: Float) -> u1; _NO_DEFLT_ } _N_} _F_ _IF_ARGS_ 0 1 X 4 \ (u0 :: Float) -> case _APP_ _SPEC_ _CONSTM_ RealFrac properFraction (Float) [ (Integer) ] [ u0 ] of { _ALG_ _TUP_2 (u1 :: Integer) (u2 :: Float) -> u1; _NO_DEFLT_ } _N_ } },
+ round = { _A_ 1 _U_ 21 _N_ _N_ _N_ _SPECIALISE_ [ Int ] 1 { _A_ 1 _U_ 1 _N_ _S_ "U(P)" {_A_ 1 _U_ 2 _N_ _N_ _N_ _N_} _N_ _N_ }, [ Integer ] 1 { _A_ 1 _U_ 1 _N_ _S_ "U(P)" {_A_ 1 _U_ 2 _N_ _N_ _N_ _N_} _N_ _N_ } },
+ ceiling = { _A_ 1 _U_ 21 _N_ _N_ _N_ _SPECIALISE_ [ Int ] 1 { _A_ 1 _U_ 1 _N_ _S_ "U(P)" {_A_ 1 _U_ 2 _N_ _N_ _N_ _N_} _N_ _N_ }, [ Integer ] 1 { _A_ 1 _U_ 1 _N_ _S_ "U(P)" {_A_ 1 _U_ 2 _N_ _N_ _N_ _N_} _N_ _N_ } },
+ floor = { _A_ 1 _U_ 21 _N_ _N_ _N_ _SPECIALISE_ [ Int ] 1 { _A_ 1 _U_ 1 _N_ _S_ "U(P)" {_A_ 1 _U_ 2 _N_ _N_ _N_ _N_} _N_ _N_ }, [ Integer ] 1 { _A_ 1 _U_ 1 _N_ _S_ "U(P)" {_A_ 1 _U_ 2 _N_ _N_ _N_ _N_} _N_ _N_ } } #-}
instance Text Float
{-# GHC_PRAGMA _M_ PreludeCore {-dfun-} _A_ 0 _N_ _N_ _N_ _F_ _IF_ARGS_ 0 0 X 5 _!_ _TUP_4 [(Int -> [Char] -> [(Float, [Char])]), (Int -> Float -> [Char] -> [Char]), ([Char] -> [([Float], [Char])]), ([Float] -> [Char] -> [Char])] [_CONSTM_ Text readsPrec (Float), _CONSTM_ Text showsPrec (Float), _CONSTM_ Text readList (Float), _CONSTM_ Text showList (Float)] _N_
- readsPrec = _A_ 2 _U_ 02 _N_ _S_ "AL" {_A_ 1 _U_ 2 _N_ _N_ _N_ _N_} _N_ _N_,
- showsPrec = _A_ 1 _U_ 222 _N_ _N_ _N_ _N_,
- readList = _A_ 0 _U_ 2 _N_ _N_ _N_ _N_,
- showList = _A_ 0 _U_ 12 _N_ _N_ _N_ _N_ #-}
+ readsPrec = { _A_ 2 _U_ 02 _N_ _S_ "AL" {_A_ 1 _U_ 2 _N_ _N_ _N_ _N_} _N_ _N_ },
+ showsPrec = { _A_ 1 _U_ 222 _N_ _N_ _N_ _N_ },
+ readList = { _A_ 0 _U_ 2 _N_ _N_ _N_ _N_ },
+ showList = { _A_ 0 _U_ 12 _N_ _N_ _N_ _N_ } #-}
instance _CCallable Float
{-# GHC_PRAGMA _M_ PreludeCore {-dfun-} _A_ 0 _N_ _N_ _N_ _F_ _IF_ARGS_ 0 0 X 1 _!_ _TUP_0 [] [] _N_ #-}
instance _CReturnable Float
-{-# GHC_PRAGMA INTERFACE VERSION 5 #-}
+{-# GHC_PRAGMA INTERFACE VERSION 6 #-}
interface PreludeCore where
import PreludeBuiltin(Float(..))
instance Enum Float
{-# GHC_PRAGMA _M_ PreludeCore {-dfun-} _A_ 0 _N_ _N_ _N_ _F_ _IF_ARGS_ 0 0 X 6 _!_ _TUP_5 [{{Ord Float}}, (Float -> [Float]), (Float -> Float -> [Float]), (Float -> Float -> [Float]), (Float -> Float -> Float -> [Float])] [_DFUN_ Ord (Float), _CONSTM_ Enum enumFrom (Float), _CONSTM_ Enum enumFromThen (Float), _CONSTM_ Enum enumFromTo (Float), _CONSTM_ Enum enumFromThenTo (Float)] _N_
- enumFrom = _A_ 1 _U_ 2 _N_ _N_ _N_ _N_,
- enumFromThen = _A_ 2 _U_ 21 _N_ _N_ _N_ _N_,
- enumFromTo = _A_ 2 _U_ 22 _N_ _N_ _N_ _N_,
- enumFromThenTo = _A_ 3 _U_ 222 _N_ _N_ _N_ _N_ #-}
+ enumFrom = { _A_ 1 _U_ 2 _N_ _N_ _N_ _N_ },
+ enumFromThen = { _A_ 2 _U_ 21 _N_ _N_ _N_ _N_ },
+ enumFromTo = { _A_ 2 _U_ 22 _N_ _N_ _N_ _N_ },
+ enumFromThenTo = { _A_ 3 _U_ 222 _N_ _N_ _N_ _N_ } #-}
instance Eq Float
{-# GHC_PRAGMA _M_ PreludeCore {-dfun-} _A_ 0 _N_ _N_ _N_ _F_ _IF_ARGS_ 0 0 X 3 _!_ _TUP_2 [(Float -> Float -> Bool), (Float -> Float -> Bool)] [_CONSTM_ Eq (==) (Float), _CONSTM_ Eq (/=) (Float)] _N_
- (==) = _A_ 2 _U_ 11 _N_ _S_ "U(P)U(P)" {_A_ 2 _U_ 22 _N_ _N_ _F_ _IF_ARGS_ 0 2 XX 1 \ (u0 :: Float#) (u1 :: Float#) -> _#_ eqFloat# [] [u0, u1] _N_} _F_ _IF_ARGS_ 0 2 CC 3 \ (u0 :: Float) (u1 :: Float) -> case u0 of { _ALG_ F# (u2 :: Float#) -> case u1 of { _ALG_ F# (u3 :: Float#) -> _#_ eqFloat# [] [u2, u3]; _NO_DEFLT_ }; _NO_DEFLT_ } _N_,
- (/=) = _A_ 2 _U_ 11 _N_ _S_ "U(P)U(P)" {_A_ 2 _U_ 22 _N_ _N_ _F_ _IF_ARGS_ 0 2 XX 1 \ (u0 :: Float#) (u1 :: Float#) -> _#_ neFloat# [] [u0, u1] _N_} _F_ _IF_ARGS_ 0 2 CC 3 \ (u0 :: Float) (u1 :: Float) -> case u0 of { _ALG_ F# (u2 :: Float#) -> case u1 of { _ALG_ F# (u3 :: Float#) -> _#_ neFloat# [] [u2, u3]; _NO_DEFLT_ }; _NO_DEFLT_ } _N_ #-}
+ (==) = { _A_ 2 _U_ 11 _N_ _S_ "U(P)U(P)" {_A_ 2 _U_ 22 _N_ _N_ _F_ _IF_ARGS_ 0 2 XX 1 \ (u0 :: Float#) (u1 :: Float#) -> _#_ eqFloat# [] [u0, u1] _N_} _F_ _IF_ARGS_ 0 2 CC 3 \ (u0 :: Float) (u1 :: Float) -> case u0 of { _ALG_ F# (u2 :: Float#) -> case u1 of { _ALG_ F# (u3 :: Float#) -> _#_ eqFloat# [] [u2, u3]; _NO_DEFLT_ }; _NO_DEFLT_ } _N_ },
+ (/=) = { _A_ 2 _U_ 11 _N_ _S_ "U(P)U(P)" {_A_ 2 _U_ 22 _N_ _N_ _F_ _IF_ARGS_ 0 2 XX 1 \ (u0 :: Float#) (u1 :: Float#) -> _#_ neFloat# [] [u0, u1] _N_} _F_ _IF_ARGS_ 0 2 CC 3 \ (u0 :: Float) (u1 :: Float) -> case u0 of { _ALG_ F# (u2 :: Float#) -> case u1 of { _ALG_ F# (u3 :: Float#) -> _#_ neFloat# [] [u2, u3]; _NO_DEFLT_ }; _NO_DEFLT_ } _N_ } #-}
instance Floating Float
{-# GHC_PRAGMA _M_ PreludeCore {-dfun-} _A_ 0 _N_ _N_ _N_ _F_ _IF_ARGS_ 0 0 X 20 _!_ _TUP_19 [{{Fractional Float}}, Float, (Float -> Float), (Float -> Float), (Float -> Float), (Float -> Float -> Float), (Float -> Float -> Float), (Float -> Float), (Float -> Float), (Float -> Float), (Float -> Float), (Float -> Float), (Float -> Float), (Float -> Float), (Float -> Float), (Float -> Float), (Float -> Float), (Float -> Float), (Float -> Float)] [_DFUN_ Fractional (Float), _CONSTM_ Floating pi (Float), _CONSTM_ Floating exp (Float), _CONSTM_ Floating log (Float), _CONSTM_ Floating sqrt (Float), _CONSTM_ Floating (**) (Float), _CONSTM_ Floating logBase (Float), _CONSTM_ Floating sin (Float), _CONSTM_ Floating cos (Float), _CONSTM_ Floating tan (Float), _CONSTM_ Floating asin (Float), _CONSTM_ Floating acos (Float), _CONSTM_ Floating atan (Float), _CONSTM_ Floating sinh (Float), _CONSTM_ Floating cosh (Float), _CONSTM_ Floating tanh (Float), _CONSTM_ Floating asinh (Float), _CONSTM_ Floating acosh (Float), _CONSTM_ Floating atanh (Float)] _N_
- pi = _A_ 0 _N_ _N_ _N_ _F_ _IF_ARGS_ 0 0 X 2 _!_ F# [] [3.1415926535897931#] _N_,
- exp = _A_ 1 _U_ 1 _N_ _S_ "U(P)" {_A_ 1 _U_ 2 _N_ _N_ _F_ _IF_ARGS_ 0 1 X 3 \ (u0 :: Float#) -> case _#_ expFloat# [] [u0] of { _PRIM_ (u1 :: Float#) -> _!_ F# [] [u1] } _N_} _F_ _IF_ARGS_ 0 1 C 4 \ (u0 :: Float) -> case u0 of { _ALG_ F# (u1 :: Float#) -> case _#_ expFloat# [] [u1] of { _PRIM_ (u2 :: Float#) -> _!_ F# [] [u2] }; _NO_DEFLT_ } _N_,
- log = _A_ 1 _U_ 1 _N_ _S_ "U(P)" {_A_ 1 _U_ 2 _N_ _N_ _F_ _IF_ARGS_ 0 1 X 3 \ (u0 :: Float#) -> case _#_ logFloat# [] [u0] of { _PRIM_ (u1 :: Float#) -> _!_ F# [] [u1] } _N_} _F_ _IF_ARGS_ 0 1 C 4 \ (u0 :: Float) -> case u0 of { _ALG_ F# (u1 :: Float#) -> case _#_ logFloat# [] [u1] of { _PRIM_ (u2 :: Float#) -> _!_ F# [] [u2] }; _NO_DEFLT_ } _N_,
- sqrt = _A_ 1 _U_ 1 _N_ _S_ "U(P)" {_A_ 1 _U_ 2 _N_ _N_ _F_ _IF_ARGS_ 0 1 X 3 \ (u0 :: Float#) -> case _#_ sqrtFloat# [] [u0] of { _PRIM_ (u1 :: Float#) -> _!_ F# [] [u1] } _N_} _F_ _IF_ARGS_ 0 1 C 4 \ (u0 :: Float) -> case u0 of { _ALG_ F# (u1 :: Float#) -> case _#_ sqrtFloat# [] [u1] of { _PRIM_ (u2 :: Float#) -> _!_ F# [] [u2] }; _NO_DEFLT_ } _N_,
- (**) = _A_ 2 _U_ 11 _N_ _S_ "U(P)U(P)" {_A_ 2 _U_ 22 _N_ _N_ _F_ _IF_ARGS_ 0 2 XX 3 \ (u0 :: Float#) (u1 :: Float#) -> case _#_ powerFloat# [] [u0, u1] of { _PRIM_ (u2 :: Float#) -> _!_ F# [] [u2] } _N_} _F_ _IF_ARGS_ 0 2 CC 5 \ (u0 :: Float) (u1 :: Float) -> case u0 of { _ALG_ F# (u2 :: Float#) -> case u1 of { _ALG_ F# (u3 :: Float#) -> case _#_ powerFloat# [] [u2, u3] of { _PRIM_ (u4 :: Float#) -> _!_ F# [] [u4] }; _NO_DEFLT_ }; _NO_DEFLT_ } _N_,
- logBase = _A_ 2 _U_ 22 _N_ _N_ _N_ _N_,
- sin = _A_ 1 _U_ 1 _N_ _S_ "U(P)" {_A_ 1 _U_ 2 _N_ _N_ _F_ _IF_ARGS_ 0 1 X 3 \ (u0 :: Float#) -> case _#_ sinFloat# [] [u0] of { _PRIM_ (u1 :: Float#) -> _!_ F# [] [u1] } _N_} _F_ _IF_ARGS_ 0 1 C 4 \ (u0 :: Float) -> case u0 of { _ALG_ F# (u1 :: Float#) -> case _#_ sinFloat# [] [u1] of { _PRIM_ (u2 :: Float#) -> _!_ F# [] [u2] }; _NO_DEFLT_ } _N_,
- cos = _A_ 1 _U_ 1 _N_ _S_ "U(P)" {_A_ 1 _U_ 2 _N_ _N_ _F_ _IF_ARGS_ 0 1 X 3 \ (u0 :: Float#) -> case _#_ cosFloat# [] [u0] of { _PRIM_ (u1 :: Float#) -> _!_ F# [] [u1] } _N_} _F_ _IF_ARGS_ 0 1 C 4 \ (u0 :: Float) -> case u0 of { _ALG_ F# (u1 :: Float#) -> case _#_ cosFloat# [] [u1] of { _PRIM_ (u2 :: Float#) -> _!_ F# [] [u2] }; _NO_DEFLT_ } _N_,
- tan = _A_ 1 _U_ 1 _N_ _S_ "U(P)" {_A_ 1 _U_ 2 _N_ _N_ _F_ _IF_ARGS_ 0 1 X 3 \ (u0 :: Float#) -> case _#_ tanFloat# [] [u0] of { _PRIM_ (u1 :: Float#) -> _!_ F# [] [u1] } _N_} _F_ _IF_ARGS_ 0 1 C 4 \ (u0 :: Float) -> case u0 of { _ALG_ F# (u1 :: Float#) -> case _#_ tanFloat# [] [u1] of { _PRIM_ (u2 :: Float#) -> _!_ F# [] [u2] }; _NO_DEFLT_ } _N_,
- asin = _A_ 1 _U_ 1 _N_ _S_ "U(P)" {_A_ 1 _U_ 2 _N_ _N_ _F_ _IF_ARGS_ 0 1 X 3 \ (u0 :: Float#) -> case _#_ asinFloat# [] [u0] of { _PRIM_ (u1 :: Float#) -> _!_ F# [] [u1] } _N_} _F_ _IF_ARGS_ 0 1 C 4 \ (u0 :: Float) -> case u0 of { _ALG_ F# (u1 :: Float#) -> case _#_ asinFloat# [] [u1] of { _PRIM_ (u2 :: Float#) -> _!_ F# [] [u2] }; _NO_DEFLT_ } _N_,
- acos = _A_ 1 _U_ 1 _N_ _S_ "U(P)" {_A_ 1 _U_ 2 _N_ _N_ _F_ _IF_ARGS_ 0 1 X 3 \ (u0 :: Float#) -> case _#_ acosFloat# [] [u0] of { _PRIM_ (u1 :: Float#) -> _!_ F# [] [u1] } _N_} _F_ _IF_ARGS_ 0 1 C 4 \ (u0 :: Float) -> case u0 of { _ALG_ F# (u1 :: Float#) -> case _#_ acosFloat# [] [u1] of { _PRIM_ (u2 :: Float#) -> _!_ F# [] [u2] }; _NO_DEFLT_ } _N_,
- atan = _A_ 1 _U_ 1 _N_ _S_ "U(P)" {_A_ 1 _U_ 2 _N_ _N_ _F_ _IF_ARGS_ 0 1 X 3 \ (u0 :: Float#) -> case _#_ atanFloat# [] [u0] of { _PRIM_ (u1 :: Float#) -> _!_ F# [] [u1] } _N_} _F_ _IF_ARGS_ 0 1 C 4 \ (u0 :: Float) -> case u0 of { _ALG_ F# (u1 :: Float#) -> case _#_ atanFloat# [] [u1] of { _PRIM_ (u2 :: Float#) -> _!_ F# [] [u2] }; _NO_DEFLT_ } _N_,
- sinh = _A_ 1 _U_ 1 _N_ _S_ "U(P)" {_A_ 1 _U_ 2 _N_ _N_ _F_ _IF_ARGS_ 0 1 X 3 \ (u0 :: Float#) -> case _#_ sinhFloat# [] [u0] of { _PRIM_ (u1 :: Float#) -> _!_ F# [] [u1] } _N_} _F_ _IF_ARGS_ 0 1 C 4 \ (u0 :: Float) -> case u0 of { _ALG_ F# (u1 :: Float#) -> case _#_ sinhFloat# [] [u1] of { _PRIM_ (u2 :: Float#) -> _!_ F# [] [u2] }; _NO_DEFLT_ } _N_,
- cosh = _A_ 1 _U_ 1 _N_ _S_ "U(P)" {_A_ 1 _U_ 2 _N_ _N_ _F_ _IF_ARGS_ 0 1 X 3 \ (u0 :: Float#) -> case _#_ coshFloat# [] [u0] of { _PRIM_ (u1 :: Float#) -> _!_ F# [] [u1] } _N_} _F_ _IF_ARGS_ 0 1 C 4 \ (u0 :: Float) -> case u0 of { _ALG_ F# (u1 :: Float#) -> case _#_ coshFloat# [] [u1] of { _PRIM_ (u2 :: Float#) -> _!_ F# [] [u2] }; _NO_DEFLT_ } _N_,
- tanh = _A_ 1 _U_ 1 _N_ _S_ "U(P)" {_A_ 1 _U_ 2 _N_ _N_ _F_ _IF_ARGS_ 0 1 X 3 \ (u0 :: Float#) -> case _#_ tanhFloat# [] [u0] of { _PRIM_ (u1 :: Float#) -> _!_ F# [] [u1] } _N_} _F_ _IF_ARGS_ 0 1 C 4 \ (u0 :: Float) -> case u0 of { _ALG_ F# (u1 :: Float#) -> case _#_ tanhFloat# [] [u1] of { _PRIM_ (u2 :: Float#) -> _!_ F# [] [u2] }; _NO_DEFLT_ } _N_,
- asinh = _A_ 1 _U_ 1 _N_ _S_ "U(P)" {_A_ 1 _U_ 2 _N_ _N_ _N_ _N_} _N_ _N_,
- acosh = _A_ 1 _U_ 1 _N_ _S_ "U(P)" {_A_ 1 _U_ 2 _N_ _N_ _N_ _N_} _N_ _N_,
- atanh = _A_ 1 _U_ 1 _N_ _S_ "U(P)" {_A_ 1 _U_ 2 _N_ _N_ _N_ _N_} _N_ _N_ #-}
+ pi = { _A_ 0 _N_ _N_ _N_ _F_ _IF_ARGS_ 0 0 X 2 _!_ F# [] [3.1415926535897931#] _N_ },
+ exp = { _A_ 1 _U_ 1 _N_ _S_ "U(P)" {_A_ 1 _U_ 2 _N_ _N_ _F_ _IF_ARGS_ 0 1 X 3 \ (u0 :: Float#) -> case _#_ expFloat# [] [u0] of { _PRIM_ (u1 :: Float#) -> _!_ F# [] [u1] } _N_} _F_ _IF_ARGS_ 0 1 C 4 \ (u0 :: Float) -> case u0 of { _ALG_ F# (u1 :: Float#) -> case _#_ expFloat# [] [u1] of { _PRIM_ (u2 :: Float#) -> _!_ F# [] [u2] }; _NO_DEFLT_ } _N_ },
+ log = { _A_ 1 _U_ 1 _N_ _S_ "U(P)" {_A_ 1 _U_ 2 _N_ _N_ _F_ _IF_ARGS_ 0 1 X 3 \ (u0 :: Float#) -> case _#_ logFloat# [] [u0] of { _PRIM_ (u1 :: Float#) -> _!_ F# [] [u1] } _N_} _F_ _IF_ARGS_ 0 1 C 4 \ (u0 :: Float) -> case u0 of { _ALG_ F# (u1 :: Float#) -> case _#_ logFloat# [] [u1] of { _PRIM_ (u2 :: Float#) -> _!_ F# [] [u2] }; _NO_DEFLT_ } _N_ },
+ sqrt = { _A_ 1 _U_ 1 _N_ _S_ "U(P)" {_A_ 1 _U_ 2 _N_ _N_ _F_ _IF_ARGS_ 0 1 X 3 \ (u0 :: Float#) -> case _#_ sqrtFloat# [] [u0] of { _PRIM_ (u1 :: Float#) -> _!_ F# [] [u1] } _N_} _F_ _IF_ARGS_ 0 1 C 4 \ (u0 :: Float) -> case u0 of { _ALG_ F# (u1 :: Float#) -> case _#_ sqrtFloat# [] [u1] of { _PRIM_ (u2 :: Float#) -> _!_ F# [] [u2] }; _NO_DEFLT_ } _N_ },
+ (**) = { _A_ 2 _U_ 11 _N_ _S_ "U(P)U(P)" {_A_ 2 _U_ 22 _N_ _N_ _F_ _IF_ARGS_ 0 2 XX 3 \ (u0 :: Float#) (u1 :: Float#) -> case _#_ powerFloat# [] [u0, u1] of { _PRIM_ (u2 :: Float#) -> _!_ F# [] [u2] } _N_} _F_ _IF_ARGS_ 0 2 CC 5 \ (u0 :: Float) (u1 :: Float) -> case u0 of { _ALG_ F# (u2 :: Float#) -> case u1 of { _ALG_ F# (u3 :: Float#) -> case _#_ powerFloat# [] [u2, u3] of { _PRIM_ (u4 :: Float#) -> _!_ F# [] [u4] }; _NO_DEFLT_ }; _NO_DEFLT_ } _N_ },
+ logBase = { _A_ 2 _U_ 11 _N_ _S_ "U(P)U(P)" {_A_ 2 _U_ 22 _N_ _N_ _F_ _IF_ARGS_ 0 2 XX 5 \ (u0 :: Float#) (u1 :: Float#) -> case _#_ logFloat# [] [u1] of { _PRIM_ (u2 :: Float#) -> case _#_ logFloat# [] [u0] of { _PRIM_ (u3 :: Float#) -> case _#_ divideFloat# [] [u2, u3] of { _PRIM_ (u4 :: Float#) -> _!_ F# [] [u4] } } } _N_} _F_ _IF_ARGS_ 0 2 CC 7 \ (u0 :: Float) (u1 :: Float) -> case u1 of { _ALG_ F# (u2 :: Float#) -> case _#_ logFloat# [] [u2] of { _PRIM_ (u3 :: Float#) -> case u0 of { _ALG_ F# (u4 :: Float#) -> case _#_ logFloat# [] [u4] of { _PRIM_ (u5 :: Float#) -> case _#_ divideFloat# [] [u3, u5] of { _PRIM_ (u6 :: Float#) -> _!_ F# [] [u6] } }; _NO_DEFLT_ } }; _NO_DEFLT_ } _N_ },
+ sin = { _A_ 1 _U_ 1 _N_ _S_ "U(P)" {_A_ 1 _U_ 2 _N_ _N_ _F_ _IF_ARGS_ 0 1 X 3 \ (u0 :: Float#) -> case _#_ sinFloat# [] [u0] of { _PRIM_ (u1 :: Float#) -> _!_ F# [] [u1] } _N_} _F_ _IF_ARGS_ 0 1 C 4 \ (u0 :: Float) -> case u0 of { _ALG_ F# (u1 :: Float#) -> case _#_ sinFloat# [] [u1] of { _PRIM_ (u2 :: Float#) -> _!_ F# [] [u2] }; _NO_DEFLT_ } _N_ },
+ cos = { _A_ 1 _U_ 1 _N_ _S_ "U(P)" {_A_ 1 _U_ 2 _N_ _N_ _F_ _IF_ARGS_ 0 1 X 3 \ (u0 :: Float#) -> case _#_ cosFloat# [] [u0] of { _PRIM_ (u1 :: Float#) -> _!_ F# [] [u1] } _N_} _F_ _IF_ARGS_ 0 1 C 4 \ (u0 :: Float) -> case u0 of { _ALG_ F# (u1 :: Float#) -> case _#_ cosFloat# [] [u1] of { _PRIM_ (u2 :: Float#) -> _!_ F# [] [u2] }; _NO_DEFLT_ } _N_ },
+ tan = { _A_ 1 _U_ 1 _N_ _S_ "U(P)" {_A_ 1 _U_ 2 _N_ _N_ _F_ _IF_ARGS_ 0 1 X 3 \ (u0 :: Float#) -> case _#_ tanFloat# [] [u0] of { _PRIM_ (u1 :: Float#) -> _!_ F# [] [u1] } _N_} _F_ _IF_ARGS_ 0 1 C 4 \ (u0 :: Float) -> case u0 of { _ALG_ F# (u1 :: Float#) -> case _#_ tanFloat# [] [u1] of { _PRIM_ (u2 :: Float#) -> _!_ F# [] [u2] }; _NO_DEFLT_ } _N_ },
+ asin = { _A_ 1 _U_ 1 _N_ _S_ "U(P)" {_A_ 1 _U_ 2 _N_ _N_ _F_ _IF_ARGS_ 0 1 X 3 \ (u0 :: Float#) -> case _#_ asinFloat# [] [u0] of { _PRIM_ (u1 :: Float#) -> _!_ F# [] [u1] } _N_} _F_ _IF_ARGS_ 0 1 C 4 \ (u0 :: Float) -> case u0 of { _ALG_ F# (u1 :: Float#) -> case _#_ asinFloat# [] [u1] of { _PRIM_ (u2 :: Float#) -> _!_ F# [] [u2] }; _NO_DEFLT_ } _N_ },
+ acos = { _A_ 1 _U_ 1 _N_ _S_ "U(P)" {_A_ 1 _U_ 2 _N_ _N_ _F_ _IF_ARGS_ 0 1 X 3 \ (u0 :: Float#) -> case _#_ acosFloat# [] [u0] of { _PRIM_ (u1 :: Float#) -> _!_ F# [] [u1] } _N_} _F_ _IF_ARGS_ 0 1 C 4 \ (u0 :: Float) -> case u0 of { _ALG_ F# (u1 :: Float#) -> case _#_ acosFloat# [] [u1] of { _PRIM_ (u2 :: Float#) -> _!_ F# [] [u2] }; _NO_DEFLT_ } _N_ },
+ atan = { _A_ 1 _U_ 1 _N_ _S_ "U(P)" {_A_ 1 _U_ 2 _N_ _N_ _F_ _IF_ARGS_ 0 1 X 3 \ (u0 :: Float#) -> case _#_ atanFloat# [] [u0] of { _PRIM_ (u1 :: Float#) -> _!_ F# [] [u1] } _N_} _F_ _IF_ARGS_ 0 1 C 4 \ (u0 :: Float) -> case u0 of { _ALG_ F# (u1 :: Float#) -> case _#_ atanFloat# [] [u1] of { _PRIM_ (u2 :: Float#) -> _!_ F# [] [u2] }; _NO_DEFLT_ } _N_ },
+ sinh = { _A_ 1 _U_ 1 _N_ _S_ "U(P)" {_A_ 1 _U_ 2 _N_ _N_ _F_ _IF_ARGS_ 0 1 X 3 \ (u0 :: Float#) -> case _#_ sinhFloat# [] [u0] of { _PRIM_ (u1 :: Float#) -> _!_ F# [] [u1] } _N_} _F_ _IF_ARGS_ 0 1 C 4 \ (u0 :: Float) -> case u0 of { _ALG_ F# (u1 :: Float#) -> case _#_ sinhFloat# [] [u1] of { _PRIM_ (u2 :: Float#) -> _!_ F# [] [u2] }; _NO_DEFLT_ } _N_ },
+ cosh = { _A_ 1 _U_ 1 _N_ _S_ "U(P)" {_A_ 1 _U_ 2 _N_ _N_ _F_ _IF_ARGS_ 0 1 X 3 \ (u0 :: Float#) -> case _#_ coshFloat# [] [u0] of { _PRIM_ (u1 :: Float#) -> _!_ F# [] [u1] } _N_} _F_ _IF_ARGS_ 0 1 C 4 \ (u0 :: Float) -> case u0 of { _ALG_ F# (u1 :: Float#) -> case _#_ coshFloat# [] [u1] of { _PRIM_ (u2 :: Float#) -> _!_ F# [] [u2] }; _NO_DEFLT_ } _N_ },
+ tanh = { _A_ 1 _U_ 1 _N_ _S_ "U(P)" {_A_ 1 _U_ 2 _N_ _N_ _F_ _IF_ARGS_ 0 1 X 3 \ (u0 :: Float#) -> case _#_ tanhFloat# [] [u0] of { _PRIM_ (u1 :: Float#) -> _!_ F# [] [u1] } _N_} _F_ _IF_ARGS_ 0 1 C 4 \ (u0 :: Float) -> case u0 of { _ALG_ F# (u1 :: Float#) -> case _#_ tanhFloat# [] [u1] of { _PRIM_ (u2 :: Float#) -> _!_ F# [] [u2] }; _NO_DEFLT_ } _N_ },
+ asinh = { _A_ 1 _U_ 1 _N_ _S_ "U(P)" {_A_ 1 _U_ 2 _N_ _N_ _N_ _N_} _N_ _N_ },
+ acosh = { _A_ 1 _U_ 1 _N_ _S_ "U(P)" {_A_ 1 _U_ 2 _N_ _N_ _N_ _N_} _N_ _N_ },
+ atanh = { _A_ 1 _U_ 1 _N_ _S_ "U(P)" {_A_ 1 _U_ 2 _N_ _N_ _N_ _N_} _N_ _N_ } #-}
instance Fractional Float
{-# GHC_PRAGMA _M_ PreludeCore {-dfun-} _A_ 0 _N_ _N_ _N_ _F_ _IF_ARGS_ 0 0 X 5 _!_ _TUP_4 [{{Num Float}}, (Float -> Float -> Float), (Float -> Float), (Ratio Integer -> Float)] [_DFUN_ Num (Float), _CONSTM_ Fractional (/) (Float), _CONSTM_ Fractional recip (Float), _CONSTM_ Fractional fromRational (Float)] _N_
- (/) = _A_ 2 _U_ 11 _N_ _S_ "U(P)U(P)" {_A_ 2 _U_ 22 _N_ _N_ _F_ _IF_ARGS_ 0 2 XX 3 \ (u0 :: Float#) (u1 :: Float#) -> case _#_ divideFloat# [] [u0, u1] of { _PRIM_ (u2 :: Float#) -> _!_ F# [] [u2] } _N_} _F_ _IF_ARGS_ 0 2 CC 5 \ (u0 :: Float) (u1 :: Float) -> case u0 of { _ALG_ F# (u2 :: Float#) -> case u1 of { _ALG_ F# (u3 :: Float#) -> case _#_ divideFloat# [] [u2, u3] of { _PRIM_ (u4 :: Float#) -> _!_ F# [] [u4] }; _NO_DEFLT_ }; _NO_DEFLT_ } _N_,
- recip = _A_ 0 _U_ 2 _N_ _N_ _N_ _N_,
- fromRational = _A_ 0 _U_ 2 _N_ _N_ _N_ _N_ #-}
+ (/) = { _A_ 2 _U_ 11 _N_ _S_ "U(P)U(P)" {_A_ 2 _U_ 22 _N_ _N_ _F_ _IF_ARGS_ 0 2 XX 3 \ (u0 :: Float#) (u1 :: Float#) -> case _#_ divideFloat# [] [u0, u1] of { _PRIM_ (u2 :: Float#) -> _!_ F# [] [u2] } _N_} _F_ _IF_ARGS_ 0 2 CC 5 \ (u0 :: Float) (u1 :: Float) -> case u0 of { _ALG_ F# (u2 :: Float#) -> case u1 of { _ALG_ F# (u3 :: Float#) -> case _#_ divideFloat# [] [u2, u3] of { _PRIM_ (u4 :: Float#) -> _!_ F# [] [u4] }; _NO_DEFLT_ }; _NO_DEFLT_ } _N_ },
+ recip = { _A_ 1 _U_ 1 _N_ _S_ "U(P)" {_A_ 1 _U_ 2 _N_ _N_ _F_ _IF_ARGS_ 0 1 X 3 \ (u0 :: Float#) -> case _#_ divideFloat# [] [1.0000000000000000#, u0] of { _PRIM_ (u1 :: Float#) -> _!_ F# [] [u1] } _N_} _F_ _IF_ARGS_ 0 1 C 4 \ (u0 :: Float) -> case u0 of { _ALG_ F# (u1 :: Float#) -> case _#_ divideFloat# [] [1.0000000000000000#, u1] of { _PRIM_ (u2 :: Float#) -> _!_ F# [] [u2] }; _NO_DEFLT_ } _N_ },
+ fromRational = { _A_ 1 _U_ 2 _N_ _N_ _N_ _N_ } #-}
instance Num Float
{-# GHC_PRAGMA _M_ PreludeCore {-dfun-} _A_ 0 _N_ _N_ _N_ _F_ _IF_ARGS_ 0 0 X 11 _!_ _TUP_10 [{{Eq Float}}, {{Text Float}}, (Float -> Float -> Float), (Float -> Float -> Float), (Float -> Float -> Float), (Float -> Float), (Float -> Float), (Float -> Float), (Integer -> Float), (Int -> Float)] [_DFUN_ Eq (Float), _DFUN_ Text (Float), _CONSTM_ Num (+) (Float), _CONSTM_ Num (-) (Float), _CONSTM_ Num (*) (Float), _CONSTM_ Num negate (Float), _CONSTM_ Num abs (Float), _CONSTM_ Num signum (Float), _CONSTM_ Num fromInteger (Float), _CONSTM_ Num fromInt (Float)] _N_
- (+) = _A_ 2 _U_ 11 _N_ _S_ "U(P)U(P)" {_A_ 2 _U_ 22 _N_ _N_ _F_ _IF_ARGS_ 0 2 XX 3 \ (u0 :: Float#) (u1 :: Float#) -> case _#_ plusFloat# [] [u0, u1] of { _PRIM_ (u2 :: Float#) -> _!_ F# [] [u2] } _N_} _F_ _IF_ARGS_ 0 2 CC 5 \ (u0 :: Float) (u1 :: Float) -> case u0 of { _ALG_ F# (u2 :: Float#) -> case u1 of { _ALG_ F# (u3 :: Float#) -> case _#_ plusFloat# [] [u2, u3] of { _PRIM_ (u4 :: Float#) -> _!_ F# [] [u4] }; _NO_DEFLT_ }; _NO_DEFLT_ } _N_,
- (-) = _A_ 2 _U_ 11 _N_ _S_ "U(P)U(P)" {_A_ 2 _U_ 22 _N_ _N_ _F_ _IF_ARGS_ 0 2 XX 3 \ (u0 :: Float#) (u1 :: Float#) -> case _#_ minusFloat# [] [u0, u1] of { _PRIM_ (u2 :: Float#) -> _!_ F# [] [u2] } _N_} _F_ _IF_ARGS_ 0 2 CC 5 \ (u0 :: Float) (u1 :: Float) -> case u0 of { _ALG_ F# (u2 :: Float#) -> case u1 of { _ALG_ F# (u3 :: Float#) -> case _#_ minusFloat# [] [u2, u3] of { _PRIM_ (u4 :: Float#) -> _!_ F# [] [u4] }; _NO_DEFLT_ }; _NO_DEFLT_ } _N_,
- (*) = _A_ 2 _U_ 11 _N_ _S_ "U(P)U(P)" {_A_ 2 _U_ 22 _N_ _N_ _F_ _IF_ARGS_ 0 2 XX 3 \ (u0 :: Float#) (u1 :: Float#) -> case _#_ timesFloat# [] [u0, u1] of { _PRIM_ (u2 :: Float#) -> _!_ F# [] [u2] } _N_} _F_ _IF_ARGS_ 0 2 CC 5 \ (u0 :: Float) (u1 :: Float) -> case u0 of { _ALG_ F# (u2 :: Float#) -> case u1 of { _ALG_ F# (u3 :: Float#) -> case _#_ timesFloat# [] [u2, u3] of { _PRIM_ (u4 :: Float#) -> _!_ F# [] [u4] }; _NO_DEFLT_ }; _NO_DEFLT_ } _N_,
- negate = _A_ 1 _U_ 1 _N_ _S_ "U(P)" {_A_ 1 _U_ 2 _N_ _N_ _F_ _IF_ARGS_ 0 1 X 3 \ (u0 :: Float#) -> case _#_ negateFloat# [] [u0] of { _PRIM_ (u1 :: Float#) -> _!_ F# [] [u1] } _N_} _F_ _IF_ARGS_ 0 1 C 4 \ (u0 :: Float) -> case u0 of { _ALG_ F# (u1 :: Float#) -> case _#_ negateFloat# [] [u1] of { _PRIM_ (u2 :: Float#) -> _!_ F# [] [u2] }; _NO_DEFLT_ } _N_,
- abs = _A_ 1 _U_ 1 _N_ _S_ "U(P)" {_A_ 1 _U_ 2 _N_ _N_ _N_ _N_} _N_ _N_,
- signum = _A_ 1 _U_ 1 _N_ _S_ "U(P)" {_A_ 1 _U_ 2 _N_ _N_ _N_ _N_} _N_ _N_,
- fromInteger = _A_ 1 _U_ 1 _N_ _S_ "U(PPP)" {_A_ 3 _U_ 222 _N_ _N_ _F_ _IF_ARGS_ 0 3 XXX 3 \ (u0 :: Int#) (u1 :: Int#) (u2 :: ByteArray#) -> case _#_ encodeFloat# [] [u0, u1, u2, 0#] of { _PRIM_ (u3 :: Float#) -> _!_ F# [] [u3] } _N_} _F_ _IF_ARGS_ 0 1 C 4 \ (u0 :: Integer) -> case u0 of { _ALG_ J# (u1 :: Int#) (u2 :: Int#) (u3 :: ByteArray#) -> case _#_ encodeFloat# [] [u1, u2, u3, 0#] of { _PRIM_ (u4 :: Float#) -> _!_ F# [] [u4] }; _NO_DEFLT_ } _N_,
- fromInt = _A_ 1 _U_ 1 _N_ _S_ "U(P)" {_A_ 1 _U_ 2 _N_ _N_ _F_ _IF_ARGS_ 0 1 X 3 \ (u0 :: Int#) -> case _#_ int2Float# [] [u0] of { _PRIM_ (u1 :: Float#) -> _!_ F# [] [u1] } _N_} _F_ _IF_ARGS_ 0 1 C 4 \ (u0 :: Int) -> case u0 of { _ALG_ I# (u1 :: Int#) -> case _#_ int2Float# [] [u1] of { _PRIM_ (u2 :: Float#) -> _!_ F# [] [u2] }; _NO_DEFLT_ } _N_ #-}
+ (+) = { _A_ 2 _U_ 11 _N_ _S_ "U(P)U(P)" {_A_ 2 _U_ 22 _N_ _N_ _F_ _IF_ARGS_ 0 2 XX 3 \ (u0 :: Float#) (u1 :: Float#) -> case _#_ plusFloat# [] [u0, u1] of { _PRIM_ (u2 :: Float#) -> _!_ F# [] [u2] } _N_} _F_ _IF_ARGS_ 0 2 CC 5 \ (u0 :: Float) (u1 :: Float) -> case u0 of { _ALG_ F# (u2 :: Float#) -> case u1 of { _ALG_ F# (u3 :: Float#) -> case _#_ plusFloat# [] [u2, u3] of { _PRIM_ (u4 :: Float#) -> _!_ F# [] [u4] }; _NO_DEFLT_ }; _NO_DEFLT_ } _N_ },
+ (-) = { _A_ 2 _U_ 11 _N_ _S_ "U(P)U(P)" {_A_ 2 _U_ 22 _N_ _N_ _F_ _IF_ARGS_ 0 2 XX 3 \ (u0 :: Float#) (u1 :: Float#) -> case _#_ minusFloat# [] [u0, u1] of { _PRIM_ (u2 :: Float#) -> _!_ F# [] [u2] } _N_} _F_ _IF_ARGS_ 0 2 CC 5 \ (u0 :: Float) (u1 :: Float) -> case u0 of { _ALG_ F# (u2 :: Float#) -> case u1 of { _ALG_ F# (u3 :: Float#) -> case _#_ minusFloat# [] [u2, u3] of { _PRIM_ (u4 :: Float#) -> _!_ F# [] [u4] }; _NO_DEFLT_ }; _NO_DEFLT_ } _N_ },
+ (*) = { _A_ 2 _U_ 11 _N_ _S_ "U(P)U(P)" {_A_ 2 _U_ 22 _N_ _N_ _F_ _IF_ARGS_ 0 2 XX 3 \ (u0 :: Float#) (u1 :: Float#) -> case _#_ timesFloat# [] [u0, u1] of { _PRIM_ (u2 :: Float#) -> _!_ F# [] [u2] } _N_} _F_ _IF_ARGS_ 0 2 CC 5 \ (u0 :: Float) (u1 :: Float) -> case u0 of { _ALG_ F# (u2 :: Float#) -> case u1 of { _ALG_ F# (u3 :: Float#) -> case _#_ timesFloat# [] [u2, u3] of { _PRIM_ (u4 :: Float#) -> _!_ F# [] [u4] }; _NO_DEFLT_ }; _NO_DEFLT_ } _N_ },
+ negate = { _A_ 1 _U_ 1 _N_ _S_ "U(P)" {_A_ 1 _U_ 2 _N_ _N_ _F_ _IF_ARGS_ 0 1 X 3 \ (u0 :: Float#) -> case _#_ negateFloat# [] [u0] of { _PRIM_ (u1 :: Float#) -> _!_ F# [] [u1] } _N_} _F_ _IF_ARGS_ 0 1 C 4 \ (u0 :: Float) -> case u0 of { _ALG_ F# (u1 :: Float#) -> case _#_ negateFloat# [] [u1] of { _PRIM_ (u2 :: Float#) -> _!_ F# [] [u2] }; _NO_DEFLT_ } _N_ },
+ abs = { _A_ 1 _U_ 1 _N_ _S_ "U(P)" {_A_ 1 _U_ 2 _N_ _N_ _N_ _N_} _N_ _N_ },
+ signum = { _A_ 1 _U_ 1 _N_ _S_ "U(P)" {_A_ 1 _U_ 2 _N_ _N_ _N_ _N_} _N_ _N_ },
+ fromInteger = { _A_ 1 _U_ 1 _N_ _S_ "U(PPP)" {_A_ 3 _U_ 222 _N_ _N_ _F_ _IF_ARGS_ 0 3 XXX 3 \ (u0 :: Int#) (u1 :: Int#) (u2 :: ByteArray#) -> case _#_ encodeFloat# [] [u0, u1, u2, 0#] of { _PRIM_ (u3 :: Float#) -> _!_ F# [] [u3] } _N_} _F_ _IF_ARGS_ 0 1 C 4 \ (u0 :: Integer) -> case u0 of { _ALG_ J# (u1 :: Int#) (u2 :: Int#) (u3 :: ByteArray#) -> case _#_ encodeFloat# [] [u1, u2, u3, 0#] of { _PRIM_ (u4 :: Float#) -> _!_ F# [] [u4] }; _NO_DEFLT_ } _N_ },
+ fromInt = { _A_ 1 _U_ 1 _N_ _S_ "U(P)" {_A_ 1 _U_ 2 _N_ _N_ _F_ _IF_ARGS_ 0 1 X 3 \ (u0 :: Int#) -> case _#_ int2Float# [] [u0] of { _PRIM_ (u1 :: Float#) -> _!_ F# [] [u1] } _N_} _F_ _IF_ARGS_ 0 1 C 4 \ (u0 :: Int) -> case u0 of { _ALG_ I# (u1 :: Int#) -> case _#_ int2Float# [] [u1] of { _PRIM_ (u2 :: Float#) -> _!_ F# [] [u2] }; _NO_DEFLT_ } _N_ } #-}
instance Ord Float
{-# GHC_PRAGMA _M_ PreludeCore {-dfun-} _A_ 0 _N_ _N_ _N_ _F_ _IF_ARGS_ 0 0 X 9 _!_ _TUP_8 [{{Eq Float}}, (Float -> Float -> Bool), (Float -> Float -> Bool), (Float -> Float -> Bool), (Float -> Float -> Bool), (Float -> Float -> Float), (Float -> Float -> Float), (Float -> Float -> _CMP_TAG)] [_DFUN_ Eq (Float), _CONSTM_ Ord (<) (Float), _CONSTM_ Ord (<=) (Float), _CONSTM_ Ord (>=) (Float), _CONSTM_ Ord (>) (Float), _CONSTM_ Ord max (Float), _CONSTM_ Ord min (Float), _CONSTM_ Ord _tagCmp (Float)] _N_
- (<) = _A_ 2 _U_ 11 _N_ _S_ "U(P)U(P)" {_A_ 2 _U_ 22 _N_ _N_ _F_ _IF_ARGS_ 0 2 XX 1 \ (u0 :: Float#) (u1 :: Float#) -> _#_ ltFloat# [] [u0, u1] _N_} _F_ _IF_ARGS_ 0 2 CC 3 \ (u0 :: Float) (u1 :: Float) -> case u0 of { _ALG_ F# (u2 :: Float#) -> case u1 of { _ALG_ F# (u3 :: Float#) -> _#_ ltFloat# [] [u2, u3]; _NO_DEFLT_ }; _NO_DEFLT_ } _N_,
- (<=) = _A_ 2 _U_ 11 _N_ _S_ "U(P)U(P)" {_A_ 2 _U_ 22 _N_ _N_ _F_ _IF_ARGS_ 0 2 XX 1 \ (u0 :: Float#) (u1 :: Float#) -> _#_ leFloat# [] [u0, u1] _N_} _F_ _IF_ARGS_ 0 2 CC 3 \ (u0 :: Float) (u1 :: Float) -> case u0 of { _ALG_ F# (u2 :: Float#) -> case u1 of { _ALG_ F# (u3 :: Float#) -> _#_ leFloat# [] [u2, u3]; _NO_DEFLT_ }; _NO_DEFLT_ } _N_,
- (>=) = _A_ 2 _U_ 11 _N_ _S_ "U(P)U(P)" {_A_ 2 _U_ 22 _N_ _N_ _F_ _IF_ARGS_ 0 2 XX 1 \ (u0 :: Float#) (u1 :: Float#) -> _#_ geFloat# [] [u0, u1] _N_} _F_ _IF_ARGS_ 0 2 CC 3 \ (u0 :: Float) (u1 :: Float) -> case u0 of { _ALG_ F# (u2 :: Float#) -> case u1 of { _ALG_ F# (u3 :: Float#) -> _#_ geFloat# [] [u2, u3]; _NO_DEFLT_ }; _NO_DEFLT_ } _N_,
- (>) = _A_ 2 _U_ 11 _N_ _S_ "U(P)U(P)" {_A_ 2 _U_ 22 _N_ _N_ _F_ _IF_ARGS_ 0 2 XX 1 \ (u0 :: Float#) (u1 :: Float#) -> _#_ gtFloat# [] [u0, u1] _N_} _F_ _IF_ARGS_ 0 2 CC 3 \ (u0 :: Float) (u1 :: Float) -> case u0 of { _ALG_ F# (u2 :: Float#) -> case u1 of { _ALG_ F# (u3 :: Float#) -> _#_ gtFloat# [] [u2, u3]; _NO_DEFLT_ }; _NO_DEFLT_ } _N_,
- max = _A_ 2 _U_ 11 _N_ _S_ "U(P)U(P)" {_A_ 2 _U_ 22 _N_ _N_ _N_ _N_} _N_ _N_,
- min = _A_ 2 _U_ 11 _N_ _S_ "U(P)U(P)" {_A_ 2 _U_ 22 _N_ _N_ _N_ _N_} _N_ _N_,
- _tagCmp = _A_ 2 _U_ 11 _N_ _S_ "U(P)U(P)" {_A_ 2 _U_ 22 _N_ _N_ _N_ _N_} _N_ _N_ #-}
+ (<) = { _A_ 2 _U_ 11 _N_ _S_ "U(P)U(P)" {_A_ 2 _U_ 22 _N_ _N_ _F_ _IF_ARGS_ 0 2 XX 1 \ (u0 :: Float#) (u1 :: Float#) -> _#_ ltFloat# [] [u0, u1] _N_} _F_ _IF_ARGS_ 0 2 CC 3 \ (u0 :: Float) (u1 :: Float) -> case u0 of { _ALG_ F# (u2 :: Float#) -> case u1 of { _ALG_ F# (u3 :: Float#) -> _#_ ltFloat# [] [u2, u3]; _NO_DEFLT_ }; _NO_DEFLT_ } _N_ },
+ (<=) = { _A_ 2 _U_ 11 _N_ _S_ "U(P)U(P)" {_A_ 2 _U_ 22 _N_ _N_ _F_ _IF_ARGS_ 0 2 XX 1 \ (u0 :: Float#) (u1 :: Float#) -> _#_ leFloat# [] [u0, u1] _N_} _F_ _IF_ARGS_ 0 2 CC 3 \ (u0 :: Float) (u1 :: Float) -> case u0 of { _ALG_ F# (u2 :: Float#) -> case u1 of { _ALG_ F# (u3 :: Float#) -> _#_ leFloat# [] [u2, u3]; _NO_DEFLT_ }; _NO_DEFLT_ } _N_ },
+ (>=) = { _A_ 2 _U_ 11 _N_ _S_ "U(P)U(P)" {_A_ 2 _U_ 22 _N_ _N_ _F_ _IF_ARGS_ 0 2 XX 1 \ (u0 :: Float#) (u1 :: Float#) -> _#_ geFloat# [] [u0, u1] _N_} _F_ _IF_ARGS_ 0 2 CC 3 \ (u0 :: Float) (u1 :: Float) -> case u0 of { _ALG_ F# (u2 :: Float#) -> case u1 of { _ALG_ F# (u3 :: Float#) -> _#_ geFloat# [] [u2, u3]; _NO_DEFLT_ }; _NO_DEFLT_ } _N_ },
+ (>) = { _A_ 2 _U_ 11 _N_ _S_ "U(P)U(P)" {_A_ 2 _U_ 22 _N_ _N_ _F_ _IF_ARGS_ 0 2 XX 1 \ (u0 :: Float#) (u1 :: Float#) -> _#_ gtFloat# [] [u0, u1] _N_} _F_ _IF_ARGS_ 0 2 CC 3 \ (u0 :: Float) (u1 :: Float) -> case u0 of { _ALG_ F# (u2 :: Float#) -> case u1 of { _ALG_ F# (u3 :: Float#) -> _#_ gtFloat# [] [u2, u3]; _NO_DEFLT_ }; _NO_DEFLT_ } _N_ },
+ max = { _A_ 2 _U_ 11 _N_ _S_ "U(P)U(P)" {_A_ 2 _U_ 22 _N_ _N_ _N_ _N_} _N_ _N_ },
+ min = { _A_ 2 _U_ 11 _N_ _S_ "U(P)U(P)" {_A_ 2 _U_ 22 _N_ _N_ _N_ _N_} _N_ _N_ },
+ _tagCmp = { _A_ 2 _U_ 11 _N_ _S_ "U(P)U(P)" {_A_ 2 _U_ 22 _N_ _N_ _N_ _N_} _N_ _N_ } #-}
instance Real Float
{-# GHC_PRAGMA _M_ PreludeCore {-dfun-} _A_ 0 _N_ _N_ _N_ _F_ _IF_ARGS_ 0 0 X 4 _!_ _TUP_3 [{{Num Float}}, {{Enum Float}}, (Float -> Ratio Integer)] [_DFUN_ Num (Float), _DFUN_ Enum (Float), _CONSTM_ Real toRational (Float)] _N_
- toRational = _A_ 1 _U_ 1 _N_ _S_ "U(P)" {_A_ 1 _U_ 2 _N_ _N_ _N_ _N_} _N_ _N_ #-}
+ toRational = { _A_ 1 _U_ 1 _N_ _S_ "U(P)" {_A_ 1 _U_ 2 _N_ _N_ _N_ _N_} _N_ _N_ } #-}
instance RealFloat Float
{-# GHC_PRAGMA _M_ PreludeCore {-dfun-} _A_ 0 _N_ _N_ _N_ _F_ _IF_ARGS_ 0 0 X 11 _!_ _TUP_10 [{{RealFrac Float}}, {{Floating Float}}, (Float -> Integer), (Float -> Int), (Float -> (Int, Int)), (Float -> (Integer, Int)), (Integer -> Int -> Float), (Float -> Int), (Float -> Float), (Int -> Float -> Float)] [_DFUN_ RealFrac (Float), _DFUN_ Floating (Float), _CONSTM_ RealFloat floatRadix (Float), _CONSTM_ RealFloat floatDigits (Float), _CONSTM_ RealFloat floatRange (Float), _CONSTM_ RealFloat decodeFloat (Float), _CONSTM_ RealFloat encodeFloat (Float), _CONSTM_ RealFloat exponent (Float), _CONSTM_ RealFloat significand (Float), _CONSTM_ RealFloat scaleFloat (Float)] _N_
- floatRadix = _A_ 1 _U_ 0 _N_ _S_ "A" {_A_ 0 _N_ _N_ _N_ _F_ _IF_ARGS_ 0 0 X 1 _#_ int2Integer# [] [2#] _N_} _N_ _N_,
- floatDigits = _A_ 1 _U_ 0 _N_ _S_ "A" {_A_ 0 _N_ _N_ _N_ _F_ _IF_ARGS_ 0 0 X 2 _!_ I# [] [24#] _N_} _F_ _IF_ARGS_ 0 1 X 2 \ (u0 :: Float) -> _!_ I# [] [24#] _N_,
- floatRange = _A_ 1 _U_ 0 _N_ _S_ "A" {_A_ 0 _N_ _N_ _N_ _N_ _N_} _N_ _N_,
- decodeFloat = _A_ 1 _U_ 1 _N_ _S_ "U(P)" {_A_ 1 _U_ 2 _N_ _N_ _N_ _N_} _N_ _N_,
- encodeFloat = _A_ 2 _U_ 11 _N_ _S_ "U(PPP)U(P)" {_A_ 4 _U_ 2222 _N_ _N_ _F_ _IF_ARGS_ 0 4 XXXX 3 \ (u0 :: Int#) (u1 :: Int#) (u2 :: ByteArray#) (u3 :: Int#) -> case _#_ encodeFloat# [] [u0, u1, u2, u3] of { _PRIM_ (u4 :: Float#) -> _!_ F# [] [u4] } _N_} _F_ _IF_ARGS_ 0 2 CC 5 \ (u0 :: Integer) (u1 :: Int) -> case u0 of { _ALG_ J# (u2 :: Int#) (u3 :: Int#) (u4 :: ByteArray#) -> case u1 of { _ALG_ I# (u5 :: Int#) -> case _#_ encodeFloat# [] [u2, u3, u4, u5] of { _PRIM_ (u6 :: Float#) -> _!_ F# [] [u6] }; _NO_DEFLT_ }; _NO_DEFLT_ } _N_,
- exponent = _A_ 1 _U_ 2 _N_ _N_ _N_ _N_,
- significand = _A_ 1 _U_ 2 _N_ _N_ _N_ _N_,
- scaleFloat = _A_ 2 _U_ 22 _N_ _N_ _N_ _N_ #-}
+ floatRadix = { _A_ 1 _U_ 0 _N_ _S_ "A" {_A_ 0 _N_ _N_ _N_ _N_ _N_} _N_ _N_ },
+ floatDigits = { _A_ 1 _U_ 0 _N_ _S_ "A" {_A_ 0 _N_ _N_ _N_ _F_ _IF_ARGS_ 0 0 X 2 _!_ I# [] [24#] _N_} _F_ _IF_ARGS_ 0 1 X 2 \ (u0 :: Float) -> _!_ I# [] [24#] _N_ },
+ floatRange = { _A_ 1 _U_ 0 _N_ _S_ "A" {_A_ 0 _N_ _N_ _N_ _N_ _N_} _N_ _N_ },
+ decodeFloat = { _A_ 1 _U_ 1 _N_ _S_ "U(P)" {_A_ 1 _U_ 2 _N_ _N_ _N_ _N_} _N_ _N_ },
+ encodeFloat = { _A_ 2 _U_ 11 _N_ _S_ "U(PPP)U(P)" {_A_ 4 _U_ 2222 _N_ _N_ _F_ _IF_ARGS_ 0 4 XXXX 3 \ (u0 :: Int#) (u1 :: Int#) (u2 :: ByteArray#) (u3 :: Int#) -> case _#_ encodeFloat# [] [u0, u1, u2, u3] of { _PRIM_ (u4 :: Float#) -> _!_ F# [] [u4] } _N_} _F_ _IF_ARGS_ 0 2 CC 5 \ (u0 :: Integer) (u1 :: Int) -> case u0 of { _ALG_ J# (u2 :: Int#) (u3 :: Int#) (u4 :: ByteArray#) -> case u1 of { _ALG_ I# (u5 :: Int#) -> case _#_ encodeFloat# [] [u2, u3, u4, u5] of { _PRIM_ (u6 :: Float#) -> _!_ F# [] [u6] }; _NO_DEFLT_ }; _NO_DEFLT_ } _N_ },
+ exponent = { _A_ 1 _U_ 1 _N_ _S_ "U(P)" {_A_ 1 _U_ 2 _N_ _N_ _N_ _N_} _N_ _N_ },
+ significand = { _A_ 1 _U_ 1 _N_ _S_ "U(P)" {_A_ 1 _U_ 2 _N_ _N_ _N_ _N_} _N_ _N_ },
+ scaleFloat = { _A_ 2 _U_ 11 _N_ _S_ "U(P)U(P)" {_A_ 2 _U_ 22 _N_ _N_ _N_ _N_} _N_ _N_ } #-}
instance RealFrac Float
{-# GHC_PRAGMA _M_ PreludeCore {-dfun-} _A_ 0 _N_ _N_ _N_ _F_ _IF_ARGS_ 0 0 X 8 _!_ _TUP_7 [{{Real Float}}, {{Fractional Float}}, _forall_ a$z1 =>{{Integral a$z1}} -> (Float -> (a$z1, Float)), _forall_ a$z1 =>{{Integral a$z1}} -> (Float -> a$z1), _forall_ a$z1 =>{{Integral a$z1}} -> (Float -> a$z1), _forall_ a$z1 =>{{Integral a$z1}} -> (Float -> a$z1), _forall_ a$z1 =>{{Integral a$z1}} -> (Float -> a$z1)] [_DFUN_ Real (Float), _DFUN_ Fractional (Float), _CONSTM_ RealFrac properFraction (Float), _CONSTM_ RealFrac truncate (Float), _CONSTM_ RealFrac round (Float), _CONSTM_ RealFrac ceiling (Float), _CONSTM_ RealFrac floor (Float)] _N_
- properFraction = _A_ 1 _U_ 22 _N_ _N_ _N_ _N_,
- truncate = _A_ 1 _U_ 22 _N_ _N_ _N_ _N_,
- round = _A_ 1 _U_ 22 _N_ _N_ _N_ _N_,
- ceiling = _A_ 1 _U_ 22 _N_ _N_ _N_ _N_,
- floor = _A_ 1 _U_ 22 _N_ _N_ _N_ _N_ #-}
+ properFraction = { _A_ 1 _U_ 11 _N_ _N_ _N_ _SPECIALISE_ [ Int ] 1 { _A_ 1 _U_ 1 _N_ _S_ "U(P)" {_A_ 1 _U_ 2 _N_ _N_ _N_ _N_} _N_ _N_ }, [ Integer ] 1 { _A_ 1 _U_ 1 _N_ _S_ "U(P)" {_A_ 1 _U_ 2 _N_ _N_ _N_ _N_} _N_ _N_ } },
+ truncate = { _A_ 1 _U_ 11 _N_ _N_ _N_ _SPECIALISE_ [ Int ] 1 { _A_ 1 _U_ 1 _N_ _S_ "U(P)" {_A_ 1 _U_ 2 _N_ _N_ _F_ _IF_ARGS_ 0 1 X 4 \ (u0 :: Float#) -> case _APP_ _WRKR_ _SPEC_ _CONSTM_ RealFrac properFraction (Float) [ (Int) ] [ u0 ] of { _ALG_ _TUP_2 (u1 :: Int) (u2 :: Float) -> u1; _NO_DEFLT_ } _N_} _F_ _IF_ARGS_ 0 1 X 4 \ (u0 :: Float) -> case _APP_ _SPEC_ _CONSTM_ RealFrac properFraction (Float) [ (Int) ] [ u0 ] of { _ALG_ _TUP_2 (u1 :: Int) (u2 :: Float) -> u1; _NO_DEFLT_ } _N_ }, [ Integer ] 1 { _A_ 1 _U_ 1 _N_ _S_ "U(P)" {_A_ 1 _U_ 2 _N_ _N_ _F_ _IF_ARGS_ 0 1 X 4 \ (u0 :: Float#) -> case _APP_ _WRKR_ _SPEC_ _CONSTM_ RealFrac properFraction (Float) [ (Integer) ] [ u0 ] of { _ALG_ _TUP_2 (u1 :: Integer) (u2 :: Float) -> u1; _NO_DEFLT_ } _N_} _F_ _IF_ARGS_ 0 1 X 4 \ (u0 :: Float) -> case _APP_ _SPEC_ _CONSTM_ RealFrac properFraction (Float) [ (Integer) ] [ u0 ] of { _ALG_ _TUP_2 (u1 :: Integer) (u2 :: Float) -> u1; _NO_DEFLT_ } _N_ } },
+ round = { _A_ 1 _U_ 21 _N_ _N_ _N_ _SPECIALISE_ [ Int ] 1 { _A_ 1 _U_ 1 _N_ _S_ "U(P)" {_A_ 1 _U_ 2 _N_ _N_ _N_ _N_} _N_ _N_ }, [ Integer ] 1 { _A_ 1 _U_ 1 _N_ _S_ "U(P)" {_A_ 1 _U_ 2 _N_ _N_ _N_ _N_} _N_ _N_ } },
+ ceiling = { _A_ 1 _U_ 21 _N_ _N_ _N_ _SPECIALISE_ [ Int ] 1 { _A_ 1 _U_ 1 _N_ _S_ "U(P)" {_A_ 1 _U_ 2 _N_ _N_ _N_ _N_} _N_ _N_ }, [ Integer ] 1 { _A_ 1 _U_ 1 _N_ _S_ "U(P)" {_A_ 1 _U_ 2 _N_ _N_ _N_ _N_} _N_ _N_ } },
+ floor = { _A_ 1 _U_ 21 _N_ _N_ _N_ _SPECIALISE_ [ Int ] 1 { _A_ 1 _U_ 1 _N_ _S_ "U(P)" {_A_ 1 _U_ 2 _N_ _N_ _N_ _N_} _N_ _N_ }, [ Integer ] 1 { _A_ 1 _U_ 1 _N_ _S_ "U(P)" {_A_ 1 _U_ 2 _N_ _N_ _N_ _N_} _N_ _N_ } } #-}
instance Text Float
{-# GHC_PRAGMA _M_ PreludeCore {-dfun-} _A_ 0 _N_ _N_ _N_ _F_ _IF_ARGS_ 0 0 X 5 _!_ _TUP_4 [(Int -> [Char] -> [(Float, [Char])]), (Int -> Float -> [Char] -> [Char]), ([Char] -> [([Float], [Char])]), ([Float] -> [Char] -> [Char])] [_CONSTM_ Text readsPrec (Float), _CONSTM_ Text showsPrec (Float), _CONSTM_ Text readList (Float), _CONSTM_ Text showList (Float)] _N_
- readsPrec = _A_ 2 _U_ 02 _N_ _S_ "AL" {_A_ 1 _U_ 2 _N_ _N_ _N_ _N_} _N_ _N_,
- showsPrec = _A_ 1 _U_ 222 _N_ _N_ _N_ _N_,
- readList = _A_ 0 _U_ 2 _N_ _N_ _N_ _N_,
- showList = _A_ 0 _U_ 12 _N_ _N_ _N_ _N_ #-}
+ readsPrec = { _A_ 2 _U_ 02 _N_ _S_ "AL" {_A_ 1 _U_ 2 _N_ _N_ _N_ _N_} _N_ _N_ },
+ showsPrec = { _A_ 1 _U_ 222 _N_ _N_ _N_ _N_ },
+ readList = { _A_ 0 _U_ 2 _N_ _N_ _N_ _N_ },
+ showList = { _A_ 0 _U_ 12 _N_ _N_ _N_ _N_ } #-}
instance _CCallable Float
{-# GHC_PRAGMA _M_ PreludeCore {-dfun-} _A_ 0 _N_ _N_ _N_ _F_ _IF_ARGS_ 0 0 X 1 _!_ _TUP_0 [] [] _N_ #-}
instance _CReturnable Float
-{-# GHC_PRAGMA INTERFACE VERSION 5 #-}
+{-# GHC_PRAGMA INTERFACE VERSION 6 #-}
interface PreludeCore where
import PreludeBuiltin(Float(..))
instance Enum Float
{-# GHC_PRAGMA _M_ PreludeCore {-dfun-} _A_ 0 _N_ _N_ _N_ _F_ _IF_ARGS_ 0 0 X 6 _!_ _TUP_5 [{{Ord Float}}, (Float -> [Float]), (Float -> Float -> [Float]), (Float -> Float -> [Float]), (Float -> Float -> Float -> [Float])] [_DFUN_ Ord (Float), _CONSTM_ Enum enumFrom (Float), _CONSTM_ Enum enumFromThen (Float), _CONSTM_ Enum enumFromTo (Float), _CONSTM_ Enum enumFromThenTo (Float)] _N_
- enumFrom = _A_ 1 _U_ 2 _N_ _N_ _N_ _N_,
- enumFromThen = _A_ 2 _U_ 21 _N_ _N_ _N_ _N_,
- enumFromTo = _A_ 2 _U_ 22 _N_ _N_ _N_ _N_,
- enumFromThenTo = _A_ 3 _U_ 222 _N_ _N_ _N_ _N_ #-}
+ enumFrom = { _A_ 1 _U_ 2 _N_ _N_ _N_ _N_ },
+ enumFromThen = { _A_ 2 _U_ 21 _N_ _N_ _N_ _N_ },
+ enumFromTo = { _A_ 2 _U_ 22 _N_ _N_ _N_ _N_ },
+ enumFromThenTo = { _A_ 3 _U_ 222 _N_ _N_ _N_ _N_ } #-}
instance Eq Float
{-# GHC_PRAGMA _M_ PreludeCore {-dfun-} _A_ 0 _N_ _N_ _N_ _F_ _IF_ARGS_ 0 0 X 3 _!_ _TUP_2 [(Float -> Float -> Bool), (Float -> Float -> Bool)] [_CONSTM_ Eq (==) (Float), _CONSTM_ Eq (/=) (Float)] _N_
- (==) = _A_ 2 _U_ 11 _N_ _S_ "U(P)U(P)" {_A_ 2 _U_ 22 _N_ _N_ _F_ _IF_ARGS_ 0 2 XX 1 \ (u0 :: Float#) (u1 :: Float#) -> _#_ eqFloat# [] [u0, u1] _N_} _F_ _IF_ARGS_ 0 2 CC 3 \ (u0 :: Float) (u1 :: Float) -> case u0 of { _ALG_ F# (u2 :: Float#) -> case u1 of { _ALG_ F# (u3 :: Float#) -> _#_ eqFloat# [] [u2, u3]; _NO_DEFLT_ }; _NO_DEFLT_ } _N_,
- (/=) = _A_ 2 _U_ 11 _N_ _S_ "U(P)U(P)" {_A_ 2 _U_ 22 _N_ _N_ _F_ _IF_ARGS_ 0 2 XX 1 \ (u0 :: Float#) (u1 :: Float#) -> _#_ neFloat# [] [u0, u1] _N_} _F_ _IF_ARGS_ 0 2 CC 3 \ (u0 :: Float) (u1 :: Float) -> case u0 of { _ALG_ F# (u2 :: Float#) -> case u1 of { _ALG_ F# (u3 :: Float#) -> _#_ neFloat# [] [u2, u3]; _NO_DEFLT_ }; _NO_DEFLT_ } _N_ #-}
+ (==) = { _A_ 2 _U_ 11 _N_ _S_ "U(P)U(P)" {_A_ 2 _U_ 22 _N_ _N_ _F_ _IF_ARGS_ 0 2 XX 1 \ (u0 :: Float#) (u1 :: Float#) -> _#_ eqFloat# [] [u0, u1] _N_} _F_ _IF_ARGS_ 0 2 CC 3 \ (u0 :: Float) (u1 :: Float) -> case u0 of { _ALG_ F# (u2 :: Float#) -> case u1 of { _ALG_ F# (u3 :: Float#) -> _#_ eqFloat# [] [u2, u3]; _NO_DEFLT_ }; _NO_DEFLT_ } _N_ },
+ (/=) = { _A_ 2 _U_ 11 _N_ _S_ "U(P)U(P)" {_A_ 2 _U_ 22 _N_ _N_ _F_ _IF_ARGS_ 0 2 XX 1 \ (u0 :: Float#) (u1 :: Float#) -> _#_ neFloat# [] [u0, u1] _N_} _F_ _IF_ARGS_ 0 2 CC 3 \ (u0 :: Float) (u1 :: Float) -> case u0 of { _ALG_ F# (u2 :: Float#) -> case u1 of { _ALG_ F# (u3 :: Float#) -> _#_ neFloat# [] [u2, u3]; _NO_DEFLT_ }; _NO_DEFLT_ } _N_ } #-}
instance Floating Float
{-# GHC_PRAGMA _M_ PreludeCore {-dfun-} _A_ 0 _N_ _N_ _N_ _F_ _IF_ARGS_ 0 0 X 20 _!_ _TUP_19 [{{Fractional Float}}, Float, (Float -> Float), (Float -> Float), (Float -> Float), (Float -> Float -> Float), (Float -> Float -> Float), (Float -> Float), (Float -> Float), (Float -> Float), (Float -> Float), (Float -> Float), (Float -> Float), (Float -> Float), (Float -> Float), (Float -> Float), (Float -> Float), (Float -> Float), (Float -> Float)] [_DFUN_ Fractional (Float), _CONSTM_ Floating pi (Float), _CONSTM_ Floating exp (Float), _CONSTM_ Floating log (Float), _CONSTM_ Floating sqrt (Float), _CONSTM_ Floating (**) (Float), _CONSTM_ Floating logBase (Float), _CONSTM_ Floating sin (Float), _CONSTM_ Floating cos (Float), _CONSTM_ Floating tan (Float), _CONSTM_ Floating asin (Float), _CONSTM_ Floating acos (Float), _CONSTM_ Floating atan (Float), _CONSTM_ Floating sinh (Float), _CONSTM_ Floating cosh (Float), _CONSTM_ Floating tanh (Float), _CONSTM_ Floating asinh (Float), _CONSTM_ Floating acosh (Float), _CONSTM_ Floating atanh (Float)] _N_
- pi = _A_ 0 _N_ _N_ _N_ _F_ _IF_ARGS_ 0 0 X 2 _!_ F# [] [3.1415926535897931#] _N_,
- exp = _A_ 1 _U_ 1 _N_ _S_ "U(P)" {_A_ 1 _U_ 2 _N_ _N_ _F_ _IF_ARGS_ 0 1 X 3 \ (u0 :: Float#) -> case _#_ expFloat# [] [u0] of { _PRIM_ (u1 :: Float#) -> _!_ F# [] [u1] } _N_} _F_ _IF_ARGS_ 0 1 C 4 \ (u0 :: Float) -> case u0 of { _ALG_ F# (u1 :: Float#) -> case _#_ expFloat# [] [u1] of { _PRIM_ (u2 :: Float#) -> _!_ F# [] [u2] }; _NO_DEFLT_ } _N_,
- log = _A_ 1 _U_ 1 _N_ _S_ "U(P)" {_A_ 1 _U_ 2 _N_ _N_ _F_ _IF_ARGS_ 0 1 X 3 \ (u0 :: Float#) -> case _#_ logFloat# [] [u0] of { _PRIM_ (u1 :: Float#) -> _!_ F# [] [u1] } _N_} _F_ _IF_ARGS_ 0 1 C 4 \ (u0 :: Float) -> case u0 of { _ALG_ F# (u1 :: Float#) -> case _#_ logFloat# [] [u1] of { _PRIM_ (u2 :: Float#) -> _!_ F# [] [u2] }; _NO_DEFLT_ } _N_,
- sqrt = _A_ 1 _U_ 1 _N_ _S_ "U(P)" {_A_ 1 _U_ 2 _N_ _N_ _F_ _IF_ARGS_ 0 1 X 3 \ (u0 :: Float#) -> case _#_ sqrtFloat# [] [u0] of { _PRIM_ (u1 :: Float#) -> _!_ F# [] [u1] } _N_} _F_ _IF_ARGS_ 0 1 C 4 \ (u0 :: Float) -> case u0 of { _ALG_ F# (u1 :: Float#) -> case _#_ sqrtFloat# [] [u1] of { _PRIM_ (u2 :: Float#) -> _!_ F# [] [u2] }; _NO_DEFLT_ } _N_,
- (**) = _A_ 2 _U_ 11 _N_ _S_ "U(P)U(P)" {_A_ 2 _U_ 22 _N_ _N_ _F_ _IF_ARGS_ 0 2 XX 3 \ (u0 :: Float#) (u1 :: Float#) -> case _#_ powerFloat# [] [u0, u1] of { _PRIM_ (u2 :: Float#) -> _!_ F# [] [u2] } _N_} _F_ _IF_ARGS_ 0 2 CC 5 \ (u0 :: Float) (u1 :: Float) -> case u0 of { _ALG_ F# (u2 :: Float#) -> case u1 of { _ALG_ F# (u3 :: Float#) -> case _#_ powerFloat# [] [u2, u3] of { _PRIM_ (u4 :: Float#) -> _!_ F# [] [u4] }; _NO_DEFLT_ }; _NO_DEFLT_ } _N_,
- logBase = _A_ 2 _U_ 22 _N_ _N_ _N_ _N_,
- sin = _A_ 1 _U_ 1 _N_ _S_ "U(P)" {_A_ 1 _U_ 2 _N_ _N_ _F_ _IF_ARGS_ 0 1 X 3 \ (u0 :: Float#) -> case _#_ sinFloat# [] [u0] of { _PRIM_ (u1 :: Float#) -> _!_ F# [] [u1] } _N_} _F_ _IF_ARGS_ 0 1 C 4 \ (u0 :: Float) -> case u0 of { _ALG_ F# (u1 :: Float#) -> case _#_ sinFloat# [] [u1] of { _PRIM_ (u2 :: Float#) -> _!_ F# [] [u2] }; _NO_DEFLT_ } _N_,
- cos = _A_ 1 _U_ 1 _N_ _S_ "U(P)" {_A_ 1 _U_ 2 _N_ _N_ _F_ _IF_ARGS_ 0 1 X 3 \ (u0 :: Float#) -> case _#_ cosFloat# [] [u0] of { _PRIM_ (u1 :: Float#) -> _!_ F# [] [u1] } _N_} _F_ _IF_ARGS_ 0 1 C 4 \ (u0 :: Float) -> case u0 of { _ALG_ F# (u1 :: Float#) -> case _#_ cosFloat# [] [u1] of { _PRIM_ (u2 :: Float#) -> _!_ F# [] [u2] }; _NO_DEFLT_ } _N_,
- tan = _A_ 1 _U_ 1 _N_ _S_ "U(P)" {_A_ 1 _U_ 2 _N_ _N_ _F_ _IF_ARGS_ 0 1 X 3 \ (u0 :: Float#) -> case _#_ tanFloat# [] [u0] of { _PRIM_ (u1 :: Float#) -> _!_ F# [] [u1] } _N_} _F_ _IF_ARGS_ 0 1 C 4 \ (u0 :: Float) -> case u0 of { _ALG_ F# (u1 :: Float#) -> case _#_ tanFloat# [] [u1] of { _PRIM_ (u2 :: Float#) -> _!_ F# [] [u2] }; _NO_DEFLT_ } _N_,
- asin = _A_ 1 _U_ 1 _N_ _S_ "U(P)" {_A_ 1 _U_ 2 _N_ _N_ _F_ _IF_ARGS_ 0 1 X 3 \ (u0 :: Float#) -> case _#_ asinFloat# [] [u0] of { _PRIM_ (u1 :: Float#) -> _!_ F# [] [u1] } _N_} _F_ _IF_ARGS_ 0 1 C 4 \ (u0 :: Float) -> case u0 of { _ALG_ F# (u1 :: Float#) -> case _#_ asinFloat# [] [u1] of { _PRIM_ (u2 :: Float#) -> _!_ F# [] [u2] }; _NO_DEFLT_ } _N_,
- acos = _A_ 1 _U_ 1 _N_ _S_ "U(P)" {_A_ 1 _U_ 2 _N_ _N_ _F_ _IF_ARGS_ 0 1 X 3 \ (u0 :: Float#) -> case _#_ acosFloat# [] [u0] of { _PRIM_ (u1 :: Float#) -> _!_ F# [] [u1] } _N_} _F_ _IF_ARGS_ 0 1 C 4 \ (u0 :: Float) -> case u0 of { _ALG_ F# (u1 :: Float#) -> case _#_ acosFloat# [] [u1] of { _PRIM_ (u2 :: Float#) -> _!_ F# [] [u2] }; _NO_DEFLT_ } _N_,
- atan = _A_ 1 _U_ 1 _N_ _S_ "U(P)" {_A_ 1 _U_ 2 _N_ _N_ _F_ _IF_ARGS_ 0 1 X 3 \ (u0 :: Float#) -> case _#_ atanFloat# [] [u0] of { _PRIM_ (u1 :: Float#) -> _!_ F# [] [u1] } _N_} _F_ _IF_ARGS_ 0 1 C 4 \ (u0 :: Float) -> case u0 of { _ALG_ F# (u1 :: Float#) -> case _#_ atanFloat# [] [u1] of { _PRIM_ (u2 :: Float#) -> _!_ F# [] [u2] }; _NO_DEFLT_ } _N_,
- sinh = _A_ 1 _U_ 1 _N_ _S_ "U(P)" {_A_ 1 _U_ 2 _N_ _N_ _F_ _IF_ARGS_ 0 1 X 3 \ (u0 :: Float#) -> case _#_ sinhFloat# [] [u0] of { _PRIM_ (u1 :: Float#) -> _!_ F# [] [u1] } _N_} _F_ _IF_ARGS_ 0 1 C 4 \ (u0 :: Float) -> case u0 of { _ALG_ F# (u1 :: Float#) -> case _#_ sinhFloat# [] [u1] of { _PRIM_ (u2 :: Float#) -> _!_ F# [] [u2] }; _NO_DEFLT_ } _N_,
- cosh = _A_ 1 _U_ 1 _N_ _S_ "U(P)" {_A_ 1 _U_ 2 _N_ _N_ _F_ _IF_ARGS_ 0 1 X 3 \ (u0 :: Float#) -> case _#_ coshFloat# [] [u0] of { _PRIM_ (u1 :: Float#) -> _!_ F# [] [u1] } _N_} _F_ _IF_ARGS_ 0 1 C 4 \ (u0 :: Float) -> case u0 of { _ALG_ F# (u1 :: Float#) -> case _#_ coshFloat# [] [u1] of { _PRIM_ (u2 :: Float#) -> _!_ F# [] [u2] }; _NO_DEFLT_ } _N_,
- tanh = _A_ 1 _U_ 1 _N_ _S_ "U(P)" {_A_ 1 _U_ 2 _N_ _N_ _F_ _IF_ARGS_ 0 1 X 3 \ (u0 :: Float#) -> case _#_ tanhFloat# [] [u0] of { _PRIM_ (u1 :: Float#) -> _!_ F# [] [u1] } _N_} _F_ _IF_ARGS_ 0 1 C 4 \ (u0 :: Float) -> case u0 of { _ALG_ F# (u1 :: Float#) -> case _#_ tanhFloat# [] [u1] of { _PRIM_ (u2 :: Float#) -> _!_ F# [] [u2] }; _NO_DEFLT_ } _N_,
- asinh = _A_ 1 _U_ 1 _N_ _S_ "U(P)" {_A_ 1 _U_ 2 _N_ _N_ _N_ _N_} _N_ _N_,
- acosh = _A_ 1 _U_ 1 _N_ _S_ "U(P)" {_A_ 1 _U_ 2 _N_ _N_ _N_ _N_} _N_ _N_,
- atanh = _A_ 1 _U_ 1 _N_ _S_ "U(P)" {_A_ 1 _U_ 2 _N_ _N_ _N_ _N_} _N_ _N_ #-}
+ pi = { _A_ 0 _N_ _N_ _N_ _F_ _IF_ARGS_ 0 0 X 2 _!_ F# [] [3.1415926535897931#] _N_ },
+ exp = { _A_ 1 _U_ 1 _N_ _S_ "U(P)" {_A_ 1 _U_ 2 _N_ _N_ _F_ _IF_ARGS_ 0 1 X 3 \ (u0 :: Float#) -> case _#_ expFloat# [] [u0] of { _PRIM_ (u1 :: Float#) -> _!_ F# [] [u1] } _N_} _F_ _IF_ARGS_ 0 1 C 4 \ (u0 :: Float) -> case u0 of { _ALG_ F# (u1 :: Float#) -> case _#_ expFloat# [] [u1] of { _PRIM_ (u2 :: Float#) -> _!_ F# [] [u2] }; _NO_DEFLT_ } _N_ },
+ log = { _A_ 1 _U_ 1 _N_ _S_ "U(P)" {_A_ 1 _U_ 2 _N_ _N_ _F_ _IF_ARGS_ 0 1 X 3 \ (u0 :: Float#) -> case _#_ logFloat# [] [u0] of { _PRIM_ (u1 :: Float#) -> _!_ F# [] [u1] } _N_} _F_ _IF_ARGS_ 0 1 C 4 \ (u0 :: Float) -> case u0 of { _ALG_ F# (u1 :: Float#) -> case _#_ logFloat# [] [u1] of { _PRIM_ (u2 :: Float#) -> _!_ F# [] [u2] }; _NO_DEFLT_ } _N_ },
+ sqrt = { _A_ 1 _U_ 1 _N_ _S_ "U(P)" {_A_ 1 _U_ 2 _N_ _N_ _F_ _IF_ARGS_ 0 1 X 3 \ (u0 :: Float#) -> case _#_ sqrtFloat# [] [u0] of { _PRIM_ (u1 :: Float#) -> _!_ F# [] [u1] } _N_} _F_ _IF_ARGS_ 0 1 C 4 \ (u0 :: Float) -> case u0 of { _ALG_ F# (u1 :: Float#) -> case _#_ sqrtFloat# [] [u1] of { _PRIM_ (u2 :: Float#) -> _!_ F# [] [u2] }; _NO_DEFLT_ } _N_ },
+ (**) = { _A_ 2 _U_ 11 _N_ _S_ "U(P)U(P)" {_A_ 2 _U_ 22 _N_ _N_ _F_ _IF_ARGS_ 0 2 XX 3 \ (u0 :: Float#) (u1 :: Float#) -> case _#_ powerFloat# [] [u0, u1] of { _PRIM_ (u2 :: Float#) -> _!_ F# [] [u2] } _N_} _F_ _IF_ARGS_ 0 2 CC 5 \ (u0 :: Float) (u1 :: Float) -> case u0 of { _ALG_ F# (u2 :: Float#) -> case u1 of { _ALG_ F# (u3 :: Float#) -> case _#_ powerFloat# [] [u2, u3] of { _PRIM_ (u4 :: Float#) -> _!_ F# [] [u4] }; _NO_DEFLT_ }; _NO_DEFLT_ } _N_ },
+ logBase = { _A_ 2 _U_ 11 _N_ _S_ "U(P)U(P)" {_A_ 2 _U_ 22 _N_ _N_ _F_ _IF_ARGS_ 0 2 XX 5 \ (u0 :: Float#) (u1 :: Float#) -> case _#_ logFloat# [] [u1] of { _PRIM_ (u2 :: Float#) -> case _#_ logFloat# [] [u0] of { _PRIM_ (u3 :: Float#) -> case _#_ divideFloat# [] [u2, u3] of { _PRIM_ (u4 :: Float#) -> _!_ F# [] [u4] } } } _N_} _F_ _IF_ARGS_ 0 2 CC 7 \ (u0 :: Float) (u1 :: Float) -> case u1 of { _ALG_ F# (u2 :: Float#) -> case _#_ logFloat# [] [u2] of { _PRIM_ (u3 :: Float#) -> case u0 of { _ALG_ F# (u4 :: Float#) -> case _#_ logFloat# [] [u4] of { _PRIM_ (u5 :: Float#) -> case _#_ divideFloat# [] [u3, u5] of { _PRIM_ (u6 :: Float#) -> _!_ F# [] [u6] } }; _NO_DEFLT_ } }; _NO_DEFLT_ } _N_ },
+ sin = { _A_ 1 _U_ 1 _N_ _S_ "U(P)" {_A_ 1 _U_ 2 _N_ _N_ _F_ _IF_ARGS_ 0 1 X 3 \ (u0 :: Float#) -> case _#_ sinFloat# [] [u0] of { _PRIM_ (u1 :: Float#) -> _!_ F# [] [u1] } _N_} _F_ _IF_ARGS_ 0 1 C 4 \ (u0 :: Float) -> case u0 of { _ALG_ F# (u1 :: Float#) -> case _#_ sinFloat# [] [u1] of { _PRIM_ (u2 :: Float#) -> _!_ F# [] [u2] }; _NO_DEFLT_ } _N_ },
+ cos = { _A_ 1 _U_ 1 _N_ _S_ "U(P)" {_A_ 1 _U_ 2 _N_ _N_ _F_ _IF_ARGS_ 0 1 X 3 \ (u0 :: Float#) -> case _#_ cosFloat# [] [u0] of { _PRIM_ (u1 :: Float#) -> _!_ F# [] [u1] } _N_} _F_ _IF_ARGS_ 0 1 C 4 \ (u0 :: Float) -> case u0 of { _ALG_ F# (u1 :: Float#) -> case _#_ cosFloat# [] [u1] of { _PRIM_ (u2 :: Float#) -> _!_ F# [] [u2] }; _NO_DEFLT_ } _N_ },
+ tan = { _A_ 1 _U_ 1 _N_ _S_ "U(P)" {_A_ 1 _U_ 2 _N_ _N_ _F_ _IF_ARGS_ 0 1 X 3 \ (u0 :: Float#) -> case _#_ tanFloat# [] [u0] of { _PRIM_ (u1 :: Float#) -> _!_ F# [] [u1] } _N_} _F_ _IF_ARGS_ 0 1 C 4 \ (u0 :: Float) -> case u0 of { _ALG_ F# (u1 :: Float#) -> case _#_ tanFloat# [] [u1] of { _PRIM_ (u2 :: Float#) -> _!_ F# [] [u2] }; _NO_DEFLT_ } _N_ },
+ asin = { _A_ 1 _U_ 1 _N_ _S_ "U(P)" {_A_ 1 _U_ 2 _N_ _N_ _F_ _IF_ARGS_ 0 1 X 3 \ (u0 :: Float#) -> case _#_ asinFloat# [] [u0] of { _PRIM_ (u1 :: Float#) -> _!_ F# [] [u1] } _N_} _F_ _IF_ARGS_ 0 1 C 4 \ (u0 :: Float) -> case u0 of { _ALG_ F# (u1 :: Float#) -> case _#_ asinFloat# [] [u1] of { _PRIM_ (u2 :: Float#) -> _!_ F# [] [u2] }; _NO_DEFLT_ } _N_ },
+ acos = { _A_ 1 _U_ 1 _N_ _S_ "U(P)" {_A_ 1 _U_ 2 _N_ _N_ _F_ _IF_ARGS_ 0 1 X 3 \ (u0 :: Float#) -> case _#_ acosFloat# [] [u0] of { _PRIM_ (u1 :: Float#) -> _!_ F# [] [u1] } _N_} _F_ _IF_ARGS_ 0 1 C 4 \ (u0 :: Float) -> case u0 of { _ALG_ F# (u1 :: Float#) -> case _#_ acosFloat# [] [u1] of { _PRIM_ (u2 :: Float#) -> _!_ F# [] [u2] }; _NO_DEFLT_ } _N_ },
+ atan = { _A_ 1 _U_ 1 _N_ _S_ "U(P)" {_A_ 1 _U_ 2 _N_ _N_ _F_ _IF_ARGS_ 0 1 X 3 \ (u0 :: Float#) -> case _#_ atanFloat# [] [u0] of { _PRIM_ (u1 :: Float#) -> _!_ F# [] [u1] } _N_} _F_ _IF_ARGS_ 0 1 C 4 \ (u0 :: Float) -> case u0 of { _ALG_ F# (u1 :: Float#) -> case _#_ atanFloat# [] [u1] of { _PRIM_ (u2 :: Float#) -> _!_ F# [] [u2] }; _NO_DEFLT_ } _N_ },
+ sinh = { _A_ 1 _U_ 1 _N_ _S_ "U(P)" {_A_ 1 _U_ 2 _N_ _N_ _F_ _IF_ARGS_ 0 1 X 3 \ (u0 :: Float#) -> case _#_ sinhFloat# [] [u0] of { _PRIM_ (u1 :: Float#) -> _!_ F# [] [u1] } _N_} _F_ _IF_ARGS_ 0 1 C 4 \ (u0 :: Float) -> case u0 of { _ALG_ F# (u1 :: Float#) -> case _#_ sinhFloat# [] [u1] of { _PRIM_ (u2 :: Float#) -> _!_ F# [] [u2] }; _NO_DEFLT_ } _N_ },
+ cosh = { _A_ 1 _U_ 1 _N_ _S_ "U(P)" {_A_ 1 _U_ 2 _N_ _N_ _F_ _IF_ARGS_ 0 1 X 3 \ (u0 :: Float#) -> case _#_ coshFloat# [] [u0] of { _PRIM_ (u1 :: Float#) -> _!_ F# [] [u1] } _N_} _F_ _IF_ARGS_ 0 1 C 4 \ (u0 :: Float) -> case u0 of { _ALG_ F# (u1 :: Float#) -> case _#_ coshFloat# [] [u1] of { _PRIM_ (u2 :: Float#) -> _!_ F# [] [u2] }; _NO_DEFLT_ } _N_ },
+ tanh = { _A_ 1 _U_ 1 _N_ _S_ "U(P)" {_A_ 1 _U_ 2 _N_ _N_ _F_ _IF_ARGS_ 0 1 X 3 \ (u0 :: Float#) -> case _#_ tanhFloat# [] [u0] of { _PRIM_ (u1 :: Float#) -> _!_ F# [] [u1] } _N_} _F_ _IF_ARGS_ 0 1 C 4 \ (u0 :: Float) -> case u0 of { _ALG_ F# (u1 :: Float#) -> case _#_ tanhFloat# [] [u1] of { _PRIM_ (u2 :: Float#) -> _!_ F# [] [u2] }; _NO_DEFLT_ } _N_ },
+ asinh = { _A_ 1 _U_ 1 _N_ _S_ "U(P)" {_A_ 1 _U_ 2 _N_ _N_ _N_ _N_} _N_ _N_ },
+ acosh = { _A_ 1 _U_ 1 _N_ _S_ "U(P)" {_A_ 1 _U_ 2 _N_ _N_ _N_ _N_} _N_ _N_ },
+ atanh = { _A_ 1 _U_ 1 _N_ _S_ "U(P)" {_A_ 1 _U_ 2 _N_ _N_ _N_ _N_} _N_ _N_ } #-}
instance Fractional Float
{-# GHC_PRAGMA _M_ PreludeCore {-dfun-} _A_ 0 _N_ _N_ _N_ _F_ _IF_ARGS_ 0 0 X 5 _!_ _TUP_4 [{{Num Float}}, (Float -> Float -> Float), (Float -> Float), (Ratio Integer -> Float)] [_DFUN_ Num (Float), _CONSTM_ Fractional (/) (Float), _CONSTM_ Fractional recip (Float), _CONSTM_ Fractional fromRational (Float)] _N_
- (/) = _A_ 2 _U_ 11 _N_ _S_ "U(P)U(P)" {_A_ 2 _U_ 22 _N_ _N_ _F_ _IF_ARGS_ 0 2 XX 3 \ (u0 :: Float#) (u1 :: Float#) -> case _#_ divideFloat# [] [u0, u1] of { _PRIM_ (u2 :: Float#) -> _!_ F# [] [u2] } _N_} _F_ _IF_ARGS_ 0 2 CC 5 \ (u0 :: Float) (u1 :: Float) -> case u0 of { _ALG_ F# (u2 :: Float#) -> case u1 of { _ALG_ F# (u3 :: Float#) -> case _#_ divideFloat# [] [u2, u3] of { _PRIM_ (u4 :: Float#) -> _!_ F# [] [u4] }; _NO_DEFLT_ }; _NO_DEFLT_ } _N_,
- recip = _A_ 0 _U_ 2 _N_ _N_ _N_ _N_,
- fromRational = _A_ 0 _U_ 2 _N_ _N_ _N_ _N_ #-}
+ (/) = { _A_ 2 _U_ 11 _N_ _S_ "U(P)U(P)" {_A_ 2 _U_ 22 _N_ _N_ _F_ _IF_ARGS_ 0 2 XX 3 \ (u0 :: Float#) (u1 :: Float#) -> case _#_ divideFloat# [] [u0, u1] of { _PRIM_ (u2 :: Float#) -> _!_ F# [] [u2] } _N_} _F_ _IF_ARGS_ 0 2 CC 5 \ (u0 :: Float) (u1 :: Float) -> case u0 of { _ALG_ F# (u2 :: Float#) -> case u1 of { _ALG_ F# (u3 :: Float#) -> case _#_ divideFloat# [] [u2, u3] of { _PRIM_ (u4 :: Float#) -> _!_ F# [] [u4] }; _NO_DEFLT_ }; _NO_DEFLT_ } _N_ },
+ recip = { _A_ 1 _U_ 1 _N_ _S_ "U(P)" {_A_ 1 _U_ 2 _N_ _N_ _F_ _IF_ARGS_ 0 1 X 3 \ (u0 :: Float#) -> case _#_ divideFloat# [] [1.0000000000000000#, u0] of { _PRIM_ (u1 :: Float#) -> _!_ F# [] [u1] } _N_} _F_ _IF_ARGS_ 0 1 C 4 \ (u0 :: Float) -> case u0 of { _ALG_ F# (u1 :: Float#) -> case _#_ divideFloat# [] [1.0000000000000000#, u1] of { _PRIM_ (u2 :: Float#) -> _!_ F# [] [u2] }; _NO_DEFLT_ } _N_ },
+ fromRational = { _A_ 1 _U_ 2 _N_ _N_ _N_ _N_ } #-}
instance Num Float
{-# GHC_PRAGMA _M_ PreludeCore {-dfun-} _A_ 0 _N_ _N_ _N_ _F_ _IF_ARGS_ 0 0 X 11 _!_ _TUP_10 [{{Eq Float}}, {{Text Float}}, (Float -> Float -> Float), (Float -> Float -> Float), (Float -> Float -> Float), (Float -> Float), (Float -> Float), (Float -> Float), (Integer -> Float), (Int -> Float)] [_DFUN_ Eq (Float), _DFUN_ Text (Float), _CONSTM_ Num (+) (Float), _CONSTM_ Num (-) (Float), _CONSTM_ Num (*) (Float), _CONSTM_ Num negate (Float), _CONSTM_ Num abs (Float), _CONSTM_ Num signum (Float), _CONSTM_ Num fromInteger (Float), _CONSTM_ Num fromInt (Float)] _N_
- (+) = _A_ 2 _U_ 11 _N_ _S_ "U(P)U(P)" {_A_ 2 _U_ 22 _N_ _N_ _F_ _IF_ARGS_ 0 2 XX 3 \ (u0 :: Float#) (u1 :: Float#) -> case _#_ plusFloat# [] [u0, u1] of { _PRIM_ (u2 :: Float#) -> _!_ F# [] [u2] } _N_} _F_ _IF_ARGS_ 0 2 CC 5 \ (u0 :: Float) (u1 :: Float) -> case u0 of { _ALG_ F# (u2 :: Float#) -> case u1 of { _ALG_ F# (u3 :: Float#) -> case _#_ plusFloat# [] [u2, u3] of { _PRIM_ (u4 :: Float#) -> _!_ F# [] [u4] }; _NO_DEFLT_ }; _NO_DEFLT_ } _N_,
- (-) = _A_ 2 _U_ 11 _N_ _S_ "U(P)U(P)" {_A_ 2 _U_ 22 _N_ _N_ _F_ _IF_ARGS_ 0 2 XX 3 \ (u0 :: Float#) (u1 :: Float#) -> case _#_ minusFloat# [] [u0, u1] of { _PRIM_ (u2 :: Float#) -> _!_ F# [] [u2] } _N_} _F_ _IF_ARGS_ 0 2 CC 5 \ (u0 :: Float) (u1 :: Float) -> case u0 of { _ALG_ F# (u2 :: Float#) -> case u1 of { _ALG_ F# (u3 :: Float#) -> case _#_ minusFloat# [] [u2, u3] of { _PRIM_ (u4 :: Float#) -> _!_ F# [] [u4] }; _NO_DEFLT_ }; _NO_DEFLT_ } _N_,
- (*) = _A_ 2 _U_ 11 _N_ _S_ "U(P)U(P)" {_A_ 2 _U_ 22 _N_ _N_ _F_ _IF_ARGS_ 0 2 XX 3 \ (u0 :: Float#) (u1 :: Float#) -> case _#_ timesFloat# [] [u0, u1] of { _PRIM_ (u2 :: Float#) -> _!_ F# [] [u2] } _N_} _F_ _IF_ARGS_ 0 2 CC 5 \ (u0 :: Float) (u1 :: Float) -> case u0 of { _ALG_ F# (u2 :: Float#) -> case u1 of { _ALG_ F# (u3 :: Float#) -> case _#_ timesFloat# [] [u2, u3] of { _PRIM_ (u4 :: Float#) -> _!_ F# [] [u4] }; _NO_DEFLT_ }; _NO_DEFLT_ } _N_,
- negate = _A_ 1 _U_ 1 _N_ _S_ "U(P)" {_A_ 1 _U_ 2 _N_ _N_ _F_ _IF_ARGS_ 0 1 X 3 \ (u0 :: Float#) -> case _#_ negateFloat# [] [u0] of { _PRIM_ (u1 :: Float#) -> _!_ F# [] [u1] } _N_} _F_ _IF_ARGS_ 0 1 C 4 \ (u0 :: Float) -> case u0 of { _ALG_ F# (u1 :: Float#) -> case _#_ negateFloat# [] [u1] of { _PRIM_ (u2 :: Float#) -> _!_ F# [] [u2] }; _NO_DEFLT_ } _N_,
- abs = _A_ 1 _U_ 1 _N_ _S_ "U(P)" {_A_ 1 _U_ 2 _N_ _N_ _N_ _N_} _N_ _N_,
- signum = _A_ 1 _U_ 1 _N_ _S_ "U(P)" {_A_ 1 _U_ 2 _N_ _N_ _N_ _N_} _N_ _N_,
- fromInteger = _A_ 1 _U_ 1 _N_ _S_ "U(PPP)" {_A_ 3 _U_ 222 _N_ _N_ _F_ _IF_ARGS_ 0 3 XXX 3 \ (u0 :: Int#) (u1 :: Int#) (u2 :: ByteArray#) -> case _#_ encodeFloat# [] [u0, u1, u2, 0#] of { _PRIM_ (u3 :: Float#) -> _!_ F# [] [u3] } _N_} _F_ _IF_ARGS_ 0 1 C 4 \ (u0 :: Integer) -> case u0 of { _ALG_ J# (u1 :: Int#) (u2 :: Int#) (u3 :: ByteArray#) -> case _#_ encodeFloat# [] [u1, u2, u3, 0#] of { _PRIM_ (u4 :: Float#) -> _!_ F# [] [u4] }; _NO_DEFLT_ } _N_,
- fromInt = _A_ 1 _U_ 1 _N_ _S_ "U(P)" {_A_ 1 _U_ 2 _N_ _N_ _F_ _IF_ARGS_ 0 1 X 3 \ (u0 :: Int#) -> case _#_ int2Float# [] [u0] of { _PRIM_ (u1 :: Float#) -> _!_ F# [] [u1] } _N_} _F_ _IF_ARGS_ 0 1 C 4 \ (u0 :: Int) -> case u0 of { _ALG_ I# (u1 :: Int#) -> case _#_ int2Float# [] [u1] of { _PRIM_ (u2 :: Float#) -> _!_ F# [] [u2] }; _NO_DEFLT_ } _N_ #-}
+ (+) = { _A_ 2 _U_ 11 _N_ _S_ "U(P)U(P)" {_A_ 2 _U_ 22 _N_ _N_ _F_ _IF_ARGS_ 0 2 XX 3 \ (u0 :: Float#) (u1 :: Float#) -> case _#_ plusFloat# [] [u0, u1] of { _PRIM_ (u2 :: Float#) -> _!_ F# [] [u2] } _N_} _F_ _IF_ARGS_ 0 2 CC 5 \ (u0 :: Float) (u1 :: Float) -> case u0 of { _ALG_ F# (u2 :: Float#) -> case u1 of { _ALG_ F# (u3 :: Float#) -> case _#_ plusFloat# [] [u2, u3] of { _PRIM_ (u4 :: Float#) -> _!_ F# [] [u4] }; _NO_DEFLT_ }; _NO_DEFLT_ } _N_ },
+ (-) = { _A_ 2 _U_ 11 _N_ _S_ "U(P)U(P)" {_A_ 2 _U_ 22 _N_ _N_ _F_ _IF_ARGS_ 0 2 XX 3 \ (u0 :: Float#) (u1 :: Float#) -> case _#_ minusFloat# [] [u0, u1] of { _PRIM_ (u2 :: Float#) -> _!_ F# [] [u2] } _N_} _F_ _IF_ARGS_ 0 2 CC 5 \ (u0 :: Float) (u1 :: Float) -> case u0 of { _ALG_ F# (u2 :: Float#) -> case u1 of { _ALG_ F# (u3 :: Float#) -> case _#_ minusFloat# [] [u2, u3] of { _PRIM_ (u4 :: Float#) -> _!_ F# [] [u4] }; _NO_DEFLT_ }; _NO_DEFLT_ } _N_ },
+ (*) = { _A_ 2 _U_ 11 _N_ _S_ "U(P)U(P)" {_A_ 2 _U_ 22 _N_ _N_ _F_ _IF_ARGS_ 0 2 XX 3 \ (u0 :: Float#) (u1 :: Float#) -> case _#_ timesFloat# [] [u0, u1] of { _PRIM_ (u2 :: Float#) -> _!_ F# [] [u2] } _N_} _F_ _IF_ARGS_ 0 2 CC 5 \ (u0 :: Float) (u1 :: Float) -> case u0 of { _ALG_ F# (u2 :: Float#) -> case u1 of { _ALG_ F# (u3 :: Float#) -> case _#_ timesFloat# [] [u2, u3] of { _PRIM_ (u4 :: Float#) -> _!_ F# [] [u4] }; _NO_DEFLT_ }; _NO_DEFLT_ } _N_ },
+ negate = { _A_ 1 _U_ 1 _N_ _S_ "U(P)" {_A_ 1 _U_ 2 _N_ _N_ _F_ _IF_ARGS_ 0 1 X 3 \ (u0 :: Float#) -> case _#_ negateFloat# [] [u0] of { _PRIM_ (u1 :: Float#) -> _!_ F# [] [u1] } _N_} _F_ _IF_ARGS_ 0 1 C 4 \ (u0 :: Float) -> case u0 of { _ALG_ F# (u1 :: Float#) -> case _#_ negateFloat# [] [u1] of { _PRIM_ (u2 :: Float#) -> _!_ F# [] [u2] }; _NO_DEFLT_ } _N_ },
+ abs = { _A_ 1 _U_ 1 _N_ _S_ "U(P)" {_A_ 1 _U_ 2 _N_ _N_ _N_ _N_} _N_ _N_ },
+ signum = { _A_ 1 _U_ 1 _N_ _S_ "U(P)" {_A_ 1 _U_ 2 _N_ _N_ _N_ _N_} _N_ _N_ },
+ fromInteger = { _A_ 1 _U_ 1 _N_ _S_ "U(PPP)" {_A_ 3 _U_ 222 _N_ _N_ _F_ _IF_ARGS_ 0 3 XXX 3 \ (u0 :: Int#) (u1 :: Int#) (u2 :: ByteArray#) -> case _#_ encodeFloat# [] [u0, u1, u2, 0#] of { _PRIM_ (u3 :: Float#) -> _!_ F# [] [u3] } _N_} _F_ _IF_ARGS_ 0 1 C 4 \ (u0 :: Integer) -> case u0 of { _ALG_ J# (u1 :: Int#) (u2 :: Int#) (u3 :: ByteArray#) -> case _#_ encodeFloat# [] [u1, u2, u3, 0#] of { _PRIM_ (u4 :: Float#) -> _!_ F# [] [u4] }; _NO_DEFLT_ } _N_ },
+ fromInt = { _A_ 1 _U_ 1 _N_ _S_ "U(P)" {_A_ 1 _U_ 2 _N_ _N_ _F_ _IF_ARGS_ 0 1 X 3 \ (u0 :: Int#) -> case _#_ int2Float# [] [u0] of { _PRIM_ (u1 :: Float#) -> _!_ F# [] [u1] } _N_} _F_ _IF_ARGS_ 0 1 C 4 \ (u0 :: Int) -> case u0 of { _ALG_ I# (u1 :: Int#) -> case _#_ int2Float# [] [u1] of { _PRIM_ (u2 :: Float#) -> _!_ F# [] [u2] }; _NO_DEFLT_ } _N_ } #-}
instance Ord Float
{-# GHC_PRAGMA _M_ PreludeCore {-dfun-} _A_ 0 _N_ _N_ _N_ _F_ _IF_ARGS_ 0 0 X 9 _!_ _TUP_8 [{{Eq Float}}, (Float -> Float -> Bool), (Float -> Float -> Bool), (Float -> Float -> Bool), (Float -> Float -> Bool), (Float -> Float -> Float), (Float -> Float -> Float), (Float -> Float -> _CMP_TAG)] [_DFUN_ Eq (Float), _CONSTM_ Ord (<) (Float), _CONSTM_ Ord (<=) (Float), _CONSTM_ Ord (>=) (Float), _CONSTM_ Ord (>) (Float), _CONSTM_ Ord max (Float), _CONSTM_ Ord min (Float), _CONSTM_ Ord _tagCmp (Float)] _N_
- (<) = _A_ 2 _U_ 11 _N_ _S_ "U(P)U(P)" {_A_ 2 _U_ 22 _N_ _N_ _F_ _IF_ARGS_ 0 2 XX 1 \ (u0 :: Float#) (u1 :: Float#) -> _#_ ltFloat# [] [u0, u1] _N_} _F_ _IF_ARGS_ 0 2 CC 3 \ (u0 :: Float) (u1 :: Float) -> case u0 of { _ALG_ F# (u2 :: Float#) -> case u1 of { _ALG_ F# (u3 :: Float#) -> _#_ ltFloat# [] [u2, u3]; _NO_DEFLT_ }; _NO_DEFLT_ } _N_,
- (<=) = _A_ 2 _U_ 11 _N_ _S_ "U(P)U(P)" {_A_ 2 _U_ 22 _N_ _N_ _F_ _IF_ARGS_ 0 2 XX 1 \ (u0 :: Float#) (u1 :: Float#) -> _#_ leFloat# [] [u0, u1] _N_} _F_ _IF_ARGS_ 0 2 CC 3 \ (u0 :: Float) (u1 :: Float) -> case u0 of { _ALG_ F# (u2 :: Float#) -> case u1 of { _ALG_ F# (u3 :: Float#) -> _#_ leFloat# [] [u2, u3]; _NO_DEFLT_ }; _NO_DEFLT_ } _N_,
- (>=) = _A_ 2 _U_ 11 _N_ _S_ "U(P)U(P)" {_A_ 2 _U_ 22 _N_ _N_ _F_ _IF_ARGS_ 0 2 XX 1 \ (u0 :: Float#) (u1 :: Float#) -> _#_ geFloat# [] [u0, u1] _N_} _F_ _IF_ARGS_ 0 2 CC 3 \ (u0 :: Float) (u1 :: Float) -> case u0 of { _ALG_ F# (u2 :: Float#) -> case u1 of { _ALG_ F# (u3 :: Float#) -> _#_ geFloat# [] [u2, u3]; _NO_DEFLT_ }; _NO_DEFLT_ } _N_,
- (>) = _A_ 2 _U_ 11 _N_ _S_ "U(P)U(P)" {_A_ 2 _U_ 22 _N_ _N_ _F_ _IF_ARGS_ 0 2 XX 1 \ (u0 :: Float#) (u1 :: Float#) -> _#_ gtFloat# [] [u0, u1] _N_} _F_ _IF_ARGS_ 0 2 CC 3 \ (u0 :: Float) (u1 :: Float) -> case u0 of { _ALG_ F# (u2 :: Float#) -> case u1 of { _ALG_ F# (u3 :: Float#) -> _#_ gtFloat# [] [u2, u3]; _NO_DEFLT_ }; _NO_DEFLT_ } _N_,
- max = _A_ 2 _U_ 11 _N_ _S_ "U(P)U(P)" {_A_ 2 _U_ 22 _N_ _N_ _N_ _N_} _N_ _N_,
- min = _A_ 2 _U_ 11 _N_ _S_ "U(P)U(P)" {_A_ 2 _U_ 22 _N_ _N_ _N_ _N_} _N_ _N_,
- _tagCmp = _A_ 2 _U_ 11 _N_ _S_ "U(P)U(P)" {_A_ 2 _U_ 22 _N_ _N_ _N_ _N_} _N_ _N_ #-}
+ (<) = { _A_ 2 _U_ 11 _N_ _S_ "U(P)U(P)" {_A_ 2 _U_ 22 _N_ _N_ _F_ _IF_ARGS_ 0 2 XX 1 \ (u0 :: Float#) (u1 :: Float#) -> _#_ ltFloat# [] [u0, u1] _N_} _F_ _IF_ARGS_ 0 2 CC 3 \ (u0 :: Float) (u1 :: Float) -> case u0 of { _ALG_ F# (u2 :: Float#) -> case u1 of { _ALG_ F# (u3 :: Float#) -> _#_ ltFloat# [] [u2, u3]; _NO_DEFLT_ }; _NO_DEFLT_ } _N_ },
+ (<=) = { _A_ 2 _U_ 11 _N_ _S_ "U(P)U(P)" {_A_ 2 _U_ 22 _N_ _N_ _F_ _IF_ARGS_ 0 2 XX 1 \ (u0 :: Float#) (u1 :: Float#) -> _#_ leFloat# [] [u0, u1] _N_} _F_ _IF_ARGS_ 0 2 CC 3 \ (u0 :: Float) (u1 :: Float) -> case u0 of { _ALG_ F# (u2 :: Float#) -> case u1 of { _ALG_ F# (u3 :: Float#) -> _#_ leFloat# [] [u2, u3]; _NO_DEFLT_ }; _NO_DEFLT_ } _N_ },
+ (>=) = { _A_ 2 _U_ 11 _N_ _S_ "U(P)U(P)" {_A_ 2 _U_ 22 _N_ _N_ _F_ _IF_ARGS_ 0 2 XX 1 \ (u0 :: Float#) (u1 :: Float#) -> _#_ geFloat# [] [u0, u1] _N_} _F_ _IF_ARGS_ 0 2 CC 3 \ (u0 :: Float) (u1 :: Float) -> case u0 of { _ALG_ F# (u2 :: Float#) -> case u1 of { _ALG_ F# (u3 :: Float#) -> _#_ geFloat# [] [u2, u3]; _NO_DEFLT_ }; _NO_DEFLT_ } _N_ },
+ (>) = { _A_ 2 _U_ 11 _N_ _S_ "U(P)U(P)" {_A_ 2 _U_ 22 _N_ _N_ _F_ _IF_ARGS_ 0 2 XX 1 \ (u0 :: Float#) (u1 :: Float#) -> _#_ gtFloat# [] [u0, u1] _N_} _F_ _IF_ARGS_ 0 2 CC 3 \ (u0 :: Float) (u1 :: Float) -> case u0 of { _ALG_ F# (u2 :: Float#) -> case u1 of { _ALG_ F# (u3 :: Float#) -> _#_ gtFloat# [] [u2, u3]; _NO_DEFLT_ }; _NO_DEFLT_ } _N_ },
+ max = { _A_ 2 _U_ 11 _N_ _S_ "U(P)U(P)" {_A_ 2 _U_ 22 _N_ _N_ _N_ _N_} _N_ _N_ },
+ min = { _A_ 2 _U_ 11 _N_ _S_ "U(P)U(P)" {_A_ 2 _U_ 22 _N_ _N_ _N_ _N_} _N_ _N_ },
+ _tagCmp = { _A_ 2 _U_ 11 _N_ _S_ "U(P)U(P)" {_A_ 2 _U_ 22 _N_ _N_ _N_ _N_} _N_ _N_ } #-}
instance Real Float
{-# GHC_PRAGMA _M_ PreludeCore {-dfun-} _A_ 0 _N_ _N_ _N_ _F_ _IF_ARGS_ 0 0 X 4 _!_ _TUP_3 [{{Num Float}}, {{Enum Float}}, (Float -> Ratio Integer)] [_DFUN_ Num (Float), _DFUN_ Enum (Float), _CONSTM_ Real toRational (Float)] _N_
- toRational = _A_ 1 _U_ 1 _N_ _S_ "U(P)" {_A_ 1 _U_ 2 _N_ _N_ _N_ _N_} _N_ _N_ #-}
+ toRational = { _A_ 1 _U_ 1 _N_ _S_ "U(P)" {_A_ 1 _U_ 2 _N_ _N_ _N_ _N_} _N_ _N_ } #-}
instance RealFloat Float
{-# GHC_PRAGMA _M_ PreludeCore {-dfun-} _A_ 0 _N_ _N_ _N_ _F_ _IF_ARGS_ 0 0 X 11 _!_ _TUP_10 [{{RealFrac Float}}, {{Floating Float}}, (Float -> Integer), (Float -> Int), (Float -> (Int, Int)), (Float -> (Integer, Int)), (Integer -> Int -> Float), (Float -> Int), (Float -> Float), (Int -> Float -> Float)] [_DFUN_ RealFrac (Float), _DFUN_ Floating (Float), _CONSTM_ RealFloat floatRadix (Float), _CONSTM_ RealFloat floatDigits (Float), _CONSTM_ RealFloat floatRange (Float), _CONSTM_ RealFloat decodeFloat (Float), _CONSTM_ RealFloat encodeFloat (Float), _CONSTM_ RealFloat exponent (Float), _CONSTM_ RealFloat significand (Float), _CONSTM_ RealFloat scaleFloat (Float)] _N_
- floatRadix = _A_ 1 _U_ 0 _N_ _S_ "A" {_A_ 0 _N_ _N_ _N_ _F_ _IF_ARGS_ 0 0 X 1 _#_ int2Integer# [] [2#] _N_} _N_ _N_,
- floatDigits = _A_ 1 _U_ 0 _N_ _S_ "A" {_A_ 0 _N_ _N_ _N_ _F_ _IF_ARGS_ 0 0 X 2 _!_ I# [] [24#] _N_} _F_ _IF_ARGS_ 0 1 X 2 \ (u0 :: Float) -> _!_ I# [] [24#] _N_,
- floatRange = _A_ 1 _U_ 0 _N_ _S_ "A" {_A_ 0 _N_ _N_ _N_ _N_ _N_} _N_ _N_,
- decodeFloat = _A_ 1 _U_ 1 _N_ _S_ "U(P)" {_A_ 1 _U_ 2 _N_ _N_ _N_ _N_} _N_ _N_,
- encodeFloat = _A_ 2 _U_ 11 _N_ _S_ "U(PPP)U(P)" {_A_ 4 _U_ 2222 _N_ _N_ _F_ _IF_ARGS_ 0 4 XXXX 3 \ (u0 :: Int#) (u1 :: Int#) (u2 :: ByteArray#) (u3 :: Int#) -> case _#_ encodeFloat# [] [u0, u1, u2, u3] of { _PRIM_ (u4 :: Float#) -> _!_ F# [] [u4] } _N_} _F_ _IF_ARGS_ 0 2 CC 5 \ (u0 :: Integer) (u1 :: Int) -> case u0 of { _ALG_ J# (u2 :: Int#) (u3 :: Int#) (u4 :: ByteArray#) -> case u1 of { _ALG_ I# (u5 :: Int#) -> case _#_ encodeFloat# [] [u2, u3, u4, u5] of { _PRIM_ (u6 :: Float#) -> _!_ F# [] [u6] }; _NO_DEFLT_ }; _NO_DEFLT_ } _N_,
- exponent = _A_ 1 _U_ 2 _N_ _N_ _N_ _N_,
- significand = _A_ 1 _U_ 2 _N_ _N_ _N_ _N_,
- scaleFloat = _A_ 2 _U_ 22 _N_ _N_ _N_ _N_ #-}
+ floatRadix = { _A_ 1 _U_ 0 _N_ _S_ "A" {_A_ 0 _N_ _N_ _N_ _N_ _N_} _N_ _N_ },
+ floatDigits = { _A_ 1 _U_ 0 _N_ _S_ "A" {_A_ 0 _N_ _N_ _N_ _F_ _IF_ARGS_ 0 0 X 2 _!_ I# [] [24#] _N_} _F_ _IF_ARGS_ 0 1 X 2 \ (u0 :: Float) -> _!_ I# [] [24#] _N_ },
+ floatRange = { _A_ 1 _U_ 0 _N_ _S_ "A" {_A_ 0 _N_ _N_ _N_ _N_ _N_} _N_ _N_ },
+ decodeFloat = { _A_ 1 _U_ 1 _N_ _S_ "U(P)" {_A_ 1 _U_ 2 _N_ _N_ _N_ _N_} _N_ _N_ },
+ encodeFloat = { _A_ 2 _U_ 11 _N_ _S_ "U(PPP)U(P)" {_A_ 4 _U_ 2222 _N_ _N_ _F_ _IF_ARGS_ 0 4 XXXX 3 \ (u0 :: Int#) (u1 :: Int#) (u2 :: ByteArray#) (u3 :: Int#) -> case _#_ encodeFloat# [] [u0, u1, u2, u3] of { _PRIM_ (u4 :: Float#) -> _!_ F# [] [u4] } _N_} _F_ _IF_ARGS_ 0 2 CC 5 \ (u0 :: Integer) (u1 :: Int) -> case u0 of { _ALG_ J# (u2 :: Int#) (u3 :: Int#) (u4 :: ByteArray#) -> case u1 of { _ALG_ I# (u5 :: Int#) -> case _#_ encodeFloat# [] [u2, u3, u4, u5] of { _PRIM_ (u6 :: Float#) -> _!_ F# [] [u6] }; _NO_DEFLT_ }; _NO_DEFLT_ } _N_ },
+ exponent = { _A_ 1 _U_ 1 _N_ _S_ "U(P)" {_A_ 1 _U_ 2 _N_ _N_ _N_ _N_} _N_ _N_ },
+ significand = { _A_ 1 _U_ 1 _N_ _S_ "U(P)" {_A_ 1 _U_ 2 _N_ _N_ _N_ _N_} _N_ _N_ },
+ scaleFloat = { _A_ 2 _U_ 11 _N_ _S_ "U(P)U(P)" {_A_ 2 _U_ 22 _N_ _N_ _N_ _N_} _N_ _N_ } #-}
instance RealFrac Float
{-# GHC_PRAGMA _M_ PreludeCore {-dfun-} _A_ 0 _N_ _N_ _N_ _F_ _IF_ARGS_ 0 0 X 8 _!_ _TUP_7 [{{Real Float}}, {{Fractional Float}}, _forall_ a$z1 =>{{Integral a$z1}} -> (Float -> (a$z1, Float)), _forall_ a$z1 =>{{Integral a$z1}} -> (Float -> a$z1), _forall_ a$z1 =>{{Integral a$z1}} -> (Float -> a$z1), _forall_ a$z1 =>{{Integral a$z1}} -> (Float -> a$z1), _forall_ a$z1 =>{{Integral a$z1}} -> (Float -> a$z1)] [_DFUN_ Real (Float), _DFUN_ Fractional (Float), _CONSTM_ RealFrac properFraction (Float), _CONSTM_ RealFrac truncate (Float), _CONSTM_ RealFrac round (Float), _CONSTM_ RealFrac ceiling (Float), _CONSTM_ RealFrac floor (Float)] _N_
- properFraction = _A_ 1 _U_ 22 _N_ _N_ _N_ _N_,
- truncate = _A_ 1 _U_ 22 _N_ _N_ _N_ _N_,
- round = _A_ 1 _U_ 22 _N_ _N_ _N_ _N_,
- ceiling = _A_ 1 _U_ 22 _N_ _N_ _N_ _N_,
- floor = _A_ 1 _U_ 22 _N_ _N_ _N_ _N_ #-}
+ properFraction = { _A_ 1 _U_ 11 _N_ _N_ _N_ _SPECIALISE_ [ Int ] 1 { _A_ 1 _U_ 1 _N_ _S_ "U(P)" {_A_ 1 _U_ 2 _N_ _N_ _N_ _N_} _N_ _N_ }, [ Integer ] 1 { _A_ 1 _U_ 1 _N_ _S_ "U(P)" {_A_ 1 _U_ 2 _N_ _N_ _N_ _N_} _N_ _N_ } },
+ truncate = { _A_ 1 _U_ 11 _N_ _N_ _N_ _SPECIALISE_ [ Int ] 1 { _A_ 1 _U_ 1 _N_ _S_ "U(P)" {_A_ 1 _U_ 2 _N_ _N_ _F_ _IF_ARGS_ 0 1 X 4 \ (u0 :: Float#) -> case _APP_ _WRKR_ _SPEC_ _CONSTM_ RealFrac properFraction (Float) [ (Int) ] [ u0 ] of { _ALG_ _TUP_2 (u1 :: Int) (u2 :: Float) -> u1; _NO_DEFLT_ } _N_} _F_ _IF_ARGS_ 0 1 X 4 \ (u0 :: Float) -> case _APP_ _SPEC_ _CONSTM_ RealFrac properFraction (Float) [ (Int) ] [ u0 ] of { _ALG_ _TUP_2 (u1 :: Int) (u2 :: Float) -> u1; _NO_DEFLT_ } _N_ }, [ Integer ] 1 { _A_ 1 _U_ 1 _N_ _S_ "U(P)" {_A_ 1 _U_ 2 _N_ _N_ _F_ _IF_ARGS_ 0 1 X 4 \ (u0 :: Float#) -> case _APP_ _WRKR_ _SPEC_ _CONSTM_ RealFrac properFraction (Float) [ (Integer) ] [ u0 ] of { _ALG_ _TUP_2 (u1 :: Integer) (u2 :: Float) -> u1; _NO_DEFLT_ } _N_} _F_ _IF_ARGS_ 0 1 X 4 \ (u0 :: Float) -> case _APP_ _SPEC_ _CONSTM_ RealFrac properFraction (Float) [ (Integer) ] [ u0 ] of { _ALG_ _TUP_2 (u1 :: Integer) (u2 :: Float) -> u1; _NO_DEFLT_ } _N_ } },
+ round = { _A_ 1 _U_ 21 _N_ _N_ _N_ _SPECIALISE_ [ Int ] 1 { _A_ 1 _U_ 1 _N_ _S_ "U(P)" {_A_ 1 _U_ 2 _N_ _N_ _N_ _N_} _N_ _N_ }, [ Integer ] 1 { _A_ 1 _U_ 1 _N_ _S_ "U(P)" {_A_ 1 _U_ 2 _N_ _N_ _N_ _N_} _N_ _N_ } },
+ ceiling = { _A_ 1 _U_ 21 _N_ _N_ _N_ _SPECIALISE_ [ Int ] 1 { _A_ 1 _U_ 1 _N_ _S_ "U(P)" {_A_ 1 _U_ 2 _N_ _N_ _N_ _N_} _N_ _N_ }, [ Integer ] 1 { _A_ 1 _U_ 1 _N_ _S_ "U(P)" {_A_ 1 _U_ 2 _N_ _N_ _N_ _N_} _N_ _N_ } },
+ floor = { _A_ 1 _U_ 21 _N_ _N_ _N_ _SPECIALISE_ [ Int ] 1 { _A_ 1 _U_ 1 _N_ _S_ "U(P)" {_A_ 1 _U_ 2 _N_ _N_ _N_ _N_} _N_ _N_ }, [ Integer ] 1 { _A_ 1 _U_ 1 _N_ _S_ "U(P)" {_A_ 1 _U_ 2 _N_ _N_ _N_ _N_} _N_ _N_ } } #-}
instance Text Float
{-# GHC_PRAGMA _M_ PreludeCore {-dfun-} _A_ 0 _N_ _N_ _N_ _F_ _IF_ARGS_ 0 0 X 5 _!_ _TUP_4 [(Int -> [Char] -> [(Float, [Char])]), (Int -> Float -> [Char] -> [Char]), ([Char] -> [([Float], [Char])]), ([Float] -> [Char] -> [Char])] [_CONSTM_ Text readsPrec (Float), _CONSTM_ Text showsPrec (Float), _CONSTM_ Text readList (Float), _CONSTM_ Text showList (Float)] _N_
- readsPrec = _A_ 2 _U_ 02 _N_ _S_ "AL" {_A_ 1 _U_ 2 _N_ _N_ _N_ _N_} _N_ _N_,
- showsPrec = _A_ 1 _U_ 222 _N_ _N_ _N_ _N_,
- readList = _A_ 0 _U_ 2 _N_ _N_ _N_ _N_,
- showList = _A_ 0 _U_ 12 _N_ _N_ _N_ _N_ #-}
+ readsPrec = { _A_ 2 _U_ 02 _N_ _S_ "AL" {_A_ 1 _U_ 2 _N_ _N_ _N_ _N_} _N_ _N_ },
+ showsPrec = { _A_ 1 _U_ 222 _N_ _N_ _N_ _N_ },
+ readList = { _A_ 0 _U_ 2 _N_ _N_ _N_ _N_ },
+ showList = { _A_ 0 _U_ 12 _N_ _N_ _N_ _N_ } #-}
instance _CCallable Float
{-# GHC_PRAGMA _M_ PreludeCore {-dfun-} _A_ 0 _N_ _N_ _N_ _F_ _IF_ARGS_ 0 0 X 1 _!_ _TUP_0 [] [] _N_ #-}
instance _CReturnable Float
-{-# GHC_PRAGMA INTERFACE VERSION 5 #-}
+{-# GHC_PRAGMA INTERFACE VERSION 6 #-}
interface PreludeCore where
import PreludeBuiltin(Int(..), Tuple0, _Addr(..), _Word(..))
import PreludeGlaMisc(_MallocPtr(..), _StablePtr(..))
{-# GHC_PRAGMA _A_ 3 _U_ 222 _N_ _S_ _!_ _N_ _N_ #-}
instance Enum Int
{-# GHC_PRAGMA _M_ PreludeCore {-dfun-} _A_ 0 _N_ _N_ _N_ _F_ _IF_ARGS_ 0 0 X 6 _!_ _TUP_5 [{{Ord Int}}, (Int -> [Int]), (Int -> Int -> [Int]), (Int -> Int -> [Int]), (Int -> Int -> Int -> [Int])] [_DFUN_ Ord (Int), _CONSTM_ Enum enumFrom (Int), _CONSTM_ Enum enumFromThen (Int), _CONSTM_ Enum enumFromTo (Int), _CONSTM_ Enum enumFromThenTo (Int)] _N_
- enumFrom = _A_ 1 _U_ 2 _N_ _N_ _F_ _ALWAYS_ \ (u0 :: Int) -> _LETREC_ {(u1 :: Int -> [Int]) = \ (u2 :: Int) -> let {(u6 :: [Int]) = let {(u5 :: Int) = case u2 of { _ALG_ I# (u3 :: Int#) -> case _#_ plusInt# [] [u3, 1#] of { _PRIM_ (u4 :: Int#) -> _!_ I# [] [u4] }; _NO_DEFLT_ }} in _APP_ u1 [ u5 ]} in _!_ (:) [Int] [u2, u6]} in _APP_ u1 [ u0 ] _N_,
- enumFromThen = _A_ 2 _U_ 21 _N_ _N_ _N_ _N_,
- enumFromTo = _A_ 2 _U_ 12 _N_ _S_ "SS" _F_ _ALWAYS_ \ (u0 :: Int) (u1 :: Int) -> case u0 of { _ALG_ I# (u2 :: Int#) -> _LETREC_ {(u3 :: Int# -> [Int]) = \ (u4 :: Int#) -> case u1 of { _ALG_ I# (u5 :: Int#) -> case _#_ leInt# [] [u4, u5] of { _ALG_ True -> let {(u7 :: [Int]) = case _#_ plusInt# [] [u4, 1#] of { _PRIM_ (u6 :: Int#) -> _APP_ u3 [ u6 ] }} in let {(u8 :: Int) = _!_ I# [] [u4]} in _!_ (:) [Int] [u8, u7]; False -> _!_ _NIL_ [Int] []; _NO_DEFLT_ }; _NO_DEFLT_ }} in _APP_ u3 [ u2 ]; _NO_DEFLT_ } _N_,
- enumFromThenTo = _A_ 3 _U_ 222 _N_ _N_ _N_ _N_ #-}
+ enumFrom = { _A_ 1 _U_ 2 _N_ _N_ _F_ _ALWAYS_ \ (u0 :: Int) -> _LETREC_ {(u1 :: Int -> [Int]) = \ (u2 :: Int) -> let {(u6 :: [Int]) = let {(u5 :: Int) = case u2 of { _ALG_ I# (u3 :: Int#) -> case _#_ plusInt# [] [u3, 1#] of { _PRIM_ (u4 :: Int#) -> _!_ I# [] [u4] }; _NO_DEFLT_ }} in _APP_ u1 [ u5 ]} in _!_ (:) [Int] [u2, u6]} in _APP_ u1 [ u0 ] _N_ },
+ enumFromThen = { _A_ 2 _U_ 21 _N_ _N_ _N_ _N_ },
+ enumFromTo = { _A_ 2 _U_ 12 _N_ _S_ "SS" _F_ _ALWAYS_ \ (u0 :: Int) (u1 :: Int) -> case u0 of { _ALG_ I# (u2 :: Int#) -> _LETREC_ {(u3 :: Int# -> [Int]) = \ (u4 :: Int#) -> case u1 of { _ALG_ I# (u5 :: Int#) -> case _#_ leInt# [] [u4, u5] of { _ALG_ True -> let {(u7 :: [Int]) = case _#_ plusInt# [] [u4, 1#] of { _PRIM_ (u6 :: Int#) -> _APP_ u3 [ u6 ] }} in let {(u8 :: Int) = _!_ I# [] [u4]} in _!_ (:) [Int] [u8, u7]; False -> _!_ _NIL_ [Int] []; _NO_DEFLT_ }; _NO_DEFLT_ }} in _APP_ u3 [ u2 ]; _NO_DEFLT_ } _N_ },
+ enumFromThenTo = { _A_ 3 _U_ 222 _N_ _N_ _N_ _N_ } #-}
instance Eq Int
{-# GHC_PRAGMA _M_ PreludeCore {-dfun-} _A_ 0 _N_ _N_ _N_ _F_ _IF_ARGS_ 0 0 X 3 _!_ _TUP_2 [(Int -> Int -> Bool), (Int -> Int -> Bool)] [_CONSTM_ Eq (==) (Int), _CONSTM_ Eq (/=) (Int)] _N_
- (==) = _A_ 2 _U_ 11 _N_ _S_ "U(P)U(P)" {_A_ 2 _U_ 22 _N_ _N_ _F_ _IF_ARGS_ 0 2 XX 1 \ (u0 :: Int#) (u1 :: Int#) -> _#_ eqInt# [] [u0, u1] _N_} _F_ _IF_ARGS_ 0 2 CC 3 \ (u0 :: Int) (u1 :: Int) -> case u0 of { _ALG_ I# (u2 :: Int#) -> case u1 of { _ALG_ I# (u3 :: Int#) -> _#_ eqInt# [] [u2, u3]; _NO_DEFLT_ }; _NO_DEFLT_ } _N_,
- (/=) = _A_ 2 _U_ 11 _N_ _S_ "U(P)U(P)" {_A_ 2 _U_ 22 _N_ _N_ _F_ _IF_ARGS_ 0 2 XX 1 \ (u0 :: Int#) (u1 :: Int#) -> _#_ neInt# [] [u0, u1] _N_} _F_ _IF_ARGS_ 0 2 CC 3 \ (u0 :: Int) (u1 :: Int) -> case u0 of { _ALG_ I# (u2 :: Int#) -> case u1 of { _ALG_ I# (u3 :: Int#) -> _#_ neInt# [] [u2, u3]; _NO_DEFLT_ }; _NO_DEFLT_ } _N_ #-}
+ (==) = { _A_ 2 _U_ 11 _N_ _S_ "U(P)U(P)" {_A_ 2 _U_ 22 _N_ _N_ _F_ _IF_ARGS_ 0 2 XX 1 \ (u0 :: Int#) (u1 :: Int#) -> _#_ eqInt# [] [u0, u1] _N_} _F_ _IF_ARGS_ 0 2 CC 3 \ (u0 :: Int) (u1 :: Int) -> case u0 of { _ALG_ I# (u2 :: Int#) -> case u1 of { _ALG_ I# (u3 :: Int#) -> _#_ eqInt# [] [u2, u3]; _NO_DEFLT_ }; _NO_DEFLT_ } _N_ },
+ (/=) = { _A_ 2 _U_ 11 _N_ _S_ "U(P)U(P)" {_A_ 2 _U_ 22 _N_ _N_ _F_ _IF_ARGS_ 0 2 XX 1 \ (u0 :: Int#) (u1 :: Int#) -> _#_ neInt# [] [u0, u1] _N_} _F_ _IF_ARGS_ 0 2 CC 3 \ (u0 :: Int) (u1 :: Int) -> case u0 of { _ALG_ I# (u2 :: Int#) -> case u1 of { _ALG_ I# (u3 :: Int#) -> _#_ neInt# [] [u2, u3]; _NO_DEFLT_ }; _NO_DEFLT_ } _N_ } #-}
instance Eq _Addr
{-# GHC_PRAGMA _M_ PreludeCore {-dfun-} _A_ 0 _N_ _N_ _N_ _F_ _IF_ARGS_ 0 0 X 3 _!_ _TUP_2 [(_Addr -> _Addr -> Bool), (_Addr -> _Addr -> Bool)] [_CONSTM_ Eq (==) (_Addr), _CONSTM_ Eq (/=) (_Addr)] _N_
- (==) = _A_ 2 _U_ 11 _N_ _S_ "U(P)U(P)" {_A_ 2 _U_ 22 _N_ _N_ _F_ _IF_ARGS_ 0 2 XX 1 \ (u0 :: Addr#) (u1 :: Addr#) -> _#_ eqAddr# [] [u0, u1] _N_} _F_ _IF_ARGS_ 0 2 CC 3 \ (u0 :: _Addr) (u1 :: _Addr) -> case u0 of { _ALG_ A# (u2 :: Addr#) -> case u1 of { _ALG_ A# (u3 :: Addr#) -> _#_ eqAddr# [] [u2, u3]; _NO_DEFLT_ }; _NO_DEFLT_ } _N_,
- (/=) = _A_ 2 _U_ 11 _N_ _S_ "U(P)U(P)" {_A_ 2 _U_ 22 _N_ _N_ _F_ _IF_ARGS_ 0 2 XX 1 \ (u0 :: Addr#) (u1 :: Addr#) -> _#_ neAddr# [] [u0, u1] _N_} _F_ _IF_ARGS_ 0 2 CC 3 \ (u0 :: _Addr) (u1 :: _Addr) -> case u0 of { _ALG_ A# (u2 :: Addr#) -> case u1 of { _ALG_ A# (u3 :: Addr#) -> _#_ neAddr# [] [u2, u3]; _NO_DEFLT_ }; _NO_DEFLT_ } _N_ #-}
+ (==) = { _A_ 2 _U_ 11 _N_ _S_ "U(P)U(P)" {_A_ 2 _U_ 22 _N_ _N_ _F_ _IF_ARGS_ 0 2 XX 1 \ (u0 :: Addr#) (u1 :: Addr#) -> _#_ eqAddr# [] [u0, u1] _N_} _F_ _IF_ARGS_ 0 2 CC 3 \ (u0 :: _Addr) (u1 :: _Addr) -> case u0 of { _ALG_ A# (u2 :: Addr#) -> case u1 of { _ALG_ A# (u3 :: Addr#) -> _#_ eqAddr# [] [u2, u3]; _NO_DEFLT_ }; _NO_DEFLT_ } _N_ },
+ (/=) = { _A_ 2 _U_ 11 _N_ _S_ "U(P)U(P)" {_A_ 2 _U_ 22 _N_ _N_ _F_ _IF_ARGS_ 0 2 XX 1 \ (u0 :: Addr#) (u1 :: Addr#) -> _#_ neAddr# [] [u0, u1] _N_} _F_ _IF_ARGS_ 0 2 CC 3 \ (u0 :: _Addr) (u1 :: _Addr) -> case u0 of { _ALG_ A# (u2 :: Addr#) -> case u1 of { _ALG_ A# (u3 :: Addr#) -> _#_ neAddr# [] [u2, u3]; _NO_DEFLT_ }; _NO_DEFLT_ } _N_ } #-}
instance Eq _Word
{-# GHC_PRAGMA _M_ PreludeCore {-dfun-} _A_ 0 _N_ _N_ _N_ _F_ _IF_ARGS_ 0 0 X 3 _!_ _TUP_2 [(_Word -> _Word -> Bool), (_Word -> _Word -> Bool)] [_CONSTM_ Eq (==) (_Word), _CONSTM_ Eq (/=) (_Word)] _N_
- (==) = _A_ 2 _U_ 11 _N_ _S_ "U(P)U(P)" {_A_ 2 _U_ 22 _N_ _N_ _F_ _IF_ARGS_ 0 2 XX 1 \ (u0 :: Word#) (u1 :: Word#) -> _#_ eqWord# [] [u0, u1] _N_} _F_ _IF_ARGS_ 0 2 CC 3 \ (u0 :: _Word) (u1 :: _Word) -> case u0 of { _ALG_ W# (u2 :: Word#) -> case u1 of { _ALG_ W# (u3 :: Word#) -> _#_ eqWord# [] [u2, u3]; _NO_DEFLT_ }; _NO_DEFLT_ } _N_,
- (/=) = _A_ 2 _U_ 11 _N_ _S_ "U(P)U(P)" {_A_ 2 _U_ 22 _N_ _N_ _F_ _IF_ARGS_ 0 2 XX 1 \ (u0 :: Word#) (u1 :: Word#) -> _#_ neWord# [] [u0, u1] _N_} _F_ _IF_ARGS_ 0 2 CC 3 \ (u0 :: _Word) (u1 :: _Word) -> case u0 of { _ALG_ W# (u2 :: Word#) -> case u1 of { _ALG_ W# (u3 :: Word#) -> _#_ neWord# [] [u2, u3]; _NO_DEFLT_ }; _NO_DEFLT_ } _N_ #-}
+ (==) = { _A_ 2 _U_ 11 _N_ _S_ "U(P)U(P)" {_A_ 2 _U_ 22 _N_ _N_ _F_ _IF_ARGS_ 0 2 XX 1 \ (u0 :: Word#) (u1 :: Word#) -> _#_ eqWord# [] [u0, u1] _N_} _F_ _IF_ARGS_ 0 2 CC 3 \ (u0 :: _Word) (u1 :: _Word) -> case u0 of { _ALG_ W# (u2 :: Word#) -> case u1 of { _ALG_ W# (u3 :: Word#) -> _#_ eqWord# [] [u2, u3]; _NO_DEFLT_ }; _NO_DEFLT_ } _N_ },
+ (/=) = { _A_ 2 _U_ 11 _N_ _S_ "U(P)U(P)" {_A_ 2 _U_ 22 _N_ _N_ _F_ _IF_ARGS_ 0 2 XX 1 \ (u0 :: Word#) (u1 :: Word#) -> _#_ neWord# [] [u0, u1] _N_} _F_ _IF_ARGS_ 0 2 CC 3 \ (u0 :: _Word) (u1 :: _Word) -> case u0 of { _ALG_ W# (u2 :: Word#) -> case u1 of { _ALG_ W# (u3 :: Word#) -> _#_ neWord# [] [u2, u3]; _NO_DEFLT_ }; _NO_DEFLT_ } _N_ } #-}
instance Integral Int
{-# GHC_PRAGMA _M_ PreludeCore {-dfun-} _A_ 0 _N_ _N_ _N_ _F_ _IF_ARGS_ 0 0 X 13 _!_ _TUP_12 [{{Real Int}}, {{Ix Int}}, (Int -> Int -> Int), (Int -> Int -> Int), (Int -> Int -> Int), (Int -> Int -> Int), (Int -> Int -> (Int, Int)), (Int -> Int -> (Int, Int)), (Int -> Bool), (Int -> Bool), (Int -> Integer), (Int -> Int)] [_DFUN_ Real (Int), _DFUN_ Ix (Int), _CONSTM_ Integral quot (Int), _CONSTM_ Integral rem (Int), _CONSTM_ Integral div (Int), _CONSTM_ Integral mod (Int), _CONSTM_ Integral quotRem (Int), _CONSTM_ Integral divMod (Int), _CONSTM_ Integral even (Int), _CONSTM_ Integral odd (Int), _CONSTM_ Integral toInteger (Int), _CONSTM_ Integral toInt (Int)] _N_
- quot = _A_ 2 _U_ 11 _N_ _S_ "U(P)U(P)" {_A_ 2 _U_ 22 _N_ _N_ _F_ _IF_ARGS_ 0 2 XC 5 \ (u0 :: Int#) (u1 :: Int#) -> case u1 of { _PRIM_ 0# -> _APP_ _TYAPP_ error { Int } [ _NOREP_S_ "Integral.Int.quot{PreludeCore}: divide by 0\n" ]; (u2 :: Int#) -> case _#_ quotInt# [] [u0, u1] of { _PRIM_ (u3 :: Int#) -> _!_ I# [] [u3] } } _N_} _F_ _IF_ARGS_ 0 2 CC 7 \ (u0 :: Int) (u1 :: Int) -> case u1 of { _ALG_ I# (u2 :: Int#) -> case u2 of { _PRIM_ 0# -> _APP_ _TYAPP_ error { Int } [ _NOREP_S_ "Integral.Int.quot{PreludeCore}: divide by 0\n" ]; (u3 :: Int#) -> case u0 of { _ALG_ I# (u4 :: Int#) -> case _#_ quotInt# [] [u4, u2] of { _PRIM_ (u5 :: Int#) -> _!_ I# [] [u5] }; _NO_DEFLT_ } }; _NO_DEFLT_ } _N_,
- rem = _A_ 2 _U_ 11 _N_ _S_ "U(P)U(P)" {_A_ 2 _U_ 22 _N_ _N_ _F_ _IF_ARGS_ 0 2 XC 5 \ (u0 :: Int#) (u1 :: Int#) -> case u1 of { _PRIM_ 0# -> _APP_ _TYAPP_ error { Int } [ _NOREP_S_ "Integral.Int.rem{PreludeCore}: divide by 0\n" ]; (u2 :: Int#) -> case _#_ remInt# [] [u0, u1] of { _PRIM_ (u3 :: Int#) -> _!_ I# [] [u3] } } _N_} _F_ _IF_ARGS_ 0 2 CC 7 \ (u0 :: Int) (u1 :: Int) -> case u1 of { _ALG_ I# (u2 :: Int#) -> case u2 of { _PRIM_ 0# -> _APP_ _TYAPP_ error { Int } [ _NOREP_S_ "Integral.Int.rem{PreludeCore}: divide by 0\n" ]; (u3 :: Int#) -> case u0 of { _ALG_ I# (u4 :: Int#) -> case _#_ remInt# [] [u4, u2] of { _PRIM_ (u5 :: Int#) -> _!_ I# [] [u5] }; _NO_DEFLT_ } }; _NO_DEFLT_ } _N_,
- div = _A_ 2 _U_ 11 _N_ _S_ "U(P)U(P)" {_A_ 2 _U_ 22 _N_ _N_ _N_ _N_} _N_ _N_,
- mod = _A_ 2 _U_ 11 _N_ _S_ "U(P)U(P)" {_A_ 2 _U_ 22 _N_ _N_ _N_ _N_} _N_ _N_,
- quotRem = _A_ 2 _U_ 11 _N_ _S_ "U(P)U(P)" {_A_ 2 _U_ 22 _N_ _N_ _N_ _N_} _N_ _N_,
- divMod = _A_ 2 _U_ 11 _N_ _S_ "U(P)U(P)" {_A_ 2 _U_ 22 _N_ _N_ _N_ _N_} _N_ _N_,
- even = _A_ 1 _U_ 1 _N_ _S_ "U(P)" {_A_ 1 _U_ 2 _N_ _N_ _N_ _N_} _N_ _N_,
- odd = _A_ 1 _U_ 1 _N_ _S_ "U(P)" {_A_ 1 _U_ 2 _N_ _N_ _N_ _N_} _N_ _N_,
- toInteger = _A_ 1 _U_ 1 _N_ _S_ "U(P)" {_A_ 1 _U_ 2 _N_ _N_ _F_ _IF_ARGS_ 0 1 X 1 \ (u0 :: Int#) -> _#_ int2Integer# [] [u0] _N_} _F_ _IF_ARGS_ 0 1 C 2 \ (u0 :: Int) -> case u0 of { _ALG_ I# (u1 :: Int#) -> _#_ int2Integer# [] [u1]; _NO_DEFLT_ } _N_,
- toInt = _A_ 1 _U_ 1 _N_ _S_ "U(P)" {_A_ 1 _U_ 2 _N_ _N_ _F_ _IF_ARGS_ 0 1 X 2 \ (u0 :: Int#) -> _!_ I# [] [u0] _N_} _F_ _IF_ARGS_ 0 1 X 1 \ (u0 :: Int) -> u0 _N_ #-}
+ quot = { _A_ 2 _U_ 11 _N_ _S_ "U(P)U(P)" {_A_ 2 _U_ 22 _N_ _N_ _F_ _IF_ARGS_ 0 2 XC 5 \ (u0 :: Int#) (u1 :: Int#) -> case u1 of { _PRIM_ 0# -> _APP_ _TYAPP_ error { Int } [ _NOREP_S_ "Integral.Int.quot{PreludeCore}: divide by 0\n" ]; (u2 :: Int#) -> case _#_ quotInt# [] [u0, u1] of { _PRIM_ (u3 :: Int#) -> _!_ I# [] [u3] } } _N_} _F_ _IF_ARGS_ 0 2 CC 7 \ (u0 :: Int) (u1 :: Int) -> case u1 of { _ALG_ I# (u2 :: Int#) -> case u2 of { _PRIM_ 0# -> _APP_ _TYAPP_ error { Int } [ _NOREP_S_ "Integral.Int.quot{PreludeCore}: divide by 0\n" ]; (u3 :: Int#) -> case u0 of { _ALG_ I# (u4 :: Int#) -> case _#_ quotInt# [] [u4, u2] of { _PRIM_ (u5 :: Int#) -> _!_ I# [] [u5] }; _NO_DEFLT_ } }; _NO_DEFLT_ } _N_ },
+ rem = { _A_ 2 _U_ 11 _N_ _S_ "U(P)U(P)" {_A_ 2 _U_ 22 _N_ _N_ _F_ _IF_ARGS_ 0 2 XC 5 \ (u0 :: Int#) (u1 :: Int#) -> case u1 of { _PRIM_ 0# -> _APP_ _TYAPP_ error { Int } [ _NOREP_S_ "Integral.Int.rem{PreludeCore}: divide by 0\n" ]; (u2 :: Int#) -> case _#_ remInt# [] [u0, u1] of { _PRIM_ (u3 :: Int#) -> _!_ I# [] [u3] } } _N_} _F_ _IF_ARGS_ 0 2 CC 7 \ (u0 :: Int) (u1 :: Int) -> case u1 of { _ALG_ I# (u2 :: Int#) -> case u2 of { _PRIM_ 0# -> _APP_ _TYAPP_ error { Int } [ _NOREP_S_ "Integral.Int.rem{PreludeCore}: divide by 0\n" ]; (u3 :: Int#) -> case u0 of { _ALG_ I# (u4 :: Int#) -> case _#_ remInt# [] [u4, u2] of { _PRIM_ (u5 :: Int#) -> _!_ I# [] [u5] }; _NO_DEFLT_ } }; _NO_DEFLT_ } _N_ },
+ div = { _A_ 2 _U_ 11 _N_ _S_ "U(P)U(P)" {_A_ 2 _U_ 22 _N_ _N_ _N_ _N_} _N_ _N_ },
+ mod = { _A_ 2 _U_ 11 _N_ _S_ "U(P)U(P)" {_A_ 2 _U_ 22 _N_ _N_ _N_ _N_} _N_ _N_ },
+ quotRem = { _A_ 2 _U_ 11 _N_ _S_ "U(P)U(P)" {_A_ 2 _U_ 22 _N_ _N_ _N_ _N_} _N_ _N_ },
+ divMod = { _A_ 2 _U_ 11 _N_ _S_ "U(P)U(P)" {_A_ 2 _U_ 22 _N_ _N_ _N_ _N_} _N_ _N_ },
+ even = { _A_ 1 _U_ 1 _N_ _S_ "U(P)" {_A_ 1 _U_ 2 _N_ _N_ _N_ _N_} _N_ _N_ },
+ odd = { _A_ 1 _U_ 1 _N_ _S_ "U(P)" {_A_ 1 _U_ 2 _N_ _N_ _N_ _N_} _N_ _N_ },
+ toInteger = { _A_ 1 _U_ 1 _N_ _S_ "U(P)" {_A_ 1 _U_ 2 _N_ _N_ _F_ _IF_ARGS_ 0 1 X 1 \ (u0 :: Int#) -> _#_ int2Integer# [] [u0] _N_} _F_ _IF_ARGS_ 0 1 C 2 \ (u0 :: Int) -> case u0 of { _ALG_ I# (u1 :: Int#) -> _#_ int2Integer# [] [u1]; _NO_DEFLT_ } _N_ },
+ toInt = { _A_ 1 _U_ 1 _N_ _S_ "U(P)" {_A_ 1 _U_ 2 _N_ _N_ _F_ _IF_ARGS_ 0 1 X 2 \ (u0 :: Int#) -> _!_ I# [] [u0] _N_} _F_ _IF_ARGS_ 0 1 X 1 \ (u0 :: Int) -> u0 _N_ } #-}
instance Ix Int
{-# GHC_PRAGMA _M_ PreludeCore {-dfun-} _A_ 0 _N_ _N_ _N_ _F_ _IF_ARGS_ 0 0 X 5 _!_ _TUP_4 [{{Ord Int}}, ((Int, Int) -> [Int]), ((Int, Int) -> Int -> Int), ((Int, Int) -> Int -> Bool)] [_DFUN_ Ord (Int), _CONSTM_ Ix range (Int), _CONSTM_ Ix index (Int), _CONSTM_ Ix inRange (Int)] _N_
- range = _A_ 1 _U_ 1 _N_ _S_ "U(U(P)U(P))" {_A_ 2 _U_ 22 _N_ _N_ _N_ _N_} _N_ _N_,
- index = _A_ 2 _U_ 11 _N_ _S_ "U(U(P)U(P))U(P)" {_A_ 3 _U_ 222 _N_ _N_ _N_ _N_} _N_ _N_,
- inRange = _A_ 2 _U_ 11 _N_ _S_ "U(U(P)U(P))U(P)" {_A_ 3 _U_ 222 _N_ _N_ _F_ _IF_ARGS_ 0 3 XXX 5 \ (u0 :: Int#) (u1 :: Int#) (u2 :: Int#) -> case _#_ leInt# [] [u0, u2] of { _ALG_ True -> _#_ leInt# [] [u2, u1]; False -> _!_ False [] []; _NO_DEFLT_ } _N_} _F_ _ALWAYS_ \ (u0 :: (Int, Int)) (u1 :: Int) -> case u0 of { _ALG_ _TUP_2 (u2 :: Int) (u3 :: Int) -> case u2 of { _ALG_ I# (u4 :: Int#) -> case u3 of { _ALG_ I# (u5 :: Int#) -> case u1 of { _ALG_ I# (u6 :: Int#) -> case _#_ leInt# [] [u4, u6] of { _ALG_ True -> _#_ leInt# [] [u6, u5]; False -> _!_ False [] []; _NO_DEFLT_ }; _NO_DEFLT_ }; _NO_DEFLT_ }; _NO_DEFLT_ }; _NO_DEFLT_ } _N_ #-}
+ range = { _A_ 1 _U_ 1 _N_ _S_ "U(U(P)U(P))" {_A_ 2 _U_ 22 _N_ _N_ _N_ _N_} _N_ _N_ },
+ index = { _A_ 2 _U_ 11 _N_ _S_ "U(U(P)U(P))U(P)" {_A_ 3 _U_ 222 _N_ _N_ _N_ _N_} _N_ _N_ },
+ inRange = { _A_ 2 _U_ 11 _N_ _S_ "U(U(P)U(P))U(P)" {_A_ 3 _U_ 222 _N_ _N_ _F_ _IF_ARGS_ 0 3 XXX 5 \ (u0 :: Int#) (u1 :: Int#) (u2 :: Int#) -> case _#_ leInt# [] [u0, u2] of { _ALG_ True -> _#_ leInt# [] [u2, u1]; False -> _!_ False [] []; _NO_DEFLT_ } _N_} _F_ _ALWAYS_ \ (u0 :: (Int, Int)) (u1 :: Int) -> case u0 of { _ALG_ _TUP_2 (u2 :: Int) (u3 :: Int) -> case u2 of { _ALG_ I# (u4 :: Int#) -> case u3 of { _ALG_ I# (u5 :: Int#) -> case u1 of { _ALG_ I# (u6 :: Int#) -> case _#_ leInt# [] [u4, u6] of { _ALG_ True -> _#_ leInt# [] [u6, u5]; False -> _!_ False [] []; _NO_DEFLT_ }; _NO_DEFLT_ }; _NO_DEFLT_ }; _NO_DEFLT_ }; _NO_DEFLT_ } _N_ } #-}
instance Num Int
{-# GHC_PRAGMA _M_ PreludeCore {-dfun-} _A_ 0 _N_ _N_ _N_ _F_ _IF_ARGS_ 0 0 X 11 _!_ _TUP_10 [{{Eq Int}}, {{Text Int}}, (Int -> Int -> Int), (Int -> Int -> Int), (Int -> Int -> Int), (Int -> Int), (Int -> Int), (Int -> Int), (Integer -> Int), (Int -> Int)] [_DFUN_ Eq (Int), _DFUN_ Text (Int), _CONSTM_ Num (+) (Int), _CONSTM_ Num (-) (Int), _CONSTM_ Num (*) (Int), _CONSTM_ Num negate (Int), _CONSTM_ Num abs (Int), _CONSTM_ Num signum (Int), _CONSTM_ Num fromInteger (Int), _CONSTM_ Num fromInt (Int)] _N_
- (+) = _A_ 2 _U_ 11 _N_ _S_ "U(P)U(P)" {_A_ 2 _U_ 22 _N_ _N_ _F_ _IF_ARGS_ 0 2 XX 3 \ (u0 :: Int#) (u1 :: Int#) -> case _#_ plusInt# [] [u0, u1] of { _PRIM_ (u2 :: Int#) -> _!_ I# [] [u2] } _N_} _F_ _IF_ARGS_ 0 2 CC 5 \ (u0 :: Int) (u1 :: Int) -> case u0 of { _ALG_ I# (u2 :: Int#) -> case u1 of { _ALG_ I# (u3 :: Int#) -> case _#_ plusInt# [] [u2, u3] of { _PRIM_ (u4 :: Int#) -> _!_ I# [] [u4] }; _NO_DEFLT_ }; _NO_DEFLT_ } _N_,
- (-) = _A_ 2 _U_ 11 _N_ _S_ "U(P)U(P)" {_A_ 2 _U_ 22 _N_ _N_ _F_ _IF_ARGS_ 0 2 XX 3 \ (u0 :: Int#) (u1 :: Int#) -> case _#_ minusInt# [] [u0, u1] of { _PRIM_ (u2 :: Int#) -> _!_ I# [] [u2] } _N_} _F_ _IF_ARGS_ 0 2 CC 5 \ (u0 :: Int) (u1 :: Int) -> case u0 of { _ALG_ I# (u2 :: Int#) -> case u1 of { _ALG_ I# (u3 :: Int#) -> case _#_ minusInt# [] [u2, u3] of { _PRIM_ (u4 :: Int#) -> _!_ I# [] [u4] }; _NO_DEFLT_ }; _NO_DEFLT_ } _N_,
- (*) = _A_ 2 _U_ 11 _N_ _S_ "U(P)U(P)" {_A_ 2 _U_ 22 _N_ _N_ _F_ _IF_ARGS_ 0 2 XX 3 \ (u0 :: Int#) (u1 :: Int#) -> case _#_ timesInt# [] [u0, u1] of { _PRIM_ (u2 :: Int#) -> _!_ I# [] [u2] } _N_} _F_ _IF_ARGS_ 0 2 CC 5 \ (u0 :: Int) (u1 :: Int) -> case u0 of { _ALG_ I# (u2 :: Int#) -> case u1 of { _ALG_ I# (u3 :: Int#) -> case _#_ timesInt# [] [u2, u3] of { _PRIM_ (u4 :: Int#) -> _!_ I# [] [u4] }; _NO_DEFLT_ }; _NO_DEFLT_ } _N_,
- negate = _A_ 1 _U_ 1 _N_ _S_ "U(P)" {_A_ 1 _U_ 2 _N_ _N_ _F_ _IF_ARGS_ 0 1 X 3 \ (u0 :: Int#) -> case _#_ negateInt# [] [u0] of { _PRIM_ (u1 :: Int#) -> _!_ I# [] [u1] } _N_} _F_ _IF_ARGS_ 0 1 C 4 \ (u0 :: Int) -> case u0 of { _ALG_ I# (u1 :: Int#) -> case _#_ negateInt# [] [u1] of { _PRIM_ (u2 :: Int#) -> _!_ I# [] [u2] }; _NO_DEFLT_ } _N_,
- abs = _A_ 1 _U_ 1 _N_ _S_ "U(P)" {_A_ 1 _U_ 2 _N_ _N_ _N_ _N_} _N_ _N_,
- signum = _A_ 1 _U_ 1 _N_ _S_ "U(P)" {_A_ 1 _U_ 2 _N_ _N_ _N_ _N_} _N_ _N_,
- fromInteger = _A_ 1 _U_ 1 _N_ _S_ "U(PPP)" {_A_ 3 _U_ 222 _N_ _N_ _F_ _IF_ARGS_ 0 3 XXX 3 \ (u0 :: Int#) (u1 :: Int#) (u2 :: ByteArray#) -> case _#_ integer2Int# [] [u0, u1, u2] of { _PRIM_ (u3 :: Int#) -> _!_ I# [] [u3] } _N_} _F_ _IF_ARGS_ 0 1 C 4 \ (u0 :: Integer) -> case u0 of { _ALG_ J# (u1 :: Int#) (u2 :: Int#) (u3 :: ByteArray#) -> case _#_ integer2Int# [] [u1, u2, u3] of { _PRIM_ (u4 :: Int#) -> _!_ I# [] [u4] }; _NO_DEFLT_ } _N_,
- fromInt = _A_ 1 _U_ 1 _N_ _S_ "U(P)" {_A_ 1 _U_ 2 _N_ _N_ _F_ _IF_ARGS_ 0 1 X 2 \ (u0 :: Int#) -> _!_ I# [] [u0] _N_} _F_ _IF_ARGS_ 0 1 X 1 \ (u0 :: Int) -> u0 _N_ #-}
+ (+) = { _A_ 2 _U_ 11 _N_ _S_ "U(P)U(P)" {_A_ 2 _U_ 22 _N_ _N_ _F_ _IF_ARGS_ 0 2 XX 3 \ (u0 :: Int#) (u1 :: Int#) -> case _#_ plusInt# [] [u0, u1] of { _PRIM_ (u2 :: Int#) -> _!_ I# [] [u2] } _N_} _F_ _IF_ARGS_ 0 2 CC 5 \ (u0 :: Int) (u1 :: Int) -> case u0 of { _ALG_ I# (u2 :: Int#) -> case u1 of { _ALG_ I# (u3 :: Int#) -> case _#_ plusInt# [] [u2, u3] of { _PRIM_ (u4 :: Int#) -> _!_ I# [] [u4] }; _NO_DEFLT_ }; _NO_DEFLT_ } _N_ },
+ (-) = { _A_ 2 _U_ 11 _N_ _S_ "U(P)U(P)" {_A_ 2 _U_ 22 _N_ _N_ _F_ _IF_ARGS_ 0 2 XX 3 \ (u0 :: Int#) (u1 :: Int#) -> case _#_ minusInt# [] [u0, u1] of { _PRIM_ (u2 :: Int#) -> _!_ I# [] [u2] } _N_} _F_ _IF_ARGS_ 0 2 CC 5 \ (u0 :: Int) (u1 :: Int) -> case u0 of { _ALG_ I# (u2 :: Int#) -> case u1 of { _ALG_ I# (u3 :: Int#) -> case _#_ minusInt# [] [u2, u3] of { _PRIM_ (u4 :: Int#) -> _!_ I# [] [u4] }; _NO_DEFLT_ }; _NO_DEFLT_ } _N_ },
+ (*) = { _A_ 2 _U_ 11 _N_ _S_ "U(P)U(P)" {_A_ 2 _U_ 22 _N_ _N_ _F_ _IF_ARGS_ 0 2 XX 3 \ (u0 :: Int#) (u1 :: Int#) -> case _#_ timesInt# [] [u0, u1] of { _PRIM_ (u2 :: Int#) -> _!_ I# [] [u2] } _N_} _F_ _IF_ARGS_ 0 2 CC 5 \ (u0 :: Int) (u1 :: Int) -> case u0 of { _ALG_ I# (u2 :: Int#) -> case u1 of { _ALG_ I# (u3 :: Int#) -> case _#_ timesInt# [] [u2, u3] of { _PRIM_ (u4 :: Int#) -> _!_ I# [] [u4] }; _NO_DEFLT_ }; _NO_DEFLT_ } _N_ },
+ negate = { _A_ 1 _U_ 1 _N_ _S_ "U(P)" {_A_ 1 _U_ 2 _N_ _N_ _F_ _IF_ARGS_ 0 1 X 3 \ (u0 :: Int#) -> case _#_ negateInt# [] [u0] of { _PRIM_ (u1 :: Int#) -> _!_ I# [] [u1] } _N_} _F_ _IF_ARGS_ 0 1 C 4 \ (u0 :: Int) -> case u0 of { _ALG_ I# (u1 :: Int#) -> case _#_ negateInt# [] [u1] of { _PRIM_ (u2 :: Int#) -> _!_ I# [] [u2] }; _NO_DEFLT_ } _N_ },
+ abs = { _A_ 1 _U_ 1 _N_ _S_ "U(P)" {_A_ 1 _U_ 2 _N_ _N_ _N_ _N_} _N_ _N_ },
+ signum = { _A_ 1 _U_ 1 _N_ _S_ "U(P)" {_A_ 1 _U_ 2 _N_ _N_ _N_ _N_} _N_ _N_ },
+ fromInteger = { _A_ 1 _U_ 1 _N_ _S_ "U(PPP)" {_A_ 3 _U_ 222 _N_ _N_ _F_ _IF_ARGS_ 0 3 XXX 3 \ (u0 :: Int#) (u1 :: Int#) (u2 :: ByteArray#) -> case _#_ integer2Int# [] [u0, u1, u2] of { _PRIM_ (u3 :: Int#) -> _!_ I# [] [u3] } _N_} _F_ _IF_ARGS_ 0 1 C 4 \ (u0 :: Integer) -> case u0 of { _ALG_ J# (u1 :: Int#) (u2 :: Int#) (u3 :: ByteArray#) -> case _#_ integer2Int# [] [u1, u2, u3] of { _PRIM_ (u4 :: Int#) -> _!_ I# [] [u4] }; _NO_DEFLT_ } _N_ },
+ fromInt = { _A_ 1 _U_ 1 _N_ _S_ "U(P)" {_A_ 1 _U_ 2 _N_ _N_ _F_ _IF_ARGS_ 0 1 X 2 \ (u0 :: Int#) -> _!_ I# [] [u0] _N_} _F_ _IF_ARGS_ 0 1 X 1 \ (u0 :: Int) -> u0 _N_ } #-}
instance Ord Int
{-# GHC_PRAGMA _M_ PreludeCore {-dfun-} _A_ 0 _N_ _N_ _N_ _F_ _IF_ARGS_ 0 0 X 9 _!_ _TUP_8 [{{Eq Int}}, (Int -> Int -> Bool), (Int -> Int -> Bool), (Int -> Int -> Bool), (Int -> Int -> Bool), (Int -> Int -> Int), (Int -> Int -> Int), (Int -> Int -> _CMP_TAG)] [_DFUN_ Eq (Int), _CONSTM_ Ord (<) (Int), _CONSTM_ Ord (<=) (Int), _CONSTM_ Ord (>=) (Int), _CONSTM_ Ord (>) (Int), _CONSTM_ Ord max (Int), _CONSTM_ Ord min (Int), _CONSTM_ Ord _tagCmp (Int)] _N_
- (<) = _A_ 2 _U_ 11 _N_ _S_ "U(P)U(P)" {_A_ 2 _U_ 22 _N_ _N_ _F_ _IF_ARGS_ 0 2 XX 1 \ (u0 :: Int#) (u1 :: Int#) -> _#_ ltInt# [] [u0, u1] _N_} _F_ _IF_ARGS_ 0 2 CC 3 \ (u0 :: Int) (u1 :: Int) -> case u0 of { _ALG_ I# (u2 :: Int#) -> case u1 of { _ALG_ I# (u3 :: Int#) -> _#_ ltInt# [] [u2, u3]; _NO_DEFLT_ }; _NO_DEFLT_ } _N_,
- (<=) = _A_ 2 _U_ 11 _N_ _S_ "U(P)U(P)" {_A_ 2 _U_ 22 _N_ _N_ _F_ _IF_ARGS_ 0 2 XX 1 \ (u0 :: Int#) (u1 :: Int#) -> _#_ leInt# [] [u0, u1] _N_} _F_ _IF_ARGS_ 0 2 CC 3 \ (u0 :: Int) (u1 :: Int) -> case u0 of { _ALG_ I# (u2 :: Int#) -> case u1 of { _ALG_ I# (u3 :: Int#) -> _#_ leInt# [] [u2, u3]; _NO_DEFLT_ }; _NO_DEFLT_ } _N_,
- (>=) = _A_ 2 _U_ 11 _N_ _S_ "U(P)U(P)" {_A_ 2 _U_ 22 _N_ _N_ _F_ _IF_ARGS_ 0 2 XX 1 \ (u0 :: Int#) (u1 :: Int#) -> _#_ geInt# [] [u0, u1] _N_} _F_ _IF_ARGS_ 0 2 CC 3 \ (u0 :: Int) (u1 :: Int) -> case u0 of { _ALG_ I# (u2 :: Int#) -> case u1 of { _ALG_ I# (u3 :: Int#) -> _#_ geInt# [] [u2, u3]; _NO_DEFLT_ }; _NO_DEFLT_ } _N_,
- (>) = _A_ 2 _U_ 11 _N_ _S_ "U(P)U(P)" {_A_ 2 _U_ 22 _N_ _N_ _F_ _IF_ARGS_ 0 2 XX 1 \ (u0 :: Int#) (u1 :: Int#) -> _#_ gtInt# [] [u0, u1] _N_} _F_ _IF_ARGS_ 0 2 CC 3 \ (u0 :: Int) (u1 :: Int) -> case u0 of { _ALG_ I# (u2 :: Int#) -> case u1 of { _ALG_ I# (u3 :: Int#) -> _#_ gtInt# [] [u2, u3]; _NO_DEFLT_ }; _NO_DEFLT_ } _N_,
- max = _A_ 2 _U_ 11 _N_ _S_ "U(P)U(P)" {_A_ 2 _U_ 22 _N_ _N_ _N_ _N_} _N_ _N_,
- min = _A_ 2 _U_ 11 _N_ _S_ "U(P)U(P)" {_A_ 2 _U_ 22 _N_ _N_ _N_ _N_} _N_ _N_,
- _tagCmp = _A_ 2 _U_ 11 _N_ _S_ "U(P)U(P)" {_A_ 2 _U_ 22 _N_ _N_ _N_ _N_} _N_ _N_ #-}
+ (<) = { _A_ 2 _U_ 11 _N_ _S_ "U(P)U(P)" {_A_ 2 _U_ 22 _N_ _N_ _F_ _IF_ARGS_ 0 2 XX 1 \ (u0 :: Int#) (u1 :: Int#) -> _#_ ltInt# [] [u0, u1] _N_} _F_ _IF_ARGS_ 0 2 CC 3 \ (u0 :: Int) (u1 :: Int) -> case u0 of { _ALG_ I# (u2 :: Int#) -> case u1 of { _ALG_ I# (u3 :: Int#) -> _#_ ltInt# [] [u2, u3]; _NO_DEFLT_ }; _NO_DEFLT_ } _N_ },
+ (<=) = { _A_ 2 _U_ 11 _N_ _S_ "U(P)U(P)" {_A_ 2 _U_ 22 _N_ _N_ _F_ _IF_ARGS_ 0 2 XX 1 \ (u0 :: Int#) (u1 :: Int#) -> _#_ leInt# [] [u0, u1] _N_} _F_ _IF_ARGS_ 0 2 CC 3 \ (u0 :: Int) (u1 :: Int) -> case u0 of { _ALG_ I# (u2 :: Int#) -> case u1 of { _ALG_ I# (u3 :: Int#) -> _#_ leInt# [] [u2, u3]; _NO_DEFLT_ }; _NO_DEFLT_ } _N_ },
+ (>=) = { _A_ 2 _U_ 11 _N_ _S_ "U(P)U(P)" {_A_ 2 _U_ 22 _N_ _N_ _F_ _IF_ARGS_ 0 2 XX 1 \ (u0 :: Int#) (u1 :: Int#) -> _#_ geInt# [] [u0, u1] _N_} _F_ _IF_ARGS_ 0 2 CC 3 \ (u0 :: Int) (u1 :: Int) -> case u0 of { _ALG_ I# (u2 :: Int#) -> case u1 of { _ALG_ I# (u3 :: Int#) -> _#_ geInt# [] [u2, u3]; _NO_DEFLT_ }; _NO_DEFLT_ } _N_ },
+ (>) = { _A_ 2 _U_ 11 _N_ _S_ "U(P)U(P)" {_A_ 2 _U_ 22 _N_ _N_ _F_ _IF_ARGS_ 0 2 XX 1 \ (u0 :: Int#) (u1 :: Int#) -> _#_ gtInt# [] [u0, u1] _N_} _F_ _IF_ARGS_ 0 2 CC 3 \ (u0 :: Int) (u1 :: Int) -> case u0 of { _ALG_ I# (u2 :: Int#) -> case u1 of { _ALG_ I# (u3 :: Int#) -> _#_ gtInt# [] [u2, u3]; _NO_DEFLT_ }; _NO_DEFLT_ } _N_ },
+ max = { _A_ 2 _U_ 11 _N_ _S_ "U(P)U(P)" {_A_ 2 _U_ 22 _N_ _N_ _N_ _N_} _N_ _N_ },
+ min = { _A_ 2 _U_ 11 _N_ _S_ "U(P)U(P)" {_A_ 2 _U_ 22 _N_ _N_ _N_ _N_} _N_ _N_ },
+ _tagCmp = { _A_ 2 _U_ 11 _N_ _S_ "U(P)U(P)" {_A_ 2 _U_ 22 _N_ _N_ _N_ _N_} _N_ _N_ } #-}
instance Ord _Addr
{-# GHC_PRAGMA _M_ PreludeCore {-dfun-} _A_ 0 _N_ _N_ _N_ _F_ _IF_ARGS_ 0 0 X 9 _!_ _TUP_8 [{{Eq _Addr}}, (_Addr -> _Addr -> Bool), (_Addr -> _Addr -> Bool), (_Addr -> _Addr -> Bool), (_Addr -> _Addr -> Bool), (_Addr -> _Addr -> _Addr), (_Addr -> _Addr -> _Addr), (_Addr -> _Addr -> _CMP_TAG)] [_DFUN_ Eq (_Addr), _CONSTM_ Ord (<) (_Addr), _CONSTM_ Ord (<=) (_Addr), _CONSTM_ Ord (>=) (_Addr), _CONSTM_ Ord (>) (_Addr), _CONSTM_ Ord max (_Addr), _CONSTM_ Ord min (_Addr), _CONSTM_ Ord _tagCmp (_Addr)] _N_
- (<) = _A_ 2 _U_ 11 _N_ _S_ "U(P)U(P)" {_A_ 2 _U_ 22 _N_ _N_ _F_ _IF_ARGS_ 0 2 XX 1 \ (u0 :: Addr#) (u1 :: Addr#) -> _#_ ltAddr# [] [u0, u1] _N_} _F_ _IF_ARGS_ 0 2 CC 3 \ (u0 :: _Addr) (u1 :: _Addr) -> case u0 of { _ALG_ A# (u2 :: Addr#) -> case u1 of { _ALG_ A# (u3 :: Addr#) -> _#_ ltAddr# [] [u2, u3]; _NO_DEFLT_ }; _NO_DEFLT_ } _N_,
- (<=) = _A_ 2 _U_ 11 _N_ _S_ "U(P)U(P)" {_A_ 2 _U_ 22 _N_ _N_ _F_ _IF_ARGS_ 0 2 XX 1 \ (u0 :: Addr#) (u1 :: Addr#) -> _#_ leAddr# [] [u0, u1] _N_} _F_ _IF_ARGS_ 0 2 CC 3 \ (u0 :: _Addr) (u1 :: _Addr) -> case u0 of { _ALG_ A# (u2 :: Addr#) -> case u1 of { _ALG_ A# (u3 :: Addr#) -> _#_ leAddr# [] [u2, u3]; _NO_DEFLT_ }; _NO_DEFLT_ } _N_,
- (>=) = _A_ 2 _U_ 11 _N_ _S_ "U(P)U(P)" {_A_ 2 _U_ 22 _N_ _N_ _F_ _IF_ARGS_ 0 2 XX 1 \ (u0 :: Addr#) (u1 :: Addr#) -> _#_ geAddr# [] [u0, u1] _N_} _F_ _IF_ARGS_ 0 2 CC 3 \ (u0 :: _Addr) (u1 :: _Addr) -> case u0 of { _ALG_ A# (u2 :: Addr#) -> case u1 of { _ALG_ A# (u3 :: Addr#) -> _#_ geAddr# [] [u2, u3]; _NO_DEFLT_ }; _NO_DEFLT_ } _N_,
- (>) = _A_ 2 _U_ 11 _N_ _S_ "U(P)U(P)" {_A_ 2 _U_ 22 _N_ _N_ _F_ _IF_ARGS_ 0 2 XX 1 \ (u0 :: Addr#) (u1 :: Addr#) -> _#_ gtAddr# [] [u0, u1] _N_} _F_ _IF_ARGS_ 0 2 CC 3 \ (u0 :: _Addr) (u1 :: _Addr) -> case u0 of { _ALG_ A# (u2 :: Addr#) -> case u1 of { _ALG_ A# (u3 :: Addr#) -> _#_ gtAddr# [] [u2, u3]; _NO_DEFLT_ }; _NO_DEFLT_ } _N_,
- max = _A_ 2 _U_ 11 _N_ _S_ "U(P)U(P)" {_A_ 2 _U_ 22 _N_ _N_ _N_ _N_} _N_ _N_,
- min = _A_ 2 _U_ 11 _N_ _S_ "U(P)U(P)" {_A_ 2 _U_ 22 _N_ _N_ _N_ _N_} _N_ _N_,
- _tagCmp = _A_ 2 _U_ 11 _N_ _S_ "U(P)U(P)" {_A_ 2 _U_ 22 _N_ _N_ _N_ _N_} _N_ _N_ #-}
+ (<) = { _A_ 2 _U_ 11 _N_ _S_ "U(P)U(P)" {_A_ 2 _U_ 22 _N_ _N_ _F_ _IF_ARGS_ 0 2 XX 1 \ (u0 :: Addr#) (u1 :: Addr#) -> _#_ ltAddr# [] [u0, u1] _N_} _F_ _IF_ARGS_ 0 2 CC 3 \ (u0 :: _Addr) (u1 :: _Addr) -> case u0 of { _ALG_ A# (u2 :: Addr#) -> case u1 of { _ALG_ A# (u3 :: Addr#) -> _#_ ltAddr# [] [u2, u3]; _NO_DEFLT_ }; _NO_DEFLT_ } _N_ },
+ (<=) = { _A_ 2 _U_ 11 _N_ _S_ "U(P)U(P)" {_A_ 2 _U_ 22 _N_ _N_ _F_ _IF_ARGS_ 0 2 XX 1 \ (u0 :: Addr#) (u1 :: Addr#) -> _#_ leAddr# [] [u0, u1] _N_} _F_ _IF_ARGS_ 0 2 CC 3 \ (u0 :: _Addr) (u1 :: _Addr) -> case u0 of { _ALG_ A# (u2 :: Addr#) -> case u1 of { _ALG_ A# (u3 :: Addr#) -> _#_ leAddr# [] [u2, u3]; _NO_DEFLT_ }; _NO_DEFLT_ } _N_ },
+ (>=) = { _A_ 2 _U_ 11 _N_ _S_ "U(P)U(P)" {_A_ 2 _U_ 22 _N_ _N_ _F_ _IF_ARGS_ 0 2 XX 1 \ (u0 :: Addr#) (u1 :: Addr#) -> _#_ geAddr# [] [u0, u1] _N_} _F_ _IF_ARGS_ 0 2 CC 3 \ (u0 :: _Addr) (u1 :: _Addr) -> case u0 of { _ALG_ A# (u2 :: Addr#) -> case u1 of { _ALG_ A# (u3 :: Addr#) -> _#_ geAddr# [] [u2, u3]; _NO_DEFLT_ }; _NO_DEFLT_ } _N_ },
+ (>) = { _A_ 2 _U_ 11 _N_ _S_ "U(P)U(P)" {_A_ 2 _U_ 22 _N_ _N_ _F_ _IF_ARGS_ 0 2 XX 1 \ (u0 :: Addr#) (u1 :: Addr#) -> _#_ gtAddr# [] [u0, u1] _N_} _F_ _IF_ARGS_ 0 2 CC 3 \ (u0 :: _Addr) (u1 :: _Addr) -> case u0 of { _ALG_ A# (u2 :: Addr#) -> case u1 of { _ALG_ A# (u3 :: Addr#) -> _#_ gtAddr# [] [u2, u3]; _NO_DEFLT_ }; _NO_DEFLT_ } _N_ },
+ max = { _A_ 2 _U_ 11 _N_ _S_ "U(P)U(P)" {_A_ 2 _U_ 22 _N_ _N_ _N_ _N_} _N_ _N_ },
+ min = { _A_ 2 _U_ 11 _N_ _S_ "U(P)U(P)" {_A_ 2 _U_ 22 _N_ _N_ _N_ _N_} _N_ _N_ },
+ _tagCmp = { _A_ 2 _U_ 11 _N_ _S_ "U(P)U(P)" {_A_ 2 _U_ 22 _N_ _N_ _N_ _N_} _N_ _N_ } #-}
instance Ord _Word
{-# GHC_PRAGMA _M_ PreludeCore {-dfun-} _A_ 0 _N_ _N_ _N_ _F_ _IF_ARGS_ 0 0 X 9 _!_ _TUP_8 [{{Eq _Word}}, (_Word -> _Word -> Bool), (_Word -> _Word -> Bool), (_Word -> _Word -> Bool), (_Word -> _Word -> Bool), (_Word -> _Word -> _Word), (_Word -> _Word -> _Word), (_Word -> _Word -> _CMP_TAG)] [_DFUN_ Eq (_Word), _CONSTM_ Ord (<) (_Word), _CONSTM_ Ord (<=) (_Word), _CONSTM_ Ord (>=) (_Word), _CONSTM_ Ord (>) (_Word), _CONSTM_ Ord max (_Word), _CONSTM_ Ord min (_Word), _CONSTM_ Ord _tagCmp (_Word)] _N_
- (<) = _A_ 2 _U_ 11 _N_ _S_ "U(P)U(P)" {_A_ 2 _U_ 22 _N_ _N_ _F_ _IF_ARGS_ 0 2 XX 1 \ (u0 :: Word#) (u1 :: Word#) -> _#_ ltWord# [] [u0, u1] _N_} _F_ _IF_ARGS_ 0 2 CC 3 \ (u0 :: _Word) (u1 :: _Word) -> case u0 of { _ALG_ W# (u2 :: Word#) -> case u1 of { _ALG_ W# (u3 :: Word#) -> _#_ ltWord# [] [u2, u3]; _NO_DEFLT_ }; _NO_DEFLT_ } _N_,
- (<=) = _A_ 2 _U_ 11 _N_ _S_ "U(P)U(P)" {_A_ 2 _U_ 22 _N_ _N_ _F_ _IF_ARGS_ 0 2 XX 1 \ (u0 :: Word#) (u1 :: Word#) -> _#_ leWord# [] [u0, u1] _N_} _F_ _IF_ARGS_ 0 2 CC 3 \ (u0 :: _Word) (u1 :: _Word) -> case u0 of { _ALG_ W# (u2 :: Word#) -> case u1 of { _ALG_ W# (u3 :: Word#) -> _#_ leWord# [] [u2, u3]; _NO_DEFLT_ }; _NO_DEFLT_ } _N_,
- (>=) = _A_ 2 _U_ 11 _N_ _S_ "U(P)U(P)" {_A_ 2 _U_ 22 _N_ _N_ _F_ _IF_ARGS_ 0 2 XX 1 \ (u0 :: Word#) (u1 :: Word#) -> _#_ geWord# [] [u0, u1] _N_} _F_ _IF_ARGS_ 0 2 CC 3 \ (u0 :: _Word) (u1 :: _Word) -> case u0 of { _ALG_ W# (u2 :: Word#) -> case u1 of { _ALG_ W# (u3 :: Word#) -> _#_ geWord# [] [u2, u3]; _NO_DEFLT_ }; _NO_DEFLT_ } _N_,
- (>) = _A_ 2 _U_ 11 _N_ _S_ "U(P)U(P)" {_A_ 2 _U_ 22 _N_ _N_ _F_ _IF_ARGS_ 0 2 XX 1 \ (u0 :: Word#) (u1 :: Word#) -> _#_ gtWord# [] [u0, u1] _N_} _F_ _IF_ARGS_ 0 2 CC 3 \ (u0 :: _Word) (u1 :: _Word) -> case u0 of { _ALG_ W# (u2 :: Word#) -> case u1 of { _ALG_ W# (u3 :: Word#) -> _#_ gtWord# [] [u2, u3]; _NO_DEFLT_ }; _NO_DEFLT_ } _N_,
- max = _A_ 2 _U_ 11 _N_ _S_ "U(P)U(P)" {_A_ 2 _U_ 22 _N_ _N_ _N_ _N_} _N_ _N_,
- min = _A_ 2 _U_ 11 _N_ _S_ "U(P)U(P)" {_A_ 2 _U_ 22 _N_ _N_ _N_ _N_} _N_ _N_,
- _tagCmp = _A_ 2 _U_ 11 _N_ _S_ "U(P)U(P)" {_A_ 2 _U_ 22 _N_ _N_ _N_ _N_} _N_ _N_ #-}
+ (<) = { _A_ 2 _U_ 11 _N_ _S_ "U(P)U(P)" {_A_ 2 _U_ 22 _N_ _N_ _F_ _IF_ARGS_ 0 2 XX 1 \ (u0 :: Word#) (u1 :: Word#) -> _#_ ltWord# [] [u0, u1] _N_} _F_ _IF_ARGS_ 0 2 CC 3 \ (u0 :: _Word) (u1 :: _Word) -> case u0 of { _ALG_ W# (u2 :: Word#) -> case u1 of { _ALG_ W# (u3 :: Word#) -> _#_ ltWord# [] [u2, u3]; _NO_DEFLT_ }; _NO_DEFLT_ } _N_ },
+ (<=) = { _A_ 2 _U_ 11 _N_ _S_ "U(P)U(P)" {_A_ 2 _U_ 22 _N_ _N_ _F_ _IF_ARGS_ 0 2 XX 1 \ (u0 :: Word#) (u1 :: Word#) -> _#_ leWord# [] [u0, u1] _N_} _F_ _IF_ARGS_ 0 2 CC 3 \ (u0 :: _Word) (u1 :: _Word) -> case u0 of { _ALG_ W# (u2 :: Word#) -> case u1 of { _ALG_ W# (u3 :: Word#) -> _#_ leWord# [] [u2, u3]; _NO_DEFLT_ }; _NO_DEFLT_ } _N_ },
+ (>=) = { _A_ 2 _U_ 11 _N_ _S_ "U(P)U(P)" {_A_ 2 _U_ 22 _N_ _N_ _F_ _IF_ARGS_ 0 2 XX 1 \ (u0 :: Word#) (u1 :: Word#) -> _#_ geWord# [] [u0, u1] _N_} _F_ _IF_ARGS_ 0 2 CC 3 \ (u0 :: _Word) (u1 :: _Word) -> case u0 of { _ALG_ W# (u2 :: Word#) -> case u1 of { _ALG_ W# (u3 :: Word#) -> _#_ geWord# [] [u2, u3]; _NO_DEFLT_ }; _NO_DEFLT_ } _N_ },
+ (>) = { _A_ 2 _U_ 11 _N_ _S_ "U(P)U(P)" {_A_ 2 _U_ 22 _N_ _N_ _F_ _IF_ARGS_ 0 2 XX 1 \ (u0 :: Word#) (u1 :: Word#) -> _#_ gtWord# [] [u0, u1] _N_} _F_ _IF_ARGS_ 0 2 CC 3 \ (u0 :: _Word) (u1 :: _Word) -> case u0 of { _ALG_ W# (u2 :: Word#) -> case u1 of { _ALG_ W# (u3 :: Word#) -> _#_ gtWord# [] [u2, u3]; _NO_DEFLT_ }; _NO_DEFLT_ } _N_ },
+ max = { _A_ 2 _U_ 11 _N_ _S_ "U(P)U(P)" {_A_ 2 _U_ 22 _N_ _N_ _N_ _N_} _N_ _N_ },
+ min = { _A_ 2 _U_ 11 _N_ _S_ "U(P)U(P)" {_A_ 2 _U_ 22 _N_ _N_ _N_ _N_} _N_ _N_ },
+ _tagCmp = { _A_ 2 _U_ 11 _N_ _S_ "U(P)U(P)" {_A_ 2 _U_ 22 _N_ _N_ _N_ _N_} _N_ _N_ } #-}
instance Real Int
{-# GHC_PRAGMA _M_ PreludeCore {-dfun-} _A_ 0 _N_ _N_ _N_ _F_ _IF_ARGS_ 0 0 X 4 _!_ _TUP_3 [{{Num Int}}, {{Enum Int}}, (Int -> Ratio Integer)] [_DFUN_ Num (Int), _DFUN_ Enum (Int), _CONSTM_ Real toRational (Int)] _N_
- toRational = _A_ 1 _U_ 1 _N_ _N_ _N_ _N_ #-}
+ toRational = { _A_ 1 _U_ 1 _N_ _N_ _N_ _N_ } #-}
instance Text Int
{-# GHC_PRAGMA _M_ PreludeCore {-dfun-} _A_ 0 _N_ _N_ _N_ _F_ _IF_ARGS_ 0 0 X 5 _!_ _TUP_4 [(Int -> [Char] -> [(Int, [Char])]), (Int -> Int -> [Char] -> [Char]), ([Char] -> [([Int], [Char])]), ([Int] -> [Char] -> [Char])] [_CONSTM_ Text readsPrec (Int), _CONSTM_ Text showsPrec (Int), _CONSTM_ Text readList (Int), _CONSTM_ Text showList (Int)] _N_
- readsPrec = _A_ 2 _U_ 02 _N_ _S_ "AL" {_A_ 1 _U_ 2 _N_ _N_ _F_ _IF_ARGS_ 0 1 X 3 \ (u0 :: [Char]) -> _APP_ _SPEC_ _ORIG_ PreludeText readSigned [ (Int) ] [ _SPEC_ _ORIG_ PreludeText readDec [ (Int) ], u0 ] _N_} _F_ _IF_ARGS_ 0 2 XX 3 \ (u0 :: Int) (u1 :: [Char]) -> _APP_ _SPEC_ _ORIG_ PreludeText readSigned [ (Int) ] [ _SPEC_ _ORIG_ PreludeText readDec [ (Int) ], u1 ] _N_,
- showsPrec = _A_ 3 _U_ 212 _N_ _S_ "LU(P)L" {_A_ 3 _U_ 222 _N_ _N_ _N_ _N_} _N_ _N_,
- readList = _A_ 0 _U_ 2 _N_ _N_ _N_ _N_,
- showList = _A_ 0 _U_ 12 _N_ _N_ _N_ _N_ #-}
+ readsPrec = { _A_ 2 _U_ 02 _N_ _S_ "AL" {_A_ 1 _U_ 2 _N_ _N_ _F_ _IF_ARGS_ 0 1 X 3 \ (u0 :: [Char]) -> _APP_ _SPEC_ _ORIG_ PreludeText readSigned [ (Int) ] [ _SPEC_ _ORIG_ PreludeText readDec [ (Int) ], u0 ] _N_} _F_ _IF_ARGS_ 0 2 XX 3 \ (u0 :: Int) (u1 :: [Char]) -> _APP_ _SPEC_ _ORIG_ PreludeText readSigned [ (Int) ] [ _SPEC_ _ORIG_ PreludeText readDec [ (Int) ], u1 ] _N_ },
+ showsPrec = { _A_ 3 _U_ 212 _N_ _S_ "LU(P)L" {_A_ 3 _U_ 222 _N_ _N_ _N_ _N_} _N_ _N_ },
+ readList = { _A_ 0 _U_ 2 _N_ _N_ _N_ _N_ },
+ showList = { _A_ 1 _U_ 12 _N_ _N_ _N_ _N_ } #-}
instance _CCallable Int
{-# GHC_PRAGMA _M_ PreludeCore {-dfun-} _A_ 0 _N_ _N_ _N_ _F_ _IF_ARGS_ 0 0 X 1 _!_ _TUP_0 [] [] _N_ #-}
instance _CCallable _Addr
import IInteger -- instances
import IRatio ( (%) )
import ITup2
-import List ( (++), foldr )
+import List ( (++), map, takeWhile )
import Prel ( otherwise, (&&), (||), chr, ord )
import PS ( _PackedString, _unpackPS )
import Text
+import TyArray
+import TyComplex
-- definitions of the boxed PrimOps; these will be
-- used in the case of partial applications, etc.
inRange (I# m, I# n) (I# i) = m <=# i && i <=# n
instance Enum Int where
-{- RAW PRELUDE ************************
- enumFrom = numericEnumFrom
- enumFromThen = numericEnumFromThen
--}
#ifndef USE_FOLDR_BUILD
- enumFrom x = x : enumFrom (x `plusInt` 1)
+ enumFrom x = x : enumFrom (x `plusInt` 1)
+ enumFromTo n m = takeWhile (<= m) (enumFrom n)
#else
- {-# INLINE enumFromTo #-}
{-# INLINE enumFrom #-}
- enumFromTo x y = _build (\ c n ->
- let g x = if x <= y then x `c` g (x `plusInt` 1) else n in g x)
+ {-# INLINE enumFromTo #-}
enumFrom x = _build (\ c _ ->
let g x = x `c` g (x `plusInt` 1) in g x)
+ enumFromTo x y = _build (\ c n ->
+ let g x = if x <= y then x `c` g (x `plusInt` 1) else n in g x)
#endif
- enumFromThen m n = en' m (n `minusInt` m)
- where en' m n = m : en' (m `plusInt` n) n
+ enumFromThen m n = en' m (n `minusInt` m)
+ where en' m n = m : en' (m `plusInt` n) n
+ enumFromThenTo n m p = takeWhile (if m >= n then (<= p) else (>= p))
+ (enumFromThen n m)
instance Text Int where
readsPrec p x = readSigned readDec x
showsPrec x = showSigned showInt x
+ readList = _readList (readsPrec 0)
+ showList = _showList (showsPrec 0)
---------------------------------------------------------------
instance _CCallable Int
inRange (m, n) i = m <=# i && i <=# n
instance Enum Int# where
- enumFrom x = x : enumFrom (x `plusInt#` 1)
+#ifndef USE_FOLDR_BUILD
+ enumFrom x = x : enumFrom (x `plusInt#` 1)
+ enumFromTo n m = takeWhile (<= m) (enumFrom n)
+#else
+ {-# INLINE enumFrom #-}
+ {-# INLINE enumFromTo #-}
+ enumFrom x = _build (\ c _ ->
+ let g x = x `c` g (x `plusInt#` 1) in g x)
+ enumFromTo x y = _build (\ c n ->
+ let g x = if x <= y then x `c` g (x `plusInt#` 1) else n in g x)
+#endif
enumFromThen m n = en' m (n `minusInt#` m)
where en' m n = m : en' (m `plusInt#` n) n
- -- default methods not specialised!
- enumFromTo n m = takeWhile (<= m) (enumFrom n)
enumFromThenTo n m p = takeWhile (if m >= n then (<= p) else (>= p))
(enumFromThen n m)
instance Text Int# where
readsPrec p s = map (\ (I# i#, s) -> (i#, s)) (readsPrec p s)
showsPrec p x = showsPrec p (I# x)
- readList s = map (\ (x, s) -> (map (\ (I# i#) -> i#) x, s)) (readList s)
- showList l = showList (map I# l)
+ readList = _readList (readsPrec 0)
+ showList = _showList (showsPrec 0)
instance _CCallable Int#
instance _CReturnable Int#
instance _CCallable _Addr
instance _CCallable _Word
+instance _CCallable (_StablePtr a)
instance _CCallable _MallocPtr
instance _CReturnable _Addr
instance _CReturnable _Word
instance _CReturnable ()
-instance _CReturnable _MallocPtr
-
-#ifndef __PARALLEL_HASKELL__
-instance _CCallable (_StablePtr a)
instance _CReturnable (_StablePtr a)
-#endif
+instance _CReturnable _MallocPtr
---------------------------------------------------------------
gtAddr (A# x) (A# y) = gtAddr# x y
-{-# GHC_PRAGMA INTERFACE VERSION 5 #-}
+{-# GHC_PRAGMA INTERFACE VERSION 6 #-}
interface PreludeCore where
import PreludeBuiltin(Int(..), Tuple0, _Addr(..), _Word(..))
import PreludeGlaMisc(_MallocPtr(..), _StablePtr(..))
{-# GHC_PRAGMA _A_ 3 _U_ 222 _N_ _S_ _!_ _N_ _N_ #-}
instance Enum Int
{-# GHC_PRAGMA _M_ PreludeCore {-dfun-} _A_ 0 _N_ _N_ _N_ _F_ _IF_ARGS_ 0 0 X 6 _!_ _TUP_5 [{{Ord Int}}, (Int -> [Int]), (Int -> Int -> [Int]), (Int -> Int -> [Int]), (Int -> Int -> Int -> [Int])] [_DFUN_ Ord (Int), _CONSTM_ Enum enumFrom (Int), _CONSTM_ Enum enumFromThen (Int), _CONSTM_ Enum enumFromTo (Int), _CONSTM_ Enum enumFromThenTo (Int)] _N_
- enumFrom = _A_ 1 _U_ 2 _N_ _N_ _F_ _ALWAYS_ \ (u0 :: Int) -> _LETREC_ {(u1 :: Int -> [Int]) = \ (u2 :: Int) -> let {(u6 :: [Int]) = let {(u5 :: Int) = case u2 of { _ALG_ I# (u3 :: Int#) -> case _#_ plusInt# [] [u3, 1#] of { _PRIM_ (u4 :: Int#) -> _!_ I# [] [u4] }; _NO_DEFLT_ }} in _APP_ u1 [ u5 ]} in _!_ (:) [Int] [u2, u6]} in _APP_ u1 [ u0 ] _N_,
- enumFromThen = _A_ 2 _U_ 21 _N_ _N_ _N_ _N_,
- enumFromTo = _A_ 2 _U_ 12 _N_ _S_ "SS" _F_ _ALWAYS_ \ (u0 :: Int) (u1 :: Int) -> case u0 of { _ALG_ I# (u2 :: Int#) -> _LETREC_ {(u3 :: Int# -> [Int]) = \ (u4 :: Int#) -> case u1 of { _ALG_ I# (u5 :: Int#) -> case _#_ leInt# [] [u4, u5] of { _ALG_ True -> let {(u7 :: [Int]) = case _#_ plusInt# [] [u4, 1#] of { _PRIM_ (u6 :: Int#) -> _APP_ u3 [ u6 ] }} in let {(u8 :: Int) = _!_ I# [] [u4]} in _!_ (:) [Int] [u8, u7]; False -> _!_ _NIL_ [Int] []; _NO_DEFLT_ }; _NO_DEFLT_ }} in _APP_ u3 [ u2 ]; _NO_DEFLT_ } _N_,
- enumFromThenTo = _A_ 3 _U_ 222 _N_ _N_ _N_ _N_ #-}
+ enumFrom = { _A_ 1 _U_ 2 _N_ _N_ _F_ _ALWAYS_ \ (u0 :: Int) -> _LETREC_ {(u1 :: Int -> [Int]) = \ (u2 :: Int) -> let {(u6 :: [Int]) = let {(u5 :: Int) = case u2 of { _ALG_ I# (u3 :: Int#) -> case _#_ plusInt# [] [u3, 1#] of { _PRIM_ (u4 :: Int#) -> _!_ I# [] [u4] }; _NO_DEFLT_ }} in _APP_ u1 [ u5 ]} in _!_ (:) [Int] [u2, u6]} in _APP_ u1 [ u0 ] _N_ },
+ enumFromThen = { _A_ 2 _U_ 21 _N_ _N_ _N_ _N_ },
+ enumFromTo = { _A_ 2 _U_ 12 _N_ _S_ "SS" _F_ _ALWAYS_ \ (u0 :: Int) (u1 :: Int) -> case u0 of { _ALG_ I# (u2 :: Int#) -> _LETREC_ {(u3 :: Int# -> [Int]) = \ (u4 :: Int#) -> case u1 of { _ALG_ I# (u5 :: Int#) -> case _#_ leInt# [] [u4, u5] of { _ALG_ True -> let {(u7 :: [Int]) = case _#_ plusInt# [] [u4, 1#] of { _PRIM_ (u6 :: Int#) -> _APP_ u3 [ u6 ] }} in let {(u8 :: Int) = _!_ I# [] [u4]} in _!_ (:) [Int] [u8, u7]; False -> _!_ _NIL_ [Int] []; _NO_DEFLT_ }; _NO_DEFLT_ }} in _APP_ u3 [ u2 ]; _NO_DEFLT_ } _N_ },
+ enumFromThenTo = { _A_ 3 _U_ 222 _N_ _N_ _N_ _N_ } #-}
instance Eq Int
{-# GHC_PRAGMA _M_ PreludeCore {-dfun-} _A_ 0 _N_ _N_ _N_ _F_ _IF_ARGS_ 0 0 X 3 _!_ _TUP_2 [(Int -> Int -> Bool), (Int -> Int -> Bool)] [_CONSTM_ Eq (==) (Int), _CONSTM_ Eq (/=) (Int)] _N_
- (==) = _A_ 2 _U_ 11 _N_ _S_ "U(P)U(P)" {_A_ 2 _U_ 22 _N_ _N_ _F_ _IF_ARGS_ 0 2 XX 1 \ (u0 :: Int#) (u1 :: Int#) -> _#_ eqInt# [] [u0, u1] _N_} _F_ _IF_ARGS_ 0 2 CC 3 \ (u0 :: Int) (u1 :: Int) -> case u0 of { _ALG_ I# (u2 :: Int#) -> case u1 of { _ALG_ I# (u3 :: Int#) -> _#_ eqInt# [] [u2, u3]; _NO_DEFLT_ }; _NO_DEFLT_ } _N_,
- (/=) = _A_ 2 _U_ 11 _N_ _S_ "U(P)U(P)" {_A_ 2 _U_ 22 _N_ _N_ _F_ _IF_ARGS_ 0 2 XX 1 \ (u0 :: Int#) (u1 :: Int#) -> _#_ neInt# [] [u0, u1] _N_} _F_ _IF_ARGS_ 0 2 CC 3 \ (u0 :: Int) (u1 :: Int) -> case u0 of { _ALG_ I# (u2 :: Int#) -> case u1 of { _ALG_ I# (u3 :: Int#) -> _#_ neInt# [] [u2, u3]; _NO_DEFLT_ }; _NO_DEFLT_ } _N_ #-}
+ (==) = { _A_ 2 _U_ 11 _N_ _S_ "U(P)U(P)" {_A_ 2 _U_ 22 _N_ _N_ _F_ _IF_ARGS_ 0 2 XX 1 \ (u0 :: Int#) (u1 :: Int#) -> _#_ eqInt# [] [u0, u1] _N_} _F_ _IF_ARGS_ 0 2 CC 3 \ (u0 :: Int) (u1 :: Int) -> case u0 of { _ALG_ I# (u2 :: Int#) -> case u1 of { _ALG_ I# (u3 :: Int#) -> _#_ eqInt# [] [u2, u3]; _NO_DEFLT_ }; _NO_DEFLT_ } _N_ },
+ (/=) = { _A_ 2 _U_ 11 _N_ _S_ "U(P)U(P)" {_A_ 2 _U_ 22 _N_ _N_ _F_ _IF_ARGS_ 0 2 XX 1 \ (u0 :: Int#) (u1 :: Int#) -> _#_ neInt# [] [u0, u1] _N_} _F_ _IF_ARGS_ 0 2 CC 3 \ (u0 :: Int) (u1 :: Int) -> case u0 of { _ALG_ I# (u2 :: Int#) -> case u1 of { _ALG_ I# (u3 :: Int#) -> _#_ neInt# [] [u2, u3]; _NO_DEFLT_ }; _NO_DEFLT_ } _N_ } #-}
instance Eq _Addr
{-# GHC_PRAGMA _M_ PreludeCore {-dfun-} _A_ 0 _N_ _N_ _N_ _F_ _IF_ARGS_ 0 0 X 3 _!_ _TUP_2 [(_Addr -> _Addr -> Bool), (_Addr -> _Addr -> Bool)] [_CONSTM_ Eq (==) (_Addr), _CONSTM_ Eq (/=) (_Addr)] _N_
- (==) = _A_ 2 _U_ 11 _N_ _S_ "U(P)U(P)" {_A_ 2 _U_ 22 _N_ _N_ _F_ _IF_ARGS_ 0 2 XX 1 \ (u0 :: Addr#) (u1 :: Addr#) -> _#_ eqAddr# [] [u0, u1] _N_} _F_ _IF_ARGS_ 0 2 CC 3 \ (u0 :: _Addr) (u1 :: _Addr) -> case u0 of { _ALG_ A# (u2 :: Addr#) -> case u1 of { _ALG_ A# (u3 :: Addr#) -> _#_ eqAddr# [] [u2, u3]; _NO_DEFLT_ }; _NO_DEFLT_ } _N_,
- (/=) = _A_ 2 _U_ 11 _N_ _S_ "U(P)U(P)" {_A_ 2 _U_ 22 _N_ _N_ _F_ _IF_ARGS_ 0 2 XX 1 \ (u0 :: Addr#) (u1 :: Addr#) -> _#_ neAddr# [] [u0, u1] _N_} _F_ _IF_ARGS_ 0 2 CC 3 \ (u0 :: _Addr) (u1 :: _Addr) -> case u0 of { _ALG_ A# (u2 :: Addr#) -> case u1 of { _ALG_ A# (u3 :: Addr#) -> _#_ neAddr# [] [u2, u3]; _NO_DEFLT_ }; _NO_DEFLT_ } _N_ #-}
+ (==) = { _A_ 2 _U_ 11 _N_ _S_ "U(P)U(P)" {_A_ 2 _U_ 22 _N_ _N_ _F_ _IF_ARGS_ 0 2 XX 1 \ (u0 :: Addr#) (u1 :: Addr#) -> _#_ eqAddr# [] [u0, u1] _N_} _F_ _IF_ARGS_ 0 2 CC 3 \ (u0 :: _Addr) (u1 :: _Addr) -> case u0 of { _ALG_ A# (u2 :: Addr#) -> case u1 of { _ALG_ A# (u3 :: Addr#) -> _#_ eqAddr# [] [u2, u3]; _NO_DEFLT_ }; _NO_DEFLT_ } _N_ },
+ (/=) = { _A_ 2 _U_ 11 _N_ _S_ "U(P)U(P)" {_A_ 2 _U_ 22 _N_ _N_ _F_ _IF_ARGS_ 0 2 XX 1 \ (u0 :: Addr#) (u1 :: Addr#) -> _#_ neAddr# [] [u0, u1] _N_} _F_ _IF_ARGS_ 0 2 CC 3 \ (u0 :: _Addr) (u1 :: _Addr) -> case u0 of { _ALG_ A# (u2 :: Addr#) -> case u1 of { _ALG_ A# (u3 :: Addr#) -> _#_ neAddr# [] [u2, u3]; _NO_DEFLT_ }; _NO_DEFLT_ } _N_ } #-}
instance Eq _Word
{-# GHC_PRAGMA _M_ PreludeCore {-dfun-} _A_ 0 _N_ _N_ _N_ _F_ _IF_ARGS_ 0 0 X 3 _!_ _TUP_2 [(_Word -> _Word -> Bool), (_Word -> _Word -> Bool)] [_CONSTM_ Eq (==) (_Word), _CONSTM_ Eq (/=) (_Word)] _N_
- (==) = _A_ 2 _U_ 11 _N_ _S_ "U(P)U(P)" {_A_ 2 _U_ 22 _N_ _N_ _F_ _IF_ARGS_ 0 2 XX 1 \ (u0 :: Word#) (u1 :: Word#) -> _#_ eqWord# [] [u0, u1] _N_} _F_ _IF_ARGS_ 0 2 CC 3 \ (u0 :: _Word) (u1 :: _Word) -> case u0 of { _ALG_ W# (u2 :: Word#) -> case u1 of { _ALG_ W# (u3 :: Word#) -> _#_ eqWord# [] [u2, u3]; _NO_DEFLT_ }; _NO_DEFLT_ } _N_,
- (/=) = _A_ 2 _U_ 11 _N_ _S_ "U(P)U(P)" {_A_ 2 _U_ 22 _N_ _N_ _F_ _IF_ARGS_ 0 2 XX 1 \ (u0 :: Word#) (u1 :: Word#) -> _#_ neWord# [] [u0, u1] _N_} _F_ _IF_ARGS_ 0 2 CC 3 \ (u0 :: _Word) (u1 :: _Word) -> case u0 of { _ALG_ W# (u2 :: Word#) -> case u1 of { _ALG_ W# (u3 :: Word#) -> _#_ neWord# [] [u2, u3]; _NO_DEFLT_ }; _NO_DEFLT_ } _N_ #-}
+ (==) = { _A_ 2 _U_ 11 _N_ _S_ "U(P)U(P)" {_A_ 2 _U_ 22 _N_ _N_ _F_ _IF_ARGS_ 0 2 XX 1 \ (u0 :: Word#) (u1 :: Word#) -> _#_ eqWord# [] [u0, u1] _N_} _F_ _IF_ARGS_ 0 2 CC 3 \ (u0 :: _Word) (u1 :: _Word) -> case u0 of { _ALG_ W# (u2 :: Word#) -> case u1 of { _ALG_ W# (u3 :: Word#) -> _#_ eqWord# [] [u2, u3]; _NO_DEFLT_ }; _NO_DEFLT_ } _N_ },
+ (/=) = { _A_ 2 _U_ 11 _N_ _S_ "U(P)U(P)" {_A_ 2 _U_ 22 _N_ _N_ _F_ _IF_ARGS_ 0 2 XX 1 \ (u0 :: Word#) (u1 :: Word#) -> _#_ neWord# [] [u0, u1] _N_} _F_ _IF_ARGS_ 0 2 CC 3 \ (u0 :: _Word) (u1 :: _Word) -> case u0 of { _ALG_ W# (u2 :: Word#) -> case u1 of { _ALG_ W# (u3 :: Word#) -> _#_ neWord# [] [u2, u3]; _NO_DEFLT_ }; _NO_DEFLT_ } _N_ } #-}
instance Integral Int
{-# GHC_PRAGMA _M_ PreludeCore {-dfun-} _A_ 0 _N_ _N_ _N_ _F_ _IF_ARGS_ 0 0 X 13 _!_ _TUP_12 [{{Real Int}}, {{Ix Int}}, (Int -> Int -> Int), (Int -> Int -> Int), (Int -> Int -> Int), (Int -> Int -> Int), (Int -> Int -> (Int, Int)), (Int -> Int -> (Int, Int)), (Int -> Bool), (Int -> Bool), (Int -> Integer), (Int -> Int)] [_DFUN_ Real (Int), _DFUN_ Ix (Int), _CONSTM_ Integral quot (Int), _CONSTM_ Integral rem (Int), _CONSTM_ Integral div (Int), _CONSTM_ Integral mod (Int), _CONSTM_ Integral quotRem (Int), _CONSTM_ Integral divMod (Int), _CONSTM_ Integral even (Int), _CONSTM_ Integral odd (Int), _CONSTM_ Integral toInteger (Int), _CONSTM_ Integral toInt (Int)] _N_
- quot = _A_ 2 _U_ 11 _N_ _S_ "U(P)U(P)" {_A_ 2 _U_ 22 _N_ _N_ _F_ _IF_ARGS_ 0 2 XC 5 \ (u0 :: Int#) (u1 :: Int#) -> case u1 of { _PRIM_ 0# -> _APP_ _TYAPP_ error { Int } [ _NOREP_S_ "Integral.Int.quot{PreludeCore}: divide by 0\n" ]; (u2 :: Int#) -> case _#_ quotInt# [] [u0, u1] of { _PRIM_ (u3 :: Int#) -> _!_ I# [] [u3] } } _N_} _F_ _IF_ARGS_ 0 2 CC 7 \ (u0 :: Int) (u1 :: Int) -> case u1 of { _ALG_ I# (u2 :: Int#) -> case u2 of { _PRIM_ 0# -> _APP_ _TYAPP_ error { Int } [ _NOREP_S_ "Integral.Int.quot{PreludeCore}: divide by 0\n" ]; (u3 :: Int#) -> case u0 of { _ALG_ I# (u4 :: Int#) -> case _#_ quotInt# [] [u4, u2] of { _PRIM_ (u5 :: Int#) -> _!_ I# [] [u5] }; _NO_DEFLT_ } }; _NO_DEFLT_ } _N_,
- rem = _A_ 2 _U_ 11 _N_ _S_ "U(P)U(P)" {_A_ 2 _U_ 22 _N_ _N_ _F_ _IF_ARGS_ 0 2 XC 5 \ (u0 :: Int#) (u1 :: Int#) -> case u1 of { _PRIM_ 0# -> _APP_ _TYAPP_ error { Int } [ _NOREP_S_ "Integral.Int.rem{PreludeCore}: divide by 0\n" ]; (u2 :: Int#) -> case _#_ remInt# [] [u0, u1] of { _PRIM_ (u3 :: Int#) -> _!_ I# [] [u3] } } _N_} _F_ _IF_ARGS_ 0 2 CC 7 \ (u0 :: Int) (u1 :: Int) -> case u1 of { _ALG_ I# (u2 :: Int#) -> case u2 of { _PRIM_ 0# -> _APP_ _TYAPP_ error { Int } [ _NOREP_S_ "Integral.Int.rem{PreludeCore}: divide by 0\n" ]; (u3 :: Int#) -> case u0 of { _ALG_ I# (u4 :: Int#) -> case _#_ remInt# [] [u4, u2] of { _PRIM_ (u5 :: Int#) -> _!_ I# [] [u5] }; _NO_DEFLT_ } }; _NO_DEFLT_ } _N_,
- div = _A_ 2 _U_ 11 _N_ _S_ "U(P)U(P)" {_A_ 2 _U_ 22 _N_ _N_ _N_ _N_} _N_ _N_,
- mod = _A_ 2 _U_ 11 _N_ _S_ "U(P)U(P)" {_A_ 2 _U_ 22 _N_ _N_ _N_ _N_} _N_ _N_,
- quotRem = _A_ 2 _U_ 11 _N_ _S_ "U(P)U(P)" {_A_ 2 _U_ 22 _N_ _N_ _N_ _N_} _N_ _N_,
- divMod = _A_ 2 _U_ 11 _N_ _S_ "U(P)U(P)" {_A_ 2 _U_ 22 _N_ _N_ _N_ _N_} _N_ _N_,
- even = _A_ 1 _U_ 1 _N_ _S_ "U(P)" {_A_ 1 _U_ 2 _N_ _N_ _N_ _N_} _N_ _N_,
- odd = _A_ 1 _U_ 1 _N_ _S_ "U(P)" {_A_ 1 _U_ 2 _N_ _N_ _N_ _N_} _N_ _N_,
- toInteger = _A_ 1 _U_ 1 _N_ _S_ "U(P)" {_A_ 1 _U_ 2 _N_ _N_ _F_ _IF_ARGS_ 0 1 X 1 \ (u0 :: Int#) -> _#_ int2Integer# [] [u0] _N_} _F_ _IF_ARGS_ 0 1 C 2 \ (u0 :: Int) -> case u0 of { _ALG_ I# (u1 :: Int#) -> _#_ int2Integer# [] [u1]; _NO_DEFLT_ } _N_,
- toInt = _A_ 1 _U_ 1 _N_ _S_ "U(P)" {_A_ 1 _U_ 2 _N_ _N_ _F_ _IF_ARGS_ 0 1 X 2 \ (u0 :: Int#) -> _!_ I# [] [u0] _N_} _F_ _IF_ARGS_ 0 1 X 1 \ (u0 :: Int) -> u0 _N_ #-}
+ quot = { _A_ 2 _U_ 11 _N_ _S_ "U(P)U(P)" {_A_ 2 _U_ 22 _N_ _N_ _F_ _IF_ARGS_ 0 2 XC 5 \ (u0 :: Int#) (u1 :: Int#) -> case u1 of { _PRIM_ 0# -> _APP_ _TYAPP_ error { Int } [ _NOREP_S_ "Integral.Int.quot{PreludeCore}: divide by 0\n" ]; (u2 :: Int#) -> case _#_ quotInt# [] [u0, u1] of { _PRIM_ (u3 :: Int#) -> _!_ I# [] [u3] } } _N_} _F_ _IF_ARGS_ 0 2 CC 7 \ (u0 :: Int) (u1 :: Int) -> case u1 of { _ALG_ I# (u2 :: Int#) -> case u2 of { _PRIM_ 0# -> _APP_ _TYAPP_ error { Int } [ _NOREP_S_ "Integral.Int.quot{PreludeCore}: divide by 0\n" ]; (u3 :: Int#) -> case u0 of { _ALG_ I# (u4 :: Int#) -> case _#_ quotInt# [] [u4, u2] of { _PRIM_ (u5 :: Int#) -> _!_ I# [] [u5] }; _NO_DEFLT_ } }; _NO_DEFLT_ } _N_ },
+ rem = { _A_ 2 _U_ 11 _N_ _S_ "U(P)U(P)" {_A_ 2 _U_ 22 _N_ _N_ _F_ _IF_ARGS_ 0 2 XC 5 \ (u0 :: Int#) (u1 :: Int#) -> case u1 of { _PRIM_ 0# -> _APP_ _TYAPP_ error { Int } [ _NOREP_S_ "Integral.Int.rem{PreludeCore}: divide by 0\n" ]; (u2 :: Int#) -> case _#_ remInt# [] [u0, u1] of { _PRIM_ (u3 :: Int#) -> _!_ I# [] [u3] } } _N_} _F_ _IF_ARGS_ 0 2 CC 7 \ (u0 :: Int) (u1 :: Int) -> case u1 of { _ALG_ I# (u2 :: Int#) -> case u2 of { _PRIM_ 0# -> _APP_ _TYAPP_ error { Int } [ _NOREP_S_ "Integral.Int.rem{PreludeCore}: divide by 0\n" ]; (u3 :: Int#) -> case u0 of { _ALG_ I# (u4 :: Int#) -> case _#_ remInt# [] [u4, u2] of { _PRIM_ (u5 :: Int#) -> _!_ I# [] [u5] }; _NO_DEFLT_ } }; _NO_DEFLT_ } _N_ },
+ div = { _A_ 2 _U_ 11 _N_ _S_ "U(P)U(P)" {_A_ 2 _U_ 22 _N_ _N_ _N_ _N_} _N_ _N_ },
+ mod = { _A_ 2 _U_ 11 _N_ _S_ "U(P)U(P)" {_A_ 2 _U_ 22 _N_ _N_ _N_ _N_} _N_ _N_ },
+ quotRem = { _A_ 2 _U_ 11 _N_ _S_ "U(P)U(P)" {_A_ 2 _U_ 22 _N_ _N_ _N_ _N_} _N_ _N_ },
+ divMod = { _A_ 2 _U_ 11 _N_ _S_ "U(P)U(P)" {_A_ 2 _U_ 22 _N_ _N_ _N_ _N_} _N_ _N_ },
+ even = { _A_ 1 _U_ 1 _N_ _S_ "U(P)" {_A_ 1 _U_ 2 _N_ _N_ _N_ _N_} _N_ _N_ },
+ odd = { _A_ 1 _U_ 1 _N_ _S_ "U(P)" {_A_ 1 _U_ 2 _N_ _N_ _N_ _N_} _N_ _N_ },
+ toInteger = { _A_ 1 _U_ 1 _N_ _S_ "U(P)" {_A_ 1 _U_ 2 _N_ _N_ _F_ _IF_ARGS_ 0 1 X 1 \ (u0 :: Int#) -> _#_ int2Integer# [] [u0] _N_} _F_ _IF_ARGS_ 0 1 C 2 \ (u0 :: Int) -> case u0 of { _ALG_ I# (u1 :: Int#) -> _#_ int2Integer# [] [u1]; _NO_DEFLT_ } _N_ },
+ toInt = { _A_ 1 _U_ 1 _N_ _S_ "U(P)" {_A_ 1 _U_ 2 _N_ _N_ _F_ _IF_ARGS_ 0 1 X 2 \ (u0 :: Int#) -> _!_ I# [] [u0] _N_} _F_ _IF_ARGS_ 0 1 X 1 \ (u0 :: Int) -> u0 _N_ } #-}
instance Ix Int
{-# GHC_PRAGMA _M_ PreludeCore {-dfun-} _A_ 0 _N_ _N_ _N_ _F_ _IF_ARGS_ 0 0 X 5 _!_ _TUP_4 [{{Ord Int}}, ((Int, Int) -> [Int]), ((Int, Int) -> Int -> Int), ((Int, Int) -> Int -> Bool)] [_DFUN_ Ord (Int), _CONSTM_ Ix range (Int), _CONSTM_ Ix index (Int), _CONSTM_ Ix inRange (Int)] _N_
- range = _A_ 1 _U_ 1 _N_ _S_ "U(U(P)U(P))" {_A_ 2 _U_ 22 _N_ _N_ _N_ _N_} _N_ _N_,
- index = _A_ 2 _U_ 11 _N_ _S_ "U(U(P)U(P))U(P)" {_A_ 3 _U_ 222 _N_ _N_ _N_ _N_} _N_ _N_,
- inRange = _A_ 2 _U_ 11 _N_ _S_ "U(U(P)U(P))U(P)" {_A_ 3 _U_ 222 _N_ _N_ _F_ _IF_ARGS_ 0 3 XXX 5 \ (u0 :: Int#) (u1 :: Int#) (u2 :: Int#) -> case _#_ leInt# [] [u0, u2] of { _ALG_ True -> _#_ leInt# [] [u2, u1]; False -> _!_ False [] []; _NO_DEFLT_ } _N_} _F_ _ALWAYS_ \ (u0 :: (Int, Int)) (u1 :: Int) -> case u0 of { _ALG_ _TUP_2 (u2 :: Int) (u3 :: Int) -> case u2 of { _ALG_ I# (u4 :: Int#) -> case u3 of { _ALG_ I# (u5 :: Int#) -> case u1 of { _ALG_ I# (u6 :: Int#) -> case _#_ leInt# [] [u4, u6] of { _ALG_ True -> _#_ leInt# [] [u6, u5]; False -> _!_ False [] []; _NO_DEFLT_ }; _NO_DEFLT_ }; _NO_DEFLT_ }; _NO_DEFLT_ }; _NO_DEFLT_ } _N_ #-}
+ range = { _A_ 1 _U_ 1 _N_ _S_ "U(U(P)U(P))" {_A_ 2 _U_ 22 _N_ _N_ _N_ _N_} _N_ _N_ },
+ index = { _A_ 2 _U_ 11 _N_ _S_ "U(U(P)U(P))U(P)" {_A_ 3 _U_ 222 _N_ _N_ _N_ _N_} _N_ _N_ },
+ inRange = { _A_ 2 _U_ 11 _N_ _S_ "U(U(P)U(P))U(P)" {_A_ 3 _U_ 222 _N_ _N_ _F_ _IF_ARGS_ 0 3 XXX 5 \ (u0 :: Int#) (u1 :: Int#) (u2 :: Int#) -> case _#_ leInt# [] [u0, u2] of { _ALG_ True -> _#_ leInt# [] [u2, u1]; False -> _!_ False [] []; _NO_DEFLT_ } _N_} _F_ _ALWAYS_ \ (u0 :: (Int, Int)) (u1 :: Int) -> case u0 of { _ALG_ _TUP_2 (u2 :: Int) (u3 :: Int) -> case u2 of { _ALG_ I# (u4 :: Int#) -> case u3 of { _ALG_ I# (u5 :: Int#) -> case u1 of { _ALG_ I# (u6 :: Int#) -> case _#_ leInt# [] [u4, u6] of { _ALG_ True -> _#_ leInt# [] [u6, u5]; False -> _!_ False [] []; _NO_DEFLT_ }; _NO_DEFLT_ }; _NO_DEFLT_ }; _NO_DEFLT_ }; _NO_DEFLT_ } _N_ } #-}
instance Num Int
{-# GHC_PRAGMA _M_ PreludeCore {-dfun-} _A_ 0 _N_ _N_ _N_ _F_ _IF_ARGS_ 0 0 X 11 _!_ _TUP_10 [{{Eq Int}}, {{Text Int}}, (Int -> Int -> Int), (Int -> Int -> Int), (Int -> Int -> Int), (Int -> Int), (Int -> Int), (Int -> Int), (Integer -> Int), (Int -> Int)] [_DFUN_ Eq (Int), _DFUN_ Text (Int), _CONSTM_ Num (+) (Int), _CONSTM_ Num (-) (Int), _CONSTM_ Num (*) (Int), _CONSTM_ Num negate (Int), _CONSTM_ Num abs (Int), _CONSTM_ Num signum (Int), _CONSTM_ Num fromInteger (Int), _CONSTM_ Num fromInt (Int)] _N_
- (+) = _A_ 2 _U_ 11 _N_ _S_ "U(P)U(P)" {_A_ 2 _U_ 22 _N_ _N_ _F_ _IF_ARGS_ 0 2 XX 3 \ (u0 :: Int#) (u1 :: Int#) -> case _#_ plusInt# [] [u0, u1] of { _PRIM_ (u2 :: Int#) -> _!_ I# [] [u2] } _N_} _F_ _IF_ARGS_ 0 2 CC 5 \ (u0 :: Int) (u1 :: Int) -> case u0 of { _ALG_ I# (u2 :: Int#) -> case u1 of { _ALG_ I# (u3 :: Int#) -> case _#_ plusInt# [] [u2, u3] of { _PRIM_ (u4 :: Int#) -> _!_ I# [] [u4] }; _NO_DEFLT_ }; _NO_DEFLT_ } _N_,
- (-) = _A_ 2 _U_ 11 _N_ _S_ "U(P)U(P)" {_A_ 2 _U_ 22 _N_ _N_ _F_ _IF_ARGS_ 0 2 XX 3 \ (u0 :: Int#) (u1 :: Int#) -> case _#_ minusInt# [] [u0, u1] of { _PRIM_ (u2 :: Int#) -> _!_ I# [] [u2] } _N_} _F_ _IF_ARGS_ 0 2 CC 5 \ (u0 :: Int) (u1 :: Int) -> case u0 of { _ALG_ I# (u2 :: Int#) -> case u1 of { _ALG_ I# (u3 :: Int#) -> case _#_ minusInt# [] [u2, u3] of { _PRIM_ (u4 :: Int#) -> _!_ I# [] [u4] }; _NO_DEFLT_ }; _NO_DEFLT_ } _N_,
- (*) = _A_ 2 _U_ 11 _N_ _S_ "U(P)U(P)" {_A_ 2 _U_ 22 _N_ _N_ _F_ _IF_ARGS_ 0 2 XX 3 \ (u0 :: Int#) (u1 :: Int#) -> case _#_ timesInt# [] [u0, u1] of { _PRIM_ (u2 :: Int#) -> _!_ I# [] [u2] } _N_} _F_ _IF_ARGS_ 0 2 CC 5 \ (u0 :: Int) (u1 :: Int) -> case u0 of { _ALG_ I# (u2 :: Int#) -> case u1 of { _ALG_ I# (u3 :: Int#) -> case _#_ timesInt# [] [u2, u3] of { _PRIM_ (u4 :: Int#) -> _!_ I# [] [u4] }; _NO_DEFLT_ }; _NO_DEFLT_ } _N_,
- negate = _A_ 1 _U_ 1 _N_ _S_ "U(P)" {_A_ 1 _U_ 2 _N_ _N_ _F_ _IF_ARGS_ 0 1 X 3 \ (u0 :: Int#) -> case _#_ negateInt# [] [u0] of { _PRIM_ (u1 :: Int#) -> _!_ I# [] [u1] } _N_} _F_ _IF_ARGS_ 0 1 C 4 \ (u0 :: Int) -> case u0 of { _ALG_ I# (u1 :: Int#) -> case _#_ negateInt# [] [u1] of { _PRIM_ (u2 :: Int#) -> _!_ I# [] [u2] }; _NO_DEFLT_ } _N_,
- abs = _A_ 1 _U_ 1 _N_ _S_ "U(P)" {_A_ 1 _U_ 2 _N_ _N_ _N_ _N_} _N_ _N_,
- signum = _A_ 1 _U_ 1 _N_ _S_ "U(P)" {_A_ 1 _U_ 2 _N_ _N_ _N_ _N_} _N_ _N_,
- fromInteger = _A_ 1 _U_ 1 _N_ _S_ "U(PPP)" {_A_ 3 _U_ 222 _N_ _N_ _F_ _IF_ARGS_ 0 3 XXX 3 \ (u0 :: Int#) (u1 :: Int#) (u2 :: ByteArray#) -> case _#_ integer2Int# [] [u0, u1, u2] of { _PRIM_ (u3 :: Int#) -> _!_ I# [] [u3] } _N_} _F_ _IF_ARGS_ 0 1 C 4 \ (u0 :: Integer) -> case u0 of { _ALG_ J# (u1 :: Int#) (u2 :: Int#) (u3 :: ByteArray#) -> case _#_ integer2Int# [] [u1, u2, u3] of { _PRIM_ (u4 :: Int#) -> _!_ I# [] [u4] }; _NO_DEFLT_ } _N_,
- fromInt = _A_ 1 _U_ 1 _N_ _S_ "U(P)" {_A_ 1 _U_ 2 _N_ _N_ _F_ _IF_ARGS_ 0 1 X 2 \ (u0 :: Int#) -> _!_ I# [] [u0] _N_} _F_ _IF_ARGS_ 0 1 X 1 \ (u0 :: Int) -> u0 _N_ #-}
+ (+) = { _A_ 2 _U_ 11 _N_ _S_ "U(P)U(P)" {_A_ 2 _U_ 22 _N_ _N_ _F_ _IF_ARGS_ 0 2 XX 3 \ (u0 :: Int#) (u1 :: Int#) -> case _#_ plusInt# [] [u0, u1] of { _PRIM_ (u2 :: Int#) -> _!_ I# [] [u2] } _N_} _F_ _IF_ARGS_ 0 2 CC 5 \ (u0 :: Int) (u1 :: Int) -> case u0 of { _ALG_ I# (u2 :: Int#) -> case u1 of { _ALG_ I# (u3 :: Int#) -> case _#_ plusInt# [] [u2, u3] of { _PRIM_ (u4 :: Int#) -> _!_ I# [] [u4] }; _NO_DEFLT_ }; _NO_DEFLT_ } _N_ },
+ (-) = { _A_ 2 _U_ 11 _N_ _S_ "U(P)U(P)" {_A_ 2 _U_ 22 _N_ _N_ _F_ _IF_ARGS_ 0 2 XX 3 \ (u0 :: Int#) (u1 :: Int#) -> case _#_ minusInt# [] [u0, u1] of { _PRIM_ (u2 :: Int#) -> _!_ I# [] [u2] } _N_} _F_ _IF_ARGS_ 0 2 CC 5 \ (u0 :: Int) (u1 :: Int) -> case u0 of { _ALG_ I# (u2 :: Int#) -> case u1 of { _ALG_ I# (u3 :: Int#) -> case _#_ minusInt# [] [u2, u3] of { _PRIM_ (u4 :: Int#) -> _!_ I# [] [u4] }; _NO_DEFLT_ }; _NO_DEFLT_ } _N_ },
+ (*) = { _A_ 2 _U_ 11 _N_ _S_ "U(P)U(P)" {_A_ 2 _U_ 22 _N_ _N_ _F_ _IF_ARGS_ 0 2 XX 3 \ (u0 :: Int#) (u1 :: Int#) -> case _#_ timesInt# [] [u0, u1] of { _PRIM_ (u2 :: Int#) -> _!_ I# [] [u2] } _N_} _F_ _IF_ARGS_ 0 2 CC 5 \ (u0 :: Int) (u1 :: Int) -> case u0 of { _ALG_ I# (u2 :: Int#) -> case u1 of { _ALG_ I# (u3 :: Int#) -> case _#_ timesInt# [] [u2, u3] of { _PRIM_ (u4 :: Int#) -> _!_ I# [] [u4] }; _NO_DEFLT_ }; _NO_DEFLT_ } _N_ },
+ negate = { _A_ 1 _U_ 1 _N_ _S_ "U(P)" {_A_ 1 _U_ 2 _N_ _N_ _F_ _IF_ARGS_ 0 1 X 3 \ (u0 :: Int#) -> case _#_ negateInt# [] [u0] of { _PRIM_ (u1 :: Int#) -> _!_ I# [] [u1] } _N_} _F_ _IF_ARGS_ 0 1 C 4 \ (u0 :: Int) -> case u0 of { _ALG_ I# (u1 :: Int#) -> case _#_ negateInt# [] [u1] of { _PRIM_ (u2 :: Int#) -> _!_ I# [] [u2] }; _NO_DEFLT_ } _N_ },
+ abs = { _A_ 1 _U_ 1 _N_ _S_ "U(P)" {_A_ 1 _U_ 2 _N_ _N_ _N_ _N_} _N_ _N_ },
+ signum = { _A_ 1 _U_ 1 _N_ _S_ "U(P)" {_A_ 1 _U_ 2 _N_ _N_ _N_ _N_} _N_ _N_ },
+ fromInteger = { _A_ 1 _U_ 1 _N_ _S_ "U(PPP)" {_A_ 3 _U_ 222 _N_ _N_ _F_ _IF_ARGS_ 0 3 XXX 3 \ (u0 :: Int#) (u1 :: Int#) (u2 :: ByteArray#) -> case _#_ integer2Int# [] [u0, u1, u2] of { _PRIM_ (u3 :: Int#) -> _!_ I# [] [u3] } _N_} _F_ _IF_ARGS_ 0 1 C 4 \ (u0 :: Integer) -> case u0 of { _ALG_ J# (u1 :: Int#) (u2 :: Int#) (u3 :: ByteArray#) -> case _#_ integer2Int# [] [u1, u2, u3] of { _PRIM_ (u4 :: Int#) -> _!_ I# [] [u4] }; _NO_DEFLT_ } _N_ },
+ fromInt = { _A_ 1 _U_ 1 _N_ _S_ "U(P)" {_A_ 1 _U_ 2 _N_ _N_ _F_ _IF_ARGS_ 0 1 X 2 \ (u0 :: Int#) -> _!_ I# [] [u0] _N_} _F_ _IF_ARGS_ 0 1 X 1 \ (u0 :: Int) -> u0 _N_ } #-}
instance Ord Int
{-# GHC_PRAGMA _M_ PreludeCore {-dfun-} _A_ 0 _N_ _N_ _N_ _F_ _IF_ARGS_ 0 0 X 9 _!_ _TUP_8 [{{Eq Int}}, (Int -> Int -> Bool), (Int -> Int -> Bool), (Int -> Int -> Bool), (Int -> Int -> Bool), (Int -> Int -> Int), (Int -> Int -> Int), (Int -> Int -> _CMP_TAG)] [_DFUN_ Eq (Int), _CONSTM_ Ord (<) (Int), _CONSTM_ Ord (<=) (Int), _CONSTM_ Ord (>=) (Int), _CONSTM_ Ord (>) (Int), _CONSTM_ Ord max (Int), _CONSTM_ Ord min (Int), _CONSTM_ Ord _tagCmp (Int)] _N_
- (<) = _A_ 2 _U_ 11 _N_ _S_ "U(P)U(P)" {_A_ 2 _U_ 22 _N_ _N_ _F_ _IF_ARGS_ 0 2 XX 1 \ (u0 :: Int#) (u1 :: Int#) -> _#_ ltInt# [] [u0, u1] _N_} _F_ _IF_ARGS_ 0 2 CC 3 \ (u0 :: Int) (u1 :: Int) -> case u0 of { _ALG_ I# (u2 :: Int#) -> case u1 of { _ALG_ I# (u3 :: Int#) -> _#_ ltInt# [] [u2, u3]; _NO_DEFLT_ }; _NO_DEFLT_ } _N_,
- (<=) = _A_ 2 _U_ 11 _N_ _S_ "U(P)U(P)" {_A_ 2 _U_ 22 _N_ _N_ _F_ _IF_ARGS_ 0 2 XX 1 \ (u0 :: Int#) (u1 :: Int#) -> _#_ leInt# [] [u0, u1] _N_} _F_ _IF_ARGS_ 0 2 CC 3 \ (u0 :: Int) (u1 :: Int) -> case u0 of { _ALG_ I# (u2 :: Int#) -> case u1 of { _ALG_ I# (u3 :: Int#) -> _#_ leInt# [] [u2, u3]; _NO_DEFLT_ }; _NO_DEFLT_ } _N_,
- (>=) = _A_ 2 _U_ 11 _N_ _S_ "U(P)U(P)" {_A_ 2 _U_ 22 _N_ _N_ _F_ _IF_ARGS_ 0 2 XX 1 \ (u0 :: Int#) (u1 :: Int#) -> _#_ geInt# [] [u0, u1] _N_} _F_ _IF_ARGS_ 0 2 CC 3 \ (u0 :: Int) (u1 :: Int) -> case u0 of { _ALG_ I# (u2 :: Int#) -> case u1 of { _ALG_ I# (u3 :: Int#) -> _#_ geInt# [] [u2, u3]; _NO_DEFLT_ }; _NO_DEFLT_ } _N_,
- (>) = _A_ 2 _U_ 11 _N_ _S_ "U(P)U(P)" {_A_ 2 _U_ 22 _N_ _N_ _F_ _IF_ARGS_ 0 2 XX 1 \ (u0 :: Int#) (u1 :: Int#) -> _#_ gtInt# [] [u0, u1] _N_} _F_ _IF_ARGS_ 0 2 CC 3 \ (u0 :: Int) (u1 :: Int) -> case u0 of { _ALG_ I# (u2 :: Int#) -> case u1 of { _ALG_ I# (u3 :: Int#) -> _#_ gtInt# [] [u2, u3]; _NO_DEFLT_ }; _NO_DEFLT_ } _N_,
- max = _A_ 2 _U_ 11 _N_ _S_ "U(P)U(P)" {_A_ 2 _U_ 22 _N_ _N_ _N_ _N_} _N_ _N_,
- min = _A_ 2 _U_ 11 _N_ _S_ "U(P)U(P)" {_A_ 2 _U_ 22 _N_ _N_ _N_ _N_} _N_ _N_,
- _tagCmp = _A_ 2 _U_ 11 _N_ _S_ "U(P)U(P)" {_A_ 2 _U_ 22 _N_ _N_ _N_ _N_} _N_ _N_ #-}
+ (<) = { _A_ 2 _U_ 11 _N_ _S_ "U(P)U(P)" {_A_ 2 _U_ 22 _N_ _N_ _F_ _IF_ARGS_ 0 2 XX 1 \ (u0 :: Int#) (u1 :: Int#) -> _#_ ltInt# [] [u0, u1] _N_} _F_ _IF_ARGS_ 0 2 CC 3 \ (u0 :: Int) (u1 :: Int) -> case u0 of { _ALG_ I# (u2 :: Int#) -> case u1 of { _ALG_ I# (u3 :: Int#) -> _#_ ltInt# [] [u2, u3]; _NO_DEFLT_ }; _NO_DEFLT_ } _N_ },
+ (<=) = { _A_ 2 _U_ 11 _N_ _S_ "U(P)U(P)" {_A_ 2 _U_ 22 _N_ _N_ _F_ _IF_ARGS_ 0 2 XX 1 \ (u0 :: Int#) (u1 :: Int#) -> _#_ leInt# [] [u0, u1] _N_} _F_ _IF_ARGS_ 0 2 CC 3 \ (u0 :: Int) (u1 :: Int) -> case u0 of { _ALG_ I# (u2 :: Int#) -> case u1 of { _ALG_ I# (u3 :: Int#) -> _#_ leInt# [] [u2, u3]; _NO_DEFLT_ }; _NO_DEFLT_ } _N_ },
+ (>=) = { _A_ 2 _U_ 11 _N_ _S_ "U(P)U(P)" {_A_ 2 _U_ 22 _N_ _N_ _F_ _IF_ARGS_ 0 2 XX 1 \ (u0 :: Int#) (u1 :: Int#) -> _#_ geInt# [] [u0, u1] _N_} _F_ _IF_ARGS_ 0 2 CC 3 \ (u0 :: Int) (u1 :: Int) -> case u0 of { _ALG_ I# (u2 :: Int#) -> case u1 of { _ALG_ I# (u3 :: Int#) -> _#_ geInt# [] [u2, u3]; _NO_DEFLT_ }; _NO_DEFLT_ } _N_ },
+ (>) = { _A_ 2 _U_ 11 _N_ _S_ "U(P)U(P)" {_A_ 2 _U_ 22 _N_ _N_ _F_ _IF_ARGS_ 0 2 XX 1 \ (u0 :: Int#) (u1 :: Int#) -> _#_ gtInt# [] [u0, u1] _N_} _F_ _IF_ARGS_ 0 2 CC 3 \ (u0 :: Int) (u1 :: Int) -> case u0 of { _ALG_ I# (u2 :: Int#) -> case u1 of { _ALG_ I# (u3 :: Int#) -> _#_ gtInt# [] [u2, u3]; _NO_DEFLT_ }; _NO_DEFLT_ } _N_ },
+ max = { _A_ 2 _U_ 11 _N_ _S_ "U(P)U(P)" {_A_ 2 _U_ 22 _N_ _N_ _N_ _N_} _N_ _N_ },
+ min = { _A_ 2 _U_ 11 _N_ _S_ "U(P)U(P)" {_A_ 2 _U_ 22 _N_ _N_ _N_ _N_} _N_ _N_ },
+ _tagCmp = { _A_ 2 _U_ 11 _N_ _S_ "U(P)U(P)" {_A_ 2 _U_ 22 _N_ _N_ _N_ _N_} _N_ _N_ } #-}
instance Ord _Addr
{-# GHC_PRAGMA _M_ PreludeCore {-dfun-} _A_ 0 _N_ _N_ _N_ _F_ _IF_ARGS_ 0 0 X 9 _!_ _TUP_8 [{{Eq _Addr}}, (_Addr -> _Addr -> Bool), (_Addr -> _Addr -> Bool), (_Addr -> _Addr -> Bool), (_Addr -> _Addr -> Bool), (_Addr -> _Addr -> _Addr), (_Addr -> _Addr -> _Addr), (_Addr -> _Addr -> _CMP_TAG)] [_DFUN_ Eq (_Addr), _CONSTM_ Ord (<) (_Addr), _CONSTM_ Ord (<=) (_Addr), _CONSTM_ Ord (>=) (_Addr), _CONSTM_ Ord (>) (_Addr), _CONSTM_ Ord max (_Addr), _CONSTM_ Ord min (_Addr), _CONSTM_ Ord _tagCmp (_Addr)] _N_
- (<) = _A_ 2 _U_ 11 _N_ _S_ "U(P)U(P)" {_A_ 2 _U_ 22 _N_ _N_ _F_ _IF_ARGS_ 0 2 XX 1 \ (u0 :: Addr#) (u1 :: Addr#) -> _#_ ltAddr# [] [u0, u1] _N_} _F_ _IF_ARGS_ 0 2 CC 3 \ (u0 :: _Addr) (u1 :: _Addr) -> case u0 of { _ALG_ A# (u2 :: Addr#) -> case u1 of { _ALG_ A# (u3 :: Addr#) -> _#_ ltAddr# [] [u2, u3]; _NO_DEFLT_ }; _NO_DEFLT_ } _N_,
- (<=) = _A_ 2 _U_ 11 _N_ _S_ "U(P)U(P)" {_A_ 2 _U_ 22 _N_ _N_ _F_ _IF_ARGS_ 0 2 XX 1 \ (u0 :: Addr#) (u1 :: Addr#) -> _#_ leAddr# [] [u0, u1] _N_} _F_ _IF_ARGS_ 0 2 CC 3 \ (u0 :: _Addr) (u1 :: _Addr) -> case u0 of { _ALG_ A# (u2 :: Addr#) -> case u1 of { _ALG_ A# (u3 :: Addr#) -> _#_ leAddr# [] [u2, u3]; _NO_DEFLT_ }; _NO_DEFLT_ } _N_,
- (>=) = _A_ 2 _U_ 11 _N_ _S_ "U(P)U(P)" {_A_ 2 _U_ 22 _N_ _N_ _F_ _IF_ARGS_ 0 2 XX 1 \ (u0 :: Addr#) (u1 :: Addr#) -> _#_ geAddr# [] [u0, u1] _N_} _F_ _IF_ARGS_ 0 2 CC 3 \ (u0 :: _Addr) (u1 :: _Addr) -> case u0 of { _ALG_ A# (u2 :: Addr#) -> case u1 of { _ALG_ A# (u3 :: Addr#) -> _#_ geAddr# [] [u2, u3]; _NO_DEFLT_ }; _NO_DEFLT_ } _N_,
- (>) = _A_ 2 _U_ 11 _N_ _S_ "U(P)U(P)" {_A_ 2 _U_ 22 _N_ _N_ _F_ _IF_ARGS_ 0 2 XX 1 \ (u0 :: Addr#) (u1 :: Addr#) -> _#_ gtAddr# [] [u0, u1] _N_} _F_ _IF_ARGS_ 0 2 CC 3 \ (u0 :: _Addr) (u1 :: _Addr) -> case u0 of { _ALG_ A# (u2 :: Addr#) -> case u1 of { _ALG_ A# (u3 :: Addr#) -> _#_ gtAddr# [] [u2, u3]; _NO_DEFLT_ }; _NO_DEFLT_ } _N_,
- max = _A_ 2 _U_ 11 _N_ _S_ "U(P)U(P)" {_A_ 2 _U_ 22 _N_ _N_ _N_ _N_} _N_ _N_,
- min = _A_ 2 _U_ 11 _N_ _S_ "U(P)U(P)" {_A_ 2 _U_ 22 _N_ _N_ _N_ _N_} _N_ _N_,
- _tagCmp = _A_ 2 _U_ 11 _N_ _S_ "U(P)U(P)" {_A_ 2 _U_ 22 _N_ _N_ _N_ _N_} _N_ _N_ #-}
+ (<) = { _A_ 2 _U_ 11 _N_ _S_ "U(P)U(P)" {_A_ 2 _U_ 22 _N_ _N_ _F_ _IF_ARGS_ 0 2 XX 1 \ (u0 :: Addr#) (u1 :: Addr#) -> _#_ ltAddr# [] [u0, u1] _N_} _F_ _IF_ARGS_ 0 2 CC 3 \ (u0 :: _Addr) (u1 :: _Addr) -> case u0 of { _ALG_ A# (u2 :: Addr#) -> case u1 of { _ALG_ A# (u3 :: Addr#) -> _#_ ltAddr# [] [u2, u3]; _NO_DEFLT_ }; _NO_DEFLT_ } _N_ },
+ (<=) = { _A_ 2 _U_ 11 _N_ _S_ "U(P)U(P)" {_A_ 2 _U_ 22 _N_ _N_ _F_ _IF_ARGS_ 0 2 XX 1 \ (u0 :: Addr#) (u1 :: Addr#) -> _#_ leAddr# [] [u0, u1] _N_} _F_ _IF_ARGS_ 0 2 CC 3 \ (u0 :: _Addr) (u1 :: _Addr) -> case u0 of { _ALG_ A# (u2 :: Addr#) -> case u1 of { _ALG_ A# (u3 :: Addr#) -> _#_ leAddr# [] [u2, u3]; _NO_DEFLT_ }; _NO_DEFLT_ } _N_ },
+ (>=) = { _A_ 2 _U_ 11 _N_ _S_ "U(P)U(P)" {_A_ 2 _U_ 22 _N_ _N_ _F_ _IF_ARGS_ 0 2 XX 1 \ (u0 :: Addr#) (u1 :: Addr#) -> _#_ geAddr# [] [u0, u1] _N_} _F_ _IF_ARGS_ 0 2 CC 3 \ (u0 :: _Addr) (u1 :: _Addr) -> case u0 of { _ALG_ A# (u2 :: Addr#) -> case u1 of { _ALG_ A# (u3 :: Addr#) -> _#_ geAddr# [] [u2, u3]; _NO_DEFLT_ }; _NO_DEFLT_ } _N_ },
+ (>) = { _A_ 2 _U_ 11 _N_ _S_ "U(P)U(P)" {_A_ 2 _U_ 22 _N_ _N_ _F_ _IF_ARGS_ 0 2 XX 1 \ (u0 :: Addr#) (u1 :: Addr#) -> _#_ gtAddr# [] [u0, u1] _N_} _F_ _IF_ARGS_ 0 2 CC 3 \ (u0 :: _Addr) (u1 :: _Addr) -> case u0 of { _ALG_ A# (u2 :: Addr#) -> case u1 of { _ALG_ A# (u3 :: Addr#) -> _#_ gtAddr# [] [u2, u3]; _NO_DEFLT_ }; _NO_DEFLT_ } _N_ },
+ max = { _A_ 2 _U_ 11 _N_ _S_ "U(P)U(P)" {_A_ 2 _U_ 22 _N_ _N_ _N_ _N_} _N_ _N_ },
+ min = { _A_ 2 _U_ 11 _N_ _S_ "U(P)U(P)" {_A_ 2 _U_ 22 _N_ _N_ _N_ _N_} _N_ _N_ },
+ _tagCmp = { _A_ 2 _U_ 11 _N_ _S_ "U(P)U(P)" {_A_ 2 _U_ 22 _N_ _N_ _N_ _N_} _N_ _N_ } #-}
instance Ord _Word
{-# GHC_PRAGMA _M_ PreludeCore {-dfun-} _A_ 0 _N_ _N_ _N_ _F_ _IF_ARGS_ 0 0 X 9 _!_ _TUP_8 [{{Eq _Word}}, (_Word -> _Word -> Bool), (_Word -> _Word -> Bool), (_Word -> _Word -> Bool), (_Word -> _Word -> Bool), (_Word -> _Word -> _Word), (_Word -> _Word -> _Word), (_Word -> _Word -> _CMP_TAG)] [_DFUN_ Eq (_Word), _CONSTM_ Ord (<) (_Word), _CONSTM_ Ord (<=) (_Word), _CONSTM_ Ord (>=) (_Word), _CONSTM_ Ord (>) (_Word), _CONSTM_ Ord max (_Word), _CONSTM_ Ord min (_Word), _CONSTM_ Ord _tagCmp (_Word)] _N_
- (<) = _A_ 2 _U_ 11 _N_ _S_ "U(P)U(P)" {_A_ 2 _U_ 22 _N_ _N_ _F_ _IF_ARGS_ 0 2 XX 1 \ (u0 :: Word#) (u1 :: Word#) -> _#_ ltWord# [] [u0, u1] _N_} _F_ _IF_ARGS_ 0 2 CC 3 \ (u0 :: _Word) (u1 :: _Word) -> case u0 of { _ALG_ W# (u2 :: Word#) -> case u1 of { _ALG_ W# (u3 :: Word#) -> _#_ ltWord# [] [u2, u3]; _NO_DEFLT_ }; _NO_DEFLT_ } _N_,
- (<=) = _A_ 2 _U_ 11 _N_ _S_ "U(P)U(P)" {_A_ 2 _U_ 22 _N_ _N_ _F_ _IF_ARGS_ 0 2 XX 1 \ (u0 :: Word#) (u1 :: Word#) -> _#_ leWord# [] [u0, u1] _N_} _F_ _IF_ARGS_ 0 2 CC 3 \ (u0 :: _Word) (u1 :: _Word) -> case u0 of { _ALG_ W# (u2 :: Word#) -> case u1 of { _ALG_ W# (u3 :: Word#) -> _#_ leWord# [] [u2, u3]; _NO_DEFLT_ }; _NO_DEFLT_ } _N_,
- (>=) = _A_ 2 _U_ 11 _N_ _S_ "U(P)U(P)" {_A_ 2 _U_ 22 _N_ _N_ _F_ _IF_ARGS_ 0 2 XX 1 \ (u0 :: Word#) (u1 :: Word#) -> _#_ geWord# [] [u0, u1] _N_} _F_ _IF_ARGS_ 0 2 CC 3 \ (u0 :: _Word) (u1 :: _Word) -> case u0 of { _ALG_ W# (u2 :: Word#) -> case u1 of { _ALG_ W# (u3 :: Word#) -> _#_ geWord# [] [u2, u3]; _NO_DEFLT_ }; _NO_DEFLT_ } _N_,
- (>) = _A_ 2 _U_ 11 _N_ _S_ "U(P)U(P)" {_A_ 2 _U_ 22 _N_ _N_ _F_ _IF_ARGS_ 0 2 XX 1 \ (u0 :: Word#) (u1 :: Word#) -> _#_ gtWord# [] [u0, u1] _N_} _F_ _IF_ARGS_ 0 2 CC 3 \ (u0 :: _Word) (u1 :: _Word) -> case u0 of { _ALG_ W# (u2 :: Word#) -> case u1 of { _ALG_ W# (u3 :: Word#) -> _#_ gtWord# [] [u2, u3]; _NO_DEFLT_ }; _NO_DEFLT_ } _N_,
- max = _A_ 2 _U_ 11 _N_ _S_ "U(P)U(P)" {_A_ 2 _U_ 22 _N_ _N_ _N_ _N_} _N_ _N_,
- min = _A_ 2 _U_ 11 _N_ _S_ "U(P)U(P)" {_A_ 2 _U_ 22 _N_ _N_ _N_ _N_} _N_ _N_,
- _tagCmp = _A_ 2 _U_ 11 _N_ _S_ "U(P)U(P)" {_A_ 2 _U_ 22 _N_ _N_ _N_ _N_} _N_ _N_ #-}
+ (<) = { _A_ 2 _U_ 11 _N_ _S_ "U(P)U(P)" {_A_ 2 _U_ 22 _N_ _N_ _F_ _IF_ARGS_ 0 2 XX 1 \ (u0 :: Word#) (u1 :: Word#) -> _#_ ltWord# [] [u0, u1] _N_} _F_ _IF_ARGS_ 0 2 CC 3 \ (u0 :: _Word) (u1 :: _Word) -> case u0 of { _ALG_ W# (u2 :: Word#) -> case u1 of { _ALG_ W# (u3 :: Word#) -> _#_ ltWord# [] [u2, u3]; _NO_DEFLT_ }; _NO_DEFLT_ } _N_ },
+ (<=) = { _A_ 2 _U_ 11 _N_ _S_ "U(P)U(P)" {_A_ 2 _U_ 22 _N_ _N_ _F_ _IF_ARGS_ 0 2 XX 1 \ (u0 :: Word#) (u1 :: Word#) -> _#_ leWord# [] [u0, u1] _N_} _F_ _IF_ARGS_ 0 2 CC 3 \ (u0 :: _Word) (u1 :: _Word) -> case u0 of { _ALG_ W# (u2 :: Word#) -> case u1 of { _ALG_ W# (u3 :: Word#) -> _#_ leWord# [] [u2, u3]; _NO_DEFLT_ }; _NO_DEFLT_ } _N_ },
+ (>=) = { _A_ 2 _U_ 11 _N_ _S_ "U(P)U(P)" {_A_ 2 _U_ 22 _N_ _N_ _F_ _IF_ARGS_ 0 2 XX 1 \ (u0 :: Word#) (u1 :: Word#) -> _#_ geWord# [] [u0, u1] _N_} _F_ _IF_ARGS_ 0 2 CC 3 \ (u0 :: _Word) (u1 :: _Word) -> case u0 of { _ALG_ W# (u2 :: Word#) -> case u1 of { _ALG_ W# (u3 :: Word#) -> _#_ geWord# [] [u2, u3]; _NO_DEFLT_ }; _NO_DEFLT_ } _N_ },
+ (>) = { _A_ 2 _U_ 11 _N_ _S_ "U(P)U(P)" {_A_ 2 _U_ 22 _N_ _N_ _F_ _IF_ARGS_ 0 2 XX 1 \ (u0 :: Word#) (u1 :: Word#) -> _#_ gtWord# [] [u0, u1] _N_} _F_ _IF_ARGS_ 0 2 CC 3 \ (u0 :: _Word) (u1 :: _Word) -> case u0 of { _ALG_ W# (u2 :: Word#) -> case u1 of { _ALG_ W# (u3 :: Word#) -> _#_ gtWord# [] [u2, u3]; _NO_DEFLT_ }; _NO_DEFLT_ } _N_ },
+ max = { _A_ 2 _U_ 11 _N_ _S_ "U(P)U(P)" {_A_ 2 _U_ 22 _N_ _N_ _N_ _N_} _N_ _N_ },
+ min = { _A_ 2 _U_ 11 _N_ _S_ "U(P)U(P)" {_A_ 2 _U_ 22 _N_ _N_ _N_ _N_} _N_ _N_ },
+ _tagCmp = { _A_ 2 _U_ 11 _N_ _S_ "U(P)U(P)" {_A_ 2 _U_ 22 _N_ _N_ _N_ _N_} _N_ _N_ } #-}
instance Real Int
{-# GHC_PRAGMA _M_ PreludeCore {-dfun-} _A_ 0 _N_ _N_ _N_ _F_ _IF_ARGS_ 0 0 X 4 _!_ _TUP_3 [{{Num Int}}, {{Enum Int}}, (Int -> Ratio Integer)] [_DFUN_ Num (Int), _DFUN_ Enum (Int), _CONSTM_ Real toRational (Int)] _N_
- toRational = _A_ 1 _U_ 1 _N_ _N_ _N_ _N_ #-}
+ toRational = { _A_ 1 _U_ 1 _N_ _N_ _N_ _N_ } #-}
instance Text Int
{-# GHC_PRAGMA _M_ PreludeCore {-dfun-} _A_ 0 _N_ _N_ _N_ _F_ _IF_ARGS_ 0 0 X 5 _!_ _TUP_4 [(Int -> [Char] -> [(Int, [Char])]), (Int -> Int -> [Char] -> [Char]), ([Char] -> [([Int], [Char])]), ([Int] -> [Char] -> [Char])] [_CONSTM_ Text readsPrec (Int), _CONSTM_ Text showsPrec (Int), _CONSTM_ Text readList (Int), _CONSTM_ Text showList (Int)] _N_
- readsPrec = _A_ 2 _U_ 02 _N_ _S_ "AL" {_A_ 1 _U_ 2 _N_ _N_ _F_ _IF_ARGS_ 0 1 X 3 \ (u0 :: [Char]) -> _APP_ _SPEC_ _ORIG_ PreludeText readSigned [ (Int) ] [ _SPEC_ _ORIG_ PreludeText readDec [ (Int) ], u0 ] _N_} _F_ _IF_ARGS_ 0 2 XX 3 \ (u0 :: Int) (u1 :: [Char]) -> _APP_ _SPEC_ _ORIG_ PreludeText readSigned [ (Int) ] [ _SPEC_ _ORIG_ PreludeText readDec [ (Int) ], u1 ] _N_,
- showsPrec = _A_ 3 _U_ 212 _N_ _S_ "LU(P)L" {_A_ 3 _U_ 222 _N_ _N_ _N_ _N_} _N_ _N_,
- readList = _A_ 0 _U_ 2 _N_ _N_ _N_ _N_,
- showList = _A_ 0 _U_ 12 _N_ _N_ _N_ _N_ #-}
+ readsPrec = { _A_ 2 _U_ 02 _N_ _S_ "AL" {_A_ 1 _U_ 2 _N_ _N_ _F_ _IF_ARGS_ 0 1 X 3 \ (u0 :: [Char]) -> _APP_ _SPEC_ _ORIG_ PreludeText readSigned [ (Int) ] [ _SPEC_ _ORIG_ PreludeText readDec [ (Int) ], u0 ] _N_} _F_ _IF_ARGS_ 0 2 XX 3 \ (u0 :: Int) (u1 :: [Char]) -> _APP_ _SPEC_ _ORIG_ PreludeText readSigned [ (Int) ] [ _SPEC_ _ORIG_ PreludeText readDec [ (Int) ], u1 ] _N_ },
+ showsPrec = { _A_ 3 _U_ 212 _N_ _S_ "LU(P)L" {_A_ 3 _U_ 222 _N_ _N_ _N_ _N_} _N_ _N_ },
+ readList = { _A_ 0 _U_ 2 _N_ _N_ _N_ _N_ },
+ showList = { _A_ 1 _U_ 12 _N_ _N_ _N_ _N_ } #-}
instance _CCallable Int
{-# GHC_PRAGMA _M_ PreludeCore {-dfun-} _A_ 0 _N_ _N_ _N_ _F_ _IF_ARGS_ 0 0 X 1 _!_ _TUP_0 [] [] _N_ #-}
instance _CCallable _Addr
-{-# GHC_PRAGMA INTERFACE VERSION 5 #-}
+{-# GHC_PRAGMA INTERFACE VERSION 6 #-}
interface PreludeCore where
import PreludeBuiltin(Int(..), Tuple0, _Addr(..), _Word(..))
-import PreludeGlaMisc(_MallocPtr(..))
+import PreludeGlaMisc(_MallocPtr(..), _StablePtr(..))
rangeComplaint_Ix_Int# :: Int# -> Int# -> Int# -> a
{-# GHC_PRAGMA _A_ 3 _U_ 222 _N_ _S_ _!_ _N_ _N_ #-}
instance Enum Int
{-# GHC_PRAGMA _M_ PreludeCore {-dfun-} _A_ 0 _N_ _N_ _N_ _F_ _IF_ARGS_ 0 0 X 6 _!_ _TUP_5 [{{Ord Int}}, (Int -> [Int]), (Int -> Int -> [Int]), (Int -> Int -> [Int]), (Int -> Int -> Int -> [Int])] [_DFUN_ Ord (Int), _CONSTM_ Enum enumFrom (Int), _CONSTM_ Enum enumFromThen (Int), _CONSTM_ Enum enumFromTo (Int), _CONSTM_ Enum enumFromThenTo (Int)] _N_
- enumFrom = _A_ 1 _U_ 2 _N_ _N_ _F_ _ALWAYS_ \ (u0 :: Int) -> _LETREC_ {(u1 :: Int -> [Int]) = \ (u2 :: Int) -> let {(u6 :: [Int]) = let {(u5 :: Int) = case u2 of { _ALG_ I# (u3 :: Int#) -> case _#_ plusInt# [] [u3, 1#] of { _PRIM_ (u4 :: Int#) -> _!_ I# [] [u4] }; _NO_DEFLT_ }} in _APP_ u1 [ u5 ]} in _!_ (:) [Int] [u2, u6]} in _APP_ u1 [ u0 ] _N_,
- enumFromThen = _A_ 2 _U_ 21 _N_ _N_ _N_ _N_,
- enumFromTo = _A_ 2 _U_ 12 _N_ _S_ "SS" _F_ _ALWAYS_ \ (u0 :: Int) (u1 :: Int) -> case u0 of { _ALG_ I# (u2 :: Int#) -> _LETREC_ {(u3 :: Int# -> [Int]) = \ (u4 :: Int#) -> case u1 of { _ALG_ I# (u5 :: Int#) -> case _#_ leInt# [] [u4, u5] of { _ALG_ True -> let {(u7 :: [Int]) = case _#_ plusInt# [] [u4, 1#] of { _PRIM_ (u6 :: Int#) -> _APP_ u3 [ u6 ] }} in let {(u8 :: Int) = _!_ I# [] [u4]} in _!_ (:) [Int] [u8, u7]; False -> _!_ _NIL_ [Int] []; _NO_DEFLT_ }; _NO_DEFLT_ }} in _APP_ u3 [ u2 ]; _NO_DEFLT_ } _N_,
- enumFromThenTo = _A_ 3 _U_ 222 _N_ _N_ _N_ _N_ #-}
+ enumFrom = { _A_ 1 _U_ 2 _N_ _N_ _F_ _ALWAYS_ \ (u0 :: Int) -> _LETREC_ {(u1 :: Int -> [Int]) = \ (u2 :: Int) -> let {(u6 :: [Int]) = let {(u5 :: Int) = case u2 of { _ALG_ I# (u3 :: Int#) -> case _#_ plusInt# [] [u3, 1#] of { _PRIM_ (u4 :: Int#) -> _!_ I# [] [u4] }; _NO_DEFLT_ }} in _APP_ u1 [ u5 ]} in _!_ (:) [Int] [u2, u6]} in _APP_ u1 [ u0 ] _N_ },
+ enumFromThen = { _A_ 2 _U_ 21 _N_ _N_ _N_ _N_ },
+ enumFromTo = { _A_ 2 _U_ 12 _N_ _S_ "SS" _F_ _ALWAYS_ \ (u0 :: Int) (u1 :: Int) -> case u0 of { _ALG_ I# (u2 :: Int#) -> _LETREC_ {(u3 :: Int# -> [Int]) = \ (u4 :: Int#) -> case u1 of { _ALG_ I# (u5 :: Int#) -> case _#_ leInt# [] [u4, u5] of { _ALG_ True -> let {(u7 :: [Int]) = case _#_ plusInt# [] [u4, 1#] of { _PRIM_ (u6 :: Int#) -> _APP_ u3 [ u6 ] }} in let {(u8 :: Int) = _!_ I# [] [u4]} in _!_ (:) [Int] [u8, u7]; False -> _!_ _NIL_ [Int] []; _NO_DEFLT_ }; _NO_DEFLT_ }} in _APP_ u3 [ u2 ]; _NO_DEFLT_ } _N_ },
+ enumFromThenTo = { _A_ 3 _U_ 222 _N_ _N_ _N_ _N_ } #-}
instance Eq Int
{-# GHC_PRAGMA _M_ PreludeCore {-dfun-} _A_ 0 _N_ _N_ _N_ _F_ _IF_ARGS_ 0 0 X 3 _!_ _TUP_2 [(Int -> Int -> Bool), (Int -> Int -> Bool)] [_CONSTM_ Eq (==) (Int), _CONSTM_ Eq (/=) (Int)] _N_
- (==) = _A_ 2 _U_ 11 _N_ _S_ "U(P)U(P)" {_A_ 2 _U_ 22 _N_ _N_ _F_ _IF_ARGS_ 0 2 XX 1 \ (u0 :: Int#) (u1 :: Int#) -> _#_ eqInt# [] [u0, u1] _N_} _F_ _IF_ARGS_ 0 2 CC 3 \ (u0 :: Int) (u1 :: Int) -> case u0 of { _ALG_ I# (u2 :: Int#) -> case u1 of { _ALG_ I# (u3 :: Int#) -> _#_ eqInt# [] [u2, u3]; _NO_DEFLT_ }; _NO_DEFLT_ } _N_,
- (/=) = _A_ 2 _U_ 11 _N_ _S_ "U(P)U(P)" {_A_ 2 _U_ 22 _N_ _N_ _F_ _IF_ARGS_ 0 2 XX 1 \ (u0 :: Int#) (u1 :: Int#) -> _#_ neInt# [] [u0, u1] _N_} _F_ _IF_ARGS_ 0 2 CC 3 \ (u0 :: Int) (u1 :: Int) -> case u0 of { _ALG_ I# (u2 :: Int#) -> case u1 of { _ALG_ I# (u3 :: Int#) -> _#_ neInt# [] [u2, u3]; _NO_DEFLT_ }; _NO_DEFLT_ } _N_ #-}
+ (==) = { _A_ 2 _U_ 11 _N_ _S_ "U(P)U(P)" {_A_ 2 _U_ 22 _N_ _N_ _F_ _IF_ARGS_ 0 2 XX 1 \ (u0 :: Int#) (u1 :: Int#) -> _#_ eqInt# [] [u0, u1] _N_} _F_ _IF_ARGS_ 0 2 CC 3 \ (u0 :: Int) (u1 :: Int) -> case u0 of { _ALG_ I# (u2 :: Int#) -> case u1 of { _ALG_ I# (u3 :: Int#) -> _#_ eqInt# [] [u2, u3]; _NO_DEFLT_ }; _NO_DEFLT_ } _N_ },
+ (/=) = { _A_ 2 _U_ 11 _N_ _S_ "U(P)U(P)" {_A_ 2 _U_ 22 _N_ _N_ _F_ _IF_ARGS_ 0 2 XX 1 \ (u0 :: Int#) (u1 :: Int#) -> _#_ neInt# [] [u0, u1] _N_} _F_ _IF_ARGS_ 0 2 CC 3 \ (u0 :: Int) (u1 :: Int) -> case u0 of { _ALG_ I# (u2 :: Int#) -> case u1 of { _ALG_ I# (u3 :: Int#) -> _#_ neInt# [] [u2, u3]; _NO_DEFLT_ }; _NO_DEFLT_ } _N_ } #-}
instance Eq _Addr
{-# GHC_PRAGMA _M_ PreludeCore {-dfun-} _A_ 0 _N_ _N_ _N_ _F_ _IF_ARGS_ 0 0 X 3 _!_ _TUP_2 [(_Addr -> _Addr -> Bool), (_Addr -> _Addr -> Bool)] [_CONSTM_ Eq (==) (_Addr), _CONSTM_ Eq (/=) (_Addr)] _N_
- (==) = _A_ 2 _U_ 11 _N_ _S_ "U(P)U(P)" {_A_ 2 _U_ 22 _N_ _N_ _F_ _IF_ARGS_ 0 2 XX 1 \ (u0 :: Addr#) (u1 :: Addr#) -> _#_ eqAddr# [] [u0, u1] _N_} _F_ _IF_ARGS_ 0 2 CC 3 \ (u0 :: _Addr) (u1 :: _Addr) -> case u0 of { _ALG_ A# (u2 :: Addr#) -> case u1 of { _ALG_ A# (u3 :: Addr#) -> _#_ eqAddr# [] [u2, u3]; _NO_DEFLT_ }; _NO_DEFLT_ } _N_,
- (/=) = _A_ 2 _U_ 11 _N_ _S_ "U(P)U(P)" {_A_ 2 _U_ 22 _N_ _N_ _F_ _IF_ARGS_ 0 2 XX 1 \ (u0 :: Addr#) (u1 :: Addr#) -> _#_ neAddr# [] [u0, u1] _N_} _F_ _IF_ARGS_ 0 2 CC 3 \ (u0 :: _Addr) (u1 :: _Addr) -> case u0 of { _ALG_ A# (u2 :: Addr#) -> case u1 of { _ALG_ A# (u3 :: Addr#) -> _#_ neAddr# [] [u2, u3]; _NO_DEFLT_ }; _NO_DEFLT_ } _N_ #-}
+ (==) = { _A_ 2 _U_ 11 _N_ _S_ "U(P)U(P)" {_A_ 2 _U_ 22 _N_ _N_ _F_ _IF_ARGS_ 0 2 XX 1 \ (u0 :: Addr#) (u1 :: Addr#) -> _#_ eqAddr# [] [u0, u1] _N_} _F_ _IF_ARGS_ 0 2 CC 3 \ (u0 :: _Addr) (u1 :: _Addr) -> case u0 of { _ALG_ A# (u2 :: Addr#) -> case u1 of { _ALG_ A# (u3 :: Addr#) -> _#_ eqAddr# [] [u2, u3]; _NO_DEFLT_ }; _NO_DEFLT_ } _N_ },
+ (/=) = { _A_ 2 _U_ 11 _N_ _S_ "U(P)U(P)" {_A_ 2 _U_ 22 _N_ _N_ _F_ _IF_ARGS_ 0 2 XX 1 \ (u0 :: Addr#) (u1 :: Addr#) -> _#_ neAddr# [] [u0, u1] _N_} _F_ _IF_ARGS_ 0 2 CC 3 \ (u0 :: _Addr) (u1 :: _Addr) -> case u0 of { _ALG_ A# (u2 :: Addr#) -> case u1 of { _ALG_ A# (u3 :: Addr#) -> _#_ neAddr# [] [u2, u3]; _NO_DEFLT_ }; _NO_DEFLT_ } _N_ } #-}
instance Eq _Word
{-# GHC_PRAGMA _M_ PreludeCore {-dfun-} _A_ 0 _N_ _N_ _N_ _F_ _IF_ARGS_ 0 0 X 3 _!_ _TUP_2 [(_Word -> _Word -> Bool), (_Word -> _Word -> Bool)] [_CONSTM_ Eq (==) (_Word), _CONSTM_ Eq (/=) (_Word)] _N_
- (==) = _A_ 2 _U_ 11 _N_ _S_ "U(P)U(P)" {_A_ 2 _U_ 22 _N_ _N_ _F_ _IF_ARGS_ 0 2 XX 1 \ (u0 :: Word#) (u1 :: Word#) -> _#_ eqWord# [] [u0, u1] _N_} _F_ _IF_ARGS_ 0 2 CC 3 \ (u0 :: _Word) (u1 :: _Word) -> case u0 of { _ALG_ W# (u2 :: Word#) -> case u1 of { _ALG_ W# (u3 :: Word#) -> _#_ eqWord# [] [u2, u3]; _NO_DEFLT_ }; _NO_DEFLT_ } _N_,
- (/=) = _A_ 2 _U_ 11 _N_ _S_ "U(P)U(P)" {_A_ 2 _U_ 22 _N_ _N_ _F_ _IF_ARGS_ 0 2 XX 1 \ (u0 :: Word#) (u1 :: Word#) -> _#_ neWord# [] [u0, u1] _N_} _F_ _IF_ARGS_ 0 2 CC 3 \ (u0 :: _Word) (u1 :: _Word) -> case u0 of { _ALG_ W# (u2 :: Word#) -> case u1 of { _ALG_ W# (u3 :: Word#) -> _#_ neWord# [] [u2, u3]; _NO_DEFLT_ }; _NO_DEFLT_ } _N_ #-}
+ (==) = { _A_ 2 _U_ 11 _N_ _S_ "U(P)U(P)" {_A_ 2 _U_ 22 _N_ _N_ _F_ _IF_ARGS_ 0 2 XX 1 \ (u0 :: Word#) (u1 :: Word#) -> _#_ eqWord# [] [u0, u1] _N_} _F_ _IF_ARGS_ 0 2 CC 3 \ (u0 :: _Word) (u1 :: _Word) -> case u0 of { _ALG_ W# (u2 :: Word#) -> case u1 of { _ALG_ W# (u3 :: Word#) -> _#_ eqWord# [] [u2, u3]; _NO_DEFLT_ }; _NO_DEFLT_ } _N_ },
+ (/=) = { _A_ 2 _U_ 11 _N_ _S_ "U(P)U(P)" {_A_ 2 _U_ 22 _N_ _N_ _F_ _IF_ARGS_ 0 2 XX 1 \ (u0 :: Word#) (u1 :: Word#) -> _#_ neWord# [] [u0, u1] _N_} _F_ _IF_ARGS_ 0 2 CC 3 \ (u0 :: _Word) (u1 :: _Word) -> case u0 of { _ALG_ W# (u2 :: Word#) -> case u1 of { _ALG_ W# (u3 :: Word#) -> _#_ neWord# [] [u2, u3]; _NO_DEFLT_ }; _NO_DEFLT_ } _N_ } #-}
instance Integral Int
{-# GHC_PRAGMA _M_ PreludeCore {-dfun-} _A_ 0 _N_ _N_ _N_ _F_ _IF_ARGS_ 0 0 X 13 _!_ _TUP_12 [{{Real Int}}, {{Ix Int}}, (Int -> Int -> Int), (Int -> Int -> Int), (Int -> Int -> Int), (Int -> Int -> Int), (Int -> Int -> (Int, Int)), (Int -> Int -> (Int, Int)), (Int -> Bool), (Int -> Bool), (Int -> Integer), (Int -> Int)] [_DFUN_ Real (Int), _DFUN_ Ix (Int), _CONSTM_ Integral quot (Int), _CONSTM_ Integral rem (Int), _CONSTM_ Integral div (Int), _CONSTM_ Integral mod (Int), _CONSTM_ Integral quotRem (Int), _CONSTM_ Integral divMod (Int), _CONSTM_ Integral even (Int), _CONSTM_ Integral odd (Int), _CONSTM_ Integral toInteger (Int), _CONSTM_ Integral toInt (Int)] _N_
- quot = _A_ 2 _U_ 11 _N_ _S_ "U(P)U(P)" {_A_ 2 _U_ 22 _N_ _N_ _F_ _IF_ARGS_ 0 2 XC 5 \ (u0 :: Int#) (u1 :: Int#) -> case u1 of { _PRIM_ 0# -> _APP_ _TYAPP_ error { Int } [ _NOREP_S_ "Integral.Int.quot{PreludeCore}: divide by 0\n" ]; (u2 :: Int#) -> case _#_ quotInt# [] [u0, u1] of { _PRIM_ (u3 :: Int#) -> _!_ I# [] [u3] } } _N_} _F_ _IF_ARGS_ 0 2 CC 7 \ (u0 :: Int) (u1 :: Int) -> case u1 of { _ALG_ I# (u2 :: Int#) -> case u2 of { _PRIM_ 0# -> _APP_ _TYAPP_ error { Int } [ _NOREP_S_ "Integral.Int.quot{PreludeCore}: divide by 0\n" ]; (u3 :: Int#) -> case u0 of { _ALG_ I# (u4 :: Int#) -> case _#_ quotInt# [] [u4, u2] of { _PRIM_ (u5 :: Int#) -> _!_ I# [] [u5] }; _NO_DEFLT_ } }; _NO_DEFLT_ } _N_,
- rem = _A_ 2 _U_ 11 _N_ _S_ "U(P)U(P)" {_A_ 2 _U_ 22 _N_ _N_ _F_ _IF_ARGS_ 0 2 XC 5 \ (u0 :: Int#) (u1 :: Int#) -> case u1 of { _PRIM_ 0# -> _APP_ _TYAPP_ error { Int } [ _NOREP_S_ "Integral.Int.rem{PreludeCore}: divide by 0\n" ]; (u2 :: Int#) -> case _#_ remInt# [] [u0, u1] of { _PRIM_ (u3 :: Int#) -> _!_ I# [] [u3] } } _N_} _F_ _IF_ARGS_ 0 2 CC 7 \ (u0 :: Int) (u1 :: Int) -> case u1 of { _ALG_ I# (u2 :: Int#) -> case u2 of { _PRIM_ 0# -> _APP_ _TYAPP_ error { Int } [ _NOREP_S_ "Integral.Int.rem{PreludeCore}: divide by 0\n" ]; (u3 :: Int#) -> case u0 of { _ALG_ I# (u4 :: Int#) -> case _#_ remInt# [] [u4, u2] of { _PRIM_ (u5 :: Int#) -> _!_ I# [] [u5] }; _NO_DEFLT_ } }; _NO_DEFLT_ } _N_,
- div = _A_ 2 _U_ 11 _N_ _S_ "U(P)U(P)" {_A_ 2 _U_ 22 _N_ _N_ _N_ _N_} _N_ _N_,
- mod = _A_ 2 _U_ 11 _N_ _S_ "U(P)U(P)" {_A_ 2 _U_ 22 _N_ _N_ _N_ _N_} _N_ _N_,
- quotRem = _A_ 2 _U_ 11 _N_ _S_ "U(P)U(P)" {_A_ 2 _U_ 22 _N_ _N_ _N_ _N_} _N_ _N_,
- divMod = _A_ 2 _U_ 11 _N_ _S_ "U(P)U(P)" {_A_ 2 _U_ 22 _N_ _N_ _N_ _N_} _N_ _N_,
- even = _A_ 1 _U_ 1 _N_ _S_ "U(P)" {_A_ 1 _U_ 2 _N_ _N_ _N_ _N_} _N_ _N_,
- odd = _A_ 1 _U_ 1 _N_ _S_ "U(P)" {_A_ 1 _U_ 2 _N_ _N_ _N_ _N_} _N_ _N_,
- toInteger = _A_ 1 _U_ 1 _N_ _S_ "U(P)" {_A_ 1 _U_ 2 _N_ _N_ _F_ _IF_ARGS_ 0 1 X 1 \ (u0 :: Int#) -> _#_ int2Integer# [] [u0] _N_} _F_ _IF_ARGS_ 0 1 C 2 \ (u0 :: Int) -> case u0 of { _ALG_ I# (u1 :: Int#) -> _#_ int2Integer# [] [u1]; _NO_DEFLT_ } _N_,
- toInt = _A_ 1 _U_ 1 _N_ _S_ "U(P)" {_A_ 1 _U_ 2 _N_ _N_ _F_ _IF_ARGS_ 0 1 X 2 \ (u0 :: Int#) -> _!_ I# [] [u0] _N_} _F_ _IF_ARGS_ 0 1 X 1 \ (u0 :: Int) -> u0 _N_ #-}
+ quot = { _A_ 2 _U_ 11 _N_ _S_ "U(P)U(P)" {_A_ 2 _U_ 22 _N_ _N_ _F_ _IF_ARGS_ 0 2 XC 5 \ (u0 :: Int#) (u1 :: Int#) -> case u1 of { _PRIM_ 0# -> _APP_ _TYAPP_ error { Int } [ _NOREP_S_ "Integral.Int.quot{PreludeCore}: divide by 0\n" ]; (u2 :: Int#) -> case _#_ quotInt# [] [u0, u1] of { _PRIM_ (u3 :: Int#) -> _!_ I# [] [u3] } } _N_} _F_ _IF_ARGS_ 0 2 CC 7 \ (u0 :: Int) (u1 :: Int) -> case u1 of { _ALG_ I# (u2 :: Int#) -> case u2 of { _PRIM_ 0# -> _APP_ _TYAPP_ error { Int } [ _NOREP_S_ "Integral.Int.quot{PreludeCore}: divide by 0\n" ]; (u3 :: Int#) -> case u0 of { _ALG_ I# (u4 :: Int#) -> case _#_ quotInt# [] [u4, u2] of { _PRIM_ (u5 :: Int#) -> _!_ I# [] [u5] }; _NO_DEFLT_ } }; _NO_DEFLT_ } _N_ },
+ rem = { _A_ 2 _U_ 11 _N_ _S_ "U(P)U(P)" {_A_ 2 _U_ 22 _N_ _N_ _F_ _IF_ARGS_ 0 2 XC 5 \ (u0 :: Int#) (u1 :: Int#) -> case u1 of { _PRIM_ 0# -> _APP_ _TYAPP_ error { Int } [ _NOREP_S_ "Integral.Int.rem{PreludeCore}: divide by 0\n" ]; (u2 :: Int#) -> case _#_ remInt# [] [u0, u1] of { _PRIM_ (u3 :: Int#) -> _!_ I# [] [u3] } } _N_} _F_ _IF_ARGS_ 0 2 CC 7 \ (u0 :: Int) (u1 :: Int) -> case u1 of { _ALG_ I# (u2 :: Int#) -> case u2 of { _PRIM_ 0# -> _APP_ _TYAPP_ error { Int } [ _NOREP_S_ "Integral.Int.rem{PreludeCore}: divide by 0\n" ]; (u3 :: Int#) -> case u0 of { _ALG_ I# (u4 :: Int#) -> case _#_ remInt# [] [u4, u2] of { _PRIM_ (u5 :: Int#) -> _!_ I# [] [u5] }; _NO_DEFLT_ } }; _NO_DEFLT_ } _N_ },
+ div = { _A_ 2 _U_ 11 _N_ _S_ "U(P)U(P)" {_A_ 2 _U_ 22 _N_ _N_ _N_ _N_} _N_ _N_ },
+ mod = { _A_ 2 _U_ 11 _N_ _S_ "U(P)U(P)" {_A_ 2 _U_ 22 _N_ _N_ _N_ _N_} _N_ _N_ },
+ quotRem = { _A_ 2 _U_ 11 _N_ _S_ "U(P)U(P)" {_A_ 2 _U_ 22 _N_ _N_ _N_ _N_} _N_ _N_ },
+ divMod = { _A_ 2 _U_ 11 _N_ _S_ "U(P)U(P)" {_A_ 2 _U_ 22 _N_ _N_ _N_ _N_} _N_ _N_ },
+ even = { _A_ 1 _U_ 1 _N_ _S_ "U(P)" {_A_ 1 _U_ 2 _N_ _N_ _N_ _N_} _N_ _N_ },
+ odd = { _A_ 1 _U_ 1 _N_ _S_ "U(P)" {_A_ 1 _U_ 2 _N_ _N_ _N_ _N_} _N_ _N_ },
+ toInteger = { _A_ 1 _U_ 1 _N_ _S_ "U(P)" {_A_ 1 _U_ 2 _N_ _N_ _F_ _IF_ARGS_ 0 1 X 1 \ (u0 :: Int#) -> _#_ int2Integer# [] [u0] _N_} _F_ _IF_ARGS_ 0 1 C 2 \ (u0 :: Int) -> case u0 of { _ALG_ I# (u1 :: Int#) -> _#_ int2Integer# [] [u1]; _NO_DEFLT_ } _N_ },
+ toInt = { _A_ 1 _U_ 1 _N_ _S_ "U(P)" {_A_ 1 _U_ 2 _N_ _N_ _F_ _IF_ARGS_ 0 1 X 2 \ (u0 :: Int#) -> _!_ I# [] [u0] _N_} _F_ _IF_ARGS_ 0 1 X 1 \ (u0 :: Int) -> u0 _N_ } #-}
instance Ix Int
{-# GHC_PRAGMA _M_ PreludeCore {-dfun-} _A_ 0 _N_ _N_ _N_ _F_ _IF_ARGS_ 0 0 X 5 _!_ _TUP_4 [{{Ord Int}}, ((Int, Int) -> [Int]), ((Int, Int) -> Int -> Int), ((Int, Int) -> Int -> Bool)] [_DFUN_ Ord (Int), _CONSTM_ Ix range (Int), _CONSTM_ Ix index (Int), _CONSTM_ Ix inRange (Int)] _N_
- range = _A_ 1 _U_ 1 _N_ _S_ "U(U(P)U(P))" {_A_ 2 _U_ 22 _N_ _N_ _N_ _N_} _N_ _N_,
- index = _A_ 2 _U_ 11 _N_ _S_ "U(U(P)U(P))U(P)" {_A_ 3 _U_ 222 _N_ _N_ _N_ _N_} _N_ _N_,
- inRange = _A_ 2 _U_ 11 _N_ _S_ "U(U(P)U(P))U(P)" {_A_ 3 _U_ 222 _N_ _N_ _F_ _IF_ARGS_ 0 3 XXX 5 \ (u0 :: Int#) (u1 :: Int#) (u2 :: Int#) -> case _#_ leInt# [] [u0, u2] of { _ALG_ True -> _#_ leInt# [] [u2, u1]; False -> _!_ False [] []; _NO_DEFLT_ } _N_} _F_ _ALWAYS_ \ (u0 :: (Int, Int)) (u1 :: Int) -> case u0 of { _ALG_ _TUP_2 (u2 :: Int) (u3 :: Int) -> case u2 of { _ALG_ I# (u4 :: Int#) -> case u3 of { _ALG_ I# (u5 :: Int#) -> case u1 of { _ALG_ I# (u6 :: Int#) -> case _#_ leInt# [] [u4, u6] of { _ALG_ True -> _#_ leInt# [] [u6, u5]; False -> _!_ False [] []; _NO_DEFLT_ }; _NO_DEFLT_ }; _NO_DEFLT_ }; _NO_DEFLT_ }; _NO_DEFLT_ } _N_ #-}
+ range = { _A_ 1 _U_ 1 _N_ _S_ "U(U(P)U(P))" {_A_ 2 _U_ 22 _N_ _N_ _N_ _N_} _N_ _N_ },
+ index = { _A_ 2 _U_ 11 _N_ _S_ "U(U(P)U(P))U(P)" {_A_ 3 _U_ 222 _N_ _N_ _N_ _N_} _N_ _N_ },
+ inRange = { _A_ 2 _U_ 11 _N_ _S_ "U(U(P)U(P))U(P)" {_A_ 3 _U_ 222 _N_ _N_ _F_ _IF_ARGS_ 0 3 XXX 5 \ (u0 :: Int#) (u1 :: Int#) (u2 :: Int#) -> case _#_ leInt# [] [u0, u2] of { _ALG_ True -> _#_ leInt# [] [u2, u1]; False -> _!_ False [] []; _NO_DEFLT_ } _N_} _F_ _ALWAYS_ \ (u0 :: (Int, Int)) (u1 :: Int) -> case u0 of { _ALG_ _TUP_2 (u2 :: Int) (u3 :: Int) -> case u2 of { _ALG_ I# (u4 :: Int#) -> case u3 of { _ALG_ I# (u5 :: Int#) -> case u1 of { _ALG_ I# (u6 :: Int#) -> case _#_ leInt# [] [u4, u6] of { _ALG_ True -> _#_ leInt# [] [u6, u5]; False -> _!_ False [] []; _NO_DEFLT_ }; _NO_DEFLT_ }; _NO_DEFLT_ }; _NO_DEFLT_ }; _NO_DEFLT_ } _N_ } #-}
instance Num Int
{-# GHC_PRAGMA _M_ PreludeCore {-dfun-} _A_ 0 _N_ _N_ _N_ _F_ _IF_ARGS_ 0 0 X 11 _!_ _TUP_10 [{{Eq Int}}, {{Text Int}}, (Int -> Int -> Int), (Int -> Int -> Int), (Int -> Int -> Int), (Int -> Int), (Int -> Int), (Int -> Int), (Integer -> Int), (Int -> Int)] [_DFUN_ Eq (Int), _DFUN_ Text (Int), _CONSTM_ Num (+) (Int), _CONSTM_ Num (-) (Int), _CONSTM_ Num (*) (Int), _CONSTM_ Num negate (Int), _CONSTM_ Num abs (Int), _CONSTM_ Num signum (Int), _CONSTM_ Num fromInteger (Int), _CONSTM_ Num fromInt (Int)] _N_
- (+) = _A_ 2 _U_ 11 _N_ _S_ "U(P)U(P)" {_A_ 2 _U_ 22 _N_ _N_ _F_ _IF_ARGS_ 0 2 XX 3 \ (u0 :: Int#) (u1 :: Int#) -> case _#_ plusInt# [] [u0, u1] of { _PRIM_ (u2 :: Int#) -> _!_ I# [] [u2] } _N_} _F_ _IF_ARGS_ 0 2 CC 5 \ (u0 :: Int) (u1 :: Int) -> case u0 of { _ALG_ I# (u2 :: Int#) -> case u1 of { _ALG_ I# (u3 :: Int#) -> case _#_ plusInt# [] [u2, u3] of { _PRIM_ (u4 :: Int#) -> _!_ I# [] [u4] }; _NO_DEFLT_ }; _NO_DEFLT_ } _N_,
- (-) = _A_ 2 _U_ 11 _N_ _S_ "U(P)U(P)" {_A_ 2 _U_ 22 _N_ _N_ _F_ _IF_ARGS_ 0 2 XX 3 \ (u0 :: Int#) (u1 :: Int#) -> case _#_ minusInt# [] [u0, u1] of { _PRIM_ (u2 :: Int#) -> _!_ I# [] [u2] } _N_} _F_ _IF_ARGS_ 0 2 CC 5 \ (u0 :: Int) (u1 :: Int) -> case u0 of { _ALG_ I# (u2 :: Int#) -> case u1 of { _ALG_ I# (u3 :: Int#) -> case _#_ minusInt# [] [u2, u3] of { _PRIM_ (u4 :: Int#) -> _!_ I# [] [u4] }; _NO_DEFLT_ }; _NO_DEFLT_ } _N_,
- (*) = _A_ 2 _U_ 11 _N_ _S_ "U(P)U(P)" {_A_ 2 _U_ 22 _N_ _N_ _F_ _IF_ARGS_ 0 2 XX 3 \ (u0 :: Int#) (u1 :: Int#) -> case _#_ timesInt# [] [u0, u1] of { _PRIM_ (u2 :: Int#) -> _!_ I# [] [u2] } _N_} _F_ _IF_ARGS_ 0 2 CC 5 \ (u0 :: Int) (u1 :: Int) -> case u0 of { _ALG_ I# (u2 :: Int#) -> case u1 of { _ALG_ I# (u3 :: Int#) -> case _#_ timesInt# [] [u2, u3] of { _PRIM_ (u4 :: Int#) -> _!_ I# [] [u4] }; _NO_DEFLT_ }; _NO_DEFLT_ } _N_,
- negate = _A_ 1 _U_ 1 _N_ _S_ "U(P)" {_A_ 1 _U_ 2 _N_ _N_ _F_ _IF_ARGS_ 0 1 X 3 \ (u0 :: Int#) -> case _#_ negateInt# [] [u0] of { _PRIM_ (u1 :: Int#) -> _!_ I# [] [u1] } _N_} _F_ _IF_ARGS_ 0 1 C 4 \ (u0 :: Int) -> case u0 of { _ALG_ I# (u1 :: Int#) -> case _#_ negateInt# [] [u1] of { _PRIM_ (u2 :: Int#) -> _!_ I# [] [u2] }; _NO_DEFLT_ } _N_,
- abs = _A_ 1 _U_ 1 _N_ _S_ "U(P)" {_A_ 1 _U_ 2 _N_ _N_ _N_ _N_} _N_ _N_,
- signum = _A_ 1 _U_ 1 _N_ _S_ "U(P)" {_A_ 1 _U_ 2 _N_ _N_ _N_ _N_} _N_ _N_,
- fromInteger = _A_ 1 _U_ 1 _N_ _S_ "U(PPP)" {_A_ 3 _U_ 222 _N_ _N_ _F_ _IF_ARGS_ 0 3 XXX 3 \ (u0 :: Int#) (u1 :: Int#) (u2 :: ByteArray#) -> case _#_ integer2Int# [] [u0, u1, u2] of { _PRIM_ (u3 :: Int#) -> _!_ I# [] [u3] } _N_} _F_ _IF_ARGS_ 0 1 C 4 \ (u0 :: Integer) -> case u0 of { _ALG_ J# (u1 :: Int#) (u2 :: Int#) (u3 :: ByteArray#) -> case _#_ integer2Int# [] [u1, u2, u3] of { _PRIM_ (u4 :: Int#) -> _!_ I# [] [u4] }; _NO_DEFLT_ } _N_,
- fromInt = _A_ 1 _U_ 1 _N_ _S_ "U(P)" {_A_ 1 _U_ 2 _N_ _N_ _F_ _IF_ARGS_ 0 1 X 2 \ (u0 :: Int#) -> _!_ I# [] [u0] _N_} _F_ _IF_ARGS_ 0 1 X 1 \ (u0 :: Int) -> u0 _N_ #-}
+ (+) = { _A_ 2 _U_ 11 _N_ _S_ "U(P)U(P)" {_A_ 2 _U_ 22 _N_ _N_ _F_ _IF_ARGS_ 0 2 XX 3 \ (u0 :: Int#) (u1 :: Int#) -> case _#_ plusInt# [] [u0, u1] of { _PRIM_ (u2 :: Int#) -> _!_ I# [] [u2] } _N_} _F_ _IF_ARGS_ 0 2 CC 5 \ (u0 :: Int) (u1 :: Int) -> case u0 of { _ALG_ I# (u2 :: Int#) -> case u1 of { _ALG_ I# (u3 :: Int#) -> case _#_ plusInt# [] [u2, u3] of { _PRIM_ (u4 :: Int#) -> _!_ I# [] [u4] }; _NO_DEFLT_ }; _NO_DEFLT_ } _N_ },
+ (-) = { _A_ 2 _U_ 11 _N_ _S_ "U(P)U(P)" {_A_ 2 _U_ 22 _N_ _N_ _F_ _IF_ARGS_ 0 2 XX 3 \ (u0 :: Int#) (u1 :: Int#) -> case _#_ minusInt# [] [u0, u1] of { _PRIM_ (u2 :: Int#) -> _!_ I# [] [u2] } _N_} _F_ _IF_ARGS_ 0 2 CC 5 \ (u0 :: Int) (u1 :: Int) -> case u0 of { _ALG_ I# (u2 :: Int#) -> case u1 of { _ALG_ I# (u3 :: Int#) -> case _#_ minusInt# [] [u2, u3] of { _PRIM_ (u4 :: Int#) -> _!_ I# [] [u4] }; _NO_DEFLT_ }; _NO_DEFLT_ } _N_ },
+ (*) = { _A_ 2 _U_ 11 _N_ _S_ "U(P)U(P)" {_A_ 2 _U_ 22 _N_ _N_ _F_ _IF_ARGS_ 0 2 XX 3 \ (u0 :: Int#) (u1 :: Int#) -> case _#_ timesInt# [] [u0, u1] of { _PRIM_ (u2 :: Int#) -> _!_ I# [] [u2] } _N_} _F_ _IF_ARGS_ 0 2 CC 5 \ (u0 :: Int) (u1 :: Int) -> case u0 of { _ALG_ I# (u2 :: Int#) -> case u1 of { _ALG_ I# (u3 :: Int#) -> case _#_ timesInt# [] [u2, u3] of { _PRIM_ (u4 :: Int#) -> _!_ I# [] [u4] }; _NO_DEFLT_ }; _NO_DEFLT_ } _N_ },
+ negate = { _A_ 1 _U_ 1 _N_ _S_ "U(P)" {_A_ 1 _U_ 2 _N_ _N_ _F_ _IF_ARGS_ 0 1 X 3 \ (u0 :: Int#) -> case _#_ negateInt# [] [u0] of { _PRIM_ (u1 :: Int#) -> _!_ I# [] [u1] } _N_} _F_ _IF_ARGS_ 0 1 C 4 \ (u0 :: Int) -> case u0 of { _ALG_ I# (u1 :: Int#) -> case _#_ negateInt# [] [u1] of { _PRIM_ (u2 :: Int#) -> _!_ I# [] [u2] }; _NO_DEFLT_ } _N_ },
+ abs = { _A_ 1 _U_ 1 _N_ _S_ "U(P)" {_A_ 1 _U_ 2 _N_ _N_ _N_ _N_} _N_ _N_ },
+ signum = { _A_ 1 _U_ 1 _N_ _S_ "U(P)" {_A_ 1 _U_ 2 _N_ _N_ _N_ _N_} _N_ _N_ },
+ fromInteger = { _A_ 1 _U_ 1 _N_ _S_ "U(PPP)" {_A_ 3 _U_ 222 _N_ _N_ _F_ _IF_ARGS_ 0 3 XXX 3 \ (u0 :: Int#) (u1 :: Int#) (u2 :: ByteArray#) -> case _#_ integer2Int# [] [u0, u1, u2] of { _PRIM_ (u3 :: Int#) -> _!_ I# [] [u3] } _N_} _F_ _IF_ARGS_ 0 1 C 4 \ (u0 :: Integer) -> case u0 of { _ALG_ J# (u1 :: Int#) (u2 :: Int#) (u3 :: ByteArray#) -> case _#_ integer2Int# [] [u1, u2, u3] of { _PRIM_ (u4 :: Int#) -> _!_ I# [] [u4] }; _NO_DEFLT_ } _N_ },
+ fromInt = { _A_ 1 _U_ 1 _N_ _S_ "U(P)" {_A_ 1 _U_ 2 _N_ _N_ _F_ _IF_ARGS_ 0 1 X 2 \ (u0 :: Int#) -> _!_ I# [] [u0] _N_} _F_ _IF_ARGS_ 0 1 X 1 \ (u0 :: Int) -> u0 _N_ } #-}
instance Ord Int
{-# GHC_PRAGMA _M_ PreludeCore {-dfun-} _A_ 0 _N_ _N_ _N_ _F_ _IF_ARGS_ 0 0 X 9 _!_ _TUP_8 [{{Eq Int}}, (Int -> Int -> Bool), (Int -> Int -> Bool), (Int -> Int -> Bool), (Int -> Int -> Bool), (Int -> Int -> Int), (Int -> Int -> Int), (Int -> Int -> _CMP_TAG)] [_DFUN_ Eq (Int), _CONSTM_ Ord (<) (Int), _CONSTM_ Ord (<=) (Int), _CONSTM_ Ord (>=) (Int), _CONSTM_ Ord (>) (Int), _CONSTM_ Ord max (Int), _CONSTM_ Ord min (Int), _CONSTM_ Ord _tagCmp (Int)] _N_
- (<) = _A_ 2 _U_ 11 _N_ _S_ "U(P)U(P)" {_A_ 2 _U_ 22 _N_ _N_ _F_ _IF_ARGS_ 0 2 XX 1 \ (u0 :: Int#) (u1 :: Int#) -> _#_ ltInt# [] [u0, u1] _N_} _F_ _IF_ARGS_ 0 2 CC 3 \ (u0 :: Int) (u1 :: Int) -> case u0 of { _ALG_ I# (u2 :: Int#) -> case u1 of { _ALG_ I# (u3 :: Int#) -> _#_ ltInt# [] [u2, u3]; _NO_DEFLT_ }; _NO_DEFLT_ } _N_,
- (<=) = _A_ 2 _U_ 11 _N_ _S_ "U(P)U(P)" {_A_ 2 _U_ 22 _N_ _N_ _F_ _IF_ARGS_ 0 2 XX 1 \ (u0 :: Int#) (u1 :: Int#) -> _#_ leInt# [] [u0, u1] _N_} _F_ _IF_ARGS_ 0 2 CC 3 \ (u0 :: Int) (u1 :: Int) -> case u0 of { _ALG_ I# (u2 :: Int#) -> case u1 of { _ALG_ I# (u3 :: Int#) -> _#_ leInt# [] [u2, u3]; _NO_DEFLT_ }; _NO_DEFLT_ } _N_,
- (>=) = _A_ 2 _U_ 11 _N_ _S_ "U(P)U(P)" {_A_ 2 _U_ 22 _N_ _N_ _F_ _IF_ARGS_ 0 2 XX 1 \ (u0 :: Int#) (u1 :: Int#) -> _#_ geInt# [] [u0, u1] _N_} _F_ _IF_ARGS_ 0 2 CC 3 \ (u0 :: Int) (u1 :: Int) -> case u0 of { _ALG_ I# (u2 :: Int#) -> case u1 of { _ALG_ I# (u3 :: Int#) -> _#_ geInt# [] [u2, u3]; _NO_DEFLT_ }; _NO_DEFLT_ } _N_,
- (>) = _A_ 2 _U_ 11 _N_ _S_ "U(P)U(P)" {_A_ 2 _U_ 22 _N_ _N_ _F_ _IF_ARGS_ 0 2 XX 1 \ (u0 :: Int#) (u1 :: Int#) -> _#_ gtInt# [] [u0, u1] _N_} _F_ _IF_ARGS_ 0 2 CC 3 \ (u0 :: Int) (u1 :: Int) -> case u0 of { _ALG_ I# (u2 :: Int#) -> case u1 of { _ALG_ I# (u3 :: Int#) -> _#_ gtInt# [] [u2, u3]; _NO_DEFLT_ }; _NO_DEFLT_ } _N_,
- max = _A_ 2 _U_ 11 _N_ _S_ "U(P)U(P)" {_A_ 2 _U_ 22 _N_ _N_ _N_ _N_} _N_ _N_,
- min = _A_ 2 _U_ 11 _N_ _S_ "U(P)U(P)" {_A_ 2 _U_ 22 _N_ _N_ _N_ _N_} _N_ _N_,
- _tagCmp = _A_ 2 _U_ 11 _N_ _S_ "U(P)U(P)" {_A_ 2 _U_ 22 _N_ _N_ _N_ _N_} _N_ _N_ #-}
+ (<) = { _A_ 2 _U_ 11 _N_ _S_ "U(P)U(P)" {_A_ 2 _U_ 22 _N_ _N_ _F_ _IF_ARGS_ 0 2 XX 1 \ (u0 :: Int#) (u1 :: Int#) -> _#_ ltInt# [] [u0, u1] _N_} _F_ _IF_ARGS_ 0 2 CC 3 \ (u0 :: Int) (u1 :: Int) -> case u0 of { _ALG_ I# (u2 :: Int#) -> case u1 of { _ALG_ I# (u3 :: Int#) -> _#_ ltInt# [] [u2, u3]; _NO_DEFLT_ }; _NO_DEFLT_ } _N_ },
+ (<=) = { _A_ 2 _U_ 11 _N_ _S_ "U(P)U(P)" {_A_ 2 _U_ 22 _N_ _N_ _F_ _IF_ARGS_ 0 2 XX 1 \ (u0 :: Int#) (u1 :: Int#) -> _#_ leInt# [] [u0, u1] _N_} _F_ _IF_ARGS_ 0 2 CC 3 \ (u0 :: Int) (u1 :: Int) -> case u0 of { _ALG_ I# (u2 :: Int#) -> case u1 of { _ALG_ I# (u3 :: Int#) -> _#_ leInt# [] [u2, u3]; _NO_DEFLT_ }; _NO_DEFLT_ } _N_ },
+ (>=) = { _A_ 2 _U_ 11 _N_ _S_ "U(P)U(P)" {_A_ 2 _U_ 22 _N_ _N_ _F_ _IF_ARGS_ 0 2 XX 1 \ (u0 :: Int#) (u1 :: Int#) -> _#_ geInt# [] [u0, u1] _N_} _F_ _IF_ARGS_ 0 2 CC 3 \ (u0 :: Int) (u1 :: Int) -> case u0 of { _ALG_ I# (u2 :: Int#) -> case u1 of { _ALG_ I# (u3 :: Int#) -> _#_ geInt# [] [u2, u3]; _NO_DEFLT_ }; _NO_DEFLT_ } _N_ },
+ (>) = { _A_ 2 _U_ 11 _N_ _S_ "U(P)U(P)" {_A_ 2 _U_ 22 _N_ _N_ _F_ _IF_ARGS_ 0 2 XX 1 \ (u0 :: Int#) (u1 :: Int#) -> _#_ gtInt# [] [u0, u1] _N_} _F_ _IF_ARGS_ 0 2 CC 3 \ (u0 :: Int) (u1 :: Int) -> case u0 of { _ALG_ I# (u2 :: Int#) -> case u1 of { _ALG_ I# (u3 :: Int#) -> _#_ gtInt# [] [u2, u3]; _NO_DEFLT_ }; _NO_DEFLT_ } _N_ },
+ max = { _A_ 2 _U_ 11 _N_ _S_ "U(P)U(P)" {_A_ 2 _U_ 22 _N_ _N_ _N_ _N_} _N_ _N_ },
+ min = { _A_ 2 _U_ 11 _N_ _S_ "U(P)U(P)" {_A_ 2 _U_ 22 _N_ _N_ _N_ _N_} _N_ _N_ },
+ _tagCmp = { _A_ 2 _U_ 11 _N_ _S_ "U(P)U(P)" {_A_ 2 _U_ 22 _N_ _N_ _N_ _N_} _N_ _N_ } #-}
instance Ord _Addr
{-# GHC_PRAGMA _M_ PreludeCore {-dfun-} _A_ 0 _N_ _N_ _N_ _F_ _IF_ARGS_ 0 0 X 9 _!_ _TUP_8 [{{Eq _Addr}}, (_Addr -> _Addr -> Bool), (_Addr -> _Addr -> Bool), (_Addr -> _Addr -> Bool), (_Addr -> _Addr -> Bool), (_Addr -> _Addr -> _Addr), (_Addr -> _Addr -> _Addr), (_Addr -> _Addr -> _CMP_TAG)] [_DFUN_ Eq (_Addr), _CONSTM_ Ord (<) (_Addr), _CONSTM_ Ord (<=) (_Addr), _CONSTM_ Ord (>=) (_Addr), _CONSTM_ Ord (>) (_Addr), _CONSTM_ Ord max (_Addr), _CONSTM_ Ord min (_Addr), _CONSTM_ Ord _tagCmp (_Addr)] _N_
- (<) = _A_ 2 _U_ 11 _N_ _S_ "U(P)U(P)" {_A_ 2 _U_ 22 _N_ _N_ _F_ _IF_ARGS_ 0 2 XX 1 \ (u0 :: Addr#) (u1 :: Addr#) -> _#_ ltAddr# [] [u0, u1] _N_} _F_ _IF_ARGS_ 0 2 CC 3 \ (u0 :: _Addr) (u1 :: _Addr) -> case u0 of { _ALG_ A# (u2 :: Addr#) -> case u1 of { _ALG_ A# (u3 :: Addr#) -> _#_ ltAddr# [] [u2, u3]; _NO_DEFLT_ }; _NO_DEFLT_ } _N_,
- (<=) = _A_ 2 _U_ 11 _N_ _S_ "U(P)U(P)" {_A_ 2 _U_ 22 _N_ _N_ _F_ _IF_ARGS_ 0 2 XX 1 \ (u0 :: Addr#) (u1 :: Addr#) -> _#_ leAddr# [] [u0, u1] _N_} _F_ _IF_ARGS_ 0 2 CC 3 \ (u0 :: _Addr) (u1 :: _Addr) -> case u0 of { _ALG_ A# (u2 :: Addr#) -> case u1 of { _ALG_ A# (u3 :: Addr#) -> _#_ leAddr# [] [u2, u3]; _NO_DEFLT_ }; _NO_DEFLT_ } _N_,
- (>=) = _A_ 2 _U_ 11 _N_ _S_ "U(P)U(P)" {_A_ 2 _U_ 22 _N_ _N_ _F_ _IF_ARGS_ 0 2 XX 1 \ (u0 :: Addr#) (u1 :: Addr#) -> _#_ geAddr# [] [u0, u1] _N_} _F_ _IF_ARGS_ 0 2 CC 3 \ (u0 :: _Addr) (u1 :: _Addr) -> case u0 of { _ALG_ A# (u2 :: Addr#) -> case u1 of { _ALG_ A# (u3 :: Addr#) -> _#_ geAddr# [] [u2, u3]; _NO_DEFLT_ }; _NO_DEFLT_ } _N_,
- (>) = _A_ 2 _U_ 11 _N_ _S_ "U(P)U(P)" {_A_ 2 _U_ 22 _N_ _N_ _F_ _IF_ARGS_ 0 2 XX 1 \ (u0 :: Addr#) (u1 :: Addr#) -> _#_ gtAddr# [] [u0, u1] _N_} _F_ _IF_ARGS_ 0 2 CC 3 \ (u0 :: _Addr) (u1 :: _Addr) -> case u0 of { _ALG_ A# (u2 :: Addr#) -> case u1 of { _ALG_ A# (u3 :: Addr#) -> _#_ gtAddr# [] [u2, u3]; _NO_DEFLT_ }; _NO_DEFLT_ } _N_,
- max = _A_ 2 _U_ 11 _N_ _S_ "U(P)U(P)" {_A_ 2 _U_ 22 _N_ _N_ _N_ _N_} _N_ _N_,
- min = _A_ 2 _U_ 11 _N_ _S_ "U(P)U(P)" {_A_ 2 _U_ 22 _N_ _N_ _N_ _N_} _N_ _N_,
- _tagCmp = _A_ 2 _U_ 11 _N_ _S_ "U(P)U(P)" {_A_ 2 _U_ 22 _N_ _N_ _N_ _N_} _N_ _N_ #-}
+ (<) = { _A_ 2 _U_ 11 _N_ _S_ "U(P)U(P)" {_A_ 2 _U_ 22 _N_ _N_ _F_ _IF_ARGS_ 0 2 XX 1 \ (u0 :: Addr#) (u1 :: Addr#) -> _#_ ltAddr# [] [u0, u1] _N_} _F_ _IF_ARGS_ 0 2 CC 3 \ (u0 :: _Addr) (u1 :: _Addr) -> case u0 of { _ALG_ A# (u2 :: Addr#) -> case u1 of { _ALG_ A# (u3 :: Addr#) -> _#_ ltAddr# [] [u2, u3]; _NO_DEFLT_ }; _NO_DEFLT_ } _N_ },
+ (<=) = { _A_ 2 _U_ 11 _N_ _S_ "U(P)U(P)" {_A_ 2 _U_ 22 _N_ _N_ _F_ _IF_ARGS_ 0 2 XX 1 \ (u0 :: Addr#) (u1 :: Addr#) -> _#_ leAddr# [] [u0, u1] _N_} _F_ _IF_ARGS_ 0 2 CC 3 \ (u0 :: _Addr) (u1 :: _Addr) -> case u0 of { _ALG_ A# (u2 :: Addr#) -> case u1 of { _ALG_ A# (u3 :: Addr#) -> _#_ leAddr# [] [u2, u3]; _NO_DEFLT_ }; _NO_DEFLT_ } _N_ },
+ (>=) = { _A_ 2 _U_ 11 _N_ _S_ "U(P)U(P)" {_A_ 2 _U_ 22 _N_ _N_ _F_ _IF_ARGS_ 0 2 XX 1 \ (u0 :: Addr#) (u1 :: Addr#) -> _#_ geAddr# [] [u0, u1] _N_} _F_ _IF_ARGS_ 0 2 CC 3 \ (u0 :: _Addr) (u1 :: _Addr) -> case u0 of { _ALG_ A# (u2 :: Addr#) -> case u1 of { _ALG_ A# (u3 :: Addr#) -> _#_ geAddr# [] [u2, u3]; _NO_DEFLT_ }; _NO_DEFLT_ } _N_ },
+ (>) = { _A_ 2 _U_ 11 _N_ _S_ "U(P)U(P)" {_A_ 2 _U_ 22 _N_ _N_ _F_ _IF_ARGS_ 0 2 XX 1 \ (u0 :: Addr#) (u1 :: Addr#) -> _#_ gtAddr# [] [u0, u1] _N_} _F_ _IF_ARGS_ 0 2 CC 3 \ (u0 :: _Addr) (u1 :: _Addr) -> case u0 of { _ALG_ A# (u2 :: Addr#) -> case u1 of { _ALG_ A# (u3 :: Addr#) -> _#_ gtAddr# [] [u2, u3]; _NO_DEFLT_ }; _NO_DEFLT_ } _N_ },
+ max = { _A_ 2 _U_ 11 _N_ _S_ "U(P)U(P)" {_A_ 2 _U_ 22 _N_ _N_ _N_ _N_} _N_ _N_ },
+ min = { _A_ 2 _U_ 11 _N_ _S_ "U(P)U(P)" {_A_ 2 _U_ 22 _N_ _N_ _N_ _N_} _N_ _N_ },
+ _tagCmp = { _A_ 2 _U_ 11 _N_ _S_ "U(P)U(P)" {_A_ 2 _U_ 22 _N_ _N_ _N_ _N_} _N_ _N_ } #-}
instance Ord _Word
{-# GHC_PRAGMA _M_ PreludeCore {-dfun-} _A_ 0 _N_ _N_ _N_ _F_ _IF_ARGS_ 0 0 X 9 _!_ _TUP_8 [{{Eq _Word}}, (_Word -> _Word -> Bool), (_Word -> _Word -> Bool), (_Word -> _Word -> Bool), (_Word -> _Word -> Bool), (_Word -> _Word -> _Word), (_Word -> _Word -> _Word), (_Word -> _Word -> _CMP_TAG)] [_DFUN_ Eq (_Word), _CONSTM_ Ord (<) (_Word), _CONSTM_ Ord (<=) (_Word), _CONSTM_ Ord (>=) (_Word), _CONSTM_ Ord (>) (_Word), _CONSTM_ Ord max (_Word), _CONSTM_ Ord min (_Word), _CONSTM_ Ord _tagCmp (_Word)] _N_
- (<) = _A_ 2 _U_ 11 _N_ _S_ "U(P)U(P)" {_A_ 2 _U_ 22 _N_ _N_ _F_ _IF_ARGS_ 0 2 XX 1 \ (u0 :: Word#) (u1 :: Word#) -> _#_ ltWord# [] [u0, u1] _N_} _F_ _IF_ARGS_ 0 2 CC 3 \ (u0 :: _Word) (u1 :: _Word) -> case u0 of { _ALG_ W# (u2 :: Word#) -> case u1 of { _ALG_ W# (u3 :: Word#) -> _#_ ltWord# [] [u2, u3]; _NO_DEFLT_ }; _NO_DEFLT_ } _N_,
- (<=) = _A_ 2 _U_ 11 _N_ _S_ "U(P)U(P)" {_A_ 2 _U_ 22 _N_ _N_ _F_ _IF_ARGS_ 0 2 XX 1 \ (u0 :: Word#) (u1 :: Word#) -> _#_ leWord# [] [u0, u1] _N_} _F_ _IF_ARGS_ 0 2 CC 3 \ (u0 :: _Word) (u1 :: _Word) -> case u0 of { _ALG_ W# (u2 :: Word#) -> case u1 of { _ALG_ W# (u3 :: Word#) -> _#_ leWord# [] [u2, u3]; _NO_DEFLT_ }; _NO_DEFLT_ } _N_,
- (>=) = _A_ 2 _U_ 11 _N_ _S_ "U(P)U(P)" {_A_ 2 _U_ 22 _N_ _N_ _F_ _IF_ARGS_ 0 2 XX 1 \ (u0 :: Word#) (u1 :: Word#) -> _#_ geWord# [] [u0, u1] _N_} _F_ _IF_ARGS_ 0 2 CC 3 \ (u0 :: _Word) (u1 :: _Word) -> case u0 of { _ALG_ W# (u2 :: Word#) -> case u1 of { _ALG_ W# (u3 :: Word#) -> _#_ geWord# [] [u2, u3]; _NO_DEFLT_ }; _NO_DEFLT_ } _N_,
- (>) = _A_ 2 _U_ 11 _N_ _S_ "U(P)U(P)" {_A_ 2 _U_ 22 _N_ _N_ _F_ _IF_ARGS_ 0 2 XX 1 \ (u0 :: Word#) (u1 :: Word#) -> _#_ gtWord# [] [u0, u1] _N_} _F_ _IF_ARGS_ 0 2 CC 3 \ (u0 :: _Word) (u1 :: _Word) -> case u0 of { _ALG_ W# (u2 :: Word#) -> case u1 of { _ALG_ W# (u3 :: Word#) -> _#_ gtWord# [] [u2, u3]; _NO_DEFLT_ }; _NO_DEFLT_ } _N_,
- max = _A_ 2 _U_ 11 _N_ _S_ "U(P)U(P)" {_A_ 2 _U_ 22 _N_ _N_ _N_ _N_} _N_ _N_,
- min = _A_ 2 _U_ 11 _N_ _S_ "U(P)U(P)" {_A_ 2 _U_ 22 _N_ _N_ _N_ _N_} _N_ _N_,
- _tagCmp = _A_ 2 _U_ 11 _N_ _S_ "U(P)U(P)" {_A_ 2 _U_ 22 _N_ _N_ _N_ _N_} _N_ _N_ #-}
+ (<) = { _A_ 2 _U_ 11 _N_ _S_ "U(P)U(P)" {_A_ 2 _U_ 22 _N_ _N_ _F_ _IF_ARGS_ 0 2 XX 1 \ (u0 :: Word#) (u1 :: Word#) -> _#_ ltWord# [] [u0, u1] _N_} _F_ _IF_ARGS_ 0 2 CC 3 \ (u0 :: _Word) (u1 :: _Word) -> case u0 of { _ALG_ W# (u2 :: Word#) -> case u1 of { _ALG_ W# (u3 :: Word#) -> _#_ ltWord# [] [u2, u3]; _NO_DEFLT_ }; _NO_DEFLT_ } _N_ },
+ (<=) = { _A_ 2 _U_ 11 _N_ _S_ "U(P)U(P)" {_A_ 2 _U_ 22 _N_ _N_ _F_ _IF_ARGS_ 0 2 XX 1 \ (u0 :: Word#) (u1 :: Word#) -> _#_ leWord# [] [u0, u1] _N_} _F_ _IF_ARGS_ 0 2 CC 3 \ (u0 :: _Word) (u1 :: _Word) -> case u0 of { _ALG_ W# (u2 :: Word#) -> case u1 of { _ALG_ W# (u3 :: Word#) -> _#_ leWord# [] [u2, u3]; _NO_DEFLT_ }; _NO_DEFLT_ } _N_ },
+ (>=) = { _A_ 2 _U_ 11 _N_ _S_ "U(P)U(P)" {_A_ 2 _U_ 22 _N_ _N_ _F_ _IF_ARGS_ 0 2 XX 1 \ (u0 :: Word#) (u1 :: Word#) -> _#_ geWord# [] [u0, u1] _N_} _F_ _IF_ARGS_ 0 2 CC 3 \ (u0 :: _Word) (u1 :: _Word) -> case u0 of { _ALG_ W# (u2 :: Word#) -> case u1 of { _ALG_ W# (u3 :: Word#) -> _#_ geWord# [] [u2, u3]; _NO_DEFLT_ }; _NO_DEFLT_ } _N_ },
+ (>) = { _A_ 2 _U_ 11 _N_ _S_ "U(P)U(P)" {_A_ 2 _U_ 22 _N_ _N_ _F_ _IF_ARGS_ 0 2 XX 1 \ (u0 :: Word#) (u1 :: Word#) -> _#_ gtWord# [] [u0, u1] _N_} _F_ _IF_ARGS_ 0 2 CC 3 \ (u0 :: _Word) (u1 :: _Word) -> case u0 of { _ALG_ W# (u2 :: Word#) -> case u1 of { _ALG_ W# (u3 :: Word#) -> _#_ gtWord# [] [u2, u3]; _NO_DEFLT_ }; _NO_DEFLT_ } _N_ },
+ max = { _A_ 2 _U_ 11 _N_ _S_ "U(P)U(P)" {_A_ 2 _U_ 22 _N_ _N_ _N_ _N_} _N_ _N_ },
+ min = { _A_ 2 _U_ 11 _N_ _S_ "U(P)U(P)" {_A_ 2 _U_ 22 _N_ _N_ _N_ _N_} _N_ _N_ },
+ _tagCmp = { _A_ 2 _U_ 11 _N_ _S_ "U(P)U(P)" {_A_ 2 _U_ 22 _N_ _N_ _N_ _N_} _N_ _N_ } #-}
instance Real Int
{-# GHC_PRAGMA _M_ PreludeCore {-dfun-} _A_ 0 _N_ _N_ _N_ _F_ _IF_ARGS_ 0 0 X 4 _!_ _TUP_3 [{{Num Int}}, {{Enum Int}}, (Int -> Ratio Integer)] [_DFUN_ Num (Int), _DFUN_ Enum (Int), _CONSTM_ Real toRational (Int)] _N_
- toRational = _A_ 1 _U_ 1 _N_ _N_ _N_ _N_ #-}
+ toRational = { _A_ 1 _U_ 1 _N_ _N_ _N_ _N_ } #-}
instance Text Int
{-# GHC_PRAGMA _M_ PreludeCore {-dfun-} _A_ 0 _N_ _N_ _N_ _F_ _IF_ARGS_ 0 0 X 5 _!_ _TUP_4 [(Int -> [Char] -> [(Int, [Char])]), (Int -> Int -> [Char] -> [Char]), ([Char] -> [([Int], [Char])]), ([Int] -> [Char] -> [Char])] [_CONSTM_ Text readsPrec (Int), _CONSTM_ Text showsPrec (Int), _CONSTM_ Text readList (Int), _CONSTM_ Text showList (Int)] _N_
- readsPrec = _A_ 2 _U_ 02 _N_ _S_ "AL" {_A_ 1 _U_ 2 _N_ _N_ _F_ _IF_ARGS_ 0 1 X 3 \ (u0 :: [Char]) -> _APP_ _SPEC_ _ORIG_ PreludeText readSigned [ (Int) ] [ _SPEC_ _ORIG_ PreludeText readDec [ (Int) ], u0 ] _N_} _F_ _IF_ARGS_ 0 2 XX 3 \ (u0 :: Int) (u1 :: [Char]) -> _APP_ _SPEC_ _ORIG_ PreludeText readSigned [ (Int) ] [ _SPEC_ _ORIG_ PreludeText readDec [ (Int) ], u1 ] _N_,
- showsPrec = _A_ 3 _U_ 212 _N_ _S_ "LU(P)L" {_A_ 3 _U_ 222 _N_ _N_ _N_ _N_} _N_ _N_,
- readList = _A_ 0 _U_ 2 _N_ _N_ _N_ _N_,
- showList = _A_ 0 _U_ 12 _N_ _N_ _N_ _N_ #-}
+ readsPrec = { _A_ 2 _U_ 02 _N_ _S_ "AL" {_A_ 1 _U_ 2 _N_ _N_ _F_ _IF_ARGS_ 0 1 X 3 \ (u0 :: [Char]) -> _APP_ _SPEC_ _ORIG_ PreludeText readSigned [ (Int) ] [ _SPEC_ _ORIG_ PreludeText readDec [ (Int) ], u0 ] _N_} _F_ _IF_ARGS_ 0 2 XX 3 \ (u0 :: Int) (u1 :: [Char]) -> _APP_ _SPEC_ _ORIG_ PreludeText readSigned [ (Int) ] [ _SPEC_ _ORIG_ PreludeText readDec [ (Int) ], u1 ] _N_ },
+ showsPrec = { _A_ 3 _U_ 212 _N_ _S_ "LU(P)L" {_A_ 3 _U_ 222 _N_ _N_ _N_ _N_} _N_ _N_ },
+ readList = { _A_ 0 _U_ 2 _N_ _N_ _N_ _N_ },
+ showList = { _A_ 1 _U_ 12 _N_ _N_ _N_ _N_ } #-}
instance _CCallable Int
{-# GHC_PRAGMA _M_ PreludeCore {-dfun-} _A_ 0 _N_ _N_ _N_ _F_ _IF_ARGS_ 0 0 X 1 _!_ _TUP_0 [] [] _N_ #-}
instance _CCallable _Addr
{-# GHC_PRAGMA _M_ PreludeCore {-dfun-} _A_ 0 _N_ _N_ _N_ _F_ _IF_ARGS_ 0 0 X 1 _!_ _TUP_0 [] [] _N_ #-}
instance _CCallable _MallocPtr
{-# GHC_PRAGMA _M_ PreludeCore {-dfun-} _A_ 0 _N_ _N_ _N_ _F_ _IF_ARGS_ 0 0 X 1 _!_ _TUP_0 [] [] _N_ #-}
+instance _CCallable (_StablePtr a)
+ {-# GHC_PRAGMA _M_ PreludeCore {-dfun-} _A_ 0 _N_ _N_ _N_ _F_ _IF_ARGS_ 1 0 X 1 _/\_ u0 -> _!_ _TUP_0 [] [] _N_ #-}
instance _CCallable _Word
{-# GHC_PRAGMA _M_ PreludeCore {-dfun-} _A_ 0 _N_ _N_ _N_ _F_ _IF_ARGS_ 0 0 X 1 _!_ _TUP_0 [] [] _N_ #-}
instance _CReturnable ()
{-# GHC_PRAGMA _M_ PreludeCore {-dfun-} _A_ 0 _N_ _N_ _N_ _F_ _IF_ARGS_ 0 0 X 1 _!_ _TUP_0 [] [] _N_ #-}
instance _CReturnable _MallocPtr
{-# GHC_PRAGMA _M_ PreludeCore {-dfun-} _A_ 0 _N_ _N_ _N_ _F_ _IF_ARGS_ 0 0 X 1 _!_ _TUP_0 [] [] _N_ #-}
+instance _CReturnable (_StablePtr a)
+ {-# GHC_PRAGMA _M_ PreludeCore {-dfun-} _A_ 0 _N_ _N_ _N_ _F_ _IF_ARGS_ 1 0 X 1 _/\_ u0 -> _!_ _TUP_0 [] [] _N_ #-}
instance _CReturnable _Word
{-# GHC_PRAGMA _M_ PreludeCore {-dfun-} _A_ 0 _N_ _N_ _N_ _F_ _IF_ARGS_ 0 0 X 1 _!_ _TUP_0 [] [] _N_ #-}
-{-# GHC_PRAGMA INTERFACE VERSION 5 #-}
+{-# GHC_PRAGMA INTERFACE VERSION 6 #-}
interface PreludeCore where
import PreludeBuiltin(Int(..), Tuple0, _Addr(..), _Word(..))
import PreludeGlaMisc(_MallocPtr(..), _StablePtr(..))
{-# GHC_PRAGMA _A_ 3 _U_ 222 _N_ _S_ _!_ _N_ _N_ #-}
instance Enum Int
{-# GHC_PRAGMA _M_ PreludeCore {-dfun-} _A_ 0 _N_ _N_ _N_ _F_ _IF_ARGS_ 0 0 X 6 _!_ _TUP_5 [{{Ord Int}}, (Int -> [Int]), (Int -> Int -> [Int]), (Int -> Int -> [Int]), (Int -> Int -> Int -> [Int])] [_DFUN_ Ord (Int), _CONSTM_ Enum enumFrom (Int), _CONSTM_ Enum enumFromThen (Int), _CONSTM_ Enum enumFromTo (Int), _CONSTM_ Enum enumFromThenTo (Int)] _N_
- enumFrom = _A_ 1 _U_ 2 _N_ _N_ _F_ _ALWAYS_ \ (u0 :: Int) -> _LETREC_ {(u1 :: Int -> [Int]) = \ (u2 :: Int) -> let {(u6 :: [Int]) = let {(u5 :: Int) = case u2 of { _ALG_ I# (u3 :: Int#) -> case _#_ plusInt# [] [u3, 1#] of { _PRIM_ (u4 :: Int#) -> _!_ I# [] [u4] }; _NO_DEFLT_ }} in _APP_ u1 [ u5 ]} in _!_ (:) [Int] [u2, u6]} in _APP_ u1 [ u0 ] _N_,
- enumFromThen = _A_ 2 _U_ 21 _N_ _N_ _N_ _N_,
- enumFromTo = _A_ 2 _U_ 12 _N_ _S_ "SS" _F_ _ALWAYS_ \ (u0 :: Int) (u1 :: Int) -> case u0 of { _ALG_ I# (u2 :: Int#) -> _LETREC_ {(u3 :: Int# -> [Int]) = \ (u4 :: Int#) -> case u1 of { _ALG_ I# (u5 :: Int#) -> case _#_ leInt# [] [u4, u5] of { _ALG_ True -> let {(u7 :: [Int]) = case _#_ plusInt# [] [u4, 1#] of { _PRIM_ (u6 :: Int#) -> _APP_ u3 [ u6 ] }} in let {(u8 :: Int) = _!_ I# [] [u4]} in _!_ (:) [Int] [u8, u7]; False -> _!_ _NIL_ [Int] []; _NO_DEFLT_ }; _NO_DEFLT_ }} in _APP_ u3 [ u2 ]; _NO_DEFLT_ } _N_,
- enumFromThenTo = _A_ 3 _U_ 222 _N_ _N_ _N_ _N_ #-}
+ enumFrom = { _A_ 1 _U_ 2 _N_ _N_ _F_ _ALWAYS_ \ (u0 :: Int) -> _LETREC_ {(u1 :: Int -> [Int]) = \ (u2 :: Int) -> let {(u6 :: [Int]) = let {(u5 :: Int) = case u2 of { _ALG_ I# (u3 :: Int#) -> case _#_ plusInt# [] [u3, 1#] of { _PRIM_ (u4 :: Int#) -> _!_ I# [] [u4] }; _NO_DEFLT_ }} in _APP_ u1 [ u5 ]} in _!_ (:) [Int] [u2, u6]} in _APP_ u1 [ u0 ] _N_ },
+ enumFromThen = { _A_ 2 _U_ 21 _N_ _N_ _N_ _N_ },
+ enumFromTo = { _A_ 2 _U_ 12 _N_ _S_ "SS" _F_ _ALWAYS_ \ (u0 :: Int) (u1 :: Int) -> case u0 of { _ALG_ I# (u2 :: Int#) -> _LETREC_ {(u3 :: Int# -> [Int]) = \ (u4 :: Int#) -> case u1 of { _ALG_ I# (u5 :: Int#) -> case _#_ leInt# [] [u4, u5] of { _ALG_ True -> let {(u7 :: [Int]) = case _#_ plusInt# [] [u4, 1#] of { _PRIM_ (u6 :: Int#) -> _APP_ u3 [ u6 ] }} in let {(u8 :: Int) = _!_ I# [] [u4]} in _!_ (:) [Int] [u8, u7]; False -> _!_ _NIL_ [Int] []; _NO_DEFLT_ }; _NO_DEFLT_ }} in _APP_ u3 [ u2 ]; _NO_DEFLT_ } _N_ },
+ enumFromThenTo = { _A_ 3 _U_ 222 _N_ _N_ _N_ _N_ } #-}
instance Eq Int
{-# GHC_PRAGMA _M_ PreludeCore {-dfun-} _A_ 0 _N_ _N_ _N_ _F_ _IF_ARGS_ 0 0 X 3 _!_ _TUP_2 [(Int -> Int -> Bool), (Int -> Int -> Bool)] [_CONSTM_ Eq (==) (Int), _CONSTM_ Eq (/=) (Int)] _N_
- (==) = _A_ 2 _U_ 11 _N_ _S_ "U(P)U(P)" {_A_ 2 _U_ 22 _N_ _N_ _F_ _IF_ARGS_ 0 2 XX 1 \ (u0 :: Int#) (u1 :: Int#) -> _#_ eqInt# [] [u0, u1] _N_} _F_ _IF_ARGS_ 0 2 CC 3 \ (u0 :: Int) (u1 :: Int) -> case u0 of { _ALG_ I# (u2 :: Int#) -> case u1 of { _ALG_ I# (u3 :: Int#) -> _#_ eqInt# [] [u2, u3]; _NO_DEFLT_ }; _NO_DEFLT_ } _N_,
- (/=) = _A_ 2 _U_ 11 _N_ _S_ "U(P)U(P)" {_A_ 2 _U_ 22 _N_ _N_ _F_ _IF_ARGS_ 0 2 XX 1 \ (u0 :: Int#) (u1 :: Int#) -> _#_ neInt# [] [u0, u1] _N_} _F_ _IF_ARGS_ 0 2 CC 3 \ (u0 :: Int) (u1 :: Int) -> case u0 of { _ALG_ I# (u2 :: Int#) -> case u1 of { _ALG_ I# (u3 :: Int#) -> _#_ neInt# [] [u2, u3]; _NO_DEFLT_ }; _NO_DEFLT_ } _N_ #-}
+ (==) = { _A_ 2 _U_ 11 _N_ _S_ "U(P)U(P)" {_A_ 2 _U_ 22 _N_ _N_ _F_ _IF_ARGS_ 0 2 XX 1 \ (u0 :: Int#) (u1 :: Int#) -> _#_ eqInt# [] [u0, u1] _N_} _F_ _IF_ARGS_ 0 2 CC 3 \ (u0 :: Int) (u1 :: Int) -> case u0 of { _ALG_ I# (u2 :: Int#) -> case u1 of { _ALG_ I# (u3 :: Int#) -> _#_ eqInt# [] [u2, u3]; _NO_DEFLT_ }; _NO_DEFLT_ } _N_ },
+ (/=) = { _A_ 2 _U_ 11 _N_ _S_ "U(P)U(P)" {_A_ 2 _U_ 22 _N_ _N_ _F_ _IF_ARGS_ 0 2 XX 1 \ (u0 :: Int#) (u1 :: Int#) -> _#_ neInt# [] [u0, u1] _N_} _F_ _IF_ARGS_ 0 2 CC 3 \ (u0 :: Int) (u1 :: Int) -> case u0 of { _ALG_ I# (u2 :: Int#) -> case u1 of { _ALG_ I# (u3 :: Int#) -> _#_ neInt# [] [u2, u3]; _NO_DEFLT_ }; _NO_DEFLT_ } _N_ } #-}
instance Eq _Addr
{-# GHC_PRAGMA _M_ PreludeCore {-dfun-} _A_ 0 _N_ _N_ _N_ _F_ _IF_ARGS_ 0 0 X 3 _!_ _TUP_2 [(_Addr -> _Addr -> Bool), (_Addr -> _Addr -> Bool)] [_CONSTM_ Eq (==) (_Addr), _CONSTM_ Eq (/=) (_Addr)] _N_
- (==) = _A_ 2 _U_ 11 _N_ _S_ "U(P)U(P)" {_A_ 2 _U_ 22 _N_ _N_ _F_ _IF_ARGS_ 0 2 XX 1 \ (u0 :: Addr#) (u1 :: Addr#) -> _#_ eqAddr# [] [u0, u1] _N_} _F_ _IF_ARGS_ 0 2 CC 3 \ (u0 :: _Addr) (u1 :: _Addr) -> case u0 of { _ALG_ A# (u2 :: Addr#) -> case u1 of { _ALG_ A# (u3 :: Addr#) -> _#_ eqAddr# [] [u2, u3]; _NO_DEFLT_ }; _NO_DEFLT_ } _N_,
- (/=) = _A_ 2 _U_ 11 _N_ _S_ "U(P)U(P)" {_A_ 2 _U_ 22 _N_ _N_ _F_ _IF_ARGS_ 0 2 XX 1 \ (u0 :: Addr#) (u1 :: Addr#) -> _#_ neAddr# [] [u0, u1] _N_} _F_ _IF_ARGS_ 0 2 CC 3 \ (u0 :: _Addr) (u1 :: _Addr) -> case u0 of { _ALG_ A# (u2 :: Addr#) -> case u1 of { _ALG_ A# (u3 :: Addr#) -> _#_ neAddr# [] [u2, u3]; _NO_DEFLT_ }; _NO_DEFLT_ } _N_ #-}
+ (==) = { _A_ 2 _U_ 11 _N_ _S_ "U(P)U(P)" {_A_ 2 _U_ 22 _N_ _N_ _F_ _IF_ARGS_ 0 2 XX 1 \ (u0 :: Addr#) (u1 :: Addr#) -> _#_ eqAddr# [] [u0, u1] _N_} _F_ _IF_ARGS_ 0 2 CC 3 \ (u0 :: _Addr) (u1 :: _Addr) -> case u0 of { _ALG_ A# (u2 :: Addr#) -> case u1 of { _ALG_ A# (u3 :: Addr#) -> _#_ eqAddr# [] [u2, u3]; _NO_DEFLT_ }; _NO_DEFLT_ } _N_ },
+ (/=) = { _A_ 2 _U_ 11 _N_ _S_ "U(P)U(P)" {_A_ 2 _U_ 22 _N_ _N_ _F_ _IF_ARGS_ 0 2 XX 1 \ (u0 :: Addr#) (u1 :: Addr#) -> _#_ neAddr# [] [u0, u1] _N_} _F_ _IF_ARGS_ 0 2 CC 3 \ (u0 :: _Addr) (u1 :: _Addr) -> case u0 of { _ALG_ A# (u2 :: Addr#) -> case u1 of { _ALG_ A# (u3 :: Addr#) -> _#_ neAddr# [] [u2, u3]; _NO_DEFLT_ }; _NO_DEFLT_ } _N_ } #-}
instance Eq _Word
{-# GHC_PRAGMA _M_ PreludeCore {-dfun-} _A_ 0 _N_ _N_ _N_ _F_ _IF_ARGS_ 0 0 X 3 _!_ _TUP_2 [(_Word -> _Word -> Bool), (_Word -> _Word -> Bool)] [_CONSTM_ Eq (==) (_Word), _CONSTM_ Eq (/=) (_Word)] _N_
- (==) = _A_ 2 _U_ 11 _N_ _S_ "U(P)U(P)" {_A_ 2 _U_ 22 _N_ _N_ _F_ _IF_ARGS_ 0 2 XX 1 \ (u0 :: Word#) (u1 :: Word#) -> _#_ eqWord# [] [u0, u1] _N_} _F_ _IF_ARGS_ 0 2 CC 3 \ (u0 :: _Word) (u1 :: _Word) -> case u0 of { _ALG_ W# (u2 :: Word#) -> case u1 of { _ALG_ W# (u3 :: Word#) -> _#_ eqWord# [] [u2, u3]; _NO_DEFLT_ }; _NO_DEFLT_ } _N_,
- (/=) = _A_ 2 _U_ 11 _N_ _S_ "U(P)U(P)" {_A_ 2 _U_ 22 _N_ _N_ _F_ _IF_ARGS_ 0 2 XX 1 \ (u0 :: Word#) (u1 :: Word#) -> _#_ neWord# [] [u0, u1] _N_} _F_ _IF_ARGS_ 0 2 CC 3 \ (u0 :: _Word) (u1 :: _Word) -> case u0 of { _ALG_ W# (u2 :: Word#) -> case u1 of { _ALG_ W# (u3 :: Word#) -> _#_ neWord# [] [u2, u3]; _NO_DEFLT_ }; _NO_DEFLT_ } _N_ #-}
+ (==) = { _A_ 2 _U_ 11 _N_ _S_ "U(P)U(P)" {_A_ 2 _U_ 22 _N_ _N_ _F_ _IF_ARGS_ 0 2 XX 1 \ (u0 :: Word#) (u1 :: Word#) -> _#_ eqWord# [] [u0, u1] _N_} _F_ _IF_ARGS_ 0 2 CC 3 \ (u0 :: _Word) (u1 :: _Word) -> case u0 of { _ALG_ W# (u2 :: Word#) -> case u1 of { _ALG_ W# (u3 :: Word#) -> _#_ eqWord# [] [u2, u3]; _NO_DEFLT_ }; _NO_DEFLT_ } _N_ },
+ (/=) = { _A_ 2 _U_ 11 _N_ _S_ "U(P)U(P)" {_A_ 2 _U_ 22 _N_ _N_ _F_ _IF_ARGS_ 0 2 XX 1 \ (u0 :: Word#) (u1 :: Word#) -> _#_ neWord# [] [u0, u1] _N_} _F_ _IF_ARGS_ 0 2 CC 3 \ (u0 :: _Word) (u1 :: _Word) -> case u0 of { _ALG_ W# (u2 :: Word#) -> case u1 of { _ALG_ W# (u3 :: Word#) -> _#_ neWord# [] [u2, u3]; _NO_DEFLT_ }; _NO_DEFLT_ } _N_ } #-}
instance Integral Int
{-# GHC_PRAGMA _M_ PreludeCore {-dfun-} _A_ 0 _N_ _N_ _N_ _F_ _IF_ARGS_ 0 0 X 13 _!_ _TUP_12 [{{Real Int}}, {{Ix Int}}, (Int -> Int -> Int), (Int -> Int -> Int), (Int -> Int -> Int), (Int -> Int -> Int), (Int -> Int -> (Int, Int)), (Int -> Int -> (Int, Int)), (Int -> Bool), (Int -> Bool), (Int -> Integer), (Int -> Int)] [_DFUN_ Real (Int), _DFUN_ Ix (Int), _CONSTM_ Integral quot (Int), _CONSTM_ Integral rem (Int), _CONSTM_ Integral div (Int), _CONSTM_ Integral mod (Int), _CONSTM_ Integral quotRem (Int), _CONSTM_ Integral divMod (Int), _CONSTM_ Integral even (Int), _CONSTM_ Integral odd (Int), _CONSTM_ Integral toInteger (Int), _CONSTM_ Integral toInt (Int)] _N_
- quot = _A_ 2 _U_ 11 _N_ _S_ "U(P)U(P)" {_A_ 2 _U_ 22 _N_ _N_ _F_ _IF_ARGS_ 0 2 XC 5 \ (u0 :: Int#) (u1 :: Int#) -> case u1 of { _PRIM_ 0# -> _APP_ _TYAPP_ error { Int } [ _NOREP_S_ "Integral.Int.quot{PreludeCore}: divide by 0\n" ]; (u2 :: Int#) -> case _#_ quotInt# [] [u0, u1] of { _PRIM_ (u3 :: Int#) -> _!_ I# [] [u3] } } _N_} _F_ _IF_ARGS_ 0 2 CC 7 \ (u0 :: Int) (u1 :: Int) -> case u1 of { _ALG_ I# (u2 :: Int#) -> case u2 of { _PRIM_ 0# -> _APP_ _TYAPP_ error { Int } [ _NOREP_S_ "Integral.Int.quot{PreludeCore}: divide by 0\n" ]; (u3 :: Int#) -> case u0 of { _ALG_ I# (u4 :: Int#) -> case _#_ quotInt# [] [u4, u2] of { _PRIM_ (u5 :: Int#) -> _!_ I# [] [u5] }; _NO_DEFLT_ } }; _NO_DEFLT_ } _N_,
- rem = _A_ 2 _U_ 11 _N_ _S_ "U(P)U(P)" {_A_ 2 _U_ 22 _N_ _N_ _F_ _IF_ARGS_ 0 2 XC 5 \ (u0 :: Int#) (u1 :: Int#) -> case u1 of { _PRIM_ 0# -> _APP_ _TYAPP_ error { Int } [ _NOREP_S_ "Integral.Int.rem{PreludeCore}: divide by 0\n" ]; (u2 :: Int#) -> case _#_ remInt# [] [u0, u1] of { _PRIM_ (u3 :: Int#) -> _!_ I# [] [u3] } } _N_} _F_ _IF_ARGS_ 0 2 CC 7 \ (u0 :: Int) (u1 :: Int) -> case u1 of { _ALG_ I# (u2 :: Int#) -> case u2 of { _PRIM_ 0# -> _APP_ _TYAPP_ error { Int } [ _NOREP_S_ "Integral.Int.rem{PreludeCore}: divide by 0\n" ]; (u3 :: Int#) -> case u0 of { _ALG_ I# (u4 :: Int#) -> case _#_ remInt# [] [u4, u2] of { _PRIM_ (u5 :: Int#) -> _!_ I# [] [u5] }; _NO_DEFLT_ } }; _NO_DEFLT_ } _N_,
- div = _A_ 2 _U_ 11 _N_ _S_ "U(P)U(P)" {_A_ 2 _U_ 22 _N_ _N_ _N_ _N_} _N_ _N_,
- mod = _A_ 2 _U_ 11 _N_ _S_ "U(P)U(P)" {_A_ 2 _U_ 22 _N_ _N_ _N_ _N_} _N_ _N_,
- quotRem = _A_ 2 _U_ 11 _N_ _S_ "U(P)U(P)" {_A_ 2 _U_ 22 _N_ _N_ _N_ _N_} _N_ _N_,
- divMod = _A_ 2 _U_ 11 _N_ _S_ "U(P)U(P)" {_A_ 2 _U_ 22 _N_ _N_ _N_ _N_} _N_ _N_,
- even = _A_ 1 _U_ 1 _N_ _S_ "U(P)" {_A_ 1 _U_ 2 _N_ _N_ _N_ _N_} _N_ _N_,
- odd = _A_ 1 _U_ 1 _N_ _S_ "U(P)" {_A_ 1 _U_ 2 _N_ _N_ _N_ _N_} _N_ _N_,
- toInteger = _A_ 1 _U_ 1 _N_ _S_ "U(P)" {_A_ 1 _U_ 2 _N_ _N_ _F_ _IF_ARGS_ 0 1 X 1 \ (u0 :: Int#) -> _#_ int2Integer# [] [u0] _N_} _F_ _IF_ARGS_ 0 1 C 2 \ (u0 :: Int) -> case u0 of { _ALG_ I# (u1 :: Int#) -> _#_ int2Integer# [] [u1]; _NO_DEFLT_ } _N_,
- toInt = _A_ 1 _U_ 1 _N_ _S_ "U(P)" {_A_ 1 _U_ 2 _N_ _N_ _F_ _IF_ARGS_ 0 1 X 2 \ (u0 :: Int#) -> _!_ I# [] [u0] _N_} _F_ _IF_ARGS_ 0 1 X 1 \ (u0 :: Int) -> u0 _N_ #-}
+ quot = { _A_ 2 _U_ 11 _N_ _S_ "U(P)U(P)" {_A_ 2 _U_ 22 _N_ _N_ _F_ _IF_ARGS_ 0 2 XC 5 \ (u0 :: Int#) (u1 :: Int#) -> case u1 of { _PRIM_ 0# -> _APP_ _TYAPP_ error { Int } [ _NOREP_S_ "Integral.Int.quot{PreludeCore}: divide by 0\n" ]; (u2 :: Int#) -> case _#_ quotInt# [] [u0, u1] of { _PRIM_ (u3 :: Int#) -> _!_ I# [] [u3] } } _N_} _F_ _IF_ARGS_ 0 2 CC 7 \ (u0 :: Int) (u1 :: Int) -> case u1 of { _ALG_ I# (u2 :: Int#) -> case u2 of { _PRIM_ 0# -> _APP_ _TYAPP_ error { Int } [ _NOREP_S_ "Integral.Int.quot{PreludeCore}: divide by 0\n" ]; (u3 :: Int#) -> case u0 of { _ALG_ I# (u4 :: Int#) -> case _#_ quotInt# [] [u4, u2] of { _PRIM_ (u5 :: Int#) -> _!_ I# [] [u5] }; _NO_DEFLT_ } }; _NO_DEFLT_ } _N_ },
+ rem = { _A_ 2 _U_ 11 _N_ _S_ "U(P)U(P)" {_A_ 2 _U_ 22 _N_ _N_ _F_ _IF_ARGS_ 0 2 XC 5 \ (u0 :: Int#) (u1 :: Int#) -> case u1 of { _PRIM_ 0# -> _APP_ _TYAPP_ error { Int } [ _NOREP_S_ "Integral.Int.rem{PreludeCore}: divide by 0\n" ]; (u2 :: Int#) -> case _#_ remInt# [] [u0, u1] of { _PRIM_ (u3 :: Int#) -> _!_ I# [] [u3] } } _N_} _F_ _IF_ARGS_ 0 2 CC 7 \ (u0 :: Int) (u1 :: Int) -> case u1 of { _ALG_ I# (u2 :: Int#) -> case u2 of { _PRIM_ 0# -> _APP_ _TYAPP_ error { Int } [ _NOREP_S_ "Integral.Int.rem{PreludeCore}: divide by 0\n" ]; (u3 :: Int#) -> case u0 of { _ALG_ I# (u4 :: Int#) -> case _#_ remInt# [] [u4, u2] of { _PRIM_ (u5 :: Int#) -> _!_ I# [] [u5] }; _NO_DEFLT_ } }; _NO_DEFLT_ } _N_ },
+ div = { _A_ 2 _U_ 11 _N_ _S_ "U(P)U(P)" {_A_ 2 _U_ 22 _N_ _N_ _N_ _N_} _N_ _N_ },
+ mod = { _A_ 2 _U_ 11 _N_ _S_ "U(P)U(P)" {_A_ 2 _U_ 22 _N_ _N_ _N_ _N_} _N_ _N_ },
+ quotRem = { _A_ 2 _U_ 11 _N_ _S_ "U(P)U(P)" {_A_ 2 _U_ 22 _N_ _N_ _N_ _N_} _N_ _N_ },
+ divMod = { _A_ 2 _U_ 11 _N_ _S_ "U(P)U(P)" {_A_ 2 _U_ 22 _N_ _N_ _N_ _N_} _N_ _N_ },
+ even = { _A_ 1 _U_ 1 _N_ _S_ "U(P)" {_A_ 1 _U_ 2 _N_ _N_ _N_ _N_} _N_ _N_ },
+ odd = { _A_ 1 _U_ 1 _N_ _S_ "U(P)" {_A_ 1 _U_ 2 _N_ _N_ _N_ _N_} _N_ _N_ },
+ toInteger = { _A_ 1 _U_ 1 _N_ _S_ "U(P)" {_A_ 1 _U_ 2 _N_ _N_ _F_ _IF_ARGS_ 0 1 X 1 \ (u0 :: Int#) -> _#_ int2Integer# [] [u0] _N_} _F_ _IF_ARGS_ 0 1 C 2 \ (u0 :: Int) -> case u0 of { _ALG_ I# (u1 :: Int#) -> _#_ int2Integer# [] [u1]; _NO_DEFLT_ } _N_ },
+ toInt = { _A_ 1 _U_ 1 _N_ _S_ "U(P)" {_A_ 1 _U_ 2 _N_ _N_ _F_ _IF_ARGS_ 0 1 X 2 \ (u0 :: Int#) -> _!_ I# [] [u0] _N_} _F_ _IF_ARGS_ 0 1 X 1 \ (u0 :: Int) -> u0 _N_ } #-}
instance Ix Int
{-# GHC_PRAGMA _M_ PreludeCore {-dfun-} _A_ 0 _N_ _N_ _N_ _F_ _IF_ARGS_ 0 0 X 5 _!_ _TUP_4 [{{Ord Int}}, ((Int, Int) -> [Int]), ((Int, Int) -> Int -> Int), ((Int, Int) -> Int -> Bool)] [_DFUN_ Ord (Int), _CONSTM_ Ix range (Int), _CONSTM_ Ix index (Int), _CONSTM_ Ix inRange (Int)] _N_
- range = _A_ 1 _U_ 1 _N_ _S_ "U(U(P)U(P))" {_A_ 2 _U_ 22 _N_ _N_ _N_ _N_} _N_ _N_,
- index = _A_ 2 _U_ 11 _N_ _S_ "U(U(P)U(P))U(P)" {_A_ 3 _U_ 222 _N_ _N_ _N_ _N_} _N_ _N_,
- inRange = _A_ 2 _U_ 11 _N_ _S_ "U(U(P)U(P))U(P)" {_A_ 3 _U_ 222 _N_ _N_ _F_ _IF_ARGS_ 0 3 XXX 5 \ (u0 :: Int#) (u1 :: Int#) (u2 :: Int#) -> case _#_ leInt# [] [u0, u2] of { _ALG_ True -> _#_ leInt# [] [u2, u1]; False -> _!_ False [] []; _NO_DEFLT_ } _N_} _F_ _ALWAYS_ \ (u0 :: (Int, Int)) (u1 :: Int) -> case u0 of { _ALG_ _TUP_2 (u2 :: Int) (u3 :: Int) -> case u2 of { _ALG_ I# (u4 :: Int#) -> case u3 of { _ALG_ I# (u5 :: Int#) -> case u1 of { _ALG_ I# (u6 :: Int#) -> case _#_ leInt# [] [u4, u6] of { _ALG_ True -> _#_ leInt# [] [u6, u5]; False -> _!_ False [] []; _NO_DEFLT_ }; _NO_DEFLT_ }; _NO_DEFLT_ }; _NO_DEFLT_ }; _NO_DEFLT_ } _N_ #-}
+ range = { _A_ 1 _U_ 1 _N_ _S_ "U(U(P)U(P))" {_A_ 2 _U_ 22 _N_ _N_ _N_ _N_} _N_ _N_ },
+ index = { _A_ 2 _U_ 11 _N_ _S_ "U(U(P)U(P))U(P)" {_A_ 3 _U_ 222 _N_ _N_ _N_ _N_} _N_ _N_ },
+ inRange = { _A_ 2 _U_ 11 _N_ _S_ "U(U(P)U(P))U(P)" {_A_ 3 _U_ 222 _N_ _N_ _F_ _IF_ARGS_ 0 3 XXX 5 \ (u0 :: Int#) (u1 :: Int#) (u2 :: Int#) -> case _#_ leInt# [] [u0, u2] of { _ALG_ True -> _#_ leInt# [] [u2, u1]; False -> _!_ False [] []; _NO_DEFLT_ } _N_} _F_ _ALWAYS_ \ (u0 :: (Int, Int)) (u1 :: Int) -> case u0 of { _ALG_ _TUP_2 (u2 :: Int) (u3 :: Int) -> case u2 of { _ALG_ I# (u4 :: Int#) -> case u3 of { _ALG_ I# (u5 :: Int#) -> case u1 of { _ALG_ I# (u6 :: Int#) -> case _#_ leInt# [] [u4, u6] of { _ALG_ True -> _#_ leInt# [] [u6, u5]; False -> _!_ False [] []; _NO_DEFLT_ }; _NO_DEFLT_ }; _NO_DEFLT_ }; _NO_DEFLT_ }; _NO_DEFLT_ } _N_ } #-}
instance Num Int
{-# GHC_PRAGMA _M_ PreludeCore {-dfun-} _A_ 0 _N_ _N_ _N_ _F_ _IF_ARGS_ 0 0 X 11 _!_ _TUP_10 [{{Eq Int}}, {{Text Int}}, (Int -> Int -> Int), (Int -> Int -> Int), (Int -> Int -> Int), (Int -> Int), (Int -> Int), (Int -> Int), (Integer -> Int), (Int -> Int)] [_DFUN_ Eq (Int), _DFUN_ Text (Int), _CONSTM_ Num (+) (Int), _CONSTM_ Num (-) (Int), _CONSTM_ Num (*) (Int), _CONSTM_ Num negate (Int), _CONSTM_ Num abs (Int), _CONSTM_ Num signum (Int), _CONSTM_ Num fromInteger (Int), _CONSTM_ Num fromInt (Int)] _N_
- (+) = _A_ 2 _U_ 11 _N_ _S_ "U(P)U(P)" {_A_ 2 _U_ 22 _N_ _N_ _F_ _IF_ARGS_ 0 2 XX 3 \ (u0 :: Int#) (u1 :: Int#) -> case _#_ plusInt# [] [u0, u1] of { _PRIM_ (u2 :: Int#) -> _!_ I# [] [u2] } _N_} _F_ _IF_ARGS_ 0 2 CC 5 \ (u0 :: Int) (u1 :: Int) -> case u0 of { _ALG_ I# (u2 :: Int#) -> case u1 of { _ALG_ I# (u3 :: Int#) -> case _#_ plusInt# [] [u2, u3] of { _PRIM_ (u4 :: Int#) -> _!_ I# [] [u4] }; _NO_DEFLT_ }; _NO_DEFLT_ } _N_,
- (-) = _A_ 2 _U_ 11 _N_ _S_ "U(P)U(P)" {_A_ 2 _U_ 22 _N_ _N_ _F_ _IF_ARGS_ 0 2 XX 3 \ (u0 :: Int#) (u1 :: Int#) -> case _#_ minusInt# [] [u0, u1] of { _PRIM_ (u2 :: Int#) -> _!_ I# [] [u2] } _N_} _F_ _IF_ARGS_ 0 2 CC 5 \ (u0 :: Int) (u1 :: Int) -> case u0 of { _ALG_ I# (u2 :: Int#) -> case u1 of { _ALG_ I# (u3 :: Int#) -> case _#_ minusInt# [] [u2, u3] of { _PRIM_ (u4 :: Int#) -> _!_ I# [] [u4] }; _NO_DEFLT_ }; _NO_DEFLT_ } _N_,
- (*) = _A_ 2 _U_ 11 _N_ _S_ "U(P)U(P)" {_A_ 2 _U_ 22 _N_ _N_ _F_ _IF_ARGS_ 0 2 XX 3 \ (u0 :: Int#) (u1 :: Int#) -> case _#_ timesInt# [] [u0, u1] of { _PRIM_ (u2 :: Int#) -> _!_ I# [] [u2] } _N_} _F_ _IF_ARGS_ 0 2 CC 5 \ (u0 :: Int) (u1 :: Int) -> case u0 of { _ALG_ I# (u2 :: Int#) -> case u1 of { _ALG_ I# (u3 :: Int#) -> case _#_ timesInt# [] [u2, u3] of { _PRIM_ (u4 :: Int#) -> _!_ I# [] [u4] }; _NO_DEFLT_ }; _NO_DEFLT_ } _N_,
- negate = _A_ 1 _U_ 1 _N_ _S_ "U(P)" {_A_ 1 _U_ 2 _N_ _N_ _F_ _IF_ARGS_ 0 1 X 3 \ (u0 :: Int#) -> case _#_ negateInt# [] [u0] of { _PRIM_ (u1 :: Int#) -> _!_ I# [] [u1] } _N_} _F_ _IF_ARGS_ 0 1 C 4 \ (u0 :: Int) -> case u0 of { _ALG_ I# (u1 :: Int#) -> case _#_ negateInt# [] [u1] of { _PRIM_ (u2 :: Int#) -> _!_ I# [] [u2] }; _NO_DEFLT_ } _N_,
- abs = _A_ 1 _U_ 1 _N_ _S_ "U(P)" {_A_ 1 _U_ 2 _N_ _N_ _N_ _N_} _N_ _N_,
- signum = _A_ 1 _U_ 1 _N_ _S_ "U(P)" {_A_ 1 _U_ 2 _N_ _N_ _N_ _N_} _N_ _N_,
- fromInteger = _A_ 1 _U_ 1 _N_ _S_ "U(PPP)" {_A_ 3 _U_ 222 _N_ _N_ _F_ _IF_ARGS_ 0 3 XXX 3 \ (u0 :: Int#) (u1 :: Int#) (u2 :: ByteArray#) -> case _#_ integer2Int# [] [u0, u1, u2] of { _PRIM_ (u3 :: Int#) -> _!_ I# [] [u3] } _N_} _F_ _IF_ARGS_ 0 1 C 4 \ (u0 :: Integer) -> case u0 of { _ALG_ J# (u1 :: Int#) (u2 :: Int#) (u3 :: ByteArray#) -> case _#_ integer2Int# [] [u1, u2, u3] of { _PRIM_ (u4 :: Int#) -> _!_ I# [] [u4] }; _NO_DEFLT_ } _N_,
- fromInt = _A_ 1 _U_ 1 _N_ _S_ "U(P)" {_A_ 1 _U_ 2 _N_ _N_ _F_ _IF_ARGS_ 0 1 X 2 \ (u0 :: Int#) -> _!_ I# [] [u0] _N_} _F_ _IF_ARGS_ 0 1 X 1 \ (u0 :: Int) -> u0 _N_ #-}
+ (+) = { _A_ 2 _U_ 11 _N_ _S_ "U(P)U(P)" {_A_ 2 _U_ 22 _N_ _N_ _F_ _IF_ARGS_ 0 2 XX 3 \ (u0 :: Int#) (u1 :: Int#) -> case _#_ plusInt# [] [u0, u1] of { _PRIM_ (u2 :: Int#) -> _!_ I# [] [u2] } _N_} _F_ _IF_ARGS_ 0 2 CC 5 \ (u0 :: Int) (u1 :: Int) -> case u0 of { _ALG_ I# (u2 :: Int#) -> case u1 of { _ALG_ I# (u3 :: Int#) -> case _#_ plusInt# [] [u2, u3] of { _PRIM_ (u4 :: Int#) -> _!_ I# [] [u4] }; _NO_DEFLT_ }; _NO_DEFLT_ } _N_ },
+ (-) = { _A_ 2 _U_ 11 _N_ _S_ "U(P)U(P)" {_A_ 2 _U_ 22 _N_ _N_ _F_ _IF_ARGS_ 0 2 XX 3 \ (u0 :: Int#) (u1 :: Int#) -> case _#_ minusInt# [] [u0, u1] of { _PRIM_ (u2 :: Int#) -> _!_ I# [] [u2] } _N_} _F_ _IF_ARGS_ 0 2 CC 5 \ (u0 :: Int) (u1 :: Int) -> case u0 of { _ALG_ I# (u2 :: Int#) -> case u1 of { _ALG_ I# (u3 :: Int#) -> case _#_ minusInt# [] [u2, u3] of { _PRIM_ (u4 :: Int#) -> _!_ I# [] [u4] }; _NO_DEFLT_ }; _NO_DEFLT_ } _N_ },
+ (*) = { _A_ 2 _U_ 11 _N_ _S_ "U(P)U(P)" {_A_ 2 _U_ 22 _N_ _N_ _F_ _IF_ARGS_ 0 2 XX 3 \ (u0 :: Int#) (u1 :: Int#) -> case _#_ timesInt# [] [u0, u1] of { _PRIM_ (u2 :: Int#) -> _!_ I# [] [u2] } _N_} _F_ _IF_ARGS_ 0 2 CC 5 \ (u0 :: Int) (u1 :: Int) -> case u0 of { _ALG_ I# (u2 :: Int#) -> case u1 of { _ALG_ I# (u3 :: Int#) -> case _#_ timesInt# [] [u2, u3] of { _PRIM_ (u4 :: Int#) -> _!_ I# [] [u4] }; _NO_DEFLT_ }; _NO_DEFLT_ } _N_ },
+ negate = { _A_ 1 _U_ 1 _N_ _S_ "U(P)" {_A_ 1 _U_ 2 _N_ _N_ _F_ _IF_ARGS_ 0 1 X 3 \ (u0 :: Int#) -> case _#_ negateInt# [] [u0] of { _PRIM_ (u1 :: Int#) -> _!_ I# [] [u1] } _N_} _F_ _IF_ARGS_ 0 1 C 4 \ (u0 :: Int) -> case u0 of { _ALG_ I# (u1 :: Int#) -> case _#_ negateInt# [] [u1] of { _PRIM_ (u2 :: Int#) -> _!_ I# [] [u2] }; _NO_DEFLT_ } _N_ },
+ abs = { _A_ 1 _U_ 1 _N_ _S_ "U(P)" {_A_ 1 _U_ 2 _N_ _N_ _N_ _N_} _N_ _N_ },
+ signum = { _A_ 1 _U_ 1 _N_ _S_ "U(P)" {_A_ 1 _U_ 2 _N_ _N_ _N_ _N_} _N_ _N_ },
+ fromInteger = { _A_ 1 _U_ 1 _N_ _S_ "U(PPP)" {_A_ 3 _U_ 222 _N_ _N_ _F_ _IF_ARGS_ 0 3 XXX 3 \ (u0 :: Int#) (u1 :: Int#) (u2 :: ByteArray#) -> case _#_ integer2Int# [] [u0, u1, u2] of { _PRIM_ (u3 :: Int#) -> _!_ I# [] [u3] } _N_} _F_ _IF_ARGS_ 0 1 C 4 \ (u0 :: Integer) -> case u0 of { _ALG_ J# (u1 :: Int#) (u2 :: Int#) (u3 :: ByteArray#) -> case _#_ integer2Int# [] [u1, u2, u3] of { _PRIM_ (u4 :: Int#) -> _!_ I# [] [u4] }; _NO_DEFLT_ } _N_ },
+ fromInt = { _A_ 1 _U_ 1 _N_ _S_ "U(P)" {_A_ 1 _U_ 2 _N_ _N_ _F_ _IF_ARGS_ 0 1 X 2 \ (u0 :: Int#) -> _!_ I# [] [u0] _N_} _F_ _IF_ARGS_ 0 1 X 1 \ (u0 :: Int) -> u0 _N_ } #-}
instance Ord Int
{-# GHC_PRAGMA _M_ PreludeCore {-dfun-} _A_ 0 _N_ _N_ _N_ _F_ _IF_ARGS_ 0 0 X 9 _!_ _TUP_8 [{{Eq Int}}, (Int -> Int -> Bool), (Int -> Int -> Bool), (Int -> Int -> Bool), (Int -> Int -> Bool), (Int -> Int -> Int), (Int -> Int -> Int), (Int -> Int -> _CMP_TAG)] [_DFUN_ Eq (Int), _CONSTM_ Ord (<) (Int), _CONSTM_ Ord (<=) (Int), _CONSTM_ Ord (>=) (Int), _CONSTM_ Ord (>) (Int), _CONSTM_ Ord max (Int), _CONSTM_ Ord min (Int), _CONSTM_ Ord _tagCmp (Int)] _N_
- (<) = _A_ 2 _U_ 11 _N_ _S_ "U(P)U(P)" {_A_ 2 _U_ 22 _N_ _N_ _F_ _IF_ARGS_ 0 2 XX 1 \ (u0 :: Int#) (u1 :: Int#) -> _#_ ltInt# [] [u0, u1] _N_} _F_ _IF_ARGS_ 0 2 CC 3 \ (u0 :: Int) (u1 :: Int) -> case u0 of { _ALG_ I# (u2 :: Int#) -> case u1 of { _ALG_ I# (u3 :: Int#) -> _#_ ltInt# [] [u2, u3]; _NO_DEFLT_ }; _NO_DEFLT_ } _N_,
- (<=) = _A_ 2 _U_ 11 _N_ _S_ "U(P)U(P)" {_A_ 2 _U_ 22 _N_ _N_ _F_ _IF_ARGS_ 0 2 XX 1 \ (u0 :: Int#) (u1 :: Int#) -> _#_ leInt# [] [u0, u1] _N_} _F_ _IF_ARGS_ 0 2 CC 3 \ (u0 :: Int) (u1 :: Int) -> case u0 of { _ALG_ I# (u2 :: Int#) -> case u1 of { _ALG_ I# (u3 :: Int#) -> _#_ leInt# [] [u2, u3]; _NO_DEFLT_ }; _NO_DEFLT_ } _N_,
- (>=) = _A_ 2 _U_ 11 _N_ _S_ "U(P)U(P)" {_A_ 2 _U_ 22 _N_ _N_ _F_ _IF_ARGS_ 0 2 XX 1 \ (u0 :: Int#) (u1 :: Int#) -> _#_ geInt# [] [u0, u1] _N_} _F_ _IF_ARGS_ 0 2 CC 3 \ (u0 :: Int) (u1 :: Int) -> case u0 of { _ALG_ I# (u2 :: Int#) -> case u1 of { _ALG_ I# (u3 :: Int#) -> _#_ geInt# [] [u2, u3]; _NO_DEFLT_ }; _NO_DEFLT_ } _N_,
- (>) = _A_ 2 _U_ 11 _N_ _S_ "U(P)U(P)" {_A_ 2 _U_ 22 _N_ _N_ _F_ _IF_ARGS_ 0 2 XX 1 \ (u0 :: Int#) (u1 :: Int#) -> _#_ gtInt# [] [u0, u1] _N_} _F_ _IF_ARGS_ 0 2 CC 3 \ (u0 :: Int) (u1 :: Int) -> case u0 of { _ALG_ I# (u2 :: Int#) -> case u1 of { _ALG_ I# (u3 :: Int#) -> _#_ gtInt# [] [u2, u3]; _NO_DEFLT_ }; _NO_DEFLT_ } _N_,
- max = _A_ 2 _U_ 11 _N_ _S_ "U(P)U(P)" {_A_ 2 _U_ 22 _N_ _N_ _N_ _N_} _N_ _N_,
- min = _A_ 2 _U_ 11 _N_ _S_ "U(P)U(P)" {_A_ 2 _U_ 22 _N_ _N_ _N_ _N_} _N_ _N_,
- _tagCmp = _A_ 2 _U_ 11 _N_ _S_ "U(P)U(P)" {_A_ 2 _U_ 22 _N_ _N_ _N_ _N_} _N_ _N_ #-}
+ (<) = { _A_ 2 _U_ 11 _N_ _S_ "U(P)U(P)" {_A_ 2 _U_ 22 _N_ _N_ _F_ _IF_ARGS_ 0 2 XX 1 \ (u0 :: Int#) (u1 :: Int#) -> _#_ ltInt# [] [u0, u1] _N_} _F_ _IF_ARGS_ 0 2 CC 3 \ (u0 :: Int) (u1 :: Int) -> case u0 of { _ALG_ I# (u2 :: Int#) -> case u1 of { _ALG_ I# (u3 :: Int#) -> _#_ ltInt# [] [u2, u3]; _NO_DEFLT_ }; _NO_DEFLT_ } _N_ },
+ (<=) = { _A_ 2 _U_ 11 _N_ _S_ "U(P)U(P)" {_A_ 2 _U_ 22 _N_ _N_ _F_ _IF_ARGS_ 0 2 XX 1 \ (u0 :: Int#) (u1 :: Int#) -> _#_ leInt# [] [u0, u1] _N_} _F_ _IF_ARGS_ 0 2 CC 3 \ (u0 :: Int) (u1 :: Int) -> case u0 of { _ALG_ I# (u2 :: Int#) -> case u1 of { _ALG_ I# (u3 :: Int#) -> _#_ leInt# [] [u2, u3]; _NO_DEFLT_ }; _NO_DEFLT_ } _N_ },
+ (>=) = { _A_ 2 _U_ 11 _N_ _S_ "U(P)U(P)" {_A_ 2 _U_ 22 _N_ _N_ _F_ _IF_ARGS_ 0 2 XX 1 \ (u0 :: Int#) (u1 :: Int#) -> _#_ geInt# [] [u0, u1] _N_} _F_ _IF_ARGS_ 0 2 CC 3 \ (u0 :: Int) (u1 :: Int) -> case u0 of { _ALG_ I# (u2 :: Int#) -> case u1 of { _ALG_ I# (u3 :: Int#) -> _#_ geInt# [] [u2, u3]; _NO_DEFLT_ }; _NO_DEFLT_ } _N_ },
+ (>) = { _A_ 2 _U_ 11 _N_ _S_ "U(P)U(P)" {_A_ 2 _U_ 22 _N_ _N_ _F_ _IF_ARGS_ 0 2 XX 1 \ (u0 :: Int#) (u1 :: Int#) -> _#_ gtInt# [] [u0, u1] _N_} _F_ _IF_ARGS_ 0 2 CC 3 \ (u0 :: Int) (u1 :: Int) -> case u0 of { _ALG_ I# (u2 :: Int#) -> case u1 of { _ALG_ I# (u3 :: Int#) -> _#_ gtInt# [] [u2, u3]; _NO_DEFLT_ }; _NO_DEFLT_ } _N_ },
+ max = { _A_ 2 _U_ 11 _N_ _S_ "U(P)U(P)" {_A_ 2 _U_ 22 _N_ _N_ _N_ _N_} _N_ _N_ },
+ min = { _A_ 2 _U_ 11 _N_ _S_ "U(P)U(P)" {_A_ 2 _U_ 22 _N_ _N_ _N_ _N_} _N_ _N_ },
+ _tagCmp = { _A_ 2 _U_ 11 _N_ _S_ "U(P)U(P)" {_A_ 2 _U_ 22 _N_ _N_ _N_ _N_} _N_ _N_ } #-}
instance Ord _Addr
{-# GHC_PRAGMA _M_ PreludeCore {-dfun-} _A_ 0 _N_ _N_ _N_ _F_ _IF_ARGS_ 0 0 X 9 _!_ _TUP_8 [{{Eq _Addr}}, (_Addr -> _Addr -> Bool), (_Addr -> _Addr -> Bool), (_Addr -> _Addr -> Bool), (_Addr -> _Addr -> Bool), (_Addr -> _Addr -> _Addr), (_Addr -> _Addr -> _Addr), (_Addr -> _Addr -> _CMP_TAG)] [_DFUN_ Eq (_Addr), _CONSTM_ Ord (<) (_Addr), _CONSTM_ Ord (<=) (_Addr), _CONSTM_ Ord (>=) (_Addr), _CONSTM_ Ord (>) (_Addr), _CONSTM_ Ord max (_Addr), _CONSTM_ Ord min (_Addr), _CONSTM_ Ord _tagCmp (_Addr)] _N_
- (<) = _A_ 2 _U_ 11 _N_ _S_ "U(P)U(P)" {_A_ 2 _U_ 22 _N_ _N_ _F_ _IF_ARGS_ 0 2 XX 1 \ (u0 :: Addr#) (u1 :: Addr#) -> _#_ ltAddr# [] [u0, u1] _N_} _F_ _IF_ARGS_ 0 2 CC 3 \ (u0 :: _Addr) (u1 :: _Addr) -> case u0 of { _ALG_ A# (u2 :: Addr#) -> case u1 of { _ALG_ A# (u3 :: Addr#) -> _#_ ltAddr# [] [u2, u3]; _NO_DEFLT_ }; _NO_DEFLT_ } _N_,
- (<=) = _A_ 2 _U_ 11 _N_ _S_ "U(P)U(P)" {_A_ 2 _U_ 22 _N_ _N_ _F_ _IF_ARGS_ 0 2 XX 1 \ (u0 :: Addr#) (u1 :: Addr#) -> _#_ leAddr# [] [u0, u1] _N_} _F_ _IF_ARGS_ 0 2 CC 3 \ (u0 :: _Addr) (u1 :: _Addr) -> case u0 of { _ALG_ A# (u2 :: Addr#) -> case u1 of { _ALG_ A# (u3 :: Addr#) -> _#_ leAddr# [] [u2, u3]; _NO_DEFLT_ }; _NO_DEFLT_ } _N_,
- (>=) = _A_ 2 _U_ 11 _N_ _S_ "U(P)U(P)" {_A_ 2 _U_ 22 _N_ _N_ _F_ _IF_ARGS_ 0 2 XX 1 \ (u0 :: Addr#) (u1 :: Addr#) -> _#_ geAddr# [] [u0, u1] _N_} _F_ _IF_ARGS_ 0 2 CC 3 \ (u0 :: _Addr) (u1 :: _Addr) -> case u0 of { _ALG_ A# (u2 :: Addr#) -> case u1 of { _ALG_ A# (u3 :: Addr#) -> _#_ geAddr# [] [u2, u3]; _NO_DEFLT_ }; _NO_DEFLT_ } _N_,
- (>) = _A_ 2 _U_ 11 _N_ _S_ "U(P)U(P)" {_A_ 2 _U_ 22 _N_ _N_ _F_ _IF_ARGS_ 0 2 XX 1 \ (u0 :: Addr#) (u1 :: Addr#) -> _#_ gtAddr# [] [u0, u1] _N_} _F_ _IF_ARGS_ 0 2 CC 3 \ (u0 :: _Addr) (u1 :: _Addr) -> case u0 of { _ALG_ A# (u2 :: Addr#) -> case u1 of { _ALG_ A# (u3 :: Addr#) -> _#_ gtAddr# [] [u2, u3]; _NO_DEFLT_ }; _NO_DEFLT_ } _N_,
- max = _A_ 2 _U_ 11 _N_ _S_ "U(P)U(P)" {_A_ 2 _U_ 22 _N_ _N_ _N_ _N_} _N_ _N_,
- min = _A_ 2 _U_ 11 _N_ _S_ "U(P)U(P)" {_A_ 2 _U_ 22 _N_ _N_ _N_ _N_} _N_ _N_,
- _tagCmp = _A_ 2 _U_ 11 _N_ _S_ "U(P)U(P)" {_A_ 2 _U_ 22 _N_ _N_ _N_ _N_} _N_ _N_ #-}
+ (<) = { _A_ 2 _U_ 11 _N_ _S_ "U(P)U(P)" {_A_ 2 _U_ 22 _N_ _N_ _F_ _IF_ARGS_ 0 2 XX 1 \ (u0 :: Addr#) (u1 :: Addr#) -> _#_ ltAddr# [] [u0, u1] _N_} _F_ _IF_ARGS_ 0 2 CC 3 \ (u0 :: _Addr) (u1 :: _Addr) -> case u0 of { _ALG_ A# (u2 :: Addr#) -> case u1 of { _ALG_ A# (u3 :: Addr#) -> _#_ ltAddr# [] [u2, u3]; _NO_DEFLT_ }; _NO_DEFLT_ } _N_ },
+ (<=) = { _A_ 2 _U_ 11 _N_ _S_ "U(P)U(P)" {_A_ 2 _U_ 22 _N_ _N_ _F_ _IF_ARGS_ 0 2 XX 1 \ (u0 :: Addr#) (u1 :: Addr#) -> _#_ leAddr# [] [u0, u1] _N_} _F_ _IF_ARGS_ 0 2 CC 3 \ (u0 :: _Addr) (u1 :: _Addr) -> case u0 of { _ALG_ A# (u2 :: Addr#) -> case u1 of { _ALG_ A# (u3 :: Addr#) -> _#_ leAddr# [] [u2, u3]; _NO_DEFLT_ }; _NO_DEFLT_ } _N_ },
+ (>=) = { _A_ 2 _U_ 11 _N_ _S_ "U(P)U(P)" {_A_ 2 _U_ 22 _N_ _N_ _F_ _IF_ARGS_ 0 2 XX 1 \ (u0 :: Addr#) (u1 :: Addr#) -> _#_ geAddr# [] [u0, u1] _N_} _F_ _IF_ARGS_ 0 2 CC 3 \ (u0 :: _Addr) (u1 :: _Addr) -> case u0 of { _ALG_ A# (u2 :: Addr#) -> case u1 of { _ALG_ A# (u3 :: Addr#) -> _#_ geAddr# [] [u2, u3]; _NO_DEFLT_ }; _NO_DEFLT_ } _N_ },
+ (>) = { _A_ 2 _U_ 11 _N_ _S_ "U(P)U(P)" {_A_ 2 _U_ 22 _N_ _N_ _F_ _IF_ARGS_ 0 2 XX 1 \ (u0 :: Addr#) (u1 :: Addr#) -> _#_ gtAddr# [] [u0, u1] _N_} _F_ _IF_ARGS_ 0 2 CC 3 \ (u0 :: _Addr) (u1 :: _Addr) -> case u0 of { _ALG_ A# (u2 :: Addr#) -> case u1 of { _ALG_ A# (u3 :: Addr#) -> _#_ gtAddr# [] [u2, u3]; _NO_DEFLT_ }; _NO_DEFLT_ } _N_ },
+ max = { _A_ 2 _U_ 11 _N_ _S_ "U(P)U(P)" {_A_ 2 _U_ 22 _N_ _N_ _N_ _N_} _N_ _N_ },
+ min = { _A_ 2 _U_ 11 _N_ _S_ "U(P)U(P)" {_A_ 2 _U_ 22 _N_ _N_ _N_ _N_} _N_ _N_ },
+ _tagCmp = { _A_ 2 _U_ 11 _N_ _S_ "U(P)U(P)" {_A_ 2 _U_ 22 _N_ _N_ _N_ _N_} _N_ _N_ } #-}
instance Ord _Word
{-# GHC_PRAGMA _M_ PreludeCore {-dfun-} _A_ 0 _N_ _N_ _N_ _F_ _IF_ARGS_ 0 0 X 9 _!_ _TUP_8 [{{Eq _Word}}, (_Word -> _Word -> Bool), (_Word -> _Word -> Bool), (_Word -> _Word -> Bool), (_Word -> _Word -> Bool), (_Word -> _Word -> _Word), (_Word -> _Word -> _Word), (_Word -> _Word -> _CMP_TAG)] [_DFUN_ Eq (_Word), _CONSTM_ Ord (<) (_Word), _CONSTM_ Ord (<=) (_Word), _CONSTM_ Ord (>=) (_Word), _CONSTM_ Ord (>) (_Word), _CONSTM_ Ord max (_Word), _CONSTM_ Ord min (_Word), _CONSTM_ Ord _tagCmp (_Word)] _N_
- (<) = _A_ 2 _U_ 11 _N_ _S_ "U(P)U(P)" {_A_ 2 _U_ 22 _N_ _N_ _F_ _IF_ARGS_ 0 2 XX 1 \ (u0 :: Word#) (u1 :: Word#) -> _#_ ltWord# [] [u0, u1] _N_} _F_ _IF_ARGS_ 0 2 CC 3 \ (u0 :: _Word) (u1 :: _Word) -> case u0 of { _ALG_ W# (u2 :: Word#) -> case u1 of { _ALG_ W# (u3 :: Word#) -> _#_ ltWord# [] [u2, u3]; _NO_DEFLT_ }; _NO_DEFLT_ } _N_,
- (<=) = _A_ 2 _U_ 11 _N_ _S_ "U(P)U(P)" {_A_ 2 _U_ 22 _N_ _N_ _F_ _IF_ARGS_ 0 2 XX 1 \ (u0 :: Word#) (u1 :: Word#) -> _#_ leWord# [] [u0, u1] _N_} _F_ _IF_ARGS_ 0 2 CC 3 \ (u0 :: _Word) (u1 :: _Word) -> case u0 of { _ALG_ W# (u2 :: Word#) -> case u1 of { _ALG_ W# (u3 :: Word#) -> _#_ leWord# [] [u2, u3]; _NO_DEFLT_ }; _NO_DEFLT_ } _N_,
- (>=) = _A_ 2 _U_ 11 _N_ _S_ "U(P)U(P)" {_A_ 2 _U_ 22 _N_ _N_ _F_ _IF_ARGS_ 0 2 XX 1 \ (u0 :: Word#) (u1 :: Word#) -> _#_ geWord# [] [u0, u1] _N_} _F_ _IF_ARGS_ 0 2 CC 3 \ (u0 :: _Word) (u1 :: _Word) -> case u0 of { _ALG_ W# (u2 :: Word#) -> case u1 of { _ALG_ W# (u3 :: Word#) -> _#_ geWord# [] [u2, u3]; _NO_DEFLT_ }; _NO_DEFLT_ } _N_,
- (>) = _A_ 2 _U_ 11 _N_ _S_ "U(P)U(P)" {_A_ 2 _U_ 22 _N_ _N_ _F_ _IF_ARGS_ 0 2 XX 1 \ (u0 :: Word#) (u1 :: Word#) -> _#_ gtWord# [] [u0, u1] _N_} _F_ _IF_ARGS_ 0 2 CC 3 \ (u0 :: _Word) (u1 :: _Word) -> case u0 of { _ALG_ W# (u2 :: Word#) -> case u1 of { _ALG_ W# (u3 :: Word#) -> _#_ gtWord# [] [u2, u3]; _NO_DEFLT_ }; _NO_DEFLT_ } _N_,
- max = _A_ 2 _U_ 11 _N_ _S_ "U(P)U(P)" {_A_ 2 _U_ 22 _N_ _N_ _N_ _N_} _N_ _N_,
- min = _A_ 2 _U_ 11 _N_ _S_ "U(P)U(P)" {_A_ 2 _U_ 22 _N_ _N_ _N_ _N_} _N_ _N_,
- _tagCmp = _A_ 2 _U_ 11 _N_ _S_ "U(P)U(P)" {_A_ 2 _U_ 22 _N_ _N_ _N_ _N_} _N_ _N_ #-}
+ (<) = { _A_ 2 _U_ 11 _N_ _S_ "U(P)U(P)" {_A_ 2 _U_ 22 _N_ _N_ _F_ _IF_ARGS_ 0 2 XX 1 \ (u0 :: Word#) (u1 :: Word#) -> _#_ ltWord# [] [u0, u1] _N_} _F_ _IF_ARGS_ 0 2 CC 3 \ (u0 :: _Word) (u1 :: _Word) -> case u0 of { _ALG_ W# (u2 :: Word#) -> case u1 of { _ALG_ W# (u3 :: Word#) -> _#_ ltWord# [] [u2, u3]; _NO_DEFLT_ }; _NO_DEFLT_ } _N_ },
+ (<=) = { _A_ 2 _U_ 11 _N_ _S_ "U(P)U(P)" {_A_ 2 _U_ 22 _N_ _N_ _F_ _IF_ARGS_ 0 2 XX 1 \ (u0 :: Word#) (u1 :: Word#) -> _#_ leWord# [] [u0, u1] _N_} _F_ _IF_ARGS_ 0 2 CC 3 \ (u0 :: _Word) (u1 :: _Word) -> case u0 of { _ALG_ W# (u2 :: Word#) -> case u1 of { _ALG_ W# (u3 :: Word#) -> _#_ leWord# [] [u2, u3]; _NO_DEFLT_ }; _NO_DEFLT_ } _N_ },
+ (>=) = { _A_ 2 _U_ 11 _N_ _S_ "U(P)U(P)" {_A_ 2 _U_ 22 _N_ _N_ _F_ _IF_ARGS_ 0 2 XX 1 \ (u0 :: Word#) (u1 :: Word#) -> _#_ geWord# [] [u0, u1] _N_} _F_ _IF_ARGS_ 0 2 CC 3 \ (u0 :: _Word) (u1 :: _Word) -> case u0 of { _ALG_ W# (u2 :: Word#) -> case u1 of { _ALG_ W# (u3 :: Word#) -> _#_ geWord# [] [u2, u3]; _NO_DEFLT_ }; _NO_DEFLT_ } _N_ },
+ (>) = { _A_ 2 _U_ 11 _N_ _S_ "U(P)U(P)" {_A_ 2 _U_ 22 _N_ _N_ _F_ _IF_ARGS_ 0 2 XX 1 \ (u0 :: Word#) (u1 :: Word#) -> _#_ gtWord# [] [u0, u1] _N_} _F_ _IF_ARGS_ 0 2 CC 3 \ (u0 :: _Word) (u1 :: _Word) -> case u0 of { _ALG_ W# (u2 :: Word#) -> case u1 of { _ALG_ W# (u3 :: Word#) -> _#_ gtWord# [] [u2, u3]; _NO_DEFLT_ }; _NO_DEFLT_ } _N_ },
+ max = { _A_ 2 _U_ 11 _N_ _S_ "U(P)U(P)" {_A_ 2 _U_ 22 _N_ _N_ _N_ _N_} _N_ _N_ },
+ min = { _A_ 2 _U_ 11 _N_ _S_ "U(P)U(P)" {_A_ 2 _U_ 22 _N_ _N_ _N_ _N_} _N_ _N_ },
+ _tagCmp = { _A_ 2 _U_ 11 _N_ _S_ "U(P)U(P)" {_A_ 2 _U_ 22 _N_ _N_ _N_ _N_} _N_ _N_ } #-}
instance Real Int
{-# GHC_PRAGMA _M_ PreludeCore {-dfun-} _A_ 0 _N_ _N_ _N_ _F_ _IF_ARGS_ 0 0 X 4 _!_ _TUP_3 [{{Num Int}}, {{Enum Int}}, (Int -> Ratio Integer)] [_DFUN_ Num (Int), _DFUN_ Enum (Int), _CONSTM_ Real toRational (Int)] _N_
- toRational = _A_ 1 _U_ 1 _N_ _N_ _N_ _N_ #-}
+ toRational = { _A_ 1 _U_ 1 _N_ _N_ _N_ _N_ } #-}
instance Text Int
{-# GHC_PRAGMA _M_ PreludeCore {-dfun-} _A_ 0 _N_ _N_ _N_ _F_ _IF_ARGS_ 0 0 X 5 _!_ _TUP_4 [(Int -> [Char] -> [(Int, [Char])]), (Int -> Int -> [Char] -> [Char]), ([Char] -> [([Int], [Char])]), ([Int] -> [Char] -> [Char])] [_CONSTM_ Text readsPrec (Int), _CONSTM_ Text showsPrec (Int), _CONSTM_ Text readList (Int), _CONSTM_ Text showList (Int)] _N_
- readsPrec = _A_ 2 _U_ 02 _N_ _S_ "AL" {_A_ 1 _U_ 2 _N_ _N_ _F_ _IF_ARGS_ 0 1 X 3 \ (u0 :: [Char]) -> _APP_ _SPEC_ _ORIG_ PreludeText readSigned [ (Int) ] [ _SPEC_ _ORIG_ PreludeText readDec [ (Int) ], u0 ] _N_} _F_ _IF_ARGS_ 0 2 XX 3 \ (u0 :: Int) (u1 :: [Char]) -> _APP_ _SPEC_ _ORIG_ PreludeText readSigned [ (Int) ] [ _SPEC_ _ORIG_ PreludeText readDec [ (Int) ], u1 ] _N_,
- showsPrec = _A_ 3 _U_ 212 _N_ _S_ "LU(P)L" {_A_ 3 _U_ 222 _N_ _N_ _N_ _N_} _N_ _N_,
- readList = _A_ 0 _U_ 2 _N_ _N_ _N_ _N_,
- showList = _A_ 0 _U_ 12 _N_ _N_ _N_ _N_ #-}
+ readsPrec = { _A_ 2 _U_ 02 _N_ _S_ "AL" {_A_ 1 _U_ 2 _N_ _N_ _F_ _IF_ARGS_ 0 1 X 3 \ (u0 :: [Char]) -> _APP_ _SPEC_ _ORIG_ PreludeText readSigned [ (Int) ] [ _SPEC_ _ORIG_ PreludeText readDec [ (Int) ], u0 ] _N_} _F_ _IF_ARGS_ 0 2 XX 3 \ (u0 :: Int) (u1 :: [Char]) -> _APP_ _SPEC_ _ORIG_ PreludeText readSigned [ (Int) ] [ _SPEC_ _ORIG_ PreludeText readDec [ (Int) ], u1 ] _N_ },
+ showsPrec = { _A_ 3 _U_ 212 _N_ _S_ "LU(P)L" {_A_ 3 _U_ 222 _N_ _N_ _N_ _N_} _N_ _N_ },
+ readList = { _A_ 0 _U_ 2 _N_ _N_ _N_ _N_ },
+ showList = { _A_ 1 _U_ 12 _N_ _N_ _N_ _N_ } #-}
instance _CCallable Int
{-# GHC_PRAGMA _M_ PreludeCore {-dfun-} _A_ 0 _N_ _N_ _N_ _F_ _IF_ARGS_ 0 0 X 1 _!_ _TUP_0 [] [] _N_ #-}
instance _CCallable _Addr
-{-# GHC_PRAGMA INTERFACE VERSION 5 #-}
+{-# GHC_PRAGMA INTERFACE VERSION 6 #-}
interface PreludeCore where
import PreludeBuiltin(Int(..), Tuple0, _Addr(..), _Word(..))
import PreludeGlaMisc(_MallocPtr(..), _StablePtr(..))
{-# GHC_PRAGMA _A_ 3 _U_ 222 _N_ _S_ _!_ _N_ _N_ #-}
instance Enum Int
{-# GHC_PRAGMA _M_ PreludeCore {-dfun-} _A_ 0 _N_ _N_ _N_ _F_ _IF_ARGS_ 0 0 X 6 _!_ _TUP_5 [{{Ord Int}}, (Int -> [Int]), (Int -> Int -> [Int]), (Int -> Int -> [Int]), (Int -> Int -> Int -> [Int])] [_DFUN_ Ord (Int), _CONSTM_ Enum enumFrom (Int), _CONSTM_ Enum enumFromThen (Int), _CONSTM_ Enum enumFromTo (Int), _CONSTM_ Enum enumFromThenTo (Int)] _N_
- enumFrom = _A_ 1 _U_ 2 _N_ _N_ _F_ _ALWAYS_ \ (u0 :: Int) -> _LETREC_ {(u1 :: Int -> [Int]) = \ (u2 :: Int) -> let {(u6 :: [Int]) = let {(u5 :: Int) = case u2 of { _ALG_ I# (u3 :: Int#) -> case _#_ plusInt# [] [u3, 1#] of { _PRIM_ (u4 :: Int#) -> _!_ I# [] [u4] }; _NO_DEFLT_ }} in _APP_ u1 [ u5 ]} in _!_ (:) [Int] [u2, u6]} in _APP_ u1 [ u0 ] _N_,
- enumFromThen = _A_ 2 _U_ 21 _N_ _N_ _N_ _N_,
- enumFromTo = _A_ 2 _U_ 12 _N_ _S_ "SS" _F_ _ALWAYS_ \ (u0 :: Int) (u1 :: Int) -> case u0 of { _ALG_ I# (u2 :: Int#) -> _LETREC_ {(u3 :: Int# -> [Int]) = \ (u4 :: Int#) -> case u1 of { _ALG_ I# (u5 :: Int#) -> case _#_ leInt# [] [u4, u5] of { _ALG_ True -> let {(u7 :: [Int]) = case _#_ plusInt# [] [u4, 1#] of { _PRIM_ (u6 :: Int#) -> _APP_ u3 [ u6 ] }} in let {(u8 :: Int) = _!_ I# [] [u4]} in _!_ (:) [Int] [u8, u7]; False -> _!_ _NIL_ [Int] []; _NO_DEFLT_ }; _NO_DEFLT_ }} in _APP_ u3 [ u2 ]; _NO_DEFLT_ } _N_,
- enumFromThenTo = _A_ 3 _U_ 222 _N_ _N_ _N_ _N_ #-}
+ enumFrom = { _A_ 1 _U_ 2 _N_ _N_ _F_ _ALWAYS_ \ (u0 :: Int) -> _LETREC_ {(u1 :: Int -> [Int]) = \ (u2 :: Int) -> let {(u6 :: [Int]) = let {(u5 :: Int) = case u2 of { _ALG_ I# (u3 :: Int#) -> case _#_ plusInt# [] [u3, 1#] of { _PRIM_ (u4 :: Int#) -> _!_ I# [] [u4] }; _NO_DEFLT_ }} in _APP_ u1 [ u5 ]} in _!_ (:) [Int] [u2, u6]} in _APP_ u1 [ u0 ] _N_ },
+ enumFromThen = { _A_ 2 _U_ 21 _N_ _N_ _N_ _N_ },
+ enumFromTo = { _A_ 2 _U_ 12 _N_ _S_ "SS" _F_ _ALWAYS_ \ (u0 :: Int) (u1 :: Int) -> case u0 of { _ALG_ I# (u2 :: Int#) -> _LETREC_ {(u3 :: Int# -> [Int]) = \ (u4 :: Int#) -> case u1 of { _ALG_ I# (u5 :: Int#) -> case _#_ leInt# [] [u4, u5] of { _ALG_ True -> let {(u7 :: [Int]) = case _#_ plusInt# [] [u4, 1#] of { _PRIM_ (u6 :: Int#) -> _APP_ u3 [ u6 ] }} in let {(u8 :: Int) = _!_ I# [] [u4]} in _!_ (:) [Int] [u8, u7]; False -> _!_ _NIL_ [Int] []; _NO_DEFLT_ }; _NO_DEFLT_ }} in _APP_ u3 [ u2 ]; _NO_DEFLT_ } _N_ },
+ enumFromThenTo = { _A_ 3 _U_ 222 _N_ _N_ _N_ _N_ } #-}
instance Eq Int
{-# GHC_PRAGMA _M_ PreludeCore {-dfun-} _A_ 0 _N_ _N_ _N_ _F_ _IF_ARGS_ 0 0 X 3 _!_ _TUP_2 [(Int -> Int -> Bool), (Int -> Int -> Bool)] [_CONSTM_ Eq (==) (Int), _CONSTM_ Eq (/=) (Int)] _N_
- (==) = _A_ 2 _U_ 11 _N_ _S_ "U(P)U(P)" {_A_ 2 _U_ 22 _N_ _N_ _F_ _IF_ARGS_ 0 2 XX 1 \ (u0 :: Int#) (u1 :: Int#) -> _#_ eqInt# [] [u0, u1] _N_} _F_ _IF_ARGS_ 0 2 CC 3 \ (u0 :: Int) (u1 :: Int) -> case u0 of { _ALG_ I# (u2 :: Int#) -> case u1 of { _ALG_ I# (u3 :: Int#) -> _#_ eqInt# [] [u2, u3]; _NO_DEFLT_ }; _NO_DEFLT_ } _N_,
- (/=) = _A_ 2 _U_ 11 _N_ _S_ "U(P)U(P)" {_A_ 2 _U_ 22 _N_ _N_ _F_ _IF_ARGS_ 0 2 XX 1 \ (u0 :: Int#) (u1 :: Int#) -> _#_ neInt# [] [u0, u1] _N_} _F_ _IF_ARGS_ 0 2 CC 3 \ (u0 :: Int) (u1 :: Int) -> case u0 of { _ALG_ I# (u2 :: Int#) -> case u1 of { _ALG_ I# (u3 :: Int#) -> _#_ neInt# [] [u2, u3]; _NO_DEFLT_ }; _NO_DEFLT_ } _N_ #-}
+ (==) = { _A_ 2 _U_ 11 _N_ _S_ "U(P)U(P)" {_A_ 2 _U_ 22 _N_ _N_ _F_ _IF_ARGS_ 0 2 XX 1 \ (u0 :: Int#) (u1 :: Int#) -> _#_ eqInt# [] [u0, u1] _N_} _F_ _IF_ARGS_ 0 2 CC 3 \ (u0 :: Int) (u1 :: Int) -> case u0 of { _ALG_ I# (u2 :: Int#) -> case u1 of { _ALG_ I# (u3 :: Int#) -> _#_ eqInt# [] [u2, u3]; _NO_DEFLT_ }; _NO_DEFLT_ } _N_ },
+ (/=) = { _A_ 2 _U_ 11 _N_ _S_ "U(P)U(P)" {_A_ 2 _U_ 22 _N_ _N_ _F_ _IF_ARGS_ 0 2 XX 1 \ (u0 :: Int#) (u1 :: Int#) -> _#_ neInt# [] [u0, u1] _N_} _F_ _IF_ARGS_ 0 2 CC 3 \ (u0 :: Int) (u1 :: Int) -> case u0 of { _ALG_ I# (u2 :: Int#) -> case u1 of { _ALG_ I# (u3 :: Int#) -> _#_ neInt# [] [u2, u3]; _NO_DEFLT_ }; _NO_DEFLT_ } _N_ } #-}
instance Eq _Addr
{-# GHC_PRAGMA _M_ PreludeCore {-dfun-} _A_ 0 _N_ _N_ _N_ _F_ _IF_ARGS_ 0 0 X 3 _!_ _TUP_2 [(_Addr -> _Addr -> Bool), (_Addr -> _Addr -> Bool)] [_CONSTM_ Eq (==) (_Addr), _CONSTM_ Eq (/=) (_Addr)] _N_
- (==) = _A_ 2 _U_ 11 _N_ _S_ "U(P)U(P)" {_A_ 2 _U_ 22 _N_ _N_ _F_ _IF_ARGS_ 0 2 XX 1 \ (u0 :: Addr#) (u1 :: Addr#) -> _#_ eqAddr# [] [u0, u1] _N_} _F_ _IF_ARGS_ 0 2 CC 3 \ (u0 :: _Addr) (u1 :: _Addr) -> case u0 of { _ALG_ A# (u2 :: Addr#) -> case u1 of { _ALG_ A# (u3 :: Addr#) -> _#_ eqAddr# [] [u2, u3]; _NO_DEFLT_ }; _NO_DEFLT_ } _N_,
- (/=) = _A_ 2 _U_ 11 _N_ _S_ "U(P)U(P)" {_A_ 2 _U_ 22 _N_ _N_ _F_ _IF_ARGS_ 0 2 XX 1 \ (u0 :: Addr#) (u1 :: Addr#) -> _#_ neAddr# [] [u0, u1] _N_} _F_ _IF_ARGS_ 0 2 CC 3 \ (u0 :: _Addr) (u1 :: _Addr) -> case u0 of { _ALG_ A# (u2 :: Addr#) -> case u1 of { _ALG_ A# (u3 :: Addr#) -> _#_ neAddr# [] [u2, u3]; _NO_DEFLT_ }; _NO_DEFLT_ } _N_ #-}
+ (==) = { _A_ 2 _U_ 11 _N_ _S_ "U(P)U(P)" {_A_ 2 _U_ 22 _N_ _N_ _F_ _IF_ARGS_ 0 2 XX 1 \ (u0 :: Addr#) (u1 :: Addr#) -> _#_ eqAddr# [] [u0, u1] _N_} _F_ _IF_ARGS_ 0 2 CC 3 \ (u0 :: _Addr) (u1 :: _Addr) -> case u0 of { _ALG_ A# (u2 :: Addr#) -> case u1 of { _ALG_ A# (u3 :: Addr#) -> _#_ eqAddr# [] [u2, u3]; _NO_DEFLT_ }; _NO_DEFLT_ } _N_ },
+ (/=) = { _A_ 2 _U_ 11 _N_ _S_ "U(P)U(P)" {_A_ 2 _U_ 22 _N_ _N_ _F_ _IF_ARGS_ 0 2 XX 1 \ (u0 :: Addr#) (u1 :: Addr#) -> _#_ neAddr# [] [u0, u1] _N_} _F_ _IF_ARGS_ 0 2 CC 3 \ (u0 :: _Addr) (u1 :: _Addr) -> case u0 of { _ALG_ A# (u2 :: Addr#) -> case u1 of { _ALG_ A# (u3 :: Addr#) -> _#_ neAddr# [] [u2, u3]; _NO_DEFLT_ }; _NO_DEFLT_ } _N_ } #-}
instance Eq _Word
{-# GHC_PRAGMA _M_ PreludeCore {-dfun-} _A_ 0 _N_ _N_ _N_ _F_ _IF_ARGS_ 0 0 X 3 _!_ _TUP_2 [(_Word -> _Word -> Bool), (_Word -> _Word -> Bool)] [_CONSTM_ Eq (==) (_Word), _CONSTM_ Eq (/=) (_Word)] _N_
- (==) = _A_ 2 _U_ 11 _N_ _S_ "U(P)U(P)" {_A_ 2 _U_ 22 _N_ _N_ _F_ _IF_ARGS_ 0 2 XX 1 \ (u0 :: Word#) (u1 :: Word#) -> _#_ eqWord# [] [u0, u1] _N_} _F_ _IF_ARGS_ 0 2 CC 3 \ (u0 :: _Word) (u1 :: _Word) -> case u0 of { _ALG_ W# (u2 :: Word#) -> case u1 of { _ALG_ W# (u3 :: Word#) -> _#_ eqWord# [] [u2, u3]; _NO_DEFLT_ }; _NO_DEFLT_ } _N_,
- (/=) = _A_ 2 _U_ 11 _N_ _S_ "U(P)U(P)" {_A_ 2 _U_ 22 _N_ _N_ _F_ _IF_ARGS_ 0 2 XX 1 \ (u0 :: Word#) (u1 :: Word#) -> _#_ neWord# [] [u0, u1] _N_} _F_ _IF_ARGS_ 0 2 CC 3 \ (u0 :: _Word) (u1 :: _Word) -> case u0 of { _ALG_ W# (u2 :: Word#) -> case u1 of { _ALG_ W# (u3 :: Word#) -> _#_ neWord# [] [u2, u3]; _NO_DEFLT_ }; _NO_DEFLT_ } _N_ #-}
+ (==) = { _A_ 2 _U_ 11 _N_ _S_ "U(P)U(P)" {_A_ 2 _U_ 22 _N_ _N_ _F_ _IF_ARGS_ 0 2 XX 1 \ (u0 :: Word#) (u1 :: Word#) -> _#_ eqWord# [] [u0, u1] _N_} _F_ _IF_ARGS_ 0 2 CC 3 \ (u0 :: _Word) (u1 :: _Word) -> case u0 of { _ALG_ W# (u2 :: Word#) -> case u1 of { _ALG_ W# (u3 :: Word#) -> _#_ eqWord# [] [u2, u3]; _NO_DEFLT_ }; _NO_DEFLT_ } _N_ },
+ (/=) = { _A_ 2 _U_ 11 _N_ _S_ "U(P)U(P)" {_A_ 2 _U_ 22 _N_ _N_ _F_ _IF_ARGS_ 0 2 XX 1 \ (u0 :: Word#) (u1 :: Word#) -> _#_ neWord# [] [u0, u1] _N_} _F_ _IF_ARGS_ 0 2 CC 3 \ (u0 :: _Word) (u1 :: _Word) -> case u0 of { _ALG_ W# (u2 :: Word#) -> case u1 of { _ALG_ W# (u3 :: Word#) -> _#_ neWord# [] [u2, u3]; _NO_DEFLT_ }; _NO_DEFLT_ } _N_ } #-}
instance Integral Int
{-# GHC_PRAGMA _M_ PreludeCore {-dfun-} _A_ 0 _N_ _N_ _N_ _F_ _IF_ARGS_ 0 0 X 13 _!_ _TUP_12 [{{Real Int}}, {{Ix Int}}, (Int -> Int -> Int), (Int -> Int -> Int), (Int -> Int -> Int), (Int -> Int -> Int), (Int -> Int -> (Int, Int)), (Int -> Int -> (Int, Int)), (Int -> Bool), (Int -> Bool), (Int -> Integer), (Int -> Int)] [_DFUN_ Real (Int), _DFUN_ Ix (Int), _CONSTM_ Integral quot (Int), _CONSTM_ Integral rem (Int), _CONSTM_ Integral div (Int), _CONSTM_ Integral mod (Int), _CONSTM_ Integral quotRem (Int), _CONSTM_ Integral divMod (Int), _CONSTM_ Integral even (Int), _CONSTM_ Integral odd (Int), _CONSTM_ Integral toInteger (Int), _CONSTM_ Integral toInt (Int)] _N_
- quot = _A_ 2 _U_ 11 _N_ _S_ "U(P)U(P)" {_A_ 2 _U_ 22 _N_ _N_ _F_ _IF_ARGS_ 0 2 XC 5 \ (u0 :: Int#) (u1 :: Int#) -> case u1 of { _PRIM_ 0# -> _APP_ _TYAPP_ error { Int } [ _NOREP_S_ "Integral.Int.quot{PreludeCore}: divide by 0\n" ]; (u2 :: Int#) -> case _#_ quotInt# [] [u0, u1] of { _PRIM_ (u3 :: Int#) -> _!_ I# [] [u3] } } _N_} _F_ _IF_ARGS_ 0 2 CC 7 \ (u0 :: Int) (u1 :: Int) -> case u1 of { _ALG_ I# (u2 :: Int#) -> case u2 of { _PRIM_ 0# -> _APP_ _TYAPP_ error { Int } [ _NOREP_S_ "Integral.Int.quot{PreludeCore}: divide by 0\n" ]; (u3 :: Int#) -> case u0 of { _ALG_ I# (u4 :: Int#) -> case _#_ quotInt# [] [u4, u2] of { _PRIM_ (u5 :: Int#) -> _!_ I# [] [u5] }; _NO_DEFLT_ } }; _NO_DEFLT_ } _N_,
- rem = _A_ 2 _U_ 11 _N_ _S_ "U(P)U(P)" {_A_ 2 _U_ 22 _N_ _N_ _F_ _IF_ARGS_ 0 2 XC 5 \ (u0 :: Int#) (u1 :: Int#) -> case u1 of { _PRIM_ 0# -> _APP_ _TYAPP_ error { Int } [ _NOREP_S_ "Integral.Int.rem{PreludeCore}: divide by 0\n" ]; (u2 :: Int#) -> case _#_ remInt# [] [u0, u1] of { _PRIM_ (u3 :: Int#) -> _!_ I# [] [u3] } } _N_} _F_ _IF_ARGS_ 0 2 CC 7 \ (u0 :: Int) (u1 :: Int) -> case u1 of { _ALG_ I# (u2 :: Int#) -> case u2 of { _PRIM_ 0# -> _APP_ _TYAPP_ error { Int } [ _NOREP_S_ "Integral.Int.rem{PreludeCore}: divide by 0\n" ]; (u3 :: Int#) -> case u0 of { _ALG_ I# (u4 :: Int#) -> case _#_ remInt# [] [u4, u2] of { _PRIM_ (u5 :: Int#) -> _!_ I# [] [u5] }; _NO_DEFLT_ } }; _NO_DEFLT_ } _N_,
- div = _A_ 2 _U_ 11 _N_ _S_ "U(P)U(P)" {_A_ 2 _U_ 22 _N_ _N_ _N_ _N_} _N_ _N_,
- mod = _A_ 2 _U_ 11 _N_ _S_ "U(P)U(P)" {_A_ 2 _U_ 22 _N_ _N_ _N_ _N_} _N_ _N_,
- quotRem = _A_ 2 _U_ 11 _N_ _S_ "U(P)U(P)" {_A_ 2 _U_ 22 _N_ _N_ _N_ _N_} _N_ _N_,
- divMod = _A_ 2 _U_ 11 _N_ _S_ "U(P)U(P)" {_A_ 2 _U_ 22 _N_ _N_ _N_ _N_} _N_ _N_,
- even = _A_ 1 _U_ 1 _N_ _S_ "U(P)" {_A_ 1 _U_ 2 _N_ _N_ _N_ _N_} _N_ _N_,
- odd = _A_ 1 _U_ 1 _N_ _S_ "U(P)" {_A_ 1 _U_ 2 _N_ _N_ _N_ _N_} _N_ _N_,
- toInteger = _A_ 1 _U_ 1 _N_ _S_ "U(P)" {_A_ 1 _U_ 2 _N_ _N_ _F_ _IF_ARGS_ 0 1 X 1 \ (u0 :: Int#) -> _#_ int2Integer# [] [u0] _N_} _F_ _IF_ARGS_ 0 1 C 2 \ (u0 :: Int) -> case u0 of { _ALG_ I# (u1 :: Int#) -> _#_ int2Integer# [] [u1]; _NO_DEFLT_ } _N_,
- toInt = _A_ 1 _U_ 1 _N_ _S_ "U(P)" {_A_ 1 _U_ 2 _N_ _N_ _F_ _IF_ARGS_ 0 1 X 2 \ (u0 :: Int#) -> _!_ I# [] [u0] _N_} _F_ _IF_ARGS_ 0 1 X 1 \ (u0 :: Int) -> u0 _N_ #-}
+ quot = { _A_ 2 _U_ 11 _N_ _S_ "U(P)U(P)" {_A_ 2 _U_ 22 _N_ _N_ _F_ _IF_ARGS_ 0 2 XC 5 \ (u0 :: Int#) (u1 :: Int#) -> case u1 of { _PRIM_ 0# -> _APP_ _TYAPP_ error { Int } [ _NOREP_S_ "Integral.Int.quot{PreludeCore}: divide by 0\n" ]; (u2 :: Int#) -> case _#_ quotInt# [] [u0, u1] of { _PRIM_ (u3 :: Int#) -> _!_ I# [] [u3] } } _N_} _F_ _IF_ARGS_ 0 2 CC 7 \ (u0 :: Int) (u1 :: Int) -> case u1 of { _ALG_ I# (u2 :: Int#) -> case u2 of { _PRIM_ 0# -> _APP_ _TYAPP_ error { Int } [ _NOREP_S_ "Integral.Int.quot{PreludeCore}: divide by 0\n" ]; (u3 :: Int#) -> case u0 of { _ALG_ I# (u4 :: Int#) -> case _#_ quotInt# [] [u4, u2] of { _PRIM_ (u5 :: Int#) -> _!_ I# [] [u5] }; _NO_DEFLT_ } }; _NO_DEFLT_ } _N_ },
+ rem = { _A_ 2 _U_ 11 _N_ _S_ "U(P)U(P)" {_A_ 2 _U_ 22 _N_ _N_ _F_ _IF_ARGS_ 0 2 XC 5 \ (u0 :: Int#) (u1 :: Int#) -> case u1 of { _PRIM_ 0# -> _APP_ _TYAPP_ error { Int } [ _NOREP_S_ "Integral.Int.rem{PreludeCore}: divide by 0\n" ]; (u2 :: Int#) -> case _#_ remInt# [] [u0, u1] of { _PRIM_ (u3 :: Int#) -> _!_ I# [] [u3] } } _N_} _F_ _IF_ARGS_ 0 2 CC 7 \ (u0 :: Int) (u1 :: Int) -> case u1 of { _ALG_ I# (u2 :: Int#) -> case u2 of { _PRIM_ 0# -> _APP_ _TYAPP_ error { Int } [ _NOREP_S_ "Integral.Int.rem{PreludeCore}: divide by 0\n" ]; (u3 :: Int#) -> case u0 of { _ALG_ I# (u4 :: Int#) -> case _#_ remInt# [] [u4, u2] of { _PRIM_ (u5 :: Int#) -> _!_ I# [] [u5] }; _NO_DEFLT_ } }; _NO_DEFLT_ } _N_ },
+ div = { _A_ 2 _U_ 11 _N_ _S_ "U(P)U(P)" {_A_ 2 _U_ 22 _N_ _N_ _N_ _N_} _N_ _N_ },
+ mod = { _A_ 2 _U_ 11 _N_ _S_ "U(P)U(P)" {_A_ 2 _U_ 22 _N_ _N_ _N_ _N_} _N_ _N_ },
+ quotRem = { _A_ 2 _U_ 11 _N_ _S_ "U(P)U(P)" {_A_ 2 _U_ 22 _N_ _N_ _N_ _N_} _N_ _N_ },
+ divMod = { _A_ 2 _U_ 11 _N_ _S_ "U(P)U(P)" {_A_ 2 _U_ 22 _N_ _N_ _N_ _N_} _N_ _N_ },
+ even = { _A_ 1 _U_ 1 _N_ _S_ "U(P)" {_A_ 1 _U_ 2 _N_ _N_ _N_ _N_} _N_ _N_ },
+ odd = { _A_ 1 _U_ 1 _N_ _S_ "U(P)" {_A_ 1 _U_ 2 _N_ _N_ _N_ _N_} _N_ _N_ },
+ toInteger = { _A_ 1 _U_ 1 _N_ _S_ "U(P)" {_A_ 1 _U_ 2 _N_ _N_ _F_ _IF_ARGS_ 0 1 X 1 \ (u0 :: Int#) -> _#_ int2Integer# [] [u0] _N_} _F_ _IF_ARGS_ 0 1 C 2 \ (u0 :: Int) -> case u0 of { _ALG_ I# (u1 :: Int#) -> _#_ int2Integer# [] [u1]; _NO_DEFLT_ } _N_ },
+ toInt = { _A_ 1 _U_ 1 _N_ _S_ "U(P)" {_A_ 1 _U_ 2 _N_ _N_ _F_ _IF_ARGS_ 0 1 X 2 \ (u0 :: Int#) -> _!_ I# [] [u0] _N_} _F_ _IF_ARGS_ 0 1 X 1 \ (u0 :: Int) -> u0 _N_ } #-}
instance Ix Int
{-# GHC_PRAGMA _M_ PreludeCore {-dfun-} _A_ 0 _N_ _N_ _N_ _F_ _IF_ARGS_ 0 0 X 5 _!_ _TUP_4 [{{Ord Int}}, ((Int, Int) -> [Int]), ((Int, Int) -> Int -> Int), ((Int, Int) -> Int -> Bool)] [_DFUN_ Ord (Int), _CONSTM_ Ix range (Int), _CONSTM_ Ix index (Int), _CONSTM_ Ix inRange (Int)] _N_
- range = _A_ 1 _U_ 1 _N_ _S_ "U(U(P)U(P))" {_A_ 2 _U_ 22 _N_ _N_ _N_ _N_} _N_ _N_,
- index = _A_ 2 _U_ 11 _N_ _S_ "U(U(P)U(P))U(P)" {_A_ 3 _U_ 222 _N_ _N_ _N_ _N_} _N_ _N_,
- inRange = _A_ 2 _U_ 11 _N_ _S_ "U(U(P)U(P))U(P)" {_A_ 3 _U_ 222 _N_ _N_ _F_ _IF_ARGS_ 0 3 XXX 5 \ (u0 :: Int#) (u1 :: Int#) (u2 :: Int#) -> case _#_ leInt# [] [u0, u2] of { _ALG_ True -> _#_ leInt# [] [u2, u1]; False -> _!_ False [] []; _NO_DEFLT_ } _N_} _F_ _ALWAYS_ \ (u0 :: (Int, Int)) (u1 :: Int) -> case u0 of { _ALG_ _TUP_2 (u2 :: Int) (u3 :: Int) -> case u2 of { _ALG_ I# (u4 :: Int#) -> case u3 of { _ALG_ I# (u5 :: Int#) -> case u1 of { _ALG_ I# (u6 :: Int#) -> case _#_ leInt# [] [u4, u6] of { _ALG_ True -> _#_ leInt# [] [u6, u5]; False -> _!_ False [] []; _NO_DEFLT_ }; _NO_DEFLT_ }; _NO_DEFLT_ }; _NO_DEFLT_ }; _NO_DEFLT_ } _N_ #-}
+ range = { _A_ 1 _U_ 1 _N_ _S_ "U(U(P)U(P))" {_A_ 2 _U_ 22 _N_ _N_ _N_ _N_} _N_ _N_ },
+ index = { _A_ 2 _U_ 11 _N_ _S_ "U(U(P)U(P))U(P)" {_A_ 3 _U_ 222 _N_ _N_ _N_ _N_} _N_ _N_ },
+ inRange = { _A_ 2 _U_ 11 _N_ _S_ "U(U(P)U(P))U(P)" {_A_ 3 _U_ 222 _N_ _N_ _F_ _IF_ARGS_ 0 3 XXX 5 \ (u0 :: Int#) (u1 :: Int#) (u2 :: Int#) -> case _#_ leInt# [] [u0, u2] of { _ALG_ True -> _#_ leInt# [] [u2, u1]; False -> _!_ False [] []; _NO_DEFLT_ } _N_} _F_ _ALWAYS_ \ (u0 :: (Int, Int)) (u1 :: Int) -> case u0 of { _ALG_ _TUP_2 (u2 :: Int) (u3 :: Int) -> case u2 of { _ALG_ I# (u4 :: Int#) -> case u3 of { _ALG_ I# (u5 :: Int#) -> case u1 of { _ALG_ I# (u6 :: Int#) -> case _#_ leInt# [] [u4, u6] of { _ALG_ True -> _#_ leInt# [] [u6, u5]; False -> _!_ False [] []; _NO_DEFLT_ }; _NO_DEFLT_ }; _NO_DEFLT_ }; _NO_DEFLT_ }; _NO_DEFLT_ } _N_ } #-}
instance Num Int
{-# GHC_PRAGMA _M_ PreludeCore {-dfun-} _A_ 0 _N_ _N_ _N_ _F_ _IF_ARGS_ 0 0 X 11 _!_ _TUP_10 [{{Eq Int}}, {{Text Int}}, (Int -> Int -> Int), (Int -> Int -> Int), (Int -> Int -> Int), (Int -> Int), (Int -> Int), (Int -> Int), (Integer -> Int), (Int -> Int)] [_DFUN_ Eq (Int), _DFUN_ Text (Int), _CONSTM_ Num (+) (Int), _CONSTM_ Num (-) (Int), _CONSTM_ Num (*) (Int), _CONSTM_ Num negate (Int), _CONSTM_ Num abs (Int), _CONSTM_ Num signum (Int), _CONSTM_ Num fromInteger (Int), _CONSTM_ Num fromInt (Int)] _N_
- (+) = _A_ 2 _U_ 11 _N_ _S_ "U(P)U(P)" {_A_ 2 _U_ 22 _N_ _N_ _F_ _IF_ARGS_ 0 2 XX 3 \ (u0 :: Int#) (u1 :: Int#) -> case _#_ plusInt# [] [u0, u1] of { _PRIM_ (u2 :: Int#) -> _!_ I# [] [u2] } _N_} _F_ _IF_ARGS_ 0 2 CC 5 \ (u0 :: Int) (u1 :: Int) -> case u0 of { _ALG_ I# (u2 :: Int#) -> case u1 of { _ALG_ I# (u3 :: Int#) -> case _#_ plusInt# [] [u2, u3] of { _PRIM_ (u4 :: Int#) -> _!_ I# [] [u4] }; _NO_DEFLT_ }; _NO_DEFLT_ } _N_,
- (-) = _A_ 2 _U_ 11 _N_ _S_ "U(P)U(P)" {_A_ 2 _U_ 22 _N_ _N_ _F_ _IF_ARGS_ 0 2 XX 3 \ (u0 :: Int#) (u1 :: Int#) -> case _#_ minusInt# [] [u0, u1] of { _PRIM_ (u2 :: Int#) -> _!_ I# [] [u2] } _N_} _F_ _IF_ARGS_ 0 2 CC 5 \ (u0 :: Int) (u1 :: Int) -> case u0 of { _ALG_ I# (u2 :: Int#) -> case u1 of { _ALG_ I# (u3 :: Int#) -> case _#_ minusInt# [] [u2, u3] of { _PRIM_ (u4 :: Int#) -> _!_ I# [] [u4] }; _NO_DEFLT_ }; _NO_DEFLT_ } _N_,
- (*) = _A_ 2 _U_ 11 _N_ _S_ "U(P)U(P)" {_A_ 2 _U_ 22 _N_ _N_ _F_ _IF_ARGS_ 0 2 XX 3 \ (u0 :: Int#) (u1 :: Int#) -> case _#_ timesInt# [] [u0, u1] of { _PRIM_ (u2 :: Int#) -> _!_ I# [] [u2] } _N_} _F_ _IF_ARGS_ 0 2 CC 5 \ (u0 :: Int) (u1 :: Int) -> case u0 of { _ALG_ I# (u2 :: Int#) -> case u1 of { _ALG_ I# (u3 :: Int#) -> case _#_ timesInt# [] [u2, u3] of { _PRIM_ (u4 :: Int#) -> _!_ I# [] [u4] }; _NO_DEFLT_ }; _NO_DEFLT_ } _N_,
- negate = _A_ 1 _U_ 1 _N_ _S_ "U(P)" {_A_ 1 _U_ 2 _N_ _N_ _F_ _IF_ARGS_ 0 1 X 3 \ (u0 :: Int#) -> case _#_ negateInt# [] [u0] of { _PRIM_ (u1 :: Int#) -> _!_ I# [] [u1] } _N_} _F_ _IF_ARGS_ 0 1 C 4 \ (u0 :: Int) -> case u0 of { _ALG_ I# (u1 :: Int#) -> case _#_ negateInt# [] [u1] of { _PRIM_ (u2 :: Int#) -> _!_ I# [] [u2] }; _NO_DEFLT_ } _N_,
- abs = _A_ 1 _U_ 1 _N_ _S_ "U(P)" {_A_ 1 _U_ 2 _N_ _N_ _N_ _N_} _N_ _N_,
- signum = _A_ 1 _U_ 1 _N_ _S_ "U(P)" {_A_ 1 _U_ 2 _N_ _N_ _N_ _N_} _N_ _N_,
- fromInteger = _A_ 1 _U_ 1 _N_ _S_ "U(PPP)" {_A_ 3 _U_ 222 _N_ _N_ _F_ _IF_ARGS_ 0 3 XXX 3 \ (u0 :: Int#) (u1 :: Int#) (u2 :: ByteArray#) -> case _#_ integer2Int# [] [u0, u1, u2] of { _PRIM_ (u3 :: Int#) -> _!_ I# [] [u3] } _N_} _F_ _IF_ARGS_ 0 1 C 4 \ (u0 :: Integer) -> case u0 of { _ALG_ J# (u1 :: Int#) (u2 :: Int#) (u3 :: ByteArray#) -> case _#_ integer2Int# [] [u1, u2, u3] of { _PRIM_ (u4 :: Int#) -> _!_ I# [] [u4] }; _NO_DEFLT_ } _N_,
- fromInt = _A_ 1 _U_ 1 _N_ _S_ "U(P)" {_A_ 1 _U_ 2 _N_ _N_ _F_ _IF_ARGS_ 0 1 X 2 \ (u0 :: Int#) -> _!_ I# [] [u0] _N_} _F_ _IF_ARGS_ 0 1 X 1 \ (u0 :: Int) -> u0 _N_ #-}
+ (+) = { _A_ 2 _U_ 11 _N_ _S_ "U(P)U(P)" {_A_ 2 _U_ 22 _N_ _N_ _F_ _IF_ARGS_ 0 2 XX 3 \ (u0 :: Int#) (u1 :: Int#) -> case _#_ plusInt# [] [u0, u1] of { _PRIM_ (u2 :: Int#) -> _!_ I# [] [u2] } _N_} _F_ _IF_ARGS_ 0 2 CC 5 \ (u0 :: Int) (u1 :: Int) -> case u0 of { _ALG_ I# (u2 :: Int#) -> case u1 of { _ALG_ I# (u3 :: Int#) -> case _#_ plusInt# [] [u2, u3] of { _PRIM_ (u4 :: Int#) -> _!_ I# [] [u4] }; _NO_DEFLT_ }; _NO_DEFLT_ } _N_ },
+ (-) = { _A_ 2 _U_ 11 _N_ _S_ "U(P)U(P)" {_A_ 2 _U_ 22 _N_ _N_ _F_ _IF_ARGS_ 0 2 XX 3 \ (u0 :: Int#) (u1 :: Int#) -> case _#_ minusInt# [] [u0, u1] of { _PRIM_ (u2 :: Int#) -> _!_ I# [] [u2] } _N_} _F_ _IF_ARGS_ 0 2 CC 5 \ (u0 :: Int) (u1 :: Int) -> case u0 of { _ALG_ I# (u2 :: Int#) -> case u1 of { _ALG_ I# (u3 :: Int#) -> case _#_ minusInt# [] [u2, u3] of { _PRIM_ (u4 :: Int#) -> _!_ I# [] [u4] }; _NO_DEFLT_ }; _NO_DEFLT_ } _N_ },
+ (*) = { _A_ 2 _U_ 11 _N_ _S_ "U(P)U(P)" {_A_ 2 _U_ 22 _N_ _N_ _F_ _IF_ARGS_ 0 2 XX 3 \ (u0 :: Int#) (u1 :: Int#) -> case _#_ timesInt# [] [u0, u1] of { _PRIM_ (u2 :: Int#) -> _!_ I# [] [u2] } _N_} _F_ _IF_ARGS_ 0 2 CC 5 \ (u0 :: Int) (u1 :: Int) -> case u0 of { _ALG_ I# (u2 :: Int#) -> case u1 of { _ALG_ I# (u3 :: Int#) -> case _#_ timesInt# [] [u2, u3] of { _PRIM_ (u4 :: Int#) -> _!_ I# [] [u4] }; _NO_DEFLT_ }; _NO_DEFLT_ } _N_ },
+ negate = { _A_ 1 _U_ 1 _N_ _S_ "U(P)" {_A_ 1 _U_ 2 _N_ _N_ _F_ _IF_ARGS_ 0 1 X 3 \ (u0 :: Int#) -> case _#_ negateInt# [] [u0] of { _PRIM_ (u1 :: Int#) -> _!_ I# [] [u1] } _N_} _F_ _IF_ARGS_ 0 1 C 4 \ (u0 :: Int) -> case u0 of { _ALG_ I# (u1 :: Int#) -> case _#_ negateInt# [] [u1] of { _PRIM_ (u2 :: Int#) -> _!_ I# [] [u2] }; _NO_DEFLT_ } _N_ },
+ abs = { _A_ 1 _U_ 1 _N_ _S_ "U(P)" {_A_ 1 _U_ 2 _N_ _N_ _N_ _N_} _N_ _N_ },
+ signum = { _A_ 1 _U_ 1 _N_ _S_ "U(P)" {_A_ 1 _U_ 2 _N_ _N_ _N_ _N_} _N_ _N_ },
+ fromInteger = { _A_ 1 _U_ 1 _N_ _S_ "U(PPP)" {_A_ 3 _U_ 222 _N_ _N_ _F_ _IF_ARGS_ 0 3 XXX 3 \ (u0 :: Int#) (u1 :: Int#) (u2 :: ByteArray#) -> case _#_ integer2Int# [] [u0, u1, u2] of { _PRIM_ (u3 :: Int#) -> _!_ I# [] [u3] } _N_} _F_ _IF_ARGS_ 0 1 C 4 \ (u0 :: Integer) -> case u0 of { _ALG_ J# (u1 :: Int#) (u2 :: Int#) (u3 :: ByteArray#) -> case _#_ integer2Int# [] [u1, u2, u3] of { _PRIM_ (u4 :: Int#) -> _!_ I# [] [u4] }; _NO_DEFLT_ } _N_ },
+ fromInt = { _A_ 1 _U_ 1 _N_ _S_ "U(P)" {_A_ 1 _U_ 2 _N_ _N_ _F_ _IF_ARGS_ 0 1 X 2 \ (u0 :: Int#) -> _!_ I# [] [u0] _N_} _F_ _IF_ARGS_ 0 1 X 1 \ (u0 :: Int) -> u0 _N_ } #-}
instance Ord Int
{-# GHC_PRAGMA _M_ PreludeCore {-dfun-} _A_ 0 _N_ _N_ _N_ _F_ _IF_ARGS_ 0 0 X 9 _!_ _TUP_8 [{{Eq Int}}, (Int -> Int -> Bool), (Int -> Int -> Bool), (Int -> Int -> Bool), (Int -> Int -> Bool), (Int -> Int -> Int), (Int -> Int -> Int), (Int -> Int -> _CMP_TAG)] [_DFUN_ Eq (Int), _CONSTM_ Ord (<) (Int), _CONSTM_ Ord (<=) (Int), _CONSTM_ Ord (>=) (Int), _CONSTM_ Ord (>) (Int), _CONSTM_ Ord max (Int), _CONSTM_ Ord min (Int), _CONSTM_ Ord _tagCmp (Int)] _N_
- (<) = _A_ 2 _U_ 11 _N_ _S_ "U(P)U(P)" {_A_ 2 _U_ 22 _N_ _N_ _F_ _IF_ARGS_ 0 2 XX 1 \ (u0 :: Int#) (u1 :: Int#) -> _#_ ltInt# [] [u0, u1] _N_} _F_ _IF_ARGS_ 0 2 CC 3 \ (u0 :: Int) (u1 :: Int) -> case u0 of { _ALG_ I# (u2 :: Int#) -> case u1 of { _ALG_ I# (u3 :: Int#) -> _#_ ltInt# [] [u2, u3]; _NO_DEFLT_ }; _NO_DEFLT_ } _N_,
- (<=) = _A_ 2 _U_ 11 _N_ _S_ "U(P)U(P)" {_A_ 2 _U_ 22 _N_ _N_ _F_ _IF_ARGS_ 0 2 XX 1 \ (u0 :: Int#) (u1 :: Int#) -> _#_ leInt# [] [u0, u1] _N_} _F_ _IF_ARGS_ 0 2 CC 3 \ (u0 :: Int) (u1 :: Int) -> case u0 of { _ALG_ I# (u2 :: Int#) -> case u1 of { _ALG_ I# (u3 :: Int#) -> _#_ leInt# [] [u2, u3]; _NO_DEFLT_ }; _NO_DEFLT_ } _N_,
- (>=) = _A_ 2 _U_ 11 _N_ _S_ "U(P)U(P)" {_A_ 2 _U_ 22 _N_ _N_ _F_ _IF_ARGS_ 0 2 XX 1 \ (u0 :: Int#) (u1 :: Int#) -> _#_ geInt# [] [u0, u1] _N_} _F_ _IF_ARGS_ 0 2 CC 3 \ (u0 :: Int) (u1 :: Int) -> case u0 of { _ALG_ I# (u2 :: Int#) -> case u1 of { _ALG_ I# (u3 :: Int#) -> _#_ geInt# [] [u2, u3]; _NO_DEFLT_ }; _NO_DEFLT_ } _N_,
- (>) = _A_ 2 _U_ 11 _N_ _S_ "U(P)U(P)" {_A_ 2 _U_ 22 _N_ _N_ _F_ _IF_ARGS_ 0 2 XX 1 \ (u0 :: Int#) (u1 :: Int#) -> _#_ gtInt# [] [u0, u1] _N_} _F_ _IF_ARGS_ 0 2 CC 3 \ (u0 :: Int) (u1 :: Int) -> case u0 of { _ALG_ I# (u2 :: Int#) -> case u1 of { _ALG_ I# (u3 :: Int#) -> _#_ gtInt# [] [u2, u3]; _NO_DEFLT_ }; _NO_DEFLT_ } _N_,
- max = _A_ 2 _U_ 11 _N_ _S_ "U(P)U(P)" {_A_ 2 _U_ 22 _N_ _N_ _N_ _N_} _N_ _N_,
- min = _A_ 2 _U_ 11 _N_ _S_ "U(P)U(P)" {_A_ 2 _U_ 22 _N_ _N_ _N_ _N_} _N_ _N_,
- _tagCmp = _A_ 2 _U_ 11 _N_ _S_ "U(P)U(P)" {_A_ 2 _U_ 22 _N_ _N_ _N_ _N_} _N_ _N_ #-}
+ (<) = { _A_ 2 _U_ 11 _N_ _S_ "U(P)U(P)" {_A_ 2 _U_ 22 _N_ _N_ _F_ _IF_ARGS_ 0 2 XX 1 \ (u0 :: Int#) (u1 :: Int#) -> _#_ ltInt# [] [u0, u1] _N_} _F_ _IF_ARGS_ 0 2 CC 3 \ (u0 :: Int) (u1 :: Int) -> case u0 of { _ALG_ I# (u2 :: Int#) -> case u1 of { _ALG_ I# (u3 :: Int#) -> _#_ ltInt# [] [u2, u3]; _NO_DEFLT_ }; _NO_DEFLT_ } _N_ },
+ (<=) = { _A_ 2 _U_ 11 _N_ _S_ "U(P)U(P)" {_A_ 2 _U_ 22 _N_ _N_ _F_ _IF_ARGS_ 0 2 XX 1 \ (u0 :: Int#) (u1 :: Int#) -> _#_ leInt# [] [u0, u1] _N_} _F_ _IF_ARGS_ 0 2 CC 3 \ (u0 :: Int) (u1 :: Int) -> case u0 of { _ALG_ I# (u2 :: Int#) -> case u1 of { _ALG_ I# (u3 :: Int#) -> _#_ leInt# [] [u2, u3]; _NO_DEFLT_ }; _NO_DEFLT_ } _N_ },
+ (>=) = { _A_ 2 _U_ 11 _N_ _S_ "U(P)U(P)" {_A_ 2 _U_ 22 _N_ _N_ _F_ _IF_ARGS_ 0 2 XX 1 \ (u0 :: Int#) (u1 :: Int#) -> _#_ geInt# [] [u0, u1] _N_} _F_ _IF_ARGS_ 0 2 CC 3 \ (u0 :: Int) (u1 :: Int) -> case u0 of { _ALG_ I# (u2 :: Int#) -> case u1 of { _ALG_ I# (u3 :: Int#) -> _#_ geInt# [] [u2, u3]; _NO_DEFLT_ }; _NO_DEFLT_ } _N_ },
+ (>) = { _A_ 2 _U_ 11 _N_ _S_ "U(P)U(P)" {_A_ 2 _U_ 22 _N_ _N_ _F_ _IF_ARGS_ 0 2 XX 1 \ (u0 :: Int#) (u1 :: Int#) -> _#_ gtInt# [] [u0, u1] _N_} _F_ _IF_ARGS_ 0 2 CC 3 \ (u0 :: Int) (u1 :: Int) -> case u0 of { _ALG_ I# (u2 :: Int#) -> case u1 of { _ALG_ I# (u3 :: Int#) -> _#_ gtInt# [] [u2, u3]; _NO_DEFLT_ }; _NO_DEFLT_ } _N_ },
+ max = { _A_ 2 _U_ 11 _N_ _S_ "U(P)U(P)" {_A_ 2 _U_ 22 _N_ _N_ _N_ _N_} _N_ _N_ },
+ min = { _A_ 2 _U_ 11 _N_ _S_ "U(P)U(P)" {_A_ 2 _U_ 22 _N_ _N_ _N_ _N_} _N_ _N_ },
+ _tagCmp = { _A_ 2 _U_ 11 _N_ _S_ "U(P)U(P)" {_A_ 2 _U_ 22 _N_ _N_ _N_ _N_} _N_ _N_ } #-}
instance Ord _Addr
{-# GHC_PRAGMA _M_ PreludeCore {-dfun-} _A_ 0 _N_ _N_ _N_ _F_ _IF_ARGS_ 0 0 X 9 _!_ _TUP_8 [{{Eq _Addr}}, (_Addr -> _Addr -> Bool), (_Addr -> _Addr -> Bool), (_Addr -> _Addr -> Bool), (_Addr -> _Addr -> Bool), (_Addr -> _Addr -> _Addr), (_Addr -> _Addr -> _Addr), (_Addr -> _Addr -> _CMP_TAG)] [_DFUN_ Eq (_Addr), _CONSTM_ Ord (<) (_Addr), _CONSTM_ Ord (<=) (_Addr), _CONSTM_ Ord (>=) (_Addr), _CONSTM_ Ord (>) (_Addr), _CONSTM_ Ord max (_Addr), _CONSTM_ Ord min (_Addr), _CONSTM_ Ord _tagCmp (_Addr)] _N_
- (<) = _A_ 2 _U_ 11 _N_ _S_ "U(P)U(P)" {_A_ 2 _U_ 22 _N_ _N_ _F_ _IF_ARGS_ 0 2 XX 1 \ (u0 :: Addr#) (u1 :: Addr#) -> _#_ ltAddr# [] [u0, u1] _N_} _F_ _IF_ARGS_ 0 2 CC 3 \ (u0 :: _Addr) (u1 :: _Addr) -> case u0 of { _ALG_ A# (u2 :: Addr#) -> case u1 of { _ALG_ A# (u3 :: Addr#) -> _#_ ltAddr# [] [u2, u3]; _NO_DEFLT_ }; _NO_DEFLT_ } _N_,
- (<=) = _A_ 2 _U_ 11 _N_ _S_ "U(P)U(P)" {_A_ 2 _U_ 22 _N_ _N_ _F_ _IF_ARGS_ 0 2 XX 1 \ (u0 :: Addr#) (u1 :: Addr#) -> _#_ leAddr# [] [u0, u1] _N_} _F_ _IF_ARGS_ 0 2 CC 3 \ (u0 :: _Addr) (u1 :: _Addr) -> case u0 of { _ALG_ A# (u2 :: Addr#) -> case u1 of { _ALG_ A# (u3 :: Addr#) -> _#_ leAddr# [] [u2, u3]; _NO_DEFLT_ }; _NO_DEFLT_ } _N_,
- (>=) = _A_ 2 _U_ 11 _N_ _S_ "U(P)U(P)" {_A_ 2 _U_ 22 _N_ _N_ _F_ _IF_ARGS_ 0 2 XX 1 \ (u0 :: Addr#) (u1 :: Addr#) -> _#_ geAddr# [] [u0, u1] _N_} _F_ _IF_ARGS_ 0 2 CC 3 \ (u0 :: _Addr) (u1 :: _Addr) -> case u0 of { _ALG_ A# (u2 :: Addr#) -> case u1 of { _ALG_ A# (u3 :: Addr#) -> _#_ geAddr# [] [u2, u3]; _NO_DEFLT_ }; _NO_DEFLT_ } _N_,
- (>) = _A_ 2 _U_ 11 _N_ _S_ "U(P)U(P)" {_A_ 2 _U_ 22 _N_ _N_ _F_ _IF_ARGS_ 0 2 XX 1 \ (u0 :: Addr#) (u1 :: Addr#) -> _#_ gtAddr# [] [u0, u1] _N_} _F_ _IF_ARGS_ 0 2 CC 3 \ (u0 :: _Addr) (u1 :: _Addr) -> case u0 of { _ALG_ A# (u2 :: Addr#) -> case u1 of { _ALG_ A# (u3 :: Addr#) -> _#_ gtAddr# [] [u2, u3]; _NO_DEFLT_ }; _NO_DEFLT_ } _N_,
- max = _A_ 2 _U_ 11 _N_ _S_ "U(P)U(P)" {_A_ 2 _U_ 22 _N_ _N_ _N_ _N_} _N_ _N_,
- min = _A_ 2 _U_ 11 _N_ _S_ "U(P)U(P)" {_A_ 2 _U_ 22 _N_ _N_ _N_ _N_} _N_ _N_,
- _tagCmp = _A_ 2 _U_ 11 _N_ _S_ "U(P)U(P)" {_A_ 2 _U_ 22 _N_ _N_ _N_ _N_} _N_ _N_ #-}
+ (<) = { _A_ 2 _U_ 11 _N_ _S_ "U(P)U(P)" {_A_ 2 _U_ 22 _N_ _N_ _F_ _IF_ARGS_ 0 2 XX 1 \ (u0 :: Addr#) (u1 :: Addr#) -> _#_ ltAddr# [] [u0, u1] _N_} _F_ _IF_ARGS_ 0 2 CC 3 \ (u0 :: _Addr) (u1 :: _Addr) -> case u0 of { _ALG_ A# (u2 :: Addr#) -> case u1 of { _ALG_ A# (u3 :: Addr#) -> _#_ ltAddr# [] [u2, u3]; _NO_DEFLT_ }; _NO_DEFLT_ } _N_ },
+ (<=) = { _A_ 2 _U_ 11 _N_ _S_ "U(P)U(P)" {_A_ 2 _U_ 22 _N_ _N_ _F_ _IF_ARGS_ 0 2 XX 1 \ (u0 :: Addr#) (u1 :: Addr#) -> _#_ leAddr# [] [u0, u1] _N_} _F_ _IF_ARGS_ 0 2 CC 3 \ (u0 :: _Addr) (u1 :: _Addr) -> case u0 of { _ALG_ A# (u2 :: Addr#) -> case u1 of { _ALG_ A# (u3 :: Addr#) -> _#_ leAddr# [] [u2, u3]; _NO_DEFLT_ }; _NO_DEFLT_ } _N_ },
+ (>=) = { _A_ 2 _U_ 11 _N_ _S_ "U(P)U(P)" {_A_ 2 _U_ 22 _N_ _N_ _F_ _IF_ARGS_ 0 2 XX 1 \ (u0 :: Addr#) (u1 :: Addr#) -> _#_ geAddr# [] [u0, u1] _N_} _F_ _IF_ARGS_ 0 2 CC 3 \ (u0 :: _Addr) (u1 :: _Addr) -> case u0 of { _ALG_ A# (u2 :: Addr#) -> case u1 of { _ALG_ A# (u3 :: Addr#) -> _#_ geAddr# [] [u2, u3]; _NO_DEFLT_ }; _NO_DEFLT_ } _N_ },
+ (>) = { _A_ 2 _U_ 11 _N_ _S_ "U(P)U(P)" {_A_ 2 _U_ 22 _N_ _N_ _F_ _IF_ARGS_ 0 2 XX 1 \ (u0 :: Addr#) (u1 :: Addr#) -> _#_ gtAddr# [] [u0, u1] _N_} _F_ _IF_ARGS_ 0 2 CC 3 \ (u0 :: _Addr) (u1 :: _Addr) -> case u0 of { _ALG_ A# (u2 :: Addr#) -> case u1 of { _ALG_ A# (u3 :: Addr#) -> _#_ gtAddr# [] [u2, u3]; _NO_DEFLT_ }; _NO_DEFLT_ } _N_ },
+ max = { _A_ 2 _U_ 11 _N_ _S_ "U(P)U(P)" {_A_ 2 _U_ 22 _N_ _N_ _N_ _N_} _N_ _N_ },
+ min = { _A_ 2 _U_ 11 _N_ _S_ "U(P)U(P)" {_A_ 2 _U_ 22 _N_ _N_ _N_ _N_} _N_ _N_ },
+ _tagCmp = { _A_ 2 _U_ 11 _N_ _S_ "U(P)U(P)" {_A_ 2 _U_ 22 _N_ _N_ _N_ _N_} _N_ _N_ } #-}
instance Ord _Word
{-# GHC_PRAGMA _M_ PreludeCore {-dfun-} _A_ 0 _N_ _N_ _N_ _F_ _IF_ARGS_ 0 0 X 9 _!_ _TUP_8 [{{Eq _Word}}, (_Word -> _Word -> Bool), (_Word -> _Word -> Bool), (_Word -> _Word -> Bool), (_Word -> _Word -> Bool), (_Word -> _Word -> _Word), (_Word -> _Word -> _Word), (_Word -> _Word -> _CMP_TAG)] [_DFUN_ Eq (_Word), _CONSTM_ Ord (<) (_Word), _CONSTM_ Ord (<=) (_Word), _CONSTM_ Ord (>=) (_Word), _CONSTM_ Ord (>) (_Word), _CONSTM_ Ord max (_Word), _CONSTM_ Ord min (_Word), _CONSTM_ Ord _tagCmp (_Word)] _N_
- (<) = _A_ 2 _U_ 11 _N_ _S_ "U(P)U(P)" {_A_ 2 _U_ 22 _N_ _N_ _F_ _IF_ARGS_ 0 2 XX 1 \ (u0 :: Word#) (u1 :: Word#) -> _#_ ltWord# [] [u0, u1] _N_} _F_ _IF_ARGS_ 0 2 CC 3 \ (u0 :: _Word) (u1 :: _Word) -> case u0 of { _ALG_ W# (u2 :: Word#) -> case u1 of { _ALG_ W# (u3 :: Word#) -> _#_ ltWord# [] [u2, u3]; _NO_DEFLT_ }; _NO_DEFLT_ } _N_,
- (<=) = _A_ 2 _U_ 11 _N_ _S_ "U(P)U(P)" {_A_ 2 _U_ 22 _N_ _N_ _F_ _IF_ARGS_ 0 2 XX 1 \ (u0 :: Word#) (u1 :: Word#) -> _#_ leWord# [] [u0, u1] _N_} _F_ _IF_ARGS_ 0 2 CC 3 \ (u0 :: _Word) (u1 :: _Word) -> case u0 of { _ALG_ W# (u2 :: Word#) -> case u1 of { _ALG_ W# (u3 :: Word#) -> _#_ leWord# [] [u2, u3]; _NO_DEFLT_ }; _NO_DEFLT_ } _N_,
- (>=) = _A_ 2 _U_ 11 _N_ _S_ "U(P)U(P)" {_A_ 2 _U_ 22 _N_ _N_ _F_ _IF_ARGS_ 0 2 XX 1 \ (u0 :: Word#) (u1 :: Word#) -> _#_ geWord# [] [u0, u1] _N_} _F_ _IF_ARGS_ 0 2 CC 3 \ (u0 :: _Word) (u1 :: _Word) -> case u0 of { _ALG_ W# (u2 :: Word#) -> case u1 of { _ALG_ W# (u3 :: Word#) -> _#_ geWord# [] [u2, u3]; _NO_DEFLT_ }; _NO_DEFLT_ } _N_,
- (>) = _A_ 2 _U_ 11 _N_ _S_ "U(P)U(P)" {_A_ 2 _U_ 22 _N_ _N_ _F_ _IF_ARGS_ 0 2 XX 1 \ (u0 :: Word#) (u1 :: Word#) -> _#_ gtWord# [] [u0, u1] _N_} _F_ _IF_ARGS_ 0 2 CC 3 \ (u0 :: _Word) (u1 :: _Word) -> case u0 of { _ALG_ W# (u2 :: Word#) -> case u1 of { _ALG_ W# (u3 :: Word#) -> _#_ gtWord# [] [u2, u3]; _NO_DEFLT_ }; _NO_DEFLT_ } _N_,
- max = _A_ 2 _U_ 11 _N_ _S_ "U(P)U(P)" {_A_ 2 _U_ 22 _N_ _N_ _N_ _N_} _N_ _N_,
- min = _A_ 2 _U_ 11 _N_ _S_ "U(P)U(P)" {_A_ 2 _U_ 22 _N_ _N_ _N_ _N_} _N_ _N_,
- _tagCmp = _A_ 2 _U_ 11 _N_ _S_ "U(P)U(P)" {_A_ 2 _U_ 22 _N_ _N_ _N_ _N_} _N_ _N_ #-}
+ (<) = { _A_ 2 _U_ 11 _N_ _S_ "U(P)U(P)" {_A_ 2 _U_ 22 _N_ _N_ _F_ _IF_ARGS_ 0 2 XX 1 \ (u0 :: Word#) (u1 :: Word#) -> _#_ ltWord# [] [u0, u1] _N_} _F_ _IF_ARGS_ 0 2 CC 3 \ (u0 :: _Word) (u1 :: _Word) -> case u0 of { _ALG_ W# (u2 :: Word#) -> case u1 of { _ALG_ W# (u3 :: Word#) -> _#_ ltWord# [] [u2, u3]; _NO_DEFLT_ }; _NO_DEFLT_ } _N_ },
+ (<=) = { _A_ 2 _U_ 11 _N_ _S_ "U(P)U(P)" {_A_ 2 _U_ 22 _N_ _N_ _F_ _IF_ARGS_ 0 2 XX 1 \ (u0 :: Word#) (u1 :: Word#) -> _#_ leWord# [] [u0, u1] _N_} _F_ _IF_ARGS_ 0 2 CC 3 \ (u0 :: _Word) (u1 :: _Word) -> case u0 of { _ALG_ W# (u2 :: Word#) -> case u1 of { _ALG_ W# (u3 :: Word#) -> _#_ leWord# [] [u2, u3]; _NO_DEFLT_ }; _NO_DEFLT_ } _N_ },
+ (>=) = { _A_ 2 _U_ 11 _N_ _S_ "U(P)U(P)" {_A_ 2 _U_ 22 _N_ _N_ _F_ _IF_ARGS_ 0 2 XX 1 \ (u0 :: Word#) (u1 :: Word#) -> _#_ geWord# [] [u0, u1] _N_} _F_ _IF_ARGS_ 0 2 CC 3 \ (u0 :: _Word) (u1 :: _Word) -> case u0 of { _ALG_ W# (u2 :: Word#) -> case u1 of { _ALG_ W# (u3 :: Word#) -> _#_ geWord# [] [u2, u3]; _NO_DEFLT_ }; _NO_DEFLT_ } _N_ },
+ (>) = { _A_ 2 _U_ 11 _N_ _S_ "U(P)U(P)" {_A_ 2 _U_ 22 _N_ _N_ _F_ _IF_ARGS_ 0 2 XX 1 \ (u0 :: Word#) (u1 :: Word#) -> _#_ gtWord# [] [u0, u1] _N_} _F_ _IF_ARGS_ 0 2 CC 3 \ (u0 :: _Word) (u1 :: _Word) -> case u0 of { _ALG_ W# (u2 :: Word#) -> case u1 of { _ALG_ W# (u3 :: Word#) -> _#_ gtWord# [] [u2, u3]; _NO_DEFLT_ }; _NO_DEFLT_ } _N_ },
+ max = { _A_ 2 _U_ 11 _N_ _S_ "U(P)U(P)" {_A_ 2 _U_ 22 _N_ _N_ _N_ _N_} _N_ _N_ },
+ min = { _A_ 2 _U_ 11 _N_ _S_ "U(P)U(P)" {_A_ 2 _U_ 22 _N_ _N_ _N_ _N_} _N_ _N_ },
+ _tagCmp = { _A_ 2 _U_ 11 _N_ _S_ "U(P)U(P)" {_A_ 2 _U_ 22 _N_ _N_ _N_ _N_} _N_ _N_ } #-}
instance Real Int
{-# GHC_PRAGMA _M_ PreludeCore {-dfun-} _A_ 0 _N_ _N_ _N_ _F_ _IF_ARGS_ 0 0 X 4 _!_ _TUP_3 [{{Num Int}}, {{Enum Int}}, (Int -> Ratio Integer)] [_DFUN_ Num (Int), _DFUN_ Enum (Int), _CONSTM_ Real toRational (Int)] _N_
- toRational = _A_ 1 _U_ 1 _N_ _N_ _N_ _N_ #-}
+ toRational = { _A_ 1 _U_ 1 _N_ _N_ _N_ _N_ } #-}
instance Text Int
{-# GHC_PRAGMA _M_ PreludeCore {-dfun-} _A_ 0 _N_ _N_ _N_ _F_ _IF_ARGS_ 0 0 X 5 _!_ _TUP_4 [(Int -> [Char] -> [(Int, [Char])]), (Int -> Int -> [Char] -> [Char]), ([Char] -> [([Int], [Char])]), ([Int] -> [Char] -> [Char])] [_CONSTM_ Text readsPrec (Int), _CONSTM_ Text showsPrec (Int), _CONSTM_ Text readList (Int), _CONSTM_ Text showList (Int)] _N_
- readsPrec = _A_ 2 _U_ 02 _N_ _S_ "AL" {_A_ 1 _U_ 2 _N_ _N_ _F_ _IF_ARGS_ 0 1 X 3 \ (u0 :: [Char]) -> _APP_ _SPEC_ _ORIG_ PreludeText readSigned [ (Int) ] [ _SPEC_ _ORIG_ PreludeText readDec [ (Int) ], u0 ] _N_} _F_ _IF_ARGS_ 0 2 XX 3 \ (u0 :: Int) (u1 :: [Char]) -> _APP_ _SPEC_ _ORIG_ PreludeText readSigned [ (Int) ] [ _SPEC_ _ORIG_ PreludeText readDec [ (Int) ], u1 ] _N_,
- showsPrec = _A_ 3 _U_ 212 _N_ _S_ "LU(P)L" {_A_ 3 _U_ 222 _N_ _N_ _N_ _N_} _N_ _N_,
- readList = _A_ 0 _U_ 2 _N_ _N_ _N_ _N_,
- showList = _A_ 0 _U_ 12 _N_ _N_ _N_ _N_ #-}
+ readsPrec = { _A_ 2 _U_ 02 _N_ _S_ "AL" {_A_ 1 _U_ 2 _N_ _N_ _F_ _IF_ARGS_ 0 1 X 3 \ (u0 :: [Char]) -> _APP_ _SPEC_ _ORIG_ PreludeText readSigned [ (Int) ] [ _SPEC_ _ORIG_ PreludeText readDec [ (Int) ], u0 ] _N_} _F_ _IF_ARGS_ 0 2 XX 3 \ (u0 :: Int) (u1 :: [Char]) -> _APP_ _SPEC_ _ORIG_ PreludeText readSigned [ (Int) ] [ _SPEC_ _ORIG_ PreludeText readDec [ (Int) ], u1 ] _N_ },
+ showsPrec = { _A_ 3 _U_ 212 _N_ _S_ "LU(P)L" {_A_ 3 _U_ 222 _N_ _N_ _N_ _N_} _N_ _N_ },
+ readList = { _A_ 0 _U_ 2 _N_ _N_ _N_ _N_ },
+ showList = { _A_ 1 _U_ 12 _N_ _N_ _N_ _N_ } #-}
instance _CCallable Int
{-# GHC_PRAGMA _M_ PreludeCore {-dfun-} _A_ 0 _N_ _N_ _N_ _F_ _IF_ARGS_ 0 0 X 1 _!_ _TUP_0 [] [] _N_ #-}
instance _CCallable _Addr
-{-# GHC_PRAGMA INTERFACE VERSION 5 #-}
+{-# GHC_PRAGMA INTERFACE VERSION 6 #-}
interface PreludeCore where
-import PreludeBuiltin(Int(..), Integer(..))
-_integer_0 :: Integer
- {-# GHC_PRAGMA _A_ 0 _N_ _N_ _N_ _F_ _IF_ARGS_ 0 0 X 1 _#_ int2Integer# [] [0#] _N_ #-}
-_integer_1 :: Integer
- {-# GHC_PRAGMA _A_ 0 _N_ _N_ _N_ _F_ _IF_ARGS_ 0 0 X 1 _#_ int2Integer# [] [1#] _N_ #-}
-_integer_m1 :: Integer
+import PreludeBuiltin(Integer(..))
+__integer0 :: Integer
+ {-# GHC_PRAGMA _A_ 0 _N_ _N_ _N_ _N_ _N_ #-}
+__integer1 :: Integer
+ {-# GHC_PRAGMA _A_ 0 _N_ _N_ _N_ _N_ _N_ #-}
+__integer2 :: Integer
+ {-# GHC_PRAGMA _A_ 0 _N_ _N_ _N_ _N_ _N_ #-}
+__integerm1 :: Integer
{-# GHC_PRAGMA _A_ 0 _N_ _N_ _N_ _N_ _N_ #-}
-int2Integer :: Int -> Integer
- {-# GHC_PRAGMA _A_ 1 _U_ 1 _N_ _S_ "U(P)" {_A_ 1 _U_ 2 _N_ _N_ _F_ _IF_ARGS_ 0 1 X 1 \ (u0 :: Int#) -> _#_ int2Integer# [] [u0] _N_} _F_ _IF_ARGS_ 0 1 C 2 \ (u0 :: Int) -> case u0 of { _ALG_ I# (u1 :: Int#) -> _#_ int2Integer# [] [u1]; _NO_DEFLT_ } _N_ #-}
instance Enum Integer
{-# GHC_PRAGMA _M_ PreludeCore {-dfun-} _A_ 0 _N_ _N_ _N_ _F_ _IF_ARGS_ 0 0 X 6 _!_ _TUP_5 [{{Ord Integer}}, (Integer -> [Integer]), (Integer -> Integer -> [Integer]), (Integer -> Integer -> [Integer]), (Integer -> Integer -> Integer -> [Integer])] [_DFUN_ Ord (Integer), _CONSTM_ Enum enumFrom (Integer), _CONSTM_ Enum enumFromThen (Integer), _CONSTM_ Enum enumFromTo (Integer), _CONSTM_ Enum enumFromThenTo (Integer)] _N_
- enumFrom = _A_ 1 _U_ 2 _N_ _N_ _N_ _N_,
- enumFromThen = _A_ 2 _U_ 21 _N_ _N_ _N_ _N_,
- enumFromTo = _A_ 2 _U_ 22 _N_ _N_ _N_ _N_,
- enumFromThenTo = _A_ 3 _U_ 222 _N_ _N_ _N_ _N_ #-}
+ enumFrom = { _A_ 1 _U_ 2 _N_ _N_ _N_ _N_ },
+ enumFromThen = { _A_ 2 _U_ 21 _N_ _N_ _N_ _N_ },
+ enumFromTo = { _A_ 2 _U_ 22 _N_ _N_ _N_ _N_ },
+ enumFromThenTo = { _A_ 3 _U_ 222 _N_ _N_ _N_ _N_ } #-}
instance Eq Integer
{-# GHC_PRAGMA _M_ PreludeCore {-dfun-} _A_ 0 _N_ _N_ _N_ _F_ _IF_ARGS_ 0 0 X 3 _!_ _TUP_2 [(Integer -> Integer -> Bool), (Integer -> Integer -> Bool)] [_CONSTM_ Eq (==) (Integer), _CONSTM_ Eq (/=) (Integer)] _N_
- (==) = _A_ 2 _U_ 11 _N_ _S_ "U(PPP)U(PPP)" {_A_ 4 _U_ 2221 _N_ _N_ _F_ _IF_ARGS_ 0 4 XXXC 4 \ (u0 :: Int#) (u1 :: Int#) (u2 :: ByteArray#) (u3 :: Integer) -> case u3 of { _ALG_ J# (u4 :: Int#) (u5 :: Int#) (u6 :: ByteArray#) -> case _#_ cmpInteger# [] [u0, u1, u2, u4, u5, u6] of { _PRIM_ 0# -> _!_ True [] []; (u7 :: Int#) -> _!_ False [] [] }; _NO_DEFLT_ } _N_} _F_ _IF_ARGS_ 0 2 CC 5 \ (u0 :: Integer) (u1 :: Integer) -> case u0 of { _ALG_ J# (u2 :: Int#) (u3 :: Int#) (u4 :: ByteArray#) -> case u1 of { _ALG_ J# (u5 :: Int#) (u6 :: Int#) (u7 :: ByteArray#) -> case _#_ cmpInteger# [] [u2, u3, u4, u5, u6, u7] of { _PRIM_ 0# -> _!_ True [] []; (u8 :: Int#) -> _!_ False [] [] }; _NO_DEFLT_ }; _NO_DEFLT_ } _N_,
- (/=) = _A_ 2 _U_ 11 _N_ _S_ "U(PPP)U(PPP)" {_A_ 4 _U_ 2221 _N_ _N_ _F_ _IF_ARGS_ 0 4 XXXC 4 \ (u0 :: Int#) (u1 :: Int#) (u2 :: ByteArray#) (u3 :: Integer) -> case u3 of { _ALG_ J# (u4 :: Int#) (u5 :: Int#) (u6 :: ByteArray#) -> case _#_ cmpInteger# [] [u0, u1, u2, u4, u5, u6] of { _PRIM_ 0# -> _!_ False [] []; (u7 :: Int#) -> _!_ True [] [] }; _NO_DEFLT_ } _N_} _F_ _IF_ARGS_ 0 2 CC 5 \ (u0 :: Integer) (u1 :: Integer) -> case u0 of { _ALG_ J# (u2 :: Int#) (u3 :: Int#) (u4 :: ByteArray#) -> case u1 of { _ALG_ J# (u5 :: Int#) (u6 :: Int#) (u7 :: ByteArray#) -> case _#_ cmpInteger# [] [u2, u3, u4, u5, u6, u7] of { _PRIM_ 0# -> _!_ False [] []; (u8 :: Int#) -> _!_ True [] [] }; _NO_DEFLT_ }; _NO_DEFLT_ } _N_ #-}
+ (==) = { _A_ 2 _U_ 11 _N_ _S_ "U(PPP)U(PPP)" {_A_ 4 _U_ 2221 _N_ _N_ _F_ _IF_ARGS_ 0 4 XXXC 4 \ (u0 :: Int#) (u1 :: Int#) (u2 :: ByteArray#) (u3 :: Integer) -> case u3 of { _ALG_ J# (u4 :: Int#) (u5 :: Int#) (u6 :: ByteArray#) -> case _#_ cmpInteger# [] [u0, u1, u2, u4, u5, u6] of { _PRIM_ 0# -> _!_ True [] []; (u7 :: Int#) -> _!_ False [] [] }; _NO_DEFLT_ } _N_} _F_ _IF_ARGS_ 0 2 CC 5 \ (u0 :: Integer) (u1 :: Integer) -> case u0 of { _ALG_ J# (u2 :: Int#) (u3 :: Int#) (u4 :: ByteArray#) -> case u1 of { _ALG_ J# (u5 :: Int#) (u6 :: Int#) (u7 :: ByteArray#) -> case _#_ cmpInteger# [] [u2, u3, u4, u5, u6, u7] of { _PRIM_ 0# -> _!_ True [] []; (u8 :: Int#) -> _!_ False [] [] }; _NO_DEFLT_ }; _NO_DEFLT_ } _N_ },
+ (/=) = { _A_ 2 _U_ 11 _N_ _S_ "U(PPP)U(PPP)" {_A_ 4 _U_ 2221 _N_ _N_ _F_ _IF_ARGS_ 0 4 XXXC 4 \ (u0 :: Int#) (u1 :: Int#) (u2 :: ByteArray#) (u3 :: Integer) -> case u3 of { _ALG_ J# (u4 :: Int#) (u5 :: Int#) (u6 :: ByteArray#) -> case _#_ cmpInteger# [] [u0, u1, u2, u4, u5, u6] of { _PRIM_ 0# -> _!_ False [] []; (u7 :: Int#) -> _!_ True [] [] }; _NO_DEFLT_ } _N_} _F_ _IF_ARGS_ 0 2 CC 5 \ (u0 :: Integer) (u1 :: Integer) -> case u0 of { _ALG_ J# (u2 :: Int#) (u3 :: Int#) (u4 :: ByteArray#) -> case u1 of { _ALG_ J# (u5 :: Int#) (u6 :: Int#) (u7 :: ByteArray#) -> case _#_ cmpInteger# [] [u2, u3, u4, u5, u6, u7] of { _PRIM_ 0# -> _!_ False [] []; (u8 :: Int#) -> _!_ True [] [] }; _NO_DEFLT_ }; _NO_DEFLT_ } _N_ } #-}
instance Integral Integer
{-# GHC_PRAGMA _M_ PreludeCore {-dfun-} _A_ 0 _N_ _N_ _N_ _F_ _IF_ARGS_ 0 0 X 13 _!_ _TUP_12 [{{Real Integer}}, {{Ix Integer}}, (Integer -> Integer -> Integer), (Integer -> Integer -> Integer), (Integer -> Integer -> Integer), (Integer -> Integer -> Integer), (Integer -> Integer -> (Integer, Integer)), (Integer -> Integer -> (Integer, Integer)), (Integer -> Bool), (Integer -> Bool), (Integer -> Integer), (Integer -> Int)] [_DFUN_ Real (Integer), _DFUN_ Ix (Integer), _CONSTM_ Integral quot (Integer), _CONSTM_ Integral rem (Integer), _CONSTM_ Integral div (Integer), _CONSTM_ Integral mod (Integer), _CONSTM_ Integral quotRem (Integer), _CONSTM_ Integral divMod (Integer), _CONSTM_ Integral even (Integer), _CONSTM_ Integral odd (Integer), _CONSTM_ Integral toInteger (Integer), _CONSTM_ Integral toInt (Integer)] _N_
- quot = _A_ 2 _U_ 11 _N_ _S_ "U(PPP)U(PPP)" {_A_ 4 _U_ 2221 _N_ _N_ _F_ _IF_ARGS_ 0 4 XXXX 7 \ (u0 :: Int#) (u1 :: Int#) (u2 :: ByteArray#) (u3 :: Integer) -> case _APP_ _WRKR_ _CONSTM_ Integral quotRem (Integer) [ u0, u1, u2, u3 ] of { _ALG_ _TUP_2 (u4 :: Integer) (u5 :: Integer) -> u4; _NO_DEFLT_ } _N_} _F_ _IF_ARGS_ 0 2 XX 5 \ (u0 :: Integer) (u1 :: Integer) -> case _APP_ _CONSTM_ Integral quotRem (Integer) [ u0, u1 ] of { _ALG_ _TUP_2 (u2 :: Integer) (u3 :: Integer) -> u2; _NO_DEFLT_ } _N_,
- rem = _A_ 2 _U_ 11 _N_ _S_ "U(PPP)U(PPP)" {_A_ 4 _U_ 2221 _N_ _N_ _F_ _IF_ARGS_ 0 4 XXXX 7 \ (u0 :: Int#) (u1 :: Int#) (u2 :: ByteArray#) (u3 :: Integer) -> case _APP_ _WRKR_ _CONSTM_ Integral quotRem (Integer) [ u0, u1, u2, u3 ] of { _ALG_ _TUP_2 (u4 :: Integer) (u5 :: Integer) -> u5; _NO_DEFLT_ } _N_} _F_ _IF_ARGS_ 0 2 XX 5 \ (u0 :: Integer) (u1 :: Integer) -> case _APP_ _CONSTM_ Integral quotRem (Integer) [ u0, u1 ] of { _ALG_ _TUP_2 (u2 :: Integer) (u3 :: Integer) -> u3; _NO_DEFLT_ } _N_,
- div = _A_ 2 _U_ 12 _N_ _S_ "U(PPP)U(PPP)" {_A_ 4 _U_ 2222 _N_ _N_ _F_ _IF_ARGS_ 0 4 XXXX 7 \ (u0 :: Int#) (u1 :: Int#) (u2 :: ByteArray#) (u3 :: Integer) -> case _APP_ _WRKR_ _CONSTM_ Integral divMod (Integer) [ u0, u1, u2, u3 ] of { _ALG_ _TUP_2 (u4 :: Integer) (u5 :: Integer) -> u4; _NO_DEFLT_ } _N_} _F_ _IF_ARGS_ 0 2 XX 5 \ (u0 :: Integer) (u1 :: Integer) -> case _APP_ _CONSTM_ Integral divMod (Integer) [ u0, u1 ] of { _ALG_ _TUP_2 (u2 :: Integer) (u3 :: Integer) -> u2; _NO_DEFLT_ } _N_,
- mod = _A_ 2 _U_ 12 _N_ _S_ "U(PPP)U(PPP)" {_A_ 4 _U_ 2222 _N_ _N_ _F_ _IF_ARGS_ 0 4 XXXX 7 \ (u0 :: Int#) (u1 :: Int#) (u2 :: ByteArray#) (u3 :: Integer) -> case _APP_ _WRKR_ _CONSTM_ Integral divMod (Integer) [ u0, u1, u2, u3 ] of { _ALG_ _TUP_2 (u4 :: Integer) (u5 :: Integer) -> u5; _NO_DEFLT_ } _N_} _F_ _IF_ARGS_ 0 2 XX 5 \ (u0 :: Integer) (u1 :: Integer) -> case _APP_ _CONSTM_ Integral divMod (Integer) [ u0, u1 ] of { _ALG_ _TUP_2 (u2 :: Integer) (u3 :: Integer) -> u3; _NO_DEFLT_ } _N_,
- quotRem = _A_ 2 _U_ 11 _N_ _S_ "U(PPP)U(PPP)" {_A_ 4 _U_ 2221 _N_ _N_ _N_ _N_} _N_ _N_,
- divMod = _A_ 2 _U_ 12 _N_ _S_ "U(PPP)U(PPP)" {_A_ 4 _U_ 2222 _N_ _N_ _N_ _N_} _N_ _N_,
- even = _A_ 1 _U_ 1 _N_ _S_ "U(PPP)" {_A_ 3 _U_ 222 _N_ _N_ _N_ _N_} _N_ _N_,
- odd = _A_ 1 _U_ 1 _N_ _S_ "U(PPP)" {_A_ 3 _U_ 222 _N_ _N_ _N_ _N_} _N_ _N_,
- toInteger = _A_ 1 _U_ 1 _N_ _S_ "U(PPP)" {_A_ 3 _U_ 222 _N_ _N_ _F_ _IF_ARGS_ 0 3 XXX 4 \ (u0 :: Int#) (u1 :: Int#) (u2 :: ByteArray#) -> _!_ J# [] [u0, u1, u2] _N_} _F_ _IF_ARGS_ 0 1 X 1 \ (u0 :: Integer) -> u0 _N_,
- toInt = _A_ 1 _U_ 1 _N_ _S_ "U(PPP)" {_A_ 3 _U_ 222 _N_ _N_ _F_ _IF_ARGS_ 0 3 XXX 3 \ (u0 :: Int#) (u1 :: Int#) (u2 :: ByteArray#) -> case _#_ integer2Int# [] [u0, u1, u2] of { _PRIM_ (u3 :: Int#) -> _!_ I# [] [u3] } _N_} _F_ _IF_ARGS_ 0 1 C 4 \ (u0 :: Integer) -> case u0 of { _ALG_ J# (u1 :: Int#) (u2 :: Int#) (u3 :: ByteArray#) -> case _#_ integer2Int# [] [u1, u2, u3] of { _PRIM_ (u4 :: Int#) -> _!_ I# [] [u4] }; _NO_DEFLT_ } _N_ #-}
+ quot = { _A_ 2 _U_ 11 _N_ _S_ "U(PPP)U(PPP)" {_A_ 4 _U_ 2221 _N_ _N_ _F_ _IF_ARGS_ 0 4 XXXX 7 \ (u0 :: Int#) (u1 :: Int#) (u2 :: ByteArray#) (u3 :: Integer) -> case _APP_ _WRKR_ _CONSTM_ Integral quotRem (Integer) [ u0, u1, u2, u3 ] of { _ALG_ _TUP_2 (u4 :: Integer) (u5 :: Integer) -> u4; _NO_DEFLT_ } _N_} _F_ _IF_ARGS_ 0 2 XX 5 \ (u0 :: Integer) (u1 :: Integer) -> case _APP_ _CONSTM_ Integral quotRem (Integer) [ u0, u1 ] of { _ALG_ _TUP_2 (u2 :: Integer) (u3 :: Integer) -> u2; _NO_DEFLT_ } _N_ },
+ rem = { _A_ 2 _U_ 11 _N_ _S_ "U(PPP)U(PPP)" {_A_ 4 _U_ 2221 _N_ _N_ _F_ _IF_ARGS_ 0 4 XXXX 7 \ (u0 :: Int#) (u1 :: Int#) (u2 :: ByteArray#) (u3 :: Integer) -> case _APP_ _WRKR_ _CONSTM_ Integral quotRem (Integer) [ u0, u1, u2, u3 ] of { _ALG_ _TUP_2 (u4 :: Integer) (u5 :: Integer) -> u5; _NO_DEFLT_ } _N_} _F_ _IF_ARGS_ 0 2 XX 5 \ (u0 :: Integer) (u1 :: Integer) -> case _APP_ _CONSTM_ Integral quotRem (Integer) [ u0, u1 ] of { _ALG_ _TUP_2 (u2 :: Integer) (u3 :: Integer) -> u3; _NO_DEFLT_ } _N_ },
+ div = { _A_ 2 _U_ 12 _N_ _S_ "U(PPP)U(PPP)" {_A_ 4 _U_ 2222 _N_ _N_ _F_ _IF_ARGS_ 0 4 XXXX 7 \ (u0 :: Int#) (u1 :: Int#) (u2 :: ByteArray#) (u3 :: Integer) -> case _APP_ _WRKR_ _CONSTM_ Integral divMod (Integer) [ u0, u1, u2, u3 ] of { _ALG_ _TUP_2 (u4 :: Integer) (u5 :: Integer) -> u4; _NO_DEFLT_ } _N_} _F_ _IF_ARGS_ 0 2 XX 5 \ (u0 :: Integer) (u1 :: Integer) -> case _APP_ _CONSTM_ Integral divMod (Integer) [ u0, u1 ] of { _ALG_ _TUP_2 (u2 :: Integer) (u3 :: Integer) -> u2; _NO_DEFLT_ } _N_ },
+ mod = { _A_ 2 _U_ 12 _N_ _S_ "U(PPP)U(PPP)" {_A_ 4 _U_ 2222 _N_ _N_ _F_ _IF_ARGS_ 0 4 XXXX 7 \ (u0 :: Int#) (u1 :: Int#) (u2 :: ByteArray#) (u3 :: Integer) -> case _APP_ _WRKR_ _CONSTM_ Integral divMod (Integer) [ u0, u1, u2, u3 ] of { _ALG_ _TUP_2 (u4 :: Integer) (u5 :: Integer) -> u5; _NO_DEFLT_ } _N_} _F_ _IF_ARGS_ 0 2 XX 5 \ (u0 :: Integer) (u1 :: Integer) -> case _APP_ _CONSTM_ Integral divMod (Integer) [ u0, u1 ] of { _ALG_ _TUP_2 (u2 :: Integer) (u3 :: Integer) -> u3; _NO_DEFLT_ } _N_ },
+ quotRem = { _A_ 2 _U_ 11 _N_ _S_ "U(PPP)U(PPP)" {_A_ 4 _U_ 2221 _N_ _N_ _N_ _N_} _N_ _N_ },
+ divMod = { _A_ 2 _U_ 12 _N_ _S_ "U(PPP)U(PPP)" {_A_ 4 _U_ 2222 _N_ _N_ _N_ _N_} _N_ _N_ },
+ even = { _A_ 1 _U_ 1 _N_ _S_ "U(PPP)" {_A_ 3 _U_ 222 _N_ _N_ _N_ _N_} _N_ _N_ },
+ odd = { _A_ 1 _U_ 1 _N_ _S_ "U(PPP)" {_A_ 3 _U_ 222 _N_ _N_ _N_ _N_} _N_ _N_ },
+ toInteger = { _A_ 1 _U_ 1 _N_ _S_ "U(PPP)" {_A_ 3 _U_ 222 _N_ _N_ _F_ _IF_ARGS_ 0 3 XXX 4 \ (u0 :: Int#) (u1 :: Int#) (u2 :: ByteArray#) -> _!_ J# [] [u0, u1, u2] _N_} _F_ _IF_ARGS_ 0 1 X 1 \ (u0 :: Integer) -> u0 _N_ },
+ toInt = { _A_ 1 _U_ 1 _N_ _S_ "U(PPP)" {_A_ 3 _U_ 222 _N_ _N_ _F_ _IF_ARGS_ 0 3 XXX 3 \ (u0 :: Int#) (u1 :: Int#) (u2 :: ByteArray#) -> case _#_ integer2Int# [] [u0, u1, u2] of { _PRIM_ (u3 :: Int#) -> _!_ I# [] [u3] } _N_} _F_ _IF_ARGS_ 0 1 C 4 \ (u0 :: Integer) -> case u0 of { _ALG_ J# (u1 :: Int#) (u2 :: Int#) (u3 :: ByteArray#) -> case _#_ integer2Int# [] [u1, u2, u3] of { _PRIM_ (u4 :: Int#) -> _!_ I# [] [u4] }; _NO_DEFLT_ } _N_ } #-}
instance Ix Integer
{-# GHC_PRAGMA _M_ PreludeCore {-dfun-} _A_ 0 _N_ _N_ _N_ _F_ _IF_ARGS_ 0 0 X 5 _!_ _TUP_4 [{{Ord Integer}}, ((Integer, Integer) -> [Integer]), ((Integer, Integer) -> Integer -> Int), ((Integer, Integer) -> Integer -> Bool)] [_DFUN_ Ord (Integer), _CONSTM_ Ix range (Integer), _CONSTM_ Ix index (Integer), _CONSTM_ Ix inRange (Integer)] _N_
- range = _A_ 1 _U_ 1 _N_ _S_ "U(LL)" {_A_ 2 _U_ 22 _N_ _N_ _F_ _IF_ARGS_ 0 0 X 1 _CONSTM_ Enum enumFromTo (Integer) _N_} _F_ _IF_ARGS_ 0 1 C 4 \ (u0 :: (Integer, Integer)) -> case u0 of { _ALG_ _TUP_2 (u1 :: Integer) (u2 :: Integer) -> _APP_ _CONSTM_ Enum enumFromTo (Integer) [ u1, u2 ]; _NO_DEFLT_ } _N_,
- index = _A_ 2 _U_ 12 _N_ _S_ "U(U(PPP)L)U(PPP)" {_A_ 5 _U_ 22222 _N_ _N_ _N_ _N_} _N_ _N_,
- inRange = _A_ 2 _U_ 11 _N_ _S_ "U(U(PPP)L)U(PPP)" {_A_ 5 _U_ 22211 _N_ _N_ _F_ _IF_ARGS_ 0 5 XXXCC 9 \ (u0 :: Int#) (u1 :: Int#) (u2 :: ByteArray#) (u3 :: Integer) (u4 :: Integer) -> case u4 of { _ALG_ J# (u5 :: Int#) (u6 :: Int#) (u7 :: ByteArray#) -> case _#_ cmpInteger# [] [u0, u1, u2, u5, u6, u7] of { _PRIM_ (u8 :: Int#) -> case _#_ leInt# [] [u8, 0#] of { _ALG_ True -> case u3 of { _ALG_ J# (u9 :: Int#) (ua :: Int#) (ub :: ByteArray#) -> case _#_ cmpInteger# [] [u5, u6, u7, u9, ua, ub] of { _PRIM_ (uc :: Int#) -> _#_ leInt# [] [uc, 0#] }; _NO_DEFLT_ }; False -> _!_ False [] []; _NO_DEFLT_ } }; _NO_DEFLT_ } _N_} _N_ _N_ #-}
+ range = { _A_ 1 _U_ 1 _N_ _S_ "U(LL)" {_A_ 2 _U_ 22 _N_ _N_ _F_ _IF_ARGS_ 0 0 X 1 _CONSTM_ Enum enumFromTo (Integer) _N_} _F_ _IF_ARGS_ 0 1 C 4 \ (u0 :: (Integer, Integer)) -> case u0 of { _ALG_ _TUP_2 (u1 :: Integer) (u2 :: Integer) -> _APP_ _CONSTM_ Enum enumFromTo (Integer) [ u1, u2 ]; _NO_DEFLT_ } _N_ },
+ index = { _A_ 2 _U_ 12 _N_ _S_ "U(U(PPP)L)U(PPP)" {_A_ 5 _U_ 22222 _N_ _N_ _N_ _N_} _N_ _N_ },
+ inRange = { _A_ 2 _U_ 11 _N_ _S_ "U(U(PPP)L)U(PPP)" {_A_ 5 _U_ 22211 _N_ _N_ _F_ _IF_ARGS_ 0 5 XXXCC 9 \ (u0 :: Int#) (u1 :: Int#) (u2 :: ByteArray#) (u3 :: Integer) (u4 :: Integer) -> case u4 of { _ALG_ J# (u5 :: Int#) (u6 :: Int#) (u7 :: ByteArray#) -> case _#_ cmpInteger# [] [u0, u1, u2, u5, u6, u7] of { _PRIM_ (u8 :: Int#) -> case _#_ leInt# [] [u8, 0#] of { _ALG_ True -> case u3 of { _ALG_ J# (u9 :: Int#) (ua :: Int#) (ub :: ByteArray#) -> case _#_ cmpInteger# [] [u5, u6, u7, u9, ua, ub] of { _PRIM_ (uc :: Int#) -> _#_ leInt# [] [uc, 0#] }; _NO_DEFLT_ }; False -> _!_ False [] []; _NO_DEFLT_ } }; _NO_DEFLT_ } _N_} _N_ _N_ } #-}
instance Num Integer
{-# GHC_PRAGMA _M_ PreludeCore {-dfun-} _A_ 0 _N_ _N_ _N_ _F_ _IF_ARGS_ 0 0 X 11 _!_ _TUP_10 [{{Eq Integer}}, {{Text Integer}}, (Integer -> Integer -> Integer), (Integer -> Integer -> Integer), (Integer -> Integer -> Integer), (Integer -> Integer), (Integer -> Integer), (Integer -> Integer), (Integer -> Integer), (Int -> Integer)] [_DFUN_ Eq (Integer), _DFUN_ Text (Integer), _CONSTM_ Num (+) (Integer), _CONSTM_ Num (-) (Integer), _CONSTM_ Num (*) (Integer), _CONSTM_ Num negate (Integer), _CONSTM_ Num abs (Integer), _CONSTM_ Num signum (Integer), _CONSTM_ Num fromInteger (Integer), _CONSTM_ Num fromInt (Integer)] _N_
- (+) = _A_ 2 _U_ 11 _N_ _S_ "U(PPP)U(PPP)" {_A_ 4 _U_ 2221 _N_ _N_ _F_ _IF_ARGS_ 0 4 XXXC 5 \ (u0 :: Int#) (u1 :: Int#) (u2 :: ByteArray#) (u3 :: Integer) -> case u3 of { _ALG_ J# (u4 :: Int#) (u5 :: Int#) (u6 :: ByteArray#) -> _#_ plusInteger# [] [u0, u1, u2, u4, u5, u6]; _NO_DEFLT_ } _N_} _F_ _IF_ARGS_ 0 2 CC 6 \ (u0 :: Integer) (u1 :: Integer) -> case u0 of { _ALG_ J# (u2 :: Int#) (u3 :: Int#) (u4 :: ByteArray#) -> case u1 of { _ALG_ J# (u5 :: Int#) (u6 :: Int#) (u7 :: ByteArray#) -> _#_ plusInteger# [] [u2, u3, u4, u5, u6, u7]; _NO_DEFLT_ }; _NO_DEFLT_ } _N_,
- (-) = _A_ 2 _U_ 11 _N_ _S_ "U(PPP)U(PPP)" {_A_ 4 _U_ 2221 _N_ _N_ _F_ _IF_ARGS_ 0 4 XXXC 5 \ (u0 :: Int#) (u1 :: Int#) (u2 :: ByteArray#) (u3 :: Integer) -> case u3 of { _ALG_ J# (u4 :: Int#) (u5 :: Int#) (u6 :: ByteArray#) -> _#_ minusInteger# [] [u0, u1, u2, u4, u5, u6]; _NO_DEFLT_ } _N_} _F_ _IF_ARGS_ 0 2 CC 6 \ (u0 :: Integer) (u1 :: Integer) -> case u0 of { _ALG_ J# (u2 :: Int#) (u3 :: Int#) (u4 :: ByteArray#) -> case u1 of { _ALG_ J# (u5 :: Int#) (u6 :: Int#) (u7 :: ByteArray#) -> _#_ minusInteger# [] [u2, u3, u4, u5, u6, u7]; _NO_DEFLT_ }; _NO_DEFLT_ } _N_,
- (*) = _A_ 2 _U_ 11 _N_ _S_ "U(PPP)U(PPP)" {_A_ 4 _U_ 2221 _N_ _N_ _F_ _IF_ARGS_ 0 4 XXXC 5 \ (u0 :: Int#) (u1 :: Int#) (u2 :: ByteArray#) (u3 :: Integer) -> case u3 of { _ALG_ J# (u4 :: Int#) (u5 :: Int#) (u6 :: ByteArray#) -> _#_ timesInteger# [] [u0, u1, u2, u4, u5, u6]; _NO_DEFLT_ } _N_} _F_ _IF_ARGS_ 0 2 CC 6 \ (u0 :: Integer) (u1 :: Integer) -> case u0 of { _ALG_ J# (u2 :: Int#) (u3 :: Int#) (u4 :: ByteArray#) -> case u1 of { _ALG_ J# (u5 :: Int#) (u6 :: Int#) (u7 :: ByteArray#) -> _#_ timesInteger# [] [u2, u3, u4, u5, u6, u7]; _NO_DEFLT_ }; _NO_DEFLT_ } _N_,
- negate = _A_ 1 _U_ 1 _N_ _S_ "U(PPP)" {_A_ 3 _U_ 222 _N_ _N_ _F_ _IF_ARGS_ 0 3 XXX 4 \ (u0 :: Int#) (u1 :: Int#) (u2 :: ByteArray#) -> _#_ negateInteger# [] [u0, u1, u2] _N_} _F_ _IF_ARGS_ 0 1 C 5 \ (u0 :: Integer) -> case u0 of { _ALG_ J# (u1 :: Int#) (u2 :: Int#) (u3 :: ByteArray#) -> _#_ negateInteger# [] [u1, u2, u3]; _NO_DEFLT_ } _N_,
- abs = _A_ 1 _U_ 1 _N_ _S_ "U(PPP)" {_A_ 3 _U_ 222 _N_ _N_ _N_ _N_} _N_ _N_,
- signum = _A_ 1 _U_ 1 _N_ _S_ "U(PPP)" {_A_ 3 _U_ 222 _N_ _N_ _N_ _N_} _N_ _N_,
- fromInteger = _A_ 1 _U_ 1 _N_ _S_ "U(PPP)" {_A_ 3 _U_ 222 _N_ _N_ _F_ _IF_ARGS_ 0 3 XXX 4 \ (u0 :: Int#) (u1 :: Int#) (u2 :: ByteArray#) -> _!_ J# [] [u0, u1, u2] _N_} _F_ _IF_ARGS_ 0 1 X 1 \ (u0 :: Integer) -> u0 _N_,
- fromInt = _A_ 1 _U_ 1 _N_ _S_ "U(P)" {_A_ 1 _U_ 2 _N_ _N_ _F_ _IF_ARGS_ 0 1 X 1 \ (u0 :: Int#) -> _#_ int2Integer# [] [u0] _N_} _F_ _IF_ARGS_ 0 1 C 2 \ (u0 :: Int) -> case u0 of { _ALG_ I# (u1 :: Int#) -> _#_ int2Integer# [] [u1]; _NO_DEFLT_ } _N_ #-}
+ (+) = { _A_ 2 _U_ 11 _N_ _S_ "U(PPP)U(PPP)" {_A_ 4 _U_ 2221 _N_ _N_ _F_ _IF_ARGS_ 0 4 XXXC 5 \ (u0 :: Int#) (u1 :: Int#) (u2 :: ByteArray#) (u3 :: Integer) -> case u3 of { _ALG_ J# (u4 :: Int#) (u5 :: Int#) (u6 :: ByteArray#) -> _#_ plusInteger# [] [u0, u1, u2, u4, u5, u6]; _NO_DEFLT_ } _N_} _F_ _IF_ARGS_ 0 2 CC 6 \ (u0 :: Integer) (u1 :: Integer) -> case u0 of { _ALG_ J# (u2 :: Int#) (u3 :: Int#) (u4 :: ByteArray#) -> case u1 of { _ALG_ J# (u5 :: Int#) (u6 :: Int#) (u7 :: ByteArray#) -> _#_ plusInteger# [] [u2, u3, u4, u5, u6, u7]; _NO_DEFLT_ }; _NO_DEFLT_ } _N_ },
+ (-) = { _A_ 2 _U_ 11 _N_ _S_ "U(PPP)U(PPP)" {_A_ 4 _U_ 2221 _N_ _N_ _F_ _IF_ARGS_ 0 4 XXXC 5 \ (u0 :: Int#) (u1 :: Int#) (u2 :: ByteArray#) (u3 :: Integer) -> case u3 of { _ALG_ J# (u4 :: Int#) (u5 :: Int#) (u6 :: ByteArray#) -> _#_ minusInteger# [] [u0, u1, u2, u4, u5, u6]; _NO_DEFLT_ } _N_} _F_ _IF_ARGS_ 0 2 CC 6 \ (u0 :: Integer) (u1 :: Integer) -> case u0 of { _ALG_ J# (u2 :: Int#) (u3 :: Int#) (u4 :: ByteArray#) -> case u1 of { _ALG_ J# (u5 :: Int#) (u6 :: Int#) (u7 :: ByteArray#) -> _#_ minusInteger# [] [u2, u3, u4, u5, u6, u7]; _NO_DEFLT_ }; _NO_DEFLT_ } _N_ },
+ (*) = { _A_ 2 _U_ 11 _N_ _S_ "U(PPP)U(PPP)" {_A_ 4 _U_ 2221 _N_ _N_ _F_ _IF_ARGS_ 0 4 XXXC 5 \ (u0 :: Int#) (u1 :: Int#) (u2 :: ByteArray#) (u3 :: Integer) -> case u3 of { _ALG_ J# (u4 :: Int#) (u5 :: Int#) (u6 :: ByteArray#) -> _#_ timesInteger# [] [u0, u1, u2, u4, u5, u6]; _NO_DEFLT_ } _N_} _F_ _IF_ARGS_ 0 2 CC 6 \ (u0 :: Integer) (u1 :: Integer) -> case u0 of { _ALG_ J# (u2 :: Int#) (u3 :: Int#) (u4 :: ByteArray#) -> case u1 of { _ALG_ J# (u5 :: Int#) (u6 :: Int#) (u7 :: ByteArray#) -> _#_ timesInteger# [] [u2, u3, u4, u5, u6, u7]; _NO_DEFLT_ }; _NO_DEFLT_ } _N_ },
+ negate = { _A_ 1 _U_ 1 _N_ _S_ "U(PPP)" {_A_ 3 _U_ 222 _N_ _N_ _F_ _IF_ARGS_ 0 3 XXX 4 \ (u0 :: Int#) (u1 :: Int#) (u2 :: ByteArray#) -> _#_ negateInteger# [] [u0, u1, u2] _N_} _F_ _IF_ARGS_ 0 1 C 5 \ (u0 :: Integer) -> case u0 of { _ALG_ J# (u1 :: Int#) (u2 :: Int#) (u3 :: ByteArray#) -> _#_ negateInteger# [] [u1, u2, u3]; _NO_DEFLT_ } _N_ },
+ abs = { _A_ 1 _U_ 1 _N_ _S_ "U(PPP)" {_A_ 3 _U_ 222 _N_ _N_ _N_ _N_} _N_ _N_ },
+ signum = { _A_ 1 _U_ 1 _N_ _S_ "U(PPP)" {_A_ 3 _U_ 222 _N_ _N_ _N_ _N_} _N_ _N_ },
+ fromInteger = { _A_ 1 _U_ 1 _N_ _S_ "U(PPP)" {_A_ 3 _U_ 222 _N_ _N_ _F_ _IF_ARGS_ 0 3 XXX 4 \ (u0 :: Int#) (u1 :: Int#) (u2 :: ByteArray#) -> _!_ J# [] [u0, u1, u2] _N_} _F_ _IF_ARGS_ 0 1 X 1 \ (u0 :: Integer) -> u0 _N_ },
+ fromInt = { _A_ 1 _U_ 1 _N_ _S_ "U(P)" {_A_ 1 _U_ 2 _N_ _N_ _F_ _IF_ARGS_ 0 1 X 1 \ (u0 :: Int#) -> _#_ int2Integer# [] [u0] _N_} _F_ _IF_ARGS_ 0 1 C 2 \ (u0 :: Int) -> case u0 of { _ALG_ I# (u1 :: Int#) -> _#_ int2Integer# [] [u1]; _NO_DEFLT_ } _N_ } #-}
instance Ord Integer
{-# GHC_PRAGMA _M_ PreludeCore {-dfun-} _A_ 0 _N_ _N_ _N_ _F_ _IF_ARGS_ 0 0 X 9 _!_ _TUP_8 [{{Eq Integer}}, (Integer -> Integer -> Bool), (Integer -> Integer -> Bool), (Integer -> Integer -> Bool), (Integer -> Integer -> Bool), (Integer -> Integer -> Integer), (Integer -> Integer -> Integer), (Integer -> Integer -> _CMP_TAG)] [_DFUN_ Eq (Integer), _CONSTM_ Ord (<) (Integer), _CONSTM_ Ord (<=) (Integer), _CONSTM_ Ord (>=) (Integer), _CONSTM_ Ord (>) (Integer), _CONSTM_ Ord max (Integer), _CONSTM_ Ord min (Integer), _CONSTM_ Ord _tagCmp (Integer)] _N_
- (<) = _A_ 2 _U_ 11 _N_ _S_ "U(PPP)U(PPP)" {_A_ 4 _U_ 2221 _N_ _N_ _F_ _IF_ARGS_ 0 4 XXXC 3 \ (u0 :: Int#) (u1 :: Int#) (u2 :: ByteArray#) (u3 :: Integer) -> case u3 of { _ALG_ J# (u4 :: Int#) (u5 :: Int#) (u6 :: ByteArray#) -> case _#_ cmpInteger# [] [u0, u1, u2, u4, u5, u6] of { _PRIM_ (u7 :: Int#) -> _#_ ltInt# [] [u7, 0#] }; _NO_DEFLT_ } _N_} _F_ _IF_ARGS_ 0 2 CC 4 \ (u0 :: Integer) (u1 :: Integer) -> case u0 of { _ALG_ J# (u2 :: Int#) (u3 :: Int#) (u4 :: ByteArray#) -> case u1 of { _ALG_ J# (u5 :: Int#) (u6 :: Int#) (u7 :: ByteArray#) -> case _#_ cmpInteger# [] [u2, u3, u4, u5, u6, u7] of { _PRIM_ (u8 :: Int#) -> _#_ ltInt# [] [u8, 0#] }; _NO_DEFLT_ }; _NO_DEFLT_ } _N_,
- (<=) = _A_ 2 _U_ 11 _N_ _S_ "U(PPP)U(PPP)" {_A_ 4 _U_ 2221 _N_ _N_ _F_ _IF_ARGS_ 0 4 XXXC 3 \ (u0 :: Int#) (u1 :: Int#) (u2 :: ByteArray#) (u3 :: Integer) -> case u3 of { _ALG_ J# (u4 :: Int#) (u5 :: Int#) (u6 :: ByteArray#) -> case _#_ cmpInteger# [] [u0, u1, u2, u4, u5, u6] of { _PRIM_ (u7 :: Int#) -> _#_ leInt# [] [u7, 0#] }; _NO_DEFLT_ } _N_} _F_ _IF_ARGS_ 0 2 CC 4 \ (u0 :: Integer) (u1 :: Integer) -> case u0 of { _ALG_ J# (u2 :: Int#) (u3 :: Int#) (u4 :: ByteArray#) -> case u1 of { _ALG_ J# (u5 :: Int#) (u6 :: Int#) (u7 :: ByteArray#) -> case _#_ cmpInteger# [] [u2, u3, u4, u5, u6, u7] of { _PRIM_ (u8 :: Int#) -> _#_ leInt# [] [u8, 0#] }; _NO_DEFLT_ }; _NO_DEFLT_ } _N_,
- (>=) = _A_ 2 _U_ 11 _N_ _S_ "U(PPP)U(PPP)" {_A_ 4 _U_ 2221 _N_ _N_ _F_ _IF_ARGS_ 0 4 XXXC 3 \ (u0 :: Int#) (u1 :: Int#) (u2 :: ByteArray#) (u3 :: Integer) -> case u3 of { _ALG_ J# (u4 :: Int#) (u5 :: Int#) (u6 :: ByteArray#) -> case _#_ cmpInteger# [] [u0, u1, u2, u4, u5, u6] of { _PRIM_ (u7 :: Int#) -> _#_ geInt# [] [u7, 0#] }; _NO_DEFLT_ } _N_} _F_ _IF_ARGS_ 0 2 CC 4 \ (u0 :: Integer) (u1 :: Integer) -> case u0 of { _ALG_ J# (u2 :: Int#) (u3 :: Int#) (u4 :: ByteArray#) -> case u1 of { _ALG_ J# (u5 :: Int#) (u6 :: Int#) (u7 :: ByteArray#) -> case _#_ cmpInteger# [] [u2, u3, u4, u5, u6, u7] of { _PRIM_ (u8 :: Int#) -> _#_ geInt# [] [u8, 0#] }; _NO_DEFLT_ }; _NO_DEFLT_ } _N_,
- (>) = _A_ 2 _U_ 11 _N_ _S_ "U(PPP)U(PPP)" {_A_ 4 _U_ 2221 _N_ _N_ _F_ _IF_ARGS_ 0 4 XXXC 3 \ (u0 :: Int#) (u1 :: Int#) (u2 :: ByteArray#) (u3 :: Integer) -> case u3 of { _ALG_ J# (u4 :: Int#) (u5 :: Int#) (u6 :: ByteArray#) -> case _#_ cmpInteger# [] [u0, u1, u2, u4, u5, u6] of { _PRIM_ (u7 :: Int#) -> _#_ gtInt# [] [u7, 0#] }; _NO_DEFLT_ } _N_} _F_ _IF_ARGS_ 0 2 CC 4 \ (u0 :: Integer) (u1 :: Integer) -> case u0 of { _ALG_ J# (u2 :: Int#) (u3 :: Int#) (u4 :: ByteArray#) -> case u1 of { _ALG_ J# (u5 :: Int#) (u6 :: Int#) (u7 :: ByteArray#) -> case _#_ cmpInteger# [] [u2, u3, u4, u5, u6, u7] of { _PRIM_ (u8 :: Int#) -> _#_ gtInt# [] [u8, 0#] }; _NO_DEFLT_ }; _NO_DEFLT_ } _N_,
- max = _A_ 2 _U_ 11 _N_ _S_ "U(PPP)U(PPP)" {_A_ 4 _U_ 2221 _N_ _N_ _N_ _N_} _N_ _N_,
- min = _A_ 2 _U_ 11 _N_ _S_ "U(PPP)U(PPP)" {_A_ 4 _U_ 2221 _N_ _N_ _N_ _N_} _N_ _N_,
- _tagCmp = _A_ 2 _U_ 11 _N_ _S_ "U(PPP)U(PPP)" {_A_ 4 _U_ 2221 _N_ _N_ _N_ _N_} _N_ _N_ #-}
+ (<) = { _A_ 2 _U_ 11 _N_ _S_ "U(PPP)U(PPP)" {_A_ 4 _U_ 2221 _N_ _N_ _F_ _IF_ARGS_ 0 4 XXXC 3 \ (u0 :: Int#) (u1 :: Int#) (u2 :: ByteArray#) (u3 :: Integer) -> case u3 of { _ALG_ J# (u4 :: Int#) (u5 :: Int#) (u6 :: ByteArray#) -> case _#_ cmpInteger# [] [u0, u1, u2, u4, u5, u6] of { _PRIM_ (u7 :: Int#) -> _#_ ltInt# [] [u7, 0#] }; _NO_DEFLT_ } _N_} _F_ _IF_ARGS_ 0 2 CC 4 \ (u0 :: Integer) (u1 :: Integer) -> case u0 of { _ALG_ J# (u2 :: Int#) (u3 :: Int#) (u4 :: ByteArray#) -> case u1 of { _ALG_ J# (u5 :: Int#) (u6 :: Int#) (u7 :: ByteArray#) -> case _#_ cmpInteger# [] [u2, u3, u4, u5, u6, u7] of { _PRIM_ (u8 :: Int#) -> _#_ ltInt# [] [u8, 0#] }; _NO_DEFLT_ }; _NO_DEFLT_ } _N_ },
+ (<=) = { _A_ 2 _U_ 11 _N_ _S_ "U(PPP)U(PPP)" {_A_ 4 _U_ 2221 _N_ _N_ _F_ _IF_ARGS_ 0 4 XXXC 3 \ (u0 :: Int#) (u1 :: Int#) (u2 :: ByteArray#) (u3 :: Integer) -> case u3 of { _ALG_ J# (u4 :: Int#) (u5 :: Int#) (u6 :: ByteArray#) -> case _#_ cmpInteger# [] [u0, u1, u2, u4, u5, u6] of { _PRIM_ (u7 :: Int#) -> _#_ leInt# [] [u7, 0#] }; _NO_DEFLT_ } _N_} _F_ _IF_ARGS_ 0 2 CC 4 \ (u0 :: Integer) (u1 :: Integer) -> case u0 of { _ALG_ J# (u2 :: Int#) (u3 :: Int#) (u4 :: ByteArray#) -> case u1 of { _ALG_ J# (u5 :: Int#) (u6 :: Int#) (u7 :: ByteArray#) -> case _#_ cmpInteger# [] [u2, u3, u4, u5, u6, u7] of { _PRIM_ (u8 :: Int#) -> _#_ leInt# [] [u8, 0#] }; _NO_DEFLT_ }; _NO_DEFLT_ } _N_ },
+ (>=) = { _A_ 2 _U_ 11 _N_ _S_ "U(PPP)U(PPP)" {_A_ 4 _U_ 2221 _N_ _N_ _F_ _IF_ARGS_ 0 4 XXXC 3 \ (u0 :: Int#) (u1 :: Int#) (u2 :: ByteArray#) (u3 :: Integer) -> case u3 of { _ALG_ J# (u4 :: Int#) (u5 :: Int#) (u6 :: ByteArray#) -> case _#_ cmpInteger# [] [u0, u1, u2, u4, u5, u6] of { _PRIM_ (u7 :: Int#) -> _#_ geInt# [] [u7, 0#] }; _NO_DEFLT_ } _N_} _F_ _IF_ARGS_ 0 2 CC 4 \ (u0 :: Integer) (u1 :: Integer) -> case u0 of { _ALG_ J# (u2 :: Int#) (u3 :: Int#) (u4 :: ByteArray#) -> case u1 of { _ALG_ J# (u5 :: Int#) (u6 :: Int#) (u7 :: ByteArray#) -> case _#_ cmpInteger# [] [u2, u3, u4, u5, u6, u7] of { _PRIM_ (u8 :: Int#) -> _#_ geInt# [] [u8, 0#] }; _NO_DEFLT_ }; _NO_DEFLT_ } _N_ },
+ (>) = { _A_ 2 _U_ 11 _N_ _S_ "U(PPP)U(PPP)" {_A_ 4 _U_ 2221 _N_ _N_ _F_ _IF_ARGS_ 0 4 XXXC 3 \ (u0 :: Int#) (u1 :: Int#) (u2 :: ByteArray#) (u3 :: Integer) -> case u3 of { _ALG_ J# (u4 :: Int#) (u5 :: Int#) (u6 :: ByteArray#) -> case _#_ cmpInteger# [] [u0, u1, u2, u4, u5, u6] of { _PRIM_ (u7 :: Int#) -> _#_ gtInt# [] [u7, 0#] }; _NO_DEFLT_ } _N_} _F_ _IF_ARGS_ 0 2 CC 4 \ (u0 :: Integer) (u1 :: Integer) -> case u0 of { _ALG_ J# (u2 :: Int#) (u3 :: Int#) (u4 :: ByteArray#) -> case u1 of { _ALG_ J# (u5 :: Int#) (u6 :: Int#) (u7 :: ByteArray#) -> case _#_ cmpInteger# [] [u2, u3, u4, u5, u6, u7] of { _PRIM_ (u8 :: Int#) -> _#_ gtInt# [] [u8, 0#] }; _NO_DEFLT_ }; _NO_DEFLT_ } _N_ },
+ max = { _A_ 2 _U_ 11 _N_ _S_ "U(PPP)U(PPP)" {_A_ 4 _U_ 2221 _N_ _N_ _N_ _N_} _N_ _N_ },
+ min = { _A_ 2 _U_ 11 _N_ _S_ "U(PPP)U(PPP)" {_A_ 4 _U_ 2221 _N_ _N_ _N_ _N_} _N_ _N_ },
+ _tagCmp = { _A_ 2 _U_ 11 _N_ _S_ "U(PPP)U(PPP)" {_A_ 4 _U_ 2221 _N_ _N_ _N_ _N_} _N_ _N_ } #-}
instance Real Integer
{-# GHC_PRAGMA _M_ PreludeCore {-dfun-} _A_ 0 _N_ _N_ _N_ _F_ _IF_ARGS_ 0 0 X 4 _!_ _TUP_3 [{{Num Integer}}, {{Enum Integer}}, (Integer -> Ratio Integer)] [_DFUN_ Num (Integer), _DFUN_ Enum (Integer), _CONSTM_ Real toRational (Integer)] _N_
- toRational = _A_ 1 _U_ 2 _N_ _N_ _N_ _N_ #-}
+ toRational = { _A_ 1 _U_ 2 _N_ _N_ _F_ _IF_ARGS_ 0 1 X 3 \ (u0 :: Integer) -> _!_ (:%) [Integer] [u0, _ORIG_ PreludeCore __integer1] _N_ } #-}
instance Text Integer
{-# GHC_PRAGMA _M_ PreludeCore {-dfun-} _A_ 0 _N_ _N_ _N_ _F_ _IF_ARGS_ 0 0 X 5 _!_ _TUP_4 [(Int -> [Char] -> [(Integer, [Char])]), (Int -> Integer -> [Char] -> [Char]), ([Char] -> [([Integer], [Char])]), ([Integer] -> [Char] -> [Char])] [_CONSTM_ Text readsPrec (Integer), _CONSTM_ Text showsPrec (Integer), _CONSTM_ Text readList (Integer), _CONSTM_ Text showList (Integer)] _N_
- readsPrec = _A_ 2 _U_ 02 _N_ _S_ "AL" {_A_ 1 _U_ 2 _N_ _N_ _F_ _IF_ARGS_ 0 1 X 3 \ (u0 :: [Char]) -> _APP_ _SPEC_ _ORIG_ PreludeText readSigned [ (Integer) ] [ _SPEC_ _ORIG_ PreludeText readDec [ (Integer) ], u0 ] _N_} _F_ _IF_ARGS_ 0 2 XX 3 \ (u0 :: Int) (u1 :: [Char]) -> _APP_ _SPEC_ _ORIG_ PreludeText readSigned [ (Integer) ] [ _SPEC_ _ORIG_ PreludeText readDec [ (Integer) ], u1 ] _N_,
- showsPrec = _A_ 3 _U_ 212 _N_ _S_ "LU(PPP)L" {_A_ 5 _U_ 22222 _N_ _N_ _N_ _N_} _N_ _N_,
- readList = _A_ 0 _U_ 2 _N_ _N_ _N_ _N_,
- showList = _A_ 0 _U_ 12 _N_ _N_ _N_ _N_ #-}
+ readsPrec = { _A_ 2 _U_ 02 _N_ _S_ "AL" {_A_ 1 _U_ 2 _N_ _N_ _F_ _IF_ARGS_ 0 1 X 3 \ (u0 :: [Char]) -> _APP_ _SPEC_ _ORIG_ PreludeText readSigned [ (Integer) ] [ _SPEC_ _ORIG_ PreludeText readDec [ (Integer) ], u0 ] _N_} _F_ _IF_ARGS_ 0 2 XX 3 \ (u0 :: Int) (u1 :: [Char]) -> _APP_ _SPEC_ _ORIG_ PreludeText readSigned [ (Integer) ] [ _SPEC_ _ORIG_ PreludeText readDec [ (Integer) ], u1 ] _N_ },
+ showsPrec = { _A_ 3 _U_ 212 _N_ _S_ "LU(PPP)L" {_A_ 5 _U_ 22222 _N_ _N_ _N_ _N_} _N_ _N_ },
+ readList = { _A_ 0 _U_ 2 _N_ _N_ _N_ _N_ },
+ showList = { _A_ 1 _U_ 12 _N_ _N_ _N_ _N_ } #-}
module PreludeCore (
Integer(..),
- int2Integer,
- _integer_0, _integer_1, _integer_m1
+ __integer0, -- These names must match those in PrelVals.hs
+ __integer1,
+ __integer2,
+ __integerm1
) where
import Cls
import IInt
import IRatio ( (%) )
import ITup2 -- instances
-import List ( (++), foldr )
+import List ( (++), foldr, takeWhile )
import Prel ( not, otherwise, (&&) )
import PS ( _PackedString, _unpackPS )
import Text
+import TyArray
+import TyComplex
------------------------------------------------------
--- a magical Integer-ish function that
--- the compiler inserts references to
+-- useful constants
-int2Integer :: Int -> Integer
-int2Integer (I# i#) = int2Integer# i#
+__integer0, __integer1, __integer2, __integerm1 :: Integer
-------------------------------------------------------
--- some *very* heavily-used constants
-
-_integer_0, _integer_1, _integer_m1 :: Integer
-_integer_0 = 0
-_integer_1 = 1
-_integer_m1 = (-1)
+__integer0 = fromInt 0
+__integer1 = fromInt 1
+__integer2 = fromInt 2
+__integerm1 = fromInt (-1)
------------------------------------------------------
-- ORIG: abs n = if n >= 0 then n else -n
abs n@(J# a1 s1 d1)
- = case _integer_0 of { J# a2 s2 d2 ->
+ = case __integer0 of { J# a2 s2 d2 ->
if (cmpInteger# a1 s1 d1 a2 s2 d2) >=# 0#
then n
else negateInteger# a1 s1 d1
-}
signum n@(J# a1 s1 d1)
- = case _integer_0 of { J# a2 s2 d2 ->
+ = case __integer0 of { J# a2 s2 d2 ->
let
cmp = cmpInteger# a1 s1 d1 a2 s2 d2
in
- if cmp ># 0# then _integer_1
- else if cmp ==# 0# then _integer_0
- else _integer_m1
+ if cmp ># 0# then __integer1
+ else if cmp ==# 0# then __integer0
+ else __integerm1
}
fromInteger x = x
fromInt (I# n#) = int2Integer# n# -- gives back a full-blown Integer
instance Real Integer where
- toRational x = x % 1
+ toRational x = x :% __integer1
instance Integral Integer where
quotRem (J# a1 s1 d1) (J# a2 s2 d2)
n `mod` d = r where (q,r) = divMod n d
divMod n d = case (quotRem n d) of { qr@(q,r) ->
- if signum r == - signum d then (q-1, r+d) else qr }
+ if signum r == - signum d then (q - __integer1, r+d) else qr }
-- Case-ified by WDP 94/10
- even x = (==) (rem x 2) 0
- odd x = (/=) (rem x 2) 0
+ even x = (==) (rem x __integer2) __integer0
+ odd x = (/=) (rem x __integer2) __integer0
instance Ix Integer where
range (m,n) = [m..n]
inRange (m,n) i = m <= i && i <= n
instance Enum Integer where
-{- RAW PRELUDE ************************
- enumFrom = numericEnumFrom
- enumFromThen = numericEnumFromThen
--}
- enumFrom n = n : enumFrom (n + 1)
- enumFromThen m n = en' m (n - m)
- where en' m n = m : en' (m + n) n
-
+ enumFrom n = n : enumFrom (n + __integer1)
+ enumFromThen m n = en' m (n - m)
+ where en' m n = m : en' (m + n) n
+ enumFromTo n m = takeWhile (<= m) (enumFrom n)
+ enumFromThenTo n m p = takeWhile (if m >= n then (<= p) else (>= p))
+ (enumFromThen n m)
instance Text Integer where
readsPrec p x = readSigned readDec x
showsPrec x = showSigned showInt x
+ readList = _readList (readsPrec 0)
+ showList = _showList (showsPrec 0)
-{-# GHC_PRAGMA INTERFACE VERSION 5 #-}
+{-# GHC_PRAGMA INTERFACE VERSION 6 #-}
interface PreludeCore where
-import PreludeBuiltin(Int(..), Integer(..))
-_integer_0 :: Integer
- {-# GHC_PRAGMA _A_ 0 _N_ _N_ _N_ _F_ _IF_ARGS_ 0 0 X 1 _#_ int2Integer# [] [0#] _N_ #-}
-_integer_1 :: Integer
- {-# GHC_PRAGMA _A_ 0 _N_ _N_ _N_ _F_ _IF_ARGS_ 0 0 X 1 _#_ int2Integer# [] [1#] _N_ #-}
-_integer_m1 :: Integer
+import PreludeBuiltin(Integer(..))
+__integer0 :: Integer
+ {-# GHC_PRAGMA _A_ 0 _N_ _N_ _N_ _N_ _N_ #-}
+__integer1 :: Integer
+ {-# GHC_PRAGMA _A_ 0 _N_ _N_ _N_ _N_ _N_ #-}
+__integer2 :: Integer
+ {-# GHC_PRAGMA _A_ 0 _N_ _N_ _N_ _N_ _N_ #-}
+__integerm1 :: Integer
{-# GHC_PRAGMA _A_ 0 _N_ _N_ _N_ _N_ _N_ #-}
-int2Integer :: Int -> Integer
- {-# GHC_PRAGMA _A_ 1 _U_ 1 _N_ _S_ "U(P)" {_A_ 1 _U_ 2 _N_ _N_ _F_ _IF_ARGS_ 0 1 X 1 \ (u0 :: Int#) -> _#_ int2Integer# [] [u0] _N_} _F_ _IF_ARGS_ 0 1 C 2 \ (u0 :: Int) -> case u0 of { _ALG_ I# (u1 :: Int#) -> _#_ int2Integer# [] [u1]; _NO_DEFLT_ } _N_ #-}
instance Enum Integer
{-# GHC_PRAGMA _M_ PreludeCore {-dfun-} _A_ 0 _N_ _N_ _N_ _F_ _IF_ARGS_ 0 0 X 6 _!_ _TUP_5 [{{Ord Integer}}, (Integer -> [Integer]), (Integer -> Integer -> [Integer]), (Integer -> Integer -> [Integer]), (Integer -> Integer -> Integer -> [Integer])] [_DFUN_ Ord (Integer), _CONSTM_ Enum enumFrom (Integer), _CONSTM_ Enum enumFromThen (Integer), _CONSTM_ Enum enumFromTo (Integer), _CONSTM_ Enum enumFromThenTo (Integer)] _N_
- enumFrom = _A_ 1 _U_ 2 _N_ _N_ _N_ _N_,
- enumFromThen = _A_ 2 _U_ 21 _N_ _N_ _N_ _N_,
- enumFromTo = _A_ 2 _U_ 22 _N_ _N_ _N_ _N_,
- enumFromThenTo = _A_ 3 _U_ 222 _N_ _N_ _N_ _N_ #-}
+ enumFrom = { _A_ 1 _U_ 2 _N_ _N_ _N_ _N_ },
+ enumFromThen = { _A_ 2 _U_ 21 _N_ _N_ _N_ _N_ },
+ enumFromTo = { _A_ 2 _U_ 22 _N_ _N_ _N_ _N_ },
+ enumFromThenTo = { _A_ 3 _U_ 222 _N_ _N_ _N_ _N_ } #-}
instance Eq Integer
{-# GHC_PRAGMA _M_ PreludeCore {-dfun-} _A_ 0 _N_ _N_ _N_ _F_ _IF_ARGS_ 0 0 X 3 _!_ _TUP_2 [(Integer -> Integer -> Bool), (Integer -> Integer -> Bool)] [_CONSTM_ Eq (==) (Integer), _CONSTM_ Eq (/=) (Integer)] _N_
- (==) = _A_ 2 _U_ 11 _N_ _S_ "U(PPP)U(PPP)" {_A_ 4 _U_ 2221 _N_ _N_ _F_ _IF_ARGS_ 0 4 XXXC 4 \ (u0 :: Int#) (u1 :: Int#) (u2 :: ByteArray#) (u3 :: Integer) -> case u3 of { _ALG_ J# (u4 :: Int#) (u5 :: Int#) (u6 :: ByteArray#) -> case _#_ cmpInteger# [] [u0, u1, u2, u4, u5, u6] of { _PRIM_ 0# -> _!_ True [] []; (u7 :: Int#) -> _!_ False [] [] }; _NO_DEFLT_ } _N_} _F_ _IF_ARGS_ 0 2 CC 5 \ (u0 :: Integer) (u1 :: Integer) -> case u0 of { _ALG_ J# (u2 :: Int#) (u3 :: Int#) (u4 :: ByteArray#) -> case u1 of { _ALG_ J# (u5 :: Int#) (u6 :: Int#) (u7 :: ByteArray#) -> case _#_ cmpInteger# [] [u2, u3, u4, u5, u6, u7] of { _PRIM_ 0# -> _!_ True [] []; (u8 :: Int#) -> _!_ False [] [] }; _NO_DEFLT_ }; _NO_DEFLT_ } _N_,
- (/=) = _A_ 2 _U_ 11 _N_ _S_ "U(PPP)U(PPP)" {_A_ 4 _U_ 2221 _N_ _N_ _F_ _IF_ARGS_ 0 4 XXXC 4 \ (u0 :: Int#) (u1 :: Int#) (u2 :: ByteArray#) (u3 :: Integer) -> case u3 of { _ALG_ J# (u4 :: Int#) (u5 :: Int#) (u6 :: ByteArray#) -> case _#_ cmpInteger# [] [u0, u1, u2, u4, u5, u6] of { _PRIM_ 0# -> _!_ False [] []; (u7 :: Int#) -> _!_ True [] [] }; _NO_DEFLT_ } _N_} _F_ _IF_ARGS_ 0 2 CC 5 \ (u0 :: Integer) (u1 :: Integer) -> case u0 of { _ALG_ J# (u2 :: Int#) (u3 :: Int#) (u4 :: ByteArray#) -> case u1 of { _ALG_ J# (u5 :: Int#) (u6 :: Int#) (u7 :: ByteArray#) -> case _#_ cmpInteger# [] [u2, u3, u4, u5, u6, u7] of { _PRIM_ 0# -> _!_ False [] []; (u8 :: Int#) -> _!_ True [] [] }; _NO_DEFLT_ }; _NO_DEFLT_ } _N_ #-}
+ (==) = { _A_ 2 _U_ 11 _N_ _S_ "U(PPP)U(PPP)" {_A_ 4 _U_ 2221 _N_ _N_ _F_ _IF_ARGS_ 0 4 XXXC 4 \ (u0 :: Int#) (u1 :: Int#) (u2 :: ByteArray#) (u3 :: Integer) -> case u3 of { _ALG_ J# (u4 :: Int#) (u5 :: Int#) (u6 :: ByteArray#) -> case _#_ cmpInteger# [] [u0, u1, u2, u4, u5, u6] of { _PRIM_ 0# -> _!_ True [] []; (u7 :: Int#) -> _!_ False [] [] }; _NO_DEFLT_ } _N_} _F_ _IF_ARGS_ 0 2 CC 5 \ (u0 :: Integer) (u1 :: Integer) -> case u0 of { _ALG_ J# (u2 :: Int#) (u3 :: Int#) (u4 :: ByteArray#) -> case u1 of { _ALG_ J# (u5 :: Int#) (u6 :: Int#) (u7 :: ByteArray#) -> case _#_ cmpInteger# [] [u2, u3, u4, u5, u6, u7] of { _PRIM_ 0# -> _!_ True [] []; (u8 :: Int#) -> _!_ False [] [] }; _NO_DEFLT_ }; _NO_DEFLT_ } _N_ },
+ (/=) = { _A_ 2 _U_ 11 _N_ _S_ "U(PPP)U(PPP)" {_A_ 4 _U_ 2221 _N_ _N_ _F_ _IF_ARGS_ 0 4 XXXC 4 \ (u0 :: Int#) (u1 :: Int#) (u2 :: ByteArray#) (u3 :: Integer) -> case u3 of { _ALG_ J# (u4 :: Int#) (u5 :: Int#) (u6 :: ByteArray#) -> case _#_ cmpInteger# [] [u0, u1, u2, u4, u5, u6] of { _PRIM_ 0# -> _!_ False [] []; (u7 :: Int#) -> _!_ True [] [] }; _NO_DEFLT_ } _N_} _F_ _IF_ARGS_ 0 2 CC 5 \ (u0 :: Integer) (u1 :: Integer) -> case u0 of { _ALG_ J# (u2 :: Int#) (u3 :: Int#) (u4 :: ByteArray#) -> case u1 of { _ALG_ J# (u5 :: Int#) (u6 :: Int#) (u7 :: ByteArray#) -> case _#_ cmpInteger# [] [u2, u3, u4, u5, u6, u7] of { _PRIM_ 0# -> _!_ False [] []; (u8 :: Int#) -> _!_ True [] [] }; _NO_DEFLT_ }; _NO_DEFLT_ } _N_ } #-}
instance Integral Integer
{-# GHC_PRAGMA _M_ PreludeCore {-dfun-} _A_ 0 _N_ _N_ _N_ _F_ _IF_ARGS_ 0 0 X 13 _!_ _TUP_12 [{{Real Integer}}, {{Ix Integer}}, (Integer -> Integer -> Integer), (Integer -> Integer -> Integer), (Integer -> Integer -> Integer), (Integer -> Integer -> Integer), (Integer -> Integer -> (Integer, Integer)), (Integer -> Integer -> (Integer, Integer)), (Integer -> Bool), (Integer -> Bool), (Integer -> Integer), (Integer -> Int)] [_DFUN_ Real (Integer), _DFUN_ Ix (Integer), _CONSTM_ Integral quot (Integer), _CONSTM_ Integral rem (Integer), _CONSTM_ Integral div (Integer), _CONSTM_ Integral mod (Integer), _CONSTM_ Integral quotRem (Integer), _CONSTM_ Integral divMod (Integer), _CONSTM_ Integral even (Integer), _CONSTM_ Integral odd (Integer), _CONSTM_ Integral toInteger (Integer), _CONSTM_ Integral toInt (Integer)] _N_
- quot = _A_ 2 _U_ 11 _N_ _S_ "U(PPP)U(PPP)" {_A_ 4 _U_ 2221 _N_ _N_ _F_ _IF_ARGS_ 0 4 XXXX 7 \ (u0 :: Int#) (u1 :: Int#) (u2 :: ByteArray#) (u3 :: Integer) -> case _APP_ _WRKR_ _CONSTM_ Integral quotRem (Integer) [ u0, u1, u2, u3 ] of { _ALG_ _TUP_2 (u4 :: Integer) (u5 :: Integer) -> u4; _NO_DEFLT_ } _N_} _F_ _IF_ARGS_ 0 2 XX 5 \ (u0 :: Integer) (u1 :: Integer) -> case _APP_ _CONSTM_ Integral quotRem (Integer) [ u0, u1 ] of { _ALG_ _TUP_2 (u2 :: Integer) (u3 :: Integer) -> u2; _NO_DEFLT_ } _N_,
- rem = _A_ 2 _U_ 11 _N_ _S_ "U(PPP)U(PPP)" {_A_ 4 _U_ 2221 _N_ _N_ _F_ _IF_ARGS_ 0 4 XXXX 7 \ (u0 :: Int#) (u1 :: Int#) (u2 :: ByteArray#) (u3 :: Integer) -> case _APP_ _WRKR_ _CONSTM_ Integral quotRem (Integer) [ u0, u1, u2, u3 ] of { _ALG_ _TUP_2 (u4 :: Integer) (u5 :: Integer) -> u5; _NO_DEFLT_ } _N_} _F_ _IF_ARGS_ 0 2 XX 5 \ (u0 :: Integer) (u1 :: Integer) -> case _APP_ _CONSTM_ Integral quotRem (Integer) [ u0, u1 ] of { _ALG_ _TUP_2 (u2 :: Integer) (u3 :: Integer) -> u3; _NO_DEFLT_ } _N_,
- div = _A_ 2 _U_ 12 _N_ _S_ "U(PPP)U(PPP)" {_A_ 4 _U_ 2222 _N_ _N_ _F_ _IF_ARGS_ 0 4 XXXX 7 \ (u0 :: Int#) (u1 :: Int#) (u2 :: ByteArray#) (u3 :: Integer) -> case _APP_ _WRKR_ _CONSTM_ Integral divMod (Integer) [ u0, u1, u2, u3 ] of { _ALG_ _TUP_2 (u4 :: Integer) (u5 :: Integer) -> u4; _NO_DEFLT_ } _N_} _F_ _IF_ARGS_ 0 2 XX 5 \ (u0 :: Integer) (u1 :: Integer) -> case _APP_ _CONSTM_ Integral divMod (Integer) [ u0, u1 ] of { _ALG_ _TUP_2 (u2 :: Integer) (u3 :: Integer) -> u2; _NO_DEFLT_ } _N_,
- mod = _A_ 2 _U_ 12 _N_ _S_ "U(PPP)U(PPP)" {_A_ 4 _U_ 2222 _N_ _N_ _F_ _IF_ARGS_ 0 4 XXXX 7 \ (u0 :: Int#) (u1 :: Int#) (u2 :: ByteArray#) (u3 :: Integer) -> case _APP_ _WRKR_ _CONSTM_ Integral divMod (Integer) [ u0, u1, u2, u3 ] of { _ALG_ _TUP_2 (u4 :: Integer) (u5 :: Integer) -> u5; _NO_DEFLT_ } _N_} _F_ _IF_ARGS_ 0 2 XX 5 \ (u0 :: Integer) (u1 :: Integer) -> case _APP_ _CONSTM_ Integral divMod (Integer) [ u0, u1 ] of { _ALG_ _TUP_2 (u2 :: Integer) (u3 :: Integer) -> u3; _NO_DEFLT_ } _N_,
- quotRem = _A_ 2 _U_ 11 _N_ _S_ "U(PPP)U(PPP)" {_A_ 4 _U_ 2221 _N_ _N_ _N_ _N_} _N_ _N_,
- divMod = _A_ 2 _U_ 12 _N_ _S_ "U(PPP)U(PPP)" {_A_ 4 _U_ 2222 _N_ _N_ _N_ _N_} _N_ _N_,
- even = _A_ 1 _U_ 1 _N_ _S_ "U(PPP)" {_A_ 3 _U_ 222 _N_ _N_ _N_ _N_} _N_ _N_,
- odd = _A_ 1 _U_ 1 _N_ _S_ "U(PPP)" {_A_ 3 _U_ 222 _N_ _N_ _N_ _N_} _N_ _N_,
- toInteger = _A_ 1 _U_ 1 _N_ _S_ "U(PPP)" {_A_ 3 _U_ 222 _N_ _N_ _F_ _IF_ARGS_ 0 3 XXX 4 \ (u0 :: Int#) (u1 :: Int#) (u2 :: ByteArray#) -> _!_ J# [] [u0, u1, u2] _N_} _F_ _IF_ARGS_ 0 1 X 1 \ (u0 :: Integer) -> u0 _N_,
- toInt = _A_ 1 _U_ 1 _N_ _S_ "U(PPP)" {_A_ 3 _U_ 222 _N_ _N_ _F_ _IF_ARGS_ 0 3 XXX 3 \ (u0 :: Int#) (u1 :: Int#) (u2 :: ByteArray#) -> case _#_ integer2Int# [] [u0, u1, u2] of { _PRIM_ (u3 :: Int#) -> _!_ I# [] [u3] } _N_} _F_ _IF_ARGS_ 0 1 C 4 \ (u0 :: Integer) -> case u0 of { _ALG_ J# (u1 :: Int#) (u2 :: Int#) (u3 :: ByteArray#) -> case _#_ integer2Int# [] [u1, u2, u3] of { _PRIM_ (u4 :: Int#) -> _!_ I# [] [u4] }; _NO_DEFLT_ } _N_ #-}
+ quot = { _A_ 2 _U_ 11 _N_ _S_ "U(PPP)U(PPP)" {_A_ 4 _U_ 2221 _N_ _N_ _F_ _IF_ARGS_ 0 4 XXXX 7 \ (u0 :: Int#) (u1 :: Int#) (u2 :: ByteArray#) (u3 :: Integer) -> case _APP_ _WRKR_ _CONSTM_ Integral quotRem (Integer) [ u0, u1, u2, u3 ] of { _ALG_ _TUP_2 (u4 :: Integer) (u5 :: Integer) -> u4; _NO_DEFLT_ } _N_} _F_ _IF_ARGS_ 0 2 XX 5 \ (u0 :: Integer) (u1 :: Integer) -> case _APP_ _CONSTM_ Integral quotRem (Integer) [ u0, u1 ] of { _ALG_ _TUP_2 (u2 :: Integer) (u3 :: Integer) -> u2; _NO_DEFLT_ } _N_ },
+ rem = { _A_ 2 _U_ 11 _N_ _S_ "U(PPP)U(PPP)" {_A_ 4 _U_ 2221 _N_ _N_ _F_ _IF_ARGS_ 0 4 XXXX 7 \ (u0 :: Int#) (u1 :: Int#) (u2 :: ByteArray#) (u3 :: Integer) -> case _APP_ _WRKR_ _CONSTM_ Integral quotRem (Integer) [ u0, u1, u2, u3 ] of { _ALG_ _TUP_2 (u4 :: Integer) (u5 :: Integer) -> u5; _NO_DEFLT_ } _N_} _F_ _IF_ARGS_ 0 2 XX 5 \ (u0 :: Integer) (u1 :: Integer) -> case _APP_ _CONSTM_ Integral quotRem (Integer) [ u0, u1 ] of { _ALG_ _TUP_2 (u2 :: Integer) (u3 :: Integer) -> u3; _NO_DEFLT_ } _N_ },
+ div = { _A_ 2 _U_ 12 _N_ _S_ "U(PPP)U(PPP)" {_A_ 4 _U_ 2222 _N_ _N_ _F_ _IF_ARGS_ 0 4 XXXX 7 \ (u0 :: Int#) (u1 :: Int#) (u2 :: ByteArray#) (u3 :: Integer) -> case _APP_ _WRKR_ _CONSTM_ Integral divMod (Integer) [ u0, u1, u2, u3 ] of { _ALG_ _TUP_2 (u4 :: Integer) (u5 :: Integer) -> u4; _NO_DEFLT_ } _N_} _F_ _IF_ARGS_ 0 2 XX 5 \ (u0 :: Integer) (u1 :: Integer) -> case _APP_ _CONSTM_ Integral divMod (Integer) [ u0, u1 ] of { _ALG_ _TUP_2 (u2 :: Integer) (u3 :: Integer) -> u2; _NO_DEFLT_ } _N_ },
+ mod = { _A_ 2 _U_ 12 _N_ _S_ "U(PPP)U(PPP)" {_A_ 4 _U_ 2222 _N_ _N_ _F_ _IF_ARGS_ 0 4 XXXX 7 \ (u0 :: Int#) (u1 :: Int#) (u2 :: ByteArray#) (u3 :: Integer) -> case _APP_ _WRKR_ _CONSTM_ Integral divMod (Integer) [ u0, u1, u2, u3 ] of { _ALG_ _TUP_2 (u4 :: Integer) (u5 :: Integer) -> u5; _NO_DEFLT_ } _N_} _F_ _IF_ARGS_ 0 2 XX 5 \ (u0 :: Integer) (u1 :: Integer) -> case _APP_ _CONSTM_ Integral divMod (Integer) [ u0, u1 ] of { _ALG_ _TUP_2 (u2 :: Integer) (u3 :: Integer) -> u3; _NO_DEFLT_ } _N_ },
+ quotRem = { _A_ 2 _U_ 11 _N_ _S_ "U(PPP)U(PPP)" {_A_ 4 _U_ 2221 _N_ _N_ _N_ _N_} _N_ _N_ },
+ divMod = { _A_ 2 _U_ 12 _N_ _S_ "U(PPP)U(PPP)" {_A_ 4 _U_ 2222 _N_ _N_ _N_ _N_} _N_ _N_ },
+ even = { _A_ 1 _U_ 1 _N_ _S_ "U(PPP)" {_A_ 3 _U_ 222 _N_ _N_ _N_ _N_} _N_ _N_ },
+ odd = { _A_ 1 _U_ 1 _N_ _S_ "U(PPP)" {_A_ 3 _U_ 222 _N_ _N_ _N_ _N_} _N_ _N_ },
+ toInteger = { _A_ 1 _U_ 1 _N_ _S_ "U(PPP)" {_A_ 3 _U_ 222 _N_ _N_ _F_ _IF_ARGS_ 0 3 XXX 4 \ (u0 :: Int#) (u1 :: Int#) (u2 :: ByteArray#) -> _!_ J# [] [u0, u1, u2] _N_} _F_ _IF_ARGS_ 0 1 X 1 \ (u0 :: Integer) -> u0 _N_ },
+ toInt = { _A_ 1 _U_ 1 _N_ _S_ "U(PPP)" {_A_ 3 _U_ 222 _N_ _N_ _F_ _IF_ARGS_ 0 3 XXX 3 \ (u0 :: Int#) (u1 :: Int#) (u2 :: ByteArray#) -> case _#_ integer2Int# [] [u0, u1, u2] of { _PRIM_ (u3 :: Int#) -> _!_ I# [] [u3] } _N_} _F_ _IF_ARGS_ 0 1 C 4 \ (u0 :: Integer) -> case u0 of { _ALG_ J# (u1 :: Int#) (u2 :: Int#) (u3 :: ByteArray#) -> case _#_ integer2Int# [] [u1, u2, u3] of { _PRIM_ (u4 :: Int#) -> _!_ I# [] [u4] }; _NO_DEFLT_ } _N_ } #-}
instance Ix Integer
{-# GHC_PRAGMA _M_ PreludeCore {-dfun-} _A_ 0 _N_ _N_ _N_ _F_ _IF_ARGS_ 0 0 X 5 _!_ _TUP_4 [{{Ord Integer}}, ((Integer, Integer) -> [Integer]), ((Integer, Integer) -> Integer -> Int), ((Integer, Integer) -> Integer -> Bool)] [_DFUN_ Ord (Integer), _CONSTM_ Ix range (Integer), _CONSTM_ Ix index (Integer), _CONSTM_ Ix inRange (Integer)] _N_
- range = _A_ 1 _U_ 1 _N_ _S_ "U(LL)" {_A_ 2 _U_ 22 _N_ _N_ _F_ _IF_ARGS_ 0 0 X 1 _CONSTM_ Enum enumFromTo (Integer) _N_} _F_ _IF_ARGS_ 0 1 C 4 \ (u0 :: (Integer, Integer)) -> case u0 of { _ALG_ _TUP_2 (u1 :: Integer) (u2 :: Integer) -> _APP_ _CONSTM_ Enum enumFromTo (Integer) [ u1, u2 ]; _NO_DEFLT_ } _N_,
- index = _A_ 2 _U_ 12 _N_ _S_ "U(U(PPP)L)U(PPP)" {_A_ 5 _U_ 22222 _N_ _N_ _N_ _N_} _N_ _N_,
- inRange = _A_ 2 _U_ 11 _N_ _S_ "U(U(PPP)L)U(PPP)" {_A_ 5 _U_ 22211 _N_ _N_ _F_ _IF_ARGS_ 0 5 XXXCC 9 \ (u0 :: Int#) (u1 :: Int#) (u2 :: ByteArray#) (u3 :: Integer) (u4 :: Integer) -> case u4 of { _ALG_ J# (u5 :: Int#) (u6 :: Int#) (u7 :: ByteArray#) -> case _#_ cmpInteger# [] [u0, u1, u2, u5, u6, u7] of { _PRIM_ (u8 :: Int#) -> case _#_ leInt# [] [u8, 0#] of { _ALG_ True -> case u3 of { _ALG_ J# (u9 :: Int#) (ua :: Int#) (ub :: ByteArray#) -> case _#_ cmpInteger# [] [u5, u6, u7, u9, ua, ub] of { _PRIM_ (uc :: Int#) -> _#_ leInt# [] [uc, 0#] }; _NO_DEFLT_ }; False -> _!_ False [] []; _NO_DEFLT_ } }; _NO_DEFLT_ } _N_} _N_ _N_ #-}
+ range = { _A_ 1 _U_ 1 _N_ _S_ "U(LL)" {_A_ 2 _U_ 22 _N_ _N_ _F_ _IF_ARGS_ 0 0 X 1 _CONSTM_ Enum enumFromTo (Integer) _N_} _F_ _IF_ARGS_ 0 1 C 4 \ (u0 :: (Integer, Integer)) -> case u0 of { _ALG_ _TUP_2 (u1 :: Integer) (u2 :: Integer) -> _APP_ _CONSTM_ Enum enumFromTo (Integer) [ u1, u2 ]; _NO_DEFLT_ } _N_ },
+ index = { _A_ 2 _U_ 12 _N_ _S_ "U(U(PPP)L)U(PPP)" {_A_ 5 _U_ 22222 _N_ _N_ _N_ _N_} _N_ _N_ },
+ inRange = { _A_ 2 _U_ 11 _N_ _S_ "U(U(PPP)L)U(PPP)" {_A_ 5 _U_ 22211 _N_ _N_ _F_ _IF_ARGS_ 0 5 XXXCC 9 \ (u0 :: Int#) (u1 :: Int#) (u2 :: ByteArray#) (u3 :: Integer) (u4 :: Integer) -> case u4 of { _ALG_ J# (u5 :: Int#) (u6 :: Int#) (u7 :: ByteArray#) -> case _#_ cmpInteger# [] [u0, u1, u2, u5, u6, u7] of { _PRIM_ (u8 :: Int#) -> case _#_ leInt# [] [u8, 0#] of { _ALG_ True -> case u3 of { _ALG_ J# (u9 :: Int#) (ua :: Int#) (ub :: ByteArray#) -> case _#_ cmpInteger# [] [u5, u6, u7, u9, ua, ub] of { _PRIM_ (uc :: Int#) -> _#_ leInt# [] [uc, 0#] }; _NO_DEFLT_ }; False -> _!_ False [] []; _NO_DEFLT_ } }; _NO_DEFLT_ } _N_} _N_ _N_ } #-}
instance Num Integer
{-# GHC_PRAGMA _M_ PreludeCore {-dfun-} _A_ 0 _N_ _N_ _N_ _F_ _IF_ARGS_ 0 0 X 11 _!_ _TUP_10 [{{Eq Integer}}, {{Text Integer}}, (Integer -> Integer -> Integer), (Integer -> Integer -> Integer), (Integer -> Integer -> Integer), (Integer -> Integer), (Integer -> Integer), (Integer -> Integer), (Integer -> Integer), (Int -> Integer)] [_DFUN_ Eq (Integer), _DFUN_ Text (Integer), _CONSTM_ Num (+) (Integer), _CONSTM_ Num (-) (Integer), _CONSTM_ Num (*) (Integer), _CONSTM_ Num negate (Integer), _CONSTM_ Num abs (Integer), _CONSTM_ Num signum (Integer), _CONSTM_ Num fromInteger (Integer), _CONSTM_ Num fromInt (Integer)] _N_
- (+) = _A_ 2 _U_ 11 _N_ _S_ "U(PPP)U(PPP)" {_A_ 4 _U_ 2221 _N_ _N_ _F_ _IF_ARGS_ 0 4 XXXC 5 \ (u0 :: Int#) (u1 :: Int#) (u2 :: ByteArray#) (u3 :: Integer) -> case u3 of { _ALG_ J# (u4 :: Int#) (u5 :: Int#) (u6 :: ByteArray#) -> _#_ plusInteger# [] [u0, u1, u2, u4, u5, u6]; _NO_DEFLT_ } _N_} _F_ _IF_ARGS_ 0 2 CC 6 \ (u0 :: Integer) (u1 :: Integer) -> case u0 of { _ALG_ J# (u2 :: Int#) (u3 :: Int#) (u4 :: ByteArray#) -> case u1 of { _ALG_ J# (u5 :: Int#) (u6 :: Int#) (u7 :: ByteArray#) -> _#_ plusInteger# [] [u2, u3, u4, u5, u6, u7]; _NO_DEFLT_ }; _NO_DEFLT_ } _N_,
- (-) = _A_ 2 _U_ 11 _N_ _S_ "U(PPP)U(PPP)" {_A_ 4 _U_ 2221 _N_ _N_ _F_ _IF_ARGS_ 0 4 XXXC 5 \ (u0 :: Int#) (u1 :: Int#) (u2 :: ByteArray#) (u3 :: Integer) -> case u3 of { _ALG_ J# (u4 :: Int#) (u5 :: Int#) (u6 :: ByteArray#) -> _#_ minusInteger# [] [u0, u1, u2, u4, u5, u6]; _NO_DEFLT_ } _N_} _F_ _IF_ARGS_ 0 2 CC 6 \ (u0 :: Integer) (u1 :: Integer) -> case u0 of { _ALG_ J# (u2 :: Int#) (u3 :: Int#) (u4 :: ByteArray#) -> case u1 of { _ALG_ J# (u5 :: Int#) (u6 :: Int#) (u7 :: ByteArray#) -> _#_ minusInteger# [] [u2, u3, u4, u5, u6, u7]; _NO_DEFLT_ }; _NO_DEFLT_ } _N_,
- (*) = _A_ 2 _U_ 11 _N_ _S_ "U(PPP)U(PPP)" {_A_ 4 _U_ 2221 _N_ _N_ _F_ _IF_ARGS_ 0 4 XXXC 5 \ (u0 :: Int#) (u1 :: Int#) (u2 :: ByteArray#) (u3 :: Integer) -> case u3 of { _ALG_ J# (u4 :: Int#) (u5 :: Int#) (u6 :: ByteArray#) -> _#_ timesInteger# [] [u0, u1, u2, u4, u5, u6]; _NO_DEFLT_ } _N_} _F_ _IF_ARGS_ 0 2 CC 6 \ (u0 :: Integer) (u1 :: Integer) -> case u0 of { _ALG_ J# (u2 :: Int#) (u3 :: Int#) (u4 :: ByteArray#) -> case u1 of { _ALG_ J# (u5 :: Int#) (u6 :: Int#) (u7 :: ByteArray#) -> _#_ timesInteger# [] [u2, u3, u4, u5, u6, u7]; _NO_DEFLT_ }; _NO_DEFLT_ } _N_,
- negate = _A_ 1 _U_ 1 _N_ _S_ "U(PPP)" {_A_ 3 _U_ 222 _N_ _N_ _F_ _IF_ARGS_ 0 3 XXX 4 \ (u0 :: Int#) (u1 :: Int#) (u2 :: ByteArray#) -> _#_ negateInteger# [] [u0, u1, u2] _N_} _F_ _IF_ARGS_ 0 1 C 5 \ (u0 :: Integer) -> case u0 of { _ALG_ J# (u1 :: Int#) (u2 :: Int#) (u3 :: ByteArray#) -> _#_ negateInteger# [] [u1, u2, u3]; _NO_DEFLT_ } _N_,
- abs = _A_ 1 _U_ 1 _N_ _S_ "U(PPP)" {_A_ 3 _U_ 222 _N_ _N_ _N_ _N_} _N_ _N_,
- signum = _A_ 1 _U_ 1 _N_ _S_ "U(PPP)" {_A_ 3 _U_ 222 _N_ _N_ _N_ _N_} _N_ _N_,
- fromInteger = _A_ 1 _U_ 1 _N_ _S_ "U(PPP)" {_A_ 3 _U_ 222 _N_ _N_ _F_ _IF_ARGS_ 0 3 XXX 4 \ (u0 :: Int#) (u1 :: Int#) (u2 :: ByteArray#) -> _!_ J# [] [u0, u1, u2] _N_} _F_ _IF_ARGS_ 0 1 X 1 \ (u0 :: Integer) -> u0 _N_,
- fromInt = _A_ 1 _U_ 1 _N_ _S_ "U(P)" {_A_ 1 _U_ 2 _N_ _N_ _F_ _IF_ARGS_ 0 1 X 1 \ (u0 :: Int#) -> _#_ int2Integer# [] [u0] _N_} _F_ _IF_ARGS_ 0 1 C 2 \ (u0 :: Int) -> case u0 of { _ALG_ I# (u1 :: Int#) -> _#_ int2Integer# [] [u1]; _NO_DEFLT_ } _N_ #-}
+ (+) = { _A_ 2 _U_ 11 _N_ _S_ "U(PPP)U(PPP)" {_A_ 4 _U_ 2221 _N_ _N_ _F_ _IF_ARGS_ 0 4 XXXC 5 \ (u0 :: Int#) (u1 :: Int#) (u2 :: ByteArray#) (u3 :: Integer) -> case u3 of { _ALG_ J# (u4 :: Int#) (u5 :: Int#) (u6 :: ByteArray#) -> _#_ plusInteger# [] [u0, u1, u2, u4, u5, u6]; _NO_DEFLT_ } _N_} _F_ _IF_ARGS_ 0 2 CC 6 \ (u0 :: Integer) (u1 :: Integer) -> case u0 of { _ALG_ J# (u2 :: Int#) (u3 :: Int#) (u4 :: ByteArray#) -> case u1 of { _ALG_ J# (u5 :: Int#) (u6 :: Int#) (u7 :: ByteArray#) -> _#_ plusInteger# [] [u2, u3, u4, u5, u6, u7]; _NO_DEFLT_ }; _NO_DEFLT_ } _N_ },
+ (-) = { _A_ 2 _U_ 11 _N_ _S_ "U(PPP)U(PPP)" {_A_ 4 _U_ 2221 _N_ _N_ _F_ _IF_ARGS_ 0 4 XXXC 5 \ (u0 :: Int#) (u1 :: Int#) (u2 :: ByteArray#) (u3 :: Integer) -> case u3 of { _ALG_ J# (u4 :: Int#) (u5 :: Int#) (u6 :: ByteArray#) -> _#_ minusInteger# [] [u0, u1, u2, u4, u5, u6]; _NO_DEFLT_ } _N_} _F_ _IF_ARGS_ 0 2 CC 6 \ (u0 :: Integer) (u1 :: Integer) -> case u0 of { _ALG_ J# (u2 :: Int#) (u3 :: Int#) (u4 :: ByteArray#) -> case u1 of { _ALG_ J# (u5 :: Int#) (u6 :: Int#) (u7 :: ByteArray#) -> _#_ minusInteger# [] [u2, u3, u4, u5, u6, u7]; _NO_DEFLT_ }; _NO_DEFLT_ } _N_ },
+ (*) = { _A_ 2 _U_ 11 _N_ _S_ "U(PPP)U(PPP)" {_A_ 4 _U_ 2221 _N_ _N_ _F_ _IF_ARGS_ 0 4 XXXC 5 \ (u0 :: Int#) (u1 :: Int#) (u2 :: ByteArray#) (u3 :: Integer) -> case u3 of { _ALG_ J# (u4 :: Int#) (u5 :: Int#) (u6 :: ByteArray#) -> _#_ timesInteger# [] [u0, u1, u2, u4, u5, u6]; _NO_DEFLT_ } _N_} _F_ _IF_ARGS_ 0 2 CC 6 \ (u0 :: Integer) (u1 :: Integer) -> case u0 of { _ALG_ J# (u2 :: Int#) (u3 :: Int#) (u4 :: ByteArray#) -> case u1 of { _ALG_ J# (u5 :: Int#) (u6 :: Int#) (u7 :: ByteArray#) -> _#_ timesInteger# [] [u2, u3, u4, u5, u6, u7]; _NO_DEFLT_ }; _NO_DEFLT_ } _N_ },
+ negate = { _A_ 1 _U_ 1 _N_ _S_ "U(PPP)" {_A_ 3 _U_ 222 _N_ _N_ _F_ _IF_ARGS_ 0 3 XXX 4 \ (u0 :: Int#) (u1 :: Int#) (u2 :: ByteArray#) -> _#_ negateInteger# [] [u0, u1, u2] _N_} _F_ _IF_ARGS_ 0 1 C 5 \ (u0 :: Integer) -> case u0 of { _ALG_ J# (u1 :: Int#) (u2 :: Int#) (u3 :: ByteArray#) -> _#_ negateInteger# [] [u1, u2, u3]; _NO_DEFLT_ } _N_ },
+ abs = { _A_ 1 _U_ 1 _N_ _S_ "U(PPP)" {_A_ 3 _U_ 222 _N_ _N_ _N_ _N_} _N_ _N_ },
+ signum = { _A_ 1 _U_ 1 _N_ _S_ "U(PPP)" {_A_ 3 _U_ 222 _N_ _N_ _N_ _N_} _N_ _N_ },
+ fromInteger = { _A_ 1 _U_ 1 _N_ _S_ "U(PPP)" {_A_ 3 _U_ 222 _N_ _N_ _F_ _IF_ARGS_ 0 3 XXX 4 \ (u0 :: Int#) (u1 :: Int#) (u2 :: ByteArray#) -> _!_ J# [] [u0, u1, u2] _N_} _F_ _IF_ARGS_ 0 1 X 1 \ (u0 :: Integer) -> u0 _N_ },
+ fromInt = { _A_ 1 _U_ 1 _N_ _S_ "U(P)" {_A_ 1 _U_ 2 _N_ _N_ _F_ _IF_ARGS_ 0 1 X 1 \ (u0 :: Int#) -> _#_ int2Integer# [] [u0] _N_} _F_ _IF_ARGS_ 0 1 C 2 \ (u0 :: Int) -> case u0 of { _ALG_ I# (u1 :: Int#) -> _#_ int2Integer# [] [u1]; _NO_DEFLT_ } _N_ } #-}
instance Ord Integer
{-# GHC_PRAGMA _M_ PreludeCore {-dfun-} _A_ 0 _N_ _N_ _N_ _F_ _IF_ARGS_ 0 0 X 9 _!_ _TUP_8 [{{Eq Integer}}, (Integer -> Integer -> Bool), (Integer -> Integer -> Bool), (Integer -> Integer -> Bool), (Integer -> Integer -> Bool), (Integer -> Integer -> Integer), (Integer -> Integer -> Integer), (Integer -> Integer -> _CMP_TAG)] [_DFUN_ Eq (Integer), _CONSTM_ Ord (<) (Integer), _CONSTM_ Ord (<=) (Integer), _CONSTM_ Ord (>=) (Integer), _CONSTM_ Ord (>) (Integer), _CONSTM_ Ord max (Integer), _CONSTM_ Ord min (Integer), _CONSTM_ Ord _tagCmp (Integer)] _N_
- (<) = _A_ 2 _U_ 11 _N_ _S_ "U(PPP)U(PPP)" {_A_ 4 _U_ 2221 _N_ _N_ _F_ _IF_ARGS_ 0 4 XXXC 3 \ (u0 :: Int#) (u1 :: Int#) (u2 :: ByteArray#) (u3 :: Integer) -> case u3 of { _ALG_ J# (u4 :: Int#) (u5 :: Int#) (u6 :: ByteArray#) -> case _#_ cmpInteger# [] [u0, u1, u2, u4, u5, u6] of { _PRIM_ (u7 :: Int#) -> _#_ ltInt# [] [u7, 0#] }; _NO_DEFLT_ } _N_} _F_ _IF_ARGS_ 0 2 CC 4 \ (u0 :: Integer) (u1 :: Integer) -> case u0 of { _ALG_ J# (u2 :: Int#) (u3 :: Int#) (u4 :: ByteArray#) -> case u1 of { _ALG_ J# (u5 :: Int#) (u6 :: Int#) (u7 :: ByteArray#) -> case _#_ cmpInteger# [] [u2, u3, u4, u5, u6, u7] of { _PRIM_ (u8 :: Int#) -> _#_ ltInt# [] [u8, 0#] }; _NO_DEFLT_ }; _NO_DEFLT_ } _N_,
- (<=) = _A_ 2 _U_ 11 _N_ _S_ "U(PPP)U(PPP)" {_A_ 4 _U_ 2221 _N_ _N_ _F_ _IF_ARGS_ 0 4 XXXC 3 \ (u0 :: Int#) (u1 :: Int#) (u2 :: ByteArray#) (u3 :: Integer) -> case u3 of { _ALG_ J# (u4 :: Int#) (u5 :: Int#) (u6 :: ByteArray#) -> case _#_ cmpInteger# [] [u0, u1, u2, u4, u5, u6] of { _PRIM_ (u7 :: Int#) -> _#_ leInt# [] [u7, 0#] }; _NO_DEFLT_ } _N_} _F_ _IF_ARGS_ 0 2 CC 4 \ (u0 :: Integer) (u1 :: Integer) -> case u0 of { _ALG_ J# (u2 :: Int#) (u3 :: Int#) (u4 :: ByteArray#) -> case u1 of { _ALG_ J# (u5 :: Int#) (u6 :: Int#) (u7 :: ByteArray#) -> case _#_ cmpInteger# [] [u2, u3, u4, u5, u6, u7] of { _PRIM_ (u8 :: Int#) -> _#_ leInt# [] [u8, 0#] }; _NO_DEFLT_ }; _NO_DEFLT_ } _N_,
- (>=) = _A_ 2 _U_ 11 _N_ _S_ "U(PPP)U(PPP)" {_A_ 4 _U_ 2221 _N_ _N_ _F_ _IF_ARGS_ 0 4 XXXC 3 \ (u0 :: Int#) (u1 :: Int#) (u2 :: ByteArray#) (u3 :: Integer) -> case u3 of { _ALG_ J# (u4 :: Int#) (u5 :: Int#) (u6 :: ByteArray#) -> case _#_ cmpInteger# [] [u0, u1, u2, u4, u5, u6] of { _PRIM_ (u7 :: Int#) -> _#_ geInt# [] [u7, 0#] }; _NO_DEFLT_ } _N_} _F_ _IF_ARGS_ 0 2 CC 4 \ (u0 :: Integer) (u1 :: Integer) -> case u0 of { _ALG_ J# (u2 :: Int#) (u3 :: Int#) (u4 :: ByteArray#) -> case u1 of { _ALG_ J# (u5 :: Int#) (u6 :: Int#) (u7 :: ByteArray#) -> case _#_ cmpInteger# [] [u2, u3, u4, u5, u6, u7] of { _PRIM_ (u8 :: Int#) -> _#_ geInt# [] [u8, 0#] }; _NO_DEFLT_ }; _NO_DEFLT_ } _N_,
- (>) = _A_ 2 _U_ 11 _N_ _S_ "U(PPP)U(PPP)" {_A_ 4 _U_ 2221 _N_ _N_ _F_ _IF_ARGS_ 0 4 XXXC 3 \ (u0 :: Int#) (u1 :: Int#) (u2 :: ByteArray#) (u3 :: Integer) -> case u3 of { _ALG_ J# (u4 :: Int#) (u5 :: Int#) (u6 :: ByteArray#) -> case _#_ cmpInteger# [] [u0, u1, u2, u4, u5, u6] of { _PRIM_ (u7 :: Int#) -> _#_ gtInt# [] [u7, 0#] }; _NO_DEFLT_ } _N_} _F_ _IF_ARGS_ 0 2 CC 4 \ (u0 :: Integer) (u1 :: Integer) -> case u0 of { _ALG_ J# (u2 :: Int#) (u3 :: Int#) (u4 :: ByteArray#) -> case u1 of { _ALG_ J# (u5 :: Int#) (u6 :: Int#) (u7 :: ByteArray#) -> case _#_ cmpInteger# [] [u2, u3, u4, u5, u6, u7] of { _PRIM_ (u8 :: Int#) -> _#_ gtInt# [] [u8, 0#] }; _NO_DEFLT_ }; _NO_DEFLT_ } _N_,
- max = _A_ 2 _U_ 11 _N_ _S_ "U(PPP)U(PPP)" {_A_ 4 _U_ 2221 _N_ _N_ _N_ _N_} _N_ _N_,
- min = _A_ 2 _U_ 11 _N_ _S_ "U(PPP)U(PPP)" {_A_ 4 _U_ 2221 _N_ _N_ _N_ _N_} _N_ _N_,
- _tagCmp = _A_ 2 _U_ 11 _N_ _S_ "U(PPP)U(PPP)" {_A_ 4 _U_ 2221 _N_ _N_ _N_ _N_} _N_ _N_ #-}
+ (<) = { _A_ 2 _U_ 11 _N_ _S_ "U(PPP)U(PPP)" {_A_ 4 _U_ 2221 _N_ _N_ _F_ _IF_ARGS_ 0 4 XXXC 3 \ (u0 :: Int#) (u1 :: Int#) (u2 :: ByteArray#) (u3 :: Integer) -> case u3 of { _ALG_ J# (u4 :: Int#) (u5 :: Int#) (u6 :: ByteArray#) -> case _#_ cmpInteger# [] [u0, u1, u2, u4, u5, u6] of { _PRIM_ (u7 :: Int#) -> _#_ ltInt# [] [u7, 0#] }; _NO_DEFLT_ } _N_} _F_ _IF_ARGS_ 0 2 CC 4 \ (u0 :: Integer) (u1 :: Integer) -> case u0 of { _ALG_ J# (u2 :: Int#) (u3 :: Int#) (u4 :: ByteArray#) -> case u1 of { _ALG_ J# (u5 :: Int#) (u6 :: Int#) (u7 :: ByteArray#) -> case _#_ cmpInteger# [] [u2, u3, u4, u5, u6, u7] of { _PRIM_ (u8 :: Int#) -> _#_ ltInt# [] [u8, 0#] }; _NO_DEFLT_ }; _NO_DEFLT_ } _N_ },
+ (<=) = { _A_ 2 _U_ 11 _N_ _S_ "U(PPP)U(PPP)" {_A_ 4 _U_ 2221 _N_ _N_ _F_ _IF_ARGS_ 0 4 XXXC 3 \ (u0 :: Int#) (u1 :: Int#) (u2 :: ByteArray#) (u3 :: Integer) -> case u3 of { _ALG_ J# (u4 :: Int#) (u5 :: Int#) (u6 :: ByteArray#) -> case _#_ cmpInteger# [] [u0, u1, u2, u4, u5, u6] of { _PRIM_ (u7 :: Int#) -> _#_ leInt# [] [u7, 0#] }; _NO_DEFLT_ } _N_} _F_ _IF_ARGS_ 0 2 CC 4 \ (u0 :: Integer) (u1 :: Integer) -> case u0 of { _ALG_ J# (u2 :: Int#) (u3 :: Int#) (u4 :: ByteArray#) -> case u1 of { _ALG_ J# (u5 :: Int#) (u6 :: Int#) (u7 :: ByteArray#) -> case _#_ cmpInteger# [] [u2, u3, u4, u5, u6, u7] of { _PRIM_ (u8 :: Int#) -> _#_ leInt# [] [u8, 0#] }; _NO_DEFLT_ }; _NO_DEFLT_ } _N_ },
+ (>=) = { _A_ 2 _U_ 11 _N_ _S_ "U(PPP)U(PPP)" {_A_ 4 _U_ 2221 _N_ _N_ _F_ _IF_ARGS_ 0 4 XXXC 3 \ (u0 :: Int#) (u1 :: Int#) (u2 :: ByteArray#) (u3 :: Integer) -> case u3 of { _ALG_ J# (u4 :: Int#) (u5 :: Int#) (u6 :: ByteArray#) -> case _#_ cmpInteger# [] [u0, u1, u2, u4, u5, u6] of { _PRIM_ (u7 :: Int#) -> _#_ geInt# [] [u7, 0#] }; _NO_DEFLT_ } _N_} _F_ _IF_ARGS_ 0 2 CC 4 \ (u0 :: Integer) (u1 :: Integer) -> case u0 of { _ALG_ J# (u2 :: Int#) (u3 :: Int#) (u4 :: ByteArray#) -> case u1 of { _ALG_ J# (u5 :: Int#) (u6 :: Int#) (u7 :: ByteArray#) -> case _#_ cmpInteger# [] [u2, u3, u4, u5, u6, u7] of { _PRIM_ (u8 :: Int#) -> _#_ geInt# [] [u8, 0#] }; _NO_DEFLT_ }; _NO_DEFLT_ } _N_ },
+ (>) = { _A_ 2 _U_ 11 _N_ _S_ "U(PPP)U(PPP)" {_A_ 4 _U_ 2221 _N_ _N_ _F_ _IF_ARGS_ 0 4 XXXC 3 \ (u0 :: Int#) (u1 :: Int#) (u2 :: ByteArray#) (u3 :: Integer) -> case u3 of { _ALG_ J# (u4 :: Int#) (u5 :: Int#) (u6 :: ByteArray#) -> case _#_ cmpInteger# [] [u0, u1, u2, u4, u5, u6] of { _PRIM_ (u7 :: Int#) -> _#_ gtInt# [] [u7, 0#] }; _NO_DEFLT_ } _N_} _F_ _IF_ARGS_ 0 2 CC 4 \ (u0 :: Integer) (u1 :: Integer) -> case u0 of { _ALG_ J# (u2 :: Int#) (u3 :: Int#) (u4 :: ByteArray#) -> case u1 of { _ALG_ J# (u5 :: Int#) (u6 :: Int#) (u7 :: ByteArray#) -> case _#_ cmpInteger# [] [u2, u3, u4, u5, u6, u7] of { _PRIM_ (u8 :: Int#) -> _#_ gtInt# [] [u8, 0#] }; _NO_DEFLT_ }; _NO_DEFLT_ } _N_ },
+ max = { _A_ 2 _U_ 11 _N_ _S_ "U(PPP)U(PPP)" {_A_ 4 _U_ 2221 _N_ _N_ _N_ _N_} _N_ _N_ },
+ min = { _A_ 2 _U_ 11 _N_ _S_ "U(PPP)U(PPP)" {_A_ 4 _U_ 2221 _N_ _N_ _N_ _N_} _N_ _N_ },
+ _tagCmp = { _A_ 2 _U_ 11 _N_ _S_ "U(PPP)U(PPP)" {_A_ 4 _U_ 2221 _N_ _N_ _N_ _N_} _N_ _N_ } #-}
instance Real Integer
{-# GHC_PRAGMA _M_ PreludeCore {-dfun-} _A_ 0 _N_ _N_ _N_ _F_ _IF_ARGS_ 0 0 X 4 _!_ _TUP_3 [{{Num Integer}}, {{Enum Integer}}, (Integer -> Ratio Integer)] [_DFUN_ Num (Integer), _DFUN_ Enum (Integer), _CONSTM_ Real toRational (Integer)] _N_
- toRational = _A_ 1 _U_ 2 _N_ _N_ _N_ _N_ #-}
+ toRational = { _A_ 1 _U_ 2 _N_ _N_ _F_ _IF_ARGS_ 0 1 X 3 \ (u0 :: Integer) -> _!_ (:%) [Integer] [u0, _ORIG_ PreludeCore __integer1] _N_ } #-}
instance Text Integer
{-# GHC_PRAGMA _M_ PreludeCore {-dfun-} _A_ 0 _N_ _N_ _N_ _F_ _IF_ARGS_ 0 0 X 5 _!_ _TUP_4 [(Int -> [Char] -> [(Integer, [Char])]), (Int -> Integer -> [Char] -> [Char]), ([Char] -> [([Integer], [Char])]), ([Integer] -> [Char] -> [Char])] [_CONSTM_ Text readsPrec (Integer), _CONSTM_ Text showsPrec (Integer), _CONSTM_ Text readList (Integer), _CONSTM_ Text showList (Integer)] _N_
- readsPrec = _A_ 2 _U_ 02 _N_ _S_ "AL" {_A_ 1 _U_ 2 _N_ _N_ _F_ _IF_ARGS_ 0 1 X 3 \ (u0 :: [Char]) -> _APP_ _SPEC_ _ORIG_ PreludeText readSigned [ (Integer) ] [ _SPEC_ _ORIG_ PreludeText readDec [ (Integer) ], u0 ] _N_} _F_ _IF_ARGS_ 0 2 XX 3 \ (u0 :: Int) (u1 :: [Char]) -> _APP_ _SPEC_ _ORIG_ PreludeText readSigned [ (Integer) ] [ _SPEC_ _ORIG_ PreludeText readDec [ (Integer) ], u1 ] _N_,
- showsPrec = _A_ 3 _U_ 212 _N_ _S_ "LU(PPP)L" {_A_ 5 _U_ 22222 _N_ _N_ _N_ _N_} _N_ _N_,
- readList = _A_ 0 _U_ 2 _N_ _N_ _N_ _N_,
- showList = _A_ 0 _U_ 12 _N_ _N_ _N_ _N_ #-}
+ readsPrec = { _A_ 2 _U_ 02 _N_ _S_ "AL" {_A_ 1 _U_ 2 _N_ _N_ _F_ _IF_ARGS_ 0 1 X 3 \ (u0 :: [Char]) -> _APP_ _SPEC_ _ORIG_ PreludeText readSigned [ (Integer) ] [ _SPEC_ _ORIG_ PreludeText readDec [ (Integer) ], u0 ] _N_} _F_ _IF_ARGS_ 0 2 XX 3 \ (u0 :: Int) (u1 :: [Char]) -> _APP_ _SPEC_ _ORIG_ PreludeText readSigned [ (Integer) ] [ _SPEC_ _ORIG_ PreludeText readDec [ (Integer) ], u1 ] _N_ },
+ showsPrec = { _A_ 3 _U_ 212 _N_ _S_ "LU(PPP)L" {_A_ 5 _U_ 22222 _N_ _N_ _N_ _N_} _N_ _N_ },
+ readList = { _A_ 0 _U_ 2 _N_ _N_ _N_ _N_ },
+ showList = { _A_ 1 _U_ 12 _N_ _N_ _N_ _N_ } #-}
-{-# GHC_PRAGMA INTERFACE VERSION 5 #-}
+{-# GHC_PRAGMA INTERFACE VERSION 6 #-}
interface PreludeCore where
-import PreludeBuiltin(Int(..), Integer(..))
-_integer_0 :: Integer
- {-# GHC_PRAGMA _A_ 0 _N_ _N_ _N_ _F_ _IF_ARGS_ 0 0 X 1 _#_ int2Integer# [] [0#] _N_ #-}
-_integer_1 :: Integer
- {-# GHC_PRAGMA _A_ 0 _N_ _N_ _N_ _F_ _IF_ARGS_ 0 0 X 1 _#_ int2Integer# [] [1#] _N_ #-}
-_integer_m1 :: Integer
+import PreludeBuiltin(Integer(..))
+__integer0 :: Integer
+ {-# GHC_PRAGMA _A_ 0 _N_ _N_ _N_ _N_ _N_ #-}
+__integer1 :: Integer
+ {-# GHC_PRAGMA _A_ 0 _N_ _N_ _N_ _N_ _N_ #-}
+__integer2 :: Integer
+ {-# GHC_PRAGMA _A_ 0 _N_ _N_ _N_ _N_ _N_ #-}
+__integerm1 :: Integer
{-# GHC_PRAGMA _A_ 0 _N_ _N_ _N_ _N_ _N_ #-}
-int2Integer :: Int -> Integer
- {-# GHC_PRAGMA _A_ 1 _U_ 1 _N_ _S_ "U(P)" {_A_ 1 _U_ 2 _N_ _N_ _F_ _IF_ARGS_ 0 1 X 1 \ (u0 :: Int#) -> _#_ int2Integer# [] [u0] _N_} _F_ _IF_ARGS_ 0 1 C 2 \ (u0 :: Int) -> case u0 of { _ALG_ I# (u1 :: Int#) -> _#_ int2Integer# [] [u1]; _NO_DEFLT_ } _N_ #-}
instance Enum Integer
{-# GHC_PRAGMA _M_ PreludeCore {-dfun-} _A_ 0 _N_ _N_ _N_ _F_ _IF_ARGS_ 0 0 X 6 _!_ _TUP_5 [{{Ord Integer}}, (Integer -> [Integer]), (Integer -> Integer -> [Integer]), (Integer -> Integer -> [Integer]), (Integer -> Integer -> Integer -> [Integer])] [_DFUN_ Ord (Integer), _CONSTM_ Enum enumFrom (Integer), _CONSTM_ Enum enumFromThen (Integer), _CONSTM_ Enum enumFromTo (Integer), _CONSTM_ Enum enumFromThenTo (Integer)] _N_
- enumFrom = _A_ 1 _U_ 2 _N_ _N_ _N_ _N_,
- enumFromThen = _A_ 2 _U_ 21 _N_ _N_ _N_ _N_,
- enumFromTo = _A_ 2 _U_ 22 _N_ _N_ _N_ _N_,
- enumFromThenTo = _A_ 3 _U_ 222 _N_ _N_ _N_ _N_ #-}
+ enumFrom = { _A_ 1 _U_ 2 _N_ _N_ _N_ _N_ },
+ enumFromThen = { _A_ 2 _U_ 21 _N_ _N_ _N_ _N_ },
+ enumFromTo = { _A_ 2 _U_ 22 _N_ _N_ _N_ _N_ },
+ enumFromThenTo = { _A_ 3 _U_ 222 _N_ _N_ _N_ _N_ } #-}
instance Eq Integer
{-# GHC_PRAGMA _M_ PreludeCore {-dfun-} _A_ 0 _N_ _N_ _N_ _F_ _IF_ARGS_ 0 0 X 3 _!_ _TUP_2 [(Integer -> Integer -> Bool), (Integer -> Integer -> Bool)] [_CONSTM_ Eq (==) (Integer), _CONSTM_ Eq (/=) (Integer)] _N_
- (==) = _A_ 2 _U_ 11 _N_ _S_ "U(PPP)U(PPP)" {_A_ 4 _U_ 2221 _N_ _N_ _F_ _IF_ARGS_ 0 4 XXXC 4 \ (u0 :: Int#) (u1 :: Int#) (u2 :: ByteArray#) (u3 :: Integer) -> case u3 of { _ALG_ J# (u4 :: Int#) (u5 :: Int#) (u6 :: ByteArray#) -> case _#_ cmpInteger# [] [u0, u1, u2, u4, u5, u6] of { _PRIM_ 0# -> _!_ True [] []; (u7 :: Int#) -> _!_ False [] [] }; _NO_DEFLT_ } _N_} _F_ _IF_ARGS_ 0 2 CC 5 \ (u0 :: Integer) (u1 :: Integer) -> case u0 of { _ALG_ J# (u2 :: Int#) (u3 :: Int#) (u4 :: ByteArray#) -> case u1 of { _ALG_ J# (u5 :: Int#) (u6 :: Int#) (u7 :: ByteArray#) -> case _#_ cmpInteger# [] [u2, u3, u4, u5, u6, u7] of { _PRIM_ 0# -> _!_ True [] []; (u8 :: Int#) -> _!_ False [] [] }; _NO_DEFLT_ }; _NO_DEFLT_ } _N_,
- (/=) = _A_ 2 _U_ 11 _N_ _S_ "U(PPP)U(PPP)" {_A_ 4 _U_ 2221 _N_ _N_ _F_ _IF_ARGS_ 0 4 XXXC 4 \ (u0 :: Int#) (u1 :: Int#) (u2 :: ByteArray#) (u3 :: Integer) -> case u3 of { _ALG_ J# (u4 :: Int#) (u5 :: Int#) (u6 :: ByteArray#) -> case _#_ cmpInteger# [] [u0, u1, u2, u4, u5, u6] of { _PRIM_ 0# -> _!_ False [] []; (u7 :: Int#) -> _!_ True [] [] }; _NO_DEFLT_ } _N_} _F_ _IF_ARGS_ 0 2 CC 5 \ (u0 :: Integer) (u1 :: Integer) -> case u0 of { _ALG_ J# (u2 :: Int#) (u3 :: Int#) (u4 :: ByteArray#) -> case u1 of { _ALG_ J# (u5 :: Int#) (u6 :: Int#) (u7 :: ByteArray#) -> case _#_ cmpInteger# [] [u2, u3, u4, u5, u6, u7] of { _PRIM_ 0# -> _!_ False [] []; (u8 :: Int#) -> _!_ True [] [] }; _NO_DEFLT_ }; _NO_DEFLT_ } _N_ #-}
+ (==) = { _A_ 2 _U_ 11 _N_ _S_ "U(PPP)U(PPP)" {_A_ 4 _U_ 2221 _N_ _N_ _F_ _IF_ARGS_ 0 4 XXXC 4 \ (u0 :: Int#) (u1 :: Int#) (u2 :: ByteArray#) (u3 :: Integer) -> case u3 of { _ALG_ J# (u4 :: Int#) (u5 :: Int#) (u6 :: ByteArray#) -> case _#_ cmpInteger# [] [u0, u1, u2, u4, u5, u6] of { _PRIM_ 0# -> _!_ True [] []; (u7 :: Int#) -> _!_ False [] [] }; _NO_DEFLT_ } _N_} _F_ _IF_ARGS_ 0 2 CC 5 \ (u0 :: Integer) (u1 :: Integer) -> case u0 of { _ALG_ J# (u2 :: Int#) (u3 :: Int#) (u4 :: ByteArray#) -> case u1 of { _ALG_ J# (u5 :: Int#) (u6 :: Int#) (u7 :: ByteArray#) -> case _#_ cmpInteger# [] [u2, u3, u4, u5, u6, u7] of { _PRIM_ 0# -> _!_ True [] []; (u8 :: Int#) -> _!_ False [] [] }; _NO_DEFLT_ }; _NO_DEFLT_ } _N_ },
+ (/=) = { _A_ 2 _U_ 11 _N_ _S_ "U(PPP)U(PPP)" {_A_ 4 _U_ 2221 _N_ _N_ _F_ _IF_ARGS_ 0 4 XXXC 4 \ (u0 :: Int#) (u1 :: Int#) (u2 :: ByteArray#) (u3 :: Integer) -> case u3 of { _ALG_ J# (u4 :: Int#) (u5 :: Int#) (u6 :: ByteArray#) -> case _#_ cmpInteger# [] [u0, u1, u2, u4, u5, u6] of { _PRIM_ 0# -> _!_ False [] []; (u7 :: Int#) -> _!_ True [] [] }; _NO_DEFLT_ } _N_} _F_ _IF_ARGS_ 0 2 CC 5 \ (u0 :: Integer) (u1 :: Integer) -> case u0 of { _ALG_ J# (u2 :: Int#) (u3 :: Int#) (u4 :: ByteArray#) -> case u1 of { _ALG_ J# (u5 :: Int#) (u6 :: Int#) (u7 :: ByteArray#) -> case _#_ cmpInteger# [] [u2, u3, u4, u5, u6, u7] of { _PRIM_ 0# -> _!_ False [] []; (u8 :: Int#) -> _!_ True [] [] }; _NO_DEFLT_ }; _NO_DEFLT_ } _N_ } #-}
instance Integral Integer
{-# GHC_PRAGMA _M_ PreludeCore {-dfun-} _A_ 0 _N_ _N_ _N_ _F_ _IF_ARGS_ 0 0 X 13 _!_ _TUP_12 [{{Real Integer}}, {{Ix Integer}}, (Integer -> Integer -> Integer), (Integer -> Integer -> Integer), (Integer -> Integer -> Integer), (Integer -> Integer -> Integer), (Integer -> Integer -> (Integer, Integer)), (Integer -> Integer -> (Integer, Integer)), (Integer -> Bool), (Integer -> Bool), (Integer -> Integer), (Integer -> Int)] [_DFUN_ Real (Integer), _DFUN_ Ix (Integer), _CONSTM_ Integral quot (Integer), _CONSTM_ Integral rem (Integer), _CONSTM_ Integral div (Integer), _CONSTM_ Integral mod (Integer), _CONSTM_ Integral quotRem (Integer), _CONSTM_ Integral divMod (Integer), _CONSTM_ Integral even (Integer), _CONSTM_ Integral odd (Integer), _CONSTM_ Integral toInteger (Integer), _CONSTM_ Integral toInt (Integer)] _N_
- quot = _A_ 2 _U_ 11 _N_ _S_ "U(PPP)U(PPP)" {_A_ 4 _U_ 2221 _N_ _N_ _F_ _IF_ARGS_ 0 4 XXXX 7 \ (u0 :: Int#) (u1 :: Int#) (u2 :: ByteArray#) (u3 :: Integer) -> case _APP_ _WRKR_ _CONSTM_ Integral quotRem (Integer) [ u0, u1, u2, u3 ] of { _ALG_ _TUP_2 (u4 :: Integer) (u5 :: Integer) -> u4; _NO_DEFLT_ } _N_} _F_ _IF_ARGS_ 0 2 XX 5 \ (u0 :: Integer) (u1 :: Integer) -> case _APP_ _CONSTM_ Integral quotRem (Integer) [ u0, u1 ] of { _ALG_ _TUP_2 (u2 :: Integer) (u3 :: Integer) -> u2; _NO_DEFLT_ } _N_,
- rem = _A_ 2 _U_ 11 _N_ _S_ "U(PPP)U(PPP)" {_A_ 4 _U_ 2221 _N_ _N_ _F_ _IF_ARGS_ 0 4 XXXX 7 \ (u0 :: Int#) (u1 :: Int#) (u2 :: ByteArray#) (u3 :: Integer) -> case _APP_ _WRKR_ _CONSTM_ Integral quotRem (Integer) [ u0, u1, u2, u3 ] of { _ALG_ _TUP_2 (u4 :: Integer) (u5 :: Integer) -> u5; _NO_DEFLT_ } _N_} _F_ _IF_ARGS_ 0 2 XX 5 \ (u0 :: Integer) (u1 :: Integer) -> case _APP_ _CONSTM_ Integral quotRem (Integer) [ u0, u1 ] of { _ALG_ _TUP_2 (u2 :: Integer) (u3 :: Integer) -> u3; _NO_DEFLT_ } _N_,
- div = _A_ 2 _U_ 12 _N_ _S_ "U(PPP)U(PPP)" {_A_ 4 _U_ 2222 _N_ _N_ _F_ _IF_ARGS_ 0 4 XXXX 7 \ (u0 :: Int#) (u1 :: Int#) (u2 :: ByteArray#) (u3 :: Integer) -> case _APP_ _WRKR_ _CONSTM_ Integral divMod (Integer) [ u0, u1, u2, u3 ] of { _ALG_ _TUP_2 (u4 :: Integer) (u5 :: Integer) -> u4; _NO_DEFLT_ } _N_} _F_ _IF_ARGS_ 0 2 XX 5 \ (u0 :: Integer) (u1 :: Integer) -> case _APP_ _CONSTM_ Integral divMod (Integer) [ u0, u1 ] of { _ALG_ _TUP_2 (u2 :: Integer) (u3 :: Integer) -> u2; _NO_DEFLT_ } _N_,
- mod = _A_ 2 _U_ 12 _N_ _S_ "U(PPP)U(PPP)" {_A_ 4 _U_ 2222 _N_ _N_ _F_ _IF_ARGS_ 0 4 XXXX 7 \ (u0 :: Int#) (u1 :: Int#) (u2 :: ByteArray#) (u3 :: Integer) -> case _APP_ _WRKR_ _CONSTM_ Integral divMod (Integer) [ u0, u1, u2, u3 ] of { _ALG_ _TUP_2 (u4 :: Integer) (u5 :: Integer) -> u5; _NO_DEFLT_ } _N_} _F_ _IF_ARGS_ 0 2 XX 5 \ (u0 :: Integer) (u1 :: Integer) -> case _APP_ _CONSTM_ Integral divMod (Integer) [ u0, u1 ] of { _ALG_ _TUP_2 (u2 :: Integer) (u3 :: Integer) -> u3; _NO_DEFLT_ } _N_,
- quotRem = _A_ 2 _U_ 11 _N_ _S_ "U(PPP)U(PPP)" {_A_ 4 _U_ 2221 _N_ _N_ _N_ _N_} _N_ _N_,
- divMod = _A_ 2 _U_ 12 _N_ _S_ "U(PPP)U(PPP)" {_A_ 4 _U_ 2222 _N_ _N_ _N_ _N_} _N_ _N_,
- even = _A_ 1 _U_ 1 _N_ _S_ "U(PPP)" {_A_ 3 _U_ 222 _N_ _N_ _N_ _N_} _N_ _N_,
- odd = _A_ 1 _U_ 1 _N_ _S_ "U(PPP)" {_A_ 3 _U_ 222 _N_ _N_ _N_ _N_} _N_ _N_,
- toInteger = _A_ 1 _U_ 1 _N_ _S_ "U(PPP)" {_A_ 3 _U_ 222 _N_ _N_ _F_ _IF_ARGS_ 0 3 XXX 4 \ (u0 :: Int#) (u1 :: Int#) (u2 :: ByteArray#) -> _!_ J# [] [u0, u1, u2] _N_} _F_ _IF_ARGS_ 0 1 X 1 \ (u0 :: Integer) -> u0 _N_,
- toInt = _A_ 1 _U_ 1 _N_ _S_ "U(PPP)" {_A_ 3 _U_ 222 _N_ _N_ _F_ _IF_ARGS_ 0 3 XXX 3 \ (u0 :: Int#) (u1 :: Int#) (u2 :: ByteArray#) -> case _#_ integer2Int# [] [u0, u1, u2] of { _PRIM_ (u3 :: Int#) -> _!_ I# [] [u3] } _N_} _F_ _IF_ARGS_ 0 1 C 4 \ (u0 :: Integer) -> case u0 of { _ALG_ J# (u1 :: Int#) (u2 :: Int#) (u3 :: ByteArray#) -> case _#_ integer2Int# [] [u1, u2, u3] of { _PRIM_ (u4 :: Int#) -> _!_ I# [] [u4] }; _NO_DEFLT_ } _N_ #-}
+ quot = { _A_ 2 _U_ 11 _N_ _S_ "U(PPP)U(PPP)" {_A_ 4 _U_ 2221 _N_ _N_ _F_ _IF_ARGS_ 0 4 XXXX 7 \ (u0 :: Int#) (u1 :: Int#) (u2 :: ByteArray#) (u3 :: Integer) -> case _APP_ _WRKR_ _CONSTM_ Integral quotRem (Integer) [ u0, u1, u2, u3 ] of { _ALG_ _TUP_2 (u4 :: Integer) (u5 :: Integer) -> u4; _NO_DEFLT_ } _N_} _F_ _IF_ARGS_ 0 2 XX 5 \ (u0 :: Integer) (u1 :: Integer) -> case _APP_ _CONSTM_ Integral quotRem (Integer) [ u0, u1 ] of { _ALG_ _TUP_2 (u2 :: Integer) (u3 :: Integer) -> u2; _NO_DEFLT_ } _N_ },
+ rem = { _A_ 2 _U_ 11 _N_ _S_ "U(PPP)U(PPP)" {_A_ 4 _U_ 2221 _N_ _N_ _F_ _IF_ARGS_ 0 4 XXXX 7 \ (u0 :: Int#) (u1 :: Int#) (u2 :: ByteArray#) (u3 :: Integer) -> case _APP_ _WRKR_ _CONSTM_ Integral quotRem (Integer) [ u0, u1, u2, u3 ] of { _ALG_ _TUP_2 (u4 :: Integer) (u5 :: Integer) -> u5; _NO_DEFLT_ } _N_} _F_ _IF_ARGS_ 0 2 XX 5 \ (u0 :: Integer) (u1 :: Integer) -> case _APP_ _CONSTM_ Integral quotRem (Integer) [ u0, u1 ] of { _ALG_ _TUP_2 (u2 :: Integer) (u3 :: Integer) -> u3; _NO_DEFLT_ } _N_ },
+ div = { _A_ 2 _U_ 12 _N_ _S_ "U(PPP)U(PPP)" {_A_ 4 _U_ 2222 _N_ _N_ _F_ _IF_ARGS_ 0 4 XXXX 7 \ (u0 :: Int#) (u1 :: Int#) (u2 :: ByteArray#) (u3 :: Integer) -> case _APP_ _WRKR_ _CONSTM_ Integral divMod (Integer) [ u0, u1, u2, u3 ] of { _ALG_ _TUP_2 (u4 :: Integer) (u5 :: Integer) -> u4; _NO_DEFLT_ } _N_} _F_ _IF_ARGS_ 0 2 XX 5 \ (u0 :: Integer) (u1 :: Integer) -> case _APP_ _CONSTM_ Integral divMod (Integer) [ u0, u1 ] of { _ALG_ _TUP_2 (u2 :: Integer) (u3 :: Integer) -> u2; _NO_DEFLT_ } _N_ },
+ mod = { _A_ 2 _U_ 12 _N_ _S_ "U(PPP)U(PPP)" {_A_ 4 _U_ 2222 _N_ _N_ _F_ _IF_ARGS_ 0 4 XXXX 7 \ (u0 :: Int#) (u1 :: Int#) (u2 :: ByteArray#) (u3 :: Integer) -> case _APP_ _WRKR_ _CONSTM_ Integral divMod (Integer) [ u0, u1, u2, u3 ] of { _ALG_ _TUP_2 (u4 :: Integer) (u5 :: Integer) -> u5; _NO_DEFLT_ } _N_} _F_ _IF_ARGS_ 0 2 XX 5 \ (u0 :: Integer) (u1 :: Integer) -> case _APP_ _CONSTM_ Integral divMod (Integer) [ u0, u1 ] of { _ALG_ _TUP_2 (u2 :: Integer) (u3 :: Integer) -> u3; _NO_DEFLT_ } _N_ },
+ quotRem = { _A_ 2 _U_ 11 _N_ _S_ "U(PPP)U(PPP)" {_A_ 4 _U_ 2221 _N_ _N_ _N_ _N_} _N_ _N_ },
+ divMod = { _A_ 2 _U_ 12 _N_ _S_ "U(PPP)U(PPP)" {_A_ 4 _U_ 2222 _N_ _N_ _N_ _N_} _N_ _N_ },
+ even = { _A_ 1 _U_ 1 _N_ _S_ "U(PPP)" {_A_ 3 _U_ 222 _N_ _N_ _N_ _N_} _N_ _N_ },
+ odd = { _A_ 1 _U_ 1 _N_ _S_ "U(PPP)" {_A_ 3 _U_ 222 _N_ _N_ _N_ _N_} _N_ _N_ },
+ toInteger = { _A_ 1 _U_ 1 _N_ _S_ "U(PPP)" {_A_ 3 _U_ 222 _N_ _N_ _F_ _IF_ARGS_ 0 3 XXX 4 \ (u0 :: Int#) (u1 :: Int#) (u2 :: ByteArray#) -> _!_ J# [] [u0, u1, u2] _N_} _F_ _IF_ARGS_ 0 1 X 1 \ (u0 :: Integer) -> u0 _N_ },
+ toInt = { _A_ 1 _U_ 1 _N_ _S_ "U(PPP)" {_A_ 3 _U_ 222 _N_ _N_ _F_ _IF_ARGS_ 0 3 XXX 3 \ (u0 :: Int#) (u1 :: Int#) (u2 :: ByteArray#) -> case _#_ integer2Int# [] [u0, u1, u2] of { _PRIM_ (u3 :: Int#) -> _!_ I# [] [u3] } _N_} _F_ _IF_ARGS_ 0 1 C 4 \ (u0 :: Integer) -> case u0 of { _ALG_ J# (u1 :: Int#) (u2 :: Int#) (u3 :: ByteArray#) -> case _#_ integer2Int# [] [u1, u2, u3] of { _PRIM_ (u4 :: Int#) -> _!_ I# [] [u4] }; _NO_DEFLT_ } _N_ } #-}
instance Ix Integer
{-# GHC_PRAGMA _M_ PreludeCore {-dfun-} _A_ 0 _N_ _N_ _N_ _F_ _IF_ARGS_ 0 0 X 5 _!_ _TUP_4 [{{Ord Integer}}, ((Integer, Integer) -> [Integer]), ((Integer, Integer) -> Integer -> Int), ((Integer, Integer) -> Integer -> Bool)] [_DFUN_ Ord (Integer), _CONSTM_ Ix range (Integer), _CONSTM_ Ix index (Integer), _CONSTM_ Ix inRange (Integer)] _N_
- range = _A_ 1 _U_ 1 _N_ _S_ "U(LL)" {_A_ 2 _U_ 22 _N_ _N_ _F_ _IF_ARGS_ 0 0 X 1 _CONSTM_ Enum enumFromTo (Integer) _N_} _F_ _IF_ARGS_ 0 1 C 4 \ (u0 :: (Integer, Integer)) -> case u0 of { _ALG_ _TUP_2 (u1 :: Integer) (u2 :: Integer) -> _APP_ _CONSTM_ Enum enumFromTo (Integer) [ u1, u2 ]; _NO_DEFLT_ } _N_,
- index = _A_ 2 _U_ 12 _N_ _S_ "U(U(PPP)L)U(PPP)" {_A_ 5 _U_ 22222 _N_ _N_ _N_ _N_} _N_ _N_,
- inRange = _A_ 2 _U_ 11 _N_ _S_ "U(U(PPP)L)U(PPP)" {_A_ 5 _U_ 22211 _N_ _N_ _F_ _IF_ARGS_ 0 5 XXXCC 9 \ (u0 :: Int#) (u1 :: Int#) (u2 :: ByteArray#) (u3 :: Integer) (u4 :: Integer) -> case u4 of { _ALG_ J# (u5 :: Int#) (u6 :: Int#) (u7 :: ByteArray#) -> case _#_ cmpInteger# [] [u0, u1, u2, u5, u6, u7] of { _PRIM_ (u8 :: Int#) -> case _#_ leInt# [] [u8, 0#] of { _ALG_ True -> case u3 of { _ALG_ J# (u9 :: Int#) (ua :: Int#) (ub :: ByteArray#) -> case _#_ cmpInteger# [] [u5, u6, u7, u9, ua, ub] of { _PRIM_ (uc :: Int#) -> _#_ leInt# [] [uc, 0#] }; _NO_DEFLT_ }; False -> _!_ False [] []; _NO_DEFLT_ } }; _NO_DEFLT_ } _N_} _N_ _N_ #-}
+ range = { _A_ 1 _U_ 1 _N_ _S_ "U(LL)" {_A_ 2 _U_ 22 _N_ _N_ _F_ _IF_ARGS_ 0 0 X 1 _CONSTM_ Enum enumFromTo (Integer) _N_} _F_ _IF_ARGS_ 0 1 C 4 \ (u0 :: (Integer, Integer)) -> case u0 of { _ALG_ _TUP_2 (u1 :: Integer) (u2 :: Integer) -> _APP_ _CONSTM_ Enum enumFromTo (Integer) [ u1, u2 ]; _NO_DEFLT_ } _N_ },
+ index = { _A_ 2 _U_ 12 _N_ _S_ "U(U(PPP)L)U(PPP)" {_A_ 5 _U_ 22222 _N_ _N_ _N_ _N_} _N_ _N_ },
+ inRange = { _A_ 2 _U_ 11 _N_ _S_ "U(U(PPP)L)U(PPP)" {_A_ 5 _U_ 22211 _N_ _N_ _F_ _IF_ARGS_ 0 5 XXXCC 9 \ (u0 :: Int#) (u1 :: Int#) (u2 :: ByteArray#) (u3 :: Integer) (u4 :: Integer) -> case u4 of { _ALG_ J# (u5 :: Int#) (u6 :: Int#) (u7 :: ByteArray#) -> case _#_ cmpInteger# [] [u0, u1, u2, u5, u6, u7] of { _PRIM_ (u8 :: Int#) -> case _#_ leInt# [] [u8, 0#] of { _ALG_ True -> case u3 of { _ALG_ J# (u9 :: Int#) (ua :: Int#) (ub :: ByteArray#) -> case _#_ cmpInteger# [] [u5, u6, u7, u9, ua, ub] of { _PRIM_ (uc :: Int#) -> _#_ leInt# [] [uc, 0#] }; _NO_DEFLT_ }; False -> _!_ False [] []; _NO_DEFLT_ } }; _NO_DEFLT_ } _N_} _N_ _N_ } #-}
instance Num Integer
{-# GHC_PRAGMA _M_ PreludeCore {-dfun-} _A_ 0 _N_ _N_ _N_ _F_ _IF_ARGS_ 0 0 X 11 _!_ _TUP_10 [{{Eq Integer}}, {{Text Integer}}, (Integer -> Integer -> Integer), (Integer -> Integer -> Integer), (Integer -> Integer -> Integer), (Integer -> Integer), (Integer -> Integer), (Integer -> Integer), (Integer -> Integer), (Int -> Integer)] [_DFUN_ Eq (Integer), _DFUN_ Text (Integer), _CONSTM_ Num (+) (Integer), _CONSTM_ Num (-) (Integer), _CONSTM_ Num (*) (Integer), _CONSTM_ Num negate (Integer), _CONSTM_ Num abs (Integer), _CONSTM_ Num signum (Integer), _CONSTM_ Num fromInteger (Integer), _CONSTM_ Num fromInt (Integer)] _N_
- (+) = _A_ 2 _U_ 11 _N_ _S_ "U(PPP)U(PPP)" {_A_ 4 _U_ 2221 _N_ _N_ _F_ _IF_ARGS_ 0 4 XXXC 5 \ (u0 :: Int#) (u1 :: Int#) (u2 :: ByteArray#) (u3 :: Integer) -> case u3 of { _ALG_ J# (u4 :: Int#) (u5 :: Int#) (u6 :: ByteArray#) -> _#_ plusInteger# [] [u0, u1, u2, u4, u5, u6]; _NO_DEFLT_ } _N_} _F_ _IF_ARGS_ 0 2 CC 6 \ (u0 :: Integer) (u1 :: Integer) -> case u0 of { _ALG_ J# (u2 :: Int#) (u3 :: Int#) (u4 :: ByteArray#) -> case u1 of { _ALG_ J# (u5 :: Int#) (u6 :: Int#) (u7 :: ByteArray#) -> _#_ plusInteger# [] [u2, u3, u4, u5, u6, u7]; _NO_DEFLT_ }; _NO_DEFLT_ } _N_,
- (-) = _A_ 2 _U_ 11 _N_ _S_ "U(PPP)U(PPP)" {_A_ 4 _U_ 2221 _N_ _N_ _F_ _IF_ARGS_ 0 4 XXXC 5 \ (u0 :: Int#) (u1 :: Int#) (u2 :: ByteArray#) (u3 :: Integer) -> case u3 of { _ALG_ J# (u4 :: Int#) (u5 :: Int#) (u6 :: ByteArray#) -> _#_ minusInteger# [] [u0, u1, u2, u4, u5, u6]; _NO_DEFLT_ } _N_} _F_ _IF_ARGS_ 0 2 CC 6 \ (u0 :: Integer) (u1 :: Integer) -> case u0 of { _ALG_ J# (u2 :: Int#) (u3 :: Int#) (u4 :: ByteArray#) -> case u1 of { _ALG_ J# (u5 :: Int#) (u6 :: Int#) (u7 :: ByteArray#) -> _#_ minusInteger# [] [u2, u3, u4, u5, u6, u7]; _NO_DEFLT_ }; _NO_DEFLT_ } _N_,
- (*) = _A_ 2 _U_ 11 _N_ _S_ "U(PPP)U(PPP)" {_A_ 4 _U_ 2221 _N_ _N_ _F_ _IF_ARGS_ 0 4 XXXC 5 \ (u0 :: Int#) (u1 :: Int#) (u2 :: ByteArray#) (u3 :: Integer) -> case u3 of { _ALG_ J# (u4 :: Int#) (u5 :: Int#) (u6 :: ByteArray#) -> _#_ timesInteger# [] [u0, u1, u2, u4, u5, u6]; _NO_DEFLT_ } _N_} _F_ _IF_ARGS_ 0 2 CC 6 \ (u0 :: Integer) (u1 :: Integer) -> case u0 of { _ALG_ J# (u2 :: Int#) (u3 :: Int#) (u4 :: ByteArray#) -> case u1 of { _ALG_ J# (u5 :: Int#) (u6 :: Int#) (u7 :: ByteArray#) -> _#_ timesInteger# [] [u2, u3, u4, u5, u6, u7]; _NO_DEFLT_ }; _NO_DEFLT_ } _N_,
- negate = _A_ 1 _U_ 1 _N_ _S_ "U(PPP)" {_A_ 3 _U_ 222 _N_ _N_ _F_ _IF_ARGS_ 0 3 XXX 4 \ (u0 :: Int#) (u1 :: Int#) (u2 :: ByteArray#) -> _#_ negateInteger# [] [u0, u1, u2] _N_} _F_ _IF_ARGS_ 0 1 C 5 \ (u0 :: Integer) -> case u0 of { _ALG_ J# (u1 :: Int#) (u2 :: Int#) (u3 :: ByteArray#) -> _#_ negateInteger# [] [u1, u2, u3]; _NO_DEFLT_ } _N_,
- abs = _A_ 1 _U_ 1 _N_ _S_ "U(PPP)" {_A_ 3 _U_ 222 _N_ _N_ _N_ _N_} _N_ _N_,
- signum = _A_ 1 _U_ 1 _N_ _S_ "U(PPP)" {_A_ 3 _U_ 222 _N_ _N_ _N_ _N_} _N_ _N_,
- fromInteger = _A_ 1 _U_ 1 _N_ _S_ "U(PPP)" {_A_ 3 _U_ 222 _N_ _N_ _F_ _IF_ARGS_ 0 3 XXX 4 \ (u0 :: Int#) (u1 :: Int#) (u2 :: ByteArray#) -> _!_ J# [] [u0, u1, u2] _N_} _F_ _IF_ARGS_ 0 1 X 1 \ (u0 :: Integer) -> u0 _N_,
- fromInt = _A_ 1 _U_ 1 _N_ _S_ "U(P)" {_A_ 1 _U_ 2 _N_ _N_ _F_ _IF_ARGS_ 0 1 X 1 \ (u0 :: Int#) -> _#_ int2Integer# [] [u0] _N_} _F_ _IF_ARGS_ 0 1 C 2 \ (u0 :: Int) -> case u0 of { _ALG_ I# (u1 :: Int#) -> _#_ int2Integer# [] [u1]; _NO_DEFLT_ } _N_ #-}
+ (+) = { _A_ 2 _U_ 11 _N_ _S_ "U(PPP)U(PPP)" {_A_ 4 _U_ 2221 _N_ _N_ _F_ _IF_ARGS_ 0 4 XXXC 5 \ (u0 :: Int#) (u1 :: Int#) (u2 :: ByteArray#) (u3 :: Integer) -> case u3 of { _ALG_ J# (u4 :: Int#) (u5 :: Int#) (u6 :: ByteArray#) -> _#_ plusInteger# [] [u0, u1, u2, u4, u5, u6]; _NO_DEFLT_ } _N_} _F_ _IF_ARGS_ 0 2 CC 6 \ (u0 :: Integer) (u1 :: Integer) -> case u0 of { _ALG_ J# (u2 :: Int#) (u3 :: Int#) (u4 :: ByteArray#) -> case u1 of { _ALG_ J# (u5 :: Int#) (u6 :: Int#) (u7 :: ByteArray#) -> _#_ plusInteger# [] [u2, u3, u4, u5, u6, u7]; _NO_DEFLT_ }; _NO_DEFLT_ } _N_ },
+ (-) = { _A_ 2 _U_ 11 _N_ _S_ "U(PPP)U(PPP)" {_A_ 4 _U_ 2221 _N_ _N_ _F_ _IF_ARGS_ 0 4 XXXC 5 \ (u0 :: Int#) (u1 :: Int#) (u2 :: ByteArray#) (u3 :: Integer) -> case u3 of { _ALG_ J# (u4 :: Int#) (u5 :: Int#) (u6 :: ByteArray#) -> _#_ minusInteger# [] [u0, u1, u2, u4, u5, u6]; _NO_DEFLT_ } _N_} _F_ _IF_ARGS_ 0 2 CC 6 \ (u0 :: Integer) (u1 :: Integer) -> case u0 of { _ALG_ J# (u2 :: Int#) (u3 :: Int#) (u4 :: ByteArray#) -> case u1 of { _ALG_ J# (u5 :: Int#) (u6 :: Int#) (u7 :: ByteArray#) -> _#_ minusInteger# [] [u2, u3, u4, u5, u6, u7]; _NO_DEFLT_ }; _NO_DEFLT_ } _N_ },
+ (*) = { _A_ 2 _U_ 11 _N_ _S_ "U(PPP)U(PPP)" {_A_ 4 _U_ 2221 _N_ _N_ _F_ _IF_ARGS_ 0 4 XXXC 5 \ (u0 :: Int#) (u1 :: Int#) (u2 :: ByteArray#) (u3 :: Integer) -> case u3 of { _ALG_ J# (u4 :: Int#) (u5 :: Int#) (u6 :: ByteArray#) -> _#_ timesInteger# [] [u0, u1, u2, u4, u5, u6]; _NO_DEFLT_ } _N_} _F_ _IF_ARGS_ 0 2 CC 6 \ (u0 :: Integer) (u1 :: Integer) -> case u0 of { _ALG_ J# (u2 :: Int#) (u3 :: Int#) (u4 :: ByteArray#) -> case u1 of { _ALG_ J# (u5 :: Int#) (u6 :: Int#) (u7 :: ByteArray#) -> _#_ timesInteger# [] [u2, u3, u4, u5, u6, u7]; _NO_DEFLT_ }; _NO_DEFLT_ } _N_ },
+ negate = { _A_ 1 _U_ 1 _N_ _S_ "U(PPP)" {_A_ 3 _U_ 222 _N_ _N_ _F_ _IF_ARGS_ 0 3 XXX 4 \ (u0 :: Int#) (u1 :: Int#) (u2 :: ByteArray#) -> _#_ negateInteger# [] [u0, u1, u2] _N_} _F_ _IF_ARGS_ 0 1 C 5 \ (u0 :: Integer) -> case u0 of { _ALG_ J# (u1 :: Int#) (u2 :: Int#) (u3 :: ByteArray#) -> _#_ negateInteger# [] [u1, u2, u3]; _NO_DEFLT_ } _N_ },
+ abs = { _A_ 1 _U_ 1 _N_ _S_ "U(PPP)" {_A_ 3 _U_ 222 _N_ _N_ _N_ _N_} _N_ _N_ },
+ signum = { _A_ 1 _U_ 1 _N_ _S_ "U(PPP)" {_A_ 3 _U_ 222 _N_ _N_ _N_ _N_} _N_ _N_ },
+ fromInteger = { _A_ 1 _U_ 1 _N_ _S_ "U(PPP)" {_A_ 3 _U_ 222 _N_ _N_ _F_ _IF_ARGS_ 0 3 XXX 4 \ (u0 :: Int#) (u1 :: Int#) (u2 :: ByteArray#) -> _!_ J# [] [u0, u1, u2] _N_} _F_ _IF_ARGS_ 0 1 X 1 \ (u0 :: Integer) -> u0 _N_ },
+ fromInt = { _A_ 1 _U_ 1 _N_ _S_ "U(P)" {_A_ 1 _U_ 2 _N_ _N_ _F_ _IF_ARGS_ 0 1 X 1 \ (u0 :: Int#) -> _#_ int2Integer# [] [u0] _N_} _F_ _IF_ARGS_ 0 1 C 2 \ (u0 :: Int) -> case u0 of { _ALG_ I# (u1 :: Int#) -> _#_ int2Integer# [] [u1]; _NO_DEFLT_ } _N_ } #-}
instance Ord Integer
{-# GHC_PRAGMA _M_ PreludeCore {-dfun-} _A_ 0 _N_ _N_ _N_ _F_ _IF_ARGS_ 0 0 X 9 _!_ _TUP_8 [{{Eq Integer}}, (Integer -> Integer -> Bool), (Integer -> Integer -> Bool), (Integer -> Integer -> Bool), (Integer -> Integer -> Bool), (Integer -> Integer -> Integer), (Integer -> Integer -> Integer), (Integer -> Integer -> _CMP_TAG)] [_DFUN_ Eq (Integer), _CONSTM_ Ord (<) (Integer), _CONSTM_ Ord (<=) (Integer), _CONSTM_ Ord (>=) (Integer), _CONSTM_ Ord (>) (Integer), _CONSTM_ Ord max (Integer), _CONSTM_ Ord min (Integer), _CONSTM_ Ord _tagCmp (Integer)] _N_
- (<) = _A_ 2 _U_ 11 _N_ _S_ "U(PPP)U(PPP)" {_A_ 4 _U_ 2221 _N_ _N_ _F_ _IF_ARGS_ 0 4 XXXC 3 \ (u0 :: Int#) (u1 :: Int#) (u2 :: ByteArray#) (u3 :: Integer) -> case u3 of { _ALG_ J# (u4 :: Int#) (u5 :: Int#) (u6 :: ByteArray#) -> case _#_ cmpInteger# [] [u0, u1, u2, u4, u5, u6] of { _PRIM_ (u7 :: Int#) -> _#_ ltInt# [] [u7, 0#] }; _NO_DEFLT_ } _N_} _F_ _IF_ARGS_ 0 2 CC 4 \ (u0 :: Integer) (u1 :: Integer) -> case u0 of { _ALG_ J# (u2 :: Int#) (u3 :: Int#) (u4 :: ByteArray#) -> case u1 of { _ALG_ J# (u5 :: Int#) (u6 :: Int#) (u7 :: ByteArray#) -> case _#_ cmpInteger# [] [u2, u3, u4, u5, u6, u7] of { _PRIM_ (u8 :: Int#) -> _#_ ltInt# [] [u8, 0#] }; _NO_DEFLT_ }; _NO_DEFLT_ } _N_,
- (<=) = _A_ 2 _U_ 11 _N_ _S_ "U(PPP)U(PPP)" {_A_ 4 _U_ 2221 _N_ _N_ _F_ _IF_ARGS_ 0 4 XXXC 3 \ (u0 :: Int#) (u1 :: Int#) (u2 :: ByteArray#) (u3 :: Integer) -> case u3 of { _ALG_ J# (u4 :: Int#) (u5 :: Int#) (u6 :: ByteArray#) -> case _#_ cmpInteger# [] [u0, u1, u2, u4, u5, u6] of { _PRIM_ (u7 :: Int#) -> _#_ leInt# [] [u7, 0#] }; _NO_DEFLT_ } _N_} _F_ _IF_ARGS_ 0 2 CC 4 \ (u0 :: Integer) (u1 :: Integer) -> case u0 of { _ALG_ J# (u2 :: Int#) (u3 :: Int#) (u4 :: ByteArray#) -> case u1 of { _ALG_ J# (u5 :: Int#) (u6 :: Int#) (u7 :: ByteArray#) -> case _#_ cmpInteger# [] [u2, u3, u4, u5, u6, u7] of { _PRIM_ (u8 :: Int#) -> _#_ leInt# [] [u8, 0#] }; _NO_DEFLT_ }; _NO_DEFLT_ } _N_,
- (>=) = _A_ 2 _U_ 11 _N_ _S_ "U(PPP)U(PPP)" {_A_ 4 _U_ 2221 _N_ _N_ _F_ _IF_ARGS_ 0 4 XXXC 3 \ (u0 :: Int#) (u1 :: Int#) (u2 :: ByteArray#) (u3 :: Integer) -> case u3 of { _ALG_ J# (u4 :: Int#) (u5 :: Int#) (u6 :: ByteArray#) -> case _#_ cmpInteger# [] [u0, u1, u2, u4, u5, u6] of { _PRIM_ (u7 :: Int#) -> _#_ geInt# [] [u7, 0#] }; _NO_DEFLT_ } _N_} _F_ _IF_ARGS_ 0 2 CC 4 \ (u0 :: Integer) (u1 :: Integer) -> case u0 of { _ALG_ J# (u2 :: Int#) (u3 :: Int#) (u4 :: ByteArray#) -> case u1 of { _ALG_ J# (u5 :: Int#) (u6 :: Int#) (u7 :: ByteArray#) -> case _#_ cmpInteger# [] [u2, u3, u4, u5, u6, u7] of { _PRIM_ (u8 :: Int#) -> _#_ geInt# [] [u8, 0#] }; _NO_DEFLT_ }; _NO_DEFLT_ } _N_,
- (>) = _A_ 2 _U_ 11 _N_ _S_ "U(PPP)U(PPP)" {_A_ 4 _U_ 2221 _N_ _N_ _F_ _IF_ARGS_ 0 4 XXXC 3 \ (u0 :: Int#) (u1 :: Int#) (u2 :: ByteArray#) (u3 :: Integer) -> case u3 of { _ALG_ J# (u4 :: Int#) (u5 :: Int#) (u6 :: ByteArray#) -> case _#_ cmpInteger# [] [u0, u1, u2, u4, u5, u6] of { _PRIM_ (u7 :: Int#) -> _#_ gtInt# [] [u7, 0#] }; _NO_DEFLT_ } _N_} _F_ _IF_ARGS_ 0 2 CC 4 \ (u0 :: Integer) (u1 :: Integer) -> case u0 of { _ALG_ J# (u2 :: Int#) (u3 :: Int#) (u4 :: ByteArray#) -> case u1 of { _ALG_ J# (u5 :: Int#) (u6 :: Int#) (u7 :: ByteArray#) -> case _#_ cmpInteger# [] [u2, u3, u4, u5, u6, u7] of { _PRIM_ (u8 :: Int#) -> _#_ gtInt# [] [u8, 0#] }; _NO_DEFLT_ }; _NO_DEFLT_ } _N_,
- max = _A_ 2 _U_ 11 _N_ _S_ "U(PPP)U(PPP)" {_A_ 4 _U_ 2221 _N_ _N_ _N_ _N_} _N_ _N_,
- min = _A_ 2 _U_ 11 _N_ _S_ "U(PPP)U(PPP)" {_A_ 4 _U_ 2221 _N_ _N_ _N_ _N_} _N_ _N_,
- _tagCmp = _A_ 2 _U_ 11 _N_ _S_ "U(PPP)U(PPP)" {_A_ 4 _U_ 2221 _N_ _N_ _N_ _N_} _N_ _N_ #-}
+ (<) = { _A_ 2 _U_ 11 _N_ _S_ "U(PPP)U(PPP)" {_A_ 4 _U_ 2221 _N_ _N_ _F_ _IF_ARGS_ 0 4 XXXC 3 \ (u0 :: Int#) (u1 :: Int#) (u2 :: ByteArray#) (u3 :: Integer) -> case u3 of { _ALG_ J# (u4 :: Int#) (u5 :: Int#) (u6 :: ByteArray#) -> case _#_ cmpInteger# [] [u0, u1, u2, u4, u5, u6] of { _PRIM_ (u7 :: Int#) -> _#_ ltInt# [] [u7, 0#] }; _NO_DEFLT_ } _N_} _F_ _IF_ARGS_ 0 2 CC 4 \ (u0 :: Integer) (u1 :: Integer) -> case u0 of { _ALG_ J# (u2 :: Int#) (u3 :: Int#) (u4 :: ByteArray#) -> case u1 of { _ALG_ J# (u5 :: Int#) (u6 :: Int#) (u7 :: ByteArray#) -> case _#_ cmpInteger# [] [u2, u3, u4, u5, u6, u7] of { _PRIM_ (u8 :: Int#) -> _#_ ltInt# [] [u8, 0#] }; _NO_DEFLT_ }; _NO_DEFLT_ } _N_ },
+ (<=) = { _A_ 2 _U_ 11 _N_ _S_ "U(PPP)U(PPP)" {_A_ 4 _U_ 2221 _N_ _N_ _F_ _IF_ARGS_ 0 4 XXXC 3 \ (u0 :: Int#) (u1 :: Int#) (u2 :: ByteArray#) (u3 :: Integer) -> case u3 of { _ALG_ J# (u4 :: Int#) (u5 :: Int#) (u6 :: ByteArray#) -> case _#_ cmpInteger# [] [u0, u1, u2, u4, u5, u6] of { _PRIM_ (u7 :: Int#) -> _#_ leInt# [] [u7, 0#] }; _NO_DEFLT_ } _N_} _F_ _IF_ARGS_ 0 2 CC 4 \ (u0 :: Integer) (u1 :: Integer) -> case u0 of { _ALG_ J# (u2 :: Int#) (u3 :: Int#) (u4 :: ByteArray#) -> case u1 of { _ALG_ J# (u5 :: Int#) (u6 :: Int#) (u7 :: ByteArray#) -> case _#_ cmpInteger# [] [u2, u3, u4, u5, u6, u7] of { _PRIM_ (u8 :: Int#) -> _#_ leInt# [] [u8, 0#] }; _NO_DEFLT_ }; _NO_DEFLT_ } _N_ },
+ (>=) = { _A_ 2 _U_ 11 _N_ _S_ "U(PPP)U(PPP)" {_A_ 4 _U_ 2221 _N_ _N_ _F_ _IF_ARGS_ 0 4 XXXC 3 \ (u0 :: Int#) (u1 :: Int#) (u2 :: ByteArray#) (u3 :: Integer) -> case u3 of { _ALG_ J# (u4 :: Int#) (u5 :: Int#) (u6 :: ByteArray#) -> case _#_ cmpInteger# [] [u0, u1, u2, u4, u5, u6] of { _PRIM_ (u7 :: Int#) -> _#_ geInt# [] [u7, 0#] }; _NO_DEFLT_ } _N_} _F_ _IF_ARGS_ 0 2 CC 4 \ (u0 :: Integer) (u1 :: Integer) -> case u0 of { _ALG_ J# (u2 :: Int#) (u3 :: Int#) (u4 :: ByteArray#) -> case u1 of { _ALG_ J# (u5 :: Int#) (u6 :: Int#) (u7 :: ByteArray#) -> case _#_ cmpInteger# [] [u2, u3, u4, u5, u6, u7] of { _PRIM_ (u8 :: Int#) -> _#_ geInt# [] [u8, 0#] }; _NO_DEFLT_ }; _NO_DEFLT_ } _N_ },
+ (>) = { _A_ 2 _U_ 11 _N_ _S_ "U(PPP)U(PPP)" {_A_ 4 _U_ 2221 _N_ _N_ _F_ _IF_ARGS_ 0 4 XXXC 3 \ (u0 :: Int#) (u1 :: Int#) (u2 :: ByteArray#) (u3 :: Integer) -> case u3 of { _ALG_ J# (u4 :: Int#) (u5 :: Int#) (u6 :: ByteArray#) -> case _#_ cmpInteger# [] [u0, u1, u2, u4, u5, u6] of { _PRIM_ (u7 :: Int#) -> _#_ gtInt# [] [u7, 0#] }; _NO_DEFLT_ } _N_} _F_ _IF_ARGS_ 0 2 CC 4 \ (u0 :: Integer) (u1 :: Integer) -> case u0 of { _ALG_ J# (u2 :: Int#) (u3 :: Int#) (u4 :: ByteArray#) -> case u1 of { _ALG_ J# (u5 :: Int#) (u6 :: Int#) (u7 :: ByteArray#) -> case _#_ cmpInteger# [] [u2, u3, u4, u5, u6, u7] of { _PRIM_ (u8 :: Int#) -> _#_ gtInt# [] [u8, 0#] }; _NO_DEFLT_ }; _NO_DEFLT_ } _N_ },
+ max = { _A_ 2 _U_ 11 _N_ _S_ "U(PPP)U(PPP)" {_A_ 4 _U_ 2221 _N_ _N_ _N_ _N_} _N_ _N_ },
+ min = { _A_ 2 _U_ 11 _N_ _S_ "U(PPP)U(PPP)" {_A_ 4 _U_ 2221 _N_ _N_ _N_ _N_} _N_ _N_ },
+ _tagCmp = { _A_ 2 _U_ 11 _N_ _S_ "U(PPP)U(PPP)" {_A_ 4 _U_ 2221 _N_ _N_ _N_ _N_} _N_ _N_ } #-}
instance Real Integer
{-# GHC_PRAGMA _M_ PreludeCore {-dfun-} _A_ 0 _N_ _N_ _N_ _F_ _IF_ARGS_ 0 0 X 4 _!_ _TUP_3 [{{Num Integer}}, {{Enum Integer}}, (Integer -> Ratio Integer)] [_DFUN_ Num (Integer), _DFUN_ Enum (Integer), _CONSTM_ Real toRational (Integer)] _N_
- toRational = _A_ 1 _U_ 2 _N_ _N_ _N_ _N_ #-}
+ toRational = { _A_ 1 _U_ 2 _N_ _N_ _F_ _IF_ARGS_ 0 1 X 3 \ (u0 :: Integer) -> _!_ (:%) [Integer] [u0, _ORIG_ PreludeCore __integer1] _N_ } #-}
instance Text Integer
{-# GHC_PRAGMA _M_ PreludeCore {-dfun-} _A_ 0 _N_ _N_ _N_ _F_ _IF_ARGS_ 0 0 X 5 _!_ _TUP_4 [(Int -> [Char] -> [(Integer, [Char])]), (Int -> Integer -> [Char] -> [Char]), ([Char] -> [([Integer], [Char])]), ([Integer] -> [Char] -> [Char])] [_CONSTM_ Text readsPrec (Integer), _CONSTM_ Text showsPrec (Integer), _CONSTM_ Text readList (Integer), _CONSTM_ Text showList (Integer)] _N_
- readsPrec = _A_ 2 _U_ 02 _N_ _S_ "AL" {_A_ 1 _U_ 2 _N_ _N_ _F_ _IF_ARGS_ 0 1 X 3 \ (u0 :: [Char]) -> _APP_ _SPEC_ _ORIG_ PreludeText readSigned [ (Integer) ] [ _SPEC_ _ORIG_ PreludeText readDec [ (Integer) ], u0 ] _N_} _F_ _IF_ARGS_ 0 2 XX 3 \ (u0 :: Int) (u1 :: [Char]) -> _APP_ _SPEC_ _ORIG_ PreludeText readSigned [ (Integer) ] [ _SPEC_ _ORIG_ PreludeText readDec [ (Integer) ], u1 ] _N_,
- showsPrec = _A_ 3 _U_ 212 _N_ _S_ "LU(PPP)L" {_A_ 5 _U_ 22222 _N_ _N_ _N_ _N_} _N_ _N_,
- readList = _A_ 0 _U_ 2 _N_ _N_ _N_ _N_,
- showList = _A_ 0 _U_ 12 _N_ _N_ _N_ _N_ #-}
+ readsPrec = { _A_ 2 _U_ 02 _N_ _S_ "AL" {_A_ 1 _U_ 2 _N_ _N_ _F_ _IF_ARGS_ 0 1 X 3 \ (u0 :: [Char]) -> _APP_ _SPEC_ _ORIG_ PreludeText readSigned [ (Integer) ] [ _SPEC_ _ORIG_ PreludeText readDec [ (Integer) ], u0 ] _N_} _F_ _IF_ARGS_ 0 2 XX 3 \ (u0 :: Int) (u1 :: [Char]) -> _APP_ _SPEC_ _ORIG_ PreludeText readSigned [ (Integer) ] [ _SPEC_ _ORIG_ PreludeText readDec [ (Integer) ], u1 ] _N_ },
+ showsPrec = { _A_ 3 _U_ 212 _N_ _S_ "LU(PPP)L" {_A_ 5 _U_ 22222 _N_ _N_ _N_ _N_} _N_ _N_ },
+ readList = { _A_ 0 _U_ 2 _N_ _N_ _N_ _N_ },
+ showList = { _A_ 1 _U_ 12 _N_ _N_ _N_ _N_ } #-}
-{-# GHC_PRAGMA INTERFACE VERSION 5 #-}
+{-# GHC_PRAGMA INTERFACE VERSION 6 #-}
interface PreludeCore where
-import PreludeBuiltin(Int(..), Integer(..))
-_integer_0 :: Integer
- {-# GHC_PRAGMA _A_ 0 _N_ _N_ _N_ _F_ _IF_ARGS_ 0 0 X 1 _#_ int2Integer# [] [0#] _N_ #-}
-_integer_1 :: Integer
- {-# GHC_PRAGMA _A_ 0 _N_ _N_ _N_ _F_ _IF_ARGS_ 0 0 X 1 _#_ int2Integer# [] [1#] _N_ #-}
-_integer_m1 :: Integer
+import PreludeBuiltin(Integer(..))
+__integer0 :: Integer
+ {-# GHC_PRAGMA _A_ 0 _N_ _N_ _N_ _N_ _N_ #-}
+__integer1 :: Integer
+ {-# GHC_PRAGMA _A_ 0 _N_ _N_ _N_ _N_ _N_ #-}
+__integer2 :: Integer
+ {-# GHC_PRAGMA _A_ 0 _N_ _N_ _N_ _N_ _N_ #-}
+__integerm1 :: Integer
{-# GHC_PRAGMA _A_ 0 _N_ _N_ _N_ _N_ _N_ #-}
-int2Integer :: Int -> Integer
- {-# GHC_PRAGMA _A_ 1 _U_ 1 _N_ _S_ "U(P)" {_A_ 1 _U_ 2 _N_ _N_ _F_ _IF_ARGS_ 0 1 X 1 \ (u0 :: Int#) -> _#_ int2Integer# [] [u0] _N_} _F_ _IF_ARGS_ 0 1 C 2 \ (u0 :: Int) -> case u0 of { _ALG_ I# (u1 :: Int#) -> _#_ int2Integer# [] [u1]; _NO_DEFLT_ } _N_ #-}
instance Enum Integer
{-# GHC_PRAGMA _M_ PreludeCore {-dfun-} _A_ 0 _N_ _N_ _N_ _F_ _IF_ARGS_ 0 0 X 6 _!_ _TUP_5 [{{Ord Integer}}, (Integer -> [Integer]), (Integer -> Integer -> [Integer]), (Integer -> Integer -> [Integer]), (Integer -> Integer -> Integer -> [Integer])] [_DFUN_ Ord (Integer), _CONSTM_ Enum enumFrom (Integer), _CONSTM_ Enum enumFromThen (Integer), _CONSTM_ Enum enumFromTo (Integer), _CONSTM_ Enum enumFromThenTo (Integer)] _N_
- enumFrom = _A_ 1 _U_ 2 _N_ _N_ _N_ _N_,
- enumFromThen = _A_ 2 _U_ 21 _N_ _N_ _N_ _N_,
- enumFromTo = _A_ 2 _U_ 22 _N_ _N_ _N_ _N_,
- enumFromThenTo = _A_ 3 _U_ 222 _N_ _N_ _N_ _N_ #-}
+ enumFrom = { _A_ 1 _U_ 2 _N_ _N_ _N_ _N_ },
+ enumFromThen = { _A_ 2 _U_ 21 _N_ _N_ _N_ _N_ },
+ enumFromTo = { _A_ 2 _U_ 22 _N_ _N_ _N_ _N_ },
+ enumFromThenTo = { _A_ 3 _U_ 222 _N_ _N_ _N_ _N_ } #-}
instance Eq Integer
{-# GHC_PRAGMA _M_ PreludeCore {-dfun-} _A_ 0 _N_ _N_ _N_ _F_ _IF_ARGS_ 0 0 X 3 _!_ _TUP_2 [(Integer -> Integer -> Bool), (Integer -> Integer -> Bool)] [_CONSTM_ Eq (==) (Integer), _CONSTM_ Eq (/=) (Integer)] _N_
- (==) = _A_ 2 _U_ 11 _N_ _S_ "U(PPP)U(PPP)" {_A_ 4 _U_ 2221 _N_ _N_ _F_ _IF_ARGS_ 0 4 XXXC 4 \ (u0 :: Int#) (u1 :: Int#) (u2 :: ByteArray#) (u3 :: Integer) -> case u3 of { _ALG_ J# (u4 :: Int#) (u5 :: Int#) (u6 :: ByteArray#) -> case _#_ cmpInteger# [] [u0, u1, u2, u4, u5, u6] of { _PRIM_ 0# -> _!_ True [] []; (u7 :: Int#) -> _!_ False [] [] }; _NO_DEFLT_ } _N_} _F_ _IF_ARGS_ 0 2 CC 5 \ (u0 :: Integer) (u1 :: Integer) -> case u0 of { _ALG_ J# (u2 :: Int#) (u3 :: Int#) (u4 :: ByteArray#) -> case u1 of { _ALG_ J# (u5 :: Int#) (u6 :: Int#) (u7 :: ByteArray#) -> case _#_ cmpInteger# [] [u2, u3, u4, u5, u6, u7] of { _PRIM_ 0# -> _!_ True [] []; (u8 :: Int#) -> _!_ False [] [] }; _NO_DEFLT_ }; _NO_DEFLT_ } _N_,
- (/=) = _A_ 2 _U_ 11 _N_ _S_ "U(PPP)U(PPP)" {_A_ 4 _U_ 2221 _N_ _N_ _F_ _IF_ARGS_ 0 4 XXXC 4 \ (u0 :: Int#) (u1 :: Int#) (u2 :: ByteArray#) (u3 :: Integer) -> case u3 of { _ALG_ J# (u4 :: Int#) (u5 :: Int#) (u6 :: ByteArray#) -> case _#_ cmpInteger# [] [u0, u1, u2, u4, u5, u6] of { _PRIM_ 0# -> _!_ False [] []; (u7 :: Int#) -> _!_ True [] [] }; _NO_DEFLT_ } _N_} _F_ _IF_ARGS_ 0 2 CC 5 \ (u0 :: Integer) (u1 :: Integer) -> case u0 of { _ALG_ J# (u2 :: Int#) (u3 :: Int#) (u4 :: ByteArray#) -> case u1 of { _ALG_ J# (u5 :: Int#) (u6 :: Int#) (u7 :: ByteArray#) -> case _#_ cmpInteger# [] [u2, u3, u4, u5, u6, u7] of { _PRIM_ 0# -> _!_ False [] []; (u8 :: Int#) -> _!_ True [] [] }; _NO_DEFLT_ }; _NO_DEFLT_ } _N_ #-}
+ (==) = { _A_ 2 _U_ 11 _N_ _S_ "U(PPP)U(PPP)" {_A_ 4 _U_ 2221 _N_ _N_ _F_ _IF_ARGS_ 0 4 XXXC 4 \ (u0 :: Int#) (u1 :: Int#) (u2 :: ByteArray#) (u3 :: Integer) -> case u3 of { _ALG_ J# (u4 :: Int#) (u5 :: Int#) (u6 :: ByteArray#) -> case _#_ cmpInteger# [] [u0, u1, u2, u4, u5, u6] of { _PRIM_ 0# -> _!_ True [] []; (u7 :: Int#) -> _!_ False [] [] }; _NO_DEFLT_ } _N_} _F_ _IF_ARGS_ 0 2 CC 5 \ (u0 :: Integer) (u1 :: Integer) -> case u0 of { _ALG_ J# (u2 :: Int#) (u3 :: Int#) (u4 :: ByteArray#) -> case u1 of { _ALG_ J# (u5 :: Int#) (u6 :: Int#) (u7 :: ByteArray#) -> case _#_ cmpInteger# [] [u2, u3, u4, u5, u6, u7] of { _PRIM_ 0# -> _!_ True [] []; (u8 :: Int#) -> _!_ False [] [] }; _NO_DEFLT_ }; _NO_DEFLT_ } _N_ },
+ (/=) = { _A_ 2 _U_ 11 _N_ _S_ "U(PPP)U(PPP)" {_A_ 4 _U_ 2221 _N_ _N_ _F_ _IF_ARGS_ 0 4 XXXC 4 \ (u0 :: Int#) (u1 :: Int#) (u2 :: ByteArray#) (u3 :: Integer) -> case u3 of { _ALG_ J# (u4 :: Int#) (u5 :: Int#) (u6 :: ByteArray#) -> case _#_ cmpInteger# [] [u0, u1, u2, u4, u5, u6] of { _PRIM_ 0# -> _!_ False [] []; (u7 :: Int#) -> _!_ True [] [] }; _NO_DEFLT_ } _N_} _F_ _IF_ARGS_ 0 2 CC 5 \ (u0 :: Integer) (u1 :: Integer) -> case u0 of { _ALG_ J# (u2 :: Int#) (u3 :: Int#) (u4 :: ByteArray#) -> case u1 of { _ALG_ J# (u5 :: Int#) (u6 :: Int#) (u7 :: ByteArray#) -> case _#_ cmpInteger# [] [u2, u3, u4, u5, u6, u7] of { _PRIM_ 0# -> _!_ False [] []; (u8 :: Int#) -> _!_ True [] [] }; _NO_DEFLT_ }; _NO_DEFLT_ } _N_ } #-}
instance Integral Integer
{-# GHC_PRAGMA _M_ PreludeCore {-dfun-} _A_ 0 _N_ _N_ _N_ _F_ _IF_ARGS_ 0 0 X 13 _!_ _TUP_12 [{{Real Integer}}, {{Ix Integer}}, (Integer -> Integer -> Integer), (Integer -> Integer -> Integer), (Integer -> Integer -> Integer), (Integer -> Integer -> Integer), (Integer -> Integer -> (Integer, Integer)), (Integer -> Integer -> (Integer, Integer)), (Integer -> Bool), (Integer -> Bool), (Integer -> Integer), (Integer -> Int)] [_DFUN_ Real (Integer), _DFUN_ Ix (Integer), _CONSTM_ Integral quot (Integer), _CONSTM_ Integral rem (Integer), _CONSTM_ Integral div (Integer), _CONSTM_ Integral mod (Integer), _CONSTM_ Integral quotRem (Integer), _CONSTM_ Integral divMod (Integer), _CONSTM_ Integral even (Integer), _CONSTM_ Integral odd (Integer), _CONSTM_ Integral toInteger (Integer), _CONSTM_ Integral toInt (Integer)] _N_
- quot = _A_ 2 _U_ 11 _N_ _S_ "U(PPP)U(PPP)" {_A_ 4 _U_ 2221 _N_ _N_ _F_ _IF_ARGS_ 0 4 XXXX 7 \ (u0 :: Int#) (u1 :: Int#) (u2 :: ByteArray#) (u3 :: Integer) -> case _APP_ _WRKR_ _CONSTM_ Integral quotRem (Integer) [ u0, u1, u2, u3 ] of { _ALG_ _TUP_2 (u4 :: Integer) (u5 :: Integer) -> u4; _NO_DEFLT_ } _N_} _F_ _IF_ARGS_ 0 2 XX 5 \ (u0 :: Integer) (u1 :: Integer) -> case _APP_ _CONSTM_ Integral quotRem (Integer) [ u0, u1 ] of { _ALG_ _TUP_2 (u2 :: Integer) (u3 :: Integer) -> u2; _NO_DEFLT_ } _N_,
- rem = _A_ 2 _U_ 11 _N_ _S_ "U(PPP)U(PPP)" {_A_ 4 _U_ 2221 _N_ _N_ _F_ _IF_ARGS_ 0 4 XXXX 7 \ (u0 :: Int#) (u1 :: Int#) (u2 :: ByteArray#) (u3 :: Integer) -> case _APP_ _WRKR_ _CONSTM_ Integral quotRem (Integer) [ u0, u1, u2, u3 ] of { _ALG_ _TUP_2 (u4 :: Integer) (u5 :: Integer) -> u5; _NO_DEFLT_ } _N_} _F_ _IF_ARGS_ 0 2 XX 5 \ (u0 :: Integer) (u1 :: Integer) -> case _APP_ _CONSTM_ Integral quotRem (Integer) [ u0, u1 ] of { _ALG_ _TUP_2 (u2 :: Integer) (u3 :: Integer) -> u3; _NO_DEFLT_ } _N_,
- div = _A_ 2 _U_ 12 _N_ _S_ "U(PPP)U(PPP)" {_A_ 4 _U_ 2222 _N_ _N_ _F_ _IF_ARGS_ 0 4 XXXX 7 \ (u0 :: Int#) (u1 :: Int#) (u2 :: ByteArray#) (u3 :: Integer) -> case _APP_ _WRKR_ _CONSTM_ Integral divMod (Integer) [ u0, u1, u2, u3 ] of { _ALG_ _TUP_2 (u4 :: Integer) (u5 :: Integer) -> u4; _NO_DEFLT_ } _N_} _F_ _IF_ARGS_ 0 2 XX 5 \ (u0 :: Integer) (u1 :: Integer) -> case _APP_ _CONSTM_ Integral divMod (Integer) [ u0, u1 ] of { _ALG_ _TUP_2 (u2 :: Integer) (u3 :: Integer) -> u2; _NO_DEFLT_ } _N_,
- mod = _A_ 2 _U_ 12 _N_ _S_ "U(PPP)U(PPP)" {_A_ 4 _U_ 2222 _N_ _N_ _F_ _IF_ARGS_ 0 4 XXXX 7 \ (u0 :: Int#) (u1 :: Int#) (u2 :: ByteArray#) (u3 :: Integer) -> case _APP_ _WRKR_ _CONSTM_ Integral divMod (Integer) [ u0, u1, u2, u3 ] of { _ALG_ _TUP_2 (u4 :: Integer) (u5 :: Integer) -> u5; _NO_DEFLT_ } _N_} _F_ _IF_ARGS_ 0 2 XX 5 \ (u0 :: Integer) (u1 :: Integer) -> case _APP_ _CONSTM_ Integral divMod (Integer) [ u0, u1 ] of { _ALG_ _TUP_2 (u2 :: Integer) (u3 :: Integer) -> u3; _NO_DEFLT_ } _N_,
- quotRem = _A_ 2 _U_ 11 _N_ _S_ "U(PPP)U(PPP)" {_A_ 4 _U_ 2221 _N_ _N_ _N_ _N_} _N_ _N_,
- divMod = _A_ 2 _U_ 12 _N_ _S_ "U(PPP)U(PPP)" {_A_ 4 _U_ 2222 _N_ _N_ _N_ _N_} _N_ _N_,
- even = _A_ 1 _U_ 1 _N_ _S_ "U(PPP)" {_A_ 3 _U_ 222 _N_ _N_ _N_ _N_} _N_ _N_,
- odd = _A_ 1 _U_ 1 _N_ _S_ "U(PPP)" {_A_ 3 _U_ 222 _N_ _N_ _N_ _N_} _N_ _N_,
- toInteger = _A_ 1 _U_ 1 _N_ _S_ "U(PPP)" {_A_ 3 _U_ 222 _N_ _N_ _F_ _IF_ARGS_ 0 3 XXX 4 \ (u0 :: Int#) (u1 :: Int#) (u2 :: ByteArray#) -> _!_ J# [] [u0, u1, u2] _N_} _F_ _IF_ARGS_ 0 1 X 1 \ (u0 :: Integer) -> u0 _N_,
- toInt = _A_ 1 _U_ 1 _N_ _S_ "U(PPP)" {_A_ 3 _U_ 222 _N_ _N_ _F_ _IF_ARGS_ 0 3 XXX 3 \ (u0 :: Int#) (u1 :: Int#) (u2 :: ByteArray#) -> case _#_ integer2Int# [] [u0, u1, u2] of { _PRIM_ (u3 :: Int#) -> _!_ I# [] [u3] } _N_} _F_ _IF_ARGS_ 0 1 C 4 \ (u0 :: Integer) -> case u0 of { _ALG_ J# (u1 :: Int#) (u2 :: Int#) (u3 :: ByteArray#) -> case _#_ integer2Int# [] [u1, u2, u3] of { _PRIM_ (u4 :: Int#) -> _!_ I# [] [u4] }; _NO_DEFLT_ } _N_ #-}
+ quot = { _A_ 2 _U_ 11 _N_ _S_ "U(PPP)U(PPP)" {_A_ 4 _U_ 2221 _N_ _N_ _F_ _IF_ARGS_ 0 4 XXXX 7 \ (u0 :: Int#) (u1 :: Int#) (u2 :: ByteArray#) (u3 :: Integer) -> case _APP_ _WRKR_ _CONSTM_ Integral quotRem (Integer) [ u0, u1, u2, u3 ] of { _ALG_ _TUP_2 (u4 :: Integer) (u5 :: Integer) -> u4; _NO_DEFLT_ } _N_} _F_ _IF_ARGS_ 0 2 XX 5 \ (u0 :: Integer) (u1 :: Integer) -> case _APP_ _CONSTM_ Integral quotRem (Integer) [ u0, u1 ] of { _ALG_ _TUP_2 (u2 :: Integer) (u3 :: Integer) -> u2; _NO_DEFLT_ } _N_ },
+ rem = { _A_ 2 _U_ 11 _N_ _S_ "U(PPP)U(PPP)" {_A_ 4 _U_ 2221 _N_ _N_ _F_ _IF_ARGS_ 0 4 XXXX 7 \ (u0 :: Int#) (u1 :: Int#) (u2 :: ByteArray#) (u3 :: Integer) -> case _APP_ _WRKR_ _CONSTM_ Integral quotRem (Integer) [ u0, u1, u2, u3 ] of { _ALG_ _TUP_2 (u4 :: Integer) (u5 :: Integer) -> u5; _NO_DEFLT_ } _N_} _F_ _IF_ARGS_ 0 2 XX 5 \ (u0 :: Integer) (u1 :: Integer) -> case _APP_ _CONSTM_ Integral quotRem (Integer) [ u0, u1 ] of { _ALG_ _TUP_2 (u2 :: Integer) (u3 :: Integer) -> u3; _NO_DEFLT_ } _N_ },
+ div = { _A_ 2 _U_ 12 _N_ _S_ "U(PPP)U(PPP)" {_A_ 4 _U_ 2222 _N_ _N_ _F_ _IF_ARGS_ 0 4 XXXX 7 \ (u0 :: Int#) (u1 :: Int#) (u2 :: ByteArray#) (u3 :: Integer) -> case _APP_ _WRKR_ _CONSTM_ Integral divMod (Integer) [ u0, u1, u2, u3 ] of { _ALG_ _TUP_2 (u4 :: Integer) (u5 :: Integer) -> u4; _NO_DEFLT_ } _N_} _F_ _IF_ARGS_ 0 2 XX 5 \ (u0 :: Integer) (u1 :: Integer) -> case _APP_ _CONSTM_ Integral divMod (Integer) [ u0, u1 ] of { _ALG_ _TUP_2 (u2 :: Integer) (u3 :: Integer) -> u2; _NO_DEFLT_ } _N_ },
+ mod = { _A_ 2 _U_ 12 _N_ _S_ "U(PPP)U(PPP)" {_A_ 4 _U_ 2222 _N_ _N_ _F_ _IF_ARGS_ 0 4 XXXX 7 \ (u0 :: Int#) (u1 :: Int#) (u2 :: ByteArray#) (u3 :: Integer) -> case _APP_ _WRKR_ _CONSTM_ Integral divMod (Integer) [ u0, u1, u2, u3 ] of { _ALG_ _TUP_2 (u4 :: Integer) (u5 :: Integer) -> u5; _NO_DEFLT_ } _N_} _F_ _IF_ARGS_ 0 2 XX 5 \ (u0 :: Integer) (u1 :: Integer) -> case _APP_ _CONSTM_ Integral divMod (Integer) [ u0, u1 ] of { _ALG_ _TUP_2 (u2 :: Integer) (u3 :: Integer) -> u3; _NO_DEFLT_ } _N_ },
+ quotRem = { _A_ 2 _U_ 11 _N_ _S_ "U(PPP)U(PPP)" {_A_ 4 _U_ 2221 _N_ _N_ _N_ _N_} _N_ _N_ },
+ divMod = { _A_ 2 _U_ 12 _N_ _S_ "U(PPP)U(PPP)" {_A_ 4 _U_ 2222 _N_ _N_ _N_ _N_} _N_ _N_ },
+ even = { _A_ 1 _U_ 1 _N_ _S_ "U(PPP)" {_A_ 3 _U_ 222 _N_ _N_ _N_ _N_} _N_ _N_ },
+ odd = { _A_ 1 _U_ 1 _N_ _S_ "U(PPP)" {_A_ 3 _U_ 222 _N_ _N_ _N_ _N_} _N_ _N_ },
+ toInteger = { _A_ 1 _U_ 1 _N_ _S_ "U(PPP)" {_A_ 3 _U_ 222 _N_ _N_ _F_ _IF_ARGS_ 0 3 XXX 4 \ (u0 :: Int#) (u1 :: Int#) (u2 :: ByteArray#) -> _!_ J# [] [u0, u1, u2] _N_} _F_ _IF_ARGS_ 0 1 X 1 \ (u0 :: Integer) -> u0 _N_ },
+ toInt = { _A_ 1 _U_ 1 _N_ _S_ "U(PPP)" {_A_ 3 _U_ 222 _N_ _N_ _F_ _IF_ARGS_ 0 3 XXX 3 \ (u0 :: Int#) (u1 :: Int#) (u2 :: ByteArray#) -> case _#_ integer2Int# [] [u0, u1, u2] of { _PRIM_ (u3 :: Int#) -> _!_ I# [] [u3] } _N_} _F_ _IF_ARGS_ 0 1 C 4 \ (u0 :: Integer) -> case u0 of { _ALG_ J# (u1 :: Int#) (u2 :: Int#) (u3 :: ByteArray#) -> case _#_ integer2Int# [] [u1, u2, u3] of { _PRIM_ (u4 :: Int#) -> _!_ I# [] [u4] }; _NO_DEFLT_ } _N_ } #-}
instance Ix Integer
{-# GHC_PRAGMA _M_ PreludeCore {-dfun-} _A_ 0 _N_ _N_ _N_ _F_ _IF_ARGS_ 0 0 X 5 _!_ _TUP_4 [{{Ord Integer}}, ((Integer, Integer) -> [Integer]), ((Integer, Integer) -> Integer -> Int), ((Integer, Integer) -> Integer -> Bool)] [_DFUN_ Ord (Integer), _CONSTM_ Ix range (Integer), _CONSTM_ Ix index (Integer), _CONSTM_ Ix inRange (Integer)] _N_
- range = _A_ 1 _U_ 1 _N_ _S_ "U(LL)" {_A_ 2 _U_ 22 _N_ _N_ _F_ _IF_ARGS_ 0 0 X 1 _CONSTM_ Enum enumFromTo (Integer) _N_} _F_ _IF_ARGS_ 0 1 C 4 \ (u0 :: (Integer, Integer)) -> case u0 of { _ALG_ _TUP_2 (u1 :: Integer) (u2 :: Integer) -> _APP_ _CONSTM_ Enum enumFromTo (Integer) [ u1, u2 ]; _NO_DEFLT_ } _N_,
- index = _A_ 2 _U_ 12 _N_ _S_ "U(U(PPP)L)U(PPP)" {_A_ 5 _U_ 22222 _N_ _N_ _N_ _N_} _N_ _N_,
- inRange = _A_ 2 _U_ 11 _N_ _S_ "U(U(PPP)L)U(PPP)" {_A_ 5 _U_ 22211 _N_ _N_ _F_ _IF_ARGS_ 0 5 XXXCC 9 \ (u0 :: Int#) (u1 :: Int#) (u2 :: ByteArray#) (u3 :: Integer) (u4 :: Integer) -> case u4 of { _ALG_ J# (u5 :: Int#) (u6 :: Int#) (u7 :: ByteArray#) -> case _#_ cmpInteger# [] [u0, u1, u2, u5, u6, u7] of { _PRIM_ (u8 :: Int#) -> case _#_ leInt# [] [u8, 0#] of { _ALG_ True -> case u3 of { _ALG_ J# (u9 :: Int#) (ua :: Int#) (ub :: ByteArray#) -> case _#_ cmpInteger# [] [u5, u6, u7, u9, ua, ub] of { _PRIM_ (uc :: Int#) -> _#_ leInt# [] [uc, 0#] }; _NO_DEFLT_ }; False -> _!_ False [] []; _NO_DEFLT_ } }; _NO_DEFLT_ } _N_} _N_ _N_ #-}
+ range = { _A_ 1 _U_ 1 _N_ _S_ "U(LL)" {_A_ 2 _U_ 22 _N_ _N_ _F_ _IF_ARGS_ 0 0 X 1 _CONSTM_ Enum enumFromTo (Integer) _N_} _F_ _IF_ARGS_ 0 1 C 4 \ (u0 :: (Integer, Integer)) -> case u0 of { _ALG_ _TUP_2 (u1 :: Integer) (u2 :: Integer) -> _APP_ _CONSTM_ Enum enumFromTo (Integer) [ u1, u2 ]; _NO_DEFLT_ } _N_ },
+ index = { _A_ 2 _U_ 12 _N_ _S_ "U(U(PPP)L)U(PPP)" {_A_ 5 _U_ 22222 _N_ _N_ _N_ _N_} _N_ _N_ },
+ inRange = { _A_ 2 _U_ 11 _N_ _S_ "U(U(PPP)L)U(PPP)" {_A_ 5 _U_ 22211 _N_ _N_ _F_ _IF_ARGS_ 0 5 XXXCC 9 \ (u0 :: Int#) (u1 :: Int#) (u2 :: ByteArray#) (u3 :: Integer) (u4 :: Integer) -> case u4 of { _ALG_ J# (u5 :: Int#) (u6 :: Int#) (u7 :: ByteArray#) -> case _#_ cmpInteger# [] [u0, u1, u2, u5, u6, u7] of { _PRIM_ (u8 :: Int#) -> case _#_ leInt# [] [u8, 0#] of { _ALG_ True -> case u3 of { _ALG_ J# (u9 :: Int#) (ua :: Int#) (ub :: ByteArray#) -> case _#_ cmpInteger# [] [u5, u6, u7, u9, ua, ub] of { _PRIM_ (uc :: Int#) -> _#_ leInt# [] [uc, 0#] }; _NO_DEFLT_ }; False -> _!_ False [] []; _NO_DEFLT_ } }; _NO_DEFLT_ } _N_} _N_ _N_ } #-}
instance Num Integer
{-# GHC_PRAGMA _M_ PreludeCore {-dfun-} _A_ 0 _N_ _N_ _N_ _F_ _IF_ARGS_ 0 0 X 11 _!_ _TUP_10 [{{Eq Integer}}, {{Text Integer}}, (Integer -> Integer -> Integer), (Integer -> Integer -> Integer), (Integer -> Integer -> Integer), (Integer -> Integer), (Integer -> Integer), (Integer -> Integer), (Integer -> Integer), (Int -> Integer)] [_DFUN_ Eq (Integer), _DFUN_ Text (Integer), _CONSTM_ Num (+) (Integer), _CONSTM_ Num (-) (Integer), _CONSTM_ Num (*) (Integer), _CONSTM_ Num negate (Integer), _CONSTM_ Num abs (Integer), _CONSTM_ Num signum (Integer), _CONSTM_ Num fromInteger (Integer), _CONSTM_ Num fromInt (Integer)] _N_
- (+) = _A_ 2 _U_ 11 _N_ _S_ "U(PPP)U(PPP)" {_A_ 4 _U_ 2221 _N_ _N_ _F_ _IF_ARGS_ 0 4 XXXC 5 \ (u0 :: Int#) (u1 :: Int#) (u2 :: ByteArray#) (u3 :: Integer) -> case u3 of { _ALG_ J# (u4 :: Int#) (u5 :: Int#) (u6 :: ByteArray#) -> _#_ plusInteger# [] [u0, u1, u2, u4, u5, u6]; _NO_DEFLT_ } _N_} _F_ _IF_ARGS_ 0 2 CC 6 \ (u0 :: Integer) (u1 :: Integer) -> case u0 of { _ALG_ J# (u2 :: Int#) (u3 :: Int#) (u4 :: ByteArray#) -> case u1 of { _ALG_ J# (u5 :: Int#) (u6 :: Int#) (u7 :: ByteArray#) -> _#_ plusInteger# [] [u2, u3, u4, u5, u6, u7]; _NO_DEFLT_ }; _NO_DEFLT_ } _N_,
- (-) = _A_ 2 _U_ 11 _N_ _S_ "U(PPP)U(PPP)" {_A_ 4 _U_ 2221 _N_ _N_ _F_ _IF_ARGS_ 0 4 XXXC 5 \ (u0 :: Int#) (u1 :: Int#) (u2 :: ByteArray#) (u3 :: Integer) -> case u3 of { _ALG_ J# (u4 :: Int#) (u5 :: Int#) (u6 :: ByteArray#) -> _#_ minusInteger# [] [u0, u1, u2, u4, u5, u6]; _NO_DEFLT_ } _N_} _F_ _IF_ARGS_ 0 2 CC 6 \ (u0 :: Integer) (u1 :: Integer) -> case u0 of { _ALG_ J# (u2 :: Int#) (u3 :: Int#) (u4 :: ByteArray#) -> case u1 of { _ALG_ J# (u5 :: Int#) (u6 :: Int#) (u7 :: ByteArray#) -> _#_ minusInteger# [] [u2, u3, u4, u5, u6, u7]; _NO_DEFLT_ }; _NO_DEFLT_ } _N_,
- (*) = _A_ 2 _U_ 11 _N_ _S_ "U(PPP)U(PPP)" {_A_ 4 _U_ 2221 _N_ _N_ _F_ _IF_ARGS_ 0 4 XXXC 5 \ (u0 :: Int#) (u1 :: Int#) (u2 :: ByteArray#) (u3 :: Integer) -> case u3 of { _ALG_ J# (u4 :: Int#) (u5 :: Int#) (u6 :: ByteArray#) -> _#_ timesInteger# [] [u0, u1, u2, u4, u5, u6]; _NO_DEFLT_ } _N_} _F_ _IF_ARGS_ 0 2 CC 6 \ (u0 :: Integer) (u1 :: Integer) -> case u0 of { _ALG_ J# (u2 :: Int#) (u3 :: Int#) (u4 :: ByteArray#) -> case u1 of { _ALG_ J# (u5 :: Int#) (u6 :: Int#) (u7 :: ByteArray#) -> _#_ timesInteger# [] [u2, u3, u4, u5, u6, u7]; _NO_DEFLT_ }; _NO_DEFLT_ } _N_,
- negate = _A_ 1 _U_ 1 _N_ _S_ "U(PPP)" {_A_ 3 _U_ 222 _N_ _N_ _F_ _IF_ARGS_ 0 3 XXX 4 \ (u0 :: Int#) (u1 :: Int#) (u2 :: ByteArray#) -> _#_ negateInteger# [] [u0, u1, u2] _N_} _F_ _IF_ARGS_ 0 1 C 5 \ (u0 :: Integer) -> case u0 of { _ALG_ J# (u1 :: Int#) (u2 :: Int#) (u3 :: ByteArray#) -> _#_ negateInteger# [] [u1, u2, u3]; _NO_DEFLT_ } _N_,
- abs = _A_ 1 _U_ 1 _N_ _S_ "U(PPP)" {_A_ 3 _U_ 222 _N_ _N_ _N_ _N_} _N_ _N_,
- signum = _A_ 1 _U_ 1 _N_ _S_ "U(PPP)" {_A_ 3 _U_ 222 _N_ _N_ _N_ _N_} _N_ _N_,
- fromInteger = _A_ 1 _U_ 1 _N_ _S_ "U(PPP)" {_A_ 3 _U_ 222 _N_ _N_ _F_ _IF_ARGS_ 0 3 XXX 4 \ (u0 :: Int#) (u1 :: Int#) (u2 :: ByteArray#) -> _!_ J# [] [u0, u1, u2] _N_} _F_ _IF_ARGS_ 0 1 X 1 \ (u0 :: Integer) -> u0 _N_,
- fromInt = _A_ 1 _U_ 1 _N_ _S_ "U(P)" {_A_ 1 _U_ 2 _N_ _N_ _F_ _IF_ARGS_ 0 1 X 1 \ (u0 :: Int#) -> _#_ int2Integer# [] [u0] _N_} _F_ _IF_ARGS_ 0 1 C 2 \ (u0 :: Int) -> case u0 of { _ALG_ I# (u1 :: Int#) -> _#_ int2Integer# [] [u1]; _NO_DEFLT_ } _N_ #-}
+ (+) = { _A_ 2 _U_ 11 _N_ _S_ "U(PPP)U(PPP)" {_A_ 4 _U_ 2221 _N_ _N_ _F_ _IF_ARGS_ 0 4 XXXC 5 \ (u0 :: Int#) (u1 :: Int#) (u2 :: ByteArray#) (u3 :: Integer) -> case u3 of { _ALG_ J# (u4 :: Int#) (u5 :: Int#) (u6 :: ByteArray#) -> _#_ plusInteger# [] [u0, u1, u2, u4, u5, u6]; _NO_DEFLT_ } _N_} _F_ _IF_ARGS_ 0 2 CC 6 \ (u0 :: Integer) (u1 :: Integer) -> case u0 of { _ALG_ J# (u2 :: Int#) (u3 :: Int#) (u4 :: ByteArray#) -> case u1 of { _ALG_ J# (u5 :: Int#) (u6 :: Int#) (u7 :: ByteArray#) -> _#_ plusInteger# [] [u2, u3, u4, u5, u6, u7]; _NO_DEFLT_ }; _NO_DEFLT_ } _N_ },
+ (-) = { _A_ 2 _U_ 11 _N_ _S_ "U(PPP)U(PPP)" {_A_ 4 _U_ 2221 _N_ _N_ _F_ _IF_ARGS_ 0 4 XXXC 5 \ (u0 :: Int#) (u1 :: Int#) (u2 :: ByteArray#) (u3 :: Integer) -> case u3 of { _ALG_ J# (u4 :: Int#) (u5 :: Int#) (u6 :: ByteArray#) -> _#_ minusInteger# [] [u0, u1, u2, u4, u5, u6]; _NO_DEFLT_ } _N_} _F_ _IF_ARGS_ 0 2 CC 6 \ (u0 :: Integer) (u1 :: Integer) -> case u0 of { _ALG_ J# (u2 :: Int#) (u3 :: Int#) (u4 :: ByteArray#) -> case u1 of { _ALG_ J# (u5 :: Int#) (u6 :: Int#) (u7 :: ByteArray#) -> _#_ minusInteger# [] [u2, u3, u4, u5, u6, u7]; _NO_DEFLT_ }; _NO_DEFLT_ } _N_ },
+ (*) = { _A_ 2 _U_ 11 _N_ _S_ "U(PPP)U(PPP)" {_A_ 4 _U_ 2221 _N_ _N_ _F_ _IF_ARGS_ 0 4 XXXC 5 \ (u0 :: Int#) (u1 :: Int#) (u2 :: ByteArray#) (u3 :: Integer) -> case u3 of { _ALG_ J# (u4 :: Int#) (u5 :: Int#) (u6 :: ByteArray#) -> _#_ timesInteger# [] [u0, u1, u2, u4, u5, u6]; _NO_DEFLT_ } _N_} _F_ _IF_ARGS_ 0 2 CC 6 \ (u0 :: Integer) (u1 :: Integer) -> case u0 of { _ALG_ J# (u2 :: Int#) (u3 :: Int#) (u4 :: ByteArray#) -> case u1 of { _ALG_ J# (u5 :: Int#) (u6 :: Int#) (u7 :: ByteArray#) -> _#_ timesInteger# [] [u2, u3, u4, u5, u6, u7]; _NO_DEFLT_ }; _NO_DEFLT_ } _N_ },
+ negate = { _A_ 1 _U_ 1 _N_ _S_ "U(PPP)" {_A_ 3 _U_ 222 _N_ _N_ _F_ _IF_ARGS_ 0 3 XXX 4 \ (u0 :: Int#) (u1 :: Int#) (u2 :: ByteArray#) -> _#_ negateInteger# [] [u0, u1, u2] _N_} _F_ _IF_ARGS_ 0 1 C 5 \ (u0 :: Integer) -> case u0 of { _ALG_ J# (u1 :: Int#) (u2 :: Int#) (u3 :: ByteArray#) -> _#_ negateInteger# [] [u1, u2, u3]; _NO_DEFLT_ } _N_ },
+ abs = { _A_ 1 _U_ 1 _N_ _S_ "U(PPP)" {_A_ 3 _U_ 222 _N_ _N_ _N_ _N_} _N_ _N_ },
+ signum = { _A_ 1 _U_ 1 _N_ _S_ "U(PPP)" {_A_ 3 _U_ 222 _N_ _N_ _N_ _N_} _N_ _N_ },
+ fromInteger = { _A_ 1 _U_ 1 _N_ _S_ "U(PPP)" {_A_ 3 _U_ 222 _N_ _N_ _F_ _IF_ARGS_ 0 3 XXX 4 \ (u0 :: Int#) (u1 :: Int#) (u2 :: ByteArray#) -> _!_ J# [] [u0, u1, u2] _N_} _F_ _IF_ARGS_ 0 1 X 1 \ (u0 :: Integer) -> u0 _N_ },
+ fromInt = { _A_ 1 _U_ 1 _N_ _S_ "U(P)" {_A_ 1 _U_ 2 _N_ _N_ _F_ _IF_ARGS_ 0 1 X 1 \ (u0 :: Int#) -> _#_ int2Integer# [] [u0] _N_} _F_ _IF_ARGS_ 0 1 C 2 \ (u0 :: Int) -> case u0 of { _ALG_ I# (u1 :: Int#) -> _#_ int2Integer# [] [u1]; _NO_DEFLT_ } _N_ } #-}
instance Ord Integer
{-# GHC_PRAGMA _M_ PreludeCore {-dfun-} _A_ 0 _N_ _N_ _N_ _F_ _IF_ARGS_ 0 0 X 9 _!_ _TUP_8 [{{Eq Integer}}, (Integer -> Integer -> Bool), (Integer -> Integer -> Bool), (Integer -> Integer -> Bool), (Integer -> Integer -> Bool), (Integer -> Integer -> Integer), (Integer -> Integer -> Integer), (Integer -> Integer -> _CMP_TAG)] [_DFUN_ Eq (Integer), _CONSTM_ Ord (<) (Integer), _CONSTM_ Ord (<=) (Integer), _CONSTM_ Ord (>=) (Integer), _CONSTM_ Ord (>) (Integer), _CONSTM_ Ord max (Integer), _CONSTM_ Ord min (Integer), _CONSTM_ Ord _tagCmp (Integer)] _N_
- (<) = _A_ 2 _U_ 11 _N_ _S_ "U(PPP)U(PPP)" {_A_ 4 _U_ 2221 _N_ _N_ _F_ _IF_ARGS_ 0 4 XXXC 3 \ (u0 :: Int#) (u1 :: Int#) (u2 :: ByteArray#) (u3 :: Integer) -> case u3 of { _ALG_ J# (u4 :: Int#) (u5 :: Int#) (u6 :: ByteArray#) -> case _#_ cmpInteger# [] [u0, u1, u2, u4, u5, u6] of { _PRIM_ (u7 :: Int#) -> _#_ ltInt# [] [u7, 0#] }; _NO_DEFLT_ } _N_} _F_ _IF_ARGS_ 0 2 CC 4 \ (u0 :: Integer) (u1 :: Integer) -> case u0 of { _ALG_ J# (u2 :: Int#) (u3 :: Int#) (u4 :: ByteArray#) -> case u1 of { _ALG_ J# (u5 :: Int#) (u6 :: Int#) (u7 :: ByteArray#) -> case _#_ cmpInteger# [] [u2, u3, u4, u5, u6, u7] of { _PRIM_ (u8 :: Int#) -> _#_ ltInt# [] [u8, 0#] }; _NO_DEFLT_ }; _NO_DEFLT_ } _N_,
- (<=) = _A_ 2 _U_ 11 _N_ _S_ "U(PPP)U(PPP)" {_A_ 4 _U_ 2221 _N_ _N_ _F_ _IF_ARGS_ 0 4 XXXC 3 \ (u0 :: Int#) (u1 :: Int#) (u2 :: ByteArray#) (u3 :: Integer) -> case u3 of { _ALG_ J# (u4 :: Int#) (u5 :: Int#) (u6 :: ByteArray#) -> case _#_ cmpInteger# [] [u0, u1, u2, u4, u5, u6] of { _PRIM_ (u7 :: Int#) -> _#_ leInt# [] [u7, 0#] }; _NO_DEFLT_ } _N_} _F_ _IF_ARGS_ 0 2 CC 4 \ (u0 :: Integer) (u1 :: Integer) -> case u0 of { _ALG_ J# (u2 :: Int#) (u3 :: Int#) (u4 :: ByteArray#) -> case u1 of { _ALG_ J# (u5 :: Int#) (u6 :: Int#) (u7 :: ByteArray#) -> case _#_ cmpInteger# [] [u2, u3, u4, u5, u6, u7] of { _PRIM_ (u8 :: Int#) -> _#_ leInt# [] [u8, 0#] }; _NO_DEFLT_ }; _NO_DEFLT_ } _N_,
- (>=) = _A_ 2 _U_ 11 _N_ _S_ "U(PPP)U(PPP)" {_A_ 4 _U_ 2221 _N_ _N_ _F_ _IF_ARGS_ 0 4 XXXC 3 \ (u0 :: Int#) (u1 :: Int#) (u2 :: ByteArray#) (u3 :: Integer) -> case u3 of { _ALG_ J# (u4 :: Int#) (u5 :: Int#) (u6 :: ByteArray#) -> case _#_ cmpInteger# [] [u0, u1, u2, u4, u5, u6] of { _PRIM_ (u7 :: Int#) -> _#_ geInt# [] [u7, 0#] }; _NO_DEFLT_ } _N_} _F_ _IF_ARGS_ 0 2 CC 4 \ (u0 :: Integer) (u1 :: Integer) -> case u0 of { _ALG_ J# (u2 :: Int#) (u3 :: Int#) (u4 :: ByteArray#) -> case u1 of { _ALG_ J# (u5 :: Int#) (u6 :: Int#) (u7 :: ByteArray#) -> case _#_ cmpInteger# [] [u2, u3, u4, u5, u6, u7] of { _PRIM_ (u8 :: Int#) -> _#_ geInt# [] [u8, 0#] }; _NO_DEFLT_ }; _NO_DEFLT_ } _N_,
- (>) = _A_ 2 _U_ 11 _N_ _S_ "U(PPP)U(PPP)" {_A_ 4 _U_ 2221 _N_ _N_ _F_ _IF_ARGS_ 0 4 XXXC 3 \ (u0 :: Int#) (u1 :: Int#) (u2 :: ByteArray#) (u3 :: Integer) -> case u3 of { _ALG_ J# (u4 :: Int#) (u5 :: Int#) (u6 :: ByteArray#) -> case _#_ cmpInteger# [] [u0, u1, u2, u4, u5, u6] of { _PRIM_ (u7 :: Int#) -> _#_ gtInt# [] [u7, 0#] }; _NO_DEFLT_ } _N_} _F_ _IF_ARGS_ 0 2 CC 4 \ (u0 :: Integer) (u1 :: Integer) -> case u0 of { _ALG_ J# (u2 :: Int#) (u3 :: Int#) (u4 :: ByteArray#) -> case u1 of { _ALG_ J# (u5 :: Int#) (u6 :: Int#) (u7 :: ByteArray#) -> case _#_ cmpInteger# [] [u2, u3, u4, u5, u6, u7] of { _PRIM_ (u8 :: Int#) -> _#_ gtInt# [] [u8, 0#] }; _NO_DEFLT_ }; _NO_DEFLT_ } _N_,
- max = _A_ 2 _U_ 11 _N_ _S_ "U(PPP)U(PPP)" {_A_ 4 _U_ 2221 _N_ _N_ _N_ _N_} _N_ _N_,
- min = _A_ 2 _U_ 11 _N_ _S_ "U(PPP)U(PPP)" {_A_ 4 _U_ 2221 _N_ _N_ _N_ _N_} _N_ _N_,
- _tagCmp = _A_ 2 _U_ 11 _N_ _S_ "U(PPP)U(PPP)" {_A_ 4 _U_ 2221 _N_ _N_ _N_ _N_} _N_ _N_ #-}
+ (<) = { _A_ 2 _U_ 11 _N_ _S_ "U(PPP)U(PPP)" {_A_ 4 _U_ 2221 _N_ _N_ _F_ _IF_ARGS_ 0 4 XXXC 3 \ (u0 :: Int#) (u1 :: Int#) (u2 :: ByteArray#) (u3 :: Integer) -> case u3 of { _ALG_ J# (u4 :: Int#) (u5 :: Int#) (u6 :: ByteArray#) -> case _#_ cmpInteger# [] [u0, u1, u2, u4, u5, u6] of { _PRIM_ (u7 :: Int#) -> _#_ ltInt# [] [u7, 0#] }; _NO_DEFLT_ } _N_} _F_ _IF_ARGS_ 0 2 CC 4 \ (u0 :: Integer) (u1 :: Integer) -> case u0 of { _ALG_ J# (u2 :: Int#) (u3 :: Int#) (u4 :: ByteArray#) -> case u1 of { _ALG_ J# (u5 :: Int#) (u6 :: Int#) (u7 :: ByteArray#) -> case _#_ cmpInteger# [] [u2, u3, u4, u5, u6, u7] of { _PRIM_ (u8 :: Int#) -> _#_ ltInt# [] [u8, 0#] }; _NO_DEFLT_ }; _NO_DEFLT_ } _N_ },
+ (<=) = { _A_ 2 _U_ 11 _N_ _S_ "U(PPP)U(PPP)" {_A_ 4 _U_ 2221 _N_ _N_ _F_ _IF_ARGS_ 0 4 XXXC 3 \ (u0 :: Int#) (u1 :: Int#) (u2 :: ByteArray#) (u3 :: Integer) -> case u3 of { _ALG_ J# (u4 :: Int#) (u5 :: Int#) (u6 :: ByteArray#) -> case _#_ cmpInteger# [] [u0, u1, u2, u4, u5, u6] of { _PRIM_ (u7 :: Int#) -> _#_ leInt# [] [u7, 0#] }; _NO_DEFLT_ } _N_} _F_ _IF_ARGS_ 0 2 CC 4 \ (u0 :: Integer) (u1 :: Integer) -> case u0 of { _ALG_ J# (u2 :: Int#) (u3 :: Int#) (u4 :: ByteArray#) -> case u1 of { _ALG_ J# (u5 :: Int#) (u6 :: Int#) (u7 :: ByteArray#) -> case _#_ cmpInteger# [] [u2, u3, u4, u5, u6, u7] of { _PRIM_ (u8 :: Int#) -> _#_ leInt# [] [u8, 0#] }; _NO_DEFLT_ }; _NO_DEFLT_ } _N_ },
+ (>=) = { _A_ 2 _U_ 11 _N_ _S_ "U(PPP)U(PPP)" {_A_ 4 _U_ 2221 _N_ _N_ _F_ _IF_ARGS_ 0 4 XXXC 3 \ (u0 :: Int#) (u1 :: Int#) (u2 :: ByteArray#) (u3 :: Integer) -> case u3 of { _ALG_ J# (u4 :: Int#) (u5 :: Int#) (u6 :: ByteArray#) -> case _#_ cmpInteger# [] [u0, u1, u2, u4, u5, u6] of { _PRIM_ (u7 :: Int#) -> _#_ geInt# [] [u7, 0#] }; _NO_DEFLT_ } _N_} _F_ _IF_ARGS_ 0 2 CC 4 \ (u0 :: Integer) (u1 :: Integer) -> case u0 of { _ALG_ J# (u2 :: Int#) (u3 :: Int#) (u4 :: ByteArray#) -> case u1 of { _ALG_ J# (u5 :: Int#) (u6 :: Int#) (u7 :: ByteArray#) -> case _#_ cmpInteger# [] [u2, u3, u4, u5, u6, u7] of { _PRIM_ (u8 :: Int#) -> _#_ geInt# [] [u8, 0#] }; _NO_DEFLT_ }; _NO_DEFLT_ } _N_ },
+ (>) = { _A_ 2 _U_ 11 _N_ _S_ "U(PPP)U(PPP)" {_A_ 4 _U_ 2221 _N_ _N_ _F_ _IF_ARGS_ 0 4 XXXC 3 \ (u0 :: Int#) (u1 :: Int#) (u2 :: ByteArray#) (u3 :: Integer) -> case u3 of { _ALG_ J# (u4 :: Int#) (u5 :: Int#) (u6 :: ByteArray#) -> case _#_ cmpInteger# [] [u0, u1, u2, u4, u5, u6] of { _PRIM_ (u7 :: Int#) -> _#_ gtInt# [] [u7, 0#] }; _NO_DEFLT_ } _N_} _F_ _IF_ARGS_ 0 2 CC 4 \ (u0 :: Integer) (u1 :: Integer) -> case u0 of { _ALG_ J# (u2 :: Int#) (u3 :: Int#) (u4 :: ByteArray#) -> case u1 of { _ALG_ J# (u5 :: Int#) (u6 :: Int#) (u7 :: ByteArray#) -> case _#_ cmpInteger# [] [u2, u3, u4, u5, u6, u7] of { _PRIM_ (u8 :: Int#) -> _#_ gtInt# [] [u8, 0#] }; _NO_DEFLT_ }; _NO_DEFLT_ } _N_ },
+ max = { _A_ 2 _U_ 11 _N_ _S_ "U(PPP)U(PPP)" {_A_ 4 _U_ 2221 _N_ _N_ _N_ _N_} _N_ _N_ },
+ min = { _A_ 2 _U_ 11 _N_ _S_ "U(PPP)U(PPP)" {_A_ 4 _U_ 2221 _N_ _N_ _N_ _N_} _N_ _N_ },
+ _tagCmp = { _A_ 2 _U_ 11 _N_ _S_ "U(PPP)U(PPP)" {_A_ 4 _U_ 2221 _N_ _N_ _N_ _N_} _N_ _N_ } #-}
instance Real Integer
{-# GHC_PRAGMA _M_ PreludeCore {-dfun-} _A_ 0 _N_ _N_ _N_ _F_ _IF_ARGS_ 0 0 X 4 _!_ _TUP_3 [{{Num Integer}}, {{Enum Integer}}, (Integer -> Ratio Integer)] [_DFUN_ Num (Integer), _DFUN_ Enum (Integer), _CONSTM_ Real toRational (Integer)] _N_
- toRational = _A_ 1 _U_ 2 _N_ _N_ _N_ _N_ #-}
+ toRational = { _A_ 1 _U_ 2 _N_ _N_ _F_ _IF_ARGS_ 0 1 X 3 \ (u0 :: Integer) -> _!_ (:%) [Integer] [u0, _ORIG_ PreludeCore __integer1] _N_ } #-}
instance Text Integer
{-# GHC_PRAGMA _M_ PreludeCore {-dfun-} _A_ 0 _N_ _N_ _N_ _F_ _IF_ARGS_ 0 0 X 5 _!_ _TUP_4 [(Int -> [Char] -> [(Integer, [Char])]), (Int -> Integer -> [Char] -> [Char]), ([Char] -> [([Integer], [Char])]), ([Integer] -> [Char] -> [Char])] [_CONSTM_ Text readsPrec (Integer), _CONSTM_ Text showsPrec (Integer), _CONSTM_ Text readList (Integer), _CONSTM_ Text showList (Integer)] _N_
- readsPrec = _A_ 2 _U_ 02 _N_ _S_ "AL" {_A_ 1 _U_ 2 _N_ _N_ _F_ _IF_ARGS_ 0 1 X 3 \ (u0 :: [Char]) -> _APP_ _SPEC_ _ORIG_ PreludeText readSigned [ (Integer) ] [ _SPEC_ _ORIG_ PreludeText readDec [ (Integer) ], u0 ] _N_} _F_ _IF_ARGS_ 0 2 XX 3 \ (u0 :: Int) (u1 :: [Char]) -> _APP_ _SPEC_ _ORIG_ PreludeText readSigned [ (Integer) ] [ _SPEC_ _ORIG_ PreludeText readDec [ (Integer) ], u1 ] _N_,
- showsPrec = _A_ 3 _U_ 212 _N_ _S_ "LU(PPP)L" {_A_ 5 _U_ 22222 _N_ _N_ _N_ _N_} _N_ _N_,
- readList = _A_ 0 _U_ 2 _N_ _N_ _N_ _N_,
- showList = _A_ 0 _U_ 12 _N_ _N_ _N_ _N_ #-}
+ readsPrec = { _A_ 2 _U_ 02 _N_ _S_ "AL" {_A_ 1 _U_ 2 _N_ _N_ _F_ _IF_ARGS_ 0 1 X 3 \ (u0 :: [Char]) -> _APP_ _SPEC_ _ORIG_ PreludeText readSigned [ (Integer) ] [ _SPEC_ _ORIG_ PreludeText readDec [ (Integer) ], u0 ] _N_} _F_ _IF_ARGS_ 0 2 XX 3 \ (u0 :: Int) (u1 :: [Char]) -> _APP_ _SPEC_ _ORIG_ PreludeText readSigned [ (Integer) ] [ _SPEC_ _ORIG_ PreludeText readDec [ (Integer) ], u1 ] _N_ },
+ showsPrec = { _A_ 3 _U_ 212 _N_ _S_ "LU(PPP)L" {_A_ 5 _U_ 22222 _N_ _N_ _N_ _N_} _N_ _N_ },
+ readList = { _A_ 0 _U_ 2 _N_ _N_ _N_ _N_ },
+ showList = { _A_ 1 _U_ 12 _N_ _N_ _N_ _N_ } #-}
-{-# GHC_PRAGMA INTERFACE VERSION 5 #-}
+{-# GHC_PRAGMA INTERFACE VERSION 6 #-}
interface PreludeCore where
-import PreludeBuiltin(Int(..), Integer(..))
-_integer_0 :: Integer
- {-# GHC_PRAGMA _A_ 0 _N_ _N_ _N_ _F_ _IF_ARGS_ 0 0 X 1 _#_ int2Integer# [] [0#] _N_ #-}
-_integer_1 :: Integer
- {-# GHC_PRAGMA _A_ 0 _N_ _N_ _N_ _F_ _IF_ARGS_ 0 0 X 1 _#_ int2Integer# [] [1#] _N_ #-}
-_integer_m1 :: Integer
+import PreludeBuiltin(Integer(..))
+__integer0 :: Integer
+ {-# GHC_PRAGMA _A_ 0 _N_ _N_ _N_ _N_ _N_ #-}
+__integer1 :: Integer
+ {-# GHC_PRAGMA _A_ 0 _N_ _N_ _N_ _N_ _N_ #-}
+__integer2 :: Integer
+ {-# GHC_PRAGMA _A_ 0 _N_ _N_ _N_ _N_ _N_ #-}
+__integerm1 :: Integer
{-# GHC_PRAGMA _A_ 0 _N_ _N_ _N_ _N_ _N_ #-}
-int2Integer :: Int -> Integer
- {-# GHC_PRAGMA _A_ 1 _U_ 1 _N_ _S_ "U(P)" {_A_ 1 _U_ 2 _N_ _N_ _F_ _IF_ARGS_ 0 1 X 1 \ (u0 :: Int#) -> _#_ int2Integer# [] [u0] _N_} _F_ _IF_ARGS_ 0 1 C 2 \ (u0 :: Int) -> case u0 of { _ALG_ I# (u1 :: Int#) -> _#_ int2Integer# [] [u1]; _NO_DEFLT_ } _N_ #-}
instance Enum Integer
{-# GHC_PRAGMA _M_ PreludeCore {-dfun-} _A_ 0 _N_ _N_ _N_ _F_ _IF_ARGS_ 0 0 X 6 _!_ _TUP_5 [{{Ord Integer}}, (Integer -> [Integer]), (Integer -> Integer -> [Integer]), (Integer -> Integer -> [Integer]), (Integer -> Integer -> Integer -> [Integer])] [_DFUN_ Ord (Integer), _CONSTM_ Enum enumFrom (Integer), _CONSTM_ Enum enumFromThen (Integer), _CONSTM_ Enum enumFromTo (Integer), _CONSTM_ Enum enumFromThenTo (Integer)] _N_
- enumFrom = _A_ 1 _U_ 2 _N_ _N_ _N_ _N_,
- enumFromThen = _A_ 2 _U_ 21 _N_ _N_ _N_ _N_,
- enumFromTo = _A_ 2 _U_ 22 _N_ _N_ _N_ _N_,
- enumFromThenTo = _A_ 3 _U_ 222 _N_ _N_ _N_ _N_ #-}
+ enumFrom = { _A_ 1 _U_ 2 _N_ _N_ _N_ _N_ },
+ enumFromThen = { _A_ 2 _U_ 21 _N_ _N_ _N_ _N_ },
+ enumFromTo = { _A_ 2 _U_ 22 _N_ _N_ _N_ _N_ },
+ enumFromThenTo = { _A_ 3 _U_ 222 _N_ _N_ _N_ _N_ } #-}
instance Eq Integer
{-# GHC_PRAGMA _M_ PreludeCore {-dfun-} _A_ 0 _N_ _N_ _N_ _F_ _IF_ARGS_ 0 0 X 3 _!_ _TUP_2 [(Integer -> Integer -> Bool), (Integer -> Integer -> Bool)] [_CONSTM_ Eq (==) (Integer), _CONSTM_ Eq (/=) (Integer)] _N_
- (==) = _A_ 2 _U_ 11 _N_ _S_ "U(PPP)U(PPP)" {_A_ 4 _U_ 2221 _N_ _N_ _F_ _IF_ARGS_ 0 4 XXXC 4 \ (u0 :: Int#) (u1 :: Int#) (u2 :: ByteArray#) (u3 :: Integer) -> case u3 of { _ALG_ J# (u4 :: Int#) (u5 :: Int#) (u6 :: ByteArray#) -> case _#_ cmpInteger# [] [u0, u1, u2, u4, u5, u6] of { _PRIM_ 0# -> _!_ True [] []; (u7 :: Int#) -> _!_ False [] [] }; _NO_DEFLT_ } _N_} _F_ _IF_ARGS_ 0 2 CC 5 \ (u0 :: Integer) (u1 :: Integer) -> case u0 of { _ALG_ J# (u2 :: Int#) (u3 :: Int#) (u4 :: ByteArray#) -> case u1 of { _ALG_ J# (u5 :: Int#) (u6 :: Int#) (u7 :: ByteArray#) -> case _#_ cmpInteger# [] [u2, u3, u4, u5, u6, u7] of { _PRIM_ 0# -> _!_ True [] []; (u8 :: Int#) -> _!_ False [] [] }; _NO_DEFLT_ }; _NO_DEFLT_ } _N_,
- (/=) = _A_ 2 _U_ 11 _N_ _S_ "U(PPP)U(PPP)" {_A_ 4 _U_ 2221 _N_ _N_ _F_ _IF_ARGS_ 0 4 XXXC 4 \ (u0 :: Int#) (u1 :: Int#) (u2 :: ByteArray#) (u3 :: Integer) -> case u3 of { _ALG_ J# (u4 :: Int#) (u5 :: Int#) (u6 :: ByteArray#) -> case _#_ cmpInteger# [] [u0, u1, u2, u4, u5, u6] of { _PRIM_ 0# -> _!_ False [] []; (u7 :: Int#) -> _!_ True [] [] }; _NO_DEFLT_ } _N_} _F_ _IF_ARGS_ 0 2 CC 5 \ (u0 :: Integer) (u1 :: Integer) -> case u0 of { _ALG_ J# (u2 :: Int#) (u3 :: Int#) (u4 :: ByteArray#) -> case u1 of { _ALG_ J# (u5 :: Int#) (u6 :: Int#) (u7 :: ByteArray#) -> case _#_ cmpInteger# [] [u2, u3, u4, u5, u6, u7] of { _PRIM_ 0# -> _!_ False [] []; (u8 :: Int#) -> _!_ True [] [] }; _NO_DEFLT_ }; _NO_DEFLT_ } _N_ #-}
+ (==) = { _A_ 2 _U_ 11 _N_ _S_ "U(PPP)U(PPP)" {_A_ 4 _U_ 2221 _N_ _N_ _F_ _IF_ARGS_ 0 4 XXXC 4 \ (u0 :: Int#) (u1 :: Int#) (u2 :: ByteArray#) (u3 :: Integer) -> case u3 of { _ALG_ J# (u4 :: Int#) (u5 :: Int#) (u6 :: ByteArray#) -> case _#_ cmpInteger# [] [u0, u1, u2, u4, u5, u6] of { _PRIM_ 0# -> _!_ True [] []; (u7 :: Int#) -> _!_ False [] [] }; _NO_DEFLT_ } _N_} _F_ _IF_ARGS_ 0 2 CC 5 \ (u0 :: Integer) (u1 :: Integer) -> case u0 of { _ALG_ J# (u2 :: Int#) (u3 :: Int#) (u4 :: ByteArray#) -> case u1 of { _ALG_ J# (u5 :: Int#) (u6 :: Int#) (u7 :: ByteArray#) -> case _#_ cmpInteger# [] [u2, u3, u4, u5, u6, u7] of { _PRIM_ 0# -> _!_ True [] []; (u8 :: Int#) -> _!_ False [] [] }; _NO_DEFLT_ }; _NO_DEFLT_ } _N_ },
+ (/=) = { _A_ 2 _U_ 11 _N_ _S_ "U(PPP)U(PPP)" {_A_ 4 _U_ 2221 _N_ _N_ _F_ _IF_ARGS_ 0 4 XXXC 4 \ (u0 :: Int#) (u1 :: Int#) (u2 :: ByteArray#) (u3 :: Integer) -> case u3 of { _ALG_ J# (u4 :: Int#) (u5 :: Int#) (u6 :: ByteArray#) -> case _#_ cmpInteger# [] [u0, u1, u2, u4, u5, u6] of { _PRIM_ 0# -> _!_ False [] []; (u7 :: Int#) -> _!_ True [] [] }; _NO_DEFLT_ } _N_} _F_ _IF_ARGS_ 0 2 CC 5 \ (u0 :: Integer) (u1 :: Integer) -> case u0 of { _ALG_ J# (u2 :: Int#) (u3 :: Int#) (u4 :: ByteArray#) -> case u1 of { _ALG_ J# (u5 :: Int#) (u6 :: Int#) (u7 :: ByteArray#) -> case _#_ cmpInteger# [] [u2, u3, u4, u5, u6, u7] of { _PRIM_ 0# -> _!_ False [] []; (u8 :: Int#) -> _!_ True [] [] }; _NO_DEFLT_ }; _NO_DEFLT_ } _N_ } #-}
instance Integral Integer
{-# GHC_PRAGMA _M_ PreludeCore {-dfun-} _A_ 0 _N_ _N_ _N_ _F_ _IF_ARGS_ 0 0 X 13 _!_ _TUP_12 [{{Real Integer}}, {{Ix Integer}}, (Integer -> Integer -> Integer), (Integer -> Integer -> Integer), (Integer -> Integer -> Integer), (Integer -> Integer -> Integer), (Integer -> Integer -> (Integer, Integer)), (Integer -> Integer -> (Integer, Integer)), (Integer -> Bool), (Integer -> Bool), (Integer -> Integer), (Integer -> Int)] [_DFUN_ Real (Integer), _DFUN_ Ix (Integer), _CONSTM_ Integral quot (Integer), _CONSTM_ Integral rem (Integer), _CONSTM_ Integral div (Integer), _CONSTM_ Integral mod (Integer), _CONSTM_ Integral quotRem (Integer), _CONSTM_ Integral divMod (Integer), _CONSTM_ Integral even (Integer), _CONSTM_ Integral odd (Integer), _CONSTM_ Integral toInteger (Integer), _CONSTM_ Integral toInt (Integer)] _N_
- quot = _A_ 2 _U_ 11 _N_ _S_ "U(PPP)U(PPP)" {_A_ 4 _U_ 2221 _N_ _N_ _F_ _IF_ARGS_ 0 4 XXXX 7 \ (u0 :: Int#) (u1 :: Int#) (u2 :: ByteArray#) (u3 :: Integer) -> case _APP_ _WRKR_ _CONSTM_ Integral quotRem (Integer) [ u0, u1, u2, u3 ] of { _ALG_ _TUP_2 (u4 :: Integer) (u5 :: Integer) -> u4; _NO_DEFLT_ } _N_} _F_ _IF_ARGS_ 0 2 XX 5 \ (u0 :: Integer) (u1 :: Integer) -> case _APP_ _CONSTM_ Integral quotRem (Integer) [ u0, u1 ] of { _ALG_ _TUP_2 (u2 :: Integer) (u3 :: Integer) -> u2; _NO_DEFLT_ } _N_,
- rem = _A_ 2 _U_ 11 _N_ _S_ "U(PPP)U(PPP)" {_A_ 4 _U_ 2221 _N_ _N_ _F_ _IF_ARGS_ 0 4 XXXX 7 \ (u0 :: Int#) (u1 :: Int#) (u2 :: ByteArray#) (u3 :: Integer) -> case _APP_ _WRKR_ _CONSTM_ Integral quotRem (Integer) [ u0, u1, u2, u3 ] of { _ALG_ _TUP_2 (u4 :: Integer) (u5 :: Integer) -> u5; _NO_DEFLT_ } _N_} _F_ _IF_ARGS_ 0 2 XX 5 \ (u0 :: Integer) (u1 :: Integer) -> case _APP_ _CONSTM_ Integral quotRem (Integer) [ u0, u1 ] of { _ALG_ _TUP_2 (u2 :: Integer) (u3 :: Integer) -> u3; _NO_DEFLT_ } _N_,
- div = _A_ 2 _U_ 12 _N_ _S_ "U(PPP)U(PPP)" {_A_ 4 _U_ 2222 _N_ _N_ _F_ _IF_ARGS_ 0 4 XXXX 7 \ (u0 :: Int#) (u1 :: Int#) (u2 :: ByteArray#) (u3 :: Integer) -> case _APP_ _WRKR_ _CONSTM_ Integral divMod (Integer) [ u0, u1, u2, u3 ] of { _ALG_ _TUP_2 (u4 :: Integer) (u5 :: Integer) -> u4; _NO_DEFLT_ } _N_} _F_ _IF_ARGS_ 0 2 XX 5 \ (u0 :: Integer) (u1 :: Integer) -> case _APP_ _CONSTM_ Integral divMod (Integer) [ u0, u1 ] of { _ALG_ _TUP_2 (u2 :: Integer) (u3 :: Integer) -> u2; _NO_DEFLT_ } _N_,
- mod = _A_ 2 _U_ 12 _N_ _S_ "U(PPP)U(PPP)" {_A_ 4 _U_ 2222 _N_ _N_ _F_ _IF_ARGS_ 0 4 XXXX 7 \ (u0 :: Int#) (u1 :: Int#) (u2 :: ByteArray#) (u3 :: Integer) -> case _APP_ _WRKR_ _CONSTM_ Integral divMod (Integer) [ u0, u1, u2, u3 ] of { _ALG_ _TUP_2 (u4 :: Integer) (u5 :: Integer) -> u5; _NO_DEFLT_ } _N_} _F_ _IF_ARGS_ 0 2 XX 5 \ (u0 :: Integer) (u1 :: Integer) -> case _APP_ _CONSTM_ Integral divMod (Integer) [ u0, u1 ] of { _ALG_ _TUP_2 (u2 :: Integer) (u3 :: Integer) -> u3; _NO_DEFLT_ } _N_,
- quotRem = _A_ 2 _U_ 11 _N_ _S_ "U(PPP)U(PPP)" {_A_ 4 _U_ 2221 _N_ _N_ _N_ _N_} _N_ _N_,
- divMod = _A_ 2 _U_ 12 _N_ _S_ "U(PPP)U(PPP)" {_A_ 4 _U_ 2222 _N_ _N_ _N_ _N_} _N_ _N_,
- even = _A_ 1 _U_ 1 _N_ _S_ "U(PPP)" {_A_ 3 _U_ 222 _N_ _N_ _N_ _N_} _N_ _N_,
- odd = _A_ 1 _U_ 1 _N_ _S_ "U(PPP)" {_A_ 3 _U_ 222 _N_ _N_ _N_ _N_} _N_ _N_,
- toInteger = _A_ 1 _U_ 1 _N_ _S_ "U(PPP)" {_A_ 3 _U_ 222 _N_ _N_ _F_ _IF_ARGS_ 0 3 XXX 4 \ (u0 :: Int#) (u1 :: Int#) (u2 :: ByteArray#) -> _!_ J# [] [u0, u1, u2] _N_} _F_ _IF_ARGS_ 0 1 X 1 \ (u0 :: Integer) -> u0 _N_,
- toInt = _A_ 1 _U_ 1 _N_ _S_ "U(PPP)" {_A_ 3 _U_ 222 _N_ _N_ _F_ _IF_ARGS_ 0 3 XXX 3 \ (u0 :: Int#) (u1 :: Int#) (u2 :: ByteArray#) -> case _#_ integer2Int# [] [u0, u1, u2] of { _PRIM_ (u3 :: Int#) -> _!_ I# [] [u3] } _N_} _F_ _IF_ARGS_ 0 1 C 4 \ (u0 :: Integer) -> case u0 of { _ALG_ J# (u1 :: Int#) (u2 :: Int#) (u3 :: ByteArray#) -> case _#_ integer2Int# [] [u1, u2, u3] of { _PRIM_ (u4 :: Int#) -> _!_ I# [] [u4] }; _NO_DEFLT_ } _N_ #-}
+ quot = { _A_ 2 _U_ 11 _N_ _S_ "U(PPP)U(PPP)" {_A_ 4 _U_ 2221 _N_ _N_ _F_ _IF_ARGS_ 0 4 XXXX 7 \ (u0 :: Int#) (u1 :: Int#) (u2 :: ByteArray#) (u3 :: Integer) -> case _APP_ _WRKR_ _CONSTM_ Integral quotRem (Integer) [ u0, u1, u2, u3 ] of { _ALG_ _TUP_2 (u4 :: Integer) (u5 :: Integer) -> u4; _NO_DEFLT_ } _N_} _F_ _IF_ARGS_ 0 2 XX 5 \ (u0 :: Integer) (u1 :: Integer) -> case _APP_ _CONSTM_ Integral quotRem (Integer) [ u0, u1 ] of { _ALG_ _TUP_2 (u2 :: Integer) (u3 :: Integer) -> u2; _NO_DEFLT_ } _N_ },
+ rem = { _A_ 2 _U_ 11 _N_ _S_ "U(PPP)U(PPP)" {_A_ 4 _U_ 2221 _N_ _N_ _F_ _IF_ARGS_ 0 4 XXXX 7 \ (u0 :: Int#) (u1 :: Int#) (u2 :: ByteArray#) (u3 :: Integer) -> case _APP_ _WRKR_ _CONSTM_ Integral quotRem (Integer) [ u0, u1, u2, u3 ] of { _ALG_ _TUP_2 (u4 :: Integer) (u5 :: Integer) -> u5; _NO_DEFLT_ } _N_} _F_ _IF_ARGS_ 0 2 XX 5 \ (u0 :: Integer) (u1 :: Integer) -> case _APP_ _CONSTM_ Integral quotRem (Integer) [ u0, u1 ] of { _ALG_ _TUP_2 (u2 :: Integer) (u3 :: Integer) -> u3; _NO_DEFLT_ } _N_ },
+ div = { _A_ 2 _U_ 12 _N_ _S_ "U(PPP)U(PPP)" {_A_ 4 _U_ 2222 _N_ _N_ _F_ _IF_ARGS_ 0 4 XXXX 7 \ (u0 :: Int#) (u1 :: Int#) (u2 :: ByteArray#) (u3 :: Integer) -> case _APP_ _WRKR_ _CONSTM_ Integral divMod (Integer) [ u0, u1, u2, u3 ] of { _ALG_ _TUP_2 (u4 :: Integer) (u5 :: Integer) -> u4; _NO_DEFLT_ } _N_} _F_ _IF_ARGS_ 0 2 XX 5 \ (u0 :: Integer) (u1 :: Integer) -> case _APP_ _CONSTM_ Integral divMod (Integer) [ u0, u1 ] of { _ALG_ _TUP_2 (u2 :: Integer) (u3 :: Integer) -> u2; _NO_DEFLT_ } _N_ },
+ mod = { _A_ 2 _U_ 12 _N_ _S_ "U(PPP)U(PPP)" {_A_ 4 _U_ 2222 _N_ _N_ _F_ _IF_ARGS_ 0 4 XXXX 7 \ (u0 :: Int#) (u1 :: Int#) (u2 :: ByteArray#) (u3 :: Integer) -> case _APP_ _WRKR_ _CONSTM_ Integral divMod (Integer) [ u0, u1, u2, u3 ] of { _ALG_ _TUP_2 (u4 :: Integer) (u5 :: Integer) -> u5; _NO_DEFLT_ } _N_} _F_ _IF_ARGS_ 0 2 XX 5 \ (u0 :: Integer) (u1 :: Integer) -> case _APP_ _CONSTM_ Integral divMod (Integer) [ u0, u1 ] of { _ALG_ _TUP_2 (u2 :: Integer) (u3 :: Integer) -> u3; _NO_DEFLT_ } _N_ },
+ quotRem = { _A_ 2 _U_ 11 _N_ _S_ "U(PPP)U(PPP)" {_A_ 4 _U_ 2221 _N_ _N_ _N_ _N_} _N_ _N_ },
+ divMod = { _A_ 2 _U_ 12 _N_ _S_ "U(PPP)U(PPP)" {_A_ 4 _U_ 2222 _N_ _N_ _N_ _N_} _N_ _N_ },
+ even = { _A_ 1 _U_ 1 _N_ _S_ "U(PPP)" {_A_ 3 _U_ 222 _N_ _N_ _N_ _N_} _N_ _N_ },
+ odd = { _A_ 1 _U_ 1 _N_ _S_ "U(PPP)" {_A_ 3 _U_ 222 _N_ _N_ _N_ _N_} _N_ _N_ },
+ toInteger = { _A_ 1 _U_ 1 _N_ _S_ "U(PPP)" {_A_ 3 _U_ 222 _N_ _N_ _F_ _IF_ARGS_ 0 3 XXX 4 \ (u0 :: Int#) (u1 :: Int#) (u2 :: ByteArray#) -> _!_ J# [] [u0, u1, u2] _N_} _F_ _IF_ARGS_ 0 1 X 1 \ (u0 :: Integer) -> u0 _N_ },
+ toInt = { _A_ 1 _U_ 1 _N_ _S_ "U(PPP)" {_A_ 3 _U_ 222 _N_ _N_ _F_ _IF_ARGS_ 0 3 XXX 3 \ (u0 :: Int#) (u1 :: Int#) (u2 :: ByteArray#) -> case _#_ integer2Int# [] [u0, u1, u2] of { _PRIM_ (u3 :: Int#) -> _!_ I# [] [u3] } _N_} _F_ _IF_ARGS_ 0 1 C 4 \ (u0 :: Integer) -> case u0 of { _ALG_ J# (u1 :: Int#) (u2 :: Int#) (u3 :: ByteArray#) -> case _#_ integer2Int# [] [u1, u2, u3] of { _PRIM_ (u4 :: Int#) -> _!_ I# [] [u4] }; _NO_DEFLT_ } _N_ } #-}
instance Ix Integer
{-# GHC_PRAGMA _M_ PreludeCore {-dfun-} _A_ 0 _N_ _N_ _N_ _F_ _IF_ARGS_ 0 0 X 5 _!_ _TUP_4 [{{Ord Integer}}, ((Integer, Integer) -> [Integer]), ((Integer, Integer) -> Integer -> Int), ((Integer, Integer) -> Integer -> Bool)] [_DFUN_ Ord (Integer), _CONSTM_ Ix range (Integer), _CONSTM_ Ix index (Integer), _CONSTM_ Ix inRange (Integer)] _N_
- range = _A_ 1 _U_ 1 _N_ _S_ "U(LL)" {_A_ 2 _U_ 22 _N_ _N_ _F_ _IF_ARGS_ 0 0 X 1 _CONSTM_ Enum enumFromTo (Integer) _N_} _F_ _IF_ARGS_ 0 1 C 4 \ (u0 :: (Integer, Integer)) -> case u0 of { _ALG_ _TUP_2 (u1 :: Integer) (u2 :: Integer) -> _APP_ _CONSTM_ Enum enumFromTo (Integer) [ u1, u2 ]; _NO_DEFLT_ } _N_,
- index = _A_ 2 _U_ 12 _N_ _S_ "U(U(PPP)L)U(PPP)" {_A_ 5 _U_ 22222 _N_ _N_ _N_ _N_} _N_ _N_,
- inRange = _A_ 2 _U_ 11 _N_ _S_ "U(U(PPP)L)U(PPP)" {_A_ 5 _U_ 22211 _N_ _N_ _F_ _IF_ARGS_ 0 5 XXXCC 9 \ (u0 :: Int#) (u1 :: Int#) (u2 :: ByteArray#) (u3 :: Integer) (u4 :: Integer) -> case u4 of { _ALG_ J# (u5 :: Int#) (u6 :: Int#) (u7 :: ByteArray#) -> case _#_ cmpInteger# [] [u0, u1, u2, u5, u6, u7] of { _PRIM_ (u8 :: Int#) -> case _#_ leInt# [] [u8, 0#] of { _ALG_ True -> case u3 of { _ALG_ J# (u9 :: Int#) (ua :: Int#) (ub :: ByteArray#) -> case _#_ cmpInteger# [] [u5, u6, u7, u9, ua, ub] of { _PRIM_ (uc :: Int#) -> _#_ leInt# [] [uc, 0#] }; _NO_DEFLT_ }; False -> _!_ False [] []; _NO_DEFLT_ } }; _NO_DEFLT_ } _N_} _N_ _N_ #-}
+ range = { _A_ 1 _U_ 1 _N_ _S_ "U(LL)" {_A_ 2 _U_ 22 _N_ _N_ _F_ _IF_ARGS_ 0 0 X 1 _CONSTM_ Enum enumFromTo (Integer) _N_} _F_ _IF_ARGS_ 0 1 C 4 \ (u0 :: (Integer, Integer)) -> case u0 of { _ALG_ _TUP_2 (u1 :: Integer) (u2 :: Integer) -> _APP_ _CONSTM_ Enum enumFromTo (Integer) [ u1, u2 ]; _NO_DEFLT_ } _N_ },
+ index = { _A_ 2 _U_ 12 _N_ _S_ "U(U(PPP)L)U(PPP)" {_A_ 5 _U_ 22222 _N_ _N_ _N_ _N_} _N_ _N_ },
+ inRange = { _A_ 2 _U_ 11 _N_ _S_ "U(U(PPP)L)U(PPP)" {_A_ 5 _U_ 22211 _N_ _N_ _F_ _IF_ARGS_ 0 5 XXXCC 9 \ (u0 :: Int#) (u1 :: Int#) (u2 :: ByteArray#) (u3 :: Integer) (u4 :: Integer) -> case u4 of { _ALG_ J# (u5 :: Int#) (u6 :: Int#) (u7 :: ByteArray#) -> case _#_ cmpInteger# [] [u0, u1, u2, u5, u6, u7] of { _PRIM_ (u8 :: Int#) -> case _#_ leInt# [] [u8, 0#] of { _ALG_ True -> case u3 of { _ALG_ J# (u9 :: Int#) (ua :: Int#) (ub :: ByteArray#) -> case _#_ cmpInteger# [] [u5, u6, u7, u9, ua, ub] of { _PRIM_ (uc :: Int#) -> _#_ leInt# [] [uc, 0#] }; _NO_DEFLT_ }; False -> _!_ False [] []; _NO_DEFLT_ } }; _NO_DEFLT_ } _N_} _N_ _N_ } #-}
instance Num Integer
{-# GHC_PRAGMA _M_ PreludeCore {-dfun-} _A_ 0 _N_ _N_ _N_ _F_ _IF_ARGS_ 0 0 X 11 _!_ _TUP_10 [{{Eq Integer}}, {{Text Integer}}, (Integer -> Integer -> Integer), (Integer -> Integer -> Integer), (Integer -> Integer -> Integer), (Integer -> Integer), (Integer -> Integer), (Integer -> Integer), (Integer -> Integer), (Int -> Integer)] [_DFUN_ Eq (Integer), _DFUN_ Text (Integer), _CONSTM_ Num (+) (Integer), _CONSTM_ Num (-) (Integer), _CONSTM_ Num (*) (Integer), _CONSTM_ Num negate (Integer), _CONSTM_ Num abs (Integer), _CONSTM_ Num signum (Integer), _CONSTM_ Num fromInteger (Integer), _CONSTM_ Num fromInt (Integer)] _N_
- (+) = _A_ 2 _U_ 11 _N_ _S_ "U(PPP)U(PPP)" {_A_ 4 _U_ 2221 _N_ _N_ _F_ _IF_ARGS_ 0 4 XXXC 5 \ (u0 :: Int#) (u1 :: Int#) (u2 :: ByteArray#) (u3 :: Integer) -> case u3 of { _ALG_ J# (u4 :: Int#) (u5 :: Int#) (u6 :: ByteArray#) -> _#_ plusInteger# [] [u0, u1, u2, u4, u5, u6]; _NO_DEFLT_ } _N_} _F_ _IF_ARGS_ 0 2 CC 6 \ (u0 :: Integer) (u1 :: Integer) -> case u0 of { _ALG_ J# (u2 :: Int#) (u3 :: Int#) (u4 :: ByteArray#) -> case u1 of { _ALG_ J# (u5 :: Int#) (u6 :: Int#) (u7 :: ByteArray#) -> _#_ plusInteger# [] [u2, u3, u4, u5, u6, u7]; _NO_DEFLT_ }; _NO_DEFLT_ } _N_,
- (-) = _A_ 2 _U_ 11 _N_ _S_ "U(PPP)U(PPP)" {_A_ 4 _U_ 2221 _N_ _N_ _F_ _IF_ARGS_ 0 4 XXXC 5 \ (u0 :: Int#) (u1 :: Int#) (u2 :: ByteArray#) (u3 :: Integer) -> case u3 of { _ALG_ J# (u4 :: Int#) (u5 :: Int#) (u6 :: ByteArray#) -> _#_ minusInteger# [] [u0, u1, u2, u4, u5, u6]; _NO_DEFLT_ } _N_} _F_ _IF_ARGS_ 0 2 CC 6 \ (u0 :: Integer) (u1 :: Integer) -> case u0 of { _ALG_ J# (u2 :: Int#) (u3 :: Int#) (u4 :: ByteArray#) -> case u1 of { _ALG_ J# (u5 :: Int#) (u6 :: Int#) (u7 :: ByteArray#) -> _#_ minusInteger# [] [u2, u3, u4, u5, u6, u7]; _NO_DEFLT_ }; _NO_DEFLT_ } _N_,
- (*) = _A_ 2 _U_ 11 _N_ _S_ "U(PPP)U(PPP)" {_A_ 4 _U_ 2221 _N_ _N_ _F_ _IF_ARGS_ 0 4 XXXC 5 \ (u0 :: Int#) (u1 :: Int#) (u2 :: ByteArray#) (u3 :: Integer) -> case u3 of { _ALG_ J# (u4 :: Int#) (u5 :: Int#) (u6 :: ByteArray#) -> _#_ timesInteger# [] [u0, u1, u2, u4, u5, u6]; _NO_DEFLT_ } _N_} _F_ _IF_ARGS_ 0 2 CC 6 \ (u0 :: Integer) (u1 :: Integer) -> case u0 of { _ALG_ J# (u2 :: Int#) (u3 :: Int#) (u4 :: ByteArray#) -> case u1 of { _ALG_ J# (u5 :: Int#) (u6 :: Int#) (u7 :: ByteArray#) -> _#_ timesInteger# [] [u2, u3, u4, u5, u6, u7]; _NO_DEFLT_ }; _NO_DEFLT_ } _N_,
- negate = _A_ 1 _U_ 1 _N_ _S_ "U(PPP)" {_A_ 3 _U_ 222 _N_ _N_ _F_ _IF_ARGS_ 0 3 XXX 4 \ (u0 :: Int#) (u1 :: Int#) (u2 :: ByteArray#) -> _#_ negateInteger# [] [u0, u1, u2] _N_} _F_ _IF_ARGS_ 0 1 C 5 \ (u0 :: Integer) -> case u0 of { _ALG_ J# (u1 :: Int#) (u2 :: Int#) (u3 :: ByteArray#) -> _#_ negateInteger# [] [u1, u2, u3]; _NO_DEFLT_ } _N_,
- abs = _A_ 1 _U_ 1 _N_ _S_ "U(PPP)" {_A_ 3 _U_ 222 _N_ _N_ _N_ _N_} _N_ _N_,
- signum = _A_ 1 _U_ 1 _N_ _S_ "U(PPP)" {_A_ 3 _U_ 222 _N_ _N_ _N_ _N_} _N_ _N_,
- fromInteger = _A_ 1 _U_ 1 _N_ _S_ "U(PPP)" {_A_ 3 _U_ 222 _N_ _N_ _F_ _IF_ARGS_ 0 3 XXX 4 \ (u0 :: Int#) (u1 :: Int#) (u2 :: ByteArray#) -> _!_ J# [] [u0, u1, u2] _N_} _F_ _IF_ARGS_ 0 1 X 1 \ (u0 :: Integer) -> u0 _N_,
- fromInt = _A_ 1 _U_ 1 _N_ _S_ "U(P)" {_A_ 1 _U_ 2 _N_ _N_ _F_ _IF_ARGS_ 0 1 X 1 \ (u0 :: Int#) -> _#_ int2Integer# [] [u0] _N_} _F_ _IF_ARGS_ 0 1 C 2 \ (u0 :: Int) -> case u0 of { _ALG_ I# (u1 :: Int#) -> _#_ int2Integer# [] [u1]; _NO_DEFLT_ } _N_ #-}
+ (+) = { _A_ 2 _U_ 11 _N_ _S_ "U(PPP)U(PPP)" {_A_ 4 _U_ 2221 _N_ _N_ _F_ _IF_ARGS_ 0 4 XXXC 5 \ (u0 :: Int#) (u1 :: Int#) (u2 :: ByteArray#) (u3 :: Integer) -> case u3 of { _ALG_ J# (u4 :: Int#) (u5 :: Int#) (u6 :: ByteArray#) -> _#_ plusInteger# [] [u0, u1, u2, u4, u5, u6]; _NO_DEFLT_ } _N_} _F_ _IF_ARGS_ 0 2 CC 6 \ (u0 :: Integer) (u1 :: Integer) -> case u0 of { _ALG_ J# (u2 :: Int#) (u3 :: Int#) (u4 :: ByteArray#) -> case u1 of { _ALG_ J# (u5 :: Int#) (u6 :: Int#) (u7 :: ByteArray#) -> _#_ plusInteger# [] [u2, u3, u4, u5, u6, u7]; _NO_DEFLT_ }; _NO_DEFLT_ } _N_ },
+ (-) = { _A_ 2 _U_ 11 _N_ _S_ "U(PPP)U(PPP)" {_A_ 4 _U_ 2221 _N_ _N_ _F_ _IF_ARGS_ 0 4 XXXC 5 \ (u0 :: Int#) (u1 :: Int#) (u2 :: ByteArray#) (u3 :: Integer) -> case u3 of { _ALG_ J# (u4 :: Int#) (u5 :: Int#) (u6 :: ByteArray#) -> _#_ minusInteger# [] [u0, u1, u2, u4, u5, u6]; _NO_DEFLT_ } _N_} _F_ _IF_ARGS_ 0 2 CC 6 \ (u0 :: Integer) (u1 :: Integer) -> case u0 of { _ALG_ J# (u2 :: Int#) (u3 :: Int#) (u4 :: ByteArray#) -> case u1 of { _ALG_ J# (u5 :: Int#) (u6 :: Int#) (u7 :: ByteArray#) -> _#_ minusInteger# [] [u2, u3, u4, u5, u6, u7]; _NO_DEFLT_ }; _NO_DEFLT_ } _N_ },
+ (*) = { _A_ 2 _U_ 11 _N_ _S_ "U(PPP)U(PPP)" {_A_ 4 _U_ 2221 _N_ _N_ _F_ _IF_ARGS_ 0 4 XXXC 5 \ (u0 :: Int#) (u1 :: Int#) (u2 :: ByteArray#) (u3 :: Integer) -> case u3 of { _ALG_ J# (u4 :: Int#) (u5 :: Int#) (u6 :: ByteArray#) -> _#_ timesInteger# [] [u0, u1, u2, u4, u5, u6]; _NO_DEFLT_ } _N_} _F_ _IF_ARGS_ 0 2 CC 6 \ (u0 :: Integer) (u1 :: Integer) -> case u0 of { _ALG_ J# (u2 :: Int#) (u3 :: Int#) (u4 :: ByteArray#) -> case u1 of { _ALG_ J# (u5 :: Int#) (u6 :: Int#) (u7 :: ByteArray#) -> _#_ timesInteger# [] [u2, u3, u4, u5, u6, u7]; _NO_DEFLT_ }; _NO_DEFLT_ } _N_ },
+ negate = { _A_ 1 _U_ 1 _N_ _S_ "U(PPP)" {_A_ 3 _U_ 222 _N_ _N_ _F_ _IF_ARGS_ 0 3 XXX 4 \ (u0 :: Int#) (u1 :: Int#) (u2 :: ByteArray#) -> _#_ negateInteger# [] [u0, u1, u2] _N_} _F_ _IF_ARGS_ 0 1 C 5 \ (u0 :: Integer) -> case u0 of { _ALG_ J# (u1 :: Int#) (u2 :: Int#) (u3 :: ByteArray#) -> _#_ negateInteger# [] [u1, u2, u3]; _NO_DEFLT_ } _N_ },
+ abs = { _A_ 1 _U_ 1 _N_ _S_ "U(PPP)" {_A_ 3 _U_ 222 _N_ _N_ _N_ _N_} _N_ _N_ },
+ signum = { _A_ 1 _U_ 1 _N_ _S_ "U(PPP)" {_A_ 3 _U_ 222 _N_ _N_ _N_ _N_} _N_ _N_ },
+ fromInteger = { _A_ 1 _U_ 1 _N_ _S_ "U(PPP)" {_A_ 3 _U_ 222 _N_ _N_ _F_ _IF_ARGS_ 0 3 XXX 4 \ (u0 :: Int#) (u1 :: Int#) (u2 :: ByteArray#) -> _!_ J# [] [u0, u1, u2] _N_} _F_ _IF_ARGS_ 0 1 X 1 \ (u0 :: Integer) -> u0 _N_ },
+ fromInt = { _A_ 1 _U_ 1 _N_ _S_ "U(P)" {_A_ 1 _U_ 2 _N_ _N_ _F_ _IF_ARGS_ 0 1 X 1 \ (u0 :: Int#) -> _#_ int2Integer# [] [u0] _N_} _F_ _IF_ARGS_ 0 1 C 2 \ (u0 :: Int) -> case u0 of { _ALG_ I# (u1 :: Int#) -> _#_ int2Integer# [] [u1]; _NO_DEFLT_ } _N_ } #-}
instance Ord Integer
{-# GHC_PRAGMA _M_ PreludeCore {-dfun-} _A_ 0 _N_ _N_ _N_ _F_ _IF_ARGS_ 0 0 X 9 _!_ _TUP_8 [{{Eq Integer}}, (Integer -> Integer -> Bool), (Integer -> Integer -> Bool), (Integer -> Integer -> Bool), (Integer -> Integer -> Bool), (Integer -> Integer -> Integer), (Integer -> Integer -> Integer), (Integer -> Integer -> _CMP_TAG)] [_DFUN_ Eq (Integer), _CONSTM_ Ord (<) (Integer), _CONSTM_ Ord (<=) (Integer), _CONSTM_ Ord (>=) (Integer), _CONSTM_ Ord (>) (Integer), _CONSTM_ Ord max (Integer), _CONSTM_ Ord min (Integer), _CONSTM_ Ord _tagCmp (Integer)] _N_
- (<) = _A_ 2 _U_ 11 _N_ _S_ "U(PPP)U(PPP)" {_A_ 4 _U_ 2221 _N_ _N_ _F_ _IF_ARGS_ 0 4 XXXC 3 \ (u0 :: Int#) (u1 :: Int#) (u2 :: ByteArray#) (u3 :: Integer) -> case u3 of { _ALG_ J# (u4 :: Int#) (u5 :: Int#) (u6 :: ByteArray#) -> case _#_ cmpInteger# [] [u0, u1, u2, u4, u5, u6] of { _PRIM_ (u7 :: Int#) -> _#_ ltInt# [] [u7, 0#] }; _NO_DEFLT_ } _N_} _F_ _IF_ARGS_ 0 2 CC 4 \ (u0 :: Integer) (u1 :: Integer) -> case u0 of { _ALG_ J# (u2 :: Int#) (u3 :: Int#) (u4 :: ByteArray#) -> case u1 of { _ALG_ J# (u5 :: Int#) (u6 :: Int#) (u7 :: ByteArray#) -> case _#_ cmpInteger# [] [u2, u3, u4, u5, u6, u7] of { _PRIM_ (u8 :: Int#) -> _#_ ltInt# [] [u8, 0#] }; _NO_DEFLT_ }; _NO_DEFLT_ } _N_,
- (<=) = _A_ 2 _U_ 11 _N_ _S_ "U(PPP)U(PPP)" {_A_ 4 _U_ 2221 _N_ _N_ _F_ _IF_ARGS_ 0 4 XXXC 3 \ (u0 :: Int#) (u1 :: Int#) (u2 :: ByteArray#) (u3 :: Integer) -> case u3 of { _ALG_ J# (u4 :: Int#) (u5 :: Int#) (u6 :: ByteArray#) -> case _#_ cmpInteger# [] [u0, u1, u2, u4, u5, u6] of { _PRIM_ (u7 :: Int#) -> _#_ leInt# [] [u7, 0#] }; _NO_DEFLT_ } _N_} _F_ _IF_ARGS_ 0 2 CC 4 \ (u0 :: Integer) (u1 :: Integer) -> case u0 of { _ALG_ J# (u2 :: Int#) (u3 :: Int#) (u4 :: ByteArray#) -> case u1 of { _ALG_ J# (u5 :: Int#) (u6 :: Int#) (u7 :: ByteArray#) -> case _#_ cmpInteger# [] [u2, u3, u4, u5, u6, u7] of { _PRIM_ (u8 :: Int#) -> _#_ leInt# [] [u8, 0#] }; _NO_DEFLT_ }; _NO_DEFLT_ } _N_,
- (>=) = _A_ 2 _U_ 11 _N_ _S_ "U(PPP)U(PPP)" {_A_ 4 _U_ 2221 _N_ _N_ _F_ _IF_ARGS_ 0 4 XXXC 3 \ (u0 :: Int#) (u1 :: Int#) (u2 :: ByteArray#) (u3 :: Integer) -> case u3 of { _ALG_ J# (u4 :: Int#) (u5 :: Int#) (u6 :: ByteArray#) -> case _#_ cmpInteger# [] [u0, u1, u2, u4, u5, u6] of { _PRIM_ (u7 :: Int#) -> _#_ geInt# [] [u7, 0#] }; _NO_DEFLT_ } _N_} _F_ _IF_ARGS_ 0 2 CC 4 \ (u0 :: Integer) (u1 :: Integer) -> case u0 of { _ALG_ J# (u2 :: Int#) (u3 :: Int#) (u4 :: ByteArray#) -> case u1 of { _ALG_ J# (u5 :: Int#) (u6 :: Int#) (u7 :: ByteArray#) -> case _#_ cmpInteger# [] [u2, u3, u4, u5, u6, u7] of { _PRIM_ (u8 :: Int#) -> _#_ geInt# [] [u8, 0#] }; _NO_DEFLT_ }; _NO_DEFLT_ } _N_,
- (>) = _A_ 2 _U_ 11 _N_ _S_ "U(PPP)U(PPP)" {_A_ 4 _U_ 2221 _N_ _N_ _F_ _IF_ARGS_ 0 4 XXXC 3 \ (u0 :: Int#) (u1 :: Int#) (u2 :: ByteArray#) (u3 :: Integer) -> case u3 of { _ALG_ J# (u4 :: Int#) (u5 :: Int#) (u6 :: ByteArray#) -> case _#_ cmpInteger# [] [u0, u1, u2, u4, u5, u6] of { _PRIM_ (u7 :: Int#) -> _#_ gtInt# [] [u7, 0#] }; _NO_DEFLT_ } _N_} _F_ _IF_ARGS_ 0 2 CC 4 \ (u0 :: Integer) (u1 :: Integer) -> case u0 of { _ALG_ J# (u2 :: Int#) (u3 :: Int#) (u4 :: ByteArray#) -> case u1 of { _ALG_ J# (u5 :: Int#) (u6 :: Int#) (u7 :: ByteArray#) -> case _#_ cmpInteger# [] [u2, u3, u4, u5, u6, u7] of { _PRIM_ (u8 :: Int#) -> _#_ gtInt# [] [u8, 0#] }; _NO_DEFLT_ }; _NO_DEFLT_ } _N_,
- max = _A_ 2 _U_ 11 _N_ _S_ "U(PPP)U(PPP)" {_A_ 4 _U_ 2221 _N_ _N_ _N_ _N_} _N_ _N_,
- min = _A_ 2 _U_ 11 _N_ _S_ "U(PPP)U(PPP)" {_A_ 4 _U_ 2221 _N_ _N_ _N_ _N_} _N_ _N_,
- _tagCmp = _A_ 2 _U_ 11 _N_ _S_ "U(PPP)U(PPP)" {_A_ 4 _U_ 2221 _N_ _N_ _N_ _N_} _N_ _N_ #-}
+ (<) = { _A_ 2 _U_ 11 _N_ _S_ "U(PPP)U(PPP)" {_A_ 4 _U_ 2221 _N_ _N_ _F_ _IF_ARGS_ 0 4 XXXC 3 \ (u0 :: Int#) (u1 :: Int#) (u2 :: ByteArray#) (u3 :: Integer) -> case u3 of { _ALG_ J# (u4 :: Int#) (u5 :: Int#) (u6 :: ByteArray#) -> case _#_ cmpInteger# [] [u0, u1, u2, u4, u5, u6] of { _PRIM_ (u7 :: Int#) -> _#_ ltInt# [] [u7, 0#] }; _NO_DEFLT_ } _N_} _F_ _IF_ARGS_ 0 2 CC 4 \ (u0 :: Integer) (u1 :: Integer) -> case u0 of { _ALG_ J# (u2 :: Int#) (u3 :: Int#) (u4 :: ByteArray#) -> case u1 of { _ALG_ J# (u5 :: Int#) (u6 :: Int#) (u7 :: ByteArray#) -> case _#_ cmpInteger# [] [u2, u3, u4, u5, u6, u7] of { _PRIM_ (u8 :: Int#) -> _#_ ltInt# [] [u8, 0#] }; _NO_DEFLT_ }; _NO_DEFLT_ } _N_ },
+ (<=) = { _A_ 2 _U_ 11 _N_ _S_ "U(PPP)U(PPP)" {_A_ 4 _U_ 2221 _N_ _N_ _F_ _IF_ARGS_ 0 4 XXXC 3 \ (u0 :: Int#) (u1 :: Int#) (u2 :: ByteArray#) (u3 :: Integer) -> case u3 of { _ALG_ J# (u4 :: Int#) (u5 :: Int#) (u6 :: ByteArray#) -> case _#_ cmpInteger# [] [u0, u1, u2, u4, u5, u6] of { _PRIM_ (u7 :: Int#) -> _#_ leInt# [] [u7, 0#] }; _NO_DEFLT_ } _N_} _F_ _IF_ARGS_ 0 2 CC 4 \ (u0 :: Integer) (u1 :: Integer) -> case u0 of { _ALG_ J# (u2 :: Int#) (u3 :: Int#) (u4 :: ByteArray#) -> case u1 of { _ALG_ J# (u5 :: Int#) (u6 :: Int#) (u7 :: ByteArray#) -> case _#_ cmpInteger# [] [u2, u3, u4, u5, u6, u7] of { _PRIM_ (u8 :: Int#) -> _#_ leInt# [] [u8, 0#] }; _NO_DEFLT_ }; _NO_DEFLT_ } _N_ },
+ (>=) = { _A_ 2 _U_ 11 _N_ _S_ "U(PPP)U(PPP)" {_A_ 4 _U_ 2221 _N_ _N_ _F_ _IF_ARGS_ 0 4 XXXC 3 \ (u0 :: Int#) (u1 :: Int#) (u2 :: ByteArray#) (u3 :: Integer) -> case u3 of { _ALG_ J# (u4 :: Int#) (u5 :: Int#) (u6 :: ByteArray#) -> case _#_ cmpInteger# [] [u0, u1, u2, u4, u5, u6] of { _PRIM_ (u7 :: Int#) -> _#_ geInt# [] [u7, 0#] }; _NO_DEFLT_ } _N_} _F_ _IF_ARGS_ 0 2 CC 4 \ (u0 :: Integer) (u1 :: Integer) -> case u0 of { _ALG_ J# (u2 :: Int#) (u3 :: Int#) (u4 :: ByteArray#) -> case u1 of { _ALG_ J# (u5 :: Int#) (u6 :: Int#) (u7 :: ByteArray#) -> case _#_ cmpInteger# [] [u2, u3, u4, u5, u6, u7] of { _PRIM_ (u8 :: Int#) -> _#_ geInt# [] [u8, 0#] }; _NO_DEFLT_ }; _NO_DEFLT_ } _N_ },
+ (>) = { _A_ 2 _U_ 11 _N_ _S_ "U(PPP)U(PPP)" {_A_ 4 _U_ 2221 _N_ _N_ _F_ _IF_ARGS_ 0 4 XXXC 3 \ (u0 :: Int#) (u1 :: Int#) (u2 :: ByteArray#) (u3 :: Integer) -> case u3 of { _ALG_ J# (u4 :: Int#) (u5 :: Int#) (u6 :: ByteArray#) -> case _#_ cmpInteger# [] [u0, u1, u2, u4, u5, u6] of { _PRIM_ (u7 :: Int#) -> _#_ gtInt# [] [u7, 0#] }; _NO_DEFLT_ } _N_} _F_ _IF_ARGS_ 0 2 CC 4 \ (u0 :: Integer) (u1 :: Integer) -> case u0 of { _ALG_ J# (u2 :: Int#) (u3 :: Int#) (u4 :: ByteArray#) -> case u1 of { _ALG_ J# (u5 :: Int#) (u6 :: Int#) (u7 :: ByteArray#) -> case _#_ cmpInteger# [] [u2, u3, u4, u5, u6, u7] of { _PRIM_ (u8 :: Int#) -> _#_ gtInt# [] [u8, 0#] }; _NO_DEFLT_ }; _NO_DEFLT_ } _N_ },
+ max = { _A_ 2 _U_ 11 _N_ _S_ "U(PPP)U(PPP)" {_A_ 4 _U_ 2221 _N_ _N_ _N_ _N_} _N_ _N_ },
+ min = { _A_ 2 _U_ 11 _N_ _S_ "U(PPP)U(PPP)" {_A_ 4 _U_ 2221 _N_ _N_ _N_ _N_} _N_ _N_ },
+ _tagCmp = { _A_ 2 _U_ 11 _N_ _S_ "U(PPP)U(PPP)" {_A_ 4 _U_ 2221 _N_ _N_ _N_ _N_} _N_ _N_ } #-}
instance Real Integer
{-# GHC_PRAGMA _M_ PreludeCore {-dfun-} _A_ 0 _N_ _N_ _N_ _F_ _IF_ARGS_ 0 0 X 4 _!_ _TUP_3 [{{Num Integer}}, {{Enum Integer}}, (Integer -> Ratio Integer)] [_DFUN_ Num (Integer), _DFUN_ Enum (Integer), _CONSTM_ Real toRational (Integer)] _N_
- toRational = _A_ 1 _U_ 2 _N_ _N_ _N_ _N_ #-}
+ toRational = { _A_ 1 _U_ 2 _N_ _N_ _F_ _IF_ARGS_ 0 1 X 3 \ (u0 :: Integer) -> _!_ (:%) [Integer] [u0, _ORIG_ PreludeCore __integer1] _N_ } #-}
instance Text Integer
{-# GHC_PRAGMA _M_ PreludeCore {-dfun-} _A_ 0 _N_ _N_ _N_ _F_ _IF_ARGS_ 0 0 X 5 _!_ _TUP_4 [(Int -> [Char] -> [(Integer, [Char])]), (Int -> Integer -> [Char] -> [Char]), ([Char] -> [([Integer], [Char])]), ([Integer] -> [Char] -> [Char])] [_CONSTM_ Text readsPrec (Integer), _CONSTM_ Text showsPrec (Integer), _CONSTM_ Text readList (Integer), _CONSTM_ Text showList (Integer)] _N_
- readsPrec = _A_ 2 _U_ 02 _N_ _S_ "AL" {_A_ 1 _U_ 2 _N_ _N_ _F_ _IF_ARGS_ 0 1 X 3 \ (u0 :: [Char]) -> _APP_ _SPEC_ _ORIG_ PreludeText readSigned [ (Integer) ] [ _SPEC_ _ORIG_ PreludeText readDec [ (Integer) ], u0 ] _N_} _F_ _IF_ARGS_ 0 2 XX 3 \ (u0 :: Int) (u1 :: [Char]) -> _APP_ _SPEC_ _ORIG_ PreludeText readSigned [ (Integer) ] [ _SPEC_ _ORIG_ PreludeText readDec [ (Integer) ], u1 ] _N_,
- showsPrec = _A_ 3 _U_ 212 _N_ _S_ "LU(PPP)L" {_A_ 5 _U_ 22222 _N_ _N_ _N_ _N_} _N_ _N_,
- readList = _A_ 0 _U_ 2 _N_ _N_ _N_ _N_,
- showList = _A_ 0 _U_ 12 _N_ _N_ _N_ _N_ #-}
+ readsPrec = { _A_ 2 _U_ 02 _N_ _S_ "AL" {_A_ 1 _U_ 2 _N_ _N_ _F_ _IF_ARGS_ 0 1 X 3 \ (u0 :: [Char]) -> _APP_ _SPEC_ _ORIG_ PreludeText readSigned [ (Integer) ] [ _SPEC_ _ORIG_ PreludeText readDec [ (Integer) ], u0 ] _N_} _F_ _IF_ARGS_ 0 2 XX 3 \ (u0 :: Int) (u1 :: [Char]) -> _APP_ _SPEC_ _ORIG_ PreludeText readSigned [ (Integer) ] [ _SPEC_ _ORIG_ PreludeText readDec [ (Integer) ], u1 ] _N_ },
+ showsPrec = { _A_ 3 _U_ 212 _N_ _S_ "LU(PPP)L" {_A_ 5 _U_ 22222 _N_ _N_ _N_ _N_} _N_ _N_ },
+ readList = { _A_ 0 _U_ 2 _N_ _N_ _N_ _N_ },
+ showList = { _A_ 1 _U_ 12 _N_ _N_ _N_ _N_ } #-}
-{-# GHC_PRAGMA INTERFACE VERSION 5 #-}
+{-# GHC_PRAGMA INTERFACE VERSION 6 #-}
interface PreludeBuiltin where
-import PreludeCore(Eq(..), Ord(..), Text(..), _CCallable(..), _CReturnable(..))
+import PreludeComplex(Complex)
+import PreludeCore(Bool(..), Eq(..), Ord(..), Text(..), _CCallable(..), _CReturnable(..))
+instance Eq [(Int, Int)]
+ {-# GHC_PRAGMA _M_ PreludeBuiltin {-dfun-} _A_ 0 _N_ _N_ _N_ _F_ _IF_ARGS_ 0 0 X 3 _!_ _TUP_2 [([(Int, Int)] -> [(Int, Int)] -> Bool), ([(Int, Int)] -> [(Int, Int)] -> Bool)] [_CONSTM_ Eq (==) ([(Int, Int)]), _CONSTM_ Eq (/=) ([(Int, Int)])] _N_
+ (==) = { _A_ 2 _U_ 11 _N_ _S_ "SS" _N_ _N_ },
+ (/=) = { _A_ 2 _U_ 11 _N_ _S_ "SS" _N_ _N_ } #-}
instance Eq a => Eq [a]
{-# GHC_PRAGMA _M_ PreludeBuiltin {-dfun-} _A_ 1 _U_ 1 _N_ _N_ _N_ _N_ #-}
+instance Eq [Bool]
+ {-# GHC_PRAGMA _M_ PreludeBuiltin {-dfun-} _A_ 0 _N_ _N_ _N_ _F_ _IF_ARGS_ 0 0 X 3 _!_ _TUP_2 [([Bool] -> [Bool] -> Bool), ([Bool] -> [Bool] -> Bool)] [_CONSTM_ Eq (==) ([Bool]), _CONSTM_ Eq (/=) ([Bool])] _N_
+ (==) = { _A_ 2 _U_ 11 _N_ _S_ "SS" _N_ _N_ },
+ (/=) = { _A_ 2 _U_ 11 _N_ _S_ "SS" _N_ _N_ } #-}
instance Eq [Char]
{-# GHC_PRAGMA _M_ PreludeBuiltin {-dfun-} _A_ 0 _N_ _N_ _N_ _F_ _IF_ARGS_ 0 0 X 3 _!_ _TUP_2 [([Char] -> [Char] -> Bool), ([Char] -> [Char] -> Bool)] [_CONSTM_ Eq (==) ([Char]), _CONSTM_ Eq (/=) ([Char])] _N_
- (==) = _A_ 2 _U_ 11 _N_ _S_ "SS" _N_ _N_,
- (/=) = _A_ 2 _U_ 11 _N_ _S_ "SS" _N_ _N_ #-}
+ (==) = { _A_ 2 _U_ 11 _N_ _S_ "SS" _N_ _N_ },
+ (/=) = { _A_ 2 _U_ 11 _N_ _S_ "SS" _N_ _N_ } #-}
+instance Eq [Complex Double]
+ {-# GHC_PRAGMA _M_ PreludeBuiltin {-dfun-} _A_ 0 _N_ _N_ _N_ _F_ _IF_ARGS_ 0 0 X 3 _!_ _TUP_2 [([Complex Double] -> [Complex Double] -> Bool), ([Complex Double] -> [Complex Double] -> Bool)] [_CONSTM_ Eq (==) ([Complex Double]), _CONSTM_ Eq (/=) ([Complex Double])] _N_
+ (==) = { _A_ 2 _U_ 11 _N_ _S_ "SS" _N_ _N_ },
+ (/=) = { _A_ 2 _U_ 11 _N_ _S_ "SS" _N_ _N_ } #-}
+instance Eq [Double]
+ {-# GHC_PRAGMA _M_ PreludeBuiltin {-dfun-} _A_ 0 _N_ _N_ _N_ _F_ _IF_ARGS_ 0 0 X 3 _!_ _TUP_2 [([Double] -> [Double] -> Bool), ([Double] -> [Double] -> Bool)] [_CONSTM_ Eq (==) ([Double]), _CONSTM_ Eq (/=) ([Double])] _N_
+ (==) = { _A_ 2 _U_ 11 _N_ _S_ "SS" _N_ _N_ },
+ (/=) = { _A_ 2 _U_ 11 _N_ _S_ "SS" _N_ _N_ } #-}
instance Eq [Int]
{-# GHC_PRAGMA _M_ PreludeBuiltin {-dfun-} _A_ 0 _N_ _N_ _N_ _F_ _IF_ARGS_ 0 0 X 3 _!_ _TUP_2 [([Int] -> [Int] -> Bool), ([Int] -> [Int] -> Bool)] [_CONSTM_ Eq (==) ([Int]), _CONSTM_ Eq (/=) ([Int])] _N_
- (==) = _A_ 2 _U_ 11 _N_ _S_ "SS" _N_ _N_,
- (/=) = _A_ 2 _U_ 11 _N_ _S_ "SS" _N_ _N_ #-}
+ (==) = { _A_ 2 _U_ 11 _N_ _S_ "SS" _N_ _N_ },
+ (/=) = { _A_ 2 _U_ 11 _N_ _S_ "SS" _N_ _N_ } #-}
+instance Eq [Integer]
+ {-# GHC_PRAGMA _M_ PreludeBuiltin {-dfun-} _A_ 0 _N_ _N_ _N_ _F_ _IF_ARGS_ 0 0 X 3 _!_ _TUP_2 [([Integer] -> [Integer] -> Bool), ([Integer] -> [Integer] -> Bool)] [_CONSTM_ Eq (==) ([Integer]), _CONSTM_ Eq (/=) ([Integer])] _N_
+ (==) = { _A_ 2 _U_ 11 _N_ _S_ "SS" _N_ _N_ },
+ (/=) = { _A_ 2 _U_ 11 _N_ _S_ "SS" _N_ _N_ } #-}
+instance Eq [[Char]]
+ {-# GHC_PRAGMA _M_ PreludeBuiltin {-dfun-} _A_ 0 _N_ _N_ _N_ _F_ _IF_ARGS_ 0 0 X 3 _!_ _TUP_2 [([[Char]] -> [[Char]] -> Bool), ([[Char]] -> [[Char]] -> Bool)] [_CONSTM_ Eq (==) ([[Char]]), _CONSTM_ Eq (/=) ([[Char]])] _N_
+ (==) = { _A_ 2 _U_ 11 _N_ _S_ "SS" _N_ _N_ },
+ (/=) = { _A_ 2 _U_ 11 _N_ _S_ "SS" _N_ _N_ } #-}
+instance Eq [[Int]]
+ {-# GHC_PRAGMA _M_ PreludeBuiltin {-dfun-} _A_ 0 _N_ _N_ _N_ _F_ _IF_ARGS_ 0 0 X 3 _!_ _TUP_2 [([[Int]] -> [[Int]] -> Bool), ([[Int]] -> [[Int]] -> Bool)] [_CONSTM_ Eq (==) ([[Int]]), _CONSTM_ Eq (/=) ([[Int]])] _N_
+ (==) = { _A_ 2 _U_ 11 _N_ _S_ "SS" _N_ _N_ },
+ (/=) = { _A_ 2 _U_ 11 _N_ _S_ "SS" _N_ _N_ } #-}
instance Ord a => Ord [a]
{-# GHC_PRAGMA _M_ PreludeBuiltin {-dfun-} _A_ 2 _U_ 12 _N_ _N_ _N_ _N_ #-}
+instance Ord [Bool]
+ {-# GHC_PRAGMA _M_ PreludeBuiltin {-dfun-} _A_ 0 _N_ _N_ _N_ _F_ _IF_ARGS_ 0 0 X 9 _!_ _TUP_8 [{{Eq [Bool]}}, ([Bool] -> [Bool] -> Bool), ([Bool] -> [Bool] -> Bool), ([Bool] -> [Bool] -> Bool), ([Bool] -> [Bool] -> Bool), ([Bool] -> [Bool] -> [Bool]), ([Bool] -> [Bool] -> [Bool]), ([Bool] -> [Bool] -> _CMP_TAG)] [_DFUN_ Eq ([Bool]), _CONSTM_ Ord (<) ([Bool]), _CONSTM_ Ord (<=) ([Bool]), _CONSTM_ Ord (>=) ([Bool]), _CONSTM_ Ord (>) ([Bool]), _CONSTM_ Ord max ([Bool]), _CONSTM_ Ord min ([Bool]), _CONSTM_ Ord _tagCmp ([Bool])] _N_
+ (<) = { _A_ 2 _U_ 11 _N_ _S_ "SS" _N_ _N_ },
+ (<=) = { _A_ 2 _U_ 11 _N_ _S_ "SS" _N_ _N_ },
+ (>=) = { _A_ 2 _U_ 11 _N_ _S_ "SS" _N_ _N_ },
+ (>) = { _A_ 2 _U_ 11 _N_ _S_ "SS" _N_ _N_ },
+ max = { _A_ 2 _U_ 22 _N_ _S_ "SS" _N_ _N_ },
+ min = { _A_ 2 _U_ 22 _N_ _S_ "SS" _N_ _N_ },
+ _tagCmp = { _A_ 2 _U_ 11 _N_ _S_ "SS" _N_ _N_ } #-}
instance Ord [Char]
{-# GHC_PRAGMA _M_ PreludeBuiltin {-dfun-} _A_ 0 _N_ _N_ _N_ _F_ _IF_ARGS_ 0 0 X 9 _!_ _TUP_8 [{{Eq [Char]}}, ([Char] -> [Char] -> Bool), ([Char] -> [Char] -> Bool), ([Char] -> [Char] -> Bool), ([Char] -> [Char] -> Bool), ([Char] -> [Char] -> [Char]), ([Char] -> [Char] -> [Char]), ([Char] -> [Char] -> _CMP_TAG)] [_DFUN_ Eq ([Char]), _CONSTM_ Ord (<) ([Char]), _CONSTM_ Ord (<=) ([Char]), _CONSTM_ Ord (>=) ([Char]), _CONSTM_ Ord (>) ([Char]), _CONSTM_ Ord max ([Char]), _CONSTM_ Ord min ([Char]), _CONSTM_ Ord _tagCmp ([Char])] _N_
- (<) = _A_ 2 _U_ 11 _N_ _S_ "SS" _N_ _N_,
- (<=) = _A_ 2 _U_ 11 _N_ _S_ "SS" _N_ _N_,
- (>=) = _A_ 2 _U_ 11 _N_ _S_ "SS" _N_ _N_,
- (>) = _A_ 2 _U_ 11 _N_ _S_ "SS" _N_ _N_,
- max = _A_ 2 _U_ 22 _N_ _S_ "SS" _N_ _N_,
- min = _A_ 2 _U_ 22 _N_ _S_ "SS" _N_ _N_,
- _tagCmp = _A_ 2 _U_ 11 _N_ _S_ "SS" _N_ _N_ #-}
+ (<) = { _A_ 2 _U_ 11 _N_ _S_ "SS" _N_ _N_ },
+ (<=) = { _A_ 2 _U_ 11 _N_ _S_ "SS" _N_ _N_ },
+ (>=) = { _A_ 2 _U_ 11 _N_ _S_ "SS" _N_ _N_ },
+ (>) = { _A_ 2 _U_ 11 _N_ _S_ "SS" _N_ _N_ },
+ max = { _A_ 2 _U_ 22 _N_ _S_ "SS" _N_ _N_ },
+ min = { _A_ 2 _U_ 22 _N_ _S_ "SS" _N_ _N_ },
+ _tagCmp = { _A_ 2 _U_ 11 _N_ _S_ "SS" _N_ _N_ } #-}
+instance Ord [Double]
+ {-# GHC_PRAGMA _M_ PreludeBuiltin {-dfun-} _A_ 0 _N_ _N_ _N_ _F_ _IF_ARGS_ 0 0 X 9 _!_ _TUP_8 [{{Eq [Double]}}, ([Double] -> [Double] -> Bool), ([Double] -> [Double] -> Bool), ([Double] -> [Double] -> Bool), ([Double] -> [Double] -> Bool), ([Double] -> [Double] -> [Double]), ([Double] -> [Double] -> [Double]), ([Double] -> [Double] -> _CMP_TAG)] [_DFUN_ Eq ([Double]), _CONSTM_ Ord (<) ([Double]), _CONSTM_ Ord (<=) ([Double]), _CONSTM_ Ord (>=) ([Double]), _CONSTM_ Ord (>) ([Double]), _CONSTM_ Ord max ([Double]), _CONSTM_ Ord min ([Double]), _CONSTM_ Ord _tagCmp ([Double])] _N_
+ (<) = { _A_ 2 _U_ 11 _N_ _S_ "SS" _N_ _N_ },
+ (<=) = { _A_ 2 _U_ 11 _N_ _S_ "SS" _N_ _N_ },
+ (>=) = { _A_ 2 _U_ 11 _N_ _S_ "SS" _N_ _N_ },
+ (>) = { _A_ 2 _U_ 11 _N_ _S_ "SS" _N_ _N_ },
+ max = { _A_ 2 _U_ 22 _N_ _S_ "SS" _N_ _N_ },
+ min = { _A_ 2 _U_ 22 _N_ _S_ "SS" _N_ _N_ },
+ _tagCmp = { _A_ 2 _U_ 11 _N_ _S_ "SS" _N_ _N_ } #-}
instance Ord [Int]
{-# GHC_PRAGMA _M_ PreludeBuiltin {-dfun-} _A_ 0 _N_ _N_ _N_ _F_ _IF_ARGS_ 0 0 X 9 _!_ _TUP_8 [{{Eq [Int]}}, ([Int] -> [Int] -> Bool), ([Int] -> [Int] -> Bool), ([Int] -> [Int] -> Bool), ([Int] -> [Int] -> Bool), ([Int] -> [Int] -> [Int]), ([Int] -> [Int] -> [Int]), ([Int] -> [Int] -> _CMP_TAG)] [_DFUN_ Eq ([Int]), _CONSTM_ Ord (<) ([Int]), _CONSTM_ Ord (<=) ([Int]), _CONSTM_ Ord (>=) ([Int]), _CONSTM_ Ord (>) ([Int]), _CONSTM_ Ord max ([Int]), _CONSTM_ Ord min ([Int]), _CONSTM_ Ord _tagCmp ([Int])] _N_
- (<) = _A_ 2 _U_ 11 _N_ _S_ "SS" _N_ _N_,
- (<=) = _A_ 2 _U_ 11 _N_ _S_ "SS" _N_ _N_,
- (>=) = _A_ 2 _U_ 11 _N_ _S_ "SS" _N_ _N_,
- (>) = _A_ 2 _U_ 11 _N_ _S_ "SS" _N_ _N_,
- max = _A_ 2 _U_ 22 _N_ _S_ "SS" _N_ _N_,
- min = _A_ 2 _U_ 22 _N_ _S_ "SS" _N_ _N_,
- _tagCmp = _A_ 2 _U_ 11 _N_ _S_ "SS" _N_ _N_ #-}
+ (<) = { _A_ 2 _U_ 11 _N_ _S_ "SS" _N_ _N_ },
+ (<=) = { _A_ 2 _U_ 11 _N_ _S_ "SS" _N_ _N_ },
+ (>=) = { _A_ 2 _U_ 11 _N_ _S_ "SS" _N_ _N_ },
+ (>) = { _A_ 2 _U_ 11 _N_ _S_ "SS" _N_ _N_ },
+ max = { _A_ 2 _U_ 22 _N_ _S_ "SS" _N_ _N_ },
+ min = { _A_ 2 _U_ 22 _N_ _S_ "SS" _N_ _N_ },
+ _tagCmp = { _A_ 2 _U_ 11 _N_ _S_ "SS" _N_ _N_ } #-}
+instance Ord [Integer]
+ {-# GHC_PRAGMA _M_ PreludeBuiltin {-dfun-} _A_ 0 _N_ _N_ _N_ _F_ _IF_ARGS_ 0 0 X 9 _!_ _TUP_8 [{{Eq [Integer]}}, ([Integer] -> [Integer] -> Bool), ([Integer] -> [Integer] -> Bool), ([Integer] -> [Integer] -> Bool), ([Integer] -> [Integer] -> Bool), ([Integer] -> [Integer] -> [Integer]), ([Integer] -> [Integer] -> [Integer]), ([Integer] -> [Integer] -> _CMP_TAG)] [_DFUN_ Eq ([Integer]), _CONSTM_ Ord (<) ([Integer]), _CONSTM_ Ord (<=) ([Integer]), _CONSTM_ Ord (>=) ([Integer]), _CONSTM_ Ord (>) ([Integer]), _CONSTM_ Ord max ([Integer]), _CONSTM_ Ord min ([Integer]), _CONSTM_ Ord _tagCmp ([Integer])] _N_
+ (<) = { _A_ 2 _U_ 11 _N_ _S_ "SS" _N_ _N_ },
+ (<=) = { _A_ 2 _U_ 11 _N_ _S_ "SS" _N_ _N_ },
+ (>=) = { _A_ 2 _U_ 11 _N_ _S_ "SS" _N_ _N_ },
+ (>) = { _A_ 2 _U_ 11 _N_ _S_ "SS" _N_ _N_ },
+ max = { _A_ 2 _U_ 22 _N_ _S_ "SS" _N_ _N_ },
+ min = { _A_ 2 _U_ 22 _N_ _S_ "SS" _N_ _N_ },
+ _tagCmp = { _A_ 2 _U_ 11 _N_ _S_ "SS" _N_ _N_ } #-}
+instance Ord [[Char]]
+ {-# GHC_PRAGMA _M_ PreludeBuiltin {-dfun-} _A_ 0 _N_ _N_ _N_ _F_ _IF_ARGS_ 0 0 X 9 _!_ _TUP_8 [{{Eq [[Char]]}}, ([[Char]] -> [[Char]] -> Bool), ([[Char]] -> [[Char]] -> Bool), ([[Char]] -> [[Char]] -> Bool), ([[Char]] -> [[Char]] -> Bool), ([[Char]] -> [[Char]] -> [[Char]]), ([[Char]] -> [[Char]] -> [[Char]]), ([[Char]] -> [[Char]] -> _CMP_TAG)] [_DFUN_ Eq ([[Char]]), _CONSTM_ Ord (<) ([[Char]]), _CONSTM_ Ord (<=) ([[Char]]), _CONSTM_ Ord (>=) ([[Char]]), _CONSTM_ Ord (>) ([[Char]]), _CONSTM_ Ord max ([[Char]]), _CONSTM_ Ord min ([[Char]]), _CONSTM_ Ord _tagCmp ([[Char]])] _N_
+ (<) = { _A_ 2 _U_ 11 _N_ _S_ "SS" _N_ _N_ },
+ (<=) = { _A_ 2 _U_ 11 _N_ _S_ "SS" _N_ _N_ },
+ (>=) = { _A_ 2 _U_ 11 _N_ _S_ "SS" _N_ _N_ },
+ (>) = { _A_ 2 _U_ 11 _N_ _S_ "SS" _N_ _N_ },
+ max = { _A_ 2 _U_ 22 _N_ _S_ "SS" _N_ _N_ },
+ min = { _A_ 2 _U_ 22 _N_ _S_ "SS" _N_ _N_ },
+ _tagCmp = { _A_ 2 _U_ 11 _N_ _S_ "SS" _N_ _N_ } #-}
+instance Ord [[Int]]
+ {-# GHC_PRAGMA _M_ PreludeBuiltin {-dfun-} _A_ 0 _N_ _N_ _N_ _F_ _IF_ARGS_ 0 0 X 9 _!_ _TUP_8 [{{Eq [[Int]]}}, ([[Int]] -> [[Int]] -> Bool), ([[Int]] -> [[Int]] -> Bool), ([[Int]] -> [[Int]] -> Bool), ([[Int]] -> [[Int]] -> Bool), ([[Int]] -> [[Int]] -> [[Int]]), ([[Int]] -> [[Int]] -> [[Int]]), ([[Int]] -> [[Int]] -> _CMP_TAG)] [_DFUN_ Eq ([[Int]]), _CONSTM_ Ord (<) ([[Int]]), _CONSTM_ Ord (<=) ([[Int]]), _CONSTM_ Ord (>=) ([[Int]]), _CONSTM_ Ord (>) ([[Int]]), _CONSTM_ Ord max ([[Int]]), _CONSTM_ Ord min ([[Int]]), _CONSTM_ Ord _tagCmp ([[Int]])] _N_
+ (<) = { _A_ 2 _U_ 11 _N_ _S_ "SS" _N_ _N_ },
+ (<=) = { _A_ 2 _U_ 11 _N_ _S_ "SS" _N_ _N_ },
+ (>=) = { _A_ 2 _U_ 11 _N_ _S_ "SS" _N_ _N_ },
+ (>) = { _A_ 2 _U_ 11 _N_ _S_ "SS" _N_ _N_ },
+ max = { _A_ 2 _U_ 22 _N_ _S_ "SS" _N_ _N_ },
+ min = { _A_ 2 _U_ 22 _N_ _S_ "SS" _N_ _N_ },
+ _tagCmp = { _A_ 2 _U_ 11 _N_ _S_ "SS" _N_ _N_ } #-}
instance Text a => Text [a]
{-# GHC_PRAGMA _M_ PreludeBuiltin {-dfun-} _A_ 1 _U_ 2 _N_ _N_ _N_ _N_ #-}
+instance Text [Bool]
+ {-# GHC_PRAGMA _M_ PreludeBuiltin {-dfun-} _A_ 0 _N_ _N_ _N_ _F_ _IF_ARGS_ 0 0 X 5 _!_ _TUP_4 [(Int -> [Char] -> [([Bool], [Char])]), (Int -> [Bool] -> [Char] -> [Char]), ([Char] -> [([[Bool]], [Char])]), ([[Bool]] -> [Char] -> [Char])] [_CONSTM_ Text readsPrec ([Bool]), _CONSTM_ Text showsPrec ([Bool]), _CONSTM_ Text readList ([Bool]), _CONSTM_ Text showList ([Bool])] _N_
+ readsPrec = { _A_ 1 _U_ 02 _N_ _S_ "A" {_A_ 0 _U_ 2 _N_ _N_ _F_ _IF_ARGS_ 0 0 X 1 _CONSTM_ Text readList (Bool) _N_} _F_ _IF_ARGS_ 0 1 X 1 \ (u0 :: Int) -> _CONSTM_ Text readList (Bool) _N_ },
+ showsPrec = { _A_ 2 _U_ 012 _N_ _S_ "AS" {_A_ 1 _U_ 12 _N_ _N_ _F_ _IF_ARGS_ 0 1 X 3 \ (u0 :: [Bool]) -> _APP_ _TYAPP_ _ORIG_ PreludeCore _showList { Bool } [ _WRKR_ _CONSTM_ Text showsPrec (Bool), u0 ] _N_} _F_ _IF_ARGS_ 0 2 XX 3 \ (u0 :: Int) (u1 :: [Bool]) -> _APP_ _TYAPP_ _ORIG_ PreludeCore _showList { Bool } [ _WRKR_ _CONSTM_ Text showsPrec (Bool), u1 ] _N_ },
+ readList = { _A_ 0 _U_ 2 _N_ _N_ _N_ _N_ },
+ showList = { _A_ 1 _U_ 12 _N_ _N_ _N_ _N_ } #-}
instance Text [Char]
{-# GHC_PRAGMA _M_ PreludeBuiltin {-dfun-} _A_ 0 _N_ _N_ _N_ _F_ _IF_ARGS_ 0 0 X 5 _!_ _TUP_4 [(Int -> [Char] -> [([Char], [Char])]), (Int -> [Char] -> [Char] -> [Char]), ([Char] -> [([[Char]], [Char])]), ([[Char]] -> [Char] -> [Char])] [_CONSTM_ Text readsPrec ([Char]), _CONSTM_ Text showsPrec ([Char]), _CONSTM_ Text readList ([Char]), _CONSTM_ Text showList ([Char])] _N_
- readsPrec = _A_ 1 _U_ 02 _N_ _S_ "A" {_A_ 0 _U_ 2 _N_ _N_ _F_ _IF_ARGS_ 0 0 X 1 _CONSTM_ Text readList (Char) _N_} _F_ _IF_ARGS_ 0 1 X 1 \ (u0 :: Int) -> _CONSTM_ Text readList (Char) _N_,
- showsPrec = _A_ 2 _U_ 022 _N_ _S_ "AL" {_A_ 1 _U_ 22 _N_ _N_ _F_ _IF_ARGS_ 0 0 X 1 _CONSTM_ Text showList (Char) _N_} _F_ _IF_ARGS_ 0 2 XX 2 \ (u0 :: Int) (u1 :: [Char]) -> _APP_ _CONSTM_ Text showList (Char) [ u1 ] _N_,
- readList = _A_ 0 _U_ 2 _N_ _N_ _N_ _N_,
- showList = _A_ 0 _U_ 12 _N_ _N_ _N_ _N_ #-}
+ readsPrec = { _A_ 1 _U_ 02 _N_ _S_ "A" {_A_ 0 _U_ 2 _N_ _N_ _F_ _IF_ARGS_ 0 0 X 1 _CONSTM_ Text readList (Char) _N_} _F_ _IF_ARGS_ 0 1 X 1 \ (u0 :: Int) -> _CONSTM_ Text readList (Char) _N_ },
+ showsPrec = { _A_ 2 _U_ 022 _N_ _S_ "AL" {_A_ 1 _U_ 22 _N_ _N_ _F_ _IF_ARGS_ 0 0 X 1 _CONSTM_ Text showList (Char) _N_} _F_ _IF_ARGS_ 0 2 XX 2 \ (u0 :: Int) (u1 :: [Char]) -> _APP_ _CONSTM_ Text showList (Char) [ u1 ] _N_ },
+ readList = { _A_ 0 _U_ 2 _N_ _N_ _N_ _N_ },
+ showList = { _A_ 1 _U_ 12 _N_ _N_ _F_ _IF_ARGS_ 0 1 X 3 \ (u0 :: [[Char]]) -> _APP_ _TYAPP_ _ORIG_ PreludeCore _showList { [Char] } [ _CONSTM_ Text showList (Char), u0 ] _N_ } #-}
+instance Text [Complex Double]
+ {-# GHC_PRAGMA _M_ PreludeBuiltin {-dfun-} _A_ 0 _N_ _N_ _N_ _F_ _IF_ARGS_ 0 0 X 5 _!_ _TUP_4 [(Int -> [Char] -> [([Complex Double], [Char])]), (Int -> [Complex Double] -> [Char] -> [Char]), ([Char] -> [([[Complex Double]], [Char])]), ([[Complex Double]] -> [Char] -> [Char])] [_CONSTM_ Text readsPrec ([Complex Double]), _CONSTM_ Text showsPrec ([Complex Double]), _CONSTM_ Text readList ([Complex Double]), _CONSTM_ Text showList ([Complex Double])] _N_
+ readsPrec = { _A_ 1 _U_ 02 _N_ _S_ "A" {_A_ 0 _U_ 2 _N_ _N_ _F_ _IF_ARGS_ 0 0 X 1 _CONSTM_ Text readList (Complex Double) _N_} _F_ _IF_ARGS_ 0 1 X 1 \ (u0 :: Int) -> _CONSTM_ Text readList (Complex Double) _N_ },
+ showsPrec = { _A_ 2 _U_ 022 _N_ _S_ "AL" {_A_ 1 _U_ 22 _N_ _N_ _F_ _IF_ARGS_ 0 0 X 1 _CONSTM_ Text showList (Complex Double) _N_} _F_ _IF_ARGS_ 0 2 XX 2 \ (u0 :: Int) (u1 :: [Complex Double]) -> _APP_ _CONSTM_ Text showList (Complex Double) [ u1 ] _N_ },
+ readList = { _A_ 0 _U_ 2 _N_ _N_ _N_ _N_ },
+ showList = { _A_ 1 _U_ 12 _N_ _N_ _F_ _IF_ARGS_ 0 1 X 3 \ (u0 :: [[Complex Double]]) -> _APP_ _TYAPP_ _ORIG_ PreludeCore _showList { [Complex Double] } [ _CONSTM_ Text showList (Complex Double), u0 ] _N_ } #-}
+instance Text [Double]
+ {-# GHC_PRAGMA _M_ PreludeBuiltin {-dfun-} _A_ 0 _N_ _N_ _N_ _F_ _IF_ARGS_ 0 0 X 5 _!_ _TUP_4 [(Int -> [Char] -> [([Double], [Char])]), (Int -> [Double] -> [Char] -> [Char]), ([Char] -> [([[Double]], [Char])]), ([[Double]] -> [Char] -> [Char])] [_CONSTM_ Text readsPrec ([Double]), _CONSTM_ Text showsPrec ([Double]), _CONSTM_ Text readList ([Double]), _CONSTM_ Text showList ([Double])] _N_
+ readsPrec = { _A_ 1 _U_ 02 _N_ _S_ "A" {_A_ 0 _U_ 2 _N_ _N_ _F_ _IF_ARGS_ 0 0 X 1 _CONSTM_ Text readList (Double) _N_} _F_ _IF_ARGS_ 0 1 X 1 \ (u0 :: Int) -> _CONSTM_ Text readList (Double) _N_ },
+ showsPrec = { _A_ 2 _U_ 022 _N_ _S_ "AL" {_A_ 1 _U_ 22 _N_ _N_ _F_ _IF_ARGS_ 0 0 X 1 _CONSTM_ Text showList (Double) _N_} _F_ _IF_ARGS_ 0 2 XX 2 \ (u0 :: Int) (u1 :: [Double]) -> _APP_ _CONSTM_ Text showList (Double) [ u1 ] _N_ },
+ readList = { _A_ 0 _U_ 2 _N_ _N_ _N_ _N_ },
+ showList = { _A_ 1 _U_ 12 _N_ _N_ _F_ _IF_ARGS_ 0 1 X 3 \ (u0 :: [[Double]]) -> _APP_ _TYAPP_ _ORIG_ PreludeCore _showList { [Double] } [ _CONSTM_ Text showList (Double), u0 ] _N_ } #-}
instance Text [Int]
{-# GHC_PRAGMA _M_ PreludeBuiltin {-dfun-} _A_ 0 _N_ _N_ _N_ _F_ _IF_ARGS_ 0 0 X 5 _!_ _TUP_4 [(Int -> [Char] -> [([Int], [Char])]), (Int -> [Int] -> [Char] -> [Char]), ([Char] -> [([[Int]], [Char])]), ([[Int]] -> [Char] -> [Char])] [_CONSTM_ Text readsPrec ([Int]), _CONSTM_ Text showsPrec ([Int]), _CONSTM_ Text readList ([Int]), _CONSTM_ Text showList ([Int])] _N_
- readsPrec = _A_ 1 _U_ 02 _N_ _S_ "A" {_A_ 0 _U_ 2 _N_ _N_ _F_ _IF_ARGS_ 0 0 X 1 _CONSTM_ Text readList (Int) _N_} _F_ _IF_ARGS_ 0 1 X 1 \ (u0 :: Int) -> _CONSTM_ Text readList (Int) _N_,
- showsPrec = _A_ 1 _U_ 022 _N_ _S_ "A" {_A_ 0 _U_ 22 _N_ _N_ _F_ _IF_ARGS_ 0 0 X 1 _CONSTM_ Text showList (Int) _N_} _F_ _IF_ARGS_ 0 1 X 1 \ (u0 :: Int) -> _CONSTM_ Text showList (Int) _N_,
- readList = _A_ 0 _U_ 2 _N_ _N_ _N_ _N_,
- showList = _A_ 0 _U_ 12 _N_ _N_ _N_ _N_ #-}
+ readsPrec = { _A_ 1 _U_ 02 _N_ _S_ "A" {_A_ 0 _U_ 2 _N_ _N_ _F_ _IF_ARGS_ 0 0 X 1 _CONSTM_ Text readList (Int) _N_} _F_ _IF_ARGS_ 0 1 X 1 \ (u0 :: Int) -> _CONSTM_ Text readList (Int) _N_ },
+ showsPrec = { _A_ 2 _U_ 022 _N_ _S_ "AL" {_A_ 1 _U_ 22 _N_ _N_ _F_ _IF_ARGS_ 0 0 X 1 _CONSTM_ Text showList (Int) _N_} _F_ _IF_ARGS_ 0 2 XX 2 \ (u0 :: Int) (u1 :: [Int]) -> _APP_ _CONSTM_ Text showList (Int) [ u1 ] _N_ },
+ readList = { _A_ 0 _U_ 2 _N_ _N_ _N_ _N_ },
+ showList = { _A_ 1 _U_ 12 _N_ _N_ _F_ _IF_ARGS_ 0 1 X 3 \ (u0 :: [[Int]]) -> _APP_ _TYAPP_ _ORIG_ PreludeCore _showList { [Int] } [ _CONSTM_ Text showList (Int), u0 ] _N_ } #-}
+instance Text [Integer]
+ {-# GHC_PRAGMA _M_ PreludeBuiltin {-dfun-} _A_ 0 _N_ _N_ _N_ _F_ _IF_ARGS_ 0 0 X 5 _!_ _TUP_4 [(Int -> [Char] -> [([Integer], [Char])]), (Int -> [Integer] -> [Char] -> [Char]), ([Char] -> [([[Integer]], [Char])]), ([[Integer]] -> [Char] -> [Char])] [_CONSTM_ Text readsPrec ([Integer]), _CONSTM_ Text showsPrec ([Integer]), _CONSTM_ Text readList ([Integer]), _CONSTM_ Text showList ([Integer])] _N_
+ readsPrec = { _A_ 1 _U_ 02 _N_ _S_ "A" {_A_ 0 _U_ 2 _N_ _N_ _F_ _IF_ARGS_ 0 0 X 1 _CONSTM_ Text readList (Integer) _N_} _F_ _IF_ARGS_ 0 1 X 1 \ (u0 :: Int) -> _CONSTM_ Text readList (Integer) _N_ },
+ showsPrec = { _A_ 2 _U_ 022 _N_ _S_ "AL" {_A_ 1 _U_ 22 _N_ _N_ _F_ _IF_ARGS_ 0 0 X 1 _CONSTM_ Text showList (Integer) _N_} _F_ _IF_ARGS_ 0 2 XX 2 \ (u0 :: Int) (u1 :: [Integer]) -> _APP_ _CONSTM_ Text showList (Integer) [ u1 ] _N_ },
+ readList = { _A_ 0 _U_ 2 _N_ _N_ _N_ _N_ },
+ showList = { _A_ 1 _U_ 12 _N_ _N_ _F_ _IF_ARGS_ 0 1 X 3 \ (u0 :: [[Integer]]) -> _APP_ _TYAPP_ _ORIG_ PreludeCore _showList { [Integer] } [ _CONSTM_ Text showList (Integer), u0 ] _N_ } #-}
+instance Text [[Char]]
+ {-# GHC_PRAGMA _M_ PreludeBuiltin {-dfun-} _A_ 0 _N_ _N_ _N_ _F_ _IF_ARGS_ 0 0 X 5 _!_ _TUP_4 [(Int -> [Char] -> [([[Char]], [Char])]), (Int -> [[Char]] -> [Char] -> [Char]), ([Char] -> [([[[Char]]], [Char])]), ([[[Char]]] -> [Char] -> [Char])] [_CONSTM_ Text readsPrec ([[Char]]), _CONSTM_ Text showsPrec ([[Char]]), _CONSTM_ Text readList ([[Char]]), _CONSTM_ Text showList ([[Char]])] _N_
+ readsPrec = { _A_ 1 _U_ 02 _N_ _S_ "A" {_A_ 0 _U_ 2 _N_ _N_ _F_ _IF_ARGS_ 0 0 X 1 _CONSTM_ Text readList ([Char]) _N_} _F_ _IF_ARGS_ 0 1 X 1 \ (u0 :: Int) -> _CONSTM_ Text readList ([Char]) _N_ },
+ showsPrec = { _A_ 2 _U_ 012 _N_ _S_ "AS" {_A_ 1 _U_ 12 _N_ _N_ _F_ _IF_ARGS_ 0 1 X 3 \ (u0 :: [[Char]]) -> _APP_ _TYAPP_ _ORIG_ PreludeCore _showList { [Char] } [ _CONSTM_ Text showList (Char), u0 ] _N_} _F_ _IF_ARGS_ 0 2 XX 2 \ (u0 :: Int) (u1 :: [[Char]]) -> _APP_ _CONSTM_ Text showList ([Char]) [ u1 ] _N_ },
+ readList = { _A_ 0 _U_ 2 _N_ _N_ _N_ _N_ },
+ showList = { _A_ 1 _U_ 12 _N_ _N_ _N_ _N_ } #-}
+instance Text [[Int]]
+ {-# GHC_PRAGMA _M_ PreludeBuiltin {-dfun-} _A_ 0 _N_ _N_ _N_ _F_ _IF_ARGS_ 0 0 X 5 _!_ _TUP_4 [(Int -> [Char] -> [([[Int]], [Char])]), (Int -> [[Int]] -> [Char] -> [Char]), ([Char] -> [([[[Int]]], [Char])]), ([[[Int]]] -> [Char] -> [Char])] [_CONSTM_ Text readsPrec ([[Int]]), _CONSTM_ Text showsPrec ([[Int]]), _CONSTM_ Text readList ([[Int]]), _CONSTM_ Text showList ([[Int]])] _N_
+ readsPrec = { _A_ 1 _U_ 02 _N_ _S_ "A" {_A_ 0 _U_ 2 _N_ _N_ _F_ _IF_ARGS_ 0 0 X 1 _CONSTM_ Text readList ([Int]) _N_} _F_ _IF_ARGS_ 0 1 X 1 \ (u0 :: Int) -> _CONSTM_ Text readList ([Int]) _N_ },
+ showsPrec = { _A_ 2 _U_ 012 _N_ _S_ "AS" {_A_ 1 _U_ 12 _N_ _N_ _F_ _IF_ARGS_ 0 1 X 3 \ (u0 :: [[Int]]) -> _APP_ _TYAPP_ _ORIG_ PreludeCore _showList { [Int] } [ _CONSTM_ Text showList (Int), u0 ] _N_} _F_ _IF_ARGS_ 0 2 XX 2 \ (u0 :: Int) (u1 :: [[Int]]) -> _APP_ _CONSTM_ Text showList ([Int]) [ u1 ] _N_ },
+ readList = { _A_ 0 _U_ 2 _N_ _N_ _N_ _N_ },
+ showList = { _A_ 1 _U_ 12 _N_ _N_ _N_ _N_ } #-}
instance _CCallable [Char]
{-# GHC_PRAGMA _M_ PreludeBuiltin {-dfun-} _A_ 0 _N_ _N_ _N_ _F_ _IF_ARGS_ 0 0 X 1 _!_ _TUP_0 [] [] _N_ #-}
instance _CReturnable [Char]
module PreludeBuiltin where
-import Prel ( (&&) )
+import Prel ( (&&), atan2 )
import Cls
import Core
+import IBool
import IChar
+import IComplex
+import IDouble
+import IFloat
import IInt
+import IInteger
+import ITup2
import List ( (++) )
import PS ( _PackedString, _unpackPS )
import Text
+import TyArray
+import TyComplex
instance (Eq a) => Eq [a] where
[] == [] = True
_EQ -> _tagCmp xs ys
instance (Text a) => Text [a] where
- readsPrec p = readList
- showsPrec p = showList
+ readsPrec p = readList
+ showsPrec p xs = showList xs
+ readList = _readList (readsPrec 0)
+ showList = _showList (showsPrec 0)
{-# SPECIALIZE instance Eq [Char] #-}
{-# SPECIALIZE instance Ord [Char] #-}
{-# SPECIALIZE instance Text [Char] #-}
+{-# SPECIALIZE instance Eq [Int] #-}
+{-# SPECIALIZE instance Ord [Int] #-}
+{-# SPECIALIZE instance Text [Int] #-}
+
+{-# SPECIALIZE instance Eq [Integer] #-}
+{-# SPECIALIZE instance Ord [Integer] #-}
+{-# SPECIALIZE instance Text [Integer] #-}
+
+--NO:{-# SPECIALIZE instance Eq [Float] #-}
+--NO:{-# SPECIALIZE instance Ord [Float] #-}
+--NO:{-# SPECIALIZE instance Text [Float] #-}
+
+{-# SPECIALIZE instance Eq [Double] #-}
+{-# SPECIALIZE instance Ord [Double] #-}
+{-# SPECIALIZE instance Text [Double] #-}
+
+{-# SPECIALIZE instance Eq [Bool] #-}
+{-# SPECIALIZE instance Ord [Bool] #-}
+{-# SPECIALIZE instance Text [Bool] #-}
+
+{-# SPECIALIZE instance Eq [[Char]] #-}
+{-# SPECIALIZE instance Ord [[Char]] #-}
+{-# SPECIALIZE instance Text [[Char]] #-}
+
+{-# SPECIALIZE instance Eq [[Int]] #-}
+{-# SPECIALIZE instance Ord [[Int]] #-}
+{-# SPECIALIZE instance Text [[Int]] #-}
+
+{-# SPECIALIZE instance Eq [Complex Double] #-}
+{-# SPECIALIZE instance Text [Complex Double] #-}
+
+{-# SPECIALIZE instance Eq [(Int,Int)] #-}
+
#if defined(__OVERLAPPING_INSTANCES__)
instance _CCallable [Char]
instance _CReturnable [Char]
#endif
-{-# SPECIALIZE instance Eq [Int] #-}
-{-# SPECIALIZE instance Ord [Int] #-}
-{-# SPECIALIZE instance Text [Int] #-}
-
-
#if defined(__UNBOXED_INSTANCES__)
{-# GENERATE_SPECS instance a :: Eq [a] #-}
{-# GENERATE_SPECS instance a :: Ord [a] #-}
{-# GENERATE_SPECS instance a :: Text [a] #-}
+#if defined(__OVERLAPPING_INSTANCES__)
instance _CCallable [Char#]
instance _CReturnable [Char#]
+#endif
#endif
+
+
+
+
-{-# GHC_PRAGMA INTERFACE VERSION 5 #-}
+{-# GHC_PRAGMA INTERFACE VERSION 6 #-}
interface PreludeBuiltin where
-import PreludeCore(Eq(..), Ord(..), Text(..), _CCallable(..), _CReturnable(..))
+import PreludeComplex(Complex)
+import PreludeCore(Bool(..), Eq(..), Ord(..), Text(..), _CCallable(..), _CReturnable(..))
+instance Eq [(Int, Int)]
+ {-# GHC_PRAGMA _M_ PreludeBuiltin {-dfun-} _A_ 0 _N_ _N_ _N_ _F_ _IF_ARGS_ 0 0 X 3 _!_ _TUP_2 [([(Int, Int)] -> [(Int, Int)] -> Bool), ([(Int, Int)] -> [(Int, Int)] -> Bool)] [_CONSTM_ Eq (==) ([(Int, Int)]), _CONSTM_ Eq (/=) ([(Int, Int)])] _N_
+ (==) = { _A_ 2 _U_ 11 _N_ _S_ "SS" _N_ _N_ },
+ (/=) = { _A_ 2 _U_ 11 _N_ _S_ "SS" _N_ _N_ } #-}
instance Eq a => Eq [a]
{-# GHC_PRAGMA _M_ PreludeBuiltin {-dfun-} _A_ 1 _U_ 1 _N_ _N_ _N_ _N_ #-}
+instance Eq [Bool]
+ {-# GHC_PRAGMA _M_ PreludeBuiltin {-dfun-} _A_ 0 _N_ _N_ _N_ _F_ _IF_ARGS_ 0 0 X 3 _!_ _TUP_2 [([Bool] -> [Bool] -> Bool), ([Bool] -> [Bool] -> Bool)] [_CONSTM_ Eq (==) ([Bool]), _CONSTM_ Eq (/=) ([Bool])] _N_
+ (==) = { _A_ 2 _U_ 11 _N_ _S_ "SS" _N_ _N_ },
+ (/=) = { _A_ 2 _U_ 11 _N_ _S_ "SS" _N_ _N_ } #-}
instance Eq [Char]
{-# GHC_PRAGMA _M_ PreludeBuiltin {-dfun-} _A_ 0 _N_ _N_ _N_ _F_ _IF_ARGS_ 0 0 X 3 _!_ _TUP_2 [([Char] -> [Char] -> Bool), ([Char] -> [Char] -> Bool)] [_CONSTM_ Eq (==) ([Char]), _CONSTM_ Eq (/=) ([Char])] _N_
- (==) = _A_ 2 _U_ 11 _N_ _S_ "SS" _N_ _N_,
- (/=) = _A_ 2 _U_ 11 _N_ _S_ "SS" _N_ _N_ #-}
+ (==) = { _A_ 2 _U_ 11 _N_ _S_ "SS" _N_ _N_ },
+ (/=) = { _A_ 2 _U_ 11 _N_ _S_ "SS" _N_ _N_ } #-}
+instance Eq [Complex Double]
+ {-# GHC_PRAGMA _M_ PreludeBuiltin {-dfun-} _A_ 0 _N_ _N_ _N_ _F_ _IF_ARGS_ 0 0 X 3 _!_ _TUP_2 [([Complex Double] -> [Complex Double] -> Bool), ([Complex Double] -> [Complex Double] -> Bool)] [_CONSTM_ Eq (==) ([Complex Double]), _CONSTM_ Eq (/=) ([Complex Double])] _N_
+ (==) = { _A_ 2 _U_ 11 _N_ _S_ "SS" _N_ _N_ },
+ (/=) = { _A_ 2 _U_ 11 _N_ _S_ "SS" _N_ _N_ } #-}
+instance Eq [Double]
+ {-# GHC_PRAGMA _M_ PreludeBuiltin {-dfun-} _A_ 0 _N_ _N_ _N_ _F_ _IF_ARGS_ 0 0 X 3 _!_ _TUP_2 [([Double] -> [Double] -> Bool), ([Double] -> [Double] -> Bool)] [_CONSTM_ Eq (==) ([Double]), _CONSTM_ Eq (/=) ([Double])] _N_
+ (==) = { _A_ 2 _U_ 11 _N_ _S_ "SS" _N_ _N_ },
+ (/=) = { _A_ 2 _U_ 11 _N_ _S_ "SS" _N_ _N_ } #-}
instance Eq [Int]
{-# GHC_PRAGMA _M_ PreludeBuiltin {-dfun-} _A_ 0 _N_ _N_ _N_ _F_ _IF_ARGS_ 0 0 X 3 _!_ _TUP_2 [([Int] -> [Int] -> Bool), ([Int] -> [Int] -> Bool)] [_CONSTM_ Eq (==) ([Int]), _CONSTM_ Eq (/=) ([Int])] _N_
- (==) = _A_ 2 _U_ 11 _N_ _S_ "SS" _N_ _N_,
- (/=) = _A_ 2 _U_ 11 _N_ _S_ "SS" _N_ _N_ #-}
+ (==) = { _A_ 2 _U_ 11 _N_ _S_ "SS" _N_ _N_ },
+ (/=) = { _A_ 2 _U_ 11 _N_ _S_ "SS" _N_ _N_ } #-}
+instance Eq [Integer]
+ {-# GHC_PRAGMA _M_ PreludeBuiltin {-dfun-} _A_ 0 _N_ _N_ _N_ _F_ _IF_ARGS_ 0 0 X 3 _!_ _TUP_2 [([Integer] -> [Integer] -> Bool), ([Integer] -> [Integer] -> Bool)] [_CONSTM_ Eq (==) ([Integer]), _CONSTM_ Eq (/=) ([Integer])] _N_
+ (==) = { _A_ 2 _U_ 11 _N_ _S_ "SS" _N_ _N_ },
+ (/=) = { _A_ 2 _U_ 11 _N_ _S_ "SS" _N_ _N_ } #-}
+instance Eq [[Char]]
+ {-# GHC_PRAGMA _M_ PreludeBuiltin {-dfun-} _A_ 0 _N_ _N_ _N_ _F_ _IF_ARGS_ 0 0 X 3 _!_ _TUP_2 [([[Char]] -> [[Char]] -> Bool), ([[Char]] -> [[Char]] -> Bool)] [_CONSTM_ Eq (==) ([[Char]]), _CONSTM_ Eq (/=) ([[Char]])] _N_
+ (==) = { _A_ 2 _U_ 11 _N_ _S_ "SS" _N_ _N_ },
+ (/=) = { _A_ 2 _U_ 11 _N_ _S_ "SS" _N_ _N_ } #-}
+instance Eq [[Int]]
+ {-# GHC_PRAGMA _M_ PreludeBuiltin {-dfun-} _A_ 0 _N_ _N_ _N_ _F_ _IF_ARGS_ 0 0 X 3 _!_ _TUP_2 [([[Int]] -> [[Int]] -> Bool), ([[Int]] -> [[Int]] -> Bool)] [_CONSTM_ Eq (==) ([[Int]]), _CONSTM_ Eq (/=) ([[Int]])] _N_
+ (==) = { _A_ 2 _U_ 11 _N_ _S_ "SS" _N_ _N_ },
+ (/=) = { _A_ 2 _U_ 11 _N_ _S_ "SS" _N_ _N_ } #-}
instance Ord a => Ord [a]
{-# GHC_PRAGMA _M_ PreludeBuiltin {-dfun-} _A_ 2 _U_ 12 _N_ _N_ _N_ _N_ #-}
+instance Ord [Bool]
+ {-# GHC_PRAGMA _M_ PreludeBuiltin {-dfun-} _A_ 0 _N_ _N_ _N_ _F_ _IF_ARGS_ 0 0 X 9 _!_ _TUP_8 [{{Eq [Bool]}}, ([Bool] -> [Bool] -> Bool), ([Bool] -> [Bool] -> Bool), ([Bool] -> [Bool] -> Bool), ([Bool] -> [Bool] -> Bool), ([Bool] -> [Bool] -> [Bool]), ([Bool] -> [Bool] -> [Bool]), ([Bool] -> [Bool] -> _CMP_TAG)] [_DFUN_ Eq ([Bool]), _CONSTM_ Ord (<) ([Bool]), _CONSTM_ Ord (<=) ([Bool]), _CONSTM_ Ord (>=) ([Bool]), _CONSTM_ Ord (>) ([Bool]), _CONSTM_ Ord max ([Bool]), _CONSTM_ Ord min ([Bool]), _CONSTM_ Ord _tagCmp ([Bool])] _N_
+ (<) = { _A_ 2 _U_ 11 _N_ _S_ "SS" _N_ _N_ },
+ (<=) = { _A_ 2 _U_ 11 _N_ _S_ "SS" _N_ _N_ },
+ (>=) = { _A_ 2 _U_ 11 _N_ _S_ "SS" _N_ _N_ },
+ (>) = { _A_ 2 _U_ 11 _N_ _S_ "SS" _N_ _N_ },
+ max = { _A_ 2 _U_ 22 _N_ _S_ "SS" _N_ _N_ },
+ min = { _A_ 2 _U_ 22 _N_ _S_ "SS" _N_ _N_ },
+ _tagCmp = { _A_ 2 _U_ 11 _N_ _S_ "SS" _N_ _N_ } #-}
instance Ord [Char]
{-# GHC_PRAGMA _M_ PreludeBuiltin {-dfun-} _A_ 0 _N_ _N_ _N_ _F_ _IF_ARGS_ 0 0 X 9 _!_ _TUP_8 [{{Eq [Char]}}, ([Char] -> [Char] -> Bool), ([Char] -> [Char] -> Bool), ([Char] -> [Char] -> Bool), ([Char] -> [Char] -> Bool), ([Char] -> [Char] -> [Char]), ([Char] -> [Char] -> [Char]), ([Char] -> [Char] -> _CMP_TAG)] [_DFUN_ Eq ([Char]), _CONSTM_ Ord (<) ([Char]), _CONSTM_ Ord (<=) ([Char]), _CONSTM_ Ord (>=) ([Char]), _CONSTM_ Ord (>) ([Char]), _CONSTM_ Ord max ([Char]), _CONSTM_ Ord min ([Char]), _CONSTM_ Ord _tagCmp ([Char])] _N_
- (<) = _A_ 2 _U_ 11 _N_ _S_ "SS" _N_ _N_,
- (<=) = _A_ 2 _U_ 11 _N_ _S_ "SS" _N_ _N_,
- (>=) = _A_ 2 _U_ 11 _N_ _S_ "SS" _N_ _N_,
- (>) = _A_ 2 _U_ 11 _N_ _S_ "SS" _N_ _N_,
- max = _A_ 2 _U_ 22 _N_ _S_ "SS" _N_ _N_,
- min = _A_ 2 _U_ 22 _N_ _S_ "SS" _N_ _N_,
- _tagCmp = _A_ 2 _U_ 11 _N_ _S_ "SS" _N_ _N_ #-}
+ (<) = { _A_ 2 _U_ 11 _N_ _S_ "SS" _N_ _N_ },
+ (<=) = { _A_ 2 _U_ 11 _N_ _S_ "SS" _N_ _N_ },
+ (>=) = { _A_ 2 _U_ 11 _N_ _S_ "SS" _N_ _N_ },
+ (>) = { _A_ 2 _U_ 11 _N_ _S_ "SS" _N_ _N_ },
+ max = { _A_ 2 _U_ 22 _N_ _S_ "SS" _N_ _N_ },
+ min = { _A_ 2 _U_ 22 _N_ _S_ "SS" _N_ _N_ },
+ _tagCmp = { _A_ 2 _U_ 11 _N_ _S_ "SS" _N_ _N_ } #-}
+instance Ord [Double]
+ {-# GHC_PRAGMA _M_ PreludeBuiltin {-dfun-} _A_ 0 _N_ _N_ _N_ _F_ _IF_ARGS_ 0 0 X 9 _!_ _TUP_8 [{{Eq [Double]}}, ([Double] -> [Double] -> Bool), ([Double] -> [Double] -> Bool), ([Double] -> [Double] -> Bool), ([Double] -> [Double] -> Bool), ([Double] -> [Double] -> [Double]), ([Double] -> [Double] -> [Double]), ([Double] -> [Double] -> _CMP_TAG)] [_DFUN_ Eq ([Double]), _CONSTM_ Ord (<) ([Double]), _CONSTM_ Ord (<=) ([Double]), _CONSTM_ Ord (>=) ([Double]), _CONSTM_ Ord (>) ([Double]), _CONSTM_ Ord max ([Double]), _CONSTM_ Ord min ([Double]), _CONSTM_ Ord _tagCmp ([Double])] _N_
+ (<) = { _A_ 2 _U_ 11 _N_ _S_ "SS" _N_ _N_ },
+ (<=) = { _A_ 2 _U_ 11 _N_ _S_ "SS" _N_ _N_ },
+ (>=) = { _A_ 2 _U_ 11 _N_ _S_ "SS" _N_ _N_ },
+ (>) = { _A_ 2 _U_ 11 _N_ _S_ "SS" _N_ _N_ },
+ max = { _A_ 2 _U_ 22 _N_ _S_ "SS" _N_ _N_ },
+ min = { _A_ 2 _U_ 22 _N_ _S_ "SS" _N_ _N_ },
+ _tagCmp = { _A_ 2 _U_ 11 _N_ _S_ "SS" _N_ _N_ } #-}
instance Ord [Int]
{-# GHC_PRAGMA _M_ PreludeBuiltin {-dfun-} _A_ 0 _N_ _N_ _N_ _F_ _IF_ARGS_ 0 0 X 9 _!_ _TUP_8 [{{Eq [Int]}}, ([Int] -> [Int] -> Bool), ([Int] -> [Int] -> Bool), ([Int] -> [Int] -> Bool), ([Int] -> [Int] -> Bool), ([Int] -> [Int] -> [Int]), ([Int] -> [Int] -> [Int]), ([Int] -> [Int] -> _CMP_TAG)] [_DFUN_ Eq ([Int]), _CONSTM_ Ord (<) ([Int]), _CONSTM_ Ord (<=) ([Int]), _CONSTM_ Ord (>=) ([Int]), _CONSTM_ Ord (>) ([Int]), _CONSTM_ Ord max ([Int]), _CONSTM_ Ord min ([Int]), _CONSTM_ Ord _tagCmp ([Int])] _N_
- (<) = _A_ 2 _U_ 11 _N_ _S_ "SS" _N_ _N_,
- (<=) = _A_ 2 _U_ 11 _N_ _S_ "SS" _N_ _N_,
- (>=) = _A_ 2 _U_ 11 _N_ _S_ "SS" _N_ _N_,
- (>) = _A_ 2 _U_ 11 _N_ _S_ "SS" _N_ _N_,
- max = _A_ 2 _U_ 22 _N_ _S_ "SS" _N_ _N_,
- min = _A_ 2 _U_ 22 _N_ _S_ "SS" _N_ _N_,
- _tagCmp = _A_ 2 _U_ 11 _N_ _S_ "SS" _N_ _N_ #-}
+ (<) = { _A_ 2 _U_ 11 _N_ _S_ "SS" _N_ _N_ },
+ (<=) = { _A_ 2 _U_ 11 _N_ _S_ "SS" _N_ _N_ },
+ (>=) = { _A_ 2 _U_ 11 _N_ _S_ "SS" _N_ _N_ },
+ (>) = { _A_ 2 _U_ 11 _N_ _S_ "SS" _N_ _N_ },
+ max = { _A_ 2 _U_ 22 _N_ _S_ "SS" _N_ _N_ },
+ min = { _A_ 2 _U_ 22 _N_ _S_ "SS" _N_ _N_ },
+ _tagCmp = { _A_ 2 _U_ 11 _N_ _S_ "SS" _N_ _N_ } #-}
+instance Ord [Integer]
+ {-# GHC_PRAGMA _M_ PreludeBuiltin {-dfun-} _A_ 0 _N_ _N_ _N_ _F_ _IF_ARGS_ 0 0 X 9 _!_ _TUP_8 [{{Eq [Integer]}}, ([Integer] -> [Integer] -> Bool), ([Integer] -> [Integer] -> Bool), ([Integer] -> [Integer] -> Bool), ([Integer] -> [Integer] -> Bool), ([Integer] -> [Integer] -> [Integer]), ([Integer] -> [Integer] -> [Integer]), ([Integer] -> [Integer] -> _CMP_TAG)] [_DFUN_ Eq ([Integer]), _CONSTM_ Ord (<) ([Integer]), _CONSTM_ Ord (<=) ([Integer]), _CONSTM_ Ord (>=) ([Integer]), _CONSTM_ Ord (>) ([Integer]), _CONSTM_ Ord max ([Integer]), _CONSTM_ Ord min ([Integer]), _CONSTM_ Ord _tagCmp ([Integer])] _N_
+ (<) = { _A_ 2 _U_ 11 _N_ _S_ "SS" _N_ _N_ },
+ (<=) = { _A_ 2 _U_ 11 _N_ _S_ "SS" _N_ _N_ },
+ (>=) = { _A_ 2 _U_ 11 _N_ _S_ "SS" _N_ _N_ },
+ (>) = { _A_ 2 _U_ 11 _N_ _S_ "SS" _N_ _N_ },
+ max = { _A_ 2 _U_ 22 _N_ _S_ "SS" _N_ _N_ },
+ min = { _A_ 2 _U_ 22 _N_ _S_ "SS" _N_ _N_ },
+ _tagCmp = { _A_ 2 _U_ 11 _N_ _S_ "SS" _N_ _N_ } #-}
+instance Ord [[Char]]
+ {-# GHC_PRAGMA _M_ PreludeBuiltin {-dfun-} _A_ 0 _N_ _N_ _N_ _F_ _IF_ARGS_ 0 0 X 9 _!_ _TUP_8 [{{Eq [[Char]]}}, ([[Char]] -> [[Char]] -> Bool), ([[Char]] -> [[Char]] -> Bool), ([[Char]] -> [[Char]] -> Bool), ([[Char]] -> [[Char]] -> Bool), ([[Char]] -> [[Char]] -> [[Char]]), ([[Char]] -> [[Char]] -> [[Char]]), ([[Char]] -> [[Char]] -> _CMP_TAG)] [_DFUN_ Eq ([[Char]]), _CONSTM_ Ord (<) ([[Char]]), _CONSTM_ Ord (<=) ([[Char]]), _CONSTM_ Ord (>=) ([[Char]]), _CONSTM_ Ord (>) ([[Char]]), _CONSTM_ Ord max ([[Char]]), _CONSTM_ Ord min ([[Char]]), _CONSTM_ Ord _tagCmp ([[Char]])] _N_
+ (<) = { _A_ 2 _U_ 11 _N_ _S_ "SS" _N_ _N_ },
+ (<=) = { _A_ 2 _U_ 11 _N_ _S_ "SS" _N_ _N_ },
+ (>=) = { _A_ 2 _U_ 11 _N_ _S_ "SS" _N_ _N_ },
+ (>) = { _A_ 2 _U_ 11 _N_ _S_ "SS" _N_ _N_ },
+ max = { _A_ 2 _U_ 22 _N_ _S_ "SS" _N_ _N_ },
+ min = { _A_ 2 _U_ 22 _N_ _S_ "SS" _N_ _N_ },
+ _tagCmp = { _A_ 2 _U_ 11 _N_ _S_ "SS" _N_ _N_ } #-}
+instance Ord [[Int]]
+ {-# GHC_PRAGMA _M_ PreludeBuiltin {-dfun-} _A_ 0 _N_ _N_ _N_ _F_ _IF_ARGS_ 0 0 X 9 _!_ _TUP_8 [{{Eq [[Int]]}}, ([[Int]] -> [[Int]] -> Bool), ([[Int]] -> [[Int]] -> Bool), ([[Int]] -> [[Int]] -> Bool), ([[Int]] -> [[Int]] -> Bool), ([[Int]] -> [[Int]] -> [[Int]]), ([[Int]] -> [[Int]] -> [[Int]]), ([[Int]] -> [[Int]] -> _CMP_TAG)] [_DFUN_ Eq ([[Int]]), _CONSTM_ Ord (<) ([[Int]]), _CONSTM_ Ord (<=) ([[Int]]), _CONSTM_ Ord (>=) ([[Int]]), _CONSTM_ Ord (>) ([[Int]]), _CONSTM_ Ord max ([[Int]]), _CONSTM_ Ord min ([[Int]]), _CONSTM_ Ord _tagCmp ([[Int]])] _N_
+ (<) = { _A_ 2 _U_ 11 _N_ _S_ "SS" _N_ _N_ },
+ (<=) = { _A_ 2 _U_ 11 _N_ _S_ "SS" _N_ _N_ },
+ (>=) = { _A_ 2 _U_ 11 _N_ _S_ "SS" _N_ _N_ },
+ (>) = { _A_ 2 _U_ 11 _N_ _S_ "SS" _N_ _N_ },
+ max = { _A_ 2 _U_ 22 _N_ _S_ "SS" _N_ _N_ },
+ min = { _A_ 2 _U_ 22 _N_ _S_ "SS" _N_ _N_ },
+ _tagCmp = { _A_ 2 _U_ 11 _N_ _S_ "SS" _N_ _N_ } #-}
instance Text a => Text [a]
{-# GHC_PRAGMA _M_ PreludeBuiltin {-dfun-} _A_ 1 _U_ 2 _N_ _N_ _N_ _N_ #-}
+instance Text [Bool]
+ {-# GHC_PRAGMA _M_ PreludeBuiltin {-dfun-} _A_ 0 _N_ _N_ _N_ _F_ _IF_ARGS_ 0 0 X 5 _!_ _TUP_4 [(Int -> [Char] -> [([Bool], [Char])]), (Int -> [Bool] -> [Char] -> [Char]), ([Char] -> [([[Bool]], [Char])]), ([[Bool]] -> [Char] -> [Char])] [_CONSTM_ Text readsPrec ([Bool]), _CONSTM_ Text showsPrec ([Bool]), _CONSTM_ Text readList ([Bool]), _CONSTM_ Text showList ([Bool])] _N_
+ readsPrec = { _A_ 1 _U_ 02 _N_ _S_ "A" {_A_ 0 _U_ 2 _N_ _N_ _F_ _IF_ARGS_ 0 0 X 1 _CONSTM_ Text readList (Bool) _N_} _F_ _IF_ARGS_ 0 1 X 1 \ (u0 :: Int) -> _CONSTM_ Text readList (Bool) _N_ },
+ showsPrec = { _A_ 2 _U_ 012 _N_ _S_ "AS" {_A_ 1 _U_ 12 _N_ _N_ _F_ _IF_ARGS_ 0 1 X 3 \ (u0 :: [Bool]) -> _APP_ _TYAPP_ _ORIG_ PreludeCore _showList { Bool } [ _WRKR_ _CONSTM_ Text showsPrec (Bool), u0 ] _N_} _F_ _IF_ARGS_ 0 2 XX 3 \ (u0 :: Int) (u1 :: [Bool]) -> _APP_ _TYAPP_ _ORIG_ PreludeCore _showList { Bool } [ _WRKR_ _CONSTM_ Text showsPrec (Bool), u1 ] _N_ },
+ readList = { _A_ 0 _U_ 2 _N_ _N_ _N_ _N_ },
+ showList = { _A_ 1 _U_ 12 _N_ _N_ _N_ _N_ } #-}
instance Text [Char]
{-# GHC_PRAGMA _M_ PreludeBuiltin {-dfun-} _A_ 0 _N_ _N_ _N_ _F_ _IF_ARGS_ 0 0 X 5 _!_ _TUP_4 [(Int -> [Char] -> [([Char], [Char])]), (Int -> [Char] -> [Char] -> [Char]), ([Char] -> [([[Char]], [Char])]), ([[Char]] -> [Char] -> [Char])] [_CONSTM_ Text readsPrec ([Char]), _CONSTM_ Text showsPrec ([Char]), _CONSTM_ Text readList ([Char]), _CONSTM_ Text showList ([Char])] _N_
- readsPrec = _A_ 1 _U_ 02 _N_ _S_ "A" {_A_ 0 _U_ 2 _N_ _N_ _F_ _IF_ARGS_ 0 0 X 1 _CONSTM_ Text readList (Char) _N_} _F_ _IF_ARGS_ 0 1 X 1 \ (u0 :: Int) -> _CONSTM_ Text readList (Char) _N_,
- showsPrec = _A_ 2 _U_ 022 _N_ _S_ "AL" {_A_ 1 _U_ 22 _N_ _N_ _F_ _IF_ARGS_ 0 0 X 1 _CONSTM_ Text showList (Char) _N_} _F_ _IF_ARGS_ 0 2 XX 2 \ (u0 :: Int) (u1 :: [Char]) -> _APP_ _CONSTM_ Text showList (Char) [ u1 ] _N_,
- readList = _A_ 0 _U_ 2 _N_ _N_ _N_ _N_,
- showList = _A_ 0 _U_ 12 _N_ _N_ _N_ _N_ #-}
+ readsPrec = { _A_ 1 _U_ 02 _N_ _S_ "A" {_A_ 0 _U_ 2 _N_ _N_ _F_ _IF_ARGS_ 0 0 X 1 _CONSTM_ Text readList (Char) _N_} _F_ _IF_ARGS_ 0 1 X 1 \ (u0 :: Int) -> _CONSTM_ Text readList (Char) _N_ },
+ showsPrec = { _A_ 2 _U_ 022 _N_ _S_ "AL" {_A_ 1 _U_ 22 _N_ _N_ _F_ _IF_ARGS_ 0 0 X 1 _CONSTM_ Text showList (Char) _N_} _F_ _IF_ARGS_ 0 2 XX 2 \ (u0 :: Int) (u1 :: [Char]) -> _APP_ _CONSTM_ Text showList (Char) [ u1 ] _N_ },
+ readList = { _A_ 0 _U_ 2 _N_ _N_ _N_ _N_ },
+ showList = { _A_ 1 _U_ 12 _N_ _N_ _F_ _IF_ARGS_ 0 1 X 3 \ (u0 :: [[Char]]) -> _APP_ _TYAPP_ _ORIG_ PreludeCore _showList { [Char] } [ _CONSTM_ Text showList (Char), u0 ] _N_ } #-}
+instance Text [Complex Double]
+ {-# GHC_PRAGMA _M_ PreludeBuiltin {-dfun-} _A_ 0 _N_ _N_ _N_ _F_ _IF_ARGS_ 0 0 X 5 _!_ _TUP_4 [(Int -> [Char] -> [([Complex Double], [Char])]), (Int -> [Complex Double] -> [Char] -> [Char]), ([Char] -> [([[Complex Double]], [Char])]), ([[Complex Double]] -> [Char] -> [Char])] [_CONSTM_ Text readsPrec ([Complex Double]), _CONSTM_ Text showsPrec ([Complex Double]), _CONSTM_ Text readList ([Complex Double]), _CONSTM_ Text showList ([Complex Double])] _N_
+ readsPrec = { _A_ 1 _U_ 02 _N_ _S_ "A" {_A_ 0 _U_ 2 _N_ _N_ _F_ _IF_ARGS_ 0 0 X 1 _CONSTM_ Text readList (Complex Double) _N_} _F_ _IF_ARGS_ 0 1 X 1 \ (u0 :: Int) -> _CONSTM_ Text readList (Complex Double) _N_ },
+ showsPrec = { _A_ 2 _U_ 022 _N_ _S_ "AL" {_A_ 1 _U_ 22 _N_ _N_ _F_ _IF_ARGS_ 0 0 X 1 _CONSTM_ Text showList (Complex Double) _N_} _F_ _IF_ARGS_ 0 2 XX 2 \ (u0 :: Int) (u1 :: [Complex Double]) -> _APP_ _CONSTM_ Text showList (Complex Double) [ u1 ] _N_ },
+ readList = { _A_ 0 _U_ 2 _N_ _N_ _N_ _N_ },
+ showList = { _A_ 1 _U_ 12 _N_ _N_ _F_ _IF_ARGS_ 0 1 X 3 \ (u0 :: [[Complex Double]]) -> _APP_ _TYAPP_ _ORIG_ PreludeCore _showList { [Complex Double] } [ _CONSTM_ Text showList (Complex Double), u0 ] _N_ } #-}
+instance Text [Double]
+ {-# GHC_PRAGMA _M_ PreludeBuiltin {-dfun-} _A_ 0 _N_ _N_ _N_ _F_ _IF_ARGS_ 0 0 X 5 _!_ _TUP_4 [(Int -> [Char] -> [([Double], [Char])]), (Int -> [Double] -> [Char] -> [Char]), ([Char] -> [([[Double]], [Char])]), ([[Double]] -> [Char] -> [Char])] [_CONSTM_ Text readsPrec ([Double]), _CONSTM_ Text showsPrec ([Double]), _CONSTM_ Text readList ([Double]), _CONSTM_ Text showList ([Double])] _N_
+ readsPrec = { _A_ 1 _U_ 02 _N_ _S_ "A" {_A_ 0 _U_ 2 _N_ _N_ _F_ _IF_ARGS_ 0 0 X 1 _CONSTM_ Text readList (Double) _N_} _F_ _IF_ARGS_ 0 1 X 1 \ (u0 :: Int) -> _CONSTM_ Text readList (Double) _N_ },
+ showsPrec = { _A_ 2 _U_ 022 _N_ _S_ "AL" {_A_ 1 _U_ 22 _N_ _N_ _F_ _IF_ARGS_ 0 0 X 1 _CONSTM_ Text showList (Double) _N_} _F_ _IF_ARGS_ 0 2 XX 2 \ (u0 :: Int) (u1 :: [Double]) -> _APP_ _CONSTM_ Text showList (Double) [ u1 ] _N_ },
+ readList = { _A_ 0 _U_ 2 _N_ _N_ _N_ _N_ },
+ showList = { _A_ 1 _U_ 12 _N_ _N_ _F_ _IF_ARGS_ 0 1 X 3 \ (u0 :: [[Double]]) -> _APP_ _TYAPP_ _ORIG_ PreludeCore _showList { [Double] } [ _CONSTM_ Text showList (Double), u0 ] _N_ } #-}
instance Text [Int]
{-# GHC_PRAGMA _M_ PreludeBuiltin {-dfun-} _A_ 0 _N_ _N_ _N_ _F_ _IF_ARGS_ 0 0 X 5 _!_ _TUP_4 [(Int -> [Char] -> [([Int], [Char])]), (Int -> [Int] -> [Char] -> [Char]), ([Char] -> [([[Int]], [Char])]), ([[Int]] -> [Char] -> [Char])] [_CONSTM_ Text readsPrec ([Int]), _CONSTM_ Text showsPrec ([Int]), _CONSTM_ Text readList ([Int]), _CONSTM_ Text showList ([Int])] _N_
- readsPrec = _A_ 1 _U_ 02 _N_ _S_ "A" {_A_ 0 _U_ 2 _N_ _N_ _F_ _IF_ARGS_ 0 0 X 1 _CONSTM_ Text readList (Int) _N_} _F_ _IF_ARGS_ 0 1 X 1 \ (u0 :: Int) -> _CONSTM_ Text readList (Int) _N_,
- showsPrec = _A_ 1 _U_ 022 _N_ _S_ "A" {_A_ 0 _U_ 22 _N_ _N_ _F_ _IF_ARGS_ 0 0 X 1 _CONSTM_ Text showList (Int) _N_} _F_ _IF_ARGS_ 0 1 X 1 \ (u0 :: Int) -> _CONSTM_ Text showList (Int) _N_,
- readList = _A_ 0 _U_ 2 _N_ _N_ _N_ _N_,
- showList = _A_ 0 _U_ 12 _N_ _N_ _N_ _N_ #-}
+ readsPrec = { _A_ 1 _U_ 02 _N_ _S_ "A" {_A_ 0 _U_ 2 _N_ _N_ _F_ _IF_ARGS_ 0 0 X 1 _CONSTM_ Text readList (Int) _N_} _F_ _IF_ARGS_ 0 1 X 1 \ (u0 :: Int) -> _CONSTM_ Text readList (Int) _N_ },
+ showsPrec = { _A_ 2 _U_ 022 _N_ _S_ "AL" {_A_ 1 _U_ 22 _N_ _N_ _F_ _IF_ARGS_ 0 0 X 1 _CONSTM_ Text showList (Int) _N_} _F_ _IF_ARGS_ 0 2 XX 2 \ (u0 :: Int) (u1 :: [Int]) -> _APP_ _CONSTM_ Text showList (Int) [ u1 ] _N_ },
+ readList = { _A_ 0 _U_ 2 _N_ _N_ _N_ _N_ },
+ showList = { _A_ 1 _U_ 12 _N_ _N_ _F_ _IF_ARGS_ 0 1 X 3 \ (u0 :: [[Int]]) -> _APP_ _TYAPP_ _ORIG_ PreludeCore _showList { [Int] } [ _CONSTM_ Text showList (Int), u0 ] _N_ } #-}
+instance Text [Integer]
+ {-# GHC_PRAGMA _M_ PreludeBuiltin {-dfun-} _A_ 0 _N_ _N_ _N_ _F_ _IF_ARGS_ 0 0 X 5 _!_ _TUP_4 [(Int -> [Char] -> [([Integer], [Char])]), (Int -> [Integer] -> [Char] -> [Char]), ([Char] -> [([[Integer]], [Char])]), ([[Integer]] -> [Char] -> [Char])] [_CONSTM_ Text readsPrec ([Integer]), _CONSTM_ Text showsPrec ([Integer]), _CONSTM_ Text readList ([Integer]), _CONSTM_ Text showList ([Integer])] _N_
+ readsPrec = { _A_ 1 _U_ 02 _N_ _S_ "A" {_A_ 0 _U_ 2 _N_ _N_ _F_ _IF_ARGS_ 0 0 X 1 _CONSTM_ Text readList (Integer) _N_} _F_ _IF_ARGS_ 0 1 X 1 \ (u0 :: Int) -> _CONSTM_ Text readList (Integer) _N_ },
+ showsPrec = { _A_ 2 _U_ 022 _N_ _S_ "AL" {_A_ 1 _U_ 22 _N_ _N_ _F_ _IF_ARGS_ 0 0 X 1 _CONSTM_ Text showList (Integer) _N_} _F_ _IF_ARGS_ 0 2 XX 2 \ (u0 :: Int) (u1 :: [Integer]) -> _APP_ _CONSTM_ Text showList (Integer) [ u1 ] _N_ },
+ readList = { _A_ 0 _U_ 2 _N_ _N_ _N_ _N_ },
+ showList = { _A_ 1 _U_ 12 _N_ _N_ _F_ _IF_ARGS_ 0 1 X 3 \ (u0 :: [[Integer]]) -> _APP_ _TYAPP_ _ORIG_ PreludeCore _showList { [Integer] } [ _CONSTM_ Text showList (Integer), u0 ] _N_ } #-}
+instance Text [[Char]]
+ {-# GHC_PRAGMA _M_ PreludeBuiltin {-dfun-} _A_ 0 _N_ _N_ _N_ _F_ _IF_ARGS_ 0 0 X 5 _!_ _TUP_4 [(Int -> [Char] -> [([[Char]], [Char])]), (Int -> [[Char]] -> [Char] -> [Char]), ([Char] -> [([[[Char]]], [Char])]), ([[[Char]]] -> [Char] -> [Char])] [_CONSTM_ Text readsPrec ([[Char]]), _CONSTM_ Text showsPrec ([[Char]]), _CONSTM_ Text readList ([[Char]]), _CONSTM_ Text showList ([[Char]])] _N_
+ readsPrec = { _A_ 1 _U_ 02 _N_ _S_ "A" {_A_ 0 _U_ 2 _N_ _N_ _F_ _IF_ARGS_ 0 0 X 1 _CONSTM_ Text readList ([Char]) _N_} _F_ _IF_ARGS_ 0 1 X 1 \ (u0 :: Int) -> _CONSTM_ Text readList ([Char]) _N_ },
+ showsPrec = { _A_ 2 _U_ 012 _N_ _S_ "AS" {_A_ 1 _U_ 12 _N_ _N_ _F_ _IF_ARGS_ 0 1 X 3 \ (u0 :: [[Char]]) -> _APP_ _TYAPP_ _ORIG_ PreludeCore _showList { [Char] } [ _CONSTM_ Text showList (Char), u0 ] _N_} _F_ _IF_ARGS_ 0 2 XX 2 \ (u0 :: Int) (u1 :: [[Char]]) -> _APP_ _CONSTM_ Text showList ([Char]) [ u1 ] _N_ },
+ readList = { _A_ 0 _U_ 2 _N_ _N_ _N_ _N_ },
+ showList = { _A_ 1 _U_ 12 _N_ _N_ _N_ _N_ } #-}
+instance Text [[Int]]
+ {-# GHC_PRAGMA _M_ PreludeBuiltin {-dfun-} _A_ 0 _N_ _N_ _N_ _F_ _IF_ARGS_ 0 0 X 5 _!_ _TUP_4 [(Int -> [Char] -> [([[Int]], [Char])]), (Int -> [[Int]] -> [Char] -> [Char]), ([Char] -> [([[[Int]]], [Char])]), ([[[Int]]] -> [Char] -> [Char])] [_CONSTM_ Text readsPrec ([[Int]]), _CONSTM_ Text showsPrec ([[Int]]), _CONSTM_ Text readList ([[Int]]), _CONSTM_ Text showList ([[Int]])] _N_
+ readsPrec = { _A_ 1 _U_ 02 _N_ _S_ "A" {_A_ 0 _U_ 2 _N_ _N_ _F_ _IF_ARGS_ 0 0 X 1 _CONSTM_ Text readList ([Int]) _N_} _F_ _IF_ARGS_ 0 1 X 1 \ (u0 :: Int) -> _CONSTM_ Text readList ([Int]) _N_ },
+ showsPrec = { _A_ 2 _U_ 012 _N_ _S_ "AS" {_A_ 1 _U_ 12 _N_ _N_ _F_ _IF_ARGS_ 0 1 X 3 \ (u0 :: [[Int]]) -> _APP_ _TYAPP_ _ORIG_ PreludeCore _showList { [Int] } [ _CONSTM_ Text showList (Int), u0 ] _N_} _F_ _IF_ARGS_ 0 2 XX 2 \ (u0 :: Int) (u1 :: [[Int]]) -> _APP_ _CONSTM_ Text showList ([Int]) [ u1 ] _N_ },
+ readList = { _A_ 0 _U_ 2 _N_ _N_ _N_ _N_ },
+ showList = { _A_ 1 _U_ 12 _N_ _N_ _N_ _N_ } #-}
instance _CCallable [Char]
{-# GHC_PRAGMA _M_ PreludeBuiltin {-dfun-} _A_ 0 _N_ _N_ _N_ _F_ _IF_ARGS_ 0 0 X 1 _!_ _TUP_0 [] [] _N_ #-}
instance _CReturnable [Char]
-{-# GHC_PRAGMA INTERFACE VERSION 5 #-}
+{-# GHC_PRAGMA INTERFACE VERSION 6 #-}
interface PreludeBuiltin where
-import PreludeCore(Eq(..), Ord(..), Text(..), _CCallable(..), _CReturnable(..))
+import PreludeComplex(Complex)
+import PreludeCore(Bool(..), Eq(..), Ord(..), Text(..), _CCallable(..), _CReturnable(..))
+instance Eq [(Int, Int)]
+ {-# GHC_PRAGMA _M_ PreludeBuiltin {-dfun-} _A_ 0 _N_ _N_ _N_ _F_ _IF_ARGS_ 0 0 X 3 _!_ _TUP_2 [([(Int, Int)] -> [(Int, Int)] -> Bool), ([(Int, Int)] -> [(Int, Int)] -> Bool)] [_CONSTM_ Eq (==) ([(Int, Int)]), _CONSTM_ Eq (/=) ([(Int, Int)])] _N_
+ (==) = { _A_ 2 _U_ 11 _N_ _S_ "SS" _N_ _N_ },
+ (/=) = { _A_ 2 _U_ 11 _N_ _S_ "SS" _N_ _N_ } #-}
instance Eq a => Eq [a]
{-# GHC_PRAGMA _M_ PreludeBuiltin {-dfun-} _A_ 1 _U_ 1 _N_ _N_ _N_ _N_ #-}
+instance Eq [Bool]
+ {-# GHC_PRAGMA _M_ PreludeBuiltin {-dfun-} _A_ 0 _N_ _N_ _N_ _F_ _IF_ARGS_ 0 0 X 3 _!_ _TUP_2 [([Bool] -> [Bool] -> Bool), ([Bool] -> [Bool] -> Bool)] [_CONSTM_ Eq (==) ([Bool]), _CONSTM_ Eq (/=) ([Bool])] _N_
+ (==) = { _A_ 2 _U_ 11 _N_ _S_ "SS" _N_ _N_ },
+ (/=) = { _A_ 2 _U_ 11 _N_ _S_ "SS" _N_ _N_ } #-}
instance Eq [Char]
{-# GHC_PRAGMA _M_ PreludeBuiltin {-dfun-} _A_ 0 _N_ _N_ _N_ _F_ _IF_ARGS_ 0 0 X 3 _!_ _TUP_2 [([Char] -> [Char] -> Bool), ([Char] -> [Char] -> Bool)] [_CONSTM_ Eq (==) ([Char]), _CONSTM_ Eq (/=) ([Char])] _N_
- (==) = _A_ 2 _U_ 11 _N_ _S_ "SS" _N_ _N_,
- (/=) = _A_ 2 _U_ 11 _N_ _S_ "SS" _N_ _N_ #-}
+ (==) = { _A_ 2 _U_ 11 _N_ _S_ "SS" _N_ _N_ },
+ (/=) = { _A_ 2 _U_ 11 _N_ _S_ "SS" _N_ _N_ } #-}
+instance Eq [Complex Double]
+ {-# GHC_PRAGMA _M_ PreludeBuiltin {-dfun-} _A_ 0 _N_ _N_ _N_ _F_ _IF_ARGS_ 0 0 X 3 _!_ _TUP_2 [([Complex Double] -> [Complex Double] -> Bool), ([Complex Double] -> [Complex Double] -> Bool)] [_CONSTM_ Eq (==) ([Complex Double]), _CONSTM_ Eq (/=) ([Complex Double])] _N_
+ (==) = { _A_ 2 _U_ 11 _N_ _S_ "SS" _N_ _N_ },
+ (/=) = { _A_ 2 _U_ 11 _N_ _S_ "SS" _N_ _N_ } #-}
+instance Eq [Double]
+ {-# GHC_PRAGMA _M_ PreludeBuiltin {-dfun-} _A_ 0 _N_ _N_ _N_ _F_ _IF_ARGS_ 0 0 X 3 _!_ _TUP_2 [([Double] -> [Double] -> Bool), ([Double] -> [Double] -> Bool)] [_CONSTM_ Eq (==) ([Double]), _CONSTM_ Eq (/=) ([Double])] _N_
+ (==) = { _A_ 2 _U_ 11 _N_ _S_ "SS" _N_ _N_ },
+ (/=) = { _A_ 2 _U_ 11 _N_ _S_ "SS" _N_ _N_ } #-}
instance Eq [Int]
{-# GHC_PRAGMA _M_ PreludeBuiltin {-dfun-} _A_ 0 _N_ _N_ _N_ _F_ _IF_ARGS_ 0 0 X 3 _!_ _TUP_2 [([Int] -> [Int] -> Bool), ([Int] -> [Int] -> Bool)] [_CONSTM_ Eq (==) ([Int]), _CONSTM_ Eq (/=) ([Int])] _N_
- (==) = _A_ 2 _U_ 11 _N_ _S_ "SS" _N_ _N_,
- (/=) = _A_ 2 _U_ 11 _N_ _S_ "SS" _N_ _N_ #-}
+ (==) = { _A_ 2 _U_ 11 _N_ _S_ "SS" _N_ _N_ },
+ (/=) = { _A_ 2 _U_ 11 _N_ _S_ "SS" _N_ _N_ } #-}
+instance Eq [Integer]
+ {-# GHC_PRAGMA _M_ PreludeBuiltin {-dfun-} _A_ 0 _N_ _N_ _N_ _F_ _IF_ARGS_ 0 0 X 3 _!_ _TUP_2 [([Integer] -> [Integer] -> Bool), ([Integer] -> [Integer] -> Bool)] [_CONSTM_ Eq (==) ([Integer]), _CONSTM_ Eq (/=) ([Integer])] _N_
+ (==) = { _A_ 2 _U_ 11 _N_ _S_ "SS" _N_ _N_ },
+ (/=) = { _A_ 2 _U_ 11 _N_ _S_ "SS" _N_ _N_ } #-}
+instance Eq [[Char]]
+ {-# GHC_PRAGMA _M_ PreludeBuiltin {-dfun-} _A_ 0 _N_ _N_ _N_ _F_ _IF_ARGS_ 0 0 X 3 _!_ _TUP_2 [([[Char]] -> [[Char]] -> Bool), ([[Char]] -> [[Char]] -> Bool)] [_CONSTM_ Eq (==) ([[Char]]), _CONSTM_ Eq (/=) ([[Char]])] _N_
+ (==) = { _A_ 2 _U_ 11 _N_ _S_ "SS" _N_ _N_ },
+ (/=) = { _A_ 2 _U_ 11 _N_ _S_ "SS" _N_ _N_ } #-}
+instance Eq [[Int]]
+ {-# GHC_PRAGMA _M_ PreludeBuiltin {-dfun-} _A_ 0 _N_ _N_ _N_ _F_ _IF_ARGS_ 0 0 X 3 _!_ _TUP_2 [([[Int]] -> [[Int]] -> Bool), ([[Int]] -> [[Int]] -> Bool)] [_CONSTM_ Eq (==) ([[Int]]), _CONSTM_ Eq (/=) ([[Int]])] _N_
+ (==) = { _A_ 2 _U_ 11 _N_ _S_ "SS" _N_ _N_ },
+ (/=) = { _A_ 2 _U_ 11 _N_ _S_ "SS" _N_ _N_ } #-}
instance Ord a => Ord [a]
{-# GHC_PRAGMA _M_ PreludeBuiltin {-dfun-} _A_ 2 _U_ 12 _N_ _N_ _N_ _N_ #-}
+instance Ord [Bool]
+ {-# GHC_PRAGMA _M_ PreludeBuiltin {-dfun-} _A_ 0 _N_ _N_ _N_ _F_ _IF_ARGS_ 0 0 X 9 _!_ _TUP_8 [{{Eq [Bool]}}, ([Bool] -> [Bool] -> Bool), ([Bool] -> [Bool] -> Bool), ([Bool] -> [Bool] -> Bool), ([Bool] -> [Bool] -> Bool), ([Bool] -> [Bool] -> [Bool]), ([Bool] -> [Bool] -> [Bool]), ([Bool] -> [Bool] -> _CMP_TAG)] [_DFUN_ Eq ([Bool]), _CONSTM_ Ord (<) ([Bool]), _CONSTM_ Ord (<=) ([Bool]), _CONSTM_ Ord (>=) ([Bool]), _CONSTM_ Ord (>) ([Bool]), _CONSTM_ Ord max ([Bool]), _CONSTM_ Ord min ([Bool]), _CONSTM_ Ord _tagCmp ([Bool])] _N_
+ (<) = { _A_ 2 _U_ 11 _N_ _S_ "SS" _N_ _N_ },
+ (<=) = { _A_ 2 _U_ 11 _N_ _S_ "SS" _N_ _N_ },
+ (>=) = { _A_ 2 _U_ 11 _N_ _S_ "SS" _N_ _N_ },
+ (>) = { _A_ 2 _U_ 11 _N_ _S_ "SS" _N_ _N_ },
+ max = { _A_ 2 _U_ 22 _N_ _S_ "SS" _N_ _N_ },
+ min = { _A_ 2 _U_ 22 _N_ _S_ "SS" _N_ _N_ },
+ _tagCmp = { _A_ 2 _U_ 11 _N_ _S_ "SS" _N_ _N_ } #-}
instance Ord [Char]
{-# GHC_PRAGMA _M_ PreludeBuiltin {-dfun-} _A_ 0 _N_ _N_ _N_ _F_ _IF_ARGS_ 0 0 X 9 _!_ _TUP_8 [{{Eq [Char]}}, ([Char] -> [Char] -> Bool), ([Char] -> [Char] -> Bool), ([Char] -> [Char] -> Bool), ([Char] -> [Char] -> Bool), ([Char] -> [Char] -> [Char]), ([Char] -> [Char] -> [Char]), ([Char] -> [Char] -> _CMP_TAG)] [_DFUN_ Eq ([Char]), _CONSTM_ Ord (<) ([Char]), _CONSTM_ Ord (<=) ([Char]), _CONSTM_ Ord (>=) ([Char]), _CONSTM_ Ord (>) ([Char]), _CONSTM_ Ord max ([Char]), _CONSTM_ Ord min ([Char]), _CONSTM_ Ord _tagCmp ([Char])] _N_
- (<) = _A_ 2 _U_ 11 _N_ _S_ "SS" _N_ _N_,
- (<=) = _A_ 2 _U_ 11 _N_ _S_ "SS" _N_ _N_,
- (>=) = _A_ 2 _U_ 11 _N_ _S_ "SS" _N_ _N_,
- (>) = _A_ 2 _U_ 11 _N_ _S_ "SS" _N_ _N_,
- max = _A_ 2 _U_ 22 _N_ _S_ "SS" _N_ _N_,
- min = _A_ 2 _U_ 22 _N_ _S_ "SS" _N_ _N_,
- _tagCmp = _A_ 2 _U_ 11 _N_ _S_ "SS" _N_ _N_ #-}
+ (<) = { _A_ 2 _U_ 11 _N_ _S_ "SS" _N_ _N_ },
+ (<=) = { _A_ 2 _U_ 11 _N_ _S_ "SS" _N_ _N_ },
+ (>=) = { _A_ 2 _U_ 11 _N_ _S_ "SS" _N_ _N_ },
+ (>) = { _A_ 2 _U_ 11 _N_ _S_ "SS" _N_ _N_ },
+ max = { _A_ 2 _U_ 22 _N_ _S_ "SS" _N_ _N_ },
+ min = { _A_ 2 _U_ 22 _N_ _S_ "SS" _N_ _N_ },
+ _tagCmp = { _A_ 2 _U_ 11 _N_ _S_ "SS" _N_ _N_ } #-}
+instance Ord [Double]
+ {-# GHC_PRAGMA _M_ PreludeBuiltin {-dfun-} _A_ 0 _N_ _N_ _N_ _F_ _IF_ARGS_ 0 0 X 9 _!_ _TUP_8 [{{Eq [Double]}}, ([Double] -> [Double] -> Bool), ([Double] -> [Double] -> Bool), ([Double] -> [Double] -> Bool), ([Double] -> [Double] -> Bool), ([Double] -> [Double] -> [Double]), ([Double] -> [Double] -> [Double]), ([Double] -> [Double] -> _CMP_TAG)] [_DFUN_ Eq ([Double]), _CONSTM_ Ord (<) ([Double]), _CONSTM_ Ord (<=) ([Double]), _CONSTM_ Ord (>=) ([Double]), _CONSTM_ Ord (>) ([Double]), _CONSTM_ Ord max ([Double]), _CONSTM_ Ord min ([Double]), _CONSTM_ Ord _tagCmp ([Double])] _N_
+ (<) = { _A_ 2 _U_ 11 _N_ _S_ "SS" _N_ _N_ },
+ (<=) = { _A_ 2 _U_ 11 _N_ _S_ "SS" _N_ _N_ },
+ (>=) = { _A_ 2 _U_ 11 _N_ _S_ "SS" _N_ _N_ },
+ (>) = { _A_ 2 _U_ 11 _N_ _S_ "SS" _N_ _N_ },
+ max = { _A_ 2 _U_ 22 _N_ _S_ "SS" _N_ _N_ },
+ min = { _A_ 2 _U_ 22 _N_ _S_ "SS" _N_ _N_ },
+ _tagCmp = { _A_ 2 _U_ 11 _N_ _S_ "SS" _N_ _N_ } #-}
instance Ord [Int]
{-# GHC_PRAGMA _M_ PreludeBuiltin {-dfun-} _A_ 0 _N_ _N_ _N_ _F_ _IF_ARGS_ 0 0 X 9 _!_ _TUP_8 [{{Eq [Int]}}, ([Int] -> [Int] -> Bool), ([Int] -> [Int] -> Bool), ([Int] -> [Int] -> Bool), ([Int] -> [Int] -> Bool), ([Int] -> [Int] -> [Int]), ([Int] -> [Int] -> [Int]), ([Int] -> [Int] -> _CMP_TAG)] [_DFUN_ Eq ([Int]), _CONSTM_ Ord (<) ([Int]), _CONSTM_ Ord (<=) ([Int]), _CONSTM_ Ord (>=) ([Int]), _CONSTM_ Ord (>) ([Int]), _CONSTM_ Ord max ([Int]), _CONSTM_ Ord min ([Int]), _CONSTM_ Ord _tagCmp ([Int])] _N_
- (<) = _A_ 2 _U_ 11 _N_ _S_ "SS" _N_ _N_,
- (<=) = _A_ 2 _U_ 11 _N_ _S_ "SS" _N_ _N_,
- (>=) = _A_ 2 _U_ 11 _N_ _S_ "SS" _N_ _N_,
- (>) = _A_ 2 _U_ 11 _N_ _S_ "SS" _N_ _N_,
- max = _A_ 2 _U_ 22 _N_ _S_ "SS" _N_ _N_,
- min = _A_ 2 _U_ 22 _N_ _S_ "SS" _N_ _N_,
- _tagCmp = _A_ 2 _U_ 11 _N_ _S_ "SS" _N_ _N_ #-}
+ (<) = { _A_ 2 _U_ 11 _N_ _S_ "SS" _N_ _N_ },
+ (<=) = { _A_ 2 _U_ 11 _N_ _S_ "SS" _N_ _N_ },
+ (>=) = { _A_ 2 _U_ 11 _N_ _S_ "SS" _N_ _N_ },
+ (>) = { _A_ 2 _U_ 11 _N_ _S_ "SS" _N_ _N_ },
+ max = { _A_ 2 _U_ 22 _N_ _S_ "SS" _N_ _N_ },
+ min = { _A_ 2 _U_ 22 _N_ _S_ "SS" _N_ _N_ },
+ _tagCmp = { _A_ 2 _U_ 11 _N_ _S_ "SS" _N_ _N_ } #-}
+instance Ord [Integer]
+ {-# GHC_PRAGMA _M_ PreludeBuiltin {-dfun-} _A_ 0 _N_ _N_ _N_ _F_ _IF_ARGS_ 0 0 X 9 _!_ _TUP_8 [{{Eq [Integer]}}, ([Integer] -> [Integer] -> Bool), ([Integer] -> [Integer] -> Bool), ([Integer] -> [Integer] -> Bool), ([Integer] -> [Integer] -> Bool), ([Integer] -> [Integer] -> [Integer]), ([Integer] -> [Integer] -> [Integer]), ([Integer] -> [Integer] -> _CMP_TAG)] [_DFUN_ Eq ([Integer]), _CONSTM_ Ord (<) ([Integer]), _CONSTM_ Ord (<=) ([Integer]), _CONSTM_ Ord (>=) ([Integer]), _CONSTM_ Ord (>) ([Integer]), _CONSTM_ Ord max ([Integer]), _CONSTM_ Ord min ([Integer]), _CONSTM_ Ord _tagCmp ([Integer])] _N_
+ (<) = { _A_ 2 _U_ 11 _N_ _S_ "SS" _N_ _N_ },
+ (<=) = { _A_ 2 _U_ 11 _N_ _S_ "SS" _N_ _N_ },
+ (>=) = { _A_ 2 _U_ 11 _N_ _S_ "SS" _N_ _N_ },
+ (>) = { _A_ 2 _U_ 11 _N_ _S_ "SS" _N_ _N_ },
+ max = { _A_ 2 _U_ 22 _N_ _S_ "SS" _N_ _N_ },
+ min = { _A_ 2 _U_ 22 _N_ _S_ "SS" _N_ _N_ },
+ _tagCmp = { _A_ 2 _U_ 11 _N_ _S_ "SS" _N_ _N_ } #-}
+instance Ord [[Char]]
+ {-# GHC_PRAGMA _M_ PreludeBuiltin {-dfun-} _A_ 0 _N_ _N_ _N_ _F_ _IF_ARGS_ 0 0 X 9 _!_ _TUP_8 [{{Eq [[Char]]}}, ([[Char]] -> [[Char]] -> Bool), ([[Char]] -> [[Char]] -> Bool), ([[Char]] -> [[Char]] -> Bool), ([[Char]] -> [[Char]] -> Bool), ([[Char]] -> [[Char]] -> [[Char]]), ([[Char]] -> [[Char]] -> [[Char]]), ([[Char]] -> [[Char]] -> _CMP_TAG)] [_DFUN_ Eq ([[Char]]), _CONSTM_ Ord (<) ([[Char]]), _CONSTM_ Ord (<=) ([[Char]]), _CONSTM_ Ord (>=) ([[Char]]), _CONSTM_ Ord (>) ([[Char]]), _CONSTM_ Ord max ([[Char]]), _CONSTM_ Ord min ([[Char]]), _CONSTM_ Ord _tagCmp ([[Char]])] _N_
+ (<) = { _A_ 2 _U_ 11 _N_ _S_ "SS" _N_ _N_ },
+ (<=) = { _A_ 2 _U_ 11 _N_ _S_ "SS" _N_ _N_ },
+ (>=) = { _A_ 2 _U_ 11 _N_ _S_ "SS" _N_ _N_ },
+ (>) = { _A_ 2 _U_ 11 _N_ _S_ "SS" _N_ _N_ },
+ max = { _A_ 2 _U_ 22 _N_ _S_ "SS" _N_ _N_ },
+ min = { _A_ 2 _U_ 22 _N_ _S_ "SS" _N_ _N_ },
+ _tagCmp = { _A_ 2 _U_ 11 _N_ _S_ "SS" _N_ _N_ } #-}
+instance Ord [[Int]]
+ {-# GHC_PRAGMA _M_ PreludeBuiltin {-dfun-} _A_ 0 _N_ _N_ _N_ _F_ _IF_ARGS_ 0 0 X 9 _!_ _TUP_8 [{{Eq [[Int]]}}, ([[Int]] -> [[Int]] -> Bool), ([[Int]] -> [[Int]] -> Bool), ([[Int]] -> [[Int]] -> Bool), ([[Int]] -> [[Int]] -> Bool), ([[Int]] -> [[Int]] -> [[Int]]), ([[Int]] -> [[Int]] -> [[Int]]), ([[Int]] -> [[Int]] -> _CMP_TAG)] [_DFUN_ Eq ([[Int]]), _CONSTM_ Ord (<) ([[Int]]), _CONSTM_ Ord (<=) ([[Int]]), _CONSTM_ Ord (>=) ([[Int]]), _CONSTM_ Ord (>) ([[Int]]), _CONSTM_ Ord max ([[Int]]), _CONSTM_ Ord min ([[Int]]), _CONSTM_ Ord _tagCmp ([[Int]])] _N_
+ (<) = { _A_ 2 _U_ 11 _N_ _S_ "SS" _N_ _N_ },
+ (<=) = { _A_ 2 _U_ 11 _N_ _S_ "SS" _N_ _N_ },
+ (>=) = { _A_ 2 _U_ 11 _N_ _S_ "SS" _N_ _N_ },
+ (>) = { _A_ 2 _U_ 11 _N_ _S_ "SS" _N_ _N_ },
+ max = { _A_ 2 _U_ 22 _N_ _S_ "SS" _N_ _N_ },
+ min = { _A_ 2 _U_ 22 _N_ _S_ "SS" _N_ _N_ },
+ _tagCmp = { _A_ 2 _U_ 11 _N_ _S_ "SS" _N_ _N_ } #-}
instance Text a => Text [a]
{-# GHC_PRAGMA _M_ PreludeBuiltin {-dfun-} _A_ 1 _U_ 2 _N_ _N_ _N_ _N_ #-}
+instance Text [Bool]
+ {-# GHC_PRAGMA _M_ PreludeBuiltin {-dfun-} _A_ 0 _N_ _N_ _N_ _F_ _IF_ARGS_ 0 0 X 5 _!_ _TUP_4 [(Int -> [Char] -> [([Bool], [Char])]), (Int -> [Bool] -> [Char] -> [Char]), ([Char] -> [([[Bool]], [Char])]), ([[Bool]] -> [Char] -> [Char])] [_CONSTM_ Text readsPrec ([Bool]), _CONSTM_ Text showsPrec ([Bool]), _CONSTM_ Text readList ([Bool]), _CONSTM_ Text showList ([Bool])] _N_
+ readsPrec = { _A_ 1 _U_ 02 _N_ _S_ "A" {_A_ 0 _U_ 2 _N_ _N_ _F_ _IF_ARGS_ 0 0 X 1 _CONSTM_ Text readList (Bool) _N_} _F_ _IF_ARGS_ 0 1 X 1 \ (u0 :: Int) -> _CONSTM_ Text readList (Bool) _N_ },
+ showsPrec = { _A_ 2 _U_ 012 _N_ _S_ "AS" {_A_ 1 _U_ 12 _N_ _N_ _F_ _IF_ARGS_ 0 1 X 3 \ (u0 :: [Bool]) -> _APP_ _TYAPP_ _ORIG_ PreludeCore _showList { Bool } [ _WRKR_ _CONSTM_ Text showsPrec (Bool), u0 ] _N_} _F_ _IF_ARGS_ 0 2 XX 3 \ (u0 :: Int) (u1 :: [Bool]) -> _APP_ _TYAPP_ _ORIG_ PreludeCore _showList { Bool } [ _WRKR_ _CONSTM_ Text showsPrec (Bool), u1 ] _N_ },
+ readList = { _A_ 0 _U_ 2 _N_ _N_ _N_ _N_ },
+ showList = { _A_ 1 _U_ 12 _N_ _N_ _N_ _N_ } #-}
instance Text [Char]
{-# GHC_PRAGMA _M_ PreludeBuiltin {-dfun-} _A_ 0 _N_ _N_ _N_ _F_ _IF_ARGS_ 0 0 X 5 _!_ _TUP_4 [(Int -> [Char] -> [([Char], [Char])]), (Int -> [Char] -> [Char] -> [Char]), ([Char] -> [([[Char]], [Char])]), ([[Char]] -> [Char] -> [Char])] [_CONSTM_ Text readsPrec ([Char]), _CONSTM_ Text showsPrec ([Char]), _CONSTM_ Text readList ([Char]), _CONSTM_ Text showList ([Char])] _N_
- readsPrec = _A_ 1 _U_ 02 _N_ _S_ "A" {_A_ 0 _U_ 2 _N_ _N_ _F_ _IF_ARGS_ 0 0 X 1 _CONSTM_ Text readList (Char) _N_} _F_ _IF_ARGS_ 0 1 X 1 \ (u0 :: Int) -> _CONSTM_ Text readList (Char) _N_,
- showsPrec = _A_ 2 _U_ 022 _N_ _S_ "AL" {_A_ 1 _U_ 22 _N_ _N_ _F_ _IF_ARGS_ 0 0 X 1 _CONSTM_ Text showList (Char) _N_} _F_ _IF_ARGS_ 0 2 XX 2 \ (u0 :: Int) (u1 :: [Char]) -> _APP_ _CONSTM_ Text showList (Char) [ u1 ] _N_,
- readList = _A_ 0 _U_ 2 _N_ _N_ _N_ _N_,
- showList = _A_ 0 _U_ 12 _N_ _N_ _N_ _N_ #-}
+ readsPrec = { _A_ 1 _U_ 02 _N_ _S_ "A" {_A_ 0 _U_ 2 _N_ _N_ _F_ _IF_ARGS_ 0 0 X 1 _CONSTM_ Text readList (Char) _N_} _F_ _IF_ARGS_ 0 1 X 1 \ (u0 :: Int) -> _CONSTM_ Text readList (Char) _N_ },
+ showsPrec = { _A_ 2 _U_ 022 _N_ _S_ "AL" {_A_ 1 _U_ 22 _N_ _N_ _F_ _IF_ARGS_ 0 0 X 1 _CONSTM_ Text showList (Char) _N_} _F_ _IF_ARGS_ 0 2 XX 2 \ (u0 :: Int) (u1 :: [Char]) -> _APP_ _CONSTM_ Text showList (Char) [ u1 ] _N_ },
+ readList = { _A_ 0 _U_ 2 _N_ _N_ _N_ _N_ },
+ showList = { _A_ 1 _U_ 12 _N_ _N_ _F_ _IF_ARGS_ 0 1 X 3 \ (u0 :: [[Char]]) -> _APP_ _TYAPP_ _ORIG_ PreludeCore _showList { [Char] } [ _CONSTM_ Text showList (Char), u0 ] _N_ } #-}
+instance Text [Complex Double]
+ {-# GHC_PRAGMA _M_ PreludeBuiltin {-dfun-} _A_ 0 _N_ _N_ _N_ _F_ _IF_ARGS_ 0 0 X 5 _!_ _TUP_4 [(Int -> [Char] -> [([Complex Double], [Char])]), (Int -> [Complex Double] -> [Char] -> [Char]), ([Char] -> [([[Complex Double]], [Char])]), ([[Complex Double]] -> [Char] -> [Char])] [_CONSTM_ Text readsPrec ([Complex Double]), _CONSTM_ Text showsPrec ([Complex Double]), _CONSTM_ Text readList ([Complex Double]), _CONSTM_ Text showList ([Complex Double])] _N_
+ readsPrec = { _A_ 1 _U_ 02 _N_ _S_ "A" {_A_ 0 _U_ 2 _N_ _N_ _F_ _IF_ARGS_ 0 0 X 1 _CONSTM_ Text readList (Complex Double) _N_} _F_ _IF_ARGS_ 0 1 X 1 \ (u0 :: Int) -> _CONSTM_ Text readList (Complex Double) _N_ },
+ showsPrec = { _A_ 2 _U_ 022 _N_ _S_ "AL" {_A_ 1 _U_ 22 _N_ _N_ _F_ _IF_ARGS_ 0 0 X 1 _CONSTM_ Text showList (Complex Double) _N_} _F_ _IF_ARGS_ 0 2 XX 2 \ (u0 :: Int) (u1 :: [Complex Double]) -> _APP_ _CONSTM_ Text showList (Complex Double) [ u1 ] _N_ },
+ readList = { _A_ 0 _U_ 2 _N_ _N_ _N_ _N_ },
+ showList = { _A_ 1 _U_ 12 _N_ _N_ _F_ _IF_ARGS_ 0 1 X 3 \ (u0 :: [[Complex Double]]) -> _APP_ _TYAPP_ _ORIG_ PreludeCore _showList { [Complex Double] } [ _CONSTM_ Text showList (Complex Double), u0 ] _N_ } #-}
+instance Text [Double]
+ {-# GHC_PRAGMA _M_ PreludeBuiltin {-dfun-} _A_ 0 _N_ _N_ _N_ _F_ _IF_ARGS_ 0 0 X 5 _!_ _TUP_4 [(Int -> [Char] -> [([Double], [Char])]), (Int -> [Double] -> [Char] -> [Char]), ([Char] -> [([[Double]], [Char])]), ([[Double]] -> [Char] -> [Char])] [_CONSTM_ Text readsPrec ([Double]), _CONSTM_ Text showsPrec ([Double]), _CONSTM_ Text readList ([Double]), _CONSTM_ Text showList ([Double])] _N_
+ readsPrec = { _A_ 1 _U_ 02 _N_ _S_ "A" {_A_ 0 _U_ 2 _N_ _N_ _F_ _IF_ARGS_ 0 0 X 1 _CONSTM_ Text readList (Double) _N_} _F_ _IF_ARGS_ 0 1 X 1 \ (u0 :: Int) -> _CONSTM_ Text readList (Double) _N_ },
+ showsPrec = { _A_ 2 _U_ 022 _N_ _S_ "AL" {_A_ 1 _U_ 22 _N_ _N_ _F_ _IF_ARGS_ 0 0 X 1 _CONSTM_ Text showList (Double) _N_} _F_ _IF_ARGS_ 0 2 XX 2 \ (u0 :: Int) (u1 :: [Double]) -> _APP_ _CONSTM_ Text showList (Double) [ u1 ] _N_ },
+ readList = { _A_ 0 _U_ 2 _N_ _N_ _N_ _N_ },
+ showList = { _A_ 1 _U_ 12 _N_ _N_ _F_ _IF_ARGS_ 0 1 X 3 \ (u0 :: [[Double]]) -> _APP_ _TYAPP_ _ORIG_ PreludeCore _showList { [Double] } [ _CONSTM_ Text showList (Double), u0 ] _N_ } #-}
instance Text [Int]
{-# GHC_PRAGMA _M_ PreludeBuiltin {-dfun-} _A_ 0 _N_ _N_ _N_ _F_ _IF_ARGS_ 0 0 X 5 _!_ _TUP_4 [(Int -> [Char] -> [([Int], [Char])]), (Int -> [Int] -> [Char] -> [Char]), ([Char] -> [([[Int]], [Char])]), ([[Int]] -> [Char] -> [Char])] [_CONSTM_ Text readsPrec ([Int]), _CONSTM_ Text showsPrec ([Int]), _CONSTM_ Text readList ([Int]), _CONSTM_ Text showList ([Int])] _N_
- readsPrec = _A_ 1 _U_ 02 _N_ _S_ "A" {_A_ 0 _U_ 2 _N_ _N_ _F_ _IF_ARGS_ 0 0 X 1 _CONSTM_ Text readList (Int) _N_} _F_ _IF_ARGS_ 0 1 X 1 \ (u0 :: Int) -> _CONSTM_ Text readList (Int) _N_,
- showsPrec = _A_ 1 _U_ 022 _N_ _S_ "A" {_A_ 0 _U_ 22 _N_ _N_ _F_ _IF_ARGS_ 0 0 X 1 _CONSTM_ Text showList (Int) _N_} _F_ _IF_ARGS_ 0 1 X 1 \ (u0 :: Int) -> _CONSTM_ Text showList (Int) _N_,
- readList = _A_ 0 _U_ 2 _N_ _N_ _N_ _N_,
- showList = _A_ 0 _U_ 12 _N_ _N_ _N_ _N_ #-}
+ readsPrec = { _A_ 1 _U_ 02 _N_ _S_ "A" {_A_ 0 _U_ 2 _N_ _N_ _F_ _IF_ARGS_ 0 0 X 1 _CONSTM_ Text readList (Int) _N_} _F_ _IF_ARGS_ 0 1 X 1 \ (u0 :: Int) -> _CONSTM_ Text readList (Int) _N_ },
+ showsPrec = { _A_ 2 _U_ 022 _N_ _S_ "AL" {_A_ 1 _U_ 22 _N_ _N_ _F_ _IF_ARGS_ 0 0 X 1 _CONSTM_ Text showList (Int) _N_} _F_ _IF_ARGS_ 0 2 XX 2 \ (u0 :: Int) (u1 :: [Int]) -> _APP_ _CONSTM_ Text showList (Int) [ u1 ] _N_ },
+ readList = { _A_ 0 _U_ 2 _N_ _N_ _N_ _N_ },
+ showList = { _A_ 1 _U_ 12 _N_ _N_ _F_ _IF_ARGS_ 0 1 X 3 \ (u0 :: [[Int]]) -> _APP_ _TYAPP_ _ORIG_ PreludeCore _showList { [Int] } [ _CONSTM_ Text showList (Int), u0 ] _N_ } #-}
+instance Text [Integer]
+ {-# GHC_PRAGMA _M_ PreludeBuiltin {-dfun-} _A_ 0 _N_ _N_ _N_ _F_ _IF_ARGS_ 0 0 X 5 _!_ _TUP_4 [(Int -> [Char] -> [([Integer], [Char])]), (Int -> [Integer] -> [Char] -> [Char]), ([Char] -> [([[Integer]], [Char])]), ([[Integer]] -> [Char] -> [Char])] [_CONSTM_ Text readsPrec ([Integer]), _CONSTM_ Text showsPrec ([Integer]), _CONSTM_ Text readList ([Integer]), _CONSTM_ Text showList ([Integer])] _N_
+ readsPrec = { _A_ 1 _U_ 02 _N_ _S_ "A" {_A_ 0 _U_ 2 _N_ _N_ _F_ _IF_ARGS_ 0 0 X 1 _CONSTM_ Text readList (Integer) _N_} _F_ _IF_ARGS_ 0 1 X 1 \ (u0 :: Int) -> _CONSTM_ Text readList (Integer) _N_ },
+ showsPrec = { _A_ 2 _U_ 022 _N_ _S_ "AL" {_A_ 1 _U_ 22 _N_ _N_ _F_ _IF_ARGS_ 0 0 X 1 _CONSTM_ Text showList (Integer) _N_} _F_ _IF_ARGS_ 0 2 XX 2 \ (u0 :: Int) (u1 :: [Integer]) -> _APP_ _CONSTM_ Text showList (Integer) [ u1 ] _N_ },
+ readList = { _A_ 0 _U_ 2 _N_ _N_ _N_ _N_ },
+ showList = { _A_ 1 _U_ 12 _N_ _N_ _F_ _IF_ARGS_ 0 1 X 3 \ (u0 :: [[Integer]]) -> _APP_ _TYAPP_ _ORIG_ PreludeCore _showList { [Integer] } [ _CONSTM_ Text showList (Integer), u0 ] _N_ } #-}
+instance Text [[Char]]
+ {-# GHC_PRAGMA _M_ PreludeBuiltin {-dfun-} _A_ 0 _N_ _N_ _N_ _F_ _IF_ARGS_ 0 0 X 5 _!_ _TUP_4 [(Int -> [Char] -> [([[Char]], [Char])]), (Int -> [[Char]] -> [Char] -> [Char]), ([Char] -> [([[[Char]]], [Char])]), ([[[Char]]] -> [Char] -> [Char])] [_CONSTM_ Text readsPrec ([[Char]]), _CONSTM_ Text showsPrec ([[Char]]), _CONSTM_ Text readList ([[Char]]), _CONSTM_ Text showList ([[Char]])] _N_
+ readsPrec = { _A_ 1 _U_ 02 _N_ _S_ "A" {_A_ 0 _U_ 2 _N_ _N_ _F_ _IF_ARGS_ 0 0 X 1 _CONSTM_ Text readList ([Char]) _N_} _F_ _IF_ARGS_ 0 1 X 1 \ (u0 :: Int) -> _CONSTM_ Text readList ([Char]) _N_ },
+ showsPrec = { _A_ 2 _U_ 012 _N_ _S_ "AS" {_A_ 1 _U_ 12 _N_ _N_ _F_ _IF_ARGS_ 0 1 X 3 \ (u0 :: [[Char]]) -> _APP_ _TYAPP_ _ORIG_ PreludeCore _showList { [Char] } [ _CONSTM_ Text showList (Char), u0 ] _N_} _F_ _IF_ARGS_ 0 2 XX 2 \ (u0 :: Int) (u1 :: [[Char]]) -> _APP_ _CONSTM_ Text showList ([Char]) [ u1 ] _N_ },
+ readList = { _A_ 0 _U_ 2 _N_ _N_ _N_ _N_ },
+ showList = { _A_ 1 _U_ 12 _N_ _N_ _N_ _N_ } #-}
+instance Text [[Int]]
+ {-# GHC_PRAGMA _M_ PreludeBuiltin {-dfun-} _A_ 0 _N_ _N_ _N_ _F_ _IF_ARGS_ 0 0 X 5 _!_ _TUP_4 [(Int -> [Char] -> [([[Int]], [Char])]), (Int -> [[Int]] -> [Char] -> [Char]), ([Char] -> [([[[Int]]], [Char])]), ([[[Int]]] -> [Char] -> [Char])] [_CONSTM_ Text readsPrec ([[Int]]), _CONSTM_ Text showsPrec ([[Int]]), _CONSTM_ Text readList ([[Int]]), _CONSTM_ Text showList ([[Int]])] _N_
+ readsPrec = { _A_ 1 _U_ 02 _N_ _S_ "A" {_A_ 0 _U_ 2 _N_ _N_ _F_ _IF_ARGS_ 0 0 X 1 _CONSTM_ Text readList ([Int]) _N_} _F_ _IF_ARGS_ 0 1 X 1 \ (u0 :: Int) -> _CONSTM_ Text readList ([Int]) _N_ },
+ showsPrec = { _A_ 2 _U_ 012 _N_ _S_ "AS" {_A_ 1 _U_ 12 _N_ _N_ _F_ _IF_ARGS_ 0 1 X 3 \ (u0 :: [[Int]]) -> _APP_ _TYAPP_ _ORIG_ PreludeCore _showList { [Int] } [ _CONSTM_ Text showList (Int), u0 ] _N_} _F_ _IF_ARGS_ 0 2 XX 2 \ (u0 :: Int) (u1 :: [[Int]]) -> _APP_ _CONSTM_ Text showList ([Int]) [ u1 ] _N_ },
+ readList = { _A_ 0 _U_ 2 _N_ _N_ _N_ _N_ },
+ showList = { _A_ 1 _U_ 12 _N_ _N_ _N_ _N_ } #-}
instance _CCallable [Char]
{-# GHC_PRAGMA _M_ PreludeBuiltin {-dfun-} _A_ 0 _N_ _N_ _N_ _F_ _IF_ARGS_ 0 0 X 1 _!_ _TUP_0 [] [] _N_ #-}
instance _CReturnable [Char]
-{-# GHC_PRAGMA INTERFACE VERSION 5 #-}
+{-# GHC_PRAGMA INTERFACE VERSION 6 #-}
interface PreludeBuiltin where
-import PreludeCore(Eq(..), Ord(..), Text(..), _CCallable(..), _CReturnable(..))
+import PreludeComplex(Complex)
+import PreludeCore(Bool(..), Eq(..), Ord(..), Text(..), _CCallable(..), _CReturnable(..))
+instance Eq [(Int, Int)]
+ {-# GHC_PRAGMA _M_ PreludeBuiltin {-dfun-} _A_ 0 _N_ _N_ _N_ _F_ _IF_ARGS_ 0 0 X 3 _!_ _TUP_2 [([(Int, Int)] -> [(Int, Int)] -> Bool), ([(Int, Int)] -> [(Int, Int)] -> Bool)] [_CONSTM_ Eq (==) ([(Int, Int)]), _CONSTM_ Eq (/=) ([(Int, Int)])] _N_
+ (==) = { _A_ 2 _U_ 11 _N_ _S_ "SS" _N_ _N_ },
+ (/=) = { _A_ 2 _U_ 11 _N_ _S_ "SS" _N_ _N_ } #-}
instance Eq a => Eq [a]
{-# GHC_PRAGMA _M_ PreludeBuiltin {-dfun-} _A_ 1 _U_ 1 _N_ _N_ _N_ _N_ #-}
+instance Eq [Bool]
+ {-# GHC_PRAGMA _M_ PreludeBuiltin {-dfun-} _A_ 0 _N_ _N_ _N_ _F_ _IF_ARGS_ 0 0 X 3 _!_ _TUP_2 [([Bool] -> [Bool] -> Bool), ([Bool] -> [Bool] -> Bool)] [_CONSTM_ Eq (==) ([Bool]), _CONSTM_ Eq (/=) ([Bool])] _N_
+ (==) = { _A_ 2 _U_ 11 _N_ _S_ "SS" _N_ _N_ },
+ (/=) = { _A_ 2 _U_ 11 _N_ _S_ "SS" _N_ _N_ } #-}
instance Eq [Char]
{-# GHC_PRAGMA _M_ PreludeBuiltin {-dfun-} _A_ 0 _N_ _N_ _N_ _F_ _IF_ARGS_ 0 0 X 3 _!_ _TUP_2 [([Char] -> [Char] -> Bool), ([Char] -> [Char] -> Bool)] [_CONSTM_ Eq (==) ([Char]), _CONSTM_ Eq (/=) ([Char])] _N_
- (==) = _A_ 2 _U_ 11 _N_ _S_ "SS" _N_ _N_,
- (/=) = _A_ 2 _U_ 11 _N_ _S_ "SS" _N_ _N_ #-}
+ (==) = { _A_ 2 _U_ 11 _N_ _S_ "SS" _N_ _N_ },
+ (/=) = { _A_ 2 _U_ 11 _N_ _S_ "SS" _N_ _N_ } #-}
+instance Eq [Complex Double]
+ {-# GHC_PRAGMA _M_ PreludeBuiltin {-dfun-} _A_ 0 _N_ _N_ _N_ _F_ _IF_ARGS_ 0 0 X 3 _!_ _TUP_2 [([Complex Double] -> [Complex Double] -> Bool), ([Complex Double] -> [Complex Double] -> Bool)] [_CONSTM_ Eq (==) ([Complex Double]), _CONSTM_ Eq (/=) ([Complex Double])] _N_
+ (==) = { _A_ 2 _U_ 11 _N_ _S_ "SS" _N_ _N_ },
+ (/=) = { _A_ 2 _U_ 11 _N_ _S_ "SS" _N_ _N_ } #-}
+instance Eq [Double]
+ {-# GHC_PRAGMA _M_ PreludeBuiltin {-dfun-} _A_ 0 _N_ _N_ _N_ _F_ _IF_ARGS_ 0 0 X 3 _!_ _TUP_2 [([Double] -> [Double] -> Bool), ([Double] -> [Double] -> Bool)] [_CONSTM_ Eq (==) ([Double]), _CONSTM_ Eq (/=) ([Double])] _N_
+ (==) = { _A_ 2 _U_ 11 _N_ _S_ "SS" _N_ _N_ },
+ (/=) = { _A_ 2 _U_ 11 _N_ _S_ "SS" _N_ _N_ } #-}
instance Eq [Int]
{-# GHC_PRAGMA _M_ PreludeBuiltin {-dfun-} _A_ 0 _N_ _N_ _N_ _F_ _IF_ARGS_ 0 0 X 3 _!_ _TUP_2 [([Int] -> [Int] -> Bool), ([Int] -> [Int] -> Bool)] [_CONSTM_ Eq (==) ([Int]), _CONSTM_ Eq (/=) ([Int])] _N_
- (==) = _A_ 2 _U_ 11 _N_ _S_ "SS" _N_ _N_,
- (/=) = _A_ 2 _U_ 11 _N_ _S_ "SS" _N_ _N_ #-}
+ (==) = { _A_ 2 _U_ 11 _N_ _S_ "SS" _N_ _N_ },
+ (/=) = { _A_ 2 _U_ 11 _N_ _S_ "SS" _N_ _N_ } #-}
+instance Eq [Integer]
+ {-# GHC_PRAGMA _M_ PreludeBuiltin {-dfun-} _A_ 0 _N_ _N_ _N_ _F_ _IF_ARGS_ 0 0 X 3 _!_ _TUP_2 [([Integer] -> [Integer] -> Bool), ([Integer] -> [Integer] -> Bool)] [_CONSTM_ Eq (==) ([Integer]), _CONSTM_ Eq (/=) ([Integer])] _N_
+ (==) = { _A_ 2 _U_ 11 _N_ _S_ "SS" _N_ _N_ },
+ (/=) = { _A_ 2 _U_ 11 _N_ _S_ "SS" _N_ _N_ } #-}
+instance Eq [[Char]]
+ {-# GHC_PRAGMA _M_ PreludeBuiltin {-dfun-} _A_ 0 _N_ _N_ _N_ _F_ _IF_ARGS_ 0 0 X 3 _!_ _TUP_2 [([[Char]] -> [[Char]] -> Bool), ([[Char]] -> [[Char]] -> Bool)] [_CONSTM_ Eq (==) ([[Char]]), _CONSTM_ Eq (/=) ([[Char]])] _N_
+ (==) = { _A_ 2 _U_ 11 _N_ _S_ "SS" _N_ _N_ },
+ (/=) = { _A_ 2 _U_ 11 _N_ _S_ "SS" _N_ _N_ } #-}
+instance Eq [[Int]]
+ {-# GHC_PRAGMA _M_ PreludeBuiltin {-dfun-} _A_ 0 _N_ _N_ _N_ _F_ _IF_ARGS_ 0 0 X 3 _!_ _TUP_2 [([[Int]] -> [[Int]] -> Bool), ([[Int]] -> [[Int]] -> Bool)] [_CONSTM_ Eq (==) ([[Int]]), _CONSTM_ Eq (/=) ([[Int]])] _N_
+ (==) = { _A_ 2 _U_ 11 _N_ _S_ "SS" _N_ _N_ },
+ (/=) = { _A_ 2 _U_ 11 _N_ _S_ "SS" _N_ _N_ } #-}
instance Ord a => Ord [a]
{-# GHC_PRAGMA _M_ PreludeBuiltin {-dfun-} _A_ 2 _U_ 12 _N_ _N_ _N_ _N_ #-}
+instance Ord [Bool]
+ {-# GHC_PRAGMA _M_ PreludeBuiltin {-dfun-} _A_ 0 _N_ _N_ _N_ _F_ _IF_ARGS_ 0 0 X 9 _!_ _TUP_8 [{{Eq [Bool]}}, ([Bool] -> [Bool] -> Bool), ([Bool] -> [Bool] -> Bool), ([Bool] -> [Bool] -> Bool), ([Bool] -> [Bool] -> Bool), ([Bool] -> [Bool] -> [Bool]), ([Bool] -> [Bool] -> [Bool]), ([Bool] -> [Bool] -> _CMP_TAG)] [_DFUN_ Eq ([Bool]), _CONSTM_ Ord (<) ([Bool]), _CONSTM_ Ord (<=) ([Bool]), _CONSTM_ Ord (>=) ([Bool]), _CONSTM_ Ord (>) ([Bool]), _CONSTM_ Ord max ([Bool]), _CONSTM_ Ord min ([Bool]), _CONSTM_ Ord _tagCmp ([Bool])] _N_
+ (<) = { _A_ 2 _U_ 11 _N_ _S_ "SS" _N_ _N_ },
+ (<=) = { _A_ 2 _U_ 11 _N_ _S_ "SS" _N_ _N_ },
+ (>=) = { _A_ 2 _U_ 11 _N_ _S_ "SS" _N_ _N_ },
+ (>) = { _A_ 2 _U_ 11 _N_ _S_ "SS" _N_ _N_ },
+ max = { _A_ 2 _U_ 22 _N_ _S_ "SS" _N_ _N_ },
+ min = { _A_ 2 _U_ 22 _N_ _S_ "SS" _N_ _N_ },
+ _tagCmp = { _A_ 2 _U_ 11 _N_ _S_ "SS" _N_ _N_ } #-}
instance Ord [Char]
{-# GHC_PRAGMA _M_ PreludeBuiltin {-dfun-} _A_ 0 _N_ _N_ _N_ _F_ _IF_ARGS_ 0 0 X 9 _!_ _TUP_8 [{{Eq [Char]}}, ([Char] -> [Char] -> Bool), ([Char] -> [Char] -> Bool), ([Char] -> [Char] -> Bool), ([Char] -> [Char] -> Bool), ([Char] -> [Char] -> [Char]), ([Char] -> [Char] -> [Char]), ([Char] -> [Char] -> _CMP_TAG)] [_DFUN_ Eq ([Char]), _CONSTM_ Ord (<) ([Char]), _CONSTM_ Ord (<=) ([Char]), _CONSTM_ Ord (>=) ([Char]), _CONSTM_ Ord (>) ([Char]), _CONSTM_ Ord max ([Char]), _CONSTM_ Ord min ([Char]), _CONSTM_ Ord _tagCmp ([Char])] _N_
- (<) = _A_ 2 _U_ 11 _N_ _S_ "SS" _N_ _N_,
- (<=) = _A_ 2 _U_ 11 _N_ _S_ "SS" _N_ _N_,
- (>=) = _A_ 2 _U_ 11 _N_ _S_ "SS" _N_ _N_,
- (>) = _A_ 2 _U_ 11 _N_ _S_ "SS" _N_ _N_,
- max = _A_ 2 _U_ 22 _N_ _S_ "SS" _N_ _N_,
- min = _A_ 2 _U_ 22 _N_ _S_ "SS" _N_ _N_,
- _tagCmp = _A_ 2 _U_ 11 _N_ _S_ "SS" _N_ _N_ #-}
+ (<) = { _A_ 2 _U_ 11 _N_ _S_ "SS" _N_ _N_ },
+ (<=) = { _A_ 2 _U_ 11 _N_ _S_ "SS" _N_ _N_ },
+ (>=) = { _A_ 2 _U_ 11 _N_ _S_ "SS" _N_ _N_ },
+ (>) = { _A_ 2 _U_ 11 _N_ _S_ "SS" _N_ _N_ },
+ max = { _A_ 2 _U_ 22 _N_ _S_ "SS" _N_ _N_ },
+ min = { _A_ 2 _U_ 22 _N_ _S_ "SS" _N_ _N_ },
+ _tagCmp = { _A_ 2 _U_ 11 _N_ _S_ "SS" _N_ _N_ } #-}
+instance Ord [Double]
+ {-# GHC_PRAGMA _M_ PreludeBuiltin {-dfun-} _A_ 0 _N_ _N_ _N_ _F_ _IF_ARGS_ 0 0 X 9 _!_ _TUP_8 [{{Eq [Double]}}, ([Double] -> [Double] -> Bool), ([Double] -> [Double] -> Bool), ([Double] -> [Double] -> Bool), ([Double] -> [Double] -> Bool), ([Double] -> [Double] -> [Double]), ([Double] -> [Double] -> [Double]), ([Double] -> [Double] -> _CMP_TAG)] [_DFUN_ Eq ([Double]), _CONSTM_ Ord (<) ([Double]), _CONSTM_ Ord (<=) ([Double]), _CONSTM_ Ord (>=) ([Double]), _CONSTM_ Ord (>) ([Double]), _CONSTM_ Ord max ([Double]), _CONSTM_ Ord min ([Double]), _CONSTM_ Ord _tagCmp ([Double])] _N_
+ (<) = { _A_ 2 _U_ 11 _N_ _S_ "SS" _N_ _N_ },
+ (<=) = { _A_ 2 _U_ 11 _N_ _S_ "SS" _N_ _N_ },
+ (>=) = { _A_ 2 _U_ 11 _N_ _S_ "SS" _N_ _N_ },
+ (>) = { _A_ 2 _U_ 11 _N_ _S_ "SS" _N_ _N_ },
+ max = { _A_ 2 _U_ 22 _N_ _S_ "SS" _N_ _N_ },
+ min = { _A_ 2 _U_ 22 _N_ _S_ "SS" _N_ _N_ },
+ _tagCmp = { _A_ 2 _U_ 11 _N_ _S_ "SS" _N_ _N_ } #-}
instance Ord [Int]
{-# GHC_PRAGMA _M_ PreludeBuiltin {-dfun-} _A_ 0 _N_ _N_ _N_ _F_ _IF_ARGS_ 0 0 X 9 _!_ _TUP_8 [{{Eq [Int]}}, ([Int] -> [Int] -> Bool), ([Int] -> [Int] -> Bool), ([Int] -> [Int] -> Bool), ([Int] -> [Int] -> Bool), ([Int] -> [Int] -> [Int]), ([Int] -> [Int] -> [Int]), ([Int] -> [Int] -> _CMP_TAG)] [_DFUN_ Eq ([Int]), _CONSTM_ Ord (<) ([Int]), _CONSTM_ Ord (<=) ([Int]), _CONSTM_ Ord (>=) ([Int]), _CONSTM_ Ord (>) ([Int]), _CONSTM_ Ord max ([Int]), _CONSTM_ Ord min ([Int]), _CONSTM_ Ord _tagCmp ([Int])] _N_
- (<) = _A_ 2 _U_ 11 _N_ _S_ "SS" _N_ _N_,
- (<=) = _A_ 2 _U_ 11 _N_ _S_ "SS" _N_ _N_,
- (>=) = _A_ 2 _U_ 11 _N_ _S_ "SS" _N_ _N_,
- (>) = _A_ 2 _U_ 11 _N_ _S_ "SS" _N_ _N_,
- max = _A_ 2 _U_ 22 _N_ _S_ "SS" _N_ _N_,
- min = _A_ 2 _U_ 22 _N_ _S_ "SS" _N_ _N_,
- _tagCmp = _A_ 2 _U_ 11 _N_ _S_ "SS" _N_ _N_ #-}
+ (<) = { _A_ 2 _U_ 11 _N_ _S_ "SS" _N_ _N_ },
+ (<=) = { _A_ 2 _U_ 11 _N_ _S_ "SS" _N_ _N_ },
+ (>=) = { _A_ 2 _U_ 11 _N_ _S_ "SS" _N_ _N_ },
+ (>) = { _A_ 2 _U_ 11 _N_ _S_ "SS" _N_ _N_ },
+ max = { _A_ 2 _U_ 22 _N_ _S_ "SS" _N_ _N_ },
+ min = { _A_ 2 _U_ 22 _N_ _S_ "SS" _N_ _N_ },
+ _tagCmp = { _A_ 2 _U_ 11 _N_ _S_ "SS" _N_ _N_ } #-}
+instance Ord [Integer]
+ {-# GHC_PRAGMA _M_ PreludeBuiltin {-dfun-} _A_ 0 _N_ _N_ _N_ _F_ _IF_ARGS_ 0 0 X 9 _!_ _TUP_8 [{{Eq [Integer]}}, ([Integer] -> [Integer] -> Bool), ([Integer] -> [Integer] -> Bool), ([Integer] -> [Integer] -> Bool), ([Integer] -> [Integer] -> Bool), ([Integer] -> [Integer] -> [Integer]), ([Integer] -> [Integer] -> [Integer]), ([Integer] -> [Integer] -> _CMP_TAG)] [_DFUN_ Eq ([Integer]), _CONSTM_ Ord (<) ([Integer]), _CONSTM_ Ord (<=) ([Integer]), _CONSTM_ Ord (>=) ([Integer]), _CONSTM_ Ord (>) ([Integer]), _CONSTM_ Ord max ([Integer]), _CONSTM_ Ord min ([Integer]), _CONSTM_ Ord _tagCmp ([Integer])] _N_
+ (<) = { _A_ 2 _U_ 11 _N_ _S_ "SS" _N_ _N_ },
+ (<=) = { _A_ 2 _U_ 11 _N_ _S_ "SS" _N_ _N_ },
+ (>=) = { _A_ 2 _U_ 11 _N_ _S_ "SS" _N_ _N_ },
+ (>) = { _A_ 2 _U_ 11 _N_ _S_ "SS" _N_ _N_ },
+ max = { _A_ 2 _U_ 22 _N_ _S_ "SS" _N_ _N_ },
+ min = { _A_ 2 _U_ 22 _N_ _S_ "SS" _N_ _N_ },
+ _tagCmp = { _A_ 2 _U_ 11 _N_ _S_ "SS" _N_ _N_ } #-}
+instance Ord [[Char]]
+ {-# GHC_PRAGMA _M_ PreludeBuiltin {-dfun-} _A_ 0 _N_ _N_ _N_ _F_ _IF_ARGS_ 0 0 X 9 _!_ _TUP_8 [{{Eq [[Char]]}}, ([[Char]] -> [[Char]] -> Bool), ([[Char]] -> [[Char]] -> Bool), ([[Char]] -> [[Char]] -> Bool), ([[Char]] -> [[Char]] -> Bool), ([[Char]] -> [[Char]] -> [[Char]]), ([[Char]] -> [[Char]] -> [[Char]]), ([[Char]] -> [[Char]] -> _CMP_TAG)] [_DFUN_ Eq ([[Char]]), _CONSTM_ Ord (<) ([[Char]]), _CONSTM_ Ord (<=) ([[Char]]), _CONSTM_ Ord (>=) ([[Char]]), _CONSTM_ Ord (>) ([[Char]]), _CONSTM_ Ord max ([[Char]]), _CONSTM_ Ord min ([[Char]]), _CONSTM_ Ord _tagCmp ([[Char]])] _N_
+ (<) = { _A_ 2 _U_ 11 _N_ _S_ "SS" _N_ _N_ },
+ (<=) = { _A_ 2 _U_ 11 _N_ _S_ "SS" _N_ _N_ },
+ (>=) = { _A_ 2 _U_ 11 _N_ _S_ "SS" _N_ _N_ },
+ (>) = { _A_ 2 _U_ 11 _N_ _S_ "SS" _N_ _N_ },
+ max = { _A_ 2 _U_ 22 _N_ _S_ "SS" _N_ _N_ },
+ min = { _A_ 2 _U_ 22 _N_ _S_ "SS" _N_ _N_ },
+ _tagCmp = { _A_ 2 _U_ 11 _N_ _S_ "SS" _N_ _N_ } #-}
+instance Ord [[Int]]
+ {-# GHC_PRAGMA _M_ PreludeBuiltin {-dfun-} _A_ 0 _N_ _N_ _N_ _F_ _IF_ARGS_ 0 0 X 9 _!_ _TUP_8 [{{Eq [[Int]]}}, ([[Int]] -> [[Int]] -> Bool), ([[Int]] -> [[Int]] -> Bool), ([[Int]] -> [[Int]] -> Bool), ([[Int]] -> [[Int]] -> Bool), ([[Int]] -> [[Int]] -> [[Int]]), ([[Int]] -> [[Int]] -> [[Int]]), ([[Int]] -> [[Int]] -> _CMP_TAG)] [_DFUN_ Eq ([[Int]]), _CONSTM_ Ord (<) ([[Int]]), _CONSTM_ Ord (<=) ([[Int]]), _CONSTM_ Ord (>=) ([[Int]]), _CONSTM_ Ord (>) ([[Int]]), _CONSTM_ Ord max ([[Int]]), _CONSTM_ Ord min ([[Int]]), _CONSTM_ Ord _tagCmp ([[Int]])] _N_
+ (<) = { _A_ 2 _U_ 11 _N_ _S_ "SS" _N_ _N_ },
+ (<=) = { _A_ 2 _U_ 11 _N_ _S_ "SS" _N_ _N_ },
+ (>=) = { _A_ 2 _U_ 11 _N_ _S_ "SS" _N_ _N_ },
+ (>) = { _A_ 2 _U_ 11 _N_ _S_ "SS" _N_ _N_ },
+ max = { _A_ 2 _U_ 22 _N_ _S_ "SS" _N_ _N_ },
+ min = { _A_ 2 _U_ 22 _N_ _S_ "SS" _N_ _N_ },
+ _tagCmp = { _A_ 2 _U_ 11 _N_ _S_ "SS" _N_ _N_ } #-}
instance Text a => Text [a]
{-# GHC_PRAGMA _M_ PreludeBuiltin {-dfun-} _A_ 1 _U_ 2 _N_ _N_ _N_ _N_ #-}
+instance Text [Bool]
+ {-# GHC_PRAGMA _M_ PreludeBuiltin {-dfun-} _A_ 0 _N_ _N_ _N_ _F_ _IF_ARGS_ 0 0 X 5 _!_ _TUP_4 [(Int -> [Char] -> [([Bool], [Char])]), (Int -> [Bool] -> [Char] -> [Char]), ([Char] -> [([[Bool]], [Char])]), ([[Bool]] -> [Char] -> [Char])] [_CONSTM_ Text readsPrec ([Bool]), _CONSTM_ Text showsPrec ([Bool]), _CONSTM_ Text readList ([Bool]), _CONSTM_ Text showList ([Bool])] _N_
+ readsPrec = { _A_ 1 _U_ 02 _N_ _S_ "A" {_A_ 0 _U_ 2 _N_ _N_ _F_ _IF_ARGS_ 0 0 X 1 _CONSTM_ Text readList (Bool) _N_} _F_ _IF_ARGS_ 0 1 X 1 \ (u0 :: Int) -> _CONSTM_ Text readList (Bool) _N_ },
+ showsPrec = { _A_ 2 _U_ 012 _N_ _S_ "AS" {_A_ 1 _U_ 12 _N_ _N_ _F_ _IF_ARGS_ 0 1 X 3 \ (u0 :: [Bool]) -> _APP_ _TYAPP_ _ORIG_ PreludeCore _showList { Bool } [ _WRKR_ _CONSTM_ Text showsPrec (Bool), u0 ] _N_} _F_ _IF_ARGS_ 0 2 XX 3 \ (u0 :: Int) (u1 :: [Bool]) -> _APP_ _TYAPP_ _ORIG_ PreludeCore _showList { Bool } [ _WRKR_ _CONSTM_ Text showsPrec (Bool), u1 ] _N_ },
+ readList = { _A_ 0 _U_ 2 _N_ _N_ _N_ _N_ },
+ showList = { _A_ 1 _U_ 12 _N_ _N_ _N_ _N_ } #-}
instance Text [Char]
{-# GHC_PRAGMA _M_ PreludeBuiltin {-dfun-} _A_ 0 _N_ _N_ _N_ _F_ _IF_ARGS_ 0 0 X 5 _!_ _TUP_4 [(Int -> [Char] -> [([Char], [Char])]), (Int -> [Char] -> [Char] -> [Char]), ([Char] -> [([[Char]], [Char])]), ([[Char]] -> [Char] -> [Char])] [_CONSTM_ Text readsPrec ([Char]), _CONSTM_ Text showsPrec ([Char]), _CONSTM_ Text readList ([Char]), _CONSTM_ Text showList ([Char])] _N_
- readsPrec = _A_ 1 _U_ 02 _N_ _S_ "A" {_A_ 0 _U_ 2 _N_ _N_ _F_ _IF_ARGS_ 0 0 X 1 _CONSTM_ Text readList (Char) _N_} _F_ _IF_ARGS_ 0 1 X 1 \ (u0 :: Int) -> _CONSTM_ Text readList (Char) _N_,
- showsPrec = _A_ 2 _U_ 022 _N_ _S_ "AL" {_A_ 1 _U_ 22 _N_ _N_ _F_ _IF_ARGS_ 0 0 X 1 _CONSTM_ Text showList (Char) _N_} _F_ _IF_ARGS_ 0 2 XX 2 \ (u0 :: Int) (u1 :: [Char]) -> _APP_ _CONSTM_ Text showList (Char) [ u1 ] _N_,
- readList = _A_ 0 _U_ 2 _N_ _N_ _N_ _N_,
- showList = _A_ 0 _U_ 12 _N_ _N_ _N_ _N_ #-}
+ readsPrec = { _A_ 1 _U_ 02 _N_ _S_ "A" {_A_ 0 _U_ 2 _N_ _N_ _F_ _IF_ARGS_ 0 0 X 1 _CONSTM_ Text readList (Char) _N_} _F_ _IF_ARGS_ 0 1 X 1 \ (u0 :: Int) -> _CONSTM_ Text readList (Char) _N_ },
+ showsPrec = { _A_ 2 _U_ 022 _N_ _S_ "AL" {_A_ 1 _U_ 22 _N_ _N_ _F_ _IF_ARGS_ 0 0 X 1 _CONSTM_ Text showList (Char) _N_} _F_ _IF_ARGS_ 0 2 XX 2 \ (u0 :: Int) (u1 :: [Char]) -> _APP_ _CONSTM_ Text showList (Char) [ u1 ] _N_ },
+ readList = { _A_ 0 _U_ 2 _N_ _N_ _N_ _N_ },
+ showList = { _A_ 1 _U_ 12 _N_ _N_ _F_ _IF_ARGS_ 0 1 X 3 \ (u0 :: [[Char]]) -> _APP_ _TYAPP_ _ORIG_ PreludeCore _showList { [Char] } [ _CONSTM_ Text showList (Char), u0 ] _N_ } #-}
+instance Text [Complex Double]
+ {-# GHC_PRAGMA _M_ PreludeBuiltin {-dfun-} _A_ 0 _N_ _N_ _N_ _F_ _IF_ARGS_ 0 0 X 5 _!_ _TUP_4 [(Int -> [Char] -> [([Complex Double], [Char])]), (Int -> [Complex Double] -> [Char] -> [Char]), ([Char] -> [([[Complex Double]], [Char])]), ([[Complex Double]] -> [Char] -> [Char])] [_CONSTM_ Text readsPrec ([Complex Double]), _CONSTM_ Text showsPrec ([Complex Double]), _CONSTM_ Text readList ([Complex Double]), _CONSTM_ Text showList ([Complex Double])] _N_
+ readsPrec = { _A_ 1 _U_ 02 _N_ _S_ "A" {_A_ 0 _U_ 2 _N_ _N_ _F_ _IF_ARGS_ 0 0 X 1 _CONSTM_ Text readList (Complex Double) _N_} _F_ _IF_ARGS_ 0 1 X 1 \ (u0 :: Int) -> _CONSTM_ Text readList (Complex Double) _N_ },
+ showsPrec = { _A_ 2 _U_ 022 _N_ _S_ "AL" {_A_ 1 _U_ 22 _N_ _N_ _F_ _IF_ARGS_ 0 0 X 1 _CONSTM_ Text showList (Complex Double) _N_} _F_ _IF_ARGS_ 0 2 XX 2 \ (u0 :: Int) (u1 :: [Complex Double]) -> _APP_ _CONSTM_ Text showList (Complex Double) [ u1 ] _N_ },
+ readList = { _A_ 0 _U_ 2 _N_ _N_ _N_ _N_ },
+ showList = { _A_ 1 _U_ 12 _N_ _N_ _F_ _IF_ARGS_ 0 1 X 3 \ (u0 :: [[Complex Double]]) -> _APP_ _TYAPP_ _ORIG_ PreludeCore _showList { [Complex Double] } [ _CONSTM_ Text showList (Complex Double), u0 ] _N_ } #-}
+instance Text [Double]
+ {-# GHC_PRAGMA _M_ PreludeBuiltin {-dfun-} _A_ 0 _N_ _N_ _N_ _F_ _IF_ARGS_ 0 0 X 5 _!_ _TUP_4 [(Int -> [Char] -> [([Double], [Char])]), (Int -> [Double] -> [Char] -> [Char]), ([Char] -> [([[Double]], [Char])]), ([[Double]] -> [Char] -> [Char])] [_CONSTM_ Text readsPrec ([Double]), _CONSTM_ Text showsPrec ([Double]), _CONSTM_ Text readList ([Double]), _CONSTM_ Text showList ([Double])] _N_
+ readsPrec = { _A_ 1 _U_ 02 _N_ _S_ "A" {_A_ 0 _U_ 2 _N_ _N_ _F_ _IF_ARGS_ 0 0 X 1 _CONSTM_ Text readList (Double) _N_} _F_ _IF_ARGS_ 0 1 X 1 \ (u0 :: Int) -> _CONSTM_ Text readList (Double) _N_ },
+ showsPrec = { _A_ 2 _U_ 022 _N_ _S_ "AL" {_A_ 1 _U_ 22 _N_ _N_ _F_ _IF_ARGS_ 0 0 X 1 _CONSTM_ Text showList (Double) _N_} _F_ _IF_ARGS_ 0 2 XX 2 \ (u0 :: Int) (u1 :: [Double]) -> _APP_ _CONSTM_ Text showList (Double) [ u1 ] _N_ },
+ readList = { _A_ 0 _U_ 2 _N_ _N_ _N_ _N_ },
+ showList = { _A_ 1 _U_ 12 _N_ _N_ _F_ _IF_ARGS_ 0 1 X 3 \ (u0 :: [[Double]]) -> _APP_ _TYAPP_ _ORIG_ PreludeCore _showList { [Double] } [ _CONSTM_ Text showList (Double), u0 ] _N_ } #-}
instance Text [Int]
{-# GHC_PRAGMA _M_ PreludeBuiltin {-dfun-} _A_ 0 _N_ _N_ _N_ _F_ _IF_ARGS_ 0 0 X 5 _!_ _TUP_4 [(Int -> [Char] -> [([Int], [Char])]), (Int -> [Int] -> [Char] -> [Char]), ([Char] -> [([[Int]], [Char])]), ([[Int]] -> [Char] -> [Char])] [_CONSTM_ Text readsPrec ([Int]), _CONSTM_ Text showsPrec ([Int]), _CONSTM_ Text readList ([Int]), _CONSTM_ Text showList ([Int])] _N_
- readsPrec = _A_ 1 _U_ 02 _N_ _S_ "A" {_A_ 0 _U_ 2 _N_ _N_ _F_ _IF_ARGS_ 0 0 X 1 _CONSTM_ Text readList (Int) _N_} _F_ _IF_ARGS_ 0 1 X 1 \ (u0 :: Int) -> _CONSTM_ Text readList (Int) _N_,
- showsPrec = _A_ 1 _U_ 022 _N_ _S_ "A" {_A_ 0 _U_ 22 _N_ _N_ _F_ _IF_ARGS_ 0 0 X 1 _CONSTM_ Text showList (Int) _N_} _F_ _IF_ARGS_ 0 1 X 1 \ (u0 :: Int) -> _CONSTM_ Text showList (Int) _N_,
- readList = _A_ 0 _U_ 2 _N_ _N_ _N_ _N_,
- showList = _A_ 0 _U_ 12 _N_ _N_ _N_ _N_ #-}
+ readsPrec = { _A_ 1 _U_ 02 _N_ _S_ "A" {_A_ 0 _U_ 2 _N_ _N_ _F_ _IF_ARGS_ 0 0 X 1 _CONSTM_ Text readList (Int) _N_} _F_ _IF_ARGS_ 0 1 X 1 \ (u0 :: Int) -> _CONSTM_ Text readList (Int) _N_ },
+ showsPrec = { _A_ 2 _U_ 022 _N_ _S_ "AL" {_A_ 1 _U_ 22 _N_ _N_ _F_ _IF_ARGS_ 0 0 X 1 _CONSTM_ Text showList (Int) _N_} _F_ _IF_ARGS_ 0 2 XX 2 \ (u0 :: Int) (u1 :: [Int]) -> _APP_ _CONSTM_ Text showList (Int) [ u1 ] _N_ },
+ readList = { _A_ 0 _U_ 2 _N_ _N_ _N_ _N_ },
+ showList = { _A_ 1 _U_ 12 _N_ _N_ _F_ _IF_ARGS_ 0 1 X 3 \ (u0 :: [[Int]]) -> _APP_ _TYAPP_ _ORIG_ PreludeCore _showList { [Int] } [ _CONSTM_ Text showList (Int), u0 ] _N_ } #-}
+instance Text [Integer]
+ {-# GHC_PRAGMA _M_ PreludeBuiltin {-dfun-} _A_ 0 _N_ _N_ _N_ _F_ _IF_ARGS_ 0 0 X 5 _!_ _TUP_4 [(Int -> [Char] -> [([Integer], [Char])]), (Int -> [Integer] -> [Char] -> [Char]), ([Char] -> [([[Integer]], [Char])]), ([[Integer]] -> [Char] -> [Char])] [_CONSTM_ Text readsPrec ([Integer]), _CONSTM_ Text showsPrec ([Integer]), _CONSTM_ Text readList ([Integer]), _CONSTM_ Text showList ([Integer])] _N_
+ readsPrec = { _A_ 1 _U_ 02 _N_ _S_ "A" {_A_ 0 _U_ 2 _N_ _N_ _F_ _IF_ARGS_ 0 0 X 1 _CONSTM_ Text readList (Integer) _N_} _F_ _IF_ARGS_ 0 1 X 1 \ (u0 :: Int) -> _CONSTM_ Text readList (Integer) _N_ },
+ showsPrec = { _A_ 2 _U_ 022 _N_ _S_ "AL" {_A_ 1 _U_ 22 _N_ _N_ _F_ _IF_ARGS_ 0 0 X 1 _CONSTM_ Text showList (Integer) _N_} _F_ _IF_ARGS_ 0 2 XX 2 \ (u0 :: Int) (u1 :: [Integer]) -> _APP_ _CONSTM_ Text showList (Integer) [ u1 ] _N_ },
+ readList = { _A_ 0 _U_ 2 _N_ _N_ _N_ _N_ },
+ showList = { _A_ 1 _U_ 12 _N_ _N_ _F_ _IF_ARGS_ 0 1 X 3 \ (u0 :: [[Integer]]) -> _APP_ _TYAPP_ _ORIG_ PreludeCore _showList { [Integer] } [ _CONSTM_ Text showList (Integer), u0 ] _N_ } #-}
+instance Text [[Char]]
+ {-# GHC_PRAGMA _M_ PreludeBuiltin {-dfun-} _A_ 0 _N_ _N_ _N_ _F_ _IF_ARGS_ 0 0 X 5 _!_ _TUP_4 [(Int -> [Char] -> [([[Char]], [Char])]), (Int -> [[Char]] -> [Char] -> [Char]), ([Char] -> [([[[Char]]], [Char])]), ([[[Char]]] -> [Char] -> [Char])] [_CONSTM_ Text readsPrec ([[Char]]), _CONSTM_ Text showsPrec ([[Char]]), _CONSTM_ Text readList ([[Char]]), _CONSTM_ Text showList ([[Char]])] _N_
+ readsPrec = { _A_ 1 _U_ 02 _N_ _S_ "A" {_A_ 0 _U_ 2 _N_ _N_ _F_ _IF_ARGS_ 0 0 X 1 _CONSTM_ Text readList ([Char]) _N_} _F_ _IF_ARGS_ 0 1 X 1 \ (u0 :: Int) -> _CONSTM_ Text readList ([Char]) _N_ },
+ showsPrec = { _A_ 2 _U_ 012 _N_ _S_ "AS" {_A_ 1 _U_ 12 _N_ _N_ _F_ _IF_ARGS_ 0 1 X 3 \ (u0 :: [[Char]]) -> _APP_ _TYAPP_ _ORIG_ PreludeCore _showList { [Char] } [ _CONSTM_ Text showList (Char), u0 ] _N_} _F_ _IF_ARGS_ 0 2 XX 2 \ (u0 :: Int) (u1 :: [[Char]]) -> _APP_ _CONSTM_ Text showList ([Char]) [ u1 ] _N_ },
+ readList = { _A_ 0 _U_ 2 _N_ _N_ _N_ _N_ },
+ showList = { _A_ 1 _U_ 12 _N_ _N_ _N_ _N_ } #-}
+instance Text [[Int]]
+ {-# GHC_PRAGMA _M_ PreludeBuiltin {-dfun-} _A_ 0 _N_ _N_ _N_ _F_ _IF_ARGS_ 0 0 X 5 _!_ _TUP_4 [(Int -> [Char] -> [([[Int]], [Char])]), (Int -> [[Int]] -> [Char] -> [Char]), ([Char] -> [([[[Int]]], [Char])]), ([[[Int]]] -> [Char] -> [Char])] [_CONSTM_ Text readsPrec ([[Int]]), _CONSTM_ Text showsPrec ([[Int]]), _CONSTM_ Text readList ([[Int]]), _CONSTM_ Text showList ([[Int]])] _N_
+ readsPrec = { _A_ 1 _U_ 02 _N_ _S_ "A" {_A_ 0 _U_ 2 _N_ _N_ _F_ _IF_ARGS_ 0 0 X 1 _CONSTM_ Text readList ([Int]) _N_} _F_ _IF_ARGS_ 0 1 X 1 \ (u0 :: Int) -> _CONSTM_ Text readList ([Int]) _N_ },
+ showsPrec = { _A_ 2 _U_ 012 _N_ _S_ "AS" {_A_ 1 _U_ 12 _N_ _N_ _F_ _IF_ARGS_ 0 1 X 3 \ (u0 :: [[Int]]) -> _APP_ _TYAPP_ _ORIG_ PreludeCore _showList { [Int] } [ _CONSTM_ Text showList (Int), u0 ] _N_} _F_ _IF_ARGS_ 0 2 XX 2 \ (u0 :: Int) (u1 :: [[Int]]) -> _APP_ _CONSTM_ Text showList ([Int]) [ u1 ] _N_ },
+ readList = { _A_ 0 _U_ 2 _N_ _N_ _N_ _N_ },
+ showList = { _A_ 1 _U_ 12 _N_ _N_ _N_ _N_ } #-}
instance _CCallable [Char]
{-# GHC_PRAGMA _M_ PreludeBuiltin {-dfun-} _A_ 0 _N_ _N_ _N_ _F_ _IF_ARGS_ 0 0 X 1 _!_ _TUP_0 [] [] _N_ #-}
instance _CReturnable [Char]
-{-# GHC_PRAGMA INTERFACE VERSION 5 #-}
+{-# GHC_PRAGMA INTERFACE VERSION 6 #-}
interface PreludeBuiltin where
-import PreludeCore(Eq(..), Ord(..), Text(..), _CCallable(..), _CReturnable(..))
+import PreludeComplex(Complex)
+import PreludeCore(Bool(..), Eq(..), Ord(..), Text(..), _CCallable(..), _CReturnable(..))
+instance Eq [(Int, Int)]
+ {-# GHC_PRAGMA _M_ PreludeBuiltin {-dfun-} _A_ 0 _N_ _N_ _N_ _F_ _IF_ARGS_ 0 0 X 3 _!_ _TUP_2 [([(Int, Int)] -> [(Int, Int)] -> Bool), ([(Int, Int)] -> [(Int, Int)] -> Bool)] [_CONSTM_ Eq (==) ([(Int, Int)]), _CONSTM_ Eq (/=) ([(Int, Int)])] _N_
+ (==) = { _A_ 2 _U_ 11 _N_ _S_ "SS" _N_ _N_ },
+ (/=) = { _A_ 2 _U_ 11 _N_ _S_ "SS" _N_ _N_ } #-}
instance Eq a => Eq [a]
{-# GHC_PRAGMA _M_ PreludeBuiltin {-dfun-} _A_ 1 _U_ 1 _N_ _N_ _N_ _N_ #-}
+instance Eq [Bool]
+ {-# GHC_PRAGMA _M_ PreludeBuiltin {-dfun-} _A_ 0 _N_ _N_ _N_ _F_ _IF_ARGS_ 0 0 X 3 _!_ _TUP_2 [([Bool] -> [Bool] -> Bool), ([Bool] -> [Bool] -> Bool)] [_CONSTM_ Eq (==) ([Bool]), _CONSTM_ Eq (/=) ([Bool])] _N_
+ (==) = { _A_ 2 _U_ 11 _N_ _S_ "SS" _N_ _N_ },
+ (/=) = { _A_ 2 _U_ 11 _N_ _S_ "SS" _N_ _N_ } #-}
instance Eq [Char]
{-# GHC_PRAGMA _M_ PreludeBuiltin {-dfun-} _A_ 0 _N_ _N_ _N_ _F_ _IF_ARGS_ 0 0 X 3 _!_ _TUP_2 [([Char] -> [Char] -> Bool), ([Char] -> [Char] -> Bool)] [_CONSTM_ Eq (==) ([Char]), _CONSTM_ Eq (/=) ([Char])] _N_
- (==) = _A_ 2 _U_ 11 _N_ _S_ "SS" _N_ _N_,
- (/=) = _A_ 2 _U_ 11 _N_ _S_ "SS" _N_ _N_ #-}
+ (==) = { _A_ 2 _U_ 11 _N_ _S_ "SS" _N_ _N_ },
+ (/=) = { _A_ 2 _U_ 11 _N_ _S_ "SS" _N_ _N_ } #-}
+instance Eq [Complex Double]
+ {-# GHC_PRAGMA _M_ PreludeBuiltin {-dfun-} _A_ 0 _N_ _N_ _N_ _F_ _IF_ARGS_ 0 0 X 3 _!_ _TUP_2 [([Complex Double] -> [Complex Double] -> Bool), ([Complex Double] -> [Complex Double] -> Bool)] [_CONSTM_ Eq (==) ([Complex Double]), _CONSTM_ Eq (/=) ([Complex Double])] _N_
+ (==) = { _A_ 2 _U_ 11 _N_ _S_ "SS" _N_ _N_ },
+ (/=) = { _A_ 2 _U_ 11 _N_ _S_ "SS" _N_ _N_ } #-}
+instance Eq [Double]
+ {-# GHC_PRAGMA _M_ PreludeBuiltin {-dfun-} _A_ 0 _N_ _N_ _N_ _F_ _IF_ARGS_ 0 0 X 3 _!_ _TUP_2 [([Double] -> [Double] -> Bool), ([Double] -> [Double] -> Bool)] [_CONSTM_ Eq (==) ([Double]), _CONSTM_ Eq (/=) ([Double])] _N_
+ (==) = { _A_ 2 _U_ 11 _N_ _S_ "SS" _N_ _N_ },
+ (/=) = { _A_ 2 _U_ 11 _N_ _S_ "SS" _N_ _N_ } #-}
instance Eq [Int]
{-# GHC_PRAGMA _M_ PreludeBuiltin {-dfun-} _A_ 0 _N_ _N_ _N_ _F_ _IF_ARGS_ 0 0 X 3 _!_ _TUP_2 [([Int] -> [Int] -> Bool), ([Int] -> [Int] -> Bool)] [_CONSTM_ Eq (==) ([Int]), _CONSTM_ Eq (/=) ([Int])] _N_
- (==) = _A_ 2 _U_ 11 _N_ _S_ "SS" _N_ _N_,
- (/=) = _A_ 2 _U_ 11 _N_ _S_ "SS" _N_ _N_ #-}
+ (==) = { _A_ 2 _U_ 11 _N_ _S_ "SS" _N_ _N_ },
+ (/=) = { _A_ 2 _U_ 11 _N_ _S_ "SS" _N_ _N_ } #-}
+instance Eq [Integer]
+ {-# GHC_PRAGMA _M_ PreludeBuiltin {-dfun-} _A_ 0 _N_ _N_ _N_ _F_ _IF_ARGS_ 0 0 X 3 _!_ _TUP_2 [([Integer] -> [Integer] -> Bool), ([Integer] -> [Integer] -> Bool)] [_CONSTM_ Eq (==) ([Integer]), _CONSTM_ Eq (/=) ([Integer])] _N_
+ (==) = { _A_ 2 _U_ 11 _N_ _S_ "SS" _N_ _N_ },
+ (/=) = { _A_ 2 _U_ 11 _N_ _S_ "SS" _N_ _N_ } #-}
+instance Eq [[Char]]
+ {-# GHC_PRAGMA _M_ PreludeBuiltin {-dfun-} _A_ 0 _N_ _N_ _N_ _F_ _IF_ARGS_ 0 0 X 3 _!_ _TUP_2 [([[Char]] -> [[Char]] -> Bool), ([[Char]] -> [[Char]] -> Bool)] [_CONSTM_ Eq (==) ([[Char]]), _CONSTM_ Eq (/=) ([[Char]])] _N_
+ (==) = { _A_ 2 _U_ 11 _N_ _S_ "SS" _N_ _N_ },
+ (/=) = { _A_ 2 _U_ 11 _N_ _S_ "SS" _N_ _N_ } #-}
+instance Eq [[Int]]
+ {-# GHC_PRAGMA _M_ PreludeBuiltin {-dfun-} _A_ 0 _N_ _N_ _N_ _F_ _IF_ARGS_ 0 0 X 3 _!_ _TUP_2 [([[Int]] -> [[Int]] -> Bool), ([[Int]] -> [[Int]] -> Bool)] [_CONSTM_ Eq (==) ([[Int]]), _CONSTM_ Eq (/=) ([[Int]])] _N_
+ (==) = { _A_ 2 _U_ 11 _N_ _S_ "SS" _N_ _N_ },
+ (/=) = { _A_ 2 _U_ 11 _N_ _S_ "SS" _N_ _N_ } #-}
instance Ord a => Ord [a]
{-# GHC_PRAGMA _M_ PreludeBuiltin {-dfun-} _A_ 2 _U_ 12 _N_ _N_ _N_ _N_ #-}
+instance Ord [Bool]
+ {-# GHC_PRAGMA _M_ PreludeBuiltin {-dfun-} _A_ 0 _N_ _N_ _N_ _F_ _IF_ARGS_ 0 0 X 9 _!_ _TUP_8 [{{Eq [Bool]}}, ([Bool] -> [Bool] -> Bool), ([Bool] -> [Bool] -> Bool), ([Bool] -> [Bool] -> Bool), ([Bool] -> [Bool] -> Bool), ([Bool] -> [Bool] -> [Bool]), ([Bool] -> [Bool] -> [Bool]), ([Bool] -> [Bool] -> _CMP_TAG)] [_DFUN_ Eq ([Bool]), _CONSTM_ Ord (<) ([Bool]), _CONSTM_ Ord (<=) ([Bool]), _CONSTM_ Ord (>=) ([Bool]), _CONSTM_ Ord (>) ([Bool]), _CONSTM_ Ord max ([Bool]), _CONSTM_ Ord min ([Bool]), _CONSTM_ Ord _tagCmp ([Bool])] _N_
+ (<) = { _A_ 2 _U_ 11 _N_ _S_ "SS" _N_ _N_ },
+ (<=) = { _A_ 2 _U_ 11 _N_ _S_ "SS" _N_ _N_ },
+ (>=) = { _A_ 2 _U_ 11 _N_ _S_ "SS" _N_ _N_ },
+ (>) = { _A_ 2 _U_ 11 _N_ _S_ "SS" _N_ _N_ },
+ max = { _A_ 2 _U_ 22 _N_ _S_ "SS" _N_ _N_ },
+ min = { _A_ 2 _U_ 22 _N_ _S_ "SS" _N_ _N_ },
+ _tagCmp = { _A_ 2 _U_ 11 _N_ _S_ "SS" _N_ _N_ } #-}
instance Ord [Char]
{-# GHC_PRAGMA _M_ PreludeBuiltin {-dfun-} _A_ 0 _N_ _N_ _N_ _F_ _IF_ARGS_ 0 0 X 9 _!_ _TUP_8 [{{Eq [Char]}}, ([Char] -> [Char] -> Bool), ([Char] -> [Char] -> Bool), ([Char] -> [Char] -> Bool), ([Char] -> [Char] -> Bool), ([Char] -> [Char] -> [Char]), ([Char] -> [Char] -> [Char]), ([Char] -> [Char] -> _CMP_TAG)] [_DFUN_ Eq ([Char]), _CONSTM_ Ord (<) ([Char]), _CONSTM_ Ord (<=) ([Char]), _CONSTM_ Ord (>=) ([Char]), _CONSTM_ Ord (>) ([Char]), _CONSTM_ Ord max ([Char]), _CONSTM_ Ord min ([Char]), _CONSTM_ Ord _tagCmp ([Char])] _N_
- (<) = _A_ 2 _U_ 11 _N_ _S_ "SS" _N_ _N_,
- (<=) = _A_ 2 _U_ 11 _N_ _S_ "SS" _N_ _N_,
- (>=) = _A_ 2 _U_ 11 _N_ _S_ "SS" _N_ _N_,
- (>) = _A_ 2 _U_ 11 _N_ _S_ "SS" _N_ _N_,
- max = _A_ 2 _U_ 22 _N_ _S_ "SS" _N_ _N_,
- min = _A_ 2 _U_ 22 _N_ _S_ "SS" _N_ _N_,
- _tagCmp = _A_ 2 _U_ 11 _N_ _S_ "SS" _N_ _N_ #-}
+ (<) = { _A_ 2 _U_ 11 _N_ _S_ "SS" _N_ _N_ },
+ (<=) = { _A_ 2 _U_ 11 _N_ _S_ "SS" _N_ _N_ },
+ (>=) = { _A_ 2 _U_ 11 _N_ _S_ "SS" _N_ _N_ },
+ (>) = { _A_ 2 _U_ 11 _N_ _S_ "SS" _N_ _N_ },
+ max = { _A_ 2 _U_ 22 _N_ _S_ "SS" _N_ _N_ },
+ min = { _A_ 2 _U_ 22 _N_ _S_ "SS" _N_ _N_ },
+ _tagCmp = { _A_ 2 _U_ 11 _N_ _S_ "SS" _N_ _N_ } #-}
+instance Ord [Double]
+ {-# GHC_PRAGMA _M_ PreludeBuiltin {-dfun-} _A_ 0 _N_ _N_ _N_ _F_ _IF_ARGS_ 0 0 X 9 _!_ _TUP_8 [{{Eq [Double]}}, ([Double] -> [Double] -> Bool), ([Double] -> [Double] -> Bool), ([Double] -> [Double] -> Bool), ([Double] -> [Double] -> Bool), ([Double] -> [Double] -> [Double]), ([Double] -> [Double] -> [Double]), ([Double] -> [Double] -> _CMP_TAG)] [_DFUN_ Eq ([Double]), _CONSTM_ Ord (<) ([Double]), _CONSTM_ Ord (<=) ([Double]), _CONSTM_ Ord (>=) ([Double]), _CONSTM_ Ord (>) ([Double]), _CONSTM_ Ord max ([Double]), _CONSTM_ Ord min ([Double]), _CONSTM_ Ord _tagCmp ([Double])] _N_
+ (<) = { _A_ 2 _U_ 11 _N_ _S_ "SS" _N_ _N_ },
+ (<=) = { _A_ 2 _U_ 11 _N_ _S_ "SS" _N_ _N_ },
+ (>=) = { _A_ 2 _U_ 11 _N_ _S_ "SS" _N_ _N_ },
+ (>) = { _A_ 2 _U_ 11 _N_ _S_ "SS" _N_ _N_ },
+ max = { _A_ 2 _U_ 22 _N_ _S_ "SS" _N_ _N_ },
+ min = { _A_ 2 _U_ 22 _N_ _S_ "SS" _N_ _N_ },
+ _tagCmp = { _A_ 2 _U_ 11 _N_ _S_ "SS" _N_ _N_ } #-}
instance Ord [Int]
{-# GHC_PRAGMA _M_ PreludeBuiltin {-dfun-} _A_ 0 _N_ _N_ _N_ _F_ _IF_ARGS_ 0 0 X 9 _!_ _TUP_8 [{{Eq [Int]}}, ([Int] -> [Int] -> Bool), ([Int] -> [Int] -> Bool), ([Int] -> [Int] -> Bool), ([Int] -> [Int] -> Bool), ([Int] -> [Int] -> [Int]), ([Int] -> [Int] -> [Int]), ([Int] -> [Int] -> _CMP_TAG)] [_DFUN_ Eq ([Int]), _CONSTM_ Ord (<) ([Int]), _CONSTM_ Ord (<=) ([Int]), _CONSTM_ Ord (>=) ([Int]), _CONSTM_ Ord (>) ([Int]), _CONSTM_ Ord max ([Int]), _CONSTM_ Ord min ([Int]), _CONSTM_ Ord _tagCmp ([Int])] _N_
- (<) = _A_ 2 _U_ 11 _N_ _S_ "SS" _N_ _N_,
- (<=) = _A_ 2 _U_ 11 _N_ _S_ "SS" _N_ _N_,
- (>=) = _A_ 2 _U_ 11 _N_ _S_ "SS" _N_ _N_,
- (>) = _A_ 2 _U_ 11 _N_ _S_ "SS" _N_ _N_,
- max = _A_ 2 _U_ 22 _N_ _S_ "SS" _N_ _N_,
- min = _A_ 2 _U_ 22 _N_ _S_ "SS" _N_ _N_,
- _tagCmp = _A_ 2 _U_ 11 _N_ _S_ "SS" _N_ _N_ #-}
+ (<) = { _A_ 2 _U_ 11 _N_ _S_ "SS" _N_ _N_ },
+ (<=) = { _A_ 2 _U_ 11 _N_ _S_ "SS" _N_ _N_ },
+ (>=) = { _A_ 2 _U_ 11 _N_ _S_ "SS" _N_ _N_ },
+ (>) = { _A_ 2 _U_ 11 _N_ _S_ "SS" _N_ _N_ },
+ max = { _A_ 2 _U_ 22 _N_ _S_ "SS" _N_ _N_ },
+ min = { _A_ 2 _U_ 22 _N_ _S_ "SS" _N_ _N_ },
+ _tagCmp = { _A_ 2 _U_ 11 _N_ _S_ "SS" _N_ _N_ } #-}
+instance Ord [Integer]
+ {-# GHC_PRAGMA _M_ PreludeBuiltin {-dfun-} _A_ 0 _N_ _N_ _N_ _F_ _IF_ARGS_ 0 0 X 9 _!_ _TUP_8 [{{Eq [Integer]}}, ([Integer] -> [Integer] -> Bool), ([Integer] -> [Integer] -> Bool), ([Integer] -> [Integer] -> Bool), ([Integer] -> [Integer] -> Bool), ([Integer] -> [Integer] -> [Integer]), ([Integer] -> [Integer] -> [Integer]), ([Integer] -> [Integer] -> _CMP_TAG)] [_DFUN_ Eq ([Integer]), _CONSTM_ Ord (<) ([Integer]), _CONSTM_ Ord (<=) ([Integer]), _CONSTM_ Ord (>=) ([Integer]), _CONSTM_ Ord (>) ([Integer]), _CONSTM_ Ord max ([Integer]), _CONSTM_ Ord min ([Integer]), _CONSTM_ Ord _tagCmp ([Integer])] _N_
+ (<) = { _A_ 2 _U_ 11 _N_ _S_ "SS" _N_ _N_ },
+ (<=) = { _A_ 2 _U_ 11 _N_ _S_ "SS" _N_ _N_ },
+ (>=) = { _A_ 2 _U_ 11 _N_ _S_ "SS" _N_ _N_ },
+ (>) = { _A_ 2 _U_ 11 _N_ _S_ "SS" _N_ _N_ },
+ max = { _A_ 2 _U_ 22 _N_ _S_ "SS" _N_ _N_ },
+ min = { _A_ 2 _U_ 22 _N_ _S_ "SS" _N_ _N_ },
+ _tagCmp = { _A_ 2 _U_ 11 _N_ _S_ "SS" _N_ _N_ } #-}
+instance Ord [[Char]]
+ {-# GHC_PRAGMA _M_ PreludeBuiltin {-dfun-} _A_ 0 _N_ _N_ _N_ _F_ _IF_ARGS_ 0 0 X 9 _!_ _TUP_8 [{{Eq [[Char]]}}, ([[Char]] -> [[Char]] -> Bool), ([[Char]] -> [[Char]] -> Bool), ([[Char]] -> [[Char]] -> Bool), ([[Char]] -> [[Char]] -> Bool), ([[Char]] -> [[Char]] -> [[Char]]), ([[Char]] -> [[Char]] -> [[Char]]), ([[Char]] -> [[Char]] -> _CMP_TAG)] [_DFUN_ Eq ([[Char]]), _CONSTM_ Ord (<) ([[Char]]), _CONSTM_ Ord (<=) ([[Char]]), _CONSTM_ Ord (>=) ([[Char]]), _CONSTM_ Ord (>) ([[Char]]), _CONSTM_ Ord max ([[Char]]), _CONSTM_ Ord min ([[Char]]), _CONSTM_ Ord _tagCmp ([[Char]])] _N_
+ (<) = { _A_ 2 _U_ 11 _N_ _S_ "SS" _N_ _N_ },
+ (<=) = { _A_ 2 _U_ 11 _N_ _S_ "SS" _N_ _N_ },
+ (>=) = { _A_ 2 _U_ 11 _N_ _S_ "SS" _N_ _N_ },
+ (>) = { _A_ 2 _U_ 11 _N_ _S_ "SS" _N_ _N_ },
+ max = { _A_ 2 _U_ 22 _N_ _S_ "SS" _N_ _N_ },
+ min = { _A_ 2 _U_ 22 _N_ _S_ "SS" _N_ _N_ },
+ _tagCmp = { _A_ 2 _U_ 11 _N_ _S_ "SS" _N_ _N_ } #-}
+instance Ord [[Int]]
+ {-# GHC_PRAGMA _M_ PreludeBuiltin {-dfun-} _A_ 0 _N_ _N_ _N_ _F_ _IF_ARGS_ 0 0 X 9 _!_ _TUP_8 [{{Eq [[Int]]}}, ([[Int]] -> [[Int]] -> Bool), ([[Int]] -> [[Int]] -> Bool), ([[Int]] -> [[Int]] -> Bool), ([[Int]] -> [[Int]] -> Bool), ([[Int]] -> [[Int]] -> [[Int]]), ([[Int]] -> [[Int]] -> [[Int]]), ([[Int]] -> [[Int]] -> _CMP_TAG)] [_DFUN_ Eq ([[Int]]), _CONSTM_ Ord (<) ([[Int]]), _CONSTM_ Ord (<=) ([[Int]]), _CONSTM_ Ord (>=) ([[Int]]), _CONSTM_ Ord (>) ([[Int]]), _CONSTM_ Ord max ([[Int]]), _CONSTM_ Ord min ([[Int]]), _CONSTM_ Ord _tagCmp ([[Int]])] _N_
+ (<) = { _A_ 2 _U_ 11 _N_ _S_ "SS" _N_ _N_ },
+ (<=) = { _A_ 2 _U_ 11 _N_ _S_ "SS" _N_ _N_ },
+ (>=) = { _A_ 2 _U_ 11 _N_ _S_ "SS" _N_ _N_ },
+ (>) = { _A_ 2 _U_ 11 _N_ _S_ "SS" _N_ _N_ },
+ max = { _A_ 2 _U_ 22 _N_ _S_ "SS" _N_ _N_ },
+ min = { _A_ 2 _U_ 22 _N_ _S_ "SS" _N_ _N_ },
+ _tagCmp = { _A_ 2 _U_ 11 _N_ _S_ "SS" _N_ _N_ } #-}
instance Text a => Text [a]
{-# GHC_PRAGMA _M_ PreludeBuiltin {-dfun-} _A_ 1 _U_ 2 _N_ _N_ _N_ _N_ #-}
+instance Text [Bool]
+ {-# GHC_PRAGMA _M_ PreludeBuiltin {-dfun-} _A_ 0 _N_ _N_ _N_ _F_ _IF_ARGS_ 0 0 X 5 _!_ _TUP_4 [(Int -> [Char] -> [([Bool], [Char])]), (Int -> [Bool] -> [Char] -> [Char]), ([Char] -> [([[Bool]], [Char])]), ([[Bool]] -> [Char] -> [Char])] [_CONSTM_ Text readsPrec ([Bool]), _CONSTM_ Text showsPrec ([Bool]), _CONSTM_ Text readList ([Bool]), _CONSTM_ Text showList ([Bool])] _N_
+ readsPrec = { _A_ 1 _U_ 02 _N_ _S_ "A" {_A_ 0 _U_ 2 _N_ _N_ _F_ _IF_ARGS_ 0 0 X 1 _CONSTM_ Text readList (Bool) _N_} _F_ _IF_ARGS_ 0 1 X 1 \ (u0 :: Int) -> _CONSTM_ Text readList (Bool) _N_ },
+ showsPrec = { _A_ 2 _U_ 012 _N_ _S_ "AS" {_A_ 1 _U_ 12 _N_ _N_ _F_ _IF_ARGS_ 0 1 X 3 \ (u0 :: [Bool]) -> _APP_ _TYAPP_ _ORIG_ PreludeCore _showList { Bool } [ _WRKR_ _CONSTM_ Text showsPrec (Bool), u0 ] _N_} _F_ _IF_ARGS_ 0 2 XX 3 \ (u0 :: Int) (u1 :: [Bool]) -> _APP_ _TYAPP_ _ORIG_ PreludeCore _showList { Bool } [ _WRKR_ _CONSTM_ Text showsPrec (Bool), u1 ] _N_ },
+ readList = { _A_ 0 _U_ 2 _N_ _N_ _N_ _N_ },
+ showList = { _A_ 1 _U_ 12 _N_ _N_ _N_ _N_ } #-}
instance Text [Char]
{-# GHC_PRAGMA _M_ PreludeBuiltin {-dfun-} _A_ 0 _N_ _N_ _N_ _F_ _IF_ARGS_ 0 0 X 5 _!_ _TUP_4 [(Int -> [Char] -> [([Char], [Char])]), (Int -> [Char] -> [Char] -> [Char]), ([Char] -> [([[Char]], [Char])]), ([[Char]] -> [Char] -> [Char])] [_CONSTM_ Text readsPrec ([Char]), _CONSTM_ Text showsPrec ([Char]), _CONSTM_ Text readList ([Char]), _CONSTM_ Text showList ([Char])] _N_
- readsPrec = _A_ 1 _U_ 02 _N_ _S_ "A" {_A_ 0 _U_ 2 _N_ _N_ _F_ _IF_ARGS_ 0 0 X 1 _CONSTM_ Text readList (Char) _N_} _F_ _IF_ARGS_ 0 1 X 1 \ (u0 :: Int) -> _CONSTM_ Text readList (Char) _N_,
- showsPrec = _A_ 2 _U_ 022 _N_ _S_ "AL" {_A_ 1 _U_ 22 _N_ _N_ _F_ _IF_ARGS_ 0 0 X 1 _CONSTM_ Text showList (Char) _N_} _F_ _IF_ARGS_ 0 2 XX 2 \ (u0 :: Int) (u1 :: [Char]) -> _APP_ _CONSTM_ Text showList (Char) [ u1 ] _N_,
- readList = _A_ 0 _U_ 2 _N_ _N_ _N_ _N_,
- showList = _A_ 0 _U_ 12 _N_ _N_ _N_ _N_ #-}
+ readsPrec = { _A_ 1 _U_ 02 _N_ _S_ "A" {_A_ 0 _U_ 2 _N_ _N_ _F_ _IF_ARGS_ 0 0 X 1 _CONSTM_ Text readList (Char) _N_} _F_ _IF_ARGS_ 0 1 X 1 \ (u0 :: Int) -> _CONSTM_ Text readList (Char) _N_ },
+ showsPrec = { _A_ 2 _U_ 022 _N_ _S_ "AL" {_A_ 1 _U_ 22 _N_ _N_ _F_ _IF_ARGS_ 0 0 X 1 _CONSTM_ Text showList (Char) _N_} _F_ _IF_ARGS_ 0 2 XX 2 \ (u0 :: Int) (u1 :: [Char]) -> _APP_ _CONSTM_ Text showList (Char) [ u1 ] _N_ },
+ readList = { _A_ 0 _U_ 2 _N_ _N_ _N_ _N_ },
+ showList = { _A_ 1 _U_ 12 _N_ _N_ _F_ _IF_ARGS_ 0 1 X 3 \ (u0 :: [[Char]]) -> _APP_ _TYAPP_ _ORIG_ PreludeCore _showList { [Char] } [ _CONSTM_ Text showList (Char), u0 ] _N_ } #-}
+instance Text [Complex Double]
+ {-# GHC_PRAGMA _M_ PreludeBuiltin {-dfun-} _A_ 0 _N_ _N_ _N_ _F_ _IF_ARGS_ 0 0 X 5 _!_ _TUP_4 [(Int -> [Char] -> [([Complex Double], [Char])]), (Int -> [Complex Double] -> [Char] -> [Char]), ([Char] -> [([[Complex Double]], [Char])]), ([[Complex Double]] -> [Char] -> [Char])] [_CONSTM_ Text readsPrec ([Complex Double]), _CONSTM_ Text showsPrec ([Complex Double]), _CONSTM_ Text readList ([Complex Double]), _CONSTM_ Text showList ([Complex Double])] _N_
+ readsPrec = { _A_ 1 _U_ 02 _N_ _S_ "A" {_A_ 0 _U_ 2 _N_ _N_ _F_ _IF_ARGS_ 0 0 X 1 _CONSTM_ Text readList (Complex Double) _N_} _F_ _IF_ARGS_ 0 1 X 1 \ (u0 :: Int) -> _CONSTM_ Text readList (Complex Double) _N_ },
+ showsPrec = { _A_ 2 _U_ 022 _N_ _S_ "AL" {_A_ 1 _U_ 22 _N_ _N_ _F_ _IF_ARGS_ 0 0 X 1 _CONSTM_ Text showList (Complex Double) _N_} _F_ _IF_ARGS_ 0 2 XX 2 \ (u0 :: Int) (u1 :: [Complex Double]) -> _APP_ _CONSTM_ Text showList (Complex Double) [ u1 ] _N_ },
+ readList = { _A_ 0 _U_ 2 _N_ _N_ _N_ _N_ },
+ showList = { _A_ 1 _U_ 12 _N_ _N_ _F_ _IF_ARGS_ 0 1 X 3 \ (u0 :: [[Complex Double]]) -> _APP_ _TYAPP_ _ORIG_ PreludeCore _showList { [Complex Double] } [ _CONSTM_ Text showList (Complex Double), u0 ] _N_ } #-}
+instance Text [Double]
+ {-# GHC_PRAGMA _M_ PreludeBuiltin {-dfun-} _A_ 0 _N_ _N_ _N_ _F_ _IF_ARGS_ 0 0 X 5 _!_ _TUP_4 [(Int -> [Char] -> [([Double], [Char])]), (Int -> [Double] -> [Char] -> [Char]), ([Char] -> [([[Double]], [Char])]), ([[Double]] -> [Char] -> [Char])] [_CONSTM_ Text readsPrec ([Double]), _CONSTM_ Text showsPrec ([Double]), _CONSTM_ Text readList ([Double]), _CONSTM_ Text showList ([Double])] _N_
+ readsPrec = { _A_ 1 _U_ 02 _N_ _S_ "A" {_A_ 0 _U_ 2 _N_ _N_ _F_ _IF_ARGS_ 0 0 X 1 _CONSTM_ Text readList (Double) _N_} _F_ _IF_ARGS_ 0 1 X 1 \ (u0 :: Int) -> _CONSTM_ Text readList (Double) _N_ },
+ showsPrec = { _A_ 2 _U_ 022 _N_ _S_ "AL" {_A_ 1 _U_ 22 _N_ _N_ _F_ _IF_ARGS_ 0 0 X 1 _CONSTM_ Text showList (Double) _N_} _F_ _IF_ARGS_ 0 2 XX 2 \ (u0 :: Int) (u1 :: [Double]) -> _APP_ _CONSTM_ Text showList (Double) [ u1 ] _N_ },
+ readList = { _A_ 0 _U_ 2 _N_ _N_ _N_ _N_ },
+ showList = { _A_ 1 _U_ 12 _N_ _N_ _F_ _IF_ARGS_ 0 1 X 3 \ (u0 :: [[Double]]) -> _APP_ _TYAPP_ _ORIG_ PreludeCore _showList { [Double] } [ _CONSTM_ Text showList (Double), u0 ] _N_ } #-}
instance Text [Int]
{-# GHC_PRAGMA _M_ PreludeBuiltin {-dfun-} _A_ 0 _N_ _N_ _N_ _F_ _IF_ARGS_ 0 0 X 5 _!_ _TUP_4 [(Int -> [Char] -> [([Int], [Char])]), (Int -> [Int] -> [Char] -> [Char]), ([Char] -> [([[Int]], [Char])]), ([[Int]] -> [Char] -> [Char])] [_CONSTM_ Text readsPrec ([Int]), _CONSTM_ Text showsPrec ([Int]), _CONSTM_ Text readList ([Int]), _CONSTM_ Text showList ([Int])] _N_
- readsPrec = _A_ 1 _U_ 02 _N_ _S_ "A" {_A_ 0 _U_ 2 _N_ _N_ _F_ _IF_ARGS_ 0 0 X 1 _CONSTM_ Text readList (Int) _N_} _F_ _IF_ARGS_ 0 1 X 1 \ (u0 :: Int) -> _CONSTM_ Text readList (Int) _N_,
- showsPrec = _A_ 1 _U_ 022 _N_ _S_ "A" {_A_ 0 _U_ 22 _N_ _N_ _F_ _IF_ARGS_ 0 0 X 1 _CONSTM_ Text showList (Int) _N_} _F_ _IF_ARGS_ 0 1 X 1 \ (u0 :: Int) -> _CONSTM_ Text showList (Int) _N_,
- readList = _A_ 0 _U_ 2 _N_ _N_ _N_ _N_,
- showList = _A_ 0 _U_ 12 _N_ _N_ _N_ _N_ #-}
+ readsPrec = { _A_ 1 _U_ 02 _N_ _S_ "A" {_A_ 0 _U_ 2 _N_ _N_ _F_ _IF_ARGS_ 0 0 X 1 _CONSTM_ Text readList (Int) _N_} _F_ _IF_ARGS_ 0 1 X 1 \ (u0 :: Int) -> _CONSTM_ Text readList (Int) _N_ },
+ showsPrec = { _A_ 2 _U_ 022 _N_ _S_ "AL" {_A_ 1 _U_ 22 _N_ _N_ _F_ _IF_ARGS_ 0 0 X 1 _CONSTM_ Text showList (Int) _N_} _F_ _IF_ARGS_ 0 2 XX 2 \ (u0 :: Int) (u1 :: [Int]) -> _APP_ _CONSTM_ Text showList (Int) [ u1 ] _N_ },
+ readList = { _A_ 0 _U_ 2 _N_ _N_ _N_ _N_ },
+ showList = { _A_ 1 _U_ 12 _N_ _N_ _F_ _IF_ARGS_ 0 1 X 3 \ (u0 :: [[Int]]) -> _APP_ _TYAPP_ _ORIG_ PreludeCore _showList { [Int] } [ _CONSTM_ Text showList (Int), u0 ] _N_ } #-}
+instance Text [Integer]
+ {-# GHC_PRAGMA _M_ PreludeBuiltin {-dfun-} _A_ 0 _N_ _N_ _N_ _F_ _IF_ARGS_ 0 0 X 5 _!_ _TUP_4 [(Int -> [Char] -> [([Integer], [Char])]), (Int -> [Integer] -> [Char] -> [Char]), ([Char] -> [([[Integer]], [Char])]), ([[Integer]] -> [Char] -> [Char])] [_CONSTM_ Text readsPrec ([Integer]), _CONSTM_ Text showsPrec ([Integer]), _CONSTM_ Text readList ([Integer]), _CONSTM_ Text showList ([Integer])] _N_
+ readsPrec = { _A_ 1 _U_ 02 _N_ _S_ "A" {_A_ 0 _U_ 2 _N_ _N_ _F_ _IF_ARGS_ 0 0 X 1 _CONSTM_ Text readList (Integer) _N_} _F_ _IF_ARGS_ 0 1 X 1 \ (u0 :: Int) -> _CONSTM_ Text readList (Integer) _N_ },
+ showsPrec = { _A_ 2 _U_ 022 _N_ _S_ "AL" {_A_ 1 _U_ 22 _N_ _N_ _F_ _IF_ARGS_ 0 0 X 1 _CONSTM_ Text showList (Integer) _N_} _F_ _IF_ARGS_ 0 2 XX 2 \ (u0 :: Int) (u1 :: [Integer]) -> _APP_ _CONSTM_ Text showList (Integer) [ u1 ] _N_ },
+ readList = { _A_ 0 _U_ 2 _N_ _N_ _N_ _N_ },
+ showList = { _A_ 1 _U_ 12 _N_ _N_ _F_ _IF_ARGS_ 0 1 X 3 \ (u0 :: [[Integer]]) -> _APP_ _TYAPP_ _ORIG_ PreludeCore _showList { [Integer] } [ _CONSTM_ Text showList (Integer), u0 ] _N_ } #-}
+instance Text [[Char]]
+ {-# GHC_PRAGMA _M_ PreludeBuiltin {-dfun-} _A_ 0 _N_ _N_ _N_ _F_ _IF_ARGS_ 0 0 X 5 _!_ _TUP_4 [(Int -> [Char] -> [([[Char]], [Char])]), (Int -> [[Char]] -> [Char] -> [Char]), ([Char] -> [([[[Char]]], [Char])]), ([[[Char]]] -> [Char] -> [Char])] [_CONSTM_ Text readsPrec ([[Char]]), _CONSTM_ Text showsPrec ([[Char]]), _CONSTM_ Text readList ([[Char]]), _CONSTM_ Text showList ([[Char]])] _N_
+ readsPrec = { _A_ 1 _U_ 02 _N_ _S_ "A" {_A_ 0 _U_ 2 _N_ _N_ _F_ _IF_ARGS_ 0 0 X 1 _CONSTM_ Text readList ([Char]) _N_} _F_ _IF_ARGS_ 0 1 X 1 \ (u0 :: Int) -> _CONSTM_ Text readList ([Char]) _N_ },
+ showsPrec = { _A_ 2 _U_ 012 _N_ _S_ "AS" {_A_ 1 _U_ 12 _N_ _N_ _F_ _IF_ARGS_ 0 1 X 3 \ (u0 :: [[Char]]) -> _APP_ _TYAPP_ _ORIG_ PreludeCore _showList { [Char] } [ _CONSTM_ Text showList (Char), u0 ] _N_} _F_ _IF_ARGS_ 0 2 XX 2 \ (u0 :: Int) (u1 :: [[Char]]) -> _APP_ _CONSTM_ Text showList ([Char]) [ u1 ] _N_ },
+ readList = { _A_ 0 _U_ 2 _N_ _N_ _N_ _N_ },
+ showList = { _A_ 1 _U_ 12 _N_ _N_ _N_ _N_ } #-}
+instance Text [[Int]]
+ {-# GHC_PRAGMA _M_ PreludeBuiltin {-dfun-} _A_ 0 _N_ _N_ _N_ _F_ _IF_ARGS_ 0 0 X 5 _!_ _TUP_4 [(Int -> [Char] -> [([[Int]], [Char])]), (Int -> [[Int]] -> [Char] -> [Char]), ([Char] -> [([[[Int]]], [Char])]), ([[[Int]]] -> [Char] -> [Char])] [_CONSTM_ Text readsPrec ([[Int]]), _CONSTM_ Text showsPrec ([[Int]]), _CONSTM_ Text readList ([[Int]]), _CONSTM_ Text showList ([[Int]])] _N_
+ readsPrec = { _A_ 1 _U_ 02 _N_ _S_ "A" {_A_ 0 _U_ 2 _N_ _N_ _F_ _IF_ARGS_ 0 0 X 1 _CONSTM_ Text readList ([Int]) _N_} _F_ _IF_ARGS_ 0 1 X 1 \ (u0 :: Int) -> _CONSTM_ Text readList ([Int]) _N_ },
+ showsPrec = { _A_ 2 _U_ 012 _N_ _S_ "AS" {_A_ 1 _U_ 12 _N_ _N_ _F_ _IF_ARGS_ 0 1 X 3 \ (u0 :: [[Int]]) -> _APP_ _TYAPP_ _ORIG_ PreludeCore _showList { [Int] } [ _CONSTM_ Text showList (Int), u0 ] _N_} _F_ _IF_ARGS_ 0 2 XX 2 \ (u0 :: Int) (u1 :: [[Int]]) -> _APP_ _CONSTM_ Text showList ([Int]) [ u1 ] _N_ },
+ readList = { _A_ 0 _U_ 2 _N_ _N_ _N_ _N_ },
+ showList = { _A_ 1 _U_ 12 _N_ _N_ _N_ _N_ } #-}
instance _CCallable [Char]
{-# GHC_PRAGMA _M_ PreludeBuiltin {-dfun-} _A_ 0 _N_ _N_ _N_ _F_ _IF_ARGS_ 0 0 X 1 _!_ _TUP_0 [] [] _N_ #-}
instance _CReturnable [Char]
-{-# GHC_PRAGMA INTERFACE VERSION 5 #-}
+{-# GHC_PRAGMA INTERFACE VERSION 6 #-}
interface PreludeIO where
import PreludeBuiltin(Bin, Char(..), Int(..), List(..))
import PreludeCore(Bool(..), Text(..))
interact :: ([Char] -> [Char]) -> [Response] -> [Request]
{-# GHC_PRAGMA _A_ 1 _U_ 11 _N_ _N_ _N_ _N_ #-}
print :: Text a => a -> [Response] -> [Request]
- {-# GHC_PRAGMA _A_ 1 _U_ 121 _N_ _N_ _N_ _N_ #-}
+ {-# GHC_PRAGMA _A_ 1 _U_ 121 _N_ _N_ _N_ _SPECIALISE_ [ Bool ] 1 { _A_ 1 _U_ 21 _N_ _N_ _N_ _N_ }, [ Char ] 1 { _A_ 1 _U_ 11 _N_ _N_ _N_ _N_ }, [ Double ] 1 { _A_ 1 _U_ 11 _N_ _N_ _N_ _N_ }, [ Int ] 1 { _A_ 1 _U_ 11 _N_ _N_ _N_ _N_ }, [ Integer ] 1 { _A_ 1 _U_ 11 _N_ _N_ _N_ _N_ }, [ [Char] ] 1 { _A_ 1 _U_ 21 _N_ _N_ _N_ _N_ }, [ [Int] ] 1 { _A_ 1 _U_ 21 _N_ _N_ _N_ _N_ }, [ [[Char]] ] 1 { _A_ 1 _U_ 21 _N_ _N_ _N_ _N_ }, [ [[Int]] ] 1 { _A_ 1 _U_ 21 _N_ _N_ _N_ _N_ }, [ _PackedString ] 1 { _A_ 1 _U_ 21 _N_ _N_ _N_ _N_ }, [ () ] 1 { _A_ 1 _U_ 21 _N_ _N_ _N_ _N_ } #-}
prints :: Text a => a -> [Char] -> [Response] -> [Request]
- {-# GHC_PRAGMA _A_ 1 _U_ 1221 _N_ _N_ _N_ _N_ #-}
+ {-# GHC_PRAGMA _A_ 1 _U_ 1221 _N_ _N_ _N_ _SPECIALISE_ [ Bool ] 1 { _A_ 2 _U_ 221 _N_ _N_ _N_ _N_ }, [ Char ] 1 { _A_ 2 _U_ 121 _N_ _N_ _N_ _N_ }, [ Double ] 1 { _A_ 2 _U_ 121 _N_ _N_ _N_ _N_ }, [ Int ] 1 { _A_ 2 _U_ 121 _N_ _N_ _N_ _N_ }, [ Integer ] 1 { _A_ 2 _U_ 121 _N_ _N_ _N_ _N_ }, [ [Char] ] 1 { _A_ 2 _U_ 221 _N_ _N_ _N_ _N_ }, [ [Int] ] 1 { _A_ 2 _U_ 221 _N_ _N_ _N_ _N_ }, [ [[Char]] ] 1 { _A_ 2 _U_ 121 _N_ _N_ _N_ _N_ }, [ [[Int]] ] 1 { _A_ 2 _U_ 121 _N_ _N_ _N_ _N_ }, [ _PackedString ] 1 { _A_ 2 _U_ 221 _N_ _N_ _N_ _N_ }, [ () ] 1 { _A_ 2 _U_ 121 _N_ _N_ _N_ _N_ } #-}
readBinChan :: [Char] -> (IOError -> [Response] -> [Request]) -> (Bin -> [Response] -> [Request]) -> [Response] -> [Request]
{-# GHC_PRAGMA _A_ 4 _U_ 2111 _N_ _N_ _N_ _N_ #-}
readBinFile :: [Char] -> (IOError -> [Response] -> [Request]) -> (Bin -> [Response] -> [Request]) -> [Response] -> [Request]
import Cls
import Core
+import IBool
+import IChar
+import IDouble
+import IInt
+import IInteger
+import IList
+import ITup0
import List ( (++), foldr )
import PS ( _PackedString, _unpackPS )
import Text
+import TyArray
+import TyComplex
import TyIO
-- File and channel names:
OtherError s -> s
EOD -> "EOD"
+{-# GENERATE_SPECS print a{+,(),Bool,Char,Int,Integer,Double,_PackedString,[Char],[Int],[[Char]],[[Int]]} #-}
print :: (Text a) => a -> Dialogue
print x = appendChan stdout (show x) exit done
+
+{-# GENERATE_SPECS prints a{+,(),Bool,Char,Int,Integer,Double,_PackedString,[Char],[Int],[[Char]],[[Int]]} #-}
prints :: (Text a) => a -> String -> Dialogue
prints x s = appendChan stdout (shows x s) exit done
-{-# GHC_PRAGMA INTERFACE VERSION 5 #-}
+{-# GHC_PRAGMA INTERFACE VERSION 6 #-}
interface PreludeIO where
import PreludeBuiltin(Bin, Char(..), Int(..), List(..))
import PreludeCore(Bool(..), Text(..))
interact :: ([Char] -> [Char]) -> [Response] -> [Request]
{-# GHC_PRAGMA _A_ 1 _U_ 11 _N_ _N_ _N_ _N_ #-}
print :: Text a => a -> [Response] -> [Request]
- {-# GHC_PRAGMA _A_ 1 _U_ 121 _N_ _N_ _N_ _N_ #-}
+ {-# GHC_PRAGMA _A_ 1 _U_ 121 _N_ _N_ _N_ _SPECIALISE_ [ Bool ] 1 { _A_ 1 _U_ 21 _N_ _N_ _N_ _N_ }, [ Char ] 1 { _A_ 1 _U_ 11 _N_ _N_ _N_ _N_ }, [ Double ] 1 { _A_ 1 _U_ 11 _N_ _N_ _N_ _N_ }, [ Int ] 1 { _A_ 1 _U_ 11 _N_ _N_ _N_ _N_ }, [ Integer ] 1 { _A_ 1 _U_ 11 _N_ _N_ _N_ _N_ }, [ [Char] ] 1 { _A_ 1 _U_ 21 _N_ _N_ _N_ _N_ }, [ [Int] ] 1 { _A_ 1 _U_ 21 _N_ _N_ _N_ _N_ }, [ [[Char]] ] 1 { _A_ 1 _U_ 21 _N_ _N_ _N_ _N_ }, [ [[Int]] ] 1 { _A_ 1 _U_ 21 _N_ _N_ _N_ _N_ }, [ _PackedString ] 1 { _A_ 1 _U_ 21 _N_ _N_ _N_ _N_ }, [ () ] 1 { _A_ 1 _U_ 21 _N_ _N_ _N_ _N_ } #-}
prints :: Text a => a -> [Char] -> [Response] -> [Request]
- {-# GHC_PRAGMA _A_ 1 _U_ 1221 _N_ _N_ _N_ _N_ #-}
+ {-# GHC_PRAGMA _A_ 1 _U_ 1221 _N_ _N_ _N_ _SPECIALISE_ [ Bool ] 1 { _A_ 2 _U_ 221 _N_ _N_ _N_ _N_ }, [ Char ] 1 { _A_ 2 _U_ 121 _N_ _N_ _N_ _N_ }, [ Double ] 1 { _A_ 2 _U_ 121 _N_ _N_ _N_ _N_ }, [ Int ] 1 { _A_ 2 _U_ 121 _N_ _N_ _N_ _N_ }, [ Integer ] 1 { _A_ 2 _U_ 121 _N_ _N_ _N_ _N_ }, [ [Char] ] 1 { _A_ 2 _U_ 221 _N_ _N_ _N_ _N_ }, [ [Int] ] 1 { _A_ 2 _U_ 221 _N_ _N_ _N_ _N_ }, [ [[Char]] ] 1 { _A_ 2 _U_ 121 _N_ _N_ _N_ _N_ }, [ [[Int]] ] 1 { _A_ 2 _U_ 121 _N_ _N_ _N_ _N_ }, [ _PackedString ] 1 { _A_ 2 _U_ 221 _N_ _N_ _N_ _N_ }, [ () ] 1 { _A_ 2 _U_ 121 _N_ _N_ _N_ _N_ } #-}
readBinChan :: [Char] -> (IOError -> [Response] -> [Request]) -> (Bin -> [Response] -> [Request]) -> [Response] -> [Request]
{-# GHC_PRAGMA _A_ 4 _U_ 2111 _N_ _N_ _N_ _N_ #-}
readBinFile :: [Char] -> (IOError -> [Response] -> [Request]) -> (Bin -> [Response] -> [Request]) -> [Response] -> [Request]
-{-# GHC_PRAGMA INTERFACE VERSION 5 #-}
+{-# GHC_PRAGMA INTERFACE VERSION 6 #-}
interface PreludeIO where
import PreludeBuiltin(Bin, Char(..), Int(..), List(..))
import PreludeCore(Bool(..), Text(..))
interact :: ([Char] -> [Char]) -> [Response] -> [Request]
{-# GHC_PRAGMA _A_ 1 _U_ 11 _N_ _N_ _N_ _N_ #-}
print :: Text a => a -> [Response] -> [Request]
- {-# GHC_PRAGMA _A_ 1 _U_ 121 _N_ _N_ _N_ _N_ #-}
+ {-# GHC_PRAGMA _A_ 1 _U_ 121 _N_ _N_ _N_ _SPECIALISE_ [ Bool ] 1 { _A_ 1 _U_ 21 _N_ _N_ _N_ _N_ }, [ Char ] 1 { _A_ 1 _U_ 11 _N_ _N_ _N_ _N_ }, [ Double ] 1 { _A_ 1 _U_ 11 _N_ _N_ _N_ _N_ }, [ Int ] 1 { _A_ 1 _U_ 11 _N_ _N_ _N_ _N_ }, [ Integer ] 1 { _A_ 1 _U_ 11 _N_ _N_ _N_ _N_ }, [ [Char] ] 1 { _A_ 1 _U_ 21 _N_ _N_ _N_ _N_ }, [ [Int] ] 1 { _A_ 1 _U_ 21 _N_ _N_ _N_ _N_ }, [ [[Char]] ] 1 { _A_ 1 _U_ 21 _N_ _N_ _N_ _N_ }, [ [[Int]] ] 1 { _A_ 1 _U_ 21 _N_ _N_ _N_ _N_ }, [ _PackedString ] 1 { _A_ 1 _U_ 21 _N_ _N_ _N_ _N_ }, [ () ] 1 { _A_ 1 _U_ 21 _N_ _N_ _N_ _N_ } #-}
prints :: Text a => a -> [Char] -> [Response] -> [Request]
- {-# GHC_PRAGMA _A_ 1 _U_ 1221 _N_ _N_ _N_ _N_ #-}
+ {-# GHC_PRAGMA _A_ 1 _U_ 1221 _N_ _N_ _N_ _SPECIALISE_ [ Bool ] 1 { _A_ 2 _U_ 221 _N_ _N_ _N_ _N_ }, [ Char ] 1 { _A_ 2 _U_ 121 _N_ _N_ _N_ _N_ }, [ Double ] 1 { _A_ 2 _U_ 121 _N_ _N_ _N_ _N_ }, [ Int ] 1 { _A_ 2 _U_ 121 _N_ _N_ _N_ _N_ }, [ Integer ] 1 { _A_ 2 _U_ 121 _N_ _N_ _N_ _N_ }, [ [Char] ] 1 { _A_ 2 _U_ 221 _N_ _N_ _N_ _N_ }, [ [Int] ] 1 { _A_ 2 _U_ 221 _N_ _N_ _N_ _N_ }, [ [[Char]] ] 1 { _A_ 2 _U_ 121 _N_ _N_ _N_ _N_ }, [ [[Int]] ] 1 { _A_ 2 _U_ 121 _N_ _N_ _N_ _N_ }, [ _PackedString ] 1 { _A_ 2 _U_ 221 _N_ _N_ _N_ _N_ }, [ () ] 1 { _A_ 2 _U_ 121 _N_ _N_ _N_ _N_ } #-}
readBinChan :: [Char] -> (IOError -> [Response] -> [Request]) -> (Bin -> [Response] -> [Request]) -> [Response] -> [Request]
{-# GHC_PRAGMA _A_ 4 _U_ 2111 _N_ _N_ _N_ _N_ #-}
readBinFile :: [Char] -> (IOError -> [Response] -> [Request]) -> (Bin -> [Response] -> [Request]) -> [Response] -> [Request]
-{-# GHC_PRAGMA INTERFACE VERSION 5 #-}
+{-# GHC_PRAGMA INTERFACE VERSION 6 #-}
interface PreludeIO where
import PreludeBuiltin(Bin, Char(..), Int(..), List(..))
import PreludeCore(Bool(..), Text(..))
interact :: ([Char] -> [Char]) -> [Response] -> [Request]
{-# GHC_PRAGMA _A_ 1 _U_ 11 _N_ _N_ _N_ _N_ #-}
print :: Text a => a -> [Response] -> [Request]
- {-# GHC_PRAGMA _A_ 1 _U_ 121 _N_ _N_ _N_ _N_ #-}
+ {-# GHC_PRAGMA _A_ 1 _U_ 121 _N_ _N_ _N_ _SPECIALISE_ [ Bool ] 1 { _A_ 1 _U_ 21 _N_ _N_ _N_ _N_ }, [ Char ] 1 { _A_ 1 _U_ 11 _N_ _N_ _N_ _N_ }, [ Double ] 1 { _A_ 1 _U_ 11 _N_ _N_ _N_ _N_ }, [ Int ] 1 { _A_ 1 _U_ 11 _N_ _N_ _N_ _N_ }, [ Integer ] 1 { _A_ 1 _U_ 11 _N_ _N_ _N_ _N_ }, [ [Char] ] 1 { _A_ 1 _U_ 21 _N_ _N_ _N_ _N_ }, [ [Int] ] 1 { _A_ 1 _U_ 21 _N_ _N_ _N_ _N_ }, [ [[Char]] ] 1 { _A_ 1 _U_ 21 _N_ _N_ _N_ _N_ }, [ [[Int]] ] 1 { _A_ 1 _U_ 21 _N_ _N_ _N_ _N_ }, [ _PackedString ] 1 { _A_ 1 _U_ 21 _N_ _N_ _N_ _N_ }, [ () ] 1 { _A_ 1 _U_ 21 _N_ _N_ _N_ _N_ } #-}
prints :: Text a => a -> [Char] -> [Response] -> [Request]
- {-# GHC_PRAGMA _A_ 1 _U_ 1221 _N_ _N_ _N_ _N_ #-}
+ {-# GHC_PRAGMA _A_ 1 _U_ 1221 _N_ _N_ _N_ _SPECIALISE_ [ Bool ] 1 { _A_ 2 _U_ 221 _N_ _N_ _N_ _N_ }, [ Char ] 1 { _A_ 2 _U_ 121 _N_ _N_ _N_ _N_ }, [ Double ] 1 { _A_ 2 _U_ 121 _N_ _N_ _N_ _N_ }, [ Int ] 1 { _A_ 2 _U_ 121 _N_ _N_ _N_ _N_ }, [ Integer ] 1 { _A_ 2 _U_ 121 _N_ _N_ _N_ _N_ }, [ [Char] ] 1 { _A_ 2 _U_ 221 _N_ _N_ _N_ _N_ }, [ [Int] ] 1 { _A_ 2 _U_ 221 _N_ _N_ _N_ _N_ }, [ [[Char]] ] 1 { _A_ 2 _U_ 121 _N_ _N_ _N_ _N_ }, [ [[Int]] ] 1 { _A_ 2 _U_ 121 _N_ _N_ _N_ _N_ }, [ _PackedString ] 1 { _A_ 2 _U_ 221 _N_ _N_ _N_ _N_ }, [ () ] 1 { _A_ 2 _U_ 121 _N_ _N_ _N_ _N_ } #-}
readBinChan :: [Char] -> (IOError -> [Response] -> [Request]) -> (Bin -> [Response] -> [Request]) -> [Response] -> [Request]
{-# GHC_PRAGMA _A_ 4 _U_ 2111 _N_ _N_ _N_ _N_ #-}
readBinFile :: [Char] -> (IOError -> [Response] -> [Request]) -> (Bin -> [Response] -> [Request]) -> [Response] -> [Request]
-{-# GHC_PRAGMA INTERFACE VERSION 5 #-}
+{-# GHC_PRAGMA INTERFACE VERSION 6 #-}
interface PreludeIO where
import PreludeBuiltin(Bin, Char(..), Int(..), List(..))
import PreludeCore(Bool(..), Text(..))
interact :: ([Char] -> [Char]) -> [Response] -> [Request]
{-# GHC_PRAGMA _A_ 1 _U_ 11 _N_ _N_ _N_ _N_ #-}
print :: Text a => a -> [Response] -> [Request]
- {-# GHC_PRAGMA _A_ 1 _U_ 121 _N_ _N_ _N_ _N_ #-}
+ {-# GHC_PRAGMA _A_ 1 _U_ 121 _N_ _N_ _N_ _SPECIALISE_ [ Bool ] 1 { _A_ 1 _U_ 21 _N_ _N_ _N_ _N_ }, [ Char ] 1 { _A_ 1 _U_ 11 _N_ _N_ _N_ _N_ }, [ Double ] 1 { _A_ 1 _U_ 11 _N_ _N_ _N_ _N_ }, [ Int ] 1 { _A_ 1 _U_ 11 _N_ _N_ _N_ _N_ }, [ Integer ] 1 { _A_ 1 _U_ 11 _N_ _N_ _N_ _N_ }, [ [Char] ] 1 { _A_ 1 _U_ 21 _N_ _N_ _N_ _N_ }, [ [Int] ] 1 { _A_ 1 _U_ 21 _N_ _N_ _N_ _N_ }, [ [[Char]] ] 1 { _A_ 1 _U_ 21 _N_ _N_ _N_ _N_ }, [ [[Int]] ] 1 { _A_ 1 _U_ 21 _N_ _N_ _N_ _N_ }, [ _PackedString ] 1 { _A_ 1 _U_ 21 _N_ _N_ _N_ _N_ }, [ () ] 1 { _A_ 1 _U_ 21 _N_ _N_ _N_ _N_ } #-}
prints :: Text a => a -> [Char] -> [Response] -> [Request]
- {-# GHC_PRAGMA _A_ 1 _U_ 1221 _N_ _N_ _N_ _N_ #-}
+ {-# GHC_PRAGMA _A_ 1 _U_ 1221 _N_ _N_ _N_ _SPECIALISE_ [ Bool ] 1 { _A_ 2 _U_ 221 _N_ _N_ _N_ _N_ }, [ Char ] 1 { _A_ 2 _U_ 121 _N_ _N_ _N_ _N_ }, [ Double ] 1 { _A_ 2 _U_ 121 _N_ _N_ _N_ _N_ }, [ Int ] 1 { _A_ 2 _U_ 121 _N_ _N_ _N_ _N_ }, [ Integer ] 1 { _A_ 2 _U_ 121 _N_ _N_ _N_ _N_ }, [ [Char] ] 1 { _A_ 2 _U_ 221 _N_ _N_ _N_ _N_ }, [ [Int] ] 1 { _A_ 2 _U_ 221 _N_ _N_ _N_ _N_ }, [ [[Char]] ] 1 { _A_ 2 _U_ 121 _N_ _N_ _N_ _N_ }, [ [[Int]] ] 1 { _A_ 2 _U_ 121 _N_ _N_ _N_ _N_ }, [ _PackedString ] 1 { _A_ 2 _U_ 221 _N_ _N_ _N_ _N_ }, [ () ] 1 { _A_ 2 _U_ 121 _N_ _N_ _N_ _N_ } #-}
readBinChan :: [Char] -> (IOError -> [Response] -> [Request]) -> (Bin -> [Response] -> [Request]) -> [Response] -> [Request]
{-# GHC_PRAGMA _A_ 4 _U_ 2111 _N_ _N_ _N_ _N_ #-}
readBinFile :: [Char] -> (IOError -> [Response] -> [Request]) -> (Bin -> [Response] -> [Request]) -> [Response] -> [Request]
-{-# GHC_PRAGMA INTERFACE VERSION 5 #-}
+{-# GHC_PRAGMA INTERFACE VERSION 6 #-}
interface PreludeRatio where
import PreludeBuiltin(Int(..), Integer(..))
import PreludeCore(Enum(..), Eq(..), Fractional(..), Integral(..), Num(..), Ord(..), Real(..), RealFrac(..), Text(..))
{-# GHC_PRAGMA _M_ PreludeRatio {-dfun-} _A_ 2 _U_ 22 _N_ _N_ _N_ _N_ #-}
instance Enum (Ratio Integer)
{-# GHC_PRAGMA _M_ PreludeRatio {-dfun-} _A_ 0 _N_ _N_ _N_ _F_ _IF_ARGS_ 0 0 X 6 _!_ _TUP_5 [{{Ord (Ratio Integer)}}, (Ratio Integer -> [Ratio Integer]), (Ratio Integer -> Ratio Integer -> [Ratio Integer]), (Ratio Integer -> Ratio Integer -> [Ratio Integer]), (Ratio Integer -> Ratio Integer -> Ratio Integer -> [Ratio Integer])] [_DFUN_ Ord (Ratio Integer), _CONSTM_ Enum enumFrom (Ratio Integer), _CONSTM_ Enum enumFromThen (Ratio Integer), _CONSTM_ Enum enumFromTo (Ratio Integer), _CONSTM_ Enum enumFromThenTo (Ratio Integer)] _N_
- enumFrom = _A_ 1 _U_ 2 _N_ _N_ _N_ _N_,
- enumFromThen = _A_ 2 _U_ 21 _N_ _N_ _N_ _N_,
- enumFromTo = _A_ 2 _U_ 22 _N_ _N_ _N_ _N_,
- enumFromThenTo = _A_ 3 _U_ 222 _N_ _N_ _N_ _N_ #-}
+ enumFrom = { _A_ 1 _U_ 2 _N_ _N_ _N_ _N_ },
+ enumFromThen = { _A_ 2 _U_ 21 _N_ _N_ _N_ _N_ },
+ enumFromTo = { _A_ 2 _U_ 22 _N_ _N_ _N_ _N_ },
+ enumFromThenTo = { _A_ 3 _U_ 222 _N_ _N_ _N_ _N_ } #-}
instance Integral a => Eq (Ratio a)
{-# GHC_PRAGMA _M_ PreludeRatio {-dfun-} _A_ 1 _U_ 1 _N_ _N_ _N_ _N_ #-}
instance Eq (Ratio Integer)
{-# GHC_PRAGMA _M_ PreludeRatio {-dfun-} _A_ 0 _N_ _N_ _N_ _F_ _IF_ARGS_ 0 0 X 3 _!_ _TUP_2 [(Ratio Integer -> Ratio Integer -> Bool), (Ratio Integer -> Ratio Integer -> Bool)] [_CONSTM_ Eq (==) (Ratio Integer), _CONSTM_ Eq (/=) (Ratio Integer)] _N_
- (==) = _A_ 2 _U_ 11 _N_ _S_ "U(U(PPP)L)U(U(PPP)L)" {_A_ 5 _U_ 22211 _N_ _N_ _F_ _IF_ARGS_ 0 5 XXXCC 9 \ (u0 :: Int#) (u1 :: Int#) (u2 :: ByteArray#) (u3 :: Integer) (u4 :: Ratio Integer) -> case u4 of { _ALG_ (:%) (u5 :: Integer) (u6 :: Integer) -> case u5 of { _ALG_ J# (u7 :: Int#) (u8 :: Int#) (u9 :: ByteArray#) -> case _#_ cmpInteger# [] [u0, u1, u2, u7, u8, u9] of { _PRIM_ 0# -> case u3 of { _ALG_ J# (ua :: Int#) (ub :: Int#) (uc :: ByteArray#) -> case u6 of { _ALG_ J# (ud :: Int#) (ue :: Int#) (uf :: ByteArray#) -> case _#_ cmpInteger# [] [ua, ub, uc, ud, ue, uf] of { _PRIM_ 0# -> _!_ True [] []; (ug :: Int#) -> _!_ False [] [] }; _NO_DEFLT_ }; _NO_DEFLT_ }; (uh :: Int#) -> _!_ False [] [] }; _NO_DEFLT_ }; _NO_DEFLT_ } _N_} _N_ _N_,
- (/=) = _A_ 2 _U_ 11 _N_ _S_ "U(U(PPP)L)U(U(PPP)L)" {_A_ 5 _U_ 22211 _N_ _N_ _F_ _IF_ARGS_ 0 5 XXXCC 9 \ (u0 :: Int#) (u1 :: Int#) (u2 :: ByteArray#) (u3 :: Integer) (u4 :: Ratio Integer) -> case u4 of { _ALG_ (:%) (u5 :: Integer) (u6 :: Integer) -> case u5 of { _ALG_ J# (u7 :: Int#) (u8 :: Int#) (u9 :: ByteArray#) -> case _#_ cmpInteger# [] [u0, u1, u2, u7, u8, u9] of { _PRIM_ 0# -> case u3 of { _ALG_ J# (ua :: Int#) (ub :: Int#) (uc :: ByteArray#) -> case u6 of { _ALG_ J# (ud :: Int#) (ue :: Int#) (uf :: ByteArray#) -> case _#_ cmpInteger# [] [ua, ub, uc, ud, ue, uf] of { _PRIM_ 0# -> _!_ False [] []; (ug :: Int#) -> _!_ True [] [] }; _NO_DEFLT_ }; _NO_DEFLT_ }; (uh :: Int#) -> _!_ True [] [] }; _NO_DEFLT_ }; _NO_DEFLT_ } _N_} _N_ _N_ #-}
+ (==) = { _A_ 2 _U_ 11 _N_ _S_ "U(U(PPP)L)U(U(PPP)L)" {_A_ 5 _U_ 22211 _N_ _N_ _F_ _IF_ARGS_ 0 5 XXXCC 9 \ (u0 :: Int#) (u1 :: Int#) (u2 :: ByteArray#) (u3 :: Integer) (u4 :: Ratio Integer) -> case u4 of { _ALG_ (:%) (u5 :: Integer) (u6 :: Integer) -> case u5 of { _ALG_ J# (u7 :: Int#) (u8 :: Int#) (u9 :: ByteArray#) -> case _#_ cmpInteger# [] [u0, u1, u2, u7, u8, u9] of { _PRIM_ 0# -> case u3 of { _ALG_ J# (ua :: Int#) (ub :: Int#) (uc :: ByteArray#) -> case u6 of { _ALG_ J# (ud :: Int#) (ue :: Int#) (uf :: ByteArray#) -> case _#_ cmpInteger# [] [ua, ub, uc, ud, ue, uf] of { _PRIM_ 0# -> _!_ True [] []; (ug :: Int#) -> _!_ False [] [] }; _NO_DEFLT_ }; _NO_DEFLT_ }; (uh :: Int#) -> _!_ False [] [] }; _NO_DEFLT_ }; _NO_DEFLT_ } _N_} _N_ _N_ },
+ (/=) = { _A_ 2 _U_ 11 _N_ _S_ "U(U(PPP)L)U(U(PPP)L)" {_A_ 5 _U_ 22211 _N_ _N_ _F_ _IF_ARGS_ 0 5 XXXCC 9 \ (u0 :: Int#) (u1 :: Int#) (u2 :: ByteArray#) (u3 :: Integer) (u4 :: Ratio Integer) -> case u4 of { _ALG_ (:%) (u5 :: Integer) (u6 :: Integer) -> case u5 of { _ALG_ J# (u7 :: Int#) (u8 :: Int#) (u9 :: ByteArray#) -> case _#_ cmpInteger# [] [u0, u1, u2, u7, u8, u9] of { _PRIM_ 0# -> case u3 of { _ALG_ J# (ua :: Int#) (ub :: Int#) (uc :: ByteArray#) -> case u6 of { _ALG_ J# (ud :: Int#) (ue :: Int#) (uf :: ByteArray#) -> case _#_ cmpInteger# [] [ua, ub, uc, ud, ue, uf] of { _PRIM_ 0# -> _!_ False [] []; (ug :: Int#) -> _!_ True [] [] }; _NO_DEFLT_ }; _NO_DEFLT_ }; (uh :: Int#) -> _!_ True [] [] }; _NO_DEFLT_ }; _NO_DEFLT_ } _N_} _N_ _N_ } #-}
instance Integral a => Fractional (Ratio a)
{-# GHC_PRAGMA _M_ PreludeRatio {-dfun-} _A_ 2 _U_ 22 _N_ _N_ _N_ _N_ #-}
instance Fractional (Ratio Integer)
{-# GHC_PRAGMA _M_ PreludeRatio {-dfun-} _A_ 0 _N_ _N_ _N_ _F_ _IF_ARGS_ 0 0 X 5 _!_ _TUP_4 [{{Num (Ratio Integer)}}, (Ratio Integer -> Ratio Integer -> Ratio Integer), (Ratio Integer -> Ratio Integer), (Ratio Integer -> Ratio Integer)] [_DFUN_ Num (Ratio Integer), _CONSTM_ Fractional (/) (Ratio Integer), _CONSTM_ Fractional recip (Ratio Integer), _CONSTM_ Fractional fromRational (Ratio Integer)] _N_
- (/) = _A_ 2 _U_ 11 _N_ _S_ "U(LU(PPP))U(U(PPP)L)" {_A_ 5 _U_ 22221 _N_ _N_ _N_ _N_} _N_ _N_,
- recip = _A_ 1 _U_ 1 _N_ _S_ "U(U(PPP)L)" {_A_ 4 _U_ 2222 _N_ _N_ _N_ _N_} _N_ _N_,
- fromRational = _A_ 1 _U_ 1 _N_ _S_ "U(LL)" {_A_ 2 _U_ 22 _N_ _N_ _F_ _IF_ARGS_ 0 2 XX 3 \ (u0 :: Integer) (u1 :: Integer) -> _!_ (:%) [Integer] [u0, u1] _N_} _F_ _IF_ARGS_ 0 1 X 1 \ (u0 :: Ratio Integer) -> u0 _N_ #-}
+ (/) = { _A_ 2 _U_ 11 _N_ _S_ "U(LU(PPP))U(U(PPP)L)" {_A_ 5 _U_ 22221 _N_ _N_ _N_ _N_} _N_ _N_ },
+ recip = { _A_ 1 _U_ 1 _N_ _S_ "U(U(PPP)L)" {_A_ 4 _U_ 2222 _N_ _N_ _N_ _N_} _N_ _N_ },
+ fromRational = { _A_ 1 _U_ 1 _N_ _S_ "U(LL)" {_A_ 2 _U_ 22 _N_ _N_ _F_ _IF_ARGS_ 0 2 XX 3 \ (u0 :: Integer) (u1 :: Integer) -> _!_ (:%) [Integer] [u0, u1] _N_} _F_ _IF_ARGS_ 0 1 X 1 \ (u0 :: Ratio Integer) -> u0 _N_ } #-}
instance Integral a => Num (Ratio a)
{-# GHC_PRAGMA _M_ PreludeRatio {-dfun-} _A_ 3 _U_ 222 _N_ _N_ _N_ _N_ #-}
instance Num (Ratio Integer)
{-# GHC_PRAGMA _M_ PreludeRatio {-dfun-} _A_ 0 _N_ _N_ _N_ _F_ _IF_ARGS_ 0 0 X 11 _!_ _TUP_10 [{{Eq (Ratio Integer)}}, {{Text (Ratio Integer)}}, (Ratio Integer -> Ratio Integer -> Ratio Integer), (Ratio Integer -> Ratio Integer -> Ratio Integer), (Ratio Integer -> Ratio Integer -> Ratio Integer), (Ratio Integer -> Ratio Integer), (Ratio Integer -> Ratio Integer), (Ratio Integer -> Ratio Integer), (Integer -> Ratio Integer), (Int -> Ratio Integer)] [_DFUN_ Eq (Ratio Integer), _DFUN_ Text (Ratio Integer), _CONSTM_ Num (+) (Ratio Integer), _CONSTM_ Num (-) (Ratio Integer), _CONSTM_ Num (*) (Ratio Integer), _CONSTM_ Num negate (Ratio Integer), _CONSTM_ Num abs (Ratio Integer), _CONSTM_ Num signum (Ratio Integer), _CONSTM_ Num fromInteger (Ratio Integer), _CONSTM_ Num fromInt (Ratio Integer)] _N_
- (+) = _A_ 2 _U_ 11 _N_ _S_ "U(LU(PPP))U(LU(PPP))" {_A_ 5 _U_ 12221 _N_ _N_ _N_ _N_} _N_ _N_,
- (-) = _A_ 2 _U_ 11 _N_ _S_ "U(LU(PPP))U(LU(PPP))" {_A_ 5 _U_ 12221 _N_ _N_ _N_ _N_} _N_ _N_,
- (*) = _A_ 2 _U_ 11 _N_ _S_ "U(LU(PPP))U(LU(PPP))" {_A_ 5 _U_ 22221 _N_ _N_ _N_ _N_} _N_ _N_,
- negate = _A_ 1 _U_ 1 _N_ _S_ "U(LL)" {_A_ 2 _U_ 22 _N_ _N_ _N_ _N_} _N_ _N_,
- abs = _A_ 1 _U_ 1 _N_ _S_ "U(LL)" {_A_ 2 _U_ 12 _N_ _N_ _N_ _N_} _N_ _N_,
- signum = _A_ 1 _U_ 1 _N_ _S_ "U(LA)" {_A_ 1 _U_ 1 _N_ _N_ _N_ _N_} _N_ _N_,
- fromInteger = _A_ 1 _U_ 2 _N_ _N_ _N_ _N_,
- fromInt = _A_ 1 _U_ 1 _N_ _N_ _N_ _N_ #-}
+ (+) = { _A_ 2 _U_ 11 _N_ _S_ "U(LU(PPP))U(LU(PPP))" {_A_ 5 _U_ 12221 _N_ _N_ _N_ _N_} _N_ _N_ },
+ (-) = { _A_ 2 _U_ 11 _N_ _S_ "U(LU(PPP))U(LU(PPP))" {_A_ 5 _U_ 12221 _N_ _N_ _N_ _N_} _N_ _N_ },
+ (*) = { _A_ 2 _U_ 11 _N_ _S_ "U(LU(PPP))U(LU(PPP))" {_A_ 5 _U_ 22221 _N_ _N_ _N_ _N_} _N_ _N_ },
+ negate = { _A_ 1 _U_ 1 _N_ _S_ "U(LL)" {_A_ 2 _U_ 22 _N_ _N_ _N_ _N_} _N_ _N_ },
+ abs = { _A_ 1 _U_ 1 _N_ _S_ "U(LL)" {_A_ 2 _U_ 12 _N_ _N_ _N_ _N_} _N_ _N_ },
+ signum = { _A_ 1 _U_ 1 _N_ _S_ "U(LA)" {_A_ 1 _U_ 1 _N_ _N_ _N_ _N_} _N_ _N_ },
+ fromInteger = { _A_ 1 _U_ 2 _N_ _N_ _F_ _IF_ARGS_ 0 1 X 3 \ (u0 :: Integer) -> _!_ (:%) [Integer] [u0, _SPEC_ _ORIG_ PreludeCore __i1 [ (Integer) ]] _N_ },
+ fromInt = { _A_ 1 _U_ 1 _N_ _N_ _N_ _N_ } #-}
instance Integral a => Ord (Ratio a)
{-# GHC_PRAGMA _M_ PreludeRatio {-dfun-} _A_ 2 _U_ 22 _N_ _N_ _N_ _N_ #-}
instance Ord (Ratio Integer)
{-# GHC_PRAGMA _M_ PreludeRatio {-dfun-} _A_ 0 _N_ _N_ _N_ _F_ _IF_ARGS_ 0 0 X 9 _!_ _TUP_8 [{{Eq (Ratio Integer)}}, (Ratio Integer -> Ratio Integer -> Bool), (Ratio Integer -> Ratio Integer -> Bool), (Ratio Integer -> Ratio Integer -> Bool), (Ratio Integer -> Ratio Integer -> Bool), (Ratio Integer -> Ratio Integer -> Ratio Integer), (Ratio Integer -> Ratio Integer -> Ratio Integer), (Ratio Integer -> Ratio Integer -> _CMP_TAG)] [_DFUN_ Eq (Ratio Integer), _CONSTM_ Ord (<) (Ratio Integer), _CONSTM_ Ord (<=) (Ratio Integer), _CONSTM_ Ord (>=) (Ratio Integer), _CONSTM_ Ord (>) (Ratio Integer), _CONSTM_ Ord max (Ratio Integer), _CONSTM_ Ord min (Ratio Integer), _CONSTM_ Ord _tagCmp (Ratio Integer)] _N_
- (<) = _A_ 2 _U_ 11 _N_ _S_ "U(U(PPP)U(PPP))U(U(PPP)U(PPP))" {_A_ 5 _U_ 22221 _N_ _N_ _N_ _N_} _N_ _N_,
- (<=) = _A_ 2 _U_ 11 _N_ _S_ "U(U(PPP)U(PPP))U(U(PPP)U(PPP))" {_A_ 5 _U_ 22221 _N_ _N_ _N_ _N_} _N_ _N_,
- (>=) = _A_ 2 _U_ 11 _N_ _S_ "U(U(PPP)U(PPP))U(U(PPP)U(PPP))" {_A_ 5 _U_ 22221 _N_ _N_ _N_ _N_} _N_ _N_,
- (>) = _A_ 2 _U_ 11 _N_ _S_ "U(U(PPP)U(PPP))U(U(PPP)U(PPP))" {_A_ 5 _U_ 22221 _N_ _N_ _N_ _N_} _N_ _N_,
- max = _A_ 2 _U_ 12 _N_ _S_ "U(U(PPP)U(PPP))U(U(PPP)U(PPP))" {_A_ 5 _U_ 22222 _N_ _N_ _N_ _N_} _N_ _N_,
- min = _A_ 2 _U_ 12 _N_ _S_ "U(U(PPP)U(PPP))U(U(PPP)U(PPP))" {_A_ 5 _U_ 22222 _N_ _N_ _N_ _N_} _N_ _N_,
- _tagCmp = _A_ 2 _U_ 11 _N_ _S_ "U(U(PPP)U(PPP))U(U(PPP)U(PPP))" {_A_ 5 _U_ 22221 _N_ _N_ _N_ _N_} _N_ _N_ #-}
+ (<) = { _A_ 2 _U_ 11 _N_ _S_ "U(U(PPP)U(PPP))U(U(PPP)U(PPP))" {_A_ 5 _U_ 22221 _N_ _N_ _N_ _N_} _N_ _N_ },
+ (<=) = { _A_ 2 _U_ 11 _N_ _S_ "U(U(PPP)U(PPP))U(U(PPP)U(PPP))" {_A_ 5 _U_ 22221 _N_ _N_ _N_ _N_} _N_ _N_ },
+ (>=) = { _A_ 2 _U_ 11 _N_ _S_ "U(U(PPP)U(PPP))U(U(PPP)U(PPP))" {_A_ 5 _U_ 22221 _N_ _N_ _N_ _N_} _N_ _N_ },
+ (>) = { _A_ 2 _U_ 11 _N_ _S_ "U(U(PPP)U(PPP))U(U(PPP)U(PPP))" {_A_ 5 _U_ 22221 _N_ _N_ _N_ _N_} _N_ _N_ },
+ max = { _A_ 2 _U_ 12 _N_ _S_ "U(U(PPP)U(PPP))U(U(PPP)U(PPP))" {_A_ 5 _U_ 22222 _N_ _N_ _N_ _N_} _N_ _N_ },
+ min = { _A_ 2 _U_ 12 _N_ _S_ "U(U(PPP)U(PPP))U(U(PPP)U(PPP))" {_A_ 5 _U_ 22222 _N_ _N_ _N_ _N_} _N_ _N_ },
+ _tagCmp = { _A_ 2 _U_ 11 _N_ _S_ "U(U(PPP)U(PPP))U(U(PPP)U(PPP))" {_A_ 5 _U_ 22221 _N_ _N_ _N_ _N_} _N_ _N_ } #-}
instance Integral a => Real (Ratio a)
{-# GHC_PRAGMA _M_ PreludeRatio {-dfun-} _A_ 3 _U_ 122 _N_ _N_ _N_ _N_ #-}
instance Real (Ratio Integer)
{-# GHC_PRAGMA _M_ PreludeRatio {-dfun-} _A_ 0 _N_ _N_ _N_ _F_ _IF_ARGS_ 0 0 X 4 _!_ _TUP_3 [{{Num (Ratio Integer)}}, {{Enum (Ratio Integer)}}, (Ratio Integer -> Ratio Integer)] [_DFUN_ Num (Ratio Integer), _DFUN_ Enum (Ratio Integer), _CONSTM_ Real toRational (Ratio Integer)] _N_
- toRational = _A_ 1 _U_ 1 _N_ _S_ "U(LL)" {_A_ 2 _U_ 22 _N_ _N_ _F_ _IF_ARGS_ 0 2 XX 3 \ (u0 :: Integer) (u1 :: Integer) -> _!_ (:%) [Integer] [u0, u1] _N_} _F_ _IF_ARGS_ 0 1 X 1 \ (u0 :: Ratio Integer) -> u0 _N_ #-}
-instance Integral a => RealFrac (Ratio a)
- {-# GHC_PRAGMA _M_ PreludeRatio {-dfun-} _A_ 3 _U_ 222 _N_ _N_ _N_ _N_ #-}
+ toRational = { _A_ 1 _U_ 1 _N_ _S_ "U(LL)" {_A_ 2 _U_ 22 _N_ _N_ _F_ _IF_ARGS_ 0 2 XX 3 \ (u0 :: Integer) (u1 :: Integer) -> _!_ (:%) [Integer] [u0, u1] _N_} _F_ _IF_ARGS_ 0 1 X 1 \ (u0 :: Ratio Integer) -> u0 _N_ } #-}
instance RealFrac (Ratio Integer)
{-# GHC_PRAGMA _M_ PreludeRatio {-dfun-} _A_ 0 _N_ _N_ _N_ _F_ _IF_ARGS_ 0 0 X 8 _!_ _TUP_7 [{{Real (Ratio Integer)}}, {{Fractional (Ratio Integer)}}, _forall_ a$z1 =>{{Integral a$z1}} -> (Ratio Integer -> (a$z1, Ratio Integer)), _forall_ a$z1 =>{{Integral a$z1}} -> (Ratio Integer -> a$z1), _forall_ a$z1 =>{{Integral a$z1}} -> (Ratio Integer -> a$z1), _forall_ a$z1 =>{{Integral a$z1}} -> (Ratio Integer -> a$z1), _forall_ a$z1 =>{{Integral a$z1}} -> (Ratio Integer -> a$z1)] [_DFUN_ Real (Ratio Integer), _DFUN_ Fractional (Ratio Integer), _CONSTM_ RealFrac properFraction (Ratio Integer), _CONSTM_ RealFrac truncate (Ratio Integer), _CONSTM_ RealFrac round (Ratio Integer), _CONSTM_ RealFrac ceiling (Ratio Integer), _CONSTM_ RealFrac floor (Ratio Integer)] _N_
- properFraction = _A_ 2 _U_ 11 _N_ _S_ "LU(LL)" {_A_ 3 _U_ 112 _N_ _N_ _N_ _N_} _N_ _N_,
- truncate = _A_ 1 _U_ 22 _N_ _N_ _F_ _IF_ARGS_ 1 1 X 3 _/\_ u0 -> \ (u1 :: {{Integral u0}}) -> _APP_ _TYAPP_ _TYAPP_ _WRKR_ _ORIG_ PreludeCore _truncate { (Ratio Integer) } { u0 } [ _CONSTM_ RealFrac properFraction (Ratio Integer), u1 ] _N_,
- round = _A_ 1 _U_ 22 _N_ _N_ _N_ _N_,
- ceiling = _A_ 1 _U_ 22 _N_ _N_ _N_ _N_,
- floor = _A_ 1 _U_ 22 _N_ _N_ _N_ _N_ #-}
+ properFraction = { _A_ 2 _U_ 11 _N_ _S_ "LU(U(PPP)U(PPP))" {_A_ 5 _U_ 12222 _N_ _N_ _N_ _N_} _N_ _SPECIALISE_ [ Int ] 1 { _A_ 1 _U_ 1 _N_ _S_ "U(U(PPP)U(PPP))" {_A_ 4 _U_ 2222 _N_ _N_ _N_ _N_} _N_ _N_ }, [ Integer ] 1 { _A_ 1 _U_ 1 _N_ _S_ "U(U(PPP)U(PPP))" {_A_ 4 _U_ 2222 _N_ _N_ _N_ _N_} _N_ _N_ } },
+ truncate = { _A_ 2 _U_ 11 _N_ _N_ _N_ _SPECIALISE_ [ Int ] 1 { _A_ 1 _U_ 1 _N_ _S_ "U(U(PPP)U(PPP))" {_A_ 4 _U_ 2222 _N_ _N_ _F_ _IF_ARGS_ 0 4 XXXX 7 \ (u0 :: Int#) (u1 :: Int#) (u2 :: ByteArray#) (u3 :: Integer) -> case _APP_ _WRKR_ _SPEC_ _CONSTM_ RealFrac properFraction (Ratio Integer) [ (Int) ] [ u0, u1, u2, u3 ] of { _ALG_ _TUP_2 (u4 :: Int) (u5 :: Ratio Integer) -> u4; _NO_DEFLT_ } _N_} _F_ _IF_ARGS_ 0 1 X 4 \ (u0 :: Ratio Integer) -> case _APP_ _SPEC_ _CONSTM_ RealFrac properFraction (Ratio Integer) [ (Int) ] [ u0 ] of { _ALG_ _TUP_2 (u1 :: Int) (u2 :: Ratio Integer) -> u1; _NO_DEFLT_ } _N_ }, [ Integer ] 1 { _A_ 1 _U_ 1 _N_ _S_ "U(U(PPP)U(PPP))" {_A_ 4 _U_ 2222 _N_ _N_ _F_ _IF_ARGS_ 0 4 XXXX 7 \ (u0 :: Int#) (u1 :: Int#) (u2 :: ByteArray#) (u3 :: Integer) -> case _APP_ _WRKR_ _SPEC_ _CONSTM_ RealFrac properFraction (Ratio Integer) [ (Integer) ] [ u0, u1, u2, u3 ] of { _ALG_ _TUP_2 (u4 :: Integer) (u5 :: Ratio Integer) -> u4; _NO_DEFLT_ } _N_} _F_ _IF_ARGS_ 0 1 X 4 \ (u0 :: Ratio Integer) -> case _APP_ _SPEC_ _CONSTM_ RealFrac properFraction (Ratio Integer) [ (Integer) ] [ u0 ] of { _ALG_ _TUP_2 (u1 :: Integer) (u2 :: Ratio Integer) -> u1; _NO_DEFLT_ } _N_ } },
+ round = { _A_ 1 _U_ 21 _N_ _N_ _N_ _SPECIALISE_ [ Int ] 1 { _A_ 1 _U_ 1 _N_ _S_ "U(U(PPP)U(PPP))" {_A_ 4 _U_ 2222 _N_ _N_ _N_ _N_} _N_ _N_ }, [ Integer ] 1 { _A_ 1 _U_ 1 _N_ _S_ "U(U(PPP)U(PPP))" {_A_ 4 _U_ 2222 _N_ _N_ _N_ _N_} _N_ _N_ } },
+ ceiling = { _A_ 1 _U_ 21 _N_ _N_ _N_ _SPECIALISE_ [ Int ] 1 { _A_ 1 _U_ 1 _N_ _S_ "U(U(PPP)U(PPP))" {_A_ 4 _U_ 2222 _N_ _N_ _N_ _N_} _N_ _N_ }, [ Integer ] 1 { _A_ 1 _U_ 1 _N_ _S_ "U(U(PPP)U(PPP))" {_A_ 4 _U_ 2222 _N_ _N_ _N_ _N_} _N_ _N_ } },
+ floor = { _A_ 1 _U_ 21 _N_ _N_ _N_ _SPECIALISE_ [ Int ] 1 { _A_ 1 _U_ 1 _N_ _S_ "U(U(PPP)U(PPP))" {_A_ 4 _U_ 2222 _N_ _N_ _N_ _N_} _N_ _N_ }, [ Integer ] 1 { _A_ 1 _U_ 1 _N_ _S_ "U(U(PPP)U(PPP))" {_A_ 4 _U_ 2222 _N_ _N_ _N_ _N_} _N_ _N_ } } #-}
instance Integral a => Text (Ratio a)
{-# GHC_PRAGMA _M_ PreludeRatio {-dfun-} _A_ 1 _U_ 2 _N_ _N_ _N_ _N_ #-}
instance Text (Ratio Integer)
{-# GHC_PRAGMA _M_ PreludeRatio {-dfun-} _A_ 0 _N_ _N_ _N_ _F_ _IF_ARGS_ 0 0 X 5 _!_ _TUP_4 [(Int -> [Char] -> [(Ratio Integer, [Char])]), (Int -> Ratio Integer -> [Char] -> [Char]), ([Char] -> [([Ratio Integer], [Char])]), ([Ratio Integer] -> [Char] -> [Char])] [_CONSTM_ Text readsPrec (Ratio Integer), _CONSTM_ Text showsPrec (Ratio Integer), _CONSTM_ Text readList (Ratio Integer), _CONSTM_ Text showList (Ratio Integer)] _N_
- readsPrec = _A_ 1 _U_ 12 _N_ _S_ "U(P)" {_A_ 1 _U_ 22 _N_ _N_ _N_ _N_} _N_ _N_,
- showsPrec = _A_ 2 _U_ 112 _N_ _S_ "LU(LL)" {_A_ 3 _U_ 1222 _N_ _N_ _N_ _N_} _N_ _N_,
- readList = _A_ 0 _U_ 2 _N_ _N_ _N_ _N_,
- showList = _A_ 0 _U_ 12 _N_ _N_ _N_ _N_ #-}
+ readsPrec = { _A_ 1 _U_ 12 _N_ _S_ "U(P)" {_A_ 1 _U_ 22 _N_ _N_ _N_ _N_} _N_ _N_ },
+ showsPrec = { _A_ 2 _U_ 112 _N_ _S_ "LU(LL)" {_A_ 3 _U_ 1222 _N_ _N_ _N_ _N_} _N_ _N_ },
+ readList = { _A_ 0 _U_ 2 _N_ _N_ _N_ _N_ },
+ showList = { _A_ 1 _U_ 12 _N_ _N_ _N_ _N_ } #-}
import Prel ( (&&), (||), (.), otherwise, gcd, fromIntegral, id )
import PS ( _PackedString, _unpackPS )
import Text
+import TyArray
+import TyComplex
--infixl 7 %, :%
x % y = reduce (x * signum y) (abs y)
-reduce _ 0 = error "(%){PreludeRatio}: zero denominator\n"
-reduce x y = (x `quot` d) :% (y `quot` d)
+reduce x y | y == __i0 = error "(%){PreludeRatio}: zero denominator\n"
+ | otherwise = (x `quot` d) :% (y `quot` d)
where d = gcd x y
instance (Integral a) => Eq (Ratio a) where
(x1:%y1) * (x2:%y2) = reduce (x1 * x2) (y1 * y2)
negate (x:%y) = (-x) :% y
abs (x:%y) = abs x :% y
- signum (x:%y) = signum x :% 1
- fromInteger x = fromInteger x :% 1
- fromInt x = fromInt x :% 1
+ signum (x:%y) = signum x :% __i1
+ fromInteger x = fromInteger x :% __i1
+ fromInt x = fromInt x :% __i1
instance (Integral a) => Real (Ratio a) where
toRational (x:%y) = toInteger x :% toInteger y
instance (Integral a) => Fractional (Ratio a) where
(x1:%y1) / (x2:%y2) = (x1*y2) % (y1*x2)
- recip (x:%y) = if x < 0 then (-y) :% (-x) else y :% x
+ recip (x:%y) = if x < __i0 then (-y) :% (-x) else y :% x
fromRational (x:%y) = fromInteger x :% fromInteger y
-instance (Integral a) => RealFrac (Ratio a) where
- properFraction (x:%y) = (fromIntegral q, r:%y)
- where (q,r) = quotRem x y
-
- -- just call the versions in Core.hs
- truncate x = _truncate x
- round x = _round x
- ceiling x = _ceiling x
- floor x = _floor x
instance (Integral a) => Enum (Ratio a) where
- enumFrom = iterate ((+)1)
- enumFromThen n m = iterate ((+)(m-n)) n
- enumFromTo n m = takeWhile (<= m) (enumFrom n)
- enumFromThenTo n m p = takeWhile (if m >= n then (<= p) else (>= p))
- (enumFromThen n m)
+ enumFrom = iterate ((+) __i1)
+ enumFromThen n m = iterate ((+) (m-n)) n
+ enumFromTo n m = takeWhile (<= m) (enumFrom n)
+ enumFromThenTo n m p = takeWhile (if m >= n then (<= p) else (>= p))
+ (enumFromThen n m)
instance (Integral a) => Text (Ratio a) where
readsPrec p = readParen (p > prec)
- (\r -> [(x%y,u) | (x,s) <- reads r,
+ (\r -> [(x%y,u) | (x,s) <- readsPrec 0 r,
("%",t) <- lex s,
- (y,u) <- reads t ])
+ (y,u) <- readsPrec 0 t ])
showsPrec p (x:%y) = showParen (p > prec)
- (shows x . showString " % " . shows y)
+ (showsPrec 0 x . showString " % " . showsPrec 0 y)
+
+ readList = _readList (readsPrec 0)
+ showList = _showList (showsPrec 0)
{-# SPECIALIZE instance Eq (Ratio Integer) #-}
{-# SPECIALIZE instance Ord (Ratio Integer) #-}
{-# SPECIALIZE instance Num (Ratio Integer) #-}
{-# SPECIALIZE instance Real (Ratio Integer) #-}
{-# SPECIALIZE instance Fractional (Ratio Integer) #-}
-{-# SPECIALIZE instance RealFrac (Ratio Integer) #-}
{-# SPECIALIZE instance Enum (Ratio Integer) #-}
{-# SPECIALIZE instance Text (Ratio Integer) #-}
-{- ToDo: Ratio Int# ???
-#if defined(__UNBOXED_INSTANCES__)
+-- We have to give a real overlapped instance for RealFrac (Ratio Integer)
+-- since we need to give SPECIALIZE pragmas
+
+-- ToDo: Allow (ignored) SPEC pragmas in poly instance]
+-- and substitute for tyvars in a SPECIALIZED instance
+
+instance RealFrac (Ratio Integer) where
+
+ {-# SPECIALIZE properFraction :: Rational -> (Int, Rational) #-}
+ {-# SPECIALIZE truncate :: Rational -> Int #-}
+ {-# SPECIALIZE round :: Rational -> Int #-}
+ {-# SPECIALIZE ceiling :: Rational -> Int #-}
+ {-# SPECIALIZE floor :: Rational -> Int #-}
+
+ {-# SPECIALIZE properFraction :: Rational -> (Integer, Rational) #-}
+ {-# SPECIALIZE truncate :: Rational -> Integer #-}
+ {-# SPECIALIZE round :: Rational -> Integer #-}
+ {-# SPECIALIZE ceiling :: Rational -> Integer #-}
+ {-# SPECIALIZE floor :: Rational -> Integer #-}
+
+ properFraction (x:%y) = case quotRem x y of
+ (q,r) -> (fromIntegral q, r:%y)
+
+ truncate x = case properFraction x of
+ (n,_) -> n
+
+ round x = case properFraction x of
+ (n,r) -> let
+ m = if r < __i0 then n - __i1 else n + __i1
+ half_down = abs r - __rhalf
+ in
+ case (_tagCmp half_down __i0) of
+ _LT -> n
+ _EQ -> if even n then n else m
+ _GT -> m
+
+ ceiling x = case properFraction x of
+ (n,r) -> if r > __i0 then n + __i1 else n
-{-# SPECIALIZE instance Eq (Ratio Int#) #-}
-{-# SPECIALIZE instance Ord (Ratio Int#) #-}
-{-# SPECIALIZE instance Num (Ratio Int#) #-}
-{-# SPECIALIZE instance Real (Ratio Int#) #-}
-{-# SPECIALIZE instance Fractional (Ratio Int#) #-}
-{-# SPECIALIZE instance RealFrac (Ratio Int#) #-}
-{-# SPECIALIZE instance Enum (Ratio Int#) #-}
-{-# SPECIALIZE instance Text (Ratio Int#) #-}
+ floor x = case properFraction x of
+ (n,r) -> if r < __i0 then n - __i1 else n
-#endif
--}
-- approxRational, applied to two real fractional numbers x and epsilon,
-- returns the simplest rational number within epsilon of x. A rational
-- and abs r' < d', and the simplest rational is q%1 + the reciprocal of
-- the simplest rational between d'%r' and d%r.
---{-# GENERATE_SPECS approxRational a{Double#,Double} #-}
-{-# GENERATE_SPECS approxRational a{Double} #-}
+{-# GENERATE_SPECS approxRational a{Double#,Double} #-}
approxRational :: (RealFrac a) => a -> a -> Rational
approxRational x eps = simplest (x-eps) (x+eps)
| x == y = xr
| x > 0 = simplest' n d n' d'
| y < 0 = - simplest' (-n') d' (-n) d
- | otherwise = 0 :% 1
+ | otherwise = __i0
where xr@(n:%d) = toRational x
(n':%d') = toRational y
simplest' n d n' d' -- assumes 0 < n%d < n'%d'
- | r == 0 = q :% 1
- | q /= q' = (q+1) :% 1
+ | r == __i0 = q :% __i1
+ | q /= q' = (q + __i1) :% __i1
| otherwise = (q*n''+d'') :% n''
where (q,r) = quotRem n d
(q',r') = quotRem n' d'
-{-# GHC_PRAGMA INTERFACE VERSION 5 #-}
+{-# GHC_PRAGMA INTERFACE VERSION 6 #-}
interface PreludeRatio where
import PreludeBuiltin(Int(..), Integer(..))
import PreludeCore(Enum(..), Eq(..), Fractional(..), Integral(..), Num(..), Ord(..), Real(..), RealFrac(..), Text(..))
{-# GHC_PRAGMA _M_ PreludeRatio {-dfun-} _A_ 2 _U_ 22 _N_ _N_ _N_ _N_ #-}
instance Enum (Ratio Integer)
{-# GHC_PRAGMA _M_ PreludeRatio {-dfun-} _A_ 0 _N_ _N_ _N_ _F_ _IF_ARGS_ 0 0 X 6 _!_ _TUP_5 [{{Ord (Ratio Integer)}}, (Ratio Integer -> [Ratio Integer]), (Ratio Integer -> Ratio Integer -> [Ratio Integer]), (Ratio Integer -> Ratio Integer -> [Ratio Integer]), (Ratio Integer -> Ratio Integer -> Ratio Integer -> [Ratio Integer])] [_DFUN_ Ord (Ratio Integer), _CONSTM_ Enum enumFrom (Ratio Integer), _CONSTM_ Enum enumFromThen (Ratio Integer), _CONSTM_ Enum enumFromTo (Ratio Integer), _CONSTM_ Enum enumFromThenTo (Ratio Integer)] _N_
- enumFrom = _A_ 1 _U_ 2 _N_ _N_ _N_ _N_,
- enumFromThen = _A_ 2 _U_ 21 _N_ _N_ _N_ _N_,
- enumFromTo = _A_ 2 _U_ 22 _N_ _N_ _N_ _N_,
- enumFromThenTo = _A_ 3 _U_ 222 _N_ _N_ _N_ _N_ #-}
+ enumFrom = { _A_ 1 _U_ 2 _N_ _N_ _N_ _N_ },
+ enumFromThen = { _A_ 2 _U_ 21 _N_ _N_ _N_ _N_ },
+ enumFromTo = { _A_ 2 _U_ 22 _N_ _N_ _N_ _N_ },
+ enumFromThenTo = { _A_ 3 _U_ 222 _N_ _N_ _N_ _N_ } #-}
instance Integral a => Eq (Ratio a)
{-# GHC_PRAGMA _M_ PreludeRatio {-dfun-} _A_ 1 _U_ 1 _N_ _N_ _N_ _N_ #-}
instance Eq (Ratio Integer)
{-# GHC_PRAGMA _M_ PreludeRatio {-dfun-} _A_ 0 _N_ _N_ _N_ _F_ _IF_ARGS_ 0 0 X 3 _!_ _TUP_2 [(Ratio Integer -> Ratio Integer -> Bool), (Ratio Integer -> Ratio Integer -> Bool)] [_CONSTM_ Eq (==) (Ratio Integer), _CONSTM_ Eq (/=) (Ratio Integer)] _N_
- (==) = _A_ 2 _U_ 11 _N_ _S_ "U(U(PPP)L)U(U(PPP)L)" {_A_ 5 _U_ 22211 _N_ _N_ _F_ _IF_ARGS_ 0 5 XXXCC 9 \ (u0 :: Int#) (u1 :: Int#) (u2 :: ByteArray#) (u3 :: Integer) (u4 :: Ratio Integer) -> case u4 of { _ALG_ (:%) (u5 :: Integer) (u6 :: Integer) -> case u5 of { _ALG_ J# (u7 :: Int#) (u8 :: Int#) (u9 :: ByteArray#) -> case _#_ cmpInteger# [] [u0, u1, u2, u7, u8, u9] of { _PRIM_ 0# -> case u3 of { _ALG_ J# (ua :: Int#) (ub :: Int#) (uc :: ByteArray#) -> case u6 of { _ALG_ J# (ud :: Int#) (ue :: Int#) (uf :: ByteArray#) -> case _#_ cmpInteger# [] [ua, ub, uc, ud, ue, uf] of { _PRIM_ 0# -> _!_ True [] []; (ug :: Int#) -> _!_ False [] [] }; _NO_DEFLT_ }; _NO_DEFLT_ }; (uh :: Int#) -> _!_ False [] [] }; _NO_DEFLT_ }; _NO_DEFLT_ } _N_} _N_ _N_,
- (/=) = _A_ 2 _U_ 11 _N_ _S_ "U(U(PPP)L)U(U(PPP)L)" {_A_ 5 _U_ 22211 _N_ _N_ _F_ _IF_ARGS_ 0 5 XXXCC 9 \ (u0 :: Int#) (u1 :: Int#) (u2 :: ByteArray#) (u3 :: Integer) (u4 :: Ratio Integer) -> case u4 of { _ALG_ (:%) (u5 :: Integer) (u6 :: Integer) -> case u5 of { _ALG_ J# (u7 :: Int#) (u8 :: Int#) (u9 :: ByteArray#) -> case _#_ cmpInteger# [] [u0, u1, u2, u7, u8, u9] of { _PRIM_ 0# -> case u3 of { _ALG_ J# (ua :: Int#) (ub :: Int#) (uc :: ByteArray#) -> case u6 of { _ALG_ J# (ud :: Int#) (ue :: Int#) (uf :: ByteArray#) -> case _#_ cmpInteger# [] [ua, ub, uc, ud, ue, uf] of { _PRIM_ 0# -> _!_ False [] []; (ug :: Int#) -> _!_ True [] [] }; _NO_DEFLT_ }; _NO_DEFLT_ }; (uh :: Int#) -> _!_ True [] [] }; _NO_DEFLT_ }; _NO_DEFLT_ } _N_} _N_ _N_ #-}
+ (==) = { _A_ 2 _U_ 11 _N_ _S_ "U(U(PPP)L)U(U(PPP)L)" {_A_ 5 _U_ 22211 _N_ _N_ _F_ _IF_ARGS_ 0 5 XXXCC 9 \ (u0 :: Int#) (u1 :: Int#) (u2 :: ByteArray#) (u3 :: Integer) (u4 :: Ratio Integer) -> case u4 of { _ALG_ (:%) (u5 :: Integer) (u6 :: Integer) -> case u5 of { _ALG_ J# (u7 :: Int#) (u8 :: Int#) (u9 :: ByteArray#) -> case _#_ cmpInteger# [] [u0, u1, u2, u7, u8, u9] of { _PRIM_ 0# -> case u3 of { _ALG_ J# (ua :: Int#) (ub :: Int#) (uc :: ByteArray#) -> case u6 of { _ALG_ J# (ud :: Int#) (ue :: Int#) (uf :: ByteArray#) -> case _#_ cmpInteger# [] [ua, ub, uc, ud, ue, uf] of { _PRIM_ 0# -> _!_ True [] []; (ug :: Int#) -> _!_ False [] [] }; _NO_DEFLT_ }; _NO_DEFLT_ }; (uh :: Int#) -> _!_ False [] [] }; _NO_DEFLT_ }; _NO_DEFLT_ } _N_} _N_ _N_ },
+ (/=) = { _A_ 2 _U_ 11 _N_ _S_ "U(U(PPP)L)U(U(PPP)L)" {_A_ 5 _U_ 22211 _N_ _N_ _F_ _IF_ARGS_ 0 5 XXXCC 9 \ (u0 :: Int#) (u1 :: Int#) (u2 :: ByteArray#) (u3 :: Integer) (u4 :: Ratio Integer) -> case u4 of { _ALG_ (:%) (u5 :: Integer) (u6 :: Integer) -> case u5 of { _ALG_ J# (u7 :: Int#) (u8 :: Int#) (u9 :: ByteArray#) -> case _#_ cmpInteger# [] [u0, u1, u2, u7, u8, u9] of { _PRIM_ 0# -> case u3 of { _ALG_ J# (ua :: Int#) (ub :: Int#) (uc :: ByteArray#) -> case u6 of { _ALG_ J# (ud :: Int#) (ue :: Int#) (uf :: ByteArray#) -> case _#_ cmpInteger# [] [ua, ub, uc, ud, ue, uf] of { _PRIM_ 0# -> _!_ False [] []; (ug :: Int#) -> _!_ True [] [] }; _NO_DEFLT_ }; _NO_DEFLT_ }; (uh :: Int#) -> _!_ True [] [] }; _NO_DEFLT_ }; _NO_DEFLT_ } _N_} _N_ _N_ } #-}
instance Integral a => Fractional (Ratio a)
{-# GHC_PRAGMA _M_ PreludeRatio {-dfun-} _A_ 2 _U_ 22 _N_ _N_ _N_ _N_ #-}
instance Fractional (Ratio Integer)
{-# GHC_PRAGMA _M_ PreludeRatio {-dfun-} _A_ 0 _N_ _N_ _N_ _F_ _IF_ARGS_ 0 0 X 5 _!_ _TUP_4 [{{Num (Ratio Integer)}}, (Ratio Integer -> Ratio Integer -> Ratio Integer), (Ratio Integer -> Ratio Integer), (Ratio Integer -> Ratio Integer)] [_DFUN_ Num (Ratio Integer), _CONSTM_ Fractional (/) (Ratio Integer), _CONSTM_ Fractional recip (Ratio Integer), _CONSTM_ Fractional fromRational (Ratio Integer)] _N_
- (/) = _A_ 2 _U_ 11 _N_ _S_ "U(LU(PPP))U(U(PPP)L)" {_A_ 5 _U_ 22221 _N_ _N_ _N_ _N_} _N_ _N_,
- recip = _A_ 1 _U_ 1 _N_ _S_ "U(U(PPP)L)" {_A_ 4 _U_ 2222 _N_ _N_ _N_ _N_} _N_ _N_,
- fromRational = _A_ 1 _U_ 1 _N_ _S_ "U(LL)" {_A_ 2 _U_ 22 _N_ _N_ _F_ _IF_ARGS_ 0 2 XX 3 \ (u0 :: Integer) (u1 :: Integer) -> _!_ (:%) [Integer] [u0, u1] _N_} _F_ _IF_ARGS_ 0 1 X 1 \ (u0 :: Ratio Integer) -> u0 _N_ #-}
+ (/) = { _A_ 2 _U_ 11 _N_ _S_ "U(LU(PPP))U(U(PPP)L)" {_A_ 5 _U_ 22221 _N_ _N_ _N_ _N_} _N_ _N_ },
+ recip = { _A_ 1 _U_ 1 _N_ _S_ "U(U(PPP)L)" {_A_ 4 _U_ 2222 _N_ _N_ _N_ _N_} _N_ _N_ },
+ fromRational = { _A_ 1 _U_ 1 _N_ _S_ "U(LL)" {_A_ 2 _U_ 22 _N_ _N_ _F_ _IF_ARGS_ 0 2 XX 3 \ (u0 :: Integer) (u1 :: Integer) -> _!_ (:%) [Integer] [u0, u1] _N_} _F_ _IF_ARGS_ 0 1 X 1 \ (u0 :: Ratio Integer) -> u0 _N_ } #-}
instance Integral a => Num (Ratio a)
{-# GHC_PRAGMA _M_ PreludeRatio {-dfun-} _A_ 3 _U_ 222 _N_ _N_ _N_ _N_ #-}
instance Num (Ratio Integer)
{-# GHC_PRAGMA _M_ PreludeRatio {-dfun-} _A_ 0 _N_ _N_ _N_ _F_ _IF_ARGS_ 0 0 X 11 _!_ _TUP_10 [{{Eq (Ratio Integer)}}, {{Text (Ratio Integer)}}, (Ratio Integer -> Ratio Integer -> Ratio Integer), (Ratio Integer -> Ratio Integer -> Ratio Integer), (Ratio Integer -> Ratio Integer -> Ratio Integer), (Ratio Integer -> Ratio Integer), (Ratio Integer -> Ratio Integer), (Ratio Integer -> Ratio Integer), (Integer -> Ratio Integer), (Int -> Ratio Integer)] [_DFUN_ Eq (Ratio Integer), _DFUN_ Text (Ratio Integer), _CONSTM_ Num (+) (Ratio Integer), _CONSTM_ Num (-) (Ratio Integer), _CONSTM_ Num (*) (Ratio Integer), _CONSTM_ Num negate (Ratio Integer), _CONSTM_ Num abs (Ratio Integer), _CONSTM_ Num signum (Ratio Integer), _CONSTM_ Num fromInteger (Ratio Integer), _CONSTM_ Num fromInt (Ratio Integer)] _N_
- (+) = _A_ 2 _U_ 11 _N_ _S_ "U(LU(PPP))U(LU(PPP))" {_A_ 5 _U_ 12221 _N_ _N_ _N_ _N_} _N_ _N_,
- (-) = _A_ 2 _U_ 11 _N_ _S_ "U(LU(PPP))U(LU(PPP))" {_A_ 5 _U_ 12221 _N_ _N_ _N_ _N_} _N_ _N_,
- (*) = _A_ 2 _U_ 11 _N_ _S_ "U(LU(PPP))U(LU(PPP))" {_A_ 5 _U_ 22221 _N_ _N_ _N_ _N_} _N_ _N_,
- negate = _A_ 1 _U_ 1 _N_ _S_ "U(LL)" {_A_ 2 _U_ 22 _N_ _N_ _N_ _N_} _N_ _N_,
- abs = _A_ 1 _U_ 1 _N_ _S_ "U(LL)" {_A_ 2 _U_ 12 _N_ _N_ _N_ _N_} _N_ _N_,
- signum = _A_ 1 _U_ 1 _N_ _S_ "U(LA)" {_A_ 1 _U_ 1 _N_ _N_ _N_ _N_} _N_ _N_,
- fromInteger = _A_ 1 _U_ 2 _N_ _N_ _N_ _N_,
- fromInt = _A_ 1 _U_ 1 _N_ _N_ _N_ _N_ #-}
+ (+) = { _A_ 2 _U_ 11 _N_ _S_ "U(LU(PPP))U(LU(PPP))" {_A_ 5 _U_ 12221 _N_ _N_ _N_ _N_} _N_ _N_ },
+ (-) = { _A_ 2 _U_ 11 _N_ _S_ "U(LU(PPP))U(LU(PPP))" {_A_ 5 _U_ 12221 _N_ _N_ _N_ _N_} _N_ _N_ },
+ (*) = { _A_ 2 _U_ 11 _N_ _S_ "U(LU(PPP))U(LU(PPP))" {_A_ 5 _U_ 22221 _N_ _N_ _N_ _N_} _N_ _N_ },
+ negate = { _A_ 1 _U_ 1 _N_ _S_ "U(LL)" {_A_ 2 _U_ 22 _N_ _N_ _N_ _N_} _N_ _N_ },
+ abs = { _A_ 1 _U_ 1 _N_ _S_ "U(LL)" {_A_ 2 _U_ 12 _N_ _N_ _N_ _N_} _N_ _N_ },
+ signum = { _A_ 1 _U_ 1 _N_ _S_ "U(LA)" {_A_ 1 _U_ 1 _N_ _N_ _N_ _N_} _N_ _N_ },
+ fromInteger = { _A_ 1 _U_ 2 _N_ _N_ _F_ _IF_ARGS_ 0 1 X 3 \ (u0 :: Integer) -> _!_ (:%) [Integer] [u0, _SPEC_ _ORIG_ PreludeCore __i1 [ (Integer) ]] _N_ },
+ fromInt = { _A_ 1 _U_ 1 _N_ _N_ _N_ _N_ } #-}
instance Integral a => Ord (Ratio a)
{-# GHC_PRAGMA _M_ PreludeRatio {-dfun-} _A_ 2 _U_ 22 _N_ _N_ _N_ _N_ #-}
instance Ord (Ratio Integer)
{-# GHC_PRAGMA _M_ PreludeRatio {-dfun-} _A_ 0 _N_ _N_ _N_ _F_ _IF_ARGS_ 0 0 X 9 _!_ _TUP_8 [{{Eq (Ratio Integer)}}, (Ratio Integer -> Ratio Integer -> Bool), (Ratio Integer -> Ratio Integer -> Bool), (Ratio Integer -> Ratio Integer -> Bool), (Ratio Integer -> Ratio Integer -> Bool), (Ratio Integer -> Ratio Integer -> Ratio Integer), (Ratio Integer -> Ratio Integer -> Ratio Integer), (Ratio Integer -> Ratio Integer -> _CMP_TAG)] [_DFUN_ Eq (Ratio Integer), _CONSTM_ Ord (<) (Ratio Integer), _CONSTM_ Ord (<=) (Ratio Integer), _CONSTM_ Ord (>=) (Ratio Integer), _CONSTM_ Ord (>) (Ratio Integer), _CONSTM_ Ord max (Ratio Integer), _CONSTM_ Ord min (Ratio Integer), _CONSTM_ Ord _tagCmp (Ratio Integer)] _N_
- (<) = _A_ 2 _U_ 11 _N_ _S_ "U(U(PPP)U(PPP))U(U(PPP)U(PPP))" {_A_ 5 _U_ 22221 _N_ _N_ _N_ _N_} _N_ _N_,
- (<=) = _A_ 2 _U_ 11 _N_ _S_ "U(U(PPP)U(PPP))U(U(PPP)U(PPP))" {_A_ 5 _U_ 22221 _N_ _N_ _N_ _N_} _N_ _N_,
- (>=) = _A_ 2 _U_ 11 _N_ _S_ "U(U(PPP)U(PPP))U(U(PPP)U(PPP))" {_A_ 5 _U_ 22221 _N_ _N_ _N_ _N_} _N_ _N_,
- (>) = _A_ 2 _U_ 11 _N_ _S_ "U(U(PPP)U(PPP))U(U(PPP)U(PPP))" {_A_ 5 _U_ 22221 _N_ _N_ _N_ _N_} _N_ _N_,
- max = _A_ 2 _U_ 12 _N_ _S_ "U(U(PPP)U(PPP))U(U(PPP)U(PPP))" {_A_ 5 _U_ 22222 _N_ _N_ _N_ _N_} _N_ _N_,
- min = _A_ 2 _U_ 12 _N_ _S_ "U(U(PPP)U(PPP))U(U(PPP)U(PPP))" {_A_ 5 _U_ 22222 _N_ _N_ _N_ _N_} _N_ _N_,
- _tagCmp = _A_ 2 _U_ 11 _N_ _S_ "U(U(PPP)U(PPP))U(U(PPP)U(PPP))" {_A_ 5 _U_ 22221 _N_ _N_ _N_ _N_} _N_ _N_ #-}
+ (<) = { _A_ 2 _U_ 11 _N_ _S_ "U(U(PPP)U(PPP))U(U(PPP)U(PPP))" {_A_ 5 _U_ 22221 _N_ _N_ _N_ _N_} _N_ _N_ },
+ (<=) = { _A_ 2 _U_ 11 _N_ _S_ "U(U(PPP)U(PPP))U(U(PPP)U(PPP))" {_A_ 5 _U_ 22221 _N_ _N_ _N_ _N_} _N_ _N_ },
+ (>=) = { _A_ 2 _U_ 11 _N_ _S_ "U(U(PPP)U(PPP))U(U(PPP)U(PPP))" {_A_ 5 _U_ 22221 _N_ _N_ _N_ _N_} _N_ _N_ },
+ (>) = { _A_ 2 _U_ 11 _N_ _S_ "U(U(PPP)U(PPP))U(U(PPP)U(PPP))" {_A_ 5 _U_ 22221 _N_ _N_ _N_ _N_} _N_ _N_ },
+ max = { _A_ 2 _U_ 12 _N_ _S_ "U(U(PPP)U(PPP))U(U(PPP)U(PPP))" {_A_ 5 _U_ 22222 _N_ _N_ _N_ _N_} _N_ _N_ },
+ min = { _A_ 2 _U_ 12 _N_ _S_ "U(U(PPP)U(PPP))U(U(PPP)U(PPP))" {_A_ 5 _U_ 22222 _N_ _N_ _N_ _N_} _N_ _N_ },
+ _tagCmp = { _A_ 2 _U_ 11 _N_ _S_ "U(U(PPP)U(PPP))U(U(PPP)U(PPP))" {_A_ 5 _U_ 22221 _N_ _N_ _N_ _N_} _N_ _N_ } #-}
instance Integral a => Real (Ratio a)
{-# GHC_PRAGMA _M_ PreludeRatio {-dfun-} _A_ 3 _U_ 122 _N_ _N_ _N_ _N_ #-}
instance Real (Ratio Integer)
{-# GHC_PRAGMA _M_ PreludeRatio {-dfun-} _A_ 0 _N_ _N_ _N_ _F_ _IF_ARGS_ 0 0 X 4 _!_ _TUP_3 [{{Num (Ratio Integer)}}, {{Enum (Ratio Integer)}}, (Ratio Integer -> Ratio Integer)] [_DFUN_ Num (Ratio Integer), _DFUN_ Enum (Ratio Integer), _CONSTM_ Real toRational (Ratio Integer)] _N_
- toRational = _A_ 1 _U_ 1 _N_ _S_ "U(LL)" {_A_ 2 _U_ 22 _N_ _N_ _F_ _IF_ARGS_ 0 2 XX 3 \ (u0 :: Integer) (u1 :: Integer) -> _!_ (:%) [Integer] [u0, u1] _N_} _F_ _IF_ARGS_ 0 1 X 1 \ (u0 :: Ratio Integer) -> u0 _N_ #-}
-instance Integral a => RealFrac (Ratio a)
- {-# GHC_PRAGMA _M_ PreludeRatio {-dfun-} _A_ 3 _U_ 222 _N_ _N_ _N_ _N_ #-}
+ toRational = { _A_ 1 _U_ 1 _N_ _S_ "U(LL)" {_A_ 2 _U_ 22 _N_ _N_ _F_ _IF_ARGS_ 0 2 XX 3 \ (u0 :: Integer) (u1 :: Integer) -> _!_ (:%) [Integer] [u0, u1] _N_} _F_ _IF_ARGS_ 0 1 X 1 \ (u0 :: Ratio Integer) -> u0 _N_ } #-}
instance RealFrac (Ratio Integer)
{-# GHC_PRAGMA _M_ PreludeRatio {-dfun-} _A_ 0 _N_ _N_ _N_ _F_ _IF_ARGS_ 0 0 X 8 _!_ _TUP_7 [{{Real (Ratio Integer)}}, {{Fractional (Ratio Integer)}}, _forall_ a$z1 =>{{Integral a$z1}} -> (Ratio Integer -> (a$z1, Ratio Integer)), _forall_ a$z1 =>{{Integral a$z1}} -> (Ratio Integer -> a$z1), _forall_ a$z1 =>{{Integral a$z1}} -> (Ratio Integer -> a$z1), _forall_ a$z1 =>{{Integral a$z1}} -> (Ratio Integer -> a$z1), _forall_ a$z1 =>{{Integral a$z1}} -> (Ratio Integer -> a$z1)] [_DFUN_ Real (Ratio Integer), _DFUN_ Fractional (Ratio Integer), _CONSTM_ RealFrac properFraction (Ratio Integer), _CONSTM_ RealFrac truncate (Ratio Integer), _CONSTM_ RealFrac round (Ratio Integer), _CONSTM_ RealFrac ceiling (Ratio Integer), _CONSTM_ RealFrac floor (Ratio Integer)] _N_
- properFraction = _A_ 2 _U_ 11 _N_ _S_ "LU(LL)" {_A_ 3 _U_ 112 _N_ _N_ _N_ _N_} _N_ _N_,
- truncate = _A_ 1 _U_ 22 _N_ _N_ _F_ _IF_ARGS_ 1 1 X 3 _/\_ u0 -> \ (u1 :: {{Integral u0}}) -> _APP_ _TYAPP_ _TYAPP_ _WRKR_ _ORIG_ PreludeCore _truncate { (Ratio Integer) } { u0 } [ _CONSTM_ RealFrac properFraction (Ratio Integer), u1 ] _N_,
- round = _A_ 1 _U_ 22 _N_ _N_ _N_ _N_,
- ceiling = _A_ 1 _U_ 22 _N_ _N_ _N_ _N_,
- floor = _A_ 1 _U_ 22 _N_ _N_ _N_ _N_ #-}
+ properFraction = { _A_ 2 _U_ 11 _N_ _S_ "LU(U(PPP)U(PPP))" {_A_ 5 _U_ 12222 _N_ _N_ _N_ _N_} _N_ _SPECIALISE_ [ Int ] 1 { _A_ 1 _U_ 1 _N_ _S_ "U(U(PPP)U(PPP))" {_A_ 4 _U_ 2222 _N_ _N_ _N_ _N_} _N_ _N_ }, [ Integer ] 1 { _A_ 1 _U_ 1 _N_ _S_ "U(U(PPP)U(PPP))" {_A_ 4 _U_ 2222 _N_ _N_ _N_ _N_} _N_ _N_ } },
+ truncate = { _A_ 2 _U_ 11 _N_ _N_ _N_ _SPECIALISE_ [ Int ] 1 { _A_ 1 _U_ 1 _N_ _S_ "U(U(PPP)U(PPP))" {_A_ 4 _U_ 2222 _N_ _N_ _F_ _IF_ARGS_ 0 4 XXXX 7 \ (u0 :: Int#) (u1 :: Int#) (u2 :: ByteArray#) (u3 :: Integer) -> case _APP_ _WRKR_ _SPEC_ _CONSTM_ RealFrac properFraction (Ratio Integer) [ (Int) ] [ u0, u1, u2, u3 ] of { _ALG_ _TUP_2 (u4 :: Int) (u5 :: Ratio Integer) -> u4; _NO_DEFLT_ } _N_} _F_ _IF_ARGS_ 0 1 X 4 \ (u0 :: Ratio Integer) -> case _APP_ _SPEC_ _CONSTM_ RealFrac properFraction (Ratio Integer) [ (Int) ] [ u0 ] of { _ALG_ _TUP_2 (u1 :: Int) (u2 :: Ratio Integer) -> u1; _NO_DEFLT_ } _N_ }, [ Integer ] 1 { _A_ 1 _U_ 1 _N_ _S_ "U(U(PPP)U(PPP))" {_A_ 4 _U_ 2222 _N_ _N_ _F_ _IF_ARGS_ 0 4 XXXX 7 \ (u0 :: Int#) (u1 :: Int#) (u2 :: ByteArray#) (u3 :: Integer) -> case _APP_ _WRKR_ _SPEC_ _CONSTM_ RealFrac properFraction (Ratio Integer) [ (Integer) ] [ u0, u1, u2, u3 ] of { _ALG_ _TUP_2 (u4 :: Integer) (u5 :: Ratio Integer) -> u4; _NO_DEFLT_ } _N_} _F_ _IF_ARGS_ 0 1 X 4 \ (u0 :: Ratio Integer) -> case _APP_ _SPEC_ _CONSTM_ RealFrac properFraction (Ratio Integer) [ (Integer) ] [ u0 ] of { _ALG_ _TUP_2 (u1 :: Integer) (u2 :: Ratio Integer) -> u1; _NO_DEFLT_ } _N_ } },
+ round = { _A_ 1 _U_ 21 _N_ _N_ _N_ _SPECIALISE_ [ Int ] 1 { _A_ 1 _U_ 1 _N_ _S_ "U(U(PPP)U(PPP))" {_A_ 4 _U_ 2222 _N_ _N_ _N_ _N_} _N_ _N_ }, [ Integer ] 1 { _A_ 1 _U_ 1 _N_ _S_ "U(U(PPP)U(PPP))" {_A_ 4 _U_ 2222 _N_ _N_ _N_ _N_} _N_ _N_ } },
+ ceiling = { _A_ 1 _U_ 21 _N_ _N_ _N_ _SPECIALISE_ [ Int ] 1 { _A_ 1 _U_ 1 _N_ _S_ "U(U(PPP)U(PPP))" {_A_ 4 _U_ 2222 _N_ _N_ _N_ _N_} _N_ _N_ }, [ Integer ] 1 { _A_ 1 _U_ 1 _N_ _S_ "U(U(PPP)U(PPP))" {_A_ 4 _U_ 2222 _N_ _N_ _N_ _N_} _N_ _N_ } },
+ floor = { _A_ 1 _U_ 21 _N_ _N_ _N_ _SPECIALISE_ [ Int ] 1 { _A_ 1 _U_ 1 _N_ _S_ "U(U(PPP)U(PPP))" {_A_ 4 _U_ 2222 _N_ _N_ _N_ _N_} _N_ _N_ }, [ Integer ] 1 { _A_ 1 _U_ 1 _N_ _S_ "U(U(PPP)U(PPP))" {_A_ 4 _U_ 2222 _N_ _N_ _N_ _N_} _N_ _N_ } } #-}
instance Integral a => Text (Ratio a)
{-# GHC_PRAGMA _M_ PreludeRatio {-dfun-} _A_ 1 _U_ 2 _N_ _N_ _N_ _N_ #-}
instance Text (Ratio Integer)
{-# GHC_PRAGMA _M_ PreludeRatio {-dfun-} _A_ 0 _N_ _N_ _N_ _F_ _IF_ARGS_ 0 0 X 5 _!_ _TUP_4 [(Int -> [Char] -> [(Ratio Integer, [Char])]), (Int -> Ratio Integer -> [Char] -> [Char]), ([Char] -> [([Ratio Integer], [Char])]), ([Ratio Integer] -> [Char] -> [Char])] [_CONSTM_ Text readsPrec (Ratio Integer), _CONSTM_ Text showsPrec (Ratio Integer), _CONSTM_ Text readList (Ratio Integer), _CONSTM_ Text showList (Ratio Integer)] _N_
- readsPrec = _A_ 1 _U_ 12 _N_ _S_ "U(P)" {_A_ 1 _U_ 22 _N_ _N_ _N_ _N_} _N_ _N_,
- showsPrec = _A_ 2 _U_ 112 _N_ _S_ "LU(LL)" {_A_ 3 _U_ 1222 _N_ _N_ _N_ _N_} _N_ _N_,
- readList = _A_ 0 _U_ 2 _N_ _N_ _N_ _N_,
- showList = _A_ 0 _U_ 12 _N_ _N_ _N_ _N_ #-}
+ readsPrec = { _A_ 1 _U_ 12 _N_ _S_ "U(P)" {_A_ 1 _U_ 22 _N_ _N_ _N_ _N_} _N_ _N_ },
+ showsPrec = { _A_ 2 _U_ 112 _N_ _S_ "LU(LL)" {_A_ 3 _U_ 1222 _N_ _N_ _N_ _N_} _N_ _N_ },
+ readList = { _A_ 0 _U_ 2 _N_ _N_ _N_ _N_ },
+ showList = { _A_ 1 _U_ 12 _N_ _N_ _N_ _N_ } #-}
instance Integral a => RealFrac (Ratio a)
{-# GHC_PRAGMA _M_ PreludeRatio {-dfun-} _A_ 3 _U_ 222 _N_ _N_ _N_ _N_ #-}
instance RealFrac (Ratio Integer)
- {-# GHC_PRAGMA _M_ PreludeRatio {-dfun-} _A_ 0 _N_ _N_ _N_ _F_ _IF_ARGS_ 0 0 X 8 _!_ _TUP_7 [{{Real (Ratio Integer)}}, {{Fractional (Ratio Integer)}}, _forall_ a$z1 =>{{Integral a$z1}} -> (Ratio Integer -> (a$z1, Ratio Integer)), _forall_ a$z1 =>{{Integral a$z1}} -> (Ratio Integer -> a$z1), _forall_ a$z1 =>{{Integral a$z1}} -> (Ratio Integer -> a$z1), _forall_ a$z1 =>{{Integral a$z1}} -> (Ratio Integer -> a$z1), _forall_ a$z1 =>{{Integral a$z1}} -> (Ratio Integer -> a$z1)] [_DFUN_ Real (Ratio Integer), _DFUN_ Fractional (Ratio Integer), _CONSTM_ RealFrac properFraction (Ratio Integer), _CONSTM_ RealFrac truncate (Ratio Integer), _CONSTM_ RealFrac round (Ratio Integer), _CONSTM_ RealFrac ceiling (Ratio Integer), _CONSTM_ RealFrac floor (Ratio Integer)] _N_
- properFraction = _A_ 2 _U_ 11 _N_ _S_ "LU(LL)" {_A_ 3 _U_ 112 _N_ _N_ _N_ _N_} _N_ _N_,
- truncate = _A_ 1 _U_ 22 _N_ _N_ _F_ _IF_ARGS_ 1 1 X 3 _/\_ u0 -> \ (u1 :: {{Integral u0}}) -> _APP_ _TYAPP_ _TYAPP_ _WRKR_ _ORIG_ PreludeCore _truncate { (Ratio Integer) } { u0 } [ _CONSTM_ RealFrac properFraction (Ratio Integer), u1 ] _N_,
- round = _A_ 1 _U_ 22 _N_ _N_ _N_ _N_,
- ceiling = _A_ 1 _U_ 22 _N_ _N_ _N_ _N_,
- floor = _A_ 1 _U_ 22 _N_ _N_ _N_ _N_ #-}
instance Integral a => Text (Ratio a)
{-# GHC_PRAGMA _M_ PreludeRatio {-dfun-} _A_ 1 _U_ 2 _N_ _N_ _N_ _N_ #-}
instance Text (Ratio Integer)
-{-# GHC_PRAGMA INTERFACE VERSION 5 #-}
+{-# GHC_PRAGMA INTERFACE VERSION 6 #-}
interface PreludeRatio where
import PreludeBuiltin(Int(..), Integer(..))
import PreludeCore(Enum(..), Eq(..), Fractional(..), Integral(..), Num(..), Ord(..), Real(..), RealFrac(..), Text(..))
{-# GHC_PRAGMA _M_ PreludeRatio {-dfun-} _A_ 2 _U_ 22 _N_ _N_ _N_ _N_ #-}
instance Enum (Ratio Integer)
{-# GHC_PRAGMA _M_ PreludeRatio {-dfun-} _A_ 0 _N_ _N_ _N_ _F_ _IF_ARGS_ 0 0 X 6 _!_ _TUP_5 [{{Ord (Ratio Integer)}}, (Ratio Integer -> [Ratio Integer]), (Ratio Integer -> Ratio Integer -> [Ratio Integer]), (Ratio Integer -> Ratio Integer -> [Ratio Integer]), (Ratio Integer -> Ratio Integer -> Ratio Integer -> [Ratio Integer])] [_DFUN_ Ord (Ratio Integer), _CONSTM_ Enum enumFrom (Ratio Integer), _CONSTM_ Enum enumFromThen (Ratio Integer), _CONSTM_ Enum enumFromTo (Ratio Integer), _CONSTM_ Enum enumFromThenTo (Ratio Integer)] _N_
- enumFrom = _A_ 1 _U_ 2 _N_ _N_ _N_ _N_,
- enumFromThen = _A_ 2 _U_ 21 _N_ _N_ _N_ _N_,
- enumFromTo = _A_ 2 _U_ 22 _N_ _N_ _N_ _N_,
- enumFromThenTo = _A_ 3 _U_ 222 _N_ _N_ _N_ _N_ #-}
+ enumFrom = { _A_ 1 _U_ 2 _N_ _N_ _N_ _N_ },
+ enumFromThen = { _A_ 2 _U_ 21 _N_ _N_ _N_ _N_ },
+ enumFromTo = { _A_ 2 _U_ 22 _N_ _N_ _N_ _N_ },
+ enumFromThenTo = { _A_ 3 _U_ 222 _N_ _N_ _N_ _N_ } #-}
instance Integral a => Eq (Ratio a)
{-# GHC_PRAGMA _M_ PreludeRatio {-dfun-} _A_ 1 _U_ 1 _N_ _N_ _N_ _N_ #-}
instance Eq (Ratio Integer)
{-# GHC_PRAGMA _M_ PreludeRatio {-dfun-} _A_ 0 _N_ _N_ _N_ _F_ _IF_ARGS_ 0 0 X 3 _!_ _TUP_2 [(Ratio Integer -> Ratio Integer -> Bool), (Ratio Integer -> Ratio Integer -> Bool)] [_CONSTM_ Eq (==) (Ratio Integer), _CONSTM_ Eq (/=) (Ratio Integer)] _N_
- (==) = _A_ 2 _U_ 11 _N_ _S_ "U(U(PPP)L)U(U(PPP)L)" {_A_ 5 _U_ 22211 _N_ _N_ _F_ _IF_ARGS_ 0 5 XXXCC 9 \ (u0 :: Int#) (u1 :: Int#) (u2 :: ByteArray#) (u3 :: Integer) (u4 :: Ratio Integer) -> case u4 of { _ALG_ (:%) (u5 :: Integer) (u6 :: Integer) -> case u5 of { _ALG_ J# (u7 :: Int#) (u8 :: Int#) (u9 :: ByteArray#) -> case _#_ cmpInteger# [] [u0, u1, u2, u7, u8, u9] of { _PRIM_ 0# -> case u3 of { _ALG_ J# (ua :: Int#) (ub :: Int#) (uc :: ByteArray#) -> case u6 of { _ALG_ J# (ud :: Int#) (ue :: Int#) (uf :: ByteArray#) -> case _#_ cmpInteger# [] [ua, ub, uc, ud, ue, uf] of { _PRIM_ 0# -> _!_ True [] []; (ug :: Int#) -> _!_ False [] [] }; _NO_DEFLT_ }; _NO_DEFLT_ }; (uh :: Int#) -> _!_ False [] [] }; _NO_DEFLT_ }; _NO_DEFLT_ } _N_} _N_ _N_,
- (/=) = _A_ 2 _U_ 11 _N_ _S_ "U(U(PPP)L)U(U(PPP)L)" {_A_ 5 _U_ 22211 _N_ _N_ _F_ _IF_ARGS_ 0 5 XXXCC 9 \ (u0 :: Int#) (u1 :: Int#) (u2 :: ByteArray#) (u3 :: Integer) (u4 :: Ratio Integer) -> case u4 of { _ALG_ (:%) (u5 :: Integer) (u6 :: Integer) -> case u5 of { _ALG_ J# (u7 :: Int#) (u8 :: Int#) (u9 :: ByteArray#) -> case _#_ cmpInteger# [] [u0, u1, u2, u7, u8, u9] of { _PRIM_ 0# -> case u3 of { _ALG_ J# (ua :: Int#) (ub :: Int#) (uc :: ByteArray#) -> case u6 of { _ALG_ J# (ud :: Int#) (ue :: Int#) (uf :: ByteArray#) -> case _#_ cmpInteger# [] [ua, ub, uc, ud, ue, uf] of { _PRIM_ 0# -> _!_ False [] []; (ug :: Int#) -> _!_ True [] [] }; _NO_DEFLT_ }; _NO_DEFLT_ }; (uh :: Int#) -> _!_ True [] [] }; _NO_DEFLT_ }; _NO_DEFLT_ } _N_} _N_ _N_ #-}
+ (==) = { _A_ 2 _U_ 11 _N_ _S_ "U(U(PPP)L)U(U(PPP)L)" {_A_ 5 _U_ 22211 _N_ _N_ _F_ _IF_ARGS_ 0 5 XXXCC 9 \ (u0 :: Int#) (u1 :: Int#) (u2 :: ByteArray#) (u3 :: Integer) (u4 :: Ratio Integer) -> case u4 of { _ALG_ (:%) (u5 :: Integer) (u6 :: Integer) -> case u5 of { _ALG_ J# (u7 :: Int#) (u8 :: Int#) (u9 :: ByteArray#) -> case _#_ cmpInteger# [] [u0, u1, u2, u7, u8, u9] of { _PRIM_ 0# -> case u3 of { _ALG_ J# (ua :: Int#) (ub :: Int#) (uc :: ByteArray#) -> case u6 of { _ALG_ J# (ud :: Int#) (ue :: Int#) (uf :: ByteArray#) -> case _#_ cmpInteger# [] [ua, ub, uc, ud, ue, uf] of { _PRIM_ 0# -> _!_ True [] []; (ug :: Int#) -> _!_ False [] [] }; _NO_DEFLT_ }; _NO_DEFLT_ }; (uh :: Int#) -> _!_ False [] [] }; _NO_DEFLT_ }; _NO_DEFLT_ } _N_} _N_ _N_ },
+ (/=) = { _A_ 2 _U_ 11 _N_ _S_ "U(U(PPP)L)U(U(PPP)L)" {_A_ 5 _U_ 22211 _N_ _N_ _F_ _IF_ARGS_ 0 5 XXXCC 9 \ (u0 :: Int#) (u1 :: Int#) (u2 :: ByteArray#) (u3 :: Integer) (u4 :: Ratio Integer) -> case u4 of { _ALG_ (:%) (u5 :: Integer) (u6 :: Integer) -> case u5 of { _ALG_ J# (u7 :: Int#) (u8 :: Int#) (u9 :: ByteArray#) -> case _#_ cmpInteger# [] [u0, u1, u2, u7, u8, u9] of { _PRIM_ 0# -> case u3 of { _ALG_ J# (ua :: Int#) (ub :: Int#) (uc :: ByteArray#) -> case u6 of { _ALG_ J# (ud :: Int#) (ue :: Int#) (uf :: ByteArray#) -> case _#_ cmpInteger# [] [ua, ub, uc, ud, ue, uf] of { _PRIM_ 0# -> _!_ False [] []; (ug :: Int#) -> _!_ True [] [] }; _NO_DEFLT_ }; _NO_DEFLT_ }; (uh :: Int#) -> _!_ True [] [] }; _NO_DEFLT_ }; _NO_DEFLT_ } _N_} _N_ _N_ } #-}
instance Integral a => Fractional (Ratio a)
{-# GHC_PRAGMA _M_ PreludeRatio {-dfun-} _A_ 2 _U_ 22 _N_ _N_ _N_ _N_ #-}
instance Fractional (Ratio Integer)
{-# GHC_PRAGMA _M_ PreludeRatio {-dfun-} _A_ 0 _N_ _N_ _N_ _F_ _IF_ARGS_ 0 0 X 5 _!_ _TUP_4 [{{Num (Ratio Integer)}}, (Ratio Integer -> Ratio Integer -> Ratio Integer), (Ratio Integer -> Ratio Integer), (Ratio Integer -> Ratio Integer)] [_DFUN_ Num (Ratio Integer), _CONSTM_ Fractional (/) (Ratio Integer), _CONSTM_ Fractional recip (Ratio Integer), _CONSTM_ Fractional fromRational (Ratio Integer)] _N_
- (/) = _A_ 2 _U_ 11 _N_ _S_ "U(LU(PPP))U(U(PPP)L)" {_A_ 5 _U_ 22221 _N_ _N_ _N_ _N_} _N_ _N_,
- recip = _A_ 1 _U_ 1 _N_ _S_ "U(U(PPP)L)" {_A_ 4 _U_ 2222 _N_ _N_ _N_ _N_} _N_ _N_,
- fromRational = _A_ 1 _U_ 1 _N_ _S_ "U(LL)" {_A_ 2 _U_ 22 _N_ _N_ _F_ _IF_ARGS_ 0 2 XX 3 \ (u0 :: Integer) (u1 :: Integer) -> _!_ (:%) [Integer] [u0, u1] _N_} _F_ _IF_ARGS_ 0 1 X 1 \ (u0 :: Ratio Integer) -> u0 _N_ #-}
+ (/) = { _A_ 2 _U_ 11 _N_ _S_ "U(LU(PPP))U(U(PPP)L)" {_A_ 5 _U_ 22221 _N_ _N_ _N_ _N_} _N_ _N_ },
+ recip = { _A_ 1 _U_ 1 _N_ _S_ "U(U(PPP)L)" {_A_ 4 _U_ 2222 _N_ _N_ _N_ _N_} _N_ _N_ },
+ fromRational = { _A_ 1 _U_ 1 _N_ _S_ "U(LL)" {_A_ 2 _U_ 22 _N_ _N_ _F_ _IF_ARGS_ 0 2 XX 3 \ (u0 :: Integer) (u1 :: Integer) -> _!_ (:%) [Integer] [u0, u1] _N_} _F_ _IF_ARGS_ 0 1 X 1 \ (u0 :: Ratio Integer) -> u0 _N_ } #-}
instance Integral a => Num (Ratio a)
{-# GHC_PRAGMA _M_ PreludeRatio {-dfun-} _A_ 3 _U_ 222 _N_ _N_ _N_ _N_ #-}
instance Num (Ratio Integer)
{-# GHC_PRAGMA _M_ PreludeRatio {-dfun-} _A_ 0 _N_ _N_ _N_ _F_ _IF_ARGS_ 0 0 X 11 _!_ _TUP_10 [{{Eq (Ratio Integer)}}, {{Text (Ratio Integer)}}, (Ratio Integer -> Ratio Integer -> Ratio Integer), (Ratio Integer -> Ratio Integer -> Ratio Integer), (Ratio Integer -> Ratio Integer -> Ratio Integer), (Ratio Integer -> Ratio Integer), (Ratio Integer -> Ratio Integer), (Ratio Integer -> Ratio Integer), (Integer -> Ratio Integer), (Int -> Ratio Integer)] [_DFUN_ Eq (Ratio Integer), _DFUN_ Text (Ratio Integer), _CONSTM_ Num (+) (Ratio Integer), _CONSTM_ Num (-) (Ratio Integer), _CONSTM_ Num (*) (Ratio Integer), _CONSTM_ Num negate (Ratio Integer), _CONSTM_ Num abs (Ratio Integer), _CONSTM_ Num signum (Ratio Integer), _CONSTM_ Num fromInteger (Ratio Integer), _CONSTM_ Num fromInt (Ratio Integer)] _N_
- (+) = _A_ 2 _U_ 11 _N_ _S_ "U(LU(PPP))U(LU(PPP))" {_A_ 5 _U_ 12221 _N_ _N_ _N_ _N_} _N_ _N_,
- (-) = _A_ 2 _U_ 11 _N_ _S_ "U(LU(PPP))U(LU(PPP))" {_A_ 5 _U_ 12221 _N_ _N_ _N_ _N_} _N_ _N_,
- (*) = _A_ 2 _U_ 11 _N_ _S_ "U(LU(PPP))U(LU(PPP))" {_A_ 5 _U_ 22221 _N_ _N_ _N_ _N_} _N_ _N_,
- negate = _A_ 1 _U_ 1 _N_ _S_ "U(LL)" {_A_ 2 _U_ 22 _N_ _N_ _N_ _N_} _N_ _N_,
- abs = _A_ 1 _U_ 1 _N_ _S_ "U(LL)" {_A_ 2 _U_ 12 _N_ _N_ _N_ _N_} _N_ _N_,
- signum = _A_ 1 _U_ 1 _N_ _S_ "U(LA)" {_A_ 1 _U_ 1 _N_ _N_ _N_ _N_} _N_ _N_,
- fromInteger = _A_ 1 _U_ 2 _N_ _N_ _N_ _N_,
- fromInt = _A_ 1 _U_ 1 _N_ _N_ _N_ _N_ #-}
+ (+) = { _A_ 2 _U_ 11 _N_ _S_ "U(LU(PPP))U(LU(PPP))" {_A_ 5 _U_ 12221 _N_ _N_ _N_ _N_} _N_ _N_ },
+ (-) = { _A_ 2 _U_ 11 _N_ _S_ "U(LU(PPP))U(LU(PPP))" {_A_ 5 _U_ 12221 _N_ _N_ _N_ _N_} _N_ _N_ },
+ (*) = { _A_ 2 _U_ 11 _N_ _S_ "U(LU(PPP))U(LU(PPP))" {_A_ 5 _U_ 22221 _N_ _N_ _N_ _N_} _N_ _N_ },
+ negate = { _A_ 1 _U_ 1 _N_ _S_ "U(LL)" {_A_ 2 _U_ 22 _N_ _N_ _N_ _N_} _N_ _N_ },
+ abs = { _A_ 1 _U_ 1 _N_ _S_ "U(LL)" {_A_ 2 _U_ 12 _N_ _N_ _N_ _N_} _N_ _N_ },
+ signum = { _A_ 1 _U_ 1 _N_ _S_ "U(LA)" {_A_ 1 _U_ 1 _N_ _N_ _N_ _N_} _N_ _N_ },
+ fromInteger = { _A_ 1 _U_ 2 _N_ _N_ _F_ _IF_ARGS_ 0 1 X 3 \ (u0 :: Integer) -> _!_ (:%) [Integer] [u0, _SPEC_ _ORIG_ PreludeCore __i1 [ (Integer) ]] _N_ },
+ fromInt = { _A_ 1 _U_ 1 _N_ _N_ _N_ _N_ } #-}
instance Integral a => Ord (Ratio a)
{-# GHC_PRAGMA _M_ PreludeRatio {-dfun-} _A_ 2 _U_ 22 _N_ _N_ _N_ _N_ #-}
instance Ord (Ratio Integer)
{-# GHC_PRAGMA _M_ PreludeRatio {-dfun-} _A_ 0 _N_ _N_ _N_ _F_ _IF_ARGS_ 0 0 X 9 _!_ _TUP_8 [{{Eq (Ratio Integer)}}, (Ratio Integer -> Ratio Integer -> Bool), (Ratio Integer -> Ratio Integer -> Bool), (Ratio Integer -> Ratio Integer -> Bool), (Ratio Integer -> Ratio Integer -> Bool), (Ratio Integer -> Ratio Integer -> Ratio Integer), (Ratio Integer -> Ratio Integer -> Ratio Integer), (Ratio Integer -> Ratio Integer -> _CMP_TAG)] [_DFUN_ Eq (Ratio Integer), _CONSTM_ Ord (<) (Ratio Integer), _CONSTM_ Ord (<=) (Ratio Integer), _CONSTM_ Ord (>=) (Ratio Integer), _CONSTM_ Ord (>) (Ratio Integer), _CONSTM_ Ord max (Ratio Integer), _CONSTM_ Ord min (Ratio Integer), _CONSTM_ Ord _tagCmp (Ratio Integer)] _N_
- (<) = _A_ 2 _U_ 11 _N_ _S_ "U(U(PPP)U(PPP))U(U(PPP)U(PPP))" {_A_ 5 _U_ 22221 _N_ _N_ _N_ _N_} _N_ _N_,
- (<=) = _A_ 2 _U_ 11 _N_ _S_ "U(U(PPP)U(PPP))U(U(PPP)U(PPP))" {_A_ 5 _U_ 22221 _N_ _N_ _N_ _N_} _N_ _N_,
- (>=) = _A_ 2 _U_ 11 _N_ _S_ "U(U(PPP)U(PPP))U(U(PPP)U(PPP))" {_A_ 5 _U_ 22221 _N_ _N_ _N_ _N_} _N_ _N_,
- (>) = _A_ 2 _U_ 11 _N_ _S_ "U(U(PPP)U(PPP))U(U(PPP)U(PPP))" {_A_ 5 _U_ 22221 _N_ _N_ _N_ _N_} _N_ _N_,
- max = _A_ 2 _U_ 12 _N_ _S_ "U(U(PPP)U(PPP))U(U(PPP)U(PPP))" {_A_ 5 _U_ 22222 _N_ _N_ _N_ _N_} _N_ _N_,
- min = _A_ 2 _U_ 12 _N_ _S_ "U(U(PPP)U(PPP))U(U(PPP)U(PPP))" {_A_ 5 _U_ 22222 _N_ _N_ _N_ _N_} _N_ _N_,
- _tagCmp = _A_ 2 _U_ 11 _N_ _S_ "U(U(PPP)U(PPP))U(U(PPP)U(PPP))" {_A_ 5 _U_ 22221 _N_ _N_ _N_ _N_} _N_ _N_ #-}
+ (<) = { _A_ 2 _U_ 11 _N_ _S_ "U(U(PPP)U(PPP))U(U(PPP)U(PPP))" {_A_ 5 _U_ 22221 _N_ _N_ _N_ _N_} _N_ _N_ },
+ (<=) = { _A_ 2 _U_ 11 _N_ _S_ "U(U(PPP)U(PPP))U(U(PPP)U(PPP))" {_A_ 5 _U_ 22221 _N_ _N_ _N_ _N_} _N_ _N_ },
+ (>=) = { _A_ 2 _U_ 11 _N_ _S_ "U(U(PPP)U(PPP))U(U(PPP)U(PPP))" {_A_ 5 _U_ 22221 _N_ _N_ _N_ _N_} _N_ _N_ },
+ (>) = { _A_ 2 _U_ 11 _N_ _S_ "U(U(PPP)U(PPP))U(U(PPP)U(PPP))" {_A_ 5 _U_ 22221 _N_ _N_ _N_ _N_} _N_ _N_ },
+ max = { _A_ 2 _U_ 12 _N_ _S_ "U(U(PPP)U(PPP))U(U(PPP)U(PPP))" {_A_ 5 _U_ 22222 _N_ _N_ _N_ _N_} _N_ _N_ },
+ min = { _A_ 2 _U_ 12 _N_ _S_ "U(U(PPP)U(PPP))U(U(PPP)U(PPP))" {_A_ 5 _U_ 22222 _N_ _N_ _N_ _N_} _N_ _N_ },
+ _tagCmp = { _A_ 2 _U_ 11 _N_ _S_ "U(U(PPP)U(PPP))U(U(PPP)U(PPP))" {_A_ 5 _U_ 22221 _N_ _N_ _N_ _N_} _N_ _N_ } #-}
instance Integral a => Real (Ratio a)
{-# GHC_PRAGMA _M_ PreludeRatio {-dfun-} _A_ 3 _U_ 122 _N_ _N_ _N_ _N_ #-}
instance Real (Ratio Integer)
{-# GHC_PRAGMA _M_ PreludeRatio {-dfun-} _A_ 0 _N_ _N_ _N_ _F_ _IF_ARGS_ 0 0 X 4 _!_ _TUP_3 [{{Num (Ratio Integer)}}, {{Enum (Ratio Integer)}}, (Ratio Integer -> Ratio Integer)] [_DFUN_ Num (Ratio Integer), _DFUN_ Enum (Ratio Integer), _CONSTM_ Real toRational (Ratio Integer)] _N_
- toRational = _A_ 1 _U_ 1 _N_ _S_ "U(LL)" {_A_ 2 _U_ 22 _N_ _N_ _F_ _IF_ARGS_ 0 2 XX 3 \ (u0 :: Integer) (u1 :: Integer) -> _!_ (:%) [Integer] [u0, u1] _N_} _F_ _IF_ARGS_ 0 1 X 1 \ (u0 :: Ratio Integer) -> u0 _N_ #-}
-instance Integral a => RealFrac (Ratio a)
- {-# GHC_PRAGMA _M_ PreludeRatio {-dfun-} _A_ 3 _U_ 222 _N_ _N_ _N_ _N_ #-}
+ toRational = { _A_ 1 _U_ 1 _N_ _S_ "U(LL)" {_A_ 2 _U_ 22 _N_ _N_ _F_ _IF_ARGS_ 0 2 XX 3 \ (u0 :: Integer) (u1 :: Integer) -> _!_ (:%) [Integer] [u0, u1] _N_} _F_ _IF_ARGS_ 0 1 X 1 \ (u0 :: Ratio Integer) -> u0 _N_ } #-}
instance RealFrac (Ratio Integer)
{-# GHC_PRAGMA _M_ PreludeRatio {-dfun-} _A_ 0 _N_ _N_ _N_ _F_ _IF_ARGS_ 0 0 X 8 _!_ _TUP_7 [{{Real (Ratio Integer)}}, {{Fractional (Ratio Integer)}}, _forall_ a$z1 =>{{Integral a$z1}} -> (Ratio Integer -> (a$z1, Ratio Integer)), _forall_ a$z1 =>{{Integral a$z1}} -> (Ratio Integer -> a$z1), _forall_ a$z1 =>{{Integral a$z1}} -> (Ratio Integer -> a$z1), _forall_ a$z1 =>{{Integral a$z1}} -> (Ratio Integer -> a$z1), _forall_ a$z1 =>{{Integral a$z1}} -> (Ratio Integer -> a$z1)] [_DFUN_ Real (Ratio Integer), _DFUN_ Fractional (Ratio Integer), _CONSTM_ RealFrac properFraction (Ratio Integer), _CONSTM_ RealFrac truncate (Ratio Integer), _CONSTM_ RealFrac round (Ratio Integer), _CONSTM_ RealFrac ceiling (Ratio Integer), _CONSTM_ RealFrac floor (Ratio Integer)] _N_
- properFraction = _A_ 2 _U_ 11 _N_ _S_ "LU(LL)" {_A_ 3 _U_ 112 _N_ _N_ _N_ _N_} _N_ _N_,
- truncate = _A_ 1 _U_ 22 _N_ _N_ _F_ _IF_ARGS_ 1 1 X 3 _/\_ u0 -> \ (u1 :: {{Integral u0}}) -> _APP_ _TYAPP_ _TYAPP_ _WRKR_ _ORIG_ PreludeCore _truncate { (Ratio Integer) } { u0 } [ _CONSTM_ RealFrac properFraction (Ratio Integer), u1 ] _N_,
- round = _A_ 1 _U_ 22 _N_ _N_ _N_ _N_,
- ceiling = _A_ 1 _U_ 22 _N_ _N_ _N_ _N_,
- floor = _A_ 1 _U_ 22 _N_ _N_ _N_ _N_ #-}
+ properFraction = { _A_ 2 _U_ 11 _N_ _S_ "LU(U(PPP)U(PPP))" {_A_ 5 _U_ 12222 _N_ _N_ _N_ _N_} _N_ _SPECIALISE_ [ Int ] 1 { _A_ 1 _U_ 1 _N_ _S_ "U(U(PPP)U(PPP))" {_A_ 4 _U_ 2222 _N_ _N_ _N_ _N_} _N_ _N_ }, [ Integer ] 1 { _A_ 1 _U_ 1 _N_ _S_ "U(U(PPP)U(PPP))" {_A_ 4 _U_ 2222 _N_ _N_ _N_ _N_} _N_ _N_ } },
+ truncate = { _A_ 2 _U_ 11 _N_ _N_ _N_ _SPECIALISE_ [ Int ] 1 { _A_ 1 _U_ 1 _N_ _S_ "U(U(PPP)U(PPP))" {_A_ 4 _U_ 2222 _N_ _N_ _F_ _IF_ARGS_ 0 4 XXXX 7 \ (u0 :: Int#) (u1 :: Int#) (u2 :: ByteArray#) (u3 :: Integer) -> case _APP_ _WRKR_ _SPEC_ _CONSTM_ RealFrac properFraction (Ratio Integer) [ (Int) ] [ u0, u1, u2, u3 ] of { _ALG_ _TUP_2 (u4 :: Int) (u5 :: Ratio Integer) -> u4; _NO_DEFLT_ } _N_} _F_ _IF_ARGS_ 0 1 X 4 \ (u0 :: Ratio Integer) -> case _APP_ _SPEC_ _CONSTM_ RealFrac properFraction (Ratio Integer) [ (Int) ] [ u0 ] of { _ALG_ _TUP_2 (u1 :: Int) (u2 :: Ratio Integer) -> u1; _NO_DEFLT_ } _N_ }, [ Integer ] 1 { _A_ 1 _U_ 1 _N_ _S_ "U(U(PPP)U(PPP))" {_A_ 4 _U_ 2222 _N_ _N_ _F_ _IF_ARGS_ 0 4 XXXX 7 \ (u0 :: Int#) (u1 :: Int#) (u2 :: ByteArray#) (u3 :: Integer) -> case _APP_ _WRKR_ _SPEC_ _CONSTM_ RealFrac properFraction (Ratio Integer) [ (Integer) ] [ u0, u1, u2, u3 ] of { _ALG_ _TUP_2 (u4 :: Integer) (u5 :: Ratio Integer) -> u4; _NO_DEFLT_ } _N_} _F_ _IF_ARGS_ 0 1 X 4 \ (u0 :: Ratio Integer) -> case _APP_ _SPEC_ _CONSTM_ RealFrac properFraction (Ratio Integer) [ (Integer) ] [ u0 ] of { _ALG_ _TUP_2 (u1 :: Integer) (u2 :: Ratio Integer) -> u1; _NO_DEFLT_ } _N_ } },
+ round = { _A_ 1 _U_ 21 _N_ _N_ _N_ _SPECIALISE_ [ Int ] 1 { _A_ 1 _U_ 1 _N_ _S_ "U(U(PPP)U(PPP))" {_A_ 4 _U_ 2222 _N_ _N_ _N_ _N_} _N_ _N_ }, [ Integer ] 1 { _A_ 1 _U_ 1 _N_ _S_ "U(U(PPP)U(PPP))" {_A_ 4 _U_ 2222 _N_ _N_ _N_ _N_} _N_ _N_ } },
+ ceiling = { _A_ 1 _U_ 21 _N_ _N_ _N_ _SPECIALISE_ [ Int ] 1 { _A_ 1 _U_ 1 _N_ _S_ "U(U(PPP)U(PPP))" {_A_ 4 _U_ 2222 _N_ _N_ _N_ _N_} _N_ _N_ }, [ Integer ] 1 { _A_ 1 _U_ 1 _N_ _S_ "U(U(PPP)U(PPP))" {_A_ 4 _U_ 2222 _N_ _N_ _N_ _N_} _N_ _N_ } },
+ floor = { _A_ 1 _U_ 21 _N_ _N_ _N_ _SPECIALISE_ [ Int ] 1 { _A_ 1 _U_ 1 _N_ _S_ "U(U(PPP)U(PPP))" {_A_ 4 _U_ 2222 _N_ _N_ _N_ _N_} _N_ _N_ }, [ Integer ] 1 { _A_ 1 _U_ 1 _N_ _S_ "U(U(PPP)U(PPP))" {_A_ 4 _U_ 2222 _N_ _N_ _N_ _N_} _N_ _N_ } } #-}
instance Integral a => Text (Ratio a)
{-# GHC_PRAGMA _M_ PreludeRatio {-dfun-} _A_ 1 _U_ 2 _N_ _N_ _N_ _N_ #-}
instance Text (Ratio Integer)
{-# GHC_PRAGMA _M_ PreludeRatio {-dfun-} _A_ 0 _N_ _N_ _N_ _F_ _IF_ARGS_ 0 0 X 5 _!_ _TUP_4 [(Int -> [Char] -> [(Ratio Integer, [Char])]), (Int -> Ratio Integer -> [Char] -> [Char]), ([Char] -> [([Ratio Integer], [Char])]), ([Ratio Integer] -> [Char] -> [Char])] [_CONSTM_ Text readsPrec (Ratio Integer), _CONSTM_ Text showsPrec (Ratio Integer), _CONSTM_ Text readList (Ratio Integer), _CONSTM_ Text showList (Ratio Integer)] _N_
- readsPrec = _A_ 1 _U_ 12 _N_ _S_ "U(P)" {_A_ 1 _U_ 22 _N_ _N_ _N_ _N_} _N_ _N_,
- showsPrec = _A_ 2 _U_ 112 _N_ _S_ "LU(LL)" {_A_ 3 _U_ 1222 _N_ _N_ _N_ _N_} _N_ _N_,
- readList = _A_ 0 _U_ 2 _N_ _N_ _N_ _N_,
- showList = _A_ 0 _U_ 12 _N_ _N_ _N_ _N_ #-}
+ readsPrec = { _A_ 1 _U_ 12 _N_ _S_ "U(P)" {_A_ 1 _U_ 22 _N_ _N_ _N_ _N_} _N_ _N_ },
+ showsPrec = { _A_ 2 _U_ 112 _N_ _S_ "LU(LL)" {_A_ 3 _U_ 1222 _N_ _N_ _N_ _N_} _N_ _N_ },
+ readList = { _A_ 0 _U_ 2 _N_ _N_ _N_ _N_ },
+ showList = { _A_ 1 _U_ 12 _N_ _N_ _N_ _N_ } #-}
instance Integral a => RealFrac (Ratio a)
{-# GHC_PRAGMA _M_ PreludeRatio {-dfun-} _A_ 3 _U_ 222 _N_ _N_ _N_ _N_ #-}
instance RealFrac (Ratio Integer)
- {-# GHC_PRAGMA _M_ PreludeRatio {-dfun-} _A_ 0 _N_ _N_ _N_ _F_ _IF_ARGS_ 0 0 X 8 _!_ _TUP_7 [{{Real (Ratio Integer)}}, {{Fractional (Ratio Integer)}}, _forall_ a$z1 =>{{Integral a$z1}} -> (Ratio Integer -> (a$z1, Ratio Integer)), _forall_ a$z1 =>{{Integral a$z1}} -> (Ratio Integer -> a$z1), _forall_ a$z1 =>{{Integral a$z1}} -> (Ratio Integer -> a$z1), _forall_ a$z1 =>{{Integral a$z1}} -> (Ratio Integer -> a$z1), _forall_ a$z1 =>{{Integral a$z1}} -> (Ratio Integer -> a$z1)] [_DFUN_ Real (Ratio Integer), _DFUN_ Fractional (Ratio Integer), _CONSTM_ RealFrac properFraction (Ratio Integer), _CONSTM_ RealFrac truncate (Ratio Integer), _CONSTM_ RealFrac round (Ratio Integer), _CONSTM_ RealFrac ceiling (Ratio Integer), _CONSTM_ RealFrac floor (Ratio Integer)] _N_
- properFraction = _A_ 2 _U_ 11 _N_ _S_ "LU(LL)" {_A_ 3 _U_ 112 _N_ _N_ _N_ _N_} _N_ _N_,
- truncate = _A_ 1 _U_ 22 _N_ _N_ _F_ _IF_ARGS_ 1 1 X 3 _/\_ u0 -> \ (u1 :: {{Integral u0}}) -> _APP_ _TYAPP_ _TYAPP_ _WRKR_ _ORIG_ PreludeCore _truncate { (Ratio Integer) } { u0 } [ _CONSTM_ RealFrac properFraction (Ratio Integer), u1 ] _N_,
- round = _A_ 1 _U_ 22 _N_ _N_ _N_ _N_,
- ceiling = _A_ 1 _U_ 22 _N_ _N_ _N_ _N_,
- floor = _A_ 1 _U_ 22 _N_ _N_ _N_ _N_ #-}
instance Integral a => Text (Ratio a)
{-# GHC_PRAGMA _M_ PreludeRatio {-dfun-} _A_ 1 _U_ 2 _N_ _N_ _N_ _N_ #-}
instance Text (Ratio Integer)
instance Integral a => RealFrac (Ratio a)
{-# GHC_PRAGMA _M_ PreludeRatio {-dfun-} _A_ 3 _U_ 222 _N_ _N_ _N_ _N_ #-}
instance RealFrac (Ratio Integer)
- {-# GHC_PRAGMA _M_ PreludeRatio {-dfun-} _A_ 0 _N_ _N_ _N_ _F_ _IF_ARGS_ 0 0 X 8 _!_ _TUP_7 [{{Real (Ratio Integer)}}, {{Fractional (Ratio Integer)}}, _forall_ a$z1 =>{{Integral a$z1}} -> (Ratio Integer -> (a$z1, Ratio Integer)), _forall_ a$z1 =>{{Integral a$z1}} -> (Ratio Integer -> a$z1), _forall_ a$z1 =>{{Integral a$z1}} -> (Ratio Integer -> a$z1), _forall_ a$z1 =>{{Integral a$z1}} -> (Ratio Integer -> a$z1), _forall_ a$z1 =>{{Integral a$z1}} -> (Ratio Integer -> a$z1)] [_DFUN_ Real (Ratio Integer), _DFUN_ Fractional (Ratio Integer), _CONSTM_ RealFrac properFraction (Ratio Integer), _CONSTM_ RealFrac truncate (Ratio Integer), _CONSTM_ RealFrac round (Ratio Integer), _CONSTM_ RealFrac ceiling (Ratio Integer), _CONSTM_ RealFrac floor (Ratio Integer)] _N_
- properFraction = _A_ 2 _U_ 11 _N_ _S_ "LU(LL)" {_A_ 3 _U_ 112 _N_ _N_ _N_ _N_} _N_ _N_,
- truncate = _A_ 1 _U_ 22 _N_ _N_ _F_ _IF_ARGS_ 1 1 X 3 _/\_ u0 -> \ (u1 :: {{Integral u0}}) -> _APP_ _TYAPP_ _TYAPP_ _WRKR_ _ORIG_ PreludeCore _truncate { (Ratio Integer) } { u0 } [ _CONSTM_ RealFrac properFraction (Ratio Integer), u1 ] _N_,
- round = _A_ 1 _U_ 22 _N_ _N_ _N_ _N_,
- ceiling = _A_ 1 _U_ 22 _N_ _N_ _N_ _N_,
- floor = _A_ 1 _U_ 22 _N_ _N_ _N_ _N_ #-}
instance Integral a => Text (Ratio a)
{-# GHC_PRAGMA _M_ PreludeRatio {-dfun-} _A_ 1 _U_ 2 _N_ _N_ _N_ _N_ #-}
instance Text (Ratio Integer)
-{-# GHC_PRAGMA INTERFACE VERSION 5 #-}
+{-# GHC_PRAGMA INTERFACE VERSION 6 #-}
interface PreludeRatio where
import PreludeBuiltin(Int(..), Integer(..))
import PreludeCore(Enum(..), Eq(..), Fractional(..), Integral(..), Num(..), Ord(..), Real(..), RealFrac(..), Text(..))
{-# GHC_PRAGMA _M_ PreludeRatio {-dfun-} _A_ 2 _U_ 22 _N_ _N_ _N_ _N_ #-}
instance Enum (Ratio Integer)
{-# GHC_PRAGMA _M_ PreludeRatio {-dfun-} _A_ 0 _N_ _N_ _N_ _F_ _IF_ARGS_ 0 0 X 6 _!_ _TUP_5 [{{Ord (Ratio Integer)}}, (Ratio Integer -> [Ratio Integer]), (Ratio Integer -> Ratio Integer -> [Ratio Integer]), (Ratio Integer -> Ratio Integer -> [Ratio Integer]), (Ratio Integer -> Ratio Integer -> Ratio Integer -> [Ratio Integer])] [_DFUN_ Ord (Ratio Integer), _CONSTM_ Enum enumFrom (Ratio Integer), _CONSTM_ Enum enumFromThen (Ratio Integer), _CONSTM_ Enum enumFromTo (Ratio Integer), _CONSTM_ Enum enumFromThenTo (Ratio Integer)] _N_
- enumFrom = _A_ 1 _U_ 2 _N_ _N_ _N_ _N_,
- enumFromThen = _A_ 2 _U_ 21 _N_ _N_ _N_ _N_,
- enumFromTo = _A_ 2 _U_ 22 _N_ _N_ _N_ _N_,
- enumFromThenTo = _A_ 3 _U_ 222 _N_ _N_ _N_ _N_ #-}
+ enumFrom = { _A_ 1 _U_ 2 _N_ _N_ _N_ _N_ },
+ enumFromThen = { _A_ 2 _U_ 21 _N_ _N_ _N_ _N_ },
+ enumFromTo = { _A_ 2 _U_ 22 _N_ _N_ _N_ _N_ },
+ enumFromThenTo = { _A_ 3 _U_ 222 _N_ _N_ _N_ _N_ } #-}
instance Integral a => Eq (Ratio a)
{-# GHC_PRAGMA _M_ PreludeRatio {-dfun-} _A_ 1 _U_ 1 _N_ _N_ _N_ _N_ #-}
instance Eq (Ratio Integer)
{-# GHC_PRAGMA _M_ PreludeRatio {-dfun-} _A_ 0 _N_ _N_ _N_ _F_ _IF_ARGS_ 0 0 X 3 _!_ _TUP_2 [(Ratio Integer -> Ratio Integer -> Bool), (Ratio Integer -> Ratio Integer -> Bool)] [_CONSTM_ Eq (==) (Ratio Integer), _CONSTM_ Eq (/=) (Ratio Integer)] _N_
- (==) = _A_ 2 _U_ 11 _N_ _S_ "U(U(PPP)L)U(U(PPP)L)" {_A_ 5 _U_ 22211 _N_ _N_ _F_ _IF_ARGS_ 0 5 XXXCC 9 \ (u0 :: Int#) (u1 :: Int#) (u2 :: ByteArray#) (u3 :: Integer) (u4 :: Ratio Integer) -> case u4 of { _ALG_ (:%) (u5 :: Integer) (u6 :: Integer) -> case u5 of { _ALG_ J# (u7 :: Int#) (u8 :: Int#) (u9 :: ByteArray#) -> case _#_ cmpInteger# [] [u0, u1, u2, u7, u8, u9] of { _PRIM_ 0# -> case u3 of { _ALG_ J# (ua :: Int#) (ub :: Int#) (uc :: ByteArray#) -> case u6 of { _ALG_ J# (ud :: Int#) (ue :: Int#) (uf :: ByteArray#) -> case _#_ cmpInteger# [] [ua, ub, uc, ud, ue, uf] of { _PRIM_ 0# -> _!_ True [] []; (ug :: Int#) -> _!_ False [] [] }; _NO_DEFLT_ }; _NO_DEFLT_ }; (uh :: Int#) -> _!_ False [] [] }; _NO_DEFLT_ }; _NO_DEFLT_ } _N_} _N_ _N_,
- (/=) = _A_ 2 _U_ 11 _N_ _S_ "U(U(PPP)L)U(U(PPP)L)" {_A_ 5 _U_ 22211 _N_ _N_ _F_ _IF_ARGS_ 0 5 XXXCC 9 \ (u0 :: Int#) (u1 :: Int#) (u2 :: ByteArray#) (u3 :: Integer) (u4 :: Ratio Integer) -> case u4 of { _ALG_ (:%) (u5 :: Integer) (u6 :: Integer) -> case u5 of { _ALG_ J# (u7 :: Int#) (u8 :: Int#) (u9 :: ByteArray#) -> case _#_ cmpInteger# [] [u0, u1, u2, u7, u8, u9] of { _PRIM_ 0# -> case u3 of { _ALG_ J# (ua :: Int#) (ub :: Int#) (uc :: ByteArray#) -> case u6 of { _ALG_ J# (ud :: Int#) (ue :: Int#) (uf :: ByteArray#) -> case _#_ cmpInteger# [] [ua, ub, uc, ud, ue, uf] of { _PRIM_ 0# -> _!_ False [] []; (ug :: Int#) -> _!_ True [] [] }; _NO_DEFLT_ }; _NO_DEFLT_ }; (uh :: Int#) -> _!_ True [] [] }; _NO_DEFLT_ }; _NO_DEFLT_ } _N_} _N_ _N_ #-}
+ (==) = { _A_ 2 _U_ 11 _N_ _S_ "U(U(PPP)L)U(U(PPP)L)" {_A_ 5 _U_ 22211 _N_ _N_ _F_ _IF_ARGS_ 0 5 XXXCC 9 \ (u0 :: Int#) (u1 :: Int#) (u2 :: ByteArray#) (u3 :: Integer) (u4 :: Ratio Integer) -> case u4 of { _ALG_ (:%) (u5 :: Integer) (u6 :: Integer) -> case u5 of { _ALG_ J# (u7 :: Int#) (u8 :: Int#) (u9 :: ByteArray#) -> case _#_ cmpInteger# [] [u0, u1, u2, u7, u8, u9] of { _PRIM_ 0# -> case u3 of { _ALG_ J# (ua :: Int#) (ub :: Int#) (uc :: ByteArray#) -> case u6 of { _ALG_ J# (ud :: Int#) (ue :: Int#) (uf :: ByteArray#) -> case _#_ cmpInteger# [] [ua, ub, uc, ud, ue, uf] of { _PRIM_ 0# -> _!_ True [] []; (ug :: Int#) -> _!_ False [] [] }; _NO_DEFLT_ }; _NO_DEFLT_ }; (uh :: Int#) -> _!_ False [] [] }; _NO_DEFLT_ }; _NO_DEFLT_ } _N_} _N_ _N_ },
+ (/=) = { _A_ 2 _U_ 11 _N_ _S_ "U(U(PPP)L)U(U(PPP)L)" {_A_ 5 _U_ 22211 _N_ _N_ _F_ _IF_ARGS_ 0 5 XXXCC 9 \ (u0 :: Int#) (u1 :: Int#) (u2 :: ByteArray#) (u3 :: Integer) (u4 :: Ratio Integer) -> case u4 of { _ALG_ (:%) (u5 :: Integer) (u6 :: Integer) -> case u5 of { _ALG_ J# (u7 :: Int#) (u8 :: Int#) (u9 :: ByteArray#) -> case _#_ cmpInteger# [] [u0, u1, u2, u7, u8, u9] of { _PRIM_ 0# -> case u3 of { _ALG_ J# (ua :: Int#) (ub :: Int#) (uc :: ByteArray#) -> case u6 of { _ALG_ J# (ud :: Int#) (ue :: Int#) (uf :: ByteArray#) -> case _#_ cmpInteger# [] [ua, ub, uc, ud, ue, uf] of { _PRIM_ 0# -> _!_ False [] []; (ug :: Int#) -> _!_ True [] [] }; _NO_DEFLT_ }; _NO_DEFLT_ }; (uh :: Int#) -> _!_ True [] [] }; _NO_DEFLT_ }; _NO_DEFLT_ } _N_} _N_ _N_ } #-}
instance Integral a => Fractional (Ratio a)
{-# GHC_PRAGMA _M_ PreludeRatio {-dfun-} _A_ 2 _U_ 22 _N_ _N_ _N_ _N_ #-}
instance Fractional (Ratio Integer)
{-# GHC_PRAGMA _M_ PreludeRatio {-dfun-} _A_ 0 _N_ _N_ _N_ _F_ _IF_ARGS_ 0 0 X 5 _!_ _TUP_4 [{{Num (Ratio Integer)}}, (Ratio Integer -> Ratio Integer -> Ratio Integer), (Ratio Integer -> Ratio Integer), (Ratio Integer -> Ratio Integer)] [_DFUN_ Num (Ratio Integer), _CONSTM_ Fractional (/) (Ratio Integer), _CONSTM_ Fractional recip (Ratio Integer), _CONSTM_ Fractional fromRational (Ratio Integer)] _N_
- (/) = _A_ 2 _U_ 11 _N_ _S_ "U(LU(PPP))U(U(PPP)L)" {_A_ 5 _U_ 22221 _N_ _N_ _N_ _N_} _N_ _N_,
- recip = _A_ 1 _U_ 1 _N_ _S_ "U(U(PPP)L)" {_A_ 4 _U_ 2222 _N_ _N_ _N_ _N_} _N_ _N_,
- fromRational = _A_ 1 _U_ 1 _N_ _S_ "U(LL)" {_A_ 2 _U_ 22 _N_ _N_ _F_ _IF_ARGS_ 0 2 XX 3 \ (u0 :: Integer) (u1 :: Integer) -> _!_ (:%) [Integer] [u0, u1] _N_} _F_ _IF_ARGS_ 0 1 X 1 \ (u0 :: Ratio Integer) -> u0 _N_ #-}
+ (/) = { _A_ 2 _U_ 11 _N_ _S_ "U(LU(PPP))U(U(PPP)L)" {_A_ 5 _U_ 22221 _N_ _N_ _N_ _N_} _N_ _N_ },
+ recip = { _A_ 1 _U_ 1 _N_ _S_ "U(U(PPP)L)" {_A_ 4 _U_ 2222 _N_ _N_ _N_ _N_} _N_ _N_ },
+ fromRational = { _A_ 1 _U_ 1 _N_ _S_ "U(LL)" {_A_ 2 _U_ 22 _N_ _N_ _F_ _IF_ARGS_ 0 2 XX 3 \ (u0 :: Integer) (u1 :: Integer) -> _!_ (:%) [Integer] [u0, u1] _N_} _F_ _IF_ARGS_ 0 1 X 1 \ (u0 :: Ratio Integer) -> u0 _N_ } #-}
instance Integral a => Num (Ratio a)
{-# GHC_PRAGMA _M_ PreludeRatio {-dfun-} _A_ 3 _U_ 222 _N_ _N_ _N_ _N_ #-}
instance Num (Ratio Integer)
{-# GHC_PRAGMA _M_ PreludeRatio {-dfun-} _A_ 0 _N_ _N_ _N_ _F_ _IF_ARGS_ 0 0 X 11 _!_ _TUP_10 [{{Eq (Ratio Integer)}}, {{Text (Ratio Integer)}}, (Ratio Integer -> Ratio Integer -> Ratio Integer), (Ratio Integer -> Ratio Integer -> Ratio Integer), (Ratio Integer -> Ratio Integer -> Ratio Integer), (Ratio Integer -> Ratio Integer), (Ratio Integer -> Ratio Integer), (Ratio Integer -> Ratio Integer), (Integer -> Ratio Integer), (Int -> Ratio Integer)] [_DFUN_ Eq (Ratio Integer), _DFUN_ Text (Ratio Integer), _CONSTM_ Num (+) (Ratio Integer), _CONSTM_ Num (-) (Ratio Integer), _CONSTM_ Num (*) (Ratio Integer), _CONSTM_ Num negate (Ratio Integer), _CONSTM_ Num abs (Ratio Integer), _CONSTM_ Num signum (Ratio Integer), _CONSTM_ Num fromInteger (Ratio Integer), _CONSTM_ Num fromInt (Ratio Integer)] _N_
- (+) = _A_ 2 _U_ 11 _N_ _S_ "U(LU(PPP))U(LU(PPP))" {_A_ 5 _U_ 12221 _N_ _N_ _N_ _N_} _N_ _N_,
- (-) = _A_ 2 _U_ 11 _N_ _S_ "U(LU(PPP))U(LU(PPP))" {_A_ 5 _U_ 12221 _N_ _N_ _N_ _N_} _N_ _N_,
- (*) = _A_ 2 _U_ 11 _N_ _S_ "U(LU(PPP))U(LU(PPP))" {_A_ 5 _U_ 22221 _N_ _N_ _N_ _N_} _N_ _N_,
- negate = _A_ 1 _U_ 1 _N_ _S_ "U(LL)" {_A_ 2 _U_ 22 _N_ _N_ _N_ _N_} _N_ _N_,
- abs = _A_ 1 _U_ 1 _N_ _S_ "U(LL)" {_A_ 2 _U_ 12 _N_ _N_ _N_ _N_} _N_ _N_,
- signum = _A_ 1 _U_ 1 _N_ _S_ "U(LA)" {_A_ 1 _U_ 1 _N_ _N_ _N_ _N_} _N_ _N_,
- fromInteger = _A_ 1 _U_ 2 _N_ _N_ _N_ _N_,
- fromInt = _A_ 1 _U_ 1 _N_ _N_ _N_ _N_ #-}
+ (+) = { _A_ 2 _U_ 11 _N_ _S_ "U(LU(PPP))U(LU(PPP))" {_A_ 5 _U_ 12221 _N_ _N_ _N_ _N_} _N_ _N_ },
+ (-) = { _A_ 2 _U_ 11 _N_ _S_ "U(LU(PPP))U(LU(PPP))" {_A_ 5 _U_ 12221 _N_ _N_ _N_ _N_} _N_ _N_ },
+ (*) = { _A_ 2 _U_ 11 _N_ _S_ "U(LU(PPP))U(LU(PPP))" {_A_ 5 _U_ 22221 _N_ _N_ _N_ _N_} _N_ _N_ },
+ negate = { _A_ 1 _U_ 1 _N_ _S_ "U(LL)" {_A_ 2 _U_ 22 _N_ _N_ _N_ _N_} _N_ _N_ },
+ abs = { _A_ 1 _U_ 1 _N_ _S_ "U(LL)" {_A_ 2 _U_ 12 _N_ _N_ _N_ _N_} _N_ _N_ },
+ signum = { _A_ 1 _U_ 1 _N_ _S_ "U(LA)" {_A_ 1 _U_ 1 _N_ _N_ _N_ _N_} _N_ _N_ },
+ fromInteger = { _A_ 1 _U_ 2 _N_ _N_ _F_ _IF_ARGS_ 0 1 X 3 \ (u0 :: Integer) -> _!_ (:%) [Integer] [u0, _SPEC_ _ORIG_ PreludeCore __i1 [ (Integer) ]] _N_ },
+ fromInt = { _A_ 1 _U_ 1 _N_ _N_ _N_ _N_ } #-}
instance Integral a => Ord (Ratio a)
{-# GHC_PRAGMA _M_ PreludeRatio {-dfun-} _A_ 2 _U_ 22 _N_ _N_ _N_ _N_ #-}
instance Ord (Ratio Integer)
{-# GHC_PRAGMA _M_ PreludeRatio {-dfun-} _A_ 0 _N_ _N_ _N_ _F_ _IF_ARGS_ 0 0 X 9 _!_ _TUP_8 [{{Eq (Ratio Integer)}}, (Ratio Integer -> Ratio Integer -> Bool), (Ratio Integer -> Ratio Integer -> Bool), (Ratio Integer -> Ratio Integer -> Bool), (Ratio Integer -> Ratio Integer -> Bool), (Ratio Integer -> Ratio Integer -> Ratio Integer), (Ratio Integer -> Ratio Integer -> Ratio Integer), (Ratio Integer -> Ratio Integer -> _CMP_TAG)] [_DFUN_ Eq (Ratio Integer), _CONSTM_ Ord (<) (Ratio Integer), _CONSTM_ Ord (<=) (Ratio Integer), _CONSTM_ Ord (>=) (Ratio Integer), _CONSTM_ Ord (>) (Ratio Integer), _CONSTM_ Ord max (Ratio Integer), _CONSTM_ Ord min (Ratio Integer), _CONSTM_ Ord _tagCmp (Ratio Integer)] _N_
- (<) = _A_ 2 _U_ 11 _N_ _S_ "U(U(PPP)U(PPP))U(U(PPP)U(PPP))" {_A_ 5 _U_ 22221 _N_ _N_ _N_ _N_} _N_ _N_,
- (<=) = _A_ 2 _U_ 11 _N_ _S_ "U(U(PPP)U(PPP))U(U(PPP)U(PPP))" {_A_ 5 _U_ 22221 _N_ _N_ _N_ _N_} _N_ _N_,
- (>=) = _A_ 2 _U_ 11 _N_ _S_ "U(U(PPP)U(PPP))U(U(PPP)U(PPP))" {_A_ 5 _U_ 22221 _N_ _N_ _N_ _N_} _N_ _N_,
- (>) = _A_ 2 _U_ 11 _N_ _S_ "U(U(PPP)U(PPP))U(U(PPP)U(PPP))" {_A_ 5 _U_ 22221 _N_ _N_ _N_ _N_} _N_ _N_,
- max = _A_ 2 _U_ 12 _N_ _S_ "U(U(PPP)U(PPP))U(U(PPP)U(PPP))" {_A_ 5 _U_ 22222 _N_ _N_ _N_ _N_} _N_ _N_,
- min = _A_ 2 _U_ 12 _N_ _S_ "U(U(PPP)U(PPP))U(U(PPP)U(PPP))" {_A_ 5 _U_ 22222 _N_ _N_ _N_ _N_} _N_ _N_,
- _tagCmp = _A_ 2 _U_ 11 _N_ _S_ "U(U(PPP)U(PPP))U(U(PPP)U(PPP))" {_A_ 5 _U_ 22221 _N_ _N_ _N_ _N_} _N_ _N_ #-}
+ (<) = { _A_ 2 _U_ 11 _N_ _S_ "U(U(PPP)U(PPP))U(U(PPP)U(PPP))" {_A_ 5 _U_ 22221 _N_ _N_ _N_ _N_} _N_ _N_ },
+ (<=) = { _A_ 2 _U_ 11 _N_ _S_ "U(U(PPP)U(PPP))U(U(PPP)U(PPP))" {_A_ 5 _U_ 22221 _N_ _N_ _N_ _N_} _N_ _N_ },
+ (>=) = { _A_ 2 _U_ 11 _N_ _S_ "U(U(PPP)U(PPP))U(U(PPP)U(PPP))" {_A_ 5 _U_ 22221 _N_ _N_ _N_ _N_} _N_ _N_ },
+ (>) = { _A_ 2 _U_ 11 _N_ _S_ "U(U(PPP)U(PPP))U(U(PPP)U(PPP))" {_A_ 5 _U_ 22221 _N_ _N_ _N_ _N_} _N_ _N_ },
+ max = { _A_ 2 _U_ 12 _N_ _S_ "U(U(PPP)U(PPP))U(U(PPP)U(PPP))" {_A_ 5 _U_ 22222 _N_ _N_ _N_ _N_} _N_ _N_ },
+ min = { _A_ 2 _U_ 12 _N_ _S_ "U(U(PPP)U(PPP))U(U(PPP)U(PPP))" {_A_ 5 _U_ 22222 _N_ _N_ _N_ _N_} _N_ _N_ },
+ _tagCmp = { _A_ 2 _U_ 11 _N_ _S_ "U(U(PPP)U(PPP))U(U(PPP)U(PPP))" {_A_ 5 _U_ 22221 _N_ _N_ _N_ _N_} _N_ _N_ } #-}
instance Integral a => Real (Ratio a)
{-# GHC_PRAGMA _M_ PreludeRatio {-dfun-} _A_ 3 _U_ 122 _N_ _N_ _N_ _N_ #-}
instance Real (Ratio Integer)
{-# GHC_PRAGMA _M_ PreludeRatio {-dfun-} _A_ 0 _N_ _N_ _N_ _F_ _IF_ARGS_ 0 0 X 4 _!_ _TUP_3 [{{Num (Ratio Integer)}}, {{Enum (Ratio Integer)}}, (Ratio Integer -> Ratio Integer)] [_DFUN_ Num (Ratio Integer), _DFUN_ Enum (Ratio Integer), _CONSTM_ Real toRational (Ratio Integer)] _N_
- toRational = _A_ 1 _U_ 1 _N_ _S_ "U(LL)" {_A_ 2 _U_ 22 _N_ _N_ _F_ _IF_ARGS_ 0 2 XX 3 \ (u0 :: Integer) (u1 :: Integer) -> _!_ (:%) [Integer] [u0, u1] _N_} _F_ _IF_ARGS_ 0 1 X 1 \ (u0 :: Ratio Integer) -> u0 _N_ #-}
-instance Integral a => RealFrac (Ratio a)
- {-# GHC_PRAGMA _M_ PreludeRatio {-dfun-} _A_ 3 _U_ 222 _N_ _N_ _N_ _N_ #-}
+ toRational = { _A_ 1 _U_ 1 _N_ _S_ "U(LL)" {_A_ 2 _U_ 22 _N_ _N_ _F_ _IF_ARGS_ 0 2 XX 3 \ (u0 :: Integer) (u1 :: Integer) -> _!_ (:%) [Integer] [u0, u1] _N_} _F_ _IF_ARGS_ 0 1 X 1 \ (u0 :: Ratio Integer) -> u0 _N_ } #-}
instance RealFrac (Ratio Integer)
{-# GHC_PRAGMA _M_ PreludeRatio {-dfun-} _A_ 0 _N_ _N_ _N_ _F_ _IF_ARGS_ 0 0 X 8 _!_ _TUP_7 [{{Real (Ratio Integer)}}, {{Fractional (Ratio Integer)}}, _forall_ a$z1 =>{{Integral a$z1}} -> (Ratio Integer -> (a$z1, Ratio Integer)), _forall_ a$z1 =>{{Integral a$z1}} -> (Ratio Integer -> a$z1), _forall_ a$z1 =>{{Integral a$z1}} -> (Ratio Integer -> a$z1), _forall_ a$z1 =>{{Integral a$z1}} -> (Ratio Integer -> a$z1), _forall_ a$z1 =>{{Integral a$z1}} -> (Ratio Integer -> a$z1)] [_DFUN_ Real (Ratio Integer), _DFUN_ Fractional (Ratio Integer), _CONSTM_ RealFrac properFraction (Ratio Integer), _CONSTM_ RealFrac truncate (Ratio Integer), _CONSTM_ RealFrac round (Ratio Integer), _CONSTM_ RealFrac ceiling (Ratio Integer), _CONSTM_ RealFrac floor (Ratio Integer)] _N_
- properFraction = _A_ 2 _U_ 11 _N_ _S_ "LU(LL)" {_A_ 3 _U_ 112 _N_ _N_ _N_ _N_} _N_ _N_,
- truncate = _A_ 1 _U_ 22 _N_ _N_ _F_ _IF_ARGS_ 1 1 X 3 _/\_ u0 -> \ (u1 :: {{Integral u0}}) -> _APP_ _TYAPP_ _TYAPP_ _WRKR_ _ORIG_ PreludeCore _truncate { (Ratio Integer) } { u0 } [ _CONSTM_ RealFrac properFraction (Ratio Integer), u1 ] _N_,
- round = _A_ 1 _U_ 22 _N_ _N_ _N_ _N_,
- ceiling = _A_ 1 _U_ 22 _N_ _N_ _N_ _N_,
- floor = _A_ 1 _U_ 22 _N_ _N_ _N_ _N_ #-}
+ properFraction = { _A_ 2 _U_ 11 _N_ _S_ "LU(U(PPP)U(PPP))" {_A_ 5 _U_ 12222 _N_ _N_ _N_ _N_} _N_ _SPECIALISE_ [ Int ] 1 { _A_ 1 _U_ 1 _N_ _S_ "U(U(PPP)U(PPP))" {_A_ 4 _U_ 2222 _N_ _N_ _N_ _N_} _N_ _N_ }, [ Integer ] 1 { _A_ 1 _U_ 1 _N_ _S_ "U(U(PPP)U(PPP))" {_A_ 4 _U_ 2222 _N_ _N_ _N_ _N_} _N_ _N_ } },
+ truncate = { _A_ 2 _U_ 11 _N_ _N_ _N_ _SPECIALISE_ [ Int ] 1 { _A_ 1 _U_ 1 _N_ _S_ "U(U(PPP)U(PPP))" {_A_ 4 _U_ 2222 _N_ _N_ _F_ _IF_ARGS_ 0 4 XXXX 7 \ (u0 :: Int#) (u1 :: Int#) (u2 :: ByteArray#) (u3 :: Integer) -> case _APP_ _WRKR_ _SPEC_ _CONSTM_ RealFrac properFraction (Ratio Integer) [ (Int) ] [ u0, u1, u2, u3 ] of { _ALG_ _TUP_2 (u4 :: Int) (u5 :: Ratio Integer) -> u4; _NO_DEFLT_ } _N_} _F_ _IF_ARGS_ 0 1 X 4 \ (u0 :: Ratio Integer) -> case _APP_ _SPEC_ _CONSTM_ RealFrac properFraction (Ratio Integer) [ (Int) ] [ u0 ] of { _ALG_ _TUP_2 (u1 :: Int) (u2 :: Ratio Integer) -> u1; _NO_DEFLT_ } _N_ }, [ Integer ] 1 { _A_ 1 _U_ 1 _N_ _S_ "U(U(PPP)U(PPP))" {_A_ 4 _U_ 2222 _N_ _N_ _F_ _IF_ARGS_ 0 4 XXXX 7 \ (u0 :: Int#) (u1 :: Int#) (u2 :: ByteArray#) (u3 :: Integer) -> case _APP_ _WRKR_ _SPEC_ _CONSTM_ RealFrac properFraction (Ratio Integer) [ (Integer) ] [ u0, u1, u2, u3 ] of { _ALG_ _TUP_2 (u4 :: Integer) (u5 :: Ratio Integer) -> u4; _NO_DEFLT_ } _N_} _F_ _IF_ARGS_ 0 1 X 4 \ (u0 :: Ratio Integer) -> case _APP_ _SPEC_ _CONSTM_ RealFrac properFraction (Ratio Integer) [ (Integer) ] [ u0 ] of { _ALG_ _TUP_2 (u1 :: Integer) (u2 :: Ratio Integer) -> u1; _NO_DEFLT_ } _N_ } },
+ round = { _A_ 1 _U_ 21 _N_ _N_ _N_ _SPECIALISE_ [ Int ] 1 { _A_ 1 _U_ 1 _N_ _S_ "U(U(PPP)U(PPP))" {_A_ 4 _U_ 2222 _N_ _N_ _N_ _N_} _N_ _N_ }, [ Integer ] 1 { _A_ 1 _U_ 1 _N_ _S_ "U(U(PPP)U(PPP))" {_A_ 4 _U_ 2222 _N_ _N_ _N_ _N_} _N_ _N_ } },
+ ceiling = { _A_ 1 _U_ 21 _N_ _N_ _N_ _SPECIALISE_ [ Int ] 1 { _A_ 1 _U_ 1 _N_ _S_ "U(U(PPP)U(PPP))" {_A_ 4 _U_ 2222 _N_ _N_ _N_ _N_} _N_ _N_ }, [ Integer ] 1 { _A_ 1 _U_ 1 _N_ _S_ "U(U(PPP)U(PPP))" {_A_ 4 _U_ 2222 _N_ _N_ _N_ _N_} _N_ _N_ } },
+ floor = { _A_ 1 _U_ 21 _N_ _N_ _N_ _SPECIALISE_ [ Int ] 1 { _A_ 1 _U_ 1 _N_ _S_ "U(U(PPP)U(PPP))" {_A_ 4 _U_ 2222 _N_ _N_ _N_ _N_} _N_ _N_ }, [ Integer ] 1 { _A_ 1 _U_ 1 _N_ _S_ "U(U(PPP)U(PPP))" {_A_ 4 _U_ 2222 _N_ _N_ _N_ _N_} _N_ _N_ } } #-}
instance Integral a => Text (Ratio a)
{-# GHC_PRAGMA _M_ PreludeRatio {-dfun-} _A_ 1 _U_ 2 _N_ _N_ _N_ _N_ #-}
instance Text (Ratio Integer)
{-# GHC_PRAGMA _M_ PreludeRatio {-dfun-} _A_ 0 _N_ _N_ _N_ _F_ _IF_ARGS_ 0 0 X 5 _!_ _TUP_4 [(Int -> [Char] -> [(Ratio Integer, [Char])]), (Int -> Ratio Integer -> [Char] -> [Char]), ([Char] -> [([Ratio Integer], [Char])]), ([Ratio Integer] -> [Char] -> [Char])] [_CONSTM_ Text readsPrec (Ratio Integer), _CONSTM_ Text showsPrec (Ratio Integer), _CONSTM_ Text readList (Ratio Integer), _CONSTM_ Text showList (Ratio Integer)] _N_
- readsPrec = _A_ 1 _U_ 12 _N_ _S_ "U(P)" {_A_ 1 _U_ 22 _N_ _N_ _N_ _N_} _N_ _N_,
- showsPrec = _A_ 2 _U_ 112 _N_ _S_ "LU(LL)" {_A_ 3 _U_ 1222 _N_ _N_ _N_ _N_} _N_ _N_,
- readList = _A_ 0 _U_ 2 _N_ _N_ _N_ _N_,
- showList = _A_ 0 _U_ 12 _N_ _N_ _N_ _N_ #-}
+ readsPrec = { _A_ 1 _U_ 12 _N_ _S_ "U(P)" {_A_ 1 _U_ 22 _N_ _N_ _N_ _N_} _N_ _N_ },
+ showsPrec = { _A_ 2 _U_ 112 _N_ _S_ "LU(LL)" {_A_ 3 _U_ 1222 _N_ _N_ _N_ _N_} _N_ _N_ },
+ readList = { _A_ 0 _U_ 2 _N_ _N_ _N_ _N_ },
+ showList = { _A_ 1 _U_ 12 _N_ _N_ _N_ _N_ } #-}
-{-# GHC_PRAGMA INTERFACE VERSION 5 #-}
+{-# GHC_PRAGMA INTERFACE VERSION 6 #-}
interface PreludeRatio where
import PreludeBuiltin(Int(..), Integer(..))
import PreludeCore(Enum(..), Eq(..), Fractional(..), Integral(..), Num(..), Ord(..), Real(..), RealFrac(..), Text(..))
{-# GHC_PRAGMA _M_ PreludeRatio {-dfun-} _A_ 2 _U_ 22 _N_ _N_ _N_ _N_ #-}
instance Enum (Ratio Integer)
{-# GHC_PRAGMA _M_ PreludeRatio {-dfun-} _A_ 0 _N_ _N_ _N_ _F_ _IF_ARGS_ 0 0 X 6 _!_ _TUP_5 [{{Ord (Ratio Integer)}}, (Ratio Integer -> [Ratio Integer]), (Ratio Integer -> Ratio Integer -> [Ratio Integer]), (Ratio Integer -> Ratio Integer -> [Ratio Integer]), (Ratio Integer -> Ratio Integer -> Ratio Integer -> [Ratio Integer])] [_DFUN_ Ord (Ratio Integer), _CONSTM_ Enum enumFrom (Ratio Integer), _CONSTM_ Enum enumFromThen (Ratio Integer), _CONSTM_ Enum enumFromTo (Ratio Integer), _CONSTM_ Enum enumFromThenTo (Ratio Integer)] _N_
- enumFrom = _A_ 1 _U_ 2 _N_ _N_ _N_ _N_,
- enumFromThen = _A_ 2 _U_ 21 _N_ _N_ _N_ _N_,
- enumFromTo = _A_ 2 _U_ 22 _N_ _N_ _N_ _N_,
- enumFromThenTo = _A_ 3 _U_ 222 _N_ _N_ _N_ _N_ #-}
+ enumFrom = { _A_ 1 _U_ 2 _N_ _N_ _N_ _N_ },
+ enumFromThen = { _A_ 2 _U_ 21 _N_ _N_ _N_ _N_ },
+ enumFromTo = { _A_ 2 _U_ 22 _N_ _N_ _N_ _N_ },
+ enumFromThenTo = { _A_ 3 _U_ 222 _N_ _N_ _N_ _N_ } #-}
instance Integral a => Eq (Ratio a)
{-# GHC_PRAGMA _M_ PreludeRatio {-dfun-} _A_ 1 _U_ 1 _N_ _N_ _N_ _N_ #-}
instance Eq (Ratio Integer)
{-# GHC_PRAGMA _M_ PreludeRatio {-dfun-} _A_ 0 _N_ _N_ _N_ _F_ _IF_ARGS_ 0 0 X 3 _!_ _TUP_2 [(Ratio Integer -> Ratio Integer -> Bool), (Ratio Integer -> Ratio Integer -> Bool)] [_CONSTM_ Eq (==) (Ratio Integer), _CONSTM_ Eq (/=) (Ratio Integer)] _N_
- (==) = _A_ 2 _U_ 11 _N_ _S_ "U(U(PPP)L)U(U(PPP)L)" {_A_ 5 _U_ 22211 _N_ _N_ _F_ _IF_ARGS_ 0 5 XXXCC 9 \ (u0 :: Int#) (u1 :: Int#) (u2 :: ByteArray#) (u3 :: Integer) (u4 :: Ratio Integer) -> case u4 of { _ALG_ (:%) (u5 :: Integer) (u6 :: Integer) -> case u5 of { _ALG_ J# (u7 :: Int#) (u8 :: Int#) (u9 :: ByteArray#) -> case _#_ cmpInteger# [] [u0, u1, u2, u7, u8, u9] of { _PRIM_ 0# -> case u3 of { _ALG_ J# (ua :: Int#) (ub :: Int#) (uc :: ByteArray#) -> case u6 of { _ALG_ J# (ud :: Int#) (ue :: Int#) (uf :: ByteArray#) -> case _#_ cmpInteger# [] [ua, ub, uc, ud, ue, uf] of { _PRIM_ 0# -> _!_ True [] []; (ug :: Int#) -> _!_ False [] [] }; _NO_DEFLT_ }; _NO_DEFLT_ }; (uh :: Int#) -> _!_ False [] [] }; _NO_DEFLT_ }; _NO_DEFLT_ } _N_} _N_ _N_,
- (/=) = _A_ 2 _U_ 11 _N_ _S_ "U(U(PPP)L)U(U(PPP)L)" {_A_ 5 _U_ 22211 _N_ _N_ _F_ _IF_ARGS_ 0 5 XXXCC 9 \ (u0 :: Int#) (u1 :: Int#) (u2 :: ByteArray#) (u3 :: Integer) (u4 :: Ratio Integer) -> case u4 of { _ALG_ (:%) (u5 :: Integer) (u6 :: Integer) -> case u5 of { _ALG_ J# (u7 :: Int#) (u8 :: Int#) (u9 :: ByteArray#) -> case _#_ cmpInteger# [] [u0, u1, u2, u7, u8, u9] of { _PRIM_ 0# -> case u3 of { _ALG_ J# (ua :: Int#) (ub :: Int#) (uc :: ByteArray#) -> case u6 of { _ALG_ J# (ud :: Int#) (ue :: Int#) (uf :: ByteArray#) -> case _#_ cmpInteger# [] [ua, ub, uc, ud, ue, uf] of { _PRIM_ 0# -> _!_ False [] []; (ug :: Int#) -> _!_ True [] [] }; _NO_DEFLT_ }; _NO_DEFLT_ }; (uh :: Int#) -> _!_ True [] [] }; _NO_DEFLT_ }; _NO_DEFLT_ } _N_} _N_ _N_ #-}
+ (==) = { _A_ 2 _U_ 11 _N_ _S_ "U(U(PPP)L)U(U(PPP)L)" {_A_ 5 _U_ 22211 _N_ _N_ _F_ _IF_ARGS_ 0 5 XXXCC 9 \ (u0 :: Int#) (u1 :: Int#) (u2 :: ByteArray#) (u3 :: Integer) (u4 :: Ratio Integer) -> case u4 of { _ALG_ (:%) (u5 :: Integer) (u6 :: Integer) -> case u5 of { _ALG_ J# (u7 :: Int#) (u8 :: Int#) (u9 :: ByteArray#) -> case _#_ cmpInteger# [] [u0, u1, u2, u7, u8, u9] of { _PRIM_ 0# -> case u3 of { _ALG_ J# (ua :: Int#) (ub :: Int#) (uc :: ByteArray#) -> case u6 of { _ALG_ J# (ud :: Int#) (ue :: Int#) (uf :: ByteArray#) -> case _#_ cmpInteger# [] [ua, ub, uc, ud, ue, uf] of { _PRIM_ 0# -> _!_ True [] []; (ug :: Int#) -> _!_ False [] [] }; _NO_DEFLT_ }; _NO_DEFLT_ }; (uh :: Int#) -> _!_ False [] [] }; _NO_DEFLT_ }; _NO_DEFLT_ } _N_} _N_ _N_ },
+ (/=) = { _A_ 2 _U_ 11 _N_ _S_ "U(U(PPP)L)U(U(PPP)L)" {_A_ 5 _U_ 22211 _N_ _N_ _F_ _IF_ARGS_ 0 5 XXXCC 9 \ (u0 :: Int#) (u1 :: Int#) (u2 :: ByteArray#) (u3 :: Integer) (u4 :: Ratio Integer) -> case u4 of { _ALG_ (:%) (u5 :: Integer) (u6 :: Integer) -> case u5 of { _ALG_ J# (u7 :: Int#) (u8 :: Int#) (u9 :: ByteArray#) -> case _#_ cmpInteger# [] [u0, u1, u2, u7, u8, u9] of { _PRIM_ 0# -> case u3 of { _ALG_ J# (ua :: Int#) (ub :: Int#) (uc :: ByteArray#) -> case u6 of { _ALG_ J# (ud :: Int#) (ue :: Int#) (uf :: ByteArray#) -> case _#_ cmpInteger# [] [ua, ub, uc, ud, ue, uf] of { _PRIM_ 0# -> _!_ False [] []; (ug :: Int#) -> _!_ True [] [] }; _NO_DEFLT_ }; _NO_DEFLT_ }; (uh :: Int#) -> _!_ True [] [] }; _NO_DEFLT_ }; _NO_DEFLT_ } _N_} _N_ _N_ } #-}
instance Integral a => Fractional (Ratio a)
{-# GHC_PRAGMA _M_ PreludeRatio {-dfun-} _A_ 2 _U_ 22 _N_ _N_ _N_ _N_ #-}
instance Fractional (Ratio Integer)
{-# GHC_PRAGMA _M_ PreludeRatio {-dfun-} _A_ 0 _N_ _N_ _N_ _F_ _IF_ARGS_ 0 0 X 5 _!_ _TUP_4 [{{Num (Ratio Integer)}}, (Ratio Integer -> Ratio Integer -> Ratio Integer), (Ratio Integer -> Ratio Integer), (Ratio Integer -> Ratio Integer)] [_DFUN_ Num (Ratio Integer), _CONSTM_ Fractional (/) (Ratio Integer), _CONSTM_ Fractional recip (Ratio Integer), _CONSTM_ Fractional fromRational (Ratio Integer)] _N_
- (/) = _A_ 2 _U_ 11 _N_ _S_ "U(LU(PPP))U(U(PPP)L)" {_A_ 5 _U_ 22221 _N_ _N_ _N_ _N_} _N_ _N_,
- recip = _A_ 1 _U_ 1 _N_ _S_ "U(U(PPP)L)" {_A_ 4 _U_ 2222 _N_ _N_ _N_ _N_} _N_ _N_,
- fromRational = _A_ 1 _U_ 1 _N_ _S_ "U(LL)" {_A_ 2 _U_ 22 _N_ _N_ _F_ _IF_ARGS_ 0 2 XX 3 \ (u0 :: Integer) (u1 :: Integer) -> _!_ (:%) [Integer] [u0, u1] _N_} _F_ _IF_ARGS_ 0 1 X 1 \ (u0 :: Ratio Integer) -> u0 _N_ #-}
+ (/) = { _A_ 2 _U_ 11 _N_ _S_ "U(LU(PPP))U(U(PPP)L)" {_A_ 5 _U_ 22221 _N_ _N_ _N_ _N_} _N_ _N_ },
+ recip = { _A_ 1 _U_ 1 _N_ _S_ "U(U(PPP)L)" {_A_ 4 _U_ 2222 _N_ _N_ _N_ _N_} _N_ _N_ },
+ fromRational = { _A_ 1 _U_ 1 _N_ _S_ "U(LL)" {_A_ 2 _U_ 22 _N_ _N_ _F_ _IF_ARGS_ 0 2 XX 3 \ (u0 :: Integer) (u1 :: Integer) -> _!_ (:%) [Integer] [u0, u1] _N_} _F_ _IF_ARGS_ 0 1 X 1 \ (u0 :: Ratio Integer) -> u0 _N_ } #-}
instance Integral a => Num (Ratio a)
{-# GHC_PRAGMA _M_ PreludeRatio {-dfun-} _A_ 3 _U_ 222 _N_ _N_ _N_ _N_ #-}
instance Num (Ratio Integer)
{-# GHC_PRAGMA _M_ PreludeRatio {-dfun-} _A_ 0 _N_ _N_ _N_ _F_ _IF_ARGS_ 0 0 X 11 _!_ _TUP_10 [{{Eq (Ratio Integer)}}, {{Text (Ratio Integer)}}, (Ratio Integer -> Ratio Integer -> Ratio Integer), (Ratio Integer -> Ratio Integer -> Ratio Integer), (Ratio Integer -> Ratio Integer -> Ratio Integer), (Ratio Integer -> Ratio Integer), (Ratio Integer -> Ratio Integer), (Ratio Integer -> Ratio Integer), (Integer -> Ratio Integer), (Int -> Ratio Integer)] [_DFUN_ Eq (Ratio Integer), _DFUN_ Text (Ratio Integer), _CONSTM_ Num (+) (Ratio Integer), _CONSTM_ Num (-) (Ratio Integer), _CONSTM_ Num (*) (Ratio Integer), _CONSTM_ Num negate (Ratio Integer), _CONSTM_ Num abs (Ratio Integer), _CONSTM_ Num signum (Ratio Integer), _CONSTM_ Num fromInteger (Ratio Integer), _CONSTM_ Num fromInt (Ratio Integer)] _N_
- (+) = _A_ 2 _U_ 11 _N_ _S_ "U(LU(PPP))U(LU(PPP))" {_A_ 5 _U_ 12221 _N_ _N_ _N_ _N_} _N_ _N_,
- (-) = _A_ 2 _U_ 11 _N_ _S_ "U(LU(PPP))U(LU(PPP))" {_A_ 5 _U_ 12221 _N_ _N_ _N_ _N_} _N_ _N_,
- (*) = _A_ 2 _U_ 11 _N_ _S_ "U(LU(PPP))U(LU(PPP))" {_A_ 5 _U_ 22221 _N_ _N_ _N_ _N_} _N_ _N_,
- negate = _A_ 1 _U_ 1 _N_ _S_ "U(LL)" {_A_ 2 _U_ 22 _N_ _N_ _N_ _N_} _N_ _N_,
- abs = _A_ 1 _U_ 1 _N_ _S_ "U(LL)" {_A_ 2 _U_ 12 _N_ _N_ _N_ _N_} _N_ _N_,
- signum = _A_ 1 _U_ 1 _N_ _S_ "U(LA)" {_A_ 1 _U_ 1 _N_ _N_ _N_ _N_} _N_ _N_,
- fromInteger = _A_ 1 _U_ 2 _N_ _N_ _N_ _N_,
- fromInt = _A_ 1 _U_ 1 _N_ _N_ _N_ _N_ #-}
+ (+) = { _A_ 2 _U_ 11 _N_ _S_ "U(LU(PPP))U(LU(PPP))" {_A_ 5 _U_ 12221 _N_ _N_ _N_ _N_} _N_ _N_ },
+ (-) = { _A_ 2 _U_ 11 _N_ _S_ "U(LU(PPP))U(LU(PPP))" {_A_ 5 _U_ 12221 _N_ _N_ _N_ _N_} _N_ _N_ },
+ (*) = { _A_ 2 _U_ 11 _N_ _S_ "U(LU(PPP))U(LU(PPP))" {_A_ 5 _U_ 22221 _N_ _N_ _N_ _N_} _N_ _N_ },
+ negate = { _A_ 1 _U_ 1 _N_ _S_ "U(LL)" {_A_ 2 _U_ 22 _N_ _N_ _N_ _N_} _N_ _N_ },
+ abs = { _A_ 1 _U_ 1 _N_ _S_ "U(LL)" {_A_ 2 _U_ 12 _N_ _N_ _N_ _N_} _N_ _N_ },
+ signum = { _A_ 1 _U_ 1 _N_ _S_ "U(LA)" {_A_ 1 _U_ 1 _N_ _N_ _N_ _N_} _N_ _N_ },
+ fromInteger = { _A_ 1 _U_ 2 _N_ _N_ _F_ _IF_ARGS_ 0 1 X 3 \ (u0 :: Integer) -> _!_ (:%) [Integer] [u0, _SPEC_ _ORIG_ PreludeCore __i1 [ (Integer) ]] _N_ },
+ fromInt = { _A_ 1 _U_ 1 _N_ _N_ _N_ _N_ } #-}
instance Integral a => Ord (Ratio a)
{-# GHC_PRAGMA _M_ PreludeRatio {-dfun-} _A_ 2 _U_ 22 _N_ _N_ _N_ _N_ #-}
instance Ord (Ratio Integer)
{-# GHC_PRAGMA _M_ PreludeRatio {-dfun-} _A_ 0 _N_ _N_ _N_ _F_ _IF_ARGS_ 0 0 X 9 _!_ _TUP_8 [{{Eq (Ratio Integer)}}, (Ratio Integer -> Ratio Integer -> Bool), (Ratio Integer -> Ratio Integer -> Bool), (Ratio Integer -> Ratio Integer -> Bool), (Ratio Integer -> Ratio Integer -> Bool), (Ratio Integer -> Ratio Integer -> Ratio Integer), (Ratio Integer -> Ratio Integer -> Ratio Integer), (Ratio Integer -> Ratio Integer -> _CMP_TAG)] [_DFUN_ Eq (Ratio Integer), _CONSTM_ Ord (<) (Ratio Integer), _CONSTM_ Ord (<=) (Ratio Integer), _CONSTM_ Ord (>=) (Ratio Integer), _CONSTM_ Ord (>) (Ratio Integer), _CONSTM_ Ord max (Ratio Integer), _CONSTM_ Ord min (Ratio Integer), _CONSTM_ Ord _tagCmp (Ratio Integer)] _N_
- (<) = _A_ 2 _U_ 11 _N_ _S_ "U(U(PPP)U(PPP))U(U(PPP)U(PPP))" {_A_ 5 _U_ 22221 _N_ _N_ _N_ _N_} _N_ _N_,
- (<=) = _A_ 2 _U_ 11 _N_ _S_ "U(U(PPP)U(PPP))U(U(PPP)U(PPP))" {_A_ 5 _U_ 22221 _N_ _N_ _N_ _N_} _N_ _N_,
- (>=) = _A_ 2 _U_ 11 _N_ _S_ "U(U(PPP)U(PPP))U(U(PPP)U(PPP))" {_A_ 5 _U_ 22221 _N_ _N_ _N_ _N_} _N_ _N_,
- (>) = _A_ 2 _U_ 11 _N_ _S_ "U(U(PPP)U(PPP))U(U(PPP)U(PPP))" {_A_ 5 _U_ 22221 _N_ _N_ _N_ _N_} _N_ _N_,
- max = _A_ 2 _U_ 12 _N_ _S_ "U(U(PPP)U(PPP))U(U(PPP)U(PPP))" {_A_ 5 _U_ 22222 _N_ _N_ _N_ _N_} _N_ _N_,
- min = _A_ 2 _U_ 12 _N_ _S_ "U(U(PPP)U(PPP))U(U(PPP)U(PPP))" {_A_ 5 _U_ 22222 _N_ _N_ _N_ _N_} _N_ _N_,
- _tagCmp = _A_ 2 _U_ 11 _N_ _S_ "U(U(PPP)U(PPP))U(U(PPP)U(PPP))" {_A_ 5 _U_ 22221 _N_ _N_ _N_ _N_} _N_ _N_ #-}
+ (<) = { _A_ 2 _U_ 11 _N_ _S_ "U(U(PPP)U(PPP))U(U(PPP)U(PPP))" {_A_ 5 _U_ 22221 _N_ _N_ _N_ _N_} _N_ _N_ },
+ (<=) = { _A_ 2 _U_ 11 _N_ _S_ "U(U(PPP)U(PPP))U(U(PPP)U(PPP))" {_A_ 5 _U_ 22221 _N_ _N_ _N_ _N_} _N_ _N_ },
+ (>=) = { _A_ 2 _U_ 11 _N_ _S_ "U(U(PPP)U(PPP))U(U(PPP)U(PPP))" {_A_ 5 _U_ 22221 _N_ _N_ _N_ _N_} _N_ _N_ },
+ (>) = { _A_ 2 _U_ 11 _N_ _S_ "U(U(PPP)U(PPP))U(U(PPP)U(PPP))" {_A_ 5 _U_ 22221 _N_ _N_ _N_ _N_} _N_ _N_ },
+ max = { _A_ 2 _U_ 12 _N_ _S_ "U(U(PPP)U(PPP))U(U(PPP)U(PPP))" {_A_ 5 _U_ 22222 _N_ _N_ _N_ _N_} _N_ _N_ },
+ min = { _A_ 2 _U_ 12 _N_ _S_ "U(U(PPP)U(PPP))U(U(PPP)U(PPP))" {_A_ 5 _U_ 22222 _N_ _N_ _N_ _N_} _N_ _N_ },
+ _tagCmp = { _A_ 2 _U_ 11 _N_ _S_ "U(U(PPP)U(PPP))U(U(PPP)U(PPP))" {_A_ 5 _U_ 22221 _N_ _N_ _N_ _N_} _N_ _N_ } #-}
instance Integral a => Real (Ratio a)
{-# GHC_PRAGMA _M_ PreludeRatio {-dfun-} _A_ 3 _U_ 122 _N_ _N_ _N_ _N_ #-}
instance Real (Ratio Integer)
{-# GHC_PRAGMA _M_ PreludeRatio {-dfun-} _A_ 0 _N_ _N_ _N_ _F_ _IF_ARGS_ 0 0 X 4 _!_ _TUP_3 [{{Num (Ratio Integer)}}, {{Enum (Ratio Integer)}}, (Ratio Integer -> Ratio Integer)] [_DFUN_ Num (Ratio Integer), _DFUN_ Enum (Ratio Integer), _CONSTM_ Real toRational (Ratio Integer)] _N_
- toRational = _A_ 1 _U_ 1 _N_ _S_ "U(LL)" {_A_ 2 _U_ 22 _N_ _N_ _F_ _IF_ARGS_ 0 2 XX 3 \ (u0 :: Integer) (u1 :: Integer) -> _!_ (:%) [Integer] [u0, u1] _N_} _F_ _IF_ARGS_ 0 1 X 1 \ (u0 :: Ratio Integer) -> u0 _N_ #-}
-instance Integral a => RealFrac (Ratio a)
- {-# GHC_PRAGMA _M_ PreludeRatio {-dfun-} _A_ 3 _U_ 222 _N_ _N_ _N_ _N_ #-}
+ toRational = { _A_ 1 _U_ 1 _N_ _S_ "U(LL)" {_A_ 2 _U_ 22 _N_ _N_ _F_ _IF_ARGS_ 0 2 XX 3 \ (u0 :: Integer) (u1 :: Integer) -> _!_ (:%) [Integer] [u0, u1] _N_} _F_ _IF_ARGS_ 0 1 X 1 \ (u0 :: Ratio Integer) -> u0 _N_ } #-}
instance RealFrac (Ratio Integer)
{-# GHC_PRAGMA _M_ PreludeRatio {-dfun-} _A_ 0 _N_ _N_ _N_ _F_ _IF_ARGS_ 0 0 X 8 _!_ _TUP_7 [{{Real (Ratio Integer)}}, {{Fractional (Ratio Integer)}}, _forall_ a$z1 =>{{Integral a$z1}} -> (Ratio Integer -> (a$z1, Ratio Integer)), _forall_ a$z1 =>{{Integral a$z1}} -> (Ratio Integer -> a$z1), _forall_ a$z1 =>{{Integral a$z1}} -> (Ratio Integer -> a$z1), _forall_ a$z1 =>{{Integral a$z1}} -> (Ratio Integer -> a$z1), _forall_ a$z1 =>{{Integral a$z1}} -> (Ratio Integer -> a$z1)] [_DFUN_ Real (Ratio Integer), _DFUN_ Fractional (Ratio Integer), _CONSTM_ RealFrac properFraction (Ratio Integer), _CONSTM_ RealFrac truncate (Ratio Integer), _CONSTM_ RealFrac round (Ratio Integer), _CONSTM_ RealFrac ceiling (Ratio Integer), _CONSTM_ RealFrac floor (Ratio Integer)] _N_
- properFraction = _A_ 2 _U_ 11 _N_ _S_ "LU(LL)" {_A_ 3 _U_ 112 _N_ _N_ _N_ _N_} _N_ _N_,
- truncate = _A_ 1 _U_ 22 _N_ _N_ _F_ _IF_ARGS_ 1 1 X 3 _/\_ u0 -> \ (u1 :: {{Integral u0}}) -> _APP_ _TYAPP_ _TYAPP_ _WRKR_ _ORIG_ PreludeCore _truncate { (Ratio Integer) } { u0 } [ _CONSTM_ RealFrac properFraction (Ratio Integer), u1 ] _N_,
- round = _A_ 1 _U_ 22 _N_ _N_ _N_ _N_,
- ceiling = _A_ 1 _U_ 22 _N_ _N_ _N_ _N_,
- floor = _A_ 1 _U_ 22 _N_ _N_ _N_ _N_ #-}
+ properFraction = { _A_ 2 _U_ 11 _N_ _S_ "LU(U(PPP)U(PPP))" {_A_ 5 _U_ 12222 _N_ _N_ _N_ _N_} _N_ _SPECIALISE_ [ Int ] 1 { _A_ 1 _U_ 1 _N_ _S_ "U(U(PPP)U(PPP))" {_A_ 4 _U_ 2222 _N_ _N_ _N_ _N_} _N_ _N_ }, [ Integer ] 1 { _A_ 1 _U_ 1 _N_ _S_ "U(U(PPP)U(PPP))" {_A_ 4 _U_ 2222 _N_ _N_ _N_ _N_} _N_ _N_ } },
+ truncate = { _A_ 2 _U_ 11 _N_ _N_ _N_ _SPECIALISE_ [ Int ] 1 { _A_ 1 _U_ 1 _N_ _S_ "U(U(PPP)U(PPP))" {_A_ 4 _U_ 2222 _N_ _N_ _F_ _IF_ARGS_ 0 4 XXXX 7 \ (u0 :: Int#) (u1 :: Int#) (u2 :: ByteArray#) (u3 :: Integer) -> case _APP_ _WRKR_ _SPEC_ _CONSTM_ RealFrac properFraction (Ratio Integer) [ (Int) ] [ u0, u1, u2, u3 ] of { _ALG_ _TUP_2 (u4 :: Int) (u5 :: Ratio Integer) -> u4; _NO_DEFLT_ } _N_} _F_ _IF_ARGS_ 0 1 X 4 \ (u0 :: Ratio Integer) -> case _APP_ _SPEC_ _CONSTM_ RealFrac properFraction (Ratio Integer) [ (Int) ] [ u0 ] of { _ALG_ _TUP_2 (u1 :: Int) (u2 :: Ratio Integer) -> u1; _NO_DEFLT_ } _N_ }, [ Integer ] 1 { _A_ 1 _U_ 1 _N_ _S_ "U(U(PPP)U(PPP))" {_A_ 4 _U_ 2222 _N_ _N_ _F_ _IF_ARGS_ 0 4 XXXX 7 \ (u0 :: Int#) (u1 :: Int#) (u2 :: ByteArray#) (u3 :: Integer) -> case _APP_ _WRKR_ _SPEC_ _CONSTM_ RealFrac properFraction (Ratio Integer) [ (Integer) ] [ u0, u1, u2, u3 ] of { _ALG_ _TUP_2 (u4 :: Integer) (u5 :: Ratio Integer) -> u4; _NO_DEFLT_ } _N_} _F_ _IF_ARGS_ 0 1 X 4 \ (u0 :: Ratio Integer) -> case _APP_ _SPEC_ _CONSTM_ RealFrac properFraction (Ratio Integer) [ (Integer) ] [ u0 ] of { _ALG_ _TUP_2 (u1 :: Integer) (u2 :: Ratio Integer) -> u1; _NO_DEFLT_ } _N_ } },
+ round = { _A_ 1 _U_ 21 _N_ _N_ _N_ _SPECIALISE_ [ Int ] 1 { _A_ 1 _U_ 1 _N_ _S_ "U(U(PPP)U(PPP))" {_A_ 4 _U_ 2222 _N_ _N_ _N_ _N_} _N_ _N_ }, [ Integer ] 1 { _A_ 1 _U_ 1 _N_ _S_ "U(U(PPP)U(PPP))" {_A_ 4 _U_ 2222 _N_ _N_ _N_ _N_} _N_ _N_ } },
+ ceiling = { _A_ 1 _U_ 21 _N_ _N_ _N_ _SPECIALISE_ [ Int ] 1 { _A_ 1 _U_ 1 _N_ _S_ "U(U(PPP)U(PPP))" {_A_ 4 _U_ 2222 _N_ _N_ _N_ _N_} _N_ _N_ }, [ Integer ] 1 { _A_ 1 _U_ 1 _N_ _S_ "U(U(PPP)U(PPP))" {_A_ 4 _U_ 2222 _N_ _N_ _N_ _N_} _N_ _N_ } },
+ floor = { _A_ 1 _U_ 21 _N_ _N_ _N_ _SPECIALISE_ [ Int ] 1 { _A_ 1 _U_ 1 _N_ _S_ "U(U(PPP)U(PPP))" {_A_ 4 _U_ 2222 _N_ _N_ _N_ _N_} _N_ _N_ }, [ Integer ] 1 { _A_ 1 _U_ 1 _N_ _S_ "U(U(PPP)U(PPP))" {_A_ 4 _U_ 2222 _N_ _N_ _N_ _N_} _N_ _N_ } } #-}
instance Integral a => Text (Ratio a)
{-# GHC_PRAGMA _M_ PreludeRatio {-dfun-} _A_ 1 _U_ 2 _N_ _N_ _N_ _N_ #-}
instance Text (Ratio Integer)
{-# GHC_PRAGMA _M_ PreludeRatio {-dfun-} _A_ 0 _N_ _N_ _N_ _F_ _IF_ARGS_ 0 0 X 5 _!_ _TUP_4 [(Int -> [Char] -> [(Ratio Integer, [Char])]), (Int -> Ratio Integer -> [Char] -> [Char]), ([Char] -> [([Ratio Integer], [Char])]), ([Ratio Integer] -> [Char] -> [Char])] [_CONSTM_ Text readsPrec (Ratio Integer), _CONSTM_ Text showsPrec (Ratio Integer), _CONSTM_ Text readList (Ratio Integer), _CONSTM_ Text showList (Ratio Integer)] _N_
- readsPrec = _A_ 1 _U_ 12 _N_ _S_ "U(P)" {_A_ 1 _U_ 22 _N_ _N_ _N_ _N_} _N_ _N_,
- showsPrec = _A_ 2 _U_ 112 _N_ _S_ "LU(LL)" {_A_ 3 _U_ 1222 _N_ _N_ _N_ _N_} _N_ _N_,
- readList = _A_ 0 _U_ 2 _N_ _N_ _N_ _N_,
- showList = _A_ 0 _U_ 12 _N_ _N_ _N_ _N_ #-}
+ readsPrec = { _A_ 1 _U_ 12 _N_ _S_ "U(P)" {_A_ 1 _U_ 22 _N_ _N_ _N_ _N_} _N_ _N_ },
+ showsPrec = { _A_ 2 _U_ 112 _N_ _S_ "LU(LL)" {_A_ 3 _U_ 1222 _N_ _N_ _N_ _N_} _N_ _N_ },
+ readList = { _A_ 0 _U_ 2 _N_ _N_ _N_ _N_ },
+ showList = { _A_ 1 _U_ 12 _N_ _N_ _N_ _N_ } #-}
-{-# GHC_PRAGMA INTERFACE VERSION 5 #-}
+{-# GHC_PRAGMA INTERFACE VERSION 6 #-}
interface PreludeBuiltin where
import PreludeCore(Enum(..), Eq(..), Ix(..), Ord(..), Text(..))
instance Enum ()
{-# GHC_PRAGMA _M_ PreludeBuiltin {-dfun-} _A_ 0 _N_ _N_ _N_ _F_ _IF_ARGS_ 0 0 X 6 _!_ _TUP_5 [{{Ord ()}}, (() -> [()]), (() -> () -> [()]), (() -> () -> [()]), (() -> () -> () -> [()])] [_DFUN_ Ord (()), _CONSTM_ Enum enumFrom (()), _CONSTM_ Enum enumFromThen (()), _CONSTM_ Enum enumFromTo (()), _CONSTM_ Enum enumFromThenTo (())] _N_
- enumFrom = _A_ 1 _U_ 2 _N_ _S_ "E" _N_ _N_,
- enumFromThen = _A_ 2 _U_ 21 _N_ _S_ "EE" _F_ _IF_ARGS_ 0 2 CC 7 \ (u0 :: ()) (u1 :: ()) -> case u0 of { _ALG_ _TUP_0 -> case u1 of { _ALG_ _TUP_0 -> let {(u2 :: [()]) = _!_ _NIL_ [()] []} in _!_ (:) [()] [u0, u2]; _NO_DEFLT_ }; _NO_DEFLT_ } _N_,
- enumFromTo = _A_ 2 _U_ 21 _N_ _S_ "EE" _F_ _IF_ARGS_ 0 2 CC 7 \ (u0 :: ()) (u1 :: ()) -> case u0 of { _ALG_ _TUP_0 -> case u1 of { _ALG_ _TUP_0 -> let {(u2 :: [()]) = _!_ _NIL_ [()] []} in _!_ (:) [()] [u0, u2]; _NO_DEFLT_ }; _NO_DEFLT_ } _N_,
- enumFromThenTo = _A_ 3 _U_ 211 _N_ _S_ "EEE" _F_ _IF_ARGS_ 0 3 CCC 8 \ (u0 :: ()) (u1 :: ()) (u2 :: ()) -> case u0 of { _ALG_ _TUP_0 -> case u1 of { _ALG_ _TUP_0 -> case u2 of { _ALG_ _TUP_0 -> let {(u3 :: [()]) = _!_ _NIL_ [()] []} in _!_ (:) [()] [u0, u3]; _NO_DEFLT_ }; _NO_DEFLT_ }; _NO_DEFLT_ } _N_ #-}
+ enumFrom = { _A_ 1 _U_ 2 _N_ _S_ "E" _N_ _N_ },
+ enumFromThen = { _A_ 2 _U_ 21 _N_ _S_ "EE" _F_ _IF_ARGS_ 0 2 CC 7 \ (u0 :: ()) (u1 :: ()) -> case u0 of { _ALG_ _TUP_0 -> case u1 of { _ALG_ _TUP_0 -> let {(u2 :: [()]) = _!_ _NIL_ [()] []} in _!_ (:) [()] [u0, u2]; _NO_DEFLT_ }; _NO_DEFLT_ } _N_ },
+ enumFromTo = { _A_ 2 _U_ 21 _N_ _S_ "EE" _F_ _IF_ARGS_ 0 2 CC 7 \ (u0 :: ()) (u1 :: ()) -> case u0 of { _ALG_ _TUP_0 -> case u1 of { _ALG_ _TUP_0 -> let {(u2 :: [()]) = _!_ _NIL_ [()] []} in _!_ (:) [()] [u0, u2]; _NO_DEFLT_ }; _NO_DEFLT_ } _N_ },
+ enumFromThenTo = { _A_ 3 _U_ 211 _N_ _S_ "EEE" _F_ _IF_ARGS_ 0 3 CCC 8 \ (u0 :: ()) (u1 :: ()) (u2 :: ()) -> case u0 of { _ALG_ _TUP_0 -> case u1 of { _ALG_ _TUP_0 -> case u2 of { _ALG_ _TUP_0 -> let {(u3 :: [()]) = _!_ _NIL_ [()] []} in _!_ (:) [()] [u0, u3]; _NO_DEFLT_ }; _NO_DEFLT_ }; _NO_DEFLT_ } _N_ } #-}
instance Eq ()
{-# GHC_PRAGMA _M_ PreludeBuiltin {-dfun-} _A_ 0 _N_ _N_ _N_ _F_ _IF_ARGS_ 0 0 X 3 _!_ _TUP_2 [(() -> () -> Bool), (() -> () -> Bool)] [_CONSTM_ Eq (==) (()), _CONSTM_ Eq (/=) (())] _N_
- (==) = _A_ 2 _U_ 11 _N_ _S_ "EE" _F_ _IF_ARGS_ 0 2 CC 3 \ (u0 :: ()) (u1 :: ()) -> case u0 of { _ALG_ _TUP_0 -> case u1 of { _ALG_ _TUP_0 -> _!_ True [] []; _NO_DEFLT_ }; _NO_DEFLT_ } _N_,
- (/=) = _A_ 2 _U_ 11 _N_ _S_ "EE" _F_ _IF_ARGS_ 0 2 CC 3 \ (u0 :: ()) (u1 :: ()) -> case u0 of { _ALG_ _TUP_0 -> case u1 of { _ALG_ _TUP_0 -> _!_ False [] []; _NO_DEFLT_ }; _NO_DEFLT_ } _N_ #-}
+ (==) = { _A_ 2 _U_ 11 _N_ _S_ "EE" _F_ _IF_ARGS_ 0 2 CC 3 \ (u0 :: ()) (u1 :: ()) -> case u0 of { _ALG_ _TUP_0 -> case u1 of { _ALG_ _TUP_0 -> _!_ True [] []; _NO_DEFLT_ }; _NO_DEFLT_ } _N_ },
+ (/=) = { _A_ 2 _U_ 11 _N_ _S_ "EE" _F_ _IF_ARGS_ 0 2 CC 3 \ (u0 :: ()) (u1 :: ()) -> case u0 of { _ALG_ _TUP_0 -> case u1 of { _ALG_ _TUP_0 -> _!_ False [] []; _NO_DEFLT_ }; _NO_DEFLT_ } _N_ } #-}
instance Ix ()
{-# GHC_PRAGMA _M_ PreludeBuiltin {-dfun-} _A_ 0 _N_ _N_ _N_ _F_ _IF_ARGS_ 0 0 X 5 _!_ _TUP_4 [{{Ord ()}}, (((), ()) -> [()]), (((), ()) -> () -> Int), (((), ()) -> () -> Bool)] [_DFUN_ Ord (()), _CONSTM_ Ix range (()), _CONSTM_ Ix index (()), _CONSTM_ Ix inRange (())] _N_
- range = _A_ 1 _U_ 1 _N_ _S_ "U(EE)" {_A_ 2 _U_ 21 _N_ _N_ _N_ _N_} _N_ _N_,
- index = _A_ 2 _U_ 11 _N_ _S_ "U(EE)E" {_A_ 3 _U_ 111 _N_ _N_ _F_ _IF_ARGS_ 0 3 CCC 5 \ (u0 :: ()) (u1 :: ()) (u2 :: ()) -> case u0 of { _ALG_ _TUP_0 -> case u1 of { _ALG_ _TUP_0 -> case u2 of { _ALG_ _TUP_0 -> _!_ I# [] [0#]; _NO_DEFLT_ }; _NO_DEFLT_ }; _NO_DEFLT_ } _N_} _F_ _IF_ARGS_ 0 2 CC 6 \ (u0 :: ((), ())) (u1 :: ()) -> case u0 of { _ALG_ _TUP_2 (u2 :: ()) (u3 :: ()) -> case u2 of { _ALG_ _TUP_0 -> case u3 of { _ALG_ _TUP_0 -> case u1 of { _ALG_ _TUP_0 -> _!_ I# [] [0#]; _NO_DEFLT_ }; _NO_DEFLT_ }; _NO_DEFLT_ }; _NO_DEFLT_ } _N_,
- inRange = _A_ 2 _U_ 11 _N_ _S_ "U(EE)E" {_A_ 3 _U_ 111 _N_ _N_ _F_ _IF_ARGS_ 0 3 CCC 4 \ (u0 :: ()) (u1 :: ()) (u2 :: ()) -> case u0 of { _ALG_ _TUP_0 -> case u1 of { _ALG_ _TUP_0 -> case u2 of { _ALG_ _TUP_0 -> _!_ True [] []; _NO_DEFLT_ }; _NO_DEFLT_ }; _NO_DEFLT_ } _N_} _F_ _IF_ARGS_ 0 2 CC 5 \ (u0 :: ((), ())) (u1 :: ()) -> case u0 of { _ALG_ _TUP_2 (u2 :: ()) (u3 :: ()) -> case u2 of { _ALG_ _TUP_0 -> case u3 of { _ALG_ _TUP_0 -> case u1 of { _ALG_ _TUP_0 -> _!_ True [] []; _NO_DEFLT_ }; _NO_DEFLT_ }; _NO_DEFLT_ }; _NO_DEFLT_ } _N_ #-}
+ range = { _A_ 1 _U_ 1 _N_ _S_ "U(EE)" {_A_ 2 _U_ 21 _N_ _N_ _N_ _N_} _N_ _N_ },
+ index = { _A_ 2 _U_ 11 _N_ _S_ "U(EE)E" {_A_ 3 _U_ 111 _N_ _N_ _F_ _IF_ARGS_ 0 3 CCC 5 \ (u0 :: ()) (u1 :: ()) (u2 :: ()) -> case u0 of { _ALG_ _TUP_0 -> case u1 of { _ALG_ _TUP_0 -> case u2 of { _ALG_ _TUP_0 -> _!_ I# [] [0#]; _NO_DEFLT_ }; _NO_DEFLT_ }; _NO_DEFLT_ } _N_} _F_ _IF_ARGS_ 0 2 CC 6 \ (u0 :: ((), ())) (u1 :: ()) -> case u0 of { _ALG_ _TUP_2 (u2 :: ()) (u3 :: ()) -> case u2 of { _ALG_ _TUP_0 -> case u3 of { _ALG_ _TUP_0 -> case u1 of { _ALG_ _TUP_0 -> _!_ I# [] [0#]; _NO_DEFLT_ }; _NO_DEFLT_ }; _NO_DEFLT_ }; _NO_DEFLT_ } _N_ },
+ inRange = { _A_ 2 _U_ 11 _N_ _S_ "U(EE)E" {_A_ 3 _U_ 111 _N_ _N_ _F_ _IF_ARGS_ 0 3 CCC 4 \ (u0 :: ()) (u1 :: ()) (u2 :: ()) -> case u0 of { _ALG_ _TUP_0 -> case u1 of { _ALG_ _TUP_0 -> case u2 of { _ALG_ _TUP_0 -> _!_ True [] []; _NO_DEFLT_ }; _NO_DEFLT_ }; _NO_DEFLT_ } _N_} _F_ _IF_ARGS_ 0 2 CC 5 \ (u0 :: ((), ())) (u1 :: ()) -> case u0 of { _ALG_ _TUP_2 (u2 :: ()) (u3 :: ()) -> case u2 of { _ALG_ _TUP_0 -> case u3 of { _ALG_ _TUP_0 -> case u1 of { _ALG_ _TUP_0 -> _!_ True [] []; _NO_DEFLT_ }; _NO_DEFLT_ }; _NO_DEFLT_ }; _NO_DEFLT_ } _N_ } #-}
instance Ord ()
{-# GHC_PRAGMA _M_ PreludeBuiltin {-dfun-} _A_ 0 _N_ _N_ _N_ _F_ _IF_ARGS_ 0 0 X 9 _!_ _TUP_8 [{{Eq ()}}, (() -> () -> Bool), (() -> () -> Bool), (() -> () -> Bool), (() -> () -> Bool), (() -> () -> ()), (() -> () -> ()), (() -> () -> _CMP_TAG)] [_DFUN_ Eq (()), _CONSTM_ Ord (<) (()), _CONSTM_ Ord (<=) (()), _CONSTM_ Ord (>=) (()), _CONSTM_ Ord (>) (()), _CONSTM_ Ord max (()), _CONSTM_ Ord min (()), _CONSTM_ Ord _tagCmp (())] _N_
- (<) = _A_ 2 _U_ 11 _N_ _S_ "EE" _F_ _IF_ARGS_ 0 2 CC 3 \ (u0 :: ()) (u1 :: ()) -> case u0 of { _ALG_ _TUP_0 -> case u1 of { _ALG_ _TUP_0 -> _!_ False [] []; _NO_DEFLT_ }; _NO_DEFLT_ } _N_,
- (<=) = _A_ 2 _U_ 11 _N_ _S_ "EE" _F_ _IF_ARGS_ 0 2 CC 3 \ (u0 :: ()) (u1 :: ()) -> case u0 of { _ALG_ _TUP_0 -> case u1 of { _ALG_ _TUP_0 -> _!_ True [] []; _NO_DEFLT_ }; _NO_DEFLT_ } _N_,
- (>=) = _A_ 2 _U_ 11 _N_ _S_ "EE" _F_ _IF_ARGS_ 0 2 CC 3 \ (u0 :: ()) (u1 :: ()) -> case u0 of { _ALG_ _TUP_0 -> case u1 of { _ALG_ _TUP_0 -> _!_ True [] []; _NO_DEFLT_ }; _NO_DEFLT_ } _N_,
- (>) = _A_ 2 _U_ 11 _N_ _S_ "EE" _F_ _IF_ARGS_ 0 2 CC 3 \ (u0 :: ()) (u1 :: ()) -> case u0 of { _ALG_ _TUP_0 -> case u1 of { _ALG_ _TUP_0 -> _!_ False [] []; _NO_DEFLT_ }; _NO_DEFLT_ } _N_,
- max = _A_ 2 _U_ 11 _N_ _S_ "EE" _F_ _IF_ARGS_ 0 2 CX 2 \ (u0 :: ()) (u1 :: ()) -> case u0 of { _ALG_ _TUP_0 -> u1; _NO_DEFLT_ } _N_,
- min = _A_ 2 _U_ 11 _N_ _S_ "EE" _F_ _IF_ARGS_ 0 2 CX 2 \ (u0 :: ()) (u1 :: ()) -> case u0 of { _ALG_ _TUP_0 -> u1; _NO_DEFLT_ } _N_,
- _tagCmp = _A_ 2 _U_ 11 _N_ _S_ "EE" _F_ _IF_ARGS_ 0 2 CC 3 \ (u0 :: ()) (u1 :: ()) -> case u0 of { _ALG_ _TUP_0 -> case u1 of { _ALG_ _TUP_0 -> _!_ _EQ [] []; _NO_DEFLT_ }; _NO_DEFLT_ } _N_ #-}
+ (<) = { _A_ 2 _U_ 11 _N_ _S_ "EE" _F_ _IF_ARGS_ 0 2 CC 3 \ (u0 :: ()) (u1 :: ()) -> case u0 of { _ALG_ _TUP_0 -> case u1 of { _ALG_ _TUP_0 -> _!_ False [] []; _NO_DEFLT_ }; _NO_DEFLT_ } _N_ },
+ (<=) = { _A_ 2 _U_ 11 _N_ _S_ "EE" _F_ _IF_ARGS_ 0 2 CC 3 \ (u0 :: ()) (u1 :: ()) -> case u0 of { _ALG_ _TUP_0 -> case u1 of { _ALG_ _TUP_0 -> _!_ True [] []; _NO_DEFLT_ }; _NO_DEFLT_ } _N_ },
+ (>=) = { _A_ 2 _U_ 11 _N_ _S_ "EE" _F_ _IF_ARGS_ 0 2 CC 3 \ (u0 :: ()) (u1 :: ()) -> case u0 of { _ALG_ _TUP_0 -> case u1 of { _ALG_ _TUP_0 -> _!_ True [] []; _NO_DEFLT_ }; _NO_DEFLT_ } _N_ },
+ (>) = { _A_ 2 _U_ 11 _N_ _S_ "EE" _F_ _IF_ARGS_ 0 2 CC 3 \ (u0 :: ()) (u1 :: ()) -> case u0 of { _ALG_ _TUP_0 -> case u1 of { _ALG_ _TUP_0 -> _!_ False [] []; _NO_DEFLT_ }; _NO_DEFLT_ } _N_ },
+ max = { _A_ 2 _U_ 11 _N_ _S_ "EE" _F_ _IF_ARGS_ 0 2 CX 2 \ (u0 :: ()) (u1 :: ()) -> case u0 of { _ALG_ _TUP_0 -> u1; _NO_DEFLT_ } _N_ },
+ min = { _A_ 2 _U_ 11 _N_ _S_ "EE" _F_ _IF_ARGS_ 0 2 CX 2 \ (u0 :: ()) (u1 :: ()) -> case u0 of { _ALG_ _TUP_0 -> u1; _NO_DEFLT_ } _N_ },
+ _tagCmp = { _A_ 2 _U_ 11 _N_ _S_ "EE" _F_ _IF_ARGS_ 0 2 CC 3 \ (u0 :: ()) (u1 :: ()) -> case u0 of { _ALG_ _TUP_0 -> case u1 of { _ALG_ _TUP_0 -> _!_ _EQ [] []; _NO_DEFLT_ }; _NO_DEFLT_ } _N_ } #-}
instance Text ()
{-# GHC_PRAGMA _M_ PreludeBuiltin {-dfun-} _A_ 0 _N_ _N_ _N_ _F_ _IF_ARGS_ 0 0 X 5 _!_ _TUP_4 [(Int -> [Char] -> [((), [Char])]), (Int -> () -> [Char] -> [Char]), ([Char] -> [([()], [Char])]), ([()] -> [Char] -> [Char])] [_CONSTM_ Text readsPrec (()), _CONSTM_ Text showsPrec (()), _CONSTM_ Text readList (()), _CONSTM_ Text showList (())] _N_
- readsPrec = _A_ 1 _U_ 02 _N_ _S_ "A" {_A_ 0 _U_ 2 _N_ _N_ _N_ _N_} _N_ _N_,
- showsPrec = _A_ 3 _U_ 012 _N_ _S_ "AEL" {_A_ 2 _U_ 12 _N_ _N_ _F_ _IF_ARGS_ 0 2 CX 4 \ (u0 :: ()) (u1 :: [Char]) -> case u0 of { _ALG_ _TUP_0 -> _APP_ _TYAPP_ _ORIG_ PreludeList (++) { Char } [ _NOREP_S_ "()", u1 ]; _NO_DEFLT_ } _N_} _F_ _IF_ARGS_ 0 3 XCX 4 \ (u0 :: Int) (u1 :: ()) (u2 :: [Char]) -> case u1 of { _ALG_ _TUP_0 -> _APP_ _TYAPP_ _ORIG_ PreludeList (++) { Char } [ _NOREP_S_ "()", u2 ]; _NO_DEFLT_ } _N_,
- readList = _A_ 0 _U_ 2 _N_ _N_ _N_ _N_,
- showList = _A_ 0 _U_ 12 _N_ _N_ _N_ _N_ #-}
+ readsPrec = { _A_ 1 _U_ 02 _N_ _S_ "A" {_A_ 0 _U_ 2 _N_ _N_ _N_ _N_} _N_ _N_ },
+ showsPrec = { _A_ 3 _U_ 012 _N_ _S_ "AEL" {_A_ 2 _U_ 12 _N_ _N_ _F_ _IF_ARGS_ 0 2 CX 4 \ (u0 :: ()) (u1 :: [Char]) -> case u0 of { _ALG_ _TUP_0 -> _APP_ _TYAPP_ _ORIG_ PreludeList (++) { Char } [ _NOREP_S_ "()", u1 ]; _NO_DEFLT_ } _N_} _F_ _IF_ARGS_ 0 3 XCX 4 \ (u0 :: Int) (u1 :: ()) (u2 :: [Char]) -> case u1 of { _ALG_ _TUP_0 -> _APP_ _TYAPP_ _ORIG_ PreludeList (++) { Char } [ _NOREP_S_ "()", u2 ]; _NO_DEFLT_ } _N_ },
+ readList = { _A_ 0 _U_ 2 _N_ _N_ _N_ _N_ },
+ showList = { _A_ 1 _U_ 12 _N_ _N_ _N_ _N_ } #-}
import List ( (++), foldr )
import PS ( _PackedString, _unpackPS )
import Text
+import TyArray
+import TyComplex
instance Eq () where
() == () = True
(\r -> [((),t) | ("(",s) <- lex r,
(")",t) <- lex s ] )
showsPrec p () = showString "()"
+ readList = _readList (readsPrec 0)
+ showList = _showList (showsPrec 0)
instance Ix () where
range ((), ()) = [()]
-{-# GHC_PRAGMA INTERFACE VERSION 5 #-}
+{-# GHC_PRAGMA INTERFACE VERSION 6 #-}
interface PreludeBuiltin where
import PreludeCore(Enum(..), Eq(..), Ix(..), Ord(..), Text(..))
instance Enum ()
{-# GHC_PRAGMA _M_ PreludeBuiltin {-dfun-} _A_ 0 _N_ _N_ _N_ _F_ _IF_ARGS_ 0 0 X 6 _!_ _TUP_5 [{{Ord ()}}, (() -> [()]), (() -> () -> [()]), (() -> () -> [()]), (() -> () -> () -> [()])] [_DFUN_ Ord (()), _CONSTM_ Enum enumFrom (()), _CONSTM_ Enum enumFromThen (()), _CONSTM_ Enum enumFromTo (()), _CONSTM_ Enum enumFromThenTo (())] _N_
- enumFrom = _A_ 1 _U_ 2 _N_ _S_ "E" _N_ _N_,
- enumFromThen = _A_ 2 _U_ 21 _N_ _S_ "EE" _F_ _IF_ARGS_ 0 2 CC 7 \ (u0 :: ()) (u1 :: ()) -> case u0 of { _ALG_ _TUP_0 -> case u1 of { _ALG_ _TUP_0 -> let {(u2 :: [()]) = _!_ _NIL_ [()] []} in _!_ (:) [()] [u0, u2]; _NO_DEFLT_ }; _NO_DEFLT_ } _N_,
- enumFromTo = _A_ 2 _U_ 21 _N_ _S_ "EE" _F_ _IF_ARGS_ 0 2 CC 7 \ (u0 :: ()) (u1 :: ()) -> case u0 of { _ALG_ _TUP_0 -> case u1 of { _ALG_ _TUP_0 -> let {(u2 :: [()]) = _!_ _NIL_ [()] []} in _!_ (:) [()] [u0, u2]; _NO_DEFLT_ }; _NO_DEFLT_ } _N_,
- enumFromThenTo = _A_ 3 _U_ 211 _N_ _S_ "EEE" _F_ _IF_ARGS_ 0 3 CCC 8 \ (u0 :: ()) (u1 :: ()) (u2 :: ()) -> case u0 of { _ALG_ _TUP_0 -> case u1 of { _ALG_ _TUP_0 -> case u2 of { _ALG_ _TUP_0 -> let {(u3 :: [()]) = _!_ _NIL_ [()] []} in _!_ (:) [()] [u0, u3]; _NO_DEFLT_ }; _NO_DEFLT_ }; _NO_DEFLT_ } _N_ #-}
+ enumFrom = { _A_ 1 _U_ 2 _N_ _S_ "E" _N_ _N_ },
+ enumFromThen = { _A_ 2 _U_ 21 _N_ _S_ "EE" _F_ _IF_ARGS_ 0 2 CC 7 \ (u0 :: ()) (u1 :: ()) -> case u0 of { _ALG_ _TUP_0 -> case u1 of { _ALG_ _TUP_0 -> let {(u2 :: [()]) = _!_ _NIL_ [()] []} in _!_ (:) [()] [u0, u2]; _NO_DEFLT_ }; _NO_DEFLT_ } _N_ },
+ enumFromTo = { _A_ 2 _U_ 21 _N_ _S_ "EE" _F_ _IF_ARGS_ 0 2 CC 7 \ (u0 :: ()) (u1 :: ()) -> case u0 of { _ALG_ _TUP_0 -> case u1 of { _ALG_ _TUP_0 -> let {(u2 :: [()]) = _!_ _NIL_ [()] []} in _!_ (:) [()] [u0, u2]; _NO_DEFLT_ }; _NO_DEFLT_ } _N_ },
+ enumFromThenTo = { _A_ 3 _U_ 211 _N_ _S_ "EEE" _F_ _IF_ARGS_ 0 3 CCC 8 \ (u0 :: ()) (u1 :: ()) (u2 :: ()) -> case u0 of { _ALG_ _TUP_0 -> case u1 of { _ALG_ _TUP_0 -> case u2 of { _ALG_ _TUP_0 -> let {(u3 :: [()]) = _!_ _NIL_ [()] []} in _!_ (:) [()] [u0, u3]; _NO_DEFLT_ }; _NO_DEFLT_ }; _NO_DEFLT_ } _N_ } #-}
instance Eq ()
{-# GHC_PRAGMA _M_ PreludeBuiltin {-dfun-} _A_ 0 _N_ _N_ _N_ _F_ _IF_ARGS_ 0 0 X 3 _!_ _TUP_2 [(() -> () -> Bool), (() -> () -> Bool)] [_CONSTM_ Eq (==) (()), _CONSTM_ Eq (/=) (())] _N_
- (==) = _A_ 2 _U_ 11 _N_ _S_ "EE" _F_ _IF_ARGS_ 0 2 CC 3 \ (u0 :: ()) (u1 :: ()) -> case u0 of { _ALG_ _TUP_0 -> case u1 of { _ALG_ _TUP_0 -> _!_ True [] []; _NO_DEFLT_ }; _NO_DEFLT_ } _N_,
- (/=) = _A_ 2 _U_ 11 _N_ _S_ "EE" _F_ _IF_ARGS_ 0 2 CC 3 \ (u0 :: ()) (u1 :: ()) -> case u0 of { _ALG_ _TUP_0 -> case u1 of { _ALG_ _TUP_0 -> _!_ False [] []; _NO_DEFLT_ }; _NO_DEFLT_ } _N_ #-}
+ (==) = { _A_ 2 _U_ 11 _N_ _S_ "EE" _F_ _IF_ARGS_ 0 2 CC 3 \ (u0 :: ()) (u1 :: ()) -> case u0 of { _ALG_ _TUP_0 -> case u1 of { _ALG_ _TUP_0 -> _!_ True [] []; _NO_DEFLT_ }; _NO_DEFLT_ } _N_ },
+ (/=) = { _A_ 2 _U_ 11 _N_ _S_ "EE" _F_ _IF_ARGS_ 0 2 CC 3 \ (u0 :: ()) (u1 :: ()) -> case u0 of { _ALG_ _TUP_0 -> case u1 of { _ALG_ _TUP_0 -> _!_ False [] []; _NO_DEFLT_ }; _NO_DEFLT_ } _N_ } #-}
instance Ix ()
{-# GHC_PRAGMA _M_ PreludeBuiltin {-dfun-} _A_ 0 _N_ _N_ _N_ _F_ _IF_ARGS_ 0 0 X 5 _!_ _TUP_4 [{{Ord ()}}, (((), ()) -> [()]), (((), ()) -> () -> Int), (((), ()) -> () -> Bool)] [_DFUN_ Ord (()), _CONSTM_ Ix range (()), _CONSTM_ Ix index (()), _CONSTM_ Ix inRange (())] _N_
- range = _A_ 1 _U_ 1 _N_ _S_ "U(EE)" {_A_ 2 _U_ 21 _N_ _N_ _N_ _N_} _N_ _N_,
- index = _A_ 2 _U_ 11 _N_ _S_ "U(EE)E" {_A_ 3 _U_ 111 _N_ _N_ _F_ _IF_ARGS_ 0 3 CCC 5 \ (u0 :: ()) (u1 :: ()) (u2 :: ()) -> case u0 of { _ALG_ _TUP_0 -> case u1 of { _ALG_ _TUP_0 -> case u2 of { _ALG_ _TUP_0 -> _!_ I# [] [0#]; _NO_DEFLT_ }; _NO_DEFLT_ }; _NO_DEFLT_ } _N_} _F_ _IF_ARGS_ 0 2 CC 6 \ (u0 :: ((), ())) (u1 :: ()) -> case u0 of { _ALG_ _TUP_2 (u2 :: ()) (u3 :: ()) -> case u2 of { _ALG_ _TUP_0 -> case u3 of { _ALG_ _TUP_0 -> case u1 of { _ALG_ _TUP_0 -> _!_ I# [] [0#]; _NO_DEFLT_ }; _NO_DEFLT_ }; _NO_DEFLT_ }; _NO_DEFLT_ } _N_,
- inRange = _A_ 2 _U_ 11 _N_ _S_ "U(EE)E" {_A_ 3 _U_ 111 _N_ _N_ _F_ _IF_ARGS_ 0 3 CCC 4 \ (u0 :: ()) (u1 :: ()) (u2 :: ()) -> case u0 of { _ALG_ _TUP_0 -> case u1 of { _ALG_ _TUP_0 -> case u2 of { _ALG_ _TUP_0 -> _!_ True [] []; _NO_DEFLT_ }; _NO_DEFLT_ }; _NO_DEFLT_ } _N_} _F_ _IF_ARGS_ 0 2 CC 5 \ (u0 :: ((), ())) (u1 :: ()) -> case u0 of { _ALG_ _TUP_2 (u2 :: ()) (u3 :: ()) -> case u2 of { _ALG_ _TUP_0 -> case u3 of { _ALG_ _TUP_0 -> case u1 of { _ALG_ _TUP_0 -> _!_ True [] []; _NO_DEFLT_ }; _NO_DEFLT_ }; _NO_DEFLT_ }; _NO_DEFLT_ } _N_ #-}
+ range = { _A_ 1 _U_ 1 _N_ _S_ "U(EE)" {_A_ 2 _U_ 21 _N_ _N_ _N_ _N_} _N_ _N_ },
+ index = { _A_ 2 _U_ 11 _N_ _S_ "U(EE)E" {_A_ 3 _U_ 111 _N_ _N_ _F_ _IF_ARGS_ 0 3 CCC 5 \ (u0 :: ()) (u1 :: ()) (u2 :: ()) -> case u0 of { _ALG_ _TUP_0 -> case u1 of { _ALG_ _TUP_0 -> case u2 of { _ALG_ _TUP_0 -> _!_ I# [] [0#]; _NO_DEFLT_ }; _NO_DEFLT_ }; _NO_DEFLT_ } _N_} _F_ _IF_ARGS_ 0 2 CC 6 \ (u0 :: ((), ())) (u1 :: ()) -> case u0 of { _ALG_ _TUP_2 (u2 :: ()) (u3 :: ()) -> case u2 of { _ALG_ _TUP_0 -> case u3 of { _ALG_ _TUP_0 -> case u1 of { _ALG_ _TUP_0 -> _!_ I# [] [0#]; _NO_DEFLT_ }; _NO_DEFLT_ }; _NO_DEFLT_ }; _NO_DEFLT_ } _N_ },
+ inRange = { _A_ 2 _U_ 11 _N_ _S_ "U(EE)E" {_A_ 3 _U_ 111 _N_ _N_ _F_ _IF_ARGS_ 0 3 CCC 4 \ (u0 :: ()) (u1 :: ()) (u2 :: ()) -> case u0 of { _ALG_ _TUP_0 -> case u1 of { _ALG_ _TUP_0 -> case u2 of { _ALG_ _TUP_0 -> _!_ True [] []; _NO_DEFLT_ }; _NO_DEFLT_ }; _NO_DEFLT_ } _N_} _F_ _IF_ARGS_ 0 2 CC 5 \ (u0 :: ((), ())) (u1 :: ()) -> case u0 of { _ALG_ _TUP_2 (u2 :: ()) (u3 :: ()) -> case u2 of { _ALG_ _TUP_0 -> case u3 of { _ALG_ _TUP_0 -> case u1 of { _ALG_ _TUP_0 -> _!_ True [] []; _NO_DEFLT_ }; _NO_DEFLT_ }; _NO_DEFLT_ }; _NO_DEFLT_ } _N_ } #-}
instance Ord ()
{-# GHC_PRAGMA _M_ PreludeBuiltin {-dfun-} _A_ 0 _N_ _N_ _N_ _F_ _IF_ARGS_ 0 0 X 9 _!_ _TUP_8 [{{Eq ()}}, (() -> () -> Bool), (() -> () -> Bool), (() -> () -> Bool), (() -> () -> Bool), (() -> () -> ()), (() -> () -> ()), (() -> () -> _CMP_TAG)] [_DFUN_ Eq (()), _CONSTM_ Ord (<) (()), _CONSTM_ Ord (<=) (()), _CONSTM_ Ord (>=) (()), _CONSTM_ Ord (>) (()), _CONSTM_ Ord max (()), _CONSTM_ Ord min (()), _CONSTM_ Ord _tagCmp (())] _N_
- (<) = _A_ 2 _U_ 11 _N_ _S_ "EE" _F_ _IF_ARGS_ 0 2 CC 3 \ (u0 :: ()) (u1 :: ()) -> case u0 of { _ALG_ _TUP_0 -> case u1 of { _ALG_ _TUP_0 -> _!_ False [] []; _NO_DEFLT_ }; _NO_DEFLT_ } _N_,
- (<=) = _A_ 2 _U_ 11 _N_ _S_ "EE" _F_ _IF_ARGS_ 0 2 CC 3 \ (u0 :: ()) (u1 :: ()) -> case u0 of { _ALG_ _TUP_0 -> case u1 of { _ALG_ _TUP_0 -> _!_ True [] []; _NO_DEFLT_ }; _NO_DEFLT_ } _N_,
- (>=) = _A_ 2 _U_ 11 _N_ _S_ "EE" _F_ _IF_ARGS_ 0 2 CC 3 \ (u0 :: ()) (u1 :: ()) -> case u0 of { _ALG_ _TUP_0 -> case u1 of { _ALG_ _TUP_0 -> _!_ True [] []; _NO_DEFLT_ }; _NO_DEFLT_ } _N_,
- (>) = _A_ 2 _U_ 11 _N_ _S_ "EE" _F_ _IF_ARGS_ 0 2 CC 3 \ (u0 :: ()) (u1 :: ()) -> case u0 of { _ALG_ _TUP_0 -> case u1 of { _ALG_ _TUP_0 -> _!_ False [] []; _NO_DEFLT_ }; _NO_DEFLT_ } _N_,
- max = _A_ 2 _U_ 11 _N_ _S_ "EE" _F_ _IF_ARGS_ 0 2 CX 2 \ (u0 :: ()) (u1 :: ()) -> case u0 of { _ALG_ _TUP_0 -> u1; _NO_DEFLT_ } _N_,
- min = _A_ 2 _U_ 11 _N_ _S_ "EE" _F_ _IF_ARGS_ 0 2 CX 2 \ (u0 :: ()) (u1 :: ()) -> case u0 of { _ALG_ _TUP_0 -> u1; _NO_DEFLT_ } _N_,
- _tagCmp = _A_ 2 _U_ 11 _N_ _S_ "EE" _F_ _IF_ARGS_ 0 2 CC 3 \ (u0 :: ()) (u1 :: ()) -> case u0 of { _ALG_ _TUP_0 -> case u1 of { _ALG_ _TUP_0 -> _!_ _EQ [] []; _NO_DEFLT_ }; _NO_DEFLT_ } _N_ #-}
+ (<) = { _A_ 2 _U_ 11 _N_ _S_ "EE" _F_ _IF_ARGS_ 0 2 CC 3 \ (u0 :: ()) (u1 :: ()) -> case u0 of { _ALG_ _TUP_0 -> case u1 of { _ALG_ _TUP_0 -> _!_ False [] []; _NO_DEFLT_ }; _NO_DEFLT_ } _N_ },
+ (<=) = { _A_ 2 _U_ 11 _N_ _S_ "EE" _F_ _IF_ARGS_ 0 2 CC 3 \ (u0 :: ()) (u1 :: ()) -> case u0 of { _ALG_ _TUP_0 -> case u1 of { _ALG_ _TUP_0 -> _!_ True [] []; _NO_DEFLT_ }; _NO_DEFLT_ } _N_ },
+ (>=) = { _A_ 2 _U_ 11 _N_ _S_ "EE" _F_ _IF_ARGS_ 0 2 CC 3 \ (u0 :: ()) (u1 :: ()) -> case u0 of { _ALG_ _TUP_0 -> case u1 of { _ALG_ _TUP_0 -> _!_ True [] []; _NO_DEFLT_ }; _NO_DEFLT_ } _N_ },
+ (>) = { _A_ 2 _U_ 11 _N_ _S_ "EE" _F_ _IF_ARGS_ 0 2 CC 3 \ (u0 :: ()) (u1 :: ()) -> case u0 of { _ALG_ _TUP_0 -> case u1 of { _ALG_ _TUP_0 -> _!_ False [] []; _NO_DEFLT_ }; _NO_DEFLT_ } _N_ },
+ max = { _A_ 2 _U_ 11 _N_ _S_ "EE" _F_ _IF_ARGS_ 0 2 CX 2 \ (u0 :: ()) (u1 :: ()) -> case u0 of { _ALG_ _TUP_0 -> u1; _NO_DEFLT_ } _N_ },
+ min = { _A_ 2 _U_ 11 _N_ _S_ "EE" _F_ _IF_ARGS_ 0 2 CX 2 \ (u0 :: ()) (u1 :: ()) -> case u0 of { _ALG_ _TUP_0 -> u1; _NO_DEFLT_ } _N_ },
+ _tagCmp = { _A_ 2 _U_ 11 _N_ _S_ "EE" _F_ _IF_ARGS_ 0 2 CC 3 \ (u0 :: ()) (u1 :: ()) -> case u0 of { _ALG_ _TUP_0 -> case u1 of { _ALG_ _TUP_0 -> _!_ _EQ [] []; _NO_DEFLT_ }; _NO_DEFLT_ } _N_ } #-}
instance Text ()
{-# GHC_PRAGMA _M_ PreludeBuiltin {-dfun-} _A_ 0 _N_ _N_ _N_ _F_ _IF_ARGS_ 0 0 X 5 _!_ _TUP_4 [(Int -> [Char] -> [((), [Char])]), (Int -> () -> [Char] -> [Char]), ([Char] -> [([()], [Char])]), ([()] -> [Char] -> [Char])] [_CONSTM_ Text readsPrec (()), _CONSTM_ Text showsPrec (()), _CONSTM_ Text readList (()), _CONSTM_ Text showList (())] _N_
- readsPrec = _A_ 1 _U_ 02 _N_ _S_ "A" {_A_ 0 _U_ 2 _N_ _N_ _N_ _N_} _N_ _N_,
- showsPrec = _A_ 3 _U_ 012 _N_ _S_ "AEL" {_A_ 2 _U_ 12 _N_ _N_ _F_ _IF_ARGS_ 0 2 CX 4 \ (u0 :: ()) (u1 :: [Char]) -> case u0 of { _ALG_ _TUP_0 -> _APP_ _TYAPP_ _ORIG_ PreludeList (++) { Char } [ _NOREP_S_ "()", u1 ]; _NO_DEFLT_ } _N_} _F_ _IF_ARGS_ 0 3 XCX 4 \ (u0 :: Int) (u1 :: ()) (u2 :: [Char]) -> case u1 of { _ALG_ _TUP_0 -> _APP_ _TYAPP_ _ORIG_ PreludeList (++) { Char } [ _NOREP_S_ "()", u2 ]; _NO_DEFLT_ } _N_,
- readList = _A_ 0 _U_ 2 _N_ _N_ _N_ _N_,
- showList = _A_ 0 _U_ 12 _N_ _N_ _N_ _N_ #-}
+ readsPrec = { _A_ 1 _U_ 02 _N_ _S_ "A" {_A_ 0 _U_ 2 _N_ _N_ _N_ _N_} _N_ _N_ },
+ showsPrec = { _A_ 3 _U_ 012 _N_ _S_ "AEL" {_A_ 2 _U_ 12 _N_ _N_ _F_ _IF_ARGS_ 0 2 CX 4 \ (u0 :: ()) (u1 :: [Char]) -> case u0 of { _ALG_ _TUP_0 -> _APP_ _TYAPP_ _ORIG_ PreludeList (++) { Char } [ _NOREP_S_ "()", u1 ]; _NO_DEFLT_ } _N_} _F_ _IF_ARGS_ 0 3 XCX 4 \ (u0 :: Int) (u1 :: ()) (u2 :: [Char]) -> case u1 of { _ALG_ _TUP_0 -> _APP_ _TYAPP_ _ORIG_ PreludeList (++) { Char } [ _NOREP_S_ "()", u2 ]; _NO_DEFLT_ } _N_ },
+ readList = { _A_ 0 _U_ 2 _N_ _N_ _N_ _N_ },
+ showList = { _A_ 1 _U_ 12 _N_ _N_ _N_ _N_ } #-}
-{-# GHC_PRAGMA INTERFACE VERSION 5 #-}
+{-# GHC_PRAGMA INTERFACE VERSION 6 #-}
interface PreludeBuiltin where
import PreludeCore(Enum(..), Eq(..), Ix(..), Ord(..), Text(..))
instance Enum ()
{-# GHC_PRAGMA _M_ PreludeBuiltin {-dfun-} _A_ 0 _N_ _N_ _N_ _F_ _IF_ARGS_ 0 0 X 6 _!_ _TUP_5 [{{Ord ()}}, (() -> [()]), (() -> () -> [()]), (() -> () -> [()]), (() -> () -> () -> [()])] [_DFUN_ Ord (()), _CONSTM_ Enum enumFrom (()), _CONSTM_ Enum enumFromThen (()), _CONSTM_ Enum enumFromTo (()), _CONSTM_ Enum enumFromThenTo (())] _N_
- enumFrom = _A_ 1 _U_ 2 _N_ _S_ "E" _N_ _N_,
- enumFromThen = _A_ 2 _U_ 21 _N_ _S_ "EE" _F_ _IF_ARGS_ 0 2 CC 7 \ (u0 :: ()) (u1 :: ()) -> case u0 of { _ALG_ _TUP_0 -> case u1 of { _ALG_ _TUP_0 -> let {(u2 :: [()]) = _!_ _NIL_ [()] []} in _!_ (:) [()] [u0, u2]; _NO_DEFLT_ }; _NO_DEFLT_ } _N_,
- enumFromTo = _A_ 2 _U_ 21 _N_ _S_ "EE" _F_ _IF_ARGS_ 0 2 CC 7 \ (u0 :: ()) (u1 :: ()) -> case u0 of { _ALG_ _TUP_0 -> case u1 of { _ALG_ _TUP_0 -> let {(u2 :: [()]) = _!_ _NIL_ [()] []} in _!_ (:) [()] [u0, u2]; _NO_DEFLT_ }; _NO_DEFLT_ } _N_,
- enumFromThenTo = _A_ 3 _U_ 211 _N_ _S_ "EEE" _F_ _IF_ARGS_ 0 3 CCC 8 \ (u0 :: ()) (u1 :: ()) (u2 :: ()) -> case u0 of { _ALG_ _TUP_0 -> case u1 of { _ALG_ _TUP_0 -> case u2 of { _ALG_ _TUP_0 -> let {(u3 :: [()]) = _!_ _NIL_ [()] []} in _!_ (:) [()] [u0, u3]; _NO_DEFLT_ }; _NO_DEFLT_ }; _NO_DEFLT_ } _N_ #-}
+ enumFrom = { _A_ 1 _U_ 2 _N_ _S_ "E" _N_ _N_ },
+ enumFromThen = { _A_ 2 _U_ 21 _N_ _S_ "EE" _F_ _IF_ARGS_ 0 2 CC 7 \ (u0 :: ()) (u1 :: ()) -> case u0 of { _ALG_ _TUP_0 -> case u1 of { _ALG_ _TUP_0 -> let {(u2 :: [()]) = _!_ _NIL_ [()] []} in _!_ (:) [()] [u0, u2]; _NO_DEFLT_ }; _NO_DEFLT_ } _N_ },
+ enumFromTo = { _A_ 2 _U_ 21 _N_ _S_ "EE" _F_ _IF_ARGS_ 0 2 CC 7 \ (u0 :: ()) (u1 :: ()) -> case u0 of { _ALG_ _TUP_0 -> case u1 of { _ALG_ _TUP_0 -> let {(u2 :: [()]) = _!_ _NIL_ [()] []} in _!_ (:) [()] [u0, u2]; _NO_DEFLT_ }; _NO_DEFLT_ } _N_ },
+ enumFromThenTo = { _A_ 3 _U_ 211 _N_ _S_ "EEE" _F_ _IF_ARGS_ 0 3 CCC 8 \ (u0 :: ()) (u1 :: ()) (u2 :: ()) -> case u0 of { _ALG_ _TUP_0 -> case u1 of { _ALG_ _TUP_0 -> case u2 of { _ALG_ _TUP_0 -> let {(u3 :: [()]) = _!_ _NIL_ [()] []} in _!_ (:) [()] [u0, u3]; _NO_DEFLT_ }; _NO_DEFLT_ }; _NO_DEFLT_ } _N_ } #-}
instance Eq ()
{-# GHC_PRAGMA _M_ PreludeBuiltin {-dfun-} _A_ 0 _N_ _N_ _N_ _F_ _IF_ARGS_ 0 0 X 3 _!_ _TUP_2 [(() -> () -> Bool), (() -> () -> Bool)] [_CONSTM_ Eq (==) (()), _CONSTM_ Eq (/=) (())] _N_
- (==) = _A_ 2 _U_ 11 _N_ _S_ "EE" _F_ _IF_ARGS_ 0 2 CC 3 \ (u0 :: ()) (u1 :: ()) -> case u0 of { _ALG_ _TUP_0 -> case u1 of { _ALG_ _TUP_0 -> _!_ True [] []; _NO_DEFLT_ }; _NO_DEFLT_ } _N_,
- (/=) = _A_ 2 _U_ 11 _N_ _S_ "EE" _F_ _IF_ARGS_ 0 2 CC 3 \ (u0 :: ()) (u1 :: ()) -> case u0 of { _ALG_ _TUP_0 -> case u1 of { _ALG_ _TUP_0 -> _!_ False [] []; _NO_DEFLT_ }; _NO_DEFLT_ } _N_ #-}
+ (==) = { _A_ 2 _U_ 11 _N_ _S_ "EE" _F_ _IF_ARGS_ 0 2 CC 3 \ (u0 :: ()) (u1 :: ()) -> case u0 of { _ALG_ _TUP_0 -> case u1 of { _ALG_ _TUP_0 -> _!_ True [] []; _NO_DEFLT_ }; _NO_DEFLT_ } _N_ },
+ (/=) = { _A_ 2 _U_ 11 _N_ _S_ "EE" _F_ _IF_ARGS_ 0 2 CC 3 \ (u0 :: ()) (u1 :: ()) -> case u0 of { _ALG_ _TUP_0 -> case u1 of { _ALG_ _TUP_0 -> _!_ False [] []; _NO_DEFLT_ }; _NO_DEFLT_ } _N_ } #-}
instance Ix ()
{-# GHC_PRAGMA _M_ PreludeBuiltin {-dfun-} _A_ 0 _N_ _N_ _N_ _F_ _IF_ARGS_ 0 0 X 5 _!_ _TUP_4 [{{Ord ()}}, (((), ()) -> [()]), (((), ()) -> () -> Int), (((), ()) -> () -> Bool)] [_DFUN_ Ord (()), _CONSTM_ Ix range (()), _CONSTM_ Ix index (()), _CONSTM_ Ix inRange (())] _N_
- range = _A_ 1 _U_ 1 _N_ _S_ "U(EE)" {_A_ 2 _U_ 21 _N_ _N_ _N_ _N_} _N_ _N_,
- index = _A_ 2 _U_ 11 _N_ _S_ "U(EE)E" {_A_ 3 _U_ 111 _N_ _N_ _F_ _IF_ARGS_ 0 3 CCC 5 \ (u0 :: ()) (u1 :: ()) (u2 :: ()) -> case u0 of { _ALG_ _TUP_0 -> case u1 of { _ALG_ _TUP_0 -> case u2 of { _ALG_ _TUP_0 -> _!_ I# [] [0#]; _NO_DEFLT_ }; _NO_DEFLT_ }; _NO_DEFLT_ } _N_} _F_ _IF_ARGS_ 0 2 CC 6 \ (u0 :: ((), ())) (u1 :: ()) -> case u0 of { _ALG_ _TUP_2 (u2 :: ()) (u3 :: ()) -> case u2 of { _ALG_ _TUP_0 -> case u3 of { _ALG_ _TUP_0 -> case u1 of { _ALG_ _TUP_0 -> _!_ I# [] [0#]; _NO_DEFLT_ }; _NO_DEFLT_ }; _NO_DEFLT_ }; _NO_DEFLT_ } _N_,
- inRange = _A_ 2 _U_ 11 _N_ _S_ "U(EE)E" {_A_ 3 _U_ 111 _N_ _N_ _F_ _IF_ARGS_ 0 3 CCC 4 \ (u0 :: ()) (u1 :: ()) (u2 :: ()) -> case u0 of { _ALG_ _TUP_0 -> case u1 of { _ALG_ _TUP_0 -> case u2 of { _ALG_ _TUP_0 -> _!_ True [] []; _NO_DEFLT_ }; _NO_DEFLT_ }; _NO_DEFLT_ } _N_} _F_ _IF_ARGS_ 0 2 CC 5 \ (u0 :: ((), ())) (u1 :: ()) -> case u0 of { _ALG_ _TUP_2 (u2 :: ()) (u3 :: ()) -> case u2 of { _ALG_ _TUP_0 -> case u3 of { _ALG_ _TUP_0 -> case u1 of { _ALG_ _TUP_0 -> _!_ True [] []; _NO_DEFLT_ }; _NO_DEFLT_ }; _NO_DEFLT_ }; _NO_DEFLT_ } _N_ #-}
+ range = { _A_ 1 _U_ 1 _N_ _S_ "U(EE)" {_A_ 2 _U_ 21 _N_ _N_ _N_ _N_} _N_ _N_ },
+ index = { _A_ 2 _U_ 11 _N_ _S_ "U(EE)E" {_A_ 3 _U_ 111 _N_ _N_ _F_ _IF_ARGS_ 0 3 CCC 5 \ (u0 :: ()) (u1 :: ()) (u2 :: ()) -> case u0 of { _ALG_ _TUP_0 -> case u1 of { _ALG_ _TUP_0 -> case u2 of { _ALG_ _TUP_0 -> _!_ I# [] [0#]; _NO_DEFLT_ }; _NO_DEFLT_ }; _NO_DEFLT_ } _N_} _F_ _IF_ARGS_ 0 2 CC 6 \ (u0 :: ((), ())) (u1 :: ()) -> case u0 of { _ALG_ _TUP_2 (u2 :: ()) (u3 :: ()) -> case u2 of { _ALG_ _TUP_0 -> case u3 of { _ALG_ _TUP_0 -> case u1 of { _ALG_ _TUP_0 -> _!_ I# [] [0#]; _NO_DEFLT_ }; _NO_DEFLT_ }; _NO_DEFLT_ }; _NO_DEFLT_ } _N_ },
+ inRange = { _A_ 2 _U_ 11 _N_ _S_ "U(EE)E" {_A_ 3 _U_ 111 _N_ _N_ _F_ _IF_ARGS_ 0 3 CCC 4 \ (u0 :: ()) (u1 :: ()) (u2 :: ()) -> case u0 of { _ALG_ _TUP_0 -> case u1 of { _ALG_ _TUP_0 -> case u2 of { _ALG_ _TUP_0 -> _!_ True [] []; _NO_DEFLT_ }; _NO_DEFLT_ }; _NO_DEFLT_ } _N_} _F_ _IF_ARGS_ 0 2 CC 5 \ (u0 :: ((), ())) (u1 :: ()) -> case u0 of { _ALG_ _TUP_2 (u2 :: ()) (u3 :: ()) -> case u2 of { _ALG_ _TUP_0 -> case u3 of { _ALG_ _TUP_0 -> case u1 of { _ALG_ _TUP_0 -> _!_ True [] []; _NO_DEFLT_ }; _NO_DEFLT_ }; _NO_DEFLT_ }; _NO_DEFLT_ } _N_ } #-}
instance Ord ()
{-# GHC_PRAGMA _M_ PreludeBuiltin {-dfun-} _A_ 0 _N_ _N_ _N_ _F_ _IF_ARGS_ 0 0 X 9 _!_ _TUP_8 [{{Eq ()}}, (() -> () -> Bool), (() -> () -> Bool), (() -> () -> Bool), (() -> () -> Bool), (() -> () -> ()), (() -> () -> ()), (() -> () -> _CMP_TAG)] [_DFUN_ Eq (()), _CONSTM_ Ord (<) (()), _CONSTM_ Ord (<=) (()), _CONSTM_ Ord (>=) (()), _CONSTM_ Ord (>) (()), _CONSTM_ Ord max (()), _CONSTM_ Ord min (()), _CONSTM_ Ord _tagCmp (())] _N_
- (<) = _A_ 2 _U_ 11 _N_ _S_ "EE" _F_ _IF_ARGS_ 0 2 CC 3 \ (u0 :: ()) (u1 :: ()) -> case u0 of { _ALG_ _TUP_0 -> case u1 of { _ALG_ _TUP_0 -> _!_ False [] []; _NO_DEFLT_ }; _NO_DEFLT_ } _N_,
- (<=) = _A_ 2 _U_ 11 _N_ _S_ "EE" _F_ _IF_ARGS_ 0 2 CC 3 \ (u0 :: ()) (u1 :: ()) -> case u0 of { _ALG_ _TUP_0 -> case u1 of { _ALG_ _TUP_0 -> _!_ True [] []; _NO_DEFLT_ }; _NO_DEFLT_ } _N_,
- (>=) = _A_ 2 _U_ 11 _N_ _S_ "EE" _F_ _IF_ARGS_ 0 2 CC 3 \ (u0 :: ()) (u1 :: ()) -> case u0 of { _ALG_ _TUP_0 -> case u1 of { _ALG_ _TUP_0 -> _!_ True [] []; _NO_DEFLT_ }; _NO_DEFLT_ } _N_,
- (>) = _A_ 2 _U_ 11 _N_ _S_ "EE" _F_ _IF_ARGS_ 0 2 CC 3 \ (u0 :: ()) (u1 :: ()) -> case u0 of { _ALG_ _TUP_0 -> case u1 of { _ALG_ _TUP_0 -> _!_ False [] []; _NO_DEFLT_ }; _NO_DEFLT_ } _N_,
- max = _A_ 2 _U_ 11 _N_ _S_ "EE" _F_ _IF_ARGS_ 0 2 CX 2 \ (u0 :: ()) (u1 :: ()) -> case u0 of { _ALG_ _TUP_0 -> u1; _NO_DEFLT_ } _N_,
- min = _A_ 2 _U_ 11 _N_ _S_ "EE" _F_ _IF_ARGS_ 0 2 CX 2 \ (u0 :: ()) (u1 :: ()) -> case u0 of { _ALG_ _TUP_0 -> u1; _NO_DEFLT_ } _N_,
- _tagCmp = _A_ 2 _U_ 11 _N_ _S_ "EE" _F_ _IF_ARGS_ 0 2 CC 3 \ (u0 :: ()) (u1 :: ()) -> case u0 of { _ALG_ _TUP_0 -> case u1 of { _ALG_ _TUP_0 -> _!_ _EQ [] []; _NO_DEFLT_ }; _NO_DEFLT_ } _N_ #-}
+ (<) = { _A_ 2 _U_ 11 _N_ _S_ "EE" _F_ _IF_ARGS_ 0 2 CC 3 \ (u0 :: ()) (u1 :: ()) -> case u0 of { _ALG_ _TUP_0 -> case u1 of { _ALG_ _TUP_0 -> _!_ False [] []; _NO_DEFLT_ }; _NO_DEFLT_ } _N_ },
+ (<=) = { _A_ 2 _U_ 11 _N_ _S_ "EE" _F_ _IF_ARGS_ 0 2 CC 3 \ (u0 :: ()) (u1 :: ()) -> case u0 of { _ALG_ _TUP_0 -> case u1 of { _ALG_ _TUP_0 -> _!_ True [] []; _NO_DEFLT_ }; _NO_DEFLT_ } _N_ },
+ (>=) = { _A_ 2 _U_ 11 _N_ _S_ "EE" _F_ _IF_ARGS_ 0 2 CC 3 \ (u0 :: ()) (u1 :: ()) -> case u0 of { _ALG_ _TUP_0 -> case u1 of { _ALG_ _TUP_0 -> _!_ True [] []; _NO_DEFLT_ }; _NO_DEFLT_ } _N_ },
+ (>) = { _A_ 2 _U_ 11 _N_ _S_ "EE" _F_ _IF_ARGS_ 0 2 CC 3 \ (u0 :: ()) (u1 :: ()) -> case u0 of { _ALG_ _TUP_0 -> case u1 of { _ALG_ _TUP_0 -> _!_ False [] []; _NO_DEFLT_ }; _NO_DEFLT_ } _N_ },
+ max = { _A_ 2 _U_ 11 _N_ _S_ "EE" _F_ _IF_ARGS_ 0 2 CX 2 \ (u0 :: ()) (u1 :: ()) -> case u0 of { _ALG_ _TUP_0 -> u1; _NO_DEFLT_ } _N_ },
+ min = { _A_ 2 _U_ 11 _N_ _S_ "EE" _F_ _IF_ARGS_ 0 2 CX 2 \ (u0 :: ()) (u1 :: ()) -> case u0 of { _ALG_ _TUP_0 -> u1; _NO_DEFLT_ } _N_ },
+ _tagCmp = { _A_ 2 _U_ 11 _N_ _S_ "EE" _F_ _IF_ARGS_ 0 2 CC 3 \ (u0 :: ()) (u1 :: ()) -> case u0 of { _ALG_ _TUP_0 -> case u1 of { _ALG_ _TUP_0 -> _!_ _EQ [] []; _NO_DEFLT_ }; _NO_DEFLT_ } _N_ } #-}
instance Text ()
{-# GHC_PRAGMA _M_ PreludeBuiltin {-dfun-} _A_ 0 _N_ _N_ _N_ _F_ _IF_ARGS_ 0 0 X 5 _!_ _TUP_4 [(Int -> [Char] -> [((), [Char])]), (Int -> () -> [Char] -> [Char]), ([Char] -> [([()], [Char])]), ([()] -> [Char] -> [Char])] [_CONSTM_ Text readsPrec (()), _CONSTM_ Text showsPrec (()), _CONSTM_ Text readList (()), _CONSTM_ Text showList (())] _N_
- readsPrec = _A_ 1 _U_ 02 _N_ _S_ "A" {_A_ 0 _U_ 2 _N_ _N_ _N_ _N_} _N_ _N_,
- showsPrec = _A_ 3 _U_ 012 _N_ _S_ "AEL" {_A_ 2 _U_ 12 _N_ _N_ _F_ _IF_ARGS_ 0 2 CX 4 \ (u0 :: ()) (u1 :: [Char]) -> case u0 of { _ALG_ _TUP_0 -> _APP_ _TYAPP_ _ORIG_ PreludeList (++) { Char } [ _NOREP_S_ "()", u1 ]; _NO_DEFLT_ } _N_} _F_ _IF_ARGS_ 0 3 XCX 4 \ (u0 :: Int) (u1 :: ()) (u2 :: [Char]) -> case u1 of { _ALG_ _TUP_0 -> _APP_ _TYAPP_ _ORIG_ PreludeList (++) { Char } [ _NOREP_S_ "()", u2 ]; _NO_DEFLT_ } _N_,
- readList = _A_ 0 _U_ 2 _N_ _N_ _N_ _N_,
- showList = _A_ 0 _U_ 12 _N_ _N_ _N_ _N_ #-}
+ readsPrec = { _A_ 1 _U_ 02 _N_ _S_ "A" {_A_ 0 _U_ 2 _N_ _N_ _N_ _N_} _N_ _N_ },
+ showsPrec = { _A_ 3 _U_ 012 _N_ _S_ "AEL" {_A_ 2 _U_ 12 _N_ _N_ _F_ _IF_ARGS_ 0 2 CX 4 \ (u0 :: ()) (u1 :: [Char]) -> case u0 of { _ALG_ _TUP_0 -> _APP_ _TYAPP_ _ORIG_ PreludeList (++) { Char } [ _NOREP_S_ "()", u1 ]; _NO_DEFLT_ } _N_} _F_ _IF_ARGS_ 0 3 XCX 4 \ (u0 :: Int) (u1 :: ()) (u2 :: [Char]) -> case u1 of { _ALG_ _TUP_0 -> _APP_ _TYAPP_ _ORIG_ PreludeList (++) { Char } [ _NOREP_S_ "()", u2 ]; _NO_DEFLT_ } _N_ },
+ readList = { _A_ 0 _U_ 2 _N_ _N_ _N_ _N_ },
+ showList = { _A_ 1 _U_ 12 _N_ _N_ _N_ _N_ } #-}
-{-# GHC_PRAGMA INTERFACE VERSION 5 #-}
+{-# GHC_PRAGMA INTERFACE VERSION 6 #-}
interface PreludeBuiltin where
import PreludeCore(Enum(..), Eq(..), Ix(..), Ord(..), Text(..))
instance Enum ()
{-# GHC_PRAGMA _M_ PreludeBuiltin {-dfun-} _A_ 0 _N_ _N_ _N_ _F_ _IF_ARGS_ 0 0 X 6 _!_ _TUP_5 [{{Ord ()}}, (() -> [()]), (() -> () -> [()]), (() -> () -> [()]), (() -> () -> () -> [()])] [_DFUN_ Ord (()), _CONSTM_ Enum enumFrom (()), _CONSTM_ Enum enumFromThen (()), _CONSTM_ Enum enumFromTo (()), _CONSTM_ Enum enumFromThenTo (())] _N_
- enumFrom = _A_ 1 _U_ 2 _N_ _S_ "E" _N_ _N_,
- enumFromThen = _A_ 2 _U_ 21 _N_ _S_ "EE" _F_ _IF_ARGS_ 0 2 CC 7 \ (u0 :: ()) (u1 :: ()) -> case u0 of { _ALG_ _TUP_0 -> case u1 of { _ALG_ _TUP_0 -> let {(u2 :: [()]) = _!_ _NIL_ [()] []} in _!_ (:) [()] [u0, u2]; _NO_DEFLT_ }; _NO_DEFLT_ } _N_,
- enumFromTo = _A_ 2 _U_ 21 _N_ _S_ "EE" _F_ _IF_ARGS_ 0 2 CC 7 \ (u0 :: ()) (u1 :: ()) -> case u0 of { _ALG_ _TUP_0 -> case u1 of { _ALG_ _TUP_0 -> let {(u2 :: [()]) = _!_ _NIL_ [()] []} in _!_ (:) [()] [u0, u2]; _NO_DEFLT_ }; _NO_DEFLT_ } _N_,
- enumFromThenTo = _A_ 3 _U_ 211 _N_ _S_ "EEE" _F_ _IF_ARGS_ 0 3 CCC 8 \ (u0 :: ()) (u1 :: ()) (u2 :: ()) -> case u0 of { _ALG_ _TUP_0 -> case u1 of { _ALG_ _TUP_0 -> case u2 of { _ALG_ _TUP_0 -> let {(u3 :: [()]) = _!_ _NIL_ [()] []} in _!_ (:) [()] [u0, u3]; _NO_DEFLT_ }; _NO_DEFLT_ }; _NO_DEFLT_ } _N_ #-}
+ enumFrom = { _A_ 1 _U_ 2 _N_ _S_ "E" _N_ _N_ },
+ enumFromThen = { _A_ 2 _U_ 21 _N_ _S_ "EE" _F_ _IF_ARGS_ 0 2 CC 7 \ (u0 :: ()) (u1 :: ()) -> case u0 of { _ALG_ _TUP_0 -> case u1 of { _ALG_ _TUP_0 -> let {(u2 :: [()]) = _!_ _NIL_ [()] []} in _!_ (:) [()] [u0, u2]; _NO_DEFLT_ }; _NO_DEFLT_ } _N_ },
+ enumFromTo = { _A_ 2 _U_ 21 _N_ _S_ "EE" _F_ _IF_ARGS_ 0 2 CC 7 \ (u0 :: ()) (u1 :: ()) -> case u0 of { _ALG_ _TUP_0 -> case u1 of { _ALG_ _TUP_0 -> let {(u2 :: [()]) = _!_ _NIL_ [()] []} in _!_ (:) [()] [u0, u2]; _NO_DEFLT_ }; _NO_DEFLT_ } _N_ },
+ enumFromThenTo = { _A_ 3 _U_ 211 _N_ _S_ "EEE" _F_ _IF_ARGS_ 0 3 CCC 8 \ (u0 :: ()) (u1 :: ()) (u2 :: ()) -> case u0 of { _ALG_ _TUP_0 -> case u1 of { _ALG_ _TUP_0 -> case u2 of { _ALG_ _TUP_0 -> let {(u3 :: [()]) = _!_ _NIL_ [()] []} in _!_ (:) [()] [u0, u3]; _NO_DEFLT_ }; _NO_DEFLT_ }; _NO_DEFLT_ } _N_ } #-}
instance Eq ()
{-# GHC_PRAGMA _M_ PreludeBuiltin {-dfun-} _A_ 0 _N_ _N_ _N_ _F_ _IF_ARGS_ 0 0 X 3 _!_ _TUP_2 [(() -> () -> Bool), (() -> () -> Bool)] [_CONSTM_ Eq (==) (()), _CONSTM_ Eq (/=) (())] _N_
- (==) = _A_ 2 _U_ 11 _N_ _S_ "EE" _F_ _IF_ARGS_ 0 2 CC 3 \ (u0 :: ()) (u1 :: ()) -> case u0 of { _ALG_ _TUP_0 -> case u1 of { _ALG_ _TUP_0 -> _!_ True [] []; _NO_DEFLT_ }; _NO_DEFLT_ } _N_,
- (/=) = _A_ 2 _U_ 11 _N_ _S_ "EE" _F_ _IF_ARGS_ 0 2 CC 3 \ (u0 :: ()) (u1 :: ()) -> case u0 of { _ALG_ _TUP_0 -> case u1 of { _ALG_ _TUP_0 -> _!_ False [] []; _NO_DEFLT_ }; _NO_DEFLT_ } _N_ #-}
+ (==) = { _A_ 2 _U_ 11 _N_ _S_ "EE" _F_ _IF_ARGS_ 0 2 CC 3 \ (u0 :: ()) (u1 :: ()) -> case u0 of { _ALG_ _TUP_0 -> case u1 of { _ALG_ _TUP_0 -> _!_ True [] []; _NO_DEFLT_ }; _NO_DEFLT_ } _N_ },
+ (/=) = { _A_ 2 _U_ 11 _N_ _S_ "EE" _F_ _IF_ARGS_ 0 2 CC 3 \ (u0 :: ()) (u1 :: ()) -> case u0 of { _ALG_ _TUP_0 -> case u1 of { _ALG_ _TUP_0 -> _!_ False [] []; _NO_DEFLT_ }; _NO_DEFLT_ } _N_ } #-}
instance Ix ()
{-# GHC_PRAGMA _M_ PreludeBuiltin {-dfun-} _A_ 0 _N_ _N_ _N_ _F_ _IF_ARGS_ 0 0 X 5 _!_ _TUP_4 [{{Ord ()}}, (((), ()) -> [()]), (((), ()) -> () -> Int), (((), ()) -> () -> Bool)] [_DFUN_ Ord (()), _CONSTM_ Ix range (()), _CONSTM_ Ix index (()), _CONSTM_ Ix inRange (())] _N_
- range = _A_ 1 _U_ 1 _N_ _S_ "U(EE)" {_A_ 2 _U_ 21 _N_ _N_ _N_ _N_} _N_ _N_,
- index = _A_ 2 _U_ 11 _N_ _S_ "U(EE)E" {_A_ 3 _U_ 111 _N_ _N_ _F_ _IF_ARGS_ 0 3 CCC 5 \ (u0 :: ()) (u1 :: ()) (u2 :: ()) -> case u0 of { _ALG_ _TUP_0 -> case u1 of { _ALG_ _TUP_0 -> case u2 of { _ALG_ _TUP_0 -> _!_ I# [] [0#]; _NO_DEFLT_ }; _NO_DEFLT_ }; _NO_DEFLT_ } _N_} _F_ _IF_ARGS_ 0 2 CC 6 \ (u0 :: ((), ())) (u1 :: ()) -> case u0 of { _ALG_ _TUP_2 (u2 :: ()) (u3 :: ()) -> case u2 of { _ALG_ _TUP_0 -> case u3 of { _ALG_ _TUP_0 -> case u1 of { _ALG_ _TUP_0 -> _!_ I# [] [0#]; _NO_DEFLT_ }; _NO_DEFLT_ }; _NO_DEFLT_ }; _NO_DEFLT_ } _N_,
- inRange = _A_ 2 _U_ 11 _N_ _S_ "U(EE)E" {_A_ 3 _U_ 111 _N_ _N_ _F_ _IF_ARGS_ 0 3 CCC 4 \ (u0 :: ()) (u1 :: ()) (u2 :: ()) -> case u0 of { _ALG_ _TUP_0 -> case u1 of { _ALG_ _TUP_0 -> case u2 of { _ALG_ _TUP_0 -> _!_ True [] []; _NO_DEFLT_ }; _NO_DEFLT_ }; _NO_DEFLT_ } _N_} _F_ _IF_ARGS_ 0 2 CC 5 \ (u0 :: ((), ())) (u1 :: ()) -> case u0 of { _ALG_ _TUP_2 (u2 :: ()) (u3 :: ()) -> case u2 of { _ALG_ _TUP_0 -> case u3 of { _ALG_ _TUP_0 -> case u1 of { _ALG_ _TUP_0 -> _!_ True [] []; _NO_DEFLT_ }; _NO_DEFLT_ }; _NO_DEFLT_ }; _NO_DEFLT_ } _N_ #-}
+ range = { _A_ 1 _U_ 1 _N_ _S_ "U(EE)" {_A_ 2 _U_ 21 _N_ _N_ _N_ _N_} _N_ _N_ },
+ index = { _A_ 2 _U_ 11 _N_ _S_ "U(EE)E" {_A_ 3 _U_ 111 _N_ _N_ _F_ _IF_ARGS_ 0 3 CCC 5 \ (u0 :: ()) (u1 :: ()) (u2 :: ()) -> case u0 of { _ALG_ _TUP_0 -> case u1 of { _ALG_ _TUP_0 -> case u2 of { _ALG_ _TUP_0 -> _!_ I# [] [0#]; _NO_DEFLT_ }; _NO_DEFLT_ }; _NO_DEFLT_ } _N_} _F_ _IF_ARGS_ 0 2 CC 6 \ (u0 :: ((), ())) (u1 :: ()) -> case u0 of { _ALG_ _TUP_2 (u2 :: ()) (u3 :: ()) -> case u2 of { _ALG_ _TUP_0 -> case u3 of { _ALG_ _TUP_0 -> case u1 of { _ALG_ _TUP_0 -> _!_ I# [] [0#]; _NO_DEFLT_ }; _NO_DEFLT_ }; _NO_DEFLT_ }; _NO_DEFLT_ } _N_ },
+ inRange = { _A_ 2 _U_ 11 _N_ _S_ "U(EE)E" {_A_ 3 _U_ 111 _N_ _N_ _F_ _IF_ARGS_ 0 3 CCC 4 \ (u0 :: ()) (u1 :: ()) (u2 :: ()) -> case u0 of { _ALG_ _TUP_0 -> case u1 of { _ALG_ _TUP_0 -> case u2 of { _ALG_ _TUP_0 -> _!_ True [] []; _NO_DEFLT_ }; _NO_DEFLT_ }; _NO_DEFLT_ } _N_} _F_ _IF_ARGS_ 0 2 CC 5 \ (u0 :: ((), ())) (u1 :: ()) -> case u0 of { _ALG_ _TUP_2 (u2 :: ()) (u3 :: ()) -> case u2 of { _ALG_ _TUP_0 -> case u3 of { _ALG_ _TUP_0 -> case u1 of { _ALG_ _TUP_0 -> _!_ True [] []; _NO_DEFLT_ }; _NO_DEFLT_ }; _NO_DEFLT_ }; _NO_DEFLT_ } _N_ } #-}
instance Ord ()
{-# GHC_PRAGMA _M_ PreludeBuiltin {-dfun-} _A_ 0 _N_ _N_ _N_ _F_ _IF_ARGS_ 0 0 X 9 _!_ _TUP_8 [{{Eq ()}}, (() -> () -> Bool), (() -> () -> Bool), (() -> () -> Bool), (() -> () -> Bool), (() -> () -> ()), (() -> () -> ()), (() -> () -> _CMP_TAG)] [_DFUN_ Eq (()), _CONSTM_ Ord (<) (()), _CONSTM_ Ord (<=) (()), _CONSTM_ Ord (>=) (()), _CONSTM_ Ord (>) (()), _CONSTM_ Ord max (()), _CONSTM_ Ord min (()), _CONSTM_ Ord _tagCmp (())] _N_
- (<) = _A_ 2 _U_ 11 _N_ _S_ "EE" _F_ _IF_ARGS_ 0 2 CC 3 \ (u0 :: ()) (u1 :: ()) -> case u0 of { _ALG_ _TUP_0 -> case u1 of { _ALG_ _TUP_0 -> _!_ False [] []; _NO_DEFLT_ }; _NO_DEFLT_ } _N_,
- (<=) = _A_ 2 _U_ 11 _N_ _S_ "EE" _F_ _IF_ARGS_ 0 2 CC 3 \ (u0 :: ()) (u1 :: ()) -> case u0 of { _ALG_ _TUP_0 -> case u1 of { _ALG_ _TUP_0 -> _!_ True [] []; _NO_DEFLT_ }; _NO_DEFLT_ } _N_,
- (>=) = _A_ 2 _U_ 11 _N_ _S_ "EE" _F_ _IF_ARGS_ 0 2 CC 3 \ (u0 :: ()) (u1 :: ()) -> case u0 of { _ALG_ _TUP_0 -> case u1 of { _ALG_ _TUP_0 -> _!_ True [] []; _NO_DEFLT_ }; _NO_DEFLT_ } _N_,
- (>) = _A_ 2 _U_ 11 _N_ _S_ "EE" _F_ _IF_ARGS_ 0 2 CC 3 \ (u0 :: ()) (u1 :: ()) -> case u0 of { _ALG_ _TUP_0 -> case u1 of { _ALG_ _TUP_0 -> _!_ False [] []; _NO_DEFLT_ }; _NO_DEFLT_ } _N_,
- max = _A_ 2 _U_ 11 _N_ _S_ "EE" _F_ _IF_ARGS_ 0 2 CX 2 \ (u0 :: ()) (u1 :: ()) -> case u0 of { _ALG_ _TUP_0 -> u1; _NO_DEFLT_ } _N_,
- min = _A_ 2 _U_ 11 _N_ _S_ "EE" _F_ _IF_ARGS_ 0 2 CX 2 \ (u0 :: ()) (u1 :: ()) -> case u0 of { _ALG_ _TUP_0 -> u1; _NO_DEFLT_ } _N_,
- _tagCmp = _A_ 2 _U_ 11 _N_ _S_ "EE" _F_ _IF_ARGS_ 0 2 CC 3 \ (u0 :: ()) (u1 :: ()) -> case u0 of { _ALG_ _TUP_0 -> case u1 of { _ALG_ _TUP_0 -> _!_ _EQ [] []; _NO_DEFLT_ }; _NO_DEFLT_ } _N_ #-}
+ (<) = { _A_ 2 _U_ 11 _N_ _S_ "EE" _F_ _IF_ARGS_ 0 2 CC 3 \ (u0 :: ()) (u1 :: ()) -> case u0 of { _ALG_ _TUP_0 -> case u1 of { _ALG_ _TUP_0 -> _!_ False [] []; _NO_DEFLT_ }; _NO_DEFLT_ } _N_ },
+ (<=) = { _A_ 2 _U_ 11 _N_ _S_ "EE" _F_ _IF_ARGS_ 0 2 CC 3 \ (u0 :: ()) (u1 :: ()) -> case u0 of { _ALG_ _TUP_0 -> case u1 of { _ALG_ _TUP_0 -> _!_ True [] []; _NO_DEFLT_ }; _NO_DEFLT_ } _N_ },
+ (>=) = { _A_ 2 _U_ 11 _N_ _S_ "EE" _F_ _IF_ARGS_ 0 2 CC 3 \ (u0 :: ()) (u1 :: ()) -> case u0 of { _ALG_ _TUP_0 -> case u1 of { _ALG_ _TUP_0 -> _!_ True [] []; _NO_DEFLT_ }; _NO_DEFLT_ } _N_ },
+ (>) = { _A_ 2 _U_ 11 _N_ _S_ "EE" _F_ _IF_ARGS_ 0 2 CC 3 \ (u0 :: ()) (u1 :: ()) -> case u0 of { _ALG_ _TUP_0 -> case u1 of { _ALG_ _TUP_0 -> _!_ False [] []; _NO_DEFLT_ }; _NO_DEFLT_ } _N_ },
+ max = { _A_ 2 _U_ 11 _N_ _S_ "EE" _F_ _IF_ARGS_ 0 2 CX 2 \ (u0 :: ()) (u1 :: ()) -> case u0 of { _ALG_ _TUP_0 -> u1; _NO_DEFLT_ } _N_ },
+ min = { _A_ 2 _U_ 11 _N_ _S_ "EE" _F_ _IF_ARGS_ 0 2 CX 2 \ (u0 :: ()) (u1 :: ()) -> case u0 of { _ALG_ _TUP_0 -> u1; _NO_DEFLT_ } _N_ },
+ _tagCmp = { _A_ 2 _U_ 11 _N_ _S_ "EE" _F_ _IF_ARGS_ 0 2 CC 3 \ (u0 :: ()) (u1 :: ()) -> case u0 of { _ALG_ _TUP_0 -> case u1 of { _ALG_ _TUP_0 -> _!_ _EQ [] []; _NO_DEFLT_ }; _NO_DEFLT_ } _N_ } #-}
instance Text ()
{-# GHC_PRAGMA _M_ PreludeBuiltin {-dfun-} _A_ 0 _N_ _N_ _N_ _F_ _IF_ARGS_ 0 0 X 5 _!_ _TUP_4 [(Int -> [Char] -> [((), [Char])]), (Int -> () -> [Char] -> [Char]), ([Char] -> [([()], [Char])]), ([()] -> [Char] -> [Char])] [_CONSTM_ Text readsPrec (()), _CONSTM_ Text showsPrec (()), _CONSTM_ Text readList (()), _CONSTM_ Text showList (())] _N_
- readsPrec = _A_ 1 _U_ 02 _N_ _S_ "A" {_A_ 0 _U_ 2 _N_ _N_ _N_ _N_} _N_ _N_,
- showsPrec = _A_ 3 _U_ 012 _N_ _S_ "AEL" {_A_ 2 _U_ 12 _N_ _N_ _F_ _IF_ARGS_ 0 2 CX 4 \ (u0 :: ()) (u1 :: [Char]) -> case u0 of { _ALG_ _TUP_0 -> _APP_ _TYAPP_ _ORIG_ PreludeList (++) { Char } [ _NOREP_S_ "()", u1 ]; _NO_DEFLT_ } _N_} _F_ _IF_ARGS_ 0 3 XCX 4 \ (u0 :: Int) (u1 :: ()) (u2 :: [Char]) -> case u1 of { _ALG_ _TUP_0 -> _APP_ _TYAPP_ _ORIG_ PreludeList (++) { Char } [ _NOREP_S_ "()", u2 ]; _NO_DEFLT_ } _N_,
- readList = _A_ 0 _U_ 2 _N_ _N_ _N_ _N_,
- showList = _A_ 0 _U_ 12 _N_ _N_ _N_ _N_ #-}
+ readsPrec = { _A_ 1 _U_ 02 _N_ _S_ "A" {_A_ 0 _U_ 2 _N_ _N_ _N_ _N_} _N_ _N_ },
+ showsPrec = { _A_ 3 _U_ 012 _N_ _S_ "AEL" {_A_ 2 _U_ 12 _N_ _N_ _F_ _IF_ARGS_ 0 2 CX 4 \ (u0 :: ()) (u1 :: [Char]) -> case u0 of { _ALG_ _TUP_0 -> _APP_ _TYAPP_ _ORIG_ PreludeList (++) { Char } [ _NOREP_S_ "()", u1 ]; _NO_DEFLT_ } _N_} _F_ _IF_ARGS_ 0 3 XCX 4 \ (u0 :: Int) (u1 :: ()) (u2 :: [Char]) -> case u1 of { _ALG_ _TUP_0 -> _APP_ _TYAPP_ _ORIG_ PreludeList (++) { Char } [ _NOREP_S_ "()", u2 ]; _NO_DEFLT_ } _N_ },
+ readList = { _A_ 0 _U_ 2 _N_ _N_ _N_ _N_ },
+ showList = { _A_ 1 _U_ 12 _N_ _N_ _N_ _N_ } #-}
-{-# GHC_PRAGMA INTERFACE VERSION 5 #-}
+{-# GHC_PRAGMA INTERFACE VERSION 6 #-}
interface PreludeBuiltin where
import PreludeCore(Enum(..), Eq(..), Ix(..), Ord(..), Text(..))
instance Enum ()
{-# GHC_PRAGMA _M_ PreludeBuiltin {-dfun-} _A_ 0 _N_ _N_ _N_ _F_ _IF_ARGS_ 0 0 X 6 _!_ _TUP_5 [{{Ord ()}}, (() -> [()]), (() -> () -> [()]), (() -> () -> [()]), (() -> () -> () -> [()])] [_DFUN_ Ord (()), _CONSTM_ Enum enumFrom (()), _CONSTM_ Enum enumFromThen (()), _CONSTM_ Enum enumFromTo (()), _CONSTM_ Enum enumFromThenTo (())] _N_
- enumFrom = _A_ 1 _U_ 2 _N_ _S_ "E" _N_ _N_,
- enumFromThen = _A_ 2 _U_ 21 _N_ _S_ "EE" _F_ _IF_ARGS_ 0 2 CC 7 \ (u0 :: ()) (u1 :: ()) -> case u0 of { _ALG_ _TUP_0 -> case u1 of { _ALG_ _TUP_0 -> let {(u2 :: [()]) = _!_ _NIL_ [()] []} in _!_ (:) [()] [u0, u2]; _NO_DEFLT_ }; _NO_DEFLT_ } _N_,
- enumFromTo = _A_ 2 _U_ 21 _N_ _S_ "EE" _F_ _IF_ARGS_ 0 2 CC 7 \ (u0 :: ()) (u1 :: ()) -> case u0 of { _ALG_ _TUP_0 -> case u1 of { _ALG_ _TUP_0 -> let {(u2 :: [()]) = _!_ _NIL_ [()] []} in _!_ (:) [()] [u0, u2]; _NO_DEFLT_ }; _NO_DEFLT_ } _N_,
- enumFromThenTo = _A_ 3 _U_ 211 _N_ _S_ "EEE" _F_ _IF_ARGS_ 0 3 CCC 8 \ (u0 :: ()) (u1 :: ()) (u2 :: ()) -> case u0 of { _ALG_ _TUP_0 -> case u1 of { _ALG_ _TUP_0 -> case u2 of { _ALG_ _TUP_0 -> let {(u3 :: [()]) = _!_ _NIL_ [()] []} in _!_ (:) [()] [u0, u3]; _NO_DEFLT_ }; _NO_DEFLT_ }; _NO_DEFLT_ } _N_ #-}
+ enumFrom = { _A_ 1 _U_ 2 _N_ _S_ "E" _N_ _N_ },
+ enumFromThen = { _A_ 2 _U_ 21 _N_ _S_ "EE" _F_ _IF_ARGS_ 0 2 CC 7 \ (u0 :: ()) (u1 :: ()) -> case u0 of { _ALG_ _TUP_0 -> case u1 of { _ALG_ _TUP_0 -> let {(u2 :: [()]) = _!_ _NIL_ [()] []} in _!_ (:) [()] [u0, u2]; _NO_DEFLT_ }; _NO_DEFLT_ } _N_ },
+ enumFromTo = { _A_ 2 _U_ 21 _N_ _S_ "EE" _F_ _IF_ARGS_ 0 2 CC 7 \ (u0 :: ()) (u1 :: ()) -> case u0 of { _ALG_ _TUP_0 -> case u1 of { _ALG_ _TUP_0 -> let {(u2 :: [()]) = _!_ _NIL_ [()] []} in _!_ (:) [()] [u0, u2]; _NO_DEFLT_ }; _NO_DEFLT_ } _N_ },
+ enumFromThenTo = { _A_ 3 _U_ 211 _N_ _S_ "EEE" _F_ _IF_ARGS_ 0 3 CCC 8 \ (u0 :: ()) (u1 :: ()) (u2 :: ()) -> case u0 of { _ALG_ _TUP_0 -> case u1 of { _ALG_ _TUP_0 -> case u2 of { _ALG_ _TUP_0 -> let {(u3 :: [()]) = _!_ _NIL_ [()] []} in _!_ (:) [()] [u0, u3]; _NO_DEFLT_ }; _NO_DEFLT_ }; _NO_DEFLT_ } _N_ } #-}
instance Eq ()
{-# GHC_PRAGMA _M_ PreludeBuiltin {-dfun-} _A_ 0 _N_ _N_ _N_ _F_ _IF_ARGS_ 0 0 X 3 _!_ _TUP_2 [(() -> () -> Bool), (() -> () -> Bool)] [_CONSTM_ Eq (==) (()), _CONSTM_ Eq (/=) (())] _N_
- (==) = _A_ 2 _U_ 11 _N_ _S_ "EE" _F_ _IF_ARGS_ 0 2 CC 3 \ (u0 :: ()) (u1 :: ()) -> case u0 of { _ALG_ _TUP_0 -> case u1 of { _ALG_ _TUP_0 -> _!_ True [] []; _NO_DEFLT_ }; _NO_DEFLT_ } _N_,
- (/=) = _A_ 2 _U_ 11 _N_ _S_ "EE" _F_ _IF_ARGS_ 0 2 CC 3 \ (u0 :: ()) (u1 :: ()) -> case u0 of { _ALG_ _TUP_0 -> case u1 of { _ALG_ _TUP_0 -> _!_ False [] []; _NO_DEFLT_ }; _NO_DEFLT_ } _N_ #-}
+ (==) = { _A_ 2 _U_ 11 _N_ _S_ "EE" _F_ _IF_ARGS_ 0 2 CC 3 \ (u0 :: ()) (u1 :: ()) -> case u0 of { _ALG_ _TUP_0 -> case u1 of { _ALG_ _TUP_0 -> _!_ True [] []; _NO_DEFLT_ }; _NO_DEFLT_ } _N_ },
+ (/=) = { _A_ 2 _U_ 11 _N_ _S_ "EE" _F_ _IF_ARGS_ 0 2 CC 3 \ (u0 :: ()) (u1 :: ()) -> case u0 of { _ALG_ _TUP_0 -> case u1 of { _ALG_ _TUP_0 -> _!_ False [] []; _NO_DEFLT_ }; _NO_DEFLT_ } _N_ } #-}
instance Ix ()
{-# GHC_PRAGMA _M_ PreludeBuiltin {-dfun-} _A_ 0 _N_ _N_ _N_ _F_ _IF_ARGS_ 0 0 X 5 _!_ _TUP_4 [{{Ord ()}}, (((), ()) -> [()]), (((), ()) -> () -> Int), (((), ()) -> () -> Bool)] [_DFUN_ Ord (()), _CONSTM_ Ix range (()), _CONSTM_ Ix index (()), _CONSTM_ Ix inRange (())] _N_
- range = _A_ 1 _U_ 1 _N_ _S_ "U(EE)" {_A_ 2 _U_ 21 _N_ _N_ _N_ _N_} _N_ _N_,
- index = _A_ 2 _U_ 11 _N_ _S_ "U(EE)E" {_A_ 3 _U_ 111 _N_ _N_ _F_ _IF_ARGS_ 0 3 CCC 5 \ (u0 :: ()) (u1 :: ()) (u2 :: ()) -> case u0 of { _ALG_ _TUP_0 -> case u1 of { _ALG_ _TUP_0 -> case u2 of { _ALG_ _TUP_0 -> _!_ I# [] [0#]; _NO_DEFLT_ }; _NO_DEFLT_ }; _NO_DEFLT_ } _N_} _F_ _IF_ARGS_ 0 2 CC 6 \ (u0 :: ((), ())) (u1 :: ()) -> case u0 of { _ALG_ _TUP_2 (u2 :: ()) (u3 :: ()) -> case u2 of { _ALG_ _TUP_0 -> case u3 of { _ALG_ _TUP_0 -> case u1 of { _ALG_ _TUP_0 -> _!_ I# [] [0#]; _NO_DEFLT_ }; _NO_DEFLT_ }; _NO_DEFLT_ }; _NO_DEFLT_ } _N_,
- inRange = _A_ 2 _U_ 11 _N_ _S_ "U(EE)E" {_A_ 3 _U_ 111 _N_ _N_ _F_ _IF_ARGS_ 0 3 CCC 4 \ (u0 :: ()) (u1 :: ()) (u2 :: ()) -> case u0 of { _ALG_ _TUP_0 -> case u1 of { _ALG_ _TUP_0 -> case u2 of { _ALG_ _TUP_0 -> _!_ True [] []; _NO_DEFLT_ }; _NO_DEFLT_ }; _NO_DEFLT_ } _N_} _F_ _IF_ARGS_ 0 2 CC 5 \ (u0 :: ((), ())) (u1 :: ()) -> case u0 of { _ALG_ _TUP_2 (u2 :: ()) (u3 :: ()) -> case u2 of { _ALG_ _TUP_0 -> case u3 of { _ALG_ _TUP_0 -> case u1 of { _ALG_ _TUP_0 -> _!_ True [] []; _NO_DEFLT_ }; _NO_DEFLT_ }; _NO_DEFLT_ }; _NO_DEFLT_ } _N_ #-}
+ range = { _A_ 1 _U_ 1 _N_ _S_ "U(EE)" {_A_ 2 _U_ 21 _N_ _N_ _N_ _N_} _N_ _N_ },
+ index = { _A_ 2 _U_ 11 _N_ _S_ "U(EE)E" {_A_ 3 _U_ 111 _N_ _N_ _F_ _IF_ARGS_ 0 3 CCC 5 \ (u0 :: ()) (u1 :: ()) (u2 :: ()) -> case u0 of { _ALG_ _TUP_0 -> case u1 of { _ALG_ _TUP_0 -> case u2 of { _ALG_ _TUP_0 -> _!_ I# [] [0#]; _NO_DEFLT_ }; _NO_DEFLT_ }; _NO_DEFLT_ } _N_} _F_ _IF_ARGS_ 0 2 CC 6 \ (u0 :: ((), ())) (u1 :: ()) -> case u0 of { _ALG_ _TUP_2 (u2 :: ()) (u3 :: ()) -> case u2 of { _ALG_ _TUP_0 -> case u3 of { _ALG_ _TUP_0 -> case u1 of { _ALG_ _TUP_0 -> _!_ I# [] [0#]; _NO_DEFLT_ }; _NO_DEFLT_ }; _NO_DEFLT_ }; _NO_DEFLT_ } _N_ },
+ inRange = { _A_ 2 _U_ 11 _N_ _S_ "U(EE)E" {_A_ 3 _U_ 111 _N_ _N_ _F_ _IF_ARGS_ 0 3 CCC 4 \ (u0 :: ()) (u1 :: ()) (u2 :: ()) -> case u0 of { _ALG_ _TUP_0 -> case u1 of { _ALG_ _TUP_0 -> case u2 of { _ALG_ _TUP_0 -> _!_ True [] []; _NO_DEFLT_ }; _NO_DEFLT_ }; _NO_DEFLT_ } _N_} _F_ _IF_ARGS_ 0 2 CC 5 \ (u0 :: ((), ())) (u1 :: ()) -> case u0 of { _ALG_ _TUP_2 (u2 :: ()) (u3 :: ()) -> case u2 of { _ALG_ _TUP_0 -> case u3 of { _ALG_ _TUP_0 -> case u1 of { _ALG_ _TUP_0 -> _!_ True [] []; _NO_DEFLT_ }; _NO_DEFLT_ }; _NO_DEFLT_ }; _NO_DEFLT_ } _N_ } #-}
instance Ord ()
{-# GHC_PRAGMA _M_ PreludeBuiltin {-dfun-} _A_ 0 _N_ _N_ _N_ _F_ _IF_ARGS_ 0 0 X 9 _!_ _TUP_8 [{{Eq ()}}, (() -> () -> Bool), (() -> () -> Bool), (() -> () -> Bool), (() -> () -> Bool), (() -> () -> ()), (() -> () -> ()), (() -> () -> _CMP_TAG)] [_DFUN_ Eq (()), _CONSTM_ Ord (<) (()), _CONSTM_ Ord (<=) (()), _CONSTM_ Ord (>=) (()), _CONSTM_ Ord (>) (()), _CONSTM_ Ord max (()), _CONSTM_ Ord min (()), _CONSTM_ Ord _tagCmp (())] _N_
- (<) = _A_ 2 _U_ 11 _N_ _S_ "EE" _F_ _IF_ARGS_ 0 2 CC 3 \ (u0 :: ()) (u1 :: ()) -> case u0 of { _ALG_ _TUP_0 -> case u1 of { _ALG_ _TUP_0 -> _!_ False [] []; _NO_DEFLT_ }; _NO_DEFLT_ } _N_,
- (<=) = _A_ 2 _U_ 11 _N_ _S_ "EE" _F_ _IF_ARGS_ 0 2 CC 3 \ (u0 :: ()) (u1 :: ()) -> case u0 of { _ALG_ _TUP_0 -> case u1 of { _ALG_ _TUP_0 -> _!_ True [] []; _NO_DEFLT_ }; _NO_DEFLT_ } _N_,
- (>=) = _A_ 2 _U_ 11 _N_ _S_ "EE" _F_ _IF_ARGS_ 0 2 CC 3 \ (u0 :: ()) (u1 :: ()) -> case u0 of { _ALG_ _TUP_0 -> case u1 of { _ALG_ _TUP_0 -> _!_ True [] []; _NO_DEFLT_ }; _NO_DEFLT_ } _N_,
- (>) = _A_ 2 _U_ 11 _N_ _S_ "EE" _F_ _IF_ARGS_ 0 2 CC 3 \ (u0 :: ()) (u1 :: ()) -> case u0 of { _ALG_ _TUP_0 -> case u1 of { _ALG_ _TUP_0 -> _!_ False [] []; _NO_DEFLT_ }; _NO_DEFLT_ } _N_,
- max = _A_ 2 _U_ 11 _N_ _S_ "EE" _F_ _IF_ARGS_ 0 2 CX 2 \ (u0 :: ()) (u1 :: ()) -> case u0 of { _ALG_ _TUP_0 -> u1; _NO_DEFLT_ } _N_,
- min = _A_ 2 _U_ 11 _N_ _S_ "EE" _F_ _IF_ARGS_ 0 2 CX 2 \ (u0 :: ()) (u1 :: ()) -> case u0 of { _ALG_ _TUP_0 -> u1; _NO_DEFLT_ } _N_,
- _tagCmp = _A_ 2 _U_ 11 _N_ _S_ "EE" _F_ _IF_ARGS_ 0 2 CC 3 \ (u0 :: ()) (u1 :: ()) -> case u0 of { _ALG_ _TUP_0 -> case u1 of { _ALG_ _TUP_0 -> _!_ _EQ [] []; _NO_DEFLT_ }; _NO_DEFLT_ } _N_ #-}
+ (<) = { _A_ 2 _U_ 11 _N_ _S_ "EE" _F_ _IF_ARGS_ 0 2 CC 3 \ (u0 :: ()) (u1 :: ()) -> case u0 of { _ALG_ _TUP_0 -> case u1 of { _ALG_ _TUP_0 -> _!_ False [] []; _NO_DEFLT_ }; _NO_DEFLT_ } _N_ },
+ (<=) = { _A_ 2 _U_ 11 _N_ _S_ "EE" _F_ _IF_ARGS_ 0 2 CC 3 \ (u0 :: ()) (u1 :: ()) -> case u0 of { _ALG_ _TUP_0 -> case u1 of { _ALG_ _TUP_0 -> _!_ True [] []; _NO_DEFLT_ }; _NO_DEFLT_ } _N_ },
+ (>=) = { _A_ 2 _U_ 11 _N_ _S_ "EE" _F_ _IF_ARGS_ 0 2 CC 3 \ (u0 :: ()) (u1 :: ()) -> case u0 of { _ALG_ _TUP_0 -> case u1 of { _ALG_ _TUP_0 -> _!_ True [] []; _NO_DEFLT_ }; _NO_DEFLT_ } _N_ },
+ (>) = { _A_ 2 _U_ 11 _N_ _S_ "EE" _F_ _IF_ARGS_ 0 2 CC 3 \ (u0 :: ()) (u1 :: ()) -> case u0 of { _ALG_ _TUP_0 -> case u1 of { _ALG_ _TUP_0 -> _!_ False [] []; _NO_DEFLT_ }; _NO_DEFLT_ } _N_ },
+ max = { _A_ 2 _U_ 11 _N_ _S_ "EE" _F_ _IF_ARGS_ 0 2 CX 2 \ (u0 :: ()) (u1 :: ()) -> case u0 of { _ALG_ _TUP_0 -> u1; _NO_DEFLT_ } _N_ },
+ min = { _A_ 2 _U_ 11 _N_ _S_ "EE" _F_ _IF_ARGS_ 0 2 CX 2 \ (u0 :: ()) (u1 :: ()) -> case u0 of { _ALG_ _TUP_0 -> u1; _NO_DEFLT_ } _N_ },
+ _tagCmp = { _A_ 2 _U_ 11 _N_ _S_ "EE" _F_ _IF_ARGS_ 0 2 CC 3 \ (u0 :: ()) (u1 :: ()) -> case u0 of { _ALG_ _TUP_0 -> case u1 of { _ALG_ _TUP_0 -> _!_ _EQ [] []; _NO_DEFLT_ }; _NO_DEFLT_ } _N_ } #-}
instance Text ()
{-# GHC_PRAGMA _M_ PreludeBuiltin {-dfun-} _A_ 0 _N_ _N_ _N_ _F_ _IF_ARGS_ 0 0 X 5 _!_ _TUP_4 [(Int -> [Char] -> [((), [Char])]), (Int -> () -> [Char] -> [Char]), ([Char] -> [([()], [Char])]), ([()] -> [Char] -> [Char])] [_CONSTM_ Text readsPrec (()), _CONSTM_ Text showsPrec (()), _CONSTM_ Text readList (()), _CONSTM_ Text showList (())] _N_
- readsPrec = _A_ 1 _U_ 02 _N_ _S_ "A" {_A_ 0 _U_ 2 _N_ _N_ _N_ _N_} _N_ _N_,
- showsPrec = _A_ 3 _U_ 012 _N_ _S_ "AEL" {_A_ 2 _U_ 12 _N_ _N_ _F_ _IF_ARGS_ 0 2 CX 4 \ (u0 :: ()) (u1 :: [Char]) -> case u0 of { _ALG_ _TUP_0 -> _APP_ _TYAPP_ _ORIG_ PreludeList (++) { Char } [ _NOREP_S_ "()", u1 ]; _NO_DEFLT_ } _N_} _F_ _IF_ARGS_ 0 3 XCX 4 \ (u0 :: Int) (u1 :: ()) (u2 :: [Char]) -> case u1 of { _ALG_ _TUP_0 -> _APP_ _TYAPP_ _ORIG_ PreludeList (++) { Char } [ _NOREP_S_ "()", u2 ]; _NO_DEFLT_ } _N_,
- readList = _A_ 0 _U_ 2 _N_ _N_ _N_ _N_,
- showList = _A_ 0 _U_ 12 _N_ _N_ _N_ _N_ #-}
+ readsPrec = { _A_ 1 _U_ 02 _N_ _S_ "A" {_A_ 0 _U_ 2 _N_ _N_ _N_ _N_} _N_ _N_ },
+ showsPrec = { _A_ 3 _U_ 012 _N_ _S_ "AEL" {_A_ 2 _U_ 12 _N_ _N_ _F_ _IF_ARGS_ 0 2 CX 4 \ (u0 :: ()) (u1 :: [Char]) -> case u0 of { _ALG_ _TUP_0 -> _APP_ _TYAPP_ _ORIG_ PreludeList (++) { Char } [ _NOREP_S_ "()", u1 ]; _NO_DEFLT_ } _N_} _F_ _IF_ARGS_ 0 3 XCX 4 \ (u0 :: Int) (u1 :: ()) (u2 :: [Char]) -> case u1 of { _ALG_ _TUP_0 -> _APP_ _TYAPP_ _ORIG_ PreludeList (++) { Char } [ _NOREP_S_ "()", u2 ]; _NO_DEFLT_ } _N_ },
+ readList = { _A_ 0 _U_ 2 _N_ _N_ _N_ _N_ },
+ showList = { _A_ 1 _U_ 12 _N_ _N_ _N_ _N_ } #-}
-{-# GHC_PRAGMA INTERFACE VERSION 5 #-}
+{-# GHC_PRAGMA INTERFACE VERSION 6 #-}
interface PreludeBuiltin where
import PreludeCore(Eq(..), Ix(..), Ord(..), Text(..))
import PreludePS(_PackedString)
instance (Eq a, Eq b) => Eq (a, b)
- {-# GHC_PRAGMA _M_ PreludeBuiltin {-dfun-} _A_ 2 _U_ 11 _N_ _N_ _N_ _N_ #-}
+ {-# GHC_PRAGMA _M_ PreludeBuiltin {-dfun-} _A_ 2 _U_ 22 _N_ _N_ _N_ _N_ #-}
instance Eq (Int, Int)
{-# GHC_PRAGMA _M_ PreludeBuiltin {-dfun-} _A_ 0 _N_ _N_ _N_ _F_ _IF_ARGS_ 0 0 X 3 _!_ _TUP_2 [((Int, Int) -> (Int, Int) -> Bool), ((Int, Int) -> (Int, Int) -> Bool)] [_CONSTM_ Eq (==) ((Int, Int)), _CONSTM_ Eq (/=) ((Int, Int))] _N_
- (==) = _A_ 2 _U_ 11 _N_ _S_ "U(U(P)L)U(U(P)L)" {_A_ 4 _U_ 2121 _N_ _N_ _F_ _IF_ARGS_ 0 4 XCXC 7 \ (u0 :: Int#) (u1 :: Int) (u2 :: Int#) (u3 :: Int) -> case _#_ eqInt# [] [u0, u2] of { _ALG_ True -> case u1 of { _ALG_ I# (u4 :: Int#) -> case u3 of { _ALG_ I# (u5 :: Int#) -> _#_ eqInt# [] [u4, u5]; _NO_DEFLT_ }; _NO_DEFLT_ }; False -> _!_ False [] []; _NO_DEFLT_ } _N_} _F_ _ALWAYS_ \ (u0 :: (Int, Int)) (u1 :: (Int, Int)) -> case u0 of { _ALG_ _TUP_2 (u2 :: Int) (u3 :: Int) -> case u2 of { _ALG_ I# (u4 :: Int#) -> case u1 of { _ALG_ _TUP_2 (u5 :: Int) (u6 :: Int) -> case u5 of { _ALG_ I# (u7 :: Int#) -> case _#_ eqInt# [] [u4, u7] of { _ALG_ True -> case u3 of { _ALG_ I# (u8 :: Int#) -> case u6 of { _ALG_ I# (u9 :: Int#) -> _#_ eqInt# [] [u8, u9]; _NO_DEFLT_ }; _NO_DEFLT_ }; False -> _!_ False [] []; _NO_DEFLT_ }; _NO_DEFLT_ }; _NO_DEFLT_ }; _NO_DEFLT_ }; _NO_DEFLT_ } _N_,
- (/=) = _A_ 2 _U_ 22 _N_ _N_ _N_ _N_ #-}
+ (==) = { _A_ 2 _U_ 11 _N_ _S_ "U(U(P)L)U(U(P)L)" {_A_ 4 _U_ 2121 _N_ _N_ _F_ _IF_ARGS_ 0 4 XCXC 7 \ (u0 :: Int#) (u1 :: Int) (u2 :: Int#) (u3 :: Int) -> case _#_ eqInt# [] [u0, u2] of { _ALG_ True -> case u1 of { _ALG_ I# (u4 :: Int#) -> case u3 of { _ALG_ I# (u5 :: Int#) -> _#_ eqInt# [] [u4, u5]; _NO_DEFLT_ }; _NO_DEFLT_ }; False -> _!_ False [] []; _NO_DEFLT_ } _N_} _F_ _ALWAYS_ \ (u0 :: (Int, Int)) (u1 :: (Int, Int)) -> case u0 of { _ALG_ _TUP_2 (u2 :: Int) (u3 :: Int) -> case u2 of { _ALG_ I# (u4 :: Int#) -> case u1 of { _ALG_ _TUP_2 (u5 :: Int) (u6 :: Int) -> case u5 of { _ALG_ I# (u7 :: Int#) -> case _#_ eqInt# [] [u4, u7] of { _ALG_ True -> case u3 of { _ALG_ I# (u8 :: Int#) -> case u6 of { _ALG_ I# (u9 :: Int#) -> _#_ eqInt# [] [u8, u9]; _NO_DEFLT_ }; _NO_DEFLT_ }; False -> _!_ False [] []; _NO_DEFLT_ }; _NO_DEFLT_ }; _NO_DEFLT_ }; _NO_DEFLT_ }; _NO_DEFLT_ } _N_ },
+ (/=) = { _A_ 2 _U_ 11 _N_ _S_ "U(U(P)L)U(U(P)L)" {_A_ 4 _U_ 2121 _N_ _N_ _F_ _IF_ARGS_ 0 4 XCXC 7 \ (u0 :: Int#) (u1 :: Int) (u2 :: Int#) (u3 :: Int) -> case _#_ neInt# [] [u0, u2] of { _ALG_ True -> _!_ True [] []; False -> case u1 of { _ALG_ I# (u4 :: Int#) -> case u3 of { _ALG_ I# (u5 :: Int#) -> _#_ neInt# [] [u4, u5]; _NO_DEFLT_ }; _NO_DEFLT_ }; _NO_DEFLT_ } _N_} _F_ _ALWAYS_ \ (u0 :: (Int, Int)) (u1 :: (Int, Int)) -> case u0 of { _ALG_ _TUP_2 (u2 :: Int) (u3 :: Int) -> case u2 of { _ALG_ I# (u4 :: Int#) -> case u1 of { _ALG_ _TUP_2 (u5 :: Int) (u6 :: Int) -> case u5 of { _ALG_ I# (u7 :: Int#) -> case _#_ neInt# [] [u4, u7] of { _ALG_ True -> _!_ True [] []; False -> case u3 of { _ALG_ I# (u8 :: Int#) -> case u6 of { _ALG_ I# (u9 :: Int#) -> _#_ neInt# [] [u8, u9]; _NO_DEFLT_ }; _NO_DEFLT_ }; _NO_DEFLT_ }; _NO_DEFLT_ }; _NO_DEFLT_ }; _NO_DEFLT_ }; _NO_DEFLT_ } _N_ } #-}
+instance Eq ([Char], [Char])
+ {-# GHC_PRAGMA _M_ PreludeBuiltin {-dfun-} _A_ 0 _N_ _N_ _N_ _F_ _IF_ARGS_ 0 0 X 3 _!_ _TUP_2 [(([Char], [Char]) -> ([Char], [Char]) -> Bool), (([Char], [Char]) -> ([Char], [Char]) -> Bool)] [_CONSTM_ Eq (==) (([Char], [Char])), _CONSTM_ Eq (/=) (([Char], [Char]))] _N_
+ (==) = { _A_ 2 _U_ 11 _N_ _S_ "U(SL)U(SL)" {_A_ 4 _U_ 2222 _N_ _N_ _N_ _N_} _N_ _N_ },
+ (/=) = { _A_ 2 _U_ 11 _N_ _S_ "U(SL)U(SL)" {_A_ 4 _U_ 2222 _N_ _N_ _N_ _N_} _N_ _N_ } #-}
+instance Eq ([Int], [Int])
+ {-# GHC_PRAGMA _M_ PreludeBuiltin {-dfun-} _A_ 0 _N_ _N_ _N_ _F_ _IF_ARGS_ 0 0 X 3 _!_ _TUP_2 [(([Int], [Int]) -> ([Int], [Int]) -> Bool), (([Int], [Int]) -> ([Int], [Int]) -> Bool)] [_CONSTM_ Eq (==) (([Int], [Int])), _CONSTM_ Eq (/=) (([Int], [Int]))] _N_
+ (==) = { _A_ 2 _U_ 11 _N_ _S_ "U(SL)U(SL)" {_A_ 4 _U_ 2222 _N_ _N_ _N_ _N_} _N_ _N_ },
+ (/=) = { _A_ 2 _U_ 11 _N_ _S_ "U(SL)U(SL)" {_A_ 4 _U_ 2222 _N_ _N_ _N_ _N_} _N_ _N_ } #-}
instance Eq (_PackedString, _PackedString)
{-# GHC_PRAGMA _M_ PreludeBuiltin {-dfun-} _A_ 0 _N_ _N_ _N_ _F_ _IF_ARGS_ 0 0 X 3 _!_ _TUP_2 [((_PackedString, _PackedString) -> (_PackedString, _PackedString) -> Bool), ((_PackedString, _PackedString) -> (_PackedString, _PackedString) -> Bool)] [_CONSTM_ Eq (==) ((_PackedString, _PackedString)), _CONSTM_ Eq (/=) ((_PackedString, _PackedString))] _N_
- (==) = _A_ 2 _U_ 11 _N_ _S_ "U(SL)U(SL)" {_A_ 4 _U_ 2222 _N_ _N_ _N_ _N_} _N_ _N_,
- (/=) = _A_ 2 _U_ 22 _N_ _N_ _N_ _N_ #-}
+ (==) = { _A_ 2 _U_ 11 _N_ _S_ "U(SL)U(SL)" {_A_ 4 _U_ 2222 _N_ _N_ _N_ _N_} _N_ _N_ },
+ (/=) = { _A_ 2 _U_ 11 _N_ _S_ "U(SL)U(SL)" {_A_ 4 _U_ 2222 _N_ _N_ _N_ _N_} _N_ _N_ } #-}
instance (Ix a, Ix b) => Ix (a, b)
{-# GHC_PRAGMA _M_ PreludeBuiltin {-dfun-} _A_ 3 _U_ 222 _N_ _N_ _N_ _N_ #-}
instance Ix (Int, Int)
{-# GHC_PRAGMA _M_ PreludeBuiltin {-dfun-} _A_ 0 _N_ _N_ _N_ _F_ _IF_ARGS_ 0 0 X 5 _!_ _TUP_4 [{{Ord (Int, Int)}}, (((Int, Int), (Int, Int)) -> [(Int, Int)]), (((Int, Int), (Int, Int)) -> (Int, Int) -> Int), (((Int, Int), (Int, Int)) -> (Int, Int) -> Bool)] [_DFUN_ Ord ((Int, Int)), _CONSTM_ Ix range ((Int, Int)), _CONSTM_ Ix index ((Int, Int)), _CONSTM_ Ix inRange ((Int, Int))] _N_
- range = _A_ 1 _U_ 1 _N_ _S_ "U(SS)" {_A_ 2 _U_ 11 _N_ _N_ _N_ _N_} _N_ _N_,
- index = _A_ 2 _U_ 11 _N_ _S_ "U(SS)U(U(P)U(P))" {_A_ 4 _U_ 1122 _N_ _N_ _N_ _N_} _N_ _N_,
- inRange = _A_ 2 _U_ 11 _N_ _S_ "U(SS)U(U(P)L)" {_A_ 4 _U_ 1121 _N_ _N_ _N_ _N_} _N_ _N_ #-}
+ range = { _A_ 1 _U_ 1 _N_ _S_ "U(SS)" {_A_ 2 _U_ 11 _N_ _N_ _N_ _N_} _N_ _N_ },
+ index = { _A_ 2 _U_ 11 _N_ _S_ "U(SS)U(U(P)U(P))" {_A_ 4 _U_ 1122 _N_ _N_ _N_ _N_} _N_ _N_ },
+ inRange = { _A_ 2 _U_ 11 _N_ _S_ "U(SS)U(U(P)L)" {_A_ 4 _U_ 1121 _N_ _N_ _N_ _N_} _N_ _N_ } #-}
instance (Ord a, Ord b) => Ord (a, b)
{-# GHC_PRAGMA _M_ PreludeBuiltin {-dfun-} _A_ 3 _U_ 112 _N_ _N_ _N_ _N_ #-}
instance Ord (Int, Int)
{-# GHC_PRAGMA _M_ PreludeBuiltin {-dfun-} _A_ 0 _N_ _N_ _N_ _F_ _IF_ARGS_ 0 0 X 9 _!_ _TUP_8 [{{Eq (Int, Int)}}, ((Int, Int) -> (Int, Int) -> Bool), ((Int, Int) -> (Int, Int) -> Bool), ((Int, Int) -> (Int, Int) -> Bool), ((Int, Int) -> (Int, Int) -> Bool), ((Int, Int) -> (Int, Int) -> (Int, Int)), ((Int, Int) -> (Int, Int) -> (Int, Int)), ((Int, Int) -> (Int, Int) -> _CMP_TAG)] [_DFUN_ Eq ((Int, Int)), _CONSTM_ Ord (<) ((Int, Int)), _CONSTM_ Ord (<=) ((Int, Int)), _CONSTM_ Ord (>=) ((Int, Int)), _CONSTM_ Ord (>) ((Int, Int)), _CONSTM_ Ord max ((Int, Int)), _CONSTM_ Ord min ((Int, Int)), _CONSTM_ Ord _tagCmp ((Int, Int))] _N_
- (<) = _A_ 2 _U_ 11 _N_ _S_ "U(U(P)L)U(U(P)L)" {_A_ 4 _U_ 2121 _N_ _N_ _N_ _N_} _N_ _N_,
- (<=) = _A_ 2 _U_ 11 _N_ _S_ "U(U(P)L)U(U(P)L)" {_A_ 4 _U_ 2121 _N_ _N_ _N_ _N_} _N_ _N_,
- (>=) = _A_ 2 _U_ 11 _N_ _S_ "U(U(P)L)U(U(P)L)" {_A_ 4 _U_ 2121 _N_ _N_ _N_ _N_} _N_ _N_,
- (>) = _A_ 2 _U_ 11 _N_ _S_ "U(U(P)L)U(U(P)L)" {_A_ 4 _U_ 2121 _N_ _N_ _N_ _N_} _N_ _N_,
- max = _A_ 2 _U_ 11 _N_ _S_ "U(U(P)L)U(U(P)L)" {_A_ 4 _U_ 2222 _N_ _N_ _N_ _N_} _N_ _N_,
- min = _A_ 2 _U_ 11 _N_ _S_ "U(U(P)L)U(U(P)L)" {_A_ 4 _U_ 2222 _N_ _N_ _N_ _N_} _N_ _N_,
- _tagCmp = _A_ 2 _U_ 11 _N_ _S_ "U(U(P)L)U(U(P)L)" {_A_ 4 _U_ 2121 _N_ _N_ _N_ _N_} _N_ _N_ #-}
+ (<) = { _A_ 2 _U_ 11 _N_ _S_ "U(U(P)L)U(U(P)L)" {_A_ 4 _U_ 2121 _N_ _N_ _N_ _N_} _N_ _N_ },
+ (<=) = { _A_ 2 _U_ 11 _N_ _S_ "U(U(P)L)U(U(P)L)" {_A_ 4 _U_ 2121 _N_ _N_ _N_ _N_} _N_ _N_ },
+ (>=) = { _A_ 2 _U_ 11 _N_ _S_ "U(U(P)L)U(U(P)L)" {_A_ 4 _U_ 2121 _N_ _N_ _N_ _N_} _N_ _N_ },
+ (>) = { _A_ 2 _U_ 11 _N_ _S_ "U(U(P)L)U(U(P)L)" {_A_ 4 _U_ 2121 _N_ _N_ _N_ _N_} _N_ _N_ },
+ max = { _A_ 2 _U_ 11 _N_ _S_ "U(U(P)L)U(U(P)L)" {_A_ 4 _U_ 2222 _N_ _N_ _N_ _N_} _N_ _N_ },
+ min = { _A_ 2 _U_ 11 _N_ _S_ "U(U(P)L)U(U(P)L)" {_A_ 4 _U_ 2222 _N_ _N_ _N_ _N_} _N_ _N_ },
+ _tagCmp = { _A_ 2 _U_ 11 _N_ _S_ "U(U(P)L)U(U(P)L)" {_A_ 4 _U_ 2121 _N_ _N_ _N_ _N_} _N_ _N_ } #-}
+instance Ord ([Char], [Char])
+ {-# GHC_PRAGMA _M_ PreludeBuiltin {-dfun-} _A_ 0 _N_ _N_ _N_ _F_ _IF_ARGS_ 0 0 X 9 _!_ _TUP_8 [{{Eq ([Char], [Char])}}, (([Char], [Char]) -> ([Char], [Char]) -> Bool), (([Char], [Char]) -> ([Char], [Char]) -> Bool), (([Char], [Char]) -> ([Char], [Char]) -> Bool), (([Char], [Char]) -> ([Char], [Char]) -> Bool), (([Char], [Char]) -> ([Char], [Char]) -> ([Char], [Char])), (([Char], [Char]) -> ([Char], [Char]) -> ([Char], [Char])), (([Char], [Char]) -> ([Char], [Char]) -> _CMP_TAG)] [_DFUN_ Eq (([Char], [Char])), _CONSTM_ Ord (<) (([Char], [Char])), _CONSTM_ Ord (<=) (([Char], [Char])), _CONSTM_ Ord (>=) (([Char], [Char])), _CONSTM_ Ord (>) (([Char], [Char])), _CONSTM_ Ord max (([Char], [Char])), _CONSTM_ Ord min (([Char], [Char])), _CONSTM_ Ord _tagCmp (([Char], [Char]))] _N_
+ (<) = { _A_ 2 _U_ 11 _N_ _S_ "U(SL)U(SL)" {_A_ 4 _U_ 2222 _N_ _N_ _N_ _N_} _N_ _N_ },
+ (<=) = { _A_ 2 _U_ 11 _N_ _S_ "U(SL)U(SL)" {_A_ 4 _U_ 2222 _N_ _N_ _N_ _N_} _N_ _N_ },
+ (>=) = { _A_ 2 _U_ 11 _N_ _S_ "U(SL)U(SL)" {_A_ 4 _U_ 2222 _N_ _N_ _N_ _N_} _N_ _N_ },
+ (>) = { _A_ 2 _U_ 11 _N_ _S_ "U(SL)U(SL)" {_A_ 4 _U_ 2222 _N_ _N_ _N_ _N_} _N_ _N_ },
+ max = { _A_ 2 _U_ 11 _N_ _S_ "U(SL)U(SL)" {_A_ 4 _U_ 2222 _N_ _N_ _N_ _N_} _N_ _N_ },
+ min = { _A_ 2 _U_ 11 _N_ _S_ "U(SL)U(SL)" {_A_ 4 _U_ 2222 _N_ _N_ _N_ _N_} _N_ _N_ },
+ _tagCmp = { _A_ 2 _U_ 11 _N_ _S_ "U(SL)U(SL)" {_A_ 4 _U_ 2222 _N_ _N_ _N_ _N_} _N_ _N_ } #-}
+instance Ord ([Int], [Int])
+ {-# GHC_PRAGMA _M_ PreludeBuiltin {-dfun-} _A_ 0 _N_ _N_ _N_ _F_ _IF_ARGS_ 0 0 X 9 _!_ _TUP_8 [{{Eq ([Int], [Int])}}, (([Int], [Int]) -> ([Int], [Int]) -> Bool), (([Int], [Int]) -> ([Int], [Int]) -> Bool), (([Int], [Int]) -> ([Int], [Int]) -> Bool), (([Int], [Int]) -> ([Int], [Int]) -> Bool), (([Int], [Int]) -> ([Int], [Int]) -> ([Int], [Int])), (([Int], [Int]) -> ([Int], [Int]) -> ([Int], [Int])), (([Int], [Int]) -> ([Int], [Int]) -> _CMP_TAG)] [_DFUN_ Eq (([Int], [Int])), _CONSTM_ Ord (<) (([Int], [Int])), _CONSTM_ Ord (<=) (([Int], [Int])), _CONSTM_ Ord (>=) (([Int], [Int])), _CONSTM_ Ord (>) (([Int], [Int])), _CONSTM_ Ord max (([Int], [Int])), _CONSTM_ Ord min (([Int], [Int])), _CONSTM_ Ord _tagCmp (([Int], [Int]))] _N_
+ (<) = { _A_ 2 _U_ 11 _N_ _S_ "U(SL)U(SL)" {_A_ 4 _U_ 2222 _N_ _N_ _N_ _N_} _N_ _N_ },
+ (<=) = { _A_ 2 _U_ 11 _N_ _S_ "U(SL)U(SL)" {_A_ 4 _U_ 2222 _N_ _N_ _N_ _N_} _N_ _N_ },
+ (>=) = { _A_ 2 _U_ 11 _N_ _S_ "U(SL)U(SL)" {_A_ 4 _U_ 2222 _N_ _N_ _N_ _N_} _N_ _N_ },
+ (>) = { _A_ 2 _U_ 11 _N_ _S_ "U(SL)U(SL)" {_A_ 4 _U_ 2222 _N_ _N_ _N_ _N_} _N_ _N_ },
+ max = { _A_ 2 _U_ 11 _N_ _S_ "U(SL)U(SL)" {_A_ 4 _U_ 2222 _N_ _N_ _N_ _N_} _N_ _N_ },
+ min = { _A_ 2 _U_ 11 _N_ _S_ "U(SL)U(SL)" {_A_ 4 _U_ 2222 _N_ _N_ _N_ _N_} _N_ _N_ },
+ _tagCmp = { _A_ 2 _U_ 11 _N_ _S_ "U(SL)U(SL)" {_A_ 4 _U_ 2222 _N_ _N_ _N_ _N_} _N_ _N_ } #-}
instance Ord (_PackedString, _PackedString)
{-# GHC_PRAGMA _M_ PreludeBuiltin {-dfun-} _A_ 0 _N_ _N_ _N_ _F_ _IF_ARGS_ 0 0 X 9 _!_ _TUP_8 [{{Eq (_PackedString, _PackedString)}}, ((_PackedString, _PackedString) -> (_PackedString, _PackedString) -> Bool), ((_PackedString, _PackedString) -> (_PackedString, _PackedString) -> Bool), ((_PackedString, _PackedString) -> (_PackedString, _PackedString) -> Bool), ((_PackedString, _PackedString) -> (_PackedString, _PackedString) -> Bool), ((_PackedString, _PackedString) -> (_PackedString, _PackedString) -> (_PackedString, _PackedString)), ((_PackedString, _PackedString) -> (_PackedString, _PackedString) -> (_PackedString, _PackedString)), ((_PackedString, _PackedString) -> (_PackedString, _PackedString) -> _CMP_TAG)] [_DFUN_ Eq ((_PackedString, _PackedString)), _CONSTM_ Ord (<) ((_PackedString, _PackedString)), _CONSTM_ Ord (<=) ((_PackedString, _PackedString)), _CONSTM_ Ord (>=) ((_PackedString, _PackedString)), _CONSTM_ Ord (>) ((_PackedString, _PackedString)), _CONSTM_ Ord max ((_PackedString, _PackedString)), _CONSTM_ Ord min ((_PackedString, _PackedString)), _CONSTM_ Ord _tagCmp ((_PackedString, _PackedString))] _N_
- (<) = _A_ 2 _U_ 11 _N_ _S_ "U(SL)U(SL)" {_A_ 4 _U_ 2222 _N_ _N_ _N_ _N_} _N_ _N_,
- (<=) = _A_ 2 _U_ 11 _N_ _S_ "U(SL)U(SL)" {_A_ 4 _U_ 2222 _N_ _N_ _N_ _N_} _N_ _N_,
- (>=) = _A_ 2 _U_ 11 _N_ _S_ "U(SL)U(SL)" {_A_ 4 _U_ 2222 _N_ _N_ _N_ _N_} _N_ _N_,
- (>) = _A_ 2 _U_ 11 _N_ _S_ "U(SL)U(SL)" {_A_ 4 _U_ 2222 _N_ _N_ _N_ _N_} _N_ _N_,
- max = _A_ 2 _U_ 11 _N_ _S_ "U(SL)U(SL)" {_A_ 4 _U_ 2222 _N_ _N_ _N_ _N_} _N_ _N_,
- min = _A_ 2 _U_ 11 _N_ _S_ "U(SL)U(SL)" {_A_ 4 _U_ 2222 _N_ _N_ _N_ _N_} _N_ _N_,
- _tagCmp = _A_ 2 _U_ 11 _N_ _S_ "U(SL)U(SL)" {_A_ 4 _U_ 2222 _N_ _N_ _N_ _N_} _N_ _N_ #-}
+ (<) = { _A_ 2 _U_ 11 _N_ _S_ "U(SL)U(SL)" {_A_ 4 _U_ 2222 _N_ _N_ _N_ _N_} _N_ _N_ },
+ (<=) = { _A_ 2 _U_ 11 _N_ _S_ "U(SL)U(SL)" {_A_ 4 _U_ 2222 _N_ _N_ _N_ _N_} _N_ _N_ },
+ (>=) = { _A_ 2 _U_ 11 _N_ _S_ "U(SL)U(SL)" {_A_ 4 _U_ 2222 _N_ _N_ _N_ _N_} _N_ _N_ },
+ (>) = { _A_ 2 _U_ 11 _N_ _S_ "U(SL)U(SL)" {_A_ 4 _U_ 2222 _N_ _N_ _N_ _N_} _N_ _N_ },
+ max = { _A_ 2 _U_ 11 _N_ _S_ "U(SL)U(SL)" {_A_ 4 _U_ 2222 _N_ _N_ _N_ _N_} _N_ _N_ },
+ min = { _A_ 2 _U_ 11 _N_ _S_ "U(SL)U(SL)" {_A_ 4 _U_ 2222 _N_ _N_ _N_ _N_} _N_ _N_ },
+ _tagCmp = { _A_ 2 _U_ 11 _N_ _S_ "U(SL)U(SL)" {_A_ 4 _U_ 2222 _N_ _N_ _N_ _N_} _N_ _N_ } #-}
+instance Text ((Int, Int), (Int, Int))
+ {-# GHC_PRAGMA _M_ PreludeBuiltin {-dfun-} _A_ 0 _N_ _N_ _N_ _F_ _IF_ARGS_ 0 0 X 5 _!_ _TUP_4 [(Int -> [Char] -> [(((Int, Int), (Int, Int)), [Char])]), (Int -> ((Int, Int), (Int, Int)) -> [Char] -> [Char]), ([Char] -> [([((Int, Int), (Int, Int))], [Char])]), ([((Int, Int), (Int, Int))] -> [Char] -> [Char])] [_CONSTM_ Text readsPrec (((Int, Int), (Int, Int))), _CONSTM_ Text showsPrec (((Int, Int), (Int, Int))), _CONSTM_ Text readList (((Int, Int), (Int, Int))), _CONSTM_ Text showList (((Int, Int), (Int, Int)))] _N_
+ readsPrec = { _A_ 1 _U_ 02 _N_ _S_ "A" {_A_ 0 _U_ 2 _N_ _N_ _N_ _N_} _N_ _N_ },
+ showsPrec = { _A_ 3 _U_ 012 _N_ _S_ "AU(LL)L" {_A_ 3 _U_ 112 _N_ _N_ _N_ _N_} _N_ _N_ },
+ readList = { _A_ 0 _U_ 2 _N_ _N_ _N_ _N_ },
+ showList = { _A_ 1 _U_ 12 _N_ _N_ _N_ _N_ } #-}
instance (Text a, Text b) => Text (a, b)
{-# GHC_PRAGMA _M_ PreludeBuiltin {-dfun-} _A_ 2 _U_ 22 _N_ _N_ _N_ _N_ #-}
instance Text (Int, Int)
{-# GHC_PRAGMA _M_ PreludeBuiltin {-dfun-} _A_ 0 _N_ _N_ _N_ _F_ _IF_ARGS_ 0 0 X 5 _!_ _TUP_4 [(Int -> [Char] -> [((Int, Int), [Char])]), (Int -> (Int, Int) -> [Char] -> [Char]), ([Char] -> [([(Int, Int)], [Char])]), ([(Int, Int)] -> [Char] -> [Char])] [_CONSTM_ Text readsPrec ((Int, Int)), _CONSTM_ Text showsPrec ((Int, Int)), _CONSTM_ Text readList ((Int, Int)), _CONSTM_ Text showList ((Int, Int))] _N_
- readsPrec = _A_ 1 _U_ 02 _N_ _S_ "A" {_A_ 0 _U_ 2 _N_ _N_ _N_ _N_} _N_ _N_,
- showsPrec = _A_ 3 _U_ 012 _N_ _S_ "AU(LL)L" {_A_ 3 _U_ 112 _N_ _N_ _N_ _N_} _N_ _N_,
- readList = _A_ 0 _U_ 2 _N_ _N_ _N_ _N_,
- showList = _A_ 0 _U_ 12 _N_ _N_ _N_ _N_ #-}
+ readsPrec = { _A_ 1 _U_ 02 _N_ _S_ "A" {_A_ 0 _U_ 2 _N_ _N_ _N_ _N_} _N_ _N_ },
+ showsPrec = { _A_ 3 _U_ 012 _N_ _S_ "AU(LL)L" {_A_ 3 _U_ 112 _N_ _N_ _N_ _N_} _N_ _N_ },
+ readList = { _A_ 0 _U_ 2 _N_ _N_ _N_ _N_ },
+ showList = { _A_ 1 _U_ 12 _N_ _N_ _N_ _N_ } #-}
instance Text (Integer, Integer)
{-# GHC_PRAGMA _M_ PreludeBuiltin {-dfun-} _A_ 0 _N_ _N_ _N_ _F_ _IF_ARGS_ 0 0 X 5 _!_ _TUP_4 [(Int -> [Char] -> [((Integer, Integer), [Char])]), (Int -> (Integer, Integer) -> [Char] -> [Char]), ([Char] -> [([(Integer, Integer)], [Char])]), ([(Integer, Integer)] -> [Char] -> [Char])] [_CONSTM_ Text readsPrec ((Integer, Integer)), _CONSTM_ Text showsPrec ((Integer, Integer)), _CONSTM_ Text readList ((Integer, Integer)), _CONSTM_ Text showList ((Integer, Integer))] _N_
- readsPrec = _A_ 1 _U_ 02 _N_ _S_ "A" {_A_ 0 _U_ 2 _N_ _N_ _N_ _N_} _N_ _N_,
- showsPrec = _A_ 3 _U_ 012 _N_ _S_ "AU(LL)L" {_A_ 3 _U_ 112 _N_ _N_ _N_ _N_} _N_ _N_,
- readList = _A_ 0 _U_ 2 _N_ _N_ _N_ _N_,
- showList = _A_ 0 _U_ 12 _N_ _N_ _N_ _N_ #-}
+ readsPrec = { _A_ 1 _U_ 02 _N_ _S_ "A" {_A_ 0 _U_ 2 _N_ _N_ _N_ _N_} _N_ _N_ },
+ showsPrec = { _A_ 3 _U_ 012 _N_ _S_ "AU(LL)L" {_A_ 3 _U_ 112 _N_ _N_ _N_ _N_} _N_ _N_ },
+ readList = { _A_ 0 _U_ 2 _N_ _N_ _N_ _N_ },
+ showList = { _A_ 1 _U_ 12 _N_ _N_ _N_ _N_ } #-}
import Cls
import Core
+import IChar
+import IDouble
import IInt
import IInteger
import IList
import List ( (++), foldr )
-import Prel ( (&&), (.) )
+import Prel ( (&&), (||), (.) )
import PS ( _PackedString, _unpackPS )
import Text
+import TyArray
+import TyComplex
instance (Eq a, Eq b) => Eq (a, b) where
(a,b) == (c,d) = a == c && b == d
+ (a,b) /= (c,d) = a /= c || b /= d
instance (Ord a, Ord b) => Ord (a, b) where
a < b = case _tagCmp a b of { _LT -> True; _EQ -> False; _GT -> False }
instance (Text a, Text b) => Text (a, b) where
readsPrec p = readParen False
(\r -> [((x,y), w) | ("(",s) <- lex r,
- (x,t) <- reads s,
+ (x,t) <- readsPrec 0 s,
(",",u) <- lex t,
- (y,v) <- reads u,
+ (y,v) <- readsPrec 0 u,
(")",w) <- lex v ] )
- showsPrec p (x,y) = showChar '(' . shows x . showString ", " .
- shows y . showChar ')'
+ showsPrec p (x,y) = showChar '(' . showsPrec 0 x . showString ", " .
+ showsPrec 0 y . showChar ')'
+
+ readList = _readList (readsPrec 0)
+ showList = _showList (showsPrec 0)
{-# SPECIALIZE instance Eq (Int, Int) #-}
{-# SPECIALIZE instance Ord (Int, Int) #-}
{-# SPECIALIZE instance Text (Int, Int) #-}
{-# SPECIALIZE instance Text (Integer, Integer) #-}
+{-# SPECIALIZE instance Text ((Int,Int),(Int,Int)) #-}
+
+{-# SPECIALIZE instance Eq ([Char], [Char]) #-}
+{-# SPECIALIZE instance Ord ([Char], [Char]) #-}
+
+{-# SPECIALIZE instance Eq ([Int], [Int]) #-}
+{-# SPECIALIZE instance Ord ([Int], [Int]) #-}
{-# SPECIALIZE instance Eq (_PackedString, _PackedString) #-}
{-# SPECIALIZE instance Ord (_PackedString, _PackedString) #-}
{-# GENERATE_SPECS instance a{Char#,Int#} b{Char#,Int#} :: Ix (a,b) #-}
{-# GENERATE_SPECS instance a b :: Text (a,b) #-}
+{-# SPECIALIZE instance Eq ([Char#], [Char#]) #-}
+{-# SPECIALIZE instance Ord ([Char#], [Char#]) #-}
+
+{-# SPECIALIZE instance Eq ([Int#], [Int#]) #-}
+{-# SPECIALIZE instance Ord ([Int#], [Int#]) #-}
+
#endif {-UNBOXED INSTANCES-}
-{-# GHC_PRAGMA INTERFACE VERSION 5 #-}
+{-# GHC_PRAGMA INTERFACE VERSION 6 #-}
interface PreludeBuiltin where
import PreludeCore(Eq(..), Ix(..), Ord(..), Text(..))
import PreludePS(_PackedString)
instance (Eq a, Eq b) => Eq (a, b)
- {-# GHC_PRAGMA _M_ PreludeBuiltin {-dfun-} _A_ 2 _U_ 11 _N_ _N_ _N_ _N_ #-}
+ {-# GHC_PRAGMA _M_ PreludeBuiltin {-dfun-} _A_ 2 _U_ 22 _N_ _N_ _N_ _N_ #-}
instance Eq (Int, Int)
{-# GHC_PRAGMA _M_ PreludeBuiltin {-dfun-} _A_ 0 _N_ _N_ _N_ _F_ _IF_ARGS_ 0 0 X 3 _!_ _TUP_2 [((Int, Int) -> (Int, Int) -> Bool), ((Int, Int) -> (Int, Int) -> Bool)] [_CONSTM_ Eq (==) ((Int, Int)), _CONSTM_ Eq (/=) ((Int, Int))] _N_
- (==) = _A_ 2 _U_ 11 _N_ _S_ "U(U(P)L)U(U(P)L)" {_A_ 4 _U_ 2121 _N_ _N_ _F_ _IF_ARGS_ 0 4 XCXC 7 \ (u0 :: Int#) (u1 :: Int) (u2 :: Int#) (u3 :: Int) -> case _#_ eqInt# [] [u0, u2] of { _ALG_ True -> case u1 of { _ALG_ I# (u4 :: Int#) -> case u3 of { _ALG_ I# (u5 :: Int#) -> _#_ eqInt# [] [u4, u5]; _NO_DEFLT_ }; _NO_DEFLT_ }; False -> _!_ False [] []; _NO_DEFLT_ } _N_} _F_ _ALWAYS_ \ (u0 :: (Int, Int)) (u1 :: (Int, Int)) -> case u0 of { _ALG_ _TUP_2 (u2 :: Int) (u3 :: Int) -> case u2 of { _ALG_ I# (u4 :: Int#) -> case u1 of { _ALG_ _TUP_2 (u5 :: Int) (u6 :: Int) -> case u5 of { _ALG_ I# (u7 :: Int#) -> case _#_ eqInt# [] [u4, u7] of { _ALG_ True -> case u3 of { _ALG_ I# (u8 :: Int#) -> case u6 of { _ALG_ I# (u9 :: Int#) -> _#_ eqInt# [] [u8, u9]; _NO_DEFLT_ }; _NO_DEFLT_ }; False -> _!_ False [] []; _NO_DEFLT_ }; _NO_DEFLT_ }; _NO_DEFLT_ }; _NO_DEFLT_ }; _NO_DEFLT_ } _N_,
- (/=) = _A_ 2 _U_ 22 _N_ _N_ _N_ _N_ #-}
+ (==) = { _A_ 2 _U_ 11 _N_ _S_ "U(U(P)L)U(U(P)L)" {_A_ 4 _U_ 2121 _N_ _N_ _F_ _IF_ARGS_ 0 4 XCXC 7 \ (u0 :: Int#) (u1 :: Int) (u2 :: Int#) (u3 :: Int) -> case _#_ eqInt# [] [u0, u2] of { _ALG_ True -> case u1 of { _ALG_ I# (u4 :: Int#) -> case u3 of { _ALG_ I# (u5 :: Int#) -> _#_ eqInt# [] [u4, u5]; _NO_DEFLT_ }; _NO_DEFLT_ }; False -> _!_ False [] []; _NO_DEFLT_ } _N_} _F_ _ALWAYS_ \ (u0 :: (Int, Int)) (u1 :: (Int, Int)) -> case u0 of { _ALG_ _TUP_2 (u2 :: Int) (u3 :: Int) -> case u2 of { _ALG_ I# (u4 :: Int#) -> case u1 of { _ALG_ _TUP_2 (u5 :: Int) (u6 :: Int) -> case u5 of { _ALG_ I# (u7 :: Int#) -> case _#_ eqInt# [] [u4, u7] of { _ALG_ True -> case u3 of { _ALG_ I# (u8 :: Int#) -> case u6 of { _ALG_ I# (u9 :: Int#) -> _#_ eqInt# [] [u8, u9]; _NO_DEFLT_ }; _NO_DEFLT_ }; False -> _!_ False [] []; _NO_DEFLT_ }; _NO_DEFLT_ }; _NO_DEFLT_ }; _NO_DEFLT_ }; _NO_DEFLT_ } _N_ },
+ (/=) = { _A_ 2 _U_ 11 _N_ _S_ "U(U(P)L)U(U(P)L)" {_A_ 4 _U_ 2121 _N_ _N_ _F_ _IF_ARGS_ 0 4 XCXC 7 \ (u0 :: Int#) (u1 :: Int) (u2 :: Int#) (u3 :: Int) -> case _#_ neInt# [] [u0, u2] of { _ALG_ True -> _!_ True [] []; False -> case u1 of { _ALG_ I# (u4 :: Int#) -> case u3 of { _ALG_ I# (u5 :: Int#) -> _#_ neInt# [] [u4, u5]; _NO_DEFLT_ }; _NO_DEFLT_ }; _NO_DEFLT_ } _N_} _F_ _ALWAYS_ \ (u0 :: (Int, Int)) (u1 :: (Int, Int)) -> case u0 of { _ALG_ _TUP_2 (u2 :: Int) (u3 :: Int) -> case u2 of { _ALG_ I# (u4 :: Int#) -> case u1 of { _ALG_ _TUP_2 (u5 :: Int) (u6 :: Int) -> case u5 of { _ALG_ I# (u7 :: Int#) -> case _#_ neInt# [] [u4, u7] of { _ALG_ True -> _!_ True [] []; False -> case u3 of { _ALG_ I# (u8 :: Int#) -> case u6 of { _ALG_ I# (u9 :: Int#) -> _#_ neInt# [] [u8, u9]; _NO_DEFLT_ }; _NO_DEFLT_ }; _NO_DEFLT_ }; _NO_DEFLT_ }; _NO_DEFLT_ }; _NO_DEFLT_ }; _NO_DEFLT_ } _N_ } #-}
+instance Eq ([Char], [Char])
+ {-# GHC_PRAGMA _M_ PreludeBuiltin {-dfun-} _A_ 0 _N_ _N_ _N_ _F_ _IF_ARGS_ 0 0 X 3 _!_ _TUP_2 [(([Char], [Char]) -> ([Char], [Char]) -> Bool), (([Char], [Char]) -> ([Char], [Char]) -> Bool)] [_CONSTM_ Eq (==) (([Char], [Char])), _CONSTM_ Eq (/=) (([Char], [Char]))] _N_
+ (==) = { _A_ 2 _U_ 11 _N_ _S_ "U(SL)U(SL)" {_A_ 4 _U_ 2222 _N_ _N_ _N_ _N_} _N_ _N_ },
+ (/=) = { _A_ 2 _U_ 11 _N_ _S_ "U(SL)U(SL)" {_A_ 4 _U_ 2222 _N_ _N_ _N_ _N_} _N_ _N_ } #-}
+instance Eq ([Int], [Int])
+ {-# GHC_PRAGMA _M_ PreludeBuiltin {-dfun-} _A_ 0 _N_ _N_ _N_ _F_ _IF_ARGS_ 0 0 X 3 _!_ _TUP_2 [(([Int], [Int]) -> ([Int], [Int]) -> Bool), (([Int], [Int]) -> ([Int], [Int]) -> Bool)] [_CONSTM_ Eq (==) (([Int], [Int])), _CONSTM_ Eq (/=) (([Int], [Int]))] _N_
+ (==) = { _A_ 2 _U_ 11 _N_ _S_ "U(SL)U(SL)" {_A_ 4 _U_ 2222 _N_ _N_ _N_ _N_} _N_ _N_ },
+ (/=) = { _A_ 2 _U_ 11 _N_ _S_ "U(SL)U(SL)" {_A_ 4 _U_ 2222 _N_ _N_ _N_ _N_} _N_ _N_ } #-}
instance Eq (_PackedString, _PackedString)
{-# GHC_PRAGMA _M_ PreludeBuiltin {-dfun-} _A_ 0 _N_ _N_ _N_ _F_ _IF_ARGS_ 0 0 X 3 _!_ _TUP_2 [((_PackedString, _PackedString) -> (_PackedString, _PackedString) -> Bool), ((_PackedString, _PackedString) -> (_PackedString, _PackedString) -> Bool)] [_CONSTM_ Eq (==) ((_PackedString, _PackedString)), _CONSTM_ Eq (/=) ((_PackedString, _PackedString))] _N_
- (==) = _A_ 2 _U_ 11 _N_ _S_ "U(SL)U(SL)" {_A_ 4 _U_ 2222 _N_ _N_ _N_ _N_} _N_ _N_,
- (/=) = _A_ 2 _U_ 22 _N_ _N_ _N_ _N_ #-}
+ (==) = { _A_ 2 _U_ 11 _N_ _S_ "U(SL)U(SL)" {_A_ 4 _U_ 2222 _N_ _N_ _N_ _N_} _N_ _N_ },
+ (/=) = { _A_ 2 _U_ 11 _N_ _S_ "U(SL)U(SL)" {_A_ 4 _U_ 2222 _N_ _N_ _N_ _N_} _N_ _N_ } #-}
instance (Ix a, Ix b) => Ix (a, b)
{-# GHC_PRAGMA _M_ PreludeBuiltin {-dfun-} _A_ 3 _U_ 222 _N_ _N_ _N_ _N_ #-}
instance Ix (Int, Int)
{-# GHC_PRAGMA _M_ PreludeBuiltin {-dfun-} _A_ 0 _N_ _N_ _N_ _F_ _IF_ARGS_ 0 0 X 5 _!_ _TUP_4 [{{Ord (Int, Int)}}, (((Int, Int), (Int, Int)) -> [(Int, Int)]), (((Int, Int), (Int, Int)) -> (Int, Int) -> Int), (((Int, Int), (Int, Int)) -> (Int, Int) -> Bool)] [_DFUN_ Ord ((Int, Int)), _CONSTM_ Ix range ((Int, Int)), _CONSTM_ Ix index ((Int, Int)), _CONSTM_ Ix inRange ((Int, Int))] _N_
- range = _A_ 1 _U_ 1 _N_ _S_ "U(SS)" {_A_ 2 _U_ 11 _N_ _N_ _N_ _N_} _N_ _N_,
- index = _A_ 2 _U_ 11 _N_ _S_ "U(SS)U(U(P)U(P))" {_A_ 4 _U_ 1122 _N_ _N_ _N_ _N_} _N_ _N_,
- inRange = _A_ 2 _U_ 11 _N_ _S_ "U(SS)U(U(P)L)" {_A_ 4 _U_ 1121 _N_ _N_ _N_ _N_} _N_ _N_ #-}
+ range = { _A_ 1 _U_ 1 _N_ _S_ "U(SS)" {_A_ 2 _U_ 11 _N_ _N_ _N_ _N_} _N_ _N_ },
+ index = { _A_ 2 _U_ 11 _N_ _S_ "U(SS)U(U(P)U(P))" {_A_ 4 _U_ 1122 _N_ _N_ _N_ _N_} _N_ _N_ },
+ inRange = { _A_ 2 _U_ 11 _N_ _S_ "U(SS)U(U(P)L)" {_A_ 4 _U_ 1121 _N_ _N_ _N_ _N_} _N_ _N_ } #-}
instance (Ord a, Ord b) => Ord (a, b)
{-# GHC_PRAGMA _M_ PreludeBuiltin {-dfun-} _A_ 3 _U_ 112 _N_ _N_ _N_ _N_ #-}
instance Ord (Int, Int)
{-# GHC_PRAGMA _M_ PreludeBuiltin {-dfun-} _A_ 0 _N_ _N_ _N_ _F_ _IF_ARGS_ 0 0 X 9 _!_ _TUP_8 [{{Eq (Int, Int)}}, ((Int, Int) -> (Int, Int) -> Bool), ((Int, Int) -> (Int, Int) -> Bool), ((Int, Int) -> (Int, Int) -> Bool), ((Int, Int) -> (Int, Int) -> Bool), ((Int, Int) -> (Int, Int) -> (Int, Int)), ((Int, Int) -> (Int, Int) -> (Int, Int)), ((Int, Int) -> (Int, Int) -> _CMP_TAG)] [_DFUN_ Eq ((Int, Int)), _CONSTM_ Ord (<) ((Int, Int)), _CONSTM_ Ord (<=) ((Int, Int)), _CONSTM_ Ord (>=) ((Int, Int)), _CONSTM_ Ord (>) ((Int, Int)), _CONSTM_ Ord max ((Int, Int)), _CONSTM_ Ord min ((Int, Int)), _CONSTM_ Ord _tagCmp ((Int, Int))] _N_
- (<) = _A_ 2 _U_ 11 _N_ _S_ "U(U(P)L)U(U(P)L)" {_A_ 4 _U_ 2121 _N_ _N_ _N_ _N_} _N_ _N_,
- (<=) = _A_ 2 _U_ 11 _N_ _S_ "U(U(P)L)U(U(P)L)" {_A_ 4 _U_ 2121 _N_ _N_ _N_ _N_} _N_ _N_,
- (>=) = _A_ 2 _U_ 11 _N_ _S_ "U(U(P)L)U(U(P)L)" {_A_ 4 _U_ 2121 _N_ _N_ _N_ _N_} _N_ _N_,
- (>) = _A_ 2 _U_ 11 _N_ _S_ "U(U(P)L)U(U(P)L)" {_A_ 4 _U_ 2121 _N_ _N_ _N_ _N_} _N_ _N_,
- max = _A_ 2 _U_ 11 _N_ _S_ "U(U(P)L)U(U(P)L)" {_A_ 4 _U_ 2222 _N_ _N_ _N_ _N_} _N_ _N_,
- min = _A_ 2 _U_ 11 _N_ _S_ "U(U(P)L)U(U(P)L)" {_A_ 4 _U_ 2222 _N_ _N_ _N_ _N_} _N_ _N_,
- _tagCmp = _A_ 2 _U_ 11 _N_ _S_ "U(U(P)L)U(U(P)L)" {_A_ 4 _U_ 2121 _N_ _N_ _N_ _N_} _N_ _N_ #-}
+ (<) = { _A_ 2 _U_ 11 _N_ _S_ "U(U(P)L)U(U(P)L)" {_A_ 4 _U_ 2121 _N_ _N_ _N_ _N_} _N_ _N_ },
+ (<=) = { _A_ 2 _U_ 11 _N_ _S_ "U(U(P)L)U(U(P)L)" {_A_ 4 _U_ 2121 _N_ _N_ _N_ _N_} _N_ _N_ },
+ (>=) = { _A_ 2 _U_ 11 _N_ _S_ "U(U(P)L)U(U(P)L)" {_A_ 4 _U_ 2121 _N_ _N_ _N_ _N_} _N_ _N_ },
+ (>) = { _A_ 2 _U_ 11 _N_ _S_ "U(U(P)L)U(U(P)L)" {_A_ 4 _U_ 2121 _N_ _N_ _N_ _N_} _N_ _N_ },
+ max = { _A_ 2 _U_ 11 _N_ _S_ "U(U(P)L)U(U(P)L)" {_A_ 4 _U_ 2222 _N_ _N_ _N_ _N_} _N_ _N_ },
+ min = { _A_ 2 _U_ 11 _N_ _S_ "U(U(P)L)U(U(P)L)" {_A_ 4 _U_ 2222 _N_ _N_ _N_ _N_} _N_ _N_ },
+ _tagCmp = { _A_ 2 _U_ 11 _N_ _S_ "U(U(P)L)U(U(P)L)" {_A_ 4 _U_ 2121 _N_ _N_ _N_ _N_} _N_ _N_ } #-}
+instance Ord ([Char], [Char])
+ {-# GHC_PRAGMA _M_ PreludeBuiltin {-dfun-} _A_ 0 _N_ _N_ _N_ _F_ _IF_ARGS_ 0 0 X 9 _!_ _TUP_8 [{{Eq ([Char], [Char])}}, (([Char], [Char]) -> ([Char], [Char]) -> Bool), (([Char], [Char]) -> ([Char], [Char]) -> Bool), (([Char], [Char]) -> ([Char], [Char]) -> Bool), (([Char], [Char]) -> ([Char], [Char]) -> Bool), (([Char], [Char]) -> ([Char], [Char]) -> ([Char], [Char])), (([Char], [Char]) -> ([Char], [Char]) -> ([Char], [Char])), (([Char], [Char]) -> ([Char], [Char]) -> _CMP_TAG)] [_DFUN_ Eq (([Char], [Char])), _CONSTM_ Ord (<) (([Char], [Char])), _CONSTM_ Ord (<=) (([Char], [Char])), _CONSTM_ Ord (>=) (([Char], [Char])), _CONSTM_ Ord (>) (([Char], [Char])), _CONSTM_ Ord max (([Char], [Char])), _CONSTM_ Ord min (([Char], [Char])), _CONSTM_ Ord _tagCmp (([Char], [Char]))] _N_
+ (<) = { _A_ 2 _U_ 11 _N_ _S_ "U(SL)U(SL)" {_A_ 4 _U_ 2222 _N_ _N_ _N_ _N_} _N_ _N_ },
+ (<=) = { _A_ 2 _U_ 11 _N_ _S_ "U(SL)U(SL)" {_A_ 4 _U_ 2222 _N_ _N_ _N_ _N_} _N_ _N_ },
+ (>=) = { _A_ 2 _U_ 11 _N_ _S_ "U(SL)U(SL)" {_A_ 4 _U_ 2222 _N_ _N_ _N_ _N_} _N_ _N_ },
+ (>) = { _A_ 2 _U_ 11 _N_ _S_ "U(SL)U(SL)" {_A_ 4 _U_ 2222 _N_ _N_ _N_ _N_} _N_ _N_ },
+ max = { _A_ 2 _U_ 11 _N_ _S_ "U(SL)U(SL)" {_A_ 4 _U_ 2222 _N_ _N_ _N_ _N_} _N_ _N_ },
+ min = { _A_ 2 _U_ 11 _N_ _S_ "U(SL)U(SL)" {_A_ 4 _U_ 2222 _N_ _N_ _N_ _N_} _N_ _N_ },
+ _tagCmp = { _A_ 2 _U_ 11 _N_ _S_ "U(SL)U(SL)" {_A_ 4 _U_ 2222 _N_ _N_ _N_ _N_} _N_ _N_ } #-}
+instance Ord ([Int], [Int])
+ {-# GHC_PRAGMA _M_ PreludeBuiltin {-dfun-} _A_ 0 _N_ _N_ _N_ _F_ _IF_ARGS_ 0 0 X 9 _!_ _TUP_8 [{{Eq ([Int], [Int])}}, (([Int], [Int]) -> ([Int], [Int]) -> Bool), (([Int], [Int]) -> ([Int], [Int]) -> Bool), (([Int], [Int]) -> ([Int], [Int]) -> Bool), (([Int], [Int]) -> ([Int], [Int]) -> Bool), (([Int], [Int]) -> ([Int], [Int]) -> ([Int], [Int])), (([Int], [Int]) -> ([Int], [Int]) -> ([Int], [Int])), (([Int], [Int]) -> ([Int], [Int]) -> _CMP_TAG)] [_DFUN_ Eq (([Int], [Int])), _CONSTM_ Ord (<) (([Int], [Int])), _CONSTM_ Ord (<=) (([Int], [Int])), _CONSTM_ Ord (>=) (([Int], [Int])), _CONSTM_ Ord (>) (([Int], [Int])), _CONSTM_ Ord max (([Int], [Int])), _CONSTM_ Ord min (([Int], [Int])), _CONSTM_ Ord _tagCmp (([Int], [Int]))] _N_
+ (<) = { _A_ 2 _U_ 11 _N_ _S_ "U(SL)U(SL)" {_A_ 4 _U_ 2222 _N_ _N_ _N_ _N_} _N_ _N_ },
+ (<=) = { _A_ 2 _U_ 11 _N_ _S_ "U(SL)U(SL)" {_A_ 4 _U_ 2222 _N_ _N_ _N_ _N_} _N_ _N_ },
+ (>=) = { _A_ 2 _U_ 11 _N_ _S_ "U(SL)U(SL)" {_A_ 4 _U_ 2222 _N_ _N_ _N_ _N_} _N_ _N_ },
+ (>) = { _A_ 2 _U_ 11 _N_ _S_ "U(SL)U(SL)" {_A_ 4 _U_ 2222 _N_ _N_ _N_ _N_} _N_ _N_ },
+ max = { _A_ 2 _U_ 11 _N_ _S_ "U(SL)U(SL)" {_A_ 4 _U_ 2222 _N_ _N_ _N_ _N_} _N_ _N_ },
+ min = { _A_ 2 _U_ 11 _N_ _S_ "U(SL)U(SL)" {_A_ 4 _U_ 2222 _N_ _N_ _N_ _N_} _N_ _N_ },
+ _tagCmp = { _A_ 2 _U_ 11 _N_ _S_ "U(SL)U(SL)" {_A_ 4 _U_ 2222 _N_ _N_ _N_ _N_} _N_ _N_ } #-}
instance Ord (_PackedString, _PackedString)
{-# GHC_PRAGMA _M_ PreludeBuiltin {-dfun-} _A_ 0 _N_ _N_ _N_ _F_ _IF_ARGS_ 0 0 X 9 _!_ _TUP_8 [{{Eq (_PackedString, _PackedString)}}, ((_PackedString, _PackedString) -> (_PackedString, _PackedString) -> Bool), ((_PackedString, _PackedString) -> (_PackedString, _PackedString) -> Bool), ((_PackedString, _PackedString) -> (_PackedString, _PackedString) -> Bool), ((_PackedString, _PackedString) -> (_PackedString, _PackedString) -> Bool), ((_PackedString, _PackedString) -> (_PackedString, _PackedString) -> (_PackedString, _PackedString)), ((_PackedString, _PackedString) -> (_PackedString, _PackedString) -> (_PackedString, _PackedString)), ((_PackedString, _PackedString) -> (_PackedString, _PackedString) -> _CMP_TAG)] [_DFUN_ Eq ((_PackedString, _PackedString)), _CONSTM_ Ord (<) ((_PackedString, _PackedString)), _CONSTM_ Ord (<=) ((_PackedString, _PackedString)), _CONSTM_ Ord (>=) ((_PackedString, _PackedString)), _CONSTM_ Ord (>) ((_PackedString, _PackedString)), _CONSTM_ Ord max ((_PackedString, _PackedString)), _CONSTM_ Ord min ((_PackedString, _PackedString)), _CONSTM_ Ord _tagCmp ((_PackedString, _PackedString))] _N_
- (<) = _A_ 2 _U_ 11 _N_ _S_ "U(SL)U(SL)" {_A_ 4 _U_ 2222 _N_ _N_ _N_ _N_} _N_ _N_,
- (<=) = _A_ 2 _U_ 11 _N_ _S_ "U(SL)U(SL)" {_A_ 4 _U_ 2222 _N_ _N_ _N_ _N_} _N_ _N_,
- (>=) = _A_ 2 _U_ 11 _N_ _S_ "U(SL)U(SL)" {_A_ 4 _U_ 2222 _N_ _N_ _N_ _N_} _N_ _N_,
- (>) = _A_ 2 _U_ 11 _N_ _S_ "U(SL)U(SL)" {_A_ 4 _U_ 2222 _N_ _N_ _N_ _N_} _N_ _N_,
- max = _A_ 2 _U_ 11 _N_ _S_ "U(SL)U(SL)" {_A_ 4 _U_ 2222 _N_ _N_ _N_ _N_} _N_ _N_,
- min = _A_ 2 _U_ 11 _N_ _S_ "U(SL)U(SL)" {_A_ 4 _U_ 2222 _N_ _N_ _N_ _N_} _N_ _N_,
- _tagCmp = _A_ 2 _U_ 11 _N_ _S_ "U(SL)U(SL)" {_A_ 4 _U_ 2222 _N_ _N_ _N_ _N_} _N_ _N_ #-}
+ (<) = { _A_ 2 _U_ 11 _N_ _S_ "U(SL)U(SL)" {_A_ 4 _U_ 2222 _N_ _N_ _N_ _N_} _N_ _N_ },
+ (<=) = { _A_ 2 _U_ 11 _N_ _S_ "U(SL)U(SL)" {_A_ 4 _U_ 2222 _N_ _N_ _N_ _N_} _N_ _N_ },
+ (>=) = { _A_ 2 _U_ 11 _N_ _S_ "U(SL)U(SL)" {_A_ 4 _U_ 2222 _N_ _N_ _N_ _N_} _N_ _N_ },
+ (>) = { _A_ 2 _U_ 11 _N_ _S_ "U(SL)U(SL)" {_A_ 4 _U_ 2222 _N_ _N_ _N_ _N_} _N_ _N_ },
+ max = { _A_ 2 _U_ 11 _N_ _S_ "U(SL)U(SL)" {_A_ 4 _U_ 2222 _N_ _N_ _N_ _N_} _N_ _N_ },
+ min = { _A_ 2 _U_ 11 _N_ _S_ "U(SL)U(SL)" {_A_ 4 _U_ 2222 _N_ _N_ _N_ _N_} _N_ _N_ },
+ _tagCmp = { _A_ 2 _U_ 11 _N_ _S_ "U(SL)U(SL)" {_A_ 4 _U_ 2222 _N_ _N_ _N_ _N_} _N_ _N_ } #-}
+instance Text ((Int, Int), (Int, Int))
+ {-# GHC_PRAGMA _M_ PreludeBuiltin {-dfun-} _A_ 0 _N_ _N_ _N_ _F_ _IF_ARGS_ 0 0 X 5 _!_ _TUP_4 [(Int -> [Char] -> [(((Int, Int), (Int, Int)), [Char])]), (Int -> ((Int, Int), (Int, Int)) -> [Char] -> [Char]), ([Char] -> [([((Int, Int), (Int, Int))], [Char])]), ([((Int, Int), (Int, Int))] -> [Char] -> [Char])] [_CONSTM_ Text readsPrec (((Int, Int), (Int, Int))), _CONSTM_ Text showsPrec (((Int, Int), (Int, Int))), _CONSTM_ Text readList (((Int, Int), (Int, Int))), _CONSTM_ Text showList (((Int, Int), (Int, Int)))] _N_
+ readsPrec = { _A_ 1 _U_ 02 _N_ _S_ "A" {_A_ 0 _U_ 2 _N_ _N_ _N_ _N_} _N_ _N_ },
+ showsPrec = { _A_ 3 _U_ 012 _N_ _S_ "AU(LL)L" {_A_ 3 _U_ 112 _N_ _N_ _N_ _N_} _N_ _N_ },
+ readList = { _A_ 0 _U_ 2 _N_ _N_ _N_ _N_ },
+ showList = { _A_ 1 _U_ 12 _N_ _N_ _N_ _N_ } #-}
instance (Text a, Text b) => Text (a, b)
{-# GHC_PRAGMA _M_ PreludeBuiltin {-dfun-} _A_ 2 _U_ 22 _N_ _N_ _N_ _N_ #-}
instance Text (Int, Int)
{-# GHC_PRAGMA _M_ PreludeBuiltin {-dfun-} _A_ 0 _N_ _N_ _N_ _F_ _IF_ARGS_ 0 0 X 5 _!_ _TUP_4 [(Int -> [Char] -> [((Int, Int), [Char])]), (Int -> (Int, Int) -> [Char] -> [Char]), ([Char] -> [([(Int, Int)], [Char])]), ([(Int, Int)] -> [Char] -> [Char])] [_CONSTM_ Text readsPrec ((Int, Int)), _CONSTM_ Text showsPrec ((Int, Int)), _CONSTM_ Text readList ((Int, Int)), _CONSTM_ Text showList ((Int, Int))] _N_
- readsPrec = _A_ 1 _U_ 02 _N_ _S_ "A" {_A_ 0 _U_ 2 _N_ _N_ _N_ _N_} _N_ _N_,
- showsPrec = _A_ 3 _U_ 012 _N_ _S_ "AU(LL)L" {_A_ 3 _U_ 112 _N_ _N_ _N_ _N_} _N_ _N_,
- readList = _A_ 0 _U_ 2 _N_ _N_ _N_ _N_,
- showList = _A_ 0 _U_ 12 _N_ _N_ _N_ _N_ #-}
+ readsPrec = { _A_ 1 _U_ 02 _N_ _S_ "A" {_A_ 0 _U_ 2 _N_ _N_ _N_ _N_} _N_ _N_ },
+ showsPrec = { _A_ 3 _U_ 012 _N_ _S_ "AU(LL)L" {_A_ 3 _U_ 112 _N_ _N_ _N_ _N_} _N_ _N_ },
+ readList = { _A_ 0 _U_ 2 _N_ _N_ _N_ _N_ },
+ showList = { _A_ 1 _U_ 12 _N_ _N_ _N_ _N_ } #-}
instance Text (Integer, Integer)
{-# GHC_PRAGMA _M_ PreludeBuiltin {-dfun-} _A_ 0 _N_ _N_ _N_ _F_ _IF_ARGS_ 0 0 X 5 _!_ _TUP_4 [(Int -> [Char] -> [((Integer, Integer), [Char])]), (Int -> (Integer, Integer) -> [Char] -> [Char]), ([Char] -> [([(Integer, Integer)], [Char])]), ([(Integer, Integer)] -> [Char] -> [Char])] [_CONSTM_ Text readsPrec ((Integer, Integer)), _CONSTM_ Text showsPrec ((Integer, Integer)), _CONSTM_ Text readList ((Integer, Integer)), _CONSTM_ Text showList ((Integer, Integer))] _N_
- readsPrec = _A_ 1 _U_ 02 _N_ _S_ "A" {_A_ 0 _U_ 2 _N_ _N_ _N_ _N_} _N_ _N_,
- showsPrec = _A_ 3 _U_ 012 _N_ _S_ "AU(LL)L" {_A_ 3 _U_ 112 _N_ _N_ _N_ _N_} _N_ _N_,
- readList = _A_ 0 _U_ 2 _N_ _N_ _N_ _N_,
- showList = _A_ 0 _U_ 12 _N_ _N_ _N_ _N_ #-}
+ readsPrec = { _A_ 1 _U_ 02 _N_ _S_ "A" {_A_ 0 _U_ 2 _N_ _N_ _N_ _N_} _N_ _N_ },
+ showsPrec = { _A_ 3 _U_ 012 _N_ _S_ "AU(LL)L" {_A_ 3 _U_ 112 _N_ _N_ _N_ _N_} _N_ _N_ },
+ readList = { _A_ 0 _U_ 2 _N_ _N_ _N_ _N_ },
+ showList = { _A_ 1 _U_ 12 _N_ _N_ _N_ _N_ } #-}
-{-# GHC_PRAGMA INTERFACE VERSION 5 #-}
+{-# GHC_PRAGMA INTERFACE VERSION 6 #-}
interface PreludeBuiltin where
import PreludeCore(Eq(..), Ix(..), Ord(..), Text(..))
import PreludePS(_PackedString)
instance (Eq a, Eq b) => Eq (a, b)
- {-# GHC_PRAGMA _M_ PreludeBuiltin {-dfun-} _A_ 2 _U_ 11 _N_ _N_ _N_ _N_ #-}
+ {-# GHC_PRAGMA _M_ PreludeBuiltin {-dfun-} _A_ 2 _U_ 22 _N_ _N_ _N_ _N_ #-}
instance Eq (Int, Int)
{-# GHC_PRAGMA _M_ PreludeBuiltin {-dfun-} _A_ 0 _N_ _N_ _N_ _F_ _IF_ARGS_ 0 0 X 3 _!_ _TUP_2 [((Int, Int) -> (Int, Int) -> Bool), ((Int, Int) -> (Int, Int) -> Bool)] [_CONSTM_ Eq (==) ((Int, Int)), _CONSTM_ Eq (/=) ((Int, Int))] _N_
- (==) = _A_ 2 _U_ 11 _N_ _S_ "U(U(P)L)U(U(P)L)" {_A_ 4 _U_ 2121 _N_ _N_ _F_ _IF_ARGS_ 0 4 XCXC 7 \ (u0 :: Int#) (u1 :: Int) (u2 :: Int#) (u3 :: Int) -> case _#_ eqInt# [] [u0, u2] of { _ALG_ True -> case u1 of { _ALG_ I# (u4 :: Int#) -> case u3 of { _ALG_ I# (u5 :: Int#) -> _#_ eqInt# [] [u4, u5]; _NO_DEFLT_ }; _NO_DEFLT_ }; False -> _!_ False [] []; _NO_DEFLT_ } _N_} _F_ _ALWAYS_ \ (u0 :: (Int, Int)) (u1 :: (Int, Int)) -> case u0 of { _ALG_ _TUP_2 (u2 :: Int) (u3 :: Int) -> case u2 of { _ALG_ I# (u4 :: Int#) -> case u1 of { _ALG_ _TUP_2 (u5 :: Int) (u6 :: Int) -> case u5 of { _ALG_ I# (u7 :: Int#) -> case _#_ eqInt# [] [u4, u7] of { _ALG_ True -> case u3 of { _ALG_ I# (u8 :: Int#) -> case u6 of { _ALG_ I# (u9 :: Int#) -> _#_ eqInt# [] [u8, u9]; _NO_DEFLT_ }; _NO_DEFLT_ }; False -> _!_ False [] []; _NO_DEFLT_ }; _NO_DEFLT_ }; _NO_DEFLT_ }; _NO_DEFLT_ }; _NO_DEFLT_ } _N_,
- (/=) = _A_ 2 _U_ 22 _N_ _N_ _N_ _N_ #-}
+ (==) = { _A_ 2 _U_ 11 _N_ _S_ "U(U(P)L)U(U(P)L)" {_A_ 4 _U_ 2121 _N_ _N_ _F_ _IF_ARGS_ 0 4 XCXC 7 \ (u0 :: Int#) (u1 :: Int) (u2 :: Int#) (u3 :: Int) -> case _#_ eqInt# [] [u0, u2] of { _ALG_ True -> case u1 of { _ALG_ I# (u4 :: Int#) -> case u3 of { _ALG_ I# (u5 :: Int#) -> _#_ eqInt# [] [u4, u5]; _NO_DEFLT_ }; _NO_DEFLT_ }; False -> _!_ False [] []; _NO_DEFLT_ } _N_} _F_ _ALWAYS_ \ (u0 :: (Int, Int)) (u1 :: (Int, Int)) -> case u0 of { _ALG_ _TUP_2 (u2 :: Int) (u3 :: Int) -> case u2 of { _ALG_ I# (u4 :: Int#) -> case u1 of { _ALG_ _TUP_2 (u5 :: Int) (u6 :: Int) -> case u5 of { _ALG_ I# (u7 :: Int#) -> case _#_ eqInt# [] [u4, u7] of { _ALG_ True -> case u3 of { _ALG_ I# (u8 :: Int#) -> case u6 of { _ALG_ I# (u9 :: Int#) -> _#_ eqInt# [] [u8, u9]; _NO_DEFLT_ }; _NO_DEFLT_ }; False -> _!_ False [] []; _NO_DEFLT_ }; _NO_DEFLT_ }; _NO_DEFLT_ }; _NO_DEFLT_ }; _NO_DEFLT_ } _N_ },
+ (/=) = { _A_ 2 _U_ 11 _N_ _S_ "U(U(P)L)U(U(P)L)" {_A_ 4 _U_ 2121 _N_ _N_ _F_ _IF_ARGS_ 0 4 XCXC 7 \ (u0 :: Int#) (u1 :: Int) (u2 :: Int#) (u3 :: Int) -> case _#_ neInt# [] [u0, u2] of { _ALG_ True -> _!_ True [] []; False -> case u1 of { _ALG_ I# (u4 :: Int#) -> case u3 of { _ALG_ I# (u5 :: Int#) -> _#_ neInt# [] [u4, u5]; _NO_DEFLT_ }; _NO_DEFLT_ }; _NO_DEFLT_ } _N_} _F_ _ALWAYS_ \ (u0 :: (Int, Int)) (u1 :: (Int, Int)) -> case u0 of { _ALG_ _TUP_2 (u2 :: Int) (u3 :: Int) -> case u2 of { _ALG_ I# (u4 :: Int#) -> case u1 of { _ALG_ _TUP_2 (u5 :: Int) (u6 :: Int) -> case u5 of { _ALG_ I# (u7 :: Int#) -> case _#_ neInt# [] [u4, u7] of { _ALG_ True -> _!_ True [] []; False -> case u3 of { _ALG_ I# (u8 :: Int#) -> case u6 of { _ALG_ I# (u9 :: Int#) -> _#_ neInt# [] [u8, u9]; _NO_DEFLT_ }; _NO_DEFLT_ }; _NO_DEFLT_ }; _NO_DEFLT_ }; _NO_DEFLT_ }; _NO_DEFLT_ }; _NO_DEFLT_ } _N_ } #-}
+instance Eq ([Char], [Char])
+ {-# GHC_PRAGMA _M_ PreludeBuiltin {-dfun-} _A_ 0 _N_ _N_ _N_ _F_ _IF_ARGS_ 0 0 X 3 _!_ _TUP_2 [(([Char], [Char]) -> ([Char], [Char]) -> Bool), (([Char], [Char]) -> ([Char], [Char]) -> Bool)] [_CONSTM_ Eq (==) (([Char], [Char])), _CONSTM_ Eq (/=) (([Char], [Char]))] _N_
+ (==) = { _A_ 2 _U_ 11 _N_ _S_ "U(SL)U(SL)" {_A_ 4 _U_ 2222 _N_ _N_ _N_ _N_} _N_ _N_ },
+ (/=) = { _A_ 2 _U_ 11 _N_ _S_ "U(SL)U(SL)" {_A_ 4 _U_ 2222 _N_ _N_ _N_ _N_} _N_ _N_ } #-}
+instance Eq ([Int], [Int])
+ {-# GHC_PRAGMA _M_ PreludeBuiltin {-dfun-} _A_ 0 _N_ _N_ _N_ _F_ _IF_ARGS_ 0 0 X 3 _!_ _TUP_2 [(([Int], [Int]) -> ([Int], [Int]) -> Bool), (([Int], [Int]) -> ([Int], [Int]) -> Bool)] [_CONSTM_ Eq (==) (([Int], [Int])), _CONSTM_ Eq (/=) (([Int], [Int]))] _N_
+ (==) = { _A_ 2 _U_ 11 _N_ _S_ "U(SL)U(SL)" {_A_ 4 _U_ 2222 _N_ _N_ _N_ _N_} _N_ _N_ },
+ (/=) = { _A_ 2 _U_ 11 _N_ _S_ "U(SL)U(SL)" {_A_ 4 _U_ 2222 _N_ _N_ _N_ _N_} _N_ _N_ } #-}
instance Eq (_PackedString, _PackedString)
{-# GHC_PRAGMA _M_ PreludeBuiltin {-dfun-} _A_ 0 _N_ _N_ _N_ _F_ _IF_ARGS_ 0 0 X 3 _!_ _TUP_2 [((_PackedString, _PackedString) -> (_PackedString, _PackedString) -> Bool), ((_PackedString, _PackedString) -> (_PackedString, _PackedString) -> Bool)] [_CONSTM_ Eq (==) ((_PackedString, _PackedString)), _CONSTM_ Eq (/=) ((_PackedString, _PackedString))] _N_
- (==) = _A_ 2 _U_ 11 _N_ _S_ "U(SL)U(SL)" {_A_ 4 _U_ 2222 _N_ _N_ _N_ _N_} _N_ _N_,
- (/=) = _A_ 2 _U_ 22 _N_ _N_ _N_ _N_ #-}
+ (==) = { _A_ 2 _U_ 11 _N_ _S_ "U(SL)U(SL)" {_A_ 4 _U_ 2222 _N_ _N_ _N_ _N_} _N_ _N_ },
+ (/=) = { _A_ 2 _U_ 11 _N_ _S_ "U(SL)U(SL)" {_A_ 4 _U_ 2222 _N_ _N_ _N_ _N_} _N_ _N_ } #-}
instance (Ix a, Ix b) => Ix (a, b)
{-# GHC_PRAGMA _M_ PreludeBuiltin {-dfun-} _A_ 3 _U_ 222 _N_ _N_ _N_ _N_ #-}
instance Ix (Int, Int)
{-# GHC_PRAGMA _M_ PreludeBuiltin {-dfun-} _A_ 0 _N_ _N_ _N_ _F_ _IF_ARGS_ 0 0 X 5 _!_ _TUP_4 [{{Ord (Int, Int)}}, (((Int, Int), (Int, Int)) -> [(Int, Int)]), (((Int, Int), (Int, Int)) -> (Int, Int) -> Int), (((Int, Int), (Int, Int)) -> (Int, Int) -> Bool)] [_DFUN_ Ord ((Int, Int)), _CONSTM_ Ix range ((Int, Int)), _CONSTM_ Ix index ((Int, Int)), _CONSTM_ Ix inRange ((Int, Int))] _N_
- range = _A_ 1 _U_ 1 _N_ _S_ "U(SS)" {_A_ 2 _U_ 11 _N_ _N_ _N_ _N_} _N_ _N_,
- index = _A_ 2 _U_ 11 _N_ _S_ "U(SS)U(U(P)U(P))" {_A_ 4 _U_ 1122 _N_ _N_ _N_ _N_} _N_ _N_,
- inRange = _A_ 2 _U_ 11 _N_ _S_ "U(SS)U(U(P)L)" {_A_ 4 _U_ 1121 _N_ _N_ _N_ _N_} _N_ _N_ #-}
+ range = { _A_ 1 _U_ 1 _N_ _S_ "U(SS)" {_A_ 2 _U_ 11 _N_ _N_ _N_ _N_} _N_ _N_ },
+ index = { _A_ 2 _U_ 11 _N_ _S_ "U(SS)U(U(P)U(P))" {_A_ 4 _U_ 1122 _N_ _N_ _N_ _N_} _N_ _N_ },
+ inRange = { _A_ 2 _U_ 11 _N_ _S_ "U(SS)U(U(P)L)" {_A_ 4 _U_ 1121 _N_ _N_ _N_ _N_} _N_ _N_ } #-}
instance (Ord a, Ord b) => Ord (a, b)
{-# GHC_PRAGMA _M_ PreludeBuiltin {-dfun-} _A_ 3 _U_ 112 _N_ _N_ _N_ _N_ #-}
instance Ord (Int, Int)
{-# GHC_PRAGMA _M_ PreludeBuiltin {-dfun-} _A_ 0 _N_ _N_ _N_ _F_ _IF_ARGS_ 0 0 X 9 _!_ _TUP_8 [{{Eq (Int, Int)}}, ((Int, Int) -> (Int, Int) -> Bool), ((Int, Int) -> (Int, Int) -> Bool), ((Int, Int) -> (Int, Int) -> Bool), ((Int, Int) -> (Int, Int) -> Bool), ((Int, Int) -> (Int, Int) -> (Int, Int)), ((Int, Int) -> (Int, Int) -> (Int, Int)), ((Int, Int) -> (Int, Int) -> _CMP_TAG)] [_DFUN_ Eq ((Int, Int)), _CONSTM_ Ord (<) ((Int, Int)), _CONSTM_ Ord (<=) ((Int, Int)), _CONSTM_ Ord (>=) ((Int, Int)), _CONSTM_ Ord (>) ((Int, Int)), _CONSTM_ Ord max ((Int, Int)), _CONSTM_ Ord min ((Int, Int)), _CONSTM_ Ord _tagCmp ((Int, Int))] _N_
- (<) = _A_ 2 _U_ 11 _N_ _S_ "U(U(P)L)U(U(P)L)" {_A_ 4 _U_ 2121 _N_ _N_ _N_ _N_} _N_ _N_,
- (<=) = _A_ 2 _U_ 11 _N_ _S_ "U(U(P)L)U(U(P)L)" {_A_ 4 _U_ 2121 _N_ _N_ _N_ _N_} _N_ _N_,
- (>=) = _A_ 2 _U_ 11 _N_ _S_ "U(U(P)L)U(U(P)L)" {_A_ 4 _U_ 2121 _N_ _N_ _N_ _N_} _N_ _N_,
- (>) = _A_ 2 _U_ 11 _N_ _S_ "U(U(P)L)U(U(P)L)" {_A_ 4 _U_ 2121 _N_ _N_ _N_ _N_} _N_ _N_,
- max = _A_ 2 _U_ 11 _N_ _S_ "U(U(P)L)U(U(P)L)" {_A_ 4 _U_ 2222 _N_ _N_ _N_ _N_} _N_ _N_,
- min = _A_ 2 _U_ 11 _N_ _S_ "U(U(P)L)U(U(P)L)" {_A_ 4 _U_ 2222 _N_ _N_ _N_ _N_} _N_ _N_,
- _tagCmp = _A_ 2 _U_ 11 _N_ _S_ "U(U(P)L)U(U(P)L)" {_A_ 4 _U_ 2121 _N_ _N_ _N_ _N_} _N_ _N_ #-}
+ (<) = { _A_ 2 _U_ 11 _N_ _S_ "U(U(P)L)U(U(P)L)" {_A_ 4 _U_ 2121 _N_ _N_ _N_ _N_} _N_ _N_ },
+ (<=) = { _A_ 2 _U_ 11 _N_ _S_ "U(U(P)L)U(U(P)L)" {_A_ 4 _U_ 2121 _N_ _N_ _N_ _N_} _N_ _N_ },
+ (>=) = { _A_ 2 _U_ 11 _N_ _S_ "U(U(P)L)U(U(P)L)" {_A_ 4 _U_ 2121 _N_ _N_ _N_ _N_} _N_ _N_ },
+ (>) = { _A_ 2 _U_ 11 _N_ _S_ "U(U(P)L)U(U(P)L)" {_A_ 4 _U_ 2121 _N_ _N_ _N_ _N_} _N_ _N_ },
+ max = { _A_ 2 _U_ 11 _N_ _S_ "U(U(P)L)U(U(P)L)" {_A_ 4 _U_ 2222 _N_ _N_ _N_ _N_} _N_ _N_ },
+ min = { _A_ 2 _U_ 11 _N_ _S_ "U(U(P)L)U(U(P)L)" {_A_ 4 _U_ 2222 _N_ _N_ _N_ _N_} _N_ _N_ },
+ _tagCmp = { _A_ 2 _U_ 11 _N_ _S_ "U(U(P)L)U(U(P)L)" {_A_ 4 _U_ 2121 _N_ _N_ _N_ _N_} _N_ _N_ } #-}
+instance Ord ([Char], [Char])
+ {-# GHC_PRAGMA _M_ PreludeBuiltin {-dfun-} _A_ 0 _N_ _N_ _N_ _F_ _IF_ARGS_ 0 0 X 9 _!_ _TUP_8 [{{Eq ([Char], [Char])}}, (([Char], [Char]) -> ([Char], [Char]) -> Bool), (([Char], [Char]) -> ([Char], [Char]) -> Bool), (([Char], [Char]) -> ([Char], [Char]) -> Bool), (([Char], [Char]) -> ([Char], [Char]) -> Bool), (([Char], [Char]) -> ([Char], [Char]) -> ([Char], [Char])), (([Char], [Char]) -> ([Char], [Char]) -> ([Char], [Char])), (([Char], [Char]) -> ([Char], [Char]) -> _CMP_TAG)] [_DFUN_ Eq (([Char], [Char])), _CONSTM_ Ord (<) (([Char], [Char])), _CONSTM_ Ord (<=) (([Char], [Char])), _CONSTM_ Ord (>=) (([Char], [Char])), _CONSTM_ Ord (>) (([Char], [Char])), _CONSTM_ Ord max (([Char], [Char])), _CONSTM_ Ord min (([Char], [Char])), _CONSTM_ Ord _tagCmp (([Char], [Char]))] _N_
+ (<) = { _A_ 2 _U_ 11 _N_ _S_ "U(SL)U(SL)" {_A_ 4 _U_ 2222 _N_ _N_ _N_ _N_} _N_ _N_ },
+ (<=) = { _A_ 2 _U_ 11 _N_ _S_ "U(SL)U(SL)" {_A_ 4 _U_ 2222 _N_ _N_ _N_ _N_} _N_ _N_ },
+ (>=) = { _A_ 2 _U_ 11 _N_ _S_ "U(SL)U(SL)" {_A_ 4 _U_ 2222 _N_ _N_ _N_ _N_} _N_ _N_ },
+ (>) = { _A_ 2 _U_ 11 _N_ _S_ "U(SL)U(SL)" {_A_ 4 _U_ 2222 _N_ _N_ _N_ _N_} _N_ _N_ },
+ max = { _A_ 2 _U_ 11 _N_ _S_ "U(SL)U(SL)" {_A_ 4 _U_ 2222 _N_ _N_ _N_ _N_} _N_ _N_ },
+ min = { _A_ 2 _U_ 11 _N_ _S_ "U(SL)U(SL)" {_A_ 4 _U_ 2222 _N_ _N_ _N_ _N_} _N_ _N_ },
+ _tagCmp = { _A_ 2 _U_ 11 _N_ _S_ "U(SL)U(SL)" {_A_ 4 _U_ 2222 _N_ _N_ _N_ _N_} _N_ _N_ } #-}
+instance Ord ([Int], [Int])
+ {-# GHC_PRAGMA _M_ PreludeBuiltin {-dfun-} _A_ 0 _N_ _N_ _N_ _F_ _IF_ARGS_ 0 0 X 9 _!_ _TUP_8 [{{Eq ([Int], [Int])}}, (([Int], [Int]) -> ([Int], [Int]) -> Bool), (([Int], [Int]) -> ([Int], [Int]) -> Bool), (([Int], [Int]) -> ([Int], [Int]) -> Bool), (([Int], [Int]) -> ([Int], [Int]) -> Bool), (([Int], [Int]) -> ([Int], [Int]) -> ([Int], [Int])), (([Int], [Int]) -> ([Int], [Int]) -> ([Int], [Int])), (([Int], [Int]) -> ([Int], [Int]) -> _CMP_TAG)] [_DFUN_ Eq (([Int], [Int])), _CONSTM_ Ord (<) (([Int], [Int])), _CONSTM_ Ord (<=) (([Int], [Int])), _CONSTM_ Ord (>=) (([Int], [Int])), _CONSTM_ Ord (>) (([Int], [Int])), _CONSTM_ Ord max (([Int], [Int])), _CONSTM_ Ord min (([Int], [Int])), _CONSTM_ Ord _tagCmp (([Int], [Int]))] _N_
+ (<) = { _A_ 2 _U_ 11 _N_ _S_ "U(SL)U(SL)" {_A_ 4 _U_ 2222 _N_ _N_ _N_ _N_} _N_ _N_ },
+ (<=) = { _A_ 2 _U_ 11 _N_ _S_ "U(SL)U(SL)" {_A_ 4 _U_ 2222 _N_ _N_ _N_ _N_} _N_ _N_ },
+ (>=) = { _A_ 2 _U_ 11 _N_ _S_ "U(SL)U(SL)" {_A_ 4 _U_ 2222 _N_ _N_ _N_ _N_} _N_ _N_ },
+ (>) = { _A_ 2 _U_ 11 _N_ _S_ "U(SL)U(SL)" {_A_ 4 _U_ 2222 _N_ _N_ _N_ _N_} _N_ _N_ },
+ max = { _A_ 2 _U_ 11 _N_ _S_ "U(SL)U(SL)" {_A_ 4 _U_ 2222 _N_ _N_ _N_ _N_} _N_ _N_ },
+ min = { _A_ 2 _U_ 11 _N_ _S_ "U(SL)U(SL)" {_A_ 4 _U_ 2222 _N_ _N_ _N_ _N_} _N_ _N_ },
+ _tagCmp = { _A_ 2 _U_ 11 _N_ _S_ "U(SL)U(SL)" {_A_ 4 _U_ 2222 _N_ _N_ _N_ _N_} _N_ _N_ } #-}
instance Ord (_PackedString, _PackedString)
{-# GHC_PRAGMA _M_ PreludeBuiltin {-dfun-} _A_ 0 _N_ _N_ _N_ _F_ _IF_ARGS_ 0 0 X 9 _!_ _TUP_8 [{{Eq (_PackedString, _PackedString)}}, ((_PackedString, _PackedString) -> (_PackedString, _PackedString) -> Bool), ((_PackedString, _PackedString) -> (_PackedString, _PackedString) -> Bool), ((_PackedString, _PackedString) -> (_PackedString, _PackedString) -> Bool), ((_PackedString, _PackedString) -> (_PackedString, _PackedString) -> Bool), ((_PackedString, _PackedString) -> (_PackedString, _PackedString) -> (_PackedString, _PackedString)), ((_PackedString, _PackedString) -> (_PackedString, _PackedString) -> (_PackedString, _PackedString)), ((_PackedString, _PackedString) -> (_PackedString, _PackedString) -> _CMP_TAG)] [_DFUN_ Eq ((_PackedString, _PackedString)), _CONSTM_ Ord (<) ((_PackedString, _PackedString)), _CONSTM_ Ord (<=) ((_PackedString, _PackedString)), _CONSTM_ Ord (>=) ((_PackedString, _PackedString)), _CONSTM_ Ord (>) ((_PackedString, _PackedString)), _CONSTM_ Ord max ((_PackedString, _PackedString)), _CONSTM_ Ord min ((_PackedString, _PackedString)), _CONSTM_ Ord _tagCmp ((_PackedString, _PackedString))] _N_
- (<) = _A_ 2 _U_ 11 _N_ _S_ "U(SL)U(SL)" {_A_ 4 _U_ 2222 _N_ _N_ _N_ _N_} _N_ _N_,
- (<=) = _A_ 2 _U_ 11 _N_ _S_ "U(SL)U(SL)" {_A_ 4 _U_ 2222 _N_ _N_ _N_ _N_} _N_ _N_,
- (>=) = _A_ 2 _U_ 11 _N_ _S_ "U(SL)U(SL)" {_A_ 4 _U_ 2222 _N_ _N_ _N_ _N_} _N_ _N_,
- (>) = _A_ 2 _U_ 11 _N_ _S_ "U(SL)U(SL)" {_A_ 4 _U_ 2222 _N_ _N_ _N_ _N_} _N_ _N_,
- max = _A_ 2 _U_ 11 _N_ _S_ "U(SL)U(SL)" {_A_ 4 _U_ 2222 _N_ _N_ _N_ _N_} _N_ _N_,
- min = _A_ 2 _U_ 11 _N_ _S_ "U(SL)U(SL)" {_A_ 4 _U_ 2222 _N_ _N_ _N_ _N_} _N_ _N_,
- _tagCmp = _A_ 2 _U_ 11 _N_ _S_ "U(SL)U(SL)" {_A_ 4 _U_ 2222 _N_ _N_ _N_ _N_} _N_ _N_ #-}
+ (<) = { _A_ 2 _U_ 11 _N_ _S_ "U(SL)U(SL)" {_A_ 4 _U_ 2222 _N_ _N_ _N_ _N_} _N_ _N_ },
+ (<=) = { _A_ 2 _U_ 11 _N_ _S_ "U(SL)U(SL)" {_A_ 4 _U_ 2222 _N_ _N_ _N_ _N_} _N_ _N_ },
+ (>=) = { _A_ 2 _U_ 11 _N_ _S_ "U(SL)U(SL)" {_A_ 4 _U_ 2222 _N_ _N_ _N_ _N_} _N_ _N_ },
+ (>) = { _A_ 2 _U_ 11 _N_ _S_ "U(SL)U(SL)" {_A_ 4 _U_ 2222 _N_ _N_ _N_ _N_} _N_ _N_ },
+ max = { _A_ 2 _U_ 11 _N_ _S_ "U(SL)U(SL)" {_A_ 4 _U_ 2222 _N_ _N_ _N_ _N_} _N_ _N_ },
+ min = { _A_ 2 _U_ 11 _N_ _S_ "U(SL)U(SL)" {_A_ 4 _U_ 2222 _N_ _N_ _N_ _N_} _N_ _N_ },
+ _tagCmp = { _A_ 2 _U_ 11 _N_ _S_ "U(SL)U(SL)" {_A_ 4 _U_ 2222 _N_ _N_ _N_ _N_} _N_ _N_ } #-}
+instance Text ((Int, Int), (Int, Int))
+ {-# GHC_PRAGMA _M_ PreludeBuiltin {-dfun-} _A_ 0 _N_ _N_ _N_ _F_ _IF_ARGS_ 0 0 X 5 _!_ _TUP_4 [(Int -> [Char] -> [(((Int, Int), (Int, Int)), [Char])]), (Int -> ((Int, Int), (Int, Int)) -> [Char] -> [Char]), ([Char] -> [([((Int, Int), (Int, Int))], [Char])]), ([((Int, Int), (Int, Int))] -> [Char] -> [Char])] [_CONSTM_ Text readsPrec (((Int, Int), (Int, Int))), _CONSTM_ Text showsPrec (((Int, Int), (Int, Int))), _CONSTM_ Text readList (((Int, Int), (Int, Int))), _CONSTM_ Text showList (((Int, Int), (Int, Int)))] _N_
+ readsPrec = { _A_ 1 _U_ 02 _N_ _S_ "A" {_A_ 0 _U_ 2 _N_ _N_ _N_ _N_} _N_ _N_ },
+ showsPrec = { _A_ 3 _U_ 012 _N_ _S_ "AU(LL)L" {_A_ 3 _U_ 112 _N_ _N_ _N_ _N_} _N_ _N_ },
+ readList = { _A_ 0 _U_ 2 _N_ _N_ _N_ _N_ },
+ showList = { _A_ 1 _U_ 12 _N_ _N_ _N_ _N_ } #-}
instance (Text a, Text b) => Text (a, b)
{-# GHC_PRAGMA _M_ PreludeBuiltin {-dfun-} _A_ 2 _U_ 22 _N_ _N_ _N_ _N_ #-}
instance Text (Int, Int)
{-# GHC_PRAGMA _M_ PreludeBuiltin {-dfun-} _A_ 0 _N_ _N_ _N_ _F_ _IF_ARGS_ 0 0 X 5 _!_ _TUP_4 [(Int -> [Char] -> [((Int, Int), [Char])]), (Int -> (Int, Int) -> [Char] -> [Char]), ([Char] -> [([(Int, Int)], [Char])]), ([(Int, Int)] -> [Char] -> [Char])] [_CONSTM_ Text readsPrec ((Int, Int)), _CONSTM_ Text showsPrec ((Int, Int)), _CONSTM_ Text readList ((Int, Int)), _CONSTM_ Text showList ((Int, Int))] _N_
- readsPrec = _A_ 1 _U_ 02 _N_ _S_ "A" {_A_ 0 _U_ 2 _N_ _N_ _N_ _N_} _N_ _N_,
- showsPrec = _A_ 3 _U_ 012 _N_ _S_ "AU(LL)L" {_A_ 3 _U_ 112 _N_ _N_ _N_ _N_} _N_ _N_,
- readList = _A_ 0 _U_ 2 _N_ _N_ _N_ _N_,
- showList = _A_ 0 _U_ 12 _N_ _N_ _N_ _N_ #-}
+ readsPrec = { _A_ 1 _U_ 02 _N_ _S_ "A" {_A_ 0 _U_ 2 _N_ _N_ _N_ _N_} _N_ _N_ },
+ showsPrec = { _A_ 3 _U_ 012 _N_ _S_ "AU(LL)L" {_A_ 3 _U_ 112 _N_ _N_ _N_ _N_} _N_ _N_ },
+ readList = { _A_ 0 _U_ 2 _N_ _N_ _N_ _N_ },
+ showList = { _A_ 1 _U_ 12 _N_ _N_ _N_ _N_ } #-}
instance Text (Integer, Integer)
{-# GHC_PRAGMA _M_ PreludeBuiltin {-dfun-} _A_ 0 _N_ _N_ _N_ _F_ _IF_ARGS_ 0 0 X 5 _!_ _TUP_4 [(Int -> [Char] -> [((Integer, Integer), [Char])]), (Int -> (Integer, Integer) -> [Char] -> [Char]), ([Char] -> [([(Integer, Integer)], [Char])]), ([(Integer, Integer)] -> [Char] -> [Char])] [_CONSTM_ Text readsPrec ((Integer, Integer)), _CONSTM_ Text showsPrec ((Integer, Integer)), _CONSTM_ Text readList ((Integer, Integer)), _CONSTM_ Text showList ((Integer, Integer))] _N_
- readsPrec = _A_ 1 _U_ 02 _N_ _S_ "A" {_A_ 0 _U_ 2 _N_ _N_ _N_ _N_} _N_ _N_,
- showsPrec = _A_ 3 _U_ 012 _N_ _S_ "AU(LL)L" {_A_ 3 _U_ 112 _N_ _N_ _N_ _N_} _N_ _N_,
- readList = _A_ 0 _U_ 2 _N_ _N_ _N_ _N_,
- showList = _A_ 0 _U_ 12 _N_ _N_ _N_ _N_ #-}
+ readsPrec = { _A_ 1 _U_ 02 _N_ _S_ "A" {_A_ 0 _U_ 2 _N_ _N_ _N_ _N_} _N_ _N_ },
+ showsPrec = { _A_ 3 _U_ 012 _N_ _S_ "AU(LL)L" {_A_ 3 _U_ 112 _N_ _N_ _N_ _N_} _N_ _N_ },
+ readList = { _A_ 0 _U_ 2 _N_ _N_ _N_ _N_ },
+ showList = { _A_ 1 _U_ 12 _N_ _N_ _N_ _N_ } #-}
-{-# GHC_PRAGMA INTERFACE VERSION 5 #-}
+{-# GHC_PRAGMA INTERFACE VERSION 6 #-}
interface PreludeBuiltin where
import PreludeCore(Eq(..), Ix(..), Ord(..), Text(..))
import PreludePS(_PackedString)
instance (Eq a, Eq b) => Eq (a, b)
- {-# GHC_PRAGMA _M_ PreludeBuiltin {-dfun-} _A_ 2 _U_ 11 _N_ _N_ _N_ _N_ #-}
+ {-# GHC_PRAGMA _M_ PreludeBuiltin {-dfun-} _A_ 2 _U_ 22 _N_ _N_ _N_ _N_ #-}
instance Eq (Int, Int)
{-# GHC_PRAGMA _M_ PreludeBuiltin {-dfun-} _A_ 0 _N_ _N_ _N_ _F_ _IF_ARGS_ 0 0 X 3 _!_ _TUP_2 [((Int, Int) -> (Int, Int) -> Bool), ((Int, Int) -> (Int, Int) -> Bool)] [_CONSTM_ Eq (==) ((Int, Int)), _CONSTM_ Eq (/=) ((Int, Int))] _N_
- (==) = _A_ 2 _U_ 11 _N_ _S_ "U(U(P)L)U(U(P)L)" {_A_ 4 _U_ 2121 _N_ _N_ _F_ _IF_ARGS_ 0 4 XCXC 7 \ (u0 :: Int#) (u1 :: Int) (u2 :: Int#) (u3 :: Int) -> case _#_ eqInt# [] [u0, u2] of { _ALG_ True -> case u1 of { _ALG_ I# (u4 :: Int#) -> case u3 of { _ALG_ I# (u5 :: Int#) -> _#_ eqInt# [] [u4, u5]; _NO_DEFLT_ }; _NO_DEFLT_ }; False -> _!_ False [] []; _NO_DEFLT_ } _N_} _F_ _ALWAYS_ \ (u0 :: (Int, Int)) (u1 :: (Int, Int)) -> case u0 of { _ALG_ _TUP_2 (u2 :: Int) (u3 :: Int) -> case u2 of { _ALG_ I# (u4 :: Int#) -> case u1 of { _ALG_ _TUP_2 (u5 :: Int) (u6 :: Int) -> case u5 of { _ALG_ I# (u7 :: Int#) -> case _#_ eqInt# [] [u4, u7] of { _ALG_ True -> case u3 of { _ALG_ I# (u8 :: Int#) -> case u6 of { _ALG_ I# (u9 :: Int#) -> _#_ eqInt# [] [u8, u9]; _NO_DEFLT_ }; _NO_DEFLT_ }; False -> _!_ False [] []; _NO_DEFLT_ }; _NO_DEFLT_ }; _NO_DEFLT_ }; _NO_DEFLT_ }; _NO_DEFLT_ } _N_,
- (/=) = _A_ 2 _U_ 22 _N_ _N_ _N_ _N_ #-}
+ (==) = { _A_ 2 _U_ 11 _N_ _S_ "U(U(P)L)U(U(P)L)" {_A_ 4 _U_ 2121 _N_ _N_ _F_ _IF_ARGS_ 0 4 XCXC 7 \ (u0 :: Int#) (u1 :: Int) (u2 :: Int#) (u3 :: Int) -> case _#_ eqInt# [] [u0, u2] of { _ALG_ True -> case u1 of { _ALG_ I# (u4 :: Int#) -> case u3 of { _ALG_ I# (u5 :: Int#) -> _#_ eqInt# [] [u4, u5]; _NO_DEFLT_ }; _NO_DEFLT_ }; False -> _!_ False [] []; _NO_DEFLT_ } _N_} _F_ _ALWAYS_ \ (u0 :: (Int, Int)) (u1 :: (Int, Int)) -> case u0 of { _ALG_ _TUP_2 (u2 :: Int) (u3 :: Int) -> case u2 of { _ALG_ I# (u4 :: Int#) -> case u1 of { _ALG_ _TUP_2 (u5 :: Int) (u6 :: Int) -> case u5 of { _ALG_ I# (u7 :: Int#) -> case _#_ eqInt# [] [u4, u7] of { _ALG_ True -> case u3 of { _ALG_ I# (u8 :: Int#) -> case u6 of { _ALG_ I# (u9 :: Int#) -> _#_ eqInt# [] [u8, u9]; _NO_DEFLT_ }; _NO_DEFLT_ }; False -> _!_ False [] []; _NO_DEFLT_ }; _NO_DEFLT_ }; _NO_DEFLT_ }; _NO_DEFLT_ }; _NO_DEFLT_ } _N_ },
+ (/=) = { _A_ 2 _U_ 11 _N_ _S_ "U(U(P)L)U(U(P)L)" {_A_ 4 _U_ 2121 _N_ _N_ _F_ _IF_ARGS_ 0 4 XCXC 7 \ (u0 :: Int#) (u1 :: Int) (u2 :: Int#) (u3 :: Int) -> case _#_ neInt# [] [u0, u2] of { _ALG_ True -> _!_ True [] []; False -> case u1 of { _ALG_ I# (u4 :: Int#) -> case u3 of { _ALG_ I# (u5 :: Int#) -> _#_ neInt# [] [u4, u5]; _NO_DEFLT_ }; _NO_DEFLT_ }; _NO_DEFLT_ } _N_} _F_ _ALWAYS_ \ (u0 :: (Int, Int)) (u1 :: (Int, Int)) -> case u0 of { _ALG_ _TUP_2 (u2 :: Int) (u3 :: Int) -> case u2 of { _ALG_ I# (u4 :: Int#) -> case u1 of { _ALG_ _TUP_2 (u5 :: Int) (u6 :: Int) -> case u5 of { _ALG_ I# (u7 :: Int#) -> case _#_ neInt# [] [u4, u7] of { _ALG_ True -> _!_ True [] []; False -> case u3 of { _ALG_ I# (u8 :: Int#) -> case u6 of { _ALG_ I# (u9 :: Int#) -> _#_ neInt# [] [u8, u9]; _NO_DEFLT_ }; _NO_DEFLT_ }; _NO_DEFLT_ }; _NO_DEFLT_ }; _NO_DEFLT_ }; _NO_DEFLT_ }; _NO_DEFLT_ } _N_ } #-}
+instance Eq ([Char], [Char])
+ {-# GHC_PRAGMA _M_ PreludeBuiltin {-dfun-} _A_ 0 _N_ _N_ _N_ _F_ _IF_ARGS_ 0 0 X 3 _!_ _TUP_2 [(([Char], [Char]) -> ([Char], [Char]) -> Bool), (([Char], [Char]) -> ([Char], [Char]) -> Bool)] [_CONSTM_ Eq (==) (([Char], [Char])), _CONSTM_ Eq (/=) (([Char], [Char]))] _N_
+ (==) = { _A_ 2 _U_ 11 _N_ _S_ "U(SL)U(SL)" {_A_ 4 _U_ 2222 _N_ _N_ _N_ _N_} _N_ _N_ },
+ (/=) = { _A_ 2 _U_ 11 _N_ _S_ "U(SL)U(SL)" {_A_ 4 _U_ 2222 _N_ _N_ _N_ _N_} _N_ _N_ } #-}
+instance Eq ([Int], [Int])
+ {-# GHC_PRAGMA _M_ PreludeBuiltin {-dfun-} _A_ 0 _N_ _N_ _N_ _F_ _IF_ARGS_ 0 0 X 3 _!_ _TUP_2 [(([Int], [Int]) -> ([Int], [Int]) -> Bool), (([Int], [Int]) -> ([Int], [Int]) -> Bool)] [_CONSTM_ Eq (==) (([Int], [Int])), _CONSTM_ Eq (/=) (([Int], [Int]))] _N_
+ (==) = { _A_ 2 _U_ 11 _N_ _S_ "U(SL)U(SL)" {_A_ 4 _U_ 2222 _N_ _N_ _N_ _N_} _N_ _N_ },
+ (/=) = { _A_ 2 _U_ 11 _N_ _S_ "U(SL)U(SL)" {_A_ 4 _U_ 2222 _N_ _N_ _N_ _N_} _N_ _N_ } #-}
instance Eq (_PackedString, _PackedString)
{-# GHC_PRAGMA _M_ PreludeBuiltin {-dfun-} _A_ 0 _N_ _N_ _N_ _F_ _IF_ARGS_ 0 0 X 3 _!_ _TUP_2 [((_PackedString, _PackedString) -> (_PackedString, _PackedString) -> Bool), ((_PackedString, _PackedString) -> (_PackedString, _PackedString) -> Bool)] [_CONSTM_ Eq (==) ((_PackedString, _PackedString)), _CONSTM_ Eq (/=) ((_PackedString, _PackedString))] _N_
- (==) = _A_ 2 _U_ 11 _N_ _S_ "U(SL)U(SL)" {_A_ 4 _U_ 2222 _N_ _N_ _N_ _N_} _N_ _N_,
- (/=) = _A_ 2 _U_ 22 _N_ _N_ _N_ _N_ #-}
+ (==) = { _A_ 2 _U_ 11 _N_ _S_ "U(SL)U(SL)" {_A_ 4 _U_ 2222 _N_ _N_ _N_ _N_} _N_ _N_ },
+ (/=) = { _A_ 2 _U_ 11 _N_ _S_ "U(SL)U(SL)" {_A_ 4 _U_ 2222 _N_ _N_ _N_ _N_} _N_ _N_ } #-}
instance (Ix a, Ix b) => Ix (a, b)
{-# GHC_PRAGMA _M_ PreludeBuiltin {-dfun-} _A_ 3 _U_ 222 _N_ _N_ _N_ _N_ #-}
instance Ix (Int, Int)
{-# GHC_PRAGMA _M_ PreludeBuiltin {-dfun-} _A_ 0 _N_ _N_ _N_ _F_ _IF_ARGS_ 0 0 X 5 _!_ _TUP_4 [{{Ord (Int, Int)}}, (((Int, Int), (Int, Int)) -> [(Int, Int)]), (((Int, Int), (Int, Int)) -> (Int, Int) -> Int), (((Int, Int), (Int, Int)) -> (Int, Int) -> Bool)] [_DFUN_ Ord ((Int, Int)), _CONSTM_ Ix range ((Int, Int)), _CONSTM_ Ix index ((Int, Int)), _CONSTM_ Ix inRange ((Int, Int))] _N_
- range = _A_ 1 _U_ 1 _N_ _S_ "U(SS)" {_A_ 2 _U_ 11 _N_ _N_ _N_ _N_} _N_ _N_,
- index = _A_ 2 _U_ 11 _N_ _S_ "U(SS)U(U(P)U(P))" {_A_ 4 _U_ 1122 _N_ _N_ _N_ _N_} _N_ _N_,
- inRange = _A_ 2 _U_ 11 _N_ _S_ "U(SS)U(U(P)L)" {_A_ 4 _U_ 1121 _N_ _N_ _N_ _N_} _N_ _N_ #-}
+ range = { _A_ 1 _U_ 1 _N_ _S_ "U(SS)" {_A_ 2 _U_ 11 _N_ _N_ _N_ _N_} _N_ _N_ },
+ index = { _A_ 2 _U_ 11 _N_ _S_ "U(SS)U(U(P)U(P))" {_A_ 4 _U_ 1122 _N_ _N_ _N_ _N_} _N_ _N_ },
+ inRange = { _A_ 2 _U_ 11 _N_ _S_ "U(SS)U(U(P)L)" {_A_ 4 _U_ 1121 _N_ _N_ _N_ _N_} _N_ _N_ } #-}
instance (Ord a, Ord b) => Ord (a, b)
{-# GHC_PRAGMA _M_ PreludeBuiltin {-dfun-} _A_ 3 _U_ 112 _N_ _N_ _N_ _N_ #-}
instance Ord (Int, Int)
{-# GHC_PRAGMA _M_ PreludeBuiltin {-dfun-} _A_ 0 _N_ _N_ _N_ _F_ _IF_ARGS_ 0 0 X 9 _!_ _TUP_8 [{{Eq (Int, Int)}}, ((Int, Int) -> (Int, Int) -> Bool), ((Int, Int) -> (Int, Int) -> Bool), ((Int, Int) -> (Int, Int) -> Bool), ((Int, Int) -> (Int, Int) -> Bool), ((Int, Int) -> (Int, Int) -> (Int, Int)), ((Int, Int) -> (Int, Int) -> (Int, Int)), ((Int, Int) -> (Int, Int) -> _CMP_TAG)] [_DFUN_ Eq ((Int, Int)), _CONSTM_ Ord (<) ((Int, Int)), _CONSTM_ Ord (<=) ((Int, Int)), _CONSTM_ Ord (>=) ((Int, Int)), _CONSTM_ Ord (>) ((Int, Int)), _CONSTM_ Ord max ((Int, Int)), _CONSTM_ Ord min ((Int, Int)), _CONSTM_ Ord _tagCmp ((Int, Int))] _N_
- (<) = _A_ 2 _U_ 11 _N_ _S_ "U(U(P)L)U(U(P)L)" {_A_ 4 _U_ 2121 _N_ _N_ _N_ _N_} _N_ _N_,
- (<=) = _A_ 2 _U_ 11 _N_ _S_ "U(U(P)L)U(U(P)L)" {_A_ 4 _U_ 2121 _N_ _N_ _N_ _N_} _N_ _N_,
- (>=) = _A_ 2 _U_ 11 _N_ _S_ "U(U(P)L)U(U(P)L)" {_A_ 4 _U_ 2121 _N_ _N_ _N_ _N_} _N_ _N_,
- (>) = _A_ 2 _U_ 11 _N_ _S_ "U(U(P)L)U(U(P)L)" {_A_ 4 _U_ 2121 _N_ _N_ _N_ _N_} _N_ _N_,
- max = _A_ 2 _U_ 11 _N_ _S_ "U(U(P)L)U(U(P)L)" {_A_ 4 _U_ 2222 _N_ _N_ _N_ _N_} _N_ _N_,
- min = _A_ 2 _U_ 11 _N_ _S_ "U(U(P)L)U(U(P)L)" {_A_ 4 _U_ 2222 _N_ _N_ _N_ _N_} _N_ _N_,
- _tagCmp = _A_ 2 _U_ 11 _N_ _S_ "U(U(P)L)U(U(P)L)" {_A_ 4 _U_ 2121 _N_ _N_ _N_ _N_} _N_ _N_ #-}
+ (<) = { _A_ 2 _U_ 11 _N_ _S_ "U(U(P)L)U(U(P)L)" {_A_ 4 _U_ 2121 _N_ _N_ _N_ _N_} _N_ _N_ },
+ (<=) = { _A_ 2 _U_ 11 _N_ _S_ "U(U(P)L)U(U(P)L)" {_A_ 4 _U_ 2121 _N_ _N_ _N_ _N_} _N_ _N_ },
+ (>=) = { _A_ 2 _U_ 11 _N_ _S_ "U(U(P)L)U(U(P)L)" {_A_ 4 _U_ 2121 _N_ _N_ _N_ _N_} _N_ _N_ },
+ (>) = { _A_ 2 _U_ 11 _N_ _S_ "U(U(P)L)U(U(P)L)" {_A_ 4 _U_ 2121 _N_ _N_ _N_ _N_} _N_ _N_ },
+ max = { _A_ 2 _U_ 11 _N_ _S_ "U(U(P)L)U(U(P)L)" {_A_ 4 _U_ 2222 _N_ _N_ _N_ _N_} _N_ _N_ },
+ min = { _A_ 2 _U_ 11 _N_ _S_ "U(U(P)L)U(U(P)L)" {_A_ 4 _U_ 2222 _N_ _N_ _N_ _N_} _N_ _N_ },
+ _tagCmp = { _A_ 2 _U_ 11 _N_ _S_ "U(U(P)L)U(U(P)L)" {_A_ 4 _U_ 2121 _N_ _N_ _N_ _N_} _N_ _N_ } #-}
+instance Ord ([Char], [Char])
+ {-# GHC_PRAGMA _M_ PreludeBuiltin {-dfun-} _A_ 0 _N_ _N_ _N_ _F_ _IF_ARGS_ 0 0 X 9 _!_ _TUP_8 [{{Eq ([Char], [Char])}}, (([Char], [Char]) -> ([Char], [Char]) -> Bool), (([Char], [Char]) -> ([Char], [Char]) -> Bool), (([Char], [Char]) -> ([Char], [Char]) -> Bool), (([Char], [Char]) -> ([Char], [Char]) -> Bool), (([Char], [Char]) -> ([Char], [Char]) -> ([Char], [Char])), (([Char], [Char]) -> ([Char], [Char]) -> ([Char], [Char])), (([Char], [Char]) -> ([Char], [Char]) -> _CMP_TAG)] [_DFUN_ Eq (([Char], [Char])), _CONSTM_ Ord (<) (([Char], [Char])), _CONSTM_ Ord (<=) (([Char], [Char])), _CONSTM_ Ord (>=) (([Char], [Char])), _CONSTM_ Ord (>) (([Char], [Char])), _CONSTM_ Ord max (([Char], [Char])), _CONSTM_ Ord min (([Char], [Char])), _CONSTM_ Ord _tagCmp (([Char], [Char]))] _N_
+ (<) = { _A_ 2 _U_ 11 _N_ _S_ "U(SL)U(SL)" {_A_ 4 _U_ 2222 _N_ _N_ _N_ _N_} _N_ _N_ },
+ (<=) = { _A_ 2 _U_ 11 _N_ _S_ "U(SL)U(SL)" {_A_ 4 _U_ 2222 _N_ _N_ _N_ _N_} _N_ _N_ },
+ (>=) = { _A_ 2 _U_ 11 _N_ _S_ "U(SL)U(SL)" {_A_ 4 _U_ 2222 _N_ _N_ _N_ _N_} _N_ _N_ },
+ (>) = { _A_ 2 _U_ 11 _N_ _S_ "U(SL)U(SL)" {_A_ 4 _U_ 2222 _N_ _N_ _N_ _N_} _N_ _N_ },
+ max = { _A_ 2 _U_ 11 _N_ _S_ "U(SL)U(SL)" {_A_ 4 _U_ 2222 _N_ _N_ _N_ _N_} _N_ _N_ },
+ min = { _A_ 2 _U_ 11 _N_ _S_ "U(SL)U(SL)" {_A_ 4 _U_ 2222 _N_ _N_ _N_ _N_} _N_ _N_ },
+ _tagCmp = { _A_ 2 _U_ 11 _N_ _S_ "U(SL)U(SL)" {_A_ 4 _U_ 2222 _N_ _N_ _N_ _N_} _N_ _N_ } #-}
+instance Ord ([Int], [Int])
+ {-# GHC_PRAGMA _M_ PreludeBuiltin {-dfun-} _A_ 0 _N_ _N_ _N_ _F_ _IF_ARGS_ 0 0 X 9 _!_ _TUP_8 [{{Eq ([Int], [Int])}}, (([Int], [Int]) -> ([Int], [Int]) -> Bool), (([Int], [Int]) -> ([Int], [Int]) -> Bool), (([Int], [Int]) -> ([Int], [Int]) -> Bool), (([Int], [Int]) -> ([Int], [Int]) -> Bool), (([Int], [Int]) -> ([Int], [Int]) -> ([Int], [Int])), (([Int], [Int]) -> ([Int], [Int]) -> ([Int], [Int])), (([Int], [Int]) -> ([Int], [Int]) -> _CMP_TAG)] [_DFUN_ Eq (([Int], [Int])), _CONSTM_ Ord (<) (([Int], [Int])), _CONSTM_ Ord (<=) (([Int], [Int])), _CONSTM_ Ord (>=) (([Int], [Int])), _CONSTM_ Ord (>) (([Int], [Int])), _CONSTM_ Ord max (([Int], [Int])), _CONSTM_ Ord min (([Int], [Int])), _CONSTM_ Ord _tagCmp (([Int], [Int]))] _N_
+ (<) = { _A_ 2 _U_ 11 _N_ _S_ "U(SL)U(SL)" {_A_ 4 _U_ 2222 _N_ _N_ _N_ _N_} _N_ _N_ },
+ (<=) = { _A_ 2 _U_ 11 _N_ _S_ "U(SL)U(SL)" {_A_ 4 _U_ 2222 _N_ _N_ _N_ _N_} _N_ _N_ },
+ (>=) = { _A_ 2 _U_ 11 _N_ _S_ "U(SL)U(SL)" {_A_ 4 _U_ 2222 _N_ _N_ _N_ _N_} _N_ _N_ },
+ (>) = { _A_ 2 _U_ 11 _N_ _S_ "U(SL)U(SL)" {_A_ 4 _U_ 2222 _N_ _N_ _N_ _N_} _N_ _N_ },
+ max = { _A_ 2 _U_ 11 _N_ _S_ "U(SL)U(SL)" {_A_ 4 _U_ 2222 _N_ _N_ _N_ _N_} _N_ _N_ },
+ min = { _A_ 2 _U_ 11 _N_ _S_ "U(SL)U(SL)" {_A_ 4 _U_ 2222 _N_ _N_ _N_ _N_} _N_ _N_ },
+ _tagCmp = { _A_ 2 _U_ 11 _N_ _S_ "U(SL)U(SL)" {_A_ 4 _U_ 2222 _N_ _N_ _N_ _N_} _N_ _N_ } #-}
instance Ord (_PackedString, _PackedString)
{-# GHC_PRAGMA _M_ PreludeBuiltin {-dfun-} _A_ 0 _N_ _N_ _N_ _F_ _IF_ARGS_ 0 0 X 9 _!_ _TUP_8 [{{Eq (_PackedString, _PackedString)}}, ((_PackedString, _PackedString) -> (_PackedString, _PackedString) -> Bool), ((_PackedString, _PackedString) -> (_PackedString, _PackedString) -> Bool), ((_PackedString, _PackedString) -> (_PackedString, _PackedString) -> Bool), ((_PackedString, _PackedString) -> (_PackedString, _PackedString) -> Bool), ((_PackedString, _PackedString) -> (_PackedString, _PackedString) -> (_PackedString, _PackedString)), ((_PackedString, _PackedString) -> (_PackedString, _PackedString) -> (_PackedString, _PackedString)), ((_PackedString, _PackedString) -> (_PackedString, _PackedString) -> _CMP_TAG)] [_DFUN_ Eq ((_PackedString, _PackedString)), _CONSTM_ Ord (<) ((_PackedString, _PackedString)), _CONSTM_ Ord (<=) ((_PackedString, _PackedString)), _CONSTM_ Ord (>=) ((_PackedString, _PackedString)), _CONSTM_ Ord (>) ((_PackedString, _PackedString)), _CONSTM_ Ord max ((_PackedString, _PackedString)), _CONSTM_ Ord min ((_PackedString, _PackedString)), _CONSTM_ Ord _tagCmp ((_PackedString, _PackedString))] _N_
- (<) = _A_ 2 _U_ 11 _N_ _S_ "U(SL)U(SL)" {_A_ 4 _U_ 2222 _N_ _N_ _N_ _N_} _N_ _N_,
- (<=) = _A_ 2 _U_ 11 _N_ _S_ "U(SL)U(SL)" {_A_ 4 _U_ 2222 _N_ _N_ _N_ _N_} _N_ _N_,
- (>=) = _A_ 2 _U_ 11 _N_ _S_ "U(SL)U(SL)" {_A_ 4 _U_ 2222 _N_ _N_ _N_ _N_} _N_ _N_,
- (>) = _A_ 2 _U_ 11 _N_ _S_ "U(SL)U(SL)" {_A_ 4 _U_ 2222 _N_ _N_ _N_ _N_} _N_ _N_,
- max = _A_ 2 _U_ 11 _N_ _S_ "U(SL)U(SL)" {_A_ 4 _U_ 2222 _N_ _N_ _N_ _N_} _N_ _N_,
- min = _A_ 2 _U_ 11 _N_ _S_ "U(SL)U(SL)" {_A_ 4 _U_ 2222 _N_ _N_ _N_ _N_} _N_ _N_,
- _tagCmp = _A_ 2 _U_ 11 _N_ _S_ "U(SL)U(SL)" {_A_ 4 _U_ 2222 _N_ _N_ _N_ _N_} _N_ _N_ #-}
+ (<) = { _A_ 2 _U_ 11 _N_ _S_ "U(SL)U(SL)" {_A_ 4 _U_ 2222 _N_ _N_ _N_ _N_} _N_ _N_ },
+ (<=) = { _A_ 2 _U_ 11 _N_ _S_ "U(SL)U(SL)" {_A_ 4 _U_ 2222 _N_ _N_ _N_ _N_} _N_ _N_ },
+ (>=) = { _A_ 2 _U_ 11 _N_ _S_ "U(SL)U(SL)" {_A_ 4 _U_ 2222 _N_ _N_ _N_ _N_} _N_ _N_ },
+ (>) = { _A_ 2 _U_ 11 _N_ _S_ "U(SL)U(SL)" {_A_ 4 _U_ 2222 _N_ _N_ _N_ _N_} _N_ _N_ },
+ max = { _A_ 2 _U_ 11 _N_ _S_ "U(SL)U(SL)" {_A_ 4 _U_ 2222 _N_ _N_ _N_ _N_} _N_ _N_ },
+ min = { _A_ 2 _U_ 11 _N_ _S_ "U(SL)U(SL)" {_A_ 4 _U_ 2222 _N_ _N_ _N_ _N_} _N_ _N_ },
+ _tagCmp = { _A_ 2 _U_ 11 _N_ _S_ "U(SL)U(SL)" {_A_ 4 _U_ 2222 _N_ _N_ _N_ _N_} _N_ _N_ } #-}
+instance Text ((Int, Int), (Int, Int))
+ {-# GHC_PRAGMA _M_ PreludeBuiltin {-dfun-} _A_ 0 _N_ _N_ _N_ _F_ _IF_ARGS_ 0 0 X 5 _!_ _TUP_4 [(Int -> [Char] -> [(((Int, Int), (Int, Int)), [Char])]), (Int -> ((Int, Int), (Int, Int)) -> [Char] -> [Char]), ([Char] -> [([((Int, Int), (Int, Int))], [Char])]), ([((Int, Int), (Int, Int))] -> [Char] -> [Char])] [_CONSTM_ Text readsPrec (((Int, Int), (Int, Int))), _CONSTM_ Text showsPrec (((Int, Int), (Int, Int))), _CONSTM_ Text readList (((Int, Int), (Int, Int))), _CONSTM_ Text showList (((Int, Int), (Int, Int)))] _N_
+ readsPrec = { _A_ 1 _U_ 02 _N_ _S_ "A" {_A_ 0 _U_ 2 _N_ _N_ _N_ _N_} _N_ _N_ },
+ showsPrec = { _A_ 3 _U_ 012 _N_ _S_ "AU(LL)L" {_A_ 3 _U_ 112 _N_ _N_ _N_ _N_} _N_ _N_ },
+ readList = { _A_ 0 _U_ 2 _N_ _N_ _N_ _N_ },
+ showList = { _A_ 1 _U_ 12 _N_ _N_ _N_ _N_ } #-}
instance (Text a, Text b) => Text (a, b)
{-# GHC_PRAGMA _M_ PreludeBuiltin {-dfun-} _A_ 2 _U_ 22 _N_ _N_ _N_ _N_ #-}
instance Text (Int, Int)
{-# GHC_PRAGMA _M_ PreludeBuiltin {-dfun-} _A_ 0 _N_ _N_ _N_ _F_ _IF_ARGS_ 0 0 X 5 _!_ _TUP_4 [(Int -> [Char] -> [((Int, Int), [Char])]), (Int -> (Int, Int) -> [Char] -> [Char]), ([Char] -> [([(Int, Int)], [Char])]), ([(Int, Int)] -> [Char] -> [Char])] [_CONSTM_ Text readsPrec ((Int, Int)), _CONSTM_ Text showsPrec ((Int, Int)), _CONSTM_ Text readList ((Int, Int)), _CONSTM_ Text showList ((Int, Int))] _N_
- readsPrec = _A_ 1 _U_ 02 _N_ _S_ "A" {_A_ 0 _U_ 2 _N_ _N_ _N_ _N_} _N_ _N_,
- showsPrec = _A_ 3 _U_ 012 _N_ _S_ "AU(LL)L" {_A_ 3 _U_ 112 _N_ _N_ _N_ _N_} _N_ _N_,
- readList = _A_ 0 _U_ 2 _N_ _N_ _N_ _N_,
- showList = _A_ 0 _U_ 12 _N_ _N_ _N_ _N_ #-}
+ readsPrec = { _A_ 1 _U_ 02 _N_ _S_ "A" {_A_ 0 _U_ 2 _N_ _N_ _N_ _N_} _N_ _N_ },
+ showsPrec = { _A_ 3 _U_ 012 _N_ _S_ "AU(LL)L" {_A_ 3 _U_ 112 _N_ _N_ _N_ _N_} _N_ _N_ },
+ readList = { _A_ 0 _U_ 2 _N_ _N_ _N_ _N_ },
+ showList = { _A_ 1 _U_ 12 _N_ _N_ _N_ _N_ } #-}
instance Text (Integer, Integer)
{-# GHC_PRAGMA _M_ PreludeBuiltin {-dfun-} _A_ 0 _N_ _N_ _N_ _F_ _IF_ARGS_ 0 0 X 5 _!_ _TUP_4 [(Int -> [Char] -> [((Integer, Integer), [Char])]), (Int -> (Integer, Integer) -> [Char] -> [Char]), ([Char] -> [([(Integer, Integer)], [Char])]), ([(Integer, Integer)] -> [Char] -> [Char])] [_CONSTM_ Text readsPrec ((Integer, Integer)), _CONSTM_ Text showsPrec ((Integer, Integer)), _CONSTM_ Text readList ((Integer, Integer)), _CONSTM_ Text showList ((Integer, Integer))] _N_
- readsPrec = _A_ 1 _U_ 02 _N_ _S_ "A" {_A_ 0 _U_ 2 _N_ _N_ _N_ _N_} _N_ _N_,
- showsPrec = _A_ 3 _U_ 012 _N_ _S_ "AU(LL)L" {_A_ 3 _U_ 112 _N_ _N_ _N_ _N_} _N_ _N_,
- readList = _A_ 0 _U_ 2 _N_ _N_ _N_ _N_,
- showList = _A_ 0 _U_ 12 _N_ _N_ _N_ _N_ #-}
+ readsPrec = { _A_ 1 _U_ 02 _N_ _S_ "A" {_A_ 0 _U_ 2 _N_ _N_ _N_ _N_} _N_ _N_ },
+ showsPrec = { _A_ 3 _U_ 012 _N_ _S_ "AU(LL)L" {_A_ 3 _U_ 112 _N_ _N_ _N_ _N_} _N_ _N_ },
+ readList = { _A_ 0 _U_ 2 _N_ _N_ _N_ _N_ },
+ showList = { _A_ 1 _U_ 12 _N_ _N_ _N_ _N_ } #-}
-{-# GHC_PRAGMA INTERFACE VERSION 5 #-}
+{-# GHC_PRAGMA INTERFACE VERSION 6 #-}
interface PreludeBuiltin where
import PreludeCore(Eq(..), Ix(..), Ord(..), Text(..))
import PreludePS(_PackedString)
instance (Eq a, Eq b) => Eq (a, b)
- {-# GHC_PRAGMA _M_ PreludeBuiltin {-dfun-} _A_ 2 _U_ 11 _N_ _N_ _N_ _N_ #-}
+ {-# GHC_PRAGMA _M_ PreludeBuiltin {-dfun-} _A_ 2 _U_ 22 _N_ _N_ _N_ _N_ #-}
instance Eq (Int, Int)
{-# GHC_PRAGMA _M_ PreludeBuiltin {-dfun-} _A_ 0 _N_ _N_ _N_ _F_ _IF_ARGS_ 0 0 X 3 _!_ _TUP_2 [((Int, Int) -> (Int, Int) -> Bool), ((Int, Int) -> (Int, Int) -> Bool)] [_CONSTM_ Eq (==) ((Int, Int)), _CONSTM_ Eq (/=) ((Int, Int))] _N_
- (==) = _A_ 2 _U_ 11 _N_ _S_ "U(U(P)L)U(U(P)L)" {_A_ 4 _U_ 2121 _N_ _N_ _F_ _IF_ARGS_ 0 4 XCXC 7 \ (u0 :: Int#) (u1 :: Int) (u2 :: Int#) (u3 :: Int) -> case _#_ eqInt# [] [u0, u2] of { _ALG_ True -> case u1 of { _ALG_ I# (u4 :: Int#) -> case u3 of { _ALG_ I# (u5 :: Int#) -> _#_ eqInt# [] [u4, u5]; _NO_DEFLT_ }; _NO_DEFLT_ }; False -> _!_ False [] []; _NO_DEFLT_ } _N_} _F_ _ALWAYS_ \ (u0 :: (Int, Int)) (u1 :: (Int, Int)) -> case u0 of { _ALG_ _TUP_2 (u2 :: Int) (u3 :: Int) -> case u2 of { _ALG_ I# (u4 :: Int#) -> case u1 of { _ALG_ _TUP_2 (u5 :: Int) (u6 :: Int) -> case u5 of { _ALG_ I# (u7 :: Int#) -> case _#_ eqInt# [] [u4, u7] of { _ALG_ True -> case u3 of { _ALG_ I# (u8 :: Int#) -> case u6 of { _ALG_ I# (u9 :: Int#) -> _#_ eqInt# [] [u8, u9]; _NO_DEFLT_ }; _NO_DEFLT_ }; False -> _!_ False [] []; _NO_DEFLT_ }; _NO_DEFLT_ }; _NO_DEFLT_ }; _NO_DEFLT_ }; _NO_DEFLT_ } _N_,
- (/=) = _A_ 2 _U_ 22 _N_ _N_ _N_ _N_ #-}
+ (==) = { _A_ 2 _U_ 11 _N_ _S_ "U(U(P)L)U(U(P)L)" {_A_ 4 _U_ 2121 _N_ _N_ _F_ _IF_ARGS_ 0 4 XCXC 7 \ (u0 :: Int#) (u1 :: Int) (u2 :: Int#) (u3 :: Int) -> case _#_ eqInt# [] [u0, u2] of { _ALG_ True -> case u1 of { _ALG_ I# (u4 :: Int#) -> case u3 of { _ALG_ I# (u5 :: Int#) -> _#_ eqInt# [] [u4, u5]; _NO_DEFLT_ }; _NO_DEFLT_ }; False -> _!_ False [] []; _NO_DEFLT_ } _N_} _F_ _ALWAYS_ \ (u0 :: (Int, Int)) (u1 :: (Int, Int)) -> case u0 of { _ALG_ _TUP_2 (u2 :: Int) (u3 :: Int) -> case u2 of { _ALG_ I# (u4 :: Int#) -> case u1 of { _ALG_ _TUP_2 (u5 :: Int) (u6 :: Int) -> case u5 of { _ALG_ I# (u7 :: Int#) -> case _#_ eqInt# [] [u4, u7] of { _ALG_ True -> case u3 of { _ALG_ I# (u8 :: Int#) -> case u6 of { _ALG_ I# (u9 :: Int#) -> _#_ eqInt# [] [u8, u9]; _NO_DEFLT_ }; _NO_DEFLT_ }; False -> _!_ False [] []; _NO_DEFLT_ }; _NO_DEFLT_ }; _NO_DEFLT_ }; _NO_DEFLT_ }; _NO_DEFLT_ } _N_ },
+ (/=) = { _A_ 2 _U_ 11 _N_ _S_ "U(U(P)L)U(U(P)L)" {_A_ 4 _U_ 2121 _N_ _N_ _F_ _IF_ARGS_ 0 4 XCXC 7 \ (u0 :: Int#) (u1 :: Int) (u2 :: Int#) (u3 :: Int) -> case _#_ neInt# [] [u0, u2] of { _ALG_ True -> _!_ True [] []; False -> case u1 of { _ALG_ I# (u4 :: Int#) -> case u3 of { _ALG_ I# (u5 :: Int#) -> _#_ neInt# [] [u4, u5]; _NO_DEFLT_ }; _NO_DEFLT_ }; _NO_DEFLT_ } _N_} _F_ _ALWAYS_ \ (u0 :: (Int, Int)) (u1 :: (Int, Int)) -> case u0 of { _ALG_ _TUP_2 (u2 :: Int) (u3 :: Int) -> case u2 of { _ALG_ I# (u4 :: Int#) -> case u1 of { _ALG_ _TUP_2 (u5 :: Int) (u6 :: Int) -> case u5 of { _ALG_ I# (u7 :: Int#) -> case _#_ neInt# [] [u4, u7] of { _ALG_ True -> _!_ True [] []; False -> case u3 of { _ALG_ I# (u8 :: Int#) -> case u6 of { _ALG_ I# (u9 :: Int#) -> _#_ neInt# [] [u8, u9]; _NO_DEFLT_ }; _NO_DEFLT_ }; _NO_DEFLT_ }; _NO_DEFLT_ }; _NO_DEFLT_ }; _NO_DEFLT_ }; _NO_DEFLT_ } _N_ } #-}
+instance Eq ([Char], [Char])
+ {-# GHC_PRAGMA _M_ PreludeBuiltin {-dfun-} _A_ 0 _N_ _N_ _N_ _F_ _IF_ARGS_ 0 0 X 3 _!_ _TUP_2 [(([Char], [Char]) -> ([Char], [Char]) -> Bool), (([Char], [Char]) -> ([Char], [Char]) -> Bool)] [_CONSTM_ Eq (==) (([Char], [Char])), _CONSTM_ Eq (/=) (([Char], [Char]))] _N_
+ (==) = { _A_ 2 _U_ 11 _N_ _S_ "U(SL)U(SL)" {_A_ 4 _U_ 2222 _N_ _N_ _N_ _N_} _N_ _N_ },
+ (/=) = { _A_ 2 _U_ 11 _N_ _S_ "U(SL)U(SL)" {_A_ 4 _U_ 2222 _N_ _N_ _N_ _N_} _N_ _N_ } #-}
+instance Eq ([Int], [Int])
+ {-# GHC_PRAGMA _M_ PreludeBuiltin {-dfun-} _A_ 0 _N_ _N_ _N_ _F_ _IF_ARGS_ 0 0 X 3 _!_ _TUP_2 [(([Int], [Int]) -> ([Int], [Int]) -> Bool), (([Int], [Int]) -> ([Int], [Int]) -> Bool)] [_CONSTM_ Eq (==) (([Int], [Int])), _CONSTM_ Eq (/=) (([Int], [Int]))] _N_
+ (==) = { _A_ 2 _U_ 11 _N_ _S_ "U(SL)U(SL)" {_A_ 4 _U_ 2222 _N_ _N_ _N_ _N_} _N_ _N_ },
+ (/=) = { _A_ 2 _U_ 11 _N_ _S_ "U(SL)U(SL)" {_A_ 4 _U_ 2222 _N_ _N_ _N_ _N_} _N_ _N_ } #-}
instance Eq (_PackedString, _PackedString)
{-# GHC_PRAGMA _M_ PreludeBuiltin {-dfun-} _A_ 0 _N_ _N_ _N_ _F_ _IF_ARGS_ 0 0 X 3 _!_ _TUP_2 [((_PackedString, _PackedString) -> (_PackedString, _PackedString) -> Bool), ((_PackedString, _PackedString) -> (_PackedString, _PackedString) -> Bool)] [_CONSTM_ Eq (==) ((_PackedString, _PackedString)), _CONSTM_ Eq (/=) ((_PackedString, _PackedString))] _N_
- (==) = _A_ 2 _U_ 11 _N_ _S_ "U(SL)U(SL)" {_A_ 4 _U_ 2222 _N_ _N_ _N_ _N_} _N_ _N_,
- (/=) = _A_ 2 _U_ 22 _N_ _N_ _N_ _N_ #-}
+ (==) = { _A_ 2 _U_ 11 _N_ _S_ "U(SL)U(SL)" {_A_ 4 _U_ 2222 _N_ _N_ _N_ _N_} _N_ _N_ },
+ (/=) = { _A_ 2 _U_ 11 _N_ _S_ "U(SL)U(SL)" {_A_ 4 _U_ 2222 _N_ _N_ _N_ _N_} _N_ _N_ } #-}
instance (Ix a, Ix b) => Ix (a, b)
{-# GHC_PRAGMA _M_ PreludeBuiltin {-dfun-} _A_ 3 _U_ 222 _N_ _N_ _N_ _N_ #-}
instance Ix (Int, Int)
{-# GHC_PRAGMA _M_ PreludeBuiltin {-dfun-} _A_ 0 _N_ _N_ _N_ _F_ _IF_ARGS_ 0 0 X 5 _!_ _TUP_4 [{{Ord (Int, Int)}}, (((Int, Int), (Int, Int)) -> [(Int, Int)]), (((Int, Int), (Int, Int)) -> (Int, Int) -> Int), (((Int, Int), (Int, Int)) -> (Int, Int) -> Bool)] [_DFUN_ Ord ((Int, Int)), _CONSTM_ Ix range ((Int, Int)), _CONSTM_ Ix index ((Int, Int)), _CONSTM_ Ix inRange ((Int, Int))] _N_
- range = _A_ 1 _U_ 1 _N_ _S_ "U(SS)" {_A_ 2 _U_ 11 _N_ _N_ _N_ _N_} _N_ _N_,
- index = _A_ 2 _U_ 11 _N_ _S_ "U(SS)U(U(P)U(P))" {_A_ 4 _U_ 1122 _N_ _N_ _N_ _N_} _N_ _N_,
- inRange = _A_ 2 _U_ 11 _N_ _S_ "U(SS)U(U(P)L)" {_A_ 4 _U_ 1121 _N_ _N_ _N_ _N_} _N_ _N_ #-}
+ range = { _A_ 1 _U_ 1 _N_ _S_ "U(SS)" {_A_ 2 _U_ 11 _N_ _N_ _N_ _N_} _N_ _N_ },
+ index = { _A_ 2 _U_ 11 _N_ _S_ "U(SS)U(U(P)U(P))" {_A_ 4 _U_ 1122 _N_ _N_ _N_ _N_} _N_ _N_ },
+ inRange = { _A_ 2 _U_ 11 _N_ _S_ "U(SS)U(U(P)L)" {_A_ 4 _U_ 1121 _N_ _N_ _N_ _N_} _N_ _N_ } #-}
instance (Ord a, Ord b) => Ord (a, b)
{-# GHC_PRAGMA _M_ PreludeBuiltin {-dfun-} _A_ 3 _U_ 112 _N_ _N_ _N_ _N_ #-}
instance Ord (Int, Int)
{-# GHC_PRAGMA _M_ PreludeBuiltin {-dfun-} _A_ 0 _N_ _N_ _N_ _F_ _IF_ARGS_ 0 0 X 9 _!_ _TUP_8 [{{Eq (Int, Int)}}, ((Int, Int) -> (Int, Int) -> Bool), ((Int, Int) -> (Int, Int) -> Bool), ((Int, Int) -> (Int, Int) -> Bool), ((Int, Int) -> (Int, Int) -> Bool), ((Int, Int) -> (Int, Int) -> (Int, Int)), ((Int, Int) -> (Int, Int) -> (Int, Int)), ((Int, Int) -> (Int, Int) -> _CMP_TAG)] [_DFUN_ Eq ((Int, Int)), _CONSTM_ Ord (<) ((Int, Int)), _CONSTM_ Ord (<=) ((Int, Int)), _CONSTM_ Ord (>=) ((Int, Int)), _CONSTM_ Ord (>) ((Int, Int)), _CONSTM_ Ord max ((Int, Int)), _CONSTM_ Ord min ((Int, Int)), _CONSTM_ Ord _tagCmp ((Int, Int))] _N_
- (<) = _A_ 2 _U_ 11 _N_ _S_ "U(U(P)L)U(U(P)L)" {_A_ 4 _U_ 2121 _N_ _N_ _N_ _N_} _N_ _N_,
- (<=) = _A_ 2 _U_ 11 _N_ _S_ "U(U(P)L)U(U(P)L)" {_A_ 4 _U_ 2121 _N_ _N_ _N_ _N_} _N_ _N_,
- (>=) = _A_ 2 _U_ 11 _N_ _S_ "U(U(P)L)U(U(P)L)" {_A_ 4 _U_ 2121 _N_ _N_ _N_ _N_} _N_ _N_,
- (>) = _A_ 2 _U_ 11 _N_ _S_ "U(U(P)L)U(U(P)L)" {_A_ 4 _U_ 2121 _N_ _N_ _N_ _N_} _N_ _N_,
- max = _A_ 2 _U_ 11 _N_ _S_ "U(U(P)L)U(U(P)L)" {_A_ 4 _U_ 2222 _N_ _N_ _N_ _N_} _N_ _N_,
- min = _A_ 2 _U_ 11 _N_ _S_ "U(U(P)L)U(U(P)L)" {_A_ 4 _U_ 2222 _N_ _N_ _N_ _N_} _N_ _N_,
- _tagCmp = _A_ 2 _U_ 11 _N_ _S_ "U(U(P)L)U(U(P)L)" {_A_ 4 _U_ 2121 _N_ _N_ _N_ _N_} _N_ _N_ #-}
+ (<) = { _A_ 2 _U_ 11 _N_ _S_ "U(U(P)L)U(U(P)L)" {_A_ 4 _U_ 2121 _N_ _N_ _N_ _N_} _N_ _N_ },
+ (<=) = { _A_ 2 _U_ 11 _N_ _S_ "U(U(P)L)U(U(P)L)" {_A_ 4 _U_ 2121 _N_ _N_ _N_ _N_} _N_ _N_ },
+ (>=) = { _A_ 2 _U_ 11 _N_ _S_ "U(U(P)L)U(U(P)L)" {_A_ 4 _U_ 2121 _N_ _N_ _N_ _N_} _N_ _N_ },
+ (>) = { _A_ 2 _U_ 11 _N_ _S_ "U(U(P)L)U(U(P)L)" {_A_ 4 _U_ 2121 _N_ _N_ _N_ _N_} _N_ _N_ },
+ max = { _A_ 2 _U_ 11 _N_ _S_ "U(U(P)L)U(U(P)L)" {_A_ 4 _U_ 2222 _N_ _N_ _N_ _N_} _N_ _N_ },
+ min = { _A_ 2 _U_ 11 _N_ _S_ "U(U(P)L)U(U(P)L)" {_A_ 4 _U_ 2222 _N_ _N_ _N_ _N_} _N_ _N_ },
+ _tagCmp = { _A_ 2 _U_ 11 _N_ _S_ "U(U(P)L)U(U(P)L)" {_A_ 4 _U_ 2121 _N_ _N_ _N_ _N_} _N_ _N_ } #-}
+instance Ord ([Char], [Char])
+ {-# GHC_PRAGMA _M_ PreludeBuiltin {-dfun-} _A_ 0 _N_ _N_ _N_ _F_ _IF_ARGS_ 0 0 X 9 _!_ _TUP_8 [{{Eq ([Char], [Char])}}, (([Char], [Char]) -> ([Char], [Char]) -> Bool), (([Char], [Char]) -> ([Char], [Char]) -> Bool), (([Char], [Char]) -> ([Char], [Char]) -> Bool), (([Char], [Char]) -> ([Char], [Char]) -> Bool), (([Char], [Char]) -> ([Char], [Char]) -> ([Char], [Char])), (([Char], [Char]) -> ([Char], [Char]) -> ([Char], [Char])), (([Char], [Char]) -> ([Char], [Char]) -> _CMP_TAG)] [_DFUN_ Eq (([Char], [Char])), _CONSTM_ Ord (<) (([Char], [Char])), _CONSTM_ Ord (<=) (([Char], [Char])), _CONSTM_ Ord (>=) (([Char], [Char])), _CONSTM_ Ord (>) (([Char], [Char])), _CONSTM_ Ord max (([Char], [Char])), _CONSTM_ Ord min (([Char], [Char])), _CONSTM_ Ord _tagCmp (([Char], [Char]))] _N_
+ (<) = { _A_ 2 _U_ 11 _N_ _S_ "U(SL)U(SL)" {_A_ 4 _U_ 2222 _N_ _N_ _N_ _N_} _N_ _N_ },
+ (<=) = { _A_ 2 _U_ 11 _N_ _S_ "U(SL)U(SL)" {_A_ 4 _U_ 2222 _N_ _N_ _N_ _N_} _N_ _N_ },
+ (>=) = { _A_ 2 _U_ 11 _N_ _S_ "U(SL)U(SL)" {_A_ 4 _U_ 2222 _N_ _N_ _N_ _N_} _N_ _N_ },
+ (>) = { _A_ 2 _U_ 11 _N_ _S_ "U(SL)U(SL)" {_A_ 4 _U_ 2222 _N_ _N_ _N_ _N_} _N_ _N_ },
+ max = { _A_ 2 _U_ 11 _N_ _S_ "U(SL)U(SL)" {_A_ 4 _U_ 2222 _N_ _N_ _N_ _N_} _N_ _N_ },
+ min = { _A_ 2 _U_ 11 _N_ _S_ "U(SL)U(SL)" {_A_ 4 _U_ 2222 _N_ _N_ _N_ _N_} _N_ _N_ },
+ _tagCmp = { _A_ 2 _U_ 11 _N_ _S_ "U(SL)U(SL)" {_A_ 4 _U_ 2222 _N_ _N_ _N_ _N_} _N_ _N_ } #-}
+instance Ord ([Int], [Int])
+ {-# GHC_PRAGMA _M_ PreludeBuiltin {-dfun-} _A_ 0 _N_ _N_ _N_ _F_ _IF_ARGS_ 0 0 X 9 _!_ _TUP_8 [{{Eq ([Int], [Int])}}, (([Int], [Int]) -> ([Int], [Int]) -> Bool), (([Int], [Int]) -> ([Int], [Int]) -> Bool), (([Int], [Int]) -> ([Int], [Int]) -> Bool), (([Int], [Int]) -> ([Int], [Int]) -> Bool), (([Int], [Int]) -> ([Int], [Int]) -> ([Int], [Int])), (([Int], [Int]) -> ([Int], [Int]) -> ([Int], [Int])), (([Int], [Int]) -> ([Int], [Int]) -> _CMP_TAG)] [_DFUN_ Eq (([Int], [Int])), _CONSTM_ Ord (<) (([Int], [Int])), _CONSTM_ Ord (<=) (([Int], [Int])), _CONSTM_ Ord (>=) (([Int], [Int])), _CONSTM_ Ord (>) (([Int], [Int])), _CONSTM_ Ord max (([Int], [Int])), _CONSTM_ Ord min (([Int], [Int])), _CONSTM_ Ord _tagCmp (([Int], [Int]))] _N_
+ (<) = { _A_ 2 _U_ 11 _N_ _S_ "U(SL)U(SL)" {_A_ 4 _U_ 2222 _N_ _N_ _N_ _N_} _N_ _N_ },
+ (<=) = { _A_ 2 _U_ 11 _N_ _S_ "U(SL)U(SL)" {_A_ 4 _U_ 2222 _N_ _N_ _N_ _N_} _N_ _N_ },
+ (>=) = { _A_ 2 _U_ 11 _N_ _S_ "U(SL)U(SL)" {_A_ 4 _U_ 2222 _N_ _N_ _N_ _N_} _N_ _N_ },
+ (>) = { _A_ 2 _U_ 11 _N_ _S_ "U(SL)U(SL)" {_A_ 4 _U_ 2222 _N_ _N_ _N_ _N_} _N_ _N_ },
+ max = { _A_ 2 _U_ 11 _N_ _S_ "U(SL)U(SL)" {_A_ 4 _U_ 2222 _N_ _N_ _N_ _N_} _N_ _N_ },
+ min = { _A_ 2 _U_ 11 _N_ _S_ "U(SL)U(SL)" {_A_ 4 _U_ 2222 _N_ _N_ _N_ _N_} _N_ _N_ },
+ _tagCmp = { _A_ 2 _U_ 11 _N_ _S_ "U(SL)U(SL)" {_A_ 4 _U_ 2222 _N_ _N_ _N_ _N_} _N_ _N_ } #-}
instance Ord (_PackedString, _PackedString)
{-# GHC_PRAGMA _M_ PreludeBuiltin {-dfun-} _A_ 0 _N_ _N_ _N_ _F_ _IF_ARGS_ 0 0 X 9 _!_ _TUP_8 [{{Eq (_PackedString, _PackedString)}}, ((_PackedString, _PackedString) -> (_PackedString, _PackedString) -> Bool), ((_PackedString, _PackedString) -> (_PackedString, _PackedString) -> Bool), ((_PackedString, _PackedString) -> (_PackedString, _PackedString) -> Bool), ((_PackedString, _PackedString) -> (_PackedString, _PackedString) -> Bool), ((_PackedString, _PackedString) -> (_PackedString, _PackedString) -> (_PackedString, _PackedString)), ((_PackedString, _PackedString) -> (_PackedString, _PackedString) -> (_PackedString, _PackedString)), ((_PackedString, _PackedString) -> (_PackedString, _PackedString) -> _CMP_TAG)] [_DFUN_ Eq ((_PackedString, _PackedString)), _CONSTM_ Ord (<) ((_PackedString, _PackedString)), _CONSTM_ Ord (<=) ((_PackedString, _PackedString)), _CONSTM_ Ord (>=) ((_PackedString, _PackedString)), _CONSTM_ Ord (>) ((_PackedString, _PackedString)), _CONSTM_ Ord max ((_PackedString, _PackedString)), _CONSTM_ Ord min ((_PackedString, _PackedString)), _CONSTM_ Ord _tagCmp ((_PackedString, _PackedString))] _N_
- (<) = _A_ 2 _U_ 11 _N_ _S_ "U(SL)U(SL)" {_A_ 4 _U_ 2222 _N_ _N_ _N_ _N_} _N_ _N_,
- (<=) = _A_ 2 _U_ 11 _N_ _S_ "U(SL)U(SL)" {_A_ 4 _U_ 2222 _N_ _N_ _N_ _N_} _N_ _N_,
- (>=) = _A_ 2 _U_ 11 _N_ _S_ "U(SL)U(SL)" {_A_ 4 _U_ 2222 _N_ _N_ _N_ _N_} _N_ _N_,
- (>) = _A_ 2 _U_ 11 _N_ _S_ "U(SL)U(SL)" {_A_ 4 _U_ 2222 _N_ _N_ _N_ _N_} _N_ _N_,
- max = _A_ 2 _U_ 11 _N_ _S_ "U(SL)U(SL)" {_A_ 4 _U_ 2222 _N_ _N_ _N_ _N_} _N_ _N_,
- min = _A_ 2 _U_ 11 _N_ _S_ "U(SL)U(SL)" {_A_ 4 _U_ 2222 _N_ _N_ _N_ _N_} _N_ _N_,
- _tagCmp = _A_ 2 _U_ 11 _N_ _S_ "U(SL)U(SL)" {_A_ 4 _U_ 2222 _N_ _N_ _N_ _N_} _N_ _N_ #-}
+ (<) = { _A_ 2 _U_ 11 _N_ _S_ "U(SL)U(SL)" {_A_ 4 _U_ 2222 _N_ _N_ _N_ _N_} _N_ _N_ },
+ (<=) = { _A_ 2 _U_ 11 _N_ _S_ "U(SL)U(SL)" {_A_ 4 _U_ 2222 _N_ _N_ _N_ _N_} _N_ _N_ },
+ (>=) = { _A_ 2 _U_ 11 _N_ _S_ "U(SL)U(SL)" {_A_ 4 _U_ 2222 _N_ _N_ _N_ _N_} _N_ _N_ },
+ (>) = { _A_ 2 _U_ 11 _N_ _S_ "U(SL)U(SL)" {_A_ 4 _U_ 2222 _N_ _N_ _N_ _N_} _N_ _N_ },
+ max = { _A_ 2 _U_ 11 _N_ _S_ "U(SL)U(SL)" {_A_ 4 _U_ 2222 _N_ _N_ _N_ _N_} _N_ _N_ },
+ min = { _A_ 2 _U_ 11 _N_ _S_ "U(SL)U(SL)" {_A_ 4 _U_ 2222 _N_ _N_ _N_ _N_} _N_ _N_ },
+ _tagCmp = { _A_ 2 _U_ 11 _N_ _S_ "U(SL)U(SL)" {_A_ 4 _U_ 2222 _N_ _N_ _N_ _N_} _N_ _N_ } #-}
+instance Text ((Int, Int), (Int, Int))
+ {-# GHC_PRAGMA _M_ PreludeBuiltin {-dfun-} _A_ 0 _N_ _N_ _N_ _F_ _IF_ARGS_ 0 0 X 5 _!_ _TUP_4 [(Int -> [Char] -> [(((Int, Int), (Int, Int)), [Char])]), (Int -> ((Int, Int), (Int, Int)) -> [Char] -> [Char]), ([Char] -> [([((Int, Int), (Int, Int))], [Char])]), ([((Int, Int), (Int, Int))] -> [Char] -> [Char])] [_CONSTM_ Text readsPrec (((Int, Int), (Int, Int))), _CONSTM_ Text showsPrec (((Int, Int), (Int, Int))), _CONSTM_ Text readList (((Int, Int), (Int, Int))), _CONSTM_ Text showList (((Int, Int), (Int, Int)))] _N_
+ readsPrec = { _A_ 1 _U_ 02 _N_ _S_ "A" {_A_ 0 _U_ 2 _N_ _N_ _N_ _N_} _N_ _N_ },
+ showsPrec = { _A_ 3 _U_ 012 _N_ _S_ "AU(LL)L" {_A_ 3 _U_ 112 _N_ _N_ _N_ _N_} _N_ _N_ },
+ readList = { _A_ 0 _U_ 2 _N_ _N_ _N_ _N_ },
+ showList = { _A_ 1 _U_ 12 _N_ _N_ _N_ _N_ } #-}
instance (Text a, Text b) => Text (a, b)
{-# GHC_PRAGMA _M_ PreludeBuiltin {-dfun-} _A_ 2 _U_ 22 _N_ _N_ _N_ _N_ #-}
instance Text (Int, Int)
{-# GHC_PRAGMA _M_ PreludeBuiltin {-dfun-} _A_ 0 _N_ _N_ _N_ _F_ _IF_ARGS_ 0 0 X 5 _!_ _TUP_4 [(Int -> [Char] -> [((Int, Int), [Char])]), (Int -> (Int, Int) -> [Char] -> [Char]), ([Char] -> [([(Int, Int)], [Char])]), ([(Int, Int)] -> [Char] -> [Char])] [_CONSTM_ Text readsPrec ((Int, Int)), _CONSTM_ Text showsPrec ((Int, Int)), _CONSTM_ Text readList ((Int, Int)), _CONSTM_ Text showList ((Int, Int))] _N_
- readsPrec = _A_ 1 _U_ 02 _N_ _S_ "A" {_A_ 0 _U_ 2 _N_ _N_ _N_ _N_} _N_ _N_,
- showsPrec = _A_ 3 _U_ 012 _N_ _S_ "AU(LL)L" {_A_ 3 _U_ 112 _N_ _N_ _N_ _N_} _N_ _N_,
- readList = _A_ 0 _U_ 2 _N_ _N_ _N_ _N_,
- showList = _A_ 0 _U_ 12 _N_ _N_ _N_ _N_ #-}
+ readsPrec = { _A_ 1 _U_ 02 _N_ _S_ "A" {_A_ 0 _U_ 2 _N_ _N_ _N_ _N_} _N_ _N_ },
+ showsPrec = { _A_ 3 _U_ 012 _N_ _S_ "AU(LL)L" {_A_ 3 _U_ 112 _N_ _N_ _N_ _N_} _N_ _N_ },
+ readList = { _A_ 0 _U_ 2 _N_ _N_ _N_ _N_ },
+ showList = { _A_ 1 _U_ 12 _N_ _N_ _N_ _N_ } #-}
instance Text (Integer, Integer)
{-# GHC_PRAGMA _M_ PreludeBuiltin {-dfun-} _A_ 0 _N_ _N_ _N_ _F_ _IF_ARGS_ 0 0 X 5 _!_ _TUP_4 [(Int -> [Char] -> [((Integer, Integer), [Char])]), (Int -> (Integer, Integer) -> [Char] -> [Char]), ([Char] -> [([(Integer, Integer)], [Char])]), ([(Integer, Integer)] -> [Char] -> [Char])] [_CONSTM_ Text readsPrec ((Integer, Integer)), _CONSTM_ Text showsPrec ((Integer, Integer)), _CONSTM_ Text readList ((Integer, Integer)), _CONSTM_ Text showList ((Integer, Integer))] _N_
- readsPrec = _A_ 1 _U_ 02 _N_ _S_ "A" {_A_ 0 _U_ 2 _N_ _N_ _N_ _N_} _N_ _N_,
- showsPrec = _A_ 3 _U_ 012 _N_ _S_ "AU(LL)L" {_A_ 3 _U_ 112 _N_ _N_ _N_ _N_} _N_ _N_,
- readList = _A_ 0 _U_ 2 _N_ _N_ _N_ _N_,
- showList = _A_ 0 _U_ 12 _N_ _N_ _N_ _N_ #-}
+ readsPrec = { _A_ 1 _U_ 02 _N_ _S_ "A" {_A_ 0 _U_ 2 _N_ _N_ _N_ _N_} _N_ _N_ },
+ showsPrec = { _A_ 3 _U_ 012 _N_ _S_ "AU(LL)L" {_A_ 3 _U_ 112 _N_ _N_ _N_ _N_} _N_ _N_ },
+ readList = { _A_ 0 _U_ 2 _N_ _N_ _N_ _N_ },
+ showList = { _A_ 1 _U_ 12 _N_ _N_ _N_ _N_ } #-}
-{-# GHC_PRAGMA INTERFACE VERSION 5 #-}
+{-# GHC_PRAGMA INTERFACE VERSION 6 #-}
interface PreludeBuiltin where
import PreludeCore(Eq(..), Ix(..), Ord(..), Text(..))
instance (Eq a, Eq b, Eq c) => Eq (a, b, c)
{-# GHC_PRAGMA _M_ PreludeBuiltin {-dfun-} _A_ 3 _U_ 111 _N_ _N_ _N_ _N_ #-}
+instance Eq (Int, Int, Int)
+ {-# GHC_PRAGMA _M_ PreludeBuiltin {-dfun-} _A_ 0 _N_ _N_ _N_ _F_ _IF_ARGS_ 0 0 X 3 _!_ _TUP_2 [((Int, Int, Int) -> (Int, Int, Int) -> Bool), ((Int, Int, Int) -> (Int, Int, Int) -> Bool)] [_CONSTM_ Eq (==) ((Int, Int, Int)), _CONSTM_ Eq (/=) ((Int, Int, Int))] _N_
+ (==) = { _A_ 2 _U_ 11 _N_ _S_ "U(U(P)LL)U(U(P)LL)" {_A_ 4 _U_ 2111 _N_ _N_ _N_ _N_} _N_ _N_ },
+ (/=) = { _A_ 2 _U_ 11 _N_ _S_ "U(U(P)LL)U(U(P)LL)" {_A_ 4 _U_ 2111 _N_ _N_ _N_ _N_} _N_ _N_ } #-}
instance (Ix a, Ix b, Ix c) => Ix (a, b, c)
{-# GHC_PRAGMA _M_ PreludeBuiltin {-dfun-} _A_ 4 _U_ 2222 _N_ _N_ _N_ _N_ #-}
instance (Ord a, Ord b, Ord c) => Ord (a, b, c)
{-# GHC_PRAGMA _M_ PreludeBuiltin {-dfun-} _A_ 4 _U_ 1112 _N_ _N_ _N_ _N_ #-}
+instance Ord (Int, Int, Int)
+ {-# GHC_PRAGMA _M_ PreludeBuiltin {-dfun-} _A_ 0 _N_ _N_ _N_ _F_ _IF_ARGS_ 0 0 X 9 _!_ _TUP_8 [{{Eq (Int, Int, Int)}}, ((Int, Int, Int) -> (Int, Int, Int) -> Bool), ((Int, Int, Int) -> (Int, Int, Int) -> Bool), ((Int, Int, Int) -> (Int, Int, Int) -> Bool), ((Int, Int, Int) -> (Int, Int, Int) -> Bool), ((Int, Int, Int) -> (Int, Int, Int) -> (Int, Int, Int)), ((Int, Int, Int) -> (Int, Int, Int) -> (Int, Int, Int)), ((Int, Int, Int) -> (Int, Int, Int) -> _CMP_TAG)] [_DFUN_ Eq ((Int, Int, Int)), _CONSTM_ Ord (<) ((Int, Int, Int)), _CONSTM_ Ord (<=) ((Int, Int, Int)), _CONSTM_ Ord (>=) ((Int, Int, Int)), _CONSTM_ Ord (>) ((Int, Int, Int)), _CONSTM_ Ord max ((Int, Int, Int)), _CONSTM_ Ord min ((Int, Int, Int)), _CONSTM_ Ord _tagCmp ((Int, Int, Int))] _N_
+ (<) = { _A_ 2 _U_ 11 _N_ _S_ "U(U(P)LL)U(U(P)LL)" {_A_ 4 _U_ 2111 _N_ _N_ _N_ _N_} _N_ _N_ },
+ (<=) = { _A_ 2 _U_ 11 _N_ _S_ "U(U(P)LL)U(U(P)LL)" {_A_ 4 _U_ 2111 _N_ _N_ _N_ _N_} _N_ _N_ },
+ (>=) = { _A_ 2 _U_ 11 _N_ _S_ "U(U(P)LL)U(U(P)LL)" {_A_ 4 _U_ 2111 _N_ _N_ _N_ _N_} _N_ _N_ },
+ (>) = { _A_ 2 _U_ 11 _N_ _S_ "U(U(P)LL)U(U(P)LL)" {_A_ 4 _U_ 2111 _N_ _N_ _N_ _N_} _N_ _N_ },
+ max = { _A_ 2 _U_ 12 _N_ _S_ "U(U(P)LL)U(U(P)LL)" {_A_ 4 _U_ 2222 _N_ _N_ _N_ _N_} _N_ _N_ },
+ min = { _A_ 2 _U_ 12 _N_ _S_ "U(U(P)LL)U(U(P)LL)" {_A_ 4 _U_ 2222 _N_ _N_ _N_ _N_} _N_ _N_ },
+ _tagCmp = { _A_ 2 _U_ 11 _N_ _S_ "U(U(P)LL)U(U(P)LL)" {_A_ 4 _U_ 2111 _N_ _N_ _N_ _N_} _N_ _N_ } #-}
instance (Text a, Text b, Text c) => Text (a, b, c)
{-# GHC_PRAGMA _M_ PreludeBuiltin {-dfun-} _A_ 3 _U_ 222 _N_ _N_ _N_ _N_ #-}
+instance Text (Int, Int, Int)
+ {-# GHC_PRAGMA _M_ PreludeBuiltin {-dfun-} _A_ 0 _N_ _N_ _N_ _F_ _IF_ARGS_ 0 0 X 5 _!_ _TUP_4 [(Int -> [Char] -> [((Int, Int, Int), [Char])]), (Int -> (Int, Int, Int) -> [Char] -> [Char]), ([Char] -> [([(Int, Int, Int)], [Char])]), ([(Int, Int, Int)] -> [Char] -> [Char])] [_CONSTM_ Text readsPrec ((Int, Int, Int)), _CONSTM_ Text showsPrec ((Int, Int, Int)), _CONSTM_ Text readList ((Int, Int, Int)), _CONSTM_ Text showList ((Int, Int, Int))] _N_
+ readsPrec = { _A_ 1 _U_ 02 _N_ _S_ "A" {_A_ 0 _U_ 2 _N_ _N_ _N_ _N_} _N_ _N_ },
+ showsPrec = { _A_ 3 _U_ 012 _N_ _S_ "AU(LLL)L" {_A_ 4 _U_ 1112 _N_ _N_ _N_ _N_} _N_ _N_ },
+ readList = { _A_ 0 _U_ 2 _N_ _N_ _N_ _N_ },
+ showList = { _A_ 1 _U_ 12 _N_ _N_ _N_ _N_ } #-}
import Prel ( (&&), (.) )
import PS ( _PackedString, _unpackPS )
import Text
+import TyArray
+import TyComplex
instance (Eq a, Eq b, Eq c) => Eq (a, b, c) where
(a1,a2,a3) == (b1,b2,b3) = a1 == b1 && a2 == b2 && a3 == b3
instance (Text a, Text b, Text c) => Text (a, b, c) where
readsPrec p = readParen False
(\a -> [((x,y,z), h) | ("(",b) <- lex a,
- (x,c) <- reads b,
+ (x,c) <- readsPrec 0 b,
(",",d) <- lex c,
- (y,e) <- reads d,
+ (y,e) <- readsPrec 0 d,
(",",f) <- lex e,
- (z,g) <- reads f,
+ (z,g) <- readsPrec 0 f,
(")",h) <- lex g ] )
- showsPrec p (x,y,z) = showChar '(' . shows x . showString ", " .
- shows y . showString ", " .
- shows z . showChar ')'
+ showsPrec p (x,y,z) = showChar '(' . showsPrec 0 x . showString ", " .
+ showsPrec 0 y . showString ", " .
+ showsPrec 0 z . showChar ')'
+
+ readList = _readList (readsPrec 0)
+ showList = _showList (showsPrec 0)
+
+{-# SPECIALIZE instance Eq (Int,Int,Int) #-}
+{-# SPECIALIZE instance Ord (Int,Int,Int) #-}
+{-# SPECIALIZE instance Text (Int,Int,Int) #-}
#if defined(__UNBOXED_INSTANCES__)
-{-# GHC_PRAGMA INTERFACE VERSION 5 #-}
+{-# GHC_PRAGMA INTERFACE VERSION 6 #-}
interface PreludeBuiltin where
import PreludeCore(Eq(..), Ix(..), Ord(..), Text(..))
instance (Eq a, Eq b, Eq c) => Eq (a, b, c)
{-# GHC_PRAGMA _M_ PreludeBuiltin {-dfun-} _A_ 3 _U_ 111 _N_ _N_ _N_ _N_ #-}
+instance Eq (Int, Int, Int)
+ {-# GHC_PRAGMA _M_ PreludeBuiltin {-dfun-} _A_ 0 _N_ _N_ _N_ _F_ _IF_ARGS_ 0 0 X 3 _!_ _TUP_2 [((Int, Int, Int) -> (Int, Int, Int) -> Bool), ((Int, Int, Int) -> (Int, Int, Int) -> Bool)] [_CONSTM_ Eq (==) ((Int, Int, Int)), _CONSTM_ Eq (/=) ((Int, Int, Int))] _N_
+ (==) = { _A_ 2 _U_ 11 _N_ _S_ "U(U(P)LL)U(U(P)LL)" {_A_ 4 _U_ 2111 _N_ _N_ _N_ _N_} _N_ _N_ },
+ (/=) = { _A_ 2 _U_ 11 _N_ _S_ "U(U(P)LL)U(U(P)LL)" {_A_ 4 _U_ 2111 _N_ _N_ _N_ _N_} _N_ _N_ } #-}
instance (Ix a, Ix b, Ix c) => Ix (a, b, c)
{-# GHC_PRAGMA _M_ PreludeBuiltin {-dfun-} _A_ 4 _U_ 2222 _N_ _N_ _N_ _N_ #-}
instance (Ord a, Ord b, Ord c) => Ord (a, b, c)
{-# GHC_PRAGMA _M_ PreludeBuiltin {-dfun-} _A_ 4 _U_ 1112 _N_ _N_ _N_ _N_ #-}
+instance Ord (Int, Int, Int)
+ {-# GHC_PRAGMA _M_ PreludeBuiltin {-dfun-} _A_ 0 _N_ _N_ _N_ _F_ _IF_ARGS_ 0 0 X 9 _!_ _TUP_8 [{{Eq (Int, Int, Int)}}, ((Int, Int, Int) -> (Int, Int, Int) -> Bool), ((Int, Int, Int) -> (Int, Int, Int) -> Bool), ((Int, Int, Int) -> (Int, Int, Int) -> Bool), ((Int, Int, Int) -> (Int, Int, Int) -> Bool), ((Int, Int, Int) -> (Int, Int, Int) -> (Int, Int, Int)), ((Int, Int, Int) -> (Int, Int, Int) -> (Int, Int, Int)), ((Int, Int, Int) -> (Int, Int, Int) -> _CMP_TAG)] [_DFUN_ Eq ((Int, Int, Int)), _CONSTM_ Ord (<) ((Int, Int, Int)), _CONSTM_ Ord (<=) ((Int, Int, Int)), _CONSTM_ Ord (>=) ((Int, Int, Int)), _CONSTM_ Ord (>) ((Int, Int, Int)), _CONSTM_ Ord max ((Int, Int, Int)), _CONSTM_ Ord min ((Int, Int, Int)), _CONSTM_ Ord _tagCmp ((Int, Int, Int))] _N_
+ (<) = { _A_ 2 _U_ 11 _N_ _S_ "U(U(P)LL)U(U(P)LL)" {_A_ 4 _U_ 2111 _N_ _N_ _N_ _N_} _N_ _N_ },
+ (<=) = { _A_ 2 _U_ 11 _N_ _S_ "U(U(P)LL)U(U(P)LL)" {_A_ 4 _U_ 2111 _N_ _N_ _N_ _N_} _N_ _N_ },
+ (>=) = { _A_ 2 _U_ 11 _N_ _S_ "U(U(P)LL)U(U(P)LL)" {_A_ 4 _U_ 2111 _N_ _N_ _N_ _N_} _N_ _N_ },
+ (>) = { _A_ 2 _U_ 11 _N_ _S_ "U(U(P)LL)U(U(P)LL)" {_A_ 4 _U_ 2111 _N_ _N_ _N_ _N_} _N_ _N_ },
+ max = { _A_ 2 _U_ 12 _N_ _S_ "U(U(P)LL)U(U(P)LL)" {_A_ 4 _U_ 2222 _N_ _N_ _N_ _N_} _N_ _N_ },
+ min = { _A_ 2 _U_ 12 _N_ _S_ "U(U(P)LL)U(U(P)LL)" {_A_ 4 _U_ 2222 _N_ _N_ _N_ _N_} _N_ _N_ },
+ _tagCmp = { _A_ 2 _U_ 11 _N_ _S_ "U(U(P)LL)U(U(P)LL)" {_A_ 4 _U_ 2111 _N_ _N_ _N_ _N_} _N_ _N_ } #-}
instance (Text a, Text b, Text c) => Text (a, b, c)
{-# GHC_PRAGMA _M_ PreludeBuiltin {-dfun-} _A_ 3 _U_ 222 _N_ _N_ _N_ _N_ #-}
+instance Text (Int, Int, Int)
+ {-# GHC_PRAGMA _M_ PreludeBuiltin {-dfun-} _A_ 0 _N_ _N_ _N_ _F_ _IF_ARGS_ 0 0 X 5 _!_ _TUP_4 [(Int -> [Char] -> [((Int, Int, Int), [Char])]), (Int -> (Int, Int, Int) -> [Char] -> [Char]), ([Char] -> [([(Int, Int, Int)], [Char])]), ([(Int, Int, Int)] -> [Char] -> [Char])] [_CONSTM_ Text readsPrec ((Int, Int, Int)), _CONSTM_ Text showsPrec ((Int, Int, Int)), _CONSTM_ Text readList ((Int, Int, Int)), _CONSTM_ Text showList ((Int, Int, Int))] _N_
+ readsPrec = { _A_ 1 _U_ 02 _N_ _S_ "A" {_A_ 0 _U_ 2 _N_ _N_ _N_ _N_} _N_ _N_ },
+ showsPrec = { _A_ 3 _U_ 012 _N_ _S_ "AU(LLL)L" {_A_ 4 _U_ 1112 _N_ _N_ _N_ _N_} _N_ _N_ },
+ readList = { _A_ 0 _U_ 2 _N_ _N_ _N_ _N_ },
+ showList = { _A_ 1 _U_ 12 _N_ _N_ _N_ _N_ } #-}
-{-# GHC_PRAGMA INTERFACE VERSION 5 #-}
+{-# GHC_PRAGMA INTERFACE VERSION 6 #-}
interface PreludeBuiltin where
import PreludeCore(Eq(..), Ix(..), Ord(..), Text(..))
instance (Eq a, Eq b, Eq c) => Eq (a, b, c)
{-# GHC_PRAGMA _M_ PreludeBuiltin {-dfun-} _A_ 3 _U_ 111 _N_ _N_ _N_ _N_ #-}
+instance Eq (Int, Int, Int)
+ {-# GHC_PRAGMA _M_ PreludeBuiltin {-dfun-} _A_ 0 _N_ _N_ _N_ _F_ _IF_ARGS_ 0 0 X 3 _!_ _TUP_2 [((Int, Int, Int) -> (Int, Int, Int) -> Bool), ((Int, Int, Int) -> (Int, Int, Int) -> Bool)] [_CONSTM_ Eq (==) ((Int, Int, Int)), _CONSTM_ Eq (/=) ((Int, Int, Int))] _N_
+ (==) = { _A_ 2 _U_ 11 _N_ _S_ "U(U(P)LL)U(U(P)LL)" {_A_ 4 _U_ 2111 _N_ _N_ _N_ _N_} _N_ _N_ },
+ (/=) = { _A_ 2 _U_ 11 _N_ _S_ "U(U(P)LL)U(U(P)LL)" {_A_ 4 _U_ 2111 _N_ _N_ _N_ _N_} _N_ _N_ } #-}
instance (Ix a, Ix b, Ix c) => Ix (a, b, c)
{-# GHC_PRAGMA _M_ PreludeBuiltin {-dfun-} _A_ 4 _U_ 2222 _N_ _N_ _N_ _N_ #-}
instance (Ord a, Ord b, Ord c) => Ord (a, b, c)
{-# GHC_PRAGMA _M_ PreludeBuiltin {-dfun-} _A_ 4 _U_ 1112 _N_ _N_ _N_ _N_ #-}
+instance Ord (Int, Int, Int)
+ {-# GHC_PRAGMA _M_ PreludeBuiltin {-dfun-} _A_ 0 _N_ _N_ _N_ _F_ _IF_ARGS_ 0 0 X 9 _!_ _TUP_8 [{{Eq (Int, Int, Int)}}, ((Int, Int, Int) -> (Int, Int, Int) -> Bool), ((Int, Int, Int) -> (Int, Int, Int) -> Bool), ((Int, Int, Int) -> (Int, Int, Int) -> Bool), ((Int, Int, Int) -> (Int, Int, Int) -> Bool), ((Int, Int, Int) -> (Int, Int, Int) -> (Int, Int, Int)), ((Int, Int, Int) -> (Int, Int, Int) -> (Int, Int, Int)), ((Int, Int, Int) -> (Int, Int, Int) -> _CMP_TAG)] [_DFUN_ Eq ((Int, Int, Int)), _CONSTM_ Ord (<) ((Int, Int, Int)), _CONSTM_ Ord (<=) ((Int, Int, Int)), _CONSTM_ Ord (>=) ((Int, Int, Int)), _CONSTM_ Ord (>) ((Int, Int, Int)), _CONSTM_ Ord max ((Int, Int, Int)), _CONSTM_ Ord min ((Int, Int, Int)), _CONSTM_ Ord _tagCmp ((Int, Int, Int))] _N_
+ (<) = { _A_ 2 _U_ 11 _N_ _S_ "U(U(P)LL)U(U(P)LL)" {_A_ 4 _U_ 2111 _N_ _N_ _N_ _N_} _N_ _N_ },
+ (<=) = { _A_ 2 _U_ 11 _N_ _S_ "U(U(P)LL)U(U(P)LL)" {_A_ 4 _U_ 2111 _N_ _N_ _N_ _N_} _N_ _N_ },
+ (>=) = { _A_ 2 _U_ 11 _N_ _S_ "U(U(P)LL)U(U(P)LL)" {_A_ 4 _U_ 2111 _N_ _N_ _N_ _N_} _N_ _N_ },
+ (>) = { _A_ 2 _U_ 11 _N_ _S_ "U(U(P)LL)U(U(P)LL)" {_A_ 4 _U_ 2111 _N_ _N_ _N_ _N_} _N_ _N_ },
+ max = { _A_ 2 _U_ 12 _N_ _S_ "U(U(P)LL)U(U(P)LL)" {_A_ 4 _U_ 2222 _N_ _N_ _N_ _N_} _N_ _N_ },
+ min = { _A_ 2 _U_ 12 _N_ _S_ "U(U(P)LL)U(U(P)LL)" {_A_ 4 _U_ 2222 _N_ _N_ _N_ _N_} _N_ _N_ },
+ _tagCmp = { _A_ 2 _U_ 11 _N_ _S_ "U(U(P)LL)U(U(P)LL)" {_A_ 4 _U_ 2111 _N_ _N_ _N_ _N_} _N_ _N_ } #-}
instance (Text a, Text b, Text c) => Text (a, b, c)
{-# GHC_PRAGMA _M_ PreludeBuiltin {-dfun-} _A_ 3 _U_ 222 _N_ _N_ _N_ _N_ #-}
+instance Text (Int, Int, Int)
+ {-# GHC_PRAGMA _M_ PreludeBuiltin {-dfun-} _A_ 0 _N_ _N_ _N_ _F_ _IF_ARGS_ 0 0 X 5 _!_ _TUP_4 [(Int -> [Char] -> [((Int, Int, Int), [Char])]), (Int -> (Int, Int, Int) -> [Char] -> [Char]), ([Char] -> [([(Int, Int, Int)], [Char])]), ([(Int, Int, Int)] -> [Char] -> [Char])] [_CONSTM_ Text readsPrec ((Int, Int, Int)), _CONSTM_ Text showsPrec ((Int, Int, Int)), _CONSTM_ Text readList ((Int, Int, Int)), _CONSTM_ Text showList ((Int, Int, Int))] _N_
+ readsPrec = { _A_ 1 _U_ 02 _N_ _S_ "A" {_A_ 0 _U_ 2 _N_ _N_ _N_ _N_} _N_ _N_ },
+ showsPrec = { _A_ 3 _U_ 012 _N_ _S_ "AU(LLL)L" {_A_ 4 _U_ 1112 _N_ _N_ _N_ _N_} _N_ _N_ },
+ readList = { _A_ 0 _U_ 2 _N_ _N_ _N_ _N_ },
+ showList = { _A_ 1 _U_ 12 _N_ _N_ _N_ _N_ } #-}
-{-# GHC_PRAGMA INTERFACE VERSION 5 #-}
+{-# GHC_PRAGMA INTERFACE VERSION 6 #-}
interface PreludeBuiltin where
import PreludeCore(Eq(..), Ix(..), Ord(..), Text(..))
instance (Eq a, Eq b, Eq c) => Eq (a, b, c)
{-# GHC_PRAGMA _M_ PreludeBuiltin {-dfun-} _A_ 3 _U_ 111 _N_ _N_ _N_ _N_ #-}
+instance Eq (Int, Int, Int)
+ {-# GHC_PRAGMA _M_ PreludeBuiltin {-dfun-} _A_ 0 _N_ _N_ _N_ _F_ _IF_ARGS_ 0 0 X 3 _!_ _TUP_2 [((Int, Int, Int) -> (Int, Int, Int) -> Bool), ((Int, Int, Int) -> (Int, Int, Int) -> Bool)] [_CONSTM_ Eq (==) ((Int, Int, Int)), _CONSTM_ Eq (/=) ((Int, Int, Int))] _N_
+ (==) = { _A_ 2 _U_ 11 _N_ _S_ "U(U(P)LL)U(U(P)LL)" {_A_ 4 _U_ 2111 _N_ _N_ _N_ _N_} _N_ _N_ },
+ (/=) = { _A_ 2 _U_ 11 _N_ _S_ "U(U(P)LL)U(U(P)LL)" {_A_ 4 _U_ 2111 _N_ _N_ _N_ _N_} _N_ _N_ } #-}
instance (Ix a, Ix b, Ix c) => Ix (a, b, c)
{-# GHC_PRAGMA _M_ PreludeBuiltin {-dfun-} _A_ 4 _U_ 2222 _N_ _N_ _N_ _N_ #-}
instance (Ord a, Ord b, Ord c) => Ord (a, b, c)
{-# GHC_PRAGMA _M_ PreludeBuiltin {-dfun-} _A_ 4 _U_ 1112 _N_ _N_ _N_ _N_ #-}
+instance Ord (Int, Int, Int)
+ {-# GHC_PRAGMA _M_ PreludeBuiltin {-dfun-} _A_ 0 _N_ _N_ _N_ _F_ _IF_ARGS_ 0 0 X 9 _!_ _TUP_8 [{{Eq (Int, Int, Int)}}, ((Int, Int, Int) -> (Int, Int, Int) -> Bool), ((Int, Int, Int) -> (Int, Int, Int) -> Bool), ((Int, Int, Int) -> (Int, Int, Int) -> Bool), ((Int, Int, Int) -> (Int, Int, Int) -> Bool), ((Int, Int, Int) -> (Int, Int, Int) -> (Int, Int, Int)), ((Int, Int, Int) -> (Int, Int, Int) -> (Int, Int, Int)), ((Int, Int, Int) -> (Int, Int, Int) -> _CMP_TAG)] [_DFUN_ Eq ((Int, Int, Int)), _CONSTM_ Ord (<) ((Int, Int, Int)), _CONSTM_ Ord (<=) ((Int, Int, Int)), _CONSTM_ Ord (>=) ((Int, Int, Int)), _CONSTM_ Ord (>) ((Int, Int, Int)), _CONSTM_ Ord max ((Int, Int, Int)), _CONSTM_ Ord min ((Int, Int, Int)), _CONSTM_ Ord _tagCmp ((Int, Int, Int))] _N_
+ (<) = { _A_ 2 _U_ 11 _N_ _S_ "U(U(P)LL)U(U(P)LL)" {_A_ 4 _U_ 2111 _N_ _N_ _N_ _N_} _N_ _N_ },
+ (<=) = { _A_ 2 _U_ 11 _N_ _S_ "U(U(P)LL)U(U(P)LL)" {_A_ 4 _U_ 2111 _N_ _N_ _N_ _N_} _N_ _N_ },
+ (>=) = { _A_ 2 _U_ 11 _N_ _S_ "U(U(P)LL)U(U(P)LL)" {_A_ 4 _U_ 2111 _N_ _N_ _N_ _N_} _N_ _N_ },
+ (>) = { _A_ 2 _U_ 11 _N_ _S_ "U(U(P)LL)U(U(P)LL)" {_A_ 4 _U_ 2111 _N_ _N_ _N_ _N_} _N_ _N_ },
+ max = { _A_ 2 _U_ 12 _N_ _S_ "U(U(P)LL)U(U(P)LL)" {_A_ 4 _U_ 2222 _N_ _N_ _N_ _N_} _N_ _N_ },
+ min = { _A_ 2 _U_ 12 _N_ _S_ "U(U(P)LL)U(U(P)LL)" {_A_ 4 _U_ 2222 _N_ _N_ _N_ _N_} _N_ _N_ },
+ _tagCmp = { _A_ 2 _U_ 11 _N_ _S_ "U(U(P)LL)U(U(P)LL)" {_A_ 4 _U_ 2111 _N_ _N_ _N_ _N_} _N_ _N_ } #-}
instance (Text a, Text b, Text c) => Text (a, b, c)
{-# GHC_PRAGMA _M_ PreludeBuiltin {-dfun-} _A_ 3 _U_ 222 _N_ _N_ _N_ _N_ #-}
+instance Text (Int, Int, Int)
+ {-# GHC_PRAGMA _M_ PreludeBuiltin {-dfun-} _A_ 0 _N_ _N_ _N_ _F_ _IF_ARGS_ 0 0 X 5 _!_ _TUP_4 [(Int -> [Char] -> [((Int, Int, Int), [Char])]), (Int -> (Int, Int, Int) -> [Char] -> [Char]), ([Char] -> [([(Int, Int, Int)], [Char])]), ([(Int, Int, Int)] -> [Char] -> [Char])] [_CONSTM_ Text readsPrec ((Int, Int, Int)), _CONSTM_ Text showsPrec ((Int, Int, Int)), _CONSTM_ Text readList ((Int, Int, Int)), _CONSTM_ Text showList ((Int, Int, Int))] _N_
+ readsPrec = { _A_ 1 _U_ 02 _N_ _S_ "A" {_A_ 0 _U_ 2 _N_ _N_ _N_ _N_} _N_ _N_ },
+ showsPrec = { _A_ 3 _U_ 012 _N_ _S_ "AU(LLL)L" {_A_ 4 _U_ 1112 _N_ _N_ _N_ _N_} _N_ _N_ },
+ readList = { _A_ 0 _U_ 2 _N_ _N_ _N_ _N_ },
+ showList = { _A_ 1 _U_ 12 _N_ _N_ _N_ _N_ } #-}
-{-# GHC_PRAGMA INTERFACE VERSION 5 #-}
+{-# GHC_PRAGMA INTERFACE VERSION 6 #-}
interface PreludeBuiltin where
import PreludeCore(Eq(..), Ix(..), Ord(..), Text(..))
instance (Eq a, Eq b, Eq c) => Eq (a, b, c)
{-# GHC_PRAGMA _M_ PreludeBuiltin {-dfun-} _A_ 3 _U_ 111 _N_ _N_ _N_ _N_ #-}
+instance Eq (Int, Int, Int)
+ {-# GHC_PRAGMA _M_ PreludeBuiltin {-dfun-} _A_ 0 _N_ _N_ _N_ _F_ _IF_ARGS_ 0 0 X 3 _!_ _TUP_2 [((Int, Int, Int) -> (Int, Int, Int) -> Bool), ((Int, Int, Int) -> (Int, Int, Int) -> Bool)] [_CONSTM_ Eq (==) ((Int, Int, Int)), _CONSTM_ Eq (/=) ((Int, Int, Int))] _N_
+ (==) = { _A_ 2 _U_ 11 _N_ _S_ "U(U(P)LL)U(U(P)LL)" {_A_ 4 _U_ 2111 _N_ _N_ _N_ _N_} _N_ _N_ },
+ (/=) = { _A_ 2 _U_ 11 _N_ _S_ "U(U(P)LL)U(U(P)LL)" {_A_ 4 _U_ 2111 _N_ _N_ _N_ _N_} _N_ _N_ } #-}
instance (Ix a, Ix b, Ix c) => Ix (a, b, c)
{-# GHC_PRAGMA _M_ PreludeBuiltin {-dfun-} _A_ 4 _U_ 2222 _N_ _N_ _N_ _N_ #-}
instance (Ord a, Ord b, Ord c) => Ord (a, b, c)
{-# GHC_PRAGMA _M_ PreludeBuiltin {-dfun-} _A_ 4 _U_ 1112 _N_ _N_ _N_ _N_ #-}
+instance Ord (Int, Int, Int)
+ {-# GHC_PRAGMA _M_ PreludeBuiltin {-dfun-} _A_ 0 _N_ _N_ _N_ _F_ _IF_ARGS_ 0 0 X 9 _!_ _TUP_8 [{{Eq (Int, Int, Int)}}, ((Int, Int, Int) -> (Int, Int, Int) -> Bool), ((Int, Int, Int) -> (Int, Int, Int) -> Bool), ((Int, Int, Int) -> (Int, Int, Int) -> Bool), ((Int, Int, Int) -> (Int, Int, Int) -> Bool), ((Int, Int, Int) -> (Int, Int, Int) -> (Int, Int, Int)), ((Int, Int, Int) -> (Int, Int, Int) -> (Int, Int, Int)), ((Int, Int, Int) -> (Int, Int, Int) -> _CMP_TAG)] [_DFUN_ Eq ((Int, Int, Int)), _CONSTM_ Ord (<) ((Int, Int, Int)), _CONSTM_ Ord (<=) ((Int, Int, Int)), _CONSTM_ Ord (>=) ((Int, Int, Int)), _CONSTM_ Ord (>) ((Int, Int, Int)), _CONSTM_ Ord max ((Int, Int, Int)), _CONSTM_ Ord min ((Int, Int, Int)), _CONSTM_ Ord _tagCmp ((Int, Int, Int))] _N_
+ (<) = { _A_ 2 _U_ 11 _N_ _S_ "U(U(P)LL)U(U(P)LL)" {_A_ 4 _U_ 2111 _N_ _N_ _N_ _N_} _N_ _N_ },
+ (<=) = { _A_ 2 _U_ 11 _N_ _S_ "U(U(P)LL)U(U(P)LL)" {_A_ 4 _U_ 2111 _N_ _N_ _N_ _N_} _N_ _N_ },
+ (>=) = { _A_ 2 _U_ 11 _N_ _S_ "U(U(P)LL)U(U(P)LL)" {_A_ 4 _U_ 2111 _N_ _N_ _N_ _N_} _N_ _N_ },
+ (>) = { _A_ 2 _U_ 11 _N_ _S_ "U(U(P)LL)U(U(P)LL)" {_A_ 4 _U_ 2111 _N_ _N_ _N_ _N_} _N_ _N_ },
+ max = { _A_ 2 _U_ 12 _N_ _S_ "U(U(P)LL)U(U(P)LL)" {_A_ 4 _U_ 2222 _N_ _N_ _N_ _N_} _N_ _N_ },
+ min = { _A_ 2 _U_ 12 _N_ _S_ "U(U(P)LL)U(U(P)LL)" {_A_ 4 _U_ 2222 _N_ _N_ _N_ _N_} _N_ _N_ },
+ _tagCmp = { _A_ 2 _U_ 11 _N_ _S_ "U(U(P)LL)U(U(P)LL)" {_A_ 4 _U_ 2111 _N_ _N_ _N_ _N_} _N_ _N_ } #-}
instance (Text a, Text b, Text c) => Text (a, b, c)
{-# GHC_PRAGMA _M_ PreludeBuiltin {-dfun-} _A_ 3 _U_ 222 _N_ _N_ _N_ _N_ #-}
+instance Text (Int, Int, Int)
+ {-# GHC_PRAGMA _M_ PreludeBuiltin {-dfun-} _A_ 0 _N_ _N_ _N_ _F_ _IF_ARGS_ 0 0 X 5 _!_ _TUP_4 [(Int -> [Char] -> [((Int, Int, Int), [Char])]), (Int -> (Int, Int, Int) -> [Char] -> [Char]), ([Char] -> [([(Int, Int, Int)], [Char])]), ([(Int, Int, Int)] -> [Char] -> [Char])] [_CONSTM_ Text readsPrec ((Int, Int, Int)), _CONSTM_ Text showsPrec ((Int, Int, Int)), _CONSTM_ Text readList ((Int, Int, Int)), _CONSTM_ Text showList ((Int, Int, Int))] _N_
+ readsPrec = { _A_ 1 _U_ 02 _N_ _S_ "A" {_A_ 0 _U_ 2 _N_ _N_ _N_ _N_} _N_ _N_ },
+ showsPrec = { _A_ 3 _U_ 012 _N_ _S_ "AU(LLL)L" {_A_ 4 _U_ 1112 _N_ _N_ _N_ _N_} _N_ _N_ },
+ readList = { _A_ 0 _U_ 2 _N_ _N_ _N_ _N_ },
+ showList = { _A_ 1 _U_ 12 _N_ _N_ _N_ _N_ } #-}
-{-# GHC_PRAGMA INTERFACE VERSION 5 #-}
+{-# GHC_PRAGMA INTERFACE VERSION 6 #-}
interface PreludeBuiltin where
import PreludeCore(Eq(..), Ix(..), Ord(..), Text(..))
instance (Eq a, Eq b, Eq c, Eq d) => Eq (a, b, c, d)
{-# GHC_PRAGMA _M_ PreludeBuiltin {-dfun-} _A_ 4 _U_ 1111 _N_ _N_ _N_ _N_ #-}
+instance Eq (Int, Int, Int, Int)
+ {-# GHC_PRAGMA _M_ PreludeBuiltin {-dfun-} _A_ 0 _N_ _N_ _N_ _F_ _IF_ARGS_ 0 0 X 3 _!_ _TUP_2 [((Int, Int, Int, Int) -> (Int, Int, Int, Int) -> Bool), ((Int, Int, Int, Int) -> (Int, Int, Int, Int) -> Bool)] [_CONSTM_ Eq (==) ((Int, Int, Int, Int)), _CONSTM_ Eq (/=) ((Int, Int, Int, Int))] _N_
+ (==) = { _A_ 2 _U_ 11 _N_ _S_ "U(U(P)LLL)U(U(P)LLL)" {_A_ 5 _U_ 21111 _N_ _N_ _N_ _N_} _N_ _N_ },
+ (/=) = { _A_ 2 _U_ 11 _N_ _S_ "U(U(P)LLL)U(U(P)LLL)" {_A_ 5 _U_ 21111 _N_ _N_ _N_ _N_} _N_ _N_ } #-}
instance (Ix a, Ix b, Ix c, Ix d) => Ix (a, b, c, d)
{-# GHC_PRAGMA _M_ PreludeBuiltin {-dfun-} _A_ 5 _U_ 22222 _N_ _N_ _N_ _N_ #-}
instance (Ord a, Ord b, Ord c, Ord d) => Ord (a, b, c, d)
{-# GHC_PRAGMA _M_ PreludeBuiltin {-dfun-} _A_ 5 _U_ 11112 _N_ _N_ _N_ _N_ #-}
+instance Ord (Int, Int, Int, Int)
+ {-# GHC_PRAGMA _M_ PreludeBuiltin {-dfun-} _A_ 0 _N_ _N_ _N_ _F_ _IF_ARGS_ 0 0 X 9 _!_ _TUP_8 [{{Eq (Int, Int, Int, Int)}}, ((Int, Int, Int, Int) -> (Int, Int, Int, Int) -> Bool), ((Int, Int, Int, Int) -> (Int, Int, Int, Int) -> Bool), ((Int, Int, Int, Int) -> (Int, Int, Int, Int) -> Bool), ((Int, Int, Int, Int) -> (Int, Int, Int, Int) -> Bool), ((Int, Int, Int, Int) -> (Int, Int, Int, Int) -> (Int, Int, Int, Int)), ((Int, Int, Int, Int) -> (Int, Int, Int, Int) -> (Int, Int, Int, Int)), ((Int, Int, Int, Int) -> (Int, Int, Int, Int) -> _CMP_TAG)] [_DFUN_ Eq ((Int, Int, Int, Int)), _CONSTM_ Ord (<) ((Int, Int, Int, Int)), _CONSTM_ Ord (<=) ((Int, Int, Int, Int)), _CONSTM_ Ord (>=) ((Int, Int, Int, Int)), _CONSTM_ Ord (>) ((Int, Int, Int, Int)), _CONSTM_ Ord max ((Int, Int, Int, Int)), _CONSTM_ Ord min ((Int, Int, Int, Int)), _CONSTM_ Ord _tagCmp ((Int, Int, Int, Int))] _N_
+ (<) = { _A_ 2 _U_ 11 _N_ _S_ "U(U(P)LLL)U(U(P)LLL)" {_A_ 5 _U_ 21111 _N_ _N_ _N_ _N_} _N_ _N_ },
+ (<=) = { _A_ 2 _U_ 11 _N_ _S_ "U(U(P)LLL)U(U(P)LLL)" {_A_ 5 _U_ 21111 _N_ _N_ _N_ _N_} _N_ _N_ },
+ (>=) = { _A_ 2 _U_ 11 _N_ _S_ "U(U(P)LLL)U(U(P)LLL)" {_A_ 5 _U_ 21111 _N_ _N_ _N_ _N_} _N_ _N_ },
+ (>) = { _A_ 2 _U_ 11 _N_ _S_ "U(U(P)LLL)U(U(P)LLL)" {_A_ 5 _U_ 21111 _N_ _N_ _N_ _N_} _N_ _N_ },
+ max = { _A_ 2 _U_ 12 _N_ _S_ "U(U(P)LLL)U(U(P)LLL)" {_A_ 5 _U_ 22222 _N_ _N_ _N_ _N_} _N_ _N_ },
+ min = { _A_ 2 _U_ 12 _N_ _S_ "U(U(P)LLL)U(U(P)LLL)" {_A_ 5 _U_ 22222 _N_ _N_ _N_ _N_} _N_ _N_ },
+ _tagCmp = { _A_ 2 _U_ 11 _N_ _S_ "U(U(P)LLL)U(U(P)LLL)" {_A_ 5 _U_ 21111 _N_ _N_ _N_ _N_} _N_ _N_ } #-}
instance (Text a, Text b, Text c, Text d) => Text (a, b, c, d)
{-# GHC_PRAGMA _M_ PreludeBuiltin {-dfun-} _A_ 4 _U_ 2222 _N_ _N_ _N_ _N_ #-}
import Prel ( (&&), (.) )
import PS ( _PackedString, _unpackPS )
import Text
+import TyArray
+import TyComplex
instance (Eq a, Eq b, Eq c, Eq d) => Eq (a,b,c,d) where
(a1,a2,a3,a4) == (b1,b2,b3,b4) = a1 == b1 && a2 == b2 && a3 == b3 && a4 == b4
instance (Text a, Text b, Text c, Text d) => Text (a, b, c, d) where
readsPrec p = readParen False
(\a -> [((w,x,y,z), j) | ("(",b) <- lex a,
- (w,c) <- reads b,
+ (w,c) <- readsPrec 0 b,
(",",d) <- lex c,
- (x,e) <- reads d,
+ (x,e) <- readsPrec 0 d,
(",",f) <- lex e,
- (y,g) <- reads f,
+ (y,g) <- readsPrec 0 f,
(",",h) <- lex g,
- (z,i) <- reads h,
+ (z,i) <- readsPrec 0 h,
(")",j) <- lex i ] )
- showsPrec p (w,x,y,z) = showChar '(' . shows w . showString ", " .
- shows x . showString ", " .
- shows y . showString ", " .
- shows z . showChar ')'
+ showsPrec p (w,x,y,z) = showChar '(' . showsPrec 0 w . showString ", " .
+ showsPrec 0 x . showString ", " .
+ showsPrec 0 y . showString ", " .
+ showsPrec 0 z . showChar ')'
+
+ readList = _readList (readsPrec 0)
+ showList = _showList (showsPrec 0)
+
+{-# SPECIALIZE instance Eq (Int,Int,Int,Int) #-}
+{-# SPECIALIZE instance Ord (Int,Int,Int,Int) #-}
#if defined(__UNBOXED_INSTANCES__)
-{-# GHC_PRAGMA INTERFACE VERSION 5 #-}
+{-# GHC_PRAGMA INTERFACE VERSION 6 #-}
interface PreludeBuiltin where
import PreludeCore(Eq(..), Ix(..), Ord(..), Text(..))
instance (Eq a, Eq b, Eq c, Eq d) => Eq (a, b, c, d)
{-# GHC_PRAGMA _M_ PreludeBuiltin {-dfun-} _A_ 4 _U_ 1111 _N_ _N_ _N_ _N_ #-}
+instance Eq (Int, Int, Int, Int)
+ {-# GHC_PRAGMA _M_ PreludeBuiltin {-dfun-} _A_ 0 _N_ _N_ _N_ _F_ _IF_ARGS_ 0 0 X 3 _!_ _TUP_2 [((Int, Int, Int, Int) -> (Int, Int, Int, Int) -> Bool), ((Int, Int, Int, Int) -> (Int, Int, Int, Int) -> Bool)] [_CONSTM_ Eq (==) ((Int, Int, Int, Int)), _CONSTM_ Eq (/=) ((Int, Int, Int, Int))] _N_
+ (==) = { _A_ 2 _U_ 11 _N_ _S_ "U(U(P)LLL)U(U(P)LLL)" {_A_ 5 _U_ 21111 _N_ _N_ _N_ _N_} _N_ _N_ },
+ (/=) = { _A_ 2 _U_ 11 _N_ _S_ "U(U(P)LLL)U(U(P)LLL)" {_A_ 5 _U_ 21111 _N_ _N_ _N_ _N_} _N_ _N_ } #-}
instance (Ix a, Ix b, Ix c, Ix d) => Ix (a, b, c, d)
{-# GHC_PRAGMA _M_ PreludeBuiltin {-dfun-} _A_ 5 _U_ 22222 _N_ _N_ _N_ _N_ #-}
instance (Ord a, Ord b, Ord c, Ord d) => Ord (a, b, c, d)
{-# GHC_PRAGMA _M_ PreludeBuiltin {-dfun-} _A_ 5 _U_ 11112 _N_ _N_ _N_ _N_ #-}
+instance Ord (Int, Int, Int, Int)
+ {-# GHC_PRAGMA _M_ PreludeBuiltin {-dfun-} _A_ 0 _N_ _N_ _N_ _F_ _IF_ARGS_ 0 0 X 9 _!_ _TUP_8 [{{Eq (Int, Int, Int, Int)}}, ((Int, Int, Int, Int) -> (Int, Int, Int, Int) -> Bool), ((Int, Int, Int, Int) -> (Int, Int, Int, Int) -> Bool), ((Int, Int, Int, Int) -> (Int, Int, Int, Int) -> Bool), ((Int, Int, Int, Int) -> (Int, Int, Int, Int) -> Bool), ((Int, Int, Int, Int) -> (Int, Int, Int, Int) -> (Int, Int, Int, Int)), ((Int, Int, Int, Int) -> (Int, Int, Int, Int) -> (Int, Int, Int, Int)), ((Int, Int, Int, Int) -> (Int, Int, Int, Int) -> _CMP_TAG)] [_DFUN_ Eq ((Int, Int, Int, Int)), _CONSTM_ Ord (<) ((Int, Int, Int, Int)), _CONSTM_ Ord (<=) ((Int, Int, Int, Int)), _CONSTM_ Ord (>=) ((Int, Int, Int, Int)), _CONSTM_ Ord (>) ((Int, Int, Int, Int)), _CONSTM_ Ord max ((Int, Int, Int, Int)), _CONSTM_ Ord min ((Int, Int, Int, Int)), _CONSTM_ Ord _tagCmp ((Int, Int, Int, Int))] _N_
+ (<) = { _A_ 2 _U_ 11 _N_ _S_ "U(U(P)LLL)U(U(P)LLL)" {_A_ 5 _U_ 21111 _N_ _N_ _N_ _N_} _N_ _N_ },
+ (<=) = { _A_ 2 _U_ 11 _N_ _S_ "U(U(P)LLL)U(U(P)LLL)" {_A_ 5 _U_ 21111 _N_ _N_ _N_ _N_} _N_ _N_ },
+ (>=) = { _A_ 2 _U_ 11 _N_ _S_ "U(U(P)LLL)U(U(P)LLL)" {_A_ 5 _U_ 21111 _N_ _N_ _N_ _N_} _N_ _N_ },
+ (>) = { _A_ 2 _U_ 11 _N_ _S_ "U(U(P)LLL)U(U(P)LLL)" {_A_ 5 _U_ 21111 _N_ _N_ _N_ _N_} _N_ _N_ },
+ max = { _A_ 2 _U_ 12 _N_ _S_ "U(U(P)LLL)U(U(P)LLL)" {_A_ 5 _U_ 22222 _N_ _N_ _N_ _N_} _N_ _N_ },
+ min = { _A_ 2 _U_ 12 _N_ _S_ "U(U(P)LLL)U(U(P)LLL)" {_A_ 5 _U_ 22222 _N_ _N_ _N_ _N_} _N_ _N_ },
+ _tagCmp = { _A_ 2 _U_ 11 _N_ _S_ "U(U(P)LLL)U(U(P)LLL)" {_A_ 5 _U_ 21111 _N_ _N_ _N_ _N_} _N_ _N_ } #-}
instance (Text a, Text b, Text c, Text d) => Text (a, b, c, d)
{-# GHC_PRAGMA _M_ PreludeBuiltin {-dfun-} _A_ 4 _U_ 2222 _N_ _N_ _N_ _N_ #-}
-{-# GHC_PRAGMA INTERFACE VERSION 5 #-}
+{-# GHC_PRAGMA INTERFACE VERSION 6 #-}
interface PreludeBuiltin where
import PreludeCore(Eq(..), Ix(..), Ord(..), Text(..))
instance (Eq a, Eq b, Eq c, Eq d) => Eq (a, b, c, d)
{-# GHC_PRAGMA _M_ PreludeBuiltin {-dfun-} _A_ 4 _U_ 1111 _N_ _N_ _N_ _N_ #-}
+instance Eq (Int, Int, Int, Int)
+ {-# GHC_PRAGMA _M_ PreludeBuiltin {-dfun-} _A_ 0 _N_ _N_ _N_ _F_ _IF_ARGS_ 0 0 X 3 _!_ _TUP_2 [((Int, Int, Int, Int) -> (Int, Int, Int, Int) -> Bool), ((Int, Int, Int, Int) -> (Int, Int, Int, Int) -> Bool)] [_CONSTM_ Eq (==) ((Int, Int, Int, Int)), _CONSTM_ Eq (/=) ((Int, Int, Int, Int))] _N_
+ (==) = { _A_ 2 _U_ 11 _N_ _S_ "U(U(P)LLL)U(U(P)LLL)" {_A_ 5 _U_ 21111 _N_ _N_ _N_ _N_} _N_ _N_ },
+ (/=) = { _A_ 2 _U_ 11 _N_ _S_ "U(U(P)LLL)U(U(P)LLL)" {_A_ 5 _U_ 21111 _N_ _N_ _N_ _N_} _N_ _N_ } #-}
instance (Ix a, Ix b, Ix c, Ix d) => Ix (a, b, c, d)
{-# GHC_PRAGMA _M_ PreludeBuiltin {-dfun-} _A_ 5 _U_ 22222 _N_ _N_ _N_ _N_ #-}
instance (Ord a, Ord b, Ord c, Ord d) => Ord (a, b, c, d)
{-# GHC_PRAGMA _M_ PreludeBuiltin {-dfun-} _A_ 5 _U_ 11112 _N_ _N_ _N_ _N_ #-}
+instance Ord (Int, Int, Int, Int)
+ {-# GHC_PRAGMA _M_ PreludeBuiltin {-dfun-} _A_ 0 _N_ _N_ _N_ _F_ _IF_ARGS_ 0 0 X 9 _!_ _TUP_8 [{{Eq (Int, Int, Int, Int)}}, ((Int, Int, Int, Int) -> (Int, Int, Int, Int) -> Bool), ((Int, Int, Int, Int) -> (Int, Int, Int, Int) -> Bool), ((Int, Int, Int, Int) -> (Int, Int, Int, Int) -> Bool), ((Int, Int, Int, Int) -> (Int, Int, Int, Int) -> Bool), ((Int, Int, Int, Int) -> (Int, Int, Int, Int) -> (Int, Int, Int, Int)), ((Int, Int, Int, Int) -> (Int, Int, Int, Int) -> (Int, Int, Int, Int)), ((Int, Int, Int, Int) -> (Int, Int, Int, Int) -> _CMP_TAG)] [_DFUN_ Eq ((Int, Int, Int, Int)), _CONSTM_ Ord (<) ((Int, Int, Int, Int)), _CONSTM_ Ord (<=) ((Int, Int, Int, Int)), _CONSTM_ Ord (>=) ((Int, Int, Int, Int)), _CONSTM_ Ord (>) ((Int, Int, Int, Int)), _CONSTM_ Ord max ((Int, Int, Int, Int)), _CONSTM_ Ord min ((Int, Int, Int, Int)), _CONSTM_ Ord _tagCmp ((Int, Int, Int, Int))] _N_
+ (<) = { _A_ 2 _U_ 11 _N_ _S_ "U(U(P)LLL)U(U(P)LLL)" {_A_ 5 _U_ 21111 _N_ _N_ _N_ _N_} _N_ _N_ },
+ (<=) = { _A_ 2 _U_ 11 _N_ _S_ "U(U(P)LLL)U(U(P)LLL)" {_A_ 5 _U_ 21111 _N_ _N_ _N_ _N_} _N_ _N_ },
+ (>=) = { _A_ 2 _U_ 11 _N_ _S_ "U(U(P)LLL)U(U(P)LLL)" {_A_ 5 _U_ 21111 _N_ _N_ _N_ _N_} _N_ _N_ },
+ (>) = { _A_ 2 _U_ 11 _N_ _S_ "U(U(P)LLL)U(U(P)LLL)" {_A_ 5 _U_ 21111 _N_ _N_ _N_ _N_} _N_ _N_ },
+ max = { _A_ 2 _U_ 12 _N_ _S_ "U(U(P)LLL)U(U(P)LLL)" {_A_ 5 _U_ 22222 _N_ _N_ _N_ _N_} _N_ _N_ },
+ min = { _A_ 2 _U_ 12 _N_ _S_ "U(U(P)LLL)U(U(P)LLL)" {_A_ 5 _U_ 22222 _N_ _N_ _N_ _N_} _N_ _N_ },
+ _tagCmp = { _A_ 2 _U_ 11 _N_ _S_ "U(U(P)LLL)U(U(P)LLL)" {_A_ 5 _U_ 21111 _N_ _N_ _N_ _N_} _N_ _N_ } #-}
instance (Text a, Text b, Text c, Text d) => Text (a, b, c, d)
{-# GHC_PRAGMA _M_ PreludeBuiltin {-dfun-} _A_ 4 _U_ 2222 _N_ _N_ _N_ _N_ #-}
-{-# GHC_PRAGMA INTERFACE VERSION 5 #-}
+{-# GHC_PRAGMA INTERFACE VERSION 6 #-}
interface PreludeBuiltin where
import PreludeCore(Eq(..), Ix(..), Ord(..), Text(..))
instance (Eq a, Eq b, Eq c, Eq d) => Eq (a, b, c, d)
{-# GHC_PRAGMA _M_ PreludeBuiltin {-dfun-} _A_ 4 _U_ 1111 _N_ _N_ _N_ _N_ #-}
+instance Eq (Int, Int, Int, Int)
+ {-# GHC_PRAGMA _M_ PreludeBuiltin {-dfun-} _A_ 0 _N_ _N_ _N_ _F_ _IF_ARGS_ 0 0 X 3 _!_ _TUP_2 [((Int, Int, Int, Int) -> (Int, Int, Int, Int) -> Bool), ((Int, Int, Int, Int) -> (Int, Int, Int, Int) -> Bool)] [_CONSTM_ Eq (==) ((Int, Int, Int, Int)), _CONSTM_ Eq (/=) ((Int, Int, Int, Int))] _N_
+ (==) = { _A_ 2 _U_ 11 _N_ _S_ "U(U(P)LLL)U(U(P)LLL)" {_A_ 5 _U_ 21111 _N_ _N_ _N_ _N_} _N_ _N_ },
+ (/=) = { _A_ 2 _U_ 11 _N_ _S_ "U(U(P)LLL)U(U(P)LLL)" {_A_ 5 _U_ 21111 _N_ _N_ _N_ _N_} _N_ _N_ } #-}
instance (Ix a, Ix b, Ix c, Ix d) => Ix (a, b, c, d)
{-# GHC_PRAGMA _M_ PreludeBuiltin {-dfun-} _A_ 5 _U_ 22222 _N_ _N_ _N_ _N_ #-}
instance (Ord a, Ord b, Ord c, Ord d) => Ord (a, b, c, d)
{-# GHC_PRAGMA _M_ PreludeBuiltin {-dfun-} _A_ 5 _U_ 11112 _N_ _N_ _N_ _N_ #-}
+instance Ord (Int, Int, Int, Int)
+ {-# GHC_PRAGMA _M_ PreludeBuiltin {-dfun-} _A_ 0 _N_ _N_ _N_ _F_ _IF_ARGS_ 0 0 X 9 _!_ _TUP_8 [{{Eq (Int, Int, Int, Int)}}, ((Int, Int, Int, Int) -> (Int, Int, Int, Int) -> Bool), ((Int, Int, Int, Int) -> (Int, Int, Int, Int) -> Bool), ((Int, Int, Int, Int) -> (Int, Int, Int, Int) -> Bool), ((Int, Int, Int, Int) -> (Int, Int, Int, Int) -> Bool), ((Int, Int, Int, Int) -> (Int, Int, Int, Int) -> (Int, Int, Int, Int)), ((Int, Int, Int, Int) -> (Int, Int, Int, Int) -> (Int, Int, Int, Int)), ((Int, Int, Int, Int) -> (Int, Int, Int, Int) -> _CMP_TAG)] [_DFUN_ Eq ((Int, Int, Int, Int)), _CONSTM_ Ord (<) ((Int, Int, Int, Int)), _CONSTM_ Ord (<=) ((Int, Int, Int, Int)), _CONSTM_ Ord (>=) ((Int, Int, Int, Int)), _CONSTM_ Ord (>) ((Int, Int, Int, Int)), _CONSTM_ Ord max ((Int, Int, Int, Int)), _CONSTM_ Ord min ((Int, Int, Int, Int)), _CONSTM_ Ord _tagCmp ((Int, Int, Int, Int))] _N_
+ (<) = { _A_ 2 _U_ 11 _N_ _S_ "U(U(P)LLL)U(U(P)LLL)" {_A_ 5 _U_ 21111 _N_ _N_ _N_ _N_} _N_ _N_ },
+ (<=) = { _A_ 2 _U_ 11 _N_ _S_ "U(U(P)LLL)U(U(P)LLL)" {_A_ 5 _U_ 21111 _N_ _N_ _N_ _N_} _N_ _N_ },
+ (>=) = { _A_ 2 _U_ 11 _N_ _S_ "U(U(P)LLL)U(U(P)LLL)" {_A_ 5 _U_ 21111 _N_ _N_ _N_ _N_} _N_ _N_ },
+ (>) = { _A_ 2 _U_ 11 _N_ _S_ "U(U(P)LLL)U(U(P)LLL)" {_A_ 5 _U_ 21111 _N_ _N_ _N_ _N_} _N_ _N_ },
+ max = { _A_ 2 _U_ 12 _N_ _S_ "U(U(P)LLL)U(U(P)LLL)" {_A_ 5 _U_ 22222 _N_ _N_ _N_ _N_} _N_ _N_ },
+ min = { _A_ 2 _U_ 12 _N_ _S_ "U(U(P)LLL)U(U(P)LLL)" {_A_ 5 _U_ 22222 _N_ _N_ _N_ _N_} _N_ _N_ },
+ _tagCmp = { _A_ 2 _U_ 11 _N_ _S_ "U(U(P)LLL)U(U(P)LLL)" {_A_ 5 _U_ 21111 _N_ _N_ _N_ _N_} _N_ _N_ } #-}
instance (Text a, Text b, Text c, Text d) => Text (a, b, c, d)
{-# GHC_PRAGMA _M_ PreludeBuiltin {-dfun-} _A_ 4 _U_ 2222 _N_ _N_ _N_ _N_ #-}
-{-# GHC_PRAGMA INTERFACE VERSION 5 #-}
+{-# GHC_PRAGMA INTERFACE VERSION 6 #-}
interface PreludeBuiltin where
import PreludeCore(Eq(..), Ix(..), Ord(..), Text(..))
instance (Eq a, Eq b, Eq c, Eq d) => Eq (a, b, c, d)
{-# GHC_PRAGMA _M_ PreludeBuiltin {-dfun-} _A_ 4 _U_ 1111 _N_ _N_ _N_ _N_ #-}
+instance Eq (Int, Int, Int, Int)
+ {-# GHC_PRAGMA _M_ PreludeBuiltin {-dfun-} _A_ 0 _N_ _N_ _N_ _F_ _IF_ARGS_ 0 0 X 3 _!_ _TUP_2 [((Int, Int, Int, Int) -> (Int, Int, Int, Int) -> Bool), ((Int, Int, Int, Int) -> (Int, Int, Int, Int) -> Bool)] [_CONSTM_ Eq (==) ((Int, Int, Int, Int)), _CONSTM_ Eq (/=) ((Int, Int, Int, Int))] _N_
+ (==) = { _A_ 2 _U_ 11 _N_ _S_ "U(U(P)LLL)U(U(P)LLL)" {_A_ 5 _U_ 21111 _N_ _N_ _N_ _N_} _N_ _N_ },
+ (/=) = { _A_ 2 _U_ 11 _N_ _S_ "U(U(P)LLL)U(U(P)LLL)" {_A_ 5 _U_ 21111 _N_ _N_ _N_ _N_} _N_ _N_ } #-}
instance (Ix a, Ix b, Ix c, Ix d) => Ix (a, b, c, d)
{-# GHC_PRAGMA _M_ PreludeBuiltin {-dfun-} _A_ 5 _U_ 22222 _N_ _N_ _N_ _N_ #-}
instance (Ord a, Ord b, Ord c, Ord d) => Ord (a, b, c, d)
{-# GHC_PRAGMA _M_ PreludeBuiltin {-dfun-} _A_ 5 _U_ 11112 _N_ _N_ _N_ _N_ #-}
+instance Ord (Int, Int, Int, Int)
+ {-# GHC_PRAGMA _M_ PreludeBuiltin {-dfun-} _A_ 0 _N_ _N_ _N_ _F_ _IF_ARGS_ 0 0 X 9 _!_ _TUP_8 [{{Eq (Int, Int, Int, Int)}}, ((Int, Int, Int, Int) -> (Int, Int, Int, Int) -> Bool), ((Int, Int, Int, Int) -> (Int, Int, Int, Int) -> Bool), ((Int, Int, Int, Int) -> (Int, Int, Int, Int) -> Bool), ((Int, Int, Int, Int) -> (Int, Int, Int, Int) -> Bool), ((Int, Int, Int, Int) -> (Int, Int, Int, Int) -> (Int, Int, Int, Int)), ((Int, Int, Int, Int) -> (Int, Int, Int, Int) -> (Int, Int, Int, Int)), ((Int, Int, Int, Int) -> (Int, Int, Int, Int) -> _CMP_TAG)] [_DFUN_ Eq ((Int, Int, Int, Int)), _CONSTM_ Ord (<) ((Int, Int, Int, Int)), _CONSTM_ Ord (<=) ((Int, Int, Int, Int)), _CONSTM_ Ord (>=) ((Int, Int, Int, Int)), _CONSTM_ Ord (>) ((Int, Int, Int, Int)), _CONSTM_ Ord max ((Int, Int, Int, Int)), _CONSTM_ Ord min ((Int, Int, Int, Int)), _CONSTM_ Ord _tagCmp ((Int, Int, Int, Int))] _N_
+ (<) = { _A_ 2 _U_ 11 _N_ _S_ "U(U(P)LLL)U(U(P)LLL)" {_A_ 5 _U_ 21111 _N_ _N_ _N_ _N_} _N_ _N_ },
+ (<=) = { _A_ 2 _U_ 11 _N_ _S_ "U(U(P)LLL)U(U(P)LLL)" {_A_ 5 _U_ 21111 _N_ _N_ _N_ _N_} _N_ _N_ },
+ (>=) = { _A_ 2 _U_ 11 _N_ _S_ "U(U(P)LLL)U(U(P)LLL)" {_A_ 5 _U_ 21111 _N_ _N_ _N_ _N_} _N_ _N_ },
+ (>) = { _A_ 2 _U_ 11 _N_ _S_ "U(U(P)LLL)U(U(P)LLL)" {_A_ 5 _U_ 21111 _N_ _N_ _N_ _N_} _N_ _N_ },
+ max = { _A_ 2 _U_ 12 _N_ _S_ "U(U(P)LLL)U(U(P)LLL)" {_A_ 5 _U_ 22222 _N_ _N_ _N_ _N_} _N_ _N_ },
+ min = { _A_ 2 _U_ 12 _N_ _S_ "U(U(P)LLL)U(U(P)LLL)" {_A_ 5 _U_ 22222 _N_ _N_ _N_ _N_} _N_ _N_ },
+ _tagCmp = { _A_ 2 _U_ 11 _N_ _S_ "U(U(P)LLL)U(U(P)LLL)" {_A_ 5 _U_ 21111 _N_ _N_ _N_ _N_} _N_ _N_ } #-}
instance (Text a, Text b, Text c, Text d) => Text (a, b, c, d)
{-# GHC_PRAGMA _M_ PreludeBuiltin {-dfun-} _A_ 4 _U_ 2222 _N_ _N_ _N_ _N_ #-}
-{-# GHC_PRAGMA INTERFACE VERSION 5 #-}
+{-# GHC_PRAGMA INTERFACE VERSION 6 #-}
interface PreludeBuiltin where
import PreludeCore(Eq(..), Ix(..), Ord(..), Text(..))
instance (Eq a, Eq b, Eq c, Eq d, Eq e) => Eq (a, b, c, d, e)
{-# GHC_PRAGMA _M_ PreludeBuiltin {-dfun-} _A_ 5 _U_ 11111 _N_ _N_ _N_ _N_ #-}
+instance Eq (Int, Int, Int, Int, Int)
+ {-# GHC_PRAGMA _M_ PreludeBuiltin {-dfun-} _A_ 0 _N_ _N_ _N_ _F_ _IF_ARGS_ 0 0 X 3 _!_ _TUP_2 [((Int, Int, Int, Int, Int) -> (Int, Int, Int, Int, Int) -> Bool), ((Int, Int, Int, Int, Int) -> (Int, Int, Int, Int, Int) -> Bool)] [_CONSTM_ Eq (==) ((Int, Int, Int, Int, Int)), _CONSTM_ Eq (/=) ((Int, Int, Int, Int, Int))] _N_
+ (==) = { _A_ 2 _U_ 11 _N_ _S_ "U(U(P)LLLL)U(U(P)LLLL)" _N_ _N_ },
+ (/=) = { _A_ 2 _U_ 11 _N_ _S_ "U(U(P)LLLL)U(U(P)LLLL)" _N_ _N_ } #-}
instance (Ix a, Ix b, Ix c, Ix d, Ix e) => Ix (a, b, c, d, e)
{-# GHC_PRAGMA _M_ PreludeBuiltin {-dfun-} _A_ 6 _U_ 222222 _N_ _N_ _N_ _N_ #-}
instance (Ord a, Ord b, Ord c, Ord d, Ord e) => Ord (a, b, c, d, e)
{-# GHC_PRAGMA _M_ PreludeBuiltin {-dfun-} _A_ 6 _U_ 111112 _N_ _N_ _N_ _N_ #-}
+instance Ord (Int, Int, Int, Int, Int)
+ {-# GHC_PRAGMA _M_ PreludeBuiltin {-dfun-} _A_ 0 _N_ _N_ _N_ _F_ _IF_ARGS_ 0 0 X 9 _!_ _TUP_8 [{{Eq (Int, Int, Int, Int, Int)}}, ((Int, Int, Int, Int, Int) -> (Int, Int, Int, Int, Int) -> Bool), ((Int, Int, Int, Int, Int) -> (Int, Int, Int, Int, Int) -> Bool), ((Int, Int, Int, Int, Int) -> (Int, Int, Int, Int, Int) -> Bool), ((Int, Int, Int, Int, Int) -> (Int, Int, Int, Int, Int) -> Bool), ((Int, Int, Int, Int, Int) -> (Int, Int, Int, Int, Int) -> (Int, Int, Int, Int, Int)), ((Int, Int, Int, Int, Int) -> (Int, Int, Int, Int, Int) -> (Int, Int, Int, Int, Int)), ((Int, Int, Int, Int, Int) -> (Int, Int, Int, Int, Int) -> _CMP_TAG)] [_DFUN_ Eq ((Int, Int, Int, Int, Int)), _CONSTM_ Ord (<) ((Int, Int, Int, Int, Int)), _CONSTM_ Ord (<=) ((Int, Int, Int, Int, Int)), _CONSTM_ Ord (>=) ((Int, Int, Int, Int, Int)), _CONSTM_ Ord (>) ((Int, Int, Int, Int, Int)), _CONSTM_ Ord max ((Int, Int, Int, Int, Int)), _CONSTM_ Ord min ((Int, Int, Int, Int, Int)), _CONSTM_ Ord _tagCmp ((Int, Int, Int, Int, Int))] _N_
+ (<) = { _A_ 2 _U_ 11 _N_ _S_ "U(U(P)LLLL)U(U(P)LLLL)" _N_ _N_ },
+ (<=) = { _A_ 2 _U_ 11 _N_ _S_ "U(U(P)LLLL)U(U(P)LLLL)" _N_ _N_ },
+ (>=) = { _A_ 2 _U_ 11 _N_ _S_ "U(U(P)LLLL)U(U(P)LLLL)" _N_ _N_ },
+ (>) = { _A_ 2 _U_ 11 _N_ _S_ "U(U(P)LLLL)U(U(P)LLLL)" _N_ _N_ },
+ max = { _A_ 2 _U_ 22 _N_ _S_ "U(U(P)LLLL)U(U(P)LLLL)" _N_ _N_ },
+ min = { _A_ 2 _U_ 22 _N_ _S_ "U(U(P)LLLL)U(U(P)LLLL)" _N_ _N_ },
+ _tagCmp = { _A_ 2 _U_ 11 _N_ _S_ "U(U(P)LLLL)U(U(P)LLLL)" _N_ _N_ } #-}
instance (Text a, Text b, Text c, Text d, Text e) => Text (a, b, c, d, e)
{-# GHC_PRAGMA _M_ PreludeBuiltin {-dfun-} _A_ 5 _U_ 22222 _N_ _N_ _N_ _N_ #-}
import Prel ( (&&), (.) )
import PS ( _PackedString, _unpackPS )
import Text
+import TyArray
+import TyComplex
instance (Eq a, Eq b, Eq c, Eq d, Eq e) => Eq (a,b,c,d,e) where
(a1,a2,a3,a4,a5) == (b1,b2,b3,b4,b5) = a1 == b1 && a2 == b2 && a3 == b3 && a4 == b4 && a5 == b5
instance (Text a, Text b, Text c, Text d, Text e) => Text (a, b, c, d, e) where
readsPrec p = readParen False
(\a -> [((w,x,y,z,v), l) | ("(",b) <- lex a,
- (w,c) <- reads b,
+ (w,c) <- readsPrec 0 b,
(",",d) <- lex c,
- (x,e) <- reads d,
+ (x,e) <- readsPrec 0 d,
(",",f) <- lex e,
- (y,g) <- reads f,
+ (y,g) <- readsPrec 0 f,
(",",h) <- lex g,
- (z,i) <- reads h,
+ (z,i) <- readsPrec 0 h,
(",",j) <- lex i,
- (v,k) <- reads j,
+ (v,k) <- readsPrec 0 j,
(")",l) <- lex k ] )
- showsPrec p (v,w,x,y,z) = showChar '(' . shows v . showString ", " .
- shows w . showString ", " .
- shows x . showString ", " .
- shows y . showString ", " .
- shows z . showChar ')'
+ showsPrec p (v,w,x,y,z) = showChar '(' . showsPrec 0 v . showString ", " .
+ showsPrec 0 w . showString ", " .
+ showsPrec 0 x . showString ", " .
+ showsPrec 0 y . showString ", " .
+ showsPrec 0 z . showChar ')'
-#if defined(__UNBOXED_INSTANCES__)
+ readList = _readList (readsPrec 0)
+ showList = _showList (showsPrec 0)
--- We only create SPECIALIZED instances unboxed tuples
--- which have all the same unboxed component
--- {-# SPECIALIZE instance Eq (Char#,Char#,Char#,Char#,Char#) #-}
--- {-# SPECIALIZE instance Ord (Char#,Char#,Char#,Char#,Char#) #-}
--- {-# SPECIALIZE instance Ix (Char#,Char#,Char#,Char#,Char#) #-}
--- {-# SPECIALIZE instance Text (Char#,Char#,Char#,Char#,Char#) #-}
-
--- {-# SPECIALIZE instance Eq (Int#,Int#,Int#,Int#,Int#) #-}
--- {-# SPECIALIZE instance Ord (Int#,Int#,Int#,Int#,Int#) #-}
--- {-# SPECIALIZE instance Ix (Int#,Int#,Int#,Int#,Int#) #-}
--- {-# SPECIALIZE instance Text (Int#,Int#,Int#,Int#,Int#) #-}
-
--- {-# SPECIALIZE instance Eq (Double#,Double#,Double#,Double#,Double#) #-}
--- {-# SPECIALIZE instance Ord (Double#,Double#,Double#,Double#,Double#) #-}
--- {-# SPECIALIZE instance Text (Double#,Double#,Double#,Double#,Double#) #-}
-
-#endif
+{-# SPECIALIZE instance Eq (Int,Int,Int,Int,Int) #-}
+{-# SPECIALIZE instance Ord (Int,Int,Int,Int,Int) #-}
-{-# GHC_PRAGMA INTERFACE VERSION 5 #-}
+{-# GHC_PRAGMA INTERFACE VERSION 6 #-}
interface PreludeBuiltin where
import PreludeCore(Eq(..), Ix(..), Ord(..), Text(..))
instance (Eq a, Eq b, Eq c, Eq d, Eq e) => Eq (a, b, c, d, e)
{-# GHC_PRAGMA _M_ PreludeBuiltin {-dfun-} _A_ 5 _U_ 11111 _N_ _N_ _N_ _N_ #-}
+instance Eq (Int, Int, Int, Int, Int)
+ {-# GHC_PRAGMA _M_ PreludeBuiltin {-dfun-} _A_ 0 _N_ _N_ _N_ _F_ _IF_ARGS_ 0 0 X 3 _!_ _TUP_2 [((Int, Int, Int, Int, Int) -> (Int, Int, Int, Int, Int) -> Bool), ((Int, Int, Int, Int, Int) -> (Int, Int, Int, Int, Int) -> Bool)] [_CONSTM_ Eq (==) ((Int, Int, Int, Int, Int)), _CONSTM_ Eq (/=) ((Int, Int, Int, Int, Int))] _N_
+ (==) = { _A_ 2 _U_ 11 _N_ _S_ "U(U(P)LLLL)U(U(P)LLLL)" _N_ _N_ },
+ (/=) = { _A_ 2 _U_ 11 _N_ _S_ "U(U(P)LLLL)U(U(P)LLLL)" _N_ _N_ } #-}
instance (Ix a, Ix b, Ix c, Ix d, Ix e) => Ix (a, b, c, d, e)
{-# GHC_PRAGMA _M_ PreludeBuiltin {-dfun-} _A_ 6 _U_ 222222 _N_ _N_ _N_ _N_ #-}
instance (Ord a, Ord b, Ord c, Ord d, Ord e) => Ord (a, b, c, d, e)
{-# GHC_PRAGMA _M_ PreludeBuiltin {-dfun-} _A_ 6 _U_ 111112 _N_ _N_ _N_ _N_ #-}
+instance Ord (Int, Int, Int, Int, Int)
+ {-# GHC_PRAGMA _M_ PreludeBuiltin {-dfun-} _A_ 0 _N_ _N_ _N_ _F_ _IF_ARGS_ 0 0 X 9 _!_ _TUP_8 [{{Eq (Int, Int, Int, Int, Int)}}, ((Int, Int, Int, Int, Int) -> (Int, Int, Int, Int, Int) -> Bool), ((Int, Int, Int, Int, Int) -> (Int, Int, Int, Int, Int) -> Bool), ((Int, Int, Int, Int, Int) -> (Int, Int, Int, Int, Int) -> Bool), ((Int, Int, Int, Int, Int) -> (Int, Int, Int, Int, Int) -> Bool), ((Int, Int, Int, Int, Int) -> (Int, Int, Int, Int, Int) -> (Int, Int, Int, Int, Int)), ((Int, Int, Int, Int, Int) -> (Int, Int, Int, Int, Int) -> (Int, Int, Int, Int, Int)), ((Int, Int, Int, Int, Int) -> (Int, Int, Int, Int, Int) -> _CMP_TAG)] [_DFUN_ Eq ((Int, Int, Int, Int, Int)), _CONSTM_ Ord (<) ((Int, Int, Int, Int, Int)), _CONSTM_ Ord (<=) ((Int, Int, Int, Int, Int)), _CONSTM_ Ord (>=) ((Int, Int, Int, Int, Int)), _CONSTM_ Ord (>) ((Int, Int, Int, Int, Int)), _CONSTM_ Ord max ((Int, Int, Int, Int, Int)), _CONSTM_ Ord min ((Int, Int, Int, Int, Int)), _CONSTM_ Ord _tagCmp ((Int, Int, Int, Int, Int))] _N_
+ (<) = { _A_ 2 _U_ 11 _N_ _S_ "U(U(P)LLLL)U(U(P)LLLL)" _N_ _N_ },
+ (<=) = { _A_ 2 _U_ 11 _N_ _S_ "U(U(P)LLLL)U(U(P)LLLL)" _N_ _N_ },
+ (>=) = { _A_ 2 _U_ 11 _N_ _S_ "U(U(P)LLLL)U(U(P)LLLL)" _N_ _N_ },
+ (>) = { _A_ 2 _U_ 11 _N_ _S_ "U(U(P)LLLL)U(U(P)LLLL)" _N_ _N_ },
+ max = { _A_ 2 _U_ 22 _N_ _S_ "U(U(P)LLLL)U(U(P)LLLL)" _N_ _N_ },
+ min = { _A_ 2 _U_ 22 _N_ _S_ "U(U(P)LLLL)U(U(P)LLLL)" _N_ _N_ },
+ _tagCmp = { _A_ 2 _U_ 11 _N_ _S_ "U(U(P)LLLL)U(U(P)LLLL)" _N_ _N_ } #-}
instance (Text a, Text b, Text c, Text d, Text e) => Text (a, b, c, d, e)
{-# GHC_PRAGMA _M_ PreludeBuiltin {-dfun-} _A_ 5 _U_ 22222 _N_ _N_ _N_ _N_ #-}
-{-# GHC_PRAGMA INTERFACE VERSION 5 #-}
+{-# GHC_PRAGMA INTERFACE VERSION 6 #-}
interface PreludeBuiltin where
import PreludeCore(Eq(..), Ix(..), Ord(..), Text(..))
instance (Eq a, Eq b, Eq c, Eq d, Eq e) => Eq (a, b, c, d, e)
{-# GHC_PRAGMA _M_ PreludeBuiltin {-dfun-} _A_ 5 _U_ 11111 _N_ _N_ _N_ _N_ #-}
+instance Eq (Int, Int, Int, Int, Int)
+ {-# GHC_PRAGMA _M_ PreludeBuiltin {-dfun-} _A_ 0 _N_ _N_ _N_ _F_ _IF_ARGS_ 0 0 X 3 _!_ _TUP_2 [((Int, Int, Int, Int, Int) -> (Int, Int, Int, Int, Int) -> Bool), ((Int, Int, Int, Int, Int) -> (Int, Int, Int, Int, Int) -> Bool)] [_CONSTM_ Eq (==) ((Int, Int, Int, Int, Int)), _CONSTM_ Eq (/=) ((Int, Int, Int, Int, Int))] _N_
+ (==) = { _A_ 2 _U_ 11 _N_ _S_ "U(U(P)LLLL)U(U(P)LLLL)" _N_ _N_ },
+ (/=) = { _A_ 2 _U_ 11 _N_ _S_ "U(U(P)LLLL)U(U(P)LLLL)" _N_ _N_ } #-}
instance (Ix a, Ix b, Ix c, Ix d, Ix e) => Ix (a, b, c, d, e)
{-# GHC_PRAGMA _M_ PreludeBuiltin {-dfun-} _A_ 6 _U_ 222222 _N_ _N_ _N_ _N_ #-}
instance (Ord a, Ord b, Ord c, Ord d, Ord e) => Ord (a, b, c, d, e)
{-# GHC_PRAGMA _M_ PreludeBuiltin {-dfun-} _A_ 6 _U_ 111112 _N_ _N_ _N_ _N_ #-}
+instance Ord (Int, Int, Int, Int, Int)
+ {-# GHC_PRAGMA _M_ PreludeBuiltin {-dfun-} _A_ 0 _N_ _N_ _N_ _F_ _IF_ARGS_ 0 0 X 9 _!_ _TUP_8 [{{Eq (Int, Int, Int, Int, Int)}}, ((Int, Int, Int, Int, Int) -> (Int, Int, Int, Int, Int) -> Bool), ((Int, Int, Int, Int, Int) -> (Int, Int, Int, Int, Int) -> Bool), ((Int, Int, Int, Int, Int) -> (Int, Int, Int, Int, Int) -> Bool), ((Int, Int, Int, Int, Int) -> (Int, Int, Int, Int, Int) -> Bool), ((Int, Int, Int, Int, Int) -> (Int, Int, Int, Int, Int) -> (Int, Int, Int, Int, Int)), ((Int, Int, Int, Int, Int) -> (Int, Int, Int, Int, Int) -> (Int, Int, Int, Int, Int)), ((Int, Int, Int, Int, Int) -> (Int, Int, Int, Int, Int) -> _CMP_TAG)] [_DFUN_ Eq ((Int, Int, Int, Int, Int)), _CONSTM_ Ord (<) ((Int, Int, Int, Int, Int)), _CONSTM_ Ord (<=) ((Int, Int, Int, Int, Int)), _CONSTM_ Ord (>=) ((Int, Int, Int, Int, Int)), _CONSTM_ Ord (>) ((Int, Int, Int, Int, Int)), _CONSTM_ Ord max ((Int, Int, Int, Int, Int)), _CONSTM_ Ord min ((Int, Int, Int, Int, Int)), _CONSTM_ Ord _tagCmp ((Int, Int, Int, Int, Int))] _N_
+ (<) = { _A_ 2 _U_ 11 _N_ _S_ "U(U(P)LLLL)U(U(P)LLLL)" _N_ _N_ },
+ (<=) = { _A_ 2 _U_ 11 _N_ _S_ "U(U(P)LLLL)U(U(P)LLLL)" _N_ _N_ },
+ (>=) = { _A_ 2 _U_ 11 _N_ _S_ "U(U(P)LLLL)U(U(P)LLLL)" _N_ _N_ },
+ (>) = { _A_ 2 _U_ 11 _N_ _S_ "U(U(P)LLLL)U(U(P)LLLL)" _N_ _N_ },
+ max = { _A_ 2 _U_ 22 _N_ _S_ "U(U(P)LLLL)U(U(P)LLLL)" _N_ _N_ },
+ min = { _A_ 2 _U_ 22 _N_ _S_ "U(U(P)LLLL)U(U(P)LLLL)" _N_ _N_ },
+ _tagCmp = { _A_ 2 _U_ 11 _N_ _S_ "U(U(P)LLLL)U(U(P)LLLL)" _N_ _N_ } #-}
instance (Text a, Text b, Text c, Text d, Text e) => Text (a, b, c, d, e)
{-# GHC_PRAGMA _M_ PreludeBuiltin {-dfun-} _A_ 5 _U_ 22222 _N_ _N_ _N_ _N_ #-}
-{-# GHC_PRAGMA INTERFACE VERSION 5 #-}
+{-# GHC_PRAGMA INTERFACE VERSION 6 #-}
interface PreludeBuiltin where
import PreludeCore(Eq(..), Ix(..), Ord(..), Text(..))
instance (Eq a, Eq b, Eq c, Eq d, Eq e) => Eq (a, b, c, d, e)
{-# GHC_PRAGMA _M_ PreludeBuiltin {-dfun-} _A_ 5 _U_ 11111 _N_ _N_ _N_ _N_ #-}
+instance Eq (Int, Int, Int, Int, Int)
+ {-# GHC_PRAGMA _M_ PreludeBuiltin {-dfun-} _A_ 0 _N_ _N_ _N_ _F_ _IF_ARGS_ 0 0 X 3 _!_ _TUP_2 [((Int, Int, Int, Int, Int) -> (Int, Int, Int, Int, Int) -> Bool), ((Int, Int, Int, Int, Int) -> (Int, Int, Int, Int, Int) -> Bool)] [_CONSTM_ Eq (==) ((Int, Int, Int, Int, Int)), _CONSTM_ Eq (/=) ((Int, Int, Int, Int, Int))] _N_
+ (==) = { _A_ 2 _U_ 11 _N_ _S_ "U(U(P)LLLL)U(U(P)LLLL)" _N_ _N_ },
+ (/=) = { _A_ 2 _U_ 11 _N_ _S_ "U(U(P)LLLL)U(U(P)LLLL)" _N_ _N_ } #-}
instance (Ix a, Ix b, Ix c, Ix d, Ix e) => Ix (a, b, c, d, e)
{-# GHC_PRAGMA _M_ PreludeBuiltin {-dfun-} _A_ 6 _U_ 222222 _N_ _N_ _N_ _N_ #-}
instance (Ord a, Ord b, Ord c, Ord d, Ord e) => Ord (a, b, c, d, e)
{-# GHC_PRAGMA _M_ PreludeBuiltin {-dfun-} _A_ 6 _U_ 111112 _N_ _N_ _N_ _N_ #-}
+instance Ord (Int, Int, Int, Int, Int)
+ {-# GHC_PRAGMA _M_ PreludeBuiltin {-dfun-} _A_ 0 _N_ _N_ _N_ _F_ _IF_ARGS_ 0 0 X 9 _!_ _TUP_8 [{{Eq (Int, Int, Int, Int, Int)}}, ((Int, Int, Int, Int, Int) -> (Int, Int, Int, Int, Int) -> Bool), ((Int, Int, Int, Int, Int) -> (Int, Int, Int, Int, Int) -> Bool), ((Int, Int, Int, Int, Int) -> (Int, Int, Int, Int, Int) -> Bool), ((Int, Int, Int, Int, Int) -> (Int, Int, Int, Int, Int) -> Bool), ((Int, Int, Int, Int, Int) -> (Int, Int, Int, Int, Int) -> (Int, Int, Int, Int, Int)), ((Int, Int, Int, Int, Int) -> (Int, Int, Int, Int, Int) -> (Int, Int, Int, Int, Int)), ((Int, Int, Int, Int, Int) -> (Int, Int, Int, Int, Int) -> _CMP_TAG)] [_DFUN_ Eq ((Int, Int, Int, Int, Int)), _CONSTM_ Ord (<) ((Int, Int, Int, Int, Int)), _CONSTM_ Ord (<=) ((Int, Int, Int, Int, Int)), _CONSTM_ Ord (>=) ((Int, Int, Int, Int, Int)), _CONSTM_ Ord (>) ((Int, Int, Int, Int, Int)), _CONSTM_ Ord max ((Int, Int, Int, Int, Int)), _CONSTM_ Ord min ((Int, Int, Int, Int, Int)), _CONSTM_ Ord _tagCmp ((Int, Int, Int, Int, Int))] _N_
+ (<) = { _A_ 2 _U_ 11 _N_ _S_ "U(U(P)LLLL)U(U(P)LLLL)" _N_ _N_ },
+ (<=) = { _A_ 2 _U_ 11 _N_ _S_ "U(U(P)LLLL)U(U(P)LLLL)" _N_ _N_ },
+ (>=) = { _A_ 2 _U_ 11 _N_ _S_ "U(U(P)LLLL)U(U(P)LLLL)" _N_ _N_ },
+ (>) = { _A_ 2 _U_ 11 _N_ _S_ "U(U(P)LLLL)U(U(P)LLLL)" _N_ _N_ },
+ max = { _A_ 2 _U_ 22 _N_ _S_ "U(U(P)LLLL)U(U(P)LLLL)" _N_ _N_ },
+ min = { _A_ 2 _U_ 22 _N_ _S_ "U(U(P)LLLL)U(U(P)LLLL)" _N_ _N_ },
+ _tagCmp = { _A_ 2 _U_ 11 _N_ _S_ "U(U(P)LLLL)U(U(P)LLLL)" _N_ _N_ } #-}
instance (Text a, Text b, Text c, Text d, Text e) => Text (a, b, c, d, e)
{-# GHC_PRAGMA _M_ PreludeBuiltin {-dfun-} _A_ 5 _U_ 22222 _N_ _N_ _N_ _N_ #-}
-{-# GHC_PRAGMA INTERFACE VERSION 5 #-}
+{-# GHC_PRAGMA INTERFACE VERSION 6 #-}
interface PreludeBuiltin where
import PreludeCore(Eq(..), Ix(..), Ord(..), Text(..))
instance (Eq a, Eq b, Eq c, Eq d, Eq e) => Eq (a, b, c, d, e)
{-# GHC_PRAGMA _M_ PreludeBuiltin {-dfun-} _A_ 5 _U_ 11111 _N_ _N_ _N_ _N_ #-}
+instance Eq (Int, Int, Int, Int, Int)
+ {-# GHC_PRAGMA _M_ PreludeBuiltin {-dfun-} _A_ 0 _N_ _N_ _N_ _F_ _IF_ARGS_ 0 0 X 3 _!_ _TUP_2 [((Int, Int, Int, Int, Int) -> (Int, Int, Int, Int, Int) -> Bool), ((Int, Int, Int, Int, Int) -> (Int, Int, Int, Int, Int) -> Bool)] [_CONSTM_ Eq (==) ((Int, Int, Int, Int, Int)), _CONSTM_ Eq (/=) ((Int, Int, Int, Int, Int))] _N_
+ (==) = { _A_ 2 _U_ 11 _N_ _S_ "U(U(P)LLLL)U(U(P)LLLL)" _N_ _N_ },
+ (/=) = { _A_ 2 _U_ 11 _N_ _S_ "U(U(P)LLLL)U(U(P)LLLL)" _N_ _N_ } #-}
instance (Ix a, Ix b, Ix c, Ix d, Ix e) => Ix (a, b, c, d, e)
{-# GHC_PRAGMA _M_ PreludeBuiltin {-dfun-} _A_ 6 _U_ 222222 _N_ _N_ _N_ _N_ #-}
instance (Ord a, Ord b, Ord c, Ord d, Ord e) => Ord (a, b, c, d, e)
{-# GHC_PRAGMA _M_ PreludeBuiltin {-dfun-} _A_ 6 _U_ 111112 _N_ _N_ _N_ _N_ #-}
+instance Ord (Int, Int, Int, Int, Int)
+ {-# GHC_PRAGMA _M_ PreludeBuiltin {-dfun-} _A_ 0 _N_ _N_ _N_ _F_ _IF_ARGS_ 0 0 X 9 _!_ _TUP_8 [{{Eq (Int, Int, Int, Int, Int)}}, ((Int, Int, Int, Int, Int) -> (Int, Int, Int, Int, Int) -> Bool), ((Int, Int, Int, Int, Int) -> (Int, Int, Int, Int, Int) -> Bool), ((Int, Int, Int, Int, Int) -> (Int, Int, Int, Int, Int) -> Bool), ((Int, Int, Int, Int, Int) -> (Int, Int, Int, Int, Int) -> Bool), ((Int, Int, Int, Int, Int) -> (Int, Int, Int, Int, Int) -> (Int, Int, Int, Int, Int)), ((Int, Int, Int, Int, Int) -> (Int, Int, Int, Int, Int) -> (Int, Int, Int, Int, Int)), ((Int, Int, Int, Int, Int) -> (Int, Int, Int, Int, Int) -> _CMP_TAG)] [_DFUN_ Eq ((Int, Int, Int, Int, Int)), _CONSTM_ Ord (<) ((Int, Int, Int, Int, Int)), _CONSTM_ Ord (<=) ((Int, Int, Int, Int, Int)), _CONSTM_ Ord (>=) ((Int, Int, Int, Int, Int)), _CONSTM_ Ord (>) ((Int, Int, Int, Int, Int)), _CONSTM_ Ord max ((Int, Int, Int, Int, Int)), _CONSTM_ Ord min ((Int, Int, Int, Int, Int)), _CONSTM_ Ord _tagCmp ((Int, Int, Int, Int, Int))] _N_
+ (<) = { _A_ 2 _U_ 11 _N_ _S_ "U(U(P)LLLL)U(U(P)LLLL)" _N_ _N_ },
+ (<=) = { _A_ 2 _U_ 11 _N_ _S_ "U(U(P)LLLL)U(U(P)LLLL)" _N_ _N_ },
+ (>=) = { _A_ 2 _U_ 11 _N_ _S_ "U(U(P)LLLL)U(U(P)LLLL)" _N_ _N_ },
+ (>) = { _A_ 2 _U_ 11 _N_ _S_ "U(U(P)LLLL)U(U(P)LLLL)" _N_ _N_ },
+ max = { _A_ 2 _U_ 22 _N_ _S_ "U(U(P)LLLL)U(U(P)LLLL)" _N_ _N_ },
+ min = { _A_ 2 _U_ 22 _N_ _S_ "U(U(P)LLLL)U(U(P)LLLL)" _N_ _N_ },
+ _tagCmp = { _A_ 2 _U_ 11 _N_ _S_ "U(U(P)LLLL)U(U(P)LLLL)" _N_ _N_ } #-}
instance (Text a, Text b, Text c, Text d, Text e) => Text (a, b, c, d, e)
{-# GHC_PRAGMA _M_ PreludeBuiltin {-dfun-} _A_ 5 _U_ 22222 _N_ _N_ _N_ _N_ #-}
-{-# GHC_PRAGMA INTERFACE VERSION 5 #-}
+{-# GHC_PRAGMA INTERFACE VERSION 6 #-}
interface PreludeList where
import PreludeBuiltin(Char(..), Int(..), List(..), Tuple2, Tuple3, Tuple4, Tuple5, Tuple6, Tuple7)
import PreludeCore(Bool(..), Eq(..), Integral(..), Num(..), Ord(..))
(++) :: [a] -> [a] -> [a]
{-# GHC_PRAGMA _A_ 2 _U_ 12 _N_ _S_ "SL" _N_ _N_ #-}
(\\) :: Eq a => [a] -> [a] -> [a]
- {-# GHC_PRAGMA _A_ 3 _U_ 122 _N_ _S_ "LLS" _N_ _N_ #-}
+ {-# GHC_PRAGMA _A_ 3 _U_ 122 _N_ _S_ "LLS" _N_ _SPECIALISE_ [ Int ] 1 { _A_ 2 _U_ 22 _N_ _S_ "LS" _N_ _N_ }, [ [Char] ] 1 { _A_ 2 _U_ 22 _N_ _S_ "LS" _N_ _N_ } #-}
all :: (a -> Bool) -> [a] -> Bool
{-# GHC_PRAGMA _A_ 2 _U_ 21 _N_ _S_ "LS" _F_ _ALWAYS_ _/\_ u0 -> \ (u1 :: u0 -> Bool) (u2 :: [u0]) -> let {(u3 :: Bool) = _!_ True [] []} in let {(u6 :: u0 -> Bool -> Bool) = \ (u4 :: u0) (u5 :: Bool) -> case _APP_ u1 [ u4 ] of { _ALG_ True -> u5; False -> _!_ False [] []; _NO_DEFLT_ }} in _APP_ _TYAPP_ _TYAPP_ foldr { u0 } { Bool } [ u6, u3, u2 ] _N_ #-}
and :: [Bool] -> Bool
dropWhile :: (a -> Bool) -> [a] -> [a]
{-# GHC_PRAGMA _A_ 2 _U_ 21 _N_ _S_ "LS" _N_ _N_ #-}
elem :: Eq a => a -> [a] -> Bool
- {-# GHC_PRAGMA _A_ 3 _U_ 121 _N_ _S_ "LLS" _F_ _ALWAYS_ _/\_ u0 -> \ (u1 :: {{Eq u0}}) (u2 :: u0) (u3 :: [u0]) -> let {(u6 :: u0 -> u0 -> Bool) = case u1 of { _ALG_ _TUP_2 (u4 :: u0 -> u0 -> Bool) (u5 :: u0 -> u0 -> Bool) -> u4; _NO_DEFLT_ }} in let {(u8 :: u0 -> Bool) = \ (u7 :: u0) -> _APP_ u6 [ u2, u7 ]} in _APP_ _TYAPP_ _ORIG_ PreludeList any { u0 } [ u8, u3 ] _SPECIALISE_ [ Char ] 1 { _A_ 2 _U_ 21 _N_ _S_ "LS" _F_ _ALWAYS_ \ (u0 :: Char) (u1 :: [Char]) -> let {(u5 :: Char -> Bool) = \ (u2 :: Char) -> case u0 of { _ALG_ C# (u3 :: Char#) -> case u2 of { _ALG_ C# (u4 :: Char#) -> _#_ eqChar# [] [u3, u4]; _NO_DEFLT_ }; _NO_DEFLT_ }} in _APP_ _TYAPP_ _ORIG_ PreludeList any { Char } [ u5, u1 ] _N_ }, [ Int ] 1 { _A_ 2 _U_ 21 _N_ _S_ "LS" _F_ _ALWAYS_ \ (u0 :: Int) (u1 :: [Int]) -> let {(u5 :: Int -> Bool) = \ (u2 :: Int) -> case u0 of { _ALG_ I# (u3 :: Int#) -> case u2 of { _ALG_ I# (u4 :: Int#) -> _#_ eqInt# [] [u3, u4]; _NO_DEFLT_ }; _NO_DEFLT_ }} in _APP_ _TYAPP_ _ORIG_ PreludeList any { Int } [ u5, u1 ] _N_ }, [ [Char] ] 1 { _A_ 2 _U_ 21 _N_ _S_ "LS" _F_ _ALWAYS_ \ (u0 :: [Char]) (u1 :: [[Char]]) -> let {(u3 :: [Char] -> Bool) = \ (u2 :: [Char]) -> _APP_ _CONSTM_ Eq (==) ([Char]) [ u0, u2 ]} in _APP_ _TYAPP_ _ORIG_ PreludeList any { [Char] } [ u3, u1 ] _N_ } #-}
+ {-# GHC_PRAGMA _A_ 3 _U_ 121 _N_ _S_ "LLS" _F_ _ALWAYS_ _/\_ u0 -> \ (u1 :: {{Eq u0}}) (u2 :: u0) (u3 :: [u0]) -> let {(u6 :: u0 -> u0 -> Bool) = case u1 of { _ALG_ _TUP_2 (u4 :: u0 -> u0 -> Bool) (u5 :: u0 -> u0 -> Bool) -> u4; _NO_DEFLT_ }} in let {(u8 :: u0 -> Bool) = \ (u7 :: u0) -> _APP_ u6 [ u2, u7 ]} in _APP_ _TYAPP_ _ORIG_ PreludeList any { u0 } [ u8, u3 ] _SPECIALISE_ [ Char ] 1 { _A_ 2 _U_ 21 _N_ _S_ "LS" _F_ _ALWAYS_ \ (u0 :: Char) (u1 :: [Char]) -> let {(u5 :: Char -> Bool) = \ (u2 :: Char) -> case u0 of { _ALG_ C# (u3 :: Char#) -> case u2 of { _ALG_ C# (u4 :: Char#) -> _#_ eqChar# [] [u3, u4]; _NO_DEFLT_ }; _NO_DEFLT_ }} in _APP_ _TYAPP_ _ORIG_ PreludeList any { Char } [ u5, u1 ] _N_ }, [ Int ] 1 { _A_ 2 _U_ 21 _N_ _S_ "LS" _F_ _ALWAYS_ \ (u0 :: Int) (u1 :: [Int]) -> let {(u5 :: Int -> Bool) = \ (u2 :: Int) -> case u0 of { _ALG_ I# (u3 :: Int#) -> case u2 of { _ALG_ I# (u4 :: Int#) -> _#_ eqInt# [] [u3, u4]; _NO_DEFLT_ }; _NO_DEFLT_ }} in _APP_ _TYAPP_ _ORIG_ PreludeList any { Int } [ u5, u1 ] _N_ }, [ Integer ] 1 { _A_ 2 _U_ 21 _N_ _S_ "LS" _F_ _ALWAYS_ \ (u0 :: Integer) (u1 :: [Integer]) -> let {(ua :: Integer -> Bool) = \ (u2 :: Integer) -> case u0 of { _ALG_ J# (u3 :: Int#) (u4 :: Int#) (u5 :: ByteArray#) -> case u2 of { _ALG_ J# (u6 :: Int#) (u7 :: Int#) (u8 :: ByteArray#) -> case _#_ cmpInteger# [] [u3, u4, u5, u6, u7, u8] of { _PRIM_ 0# -> _!_ True [] []; (u9 :: Int#) -> _!_ False [] [] }; _NO_DEFLT_ }; _NO_DEFLT_ }} in _APP_ _TYAPP_ _ORIG_ PreludeList any { Integer } [ ua, u1 ] _N_ }, [ [Char] ] 1 { _A_ 2 _U_ 21 _N_ _S_ "LS" _F_ _ALWAYS_ \ (u0 :: [Char]) (u1 :: [[Char]]) -> let {(u3 :: [Char] -> Bool) = \ (u2 :: [Char]) -> _APP_ _CONSTM_ Eq (==) ([Char]) [ u0, u2 ]} in _APP_ _TYAPP_ _ORIG_ PreludeList any { [Char] } [ u3, u1 ] _N_ }, [ [Int] ] 1 { _A_ 2 _U_ 21 _N_ _S_ "LS" _F_ _ALWAYS_ \ (u0 :: [Int]) (u1 :: [[Int]]) -> let {(u3 :: [Int] -> Bool) = \ (u2 :: [Int]) -> _APP_ _CONSTM_ Eq (==) ([Int]) [ u0, u2 ]} in _APP_ _TYAPP_ _ORIG_ PreludeList any { [Int] } [ u3, u1 ] _N_ }, [ (Int, Int) ] 1 { _A_ 2 _U_ 21 _N_ _S_ "LS" _F_ _ALWAYS_ \ (u0 :: (Int, Int)) (u1 :: [(Int, Int)]) -> let {(ub :: (Int, Int) -> Bool) = \ (u2 :: (Int, Int)) -> case u0 of { _ALG_ _TUP_2 (u3 :: Int) (u4 :: Int) -> case u3 of { _ALG_ I# (u5 :: Int#) -> case u2 of { _ALG_ _TUP_2 (u6 :: Int) (u7 :: Int) -> case u6 of { _ALG_ I# (u8 :: Int#) -> case _#_ eqInt# [] [u5, u8] of { _ALG_ True -> case u4 of { _ALG_ I# (u9 :: Int#) -> case u7 of { _ALG_ I# (ua :: Int#) -> _#_ eqInt# [] [u9, ua]; _NO_DEFLT_ }; _NO_DEFLT_ }; False -> _!_ False [] []; _NO_DEFLT_ }; _NO_DEFLT_ }; _NO_DEFLT_ }; _NO_DEFLT_ }; _NO_DEFLT_ }} in _APP_ _TYAPP_ _ORIG_ PreludeList any { (Int, Int) } [ ub, u1 ] _N_ } #-}
filter :: (a -> Bool) -> [a] -> [a]
{-# GHC_PRAGMA _A_ 2 _U_ 21 _N_ _S_ "LS" _F_ _ALWAYS_ _/\_ u0 -> \ (u1 :: u0 -> Bool) (u2 :: [u0]) -> let {(u9 :: _forall_ a$z1 =>(u0 -> a$z1 -> a$z1) -> a$z1 -> a$z1) = _/\_ u3 -> \ (u4 :: u0 -> u3 -> u3) (u5 :: u3) -> let {(u8 :: u0 -> u3 -> u3) = \ (u6 :: u0) (u7 :: u3) -> case _APP_ u1 [ u6 ] of { _ALG_ True -> _APP_ u4 [ u6, u7 ]; False -> u7; _NO_DEFLT_ }} in _APP_ _TYAPP_ _TYAPP_ foldr { u0 } { u3 } [ u8, u5, u2 ]} in _APP_ _TYAPP_ _build { u0 } [ u9 ] _N_ #-}
foldl1 :: (a -> a -> a) -> [a] -> a
foldr1 :: (a -> a -> a) -> [a] -> a
{-# GHC_PRAGMA _A_ 2 _U_ 21 _N_ _S_ "LS" _N_ _N_ #-}
genericLength :: Num b => [a] -> b
- {-# GHC_PRAGMA _A_ 1 _U_ 21 _N_ _N_ _N_ _N_ #-}
+ {-# GHC_PRAGMA _A_ 1 _U_ 21 _N_ _N_ _N_ _SPECIALISE_ [ _N_, Int ] 1 { _A_ 1 _U_ 1 _N_ _S_ "S" _N_ _N_ }, [ _N_, Integer ] 1 { _A_ 1 _U_ 1 _N_ _S_ "S" _N_ _N_ } #-}
head :: [a] -> a
{-# GHC_PRAGMA _A_ 1 _U_ 1 _N_ _S_ "S" _F_ _ALWAYS_ _/\_ u0 -> \ (u1 :: [u0]) -> let {(u2 :: u0) = _APP_ _TYAPP_ error { u0 } [ _NOREP_S_ "head{PreludeList}: head []\n" ]} in let {(u5 :: u0 -> u0 -> u0) = \ (u3 :: u0) (u4 :: u0) -> u3} in _APP_ _TYAPP_ _TYAPP_ foldr { u0 } { u0 } [ u5, u2, u1 ] _N_ #-}
init :: [a] -> [a]
map :: (a -> b) -> [a] -> [b]
{-# GHC_PRAGMA _A_ 2 _U_ 21 _N_ _S_ "LS" _F_ _ALWAYS_ _/\_ u0 u1 -> \ (u2 :: u0 -> u1) (u3 :: [u0]) -> let {(ua :: _forall_ a$z1 =>(u1 -> a$z1 -> a$z1) -> a$z1 -> a$z1) = _/\_ u4 -> \ (u5 :: u1 -> u4 -> u4) (u6 :: u4) -> let {(u9 :: u0 -> u4 -> u4) = \ (u7 :: u0) -> let {(u8 :: u1) = _APP_ u2 [ u7 ]} in _APP_ u5 [ u8 ]} in _APP_ _TYAPP_ _TYAPP_ foldr { u0 } { u4 } [ u9, u6, u3 ]} in _APP_ _TYAPP_ _build { u1 } [ ua ] _N_ #-}
maximum :: Ord a => [a] -> a
- {-# GHC_PRAGMA _A_ 1 _U_ 11 _N_ _N_ _N_ _N_ #-}
+ {-# GHC_PRAGMA _A_ 1 _U_ 11 _N_ _N_ _N_ _SPECIALISE_ [ Double ] 1 { _A_ 1 _U_ 1 _N_ _S_ "S" _N_ _N_ }, [ Int ] 1 { _A_ 1 _U_ 1 _N_ _S_ "S" _N_ _N_ }, [ Integer ] 1 { _A_ 1 _U_ 1 _N_ _S_ "S" _N_ _N_ } #-}
minimum :: Ord a => [a] -> a
- {-# GHC_PRAGMA _A_ 1 _U_ 11 _N_ _N_ _N_ _N_ #-}
+ {-# GHC_PRAGMA _A_ 1 _U_ 11 _N_ _N_ _N_ _SPECIALISE_ [ Double ] 1 { _A_ 1 _U_ 1 _N_ _S_ "S" _N_ _N_ }, [ Int ] 1 { _A_ 1 _U_ 1 _N_ _S_ "S" _N_ _N_ }, [ Integer ] 1 { _A_ 1 _U_ 1 _N_ _S_ "S" _N_ _N_ } #-}
notElem :: Eq a => a -> [a] -> Bool
- {-# GHC_PRAGMA _A_ 3 _U_ 121 _N_ _S_ "LLS" _F_ _ALWAYS_ _/\_ u0 -> \ (u1 :: {{Eq u0}}) (u2 :: u0) (u3 :: [u0]) -> let {(u6 :: u0 -> u0 -> Bool) = case u1 of { _ALG_ _TUP_2 (u4 :: u0 -> u0 -> Bool) (u5 :: u0 -> u0 -> Bool) -> u5; _NO_DEFLT_ }} in let {(u8 :: u0 -> Bool) = \ (u7 :: u0) -> _APP_ u6 [ u2, u7 ]} in _APP_ _TYAPP_ _ORIG_ PreludeList all { u0 } [ u8, u3 ] _SPECIALISE_ [ Char ] 1 { _A_ 2 _U_ 21 _N_ _S_ "LS" _F_ _ALWAYS_ \ (u0 :: Char) (u1 :: [Char]) -> let {(u5 :: Char -> Bool) = \ (u2 :: Char) -> case u0 of { _ALG_ C# (u3 :: Char#) -> case u2 of { _ALG_ C# (u4 :: Char#) -> _#_ neChar# [] [u3, u4]; _NO_DEFLT_ }; _NO_DEFLT_ }} in _APP_ _TYAPP_ _ORIG_ PreludeList all { Char } [ u5, u1 ] _N_ }, [ Int ] 1 { _A_ 2 _U_ 21 _N_ _S_ "LS" _F_ _ALWAYS_ \ (u0 :: Int) (u1 :: [Int]) -> let {(u5 :: Int -> Bool) = \ (u2 :: Int) -> case u0 of { _ALG_ I# (u3 :: Int#) -> case u2 of { _ALG_ I# (u4 :: Int#) -> _#_ neInt# [] [u3, u4]; _NO_DEFLT_ }; _NO_DEFLT_ }} in _APP_ _TYAPP_ _ORIG_ PreludeList all { Int } [ u5, u1 ] _N_ }, [ [Char] ] 1 { _A_ 2 _U_ 21 _N_ _S_ "LS" _F_ _ALWAYS_ \ (u0 :: [Char]) (u1 :: [[Char]]) -> let {(u3 :: [Char] -> Bool) = \ (u2 :: [Char]) -> _APP_ _CONSTM_ Eq (/=) ([Char]) [ u0, u2 ]} in _APP_ _TYAPP_ _ORIG_ PreludeList all { [Char] } [ u3, u1 ] _N_ } #-}
+ {-# GHC_PRAGMA _A_ 3 _U_ 121 _N_ _S_ "LLS" _F_ _ALWAYS_ _/\_ u0 -> \ (u1 :: {{Eq u0}}) (u2 :: u0) (u3 :: [u0]) -> let {(u6 :: u0 -> u0 -> Bool) = case u1 of { _ALG_ _TUP_2 (u4 :: u0 -> u0 -> Bool) (u5 :: u0 -> u0 -> Bool) -> u5; _NO_DEFLT_ }} in let {(u8 :: u0 -> Bool) = \ (u7 :: u0) -> _APP_ u6 [ u2, u7 ]} in _APP_ _TYAPP_ _ORIG_ PreludeList all { u0 } [ u8, u3 ] _SPECIALISE_ [ Char ] 1 { _A_ 2 _U_ 21 _N_ _S_ "LS" _F_ _ALWAYS_ \ (u0 :: Char) (u1 :: [Char]) -> let {(u5 :: Char -> Bool) = \ (u2 :: Char) -> case u0 of { _ALG_ C# (u3 :: Char#) -> case u2 of { _ALG_ C# (u4 :: Char#) -> _#_ neChar# [] [u3, u4]; _NO_DEFLT_ }; _NO_DEFLT_ }} in _APP_ _TYAPP_ _ORIG_ PreludeList all { Char } [ u5, u1 ] _N_ }, [ Int ] 1 { _A_ 2 _U_ 21 _N_ _S_ "LS" _F_ _ALWAYS_ \ (u0 :: Int) (u1 :: [Int]) -> let {(u5 :: Int -> Bool) = \ (u2 :: Int) -> case u0 of { _ALG_ I# (u3 :: Int#) -> case u2 of { _ALG_ I# (u4 :: Int#) -> _#_ neInt# [] [u3, u4]; _NO_DEFLT_ }; _NO_DEFLT_ }} in _APP_ _TYAPP_ _ORIG_ PreludeList all { Int } [ u5, u1 ] _N_ }, [ Integer ] 1 { _A_ 2 _U_ 21 _N_ _S_ "LS" _F_ _ALWAYS_ \ (u0 :: Integer) (u1 :: [Integer]) -> let {(ua :: Integer -> Bool) = \ (u2 :: Integer) -> case u0 of { _ALG_ J# (u3 :: Int#) (u4 :: Int#) (u5 :: ByteArray#) -> case u2 of { _ALG_ J# (u6 :: Int#) (u7 :: Int#) (u8 :: ByteArray#) -> case _#_ cmpInteger# [] [u3, u4, u5, u6, u7, u8] of { _PRIM_ 0# -> _!_ False [] []; (u9 :: Int#) -> _!_ True [] [] }; _NO_DEFLT_ }; _NO_DEFLT_ }} in _APP_ _TYAPP_ _ORIG_ PreludeList all { Integer } [ ua, u1 ] _N_ }, [ [Char] ] 1 { _A_ 2 _U_ 21 _N_ _S_ "LS" _F_ _ALWAYS_ \ (u0 :: [Char]) (u1 :: [[Char]]) -> let {(u3 :: [Char] -> Bool) = \ (u2 :: [Char]) -> _APP_ _CONSTM_ Eq (/=) ([Char]) [ u0, u2 ]} in _APP_ _TYAPP_ _ORIG_ PreludeList all { [Char] } [ u3, u1 ] _N_ }, [ (Int, Int) ] 1 { _A_ 2 _U_ 21 _N_ _S_ "LS" _F_ _ALWAYS_ \ (u0 :: (Int, Int)) (u1 :: [(Int, Int)]) -> let {(ub :: (Int, Int) -> Bool) = \ (u2 :: (Int, Int)) -> case u0 of { _ALG_ _TUP_2 (u3 :: Int) (u4 :: Int) -> case u3 of { _ALG_ I# (u5 :: Int#) -> case u2 of { _ALG_ _TUP_2 (u6 :: Int) (u7 :: Int) -> case u6 of { _ALG_ I# (u8 :: Int#) -> case _#_ neInt# [] [u5, u8] of { _ALG_ True -> _!_ True [] []; False -> case u4 of { _ALG_ I# (u9 :: Int#) -> case u7 of { _ALG_ I# (ua :: Int#) -> _#_ neInt# [] [u9, ua]; _NO_DEFLT_ }; _NO_DEFLT_ }; _NO_DEFLT_ }; _NO_DEFLT_ }; _NO_DEFLT_ }; _NO_DEFLT_ }; _NO_DEFLT_ }} in _APP_ _TYAPP_ _ORIG_ PreludeList all { (Int, Int) } [ ub, u1 ] _N_ } #-}
nub :: Eq a => [a] -> [a]
- {-# GHC_PRAGMA _A_ 2 _U_ 11 _N_ _S_ "LS" _N_ _N_ #-}
+ {-# GHC_PRAGMA _A_ 2 _U_ 11 _N_ _S_ "LS" _N_ _SPECIALISE_ [ Int ] 1 { _A_ 1 _U_ 1 _N_ _S_ "S" _N_ _N_ }, [ [Char] ] 1 { _A_ 1 _U_ 1 _N_ _S_ "S" _N_ _N_ }, [ [Int] ] 1 { _A_ 1 _U_ 1 _N_ _S_ "S" _N_ _N_ } #-}
null :: [a] -> Bool
{-# GHC_PRAGMA _A_ 1 _U_ 1 _N_ _S_ "S" _F_ _ALWAYS_ _/\_ u0 -> \ (u1 :: [u0]) -> let {(u2 :: Bool) = _!_ True [] []} in let {(u5 :: u0 -> Bool -> Bool) = \ (u3 :: u0) (u4 :: Bool) -> _!_ False [] []} in _APP_ _TYAPP_ _TYAPP_ foldr { u0 } { Bool } [ u5, u2, u1 ] _N_ #-}
or :: [Bool] -> Bool
partition :: (a -> Bool) -> [a] -> ([a], [a])
{-# GHC_PRAGMA _A_ 2 _U_ 21 _N_ _S_ "LS" _F_ _ALWAYS_ _/\_ u0 -> \ (u1 :: u0 -> Bool) (u2 :: [u0]) -> let {(u9 :: u0 -> ([u0], [u0]) -> ([u0], [u0])) = \ (u3 :: u0) (u4 :: ([u0], [u0])) -> case u4 of { _ALG_ _TUP_2 (u5 :: [u0]) (u6 :: [u0]) -> case _APP_ u1 [ u3 ] of { _ALG_ True -> let {(u7 :: [u0]) = _!_ (:) [u0] [u3, u5]} in _!_ _TUP_2 [[u0], [u0]] [u7, u6]; False -> let {(u8 :: [u0]) = _!_ (:) [u0] [u3, u6]} in _!_ _TUP_2 [[u0], [u0]] [u5, u8]; _NO_DEFLT_ }; _NO_DEFLT_ }} in let {(ua :: [u0]) = _!_ _NIL_ [u0] []} in let {(ub :: ([u0], [u0])) = _!_ _TUP_2 [[u0], [u0]] [ua, ua]} in _APP_ _TYAPP_ _TYAPP_ foldr { u0 } { ([u0], [u0]) } [ u9, ub, u2 ] _N_ #-}
product :: Num a => [a] -> a
- {-# GHC_PRAGMA _A_ 1 _U_ 22 _N_ _N_ _F_ _ALWAYS_ _/\_ u0 -> \ (u1 :: {{Num u0}}) -> let {(uc :: u0 -> u0 -> u0) = case u1 of { _ALG_ _TUP_10 (u2 :: {{Eq u0}}) (u3 :: {{Text u0}}) (u4 :: u0 -> u0 -> u0) (u5 :: u0 -> u0 -> u0) (u6 :: u0 -> u0 -> u0) (u7 :: u0 -> u0) (u8 :: u0 -> u0) (u9 :: u0 -> u0) (ua :: Integer -> u0) (ub :: Int -> u0) -> u6; _NO_DEFLT_ }} in let {(uo :: u0) = let {(ud :: Int) = _!_ I# [] [1#]} in case u1 of { _ALG_ _TUP_10 (ue :: {{Eq u0}}) (uf :: {{Text u0}}) (ug :: u0 -> u0 -> u0) (uh :: u0 -> u0 -> u0) (ui :: u0 -> u0 -> u0) (uj :: u0 -> u0) (uk :: u0 -> u0) (ul :: u0 -> u0) (um :: Integer -> u0) (un :: Int -> u0) -> _APP_ un [ ud ]; _NO_DEFLT_ }} in \ (up :: [u0]) -> _APP_ _TYAPP_ _TYAPP_ foldl { u0 } { u0 } [ uc, uo, up ] _SPECIALISE_ [ Double ] 1 { _A_ 1 _U_ 1 _N_ _S_ "S" _F_ _ALWAYS_ \ (u0 :: [Double]) -> let {(u1 :: Double) = _!_ D# [] [1.0000000000000000##]} in _APP_ _TYAPP_ _TYAPP_ foldl { Double } { Double } [ _CONSTM_ Num (*) (Double), u1, u0 ] _N_ }, [ Int ] 1 { _A_ 1 _U_ 1 _N_ _S_ "S" _F_ _ALWAYS_ \ (u0 :: [Int]) -> let {(u1 :: Int) = _!_ I# [] [1#]} in _APP_ _TYAPP_ _TYAPP_ foldl { Int } { Int } [ _CONSTM_ Num (*) (Int), u1, u0 ] _N_ }, [ Integer ] 1 { _A_ 1 _U_ 1 _N_ _S_ "S" _F_ _ALWAYS_ \ (u0 :: [Integer]) -> let {(u1 :: Integer) = _#_ int2Integer# [] [1#]} in _APP_ _TYAPP_ _TYAPP_ foldl { Integer } { Integer } [ _CONSTM_ Num (*) (Integer), u1, u0 ] _N_ } #-}
+ {-# GHC_PRAGMA _A_ 1 _U_ 22 _N_ _N_ _F_ _ALWAYS_ _/\_ u0 -> \ (u1 :: {{Num u0}}) -> let {(uc :: u0 -> u0 -> u0) = case u1 of { _ALG_ _TUP_10 (u2 :: {{Eq u0}}) (u3 :: {{Text u0}}) (u4 :: u0 -> u0 -> u0) (u5 :: u0 -> u0 -> u0) (u6 :: u0 -> u0 -> u0) (u7 :: u0 -> u0) (u8 :: u0 -> u0) (u9 :: u0 -> u0) (ua :: Integer -> u0) (ub :: Int -> u0) -> u6; _NO_DEFLT_ }} in let {(uo :: u0) = let {(ud :: Int) = _!_ I# [] [1#]} in case u1 of { _ALG_ _TUP_10 (ue :: {{Eq u0}}) (uf :: {{Text u0}}) (ug :: u0 -> u0 -> u0) (uh :: u0 -> u0 -> u0) (ui :: u0 -> u0 -> u0) (uj :: u0 -> u0) (uk :: u0 -> u0) (ul :: u0 -> u0) (um :: Integer -> u0) (un :: Int -> u0) -> _APP_ un [ ud ]; _NO_DEFLT_ }} in \ (up :: [u0]) -> _APP_ _TYAPP_ _TYAPP_ foldl { u0 } { u0 } [ uc, uo, up ] _SPECIALISE_ [ Double ] 1 { _A_ 1 _U_ 1 _N_ _S_ "S" _F_ _ALWAYS_ \ (u0 :: [Double]) -> let {(u1 :: Double) = _!_ D# [] [1.0000000000000000##]} in _APP_ _TYAPP_ _TYAPP_ foldl { Double } { Double } [ _CONSTM_ Num (*) (Double), u1, u0 ] _N_ }, [ Int ] 1 { _A_ 1 _U_ 1 _N_ _S_ "S" _F_ _ALWAYS_ \ (u0 :: [Int]) -> let {(u1 :: Int) = _!_ I# [] [1#]} in _APP_ _TYAPP_ _TYAPP_ foldl { Int } { Int } [ _CONSTM_ Num (*) (Int), u1, u0 ] _N_ }, [ Integer ] 1 { _A_ 1 _U_ 1 _N_ _S_ "S" _F_ _ALWAYS_ \ (u0 :: [Integer]) -> let {(u1 :: Integer) = _#_ int2Integer# [] [1#]} in _APP_ _TYAPP_ _TYAPP_ foldl { Integer } { Integer } [ _CONSTM_ Num (*) (Integer), u1, u0 ] _N_ }, [ (Complex Double) ] 1 { _A_ 1 _U_ 1 _N_ _S_ "S" _F_ _ALWAYS_ let {(u6 :: Complex Double -> Complex Double -> Complex Double) = \ (u0 :: Complex Double) (u1 :: Complex Double) -> case u0 of { _ALG_ (:+) (u2 :: Double) (u3 :: Double) -> case u1 of { _ALG_ (:+) (u4 :: Double) (u5 :: Double) -> _APP_ _WRKR_ _CONSTM_ Num (*) (Complex Double) [ u2, u3, u4, u5 ]; _NO_DEFLT_ }; _NO_DEFLT_ }} in let {(u8 :: Complex Double) = let {(u7 :: Int) = _!_ I# [] [1#]} in _APP_ _CONSTM_ Num fromInt (Complex Double) [ u7 ]} in \ (u9 :: [Complex Double]) -> _APP_ _TYAPP_ _TYAPP_ foldl { (Complex Double) } { (Complex Double) } [ u6, u8, u9 ] _N_ } #-}
products :: Num a => [a] -> [a]
- {-# GHC_PRAGMA _A_ 1 _U_ 21 _N_ _N_ _N_ _N_ #-}
+ {-# GHC_PRAGMA _A_ 1 _U_ 21 _N_ _N_ _N_ _SPECIALISE_ [ Double ] 1 { _A_ 1 _U_ 1 _N_ _N_ _N_ _N_ }, [ Int ] 1 { _A_ 1 _U_ 1 _N_ _N_ _N_ _N_ }, [ Integer ] 1 { _A_ 1 _U_ 1 _N_ _N_ _F_ _IF_ARGS_ 0 1 X 4 \ (u0 :: [Integer]) -> _APP_ _TYAPP_ _TYAPP_ _ORIG_ PreludeList scanl { Integer } { Integer } [ _CONSTM_ Num (*) (Integer), _SPEC_ _ORIG_ PreludeCore __i1 [ (Integer) ], u0 ] _N_ }, [ (Complex Double) ] 1 { _A_ 1 _U_ 1 _N_ _N_ _N_ _N_ } #-}
repeat :: a -> [a]
{-# GHC_PRAGMA _A_ 1 _U_ 2 _N_ _N_ _F_ _ALWAYS_ _/\_ u0 -> \ (u1 :: u0) -> let {(u6 :: _forall_ a$z1 =>(u0 -> a$z1 -> a$z1) -> a$z1 -> a$z1) = _/\_ u2 -> \ (u3 :: u0 -> u2 -> u2) (u4 :: u2) -> _LETREC_ {(u5 :: u2) = _APP_ u3 [ u1, u5 ]} in u5} in _APP_ _TYAPP_ _build { u0 } [ u6 ] _N_ #-}
reverse :: [a] -> [a]
sum :: Num a => [a] -> a
{-# GHC_PRAGMA _A_ 1 _U_ 22 _N_ _N_ _F_ _ALWAYS_ _/\_ u0 -> \ (u1 :: {{Num u0}}) -> let {(uc :: u0 -> u0 -> u0) = case u1 of { _ALG_ _TUP_10 (u2 :: {{Eq u0}}) (u3 :: {{Text u0}}) (u4 :: u0 -> u0 -> u0) (u5 :: u0 -> u0 -> u0) (u6 :: u0 -> u0 -> u0) (u7 :: u0 -> u0) (u8 :: u0 -> u0) (u9 :: u0 -> u0) (ua :: Integer -> u0) (ub :: Int -> u0) -> u4; _NO_DEFLT_ }} in let {(uo :: u0) = let {(ud :: Int) = _!_ I# [] [0#]} in case u1 of { _ALG_ _TUP_10 (ue :: {{Eq u0}}) (uf :: {{Text u0}}) (ug :: u0 -> u0 -> u0) (uh :: u0 -> u0 -> u0) (ui :: u0 -> u0 -> u0) (uj :: u0 -> u0) (uk :: u0 -> u0) (ul :: u0 -> u0) (um :: Integer -> u0) (un :: Int -> u0) -> _APP_ un [ ud ]; _NO_DEFLT_ }} in \ (up :: [u0]) -> _APP_ _TYAPP_ _TYAPP_ foldl { u0 } { u0 } [ uc, uo, up ] _SPECIALISE_ [ Double ] 1 { _A_ 1 _U_ 1 _N_ _S_ "S" _F_ _ALWAYS_ \ (u0 :: [Double]) -> let {(u1 :: Double) = _!_ D# [] [0.0000000000000000##]} in _APP_ _TYAPP_ _TYAPP_ foldl { Double } { Double } [ _CONSTM_ Num (+) (Double), u1, u0 ] _N_ }, [ Int ] 1 { _A_ 1 _U_ 1 _N_ _S_ "S" _F_ _ALWAYS_ \ (u0 :: [Int]) -> let {(u1 :: Int) = _!_ I# [] [0#]} in _APP_ _TYAPP_ _TYAPP_ foldl { Int } { Int } [ _CONSTM_ Num (+) (Int), u1, u0 ] _N_ }, [ Integer ] 1 { _A_ 1 _U_ 1 _N_ _S_ "S" _F_ _ALWAYS_ \ (u0 :: [Integer]) -> let {(u1 :: Integer) = _#_ int2Integer# [] [0#]} in _APP_ _TYAPP_ _TYAPP_ foldl { Integer } { Integer } [ _CONSTM_ Num (+) (Integer), u1, u0 ] _N_ }, [ (Complex Double) ] 1 { _A_ 1 _U_ 1 _N_ _S_ "S" _F_ _ALWAYS_ let {(u6 :: Complex Double -> Complex Double -> Complex Double) = \ (u0 :: Complex Double) (u1 :: Complex Double) -> case u0 of { _ALG_ (:+) (u2 :: Double) (u3 :: Double) -> case u1 of { _ALG_ (:+) (u4 :: Double) (u5 :: Double) -> _APP_ _WRKR_ _CONSTM_ Num (+) (Complex Double) [ u2, u3, u4, u5 ]; _NO_DEFLT_ }; _NO_DEFLT_ }} in let {(u8 :: Complex Double) = let {(u7 :: Int) = _!_ I# [] [0#]} in _APP_ _CONSTM_ Num fromInt (Complex Double) [ u7 ]} in \ (u9 :: [Complex Double]) -> _APP_ _TYAPP_ _TYAPP_ foldl { (Complex Double) } { (Complex Double) } [ u6, u8, u9 ] _N_ } #-}
sums :: Num a => [a] -> [a]
- {-# GHC_PRAGMA _A_ 1 _U_ 21 _N_ _N_ _N_ _N_ #-}
+ {-# GHC_PRAGMA _A_ 1 _U_ 21 _N_ _N_ _N_ _SPECIALISE_ [ Double ] 1 { _A_ 1 _U_ 1 _N_ _N_ _N_ _N_ }, [ Int ] 1 { _A_ 1 _U_ 1 _N_ _N_ _N_ _N_ }, [ Integer ] 1 { _A_ 1 _U_ 1 _N_ _N_ _F_ _IF_ARGS_ 0 1 X 4 \ (u0 :: [Integer]) -> _APP_ _TYAPP_ _TYAPP_ _ORIG_ PreludeList scanl { Integer } { Integer } [ _CONSTM_ Num (+) (Integer), _SPEC_ _ORIG_ PreludeCore __i0 [ (Integer) ], u0 ] _N_ }, [ (Complex Double) ] 1 { _A_ 1 _U_ 1 _N_ _N_ _N_ _N_ } #-}
tail :: [a] -> [a]
{-# GHC_PRAGMA _A_ 1 _U_ 1 _N_ _S_ "S" _F_ _IF_ARGS_ 1 1 C 5 _/\_ u0 -> \ (u1 :: [u0]) -> case u1 of { _ALG_ (:) (u2 :: u0) (u3 :: [u0]) -> u3; _NIL_ -> _APP_ _TYAPP_ error { [u0] } [ _NOREP_S_ "tail{PreludeList}: tail []\n" ]; _NO_DEFLT_ } _N_ #-}
take :: Integral a => a -> [b] -> [b]
- {-# GHC_PRAGMA _A_ 3 _U_ 121 _N_ _S_ "U(AAAAAAAAAAAS)LL" {_A_ 3 _U_ 121 _N_ _N_ _N_ _N_} _F_ _IF_ARGS_ 2 3 CXX 7 _/\_ u0 u1 -> \ (u2 :: {{Integral u0}}) (u3 :: u0) (u4 :: [u1]) -> let {(uh :: Int) = case u2 of { _ALG_ _TUP_12 (u5 :: {{Real u0}}) (u6 :: {{Ix u0}}) (u7 :: u0 -> u0 -> u0) (u8 :: u0 -> u0 -> u0) (u9 :: u0 -> u0 -> u0) (ua :: u0 -> u0 -> u0) (ub :: u0 -> u0 -> (u0, u0)) (uc :: u0 -> u0 -> (u0, u0)) (ud :: u0 -> Bool) (ue :: u0 -> Bool) (uf :: u0 -> Integer) (ug :: u0 -> Int) -> _APP_ ug [ u3 ]; _NO_DEFLT_ }} in _APP_ _TYAPP_ _SPEC_ _ORIG_ PreludeList take [ (Int), _N_ ] { u1 } [ uh, u4 ] _SPECIALISE_ [ Int, _N_ ] 1 { _A_ 2 _U_ 11 _N_ _S_ "U(P)L" {_A_ 2 _U_ 21 _N_ _N_ _N_ _N_} _N_ _N_ }, [ Integer, _N_ ] 1 { _A_ 2 _U_ 11 _N_ _S_ "U(PPP)L" {_A_ 4 _U_ 2221 _N_ _N_ _F_ _IF_ARGS_ 1 4 XXXX 4 _/\_ u0 -> \ (u1 :: Int#) (u2 :: Int#) (u3 :: ByteArray#) (u4 :: [u0]) -> case _#_ integer2Int# [] [u1, u2, u3] of { _PRIM_ (u5 :: Int#) -> _APP_ _TYAPP_ _WRKR_ _SPEC_ _ORIG_ PreludeList take [ (Int), _N_ ] { u0 } [ u5, u4 ] } _N_} _F_ _ALWAYS_ _/\_ u0 -> \ (u1 :: Integer) (u2 :: [u0]) -> case u1 of { _ALG_ J# (u3 :: Int#) (u4 :: Int#) (u5 :: ByteArray#) -> case _#_ integer2Int# [] [u3, u4, u5] of { _PRIM_ (u6 :: Int#) -> _APP_ _TYAPP_ _WRKR_ _SPEC_ _ORIG_ PreludeList take [ (Int), _N_ ] { u0 } [ u6, u2 ] }; _NO_DEFLT_ } _N_ } #-}
+ {-# GHC_PRAGMA _A_ 1 _U_ 122 _N_ _S_ "U(LU(U(ASSAAAAA)AAA)AAAALAAAAL)" {_A_ 5 _U_ 2121222 _N_ _N_ _N_ _N_} _N_ _SPECIALISE_ [ Int, _N_ ] 1 { _A_ 2 _U_ 11 _N_ _S_ "U(P)L" {_A_ 2 _U_ 21 _N_ _N_ _N_ _N_} _N_ _N_ }, [ Integer, _N_ ] 1 { _A_ 1 _U_ 12 _N_ _S_ "U(PPP)" {_A_ 3 _U_ 2222 _N_ _N_ _N_ _N_} _N_ _N_ } #-}
takeWhile :: (a -> Bool) -> [a] -> [a]
{-# GHC_PRAGMA _A_ 2 _U_ 21 _N_ _S_ "LS" _F_ _ALWAYS_ _/\_ u0 -> \ (u1 :: u0 -> Bool) (u2 :: [u0]) -> let {(u9 :: _forall_ a$z1 =>(u0 -> a$z1 -> a$z1) -> a$z1 -> a$z1) = _/\_ u3 -> \ (u4 :: u0 -> u3 -> u3) (u5 :: u3) -> let {(u8 :: u0 -> u3 -> u3) = \ (u6 :: u0) (u7 :: u3) -> case _APP_ u1 [ u6 ] of { _ALG_ True -> _APP_ u4 [ u6, u7 ]; False -> u5; _NO_DEFLT_ }} in _APP_ _TYAPP_ _TYAPP_ foldr { u0 } { u3 } [ u8, u5, u2 ]} in _APP_ _TYAPP_ _build { u0 } [ u9 ] _N_ #-}
transpose :: [[a]] -> [[a]]
import IInt
import IInteger
import IList
-import Prel ( otherwise, isSpace, (&&), (||), atan2, (.), flip, (^) )
+import ITup2
+import Prel ( otherwise, isSpace, (&&), (||), atan2, (.), flip, (^),
+ id, maxInt, maxInt# )
import PS ( _PackedString, _unpackPS )
import Text
+import TyArray
import TyComplex
--infixl 9 !!
-- are the dual functions working from the end of a finite list,
-- rather than the beginning.
---{-# GENERATE_SPECS head a #-}
+{-# GENERATE_SPECS head a #-}
head :: [a] -> a
#ifndef USE_FOLDR_BUILD
head (x:_) = x
(error "head{PreludeList}: head []\n")
#endif
---{-# GENERATE_SPECS last a #-}
+{-# GENERATE_SPECS last a #-}
last :: [a] -> a
last [] = error "last{PreludeList}: last []\n"
last [x] = x
last (_:xs) = last xs
---{-# GENERATE_SPECS tail a #-}
+{-# GENERATE_SPECS tail a #-}
tail :: [a] -> [a]
tail (_:xs) = xs
tail [] = error "tail{PreludeList}: tail []\n"
---{-# GENERATE_SPECS init a #-}
+{-# GENERATE_SPECS init a #-}
init :: [a] -> [a]
init [] = error "init{PreludeList}: init []\n"
init [x] = []
init (x:xs) = x : init xs
-- null determines if a list is empty.
---{-# GENERATE_SPECS null a #-}
+{-# GENERATE_SPECS null a #-}
null :: [a] -> Bool
#ifndef USE_FOLDR_BUILD
null [] = True
#endif
-- list concatenation (right-associative)
---{-# GENERATE_SPECS (++) a #-}
+{-# GENERATE_SPECS (++) a #-}
(++) :: [a] -> [a] -> [a]
#ifdef USE_REPORT_PRELUDE
-- list difference (non-associative). In the result of xs \\ ys,
-- the first occurrence of each element of ys in turn (if any)
-- has been removed from xs. Thus, (xs ++ ys) \\ xs == ys.
---{-# GENERATE_SPECS (\\) a{+,Int} #-}
+{-# GENERATE_SPECS (\\) a{+,Int,[Char]} #-}
(\\) :: (Eq a) => [a] -> [a] -> [a]
(\\) xs ys = foldl del xs ys
where [] `del` _ = []
-- of the more general genericLength, the result type of which may be
-- any kind of number.
---{-# GENERATE_SPECS genericLength a{~,Int#,Double#,Int} b #-}
+{-# GENERATE_SPECS genericLength a{~,Int#,Double#,Int,Integer} b #-}
genericLength :: (Num a) => [b] -> a
-genericLength xs = foldl (\n _ -> n+1) 0 xs
+genericLength xs = foldl (\n _ -> n+__i1) __i0 xs
---{-# GENERATE_SPECS length a #-}
+{-# GENERATE_SPECS length a #-}
length :: [a] -> Int
#ifdef USE_REPORT_PRELUDE
length = genericLength
-- List index (subscript) operator, 0-origin
-{-# SPECIALIZE (!!) :: [b] -> Int -> b, [b] -> Integer -> b #-}
---{-# GENERATE_SPECS (!!) a{~,Int#,Int,Integer} b #-}
+{-# GENERATE_SPECS (!!) a{~,Int#,Int,Integer} b #-}
(!!) :: (Integral a) => [b] -> a -> b
#ifdef USE_REPORT_PRELUDE
(x:_) !! 0 = x
-- in the more efficient version.
-- (Not to mention if "n" won't fit in an Int :-)
-_ !! n | n < 0 = error "(!!){PreludeList}: negative index\n"
+_ !! n | n < __i0 = error "(!!){PreludeList}: negative index\n"
xs !! n = sub xs (case (toInt n) of { I# n# -> n# })
where sub :: [a] -> Int# -> a
- sub [] _ = error "(!!){PreludeList}: index too large\n"
+ sub [] _ = error "(!!){PreludeList}: index too large\n"
sub (x:xs) n# = if n# ==# 0#
then x
else sub xs (n# `minusInt#` 1#)
#endif /* ! USE_REPORT_PRELUDE */
-- map f xs applies f to each element of xs; i.e., map f xs == [f x | x <- xs].
---{-# GENERATE_SPECS map a b #-}
+{-# GENERATE_SPECS map a b #-}
map :: (a -> b) -> [a] -> [b]
#ifndef USE_FOLDR_BUILD
map f [] = []
-- filter, applied to a predicate and a list, returns the list of those
-- elements that satisfy the predicate; i.e.,
-- filter p xs == [x | x <- xs, p x].
---{-# GENERATE_SPECS filter a #-}
+{-# GENERATE_SPECS filter a #-}
filter :: (a -> Bool) -> [a] -> [a]
#ifdef USE_REPORT_PRELUDE
filter p = foldr (\x xs -> if p x then x:xs else xs) []
#ifdef USE_FOLDR_BUILD
{-# INLINE partition #-}
#endif
---{-# GENERATE_SPECS partition a #-}
+{-# GENERATE_SPECS partition a #-}
partition :: (a -> Bool) -> [a] -> ([a],[a])
partition p xs = foldr select ([],[]) xs
where select x (ts,fs) | p x = (x:ts,fs)
-- scanl1 is similar, again without the starting element:
-- scanl1 f [x1, x2, ...] == [x1, x1 `f` x2, ...]
---{-# GENERATE_SPECS foldl1 a #-}
+{-# GENERATE_SPECS foldl1 a #-}
foldl1 :: (a -> a -> a) -> [a] -> a
foldl1 f (x:xs) = foldl f x xs
foldl1 _ [] = error "foldl1{PreludeList}: empty list\n"
---{-# GENERATE_SPECS scanl a b#-}
+{-# GENERATE_SPECS scanl a b#-}
scanl :: (a -> b -> a) -> a -> [b] -> [a]
scanl f q xs = q : (case xs of
[] -> []
x:xs -> scanl f (f q x) xs)
---{-# GENERATE_SPECS scanl1 a #-}
+{-# GENERATE_SPECS scanl1 a #-}
scanl1 :: (a -> a -> a) -> [a] -> [a]
scanl1 f (x:xs) = scanl f x xs
scanl1 _ [] = error "scanl1{PreludeList}: empty list\n"
-- foldr, foldr1, scanr, and scanr1 are the right-to-left duals of the
-- above functions.
---{-# GENERATE_SPECS foldr1 a #-}
+{-# GENERATE_SPECS foldr1 a #-}
foldr1 :: (a -> a -> a) -> [a] -> a
foldr1 f [x] = x
foldr1 f (x:xs) = f x (foldr1 f xs)
foldr1 _ [] = error "foldr1{PreludeList}: empty list\n"
---{-# GENERATE_SPECS scanr a b #-}
+{-# GENERATE_SPECS scanr a b #-}
scanr :: (a -> b -> b) -> b -> [a] -> [b]
scanr f q0 [] = [q0]
scanr f q0 (x:xs) = f x q : qs
where qs@(q:_) = scanr f q0 xs
---{-# GENERATE_SPECS scanr1 a #-}
+{-# GENERATE_SPECS scanr1 a #-}
scanr1 :: (a -> a -> a) -> [a] -> [a]
scanr1 f [x] = [x]
scanr1 f (x:xs) = f x q : qs
-- iterate f x returns an infinite list of repeated applications of f to x:
-- iterate f x == [x, f x, f (f x), ...]
---{-# GENERATE_SPECS iterate a #-}
+{-# GENERATE_SPECS iterate a #-}
iterate :: (a -> a) -> a -> [a]
#ifndef USE_FOLDR_BUILD
iterate f x = x : iterate f (f x)
-- repeat x is an infinite list, with x the value of every element.
---{-# GENERATE_SPECS repeat a #-}
+{-# GENERATE_SPECS repeat a #-}
repeat :: a -> [a]
#ifndef USE_FOLDR_BUILD
repeat x = xs where xs = x:xs
-- the infinite repetition of the original list. It is the identity
-- on infinite lists.
---{-# GENERATE_SPECS cycle a #-}
+{-# GENERATE_SPECS cycle a #-}
cycle :: [a] -> [a]
#ifndef USE_FOLDR_BUILD
cycle xs = xs' where xs' = xs ++ xs'
#else /* hack away */
--- ToDo: massive Patrick hack not included yet
+{-# GENERATE_SPECS take a{~,Integer} b #-}
take :: (Integral a) => a -> [b] -> [b]
-drop :: (Integral a) => a -> [b] -> [b]
-splitAt :: (Integral a) => a -> [b] -> ([b], [b])
-
-{-# SPECIALIZE take :: Int -> [b] -> [b], Integer -> [b] -> [b] #-}
-{-# SPECIALIZE drop :: Int -> [b] -> [b], Integer -> [b] -> [b] #-}
-{-# SPECIALIZE splitAt :: Int -> [b] -> ([b], [b]), Integer -> [b] -> ([b], [b]) #-}
-
-take n xs = takeInt (toInt n) xs
-
-takeInt :: Int -> [b] -> [b]
-takeInt (I# n#) xs
- | n# <# 0# = error "take{PreludeList}: negative index"
- | otherwise = takeInt# n# xs
- where
- takeInt# :: Int# -> [a] -> [a]
- takeInt# 0# _ = []
- takeInt# _ [] = []
- takeInt# m# (x:xs) = x : takeInt# (m# `minusInt#` 1#) xs
-{- NEW, from Kevin Hammond (kh)
- ToDo: needs the < 0 checking
+{-# SPECIALIZE take :: Int -> [b] -> [b] = _takeInt #-}
+
+#if defined(__UNBOXED_INSTANCES__)
+{-# SPECIALIZE take ::
+ Int# -> [b] -> [b] = _takeUInt,
+ Int# -> [Int#] -> [Int#] = _takeUInti,
+ Int# -> [Char#] -> [Char#] = _takeUIntc,
+ Int# -> [Double#] -> [Double#] = _takeUIntd,
+ Int -> [Int#] -> [Int#] = _takeInti,
+ Int -> [Char#] -> [Char#] = _takeIntc,
+ Int -> [Double#] -> [Double#] = _takeIntd #-}
+
+{-# INLINE _takeUInti #-}
+{-# INLINE _takeUIntc #-}
+{-# INLINE _takeUIntd #-}
+{-# INLINE _takeInti #-}
+{-# INLINE _takeIntc #-}
+{-# INLINE _takeIntd #-}
+
+_takeUInti :: Int# -> [Int#] -> [Int#]
+_takeUInti n xs = _takeUInt n xs
+_takeUIntc :: Int# -> [Char#] -> [Char#]
+_takeUIntc n xs = _takeUInt n xs
+_takeUIntd :: Int# -> [Double#] -> [Double#]
+_takeUIntd n xs = _takeUInt n xs
+_takeInti :: Int -> [Int#] -> [Int#]
+_takeInti n xs = _takeInt n xs
+_takeIntc :: Int -> [Char#] -> [Char#]
+_takeIntc n xs = _takeInt n xs
+_takeIntd :: Int -> [Double#] -> [Double#]
+_takeIntd n xs = _takeInt n xs
-take n | n >= 0 =
- if n <= fromIntegral maxInt then take' 0 else take'' n
- where
- take' :: Int -> [a] -> [a]
- take' _ [] = []
- take' m _ | m == n' = []
- take' m (x:xs) = x : take' (m+1) xs
-
- take'' :: (Integral a) => a -> [b] -> [b]
- tale'' 0 - = []
- take'' _ [] = []
- take'' n (x:xs) = x : take'' (n-1) xs
+#endif
- n' = fromIntegral n
+-- The general code for take, below, checks n <= maxInt
+-- No need to check for maxInt overflow when specialised
+-- at type Int or Int# since the Int must be <= maxInt
+
+_takeUInt :: Int# -> [b] -> [b]
+_takeUInt n xs
+ | n `geInt#` 0# = _take_unsafe_UInt n xs
+ | otherwise = error "take{PreludeList}: negative index"
+
+{-# INLINE _takeInt #-}
+_takeInt :: Int -> [b] -> [b]
+_takeInt (I# n#) xs = _takeUInt n# xs
+
+_take_unsafe_UInt 0# _ = []
+_take_unsafe_UInt _ [] = []
+_take_unsafe_UInt m (x:xs) = x : _take_unsafe_UInt (m `minusInt#` 1#) xs
+
+-- For an index n between maxInt and maxInt^2 we use a function
+-- with two indexes m and r where n = m * maxInt + r
+
+_take_unsafe_UIntUInt _ _ [] = []
+_take_unsafe_UIntUInt 1# 0# xs = _take_unsafe_UInt maxInt# xs
+_take_unsafe_UIntUInt m 0# xs = _take_unsafe_UIntUInt (m `minusInt#` 1#) maxInt# xs
+_take_unsafe_UIntUInt m r (x:xs) = x : _take_unsafe_UIntUInt m (r `minusInt#` 1#) xs
+
+_take_unsafe_Integral :: (Integral a) => a -> [b] -> [b]
+_take_unsafe_Integral _ [] = []
+_take_unsafe_Integral 0 _ = []
+_take_unsafe_Integral n (x:xs) = x : _take_unsafe_Integral (n-1) xs
+
+__max :: Num a => a
+__max = fromInt maxInt
+
+take n | n < __i0
+ = error "take{PreludeList}: negative index"
+ | n <= __max
+ = let n# = i2i# (toInt n)
+ in \xs -> _take_unsafe_UInt n# xs
+ | n <= __max * __max
+ = let m# = i2i# (toInt m)
+ r# = i2i# (toInt r)
+ in \xs -> _take_unsafe_UIntUInt m# r# xs
+ | otherwise
+ = \xs -> _take_unsafe_Integral n xs
+ where
+ (m,r) = n `quotRem` __max
+ i2i# (I# i#) = i#
-- Test
-- main = print (head (take (123456789123456789::Integer) [1..]))
--}
-- ToDo: NEW drop and splitAt, too (WDP)
+{-# GENERATE_SPECS drop a{~,Int#,Int,Integer} b #-}
+drop :: (Integral a) => a -> [b] -> [b]
drop n xs = dropInt (toInt n) xs
dropInt :: Int -> [b] -> [b]
dropInt# _ [] = []
dropInt# m# (_:xs) = dropInt# (m# `minusInt#` 1#) xs
+{-# GENERATE_SPECS splitAt a{~,Int#,Int,Integer} b #-}
+splitAt :: (Integral a) => a -> [b] -> ([b], [b])
splitAt n xs | n >= 0 = splitAtInt (toInt n) xs
splitAtInt :: Int -> [b] -> ([b], [b])
-- returns the remaining suffix. Span p xs is equivalent to
-- (takeWhile p xs, dropWhile p xs), while break p uses the negation of p.
---{-# GENERATE_SPECS takeWhile a #-}
+{-# GENERATE_SPECS takeWhile a #-}
takeWhile :: (a -> Bool) -> [a] -> [a]
#ifndef USE_FOLDR_BUILD
takeWhile p [] = []
foldr fn n xs)
#endif /* USE_FOLDR_BUILD */
---{-# GENERATE_SPECS dropWhile a #-}
+{-# GENERATE_SPECS dropWhile a #-}
dropWhile :: (a -> Bool) -> [a] -> [a]
dropWhile p [] = []
dropWhile p xs@(x:xs')
| p x = dropWhile p xs'
| otherwise = xs
---{-# GENERATE_SPECS span a #-}
+{-# GENERATE_SPECS span a #-}
span :: (a -> Bool) -> [a] -> ([a],[a])
span p [] = ([],[])
span p xs@(x:xs')
| p x = let (ys,zs) = span p xs' in (x:ys,zs)
| otherwise = ([],xs)
---{-# GENERATE_SPECS break a #-}
+{-# GENERATE_SPECS break a #-}
break :: (a -> Bool) -> [a] -> ([a],[a])
#ifdef USE_REPORT_PRELUDE
break p = span (not . p)
#endif /* ! USE_REPORT_PRELUDE */
-- nub (meaning "essence") removes duplicate elements from its list argument.
---{-# GENERATE_SPECS nub a{+,Int} #-}
+{-# GENERATE_SPECS nub a{+,Int,[Int],[Char]} #-}
nub :: (Eq a) => [a] -> [a]
#ifdef USE_REPORT_PRELUDE
nub [] = []
#endif /* ! USE_REPORT_PRELUDE */
-- reverse xs returns the elements of xs in reverse order. xs must be finite.
---{-# GENERATE_SPECS reverse a #-}
+{-# GENERATE_SPECS reverse a #-}
reverse :: [a] -> [a]
#ifdef USE_REPORT_PRELUDE
reverse = foldl (flip (:)) []
-- Applied to a predicate and a list, any determines if any element
-- of the list satisfies the predicate. Similarly, for all.
---{-# GENERATE_SPECS any a #-}
+{-# GENERATE_SPECS any a #-}
any :: (a -> Bool) -> [a] -> Bool
---{-# GENERATE_SPECS all a #-}
+{-# GENERATE_SPECS all a #-}
all :: (a -> Bool) -> [a] -> Bool
#ifdef USE_REPORT_PRELUDE
any p = or . map p
-- elem is the list membership predicate, usually written in infix form,
-- e.g., x `elem` xs. notElem is the negation.
---{-# GENERATE_SPECS elem a{+,Int,Char,String} #-}
+{-# GENERATE_SPECS elem a{+,Int,Integer,Char,String,(Int,Int)} #-}
elem :: (Eq a) => a -> [a] -> Bool
---{-# GENERATE_SPECS notElem a{+,Int,Char,String} #-}
+{-# GENERATE_SPECS notElem a{+,Int,Integer,Char,String,(Int,Int)} #-}
notElem :: (Eq a) => a -> [a] -> Bool
-{-# SPECIALIZE elem :: Int -> [Int] -> Bool, Char -> [Char] -> Bool, String -> [String] -> Bool #-}
-{-# SPECIALIZE notElem :: Int -> [Int] -> Bool, Char -> [Char] -> Bool, String -> [String] -> Bool #-}
-
#ifdef USE_REPORT_PRELUDE
elem = any . (==)
notElem = all . (/=)
#endif /* ! USE_REPORT_PRELUDE */
-- sum and product compute the sum or product of a finite list of numbers.
-{-# SPECIALIZE sum :: [Int] -> Int, [Integer] -> Integer, [Double] -> Double, [Complex Double] -> Complex Double #-}
---{-# GENERATE_SPECS sum a{Int#,Double#,Int,Integer,Double} #-}
+{-# GENERATE_SPECS sum a{Int#,Double#,Int,Integer,Double,Complex(Double#),Complex(Double)} #-}
sum :: (Num a) => [a] -> a
-{-# SPECIALIZE product :: [Int] -> Int, [Integer] -> Integer, [Double] -> Double #-}
---{-# GENERATE_SPECS product a{Int#,Double#,Int,Integer,Double} #-}
+{-# GENERATE_SPECS product a{Int#,Double#,Int,Integer,Double,Complex(Double#),Complex(Double)} #-}
product :: (Num a) => [a] -> a
#ifdef USE_REPORT_PRELUDE
-- sums and products give a list of running sums or products from
-- a list of numbers. For example, sums [1,2,3] == [0,1,3,6].
---{-# GENERATE_SPECS sums a{Int#,Double#,Int,Integer,Double} #-}
+{-# GENERATE_SPECS sums a{Int#,Double#,Int,Integer,Double,Complex(Double#),Complex(Double)} #-}
sums :: (Num a) => [a] -> [a]
-sums xs = scanl (+) 0 xs
---{-# GENERATE_SPECS products a{Int#,Double#,Int,Integer,Double} #-}
+sums xs = scanl (+) __i0 xs
+{-# GENERATE_SPECS products a{Int#,Double#,Int,Integer,Double,Complex(Double#),Complex(Double)} #-}
products :: (Num a) => [a] -> [a]
-products xs = scanl (*) 1 xs
+products xs = scanl (*) __i1 xs
-- maximum and minimum return the maximum or minimum value from a list,
-- which must be non-empty, finite, and of an ordered type.
---{-# GENERATE_SPECS maximum a{+,Int,Integer,Double} #-}
+{-# GENERATE_SPECS maximum a{+,Int,Integer,Double} #-}
maximum :: (Ord a) => [a] -> a
---{-# GENERATE_SPECS minimum a{+,Int,Integer,Double} #-}
+{-# GENERATE_SPECS minimum a{+,Int,Integer,Double} #-}
minimum :: (Ord a) => [a] -> a
#ifdef USE_REPORT_PRELUDE
maximum = foldl1 max
#endif /* ! USE_REPORT_PRELUDE */
-- concat, applied to a list of lists, returns their flattened concatenation.
---{-# GENERATE_SPECS concat a #-}
+{-# GENERATE_SPECS concat a #-}
concat :: [[a]] -> [a]
#ifdef USE_REPORT_PRELUDE
concat = foldr (++) []
-- than the previous one; any elements outside of the "triangular"
-- transposable region are lost. The input can be infinite in either
-- dimension or both.
---{-# GENERATE_SPECS transpose a #-}
+{-# GENERATE_SPECS transpose a #-}
transpose :: [[a]] -> [[a]]
transpose xs = foldr
(\xs xss -> zipWith (:) xs (xss ++ repeat []))
#ifdef USE_FOLDR_BUILD
{-# INLINE zip #-}
#endif
---{-# GENERATE_SPECS zip a b #-}
+{-# GENERATE_SPECS zip a b #-}
zip :: [a] -> [b] -> [(a,b)]
zip as bs = zipWith (\a b -> (a,b)) as bs
-- For example, zipWith (+) is applied to two lists to produce the list
-- of corresponding sums.
---{-# GENERATE_SPECS zipWith a b c #-}
+{-# GENERATE_SPECS zipWith a b c #-}
zipWith :: (a->b->c) -> [a]->[b]->[c]
#ifndef USE_FOLDR_BUILD
zipWith z (a:as) (b:bs) = z a b : zipWith z as bs
-- unzip transforms a list of pairs into a pair of lists. As with zip,
-- a family of such functions up to septuplets is provided.
---{-# GENERATE_SPECS unzip a b #-}
+{-# GENERATE_SPECS unzip a b #-}
unzip :: [(a,b)] -> ([a],[b])
unzip xs = foldr (\(a,b) ~(as,bs) -> (a:as,b:bs)) ([],[]) xs
-{-# GHC_PRAGMA INTERFACE VERSION 5 #-}
+{-# GHC_PRAGMA INTERFACE VERSION 6 #-}
interface PreludeList where
import PreludeBuiltin(Char(..), Int(..), List(..), Tuple2, Tuple3, Tuple4, Tuple5, Tuple6, Tuple7)
import PreludeCore(Bool(..), Eq(..), Integral(..), Num(..), Ord(..))
(++) :: [a] -> [a] -> [a]
{-# GHC_PRAGMA _A_ 2 _U_ 12 _N_ _S_ "SL" _N_ _N_ #-}
(\\) :: Eq a => [a] -> [a] -> [a]
- {-# GHC_PRAGMA _A_ 3 _U_ 122 _N_ _S_ "LLS" _N_ _N_ #-}
+ {-# GHC_PRAGMA _A_ 3 _U_ 122 _N_ _S_ "LLS" _N_ _SPECIALISE_ [ Int ] 1 { _A_ 2 _U_ 22 _N_ _S_ "LS" _N_ _N_ }, [ [Char] ] 1 { _A_ 2 _U_ 22 _N_ _S_ "LS" _N_ _N_ } #-}
all :: (a -> Bool) -> [a] -> Bool
{-# GHC_PRAGMA _A_ 2 _U_ 21 _N_ _S_ "LS" _F_ _ALWAYS_ _/\_ u0 -> \ (u1 :: u0 -> Bool) (u2 :: [u0]) -> let {(u3 :: Bool) = _!_ True [] []} in let {(u6 :: u0 -> Bool -> Bool) = \ (u4 :: u0) (u5 :: Bool) -> case _APP_ u1 [ u4 ] of { _ALG_ True -> u5; False -> _!_ False [] []; _NO_DEFLT_ }} in _APP_ _TYAPP_ _TYAPP_ foldr { u0 } { Bool } [ u6, u3, u2 ] _N_ #-}
and :: [Bool] -> Bool
dropWhile :: (a -> Bool) -> [a] -> [a]
{-# GHC_PRAGMA _A_ 2 _U_ 21 _N_ _S_ "LS" _N_ _N_ #-}
elem :: Eq a => a -> [a] -> Bool
- {-# GHC_PRAGMA _A_ 3 _U_ 121 _N_ _S_ "LLS" _F_ _ALWAYS_ _/\_ u0 -> \ (u1 :: {{Eq u0}}) (u2 :: u0) (u3 :: [u0]) -> let {(u6 :: u0 -> u0 -> Bool) = case u1 of { _ALG_ _TUP_2 (u4 :: u0 -> u0 -> Bool) (u5 :: u0 -> u0 -> Bool) -> u4; _NO_DEFLT_ }} in let {(u8 :: u0 -> Bool) = \ (u7 :: u0) -> _APP_ u6 [ u2, u7 ]} in _APP_ _TYAPP_ _ORIG_ PreludeList any { u0 } [ u8, u3 ] _SPECIALISE_ [ Char ] 1 { _A_ 2 _U_ 21 _N_ _S_ "LS" _F_ _ALWAYS_ \ (u0 :: Char) (u1 :: [Char]) -> let {(u5 :: Char -> Bool) = \ (u2 :: Char) -> case u0 of { _ALG_ C# (u3 :: Char#) -> case u2 of { _ALG_ C# (u4 :: Char#) -> _#_ eqChar# [] [u3, u4]; _NO_DEFLT_ }; _NO_DEFLT_ }} in _APP_ _TYAPP_ _ORIG_ PreludeList any { Char } [ u5, u1 ] _N_ }, [ Int ] 1 { _A_ 2 _U_ 21 _N_ _S_ "LS" _F_ _ALWAYS_ \ (u0 :: Int) (u1 :: [Int]) -> let {(u5 :: Int -> Bool) = \ (u2 :: Int) -> case u0 of { _ALG_ I# (u3 :: Int#) -> case u2 of { _ALG_ I# (u4 :: Int#) -> _#_ eqInt# [] [u3, u4]; _NO_DEFLT_ }; _NO_DEFLT_ }} in _APP_ _TYAPP_ _ORIG_ PreludeList any { Int } [ u5, u1 ] _N_ }, [ [Char] ] 1 { _A_ 2 _U_ 21 _N_ _S_ "LS" _F_ _ALWAYS_ \ (u0 :: [Char]) (u1 :: [[Char]]) -> let {(u3 :: [Char] -> Bool) = \ (u2 :: [Char]) -> _APP_ _CONSTM_ Eq (==) ([Char]) [ u0, u2 ]} in _APP_ _TYAPP_ _ORIG_ PreludeList any { [Char] } [ u3, u1 ] _N_ } #-}
+ {-# GHC_PRAGMA _A_ 3 _U_ 121 _N_ _S_ "LLS" _F_ _ALWAYS_ _/\_ u0 -> \ (u1 :: {{Eq u0}}) (u2 :: u0) (u3 :: [u0]) -> let {(u6 :: u0 -> u0 -> Bool) = case u1 of { _ALG_ _TUP_2 (u4 :: u0 -> u0 -> Bool) (u5 :: u0 -> u0 -> Bool) -> u4; _NO_DEFLT_ }} in let {(u8 :: u0 -> Bool) = \ (u7 :: u0) -> _APP_ u6 [ u2, u7 ]} in _APP_ _TYAPP_ _ORIG_ PreludeList any { u0 } [ u8, u3 ] _SPECIALISE_ [ Char ] 1 { _A_ 2 _U_ 21 _N_ _S_ "LS" _F_ _ALWAYS_ \ (u0 :: Char) (u1 :: [Char]) -> let {(u5 :: Char -> Bool) = \ (u2 :: Char) -> case u0 of { _ALG_ C# (u3 :: Char#) -> case u2 of { _ALG_ C# (u4 :: Char#) -> _#_ eqChar# [] [u3, u4]; _NO_DEFLT_ }; _NO_DEFLT_ }} in _APP_ _TYAPP_ _ORIG_ PreludeList any { Char } [ u5, u1 ] _N_ }, [ Int ] 1 { _A_ 2 _U_ 21 _N_ _S_ "LS" _F_ _ALWAYS_ \ (u0 :: Int) (u1 :: [Int]) -> let {(u5 :: Int -> Bool) = \ (u2 :: Int) -> case u0 of { _ALG_ I# (u3 :: Int#) -> case u2 of { _ALG_ I# (u4 :: Int#) -> _#_ eqInt# [] [u3, u4]; _NO_DEFLT_ }; _NO_DEFLT_ }} in _APP_ _TYAPP_ _ORIG_ PreludeList any { Int } [ u5, u1 ] _N_ }, [ Integer ] 1 { _A_ 2 _U_ 21 _N_ _S_ "LS" _F_ _ALWAYS_ \ (u0 :: Integer) (u1 :: [Integer]) -> let {(ua :: Integer -> Bool) = \ (u2 :: Integer) -> case u0 of { _ALG_ J# (u3 :: Int#) (u4 :: Int#) (u5 :: ByteArray#) -> case u2 of { _ALG_ J# (u6 :: Int#) (u7 :: Int#) (u8 :: ByteArray#) -> case _#_ cmpInteger# [] [u3, u4, u5, u6, u7, u8] of { _PRIM_ 0# -> _!_ True [] []; (u9 :: Int#) -> _!_ False [] [] }; _NO_DEFLT_ }; _NO_DEFLT_ }} in _APP_ _TYAPP_ _ORIG_ PreludeList any { Integer } [ ua, u1 ] _N_ }, [ [Char] ] 1 { _A_ 2 _U_ 21 _N_ _S_ "LS" _F_ _ALWAYS_ \ (u0 :: [Char]) (u1 :: [[Char]]) -> let {(u3 :: [Char] -> Bool) = \ (u2 :: [Char]) -> _APP_ _CONSTM_ Eq (==) ([Char]) [ u0, u2 ]} in _APP_ _TYAPP_ _ORIG_ PreludeList any { [Char] } [ u3, u1 ] _N_ }, [ [Int] ] 1 { _A_ 2 _U_ 21 _N_ _S_ "LS" _F_ _ALWAYS_ \ (u0 :: [Int]) (u1 :: [[Int]]) -> let {(u3 :: [Int] -> Bool) = \ (u2 :: [Int]) -> _APP_ _CONSTM_ Eq (==) ([Int]) [ u0, u2 ]} in _APP_ _TYAPP_ _ORIG_ PreludeList any { [Int] } [ u3, u1 ] _N_ }, [ (Int, Int) ] 1 { _A_ 2 _U_ 21 _N_ _S_ "LS" _F_ _ALWAYS_ \ (u0 :: (Int, Int)) (u1 :: [(Int, Int)]) -> let {(ub :: (Int, Int) -> Bool) = \ (u2 :: (Int, Int)) -> case u0 of { _ALG_ _TUP_2 (u3 :: Int) (u4 :: Int) -> case u3 of { _ALG_ I# (u5 :: Int#) -> case u2 of { _ALG_ _TUP_2 (u6 :: Int) (u7 :: Int) -> case u6 of { _ALG_ I# (u8 :: Int#) -> case _#_ eqInt# [] [u5, u8] of { _ALG_ True -> case u4 of { _ALG_ I# (u9 :: Int#) -> case u7 of { _ALG_ I# (ua :: Int#) -> _#_ eqInt# [] [u9, ua]; _NO_DEFLT_ }; _NO_DEFLT_ }; False -> _!_ False [] []; _NO_DEFLT_ }; _NO_DEFLT_ }; _NO_DEFLT_ }; _NO_DEFLT_ }; _NO_DEFLT_ }} in _APP_ _TYAPP_ _ORIG_ PreludeList any { (Int, Int) } [ ub, u1 ] _N_ } #-}
filter :: (a -> Bool) -> [a] -> [a]
{-# GHC_PRAGMA _A_ 2 _U_ 21 _N_ _S_ "LS" _F_ _ALWAYS_ _/\_ u0 -> \ (u1 :: u0 -> Bool) (u2 :: [u0]) -> let {(u9 :: _forall_ a$z1 =>(u0 -> a$z1 -> a$z1) -> a$z1 -> a$z1) = _/\_ u3 -> \ (u4 :: u0 -> u3 -> u3) (u5 :: u3) -> let {(u8 :: u0 -> u3 -> u3) = \ (u6 :: u0) (u7 :: u3) -> case _APP_ u1 [ u6 ] of { _ALG_ True -> _APP_ u4 [ u6, u7 ]; False -> u7; _NO_DEFLT_ }} in _APP_ _TYAPP_ _TYAPP_ foldr { u0 } { u3 } [ u8, u5, u2 ]} in _APP_ _TYAPP_ _build { u0 } [ u9 ] _N_ #-}
foldl1 :: (a -> a -> a) -> [a] -> a
foldr1 :: (a -> a -> a) -> [a] -> a
{-# GHC_PRAGMA _A_ 2 _U_ 21 _N_ _S_ "LS" _N_ _N_ #-}
genericLength :: Num b => [a] -> b
- {-# GHC_PRAGMA _A_ 1 _U_ 21 _N_ _N_ _N_ _N_ #-}
+ {-# GHC_PRAGMA _A_ 1 _U_ 21 _N_ _N_ _N_ _SPECIALISE_ [ _N_, Int ] 1 { _A_ 1 _U_ 1 _N_ _S_ "S" _N_ _N_ }, [ _N_, Integer ] 1 { _A_ 1 _U_ 1 _N_ _S_ "S" _N_ _N_ } #-}
head :: [a] -> a
{-# GHC_PRAGMA _A_ 1 _U_ 1 _N_ _S_ "S" _F_ _ALWAYS_ _/\_ u0 -> \ (u1 :: [u0]) -> let {(u2 :: u0) = _APP_ _TYAPP_ error { u0 } [ _NOREP_S_ "head{PreludeList}: head []\n" ]} in let {(u5 :: u0 -> u0 -> u0) = \ (u3 :: u0) (u4 :: u0) -> u3} in _APP_ _TYAPP_ _TYAPP_ foldr { u0 } { u0 } [ u5, u2, u1 ] _N_ #-}
init :: [a] -> [a]
map :: (a -> b) -> [a] -> [b]
{-# GHC_PRAGMA _A_ 2 _U_ 21 _N_ _S_ "LS" _F_ _ALWAYS_ _/\_ u0 u1 -> \ (u2 :: u0 -> u1) (u3 :: [u0]) -> let {(ua :: _forall_ a$z1 =>(u1 -> a$z1 -> a$z1) -> a$z1 -> a$z1) = _/\_ u4 -> \ (u5 :: u1 -> u4 -> u4) (u6 :: u4) -> let {(u9 :: u0 -> u4 -> u4) = \ (u7 :: u0) -> let {(u8 :: u1) = _APP_ u2 [ u7 ]} in _APP_ u5 [ u8 ]} in _APP_ _TYAPP_ _TYAPP_ foldr { u0 } { u4 } [ u9, u6, u3 ]} in _APP_ _TYAPP_ _build { u1 } [ ua ] _N_ #-}
maximum :: Ord a => [a] -> a
- {-# GHC_PRAGMA _A_ 1 _U_ 11 _N_ _N_ _N_ _N_ #-}
+ {-# GHC_PRAGMA _A_ 1 _U_ 11 _N_ _N_ _N_ _SPECIALISE_ [ Double ] 1 { _A_ 1 _U_ 1 _N_ _S_ "S" _N_ _N_ }, [ Int ] 1 { _A_ 1 _U_ 1 _N_ _S_ "S" _N_ _N_ }, [ Integer ] 1 { _A_ 1 _U_ 1 _N_ _S_ "S" _N_ _N_ } #-}
minimum :: Ord a => [a] -> a
- {-# GHC_PRAGMA _A_ 1 _U_ 11 _N_ _N_ _N_ _N_ #-}
+ {-# GHC_PRAGMA _A_ 1 _U_ 11 _N_ _N_ _N_ _SPECIALISE_ [ Double ] 1 { _A_ 1 _U_ 1 _N_ _S_ "S" _N_ _N_ }, [ Int ] 1 { _A_ 1 _U_ 1 _N_ _S_ "S" _N_ _N_ }, [ Integer ] 1 { _A_ 1 _U_ 1 _N_ _S_ "S" _N_ _N_ } #-}
notElem :: Eq a => a -> [a] -> Bool
- {-# GHC_PRAGMA _A_ 3 _U_ 121 _N_ _S_ "LLS" _F_ _ALWAYS_ _/\_ u0 -> \ (u1 :: {{Eq u0}}) (u2 :: u0) (u3 :: [u0]) -> let {(u6 :: u0 -> u0 -> Bool) = case u1 of { _ALG_ _TUP_2 (u4 :: u0 -> u0 -> Bool) (u5 :: u0 -> u0 -> Bool) -> u5; _NO_DEFLT_ }} in let {(u8 :: u0 -> Bool) = \ (u7 :: u0) -> _APP_ u6 [ u2, u7 ]} in _APP_ _TYAPP_ _ORIG_ PreludeList all { u0 } [ u8, u3 ] _SPECIALISE_ [ Char ] 1 { _A_ 2 _U_ 21 _N_ _S_ "LS" _F_ _ALWAYS_ \ (u0 :: Char) (u1 :: [Char]) -> let {(u5 :: Char -> Bool) = \ (u2 :: Char) -> case u0 of { _ALG_ C# (u3 :: Char#) -> case u2 of { _ALG_ C# (u4 :: Char#) -> _#_ neChar# [] [u3, u4]; _NO_DEFLT_ }; _NO_DEFLT_ }} in _APP_ _TYAPP_ _ORIG_ PreludeList all { Char } [ u5, u1 ] _N_ }, [ Int ] 1 { _A_ 2 _U_ 21 _N_ _S_ "LS" _F_ _ALWAYS_ \ (u0 :: Int) (u1 :: [Int]) -> let {(u5 :: Int -> Bool) = \ (u2 :: Int) -> case u0 of { _ALG_ I# (u3 :: Int#) -> case u2 of { _ALG_ I# (u4 :: Int#) -> _#_ neInt# [] [u3, u4]; _NO_DEFLT_ }; _NO_DEFLT_ }} in _APP_ _TYAPP_ _ORIG_ PreludeList all { Int } [ u5, u1 ] _N_ }, [ [Char] ] 1 { _A_ 2 _U_ 21 _N_ _S_ "LS" _F_ _ALWAYS_ \ (u0 :: [Char]) (u1 :: [[Char]]) -> let {(u3 :: [Char] -> Bool) = \ (u2 :: [Char]) -> _APP_ _CONSTM_ Eq (/=) ([Char]) [ u0, u2 ]} in _APP_ _TYAPP_ _ORIG_ PreludeList all { [Char] } [ u3, u1 ] _N_ } #-}
+ {-# GHC_PRAGMA _A_ 3 _U_ 121 _N_ _S_ "LLS" _F_ _ALWAYS_ _/\_ u0 -> \ (u1 :: {{Eq u0}}) (u2 :: u0) (u3 :: [u0]) -> let {(u6 :: u0 -> u0 -> Bool) = case u1 of { _ALG_ _TUP_2 (u4 :: u0 -> u0 -> Bool) (u5 :: u0 -> u0 -> Bool) -> u5; _NO_DEFLT_ }} in let {(u8 :: u0 -> Bool) = \ (u7 :: u0) -> _APP_ u6 [ u2, u7 ]} in _APP_ _TYAPP_ _ORIG_ PreludeList all { u0 } [ u8, u3 ] _SPECIALISE_ [ Char ] 1 { _A_ 2 _U_ 21 _N_ _S_ "LS" _F_ _ALWAYS_ \ (u0 :: Char) (u1 :: [Char]) -> let {(u5 :: Char -> Bool) = \ (u2 :: Char) -> case u0 of { _ALG_ C# (u3 :: Char#) -> case u2 of { _ALG_ C# (u4 :: Char#) -> _#_ neChar# [] [u3, u4]; _NO_DEFLT_ }; _NO_DEFLT_ }} in _APP_ _TYAPP_ _ORIG_ PreludeList all { Char } [ u5, u1 ] _N_ }, [ Int ] 1 { _A_ 2 _U_ 21 _N_ _S_ "LS" _F_ _ALWAYS_ \ (u0 :: Int) (u1 :: [Int]) -> let {(u5 :: Int -> Bool) = \ (u2 :: Int) -> case u0 of { _ALG_ I# (u3 :: Int#) -> case u2 of { _ALG_ I# (u4 :: Int#) -> _#_ neInt# [] [u3, u4]; _NO_DEFLT_ }; _NO_DEFLT_ }} in _APP_ _TYAPP_ _ORIG_ PreludeList all { Int } [ u5, u1 ] _N_ }, [ Integer ] 1 { _A_ 2 _U_ 21 _N_ _S_ "LS" _F_ _ALWAYS_ \ (u0 :: Integer) (u1 :: [Integer]) -> let {(ua :: Integer -> Bool) = \ (u2 :: Integer) -> case u0 of { _ALG_ J# (u3 :: Int#) (u4 :: Int#) (u5 :: ByteArray#) -> case u2 of { _ALG_ J# (u6 :: Int#) (u7 :: Int#) (u8 :: ByteArray#) -> case _#_ cmpInteger# [] [u3, u4, u5, u6, u7, u8] of { _PRIM_ 0# -> _!_ False [] []; (u9 :: Int#) -> _!_ True [] [] }; _NO_DEFLT_ }; _NO_DEFLT_ }} in _APP_ _TYAPP_ _ORIG_ PreludeList all { Integer } [ ua, u1 ] _N_ }, [ [Char] ] 1 { _A_ 2 _U_ 21 _N_ _S_ "LS" _F_ _ALWAYS_ \ (u0 :: [Char]) (u1 :: [[Char]]) -> let {(u3 :: [Char] -> Bool) = \ (u2 :: [Char]) -> _APP_ _CONSTM_ Eq (/=) ([Char]) [ u0, u2 ]} in _APP_ _TYAPP_ _ORIG_ PreludeList all { [Char] } [ u3, u1 ] _N_ }, [ (Int, Int) ] 1 { _A_ 2 _U_ 21 _N_ _S_ "LS" _F_ _ALWAYS_ \ (u0 :: (Int, Int)) (u1 :: [(Int, Int)]) -> let {(ub :: (Int, Int) -> Bool) = \ (u2 :: (Int, Int)) -> case u0 of { _ALG_ _TUP_2 (u3 :: Int) (u4 :: Int) -> case u3 of { _ALG_ I# (u5 :: Int#) -> case u2 of { _ALG_ _TUP_2 (u6 :: Int) (u7 :: Int) -> case u6 of { _ALG_ I# (u8 :: Int#) -> case _#_ neInt# [] [u5, u8] of { _ALG_ True -> _!_ True [] []; False -> case u4 of { _ALG_ I# (u9 :: Int#) -> case u7 of { _ALG_ I# (ua :: Int#) -> _#_ neInt# [] [u9, ua]; _NO_DEFLT_ }; _NO_DEFLT_ }; _NO_DEFLT_ }; _NO_DEFLT_ }; _NO_DEFLT_ }; _NO_DEFLT_ }; _NO_DEFLT_ }} in _APP_ _TYAPP_ _ORIG_ PreludeList all { (Int, Int) } [ ub, u1 ] _N_ } #-}
nub :: Eq a => [a] -> [a]
- {-# GHC_PRAGMA _A_ 2 _U_ 11 _N_ _S_ "LS" _N_ _N_ #-}
+ {-# GHC_PRAGMA _A_ 2 _U_ 11 _N_ _S_ "LS" _N_ _SPECIALISE_ [ Int ] 1 { _A_ 1 _U_ 1 _N_ _S_ "S" _N_ _N_ }, [ [Char] ] 1 { _A_ 1 _U_ 1 _N_ _S_ "S" _N_ _N_ }, [ [Int] ] 1 { _A_ 1 _U_ 1 _N_ _S_ "S" _N_ _N_ } #-}
null :: [a] -> Bool
{-# GHC_PRAGMA _A_ 1 _U_ 1 _N_ _S_ "S" _F_ _ALWAYS_ _/\_ u0 -> \ (u1 :: [u0]) -> let {(u2 :: Bool) = _!_ True [] []} in let {(u5 :: u0 -> Bool -> Bool) = \ (u3 :: u0) (u4 :: Bool) -> _!_ False [] []} in _APP_ _TYAPP_ _TYAPP_ foldr { u0 } { Bool } [ u5, u2, u1 ] _N_ #-}
or :: [Bool] -> Bool
partition :: (a -> Bool) -> [a] -> ([a], [a])
{-# GHC_PRAGMA _A_ 2 _U_ 21 _N_ _S_ "LS" _F_ _ALWAYS_ _/\_ u0 -> \ (u1 :: u0 -> Bool) (u2 :: [u0]) -> let {(u9 :: u0 -> ([u0], [u0]) -> ([u0], [u0])) = \ (u3 :: u0) (u4 :: ([u0], [u0])) -> case u4 of { _ALG_ _TUP_2 (u5 :: [u0]) (u6 :: [u0]) -> case _APP_ u1 [ u3 ] of { _ALG_ True -> let {(u7 :: [u0]) = _!_ (:) [u0] [u3, u5]} in _!_ _TUP_2 [[u0], [u0]] [u7, u6]; False -> let {(u8 :: [u0]) = _!_ (:) [u0] [u3, u6]} in _!_ _TUP_2 [[u0], [u0]] [u5, u8]; _NO_DEFLT_ }; _NO_DEFLT_ }} in let {(ua :: [u0]) = _!_ _NIL_ [u0] []} in let {(ub :: ([u0], [u0])) = _!_ _TUP_2 [[u0], [u0]] [ua, ua]} in _APP_ _TYAPP_ _TYAPP_ foldr { u0 } { ([u0], [u0]) } [ u9, ub, u2 ] _N_ #-}
product :: Num a => [a] -> a
- {-# GHC_PRAGMA _A_ 1 _U_ 22 _N_ _N_ _F_ _ALWAYS_ _/\_ u0 -> \ (u1 :: {{Num u0}}) -> let {(uc :: u0 -> u0 -> u0) = case u1 of { _ALG_ _TUP_10 (u2 :: {{Eq u0}}) (u3 :: {{Text u0}}) (u4 :: u0 -> u0 -> u0) (u5 :: u0 -> u0 -> u0) (u6 :: u0 -> u0 -> u0) (u7 :: u0 -> u0) (u8 :: u0 -> u0) (u9 :: u0 -> u0) (ua :: Integer -> u0) (ub :: Int -> u0) -> u6; _NO_DEFLT_ }} in let {(uo :: u0) = let {(ud :: Int) = _!_ I# [] [1#]} in case u1 of { _ALG_ _TUP_10 (ue :: {{Eq u0}}) (uf :: {{Text u0}}) (ug :: u0 -> u0 -> u0) (uh :: u0 -> u0 -> u0) (ui :: u0 -> u0 -> u0) (uj :: u0 -> u0) (uk :: u0 -> u0) (ul :: u0 -> u0) (um :: Integer -> u0) (un :: Int -> u0) -> _APP_ un [ ud ]; _NO_DEFLT_ }} in \ (up :: [u0]) -> _APP_ _TYAPP_ _TYAPP_ foldl { u0 } { u0 } [ uc, uo, up ] _SPECIALISE_ [ Double ] 1 { _A_ 1 _U_ 1 _N_ _S_ "S" _F_ _ALWAYS_ \ (u0 :: [Double]) -> let {(u1 :: Double) = _!_ D# [] [1.0000000000000000##]} in _APP_ _TYAPP_ _TYAPP_ foldl { Double } { Double } [ _CONSTM_ Num (*) (Double), u1, u0 ] _N_ }, [ Int ] 1 { _A_ 1 _U_ 1 _N_ _S_ "S" _F_ _ALWAYS_ \ (u0 :: [Int]) -> let {(u1 :: Int) = _!_ I# [] [1#]} in _APP_ _TYAPP_ _TYAPP_ foldl { Int } { Int } [ _CONSTM_ Num (*) (Int), u1, u0 ] _N_ }, [ Integer ] 1 { _A_ 1 _U_ 1 _N_ _S_ "S" _F_ _ALWAYS_ \ (u0 :: [Integer]) -> let {(u1 :: Integer) = _#_ int2Integer# [] [1#]} in _APP_ _TYAPP_ _TYAPP_ foldl { Integer } { Integer } [ _CONSTM_ Num (*) (Integer), u1, u0 ] _N_ } #-}
+ {-# GHC_PRAGMA _A_ 1 _U_ 22 _N_ _N_ _F_ _ALWAYS_ _/\_ u0 -> \ (u1 :: {{Num u0}}) -> let {(uc :: u0 -> u0 -> u0) = case u1 of { _ALG_ _TUP_10 (u2 :: {{Eq u0}}) (u3 :: {{Text u0}}) (u4 :: u0 -> u0 -> u0) (u5 :: u0 -> u0 -> u0) (u6 :: u0 -> u0 -> u0) (u7 :: u0 -> u0) (u8 :: u0 -> u0) (u9 :: u0 -> u0) (ua :: Integer -> u0) (ub :: Int -> u0) -> u6; _NO_DEFLT_ }} in let {(uo :: u0) = let {(ud :: Int) = _!_ I# [] [1#]} in case u1 of { _ALG_ _TUP_10 (ue :: {{Eq u0}}) (uf :: {{Text u0}}) (ug :: u0 -> u0 -> u0) (uh :: u0 -> u0 -> u0) (ui :: u0 -> u0 -> u0) (uj :: u0 -> u0) (uk :: u0 -> u0) (ul :: u0 -> u0) (um :: Integer -> u0) (un :: Int -> u0) -> _APP_ un [ ud ]; _NO_DEFLT_ }} in \ (up :: [u0]) -> _APP_ _TYAPP_ _TYAPP_ foldl { u0 } { u0 } [ uc, uo, up ] _SPECIALISE_ [ Double ] 1 { _A_ 1 _U_ 1 _N_ _S_ "S" _F_ _ALWAYS_ \ (u0 :: [Double]) -> let {(u1 :: Double) = _!_ D# [] [1.0000000000000000##]} in _APP_ _TYAPP_ _TYAPP_ foldl { Double } { Double } [ _CONSTM_ Num (*) (Double), u1, u0 ] _N_ }, [ Int ] 1 { _A_ 1 _U_ 1 _N_ _S_ "S" _F_ _ALWAYS_ \ (u0 :: [Int]) -> let {(u1 :: Int) = _!_ I# [] [1#]} in _APP_ _TYAPP_ _TYAPP_ foldl { Int } { Int } [ _CONSTM_ Num (*) (Int), u1, u0 ] _N_ }, [ Integer ] 1 { _A_ 1 _U_ 1 _N_ _S_ "S" _F_ _ALWAYS_ \ (u0 :: [Integer]) -> let {(u1 :: Integer) = _#_ int2Integer# [] [1#]} in _APP_ _TYAPP_ _TYAPP_ foldl { Integer } { Integer } [ _CONSTM_ Num (*) (Integer), u1, u0 ] _N_ }, [ (Complex Double) ] 1 { _A_ 1 _U_ 1 _N_ _S_ "S" _F_ _ALWAYS_ let {(u6 :: Complex Double -> Complex Double -> Complex Double) = \ (u0 :: Complex Double) (u1 :: Complex Double) -> case u0 of { _ALG_ (:+) (u2 :: Double) (u3 :: Double) -> case u1 of { _ALG_ (:+) (u4 :: Double) (u5 :: Double) -> _APP_ _WRKR_ _CONSTM_ Num (*) (Complex Double) [ u2, u3, u4, u5 ]; _NO_DEFLT_ }; _NO_DEFLT_ }} in let {(u8 :: Complex Double) = let {(u7 :: Int) = _!_ I# [] [1#]} in _APP_ _CONSTM_ Num fromInt (Complex Double) [ u7 ]} in \ (u9 :: [Complex Double]) -> _APP_ _TYAPP_ _TYAPP_ foldl { (Complex Double) } { (Complex Double) } [ u6, u8, u9 ] _N_ } #-}
products :: Num a => [a] -> [a]
- {-# GHC_PRAGMA _A_ 1 _U_ 21 _N_ _N_ _N_ _N_ #-}
+ {-# GHC_PRAGMA _A_ 1 _U_ 21 _N_ _N_ _N_ _SPECIALISE_ [ Double ] 1 { _A_ 1 _U_ 1 _N_ _N_ _N_ _N_ }, [ Int ] 1 { _A_ 1 _U_ 1 _N_ _N_ _N_ _N_ }, [ Integer ] 1 { _A_ 1 _U_ 1 _N_ _N_ _F_ _IF_ARGS_ 0 1 X 4 \ (u0 :: [Integer]) -> _APP_ _TYAPP_ _TYAPP_ _ORIG_ PreludeList scanl { Integer } { Integer } [ _CONSTM_ Num (*) (Integer), _SPEC_ _ORIG_ PreludeCore __i1 [ (Integer) ], u0 ] _N_ }, [ (Complex Double) ] 1 { _A_ 1 _U_ 1 _N_ _N_ _N_ _N_ } #-}
repeat :: a -> [a]
{-# GHC_PRAGMA _A_ 1 _U_ 2 _N_ _N_ _F_ _ALWAYS_ _/\_ u0 -> \ (u1 :: u0) -> let {(u6 :: _forall_ a$z1 =>(u0 -> a$z1 -> a$z1) -> a$z1 -> a$z1) = _/\_ u2 -> \ (u3 :: u0 -> u2 -> u2) (u4 :: u2) -> _LETREC_ {(u5 :: u2) = _APP_ u3 [ u1, u5 ]} in u5} in _APP_ _TYAPP_ _build { u0 } [ u6 ] _N_ #-}
reverse :: [a] -> [a]
sum :: Num a => [a] -> a
{-# GHC_PRAGMA _A_ 1 _U_ 22 _N_ _N_ _F_ _ALWAYS_ _/\_ u0 -> \ (u1 :: {{Num u0}}) -> let {(uc :: u0 -> u0 -> u0) = case u1 of { _ALG_ _TUP_10 (u2 :: {{Eq u0}}) (u3 :: {{Text u0}}) (u4 :: u0 -> u0 -> u0) (u5 :: u0 -> u0 -> u0) (u6 :: u0 -> u0 -> u0) (u7 :: u0 -> u0) (u8 :: u0 -> u0) (u9 :: u0 -> u0) (ua :: Integer -> u0) (ub :: Int -> u0) -> u4; _NO_DEFLT_ }} in let {(uo :: u0) = let {(ud :: Int) = _!_ I# [] [0#]} in case u1 of { _ALG_ _TUP_10 (ue :: {{Eq u0}}) (uf :: {{Text u0}}) (ug :: u0 -> u0 -> u0) (uh :: u0 -> u0 -> u0) (ui :: u0 -> u0 -> u0) (uj :: u0 -> u0) (uk :: u0 -> u0) (ul :: u0 -> u0) (um :: Integer -> u0) (un :: Int -> u0) -> _APP_ un [ ud ]; _NO_DEFLT_ }} in \ (up :: [u0]) -> _APP_ _TYAPP_ _TYAPP_ foldl { u0 } { u0 } [ uc, uo, up ] _SPECIALISE_ [ Double ] 1 { _A_ 1 _U_ 1 _N_ _S_ "S" _F_ _ALWAYS_ \ (u0 :: [Double]) -> let {(u1 :: Double) = _!_ D# [] [0.0000000000000000##]} in _APP_ _TYAPP_ _TYAPP_ foldl { Double } { Double } [ _CONSTM_ Num (+) (Double), u1, u0 ] _N_ }, [ Int ] 1 { _A_ 1 _U_ 1 _N_ _S_ "S" _F_ _ALWAYS_ \ (u0 :: [Int]) -> let {(u1 :: Int) = _!_ I# [] [0#]} in _APP_ _TYAPP_ _TYAPP_ foldl { Int } { Int } [ _CONSTM_ Num (+) (Int), u1, u0 ] _N_ }, [ Integer ] 1 { _A_ 1 _U_ 1 _N_ _S_ "S" _F_ _ALWAYS_ \ (u0 :: [Integer]) -> let {(u1 :: Integer) = _#_ int2Integer# [] [0#]} in _APP_ _TYAPP_ _TYAPP_ foldl { Integer } { Integer } [ _CONSTM_ Num (+) (Integer), u1, u0 ] _N_ }, [ (Complex Double) ] 1 { _A_ 1 _U_ 1 _N_ _S_ "S" _F_ _ALWAYS_ let {(u6 :: Complex Double -> Complex Double -> Complex Double) = \ (u0 :: Complex Double) (u1 :: Complex Double) -> case u0 of { _ALG_ (:+) (u2 :: Double) (u3 :: Double) -> case u1 of { _ALG_ (:+) (u4 :: Double) (u5 :: Double) -> _APP_ _WRKR_ _CONSTM_ Num (+) (Complex Double) [ u2, u3, u4, u5 ]; _NO_DEFLT_ }; _NO_DEFLT_ }} in let {(u8 :: Complex Double) = let {(u7 :: Int) = _!_ I# [] [0#]} in _APP_ _CONSTM_ Num fromInt (Complex Double) [ u7 ]} in \ (u9 :: [Complex Double]) -> _APP_ _TYAPP_ _TYAPP_ foldl { (Complex Double) } { (Complex Double) } [ u6, u8, u9 ] _N_ } #-}
sums :: Num a => [a] -> [a]
- {-# GHC_PRAGMA _A_ 1 _U_ 21 _N_ _N_ _N_ _N_ #-}
+ {-# GHC_PRAGMA _A_ 1 _U_ 21 _N_ _N_ _N_ _SPECIALISE_ [ Double ] 1 { _A_ 1 _U_ 1 _N_ _N_ _N_ _N_ }, [ Int ] 1 { _A_ 1 _U_ 1 _N_ _N_ _N_ _N_ }, [ Integer ] 1 { _A_ 1 _U_ 1 _N_ _N_ _F_ _IF_ARGS_ 0 1 X 4 \ (u0 :: [Integer]) -> _APP_ _TYAPP_ _TYAPP_ _ORIG_ PreludeList scanl { Integer } { Integer } [ _CONSTM_ Num (+) (Integer), _SPEC_ _ORIG_ PreludeCore __i0 [ (Integer) ], u0 ] _N_ }, [ (Complex Double) ] 1 { _A_ 1 _U_ 1 _N_ _N_ _N_ _N_ } #-}
tail :: [a] -> [a]
{-# GHC_PRAGMA _A_ 1 _U_ 1 _N_ _S_ "S" _F_ _IF_ARGS_ 1 1 C 5 _/\_ u0 -> \ (u1 :: [u0]) -> case u1 of { _ALG_ (:) (u2 :: u0) (u3 :: [u0]) -> u3; _NIL_ -> _APP_ _TYAPP_ error { [u0] } [ _NOREP_S_ "tail{PreludeList}: tail []\n" ]; _NO_DEFLT_ } _N_ #-}
take :: Integral a => a -> [b] -> [b]
- {-# GHC_PRAGMA _A_ 3 _U_ 121 _N_ _S_ "U(AAAAAAAAAAAS)LL" {_A_ 3 _U_ 121 _N_ _N_ _N_ _N_} _F_ _IF_ARGS_ 2 3 CXX 7 _/\_ u0 u1 -> \ (u2 :: {{Integral u0}}) (u3 :: u0) (u4 :: [u1]) -> let {(uh :: Int) = case u2 of { _ALG_ _TUP_12 (u5 :: {{Real u0}}) (u6 :: {{Ix u0}}) (u7 :: u0 -> u0 -> u0) (u8 :: u0 -> u0 -> u0) (u9 :: u0 -> u0 -> u0) (ua :: u0 -> u0 -> u0) (ub :: u0 -> u0 -> (u0, u0)) (uc :: u0 -> u0 -> (u0, u0)) (ud :: u0 -> Bool) (ue :: u0 -> Bool) (uf :: u0 -> Integer) (ug :: u0 -> Int) -> _APP_ ug [ u3 ]; _NO_DEFLT_ }} in _APP_ _TYAPP_ _SPEC_ _ORIG_ PreludeList take [ (Int), _N_ ] { u1 } [ uh, u4 ] _SPECIALISE_ [ Int, _N_ ] 1 { _A_ 2 _U_ 11 _N_ _S_ "U(P)L" {_A_ 2 _U_ 21 _N_ _N_ _N_ _N_} _N_ _N_ }, [ Integer, _N_ ] 1 { _A_ 2 _U_ 11 _N_ _S_ "U(PPP)L" {_A_ 4 _U_ 2221 _N_ _N_ _F_ _IF_ARGS_ 1 4 XXXX 4 _/\_ u0 -> \ (u1 :: Int#) (u2 :: Int#) (u3 :: ByteArray#) (u4 :: [u0]) -> case _#_ integer2Int# [] [u1, u2, u3] of { _PRIM_ (u5 :: Int#) -> _APP_ _TYAPP_ _WRKR_ _SPEC_ _ORIG_ PreludeList take [ (Int), _N_ ] { u0 } [ u5, u4 ] } _N_} _F_ _ALWAYS_ _/\_ u0 -> \ (u1 :: Integer) (u2 :: [u0]) -> case u1 of { _ALG_ J# (u3 :: Int#) (u4 :: Int#) (u5 :: ByteArray#) -> case _#_ integer2Int# [] [u3, u4, u5] of { _PRIM_ (u6 :: Int#) -> _APP_ _TYAPP_ _WRKR_ _SPEC_ _ORIG_ PreludeList take [ (Int), _N_ ] { u0 } [ u6, u2 ] }; _NO_DEFLT_ } _N_ } #-}
+ {-# GHC_PRAGMA _A_ 1 _U_ 122 _N_ _S_ "U(LU(U(ASSAAAAA)AAA)AAAALAAAAL)" {_A_ 5 _U_ 2121222 _N_ _N_ _N_ _N_} _N_ _SPECIALISE_ [ Int, _N_ ] 1 { _A_ 2 _U_ 11 _N_ _S_ "U(P)L" {_A_ 2 _U_ 21 _N_ _N_ _N_ _N_} _N_ _N_ }, [ Integer, _N_ ] 1 { _A_ 1 _U_ 12 _N_ _S_ "U(PPP)" {_A_ 3 _U_ 2222 _N_ _N_ _N_ _N_} _N_ _N_ } #-}
takeWhile :: (a -> Bool) -> [a] -> [a]
{-# GHC_PRAGMA _A_ 2 _U_ 21 _N_ _S_ "LS" _F_ _ALWAYS_ _/\_ u0 -> \ (u1 :: u0 -> Bool) (u2 :: [u0]) -> let {(u9 :: _forall_ a$z1 =>(u0 -> a$z1 -> a$z1) -> a$z1 -> a$z1) = _/\_ u3 -> \ (u4 :: u0 -> u3 -> u3) (u5 :: u3) -> let {(u8 :: u0 -> u3 -> u3) = \ (u6 :: u0) (u7 :: u3) -> case _APP_ u1 [ u6 ] of { _ALG_ True -> _APP_ u4 [ u6, u7 ]; False -> u5; _NO_DEFLT_ }} in _APP_ _TYAPP_ _TYAPP_ foldr { u0 } { u3 } [ u8, u5, u2 ]} in _APP_ _TYAPP_ _build { u0 } [ u9 ] _N_ #-}
transpose :: [[a]] -> [[a]]
-{-# GHC_PRAGMA INTERFACE VERSION 5 #-}
+{-# GHC_PRAGMA INTERFACE VERSION 6 #-}
interface PreludeList where
import PreludeBuiltin(Char(..), Int(..), List(..), Tuple2, Tuple3, Tuple4, Tuple5, Tuple6, Tuple7)
import PreludeCore(Bool(..), Eq(..), Integral(..), Num(..), Ord(..))
(++) :: [a] -> [a] -> [a]
{-# GHC_PRAGMA _A_ 2 _U_ 12 _N_ _S_ "SL" _N_ _N_ #-}
(\\) :: Eq a => [a] -> [a] -> [a]
- {-# GHC_PRAGMA _A_ 3 _U_ 122 _N_ _S_ "LLS" _N_ _N_ #-}
+ {-# GHC_PRAGMA _A_ 3 _U_ 122 _N_ _S_ "LLS" _N_ _SPECIALISE_ [ Int ] 1 { _A_ 2 _U_ 22 _N_ _S_ "LS" _N_ _N_ }, [ [Char] ] 1 { _A_ 2 _U_ 22 _N_ _S_ "LS" _N_ _N_ } #-}
all :: (a -> Bool) -> [a] -> Bool
{-# GHC_PRAGMA _A_ 2 _U_ 21 _N_ _S_ "LS" _F_ _ALWAYS_ _/\_ u0 -> \ (u1 :: u0 -> Bool) (u2 :: [u0]) -> let {(u3 :: Bool) = _!_ True [] []} in let {(u6 :: u0 -> Bool -> Bool) = \ (u4 :: u0) (u5 :: Bool) -> case _APP_ u1 [ u4 ] of { _ALG_ True -> u5; False -> _!_ False [] []; _NO_DEFLT_ }} in _APP_ _TYAPP_ _TYAPP_ foldr { u0 } { Bool } [ u6, u3, u2 ] _N_ #-}
and :: [Bool] -> Bool
dropWhile :: (a -> Bool) -> [a] -> [a]
{-# GHC_PRAGMA _A_ 2 _U_ 21 _N_ _S_ "LS" _N_ _N_ #-}
elem :: Eq a => a -> [a] -> Bool
- {-# GHC_PRAGMA _A_ 3 _U_ 121 _N_ _S_ "LLS" _F_ _ALWAYS_ _/\_ u0 -> \ (u1 :: {{Eq u0}}) (u2 :: u0) (u3 :: [u0]) -> let {(u6 :: u0 -> u0 -> Bool) = case u1 of { _ALG_ _TUP_2 (u4 :: u0 -> u0 -> Bool) (u5 :: u0 -> u0 -> Bool) -> u4; _NO_DEFLT_ }} in let {(u8 :: u0 -> Bool) = \ (u7 :: u0) -> _APP_ u6 [ u2, u7 ]} in _APP_ _TYAPP_ _ORIG_ PreludeList any { u0 } [ u8, u3 ] _SPECIALISE_ [ Char ] 1 { _A_ 2 _U_ 21 _N_ _S_ "LS" _F_ _ALWAYS_ \ (u0 :: Char) (u1 :: [Char]) -> let {(u5 :: Char -> Bool) = \ (u2 :: Char) -> case u0 of { _ALG_ C# (u3 :: Char#) -> case u2 of { _ALG_ C# (u4 :: Char#) -> _#_ eqChar# [] [u3, u4]; _NO_DEFLT_ }; _NO_DEFLT_ }} in _APP_ _TYAPP_ _ORIG_ PreludeList any { Char } [ u5, u1 ] _N_ }, [ Int ] 1 { _A_ 2 _U_ 21 _N_ _S_ "LS" _F_ _ALWAYS_ \ (u0 :: Int) (u1 :: [Int]) -> let {(u5 :: Int -> Bool) = \ (u2 :: Int) -> case u0 of { _ALG_ I# (u3 :: Int#) -> case u2 of { _ALG_ I# (u4 :: Int#) -> _#_ eqInt# [] [u3, u4]; _NO_DEFLT_ }; _NO_DEFLT_ }} in _APP_ _TYAPP_ _ORIG_ PreludeList any { Int } [ u5, u1 ] _N_ }, [ [Char] ] 1 { _A_ 2 _U_ 21 _N_ _S_ "LS" _F_ _ALWAYS_ \ (u0 :: [Char]) (u1 :: [[Char]]) -> let {(u3 :: [Char] -> Bool) = \ (u2 :: [Char]) -> _APP_ _CONSTM_ Eq (==) ([Char]) [ u0, u2 ]} in _APP_ _TYAPP_ _ORIG_ PreludeList any { [Char] } [ u3, u1 ] _N_ } #-}
+ {-# GHC_PRAGMA _A_ 3 _U_ 121 _N_ _S_ "LLS" _F_ _ALWAYS_ _/\_ u0 -> \ (u1 :: {{Eq u0}}) (u2 :: u0) (u3 :: [u0]) -> let {(u6 :: u0 -> u0 -> Bool) = case u1 of { _ALG_ _TUP_2 (u4 :: u0 -> u0 -> Bool) (u5 :: u0 -> u0 -> Bool) -> u4; _NO_DEFLT_ }} in let {(u8 :: u0 -> Bool) = \ (u7 :: u0) -> _APP_ u6 [ u2, u7 ]} in _APP_ _TYAPP_ _ORIG_ PreludeList any { u0 } [ u8, u3 ] _SPECIALISE_ [ Char ] 1 { _A_ 2 _U_ 21 _N_ _S_ "LS" _F_ _ALWAYS_ \ (u0 :: Char) (u1 :: [Char]) -> let {(u5 :: Char -> Bool) = \ (u2 :: Char) -> case u0 of { _ALG_ C# (u3 :: Char#) -> case u2 of { _ALG_ C# (u4 :: Char#) -> _#_ eqChar# [] [u3, u4]; _NO_DEFLT_ }; _NO_DEFLT_ }} in _APP_ _TYAPP_ _ORIG_ PreludeList any { Char } [ u5, u1 ] _N_ }, [ Int ] 1 { _A_ 2 _U_ 21 _N_ _S_ "LS" _F_ _ALWAYS_ \ (u0 :: Int) (u1 :: [Int]) -> let {(u5 :: Int -> Bool) = \ (u2 :: Int) -> case u0 of { _ALG_ I# (u3 :: Int#) -> case u2 of { _ALG_ I# (u4 :: Int#) -> _#_ eqInt# [] [u3, u4]; _NO_DEFLT_ }; _NO_DEFLT_ }} in _APP_ _TYAPP_ _ORIG_ PreludeList any { Int } [ u5, u1 ] _N_ }, [ Integer ] 1 { _A_ 2 _U_ 21 _N_ _S_ "LS" _F_ _ALWAYS_ \ (u0 :: Integer) (u1 :: [Integer]) -> let {(ua :: Integer -> Bool) = \ (u2 :: Integer) -> case u0 of { _ALG_ J# (u3 :: Int#) (u4 :: Int#) (u5 :: ByteArray#) -> case u2 of { _ALG_ J# (u6 :: Int#) (u7 :: Int#) (u8 :: ByteArray#) -> case _#_ cmpInteger# [] [u3, u4, u5, u6, u7, u8] of { _PRIM_ 0# -> _!_ True [] []; (u9 :: Int#) -> _!_ False [] [] }; _NO_DEFLT_ }; _NO_DEFLT_ }} in _APP_ _TYAPP_ _ORIG_ PreludeList any { Integer } [ ua, u1 ] _N_ }, [ [Char] ] 1 { _A_ 2 _U_ 21 _N_ _S_ "LS" _F_ _ALWAYS_ \ (u0 :: [Char]) (u1 :: [[Char]]) -> let {(u3 :: [Char] -> Bool) = \ (u2 :: [Char]) -> _APP_ _CONSTM_ Eq (==) ([Char]) [ u0, u2 ]} in _APP_ _TYAPP_ _ORIG_ PreludeList any { [Char] } [ u3, u1 ] _N_ }, [ [Int] ] 1 { _A_ 2 _U_ 21 _N_ _S_ "LS" _F_ _ALWAYS_ \ (u0 :: [Int]) (u1 :: [[Int]]) -> let {(u3 :: [Int] -> Bool) = \ (u2 :: [Int]) -> _APP_ _CONSTM_ Eq (==) ([Int]) [ u0, u2 ]} in _APP_ _TYAPP_ _ORIG_ PreludeList any { [Int] } [ u3, u1 ] _N_ }, [ (Int, Int) ] 1 { _A_ 2 _U_ 21 _N_ _S_ "LS" _F_ _ALWAYS_ \ (u0 :: (Int, Int)) (u1 :: [(Int, Int)]) -> let {(ub :: (Int, Int) -> Bool) = \ (u2 :: (Int, Int)) -> case u0 of { _ALG_ _TUP_2 (u3 :: Int) (u4 :: Int) -> case u3 of { _ALG_ I# (u5 :: Int#) -> case u2 of { _ALG_ _TUP_2 (u6 :: Int) (u7 :: Int) -> case u6 of { _ALG_ I# (u8 :: Int#) -> case _#_ eqInt# [] [u5, u8] of { _ALG_ True -> case u4 of { _ALG_ I# (u9 :: Int#) -> case u7 of { _ALG_ I# (ua :: Int#) -> _#_ eqInt# [] [u9, ua]; _NO_DEFLT_ }; _NO_DEFLT_ }; False -> _!_ False [] []; _NO_DEFLT_ }; _NO_DEFLT_ }; _NO_DEFLT_ }; _NO_DEFLT_ }; _NO_DEFLT_ }} in _APP_ _TYAPP_ _ORIG_ PreludeList any { (Int, Int) } [ ub, u1 ] _N_ } #-}
filter :: (a -> Bool) -> [a] -> [a]
{-# GHC_PRAGMA _A_ 2 _U_ 21 _N_ _S_ "LS" _F_ _ALWAYS_ _/\_ u0 -> \ (u1 :: u0 -> Bool) (u2 :: [u0]) -> let {(u9 :: _forall_ a$z1 =>(u0 -> a$z1 -> a$z1) -> a$z1 -> a$z1) = _/\_ u3 -> \ (u4 :: u0 -> u3 -> u3) (u5 :: u3) -> let {(u8 :: u0 -> u3 -> u3) = \ (u6 :: u0) (u7 :: u3) -> case _APP_ u1 [ u6 ] of { _ALG_ True -> _APP_ u4 [ u6, u7 ]; False -> u7; _NO_DEFLT_ }} in _APP_ _TYAPP_ _TYAPP_ foldr { u0 } { u3 } [ u8, u5, u2 ]} in _APP_ _TYAPP_ _build { u0 } [ u9 ] _N_ #-}
foldl1 :: (a -> a -> a) -> [a] -> a
foldr1 :: (a -> a -> a) -> [a] -> a
{-# GHC_PRAGMA _A_ 2 _U_ 21 _N_ _S_ "LS" _N_ _N_ #-}
genericLength :: Num b => [a] -> b
- {-# GHC_PRAGMA _A_ 1 _U_ 21 _N_ _N_ _N_ _N_ #-}
+ {-# GHC_PRAGMA _A_ 1 _U_ 21 _N_ _N_ _N_ _SPECIALISE_ [ _N_, Int ] 1 { _A_ 1 _U_ 1 _N_ _S_ "S" _N_ _N_ }, [ _N_, Integer ] 1 { _A_ 1 _U_ 1 _N_ _S_ "S" _N_ _N_ } #-}
head :: [a] -> a
{-# GHC_PRAGMA _A_ 1 _U_ 1 _N_ _S_ "S" _F_ _ALWAYS_ _/\_ u0 -> \ (u1 :: [u0]) -> let {(u2 :: u0) = _APP_ _TYAPP_ error { u0 } [ _NOREP_S_ "head{PreludeList}: head []\n" ]} in let {(u5 :: u0 -> u0 -> u0) = \ (u3 :: u0) (u4 :: u0) -> u3} in _APP_ _TYAPP_ _TYAPP_ foldr { u0 } { u0 } [ u5, u2, u1 ] _N_ #-}
init :: [a] -> [a]
map :: (a -> b) -> [a] -> [b]
{-# GHC_PRAGMA _A_ 2 _U_ 21 _N_ _S_ "LS" _F_ _ALWAYS_ _/\_ u0 u1 -> \ (u2 :: u0 -> u1) (u3 :: [u0]) -> let {(ua :: _forall_ a$z1 =>(u1 -> a$z1 -> a$z1) -> a$z1 -> a$z1) = _/\_ u4 -> \ (u5 :: u1 -> u4 -> u4) (u6 :: u4) -> let {(u9 :: u0 -> u4 -> u4) = \ (u7 :: u0) -> let {(u8 :: u1) = _APP_ u2 [ u7 ]} in _APP_ u5 [ u8 ]} in _APP_ _TYAPP_ _TYAPP_ foldr { u0 } { u4 } [ u9, u6, u3 ]} in _APP_ _TYAPP_ _build { u1 } [ ua ] _N_ #-}
maximum :: Ord a => [a] -> a
- {-# GHC_PRAGMA _A_ 1 _U_ 11 _N_ _N_ _N_ _N_ #-}
+ {-# GHC_PRAGMA _A_ 1 _U_ 11 _N_ _N_ _N_ _SPECIALISE_ [ Double ] 1 { _A_ 1 _U_ 1 _N_ _S_ "S" _N_ _N_ }, [ Int ] 1 { _A_ 1 _U_ 1 _N_ _S_ "S" _N_ _N_ }, [ Integer ] 1 { _A_ 1 _U_ 1 _N_ _S_ "S" _N_ _N_ } #-}
minimum :: Ord a => [a] -> a
- {-# GHC_PRAGMA _A_ 1 _U_ 11 _N_ _N_ _N_ _N_ #-}
+ {-# GHC_PRAGMA _A_ 1 _U_ 11 _N_ _N_ _N_ _SPECIALISE_ [ Double ] 1 { _A_ 1 _U_ 1 _N_ _S_ "S" _N_ _N_ }, [ Int ] 1 { _A_ 1 _U_ 1 _N_ _S_ "S" _N_ _N_ }, [ Integer ] 1 { _A_ 1 _U_ 1 _N_ _S_ "S" _N_ _N_ } #-}
notElem :: Eq a => a -> [a] -> Bool
- {-# GHC_PRAGMA _A_ 3 _U_ 121 _N_ _S_ "LLS" _F_ _ALWAYS_ _/\_ u0 -> \ (u1 :: {{Eq u0}}) (u2 :: u0) (u3 :: [u0]) -> let {(u6 :: u0 -> u0 -> Bool) = case u1 of { _ALG_ _TUP_2 (u4 :: u0 -> u0 -> Bool) (u5 :: u0 -> u0 -> Bool) -> u5; _NO_DEFLT_ }} in let {(u8 :: u0 -> Bool) = \ (u7 :: u0) -> _APP_ u6 [ u2, u7 ]} in _APP_ _TYAPP_ _ORIG_ PreludeList all { u0 } [ u8, u3 ] _SPECIALISE_ [ Char ] 1 { _A_ 2 _U_ 21 _N_ _S_ "LS" _F_ _ALWAYS_ \ (u0 :: Char) (u1 :: [Char]) -> let {(u5 :: Char -> Bool) = \ (u2 :: Char) -> case u0 of { _ALG_ C# (u3 :: Char#) -> case u2 of { _ALG_ C# (u4 :: Char#) -> _#_ neChar# [] [u3, u4]; _NO_DEFLT_ }; _NO_DEFLT_ }} in _APP_ _TYAPP_ _ORIG_ PreludeList all { Char } [ u5, u1 ] _N_ }, [ Int ] 1 { _A_ 2 _U_ 21 _N_ _S_ "LS" _F_ _ALWAYS_ \ (u0 :: Int) (u1 :: [Int]) -> let {(u5 :: Int -> Bool) = \ (u2 :: Int) -> case u0 of { _ALG_ I# (u3 :: Int#) -> case u2 of { _ALG_ I# (u4 :: Int#) -> _#_ neInt# [] [u3, u4]; _NO_DEFLT_ }; _NO_DEFLT_ }} in _APP_ _TYAPP_ _ORIG_ PreludeList all { Int } [ u5, u1 ] _N_ }, [ [Char] ] 1 { _A_ 2 _U_ 21 _N_ _S_ "LS" _F_ _ALWAYS_ \ (u0 :: [Char]) (u1 :: [[Char]]) -> let {(u3 :: [Char] -> Bool) = \ (u2 :: [Char]) -> _APP_ _CONSTM_ Eq (/=) ([Char]) [ u0, u2 ]} in _APP_ _TYAPP_ _ORIG_ PreludeList all { [Char] } [ u3, u1 ] _N_ } #-}
+ {-# GHC_PRAGMA _A_ 3 _U_ 121 _N_ _S_ "LLS" _F_ _ALWAYS_ _/\_ u0 -> \ (u1 :: {{Eq u0}}) (u2 :: u0) (u3 :: [u0]) -> let {(u6 :: u0 -> u0 -> Bool) = case u1 of { _ALG_ _TUP_2 (u4 :: u0 -> u0 -> Bool) (u5 :: u0 -> u0 -> Bool) -> u5; _NO_DEFLT_ }} in let {(u8 :: u0 -> Bool) = \ (u7 :: u0) -> _APP_ u6 [ u2, u7 ]} in _APP_ _TYAPP_ _ORIG_ PreludeList all { u0 } [ u8, u3 ] _SPECIALISE_ [ Char ] 1 { _A_ 2 _U_ 21 _N_ _S_ "LS" _F_ _ALWAYS_ \ (u0 :: Char) (u1 :: [Char]) -> let {(u5 :: Char -> Bool) = \ (u2 :: Char) -> case u0 of { _ALG_ C# (u3 :: Char#) -> case u2 of { _ALG_ C# (u4 :: Char#) -> _#_ neChar# [] [u3, u4]; _NO_DEFLT_ }; _NO_DEFLT_ }} in _APP_ _TYAPP_ _ORIG_ PreludeList all { Char } [ u5, u1 ] _N_ }, [ Int ] 1 { _A_ 2 _U_ 21 _N_ _S_ "LS" _F_ _ALWAYS_ \ (u0 :: Int) (u1 :: [Int]) -> let {(u5 :: Int -> Bool) = \ (u2 :: Int) -> case u0 of { _ALG_ I# (u3 :: Int#) -> case u2 of { _ALG_ I# (u4 :: Int#) -> _#_ neInt# [] [u3, u4]; _NO_DEFLT_ }; _NO_DEFLT_ }} in _APP_ _TYAPP_ _ORIG_ PreludeList all { Int } [ u5, u1 ] _N_ }, [ Integer ] 1 { _A_ 2 _U_ 21 _N_ _S_ "LS" _F_ _ALWAYS_ \ (u0 :: Integer) (u1 :: [Integer]) -> let {(ua :: Integer -> Bool) = \ (u2 :: Integer) -> case u0 of { _ALG_ J# (u3 :: Int#) (u4 :: Int#) (u5 :: ByteArray#) -> case u2 of { _ALG_ J# (u6 :: Int#) (u7 :: Int#) (u8 :: ByteArray#) -> case _#_ cmpInteger# [] [u3, u4, u5, u6, u7, u8] of { _PRIM_ 0# -> _!_ False [] []; (u9 :: Int#) -> _!_ True [] [] }; _NO_DEFLT_ }; _NO_DEFLT_ }} in _APP_ _TYAPP_ _ORIG_ PreludeList all { Integer } [ ua, u1 ] _N_ }, [ [Char] ] 1 { _A_ 2 _U_ 21 _N_ _S_ "LS" _F_ _ALWAYS_ \ (u0 :: [Char]) (u1 :: [[Char]]) -> let {(u3 :: [Char] -> Bool) = \ (u2 :: [Char]) -> _APP_ _CONSTM_ Eq (/=) ([Char]) [ u0, u2 ]} in _APP_ _TYAPP_ _ORIG_ PreludeList all { [Char] } [ u3, u1 ] _N_ }, [ (Int, Int) ] 1 { _A_ 2 _U_ 21 _N_ _S_ "LS" _F_ _ALWAYS_ \ (u0 :: (Int, Int)) (u1 :: [(Int, Int)]) -> let {(ub :: (Int, Int) -> Bool) = \ (u2 :: (Int, Int)) -> case u0 of { _ALG_ _TUP_2 (u3 :: Int) (u4 :: Int) -> case u3 of { _ALG_ I# (u5 :: Int#) -> case u2 of { _ALG_ _TUP_2 (u6 :: Int) (u7 :: Int) -> case u6 of { _ALG_ I# (u8 :: Int#) -> case _#_ neInt# [] [u5, u8] of { _ALG_ True -> _!_ True [] []; False -> case u4 of { _ALG_ I# (u9 :: Int#) -> case u7 of { _ALG_ I# (ua :: Int#) -> _#_ neInt# [] [u9, ua]; _NO_DEFLT_ }; _NO_DEFLT_ }; _NO_DEFLT_ }; _NO_DEFLT_ }; _NO_DEFLT_ }; _NO_DEFLT_ }; _NO_DEFLT_ }} in _APP_ _TYAPP_ _ORIG_ PreludeList all { (Int, Int) } [ ub, u1 ] _N_ } #-}
nub :: Eq a => [a] -> [a]
- {-# GHC_PRAGMA _A_ 2 _U_ 11 _N_ _S_ "LS" _N_ _N_ #-}
+ {-# GHC_PRAGMA _A_ 2 _U_ 11 _N_ _S_ "LS" _N_ _SPECIALISE_ [ Int ] 1 { _A_ 1 _U_ 1 _N_ _S_ "S" _N_ _N_ }, [ [Char] ] 1 { _A_ 1 _U_ 1 _N_ _S_ "S" _N_ _N_ }, [ [Int] ] 1 { _A_ 1 _U_ 1 _N_ _S_ "S" _N_ _N_ } #-}
null :: [a] -> Bool
{-# GHC_PRAGMA _A_ 1 _U_ 1 _N_ _S_ "S" _F_ _ALWAYS_ _/\_ u0 -> \ (u1 :: [u0]) -> let {(u2 :: Bool) = _!_ True [] []} in let {(u5 :: u0 -> Bool -> Bool) = \ (u3 :: u0) (u4 :: Bool) -> _!_ False [] []} in _APP_ _TYAPP_ _TYAPP_ foldr { u0 } { Bool } [ u5, u2, u1 ] _N_ #-}
or :: [Bool] -> Bool
partition :: (a -> Bool) -> [a] -> ([a], [a])
{-# GHC_PRAGMA _A_ 2 _U_ 21 _N_ _S_ "LS" _F_ _ALWAYS_ _/\_ u0 -> \ (u1 :: u0 -> Bool) (u2 :: [u0]) -> let {(u9 :: u0 -> ([u0], [u0]) -> ([u0], [u0])) = \ (u3 :: u0) (u4 :: ([u0], [u0])) -> case u4 of { _ALG_ _TUP_2 (u5 :: [u0]) (u6 :: [u0]) -> case _APP_ u1 [ u3 ] of { _ALG_ True -> let {(u7 :: [u0]) = _!_ (:) [u0] [u3, u5]} in _!_ _TUP_2 [[u0], [u0]] [u7, u6]; False -> let {(u8 :: [u0]) = _!_ (:) [u0] [u3, u6]} in _!_ _TUP_2 [[u0], [u0]] [u5, u8]; _NO_DEFLT_ }; _NO_DEFLT_ }} in let {(ua :: [u0]) = _!_ _NIL_ [u0] []} in let {(ub :: ([u0], [u0])) = _!_ _TUP_2 [[u0], [u0]] [ua, ua]} in _APP_ _TYAPP_ _TYAPP_ foldr { u0 } { ([u0], [u0]) } [ u9, ub, u2 ] _N_ #-}
product :: Num a => [a] -> a
- {-# GHC_PRAGMA _A_ 1 _U_ 22 _N_ _N_ _F_ _ALWAYS_ _/\_ u0 -> \ (u1 :: {{Num u0}}) -> let {(uc :: u0 -> u0 -> u0) = case u1 of { _ALG_ _TUP_10 (u2 :: {{Eq u0}}) (u3 :: {{Text u0}}) (u4 :: u0 -> u0 -> u0) (u5 :: u0 -> u0 -> u0) (u6 :: u0 -> u0 -> u0) (u7 :: u0 -> u0) (u8 :: u0 -> u0) (u9 :: u0 -> u0) (ua :: Integer -> u0) (ub :: Int -> u0) -> u6; _NO_DEFLT_ }} in let {(uo :: u0) = let {(ud :: Int) = _!_ I# [] [1#]} in case u1 of { _ALG_ _TUP_10 (ue :: {{Eq u0}}) (uf :: {{Text u0}}) (ug :: u0 -> u0 -> u0) (uh :: u0 -> u0 -> u0) (ui :: u0 -> u0 -> u0) (uj :: u0 -> u0) (uk :: u0 -> u0) (ul :: u0 -> u0) (um :: Integer -> u0) (un :: Int -> u0) -> _APP_ un [ ud ]; _NO_DEFLT_ }} in \ (up :: [u0]) -> _APP_ _TYAPP_ _TYAPP_ foldl { u0 } { u0 } [ uc, uo, up ] _SPECIALISE_ [ Double ] 1 { _A_ 1 _U_ 1 _N_ _S_ "S" _F_ _ALWAYS_ \ (u0 :: [Double]) -> let {(u1 :: Double) = _!_ D# [] [1.0000000000000000##]} in _APP_ _TYAPP_ _TYAPP_ foldl { Double } { Double } [ _CONSTM_ Num (*) (Double), u1, u0 ] _N_ }, [ Int ] 1 { _A_ 1 _U_ 1 _N_ _S_ "S" _F_ _ALWAYS_ \ (u0 :: [Int]) -> let {(u1 :: Int) = _!_ I# [] [1#]} in _APP_ _TYAPP_ _TYAPP_ foldl { Int } { Int } [ _CONSTM_ Num (*) (Int), u1, u0 ] _N_ }, [ Integer ] 1 { _A_ 1 _U_ 1 _N_ _S_ "S" _F_ _ALWAYS_ \ (u0 :: [Integer]) -> let {(u1 :: Integer) = _#_ int2Integer# [] [1#]} in _APP_ _TYAPP_ _TYAPP_ foldl { Integer } { Integer } [ _CONSTM_ Num (*) (Integer), u1, u0 ] _N_ } #-}
+ {-# GHC_PRAGMA _A_ 1 _U_ 22 _N_ _N_ _F_ _ALWAYS_ _/\_ u0 -> \ (u1 :: {{Num u0}}) -> let {(uc :: u0 -> u0 -> u0) = case u1 of { _ALG_ _TUP_10 (u2 :: {{Eq u0}}) (u3 :: {{Text u0}}) (u4 :: u0 -> u0 -> u0) (u5 :: u0 -> u0 -> u0) (u6 :: u0 -> u0 -> u0) (u7 :: u0 -> u0) (u8 :: u0 -> u0) (u9 :: u0 -> u0) (ua :: Integer -> u0) (ub :: Int -> u0) -> u6; _NO_DEFLT_ }} in let {(uo :: u0) = let {(ud :: Int) = _!_ I# [] [1#]} in case u1 of { _ALG_ _TUP_10 (ue :: {{Eq u0}}) (uf :: {{Text u0}}) (ug :: u0 -> u0 -> u0) (uh :: u0 -> u0 -> u0) (ui :: u0 -> u0 -> u0) (uj :: u0 -> u0) (uk :: u0 -> u0) (ul :: u0 -> u0) (um :: Integer -> u0) (un :: Int -> u0) -> _APP_ un [ ud ]; _NO_DEFLT_ }} in \ (up :: [u0]) -> _APP_ _TYAPP_ _TYAPP_ foldl { u0 } { u0 } [ uc, uo, up ] _SPECIALISE_ [ Double ] 1 { _A_ 1 _U_ 1 _N_ _S_ "S" _F_ _ALWAYS_ \ (u0 :: [Double]) -> let {(u1 :: Double) = _!_ D# [] [1.0000000000000000##]} in _APP_ _TYAPP_ _TYAPP_ foldl { Double } { Double } [ _CONSTM_ Num (*) (Double), u1, u0 ] _N_ }, [ Int ] 1 { _A_ 1 _U_ 1 _N_ _S_ "S" _F_ _ALWAYS_ \ (u0 :: [Int]) -> let {(u1 :: Int) = _!_ I# [] [1#]} in _APP_ _TYAPP_ _TYAPP_ foldl { Int } { Int } [ _CONSTM_ Num (*) (Int), u1, u0 ] _N_ }, [ Integer ] 1 { _A_ 1 _U_ 1 _N_ _S_ "S" _F_ _ALWAYS_ \ (u0 :: [Integer]) -> let {(u1 :: Integer) = _#_ int2Integer# [] [1#]} in _APP_ _TYAPP_ _TYAPP_ foldl { Integer } { Integer } [ _CONSTM_ Num (*) (Integer), u1, u0 ] _N_ }, [ (Complex Double) ] 1 { _A_ 1 _U_ 1 _N_ _S_ "S" _F_ _ALWAYS_ let {(u6 :: Complex Double -> Complex Double -> Complex Double) = \ (u0 :: Complex Double) (u1 :: Complex Double) -> case u0 of { _ALG_ (:+) (u2 :: Double) (u3 :: Double) -> case u1 of { _ALG_ (:+) (u4 :: Double) (u5 :: Double) -> _APP_ _WRKR_ _CONSTM_ Num (*) (Complex Double) [ u2, u3, u4, u5 ]; _NO_DEFLT_ }; _NO_DEFLT_ }} in let {(u8 :: Complex Double) = let {(u7 :: Int) = _!_ I# [] [1#]} in _APP_ _CONSTM_ Num fromInt (Complex Double) [ u7 ]} in \ (u9 :: [Complex Double]) -> _APP_ _TYAPP_ _TYAPP_ foldl { (Complex Double) } { (Complex Double) } [ u6, u8, u9 ] _N_ } #-}
products :: Num a => [a] -> [a]
- {-# GHC_PRAGMA _A_ 1 _U_ 21 _N_ _N_ _N_ _N_ #-}
+ {-# GHC_PRAGMA _A_ 1 _U_ 21 _N_ _N_ _N_ _SPECIALISE_ [ Double ] 1 { _A_ 1 _U_ 1 _N_ _N_ _N_ _N_ }, [ Int ] 1 { _A_ 1 _U_ 1 _N_ _N_ _N_ _N_ }, [ Integer ] 1 { _A_ 1 _U_ 1 _N_ _N_ _F_ _IF_ARGS_ 0 1 X 4 \ (u0 :: [Integer]) -> _APP_ _TYAPP_ _TYAPP_ _ORIG_ PreludeList scanl { Integer } { Integer } [ _CONSTM_ Num (*) (Integer), _SPEC_ _ORIG_ PreludeCore __i1 [ (Integer) ], u0 ] _N_ }, [ (Complex Double) ] 1 { _A_ 1 _U_ 1 _N_ _N_ _N_ _N_ } #-}
repeat :: a -> [a]
{-# GHC_PRAGMA _A_ 1 _U_ 2 _N_ _N_ _F_ _ALWAYS_ _/\_ u0 -> \ (u1 :: u0) -> let {(u6 :: _forall_ a$z1 =>(u0 -> a$z1 -> a$z1) -> a$z1 -> a$z1) = _/\_ u2 -> \ (u3 :: u0 -> u2 -> u2) (u4 :: u2) -> _LETREC_ {(u5 :: u2) = _APP_ u3 [ u1, u5 ]} in u5} in _APP_ _TYAPP_ _build { u0 } [ u6 ] _N_ #-}
reverse :: [a] -> [a]
sum :: Num a => [a] -> a
{-# GHC_PRAGMA _A_ 1 _U_ 22 _N_ _N_ _F_ _ALWAYS_ _/\_ u0 -> \ (u1 :: {{Num u0}}) -> let {(uc :: u0 -> u0 -> u0) = case u1 of { _ALG_ _TUP_10 (u2 :: {{Eq u0}}) (u3 :: {{Text u0}}) (u4 :: u0 -> u0 -> u0) (u5 :: u0 -> u0 -> u0) (u6 :: u0 -> u0 -> u0) (u7 :: u0 -> u0) (u8 :: u0 -> u0) (u9 :: u0 -> u0) (ua :: Integer -> u0) (ub :: Int -> u0) -> u4; _NO_DEFLT_ }} in let {(uo :: u0) = let {(ud :: Int) = _!_ I# [] [0#]} in case u1 of { _ALG_ _TUP_10 (ue :: {{Eq u0}}) (uf :: {{Text u0}}) (ug :: u0 -> u0 -> u0) (uh :: u0 -> u0 -> u0) (ui :: u0 -> u0 -> u0) (uj :: u0 -> u0) (uk :: u0 -> u0) (ul :: u0 -> u0) (um :: Integer -> u0) (un :: Int -> u0) -> _APP_ un [ ud ]; _NO_DEFLT_ }} in \ (up :: [u0]) -> _APP_ _TYAPP_ _TYAPP_ foldl { u0 } { u0 } [ uc, uo, up ] _SPECIALISE_ [ Double ] 1 { _A_ 1 _U_ 1 _N_ _S_ "S" _F_ _ALWAYS_ \ (u0 :: [Double]) -> let {(u1 :: Double) = _!_ D# [] [0.0000000000000000##]} in _APP_ _TYAPP_ _TYAPP_ foldl { Double } { Double } [ _CONSTM_ Num (+) (Double), u1, u0 ] _N_ }, [ Int ] 1 { _A_ 1 _U_ 1 _N_ _S_ "S" _F_ _ALWAYS_ \ (u0 :: [Int]) -> let {(u1 :: Int) = _!_ I# [] [0#]} in _APP_ _TYAPP_ _TYAPP_ foldl { Int } { Int } [ _CONSTM_ Num (+) (Int), u1, u0 ] _N_ }, [ Integer ] 1 { _A_ 1 _U_ 1 _N_ _S_ "S" _F_ _ALWAYS_ \ (u0 :: [Integer]) -> let {(u1 :: Integer) = _#_ int2Integer# [] [0#]} in _APP_ _TYAPP_ _TYAPP_ foldl { Integer } { Integer } [ _CONSTM_ Num (+) (Integer), u1, u0 ] _N_ }, [ (Complex Double) ] 1 { _A_ 1 _U_ 1 _N_ _S_ "S" _F_ _ALWAYS_ let {(u6 :: Complex Double -> Complex Double -> Complex Double) = \ (u0 :: Complex Double) (u1 :: Complex Double) -> case u0 of { _ALG_ (:+) (u2 :: Double) (u3 :: Double) -> case u1 of { _ALG_ (:+) (u4 :: Double) (u5 :: Double) -> _APP_ _WRKR_ _CONSTM_ Num (+) (Complex Double) [ u2, u3, u4, u5 ]; _NO_DEFLT_ }; _NO_DEFLT_ }} in let {(u8 :: Complex Double) = let {(u7 :: Int) = _!_ I# [] [0#]} in _APP_ _CONSTM_ Num fromInt (Complex Double) [ u7 ]} in \ (u9 :: [Complex Double]) -> _APP_ _TYAPP_ _TYAPP_ foldl { (Complex Double) } { (Complex Double) } [ u6, u8, u9 ] _N_ } #-}
sums :: Num a => [a] -> [a]
- {-# GHC_PRAGMA _A_ 1 _U_ 21 _N_ _N_ _N_ _N_ #-}
+ {-# GHC_PRAGMA _A_ 1 _U_ 21 _N_ _N_ _N_ _SPECIALISE_ [ Double ] 1 { _A_ 1 _U_ 1 _N_ _N_ _N_ _N_ }, [ Int ] 1 { _A_ 1 _U_ 1 _N_ _N_ _N_ _N_ }, [ Integer ] 1 { _A_ 1 _U_ 1 _N_ _N_ _F_ _IF_ARGS_ 0 1 X 4 \ (u0 :: [Integer]) -> _APP_ _TYAPP_ _TYAPP_ _ORIG_ PreludeList scanl { Integer } { Integer } [ _CONSTM_ Num (+) (Integer), _SPEC_ _ORIG_ PreludeCore __i0 [ (Integer) ], u0 ] _N_ }, [ (Complex Double) ] 1 { _A_ 1 _U_ 1 _N_ _N_ _N_ _N_ } #-}
tail :: [a] -> [a]
{-# GHC_PRAGMA _A_ 1 _U_ 1 _N_ _S_ "S" _F_ _IF_ARGS_ 1 1 C 5 _/\_ u0 -> \ (u1 :: [u0]) -> case u1 of { _ALG_ (:) (u2 :: u0) (u3 :: [u0]) -> u3; _NIL_ -> _APP_ _TYAPP_ error { [u0] } [ _NOREP_S_ "tail{PreludeList}: tail []\n" ]; _NO_DEFLT_ } _N_ #-}
take :: Integral a => a -> [b] -> [b]
- {-# GHC_PRAGMA _A_ 3 _U_ 121 _N_ _S_ "U(AAAAAAAAAAAS)LL" {_A_ 3 _U_ 121 _N_ _N_ _N_ _N_} _F_ _IF_ARGS_ 2 3 CXX 7 _/\_ u0 u1 -> \ (u2 :: {{Integral u0}}) (u3 :: u0) (u4 :: [u1]) -> let {(uh :: Int) = case u2 of { _ALG_ _TUP_12 (u5 :: {{Real u0}}) (u6 :: {{Ix u0}}) (u7 :: u0 -> u0 -> u0) (u8 :: u0 -> u0 -> u0) (u9 :: u0 -> u0 -> u0) (ua :: u0 -> u0 -> u0) (ub :: u0 -> u0 -> (u0, u0)) (uc :: u0 -> u0 -> (u0, u0)) (ud :: u0 -> Bool) (ue :: u0 -> Bool) (uf :: u0 -> Integer) (ug :: u0 -> Int) -> _APP_ ug [ u3 ]; _NO_DEFLT_ }} in _APP_ _TYAPP_ _SPEC_ _ORIG_ PreludeList take [ (Int), _N_ ] { u1 } [ uh, u4 ] _SPECIALISE_ [ Int, _N_ ] 1 { _A_ 2 _U_ 11 _N_ _S_ "U(P)L" {_A_ 2 _U_ 21 _N_ _N_ _N_ _N_} _N_ _N_ }, [ Integer, _N_ ] 1 { _A_ 2 _U_ 11 _N_ _S_ "U(PPP)L" {_A_ 4 _U_ 2221 _N_ _N_ _F_ _IF_ARGS_ 1 4 XXXX 4 _/\_ u0 -> \ (u1 :: Int#) (u2 :: Int#) (u3 :: ByteArray#) (u4 :: [u0]) -> case _#_ integer2Int# [] [u1, u2, u3] of { _PRIM_ (u5 :: Int#) -> _APP_ _TYAPP_ _WRKR_ _SPEC_ _ORIG_ PreludeList take [ (Int), _N_ ] { u0 } [ u5, u4 ] } _N_} _F_ _ALWAYS_ _/\_ u0 -> \ (u1 :: Integer) (u2 :: [u0]) -> case u1 of { _ALG_ J# (u3 :: Int#) (u4 :: Int#) (u5 :: ByteArray#) -> case _#_ integer2Int# [] [u3, u4, u5] of { _PRIM_ (u6 :: Int#) -> _APP_ _TYAPP_ _WRKR_ _SPEC_ _ORIG_ PreludeList take [ (Int), _N_ ] { u0 } [ u6, u2 ] }; _NO_DEFLT_ } _N_ } #-}
+ {-# GHC_PRAGMA _A_ 1 _U_ 122 _N_ _S_ "U(LU(U(ASSAAAAA)AAA)AAAALAAAAL)" {_A_ 5 _U_ 2121222 _N_ _N_ _N_ _N_} _N_ _SPECIALISE_ [ Int, _N_ ] 1 { _A_ 2 _U_ 11 _N_ _S_ "U(P)L" {_A_ 2 _U_ 21 _N_ _N_ _N_ _N_} _N_ _N_ }, [ Integer, _N_ ] 1 { _A_ 1 _U_ 12 _N_ _S_ "U(PPP)" {_A_ 3 _U_ 2222 _N_ _N_ _N_ _N_} _N_ _N_ } #-}
takeWhile :: (a -> Bool) -> [a] -> [a]
{-# GHC_PRAGMA _A_ 2 _U_ 21 _N_ _S_ "LS" _F_ _ALWAYS_ _/\_ u0 -> \ (u1 :: u0 -> Bool) (u2 :: [u0]) -> let {(u9 :: _forall_ a$z1 =>(u0 -> a$z1 -> a$z1) -> a$z1 -> a$z1) = _/\_ u3 -> \ (u4 :: u0 -> u3 -> u3) (u5 :: u3) -> let {(u8 :: u0 -> u3 -> u3) = \ (u6 :: u0) (u7 :: u3) -> case _APP_ u1 [ u6 ] of { _ALG_ True -> _APP_ u4 [ u6, u7 ]; False -> u5; _NO_DEFLT_ }} in _APP_ _TYAPP_ _TYAPP_ foldr { u0 } { u3 } [ u8, u5, u2 ]} in _APP_ _TYAPP_ _build { u0 } [ u9 ] _N_ #-}
transpose :: [[a]] -> [[a]]
-{-# GHC_PRAGMA INTERFACE VERSION 5 #-}
+{-# GHC_PRAGMA INTERFACE VERSION 6 #-}
interface PreludeList where
import PreludeBuiltin(Char(..), Int(..), List(..), Tuple2, Tuple3, Tuple4, Tuple5, Tuple6, Tuple7)
import PreludeCore(Bool(..), Eq(..), Integral(..), Num(..), Ord(..))
(++) :: [a] -> [a] -> [a]
{-# GHC_PRAGMA _A_ 2 _U_ 12 _N_ _S_ "SL" _N_ _N_ #-}
(\\) :: Eq a => [a] -> [a] -> [a]
- {-# GHC_PRAGMA _A_ 3 _U_ 122 _N_ _S_ "LLS" _N_ _N_ #-}
+ {-# GHC_PRAGMA _A_ 3 _U_ 122 _N_ _S_ "LLS" _N_ _SPECIALISE_ [ Int ] 1 { _A_ 2 _U_ 22 _N_ _S_ "LS" _N_ _N_ }, [ [Char] ] 1 { _A_ 2 _U_ 22 _N_ _S_ "LS" _N_ _N_ } #-}
all :: (a -> Bool) -> [a] -> Bool
{-# GHC_PRAGMA _A_ 2 _U_ 21 _N_ _S_ "LS" _F_ _ALWAYS_ _/\_ u0 -> \ (u1 :: u0 -> Bool) (u2 :: [u0]) -> let {(u3 :: Bool) = _!_ True [] []} in let {(u6 :: u0 -> Bool -> Bool) = \ (u4 :: u0) (u5 :: Bool) -> case _APP_ u1 [ u4 ] of { _ALG_ True -> u5; False -> _!_ False [] []; _NO_DEFLT_ }} in _APP_ _TYAPP_ _TYAPP_ foldr { u0 } { Bool } [ u6, u3, u2 ] _N_ #-}
and :: [Bool] -> Bool
dropWhile :: (a -> Bool) -> [a] -> [a]
{-# GHC_PRAGMA _A_ 2 _U_ 21 _N_ _S_ "LS" _N_ _N_ #-}
elem :: Eq a => a -> [a] -> Bool
- {-# GHC_PRAGMA _A_ 3 _U_ 121 _N_ _S_ "LLS" _F_ _ALWAYS_ _/\_ u0 -> \ (u1 :: {{Eq u0}}) (u2 :: u0) (u3 :: [u0]) -> let {(u6 :: u0 -> u0 -> Bool) = case u1 of { _ALG_ _TUP_2 (u4 :: u0 -> u0 -> Bool) (u5 :: u0 -> u0 -> Bool) -> u4; _NO_DEFLT_ }} in let {(u8 :: u0 -> Bool) = \ (u7 :: u0) -> _APP_ u6 [ u2, u7 ]} in _APP_ _TYAPP_ _ORIG_ PreludeList any { u0 } [ u8, u3 ] _SPECIALISE_ [ Char ] 1 { _A_ 2 _U_ 21 _N_ _S_ "LS" _F_ _ALWAYS_ \ (u0 :: Char) (u1 :: [Char]) -> let {(u5 :: Char -> Bool) = \ (u2 :: Char) -> case u0 of { _ALG_ C# (u3 :: Char#) -> case u2 of { _ALG_ C# (u4 :: Char#) -> _#_ eqChar# [] [u3, u4]; _NO_DEFLT_ }; _NO_DEFLT_ }} in _APP_ _TYAPP_ _ORIG_ PreludeList any { Char } [ u5, u1 ] _N_ }, [ Int ] 1 { _A_ 2 _U_ 21 _N_ _S_ "LS" _F_ _ALWAYS_ \ (u0 :: Int) (u1 :: [Int]) -> let {(u5 :: Int -> Bool) = \ (u2 :: Int) -> case u0 of { _ALG_ I# (u3 :: Int#) -> case u2 of { _ALG_ I# (u4 :: Int#) -> _#_ eqInt# [] [u3, u4]; _NO_DEFLT_ }; _NO_DEFLT_ }} in _APP_ _TYAPP_ _ORIG_ PreludeList any { Int } [ u5, u1 ] _N_ }, [ [Char] ] 1 { _A_ 2 _U_ 21 _N_ _S_ "LS" _F_ _ALWAYS_ \ (u0 :: [Char]) (u1 :: [[Char]]) -> let {(u3 :: [Char] -> Bool) = \ (u2 :: [Char]) -> _APP_ _CONSTM_ Eq (==) ([Char]) [ u0, u2 ]} in _APP_ _TYAPP_ _ORIG_ PreludeList any { [Char] } [ u3, u1 ] _N_ } #-}
+ {-# GHC_PRAGMA _A_ 3 _U_ 121 _N_ _S_ "LLS" _F_ _ALWAYS_ _/\_ u0 -> \ (u1 :: {{Eq u0}}) (u2 :: u0) (u3 :: [u0]) -> let {(u6 :: u0 -> u0 -> Bool) = case u1 of { _ALG_ _TUP_2 (u4 :: u0 -> u0 -> Bool) (u5 :: u0 -> u0 -> Bool) -> u4; _NO_DEFLT_ }} in let {(u8 :: u0 -> Bool) = \ (u7 :: u0) -> _APP_ u6 [ u2, u7 ]} in _APP_ _TYAPP_ _ORIG_ PreludeList any { u0 } [ u8, u3 ] _SPECIALISE_ [ Char ] 1 { _A_ 2 _U_ 21 _N_ _S_ "LS" _F_ _ALWAYS_ \ (u0 :: Char) (u1 :: [Char]) -> let {(u5 :: Char -> Bool) = \ (u2 :: Char) -> case u0 of { _ALG_ C# (u3 :: Char#) -> case u2 of { _ALG_ C# (u4 :: Char#) -> _#_ eqChar# [] [u3, u4]; _NO_DEFLT_ }; _NO_DEFLT_ }} in _APP_ _TYAPP_ _ORIG_ PreludeList any { Char } [ u5, u1 ] _N_ }, [ Int ] 1 { _A_ 2 _U_ 21 _N_ _S_ "LS" _F_ _ALWAYS_ \ (u0 :: Int) (u1 :: [Int]) -> let {(u5 :: Int -> Bool) = \ (u2 :: Int) -> case u0 of { _ALG_ I# (u3 :: Int#) -> case u2 of { _ALG_ I# (u4 :: Int#) -> _#_ eqInt# [] [u3, u4]; _NO_DEFLT_ }; _NO_DEFLT_ }} in _APP_ _TYAPP_ _ORIG_ PreludeList any { Int } [ u5, u1 ] _N_ }, [ Integer ] 1 { _A_ 2 _U_ 21 _N_ _S_ "LS" _F_ _ALWAYS_ \ (u0 :: Integer) (u1 :: [Integer]) -> let {(ua :: Integer -> Bool) = \ (u2 :: Integer) -> case u0 of { _ALG_ J# (u3 :: Int#) (u4 :: Int#) (u5 :: ByteArray#) -> case u2 of { _ALG_ J# (u6 :: Int#) (u7 :: Int#) (u8 :: ByteArray#) -> case _#_ cmpInteger# [] [u3, u4, u5, u6, u7, u8] of { _PRIM_ 0# -> _!_ True [] []; (u9 :: Int#) -> _!_ False [] [] }; _NO_DEFLT_ }; _NO_DEFLT_ }} in _APP_ _TYAPP_ _ORIG_ PreludeList any { Integer } [ ua, u1 ] _N_ }, [ [Char] ] 1 { _A_ 2 _U_ 21 _N_ _S_ "LS" _F_ _ALWAYS_ \ (u0 :: [Char]) (u1 :: [[Char]]) -> let {(u3 :: [Char] -> Bool) = \ (u2 :: [Char]) -> _APP_ _CONSTM_ Eq (==) ([Char]) [ u0, u2 ]} in _APP_ _TYAPP_ _ORIG_ PreludeList any { [Char] } [ u3, u1 ] _N_ }, [ [Int] ] 1 { _A_ 2 _U_ 21 _N_ _S_ "LS" _F_ _ALWAYS_ \ (u0 :: [Int]) (u1 :: [[Int]]) -> let {(u3 :: [Int] -> Bool) = \ (u2 :: [Int]) -> _APP_ _CONSTM_ Eq (==) ([Int]) [ u0, u2 ]} in _APP_ _TYAPP_ _ORIG_ PreludeList any { [Int] } [ u3, u1 ] _N_ }, [ (Int, Int) ] 1 { _A_ 2 _U_ 21 _N_ _S_ "LS" _F_ _ALWAYS_ \ (u0 :: (Int, Int)) (u1 :: [(Int, Int)]) -> let {(ub :: (Int, Int) -> Bool) = \ (u2 :: (Int, Int)) -> case u0 of { _ALG_ _TUP_2 (u3 :: Int) (u4 :: Int) -> case u3 of { _ALG_ I# (u5 :: Int#) -> case u2 of { _ALG_ _TUP_2 (u6 :: Int) (u7 :: Int) -> case u6 of { _ALG_ I# (u8 :: Int#) -> case _#_ eqInt# [] [u5, u8] of { _ALG_ True -> case u4 of { _ALG_ I# (u9 :: Int#) -> case u7 of { _ALG_ I# (ua :: Int#) -> _#_ eqInt# [] [u9, ua]; _NO_DEFLT_ }; _NO_DEFLT_ }; False -> _!_ False [] []; _NO_DEFLT_ }; _NO_DEFLT_ }; _NO_DEFLT_ }; _NO_DEFLT_ }; _NO_DEFLT_ }} in _APP_ _TYAPP_ _ORIG_ PreludeList any { (Int, Int) } [ ub, u1 ] _N_ } #-}
filter :: (a -> Bool) -> [a] -> [a]
{-# GHC_PRAGMA _A_ 2 _U_ 21 _N_ _S_ "LS" _F_ _ALWAYS_ _/\_ u0 -> \ (u1 :: u0 -> Bool) (u2 :: [u0]) -> let {(u9 :: _forall_ a$z1 =>(u0 -> a$z1 -> a$z1) -> a$z1 -> a$z1) = _/\_ u3 -> \ (u4 :: u0 -> u3 -> u3) (u5 :: u3) -> let {(u8 :: u0 -> u3 -> u3) = \ (u6 :: u0) (u7 :: u3) -> case _APP_ u1 [ u6 ] of { _ALG_ True -> _APP_ u4 [ u6, u7 ]; False -> u7; _NO_DEFLT_ }} in _APP_ _TYAPP_ _TYAPP_ foldr { u0 } { u3 } [ u8, u5, u2 ]} in _APP_ _TYAPP_ _build { u0 } [ u9 ] _N_ #-}
foldl1 :: (a -> a -> a) -> [a] -> a
foldr1 :: (a -> a -> a) -> [a] -> a
{-# GHC_PRAGMA _A_ 2 _U_ 21 _N_ _S_ "LS" _N_ _N_ #-}
genericLength :: Num b => [a] -> b
- {-# GHC_PRAGMA _A_ 1 _U_ 21 _N_ _N_ _N_ _N_ #-}
+ {-# GHC_PRAGMA _A_ 1 _U_ 21 _N_ _N_ _N_ _SPECIALISE_ [ _N_, Int ] 1 { _A_ 1 _U_ 1 _N_ _S_ "S" _N_ _N_ }, [ _N_, Integer ] 1 { _A_ 1 _U_ 1 _N_ _S_ "S" _N_ _N_ } #-}
head :: [a] -> a
{-# GHC_PRAGMA _A_ 1 _U_ 1 _N_ _S_ "S" _F_ _ALWAYS_ _/\_ u0 -> \ (u1 :: [u0]) -> let {(u2 :: u0) = _APP_ _TYAPP_ error { u0 } [ _NOREP_S_ "head{PreludeList}: head []\n" ]} in let {(u5 :: u0 -> u0 -> u0) = \ (u3 :: u0) (u4 :: u0) -> u3} in _APP_ _TYAPP_ _TYAPP_ foldr { u0 } { u0 } [ u5, u2, u1 ] _N_ #-}
init :: [a] -> [a]
map :: (a -> b) -> [a] -> [b]
{-# GHC_PRAGMA _A_ 2 _U_ 21 _N_ _S_ "LS" _F_ _ALWAYS_ _/\_ u0 u1 -> \ (u2 :: u0 -> u1) (u3 :: [u0]) -> let {(ua :: _forall_ a$z1 =>(u1 -> a$z1 -> a$z1) -> a$z1 -> a$z1) = _/\_ u4 -> \ (u5 :: u1 -> u4 -> u4) (u6 :: u4) -> let {(u9 :: u0 -> u4 -> u4) = \ (u7 :: u0) -> let {(u8 :: u1) = _APP_ u2 [ u7 ]} in _APP_ u5 [ u8 ]} in _APP_ _TYAPP_ _TYAPP_ foldr { u0 } { u4 } [ u9, u6, u3 ]} in _APP_ _TYAPP_ _build { u1 } [ ua ] _N_ #-}
maximum :: Ord a => [a] -> a
- {-# GHC_PRAGMA _A_ 1 _U_ 11 _N_ _N_ _N_ _N_ #-}
+ {-# GHC_PRAGMA _A_ 1 _U_ 11 _N_ _N_ _N_ _SPECIALISE_ [ Double ] 1 { _A_ 1 _U_ 1 _N_ _S_ "S" _N_ _N_ }, [ Int ] 1 { _A_ 1 _U_ 1 _N_ _S_ "S" _N_ _N_ }, [ Integer ] 1 { _A_ 1 _U_ 1 _N_ _S_ "S" _N_ _N_ } #-}
minimum :: Ord a => [a] -> a
- {-# GHC_PRAGMA _A_ 1 _U_ 11 _N_ _N_ _N_ _N_ #-}
+ {-# GHC_PRAGMA _A_ 1 _U_ 11 _N_ _N_ _N_ _SPECIALISE_ [ Double ] 1 { _A_ 1 _U_ 1 _N_ _S_ "S" _N_ _N_ }, [ Int ] 1 { _A_ 1 _U_ 1 _N_ _S_ "S" _N_ _N_ }, [ Integer ] 1 { _A_ 1 _U_ 1 _N_ _S_ "S" _N_ _N_ } #-}
notElem :: Eq a => a -> [a] -> Bool
- {-# GHC_PRAGMA _A_ 3 _U_ 121 _N_ _S_ "LLS" _F_ _ALWAYS_ _/\_ u0 -> \ (u1 :: {{Eq u0}}) (u2 :: u0) (u3 :: [u0]) -> let {(u6 :: u0 -> u0 -> Bool) = case u1 of { _ALG_ _TUP_2 (u4 :: u0 -> u0 -> Bool) (u5 :: u0 -> u0 -> Bool) -> u5; _NO_DEFLT_ }} in let {(u8 :: u0 -> Bool) = \ (u7 :: u0) -> _APP_ u6 [ u2, u7 ]} in _APP_ _TYAPP_ _ORIG_ PreludeList all { u0 } [ u8, u3 ] _SPECIALISE_ [ Char ] 1 { _A_ 2 _U_ 21 _N_ _S_ "LS" _F_ _ALWAYS_ \ (u0 :: Char) (u1 :: [Char]) -> let {(u5 :: Char -> Bool) = \ (u2 :: Char) -> case u0 of { _ALG_ C# (u3 :: Char#) -> case u2 of { _ALG_ C# (u4 :: Char#) -> _#_ neChar# [] [u3, u4]; _NO_DEFLT_ }; _NO_DEFLT_ }} in _APP_ _TYAPP_ _ORIG_ PreludeList all { Char } [ u5, u1 ] _N_ }, [ Int ] 1 { _A_ 2 _U_ 21 _N_ _S_ "LS" _F_ _ALWAYS_ \ (u0 :: Int) (u1 :: [Int]) -> let {(u5 :: Int -> Bool) = \ (u2 :: Int) -> case u0 of { _ALG_ I# (u3 :: Int#) -> case u2 of { _ALG_ I# (u4 :: Int#) -> _#_ neInt# [] [u3, u4]; _NO_DEFLT_ }; _NO_DEFLT_ }} in _APP_ _TYAPP_ _ORIG_ PreludeList all { Int } [ u5, u1 ] _N_ }, [ [Char] ] 1 { _A_ 2 _U_ 21 _N_ _S_ "LS" _F_ _ALWAYS_ \ (u0 :: [Char]) (u1 :: [[Char]]) -> let {(u3 :: [Char] -> Bool) = \ (u2 :: [Char]) -> _APP_ _CONSTM_ Eq (/=) ([Char]) [ u0, u2 ]} in _APP_ _TYAPP_ _ORIG_ PreludeList all { [Char] } [ u3, u1 ] _N_ } #-}
+ {-# GHC_PRAGMA _A_ 3 _U_ 121 _N_ _S_ "LLS" _F_ _ALWAYS_ _/\_ u0 -> \ (u1 :: {{Eq u0}}) (u2 :: u0) (u3 :: [u0]) -> let {(u6 :: u0 -> u0 -> Bool) = case u1 of { _ALG_ _TUP_2 (u4 :: u0 -> u0 -> Bool) (u5 :: u0 -> u0 -> Bool) -> u5; _NO_DEFLT_ }} in let {(u8 :: u0 -> Bool) = \ (u7 :: u0) -> _APP_ u6 [ u2, u7 ]} in _APP_ _TYAPP_ _ORIG_ PreludeList all { u0 } [ u8, u3 ] _SPECIALISE_ [ Char ] 1 { _A_ 2 _U_ 21 _N_ _S_ "LS" _F_ _ALWAYS_ \ (u0 :: Char) (u1 :: [Char]) -> let {(u5 :: Char -> Bool) = \ (u2 :: Char) -> case u0 of { _ALG_ C# (u3 :: Char#) -> case u2 of { _ALG_ C# (u4 :: Char#) -> _#_ neChar# [] [u3, u4]; _NO_DEFLT_ }; _NO_DEFLT_ }} in _APP_ _TYAPP_ _ORIG_ PreludeList all { Char } [ u5, u1 ] _N_ }, [ Int ] 1 { _A_ 2 _U_ 21 _N_ _S_ "LS" _F_ _ALWAYS_ \ (u0 :: Int) (u1 :: [Int]) -> let {(u5 :: Int -> Bool) = \ (u2 :: Int) -> case u0 of { _ALG_ I# (u3 :: Int#) -> case u2 of { _ALG_ I# (u4 :: Int#) -> _#_ neInt# [] [u3, u4]; _NO_DEFLT_ }; _NO_DEFLT_ }} in _APP_ _TYAPP_ _ORIG_ PreludeList all { Int } [ u5, u1 ] _N_ }, [ Integer ] 1 { _A_ 2 _U_ 21 _N_ _S_ "LS" _F_ _ALWAYS_ \ (u0 :: Integer) (u1 :: [Integer]) -> let {(ua :: Integer -> Bool) = \ (u2 :: Integer) -> case u0 of { _ALG_ J# (u3 :: Int#) (u4 :: Int#) (u5 :: ByteArray#) -> case u2 of { _ALG_ J# (u6 :: Int#) (u7 :: Int#) (u8 :: ByteArray#) -> case _#_ cmpInteger# [] [u3, u4, u5, u6, u7, u8] of { _PRIM_ 0# -> _!_ False [] []; (u9 :: Int#) -> _!_ True [] [] }; _NO_DEFLT_ }; _NO_DEFLT_ }} in _APP_ _TYAPP_ _ORIG_ PreludeList all { Integer } [ ua, u1 ] _N_ }, [ [Char] ] 1 { _A_ 2 _U_ 21 _N_ _S_ "LS" _F_ _ALWAYS_ \ (u0 :: [Char]) (u1 :: [[Char]]) -> let {(u3 :: [Char] -> Bool) = \ (u2 :: [Char]) -> _APP_ _CONSTM_ Eq (/=) ([Char]) [ u0, u2 ]} in _APP_ _TYAPP_ _ORIG_ PreludeList all { [Char] } [ u3, u1 ] _N_ }, [ (Int, Int) ] 1 { _A_ 2 _U_ 21 _N_ _S_ "LS" _F_ _ALWAYS_ \ (u0 :: (Int, Int)) (u1 :: [(Int, Int)]) -> let {(ub :: (Int, Int) -> Bool) = \ (u2 :: (Int, Int)) -> case u0 of { _ALG_ _TUP_2 (u3 :: Int) (u4 :: Int) -> case u3 of { _ALG_ I# (u5 :: Int#) -> case u2 of { _ALG_ _TUP_2 (u6 :: Int) (u7 :: Int) -> case u6 of { _ALG_ I# (u8 :: Int#) -> case _#_ neInt# [] [u5, u8] of { _ALG_ True -> _!_ True [] []; False -> case u4 of { _ALG_ I# (u9 :: Int#) -> case u7 of { _ALG_ I# (ua :: Int#) -> _#_ neInt# [] [u9, ua]; _NO_DEFLT_ }; _NO_DEFLT_ }; _NO_DEFLT_ }; _NO_DEFLT_ }; _NO_DEFLT_ }; _NO_DEFLT_ }; _NO_DEFLT_ }} in _APP_ _TYAPP_ _ORIG_ PreludeList all { (Int, Int) } [ ub, u1 ] _N_ } #-}
nub :: Eq a => [a] -> [a]
- {-# GHC_PRAGMA _A_ 2 _U_ 11 _N_ _S_ "LS" _N_ _N_ #-}
+ {-# GHC_PRAGMA _A_ 2 _U_ 11 _N_ _S_ "LS" _N_ _SPECIALISE_ [ Int ] 1 { _A_ 1 _U_ 1 _N_ _S_ "S" _N_ _N_ }, [ [Char] ] 1 { _A_ 1 _U_ 1 _N_ _S_ "S" _N_ _N_ }, [ [Int] ] 1 { _A_ 1 _U_ 1 _N_ _S_ "S" _N_ _N_ } #-}
null :: [a] -> Bool
{-# GHC_PRAGMA _A_ 1 _U_ 1 _N_ _S_ "S" _F_ _ALWAYS_ _/\_ u0 -> \ (u1 :: [u0]) -> let {(u2 :: Bool) = _!_ True [] []} in let {(u5 :: u0 -> Bool -> Bool) = \ (u3 :: u0) (u4 :: Bool) -> _!_ False [] []} in _APP_ _TYAPP_ _TYAPP_ foldr { u0 } { Bool } [ u5, u2, u1 ] _N_ #-}
or :: [Bool] -> Bool
partition :: (a -> Bool) -> [a] -> ([a], [a])
{-# GHC_PRAGMA _A_ 2 _U_ 21 _N_ _S_ "LS" _F_ _ALWAYS_ _/\_ u0 -> \ (u1 :: u0 -> Bool) (u2 :: [u0]) -> let {(u9 :: u0 -> ([u0], [u0]) -> ([u0], [u0])) = \ (u3 :: u0) (u4 :: ([u0], [u0])) -> case u4 of { _ALG_ _TUP_2 (u5 :: [u0]) (u6 :: [u0]) -> case _APP_ u1 [ u3 ] of { _ALG_ True -> let {(u7 :: [u0]) = _!_ (:) [u0] [u3, u5]} in _!_ _TUP_2 [[u0], [u0]] [u7, u6]; False -> let {(u8 :: [u0]) = _!_ (:) [u0] [u3, u6]} in _!_ _TUP_2 [[u0], [u0]] [u5, u8]; _NO_DEFLT_ }; _NO_DEFLT_ }} in let {(ua :: [u0]) = _!_ _NIL_ [u0] []} in let {(ub :: ([u0], [u0])) = _!_ _TUP_2 [[u0], [u0]] [ua, ua]} in _APP_ _TYAPP_ _TYAPP_ foldr { u0 } { ([u0], [u0]) } [ u9, ub, u2 ] _N_ #-}
product :: Num a => [a] -> a
- {-# GHC_PRAGMA _A_ 1 _U_ 22 _N_ _N_ _F_ _ALWAYS_ _/\_ u0 -> \ (u1 :: {{Num u0}}) -> let {(uc :: u0 -> u0 -> u0) = case u1 of { _ALG_ _TUP_10 (u2 :: {{Eq u0}}) (u3 :: {{Text u0}}) (u4 :: u0 -> u0 -> u0) (u5 :: u0 -> u0 -> u0) (u6 :: u0 -> u0 -> u0) (u7 :: u0 -> u0) (u8 :: u0 -> u0) (u9 :: u0 -> u0) (ua :: Integer -> u0) (ub :: Int -> u0) -> u6; _NO_DEFLT_ }} in let {(uo :: u0) = let {(ud :: Int) = _!_ I# [] [1#]} in case u1 of { _ALG_ _TUP_10 (ue :: {{Eq u0}}) (uf :: {{Text u0}}) (ug :: u0 -> u0 -> u0) (uh :: u0 -> u0 -> u0) (ui :: u0 -> u0 -> u0) (uj :: u0 -> u0) (uk :: u0 -> u0) (ul :: u0 -> u0) (um :: Integer -> u0) (un :: Int -> u0) -> _APP_ un [ ud ]; _NO_DEFLT_ }} in \ (up :: [u0]) -> _APP_ _TYAPP_ _TYAPP_ foldl { u0 } { u0 } [ uc, uo, up ] _SPECIALISE_ [ Double ] 1 { _A_ 1 _U_ 1 _N_ _S_ "S" _F_ _ALWAYS_ \ (u0 :: [Double]) -> let {(u1 :: Double) = _!_ D# [] [1.0000000000000000##]} in _APP_ _TYAPP_ _TYAPP_ foldl { Double } { Double } [ _CONSTM_ Num (*) (Double), u1, u0 ] _N_ }, [ Int ] 1 { _A_ 1 _U_ 1 _N_ _S_ "S" _F_ _ALWAYS_ \ (u0 :: [Int]) -> let {(u1 :: Int) = _!_ I# [] [1#]} in _APP_ _TYAPP_ _TYAPP_ foldl { Int } { Int } [ _CONSTM_ Num (*) (Int), u1, u0 ] _N_ }, [ Integer ] 1 { _A_ 1 _U_ 1 _N_ _S_ "S" _F_ _ALWAYS_ \ (u0 :: [Integer]) -> let {(u1 :: Integer) = _#_ int2Integer# [] [1#]} in _APP_ _TYAPP_ _TYAPP_ foldl { Integer } { Integer } [ _CONSTM_ Num (*) (Integer), u1, u0 ] _N_ } #-}
+ {-# GHC_PRAGMA _A_ 1 _U_ 22 _N_ _N_ _F_ _ALWAYS_ _/\_ u0 -> \ (u1 :: {{Num u0}}) -> let {(uc :: u0 -> u0 -> u0) = case u1 of { _ALG_ _TUP_10 (u2 :: {{Eq u0}}) (u3 :: {{Text u0}}) (u4 :: u0 -> u0 -> u0) (u5 :: u0 -> u0 -> u0) (u6 :: u0 -> u0 -> u0) (u7 :: u0 -> u0) (u8 :: u0 -> u0) (u9 :: u0 -> u0) (ua :: Integer -> u0) (ub :: Int -> u0) -> u6; _NO_DEFLT_ }} in let {(uo :: u0) = let {(ud :: Int) = _!_ I# [] [1#]} in case u1 of { _ALG_ _TUP_10 (ue :: {{Eq u0}}) (uf :: {{Text u0}}) (ug :: u0 -> u0 -> u0) (uh :: u0 -> u0 -> u0) (ui :: u0 -> u0 -> u0) (uj :: u0 -> u0) (uk :: u0 -> u0) (ul :: u0 -> u0) (um :: Integer -> u0) (un :: Int -> u0) -> _APP_ un [ ud ]; _NO_DEFLT_ }} in \ (up :: [u0]) -> _APP_ _TYAPP_ _TYAPP_ foldl { u0 } { u0 } [ uc, uo, up ] _SPECIALISE_ [ Double ] 1 { _A_ 1 _U_ 1 _N_ _S_ "S" _F_ _ALWAYS_ \ (u0 :: [Double]) -> let {(u1 :: Double) = _!_ D# [] [1.0000000000000000##]} in _APP_ _TYAPP_ _TYAPP_ foldl { Double } { Double } [ _CONSTM_ Num (*) (Double), u1, u0 ] _N_ }, [ Int ] 1 { _A_ 1 _U_ 1 _N_ _S_ "S" _F_ _ALWAYS_ \ (u0 :: [Int]) -> let {(u1 :: Int) = _!_ I# [] [1#]} in _APP_ _TYAPP_ _TYAPP_ foldl { Int } { Int } [ _CONSTM_ Num (*) (Int), u1, u0 ] _N_ }, [ Integer ] 1 { _A_ 1 _U_ 1 _N_ _S_ "S" _F_ _ALWAYS_ \ (u0 :: [Integer]) -> let {(u1 :: Integer) = _#_ int2Integer# [] [1#]} in _APP_ _TYAPP_ _TYAPP_ foldl { Integer } { Integer } [ _CONSTM_ Num (*) (Integer), u1, u0 ] _N_ }, [ (Complex Double) ] 1 { _A_ 1 _U_ 1 _N_ _S_ "S" _F_ _ALWAYS_ let {(u6 :: Complex Double -> Complex Double -> Complex Double) = \ (u0 :: Complex Double) (u1 :: Complex Double) -> case u0 of { _ALG_ (:+) (u2 :: Double) (u3 :: Double) -> case u1 of { _ALG_ (:+) (u4 :: Double) (u5 :: Double) -> _APP_ _WRKR_ _CONSTM_ Num (*) (Complex Double) [ u2, u3, u4, u5 ]; _NO_DEFLT_ }; _NO_DEFLT_ }} in let {(u8 :: Complex Double) = let {(u7 :: Int) = _!_ I# [] [1#]} in _APP_ _CONSTM_ Num fromInt (Complex Double) [ u7 ]} in \ (u9 :: [Complex Double]) -> _APP_ _TYAPP_ _TYAPP_ foldl { (Complex Double) } { (Complex Double) } [ u6, u8, u9 ] _N_ } #-}
products :: Num a => [a] -> [a]
- {-# GHC_PRAGMA _A_ 1 _U_ 21 _N_ _N_ _N_ _N_ #-}
+ {-# GHC_PRAGMA _A_ 1 _U_ 21 _N_ _N_ _N_ _SPECIALISE_ [ Double ] 1 { _A_ 1 _U_ 1 _N_ _N_ _N_ _N_ }, [ Int ] 1 { _A_ 1 _U_ 1 _N_ _N_ _N_ _N_ }, [ Integer ] 1 { _A_ 1 _U_ 1 _N_ _N_ _F_ _IF_ARGS_ 0 1 X 4 \ (u0 :: [Integer]) -> _APP_ _TYAPP_ _TYAPP_ _ORIG_ PreludeList scanl { Integer } { Integer } [ _CONSTM_ Num (*) (Integer), _SPEC_ _ORIG_ PreludeCore __i1 [ (Integer) ], u0 ] _N_ }, [ (Complex Double) ] 1 { _A_ 1 _U_ 1 _N_ _N_ _N_ _N_ } #-}
repeat :: a -> [a]
{-# GHC_PRAGMA _A_ 1 _U_ 2 _N_ _N_ _F_ _ALWAYS_ _/\_ u0 -> \ (u1 :: u0) -> let {(u6 :: _forall_ a$z1 =>(u0 -> a$z1 -> a$z1) -> a$z1 -> a$z1) = _/\_ u2 -> \ (u3 :: u0 -> u2 -> u2) (u4 :: u2) -> _LETREC_ {(u5 :: u2) = _APP_ u3 [ u1, u5 ]} in u5} in _APP_ _TYAPP_ _build { u0 } [ u6 ] _N_ #-}
reverse :: [a] -> [a]
sum :: Num a => [a] -> a
{-# GHC_PRAGMA _A_ 1 _U_ 22 _N_ _N_ _F_ _ALWAYS_ _/\_ u0 -> \ (u1 :: {{Num u0}}) -> let {(uc :: u0 -> u0 -> u0) = case u1 of { _ALG_ _TUP_10 (u2 :: {{Eq u0}}) (u3 :: {{Text u0}}) (u4 :: u0 -> u0 -> u0) (u5 :: u0 -> u0 -> u0) (u6 :: u0 -> u0 -> u0) (u7 :: u0 -> u0) (u8 :: u0 -> u0) (u9 :: u0 -> u0) (ua :: Integer -> u0) (ub :: Int -> u0) -> u4; _NO_DEFLT_ }} in let {(uo :: u0) = let {(ud :: Int) = _!_ I# [] [0#]} in case u1 of { _ALG_ _TUP_10 (ue :: {{Eq u0}}) (uf :: {{Text u0}}) (ug :: u0 -> u0 -> u0) (uh :: u0 -> u0 -> u0) (ui :: u0 -> u0 -> u0) (uj :: u0 -> u0) (uk :: u0 -> u0) (ul :: u0 -> u0) (um :: Integer -> u0) (un :: Int -> u0) -> _APP_ un [ ud ]; _NO_DEFLT_ }} in \ (up :: [u0]) -> _APP_ _TYAPP_ _TYAPP_ foldl { u0 } { u0 } [ uc, uo, up ] _SPECIALISE_ [ Double ] 1 { _A_ 1 _U_ 1 _N_ _S_ "S" _F_ _ALWAYS_ \ (u0 :: [Double]) -> let {(u1 :: Double) = _!_ D# [] [0.0000000000000000##]} in _APP_ _TYAPP_ _TYAPP_ foldl { Double } { Double } [ _CONSTM_ Num (+) (Double), u1, u0 ] _N_ }, [ Int ] 1 { _A_ 1 _U_ 1 _N_ _S_ "S" _F_ _ALWAYS_ \ (u0 :: [Int]) -> let {(u1 :: Int) = _!_ I# [] [0#]} in _APP_ _TYAPP_ _TYAPP_ foldl { Int } { Int } [ _CONSTM_ Num (+) (Int), u1, u0 ] _N_ }, [ Integer ] 1 { _A_ 1 _U_ 1 _N_ _S_ "S" _F_ _ALWAYS_ \ (u0 :: [Integer]) -> let {(u1 :: Integer) = _#_ int2Integer# [] [0#]} in _APP_ _TYAPP_ _TYAPP_ foldl { Integer } { Integer } [ _CONSTM_ Num (+) (Integer), u1, u0 ] _N_ }, [ (Complex Double) ] 1 { _A_ 1 _U_ 1 _N_ _S_ "S" _F_ _ALWAYS_ let {(u6 :: Complex Double -> Complex Double -> Complex Double) = \ (u0 :: Complex Double) (u1 :: Complex Double) -> case u0 of { _ALG_ (:+) (u2 :: Double) (u3 :: Double) -> case u1 of { _ALG_ (:+) (u4 :: Double) (u5 :: Double) -> _APP_ _WRKR_ _CONSTM_ Num (+) (Complex Double) [ u2, u3, u4, u5 ]; _NO_DEFLT_ }; _NO_DEFLT_ }} in let {(u8 :: Complex Double) = let {(u7 :: Int) = _!_ I# [] [0#]} in _APP_ _CONSTM_ Num fromInt (Complex Double) [ u7 ]} in \ (u9 :: [Complex Double]) -> _APP_ _TYAPP_ _TYAPP_ foldl { (Complex Double) } { (Complex Double) } [ u6, u8, u9 ] _N_ } #-}
sums :: Num a => [a] -> [a]
- {-# GHC_PRAGMA _A_ 1 _U_ 21 _N_ _N_ _N_ _N_ #-}
+ {-# GHC_PRAGMA _A_ 1 _U_ 21 _N_ _N_ _N_ _SPECIALISE_ [ Double ] 1 { _A_ 1 _U_ 1 _N_ _N_ _N_ _N_ }, [ Int ] 1 { _A_ 1 _U_ 1 _N_ _N_ _N_ _N_ }, [ Integer ] 1 { _A_ 1 _U_ 1 _N_ _N_ _F_ _IF_ARGS_ 0 1 X 4 \ (u0 :: [Integer]) -> _APP_ _TYAPP_ _TYAPP_ _ORIG_ PreludeList scanl { Integer } { Integer } [ _CONSTM_ Num (+) (Integer), _SPEC_ _ORIG_ PreludeCore __i0 [ (Integer) ], u0 ] _N_ }, [ (Complex Double) ] 1 { _A_ 1 _U_ 1 _N_ _N_ _N_ _N_ } #-}
tail :: [a] -> [a]
{-# GHC_PRAGMA _A_ 1 _U_ 1 _N_ _S_ "S" _F_ _IF_ARGS_ 1 1 C 5 _/\_ u0 -> \ (u1 :: [u0]) -> case u1 of { _ALG_ (:) (u2 :: u0) (u3 :: [u0]) -> u3; _NIL_ -> _APP_ _TYAPP_ error { [u0] } [ _NOREP_S_ "tail{PreludeList}: tail []\n" ]; _NO_DEFLT_ } _N_ #-}
take :: Integral a => a -> [b] -> [b]
- {-# GHC_PRAGMA _A_ 3 _U_ 121 _N_ _S_ "U(AAAAAAAAAAAS)LL" {_A_ 3 _U_ 121 _N_ _N_ _N_ _N_} _F_ _IF_ARGS_ 2 3 CXX 7 _/\_ u0 u1 -> \ (u2 :: {{Integral u0}}) (u3 :: u0) (u4 :: [u1]) -> let {(uh :: Int) = case u2 of { _ALG_ _TUP_12 (u5 :: {{Real u0}}) (u6 :: {{Ix u0}}) (u7 :: u0 -> u0 -> u0) (u8 :: u0 -> u0 -> u0) (u9 :: u0 -> u0 -> u0) (ua :: u0 -> u0 -> u0) (ub :: u0 -> u0 -> (u0, u0)) (uc :: u0 -> u0 -> (u0, u0)) (ud :: u0 -> Bool) (ue :: u0 -> Bool) (uf :: u0 -> Integer) (ug :: u0 -> Int) -> _APP_ ug [ u3 ]; _NO_DEFLT_ }} in _APP_ _TYAPP_ _SPEC_ _ORIG_ PreludeList take [ (Int), _N_ ] { u1 } [ uh, u4 ] _SPECIALISE_ [ Int, _N_ ] 1 { _A_ 2 _U_ 11 _N_ _S_ "U(P)L" {_A_ 2 _U_ 21 _N_ _N_ _N_ _N_} _N_ _N_ }, [ Integer, _N_ ] 1 { _A_ 2 _U_ 11 _N_ _S_ "U(PPP)L" {_A_ 4 _U_ 2221 _N_ _N_ _F_ _IF_ARGS_ 1 4 XXXX 4 _/\_ u0 -> \ (u1 :: Int#) (u2 :: Int#) (u3 :: ByteArray#) (u4 :: [u0]) -> case _#_ integer2Int# [] [u1, u2, u3] of { _PRIM_ (u5 :: Int#) -> _APP_ _TYAPP_ _WRKR_ _SPEC_ _ORIG_ PreludeList take [ (Int), _N_ ] { u0 } [ u5, u4 ] } _N_} _F_ _ALWAYS_ _/\_ u0 -> \ (u1 :: Integer) (u2 :: [u0]) -> case u1 of { _ALG_ J# (u3 :: Int#) (u4 :: Int#) (u5 :: ByteArray#) -> case _#_ integer2Int# [] [u3, u4, u5] of { _PRIM_ (u6 :: Int#) -> _APP_ _TYAPP_ _WRKR_ _SPEC_ _ORIG_ PreludeList take [ (Int), _N_ ] { u0 } [ u6, u2 ] }; _NO_DEFLT_ } _N_ } #-}
+ {-# GHC_PRAGMA _A_ 1 _U_ 122 _N_ _S_ "U(LU(U(ASSAAAAA)AAA)AAAALAAAAL)" {_A_ 5 _U_ 2121222 _N_ _N_ _N_ _N_} _N_ _SPECIALISE_ [ Int, _N_ ] 1 { _A_ 2 _U_ 11 _N_ _S_ "U(P)L" {_A_ 2 _U_ 21 _N_ _N_ _N_ _N_} _N_ _N_ }, [ Integer, _N_ ] 1 { _A_ 1 _U_ 12 _N_ _S_ "U(PPP)" {_A_ 3 _U_ 2222 _N_ _N_ _N_ _N_} _N_ _N_ } #-}
takeWhile :: (a -> Bool) -> [a] -> [a]
{-# GHC_PRAGMA _A_ 2 _U_ 21 _N_ _S_ "LS" _F_ _ALWAYS_ _/\_ u0 -> \ (u1 :: u0 -> Bool) (u2 :: [u0]) -> let {(u9 :: _forall_ a$z1 =>(u0 -> a$z1 -> a$z1) -> a$z1 -> a$z1) = _/\_ u3 -> \ (u4 :: u0 -> u3 -> u3) (u5 :: u3) -> let {(u8 :: u0 -> u3 -> u3) = \ (u6 :: u0) (u7 :: u3) -> case _APP_ u1 [ u6 ] of { _ALG_ True -> _APP_ u4 [ u6, u7 ]; False -> u5; _NO_DEFLT_ }} in _APP_ _TYAPP_ _TYAPP_ foldr { u0 } { u3 } [ u8, u5, u2 ]} in _APP_ _TYAPP_ _build { u0 } [ u9 ] _N_ #-}
transpose :: [[a]] -> [[a]]
-{-# GHC_PRAGMA INTERFACE VERSION 5 #-}
+{-# GHC_PRAGMA INTERFACE VERSION 6 #-}
interface PreludeList where
import PreludeBuiltin(Char(..), Int(..), List(..), Tuple2, Tuple3, Tuple4, Tuple5, Tuple6, Tuple7)
import PreludeCore(Bool(..), Eq(..), Integral(..), Num(..), Ord(..))
(++) :: [a] -> [a] -> [a]
{-# GHC_PRAGMA _A_ 2 _U_ 12 _N_ _S_ "SL" _N_ _N_ #-}
(\\) :: Eq a => [a] -> [a] -> [a]
- {-# GHC_PRAGMA _A_ 3 _U_ 122 _N_ _S_ "LLS" _N_ _N_ #-}
+ {-# GHC_PRAGMA _A_ 3 _U_ 122 _N_ _S_ "LLS" _N_ _SPECIALISE_ [ Int ] 1 { _A_ 2 _U_ 22 _N_ _S_ "LS" _N_ _N_ }, [ [Char] ] 1 { _A_ 2 _U_ 22 _N_ _S_ "LS" _N_ _N_ } #-}
all :: (a -> Bool) -> [a] -> Bool
{-# GHC_PRAGMA _A_ 2 _U_ 21 _N_ _S_ "LS" _F_ _ALWAYS_ _/\_ u0 -> \ (u1 :: u0 -> Bool) (u2 :: [u0]) -> let {(u3 :: Bool) = _!_ True [] []} in let {(u6 :: u0 -> Bool -> Bool) = \ (u4 :: u0) (u5 :: Bool) -> case _APP_ u1 [ u4 ] of { _ALG_ True -> u5; False -> _!_ False [] []; _NO_DEFLT_ }} in _APP_ _TYAPP_ _TYAPP_ foldr { u0 } { Bool } [ u6, u3, u2 ] _N_ #-}
and :: [Bool] -> Bool
dropWhile :: (a -> Bool) -> [a] -> [a]
{-# GHC_PRAGMA _A_ 2 _U_ 21 _N_ _S_ "LS" _N_ _N_ #-}
elem :: Eq a => a -> [a] -> Bool
- {-# GHC_PRAGMA _A_ 3 _U_ 121 _N_ _S_ "LLS" _F_ _ALWAYS_ _/\_ u0 -> \ (u1 :: {{Eq u0}}) (u2 :: u0) (u3 :: [u0]) -> let {(u6 :: u0 -> u0 -> Bool) = case u1 of { _ALG_ _TUP_2 (u4 :: u0 -> u0 -> Bool) (u5 :: u0 -> u0 -> Bool) -> u4; _NO_DEFLT_ }} in let {(u8 :: u0 -> Bool) = \ (u7 :: u0) -> _APP_ u6 [ u2, u7 ]} in _APP_ _TYAPP_ _ORIG_ PreludeList any { u0 } [ u8, u3 ] _SPECIALISE_ [ Char ] 1 { _A_ 2 _U_ 21 _N_ _S_ "LS" _F_ _ALWAYS_ \ (u0 :: Char) (u1 :: [Char]) -> let {(u5 :: Char -> Bool) = \ (u2 :: Char) -> case u0 of { _ALG_ C# (u3 :: Char#) -> case u2 of { _ALG_ C# (u4 :: Char#) -> _#_ eqChar# [] [u3, u4]; _NO_DEFLT_ }; _NO_DEFLT_ }} in _APP_ _TYAPP_ _ORIG_ PreludeList any { Char } [ u5, u1 ] _N_ }, [ Int ] 1 { _A_ 2 _U_ 21 _N_ _S_ "LS" _F_ _ALWAYS_ \ (u0 :: Int) (u1 :: [Int]) -> let {(u5 :: Int -> Bool) = \ (u2 :: Int) -> case u0 of { _ALG_ I# (u3 :: Int#) -> case u2 of { _ALG_ I# (u4 :: Int#) -> _#_ eqInt# [] [u3, u4]; _NO_DEFLT_ }; _NO_DEFLT_ }} in _APP_ _TYAPP_ _ORIG_ PreludeList any { Int } [ u5, u1 ] _N_ }, [ [Char] ] 1 { _A_ 2 _U_ 21 _N_ _S_ "LS" _F_ _ALWAYS_ \ (u0 :: [Char]) (u1 :: [[Char]]) -> let {(u3 :: [Char] -> Bool) = \ (u2 :: [Char]) -> _APP_ _CONSTM_ Eq (==) ([Char]) [ u0, u2 ]} in _APP_ _TYAPP_ _ORIG_ PreludeList any { [Char] } [ u3, u1 ] _N_ } #-}
+ {-# GHC_PRAGMA _A_ 3 _U_ 121 _N_ _S_ "LLS" _F_ _ALWAYS_ _/\_ u0 -> \ (u1 :: {{Eq u0}}) (u2 :: u0) (u3 :: [u0]) -> let {(u6 :: u0 -> u0 -> Bool) = case u1 of { _ALG_ _TUP_2 (u4 :: u0 -> u0 -> Bool) (u5 :: u0 -> u0 -> Bool) -> u4; _NO_DEFLT_ }} in let {(u8 :: u0 -> Bool) = \ (u7 :: u0) -> _APP_ u6 [ u2, u7 ]} in _APP_ _TYAPP_ _ORIG_ PreludeList any { u0 } [ u8, u3 ] _SPECIALISE_ [ Char ] 1 { _A_ 2 _U_ 21 _N_ _S_ "LS" _F_ _ALWAYS_ \ (u0 :: Char) (u1 :: [Char]) -> let {(u5 :: Char -> Bool) = \ (u2 :: Char) -> case u0 of { _ALG_ C# (u3 :: Char#) -> case u2 of { _ALG_ C# (u4 :: Char#) -> _#_ eqChar# [] [u3, u4]; _NO_DEFLT_ }; _NO_DEFLT_ }} in _APP_ _TYAPP_ _ORIG_ PreludeList any { Char } [ u5, u1 ] _N_ }, [ Int ] 1 { _A_ 2 _U_ 21 _N_ _S_ "LS" _F_ _ALWAYS_ \ (u0 :: Int) (u1 :: [Int]) -> let {(u5 :: Int -> Bool) = \ (u2 :: Int) -> case u0 of { _ALG_ I# (u3 :: Int#) -> case u2 of { _ALG_ I# (u4 :: Int#) -> _#_ eqInt# [] [u3, u4]; _NO_DEFLT_ }; _NO_DEFLT_ }} in _APP_ _TYAPP_ _ORIG_ PreludeList any { Int } [ u5, u1 ] _N_ }, [ Integer ] 1 { _A_ 2 _U_ 21 _N_ _S_ "LS" _F_ _ALWAYS_ \ (u0 :: Integer) (u1 :: [Integer]) -> let {(ua :: Integer -> Bool) = \ (u2 :: Integer) -> case u0 of { _ALG_ J# (u3 :: Int#) (u4 :: Int#) (u5 :: ByteArray#) -> case u2 of { _ALG_ J# (u6 :: Int#) (u7 :: Int#) (u8 :: ByteArray#) -> case _#_ cmpInteger# [] [u3, u4, u5, u6, u7, u8] of { _PRIM_ 0# -> _!_ True [] []; (u9 :: Int#) -> _!_ False [] [] }; _NO_DEFLT_ }; _NO_DEFLT_ }} in _APP_ _TYAPP_ _ORIG_ PreludeList any { Integer } [ ua, u1 ] _N_ }, [ [Char] ] 1 { _A_ 2 _U_ 21 _N_ _S_ "LS" _F_ _ALWAYS_ \ (u0 :: [Char]) (u1 :: [[Char]]) -> let {(u3 :: [Char] -> Bool) = \ (u2 :: [Char]) -> _APP_ _CONSTM_ Eq (==) ([Char]) [ u0, u2 ]} in _APP_ _TYAPP_ _ORIG_ PreludeList any { [Char] } [ u3, u1 ] _N_ }, [ [Int] ] 1 { _A_ 2 _U_ 21 _N_ _S_ "LS" _F_ _ALWAYS_ \ (u0 :: [Int]) (u1 :: [[Int]]) -> let {(u3 :: [Int] -> Bool) = \ (u2 :: [Int]) -> _APP_ _CONSTM_ Eq (==) ([Int]) [ u0, u2 ]} in _APP_ _TYAPP_ _ORIG_ PreludeList any { [Int] } [ u3, u1 ] _N_ }, [ (Int, Int) ] 1 { _A_ 2 _U_ 21 _N_ _S_ "LS" _F_ _ALWAYS_ \ (u0 :: (Int, Int)) (u1 :: [(Int, Int)]) -> let {(ub :: (Int, Int) -> Bool) = \ (u2 :: (Int, Int)) -> case u0 of { _ALG_ _TUP_2 (u3 :: Int) (u4 :: Int) -> case u3 of { _ALG_ I# (u5 :: Int#) -> case u2 of { _ALG_ _TUP_2 (u6 :: Int) (u7 :: Int) -> case u6 of { _ALG_ I# (u8 :: Int#) -> case _#_ eqInt# [] [u5, u8] of { _ALG_ True -> case u4 of { _ALG_ I# (u9 :: Int#) -> case u7 of { _ALG_ I# (ua :: Int#) -> _#_ eqInt# [] [u9, ua]; _NO_DEFLT_ }; _NO_DEFLT_ }; False -> _!_ False [] []; _NO_DEFLT_ }; _NO_DEFLT_ }; _NO_DEFLT_ }; _NO_DEFLT_ }; _NO_DEFLT_ }} in _APP_ _TYAPP_ _ORIG_ PreludeList any { (Int, Int) } [ ub, u1 ] _N_ } #-}
filter :: (a -> Bool) -> [a] -> [a]
{-# GHC_PRAGMA _A_ 2 _U_ 21 _N_ _S_ "LS" _F_ _ALWAYS_ _/\_ u0 -> \ (u1 :: u0 -> Bool) (u2 :: [u0]) -> let {(u9 :: _forall_ a$z1 =>(u0 -> a$z1 -> a$z1) -> a$z1 -> a$z1) = _/\_ u3 -> \ (u4 :: u0 -> u3 -> u3) (u5 :: u3) -> let {(u8 :: u0 -> u3 -> u3) = \ (u6 :: u0) (u7 :: u3) -> case _APP_ u1 [ u6 ] of { _ALG_ True -> _APP_ u4 [ u6, u7 ]; False -> u7; _NO_DEFLT_ }} in _APP_ _TYAPP_ _TYAPP_ foldr { u0 } { u3 } [ u8, u5, u2 ]} in _APP_ _TYAPP_ _build { u0 } [ u9 ] _N_ #-}
foldl1 :: (a -> a -> a) -> [a] -> a
foldr1 :: (a -> a -> a) -> [a] -> a
{-# GHC_PRAGMA _A_ 2 _U_ 21 _N_ _S_ "LS" _N_ _N_ #-}
genericLength :: Num b => [a] -> b
- {-# GHC_PRAGMA _A_ 1 _U_ 21 _N_ _N_ _N_ _N_ #-}
+ {-# GHC_PRAGMA _A_ 1 _U_ 21 _N_ _N_ _N_ _SPECIALISE_ [ _N_, Int ] 1 { _A_ 1 _U_ 1 _N_ _S_ "S" _N_ _N_ }, [ _N_, Integer ] 1 { _A_ 1 _U_ 1 _N_ _S_ "S" _N_ _N_ } #-}
head :: [a] -> a
{-# GHC_PRAGMA _A_ 1 _U_ 1 _N_ _S_ "S" _F_ _ALWAYS_ _/\_ u0 -> \ (u1 :: [u0]) -> let {(u2 :: u0) = _APP_ _TYAPP_ error { u0 } [ _NOREP_S_ "head{PreludeList}: head []\n" ]} in let {(u5 :: u0 -> u0 -> u0) = \ (u3 :: u0) (u4 :: u0) -> u3} in _APP_ _TYAPP_ _TYAPP_ foldr { u0 } { u0 } [ u5, u2, u1 ] _N_ #-}
init :: [a] -> [a]
map :: (a -> b) -> [a] -> [b]
{-# GHC_PRAGMA _A_ 2 _U_ 21 _N_ _S_ "LS" _F_ _ALWAYS_ _/\_ u0 u1 -> \ (u2 :: u0 -> u1) (u3 :: [u0]) -> let {(ua :: _forall_ a$z1 =>(u1 -> a$z1 -> a$z1) -> a$z1 -> a$z1) = _/\_ u4 -> \ (u5 :: u1 -> u4 -> u4) (u6 :: u4) -> let {(u9 :: u0 -> u4 -> u4) = \ (u7 :: u0) -> let {(u8 :: u1) = _APP_ u2 [ u7 ]} in _APP_ u5 [ u8 ]} in _APP_ _TYAPP_ _TYAPP_ foldr { u0 } { u4 } [ u9, u6, u3 ]} in _APP_ _TYAPP_ _build { u1 } [ ua ] _N_ #-}
maximum :: Ord a => [a] -> a
- {-# GHC_PRAGMA _A_ 1 _U_ 11 _N_ _N_ _N_ _N_ #-}
+ {-# GHC_PRAGMA _A_ 1 _U_ 11 _N_ _N_ _N_ _SPECIALISE_ [ Double ] 1 { _A_ 1 _U_ 1 _N_ _S_ "S" _N_ _N_ }, [ Int ] 1 { _A_ 1 _U_ 1 _N_ _S_ "S" _N_ _N_ }, [ Integer ] 1 { _A_ 1 _U_ 1 _N_ _S_ "S" _N_ _N_ } #-}
minimum :: Ord a => [a] -> a
- {-# GHC_PRAGMA _A_ 1 _U_ 11 _N_ _N_ _N_ _N_ #-}
+ {-# GHC_PRAGMA _A_ 1 _U_ 11 _N_ _N_ _N_ _SPECIALISE_ [ Double ] 1 { _A_ 1 _U_ 1 _N_ _S_ "S" _N_ _N_ }, [ Int ] 1 { _A_ 1 _U_ 1 _N_ _S_ "S" _N_ _N_ }, [ Integer ] 1 { _A_ 1 _U_ 1 _N_ _S_ "S" _N_ _N_ } #-}
notElem :: Eq a => a -> [a] -> Bool
- {-# GHC_PRAGMA _A_ 3 _U_ 121 _N_ _S_ "LLS" _F_ _ALWAYS_ _/\_ u0 -> \ (u1 :: {{Eq u0}}) (u2 :: u0) (u3 :: [u0]) -> let {(u6 :: u0 -> u0 -> Bool) = case u1 of { _ALG_ _TUP_2 (u4 :: u0 -> u0 -> Bool) (u5 :: u0 -> u0 -> Bool) -> u5; _NO_DEFLT_ }} in let {(u8 :: u0 -> Bool) = \ (u7 :: u0) -> _APP_ u6 [ u2, u7 ]} in _APP_ _TYAPP_ _ORIG_ PreludeList all { u0 } [ u8, u3 ] _SPECIALISE_ [ Char ] 1 { _A_ 2 _U_ 21 _N_ _S_ "LS" _F_ _ALWAYS_ \ (u0 :: Char) (u1 :: [Char]) -> let {(u5 :: Char -> Bool) = \ (u2 :: Char) -> case u0 of { _ALG_ C# (u3 :: Char#) -> case u2 of { _ALG_ C# (u4 :: Char#) -> _#_ neChar# [] [u3, u4]; _NO_DEFLT_ }; _NO_DEFLT_ }} in _APP_ _TYAPP_ _ORIG_ PreludeList all { Char } [ u5, u1 ] _N_ }, [ Int ] 1 { _A_ 2 _U_ 21 _N_ _S_ "LS" _F_ _ALWAYS_ \ (u0 :: Int) (u1 :: [Int]) -> let {(u5 :: Int -> Bool) = \ (u2 :: Int) -> case u0 of { _ALG_ I# (u3 :: Int#) -> case u2 of { _ALG_ I# (u4 :: Int#) -> _#_ neInt# [] [u3, u4]; _NO_DEFLT_ }; _NO_DEFLT_ }} in _APP_ _TYAPP_ _ORIG_ PreludeList all { Int } [ u5, u1 ] _N_ }, [ [Char] ] 1 { _A_ 2 _U_ 21 _N_ _S_ "LS" _F_ _ALWAYS_ \ (u0 :: [Char]) (u1 :: [[Char]]) -> let {(u3 :: [Char] -> Bool) = \ (u2 :: [Char]) -> _APP_ _CONSTM_ Eq (/=) ([Char]) [ u0, u2 ]} in _APP_ _TYAPP_ _ORIG_ PreludeList all { [Char] } [ u3, u1 ] _N_ } #-}
+ {-# GHC_PRAGMA _A_ 3 _U_ 121 _N_ _S_ "LLS" _F_ _ALWAYS_ _/\_ u0 -> \ (u1 :: {{Eq u0}}) (u2 :: u0) (u3 :: [u0]) -> let {(u6 :: u0 -> u0 -> Bool) = case u1 of { _ALG_ _TUP_2 (u4 :: u0 -> u0 -> Bool) (u5 :: u0 -> u0 -> Bool) -> u5; _NO_DEFLT_ }} in let {(u8 :: u0 -> Bool) = \ (u7 :: u0) -> _APP_ u6 [ u2, u7 ]} in _APP_ _TYAPP_ _ORIG_ PreludeList all { u0 } [ u8, u3 ] _SPECIALISE_ [ Char ] 1 { _A_ 2 _U_ 21 _N_ _S_ "LS" _F_ _ALWAYS_ \ (u0 :: Char) (u1 :: [Char]) -> let {(u5 :: Char -> Bool) = \ (u2 :: Char) -> case u0 of { _ALG_ C# (u3 :: Char#) -> case u2 of { _ALG_ C# (u4 :: Char#) -> _#_ neChar# [] [u3, u4]; _NO_DEFLT_ }; _NO_DEFLT_ }} in _APP_ _TYAPP_ _ORIG_ PreludeList all { Char } [ u5, u1 ] _N_ }, [ Int ] 1 { _A_ 2 _U_ 21 _N_ _S_ "LS" _F_ _ALWAYS_ \ (u0 :: Int) (u1 :: [Int]) -> let {(u5 :: Int -> Bool) = \ (u2 :: Int) -> case u0 of { _ALG_ I# (u3 :: Int#) -> case u2 of { _ALG_ I# (u4 :: Int#) -> _#_ neInt# [] [u3, u4]; _NO_DEFLT_ }; _NO_DEFLT_ }} in _APP_ _TYAPP_ _ORIG_ PreludeList all { Int } [ u5, u1 ] _N_ }, [ Integer ] 1 { _A_ 2 _U_ 21 _N_ _S_ "LS" _F_ _ALWAYS_ \ (u0 :: Integer) (u1 :: [Integer]) -> let {(ua :: Integer -> Bool) = \ (u2 :: Integer) -> case u0 of { _ALG_ J# (u3 :: Int#) (u4 :: Int#) (u5 :: ByteArray#) -> case u2 of { _ALG_ J# (u6 :: Int#) (u7 :: Int#) (u8 :: ByteArray#) -> case _#_ cmpInteger# [] [u3, u4, u5, u6, u7, u8] of { _PRIM_ 0# -> _!_ False [] []; (u9 :: Int#) -> _!_ True [] [] }; _NO_DEFLT_ }; _NO_DEFLT_ }} in _APP_ _TYAPP_ _ORIG_ PreludeList all { Integer } [ ua, u1 ] _N_ }, [ [Char] ] 1 { _A_ 2 _U_ 21 _N_ _S_ "LS" _F_ _ALWAYS_ \ (u0 :: [Char]) (u1 :: [[Char]]) -> let {(u3 :: [Char] -> Bool) = \ (u2 :: [Char]) -> _APP_ _CONSTM_ Eq (/=) ([Char]) [ u0, u2 ]} in _APP_ _TYAPP_ _ORIG_ PreludeList all { [Char] } [ u3, u1 ] _N_ }, [ (Int, Int) ] 1 { _A_ 2 _U_ 21 _N_ _S_ "LS" _F_ _ALWAYS_ \ (u0 :: (Int, Int)) (u1 :: [(Int, Int)]) -> let {(ub :: (Int, Int) -> Bool) = \ (u2 :: (Int, Int)) -> case u0 of { _ALG_ _TUP_2 (u3 :: Int) (u4 :: Int) -> case u3 of { _ALG_ I# (u5 :: Int#) -> case u2 of { _ALG_ _TUP_2 (u6 :: Int) (u7 :: Int) -> case u6 of { _ALG_ I# (u8 :: Int#) -> case _#_ neInt# [] [u5, u8] of { _ALG_ True -> _!_ True [] []; False -> case u4 of { _ALG_ I# (u9 :: Int#) -> case u7 of { _ALG_ I# (ua :: Int#) -> _#_ neInt# [] [u9, ua]; _NO_DEFLT_ }; _NO_DEFLT_ }; _NO_DEFLT_ }; _NO_DEFLT_ }; _NO_DEFLT_ }; _NO_DEFLT_ }; _NO_DEFLT_ }} in _APP_ _TYAPP_ _ORIG_ PreludeList all { (Int, Int) } [ ub, u1 ] _N_ } #-}
nub :: Eq a => [a] -> [a]
- {-# GHC_PRAGMA _A_ 2 _U_ 11 _N_ _S_ "LS" _N_ _N_ #-}
+ {-# GHC_PRAGMA _A_ 2 _U_ 11 _N_ _S_ "LS" _N_ _SPECIALISE_ [ Int ] 1 { _A_ 1 _U_ 1 _N_ _S_ "S" _N_ _N_ }, [ [Char] ] 1 { _A_ 1 _U_ 1 _N_ _S_ "S" _N_ _N_ }, [ [Int] ] 1 { _A_ 1 _U_ 1 _N_ _S_ "S" _N_ _N_ } #-}
null :: [a] -> Bool
{-# GHC_PRAGMA _A_ 1 _U_ 1 _N_ _S_ "S" _F_ _ALWAYS_ _/\_ u0 -> \ (u1 :: [u0]) -> let {(u2 :: Bool) = _!_ True [] []} in let {(u5 :: u0 -> Bool -> Bool) = \ (u3 :: u0) (u4 :: Bool) -> _!_ False [] []} in _APP_ _TYAPP_ _TYAPP_ foldr { u0 } { Bool } [ u5, u2, u1 ] _N_ #-}
or :: [Bool] -> Bool
partition :: (a -> Bool) -> [a] -> ([a], [a])
{-# GHC_PRAGMA _A_ 2 _U_ 21 _N_ _S_ "LS" _F_ _ALWAYS_ _/\_ u0 -> \ (u1 :: u0 -> Bool) (u2 :: [u0]) -> let {(u9 :: u0 -> ([u0], [u0]) -> ([u0], [u0])) = \ (u3 :: u0) (u4 :: ([u0], [u0])) -> case u4 of { _ALG_ _TUP_2 (u5 :: [u0]) (u6 :: [u0]) -> case _APP_ u1 [ u3 ] of { _ALG_ True -> let {(u7 :: [u0]) = _!_ (:) [u0] [u3, u5]} in _!_ _TUP_2 [[u0], [u0]] [u7, u6]; False -> let {(u8 :: [u0]) = _!_ (:) [u0] [u3, u6]} in _!_ _TUP_2 [[u0], [u0]] [u5, u8]; _NO_DEFLT_ }; _NO_DEFLT_ }} in let {(ua :: [u0]) = _!_ _NIL_ [u0] []} in let {(ub :: ([u0], [u0])) = _!_ _TUP_2 [[u0], [u0]] [ua, ua]} in _APP_ _TYAPP_ _TYAPP_ foldr { u0 } { ([u0], [u0]) } [ u9, ub, u2 ] _N_ #-}
product :: Num a => [a] -> a
- {-# GHC_PRAGMA _A_ 1 _U_ 22 _N_ _N_ _F_ _ALWAYS_ _/\_ u0 -> \ (u1 :: {{Num u0}}) -> let {(uc :: u0 -> u0 -> u0) = case u1 of { _ALG_ _TUP_10 (u2 :: {{Eq u0}}) (u3 :: {{Text u0}}) (u4 :: u0 -> u0 -> u0) (u5 :: u0 -> u0 -> u0) (u6 :: u0 -> u0 -> u0) (u7 :: u0 -> u0) (u8 :: u0 -> u0) (u9 :: u0 -> u0) (ua :: Integer -> u0) (ub :: Int -> u0) -> u6; _NO_DEFLT_ }} in let {(uo :: u0) = let {(ud :: Int) = _!_ I# [] [1#]} in case u1 of { _ALG_ _TUP_10 (ue :: {{Eq u0}}) (uf :: {{Text u0}}) (ug :: u0 -> u0 -> u0) (uh :: u0 -> u0 -> u0) (ui :: u0 -> u0 -> u0) (uj :: u0 -> u0) (uk :: u0 -> u0) (ul :: u0 -> u0) (um :: Integer -> u0) (un :: Int -> u0) -> _APP_ un [ ud ]; _NO_DEFLT_ }} in \ (up :: [u0]) -> _APP_ _TYAPP_ _TYAPP_ foldl { u0 } { u0 } [ uc, uo, up ] _SPECIALISE_ [ Double ] 1 { _A_ 1 _U_ 1 _N_ _S_ "S" _F_ _ALWAYS_ \ (u0 :: [Double]) -> let {(u1 :: Double) = _!_ D# [] [1.0000000000000000##]} in _APP_ _TYAPP_ _TYAPP_ foldl { Double } { Double } [ _CONSTM_ Num (*) (Double), u1, u0 ] _N_ }, [ Int ] 1 { _A_ 1 _U_ 1 _N_ _S_ "S" _F_ _ALWAYS_ \ (u0 :: [Int]) -> let {(u1 :: Int) = _!_ I# [] [1#]} in _APP_ _TYAPP_ _TYAPP_ foldl { Int } { Int } [ _CONSTM_ Num (*) (Int), u1, u0 ] _N_ }, [ Integer ] 1 { _A_ 1 _U_ 1 _N_ _S_ "S" _F_ _ALWAYS_ \ (u0 :: [Integer]) -> let {(u1 :: Integer) = _#_ int2Integer# [] [1#]} in _APP_ _TYAPP_ _TYAPP_ foldl { Integer } { Integer } [ _CONSTM_ Num (*) (Integer), u1, u0 ] _N_ } #-}
+ {-# GHC_PRAGMA _A_ 1 _U_ 22 _N_ _N_ _F_ _ALWAYS_ _/\_ u0 -> \ (u1 :: {{Num u0}}) -> let {(uc :: u0 -> u0 -> u0) = case u1 of { _ALG_ _TUP_10 (u2 :: {{Eq u0}}) (u3 :: {{Text u0}}) (u4 :: u0 -> u0 -> u0) (u5 :: u0 -> u0 -> u0) (u6 :: u0 -> u0 -> u0) (u7 :: u0 -> u0) (u8 :: u0 -> u0) (u9 :: u0 -> u0) (ua :: Integer -> u0) (ub :: Int -> u0) -> u6; _NO_DEFLT_ }} in let {(uo :: u0) = let {(ud :: Int) = _!_ I# [] [1#]} in case u1 of { _ALG_ _TUP_10 (ue :: {{Eq u0}}) (uf :: {{Text u0}}) (ug :: u0 -> u0 -> u0) (uh :: u0 -> u0 -> u0) (ui :: u0 -> u0 -> u0) (uj :: u0 -> u0) (uk :: u0 -> u0) (ul :: u0 -> u0) (um :: Integer -> u0) (un :: Int -> u0) -> _APP_ un [ ud ]; _NO_DEFLT_ }} in \ (up :: [u0]) -> _APP_ _TYAPP_ _TYAPP_ foldl { u0 } { u0 } [ uc, uo, up ] _SPECIALISE_ [ Double ] 1 { _A_ 1 _U_ 1 _N_ _S_ "S" _F_ _ALWAYS_ \ (u0 :: [Double]) -> let {(u1 :: Double) = _!_ D# [] [1.0000000000000000##]} in _APP_ _TYAPP_ _TYAPP_ foldl { Double } { Double } [ _CONSTM_ Num (*) (Double), u1, u0 ] _N_ }, [ Int ] 1 { _A_ 1 _U_ 1 _N_ _S_ "S" _F_ _ALWAYS_ \ (u0 :: [Int]) -> let {(u1 :: Int) = _!_ I# [] [1#]} in _APP_ _TYAPP_ _TYAPP_ foldl { Int } { Int } [ _CONSTM_ Num (*) (Int), u1, u0 ] _N_ }, [ Integer ] 1 { _A_ 1 _U_ 1 _N_ _S_ "S" _F_ _ALWAYS_ \ (u0 :: [Integer]) -> let {(u1 :: Integer) = _#_ int2Integer# [] [1#]} in _APP_ _TYAPP_ _TYAPP_ foldl { Integer } { Integer } [ _CONSTM_ Num (*) (Integer), u1, u0 ] _N_ }, [ (Complex Double) ] 1 { _A_ 1 _U_ 1 _N_ _S_ "S" _F_ _ALWAYS_ let {(u6 :: Complex Double -> Complex Double -> Complex Double) = \ (u0 :: Complex Double) (u1 :: Complex Double) -> case u0 of { _ALG_ (:+) (u2 :: Double) (u3 :: Double) -> case u1 of { _ALG_ (:+) (u4 :: Double) (u5 :: Double) -> _APP_ _WRKR_ _CONSTM_ Num (*) (Complex Double) [ u2, u3, u4, u5 ]; _NO_DEFLT_ }; _NO_DEFLT_ }} in let {(u8 :: Complex Double) = let {(u7 :: Int) = _!_ I# [] [1#]} in _APP_ _CONSTM_ Num fromInt (Complex Double) [ u7 ]} in \ (u9 :: [Complex Double]) -> _APP_ _TYAPP_ _TYAPP_ foldl { (Complex Double) } { (Complex Double) } [ u6, u8, u9 ] _N_ } #-}
products :: Num a => [a] -> [a]
- {-# GHC_PRAGMA _A_ 1 _U_ 21 _N_ _N_ _N_ _N_ #-}
+ {-# GHC_PRAGMA _A_ 1 _U_ 21 _N_ _N_ _N_ _SPECIALISE_ [ Double ] 1 { _A_ 1 _U_ 1 _N_ _N_ _N_ _N_ }, [ Int ] 1 { _A_ 1 _U_ 1 _N_ _N_ _N_ _N_ }, [ Integer ] 1 { _A_ 1 _U_ 1 _N_ _N_ _F_ _IF_ARGS_ 0 1 X 4 \ (u0 :: [Integer]) -> _APP_ _TYAPP_ _TYAPP_ _ORIG_ PreludeList scanl { Integer } { Integer } [ _CONSTM_ Num (*) (Integer), _SPEC_ _ORIG_ PreludeCore __i1 [ (Integer) ], u0 ] _N_ }, [ (Complex Double) ] 1 { _A_ 1 _U_ 1 _N_ _N_ _N_ _N_ } #-}
repeat :: a -> [a]
{-# GHC_PRAGMA _A_ 1 _U_ 2 _N_ _N_ _F_ _ALWAYS_ _/\_ u0 -> \ (u1 :: u0) -> let {(u6 :: _forall_ a$z1 =>(u0 -> a$z1 -> a$z1) -> a$z1 -> a$z1) = _/\_ u2 -> \ (u3 :: u0 -> u2 -> u2) (u4 :: u2) -> _LETREC_ {(u5 :: u2) = _APP_ u3 [ u1, u5 ]} in u5} in _APP_ _TYAPP_ _build { u0 } [ u6 ] _N_ #-}
reverse :: [a] -> [a]
sum :: Num a => [a] -> a
{-# GHC_PRAGMA _A_ 1 _U_ 22 _N_ _N_ _F_ _ALWAYS_ _/\_ u0 -> \ (u1 :: {{Num u0}}) -> let {(uc :: u0 -> u0 -> u0) = case u1 of { _ALG_ _TUP_10 (u2 :: {{Eq u0}}) (u3 :: {{Text u0}}) (u4 :: u0 -> u0 -> u0) (u5 :: u0 -> u0 -> u0) (u6 :: u0 -> u0 -> u0) (u7 :: u0 -> u0) (u8 :: u0 -> u0) (u9 :: u0 -> u0) (ua :: Integer -> u0) (ub :: Int -> u0) -> u4; _NO_DEFLT_ }} in let {(uo :: u0) = let {(ud :: Int) = _!_ I# [] [0#]} in case u1 of { _ALG_ _TUP_10 (ue :: {{Eq u0}}) (uf :: {{Text u0}}) (ug :: u0 -> u0 -> u0) (uh :: u0 -> u0 -> u0) (ui :: u0 -> u0 -> u0) (uj :: u0 -> u0) (uk :: u0 -> u0) (ul :: u0 -> u0) (um :: Integer -> u0) (un :: Int -> u0) -> _APP_ un [ ud ]; _NO_DEFLT_ }} in \ (up :: [u0]) -> _APP_ _TYAPP_ _TYAPP_ foldl { u0 } { u0 } [ uc, uo, up ] _SPECIALISE_ [ Double ] 1 { _A_ 1 _U_ 1 _N_ _S_ "S" _F_ _ALWAYS_ \ (u0 :: [Double]) -> let {(u1 :: Double) = _!_ D# [] [0.0000000000000000##]} in _APP_ _TYAPP_ _TYAPP_ foldl { Double } { Double } [ _CONSTM_ Num (+) (Double), u1, u0 ] _N_ }, [ Int ] 1 { _A_ 1 _U_ 1 _N_ _S_ "S" _F_ _ALWAYS_ \ (u0 :: [Int]) -> let {(u1 :: Int) = _!_ I# [] [0#]} in _APP_ _TYAPP_ _TYAPP_ foldl { Int } { Int } [ _CONSTM_ Num (+) (Int), u1, u0 ] _N_ }, [ Integer ] 1 { _A_ 1 _U_ 1 _N_ _S_ "S" _F_ _ALWAYS_ \ (u0 :: [Integer]) -> let {(u1 :: Integer) = _#_ int2Integer# [] [0#]} in _APP_ _TYAPP_ _TYAPP_ foldl { Integer } { Integer } [ _CONSTM_ Num (+) (Integer), u1, u0 ] _N_ }, [ (Complex Double) ] 1 { _A_ 1 _U_ 1 _N_ _S_ "S" _F_ _ALWAYS_ let {(u6 :: Complex Double -> Complex Double -> Complex Double) = \ (u0 :: Complex Double) (u1 :: Complex Double) -> case u0 of { _ALG_ (:+) (u2 :: Double) (u3 :: Double) -> case u1 of { _ALG_ (:+) (u4 :: Double) (u5 :: Double) -> _APP_ _WRKR_ _CONSTM_ Num (+) (Complex Double) [ u2, u3, u4, u5 ]; _NO_DEFLT_ }; _NO_DEFLT_ }} in let {(u8 :: Complex Double) = let {(u7 :: Int) = _!_ I# [] [0#]} in _APP_ _CONSTM_ Num fromInt (Complex Double) [ u7 ]} in \ (u9 :: [Complex Double]) -> _APP_ _TYAPP_ _TYAPP_ foldl { (Complex Double) } { (Complex Double) } [ u6, u8, u9 ] _N_ } #-}
sums :: Num a => [a] -> [a]
- {-# GHC_PRAGMA _A_ 1 _U_ 21 _N_ _N_ _N_ _N_ #-}
+ {-# GHC_PRAGMA _A_ 1 _U_ 21 _N_ _N_ _N_ _SPECIALISE_ [ Double ] 1 { _A_ 1 _U_ 1 _N_ _N_ _N_ _N_ }, [ Int ] 1 { _A_ 1 _U_ 1 _N_ _N_ _N_ _N_ }, [ Integer ] 1 { _A_ 1 _U_ 1 _N_ _N_ _F_ _IF_ARGS_ 0 1 X 4 \ (u0 :: [Integer]) -> _APP_ _TYAPP_ _TYAPP_ _ORIG_ PreludeList scanl { Integer } { Integer } [ _CONSTM_ Num (+) (Integer), _SPEC_ _ORIG_ PreludeCore __i0 [ (Integer) ], u0 ] _N_ }, [ (Complex Double) ] 1 { _A_ 1 _U_ 1 _N_ _N_ _N_ _N_ } #-}
tail :: [a] -> [a]
{-# GHC_PRAGMA _A_ 1 _U_ 1 _N_ _S_ "S" _F_ _IF_ARGS_ 1 1 C 5 _/\_ u0 -> \ (u1 :: [u0]) -> case u1 of { _ALG_ (:) (u2 :: u0) (u3 :: [u0]) -> u3; _NIL_ -> _APP_ _TYAPP_ error { [u0] } [ _NOREP_S_ "tail{PreludeList}: tail []\n" ]; _NO_DEFLT_ } _N_ #-}
take :: Integral a => a -> [b] -> [b]
- {-# GHC_PRAGMA _A_ 3 _U_ 121 _N_ _S_ "U(AAAAAAAAAAAS)LL" {_A_ 3 _U_ 121 _N_ _N_ _N_ _N_} _F_ _IF_ARGS_ 2 3 CXX 7 _/\_ u0 u1 -> \ (u2 :: {{Integral u0}}) (u3 :: u0) (u4 :: [u1]) -> let {(uh :: Int) = case u2 of { _ALG_ _TUP_12 (u5 :: {{Real u0}}) (u6 :: {{Ix u0}}) (u7 :: u0 -> u0 -> u0) (u8 :: u0 -> u0 -> u0) (u9 :: u0 -> u0 -> u0) (ua :: u0 -> u0 -> u0) (ub :: u0 -> u0 -> (u0, u0)) (uc :: u0 -> u0 -> (u0, u0)) (ud :: u0 -> Bool) (ue :: u0 -> Bool) (uf :: u0 -> Integer) (ug :: u0 -> Int) -> _APP_ ug [ u3 ]; _NO_DEFLT_ }} in _APP_ _TYAPP_ _SPEC_ _ORIG_ PreludeList take [ (Int), _N_ ] { u1 } [ uh, u4 ] _SPECIALISE_ [ Int, _N_ ] 1 { _A_ 2 _U_ 11 _N_ _S_ "U(P)L" {_A_ 2 _U_ 21 _N_ _N_ _N_ _N_} _N_ _N_ }, [ Integer, _N_ ] 1 { _A_ 2 _U_ 11 _N_ _S_ "U(PPP)L" {_A_ 4 _U_ 2221 _N_ _N_ _F_ _IF_ARGS_ 1 4 XXXX 4 _/\_ u0 -> \ (u1 :: Int#) (u2 :: Int#) (u3 :: ByteArray#) (u4 :: [u0]) -> case _#_ integer2Int# [] [u1, u2, u3] of { _PRIM_ (u5 :: Int#) -> _APP_ _TYAPP_ _WRKR_ _SPEC_ _ORIG_ PreludeList take [ (Int), _N_ ] { u0 } [ u5, u4 ] } _N_} _F_ _ALWAYS_ _/\_ u0 -> \ (u1 :: Integer) (u2 :: [u0]) -> case u1 of { _ALG_ J# (u3 :: Int#) (u4 :: Int#) (u5 :: ByteArray#) -> case _#_ integer2Int# [] [u3, u4, u5] of { _PRIM_ (u6 :: Int#) -> _APP_ _TYAPP_ _WRKR_ _SPEC_ _ORIG_ PreludeList take [ (Int), _N_ ] { u0 } [ u6, u2 ] }; _NO_DEFLT_ } _N_ } #-}
+ {-# GHC_PRAGMA _A_ 1 _U_ 122 _N_ _S_ "U(LU(U(ASSAAAAA)AAA)AAAALAAAAL)" {_A_ 5 _U_ 2121222 _N_ _N_ _N_ _N_} _N_ _SPECIALISE_ [ Int, _N_ ] 1 { _A_ 2 _U_ 11 _N_ _S_ "U(P)L" {_A_ 2 _U_ 21 _N_ _N_ _N_ _N_} _N_ _N_ }, [ Integer, _N_ ] 1 { _A_ 1 _U_ 12 _N_ _S_ "U(PPP)" {_A_ 3 _U_ 2222 _N_ _N_ _N_ _N_} _N_ _N_ } #-}
takeWhile :: (a -> Bool) -> [a] -> [a]
{-# GHC_PRAGMA _A_ 2 _U_ 21 _N_ _S_ "LS" _F_ _ALWAYS_ _/\_ u0 -> \ (u1 :: u0 -> Bool) (u2 :: [u0]) -> let {(u9 :: _forall_ a$z1 =>(u0 -> a$z1 -> a$z1) -> a$z1 -> a$z1) = _/\_ u3 -> \ (u4 :: u0 -> u3 -> u3) (u5 :: u3) -> let {(u8 :: u0 -> u3 -> u3) = \ (u6 :: u0) (u7 :: u3) -> case _APP_ u1 [ u6 ] of { _ALG_ True -> _APP_ u4 [ u6, u7 ]; False -> u5; _NO_DEFLT_ }} in _APP_ _TYAPP_ _TYAPP_ foldr { u0 } { u3 } [ u8, u5, u2 ]} in _APP_ _TYAPP_ _build { u0 } [ u9 ] _N_ #-}
transpose :: [[a]] -> [[a]]
-{-# GHC_PRAGMA INTERFACE VERSION 5 #-}
+{-# GHC_PRAGMA INTERFACE VERSION 6 #-}
interface Merge where
import PreludeIOError(IOError13)
import PreludeMonadicIO(Either)
-{-# GHC_PRAGMA INTERFACE VERSION 5 #-}
+{-# GHC_PRAGMA INTERFACE VERSION 6 #-}
interface Merge where
import PreludeIOError(IOError13)
import PreludeMonadicIO(Either)
-{-# GHC_PRAGMA INTERFACE VERSION 5 #-}
+{-# GHC_PRAGMA INTERFACE VERSION 6 #-}
interface Merge where
import PreludeIOError(IOError13)
import PreludeMonadicIO(Either)
-{-# GHC_PRAGMA INTERFACE VERSION 5 #-}
+{-# GHC_PRAGMA INTERFACE VERSION 6 #-}
interface Merge where
import PreludeIOError(IOError13)
import PreludeMonadicIO(Either)
-{-# GHC_PRAGMA INTERFACE VERSION 5 #-}
+{-# GHC_PRAGMA INTERFACE VERSION 6 #-}
interface Merge where
import PreludeIOError(IOError13)
import PreludeMonadicIO(Either)
-{-# GHC_PRAGMA INTERFACE VERSION 5 #-}
+{-# GHC_PRAGMA INTERFACE VERSION 6 #-}
interface PreludePS where
import PreludeArray(_ByteArray)
import PreludeBuiltin(Char(..), Int(..), List(..), Tuple0, Tuple2, _Addr(..), _RealWorld(..), _State(..))
{-# GHC_PRAGMA _A_ 2 _U_ 22 _N_ _S_ "PP" _N_ _N_ #-}
instance Eq _PackedString
{-# GHC_PRAGMA _M_ PreludePS {-dfun-} _A_ 0 _N_ _N_ _N_ _F_ _IF_ARGS_ 0 0 X 3 _!_ _TUP_2 [(_PackedString -> _PackedString -> Bool), (_PackedString -> _PackedString -> Bool)] [_CONSTM_ Eq (==) (_PackedString), _CONSTM_ Eq (/=) (_PackedString)] _N_
- (==) = _A_ 2 _U_ 22 _N_ _S_ "SS" _N_ _N_,
- (/=) = _A_ 2 _U_ 22 _N_ _S_ "SS" _N_ _N_ #-}
+ (==) = { _A_ 2 _U_ 22 _N_ _S_ "SS" _N_ _N_ },
+ (/=) = { _A_ 2 _U_ 22 _N_ _S_ "SS" _N_ _N_ } #-}
instance Ord _PackedString
{-# GHC_PRAGMA _M_ PreludePS {-dfun-} _A_ 0 _N_ _N_ _N_ _F_ _IF_ARGS_ 0 0 X 9 _!_ _TUP_8 [{{Eq _PackedString}}, (_PackedString -> _PackedString -> Bool), (_PackedString -> _PackedString -> Bool), (_PackedString -> _PackedString -> Bool), (_PackedString -> _PackedString -> Bool), (_PackedString -> _PackedString -> _PackedString), (_PackedString -> _PackedString -> _PackedString), (_PackedString -> _PackedString -> _CMP_TAG)] [_DFUN_ Eq (_PackedString), _CONSTM_ Ord (<) (_PackedString), _CONSTM_ Ord (<=) (_PackedString), _CONSTM_ Ord (>=) (_PackedString), _CONSTM_ Ord (>) (_PackedString), _CONSTM_ Ord max (_PackedString), _CONSTM_ Ord min (_PackedString), _CONSTM_ Ord _tagCmp (_PackedString)] _N_
- (<) = _A_ 2 _U_ 22 _N_ _S_ "SS" _N_ _N_,
- (<=) = _A_ 2 _U_ 22 _N_ _S_ "SS" _N_ _N_,
- (>=) = _A_ 2 _U_ 22 _N_ _S_ "SS" _N_ _N_,
- (>) = _A_ 2 _U_ 22 _N_ _S_ "SS" _N_ _N_,
- max = _A_ 2 _U_ 22 _N_ _N_ _N_ _N_,
- min = _A_ 2 _U_ 22 _N_ _N_ _N_ _N_,
- _tagCmp = _A_ 2 _U_ 22 _N_ _S_ "SS" _N_ _N_ #-}
+ (<) = { _A_ 2 _U_ 22 _N_ _S_ "SS" _N_ _N_ },
+ (<=) = { _A_ 2 _U_ 22 _N_ _S_ "SS" _N_ _N_ },
+ (>=) = { _A_ 2 _U_ 22 _N_ _S_ "SS" _N_ _N_ },
+ (>) = { _A_ 2 _U_ 22 _N_ _S_ "SS" _N_ _N_ },
+ max = { _A_ 2 _U_ 22 _N_ _S_ "SS" _N_ _N_ },
+ min = { _A_ 2 _U_ 22 _N_ _S_ "SS" _N_ _N_ },
+ _tagCmp = { _A_ 2 _U_ 22 _N_ _S_ "SS" _N_ _N_ } #-}
instance Text _PackedString
{-# GHC_PRAGMA _M_ PreludePS {-dfun-} _A_ 0 _N_ _N_ _N_ _F_ _IF_ARGS_ 0 0 X 5 _!_ _TUP_4 [(Int -> [Char] -> [(_PackedString, [Char])]), (Int -> _PackedString -> [Char] -> [Char]), ([Char] -> [([_PackedString], [Char])]), ([_PackedString] -> [Char] -> [Char])] [_CONSTM_ Text readsPrec (_PackedString), _CONSTM_ Text showsPrec (_PackedString), _CONSTM_ Text readList (_PackedString), _CONSTM_ Text showList (_PackedString)] _N_
- readsPrec = _A_ 2 _U_ 02 _N_ _S_ _!_ _F_ _IF_ARGS_ 0 2 XX 3 \ (u0 :: Int) (u1 :: [Char]) -> _APP_ _TYAPP_ error { ([Char] -> [(_PackedString, [Char])]) } [ _NOREP_S_ "readsPrec: _PackedString: ToDo", u1 ] _N_,
- showsPrec = _A_ 3 _U_ 012 _N_ _S_ "ALL" {_A_ 2 _U_ 12 _N_ _N_ _N_ _N_} _F_ _IF_ARGS_ 0 3 XXX 6 \ (u0 :: Int) (u1 :: _PackedString) (u2 :: [Char]) -> let {(u3 :: [Char]) = _APP_ _ORIG_ PreludePS _unpackPS [ u1 ]} in _APP_ _CONSTM_ Text showList (Char) [ u3, u2 ] _N_,
- readList = _A_ 0 _U_ 2 _N_ _N_ _N_ _N_,
- showList = _A_ 0 _U_ 12 _N_ _N_ _N_ _N_ #-}
+ readsPrec = { _A_ 2 _U_ 02 _N_ _S_ _!_ _N_ _N_ },
+ showsPrec = { _A_ 3 _U_ 012 _N_ _S_ "ALL" {_A_ 2 _U_ 12 _N_ _N_ _N_ _N_} _F_ _IF_ARGS_ 0 3 XXX 6 \ (u0 :: Int) (u1 :: _PackedString) (u2 :: [Char]) -> let {(u3 :: [Char]) = _APP_ _ORIG_ PreludePS _unpackPS [ u1 ]} in _APP_ _CONSTM_ Text showList (Char) [ u3, u2 ] _N_ },
+ readList = { _A_ 0 _U_ 2 _N_ _N_ _N_ _N_ },
+ showList = { _A_ 1 _U_ 12 _N_ _N_ _F_ _IF_ARGS_ 0 1 X 3 \ (u0 :: [_PackedString]) -> _APP_ _TYAPP_ _ORIG_ PreludeCore _showList { _PackedString } [ _WRKR_ _CONSTM_ Text showsPrec (_PackedString), u0 ] _N_ } #-}
lines, words, reverse, null, foldr1
)
import TyArray ( Array(..) )
+import TyComplex
import Text
\end{code}
a < b = case _tagCmpPS a b of { _LT -> True; _EQ -> False; _GT -> False }
a >= b = case _tagCmpPS a b of { _LT -> False; _EQ -> True; _GT -> True }
a > b = case _tagCmpPS 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
_tagCmp a b = _tagCmpPS a b
\end{code}
else _GT
instance Text _PackedString where
- readsPrec p = error "readsPrec: _PackedString: ToDo"
- showsPrec p ps r = showsPrec p (_unpackPS ps) r
+ readsPrec p = error "readsPrec: _PackedString: ToDo"
+ showsPrec p ps r = showsPrec p (_unpackPS ps) r
+ readList = _readList (readsPrec 0)
+ showList = _showList (showsPrec 0)
\end{code}
%************************************************************************
-{-# GHC_PRAGMA INTERFACE VERSION 5 #-}
+{-# GHC_PRAGMA INTERFACE VERSION 6 #-}
interface PreludePS where
import PreludeArray(_ByteArray)
import PreludeBuiltin(Char(..), Int(..), List(..), Tuple0, Tuple2, _Addr(..), _RealWorld(..), _State(..))
{-# GHC_PRAGMA _A_ 2 _U_ 22 _N_ _S_ "PP" _N_ _N_ #-}
instance Eq _PackedString
{-# GHC_PRAGMA _M_ PreludePS {-dfun-} _A_ 0 _N_ _N_ _N_ _F_ _IF_ARGS_ 0 0 X 3 _!_ _TUP_2 [(_PackedString -> _PackedString -> Bool), (_PackedString -> _PackedString -> Bool)] [_CONSTM_ Eq (==) (_PackedString), _CONSTM_ Eq (/=) (_PackedString)] _N_
- (==) = _A_ 2 _U_ 22 _N_ _S_ "SS" _N_ _N_,
- (/=) = _A_ 2 _U_ 22 _N_ _S_ "SS" _N_ _N_ #-}
+ (==) = { _A_ 2 _U_ 22 _N_ _S_ "SS" _N_ _N_ },
+ (/=) = { _A_ 2 _U_ 22 _N_ _S_ "SS" _N_ _N_ } #-}
instance Ord _PackedString
{-# GHC_PRAGMA _M_ PreludePS {-dfun-} _A_ 0 _N_ _N_ _N_ _F_ _IF_ARGS_ 0 0 X 9 _!_ _TUP_8 [{{Eq _PackedString}}, (_PackedString -> _PackedString -> Bool), (_PackedString -> _PackedString -> Bool), (_PackedString -> _PackedString -> Bool), (_PackedString -> _PackedString -> Bool), (_PackedString -> _PackedString -> _PackedString), (_PackedString -> _PackedString -> _PackedString), (_PackedString -> _PackedString -> _CMP_TAG)] [_DFUN_ Eq (_PackedString), _CONSTM_ Ord (<) (_PackedString), _CONSTM_ Ord (<=) (_PackedString), _CONSTM_ Ord (>=) (_PackedString), _CONSTM_ Ord (>) (_PackedString), _CONSTM_ Ord max (_PackedString), _CONSTM_ Ord min (_PackedString), _CONSTM_ Ord _tagCmp (_PackedString)] _N_
- (<) = _A_ 2 _U_ 22 _N_ _S_ "SS" _N_ _N_,
- (<=) = _A_ 2 _U_ 22 _N_ _S_ "SS" _N_ _N_,
- (>=) = _A_ 2 _U_ 22 _N_ _S_ "SS" _N_ _N_,
- (>) = _A_ 2 _U_ 22 _N_ _S_ "SS" _N_ _N_,
- max = _A_ 2 _U_ 22 _N_ _N_ _N_ _N_,
- min = _A_ 2 _U_ 22 _N_ _N_ _N_ _N_,
- _tagCmp = _A_ 2 _U_ 22 _N_ _S_ "SS" _N_ _N_ #-}
+ (<) = { _A_ 2 _U_ 22 _N_ _S_ "SS" _N_ _N_ },
+ (<=) = { _A_ 2 _U_ 22 _N_ _S_ "SS" _N_ _N_ },
+ (>=) = { _A_ 2 _U_ 22 _N_ _S_ "SS" _N_ _N_ },
+ (>) = { _A_ 2 _U_ 22 _N_ _S_ "SS" _N_ _N_ },
+ max = { _A_ 2 _U_ 22 _N_ _S_ "SS" _N_ _N_ },
+ min = { _A_ 2 _U_ 22 _N_ _S_ "SS" _N_ _N_ },
+ _tagCmp = { _A_ 2 _U_ 22 _N_ _S_ "SS" _N_ _N_ } #-}
instance Text _PackedString
{-# GHC_PRAGMA _M_ PreludePS {-dfun-} _A_ 0 _N_ _N_ _N_ _F_ _IF_ARGS_ 0 0 X 5 _!_ _TUP_4 [(Int -> [Char] -> [(_PackedString, [Char])]), (Int -> _PackedString -> [Char] -> [Char]), ([Char] -> [([_PackedString], [Char])]), ([_PackedString] -> [Char] -> [Char])] [_CONSTM_ Text readsPrec (_PackedString), _CONSTM_ Text showsPrec (_PackedString), _CONSTM_ Text readList (_PackedString), _CONSTM_ Text showList (_PackedString)] _N_
- readsPrec = _A_ 2 _U_ 02 _N_ _S_ _!_ _F_ _IF_ARGS_ 0 2 XX 3 \ (u0 :: Int) (u1 :: [Char]) -> _APP_ _TYAPP_ error { ([Char] -> [(_PackedString, [Char])]) } [ _NOREP_S_ "readsPrec: _PackedString: ToDo", u1 ] _N_,
- showsPrec = _A_ 3 _U_ 012 _N_ _S_ "ALL" {_A_ 2 _U_ 12 _N_ _N_ _N_ _N_} _F_ _IF_ARGS_ 0 3 XXX 6 \ (u0 :: Int) (u1 :: _PackedString) (u2 :: [Char]) -> let {(u3 :: [Char]) = _APP_ _ORIG_ PreludePS _unpackPS [ u1 ]} in _APP_ _CONSTM_ Text showList (Char) [ u3, u2 ] _N_,
- readList = _A_ 0 _U_ 2 _N_ _N_ _N_ _N_,
- showList = _A_ 0 _U_ 12 _N_ _N_ _N_ _N_ #-}
+ readsPrec = { _A_ 2 _U_ 02 _N_ _S_ _!_ _N_ _N_ },
+ showsPrec = { _A_ 3 _U_ 012 _N_ _S_ "ALL" {_A_ 2 _U_ 12 _N_ _N_ _N_ _N_} _F_ _IF_ARGS_ 0 3 XXX 6 \ (u0 :: Int) (u1 :: _PackedString) (u2 :: [Char]) -> let {(u3 :: [Char]) = _APP_ _ORIG_ PreludePS _unpackPS [ u1 ]} in _APP_ _CONSTM_ Text showList (Char) [ u3, u2 ] _N_ },
+ readList = { _A_ 0 _U_ 2 _N_ _N_ _N_ _N_ },
+ showList = { _A_ 1 _U_ 12 _N_ _N_ _F_ _IF_ARGS_ 0 1 X 3 \ (u0 :: [_PackedString]) -> _APP_ _TYAPP_ _ORIG_ PreludeCore _showList { _PackedString } [ _WRKR_ _CONSTM_ Text showsPrec (_PackedString), u0 ] _N_ } #-}
-{-# GHC_PRAGMA INTERFACE VERSION 5 #-}
+{-# GHC_PRAGMA INTERFACE VERSION 6 #-}
interface PreludePS where
import PreludeArray(_ByteArray)
import PreludeBuiltin(Char(..), Int(..), List(..), Tuple0, Tuple2, _Addr(..), _RealWorld(..), _State(..))
{-# GHC_PRAGMA _A_ 2 _U_ 22 _N_ _S_ "PP" _N_ _N_ #-}
instance Eq _PackedString
{-# GHC_PRAGMA _M_ PreludePS {-dfun-} _A_ 0 _N_ _N_ _N_ _F_ _IF_ARGS_ 0 0 X 3 _!_ _TUP_2 [(_PackedString -> _PackedString -> Bool), (_PackedString -> _PackedString -> Bool)] [_CONSTM_ Eq (==) (_PackedString), _CONSTM_ Eq (/=) (_PackedString)] _N_
- (==) = _A_ 2 _U_ 22 _N_ _S_ "SS" _N_ _N_,
- (/=) = _A_ 2 _U_ 22 _N_ _S_ "SS" _N_ _N_ #-}
+ (==) = { _A_ 2 _U_ 22 _N_ _S_ "SS" _N_ _N_ },
+ (/=) = { _A_ 2 _U_ 22 _N_ _S_ "SS" _N_ _N_ } #-}
instance Ord _PackedString
{-# GHC_PRAGMA _M_ PreludePS {-dfun-} _A_ 0 _N_ _N_ _N_ _F_ _IF_ARGS_ 0 0 X 9 _!_ _TUP_8 [{{Eq _PackedString}}, (_PackedString -> _PackedString -> Bool), (_PackedString -> _PackedString -> Bool), (_PackedString -> _PackedString -> Bool), (_PackedString -> _PackedString -> Bool), (_PackedString -> _PackedString -> _PackedString), (_PackedString -> _PackedString -> _PackedString), (_PackedString -> _PackedString -> _CMP_TAG)] [_DFUN_ Eq (_PackedString), _CONSTM_ Ord (<) (_PackedString), _CONSTM_ Ord (<=) (_PackedString), _CONSTM_ Ord (>=) (_PackedString), _CONSTM_ Ord (>) (_PackedString), _CONSTM_ Ord max (_PackedString), _CONSTM_ Ord min (_PackedString), _CONSTM_ Ord _tagCmp (_PackedString)] _N_
- (<) = _A_ 2 _U_ 22 _N_ _S_ "SS" _N_ _N_,
- (<=) = _A_ 2 _U_ 22 _N_ _S_ "SS" _N_ _N_,
- (>=) = _A_ 2 _U_ 22 _N_ _S_ "SS" _N_ _N_,
- (>) = _A_ 2 _U_ 22 _N_ _S_ "SS" _N_ _N_,
- max = _A_ 2 _U_ 22 _N_ _N_ _N_ _N_,
- min = _A_ 2 _U_ 22 _N_ _N_ _N_ _N_,
- _tagCmp = _A_ 2 _U_ 22 _N_ _S_ "SS" _N_ _N_ #-}
+ (<) = { _A_ 2 _U_ 22 _N_ _S_ "SS" _N_ _N_ },
+ (<=) = { _A_ 2 _U_ 22 _N_ _S_ "SS" _N_ _N_ },
+ (>=) = { _A_ 2 _U_ 22 _N_ _S_ "SS" _N_ _N_ },
+ (>) = { _A_ 2 _U_ 22 _N_ _S_ "SS" _N_ _N_ },
+ max = { _A_ 2 _U_ 22 _N_ _S_ "SS" _N_ _N_ },
+ min = { _A_ 2 _U_ 22 _N_ _S_ "SS" _N_ _N_ },
+ _tagCmp = { _A_ 2 _U_ 22 _N_ _S_ "SS" _N_ _N_ } #-}
instance Text _PackedString
{-# GHC_PRAGMA _M_ PreludePS {-dfun-} _A_ 0 _N_ _N_ _N_ _F_ _IF_ARGS_ 0 0 X 5 _!_ _TUP_4 [(Int -> [Char] -> [(_PackedString, [Char])]), (Int -> _PackedString -> [Char] -> [Char]), ([Char] -> [([_PackedString], [Char])]), ([_PackedString] -> [Char] -> [Char])] [_CONSTM_ Text readsPrec (_PackedString), _CONSTM_ Text showsPrec (_PackedString), _CONSTM_ Text readList (_PackedString), _CONSTM_ Text showList (_PackedString)] _N_
- readsPrec = _A_ 2 _U_ 02 _N_ _S_ _!_ _F_ _IF_ARGS_ 0 2 XX 3 \ (u0 :: Int) (u1 :: [Char]) -> _APP_ _TYAPP_ error { ([Char] -> [(_PackedString, [Char])]) } [ _NOREP_S_ "readsPrec: _PackedString: ToDo", u1 ] _N_,
- showsPrec = _A_ 3 _U_ 012 _N_ _S_ "ALL" {_A_ 2 _U_ 12 _N_ _N_ _N_ _N_} _F_ _IF_ARGS_ 0 3 XXX 6 \ (u0 :: Int) (u1 :: _PackedString) (u2 :: [Char]) -> let {(u3 :: [Char]) = _APP_ _ORIG_ PreludePS _unpackPS [ u1 ]} in _APP_ _CONSTM_ Text showList (Char) [ u3, u2 ] _N_,
- readList = _A_ 0 _U_ 2 _N_ _N_ _N_ _N_,
- showList = _A_ 0 _U_ 12 _N_ _N_ _N_ _N_ #-}
+ readsPrec = { _A_ 2 _U_ 02 _N_ _S_ _!_ _N_ _N_ },
+ showsPrec = { _A_ 3 _U_ 012 _N_ _S_ "ALL" {_A_ 2 _U_ 12 _N_ _N_ _N_ _N_} _F_ _IF_ARGS_ 0 3 XXX 6 \ (u0 :: Int) (u1 :: _PackedString) (u2 :: [Char]) -> let {(u3 :: [Char]) = _APP_ _ORIG_ PreludePS _unpackPS [ u1 ]} in _APP_ _CONSTM_ Text showList (Char) [ u3, u2 ] _N_ },
+ readList = { _A_ 0 _U_ 2 _N_ _N_ _N_ _N_ },
+ showList = { _A_ 1 _U_ 12 _N_ _N_ _F_ _IF_ARGS_ 0 1 X 3 \ (u0 :: [_PackedString]) -> _APP_ _TYAPP_ _ORIG_ PreludeCore _showList { _PackedString } [ _WRKR_ _CONSTM_ Text showsPrec (_PackedString), u0 ] _N_ } #-}
-{-# GHC_PRAGMA INTERFACE VERSION 5 #-}
+{-# GHC_PRAGMA INTERFACE VERSION 6 #-}
interface PreludePS where
import PreludeArray(_ByteArray)
import PreludeBuiltin(Char(..), Int(..), List(..), Tuple0, Tuple2, _Addr(..), _RealWorld(..), _State(..))
{-# GHC_PRAGMA _A_ 2 _U_ 22 _N_ _S_ "PP" _N_ _N_ #-}
instance Eq _PackedString
{-# GHC_PRAGMA _M_ PreludePS {-dfun-} _A_ 0 _N_ _N_ _N_ _F_ _IF_ARGS_ 0 0 X 3 _!_ _TUP_2 [(_PackedString -> _PackedString -> Bool), (_PackedString -> _PackedString -> Bool)] [_CONSTM_ Eq (==) (_PackedString), _CONSTM_ Eq (/=) (_PackedString)] _N_
- (==) = _A_ 2 _U_ 22 _N_ _S_ "SS" _N_ _N_,
- (/=) = _A_ 2 _U_ 22 _N_ _S_ "SS" _N_ _N_ #-}
+ (==) = { _A_ 2 _U_ 22 _N_ _S_ "SS" _N_ _N_ },
+ (/=) = { _A_ 2 _U_ 22 _N_ _S_ "SS" _N_ _N_ } #-}
instance Ord _PackedString
{-# GHC_PRAGMA _M_ PreludePS {-dfun-} _A_ 0 _N_ _N_ _N_ _F_ _IF_ARGS_ 0 0 X 9 _!_ _TUP_8 [{{Eq _PackedString}}, (_PackedString -> _PackedString -> Bool), (_PackedString -> _PackedString -> Bool), (_PackedString -> _PackedString -> Bool), (_PackedString -> _PackedString -> Bool), (_PackedString -> _PackedString -> _PackedString), (_PackedString -> _PackedString -> _PackedString), (_PackedString -> _PackedString -> _CMP_TAG)] [_DFUN_ Eq (_PackedString), _CONSTM_ Ord (<) (_PackedString), _CONSTM_ Ord (<=) (_PackedString), _CONSTM_ Ord (>=) (_PackedString), _CONSTM_ Ord (>) (_PackedString), _CONSTM_ Ord max (_PackedString), _CONSTM_ Ord min (_PackedString), _CONSTM_ Ord _tagCmp (_PackedString)] _N_
- (<) = _A_ 2 _U_ 22 _N_ _S_ "SS" _N_ _N_,
- (<=) = _A_ 2 _U_ 22 _N_ _S_ "SS" _N_ _N_,
- (>=) = _A_ 2 _U_ 22 _N_ _S_ "SS" _N_ _N_,
- (>) = _A_ 2 _U_ 22 _N_ _S_ "SS" _N_ _N_,
- max = _A_ 2 _U_ 22 _N_ _N_ _N_ _N_,
- min = _A_ 2 _U_ 22 _N_ _N_ _N_ _N_,
- _tagCmp = _A_ 2 _U_ 22 _N_ _S_ "SS" _N_ _N_ #-}
+ (<) = { _A_ 2 _U_ 22 _N_ _S_ "SS" _N_ _N_ },
+ (<=) = { _A_ 2 _U_ 22 _N_ _S_ "SS" _N_ _N_ },
+ (>=) = { _A_ 2 _U_ 22 _N_ _S_ "SS" _N_ _N_ },
+ (>) = { _A_ 2 _U_ 22 _N_ _S_ "SS" _N_ _N_ },
+ max = { _A_ 2 _U_ 22 _N_ _S_ "SS" _N_ _N_ },
+ min = { _A_ 2 _U_ 22 _N_ _S_ "SS" _N_ _N_ },
+ _tagCmp = { _A_ 2 _U_ 22 _N_ _S_ "SS" _N_ _N_ } #-}
instance Text _PackedString
{-# GHC_PRAGMA _M_ PreludePS {-dfun-} _A_ 0 _N_ _N_ _N_ _F_ _IF_ARGS_ 0 0 X 5 _!_ _TUP_4 [(Int -> [Char] -> [(_PackedString, [Char])]), (Int -> _PackedString -> [Char] -> [Char]), ([Char] -> [([_PackedString], [Char])]), ([_PackedString] -> [Char] -> [Char])] [_CONSTM_ Text readsPrec (_PackedString), _CONSTM_ Text showsPrec (_PackedString), _CONSTM_ Text readList (_PackedString), _CONSTM_ Text showList (_PackedString)] _N_
- readsPrec = _A_ 2 _U_ 02 _N_ _S_ _!_ _F_ _IF_ARGS_ 0 2 XX 3 \ (u0 :: Int) (u1 :: [Char]) -> _APP_ _TYAPP_ error { ([Char] -> [(_PackedString, [Char])]) } [ _NOREP_S_ "readsPrec: _PackedString: ToDo", u1 ] _N_,
- showsPrec = _A_ 3 _U_ 012 _N_ _S_ "ALL" {_A_ 2 _U_ 12 _N_ _N_ _N_ _N_} _F_ _IF_ARGS_ 0 3 XXX 6 \ (u0 :: Int) (u1 :: _PackedString) (u2 :: [Char]) -> let {(u3 :: [Char]) = _APP_ _ORIG_ PreludePS _unpackPS [ u1 ]} in _APP_ _CONSTM_ Text showList (Char) [ u3, u2 ] _N_,
- readList = _A_ 0 _U_ 2 _N_ _N_ _N_ _N_,
- showList = _A_ 0 _U_ 12 _N_ _N_ _N_ _N_ #-}
+ readsPrec = { _A_ 2 _U_ 02 _N_ _S_ _!_ _N_ _N_ },
+ showsPrec = { _A_ 3 _U_ 012 _N_ _S_ "ALL" {_A_ 2 _U_ 12 _N_ _N_ _N_ _N_} _F_ _IF_ARGS_ 0 3 XXX 6 \ (u0 :: Int) (u1 :: _PackedString) (u2 :: [Char]) -> let {(u3 :: [Char]) = _APP_ _ORIG_ PreludePS _unpackPS [ u1 ]} in _APP_ _CONSTM_ Text showList (Char) [ u3, u2 ] _N_ },
+ readList = { _A_ 0 _U_ 2 _N_ _N_ _N_ _N_ },
+ showList = { _A_ 1 _U_ 12 _N_ _N_ _F_ _IF_ARGS_ 0 1 X 3 \ (u0 :: [_PackedString]) -> _APP_ _TYAPP_ _ORIG_ PreludeCore _showList { _PackedString } [ _WRKR_ _CONSTM_ Text showsPrec (_PackedString), u0 ] _N_ } #-}
-{-# GHC_PRAGMA INTERFACE VERSION 5 #-}
+{-# GHC_PRAGMA INTERFACE VERSION 6 #-}
interface PreludePS where
import PreludeArray(_ByteArray)
import PreludeBuiltin(Char(..), Int(..), List(..), Tuple0, Tuple2, _Addr(..), _RealWorld(..), _State(..))
{-# GHC_PRAGMA _A_ 2 _U_ 22 _N_ _S_ "PP" _N_ _N_ #-}
instance Eq _PackedString
{-# GHC_PRAGMA _M_ PreludePS {-dfun-} _A_ 0 _N_ _N_ _N_ _F_ _IF_ARGS_ 0 0 X 3 _!_ _TUP_2 [(_PackedString -> _PackedString -> Bool), (_PackedString -> _PackedString -> Bool)] [_CONSTM_ Eq (==) (_PackedString), _CONSTM_ Eq (/=) (_PackedString)] _N_
- (==) = _A_ 2 _U_ 22 _N_ _S_ "SS" _N_ _N_,
- (/=) = _A_ 2 _U_ 22 _N_ _S_ "SS" _N_ _N_ #-}
+ (==) = { _A_ 2 _U_ 22 _N_ _S_ "SS" _N_ _N_ },
+ (/=) = { _A_ 2 _U_ 22 _N_ _S_ "SS" _N_ _N_ } #-}
instance Ord _PackedString
{-# GHC_PRAGMA _M_ PreludePS {-dfun-} _A_ 0 _N_ _N_ _N_ _F_ _IF_ARGS_ 0 0 X 9 _!_ _TUP_8 [{{Eq _PackedString}}, (_PackedString -> _PackedString -> Bool), (_PackedString -> _PackedString -> Bool), (_PackedString -> _PackedString -> Bool), (_PackedString -> _PackedString -> Bool), (_PackedString -> _PackedString -> _PackedString), (_PackedString -> _PackedString -> _PackedString), (_PackedString -> _PackedString -> _CMP_TAG)] [_DFUN_ Eq (_PackedString), _CONSTM_ Ord (<) (_PackedString), _CONSTM_ Ord (<=) (_PackedString), _CONSTM_ Ord (>=) (_PackedString), _CONSTM_ Ord (>) (_PackedString), _CONSTM_ Ord max (_PackedString), _CONSTM_ Ord min (_PackedString), _CONSTM_ Ord _tagCmp (_PackedString)] _N_
- (<) = _A_ 2 _U_ 22 _N_ _S_ "SS" _N_ _N_,
- (<=) = _A_ 2 _U_ 22 _N_ _S_ "SS" _N_ _N_,
- (>=) = _A_ 2 _U_ 22 _N_ _S_ "SS" _N_ _N_,
- (>) = _A_ 2 _U_ 22 _N_ _S_ "SS" _N_ _N_,
- max = _A_ 2 _U_ 22 _N_ _N_ _N_ _N_,
- min = _A_ 2 _U_ 22 _N_ _N_ _N_ _N_,
- _tagCmp = _A_ 2 _U_ 22 _N_ _S_ "SS" _N_ _N_ #-}
+ (<) = { _A_ 2 _U_ 22 _N_ _S_ "SS" _N_ _N_ },
+ (<=) = { _A_ 2 _U_ 22 _N_ _S_ "SS" _N_ _N_ },
+ (>=) = { _A_ 2 _U_ 22 _N_ _S_ "SS" _N_ _N_ },
+ (>) = { _A_ 2 _U_ 22 _N_ _S_ "SS" _N_ _N_ },
+ max = { _A_ 2 _U_ 22 _N_ _S_ "SS" _N_ _N_ },
+ min = { _A_ 2 _U_ 22 _N_ _S_ "SS" _N_ _N_ },
+ _tagCmp = { _A_ 2 _U_ 22 _N_ _S_ "SS" _N_ _N_ } #-}
instance Text _PackedString
{-# GHC_PRAGMA _M_ PreludePS {-dfun-} _A_ 0 _N_ _N_ _N_ _F_ _IF_ARGS_ 0 0 X 5 _!_ _TUP_4 [(Int -> [Char] -> [(_PackedString, [Char])]), (Int -> _PackedString -> [Char] -> [Char]), ([Char] -> [([_PackedString], [Char])]), ([_PackedString] -> [Char] -> [Char])] [_CONSTM_ Text readsPrec (_PackedString), _CONSTM_ Text showsPrec (_PackedString), _CONSTM_ Text readList (_PackedString), _CONSTM_ Text showList (_PackedString)] _N_
- readsPrec = _A_ 2 _U_ 02 _N_ _S_ _!_ _F_ _IF_ARGS_ 0 2 XX 3 \ (u0 :: Int) (u1 :: [Char]) -> _APP_ _TYAPP_ error { ([Char] -> [(_PackedString, [Char])]) } [ _NOREP_S_ "readsPrec: _PackedString: ToDo", u1 ] _N_,
- showsPrec = _A_ 3 _U_ 012 _N_ _S_ "ALL" {_A_ 2 _U_ 12 _N_ _N_ _N_ _N_} _F_ _IF_ARGS_ 0 3 XXX 6 \ (u0 :: Int) (u1 :: _PackedString) (u2 :: [Char]) -> let {(u3 :: [Char]) = _APP_ _ORIG_ PreludePS _unpackPS [ u1 ]} in _APP_ _CONSTM_ Text showList (Char) [ u3, u2 ] _N_,
- readList = _A_ 0 _U_ 2 _N_ _N_ _N_ _N_,
- showList = _A_ 0 _U_ 12 _N_ _N_ _N_ _N_ #-}
+ readsPrec = { _A_ 2 _U_ 02 _N_ _S_ _!_ _N_ _N_ },
+ showsPrec = { _A_ 3 _U_ 012 _N_ _S_ "ALL" {_A_ 2 _U_ 12 _N_ _N_ _N_ _N_} _F_ _IF_ARGS_ 0 3 XXX 6 \ (u0 :: Int) (u1 :: _PackedString) (u2 :: [Char]) -> let {(u3 :: [Char]) = _APP_ _ORIG_ PreludePS _unpackPS [ u1 ]} in _APP_ _CONSTM_ Text showList (Char) [ u3, u2 ] _N_ },
+ readList = { _A_ 0 _U_ 2 _N_ _N_ _N_ _N_ },
+ showList = { _A_ 1 _U_ 12 _N_ _N_ _F_ _IF_ARGS_ 0 1 X 3 \ (u0 :: [_PackedString]) -> _APP_ _TYAPP_ _ORIG_ PreludeCore _showList { _PackedString } [ _WRKR_ _CONSTM_ Text showsPrec (_PackedString), u0 ] _N_ } #-}
-{-# GHC_PRAGMA INTERFACE VERSION 5 #-}
+{-# GHC_PRAGMA INTERFACE VERSION 6 #-}
interface Prelude where
import PreludeBuiltin(Bin, Char(..), Int(..), Tuple2)
import PreludeCore(Bool(..), Fractional(..), Integral(..), Num(..), RealFloat(..), RealFrac(..))
(.) :: (a -> c) -> (b -> a) -> b -> c
{-# GHC_PRAGMA _A_ 3 _U_ 112 _N_ _S_ "SLL" _F_ _ALWAYS_ _/\_ u0 u1 u2 -> \ (u3 :: u0 -> u2) (u4 :: u1 -> u0) (u5 :: u1) -> let {(u6 :: u0) = _APP_ u4 [ u5 ]} in _APP_ u3 [ u6 ] _N_ #-}
(^) :: (Num b, Integral a) => b -> a -> b
- {-# GHC_PRAGMA _A_ 2 _U_ 2122 _N_ _S_ "LU(U(LU(U(U(SA)AALAAAA)AAAA)A)AAALAAAALAA)" {_A_ 5 _U_ 2212222 _N_ _N_ _N_ _N_} _N_ _SPECIALISE_ [ Int, Double ] 2 { _A_ 2 _U_ 21 _N_ _S_ "LU(P)" {_A_ 2 _U_ 22 _N_ _N_ _N_ _N_} _N_ _N_ }, [ Int, Int ] 2 { _A_ 2 _U_ 21 _N_ _S_ "LU(P)" {_A_ 2 _U_ 22 _N_ _N_ _N_ _N_} _N_ _N_ }, [ Int, Integer ] 2 { _A_ 2 _U_ 21 _N_ _S_ "LU(P)" {_A_ 2 _U_ 22 _N_ _N_ _N_ _N_} _N_ _N_ }, [ Int, (Ratio Integer) ] 2 { _A_ 2 _U_ 21 _N_ _S_ "LU(P)" {_A_ 2 _U_ 22 _N_ _N_ _N_ _N_} _N_ _N_ }, [ Int, (Complex Double) ] 2 { _A_ 2 _U_ 21 _N_ _S_ "LU(P)" {_A_ 2 _U_ 22 _N_ _N_ _N_ _N_} _N_ _N_ } #-}
+ {-# GHC_PRAGMA _A_ 2 _U_ 2122 _N_ _S_ "LU(U(LU(U(U(SL)LLLLLLL)LLLL)L)LLLLLLLLLLL)" _N_ _SPECIALISE_ [ Int, Double ] 2 { _A_ 2 _U_ 21 _N_ _S_ "LU(P)" {_A_ 2 _U_ 22 _N_ _N_ _N_ _N_} _N_ _N_ }, [ Int, Int ] 2 { _A_ 2 _U_ 21 _N_ _S_ "LU(P)" {_A_ 2 _U_ 22 _N_ _N_ _N_ _N_} _N_ _N_ }, [ Int, Integer ] 2 { _A_ 2 _U_ 21 _N_ _S_ "LU(P)" {_A_ 2 _U_ 22 _N_ _N_ _N_ _N_} _N_ _N_ }, [ Int, (Ratio Integer) ] 2 { _A_ 2 _U_ 21 _N_ _S_ "LU(P)" {_A_ 2 _U_ 22 _N_ _N_ _N_ _N_} _N_ _N_ }, [ Int, (Complex Double) ] 2 { _A_ 2 _U_ 21 _N_ _S_ "LU(P)" {_A_ 2 _U_ 22 _N_ _N_ _N_ _N_} _N_ _N_ }, [ Integer, Integer ] 2 { _A_ 2 _U_ 21 _N_ _S_ "LU(PPP)" {_A_ 4 _U_ 2222 _N_ _N_ _N_ _N_} _N_ _N_ } #-}
(^^) :: (Fractional b, Integral a) => b -> a -> b
- {-# GHC_PRAGMA _A_ 2 _U_ 2122 _N_ _S_ "LU(LU(U(AAASAAAA)AAA)AALAAAALAA)" {_A_ 5 _U_ 2212222 _N_ _N_ _N_ _N_} _N_ _SPECIALISE_ [ Int, Double ] 2 { _A_ 2 _U_ 21 _N_ _S_ "LU(P)" {_A_ 2 _U_ 22 _N_ _N_ _N_ _N_} _N_ _N_ }, [ Int, (Ratio Integer) ] 2 { _A_ 2 _U_ 21 _N_ _S_ "LU(P)" {_A_ 2 _U_ 22 _N_ _N_ _N_ _N_} _N_ _N_ } #-}
+ {-# GHC_PRAGMA _A_ 2 _U_ 2222 _N_ _S_ "LU(LU(U(LLLSLLLL)LLL)LLLLLLLLLL)" _N_ _SPECIALISE_ [ Int, Double ] 2 { _A_ 2 _U_ 21 _N_ _S_ "LU(P)" {_A_ 2 _U_ 22 _N_ _N_ _N_ _N_} _N_ _N_ }, [ Int, (Ratio Integer) ] 2 { _A_ 2 _U_ 21 _N_ _S_ "LU(P)" {_A_ 2 _U_ 22 _N_ _N_ _N_ _N_} _N_ _N_ }, [ Int, (Complex Double) ] 2 { _A_ 2 _U_ 21 _N_ _S_ "LU(P)" {_A_ 2 _U_ 22 _N_ _N_ _N_ _N_} _N_ _N_ } #-}
appendBin :: Bin -> Bin -> Bin
- {-# GHC_PRAGMA _A_ 2 _U_ 22 _N_ _S_ _!_ _F_ _IF_ARGS_ 0 2 XX 4 \ (u0 :: Bin) (u1 :: Bin) -> _APP_ _TYAPP_ error { (Bin -> Bin -> Bin) } [ _NOREP_S_ "appendBin{Prelude}\n", u0, u1 ] _N_ #-}
+ {-# GHC_PRAGMA _A_ 2 _U_ 22 _N_ _S_ _!_ _N_ _N_ #-}
asTypeOf :: a -> a -> a
{-# GHC_PRAGMA _A_ 2 _U_ 10 _N_ _N_ _F_ _IF_ARGS_ 1 0 X 1 _/\_ u0 -> _TYAPP_ _TYAPP_ _ORIG_ Prelude const { u0 } { u0 } _N_ #-}
atan2 :: RealFloat a => a -> a -> a
{-# GHC_PRAGMA _A_ 2 _U_ 10 _N_ _S_ "SA" {_A_ 1 _U_ 1 _N_ _N_ _F_ _IF_ARGS_ 2 1 X 1 _/\_ u0 u1 -> \ (u2 :: u1) -> u2 _N_} _F_ _IF_ARGS_ 2 2 XX 1 _/\_ u0 u1 -> \ (u2 :: u1) (u3 :: u0) -> u2 _N_ #-}
flip :: (b -> a -> c) -> a -> b -> c
{-# GHC_PRAGMA _A_ 3 _U_ 122 _N_ _S_ "SLL" _F_ _IF_ARGS_ 3 3 XXX 3 _/\_ u0 u1 u2 -> \ (u3 :: u1 -> u0 -> u2) (u4 :: u0) (u5 :: u1) -> _APP_ u3 [ u5, u4 ] _N_ #-}
+fromChar# :: Char# -> Char
+ {-# GHC_PRAGMA _A_ 1 _U_ 2 _N_ _S_ "P" _F_ _IF_ARGS_ 0 1 X 2 \ (u0 :: Char#) -> _!_ C# [] [u0] _N_ #-}
+fromInt# :: Int# -> Int
+ {-# GHC_PRAGMA _A_ 1 _U_ 2 _N_ _S_ "P" _F_ _IF_ARGS_ 0 1 X 2 \ (u0 :: Int#) -> _!_ I# [] [u0] _N_ #-}
fromIntegral :: (Integral a, Num b) => a -> b
- {-# GHC_PRAGMA _A_ 3 _U_ 112 _N_ _S_ "LU(AAAAAAAASA)L" {_A_ 3 _U_ 112 _N_ _N_ _F_ _IF_ARGS_ 2 3 CXX 6 _/\_ u0 u1 -> \ (u2 :: {{Integral u0}}) (u3 :: Integer -> u1) (u4 :: u0) -> let {(uh :: Integer) = case u2 of { _ALG_ _TUP_12 (u5 :: {{Real u0}}) (u6 :: {{Ix u0}}) (u7 :: u0 -> u0 -> u0) (u8 :: u0 -> u0 -> u0) (u9 :: u0 -> u0 -> u0) (ua :: u0 -> u0 -> u0) (ub :: u0 -> u0 -> (u0, u0)) (uc :: u0 -> u0 -> (u0, u0)) (ud :: u0 -> Bool) (ue :: u0 -> Bool) (uf :: u0 -> Integer) (ug :: u0 -> Int) -> _APP_ uf [ u4 ]; _NO_DEFLT_ }} in _APP_ u3 [ uh ] _N_} _F_ _IF_ARGS_ 2 3 CCX 7 _/\_ u0 u1 -> \ (u2 :: {{Integral u0}}) (u3 :: {{Num u1}}) (u4 :: u0) -> let {(uh :: Integer) = case u2 of { _ALG_ _TUP_12 (u5 :: {{Real u0}}) (u6 :: {{Ix u0}}) (u7 :: u0 -> u0 -> u0) (u8 :: u0 -> u0 -> u0) (u9 :: u0 -> u0 -> u0) (ua :: u0 -> u0 -> u0) (ub :: u0 -> u0 -> (u0, u0)) (uc :: u0 -> u0 -> (u0, u0)) (ud :: u0 -> Bool) (ue :: u0 -> Bool) (uf :: u0 -> Integer) (ug :: u0 -> Int) -> _APP_ uf [ u4 ]; _NO_DEFLT_ }} in case u3 of { _ALG_ _TUP_10 (ui :: {{Eq u1}}) (uj :: {{Text u1}}) (uk :: u1 -> u1 -> u1) (ul :: u1 -> u1 -> u1) (um :: u1 -> u1 -> u1) (un :: u1 -> u1) (uo :: u1 -> u1) (up :: u1 -> u1) (uq :: Integer -> u1) (ur :: Int -> u1) -> _APP_ uq [ uh ]; _NO_DEFLT_ } _SPECIALISE_ [ Int, Double ] 2 { _A_ 1 _U_ 1 _N_ _S_ "U(P)" {_A_ 1 _U_ 2 _N_ _N_ _F_ _IF_ARGS_ 0 1 X 3 \ (u0 :: Int#) -> case _#_ int2Double# [] [u0] of { _PRIM_ (u1 :: Double#) -> _!_ D# [] [u1] } _N_} _F_ _IF_ARGS_ 0 1 C 4 \ (u0 :: Int) -> case u0 of { _ALG_ I# (u1 :: Int#) -> case _#_ int2Double# [] [u1] of { _PRIM_ (u2 :: Double#) -> _!_ D# [] [u2] }; _NO_DEFLT_ } _N_ }, [ Int, Int ] 2 { _A_ 1 _U_ 1 _N_ _N_ _F_ _IF_ARGS_ 0 0 X 1 _TYAPP_ _ORIG_ Prelude id { Int } _N_ }, [ Int, Integer ] 2 { _A_ 1 _U_ 1 _N_ _S_ "U(P)" {_A_ 1 _U_ 2 _N_ _N_ _F_ _IF_ARGS_ 0 1 X 1 \ (u0 :: Int#) -> _#_ int2Integer# [] [u0] _N_} _F_ _IF_ARGS_ 0 1 C 2 \ (u0 :: Int) -> case u0 of { _ALG_ I# (u1 :: Int#) -> _#_ int2Integer# [] [u1]; _NO_DEFLT_ } _N_ }, [ Integer, Double ] 2 { _A_ 1 _U_ 1 _N_ _S_ "U(PPP)" {_A_ 3 _U_ 222 _N_ _N_ _F_ _IF_ARGS_ 0 3 XXX 3 \ (u0 :: Int#) (u1 :: Int#) (u2 :: ByteArray#) -> case _#_ encodeDouble# [] [u0, u1, u2, 0#] of { _PRIM_ (u3 :: Double#) -> _!_ D# [] [u3] } _N_} _F_ _IF_ARGS_ 0 1 C 4 \ (u0 :: Integer) -> case u0 of { _ALG_ J# (u1 :: Int#) (u2 :: Int#) (u3 :: ByteArray#) -> case _#_ encodeDouble# [] [u1, u2, u3, 0#] of { _PRIM_ (u4 :: Double#) -> _!_ D# [] [u4] }; _NO_DEFLT_ } _N_ }, [ Integer, Int ] 2 { _A_ 1 _U_ 1 _N_ _S_ "U(PPP)" {_A_ 3 _U_ 222 _N_ _N_ _F_ _IF_ARGS_ 0 3 XXX 3 \ (u0 :: Int#) (u1 :: Int#) (u2 :: ByteArray#) -> case _#_ integer2Int# [] [u0, u1, u2] of { _PRIM_ (u3 :: Int#) -> _!_ I# [] [u3] } _N_} _F_ _IF_ARGS_ 0 1 C 4 \ (u0 :: Integer) -> case u0 of { _ALG_ J# (u1 :: Int#) (u2 :: Int#) (u3 :: ByteArray#) -> case _#_ integer2Int# [] [u1, u2, u3] of { _PRIM_ (u4 :: Int#) -> _!_ I# [] [u4] }; _NO_DEFLT_ } _N_ }, [ Integer, Integer ] 2 { _A_ 1 _U_ 1 _N_ _N_ _F_ _IF_ARGS_ 0 0 X 1 _TYAPP_ _ORIG_ Prelude id { Integer } _N_ } #-}
+ {-# GHC_PRAGMA _A_ 3 _U_ 112 _N_ _S_ "LU(AAAAAAAASA)L" {_A_ 3 _U_ 112 _N_ _N_ _F_ _IF_ARGS_ 2 3 CXX 6 _/\_ u0 u1 -> \ (u2 :: {{Integral u0}}) (u3 :: Integer -> u1) (u4 :: u0) -> let {(uh :: Integer) = case u2 of { _ALG_ _TUP_12 (u5 :: {{Real u0}}) (u6 :: {{Ix u0}}) (u7 :: u0 -> u0 -> u0) (u8 :: u0 -> u0 -> u0) (u9 :: u0 -> u0 -> u0) (ua :: u0 -> u0 -> u0) (ub :: u0 -> u0 -> (u0, u0)) (uc :: u0 -> u0 -> (u0, u0)) (ud :: u0 -> Bool) (ue :: u0 -> Bool) (uf :: u0 -> Integer) (ug :: u0 -> Int) -> _APP_ uf [ u4 ]; _NO_DEFLT_ }} in _APP_ u3 [ uh ] _N_} _F_ _IF_ARGS_ 2 3 CCX 7 _/\_ u0 u1 -> \ (u2 :: {{Integral u0}}) (u3 :: {{Num u1}}) (u4 :: u0) -> let {(uh :: Integer) = case u2 of { _ALG_ _TUP_12 (u5 :: {{Real u0}}) (u6 :: {{Ix u0}}) (u7 :: u0 -> u0 -> u0) (u8 :: u0 -> u0 -> u0) (u9 :: u0 -> u0 -> u0) (ua :: u0 -> u0 -> u0) (ub :: u0 -> u0 -> (u0, u0)) (uc :: u0 -> u0 -> (u0, u0)) (ud :: u0 -> Bool) (ue :: u0 -> Bool) (uf :: u0 -> Integer) (ug :: u0 -> Int) -> _APP_ uf [ u4 ]; _NO_DEFLT_ }} in case u3 of { _ALG_ _TUP_10 (ui :: {{Eq u1}}) (uj :: {{Text u1}}) (uk :: u1 -> u1 -> u1) (ul :: u1 -> u1 -> u1) (um :: u1 -> u1 -> u1) (un :: u1 -> u1) (uo :: u1 -> u1) (up :: u1 -> u1) (uq :: Integer -> u1) (ur :: Int -> u1) -> _APP_ uq [ uh ]; _NO_DEFLT_ } _SPECIALISE_ [ Int, Double ] 2 { _A_ 1 _U_ 1 _N_ _S_ "U(P)" {_A_ 1 _U_ 2 _N_ _N_ _F_ _IF_ARGS_ 0 1 X 3 \ (u0 :: Int#) -> case _#_ int2Double# [] [u0] of { _PRIM_ (u1 :: Double#) -> _!_ D# [] [u1] } _N_} _F_ _IF_ARGS_ 0 1 C 4 \ (u0 :: Int) -> case u0 of { _ALG_ I# (u1 :: Int#) -> case _#_ int2Double# [] [u1] of { _PRIM_ (u2 :: Double#) -> _!_ D# [] [u2] }; _NO_DEFLT_ } _N_ }, [ Int, Float ] 2 { _A_ 1 _U_ 1 _N_ _S_ "U(P)" {_A_ 1 _U_ 2 _N_ _N_ _F_ _IF_ARGS_ 0 1 X 3 \ (u0 :: Int#) -> case _#_ int2Float# [] [u0] of { _PRIM_ (u1 :: Float#) -> _!_ F# [] [u1] } _N_} _F_ _IF_ARGS_ 0 1 C 4 \ (u0 :: Int) -> case u0 of { _ALG_ I# (u1 :: Int#) -> case _#_ int2Float# [] [u1] of { _PRIM_ (u2 :: Float#) -> _!_ F# [] [u2] }; _NO_DEFLT_ } _N_ }, [ Int, Int ] 2 { _A_ 1 _U_ 1 _N_ _N_ _F_ _IF_ARGS_ 0 0 X 1 _TYAPP_ _ORIG_ Prelude id { Int } _N_ }, [ Int, Integer ] 2 { _A_ 1 _U_ 1 _N_ _S_ "U(P)" {_A_ 1 _U_ 2 _N_ _N_ _F_ _IF_ARGS_ 0 1 X 1 \ (u0 :: Int#) -> _#_ int2Integer# [] [u0] _N_} _F_ _IF_ARGS_ 0 1 C 2 \ (u0 :: Int) -> case u0 of { _ALG_ I# (u1 :: Int#) -> _#_ int2Integer# [] [u1]; _NO_DEFLT_ } _N_ }, [ Int, (Ratio Integer) ] 2 { _A_ 1 _U_ 1 _N_ _N_ _N_ _N_ }, [ Integer, Double ] 2 { _A_ 1 _U_ 1 _N_ _S_ "U(PPP)" {_A_ 3 _U_ 222 _N_ _N_ _F_ _IF_ARGS_ 0 3 XXX 3 \ (u0 :: Int#) (u1 :: Int#) (u2 :: ByteArray#) -> case _#_ encodeDouble# [] [u0, u1, u2, 0#] of { _PRIM_ (u3 :: Double#) -> _!_ D# [] [u3] } _N_} _F_ _IF_ARGS_ 0 1 C 4 \ (u0 :: Integer) -> case u0 of { _ALG_ J# (u1 :: Int#) (u2 :: Int#) (u3 :: ByteArray#) -> case _#_ encodeDouble# [] [u1, u2, u3, 0#] of { _PRIM_ (u4 :: Double#) -> _!_ D# [] [u4] }; _NO_DEFLT_ } _N_ }, [ Integer, Float ] 2 { _A_ 1 _U_ 1 _N_ _S_ "U(PPP)" {_A_ 3 _U_ 222 _N_ _N_ _F_ _IF_ARGS_ 0 3 XXX 3 \ (u0 :: Int#) (u1 :: Int#) (u2 :: ByteArray#) -> case _#_ encodeFloat# [] [u0, u1, u2, 0#] of { _PRIM_ (u3 :: Float#) -> _!_ F# [] [u3] } _N_} _F_ _IF_ARGS_ 0 1 C 4 \ (u0 :: Integer) -> case u0 of { _ALG_ J# (u1 :: Int#) (u2 :: Int#) (u3 :: ByteArray#) -> case _#_ encodeFloat# [] [u1, u2, u3, 0#] of { _PRIM_ (u4 :: Float#) -> _!_ F# [] [u4] }; _NO_DEFLT_ } _N_ }, [ Integer, Int ] 2 { _A_ 1 _U_ 1 _N_ _S_ "U(PPP)" {_A_ 3 _U_ 222 _N_ _N_ _F_ _IF_ARGS_ 0 3 XXX 3 \ (u0 :: Int#) (u1 :: Int#) (u2 :: ByteArray#) -> case _#_ integer2Int# [] [u0, u1, u2] of { _PRIM_ (u3 :: Int#) -> _!_ I# [] [u3] } _N_} _F_ _IF_ARGS_ 0 1 C 4 \ (u0 :: Integer) -> case u0 of { _ALG_ J# (u1 :: Int#) (u2 :: Int#) (u3 :: ByteArray#) -> case _#_ integer2Int# [] [u1, u2, u3] of { _PRIM_ (u4 :: Int#) -> _!_ I# [] [u4] }; _NO_DEFLT_ } _N_ }, [ Integer, Integer ] 2 { _A_ 1 _U_ 1 _N_ _N_ _F_ _IF_ARGS_ 0 0 X 1 _TYAPP_ _ORIG_ Prelude id { Integer } _N_ }, [ Integer, (Ratio Integer) ] 2 { _A_ 1 _U_ 2 _N_ _N_ _F_ _IF_ARGS_ 0 1 X 3 \ (u0 :: Integer) -> _!_ (:%) [Integer] [u0, _SPEC_ _ORIG_ PreludeCore __i1 [ (Integer) ]] _N_ } #-}
fromRealFrac :: (RealFrac a, Fractional b) => a -> b
- {-# GHC_PRAGMA _A_ 3 _U_ 112 _N_ _S_ "LU(AAAS)L" {_A_ 3 _U_ 112 _N_ _N_ _F_ _IF_ARGS_ 2 3 CXX 7 _/\_ u0 u1 -> \ (u2 :: {{RealFrac u0}}) (u3 :: Ratio Integer -> u1) (u4 :: u0) -> let {(uf :: Ratio Integer) = case u2 of { _ALG_ _TUP_7 (u5 :: {{Real u0}}) (u6 :: {{Fractional u0}}) (u7 :: _forall_ a$z1 =>{{Integral a$z1}} -> u0 -> (a$z1, u0)) (u8 :: _forall_ a$z1 =>{{Integral a$z1}} -> u0 -> a$z1) (u9 :: _forall_ a$z1 =>{{Integral a$z1}} -> u0 -> a$z1) (ua :: _forall_ a$z1 =>{{Integral a$z1}} -> u0 -> a$z1) (ub :: _forall_ a$z1 =>{{Integral a$z1}} -> u0 -> a$z1) -> case u5 of { _ALG_ _TUP_3 (uc :: {{Num u0}}) (ud :: {{Enum u0}}) (ue :: u0 -> Ratio Integer) -> _APP_ ue [ u4 ]; _NO_DEFLT_ }; _NO_DEFLT_ }} in _APP_ u3 [ uf ] _N_} _F_ _IF_ARGS_ 2 3 CCX 8 _/\_ u0 u1 -> \ (u2 :: {{RealFrac u0}}) (u3 :: {{Fractional u1}}) (u4 :: u0) -> let {(uf :: Ratio Integer) = case u2 of { _ALG_ _TUP_7 (u5 :: {{Real u0}}) (u6 :: {{Fractional u0}}) (u7 :: _forall_ a$z1 =>{{Integral a$z1}} -> u0 -> (a$z1, u0)) (u8 :: _forall_ a$z1 =>{{Integral a$z1}} -> u0 -> a$z1) (u9 :: _forall_ a$z1 =>{{Integral a$z1}} -> u0 -> a$z1) (ua :: _forall_ a$z1 =>{{Integral a$z1}} -> u0 -> a$z1) (ub :: _forall_ a$z1 =>{{Integral a$z1}} -> u0 -> a$z1) -> case u5 of { _ALG_ _TUP_3 (uc :: {{Num u0}}) (ud :: {{Enum u0}}) (ue :: u0 -> Ratio Integer) -> _APP_ ue [ u4 ]; _NO_DEFLT_ }; _NO_DEFLT_ }} in case u3 of { _ALG_ _TUP_4 (ug :: {{Num u1}}) (uh :: u1 -> u1 -> u1) (ui :: u1 -> u1) (uj :: Ratio Integer -> u1) -> _APP_ uj [ uf ]; _NO_DEFLT_ } _SPECIALISE_ [ Double, Double ] 2 { _A_ 1 _U_ 1 _N_ _N_ _F_ _IF_ARGS_ 0 0 X 1 _TYAPP_ _ORIG_ Prelude id { Double } _N_ }, [ Double, Float ] 2 { _A_ 1 _U_ 1 _N_ _S_ "U(P)" {_A_ 1 _U_ 2 _N_ _N_ _F_ _IF_ARGS_ 0 1 X 3 \ (u0 :: Double#) -> case _#_ double2Float# [] [u0] of { _PRIM_ (u1 :: Float#) -> _!_ F# [] [u1] } _N_} _F_ _IF_ARGS_ 0 1 C 4 \ (u0 :: Double) -> case u0 of { _ALG_ D# (u1 :: Double#) -> case _#_ double2Float# [] [u1] of { _PRIM_ (u2 :: Float#) -> _!_ F# [] [u2] }; _NO_DEFLT_ } _N_ }, [ Float, Double ] 2 { _A_ 1 _U_ 1 _N_ _S_ "U(P)" {_A_ 1 _U_ 2 _N_ _N_ _F_ _IF_ARGS_ 0 1 X 3 \ (u0 :: Float#) -> case _#_ float2Double# [] [u0] of { _PRIM_ (u1 :: Double#) -> _!_ D# [] [u1] } _N_} _F_ _IF_ARGS_ 0 1 C 4 \ (u0 :: Float) -> case u0 of { _ALG_ F# (u1 :: Float#) -> case _#_ float2Double# [] [u1] of { _PRIM_ (u2 :: Double#) -> _!_ D# [] [u2] }; _NO_DEFLT_ } _N_ }, [ Float, Float ] 2 { _A_ 1 _U_ 1 _N_ _N_ _F_ _IF_ARGS_ 0 0 X 1 _TYAPP_ _ORIG_ Prelude id { Float } _N_ } #-}
+ {-# GHC_PRAGMA _A_ 3 _U_ 112 _N_ _S_ "LU(AAAS)L" {_A_ 3 _U_ 112 _N_ _N_ _F_ _IF_ARGS_ 2 3 CXX 7 _/\_ u0 u1 -> \ (u2 :: {{RealFrac u0}}) (u3 :: Ratio Integer -> u1) (u4 :: u0) -> let {(uf :: Ratio Integer) = case u2 of { _ALG_ _TUP_7 (u5 :: {{Real u0}}) (u6 :: {{Fractional u0}}) (u7 :: _forall_ a$z1 =>{{Integral a$z1}} -> u0 -> (a$z1, u0)) (u8 :: _forall_ a$z1 =>{{Integral a$z1}} -> u0 -> a$z1) (u9 :: _forall_ a$z1 =>{{Integral a$z1}} -> u0 -> a$z1) (ua :: _forall_ a$z1 =>{{Integral a$z1}} -> u0 -> a$z1) (ub :: _forall_ a$z1 =>{{Integral a$z1}} -> u0 -> a$z1) -> case u5 of { _ALG_ _TUP_3 (uc :: {{Num u0}}) (ud :: {{Enum u0}}) (ue :: u0 -> Ratio Integer) -> _APP_ ue [ u4 ]; _NO_DEFLT_ }; _NO_DEFLT_ }} in _APP_ u3 [ uf ] _N_} _F_ _IF_ARGS_ 2 3 CCX 8 _/\_ u0 u1 -> \ (u2 :: {{RealFrac u0}}) (u3 :: {{Fractional u1}}) (u4 :: u0) -> let {(uf :: Ratio Integer) = case u2 of { _ALG_ _TUP_7 (u5 :: {{Real u0}}) (u6 :: {{Fractional u0}}) (u7 :: _forall_ a$z1 =>{{Integral a$z1}} -> u0 -> (a$z1, u0)) (u8 :: _forall_ a$z1 =>{{Integral a$z1}} -> u0 -> a$z1) (u9 :: _forall_ a$z1 =>{{Integral a$z1}} -> u0 -> a$z1) (ua :: _forall_ a$z1 =>{{Integral a$z1}} -> u0 -> a$z1) (ub :: _forall_ a$z1 =>{{Integral a$z1}} -> u0 -> a$z1) -> case u5 of { _ALG_ _TUP_3 (uc :: {{Num u0}}) (ud :: {{Enum u0}}) (ue :: u0 -> Ratio Integer) -> _APP_ ue [ u4 ]; _NO_DEFLT_ }; _NO_DEFLT_ }} in case u3 of { _ALG_ _TUP_4 (ug :: {{Num u1}}) (uh :: u1 -> u1 -> u1) (ui :: u1 -> u1) (uj :: Ratio Integer -> u1) -> _APP_ uj [ uf ]; _NO_DEFLT_ } _SPECIALISE_ [ Double, Double ] 2 { _A_ 1 _U_ 1 _N_ _N_ _F_ _IF_ARGS_ 0 0 X 1 _TYAPP_ _ORIG_ Prelude id { Double } _N_ }, [ Double, Float ] 2 { _A_ 1 _U_ 1 _N_ _S_ "U(P)" {_A_ 1 _U_ 2 _N_ _N_ _F_ _IF_ARGS_ 0 1 X 3 \ (u0 :: Double#) -> case _#_ double2Float# [] [u0] of { _PRIM_ (u1 :: Float#) -> _!_ F# [] [u1] } _N_} _F_ _IF_ARGS_ 0 1 C 4 \ (u0 :: Double) -> case u0 of { _ALG_ D# (u1 :: Double#) -> case _#_ double2Float# [] [u1] of { _PRIM_ (u2 :: Float#) -> _!_ F# [] [u2] }; _NO_DEFLT_ } _N_ }, [ Double, (Ratio Integer) ] 2 { _A_ 1 _U_ 1 _N_ _S_ "U(P)" {_A_ 1 _U_ 2 _N_ _N_ _N_ _N_} _N_ _N_ }, [ Float, Double ] 2 { _A_ 1 _U_ 1 _N_ _S_ "U(P)" {_A_ 1 _U_ 2 _N_ _N_ _F_ _IF_ARGS_ 0 1 X 3 \ (u0 :: Float#) -> case _#_ float2Double# [] [u0] of { _PRIM_ (u1 :: Double#) -> _!_ D# [] [u1] } _N_} _F_ _IF_ARGS_ 0 1 C 4 \ (u0 :: Float) -> case u0 of { _ALG_ F# (u1 :: Float#) -> case _#_ float2Double# [] [u1] of { _PRIM_ (u2 :: Double#) -> _!_ D# [] [u2] }; _NO_DEFLT_ } _N_ }, [ Float, Float ] 2 { _A_ 1 _U_ 1 _N_ _N_ _F_ _IF_ARGS_ 0 0 X 1 _TYAPP_ _ORIG_ Prelude id { Float } _N_ }, [ Float, (Ratio Integer) ] 2 { _A_ 1 _U_ 1 _N_ _S_ "U(P)" {_A_ 1 _U_ 2 _N_ _N_ _N_ _N_} _N_ _N_ }, [ (Ratio Integer), Double ] 2 { _A_ 1 _U_ 1 _N_ _S_ "U(U(PPP)U(PPP))" {_A_ 4 _U_ 2222 _N_ _N_ _N_ _N_} _N_ _N_ }, [ (Ratio Integer), Float ] 2 { _A_ 1 _U_ 2 _N_ _N_ _F_ _IF_ARGS_ 0 0 X 1 _CONSTM_ Fractional fromRational (Float) _N_ }, [ (Ratio Integer), (Ratio Integer) ] 2 { _A_ 1 _U_ 1 _N_ _N_ _F_ _IF_ARGS_ 0 0 X 1 _TYAPP_ _ORIG_ Prelude id { (Ratio Integer) } _N_ } #-}
fst :: (b, a) -> b
{-# GHC_PRAGMA _A_ 1 _U_ 1 _N_ _S_ "U(SA)" {_A_ 1 _U_ 1 _N_ _N_ _F_ _IF_ARGS_ 2 1 X 1 _/\_ u0 u1 -> \ (u2 :: u1) -> u2 _N_} _F_ _IF_ARGS_ 2 1 C 2 _/\_ u0 u1 -> \ (u2 :: (u1, u0)) -> case u2 of { _ALG_ _TUP_2 (u3 :: u1) (u4 :: u0) -> u3; _NO_DEFLT_ } _N_ #-}
gcd :: Integral a => a -> a -> a
{-# GHC_PRAGMA _A_ 1 _U_ 1 _N_ _S_ "S" _F_ _IF_ARGS_ 1 1 X 1 _/\_ u0 -> \ (u1 :: u0) -> u1 _N_ #-}
isAlpha :: Char -> Bool
{-# GHC_PRAGMA _A_ 1 _U_ 1 _N_ _S_ "U(P)" {_A_ 1 _U_ 2 _N_ _N_ _N_ _N_} _N_ _N_ #-}
+isAlpha# :: Char# -> Bool
+ {-# GHC_PRAGMA _A_ 1 _U_ 2 _N_ _S_ "P" _N_ _N_ #-}
isAlphanum :: Char -> Bool
{-# GHC_PRAGMA _A_ 1 _U_ 1 _N_ _S_ "U(P)" {_A_ 1 _U_ 2 _N_ _N_ _N_ _N_} _N_ _N_ #-}
+isAlphanum# :: Char# -> Bool
+ {-# GHC_PRAGMA _A_ 1 _U_ 2 _N_ _S_ "P" _N_ _N_ #-}
isAscii :: Char -> Bool
{-# GHC_PRAGMA _A_ 1 _U_ 1 _N_ _S_ "U(P)" {_A_ 1 _U_ 2 _N_ _N_ _F_ _IF_ARGS_ 0 1 X 2 \ (u0 :: Char#) -> case _#_ ord# [] [u0] of { _PRIM_ (u1 :: Int#) -> _#_ ltInt# [] [u1, 128#] } _N_} _F_ _IF_ARGS_ 0 1 C 3 \ (u0 :: Char) -> case u0 of { _ALG_ C# (u1 :: Char#) -> case _#_ ord# [] [u1] of { _PRIM_ (u2 :: Int#) -> _#_ ltInt# [] [u2, 128#] }; _NO_DEFLT_ } _N_ #-}
+isAscii# :: Char# -> Bool
+ {-# GHC_PRAGMA _A_ 1 _U_ 2 _N_ _S_ "P" _F_ _IF_ARGS_ 0 1 X 2 \ (u0 :: Char#) -> case _#_ ord# [] [u0] of { _PRIM_ (u1 :: Int#) -> _#_ ltInt# [] [u1, 128#] } _N_ #-}
isControl :: Char -> Bool
{-# GHC_PRAGMA _A_ 1 _U_ 1 _N_ _S_ "U(P)" {_A_ 1 _U_ 2 _N_ _N_ _N_ _N_} _N_ _N_ #-}
+isControl# :: Char# -> Bool
+ {-# GHC_PRAGMA _A_ 1 _U_ 2 _N_ _S_ "P" _N_ _N_ #-}
isDigit :: Char -> Bool
{-# GHC_PRAGMA _A_ 1 _U_ 1 _N_ _S_ "U(P)" {_A_ 1 _U_ 2 _N_ _N_ _N_ _N_} _N_ _N_ #-}
+isDigit# :: Char# -> Bool
+ {-# GHC_PRAGMA _A_ 1 _U_ 2 _N_ _S_ "P" _N_ _N_ #-}
isLower :: Char -> Bool
{-# GHC_PRAGMA _A_ 1 _U_ 1 _N_ _S_ "U(P)" {_A_ 1 _U_ 2 _N_ _N_ _N_ _N_} _N_ _N_ #-}
+isLower# :: Char# -> Bool
+ {-# GHC_PRAGMA _A_ 1 _U_ 2 _N_ _S_ "P" _N_ _N_ #-}
isNullBin :: Bin -> Bool
- {-# GHC_PRAGMA _A_ 1 _U_ 2 _N_ _S_ _!_ _F_ _IF_ARGS_ 0 1 X 3 \ (u0 :: Bin) -> _APP_ _TYAPP_ error { (Bin -> Bool) } [ _NOREP_S_ "isNullBin{Prelude}\n", u0 ] _N_ #-}
+ {-# GHC_PRAGMA _A_ 1 _U_ 2 _N_ _S_ _!_ _N_ _N_ #-}
isPrint :: Char -> Bool
{-# GHC_PRAGMA _A_ 1 _U_ 1 _N_ _S_ "U(P)" {_A_ 1 _U_ 2 _N_ _N_ _N_ _N_} _N_ _N_ #-}
+isPrint# :: Char# -> Bool
+ {-# GHC_PRAGMA _A_ 1 _U_ 2 _N_ _S_ "P" _N_ _N_ #-}
isSpace :: Char -> Bool
{-# GHC_PRAGMA _A_ 1 _U_ 1 _N_ _S_ "U(P)" {_A_ 1 _U_ 1 _N_ _N_ _N_ _N_} _N_ _N_ #-}
+isSpace# :: Char# -> Bool
+ {-# GHC_PRAGMA _A_ 1 _U_ 1 _N_ _S_ "P" _N_ _N_ #-}
isUpper :: Char -> Bool
{-# GHC_PRAGMA _A_ 1 _U_ 1 _N_ _S_ "U(P)" {_A_ 1 _U_ 2 _N_ _N_ _N_ _N_} _N_ _N_ #-}
+isUpper# :: Char# -> Bool
+ {-# GHC_PRAGMA _A_ 1 _U_ 2 _N_ _S_ "P" _N_ _N_ #-}
lcm :: Integral a => a -> a -> a
{-# GHC_PRAGMA _A_ 1 _U_ 122 _N_ _S_ "U(U(U(U(SA)AAALALAAL)AA)ALLAAAAAAAA)" {_A_ 3 _U_ 12222 _N_ _N_ _N_ _N_} _N_ _SPECIALISE_ [ Int ] 1 { _A_ 2 _U_ 11 _N_ _S_ "LU(P)" {_A_ 2 _U_ 12 _N_ _N_ _N_ _N_} _N_ _N_ }, [ Integer ] 1 { _A_ 2 _U_ 11 _N_ _S_ "LU(PPP)" {_A_ 4 _U_ 1222 _N_ _N_ _N_ _N_} _N_ _N_ } #-}
maxChar :: Char
{-# GHC_PRAGMA _A_ 0 _N_ _N_ _N_ _F_ _IF_ARGS_ 0 0 X 2 _!_ C# [] ['\o377'#] _N_ #-}
+maxChar# :: Char#
+ {-# GHC_PRAGMA _A_ 0 _N_ _N_ _N_ _F_ _IF_ARGS_ 0 0 X 2 _!_ _Lift [Char#] ['\o377'#] _N_ #-}
maxInt :: Int
{-# GHC_PRAGMA _A_ 0 _N_ _N_ _N_ _F_ _IF_ARGS_ 0 0 X 2 _!_ I# [] [2147483647#] _N_ #-}
+maxInt# :: Int#
+ {-# GHC_PRAGMA _A_ 0 _N_ _N_ _N_ _F_ _IF_ARGS_ 0 0 X 2 _!_ _Lift [Int#] [2147483647#] _N_ #-}
minChar :: Char
{-# GHC_PRAGMA _A_ 0 _N_ _N_ _N_ _F_ _IF_ARGS_ 0 0 X 2 _!_ C# [] ['\o0'#] _N_ #-}
+minChar# :: Char#
+ {-# GHC_PRAGMA _A_ 0 _N_ _N_ _N_ _F_ _IF_ARGS_ 0 0 X 2 _!_ _Lift [Char#] ['\o0'#] _N_ #-}
minInt :: Int
{-# GHC_PRAGMA _A_ 0 _N_ _N_ _N_ _F_ _IF_ARGS_ 0 0 X 2 _!_ I# [] [-2147483647#] _N_ #-}
+minInt# :: Int#
+ {-# GHC_PRAGMA _A_ 0 _N_ _N_ _N_ _F_ _IF_ARGS_ 0 0 X 2 _!_ _Lift [Int#] [-2147483647#] _N_ #-}
not :: Bool -> Bool
{-# GHC_PRAGMA _A_ 1 _U_ 1 _N_ _S_ "E" _F_ _ALWAYS_ \ (u0 :: Bool) -> case u0 of { _ALG_ True -> _!_ False [] []; False -> _!_ True [] []; _NO_DEFLT_ } _N_ #-}
nullBin :: Bin
- {-# GHC_PRAGMA _A_ 0 _N_ _N_ _S_ _!_ _F_ _IF_ARGS_ 0 0 X 2 _APP_ _TYAPP_ error { Bin } [ _NOREP_S_ "nullBin{Prelude}\n" ] _N_ #-}
+ {-# GHC_PRAGMA _A_ 0 _N_ _N_ _S_ _!_ _N_ _N_ #-}
ord :: Char -> Int
{-# GHC_PRAGMA _A_ 1 _U_ 1 _N_ _S_ "U(P)" {_A_ 1 _U_ 2 _N_ _N_ _F_ _IF_ARGS_ 0 1 X 3 \ (u0 :: Char#) -> case _#_ ord# [] [u0] of { _PRIM_ (u1 :: Int#) -> _!_ I# [] [u1] } _N_} _F_ _IF_ARGS_ 0 1 C 4 \ (u0 :: Char) -> case u0 of { _ALG_ C# (u1 :: Char#) -> case _#_ ord# [] [u1] of { _PRIM_ (u2 :: Int#) -> _!_ I# [] [u2] }; _NO_DEFLT_ } _N_ #-}
otherwise :: Bool
snd :: (a, b) -> b
{-# GHC_PRAGMA _A_ 1 _U_ 1 _N_ _S_ "U(AS)" {_A_ 1 _U_ 1 _N_ _N_ _F_ _IF_ARGS_ 2 1 X 1 _/\_ u0 u1 -> \ (u2 :: u1) -> u2 _N_} _F_ _IF_ARGS_ 2 1 C 2 _/\_ u0 u1 -> \ (u2 :: (u0, u1)) -> case u2 of { _ALG_ _TUP_2 (u3 :: u0) (u4 :: u1) -> u4; _NO_DEFLT_ } _N_ #-}
subtract :: Num a => a -> a -> a
- {-# GHC_PRAGMA _A_ 3 _U_ 122 _N_ _S_ "U(AAASAAAAAA)LL" {_A_ 3 _U_ 122 _N_ _N_ _F_ _IF_ARGS_ 1 3 XXX 3 _/\_ u0 -> \ (u1 :: u0 -> u0 -> u0) (u2 :: u0) (u3 :: u0) -> _APP_ u1 [ u3, u2 ] _N_} _F_ _IF_ARGS_ 1 3 CXX 4 _/\_ u0 -> \ (u1 :: {{Num u0}}) (u2 :: u0) (u3 :: u0) -> case u1 of { _ALG_ _TUP_10 (u4 :: {{Eq u0}}) (u5 :: {{Text u0}}) (u6 :: u0 -> u0 -> u0) (u7 :: u0 -> u0 -> u0) (u8 :: u0 -> u0 -> u0) (u9 :: u0 -> u0) (ua :: u0 -> u0) (ub :: u0 -> u0) (uc :: Integer -> u0) (ud :: Int -> u0) -> _APP_ u7 [ u3, u2 ]; _NO_DEFLT_ } _SPECIALISE_ [ Double ] 1 { _A_ 2 _U_ 11 _N_ _S_ "U(P)U(P)" {_A_ 2 _U_ 22 _N_ _N_ _F_ _IF_ARGS_ 0 2 XX 3 \ (u0 :: Double#) (u1 :: Double#) -> case _#_ minusDouble# [] [u1, u0] of { _PRIM_ (u2 :: Double#) -> _!_ D# [] [u2] } _N_} _F_ _IF_ARGS_ 0 2 CC 5 \ (u0 :: Double) (u1 :: Double) -> case u1 of { _ALG_ D# (u2 :: Double#) -> case u0 of { _ALG_ D# (u3 :: Double#) -> case _#_ minusDouble# [] [u2, u3] of { _PRIM_ (u4 :: Double#) -> _!_ D# [] [u4] }; _NO_DEFLT_ }; _NO_DEFLT_ } _N_ }, [ Int ] 1 { _A_ 2 _U_ 11 _N_ _S_ "U(P)U(P)" {_A_ 2 _U_ 22 _N_ _N_ _F_ _IF_ARGS_ 0 2 XX 3 \ (u0 :: Int#) (u1 :: Int#) -> case _#_ minusInt# [] [u1, u0] of { _PRIM_ (u2 :: Int#) -> _!_ I# [] [u2] } _N_} _F_ _IF_ARGS_ 0 2 CC 5 \ (u0 :: Int) (u1 :: Int) -> case u1 of { _ALG_ I# (u2 :: Int#) -> case u0 of { _ALG_ I# (u3 :: Int#) -> case _#_ minusInt# [] [u2, u3] of { _PRIM_ (u4 :: Int#) -> _!_ I# [] [u4] }; _NO_DEFLT_ }; _NO_DEFLT_ } _N_ } #-}
+ {-# GHC_PRAGMA _A_ 3 _U_ 122 _N_ _S_ "U(AAASAAAAAA)LL" {_A_ 3 _U_ 122 _N_ _N_ _F_ _IF_ARGS_ 1 3 XXX 3 _/\_ u0 -> \ (u1 :: u0 -> u0 -> u0) (u2 :: u0) (u3 :: u0) -> _APP_ u1 [ u3, u2 ] _N_} _F_ _IF_ARGS_ 1 3 CXX 4 _/\_ u0 -> \ (u1 :: {{Num u0}}) (u2 :: u0) (u3 :: u0) -> case u1 of { _ALG_ _TUP_10 (u4 :: {{Eq u0}}) (u5 :: {{Text u0}}) (u6 :: u0 -> u0 -> u0) (u7 :: u0 -> u0 -> u0) (u8 :: u0 -> u0 -> u0) (u9 :: u0 -> u0) (ua :: u0 -> u0) (ub :: u0 -> u0) (uc :: Integer -> u0) (ud :: Int -> u0) -> _APP_ u7 [ u3, u2 ]; _NO_DEFLT_ } _SPECIALISE_ [ Double ] 1 { _A_ 2 _U_ 11 _N_ _S_ "U(P)U(P)" {_A_ 2 _U_ 22 _N_ _N_ _F_ _IF_ARGS_ 0 2 XX 3 \ (u0 :: Double#) (u1 :: Double#) -> case _#_ minusDouble# [] [u1, u0] of { _PRIM_ (u2 :: Double#) -> _!_ D# [] [u2] } _N_} _F_ _IF_ARGS_ 0 2 CC 5 \ (u0 :: Double) (u1 :: Double) -> case u1 of { _ALG_ D# (u2 :: Double#) -> case u0 of { _ALG_ D# (u3 :: Double#) -> case _#_ minusDouble# [] [u2, u3] of { _PRIM_ (u4 :: Double#) -> _!_ D# [] [u4] }; _NO_DEFLT_ }; _NO_DEFLT_ } _N_ }, [ Int ] 1 { _A_ 2 _U_ 11 _N_ _S_ "U(P)U(P)" {_A_ 2 _U_ 22 _N_ _N_ _F_ _IF_ARGS_ 0 2 XX 3 \ (u0 :: Int#) (u1 :: Int#) -> case _#_ minusInt# [] [u1, u0] of { _PRIM_ (u2 :: Int#) -> _!_ I# [] [u2] } _N_} _F_ _IF_ARGS_ 0 2 CC 5 \ (u0 :: Int) (u1 :: Int) -> case u1 of { _ALG_ I# (u2 :: Int#) -> case u0 of { _ALG_ I# (u3 :: Int#) -> case _#_ minusInt# [] [u2, u3] of { _PRIM_ (u4 :: Int#) -> _!_ I# [] [u4] }; _NO_DEFLT_ }; _NO_DEFLT_ } _N_ }, [ (Complex Double) ] 1 { _A_ 2 _U_ 11 _N_ _S_ "U(LL)U(LL)" {_A_ 4 _U_ 2222 _N_ _N_ _N_ _N_} _N_ _N_ } #-}
+toChar# :: Char -> Char#
+ {-# GHC_PRAGMA _A_ 1 _U_ 1 _N_ _S_ "U(P)" {_A_ 1 _U_ 1 _N_ _N_ _F_ _IF_ARGS_ 0 1 X 1 \ (u0 :: Char#) -> u0 _N_} _F_ _IF_ARGS_ 0 1 C 2 \ (u0 :: Char) -> case u0 of { _ALG_ C# (u1 :: Char#) -> u1; _NO_DEFLT_ } _N_ #-}
+toInt# :: Int -> Int#
+ {-# GHC_PRAGMA _A_ 1 _U_ 1 _N_ _S_ "U(P)" {_A_ 1 _U_ 1 _N_ _N_ _F_ _IF_ARGS_ 0 1 X 1 \ (u0 :: Int#) -> u0 _N_} _F_ _IF_ARGS_ 0 1 C 2 \ (u0 :: Int) -> case u0 of { _ALG_ I# (u1 :: Int#) -> u1; _NO_DEFLT_ } _N_ #-}
toLower :: Char -> Char
{-# GHC_PRAGMA _A_ 1 _U_ 1 _N_ _S_ "U(P)" {_A_ 1 _U_ 2 _N_ _N_ _N_ _N_} _N_ _N_ #-}
+toLower# :: Char# -> Char#
+ {-# GHC_PRAGMA _A_ 1 _U_ 2 _N_ _S_ "P" _N_ _N_ #-}
toUpper :: Char -> Char
{-# GHC_PRAGMA _A_ 1 _U_ 1 _N_ _S_ "U(P)" {_A_ 1 _U_ 2 _N_ _N_ _N_ _N_} _N_ _N_ #-}
+toUpper# :: Char# -> Char#
+ {-# GHC_PRAGMA _A_ 1 _U_ 2 _N_ _S_ "P" _N_ _N_ #-}
until :: (a -> Bool) -> (a -> a) -> a -> a
{-# GHC_PRAGMA _A_ 3 _U_ 222 _N_ _S_ "SLL" _N_ _N_ #-}
(||) :: Bool -> Bool -> Bool
toLower,
toUpper,
until,
- (||)
+ (||),
+
+ minInt#, maxInt#,
+ toInt#, fromInt#,
+ minChar#, maxChar#,
+ toChar#, fromChar#,
+ isAscii#, isControl#, isPrint#, isSpace#,
+ isUpper#, isLower#, isAlpha#, isDigit#, isAlphanum#,
+ toUpper#, toLower#
-#if defined(__UNBOXED_INSTANCES__)
- , minInt#, maxInt#
- , minChar#, maxChar#
- , toChar#, fromChar#
- , isAscii#, isControl#, isPrint#, isSpace#
- , isUpper#, isLower#, isAlpha#, isDigit#, isAlphanum#
- , toUpper#, toLower#
-#endif
) where
import UTypes ( Bin ) -- so we don't get any data constructors!
import Cls
import Core
+import TyArray
import TyComplex
import IChar
import IComplex
isNullBin :: Bin -> Bool
appendBin :: Bin -> Bin -> Bin
--- *
nullBin = error "nullBin{Prelude}\n"
isNullBin = error "isNullBin{Prelude}\n"
appendBin = error "appendBin{Prelude}\n"
toLower c | isUpper c = chr ((ord c - ord 'A') + ord 'a')
| otherwise = c
-#if defined(__UNBOXED_INSTANCES__)
---------------------------------------------------------------
-- Int# functions
---------------------------------------------------------------
+toInt# :: Int -> Int#
+toInt# (I# i#) = i#
+
+fromInt# :: Int# -> Int
+fromInt# i# = I# i#
+
-- ToDo: Preferable to overload minInt and maxInt
-- minInt, maxInt :: Num a => a
-- Solution: place in class Num (as pi is in Floating)
-- ord# and chr# are builtin
minChar#, maxChar# :: Char#
-minChar# = '\0'#
-maxChar# = '\255'#
+minChar# = '\0'#
+maxChar# = '\255'#
isAscii#, isControl#, isPrint#, isSpace# :: Char# -> Bool
isUpper#, isLower#, isAlpha#, isDigit#, isAlphanum# :: Char# -> Bool
-isAscii# c = ord# c < 128#
-isControl# c = c < ' '# || c == '\DEL'#
-isPrint# c = c >= ' '# && c <= '~'#
-isSpace# c = c == ' '# || c == '\t'# || c == '\n'# ||
- c == '\r'# || c == '\f'# || c == '\v'#
-isUpper# c = c >= 'A'# && c <= 'Z'#
-isLower# c = c >= 'a'# && c <= 'z'#
-isAlpha# c = isUpper# c || isLower# c
-isDigit# c = c >= '0'# && c <= '9'#
-isAlphanum# c = isAlpha# c || isDigit# c
+isAscii# c = ord# c `ltInt#` 128#
+isControl# c = c `ltChar#` ' '# || c `eqChar#` '\DEL'#
+isPrint# c = c `geChar#` ' '# && c `leChar#` '~'#
+isSpace# c = c `eqChar#` ' '# || c `eqChar#` '\t'# || c `eqChar#` '\n'# ||
+ c `eqChar#` '\r'# || c `eqChar#` '\f'# || c `eqChar#` '\v'#
+isUpper# c = c `geChar#` 'A'# && c `leChar#` 'Z'#
+isLower# c = c `geChar#` 'a'# && c `leChar#` 'z'#
+isAlpha# c = isUpper# c || isLower# c
+isDigit# c = c `geChar#` '0'# && c `leChar#` '9'#
+isAlphanum# c = isAlpha# c || isDigit# c
toUpper#, toLower# :: Char# -> Char#
-toUpper# c | isLower# c = chr# ((ord# c - ord# 'a'#) + ord# 'A'#)
+toUpper# c | isLower# c = chr# ((ord# c `minusInt#` ord# 'a'#) `plusInt#` ord# 'A'#)
| otherwise = c
-
-toLower# c | isUpper# c = chr# ((ord# c - ord# 'A'#) + ord# 'a'#)
+toLower# c | isUpper# c = chr# ((ord# c `minusInt#` ord# 'A'#) `plusInt#` ord# 'a'#)
| otherwise = c
-#endif {-UNBOXED INSTANCES-}
-
---------------------------------------------------------------
-- Numeric functions
---------------------------------------------------------------
---{-# GENERATE_SPECS subtract a{Int#,Double#} #-}
-{-# GENERATE_SPECS subtract a{~,Int,Double} #-}
+{-# GENERATE_SPECS subtract a{Int#,Double#,Int,Double,Complex(Double#),Complex(Double)} #-}
subtract :: (Num a) => a -> a -> a
#ifdef USE_REPORT_PRELUDE
subtract = flip (-)
subtract x y = y - x
#endif /* ! USE_REPORT_PRELUDE */
---{-# GENERATE_SPECS gcd a{Int#,Int,Integer} #-}
-{-# GENERATE_SPECS gcd a{~,Int,Integer} #-}
+{-# GENERATE_SPECS gcd a{Int#,Int,Integer} #-}
gcd :: (Integral a) => a -> a -> a
-gcd 0 0 = error "gcd{Prelude}: gcd 0 0 is undefined\n"
-gcd x y = gcd' (abs x) (abs y)
- where gcd' x 0 = x
- gcd' x y = gcd' y (x `rem` y)
-
---{-# GENERATE_SPECS lcm a{Int#,Int,Integer} #-}
-{-# GENERATE_SPECS lcm a{~,Int,Integer} #-}
+gcd x y | x == __i0 && y == __i0
+ = error "gcd{Prelude}: gcd 0 0 is undefined\n"
+ | otherwise
+ = gcd' (abs x) (abs y)
+ where gcd' x y | y == __i0
+ = x
+ | otherwise
+ = gcd' y (x `rem` y)
+
+{-# GENERATE_SPECS lcm a{Int#,Int,Integer} #-}
lcm :: (Integral a) => a -> a -> a
-lcm _ 0 = 0
-lcm 0 _ = 0
-lcm x y = abs ((x `quot` (gcd x y)) * y)
-
---{-# GENERATE_SPECS (^) a{~,Int#,Double#,Int,Integer,Double,Complex(Double#),Complex(Double)} b{~,Int#,Int} #-}
-{-# GENERATE_SPECS (^) a{~,Int,Integer,Double,Rational,Complex(Double)} b{~,Int} #-}
+lcm x y | y == __i0
+ = __i0
+ | x == __i0
+ = __i0
+ | otherwise
+ = abs ((x `quot` (gcd x y)) * y)
+
+{-# SPECIALIZE (^) :: Integer -> Integer -> Integer #-}
+{-# GENERATE_SPECS (^) a{~,Int#,Double#,Int,Integer,Double,Rational,Complex(Double#),Complex(Double)} b{~,Int#,Int} #-}
(^) :: (Num a, Integral b) => a -> b -> a
-x ^ 0 = 1
-x ^ (n+1) = f x n x
- where f _ 0 y = y
- f x n y = g x n where
- g x n | odd n = f x (n-1) (x*y)
- | otherwise = g (x*x) (n `div` 2)
-_ ^ _ = error "(^){Prelude}: negative exponent\n"
-
---{-# GENERATE_SPECS (^^) a{~,Double#,Double,Complex(Double#),Complex(Double)} b{~,Int#,Int} #-}
-{-# GENERATE_SPECS (^^) a{~,Double,Rational} b{~,Int} #-}
+x ^ n | n == __i0
+ = __i1
+ | n > __i0
+ = f x (n - __i1) x
+ | otherwise
+ = error "(^){Prelude}: negative exponent\n"
+ where
+ f x n y | n == __i0
+ = y
+ | otherwise
+ = g x n y
+ g x n y | odd n
+ = f x (n - __i1) (x*y)
+ | otherwise
+ = g (x*x) (n `div` __i2) y
+
+{-# GENERATE_SPECS (^^) a{~,Double#,Double,Rational,Complex(Double#),Complex(Double)} b{~,Int#,Int} #-}
(^^) :: (Fractional a, Integral b) => a -> b -> a
x ^^ n = if n >= 0 then x^n else recip (x^(-n))
---{-# GENERATE_SPECS atan2 a{Double#,Double} #-}
-{-# GENERATE_SPECS atan2 a{~,Double} #-}
+{-# GENERATE_SPECS atan2 a{Double#,Double} #-}
atan2 :: (RealFloat a) => a -> a -> a
#if USE_REPORT_PRELUDE
atan2 y x = case (signum y, signum x) of
---------------------------------------------------------------
-- component projections for pairs:
---{-# GENERATE_SPECS fst a b #-}
+{-# GENERATE_SPECS fst a b #-}
fst :: (a,b) -> a
fst (x,y) = x
---{-# GENERATE_SPECS snd a b #-}
+{-# GENERATE_SPECS snd a b #-}
snd :: (a,b) -> b
snd (x,y) = y
-- identity function
---{-# GENERATE_SPECS id a #-}
+{-# GENERATE_SPECS id a #-}
id :: a -> a
id x = x
-- constant function
---{-# GENERATE_SPECS const a b #-}
+{-# GENERATE_SPECS const a b #-}
const :: a -> b -> a
const x _ = x
-- function composition
{-# INLINE (.) #-}
---{-# GENERATE_SPECS (.) a b c #-}
+{-# GENERATE_SPECS (.) a b c #-}
(.) :: (b -> c) -> (a -> b) -> a -> c
(f . g) x = f (g x)
-- flip f takes its (first) two arguments in the reverse order of f.
---{-# GENERATE_SPECS flip a b c #-}
+{-# GENERATE_SPECS flip a b c #-}
flip :: (a -> b -> c) -> b -> a -> c
flip f x y = f y x
-- right-associating infix application operator (useful in continuation-
-- passing style)
---{-# GENERATE_SPECS ($) a b #-}
+{-# GENERATE_SPECS ($) a b #-}
($) :: (a -> b) -> a -> b
f $ x = f x
-- until p f yields the result of applying f until p holds.
---{-# GENERATE_SPECS until a #-}
+{-# GENERATE_SPECS until a #-}
until :: (a -> Bool) -> (a -> a) -> a -> a
until p f x | p x = x
| otherwise = until p f (f x)
-- asTypeOf is a type-restricted version of const. It is usually used
-- as an infix operator, and its typing forces its first argument
-- (which is usually overloaded) to have the same type as the second.
---{-# GENERATE_SPECS asTypeOf a #-}
+{-# GENERATE_SPECS asTypeOf a #-}
asTypeOf :: a -> a -> a
asTypeOf = const
-- fromIntegral and fromRealFrac with explicit specialisations
---------------------------------------------------------------
-{- LATER:
{-# SPECIALIZE fromIntegral ::
- Int# -> Int# = id,
- Int# -> Double# = int2Double#,
- Int# -> Int = i2I#,
- Int# -> Integer = int2Integer#,
- Int# -> Double = i2D#,
- Int -> Int# = i2i,
- Int -> Double# = i2d,
+ Int -> Rational,
+ Integer -> Rational,
Int -> Int = id,
Int -> Integer = i2Integer,
+ Int -> Float = i2F,
Int -> Double = i2D,
- Integer -> Int# = integer2i,
- Integer -> Double# = integer2d,
Integer -> Int = integer2I,
Integer -> Integer = id,
- Integer -> Double = integer2D #-}
--}
+ Integer -> Float = integer2F,
+ Integer -> Double = integer2D #-}
+#if defined(__UNBOXED_INSTANCES__)
{-# SPECIALIZE fromIntegral ::
- Int -> Int = id,
- Int -> Integer = i2Integer,
- Int -> Double = i2D,
- Integer -> Int = integer2I,
- Integer -> Integer = id,
- Integer -> Double = integer2D #-}
+ Int# -> Rational,
+ Int# -> Int# = id,
+ Int# -> Double# = i2d#,
+ Int# -> Int = i2I#,
+ Int# -> Integer = i2Integer#,
+ Int# -> Float = i2F#,
+ Int# -> Double = i2D#,
+ Int -> Int# = i2i,
+ Int -> Double# = i2d,
+ Integer -> Int# = integer2i,
+ Integer -> Double# = integer2d #-}
+#endif
+i2d# i# = int2Double# i#
i2I# i# = I# i#
+i2Integer# i# = int2Integer# i#
+i2F# i# = F# (int2Float# i#)
i2D# i# = D# (int2Double# i#)
i2i (I# i#) = i#
i2d (I# i#) = int2Double# i#
-i2D (I# i#) = D# (int2Double# i#)
i2Integer (I# i#) = int2Integer# i#
+i2F (I# i#) = F# (int2Float# i#)
+i2D (I# i#) = D# (int2Double# i#)
integer2i (J# a# s# d#) = integer2Int# a# s# d#
integer2d (J# a# s# d#) = encodeDouble# a# s# d# 0#
fromIntegral :: (Integral a, Num b) => a -> b
fromIntegral = fromInteger . toInteger
-{- LATER:
{-# SPECIALIZE fromRealFrac ::
+ Double -> Rational,
+ Rational -> Double,
+ Float -> Rational,
+ Rational -> Float,
+ Rational -> Rational = id,
+ Double -> Double = id,
+ Double -> Float = d2F,
+ Float -> Float = id,
+ Float -> Double = f2D #-}
+
+#if defined(__UNBOXED_INSTANCES__)
+{-# SPECIALIZE fromRealFrac ::
+ Double# -> Rational,
+ Rational -> Double#,
Double# -> Double# = id,
+ Double# -> Float = d2F#,
Double# -> Double = d2D#,
Double -> Double# = d2d,
- Double -> Double = id #-}
--}
-
-{-# SPECIALIZE fromRealFrac ::
- Float -> Float = id,
- Float -> Double = f2D,
- Double -> Float = d2F,
- Double -> Double = id #-}
+ Float -> Double# = f2d #-}
+#endif
d2F# d# = F# (double2Float# d#)
d2D# d# = D# d#
-{-# GHC_PRAGMA INTERFACE VERSION 5 #-}
+{-# GHC_PRAGMA INTERFACE VERSION 6 #-}
interface Prelude where
import PreludeArray((!), (//), Array, Assoc, _ByteArray, accum, accumArray, amap, array, assocs, bounds, elems, indices, ixmap, listArray)
import PreludeBuiltin(Bin, Char(..), Int(..), Integer(..), List(..), Tuple0, Tuple2, Tuple3, Tuple4, Tuple5, Tuple6, Tuple7, _Addr(..), _RealWorld(..), _State(..))
import PreludeComplex(Complex, cis, conjugate, imagPart, magnitude, mkPolar, phase, polar, realPart)
-import PreludeCore(Bool(..), Eq(..), Fractional(..), Integral(..), Ix(..), Num(..), Ord(..), Real(..), RealFloat(..), RealFrac(..), Text(..), _ceiling, _floor, _readList, _round, _showList, _showRational, _truncate)
+import PreludeCore(Bool(..), Eq(..), Fractional(..), Integral(..), Ix(..), Num(..), Ord(..), Real(..), RealFloat(..), RealFrac(..), Text(..), _readList, _showList, _showRational)
import PreludeIO(interact13) renaming (interact13 to interact)
import PreludeIOError(IOError13)
import PreludeList((!!), (++), (\\), all, and, any, break, concat, cycle, drop, dropWhile, elem, filter, foldl1, foldr1, genericLength, head, init, iterate, last, length, lines, map, maximum, minimum, notElem, nub, null, or, partition, product, products, repeat, reverse, scanl, scanl1, scanr, scanr1, span, splitAt, sum, sums, tail, take, takeWhile, transpose, unlines, unwords, unzip, unzip3, unzip4, unzip5, unzip6, unzip7, words, zip, zip3, zip4, zip5, zip6, zip7, zipWith, zipWith3, zipWith4, zipWith5, zipWith6, zipWith7)
(.) :: (a -> c) -> (b -> a) -> b -> c
{-# GHC_PRAGMA _A_ 3 _U_ 112 _N_ _S_ "SLL" _F_ _ALWAYS_ _/\_ u0 u1 u2 -> \ (u3 :: u0 -> u2) (u4 :: u1 -> u0) (u5 :: u1) -> let {(u6 :: u0) = _APP_ u4 [ u5 ]} in _APP_ u3 [ u6 ] _N_ #-}
(^) :: (Num b, Integral a) => b -> a -> b
- {-# GHC_PRAGMA _A_ 2 _U_ 2122 _N_ _S_ "LU(U(LU(U(U(SA)AALAAAA)AAAA)A)AAALAAAALAA)" {_A_ 5 _U_ 2212222 _N_ _N_ _N_ _N_} _N_ _SPECIALISE_ [ Int, Double ] 2 { _A_ 2 _U_ 21 _N_ _S_ "LU(P)" {_A_ 2 _U_ 22 _N_ _N_ _N_ _N_} _N_ _N_ }, [ Int, Int ] 2 { _A_ 2 _U_ 21 _N_ _S_ "LU(P)" {_A_ 2 _U_ 22 _N_ _N_ _N_ _N_} _N_ _N_ }, [ Int, Integer ] 2 { _A_ 2 _U_ 21 _N_ _S_ "LU(P)" {_A_ 2 _U_ 22 _N_ _N_ _N_ _N_} _N_ _N_ }, [ Int, (Ratio Integer) ] 2 { _A_ 2 _U_ 21 _N_ _S_ "LU(P)" {_A_ 2 _U_ 22 _N_ _N_ _N_ _N_} _N_ _N_ }, [ Int, (Complex Double) ] 2 { _A_ 2 _U_ 21 _N_ _S_ "LU(P)" {_A_ 2 _U_ 22 _N_ _N_ _N_ _N_} _N_ _N_ } #-}
+ {-# GHC_PRAGMA _A_ 2 _U_ 2122 _N_ _S_ "LU(U(LU(U(U(SL)LLLLLLL)LLLL)L)LLLLLLLLLLL)" _N_ _SPECIALISE_ [ Int, Double ] 2 { _A_ 2 _U_ 21 _N_ _S_ "LU(P)" {_A_ 2 _U_ 22 _N_ _N_ _N_ _N_} _N_ _N_ }, [ Int, Int ] 2 { _A_ 2 _U_ 21 _N_ _S_ "LU(P)" {_A_ 2 _U_ 22 _N_ _N_ _N_ _N_} _N_ _N_ }, [ Int, Integer ] 2 { _A_ 2 _U_ 21 _N_ _S_ "LU(P)" {_A_ 2 _U_ 22 _N_ _N_ _N_ _N_} _N_ _N_ }, [ Int, (Ratio Integer) ] 2 { _A_ 2 _U_ 21 _N_ _S_ "LU(P)" {_A_ 2 _U_ 22 _N_ _N_ _N_ _N_} _N_ _N_ }, [ Int, (Complex Double) ] 2 { _A_ 2 _U_ 21 _N_ _S_ "LU(P)" {_A_ 2 _U_ 22 _N_ _N_ _N_ _N_} _N_ _N_ }, [ Integer, Integer ] 2 { _A_ 2 _U_ 21 _N_ _S_ "LU(PPP)" {_A_ 4 _U_ 2222 _N_ _N_ _N_ _N_} _N_ _N_ } #-}
(^^) :: (Fractional b, Integral a) => b -> a -> b
- {-# GHC_PRAGMA _A_ 2 _U_ 2122 _N_ _S_ "LU(LU(U(AAASAAAA)AAA)AALAAAALAA)" {_A_ 5 _U_ 2212222 _N_ _N_ _N_ _N_} _N_ _SPECIALISE_ [ Int, Double ] 2 { _A_ 2 _U_ 21 _N_ _S_ "LU(P)" {_A_ 2 _U_ 22 _N_ _N_ _N_ _N_} _N_ _N_ }, [ Int, (Ratio Integer) ] 2 { _A_ 2 _U_ 21 _N_ _S_ "LU(P)" {_A_ 2 _U_ 22 _N_ _N_ _N_ _N_} _N_ _N_ } #-}
+ {-# GHC_PRAGMA _A_ 2 _U_ 2222 _N_ _S_ "LU(LU(U(LLLSLLLL)LLL)LLLLLLLLLL)" _N_ _SPECIALISE_ [ Int, Double ] 2 { _A_ 2 _U_ 21 _N_ _S_ "LU(P)" {_A_ 2 _U_ 22 _N_ _N_ _N_ _N_} _N_ _N_ }, [ Int, (Ratio Integer) ] 2 { _A_ 2 _U_ 21 _N_ _S_ "LU(P)" {_A_ 2 _U_ 22 _N_ _N_ _N_ _N_} _N_ _N_ }, [ Int, (Complex Double) ] 2 { _A_ 2 _U_ 21 _N_ _S_ "LU(P)" {_A_ 2 _U_ 22 _N_ _N_ _N_ _N_} _N_ _N_ } #-}
appendBin :: Bin -> Bin -> Bin
- {-# GHC_PRAGMA _A_ 2 _U_ 22 _N_ _S_ _!_ _F_ _IF_ARGS_ 0 2 XX 4 \ (u0 :: Bin) (u1 :: Bin) -> _APP_ _TYAPP_ error { (Bin -> Bin -> Bin) } [ _NOREP_S_ "appendBin{Prelude}\n", u0, u1 ] _N_ #-}
+ {-# GHC_PRAGMA _A_ 2 _U_ 22 _N_ _S_ _!_ _N_ _N_ #-}
asTypeOf :: a -> a -> a
{-# GHC_PRAGMA _A_ 2 _U_ 10 _N_ _N_ _F_ _IF_ARGS_ 1 0 X 1 _/\_ u0 -> _TYAPP_ _TYAPP_ _ORIG_ Prelude const { u0 } { u0 } _N_ #-}
atan2 :: RealFloat a => a -> a -> a
flip :: (b -> a -> c) -> a -> b -> c
{-# GHC_PRAGMA _A_ 3 _U_ 122 _N_ _S_ "SLL" _F_ _IF_ARGS_ 3 3 XXX 3 _/\_ u0 u1 u2 -> \ (u3 :: u1 -> u0 -> u2) (u4 :: u0) (u5 :: u1) -> _APP_ u3 [ u5, u4 ] _N_ #-}
fromIntegral :: (Integral a, Num b) => a -> b
- {-# GHC_PRAGMA _A_ 3 _U_ 112 _N_ _S_ "LU(AAAAAAAASA)L" {_A_ 3 _U_ 112 _N_ _N_ _F_ _IF_ARGS_ 2 3 CXX 6 _/\_ u0 u1 -> \ (u2 :: {{Integral u0}}) (u3 :: Integer -> u1) (u4 :: u0) -> let {(uh :: Integer) = case u2 of { _ALG_ _TUP_12 (u5 :: {{Real u0}}) (u6 :: {{Ix u0}}) (u7 :: u0 -> u0 -> u0) (u8 :: u0 -> u0 -> u0) (u9 :: u0 -> u0 -> u0) (ua :: u0 -> u0 -> u0) (ub :: u0 -> u0 -> (u0, u0)) (uc :: u0 -> u0 -> (u0, u0)) (ud :: u0 -> Bool) (ue :: u0 -> Bool) (uf :: u0 -> Integer) (ug :: u0 -> Int) -> _APP_ uf [ u4 ]; _NO_DEFLT_ }} in _APP_ u3 [ uh ] _N_} _F_ _IF_ARGS_ 2 3 CCX 7 _/\_ u0 u1 -> \ (u2 :: {{Integral u0}}) (u3 :: {{Num u1}}) (u4 :: u0) -> let {(uh :: Integer) = case u2 of { _ALG_ _TUP_12 (u5 :: {{Real u0}}) (u6 :: {{Ix u0}}) (u7 :: u0 -> u0 -> u0) (u8 :: u0 -> u0 -> u0) (u9 :: u0 -> u0 -> u0) (ua :: u0 -> u0 -> u0) (ub :: u0 -> u0 -> (u0, u0)) (uc :: u0 -> u0 -> (u0, u0)) (ud :: u0 -> Bool) (ue :: u0 -> Bool) (uf :: u0 -> Integer) (ug :: u0 -> Int) -> _APP_ uf [ u4 ]; _NO_DEFLT_ }} in case u3 of { _ALG_ _TUP_10 (ui :: {{Eq u1}}) (uj :: {{Text u1}}) (uk :: u1 -> u1 -> u1) (ul :: u1 -> u1 -> u1) (um :: u1 -> u1 -> u1) (un :: u1 -> u1) (uo :: u1 -> u1) (up :: u1 -> u1) (uq :: Integer -> u1) (ur :: Int -> u1) -> _APP_ uq [ uh ]; _NO_DEFLT_ } _SPECIALISE_ [ Int, Double ] 2 { _A_ 1 _U_ 1 _N_ _S_ "U(P)" {_A_ 1 _U_ 2 _N_ _N_ _F_ _IF_ARGS_ 0 1 X 3 \ (u0 :: Int#) -> case _#_ int2Double# [] [u0] of { _PRIM_ (u1 :: Double#) -> _!_ D# [] [u1] } _N_} _F_ _IF_ARGS_ 0 1 C 4 \ (u0 :: Int) -> case u0 of { _ALG_ I# (u1 :: Int#) -> case _#_ int2Double# [] [u1] of { _PRIM_ (u2 :: Double#) -> _!_ D# [] [u2] }; _NO_DEFLT_ } _N_ }, [ Int, Int ] 2 { _A_ 1 _U_ 1 _N_ _N_ _F_ _IF_ARGS_ 0 0 X 1 _TYAPP_ _ORIG_ Prelude id { Int } _N_ }, [ Int, Integer ] 2 { _A_ 1 _U_ 1 _N_ _S_ "U(P)" {_A_ 1 _U_ 2 _N_ _N_ _F_ _IF_ARGS_ 0 1 X 1 \ (u0 :: Int#) -> _#_ int2Integer# [] [u0] _N_} _F_ _IF_ARGS_ 0 1 C 2 \ (u0 :: Int) -> case u0 of { _ALG_ I# (u1 :: Int#) -> _#_ int2Integer# [] [u1]; _NO_DEFLT_ } _N_ }, [ Integer, Double ] 2 { _A_ 1 _U_ 1 _N_ _S_ "U(PPP)" {_A_ 3 _U_ 222 _N_ _N_ _F_ _IF_ARGS_ 0 3 XXX 3 \ (u0 :: Int#) (u1 :: Int#) (u2 :: ByteArray#) -> case _#_ encodeDouble# [] [u0, u1, u2, 0#] of { _PRIM_ (u3 :: Double#) -> _!_ D# [] [u3] } _N_} _F_ _IF_ARGS_ 0 1 C 4 \ (u0 :: Integer) -> case u0 of { _ALG_ J# (u1 :: Int#) (u2 :: Int#) (u3 :: ByteArray#) -> case _#_ encodeDouble# [] [u1, u2, u3, 0#] of { _PRIM_ (u4 :: Double#) -> _!_ D# [] [u4] }; _NO_DEFLT_ } _N_ }, [ Integer, Int ] 2 { _A_ 1 _U_ 1 _N_ _S_ "U(PPP)" {_A_ 3 _U_ 222 _N_ _N_ _F_ _IF_ARGS_ 0 3 XXX 3 \ (u0 :: Int#) (u1 :: Int#) (u2 :: ByteArray#) -> case _#_ integer2Int# [] [u0, u1, u2] of { _PRIM_ (u3 :: Int#) -> _!_ I# [] [u3] } _N_} _F_ _IF_ARGS_ 0 1 C 4 \ (u0 :: Integer) -> case u0 of { _ALG_ J# (u1 :: Int#) (u2 :: Int#) (u3 :: ByteArray#) -> case _#_ integer2Int# [] [u1, u2, u3] of { _PRIM_ (u4 :: Int#) -> _!_ I# [] [u4] }; _NO_DEFLT_ } _N_ }, [ Integer, Integer ] 2 { _A_ 1 _U_ 1 _N_ _N_ _F_ _IF_ARGS_ 0 0 X 1 _TYAPP_ _ORIG_ Prelude id { Integer } _N_ } #-}
+ {-# GHC_PRAGMA _A_ 3 _U_ 112 _N_ _S_ "LU(AAAAAAAASA)L" {_A_ 3 _U_ 112 _N_ _N_ _F_ _IF_ARGS_ 2 3 CXX 6 _/\_ u0 u1 -> \ (u2 :: {{Integral u0}}) (u3 :: Integer -> u1) (u4 :: u0) -> let {(uh :: Integer) = case u2 of { _ALG_ _TUP_12 (u5 :: {{Real u0}}) (u6 :: {{Ix u0}}) (u7 :: u0 -> u0 -> u0) (u8 :: u0 -> u0 -> u0) (u9 :: u0 -> u0 -> u0) (ua :: u0 -> u0 -> u0) (ub :: u0 -> u0 -> (u0, u0)) (uc :: u0 -> u0 -> (u0, u0)) (ud :: u0 -> Bool) (ue :: u0 -> Bool) (uf :: u0 -> Integer) (ug :: u0 -> Int) -> _APP_ uf [ u4 ]; _NO_DEFLT_ }} in _APP_ u3 [ uh ] _N_} _F_ _IF_ARGS_ 2 3 CCX 7 _/\_ u0 u1 -> \ (u2 :: {{Integral u0}}) (u3 :: {{Num u1}}) (u4 :: u0) -> let {(uh :: Integer) = case u2 of { _ALG_ _TUP_12 (u5 :: {{Real u0}}) (u6 :: {{Ix u0}}) (u7 :: u0 -> u0 -> u0) (u8 :: u0 -> u0 -> u0) (u9 :: u0 -> u0 -> u0) (ua :: u0 -> u0 -> u0) (ub :: u0 -> u0 -> (u0, u0)) (uc :: u0 -> u0 -> (u0, u0)) (ud :: u0 -> Bool) (ue :: u0 -> Bool) (uf :: u0 -> Integer) (ug :: u0 -> Int) -> _APP_ uf [ u4 ]; _NO_DEFLT_ }} in case u3 of { _ALG_ _TUP_10 (ui :: {{Eq u1}}) (uj :: {{Text u1}}) (uk :: u1 -> u1 -> u1) (ul :: u1 -> u1 -> u1) (um :: u1 -> u1 -> u1) (un :: u1 -> u1) (uo :: u1 -> u1) (up :: u1 -> u1) (uq :: Integer -> u1) (ur :: Int -> u1) -> _APP_ uq [ uh ]; _NO_DEFLT_ } _SPECIALISE_ [ Int, Double ] 2 { _A_ 1 _U_ 1 _N_ _S_ "U(P)" {_A_ 1 _U_ 2 _N_ _N_ _F_ _IF_ARGS_ 0 1 X 3 \ (u0 :: Int#) -> case _#_ int2Double# [] [u0] of { _PRIM_ (u1 :: Double#) -> _!_ D# [] [u1] } _N_} _F_ _IF_ARGS_ 0 1 C 4 \ (u0 :: Int) -> case u0 of { _ALG_ I# (u1 :: Int#) -> case _#_ int2Double# [] [u1] of { _PRIM_ (u2 :: Double#) -> _!_ D# [] [u2] }; _NO_DEFLT_ } _N_ }, [ Int, Float ] 2 { _A_ 1 _U_ 1 _N_ _S_ "U(P)" {_A_ 1 _U_ 2 _N_ _N_ _F_ _IF_ARGS_ 0 1 X 3 \ (u0 :: Int#) -> case _#_ int2Float# [] [u0] of { _PRIM_ (u1 :: Float#) -> _!_ F# [] [u1] } _N_} _F_ _IF_ARGS_ 0 1 C 4 \ (u0 :: Int) -> case u0 of { _ALG_ I# (u1 :: Int#) -> case _#_ int2Float# [] [u1] of { _PRIM_ (u2 :: Float#) -> _!_ F# [] [u2] }; _NO_DEFLT_ } _N_ }, [ Int, Int ] 2 { _A_ 1 _U_ 1 _N_ _N_ _F_ _IF_ARGS_ 0 0 X 1 _TYAPP_ _ORIG_ Prelude id { Int } _N_ }, [ Int, Integer ] 2 { _A_ 1 _U_ 1 _N_ _S_ "U(P)" {_A_ 1 _U_ 2 _N_ _N_ _F_ _IF_ARGS_ 0 1 X 1 \ (u0 :: Int#) -> _#_ int2Integer# [] [u0] _N_} _F_ _IF_ARGS_ 0 1 C 2 \ (u0 :: Int) -> case u0 of { _ALG_ I# (u1 :: Int#) -> _#_ int2Integer# [] [u1]; _NO_DEFLT_ } _N_ }, [ Int, (Ratio Integer) ] 2 { _A_ 1 _U_ 1 _N_ _N_ _N_ _N_ }, [ Integer, Double ] 2 { _A_ 1 _U_ 1 _N_ _S_ "U(PPP)" {_A_ 3 _U_ 222 _N_ _N_ _F_ _IF_ARGS_ 0 3 XXX 3 \ (u0 :: Int#) (u1 :: Int#) (u2 :: ByteArray#) -> case _#_ encodeDouble# [] [u0, u1, u2, 0#] of { _PRIM_ (u3 :: Double#) -> _!_ D# [] [u3] } _N_} _F_ _IF_ARGS_ 0 1 C 4 \ (u0 :: Integer) -> case u0 of { _ALG_ J# (u1 :: Int#) (u2 :: Int#) (u3 :: ByteArray#) -> case _#_ encodeDouble# [] [u1, u2, u3, 0#] of { _PRIM_ (u4 :: Double#) -> _!_ D# [] [u4] }; _NO_DEFLT_ } _N_ }, [ Integer, Float ] 2 { _A_ 1 _U_ 1 _N_ _S_ "U(PPP)" {_A_ 3 _U_ 222 _N_ _N_ _F_ _IF_ARGS_ 0 3 XXX 3 \ (u0 :: Int#) (u1 :: Int#) (u2 :: ByteArray#) -> case _#_ encodeFloat# [] [u0, u1, u2, 0#] of { _PRIM_ (u3 :: Float#) -> _!_ F# [] [u3] } _N_} _F_ _IF_ARGS_ 0 1 C 4 \ (u0 :: Integer) -> case u0 of { _ALG_ J# (u1 :: Int#) (u2 :: Int#) (u3 :: ByteArray#) -> case _#_ encodeFloat# [] [u1, u2, u3, 0#] of { _PRIM_ (u4 :: Float#) -> _!_ F# [] [u4] }; _NO_DEFLT_ } _N_ }, [ Integer, Int ] 2 { _A_ 1 _U_ 1 _N_ _S_ "U(PPP)" {_A_ 3 _U_ 222 _N_ _N_ _F_ _IF_ARGS_ 0 3 XXX 3 \ (u0 :: Int#) (u1 :: Int#) (u2 :: ByteArray#) -> case _#_ integer2Int# [] [u0, u1, u2] of { _PRIM_ (u3 :: Int#) -> _!_ I# [] [u3] } _N_} _F_ _IF_ARGS_ 0 1 C 4 \ (u0 :: Integer) -> case u0 of { _ALG_ J# (u1 :: Int#) (u2 :: Int#) (u3 :: ByteArray#) -> case _#_ integer2Int# [] [u1, u2, u3] of { _PRIM_ (u4 :: Int#) -> _!_ I# [] [u4] }; _NO_DEFLT_ } _N_ }, [ Integer, Integer ] 2 { _A_ 1 _U_ 1 _N_ _N_ _F_ _IF_ARGS_ 0 0 X 1 _TYAPP_ _ORIG_ Prelude id { Integer } _N_ }, [ Integer, (Ratio Integer) ] 2 { _A_ 1 _U_ 2 _N_ _N_ _F_ _IF_ARGS_ 0 1 X 3 \ (u0 :: Integer) -> _!_ (:%) [Integer] [u0, _SPEC_ _ORIG_ PreludeCore __i1 [ (Integer) ]] _N_ } #-}
fromRealFrac :: (RealFrac a, Fractional b) => a -> b
- {-# GHC_PRAGMA _A_ 3 _U_ 112 _N_ _S_ "LU(AAAS)L" {_A_ 3 _U_ 112 _N_ _N_ _F_ _IF_ARGS_ 2 3 CXX 7 _/\_ u0 u1 -> \ (u2 :: {{RealFrac u0}}) (u3 :: Ratio Integer -> u1) (u4 :: u0) -> let {(uf :: Ratio Integer) = case u2 of { _ALG_ _TUP_7 (u5 :: {{Real u0}}) (u6 :: {{Fractional u0}}) (u7 :: _forall_ a$z1 =>{{Integral a$z1}} -> u0 -> (a$z1, u0)) (u8 :: _forall_ a$z1 =>{{Integral a$z1}} -> u0 -> a$z1) (u9 :: _forall_ a$z1 =>{{Integral a$z1}} -> u0 -> a$z1) (ua :: _forall_ a$z1 =>{{Integral a$z1}} -> u0 -> a$z1) (ub :: _forall_ a$z1 =>{{Integral a$z1}} -> u0 -> a$z1) -> case u5 of { _ALG_ _TUP_3 (uc :: {{Num u0}}) (ud :: {{Enum u0}}) (ue :: u0 -> Ratio Integer) -> _APP_ ue [ u4 ]; _NO_DEFLT_ }; _NO_DEFLT_ }} in _APP_ u3 [ uf ] _N_} _F_ _IF_ARGS_ 2 3 CCX 8 _/\_ u0 u1 -> \ (u2 :: {{RealFrac u0}}) (u3 :: {{Fractional u1}}) (u4 :: u0) -> let {(uf :: Ratio Integer) = case u2 of { _ALG_ _TUP_7 (u5 :: {{Real u0}}) (u6 :: {{Fractional u0}}) (u7 :: _forall_ a$z1 =>{{Integral a$z1}} -> u0 -> (a$z1, u0)) (u8 :: _forall_ a$z1 =>{{Integral a$z1}} -> u0 -> a$z1) (u9 :: _forall_ a$z1 =>{{Integral a$z1}} -> u0 -> a$z1) (ua :: _forall_ a$z1 =>{{Integral a$z1}} -> u0 -> a$z1) (ub :: _forall_ a$z1 =>{{Integral a$z1}} -> u0 -> a$z1) -> case u5 of { _ALG_ _TUP_3 (uc :: {{Num u0}}) (ud :: {{Enum u0}}) (ue :: u0 -> Ratio Integer) -> _APP_ ue [ u4 ]; _NO_DEFLT_ }; _NO_DEFLT_ }} in case u3 of { _ALG_ _TUP_4 (ug :: {{Num u1}}) (uh :: u1 -> u1 -> u1) (ui :: u1 -> u1) (uj :: Ratio Integer -> u1) -> _APP_ uj [ uf ]; _NO_DEFLT_ } _SPECIALISE_ [ Double, Double ] 2 { _A_ 1 _U_ 1 _N_ _N_ _F_ _IF_ARGS_ 0 0 X 1 _TYAPP_ _ORIG_ Prelude id { Double } _N_ }, [ Double, Float ] 2 { _A_ 1 _U_ 1 _N_ _S_ "U(P)" {_A_ 1 _U_ 2 _N_ _N_ _F_ _IF_ARGS_ 0 1 X 3 \ (u0 :: Double#) -> case _#_ double2Float# [] [u0] of { _PRIM_ (u1 :: Float#) -> _!_ F# [] [u1] } _N_} _F_ _IF_ARGS_ 0 1 C 4 \ (u0 :: Double) -> case u0 of { _ALG_ D# (u1 :: Double#) -> case _#_ double2Float# [] [u1] of { _PRIM_ (u2 :: Float#) -> _!_ F# [] [u2] }; _NO_DEFLT_ } _N_ }, [ Float, Double ] 2 { _A_ 1 _U_ 1 _N_ _S_ "U(P)" {_A_ 1 _U_ 2 _N_ _N_ _F_ _IF_ARGS_ 0 1 X 3 \ (u0 :: Float#) -> case _#_ float2Double# [] [u0] of { _PRIM_ (u1 :: Double#) -> _!_ D# [] [u1] } _N_} _F_ _IF_ARGS_ 0 1 C 4 \ (u0 :: Float) -> case u0 of { _ALG_ F# (u1 :: Float#) -> case _#_ float2Double# [] [u1] of { _PRIM_ (u2 :: Double#) -> _!_ D# [] [u2] }; _NO_DEFLT_ } _N_ }, [ Float, Float ] 2 { _A_ 1 _U_ 1 _N_ _N_ _F_ _IF_ARGS_ 0 0 X 1 _TYAPP_ _ORIG_ Prelude id { Float } _N_ } #-}
+ {-# GHC_PRAGMA _A_ 3 _U_ 112 _N_ _S_ "LU(AAAS)L" {_A_ 3 _U_ 112 _N_ _N_ _F_ _IF_ARGS_ 2 3 CXX 7 _/\_ u0 u1 -> \ (u2 :: {{RealFrac u0}}) (u3 :: Ratio Integer -> u1) (u4 :: u0) -> let {(uf :: Ratio Integer) = case u2 of { _ALG_ _TUP_7 (u5 :: {{Real u0}}) (u6 :: {{Fractional u0}}) (u7 :: _forall_ a$z1 =>{{Integral a$z1}} -> u0 -> (a$z1, u0)) (u8 :: _forall_ a$z1 =>{{Integral a$z1}} -> u0 -> a$z1) (u9 :: _forall_ a$z1 =>{{Integral a$z1}} -> u0 -> a$z1) (ua :: _forall_ a$z1 =>{{Integral a$z1}} -> u0 -> a$z1) (ub :: _forall_ a$z1 =>{{Integral a$z1}} -> u0 -> a$z1) -> case u5 of { _ALG_ _TUP_3 (uc :: {{Num u0}}) (ud :: {{Enum u0}}) (ue :: u0 -> Ratio Integer) -> _APP_ ue [ u4 ]; _NO_DEFLT_ }; _NO_DEFLT_ }} in _APP_ u3 [ uf ] _N_} _F_ _IF_ARGS_ 2 3 CCX 8 _/\_ u0 u1 -> \ (u2 :: {{RealFrac u0}}) (u3 :: {{Fractional u1}}) (u4 :: u0) -> let {(uf :: Ratio Integer) = case u2 of { _ALG_ _TUP_7 (u5 :: {{Real u0}}) (u6 :: {{Fractional u0}}) (u7 :: _forall_ a$z1 =>{{Integral a$z1}} -> u0 -> (a$z1, u0)) (u8 :: _forall_ a$z1 =>{{Integral a$z1}} -> u0 -> a$z1) (u9 :: _forall_ a$z1 =>{{Integral a$z1}} -> u0 -> a$z1) (ua :: _forall_ a$z1 =>{{Integral a$z1}} -> u0 -> a$z1) (ub :: _forall_ a$z1 =>{{Integral a$z1}} -> u0 -> a$z1) -> case u5 of { _ALG_ _TUP_3 (uc :: {{Num u0}}) (ud :: {{Enum u0}}) (ue :: u0 -> Ratio Integer) -> _APP_ ue [ u4 ]; _NO_DEFLT_ }; _NO_DEFLT_ }} in case u3 of { _ALG_ _TUP_4 (ug :: {{Num u1}}) (uh :: u1 -> u1 -> u1) (ui :: u1 -> u1) (uj :: Ratio Integer -> u1) -> _APP_ uj [ uf ]; _NO_DEFLT_ } _SPECIALISE_ [ Double, Double ] 2 { _A_ 1 _U_ 1 _N_ _N_ _F_ _IF_ARGS_ 0 0 X 1 _TYAPP_ _ORIG_ Prelude id { Double } _N_ }, [ Double, Float ] 2 { _A_ 1 _U_ 1 _N_ _S_ "U(P)" {_A_ 1 _U_ 2 _N_ _N_ _F_ _IF_ARGS_ 0 1 X 3 \ (u0 :: Double#) -> case _#_ double2Float# [] [u0] of { _PRIM_ (u1 :: Float#) -> _!_ F# [] [u1] } _N_} _F_ _IF_ARGS_ 0 1 C 4 \ (u0 :: Double) -> case u0 of { _ALG_ D# (u1 :: Double#) -> case _#_ double2Float# [] [u1] of { _PRIM_ (u2 :: Float#) -> _!_ F# [] [u2] }; _NO_DEFLT_ } _N_ }, [ Double, (Ratio Integer) ] 2 { _A_ 1 _U_ 1 _N_ _S_ "U(P)" {_A_ 1 _U_ 2 _N_ _N_ _N_ _N_} _N_ _N_ }, [ Float, Double ] 2 { _A_ 1 _U_ 1 _N_ _S_ "U(P)" {_A_ 1 _U_ 2 _N_ _N_ _F_ _IF_ARGS_ 0 1 X 3 \ (u0 :: Float#) -> case _#_ float2Double# [] [u0] of { _PRIM_ (u1 :: Double#) -> _!_ D# [] [u1] } _N_} _F_ _IF_ARGS_ 0 1 C 4 \ (u0 :: Float) -> case u0 of { _ALG_ F# (u1 :: Float#) -> case _#_ float2Double# [] [u1] of { _PRIM_ (u2 :: Double#) -> _!_ D# [] [u2] }; _NO_DEFLT_ } _N_ }, [ Float, Float ] 2 { _A_ 1 _U_ 1 _N_ _N_ _F_ _IF_ARGS_ 0 0 X 1 _TYAPP_ _ORIG_ Prelude id { Float } _N_ }, [ Float, (Ratio Integer) ] 2 { _A_ 1 _U_ 1 _N_ _S_ "U(P)" {_A_ 1 _U_ 2 _N_ _N_ _N_ _N_} _N_ _N_ }, [ (Ratio Integer), Double ] 2 { _A_ 1 _U_ 1 _N_ _S_ "U(U(PPP)U(PPP))" {_A_ 4 _U_ 2222 _N_ _N_ _N_ _N_} _N_ _N_ }, [ (Ratio Integer), Float ] 2 { _A_ 1 _U_ 2 _N_ _N_ _F_ _IF_ARGS_ 0 0 X 1 _CONSTM_ Fractional fromRational (Float) _N_ }, [ (Ratio Integer), (Ratio Integer) ] 2 { _A_ 1 _U_ 1 _N_ _N_ _F_ _IF_ARGS_ 0 0 X 1 _TYAPP_ _ORIG_ Prelude id { (Ratio Integer) } _N_ } #-}
fst :: (b, a) -> b
{-# GHC_PRAGMA _A_ 1 _U_ 1 _N_ _S_ "U(SA)" {_A_ 1 _U_ 1 _N_ _N_ _F_ _IF_ARGS_ 2 1 X 1 _/\_ u0 u1 -> \ (u2 :: u1) -> u2 _N_} _F_ _IF_ARGS_ 2 1 C 2 _/\_ u0 u1 -> \ (u2 :: (u1, u0)) -> case u2 of { _ALG_ _TUP_2 (u3 :: u1) (u4 :: u0) -> u3; _NO_DEFLT_ } _N_ #-}
gcd :: Integral a => a -> a -> a
isLower :: Char -> Bool
{-# GHC_PRAGMA _A_ 1 _U_ 1 _N_ _S_ "U(P)" {_A_ 1 _U_ 2 _N_ _N_ _N_ _N_} _N_ _N_ #-}
isNullBin :: Bin -> Bool
- {-# GHC_PRAGMA _A_ 1 _U_ 2 _N_ _S_ _!_ _F_ _IF_ARGS_ 0 1 X 3 \ (u0 :: Bin) -> _APP_ _TYAPP_ error { (Bin -> Bool) } [ _NOREP_S_ "isNullBin{Prelude}\n", u0 ] _N_ #-}
+ {-# GHC_PRAGMA _A_ 1 _U_ 2 _N_ _S_ _!_ _N_ _N_ #-}
isPrint :: Char -> Bool
{-# GHC_PRAGMA _A_ 1 _U_ 1 _N_ _S_ "U(P)" {_A_ 1 _U_ 2 _N_ _N_ _N_ _N_} _N_ _N_ #-}
isSpace :: Char -> Bool
not :: Bool -> Bool
{-# GHC_PRAGMA _A_ 1 _U_ 1 _N_ _S_ "E" _F_ _ALWAYS_ \ (u0 :: Bool) -> case u0 of { _ALG_ True -> _!_ False [] []; False -> _!_ True [] []; _NO_DEFLT_ } _N_ #-}
nullBin :: Bin
- {-# GHC_PRAGMA _A_ 0 _N_ _N_ _S_ _!_ _F_ _IF_ARGS_ 0 0 X 2 _APP_ _TYAPP_ error { Bin } [ _NOREP_S_ "nullBin{Prelude}\n" ] _N_ #-}
+ {-# GHC_PRAGMA _A_ 0 _N_ _N_ _S_ _!_ _N_ _N_ #-}
ord :: Char -> Int
{-# GHC_PRAGMA _A_ 1 _U_ 1 _N_ _S_ "U(P)" {_A_ 1 _U_ 2 _N_ _N_ _F_ _IF_ARGS_ 0 1 X 3 \ (u0 :: Char#) -> case _#_ ord# [] [u0] of { _PRIM_ (u1 :: Int#) -> _!_ I# [] [u1] } _N_} _F_ _IF_ARGS_ 0 1 C 4 \ (u0 :: Char) -> case u0 of { _ALG_ C# (u1 :: Char#) -> case _#_ ord# [] [u1] of { _PRIM_ (u2 :: Int#) -> _!_ I# [] [u2] }; _NO_DEFLT_ } _N_ #-}
otherwise :: Bool
snd :: (a, b) -> b
{-# GHC_PRAGMA _A_ 1 _U_ 1 _N_ _S_ "U(AS)" {_A_ 1 _U_ 1 _N_ _N_ _F_ _IF_ARGS_ 2 1 X 1 _/\_ u0 u1 -> \ (u2 :: u1) -> u2 _N_} _F_ _IF_ARGS_ 2 1 C 2 _/\_ u0 u1 -> \ (u2 :: (u0, u1)) -> case u2 of { _ALG_ _TUP_2 (u3 :: u0) (u4 :: u1) -> u4; _NO_DEFLT_ } _N_ #-}
subtract :: Num a => a -> a -> a
- {-# GHC_PRAGMA _A_ 3 _U_ 122 _N_ _S_ "U(AAASAAAAAA)LL" {_A_ 3 _U_ 122 _N_ _N_ _F_ _IF_ARGS_ 1 3 XXX 3 _/\_ u0 -> \ (u1 :: u0 -> u0 -> u0) (u2 :: u0) (u3 :: u0) -> _APP_ u1 [ u3, u2 ] _N_} _F_ _IF_ARGS_ 1 3 CXX 4 _/\_ u0 -> \ (u1 :: {{Num u0}}) (u2 :: u0) (u3 :: u0) -> case u1 of { _ALG_ _TUP_10 (u4 :: {{Eq u0}}) (u5 :: {{Text u0}}) (u6 :: u0 -> u0 -> u0) (u7 :: u0 -> u0 -> u0) (u8 :: u0 -> u0 -> u0) (u9 :: u0 -> u0) (ua :: u0 -> u0) (ub :: u0 -> u0) (uc :: Integer -> u0) (ud :: Int -> u0) -> _APP_ u7 [ u3, u2 ]; _NO_DEFLT_ } _SPECIALISE_ [ Double ] 1 { _A_ 2 _U_ 11 _N_ _S_ "U(P)U(P)" {_A_ 2 _U_ 22 _N_ _N_ _F_ _IF_ARGS_ 0 2 XX 3 \ (u0 :: Double#) (u1 :: Double#) -> case _#_ minusDouble# [] [u1, u0] of { _PRIM_ (u2 :: Double#) -> _!_ D# [] [u2] } _N_} _F_ _IF_ARGS_ 0 2 CC 5 \ (u0 :: Double) (u1 :: Double) -> case u1 of { _ALG_ D# (u2 :: Double#) -> case u0 of { _ALG_ D# (u3 :: Double#) -> case _#_ minusDouble# [] [u2, u3] of { _PRIM_ (u4 :: Double#) -> _!_ D# [] [u4] }; _NO_DEFLT_ }; _NO_DEFLT_ } _N_ }, [ Int ] 1 { _A_ 2 _U_ 11 _N_ _S_ "U(P)U(P)" {_A_ 2 _U_ 22 _N_ _N_ _F_ _IF_ARGS_ 0 2 XX 3 \ (u0 :: Int#) (u1 :: Int#) -> case _#_ minusInt# [] [u1, u0] of { _PRIM_ (u2 :: Int#) -> _!_ I# [] [u2] } _N_} _F_ _IF_ARGS_ 0 2 CC 5 \ (u0 :: Int) (u1 :: Int) -> case u1 of { _ALG_ I# (u2 :: Int#) -> case u0 of { _ALG_ I# (u3 :: Int#) -> case _#_ minusInt# [] [u2, u3] of { _PRIM_ (u4 :: Int#) -> _!_ I# [] [u4] }; _NO_DEFLT_ }; _NO_DEFLT_ } _N_ } #-}
+ {-# GHC_PRAGMA _A_ 3 _U_ 122 _N_ _S_ "U(AAASAAAAAA)LL" {_A_ 3 _U_ 122 _N_ _N_ _F_ _IF_ARGS_ 1 3 XXX 3 _/\_ u0 -> \ (u1 :: u0 -> u0 -> u0) (u2 :: u0) (u3 :: u0) -> _APP_ u1 [ u3, u2 ] _N_} _F_ _IF_ARGS_ 1 3 CXX 4 _/\_ u0 -> \ (u1 :: {{Num u0}}) (u2 :: u0) (u3 :: u0) -> case u1 of { _ALG_ _TUP_10 (u4 :: {{Eq u0}}) (u5 :: {{Text u0}}) (u6 :: u0 -> u0 -> u0) (u7 :: u0 -> u0 -> u0) (u8 :: u0 -> u0 -> u0) (u9 :: u0 -> u0) (ua :: u0 -> u0) (ub :: u0 -> u0) (uc :: Integer -> u0) (ud :: Int -> u0) -> _APP_ u7 [ u3, u2 ]; _NO_DEFLT_ } _SPECIALISE_ [ Double ] 1 { _A_ 2 _U_ 11 _N_ _S_ "U(P)U(P)" {_A_ 2 _U_ 22 _N_ _N_ _F_ _IF_ARGS_ 0 2 XX 3 \ (u0 :: Double#) (u1 :: Double#) -> case _#_ minusDouble# [] [u1, u0] of { _PRIM_ (u2 :: Double#) -> _!_ D# [] [u2] } _N_} _F_ _IF_ARGS_ 0 2 CC 5 \ (u0 :: Double) (u1 :: Double) -> case u1 of { _ALG_ D# (u2 :: Double#) -> case u0 of { _ALG_ D# (u3 :: Double#) -> case _#_ minusDouble# [] [u2, u3] of { _PRIM_ (u4 :: Double#) -> _!_ D# [] [u4] }; _NO_DEFLT_ }; _NO_DEFLT_ } _N_ }, [ Int ] 1 { _A_ 2 _U_ 11 _N_ _S_ "U(P)U(P)" {_A_ 2 _U_ 22 _N_ _N_ _F_ _IF_ARGS_ 0 2 XX 3 \ (u0 :: Int#) (u1 :: Int#) -> case _#_ minusInt# [] [u1, u0] of { _PRIM_ (u2 :: Int#) -> _!_ I# [] [u2] } _N_} _F_ _IF_ARGS_ 0 2 CC 5 \ (u0 :: Int) (u1 :: Int) -> case u1 of { _ALG_ I# (u2 :: Int#) -> case u0 of { _ALG_ I# (u3 :: Int#) -> case _#_ minusInt# [] [u2, u3] of { _PRIM_ (u4 :: Int#) -> _!_ I# [] [u4] }; _NO_DEFLT_ }; _NO_DEFLT_ } _N_ }, [ (Complex Double) ] 1 { _A_ 2 _U_ 11 _N_ _S_ "U(LL)U(LL)" {_A_ 4 _U_ 2222 _N_ _N_ _N_ _N_} _N_ _N_ } #-}
thenMaybe :: Maybe a -> (a -> Maybe b) -> Maybe b
{-# GHC_PRAGMA _A_ 2 _U_ 11 _N_ _S_ "SL" _F_ _IF_ARGS_ 2 2 CX 5 _/\_ u0 u1 -> \ (u2 :: Maybe u0) (u3 :: u0 -> Maybe u1) -> case u2 of { _ALG_ Nothing -> _!_ Nothing [u1] []; Just (u4 :: u0) -> _APP_ u3 [ u4 ]; _NO_DEFLT_ } _N_ #-}
toLower :: Char -> Char
imagPart :: Complex a -> a
{-# GHC_PRAGMA _A_ 1 _U_ 1 _N_ _S_ "U(AS)" {_A_ 1 _U_ 1 _N_ _N_ _F_ _IF_ARGS_ 1 1 X 1 _/\_ u0 -> \ (u1 :: u0) -> u1 _N_} _F_ _IF_ARGS_ 1 1 C 2 _/\_ u0 -> \ (u1 :: Complex u0) -> case u1 of { _ALG_ (:+) (u2 :: u0) (u3 :: u0) -> u3; _NO_DEFLT_ } _N_ #-}
magnitude :: RealFloat a => Complex a -> a
- {-# GHC_PRAGMA _A_ 1 _U_ 12 _N_ _S_ "U(ALAAAAALAS)" {_A_ 3 _U_ 2221 _N_ _N_ _N_ _N_} _N_ _SPECIALISE_ [ Double ] 1 { _A_ 1 _U_ 1 _N_ _S_ "U(LL)" {_A_ 2 _U_ 22 _N_ _N_ _N_ _N_} _N_ _N_ } #-}
+ {-# GHC_PRAGMA _A_ 1 _U_ 12 _N_ _S_ "U(ALAAAAALAS)" {_A_ 3 _U_ 2221 _N_ _N_ _N_ _N_} _N_ _SPECIALISE_ [ Double ] 1 { _A_ 1 _U_ 1 _N_ _S_ "U(U(P)U(P))" {_A_ 2 _U_ 22 _N_ _N_ _N_ _N_} _N_ _N_ } #-}
mkPolar :: RealFloat a => a -> a -> Complex a
{-# GHC_PRAGMA _A_ 3 _U_ 122 _N_ _N_ _N_ _SPECIALISE_ [ Double ] 1 { _A_ 2 _U_ 22 _N_ _N_ _N_ _N_ } #-}
phase :: RealFloat a => Complex a -> a
{-# GHC_PRAGMA _A_ 1 _U_ 22 _N_ _N_ _N_ _SPECIALISE_ [ Double ] 1 { _A_ 1 _U_ 2 _N_ _N_ _N_ _N_ } #-}
realPart :: Complex a -> a
{-# GHC_PRAGMA _A_ 1 _U_ 1 _N_ _S_ "U(SA)" {_A_ 1 _U_ 1 _N_ _N_ _F_ _IF_ARGS_ 1 1 X 1 _/\_ u0 -> \ (u1 :: u0) -> u1 _N_} _F_ _IF_ARGS_ 1 1 C 2 _/\_ u0 -> \ (u1 :: Complex u0) -> case u1 of { _ALG_ (:+) (u2 :: u0) (u3 :: u0) -> u2; _NO_DEFLT_ } _N_ #-}
-_ceiling :: (RealFrac a, Integral b) => a -> b
- {-# GHC_PRAGMA _A_ 2 _U_ 122 _N_ _S_ "U(U(AU(U(AAAASAAA)AAAA)A)LSAAAA)L" {_A_ 4 _U_ 11122 _N_ _N_ _N_ _N_} _N_ _SPECIALISE_ [ Double, Int ] 2 { _A_ 0 _U_ 2 _N_ _N_ _N_ _N_ } #-}
-_floor :: (RealFrac a, Integral b) => a -> b
- {-# GHC_PRAGMA _A_ 2 _U_ 122 _N_ _S_ "U(U(AU(U(ASAAAAAA)AAAA)A)LSAAAA)L" {_A_ 4 _U_ 11122 _N_ _N_ _N_ _N_} _N_ _SPECIALISE_ [ Double, Int ] 2 { _A_ 0 _U_ 2 _N_ _N_ _N_ _N_ } #-}
-_readList :: Text a => [Char] -> [([a], [Char])]
+_readList :: ([Char] -> [(a, [Char])]) -> [Char] -> [([a], [Char])]
{-# GHC_PRAGMA _A_ 1 _U_ 22 _N_ _N_ _N_ _N_ #-}
-_round :: (RealFrac a, Integral b) => a -> b
- {-# GHC_PRAGMA _A_ 2 _U_ 122 _N_ _S_ "U(U(AU(U(ALAAAAAS)AAAA)A)LSAAAA)L" {_A_ 5 _U_ 112122 _N_ _N_ _N_ _N_} _N_ _SPECIALISE_ [ Double, Int ] 2 { _A_ 0 _U_ 2 _N_ _N_ _N_ _N_ }, [ (Ratio Integer), Integer ] 2 { _A_ 1 _U_ 1 _N_ _S_ "U(LL)" {_A_ 2 _U_ 22 _N_ _N_ _N_ _N_} _N_ _N_ } #-}
-_showList :: Text a => [a] -> [Char] -> [Char]
- {-# GHC_PRAGMA _A_ 1 _U_ 212 _N_ _N_ _N_ _N_ #-}
+_showList :: (a -> [Char] -> [Char]) -> [a] -> [Char] -> [Char]
+ {-# GHC_PRAGMA _A_ 2 _U_ 212 _N_ _S_ "LS" _N_ _N_ #-}
_showRational :: Int -> Ratio Integer -> [Char]
{-# GHC_PRAGMA _A_ 2 _U_ 21 _N_ _S_ "LU(U(PPP)L)" {_A_ 5 _U_ 22222 _N_ _N_ _N_ _N_} _N_ _N_ #-}
-_truncate :: (RealFrac a, Integral b) => a -> b
- {-# GHC_PRAGMA _A_ 2 _U_ 122 _N_ _S_ "U(AASAAAA)L" {_A_ 2 _U_ 122 _N_ _N_ _N_ _N_} _N_ _SPECIALISE_ [ Double, Int ] 2 { _A_ 0 _U_ 2 _N_ _N_ _N_ _N_ } #-}
interact :: ([Char] -> [Char]) -> _State _RealWorld -> (Either IOError13 (), _State _RealWorld)
{-# GHC_PRAGMA _A_ 2 _U_ 11 _N_ _S_ "LU(P)" {_A_ 2 _U_ 12 _N_ _N_ _N_ _N_} _N_ _N_ #-}
(!!) :: Integral a => [b] -> a -> b
(++) :: [a] -> [a] -> [a]
{-# GHC_PRAGMA _A_ 2 _U_ 12 _N_ _S_ "SL" _N_ _N_ #-}
(\\) :: Eq a => [a] -> [a] -> [a]
- {-# GHC_PRAGMA _A_ 3 _U_ 122 _N_ _S_ "LLS" _N_ _N_ #-}
+ {-# GHC_PRAGMA _A_ 3 _U_ 122 _N_ _S_ "LLS" _N_ _SPECIALISE_ [ Int ] 1 { _A_ 2 _U_ 22 _N_ _S_ "LS" _N_ _N_ }, [ [Char] ] 1 { _A_ 2 _U_ 22 _N_ _S_ "LS" _N_ _N_ } #-}
all :: (a -> Bool) -> [a] -> Bool
{-# GHC_PRAGMA _A_ 2 _U_ 21 _N_ _S_ "LS" _F_ _ALWAYS_ _/\_ u0 -> \ (u1 :: u0 -> Bool) (u2 :: [u0]) -> let {(u3 :: Bool) = _!_ True [] []} in let {(u6 :: u0 -> Bool -> Bool) = \ (u4 :: u0) (u5 :: Bool) -> case _APP_ u1 [ u4 ] of { _ALG_ True -> u5; False -> _!_ False [] []; _NO_DEFLT_ }} in _APP_ _TYAPP_ _TYAPP_ foldr { u0 } { Bool } [ u6, u3, u2 ] _N_ #-}
and :: [Bool] -> Bool
dropWhile :: (a -> Bool) -> [a] -> [a]
{-# GHC_PRAGMA _A_ 2 _U_ 21 _N_ _S_ "LS" _N_ _N_ #-}
elem :: Eq a => a -> [a] -> Bool
- {-# GHC_PRAGMA _A_ 3 _U_ 121 _N_ _S_ "LLS" _F_ _ALWAYS_ _/\_ u0 -> \ (u1 :: {{Eq u0}}) (u2 :: u0) (u3 :: [u0]) -> let {(u6 :: u0 -> u0 -> Bool) = case u1 of { _ALG_ _TUP_2 (u4 :: u0 -> u0 -> Bool) (u5 :: u0 -> u0 -> Bool) -> u4; _NO_DEFLT_ }} in let {(u8 :: u0 -> Bool) = \ (u7 :: u0) -> _APP_ u6 [ u2, u7 ]} in _APP_ _TYAPP_ _ORIG_ PreludeList any { u0 } [ u8, u3 ] _SPECIALISE_ [ Char ] 1 { _A_ 2 _U_ 21 _N_ _S_ "LS" _F_ _ALWAYS_ \ (u0 :: Char) (u1 :: [Char]) -> let {(u5 :: Char -> Bool) = \ (u2 :: Char) -> case u0 of { _ALG_ C# (u3 :: Char#) -> case u2 of { _ALG_ C# (u4 :: Char#) -> _#_ eqChar# [] [u3, u4]; _NO_DEFLT_ }; _NO_DEFLT_ }} in _APP_ _TYAPP_ _ORIG_ PreludeList any { Char } [ u5, u1 ] _N_ }, [ Int ] 1 { _A_ 2 _U_ 21 _N_ _S_ "LS" _F_ _ALWAYS_ \ (u0 :: Int) (u1 :: [Int]) -> let {(u5 :: Int -> Bool) = \ (u2 :: Int) -> case u0 of { _ALG_ I# (u3 :: Int#) -> case u2 of { _ALG_ I# (u4 :: Int#) -> _#_ eqInt# [] [u3, u4]; _NO_DEFLT_ }; _NO_DEFLT_ }} in _APP_ _TYAPP_ _ORIG_ PreludeList any { Int } [ u5, u1 ] _N_ }, [ [Char] ] 1 { _A_ 2 _U_ 21 _N_ _S_ "LS" _F_ _ALWAYS_ \ (u0 :: [Char]) (u1 :: [[Char]]) -> let {(u3 :: [Char] -> Bool) = \ (u2 :: [Char]) -> _APP_ _CONSTM_ Eq (==) ([Char]) [ u0, u2 ]} in _APP_ _TYAPP_ _ORIG_ PreludeList any { [Char] } [ u3, u1 ] _N_ } #-}
+ {-# GHC_PRAGMA _A_ 3 _U_ 121 _N_ _S_ "LLS" _F_ _ALWAYS_ _/\_ u0 -> \ (u1 :: {{Eq u0}}) (u2 :: u0) (u3 :: [u0]) -> let {(u6 :: u0 -> u0 -> Bool) = case u1 of { _ALG_ _TUP_2 (u4 :: u0 -> u0 -> Bool) (u5 :: u0 -> u0 -> Bool) -> u4; _NO_DEFLT_ }} in let {(u8 :: u0 -> Bool) = \ (u7 :: u0) -> _APP_ u6 [ u2, u7 ]} in _APP_ _TYAPP_ _ORIG_ PreludeList any { u0 } [ u8, u3 ] _SPECIALISE_ [ Char ] 1 { _A_ 2 _U_ 21 _N_ _S_ "LS" _F_ _ALWAYS_ \ (u0 :: Char) (u1 :: [Char]) -> let {(u5 :: Char -> Bool) = \ (u2 :: Char) -> case u0 of { _ALG_ C# (u3 :: Char#) -> case u2 of { _ALG_ C# (u4 :: Char#) -> _#_ eqChar# [] [u3, u4]; _NO_DEFLT_ }; _NO_DEFLT_ }} in _APP_ _TYAPP_ _ORIG_ PreludeList any { Char } [ u5, u1 ] _N_ }, [ Int ] 1 { _A_ 2 _U_ 21 _N_ _S_ "LS" _F_ _ALWAYS_ \ (u0 :: Int) (u1 :: [Int]) -> let {(u5 :: Int -> Bool) = \ (u2 :: Int) -> case u0 of { _ALG_ I# (u3 :: Int#) -> case u2 of { _ALG_ I# (u4 :: Int#) -> _#_ eqInt# [] [u3, u4]; _NO_DEFLT_ }; _NO_DEFLT_ }} in _APP_ _TYAPP_ _ORIG_ PreludeList any { Int } [ u5, u1 ] _N_ }, [ Integer ] 1 { _A_ 2 _U_ 21 _N_ _S_ "LS" _F_ _ALWAYS_ \ (u0 :: Integer) (u1 :: [Integer]) -> let {(ua :: Integer -> Bool) = \ (u2 :: Integer) -> case u0 of { _ALG_ J# (u3 :: Int#) (u4 :: Int#) (u5 :: ByteArray#) -> case u2 of { _ALG_ J# (u6 :: Int#) (u7 :: Int#) (u8 :: ByteArray#) -> case _#_ cmpInteger# [] [u3, u4, u5, u6, u7, u8] of { _PRIM_ 0# -> _!_ True [] []; (u9 :: Int#) -> _!_ False [] [] }; _NO_DEFLT_ }; _NO_DEFLT_ }} in _APP_ _TYAPP_ _ORIG_ PreludeList any { Integer } [ ua, u1 ] _N_ }, [ [Char] ] 1 { _A_ 2 _U_ 21 _N_ _S_ "LS" _F_ _ALWAYS_ \ (u0 :: [Char]) (u1 :: [[Char]]) -> let {(u3 :: [Char] -> Bool) = \ (u2 :: [Char]) -> _APP_ _CONSTM_ Eq (==) ([Char]) [ u0, u2 ]} in _APP_ _TYAPP_ _ORIG_ PreludeList any { [Char] } [ u3, u1 ] _N_ }, [ [Int] ] 1 { _A_ 2 _U_ 21 _N_ _S_ "LS" _F_ _ALWAYS_ \ (u0 :: [Int]) (u1 :: [[Int]]) -> let {(u3 :: [Int] -> Bool) = \ (u2 :: [Int]) -> _APP_ _CONSTM_ Eq (==) ([Int]) [ u0, u2 ]} in _APP_ _TYAPP_ _ORIG_ PreludeList any { [Int] } [ u3, u1 ] _N_ }, [ (Int, Int) ] 1 { _A_ 2 _U_ 21 _N_ _S_ "LS" _F_ _ALWAYS_ \ (u0 :: (Int, Int)) (u1 :: [(Int, Int)]) -> let {(ub :: (Int, Int) -> Bool) = \ (u2 :: (Int, Int)) -> case u0 of { _ALG_ _TUP_2 (u3 :: Int) (u4 :: Int) -> case u3 of { _ALG_ I# (u5 :: Int#) -> case u2 of { _ALG_ _TUP_2 (u6 :: Int) (u7 :: Int) -> case u6 of { _ALG_ I# (u8 :: Int#) -> case _#_ eqInt# [] [u5, u8] of { _ALG_ True -> case u4 of { _ALG_ I# (u9 :: Int#) -> case u7 of { _ALG_ I# (ua :: Int#) -> _#_ eqInt# [] [u9, ua]; _NO_DEFLT_ }; _NO_DEFLT_ }; False -> _!_ False [] []; _NO_DEFLT_ }; _NO_DEFLT_ }; _NO_DEFLT_ }; _NO_DEFLT_ }; _NO_DEFLT_ }} in _APP_ _TYAPP_ _ORIG_ PreludeList any { (Int, Int) } [ ub, u1 ] _N_ } #-}
filter :: (a -> Bool) -> [a] -> [a]
{-# GHC_PRAGMA _A_ 2 _U_ 21 _N_ _S_ "LS" _F_ _ALWAYS_ _/\_ u0 -> \ (u1 :: u0 -> Bool) (u2 :: [u0]) -> let {(u9 :: _forall_ a$z1 =>(u0 -> a$z1 -> a$z1) -> a$z1 -> a$z1) = _/\_ u3 -> \ (u4 :: u0 -> u3 -> u3) (u5 :: u3) -> let {(u8 :: u0 -> u3 -> u3) = \ (u6 :: u0) (u7 :: u3) -> case _APP_ u1 [ u6 ] of { _ALG_ True -> _APP_ u4 [ u6, u7 ]; False -> u7; _NO_DEFLT_ }} in _APP_ _TYAPP_ _TYAPP_ foldr { u0 } { u3 } [ u8, u5, u2 ]} in _APP_ _TYAPP_ _build { u0 } [ u9 ] _N_ #-}
foldl1 :: (a -> a -> a) -> [a] -> a
foldr1 :: (a -> a -> a) -> [a] -> a
{-# GHC_PRAGMA _A_ 2 _U_ 21 _N_ _S_ "LS" _N_ _N_ #-}
genericLength :: Num b => [a] -> b
- {-# GHC_PRAGMA _A_ 1 _U_ 21 _N_ _N_ _N_ _N_ #-}
+ {-# GHC_PRAGMA _A_ 1 _U_ 21 _N_ _N_ _N_ _SPECIALISE_ [ _N_, Int ] 1 { _A_ 1 _U_ 1 _N_ _S_ "S" _N_ _N_ }, [ _N_, Integer ] 1 { _A_ 1 _U_ 1 _N_ _S_ "S" _N_ _N_ } #-}
head :: [a] -> a
{-# GHC_PRAGMA _A_ 1 _U_ 1 _N_ _S_ "S" _F_ _ALWAYS_ _/\_ u0 -> \ (u1 :: [u0]) -> let {(u2 :: u0) = _APP_ _TYAPP_ error { u0 } [ _NOREP_S_ "head{PreludeList}: head []\n" ]} in let {(u5 :: u0 -> u0 -> u0) = \ (u3 :: u0) (u4 :: u0) -> u3} in _APP_ _TYAPP_ _TYAPP_ foldr { u0 } { u0 } [ u5, u2, u1 ] _N_ #-}
init :: [a] -> [a]
map :: (a -> b) -> [a] -> [b]
{-# GHC_PRAGMA _A_ 2 _U_ 21 _N_ _S_ "LS" _F_ _ALWAYS_ _/\_ u0 u1 -> \ (u2 :: u0 -> u1) (u3 :: [u0]) -> let {(ua :: _forall_ a$z1 =>(u1 -> a$z1 -> a$z1) -> a$z1 -> a$z1) = _/\_ u4 -> \ (u5 :: u1 -> u4 -> u4) (u6 :: u4) -> let {(u9 :: u0 -> u4 -> u4) = \ (u7 :: u0) -> let {(u8 :: u1) = _APP_ u2 [ u7 ]} in _APP_ u5 [ u8 ]} in _APP_ _TYAPP_ _TYAPP_ foldr { u0 } { u4 } [ u9, u6, u3 ]} in _APP_ _TYAPP_ _build { u1 } [ ua ] _N_ #-}
maximum :: Ord a => [a] -> a
- {-# GHC_PRAGMA _A_ 1 _U_ 11 _N_ _N_ _N_ _N_ #-}
+ {-# GHC_PRAGMA _A_ 1 _U_ 11 _N_ _N_ _N_ _SPECIALISE_ [ Double ] 1 { _A_ 1 _U_ 1 _N_ _S_ "S" _N_ _N_ }, [ Int ] 1 { _A_ 1 _U_ 1 _N_ _S_ "S" _N_ _N_ }, [ Integer ] 1 { _A_ 1 _U_ 1 _N_ _S_ "S" _N_ _N_ } #-}
minimum :: Ord a => [a] -> a
- {-# GHC_PRAGMA _A_ 1 _U_ 11 _N_ _N_ _N_ _N_ #-}
+ {-# GHC_PRAGMA _A_ 1 _U_ 11 _N_ _N_ _N_ _SPECIALISE_ [ Double ] 1 { _A_ 1 _U_ 1 _N_ _S_ "S" _N_ _N_ }, [ Int ] 1 { _A_ 1 _U_ 1 _N_ _S_ "S" _N_ _N_ }, [ Integer ] 1 { _A_ 1 _U_ 1 _N_ _S_ "S" _N_ _N_ } #-}
notElem :: Eq a => a -> [a] -> Bool
- {-# GHC_PRAGMA _A_ 3 _U_ 121 _N_ _S_ "LLS" _F_ _ALWAYS_ _/\_ u0 -> \ (u1 :: {{Eq u0}}) (u2 :: u0) (u3 :: [u0]) -> let {(u6 :: u0 -> u0 -> Bool) = case u1 of { _ALG_ _TUP_2 (u4 :: u0 -> u0 -> Bool) (u5 :: u0 -> u0 -> Bool) -> u5; _NO_DEFLT_ }} in let {(u8 :: u0 -> Bool) = \ (u7 :: u0) -> _APP_ u6 [ u2, u7 ]} in _APP_ _TYAPP_ _ORIG_ PreludeList all { u0 } [ u8, u3 ] _SPECIALISE_ [ Char ] 1 { _A_ 2 _U_ 21 _N_ _S_ "LS" _F_ _ALWAYS_ \ (u0 :: Char) (u1 :: [Char]) -> let {(u5 :: Char -> Bool) = \ (u2 :: Char) -> case u0 of { _ALG_ C# (u3 :: Char#) -> case u2 of { _ALG_ C# (u4 :: Char#) -> _#_ neChar# [] [u3, u4]; _NO_DEFLT_ }; _NO_DEFLT_ }} in _APP_ _TYAPP_ _ORIG_ PreludeList all { Char } [ u5, u1 ] _N_ }, [ Int ] 1 { _A_ 2 _U_ 21 _N_ _S_ "LS" _F_ _ALWAYS_ \ (u0 :: Int) (u1 :: [Int]) -> let {(u5 :: Int -> Bool) = \ (u2 :: Int) -> case u0 of { _ALG_ I# (u3 :: Int#) -> case u2 of { _ALG_ I# (u4 :: Int#) -> _#_ neInt# [] [u3, u4]; _NO_DEFLT_ }; _NO_DEFLT_ }} in _APP_ _TYAPP_ _ORIG_ PreludeList all { Int } [ u5, u1 ] _N_ }, [ [Char] ] 1 { _A_ 2 _U_ 21 _N_ _S_ "LS" _F_ _ALWAYS_ \ (u0 :: [Char]) (u1 :: [[Char]]) -> let {(u3 :: [Char] -> Bool) = \ (u2 :: [Char]) -> _APP_ _CONSTM_ Eq (/=) ([Char]) [ u0, u2 ]} in _APP_ _TYAPP_ _ORIG_ PreludeList all { [Char] } [ u3, u1 ] _N_ } #-}
+ {-# GHC_PRAGMA _A_ 3 _U_ 121 _N_ _S_ "LLS" _F_ _ALWAYS_ _/\_ u0 -> \ (u1 :: {{Eq u0}}) (u2 :: u0) (u3 :: [u0]) -> let {(u6 :: u0 -> u0 -> Bool) = case u1 of { _ALG_ _TUP_2 (u4 :: u0 -> u0 -> Bool) (u5 :: u0 -> u0 -> Bool) -> u5; _NO_DEFLT_ }} in let {(u8 :: u0 -> Bool) = \ (u7 :: u0) -> _APP_ u6 [ u2, u7 ]} in _APP_ _TYAPP_ _ORIG_ PreludeList all { u0 } [ u8, u3 ] _SPECIALISE_ [ Char ] 1 { _A_ 2 _U_ 21 _N_ _S_ "LS" _F_ _ALWAYS_ \ (u0 :: Char) (u1 :: [Char]) -> let {(u5 :: Char -> Bool) = \ (u2 :: Char) -> case u0 of { _ALG_ C# (u3 :: Char#) -> case u2 of { _ALG_ C# (u4 :: Char#) -> _#_ neChar# [] [u3, u4]; _NO_DEFLT_ }; _NO_DEFLT_ }} in _APP_ _TYAPP_ _ORIG_ PreludeList all { Char } [ u5, u1 ] _N_ }, [ Int ] 1 { _A_ 2 _U_ 21 _N_ _S_ "LS" _F_ _ALWAYS_ \ (u0 :: Int) (u1 :: [Int]) -> let {(u5 :: Int -> Bool) = \ (u2 :: Int) -> case u0 of { _ALG_ I# (u3 :: Int#) -> case u2 of { _ALG_ I# (u4 :: Int#) -> _#_ neInt# [] [u3, u4]; _NO_DEFLT_ }; _NO_DEFLT_ }} in _APP_ _TYAPP_ _ORIG_ PreludeList all { Int } [ u5, u1 ] _N_ }, [ Integer ] 1 { _A_ 2 _U_ 21 _N_ _S_ "LS" _F_ _ALWAYS_ \ (u0 :: Integer) (u1 :: [Integer]) -> let {(ua :: Integer -> Bool) = \ (u2 :: Integer) -> case u0 of { _ALG_ J# (u3 :: Int#) (u4 :: Int#) (u5 :: ByteArray#) -> case u2 of { _ALG_ J# (u6 :: Int#) (u7 :: Int#) (u8 :: ByteArray#) -> case _#_ cmpInteger# [] [u3, u4, u5, u6, u7, u8] of { _PRIM_ 0# -> _!_ False [] []; (u9 :: Int#) -> _!_ True [] [] }; _NO_DEFLT_ }; _NO_DEFLT_ }} in _APP_ _TYAPP_ _ORIG_ PreludeList all { Integer } [ ua, u1 ] _N_ }, [ [Char] ] 1 { _A_ 2 _U_ 21 _N_ _S_ "LS" _F_ _ALWAYS_ \ (u0 :: [Char]) (u1 :: [[Char]]) -> let {(u3 :: [Char] -> Bool) = \ (u2 :: [Char]) -> _APP_ _CONSTM_ Eq (/=) ([Char]) [ u0, u2 ]} in _APP_ _TYAPP_ _ORIG_ PreludeList all { [Char] } [ u3, u1 ] _N_ }, [ (Int, Int) ] 1 { _A_ 2 _U_ 21 _N_ _S_ "LS" _F_ _ALWAYS_ \ (u0 :: (Int, Int)) (u1 :: [(Int, Int)]) -> let {(ub :: (Int, Int) -> Bool) = \ (u2 :: (Int, Int)) -> case u0 of { _ALG_ _TUP_2 (u3 :: Int) (u4 :: Int) -> case u3 of { _ALG_ I# (u5 :: Int#) -> case u2 of { _ALG_ _TUP_2 (u6 :: Int) (u7 :: Int) -> case u6 of { _ALG_ I# (u8 :: Int#) -> case _#_ neInt# [] [u5, u8] of { _ALG_ True -> _!_ True [] []; False -> case u4 of { _ALG_ I# (u9 :: Int#) -> case u7 of { _ALG_ I# (ua :: Int#) -> _#_ neInt# [] [u9, ua]; _NO_DEFLT_ }; _NO_DEFLT_ }; _NO_DEFLT_ }; _NO_DEFLT_ }; _NO_DEFLT_ }; _NO_DEFLT_ }; _NO_DEFLT_ }} in _APP_ _TYAPP_ _ORIG_ PreludeList all { (Int, Int) } [ ub, u1 ] _N_ } #-}
nub :: Eq a => [a] -> [a]
- {-# GHC_PRAGMA _A_ 2 _U_ 11 _N_ _S_ "LS" _N_ _N_ #-}
+ {-# GHC_PRAGMA _A_ 2 _U_ 11 _N_ _S_ "LS" _N_ _SPECIALISE_ [ Int ] 1 { _A_ 1 _U_ 1 _N_ _S_ "S" _N_ _N_ }, [ [Char] ] 1 { _A_ 1 _U_ 1 _N_ _S_ "S" _N_ _N_ }, [ [Int] ] 1 { _A_ 1 _U_ 1 _N_ _S_ "S" _N_ _N_ } #-}
null :: [a] -> Bool
{-# GHC_PRAGMA _A_ 1 _U_ 1 _N_ _S_ "S" _F_ _ALWAYS_ _/\_ u0 -> \ (u1 :: [u0]) -> let {(u2 :: Bool) = _!_ True [] []} in let {(u5 :: u0 -> Bool -> Bool) = \ (u3 :: u0) (u4 :: Bool) -> _!_ False [] []} in _APP_ _TYAPP_ _TYAPP_ foldr { u0 } { Bool } [ u5, u2, u1 ] _N_ #-}
or :: [Bool] -> Bool
partition :: (a -> Bool) -> [a] -> ([a], [a])
{-# GHC_PRAGMA _A_ 2 _U_ 21 _N_ _S_ "LS" _F_ _ALWAYS_ _/\_ u0 -> \ (u1 :: u0 -> Bool) (u2 :: [u0]) -> let {(u9 :: u0 -> ([u0], [u0]) -> ([u0], [u0])) = \ (u3 :: u0) (u4 :: ([u0], [u0])) -> case u4 of { _ALG_ _TUP_2 (u5 :: [u0]) (u6 :: [u0]) -> case _APP_ u1 [ u3 ] of { _ALG_ True -> let {(u7 :: [u0]) = _!_ (:) [u0] [u3, u5]} in _!_ _TUP_2 [[u0], [u0]] [u7, u6]; False -> let {(u8 :: [u0]) = _!_ (:) [u0] [u3, u6]} in _!_ _TUP_2 [[u0], [u0]] [u5, u8]; _NO_DEFLT_ }; _NO_DEFLT_ }} in let {(ua :: [u0]) = _!_ _NIL_ [u0] []} in let {(ub :: ([u0], [u0])) = _!_ _TUP_2 [[u0], [u0]] [ua, ua]} in _APP_ _TYAPP_ _TYAPP_ foldr { u0 } { ([u0], [u0]) } [ u9, ub, u2 ] _N_ #-}
product :: Num a => [a] -> a
- {-# GHC_PRAGMA _A_ 1 _U_ 22 _N_ _N_ _F_ _ALWAYS_ _/\_ u0 -> \ (u1 :: {{Num u0}}) -> let {(uc :: u0 -> u0 -> u0) = case u1 of { _ALG_ _TUP_10 (u2 :: {{Eq u0}}) (u3 :: {{Text u0}}) (u4 :: u0 -> u0 -> u0) (u5 :: u0 -> u0 -> u0) (u6 :: u0 -> u0 -> u0) (u7 :: u0 -> u0) (u8 :: u0 -> u0) (u9 :: u0 -> u0) (ua :: Integer -> u0) (ub :: Int -> u0) -> u6; _NO_DEFLT_ }} in let {(uo :: u0) = let {(ud :: Int) = _!_ I# [] [1#]} in case u1 of { _ALG_ _TUP_10 (ue :: {{Eq u0}}) (uf :: {{Text u0}}) (ug :: u0 -> u0 -> u0) (uh :: u0 -> u0 -> u0) (ui :: u0 -> u0 -> u0) (uj :: u0 -> u0) (uk :: u0 -> u0) (ul :: u0 -> u0) (um :: Integer -> u0) (un :: Int -> u0) -> _APP_ un [ ud ]; _NO_DEFLT_ }} in \ (up :: [u0]) -> _APP_ _TYAPP_ _TYAPP_ foldl { u0 } { u0 } [ uc, uo, up ] _SPECIALISE_ [ Double ] 1 { _A_ 1 _U_ 1 _N_ _S_ "S" _F_ _ALWAYS_ \ (u0 :: [Double]) -> let {(u1 :: Double) = _!_ D# [] [1.0000000000000000##]} in _APP_ _TYAPP_ _TYAPP_ foldl { Double } { Double } [ _CONSTM_ Num (*) (Double), u1, u0 ] _N_ }, [ Int ] 1 { _A_ 1 _U_ 1 _N_ _S_ "S" _F_ _ALWAYS_ \ (u0 :: [Int]) -> let {(u1 :: Int) = _!_ I# [] [1#]} in _APP_ _TYAPP_ _TYAPP_ foldl { Int } { Int } [ _CONSTM_ Num (*) (Int), u1, u0 ] _N_ }, [ Integer ] 1 { _A_ 1 _U_ 1 _N_ _S_ "S" _F_ _ALWAYS_ \ (u0 :: [Integer]) -> let {(u1 :: Integer) = _#_ int2Integer# [] [1#]} in _APP_ _TYAPP_ _TYAPP_ foldl { Integer } { Integer } [ _CONSTM_ Num (*) (Integer), u1, u0 ] _N_ } #-}
+ {-# GHC_PRAGMA _A_ 1 _U_ 22 _N_ _N_ _F_ _ALWAYS_ _/\_ u0 -> \ (u1 :: {{Num u0}}) -> let {(uc :: u0 -> u0 -> u0) = case u1 of { _ALG_ _TUP_10 (u2 :: {{Eq u0}}) (u3 :: {{Text u0}}) (u4 :: u0 -> u0 -> u0) (u5 :: u0 -> u0 -> u0) (u6 :: u0 -> u0 -> u0) (u7 :: u0 -> u0) (u8 :: u0 -> u0) (u9 :: u0 -> u0) (ua :: Integer -> u0) (ub :: Int -> u0) -> u6; _NO_DEFLT_ }} in let {(uo :: u0) = let {(ud :: Int) = _!_ I# [] [1#]} in case u1 of { _ALG_ _TUP_10 (ue :: {{Eq u0}}) (uf :: {{Text u0}}) (ug :: u0 -> u0 -> u0) (uh :: u0 -> u0 -> u0) (ui :: u0 -> u0 -> u0) (uj :: u0 -> u0) (uk :: u0 -> u0) (ul :: u0 -> u0) (um :: Integer -> u0) (un :: Int -> u0) -> _APP_ un [ ud ]; _NO_DEFLT_ }} in \ (up :: [u0]) -> _APP_ _TYAPP_ _TYAPP_ foldl { u0 } { u0 } [ uc, uo, up ] _SPECIALISE_ [ Double ] 1 { _A_ 1 _U_ 1 _N_ _S_ "S" _F_ _ALWAYS_ \ (u0 :: [Double]) -> let {(u1 :: Double) = _!_ D# [] [1.0000000000000000##]} in _APP_ _TYAPP_ _TYAPP_ foldl { Double } { Double } [ _CONSTM_ Num (*) (Double), u1, u0 ] _N_ }, [ Int ] 1 { _A_ 1 _U_ 1 _N_ _S_ "S" _F_ _ALWAYS_ \ (u0 :: [Int]) -> let {(u1 :: Int) = _!_ I# [] [1#]} in _APP_ _TYAPP_ _TYAPP_ foldl { Int } { Int } [ _CONSTM_ Num (*) (Int), u1, u0 ] _N_ }, [ Integer ] 1 { _A_ 1 _U_ 1 _N_ _S_ "S" _F_ _ALWAYS_ \ (u0 :: [Integer]) -> let {(u1 :: Integer) = _#_ int2Integer# [] [1#]} in _APP_ _TYAPP_ _TYAPP_ foldl { Integer } { Integer } [ _CONSTM_ Num (*) (Integer), u1, u0 ] _N_ }, [ (Complex Double) ] 1 { _A_ 1 _U_ 1 _N_ _S_ "S" _F_ _ALWAYS_ let {(u6 :: Complex Double -> Complex Double -> Complex Double) = \ (u0 :: Complex Double) (u1 :: Complex Double) -> case u0 of { _ALG_ (:+) (u2 :: Double) (u3 :: Double) -> case u1 of { _ALG_ (:+) (u4 :: Double) (u5 :: Double) -> _APP_ _WRKR_ _CONSTM_ Num (*) (Complex Double) [ u2, u3, u4, u5 ]; _NO_DEFLT_ }; _NO_DEFLT_ }} in let {(u8 :: Complex Double) = let {(u7 :: Int) = _!_ I# [] [1#]} in _APP_ _CONSTM_ Num fromInt (Complex Double) [ u7 ]} in \ (u9 :: [Complex Double]) -> _APP_ _TYAPP_ _TYAPP_ foldl { (Complex Double) } { (Complex Double) } [ u6, u8, u9 ] _N_ } #-}
products :: Num a => [a] -> [a]
- {-# GHC_PRAGMA _A_ 1 _U_ 21 _N_ _N_ _N_ _N_ #-}
+ {-# GHC_PRAGMA _A_ 1 _U_ 21 _N_ _N_ _N_ _SPECIALISE_ [ Double ] 1 { _A_ 1 _U_ 1 _N_ _N_ _N_ _N_ }, [ Int ] 1 { _A_ 1 _U_ 1 _N_ _N_ _N_ _N_ }, [ Integer ] 1 { _A_ 1 _U_ 1 _N_ _N_ _F_ _IF_ARGS_ 0 1 X 4 \ (u0 :: [Integer]) -> _APP_ _TYAPP_ _TYAPP_ _ORIG_ PreludeList scanl { Integer } { Integer } [ _CONSTM_ Num (*) (Integer), _SPEC_ _ORIG_ PreludeCore __i1 [ (Integer) ], u0 ] _N_ }, [ (Complex Double) ] 1 { _A_ 1 _U_ 1 _N_ _N_ _N_ _N_ } #-}
repeat :: a -> [a]
{-# GHC_PRAGMA _A_ 1 _U_ 2 _N_ _N_ _F_ _ALWAYS_ _/\_ u0 -> \ (u1 :: u0) -> let {(u6 :: _forall_ a$z1 =>(u0 -> a$z1 -> a$z1) -> a$z1 -> a$z1) = _/\_ u2 -> \ (u3 :: u0 -> u2 -> u2) (u4 :: u2) -> _LETREC_ {(u5 :: u2) = _APP_ u3 [ u1, u5 ]} in u5} in _APP_ _TYAPP_ _build { u0 } [ u6 ] _N_ #-}
reverse :: [a] -> [a]
sum :: Num a => [a] -> a
{-# GHC_PRAGMA _A_ 1 _U_ 22 _N_ _N_ _F_ _ALWAYS_ _/\_ u0 -> \ (u1 :: {{Num u0}}) -> let {(uc :: u0 -> u0 -> u0) = case u1 of { _ALG_ _TUP_10 (u2 :: {{Eq u0}}) (u3 :: {{Text u0}}) (u4 :: u0 -> u0 -> u0) (u5 :: u0 -> u0 -> u0) (u6 :: u0 -> u0 -> u0) (u7 :: u0 -> u0) (u8 :: u0 -> u0) (u9 :: u0 -> u0) (ua :: Integer -> u0) (ub :: Int -> u0) -> u4; _NO_DEFLT_ }} in let {(uo :: u0) = let {(ud :: Int) = _!_ I# [] [0#]} in case u1 of { _ALG_ _TUP_10 (ue :: {{Eq u0}}) (uf :: {{Text u0}}) (ug :: u0 -> u0 -> u0) (uh :: u0 -> u0 -> u0) (ui :: u0 -> u0 -> u0) (uj :: u0 -> u0) (uk :: u0 -> u0) (ul :: u0 -> u0) (um :: Integer -> u0) (un :: Int -> u0) -> _APP_ un [ ud ]; _NO_DEFLT_ }} in \ (up :: [u0]) -> _APP_ _TYAPP_ _TYAPP_ foldl { u0 } { u0 } [ uc, uo, up ] _SPECIALISE_ [ Double ] 1 { _A_ 1 _U_ 1 _N_ _S_ "S" _F_ _ALWAYS_ \ (u0 :: [Double]) -> let {(u1 :: Double) = _!_ D# [] [0.0000000000000000##]} in _APP_ _TYAPP_ _TYAPP_ foldl { Double } { Double } [ _CONSTM_ Num (+) (Double), u1, u0 ] _N_ }, [ Int ] 1 { _A_ 1 _U_ 1 _N_ _S_ "S" _F_ _ALWAYS_ \ (u0 :: [Int]) -> let {(u1 :: Int) = _!_ I# [] [0#]} in _APP_ _TYAPP_ _TYAPP_ foldl { Int } { Int } [ _CONSTM_ Num (+) (Int), u1, u0 ] _N_ }, [ Integer ] 1 { _A_ 1 _U_ 1 _N_ _S_ "S" _F_ _ALWAYS_ \ (u0 :: [Integer]) -> let {(u1 :: Integer) = _#_ int2Integer# [] [0#]} in _APP_ _TYAPP_ _TYAPP_ foldl { Integer } { Integer } [ _CONSTM_ Num (+) (Integer), u1, u0 ] _N_ }, [ (Complex Double) ] 1 { _A_ 1 _U_ 1 _N_ _S_ "S" _F_ _ALWAYS_ let {(u6 :: Complex Double -> Complex Double -> Complex Double) = \ (u0 :: Complex Double) (u1 :: Complex Double) -> case u0 of { _ALG_ (:+) (u2 :: Double) (u3 :: Double) -> case u1 of { _ALG_ (:+) (u4 :: Double) (u5 :: Double) -> _APP_ _WRKR_ _CONSTM_ Num (+) (Complex Double) [ u2, u3, u4, u5 ]; _NO_DEFLT_ }; _NO_DEFLT_ }} in let {(u8 :: Complex Double) = let {(u7 :: Int) = _!_ I# [] [0#]} in _APP_ _CONSTM_ Num fromInt (Complex Double) [ u7 ]} in \ (u9 :: [Complex Double]) -> _APP_ _TYAPP_ _TYAPP_ foldl { (Complex Double) } { (Complex Double) } [ u6, u8, u9 ] _N_ } #-}
sums :: Num a => [a] -> [a]
- {-# GHC_PRAGMA _A_ 1 _U_ 21 _N_ _N_ _N_ _N_ #-}
+ {-# GHC_PRAGMA _A_ 1 _U_ 21 _N_ _N_ _N_ _SPECIALISE_ [ Double ] 1 { _A_ 1 _U_ 1 _N_ _N_ _N_ _N_ }, [ Int ] 1 { _A_ 1 _U_ 1 _N_ _N_ _N_ _N_ }, [ Integer ] 1 { _A_ 1 _U_ 1 _N_ _N_ _F_ _IF_ARGS_ 0 1 X 4 \ (u0 :: [Integer]) -> _APP_ _TYAPP_ _TYAPP_ _ORIG_ PreludeList scanl { Integer } { Integer } [ _CONSTM_ Num (+) (Integer), _SPEC_ _ORIG_ PreludeCore __i0 [ (Integer) ], u0 ] _N_ }, [ (Complex Double) ] 1 { _A_ 1 _U_ 1 _N_ _N_ _N_ _N_ } #-}
tail :: [a] -> [a]
{-# GHC_PRAGMA _A_ 1 _U_ 1 _N_ _S_ "S" _F_ _IF_ARGS_ 1 1 C 5 _/\_ u0 -> \ (u1 :: [u0]) -> case u1 of { _ALG_ (:) (u2 :: u0) (u3 :: [u0]) -> u3; _NIL_ -> _APP_ _TYAPP_ error { [u0] } [ _NOREP_S_ "tail{PreludeList}: tail []\n" ]; _NO_DEFLT_ } _N_ #-}
take :: Integral a => a -> [b] -> [b]
- {-# GHC_PRAGMA _A_ 3 _U_ 121 _N_ _S_ "U(AAAAAAAAAAAS)LL" {_A_ 3 _U_ 121 _N_ _N_ _N_ _N_} _F_ _IF_ARGS_ 2 3 CXX 7 _/\_ u0 u1 -> \ (u2 :: {{Integral u0}}) (u3 :: u0) (u4 :: [u1]) -> let {(uh :: Int) = case u2 of { _ALG_ _TUP_12 (u5 :: {{Real u0}}) (u6 :: {{Ix u0}}) (u7 :: u0 -> u0 -> u0) (u8 :: u0 -> u0 -> u0) (u9 :: u0 -> u0 -> u0) (ua :: u0 -> u0 -> u0) (ub :: u0 -> u0 -> (u0, u0)) (uc :: u0 -> u0 -> (u0, u0)) (ud :: u0 -> Bool) (ue :: u0 -> Bool) (uf :: u0 -> Integer) (ug :: u0 -> Int) -> _APP_ ug [ u3 ]; _NO_DEFLT_ }} in _APP_ _TYAPP_ _SPEC_ _ORIG_ PreludeList take [ (Int), _N_ ] { u1 } [ uh, u4 ] _SPECIALISE_ [ Int, _N_ ] 1 { _A_ 2 _U_ 11 _N_ _S_ "U(P)L" {_A_ 2 _U_ 21 _N_ _N_ _N_ _N_} _N_ _N_ }, [ Integer, _N_ ] 1 { _A_ 2 _U_ 11 _N_ _S_ "U(PPP)L" {_A_ 4 _U_ 2221 _N_ _N_ _F_ _IF_ARGS_ 1 4 XXXX 4 _/\_ u0 -> \ (u1 :: Int#) (u2 :: Int#) (u3 :: ByteArray#) (u4 :: [u0]) -> case _#_ integer2Int# [] [u1, u2, u3] of { _PRIM_ (u5 :: Int#) -> _APP_ _TYAPP_ _WRKR_ _SPEC_ _ORIG_ PreludeList take [ (Int), _N_ ] { u0 } [ u5, u4 ] } _N_} _F_ _ALWAYS_ _/\_ u0 -> \ (u1 :: Integer) (u2 :: [u0]) -> case u1 of { _ALG_ J# (u3 :: Int#) (u4 :: Int#) (u5 :: ByteArray#) -> case _#_ integer2Int# [] [u3, u4, u5] of { _PRIM_ (u6 :: Int#) -> _APP_ _TYAPP_ _WRKR_ _SPEC_ _ORIG_ PreludeList take [ (Int), _N_ ] { u0 } [ u6, u2 ] }; _NO_DEFLT_ } _N_ } #-}
+ {-# GHC_PRAGMA _A_ 1 _U_ 122 _N_ _S_ "U(LU(U(ASSAAAAA)AAA)AAAALAAAAL)" {_A_ 5 _U_ 2121222 _N_ _N_ _N_ _N_} _N_ _SPECIALISE_ [ Int, _N_ ] 1 { _A_ 2 _U_ 11 _N_ _S_ "U(P)L" {_A_ 2 _U_ 21 _N_ _N_ _N_ _N_} _N_ _N_ }, [ Integer, _N_ ] 1 { _A_ 1 _U_ 12 _N_ _S_ "U(PPP)" {_A_ 3 _U_ 2222 _N_ _N_ _N_ _N_} _N_ _N_ } #-}
takeWhile :: (a -> Bool) -> [a] -> [a]
{-# GHC_PRAGMA _A_ 2 _U_ 21 _N_ _S_ "LS" _F_ _ALWAYS_ _/\_ u0 -> \ (u1 :: u0 -> Bool) (u2 :: [u0]) -> let {(u9 :: _forall_ a$z1 =>(u0 -> a$z1 -> a$z1) -> a$z1 -> a$z1) = _/\_ u3 -> \ (u4 :: u0 -> u3 -> u3) (u5 :: u3) -> let {(u8 :: u0 -> u3 -> u3) = \ (u6 :: u0) (u7 :: u3) -> case _APP_ u1 [ u6 ] of { _ALG_ True -> _APP_ u4 [ u6, u7 ]; False -> u5; _NO_DEFLT_ }} in _APP_ _TYAPP_ _TYAPP_ foldr { u0 } { u3 } [ u8, u5, u2 ]} in _APP_ _TYAPP_ _build { u0 } [ u9 ] _N_ #-}
transpose :: [[a]] -> [[a]]
lex :: [Char] -> [([Char], [Char])]
{-# GHC_PRAGMA _A_ 1 _U_ 2 _N_ _S_ "S" _N_ _N_ #-}
read :: Text a => [Char] -> a
- {-# GHC_PRAGMA _A_ 1 _U_ 12 _N_ _S_ "U(SAAA)" {_A_ 1 _U_ 12 _N_ _N_ _N_ _N_} _N_ _SPECIALISE_ [ Double ] 1 { _A_ 1 _U_ 2 _N_ _N_ _N_ _N_ }, [ Float ] 1 { _A_ 1 _U_ 2 _N_ _N_ _N_ _N_ }, [ Int ] 1 { _A_ 1 _U_ 2 _N_ _N_ _N_ _N_ }, [ Integer ] 1 { _A_ 1 _U_ 2 _N_ _N_ _N_ _N_ } #-}
+ {-# GHC_PRAGMA _A_ 1 _U_ 12 _N_ _S_ "U(SAAA)" {_A_ 1 _U_ 12 _N_ _N_ _N_ _N_} _N_ _SPECIALISE_ [ Bool ] 1 { _A_ 1 _U_ 2 _N_ _N_ _N_ _N_ }, [ Char ] 1 { _A_ 1 _U_ 2 _N_ _N_ _N_ _N_ }, [ Double ] 1 { _A_ 1 _U_ 2 _N_ _N_ _N_ _N_ }, [ Int ] 1 { _A_ 1 _U_ 2 _N_ _N_ _N_ _N_ }, [ Integer ] 1 { _A_ 1 _U_ 2 _N_ _N_ _N_ _N_ }, [ [Bool] ] 1 { _A_ 1 _U_ 2 _N_ _N_ _N_ _N_ }, [ [Char] ] 1 { _A_ 1 _U_ 2 _N_ _N_ _N_ _N_ }, [ [Double] ] 1 { _A_ 1 _U_ 2 _N_ _N_ _N_ _N_ }, [ [Float] ] 1 { _A_ 1 _U_ 2 _N_ _N_ _N_ _N_ }, [ [Int] ] 1 { _A_ 1 _U_ 2 _N_ _N_ _N_ _N_ }, [ [Integer] ] 1 { _A_ 1 _U_ 2 _N_ _N_ _N_ _N_ }, [ [[Char]] ] 1 { _A_ 1 _U_ 2 _N_ _N_ _N_ _N_ }, [ [[Int]] ] 1 { _A_ 1 _U_ 2 _N_ _N_ _N_ _N_ }, [ [Complex Double] ] 1 { _A_ 1 _U_ 2 _N_ _N_ _N_ _N_ }, [ (Ratio Integer) ] 1 { _A_ 1 _U_ 2 _N_ _N_ _N_ _N_ }, [ (Array Int Double) ] 1 { _A_ 1 _U_ 2 _N_ _N_ _N_ _N_ }, [ (Array (Int, Int) Double) ] 1 { _A_ 1 _U_ 2 _N_ _N_ _N_ _N_ }, [ _PackedString ] 1 { _A_ 1 _U_ 2 _N_ _S_ _!_ _N_ _N_ }, [ (Complex Double) ] 1 { _A_ 1 _U_ 2 _N_ _N_ _N_ _N_ }, [ () ] 1 { _A_ 1 _U_ 2 _N_ _N_ _N_ _N_ }, [ (Int, Int) ] 1 { _A_ 1 _U_ 2 _N_ _N_ _N_ _N_ }, [ (Integer, Integer) ] 1 { _A_ 1 _U_ 2 _N_ _N_ _N_ _N_ }, [ (Int, Int, Int) ] 1 { _A_ 1 _U_ 2 _N_ _N_ _N_ _N_ } #-}
readDec :: Integral a => [Char] -> [(a, [Char])]
- {-# GHC_PRAGMA _A_ 1 _U_ 22 _N_ _N_ _N_ _SPECIALISE_ [ Int ] 1 { _A_ 1 _U_ 2 _N_ _N_ _N_ _N_ }, [ Integer ] 1 { _A_ 1 _U_ 2 _N_ _S_ "S" _N_ _N_ } #-}
+ {-# GHC_PRAGMA _A_ 1 _U_ 22 _N_ _N_ _N_ _SPECIALISE_ [ Int ] 1 { _A_ 1 _U_ 2 _N_ _N_ _N_ _N_ }, [ Integer ] 1 { _A_ 1 _U_ 2 _N_ _N_ _N_ _N_ } #-}
readFloat :: RealFloat a => [Char] -> [(a, [Char])]
- {-# GHC_PRAGMA _A_ 2 _U_ 12 _N_ _S_ "LS" _N_ _SPECIALISE_ [ Double ] 1 { _A_ 1 _U_ 2 _N_ _S_ "S" _N_ _N_ }, [ Float ] 1 { _A_ 1 _U_ 2 _N_ _S_ "S" _N_ _N_ } #-}
+ {-# GHC_PRAGMA _A_ 2 _U_ 12 _N_ _S_ "LS" _N_ _SPECIALISE_ [ Double ] 1 { _A_ 1 _U_ 2 _N_ _S_ "S" _N_ _N_ } #-}
readLitChar :: [Char] -> [(Char, [Char])]
{-# GHC_PRAGMA _A_ 0 _U_ 1 _N_ _N_ _N_ _N_ #-}
readParen :: Bool -> ([Char] -> [(a, [Char])]) -> [Char] -> [(a, [Char])]
readSigned :: Real a => ([Char] -> [(a, [Char])]) -> [Char] -> [(a, [Char])]
{-# GHC_PRAGMA _A_ 2 _U_ 122 _N_ _N_ _N_ _SPECIALISE_ [ Double ] 1 { _A_ 1 _U_ 22 _N_ _N_ _N_ _N_ }, [ Int ] 1 { _A_ 1 _U_ 22 _N_ _N_ _N_ _N_ }, [ Integer ] 1 { _A_ 1 _U_ 22 _N_ _N_ _N_ _N_ } #-}
reads :: Text a => [Char] -> [(a, [Char])]
- {-# GHC_PRAGMA _A_ 1 _U_ 12 _N_ _S_ "U(SAAA)" {_A_ 1 _U_ 12 _N_ _N_ _N_ _N_} _N_ _SPECIALISE_ [ Double ] 1 { _A_ 1 _U_ 2 _N_ _N_ _N_ _N_ }, [ Float ] 1 { _A_ 1 _U_ 2 _N_ _N_ _N_ _N_ }, [ Int ] 1 { _A_ 1 _U_ 2 _N_ _N_ _N_ _N_ }, [ Integer ] 1 { _A_ 1 _U_ 2 _N_ _N_ _N_ _N_ } #-}
+ {-# GHC_PRAGMA _A_ 1 _U_ 12 _N_ _S_ "U(SAAA)" {_A_ 1 _U_ 12 _N_ _N_ _N_ _N_} _N_ _SPECIALISE_ [ Bool ] 1 { _A_ 1 _U_ 2 _N_ _N_ _N_ _N_ }, [ Char ] 1 { _A_ 0 _U_ 2 _N_ _N_ _N_ _N_ }, [ Double ] 1 { _A_ 1 _U_ 2 _N_ _N_ _N_ _N_ }, [ Int ] 1 { _A_ 1 _U_ 2 _N_ _N_ _N_ _N_ }, [ Integer ] 1 { _A_ 1 _U_ 2 _N_ _N_ _N_ _N_ }, [ [Bool] ] 1 { _A_ 0 _U_ 2 _N_ _N_ _F_ _IF_ARGS_ 0 0 X 1 _CONSTM_ Text readList (Bool) _N_ }, [ [Char] ] 1 { _A_ 0 _U_ 2 _N_ _N_ _F_ _IF_ARGS_ 0 0 X 1 _CONSTM_ Text readList (Char) _N_ }, [ [Double] ] 1 { _A_ 0 _U_ 2 _N_ _N_ _F_ _IF_ARGS_ 0 0 X 1 _CONSTM_ Text readList (Double) _N_ }, [ [Float] ] 1 { _A_ 0 _U_ 2 _N_ _N_ _N_ _N_ }, [ [Int] ] 1 { _A_ 0 _U_ 2 _N_ _N_ _F_ _IF_ARGS_ 0 0 X 1 _CONSTM_ Text readList (Int) _N_ }, [ [Integer] ] 1 { _A_ 0 _U_ 2 _N_ _N_ _F_ _IF_ARGS_ 0 0 X 1 _CONSTM_ Text readList (Integer) _N_ }, [ [[Char]] ] 1 { _A_ 0 _U_ 2 _N_ _N_ _F_ _IF_ARGS_ 0 0 X 1 _CONSTM_ Text readList ([Char]) _N_ }, [ [[Int]] ] 1 { _A_ 0 _U_ 2 _N_ _N_ _F_ _IF_ARGS_ 0 0 X 1 _CONSTM_ Text readList ([Int]) _N_ }, [ [Complex Double] ] 1 { _A_ 0 _U_ 2 _N_ _N_ _F_ _IF_ARGS_ 0 0 X 1 _CONSTM_ Text readList (Complex Double) _N_ }, [ (Ratio Integer) ] 1 { _A_ 0 _U_ 2 _N_ _N_ _N_ _N_ }, [ (Array Int Double) ] 1 { _A_ 0 _U_ 2 _N_ _N_ _N_ _N_ }, [ (Array (Int, Int) Double) ] 1 { _A_ 0 _U_ 2 _N_ _N_ _N_ _N_ }, [ _PackedString ] 1 { _A_ 1 _U_ 2 _N_ _S_ _!_ _N_ _N_ }, [ (Complex Double) ] 1 { _A_ 0 _U_ 2 _N_ _N_ _N_ _N_ }, [ () ] 1 { _A_ 0 _U_ 2 _N_ _N_ _N_ _N_ }, [ (Int, Int) ] 1 { _A_ 0 _U_ 2 _N_ _N_ _N_ _N_ }, [ (Integer, Integer) ] 1 { _A_ 0 _U_ 2 _N_ _N_ _N_ _N_ }, [ (Int, Int, Int) ] 1 { _A_ 0 _U_ 2 _N_ _N_ _N_ _N_ } #-}
show :: Text a => a -> [Char]
- {-# GHC_PRAGMA _A_ 1 _U_ 12 _N_ _S_ "U(ASAA)" {_A_ 1 _U_ 12 _N_ _N_ _N_ _N_} _N_ _SPECIALISE_ [ Char ] 1 { _A_ 1 _U_ 1 _N_ _S_ "U(P)" {_A_ 1 _U_ 2 _N_ _N_ _N_ _N_} _N_ _N_ }, [ Double ] 1 { _A_ 1 _U_ 1 _N_ _S_ "U(P)" {_A_ 1 _U_ 2 _N_ _N_ _N_ _N_} _N_ _N_ }, [ Float ] 1 { _A_ 1 _U_ 2 _N_ _N_ _N_ _N_ }, [ Int ] 1 { _A_ 1 _U_ 1 _N_ _S_ "U(P)" {_A_ 1 _U_ 2 _N_ _N_ _N_ _N_} _N_ _N_ }, [ Integer ] 1 { _A_ 1 _U_ 1 _N_ _S_ "U(PPP)" {_A_ 3 _U_ 222 _N_ _N_ _N_ _N_} _N_ _N_ }, [ [Char] ] 1 { _A_ 1 _U_ 2 _N_ _N_ _N_ _N_ }, [ _PackedString ] 1 { _A_ 1 _U_ 1 _N_ _N_ _N_ _N_ }, [ (Int, Int) ] 1 { _A_ 1 _U_ 1 _N_ _S_ "U(LL)" {_A_ 2 _U_ 22 _N_ _N_ _N_ _N_} _N_ _N_ }, [ (Integer, Integer) ] 1 { _A_ 1 _U_ 1 _N_ _S_ "U(LL)" {_A_ 2 _U_ 22 _N_ _N_ _N_ _N_} _N_ _N_ } #-}
+ {-# GHC_PRAGMA _A_ 1 _U_ 12 _N_ _S_ "U(ASAA)" {_A_ 1 _U_ 12 _N_ _N_ _N_ _N_} _N_ _SPECIALISE_ [ Bool ] 1 { _A_ 1 _U_ 2 _N_ _S_ "E" _N_ _N_ }, [ Char ] 1 { _A_ 1 _U_ 1 _N_ _S_ "U(P)" {_A_ 1 _U_ 2 _N_ _N_ _N_ _N_} _N_ _N_ }, [ Double ] 1 { _A_ 1 _U_ 1 _N_ _S_ "U(P)" {_A_ 1 _U_ 2 _N_ _N_ _N_ _N_} _N_ _N_ }, [ Int ] 1 { _A_ 1 _U_ 1 _N_ _S_ "U(P)" {_A_ 1 _U_ 2 _N_ _N_ _N_ _N_} _N_ _N_ }, [ Integer ] 1 { _A_ 1 _U_ 1 _N_ _S_ "U(PPP)" {_A_ 3 _U_ 222 _N_ _N_ _N_ _N_} _N_ _N_ }, [ [Bool] ] 1 { _A_ 1 _U_ 1 _N_ _S_ "S" _N_ _N_ }, [ [Char] ] 1 { _A_ 1 _U_ 2 _N_ _N_ _N_ _N_ }, [ [Double] ] 1 { _A_ 1 _U_ 2 _N_ _N_ _N_ _N_ }, [ [Int] ] 1 { _A_ 1 _U_ 2 _N_ _N_ _N_ _N_ }, [ [Integer] ] 1 { _A_ 1 _U_ 2 _N_ _N_ _N_ _N_ }, [ [[Char]] ] 1 { _A_ 1 _U_ 1 _N_ _S_ "S" _N_ _N_ }, [ [[Int]] ] 1 { _A_ 1 _U_ 1 _N_ _S_ "S" _N_ _N_ }, [ [Complex Double] ] 1 { _A_ 1 _U_ 2 _N_ _N_ _N_ _N_ }, [ (Ratio Integer) ] 1 { _A_ 1 _U_ 1 _N_ _S_ "U(LL)" {_A_ 2 _U_ 22 _N_ _N_ _N_ _N_} _N_ _N_ }, [ (Array Int Double) ] 1 { _A_ 1 _U_ 2 _N_ _N_ _N_ _N_ }, [ (Array (Int, Int) Double) ] 1 { _A_ 1 _U_ 2 _N_ _N_ _N_ _N_ }, [ _PackedString ] 1 { _A_ 1 _U_ 1 _N_ _N_ _N_ _N_ }, [ (Complex Double) ] 1 { _A_ 1 _U_ 1 _N_ _S_ "U(LL)" {_A_ 2 _U_ 22 _N_ _N_ _N_ _N_} _N_ _N_ }, [ () ] 1 { _A_ 1 _U_ 1 _N_ _S_ "E" _N_ _N_ }, [ (Int, Int) ] 1 { _A_ 1 _U_ 1 _N_ _S_ "U(LL)" {_A_ 2 _U_ 22 _N_ _N_ _N_ _N_} _N_ _N_ }, [ (Integer, Integer) ] 1 { _A_ 1 _U_ 1 _N_ _S_ "U(LL)" {_A_ 2 _U_ 22 _N_ _N_ _N_ _N_} _N_ _N_ }, [ (Int, Int, Int) ] 1 { _A_ 1 _U_ 1 _N_ _S_ "U(LLL)" {_A_ 3 _U_ 222 _N_ _N_ _N_ _N_} _N_ _N_ } #-}
showChar :: Char -> [Char] -> [Char]
{-# GHC_PRAGMA _A_ 2 _U_ 22 _N_ _N_ _F_ _IF_ARGS_ 0 2 XX 3 \ (u0 :: Char) (u1 :: [Char]) -> _!_ (:) [Char] [u0, u1] _N_ #-}
showFloat :: RealFloat a => a -> [Char] -> [Char]
- {-# GHC_PRAGMA _A_ 1 _U_ 122 _N_ _S_ "U(U(LU(SLLL)LAAAA)LLLALAAAA)" {_A_ 5 _U_ 1122222 _N_ _N_ _N_ _N_} _N_ _SPECIALISE_ [ Double ] 1 { _A_ 1 _U_ 12 _N_ _S_ "U(P)" {_A_ 1 _U_ 22 _N_ _N_ _N_ _N_} _N_ _N_ }, [ Float ] 1 { _A_ 0 _U_ 22 _N_ _N_ _N_ _N_ } #-}
+ {-# GHC_PRAGMA _A_ 1 _U_ 122 _N_ _S_ "U(U(AU(SAAA)AAAAL)LLLALAAAA)" {_A_ 5 _U_ 1122222 _N_ _N_ _N_ _N_} _N_ _SPECIALISE_ [ Double ] 1 { _A_ 1 _U_ 12 _N_ _S_ "U(P)" {_A_ 1 _U_ 22 _N_ _N_ _N_ _N_} _N_ _N_ } #-}
showInt :: Integral a => a -> [Char] -> [Char]
{-# GHC_PRAGMA _A_ 1 _U_ 122 _N_ _S_ "U(U(U(U(SL)LLLLLLLLL)LL)LLLLLSLLLLL)" _N_ _SPECIALISE_ [ Int ] 1 { _A_ 2 _U_ 12 _N_ _S_ "U(P)L" {_A_ 2 _U_ 22 _N_ _N_ _N_ _N_} _N_ _N_ }, [ Integer ] 1 { _A_ 2 _U_ 12 _N_ _S_ "U(PPP)L" {_A_ 4 _U_ 2222 _N_ _N_ _N_ _N_} _N_ _N_ } #-}
showLitChar :: Char -> [Char] -> [Char]
showString :: [Char] -> [Char] -> [Char]
{-# GHC_PRAGMA _A_ 2 _U_ 12 _N_ _N_ _F_ _IF_ARGS_ 0 0 X 1 _TYAPP_ _ORIG_ PreludeList (++) { Char } _N_ #-}
shows :: Text a => a -> [Char] -> [Char]
- {-# GHC_PRAGMA _A_ 1 _U_ 122 _N_ _S_ "U(ASAA)" {_A_ 1 _U_ 122 _N_ _N_ _N_ _N_} _N_ _SPECIALISE_ [ Char ] 1 { _A_ 2 _U_ 12 _N_ _S_ "U(P)L" {_A_ 2 _U_ 22 _N_ _N_ _N_ _N_} _N_ _N_ }, [ Double ] 1 { _A_ 1 _U_ 12 _N_ _S_ "U(P)" {_A_ 1 _U_ 22 _N_ _N_ _N_ _N_} _N_ _N_ }, [ Float ] 1 { _A_ 0 _U_ 22 _N_ _N_ _N_ _N_ }, [ Int ] 1 { _A_ 2 _U_ 12 _N_ _S_ "U(P)L" {_A_ 2 _U_ 22 _N_ _N_ _N_ _N_} _N_ _N_ }, [ Integer ] 1 { _A_ 2 _U_ 12 _N_ _S_ "U(PPP)L" {_A_ 4 _U_ 2222 _N_ _N_ _N_ _N_} _N_ _N_ }, [ [Char] ] 1 { _A_ 1 _U_ 22 _N_ _N_ _F_ _IF_ARGS_ 0 0 X 1 _CONSTM_ Text showList (Char) _N_ }, [ _PackedString ] 1 { _A_ 2 _U_ 12 _N_ _N_ _N_ _N_ }, [ (Int, Int) ] 1 { _A_ 2 _U_ 12 _N_ _S_ "U(LL)L" {_A_ 3 _U_ 222 _N_ _N_ _N_ _N_} _N_ _N_ }, [ (Integer, Integer) ] 1 { _A_ 2 _U_ 12 _N_ _S_ "U(LL)L" {_A_ 3 _U_ 222 _N_ _N_ _N_ _N_} _N_ _N_ } #-}
+ {-# GHC_PRAGMA _A_ 1 _U_ 122 _N_ _S_ "U(ASAA)" {_A_ 1 _U_ 122 _N_ _N_ _N_ _N_} _N_ _SPECIALISE_ [ Bool ] 1 { _A_ 2 _U_ 22 _N_ _N_ _N_ _N_ }, [ Char ] 1 { _A_ 2 _U_ 12 _N_ _S_ "U(P)L" {_A_ 2 _U_ 22 _N_ _N_ _N_ _N_} _N_ _N_ }, [ Double ] 1 { _A_ 1 _U_ 12 _N_ _S_ "U(P)" {_A_ 1 _U_ 22 _N_ _N_ _N_ _N_} _N_ _N_ }, [ Int ] 1 { _A_ 2 _U_ 12 _N_ _S_ "U(P)L" {_A_ 2 _U_ 22 _N_ _N_ _N_ _N_} _N_ _N_ }, [ Integer ] 1 { _A_ 2 _U_ 12 _N_ _S_ "U(PPP)L" {_A_ 4 _U_ 2222 _N_ _N_ _N_ _N_} _N_ _N_ }, [ [Bool] ] 1 { _A_ 1 _U_ 12 _N_ _S_ "S" _F_ _IF_ARGS_ 0 1 X 3 \ (u0 :: [Bool]) -> _APP_ _TYAPP_ _ORIG_ PreludeCore _showList { Bool } [ _WRKR_ _CONSTM_ Text showsPrec (Bool), u0 ] _N_ }, [ [Char] ] 1 { _A_ 1 _U_ 22 _N_ _N_ _F_ _IF_ARGS_ 0 0 X 1 _CONSTM_ Text showList (Char) _N_ }, [ [Double] ] 1 { _A_ 1 _U_ 22 _N_ _N_ _F_ _IF_ARGS_ 0 0 X 1 _CONSTM_ Text showList (Double) _N_ }, [ [Int] ] 1 { _A_ 1 _U_ 22 _N_ _N_ _F_ _IF_ARGS_ 0 0 X 1 _CONSTM_ Text showList (Int) _N_ }, [ [Integer] ] 1 { _A_ 1 _U_ 22 _N_ _N_ _F_ _IF_ARGS_ 0 0 X 1 _CONSTM_ Text showList (Integer) _N_ }, [ [[Char]] ] 1 { _A_ 1 _U_ 12 _N_ _S_ "S" _F_ _IF_ARGS_ 0 1 X 3 \ (u0 :: [[Char]]) -> _APP_ _TYAPP_ _ORIG_ PreludeCore _showList { [Char] } [ _CONSTM_ Text showList (Char), u0 ] _N_ }, [ [[Int]] ] 1 { _A_ 1 _U_ 12 _N_ _S_ "S" _F_ _IF_ARGS_ 0 1 X 3 \ (u0 :: [[Int]]) -> _APP_ _TYAPP_ _ORIG_ PreludeCore _showList { [Int] } [ _CONSTM_ Text showList (Int), u0 ] _N_ }, [ [Complex Double] ] 1 { _A_ 1 _U_ 22 _N_ _N_ _F_ _IF_ARGS_ 0 0 X 1 _CONSTM_ Text showList (Complex Double) _N_ }, [ (Ratio Integer) ] 1 { _A_ 1 _U_ 12 _N_ _S_ "U(LL)" {_A_ 2 _U_ 222 _N_ _N_ _N_ _N_} _N_ _N_ }, [ (Array Int Double) ] 1 { _A_ 1 _U_ 22 _N_ _N_ _N_ _N_ }, [ (Array (Int, Int) Double) ] 1 { _A_ 1 _U_ 22 _N_ _N_ _N_ _N_ }, [ _PackedString ] 1 { _A_ 2 _U_ 12 _N_ _N_ _N_ _N_ }, [ (Complex Double) ] 1 { _A_ 1 _U_ 12 _N_ _S_ "U(LL)" {_A_ 2 _U_ 222 _N_ _N_ _N_ _N_} _N_ _N_ }, [ () ] 1 { _A_ 2 _U_ 12 _N_ _S_ "EL" _F_ _IF_ARGS_ 0 2 CX 4 \ (u0 :: ()) (u1 :: [Char]) -> case u0 of { _ALG_ _TUP_0 -> _APP_ _TYAPP_ _ORIG_ PreludeList (++) { Char } [ _NOREP_S_ "()", u1 ]; _NO_DEFLT_ } _N_ }, [ (Int, Int) ] 1 { _A_ 2 _U_ 12 _N_ _S_ "U(LL)L" {_A_ 3 _U_ 222 _N_ _N_ _N_ _N_} _N_ _N_ }, [ (Integer, Integer) ] 1 { _A_ 2 _U_ 12 _N_ _S_ "U(LL)L" {_A_ 3 _U_ 222 _N_ _N_ _N_ _N_} _N_ _N_ }, [ (Int, Int, Int) ] 1 { _A_ 2 _U_ 12 _N_ _S_ "U(LLL)L" {_A_ 4 _U_ 2222 _N_ _N_ _N_ _N_} _N_ _N_ } #-}
appendFile :: [Char] -> [Char] -> _State _RealWorld -> (Either IOError13 (), _State _RealWorld)
{-# GHC_PRAGMA _A_ 3 _U_ 221 _N_ _S_ "LLU(P)" {_A_ 3 _U_ 222 _N_ _N_ _N_ _N_} _N_ _N_ #-}
hPutChar :: _MVar _Handle -> Char -> _State _RealWorld -> (Either IOError13 (), _State _RealWorld)
print :: Text a => a -> _State _RealWorld -> (Either IOError13 (), _State _RealWorld)
{-# GHC_PRAGMA _A_ 1 _U_ 121 _N_ _N_ _N_ _N_ #-}
putChar :: Char -> _State _RealWorld -> (Either IOError13 (), _State _RealWorld)
- {-# GHC_PRAGMA _A_ 2 _U_ 11 _N_ _N_ _F_ _IF_ARGS_ 0 0 X 2 _APP_ _ORIG_ PreludeWriteTextIO hPutChar [ _ORIG_ PreludeStdIO stdout13 ] _N_ #-}
+ {-# GHC_PRAGMA _A_ 2 _U_ 11 _N_ _N_ _F_ _IF_ARGS_ 0 2 XC 6 \ (u0 :: Char) (u1 :: _State _RealWorld) -> case _ORIG_ PreludeStdIO stdout13 of { _ALG_ _MVar (u2 :: SynchVar# _RealWorld _Handle) -> case u1 of { _ALG_ S# (u3 :: State# _RealWorld) -> _APP_ _WRKR_ _ORIG_ PreludeWriteTextIO hPutChar [ u2, u0, u3 ]; _NO_DEFLT_ }; _NO_DEFLT_ } _N_ #-}
putStr :: [Char] -> _State _RealWorld -> (Either IOError13 (), _State _RealWorld)
- {-# GHC_PRAGMA _A_ 2 _U_ 21 _N_ _N_ _F_ _IF_ARGS_ 0 0 X 2 _APP_ _ORIG_ PreludeWriteTextIO hPutStr [ _ORIG_ PreludeStdIO stdout13 ] _N_ #-}
+ {-# GHC_PRAGMA _A_ 2 _U_ 21 _N_ _N_ _F_ _IF_ARGS_ 0 2 XC 6 \ (u0 :: [Char]) (u1 :: _State _RealWorld) -> case _ORIG_ PreludeStdIO stdout13 of { _ALG_ _MVar (u2 :: SynchVar# _RealWorld _Handle) -> case u1 of { _ALG_ S# (u3 :: State# _RealWorld) -> _APP_ _WRKR_ _ORIG_ PreludeWriteTextIO hPutStr [ u2, u0, u3 ]; _NO_DEFLT_ }; _NO_DEFLT_ } _N_ #-}
putText :: Text a => a -> _State _RealWorld -> (Either IOError13 (), _State _RealWorld)
{-# GHC_PRAGMA _A_ 1 _U_ 121 _N_ _N_ _F_ _IF_ARGS_ 1 1 X 3 _/\_ u0 -> \ (u1 :: {{Text u0}}) -> _APP_ _TYAPP_ _ORIG_ PreludeWriteTextIO hPutText { u0 } [ u1, _ORIG_ PreludeStdIO stdout13 ] _N_ #-}
writeFile :: [Char] -> [Char] -> _State _RealWorld -> (Either IOError13 (), _State _RealWorld)
#if defined(__UNBOXED_INSTANCES__)
minInt#, maxInt#,
+ toInt#, fromInt#,
minChar#, maxChar#,
toChar#, fromChar#,
isAscii#, isControl#, isPrint#, isSpace#,
readParen, showParen, readLitChar, showLitChar, readSigned,
showSigned, showSpace__, readDec, showInt, readFloat, showFloat,
_showHex, _showRadix, _showDigit, -- non-std
- _readList, _showList, _truncate, _round, _ceiling, _floor,
+ _readList, _showList,
_readRational, _showRational, -- extras!
= io `thenPrimIO` \ r ->
case r of
Right a -> returnPrimIO a
- Left e -> error ("I/O Error (ioToPrimIO): " ++ shows e "\n")
+ Left e -> error ("I/O Error (ioToPrimIO): " ++ showsPrec 0 e "\n")
-- 1.3 extra functions
-{-# GHC_PRAGMA INTERFACE VERSION 5 #-}
+{-# GHC_PRAGMA INTERFACE VERSION 6 #-}
interface Prelude where
import PreludeArray((!), (//), Array, Assoc, _ByteArray, accum, accumArray, amap, array, assocs, bounds, elems, indices, ixmap, listArray)
import PreludeBuiltin(Bin, Char(..), Int(..), Integer(..), List(..), Tuple0, Tuple2, Tuple3, Tuple4, Tuple5, Tuple6, Tuple7, _Addr(..), _RealWorld(..), _State(..))
import PreludeComplex(Complex, cis, conjugate, imagPart, magnitude, mkPolar, phase, polar, realPart)
-import PreludeCore(Bool(..), Eq(..), Fractional(..), Integral(..), Ix(..), Num(..), Ord(..), Real(..), RealFloat(..), RealFrac(..), Text(..), _ceiling, _floor, _readList, _round, _showList, _showRational, _truncate)
+import PreludeCore(Bool(..), Eq(..), Fractional(..), Integral(..), Ix(..), Num(..), Ord(..), Real(..), RealFloat(..), RealFrac(..), Text(..), _readList, _showList, _showRational)
import PreludeIO(interact13) renaming (interact13 to interact)
import PreludeIOError(IOError13)
import PreludeList((!!), (++), (\\), all, and, any, break, concat, cycle, drop, dropWhile, elem, filter, foldl1, foldr1, genericLength, head, init, iterate, last, length, lines, map, maximum, minimum, notElem, nub, null, or, partition, product, products, repeat, reverse, scanl, scanl1, scanr, scanr1, span, splitAt, sum, sums, tail, take, takeWhile, transpose, unlines, unwords, unzip, unzip3, unzip4, unzip5, unzip6, unzip7, words, zip, zip3, zip4, zip5, zip6, zip7, zipWith, zipWith3, zipWith4, zipWith5, zipWith6, zipWith7)
(.) :: (a -> c) -> (b -> a) -> b -> c
{-# GHC_PRAGMA _A_ 3 _U_ 112 _N_ _S_ "SLL" _F_ _ALWAYS_ _/\_ u0 u1 u2 -> \ (u3 :: u0 -> u2) (u4 :: u1 -> u0) (u5 :: u1) -> let {(u6 :: u0) = _APP_ u4 [ u5 ]} in _APP_ u3 [ u6 ] _N_ #-}
(^) :: (Num b, Integral a) => b -> a -> b
- {-# GHC_PRAGMA _A_ 2 _U_ 2122 _N_ _S_ "LU(U(LU(U(U(SA)AALAAAA)AAAA)A)AAALAAAALAA)" {_A_ 5 _U_ 2212222 _N_ _N_ _N_ _N_} _N_ _SPECIALISE_ [ Int, Double ] 2 { _A_ 2 _U_ 21 _N_ _S_ "LU(P)" {_A_ 2 _U_ 22 _N_ _N_ _N_ _N_} _N_ _N_ }, [ Int, Int ] 2 { _A_ 2 _U_ 21 _N_ _S_ "LU(P)" {_A_ 2 _U_ 22 _N_ _N_ _N_ _N_} _N_ _N_ }, [ Int, Integer ] 2 { _A_ 2 _U_ 21 _N_ _S_ "LU(P)" {_A_ 2 _U_ 22 _N_ _N_ _N_ _N_} _N_ _N_ }, [ Int, (Ratio Integer) ] 2 { _A_ 2 _U_ 21 _N_ _S_ "LU(P)" {_A_ 2 _U_ 22 _N_ _N_ _N_ _N_} _N_ _N_ }, [ Int, (Complex Double) ] 2 { _A_ 2 _U_ 21 _N_ _S_ "LU(P)" {_A_ 2 _U_ 22 _N_ _N_ _N_ _N_} _N_ _N_ } #-}
+ {-# GHC_PRAGMA _A_ 2 _U_ 2122 _N_ _S_ "LU(U(LU(U(U(SL)LLLLLLL)LLLL)L)LLLLLLLLLLL)" _N_ _SPECIALISE_ [ Int, Double ] 2 { _A_ 2 _U_ 21 _N_ _S_ "LU(P)" {_A_ 2 _U_ 22 _N_ _N_ _N_ _N_} _N_ _N_ }, [ Int, Int ] 2 { _A_ 2 _U_ 21 _N_ _S_ "LU(P)" {_A_ 2 _U_ 22 _N_ _N_ _N_ _N_} _N_ _N_ }, [ Int, Integer ] 2 { _A_ 2 _U_ 21 _N_ _S_ "LU(P)" {_A_ 2 _U_ 22 _N_ _N_ _N_ _N_} _N_ _N_ }, [ Int, (Ratio Integer) ] 2 { _A_ 2 _U_ 21 _N_ _S_ "LU(P)" {_A_ 2 _U_ 22 _N_ _N_ _N_ _N_} _N_ _N_ }, [ Int, (Complex Double) ] 2 { _A_ 2 _U_ 21 _N_ _S_ "LU(P)" {_A_ 2 _U_ 22 _N_ _N_ _N_ _N_} _N_ _N_ }, [ Integer, Integer ] 2 { _A_ 2 _U_ 21 _N_ _S_ "LU(PPP)" {_A_ 4 _U_ 2222 _N_ _N_ _N_ _N_} _N_ _N_ } #-}
(^^) :: (Fractional b, Integral a) => b -> a -> b
- {-# GHC_PRAGMA _A_ 2 _U_ 2122 _N_ _S_ "LU(LU(U(AAASAAAA)AAA)AALAAAALAA)" {_A_ 5 _U_ 2212222 _N_ _N_ _N_ _N_} _N_ _SPECIALISE_ [ Int, Double ] 2 { _A_ 2 _U_ 21 _N_ _S_ "LU(P)" {_A_ 2 _U_ 22 _N_ _N_ _N_ _N_} _N_ _N_ }, [ Int, (Ratio Integer) ] 2 { _A_ 2 _U_ 21 _N_ _S_ "LU(P)" {_A_ 2 _U_ 22 _N_ _N_ _N_ _N_} _N_ _N_ } #-}
+ {-# GHC_PRAGMA _A_ 2 _U_ 2222 _N_ _S_ "LU(LU(U(LLLSLLLL)LLL)LLLLLLLLLL)" _N_ _SPECIALISE_ [ Int, Double ] 2 { _A_ 2 _U_ 21 _N_ _S_ "LU(P)" {_A_ 2 _U_ 22 _N_ _N_ _N_ _N_} _N_ _N_ }, [ Int, (Ratio Integer) ] 2 { _A_ 2 _U_ 21 _N_ _S_ "LU(P)" {_A_ 2 _U_ 22 _N_ _N_ _N_ _N_} _N_ _N_ }, [ Int, (Complex Double) ] 2 { _A_ 2 _U_ 21 _N_ _S_ "LU(P)" {_A_ 2 _U_ 22 _N_ _N_ _N_ _N_} _N_ _N_ } #-}
appendBin :: Bin -> Bin -> Bin
- {-# GHC_PRAGMA _A_ 2 _U_ 22 _N_ _S_ _!_ _F_ _IF_ARGS_ 0 2 XX 4 \ (u0 :: Bin) (u1 :: Bin) -> _APP_ _TYAPP_ error { (Bin -> Bin -> Bin) } [ _NOREP_S_ "appendBin{Prelude}\n", u0, u1 ] _N_ #-}
+ {-# GHC_PRAGMA _A_ 2 _U_ 22 _N_ _S_ _!_ _N_ _N_ #-}
asTypeOf :: a -> a -> a
{-# GHC_PRAGMA _A_ 2 _U_ 10 _N_ _N_ _F_ _IF_ARGS_ 1 0 X 1 _/\_ u0 -> _TYAPP_ _TYAPP_ _ORIG_ Prelude const { u0 } { u0 } _N_ #-}
atan2 :: RealFloat a => a -> a -> a
flip :: (b -> a -> c) -> a -> b -> c
{-# GHC_PRAGMA _A_ 3 _U_ 122 _N_ _S_ "SLL" _F_ _IF_ARGS_ 3 3 XXX 3 _/\_ u0 u1 u2 -> \ (u3 :: u1 -> u0 -> u2) (u4 :: u0) (u5 :: u1) -> _APP_ u3 [ u5, u4 ] _N_ #-}
fromIntegral :: (Integral a, Num b) => a -> b
- {-# GHC_PRAGMA _A_ 3 _U_ 112 _N_ _S_ "LU(AAAAAAAASA)L" {_A_ 3 _U_ 112 _N_ _N_ _F_ _IF_ARGS_ 2 3 CXX 6 _/\_ u0 u1 -> \ (u2 :: {{Integral u0}}) (u3 :: Integer -> u1) (u4 :: u0) -> let {(uh :: Integer) = case u2 of { _ALG_ _TUP_12 (u5 :: {{Real u0}}) (u6 :: {{Ix u0}}) (u7 :: u0 -> u0 -> u0) (u8 :: u0 -> u0 -> u0) (u9 :: u0 -> u0 -> u0) (ua :: u0 -> u0 -> u0) (ub :: u0 -> u0 -> (u0, u0)) (uc :: u0 -> u0 -> (u0, u0)) (ud :: u0 -> Bool) (ue :: u0 -> Bool) (uf :: u0 -> Integer) (ug :: u0 -> Int) -> _APP_ uf [ u4 ]; _NO_DEFLT_ }} in _APP_ u3 [ uh ] _N_} _F_ _IF_ARGS_ 2 3 CCX 7 _/\_ u0 u1 -> \ (u2 :: {{Integral u0}}) (u3 :: {{Num u1}}) (u4 :: u0) -> let {(uh :: Integer) = case u2 of { _ALG_ _TUP_12 (u5 :: {{Real u0}}) (u6 :: {{Ix u0}}) (u7 :: u0 -> u0 -> u0) (u8 :: u0 -> u0 -> u0) (u9 :: u0 -> u0 -> u0) (ua :: u0 -> u0 -> u0) (ub :: u0 -> u0 -> (u0, u0)) (uc :: u0 -> u0 -> (u0, u0)) (ud :: u0 -> Bool) (ue :: u0 -> Bool) (uf :: u0 -> Integer) (ug :: u0 -> Int) -> _APP_ uf [ u4 ]; _NO_DEFLT_ }} in case u3 of { _ALG_ _TUP_10 (ui :: {{Eq u1}}) (uj :: {{Text u1}}) (uk :: u1 -> u1 -> u1) (ul :: u1 -> u1 -> u1) (um :: u1 -> u1 -> u1) (un :: u1 -> u1) (uo :: u1 -> u1) (up :: u1 -> u1) (uq :: Integer -> u1) (ur :: Int -> u1) -> _APP_ uq [ uh ]; _NO_DEFLT_ } _SPECIALISE_ [ Int, Double ] 2 { _A_ 1 _U_ 1 _N_ _S_ "U(P)" {_A_ 1 _U_ 2 _N_ _N_ _F_ _IF_ARGS_ 0 1 X 3 \ (u0 :: Int#) -> case _#_ int2Double# [] [u0] of { _PRIM_ (u1 :: Double#) -> _!_ D# [] [u1] } _N_} _F_ _IF_ARGS_ 0 1 C 4 \ (u0 :: Int) -> case u0 of { _ALG_ I# (u1 :: Int#) -> case _#_ int2Double# [] [u1] of { _PRIM_ (u2 :: Double#) -> _!_ D# [] [u2] }; _NO_DEFLT_ } _N_ }, [ Int, Int ] 2 { _A_ 1 _U_ 1 _N_ _N_ _F_ _IF_ARGS_ 0 0 X 1 _TYAPP_ _ORIG_ Prelude id { Int } _N_ }, [ Int, Integer ] 2 { _A_ 1 _U_ 1 _N_ _S_ "U(P)" {_A_ 1 _U_ 2 _N_ _N_ _F_ _IF_ARGS_ 0 1 X 1 \ (u0 :: Int#) -> _#_ int2Integer# [] [u0] _N_} _F_ _IF_ARGS_ 0 1 C 2 \ (u0 :: Int) -> case u0 of { _ALG_ I# (u1 :: Int#) -> _#_ int2Integer# [] [u1]; _NO_DEFLT_ } _N_ }, [ Integer, Double ] 2 { _A_ 1 _U_ 1 _N_ _S_ "U(PPP)" {_A_ 3 _U_ 222 _N_ _N_ _F_ _IF_ARGS_ 0 3 XXX 3 \ (u0 :: Int#) (u1 :: Int#) (u2 :: ByteArray#) -> case _#_ encodeDouble# [] [u0, u1, u2, 0#] of { _PRIM_ (u3 :: Double#) -> _!_ D# [] [u3] } _N_} _F_ _IF_ARGS_ 0 1 C 4 \ (u0 :: Integer) -> case u0 of { _ALG_ J# (u1 :: Int#) (u2 :: Int#) (u3 :: ByteArray#) -> case _#_ encodeDouble# [] [u1, u2, u3, 0#] of { _PRIM_ (u4 :: Double#) -> _!_ D# [] [u4] }; _NO_DEFLT_ } _N_ }, [ Integer, Int ] 2 { _A_ 1 _U_ 1 _N_ _S_ "U(PPP)" {_A_ 3 _U_ 222 _N_ _N_ _F_ _IF_ARGS_ 0 3 XXX 3 \ (u0 :: Int#) (u1 :: Int#) (u2 :: ByteArray#) -> case _#_ integer2Int# [] [u0, u1, u2] of { _PRIM_ (u3 :: Int#) -> _!_ I# [] [u3] } _N_} _F_ _IF_ARGS_ 0 1 C 4 \ (u0 :: Integer) -> case u0 of { _ALG_ J# (u1 :: Int#) (u2 :: Int#) (u3 :: ByteArray#) -> case _#_ integer2Int# [] [u1, u2, u3] of { _PRIM_ (u4 :: Int#) -> _!_ I# [] [u4] }; _NO_DEFLT_ } _N_ }, [ Integer, Integer ] 2 { _A_ 1 _U_ 1 _N_ _N_ _F_ _IF_ARGS_ 0 0 X 1 _TYAPP_ _ORIG_ Prelude id { Integer } _N_ } #-}
+ {-# GHC_PRAGMA _A_ 3 _U_ 112 _N_ _S_ "LU(AAAAAAAASA)L" {_A_ 3 _U_ 112 _N_ _N_ _F_ _IF_ARGS_ 2 3 CXX 6 _/\_ u0 u1 -> \ (u2 :: {{Integral u0}}) (u3 :: Integer -> u1) (u4 :: u0) -> let {(uh :: Integer) = case u2 of { _ALG_ _TUP_12 (u5 :: {{Real u0}}) (u6 :: {{Ix u0}}) (u7 :: u0 -> u0 -> u0) (u8 :: u0 -> u0 -> u0) (u9 :: u0 -> u0 -> u0) (ua :: u0 -> u0 -> u0) (ub :: u0 -> u0 -> (u0, u0)) (uc :: u0 -> u0 -> (u0, u0)) (ud :: u0 -> Bool) (ue :: u0 -> Bool) (uf :: u0 -> Integer) (ug :: u0 -> Int) -> _APP_ uf [ u4 ]; _NO_DEFLT_ }} in _APP_ u3 [ uh ] _N_} _F_ _IF_ARGS_ 2 3 CCX 7 _/\_ u0 u1 -> \ (u2 :: {{Integral u0}}) (u3 :: {{Num u1}}) (u4 :: u0) -> let {(uh :: Integer) = case u2 of { _ALG_ _TUP_12 (u5 :: {{Real u0}}) (u6 :: {{Ix u0}}) (u7 :: u0 -> u0 -> u0) (u8 :: u0 -> u0 -> u0) (u9 :: u0 -> u0 -> u0) (ua :: u0 -> u0 -> u0) (ub :: u0 -> u0 -> (u0, u0)) (uc :: u0 -> u0 -> (u0, u0)) (ud :: u0 -> Bool) (ue :: u0 -> Bool) (uf :: u0 -> Integer) (ug :: u0 -> Int) -> _APP_ uf [ u4 ]; _NO_DEFLT_ }} in case u3 of { _ALG_ _TUP_10 (ui :: {{Eq u1}}) (uj :: {{Text u1}}) (uk :: u1 -> u1 -> u1) (ul :: u1 -> u1 -> u1) (um :: u1 -> u1 -> u1) (un :: u1 -> u1) (uo :: u1 -> u1) (up :: u1 -> u1) (uq :: Integer -> u1) (ur :: Int -> u1) -> _APP_ uq [ uh ]; _NO_DEFLT_ } _SPECIALISE_ [ Int, Double ] 2 { _A_ 1 _U_ 1 _N_ _S_ "U(P)" {_A_ 1 _U_ 2 _N_ _N_ _F_ _IF_ARGS_ 0 1 X 3 \ (u0 :: Int#) -> case _#_ int2Double# [] [u0] of { _PRIM_ (u1 :: Double#) -> _!_ D# [] [u1] } _N_} _F_ _IF_ARGS_ 0 1 C 4 \ (u0 :: Int) -> case u0 of { _ALG_ I# (u1 :: Int#) -> case _#_ int2Double# [] [u1] of { _PRIM_ (u2 :: Double#) -> _!_ D# [] [u2] }; _NO_DEFLT_ } _N_ }, [ Int, Float ] 2 { _A_ 1 _U_ 1 _N_ _S_ "U(P)" {_A_ 1 _U_ 2 _N_ _N_ _F_ _IF_ARGS_ 0 1 X 3 \ (u0 :: Int#) -> case _#_ int2Float# [] [u0] of { _PRIM_ (u1 :: Float#) -> _!_ F# [] [u1] } _N_} _F_ _IF_ARGS_ 0 1 C 4 \ (u0 :: Int) -> case u0 of { _ALG_ I# (u1 :: Int#) -> case _#_ int2Float# [] [u1] of { _PRIM_ (u2 :: Float#) -> _!_ F# [] [u2] }; _NO_DEFLT_ } _N_ }, [ Int, Int ] 2 { _A_ 1 _U_ 1 _N_ _N_ _F_ _IF_ARGS_ 0 0 X 1 _TYAPP_ _ORIG_ Prelude id { Int } _N_ }, [ Int, Integer ] 2 { _A_ 1 _U_ 1 _N_ _S_ "U(P)" {_A_ 1 _U_ 2 _N_ _N_ _F_ _IF_ARGS_ 0 1 X 1 \ (u0 :: Int#) -> _#_ int2Integer# [] [u0] _N_} _F_ _IF_ARGS_ 0 1 C 2 \ (u0 :: Int) -> case u0 of { _ALG_ I# (u1 :: Int#) -> _#_ int2Integer# [] [u1]; _NO_DEFLT_ } _N_ }, [ Int, (Ratio Integer) ] 2 { _A_ 1 _U_ 1 _N_ _N_ _N_ _N_ }, [ Integer, Double ] 2 { _A_ 1 _U_ 1 _N_ _S_ "U(PPP)" {_A_ 3 _U_ 222 _N_ _N_ _F_ _IF_ARGS_ 0 3 XXX 3 \ (u0 :: Int#) (u1 :: Int#) (u2 :: ByteArray#) -> case _#_ encodeDouble# [] [u0, u1, u2, 0#] of { _PRIM_ (u3 :: Double#) -> _!_ D# [] [u3] } _N_} _F_ _IF_ARGS_ 0 1 C 4 \ (u0 :: Integer) -> case u0 of { _ALG_ J# (u1 :: Int#) (u2 :: Int#) (u3 :: ByteArray#) -> case _#_ encodeDouble# [] [u1, u2, u3, 0#] of { _PRIM_ (u4 :: Double#) -> _!_ D# [] [u4] }; _NO_DEFLT_ } _N_ }, [ Integer, Float ] 2 { _A_ 1 _U_ 1 _N_ _S_ "U(PPP)" {_A_ 3 _U_ 222 _N_ _N_ _F_ _IF_ARGS_ 0 3 XXX 3 \ (u0 :: Int#) (u1 :: Int#) (u2 :: ByteArray#) -> case _#_ encodeFloat# [] [u0, u1, u2, 0#] of { _PRIM_ (u3 :: Float#) -> _!_ F# [] [u3] } _N_} _F_ _IF_ARGS_ 0 1 C 4 \ (u0 :: Integer) -> case u0 of { _ALG_ J# (u1 :: Int#) (u2 :: Int#) (u3 :: ByteArray#) -> case _#_ encodeFloat# [] [u1, u2, u3, 0#] of { _PRIM_ (u4 :: Float#) -> _!_ F# [] [u4] }; _NO_DEFLT_ } _N_ }, [ Integer, Int ] 2 { _A_ 1 _U_ 1 _N_ _S_ "U(PPP)" {_A_ 3 _U_ 222 _N_ _N_ _F_ _IF_ARGS_ 0 3 XXX 3 \ (u0 :: Int#) (u1 :: Int#) (u2 :: ByteArray#) -> case _#_ integer2Int# [] [u0, u1, u2] of { _PRIM_ (u3 :: Int#) -> _!_ I# [] [u3] } _N_} _F_ _IF_ARGS_ 0 1 C 4 \ (u0 :: Integer) -> case u0 of { _ALG_ J# (u1 :: Int#) (u2 :: Int#) (u3 :: ByteArray#) -> case _#_ integer2Int# [] [u1, u2, u3] of { _PRIM_ (u4 :: Int#) -> _!_ I# [] [u4] }; _NO_DEFLT_ } _N_ }, [ Integer, Integer ] 2 { _A_ 1 _U_ 1 _N_ _N_ _F_ _IF_ARGS_ 0 0 X 1 _TYAPP_ _ORIG_ Prelude id { Integer } _N_ }, [ Integer, (Ratio Integer) ] 2 { _A_ 1 _U_ 2 _N_ _N_ _F_ _IF_ARGS_ 0 1 X 3 \ (u0 :: Integer) -> _!_ (:%) [Integer] [u0, _SPEC_ _ORIG_ PreludeCore __i1 [ (Integer) ]] _N_ } #-}
fromRealFrac :: (RealFrac a, Fractional b) => a -> b
- {-# GHC_PRAGMA _A_ 3 _U_ 112 _N_ _S_ "LU(AAAS)L" {_A_ 3 _U_ 112 _N_ _N_ _F_ _IF_ARGS_ 2 3 CXX 7 _/\_ u0 u1 -> \ (u2 :: {{RealFrac u0}}) (u3 :: Ratio Integer -> u1) (u4 :: u0) -> let {(uf :: Ratio Integer) = case u2 of { _ALG_ _TUP_7 (u5 :: {{Real u0}}) (u6 :: {{Fractional u0}}) (u7 :: _forall_ a$z1 =>{{Integral a$z1}} -> u0 -> (a$z1, u0)) (u8 :: _forall_ a$z1 =>{{Integral a$z1}} -> u0 -> a$z1) (u9 :: _forall_ a$z1 =>{{Integral a$z1}} -> u0 -> a$z1) (ua :: _forall_ a$z1 =>{{Integral a$z1}} -> u0 -> a$z1) (ub :: _forall_ a$z1 =>{{Integral a$z1}} -> u0 -> a$z1) -> case u5 of { _ALG_ _TUP_3 (uc :: {{Num u0}}) (ud :: {{Enum u0}}) (ue :: u0 -> Ratio Integer) -> _APP_ ue [ u4 ]; _NO_DEFLT_ }; _NO_DEFLT_ }} in _APP_ u3 [ uf ] _N_} _F_ _IF_ARGS_ 2 3 CCX 8 _/\_ u0 u1 -> \ (u2 :: {{RealFrac u0}}) (u3 :: {{Fractional u1}}) (u4 :: u0) -> let {(uf :: Ratio Integer) = case u2 of { _ALG_ _TUP_7 (u5 :: {{Real u0}}) (u6 :: {{Fractional u0}}) (u7 :: _forall_ a$z1 =>{{Integral a$z1}} -> u0 -> (a$z1, u0)) (u8 :: _forall_ a$z1 =>{{Integral a$z1}} -> u0 -> a$z1) (u9 :: _forall_ a$z1 =>{{Integral a$z1}} -> u0 -> a$z1) (ua :: _forall_ a$z1 =>{{Integral a$z1}} -> u0 -> a$z1) (ub :: _forall_ a$z1 =>{{Integral a$z1}} -> u0 -> a$z1) -> case u5 of { _ALG_ _TUP_3 (uc :: {{Num u0}}) (ud :: {{Enum u0}}) (ue :: u0 -> Ratio Integer) -> _APP_ ue [ u4 ]; _NO_DEFLT_ }; _NO_DEFLT_ }} in case u3 of { _ALG_ _TUP_4 (ug :: {{Num u1}}) (uh :: u1 -> u1 -> u1) (ui :: u1 -> u1) (uj :: Ratio Integer -> u1) -> _APP_ uj [ uf ]; _NO_DEFLT_ } _SPECIALISE_ [ Double, Double ] 2 { _A_ 1 _U_ 1 _N_ _N_ _F_ _IF_ARGS_ 0 0 X 1 _TYAPP_ _ORIG_ Prelude id { Double } _N_ }, [ Double, Float ] 2 { _A_ 1 _U_ 1 _N_ _S_ "U(P)" {_A_ 1 _U_ 2 _N_ _N_ _F_ _IF_ARGS_ 0 1 X 3 \ (u0 :: Double#) -> case _#_ double2Float# [] [u0] of { _PRIM_ (u1 :: Float#) -> _!_ F# [] [u1] } _N_} _F_ _IF_ARGS_ 0 1 C 4 \ (u0 :: Double) -> case u0 of { _ALG_ D# (u1 :: Double#) -> case _#_ double2Float# [] [u1] of { _PRIM_ (u2 :: Float#) -> _!_ F# [] [u2] }; _NO_DEFLT_ } _N_ }, [ Float, Double ] 2 { _A_ 1 _U_ 1 _N_ _S_ "U(P)" {_A_ 1 _U_ 2 _N_ _N_ _F_ _IF_ARGS_ 0 1 X 3 \ (u0 :: Float#) -> case _#_ float2Double# [] [u0] of { _PRIM_ (u1 :: Double#) -> _!_ D# [] [u1] } _N_} _F_ _IF_ARGS_ 0 1 C 4 \ (u0 :: Float) -> case u0 of { _ALG_ F# (u1 :: Float#) -> case _#_ float2Double# [] [u1] of { _PRIM_ (u2 :: Double#) -> _!_ D# [] [u2] }; _NO_DEFLT_ } _N_ }, [ Float, Float ] 2 { _A_ 1 _U_ 1 _N_ _N_ _F_ _IF_ARGS_ 0 0 X 1 _TYAPP_ _ORIG_ Prelude id { Float } _N_ } #-}
+ {-# GHC_PRAGMA _A_ 3 _U_ 112 _N_ _S_ "LU(AAAS)L" {_A_ 3 _U_ 112 _N_ _N_ _F_ _IF_ARGS_ 2 3 CXX 7 _/\_ u0 u1 -> \ (u2 :: {{RealFrac u0}}) (u3 :: Ratio Integer -> u1) (u4 :: u0) -> let {(uf :: Ratio Integer) = case u2 of { _ALG_ _TUP_7 (u5 :: {{Real u0}}) (u6 :: {{Fractional u0}}) (u7 :: _forall_ a$z1 =>{{Integral a$z1}} -> u0 -> (a$z1, u0)) (u8 :: _forall_ a$z1 =>{{Integral a$z1}} -> u0 -> a$z1) (u9 :: _forall_ a$z1 =>{{Integral a$z1}} -> u0 -> a$z1) (ua :: _forall_ a$z1 =>{{Integral a$z1}} -> u0 -> a$z1) (ub :: _forall_ a$z1 =>{{Integral a$z1}} -> u0 -> a$z1) -> case u5 of { _ALG_ _TUP_3 (uc :: {{Num u0}}) (ud :: {{Enum u0}}) (ue :: u0 -> Ratio Integer) -> _APP_ ue [ u4 ]; _NO_DEFLT_ }; _NO_DEFLT_ }} in _APP_ u3 [ uf ] _N_} _F_ _IF_ARGS_ 2 3 CCX 8 _/\_ u0 u1 -> \ (u2 :: {{RealFrac u0}}) (u3 :: {{Fractional u1}}) (u4 :: u0) -> let {(uf :: Ratio Integer) = case u2 of { _ALG_ _TUP_7 (u5 :: {{Real u0}}) (u6 :: {{Fractional u0}}) (u7 :: _forall_ a$z1 =>{{Integral a$z1}} -> u0 -> (a$z1, u0)) (u8 :: _forall_ a$z1 =>{{Integral a$z1}} -> u0 -> a$z1) (u9 :: _forall_ a$z1 =>{{Integral a$z1}} -> u0 -> a$z1) (ua :: _forall_ a$z1 =>{{Integral a$z1}} -> u0 -> a$z1) (ub :: _forall_ a$z1 =>{{Integral a$z1}} -> u0 -> a$z1) -> case u5 of { _ALG_ _TUP_3 (uc :: {{Num u0}}) (ud :: {{Enum u0}}) (ue :: u0 -> Ratio Integer) -> _APP_ ue [ u4 ]; _NO_DEFLT_ }; _NO_DEFLT_ }} in case u3 of { _ALG_ _TUP_4 (ug :: {{Num u1}}) (uh :: u1 -> u1 -> u1) (ui :: u1 -> u1) (uj :: Ratio Integer -> u1) -> _APP_ uj [ uf ]; _NO_DEFLT_ } _SPECIALISE_ [ Double, Double ] 2 { _A_ 1 _U_ 1 _N_ _N_ _F_ _IF_ARGS_ 0 0 X 1 _TYAPP_ _ORIG_ Prelude id { Double } _N_ }, [ Double, Float ] 2 { _A_ 1 _U_ 1 _N_ _S_ "U(P)" {_A_ 1 _U_ 2 _N_ _N_ _F_ _IF_ARGS_ 0 1 X 3 \ (u0 :: Double#) -> case _#_ double2Float# [] [u0] of { _PRIM_ (u1 :: Float#) -> _!_ F# [] [u1] } _N_} _F_ _IF_ARGS_ 0 1 C 4 \ (u0 :: Double) -> case u0 of { _ALG_ D# (u1 :: Double#) -> case _#_ double2Float# [] [u1] of { _PRIM_ (u2 :: Float#) -> _!_ F# [] [u2] }; _NO_DEFLT_ } _N_ }, [ Double, (Ratio Integer) ] 2 { _A_ 1 _U_ 1 _N_ _S_ "U(P)" {_A_ 1 _U_ 2 _N_ _N_ _N_ _N_} _N_ _N_ }, [ Float, Double ] 2 { _A_ 1 _U_ 1 _N_ _S_ "U(P)" {_A_ 1 _U_ 2 _N_ _N_ _F_ _IF_ARGS_ 0 1 X 3 \ (u0 :: Float#) -> case _#_ float2Double# [] [u0] of { _PRIM_ (u1 :: Double#) -> _!_ D# [] [u1] } _N_} _F_ _IF_ARGS_ 0 1 C 4 \ (u0 :: Float) -> case u0 of { _ALG_ F# (u1 :: Float#) -> case _#_ float2Double# [] [u1] of { _PRIM_ (u2 :: Double#) -> _!_ D# [] [u2] }; _NO_DEFLT_ } _N_ }, [ Float, Float ] 2 { _A_ 1 _U_ 1 _N_ _N_ _F_ _IF_ARGS_ 0 0 X 1 _TYAPP_ _ORIG_ Prelude id { Float } _N_ }, [ Float, (Ratio Integer) ] 2 { _A_ 1 _U_ 1 _N_ _S_ "U(P)" {_A_ 1 _U_ 2 _N_ _N_ _N_ _N_} _N_ _N_ }, [ (Ratio Integer), Double ] 2 { _A_ 1 _U_ 1 _N_ _S_ "U(U(PPP)U(PPP))" {_A_ 4 _U_ 2222 _N_ _N_ _N_ _N_} _N_ _N_ }, [ (Ratio Integer), Float ] 2 { _A_ 1 _U_ 2 _N_ _N_ _F_ _IF_ARGS_ 0 0 X 1 _CONSTM_ Fractional fromRational (Float) _N_ }, [ (Ratio Integer), (Ratio Integer) ] 2 { _A_ 1 _U_ 1 _N_ _N_ _F_ _IF_ARGS_ 0 0 X 1 _TYAPP_ _ORIG_ Prelude id { (Ratio Integer) } _N_ } #-}
fst :: (b, a) -> b
{-# GHC_PRAGMA _A_ 1 _U_ 1 _N_ _S_ "U(SA)" {_A_ 1 _U_ 1 _N_ _N_ _F_ _IF_ARGS_ 2 1 X 1 _/\_ u0 u1 -> \ (u2 :: u1) -> u2 _N_} _F_ _IF_ARGS_ 2 1 C 2 _/\_ u0 u1 -> \ (u2 :: (u1, u0)) -> case u2 of { _ALG_ _TUP_2 (u3 :: u1) (u4 :: u0) -> u3; _NO_DEFLT_ } _N_ #-}
gcd :: Integral a => a -> a -> a
isLower :: Char -> Bool
{-# GHC_PRAGMA _A_ 1 _U_ 1 _N_ _S_ "U(P)" {_A_ 1 _U_ 2 _N_ _N_ _N_ _N_} _N_ _N_ #-}
isNullBin :: Bin -> Bool
- {-# GHC_PRAGMA _A_ 1 _U_ 2 _N_ _S_ _!_ _F_ _IF_ARGS_ 0 1 X 3 \ (u0 :: Bin) -> _APP_ _TYAPP_ error { (Bin -> Bool) } [ _NOREP_S_ "isNullBin{Prelude}\n", u0 ] _N_ #-}
+ {-# GHC_PRAGMA _A_ 1 _U_ 2 _N_ _S_ _!_ _N_ _N_ #-}
isPrint :: Char -> Bool
{-# GHC_PRAGMA _A_ 1 _U_ 1 _N_ _S_ "U(P)" {_A_ 1 _U_ 2 _N_ _N_ _N_ _N_} _N_ _N_ #-}
isSpace :: Char -> Bool
not :: Bool -> Bool
{-# GHC_PRAGMA _A_ 1 _U_ 1 _N_ _S_ "E" _F_ _ALWAYS_ \ (u0 :: Bool) -> case u0 of { _ALG_ True -> _!_ False [] []; False -> _!_ True [] []; _NO_DEFLT_ } _N_ #-}
nullBin :: Bin
- {-# GHC_PRAGMA _A_ 0 _N_ _N_ _S_ _!_ _F_ _IF_ARGS_ 0 0 X 2 _APP_ _TYAPP_ error { Bin } [ _NOREP_S_ "nullBin{Prelude}\n" ] _N_ #-}
+ {-# GHC_PRAGMA _A_ 0 _N_ _N_ _S_ _!_ _N_ _N_ #-}
ord :: Char -> Int
{-# GHC_PRAGMA _A_ 1 _U_ 1 _N_ _S_ "U(P)" {_A_ 1 _U_ 2 _N_ _N_ _F_ _IF_ARGS_ 0 1 X 3 \ (u0 :: Char#) -> case _#_ ord# [] [u0] of { _PRIM_ (u1 :: Int#) -> _!_ I# [] [u1] } _N_} _F_ _IF_ARGS_ 0 1 C 4 \ (u0 :: Char) -> case u0 of { _ALG_ C# (u1 :: Char#) -> case _#_ ord# [] [u1] of { _PRIM_ (u2 :: Int#) -> _!_ I# [] [u2] }; _NO_DEFLT_ } _N_ #-}
otherwise :: Bool
snd :: (a, b) -> b
{-# GHC_PRAGMA _A_ 1 _U_ 1 _N_ _S_ "U(AS)" {_A_ 1 _U_ 1 _N_ _N_ _F_ _IF_ARGS_ 2 1 X 1 _/\_ u0 u1 -> \ (u2 :: u1) -> u2 _N_} _F_ _IF_ARGS_ 2 1 C 2 _/\_ u0 u1 -> \ (u2 :: (u0, u1)) -> case u2 of { _ALG_ _TUP_2 (u3 :: u0) (u4 :: u1) -> u4; _NO_DEFLT_ } _N_ #-}
subtract :: Num a => a -> a -> a
- {-# GHC_PRAGMA _A_ 3 _U_ 122 _N_ _S_ "U(AAASAAAAAA)LL" {_A_ 3 _U_ 122 _N_ _N_ _F_ _IF_ARGS_ 1 3 XXX 3 _/\_ u0 -> \ (u1 :: u0 -> u0 -> u0) (u2 :: u0) (u3 :: u0) -> _APP_ u1 [ u3, u2 ] _N_} _F_ _IF_ARGS_ 1 3 CXX 4 _/\_ u0 -> \ (u1 :: {{Num u0}}) (u2 :: u0) (u3 :: u0) -> case u1 of { _ALG_ _TUP_10 (u4 :: {{Eq u0}}) (u5 :: {{Text u0}}) (u6 :: u0 -> u0 -> u0) (u7 :: u0 -> u0 -> u0) (u8 :: u0 -> u0 -> u0) (u9 :: u0 -> u0) (ua :: u0 -> u0) (ub :: u0 -> u0) (uc :: Integer -> u0) (ud :: Int -> u0) -> _APP_ u7 [ u3, u2 ]; _NO_DEFLT_ } _SPECIALISE_ [ Double ] 1 { _A_ 2 _U_ 11 _N_ _S_ "U(P)U(P)" {_A_ 2 _U_ 22 _N_ _N_ _F_ _IF_ARGS_ 0 2 XX 3 \ (u0 :: Double#) (u1 :: Double#) -> case _#_ minusDouble# [] [u1, u0] of { _PRIM_ (u2 :: Double#) -> _!_ D# [] [u2] } _N_} _F_ _IF_ARGS_ 0 2 CC 5 \ (u0 :: Double) (u1 :: Double) -> case u1 of { _ALG_ D# (u2 :: Double#) -> case u0 of { _ALG_ D# (u3 :: Double#) -> case _#_ minusDouble# [] [u2, u3] of { _PRIM_ (u4 :: Double#) -> _!_ D# [] [u4] }; _NO_DEFLT_ }; _NO_DEFLT_ } _N_ }, [ Int ] 1 { _A_ 2 _U_ 11 _N_ _S_ "U(P)U(P)" {_A_ 2 _U_ 22 _N_ _N_ _F_ _IF_ARGS_ 0 2 XX 3 \ (u0 :: Int#) (u1 :: Int#) -> case _#_ minusInt# [] [u1, u0] of { _PRIM_ (u2 :: Int#) -> _!_ I# [] [u2] } _N_} _F_ _IF_ARGS_ 0 2 CC 5 \ (u0 :: Int) (u1 :: Int) -> case u1 of { _ALG_ I# (u2 :: Int#) -> case u0 of { _ALG_ I# (u3 :: Int#) -> case _#_ minusInt# [] [u2, u3] of { _PRIM_ (u4 :: Int#) -> _!_ I# [] [u4] }; _NO_DEFLT_ }; _NO_DEFLT_ } _N_ } #-}
+ {-# GHC_PRAGMA _A_ 3 _U_ 122 _N_ _S_ "U(AAASAAAAAA)LL" {_A_ 3 _U_ 122 _N_ _N_ _F_ _IF_ARGS_ 1 3 XXX 3 _/\_ u0 -> \ (u1 :: u0 -> u0 -> u0) (u2 :: u0) (u3 :: u0) -> _APP_ u1 [ u3, u2 ] _N_} _F_ _IF_ARGS_ 1 3 CXX 4 _/\_ u0 -> \ (u1 :: {{Num u0}}) (u2 :: u0) (u3 :: u0) -> case u1 of { _ALG_ _TUP_10 (u4 :: {{Eq u0}}) (u5 :: {{Text u0}}) (u6 :: u0 -> u0 -> u0) (u7 :: u0 -> u0 -> u0) (u8 :: u0 -> u0 -> u0) (u9 :: u0 -> u0) (ua :: u0 -> u0) (ub :: u0 -> u0) (uc :: Integer -> u0) (ud :: Int -> u0) -> _APP_ u7 [ u3, u2 ]; _NO_DEFLT_ } _SPECIALISE_ [ Double ] 1 { _A_ 2 _U_ 11 _N_ _S_ "U(P)U(P)" {_A_ 2 _U_ 22 _N_ _N_ _F_ _IF_ARGS_ 0 2 XX 3 \ (u0 :: Double#) (u1 :: Double#) -> case _#_ minusDouble# [] [u1, u0] of { _PRIM_ (u2 :: Double#) -> _!_ D# [] [u2] } _N_} _F_ _IF_ARGS_ 0 2 CC 5 \ (u0 :: Double) (u1 :: Double) -> case u1 of { _ALG_ D# (u2 :: Double#) -> case u0 of { _ALG_ D# (u3 :: Double#) -> case _#_ minusDouble# [] [u2, u3] of { _PRIM_ (u4 :: Double#) -> _!_ D# [] [u4] }; _NO_DEFLT_ }; _NO_DEFLT_ } _N_ }, [ Int ] 1 { _A_ 2 _U_ 11 _N_ _S_ "U(P)U(P)" {_A_ 2 _U_ 22 _N_ _N_ _F_ _IF_ARGS_ 0 2 XX 3 \ (u0 :: Int#) (u1 :: Int#) -> case _#_ minusInt# [] [u1, u0] of { _PRIM_ (u2 :: Int#) -> _!_ I# [] [u2] } _N_} _F_ _IF_ARGS_ 0 2 CC 5 \ (u0 :: Int) (u1 :: Int) -> case u1 of { _ALG_ I# (u2 :: Int#) -> case u0 of { _ALG_ I# (u3 :: Int#) -> case _#_ minusInt# [] [u2, u3] of { _PRIM_ (u4 :: Int#) -> _!_ I# [] [u4] }; _NO_DEFLT_ }; _NO_DEFLT_ } _N_ }, [ (Complex Double) ] 1 { _A_ 2 _U_ 11 _N_ _S_ "U(LL)U(LL)" {_A_ 4 _U_ 2222 _N_ _N_ _N_ _N_} _N_ _N_ } #-}
thenMaybe :: Maybe a -> (a -> Maybe b) -> Maybe b
{-# GHC_PRAGMA _A_ 2 _U_ 11 _N_ _S_ "SL" _F_ _IF_ARGS_ 2 2 CX 5 _/\_ u0 u1 -> \ (u2 :: Maybe u0) (u3 :: u0 -> Maybe u1) -> case u2 of { _ALG_ Nothing -> _!_ Nothing [u1] []; Just (u4 :: u0) -> _APP_ u3 [ u4 ]; _NO_DEFLT_ } _N_ #-}
toLower :: Char -> Char
imagPart :: Complex a -> a
{-# GHC_PRAGMA _A_ 1 _U_ 1 _N_ _S_ "U(AS)" {_A_ 1 _U_ 1 _N_ _N_ _F_ _IF_ARGS_ 1 1 X 1 _/\_ u0 -> \ (u1 :: u0) -> u1 _N_} _F_ _IF_ARGS_ 1 1 C 2 _/\_ u0 -> \ (u1 :: Complex u0) -> case u1 of { _ALG_ (:+) (u2 :: u0) (u3 :: u0) -> u3; _NO_DEFLT_ } _N_ #-}
magnitude :: RealFloat a => Complex a -> a
- {-# GHC_PRAGMA _A_ 1 _U_ 12 _N_ _S_ "U(ALAAAAALAS)" {_A_ 3 _U_ 2221 _N_ _N_ _N_ _N_} _N_ _SPECIALISE_ [ Double ] 1 { _A_ 1 _U_ 1 _N_ _S_ "U(LL)" {_A_ 2 _U_ 22 _N_ _N_ _N_ _N_} _N_ _N_ } #-}
+ {-# GHC_PRAGMA _A_ 1 _U_ 12 _N_ _S_ "U(ALAAAAALAS)" {_A_ 3 _U_ 2221 _N_ _N_ _N_ _N_} _N_ _SPECIALISE_ [ Double ] 1 { _A_ 1 _U_ 1 _N_ _S_ "U(U(P)U(P))" {_A_ 2 _U_ 22 _N_ _N_ _N_ _N_} _N_ _N_ } #-}
mkPolar :: RealFloat a => a -> a -> Complex a
{-# GHC_PRAGMA _A_ 3 _U_ 122 _N_ _N_ _N_ _SPECIALISE_ [ Double ] 1 { _A_ 2 _U_ 22 _N_ _N_ _N_ _N_ } #-}
phase :: RealFloat a => Complex a -> a
{-# GHC_PRAGMA _A_ 1 _U_ 22 _N_ _N_ _N_ _SPECIALISE_ [ Double ] 1 { _A_ 1 _U_ 2 _N_ _N_ _N_ _N_ } #-}
realPart :: Complex a -> a
{-# GHC_PRAGMA _A_ 1 _U_ 1 _N_ _S_ "U(SA)" {_A_ 1 _U_ 1 _N_ _N_ _F_ _IF_ARGS_ 1 1 X 1 _/\_ u0 -> \ (u1 :: u0) -> u1 _N_} _F_ _IF_ARGS_ 1 1 C 2 _/\_ u0 -> \ (u1 :: Complex u0) -> case u1 of { _ALG_ (:+) (u2 :: u0) (u3 :: u0) -> u2; _NO_DEFLT_ } _N_ #-}
-_ceiling :: (RealFrac a, Integral b) => a -> b
- {-# GHC_PRAGMA _A_ 2 _U_ 122 _N_ _S_ "U(U(AU(U(AAAASAAA)AAAA)A)LSAAAA)L" {_A_ 4 _U_ 11122 _N_ _N_ _N_ _N_} _N_ _SPECIALISE_ [ Double, Int ] 2 { _A_ 0 _U_ 2 _N_ _N_ _N_ _N_ } #-}
-_floor :: (RealFrac a, Integral b) => a -> b
- {-# GHC_PRAGMA _A_ 2 _U_ 122 _N_ _S_ "U(U(AU(U(ASAAAAAA)AAAA)A)LSAAAA)L" {_A_ 4 _U_ 11122 _N_ _N_ _N_ _N_} _N_ _SPECIALISE_ [ Double, Int ] 2 { _A_ 0 _U_ 2 _N_ _N_ _N_ _N_ } #-}
-_readList :: Text a => [Char] -> [([a], [Char])]
+_readList :: ([Char] -> [(a, [Char])]) -> [Char] -> [([a], [Char])]
{-# GHC_PRAGMA _A_ 1 _U_ 22 _N_ _N_ _N_ _N_ #-}
-_round :: (RealFrac a, Integral b) => a -> b
- {-# GHC_PRAGMA _A_ 2 _U_ 122 _N_ _S_ "U(U(AU(U(ALAAAAAS)AAAA)A)LSAAAA)L" {_A_ 5 _U_ 112122 _N_ _N_ _N_ _N_} _N_ _SPECIALISE_ [ Double, Int ] 2 { _A_ 0 _U_ 2 _N_ _N_ _N_ _N_ }, [ (Ratio Integer), Integer ] 2 { _A_ 1 _U_ 1 _N_ _S_ "U(LL)" {_A_ 2 _U_ 22 _N_ _N_ _N_ _N_} _N_ _N_ } #-}
-_showList :: Text a => [a] -> [Char] -> [Char]
- {-# GHC_PRAGMA _A_ 1 _U_ 212 _N_ _N_ _N_ _N_ #-}
+_showList :: (a -> [Char] -> [Char]) -> [a] -> [Char] -> [Char]
+ {-# GHC_PRAGMA _A_ 2 _U_ 212 _N_ _S_ "LS" _N_ _N_ #-}
_showRational :: Int -> Ratio Integer -> [Char]
{-# GHC_PRAGMA _A_ 2 _U_ 21 _N_ _S_ "LU(U(PPP)L)" {_A_ 5 _U_ 22222 _N_ _N_ _N_ _N_} _N_ _N_ #-}
-_truncate :: (RealFrac a, Integral b) => a -> b
- {-# GHC_PRAGMA _A_ 2 _U_ 122 _N_ _S_ "U(AASAAAA)L" {_A_ 2 _U_ 122 _N_ _N_ _N_ _N_} _N_ _SPECIALISE_ [ Double, Int ] 2 { _A_ 0 _U_ 2 _N_ _N_ _N_ _N_ } #-}
interact :: ([Char] -> [Char]) -> _State _RealWorld -> (Either IOError13 (), _State _RealWorld)
{-# GHC_PRAGMA _A_ 2 _U_ 11 _N_ _S_ "LU(P)" {_A_ 2 _U_ 12 _N_ _N_ _N_ _N_} _N_ _N_ #-}
(!!) :: Integral a => [b] -> a -> b
(++) :: [a] -> [a] -> [a]
{-# GHC_PRAGMA _A_ 2 _U_ 12 _N_ _S_ "SL" _N_ _N_ #-}
(\\) :: Eq a => [a] -> [a] -> [a]
- {-# GHC_PRAGMA _A_ 3 _U_ 122 _N_ _S_ "LLS" _N_ _N_ #-}
+ {-# GHC_PRAGMA _A_ 3 _U_ 122 _N_ _S_ "LLS" _N_ _SPECIALISE_ [ Int ] 1 { _A_ 2 _U_ 22 _N_ _S_ "LS" _N_ _N_ }, [ [Char] ] 1 { _A_ 2 _U_ 22 _N_ _S_ "LS" _N_ _N_ } #-}
all :: (a -> Bool) -> [a] -> Bool
{-# GHC_PRAGMA _A_ 2 _U_ 21 _N_ _S_ "LS" _F_ _ALWAYS_ _/\_ u0 -> \ (u1 :: u0 -> Bool) (u2 :: [u0]) -> let {(u3 :: Bool) = _!_ True [] []} in let {(u6 :: u0 -> Bool -> Bool) = \ (u4 :: u0) (u5 :: Bool) -> case _APP_ u1 [ u4 ] of { _ALG_ True -> u5; False -> _!_ False [] []; _NO_DEFLT_ }} in _APP_ _TYAPP_ _TYAPP_ foldr { u0 } { Bool } [ u6, u3, u2 ] _N_ #-}
and :: [Bool] -> Bool
dropWhile :: (a -> Bool) -> [a] -> [a]
{-# GHC_PRAGMA _A_ 2 _U_ 21 _N_ _S_ "LS" _N_ _N_ #-}
elem :: Eq a => a -> [a] -> Bool
- {-# GHC_PRAGMA _A_ 3 _U_ 121 _N_ _S_ "LLS" _F_ _ALWAYS_ _/\_ u0 -> \ (u1 :: {{Eq u0}}) (u2 :: u0) (u3 :: [u0]) -> let {(u6 :: u0 -> u0 -> Bool) = case u1 of { _ALG_ _TUP_2 (u4 :: u0 -> u0 -> Bool) (u5 :: u0 -> u0 -> Bool) -> u4; _NO_DEFLT_ }} in let {(u8 :: u0 -> Bool) = \ (u7 :: u0) -> _APP_ u6 [ u2, u7 ]} in _APP_ _TYAPP_ _ORIG_ PreludeList any { u0 } [ u8, u3 ] _SPECIALISE_ [ Char ] 1 { _A_ 2 _U_ 21 _N_ _S_ "LS" _F_ _ALWAYS_ \ (u0 :: Char) (u1 :: [Char]) -> let {(u5 :: Char -> Bool) = \ (u2 :: Char) -> case u0 of { _ALG_ C# (u3 :: Char#) -> case u2 of { _ALG_ C# (u4 :: Char#) -> _#_ eqChar# [] [u3, u4]; _NO_DEFLT_ }; _NO_DEFLT_ }} in _APP_ _TYAPP_ _ORIG_ PreludeList any { Char } [ u5, u1 ] _N_ }, [ Int ] 1 { _A_ 2 _U_ 21 _N_ _S_ "LS" _F_ _ALWAYS_ \ (u0 :: Int) (u1 :: [Int]) -> let {(u5 :: Int -> Bool) = \ (u2 :: Int) -> case u0 of { _ALG_ I# (u3 :: Int#) -> case u2 of { _ALG_ I# (u4 :: Int#) -> _#_ eqInt# [] [u3, u4]; _NO_DEFLT_ }; _NO_DEFLT_ }} in _APP_ _TYAPP_ _ORIG_ PreludeList any { Int } [ u5, u1 ] _N_ }, [ [Char] ] 1 { _A_ 2 _U_ 21 _N_ _S_ "LS" _F_ _ALWAYS_ \ (u0 :: [Char]) (u1 :: [[Char]]) -> let {(u3 :: [Char] -> Bool) = \ (u2 :: [Char]) -> _APP_ _CONSTM_ Eq (==) ([Char]) [ u0, u2 ]} in _APP_ _TYAPP_ _ORIG_ PreludeList any { [Char] } [ u3, u1 ] _N_ } #-}
+ {-# GHC_PRAGMA _A_ 3 _U_ 121 _N_ _S_ "LLS" _F_ _ALWAYS_ _/\_ u0 -> \ (u1 :: {{Eq u0}}) (u2 :: u0) (u3 :: [u0]) -> let {(u6 :: u0 -> u0 -> Bool) = case u1 of { _ALG_ _TUP_2 (u4 :: u0 -> u0 -> Bool) (u5 :: u0 -> u0 -> Bool) -> u4; _NO_DEFLT_ }} in let {(u8 :: u0 -> Bool) = \ (u7 :: u0) -> _APP_ u6 [ u2, u7 ]} in _APP_ _TYAPP_ _ORIG_ PreludeList any { u0 } [ u8, u3 ] _SPECIALISE_ [ Char ] 1 { _A_ 2 _U_ 21 _N_ _S_ "LS" _F_ _ALWAYS_ \ (u0 :: Char) (u1 :: [Char]) -> let {(u5 :: Char -> Bool) = \ (u2 :: Char) -> case u0 of { _ALG_ C# (u3 :: Char#) -> case u2 of { _ALG_ C# (u4 :: Char#) -> _#_ eqChar# [] [u3, u4]; _NO_DEFLT_ }; _NO_DEFLT_ }} in _APP_ _TYAPP_ _ORIG_ PreludeList any { Char } [ u5, u1 ] _N_ }, [ Int ] 1 { _A_ 2 _U_ 21 _N_ _S_ "LS" _F_ _ALWAYS_ \ (u0 :: Int) (u1 :: [Int]) -> let {(u5 :: Int -> Bool) = \ (u2 :: Int) -> case u0 of { _ALG_ I# (u3 :: Int#) -> case u2 of { _ALG_ I# (u4 :: Int#) -> _#_ eqInt# [] [u3, u4]; _NO_DEFLT_ }; _NO_DEFLT_ }} in _APP_ _TYAPP_ _ORIG_ PreludeList any { Int } [ u5, u1 ] _N_ }, [ Integer ] 1 { _A_ 2 _U_ 21 _N_ _S_ "LS" _F_ _ALWAYS_ \ (u0 :: Integer) (u1 :: [Integer]) -> let {(ua :: Integer -> Bool) = \ (u2 :: Integer) -> case u0 of { _ALG_ J# (u3 :: Int#) (u4 :: Int#) (u5 :: ByteArray#) -> case u2 of { _ALG_ J# (u6 :: Int#) (u7 :: Int#) (u8 :: ByteArray#) -> case _#_ cmpInteger# [] [u3, u4, u5, u6, u7, u8] of { _PRIM_ 0# -> _!_ True [] []; (u9 :: Int#) -> _!_ False [] [] }; _NO_DEFLT_ }; _NO_DEFLT_ }} in _APP_ _TYAPP_ _ORIG_ PreludeList any { Integer } [ ua, u1 ] _N_ }, [ [Char] ] 1 { _A_ 2 _U_ 21 _N_ _S_ "LS" _F_ _ALWAYS_ \ (u0 :: [Char]) (u1 :: [[Char]]) -> let {(u3 :: [Char] -> Bool) = \ (u2 :: [Char]) -> _APP_ _CONSTM_ Eq (==) ([Char]) [ u0, u2 ]} in _APP_ _TYAPP_ _ORIG_ PreludeList any { [Char] } [ u3, u1 ] _N_ }, [ [Int] ] 1 { _A_ 2 _U_ 21 _N_ _S_ "LS" _F_ _ALWAYS_ \ (u0 :: [Int]) (u1 :: [[Int]]) -> let {(u3 :: [Int] -> Bool) = \ (u2 :: [Int]) -> _APP_ _CONSTM_ Eq (==) ([Int]) [ u0, u2 ]} in _APP_ _TYAPP_ _ORIG_ PreludeList any { [Int] } [ u3, u1 ] _N_ }, [ (Int, Int) ] 1 { _A_ 2 _U_ 21 _N_ _S_ "LS" _F_ _ALWAYS_ \ (u0 :: (Int, Int)) (u1 :: [(Int, Int)]) -> let {(ub :: (Int, Int) -> Bool) = \ (u2 :: (Int, Int)) -> case u0 of { _ALG_ _TUP_2 (u3 :: Int) (u4 :: Int) -> case u3 of { _ALG_ I# (u5 :: Int#) -> case u2 of { _ALG_ _TUP_2 (u6 :: Int) (u7 :: Int) -> case u6 of { _ALG_ I# (u8 :: Int#) -> case _#_ eqInt# [] [u5, u8] of { _ALG_ True -> case u4 of { _ALG_ I# (u9 :: Int#) -> case u7 of { _ALG_ I# (ua :: Int#) -> _#_ eqInt# [] [u9, ua]; _NO_DEFLT_ }; _NO_DEFLT_ }; False -> _!_ False [] []; _NO_DEFLT_ }; _NO_DEFLT_ }; _NO_DEFLT_ }; _NO_DEFLT_ }; _NO_DEFLT_ }} in _APP_ _TYAPP_ _ORIG_ PreludeList any { (Int, Int) } [ ub, u1 ] _N_ } #-}
filter :: (a -> Bool) -> [a] -> [a]
{-# GHC_PRAGMA _A_ 2 _U_ 21 _N_ _S_ "LS" _F_ _ALWAYS_ _/\_ u0 -> \ (u1 :: u0 -> Bool) (u2 :: [u0]) -> let {(u9 :: _forall_ a$z1 =>(u0 -> a$z1 -> a$z1) -> a$z1 -> a$z1) = _/\_ u3 -> \ (u4 :: u0 -> u3 -> u3) (u5 :: u3) -> let {(u8 :: u0 -> u3 -> u3) = \ (u6 :: u0) (u7 :: u3) -> case _APP_ u1 [ u6 ] of { _ALG_ True -> _APP_ u4 [ u6, u7 ]; False -> u7; _NO_DEFLT_ }} in _APP_ _TYAPP_ _TYAPP_ foldr { u0 } { u3 } [ u8, u5, u2 ]} in _APP_ _TYAPP_ _build { u0 } [ u9 ] _N_ #-}
foldl1 :: (a -> a -> a) -> [a] -> a
foldr1 :: (a -> a -> a) -> [a] -> a
{-# GHC_PRAGMA _A_ 2 _U_ 21 _N_ _S_ "LS" _N_ _N_ #-}
genericLength :: Num b => [a] -> b
- {-# GHC_PRAGMA _A_ 1 _U_ 21 _N_ _N_ _N_ _N_ #-}
+ {-# GHC_PRAGMA _A_ 1 _U_ 21 _N_ _N_ _N_ _SPECIALISE_ [ _N_, Int ] 1 { _A_ 1 _U_ 1 _N_ _S_ "S" _N_ _N_ }, [ _N_, Integer ] 1 { _A_ 1 _U_ 1 _N_ _S_ "S" _N_ _N_ } #-}
head :: [a] -> a
{-# GHC_PRAGMA _A_ 1 _U_ 1 _N_ _S_ "S" _F_ _ALWAYS_ _/\_ u0 -> \ (u1 :: [u0]) -> let {(u2 :: u0) = _APP_ _TYAPP_ error { u0 } [ _NOREP_S_ "head{PreludeList}: head []\n" ]} in let {(u5 :: u0 -> u0 -> u0) = \ (u3 :: u0) (u4 :: u0) -> u3} in _APP_ _TYAPP_ _TYAPP_ foldr { u0 } { u0 } [ u5, u2, u1 ] _N_ #-}
init :: [a] -> [a]
map :: (a -> b) -> [a] -> [b]
{-# GHC_PRAGMA _A_ 2 _U_ 21 _N_ _S_ "LS" _F_ _ALWAYS_ _/\_ u0 u1 -> \ (u2 :: u0 -> u1) (u3 :: [u0]) -> let {(ua :: _forall_ a$z1 =>(u1 -> a$z1 -> a$z1) -> a$z1 -> a$z1) = _/\_ u4 -> \ (u5 :: u1 -> u4 -> u4) (u6 :: u4) -> let {(u9 :: u0 -> u4 -> u4) = \ (u7 :: u0) -> let {(u8 :: u1) = _APP_ u2 [ u7 ]} in _APP_ u5 [ u8 ]} in _APP_ _TYAPP_ _TYAPP_ foldr { u0 } { u4 } [ u9, u6, u3 ]} in _APP_ _TYAPP_ _build { u1 } [ ua ] _N_ #-}
maximum :: Ord a => [a] -> a
- {-# GHC_PRAGMA _A_ 1 _U_ 11 _N_ _N_ _N_ _N_ #-}
+ {-# GHC_PRAGMA _A_ 1 _U_ 11 _N_ _N_ _N_ _SPECIALISE_ [ Double ] 1 { _A_ 1 _U_ 1 _N_ _S_ "S" _N_ _N_ }, [ Int ] 1 { _A_ 1 _U_ 1 _N_ _S_ "S" _N_ _N_ }, [ Integer ] 1 { _A_ 1 _U_ 1 _N_ _S_ "S" _N_ _N_ } #-}
minimum :: Ord a => [a] -> a
- {-# GHC_PRAGMA _A_ 1 _U_ 11 _N_ _N_ _N_ _N_ #-}
+ {-# GHC_PRAGMA _A_ 1 _U_ 11 _N_ _N_ _N_ _SPECIALISE_ [ Double ] 1 { _A_ 1 _U_ 1 _N_ _S_ "S" _N_ _N_ }, [ Int ] 1 { _A_ 1 _U_ 1 _N_ _S_ "S" _N_ _N_ }, [ Integer ] 1 { _A_ 1 _U_ 1 _N_ _S_ "S" _N_ _N_ } #-}
notElem :: Eq a => a -> [a] -> Bool
- {-# GHC_PRAGMA _A_ 3 _U_ 121 _N_ _S_ "LLS" _F_ _ALWAYS_ _/\_ u0 -> \ (u1 :: {{Eq u0}}) (u2 :: u0) (u3 :: [u0]) -> let {(u6 :: u0 -> u0 -> Bool) = case u1 of { _ALG_ _TUP_2 (u4 :: u0 -> u0 -> Bool) (u5 :: u0 -> u0 -> Bool) -> u5; _NO_DEFLT_ }} in let {(u8 :: u0 -> Bool) = \ (u7 :: u0) -> _APP_ u6 [ u2, u7 ]} in _APP_ _TYAPP_ _ORIG_ PreludeList all { u0 } [ u8, u3 ] _SPECIALISE_ [ Char ] 1 { _A_ 2 _U_ 21 _N_ _S_ "LS" _F_ _ALWAYS_ \ (u0 :: Char) (u1 :: [Char]) -> let {(u5 :: Char -> Bool) = \ (u2 :: Char) -> case u0 of { _ALG_ C# (u3 :: Char#) -> case u2 of { _ALG_ C# (u4 :: Char#) -> _#_ neChar# [] [u3, u4]; _NO_DEFLT_ }; _NO_DEFLT_ }} in _APP_ _TYAPP_ _ORIG_ PreludeList all { Char } [ u5, u1 ] _N_ }, [ Int ] 1 { _A_ 2 _U_ 21 _N_ _S_ "LS" _F_ _ALWAYS_ \ (u0 :: Int) (u1 :: [Int]) -> let {(u5 :: Int -> Bool) = \ (u2 :: Int) -> case u0 of { _ALG_ I# (u3 :: Int#) -> case u2 of { _ALG_ I# (u4 :: Int#) -> _#_ neInt# [] [u3, u4]; _NO_DEFLT_ }; _NO_DEFLT_ }} in _APP_ _TYAPP_ _ORIG_ PreludeList all { Int } [ u5, u1 ] _N_ }, [ [Char] ] 1 { _A_ 2 _U_ 21 _N_ _S_ "LS" _F_ _ALWAYS_ \ (u0 :: [Char]) (u1 :: [[Char]]) -> let {(u3 :: [Char] -> Bool) = \ (u2 :: [Char]) -> _APP_ _CONSTM_ Eq (/=) ([Char]) [ u0, u2 ]} in _APP_ _TYAPP_ _ORIG_ PreludeList all { [Char] } [ u3, u1 ] _N_ } #-}
+ {-# GHC_PRAGMA _A_ 3 _U_ 121 _N_ _S_ "LLS" _F_ _ALWAYS_ _/\_ u0 -> \ (u1 :: {{Eq u0}}) (u2 :: u0) (u3 :: [u0]) -> let {(u6 :: u0 -> u0 -> Bool) = case u1 of { _ALG_ _TUP_2 (u4 :: u0 -> u0 -> Bool) (u5 :: u0 -> u0 -> Bool) -> u5; _NO_DEFLT_ }} in let {(u8 :: u0 -> Bool) = \ (u7 :: u0) -> _APP_ u6 [ u2, u7 ]} in _APP_ _TYAPP_ _ORIG_ PreludeList all { u0 } [ u8, u3 ] _SPECIALISE_ [ Char ] 1 { _A_ 2 _U_ 21 _N_ _S_ "LS" _F_ _ALWAYS_ \ (u0 :: Char) (u1 :: [Char]) -> let {(u5 :: Char -> Bool) = \ (u2 :: Char) -> case u0 of { _ALG_ C# (u3 :: Char#) -> case u2 of { _ALG_ C# (u4 :: Char#) -> _#_ neChar# [] [u3, u4]; _NO_DEFLT_ }; _NO_DEFLT_ }} in _APP_ _TYAPP_ _ORIG_ PreludeList all { Char } [ u5, u1 ] _N_ }, [ Int ] 1 { _A_ 2 _U_ 21 _N_ _S_ "LS" _F_ _ALWAYS_ \ (u0 :: Int) (u1 :: [Int]) -> let {(u5 :: Int -> Bool) = \ (u2 :: Int) -> case u0 of { _ALG_ I# (u3 :: Int#) -> case u2 of { _ALG_ I# (u4 :: Int#) -> _#_ neInt# [] [u3, u4]; _NO_DEFLT_ }; _NO_DEFLT_ }} in _APP_ _TYAPP_ _ORIG_ PreludeList all { Int } [ u5, u1 ] _N_ }, [ Integer ] 1 { _A_ 2 _U_ 21 _N_ _S_ "LS" _F_ _ALWAYS_ \ (u0 :: Integer) (u1 :: [Integer]) -> let {(ua :: Integer -> Bool) = \ (u2 :: Integer) -> case u0 of { _ALG_ J# (u3 :: Int#) (u4 :: Int#) (u5 :: ByteArray#) -> case u2 of { _ALG_ J# (u6 :: Int#) (u7 :: Int#) (u8 :: ByteArray#) -> case _#_ cmpInteger# [] [u3, u4, u5, u6, u7, u8] of { _PRIM_ 0# -> _!_ False [] []; (u9 :: Int#) -> _!_ True [] [] }; _NO_DEFLT_ }; _NO_DEFLT_ }} in _APP_ _TYAPP_ _ORIG_ PreludeList all { Integer } [ ua, u1 ] _N_ }, [ [Char] ] 1 { _A_ 2 _U_ 21 _N_ _S_ "LS" _F_ _ALWAYS_ \ (u0 :: [Char]) (u1 :: [[Char]]) -> let {(u3 :: [Char] -> Bool) = \ (u2 :: [Char]) -> _APP_ _CONSTM_ Eq (/=) ([Char]) [ u0, u2 ]} in _APP_ _TYAPP_ _ORIG_ PreludeList all { [Char] } [ u3, u1 ] _N_ }, [ (Int, Int) ] 1 { _A_ 2 _U_ 21 _N_ _S_ "LS" _F_ _ALWAYS_ \ (u0 :: (Int, Int)) (u1 :: [(Int, Int)]) -> let {(ub :: (Int, Int) -> Bool) = \ (u2 :: (Int, Int)) -> case u0 of { _ALG_ _TUP_2 (u3 :: Int) (u4 :: Int) -> case u3 of { _ALG_ I# (u5 :: Int#) -> case u2 of { _ALG_ _TUP_2 (u6 :: Int) (u7 :: Int) -> case u6 of { _ALG_ I# (u8 :: Int#) -> case _#_ neInt# [] [u5, u8] of { _ALG_ True -> _!_ True [] []; False -> case u4 of { _ALG_ I# (u9 :: Int#) -> case u7 of { _ALG_ I# (ua :: Int#) -> _#_ neInt# [] [u9, ua]; _NO_DEFLT_ }; _NO_DEFLT_ }; _NO_DEFLT_ }; _NO_DEFLT_ }; _NO_DEFLT_ }; _NO_DEFLT_ }; _NO_DEFLT_ }} in _APP_ _TYAPP_ _ORIG_ PreludeList all { (Int, Int) } [ ub, u1 ] _N_ } #-}
nub :: Eq a => [a] -> [a]
- {-# GHC_PRAGMA _A_ 2 _U_ 11 _N_ _S_ "LS" _N_ _N_ #-}
+ {-# GHC_PRAGMA _A_ 2 _U_ 11 _N_ _S_ "LS" _N_ _SPECIALISE_ [ Int ] 1 { _A_ 1 _U_ 1 _N_ _S_ "S" _N_ _N_ }, [ [Char] ] 1 { _A_ 1 _U_ 1 _N_ _S_ "S" _N_ _N_ }, [ [Int] ] 1 { _A_ 1 _U_ 1 _N_ _S_ "S" _N_ _N_ } #-}
null :: [a] -> Bool
{-# GHC_PRAGMA _A_ 1 _U_ 1 _N_ _S_ "S" _F_ _ALWAYS_ _/\_ u0 -> \ (u1 :: [u0]) -> let {(u2 :: Bool) = _!_ True [] []} in let {(u5 :: u0 -> Bool -> Bool) = \ (u3 :: u0) (u4 :: Bool) -> _!_ False [] []} in _APP_ _TYAPP_ _TYAPP_ foldr { u0 } { Bool } [ u5, u2, u1 ] _N_ #-}
or :: [Bool] -> Bool
partition :: (a -> Bool) -> [a] -> ([a], [a])
{-# GHC_PRAGMA _A_ 2 _U_ 21 _N_ _S_ "LS" _F_ _ALWAYS_ _/\_ u0 -> \ (u1 :: u0 -> Bool) (u2 :: [u0]) -> let {(u9 :: u0 -> ([u0], [u0]) -> ([u0], [u0])) = \ (u3 :: u0) (u4 :: ([u0], [u0])) -> case u4 of { _ALG_ _TUP_2 (u5 :: [u0]) (u6 :: [u0]) -> case _APP_ u1 [ u3 ] of { _ALG_ True -> let {(u7 :: [u0]) = _!_ (:) [u0] [u3, u5]} in _!_ _TUP_2 [[u0], [u0]] [u7, u6]; False -> let {(u8 :: [u0]) = _!_ (:) [u0] [u3, u6]} in _!_ _TUP_2 [[u0], [u0]] [u5, u8]; _NO_DEFLT_ }; _NO_DEFLT_ }} in let {(ua :: [u0]) = _!_ _NIL_ [u0] []} in let {(ub :: ([u0], [u0])) = _!_ _TUP_2 [[u0], [u0]] [ua, ua]} in _APP_ _TYAPP_ _TYAPP_ foldr { u0 } { ([u0], [u0]) } [ u9, ub, u2 ] _N_ #-}
product :: Num a => [a] -> a
- {-# GHC_PRAGMA _A_ 1 _U_ 22 _N_ _N_ _F_ _ALWAYS_ _/\_ u0 -> \ (u1 :: {{Num u0}}) -> let {(uc :: u0 -> u0 -> u0) = case u1 of { _ALG_ _TUP_10 (u2 :: {{Eq u0}}) (u3 :: {{Text u0}}) (u4 :: u0 -> u0 -> u0) (u5 :: u0 -> u0 -> u0) (u6 :: u0 -> u0 -> u0) (u7 :: u0 -> u0) (u8 :: u0 -> u0) (u9 :: u0 -> u0) (ua :: Integer -> u0) (ub :: Int -> u0) -> u6; _NO_DEFLT_ }} in let {(uo :: u0) = let {(ud :: Int) = _!_ I# [] [1#]} in case u1 of { _ALG_ _TUP_10 (ue :: {{Eq u0}}) (uf :: {{Text u0}}) (ug :: u0 -> u0 -> u0) (uh :: u0 -> u0 -> u0) (ui :: u0 -> u0 -> u0) (uj :: u0 -> u0) (uk :: u0 -> u0) (ul :: u0 -> u0) (um :: Integer -> u0) (un :: Int -> u0) -> _APP_ un [ ud ]; _NO_DEFLT_ }} in \ (up :: [u0]) -> _APP_ _TYAPP_ _TYAPP_ foldl { u0 } { u0 } [ uc, uo, up ] _SPECIALISE_ [ Double ] 1 { _A_ 1 _U_ 1 _N_ _S_ "S" _F_ _ALWAYS_ \ (u0 :: [Double]) -> let {(u1 :: Double) = _!_ D# [] [1.0000000000000000##]} in _APP_ _TYAPP_ _TYAPP_ foldl { Double } { Double } [ _CONSTM_ Num (*) (Double), u1, u0 ] _N_ }, [ Int ] 1 { _A_ 1 _U_ 1 _N_ _S_ "S" _F_ _ALWAYS_ \ (u0 :: [Int]) -> let {(u1 :: Int) = _!_ I# [] [1#]} in _APP_ _TYAPP_ _TYAPP_ foldl { Int } { Int } [ _CONSTM_ Num (*) (Int), u1, u0 ] _N_ }, [ Integer ] 1 { _A_ 1 _U_ 1 _N_ _S_ "S" _F_ _ALWAYS_ \ (u0 :: [Integer]) -> let {(u1 :: Integer) = _#_ int2Integer# [] [1#]} in _APP_ _TYAPP_ _TYAPP_ foldl { Integer } { Integer } [ _CONSTM_ Num (*) (Integer), u1, u0 ] _N_ } #-}
+ {-# GHC_PRAGMA _A_ 1 _U_ 22 _N_ _N_ _F_ _ALWAYS_ _/\_ u0 -> \ (u1 :: {{Num u0}}) -> let {(uc :: u0 -> u0 -> u0) = case u1 of { _ALG_ _TUP_10 (u2 :: {{Eq u0}}) (u3 :: {{Text u0}}) (u4 :: u0 -> u0 -> u0) (u5 :: u0 -> u0 -> u0) (u6 :: u0 -> u0 -> u0) (u7 :: u0 -> u0) (u8 :: u0 -> u0) (u9 :: u0 -> u0) (ua :: Integer -> u0) (ub :: Int -> u0) -> u6; _NO_DEFLT_ }} in let {(uo :: u0) = let {(ud :: Int) = _!_ I# [] [1#]} in case u1 of { _ALG_ _TUP_10 (ue :: {{Eq u0}}) (uf :: {{Text u0}}) (ug :: u0 -> u0 -> u0) (uh :: u0 -> u0 -> u0) (ui :: u0 -> u0 -> u0) (uj :: u0 -> u0) (uk :: u0 -> u0) (ul :: u0 -> u0) (um :: Integer -> u0) (un :: Int -> u0) -> _APP_ un [ ud ]; _NO_DEFLT_ }} in \ (up :: [u0]) -> _APP_ _TYAPP_ _TYAPP_ foldl { u0 } { u0 } [ uc, uo, up ] _SPECIALISE_ [ Double ] 1 { _A_ 1 _U_ 1 _N_ _S_ "S" _F_ _ALWAYS_ \ (u0 :: [Double]) -> let {(u1 :: Double) = _!_ D# [] [1.0000000000000000##]} in _APP_ _TYAPP_ _TYAPP_ foldl { Double } { Double } [ _CONSTM_ Num (*) (Double), u1, u0 ] _N_ }, [ Int ] 1 { _A_ 1 _U_ 1 _N_ _S_ "S" _F_ _ALWAYS_ \ (u0 :: [Int]) -> let {(u1 :: Int) = _!_ I# [] [1#]} in _APP_ _TYAPP_ _TYAPP_ foldl { Int } { Int } [ _CONSTM_ Num (*) (Int), u1, u0 ] _N_ }, [ Integer ] 1 { _A_ 1 _U_ 1 _N_ _S_ "S" _F_ _ALWAYS_ \ (u0 :: [Integer]) -> let {(u1 :: Integer) = _#_ int2Integer# [] [1#]} in _APP_ _TYAPP_ _TYAPP_ foldl { Integer } { Integer } [ _CONSTM_ Num (*) (Integer), u1, u0 ] _N_ }, [ (Complex Double) ] 1 { _A_ 1 _U_ 1 _N_ _S_ "S" _F_ _ALWAYS_ let {(u6 :: Complex Double -> Complex Double -> Complex Double) = \ (u0 :: Complex Double) (u1 :: Complex Double) -> case u0 of { _ALG_ (:+) (u2 :: Double) (u3 :: Double) -> case u1 of { _ALG_ (:+) (u4 :: Double) (u5 :: Double) -> _APP_ _WRKR_ _CONSTM_ Num (*) (Complex Double) [ u2, u3, u4, u5 ]; _NO_DEFLT_ }; _NO_DEFLT_ }} in let {(u8 :: Complex Double) = let {(u7 :: Int) = _!_ I# [] [1#]} in _APP_ _CONSTM_ Num fromInt (Complex Double) [ u7 ]} in \ (u9 :: [Complex Double]) -> _APP_ _TYAPP_ _TYAPP_ foldl { (Complex Double) } { (Complex Double) } [ u6, u8, u9 ] _N_ } #-}
products :: Num a => [a] -> [a]
- {-# GHC_PRAGMA _A_ 1 _U_ 21 _N_ _N_ _N_ _N_ #-}
+ {-# GHC_PRAGMA _A_ 1 _U_ 21 _N_ _N_ _N_ _SPECIALISE_ [ Double ] 1 { _A_ 1 _U_ 1 _N_ _N_ _N_ _N_ }, [ Int ] 1 { _A_ 1 _U_ 1 _N_ _N_ _N_ _N_ }, [ Integer ] 1 { _A_ 1 _U_ 1 _N_ _N_ _F_ _IF_ARGS_ 0 1 X 4 \ (u0 :: [Integer]) -> _APP_ _TYAPP_ _TYAPP_ _ORIG_ PreludeList scanl { Integer } { Integer } [ _CONSTM_ Num (*) (Integer), _SPEC_ _ORIG_ PreludeCore __i1 [ (Integer) ], u0 ] _N_ }, [ (Complex Double) ] 1 { _A_ 1 _U_ 1 _N_ _N_ _N_ _N_ } #-}
repeat :: a -> [a]
{-# GHC_PRAGMA _A_ 1 _U_ 2 _N_ _N_ _F_ _ALWAYS_ _/\_ u0 -> \ (u1 :: u0) -> let {(u6 :: _forall_ a$z1 =>(u0 -> a$z1 -> a$z1) -> a$z1 -> a$z1) = _/\_ u2 -> \ (u3 :: u0 -> u2 -> u2) (u4 :: u2) -> _LETREC_ {(u5 :: u2) = _APP_ u3 [ u1, u5 ]} in u5} in _APP_ _TYAPP_ _build { u0 } [ u6 ] _N_ #-}
reverse :: [a] -> [a]
sum :: Num a => [a] -> a
{-# GHC_PRAGMA _A_ 1 _U_ 22 _N_ _N_ _F_ _ALWAYS_ _/\_ u0 -> \ (u1 :: {{Num u0}}) -> let {(uc :: u0 -> u0 -> u0) = case u1 of { _ALG_ _TUP_10 (u2 :: {{Eq u0}}) (u3 :: {{Text u0}}) (u4 :: u0 -> u0 -> u0) (u5 :: u0 -> u0 -> u0) (u6 :: u0 -> u0 -> u0) (u7 :: u0 -> u0) (u8 :: u0 -> u0) (u9 :: u0 -> u0) (ua :: Integer -> u0) (ub :: Int -> u0) -> u4; _NO_DEFLT_ }} in let {(uo :: u0) = let {(ud :: Int) = _!_ I# [] [0#]} in case u1 of { _ALG_ _TUP_10 (ue :: {{Eq u0}}) (uf :: {{Text u0}}) (ug :: u0 -> u0 -> u0) (uh :: u0 -> u0 -> u0) (ui :: u0 -> u0 -> u0) (uj :: u0 -> u0) (uk :: u0 -> u0) (ul :: u0 -> u0) (um :: Integer -> u0) (un :: Int -> u0) -> _APP_ un [ ud ]; _NO_DEFLT_ }} in \ (up :: [u0]) -> _APP_ _TYAPP_ _TYAPP_ foldl { u0 } { u0 } [ uc, uo, up ] _SPECIALISE_ [ Double ] 1 { _A_ 1 _U_ 1 _N_ _S_ "S" _F_ _ALWAYS_ \ (u0 :: [Double]) -> let {(u1 :: Double) = _!_ D# [] [0.0000000000000000##]} in _APP_ _TYAPP_ _TYAPP_ foldl { Double } { Double } [ _CONSTM_ Num (+) (Double), u1, u0 ] _N_ }, [ Int ] 1 { _A_ 1 _U_ 1 _N_ _S_ "S" _F_ _ALWAYS_ \ (u0 :: [Int]) -> let {(u1 :: Int) = _!_ I# [] [0#]} in _APP_ _TYAPP_ _TYAPP_ foldl { Int } { Int } [ _CONSTM_ Num (+) (Int), u1, u0 ] _N_ }, [ Integer ] 1 { _A_ 1 _U_ 1 _N_ _S_ "S" _F_ _ALWAYS_ \ (u0 :: [Integer]) -> let {(u1 :: Integer) = _#_ int2Integer# [] [0#]} in _APP_ _TYAPP_ _TYAPP_ foldl { Integer } { Integer } [ _CONSTM_ Num (+) (Integer), u1, u0 ] _N_ }, [ (Complex Double) ] 1 { _A_ 1 _U_ 1 _N_ _S_ "S" _F_ _ALWAYS_ let {(u6 :: Complex Double -> Complex Double -> Complex Double) = \ (u0 :: Complex Double) (u1 :: Complex Double) -> case u0 of { _ALG_ (:+) (u2 :: Double) (u3 :: Double) -> case u1 of { _ALG_ (:+) (u4 :: Double) (u5 :: Double) -> _APP_ _WRKR_ _CONSTM_ Num (+) (Complex Double) [ u2, u3, u4, u5 ]; _NO_DEFLT_ }; _NO_DEFLT_ }} in let {(u8 :: Complex Double) = let {(u7 :: Int) = _!_ I# [] [0#]} in _APP_ _CONSTM_ Num fromInt (Complex Double) [ u7 ]} in \ (u9 :: [Complex Double]) -> _APP_ _TYAPP_ _TYAPP_ foldl { (Complex Double) } { (Complex Double) } [ u6, u8, u9 ] _N_ } #-}
sums :: Num a => [a] -> [a]
- {-# GHC_PRAGMA _A_ 1 _U_ 21 _N_ _N_ _N_ _N_ #-}
+ {-# GHC_PRAGMA _A_ 1 _U_ 21 _N_ _N_ _N_ _SPECIALISE_ [ Double ] 1 { _A_ 1 _U_ 1 _N_ _N_ _N_ _N_ }, [ Int ] 1 { _A_ 1 _U_ 1 _N_ _N_ _N_ _N_ }, [ Integer ] 1 { _A_ 1 _U_ 1 _N_ _N_ _F_ _IF_ARGS_ 0 1 X 4 \ (u0 :: [Integer]) -> _APP_ _TYAPP_ _TYAPP_ _ORIG_ PreludeList scanl { Integer } { Integer } [ _CONSTM_ Num (+) (Integer), _SPEC_ _ORIG_ PreludeCore __i0 [ (Integer) ], u0 ] _N_ }, [ (Complex Double) ] 1 { _A_ 1 _U_ 1 _N_ _N_ _N_ _N_ } #-}
tail :: [a] -> [a]
{-# GHC_PRAGMA _A_ 1 _U_ 1 _N_ _S_ "S" _F_ _IF_ARGS_ 1 1 C 5 _/\_ u0 -> \ (u1 :: [u0]) -> case u1 of { _ALG_ (:) (u2 :: u0) (u3 :: [u0]) -> u3; _NIL_ -> _APP_ _TYAPP_ error { [u0] } [ _NOREP_S_ "tail{PreludeList}: tail []\n" ]; _NO_DEFLT_ } _N_ #-}
take :: Integral a => a -> [b] -> [b]
- {-# GHC_PRAGMA _A_ 3 _U_ 121 _N_ _S_ "U(AAAAAAAAAAAS)LL" {_A_ 3 _U_ 121 _N_ _N_ _N_ _N_} _F_ _IF_ARGS_ 2 3 CXX 7 _/\_ u0 u1 -> \ (u2 :: {{Integral u0}}) (u3 :: u0) (u4 :: [u1]) -> let {(uh :: Int) = case u2 of { _ALG_ _TUP_12 (u5 :: {{Real u0}}) (u6 :: {{Ix u0}}) (u7 :: u0 -> u0 -> u0) (u8 :: u0 -> u0 -> u0) (u9 :: u0 -> u0 -> u0) (ua :: u0 -> u0 -> u0) (ub :: u0 -> u0 -> (u0, u0)) (uc :: u0 -> u0 -> (u0, u0)) (ud :: u0 -> Bool) (ue :: u0 -> Bool) (uf :: u0 -> Integer) (ug :: u0 -> Int) -> _APP_ ug [ u3 ]; _NO_DEFLT_ }} in _APP_ _TYAPP_ _SPEC_ _ORIG_ PreludeList take [ (Int), _N_ ] { u1 } [ uh, u4 ] _SPECIALISE_ [ Int, _N_ ] 1 { _A_ 2 _U_ 11 _N_ _S_ "U(P)L" {_A_ 2 _U_ 21 _N_ _N_ _N_ _N_} _N_ _N_ }, [ Integer, _N_ ] 1 { _A_ 2 _U_ 11 _N_ _S_ "U(PPP)L" {_A_ 4 _U_ 2221 _N_ _N_ _F_ _IF_ARGS_ 1 4 XXXX 4 _/\_ u0 -> \ (u1 :: Int#) (u2 :: Int#) (u3 :: ByteArray#) (u4 :: [u0]) -> case _#_ integer2Int# [] [u1, u2, u3] of { _PRIM_ (u5 :: Int#) -> _APP_ _TYAPP_ _WRKR_ _SPEC_ _ORIG_ PreludeList take [ (Int), _N_ ] { u0 } [ u5, u4 ] } _N_} _F_ _ALWAYS_ _/\_ u0 -> \ (u1 :: Integer) (u2 :: [u0]) -> case u1 of { _ALG_ J# (u3 :: Int#) (u4 :: Int#) (u5 :: ByteArray#) -> case _#_ integer2Int# [] [u3, u4, u5] of { _PRIM_ (u6 :: Int#) -> _APP_ _TYAPP_ _WRKR_ _SPEC_ _ORIG_ PreludeList take [ (Int), _N_ ] { u0 } [ u6, u2 ] }; _NO_DEFLT_ } _N_ } #-}
+ {-# GHC_PRAGMA _A_ 1 _U_ 122 _N_ _S_ "U(LU(U(ASSAAAAA)AAA)AAAALAAAAL)" {_A_ 5 _U_ 2121222 _N_ _N_ _N_ _N_} _N_ _SPECIALISE_ [ Int, _N_ ] 1 { _A_ 2 _U_ 11 _N_ _S_ "U(P)L" {_A_ 2 _U_ 21 _N_ _N_ _N_ _N_} _N_ _N_ }, [ Integer, _N_ ] 1 { _A_ 1 _U_ 12 _N_ _S_ "U(PPP)" {_A_ 3 _U_ 2222 _N_ _N_ _N_ _N_} _N_ _N_ } #-}
takeWhile :: (a -> Bool) -> [a] -> [a]
{-# GHC_PRAGMA _A_ 2 _U_ 21 _N_ _S_ "LS" _F_ _ALWAYS_ _/\_ u0 -> \ (u1 :: u0 -> Bool) (u2 :: [u0]) -> let {(u9 :: _forall_ a$z1 =>(u0 -> a$z1 -> a$z1) -> a$z1 -> a$z1) = _/\_ u3 -> \ (u4 :: u0 -> u3 -> u3) (u5 :: u3) -> let {(u8 :: u0 -> u3 -> u3) = \ (u6 :: u0) (u7 :: u3) -> case _APP_ u1 [ u6 ] of { _ALG_ True -> _APP_ u4 [ u6, u7 ]; False -> u5; _NO_DEFLT_ }} in _APP_ _TYAPP_ _TYAPP_ foldr { u0 } { u3 } [ u8, u5, u2 ]} in _APP_ _TYAPP_ _build { u0 } [ u9 ] _N_ #-}
transpose :: [[a]] -> [[a]]
lex :: [Char] -> [([Char], [Char])]
{-# GHC_PRAGMA _A_ 1 _U_ 2 _N_ _S_ "S" _N_ _N_ #-}
read :: Text a => [Char] -> a
- {-# GHC_PRAGMA _A_ 1 _U_ 12 _N_ _S_ "U(SAAA)" {_A_ 1 _U_ 12 _N_ _N_ _N_ _N_} _N_ _SPECIALISE_ [ Double ] 1 { _A_ 1 _U_ 2 _N_ _N_ _N_ _N_ }, [ Float ] 1 { _A_ 1 _U_ 2 _N_ _N_ _N_ _N_ }, [ Int ] 1 { _A_ 1 _U_ 2 _N_ _N_ _N_ _N_ }, [ Integer ] 1 { _A_ 1 _U_ 2 _N_ _N_ _N_ _N_ } #-}
+ {-# GHC_PRAGMA _A_ 1 _U_ 12 _N_ _S_ "U(SAAA)" {_A_ 1 _U_ 12 _N_ _N_ _N_ _N_} _N_ _SPECIALISE_ [ Bool ] 1 { _A_ 1 _U_ 2 _N_ _N_ _N_ _N_ }, [ Char ] 1 { _A_ 1 _U_ 2 _N_ _N_ _N_ _N_ }, [ Double ] 1 { _A_ 1 _U_ 2 _N_ _N_ _N_ _N_ }, [ Int ] 1 { _A_ 1 _U_ 2 _N_ _N_ _N_ _N_ }, [ Integer ] 1 { _A_ 1 _U_ 2 _N_ _N_ _N_ _N_ }, [ [Bool] ] 1 { _A_ 1 _U_ 2 _N_ _N_ _N_ _N_ }, [ [Char] ] 1 { _A_ 1 _U_ 2 _N_ _N_ _N_ _N_ }, [ [Double] ] 1 { _A_ 1 _U_ 2 _N_ _N_ _N_ _N_ }, [ [Float] ] 1 { _A_ 1 _U_ 2 _N_ _N_ _N_ _N_ }, [ [Int] ] 1 { _A_ 1 _U_ 2 _N_ _N_ _N_ _N_ }, [ [Integer] ] 1 { _A_ 1 _U_ 2 _N_ _N_ _N_ _N_ }, [ [[Char]] ] 1 { _A_ 1 _U_ 2 _N_ _N_ _N_ _N_ }, [ [[Int]] ] 1 { _A_ 1 _U_ 2 _N_ _N_ _N_ _N_ }, [ [Complex Double] ] 1 { _A_ 1 _U_ 2 _N_ _N_ _N_ _N_ }, [ (Ratio Integer) ] 1 { _A_ 1 _U_ 2 _N_ _N_ _N_ _N_ }, [ (Array Int Double) ] 1 { _A_ 1 _U_ 2 _N_ _N_ _N_ _N_ }, [ (Array (Int, Int) Double) ] 1 { _A_ 1 _U_ 2 _N_ _N_ _N_ _N_ }, [ _PackedString ] 1 { _A_ 1 _U_ 2 _N_ _S_ _!_ _N_ _N_ }, [ (Complex Double) ] 1 { _A_ 1 _U_ 2 _N_ _N_ _N_ _N_ }, [ () ] 1 { _A_ 1 _U_ 2 _N_ _N_ _N_ _N_ }, [ (Int, Int) ] 1 { _A_ 1 _U_ 2 _N_ _N_ _N_ _N_ }, [ (Integer, Integer) ] 1 { _A_ 1 _U_ 2 _N_ _N_ _N_ _N_ }, [ (Int, Int, Int) ] 1 { _A_ 1 _U_ 2 _N_ _N_ _N_ _N_ } #-}
readDec :: Integral a => [Char] -> [(a, [Char])]
- {-# GHC_PRAGMA _A_ 1 _U_ 22 _N_ _N_ _N_ _SPECIALISE_ [ Int ] 1 { _A_ 1 _U_ 2 _N_ _N_ _N_ _N_ }, [ Integer ] 1 { _A_ 1 _U_ 2 _N_ _S_ "S" _N_ _N_ } #-}
+ {-# GHC_PRAGMA _A_ 1 _U_ 22 _N_ _N_ _N_ _SPECIALISE_ [ Int ] 1 { _A_ 1 _U_ 2 _N_ _N_ _N_ _N_ }, [ Integer ] 1 { _A_ 1 _U_ 2 _N_ _N_ _N_ _N_ } #-}
readFloat :: RealFloat a => [Char] -> [(a, [Char])]
- {-# GHC_PRAGMA _A_ 2 _U_ 12 _N_ _S_ "LS" _N_ _SPECIALISE_ [ Double ] 1 { _A_ 1 _U_ 2 _N_ _S_ "S" _N_ _N_ }, [ Float ] 1 { _A_ 1 _U_ 2 _N_ _S_ "S" _N_ _N_ } #-}
+ {-# GHC_PRAGMA _A_ 2 _U_ 12 _N_ _S_ "LS" _N_ _SPECIALISE_ [ Double ] 1 { _A_ 1 _U_ 2 _N_ _S_ "S" _N_ _N_ } #-}
readLitChar :: [Char] -> [(Char, [Char])]
{-# GHC_PRAGMA _A_ 0 _U_ 1 _N_ _N_ _N_ _N_ #-}
readParen :: Bool -> ([Char] -> [(a, [Char])]) -> [Char] -> [(a, [Char])]
readSigned :: Real a => ([Char] -> [(a, [Char])]) -> [Char] -> [(a, [Char])]
{-# GHC_PRAGMA _A_ 2 _U_ 122 _N_ _N_ _N_ _SPECIALISE_ [ Double ] 1 { _A_ 1 _U_ 22 _N_ _N_ _N_ _N_ }, [ Int ] 1 { _A_ 1 _U_ 22 _N_ _N_ _N_ _N_ }, [ Integer ] 1 { _A_ 1 _U_ 22 _N_ _N_ _N_ _N_ } #-}
reads :: Text a => [Char] -> [(a, [Char])]
- {-# GHC_PRAGMA _A_ 1 _U_ 12 _N_ _S_ "U(SAAA)" {_A_ 1 _U_ 12 _N_ _N_ _N_ _N_} _N_ _SPECIALISE_ [ Double ] 1 { _A_ 1 _U_ 2 _N_ _N_ _N_ _N_ }, [ Float ] 1 { _A_ 1 _U_ 2 _N_ _N_ _N_ _N_ }, [ Int ] 1 { _A_ 1 _U_ 2 _N_ _N_ _N_ _N_ }, [ Integer ] 1 { _A_ 1 _U_ 2 _N_ _N_ _N_ _N_ } #-}
+ {-# GHC_PRAGMA _A_ 1 _U_ 12 _N_ _S_ "U(SAAA)" {_A_ 1 _U_ 12 _N_ _N_ _N_ _N_} _N_ _SPECIALISE_ [ Bool ] 1 { _A_ 1 _U_ 2 _N_ _N_ _N_ _N_ }, [ Char ] 1 { _A_ 0 _U_ 2 _N_ _N_ _N_ _N_ }, [ Double ] 1 { _A_ 1 _U_ 2 _N_ _N_ _N_ _N_ }, [ Int ] 1 { _A_ 1 _U_ 2 _N_ _N_ _N_ _N_ }, [ Integer ] 1 { _A_ 1 _U_ 2 _N_ _N_ _N_ _N_ }, [ [Bool] ] 1 { _A_ 0 _U_ 2 _N_ _N_ _F_ _IF_ARGS_ 0 0 X 1 _CONSTM_ Text readList (Bool) _N_ }, [ [Char] ] 1 { _A_ 0 _U_ 2 _N_ _N_ _F_ _IF_ARGS_ 0 0 X 1 _CONSTM_ Text readList (Char) _N_ }, [ [Double] ] 1 { _A_ 0 _U_ 2 _N_ _N_ _F_ _IF_ARGS_ 0 0 X 1 _CONSTM_ Text readList (Double) _N_ }, [ [Float] ] 1 { _A_ 0 _U_ 2 _N_ _N_ _N_ _N_ }, [ [Int] ] 1 { _A_ 0 _U_ 2 _N_ _N_ _F_ _IF_ARGS_ 0 0 X 1 _CONSTM_ Text readList (Int) _N_ }, [ [Integer] ] 1 { _A_ 0 _U_ 2 _N_ _N_ _F_ _IF_ARGS_ 0 0 X 1 _CONSTM_ Text readList (Integer) _N_ }, [ [[Char]] ] 1 { _A_ 0 _U_ 2 _N_ _N_ _F_ _IF_ARGS_ 0 0 X 1 _CONSTM_ Text readList ([Char]) _N_ }, [ [[Int]] ] 1 { _A_ 0 _U_ 2 _N_ _N_ _F_ _IF_ARGS_ 0 0 X 1 _CONSTM_ Text readList ([Int]) _N_ }, [ [Complex Double] ] 1 { _A_ 0 _U_ 2 _N_ _N_ _F_ _IF_ARGS_ 0 0 X 1 _CONSTM_ Text readList (Complex Double) _N_ }, [ (Ratio Integer) ] 1 { _A_ 0 _U_ 2 _N_ _N_ _N_ _N_ }, [ (Array Int Double) ] 1 { _A_ 0 _U_ 2 _N_ _N_ _N_ _N_ }, [ (Array (Int, Int) Double) ] 1 { _A_ 0 _U_ 2 _N_ _N_ _N_ _N_ }, [ _PackedString ] 1 { _A_ 1 _U_ 2 _N_ _S_ _!_ _N_ _N_ }, [ (Complex Double) ] 1 { _A_ 0 _U_ 2 _N_ _N_ _N_ _N_ }, [ () ] 1 { _A_ 0 _U_ 2 _N_ _N_ _N_ _N_ }, [ (Int, Int) ] 1 { _A_ 0 _U_ 2 _N_ _N_ _N_ _N_ }, [ (Integer, Integer) ] 1 { _A_ 0 _U_ 2 _N_ _N_ _N_ _N_ }, [ (Int, Int, Int) ] 1 { _A_ 0 _U_ 2 _N_ _N_ _N_ _N_ } #-}
show :: Text a => a -> [Char]
- {-# GHC_PRAGMA _A_ 1 _U_ 12 _N_ _S_ "U(ASAA)" {_A_ 1 _U_ 12 _N_ _N_ _N_ _N_} _N_ _SPECIALISE_ [ Char ] 1 { _A_ 1 _U_ 1 _N_ _S_ "U(P)" {_A_ 1 _U_ 2 _N_ _N_ _N_ _N_} _N_ _N_ }, [ Double ] 1 { _A_ 1 _U_ 1 _N_ _S_ "U(P)" {_A_ 1 _U_ 2 _N_ _N_ _N_ _N_} _N_ _N_ }, [ Float ] 1 { _A_ 1 _U_ 2 _N_ _N_ _N_ _N_ }, [ Int ] 1 { _A_ 1 _U_ 1 _N_ _S_ "U(P)" {_A_ 1 _U_ 2 _N_ _N_ _N_ _N_} _N_ _N_ }, [ Integer ] 1 { _A_ 1 _U_ 1 _N_ _S_ "U(PPP)" {_A_ 3 _U_ 222 _N_ _N_ _N_ _N_} _N_ _N_ }, [ [Char] ] 1 { _A_ 1 _U_ 2 _N_ _N_ _N_ _N_ }, [ _PackedString ] 1 { _A_ 1 _U_ 1 _N_ _N_ _N_ _N_ }, [ (Int, Int) ] 1 { _A_ 1 _U_ 1 _N_ _S_ "U(LL)" {_A_ 2 _U_ 22 _N_ _N_ _N_ _N_} _N_ _N_ }, [ (Integer, Integer) ] 1 { _A_ 1 _U_ 1 _N_ _S_ "U(LL)" {_A_ 2 _U_ 22 _N_ _N_ _N_ _N_} _N_ _N_ } #-}
+ {-# GHC_PRAGMA _A_ 1 _U_ 12 _N_ _S_ "U(ASAA)" {_A_ 1 _U_ 12 _N_ _N_ _N_ _N_} _N_ _SPECIALISE_ [ Bool ] 1 { _A_ 1 _U_ 2 _N_ _S_ "E" _N_ _N_ }, [ Char ] 1 { _A_ 1 _U_ 1 _N_ _S_ "U(P)" {_A_ 1 _U_ 2 _N_ _N_ _N_ _N_} _N_ _N_ }, [ Double ] 1 { _A_ 1 _U_ 1 _N_ _S_ "U(P)" {_A_ 1 _U_ 2 _N_ _N_ _N_ _N_} _N_ _N_ }, [ Int ] 1 { _A_ 1 _U_ 1 _N_ _S_ "U(P)" {_A_ 1 _U_ 2 _N_ _N_ _N_ _N_} _N_ _N_ }, [ Integer ] 1 { _A_ 1 _U_ 1 _N_ _S_ "U(PPP)" {_A_ 3 _U_ 222 _N_ _N_ _N_ _N_} _N_ _N_ }, [ [Bool] ] 1 { _A_ 1 _U_ 1 _N_ _S_ "S" _N_ _N_ }, [ [Char] ] 1 { _A_ 1 _U_ 2 _N_ _N_ _N_ _N_ }, [ [Double] ] 1 { _A_ 1 _U_ 2 _N_ _N_ _N_ _N_ }, [ [Int] ] 1 { _A_ 1 _U_ 2 _N_ _N_ _N_ _N_ }, [ [Integer] ] 1 { _A_ 1 _U_ 2 _N_ _N_ _N_ _N_ }, [ [[Char]] ] 1 { _A_ 1 _U_ 1 _N_ _S_ "S" _N_ _N_ }, [ [[Int]] ] 1 { _A_ 1 _U_ 1 _N_ _S_ "S" _N_ _N_ }, [ [Complex Double] ] 1 { _A_ 1 _U_ 2 _N_ _N_ _N_ _N_ }, [ (Ratio Integer) ] 1 { _A_ 1 _U_ 1 _N_ _S_ "U(LL)" {_A_ 2 _U_ 22 _N_ _N_ _N_ _N_} _N_ _N_ }, [ (Array Int Double) ] 1 { _A_ 1 _U_ 2 _N_ _N_ _N_ _N_ }, [ (Array (Int, Int) Double) ] 1 { _A_ 1 _U_ 2 _N_ _N_ _N_ _N_ }, [ _PackedString ] 1 { _A_ 1 _U_ 1 _N_ _N_ _N_ _N_ }, [ (Complex Double) ] 1 { _A_ 1 _U_ 1 _N_ _S_ "U(LL)" {_A_ 2 _U_ 22 _N_ _N_ _N_ _N_} _N_ _N_ }, [ () ] 1 { _A_ 1 _U_ 1 _N_ _S_ "E" _N_ _N_ }, [ (Int, Int) ] 1 { _A_ 1 _U_ 1 _N_ _S_ "U(LL)" {_A_ 2 _U_ 22 _N_ _N_ _N_ _N_} _N_ _N_ }, [ (Integer, Integer) ] 1 { _A_ 1 _U_ 1 _N_ _S_ "U(LL)" {_A_ 2 _U_ 22 _N_ _N_ _N_ _N_} _N_ _N_ }, [ (Int, Int, Int) ] 1 { _A_ 1 _U_ 1 _N_ _S_ "U(LLL)" {_A_ 3 _U_ 222 _N_ _N_ _N_ _N_} _N_ _N_ } #-}
showChar :: Char -> [Char] -> [Char]
{-# GHC_PRAGMA _A_ 2 _U_ 22 _N_ _N_ _F_ _IF_ARGS_ 0 2 XX 3 \ (u0 :: Char) (u1 :: [Char]) -> _!_ (:) [Char] [u0, u1] _N_ #-}
showFloat :: RealFloat a => a -> [Char] -> [Char]
- {-# GHC_PRAGMA _A_ 1 _U_ 122 _N_ _S_ "U(U(LU(SLLL)LAAAA)LLLALAAAA)" {_A_ 5 _U_ 1122222 _N_ _N_ _N_ _N_} _N_ _SPECIALISE_ [ Double ] 1 { _A_ 1 _U_ 12 _N_ _S_ "U(P)" {_A_ 1 _U_ 22 _N_ _N_ _N_ _N_} _N_ _N_ }, [ Float ] 1 { _A_ 0 _U_ 22 _N_ _N_ _N_ _N_ } #-}
+ {-# GHC_PRAGMA _A_ 1 _U_ 122 _N_ _S_ "U(U(AU(SAAA)AAAAL)LLLALAAAA)" {_A_ 5 _U_ 1122222 _N_ _N_ _N_ _N_} _N_ _SPECIALISE_ [ Double ] 1 { _A_ 1 _U_ 12 _N_ _S_ "U(P)" {_A_ 1 _U_ 22 _N_ _N_ _N_ _N_} _N_ _N_ } #-}
showInt :: Integral a => a -> [Char] -> [Char]
{-# GHC_PRAGMA _A_ 1 _U_ 122 _N_ _S_ "U(U(U(U(SL)LLLLLLLLL)LL)LLLLLSLLLLL)" _N_ _SPECIALISE_ [ Int ] 1 { _A_ 2 _U_ 12 _N_ _S_ "U(P)L" {_A_ 2 _U_ 22 _N_ _N_ _N_ _N_} _N_ _N_ }, [ Integer ] 1 { _A_ 2 _U_ 12 _N_ _S_ "U(PPP)L" {_A_ 4 _U_ 2222 _N_ _N_ _N_ _N_} _N_ _N_ } #-}
showLitChar :: Char -> [Char] -> [Char]
showString :: [Char] -> [Char] -> [Char]
{-# GHC_PRAGMA _A_ 2 _U_ 12 _N_ _N_ _F_ _IF_ARGS_ 0 0 X 1 _TYAPP_ _ORIG_ PreludeList (++) { Char } _N_ #-}
shows :: Text a => a -> [Char] -> [Char]
- {-# GHC_PRAGMA _A_ 1 _U_ 122 _N_ _S_ "U(ASAA)" {_A_ 1 _U_ 122 _N_ _N_ _N_ _N_} _N_ _SPECIALISE_ [ Char ] 1 { _A_ 2 _U_ 12 _N_ _S_ "U(P)L" {_A_ 2 _U_ 22 _N_ _N_ _N_ _N_} _N_ _N_ }, [ Double ] 1 { _A_ 1 _U_ 12 _N_ _S_ "U(P)" {_A_ 1 _U_ 22 _N_ _N_ _N_ _N_} _N_ _N_ }, [ Float ] 1 { _A_ 0 _U_ 22 _N_ _N_ _N_ _N_ }, [ Int ] 1 { _A_ 2 _U_ 12 _N_ _S_ "U(P)L" {_A_ 2 _U_ 22 _N_ _N_ _N_ _N_} _N_ _N_ }, [ Integer ] 1 { _A_ 2 _U_ 12 _N_ _S_ "U(PPP)L" {_A_ 4 _U_ 2222 _N_ _N_ _N_ _N_} _N_ _N_ }, [ [Char] ] 1 { _A_ 1 _U_ 22 _N_ _N_ _F_ _IF_ARGS_ 0 0 X 1 _CONSTM_ Text showList (Char) _N_ }, [ _PackedString ] 1 { _A_ 2 _U_ 12 _N_ _N_ _N_ _N_ }, [ (Int, Int) ] 1 { _A_ 2 _U_ 12 _N_ _S_ "U(LL)L" {_A_ 3 _U_ 222 _N_ _N_ _N_ _N_} _N_ _N_ }, [ (Integer, Integer) ] 1 { _A_ 2 _U_ 12 _N_ _S_ "U(LL)L" {_A_ 3 _U_ 222 _N_ _N_ _N_ _N_} _N_ _N_ } #-}
+ {-# GHC_PRAGMA _A_ 1 _U_ 122 _N_ _S_ "U(ASAA)" {_A_ 1 _U_ 122 _N_ _N_ _N_ _N_} _N_ _SPECIALISE_ [ Bool ] 1 { _A_ 2 _U_ 22 _N_ _N_ _N_ _N_ }, [ Char ] 1 { _A_ 2 _U_ 12 _N_ _S_ "U(P)L" {_A_ 2 _U_ 22 _N_ _N_ _N_ _N_} _N_ _N_ }, [ Double ] 1 { _A_ 1 _U_ 12 _N_ _S_ "U(P)" {_A_ 1 _U_ 22 _N_ _N_ _N_ _N_} _N_ _N_ }, [ Int ] 1 { _A_ 2 _U_ 12 _N_ _S_ "U(P)L" {_A_ 2 _U_ 22 _N_ _N_ _N_ _N_} _N_ _N_ }, [ Integer ] 1 { _A_ 2 _U_ 12 _N_ _S_ "U(PPP)L" {_A_ 4 _U_ 2222 _N_ _N_ _N_ _N_} _N_ _N_ }, [ [Bool] ] 1 { _A_ 1 _U_ 12 _N_ _S_ "S" _F_ _IF_ARGS_ 0 1 X 3 \ (u0 :: [Bool]) -> _APP_ _TYAPP_ _ORIG_ PreludeCore _showList { Bool } [ _WRKR_ _CONSTM_ Text showsPrec (Bool), u0 ] _N_ }, [ [Char] ] 1 { _A_ 1 _U_ 22 _N_ _N_ _F_ _IF_ARGS_ 0 0 X 1 _CONSTM_ Text showList (Char) _N_ }, [ [Double] ] 1 { _A_ 1 _U_ 22 _N_ _N_ _F_ _IF_ARGS_ 0 0 X 1 _CONSTM_ Text showList (Double) _N_ }, [ [Int] ] 1 { _A_ 1 _U_ 22 _N_ _N_ _F_ _IF_ARGS_ 0 0 X 1 _CONSTM_ Text showList (Int) _N_ }, [ [Integer] ] 1 { _A_ 1 _U_ 22 _N_ _N_ _F_ _IF_ARGS_ 0 0 X 1 _CONSTM_ Text showList (Integer) _N_ }, [ [[Char]] ] 1 { _A_ 1 _U_ 12 _N_ _S_ "S" _F_ _IF_ARGS_ 0 1 X 3 \ (u0 :: [[Char]]) -> _APP_ _TYAPP_ _ORIG_ PreludeCore _showList { [Char] } [ _CONSTM_ Text showList (Char), u0 ] _N_ }, [ [[Int]] ] 1 { _A_ 1 _U_ 12 _N_ _S_ "S" _F_ _IF_ARGS_ 0 1 X 3 \ (u0 :: [[Int]]) -> _APP_ _TYAPP_ _ORIG_ PreludeCore _showList { [Int] } [ _CONSTM_ Text showList (Int), u0 ] _N_ }, [ [Complex Double] ] 1 { _A_ 1 _U_ 22 _N_ _N_ _F_ _IF_ARGS_ 0 0 X 1 _CONSTM_ Text showList (Complex Double) _N_ }, [ (Ratio Integer) ] 1 { _A_ 1 _U_ 12 _N_ _S_ "U(LL)" {_A_ 2 _U_ 222 _N_ _N_ _N_ _N_} _N_ _N_ }, [ (Array Int Double) ] 1 { _A_ 1 _U_ 22 _N_ _N_ _N_ _N_ }, [ (Array (Int, Int) Double) ] 1 { _A_ 1 _U_ 22 _N_ _N_ _N_ _N_ }, [ _PackedString ] 1 { _A_ 2 _U_ 12 _N_ _N_ _N_ _N_ }, [ (Complex Double) ] 1 { _A_ 1 _U_ 12 _N_ _S_ "U(LL)" {_A_ 2 _U_ 222 _N_ _N_ _N_ _N_} _N_ _N_ }, [ () ] 1 { _A_ 2 _U_ 12 _N_ _S_ "EL" _F_ _IF_ARGS_ 0 2 CX 4 \ (u0 :: ()) (u1 :: [Char]) -> case u0 of { _ALG_ _TUP_0 -> _APP_ _TYAPP_ _ORIG_ PreludeList (++) { Char } [ _NOREP_S_ "()", u1 ]; _NO_DEFLT_ } _N_ }, [ (Int, Int) ] 1 { _A_ 2 _U_ 12 _N_ _S_ "U(LL)L" {_A_ 3 _U_ 222 _N_ _N_ _N_ _N_} _N_ _N_ }, [ (Integer, Integer) ] 1 { _A_ 2 _U_ 12 _N_ _S_ "U(LL)L" {_A_ 3 _U_ 222 _N_ _N_ _N_ _N_} _N_ _N_ }, [ (Int, Int, Int) ] 1 { _A_ 2 _U_ 12 _N_ _S_ "U(LLL)L" {_A_ 4 _U_ 2222 _N_ _N_ _N_ _N_} _N_ _N_ } #-}
appendFile :: [Char] -> [Char] -> _State _RealWorld -> (Either IOError13 (), _State _RealWorld)
{-# GHC_PRAGMA _A_ 3 _U_ 221 _N_ _S_ "LLU(P)" {_A_ 3 _U_ 222 _N_ _N_ _N_ _N_} _N_ _N_ #-}
hPutChar :: _MVar _Handle -> Char -> _State _RealWorld -> (Either IOError13 (), _State _RealWorld)
print :: Text a => a -> _State _RealWorld -> (Either IOError13 (), _State _RealWorld)
{-# GHC_PRAGMA _A_ 1 _U_ 121 _N_ _N_ _N_ _N_ #-}
putChar :: Char -> _State _RealWorld -> (Either IOError13 (), _State _RealWorld)
- {-# GHC_PRAGMA _A_ 2 _U_ 11 _N_ _N_ _F_ _IF_ARGS_ 0 0 X 2 _APP_ _ORIG_ PreludeWriteTextIO hPutChar [ _ORIG_ PreludeStdIO stdout13 ] _N_ #-}
+ {-# GHC_PRAGMA _A_ 2 _U_ 11 _N_ _N_ _F_ _IF_ARGS_ 0 2 XC 6 \ (u0 :: Char) (u1 :: _State _RealWorld) -> case _ORIG_ PreludeStdIO stdout13 of { _ALG_ _MVar (u2 :: SynchVar# _RealWorld _Handle) -> case u1 of { _ALG_ S# (u3 :: State# _RealWorld) -> _APP_ _WRKR_ _ORIG_ PreludeWriteTextIO hPutChar [ u2, u0, u3 ]; _NO_DEFLT_ }; _NO_DEFLT_ } _N_ #-}
putStr :: [Char] -> _State _RealWorld -> (Either IOError13 (), _State _RealWorld)
- {-# GHC_PRAGMA _A_ 2 _U_ 21 _N_ _N_ _F_ _IF_ARGS_ 0 0 X 2 _APP_ _ORIG_ PreludeWriteTextIO hPutStr [ _ORIG_ PreludeStdIO stdout13 ] _N_ #-}
+ {-# GHC_PRAGMA _A_ 2 _U_ 21 _N_ _N_ _F_ _IF_ARGS_ 0 2 XC 6 \ (u0 :: [Char]) (u1 :: _State _RealWorld) -> case _ORIG_ PreludeStdIO stdout13 of { _ALG_ _MVar (u2 :: SynchVar# _RealWorld _Handle) -> case u1 of { _ALG_ S# (u3 :: State# _RealWorld) -> _APP_ _WRKR_ _ORIG_ PreludeWriteTextIO hPutStr [ u2, u0, u3 ]; _NO_DEFLT_ }; _NO_DEFLT_ } _N_ #-}
putText :: Text a => a -> _State _RealWorld -> (Either IOError13 (), _State _RealWorld)
{-# GHC_PRAGMA _A_ 1 _U_ 121 _N_ _N_ _F_ _IF_ARGS_ 1 1 X 3 _/\_ u0 -> \ (u1 :: {{Text u0}}) -> _APP_ _TYAPP_ _ORIG_ PreludeWriteTextIO hPutText { u0 } [ u1, _ORIG_ PreludeStdIO stdout13 ] _N_ #-}
writeFile :: [Char] -> [Char] -> _State _RealWorld -> (Either IOError13 (), _State _RealWorld)
-{-# GHC_PRAGMA INTERFACE VERSION 5 #-}
+{-# GHC_PRAGMA INTERFACE VERSION 6 #-}
interface Prelude where
import PreludeArray((!), (//), Array, Assoc, _ByteArray, accum, accumArray, amap, array, assocs, bounds, elems, indices, ixmap, listArray)
import PreludeBuiltin(Bin, Char(..), Int(..), Integer(..), List(..), Tuple0, Tuple2, Tuple3, Tuple4, Tuple5, Tuple6, Tuple7, _Addr(..), _RealWorld(..), _State(..))
import PreludeComplex(Complex, cis, conjugate, imagPart, magnitude, mkPolar, phase, polar, realPart)
-import PreludeCore(Bool(..), Eq(..), Fractional(..), Integral(..), Ix(..), Num(..), Ord(..), Real(..), RealFloat(..), RealFrac(..), Text(..), _ceiling, _floor, _readList, _round, _showList, _showRational, _truncate)
+import PreludeCore(Bool(..), Eq(..), Fractional(..), Integral(..), Ix(..), Num(..), Ord(..), Real(..), RealFloat(..), RealFrac(..), Text(..), _readList, _showList, _showRational)
import PreludeIO(interact13) renaming (interact13 to interact)
import PreludeIOError(IOError13)
import PreludeList((!!), (++), (\\), all, and, any, break, concat, cycle, drop, dropWhile, elem, filter, foldl1, foldr1, genericLength, head, init, iterate, last, length, lines, map, maximum, minimum, notElem, nub, null, or, partition, product, products, repeat, reverse, scanl, scanl1, scanr, scanr1, span, splitAt, sum, sums, tail, take, takeWhile, transpose, unlines, unwords, unzip, unzip3, unzip4, unzip5, unzip6, unzip7, words, zip, zip3, zip4, zip5, zip6, zip7, zipWith, zipWith3, zipWith4, zipWith5, zipWith6, zipWith7)
(.) :: (a -> c) -> (b -> a) -> b -> c
{-# GHC_PRAGMA _A_ 3 _U_ 112 _N_ _S_ "SLL" _F_ _ALWAYS_ _/\_ u0 u1 u2 -> \ (u3 :: u0 -> u2) (u4 :: u1 -> u0) (u5 :: u1) -> let {(u6 :: u0) = _APP_ u4 [ u5 ]} in _APP_ u3 [ u6 ] _N_ #-}
(^) :: (Num b, Integral a) => b -> a -> b
- {-# GHC_PRAGMA _A_ 2 _U_ 2122 _N_ _S_ "LU(U(LU(U(U(SA)AALAAAA)AAAA)A)AAALAAAALAA)" {_A_ 5 _U_ 2212222 _N_ _N_ _N_ _N_} _N_ _SPECIALISE_ [ Int, Double ] 2 { _A_ 2 _U_ 21 _N_ _S_ "LU(P)" {_A_ 2 _U_ 22 _N_ _N_ _N_ _N_} _N_ _N_ }, [ Int, Int ] 2 { _A_ 2 _U_ 21 _N_ _S_ "LU(P)" {_A_ 2 _U_ 22 _N_ _N_ _N_ _N_} _N_ _N_ }, [ Int, Integer ] 2 { _A_ 2 _U_ 21 _N_ _S_ "LU(P)" {_A_ 2 _U_ 22 _N_ _N_ _N_ _N_} _N_ _N_ }, [ Int, (Ratio Integer) ] 2 { _A_ 2 _U_ 21 _N_ _S_ "LU(P)" {_A_ 2 _U_ 22 _N_ _N_ _N_ _N_} _N_ _N_ }, [ Int, (Complex Double) ] 2 { _A_ 2 _U_ 21 _N_ _S_ "LU(P)" {_A_ 2 _U_ 22 _N_ _N_ _N_ _N_} _N_ _N_ } #-}
+ {-# GHC_PRAGMA _A_ 2 _U_ 2122 _N_ _S_ "LU(U(LU(U(U(SL)LLLLLLL)LLLL)L)LLLLLLLLLLL)" _N_ _SPECIALISE_ [ Int, Double ] 2 { _A_ 2 _U_ 21 _N_ _S_ "LU(P)" {_A_ 2 _U_ 22 _N_ _N_ _N_ _N_} _N_ _N_ }, [ Int, Int ] 2 { _A_ 2 _U_ 21 _N_ _S_ "LU(P)" {_A_ 2 _U_ 22 _N_ _N_ _N_ _N_} _N_ _N_ }, [ Int, Integer ] 2 { _A_ 2 _U_ 21 _N_ _S_ "LU(P)" {_A_ 2 _U_ 22 _N_ _N_ _N_ _N_} _N_ _N_ }, [ Int, (Ratio Integer) ] 2 { _A_ 2 _U_ 21 _N_ _S_ "LU(P)" {_A_ 2 _U_ 22 _N_ _N_ _N_ _N_} _N_ _N_ }, [ Int, (Complex Double) ] 2 { _A_ 2 _U_ 21 _N_ _S_ "LU(P)" {_A_ 2 _U_ 22 _N_ _N_ _N_ _N_} _N_ _N_ }, [ Integer, Integer ] 2 { _A_ 2 _U_ 21 _N_ _S_ "LU(PPP)" {_A_ 4 _U_ 2222 _N_ _N_ _N_ _N_} _N_ _N_ } #-}
(^^) :: (Fractional b, Integral a) => b -> a -> b
- {-# GHC_PRAGMA _A_ 2 _U_ 2122 _N_ _S_ "LU(LU(U(AAASAAAA)AAA)AALAAAALAA)" {_A_ 5 _U_ 2212222 _N_ _N_ _N_ _N_} _N_ _SPECIALISE_ [ Int, Double ] 2 { _A_ 2 _U_ 21 _N_ _S_ "LU(P)" {_A_ 2 _U_ 22 _N_ _N_ _N_ _N_} _N_ _N_ }, [ Int, (Ratio Integer) ] 2 { _A_ 2 _U_ 21 _N_ _S_ "LU(P)" {_A_ 2 _U_ 22 _N_ _N_ _N_ _N_} _N_ _N_ } #-}
+ {-# GHC_PRAGMA _A_ 2 _U_ 2222 _N_ _S_ "LU(LU(U(LLLSLLLL)LLL)LLLLLLLLLL)" _N_ _SPECIALISE_ [ Int, Double ] 2 { _A_ 2 _U_ 21 _N_ _S_ "LU(P)" {_A_ 2 _U_ 22 _N_ _N_ _N_ _N_} _N_ _N_ }, [ Int, (Ratio Integer) ] 2 { _A_ 2 _U_ 21 _N_ _S_ "LU(P)" {_A_ 2 _U_ 22 _N_ _N_ _N_ _N_} _N_ _N_ }, [ Int, (Complex Double) ] 2 { _A_ 2 _U_ 21 _N_ _S_ "LU(P)" {_A_ 2 _U_ 22 _N_ _N_ _N_ _N_} _N_ _N_ } #-}
appendBin :: Bin -> Bin -> Bin
- {-# GHC_PRAGMA _A_ 2 _U_ 22 _N_ _S_ _!_ _F_ _IF_ARGS_ 0 2 XX 4 \ (u0 :: Bin) (u1 :: Bin) -> _APP_ _TYAPP_ error { (Bin -> Bin -> Bin) } [ _NOREP_S_ "appendBin{Prelude}\n", u0, u1 ] _N_ #-}
+ {-# GHC_PRAGMA _A_ 2 _U_ 22 _N_ _S_ _!_ _N_ _N_ #-}
asTypeOf :: a -> a -> a
{-# GHC_PRAGMA _A_ 2 _U_ 10 _N_ _N_ _F_ _IF_ARGS_ 1 0 X 1 _/\_ u0 -> _TYAPP_ _TYAPP_ _ORIG_ Prelude const { u0 } { u0 } _N_ #-}
atan2 :: RealFloat a => a -> a -> a
flip :: (b -> a -> c) -> a -> b -> c
{-# GHC_PRAGMA _A_ 3 _U_ 122 _N_ _S_ "SLL" _F_ _IF_ARGS_ 3 3 XXX 3 _/\_ u0 u1 u2 -> \ (u3 :: u1 -> u0 -> u2) (u4 :: u0) (u5 :: u1) -> _APP_ u3 [ u5, u4 ] _N_ #-}
fromIntegral :: (Integral a, Num b) => a -> b
- {-# GHC_PRAGMA _A_ 3 _U_ 112 _N_ _S_ "LU(AAAAAAAASA)L" {_A_ 3 _U_ 112 _N_ _N_ _F_ _IF_ARGS_ 2 3 CXX 6 _/\_ u0 u1 -> \ (u2 :: {{Integral u0}}) (u3 :: Integer -> u1) (u4 :: u0) -> let {(uh :: Integer) = case u2 of { _ALG_ _TUP_12 (u5 :: {{Real u0}}) (u6 :: {{Ix u0}}) (u7 :: u0 -> u0 -> u0) (u8 :: u0 -> u0 -> u0) (u9 :: u0 -> u0 -> u0) (ua :: u0 -> u0 -> u0) (ub :: u0 -> u0 -> (u0, u0)) (uc :: u0 -> u0 -> (u0, u0)) (ud :: u0 -> Bool) (ue :: u0 -> Bool) (uf :: u0 -> Integer) (ug :: u0 -> Int) -> _APP_ uf [ u4 ]; _NO_DEFLT_ }} in _APP_ u3 [ uh ] _N_} _F_ _IF_ARGS_ 2 3 CCX 7 _/\_ u0 u1 -> \ (u2 :: {{Integral u0}}) (u3 :: {{Num u1}}) (u4 :: u0) -> let {(uh :: Integer) = case u2 of { _ALG_ _TUP_12 (u5 :: {{Real u0}}) (u6 :: {{Ix u0}}) (u7 :: u0 -> u0 -> u0) (u8 :: u0 -> u0 -> u0) (u9 :: u0 -> u0 -> u0) (ua :: u0 -> u0 -> u0) (ub :: u0 -> u0 -> (u0, u0)) (uc :: u0 -> u0 -> (u0, u0)) (ud :: u0 -> Bool) (ue :: u0 -> Bool) (uf :: u0 -> Integer) (ug :: u0 -> Int) -> _APP_ uf [ u4 ]; _NO_DEFLT_ }} in case u3 of { _ALG_ _TUP_10 (ui :: {{Eq u1}}) (uj :: {{Text u1}}) (uk :: u1 -> u1 -> u1) (ul :: u1 -> u1 -> u1) (um :: u1 -> u1 -> u1) (un :: u1 -> u1) (uo :: u1 -> u1) (up :: u1 -> u1) (uq :: Integer -> u1) (ur :: Int -> u1) -> _APP_ uq [ uh ]; _NO_DEFLT_ } _SPECIALISE_ [ Int, Double ] 2 { _A_ 1 _U_ 1 _N_ _S_ "U(P)" {_A_ 1 _U_ 2 _N_ _N_ _F_ _IF_ARGS_ 0 1 X 3 \ (u0 :: Int#) -> case _#_ int2Double# [] [u0] of { _PRIM_ (u1 :: Double#) -> _!_ D# [] [u1] } _N_} _F_ _IF_ARGS_ 0 1 C 4 \ (u0 :: Int) -> case u0 of { _ALG_ I# (u1 :: Int#) -> case _#_ int2Double# [] [u1] of { _PRIM_ (u2 :: Double#) -> _!_ D# [] [u2] }; _NO_DEFLT_ } _N_ }, [ Int, Int ] 2 { _A_ 1 _U_ 1 _N_ _N_ _F_ _IF_ARGS_ 0 0 X 1 _TYAPP_ _ORIG_ Prelude id { Int } _N_ }, [ Int, Integer ] 2 { _A_ 1 _U_ 1 _N_ _S_ "U(P)" {_A_ 1 _U_ 2 _N_ _N_ _F_ _IF_ARGS_ 0 1 X 1 \ (u0 :: Int#) -> _#_ int2Integer# [] [u0] _N_} _F_ _IF_ARGS_ 0 1 C 2 \ (u0 :: Int) -> case u0 of { _ALG_ I# (u1 :: Int#) -> _#_ int2Integer# [] [u1]; _NO_DEFLT_ } _N_ }, [ Integer, Double ] 2 { _A_ 1 _U_ 1 _N_ _S_ "U(PPP)" {_A_ 3 _U_ 222 _N_ _N_ _F_ _IF_ARGS_ 0 3 XXX 3 \ (u0 :: Int#) (u1 :: Int#) (u2 :: ByteArray#) -> case _#_ encodeDouble# [] [u0, u1, u2, 0#] of { _PRIM_ (u3 :: Double#) -> _!_ D# [] [u3] } _N_} _F_ _IF_ARGS_ 0 1 C 4 \ (u0 :: Integer) -> case u0 of { _ALG_ J# (u1 :: Int#) (u2 :: Int#) (u3 :: ByteArray#) -> case _#_ encodeDouble# [] [u1, u2, u3, 0#] of { _PRIM_ (u4 :: Double#) -> _!_ D# [] [u4] }; _NO_DEFLT_ } _N_ }, [ Integer, Int ] 2 { _A_ 1 _U_ 1 _N_ _S_ "U(PPP)" {_A_ 3 _U_ 222 _N_ _N_ _F_ _IF_ARGS_ 0 3 XXX 3 \ (u0 :: Int#) (u1 :: Int#) (u2 :: ByteArray#) -> case _#_ integer2Int# [] [u0, u1, u2] of { _PRIM_ (u3 :: Int#) -> _!_ I# [] [u3] } _N_} _F_ _IF_ARGS_ 0 1 C 4 \ (u0 :: Integer) -> case u0 of { _ALG_ J# (u1 :: Int#) (u2 :: Int#) (u3 :: ByteArray#) -> case _#_ integer2Int# [] [u1, u2, u3] of { _PRIM_ (u4 :: Int#) -> _!_ I# [] [u4] }; _NO_DEFLT_ } _N_ }, [ Integer, Integer ] 2 { _A_ 1 _U_ 1 _N_ _N_ _F_ _IF_ARGS_ 0 0 X 1 _TYAPP_ _ORIG_ Prelude id { Integer } _N_ } #-}
+ {-# GHC_PRAGMA _A_ 3 _U_ 112 _N_ _S_ "LU(AAAAAAAASA)L" {_A_ 3 _U_ 112 _N_ _N_ _F_ _IF_ARGS_ 2 3 CXX 6 _/\_ u0 u1 -> \ (u2 :: {{Integral u0}}) (u3 :: Integer -> u1) (u4 :: u0) -> let {(uh :: Integer) = case u2 of { _ALG_ _TUP_12 (u5 :: {{Real u0}}) (u6 :: {{Ix u0}}) (u7 :: u0 -> u0 -> u0) (u8 :: u0 -> u0 -> u0) (u9 :: u0 -> u0 -> u0) (ua :: u0 -> u0 -> u0) (ub :: u0 -> u0 -> (u0, u0)) (uc :: u0 -> u0 -> (u0, u0)) (ud :: u0 -> Bool) (ue :: u0 -> Bool) (uf :: u0 -> Integer) (ug :: u0 -> Int) -> _APP_ uf [ u4 ]; _NO_DEFLT_ }} in _APP_ u3 [ uh ] _N_} _F_ _IF_ARGS_ 2 3 CCX 7 _/\_ u0 u1 -> \ (u2 :: {{Integral u0}}) (u3 :: {{Num u1}}) (u4 :: u0) -> let {(uh :: Integer) = case u2 of { _ALG_ _TUP_12 (u5 :: {{Real u0}}) (u6 :: {{Ix u0}}) (u7 :: u0 -> u0 -> u0) (u8 :: u0 -> u0 -> u0) (u9 :: u0 -> u0 -> u0) (ua :: u0 -> u0 -> u0) (ub :: u0 -> u0 -> (u0, u0)) (uc :: u0 -> u0 -> (u0, u0)) (ud :: u0 -> Bool) (ue :: u0 -> Bool) (uf :: u0 -> Integer) (ug :: u0 -> Int) -> _APP_ uf [ u4 ]; _NO_DEFLT_ }} in case u3 of { _ALG_ _TUP_10 (ui :: {{Eq u1}}) (uj :: {{Text u1}}) (uk :: u1 -> u1 -> u1) (ul :: u1 -> u1 -> u1) (um :: u1 -> u1 -> u1) (un :: u1 -> u1) (uo :: u1 -> u1) (up :: u1 -> u1) (uq :: Integer -> u1) (ur :: Int -> u1) -> _APP_ uq [ uh ]; _NO_DEFLT_ } _SPECIALISE_ [ Int, Double ] 2 { _A_ 1 _U_ 1 _N_ _S_ "U(P)" {_A_ 1 _U_ 2 _N_ _N_ _F_ _IF_ARGS_ 0 1 X 3 \ (u0 :: Int#) -> case _#_ int2Double# [] [u0] of { _PRIM_ (u1 :: Double#) -> _!_ D# [] [u1] } _N_} _F_ _IF_ARGS_ 0 1 C 4 \ (u0 :: Int) -> case u0 of { _ALG_ I# (u1 :: Int#) -> case _#_ int2Double# [] [u1] of { _PRIM_ (u2 :: Double#) -> _!_ D# [] [u2] }; _NO_DEFLT_ } _N_ }, [ Int, Float ] 2 { _A_ 1 _U_ 1 _N_ _S_ "U(P)" {_A_ 1 _U_ 2 _N_ _N_ _F_ _IF_ARGS_ 0 1 X 3 \ (u0 :: Int#) -> case _#_ int2Float# [] [u0] of { _PRIM_ (u1 :: Float#) -> _!_ F# [] [u1] } _N_} _F_ _IF_ARGS_ 0 1 C 4 \ (u0 :: Int) -> case u0 of { _ALG_ I# (u1 :: Int#) -> case _#_ int2Float# [] [u1] of { _PRIM_ (u2 :: Float#) -> _!_ F# [] [u2] }; _NO_DEFLT_ } _N_ }, [ Int, Int ] 2 { _A_ 1 _U_ 1 _N_ _N_ _F_ _IF_ARGS_ 0 0 X 1 _TYAPP_ _ORIG_ Prelude id { Int } _N_ }, [ Int, Integer ] 2 { _A_ 1 _U_ 1 _N_ _S_ "U(P)" {_A_ 1 _U_ 2 _N_ _N_ _F_ _IF_ARGS_ 0 1 X 1 \ (u0 :: Int#) -> _#_ int2Integer# [] [u0] _N_} _F_ _IF_ARGS_ 0 1 C 2 \ (u0 :: Int) -> case u0 of { _ALG_ I# (u1 :: Int#) -> _#_ int2Integer# [] [u1]; _NO_DEFLT_ } _N_ }, [ Int, (Ratio Integer) ] 2 { _A_ 1 _U_ 1 _N_ _N_ _N_ _N_ }, [ Integer, Double ] 2 { _A_ 1 _U_ 1 _N_ _S_ "U(PPP)" {_A_ 3 _U_ 222 _N_ _N_ _F_ _IF_ARGS_ 0 3 XXX 3 \ (u0 :: Int#) (u1 :: Int#) (u2 :: ByteArray#) -> case _#_ encodeDouble# [] [u0, u1, u2, 0#] of { _PRIM_ (u3 :: Double#) -> _!_ D# [] [u3] } _N_} _F_ _IF_ARGS_ 0 1 C 4 \ (u0 :: Integer) -> case u0 of { _ALG_ J# (u1 :: Int#) (u2 :: Int#) (u3 :: ByteArray#) -> case _#_ encodeDouble# [] [u1, u2, u3, 0#] of { _PRIM_ (u4 :: Double#) -> _!_ D# [] [u4] }; _NO_DEFLT_ } _N_ }, [ Integer, Float ] 2 { _A_ 1 _U_ 1 _N_ _S_ "U(PPP)" {_A_ 3 _U_ 222 _N_ _N_ _F_ _IF_ARGS_ 0 3 XXX 3 \ (u0 :: Int#) (u1 :: Int#) (u2 :: ByteArray#) -> case _#_ encodeFloat# [] [u0, u1, u2, 0#] of { _PRIM_ (u3 :: Float#) -> _!_ F# [] [u3] } _N_} _F_ _IF_ARGS_ 0 1 C 4 \ (u0 :: Integer) -> case u0 of { _ALG_ J# (u1 :: Int#) (u2 :: Int#) (u3 :: ByteArray#) -> case _#_ encodeFloat# [] [u1, u2, u3, 0#] of { _PRIM_ (u4 :: Float#) -> _!_ F# [] [u4] }; _NO_DEFLT_ } _N_ }, [ Integer, Int ] 2 { _A_ 1 _U_ 1 _N_ _S_ "U(PPP)" {_A_ 3 _U_ 222 _N_ _N_ _F_ _IF_ARGS_ 0 3 XXX 3 \ (u0 :: Int#) (u1 :: Int#) (u2 :: ByteArray#) -> case _#_ integer2Int# [] [u0, u1, u2] of { _PRIM_ (u3 :: Int#) -> _!_ I# [] [u3] } _N_} _F_ _IF_ARGS_ 0 1 C 4 \ (u0 :: Integer) -> case u0 of { _ALG_ J# (u1 :: Int#) (u2 :: Int#) (u3 :: ByteArray#) -> case _#_ integer2Int# [] [u1, u2, u3] of { _PRIM_ (u4 :: Int#) -> _!_ I# [] [u4] }; _NO_DEFLT_ } _N_ }, [ Integer, Integer ] 2 { _A_ 1 _U_ 1 _N_ _N_ _F_ _IF_ARGS_ 0 0 X 1 _TYAPP_ _ORIG_ Prelude id { Integer } _N_ }, [ Integer, (Ratio Integer) ] 2 { _A_ 1 _U_ 2 _N_ _N_ _F_ _IF_ARGS_ 0 1 X 3 \ (u0 :: Integer) -> _!_ (:%) [Integer] [u0, _SPEC_ _ORIG_ PreludeCore __i1 [ (Integer) ]] _N_ } #-}
fromRealFrac :: (RealFrac a, Fractional b) => a -> b
- {-# GHC_PRAGMA _A_ 3 _U_ 112 _N_ _S_ "LU(AAAS)L" {_A_ 3 _U_ 112 _N_ _N_ _F_ _IF_ARGS_ 2 3 CXX 7 _/\_ u0 u1 -> \ (u2 :: {{RealFrac u0}}) (u3 :: Ratio Integer -> u1) (u4 :: u0) -> let {(uf :: Ratio Integer) = case u2 of { _ALG_ _TUP_7 (u5 :: {{Real u0}}) (u6 :: {{Fractional u0}}) (u7 :: _forall_ a$z1 =>{{Integral a$z1}} -> u0 -> (a$z1, u0)) (u8 :: _forall_ a$z1 =>{{Integral a$z1}} -> u0 -> a$z1) (u9 :: _forall_ a$z1 =>{{Integral a$z1}} -> u0 -> a$z1) (ua :: _forall_ a$z1 =>{{Integral a$z1}} -> u0 -> a$z1) (ub :: _forall_ a$z1 =>{{Integral a$z1}} -> u0 -> a$z1) -> case u5 of { _ALG_ _TUP_3 (uc :: {{Num u0}}) (ud :: {{Enum u0}}) (ue :: u0 -> Ratio Integer) -> _APP_ ue [ u4 ]; _NO_DEFLT_ }; _NO_DEFLT_ }} in _APP_ u3 [ uf ] _N_} _F_ _IF_ARGS_ 2 3 CCX 8 _/\_ u0 u1 -> \ (u2 :: {{RealFrac u0}}) (u3 :: {{Fractional u1}}) (u4 :: u0) -> let {(uf :: Ratio Integer) = case u2 of { _ALG_ _TUP_7 (u5 :: {{Real u0}}) (u6 :: {{Fractional u0}}) (u7 :: _forall_ a$z1 =>{{Integral a$z1}} -> u0 -> (a$z1, u0)) (u8 :: _forall_ a$z1 =>{{Integral a$z1}} -> u0 -> a$z1) (u9 :: _forall_ a$z1 =>{{Integral a$z1}} -> u0 -> a$z1) (ua :: _forall_ a$z1 =>{{Integral a$z1}} -> u0 -> a$z1) (ub :: _forall_ a$z1 =>{{Integral a$z1}} -> u0 -> a$z1) -> case u5 of { _ALG_ _TUP_3 (uc :: {{Num u0}}) (ud :: {{Enum u0}}) (ue :: u0 -> Ratio Integer) -> _APP_ ue [ u4 ]; _NO_DEFLT_ }; _NO_DEFLT_ }} in case u3 of { _ALG_ _TUP_4 (ug :: {{Num u1}}) (uh :: u1 -> u1 -> u1) (ui :: u1 -> u1) (uj :: Ratio Integer -> u1) -> _APP_ uj [ uf ]; _NO_DEFLT_ } _SPECIALISE_ [ Double, Double ] 2 { _A_ 1 _U_ 1 _N_ _N_ _F_ _IF_ARGS_ 0 0 X 1 _TYAPP_ _ORIG_ Prelude id { Double } _N_ }, [ Double, Float ] 2 { _A_ 1 _U_ 1 _N_ _S_ "U(P)" {_A_ 1 _U_ 2 _N_ _N_ _F_ _IF_ARGS_ 0 1 X 3 \ (u0 :: Double#) -> case _#_ double2Float# [] [u0] of { _PRIM_ (u1 :: Float#) -> _!_ F# [] [u1] } _N_} _F_ _IF_ARGS_ 0 1 C 4 \ (u0 :: Double) -> case u0 of { _ALG_ D# (u1 :: Double#) -> case _#_ double2Float# [] [u1] of { _PRIM_ (u2 :: Float#) -> _!_ F# [] [u2] }; _NO_DEFLT_ } _N_ }, [ Float, Double ] 2 { _A_ 1 _U_ 1 _N_ _S_ "U(P)" {_A_ 1 _U_ 2 _N_ _N_ _F_ _IF_ARGS_ 0 1 X 3 \ (u0 :: Float#) -> case _#_ float2Double# [] [u0] of { _PRIM_ (u1 :: Double#) -> _!_ D# [] [u1] } _N_} _F_ _IF_ARGS_ 0 1 C 4 \ (u0 :: Float) -> case u0 of { _ALG_ F# (u1 :: Float#) -> case _#_ float2Double# [] [u1] of { _PRIM_ (u2 :: Double#) -> _!_ D# [] [u2] }; _NO_DEFLT_ } _N_ }, [ Float, Float ] 2 { _A_ 1 _U_ 1 _N_ _N_ _F_ _IF_ARGS_ 0 0 X 1 _TYAPP_ _ORIG_ Prelude id { Float } _N_ } #-}
+ {-# GHC_PRAGMA _A_ 3 _U_ 112 _N_ _S_ "LU(AAAS)L" {_A_ 3 _U_ 112 _N_ _N_ _F_ _IF_ARGS_ 2 3 CXX 7 _/\_ u0 u1 -> \ (u2 :: {{RealFrac u0}}) (u3 :: Ratio Integer -> u1) (u4 :: u0) -> let {(uf :: Ratio Integer) = case u2 of { _ALG_ _TUP_7 (u5 :: {{Real u0}}) (u6 :: {{Fractional u0}}) (u7 :: _forall_ a$z1 =>{{Integral a$z1}} -> u0 -> (a$z1, u0)) (u8 :: _forall_ a$z1 =>{{Integral a$z1}} -> u0 -> a$z1) (u9 :: _forall_ a$z1 =>{{Integral a$z1}} -> u0 -> a$z1) (ua :: _forall_ a$z1 =>{{Integral a$z1}} -> u0 -> a$z1) (ub :: _forall_ a$z1 =>{{Integral a$z1}} -> u0 -> a$z1) -> case u5 of { _ALG_ _TUP_3 (uc :: {{Num u0}}) (ud :: {{Enum u0}}) (ue :: u0 -> Ratio Integer) -> _APP_ ue [ u4 ]; _NO_DEFLT_ }; _NO_DEFLT_ }} in _APP_ u3 [ uf ] _N_} _F_ _IF_ARGS_ 2 3 CCX 8 _/\_ u0 u1 -> \ (u2 :: {{RealFrac u0}}) (u3 :: {{Fractional u1}}) (u4 :: u0) -> let {(uf :: Ratio Integer) = case u2 of { _ALG_ _TUP_7 (u5 :: {{Real u0}}) (u6 :: {{Fractional u0}}) (u7 :: _forall_ a$z1 =>{{Integral a$z1}} -> u0 -> (a$z1, u0)) (u8 :: _forall_ a$z1 =>{{Integral a$z1}} -> u0 -> a$z1) (u9 :: _forall_ a$z1 =>{{Integral a$z1}} -> u0 -> a$z1) (ua :: _forall_ a$z1 =>{{Integral a$z1}} -> u0 -> a$z1) (ub :: _forall_ a$z1 =>{{Integral a$z1}} -> u0 -> a$z1) -> case u5 of { _ALG_ _TUP_3 (uc :: {{Num u0}}) (ud :: {{Enum u0}}) (ue :: u0 -> Ratio Integer) -> _APP_ ue [ u4 ]; _NO_DEFLT_ }; _NO_DEFLT_ }} in case u3 of { _ALG_ _TUP_4 (ug :: {{Num u1}}) (uh :: u1 -> u1 -> u1) (ui :: u1 -> u1) (uj :: Ratio Integer -> u1) -> _APP_ uj [ uf ]; _NO_DEFLT_ } _SPECIALISE_ [ Double, Double ] 2 { _A_ 1 _U_ 1 _N_ _N_ _F_ _IF_ARGS_ 0 0 X 1 _TYAPP_ _ORIG_ Prelude id { Double } _N_ }, [ Double, Float ] 2 { _A_ 1 _U_ 1 _N_ _S_ "U(P)" {_A_ 1 _U_ 2 _N_ _N_ _F_ _IF_ARGS_ 0 1 X 3 \ (u0 :: Double#) -> case _#_ double2Float# [] [u0] of { _PRIM_ (u1 :: Float#) -> _!_ F# [] [u1] } _N_} _F_ _IF_ARGS_ 0 1 C 4 \ (u0 :: Double) -> case u0 of { _ALG_ D# (u1 :: Double#) -> case _#_ double2Float# [] [u1] of { _PRIM_ (u2 :: Float#) -> _!_ F# [] [u2] }; _NO_DEFLT_ } _N_ }, [ Double, (Ratio Integer) ] 2 { _A_ 1 _U_ 1 _N_ _S_ "U(P)" {_A_ 1 _U_ 2 _N_ _N_ _N_ _N_} _N_ _N_ }, [ Float, Double ] 2 { _A_ 1 _U_ 1 _N_ _S_ "U(P)" {_A_ 1 _U_ 2 _N_ _N_ _F_ _IF_ARGS_ 0 1 X 3 \ (u0 :: Float#) -> case _#_ float2Double# [] [u0] of { _PRIM_ (u1 :: Double#) -> _!_ D# [] [u1] } _N_} _F_ _IF_ARGS_ 0 1 C 4 \ (u0 :: Float) -> case u0 of { _ALG_ F# (u1 :: Float#) -> case _#_ float2Double# [] [u1] of { _PRIM_ (u2 :: Double#) -> _!_ D# [] [u2] }; _NO_DEFLT_ } _N_ }, [ Float, Float ] 2 { _A_ 1 _U_ 1 _N_ _N_ _F_ _IF_ARGS_ 0 0 X 1 _TYAPP_ _ORIG_ Prelude id { Float } _N_ }, [ Float, (Ratio Integer) ] 2 { _A_ 1 _U_ 1 _N_ _S_ "U(P)" {_A_ 1 _U_ 2 _N_ _N_ _N_ _N_} _N_ _N_ }, [ (Ratio Integer), Double ] 2 { _A_ 1 _U_ 1 _N_ _S_ "U(U(PPP)U(PPP))" {_A_ 4 _U_ 2222 _N_ _N_ _N_ _N_} _N_ _N_ }, [ (Ratio Integer), Float ] 2 { _A_ 1 _U_ 2 _N_ _N_ _F_ _IF_ARGS_ 0 0 X 1 _CONSTM_ Fractional fromRational (Float) _N_ }, [ (Ratio Integer), (Ratio Integer) ] 2 { _A_ 1 _U_ 1 _N_ _N_ _F_ _IF_ARGS_ 0 0 X 1 _TYAPP_ _ORIG_ Prelude id { (Ratio Integer) } _N_ } #-}
fst :: (b, a) -> b
{-# GHC_PRAGMA _A_ 1 _U_ 1 _N_ _S_ "U(SA)" {_A_ 1 _U_ 1 _N_ _N_ _F_ _IF_ARGS_ 2 1 X 1 _/\_ u0 u1 -> \ (u2 :: u1) -> u2 _N_} _F_ _IF_ARGS_ 2 1 C 2 _/\_ u0 u1 -> \ (u2 :: (u1, u0)) -> case u2 of { _ALG_ _TUP_2 (u3 :: u1) (u4 :: u0) -> u3; _NO_DEFLT_ } _N_ #-}
gcd :: Integral a => a -> a -> a
isLower :: Char -> Bool
{-# GHC_PRAGMA _A_ 1 _U_ 1 _N_ _S_ "U(P)" {_A_ 1 _U_ 2 _N_ _N_ _N_ _N_} _N_ _N_ #-}
isNullBin :: Bin -> Bool
- {-# GHC_PRAGMA _A_ 1 _U_ 2 _N_ _S_ _!_ _F_ _IF_ARGS_ 0 1 X 3 \ (u0 :: Bin) -> _APP_ _TYAPP_ error { (Bin -> Bool) } [ _NOREP_S_ "isNullBin{Prelude}\n", u0 ] _N_ #-}
+ {-# GHC_PRAGMA _A_ 1 _U_ 2 _N_ _S_ _!_ _N_ _N_ #-}
isPrint :: Char -> Bool
{-# GHC_PRAGMA _A_ 1 _U_ 1 _N_ _S_ "U(P)" {_A_ 1 _U_ 2 _N_ _N_ _N_ _N_} _N_ _N_ #-}
isSpace :: Char -> Bool
not :: Bool -> Bool
{-# GHC_PRAGMA _A_ 1 _U_ 1 _N_ _S_ "E" _F_ _ALWAYS_ \ (u0 :: Bool) -> case u0 of { _ALG_ True -> _!_ False [] []; False -> _!_ True [] []; _NO_DEFLT_ } _N_ #-}
nullBin :: Bin
- {-# GHC_PRAGMA _A_ 0 _N_ _N_ _S_ _!_ _F_ _IF_ARGS_ 0 0 X 2 _APP_ _TYAPP_ error { Bin } [ _NOREP_S_ "nullBin{Prelude}\n" ] _N_ #-}
+ {-# GHC_PRAGMA _A_ 0 _N_ _N_ _S_ _!_ _N_ _N_ #-}
ord :: Char -> Int
{-# GHC_PRAGMA _A_ 1 _U_ 1 _N_ _S_ "U(P)" {_A_ 1 _U_ 2 _N_ _N_ _F_ _IF_ARGS_ 0 1 X 3 \ (u0 :: Char#) -> case _#_ ord# [] [u0] of { _PRIM_ (u1 :: Int#) -> _!_ I# [] [u1] } _N_} _F_ _IF_ARGS_ 0 1 C 4 \ (u0 :: Char) -> case u0 of { _ALG_ C# (u1 :: Char#) -> case _#_ ord# [] [u1] of { _PRIM_ (u2 :: Int#) -> _!_ I# [] [u2] }; _NO_DEFLT_ } _N_ #-}
otherwise :: Bool
snd :: (a, b) -> b
{-# GHC_PRAGMA _A_ 1 _U_ 1 _N_ _S_ "U(AS)" {_A_ 1 _U_ 1 _N_ _N_ _F_ _IF_ARGS_ 2 1 X 1 _/\_ u0 u1 -> \ (u2 :: u1) -> u2 _N_} _F_ _IF_ARGS_ 2 1 C 2 _/\_ u0 u1 -> \ (u2 :: (u0, u1)) -> case u2 of { _ALG_ _TUP_2 (u3 :: u0) (u4 :: u1) -> u4; _NO_DEFLT_ } _N_ #-}
subtract :: Num a => a -> a -> a
- {-# GHC_PRAGMA _A_ 3 _U_ 122 _N_ _S_ "U(AAASAAAAAA)LL" {_A_ 3 _U_ 122 _N_ _N_ _F_ _IF_ARGS_ 1 3 XXX 3 _/\_ u0 -> \ (u1 :: u0 -> u0 -> u0) (u2 :: u0) (u3 :: u0) -> _APP_ u1 [ u3, u2 ] _N_} _F_ _IF_ARGS_ 1 3 CXX 4 _/\_ u0 -> \ (u1 :: {{Num u0}}) (u2 :: u0) (u3 :: u0) -> case u1 of { _ALG_ _TUP_10 (u4 :: {{Eq u0}}) (u5 :: {{Text u0}}) (u6 :: u0 -> u0 -> u0) (u7 :: u0 -> u0 -> u0) (u8 :: u0 -> u0 -> u0) (u9 :: u0 -> u0) (ua :: u0 -> u0) (ub :: u0 -> u0) (uc :: Integer -> u0) (ud :: Int -> u0) -> _APP_ u7 [ u3, u2 ]; _NO_DEFLT_ } _SPECIALISE_ [ Double ] 1 { _A_ 2 _U_ 11 _N_ _S_ "U(P)U(P)" {_A_ 2 _U_ 22 _N_ _N_ _F_ _IF_ARGS_ 0 2 XX 3 \ (u0 :: Double#) (u1 :: Double#) -> case _#_ minusDouble# [] [u1, u0] of { _PRIM_ (u2 :: Double#) -> _!_ D# [] [u2] } _N_} _F_ _IF_ARGS_ 0 2 CC 5 \ (u0 :: Double) (u1 :: Double) -> case u1 of { _ALG_ D# (u2 :: Double#) -> case u0 of { _ALG_ D# (u3 :: Double#) -> case _#_ minusDouble# [] [u2, u3] of { _PRIM_ (u4 :: Double#) -> _!_ D# [] [u4] }; _NO_DEFLT_ }; _NO_DEFLT_ } _N_ }, [ Int ] 1 { _A_ 2 _U_ 11 _N_ _S_ "U(P)U(P)" {_A_ 2 _U_ 22 _N_ _N_ _F_ _IF_ARGS_ 0 2 XX 3 \ (u0 :: Int#) (u1 :: Int#) -> case _#_ minusInt# [] [u1, u0] of { _PRIM_ (u2 :: Int#) -> _!_ I# [] [u2] } _N_} _F_ _IF_ARGS_ 0 2 CC 5 \ (u0 :: Int) (u1 :: Int) -> case u1 of { _ALG_ I# (u2 :: Int#) -> case u0 of { _ALG_ I# (u3 :: Int#) -> case _#_ minusInt# [] [u2, u3] of { _PRIM_ (u4 :: Int#) -> _!_ I# [] [u4] }; _NO_DEFLT_ }; _NO_DEFLT_ } _N_ } #-}
+ {-# GHC_PRAGMA _A_ 3 _U_ 122 _N_ _S_ "U(AAASAAAAAA)LL" {_A_ 3 _U_ 122 _N_ _N_ _F_ _IF_ARGS_ 1 3 XXX 3 _/\_ u0 -> \ (u1 :: u0 -> u0 -> u0) (u2 :: u0) (u3 :: u0) -> _APP_ u1 [ u3, u2 ] _N_} _F_ _IF_ARGS_ 1 3 CXX 4 _/\_ u0 -> \ (u1 :: {{Num u0}}) (u2 :: u0) (u3 :: u0) -> case u1 of { _ALG_ _TUP_10 (u4 :: {{Eq u0}}) (u5 :: {{Text u0}}) (u6 :: u0 -> u0 -> u0) (u7 :: u0 -> u0 -> u0) (u8 :: u0 -> u0 -> u0) (u9 :: u0 -> u0) (ua :: u0 -> u0) (ub :: u0 -> u0) (uc :: Integer -> u0) (ud :: Int -> u0) -> _APP_ u7 [ u3, u2 ]; _NO_DEFLT_ } _SPECIALISE_ [ Double ] 1 { _A_ 2 _U_ 11 _N_ _S_ "U(P)U(P)" {_A_ 2 _U_ 22 _N_ _N_ _F_ _IF_ARGS_ 0 2 XX 3 \ (u0 :: Double#) (u1 :: Double#) -> case _#_ minusDouble# [] [u1, u0] of { _PRIM_ (u2 :: Double#) -> _!_ D# [] [u2] } _N_} _F_ _IF_ARGS_ 0 2 CC 5 \ (u0 :: Double) (u1 :: Double) -> case u1 of { _ALG_ D# (u2 :: Double#) -> case u0 of { _ALG_ D# (u3 :: Double#) -> case _#_ minusDouble# [] [u2, u3] of { _PRIM_ (u4 :: Double#) -> _!_ D# [] [u4] }; _NO_DEFLT_ }; _NO_DEFLT_ } _N_ }, [ Int ] 1 { _A_ 2 _U_ 11 _N_ _S_ "U(P)U(P)" {_A_ 2 _U_ 22 _N_ _N_ _F_ _IF_ARGS_ 0 2 XX 3 \ (u0 :: Int#) (u1 :: Int#) -> case _#_ minusInt# [] [u1, u0] of { _PRIM_ (u2 :: Int#) -> _!_ I# [] [u2] } _N_} _F_ _IF_ARGS_ 0 2 CC 5 \ (u0 :: Int) (u1 :: Int) -> case u1 of { _ALG_ I# (u2 :: Int#) -> case u0 of { _ALG_ I# (u3 :: Int#) -> case _#_ minusInt# [] [u2, u3] of { _PRIM_ (u4 :: Int#) -> _!_ I# [] [u4] }; _NO_DEFLT_ }; _NO_DEFLT_ } _N_ }, [ (Complex Double) ] 1 { _A_ 2 _U_ 11 _N_ _S_ "U(LL)U(LL)" {_A_ 4 _U_ 2222 _N_ _N_ _N_ _N_} _N_ _N_ } #-}
thenMaybe :: Maybe a -> (a -> Maybe b) -> Maybe b
{-# GHC_PRAGMA _A_ 2 _U_ 11 _N_ _S_ "SL" _F_ _IF_ARGS_ 2 2 CX 5 _/\_ u0 u1 -> \ (u2 :: Maybe u0) (u3 :: u0 -> Maybe u1) -> case u2 of { _ALG_ Nothing -> _!_ Nothing [u1] []; Just (u4 :: u0) -> _APP_ u3 [ u4 ]; _NO_DEFLT_ } _N_ #-}
toLower :: Char -> Char
imagPart :: Complex a -> a
{-# GHC_PRAGMA _A_ 1 _U_ 1 _N_ _S_ "U(AS)" {_A_ 1 _U_ 1 _N_ _N_ _F_ _IF_ARGS_ 1 1 X 1 _/\_ u0 -> \ (u1 :: u0) -> u1 _N_} _F_ _IF_ARGS_ 1 1 C 2 _/\_ u0 -> \ (u1 :: Complex u0) -> case u1 of { _ALG_ (:+) (u2 :: u0) (u3 :: u0) -> u3; _NO_DEFLT_ } _N_ #-}
magnitude :: RealFloat a => Complex a -> a
- {-# GHC_PRAGMA _A_ 1 _U_ 12 _N_ _S_ "U(ALAAAAALAS)" {_A_ 3 _U_ 2221 _N_ _N_ _N_ _N_} _N_ _SPECIALISE_ [ Double ] 1 { _A_ 1 _U_ 1 _N_ _S_ "U(LL)" {_A_ 2 _U_ 22 _N_ _N_ _N_ _N_} _N_ _N_ } #-}
+ {-# GHC_PRAGMA _A_ 1 _U_ 12 _N_ _S_ "U(ALAAAAALAS)" {_A_ 3 _U_ 2221 _N_ _N_ _N_ _N_} _N_ _SPECIALISE_ [ Double ] 1 { _A_ 1 _U_ 1 _N_ _S_ "U(U(P)U(P))" {_A_ 2 _U_ 22 _N_ _N_ _N_ _N_} _N_ _N_ } #-}
mkPolar :: RealFloat a => a -> a -> Complex a
{-# GHC_PRAGMA _A_ 3 _U_ 122 _N_ _N_ _N_ _SPECIALISE_ [ Double ] 1 { _A_ 2 _U_ 22 _N_ _N_ _N_ _N_ } #-}
phase :: RealFloat a => Complex a -> a
{-# GHC_PRAGMA _A_ 1 _U_ 22 _N_ _N_ _N_ _SPECIALISE_ [ Double ] 1 { _A_ 1 _U_ 2 _N_ _N_ _N_ _N_ } #-}
realPart :: Complex a -> a
{-# GHC_PRAGMA _A_ 1 _U_ 1 _N_ _S_ "U(SA)" {_A_ 1 _U_ 1 _N_ _N_ _F_ _IF_ARGS_ 1 1 X 1 _/\_ u0 -> \ (u1 :: u0) -> u1 _N_} _F_ _IF_ARGS_ 1 1 C 2 _/\_ u0 -> \ (u1 :: Complex u0) -> case u1 of { _ALG_ (:+) (u2 :: u0) (u3 :: u0) -> u2; _NO_DEFLT_ } _N_ #-}
-_ceiling :: (RealFrac a, Integral b) => a -> b
- {-# GHC_PRAGMA _A_ 2 _U_ 122 _N_ _S_ "U(U(AU(U(AAAASAAA)AAAA)A)LSAAAA)L" {_A_ 4 _U_ 11122 _N_ _N_ _N_ _N_} _N_ _SPECIALISE_ [ Double, Int ] 2 { _A_ 0 _U_ 2 _N_ _N_ _N_ _N_ } #-}
-_floor :: (RealFrac a, Integral b) => a -> b
- {-# GHC_PRAGMA _A_ 2 _U_ 122 _N_ _S_ "U(U(AU(U(ASAAAAAA)AAAA)A)LSAAAA)L" {_A_ 4 _U_ 11122 _N_ _N_ _N_ _N_} _N_ _SPECIALISE_ [ Double, Int ] 2 { _A_ 0 _U_ 2 _N_ _N_ _N_ _N_ } #-}
-_readList :: Text a => [Char] -> [([a], [Char])]
+_readList :: ([Char] -> [(a, [Char])]) -> [Char] -> [([a], [Char])]
{-# GHC_PRAGMA _A_ 1 _U_ 22 _N_ _N_ _N_ _N_ #-}
-_round :: (RealFrac a, Integral b) => a -> b
- {-# GHC_PRAGMA _A_ 2 _U_ 122 _N_ _S_ "U(U(AU(U(ALAAAAAS)AAAA)A)LSAAAA)L" {_A_ 5 _U_ 112122 _N_ _N_ _N_ _N_} _N_ _SPECIALISE_ [ Double, Int ] 2 { _A_ 0 _U_ 2 _N_ _N_ _N_ _N_ }, [ (Ratio Integer), Integer ] 2 { _A_ 1 _U_ 1 _N_ _S_ "U(LL)" {_A_ 2 _U_ 22 _N_ _N_ _N_ _N_} _N_ _N_ } #-}
-_showList :: Text a => [a] -> [Char] -> [Char]
- {-# GHC_PRAGMA _A_ 1 _U_ 212 _N_ _N_ _N_ _N_ #-}
+_showList :: (a -> [Char] -> [Char]) -> [a] -> [Char] -> [Char]
+ {-# GHC_PRAGMA _A_ 2 _U_ 212 _N_ _S_ "LS" _N_ _N_ #-}
_showRational :: Int -> Ratio Integer -> [Char]
{-# GHC_PRAGMA _A_ 2 _U_ 21 _N_ _S_ "LU(U(PPP)L)" {_A_ 5 _U_ 22222 _N_ _N_ _N_ _N_} _N_ _N_ #-}
-_truncate :: (RealFrac a, Integral b) => a -> b
- {-# GHC_PRAGMA _A_ 2 _U_ 122 _N_ _S_ "U(AASAAAA)L" {_A_ 2 _U_ 122 _N_ _N_ _N_ _N_} _N_ _SPECIALISE_ [ Double, Int ] 2 { _A_ 0 _U_ 2 _N_ _N_ _N_ _N_ } #-}
interact :: ([Char] -> [Char]) -> _State _RealWorld -> (Either IOError13 (), _State _RealWorld)
{-# GHC_PRAGMA _A_ 2 _U_ 11 _N_ _S_ "LU(P)" {_A_ 2 _U_ 12 _N_ _N_ _N_ _N_} _N_ _N_ #-}
(!!) :: Integral a => [b] -> a -> b
(++) :: [a] -> [a] -> [a]
{-# GHC_PRAGMA _A_ 2 _U_ 12 _N_ _S_ "SL" _N_ _N_ #-}
(\\) :: Eq a => [a] -> [a] -> [a]
- {-# GHC_PRAGMA _A_ 3 _U_ 122 _N_ _S_ "LLS" _N_ _N_ #-}
+ {-# GHC_PRAGMA _A_ 3 _U_ 122 _N_ _S_ "LLS" _N_ _SPECIALISE_ [ Int ] 1 { _A_ 2 _U_ 22 _N_ _S_ "LS" _N_ _N_ }, [ [Char] ] 1 { _A_ 2 _U_ 22 _N_ _S_ "LS" _N_ _N_ } #-}
all :: (a -> Bool) -> [a] -> Bool
{-# GHC_PRAGMA _A_ 2 _U_ 21 _N_ _S_ "LS" _F_ _ALWAYS_ _/\_ u0 -> \ (u1 :: u0 -> Bool) (u2 :: [u0]) -> let {(u3 :: Bool) = _!_ True [] []} in let {(u6 :: u0 -> Bool -> Bool) = \ (u4 :: u0) (u5 :: Bool) -> case _APP_ u1 [ u4 ] of { _ALG_ True -> u5; False -> _!_ False [] []; _NO_DEFLT_ }} in _APP_ _TYAPP_ _TYAPP_ foldr { u0 } { Bool } [ u6, u3, u2 ] _N_ #-}
and :: [Bool] -> Bool
dropWhile :: (a -> Bool) -> [a] -> [a]
{-# GHC_PRAGMA _A_ 2 _U_ 21 _N_ _S_ "LS" _N_ _N_ #-}
elem :: Eq a => a -> [a] -> Bool
- {-# GHC_PRAGMA _A_ 3 _U_ 121 _N_ _S_ "LLS" _F_ _ALWAYS_ _/\_ u0 -> \ (u1 :: {{Eq u0}}) (u2 :: u0) (u3 :: [u0]) -> let {(u6 :: u0 -> u0 -> Bool) = case u1 of { _ALG_ _TUP_2 (u4 :: u0 -> u0 -> Bool) (u5 :: u0 -> u0 -> Bool) -> u4; _NO_DEFLT_ }} in let {(u8 :: u0 -> Bool) = \ (u7 :: u0) -> _APP_ u6 [ u2, u7 ]} in _APP_ _TYAPP_ _ORIG_ PreludeList any { u0 } [ u8, u3 ] _SPECIALISE_ [ Char ] 1 { _A_ 2 _U_ 21 _N_ _S_ "LS" _F_ _ALWAYS_ \ (u0 :: Char) (u1 :: [Char]) -> let {(u5 :: Char -> Bool) = \ (u2 :: Char) -> case u0 of { _ALG_ C# (u3 :: Char#) -> case u2 of { _ALG_ C# (u4 :: Char#) -> _#_ eqChar# [] [u3, u4]; _NO_DEFLT_ }; _NO_DEFLT_ }} in _APP_ _TYAPP_ _ORIG_ PreludeList any { Char } [ u5, u1 ] _N_ }, [ Int ] 1 { _A_ 2 _U_ 21 _N_ _S_ "LS" _F_ _ALWAYS_ \ (u0 :: Int) (u1 :: [Int]) -> let {(u5 :: Int -> Bool) = \ (u2 :: Int) -> case u0 of { _ALG_ I# (u3 :: Int#) -> case u2 of { _ALG_ I# (u4 :: Int#) -> _#_ eqInt# [] [u3, u4]; _NO_DEFLT_ }; _NO_DEFLT_ }} in _APP_ _TYAPP_ _ORIG_ PreludeList any { Int } [ u5, u1 ] _N_ }, [ [Char] ] 1 { _A_ 2 _U_ 21 _N_ _S_ "LS" _F_ _ALWAYS_ \ (u0 :: [Char]) (u1 :: [[Char]]) -> let {(u3 :: [Char] -> Bool) = \ (u2 :: [Char]) -> _APP_ _CONSTM_ Eq (==) ([Char]) [ u0, u2 ]} in _APP_ _TYAPP_ _ORIG_ PreludeList any { [Char] } [ u3, u1 ] _N_ } #-}
+ {-# GHC_PRAGMA _A_ 3 _U_ 121 _N_ _S_ "LLS" _F_ _ALWAYS_ _/\_ u0 -> \ (u1 :: {{Eq u0}}) (u2 :: u0) (u3 :: [u0]) -> let {(u6 :: u0 -> u0 -> Bool) = case u1 of { _ALG_ _TUP_2 (u4 :: u0 -> u0 -> Bool) (u5 :: u0 -> u0 -> Bool) -> u4; _NO_DEFLT_ }} in let {(u8 :: u0 -> Bool) = \ (u7 :: u0) -> _APP_ u6 [ u2, u7 ]} in _APP_ _TYAPP_ _ORIG_ PreludeList any { u0 } [ u8, u3 ] _SPECIALISE_ [ Char ] 1 { _A_ 2 _U_ 21 _N_ _S_ "LS" _F_ _ALWAYS_ \ (u0 :: Char) (u1 :: [Char]) -> let {(u5 :: Char -> Bool) = \ (u2 :: Char) -> case u0 of { _ALG_ C# (u3 :: Char#) -> case u2 of { _ALG_ C# (u4 :: Char#) -> _#_ eqChar# [] [u3, u4]; _NO_DEFLT_ }; _NO_DEFLT_ }} in _APP_ _TYAPP_ _ORIG_ PreludeList any { Char } [ u5, u1 ] _N_ }, [ Int ] 1 { _A_ 2 _U_ 21 _N_ _S_ "LS" _F_ _ALWAYS_ \ (u0 :: Int) (u1 :: [Int]) -> let {(u5 :: Int -> Bool) = \ (u2 :: Int) -> case u0 of { _ALG_ I# (u3 :: Int#) -> case u2 of { _ALG_ I# (u4 :: Int#) -> _#_ eqInt# [] [u3, u4]; _NO_DEFLT_ }; _NO_DEFLT_ }} in _APP_ _TYAPP_ _ORIG_ PreludeList any { Int } [ u5, u1 ] _N_ }, [ Integer ] 1 { _A_ 2 _U_ 21 _N_ _S_ "LS" _F_ _ALWAYS_ \ (u0 :: Integer) (u1 :: [Integer]) -> let {(ua :: Integer -> Bool) = \ (u2 :: Integer) -> case u0 of { _ALG_ J# (u3 :: Int#) (u4 :: Int#) (u5 :: ByteArray#) -> case u2 of { _ALG_ J# (u6 :: Int#) (u7 :: Int#) (u8 :: ByteArray#) -> case _#_ cmpInteger# [] [u3, u4, u5, u6, u7, u8] of { _PRIM_ 0# -> _!_ True [] []; (u9 :: Int#) -> _!_ False [] [] }; _NO_DEFLT_ }; _NO_DEFLT_ }} in _APP_ _TYAPP_ _ORIG_ PreludeList any { Integer } [ ua, u1 ] _N_ }, [ [Char] ] 1 { _A_ 2 _U_ 21 _N_ _S_ "LS" _F_ _ALWAYS_ \ (u0 :: [Char]) (u1 :: [[Char]]) -> let {(u3 :: [Char] -> Bool) = \ (u2 :: [Char]) -> _APP_ _CONSTM_ Eq (==) ([Char]) [ u0, u2 ]} in _APP_ _TYAPP_ _ORIG_ PreludeList any { [Char] } [ u3, u1 ] _N_ }, [ [Int] ] 1 { _A_ 2 _U_ 21 _N_ _S_ "LS" _F_ _ALWAYS_ \ (u0 :: [Int]) (u1 :: [[Int]]) -> let {(u3 :: [Int] -> Bool) = \ (u2 :: [Int]) -> _APP_ _CONSTM_ Eq (==) ([Int]) [ u0, u2 ]} in _APP_ _TYAPP_ _ORIG_ PreludeList any { [Int] } [ u3, u1 ] _N_ }, [ (Int, Int) ] 1 { _A_ 2 _U_ 21 _N_ _S_ "LS" _F_ _ALWAYS_ \ (u0 :: (Int, Int)) (u1 :: [(Int, Int)]) -> let {(ub :: (Int, Int) -> Bool) = \ (u2 :: (Int, Int)) -> case u0 of { _ALG_ _TUP_2 (u3 :: Int) (u4 :: Int) -> case u3 of { _ALG_ I# (u5 :: Int#) -> case u2 of { _ALG_ _TUP_2 (u6 :: Int) (u7 :: Int) -> case u6 of { _ALG_ I# (u8 :: Int#) -> case _#_ eqInt# [] [u5, u8] of { _ALG_ True -> case u4 of { _ALG_ I# (u9 :: Int#) -> case u7 of { _ALG_ I# (ua :: Int#) -> _#_ eqInt# [] [u9, ua]; _NO_DEFLT_ }; _NO_DEFLT_ }; False -> _!_ False [] []; _NO_DEFLT_ }; _NO_DEFLT_ }; _NO_DEFLT_ }; _NO_DEFLT_ }; _NO_DEFLT_ }} in _APP_ _TYAPP_ _ORIG_ PreludeList any { (Int, Int) } [ ub, u1 ] _N_ } #-}
filter :: (a -> Bool) -> [a] -> [a]
{-# GHC_PRAGMA _A_ 2 _U_ 21 _N_ _S_ "LS" _F_ _ALWAYS_ _/\_ u0 -> \ (u1 :: u0 -> Bool) (u2 :: [u0]) -> let {(u9 :: _forall_ a$z1 =>(u0 -> a$z1 -> a$z1) -> a$z1 -> a$z1) = _/\_ u3 -> \ (u4 :: u0 -> u3 -> u3) (u5 :: u3) -> let {(u8 :: u0 -> u3 -> u3) = \ (u6 :: u0) (u7 :: u3) -> case _APP_ u1 [ u6 ] of { _ALG_ True -> _APP_ u4 [ u6, u7 ]; False -> u7; _NO_DEFLT_ }} in _APP_ _TYAPP_ _TYAPP_ foldr { u0 } { u3 } [ u8, u5, u2 ]} in _APP_ _TYAPP_ _build { u0 } [ u9 ] _N_ #-}
foldl1 :: (a -> a -> a) -> [a] -> a
foldr1 :: (a -> a -> a) -> [a] -> a
{-# GHC_PRAGMA _A_ 2 _U_ 21 _N_ _S_ "LS" _N_ _N_ #-}
genericLength :: Num b => [a] -> b
- {-# GHC_PRAGMA _A_ 1 _U_ 21 _N_ _N_ _N_ _N_ #-}
+ {-# GHC_PRAGMA _A_ 1 _U_ 21 _N_ _N_ _N_ _SPECIALISE_ [ _N_, Int ] 1 { _A_ 1 _U_ 1 _N_ _S_ "S" _N_ _N_ }, [ _N_, Integer ] 1 { _A_ 1 _U_ 1 _N_ _S_ "S" _N_ _N_ } #-}
head :: [a] -> a
{-# GHC_PRAGMA _A_ 1 _U_ 1 _N_ _S_ "S" _F_ _ALWAYS_ _/\_ u0 -> \ (u1 :: [u0]) -> let {(u2 :: u0) = _APP_ _TYAPP_ error { u0 } [ _NOREP_S_ "head{PreludeList}: head []\n" ]} in let {(u5 :: u0 -> u0 -> u0) = \ (u3 :: u0) (u4 :: u0) -> u3} in _APP_ _TYAPP_ _TYAPP_ foldr { u0 } { u0 } [ u5, u2, u1 ] _N_ #-}
init :: [a] -> [a]
map :: (a -> b) -> [a] -> [b]
{-# GHC_PRAGMA _A_ 2 _U_ 21 _N_ _S_ "LS" _F_ _ALWAYS_ _/\_ u0 u1 -> \ (u2 :: u0 -> u1) (u3 :: [u0]) -> let {(ua :: _forall_ a$z1 =>(u1 -> a$z1 -> a$z1) -> a$z1 -> a$z1) = _/\_ u4 -> \ (u5 :: u1 -> u4 -> u4) (u6 :: u4) -> let {(u9 :: u0 -> u4 -> u4) = \ (u7 :: u0) -> let {(u8 :: u1) = _APP_ u2 [ u7 ]} in _APP_ u5 [ u8 ]} in _APP_ _TYAPP_ _TYAPP_ foldr { u0 } { u4 } [ u9, u6, u3 ]} in _APP_ _TYAPP_ _build { u1 } [ ua ] _N_ #-}
maximum :: Ord a => [a] -> a
- {-# GHC_PRAGMA _A_ 1 _U_ 11 _N_ _N_ _N_ _N_ #-}
+ {-# GHC_PRAGMA _A_ 1 _U_ 11 _N_ _N_ _N_ _SPECIALISE_ [ Double ] 1 { _A_ 1 _U_ 1 _N_ _S_ "S" _N_ _N_ }, [ Int ] 1 { _A_ 1 _U_ 1 _N_ _S_ "S" _N_ _N_ }, [ Integer ] 1 { _A_ 1 _U_ 1 _N_ _S_ "S" _N_ _N_ } #-}
minimum :: Ord a => [a] -> a
- {-# GHC_PRAGMA _A_ 1 _U_ 11 _N_ _N_ _N_ _N_ #-}
+ {-# GHC_PRAGMA _A_ 1 _U_ 11 _N_ _N_ _N_ _SPECIALISE_ [ Double ] 1 { _A_ 1 _U_ 1 _N_ _S_ "S" _N_ _N_ }, [ Int ] 1 { _A_ 1 _U_ 1 _N_ _S_ "S" _N_ _N_ }, [ Integer ] 1 { _A_ 1 _U_ 1 _N_ _S_ "S" _N_ _N_ } #-}
notElem :: Eq a => a -> [a] -> Bool
- {-# GHC_PRAGMA _A_ 3 _U_ 121 _N_ _S_ "LLS" _F_ _ALWAYS_ _/\_ u0 -> \ (u1 :: {{Eq u0}}) (u2 :: u0) (u3 :: [u0]) -> let {(u6 :: u0 -> u0 -> Bool) = case u1 of { _ALG_ _TUP_2 (u4 :: u0 -> u0 -> Bool) (u5 :: u0 -> u0 -> Bool) -> u5; _NO_DEFLT_ }} in let {(u8 :: u0 -> Bool) = \ (u7 :: u0) -> _APP_ u6 [ u2, u7 ]} in _APP_ _TYAPP_ _ORIG_ PreludeList all { u0 } [ u8, u3 ] _SPECIALISE_ [ Char ] 1 { _A_ 2 _U_ 21 _N_ _S_ "LS" _F_ _ALWAYS_ \ (u0 :: Char) (u1 :: [Char]) -> let {(u5 :: Char -> Bool) = \ (u2 :: Char) -> case u0 of { _ALG_ C# (u3 :: Char#) -> case u2 of { _ALG_ C# (u4 :: Char#) -> _#_ neChar# [] [u3, u4]; _NO_DEFLT_ }; _NO_DEFLT_ }} in _APP_ _TYAPP_ _ORIG_ PreludeList all { Char } [ u5, u1 ] _N_ }, [ Int ] 1 { _A_ 2 _U_ 21 _N_ _S_ "LS" _F_ _ALWAYS_ \ (u0 :: Int) (u1 :: [Int]) -> let {(u5 :: Int -> Bool) = \ (u2 :: Int) -> case u0 of { _ALG_ I# (u3 :: Int#) -> case u2 of { _ALG_ I# (u4 :: Int#) -> _#_ neInt# [] [u3, u4]; _NO_DEFLT_ }; _NO_DEFLT_ }} in _APP_ _TYAPP_ _ORIG_ PreludeList all { Int } [ u5, u1 ] _N_ }, [ [Char] ] 1 { _A_ 2 _U_ 21 _N_ _S_ "LS" _F_ _ALWAYS_ \ (u0 :: [Char]) (u1 :: [[Char]]) -> let {(u3 :: [Char] -> Bool) = \ (u2 :: [Char]) -> _APP_ _CONSTM_ Eq (/=) ([Char]) [ u0, u2 ]} in _APP_ _TYAPP_ _ORIG_ PreludeList all { [Char] } [ u3, u1 ] _N_ } #-}
+ {-# GHC_PRAGMA _A_ 3 _U_ 121 _N_ _S_ "LLS" _F_ _ALWAYS_ _/\_ u0 -> \ (u1 :: {{Eq u0}}) (u2 :: u0) (u3 :: [u0]) -> let {(u6 :: u0 -> u0 -> Bool) = case u1 of { _ALG_ _TUP_2 (u4 :: u0 -> u0 -> Bool) (u5 :: u0 -> u0 -> Bool) -> u5; _NO_DEFLT_ }} in let {(u8 :: u0 -> Bool) = \ (u7 :: u0) -> _APP_ u6 [ u2, u7 ]} in _APP_ _TYAPP_ _ORIG_ PreludeList all { u0 } [ u8, u3 ] _SPECIALISE_ [ Char ] 1 { _A_ 2 _U_ 21 _N_ _S_ "LS" _F_ _ALWAYS_ \ (u0 :: Char) (u1 :: [Char]) -> let {(u5 :: Char -> Bool) = \ (u2 :: Char) -> case u0 of { _ALG_ C# (u3 :: Char#) -> case u2 of { _ALG_ C# (u4 :: Char#) -> _#_ neChar# [] [u3, u4]; _NO_DEFLT_ }; _NO_DEFLT_ }} in _APP_ _TYAPP_ _ORIG_ PreludeList all { Char } [ u5, u1 ] _N_ }, [ Int ] 1 { _A_ 2 _U_ 21 _N_ _S_ "LS" _F_ _ALWAYS_ \ (u0 :: Int) (u1 :: [Int]) -> let {(u5 :: Int -> Bool) = \ (u2 :: Int) -> case u0 of { _ALG_ I# (u3 :: Int#) -> case u2 of { _ALG_ I# (u4 :: Int#) -> _#_ neInt# [] [u3, u4]; _NO_DEFLT_ }; _NO_DEFLT_ }} in _APP_ _TYAPP_ _ORIG_ PreludeList all { Int } [ u5, u1 ] _N_ }, [ Integer ] 1 { _A_ 2 _U_ 21 _N_ _S_ "LS" _F_ _ALWAYS_ \ (u0 :: Integer) (u1 :: [Integer]) -> let {(ua :: Integer -> Bool) = \ (u2 :: Integer) -> case u0 of { _ALG_ J# (u3 :: Int#) (u4 :: Int#) (u5 :: ByteArray#) -> case u2 of { _ALG_ J# (u6 :: Int#) (u7 :: Int#) (u8 :: ByteArray#) -> case _#_ cmpInteger# [] [u3, u4, u5, u6, u7, u8] of { _PRIM_ 0# -> _!_ False [] []; (u9 :: Int#) -> _!_ True [] [] }; _NO_DEFLT_ }; _NO_DEFLT_ }} in _APP_ _TYAPP_ _ORIG_ PreludeList all { Integer } [ ua, u1 ] _N_ }, [ [Char] ] 1 { _A_ 2 _U_ 21 _N_ _S_ "LS" _F_ _ALWAYS_ \ (u0 :: [Char]) (u1 :: [[Char]]) -> let {(u3 :: [Char] -> Bool) = \ (u2 :: [Char]) -> _APP_ _CONSTM_ Eq (/=) ([Char]) [ u0, u2 ]} in _APP_ _TYAPP_ _ORIG_ PreludeList all { [Char] } [ u3, u1 ] _N_ }, [ (Int, Int) ] 1 { _A_ 2 _U_ 21 _N_ _S_ "LS" _F_ _ALWAYS_ \ (u0 :: (Int, Int)) (u1 :: [(Int, Int)]) -> let {(ub :: (Int, Int) -> Bool) = \ (u2 :: (Int, Int)) -> case u0 of { _ALG_ _TUP_2 (u3 :: Int) (u4 :: Int) -> case u3 of { _ALG_ I# (u5 :: Int#) -> case u2 of { _ALG_ _TUP_2 (u6 :: Int) (u7 :: Int) -> case u6 of { _ALG_ I# (u8 :: Int#) -> case _#_ neInt# [] [u5, u8] of { _ALG_ True -> _!_ True [] []; False -> case u4 of { _ALG_ I# (u9 :: Int#) -> case u7 of { _ALG_ I# (ua :: Int#) -> _#_ neInt# [] [u9, ua]; _NO_DEFLT_ }; _NO_DEFLT_ }; _NO_DEFLT_ }; _NO_DEFLT_ }; _NO_DEFLT_ }; _NO_DEFLT_ }; _NO_DEFLT_ }} in _APP_ _TYAPP_ _ORIG_ PreludeList all { (Int, Int) } [ ub, u1 ] _N_ } #-}
nub :: Eq a => [a] -> [a]
- {-# GHC_PRAGMA _A_ 2 _U_ 11 _N_ _S_ "LS" _N_ _N_ #-}
+ {-# GHC_PRAGMA _A_ 2 _U_ 11 _N_ _S_ "LS" _N_ _SPECIALISE_ [ Int ] 1 { _A_ 1 _U_ 1 _N_ _S_ "S" _N_ _N_ }, [ [Char] ] 1 { _A_ 1 _U_ 1 _N_ _S_ "S" _N_ _N_ }, [ [Int] ] 1 { _A_ 1 _U_ 1 _N_ _S_ "S" _N_ _N_ } #-}
null :: [a] -> Bool
{-# GHC_PRAGMA _A_ 1 _U_ 1 _N_ _S_ "S" _F_ _ALWAYS_ _/\_ u0 -> \ (u1 :: [u0]) -> let {(u2 :: Bool) = _!_ True [] []} in let {(u5 :: u0 -> Bool -> Bool) = \ (u3 :: u0) (u4 :: Bool) -> _!_ False [] []} in _APP_ _TYAPP_ _TYAPP_ foldr { u0 } { Bool } [ u5, u2, u1 ] _N_ #-}
or :: [Bool] -> Bool
partition :: (a -> Bool) -> [a] -> ([a], [a])
{-# GHC_PRAGMA _A_ 2 _U_ 21 _N_ _S_ "LS" _F_ _ALWAYS_ _/\_ u0 -> \ (u1 :: u0 -> Bool) (u2 :: [u0]) -> let {(u9 :: u0 -> ([u0], [u0]) -> ([u0], [u0])) = \ (u3 :: u0) (u4 :: ([u0], [u0])) -> case u4 of { _ALG_ _TUP_2 (u5 :: [u0]) (u6 :: [u0]) -> case _APP_ u1 [ u3 ] of { _ALG_ True -> let {(u7 :: [u0]) = _!_ (:) [u0] [u3, u5]} in _!_ _TUP_2 [[u0], [u0]] [u7, u6]; False -> let {(u8 :: [u0]) = _!_ (:) [u0] [u3, u6]} in _!_ _TUP_2 [[u0], [u0]] [u5, u8]; _NO_DEFLT_ }; _NO_DEFLT_ }} in let {(ua :: [u0]) = _!_ _NIL_ [u0] []} in let {(ub :: ([u0], [u0])) = _!_ _TUP_2 [[u0], [u0]] [ua, ua]} in _APP_ _TYAPP_ _TYAPP_ foldr { u0 } { ([u0], [u0]) } [ u9, ub, u2 ] _N_ #-}
product :: Num a => [a] -> a
- {-# GHC_PRAGMA _A_ 1 _U_ 22 _N_ _N_ _F_ _ALWAYS_ _/\_ u0 -> \ (u1 :: {{Num u0}}) -> let {(uc :: u0 -> u0 -> u0) = case u1 of { _ALG_ _TUP_10 (u2 :: {{Eq u0}}) (u3 :: {{Text u0}}) (u4 :: u0 -> u0 -> u0) (u5 :: u0 -> u0 -> u0) (u6 :: u0 -> u0 -> u0) (u7 :: u0 -> u0) (u8 :: u0 -> u0) (u9 :: u0 -> u0) (ua :: Integer -> u0) (ub :: Int -> u0) -> u6; _NO_DEFLT_ }} in let {(uo :: u0) = let {(ud :: Int) = _!_ I# [] [1#]} in case u1 of { _ALG_ _TUP_10 (ue :: {{Eq u0}}) (uf :: {{Text u0}}) (ug :: u0 -> u0 -> u0) (uh :: u0 -> u0 -> u0) (ui :: u0 -> u0 -> u0) (uj :: u0 -> u0) (uk :: u0 -> u0) (ul :: u0 -> u0) (um :: Integer -> u0) (un :: Int -> u0) -> _APP_ un [ ud ]; _NO_DEFLT_ }} in \ (up :: [u0]) -> _APP_ _TYAPP_ _TYAPP_ foldl { u0 } { u0 } [ uc, uo, up ] _SPECIALISE_ [ Double ] 1 { _A_ 1 _U_ 1 _N_ _S_ "S" _F_ _ALWAYS_ \ (u0 :: [Double]) -> let {(u1 :: Double) = _!_ D# [] [1.0000000000000000##]} in _APP_ _TYAPP_ _TYAPP_ foldl { Double } { Double } [ _CONSTM_ Num (*) (Double), u1, u0 ] _N_ }, [ Int ] 1 { _A_ 1 _U_ 1 _N_ _S_ "S" _F_ _ALWAYS_ \ (u0 :: [Int]) -> let {(u1 :: Int) = _!_ I# [] [1#]} in _APP_ _TYAPP_ _TYAPP_ foldl { Int } { Int } [ _CONSTM_ Num (*) (Int), u1, u0 ] _N_ }, [ Integer ] 1 { _A_ 1 _U_ 1 _N_ _S_ "S" _F_ _ALWAYS_ \ (u0 :: [Integer]) -> let {(u1 :: Integer) = _#_ int2Integer# [] [1#]} in _APP_ _TYAPP_ _TYAPP_ foldl { Integer } { Integer } [ _CONSTM_ Num (*) (Integer), u1, u0 ] _N_ } #-}
+ {-# GHC_PRAGMA _A_ 1 _U_ 22 _N_ _N_ _F_ _ALWAYS_ _/\_ u0 -> \ (u1 :: {{Num u0}}) -> let {(uc :: u0 -> u0 -> u0) = case u1 of { _ALG_ _TUP_10 (u2 :: {{Eq u0}}) (u3 :: {{Text u0}}) (u4 :: u0 -> u0 -> u0) (u5 :: u0 -> u0 -> u0) (u6 :: u0 -> u0 -> u0) (u7 :: u0 -> u0) (u8 :: u0 -> u0) (u9 :: u0 -> u0) (ua :: Integer -> u0) (ub :: Int -> u0) -> u6; _NO_DEFLT_ }} in let {(uo :: u0) = let {(ud :: Int) = _!_ I# [] [1#]} in case u1 of { _ALG_ _TUP_10 (ue :: {{Eq u0}}) (uf :: {{Text u0}}) (ug :: u0 -> u0 -> u0) (uh :: u0 -> u0 -> u0) (ui :: u0 -> u0 -> u0) (uj :: u0 -> u0) (uk :: u0 -> u0) (ul :: u0 -> u0) (um :: Integer -> u0) (un :: Int -> u0) -> _APP_ un [ ud ]; _NO_DEFLT_ }} in \ (up :: [u0]) -> _APP_ _TYAPP_ _TYAPP_ foldl { u0 } { u0 } [ uc, uo, up ] _SPECIALISE_ [ Double ] 1 { _A_ 1 _U_ 1 _N_ _S_ "S" _F_ _ALWAYS_ \ (u0 :: [Double]) -> let {(u1 :: Double) = _!_ D# [] [1.0000000000000000##]} in _APP_ _TYAPP_ _TYAPP_ foldl { Double } { Double } [ _CONSTM_ Num (*) (Double), u1, u0 ] _N_ }, [ Int ] 1 { _A_ 1 _U_ 1 _N_ _S_ "S" _F_ _ALWAYS_ \ (u0 :: [Int]) -> let {(u1 :: Int) = _!_ I# [] [1#]} in _APP_ _TYAPP_ _TYAPP_ foldl { Int } { Int } [ _CONSTM_ Num (*) (Int), u1, u0 ] _N_ }, [ Integer ] 1 { _A_ 1 _U_ 1 _N_ _S_ "S" _F_ _ALWAYS_ \ (u0 :: [Integer]) -> let {(u1 :: Integer) = _#_ int2Integer# [] [1#]} in _APP_ _TYAPP_ _TYAPP_ foldl { Integer } { Integer } [ _CONSTM_ Num (*) (Integer), u1, u0 ] _N_ }, [ (Complex Double) ] 1 { _A_ 1 _U_ 1 _N_ _S_ "S" _F_ _ALWAYS_ let {(u6 :: Complex Double -> Complex Double -> Complex Double) = \ (u0 :: Complex Double) (u1 :: Complex Double) -> case u0 of { _ALG_ (:+) (u2 :: Double) (u3 :: Double) -> case u1 of { _ALG_ (:+) (u4 :: Double) (u5 :: Double) -> _APP_ _WRKR_ _CONSTM_ Num (*) (Complex Double) [ u2, u3, u4, u5 ]; _NO_DEFLT_ }; _NO_DEFLT_ }} in let {(u8 :: Complex Double) = let {(u7 :: Int) = _!_ I# [] [1#]} in _APP_ _CONSTM_ Num fromInt (Complex Double) [ u7 ]} in \ (u9 :: [Complex Double]) -> _APP_ _TYAPP_ _TYAPP_ foldl { (Complex Double) } { (Complex Double) } [ u6, u8, u9 ] _N_ } #-}
products :: Num a => [a] -> [a]
- {-# GHC_PRAGMA _A_ 1 _U_ 21 _N_ _N_ _N_ _N_ #-}
+ {-# GHC_PRAGMA _A_ 1 _U_ 21 _N_ _N_ _N_ _SPECIALISE_ [ Double ] 1 { _A_ 1 _U_ 1 _N_ _N_ _N_ _N_ }, [ Int ] 1 { _A_ 1 _U_ 1 _N_ _N_ _N_ _N_ }, [ Integer ] 1 { _A_ 1 _U_ 1 _N_ _N_ _F_ _IF_ARGS_ 0 1 X 4 \ (u0 :: [Integer]) -> _APP_ _TYAPP_ _TYAPP_ _ORIG_ PreludeList scanl { Integer } { Integer } [ _CONSTM_ Num (*) (Integer), _SPEC_ _ORIG_ PreludeCore __i1 [ (Integer) ], u0 ] _N_ }, [ (Complex Double) ] 1 { _A_ 1 _U_ 1 _N_ _N_ _N_ _N_ } #-}
repeat :: a -> [a]
{-# GHC_PRAGMA _A_ 1 _U_ 2 _N_ _N_ _F_ _ALWAYS_ _/\_ u0 -> \ (u1 :: u0) -> let {(u6 :: _forall_ a$z1 =>(u0 -> a$z1 -> a$z1) -> a$z1 -> a$z1) = _/\_ u2 -> \ (u3 :: u0 -> u2 -> u2) (u4 :: u2) -> _LETREC_ {(u5 :: u2) = _APP_ u3 [ u1, u5 ]} in u5} in _APP_ _TYAPP_ _build { u0 } [ u6 ] _N_ #-}
reverse :: [a] -> [a]
sum :: Num a => [a] -> a
{-# GHC_PRAGMA _A_ 1 _U_ 22 _N_ _N_ _F_ _ALWAYS_ _/\_ u0 -> \ (u1 :: {{Num u0}}) -> let {(uc :: u0 -> u0 -> u0) = case u1 of { _ALG_ _TUP_10 (u2 :: {{Eq u0}}) (u3 :: {{Text u0}}) (u4 :: u0 -> u0 -> u0) (u5 :: u0 -> u0 -> u0) (u6 :: u0 -> u0 -> u0) (u7 :: u0 -> u0) (u8 :: u0 -> u0) (u9 :: u0 -> u0) (ua :: Integer -> u0) (ub :: Int -> u0) -> u4; _NO_DEFLT_ }} in let {(uo :: u0) = let {(ud :: Int) = _!_ I# [] [0#]} in case u1 of { _ALG_ _TUP_10 (ue :: {{Eq u0}}) (uf :: {{Text u0}}) (ug :: u0 -> u0 -> u0) (uh :: u0 -> u0 -> u0) (ui :: u0 -> u0 -> u0) (uj :: u0 -> u0) (uk :: u0 -> u0) (ul :: u0 -> u0) (um :: Integer -> u0) (un :: Int -> u0) -> _APP_ un [ ud ]; _NO_DEFLT_ }} in \ (up :: [u0]) -> _APP_ _TYAPP_ _TYAPP_ foldl { u0 } { u0 } [ uc, uo, up ] _SPECIALISE_ [ Double ] 1 { _A_ 1 _U_ 1 _N_ _S_ "S" _F_ _ALWAYS_ \ (u0 :: [Double]) -> let {(u1 :: Double) = _!_ D# [] [0.0000000000000000##]} in _APP_ _TYAPP_ _TYAPP_ foldl { Double } { Double } [ _CONSTM_ Num (+) (Double), u1, u0 ] _N_ }, [ Int ] 1 { _A_ 1 _U_ 1 _N_ _S_ "S" _F_ _ALWAYS_ \ (u0 :: [Int]) -> let {(u1 :: Int) = _!_ I# [] [0#]} in _APP_ _TYAPP_ _TYAPP_ foldl { Int } { Int } [ _CONSTM_ Num (+) (Int), u1, u0 ] _N_ }, [ Integer ] 1 { _A_ 1 _U_ 1 _N_ _S_ "S" _F_ _ALWAYS_ \ (u0 :: [Integer]) -> let {(u1 :: Integer) = _#_ int2Integer# [] [0#]} in _APP_ _TYAPP_ _TYAPP_ foldl { Integer } { Integer } [ _CONSTM_ Num (+) (Integer), u1, u0 ] _N_ }, [ (Complex Double) ] 1 { _A_ 1 _U_ 1 _N_ _S_ "S" _F_ _ALWAYS_ let {(u6 :: Complex Double -> Complex Double -> Complex Double) = \ (u0 :: Complex Double) (u1 :: Complex Double) -> case u0 of { _ALG_ (:+) (u2 :: Double) (u3 :: Double) -> case u1 of { _ALG_ (:+) (u4 :: Double) (u5 :: Double) -> _APP_ _WRKR_ _CONSTM_ Num (+) (Complex Double) [ u2, u3, u4, u5 ]; _NO_DEFLT_ }; _NO_DEFLT_ }} in let {(u8 :: Complex Double) = let {(u7 :: Int) = _!_ I# [] [0#]} in _APP_ _CONSTM_ Num fromInt (Complex Double) [ u7 ]} in \ (u9 :: [Complex Double]) -> _APP_ _TYAPP_ _TYAPP_ foldl { (Complex Double) } { (Complex Double) } [ u6, u8, u9 ] _N_ } #-}
sums :: Num a => [a] -> [a]
- {-# GHC_PRAGMA _A_ 1 _U_ 21 _N_ _N_ _N_ _N_ #-}
+ {-# GHC_PRAGMA _A_ 1 _U_ 21 _N_ _N_ _N_ _SPECIALISE_ [ Double ] 1 { _A_ 1 _U_ 1 _N_ _N_ _N_ _N_ }, [ Int ] 1 { _A_ 1 _U_ 1 _N_ _N_ _N_ _N_ }, [ Integer ] 1 { _A_ 1 _U_ 1 _N_ _N_ _F_ _IF_ARGS_ 0 1 X 4 \ (u0 :: [Integer]) -> _APP_ _TYAPP_ _TYAPP_ _ORIG_ PreludeList scanl { Integer } { Integer } [ _CONSTM_ Num (+) (Integer), _SPEC_ _ORIG_ PreludeCore __i0 [ (Integer) ], u0 ] _N_ }, [ (Complex Double) ] 1 { _A_ 1 _U_ 1 _N_ _N_ _N_ _N_ } #-}
tail :: [a] -> [a]
{-# GHC_PRAGMA _A_ 1 _U_ 1 _N_ _S_ "S" _F_ _IF_ARGS_ 1 1 C 5 _/\_ u0 -> \ (u1 :: [u0]) -> case u1 of { _ALG_ (:) (u2 :: u0) (u3 :: [u0]) -> u3; _NIL_ -> _APP_ _TYAPP_ error { [u0] } [ _NOREP_S_ "tail{PreludeList}: tail []\n" ]; _NO_DEFLT_ } _N_ #-}
take :: Integral a => a -> [b] -> [b]
- {-# GHC_PRAGMA _A_ 3 _U_ 121 _N_ _S_ "U(AAAAAAAAAAAS)LL" {_A_ 3 _U_ 121 _N_ _N_ _N_ _N_} _F_ _IF_ARGS_ 2 3 CXX 7 _/\_ u0 u1 -> \ (u2 :: {{Integral u0}}) (u3 :: u0) (u4 :: [u1]) -> let {(uh :: Int) = case u2 of { _ALG_ _TUP_12 (u5 :: {{Real u0}}) (u6 :: {{Ix u0}}) (u7 :: u0 -> u0 -> u0) (u8 :: u0 -> u0 -> u0) (u9 :: u0 -> u0 -> u0) (ua :: u0 -> u0 -> u0) (ub :: u0 -> u0 -> (u0, u0)) (uc :: u0 -> u0 -> (u0, u0)) (ud :: u0 -> Bool) (ue :: u0 -> Bool) (uf :: u0 -> Integer) (ug :: u0 -> Int) -> _APP_ ug [ u3 ]; _NO_DEFLT_ }} in _APP_ _TYAPP_ _SPEC_ _ORIG_ PreludeList take [ (Int), _N_ ] { u1 } [ uh, u4 ] _SPECIALISE_ [ Int, _N_ ] 1 { _A_ 2 _U_ 11 _N_ _S_ "U(P)L" {_A_ 2 _U_ 21 _N_ _N_ _N_ _N_} _N_ _N_ }, [ Integer, _N_ ] 1 { _A_ 2 _U_ 11 _N_ _S_ "U(PPP)L" {_A_ 4 _U_ 2221 _N_ _N_ _F_ _IF_ARGS_ 1 4 XXXX 4 _/\_ u0 -> \ (u1 :: Int#) (u2 :: Int#) (u3 :: ByteArray#) (u4 :: [u0]) -> case _#_ integer2Int# [] [u1, u2, u3] of { _PRIM_ (u5 :: Int#) -> _APP_ _TYAPP_ _WRKR_ _SPEC_ _ORIG_ PreludeList take [ (Int), _N_ ] { u0 } [ u5, u4 ] } _N_} _F_ _ALWAYS_ _/\_ u0 -> \ (u1 :: Integer) (u2 :: [u0]) -> case u1 of { _ALG_ J# (u3 :: Int#) (u4 :: Int#) (u5 :: ByteArray#) -> case _#_ integer2Int# [] [u3, u4, u5] of { _PRIM_ (u6 :: Int#) -> _APP_ _TYAPP_ _WRKR_ _SPEC_ _ORIG_ PreludeList take [ (Int), _N_ ] { u0 } [ u6, u2 ] }; _NO_DEFLT_ } _N_ } #-}
+ {-# GHC_PRAGMA _A_ 1 _U_ 122 _N_ _S_ "U(LU(U(ASSAAAAA)AAA)AAAALAAAAL)" {_A_ 5 _U_ 2121222 _N_ _N_ _N_ _N_} _N_ _SPECIALISE_ [ Int, _N_ ] 1 { _A_ 2 _U_ 11 _N_ _S_ "U(P)L" {_A_ 2 _U_ 21 _N_ _N_ _N_ _N_} _N_ _N_ }, [ Integer, _N_ ] 1 { _A_ 1 _U_ 12 _N_ _S_ "U(PPP)" {_A_ 3 _U_ 2222 _N_ _N_ _N_ _N_} _N_ _N_ } #-}
takeWhile :: (a -> Bool) -> [a] -> [a]
{-# GHC_PRAGMA _A_ 2 _U_ 21 _N_ _S_ "LS" _F_ _ALWAYS_ _/\_ u0 -> \ (u1 :: u0 -> Bool) (u2 :: [u0]) -> let {(u9 :: _forall_ a$z1 =>(u0 -> a$z1 -> a$z1) -> a$z1 -> a$z1) = _/\_ u3 -> \ (u4 :: u0 -> u3 -> u3) (u5 :: u3) -> let {(u8 :: u0 -> u3 -> u3) = \ (u6 :: u0) (u7 :: u3) -> case _APP_ u1 [ u6 ] of { _ALG_ True -> _APP_ u4 [ u6, u7 ]; False -> u5; _NO_DEFLT_ }} in _APP_ _TYAPP_ _TYAPP_ foldr { u0 } { u3 } [ u8, u5, u2 ]} in _APP_ _TYAPP_ _build { u0 } [ u9 ] _N_ #-}
transpose :: [[a]] -> [[a]]
lex :: [Char] -> [([Char], [Char])]
{-# GHC_PRAGMA _A_ 1 _U_ 2 _N_ _S_ "S" _N_ _N_ #-}
read :: Text a => [Char] -> a
- {-# GHC_PRAGMA _A_ 1 _U_ 12 _N_ _S_ "U(SAAA)" {_A_ 1 _U_ 12 _N_ _N_ _N_ _N_} _N_ _SPECIALISE_ [ Double ] 1 { _A_ 1 _U_ 2 _N_ _N_ _N_ _N_ }, [ Float ] 1 { _A_ 1 _U_ 2 _N_ _N_ _N_ _N_ }, [ Int ] 1 { _A_ 1 _U_ 2 _N_ _N_ _N_ _N_ }, [ Integer ] 1 { _A_ 1 _U_ 2 _N_ _N_ _N_ _N_ } #-}
+ {-# GHC_PRAGMA _A_ 1 _U_ 12 _N_ _S_ "U(SAAA)" {_A_ 1 _U_ 12 _N_ _N_ _N_ _N_} _N_ _SPECIALISE_ [ Bool ] 1 { _A_ 1 _U_ 2 _N_ _N_ _N_ _N_ }, [ Char ] 1 { _A_ 1 _U_ 2 _N_ _N_ _N_ _N_ }, [ Double ] 1 { _A_ 1 _U_ 2 _N_ _N_ _N_ _N_ }, [ Int ] 1 { _A_ 1 _U_ 2 _N_ _N_ _N_ _N_ }, [ Integer ] 1 { _A_ 1 _U_ 2 _N_ _N_ _N_ _N_ }, [ [Bool] ] 1 { _A_ 1 _U_ 2 _N_ _N_ _N_ _N_ }, [ [Char] ] 1 { _A_ 1 _U_ 2 _N_ _N_ _N_ _N_ }, [ [Double] ] 1 { _A_ 1 _U_ 2 _N_ _N_ _N_ _N_ }, [ [Float] ] 1 { _A_ 1 _U_ 2 _N_ _N_ _N_ _N_ }, [ [Int] ] 1 { _A_ 1 _U_ 2 _N_ _N_ _N_ _N_ }, [ [Integer] ] 1 { _A_ 1 _U_ 2 _N_ _N_ _N_ _N_ }, [ [[Char]] ] 1 { _A_ 1 _U_ 2 _N_ _N_ _N_ _N_ }, [ [[Int]] ] 1 { _A_ 1 _U_ 2 _N_ _N_ _N_ _N_ }, [ [Complex Double] ] 1 { _A_ 1 _U_ 2 _N_ _N_ _N_ _N_ }, [ (Ratio Integer) ] 1 { _A_ 1 _U_ 2 _N_ _N_ _N_ _N_ }, [ (Array Int Double) ] 1 { _A_ 1 _U_ 2 _N_ _N_ _N_ _N_ }, [ (Array (Int, Int) Double) ] 1 { _A_ 1 _U_ 2 _N_ _N_ _N_ _N_ }, [ _PackedString ] 1 { _A_ 1 _U_ 2 _N_ _S_ _!_ _N_ _N_ }, [ (Complex Double) ] 1 { _A_ 1 _U_ 2 _N_ _N_ _N_ _N_ }, [ () ] 1 { _A_ 1 _U_ 2 _N_ _N_ _N_ _N_ }, [ (Int, Int) ] 1 { _A_ 1 _U_ 2 _N_ _N_ _N_ _N_ }, [ (Integer, Integer) ] 1 { _A_ 1 _U_ 2 _N_ _N_ _N_ _N_ }, [ (Int, Int, Int) ] 1 { _A_ 1 _U_ 2 _N_ _N_ _N_ _N_ } #-}
readDec :: Integral a => [Char] -> [(a, [Char])]
- {-# GHC_PRAGMA _A_ 1 _U_ 22 _N_ _N_ _N_ _SPECIALISE_ [ Int ] 1 { _A_ 1 _U_ 2 _N_ _N_ _N_ _N_ }, [ Integer ] 1 { _A_ 1 _U_ 2 _N_ _S_ "S" _N_ _N_ } #-}
+ {-# GHC_PRAGMA _A_ 1 _U_ 22 _N_ _N_ _N_ _SPECIALISE_ [ Int ] 1 { _A_ 1 _U_ 2 _N_ _N_ _N_ _N_ }, [ Integer ] 1 { _A_ 1 _U_ 2 _N_ _N_ _N_ _N_ } #-}
readFloat :: RealFloat a => [Char] -> [(a, [Char])]
- {-# GHC_PRAGMA _A_ 2 _U_ 12 _N_ _S_ "LS" _N_ _SPECIALISE_ [ Double ] 1 { _A_ 1 _U_ 2 _N_ _S_ "S" _N_ _N_ }, [ Float ] 1 { _A_ 1 _U_ 2 _N_ _S_ "S" _N_ _N_ } #-}
+ {-# GHC_PRAGMA _A_ 2 _U_ 12 _N_ _S_ "LS" _N_ _SPECIALISE_ [ Double ] 1 { _A_ 1 _U_ 2 _N_ _S_ "S" _N_ _N_ } #-}
readLitChar :: [Char] -> [(Char, [Char])]
{-# GHC_PRAGMA _A_ 0 _U_ 1 _N_ _N_ _N_ _N_ #-}
readParen :: Bool -> ([Char] -> [(a, [Char])]) -> [Char] -> [(a, [Char])]
readSigned :: Real a => ([Char] -> [(a, [Char])]) -> [Char] -> [(a, [Char])]
{-# GHC_PRAGMA _A_ 2 _U_ 122 _N_ _N_ _N_ _SPECIALISE_ [ Double ] 1 { _A_ 1 _U_ 22 _N_ _N_ _N_ _N_ }, [ Int ] 1 { _A_ 1 _U_ 22 _N_ _N_ _N_ _N_ }, [ Integer ] 1 { _A_ 1 _U_ 22 _N_ _N_ _N_ _N_ } #-}
reads :: Text a => [Char] -> [(a, [Char])]
- {-# GHC_PRAGMA _A_ 1 _U_ 12 _N_ _S_ "U(SAAA)" {_A_ 1 _U_ 12 _N_ _N_ _N_ _N_} _N_ _SPECIALISE_ [ Double ] 1 { _A_ 1 _U_ 2 _N_ _N_ _N_ _N_ }, [ Float ] 1 { _A_ 1 _U_ 2 _N_ _N_ _N_ _N_ }, [ Int ] 1 { _A_ 1 _U_ 2 _N_ _N_ _N_ _N_ }, [ Integer ] 1 { _A_ 1 _U_ 2 _N_ _N_ _N_ _N_ } #-}
+ {-# GHC_PRAGMA _A_ 1 _U_ 12 _N_ _S_ "U(SAAA)" {_A_ 1 _U_ 12 _N_ _N_ _N_ _N_} _N_ _SPECIALISE_ [ Bool ] 1 { _A_ 1 _U_ 2 _N_ _N_ _N_ _N_ }, [ Char ] 1 { _A_ 0 _U_ 2 _N_ _N_ _N_ _N_ }, [ Double ] 1 { _A_ 1 _U_ 2 _N_ _N_ _N_ _N_ }, [ Int ] 1 { _A_ 1 _U_ 2 _N_ _N_ _N_ _N_ }, [ Integer ] 1 { _A_ 1 _U_ 2 _N_ _N_ _N_ _N_ }, [ [Bool] ] 1 { _A_ 0 _U_ 2 _N_ _N_ _F_ _IF_ARGS_ 0 0 X 1 _CONSTM_ Text readList (Bool) _N_ }, [ [Char] ] 1 { _A_ 0 _U_ 2 _N_ _N_ _F_ _IF_ARGS_ 0 0 X 1 _CONSTM_ Text readList (Char) _N_ }, [ [Double] ] 1 { _A_ 0 _U_ 2 _N_ _N_ _F_ _IF_ARGS_ 0 0 X 1 _CONSTM_ Text readList (Double) _N_ }, [ [Float] ] 1 { _A_ 0 _U_ 2 _N_ _N_ _N_ _N_ }, [ [Int] ] 1 { _A_ 0 _U_ 2 _N_ _N_ _F_ _IF_ARGS_ 0 0 X 1 _CONSTM_ Text readList (Int) _N_ }, [ [Integer] ] 1 { _A_ 0 _U_ 2 _N_ _N_ _F_ _IF_ARGS_ 0 0 X 1 _CONSTM_ Text readList (Integer) _N_ }, [ [[Char]] ] 1 { _A_ 0 _U_ 2 _N_ _N_ _F_ _IF_ARGS_ 0 0 X 1 _CONSTM_ Text readList ([Char]) _N_ }, [ [[Int]] ] 1 { _A_ 0 _U_ 2 _N_ _N_ _F_ _IF_ARGS_ 0 0 X 1 _CONSTM_ Text readList ([Int]) _N_ }, [ [Complex Double] ] 1 { _A_ 0 _U_ 2 _N_ _N_ _F_ _IF_ARGS_ 0 0 X 1 _CONSTM_ Text readList (Complex Double) _N_ }, [ (Ratio Integer) ] 1 { _A_ 0 _U_ 2 _N_ _N_ _N_ _N_ }, [ (Array Int Double) ] 1 { _A_ 0 _U_ 2 _N_ _N_ _N_ _N_ }, [ (Array (Int, Int) Double) ] 1 { _A_ 0 _U_ 2 _N_ _N_ _N_ _N_ }, [ _PackedString ] 1 { _A_ 1 _U_ 2 _N_ _S_ _!_ _N_ _N_ }, [ (Complex Double) ] 1 { _A_ 0 _U_ 2 _N_ _N_ _N_ _N_ }, [ () ] 1 { _A_ 0 _U_ 2 _N_ _N_ _N_ _N_ }, [ (Int, Int) ] 1 { _A_ 0 _U_ 2 _N_ _N_ _N_ _N_ }, [ (Integer, Integer) ] 1 { _A_ 0 _U_ 2 _N_ _N_ _N_ _N_ }, [ (Int, Int, Int) ] 1 { _A_ 0 _U_ 2 _N_ _N_ _N_ _N_ } #-}
show :: Text a => a -> [Char]
- {-# GHC_PRAGMA _A_ 1 _U_ 12 _N_ _S_ "U(ASAA)" {_A_ 1 _U_ 12 _N_ _N_ _N_ _N_} _N_ _SPECIALISE_ [ Char ] 1 { _A_ 1 _U_ 1 _N_ _S_ "U(P)" {_A_ 1 _U_ 2 _N_ _N_ _N_ _N_} _N_ _N_ }, [ Double ] 1 { _A_ 1 _U_ 1 _N_ _S_ "U(P)" {_A_ 1 _U_ 2 _N_ _N_ _N_ _N_} _N_ _N_ }, [ Float ] 1 { _A_ 1 _U_ 2 _N_ _N_ _N_ _N_ }, [ Int ] 1 { _A_ 1 _U_ 1 _N_ _S_ "U(P)" {_A_ 1 _U_ 2 _N_ _N_ _N_ _N_} _N_ _N_ }, [ Integer ] 1 { _A_ 1 _U_ 1 _N_ _S_ "U(PPP)" {_A_ 3 _U_ 222 _N_ _N_ _N_ _N_} _N_ _N_ }, [ [Char] ] 1 { _A_ 1 _U_ 2 _N_ _N_ _N_ _N_ }, [ _PackedString ] 1 { _A_ 1 _U_ 1 _N_ _N_ _N_ _N_ }, [ (Int, Int) ] 1 { _A_ 1 _U_ 1 _N_ _S_ "U(LL)" {_A_ 2 _U_ 22 _N_ _N_ _N_ _N_} _N_ _N_ }, [ (Integer, Integer) ] 1 { _A_ 1 _U_ 1 _N_ _S_ "U(LL)" {_A_ 2 _U_ 22 _N_ _N_ _N_ _N_} _N_ _N_ } #-}
+ {-# GHC_PRAGMA _A_ 1 _U_ 12 _N_ _S_ "U(ASAA)" {_A_ 1 _U_ 12 _N_ _N_ _N_ _N_} _N_ _SPECIALISE_ [ Bool ] 1 { _A_ 1 _U_ 2 _N_ _S_ "E" _N_ _N_ }, [ Char ] 1 { _A_ 1 _U_ 1 _N_ _S_ "U(P)" {_A_ 1 _U_ 2 _N_ _N_ _N_ _N_} _N_ _N_ }, [ Double ] 1 { _A_ 1 _U_ 1 _N_ _S_ "U(P)" {_A_ 1 _U_ 2 _N_ _N_ _N_ _N_} _N_ _N_ }, [ Int ] 1 { _A_ 1 _U_ 1 _N_ _S_ "U(P)" {_A_ 1 _U_ 2 _N_ _N_ _N_ _N_} _N_ _N_ }, [ Integer ] 1 { _A_ 1 _U_ 1 _N_ _S_ "U(PPP)" {_A_ 3 _U_ 222 _N_ _N_ _N_ _N_} _N_ _N_ }, [ [Bool] ] 1 { _A_ 1 _U_ 1 _N_ _S_ "S" _N_ _N_ }, [ [Char] ] 1 { _A_ 1 _U_ 2 _N_ _N_ _N_ _N_ }, [ [Double] ] 1 { _A_ 1 _U_ 2 _N_ _N_ _N_ _N_ }, [ [Int] ] 1 { _A_ 1 _U_ 2 _N_ _N_ _N_ _N_ }, [ [Integer] ] 1 { _A_ 1 _U_ 2 _N_ _N_ _N_ _N_ }, [ [[Char]] ] 1 { _A_ 1 _U_ 1 _N_ _S_ "S" _N_ _N_ }, [ [[Int]] ] 1 { _A_ 1 _U_ 1 _N_ _S_ "S" _N_ _N_ }, [ [Complex Double] ] 1 { _A_ 1 _U_ 2 _N_ _N_ _N_ _N_ }, [ (Ratio Integer) ] 1 { _A_ 1 _U_ 1 _N_ _S_ "U(LL)" {_A_ 2 _U_ 22 _N_ _N_ _N_ _N_} _N_ _N_ }, [ (Array Int Double) ] 1 { _A_ 1 _U_ 2 _N_ _N_ _N_ _N_ }, [ (Array (Int, Int) Double) ] 1 { _A_ 1 _U_ 2 _N_ _N_ _N_ _N_ }, [ _PackedString ] 1 { _A_ 1 _U_ 1 _N_ _N_ _N_ _N_ }, [ (Complex Double) ] 1 { _A_ 1 _U_ 1 _N_ _S_ "U(LL)" {_A_ 2 _U_ 22 _N_ _N_ _N_ _N_} _N_ _N_ }, [ () ] 1 { _A_ 1 _U_ 1 _N_ _S_ "E" _N_ _N_ }, [ (Int, Int) ] 1 { _A_ 1 _U_ 1 _N_ _S_ "U(LL)" {_A_ 2 _U_ 22 _N_ _N_ _N_ _N_} _N_ _N_ }, [ (Integer, Integer) ] 1 { _A_ 1 _U_ 1 _N_ _S_ "U(LL)" {_A_ 2 _U_ 22 _N_ _N_ _N_ _N_} _N_ _N_ }, [ (Int, Int, Int) ] 1 { _A_ 1 _U_ 1 _N_ _S_ "U(LLL)" {_A_ 3 _U_ 222 _N_ _N_ _N_ _N_} _N_ _N_ } #-}
showChar :: Char -> [Char] -> [Char]
{-# GHC_PRAGMA _A_ 2 _U_ 22 _N_ _N_ _F_ _IF_ARGS_ 0 2 XX 3 \ (u0 :: Char) (u1 :: [Char]) -> _!_ (:) [Char] [u0, u1] _N_ #-}
showFloat :: RealFloat a => a -> [Char] -> [Char]
- {-# GHC_PRAGMA _A_ 1 _U_ 122 _N_ _S_ "U(U(LU(SLLL)LAAAA)LLLALAAAA)" {_A_ 5 _U_ 1122222 _N_ _N_ _N_ _N_} _N_ _SPECIALISE_ [ Double ] 1 { _A_ 1 _U_ 12 _N_ _S_ "U(P)" {_A_ 1 _U_ 22 _N_ _N_ _N_ _N_} _N_ _N_ }, [ Float ] 1 { _A_ 0 _U_ 22 _N_ _N_ _N_ _N_ } #-}
+ {-# GHC_PRAGMA _A_ 1 _U_ 122 _N_ _S_ "U(U(AU(SAAA)AAAAL)LLLALAAAA)" {_A_ 5 _U_ 1122222 _N_ _N_ _N_ _N_} _N_ _SPECIALISE_ [ Double ] 1 { _A_ 1 _U_ 12 _N_ _S_ "U(P)" {_A_ 1 _U_ 22 _N_ _N_ _N_ _N_} _N_ _N_ } #-}
showInt :: Integral a => a -> [Char] -> [Char]
{-# GHC_PRAGMA _A_ 1 _U_ 122 _N_ _S_ "U(U(U(U(SL)LLLLLLLLL)LL)LLLLLSLLLLL)" _N_ _SPECIALISE_ [ Int ] 1 { _A_ 2 _U_ 12 _N_ _S_ "U(P)L" {_A_ 2 _U_ 22 _N_ _N_ _N_ _N_} _N_ _N_ }, [ Integer ] 1 { _A_ 2 _U_ 12 _N_ _S_ "U(PPP)L" {_A_ 4 _U_ 2222 _N_ _N_ _N_ _N_} _N_ _N_ } #-}
showLitChar :: Char -> [Char] -> [Char]
showString :: [Char] -> [Char] -> [Char]
{-# GHC_PRAGMA _A_ 2 _U_ 12 _N_ _N_ _F_ _IF_ARGS_ 0 0 X 1 _TYAPP_ _ORIG_ PreludeList (++) { Char } _N_ #-}
shows :: Text a => a -> [Char] -> [Char]
- {-# GHC_PRAGMA _A_ 1 _U_ 122 _N_ _S_ "U(ASAA)" {_A_ 1 _U_ 122 _N_ _N_ _N_ _N_} _N_ _SPECIALISE_ [ Char ] 1 { _A_ 2 _U_ 12 _N_ _S_ "U(P)L" {_A_ 2 _U_ 22 _N_ _N_ _N_ _N_} _N_ _N_ }, [ Double ] 1 { _A_ 1 _U_ 12 _N_ _S_ "U(P)" {_A_ 1 _U_ 22 _N_ _N_ _N_ _N_} _N_ _N_ }, [ Float ] 1 { _A_ 0 _U_ 22 _N_ _N_ _N_ _N_ }, [ Int ] 1 { _A_ 2 _U_ 12 _N_ _S_ "U(P)L" {_A_ 2 _U_ 22 _N_ _N_ _N_ _N_} _N_ _N_ }, [ Integer ] 1 { _A_ 2 _U_ 12 _N_ _S_ "U(PPP)L" {_A_ 4 _U_ 2222 _N_ _N_ _N_ _N_} _N_ _N_ }, [ [Char] ] 1 { _A_ 1 _U_ 22 _N_ _N_ _F_ _IF_ARGS_ 0 0 X 1 _CONSTM_ Text showList (Char) _N_ }, [ _PackedString ] 1 { _A_ 2 _U_ 12 _N_ _N_ _N_ _N_ }, [ (Int, Int) ] 1 { _A_ 2 _U_ 12 _N_ _S_ "U(LL)L" {_A_ 3 _U_ 222 _N_ _N_ _N_ _N_} _N_ _N_ }, [ (Integer, Integer) ] 1 { _A_ 2 _U_ 12 _N_ _S_ "U(LL)L" {_A_ 3 _U_ 222 _N_ _N_ _N_ _N_} _N_ _N_ } #-}
+ {-# GHC_PRAGMA _A_ 1 _U_ 122 _N_ _S_ "U(ASAA)" {_A_ 1 _U_ 122 _N_ _N_ _N_ _N_} _N_ _SPECIALISE_ [ Bool ] 1 { _A_ 2 _U_ 22 _N_ _N_ _N_ _N_ }, [ Char ] 1 { _A_ 2 _U_ 12 _N_ _S_ "U(P)L" {_A_ 2 _U_ 22 _N_ _N_ _N_ _N_} _N_ _N_ }, [ Double ] 1 { _A_ 1 _U_ 12 _N_ _S_ "U(P)" {_A_ 1 _U_ 22 _N_ _N_ _N_ _N_} _N_ _N_ }, [ Int ] 1 { _A_ 2 _U_ 12 _N_ _S_ "U(P)L" {_A_ 2 _U_ 22 _N_ _N_ _N_ _N_} _N_ _N_ }, [ Integer ] 1 { _A_ 2 _U_ 12 _N_ _S_ "U(PPP)L" {_A_ 4 _U_ 2222 _N_ _N_ _N_ _N_} _N_ _N_ }, [ [Bool] ] 1 { _A_ 1 _U_ 12 _N_ _S_ "S" _F_ _IF_ARGS_ 0 1 X 3 \ (u0 :: [Bool]) -> _APP_ _TYAPP_ _ORIG_ PreludeCore _showList { Bool } [ _WRKR_ _CONSTM_ Text showsPrec (Bool), u0 ] _N_ }, [ [Char] ] 1 { _A_ 1 _U_ 22 _N_ _N_ _F_ _IF_ARGS_ 0 0 X 1 _CONSTM_ Text showList (Char) _N_ }, [ [Double] ] 1 { _A_ 1 _U_ 22 _N_ _N_ _F_ _IF_ARGS_ 0 0 X 1 _CONSTM_ Text showList (Double) _N_ }, [ [Int] ] 1 { _A_ 1 _U_ 22 _N_ _N_ _F_ _IF_ARGS_ 0 0 X 1 _CONSTM_ Text showList (Int) _N_ }, [ [Integer] ] 1 { _A_ 1 _U_ 22 _N_ _N_ _F_ _IF_ARGS_ 0 0 X 1 _CONSTM_ Text showList (Integer) _N_ }, [ [[Char]] ] 1 { _A_ 1 _U_ 12 _N_ _S_ "S" _F_ _IF_ARGS_ 0 1 X 3 \ (u0 :: [[Char]]) -> _APP_ _TYAPP_ _ORIG_ PreludeCore _showList { [Char] } [ _CONSTM_ Text showList (Char), u0 ] _N_ }, [ [[Int]] ] 1 { _A_ 1 _U_ 12 _N_ _S_ "S" _F_ _IF_ARGS_ 0 1 X 3 \ (u0 :: [[Int]]) -> _APP_ _TYAPP_ _ORIG_ PreludeCore _showList { [Int] } [ _CONSTM_ Text showList (Int), u0 ] _N_ }, [ [Complex Double] ] 1 { _A_ 1 _U_ 22 _N_ _N_ _F_ _IF_ARGS_ 0 0 X 1 _CONSTM_ Text showList (Complex Double) _N_ }, [ (Ratio Integer) ] 1 { _A_ 1 _U_ 12 _N_ _S_ "U(LL)" {_A_ 2 _U_ 222 _N_ _N_ _N_ _N_} _N_ _N_ }, [ (Array Int Double) ] 1 { _A_ 1 _U_ 22 _N_ _N_ _N_ _N_ }, [ (Array (Int, Int) Double) ] 1 { _A_ 1 _U_ 22 _N_ _N_ _N_ _N_ }, [ _PackedString ] 1 { _A_ 2 _U_ 12 _N_ _N_ _N_ _N_ }, [ (Complex Double) ] 1 { _A_ 1 _U_ 12 _N_ _S_ "U(LL)" {_A_ 2 _U_ 222 _N_ _N_ _N_ _N_} _N_ _N_ }, [ () ] 1 { _A_ 2 _U_ 12 _N_ _S_ "EL" _F_ _IF_ARGS_ 0 2 CX 4 \ (u0 :: ()) (u1 :: [Char]) -> case u0 of { _ALG_ _TUP_0 -> _APP_ _TYAPP_ _ORIG_ PreludeList (++) { Char } [ _NOREP_S_ "()", u1 ]; _NO_DEFLT_ } _N_ }, [ (Int, Int) ] 1 { _A_ 2 _U_ 12 _N_ _S_ "U(LL)L" {_A_ 3 _U_ 222 _N_ _N_ _N_ _N_} _N_ _N_ }, [ (Integer, Integer) ] 1 { _A_ 2 _U_ 12 _N_ _S_ "U(LL)L" {_A_ 3 _U_ 222 _N_ _N_ _N_ _N_} _N_ _N_ }, [ (Int, Int, Int) ] 1 { _A_ 2 _U_ 12 _N_ _S_ "U(LLL)L" {_A_ 4 _U_ 2222 _N_ _N_ _N_ _N_} _N_ _N_ } #-}
appendFile :: [Char] -> [Char] -> _State _RealWorld -> (Either IOError13 (), _State _RealWorld)
{-# GHC_PRAGMA _A_ 3 _U_ 221 _N_ _S_ "LLU(P)" {_A_ 3 _U_ 222 _N_ _N_ _N_ _N_} _N_ _N_ #-}
hPutChar :: _MVar _Handle -> Char -> _State _RealWorld -> (Either IOError13 (), _State _RealWorld)
print :: Text a => a -> _State _RealWorld -> (Either IOError13 (), _State _RealWorld)
{-# GHC_PRAGMA _A_ 1 _U_ 121 _N_ _N_ _N_ _N_ #-}
putChar :: Char -> _State _RealWorld -> (Either IOError13 (), _State _RealWorld)
- {-# GHC_PRAGMA _A_ 2 _U_ 11 _N_ _N_ _F_ _IF_ARGS_ 0 0 X 2 _APP_ _ORIG_ PreludeWriteTextIO hPutChar [ _ORIG_ PreludeStdIO stdout13 ] _N_ #-}
+ {-# GHC_PRAGMA _A_ 2 _U_ 11 _N_ _N_ _F_ _IF_ARGS_ 0 2 XC 6 \ (u0 :: Char) (u1 :: _State _RealWorld) -> case _ORIG_ PreludeStdIO stdout13 of { _ALG_ _MVar (u2 :: SynchVar# _RealWorld _Handle) -> case u1 of { _ALG_ S# (u3 :: State# _RealWorld) -> _APP_ _WRKR_ _ORIG_ PreludeWriteTextIO hPutChar [ u2, u0, u3 ]; _NO_DEFLT_ }; _NO_DEFLT_ } _N_ #-}
putStr :: [Char] -> _State _RealWorld -> (Either IOError13 (), _State _RealWorld)
- {-# GHC_PRAGMA _A_ 2 _U_ 21 _N_ _N_ _F_ _IF_ARGS_ 0 0 X 2 _APP_ _ORIG_ PreludeWriteTextIO hPutStr [ _ORIG_ PreludeStdIO stdout13 ] _N_ #-}
+ {-# GHC_PRAGMA _A_ 2 _U_ 21 _N_ _N_ _F_ _IF_ARGS_ 0 2 XC 6 \ (u0 :: [Char]) (u1 :: _State _RealWorld) -> case _ORIG_ PreludeStdIO stdout13 of { _ALG_ _MVar (u2 :: SynchVar# _RealWorld _Handle) -> case u1 of { _ALG_ S# (u3 :: State# _RealWorld) -> _APP_ _WRKR_ _ORIG_ PreludeWriteTextIO hPutStr [ u2, u0, u3 ]; _NO_DEFLT_ }; _NO_DEFLT_ } _N_ #-}
putText :: Text a => a -> _State _RealWorld -> (Either IOError13 (), _State _RealWorld)
{-# GHC_PRAGMA _A_ 1 _U_ 121 _N_ _N_ _F_ _IF_ARGS_ 1 1 X 3 _/\_ u0 -> \ (u1 :: {{Text u0}}) -> _APP_ _TYAPP_ _ORIG_ PreludeWriteTextIO hPutText { u0 } [ u1, _ORIG_ PreludeStdIO stdout13 ] _N_ #-}
writeFile :: [Char] -> [Char] -> _State _RealWorld -> (Either IOError13 (), _State _RealWorld)
-{-# GHC_PRAGMA INTERFACE VERSION 5 #-}
+{-# GHC_PRAGMA INTERFACE VERSION 6 #-}
interface Prelude where
import PreludeArray((!), (//), Array, Assoc, _ByteArray, accum, accumArray, amap, array, assocs, bounds, elems, indices, ixmap, listArray)
import PreludeBuiltin(Bin, Char(..), Int(..), Integer(..), List(..), Tuple0, Tuple2, Tuple3, Tuple4, Tuple5, Tuple6, Tuple7, _Addr(..), _RealWorld(..), _State(..))
import PreludeComplex(Complex, cis, conjugate, imagPart, magnitude, mkPolar, phase, polar, realPart)
-import PreludeCore(Bool(..), Eq(..), Fractional(..), Integral(..), Ix(..), Num(..), Ord(..), Real(..), RealFloat(..), RealFrac(..), Text(..), _ceiling, _floor, _readList, _round, _showList, _showRational, _truncate)
+import PreludeCore(Bool(..), Eq(..), Fractional(..), Integral(..), Ix(..), Num(..), Ord(..), Real(..), RealFloat(..), RealFrac(..), Text(..), _readList, _showList, _showRational)
import PreludeIO(interact13) renaming (interact13 to interact)
import PreludeIOError(IOError13)
import PreludeList((!!), (++), (\\), all, and, any, break, concat, cycle, drop, dropWhile, elem, filter, foldl1, foldr1, genericLength, head, init, iterate, last, length, lines, map, maximum, minimum, notElem, nub, null, or, partition, product, products, repeat, reverse, scanl, scanl1, scanr, scanr1, span, splitAt, sum, sums, tail, take, takeWhile, transpose, unlines, unwords, unzip, unzip3, unzip4, unzip5, unzip6, unzip7, words, zip, zip3, zip4, zip5, zip6, zip7, zipWith, zipWith3, zipWith4, zipWith5, zipWith6, zipWith7)
(.) :: (a -> c) -> (b -> a) -> b -> c
{-# GHC_PRAGMA _A_ 3 _U_ 112 _N_ _S_ "SLL" _F_ _ALWAYS_ _/\_ u0 u1 u2 -> \ (u3 :: u0 -> u2) (u4 :: u1 -> u0) (u5 :: u1) -> let {(u6 :: u0) = _APP_ u4 [ u5 ]} in _APP_ u3 [ u6 ] _N_ #-}
(^) :: (Num b, Integral a) => b -> a -> b
- {-# GHC_PRAGMA _A_ 2 _U_ 2122 _N_ _S_ "LU(U(LU(U(U(SA)AALAAAA)AAAA)A)AAALAAAALAA)" {_A_ 5 _U_ 2212222 _N_ _N_ _N_ _N_} _N_ _SPECIALISE_ [ Int, Double ] 2 { _A_ 2 _U_ 21 _N_ _S_ "LU(P)" {_A_ 2 _U_ 22 _N_ _N_ _N_ _N_} _N_ _N_ }, [ Int, Int ] 2 { _A_ 2 _U_ 21 _N_ _S_ "LU(P)" {_A_ 2 _U_ 22 _N_ _N_ _N_ _N_} _N_ _N_ }, [ Int, Integer ] 2 { _A_ 2 _U_ 21 _N_ _S_ "LU(P)" {_A_ 2 _U_ 22 _N_ _N_ _N_ _N_} _N_ _N_ }, [ Int, (Ratio Integer) ] 2 { _A_ 2 _U_ 21 _N_ _S_ "LU(P)" {_A_ 2 _U_ 22 _N_ _N_ _N_ _N_} _N_ _N_ }, [ Int, (Complex Double) ] 2 { _A_ 2 _U_ 21 _N_ _S_ "LU(P)" {_A_ 2 _U_ 22 _N_ _N_ _N_ _N_} _N_ _N_ } #-}
+ {-# GHC_PRAGMA _A_ 2 _U_ 2222 _N_ _S_ "LU(U(LU(U(U(SL)LLLLLLL)LLLL)L)LLLLLLLLLLL)" _N_ _SPECIALISE_ [ Int, Double ] 2 { _A_ 2 _U_ 21 _N_ _S_ "LU(P)" {_A_ 2 _U_ 22 _N_ _N_ _N_ _N_} _N_ _N_ }, [ Int, Int ] 2 { _A_ 2 _U_ 21 _N_ _S_ "LU(P)" {_A_ 2 _U_ 22 _N_ _N_ _N_ _N_} _N_ _N_ }, [ Int, Integer ] 2 { _A_ 2 _U_ 21 _N_ _S_ "LU(P)" {_A_ 2 _U_ 22 _N_ _N_ _N_ _N_} _N_ _N_ }, [ Int, (Ratio Integer) ] 2 { _A_ 2 _U_ 21 _N_ _S_ "LU(P)" {_A_ 2 _U_ 22 _N_ _N_ _N_ _N_} _N_ _N_ }, [ Int, (Complex Double) ] 2 { _A_ 2 _U_ 21 _N_ _S_ "LU(P)" {_A_ 2 _U_ 22 _N_ _N_ _N_ _N_} _N_ _N_ }, [ Integer, Integer ] 2 { _A_ 2 _U_ 21 _N_ _S_ "LU(PPP)" {_A_ 4 _U_ 2222 _N_ _N_ _N_ _N_} _N_ _N_ } #-}
(^^) :: (Fractional b, Integral a) => b -> a -> b
- {-# GHC_PRAGMA _A_ 2 _U_ 2122 _N_ _S_ "LU(LU(U(AAASAAAA)AAA)AALAAAALAA)" {_A_ 5 _U_ 2212222 _N_ _N_ _N_ _N_} _N_ _SPECIALISE_ [ Int, Double ] 2 { _A_ 2 _U_ 21 _N_ _S_ "LU(P)" {_A_ 2 _U_ 22 _N_ _N_ _N_ _N_} _N_ _N_ }, [ Int, (Ratio Integer) ] 2 { _A_ 2 _U_ 21 _N_ _S_ "LU(P)" {_A_ 2 _U_ 22 _N_ _N_ _N_ _N_} _N_ _N_ } #-}
+ {-# GHC_PRAGMA _A_ 2 _U_ 2222 _N_ _S_ "LU(LU(U(LLLSLLLL)LLL)LLLLLLLLLL)" _N_ _SPECIALISE_ [ Int, Double ] 2 { _A_ 2 _U_ 21 _N_ _S_ "LU(P)" {_A_ 2 _U_ 22 _N_ _N_ _N_ _N_} _N_ _N_ }, [ Int, (Ratio Integer) ] 2 { _A_ 2 _U_ 21 _N_ _S_ "LU(P)" {_A_ 2 _U_ 22 _N_ _N_ _N_ _N_} _N_ _N_ }, [ Int, (Complex Double) ] 2 { _A_ 2 _U_ 21 _N_ _S_ "LU(P)" {_A_ 2 _U_ 22 _N_ _N_ _N_ _N_} _N_ _N_ } #-}
appendBin :: Bin -> Bin -> Bin
- {-# GHC_PRAGMA _A_ 2 _U_ 22 _N_ _S_ _!_ _F_ _IF_ARGS_ 0 2 XX 4 \ (u0 :: Bin) (u1 :: Bin) -> _APP_ _TYAPP_ error { (Bin -> Bin -> Bin) } [ _NOREP_S_ "appendBin{Prelude}\n", u0, u1 ] _N_ #-}
+ {-# GHC_PRAGMA _A_ 2 _U_ 22 _N_ _S_ _!_ _N_ _N_ #-}
asTypeOf :: a -> a -> a
{-# GHC_PRAGMA _A_ 2 _U_ 10 _N_ _N_ _F_ _IF_ARGS_ 1 0 X 1 _/\_ u0 -> _TYAPP_ _TYAPP_ _ORIG_ Prelude const { u0 } { u0 } _N_ #-}
atan2 :: RealFloat a => a -> a -> a
flip :: (b -> a -> c) -> a -> b -> c
{-# GHC_PRAGMA _A_ 3 _U_ 122 _N_ _S_ "SLL" _F_ _IF_ARGS_ 3 3 XXX 3 _/\_ u0 u1 u2 -> \ (u3 :: u1 -> u0 -> u2) (u4 :: u0) (u5 :: u1) -> _APP_ u3 [ u5, u4 ] _N_ #-}
fromIntegral :: (Integral a, Num b) => a -> b
- {-# GHC_PRAGMA _A_ 3 _U_ 112 _N_ _S_ "LU(AAAAAAAASA)L" {_A_ 3 _U_ 112 _N_ _N_ _F_ _IF_ARGS_ 2 3 CXX 6 _/\_ u0 u1 -> \ (u2 :: {{Integral u0}}) (u3 :: Integer -> u1) (u4 :: u0) -> let {(uh :: Integer) = case u2 of { _ALG_ _TUP_12 (u5 :: {{Real u0}}) (u6 :: {{Ix u0}}) (u7 :: u0 -> u0 -> u0) (u8 :: u0 -> u0 -> u0) (u9 :: u0 -> u0 -> u0) (ua :: u0 -> u0 -> u0) (ub :: u0 -> u0 -> (u0, u0)) (uc :: u0 -> u0 -> (u0, u0)) (ud :: u0 -> Bool) (ue :: u0 -> Bool) (uf :: u0 -> Integer) (ug :: u0 -> Int) -> _APP_ uf [ u4 ]; _NO_DEFLT_ }} in _APP_ u3 [ uh ] _N_} _F_ _IF_ARGS_ 2 3 CCX 7 _/\_ u0 u1 -> \ (u2 :: {{Integral u0}}) (u3 :: {{Num u1}}) (u4 :: u0) -> let {(uh :: Integer) = case u2 of { _ALG_ _TUP_12 (u5 :: {{Real u0}}) (u6 :: {{Ix u0}}) (u7 :: u0 -> u0 -> u0) (u8 :: u0 -> u0 -> u0) (u9 :: u0 -> u0 -> u0) (ua :: u0 -> u0 -> u0) (ub :: u0 -> u0 -> (u0, u0)) (uc :: u0 -> u0 -> (u0, u0)) (ud :: u0 -> Bool) (ue :: u0 -> Bool) (uf :: u0 -> Integer) (ug :: u0 -> Int) -> _APP_ uf [ u4 ]; _NO_DEFLT_ }} in case u3 of { _ALG_ _TUP_10 (ui :: {{Eq u1}}) (uj :: {{Text u1}}) (uk :: u1 -> u1 -> u1) (ul :: u1 -> u1 -> u1) (um :: u1 -> u1 -> u1) (un :: u1 -> u1) (uo :: u1 -> u1) (up :: u1 -> u1) (uq :: Integer -> u1) (ur :: Int -> u1) -> _APP_ uq [ uh ]; _NO_DEFLT_ } _SPECIALISE_ [ Int, Double ] 2 { _A_ 1 _U_ 1 _N_ _S_ "U(P)" {_A_ 1 _U_ 2 _N_ _N_ _F_ _IF_ARGS_ 0 1 X 3 \ (u0 :: Int#) -> case _#_ int2Double# [] [u0] of { _PRIM_ (u1 :: Double#) -> _!_ D# [] [u1] } _N_} _F_ _IF_ARGS_ 0 1 C 4 \ (u0 :: Int) -> case u0 of { _ALG_ I# (u1 :: Int#) -> case _#_ int2Double# [] [u1] of { _PRIM_ (u2 :: Double#) -> _!_ D# [] [u2] }; _NO_DEFLT_ } _N_ }, [ Int, Int ] 2 { _A_ 1 _U_ 1 _N_ _N_ _F_ _IF_ARGS_ 0 0 X 1 _TYAPP_ _ORIG_ Prelude id { Int } _N_ }, [ Int, Integer ] 2 { _A_ 1 _U_ 1 _N_ _S_ "U(P)" {_A_ 1 _U_ 2 _N_ _N_ _F_ _IF_ARGS_ 0 1 X 1 \ (u0 :: Int#) -> _#_ int2Integer# [] [u0] _N_} _F_ _IF_ARGS_ 0 1 C 2 \ (u0 :: Int) -> case u0 of { _ALG_ I# (u1 :: Int#) -> _#_ int2Integer# [] [u1]; _NO_DEFLT_ } _N_ }, [ Integer, Double ] 2 { _A_ 1 _U_ 1 _N_ _S_ "U(PPP)" {_A_ 3 _U_ 222 _N_ _N_ _F_ _IF_ARGS_ 0 3 XXX 3 \ (u0 :: Int#) (u1 :: Int#) (u2 :: ByteArray#) -> case _#_ encodeDouble# [] [u0, u1, u2, 0#] of { _PRIM_ (u3 :: Double#) -> _!_ D# [] [u3] } _N_} _F_ _IF_ARGS_ 0 1 C 4 \ (u0 :: Integer) -> case u0 of { _ALG_ J# (u1 :: Int#) (u2 :: Int#) (u3 :: ByteArray#) -> case _#_ encodeDouble# [] [u1, u2, u3, 0#] of { _PRIM_ (u4 :: Double#) -> _!_ D# [] [u4] }; _NO_DEFLT_ } _N_ }, [ Integer, Int ] 2 { _A_ 1 _U_ 1 _N_ _S_ "U(PPP)" {_A_ 3 _U_ 222 _N_ _N_ _F_ _IF_ARGS_ 0 3 XXX 3 \ (u0 :: Int#) (u1 :: Int#) (u2 :: ByteArray#) -> case _#_ integer2Int# [] [u0, u1, u2] of { _PRIM_ (u3 :: Int#) -> _!_ I# [] [u3] } _N_} _F_ _IF_ARGS_ 0 1 C 4 \ (u0 :: Integer) -> case u0 of { _ALG_ J# (u1 :: Int#) (u2 :: Int#) (u3 :: ByteArray#) -> case _#_ integer2Int# [] [u1, u2, u3] of { _PRIM_ (u4 :: Int#) -> _!_ I# [] [u4] }; _NO_DEFLT_ } _N_ }, [ Integer, Integer ] 2 { _A_ 1 _U_ 1 _N_ _N_ _F_ _IF_ARGS_ 0 0 X 1 _TYAPP_ _ORIG_ Prelude id { Integer } _N_ } #-}
+ {-# GHC_PRAGMA _A_ 3 _U_ 112 _N_ _S_ "LU(AAAAAAAASA)L" {_A_ 3 _U_ 112 _N_ _N_ _F_ _IF_ARGS_ 2 3 CXX 6 _/\_ u0 u1 -> \ (u2 :: {{Integral u0}}) (u3 :: Integer -> u1) (u4 :: u0) -> let {(uh :: Integer) = case u2 of { _ALG_ _TUP_12 (u5 :: {{Real u0}}) (u6 :: {{Ix u0}}) (u7 :: u0 -> u0 -> u0) (u8 :: u0 -> u0 -> u0) (u9 :: u0 -> u0 -> u0) (ua :: u0 -> u0 -> u0) (ub :: u0 -> u0 -> (u0, u0)) (uc :: u0 -> u0 -> (u0, u0)) (ud :: u0 -> Bool) (ue :: u0 -> Bool) (uf :: u0 -> Integer) (ug :: u0 -> Int) -> _APP_ uf [ u4 ]; _NO_DEFLT_ }} in _APP_ u3 [ uh ] _N_} _F_ _IF_ARGS_ 2 3 CCX 7 _/\_ u0 u1 -> \ (u2 :: {{Integral u0}}) (u3 :: {{Num u1}}) (u4 :: u0) -> let {(uh :: Integer) = case u2 of { _ALG_ _TUP_12 (u5 :: {{Real u0}}) (u6 :: {{Ix u0}}) (u7 :: u0 -> u0 -> u0) (u8 :: u0 -> u0 -> u0) (u9 :: u0 -> u0 -> u0) (ua :: u0 -> u0 -> u0) (ub :: u0 -> u0 -> (u0, u0)) (uc :: u0 -> u0 -> (u0, u0)) (ud :: u0 -> Bool) (ue :: u0 -> Bool) (uf :: u0 -> Integer) (ug :: u0 -> Int) -> _APP_ uf [ u4 ]; _NO_DEFLT_ }} in case u3 of { _ALG_ _TUP_10 (ui :: {{Eq u1}}) (uj :: {{Text u1}}) (uk :: u1 -> u1 -> u1) (ul :: u1 -> u1 -> u1) (um :: u1 -> u1 -> u1) (un :: u1 -> u1) (uo :: u1 -> u1) (up :: u1 -> u1) (uq :: Integer -> u1) (ur :: Int -> u1) -> _APP_ uq [ uh ]; _NO_DEFLT_ } _SPECIALISE_ [ Int, Double ] 2 { _A_ 1 _U_ 1 _N_ _S_ "U(P)" {_A_ 1 _U_ 2 _N_ _N_ _F_ _IF_ARGS_ 0 1 X 3 \ (u0 :: Int#) -> case _#_ int2Double# [] [u0] of { _PRIM_ (u1 :: Double#) -> _!_ D# [] [u1] } _N_} _F_ _IF_ARGS_ 0 1 C 4 \ (u0 :: Int) -> case u0 of { _ALG_ I# (u1 :: Int#) -> case _#_ int2Double# [] [u1] of { _PRIM_ (u2 :: Double#) -> _!_ D# [] [u2] }; _NO_DEFLT_ } _N_ }, [ Int, Float ] 2 { _A_ 1 _U_ 1 _N_ _S_ "U(P)" {_A_ 1 _U_ 2 _N_ _N_ _F_ _IF_ARGS_ 0 1 X 3 \ (u0 :: Int#) -> case _#_ int2Float# [] [u0] of { _PRIM_ (u1 :: Float#) -> _!_ F# [] [u1] } _N_} _F_ _IF_ARGS_ 0 1 C 4 \ (u0 :: Int) -> case u0 of { _ALG_ I# (u1 :: Int#) -> case _#_ int2Float# [] [u1] of { _PRIM_ (u2 :: Float#) -> _!_ F# [] [u2] }; _NO_DEFLT_ } _N_ }, [ Int, Int ] 2 { _A_ 1 _U_ 1 _N_ _N_ _F_ _IF_ARGS_ 0 0 X 1 _TYAPP_ _ORIG_ Prelude id { Int } _N_ }, [ Int, Integer ] 2 { _A_ 1 _U_ 1 _N_ _S_ "U(P)" {_A_ 1 _U_ 2 _N_ _N_ _F_ _IF_ARGS_ 0 1 X 1 \ (u0 :: Int#) -> _#_ int2Integer# [] [u0] _N_} _F_ _IF_ARGS_ 0 1 C 2 \ (u0 :: Int) -> case u0 of { _ALG_ I# (u1 :: Int#) -> _#_ int2Integer# [] [u1]; _NO_DEFLT_ } _N_ }, [ Int, (Ratio Integer) ] 2 { _A_ 1 _U_ 1 _N_ _N_ _N_ _N_ }, [ Integer, Double ] 2 { _A_ 1 _U_ 1 _N_ _S_ "U(PPP)" {_A_ 3 _U_ 222 _N_ _N_ _F_ _IF_ARGS_ 0 3 XXX 3 \ (u0 :: Int#) (u1 :: Int#) (u2 :: ByteArray#) -> case _#_ encodeDouble# [] [u0, u1, u2, 0#] of { _PRIM_ (u3 :: Double#) -> _!_ D# [] [u3] } _N_} _F_ _IF_ARGS_ 0 1 C 4 \ (u0 :: Integer) -> case u0 of { _ALG_ J# (u1 :: Int#) (u2 :: Int#) (u3 :: ByteArray#) -> case _#_ encodeDouble# [] [u1, u2, u3, 0#] of { _PRIM_ (u4 :: Double#) -> _!_ D# [] [u4] }; _NO_DEFLT_ } _N_ }, [ Integer, Float ] 2 { _A_ 1 _U_ 1 _N_ _S_ "U(PPP)" {_A_ 3 _U_ 222 _N_ _N_ _F_ _IF_ARGS_ 0 3 XXX 3 \ (u0 :: Int#) (u1 :: Int#) (u2 :: ByteArray#) -> case _#_ encodeFloat# [] [u0, u1, u2, 0#] of { _PRIM_ (u3 :: Float#) -> _!_ F# [] [u3] } _N_} _F_ _IF_ARGS_ 0 1 C 4 \ (u0 :: Integer) -> case u0 of { _ALG_ J# (u1 :: Int#) (u2 :: Int#) (u3 :: ByteArray#) -> case _#_ encodeFloat# [] [u1, u2, u3, 0#] of { _PRIM_ (u4 :: Float#) -> _!_ F# [] [u4] }; _NO_DEFLT_ } _N_ }, [ Integer, Int ] 2 { _A_ 1 _U_ 1 _N_ _S_ "U(PPP)" {_A_ 3 _U_ 222 _N_ _N_ _F_ _IF_ARGS_ 0 3 XXX 3 \ (u0 :: Int#) (u1 :: Int#) (u2 :: ByteArray#) -> case _#_ integer2Int# [] [u0, u1, u2] of { _PRIM_ (u3 :: Int#) -> _!_ I# [] [u3] } _N_} _F_ _IF_ARGS_ 0 1 C 4 \ (u0 :: Integer) -> case u0 of { _ALG_ J# (u1 :: Int#) (u2 :: Int#) (u3 :: ByteArray#) -> case _#_ integer2Int# [] [u1, u2, u3] of { _PRIM_ (u4 :: Int#) -> _!_ I# [] [u4] }; _NO_DEFLT_ } _N_ }, [ Integer, Integer ] 2 { _A_ 1 _U_ 1 _N_ _N_ _F_ _IF_ARGS_ 0 0 X 1 _TYAPP_ _ORIG_ Prelude id { Integer } _N_ }, [ Integer, (Ratio Integer) ] 2 { _A_ 1 _U_ 2 _N_ _N_ _F_ _IF_ARGS_ 0 1 X 3 \ (u0 :: Integer) -> _!_ (:%) [Integer] [u0, _SPEC_ _ORIG_ PreludeCore __i1 [ (Integer) ]] _N_ } #-}
fromRealFrac :: (RealFrac a, Fractional b) => a -> b
- {-# GHC_PRAGMA _A_ 3 _U_ 112 _N_ _S_ "LU(AAAS)L" {_A_ 3 _U_ 112 _N_ _N_ _N_ _N_} _N_ _SPECIALISE_ [ Double, Double ] 2 { _A_ 1 _U_ 1 _N_ _N_ _F_ _IF_ARGS_ 0 0 X 1 _TYAPP_ _ORIG_ Prelude id { Double } _N_ }, [ Double, Float ] 2 { _A_ 1 _U_ 1 _N_ _S_ "U(P)" {_A_ 1 _U_ 2 _N_ _N_ _F_ _IF_ARGS_ 0 1 X 3 \ (u0 :: Double#) -> case _#_ double2Float# [] [u0] of { _PRIM_ (u1 :: Float#) -> _!_ F# [] [u1] } _N_} _F_ _IF_ARGS_ 0 1 C 4 \ (u0 :: Double) -> case u0 of { _ALG_ D# (u1 :: Double#) -> case _#_ double2Float# [] [u1] of { _PRIM_ (u2 :: Float#) -> _!_ F# [] [u2] }; _NO_DEFLT_ } _N_ }, [ Float, Double ] 2 { _A_ 1 _U_ 1 _N_ _S_ "U(P)" {_A_ 1 _U_ 2 _N_ _N_ _F_ _IF_ARGS_ 0 1 X 3 \ (u0 :: Float#) -> case _#_ float2Double# [] [u0] of { _PRIM_ (u1 :: Double#) -> _!_ D# [] [u1] } _N_} _F_ _IF_ARGS_ 0 1 C 4 \ (u0 :: Float) -> case u0 of { _ALG_ F# (u1 :: Float#) -> case _#_ float2Double# [] [u1] of { _PRIM_ (u2 :: Double#) -> _!_ D# [] [u2] }; _NO_DEFLT_ } _N_ }, [ Float, Float ] 2 { _A_ 1 _U_ 1 _N_ _N_ _F_ _IF_ARGS_ 0 0 X 1 _TYAPP_ _ORIG_ Prelude id { Float } _N_ } #-}
+ {-# GHC_PRAGMA _A_ 3 _U_ 112 _N_ _S_ "LU(AAAS)L" {_A_ 3 _U_ 112 _N_ _N_ _N_ _N_} _N_ _SPECIALISE_ [ Double, Double ] 2 { _A_ 1 _U_ 1 _N_ _N_ _F_ _IF_ARGS_ 0 0 X 1 _TYAPP_ _ORIG_ Prelude id { Double } _N_ }, [ Double, Float ] 2 { _A_ 1 _U_ 1 _N_ _S_ "U(P)" {_A_ 1 _U_ 2 _N_ _N_ _F_ _IF_ARGS_ 0 1 X 3 \ (u0 :: Double#) -> case _#_ double2Float# [] [u0] of { _PRIM_ (u1 :: Float#) -> _!_ F# [] [u1] } _N_} _F_ _IF_ARGS_ 0 1 C 4 \ (u0 :: Double) -> case u0 of { _ALG_ D# (u1 :: Double#) -> case _#_ double2Float# [] [u1] of { _PRIM_ (u2 :: Float#) -> _!_ F# [] [u2] }; _NO_DEFLT_ } _N_ }, [ Double, (Ratio Integer) ] 2 { _A_ 1 _U_ 1 _N_ _S_ "U(P)" {_A_ 1 _U_ 2 _N_ _N_ _N_ _N_} _N_ _N_ }, [ Float, Double ] 2 { _A_ 1 _U_ 1 _N_ _S_ "U(P)" {_A_ 1 _U_ 2 _N_ _N_ _F_ _IF_ARGS_ 0 1 X 3 \ (u0 :: Float#) -> case _#_ float2Double# [] [u0] of { _PRIM_ (u1 :: Double#) -> _!_ D# [] [u1] } _N_} _F_ _IF_ARGS_ 0 1 C 4 \ (u0 :: Float) -> case u0 of { _ALG_ F# (u1 :: Float#) -> case _#_ float2Double# [] [u1] of { _PRIM_ (u2 :: Double#) -> _!_ D# [] [u2] }; _NO_DEFLT_ } _N_ }, [ Float, Float ] 2 { _A_ 1 _U_ 1 _N_ _N_ _F_ _IF_ARGS_ 0 0 X 1 _TYAPP_ _ORIG_ Prelude id { Float } _N_ }, [ Float, (Ratio Integer) ] 2 { _A_ 1 _U_ 1 _N_ _S_ "U(P)" {_A_ 1 _U_ 2 _N_ _N_ _N_ _N_} _N_ _N_ }, [ (Ratio Integer), Double ] 2 { _A_ 1 _U_ 1 _N_ _S_ "U(U(PPP)U(PPP))" {_A_ 4 _U_ 2222 _N_ _N_ _N_ _N_} _N_ _N_ }, [ (Ratio Integer), Float ] 2 { _A_ 1 _U_ 2 _N_ _N_ _F_ _IF_ARGS_ 0 0 X 1 _CONSTM_ Fractional fromRational (Float) _N_ }, [ (Ratio Integer), (Ratio Integer) ] 2 { _A_ 1 _U_ 1 _N_ _N_ _F_ _IF_ARGS_ 0 0 X 1 _TYAPP_ _ORIG_ Prelude id { (Ratio Integer) } _N_ } #-}
fst :: (b, a) -> b
{-# GHC_PRAGMA _A_ 1 _U_ 1 _N_ _S_ "U(SA)" {_A_ 1 _U_ 1 _N_ _N_ _F_ _IF_ARGS_ 2 1 X 1 _/\_ u0 u1 -> \ (u2 :: u1) -> u2 _N_} _F_ _IF_ARGS_ 2 1 C 2 _/\_ u0 u1 -> \ (u2 :: (u1, u0)) -> case u2 of { _ALG_ _TUP_2 (u3 :: u1) (u4 :: u0) -> u3; _NO_DEFLT_ } _N_ #-}
gcd :: Integral a => a -> a -> a
isLower :: Char -> Bool
{-# GHC_PRAGMA _A_ 1 _U_ 1 _N_ _S_ "U(P)" {_A_ 1 _U_ 2 _N_ _N_ _N_ _N_} _N_ _N_ #-}
isNullBin :: Bin -> Bool
- {-# GHC_PRAGMA _A_ 1 _U_ 2 _N_ _S_ _!_ _F_ _IF_ARGS_ 0 1 X 3 \ (u0 :: Bin) -> _APP_ _TYAPP_ error { (Bin -> Bool) } [ _NOREP_S_ "isNullBin{Prelude}\n", u0 ] _N_ #-}
+ {-# GHC_PRAGMA _A_ 1 _U_ 2 _N_ _S_ _!_ _N_ _N_ #-}
isPrint :: Char -> Bool
{-# GHC_PRAGMA _A_ 1 _U_ 1 _N_ _S_ "U(P)" {_A_ 1 _U_ 2 _N_ _N_ _N_ _N_} _N_ _N_ #-}
isSpace :: Char -> Bool
not :: Bool -> Bool
{-# GHC_PRAGMA _A_ 1 _U_ 1 _N_ _S_ "E" _F_ _ALWAYS_ \ (u0 :: Bool) -> case u0 of { _ALG_ True -> _!_ False [] []; False -> _!_ True [] []; _NO_DEFLT_ } _N_ #-}
nullBin :: Bin
- {-# GHC_PRAGMA _A_ 0 _N_ _N_ _S_ _!_ _F_ _IF_ARGS_ 0 0 X 2 _APP_ _TYAPP_ error { Bin } [ _NOREP_S_ "nullBin{Prelude}\n" ] _N_ #-}
+ {-# GHC_PRAGMA _A_ 0 _N_ _N_ _S_ _!_ _N_ _N_ #-}
ord :: Char -> Int
{-# GHC_PRAGMA _A_ 1 _U_ 1 _N_ _S_ "U(P)" {_A_ 1 _U_ 2 _N_ _N_ _F_ _IF_ARGS_ 0 1 X 3 \ (u0 :: Char#) -> case _#_ ord# [] [u0] of { _PRIM_ (u1 :: Int#) -> _!_ I# [] [u1] } _N_} _F_ _IF_ARGS_ 0 1 C 4 \ (u0 :: Char) -> case u0 of { _ALG_ C# (u1 :: Char#) -> case _#_ ord# [] [u1] of { _PRIM_ (u2 :: Int#) -> _!_ I# [] [u2] }; _NO_DEFLT_ } _N_ #-}
otherwise :: Bool
snd :: (a, b) -> b
{-# GHC_PRAGMA _A_ 1 _U_ 1 _N_ _S_ "U(AS)" {_A_ 1 _U_ 1 _N_ _N_ _F_ _IF_ARGS_ 2 1 X 1 _/\_ u0 u1 -> \ (u2 :: u1) -> u2 _N_} _F_ _IF_ARGS_ 2 1 C 2 _/\_ u0 u1 -> \ (u2 :: (u0, u1)) -> case u2 of { _ALG_ _TUP_2 (u3 :: u0) (u4 :: u1) -> u4; _NO_DEFLT_ } _N_ #-}
subtract :: Num a => a -> a -> a
- {-# GHC_PRAGMA _A_ 3 _U_ 122 _N_ _S_ "U(AAASAAAAAA)LL" {_A_ 3 _U_ 122 _N_ _N_ _F_ _IF_ARGS_ 1 3 XXX 3 _/\_ u0 -> \ (u1 :: u0 -> u0 -> u0) (u2 :: u0) (u3 :: u0) -> _APP_ u1 [ u3, u2 ] _N_} _F_ _IF_ARGS_ 1 3 CXX 4 _/\_ u0 -> \ (u1 :: {{Num u0}}) (u2 :: u0) (u3 :: u0) -> case u1 of { _ALG_ _TUP_10 (u4 :: {{Eq u0}}) (u5 :: {{Text u0}}) (u6 :: u0 -> u0 -> u0) (u7 :: u0 -> u0 -> u0) (u8 :: u0 -> u0 -> u0) (u9 :: u0 -> u0) (ua :: u0 -> u0) (ub :: u0 -> u0) (uc :: Integer -> u0) (ud :: Int -> u0) -> _APP_ u7 [ u3, u2 ]; _NO_DEFLT_ } _SPECIALISE_ [ Double ] 1 { _A_ 2 _U_ 11 _N_ _S_ "U(P)U(P)" {_A_ 2 _U_ 22 _N_ _N_ _F_ _IF_ARGS_ 0 2 XX 3 \ (u0 :: Double#) (u1 :: Double#) -> case _#_ minusDouble# [] [u1, u0] of { _PRIM_ (u2 :: Double#) -> _!_ D# [] [u2] } _N_} _F_ _IF_ARGS_ 0 2 CC 5 \ (u0 :: Double) (u1 :: Double) -> case u1 of { _ALG_ D# (u2 :: Double#) -> case u0 of { _ALG_ D# (u3 :: Double#) -> case _#_ minusDouble# [] [u2, u3] of { _PRIM_ (u4 :: Double#) -> _!_ D# [] [u4] }; _NO_DEFLT_ }; _NO_DEFLT_ } _N_ }, [ Int ] 1 { _A_ 2 _U_ 11 _N_ _S_ "U(P)U(P)" {_A_ 2 _U_ 22 _N_ _N_ _F_ _IF_ARGS_ 0 2 XX 3 \ (u0 :: Int#) (u1 :: Int#) -> case _#_ minusInt# [] [u1, u0] of { _PRIM_ (u2 :: Int#) -> _!_ I# [] [u2] } _N_} _F_ _IF_ARGS_ 0 2 CC 5 \ (u0 :: Int) (u1 :: Int) -> case u1 of { _ALG_ I# (u2 :: Int#) -> case u0 of { _ALG_ I# (u3 :: Int#) -> case _#_ minusInt# [] [u2, u3] of { _PRIM_ (u4 :: Int#) -> _!_ I# [] [u4] }; _NO_DEFLT_ }; _NO_DEFLT_ } _N_ } #-}
+ {-# GHC_PRAGMA _A_ 3 _U_ 122 _N_ _S_ "U(AAASAAAAAA)LL" {_A_ 3 _U_ 122 _N_ _N_ _F_ _IF_ARGS_ 1 3 XXX 3 _/\_ u0 -> \ (u1 :: u0 -> u0 -> u0) (u2 :: u0) (u3 :: u0) -> _APP_ u1 [ u3, u2 ] _N_} _F_ _IF_ARGS_ 1 3 CXX 4 _/\_ u0 -> \ (u1 :: {{Num u0}}) (u2 :: u0) (u3 :: u0) -> case u1 of { _ALG_ _TUP_10 (u4 :: {{Eq u0}}) (u5 :: {{Text u0}}) (u6 :: u0 -> u0 -> u0) (u7 :: u0 -> u0 -> u0) (u8 :: u0 -> u0 -> u0) (u9 :: u0 -> u0) (ua :: u0 -> u0) (ub :: u0 -> u0) (uc :: Integer -> u0) (ud :: Int -> u0) -> _APP_ u7 [ u3, u2 ]; _NO_DEFLT_ } _SPECIALISE_ [ Double ] 1 { _A_ 2 _U_ 11 _N_ _S_ "U(P)U(P)" {_A_ 2 _U_ 22 _N_ _N_ _F_ _IF_ARGS_ 0 2 XX 3 \ (u0 :: Double#) (u1 :: Double#) -> case _#_ minusDouble# [] [u1, u0] of { _PRIM_ (u2 :: Double#) -> _!_ D# [] [u2] } _N_} _F_ _IF_ARGS_ 0 2 CC 5 \ (u0 :: Double) (u1 :: Double) -> case u1 of { _ALG_ D# (u2 :: Double#) -> case u0 of { _ALG_ D# (u3 :: Double#) -> case _#_ minusDouble# [] [u2, u3] of { _PRIM_ (u4 :: Double#) -> _!_ D# [] [u4] }; _NO_DEFLT_ }; _NO_DEFLT_ } _N_ }, [ Int ] 1 { _A_ 2 _U_ 11 _N_ _S_ "U(P)U(P)" {_A_ 2 _U_ 22 _N_ _N_ _F_ _IF_ARGS_ 0 2 XX 3 \ (u0 :: Int#) (u1 :: Int#) -> case _#_ minusInt# [] [u1, u0] of { _PRIM_ (u2 :: Int#) -> _!_ I# [] [u2] } _N_} _F_ _IF_ARGS_ 0 2 CC 5 \ (u0 :: Int) (u1 :: Int) -> case u1 of { _ALG_ I# (u2 :: Int#) -> case u0 of { _ALG_ I# (u3 :: Int#) -> case _#_ minusInt# [] [u2, u3] of { _PRIM_ (u4 :: Int#) -> _!_ I# [] [u4] }; _NO_DEFLT_ }; _NO_DEFLT_ } _N_ }, [ (Complex Double) ] 1 { _A_ 2 _U_ 11 _N_ _S_ "U(LL)U(LL)" {_A_ 4 _U_ 2222 _N_ _N_ _N_ _N_} _N_ _N_ } #-}
thenMaybe :: Maybe a -> (a -> Maybe b) -> Maybe b
{-# GHC_PRAGMA _A_ 2 _U_ 11 _N_ _S_ "SL" _F_ _IF_ARGS_ 2 2 CX 5 _/\_ u0 u1 -> \ (u2 :: Maybe u0) (u3 :: u0 -> Maybe u1) -> case u2 of { _ALG_ Nothing -> _!_ Nothing [u1] []; Just (u4 :: u0) -> _APP_ u3 [ u4 ]; _NO_DEFLT_ } _N_ #-}
toLower :: Char -> Char
imagPart :: Complex a -> a
{-# GHC_PRAGMA _A_ 1 _U_ 1 _N_ _S_ "U(AS)" {_A_ 1 _U_ 1 _N_ _N_ _F_ _IF_ARGS_ 1 1 X 1 _/\_ u0 -> \ (u1 :: u0) -> u1 _N_} _F_ _IF_ARGS_ 1 1 C 2 _/\_ u0 -> \ (u1 :: Complex u0) -> case u1 of { _ALG_ (:+) (u2 :: u0) (u3 :: u0) -> u3; _NO_DEFLT_ } _N_ #-}
magnitude :: RealFloat a => Complex a -> a
- {-# GHC_PRAGMA _A_ 1 _U_ 12 _N_ _S_ "U(ALAAAAALAS)" {_A_ 3 _U_ 2221 _N_ _N_ _N_ _N_} _N_ _SPECIALISE_ [ Double ] 1 { _A_ 1 _U_ 1 _N_ _S_ "U(LL)" {_A_ 2 _U_ 22 _N_ _N_ _N_ _N_} _N_ _N_ } #-}
+ {-# GHC_PRAGMA _A_ 1 _U_ 12 _N_ _S_ "U(ALAAAAALAS)" {_A_ 3 _U_ 2221 _N_ _N_ _N_ _N_} _N_ _SPECIALISE_ [ Double ] 1 { _A_ 1 _U_ 1 _N_ _S_ "U(U(P)U(P))" {_A_ 2 _U_ 22 _N_ _N_ _N_ _N_} _N_ _N_ } #-}
mkPolar :: RealFloat a => a -> a -> Complex a
{-# GHC_PRAGMA _A_ 3 _U_ 122 _N_ _N_ _N_ _SPECIALISE_ [ Double ] 1 { _A_ 2 _U_ 22 _N_ _N_ _N_ _N_ } #-}
phase :: RealFloat a => Complex a -> a
{-# GHC_PRAGMA _A_ 1 _U_ 22 _N_ _N_ _N_ _SPECIALISE_ [ Double ] 1 { _A_ 1 _U_ 2 _N_ _N_ _N_ _N_ } #-}
realPart :: Complex a -> a
{-# GHC_PRAGMA _A_ 1 _U_ 1 _N_ _S_ "U(SA)" {_A_ 1 _U_ 1 _N_ _N_ _F_ _IF_ARGS_ 1 1 X 1 _/\_ u0 -> \ (u1 :: u0) -> u1 _N_} _F_ _IF_ARGS_ 1 1 C 2 _/\_ u0 -> \ (u1 :: Complex u0) -> case u1 of { _ALG_ (:+) (u2 :: u0) (u3 :: u0) -> u2; _NO_DEFLT_ } _N_ #-}
-_ceiling :: (RealFrac a, Integral b) => a -> b
- {-# GHC_PRAGMA _A_ 2 _U_ 122 _N_ _S_ "U(U(AU(U(AAAASAAA)AAAA)A)LSAAAA)L" {_A_ 4 _U_ 11122 _N_ _N_ _N_ _N_} _N_ _SPECIALISE_ [ Double, Int ] 2 { _A_ 0 _U_ 2 _N_ _N_ _N_ _N_ } #-}
-_floor :: (RealFrac a, Integral b) => a -> b
- {-# GHC_PRAGMA _A_ 2 _U_ 122 _N_ _S_ "U(U(AU(U(ASAAAAAA)AAAA)A)LSAAAA)L" {_A_ 4 _U_ 11122 _N_ _N_ _N_ _N_} _N_ _SPECIALISE_ [ Double, Int ] 2 { _A_ 0 _U_ 2 _N_ _N_ _N_ _N_ } #-}
-_readList :: Text a => [Char] -> [([a], [Char])]
+_readList :: ([Char] -> [(a, [Char])]) -> [Char] -> [([a], [Char])]
{-# GHC_PRAGMA _A_ 1 _U_ 22 _N_ _N_ _N_ _N_ #-}
-_round :: (RealFrac a, Integral b) => a -> b
- {-# GHC_PRAGMA _A_ 2 _U_ 122 _N_ _S_ "U(U(AU(U(ALAAAAAS)AAAA)A)LSAAAA)L" {_A_ 5 _U_ 112122 _N_ _N_ _N_ _N_} _N_ _SPECIALISE_ [ Double, Int ] 2 { _A_ 0 _U_ 2 _N_ _N_ _N_ _N_ }, [ (Ratio Integer), Integer ] 2 { _A_ 1 _U_ 1 _N_ _S_ "U(LL)" {_A_ 2 _U_ 22 _N_ _N_ _N_ _N_} _N_ _N_ } #-}
-_showList :: Text a => [a] -> [Char] -> [Char]
- {-# GHC_PRAGMA _A_ 1 _U_ 212 _N_ _N_ _N_ _N_ #-}
+_showList :: (a -> [Char] -> [Char]) -> [a] -> [Char] -> [Char]
+ {-# GHC_PRAGMA _A_ 2 _U_ 212 _N_ _S_ "LS" _N_ _N_ #-}
_showRational :: Int -> Ratio Integer -> [Char]
{-# GHC_PRAGMA _A_ 2 _U_ 21 _N_ _S_ "LU(U(PPP)L)" {_A_ 5 _U_ 22222 _N_ _N_ _N_ _N_} _N_ _N_ #-}
-_truncate :: (RealFrac a, Integral b) => a -> b
- {-# GHC_PRAGMA _A_ 2 _U_ 122 _N_ _S_ "U(AASAAAA)L" {_A_ 2 _U_ 122 _N_ _N_ _N_ _N_} _N_ _SPECIALISE_ [ Double, Int ] 2 { _A_ 0 _U_ 2 _N_ _N_ _N_ _N_ } #-}
interact :: ([Char] -> [Char]) -> _State _RealWorld -> (Either IOError13 (), _State _RealWorld)
{-# GHC_PRAGMA _A_ 2 _U_ 11 _N_ _S_ "LU(P)" {_A_ 2 _U_ 12 _N_ _N_ _N_ _N_} _N_ _N_ #-}
(!!) :: Integral a => [b] -> a -> b
(++) :: [a] -> [a] -> [a]
{-# GHC_PRAGMA _A_ 2 _U_ 12 _N_ _S_ "SL" _N_ _N_ #-}
(\\) :: Eq a => [a] -> [a] -> [a]
- {-# GHC_PRAGMA _A_ 3 _U_ 122 _N_ _S_ "LLS" _N_ _N_ #-}
+ {-# GHC_PRAGMA _A_ 3 _U_ 122 _N_ _S_ "LLS" _N_ _SPECIALISE_ [ Int ] 1 { _A_ 2 _U_ 22 _N_ _S_ "LS" _N_ _N_ }, [ [Char] ] 1 { _A_ 2 _U_ 22 _N_ _S_ "LS" _N_ _N_ } #-}
all :: (a -> Bool) -> [a] -> Bool
{-# GHC_PRAGMA _A_ 2 _U_ 21 _N_ _S_ "LS" _F_ _ALWAYS_ _/\_ u0 -> \ (u1 :: u0 -> Bool) (u2 :: [u0]) -> let {(u3 :: Bool) = _!_ True [] []} in let {(u6 :: u0 -> Bool -> Bool) = \ (u4 :: u0) (u5 :: Bool) -> case _APP_ u1 [ u4 ] of { _ALG_ True -> u5; False -> _!_ False [] []; _NO_DEFLT_ }} in _APP_ _TYAPP_ _TYAPP_ foldr { u0 } { Bool } [ u6, u3, u2 ] _N_ #-}
and :: [Bool] -> Bool
dropWhile :: (a -> Bool) -> [a] -> [a]
{-# GHC_PRAGMA _A_ 2 _U_ 21 _N_ _S_ "LS" _N_ _N_ #-}
elem :: Eq a => a -> [a] -> Bool
- {-# GHC_PRAGMA _A_ 3 _U_ 121 _N_ _S_ "LLS" _F_ _ALWAYS_ _/\_ u0 -> \ (u1 :: {{Eq u0}}) (u2 :: u0) (u3 :: [u0]) -> let {(u6 :: u0 -> u0 -> Bool) = case u1 of { _ALG_ _TUP_2 (u4 :: u0 -> u0 -> Bool) (u5 :: u0 -> u0 -> Bool) -> u4; _NO_DEFLT_ }} in let {(u8 :: u0 -> Bool) = \ (u7 :: u0) -> _APP_ u6 [ u2, u7 ]} in _APP_ _TYAPP_ _ORIG_ PreludeList any { u0 } [ u8, u3 ] _SPECIALISE_ [ Char ] 1 { _A_ 2 _U_ 21 _N_ _S_ "LS" _F_ _ALWAYS_ \ (u0 :: Char) (u1 :: [Char]) -> let {(u5 :: Char -> Bool) = \ (u2 :: Char) -> case u0 of { _ALG_ C# (u3 :: Char#) -> case u2 of { _ALG_ C# (u4 :: Char#) -> _#_ eqChar# [] [u3, u4]; _NO_DEFLT_ }; _NO_DEFLT_ }} in _APP_ _TYAPP_ _ORIG_ PreludeList any { Char } [ u5, u1 ] _N_ }, [ Int ] 1 { _A_ 2 _U_ 21 _N_ _S_ "LS" _F_ _ALWAYS_ \ (u0 :: Int) (u1 :: [Int]) -> let {(u5 :: Int -> Bool) = \ (u2 :: Int) -> case u0 of { _ALG_ I# (u3 :: Int#) -> case u2 of { _ALG_ I# (u4 :: Int#) -> _#_ eqInt# [] [u3, u4]; _NO_DEFLT_ }; _NO_DEFLT_ }} in _APP_ _TYAPP_ _ORIG_ PreludeList any { Int } [ u5, u1 ] _N_ }, [ [Char] ] 1 { _A_ 2 _U_ 21 _N_ _S_ "LS" _F_ _ALWAYS_ \ (u0 :: [Char]) (u1 :: [[Char]]) -> let {(u3 :: [Char] -> Bool) = \ (u2 :: [Char]) -> _APP_ _CONSTM_ Eq (==) ([Char]) [ u0, u2 ]} in _APP_ _TYAPP_ _ORIG_ PreludeList any { [Char] } [ u3, u1 ] _N_ } #-}
+ {-# GHC_PRAGMA _A_ 3 _U_ 121 _N_ _S_ "LLS" _F_ _ALWAYS_ _/\_ u0 -> \ (u1 :: {{Eq u0}}) (u2 :: u0) (u3 :: [u0]) -> let {(u6 :: u0 -> u0 -> Bool) = case u1 of { _ALG_ _TUP_2 (u4 :: u0 -> u0 -> Bool) (u5 :: u0 -> u0 -> Bool) -> u4; _NO_DEFLT_ }} in let {(u8 :: u0 -> Bool) = \ (u7 :: u0) -> _APP_ u6 [ u2, u7 ]} in _APP_ _TYAPP_ _ORIG_ PreludeList any { u0 } [ u8, u3 ] _SPECIALISE_ [ Char ] 1 { _A_ 2 _U_ 21 _N_ _S_ "LS" _F_ _ALWAYS_ \ (u0 :: Char) (u1 :: [Char]) -> let {(u5 :: Char -> Bool) = \ (u2 :: Char) -> case u0 of { _ALG_ C# (u3 :: Char#) -> case u2 of { _ALG_ C# (u4 :: Char#) -> _#_ eqChar# [] [u3, u4]; _NO_DEFLT_ }; _NO_DEFLT_ }} in _APP_ _TYAPP_ _ORIG_ PreludeList any { Char } [ u5, u1 ] _N_ }, [ Int ] 1 { _A_ 2 _U_ 21 _N_ _S_ "LS" _F_ _ALWAYS_ \ (u0 :: Int) (u1 :: [Int]) -> let {(u5 :: Int -> Bool) = \ (u2 :: Int) -> case u0 of { _ALG_ I# (u3 :: Int#) -> case u2 of { _ALG_ I# (u4 :: Int#) -> _#_ eqInt# [] [u3, u4]; _NO_DEFLT_ }; _NO_DEFLT_ }} in _APP_ _TYAPP_ _ORIG_ PreludeList any { Int } [ u5, u1 ] _N_ }, [ Integer ] 1 { _A_ 2 _U_ 21 _N_ _S_ "LS" _F_ _ALWAYS_ \ (u0 :: Integer) (u1 :: [Integer]) -> let {(ua :: Integer -> Bool) = \ (u2 :: Integer) -> case u0 of { _ALG_ J# (u3 :: Int#) (u4 :: Int#) (u5 :: ByteArray#) -> case u2 of { _ALG_ J# (u6 :: Int#) (u7 :: Int#) (u8 :: ByteArray#) -> case _#_ cmpInteger# [] [u3, u4, u5, u6, u7, u8] of { _PRIM_ 0# -> _!_ True [] []; (u9 :: Int#) -> _!_ False [] [] }; _NO_DEFLT_ }; _NO_DEFLT_ }} in _APP_ _TYAPP_ _ORIG_ PreludeList any { Integer } [ ua, u1 ] _N_ }, [ [Char] ] 1 { _A_ 2 _U_ 21 _N_ _S_ "LS" _F_ _ALWAYS_ \ (u0 :: [Char]) (u1 :: [[Char]]) -> let {(u3 :: [Char] -> Bool) = \ (u2 :: [Char]) -> _APP_ _CONSTM_ Eq (==) ([Char]) [ u0, u2 ]} in _APP_ _TYAPP_ _ORIG_ PreludeList any { [Char] } [ u3, u1 ] _N_ }, [ [Int] ] 1 { _A_ 2 _U_ 21 _N_ _S_ "LS" _F_ _ALWAYS_ \ (u0 :: [Int]) (u1 :: [[Int]]) -> let {(u3 :: [Int] -> Bool) = \ (u2 :: [Int]) -> _APP_ _CONSTM_ Eq (==) ([Int]) [ u0, u2 ]} in _APP_ _TYAPP_ _ORIG_ PreludeList any { [Int] } [ u3, u1 ] _N_ }, [ (Int, Int) ] 1 { _A_ 2 _U_ 21 _N_ _S_ "LS" _F_ _ALWAYS_ \ (u0 :: (Int, Int)) (u1 :: [(Int, Int)]) -> let {(ub :: (Int, Int) -> Bool) = \ (u2 :: (Int, Int)) -> case u0 of { _ALG_ _TUP_2 (u3 :: Int) (u4 :: Int) -> case u3 of { _ALG_ I# (u5 :: Int#) -> case u2 of { _ALG_ _TUP_2 (u6 :: Int) (u7 :: Int) -> case u6 of { _ALG_ I# (u8 :: Int#) -> case _#_ eqInt# [] [u5, u8] of { _ALG_ True -> case u4 of { _ALG_ I# (u9 :: Int#) -> case u7 of { _ALG_ I# (ua :: Int#) -> _#_ eqInt# [] [u9, ua]; _NO_DEFLT_ }; _NO_DEFLT_ }; False -> _!_ False [] []; _NO_DEFLT_ }; _NO_DEFLT_ }; _NO_DEFLT_ }; _NO_DEFLT_ }; _NO_DEFLT_ }} in _APP_ _TYAPP_ _ORIG_ PreludeList any { (Int, Int) } [ ub, u1 ] _N_ } #-}
filter :: (a -> Bool) -> [a] -> [a]
{-# GHC_PRAGMA _A_ 2 _U_ 21 _N_ _S_ "LS" _F_ _ALWAYS_ _/\_ u0 -> \ (u1 :: u0 -> Bool) (u2 :: [u0]) -> let {(u9 :: _forall_ a$z1 =>(u0 -> a$z1 -> a$z1) -> a$z1 -> a$z1) = _/\_ u3 -> \ (u4 :: u0 -> u3 -> u3) (u5 :: u3) -> let {(u8 :: u0 -> u3 -> u3) = \ (u6 :: u0) (u7 :: u3) -> case _APP_ u1 [ u6 ] of { _ALG_ True -> _APP_ u4 [ u6, u7 ]; False -> u7; _NO_DEFLT_ }} in _APP_ _TYAPP_ _TYAPP_ foldr { u0 } { u3 } [ u8, u5, u2 ]} in _APP_ _TYAPP_ _build { u0 } [ u9 ] _N_ #-}
foldl1 :: (a -> a -> a) -> [a] -> a
foldr1 :: (a -> a -> a) -> [a] -> a
{-# GHC_PRAGMA _A_ 2 _U_ 21 _N_ _S_ "LS" _N_ _N_ #-}
genericLength :: Num b => [a] -> b
- {-# GHC_PRAGMA _A_ 1 _U_ 21 _N_ _N_ _N_ _N_ #-}
+ {-# GHC_PRAGMA _A_ 1 _U_ 21 _N_ _N_ _N_ _SPECIALISE_ [ _N_, Int ] 1 { _A_ 1 _U_ 1 _N_ _S_ "S" _N_ _N_ }, [ _N_, Integer ] 1 { _A_ 1 _U_ 1 _N_ _S_ "S" _N_ _N_ } #-}
head :: [a] -> a
{-# GHC_PRAGMA _A_ 1 _U_ 1 _N_ _S_ "S" _F_ _ALWAYS_ _/\_ u0 -> \ (u1 :: [u0]) -> let {(u2 :: u0) = _APP_ _TYAPP_ error { u0 } [ _NOREP_S_ "head{PreludeList}: head []\n" ]} in let {(u5 :: u0 -> u0 -> u0) = \ (u3 :: u0) (u4 :: u0) -> u3} in _APP_ _TYAPP_ _TYAPP_ foldr { u0 } { u0 } [ u5, u2, u1 ] _N_ #-}
init :: [a] -> [a]
map :: (a -> b) -> [a] -> [b]
{-# GHC_PRAGMA _A_ 2 _U_ 21 _N_ _S_ "LS" _F_ _ALWAYS_ _/\_ u0 u1 -> \ (u2 :: u0 -> u1) (u3 :: [u0]) -> let {(ua :: _forall_ a$z1 =>(u1 -> a$z1 -> a$z1) -> a$z1 -> a$z1) = _/\_ u4 -> \ (u5 :: u1 -> u4 -> u4) (u6 :: u4) -> let {(u9 :: u0 -> u4 -> u4) = \ (u7 :: u0) -> let {(u8 :: u1) = _APP_ u2 [ u7 ]} in _APP_ u5 [ u8 ]} in _APP_ _TYAPP_ _TYAPP_ foldr { u0 } { u4 } [ u9, u6, u3 ]} in _APP_ _TYAPP_ _build { u1 } [ ua ] _N_ #-}
maximum :: Ord a => [a] -> a
- {-# GHC_PRAGMA _A_ 1 _U_ 11 _N_ _N_ _N_ _N_ #-}
+ {-# GHC_PRAGMA _A_ 1 _U_ 11 _N_ _N_ _N_ _SPECIALISE_ [ Double ] 1 { _A_ 1 _U_ 1 _N_ _S_ "S" _N_ _N_ }, [ Int ] 1 { _A_ 1 _U_ 1 _N_ _S_ "S" _N_ _N_ }, [ Integer ] 1 { _A_ 1 _U_ 1 _N_ _S_ "S" _N_ _N_ } #-}
minimum :: Ord a => [a] -> a
- {-# GHC_PRAGMA _A_ 1 _U_ 11 _N_ _N_ _N_ _N_ #-}
+ {-# GHC_PRAGMA _A_ 1 _U_ 11 _N_ _N_ _N_ _SPECIALISE_ [ Double ] 1 { _A_ 1 _U_ 1 _N_ _S_ "S" _N_ _N_ }, [ Int ] 1 { _A_ 1 _U_ 1 _N_ _S_ "S" _N_ _N_ }, [ Integer ] 1 { _A_ 1 _U_ 1 _N_ _S_ "S" _N_ _N_ } #-}
notElem :: Eq a => a -> [a] -> Bool
- {-# GHC_PRAGMA _A_ 3 _U_ 121 _N_ _S_ "LLS" _F_ _ALWAYS_ _/\_ u0 -> \ (u1 :: {{Eq u0}}) (u2 :: u0) (u3 :: [u0]) -> let {(u6 :: u0 -> u0 -> Bool) = case u1 of { _ALG_ _TUP_2 (u4 :: u0 -> u0 -> Bool) (u5 :: u0 -> u0 -> Bool) -> u5; _NO_DEFLT_ }} in let {(u8 :: u0 -> Bool) = \ (u7 :: u0) -> _APP_ u6 [ u2, u7 ]} in _APP_ _TYAPP_ _ORIG_ PreludeList all { u0 } [ u8, u3 ] _SPECIALISE_ [ Char ] 1 { _A_ 2 _U_ 21 _N_ _S_ "LS" _F_ _ALWAYS_ \ (u0 :: Char) (u1 :: [Char]) -> let {(u5 :: Char -> Bool) = \ (u2 :: Char) -> case u0 of { _ALG_ C# (u3 :: Char#) -> case u2 of { _ALG_ C# (u4 :: Char#) -> _#_ neChar# [] [u3, u4]; _NO_DEFLT_ }; _NO_DEFLT_ }} in _APP_ _TYAPP_ _ORIG_ PreludeList all { Char } [ u5, u1 ] _N_ }, [ Int ] 1 { _A_ 2 _U_ 21 _N_ _S_ "LS" _F_ _ALWAYS_ \ (u0 :: Int) (u1 :: [Int]) -> let {(u5 :: Int -> Bool) = \ (u2 :: Int) -> case u0 of { _ALG_ I# (u3 :: Int#) -> case u2 of { _ALG_ I# (u4 :: Int#) -> _#_ neInt# [] [u3, u4]; _NO_DEFLT_ }; _NO_DEFLT_ }} in _APP_ _TYAPP_ _ORIG_ PreludeList all { Int } [ u5, u1 ] _N_ }, [ [Char] ] 1 { _A_ 2 _U_ 21 _N_ _S_ "LS" _F_ _ALWAYS_ \ (u0 :: [Char]) (u1 :: [[Char]]) -> let {(u3 :: [Char] -> Bool) = \ (u2 :: [Char]) -> _APP_ _CONSTM_ Eq (/=) ([Char]) [ u0, u2 ]} in _APP_ _TYAPP_ _ORIG_ PreludeList all { [Char] } [ u3, u1 ] _N_ } #-}
+ {-# GHC_PRAGMA _A_ 3 _U_ 121 _N_ _S_ "LLS" _F_ _ALWAYS_ _/\_ u0 -> \ (u1 :: {{Eq u0}}) (u2 :: u0) (u3 :: [u0]) -> let {(u6 :: u0 -> u0 -> Bool) = case u1 of { _ALG_ _TUP_2 (u4 :: u0 -> u0 -> Bool) (u5 :: u0 -> u0 -> Bool) -> u5; _NO_DEFLT_ }} in let {(u8 :: u0 -> Bool) = \ (u7 :: u0) -> _APP_ u6 [ u2, u7 ]} in _APP_ _TYAPP_ _ORIG_ PreludeList all { u0 } [ u8, u3 ] _SPECIALISE_ [ Char ] 1 { _A_ 2 _U_ 21 _N_ _S_ "LS" _F_ _ALWAYS_ \ (u0 :: Char) (u1 :: [Char]) -> let {(u5 :: Char -> Bool) = \ (u2 :: Char) -> case u0 of { _ALG_ C# (u3 :: Char#) -> case u2 of { _ALG_ C# (u4 :: Char#) -> _#_ neChar# [] [u3, u4]; _NO_DEFLT_ }; _NO_DEFLT_ }} in _APP_ _TYAPP_ _ORIG_ PreludeList all { Char } [ u5, u1 ] _N_ }, [ Int ] 1 { _A_ 2 _U_ 21 _N_ _S_ "LS" _F_ _ALWAYS_ \ (u0 :: Int) (u1 :: [Int]) -> let {(u5 :: Int -> Bool) = \ (u2 :: Int) -> case u0 of { _ALG_ I# (u3 :: Int#) -> case u2 of { _ALG_ I# (u4 :: Int#) -> _#_ neInt# [] [u3, u4]; _NO_DEFLT_ }; _NO_DEFLT_ }} in _APP_ _TYAPP_ _ORIG_ PreludeList all { Int } [ u5, u1 ] _N_ }, [ Integer ] 1 { _A_ 2 _U_ 21 _N_ _S_ "LS" _F_ _ALWAYS_ \ (u0 :: Integer) (u1 :: [Integer]) -> let {(ua :: Integer -> Bool) = \ (u2 :: Integer) -> case u0 of { _ALG_ J# (u3 :: Int#) (u4 :: Int#) (u5 :: ByteArray#) -> case u2 of { _ALG_ J# (u6 :: Int#) (u7 :: Int#) (u8 :: ByteArray#) -> case _#_ cmpInteger# [] [u3, u4, u5, u6, u7, u8] of { _PRIM_ 0# -> _!_ False [] []; (u9 :: Int#) -> _!_ True [] [] }; _NO_DEFLT_ }; _NO_DEFLT_ }} in _APP_ _TYAPP_ _ORIG_ PreludeList all { Integer } [ ua, u1 ] _N_ }, [ [Char] ] 1 { _A_ 2 _U_ 21 _N_ _S_ "LS" _F_ _ALWAYS_ \ (u0 :: [Char]) (u1 :: [[Char]]) -> let {(u3 :: [Char] -> Bool) = \ (u2 :: [Char]) -> _APP_ _CONSTM_ Eq (/=) ([Char]) [ u0, u2 ]} in _APP_ _TYAPP_ _ORIG_ PreludeList all { [Char] } [ u3, u1 ] _N_ }, [ (Int, Int) ] 1 { _A_ 2 _U_ 21 _N_ _S_ "LS" _F_ _ALWAYS_ \ (u0 :: (Int, Int)) (u1 :: [(Int, Int)]) -> let {(ub :: (Int, Int) -> Bool) = \ (u2 :: (Int, Int)) -> case u0 of { _ALG_ _TUP_2 (u3 :: Int) (u4 :: Int) -> case u3 of { _ALG_ I# (u5 :: Int#) -> case u2 of { _ALG_ _TUP_2 (u6 :: Int) (u7 :: Int) -> case u6 of { _ALG_ I# (u8 :: Int#) -> case _#_ neInt# [] [u5, u8] of { _ALG_ True -> _!_ True [] []; False -> case u4 of { _ALG_ I# (u9 :: Int#) -> case u7 of { _ALG_ I# (ua :: Int#) -> _#_ neInt# [] [u9, ua]; _NO_DEFLT_ }; _NO_DEFLT_ }; _NO_DEFLT_ }; _NO_DEFLT_ }; _NO_DEFLT_ }; _NO_DEFLT_ }; _NO_DEFLT_ }} in _APP_ _TYAPP_ _ORIG_ PreludeList all { (Int, Int) } [ ub, u1 ] _N_ } #-}
nub :: Eq a => [a] -> [a]
- {-# GHC_PRAGMA _A_ 2 _U_ 11 _N_ _S_ "LS" _N_ _N_ #-}
+ {-# GHC_PRAGMA _A_ 2 _U_ 11 _N_ _S_ "LS" _N_ _SPECIALISE_ [ Int ] 1 { _A_ 1 _U_ 1 _N_ _S_ "S" _N_ _N_ }, [ [Char] ] 1 { _A_ 1 _U_ 1 _N_ _S_ "S" _N_ _N_ }, [ [Int] ] 1 { _A_ 1 _U_ 1 _N_ _S_ "S" _N_ _N_ } #-}
null :: [a] -> Bool
{-# GHC_PRAGMA _A_ 1 _U_ 1 _N_ _S_ "S" _F_ _ALWAYS_ _/\_ u0 -> \ (u1 :: [u0]) -> let {(u2 :: Bool) = _!_ True [] []} in let {(u5 :: u0 -> Bool -> Bool) = \ (u3 :: u0) (u4 :: Bool) -> _!_ False [] []} in _APP_ _TYAPP_ _TYAPP_ foldr { u0 } { Bool } [ u5, u2, u1 ] _N_ #-}
or :: [Bool] -> Bool
partition :: (a -> Bool) -> [a] -> ([a], [a])
{-# GHC_PRAGMA _A_ 2 _U_ 21 _N_ _S_ "LS" _F_ _ALWAYS_ _/\_ u0 -> \ (u1 :: u0 -> Bool) (u2 :: [u0]) -> let {(u9 :: u0 -> ([u0], [u0]) -> ([u0], [u0])) = \ (u3 :: u0) (u4 :: ([u0], [u0])) -> case u4 of { _ALG_ _TUP_2 (u5 :: [u0]) (u6 :: [u0]) -> case _APP_ u1 [ u3 ] of { _ALG_ True -> let {(u7 :: [u0]) = _!_ (:) [u0] [u3, u5]} in _!_ _TUP_2 [[u0], [u0]] [u7, u6]; False -> let {(u8 :: [u0]) = _!_ (:) [u0] [u3, u6]} in _!_ _TUP_2 [[u0], [u0]] [u5, u8]; _NO_DEFLT_ }; _NO_DEFLT_ }} in let {(ua :: [u0]) = _!_ _NIL_ [u0] []} in let {(ub :: ([u0], [u0])) = _!_ _TUP_2 [[u0], [u0]] [ua, ua]} in _APP_ _TYAPP_ _TYAPP_ foldr { u0 } { ([u0], [u0]) } [ u9, ub, u2 ] _N_ #-}
product :: Num a => [a] -> a
- {-# GHC_PRAGMA _A_ 1 _U_ 22 _N_ _N_ _F_ _ALWAYS_ _/\_ u0 -> \ (u1 :: {{Num u0}}) -> let {(uc :: u0 -> u0 -> u0) = case u1 of { _ALG_ _TUP_10 (u2 :: {{Eq u0}}) (u3 :: {{Text u0}}) (u4 :: u0 -> u0 -> u0) (u5 :: u0 -> u0 -> u0) (u6 :: u0 -> u0 -> u0) (u7 :: u0 -> u0) (u8 :: u0 -> u0) (u9 :: u0 -> u0) (ua :: Integer -> u0) (ub :: Int -> u0) -> u6; _NO_DEFLT_ }} in let {(uo :: u0) = let {(ud :: Int) = _!_ I# [] [1#]} in case u1 of { _ALG_ _TUP_10 (ue :: {{Eq u0}}) (uf :: {{Text u0}}) (ug :: u0 -> u0 -> u0) (uh :: u0 -> u0 -> u0) (ui :: u0 -> u0 -> u0) (uj :: u0 -> u0) (uk :: u0 -> u0) (ul :: u0 -> u0) (um :: Integer -> u0) (un :: Int -> u0) -> _APP_ un [ ud ]; _NO_DEFLT_ }} in \ (up :: [u0]) -> _APP_ _TYAPP_ _TYAPP_ foldl { u0 } { u0 } [ uc, uo, up ] _SPECIALISE_ [ Double ] 1 { _A_ 1 _U_ 1 _N_ _S_ "S" _F_ _ALWAYS_ \ (u0 :: [Double]) -> let {(u1 :: Double) = _!_ D# [] [1.0000000000000000##]} in _APP_ _TYAPP_ _TYAPP_ foldl { Double } { Double } [ _CONSTM_ Num (*) (Double), u1, u0 ] _N_ }, [ Int ] 1 { _A_ 1 _U_ 1 _N_ _S_ "S" _F_ _ALWAYS_ \ (u0 :: [Int]) -> let {(u1 :: Int) = _!_ I# [] [1#]} in _APP_ _TYAPP_ _TYAPP_ foldl { Int } { Int } [ _CONSTM_ Num (*) (Int), u1, u0 ] _N_ }, [ Integer ] 1 { _A_ 1 _U_ 1 _N_ _S_ "S" _F_ _ALWAYS_ \ (u0 :: [Integer]) -> let {(u1 :: Integer) = _#_ int2Integer# [] [1#]} in _APP_ _TYAPP_ _TYAPP_ foldl { Integer } { Integer } [ _CONSTM_ Num (*) (Integer), u1, u0 ] _N_ } #-}
+ {-# GHC_PRAGMA _A_ 1 _U_ 22 _N_ _N_ _F_ _ALWAYS_ _/\_ u0 -> \ (u1 :: {{Num u0}}) -> let {(uc :: u0 -> u0 -> u0) = case u1 of { _ALG_ _TUP_10 (u2 :: {{Eq u0}}) (u3 :: {{Text u0}}) (u4 :: u0 -> u0 -> u0) (u5 :: u0 -> u0 -> u0) (u6 :: u0 -> u0 -> u0) (u7 :: u0 -> u0) (u8 :: u0 -> u0) (u9 :: u0 -> u0) (ua :: Integer -> u0) (ub :: Int -> u0) -> u6; _NO_DEFLT_ }} in let {(uo :: u0) = let {(ud :: Int) = _!_ I# [] [1#]} in case u1 of { _ALG_ _TUP_10 (ue :: {{Eq u0}}) (uf :: {{Text u0}}) (ug :: u0 -> u0 -> u0) (uh :: u0 -> u0 -> u0) (ui :: u0 -> u0 -> u0) (uj :: u0 -> u0) (uk :: u0 -> u0) (ul :: u0 -> u0) (um :: Integer -> u0) (un :: Int -> u0) -> _APP_ un [ ud ]; _NO_DEFLT_ }} in \ (up :: [u0]) -> _APP_ _TYAPP_ _TYAPP_ foldl { u0 } { u0 } [ uc, uo, up ] _SPECIALISE_ [ Double ] 1 { _A_ 1 _U_ 1 _N_ _S_ "S" _F_ _ALWAYS_ \ (u0 :: [Double]) -> let {(u1 :: Double) = _!_ D# [] [1.0000000000000000##]} in _APP_ _TYAPP_ _TYAPP_ foldl { Double } { Double } [ _CONSTM_ Num (*) (Double), u1, u0 ] _N_ }, [ Int ] 1 { _A_ 1 _U_ 1 _N_ _S_ "S" _F_ _ALWAYS_ \ (u0 :: [Int]) -> let {(u1 :: Int) = _!_ I# [] [1#]} in _APP_ _TYAPP_ _TYAPP_ foldl { Int } { Int } [ _CONSTM_ Num (*) (Int), u1, u0 ] _N_ }, [ Integer ] 1 { _A_ 1 _U_ 1 _N_ _S_ "S" _F_ _ALWAYS_ \ (u0 :: [Integer]) -> let {(u1 :: Integer) = _#_ int2Integer# [] [1#]} in _APP_ _TYAPP_ _TYAPP_ foldl { Integer } { Integer } [ _CONSTM_ Num (*) (Integer), u1, u0 ] _N_ }, [ (Complex Double) ] 1 { _A_ 1 _U_ 1 _N_ _S_ "S" _F_ _ALWAYS_ let {(u6 :: Complex Double -> Complex Double -> Complex Double) = \ (u0 :: Complex Double) (u1 :: Complex Double) -> case u0 of { _ALG_ (:+) (u2 :: Double) (u3 :: Double) -> case u1 of { _ALG_ (:+) (u4 :: Double) (u5 :: Double) -> _APP_ _WRKR_ _CONSTM_ Num (*) (Complex Double) [ u2, u3, u4, u5 ]; _NO_DEFLT_ }; _NO_DEFLT_ }} in let {(u8 :: Complex Double) = let {(u7 :: Int) = _!_ I# [] [1#]} in _APP_ _CONSTM_ Num fromInt (Complex Double) [ u7 ]} in \ (u9 :: [Complex Double]) -> _APP_ _TYAPP_ _TYAPP_ foldl { (Complex Double) } { (Complex Double) } [ u6, u8, u9 ] _N_ } #-}
products :: Num a => [a] -> [a]
- {-# GHC_PRAGMA _A_ 1 _U_ 21 _N_ _N_ _N_ _N_ #-}
+ {-# GHC_PRAGMA _A_ 1 _U_ 21 _N_ _N_ _N_ _SPECIALISE_ [ Double ] 1 { _A_ 1 _U_ 1 _N_ _N_ _N_ _N_ }, [ Int ] 1 { _A_ 1 _U_ 1 _N_ _N_ _N_ _N_ }, [ Integer ] 1 { _A_ 1 _U_ 1 _N_ _N_ _F_ _IF_ARGS_ 0 1 X 4 \ (u0 :: [Integer]) -> _APP_ _TYAPP_ _TYAPP_ _ORIG_ PreludeList scanl { Integer } { Integer } [ _CONSTM_ Num (*) (Integer), _SPEC_ _ORIG_ PreludeCore __i1 [ (Integer) ], u0 ] _N_ }, [ (Complex Double) ] 1 { _A_ 1 _U_ 1 _N_ _N_ _N_ _N_ } #-}
repeat :: a -> [a]
{-# GHC_PRAGMA _A_ 1 _U_ 2 _N_ _N_ _F_ _ALWAYS_ _/\_ u0 -> \ (u1 :: u0) -> let {(u6 :: _forall_ a$z1 =>(u0 -> a$z1 -> a$z1) -> a$z1 -> a$z1) = _/\_ u2 -> \ (u3 :: u0 -> u2 -> u2) (u4 :: u2) -> _LETREC_ {(u5 :: u2) = _APP_ u3 [ u1, u5 ]} in u5} in _APP_ _TYAPP_ _build { u0 } [ u6 ] _N_ #-}
reverse :: [a] -> [a]
sum :: Num a => [a] -> a
{-# GHC_PRAGMA _A_ 1 _U_ 22 _N_ _N_ _F_ _ALWAYS_ _/\_ u0 -> \ (u1 :: {{Num u0}}) -> let {(uc :: u0 -> u0 -> u0) = case u1 of { _ALG_ _TUP_10 (u2 :: {{Eq u0}}) (u3 :: {{Text u0}}) (u4 :: u0 -> u0 -> u0) (u5 :: u0 -> u0 -> u0) (u6 :: u0 -> u0 -> u0) (u7 :: u0 -> u0) (u8 :: u0 -> u0) (u9 :: u0 -> u0) (ua :: Integer -> u0) (ub :: Int -> u0) -> u4; _NO_DEFLT_ }} in let {(uo :: u0) = let {(ud :: Int) = _!_ I# [] [0#]} in case u1 of { _ALG_ _TUP_10 (ue :: {{Eq u0}}) (uf :: {{Text u0}}) (ug :: u0 -> u0 -> u0) (uh :: u0 -> u0 -> u0) (ui :: u0 -> u0 -> u0) (uj :: u0 -> u0) (uk :: u0 -> u0) (ul :: u0 -> u0) (um :: Integer -> u0) (un :: Int -> u0) -> _APP_ un [ ud ]; _NO_DEFLT_ }} in \ (up :: [u0]) -> _APP_ _TYAPP_ _TYAPP_ foldl { u0 } { u0 } [ uc, uo, up ] _SPECIALISE_ [ Double ] 1 { _A_ 1 _U_ 1 _N_ _S_ "S" _F_ _ALWAYS_ \ (u0 :: [Double]) -> let {(u1 :: Double) = _!_ D# [] [0.0000000000000000##]} in _APP_ _TYAPP_ _TYAPP_ foldl { Double } { Double } [ _CONSTM_ Num (+) (Double), u1, u0 ] _N_ }, [ Int ] 1 { _A_ 1 _U_ 1 _N_ _S_ "S" _F_ _ALWAYS_ \ (u0 :: [Int]) -> let {(u1 :: Int) = _!_ I# [] [0#]} in _APP_ _TYAPP_ _TYAPP_ foldl { Int } { Int } [ _CONSTM_ Num (+) (Int), u1, u0 ] _N_ }, [ Integer ] 1 { _A_ 1 _U_ 1 _N_ _S_ "S" _F_ _ALWAYS_ \ (u0 :: [Integer]) -> let {(u1 :: Integer) = _#_ int2Integer# [] [0#]} in _APP_ _TYAPP_ _TYAPP_ foldl { Integer } { Integer } [ _CONSTM_ Num (+) (Integer), u1, u0 ] _N_ }, [ (Complex Double) ] 1 { _A_ 1 _U_ 1 _N_ _S_ "S" _F_ _ALWAYS_ let {(u6 :: Complex Double -> Complex Double -> Complex Double) = \ (u0 :: Complex Double) (u1 :: Complex Double) -> case u0 of { _ALG_ (:+) (u2 :: Double) (u3 :: Double) -> case u1 of { _ALG_ (:+) (u4 :: Double) (u5 :: Double) -> _APP_ _WRKR_ _CONSTM_ Num (+) (Complex Double) [ u2, u3, u4, u5 ]; _NO_DEFLT_ }; _NO_DEFLT_ }} in let {(u8 :: Complex Double) = let {(u7 :: Int) = _!_ I# [] [0#]} in _APP_ _CONSTM_ Num fromInt (Complex Double) [ u7 ]} in \ (u9 :: [Complex Double]) -> _APP_ _TYAPP_ _TYAPP_ foldl { (Complex Double) } { (Complex Double) } [ u6, u8, u9 ] _N_ } #-}
sums :: Num a => [a] -> [a]
- {-# GHC_PRAGMA _A_ 1 _U_ 21 _N_ _N_ _N_ _N_ #-}
+ {-# GHC_PRAGMA _A_ 1 _U_ 21 _N_ _N_ _N_ _SPECIALISE_ [ Double ] 1 { _A_ 1 _U_ 1 _N_ _N_ _N_ _N_ }, [ Int ] 1 { _A_ 1 _U_ 1 _N_ _N_ _N_ _N_ }, [ Integer ] 1 { _A_ 1 _U_ 1 _N_ _N_ _F_ _IF_ARGS_ 0 1 X 4 \ (u0 :: [Integer]) -> _APP_ _TYAPP_ _TYAPP_ _ORIG_ PreludeList scanl { Integer } { Integer } [ _CONSTM_ Num (+) (Integer), _SPEC_ _ORIG_ PreludeCore __i0 [ (Integer) ], u0 ] _N_ }, [ (Complex Double) ] 1 { _A_ 1 _U_ 1 _N_ _N_ _N_ _N_ } #-}
tail :: [a] -> [a]
{-# GHC_PRAGMA _A_ 1 _U_ 1 _N_ _S_ "S" _F_ _IF_ARGS_ 1 1 C 5 _/\_ u0 -> \ (u1 :: [u0]) -> case u1 of { _ALG_ (:) (u2 :: u0) (u3 :: [u0]) -> u3; _NIL_ -> _APP_ _TYAPP_ error { [u0] } [ _NOREP_S_ "tail{PreludeList}: tail []\n" ]; _NO_DEFLT_ } _N_ #-}
take :: Integral a => a -> [b] -> [b]
- {-# GHC_PRAGMA _A_ 3 _U_ 121 _N_ _S_ "U(AAAAAAAAAAAS)LL" {_A_ 3 _U_ 121 _N_ _N_ _N_ _N_} _F_ _IF_ARGS_ 2 3 CXX 7 _/\_ u0 u1 -> \ (u2 :: {{Integral u0}}) (u3 :: u0) (u4 :: [u1]) -> let {(uh :: Int) = case u2 of { _ALG_ _TUP_12 (u5 :: {{Real u0}}) (u6 :: {{Ix u0}}) (u7 :: u0 -> u0 -> u0) (u8 :: u0 -> u0 -> u0) (u9 :: u0 -> u0 -> u0) (ua :: u0 -> u0 -> u0) (ub :: u0 -> u0 -> (u0, u0)) (uc :: u0 -> u0 -> (u0, u0)) (ud :: u0 -> Bool) (ue :: u0 -> Bool) (uf :: u0 -> Integer) (ug :: u0 -> Int) -> _APP_ ug [ u3 ]; _NO_DEFLT_ }} in _APP_ _TYAPP_ _SPEC_ _ORIG_ PreludeList take [ (Int), _N_ ] { u1 } [ uh, u4 ] _SPECIALISE_ [ Int, _N_ ] 1 { _A_ 2 _U_ 11 _N_ _S_ "U(P)L" {_A_ 2 _U_ 21 _N_ _N_ _N_ _N_} _N_ _N_ }, [ Integer, _N_ ] 1 { _A_ 2 _U_ 11 _N_ _S_ "U(PPP)L" {_A_ 4 _U_ 2221 _N_ _N_ _F_ _IF_ARGS_ 1 4 XXXX 4 _/\_ u0 -> \ (u1 :: Int#) (u2 :: Int#) (u3 :: ByteArray#) (u4 :: [u0]) -> case _#_ integer2Int# [] [u1, u2, u3] of { _PRIM_ (u5 :: Int#) -> _APP_ _TYAPP_ _WRKR_ _SPEC_ _ORIG_ PreludeList take [ (Int), _N_ ] { u0 } [ u5, u4 ] } _N_} _F_ _ALWAYS_ _/\_ u0 -> \ (u1 :: Integer) (u2 :: [u0]) -> case u1 of { _ALG_ J# (u3 :: Int#) (u4 :: Int#) (u5 :: ByteArray#) -> case _#_ integer2Int# [] [u3, u4, u5] of { _PRIM_ (u6 :: Int#) -> _APP_ _TYAPP_ _WRKR_ _SPEC_ _ORIG_ PreludeList take [ (Int), _N_ ] { u0 } [ u6, u2 ] }; _NO_DEFLT_ } _N_ } #-}
+ {-# GHC_PRAGMA _A_ 1 _U_ 122 _N_ _S_ "U(LU(U(ASSAAAAA)AAA)AAAALAAAAL)" {_A_ 5 _U_ 2121222 _N_ _N_ _N_ _N_} _N_ _SPECIALISE_ [ Int, _N_ ] 1 { _A_ 2 _U_ 11 _N_ _S_ "U(P)L" {_A_ 2 _U_ 21 _N_ _N_ _N_ _N_} _N_ _N_ }, [ Integer, _N_ ] 1 { _A_ 1 _U_ 12 _N_ _S_ "U(PPP)" {_A_ 3 _U_ 2222 _N_ _N_ _N_ _N_} _N_ _N_ } #-}
takeWhile :: (a -> Bool) -> [a] -> [a]
{-# GHC_PRAGMA _A_ 2 _U_ 21 _N_ _S_ "LS" _F_ _ALWAYS_ _/\_ u0 -> \ (u1 :: u0 -> Bool) (u2 :: [u0]) -> let {(u9 :: _forall_ a$z1 =>(u0 -> a$z1 -> a$z1) -> a$z1 -> a$z1) = _/\_ u3 -> \ (u4 :: u0 -> u3 -> u3) (u5 :: u3) -> let {(u8 :: u0 -> u3 -> u3) = \ (u6 :: u0) (u7 :: u3) -> case _APP_ u1 [ u6 ] of { _ALG_ True -> _APP_ u4 [ u6, u7 ]; False -> u5; _NO_DEFLT_ }} in _APP_ _TYAPP_ _TYAPP_ foldr { u0 } { u3 } [ u8, u5, u2 ]} in _APP_ _TYAPP_ _build { u0 } [ u9 ] _N_ #-}
transpose :: [[a]] -> [[a]]
lex :: [Char] -> [([Char], [Char])]
{-# GHC_PRAGMA _A_ 1 _U_ 2 _N_ _S_ "S" _N_ _N_ #-}
read :: Text a => [Char] -> a
- {-# GHC_PRAGMA _A_ 1 _U_ 12 _N_ _S_ "U(SAAA)" {_A_ 1 _U_ 12 _N_ _N_ _N_ _N_} _N_ _SPECIALISE_ [ Double ] 1 { _A_ 1 _U_ 2 _N_ _N_ _N_ _N_ }, [ Float ] 1 { _A_ 1 _U_ 2 _N_ _N_ _N_ _N_ }, [ Int ] 1 { _A_ 1 _U_ 2 _N_ _N_ _N_ _N_ }, [ Integer ] 1 { _A_ 1 _U_ 2 _N_ _N_ _N_ _N_ } #-}
+ {-# GHC_PRAGMA _A_ 1 _U_ 12 _N_ _S_ "U(SAAA)" {_A_ 1 _U_ 12 _N_ _N_ _N_ _N_} _N_ _SPECIALISE_ [ Bool ] 1 { _A_ 1 _U_ 2 _N_ _N_ _N_ _N_ }, [ Char ] 1 { _A_ 1 _U_ 2 _N_ _N_ _N_ _N_ }, [ Double ] 1 { _A_ 1 _U_ 2 _N_ _N_ _N_ _N_ }, [ Int ] 1 { _A_ 1 _U_ 2 _N_ _N_ _N_ _N_ }, [ Integer ] 1 { _A_ 1 _U_ 2 _N_ _N_ _N_ _N_ }, [ [Bool] ] 1 { _A_ 1 _U_ 2 _N_ _N_ _N_ _N_ }, [ [Char] ] 1 { _A_ 1 _U_ 2 _N_ _N_ _N_ _N_ }, [ [Double] ] 1 { _A_ 1 _U_ 2 _N_ _N_ _N_ _N_ }, [ [Float] ] 1 { _A_ 1 _U_ 2 _N_ _N_ _N_ _N_ }, [ [Int] ] 1 { _A_ 1 _U_ 2 _N_ _N_ _N_ _N_ }, [ [Integer] ] 1 { _A_ 1 _U_ 2 _N_ _N_ _N_ _N_ }, [ [[Char]] ] 1 { _A_ 1 _U_ 2 _N_ _N_ _N_ _N_ }, [ [[Int]] ] 1 { _A_ 1 _U_ 2 _N_ _N_ _N_ _N_ }, [ [Complex Double] ] 1 { _A_ 1 _U_ 2 _N_ _N_ _N_ _N_ }, [ (Ratio Integer) ] 1 { _A_ 1 _U_ 2 _N_ _N_ _N_ _N_ }, [ (Array Int Double) ] 1 { _A_ 1 _U_ 2 _N_ _N_ _N_ _N_ }, [ (Array (Int, Int) Double) ] 1 { _A_ 1 _U_ 2 _N_ _N_ _N_ _N_ }, [ _PackedString ] 1 { _A_ 1 _U_ 2 _N_ _S_ _!_ _N_ _N_ }, [ (Complex Double) ] 1 { _A_ 1 _U_ 2 _N_ _N_ _N_ _N_ }, [ () ] 1 { _A_ 1 _U_ 2 _N_ _N_ _N_ _N_ }, [ (Int, Int) ] 1 { _A_ 1 _U_ 2 _N_ _N_ _N_ _N_ }, [ (Integer, Integer) ] 1 { _A_ 1 _U_ 2 _N_ _N_ _N_ _N_ }, [ (Int, Int, Int) ] 1 { _A_ 1 _U_ 2 _N_ _N_ _N_ _N_ } #-}
readDec :: Integral a => [Char] -> [(a, [Char])]
- {-# GHC_PRAGMA _A_ 1 _U_ 22 _N_ _N_ _N_ _SPECIALISE_ [ Int ] 1 { _A_ 0 _U_ 2 _N_ _N_ _N_ _N_ }, [ Integer ] 1 { _A_ 1 _U_ 2 _N_ _S_ "S" _N_ _N_ } #-}
+ {-# GHC_PRAGMA _A_ 1 _U_ 22 _N_ _N_ _N_ _SPECIALISE_ [ Int ] 1 { _A_ 0 _U_ 2 _N_ _N_ _N_ _N_ }, [ Integer ] 1 { _A_ 0 _U_ 2 _N_ _N_ _N_ _N_ } #-}
readFloat :: RealFloat a => [Char] -> [(a, [Char])]
- {-# GHC_PRAGMA _A_ 2 _U_ 12 _N_ _S_ "LS" _N_ _SPECIALISE_ [ Double ] 1 { _A_ 1 _U_ 2 _N_ _S_ "S" _N_ _N_ }, [ Float ] 1 { _A_ 1 _U_ 2 _N_ _S_ "S" _N_ _N_ } #-}
+ {-# GHC_PRAGMA _A_ 2 _U_ 12 _N_ _S_ "LS" _N_ _SPECIALISE_ [ Double ] 1 { _A_ 1 _U_ 2 _N_ _S_ "S" _N_ _N_ } #-}
readLitChar :: [Char] -> [(Char, [Char])]
{-# GHC_PRAGMA _A_ 0 _U_ 1 _N_ _N_ _N_ _N_ #-}
readParen :: Bool -> ([Char] -> [(a, [Char])]) -> [Char] -> [(a, [Char])]
readSigned :: Real a => ([Char] -> [(a, [Char])]) -> [Char] -> [(a, [Char])]
{-# GHC_PRAGMA _A_ 2 _U_ 122 _N_ _N_ _N_ _SPECIALISE_ [ Double ] 1 { _A_ 1 _U_ 22 _N_ _N_ _N_ _N_ }, [ Int ] 1 { _A_ 1 _U_ 22 _N_ _N_ _N_ _N_ }, [ Integer ] 1 { _A_ 1 _U_ 22 _N_ _N_ _N_ _N_ } #-}
reads :: Text a => [Char] -> [(a, [Char])]
- {-# GHC_PRAGMA _A_ 1 _U_ 12 _N_ _S_ "U(SAAA)" {_A_ 1 _U_ 12 _N_ _N_ _N_ _N_} _N_ _SPECIALISE_ [ Double ] 1 { _A_ 1 _U_ 2 _N_ _N_ _N_ _N_ }, [ Float ] 1 { _A_ 1 _U_ 2 _N_ _N_ _N_ _N_ }, [ Int ] 1 { _A_ 1 _U_ 2 _N_ _N_ _N_ _N_ }, [ Integer ] 1 { _A_ 1 _U_ 2 _N_ _N_ _N_ _N_ } #-}
+ {-# GHC_PRAGMA _A_ 1 _U_ 12 _N_ _S_ "U(SAAA)" {_A_ 1 _U_ 12 _N_ _N_ _N_ _N_} _N_ _SPECIALISE_ [ Bool ] 1 { _A_ 1 _U_ 2 _N_ _N_ _N_ _N_ }, [ Char ] 1 { _A_ 0 _U_ 2 _N_ _N_ _N_ _N_ }, [ Double ] 1 { _A_ 1 _U_ 2 _N_ _N_ _N_ _N_ }, [ Int ] 1 { _A_ 1 _U_ 2 _N_ _N_ _N_ _N_ }, [ Integer ] 1 { _A_ 1 _U_ 2 _N_ _N_ _N_ _N_ }, [ [Bool] ] 1 { _A_ 0 _U_ 2 _N_ _N_ _F_ _IF_ARGS_ 0 0 X 1 _CONSTM_ Text readList (Bool) _N_ }, [ [Char] ] 1 { _A_ 0 _U_ 2 _N_ _N_ _F_ _IF_ARGS_ 0 0 X 1 _CONSTM_ Text readList (Char) _N_ }, [ [Double] ] 1 { _A_ 0 _U_ 2 _N_ _N_ _F_ _IF_ARGS_ 0 0 X 1 _CONSTM_ Text readList (Double) _N_ }, [ [Float] ] 1 { _A_ 0 _U_ 2 _N_ _N_ _N_ _N_ }, [ [Int] ] 1 { _A_ 0 _U_ 2 _N_ _N_ _F_ _IF_ARGS_ 0 0 X 1 _CONSTM_ Text readList (Int) _N_ }, [ [Integer] ] 1 { _A_ 0 _U_ 2 _N_ _N_ _F_ _IF_ARGS_ 0 0 X 1 _CONSTM_ Text readList (Integer) _N_ }, [ [[Char]] ] 1 { _A_ 0 _U_ 2 _N_ _N_ _F_ _IF_ARGS_ 0 0 X 1 _CONSTM_ Text readList ([Char]) _N_ }, [ [[Int]] ] 1 { _A_ 0 _U_ 2 _N_ _N_ _F_ _IF_ARGS_ 0 0 X 1 _CONSTM_ Text readList ([Int]) _N_ }, [ [Complex Double] ] 1 { _A_ 0 _U_ 2 _N_ _N_ _F_ _IF_ARGS_ 0 0 X 1 _CONSTM_ Text readList (Complex Double) _N_ }, [ (Ratio Integer) ] 1 { _A_ 0 _U_ 2 _N_ _N_ _N_ _N_ }, [ (Array Int Double) ] 1 { _A_ 0 _U_ 2 _N_ _N_ _N_ _N_ }, [ (Array (Int, Int) Double) ] 1 { _A_ 0 _U_ 2 _N_ _N_ _N_ _N_ }, [ _PackedString ] 1 { _A_ 1 _U_ 2 _N_ _S_ _!_ _N_ _N_ }, [ (Complex Double) ] 1 { _A_ 0 _U_ 2 _N_ _N_ _N_ _N_ }, [ () ] 1 { _A_ 0 _U_ 2 _N_ _N_ _N_ _N_ }, [ (Int, Int) ] 1 { _A_ 0 _U_ 2 _N_ _N_ _N_ _N_ }, [ (Integer, Integer) ] 1 { _A_ 0 _U_ 2 _N_ _N_ _N_ _N_ }, [ (Int, Int, Int) ] 1 { _A_ 0 _U_ 2 _N_ _N_ _N_ _N_ } #-}
show :: Text a => a -> [Char]
- {-# GHC_PRAGMA _A_ 1 _U_ 12 _N_ _S_ "U(ASAA)" {_A_ 1 _U_ 12 _N_ _N_ _N_ _N_} _N_ _SPECIALISE_ [ Char ] 1 { _A_ 1 _U_ 1 _N_ _S_ "U(P)" {_A_ 1 _U_ 2 _N_ _N_ _N_ _N_} _N_ _N_ }, [ Double ] 1 { _A_ 1 _U_ 1 _N_ _S_ "U(P)" {_A_ 1 _U_ 2 _N_ _N_ _N_ _N_} _N_ _N_ }, [ Float ] 1 { _A_ 1 _U_ 2 _N_ _N_ _N_ _N_ }, [ Int ] 1 { _A_ 1 _U_ 1 _N_ _S_ "U(P)" {_A_ 1 _U_ 2 _N_ _N_ _N_ _N_} _N_ _N_ }, [ Integer ] 1 { _A_ 1 _U_ 1 _N_ _S_ "U(PPP)" {_A_ 3 _U_ 222 _N_ _N_ _N_ _N_} _N_ _N_ }, [ [Char] ] 1 { _A_ 1 _U_ 2 _N_ _N_ _N_ _N_ }, [ _PackedString ] 1 { _A_ 1 _U_ 1 _N_ _N_ _N_ _N_ }, [ (Int, Int) ] 1 { _A_ 1 _U_ 1 _N_ _S_ "U(LL)" {_A_ 2 _U_ 22 _N_ _N_ _N_ _N_} _N_ _N_ }, [ (Integer, Integer) ] 1 { _A_ 1 _U_ 1 _N_ _S_ "U(LL)" {_A_ 2 _U_ 22 _N_ _N_ _N_ _N_} _N_ _N_ } #-}
+ {-# GHC_PRAGMA _A_ 1 _U_ 12 _N_ _S_ "U(ASAA)" {_A_ 1 _U_ 12 _N_ _N_ _N_ _N_} _N_ _SPECIALISE_ [ Bool ] 1 { _A_ 1 _U_ 2 _N_ _S_ "E" _N_ _N_ }, [ Char ] 1 { _A_ 1 _U_ 1 _N_ _S_ "U(P)" {_A_ 1 _U_ 2 _N_ _N_ _N_ _N_} _N_ _N_ }, [ Double ] 1 { _A_ 1 _U_ 1 _N_ _S_ "U(P)" {_A_ 1 _U_ 2 _N_ _N_ _N_ _N_} _N_ _N_ }, [ Int ] 1 { _A_ 1 _U_ 1 _N_ _S_ "U(P)" {_A_ 1 _U_ 2 _N_ _N_ _N_ _N_} _N_ _N_ }, [ Integer ] 1 { _A_ 1 _U_ 1 _N_ _S_ "U(PPP)" {_A_ 3 _U_ 222 _N_ _N_ _N_ _N_} _N_ _N_ }, [ [Bool] ] 1 { _A_ 1 _U_ 1 _N_ _S_ "S" _N_ _N_ }, [ [Char] ] 1 { _A_ 1 _U_ 2 _N_ _N_ _N_ _N_ }, [ [Double] ] 1 { _A_ 1 _U_ 2 _N_ _N_ _N_ _N_ }, [ [Int] ] 1 { _A_ 1 _U_ 2 _N_ _N_ _N_ _N_ }, [ [Integer] ] 1 { _A_ 1 _U_ 2 _N_ _N_ _N_ _N_ }, [ [[Char]] ] 1 { _A_ 1 _U_ 1 _N_ _S_ "S" _N_ _N_ }, [ [[Int]] ] 1 { _A_ 1 _U_ 1 _N_ _S_ "S" _N_ _N_ }, [ [Complex Double] ] 1 { _A_ 1 _U_ 2 _N_ _N_ _N_ _N_ }, [ (Ratio Integer) ] 1 { _A_ 1 _U_ 1 _N_ _S_ "U(LL)" {_A_ 2 _U_ 22 _N_ _N_ _N_ _N_} _N_ _N_ }, [ (Array Int Double) ] 1 { _A_ 1 _U_ 2 _N_ _N_ _N_ _N_ }, [ (Array (Int, Int) Double) ] 1 { _A_ 1 _U_ 2 _N_ _N_ _N_ _N_ }, [ _PackedString ] 1 { _A_ 1 _U_ 1 _N_ _N_ _N_ _N_ }, [ (Complex Double) ] 1 { _A_ 1 _U_ 1 _N_ _S_ "U(LL)" {_A_ 2 _U_ 22 _N_ _N_ _N_ _N_} _N_ _N_ }, [ () ] 1 { _A_ 1 _U_ 1 _N_ _S_ "E" _N_ _N_ }, [ (Int, Int) ] 1 { _A_ 1 _U_ 1 _N_ _S_ "U(LL)" {_A_ 2 _U_ 22 _N_ _N_ _N_ _N_} _N_ _N_ }, [ (Integer, Integer) ] 1 { _A_ 1 _U_ 1 _N_ _S_ "U(LL)" {_A_ 2 _U_ 22 _N_ _N_ _N_ _N_} _N_ _N_ }, [ (Int, Int, Int) ] 1 { _A_ 1 _U_ 1 _N_ _S_ "U(LLL)" {_A_ 3 _U_ 222 _N_ _N_ _N_ _N_} _N_ _N_ } #-}
showChar :: Char -> [Char] -> [Char]
{-# GHC_PRAGMA _A_ 2 _U_ 22 _N_ _N_ _F_ _IF_ARGS_ 0 2 XX 3 \ (u0 :: Char) (u1 :: [Char]) -> _!_ (:) [Char] [u0, u1] _N_ #-}
showFloat :: RealFloat a => a -> [Char] -> [Char]
- {-# GHC_PRAGMA _A_ 1 _U_ 122 _N_ _S_ "U(U(LU(SLLL)LAAAA)LLLALAAAA)" {_A_ 5 _U_ 1122222 _N_ _N_ _N_ _N_} _N_ _SPECIALISE_ [ Double ] 1 { _A_ 1 _U_ 12 _N_ _S_ "U(P)" {_A_ 1 _U_ 22 _N_ _N_ _N_ _N_} _N_ _N_ }, [ Float ] 1 { _A_ 0 _U_ 22 _N_ _N_ _N_ _N_ } #-}
+ {-# GHC_PRAGMA _A_ 1 _U_ 122 _N_ _S_ "U(U(AU(SAAA)AAAAL)LLLALAAAA)" {_A_ 5 _U_ 1122222 _N_ _N_ _N_ _N_} _N_ _SPECIALISE_ [ Double ] 1 { _A_ 1 _U_ 12 _N_ _S_ "U(P)" {_A_ 1 _U_ 22 _N_ _N_ _N_ _N_} _N_ _N_ } #-}
showInt :: Integral a => a -> [Char] -> [Char]
{-# GHC_PRAGMA _A_ 1 _U_ 222 _N_ _S_ "U(U(U(U(SL)LLLLLLLLL)LL)LLLLLSLLLLL)" _N_ _SPECIALISE_ [ Int ] 1 { _A_ 2 _U_ 12 _N_ _S_ "U(P)L" {_A_ 2 _U_ 22 _N_ _N_ _N_ _N_} _N_ _N_ }, [ Integer ] 1 { _A_ 2 _U_ 12 _N_ _S_ "U(PPP)L" {_A_ 4 _U_ 2222 _N_ _N_ _N_ _N_} _N_ _N_ } #-}
showLitChar :: Char -> [Char] -> [Char]
showString :: [Char] -> [Char] -> [Char]
{-# GHC_PRAGMA _A_ 2 _U_ 12 _N_ _N_ _F_ _IF_ARGS_ 0 0 X 1 _TYAPP_ _ORIG_ PreludeList (++) { Char } _N_ #-}
shows :: Text a => a -> [Char] -> [Char]
- {-# GHC_PRAGMA _A_ 1 _U_ 122 _N_ _S_ "U(ASAA)" {_A_ 1 _U_ 122 _N_ _N_ _N_ _N_} _N_ _SPECIALISE_ [ Char ] 1 { _A_ 2 _U_ 12 _N_ _S_ "U(P)L" {_A_ 2 _U_ 22 _N_ _N_ _N_ _N_} _N_ _N_ }, [ Double ] 1 { _A_ 1 _U_ 12 _N_ _S_ "U(P)" {_A_ 1 _U_ 22 _N_ _N_ _N_ _N_} _N_ _N_ }, [ Float ] 1 { _A_ 0 _U_ 22 _N_ _N_ _N_ _N_ }, [ Int ] 1 { _A_ 2 _U_ 12 _N_ _S_ "U(P)L" {_A_ 2 _U_ 22 _N_ _N_ _N_ _N_} _N_ _N_ }, [ Integer ] 1 { _A_ 2 _U_ 12 _N_ _S_ "U(PPP)L" {_A_ 4 _U_ 2222 _N_ _N_ _N_ _N_} _N_ _N_ }, [ [Char] ] 1 { _A_ 1 _U_ 22 _N_ _N_ _F_ _IF_ARGS_ 0 0 X 1 _CONSTM_ Text showList (Char) _N_ }, [ _PackedString ] 1 { _A_ 2 _U_ 12 _N_ _N_ _N_ _N_ }, [ (Int, Int) ] 1 { _A_ 2 _U_ 12 _N_ _S_ "U(LL)L" {_A_ 3 _U_ 222 _N_ _N_ _N_ _N_} _N_ _N_ }, [ (Integer, Integer) ] 1 { _A_ 2 _U_ 12 _N_ _S_ "U(LL)L" {_A_ 3 _U_ 222 _N_ _N_ _N_ _N_} _N_ _N_ } #-}
+ {-# GHC_PRAGMA _A_ 1 _U_ 122 _N_ _S_ "U(ASAA)" {_A_ 1 _U_ 122 _N_ _N_ _N_ _N_} _N_ _SPECIALISE_ [ Bool ] 1 { _A_ 2 _U_ 22 _N_ _N_ _N_ _N_ }, [ Char ] 1 { _A_ 2 _U_ 12 _N_ _S_ "U(P)L" {_A_ 2 _U_ 22 _N_ _N_ _N_ _N_} _N_ _N_ }, [ Double ] 1 { _A_ 1 _U_ 12 _N_ _S_ "U(P)" {_A_ 1 _U_ 22 _N_ _N_ _N_ _N_} _N_ _N_ }, [ Int ] 1 { _A_ 2 _U_ 12 _N_ _S_ "U(P)L" {_A_ 2 _U_ 22 _N_ _N_ _N_ _N_} _N_ _N_ }, [ Integer ] 1 { _A_ 2 _U_ 12 _N_ _S_ "U(PPP)L" {_A_ 4 _U_ 2222 _N_ _N_ _N_ _N_} _N_ _N_ }, [ [Bool] ] 1 { _A_ 1 _U_ 12 _N_ _S_ "S" _F_ _IF_ARGS_ 0 1 X 3 \ (u0 :: [Bool]) -> _APP_ _TYAPP_ _ORIG_ PreludeCore _showList { Bool } [ _WRKR_ _CONSTM_ Text showsPrec (Bool), u0 ] _N_ }, [ [Char] ] 1 { _A_ 1 _U_ 22 _N_ _N_ _F_ _IF_ARGS_ 0 0 X 1 _CONSTM_ Text showList (Char) _N_ }, [ [Double] ] 1 { _A_ 1 _U_ 22 _N_ _N_ _F_ _IF_ARGS_ 0 0 X 1 _CONSTM_ Text showList (Double) _N_ }, [ [Int] ] 1 { _A_ 1 _U_ 22 _N_ _N_ _F_ _IF_ARGS_ 0 0 X 1 _CONSTM_ Text showList (Int) _N_ }, [ [Integer] ] 1 { _A_ 1 _U_ 22 _N_ _N_ _F_ _IF_ARGS_ 0 0 X 1 _CONSTM_ Text showList (Integer) _N_ }, [ [[Char]] ] 1 { _A_ 1 _U_ 12 _N_ _S_ "S" _F_ _IF_ARGS_ 0 1 X 3 \ (u0 :: [[Char]]) -> _APP_ _TYAPP_ _ORIG_ PreludeCore _showList { [Char] } [ _CONSTM_ Text showList (Char), u0 ] _N_ }, [ [[Int]] ] 1 { _A_ 1 _U_ 12 _N_ _S_ "S" _F_ _IF_ARGS_ 0 1 X 3 \ (u0 :: [[Int]]) -> _APP_ _TYAPP_ _ORIG_ PreludeCore _showList { [Int] } [ _CONSTM_ Text showList (Int), u0 ] _N_ }, [ [Complex Double] ] 1 { _A_ 1 _U_ 22 _N_ _N_ _F_ _IF_ARGS_ 0 0 X 1 _CONSTM_ Text showList (Complex Double) _N_ }, [ (Ratio Integer) ] 1 { _A_ 1 _U_ 12 _N_ _S_ "U(LL)" {_A_ 2 _U_ 222 _N_ _N_ _N_ _N_} _N_ _N_ }, [ (Array Int Double) ] 1 { _A_ 1 _U_ 22 _N_ _N_ _N_ _N_ }, [ (Array (Int, Int) Double) ] 1 { _A_ 1 _U_ 22 _N_ _N_ _N_ _N_ }, [ _PackedString ] 1 { _A_ 2 _U_ 12 _N_ _N_ _N_ _N_ }, [ (Complex Double) ] 1 { _A_ 1 _U_ 12 _N_ _S_ "U(LL)" {_A_ 2 _U_ 222 _N_ _N_ _N_ _N_} _N_ _N_ }, [ () ] 1 { _A_ 2 _U_ 12 _N_ _S_ "EL" _F_ _IF_ARGS_ 0 2 CX 4 \ (u0 :: ()) (u1 :: [Char]) -> case u0 of { _ALG_ _TUP_0 -> _APP_ _TYAPP_ _ORIG_ PreludeList (++) { Char } [ _NOREP_S_ "()", u1 ]; _NO_DEFLT_ } _N_ }, [ (Int, Int) ] 1 { _A_ 2 _U_ 12 _N_ _S_ "U(LL)L" {_A_ 3 _U_ 222 _N_ _N_ _N_ _N_} _N_ _N_ }, [ (Integer, Integer) ] 1 { _A_ 2 _U_ 12 _N_ _S_ "U(LL)L" {_A_ 3 _U_ 222 _N_ _N_ _N_ _N_} _N_ _N_ }, [ (Int, Int, Int) ] 1 { _A_ 2 _U_ 12 _N_ _S_ "U(LLL)L" {_A_ 4 _U_ 2222 _N_ _N_ _N_ _N_} _N_ _N_ } #-}
appendFile :: [Char] -> [Char] -> _State _RealWorld -> (Either IOError13 (), _State _RealWorld)
{-# GHC_PRAGMA _A_ 3 _U_ 221 _N_ _S_ "LLU(P)" {_A_ 3 _U_ 222 _N_ _N_ _N_ _N_} _N_ _N_ #-}
hPutChar :: _MVar _Handle -> Char -> _State _RealWorld -> (Either IOError13 (), _State _RealWorld)
print :: Text a => a -> _State _RealWorld -> (Either IOError13 (), _State _RealWorld)
{-# GHC_PRAGMA _A_ 1 _U_ 121 _N_ _N_ _N_ _N_ #-}
putChar :: Char -> _State _RealWorld -> (Either IOError13 (), _State _RealWorld)
- {-# GHC_PRAGMA _A_ 2 _U_ 11 _N_ _N_ _F_ _IF_ARGS_ 0 0 X 2 _APP_ _ORIG_ PreludeWriteTextIO hPutChar [ _ORIG_ PreludeStdIO stdout13 ] _N_ #-}
+ {-# GHC_PRAGMA _A_ 2 _U_ 11 _N_ _N_ _F_ _IF_ARGS_ 0 2 XC 6 \ (u0 :: Char) (u1 :: _State _RealWorld) -> case _ORIG_ PreludeStdIO stdout13 of { _ALG_ _MVar (u2 :: SynchVar# _RealWorld _Handle) -> case u1 of { _ALG_ S# (u3 :: State# _RealWorld) -> _APP_ _WRKR_ _ORIG_ PreludeWriteTextIO hPutChar [ u2, u0, u3 ]; _NO_DEFLT_ }; _NO_DEFLT_ } _N_ #-}
putStr :: [Char] -> _State _RealWorld -> (Either IOError13 (), _State _RealWorld)
- {-# GHC_PRAGMA _A_ 2 _U_ 21 _N_ _N_ _F_ _IF_ARGS_ 0 0 X 2 _APP_ _ORIG_ PreludeWriteTextIO hPutStr [ _ORIG_ PreludeStdIO stdout13 ] _N_ #-}
+ {-# GHC_PRAGMA _A_ 2 _U_ 21 _N_ _N_ _F_ _IF_ARGS_ 0 2 XC 6 \ (u0 :: [Char]) (u1 :: _State _RealWorld) -> case _ORIG_ PreludeStdIO stdout13 of { _ALG_ _MVar (u2 :: SynchVar# _RealWorld _Handle) -> case u1 of { _ALG_ S# (u3 :: State# _RealWorld) -> _APP_ _WRKR_ _ORIG_ PreludeWriteTextIO hPutStr [ u2, u0, u3 ]; _NO_DEFLT_ }; _NO_DEFLT_ } _N_ #-}
putText :: Text a => a -> _State _RealWorld -> (Either IOError13 (), _State _RealWorld)
{-# GHC_PRAGMA _A_ 1 _U_ 121 _N_ _N_ _F_ _IF_ARGS_ 1 1 X 3 _/\_ u0 -> \ (u1 :: {{Text u0}}) -> _APP_ _TYAPP_ _ORIG_ PreludeWriteTextIO hPutText { u0 } [ u1, _ORIG_ PreludeStdIO stdout13 ] _N_ #-}
writeFile :: [Char] -> [Char] -> _State _RealWorld -> (Either IOError13 (), _State _RealWorld)
-{-# GHC_PRAGMA INTERFACE VERSION 5 #-}
+{-# GHC_PRAGMA INTERFACE VERSION 6 #-}
interface Prelude where
import PreludeArray((!), (//), Array, Assoc, _ByteArray, accum, accumArray, amap, array, assocs, bounds, elems, indices, ixmap, listArray)
import PreludeBuiltin(Bin, Char(..), Int(..), Integer(..), List(..), Tuple0, Tuple2, Tuple3, Tuple4, Tuple5, Tuple6, Tuple7, _Addr(..), _RealWorld(..), _State(..))
import PreludeComplex(Complex, cis, conjugate, imagPart, magnitude, mkPolar, phase, polar, realPart)
-import PreludeCore(Bool(..), Eq(..), Fractional(..), Integral(..), Ix(..), Num(..), Ord(..), Real(..), RealFloat(..), RealFrac(..), Text(..), _ceiling, _floor, _readList, _round, _showList, _showRational, _truncate)
+import PreludeCore(Bool(..), Eq(..), Fractional(..), Integral(..), Ix(..), Num(..), Ord(..), Real(..), RealFloat(..), RealFrac(..), Text(..), _readList, _showList, _showRational)
import PreludeIO(interact13) renaming (interact13 to interact)
import PreludeIOError(IOError13)
import PreludeList((!!), (++), (\\), all, and, any, break, concat, cycle, drop, dropWhile, elem, filter, foldl1, foldr1, genericLength, head, init, iterate, last, length, lines, map, maximum, minimum, notElem, nub, null, or, partition, product, products, repeat, reverse, scanl, scanl1, scanr, scanr1, span, splitAt, sum, sums, tail, take, takeWhile, transpose, unlines, unwords, unzip, unzip3, unzip4, unzip5, unzip6, unzip7, words, zip, zip3, zip4, zip5, zip6, zip7, zipWith, zipWith3, zipWith4, zipWith5, zipWith6, zipWith7)
(.) :: (a -> c) -> (b -> a) -> b -> c
{-# GHC_PRAGMA _A_ 3 _U_ 112 _N_ _S_ "SLL" _F_ _ALWAYS_ _/\_ u0 u1 u2 -> \ (u3 :: u0 -> u2) (u4 :: u1 -> u0) (u5 :: u1) -> let {(u6 :: u0) = _APP_ u4 [ u5 ]} in _APP_ u3 [ u6 ] _N_ #-}
(^) :: (Num b, Integral a) => b -> a -> b
- {-# GHC_PRAGMA _A_ 2 _U_ 2122 _N_ _S_ "LU(U(LU(U(U(SA)AALAAAA)AAAA)A)AAALAAAALAA)" {_A_ 5 _U_ 2212222 _N_ _N_ _N_ _N_} _N_ _SPECIALISE_ [ Int, Double ] 2 { _A_ 2 _U_ 21 _N_ _S_ "LU(P)" {_A_ 2 _U_ 22 _N_ _N_ _N_ _N_} _N_ _N_ }, [ Int, Int ] 2 { _A_ 2 _U_ 21 _N_ _S_ "LU(P)" {_A_ 2 _U_ 22 _N_ _N_ _N_ _N_} _N_ _N_ }, [ Int, Integer ] 2 { _A_ 2 _U_ 21 _N_ _S_ "LU(P)" {_A_ 2 _U_ 22 _N_ _N_ _N_ _N_} _N_ _N_ }, [ Int, (Ratio Integer) ] 2 { _A_ 2 _U_ 21 _N_ _S_ "LU(P)" {_A_ 2 _U_ 22 _N_ _N_ _N_ _N_} _N_ _N_ }, [ Int, (Complex Double) ] 2 { _A_ 2 _U_ 21 _N_ _S_ "LU(P)" {_A_ 2 _U_ 22 _N_ _N_ _N_ _N_} _N_ _N_ } #-}
+ {-# GHC_PRAGMA _A_ 2 _U_ 2122 _N_ _S_ "LU(U(LU(U(U(SL)LLLLLLL)LLLL)L)LLLLLLLLLLL)" _N_ _SPECIALISE_ [ Int, Double ] 2 { _A_ 2 _U_ 21 _N_ _S_ "LU(P)" {_A_ 2 _U_ 22 _N_ _N_ _N_ _N_} _N_ _N_ }, [ Int, Int ] 2 { _A_ 2 _U_ 21 _N_ _S_ "LU(P)" {_A_ 2 _U_ 22 _N_ _N_ _N_ _N_} _N_ _N_ }, [ Int, Integer ] 2 { _A_ 2 _U_ 21 _N_ _S_ "LU(P)" {_A_ 2 _U_ 22 _N_ _N_ _N_ _N_} _N_ _N_ }, [ Int, (Ratio Integer) ] 2 { _A_ 2 _U_ 21 _N_ _S_ "LU(P)" {_A_ 2 _U_ 22 _N_ _N_ _N_ _N_} _N_ _N_ }, [ Int, (Complex Double) ] 2 { _A_ 2 _U_ 21 _N_ _S_ "LU(P)" {_A_ 2 _U_ 22 _N_ _N_ _N_ _N_} _N_ _N_ }, [ Integer, Integer ] 2 { _A_ 2 _U_ 21 _N_ _S_ "LU(PPP)" {_A_ 4 _U_ 2222 _N_ _N_ _N_ _N_} _N_ _N_ } #-}
(^^) :: (Fractional b, Integral a) => b -> a -> b
- {-# GHC_PRAGMA _A_ 2 _U_ 2122 _N_ _S_ "LU(LU(U(AAASAAAA)AAA)AALAAAALAA)" {_A_ 5 _U_ 2212222 _N_ _N_ _N_ _N_} _N_ _SPECIALISE_ [ Int, Double ] 2 { _A_ 2 _U_ 21 _N_ _S_ "LU(P)" {_A_ 2 _U_ 22 _N_ _N_ _N_ _N_} _N_ _N_ }, [ Int, (Ratio Integer) ] 2 { _A_ 2 _U_ 21 _N_ _S_ "LU(P)" {_A_ 2 _U_ 22 _N_ _N_ _N_ _N_} _N_ _N_ } #-}
+ {-# GHC_PRAGMA _A_ 2 _U_ 2222 _N_ _S_ "LU(LU(U(LLLSLLLL)LLL)LLLLLLLLLL)" _N_ _SPECIALISE_ [ Int, Double ] 2 { _A_ 2 _U_ 21 _N_ _S_ "LU(P)" {_A_ 2 _U_ 22 _N_ _N_ _N_ _N_} _N_ _N_ }, [ Int, (Ratio Integer) ] 2 { _A_ 2 _U_ 21 _N_ _S_ "LU(P)" {_A_ 2 _U_ 22 _N_ _N_ _N_ _N_} _N_ _N_ }, [ Int, (Complex Double) ] 2 { _A_ 2 _U_ 21 _N_ _S_ "LU(P)" {_A_ 2 _U_ 22 _N_ _N_ _N_ _N_} _N_ _N_ } #-}
appendBin :: Bin -> Bin -> Bin
- {-# GHC_PRAGMA _A_ 2 _U_ 22 _N_ _S_ _!_ _F_ _IF_ARGS_ 0 2 XX 4 \ (u0 :: Bin) (u1 :: Bin) -> _APP_ _TYAPP_ error { (Bin -> Bin -> Bin) } [ _NOREP_S_ "appendBin{Prelude}\n", u0, u1 ] _N_ #-}
+ {-# GHC_PRAGMA _A_ 2 _U_ 22 _N_ _S_ _!_ _N_ _N_ #-}
asTypeOf :: a -> a -> a
{-# GHC_PRAGMA _A_ 2 _U_ 10 _N_ _N_ _F_ _IF_ARGS_ 1 0 X 1 _/\_ u0 -> _TYAPP_ _TYAPP_ _ORIG_ Prelude const { u0 } { u0 } _N_ #-}
atan2 :: RealFloat a => a -> a -> a
flip :: (b -> a -> c) -> a -> b -> c
{-# GHC_PRAGMA _A_ 3 _U_ 122 _N_ _S_ "SLL" _F_ _IF_ARGS_ 3 3 XXX 3 _/\_ u0 u1 u2 -> \ (u3 :: u1 -> u0 -> u2) (u4 :: u0) (u5 :: u1) -> _APP_ u3 [ u5, u4 ] _N_ #-}
fromIntegral :: (Integral a, Num b) => a -> b
- {-# GHC_PRAGMA _A_ 3 _U_ 112 _N_ _S_ "LU(AAAAAAAASA)L" {_A_ 3 _U_ 112 _N_ _N_ _F_ _IF_ARGS_ 2 3 CXX 6 _/\_ u0 u1 -> \ (u2 :: {{Integral u0}}) (u3 :: Integer -> u1) (u4 :: u0) -> let {(uh :: Integer) = case u2 of { _ALG_ _TUP_12 (u5 :: {{Real u0}}) (u6 :: {{Ix u0}}) (u7 :: u0 -> u0 -> u0) (u8 :: u0 -> u0 -> u0) (u9 :: u0 -> u0 -> u0) (ua :: u0 -> u0 -> u0) (ub :: u0 -> u0 -> (u0, u0)) (uc :: u0 -> u0 -> (u0, u0)) (ud :: u0 -> Bool) (ue :: u0 -> Bool) (uf :: u0 -> Integer) (ug :: u0 -> Int) -> _APP_ uf [ u4 ]; _NO_DEFLT_ }} in _APP_ u3 [ uh ] _N_} _F_ _IF_ARGS_ 2 3 CCX 7 _/\_ u0 u1 -> \ (u2 :: {{Integral u0}}) (u3 :: {{Num u1}}) (u4 :: u0) -> let {(uh :: Integer) = case u2 of { _ALG_ _TUP_12 (u5 :: {{Real u0}}) (u6 :: {{Ix u0}}) (u7 :: u0 -> u0 -> u0) (u8 :: u0 -> u0 -> u0) (u9 :: u0 -> u0 -> u0) (ua :: u0 -> u0 -> u0) (ub :: u0 -> u0 -> (u0, u0)) (uc :: u0 -> u0 -> (u0, u0)) (ud :: u0 -> Bool) (ue :: u0 -> Bool) (uf :: u0 -> Integer) (ug :: u0 -> Int) -> _APP_ uf [ u4 ]; _NO_DEFLT_ }} in case u3 of { _ALG_ _TUP_10 (ui :: {{Eq u1}}) (uj :: {{Text u1}}) (uk :: u1 -> u1 -> u1) (ul :: u1 -> u1 -> u1) (um :: u1 -> u1 -> u1) (un :: u1 -> u1) (uo :: u1 -> u1) (up :: u1 -> u1) (uq :: Integer -> u1) (ur :: Int -> u1) -> _APP_ uq [ uh ]; _NO_DEFLT_ } _SPECIALISE_ [ Int, Double ] 2 { _A_ 1 _U_ 1 _N_ _S_ "U(P)" {_A_ 1 _U_ 2 _N_ _N_ _F_ _IF_ARGS_ 0 1 X 3 \ (u0 :: Int#) -> case _#_ int2Double# [] [u0] of { _PRIM_ (u1 :: Double#) -> _!_ D# [] [u1] } _N_} _F_ _IF_ARGS_ 0 1 C 4 \ (u0 :: Int) -> case u0 of { _ALG_ I# (u1 :: Int#) -> case _#_ int2Double# [] [u1] of { _PRIM_ (u2 :: Double#) -> _!_ D# [] [u2] }; _NO_DEFLT_ } _N_ }, [ Int, Int ] 2 { _A_ 1 _U_ 1 _N_ _N_ _F_ _IF_ARGS_ 0 0 X 1 _TYAPP_ _ORIG_ Prelude id { Int } _N_ }, [ Int, Integer ] 2 { _A_ 1 _U_ 1 _N_ _S_ "U(P)" {_A_ 1 _U_ 2 _N_ _N_ _F_ _IF_ARGS_ 0 1 X 1 \ (u0 :: Int#) -> _#_ int2Integer# [] [u0] _N_} _F_ _IF_ARGS_ 0 1 C 2 \ (u0 :: Int) -> case u0 of { _ALG_ I# (u1 :: Int#) -> _#_ int2Integer# [] [u1]; _NO_DEFLT_ } _N_ }, [ Integer, Double ] 2 { _A_ 1 _U_ 1 _N_ _S_ "U(PPP)" {_A_ 3 _U_ 222 _N_ _N_ _F_ _IF_ARGS_ 0 3 XXX 3 \ (u0 :: Int#) (u1 :: Int#) (u2 :: ByteArray#) -> case _#_ encodeDouble# [] [u0, u1, u2, 0#] of { _PRIM_ (u3 :: Double#) -> _!_ D# [] [u3] } _N_} _F_ _IF_ARGS_ 0 1 C 4 \ (u0 :: Integer) -> case u0 of { _ALG_ J# (u1 :: Int#) (u2 :: Int#) (u3 :: ByteArray#) -> case _#_ encodeDouble# [] [u1, u2, u3, 0#] of { _PRIM_ (u4 :: Double#) -> _!_ D# [] [u4] }; _NO_DEFLT_ } _N_ }, [ Integer, Int ] 2 { _A_ 1 _U_ 1 _N_ _S_ "U(PPP)" {_A_ 3 _U_ 222 _N_ _N_ _F_ _IF_ARGS_ 0 3 XXX 3 \ (u0 :: Int#) (u1 :: Int#) (u2 :: ByteArray#) -> case _#_ integer2Int# [] [u0, u1, u2] of { _PRIM_ (u3 :: Int#) -> _!_ I# [] [u3] } _N_} _F_ _IF_ARGS_ 0 1 C 4 \ (u0 :: Integer) -> case u0 of { _ALG_ J# (u1 :: Int#) (u2 :: Int#) (u3 :: ByteArray#) -> case _#_ integer2Int# [] [u1, u2, u3] of { _PRIM_ (u4 :: Int#) -> _!_ I# [] [u4] }; _NO_DEFLT_ } _N_ }, [ Integer, Integer ] 2 { _A_ 1 _U_ 1 _N_ _N_ _F_ _IF_ARGS_ 0 0 X 1 _TYAPP_ _ORIG_ Prelude id { Integer } _N_ } #-}
+ {-# GHC_PRAGMA _A_ 3 _U_ 112 _N_ _S_ "LU(AAAAAAAASA)L" {_A_ 3 _U_ 112 _N_ _N_ _F_ _IF_ARGS_ 2 3 CXX 6 _/\_ u0 u1 -> \ (u2 :: {{Integral u0}}) (u3 :: Integer -> u1) (u4 :: u0) -> let {(uh :: Integer) = case u2 of { _ALG_ _TUP_12 (u5 :: {{Real u0}}) (u6 :: {{Ix u0}}) (u7 :: u0 -> u0 -> u0) (u8 :: u0 -> u0 -> u0) (u9 :: u0 -> u0 -> u0) (ua :: u0 -> u0 -> u0) (ub :: u0 -> u0 -> (u0, u0)) (uc :: u0 -> u0 -> (u0, u0)) (ud :: u0 -> Bool) (ue :: u0 -> Bool) (uf :: u0 -> Integer) (ug :: u0 -> Int) -> _APP_ uf [ u4 ]; _NO_DEFLT_ }} in _APP_ u3 [ uh ] _N_} _F_ _IF_ARGS_ 2 3 CCX 7 _/\_ u0 u1 -> \ (u2 :: {{Integral u0}}) (u3 :: {{Num u1}}) (u4 :: u0) -> let {(uh :: Integer) = case u2 of { _ALG_ _TUP_12 (u5 :: {{Real u0}}) (u6 :: {{Ix u0}}) (u7 :: u0 -> u0 -> u0) (u8 :: u0 -> u0 -> u0) (u9 :: u0 -> u0 -> u0) (ua :: u0 -> u0 -> u0) (ub :: u0 -> u0 -> (u0, u0)) (uc :: u0 -> u0 -> (u0, u0)) (ud :: u0 -> Bool) (ue :: u0 -> Bool) (uf :: u0 -> Integer) (ug :: u0 -> Int) -> _APP_ uf [ u4 ]; _NO_DEFLT_ }} in case u3 of { _ALG_ _TUP_10 (ui :: {{Eq u1}}) (uj :: {{Text u1}}) (uk :: u1 -> u1 -> u1) (ul :: u1 -> u1 -> u1) (um :: u1 -> u1 -> u1) (un :: u1 -> u1) (uo :: u1 -> u1) (up :: u1 -> u1) (uq :: Integer -> u1) (ur :: Int -> u1) -> _APP_ uq [ uh ]; _NO_DEFLT_ } _SPECIALISE_ [ Int, Double ] 2 { _A_ 1 _U_ 1 _N_ _S_ "U(P)" {_A_ 1 _U_ 2 _N_ _N_ _F_ _IF_ARGS_ 0 1 X 3 \ (u0 :: Int#) -> case _#_ int2Double# [] [u0] of { _PRIM_ (u1 :: Double#) -> _!_ D# [] [u1] } _N_} _F_ _IF_ARGS_ 0 1 C 4 \ (u0 :: Int) -> case u0 of { _ALG_ I# (u1 :: Int#) -> case _#_ int2Double# [] [u1] of { _PRIM_ (u2 :: Double#) -> _!_ D# [] [u2] }; _NO_DEFLT_ } _N_ }, [ Int, Float ] 2 { _A_ 1 _U_ 1 _N_ _S_ "U(P)" {_A_ 1 _U_ 2 _N_ _N_ _F_ _IF_ARGS_ 0 1 X 3 \ (u0 :: Int#) -> case _#_ int2Float# [] [u0] of { _PRIM_ (u1 :: Float#) -> _!_ F# [] [u1] } _N_} _F_ _IF_ARGS_ 0 1 C 4 \ (u0 :: Int) -> case u0 of { _ALG_ I# (u1 :: Int#) -> case _#_ int2Float# [] [u1] of { _PRIM_ (u2 :: Float#) -> _!_ F# [] [u2] }; _NO_DEFLT_ } _N_ }, [ Int, Int ] 2 { _A_ 1 _U_ 1 _N_ _N_ _F_ _IF_ARGS_ 0 0 X 1 _TYAPP_ _ORIG_ Prelude id { Int } _N_ }, [ Int, Integer ] 2 { _A_ 1 _U_ 1 _N_ _S_ "U(P)" {_A_ 1 _U_ 2 _N_ _N_ _F_ _IF_ARGS_ 0 1 X 1 \ (u0 :: Int#) -> _#_ int2Integer# [] [u0] _N_} _F_ _IF_ARGS_ 0 1 C 2 \ (u0 :: Int) -> case u0 of { _ALG_ I# (u1 :: Int#) -> _#_ int2Integer# [] [u1]; _NO_DEFLT_ } _N_ }, [ Int, (Ratio Integer) ] 2 { _A_ 1 _U_ 1 _N_ _N_ _N_ _N_ }, [ Integer, Double ] 2 { _A_ 1 _U_ 1 _N_ _S_ "U(PPP)" {_A_ 3 _U_ 222 _N_ _N_ _F_ _IF_ARGS_ 0 3 XXX 3 \ (u0 :: Int#) (u1 :: Int#) (u2 :: ByteArray#) -> case _#_ encodeDouble# [] [u0, u1, u2, 0#] of { _PRIM_ (u3 :: Double#) -> _!_ D# [] [u3] } _N_} _F_ _IF_ARGS_ 0 1 C 4 \ (u0 :: Integer) -> case u0 of { _ALG_ J# (u1 :: Int#) (u2 :: Int#) (u3 :: ByteArray#) -> case _#_ encodeDouble# [] [u1, u2, u3, 0#] of { _PRIM_ (u4 :: Double#) -> _!_ D# [] [u4] }; _NO_DEFLT_ } _N_ }, [ Integer, Float ] 2 { _A_ 1 _U_ 1 _N_ _S_ "U(PPP)" {_A_ 3 _U_ 222 _N_ _N_ _F_ _IF_ARGS_ 0 3 XXX 3 \ (u0 :: Int#) (u1 :: Int#) (u2 :: ByteArray#) -> case _#_ encodeFloat# [] [u0, u1, u2, 0#] of { _PRIM_ (u3 :: Float#) -> _!_ F# [] [u3] } _N_} _F_ _IF_ARGS_ 0 1 C 4 \ (u0 :: Integer) -> case u0 of { _ALG_ J# (u1 :: Int#) (u2 :: Int#) (u3 :: ByteArray#) -> case _#_ encodeFloat# [] [u1, u2, u3, 0#] of { _PRIM_ (u4 :: Float#) -> _!_ F# [] [u4] }; _NO_DEFLT_ } _N_ }, [ Integer, Int ] 2 { _A_ 1 _U_ 1 _N_ _S_ "U(PPP)" {_A_ 3 _U_ 222 _N_ _N_ _F_ _IF_ARGS_ 0 3 XXX 3 \ (u0 :: Int#) (u1 :: Int#) (u2 :: ByteArray#) -> case _#_ integer2Int# [] [u0, u1, u2] of { _PRIM_ (u3 :: Int#) -> _!_ I# [] [u3] } _N_} _F_ _IF_ARGS_ 0 1 C 4 \ (u0 :: Integer) -> case u0 of { _ALG_ J# (u1 :: Int#) (u2 :: Int#) (u3 :: ByteArray#) -> case _#_ integer2Int# [] [u1, u2, u3] of { _PRIM_ (u4 :: Int#) -> _!_ I# [] [u4] }; _NO_DEFLT_ } _N_ }, [ Integer, Integer ] 2 { _A_ 1 _U_ 1 _N_ _N_ _F_ _IF_ARGS_ 0 0 X 1 _TYAPP_ _ORIG_ Prelude id { Integer } _N_ }, [ Integer, (Ratio Integer) ] 2 { _A_ 1 _U_ 2 _N_ _N_ _F_ _IF_ARGS_ 0 1 X 3 \ (u0 :: Integer) -> _!_ (:%) [Integer] [u0, _SPEC_ _ORIG_ PreludeCore __i1 [ (Integer) ]] _N_ } #-}
fromRealFrac :: (RealFrac a, Fractional b) => a -> b
- {-# GHC_PRAGMA _A_ 3 _U_ 112 _N_ _S_ "LU(AAAS)L" {_A_ 3 _U_ 112 _N_ _N_ _F_ _IF_ARGS_ 2 3 CXX 7 _/\_ u0 u1 -> \ (u2 :: {{RealFrac u0}}) (u3 :: Ratio Integer -> u1) (u4 :: u0) -> let {(uf :: Ratio Integer) = case u2 of { _ALG_ _TUP_7 (u5 :: {{Real u0}}) (u6 :: {{Fractional u0}}) (u7 :: _forall_ a$z1 =>{{Integral a$z1}} -> u0 -> (a$z1, u0)) (u8 :: _forall_ a$z1 =>{{Integral a$z1}} -> u0 -> a$z1) (u9 :: _forall_ a$z1 =>{{Integral a$z1}} -> u0 -> a$z1) (ua :: _forall_ a$z1 =>{{Integral a$z1}} -> u0 -> a$z1) (ub :: _forall_ a$z1 =>{{Integral a$z1}} -> u0 -> a$z1) -> case u5 of { _ALG_ _TUP_3 (uc :: {{Num u0}}) (ud :: {{Enum u0}}) (ue :: u0 -> Ratio Integer) -> _APP_ ue [ u4 ]; _NO_DEFLT_ }; _NO_DEFLT_ }} in _APP_ u3 [ uf ] _N_} _F_ _IF_ARGS_ 2 3 CCX 8 _/\_ u0 u1 -> \ (u2 :: {{RealFrac u0}}) (u3 :: {{Fractional u1}}) (u4 :: u0) -> let {(uf :: Ratio Integer) = case u2 of { _ALG_ _TUP_7 (u5 :: {{Real u0}}) (u6 :: {{Fractional u0}}) (u7 :: _forall_ a$z1 =>{{Integral a$z1}} -> u0 -> (a$z1, u0)) (u8 :: _forall_ a$z1 =>{{Integral a$z1}} -> u0 -> a$z1) (u9 :: _forall_ a$z1 =>{{Integral a$z1}} -> u0 -> a$z1) (ua :: _forall_ a$z1 =>{{Integral a$z1}} -> u0 -> a$z1) (ub :: _forall_ a$z1 =>{{Integral a$z1}} -> u0 -> a$z1) -> case u5 of { _ALG_ _TUP_3 (uc :: {{Num u0}}) (ud :: {{Enum u0}}) (ue :: u0 -> Ratio Integer) -> _APP_ ue [ u4 ]; _NO_DEFLT_ }; _NO_DEFLT_ }} in case u3 of { _ALG_ _TUP_4 (ug :: {{Num u1}}) (uh :: u1 -> u1 -> u1) (ui :: u1 -> u1) (uj :: Ratio Integer -> u1) -> _APP_ uj [ uf ]; _NO_DEFLT_ } _SPECIALISE_ [ Double, Double ] 2 { _A_ 1 _U_ 1 _N_ _N_ _F_ _IF_ARGS_ 0 0 X 1 _TYAPP_ _ORIG_ Prelude id { Double } _N_ }, [ Double, Float ] 2 { _A_ 1 _U_ 1 _N_ _S_ "U(P)" {_A_ 1 _U_ 2 _N_ _N_ _F_ _IF_ARGS_ 0 1 X 3 \ (u0 :: Double#) -> case _#_ double2Float# [] [u0] of { _PRIM_ (u1 :: Float#) -> _!_ F# [] [u1] } _N_} _F_ _IF_ARGS_ 0 1 C 4 \ (u0 :: Double) -> case u0 of { _ALG_ D# (u1 :: Double#) -> case _#_ double2Float# [] [u1] of { _PRIM_ (u2 :: Float#) -> _!_ F# [] [u2] }; _NO_DEFLT_ } _N_ }, [ Float, Double ] 2 { _A_ 1 _U_ 1 _N_ _S_ "U(P)" {_A_ 1 _U_ 2 _N_ _N_ _F_ _IF_ARGS_ 0 1 X 3 \ (u0 :: Float#) -> case _#_ float2Double# [] [u0] of { _PRIM_ (u1 :: Double#) -> _!_ D# [] [u1] } _N_} _F_ _IF_ARGS_ 0 1 C 4 \ (u0 :: Float) -> case u0 of { _ALG_ F# (u1 :: Float#) -> case _#_ float2Double# [] [u1] of { _PRIM_ (u2 :: Double#) -> _!_ D# [] [u2] }; _NO_DEFLT_ } _N_ }, [ Float, Float ] 2 { _A_ 1 _U_ 1 _N_ _N_ _F_ _IF_ARGS_ 0 0 X 1 _TYAPP_ _ORIG_ Prelude id { Float } _N_ } #-}
+ {-# GHC_PRAGMA _A_ 3 _U_ 112 _N_ _S_ "LU(AAAS)L" {_A_ 3 _U_ 112 _N_ _N_ _F_ _IF_ARGS_ 2 3 CXX 7 _/\_ u0 u1 -> \ (u2 :: {{RealFrac u0}}) (u3 :: Ratio Integer -> u1) (u4 :: u0) -> let {(uf :: Ratio Integer) = case u2 of { _ALG_ _TUP_7 (u5 :: {{Real u0}}) (u6 :: {{Fractional u0}}) (u7 :: _forall_ a$z1 =>{{Integral a$z1}} -> u0 -> (a$z1, u0)) (u8 :: _forall_ a$z1 =>{{Integral a$z1}} -> u0 -> a$z1) (u9 :: _forall_ a$z1 =>{{Integral a$z1}} -> u0 -> a$z1) (ua :: _forall_ a$z1 =>{{Integral a$z1}} -> u0 -> a$z1) (ub :: _forall_ a$z1 =>{{Integral a$z1}} -> u0 -> a$z1) -> case u5 of { _ALG_ _TUP_3 (uc :: {{Num u0}}) (ud :: {{Enum u0}}) (ue :: u0 -> Ratio Integer) -> _APP_ ue [ u4 ]; _NO_DEFLT_ }; _NO_DEFLT_ }} in _APP_ u3 [ uf ] _N_} _F_ _IF_ARGS_ 2 3 CCX 8 _/\_ u0 u1 -> \ (u2 :: {{RealFrac u0}}) (u3 :: {{Fractional u1}}) (u4 :: u0) -> let {(uf :: Ratio Integer) = case u2 of { _ALG_ _TUP_7 (u5 :: {{Real u0}}) (u6 :: {{Fractional u0}}) (u7 :: _forall_ a$z1 =>{{Integral a$z1}} -> u0 -> (a$z1, u0)) (u8 :: _forall_ a$z1 =>{{Integral a$z1}} -> u0 -> a$z1) (u9 :: _forall_ a$z1 =>{{Integral a$z1}} -> u0 -> a$z1) (ua :: _forall_ a$z1 =>{{Integral a$z1}} -> u0 -> a$z1) (ub :: _forall_ a$z1 =>{{Integral a$z1}} -> u0 -> a$z1) -> case u5 of { _ALG_ _TUP_3 (uc :: {{Num u0}}) (ud :: {{Enum u0}}) (ue :: u0 -> Ratio Integer) -> _APP_ ue [ u4 ]; _NO_DEFLT_ }; _NO_DEFLT_ }} in case u3 of { _ALG_ _TUP_4 (ug :: {{Num u1}}) (uh :: u1 -> u1 -> u1) (ui :: u1 -> u1) (uj :: Ratio Integer -> u1) -> _APP_ uj [ uf ]; _NO_DEFLT_ } _SPECIALISE_ [ Double, Double ] 2 { _A_ 1 _U_ 1 _N_ _N_ _F_ _IF_ARGS_ 0 0 X 1 _TYAPP_ _ORIG_ Prelude id { Double } _N_ }, [ Double, Float ] 2 { _A_ 1 _U_ 1 _N_ _S_ "U(P)" {_A_ 1 _U_ 2 _N_ _N_ _F_ _IF_ARGS_ 0 1 X 3 \ (u0 :: Double#) -> case _#_ double2Float# [] [u0] of { _PRIM_ (u1 :: Float#) -> _!_ F# [] [u1] } _N_} _F_ _IF_ARGS_ 0 1 C 4 \ (u0 :: Double) -> case u0 of { _ALG_ D# (u1 :: Double#) -> case _#_ double2Float# [] [u1] of { _PRIM_ (u2 :: Float#) -> _!_ F# [] [u2] }; _NO_DEFLT_ } _N_ }, [ Double, (Ratio Integer) ] 2 { _A_ 1 _U_ 1 _N_ _S_ "U(P)" {_A_ 1 _U_ 2 _N_ _N_ _N_ _N_} _N_ _N_ }, [ Float, Double ] 2 { _A_ 1 _U_ 1 _N_ _S_ "U(P)" {_A_ 1 _U_ 2 _N_ _N_ _F_ _IF_ARGS_ 0 1 X 3 \ (u0 :: Float#) -> case _#_ float2Double# [] [u0] of { _PRIM_ (u1 :: Double#) -> _!_ D# [] [u1] } _N_} _F_ _IF_ARGS_ 0 1 C 4 \ (u0 :: Float) -> case u0 of { _ALG_ F# (u1 :: Float#) -> case _#_ float2Double# [] [u1] of { _PRIM_ (u2 :: Double#) -> _!_ D# [] [u2] }; _NO_DEFLT_ } _N_ }, [ Float, Float ] 2 { _A_ 1 _U_ 1 _N_ _N_ _F_ _IF_ARGS_ 0 0 X 1 _TYAPP_ _ORIG_ Prelude id { Float } _N_ }, [ Float, (Ratio Integer) ] 2 { _A_ 1 _U_ 1 _N_ _S_ "U(P)" {_A_ 1 _U_ 2 _N_ _N_ _N_ _N_} _N_ _N_ }, [ (Ratio Integer), Double ] 2 { _A_ 1 _U_ 1 _N_ _S_ "U(U(PPP)U(PPP))" {_A_ 4 _U_ 2222 _N_ _N_ _N_ _N_} _N_ _N_ }, [ (Ratio Integer), Float ] 2 { _A_ 1 _U_ 2 _N_ _N_ _F_ _IF_ARGS_ 0 0 X 1 _CONSTM_ Fractional fromRational (Float) _N_ }, [ (Ratio Integer), (Ratio Integer) ] 2 { _A_ 1 _U_ 1 _N_ _N_ _F_ _IF_ARGS_ 0 0 X 1 _TYAPP_ _ORIG_ Prelude id { (Ratio Integer) } _N_ } #-}
fst :: (b, a) -> b
{-# GHC_PRAGMA _A_ 1 _U_ 1 _N_ _S_ "U(SA)" {_A_ 1 _U_ 1 _N_ _N_ _F_ _IF_ARGS_ 2 1 X 1 _/\_ u0 u1 -> \ (u2 :: u1) -> u2 _N_} _F_ _IF_ARGS_ 2 1 C 2 _/\_ u0 u1 -> \ (u2 :: (u1, u0)) -> case u2 of { _ALG_ _TUP_2 (u3 :: u1) (u4 :: u0) -> u3; _NO_DEFLT_ } _N_ #-}
gcd :: Integral a => a -> a -> a
isLower :: Char -> Bool
{-# GHC_PRAGMA _A_ 1 _U_ 1 _N_ _S_ "U(P)" {_A_ 1 _U_ 2 _N_ _N_ _N_ _N_} _N_ _N_ #-}
isNullBin :: Bin -> Bool
- {-# GHC_PRAGMA _A_ 1 _U_ 2 _N_ _S_ _!_ _F_ _IF_ARGS_ 0 1 X 3 \ (u0 :: Bin) -> _APP_ _TYAPP_ error { (Bin -> Bool) } [ _NOREP_S_ "isNullBin{Prelude}\n", u0 ] _N_ #-}
+ {-# GHC_PRAGMA _A_ 1 _U_ 2 _N_ _S_ _!_ _N_ _N_ #-}
isPrint :: Char -> Bool
{-# GHC_PRAGMA _A_ 1 _U_ 1 _N_ _S_ "U(P)" {_A_ 1 _U_ 2 _N_ _N_ _N_ _N_} _N_ _N_ #-}
isSpace :: Char -> Bool
not :: Bool -> Bool
{-# GHC_PRAGMA _A_ 1 _U_ 1 _N_ _S_ "E" _F_ _ALWAYS_ \ (u0 :: Bool) -> case u0 of { _ALG_ True -> _!_ False [] []; False -> _!_ True [] []; _NO_DEFLT_ } _N_ #-}
nullBin :: Bin
- {-# GHC_PRAGMA _A_ 0 _N_ _N_ _S_ _!_ _F_ _IF_ARGS_ 0 0 X 2 _APP_ _TYAPP_ error { Bin } [ _NOREP_S_ "nullBin{Prelude}\n" ] _N_ #-}
+ {-# GHC_PRAGMA _A_ 0 _N_ _N_ _S_ _!_ _N_ _N_ #-}
ord :: Char -> Int
{-# GHC_PRAGMA _A_ 1 _U_ 1 _N_ _S_ "U(P)" {_A_ 1 _U_ 2 _N_ _N_ _F_ _IF_ARGS_ 0 1 X 3 \ (u0 :: Char#) -> case _#_ ord# [] [u0] of { _PRIM_ (u1 :: Int#) -> _!_ I# [] [u1] } _N_} _F_ _IF_ARGS_ 0 1 C 4 \ (u0 :: Char) -> case u0 of { _ALG_ C# (u1 :: Char#) -> case _#_ ord# [] [u1] of { _PRIM_ (u2 :: Int#) -> _!_ I# [] [u2] }; _NO_DEFLT_ } _N_ #-}
otherwise :: Bool
snd :: (a, b) -> b
{-# GHC_PRAGMA _A_ 1 _U_ 1 _N_ _S_ "U(AS)" {_A_ 1 _U_ 1 _N_ _N_ _F_ _IF_ARGS_ 2 1 X 1 _/\_ u0 u1 -> \ (u2 :: u1) -> u2 _N_} _F_ _IF_ARGS_ 2 1 C 2 _/\_ u0 u1 -> \ (u2 :: (u0, u1)) -> case u2 of { _ALG_ _TUP_2 (u3 :: u0) (u4 :: u1) -> u4; _NO_DEFLT_ } _N_ #-}
subtract :: Num a => a -> a -> a
- {-# GHC_PRAGMA _A_ 3 _U_ 122 _N_ _S_ "U(AAASAAAAAA)LL" {_A_ 3 _U_ 122 _N_ _N_ _F_ _IF_ARGS_ 1 3 XXX 3 _/\_ u0 -> \ (u1 :: u0 -> u0 -> u0) (u2 :: u0) (u3 :: u0) -> _APP_ u1 [ u3, u2 ] _N_} _F_ _IF_ARGS_ 1 3 CXX 4 _/\_ u0 -> \ (u1 :: {{Num u0}}) (u2 :: u0) (u3 :: u0) -> case u1 of { _ALG_ _TUP_10 (u4 :: {{Eq u0}}) (u5 :: {{Text u0}}) (u6 :: u0 -> u0 -> u0) (u7 :: u0 -> u0 -> u0) (u8 :: u0 -> u0 -> u0) (u9 :: u0 -> u0) (ua :: u0 -> u0) (ub :: u0 -> u0) (uc :: Integer -> u0) (ud :: Int -> u0) -> _APP_ u7 [ u3, u2 ]; _NO_DEFLT_ } _SPECIALISE_ [ Double ] 1 { _A_ 2 _U_ 11 _N_ _S_ "U(P)U(P)" {_A_ 2 _U_ 22 _N_ _N_ _F_ _IF_ARGS_ 0 2 XX 3 \ (u0 :: Double#) (u1 :: Double#) -> case _#_ minusDouble# [] [u1, u0] of { _PRIM_ (u2 :: Double#) -> _!_ D# [] [u2] } _N_} _F_ _IF_ARGS_ 0 2 CC 5 \ (u0 :: Double) (u1 :: Double) -> case u1 of { _ALG_ D# (u2 :: Double#) -> case u0 of { _ALG_ D# (u3 :: Double#) -> case _#_ minusDouble# [] [u2, u3] of { _PRIM_ (u4 :: Double#) -> _!_ D# [] [u4] }; _NO_DEFLT_ }; _NO_DEFLT_ } _N_ }, [ Int ] 1 { _A_ 2 _U_ 11 _N_ _S_ "U(P)U(P)" {_A_ 2 _U_ 22 _N_ _N_ _F_ _IF_ARGS_ 0 2 XX 3 \ (u0 :: Int#) (u1 :: Int#) -> case _#_ minusInt# [] [u1, u0] of { _PRIM_ (u2 :: Int#) -> _!_ I# [] [u2] } _N_} _F_ _IF_ARGS_ 0 2 CC 5 \ (u0 :: Int) (u1 :: Int) -> case u1 of { _ALG_ I# (u2 :: Int#) -> case u0 of { _ALG_ I# (u3 :: Int#) -> case _#_ minusInt# [] [u2, u3] of { _PRIM_ (u4 :: Int#) -> _!_ I# [] [u4] }; _NO_DEFLT_ }; _NO_DEFLT_ } _N_ } #-}
+ {-# GHC_PRAGMA _A_ 3 _U_ 122 _N_ _S_ "U(AAASAAAAAA)LL" {_A_ 3 _U_ 122 _N_ _N_ _F_ _IF_ARGS_ 1 3 XXX 3 _/\_ u0 -> \ (u1 :: u0 -> u0 -> u0) (u2 :: u0) (u3 :: u0) -> _APP_ u1 [ u3, u2 ] _N_} _F_ _IF_ARGS_ 1 3 CXX 4 _/\_ u0 -> \ (u1 :: {{Num u0}}) (u2 :: u0) (u3 :: u0) -> case u1 of { _ALG_ _TUP_10 (u4 :: {{Eq u0}}) (u5 :: {{Text u0}}) (u6 :: u0 -> u0 -> u0) (u7 :: u0 -> u0 -> u0) (u8 :: u0 -> u0 -> u0) (u9 :: u0 -> u0) (ua :: u0 -> u0) (ub :: u0 -> u0) (uc :: Integer -> u0) (ud :: Int -> u0) -> _APP_ u7 [ u3, u2 ]; _NO_DEFLT_ } _SPECIALISE_ [ Double ] 1 { _A_ 2 _U_ 11 _N_ _S_ "U(P)U(P)" {_A_ 2 _U_ 22 _N_ _N_ _F_ _IF_ARGS_ 0 2 XX 3 \ (u0 :: Double#) (u1 :: Double#) -> case _#_ minusDouble# [] [u1, u0] of { _PRIM_ (u2 :: Double#) -> _!_ D# [] [u2] } _N_} _F_ _IF_ARGS_ 0 2 CC 5 \ (u0 :: Double) (u1 :: Double) -> case u1 of { _ALG_ D# (u2 :: Double#) -> case u0 of { _ALG_ D# (u3 :: Double#) -> case _#_ minusDouble# [] [u2, u3] of { _PRIM_ (u4 :: Double#) -> _!_ D# [] [u4] }; _NO_DEFLT_ }; _NO_DEFLT_ } _N_ }, [ Int ] 1 { _A_ 2 _U_ 11 _N_ _S_ "U(P)U(P)" {_A_ 2 _U_ 22 _N_ _N_ _F_ _IF_ARGS_ 0 2 XX 3 \ (u0 :: Int#) (u1 :: Int#) -> case _#_ minusInt# [] [u1, u0] of { _PRIM_ (u2 :: Int#) -> _!_ I# [] [u2] } _N_} _F_ _IF_ARGS_ 0 2 CC 5 \ (u0 :: Int) (u1 :: Int) -> case u1 of { _ALG_ I# (u2 :: Int#) -> case u0 of { _ALG_ I# (u3 :: Int#) -> case _#_ minusInt# [] [u2, u3] of { _PRIM_ (u4 :: Int#) -> _!_ I# [] [u4] }; _NO_DEFLT_ }; _NO_DEFLT_ } _N_ }, [ (Complex Double) ] 1 { _A_ 2 _U_ 11 _N_ _S_ "U(LL)U(LL)" {_A_ 4 _U_ 2222 _N_ _N_ _N_ _N_} _N_ _N_ } #-}
thenMaybe :: Maybe a -> (a -> Maybe b) -> Maybe b
{-# GHC_PRAGMA _A_ 2 _U_ 11 _N_ _S_ "SL" _F_ _IF_ARGS_ 2 2 CX 5 _/\_ u0 u1 -> \ (u2 :: Maybe u0) (u3 :: u0 -> Maybe u1) -> case u2 of { _ALG_ Nothing -> _!_ Nothing [u1] []; Just (u4 :: u0) -> _APP_ u3 [ u4 ]; _NO_DEFLT_ } _N_ #-}
toLower :: Char -> Char
imagPart :: Complex a -> a
{-# GHC_PRAGMA _A_ 1 _U_ 1 _N_ _S_ "U(AS)" {_A_ 1 _U_ 1 _N_ _N_ _F_ _IF_ARGS_ 1 1 X 1 _/\_ u0 -> \ (u1 :: u0) -> u1 _N_} _F_ _IF_ARGS_ 1 1 C 2 _/\_ u0 -> \ (u1 :: Complex u0) -> case u1 of { _ALG_ (:+) (u2 :: u0) (u3 :: u0) -> u3; _NO_DEFLT_ } _N_ #-}
magnitude :: RealFloat a => Complex a -> a
- {-# GHC_PRAGMA _A_ 1 _U_ 12 _N_ _S_ "U(ALAAAAALAS)" {_A_ 3 _U_ 2221 _N_ _N_ _N_ _N_} _N_ _SPECIALISE_ [ Double ] 1 { _A_ 1 _U_ 1 _N_ _S_ "U(LL)" {_A_ 2 _U_ 22 _N_ _N_ _N_ _N_} _N_ _N_ } #-}
+ {-# GHC_PRAGMA _A_ 1 _U_ 12 _N_ _S_ "U(ALAAAAALAS)" {_A_ 3 _U_ 2221 _N_ _N_ _N_ _N_} _N_ _SPECIALISE_ [ Double ] 1 { _A_ 1 _U_ 1 _N_ _S_ "U(U(P)U(P))" {_A_ 2 _U_ 22 _N_ _N_ _N_ _N_} _N_ _N_ } #-}
mkPolar :: RealFloat a => a -> a -> Complex a
{-# GHC_PRAGMA _A_ 3 _U_ 122 _N_ _N_ _N_ _SPECIALISE_ [ Double ] 1 { _A_ 2 _U_ 22 _N_ _N_ _N_ _N_ } #-}
phase :: RealFloat a => Complex a -> a
{-# GHC_PRAGMA _A_ 1 _U_ 22 _N_ _N_ _N_ _SPECIALISE_ [ Double ] 1 { _A_ 1 _U_ 2 _N_ _N_ _N_ _N_ } #-}
realPart :: Complex a -> a
{-# GHC_PRAGMA _A_ 1 _U_ 1 _N_ _S_ "U(SA)" {_A_ 1 _U_ 1 _N_ _N_ _F_ _IF_ARGS_ 1 1 X 1 _/\_ u0 -> \ (u1 :: u0) -> u1 _N_} _F_ _IF_ARGS_ 1 1 C 2 _/\_ u0 -> \ (u1 :: Complex u0) -> case u1 of { _ALG_ (:+) (u2 :: u0) (u3 :: u0) -> u2; _NO_DEFLT_ } _N_ #-}
-_ceiling :: (RealFrac a, Integral b) => a -> b
- {-# GHC_PRAGMA _A_ 2 _U_ 122 _N_ _S_ "U(U(AU(U(AAAASAAA)AAAA)A)LSAAAA)L" {_A_ 4 _U_ 11122 _N_ _N_ _N_ _N_} _N_ _SPECIALISE_ [ Double, Int ] 2 { _A_ 0 _U_ 2 _N_ _N_ _N_ _N_ } #-}
-_floor :: (RealFrac a, Integral b) => a -> b
- {-# GHC_PRAGMA _A_ 2 _U_ 122 _N_ _S_ "U(U(AU(U(ASAAAAAA)AAAA)A)LSAAAA)L" {_A_ 4 _U_ 11122 _N_ _N_ _N_ _N_} _N_ _SPECIALISE_ [ Double, Int ] 2 { _A_ 0 _U_ 2 _N_ _N_ _N_ _N_ } #-}
-_readList :: Text a => [Char] -> [([a], [Char])]
+_readList :: ([Char] -> [(a, [Char])]) -> [Char] -> [([a], [Char])]
{-# GHC_PRAGMA _A_ 1 _U_ 22 _N_ _N_ _N_ _N_ #-}
-_round :: (RealFrac a, Integral b) => a -> b
- {-# GHC_PRAGMA _A_ 2 _U_ 122 _N_ _S_ "U(U(AU(U(ALAAAAAS)AAAA)A)LSAAAA)L" {_A_ 5 _U_ 112122 _N_ _N_ _N_ _N_} _N_ _SPECIALISE_ [ Double, Int ] 2 { _A_ 0 _U_ 2 _N_ _N_ _N_ _N_ }, [ (Ratio Integer), Integer ] 2 { _A_ 1 _U_ 1 _N_ _S_ "U(LL)" {_A_ 2 _U_ 22 _N_ _N_ _N_ _N_} _N_ _N_ } #-}
-_showList :: Text a => [a] -> [Char] -> [Char]
- {-# GHC_PRAGMA _A_ 1 _U_ 212 _N_ _N_ _N_ _N_ #-}
+_showList :: (a -> [Char] -> [Char]) -> [a] -> [Char] -> [Char]
+ {-# GHC_PRAGMA _A_ 2 _U_ 212 _N_ _S_ "LS" _N_ _N_ #-}
_showRational :: Int -> Ratio Integer -> [Char]
{-# GHC_PRAGMA _A_ 2 _U_ 21 _N_ _S_ "LU(U(PPP)L)" {_A_ 5 _U_ 22222 _N_ _N_ _N_ _N_} _N_ _N_ #-}
-_truncate :: (RealFrac a, Integral b) => a -> b
- {-# GHC_PRAGMA _A_ 2 _U_ 122 _N_ _S_ "U(AASAAAA)L" {_A_ 2 _U_ 122 _N_ _N_ _N_ _N_} _N_ _SPECIALISE_ [ Double, Int ] 2 { _A_ 0 _U_ 2 _N_ _N_ _N_ _N_ } #-}
interact :: ([Char] -> [Char]) -> _State _RealWorld -> (Either IOError13 (), _State _RealWorld)
{-# GHC_PRAGMA _A_ 2 _U_ 11 _N_ _S_ "LU(P)" {_A_ 2 _U_ 12 _N_ _N_ _N_ _N_} _N_ _N_ #-}
(!!) :: Integral a => [b] -> a -> b
(++) :: [a] -> [a] -> [a]
{-# GHC_PRAGMA _A_ 2 _U_ 12 _N_ _S_ "SL" _N_ _N_ #-}
(\\) :: Eq a => [a] -> [a] -> [a]
- {-# GHC_PRAGMA _A_ 3 _U_ 122 _N_ _S_ "LLS" _N_ _N_ #-}
+ {-# GHC_PRAGMA _A_ 3 _U_ 122 _N_ _S_ "LLS" _N_ _SPECIALISE_ [ Int ] 1 { _A_ 2 _U_ 22 _N_ _S_ "LS" _N_ _N_ }, [ [Char] ] 1 { _A_ 2 _U_ 22 _N_ _S_ "LS" _N_ _N_ } #-}
all :: (a -> Bool) -> [a] -> Bool
{-# GHC_PRAGMA _A_ 2 _U_ 21 _N_ _S_ "LS" _F_ _ALWAYS_ _/\_ u0 -> \ (u1 :: u0 -> Bool) (u2 :: [u0]) -> let {(u3 :: Bool) = _!_ True [] []} in let {(u6 :: u0 -> Bool -> Bool) = \ (u4 :: u0) (u5 :: Bool) -> case _APP_ u1 [ u4 ] of { _ALG_ True -> u5; False -> _!_ False [] []; _NO_DEFLT_ }} in _APP_ _TYAPP_ _TYAPP_ foldr { u0 } { Bool } [ u6, u3, u2 ] _N_ #-}
and :: [Bool] -> Bool
dropWhile :: (a -> Bool) -> [a] -> [a]
{-# GHC_PRAGMA _A_ 2 _U_ 21 _N_ _S_ "LS" _N_ _N_ #-}
elem :: Eq a => a -> [a] -> Bool
- {-# GHC_PRAGMA _A_ 3 _U_ 121 _N_ _S_ "LLS" _F_ _ALWAYS_ _/\_ u0 -> \ (u1 :: {{Eq u0}}) (u2 :: u0) (u3 :: [u0]) -> let {(u6 :: u0 -> u0 -> Bool) = case u1 of { _ALG_ _TUP_2 (u4 :: u0 -> u0 -> Bool) (u5 :: u0 -> u0 -> Bool) -> u4; _NO_DEFLT_ }} in let {(u8 :: u0 -> Bool) = \ (u7 :: u0) -> _APP_ u6 [ u2, u7 ]} in _APP_ _TYAPP_ _ORIG_ PreludeList any { u0 } [ u8, u3 ] _SPECIALISE_ [ Char ] 1 { _A_ 2 _U_ 21 _N_ _S_ "LS" _F_ _ALWAYS_ \ (u0 :: Char) (u1 :: [Char]) -> let {(u5 :: Char -> Bool) = \ (u2 :: Char) -> case u0 of { _ALG_ C# (u3 :: Char#) -> case u2 of { _ALG_ C# (u4 :: Char#) -> _#_ eqChar# [] [u3, u4]; _NO_DEFLT_ }; _NO_DEFLT_ }} in _APP_ _TYAPP_ _ORIG_ PreludeList any { Char } [ u5, u1 ] _N_ }, [ Int ] 1 { _A_ 2 _U_ 21 _N_ _S_ "LS" _F_ _ALWAYS_ \ (u0 :: Int) (u1 :: [Int]) -> let {(u5 :: Int -> Bool) = \ (u2 :: Int) -> case u0 of { _ALG_ I# (u3 :: Int#) -> case u2 of { _ALG_ I# (u4 :: Int#) -> _#_ eqInt# [] [u3, u4]; _NO_DEFLT_ }; _NO_DEFLT_ }} in _APP_ _TYAPP_ _ORIG_ PreludeList any { Int } [ u5, u1 ] _N_ }, [ [Char] ] 1 { _A_ 2 _U_ 21 _N_ _S_ "LS" _F_ _ALWAYS_ \ (u0 :: [Char]) (u1 :: [[Char]]) -> let {(u3 :: [Char] -> Bool) = \ (u2 :: [Char]) -> _APP_ _CONSTM_ Eq (==) ([Char]) [ u0, u2 ]} in _APP_ _TYAPP_ _ORIG_ PreludeList any { [Char] } [ u3, u1 ] _N_ } #-}
+ {-# GHC_PRAGMA _A_ 3 _U_ 121 _N_ _S_ "LLS" _F_ _ALWAYS_ _/\_ u0 -> \ (u1 :: {{Eq u0}}) (u2 :: u0) (u3 :: [u0]) -> let {(u6 :: u0 -> u0 -> Bool) = case u1 of { _ALG_ _TUP_2 (u4 :: u0 -> u0 -> Bool) (u5 :: u0 -> u0 -> Bool) -> u4; _NO_DEFLT_ }} in let {(u8 :: u0 -> Bool) = \ (u7 :: u0) -> _APP_ u6 [ u2, u7 ]} in _APP_ _TYAPP_ _ORIG_ PreludeList any { u0 } [ u8, u3 ] _SPECIALISE_ [ Char ] 1 { _A_ 2 _U_ 21 _N_ _S_ "LS" _F_ _ALWAYS_ \ (u0 :: Char) (u1 :: [Char]) -> let {(u5 :: Char -> Bool) = \ (u2 :: Char) -> case u0 of { _ALG_ C# (u3 :: Char#) -> case u2 of { _ALG_ C# (u4 :: Char#) -> _#_ eqChar# [] [u3, u4]; _NO_DEFLT_ }; _NO_DEFLT_ }} in _APP_ _TYAPP_ _ORIG_ PreludeList any { Char } [ u5, u1 ] _N_ }, [ Int ] 1 { _A_ 2 _U_ 21 _N_ _S_ "LS" _F_ _ALWAYS_ \ (u0 :: Int) (u1 :: [Int]) -> let {(u5 :: Int -> Bool) = \ (u2 :: Int) -> case u0 of { _ALG_ I# (u3 :: Int#) -> case u2 of { _ALG_ I# (u4 :: Int#) -> _#_ eqInt# [] [u3, u4]; _NO_DEFLT_ }; _NO_DEFLT_ }} in _APP_ _TYAPP_ _ORIG_ PreludeList any { Int } [ u5, u1 ] _N_ }, [ Integer ] 1 { _A_ 2 _U_ 21 _N_ _S_ "LS" _F_ _ALWAYS_ \ (u0 :: Integer) (u1 :: [Integer]) -> let {(ua :: Integer -> Bool) = \ (u2 :: Integer) -> case u0 of { _ALG_ J# (u3 :: Int#) (u4 :: Int#) (u5 :: ByteArray#) -> case u2 of { _ALG_ J# (u6 :: Int#) (u7 :: Int#) (u8 :: ByteArray#) -> case _#_ cmpInteger# [] [u3, u4, u5, u6, u7, u8] of { _PRIM_ 0# -> _!_ True [] []; (u9 :: Int#) -> _!_ False [] [] }; _NO_DEFLT_ }; _NO_DEFLT_ }} in _APP_ _TYAPP_ _ORIG_ PreludeList any { Integer } [ ua, u1 ] _N_ }, [ [Char] ] 1 { _A_ 2 _U_ 21 _N_ _S_ "LS" _F_ _ALWAYS_ \ (u0 :: [Char]) (u1 :: [[Char]]) -> let {(u3 :: [Char] -> Bool) = \ (u2 :: [Char]) -> _APP_ _CONSTM_ Eq (==) ([Char]) [ u0, u2 ]} in _APP_ _TYAPP_ _ORIG_ PreludeList any { [Char] } [ u3, u1 ] _N_ }, [ [Int] ] 1 { _A_ 2 _U_ 21 _N_ _S_ "LS" _F_ _ALWAYS_ \ (u0 :: [Int]) (u1 :: [[Int]]) -> let {(u3 :: [Int] -> Bool) = \ (u2 :: [Int]) -> _APP_ _CONSTM_ Eq (==) ([Int]) [ u0, u2 ]} in _APP_ _TYAPP_ _ORIG_ PreludeList any { [Int] } [ u3, u1 ] _N_ }, [ (Int, Int) ] 1 { _A_ 2 _U_ 21 _N_ _S_ "LS" _F_ _ALWAYS_ \ (u0 :: (Int, Int)) (u1 :: [(Int, Int)]) -> let {(ub :: (Int, Int) -> Bool) = \ (u2 :: (Int, Int)) -> case u0 of { _ALG_ _TUP_2 (u3 :: Int) (u4 :: Int) -> case u3 of { _ALG_ I# (u5 :: Int#) -> case u2 of { _ALG_ _TUP_2 (u6 :: Int) (u7 :: Int) -> case u6 of { _ALG_ I# (u8 :: Int#) -> case _#_ eqInt# [] [u5, u8] of { _ALG_ True -> case u4 of { _ALG_ I# (u9 :: Int#) -> case u7 of { _ALG_ I# (ua :: Int#) -> _#_ eqInt# [] [u9, ua]; _NO_DEFLT_ }; _NO_DEFLT_ }; False -> _!_ False [] []; _NO_DEFLT_ }; _NO_DEFLT_ }; _NO_DEFLT_ }; _NO_DEFLT_ }; _NO_DEFLT_ }} in _APP_ _TYAPP_ _ORIG_ PreludeList any { (Int, Int) } [ ub, u1 ] _N_ } #-}
filter :: (a -> Bool) -> [a] -> [a]
{-# GHC_PRAGMA _A_ 2 _U_ 21 _N_ _S_ "LS" _F_ _ALWAYS_ _/\_ u0 -> \ (u1 :: u0 -> Bool) (u2 :: [u0]) -> let {(u9 :: _forall_ a$z1 =>(u0 -> a$z1 -> a$z1) -> a$z1 -> a$z1) = _/\_ u3 -> \ (u4 :: u0 -> u3 -> u3) (u5 :: u3) -> let {(u8 :: u0 -> u3 -> u3) = \ (u6 :: u0) (u7 :: u3) -> case _APP_ u1 [ u6 ] of { _ALG_ True -> _APP_ u4 [ u6, u7 ]; False -> u7; _NO_DEFLT_ }} in _APP_ _TYAPP_ _TYAPP_ foldr { u0 } { u3 } [ u8, u5, u2 ]} in _APP_ _TYAPP_ _build { u0 } [ u9 ] _N_ #-}
foldl1 :: (a -> a -> a) -> [a] -> a
foldr1 :: (a -> a -> a) -> [a] -> a
{-# GHC_PRAGMA _A_ 2 _U_ 21 _N_ _S_ "LS" _N_ _N_ #-}
genericLength :: Num b => [a] -> b
- {-# GHC_PRAGMA _A_ 1 _U_ 21 _N_ _N_ _N_ _N_ #-}
+ {-# GHC_PRAGMA _A_ 1 _U_ 21 _N_ _N_ _N_ _SPECIALISE_ [ _N_, Int ] 1 { _A_ 1 _U_ 1 _N_ _S_ "S" _N_ _N_ }, [ _N_, Integer ] 1 { _A_ 1 _U_ 1 _N_ _S_ "S" _N_ _N_ } #-}
head :: [a] -> a
{-# GHC_PRAGMA _A_ 1 _U_ 1 _N_ _S_ "S" _F_ _ALWAYS_ _/\_ u0 -> \ (u1 :: [u0]) -> let {(u2 :: u0) = _APP_ _TYAPP_ error { u0 } [ _NOREP_S_ "head{PreludeList}: head []\n" ]} in let {(u5 :: u0 -> u0 -> u0) = \ (u3 :: u0) (u4 :: u0) -> u3} in _APP_ _TYAPP_ _TYAPP_ foldr { u0 } { u0 } [ u5, u2, u1 ] _N_ #-}
init :: [a] -> [a]
map :: (a -> b) -> [a] -> [b]
{-# GHC_PRAGMA _A_ 2 _U_ 21 _N_ _S_ "LS" _F_ _ALWAYS_ _/\_ u0 u1 -> \ (u2 :: u0 -> u1) (u3 :: [u0]) -> let {(ua :: _forall_ a$z1 =>(u1 -> a$z1 -> a$z1) -> a$z1 -> a$z1) = _/\_ u4 -> \ (u5 :: u1 -> u4 -> u4) (u6 :: u4) -> let {(u9 :: u0 -> u4 -> u4) = \ (u7 :: u0) -> let {(u8 :: u1) = _APP_ u2 [ u7 ]} in _APP_ u5 [ u8 ]} in _APP_ _TYAPP_ _TYAPP_ foldr { u0 } { u4 } [ u9, u6, u3 ]} in _APP_ _TYAPP_ _build { u1 } [ ua ] _N_ #-}
maximum :: Ord a => [a] -> a
- {-# GHC_PRAGMA _A_ 1 _U_ 11 _N_ _N_ _N_ _N_ #-}
+ {-# GHC_PRAGMA _A_ 1 _U_ 11 _N_ _N_ _N_ _SPECIALISE_ [ Double ] 1 { _A_ 1 _U_ 1 _N_ _S_ "S" _N_ _N_ }, [ Int ] 1 { _A_ 1 _U_ 1 _N_ _S_ "S" _N_ _N_ }, [ Integer ] 1 { _A_ 1 _U_ 1 _N_ _S_ "S" _N_ _N_ } #-}
minimum :: Ord a => [a] -> a
- {-# GHC_PRAGMA _A_ 1 _U_ 11 _N_ _N_ _N_ _N_ #-}
+ {-# GHC_PRAGMA _A_ 1 _U_ 11 _N_ _N_ _N_ _SPECIALISE_ [ Double ] 1 { _A_ 1 _U_ 1 _N_ _S_ "S" _N_ _N_ }, [ Int ] 1 { _A_ 1 _U_ 1 _N_ _S_ "S" _N_ _N_ }, [ Integer ] 1 { _A_ 1 _U_ 1 _N_ _S_ "S" _N_ _N_ } #-}
notElem :: Eq a => a -> [a] -> Bool
- {-# GHC_PRAGMA _A_ 3 _U_ 121 _N_ _S_ "LLS" _F_ _ALWAYS_ _/\_ u0 -> \ (u1 :: {{Eq u0}}) (u2 :: u0) (u3 :: [u0]) -> let {(u6 :: u0 -> u0 -> Bool) = case u1 of { _ALG_ _TUP_2 (u4 :: u0 -> u0 -> Bool) (u5 :: u0 -> u0 -> Bool) -> u5; _NO_DEFLT_ }} in let {(u8 :: u0 -> Bool) = \ (u7 :: u0) -> _APP_ u6 [ u2, u7 ]} in _APP_ _TYAPP_ _ORIG_ PreludeList all { u0 } [ u8, u3 ] _SPECIALISE_ [ Char ] 1 { _A_ 2 _U_ 21 _N_ _S_ "LS" _F_ _ALWAYS_ \ (u0 :: Char) (u1 :: [Char]) -> let {(u5 :: Char -> Bool) = \ (u2 :: Char) -> case u0 of { _ALG_ C# (u3 :: Char#) -> case u2 of { _ALG_ C# (u4 :: Char#) -> _#_ neChar# [] [u3, u4]; _NO_DEFLT_ }; _NO_DEFLT_ }} in _APP_ _TYAPP_ _ORIG_ PreludeList all { Char } [ u5, u1 ] _N_ }, [ Int ] 1 { _A_ 2 _U_ 21 _N_ _S_ "LS" _F_ _ALWAYS_ \ (u0 :: Int) (u1 :: [Int]) -> let {(u5 :: Int -> Bool) = \ (u2 :: Int) -> case u0 of { _ALG_ I# (u3 :: Int#) -> case u2 of { _ALG_ I# (u4 :: Int#) -> _#_ neInt# [] [u3, u4]; _NO_DEFLT_ }; _NO_DEFLT_ }} in _APP_ _TYAPP_ _ORIG_ PreludeList all { Int } [ u5, u1 ] _N_ }, [ [Char] ] 1 { _A_ 2 _U_ 21 _N_ _S_ "LS" _F_ _ALWAYS_ \ (u0 :: [Char]) (u1 :: [[Char]]) -> let {(u3 :: [Char] -> Bool) = \ (u2 :: [Char]) -> _APP_ _CONSTM_ Eq (/=) ([Char]) [ u0, u2 ]} in _APP_ _TYAPP_ _ORIG_ PreludeList all { [Char] } [ u3, u1 ] _N_ } #-}
+ {-# GHC_PRAGMA _A_ 3 _U_ 121 _N_ _S_ "LLS" _F_ _ALWAYS_ _/\_ u0 -> \ (u1 :: {{Eq u0}}) (u2 :: u0) (u3 :: [u0]) -> let {(u6 :: u0 -> u0 -> Bool) = case u1 of { _ALG_ _TUP_2 (u4 :: u0 -> u0 -> Bool) (u5 :: u0 -> u0 -> Bool) -> u5; _NO_DEFLT_ }} in let {(u8 :: u0 -> Bool) = \ (u7 :: u0) -> _APP_ u6 [ u2, u7 ]} in _APP_ _TYAPP_ _ORIG_ PreludeList all { u0 } [ u8, u3 ] _SPECIALISE_ [ Char ] 1 { _A_ 2 _U_ 21 _N_ _S_ "LS" _F_ _ALWAYS_ \ (u0 :: Char) (u1 :: [Char]) -> let {(u5 :: Char -> Bool) = \ (u2 :: Char) -> case u0 of { _ALG_ C# (u3 :: Char#) -> case u2 of { _ALG_ C# (u4 :: Char#) -> _#_ neChar# [] [u3, u4]; _NO_DEFLT_ }; _NO_DEFLT_ }} in _APP_ _TYAPP_ _ORIG_ PreludeList all { Char } [ u5, u1 ] _N_ }, [ Int ] 1 { _A_ 2 _U_ 21 _N_ _S_ "LS" _F_ _ALWAYS_ \ (u0 :: Int) (u1 :: [Int]) -> let {(u5 :: Int -> Bool) = \ (u2 :: Int) -> case u0 of { _ALG_ I# (u3 :: Int#) -> case u2 of { _ALG_ I# (u4 :: Int#) -> _#_ neInt# [] [u3, u4]; _NO_DEFLT_ }; _NO_DEFLT_ }} in _APP_ _TYAPP_ _ORIG_ PreludeList all { Int } [ u5, u1 ] _N_ }, [ Integer ] 1 { _A_ 2 _U_ 21 _N_ _S_ "LS" _F_ _ALWAYS_ \ (u0 :: Integer) (u1 :: [Integer]) -> let {(ua :: Integer -> Bool) = \ (u2 :: Integer) -> case u0 of { _ALG_ J# (u3 :: Int#) (u4 :: Int#) (u5 :: ByteArray#) -> case u2 of { _ALG_ J# (u6 :: Int#) (u7 :: Int#) (u8 :: ByteArray#) -> case _#_ cmpInteger# [] [u3, u4, u5, u6, u7, u8] of { _PRIM_ 0# -> _!_ False [] []; (u9 :: Int#) -> _!_ True [] [] }; _NO_DEFLT_ }; _NO_DEFLT_ }} in _APP_ _TYAPP_ _ORIG_ PreludeList all { Integer } [ ua, u1 ] _N_ }, [ [Char] ] 1 { _A_ 2 _U_ 21 _N_ _S_ "LS" _F_ _ALWAYS_ \ (u0 :: [Char]) (u1 :: [[Char]]) -> let {(u3 :: [Char] -> Bool) = \ (u2 :: [Char]) -> _APP_ _CONSTM_ Eq (/=) ([Char]) [ u0, u2 ]} in _APP_ _TYAPP_ _ORIG_ PreludeList all { [Char] } [ u3, u1 ] _N_ }, [ (Int, Int) ] 1 { _A_ 2 _U_ 21 _N_ _S_ "LS" _F_ _ALWAYS_ \ (u0 :: (Int, Int)) (u1 :: [(Int, Int)]) -> let {(ub :: (Int, Int) -> Bool) = \ (u2 :: (Int, Int)) -> case u0 of { _ALG_ _TUP_2 (u3 :: Int) (u4 :: Int) -> case u3 of { _ALG_ I# (u5 :: Int#) -> case u2 of { _ALG_ _TUP_2 (u6 :: Int) (u7 :: Int) -> case u6 of { _ALG_ I# (u8 :: Int#) -> case _#_ neInt# [] [u5, u8] of { _ALG_ True -> _!_ True [] []; False -> case u4 of { _ALG_ I# (u9 :: Int#) -> case u7 of { _ALG_ I# (ua :: Int#) -> _#_ neInt# [] [u9, ua]; _NO_DEFLT_ }; _NO_DEFLT_ }; _NO_DEFLT_ }; _NO_DEFLT_ }; _NO_DEFLT_ }; _NO_DEFLT_ }; _NO_DEFLT_ }} in _APP_ _TYAPP_ _ORIG_ PreludeList all { (Int, Int) } [ ub, u1 ] _N_ } #-}
nub :: Eq a => [a] -> [a]
- {-# GHC_PRAGMA _A_ 2 _U_ 11 _N_ _S_ "LS" _N_ _N_ #-}
+ {-# GHC_PRAGMA _A_ 2 _U_ 11 _N_ _S_ "LS" _N_ _SPECIALISE_ [ Int ] 1 { _A_ 1 _U_ 1 _N_ _S_ "S" _N_ _N_ }, [ [Char] ] 1 { _A_ 1 _U_ 1 _N_ _S_ "S" _N_ _N_ }, [ [Int] ] 1 { _A_ 1 _U_ 1 _N_ _S_ "S" _N_ _N_ } #-}
null :: [a] -> Bool
{-# GHC_PRAGMA _A_ 1 _U_ 1 _N_ _S_ "S" _F_ _ALWAYS_ _/\_ u0 -> \ (u1 :: [u0]) -> let {(u2 :: Bool) = _!_ True [] []} in let {(u5 :: u0 -> Bool -> Bool) = \ (u3 :: u0) (u4 :: Bool) -> _!_ False [] []} in _APP_ _TYAPP_ _TYAPP_ foldr { u0 } { Bool } [ u5, u2, u1 ] _N_ #-}
or :: [Bool] -> Bool
partition :: (a -> Bool) -> [a] -> ([a], [a])
{-# GHC_PRAGMA _A_ 2 _U_ 21 _N_ _S_ "LS" _F_ _ALWAYS_ _/\_ u0 -> \ (u1 :: u0 -> Bool) (u2 :: [u0]) -> let {(u9 :: u0 -> ([u0], [u0]) -> ([u0], [u0])) = \ (u3 :: u0) (u4 :: ([u0], [u0])) -> case u4 of { _ALG_ _TUP_2 (u5 :: [u0]) (u6 :: [u0]) -> case _APP_ u1 [ u3 ] of { _ALG_ True -> let {(u7 :: [u0]) = _!_ (:) [u0] [u3, u5]} in _!_ _TUP_2 [[u0], [u0]] [u7, u6]; False -> let {(u8 :: [u0]) = _!_ (:) [u0] [u3, u6]} in _!_ _TUP_2 [[u0], [u0]] [u5, u8]; _NO_DEFLT_ }; _NO_DEFLT_ }} in let {(ua :: [u0]) = _!_ _NIL_ [u0] []} in let {(ub :: ([u0], [u0])) = _!_ _TUP_2 [[u0], [u0]] [ua, ua]} in _APP_ _TYAPP_ _TYAPP_ foldr { u0 } { ([u0], [u0]) } [ u9, ub, u2 ] _N_ #-}
product :: Num a => [a] -> a
- {-# GHC_PRAGMA _A_ 1 _U_ 22 _N_ _N_ _F_ _ALWAYS_ _/\_ u0 -> \ (u1 :: {{Num u0}}) -> let {(uc :: u0 -> u0 -> u0) = case u1 of { _ALG_ _TUP_10 (u2 :: {{Eq u0}}) (u3 :: {{Text u0}}) (u4 :: u0 -> u0 -> u0) (u5 :: u0 -> u0 -> u0) (u6 :: u0 -> u0 -> u0) (u7 :: u0 -> u0) (u8 :: u0 -> u0) (u9 :: u0 -> u0) (ua :: Integer -> u0) (ub :: Int -> u0) -> u6; _NO_DEFLT_ }} in let {(uo :: u0) = let {(ud :: Int) = _!_ I# [] [1#]} in case u1 of { _ALG_ _TUP_10 (ue :: {{Eq u0}}) (uf :: {{Text u0}}) (ug :: u0 -> u0 -> u0) (uh :: u0 -> u0 -> u0) (ui :: u0 -> u0 -> u0) (uj :: u0 -> u0) (uk :: u0 -> u0) (ul :: u0 -> u0) (um :: Integer -> u0) (un :: Int -> u0) -> _APP_ un [ ud ]; _NO_DEFLT_ }} in \ (up :: [u0]) -> _APP_ _TYAPP_ _TYAPP_ foldl { u0 } { u0 } [ uc, uo, up ] _SPECIALISE_ [ Double ] 1 { _A_ 1 _U_ 1 _N_ _S_ "S" _F_ _ALWAYS_ \ (u0 :: [Double]) -> let {(u1 :: Double) = _!_ D# [] [1.0000000000000000##]} in _APP_ _TYAPP_ _TYAPP_ foldl { Double } { Double } [ _CONSTM_ Num (*) (Double), u1, u0 ] _N_ }, [ Int ] 1 { _A_ 1 _U_ 1 _N_ _S_ "S" _F_ _ALWAYS_ \ (u0 :: [Int]) -> let {(u1 :: Int) = _!_ I# [] [1#]} in _APP_ _TYAPP_ _TYAPP_ foldl { Int } { Int } [ _CONSTM_ Num (*) (Int), u1, u0 ] _N_ }, [ Integer ] 1 { _A_ 1 _U_ 1 _N_ _S_ "S" _F_ _ALWAYS_ \ (u0 :: [Integer]) -> let {(u1 :: Integer) = _#_ int2Integer# [] [1#]} in _APP_ _TYAPP_ _TYAPP_ foldl { Integer } { Integer } [ _CONSTM_ Num (*) (Integer), u1, u0 ] _N_ } #-}
+ {-# GHC_PRAGMA _A_ 1 _U_ 22 _N_ _N_ _F_ _ALWAYS_ _/\_ u0 -> \ (u1 :: {{Num u0}}) -> let {(uc :: u0 -> u0 -> u0) = case u1 of { _ALG_ _TUP_10 (u2 :: {{Eq u0}}) (u3 :: {{Text u0}}) (u4 :: u0 -> u0 -> u0) (u5 :: u0 -> u0 -> u0) (u6 :: u0 -> u0 -> u0) (u7 :: u0 -> u0) (u8 :: u0 -> u0) (u9 :: u0 -> u0) (ua :: Integer -> u0) (ub :: Int -> u0) -> u6; _NO_DEFLT_ }} in let {(uo :: u0) = let {(ud :: Int) = _!_ I# [] [1#]} in case u1 of { _ALG_ _TUP_10 (ue :: {{Eq u0}}) (uf :: {{Text u0}}) (ug :: u0 -> u0 -> u0) (uh :: u0 -> u0 -> u0) (ui :: u0 -> u0 -> u0) (uj :: u0 -> u0) (uk :: u0 -> u0) (ul :: u0 -> u0) (um :: Integer -> u0) (un :: Int -> u0) -> _APP_ un [ ud ]; _NO_DEFLT_ }} in \ (up :: [u0]) -> _APP_ _TYAPP_ _TYAPP_ foldl { u0 } { u0 } [ uc, uo, up ] _SPECIALISE_ [ Double ] 1 { _A_ 1 _U_ 1 _N_ _S_ "S" _F_ _ALWAYS_ \ (u0 :: [Double]) -> let {(u1 :: Double) = _!_ D# [] [1.0000000000000000##]} in _APP_ _TYAPP_ _TYAPP_ foldl { Double } { Double } [ _CONSTM_ Num (*) (Double), u1, u0 ] _N_ }, [ Int ] 1 { _A_ 1 _U_ 1 _N_ _S_ "S" _F_ _ALWAYS_ \ (u0 :: [Int]) -> let {(u1 :: Int) = _!_ I# [] [1#]} in _APP_ _TYAPP_ _TYAPP_ foldl { Int } { Int } [ _CONSTM_ Num (*) (Int), u1, u0 ] _N_ }, [ Integer ] 1 { _A_ 1 _U_ 1 _N_ _S_ "S" _F_ _ALWAYS_ \ (u0 :: [Integer]) -> let {(u1 :: Integer) = _#_ int2Integer# [] [1#]} in _APP_ _TYAPP_ _TYAPP_ foldl { Integer } { Integer } [ _CONSTM_ Num (*) (Integer), u1, u0 ] _N_ }, [ (Complex Double) ] 1 { _A_ 1 _U_ 1 _N_ _S_ "S" _F_ _ALWAYS_ let {(u6 :: Complex Double -> Complex Double -> Complex Double) = \ (u0 :: Complex Double) (u1 :: Complex Double) -> case u0 of { _ALG_ (:+) (u2 :: Double) (u3 :: Double) -> case u1 of { _ALG_ (:+) (u4 :: Double) (u5 :: Double) -> _APP_ _WRKR_ _CONSTM_ Num (*) (Complex Double) [ u2, u3, u4, u5 ]; _NO_DEFLT_ }; _NO_DEFLT_ }} in let {(u8 :: Complex Double) = let {(u7 :: Int) = _!_ I# [] [1#]} in _APP_ _CONSTM_ Num fromInt (Complex Double) [ u7 ]} in \ (u9 :: [Complex Double]) -> _APP_ _TYAPP_ _TYAPP_ foldl { (Complex Double) } { (Complex Double) } [ u6, u8, u9 ] _N_ } #-}
products :: Num a => [a] -> [a]
- {-# GHC_PRAGMA _A_ 1 _U_ 21 _N_ _N_ _N_ _N_ #-}
+ {-# GHC_PRAGMA _A_ 1 _U_ 21 _N_ _N_ _N_ _SPECIALISE_ [ Double ] 1 { _A_ 1 _U_ 1 _N_ _N_ _N_ _N_ }, [ Int ] 1 { _A_ 1 _U_ 1 _N_ _N_ _N_ _N_ }, [ Integer ] 1 { _A_ 1 _U_ 1 _N_ _N_ _F_ _IF_ARGS_ 0 1 X 4 \ (u0 :: [Integer]) -> _APP_ _TYAPP_ _TYAPP_ _ORIG_ PreludeList scanl { Integer } { Integer } [ _CONSTM_ Num (*) (Integer), _SPEC_ _ORIG_ PreludeCore __i1 [ (Integer) ], u0 ] _N_ }, [ (Complex Double) ] 1 { _A_ 1 _U_ 1 _N_ _N_ _N_ _N_ } #-}
repeat :: a -> [a]
{-# GHC_PRAGMA _A_ 1 _U_ 2 _N_ _N_ _F_ _ALWAYS_ _/\_ u0 -> \ (u1 :: u0) -> let {(u6 :: _forall_ a$z1 =>(u0 -> a$z1 -> a$z1) -> a$z1 -> a$z1) = _/\_ u2 -> \ (u3 :: u0 -> u2 -> u2) (u4 :: u2) -> _LETREC_ {(u5 :: u2) = _APP_ u3 [ u1, u5 ]} in u5} in _APP_ _TYAPP_ _build { u0 } [ u6 ] _N_ #-}
reverse :: [a] -> [a]
sum :: Num a => [a] -> a
{-# GHC_PRAGMA _A_ 1 _U_ 22 _N_ _N_ _F_ _ALWAYS_ _/\_ u0 -> \ (u1 :: {{Num u0}}) -> let {(uc :: u0 -> u0 -> u0) = case u1 of { _ALG_ _TUP_10 (u2 :: {{Eq u0}}) (u3 :: {{Text u0}}) (u4 :: u0 -> u0 -> u0) (u5 :: u0 -> u0 -> u0) (u6 :: u0 -> u0 -> u0) (u7 :: u0 -> u0) (u8 :: u0 -> u0) (u9 :: u0 -> u0) (ua :: Integer -> u0) (ub :: Int -> u0) -> u4; _NO_DEFLT_ }} in let {(uo :: u0) = let {(ud :: Int) = _!_ I# [] [0#]} in case u1 of { _ALG_ _TUP_10 (ue :: {{Eq u0}}) (uf :: {{Text u0}}) (ug :: u0 -> u0 -> u0) (uh :: u0 -> u0 -> u0) (ui :: u0 -> u0 -> u0) (uj :: u0 -> u0) (uk :: u0 -> u0) (ul :: u0 -> u0) (um :: Integer -> u0) (un :: Int -> u0) -> _APP_ un [ ud ]; _NO_DEFLT_ }} in \ (up :: [u0]) -> _APP_ _TYAPP_ _TYAPP_ foldl { u0 } { u0 } [ uc, uo, up ] _SPECIALISE_ [ Double ] 1 { _A_ 1 _U_ 1 _N_ _S_ "S" _F_ _ALWAYS_ \ (u0 :: [Double]) -> let {(u1 :: Double) = _!_ D# [] [0.0000000000000000##]} in _APP_ _TYAPP_ _TYAPP_ foldl { Double } { Double } [ _CONSTM_ Num (+) (Double), u1, u0 ] _N_ }, [ Int ] 1 { _A_ 1 _U_ 1 _N_ _S_ "S" _F_ _ALWAYS_ \ (u0 :: [Int]) -> let {(u1 :: Int) = _!_ I# [] [0#]} in _APP_ _TYAPP_ _TYAPP_ foldl { Int } { Int } [ _CONSTM_ Num (+) (Int), u1, u0 ] _N_ }, [ Integer ] 1 { _A_ 1 _U_ 1 _N_ _S_ "S" _F_ _ALWAYS_ \ (u0 :: [Integer]) -> let {(u1 :: Integer) = _#_ int2Integer# [] [0#]} in _APP_ _TYAPP_ _TYAPP_ foldl { Integer } { Integer } [ _CONSTM_ Num (+) (Integer), u1, u0 ] _N_ }, [ (Complex Double) ] 1 { _A_ 1 _U_ 1 _N_ _S_ "S" _F_ _ALWAYS_ let {(u6 :: Complex Double -> Complex Double -> Complex Double) = \ (u0 :: Complex Double) (u1 :: Complex Double) -> case u0 of { _ALG_ (:+) (u2 :: Double) (u3 :: Double) -> case u1 of { _ALG_ (:+) (u4 :: Double) (u5 :: Double) -> _APP_ _WRKR_ _CONSTM_ Num (+) (Complex Double) [ u2, u3, u4, u5 ]; _NO_DEFLT_ }; _NO_DEFLT_ }} in let {(u8 :: Complex Double) = let {(u7 :: Int) = _!_ I# [] [0#]} in _APP_ _CONSTM_ Num fromInt (Complex Double) [ u7 ]} in \ (u9 :: [Complex Double]) -> _APP_ _TYAPP_ _TYAPP_ foldl { (Complex Double) } { (Complex Double) } [ u6, u8, u9 ] _N_ } #-}
sums :: Num a => [a] -> [a]
- {-# GHC_PRAGMA _A_ 1 _U_ 21 _N_ _N_ _N_ _N_ #-}
+ {-# GHC_PRAGMA _A_ 1 _U_ 21 _N_ _N_ _N_ _SPECIALISE_ [ Double ] 1 { _A_ 1 _U_ 1 _N_ _N_ _N_ _N_ }, [ Int ] 1 { _A_ 1 _U_ 1 _N_ _N_ _N_ _N_ }, [ Integer ] 1 { _A_ 1 _U_ 1 _N_ _N_ _F_ _IF_ARGS_ 0 1 X 4 \ (u0 :: [Integer]) -> _APP_ _TYAPP_ _TYAPP_ _ORIG_ PreludeList scanl { Integer } { Integer } [ _CONSTM_ Num (+) (Integer), _SPEC_ _ORIG_ PreludeCore __i0 [ (Integer) ], u0 ] _N_ }, [ (Complex Double) ] 1 { _A_ 1 _U_ 1 _N_ _N_ _N_ _N_ } #-}
tail :: [a] -> [a]
{-# GHC_PRAGMA _A_ 1 _U_ 1 _N_ _S_ "S" _F_ _IF_ARGS_ 1 1 C 5 _/\_ u0 -> \ (u1 :: [u0]) -> case u1 of { _ALG_ (:) (u2 :: u0) (u3 :: [u0]) -> u3; _NIL_ -> _APP_ _TYAPP_ error { [u0] } [ _NOREP_S_ "tail{PreludeList}: tail []\n" ]; _NO_DEFLT_ } _N_ #-}
take :: Integral a => a -> [b] -> [b]
- {-# GHC_PRAGMA _A_ 3 _U_ 121 _N_ _S_ "U(AAAAAAAAAAAS)LL" {_A_ 3 _U_ 121 _N_ _N_ _N_ _N_} _F_ _IF_ARGS_ 2 3 CXX 7 _/\_ u0 u1 -> \ (u2 :: {{Integral u0}}) (u3 :: u0) (u4 :: [u1]) -> let {(uh :: Int) = case u2 of { _ALG_ _TUP_12 (u5 :: {{Real u0}}) (u6 :: {{Ix u0}}) (u7 :: u0 -> u0 -> u0) (u8 :: u0 -> u0 -> u0) (u9 :: u0 -> u0 -> u0) (ua :: u0 -> u0 -> u0) (ub :: u0 -> u0 -> (u0, u0)) (uc :: u0 -> u0 -> (u0, u0)) (ud :: u0 -> Bool) (ue :: u0 -> Bool) (uf :: u0 -> Integer) (ug :: u0 -> Int) -> _APP_ ug [ u3 ]; _NO_DEFLT_ }} in _APP_ _TYAPP_ _SPEC_ _ORIG_ PreludeList take [ (Int), _N_ ] { u1 } [ uh, u4 ] _SPECIALISE_ [ Int, _N_ ] 1 { _A_ 2 _U_ 11 _N_ _S_ "U(P)L" {_A_ 2 _U_ 21 _N_ _N_ _N_ _N_} _N_ _N_ }, [ Integer, _N_ ] 1 { _A_ 2 _U_ 11 _N_ _S_ "U(PPP)L" {_A_ 4 _U_ 2221 _N_ _N_ _F_ _IF_ARGS_ 1 4 XXXX 4 _/\_ u0 -> \ (u1 :: Int#) (u2 :: Int#) (u3 :: ByteArray#) (u4 :: [u0]) -> case _#_ integer2Int# [] [u1, u2, u3] of { _PRIM_ (u5 :: Int#) -> _APP_ _TYAPP_ _WRKR_ _SPEC_ _ORIG_ PreludeList take [ (Int), _N_ ] { u0 } [ u5, u4 ] } _N_} _F_ _ALWAYS_ _/\_ u0 -> \ (u1 :: Integer) (u2 :: [u0]) -> case u1 of { _ALG_ J# (u3 :: Int#) (u4 :: Int#) (u5 :: ByteArray#) -> case _#_ integer2Int# [] [u3, u4, u5] of { _PRIM_ (u6 :: Int#) -> _APP_ _TYAPP_ _WRKR_ _SPEC_ _ORIG_ PreludeList take [ (Int), _N_ ] { u0 } [ u6, u2 ] }; _NO_DEFLT_ } _N_ } #-}
+ {-# GHC_PRAGMA _A_ 1 _U_ 122 _N_ _S_ "U(LU(U(ASSAAAAA)AAA)AAAALAAAAL)" {_A_ 5 _U_ 2121222 _N_ _N_ _N_ _N_} _N_ _SPECIALISE_ [ Int, _N_ ] 1 { _A_ 2 _U_ 11 _N_ _S_ "U(P)L" {_A_ 2 _U_ 21 _N_ _N_ _N_ _N_} _N_ _N_ }, [ Integer, _N_ ] 1 { _A_ 1 _U_ 12 _N_ _S_ "U(PPP)" {_A_ 3 _U_ 2222 _N_ _N_ _N_ _N_} _N_ _N_ } #-}
takeWhile :: (a -> Bool) -> [a] -> [a]
{-# GHC_PRAGMA _A_ 2 _U_ 21 _N_ _S_ "LS" _F_ _ALWAYS_ _/\_ u0 -> \ (u1 :: u0 -> Bool) (u2 :: [u0]) -> let {(u9 :: _forall_ a$z1 =>(u0 -> a$z1 -> a$z1) -> a$z1 -> a$z1) = _/\_ u3 -> \ (u4 :: u0 -> u3 -> u3) (u5 :: u3) -> let {(u8 :: u0 -> u3 -> u3) = \ (u6 :: u0) (u7 :: u3) -> case _APP_ u1 [ u6 ] of { _ALG_ True -> _APP_ u4 [ u6, u7 ]; False -> u5; _NO_DEFLT_ }} in _APP_ _TYAPP_ _TYAPP_ foldr { u0 } { u3 } [ u8, u5, u2 ]} in _APP_ _TYAPP_ _build { u0 } [ u9 ] _N_ #-}
transpose :: [[a]] -> [[a]]
lex :: [Char] -> [([Char], [Char])]
{-# GHC_PRAGMA _A_ 1 _U_ 2 _N_ _S_ "S" _N_ _N_ #-}
read :: Text a => [Char] -> a
- {-# GHC_PRAGMA _A_ 1 _U_ 12 _N_ _S_ "U(SAAA)" {_A_ 1 _U_ 12 _N_ _N_ _N_ _N_} _N_ _SPECIALISE_ [ Double ] 1 { _A_ 1 _U_ 2 _N_ _N_ _N_ _N_ }, [ Float ] 1 { _A_ 1 _U_ 2 _N_ _N_ _N_ _N_ }, [ Int ] 1 { _A_ 1 _U_ 2 _N_ _N_ _N_ _N_ }, [ Integer ] 1 { _A_ 1 _U_ 2 _N_ _N_ _N_ _N_ } #-}
+ {-# GHC_PRAGMA _A_ 1 _U_ 12 _N_ _S_ "U(SAAA)" {_A_ 1 _U_ 12 _N_ _N_ _N_ _N_} _N_ _SPECIALISE_ [ Bool ] 1 { _A_ 1 _U_ 2 _N_ _N_ _N_ _N_ }, [ Char ] 1 { _A_ 1 _U_ 2 _N_ _N_ _N_ _N_ }, [ Double ] 1 { _A_ 1 _U_ 2 _N_ _N_ _N_ _N_ }, [ Int ] 1 { _A_ 1 _U_ 2 _N_ _N_ _N_ _N_ }, [ Integer ] 1 { _A_ 1 _U_ 2 _N_ _N_ _N_ _N_ }, [ [Bool] ] 1 { _A_ 1 _U_ 2 _N_ _N_ _N_ _N_ }, [ [Char] ] 1 { _A_ 1 _U_ 2 _N_ _N_ _N_ _N_ }, [ [Double] ] 1 { _A_ 1 _U_ 2 _N_ _N_ _N_ _N_ }, [ [Float] ] 1 { _A_ 1 _U_ 2 _N_ _N_ _N_ _N_ }, [ [Int] ] 1 { _A_ 1 _U_ 2 _N_ _N_ _N_ _N_ }, [ [Integer] ] 1 { _A_ 1 _U_ 2 _N_ _N_ _N_ _N_ }, [ [[Char]] ] 1 { _A_ 1 _U_ 2 _N_ _N_ _N_ _N_ }, [ [[Int]] ] 1 { _A_ 1 _U_ 2 _N_ _N_ _N_ _N_ }, [ [Complex Double] ] 1 { _A_ 1 _U_ 2 _N_ _N_ _N_ _N_ }, [ (Ratio Integer) ] 1 { _A_ 1 _U_ 2 _N_ _N_ _N_ _N_ }, [ (Array Int Double) ] 1 { _A_ 1 _U_ 2 _N_ _N_ _N_ _N_ }, [ (Array (Int, Int) Double) ] 1 { _A_ 1 _U_ 2 _N_ _N_ _N_ _N_ }, [ _PackedString ] 1 { _A_ 1 _U_ 2 _N_ _S_ _!_ _N_ _N_ }, [ (Complex Double) ] 1 { _A_ 1 _U_ 2 _N_ _N_ _N_ _N_ }, [ () ] 1 { _A_ 1 _U_ 2 _N_ _N_ _N_ _N_ }, [ (Int, Int) ] 1 { _A_ 1 _U_ 2 _N_ _N_ _N_ _N_ }, [ (Integer, Integer) ] 1 { _A_ 1 _U_ 2 _N_ _N_ _N_ _N_ }, [ (Int, Int, Int) ] 1 { _A_ 1 _U_ 2 _N_ _N_ _N_ _N_ } #-}
readDec :: Integral a => [Char] -> [(a, [Char])]
- {-# GHC_PRAGMA _A_ 1 _U_ 22 _N_ _N_ _N_ _SPECIALISE_ [ Int ] 1 { _A_ 1 _U_ 2 _N_ _N_ _N_ _N_ }, [ Integer ] 1 { _A_ 1 _U_ 2 _N_ _S_ "S" _N_ _N_ } #-}
+ {-# GHC_PRAGMA _A_ 1 _U_ 22 _N_ _N_ _N_ _SPECIALISE_ [ Int ] 1 { _A_ 1 _U_ 2 _N_ _N_ _N_ _N_ }, [ Integer ] 1 { _A_ 1 _U_ 2 _N_ _N_ _N_ _N_ } #-}
readFloat :: RealFloat a => [Char] -> [(a, [Char])]
- {-# GHC_PRAGMA _A_ 2 _U_ 12 _N_ _S_ "LS" _N_ _SPECIALISE_ [ Double ] 1 { _A_ 1 _U_ 2 _N_ _S_ "S" _N_ _N_ }, [ Float ] 1 { _A_ 1 _U_ 2 _N_ _S_ "S" _N_ _N_ } #-}
+ {-# GHC_PRAGMA _A_ 2 _U_ 12 _N_ _S_ "LS" _N_ _SPECIALISE_ [ Double ] 1 { _A_ 1 _U_ 2 _N_ _S_ "S" _N_ _N_ } #-}
readLitChar :: [Char] -> [(Char, [Char])]
{-# GHC_PRAGMA _A_ 0 _U_ 1 _N_ _N_ _N_ _N_ #-}
readParen :: Bool -> ([Char] -> [(a, [Char])]) -> [Char] -> [(a, [Char])]
readSigned :: Real a => ([Char] -> [(a, [Char])]) -> [Char] -> [(a, [Char])]
{-# GHC_PRAGMA _A_ 2 _U_ 122 _N_ _N_ _N_ _SPECIALISE_ [ Double ] 1 { _A_ 1 _U_ 22 _N_ _N_ _N_ _N_ }, [ Int ] 1 { _A_ 1 _U_ 22 _N_ _N_ _N_ _N_ }, [ Integer ] 1 { _A_ 1 _U_ 22 _N_ _N_ _N_ _N_ } #-}
reads :: Text a => [Char] -> [(a, [Char])]
- {-# GHC_PRAGMA _A_ 1 _U_ 12 _N_ _S_ "U(SAAA)" {_A_ 1 _U_ 12 _N_ _N_ _N_ _N_} _N_ _SPECIALISE_ [ Double ] 1 { _A_ 1 _U_ 2 _N_ _N_ _N_ _N_ }, [ Float ] 1 { _A_ 1 _U_ 2 _N_ _N_ _N_ _N_ }, [ Int ] 1 { _A_ 1 _U_ 2 _N_ _N_ _N_ _N_ }, [ Integer ] 1 { _A_ 1 _U_ 2 _N_ _N_ _N_ _N_ } #-}
+ {-# GHC_PRAGMA _A_ 1 _U_ 12 _N_ _S_ "U(SAAA)" {_A_ 1 _U_ 12 _N_ _N_ _N_ _N_} _N_ _SPECIALISE_ [ Bool ] 1 { _A_ 1 _U_ 2 _N_ _N_ _N_ _N_ }, [ Char ] 1 { _A_ 0 _U_ 2 _N_ _N_ _N_ _N_ }, [ Double ] 1 { _A_ 1 _U_ 2 _N_ _N_ _N_ _N_ }, [ Int ] 1 { _A_ 1 _U_ 2 _N_ _N_ _N_ _N_ }, [ Integer ] 1 { _A_ 1 _U_ 2 _N_ _N_ _N_ _N_ }, [ [Bool] ] 1 { _A_ 0 _U_ 2 _N_ _N_ _F_ _IF_ARGS_ 0 0 X 1 _CONSTM_ Text readList (Bool) _N_ }, [ [Char] ] 1 { _A_ 0 _U_ 2 _N_ _N_ _F_ _IF_ARGS_ 0 0 X 1 _CONSTM_ Text readList (Char) _N_ }, [ [Double] ] 1 { _A_ 0 _U_ 2 _N_ _N_ _F_ _IF_ARGS_ 0 0 X 1 _CONSTM_ Text readList (Double) _N_ }, [ [Float] ] 1 { _A_ 0 _U_ 2 _N_ _N_ _N_ _N_ }, [ [Int] ] 1 { _A_ 0 _U_ 2 _N_ _N_ _F_ _IF_ARGS_ 0 0 X 1 _CONSTM_ Text readList (Int) _N_ }, [ [Integer] ] 1 { _A_ 0 _U_ 2 _N_ _N_ _F_ _IF_ARGS_ 0 0 X 1 _CONSTM_ Text readList (Integer) _N_ }, [ [[Char]] ] 1 { _A_ 0 _U_ 2 _N_ _N_ _F_ _IF_ARGS_ 0 0 X 1 _CONSTM_ Text readList ([Char]) _N_ }, [ [[Int]] ] 1 { _A_ 0 _U_ 2 _N_ _N_ _F_ _IF_ARGS_ 0 0 X 1 _CONSTM_ Text readList ([Int]) _N_ }, [ [Complex Double] ] 1 { _A_ 0 _U_ 2 _N_ _N_ _F_ _IF_ARGS_ 0 0 X 1 _CONSTM_ Text readList (Complex Double) _N_ }, [ (Ratio Integer) ] 1 { _A_ 0 _U_ 2 _N_ _N_ _N_ _N_ }, [ (Array Int Double) ] 1 { _A_ 0 _U_ 2 _N_ _N_ _N_ _N_ }, [ (Array (Int, Int) Double) ] 1 { _A_ 0 _U_ 2 _N_ _N_ _N_ _N_ }, [ _PackedString ] 1 { _A_ 1 _U_ 2 _N_ _S_ _!_ _N_ _N_ }, [ (Complex Double) ] 1 { _A_ 0 _U_ 2 _N_ _N_ _N_ _N_ }, [ () ] 1 { _A_ 0 _U_ 2 _N_ _N_ _N_ _N_ }, [ (Int, Int) ] 1 { _A_ 0 _U_ 2 _N_ _N_ _N_ _N_ }, [ (Integer, Integer) ] 1 { _A_ 0 _U_ 2 _N_ _N_ _N_ _N_ }, [ (Int, Int, Int) ] 1 { _A_ 0 _U_ 2 _N_ _N_ _N_ _N_ } #-}
show :: Text a => a -> [Char]
- {-# GHC_PRAGMA _A_ 1 _U_ 12 _N_ _S_ "U(ASAA)" {_A_ 1 _U_ 12 _N_ _N_ _N_ _N_} _N_ _SPECIALISE_ [ Char ] 1 { _A_ 1 _U_ 1 _N_ _S_ "U(P)" {_A_ 1 _U_ 2 _N_ _N_ _N_ _N_} _N_ _N_ }, [ Double ] 1 { _A_ 1 _U_ 1 _N_ _S_ "U(P)" {_A_ 1 _U_ 2 _N_ _N_ _N_ _N_} _N_ _N_ }, [ Float ] 1 { _A_ 1 _U_ 2 _N_ _N_ _N_ _N_ }, [ Int ] 1 { _A_ 1 _U_ 1 _N_ _S_ "U(P)" {_A_ 1 _U_ 2 _N_ _N_ _N_ _N_} _N_ _N_ }, [ Integer ] 1 { _A_ 1 _U_ 1 _N_ _S_ "U(PPP)" {_A_ 3 _U_ 222 _N_ _N_ _N_ _N_} _N_ _N_ }, [ [Char] ] 1 { _A_ 1 _U_ 2 _N_ _N_ _N_ _N_ }, [ _PackedString ] 1 { _A_ 1 _U_ 1 _N_ _N_ _N_ _N_ }, [ (Int, Int) ] 1 { _A_ 1 _U_ 1 _N_ _S_ "U(LL)" {_A_ 2 _U_ 22 _N_ _N_ _N_ _N_} _N_ _N_ }, [ (Integer, Integer) ] 1 { _A_ 1 _U_ 1 _N_ _S_ "U(LL)" {_A_ 2 _U_ 22 _N_ _N_ _N_ _N_} _N_ _N_ } #-}
+ {-# GHC_PRAGMA _A_ 1 _U_ 12 _N_ _S_ "U(ASAA)" {_A_ 1 _U_ 12 _N_ _N_ _N_ _N_} _N_ _SPECIALISE_ [ Bool ] 1 { _A_ 1 _U_ 2 _N_ _S_ "E" _N_ _N_ }, [ Char ] 1 { _A_ 1 _U_ 1 _N_ _S_ "U(P)" {_A_ 1 _U_ 2 _N_ _N_ _N_ _N_} _N_ _N_ }, [ Double ] 1 { _A_ 1 _U_ 1 _N_ _S_ "U(P)" {_A_ 1 _U_ 2 _N_ _N_ _N_ _N_} _N_ _N_ }, [ Int ] 1 { _A_ 1 _U_ 1 _N_ _S_ "U(P)" {_A_ 1 _U_ 2 _N_ _N_ _N_ _N_} _N_ _N_ }, [ Integer ] 1 { _A_ 1 _U_ 1 _N_ _S_ "U(PPP)" {_A_ 3 _U_ 222 _N_ _N_ _N_ _N_} _N_ _N_ }, [ [Bool] ] 1 { _A_ 1 _U_ 1 _N_ _S_ "S" _N_ _N_ }, [ [Char] ] 1 { _A_ 1 _U_ 2 _N_ _N_ _N_ _N_ }, [ [Double] ] 1 { _A_ 1 _U_ 2 _N_ _N_ _N_ _N_ }, [ [Int] ] 1 { _A_ 1 _U_ 2 _N_ _N_ _N_ _N_ }, [ [Integer] ] 1 { _A_ 1 _U_ 2 _N_ _N_ _N_ _N_ }, [ [[Char]] ] 1 { _A_ 1 _U_ 1 _N_ _S_ "S" _N_ _N_ }, [ [[Int]] ] 1 { _A_ 1 _U_ 1 _N_ _S_ "S" _N_ _N_ }, [ [Complex Double] ] 1 { _A_ 1 _U_ 2 _N_ _N_ _N_ _N_ }, [ (Ratio Integer) ] 1 { _A_ 1 _U_ 1 _N_ _S_ "U(LL)" {_A_ 2 _U_ 22 _N_ _N_ _N_ _N_} _N_ _N_ }, [ (Array Int Double) ] 1 { _A_ 1 _U_ 2 _N_ _N_ _N_ _N_ }, [ (Array (Int, Int) Double) ] 1 { _A_ 1 _U_ 2 _N_ _N_ _N_ _N_ }, [ _PackedString ] 1 { _A_ 1 _U_ 1 _N_ _N_ _N_ _N_ }, [ (Complex Double) ] 1 { _A_ 1 _U_ 1 _N_ _S_ "U(LL)" {_A_ 2 _U_ 22 _N_ _N_ _N_ _N_} _N_ _N_ }, [ () ] 1 { _A_ 1 _U_ 1 _N_ _S_ "E" _N_ _N_ }, [ (Int, Int) ] 1 { _A_ 1 _U_ 1 _N_ _S_ "U(LL)" {_A_ 2 _U_ 22 _N_ _N_ _N_ _N_} _N_ _N_ }, [ (Integer, Integer) ] 1 { _A_ 1 _U_ 1 _N_ _S_ "U(LL)" {_A_ 2 _U_ 22 _N_ _N_ _N_ _N_} _N_ _N_ }, [ (Int, Int, Int) ] 1 { _A_ 1 _U_ 1 _N_ _S_ "U(LLL)" {_A_ 3 _U_ 222 _N_ _N_ _N_ _N_} _N_ _N_ } #-}
showChar :: Char -> [Char] -> [Char]
{-# GHC_PRAGMA _A_ 2 _U_ 22 _N_ _N_ _F_ _IF_ARGS_ 0 2 XX 3 \ (u0 :: Char) (u1 :: [Char]) -> _!_ (:) [Char] [u0, u1] _N_ #-}
showFloat :: RealFloat a => a -> [Char] -> [Char]
- {-# GHC_PRAGMA _A_ 1 _U_ 122 _N_ _S_ "U(U(LU(SLLL)LAAAA)LLLALAAAA)" {_A_ 5 _U_ 1122222 _N_ _N_ _N_ _N_} _N_ _SPECIALISE_ [ Double ] 1 { _A_ 1 _U_ 12 _N_ _S_ "U(P)" {_A_ 1 _U_ 22 _N_ _N_ _N_ _N_} _N_ _N_ }, [ Float ] 1 { _A_ 0 _U_ 22 _N_ _N_ _N_ _N_ } #-}
+ {-# GHC_PRAGMA _A_ 1 _U_ 122 _N_ _S_ "U(U(AU(SAAA)AAAAL)LLLALAAAA)" {_A_ 5 _U_ 1122222 _N_ _N_ _N_ _N_} _N_ _SPECIALISE_ [ Double ] 1 { _A_ 1 _U_ 12 _N_ _S_ "U(P)" {_A_ 1 _U_ 22 _N_ _N_ _N_ _N_} _N_ _N_ } #-}
showInt :: Integral a => a -> [Char] -> [Char]
{-# GHC_PRAGMA _A_ 1 _U_ 122 _N_ _S_ "U(U(U(U(SL)LLLLLLLLL)LL)LLLLLSLLLLL)" _N_ _SPECIALISE_ [ Int ] 1 { _A_ 2 _U_ 12 _N_ _S_ "U(P)L" {_A_ 2 _U_ 22 _N_ _N_ _N_ _N_} _N_ _N_ }, [ Integer ] 1 { _A_ 2 _U_ 12 _N_ _S_ "U(PPP)L" {_A_ 4 _U_ 2222 _N_ _N_ _N_ _N_} _N_ _N_ } #-}
showLitChar :: Char -> [Char] -> [Char]
showString :: [Char] -> [Char] -> [Char]
{-# GHC_PRAGMA _A_ 2 _U_ 12 _N_ _N_ _F_ _IF_ARGS_ 0 0 X 1 _TYAPP_ _ORIG_ PreludeList (++) { Char } _N_ #-}
shows :: Text a => a -> [Char] -> [Char]
- {-# GHC_PRAGMA _A_ 1 _U_ 122 _N_ _S_ "U(ASAA)" {_A_ 1 _U_ 122 _N_ _N_ _N_ _N_} _N_ _SPECIALISE_ [ Char ] 1 { _A_ 2 _U_ 12 _N_ _S_ "U(P)L" {_A_ 2 _U_ 22 _N_ _N_ _N_ _N_} _N_ _N_ }, [ Double ] 1 { _A_ 1 _U_ 12 _N_ _S_ "U(P)" {_A_ 1 _U_ 22 _N_ _N_ _N_ _N_} _N_ _N_ }, [ Float ] 1 { _A_ 0 _U_ 22 _N_ _N_ _N_ _N_ }, [ Int ] 1 { _A_ 2 _U_ 12 _N_ _S_ "U(P)L" {_A_ 2 _U_ 22 _N_ _N_ _N_ _N_} _N_ _N_ }, [ Integer ] 1 { _A_ 2 _U_ 12 _N_ _S_ "U(PPP)L" {_A_ 4 _U_ 2222 _N_ _N_ _N_ _N_} _N_ _N_ }, [ [Char] ] 1 { _A_ 1 _U_ 22 _N_ _N_ _F_ _IF_ARGS_ 0 0 X 1 _CONSTM_ Text showList (Char) _N_ }, [ _PackedString ] 1 { _A_ 2 _U_ 12 _N_ _N_ _N_ _N_ }, [ (Int, Int) ] 1 { _A_ 2 _U_ 12 _N_ _S_ "U(LL)L" {_A_ 3 _U_ 222 _N_ _N_ _N_ _N_} _N_ _N_ }, [ (Integer, Integer) ] 1 { _A_ 2 _U_ 12 _N_ _S_ "U(LL)L" {_A_ 3 _U_ 222 _N_ _N_ _N_ _N_} _N_ _N_ } #-}
+ {-# GHC_PRAGMA _A_ 1 _U_ 122 _N_ _S_ "U(ASAA)" {_A_ 1 _U_ 122 _N_ _N_ _N_ _N_} _N_ _SPECIALISE_ [ Bool ] 1 { _A_ 2 _U_ 22 _N_ _N_ _N_ _N_ }, [ Char ] 1 { _A_ 2 _U_ 12 _N_ _S_ "U(P)L" {_A_ 2 _U_ 22 _N_ _N_ _N_ _N_} _N_ _N_ }, [ Double ] 1 { _A_ 1 _U_ 12 _N_ _S_ "U(P)" {_A_ 1 _U_ 22 _N_ _N_ _N_ _N_} _N_ _N_ }, [ Int ] 1 { _A_ 2 _U_ 12 _N_ _S_ "U(P)L" {_A_ 2 _U_ 22 _N_ _N_ _N_ _N_} _N_ _N_ }, [ Integer ] 1 { _A_ 2 _U_ 12 _N_ _S_ "U(PPP)L" {_A_ 4 _U_ 2222 _N_ _N_ _N_ _N_} _N_ _N_ }, [ [Bool] ] 1 { _A_ 1 _U_ 12 _N_ _S_ "S" _F_ _IF_ARGS_ 0 1 X 3 \ (u0 :: [Bool]) -> _APP_ _TYAPP_ _ORIG_ PreludeCore _showList { Bool } [ _WRKR_ _CONSTM_ Text showsPrec (Bool), u0 ] _N_ }, [ [Char] ] 1 { _A_ 1 _U_ 22 _N_ _N_ _F_ _IF_ARGS_ 0 0 X 1 _CONSTM_ Text showList (Char) _N_ }, [ [Double] ] 1 { _A_ 1 _U_ 22 _N_ _N_ _F_ _IF_ARGS_ 0 0 X 1 _CONSTM_ Text showList (Double) _N_ }, [ [Int] ] 1 { _A_ 1 _U_ 22 _N_ _N_ _F_ _IF_ARGS_ 0 0 X 1 _CONSTM_ Text showList (Int) _N_ }, [ [Integer] ] 1 { _A_ 1 _U_ 22 _N_ _N_ _F_ _IF_ARGS_ 0 0 X 1 _CONSTM_ Text showList (Integer) _N_ }, [ [[Char]] ] 1 { _A_ 1 _U_ 12 _N_ _S_ "S" _F_ _IF_ARGS_ 0 1 X 3 \ (u0 :: [[Char]]) -> _APP_ _TYAPP_ _ORIG_ PreludeCore _showList { [Char] } [ _CONSTM_ Text showList (Char), u0 ] _N_ }, [ [[Int]] ] 1 { _A_ 1 _U_ 12 _N_ _S_ "S" _F_ _IF_ARGS_ 0 1 X 3 \ (u0 :: [[Int]]) -> _APP_ _TYAPP_ _ORIG_ PreludeCore _showList { [Int] } [ _CONSTM_ Text showList (Int), u0 ] _N_ }, [ [Complex Double] ] 1 { _A_ 1 _U_ 22 _N_ _N_ _F_ _IF_ARGS_ 0 0 X 1 _CONSTM_ Text showList (Complex Double) _N_ }, [ (Ratio Integer) ] 1 { _A_ 1 _U_ 12 _N_ _S_ "U(LL)" {_A_ 2 _U_ 222 _N_ _N_ _N_ _N_} _N_ _N_ }, [ (Array Int Double) ] 1 { _A_ 1 _U_ 22 _N_ _N_ _N_ _N_ }, [ (Array (Int, Int) Double) ] 1 { _A_ 1 _U_ 22 _N_ _N_ _N_ _N_ }, [ _PackedString ] 1 { _A_ 2 _U_ 12 _N_ _N_ _N_ _N_ }, [ (Complex Double) ] 1 { _A_ 1 _U_ 12 _N_ _S_ "U(LL)" {_A_ 2 _U_ 222 _N_ _N_ _N_ _N_} _N_ _N_ }, [ () ] 1 { _A_ 2 _U_ 12 _N_ _S_ "EL" _F_ _IF_ARGS_ 0 2 CX 4 \ (u0 :: ()) (u1 :: [Char]) -> case u0 of { _ALG_ _TUP_0 -> _APP_ _TYAPP_ _ORIG_ PreludeList (++) { Char } [ _NOREP_S_ "()", u1 ]; _NO_DEFLT_ } _N_ }, [ (Int, Int) ] 1 { _A_ 2 _U_ 12 _N_ _S_ "U(LL)L" {_A_ 3 _U_ 222 _N_ _N_ _N_ _N_} _N_ _N_ }, [ (Integer, Integer) ] 1 { _A_ 2 _U_ 12 _N_ _S_ "U(LL)L" {_A_ 3 _U_ 222 _N_ _N_ _N_ _N_} _N_ _N_ }, [ (Int, Int, Int) ] 1 { _A_ 2 _U_ 12 _N_ _S_ "U(LLL)L" {_A_ 4 _U_ 2222 _N_ _N_ _N_ _N_} _N_ _N_ } #-}
appendFile :: [Char] -> [Char] -> _State _RealWorld -> (Either IOError13 (), _State _RealWorld)
{-# GHC_PRAGMA _A_ 3 _U_ 221 _N_ _S_ "LLU(P)" {_A_ 3 _U_ 222 _N_ _N_ _N_ _N_} _N_ _N_ #-}
hPutChar :: _MVar _Handle -> Char -> _State _RealWorld -> (Either IOError13 (), _State _RealWorld)
print :: Text a => a -> _State _RealWorld -> (Either IOError13 (), _State _RealWorld)
{-# GHC_PRAGMA _A_ 1 _U_ 121 _N_ _N_ _N_ _N_ #-}
putChar :: Char -> _State _RealWorld -> (Either IOError13 (), _State _RealWorld)
- {-# GHC_PRAGMA _A_ 2 _U_ 11 _N_ _N_ _F_ _IF_ARGS_ 0 0 X 2 _APP_ _ORIG_ PreludeWriteTextIO hPutChar [ _ORIG_ PreludeStdIO stdout13 ] _N_ #-}
+ {-# GHC_PRAGMA _A_ 2 _U_ 11 _N_ _N_ _F_ _IF_ARGS_ 0 2 XC 6 \ (u0 :: Char) (u1 :: _State _RealWorld) -> case _ORIG_ PreludeStdIO stdout13 of { _ALG_ _MVar (u2 :: SynchVar# _RealWorld _Handle) -> case u1 of { _ALG_ S# (u3 :: State# _RealWorld) -> _APP_ _WRKR_ _ORIG_ PreludeWriteTextIO hPutChar [ u2, u0, u3 ]; _NO_DEFLT_ }; _NO_DEFLT_ } _N_ #-}
putStr :: [Char] -> _State _RealWorld -> (Either IOError13 (), _State _RealWorld)
- {-# GHC_PRAGMA _A_ 2 _U_ 21 _N_ _N_ _F_ _IF_ARGS_ 0 0 X 2 _APP_ _ORIG_ PreludeWriteTextIO hPutStr [ _ORIG_ PreludeStdIO stdout13 ] _N_ #-}
+ {-# GHC_PRAGMA _A_ 2 _U_ 21 _N_ _N_ _F_ _IF_ARGS_ 0 2 XC 6 \ (u0 :: [Char]) (u1 :: _State _RealWorld) -> case _ORIG_ PreludeStdIO stdout13 of { _ALG_ _MVar (u2 :: SynchVar# _RealWorld _Handle) -> case u1 of { _ALG_ S# (u3 :: State# _RealWorld) -> _APP_ _WRKR_ _ORIG_ PreludeWriteTextIO hPutStr [ u2, u0, u3 ]; _NO_DEFLT_ }; _NO_DEFLT_ } _N_ #-}
putText :: Text a => a -> _State _RealWorld -> (Either IOError13 (), _State _RealWorld)
{-# GHC_PRAGMA _A_ 1 _U_ 121 _N_ _N_ _F_ _IF_ARGS_ 1 1 X 3 _/\_ u0 -> \ (u1 :: {{Text u0}}) -> _APP_ _TYAPP_ _ORIG_ PreludeWriteTextIO hPutText { u0 } [ u1, _ORIG_ PreludeStdIO stdout13 ] _N_ #-}
writeFile :: [Char] -> [Char] -> _State _RealWorld -> (Either IOError13 (), _State _RealWorld)
-{-# GHC_PRAGMA INTERFACE VERSION 5 #-}
+{-# GHC_PRAGMA INTERFACE VERSION 6 #-}
interface PreludeCore where
import PreludeArray(Array, Assoc(..), _ByteArray)
import PreludeBuiltin(Bin, Char(..), Double(..), Float(..), Int(..), Integer(..), List(..), Tuple0, Tuple2, Tuple3, Tuple4, Tuple5, _Addr(..), _CMP_TAG(..), _RealWorld(..), _State(..), _Word(..))
class Binary a where
readBin :: Bin -> (a, Bin)
{-# GHC_PRAGMA {-meth-} _A_ 1 _U_ 12 _N_ _S_ "S" _F_ _IF_ARGS_ 1 1 C 2 _/\_ u0 -> \ (u1 :: (Bin -> (u0, Bin), u0 -> Bin -> Bin)) -> case u1 of { _ALG_ _TUP_2 (u2 :: Bin -> (u0, Bin)) (u3 :: u0 -> Bin -> Bin) -> u2; _NO_DEFLT_ } _N_
- {-defm-} _A_ 2 _U_ 02 _N_ _S_ _!_ _F_ _IF_ARGS_ 1 2 XX 3 _/\_ u0 -> \ (u1 :: {{Binary u0}}) (u2 :: Bin) -> _APP_ _TYAPP_ patError# { (Bin -> (u0, Bin)) } [ _NOREP_S_ "%DPreludeCore.Binary.readBin\"", u2 ] _N_ #-}
+ {-defm-} _A_ 2 _U_ 02 _N_ _S_ _!_ _N_ _N_ #-}
showBin :: a -> Bin -> Bin
{-# GHC_PRAGMA {-meth-} _A_ 1 _U_ 122 _N_ _S_ "S" _F_ _IF_ARGS_ 1 1 C 2 _/\_ u0 -> \ (u1 :: (Bin -> (u0, Bin), u0 -> Bin -> Bin)) -> case u1 of { _ALG_ _TUP_2 (u2 :: Bin -> (u0, Bin)) (u3 :: u0 -> Bin -> Bin) -> u3; _NO_DEFLT_ } _N_
- {-defm-} _A_ 3 _U_ 022 _N_ _S_ _!_ _F_ _IF_ARGS_ 1 3 XXX 4 _/\_ u0 -> \ (u1 :: {{Binary u0}}) (u2 :: u0) (u3 :: Bin) -> _APP_ _TYAPP_ patError# { (u0 -> Bin -> Bin) } [ _NOREP_S_ "%DPreludeCore.Binary.showBin\"", u2, u3 ] _N_ #-}
+ {-defm-} _A_ 3 _U_ 022 _N_ _S_ _!_ _N_ _N_ #-}
class (Ord a) => Enum a {-# GHC_PRAGMA {-superdicts-} _A_ 1 _U_ 1 _N_ _S_ "S" _F_ _IF_ARGS_ 1 1 C 2 _/\_ u0 -> \ (u1 :: ({{Ord u0}}, u0 -> [u0], u0 -> u0 -> [u0], u0 -> u0 -> [u0], u0 -> u0 -> u0 -> [u0])) -> case u1 of { _ALG_ _TUP_5 (u2 :: {{Ord u0}}) (u3 :: u0 -> [u0]) (u4 :: u0 -> u0 -> [u0]) (u5 :: u0 -> u0 -> [u0]) (u6 :: u0 -> u0 -> u0 -> [u0]) -> u2; _NO_DEFLT_ } _N_ #-} where
enumFrom :: a -> [a]
{-# GHC_PRAGMA {-meth-} _A_ 1 _U_ 12 _N_ _S_ "S" _F_ _IF_ARGS_ 1 1 C 2 _/\_ u0 -> \ (u1 :: ({{Ord u0}}, u0 -> [u0], u0 -> u0 -> [u0], u0 -> u0 -> [u0], u0 -> u0 -> u0 -> [u0])) -> case u1 of { _ALG_ _TUP_5 (u2 :: {{Ord u0}}) (u3 :: u0 -> [u0]) (u4 :: u0 -> u0 -> [u0]) (u5 :: u0 -> u0 -> [u0]) (u6 :: u0 -> u0 -> u0 -> [u0]) -> u3; _NO_DEFLT_ } _N_
- {-defm-} _A_ 2 _U_ 02 _N_ _S_ _!_ _F_ _IF_ARGS_ 1 2 XX 3 _/\_ u0 -> \ (u1 :: {{Enum u0}}) (u2 :: u0) -> _APP_ _TYAPP_ patError# { (u0 -> [u0]) } [ _NOREP_S_ "%DPreludeCore.Enum.enumFrom\"", u2 ] _N_ #-}
+ {-defm-} _A_ 2 _U_ 02 _N_ _S_ _!_ _N_ _N_ #-}
enumFromThen :: a -> a -> [a]
{-# GHC_PRAGMA {-meth-} _A_ 1 _U_ 122 _N_ _S_ "S" _F_ _IF_ARGS_ 1 1 C 2 _/\_ u0 -> \ (u1 :: ({{Ord u0}}, u0 -> [u0], u0 -> u0 -> [u0], u0 -> u0 -> [u0], u0 -> u0 -> u0 -> [u0])) -> case u1 of { _ALG_ _TUP_5 (u2 :: {{Ord u0}}) (u3 :: u0 -> [u0]) (u4 :: u0 -> u0 -> [u0]) (u5 :: u0 -> u0 -> [u0]) (u6 :: u0 -> u0 -> u0 -> [u0]) -> u4; _NO_DEFLT_ } _N_
- {-defm-} _A_ 3 _U_ 022 _N_ _S_ _!_ _F_ _IF_ARGS_ 1 3 XXX 4 _/\_ u0 -> \ (u1 :: {{Enum u0}}) (u2 :: u0) (u3 :: u0) -> _APP_ _TYAPP_ patError# { (u0 -> u0 -> [u0]) } [ _NOREP_S_ "%DPreludeCore.Enum.enumFromThen\"", u2, u3 ] _N_ #-}
+ {-defm-} _A_ 3 _U_ 022 _N_ _S_ _!_ _N_ _N_ #-}
enumFromTo :: a -> a -> [a]
{-# GHC_PRAGMA {-meth-} _A_ 1 _U_ 122 _N_ _S_ "S" _F_ _IF_ARGS_ 1 1 C 2 _/\_ u0 -> \ (u1 :: ({{Ord u0}}, u0 -> [u0], u0 -> u0 -> [u0], u0 -> u0 -> [u0], u0 -> u0 -> u0 -> [u0])) -> case u1 of { _ALG_ _TUP_5 (u2 :: {{Ord u0}}) (u3 :: u0 -> [u0]) (u4 :: u0 -> u0 -> [u0]) (u5 :: u0 -> u0 -> [u0]) (u6 :: u0 -> u0 -> u0 -> [u0]) -> u5; _NO_DEFLT_ } _N_
{-defm-} _A_ 3 _U_ 122 _N_ _S_ "SLL" _N_ _N_ #-}
class Eq a where
(==) :: a -> a -> Bool
{-# GHC_PRAGMA {-meth-} _A_ 1 _U_ 122 _N_ _S_ "S" _F_ _IF_ARGS_ 1 1 C 2 _/\_ u0 -> \ (u1 :: (u0 -> u0 -> Bool, u0 -> u0 -> Bool)) -> case u1 of { _ALG_ _TUP_2 (u2 :: u0 -> u0 -> Bool) (u3 :: u0 -> u0 -> Bool) -> u2; _NO_DEFLT_ } _N_
- {-defm-} _A_ 3 _U_ 022 _N_ _S_ _!_ _F_ _IF_ARGS_ 1 3 XXX 4 _/\_ u0 -> \ (u1 :: {{Eq u0}}) (u2 :: u0) (u3 :: u0) -> _APP_ _TYAPP_ patError# { (u0 -> u0 -> Bool) } [ _NOREP_S_ "%DPreludeCore.Eq.(==)\"", u2, u3 ] _N_ #-}
+ {-defm-} _A_ 3 _U_ 022 _N_ _S_ _!_ _N_ _N_ #-}
(/=) :: a -> a -> Bool
{-# GHC_PRAGMA {-meth-} _A_ 1 _U_ 122 _N_ _S_ "S" _F_ _IF_ARGS_ 1 1 C 2 _/\_ u0 -> \ (u1 :: (u0 -> u0 -> Bool, u0 -> u0 -> Bool)) -> case u1 of { _ALG_ _TUP_2 (u2 :: u0 -> u0 -> Bool) (u3 :: u0 -> u0 -> Bool) -> u3; _NO_DEFLT_ } _N_
{-defm-} _A_ 3 _U_ 122 _N_ _S_ "SLL" _N_ _N_ #-}
class (Fractional a) => Floating a {-# GHC_PRAGMA {-superdicts-} _A_ 1 _U_ 1 _N_ _S_ "S" _F_ _IF_ARGS_ 1 1 C 2 _/\_ u0 -> \ (u1 :: ({{Fractional u0}}, u0, u0 -> u0, u0 -> u0, u0 -> u0, u0 -> u0 -> u0, u0 -> u0 -> u0, u0 -> u0, u0 -> u0, u0 -> u0, u0 -> u0, u0 -> u0, u0 -> u0, u0 -> u0, u0 -> u0, u0 -> u0, u0 -> u0, u0 -> u0, u0 -> u0)) -> case u1 of { _ALG_ _TUP_19 (u2 :: {{Fractional u0}}) (u3 :: u0) (u4 :: u0 -> u0) (u5 :: u0 -> u0) (u6 :: u0 -> u0) (u7 :: u0 -> u0 -> u0) (u8 :: u0 -> u0 -> u0) (u9 :: u0 -> u0) (ua :: u0 -> u0) (ub :: u0 -> u0) (uc :: u0 -> u0) (ud :: u0 -> u0) (ue :: u0 -> u0) (uf :: u0 -> u0) (ug :: u0 -> u0) (uh :: u0 -> u0) (ui :: u0 -> u0) (uj :: u0 -> u0) (uk :: u0 -> u0) -> u2; _NO_DEFLT_ } _N_ #-} where
pi :: a
{-# GHC_PRAGMA {-meth-} _A_ 1 _U_ 1 _N_ _S_ "S" _F_ _IF_ARGS_ 1 1 C 2 _/\_ u0 -> \ (u1 :: ({{Fractional u0}}, u0, u0 -> u0, u0 -> u0, u0 -> u0, u0 -> u0 -> u0, u0 -> u0 -> u0, u0 -> u0, u0 -> u0, u0 -> u0, u0 -> u0, u0 -> u0, u0 -> u0, u0 -> u0, u0 -> u0, u0 -> u0, u0 -> u0, u0 -> u0, u0 -> u0)) -> case u1 of { _ALG_ _TUP_19 (u2 :: {{Fractional u0}}) (u3 :: u0) (u4 :: u0 -> u0) (u5 :: u0 -> u0) (u6 :: u0 -> u0) (u7 :: u0 -> u0 -> u0) (u8 :: u0 -> u0 -> u0) (u9 :: u0 -> u0) (ua :: u0 -> u0) (ub :: u0 -> u0) (uc :: u0 -> u0) (ud :: u0 -> u0) (ue :: u0 -> u0) (uf :: u0 -> u0) (ug :: u0 -> u0) (uh :: u0 -> u0) (ui :: u0 -> u0) (uj :: u0 -> u0) (uk :: u0 -> u0) -> u3; _NO_DEFLT_ } _N_
- {-defm-} _A_ 1 _U_ 0 _N_ _S_ _!_ _F_ _IF_ARGS_ 1 1 X 2 _/\_ u0 -> \ (u1 :: {{Floating u0}}) -> _APP_ _TYAPP_ patError# { u0 } [ _NOREP_S_ "%DPreludeCore.Floating.pi\"" ] _N_ #-}
+ {-defm-} _A_ 1 _U_ 0 _N_ _S_ _!_ _N_ _N_ #-}
exp :: a -> a
{-# GHC_PRAGMA {-meth-} _A_ 1 _U_ 12 _N_ _S_ "S" _F_ _IF_ARGS_ 1 1 C 2 _/\_ u0 -> \ (u1 :: ({{Fractional u0}}, u0, u0 -> u0, u0 -> u0, u0 -> u0, u0 -> u0 -> u0, u0 -> u0 -> u0, u0 -> u0, u0 -> u0, u0 -> u0, u0 -> u0, u0 -> u0, u0 -> u0, u0 -> u0, u0 -> u0, u0 -> u0, u0 -> u0, u0 -> u0, u0 -> u0)) -> case u1 of { _ALG_ _TUP_19 (u2 :: {{Fractional u0}}) (u3 :: u0) (u4 :: u0 -> u0) (u5 :: u0 -> u0) (u6 :: u0 -> u0) (u7 :: u0 -> u0 -> u0) (u8 :: u0 -> u0 -> u0) (u9 :: u0 -> u0) (ua :: u0 -> u0) (ub :: u0 -> u0) (uc :: u0 -> u0) (ud :: u0 -> u0) (ue :: u0 -> u0) (uf :: u0 -> u0) (ug :: u0 -> u0) (uh :: u0 -> u0) (ui :: u0 -> u0) (uj :: u0 -> u0) (uk :: u0 -> u0) -> u4; _NO_DEFLT_ } _N_
- {-defm-} _A_ 2 _U_ 02 _N_ _S_ _!_ _F_ _IF_ARGS_ 1 2 XX 3 _/\_ u0 -> \ (u1 :: {{Floating u0}}) (u2 :: u0) -> _APP_ _TYAPP_ patError# { (u0 -> u0) } [ _NOREP_S_ "%DPreludeCore.Floating.exp\"", u2 ] _N_ #-}
+ {-defm-} _A_ 2 _U_ 02 _N_ _S_ _!_ _N_ _N_ #-}
log :: a -> a
{-# GHC_PRAGMA {-meth-} _A_ 1 _U_ 12 _N_ _S_ "S" _F_ _IF_ARGS_ 1 1 C 2 _/\_ u0 -> \ (u1 :: ({{Fractional u0}}, u0, u0 -> u0, u0 -> u0, u0 -> u0, u0 -> u0 -> u0, u0 -> u0 -> u0, u0 -> u0, u0 -> u0, u0 -> u0, u0 -> u0, u0 -> u0, u0 -> u0, u0 -> u0, u0 -> u0, u0 -> u0, u0 -> u0, u0 -> u0, u0 -> u0)) -> case u1 of { _ALG_ _TUP_19 (u2 :: {{Fractional u0}}) (u3 :: u0) (u4 :: u0 -> u0) (u5 :: u0 -> u0) (u6 :: u0 -> u0) (u7 :: u0 -> u0 -> u0) (u8 :: u0 -> u0 -> u0) (u9 :: u0 -> u0) (ua :: u0 -> u0) (ub :: u0 -> u0) (uc :: u0 -> u0) (ud :: u0 -> u0) (ue :: u0 -> u0) (uf :: u0 -> u0) (ug :: u0 -> u0) (uh :: u0 -> u0) (ui :: u0 -> u0) (uj :: u0 -> u0) (uk :: u0 -> u0) -> u5; _NO_DEFLT_ } _N_
- {-defm-} _A_ 2 _U_ 02 _N_ _S_ _!_ _F_ _IF_ARGS_ 1 2 XX 3 _/\_ u0 -> \ (u1 :: {{Floating u0}}) (u2 :: u0) -> _APP_ _TYAPP_ patError# { (u0 -> u0) } [ _NOREP_S_ "%DPreludeCore.Floating.log\"", u2 ] _N_ #-}
+ {-defm-} _A_ 2 _U_ 02 _N_ _S_ _!_ _N_ _N_ #-}
sqrt :: a -> a
{-# GHC_PRAGMA {-meth-} _A_ 1 _U_ 12 _N_ _S_ "S" _F_ _IF_ARGS_ 1 1 C 2 _/\_ u0 -> \ (u1 :: ({{Fractional u0}}, u0, u0 -> u0, u0 -> u0, u0 -> u0, u0 -> u0 -> u0, u0 -> u0 -> u0, u0 -> u0, u0 -> u0, u0 -> u0, u0 -> u0, u0 -> u0, u0 -> u0, u0 -> u0, u0 -> u0, u0 -> u0, u0 -> u0, u0 -> u0, u0 -> u0)) -> case u1 of { _ALG_ _TUP_19 (u2 :: {{Fractional u0}}) (u3 :: u0) (u4 :: u0 -> u0) (u5 :: u0 -> u0) (u6 :: u0 -> u0) (u7 :: u0 -> u0 -> u0) (u8 :: u0 -> u0 -> u0) (u9 :: u0 -> u0) (ua :: u0 -> u0) (ub :: u0 -> u0) (uc :: u0 -> u0) (ud :: u0 -> u0) (ue :: u0 -> u0) (uf :: u0 -> u0) (ug :: u0 -> u0) (uh :: u0 -> u0) (ui :: u0 -> u0) (uj :: u0 -> u0) (uk :: u0 -> u0) -> u6; _NO_DEFLT_ } _N_
{-defm-} _A_ 1 _U_ 12 _N_ _S_ "S" _N_ _N_ #-}
{-defm-} _A_ 3 _U_ 122 _N_ _S_ "SLL" _N_ _N_ #-}
sin :: a -> a
{-# GHC_PRAGMA {-meth-} _A_ 1 _U_ 12 _N_ _S_ "S" _F_ _IF_ARGS_ 1 1 C 2 _/\_ u0 -> \ (u1 :: ({{Fractional u0}}, u0, u0 -> u0, u0 -> u0, u0 -> u0, u0 -> u0 -> u0, u0 -> u0 -> u0, u0 -> u0, u0 -> u0, u0 -> u0, u0 -> u0, u0 -> u0, u0 -> u0, u0 -> u0, u0 -> u0, u0 -> u0, u0 -> u0, u0 -> u0, u0 -> u0)) -> case u1 of { _ALG_ _TUP_19 (u2 :: {{Fractional u0}}) (u3 :: u0) (u4 :: u0 -> u0) (u5 :: u0 -> u0) (u6 :: u0 -> u0) (u7 :: u0 -> u0 -> u0) (u8 :: u0 -> u0 -> u0) (u9 :: u0 -> u0) (ua :: u0 -> u0) (ub :: u0 -> u0) (uc :: u0 -> u0) (ud :: u0 -> u0) (ue :: u0 -> u0) (uf :: u0 -> u0) (ug :: u0 -> u0) (uh :: u0 -> u0) (ui :: u0 -> u0) (uj :: u0 -> u0) (uk :: u0 -> u0) -> u9; _NO_DEFLT_ } _N_
- {-defm-} _A_ 2 _U_ 02 _N_ _S_ _!_ _F_ _IF_ARGS_ 1 2 XX 3 _/\_ u0 -> \ (u1 :: {{Floating u0}}) (u2 :: u0) -> _APP_ _TYAPP_ patError# { (u0 -> u0) } [ _NOREP_S_ "%DPreludeCore.Floating.sin\"", u2 ] _N_ #-}
+ {-defm-} _A_ 2 _U_ 02 _N_ _S_ _!_ _N_ _N_ #-}
cos :: a -> a
{-# GHC_PRAGMA {-meth-} _A_ 1 _U_ 12 _N_ _S_ "S" _F_ _IF_ARGS_ 1 1 C 2 _/\_ u0 -> \ (u1 :: ({{Fractional u0}}, u0, u0 -> u0, u0 -> u0, u0 -> u0, u0 -> u0 -> u0, u0 -> u0 -> u0, u0 -> u0, u0 -> u0, u0 -> u0, u0 -> u0, u0 -> u0, u0 -> u0, u0 -> u0, u0 -> u0, u0 -> u0, u0 -> u0, u0 -> u0, u0 -> u0)) -> case u1 of { _ALG_ _TUP_19 (u2 :: {{Fractional u0}}) (u3 :: u0) (u4 :: u0 -> u0) (u5 :: u0 -> u0) (u6 :: u0 -> u0) (u7 :: u0 -> u0 -> u0) (u8 :: u0 -> u0 -> u0) (u9 :: u0 -> u0) (ua :: u0 -> u0) (ub :: u0 -> u0) (uc :: u0 -> u0) (ud :: u0 -> u0) (ue :: u0 -> u0) (uf :: u0 -> u0) (ug :: u0 -> u0) (uh :: u0 -> u0) (ui :: u0 -> u0) (uj :: u0 -> u0) (uk :: u0 -> u0) -> ua; _NO_DEFLT_ } _N_
- {-defm-} _A_ 2 _U_ 02 _N_ _S_ _!_ _F_ _IF_ARGS_ 1 2 XX 3 _/\_ u0 -> \ (u1 :: {{Floating u0}}) (u2 :: u0) -> _APP_ _TYAPP_ patError# { (u0 -> u0) } [ _NOREP_S_ "%DPreludeCore.Floating.cos\"", u2 ] _N_ #-}
+ {-defm-} _A_ 2 _U_ 02 _N_ _S_ _!_ _N_ _N_ #-}
tan :: a -> a
{-# GHC_PRAGMA {-meth-} _A_ 1 _U_ 12 _N_ _S_ "S" _F_ _IF_ARGS_ 1 1 C 2 _/\_ u0 -> \ (u1 :: ({{Fractional u0}}, u0, u0 -> u0, u0 -> u0, u0 -> u0, u0 -> u0 -> u0, u0 -> u0 -> u0, u0 -> u0, u0 -> u0, u0 -> u0, u0 -> u0, u0 -> u0, u0 -> u0, u0 -> u0, u0 -> u0, u0 -> u0, u0 -> u0, u0 -> u0, u0 -> u0)) -> case u1 of { _ALG_ _TUP_19 (u2 :: {{Fractional u0}}) (u3 :: u0) (u4 :: u0 -> u0) (u5 :: u0 -> u0) (u6 :: u0 -> u0) (u7 :: u0 -> u0 -> u0) (u8 :: u0 -> u0 -> u0) (u9 :: u0 -> u0) (ua :: u0 -> u0) (ub :: u0 -> u0) (uc :: u0 -> u0) (ud :: u0 -> u0) (ue :: u0 -> u0) (uf :: u0 -> u0) (ug :: u0 -> u0) (uh :: u0 -> u0) (ui :: u0 -> u0) (uj :: u0 -> u0) (uk :: u0 -> u0) -> ub; _NO_DEFLT_ } _N_
{-defm-} _A_ 2 _U_ 12 _N_ _S_ "SL" _N_ _N_ #-}
asin :: a -> a
{-# GHC_PRAGMA {-meth-} _A_ 1 _U_ 12 _N_ _S_ "S" _F_ _IF_ARGS_ 1 1 C 2 _/\_ u0 -> \ (u1 :: ({{Fractional u0}}, u0, u0 -> u0, u0 -> u0, u0 -> u0, u0 -> u0 -> u0, u0 -> u0 -> u0, u0 -> u0, u0 -> u0, u0 -> u0, u0 -> u0, u0 -> u0, u0 -> u0, u0 -> u0, u0 -> u0, u0 -> u0, u0 -> u0, u0 -> u0, u0 -> u0)) -> case u1 of { _ALG_ _TUP_19 (u2 :: {{Fractional u0}}) (u3 :: u0) (u4 :: u0 -> u0) (u5 :: u0 -> u0) (u6 :: u0 -> u0) (u7 :: u0 -> u0 -> u0) (u8 :: u0 -> u0 -> u0) (u9 :: u0 -> u0) (ua :: u0 -> u0) (ub :: u0 -> u0) (uc :: u0 -> u0) (ud :: u0 -> u0) (ue :: u0 -> u0) (uf :: u0 -> u0) (ug :: u0 -> u0) (uh :: u0 -> u0) (ui :: u0 -> u0) (uj :: u0 -> u0) (uk :: u0 -> u0) -> uc; _NO_DEFLT_ } _N_
- {-defm-} _A_ 2 _U_ 02 _N_ _S_ _!_ _F_ _IF_ARGS_ 1 2 XX 3 _/\_ u0 -> \ (u1 :: {{Floating u0}}) (u2 :: u0) -> _APP_ _TYAPP_ patError# { (u0 -> u0) } [ _NOREP_S_ "%DPreludeCore.Floating.asin\"", u2 ] _N_ #-}
+ {-defm-} _A_ 2 _U_ 02 _N_ _S_ _!_ _N_ _N_ #-}
acos :: a -> a
{-# GHC_PRAGMA {-meth-} _A_ 1 _U_ 12 _N_ _S_ "S" _F_ _IF_ARGS_ 1 1 C 2 _/\_ u0 -> \ (u1 :: ({{Fractional u0}}, u0, u0 -> u0, u0 -> u0, u0 -> u0, u0 -> u0 -> u0, u0 -> u0 -> u0, u0 -> u0, u0 -> u0, u0 -> u0, u0 -> u0, u0 -> u0, u0 -> u0, u0 -> u0, u0 -> u0, u0 -> u0, u0 -> u0, u0 -> u0, u0 -> u0)) -> case u1 of { _ALG_ _TUP_19 (u2 :: {{Fractional u0}}) (u3 :: u0) (u4 :: u0 -> u0) (u5 :: u0 -> u0) (u6 :: u0 -> u0) (u7 :: u0 -> u0 -> u0) (u8 :: u0 -> u0 -> u0) (u9 :: u0 -> u0) (ua :: u0 -> u0) (ub :: u0 -> u0) (uc :: u0 -> u0) (ud :: u0 -> u0) (ue :: u0 -> u0) (uf :: u0 -> u0) (ug :: u0 -> u0) (uh :: u0 -> u0) (ui :: u0 -> u0) (uj :: u0 -> u0) (uk :: u0 -> u0) -> ud; _NO_DEFLT_ } _N_
- {-defm-} _A_ 2 _U_ 02 _N_ _S_ _!_ _F_ _IF_ARGS_ 1 2 XX 3 _/\_ u0 -> \ (u1 :: {{Floating u0}}) (u2 :: u0) -> _APP_ _TYAPP_ patError# { (u0 -> u0) } [ _NOREP_S_ "%DPreludeCore.Floating.acos\"", u2 ] _N_ #-}
+ {-defm-} _A_ 2 _U_ 02 _N_ _S_ _!_ _N_ _N_ #-}
atan :: a -> a
{-# GHC_PRAGMA {-meth-} _A_ 1 _U_ 12 _N_ _S_ "S" _F_ _IF_ARGS_ 1 1 C 2 _/\_ u0 -> \ (u1 :: ({{Fractional u0}}, u0, u0 -> u0, u0 -> u0, u0 -> u0, u0 -> u0 -> u0, u0 -> u0 -> u0, u0 -> u0, u0 -> u0, u0 -> u0, u0 -> u0, u0 -> u0, u0 -> u0, u0 -> u0, u0 -> u0, u0 -> u0, u0 -> u0, u0 -> u0, u0 -> u0)) -> case u1 of { _ALG_ _TUP_19 (u2 :: {{Fractional u0}}) (u3 :: u0) (u4 :: u0 -> u0) (u5 :: u0 -> u0) (u6 :: u0 -> u0) (u7 :: u0 -> u0 -> u0) (u8 :: u0 -> u0 -> u0) (u9 :: u0 -> u0) (ua :: u0 -> u0) (ub :: u0 -> u0) (uc :: u0 -> u0) (ud :: u0 -> u0) (ue :: u0 -> u0) (uf :: u0 -> u0) (ug :: u0 -> u0) (uh :: u0 -> u0) (ui :: u0 -> u0) (uj :: u0 -> u0) (uk :: u0 -> u0) -> ue; _NO_DEFLT_ } _N_
- {-defm-} _A_ 2 _U_ 02 _N_ _S_ _!_ _F_ _IF_ARGS_ 1 2 XX 3 _/\_ u0 -> \ (u1 :: {{Floating u0}}) (u2 :: u0) -> _APP_ _TYAPP_ patError# { (u0 -> u0) } [ _NOREP_S_ "%DPreludeCore.Floating.atan\"", u2 ] _N_ #-}
+ {-defm-} _A_ 2 _U_ 02 _N_ _S_ _!_ _N_ _N_ #-}
sinh :: a -> a
{-# GHC_PRAGMA {-meth-} _A_ 1 _U_ 12 _N_ _S_ "S" _F_ _IF_ARGS_ 1 1 C 2 _/\_ u0 -> \ (u1 :: ({{Fractional u0}}, u0, u0 -> u0, u0 -> u0, u0 -> u0, u0 -> u0 -> u0, u0 -> u0 -> u0, u0 -> u0, u0 -> u0, u0 -> u0, u0 -> u0, u0 -> u0, u0 -> u0, u0 -> u0, u0 -> u0, u0 -> u0, u0 -> u0, u0 -> u0, u0 -> u0)) -> case u1 of { _ALG_ _TUP_19 (u2 :: {{Fractional u0}}) (u3 :: u0) (u4 :: u0 -> u0) (u5 :: u0 -> u0) (u6 :: u0 -> u0) (u7 :: u0 -> u0 -> u0) (u8 :: u0 -> u0 -> u0) (u9 :: u0 -> u0) (ua :: u0 -> u0) (ub :: u0 -> u0) (uc :: u0 -> u0) (ud :: u0 -> u0) (ue :: u0 -> u0) (uf :: u0 -> u0) (ug :: u0 -> u0) (uh :: u0 -> u0) (ui :: u0 -> u0) (uj :: u0 -> u0) (uk :: u0 -> u0) -> uf; _NO_DEFLT_ } _N_
- {-defm-} _A_ 2 _U_ 02 _N_ _S_ _!_ _F_ _IF_ARGS_ 1 2 XX 3 _/\_ u0 -> \ (u1 :: {{Floating u0}}) (u2 :: u0) -> _APP_ _TYAPP_ patError# { (u0 -> u0) } [ _NOREP_S_ "%DPreludeCore.Floating.sinh\"", u2 ] _N_ #-}
+ {-defm-} _A_ 2 _U_ 02 _N_ _S_ _!_ _N_ _N_ #-}
cosh :: a -> a
{-# GHC_PRAGMA {-meth-} _A_ 1 _U_ 12 _N_ _S_ "S" _F_ _IF_ARGS_ 1 1 C 2 _/\_ u0 -> \ (u1 :: ({{Fractional u0}}, u0, u0 -> u0, u0 -> u0, u0 -> u0, u0 -> u0 -> u0, u0 -> u0 -> u0, u0 -> u0, u0 -> u0, u0 -> u0, u0 -> u0, u0 -> u0, u0 -> u0, u0 -> u0, u0 -> u0, u0 -> u0, u0 -> u0, u0 -> u0, u0 -> u0)) -> case u1 of { _ALG_ _TUP_19 (u2 :: {{Fractional u0}}) (u3 :: u0) (u4 :: u0 -> u0) (u5 :: u0 -> u0) (u6 :: u0 -> u0) (u7 :: u0 -> u0 -> u0) (u8 :: u0 -> u0 -> u0) (u9 :: u0 -> u0) (ua :: u0 -> u0) (ub :: u0 -> u0) (uc :: u0 -> u0) (ud :: u0 -> u0) (ue :: u0 -> u0) (uf :: u0 -> u0) (ug :: u0 -> u0) (uh :: u0 -> u0) (ui :: u0 -> u0) (uj :: u0 -> u0) (uk :: u0 -> u0) -> ug; _NO_DEFLT_ } _N_
- {-defm-} _A_ 2 _U_ 02 _N_ _S_ _!_ _F_ _IF_ARGS_ 1 2 XX 3 _/\_ u0 -> \ (u1 :: {{Floating u0}}) (u2 :: u0) -> _APP_ _TYAPP_ patError# { (u0 -> u0) } [ _NOREP_S_ "%DPreludeCore.Floating.cosh\"", u2 ] _N_ #-}
+ {-defm-} _A_ 2 _U_ 02 _N_ _S_ _!_ _N_ _N_ #-}
tanh :: a -> a
{-# GHC_PRAGMA {-meth-} _A_ 1 _U_ 12 _N_ _S_ "S" _F_ _IF_ARGS_ 1 1 C 2 _/\_ u0 -> \ (u1 :: ({{Fractional u0}}, u0, u0 -> u0, u0 -> u0, u0 -> u0, u0 -> u0 -> u0, u0 -> u0 -> u0, u0 -> u0, u0 -> u0, u0 -> u0, u0 -> u0, u0 -> u0, u0 -> u0, u0 -> u0, u0 -> u0, u0 -> u0, u0 -> u0, u0 -> u0, u0 -> u0)) -> case u1 of { _ALG_ _TUP_19 (u2 :: {{Fractional u0}}) (u3 :: u0) (u4 :: u0 -> u0) (u5 :: u0 -> u0) (u6 :: u0 -> u0) (u7 :: u0 -> u0 -> u0) (u8 :: u0 -> u0 -> u0) (u9 :: u0 -> u0) (ua :: u0 -> u0) (ub :: u0 -> u0) (uc :: u0 -> u0) (ud :: u0 -> u0) (ue :: u0 -> u0) (uf :: u0 -> u0) (ug :: u0 -> u0) (uh :: u0 -> u0) (ui :: u0 -> u0) (uj :: u0 -> u0) (uk :: u0 -> u0) -> uh; _NO_DEFLT_ } _N_
{-defm-} _A_ 2 _U_ 12 _N_ _S_ "SL" _N_ _N_ #-}
asinh :: a -> a
{-# GHC_PRAGMA {-meth-} _A_ 1 _U_ 12 _N_ _S_ "S" _F_ _IF_ARGS_ 1 1 C 2 _/\_ u0 -> \ (u1 :: ({{Fractional u0}}, u0, u0 -> u0, u0 -> u0, u0 -> u0, u0 -> u0 -> u0, u0 -> u0 -> u0, u0 -> u0, u0 -> u0, u0 -> u0, u0 -> u0, u0 -> u0, u0 -> u0, u0 -> u0, u0 -> u0, u0 -> u0, u0 -> u0, u0 -> u0, u0 -> u0)) -> case u1 of { _ALG_ _TUP_19 (u2 :: {{Fractional u0}}) (u3 :: u0) (u4 :: u0 -> u0) (u5 :: u0 -> u0) (u6 :: u0 -> u0) (u7 :: u0 -> u0 -> u0) (u8 :: u0 -> u0 -> u0) (u9 :: u0 -> u0) (ua :: u0 -> u0) (ub :: u0 -> u0) (uc :: u0 -> u0) (ud :: u0 -> u0) (ue :: u0 -> u0) (uf :: u0 -> u0) (ug :: u0 -> u0) (uh :: u0 -> u0) (ui :: u0 -> u0) (uj :: u0 -> u0) (uk :: u0 -> u0) -> ui; _NO_DEFLT_ } _N_
- {-defm-} _A_ 2 _U_ 02 _N_ _S_ _!_ _F_ _IF_ARGS_ 1 2 XX 3 _/\_ u0 -> \ (u1 :: {{Floating u0}}) (u2 :: u0) -> _APP_ _TYAPP_ patError# { (u0 -> u0) } [ _NOREP_S_ "%DPreludeCore.Floating.asinh\"", u2 ] _N_ #-}
+ {-defm-} _A_ 2 _U_ 02 _N_ _S_ _!_ _N_ _N_ #-}
acosh :: a -> a
{-# GHC_PRAGMA {-meth-} _A_ 1 _U_ 12 _N_ _S_ "S" _F_ _IF_ARGS_ 1 1 C 2 _/\_ u0 -> \ (u1 :: ({{Fractional u0}}, u0, u0 -> u0, u0 -> u0, u0 -> u0, u0 -> u0 -> u0, u0 -> u0 -> u0, u0 -> u0, u0 -> u0, u0 -> u0, u0 -> u0, u0 -> u0, u0 -> u0, u0 -> u0, u0 -> u0, u0 -> u0, u0 -> u0, u0 -> u0, u0 -> u0)) -> case u1 of { _ALG_ _TUP_19 (u2 :: {{Fractional u0}}) (u3 :: u0) (u4 :: u0 -> u0) (u5 :: u0 -> u0) (u6 :: u0 -> u0) (u7 :: u0 -> u0 -> u0) (u8 :: u0 -> u0 -> u0) (u9 :: u0 -> u0) (ua :: u0 -> u0) (ub :: u0 -> u0) (uc :: u0 -> u0) (ud :: u0 -> u0) (ue :: u0 -> u0) (uf :: u0 -> u0) (ug :: u0 -> u0) (uh :: u0 -> u0) (ui :: u0 -> u0) (uj :: u0 -> u0) (uk :: u0 -> u0) -> uj; _NO_DEFLT_ } _N_
- {-defm-} _A_ 2 _U_ 02 _N_ _S_ _!_ _F_ _IF_ARGS_ 1 2 XX 3 _/\_ u0 -> \ (u1 :: {{Floating u0}}) (u2 :: u0) -> _APP_ _TYAPP_ patError# { (u0 -> u0) } [ _NOREP_S_ "%DPreludeCore.Floating.acosh\"", u2 ] _N_ #-}
+ {-defm-} _A_ 2 _U_ 02 _N_ _S_ _!_ _N_ _N_ #-}
atanh :: a -> a
{-# GHC_PRAGMA {-meth-} _A_ 1 _U_ 12 _N_ _S_ "S" _F_ _IF_ARGS_ 1 1 C 2 _/\_ u0 -> \ (u1 :: ({{Fractional u0}}, u0, u0 -> u0, u0 -> u0, u0 -> u0, u0 -> u0 -> u0, u0 -> u0 -> u0, u0 -> u0, u0 -> u0, u0 -> u0, u0 -> u0, u0 -> u0, u0 -> u0, u0 -> u0, u0 -> u0, u0 -> u0, u0 -> u0, u0 -> u0, u0 -> u0)) -> case u1 of { _ALG_ _TUP_19 (u2 :: {{Fractional u0}}) (u3 :: u0) (u4 :: u0 -> u0) (u5 :: u0 -> u0) (u6 :: u0 -> u0) (u7 :: u0 -> u0 -> u0) (u8 :: u0 -> u0 -> u0) (u9 :: u0 -> u0) (ua :: u0 -> u0) (ub :: u0 -> u0) (uc :: u0 -> u0) (ud :: u0 -> u0) (ue :: u0 -> u0) (uf :: u0 -> u0) (ug :: u0 -> u0) (uh :: u0 -> u0) (ui :: u0 -> u0) (uj :: u0 -> u0) (uk :: u0 -> u0) -> uk; _NO_DEFLT_ } _N_
- {-defm-} _A_ 2 _U_ 02 _N_ _S_ _!_ _F_ _IF_ARGS_ 1 2 XX 3 _/\_ u0 -> \ (u1 :: {{Floating u0}}) (u2 :: u0) -> _APP_ _TYAPP_ patError# { (u0 -> u0) } [ _NOREP_S_ "%DPreludeCore.Floating.atanh\"", u2 ] _N_ #-}
+ {-defm-} _A_ 2 _U_ 02 _N_ _S_ _!_ _N_ _N_ #-}
class (Num a) => Fractional a {-# GHC_PRAGMA {-superdicts-} _A_ 1 _U_ 1 _N_ _S_ "S" _F_ _IF_ARGS_ 1 1 C 2 _/\_ u0 -> \ (u1 :: ({{Num u0}}, u0 -> u0 -> u0, u0 -> u0, Ratio Integer -> u0)) -> case u1 of { _ALG_ _TUP_4 (u2 :: {{Num u0}}) (u3 :: u0 -> u0 -> u0) (u4 :: u0 -> u0) (u5 :: Ratio Integer -> u0) -> u2; _NO_DEFLT_ } _N_ #-} where
(/) :: a -> a -> a
{-# GHC_PRAGMA {-meth-} _A_ 1 _U_ 122 _N_ _S_ "S" _F_ _IF_ARGS_ 1 1 C 2 _/\_ u0 -> \ (u1 :: ({{Num u0}}, u0 -> u0 -> u0, u0 -> u0, Ratio Integer -> u0)) -> case u1 of { _ALG_ _TUP_4 (u2 :: {{Num u0}}) (u3 :: u0 -> u0 -> u0) (u4 :: u0 -> u0) (u5 :: Ratio Integer -> u0) -> u3; _NO_DEFLT_ } _N_
- {-defm-} _A_ 3 _U_ 022 _N_ _S_ _!_ _F_ _IF_ARGS_ 1 3 XXX 4 _/\_ u0 -> \ (u1 :: {{Fractional u0}}) (u2 :: u0) (u3 :: u0) -> _APP_ _TYAPP_ patError# { (u0 -> u0 -> u0) } [ _NOREP_S_ "%DPreludeCore.Fractional.(/)\"", u2, u3 ] _N_ #-}
+ {-defm-} _A_ 3 _U_ 022 _N_ _S_ _!_ _N_ _N_ #-}
recip :: a -> a
{-# GHC_PRAGMA {-meth-} _A_ 1 _U_ 12 _N_ _S_ "S" _F_ _IF_ARGS_ 1 1 C 2 _/\_ u0 -> \ (u1 :: ({{Num u0}}, u0 -> u0 -> u0, u0 -> u0, Ratio Integer -> u0)) -> case u1 of { _ALG_ _TUP_4 (u2 :: {{Num u0}}) (u3 :: u0 -> u0 -> u0) (u4 :: u0 -> u0) (u5 :: Ratio Integer -> u0) -> u4; _NO_DEFLT_ } _N_
{-defm-} _A_ 1 _U_ 12 _N_ _S_ "S" _N_ _N_ #-}
fromRational :: Ratio Integer -> a
{-# GHC_PRAGMA {-meth-} _A_ 1 _U_ 12 _N_ _S_ "S" _F_ _IF_ARGS_ 1 1 C 2 _/\_ u0 -> \ (u1 :: ({{Num u0}}, u0 -> u0 -> u0, u0 -> u0, Ratio Integer -> u0)) -> case u1 of { _ALG_ _TUP_4 (u2 :: {{Num u0}}) (u3 :: u0 -> u0 -> u0) (u4 :: u0 -> u0) (u5 :: Ratio Integer -> u0) -> u5; _NO_DEFLT_ } _N_
- {-defm-} _A_ 2 _U_ 02 _N_ _S_ _!_ _F_ _IF_ARGS_ 1 2 XX 3 _/\_ u0 -> \ (u1 :: {{Fractional u0}}) (u2 :: Ratio Integer) -> _APP_ _TYAPP_ patError# { (Ratio Integer -> u0) } [ _NOREP_S_ "%DPreludeCore.Fractional.fromRational\"", u2 ] _N_ #-}
+ {-defm-} _A_ 2 _U_ 02 _N_ _S_ _!_ _N_ _N_ #-}
class (Real a, Ix a) => Integral a {-# GHC_PRAGMA {-superdicts-} _A_ 1 _U_ 1 _N_ _S_ "S" _F_ _IF_ARGS_ 1 1 C 2 _/\_ u0 -> \ (u1 :: ({{Real u0}}, {{Ix u0}}, u0 -> u0 -> u0, u0 -> u0 -> u0, u0 -> u0 -> u0, u0 -> u0 -> u0, u0 -> u0 -> (u0, u0), u0 -> u0 -> (u0, u0), u0 -> Bool, u0 -> Bool, u0 -> Integer, u0 -> Int)) -> case u1 of { _ALG_ _TUP_12 (u2 :: {{Real u0}}) (u3 :: {{Ix u0}}) (u4 :: u0 -> u0 -> u0) (u5 :: u0 -> u0 -> u0) (u6 :: u0 -> u0 -> u0) (u7 :: u0 -> u0 -> u0) (u8 :: u0 -> u0 -> (u0, u0)) (u9 :: u0 -> u0 -> (u0, u0)) (ua :: u0 -> Bool) (ub :: u0 -> Bool) (uc :: u0 -> Integer) (ud :: u0 -> Int) -> u2; _NO_DEFLT_ } _N_, _A_ 1 _U_ 1 _N_ _S_ "S" _F_ _IF_ARGS_ 1 1 C 2 _/\_ u0 -> \ (u1 :: ({{Real u0}}, {{Ix u0}}, u0 -> u0 -> u0, u0 -> u0 -> u0, u0 -> u0 -> u0, u0 -> u0 -> u0, u0 -> u0 -> (u0, u0), u0 -> u0 -> (u0, u0), u0 -> Bool, u0 -> Bool, u0 -> Integer, u0 -> Int)) -> case u1 of { _ALG_ _TUP_12 (u2 :: {{Real u0}}) (u3 :: {{Ix u0}}) (u4 :: u0 -> u0 -> u0) (u5 :: u0 -> u0 -> u0) (u6 :: u0 -> u0 -> u0) (u7 :: u0 -> u0 -> u0) (u8 :: u0 -> u0 -> (u0, u0)) (u9 :: u0 -> u0 -> (u0, u0)) (ua :: u0 -> Bool) (ub :: u0 -> Bool) (uc :: u0 -> Integer) (ud :: u0 -> Int) -> u3; _NO_DEFLT_ } _N_ #-} where
quot :: a -> a -> a
{-# GHC_PRAGMA {-meth-} _A_ 1 _U_ 122 _N_ _S_ "S" _F_ _IF_ARGS_ 1 1 C 2 _/\_ u0 -> \ (u1 :: ({{Real u0}}, {{Ix u0}}, u0 -> u0 -> u0, u0 -> u0 -> u0, u0 -> u0 -> u0, u0 -> u0 -> u0, u0 -> u0 -> (u0, u0), u0 -> u0 -> (u0, u0), u0 -> Bool, u0 -> Bool, u0 -> Integer, u0 -> Int)) -> case u1 of { _ALG_ _TUP_12 (u2 :: {{Real u0}}) (u3 :: {{Ix u0}}) (u4 :: u0 -> u0 -> u0) (u5 :: u0 -> u0 -> u0) (u6 :: u0 -> u0 -> u0) (u7 :: u0 -> u0 -> u0) (u8 :: u0 -> u0 -> (u0, u0)) (u9 :: u0 -> u0 -> (u0, u0)) (ua :: u0 -> Bool) (ub :: u0 -> Bool) (uc :: u0 -> Integer) (ud :: u0 -> Int) -> u4; _NO_DEFLT_ } _N_
{-defm-} _A_ 3 _U_ 122 _N_ _S_ "SLL" _F_ _IF_ARGS_ 1 3 CXX 6 _/\_ u0 -> \ (u1 :: {{Integral u0}}) (u2 :: u0) (u3 :: u0) -> case case u1 of { _ALG_ _TUP_12 (u4 :: {{Real u0}}) (u5 :: {{Ix u0}}) (u6 :: u0 -> u0 -> u0) (u7 :: u0 -> u0 -> u0) (u8 :: u0 -> u0 -> u0) (u9 :: u0 -> u0 -> u0) (ua :: u0 -> u0 -> (u0, u0)) (ub :: u0 -> u0 -> (u0, u0)) (uc :: u0 -> Bool) (ud :: u0 -> Bool) (ue :: u0 -> Integer) (uf :: u0 -> Int) -> _APP_ ub [ u2, u3 ]; _NO_DEFLT_ } of { _ALG_ _TUP_2 (ug :: u0) (uh :: u0) -> uh; _NO_DEFLT_ } _N_ #-}
quotRem :: a -> a -> (a, a)
{-# GHC_PRAGMA {-meth-} _A_ 1 _U_ 122 _N_ _S_ "S" _F_ _IF_ARGS_ 1 1 C 2 _/\_ u0 -> \ (u1 :: ({{Real u0}}, {{Ix u0}}, u0 -> u0 -> u0, u0 -> u0 -> u0, u0 -> u0 -> u0, u0 -> u0 -> u0, u0 -> u0 -> (u0, u0), u0 -> u0 -> (u0, u0), u0 -> Bool, u0 -> Bool, u0 -> Integer, u0 -> Int)) -> case u1 of { _ALG_ _TUP_12 (u2 :: {{Real u0}}) (u3 :: {{Ix u0}}) (u4 :: u0 -> u0 -> u0) (u5 :: u0 -> u0 -> u0) (u6 :: u0 -> u0 -> u0) (u7 :: u0 -> u0 -> u0) (u8 :: u0 -> u0 -> (u0, u0)) (u9 :: u0 -> u0 -> (u0, u0)) (ua :: u0 -> Bool) (ub :: u0 -> Bool) (uc :: u0 -> Integer) (ud :: u0 -> Int) -> u8; _NO_DEFLT_ } _N_
- {-defm-} _A_ 3 _U_ 022 _N_ _S_ _!_ _F_ _IF_ARGS_ 1 3 XXX 4 _/\_ u0 -> \ (u1 :: {{Integral u0}}) (u2 :: u0) (u3 :: u0) -> _APP_ _TYAPP_ patError# { (u0 -> u0 -> (u0, u0)) } [ _NOREP_S_ "%DPreludeCore.Integral.quotRem\"", u2, u3 ] _N_ #-}
+ {-defm-} _A_ 3 _U_ 022 _N_ _S_ _!_ _N_ _N_ #-}
divMod :: a -> a -> (a, a)
{-# GHC_PRAGMA {-meth-} _A_ 1 _U_ 122 _N_ _S_ "S" _F_ _IF_ARGS_ 1 1 C 2 _/\_ u0 -> \ (u1 :: ({{Real u0}}, {{Ix u0}}, u0 -> u0 -> u0, u0 -> u0 -> u0, u0 -> u0 -> u0, u0 -> u0 -> u0, u0 -> u0 -> (u0, u0), u0 -> u0 -> (u0, u0), u0 -> Bool, u0 -> Bool, u0 -> Integer, u0 -> Int)) -> case u1 of { _ALG_ _TUP_12 (u2 :: {{Real u0}}) (u3 :: {{Ix u0}}) (u4 :: u0 -> u0 -> u0) (u5 :: u0 -> u0 -> u0) (u6 :: u0 -> u0 -> u0) (u7 :: u0 -> u0 -> u0) (u8 :: u0 -> u0 -> (u0, u0)) (u9 :: u0 -> u0 -> (u0, u0)) (ua :: u0 -> Bool) (ub :: u0 -> Bool) (uc :: u0 -> Integer) (ud :: u0 -> Int) -> u9; _NO_DEFLT_ } _N_
{-defm-} _A_ 1 _U_ 122 _N_ _S_ "S" _N_ _N_ #-}
{-defm-} _A_ 1 _U_ 12 _N_ _S_ "S" _N_ _N_ #-}
toInteger :: a -> Integer
{-# GHC_PRAGMA {-meth-} _A_ 1 _U_ 12 _N_ _S_ "S" _F_ _IF_ARGS_ 1 1 C 2 _/\_ u0 -> \ (u1 :: ({{Real u0}}, {{Ix u0}}, u0 -> u0 -> u0, u0 -> u0 -> u0, u0 -> u0 -> u0, u0 -> u0 -> u0, u0 -> u0 -> (u0, u0), u0 -> u0 -> (u0, u0), u0 -> Bool, u0 -> Bool, u0 -> Integer, u0 -> Int)) -> case u1 of { _ALG_ _TUP_12 (u2 :: {{Real u0}}) (u3 :: {{Ix u0}}) (u4 :: u0 -> u0 -> u0) (u5 :: u0 -> u0 -> u0) (u6 :: u0 -> u0 -> u0) (u7 :: u0 -> u0 -> u0) (u8 :: u0 -> u0 -> (u0, u0)) (u9 :: u0 -> u0 -> (u0, u0)) (ua :: u0 -> Bool) (ub :: u0 -> Bool) (uc :: u0 -> Integer) (ud :: u0 -> Int) -> uc; _NO_DEFLT_ } _N_
- {-defm-} _A_ 2 _U_ 02 _N_ _S_ _!_ _F_ _IF_ARGS_ 1 2 XX 3 _/\_ u0 -> \ (u1 :: {{Integral u0}}) (u2 :: u0) -> _APP_ _TYAPP_ patError# { (u0 -> Integer) } [ _NOREP_S_ "%DPreludeCore.Integral.toInteger\"", u2 ] _N_ #-}
+ {-defm-} _A_ 2 _U_ 02 _N_ _S_ _!_ _N_ _N_ #-}
toInt :: a -> Int
{-# GHC_PRAGMA {-meth-} _A_ 1 _U_ 12 _N_ _S_ "S" _F_ _IF_ARGS_ 1 1 C 2 _/\_ u0 -> \ (u1 :: ({{Real u0}}, {{Ix u0}}, u0 -> u0 -> u0, u0 -> u0 -> u0, u0 -> u0 -> u0, u0 -> u0 -> u0, u0 -> u0 -> (u0, u0), u0 -> u0 -> (u0, u0), u0 -> Bool, u0 -> Bool, u0 -> Integer, u0 -> Int)) -> case u1 of { _ALG_ _TUP_12 (u2 :: {{Real u0}}) (u3 :: {{Ix u0}}) (u4 :: u0 -> u0 -> u0) (u5 :: u0 -> u0 -> u0) (u6 :: u0 -> u0 -> u0) (u7 :: u0 -> u0 -> u0) (u8 :: u0 -> u0 -> (u0, u0)) (u9 :: u0 -> u0 -> (u0, u0)) (ua :: u0 -> Bool) (ub :: u0 -> Bool) (uc :: u0 -> Integer) (ud :: u0 -> Int) -> ud; _NO_DEFLT_ } _N_
- {-defm-} _A_ 2 _U_ 02 _N_ _S_ _!_ _F_ _IF_ARGS_ 1 2 XX 3 _/\_ u0 -> \ (u1 :: {{Integral u0}}) (u2 :: u0) -> _APP_ _TYAPP_ patError# { (u0 -> Int) } [ _NOREP_S_ "%DPreludeCore.Integral.toInt\"", u2 ] _N_ #-}
+ {-defm-} _A_ 2 _U_ 02 _N_ _S_ _!_ _N_ _N_ #-}
class (Ord a) => Ix a {-# GHC_PRAGMA {-superdicts-} _A_ 1 _U_ 1 _N_ _S_ "S" _F_ _IF_ARGS_ 1 1 C 2 _/\_ u0 -> \ (u1 :: ({{Ord u0}}, (u0, u0) -> [u0], (u0, u0) -> u0 -> Int, (u0, u0) -> u0 -> Bool)) -> case u1 of { _ALG_ _TUP_4 (u2 :: {{Ord u0}}) (u3 :: (u0, u0) -> [u0]) (u4 :: (u0, u0) -> u0 -> Int) (u5 :: (u0, u0) -> u0 -> Bool) -> u2; _NO_DEFLT_ } _N_ #-} where
range :: (a, a) -> [a]
{-# GHC_PRAGMA {-meth-} _A_ 1 _U_ 12 _N_ _S_ "S" _F_ _IF_ARGS_ 1 1 C 2 _/\_ u0 -> \ (u1 :: ({{Ord u0}}, (u0, u0) -> [u0], (u0, u0) -> u0 -> Int, (u0, u0) -> u0 -> Bool)) -> case u1 of { _ALG_ _TUP_4 (u2 :: {{Ord u0}}) (u3 :: (u0, u0) -> [u0]) (u4 :: (u0, u0) -> u0 -> Int) (u5 :: (u0, u0) -> u0 -> Bool) -> u3; _NO_DEFLT_ } _N_
- {-defm-} _A_ 2 _U_ 02 _N_ _S_ _!_ _F_ _IF_ARGS_ 1 2 XX 3 _/\_ u0 -> \ (u1 :: {{Ix u0}}) (u2 :: (u0, u0)) -> _APP_ _TYAPP_ patError# { ((u0, u0) -> [u0]) } [ _NOREP_S_ "%DPreludeCore.Ix.range\"", u2 ] _N_ #-}
+ {-defm-} _A_ 2 _U_ 02 _N_ _S_ _!_ _N_ _N_ #-}
index :: (a, a) -> a -> Int
{-# GHC_PRAGMA {-meth-} _A_ 1 _U_ 122 _N_ _S_ "S" _F_ _IF_ARGS_ 1 1 C 2 _/\_ u0 -> \ (u1 :: ({{Ord u0}}, (u0, u0) -> [u0], (u0, u0) -> u0 -> Int, (u0, u0) -> u0 -> Bool)) -> case u1 of { _ALG_ _TUP_4 (u2 :: {{Ord u0}}) (u3 :: (u0, u0) -> [u0]) (u4 :: (u0, u0) -> u0 -> Int) (u5 :: (u0, u0) -> u0 -> Bool) -> u4; _NO_DEFLT_ } _N_
- {-defm-} _A_ 3 _U_ 022 _N_ _S_ _!_ _F_ _IF_ARGS_ 1 3 XXX 4 _/\_ u0 -> \ (u1 :: {{Ix u0}}) (u2 :: (u0, u0)) (u3 :: u0) -> _APP_ _TYAPP_ patError# { ((u0, u0) -> u0 -> Int) } [ _NOREP_S_ "%DPreludeCore.Ix.index\"", u2, u3 ] _N_ #-}
+ {-defm-} _A_ 3 _U_ 022 _N_ _S_ _!_ _N_ _N_ #-}
inRange :: (a, a) -> a -> Bool
{-# GHC_PRAGMA {-meth-} _A_ 1 _U_ 122 _N_ _S_ "S" _F_ _IF_ARGS_ 1 1 C 2 _/\_ u0 -> \ (u1 :: ({{Ord u0}}, (u0, u0) -> [u0], (u0, u0) -> u0 -> Int, (u0, u0) -> u0 -> Bool)) -> case u1 of { _ALG_ _TUP_4 (u2 :: {{Ord u0}}) (u3 :: (u0, u0) -> [u0]) (u4 :: (u0, u0) -> u0 -> Int) (u5 :: (u0, u0) -> u0 -> Bool) -> u5; _NO_DEFLT_ } _N_
- {-defm-} _A_ 3 _U_ 022 _N_ _S_ _!_ _F_ _IF_ARGS_ 1 3 XXX 4 _/\_ u0 -> \ (u1 :: {{Ix u0}}) (u2 :: (u0, u0)) (u3 :: u0) -> _APP_ _TYAPP_ patError# { ((u0, u0) -> u0 -> Bool) } [ _NOREP_S_ "%DPreludeCore.Ix.inRange\"", u2, u3 ] _N_ #-}
+ {-defm-} _A_ 3 _U_ 022 _N_ _S_ _!_ _N_ _N_ #-}
class (Eq a, Text a) => Num a {-# GHC_PRAGMA {-superdicts-} _A_ 1 _U_ 1 _N_ _S_ "S" _F_ _IF_ARGS_ 1 1 C 2 _/\_ u0 -> \ (u1 :: ({{Eq u0}}, {{Text u0}}, u0 -> u0 -> u0, u0 -> u0 -> u0, u0 -> u0 -> u0, u0 -> u0, u0 -> u0, u0 -> u0, Integer -> u0, Int -> u0)) -> case u1 of { _ALG_ _TUP_10 (u2 :: {{Eq u0}}) (u3 :: {{Text u0}}) (u4 :: u0 -> u0 -> u0) (u5 :: u0 -> u0 -> u0) (u6 :: u0 -> u0 -> u0) (u7 :: u0 -> u0) (u8 :: u0 -> u0) (u9 :: u0 -> u0) (ua :: Integer -> u0) (ub :: Int -> u0) -> u2; _NO_DEFLT_ } _N_, _A_ 1 _U_ 1 _N_ _S_ "S" _F_ _IF_ARGS_ 1 1 C 2 _/\_ u0 -> \ (u1 :: ({{Eq u0}}, {{Text u0}}, u0 -> u0 -> u0, u0 -> u0 -> u0, u0 -> u0 -> u0, u0 -> u0, u0 -> u0, u0 -> u0, Integer -> u0, Int -> u0)) -> case u1 of { _ALG_ _TUP_10 (u2 :: {{Eq u0}}) (u3 :: {{Text u0}}) (u4 :: u0 -> u0 -> u0) (u5 :: u0 -> u0 -> u0) (u6 :: u0 -> u0 -> u0) (u7 :: u0 -> u0) (u8 :: u0 -> u0) (u9 :: u0 -> u0) (ua :: Integer -> u0) (ub :: Int -> u0) -> u3; _NO_DEFLT_ } _N_ #-} where
(+) :: a -> a -> a
{-# GHC_PRAGMA {-meth-} _A_ 1 _U_ 122 _N_ _S_ "S" _F_ _IF_ARGS_ 1 1 C 2 _/\_ u0 -> \ (u1 :: ({{Eq u0}}, {{Text u0}}, u0 -> u0 -> u0, u0 -> u0 -> u0, u0 -> u0 -> u0, u0 -> u0, u0 -> u0, u0 -> u0, Integer -> u0, Int -> u0)) -> case u1 of { _ALG_ _TUP_10 (u2 :: {{Eq u0}}) (u3 :: {{Text u0}}) (u4 :: u0 -> u0 -> u0) (u5 :: u0 -> u0 -> u0) (u6 :: u0 -> u0 -> u0) (u7 :: u0 -> u0) (u8 :: u0 -> u0) (u9 :: u0 -> u0) (ua :: Integer -> u0) (ub :: Int -> u0) -> u4; _NO_DEFLT_ } _N_
- {-defm-} _A_ 3 _U_ 022 _N_ _S_ _!_ _F_ _IF_ARGS_ 1 3 XXX 4 _/\_ u0 -> \ (u1 :: {{Num u0}}) (u2 :: u0) (u3 :: u0) -> _APP_ _TYAPP_ patError# { (u0 -> u0 -> u0) } [ _NOREP_S_ "%DPreludeCore.Num.(+)\"", u2, u3 ] _N_ #-}
+ {-defm-} _A_ 3 _U_ 022 _N_ _S_ _!_ _N_ _N_ #-}
(-) :: a -> a -> a
{-# GHC_PRAGMA {-meth-} _A_ 1 _U_ 122 _N_ _S_ "S" _F_ _IF_ARGS_ 1 1 C 2 _/\_ u0 -> \ (u1 :: ({{Eq u0}}, {{Text u0}}, u0 -> u0 -> u0, u0 -> u0 -> u0, u0 -> u0 -> u0, u0 -> u0, u0 -> u0, u0 -> u0, Integer -> u0, Int -> u0)) -> case u1 of { _ALG_ _TUP_10 (u2 :: {{Eq u0}}) (u3 :: {{Text u0}}) (u4 :: u0 -> u0 -> u0) (u5 :: u0 -> u0 -> u0) (u6 :: u0 -> u0 -> u0) (u7 :: u0 -> u0) (u8 :: u0 -> u0) (u9 :: u0 -> u0) (ua :: Integer -> u0) (ub :: Int -> u0) -> u5; _NO_DEFLT_ } _N_
{-defm-} _A_ 3 _U_ 122 _N_ _S_ "SLL" _F_ _ALWAYS_ _/\_ u0 -> \ (u1 :: {{Num u0}}) (u2 :: u0) (u3 :: u0) -> case u1 of { _ALG_ _TUP_10 (u4 :: {{Eq u0}}) (u5 :: {{Text u0}}) (u6 :: u0 -> u0 -> u0) (u7 :: u0 -> u0 -> u0) (u8 :: u0 -> u0 -> u0) (u9 :: u0 -> u0) (ua :: u0 -> u0) (ub :: u0 -> u0) (uc :: Integer -> u0) (ud :: Int -> u0) -> let {(ue :: u0) = _APP_ u9 [ u3 ]} in _APP_ u6 [ u2, ue ]; _NO_DEFLT_ } _N_ #-}
(*) :: a -> a -> a
{-# GHC_PRAGMA {-meth-} _A_ 1 _U_ 122 _N_ _S_ "S" _F_ _IF_ARGS_ 1 1 C 2 _/\_ u0 -> \ (u1 :: ({{Eq u0}}, {{Text u0}}, u0 -> u0 -> u0, u0 -> u0 -> u0, u0 -> u0 -> u0, u0 -> u0, u0 -> u0, u0 -> u0, Integer -> u0, Int -> u0)) -> case u1 of { _ALG_ _TUP_10 (u2 :: {{Eq u0}}) (u3 :: {{Text u0}}) (u4 :: u0 -> u0 -> u0) (u5 :: u0 -> u0 -> u0) (u6 :: u0 -> u0 -> u0) (u7 :: u0 -> u0) (u8 :: u0 -> u0) (u9 :: u0 -> u0) (ua :: Integer -> u0) (ub :: Int -> u0) -> u6; _NO_DEFLT_ } _N_
- {-defm-} _A_ 3 _U_ 022 _N_ _S_ _!_ _F_ _IF_ARGS_ 1 3 XXX 4 _/\_ u0 -> \ (u1 :: {{Num u0}}) (u2 :: u0) (u3 :: u0) -> _APP_ _TYAPP_ patError# { (u0 -> u0 -> u0) } [ _NOREP_S_ "%DPreludeCore.Num.(*)\"", u2, u3 ] _N_ #-}
+ {-defm-} _A_ 3 _U_ 022 _N_ _S_ _!_ _N_ _N_ #-}
negate :: a -> a
{-# GHC_PRAGMA {-meth-} _A_ 1 _U_ 12 _N_ _S_ "S" _F_ _IF_ARGS_ 1 1 C 2 _/\_ u0 -> \ (u1 :: ({{Eq u0}}, {{Text u0}}, u0 -> u0 -> u0, u0 -> u0 -> u0, u0 -> u0 -> u0, u0 -> u0, u0 -> u0, u0 -> u0, Integer -> u0, Int -> u0)) -> case u1 of { _ALG_ _TUP_10 (u2 :: {{Eq u0}}) (u3 :: {{Text u0}}) (u4 :: u0 -> u0 -> u0) (u5 :: u0 -> u0 -> u0) (u6 :: u0 -> u0 -> u0) (u7 :: u0 -> u0) (u8 :: u0 -> u0) (u9 :: u0 -> u0) (ua :: Integer -> u0) (ub :: Int -> u0) -> u7; _NO_DEFLT_ } _N_
- {-defm-} _A_ 2 _U_ 02 _N_ _S_ _!_ _F_ _IF_ARGS_ 1 2 XX 3 _/\_ u0 -> \ (u1 :: {{Num u0}}) (u2 :: u0) -> _APP_ _TYAPP_ patError# { (u0 -> u0) } [ _NOREP_S_ "%DPreludeCore.Num.negate\"", u2 ] _N_ #-}
+ {-defm-} _A_ 2 _U_ 02 _N_ _S_ _!_ _N_ _N_ #-}
abs :: a -> a
{-# GHC_PRAGMA {-meth-} _A_ 1 _U_ 12 _N_ _S_ "S" _F_ _IF_ARGS_ 1 1 C 2 _/\_ u0 -> \ (u1 :: ({{Eq u0}}, {{Text u0}}, u0 -> u0 -> u0, u0 -> u0 -> u0, u0 -> u0 -> u0, u0 -> u0, u0 -> u0, u0 -> u0, Integer -> u0, Int -> u0)) -> case u1 of { _ALG_ _TUP_10 (u2 :: {{Eq u0}}) (u3 :: {{Text u0}}) (u4 :: u0 -> u0 -> u0) (u5 :: u0 -> u0 -> u0) (u6 :: u0 -> u0 -> u0) (u7 :: u0 -> u0) (u8 :: u0 -> u0) (u9 :: u0 -> u0) (ua :: Integer -> u0) (ub :: Int -> u0) -> u8; _NO_DEFLT_ } _N_
- {-defm-} _A_ 2 _U_ 02 _N_ _S_ _!_ _F_ _IF_ARGS_ 1 2 XX 3 _/\_ u0 -> \ (u1 :: {{Num u0}}) (u2 :: u0) -> _APP_ _TYAPP_ patError# { (u0 -> u0) } [ _NOREP_S_ "%DPreludeCore.Num.abs\"", u2 ] _N_ #-}
+ {-defm-} _A_ 2 _U_ 02 _N_ _S_ _!_ _N_ _N_ #-}
signum :: a -> a
{-# GHC_PRAGMA {-meth-} _A_ 1 _U_ 12 _N_ _S_ "S" _F_ _IF_ARGS_ 1 1 C 2 _/\_ u0 -> \ (u1 :: ({{Eq u0}}, {{Text u0}}, u0 -> u0 -> u0, u0 -> u0 -> u0, u0 -> u0 -> u0, u0 -> u0, u0 -> u0, u0 -> u0, Integer -> u0, Int -> u0)) -> case u1 of { _ALG_ _TUP_10 (u2 :: {{Eq u0}}) (u3 :: {{Text u0}}) (u4 :: u0 -> u0 -> u0) (u5 :: u0 -> u0 -> u0) (u6 :: u0 -> u0 -> u0) (u7 :: u0 -> u0) (u8 :: u0 -> u0) (u9 :: u0 -> u0) (ua :: Integer -> u0) (ub :: Int -> u0) -> u9; _NO_DEFLT_ } _N_
- {-defm-} _A_ 2 _U_ 02 _N_ _S_ _!_ _F_ _IF_ARGS_ 1 2 XX 3 _/\_ u0 -> \ (u1 :: {{Num u0}}) (u2 :: u0) -> _APP_ _TYAPP_ patError# { (u0 -> u0) } [ _NOREP_S_ "%DPreludeCore.Num.signum\"", u2 ] _N_ #-}
+ {-defm-} _A_ 2 _U_ 02 _N_ _S_ _!_ _N_ _N_ #-}
fromInteger :: Integer -> a
{-# GHC_PRAGMA {-meth-} _A_ 1 _U_ 12 _N_ _S_ "S" _F_ _IF_ARGS_ 1 1 C 2 _/\_ u0 -> \ (u1 :: ({{Eq u0}}, {{Text u0}}, u0 -> u0 -> u0, u0 -> u0 -> u0, u0 -> u0 -> u0, u0 -> u0, u0 -> u0, u0 -> u0, Integer -> u0, Int -> u0)) -> case u1 of { _ALG_ _TUP_10 (u2 :: {{Eq u0}}) (u3 :: {{Text u0}}) (u4 :: u0 -> u0 -> u0) (u5 :: u0 -> u0 -> u0) (u6 :: u0 -> u0 -> u0) (u7 :: u0 -> u0) (u8 :: u0 -> u0) (u9 :: u0 -> u0) (ua :: Integer -> u0) (ub :: Int -> u0) -> ua; _NO_DEFLT_ } _N_
- {-defm-} _A_ 2 _U_ 02 _N_ _S_ _!_ _F_ _IF_ARGS_ 1 2 XX 3 _/\_ u0 -> \ (u1 :: {{Num u0}}) (u2 :: Integer) -> _APP_ _TYAPP_ patError# { (Integer -> u0) } [ _NOREP_S_ "%DPreludeCore.Num.fromInteger\"", u2 ] _N_ #-}
+ {-defm-} _A_ 2 _U_ 02 _N_ _S_ _!_ _N_ _N_ #-}
fromInt :: Int -> a
{-# GHC_PRAGMA {-meth-} _A_ 1 _U_ 12 _N_ _S_ "S" _F_ _IF_ARGS_ 1 1 C 2 _/\_ u0 -> \ (u1 :: ({{Eq u0}}, {{Text u0}}, u0 -> u0 -> u0, u0 -> u0 -> u0, u0 -> u0 -> u0, u0 -> u0, u0 -> u0, u0 -> u0, Integer -> u0, Int -> u0)) -> case u1 of { _ALG_ _TUP_10 (u2 :: {{Eq u0}}) (u3 :: {{Text u0}}) (u4 :: u0 -> u0 -> u0) (u5 :: u0 -> u0 -> u0) (u6 :: u0 -> u0 -> u0) (u7 :: u0 -> u0) (u8 :: u0 -> u0) (u9 :: u0 -> u0) (ua :: Integer -> u0) (ub :: Int -> u0) -> ub; _NO_DEFLT_ } _N_
{-defm-} _A_ 2 _U_ 11 _N_ _S_ "SL" _F_ _IF_ARGS_ 1 2 CC 6 _/\_ u0 -> \ (u1 :: {{Num u0}}) (u2 :: Int) -> let {(u4 :: Integer) = case u2 of { _ALG_ I# (u3 :: Int#) -> _#_ int2Integer# [] [u3]; _NO_DEFLT_ }} in case u1 of { _ALG_ _TUP_10 (u5 :: {{Eq u0}}) (u6 :: {{Text u0}}) (u7 :: u0 -> u0 -> u0) (u8 :: u0 -> u0 -> u0) (u9 :: u0 -> u0 -> u0) (ua :: u0 -> u0) (ub :: u0 -> u0) (uc :: u0 -> u0) (ud :: Integer -> u0) (ue :: Int -> u0) -> _APP_ ud [ u4 ]; _NO_DEFLT_ } _N_ #-}
{-defm-} _A_ 3 _U_ 122 _N_ _S_ "SLL" _N_ _N_ #-}
(<=) :: a -> a -> Bool
{-# GHC_PRAGMA {-meth-} _A_ 1 _U_ 122 _N_ _S_ "S" _F_ _IF_ARGS_ 1 1 C 2 _/\_ u0 -> \ (u1 :: ({{Eq u0}}, u0 -> u0 -> Bool, u0 -> u0 -> Bool, u0 -> u0 -> Bool, u0 -> u0 -> Bool, u0 -> u0 -> u0, u0 -> u0 -> u0, u0 -> u0 -> _CMP_TAG)) -> case u1 of { _ALG_ _TUP_8 (u2 :: {{Eq u0}}) (u3 :: u0 -> u0 -> Bool) (u4 :: u0 -> u0 -> Bool) (u5 :: u0 -> u0 -> Bool) (u6 :: u0 -> u0 -> Bool) (u7 :: u0 -> u0 -> u0) (u8 :: u0 -> u0 -> u0) (u9 :: u0 -> u0 -> _CMP_TAG) -> u4; _NO_DEFLT_ } _N_
- {-defm-} _A_ 3 _U_ 022 _N_ _S_ _!_ _F_ _IF_ARGS_ 1 3 XXX 4 _/\_ u0 -> \ (u1 :: {{Ord u0}}) (u2 :: u0) (u3 :: u0) -> _APP_ _TYAPP_ patError# { (u0 -> u0 -> Bool) } [ _NOREP_S_ "%DPreludeCore.Ord.(<=)\"", u2, u3 ] _N_ #-}
+ {-defm-} _A_ 3 _U_ 022 _N_ _S_ _!_ _N_ _N_ #-}
(>=) :: a -> a -> Bool
{-# GHC_PRAGMA {-meth-} _A_ 1 _U_ 122 _N_ _S_ "S" _F_ _IF_ARGS_ 1 1 C 2 _/\_ u0 -> \ (u1 :: ({{Eq u0}}, u0 -> u0 -> Bool, u0 -> u0 -> Bool, u0 -> u0 -> Bool, u0 -> u0 -> Bool, u0 -> u0 -> u0, u0 -> u0 -> u0, u0 -> u0 -> _CMP_TAG)) -> case u1 of { _ALG_ _TUP_8 (u2 :: {{Eq u0}}) (u3 :: u0 -> u0 -> Bool) (u4 :: u0 -> u0 -> Bool) (u5 :: u0 -> u0 -> Bool) (u6 :: u0 -> u0 -> Bool) (u7 :: u0 -> u0 -> u0) (u8 :: u0 -> u0 -> u0) (u9 :: u0 -> u0 -> _CMP_TAG) -> u5; _NO_DEFLT_ } _N_
{-defm-} _A_ 3 _U_ 122 _N_ _S_ "SLL" _F_ _IF_ARGS_ 1 3 CXX 4 _/\_ u0 -> \ (u1 :: {{Ord u0}}) (u2 :: u0) (u3 :: u0) -> case u1 of { _ALG_ _TUP_8 (u4 :: {{Eq u0}}) (u5 :: u0 -> u0 -> Bool) (u6 :: u0 -> u0 -> Bool) (u7 :: u0 -> u0 -> Bool) (u8 :: u0 -> u0 -> Bool) (u9 :: u0 -> u0 -> u0) (ua :: u0 -> u0 -> u0) (ub :: u0 -> u0 -> _CMP_TAG) -> _APP_ u6 [ u3, u2 ]; _NO_DEFLT_ } _N_ #-}
class (Num a, Enum a) => Real a {-# GHC_PRAGMA {-superdicts-} _A_ 1 _U_ 1 _N_ _S_ "S" _F_ _IF_ARGS_ 1 1 C 2 _/\_ u0 -> \ (u1 :: ({{Num u0}}, {{Enum u0}}, u0 -> Ratio Integer)) -> case u1 of { _ALG_ _TUP_3 (u2 :: {{Num u0}}) (u3 :: {{Enum u0}}) (u4 :: u0 -> Ratio Integer) -> u2; _NO_DEFLT_ } _N_, _A_ 1 _U_ 1 _N_ _S_ "S" _F_ _IF_ARGS_ 1 1 C 2 _/\_ u0 -> \ (u1 :: ({{Num u0}}, {{Enum u0}}, u0 -> Ratio Integer)) -> case u1 of { _ALG_ _TUP_3 (u2 :: {{Num u0}}) (u3 :: {{Enum u0}}) (u4 :: u0 -> Ratio Integer) -> u3; _NO_DEFLT_ } _N_ #-} where
toRational :: a -> Ratio Integer
{-# GHC_PRAGMA {-meth-} _A_ 1 _U_ 12 _N_ _S_ "S" _F_ _IF_ARGS_ 1 1 C 2 _/\_ u0 -> \ (u1 :: ({{Num u0}}, {{Enum u0}}, u0 -> Ratio Integer)) -> case u1 of { _ALG_ _TUP_3 (u2 :: {{Num u0}}) (u3 :: {{Enum u0}}) (u4 :: u0 -> Ratio Integer) -> u4; _NO_DEFLT_ } _N_
- {-defm-} _A_ 2 _U_ 02 _N_ _S_ _!_ _F_ _IF_ARGS_ 1 2 XX 3 _/\_ u0 -> \ (u1 :: {{Real u0}}) (u2 :: u0) -> _APP_ _TYAPP_ patError# { (u0 -> Ratio Integer) } [ _NOREP_S_ "%DPreludeCore.Real.toRational\"", u2 ] _N_ #-}
+ {-defm-} _A_ 2 _U_ 02 _N_ _S_ _!_ _N_ _N_ #-}
class (RealFrac a, Floating a) => RealFloat a {-# GHC_PRAGMA {-superdicts-} _A_ 1 _U_ 1 _N_ _S_ "S" _F_ _IF_ARGS_ 1 1 C 2 _/\_ u0 -> \ (u1 :: ({{RealFrac u0}}, {{Floating u0}}, u0 -> Integer, u0 -> Int, u0 -> (Int, Int), u0 -> (Integer, Int), Integer -> Int -> u0, u0 -> Int, u0 -> u0, Int -> u0 -> u0)) -> case u1 of { _ALG_ _TUP_10 (u2 :: {{RealFrac u0}}) (u3 :: {{Floating u0}}) (u4 :: u0 -> Integer) (u5 :: u0 -> Int) (u6 :: u0 -> (Int, Int)) (u7 :: u0 -> (Integer, Int)) (u8 :: Integer -> Int -> u0) (u9 :: u0 -> Int) (ua :: u0 -> u0) (ub :: Int -> u0 -> u0) -> u2; _NO_DEFLT_ } _N_, _A_ 1 _U_ 1 _N_ _S_ "S" _F_ _IF_ARGS_ 1 1 C 2 _/\_ u0 -> \ (u1 :: ({{RealFrac u0}}, {{Floating u0}}, u0 -> Integer, u0 -> Int, u0 -> (Int, Int), u0 -> (Integer, Int), Integer -> Int -> u0, u0 -> Int, u0 -> u0, Int -> u0 -> u0)) -> case u1 of { _ALG_ _TUP_10 (u2 :: {{RealFrac u0}}) (u3 :: {{Floating u0}}) (u4 :: u0 -> Integer) (u5 :: u0 -> Int) (u6 :: u0 -> (Int, Int)) (u7 :: u0 -> (Integer, Int)) (u8 :: Integer -> Int -> u0) (u9 :: u0 -> Int) (ua :: u0 -> u0) (ub :: Int -> u0 -> u0) -> u3; _NO_DEFLT_ } _N_ #-} where
floatRadix :: a -> Integer
{-# GHC_PRAGMA {-meth-} _A_ 1 _U_ 12 _N_ _S_ "S" _F_ _IF_ARGS_ 1 1 C 2 _/\_ u0 -> \ (u1 :: ({{RealFrac u0}}, {{Floating u0}}, u0 -> Integer, u0 -> Int, u0 -> (Int, Int), u0 -> (Integer, Int), Integer -> Int -> u0, u0 -> Int, u0 -> u0, Int -> u0 -> u0)) -> case u1 of { _ALG_ _TUP_10 (u2 :: {{RealFrac u0}}) (u3 :: {{Floating u0}}) (u4 :: u0 -> Integer) (u5 :: u0 -> Int) (u6 :: u0 -> (Int, Int)) (u7 :: u0 -> (Integer, Int)) (u8 :: Integer -> Int -> u0) (u9 :: u0 -> Int) (ua :: u0 -> u0) (ub :: Int -> u0 -> u0) -> u4; _NO_DEFLT_ } _N_
- {-defm-} _A_ 2 _U_ 02 _N_ _S_ _!_ _F_ _IF_ARGS_ 1 2 XX 3 _/\_ u0 -> \ (u1 :: {{RealFloat u0}}) (u2 :: u0) -> _APP_ _TYAPP_ patError# { (u0 -> Integer) } [ _NOREP_S_ "%DPreludeCore.RealFloat.floatRadix\"", u2 ] _N_ #-}
+ {-defm-} _A_ 2 _U_ 02 _N_ _S_ _!_ _N_ _N_ #-}
floatDigits :: a -> Int
{-# GHC_PRAGMA {-meth-} _A_ 1 _U_ 12 _N_ _S_ "S" _F_ _IF_ARGS_ 1 1 C 2 _/\_ u0 -> \ (u1 :: ({{RealFrac u0}}, {{Floating u0}}, u0 -> Integer, u0 -> Int, u0 -> (Int, Int), u0 -> (Integer, Int), Integer -> Int -> u0, u0 -> Int, u0 -> u0, Int -> u0 -> u0)) -> case u1 of { _ALG_ _TUP_10 (u2 :: {{RealFrac u0}}) (u3 :: {{Floating u0}}) (u4 :: u0 -> Integer) (u5 :: u0 -> Int) (u6 :: u0 -> (Int, Int)) (u7 :: u0 -> (Integer, Int)) (u8 :: Integer -> Int -> u0) (u9 :: u0 -> Int) (ua :: u0 -> u0) (ub :: Int -> u0 -> u0) -> u5; _NO_DEFLT_ } _N_
- {-defm-} _A_ 2 _U_ 02 _N_ _S_ _!_ _F_ _IF_ARGS_ 1 2 XX 3 _/\_ u0 -> \ (u1 :: {{RealFloat u0}}) (u2 :: u0) -> _APP_ _TYAPP_ patError# { (u0 -> Int) } [ _NOREP_S_ "%DPreludeCore.RealFloat.floatDigits\"", u2 ] _N_ #-}
+ {-defm-} _A_ 2 _U_ 02 _N_ _S_ _!_ _N_ _N_ #-}
floatRange :: a -> (Int, Int)
{-# GHC_PRAGMA {-meth-} _A_ 1 _U_ 12 _N_ _S_ "S" _F_ _IF_ARGS_ 1 1 C 2 _/\_ u0 -> \ (u1 :: ({{RealFrac u0}}, {{Floating u0}}, u0 -> Integer, u0 -> Int, u0 -> (Int, Int), u0 -> (Integer, Int), Integer -> Int -> u0, u0 -> Int, u0 -> u0, Int -> u0 -> u0)) -> case u1 of { _ALG_ _TUP_10 (u2 :: {{RealFrac u0}}) (u3 :: {{Floating u0}}) (u4 :: u0 -> Integer) (u5 :: u0 -> Int) (u6 :: u0 -> (Int, Int)) (u7 :: u0 -> (Integer, Int)) (u8 :: Integer -> Int -> u0) (u9 :: u0 -> Int) (ua :: u0 -> u0) (ub :: Int -> u0 -> u0) -> u6; _NO_DEFLT_ } _N_
- {-defm-} _A_ 2 _U_ 02 _N_ _S_ _!_ _F_ _IF_ARGS_ 1 2 XX 3 _/\_ u0 -> \ (u1 :: {{RealFloat u0}}) (u2 :: u0) -> _APP_ _TYAPP_ patError# { (u0 -> (Int, Int)) } [ _NOREP_S_ "%DPreludeCore.RealFloat.floatRange\"", u2 ] _N_ #-}
+ {-defm-} _A_ 2 _U_ 02 _N_ _S_ _!_ _N_ _N_ #-}
decodeFloat :: a -> (Integer, Int)
{-# GHC_PRAGMA {-meth-} _A_ 1 _U_ 12 _N_ _S_ "S" _F_ _IF_ARGS_ 1 1 C 2 _/\_ u0 -> \ (u1 :: ({{RealFrac u0}}, {{Floating u0}}, u0 -> Integer, u0 -> Int, u0 -> (Int, Int), u0 -> (Integer, Int), Integer -> Int -> u0, u0 -> Int, u0 -> u0, Int -> u0 -> u0)) -> case u1 of { _ALG_ _TUP_10 (u2 :: {{RealFrac u0}}) (u3 :: {{Floating u0}}) (u4 :: u0 -> Integer) (u5 :: u0 -> Int) (u6 :: u0 -> (Int, Int)) (u7 :: u0 -> (Integer, Int)) (u8 :: Integer -> Int -> u0) (u9 :: u0 -> Int) (ua :: u0 -> u0) (ub :: Int -> u0 -> u0) -> u7; _NO_DEFLT_ } _N_
- {-defm-} _A_ 2 _U_ 02 _N_ _S_ _!_ _F_ _IF_ARGS_ 1 2 XX 3 _/\_ u0 -> \ (u1 :: {{RealFloat u0}}) (u2 :: u0) -> _APP_ _TYAPP_ patError# { (u0 -> (Integer, Int)) } [ _NOREP_S_ "%DPreludeCore.RealFloat.decodeFloat\"", u2 ] _N_ #-}
+ {-defm-} _A_ 2 _U_ 02 _N_ _S_ _!_ _N_ _N_ #-}
encodeFloat :: Integer -> Int -> a
{-# GHC_PRAGMA {-meth-} _A_ 1 _U_ 122 _N_ _S_ "S" _F_ _IF_ARGS_ 1 1 C 2 _/\_ u0 -> \ (u1 :: ({{RealFrac u0}}, {{Floating u0}}, u0 -> Integer, u0 -> Int, u0 -> (Int, Int), u0 -> (Integer, Int), Integer -> Int -> u0, u0 -> Int, u0 -> u0, Int -> u0 -> u0)) -> case u1 of { _ALG_ _TUP_10 (u2 :: {{RealFrac u0}}) (u3 :: {{Floating u0}}) (u4 :: u0 -> Integer) (u5 :: u0 -> Int) (u6 :: u0 -> (Int, Int)) (u7 :: u0 -> (Integer, Int)) (u8 :: Integer -> Int -> u0) (u9 :: u0 -> Int) (ua :: u0 -> u0) (ub :: Int -> u0 -> u0) -> u8; _NO_DEFLT_ } _N_
- {-defm-} _A_ 3 _U_ 022 _N_ _S_ _!_ _F_ _IF_ARGS_ 1 3 XXX 4 _/\_ u0 -> \ (u1 :: {{RealFloat u0}}) (u2 :: Integer) (u3 :: Int) -> _APP_ _TYAPP_ patError# { (Integer -> Int -> u0) } [ _NOREP_S_ "%DPreludeCore.RealFloat.encodeFloat\"", u2, u3 ] _N_ #-}
+ {-defm-} _A_ 3 _U_ 022 _N_ _S_ _!_ _N_ _N_ #-}
exponent :: a -> Int
{-# GHC_PRAGMA {-meth-} _A_ 1 _U_ 12 _N_ _S_ "S" _F_ _IF_ARGS_ 1 1 C 2 _/\_ u0 -> \ (u1 :: ({{RealFrac u0}}, {{Floating u0}}, u0 -> Integer, u0 -> Int, u0 -> (Int, Int), u0 -> (Integer, Int), Integer -> Int -> u0, u0 -> Int, u0 -> u0, Int -> u0 -> u0)) -> case u1 of { _ALG_ _TUP_10 (u2 :: {{RealFrac u0}}) (u3 :: {{Floating u0}}) (u4 :: u0 -> Integer) (u5 :: u0 -> Int) (u6 :: u0 -> (Int, Int)) (u7 :: u0 -> (Integer, Int)) (u8 :: Integer -> Int -> u0) (u9 :: u0 -> Int) (ua :: u0 -> u0) (ub :: Int -> u0 -> u0) -> u9; _NO_DEFLT_ } _N_
{-defm-} _A_ 2 _U_ 12 _N_ _S_ "SL" _N_ _N_ #-}
class (Real a, Fractional a) => RealFrac a {-# GHC_PRAGMA {-superdicts-} _A_ 1 _U_ 1 _N_ _S_ "S" _F_ _IF_ARGS_ 1 1 C 2 _/\_ u0 -> \ (u1 :: ({{Real u0}}, {{Fractional u0}}, (_forall_ z$z1 =>{{Integral z$z1}} -> u0 -> (z$z1, u0)), (_forall_ z$z1 =>{{Integral z$z1}} -> u0 -> z$z1), (_forall_ z$z1 =>{{Integral z$z1}} -> u0 -> z$z1), (_forall_ z$z1 =>{{Integral z$z1}} -> u0 -> z$z1), (_forall_ z$z1 =>{{Integral z$z1}} -> u0 -> z$z1))) -> case u1 of { _ALG_ _TUP_7 (u2 :: {{Real u0}}) (u3 :: {{Fractional u0}}) (u4 :: _forall_ a$z1 =>{{Integral a$z1}} -> u0 -> (a$z1, u0)) (u5 :: _forall_ a$z1 =>{{Integral a$z1}} -> u0 -> a$z1) (u6 :: _forall_ a$z1 =>{{Integral a$z1}} -> u0 -> a$z1) (u7 :: _forall_ a$z1 =>{{Integral a$z1}} -> u0 -> a$z1) (u8 :: _forall_ a$z1 =>{{Integral a$z1}} -> u0 -> a$z1) -> u2; _NO_DEFLT_ } _N_, _A_ 1 _U_ 1 _N_ _S_ "S" _F_ _IF_ARGS_ 1 1 C 2 _/\_ u0 -> \ (u1 :: ({{Real u0}}, {{Fractional u0}}, (_forall_ z$z1 =>{{Integral z$z1}} -> u0 -> (z$z1, u0)), (_forall_ z$z1 =>{{Integral z$z1}} -> u0 -> z$z1), (_forall_ z$z1 =>{{Integral z$z1}} -> u0 -> z$z1), (_forall_ z$z1 =>{{Integral z$z1}} -> u0 -> z$z1), (_forall_ z$z1 =>{{Integral z$z1}} -> u0 -> z$z1))) -> case u1 of { _ALG_ _TUP_7 (u2 :: {{Real u0}}) (u3 :: {{Fractional u0}}) (u4 :: _forall_ a$z1 =>{{Integral a$z1}} -> u0 -> (a$z1, u0)) (u5 :: _forall_ a$z1 =>{{Integral a$z1}} -> u0 -> a$z1) (u6 :: _forall_ a$z1 =>{{Integral a$z1}} -> u0 -> a$z1) (u7 :: _forall_ a$z1 =>{{Integral a$z1}} -> u0 -> a$z1) (u8 :: _forall_ a$z1 =>{{Integral a$z1}} -> u0 -> a$z1) -> u3; _NO_DEFLT_ } _N_ #-} where
properFraction :: Integral b => a -> (b, a)
{-# GHC_PRAGMA {-meth-} _A_ 2 _U_ 122 _N_ _S_ "SL" _F_ _IF_ARGS_ 2 2 CX 3 _/\_ u0 u1 -> \ (u2 :: ({{Real u0}}, {{Fractional u0}}, (_forall_ z$z1 =>{{Integral z$z1}} -> u0 -> (z$z1, u0)), (_forall_ z$z1 =>{{Integral z$z1}} -> u0 -> z$z1), (_forall_ z$z1 =>{{Integral z$z1}} -> u0 -> z$z1), (_forall_ z$z1 =>{{Integral z$z1}} -> u0 -> z$z1), (_forall_ z$z1 =>{{Integral z$z1}} -> u0 -> z$z1))) (u3 :: {{Integral u1}}) -> case u2 of { _ALG_ _TUP_7 (u4 :: {{Real u0}}) (u5 :: {{Fractional u0}}) (u6 :: _forall_ a$z1 =>{{Integral a$z1}} -> u0 -> (a$z1, u0)) (u7 :: _forall_ a$z1 =>{{Integral a$z1}} -> u0 -> a$z1) (u8 :: _forall_ a$z1 =>{{Integral a$z1}} -> u0 -> a$z1) (u9 :: _forall_ a$z1 =>{{Integral a$z1}} -> u0 -> a$z1) (ua :: _forall_ a$z1 =>{{Integral a$z1}} -> u0 -> a$z1) -> _APP_ _TYAPP_ u6 { u1 } [ u3 ]; _NO_DEFLT_ } _N_
- {-defm-} _A_ 3 _U_ 002 _N_ _S_ _!_ _F_ _IF_ARGS_ 2 3 XXX 3 _/\_ u0 u1 -> \ (u2 :: {{RealFrac u0}}) (u3 :: {{Integral u1}}) (u4 :: u0) -> _APP_ _TYAPP_ patError# { (u0 -> (u1, u0)) } [ _NOREP_S_ "%DPreludeCore.RealFrac.properFraction\"", u4 ] _N_ #-}
+ {-defm-} _A_ 3 _U_ 002 _N_ _S_ _!_ _N_ _N_ #-}
truncate :: Integral b => a -> b
{-# GHC_PRAGMA {-meth-} _A_ 2 _U_ 122 _N_ _S_ "SL" _F_ _IF_ARGS_ 2 2 CX 3 _/\_ u0 u1 -> \ (u2 :: ({{Real u0}}, {{Fractional u0}}, (_forall_ z$z1 =>{{Integral z$z1}} -> u0 -> (z$z1, u0)), (_forall_ z$z1 =>{{Integral z$z1}} -> u0 -> z$z1), (_forall_ z$z1 =>{{Integral z$z1}} -> u0 -> z$z1), (_forall_ z$z1 =>{{Integral z$z1}} -> u0 -> z$z1), (_forall_ z$z1 =>{{Integral z$z1}} -> u0 -> z$z1))) (u3 :: {{Integral u1}}) -> case u2 of { _ALG_ _TUP_7 (u4 :: {{Real u0}}) (u5 :: {{Fractional u0}}) (u6 :: _forall_ a$z1 =>{{Integral a$z1}} -> u0 -> (a$z1, u0)) (u7 :: _forall_ a$z1 =>{{Integral a$z1}} -> u0 -> a$z1) (u8 :: _forall_ a$z1 =>{{Integral a$z1}} -> u0 -> a$z1) (u9 :: _forall_ a$z1 =>{{Integral a$z1}} -> u0 -> a$z1) (ua :: _forall_ a$z1 =>{{Integral a$z1}} -> u0 -> a$z1) -> _APP_ _TYAPP_ u7 { u1 } [ u3 ]; _NO_DEFLT_ } _N_
{-defm-} _A_ 2 _U_ 122 _N_ _S_ "SL" _N_ _N_ #-}
class Text a where
readsPrec :: Int -> [Char] -> [(a, [Char])]
{-# GHC_PRAGMA {-meth-} _A_ 1 _U_ 122 _N_ _S_ "S" _F_ _IF_ARGS_ 1 1 C 2 _/\_ u0 -> \ (u1 :: (Int -> [Char] -> [(u0, [Char])], Int -> u0 -> [Char] -> [Char], [Char] -> [([u0], [Char])], [u0] -> [Char] -> [Char])) -> case u1 of { _ALG_ _TUP_4 (u2 :: Int -> [Char] -> [(u0, [Char])]) (u3 :: Int -> u0 -> [Char] -> [Char]) (u4 :: [Char] -> [([u0], [Char])]) (u5 :: [u0] -> [Char] -> [Char]) -> u2; _NO_DEFLT_ } _N_
- {-defm-} _A_ 3 _U_ 022 _N_ _S_ _!_ _F_ _IF_ARGS_ 1 3 XXX 4 _/\_ u0 -> \ (u1 :: {{Text u0}}) (u2 :: Int) (u3 :: [Char]) -> _APP_ _TYAPP_ patError# { (Int -> [Char] -> [(u0, [Char])]) } [ _NOREP_S_ "%DPreludeCore.Text.readsPrec\"", u2, u3 ] _N_ #-}
+ {-defm-} _A_ 3 _U_ 022 _N_ _S_ _!_ _N_ _N_ #-}
showsPrec :: Int -> a -> [Char] -> [Char]
{-# GHC_PRAGMA {-meth-} _A_ 1 _U_ 1222 _N_ _S_ "S" _F_ _IF_ARGS_ 1 1 C 2 _/\_ u0 -> \ (u1 :: (Int -> [Char] -> [(u0, [Char])], Int -> u0 -> [Char] -> [Char], [Char] -> [([u0], [Char])], [u0] -> [Char] -> [Char])) -> case u1 of { _ALG_ _TUP_4 (u2 :: Int -> [Char] -> [(u0, [Char])]) (u3 :: Int -> u0 -> [Char] -> [Char]) (u4 :: [Char] -> [([u0], [Char])]) (u5 :: [u0] -> [Char] -> [Char]) -> u3; _NO_DEFLT_ } _N_
- {-defm-} _A_ 4 _U_ 0222 _N_ _S_ _!_ _F_ _IF_ARGS_ 1 4 XXXX 5 _/\_ u0 -> \ (u1 :: {{Text u0}}) (u2 :: Int) (u3 :: u0) (u4 :: [Char]) -> _APP_ _TYAPP_ patError# { (Int -> u0 -> [Char] -> [Char]) } [ _NOREP_S_ "%DPreludeCore.Text.showsPrec\"", u2, u3, u4 ] _N_ #-}
+ {-defm-} _A_ 4 _U_ 0222 _N_ _S_ _!_ _N_ _N_ #-}
readList :: [Char] -> [([a], [Char])]
{-# GHC_PRAGMA {-meth-} _A_ 1 _U_ 12 _N_ _S_ "S" _F_ _IF_ARGS_ 1 1 C 2 _/\_ u0 -> \ (u1 :: (Int -> [Char] -> [(u0, [Char])], Int -> u0 -> [Char] -> [Char], [Char] -> [([u0], [Char])], [u0] -> [Char] -> [Char])) -> case u1 of { _ALG_ _TUP_4 (u2 :: Int -> [Char] -> [(u0, [Char])]) (u3 :: Int -> u0 -> [Char] -> [Char]) (u4 :: [Char] -> [([u0], [Char])]) (u5 :: [u0] -> [Char] -> [Char]) -> u4; _NO_DEFLT_ } _N_
- {-defm-} _A_ 1 _U_ 22 _N_ _N_ _F_ _IF_ARGS_ 0 0 X 1 _ORIG_ PreludeCore _readList _N_ #-}
+ {-defm-} _A_ 1 _U_ 12 _N_ _N_ _N_ _N_ #-}
showList :: [a] -> [Char] -> [Char]
{-# GHC_PRAGMA {-meth-} _A_ 1 _U_ 122 _N_ _S_ "S" _F_ _IF_ARGS_ 1 1 C 2 _/\_ u0 -> \ (u1 :: (Int -> [Char] -> [(u0, [Char])], Int -> u0 -> [Char] -> [Char], [Char] -> [([u0], [Char])], [u0] -> [Char] -> [Char])) -> case u1 of { _ALG_ _TUP_4 (u2 :: Int -> [Char] -> [(u0, [Char])]) (u3 :: Int -> u0 -> [Char] -> [Char]) (u4 :: [Char] -> [([u0], [Char])]) (u5 :: [u0] -> [Char] -> [Char]) -> u5; _NO_DEFLT_ } _N_
- {-defm-} _A_ 1 _U_ 212 _N_ _N_ _F_ _IF_ARGS_ 0 0 X 1 _ORIG_ PreludeCore _showList _N_ #-}
+ {-defm-} _A_ 1 _U_ 112 _N_ _N_ _N_ _N_ #-}
class _CCallable a
class _CReturnable a
data Array a b {-# GHC_PRAGMA _Array (a, a) (Array# b) #-}
data Assoc a b = (:=) a b
data _ByteArray a {-# GHC_PRAGMA _ByteArray (a, a) ByteArray# #-}
data Bin
-data Complex a = (:+) a a
+data Complex a = (:+) a a {-# GHC_PRAGMA _SPECIALISE_ [ Double# ] #-}
data _MutableArray a b c {-# GHC_PRAGMA _MutableArray (b, b) (MutableArray# a c) #-}
data _MutableByteArray a b {-# GHC_PRAGMA _MutableByteArray (b, b) (MutableByteArray# a) #-}
data IOError13 = AlreadyExists [Char] | HardwareFault [Char] | IllegalOperation [Char] | InappropriateType [Char] | Interrupted [Char] | InvalidArgument [Char] | NoSuchThing [Char] | OtherError13 [Char] | PermissionDenied [Char] | ProtocolError [Char] | ResourceBusy [Char] | ResourceExhausted [Char] | ResourceVanished [Char] | SystemError [Char] | TimeExpired [Char] | UnsatisfiedConstraints [Char] | UnsupportedOperation [Char] | UserError [Char] | EOF
type ReadS a = [Char] -> [(a, [Char])]
type ShowS = [Char] -> [Char]
data _FILE {-# GHC_PRAGMA _FILE Addr# #-}
+__i0 :: Num a => a
+ {-# GHC_PRAGMA _A_ 1 _U_ 1 _N_ _S_ "U(AAAAAAAAAS)" {_A_ 1 _U_ 1 _N_ _N_ _N_ _N_} _N_ _SPECIALISE_ [ Double ] 1 { _A_ 0 _N_ _N_ _N_ _F_ _IF_ARGS_ 0 0 X 2 _!_ D# [] [0.0000000000000000##] _N_ }, [ Int ] 1 { _A_ 0 _N_ _N_ _N_ _F_ _IF_ARGS_ 0 0 X 2 _!_ I# [] [0#] _N_ }, [ Integer ] 1 { _A_ 0 _N_ _N_ _N_ _N_ _N_ }, [ (Ratio Integer) ] 1 { _A_ 0 _N_ _N_ _N_ _N_ _N_ }, [ (Complex Double) ] 1 { _A_ 0 _N_ _N_ _N_ _N_ _N_ } #-}
+__i1 :: Num a => a
+ {-# GHC_PRAGMA _A_ 1 _U_ 1 _N_ _S_ "U(AAAAAAAAAS)" {_A_ 1 _U_ 1 _N_ _N_ _N_ _N_} _N_ _SPECIALISE_ [ Double ] 1 { _A_ 0 _N_ _N_ _N_ _F_ _IF_ARGS_ 0 0 X 2 _!_ D# [] [1.0000000000000000##] _N_ }, [ Int ] 1 { _A_ 0 _N_ _N_ _N_ _F_ _IF_ARGS_ 0 0 X 2 _!_ I# [] [1#] _N_ }, [ Integer ] 1 { _A_ 0 _N_ _N_ _N_ _N_ _N_ }, [ (Ratio Integer) ] 1 { _A_ 0 _N_ _N_ _N_ _N_ _N_ }, [ (Complex Double) ] 1 { _A_ 0 _N_ _N_ _N_ _N_ _N_ } #-}
+__i10 :: Num a => a
+ {-# GHC_PRAGMA _A_ 1 _U_ 1 _N_ _S_ "U(AAAAAAAAAS)" {_A_ 1 _U_ 1 _N_ _N_ _N_ _N_} _N_ _SPECIALISE_ [ Double ] 1 { _A_ 0 _N_ _N_ _N_ _F_ _IF_ARGS_ 0 0 X 2 _!_ D# [] [10.000000000000000##] _N_ }, [ Int ] 1 { _A_ 0 _N_ _N_ _N_ _F_ _IF_ARGS_ 0 0 X 2 _!_ I# [] [10#] _N_ }, [ Integer ] 1 { _A_ 0 _N_ _N_ _N_ _N_ _N_ }, [ (Ratio Integer) ] 1 { _A_ 0 _N_ _N_ _N_ _N_ _N_ }, [ (Complex Double) ] 1 { _A_ 0 _N_ _N_ _N_ _N_ _N_ } #-}
+__i16 :: Num a => a
+ {-# GHC_PRAGMA _A_ 1 _U_ 1 _N_ _S_ "U(AAAAAAAAAS)" {_A_ 1 _U_ 1 _N_ _N_ _N_ _N_} _N_ _SPECIALISE_ [ Double ] 1 { _A_ 0 _N_ _N_ _N_ _F_ _IF_ARGS_ 0 0 X 2 _!_ D# [] [16.000000000000000##] _N_ }, [ Int ] 1 { _A_ 0 _N_ _N_ _N_ _F_ _IF_ARGS_ 0 0 X 2 _!_ I# [] [16#] _N_ }, [ Integer ] 1 { _A_ 0 _N_ _N_ _N_ _N_ _N_ }, [ (Ratio Integer) ] 1 { _A_ 0 _N_ _N_ _N_ _N_ _N_ }, [ (Complex Double) ] 1 { _A_ 0 _N_ _N_ _N_ _N_ _N_ } #-}
+__i2 :: Num a => a
+ {-# GHC_PRAGMA _A_ 1 _U_ 1 _N_ _S_ "U(AAAAAAAAAS)" {_A_ 1 _U_ 1 _N_ _N_ _N_ _N_} _N_ _SPECIALISE_ [ Double ] 1 { _A_ 0 _N_ _N_ _N_ _F_ _IF_ARGS_ 0 0 X 2 _!_ D# [] [2.0000000000000000##] _N_ }, [ Int ] 1 { _A_ 0 _N_ _N_ _N_ _F_ _IF_ARGS_ 0 0 X 2 _!_ I# [] [2#] _N_ }, [ Integer ] 1 { _A_ 0 _N_ _N_ _N_ _N_ _N_ }, [ (Ratio Integer) ] 1 { _A_ 0 _N_ _N_ _N_ _N_ _N_ }, [ (Complex Double) ] 1 { _A_ 0 _N_ _N_ _N_ _N_ _N_ } #-}
+__i8 :: Num a => a
+ {-# GHC_PRAGMA _A_ 1 _U_ 1 _N_ _S_ "U(AAAAAAAAAS)" {_A_ 1 _U_ 1 _N_ _N_ _N_ _N_} _N_ _SPECIALISE_ [ Double ] 1 { _A_ 0 _N_ _N_ _N_ _F_ _IF_ARGS_ 0 0 X 2 _!_ D# [] [8.0000000000000000##] _N_ }, [ Int ] 1 { _A_ 0 _N_ _N_ _N_ _F_ _IF_ARGS_ 0 0 X 2 _!_ I# [] [8#] _N_ }, [ Integer ] 1 { _A_ 0 _N_ _N_ _N_ _N_ _N_ }, [ (Ratio Integer) ] 1 { _A_ 0 _N_ _N_ _N_ _N_ _N_ }, [ (Complex Double) ] 1 { _A_ 0 _N_ _N_ _N_ _N_ _N_ } #-}
+__im1 :: Num a => a
+ {-# GHC_PRAGMA _A_ 1 _U_ 1 _N_ _S_ "U(AAAAAAAAAS)" {_A_ 1 _U_ 1 _N_ _N_ _N_ _N_} _N_ _SPECIALISE_ [ Double ] 1 { _A_ 0 _N_ _N_ _N_ _F_ _IF_ARGS_ 0 0 X 2 _!_ D# [] [-1.0000000000000000##] _N_ }, [ Int ] 1 { _A_ 0 _N_ _N_ _N_ _F_ _IF_ARGS_ 0 0 X 2 _!_ I# [] [-1#] _N_ }, [ Integer ] 1 { _A_ 0 _N_ _N_ _N_ _N_ _N_ }, [ (Ratio Integer) ] 1 { _A_ 0 _N_ _N_ _N_ _N_ _N_ }, [ (Complex Double) ] 1 { _A_ 0 _N_ _N_ _N_ _N_ _N_ } #-}
+__integer0 :: Integer
+ {-# GHC_PRAGMA _A_ 0 _N_ _N_ _N_ _N_ _N_ #-}
+__integer1 :: Integer
+ {-# GHC_PRAGMA _A_ 0 _N_ _N_ _N_ _N_ _N_ #-}
+__integer2 :: Integer
+ {-# GHC_PRAGMA _A_ 0 _N_ _N_ _N_ _N_ _N_ #-}
+__integerm1 :: Integer
+ {-# GHC_PRAGMA _A_ 0 _N_ _N_ _N_ _N_ _N_ #-}
+__rhalf :: Fractional a => a
+ {-# GHC_PRAGMA _A_ 1 _U_ 1 _N_ _S_ "U(AAAS)" {_A_ 1 _U_ 1 _N_ _N_ _N_ _N_} _N_ _SPECIALISE_ [ Double ] 1 { _A_ 0 _N_ _N_ _N_ _N_ _N_ }, [ (Ratio Integer) ] 1 { _A_ 0 _N_ _N_ _N_ _F_ _IF_ARGS_ 0 0 X 3 _!_ (:%) [Integer] [_SPEC_ _ORIG_ PreludeCore __i1 [ (Integer) ], _SPEC_ _ORIG_ PreludeCore __i2 [ (Integer) ]] _N_ }, [ (Complex Double) ] 1 { _A_ 0 _N_ _N_ _N_ _N_ _N_ } #-}
+_fromRational :: RealFloat a => Ratio Integer -> a
+ {-# GHC_PRAGMA _A_ 2 _U_ 22 _N_ _N_ _N_ _SPECIALISE_ [ Double ] 1 { _A_ 1 _U_ 1 _N_ _S_ "U(U(PPP)U(PPP))" {_A_ 4 _U_ 2221 _N_ _N_ _N_ _N_} _N_ _N_ } #-}
instance Enum ()
{-# GHC_PRAGMA _M_ PreludeBuiltin {-dfun-} _A_ 0 _N_ _N_ _N_ _F_ _IF_ARGS_ 0 0 X 6 _!_ _TUP_5 [{{Ord ()}}, (() -> [()]), (() -> () -> [()]), (() -> () -> [()]), (() -> () -> () -> [()])] [_DFUN_ Ord (()), _CONSTM_ Enum enumFrom (()), _CONSTM_ Enum enumFromThen (()), _CONSTM_ Enum enumFromTo (()), _CONSTM_ Enum enumFromThenTo (())] _N_
- enumFrom = _A_ 1 _U_ 2 _N_ _S_ "E" _N_ _N_,
- enumFromThen = _A_ 2 _U_ 21 _N_ _S_ "EE" _F_ _IF_ARGS_ 0 2 CC 7 \ (u0 :: ()) (u1 :: ()) -> case u0 of { _ALG_ _TUP_0 -> case u1 of { _ALG_ _TUP_0 -> let {(u2 :: [()]) = _!_ _NIL_ [()] []} in _!_ (:) [()] [u0, u2]; _NO_DEFLT_ }; _NO_DEFLT_ } _N_,
- enumFromTo = _A_ 2 _U_ 21 _N_ _S_ "EE" _F_ _IF_ARGS_ 0 2 CC 7 \ (u0 :: ()) (u1 :: ()) -> case u0 of { _ALG_ _TUP_0 -> case u1 of { _ALG_ _TUP_0 -> let {(u2 :: [()]) = _!_ _NIL_ [()] []} in _!_ (:) [()] [u0, u2]; _NO_DEFLT_ }; _NO_DEFLT_ } _N_,
- enumFromThenTo = _A_ 3 _U_ 211 _N_ _S_ "EEE" _F_ _IF_ARGS_ 0 3 CCC 8 \ (u0 :: ()) (u1 :: ()) (u2 :: ()) -> case u0 of { _ALG_ _TUP_0 -> case u1 of { _ALG_ _TUP_0 -> case u2 of { _ALG_ _TUP_0 -> let {(u3 :: [()]) = _!_ _NIL_ [()] []} in _!_ (:) [()] [u0, u3]; _NO_DEFLT_ }; _NO_DEFLT_ }; _NO_DEFLT_ } _N_ #-}
+ enumFrom = { _A_ 1 _U_ 2 _N_ _S_ "E" _N_ _N_ },
+ enumFromThen = { _A_ 2 _U_ 21 _N_ _S_ "EE" _F_ _IF_ARGS_ 0 2 CC 7 \ (u0 :: ()) (u1 :: ()) -> case u0 of { _ALG_ _TUP_0 -> case u1 of { _ALG_ _TUP_0 -> let {(u2 :: [()]) = _!_ _NIL_ [()] []} in _!_ (:) [()] [u0, u2]; _NO_DEFLT_ }; _NO_DEFLT_ } _N_ },
+ enumFromTo = { _A_ 2 _U_ 21 _N_ _S_ "EE" _F_ _IF_ARGS_ 0 2 CC 7 \ (u0 :: ()) (u1 :: ()) -> case u0 of { _ALG_ _TUP_0 -> case u1 of { _ALG_ _TUP_0 -> let {(u2 :: [()]) = _!_ _NIL_ [()] []} in _!_ (:) [()] [u0, u2]; _NO_DEFLT_ }; _NO_DEFLT_ } _N_ },
+ enumFromThenTo = { _A_ 3 _U_ 211 _N_ _S_ "EEE" _F_ _IF_ARGS_ 0 3 CCC 8 \ (u0 :: ()) (u1 :: ()) (u2 :: ()) -> case u0 of { _ALG_ _TUP_0 -> case u1 of { _ALG_ _TUP_0 -> case u2 of { _ALG_ _TUP_0 -> let {(u3 :: [()]) = _!_ _NIL_ [()] []} in _!_ (:) [()] [u0, u3]; _NO_DEFLT_ }; _NO_DEFLT_ }; _NO_DEFLT_ } _N_ } #-}
instance Enum Bool
{-# GHC_PRAGMA _M_ PreludeCore {-dfun-} _A_ 0 _N_ _N_ _N_ _F_ _IF_ARGS_ 0 0 X 6 _!_ _TUP_5 [{{Ord Bool}}, (Bool -> [Bool]), (Bool -> Bool -> [Bool]), (Bool -> Bool -> [Bool]), (Bool -> Bool -> Bool -> [Bool])] [_DFUN_ Ord (Bool), _CONSTM_ Enum enumFrom (Bool), _CONSTM_ Enum enumFromThen (Bool), _CONSTM_ Enum enumFromTo (Bool), _CONSTM_ Enum enumFromThenTo (Bool)] _N_
- enumFrom = _A_ 1 _U_ 2 _N_ _S_ "E" _N_ _N_,
- enumFromThen = _A_ 2 _U_ 22 _N_ _S_ "EE" _N_ _N_,
- enumFromTo = _A_ 2 _U_ 22 _N_ _N_ _N_ _N_,
- enumFromThenTo = _A_ 3 _U_ 222 _N_ _N_ _N_ _N_ #-}
+ enumFrom = { _A_ 1 _U_ 2 _N_ _S_ "E" _N_ _N_ },
+ enumFromThen = { _A_ 2 _U_ 22 _N_ _S_ "EE" _N_ _N_ },
+ enumFromTo = { _A_ 2 _U_ 22 _N_ _S_ "EL" _N_ _N_ },
+ enumFromThenTo = { _A_ 3 _U_ 222 _N_ _S_ "EEL" _N_ _N_ } #-}
instance Enum Char
{-# GHC_PRAGMA _M_ PreludeCore {-dfun-} _A_ 0 _N_ _N_ _N_ _F_ _IF_ARGS_ 0 0 X 6 _!_ _TUP_5 [{{Ord Char}}, (Char -> [Char]), (Char -> Char -> [Char]), (Char -> Char -> [Char]), (Char -> Char -> Char -> [Char])] [_DFUN_ Ord (Char), _CONSTM_ Enum enumFrom (Char), _CONSTM_ Enum enumFromThen (Char), _CONSTM_ Enum enumFromTo (Char), _CONSTM_ Enum enumFromThenTo (Char)] _N_
- enumFrom = _A_ 1 _U_ 1 _N_ _S_ "U(P)" {_A_ 1 _U_ 2 _N_ _N_ _N_ _N_} _N_ _N_,
- enumFromThen = _A_ 2 _U_ 22 _N_ _N_ _N_ _N_,
- enumFromTo = _A_ 2 _U_ 22 _N_ _N_ _N_ _N_,
- enumFromThenTo = _A_ 3 _U_ 222 _N_ _N_ _N_ _N_ #-}
+ enumFrom = { _A_ 1 _U_ 1 _N_ _S_ "U(P)" {_A_ 1 _U_ 2 _N_ _N_ _N_ _N_} _N_ _N_ },
+ enumFromThen = { _A_ 2 _U_ 22 _N_ _N_ _N_ _N_ },
+ enumFromTo = { _A_ 2 _U_ 12 _N_ _S_ "U(P)L" {_A_ 2 _U_ 22 _N_ _N_ _N_ _N_} _N_ _N_ },
+ enumFromThenTo = { _A_ 3 _U_ 222 _N_ _N_ _N_ _N_ } #-}
instance Enum Double
{-# GHC_PRAGMA _M_ PreludeCore {-dfun-} _A_ 0 _N_ _N_ _N_ _F_ _IF_ARGS_ 0 0 X 6 _!_ _TUP_5 [{{Ord Double}}, (Double -> [Double]), (Double -> Double -> [Double]), (Double -> Double -> [Double]), (Double -> Double -> Double -> [Double])] [_DFUN_ Ord (Double), _CONSTM_ Enum enumFrom (Double), _CONSTM_ Enum enumFromThen (Double), _CONSTM_ Enum enumFromTo (Double), _CONSTM_ Enum enumFromThenTo (Double)] _N_
- enumFrom = _A_ 1 _U_ 2 _N_ _N_ _N_ _N_,
- enumFromThen = _A_ 2 _U_ 21 _N_ _N_ _N_ _N_,
- enumFromTo = _A_ 2 _U_ 22 _N_ _N_ _N_ _N_,
- enumFromThenTo = _A_ 3 _U_ 222 _N_ _N_ _N_ _N_ #-}
+ enumFrom = { _A_ 1 _U_ 2 _N_ _N_ _N_ _N_ },
+ enumFromThen = { _A_ 2 _U_ 21 _N_ _N_ _N_ _N_ },
+ enumFromTo = { _A_ 2 _U_ 22 _N_ _N_ _N_ _N_ },
+ enumFromThenTo = { _A_ 3 _U_ 222 _N_ _N_ _N_ _N_ } #-}
instance Enum Float
{-# GHC_PRAGMA _M_ PreludeCore {-dfun-} _A_ 0 _N_ _N_ _N_ _F_ _IF_ARGS_ 0 0 X 6 _!_ _TUP_5 [{{Ord Float}}, (Float -> [Float]), (Float -> Float -> [Float]), (Float -> Float -> [Float]), (Float -> Float -> Float -> [Float])] [_DFUN_ Ord (Float), _CONSTM_ Enum enumFrom (Float), _CONSTM_ Enum enumFromThen (Float), _CONSTM_ Enum enumFromTo (Float), _CONSTM_ Enum enumFromThenTo (Float)] _N_
- enumFrom = _A_ 1 _U_ 2 _N_ _N_ _N_ _N_,
- enumFromThen = _A_ 2 _U_ 21 _N_ _N_ _N_ _N_,
- enumFromTo = _A_ 2 _U_ 22 _N_ _N_ _N_ _N_,
- enumFromThenTo = _A_ 3 _U_ 222 _N_ _N_ _N_ _N_ #-}
+ enumFrom = { _A_ 1 _U_ 2 _N_ _N_ _N_ _N_ },
+ enumFromThen = { _A_ 2 _U_ 21 _N_ _N_ _N_ _N_ },
+ enumFromTo = { _A_ 2 _U_ 22 _N_ _N_ _N_ _N_ },
+ enumFromThenTo = { _A_ 3 _U_ 222 _N_ _N_ _N_ _N_ } #-}
instance Enum Int
{-# GHC_PRAGMA _M_ PreludeCore {-dfun-} _A_ 0 _N_ _N_ _N_ _F_ _IF_ARGS_ 0 0 X 6 _!_ _TUP_5 [{{Ord Int}}, (Int -> [Int]), (Int -> Int -> [Int]), (Int -> Int -> [Int]), (Int -> Int -> Int -> [Int])] [_DFUN_ Ord (Int), _CONSTM_ Enum enumFrom (Int), _CONSTM_ Enum enumFromThen (Int), _CONSTM_ Enum enumFromTo (Int), _CONSTM_ Enum enumFromThenTo (Int)] _N_
- enumFrom = _A_ 1 _U_ 2 _N_ _N_ _F_ _ALWAYS_ \ (u0 :: Int) -> _LETREC_ {(u1 :: Int -> [Int]) = \ (u2 :: Int) -> let {(u6 :: [Int]) = let {(u5 :: Int) = case u2 of { _ALG_ I# (u3 :: Int#) -> case _#_ plusInt# [] [u3, 1#] of { _PRIM_ (u4 :: Int#) -> _!_ I# [] [u4] }; _NO_DEFLT_ }} in _APP_ u1 [ u5 ]} in _!_ (:) [Int] [u2, u6]} in _APP_ u1 [ u0 ] _N_,
- enumFromThen = _A_ 2 _U_ 21 _N_ _N_ _N_ _N_,
- enumFromTo = _A_ 2 _U_ 12 _N_ _S_ "SS" _F_ _ALWAYS_ \ (u0 :: Int) (u1 :: Int) -> case u0 of { _ALG_ I# (u2 :: Int#) -> _LETREC_ {(u3 :: Int# -> [Int]) = \ (u4 :: Int#) -> case u1 of { _ALG_ I# (u5 :: Int#) -> case _#_ leInt# [] [u4, u5] of { _ALG_ True -> let {(u7 :: [Int]) = case _#_ plusInt# [] [u4, 1#] of { _PRIM_ (u6 :: Int#) -> _APP_ u3 [ u6 ] }} in let {(u8 :: Int) = _!_ I# [] [u4]} in _!_ (:) [Int] [u8, u7]; False -> _!_ _NIL_ [Int] []; _NO_DEFLT_ }; _NO_DEFLT_ }} in _APP_ u3 [ u2 ]; _NO_DEFLT_ } _N_,
- enumFromThenTo = _A_ 3 _U_ 222 _N_ _N_ _N_ _N_ #-}
+ enumFrom = { _A_ 1 _U_ 2 _N_ _N_ _F_ _ALWAYS_ \ (u0 :: Int) -> _LETREC_ {(u1 :: Int -> [Int]) = \ (u2 :: Int) -> let {(u6 :: [Int]) = let {(u5 :: Int) = case u2 of { _ALG_ I# (u3 :: Int#) -> case _#_ plusInt# [] [u3, 1#] of { _PRIM_ (u4 :: Int#) -> _!_ I# [] [u4] }; _NO_DEFLT_ }} in _APP_ u1 [ u5 ]} in _!_ (:) [Int] [u2, u6]} in _APP_ u1 [ u0 ] _N_ },
+ enumFromThen = { _A_ 2 _U_ 21 _N_ _N_ _N_ _N_ },
+ enumFromTo = { _A_ 2 _U_ 12 _N_ _S_ "SS" _F_ _ALWAYS_ \ (u0 :: Int) (u1 :: Int) -> case u0 of { _ALG_ I# (u2 :: Int#) -> _LETREC_ {(u3 :: Int# -> [Int]) = \ (u4 :: Int#) -> case u1 of { _ALG_ I# (u5 :: Int#) -> case _#_ leInt# [] [u4, u5] of { _ALG_ True -> let {(u7 :: [Int]) = case _#_ plusInt# [] [u4, 1#] of { _PRIM_ (u6 :: Int#) -> _APP_ u3 [ u6 ] }} in let {(u8 :: Int) = _!_ I# [] [u4]} in _!_ (:) [Int] [u8, u7]; False -> _!_ _NIL_ [Int] []; _NO_DEFLT_ }; _NO_DEFLT_ }} in _APP_ u3 [ u2 ]; _NO_DEFLT_ } _N_ },
+ enumFromThenTo = { _A_ 3 _U_ 222 _N_ _N_ _N_ _N_ } #-}
instance Enum Integer
{-# GHC_PRAGMA _M_ PreludeCore {-dfun-} _A_ 0 _N_ _N_ _N_ _F_ _IF_ARGS_ 0 0 X 6 _!_ _TUP_5 [{{Ord Integer}}, (Integer -> [Integer]), (Integer -> Integer -> [Integer]), (Integer -> Integer -> [Integer]), (Integer -> Integer -> Integer -> [Integer])] [_DFUN_ Ord (Integer), _CONSTM_ Enum enumFrom (Integer), _CONSTM_ Enum enumFromThen (Integer), _CONSTM_ Enum enumFromTo (Integer), _CONSTM_ Enum enumFromThenTo (Integer)] _N_
- enumFrom = _A_ 1 _U_ 2 _N_ _N_ _N_ _N_,
- enumFromThen = _A_ 2 _U_ 21 _N_ _N_ _N_ _N_,
- enumFromTo = _A_ 2 _U_ 22 _N_ _N_ _N_ _N_,
- enumFromThenTo = _A_ 3 _U_ 222 _N_ _N_ _N_ _N_ #-}
+ enumFrom = { _A_ 1 _U_ 2 _N_ _N_ _N_ _N_ },
+ enumFromThen = { _A_ 2 _U_ 21 _N_ _N_ _N_ _N_ },
+ enumFromTo = { _A_ 2 _U_ 22 _N_ _N_ _N_ _N_ },
+ enumFromThenTo = { _A_ 3 _U_ 222 _N_ _N_ _N_ _N_ } #-}
instance Integral a => Enum (Ratio a)
{-# GHC_PRAGMA _M_ PreludeRatio {-dfun-} _A_ 2 _U_ 22 _N_ _N_ _N_ _N_ #-}
instance Enum (Ratio Integer)
{-# GHC_PRAGMA _M_ PreludeRatio {-dfun-} _A_ 0 _N_ _N_ _N_ _F_ _IF_ARGS_ 0 0 X 6 _!_ _TUP_5 [{{Ord (Ratio Integer)}}, (Ratio Integer -> [Ratio Integer]), (Ratio Integer -> Ratio Integer -> [Ratio Integer]), (Ratio Integer -> Ratio Integer -> [Ratio Integer]), (Ratio Integer -> Ratio Integer -> Ratio Integer -> [Ratio Integer])] [_DFUN_ Ord (Ratio Integer), _CONSTM_ Enum enumFrom (Ratio Integer), _CONSTM_ Enum enumFromThen (Ratio Integer), _CONSTM_ Enum enumFromTo (Ratio Integer), _CONSTM_ Enum enumFromThenTo (Ratio Integer)] _N_
- enumFrom = _A_ 1 _U_ 2 _N_ _N_ _N_ _N_,
- enumFromThen = _A_ 2 _U_ 21 _N_ _N_ _N_ _N_,
- enumFromTo = _A_ 2 _U_ 22 _N_ _N_ _N_ _N_,
- enumFromThenTo = _A_ 3 _U_ 222 _N_ _N_ _N_ _N_ #-}
+ enumFrom = { _A_ 1 _U_ 2 _N_ _N_ _N_ _N_ },
+ enumFromThen = { _A_ 2 _U_ 21 _N_ _N_ _N_ _N_ },
+ enumFromTo = { _A_ 2 _U_ 22 _N_ _N_ _N_ _N_ },
+ enumFromThenTo = { _A_ 3 _U_ 222 _N_ _N_ _N_ _N_ } #-}
instance Eq ()
{-# GHC_PRAGMA _M_ PreludeBuiltin {-dfun-} _A_ 0 _N_ _N_ _N_ _F_ _IF_ARGS_ 0 0 X 3 _!_ _TUP_2 [(() -> () -> Bool), (() -> () -> Bool)] [_CONSTM_ Eq (==) (()), _CONSTM_ Eq (/=) (())] _N_
- (==) = _A_ 2 _U_ 11 _N_ _S_ "EE" _F_ _IF_ARGS_ 0 2 CC 3 \ (u0 :: ()) (u1 :: ()) -> case u0 of { _ALG_ _TUP_0 -> case u1 of { _ALG_ _TUP_0 -> _!_ True [] []; _NO_DEFLT_ }; _NO_DEFLT_ } _N_,
- (/=) = _A_ 2 _U_ 11 _N_ _S_ "EE" _F_ _IF_ARGS_ 0 2 CC 3 \ (u0 :: ()) (u1 :: ()) -> case u0 of { _ALG_ _TUP_0 -> case u1 of { _ALG_ _TUP_0 -> _!_ False [] []; _NO_DEFLT_ }; _NO_DEFLT_ } _N_ #-}
+ (==) = { _A_ 2 _U_ 11 _N_ _S_ "EE" _F_ _IF_ARGS_ 0 2 CC 3 \ (u0 :: ()) (u1 :: ()) -> case u0 of { _ALG_ _TUP_0 -> case u1 of { _ALG_ _TUP_0 -> _!_ True [] []; _NO_DEFLT_ }; _NO_DEFLT_ } _N_ },
+ (/=) = { _A_ 2 _U_ 11 _N_ _S_ "EE" _F_ _IF_ARGS_ 0 2 CC 3 \ (u0 :: ()) (u1 :: ()) -> case u0 of { _ALG_ _TUP_0 -> case u1 of { _ALG_ _TUP_0 -> _!_ False [] []; _NO_DEFLT_ }; _NO_DEFLT_ } _N_ } #-}
instance (Eq a, Eq b) => Eq (a, b)
- {-# GHC_PRAGMA _M_ PreludeBuiltin {-dfun-} _A_ 2 _U_ 11 _N_ _N_ _N_ _N_ #-}
+ {-# GHC_PRAGMA _M_ PreludeBuiltin {-dfun-} _A_ 2 _U_ 22 _N_ _N_ _N_ _N_ #-}
instance (Eq a, Eq b, Eq c) => Eq (a, b, c)
{-# GHC_PRAGMA _M_ PreludeBuiltin {-dfun-} _A_ 3 _U_ 111 _N_ _N_ _N_ _N_ #-}
instance (Eq a, Eq b, Eq c, Eq d) => Eq (a, b, c, d)
{-# GHC_PRAGMA _M_ PreludeBuiltin {-dfun-} _A_ 5 _U_ 11111 _N_ _N_ _N_ _N_ #-}
instance Eq (Int, Int)
{-# GHC_PRAGMA _M_ PreludeBuiltin {-dfun-} _A_ 0 _N_ _N_ _N_ _F_ _IF_ARGS_ 0 0 X 3 _!_ _TUP_2 [((Int, Int) -> (Int, Int) -> Bool), ((Int, Int) -> (Int, Int) -> Bool)] [_CONSTM_ Eq (==) ((Int, Int)), _CONSTM_ Eq (/=) ((Int, Int))] _N_
- (==) = _A_ 2 _U_ 11 _N_ _S_ "U(U(P)L)U(U(P)L)" {_A_ 4 _U_ 2121 _N_ _N_ _F_ _IF_ARGS_ 0 4 XCXC 7 \ (u0 :: Int#) (u1 :: Int) (u2 :: Int#) (u3 :: Int) -> case _#_ eqInt# [] [u0, u2] of { _ALG_ True -> case u1 of { _ALG_ I# (u4 :: Int#) -> case u3 of { _ALG_ I# (u5 :: Int#) -> _#_ eqInt# [] [u4, u5]; _NO_DEFLT_ }; _NO_DEFLT_ }; False -> _!_ False [] []; _NO_DEFLT_ } _N_} _F_ _ALWAYS_ \ (u0 :: (Int, Int)) (u1 :: (Int, Int)) -> case u0 of { _ALG_ _TUP_2 (u2 :: Int) (u3 :: Int) -> case u2 of { _ALG_ I# (u4 :: Int#) -> case u1 of { _ALG_ _TUP_2 (u5 :: Int) (u6 :: Int) -> case u5 of { _ALG_ I# (u7 :: Int#) -> case _#_ eqInt# [] [u4, u7] of { _ALG_ True -> case u3 of { _ALG_ I# (u8 :: Int#) -> case u6 of { _ALG_ I# (u9 :: Int#) -> _#_ eqInt# [] [u8, u9]; _NO_DEFLT_ }; _NO_DEFLT_ }; False -> _!_ False [] []; _NO_DEFLT_ }; _NO_DEFLT_ }; _NO_DEFLT_ }; _NO_DEFLT_ }; _NO_DEFLT_ } _N_,
- (/=) = _A_ 2 _U_ 22 _N_ _N_ _N_ _N_ #-}
+ (==) = { _A_ 2 _U_ 11 _N_ _S_ "U(U(P)L)U(U(P)L)" {_A_ 4 _U_ 2121 _N_ _N_ _F_ _IF_ARGS_ 0 4 XCXC 7 \ (u0 :: Int#) (u1 :: Int) (u2 :: Int#) (u3 :: Int) -> case _#_ eqInt# [] [u0, u2] of { _ALG_ True -> case u1 of { _ALG_ I# (u4 :: Int#) -> case u3 of { _ALG_ I# (u5 :: Int#) -> _#_ eqInt# [] [u4, u5]; _NO_DEFLT_ }; _NO_DEFLT_ }; False -> _!_ False [] []; _NO_DEFLT_ } _N_} _F_ _ALWAYS_ \ (u0 :: (Int, Int)) (u1 :: (Int, Int)) -> case u0 of { _ALG_ _TUP_2 (u2 :: Int) (u3 :: Int) -> case u2 of { _ALG_ I# (u4 :: Int#) -> case u1 of { _ALG_ _TUP_2 (u5 :: Int) (u6 :: Int) -> case u5 of { _ALG_ I# (u7 :: Int#) -> case _#_ eqInt# [] [u4, u7] of { _ALG_ True -> case u3 of { _ALG_ I# (u8 :: Int#) -> case u6 of { _ALG_ I# (u9 :: Int#) -> _#_ eqInt# [] [u8, u9]; _NO_DEFLT_ }; _NO_DEFLT_ }; False -> _!_ False [] []; _NO_DEFLT_ }; _NO_DEFLT_ }; _NO_DEFLT_ }; _NO_DEFLT_ }; _NO_DEFLT_ } _N_ },
+ (/=) = { _A_ 2 _U_ 11 _N_ _S_ "U(U(P)L)U(U(P)L)" {_A_ 4 _U_ 2121 _N_ _N_ _F_ _IF_ARGS_ 0 4 XCXC 7 \ (u0 :: Int#) (u1 :: Int) (u2 :: Int#) (u3 :: Int) -> case _#_ neInt# [] [u0, u2] of { _ALG_ True -> _!_ True [] []; False -> case u1 of { _ALG_ I# (u4 :: Int#) -> case u3 of { _ALG_ I# (u5 :: Int#) -> _#_ neInt# [] [u4, u5]; _NO_DEFLT_ }; _NO_DEFLT_ }; _NO_DEFLT_ } _N_} _F_ _ALWAYS_ \ (u0 :: (Int, Int)) (u1 :: (Int, Int)) -> case u0 of { _ALG_ _TUP_2 (u2 :: Int) (u3 :: Int) -> case u2 of { _ALG_ I# (u4 :: Int#) -> case u1 of { _ALG_ _TUP_2 (u5 :: Int) (u6 :: Int) -> case u5 of { _ALG_ I# (u7 :: Int#) -> case _#_ neInt# [] [u4, u7] of { _ALG_ True -> _!_ True [] []; False -> case u3 of { _ALG_ I# (u8 :: Int#) -> case u6 of { _ALG_ I# (u9 :: Int#) -> _#_ neInt# [] [u8, u9]; _NO_DEFLT_ }; _NO_DEFLT_ }; _NO_DEFLT_ }; _NO_DEFLT_ }; _NO_DEFLT_ }; _NO_DEFLT_ }; _NO_DEFLT_ } _N_ } #-}
+instance Eq (Int, Int, Int)
+ {-# GHC_PRAGMA _M_ PreludeBuiltin {-dfun-} _A_ 0 _N_ _N_ _N_ _F_ _IF_ARGS_ 0 0 X 3 _!_ _TUP_2 [((Int, Int, Int) -> (Int, Int, Int) -> Bool), ((Int, Int, Int) -> (Int, Int, Int) -> Bool)] [_CONSTM_ Eq (==) ((Int, Int, Int)), _CONSTM_ Eq (/=) ((Int, Int, Int))] _N_
+ (==) = { _A_ 2 _U_ 11 _N_ _S_ "U(U(P)LL)U(U(P)LL)" {_A_ 4 _U_ 2111 _N_ _N_ _N_ _N_} _N_ _N_ },
+ (/=) = { _A_ 2 _U_ 11 _N_ _S_ "U(U(P)LL)U(U(P)LL)" {_A_ 4 _U_ 2111 _N_ _N_ _N_ _N_} _N_ _N_ } #-}
+instance Eq (Int, Int, Int, Int)
+ {-# GHC_PRAGMA _M_ PreludeBuiltin {-dfun-} _A_ 0 _N_ _N_ _N_ _F_ _IF_ARGS_ 0 0 X 3 _!_ _TUP_2 [((Int, Int, Int, Int) -> (Int, Int, Int, Int) -> Bool), ((Int, Int, Int, Int) -> (Int, Int, Int, Int) -> Bool)] [_CONSTM_ Eq (==) ((Int, Int, Int, Int)), _CONSTM_ Eq (/=) ((Int, Int, Int, Int))] _N_
+ (==) = { _A_ 2 _U_ 11 _N_ _S_ "U(U(P)LLL)U(U(P)LLL)" {_A_ 5 _U_ 21111 _N_ _N_ _N_ _N_} _N_ _N_ },
+ (/=) = { _A_ 2 _U_ 11 _N_ _S_ "U(U(P)LLL)U(U(P)LLL)" {_A_ 5 _U_ 21111 _N_ _N_ _N_ _N_} _N_ _N_ } #-}
+instance Eq (Int, Int, Int, Int, Int)
+ {-# GHC_PRAGMA _M_ PreludeBuiltin {-dfun-} _A_ 0 _N_ _N_ _N_ _F_ _IF_ARGS_ 0 0 X 3 _!_ _TUP_2 [((Int, Int, Int, Int, Int) -> (Int, Int, Int, Int, Int) -> Bool), ((Int, Int, Int, Int, Int) -> (Int, Int, Int, Int, Int) -> Bool)] [_CONSTM_ Eq (==) ((Int, Int, Int, Int, Int)), _CONSTM_ Eq (/=) ((Int, Int, Int, Int, Int))] _N_
+ (==) = { _A_ 2 _U_ 11 _N_ _S_ "U(U(P)LLLL)U(U(P)LLLL)" _N_ _N_ },
+ (/=) = { _A_ 2 _U_ 11 _N_ _S_ "U(U(P)LLLL)U(U(P)LLLL)" _N_ _N_ } #-}
+instance Eq ([Char], [Char])
+ {-# GHC_PRAGMA _M_ PreludeBuiltin {-dfun-} _A_ 0 _N_ _N_ _N_ _F_ _IF_ARGS_ 0 0 X 3 _!_ _TUP_2 [(([Char], [Char]) -> ([Char], [Char]) -> Bool), (([Char], [Char]) -> ([Char], [Char]) -> Bool)] [_CONSTM_ Eq (==) (([Char], [Char])), _CONSTM_ Eq (/=) (([Char], [Char]))] _N_
+ (==) = { _A_ 2 _U_ 11 _N_ _S_ "U(SL)U(SL)" {_A_ 4 _U_ 2222 _N_ _N_ _N_ _N_} _N_ _N_ },
+ (/=) = { _A_ 2 _U_ 11 _N_ _S_ "U(SL)U(SL)" {_A_ 4 _U_ 2222 _N_ _N_ _N_ _N_} _N_ _N_ } #-}
+instance Eq ([Int], [Int])
+ {-# GHC_PRAGMA _M_ PreludeBuiltin {-dfun-} _A_ 0 _N_ _N_ _N_ _F_ _IF_ARGS_ 0 0 X 3 _!_ _TUP_2 [(([Int], [Int]) -> ([Int], [Int]) -> Bool), (([Int], [Int]) -> ([Int], [Int]) -> Bool)] [_CONSTM_ Eq (==) (([Int], [Int])), _CONSTM_ Eq (/=) (([Int], [Int]))] _N_
+ (==) = { _A_ 2 _U_ 11 _N_ _S_ "U(SL)U(SL)" {_A_ 4 _U_ 2222 _N_ _N_ _N_ _N_} _N_ _N_ },
+ (/=) = { _A_ 2 _U_ 11 _N_ _S_ "U(SL)U(SL)" {_A_ 4 _U_ 2222 _N_ _N_ _N_ _N_} _N_ _N_ } #-}
instance Eq (_PackedString, _PackedString)
{-# GHC_PRAGMA _M_ PreludeBuiltin {-dfun-} _A_ 0 _N_ _N_ _N_ _F_ _IF_ARGS_ 0 0 X 3 _!_ _TUP_2 [((_PackedString, _PackedString) -> (_PackedString, _PackedString) -> Bool), ((_PackedString, _PackedString) -> (_PackedString, _PackedString) -> Bool)] [_CONSTM_ Eq (==) ((_PackedString, _PackedString)), _CONSTM_ Eq (/=) ((_PackedString, _PackedString))] _N_
- (==) = _A_ 2 _U_ 11 _N_ _S_ "U(SL)U(SL)" {_A_ 4 _U_ 2222 _N_ _N_ _N_ _N_} _N_ _N_,
- (/=) = _A_ 2 _U_ 22 _N_ _N_ _N_ _N_ #-}
+ (==) = { _A_ 2 _U_ 11 _N_ _S_ "U(SL)U(SL)" {_A_ 4 _U_ 2222 _N_ _N_ _N_ _N_} _N_ _N_ },
+ (/=) = { _A_ 2 _U_ 11 _N_ _S_ "U(SL)U(SL)" {_A_ 4 _U_ 2222 _N_ _N_ _N_ _N_} _N_ _N_ } #-}
instance (Ix a, Eq b) => Eq (Array a b)
{-# GHC_PRAGMA _M_ PreludeArray {-dfun-} _A_ 2 _U_ 21 _N_ _N_ _N_ _N_ #-}
instance (Eq a, Eq b) => Eq (Assoc a b)
{-# GHC_PRAGMA _M_ PreludeArray {-dfun-} _A_ 2 _U_ 11 _N_ _N_ _N_ _N_ #-}
instance Eq Bool
{-# GHC_PRAGMA _M_ PreludeCore {-dfun-} _A_ 0 _N_ _N_ _N_ _F_ _IF_ARGS_ 0 0 X 3 _!_ _TUP_2 [(Bool -> Bool -> Bool), (Bool -> Bool -> Bool)] [_CONSTM_ Eq (==) (Bool), _CONSTM_ Eq (/=) (Bool)] _N_
- (==) = _A_ 2 _U_ 11 _N_ _S_ "EE" _F_ _IF_ARGS_ 0 2 CC 7 \ (u0 :: Bool) (u1 :: Bool) -> case u0 of { _ALG_ True -> u1; False -> case u1 of { _ALG_ True -> _!_ False [] []; False -> _!_ True [] []; _NO_DEFLT_ }; _NO_DEFLT_ } _N_,
- (/=) = _A_ 2 _U_ 11 _N_ _S_ "EE" _F_ _IF_ARGS_ 0 2 CC 7 \ (u0 :: Bool) (u1 :: Bool) -> case u0 of { _ALG_ True -> case u1 of { _ALG_ True -> _!_ False [] []; False -> _!_ True [] []; _NO_DEFLT_ }; False -> u1; _NO_DEFLT_ } _N_ #-}
+ (==) = { _A_ 2 _U_ 11 _N_ _S_ "EE" _F_ _IF_ARGS_ 0 2 CC 7 \ (u0 :: Bool) (u1 :: Bool) -> case u0 of { _ALG_ True -> u1; False -> case u1 of { _ALG_ True -> _!_ False [] []; False -> _!_ True [] []; _NO_DEFLT_ }; _NO_DEFLT_ } _N_ },
+ (/=) = { _A_ 2 _U_ 11 _N_ _S_ "EE" _F_ _IF_ARGS_ 0 2 CC 7 \ (u0 :: Bool) (u1 :: Bool) -> case u0 of { _ALG_ True -> case u1 of { _ALG_ True -> _!_ False [] []; False -> _!_ True [] []; _NO_DEFLT_ }; False -> u1; _NO_DEFLT_ } _N_ } #-}
instance Eq Char
{-# GHC_PRAGMA _M_ PreludeCore {-dfun-} _A_ 0 _N_ _N_ _N_ _F_ _IF_ARGS_ 0 0 X 3 _!_ _TUP_2 [(Char -> Char -> Bool), (Char -> Char -> Bool)] [_CONSTM_ Eq (==) (Char), _CONSTM_ Eq (/=) (Char)] _N_
- (==) = _A_ 2 _U_ 11 _N_ _S_ "U(P)U(P)" {_A_ 2 _U_ 22 _N_ _N_ _F_ _IF_ARGS_ 0 2 XX 1 \ (u0 :: Char#) (u1 :: Char#) -> _#_ eqChar# [] [u0, u1] _N_} _F_ _IF_ARGS_ 0 2 CC 3 \ (u0 :: Char) (u1 :: Char) -> case u0 of { _ALG_ C# (u2 :: Char#) -> case u1 of { _ALG_ C# (u3 :: Char#) -> _#_ eqChar# [] [u2, u3]; _NO_DEFLT_ }; _NO_DEFLT_ } _N_,
- (/=) = _A_ 2 _U_ 11 _N_ _S_ "U(P)U(P)" {_A_ 2 _U_ 22 _N_ _N_ _F_ _IF_ARGS_ 0 2 XX 1 \ (u0 :: Char#) (u1 :: Char#) -> _#_ neChar# [] [u0, u1] _N_} _F_ _IF_ARGS_ 0 2 CC 3 \ (u0 :: Char) (u1 :: Char) -> case u0 of { _ALG_ C# (u2 :: Char#) -> case u1 of { _ALG_ C# (u3 :: Char#) -> _#_ neChar# [] [u2, u3]; _NO_DEFLT_ }; _NO_DEFLT_ } _N_ #-}
+ (==) = { _A_ 2 _U_ 11 _N_ _S_ "U(P)U(P)" {_A_ 2 _U_ 22 _N_ _N_ _F_ _IF_ARGS_ 0 2 XX 1 \ (u0 :: Char#) (u1 :: Char#) -> _#_ eqChar# [] [u0, u1] _N_} _F_ _IF_ARGS_ 0 2 CC 3 \ (u0 :: Char) (u1 :: Char) -> case u0 of { _ALG_ C# (u2 :: Char#) -> case u1 of { _ALG_ C# (u3 :: Char#) -> _#_ eqChar# [] [u2, u3]; _NO_DEFLT_ }; _NO_DEFLT_ } _N_ },
+ (/=) = { _A_ 2 _U_ 11 _N_ _S_ "U(P)U(P)" {_A_ 2 _U_ 22 _N_ _N_ _F_ _IF_ARGS_ 0 2 XX 1 \ (u0 :: Char#) (u1 :: Char#) -> _#_ neChar# [] [u0, u1] _N_} _F_ _IF_ARGS_ 0 2 CC 3 \ (u0 :: Char) (u1 :: Char) -> case u0 of { _ALG_ C# (u2 :: Char#) -> case u1 of { _ALG_ C# (u3 :: Char#) -> _#_ neChar# [] [u2, u3]; _NO_DEFLT_ }; _NO_DEFLT_ } _N_ } #-}
instance Eq a => Eq (Complex a)
{-# GHC_PRAGMA _M_ PreludeComplex {-dfun-} _A_ 1 _U_ 2 _N_ _N_ _N_ _N_ #-}
instance Eq (Complex Double)
{-# GHC_PRAGMA _M_ PreludeComplex {-dfun-} _A_ 0 _N_ _N_ _N_ _F_ _IF_ARGS_ 0 0 X 3 _!_ _TUP_2 [(Complex Double -> Complex Double -> Bool), (Complex Double -> Complex Double -> Bool)] [_CONSTM_ Eq (==) (Complex Double), _CONSTM_ Eq (/=) (Complex Double)] _N_
- (==) = _A_ 2 _U_ 11 _N_ _S_ "U(U(P)L)U(U(P)L)" {_A_ 4 _U_ 2121 _N_ _N_ _F_ _IF_ARGS_ 0 4 XCXC 7 \ (u0 :: Double#) (u1 :: Double) (u2 :: Double#) (u3 :: Double) -> case _#_ eqDouble# [] [u0, u2] of { _ALG_ True -> case u1 of { _ALG_ D# (u4 :: Double#) -> case u3 of { _ALG_ D# (u5 :: Double#) -> _#_ eqDouble# [] [u4, u5]; _NO_DEFLT_ }; _NO_DEFLT_ }; False -> _!_ False [] []; _NO_DEFLT_ } _N_} _F_ _ALWAYS_ \ (u0 :: Complex Double) (u1 :: Complex Double) -> case u0 of { _ALG_ (:+) (u2 :: Double) (u3 :: Double) -> case u2 of { _ALG_ D# (u4 :: Double#) -> case u1 of { _ALG_ (:+) (u5 :: Double) (u6 :: Double) -> case u5 of { _ALG_ D# (u7 :: Double#) -> case _#_ eqDouble# [] [u4, u7] of { _ALG_ True -> case u3 of { _ALG_ D# (u8 :: Double#) -> case u6 of { _ALG_ D# (u9 :: Double#) -> _#_ eqDouble# [] [u8, u9]; _NO_DEFLT_ }; _NO_DEFLT_ }; False -> _!_ False [] []; _NO_DEFLT_ }; _NO_DEFLT_ }; _NO_DEFLT_ }; _NO_DEFLT_ }; _NO_DEFLT_ } _N_,
- (/=) = _A_ 2 _U_ 11 _N_ _S_ "U(U(P)L)U(U(P)L)" {_A_ 4 _U_ 2121 _N_ _N_ _F_ _IF_ARGS_ 0 4 XCXC 7 \ (u0 :: Double#) (u1 :: Double) (u2 :: Double#) (u3 :: Double) -> case _#_ neDouble# [] [u0, u2] of { _ALG_ True -> _!_ True [] []; False -> case u1 of { _ALG_ D# (u4 :: Double#) -> case u3 of { _ALG_ D# (u5 :: Double#) -> _#_ neDouble# [] [u4, u5]; _NO_DEFLT_ }; _NO_DEFLT_ }; _NO_DEFLT_ } _N_} _F_ _ALWAYS_ \ (u0 :: Complex Double) (u1 :: Complex Double) -> case u0 of { _ALG_ (:+) (u2 :: Double) (u3 :: Double) -> case u2 of { _ALG_ D# (u4 :: Double#) -> case u1 of { _ALG_ (:+) (u5 :: Double) (u6 :: Double) -> case u5 of { _ALG_ D# (u7 :: Double#) -> case _#_ neDouble# [] [u4, u7] of { _ALG_ True -> _!_ True [] []; False -> case u3 of { _ALG_ D# (u8 :: Double#) -> case u6 of { _ALG_ D# (u9 :: Double#) -> _#_ neDouble# [] [u8, u9]; _NO_DEFLT_ }; _NO_DEFLT_ }; _NO_DEFLT_ }; _NO_DEFLT_ }; _NO_DEFLT_ }; _NO_DEFLT_ }; _NO_DEFLT_ } _N_ #-}
+ (==) = { _A_ 2 _U_ 11 _N_ _S_ "U(U(P)L)U(U(P)L)" {_A_ 4 _U_ 2121 _N_ _N_ _F_ _IF_ARGS_ 0 4 XCXC 7 \ (u0 :: Double#) (u1 :: Double) (u2 :: Double#) (u3 :: Double) -> case _#_ eqDouble# [] [u0, u2] of { _ALG_ True -> case u1 of { _ALG_ D# (u4 :: Double#) -> case u3 of { _ALG_ D# (u5 :: Double#) -> _#_ eqDouble# [] [u4, u5]; _NO_DEFLT_ }; _NO_DEFLT_ }; False -> _!_ False [] []; _NO_DEFLT_ } _N_} _F_ _ALWAYS_ \ (u0 :: Complex Double) (u1 :: Complex Double) -> case u0 of { _ALG_ (:+) (u2 :: Double) (u3 :: Double) -> case u2 of { _ALG_ D# (u4 :: Double#) -> case u1 of { _ALG_ (:+) (u5 :: Double) (u6 :: Double) -> case u5 of { _ALG_ D# (u7 :: Double#) -> case _#_ eqDouble# [] [u4, u7] of { _ALG_ True -> case u3 of { _ALG_ D# (u8 :: Double#) -> case u6 of { _ALG_ D# (u9 :: Double#) -> _#_ eqDouble# [] [u8, u9]; _NO_DEFLT_ }; _NO_DEFLT_ }; False -> _!_ False [] []; _NO_DEFLT_ }; _NO_DEFLT_ }; _NO_DEFLT_ }; _NO_DEFLT_ }; _NO_DEFLT_ } _N_ },
+ (/=) = { _A_ 2 _U_ 11 _N_ _S_ "U(U(P)L)U(U(P)L)" {_A_ 4 _U_ 2121 _N_ _N_ _F_ _IF_ARGS_ 0 4 XCXC 7 \ (u0 :: Double#) (u1 :: Double) (u2 :: Double#) (u3 :: Double) -> case _#_ neDouble# [] [u0, u2] of { _ALG_ True -> _!_ True [] []; False -> case u1 of { _ALG_ D# (u4 :: Double#) -> case u3 of { _ALG_ D# (u5 :: Double#) -> _#_ neDouble# [] [u4, u5]; _NO_DEFLT_ }; _NO_DEFLT_ }; _NO_DEFLT_ } _N_} _F_ _ALWAYS_ \ (u0 :: Complex Double) (u1 :: Complex Double) -> case u0 of { _ALG_ (:+) (u2 :: Double) (u3 :: Double) -> case u2 of { _ALG_ D# (u4 :: Double#) -> case u1 of { _ALG_ (:+) (u5 :: Double) (u6 :: Double) -> case u5 of { _ALG_ D# (u7 :: Double#) -> case _#_ neDouble# [] [u4, u7] of { _ALG_ True -> _!_ True [] []; False -> case u3 of { _ALG_ D# (u8 :: Double#) -> case u6 of { _ALG_ D# (u9 :: Double#) -> _#_ neDouble# [] [u8, u9]; _NO_DEFLT_ }; _NO_DEFLT_ }; _NO_DEFLT_ }; _NO_DEFLT_ }; _NO_DEFLT_ }; _NO_DEFLT_ }; _NO_DEFLT_ } _N_ } #-}
instance Eq Double
{-# GHC_PRAGMA _M_ PreludeCore {-dfun-} _A_ 0 _N_ _N_ _N_ _F_ _IF_ARGS_ 0 0 X 3 _!_ _TUP_2 [(Double -> Double -> Bool), (Double -> Double -> Bool)] [_CONSTM_ Eq (==) (Double), _CONSTM_ Eq (/=) (Double)] _N_
- (==) = _A_ 2 _U_ 11 _N_ _S_ "U(P)U(P)" {_A_ 2 _U_ 22 _N_ _N_ _F_ _IF_ARGS_ 0 2 XX 1 \ (u0 :: Double#) (u1 :: Double#) -> _#_ eqDouble# [] [u0, u1] _N_} _F_ _IF_ARGS_ 0 2 CC 3 \ (u0 :: Double) (u1 :: Double) -> case u0 of { _ALG_ D# (u2 :: Double#) -> case u1 of { _ALG_ D# (u3 :: Double#) -> _#_ eqDouble# [] [u2, u3]; _NO_DEFLT_ }; _NO_DEFLT_ } _N_,
- (/=) = _A_ 2 _U_ 11 _N_ _S_ "U(P)U(P)" {_A_ 2 _U_ 22 _N_ _N_ _F_ _IF_ARGS_ 0 2 XX 1 \ (u0 :: Double#) (u1 :: Double#) -> _#_ neDouble# [] [u0, u1] _N_} _F_ _IF_ARGS_ 0 2 CC 3 \ (u0 :: Double) (u1 :: Double) -> case u0 of { _ALG_ D# (u2 :: Double#) -> case u1 of { _ALG_ D# (u3 :: Double#) -> _#_ neDouble# [] [u2, u3]; _NO_DEFLT_ }; _NO_DEFLT_ } _N_ #-}
+ (==) = { _A_ 2 _U_ 11 _N_ _S_ "U(P)U(P)" {_A_ 2 _U_ 22 _N_ _N_ _F_ _IF_ARGS_ 0 2 XX 1 \ (u0 :: Double#) (u1 :: Double#) -> _#_ eqDouble# [] [u0, u1] _N_} _F_ _IF_ARGS_ 0 2 CC 3 \ (u0 :: Double) (u1 :: Double) -> case u0 of { _ALG_ D# (u2 :: Double#) -> case u1 of { _ALG_ D# (u3 :: Double#) -> _#_ eqDouble# [] [u2, u3]; _NO_DEFLT_ }; _NO_DEFLT_ } _N_ },
+ (/=) = { _A_ 2 _U_ 11 _N_ _S_ "U(P)U(P)" {_A_ 2 _U_ 22 _N_ _N_ _F_ _IF_ARGS_ 0 2 XX 1 \ (u0 :: Double#) (u1 :: Double#) -> _#_ neDouble# [] [u0, u1] _N_} _F_ _IF_ARGS_ 0 2 CC 3 \ (u0 :: Double) (u1 :: Double) -> case u0 of { _ALG_ D# (u2 :: Double#) -> case u1 of { _ALG_ D# (u3 :: Double#) -> _#_ neDouble# [] [u2, u3]; _NO_DEFLT_ }; _NO_DEFLT_ } _N_ } #-}
instance (Eq a, Eq b) => Eq (Either a b)
{-# GHC_PRAGMA _M_ PreludeMonadicIO {-dfun-} _A_ 2 _U_ 11 _N_ _N_ _N_ _N_ #-}
instance Eq Float
{-# GHC_PRAGMA _M_ PreludeCore {-dfun-} _A_ 0 _N_ _N_ _N_ _F_ _IF_ARGS_ 0 0 X 3 _!_ _TUP_2 [(Float -> Float -> Bool), (Float -> Float -> Bool)] [_CONSTM_ Eq (==) (Float), _CONSTM_ Eq (/=) (Float)] _N_
- (==) = _A_ 2 _U_ 11 _N_ _S_ "U(P)U(P)" {_A_ 2 _U_ 22 _N_ _N_ _F_ _IF_ARGS_ 0 2 XX 1 \ (u0 :: Float#) (u1 :: Float#) -> _#_ eqFloat# [] [u0, u1] _N_} _F_ _IF_ARGS_ 0 2 CC 3 \ (u0 :: Float) (u1 :: Float) -> case u0 of { _ALG_ F# (u2 :: Float#) -> case u1 of { _ALG_ F# (u3 :: Float#) -> _#_ eqFloat# [] [u2, u3]; _NO_DEFLT_ }; _NO_DEFLT_ } _N_,
- (/=) = _A_ 2 _U_ 11 _N_ _S_ "U(P)U(P)" {_A_ 2 _U_ 22 _N_ _N_ _F_ _IF_ARGS_ 0 2 XX 1 \ (u0 :: Float#) (u1 :: Float#) -> _#_ neFloat# [] [u0, u1] _N_} _F_ _IF_ARGS_ 0 2 CC 3 \ (u0 :: Float) (u1 :: Float) -> case u0 of { _ALG_ F# (u2 :: Float#) -> case u1 of { _ALG_ F# (u3 :: Float#) -> _#_ neFloat# [] [u2, u3]; _NO_DEFLT_ }; _NO_DEFLT_ } _N_ #-}
+ (==) = { _A_ 2 _U_ 11 _N_ _S_ "U(P)U(P)" {_A_ 2 _U_ 22 _N_ _N_ _F_ _IF_ARGS_ 0 2 XX 1 \ (u0 :: Float#) (u1 :: Float#) -> _#_ eqFloat# [] [u0, u1] _N_} _F_ _IF_ARGS_ 0 2 CC 3 \ (u0 :: Float) (u1 :: Float) -> case u0 of { _ALG_ F# (u2 :: Float#) -> case u1 of { _ALG_ F# (u3 :: Float#) -> _#_ eqFloat# [] [u2, u3]; _NO_DEFLT_ }; _NO_DEFLT_ } _N_ },
+ (/=) = { _A_ 2 _U_ 11 _N_ _S_ "U(P)U(P)" {_A_ 2 _U_ 22 _N_ _N_ _F_ _IF_ARGS_ 0 2 XX 1 \ (u0 :: Float#) (u1 :: Float#) -> _#_ neFloat# [] [u0, u1] _N_} _F_ _IF_ARGS_ 0 2 CC 3 \ (u0 :: Float) (u1 :: Float) -> case u0 of { _ALG_ F# (u2 :: Float#) -> case u1 of { _ALG_ F# (u3 :: Float#) -> _#_ neFloat# [] [u2, u3]; _NO_DEFLT_ }; _NO_DEFLT_ } _N_ } #-}
instance Eq Int
{-# GHC_PRAGMA _M_ PreludeCore {-dfun-} _A_ 0 _N_ _N_ _N_ _F_ _IF_ARGS_ 0 0 X 3 _!_ _TUP_2 [(Int -> Int -> Bool), (Int -> Int -> Bool)] [_CONSTM_ Eq (==) (Int), _CONSTM_ Eq (/=) (Int)] _N_
- (==) = _A_ 2 _U_ 11 _N_ _S_ "U(P)U(P)" {_A_ 2 _U_ 22 _N_ _N_ _F_ _IF_ARGS_ 0 2 XX 1 \ (u0 :: Int#) (u1 :: Int#) -> _#_ eqInt# [] [u0, u1] _N_} _F_ _IF_ARGS_ 0 2 CC 3 \ (u0 :: Int) (u1 :: Int) -> case u0 of { _ALG_ I# (u2 :: Int#) -> case u1 of { _ALG_ I# (u3 :: Int#) -> _#_ eqInt# [] [u2, u3]; _NO_DEFLT_ }; _NO_DEFLT_ } _N_,
- (/=) = _A_ 2 _U_ 11 _N_ _S_ "U(P)U(P)" {_A_ 2 _U_ 22 _N_ _N_ _F_ _IF_ARGS_ 0 2 XX 1 \ (u0 :: Int#) (u1 :: Int#) -> _#_ neInt# [] [u0, u1] _N_} _F_ _IF_ARGS_ 0 2 CC 3 \ (u0 :: Int) (u1 :: Int) -> case u0 of { _ALG_ I# (u2 :: Int#) -> case u1 of { _ALG_ I# (u3 :: Int#) -> _#_ neInt# [] [u2, u3]; _NO_DEFLT_ }; _NO_DEFLT_ } _N_ #-}
+ (==) = { _A_ 2 _U_ 11 _N_ _S_ "U(P)U(P)" {_A_ 2 _U_ 22 _N_ _N_ _F_ _IF_ARGS_ 0 2 XX 1 \ (u0 :: Int#) (u1 :: Int#) -> _#_ eqInt# [] [u0, u1] _N_} _F_ _IF_ARGS_ 0 2 CC 3 \ (u0 :: Int) (u1 :: Int) -> case u0 of { _ALG_ I# (u2 :: Int#) -> case u1 of { _ALG_ I# (u3 :: Int#) -> _#_ eqInt# [] [u2, u3]; _NO_DEFLT_ }; _NO_DEFLT_ } _N_ },
+ (/=) = { _A_ 2 _U_ 11 _N_ _S_ "U(P)U(P)" {_A_ 2 _U_ 22 _N_ _N_ _F_ _IF_ARGS_ 0 2 XX 1 \ (u0 :: Int#) (u1 :: Int#) -> _#_ neInt# [] [u0, u1] _N_} _F_ _IF_ARGS_ 0 2 CC 3 \ (u0 :: Int) (u1 :: Int) -> case u0 of { _ALG_ I# (u2 :: Int#) -> case u1 of { _ALG_ I# (u3 :: Int#) -> _#_ neInt# [] [u2, u3]; _NO_DEFLT_ }; _NO_DEFLT_ } _N_ } #-}
instance Eq Integer
{-# GHC_PRAGMA _M_ PreludeCore {-dfun-} _A_ 0 _N_ _N_ _N_ _F_ _IF_ARGS_ 0 0 X 3 _!_ _TUP_2 [(Integer -> Integer -> Bool), (Integer -> Integer -> Bool)] [_CONSTM_ Eq (==) (Integer), _CONSTM_ Eq (/=) (Integer)] _N_
- (==) = _A_ 2 _U_ 11 _N_ _S_ "U(PPP)U(PPP)" {_A_ 4 _U_ 2221 _N_ _N_ _F_ _IF_ARGS_ 0 4 XXXC 4 \ (u0 :: Int#) (u1 :: Int#) (u2 :: ByteArray#) (u3 :: Integer) -> case u3 of { _ALG_ J# (u4 :: Int#) (u5 :: Int#) (u6 :: ByteArray#) -> case _#_ cmpInteger# [] [u0, u1, u2, u4, u5, u6] of { _PRIM_ 0# -> _!_ True [] []; (u7 :: Int#) -> _!_ False [] [] }; _NO_DEFLT_ } _N_} _F_ _IF_ARGS_ 0 2 CC 5 \ (u0 :: Integer) (u1 :: Integer) -> case u0 of { _ALG_ J# (u2 :: Int#) (u3 :: Int#) (u4 :: ByteArray#) -> case u1 of { _ALG_ J# (u5 :: Int#) (u6 :: Int#) (u7 :: ByteArray#) -> case _#_ cmpInteger# [] [u2, u3, u4, u5, u6, u7] of { _PRIM_ 0# -> _!_ True [] []; (u8 :: Int#) -> _!_ False [] [] }; _NO_DEFLT_ }; _NO_DEFLT_ } _N_,
- (/=) = _A_ 2 _U_ 11 _N_ _S_ "U(PPP)U(PPP)" {_A_ 4 _U_ 2221 _N_ _N_ _F_ _IF_ARGS_ 0 4 XXXC 4 \ (u0 :: Int#) (u1 :: Int#) (u2 :: ByteArray#) (u3 :: Integer) -> case u3 of { _ALG_ J# (u4 :: Int#) (u5 :: Int#) (u6 :: ByteArray#) -> case _#_ cmpInteger# [] [u0, u1, u2, u4, u5, u6] of { _PRIM_ 0# -> _!_ False [] []; (u7 :: Int#) -> _!_ True [] [] }; _NO_DEFLT_ } _N_} _F_ _IF_ARGS_ 0 2 CC 5 \ (u0 :: Integer) (u1 :: Integer) -> case u0 of { _ALG_ J# (u2 :: Int#) (u3 :: Int#) (u4 :: ByteArray#) -> case u1 of { _ALG_ J# (u5 :: Int#) (u6 :: Int#) (u7 :: ByteArray#) -> case _#_ cmpInteger# [] [u2, u3, u4, u5, u6, u7] of { _PRIM_ 0# -> _!_ False [] []; (u8 :: Int#) -> _!_ True [] [] }; _NO_DEFLT_ }; _NO_DEFLT_ } _N_ #-}
+ (==) = { _A_ 2 _U_ 11 _N_ _S_ "U(PPP)U(PPP)" {_A_ 4 _U_ 2221 _N_ _N_ _F_ _IF_ARGS_ 0 4 XXXC 4 \ (u0 :: Int#) (u1 :: Int#) (u2 :: ByteArray#) (u3 :: Integer) -> case u3 of { _ALG_ J# (u4 :: Int#) (u5 :: Int#) (u6 :: ByteArray#) -> case _#_ cmpInteger# [] [u0, u1, u2, u4, u5, u6] of { _PRIM_ 0# -> _!_ True [] []; (u7 :: Int#) -> _!_ False [] [] }; _NO_DEFLT_ } _N_} _F_ _IF_ARGS_ 0 2 CC 5 \ (u0 :: Integer) (u1 :: Integer) -> case u0 of { _ALG_ J# (u2 :: Int#) (u3 :: Int#) (u4 :: ByteArray#) -> case u1 of { _ALG_ J# (u5 :: Int#) (u6 :: Int#) (u7 :: ByteArray#) -> case _#_ cmpInteger# [] [u2, u3, u4, u5, u6, u7] of { _PRIM_ 0# -> _!_ True [] []; (u8 :: Int#) -> _!_ False [] [] }; _NO_DEFLT_ }; _NO_DEFLT_ } _N_ },
+ (/=) = { _A_ 2 _U_ 11 _N_ _S_ "U(PPP)U(PPP)" {_A_ 4 _U_ 2221 _N_ _N_ _F_ _IF_ARGS_ 0 4 XXXC 4 \ (u0 :: Int#) (u1 :: Int#) (u2 :: ByteArray#) (u3 :: Integer) -> case u3 of { _ALG_ J# (u4 :: Int#) (u5 :: Int#) (u6 :: ByteArray#) -> case _#_ cmpInteger# [] [u0, u1, u2, u4, u5, u6] of { _PRIM_ 0# -> _!_ False [] []; (u7 :: Int#) -> _!_ True [] [] }; _NO_DEFLT_ } _N_} _F_ _IF_ARGS_ 0 2 CC 5 \ (u0 :: Integer) (u1 :: Integer) -> case u0 of { _ALG_ J# (u2 :: Int#) (u3 :: Int#) (u4 :: ByteArray#) -> case u1 of { _ALG_ J# (u5 :: Int#) (u6 :: Int#) (u7 :: ByteArray#) -> case _#_ cmpInteger# [] [u2, u3, u4, u5, u6, u7] of { _PRIM_ 0# -> _!_ False [] []; (u8 :: Int#) -> _!_ True [] [] }; _NO_DEFLT_ }; _NO_DEFLT_ } _N_ } #-}
instance Eq a => Eq (Maybe a)
{-# GHC_PRAGMA _M_ PreludeStdIO {-dfun-} _A_ 1 _U_ 1 _N_ _N_ _N_ _N_ #-}
instance Integral a => Eq (Ratio a)
{-# GHC_PRAGMA _M_ PreludeRatio {-dfun-} _A_ 1 _U_ 1 _N_ _N_ _N_ _N_ #-}
instance Eq (Ratio Integer)
{-# GHC_PRAGMA _M_ PreludeRatio {-dfun-} _A_ 0 _N_ _N_ _N_ _F_ _IF_ARGS_ 0 0 X 3 _!_ _TUP_2 [(Ratio Integer -> Ratio Integer -> Bool), (Ratio Integer -> Ratio Integer -> Bool)] [_CONSTM_ Eq (==) (Ratio Integer), _CONSTM_ Eq (/=) (Ratio Integer)] _N_
- (==) = _A_ 2 _U_ 11 _N_ _S_ "U(U(PPP)L)U(U(PPP)L)" {_A_ 5 _U_ 22211 _N_ _N_ _F_ _IF_ARGS_ 0 5 XXXCC 9 \ (u0 :: Int#) (u1 :: Int#) (u2 :: ByteArray#) (u3 :: Integer) (u4 :: Ratio Integer) -> case u4 of { _ALG_ (:%) (u5 :: Integer) (u6 :: Integer) -> case u5 of { _ALG_ J# (u7 :: Int#) (u8 :: Int#) (u9 :: ByteArray#) -> case _#_ cmpInteger# [] [u0, u1, u2, u7, u8, u9] of { _PRIM_ 0# -> case u3 of { _ALG_ J# (ua :: Int#) (ub :: Int#) (uc :: ByteArray#) -> case u6 of { _ALG_ J# (ud :: Int#) (ue :: Int#) (uf :: ByteArray#) -> case _#_ cmpInteger# [] [ua, ub, uc, ud, ue, uf] of { _PRIM_ 0# -> _!_ True [] []; (ug :: Int#) -> _!_ False [] [] }; _NO_DEFLT_ }; _NO_DEFLT_ }; (uh :: Int#) -> _!_ False [] [] }; _NO_DEFLT_ }; _NO_DEFLT_ } _N_} _N_ _N_,
- (/=) = _A_ 2 _U_ 11 _N_ _S_ "U(U(PPP)L)U(U(PPP)L)" {_A_ 5 _U_ 22211 _N_ _N_ _F_ _IF_ARGS_ 0 5 XXXCC 9 \ (u0 :: Int#) (u1 :: Int#) (u2 :: ByteArray#) (u3 :: Integer) (u4 :: Ratio Integer) -> case u4 of { _ALG_ (:%) (u5 :: Integer) (u6 :: Integer) -> case u5 of { _ALG_ J# (u7 :: Int#) (u8 :: Int#) (u9 :: ByteArray#) -> case _#_ cmpInteger# [] [u0, u1, u2, u7, u8, u9] of { _PRIM_ 0# -> case u3 of { _ALG_ J# (ua :: Int#) (ub :: Int#) (uc :: ByteArray#) -> case u6 of { _ALG_ J# (ud :: Int#) (ue :: Int#) (uf :: ByteArray#) -> case _#_ cmpInteger# [] [ua, ub, uc, ud, ue, uf] of { _PRIM_ 0# -> _!_ False [] []; (ug :: Int#) -> _!_ True [] [] }; _NO_DEFLT_ }; _NO_DEFLT_ }; (uh :: Int#) -> _!_ True [] [] }; _NO_DEFLT_ }; _NO_DEFLT_ } _N_} _N_ _N_ #-}
+ (==) = { _A_ 2 _U_ 11 _N_ _S_ "U(U(PPP)L)U(U(PPP)L)" {_A_ 5 _U_ 22211 _N_ _N_ _F_ _IF_ARGS_ 0 5 XXXCC 9 \ (u0 :: Int#) (u1 :: Int#) (u2 :: ByteArray#) (u3 :: Integer) (u4 :: Ratio Integer) -> case u4 of { _ALG_ (:%) (u5 :: Integer) (u6 :: Integer) -> case u5 of { _ALG_ J# (u7 :: Int#) (u8 :: Int#) (u9 :: ByteArray#) -> case _#_ cmpInteger# [] [u0, u1, u2, u7, u8, u9] of { _PRIM_ 0# -> case u3 of { _ALG_ J# (ua :: Int#) (ub :: Int#) (uc :: ByteArray#) -> case u6 of { _ALG_ J# (ud :: Int#) (ue :: Int#) (uf :: ByteArray#) -> case _#_ cmpInteger# [] [ua, ub, uc, ud, ue, uf] of { _PRIM_ 0# -> _!_ True [] []; (ug :: Int#) -> _!_ False [] [] }; _NO_DEFLT_ }; _NO_DEFLT_ }; (uh :: Int#) -> _!_ False [] [] }; _NO_DEFLT_ }; _NO_DEFLT_ } _N_} _N_ _N_ },
+ (/=) = { _A_ 2 _U_ 11 _N_ _S_ "U(U(PPP)L)U(U(PPP)L)" {_A_ 5 _U_ 22211 _N_ _N_ _F_ _IF_ARGS_ 0 5 XXXCC 9 \ (u0 :: Int#) (u1 :: Int#) (u2 :: ByteArray#) (u3 :: Integer) (u4 :: Ratio Integer) -> case u4 of { _ALG_ (:%) (u5 :: Integer) (u6 :: Integer) -> case u5 of { _ALG_ J# (u7 :: Int#) (u8 :: Int#) (u9 :: ByteArray#) -> case _#_ cmpInteger# [] [u0, u1, u2, u7, u8, u9] of { _PRIM_ 0# -> case u3 of { _ALG_ J# (ua :: Int#) (ub :: Int#) (uc :: ByteArray#) -> case u6 of { _ALG_ J# (ud :: Int#) (ue :: Int#) (uf :: ByteArray#) -> case _#_ cmpInteger# [] [ua, ub, uc, ud, ue, uf] of { _PRIM_ 0# -> _!_ False [] []; (ug :: Int#) -> _!_ True [] [] }; _NO_DEFLT_ }; _NO_DEFLT_ }; (uh :: Int#) -> _!_ True [] [] }; _NO_DEFLT_ }; _NO_DEFLT_ } _N_} _N_ _N_ } #-}
+instance Eq [(Int, Int)]
+ {-# GHC_PRAGMA _M_ PreludeBuiltin {-dfun-} _A_ 0 _N_ _N_ _N_ _F_ _IF_ARGS_ 0 0 X 3 _!_ _TUP_2 [([(Int, Int)] -> [(Int, Int)] -> Bool), ([(Int, Int)] -> [(Int, Int)] -> Bool)] [_CONSTM_ Eq (==) ([(Int, Int)]), _CONSTM_ Eq (/=) ([(Int, Int)])] _N_
+ (==) = { _A_ 2 _U_ 11 _N_ _S_ "SS" _N_ _N_ },
+ (/=) = { _A_ 2 _U_ 11 _N_ _S_ "SS" _N_ _N_ } #-}
instance Eq a => Eq [a]
{-# GHC_PRAGMA _M_ PreludeBuiltin {-dfun-} _A_ 1 _U_ 1 _N_ _N_ _N_ _N_ #-}
+instance Eq [Bool]
+ {-# GHC_PRAGMA _M_ PreludeBuiltin {-dfun-} _A_ 0 _N_ _N_ _N_ _F_ _IF_ARGS_ 0 0 X 3 _!_ _TUP_2 [([Bool] -> [Bool] -> Bool), ([Bool] -> [Bool] -> Bool)] [_CONSTM_ Eq (==) ([Bool]), _CONSTM_ Eq (/=) ([Bool])] _N_
+ (==) = { _A_ 2 _U_ 11 _N_ _S_ "SS" _N_ _N_ },
+ (/=) = { _A_ 2 _U_ 11 _N_ _S_ "SS" _N_ _N_ } #-}
instance Eq [Char]
{-# GHC_PRAGMA _M_ PreludeBuiltin {-dfun-} _A_ 0 _N_ _N_ _N_ _F_ _IF_ARGS_ 0 0 X 3 _!_ _TUP_2 [([Char] -> [Char] -> Bool), ([Char] -> [Char] -> Bool)] [_CONSTM_ Eq (==) ([Char]), _CONSTM_ Eq (/=) ([Char])] _N_
- (==) = _A_ 2 _U_ 11 _N_ _S_ "SS" _N_ _N_,
- (/=) = _A_ 2 _U_ 11 _N_ _S_ "SS" _N_ _N_ #-}
+ (==) = { _A_ 2 _U_ 11 _N_ _S_ "SS" _N_ _N_ },
+ (/=) = { _A_ 2 _U_ 11 _N_ _S_ "SS" _N_ _N_ } #-}
+instance Eq [Complex Double]
+ {-# GHC_PRAGMA _M_ PreludeBuiltin {-dfun-} _A_ 0 _N_ _N_ _N_ _F_ _IF_ARGS_ 0 0 X 3 _!_ _TUP_2 [([Complex Double] -> [Complex Double] -> Bool), ([Complex Double] -> [Complex Double] -> Bool)] [_CONSTM_ Eq (==) ([Complex Double]), _CONSTM_ Eq (/=) ([Complex Double])] _N_
+ (==) = { _A_ 2 _U_ 11 _N_ _S_ "SS" _N_ _N_ },
+ (/=) = { _A_ 2 _U_ 11 _N_ _S_ "SS" _N_ _N_ } #-}
+instance Eq [Double]
+ {-# GHC_PRAGMA _M_ PreludeBuiltin {-dfun-} _A_ 0 _N_ _N_ _N_ _F_ _IF_ARGS_ 0 0 X 3 _!_ _TUP_2 [([Double] -> [Double] -> Bool), ([Double] -> [Double] -> Bool)] [_CONSTM_ Eq (==) ([Double]), _CONSTM_ Eq (/=) ([Double])] _N_
+ (==) = { _A_ 2 _U_ 11 _N_ _S_ "SS" _N_ _N_ },
+ (/=) = { _A_ 2 _U_ 11 _N_ _S_ "SS" _N_ _N_ } #-}
instance Eq [Int]
{-# GHC_PRAGMA _M_ PreludeBuiltin {-dfun-} _A_ 0 _N_ _N_ _N_ _F_ _IF_ARGS_ 0 0 X 3 _!_ _TUP_2 [([Int] -> [Int] -> Bool), ([Int] -> [Int] -> Bool)] [_CONSTM_ Eq (==) ([Int]), _CONSTM_ Eq (/=) ([Int])] _N_
- (==) = _A_ 2 _U_ 11 _N_ _S_ "SS" _N_ _N_,
- (/=) = _A_ 2 _U_ 11 _N_ _S_ "SS" _N_ _N_ #-}
+ (==) = { _A_ 2 _U_ 11 _N_ _S_ "SS" _N_ _N_ },
+ (/=) = { _A_ 2 _U_ 11 _N_ _S_ "SS" _N_ _N_ } #-}
+instance Eq [Integer]
+ {-# GHC_PRAGMA _M_ PreludeBuiltin {-dfun-} _A_ 0 _N_ _N_ _N_ _F_ _IF_ARGS_ 0 0 X 3 _!_ _TUP_2 [([Integer] -> [Integer] -> Bool), ([Integer] -> [Integer] -> Bool)] [_CONSTM_ Eq (==) ([Integer]), _CONSTM_ Eq (/=) ([Integer])] _N_
+ (==) = { _A_ 2 _U_ 11 _N_ _S_ "SS" _N_ _N_ },
+ (/=) = { _A_ 2 _U_ 11 _N_ _S_ "SS" _N_ _N_ } #-}
+instance Eq [[Char]]
+ {-# GHC_PRAGMA _M_ PreludeBuiltin {-dfun-} _A_ 0 _N_ _N_ _N_ _F_ _IF_ARGS_ 0 0 X 3 _!_ _TUP_2 [([[Char]] -> [[Char]] -> Bool), ([[Char]] -> [[Char]] -> Bool)] [_CONSTM_ Eq (==) ([[Char]]), _CONSTM_ Eq (/=) ([[Char]])] _N_
+ (==) = { _A_ 2 _U_ 11 _N_ _S_ "SS" _N_ _N_ },
+ (/=) = { _A_ 2 _U_ 11 _N_ _S_ "SS" _N_ _N_ } #-}
+instance Eq [[Int]]
+ {-# GHC_PRAGMA _M_ PreludeBuiltin {-dfun-} _A_ 0 _N_ _N_ _N_ _F_ _IF_ARGS_ 0 0 X 3 _!_ _TUP_2 [([[Int]] -> [[Int]] -> Bool), ([[Int]] -> [[Int]] -> Bool)] [_CONSTM_ Eq (==) ([[Int]]), _CONSTM_ Eq (/=) ([[Int]])] _N_
+ (==) = { _A_ 2 _U_ 11 _N_ _S_ "SS" _N_ _N_ },
+ (/=) = { _A_ 2 _U_ 11 _N_ _S_ "SS" _N_ _N_ } #-}
instance Eq _Addr
{-# GHC_PRAGMA _M_ PreludeCore {-dfun-} _A_ 0 _N_ _N_ _N_ _F_ _IF_ARGS_ 0 0 X 3 _!_ _TUP_2 [(_Addr -> _Addr -> Bool), (_Addr -> _Addr -> Bool)] [_CONSTM_ Eq (==) (_Addr), _CONSTM_ Eq (/=) (_Addr)] _N_
- (==) = _A_ 2 _U_ 11 _N_ _S_ "U(P)U(P)" {_A_ 2 _U_ 22 _N_ _N_ _F_ _IF_ARGS_ 0 2 XX 1 \ (u0 :: Addr#) (u1 :: Addr#) -> _#_ eqAddr# [] [u0, u1] _N_} _F_ _IF_ARGS_ 0 2 CC 3 \ (u0 :: _Addr) (u1 :: _Addr) -> case u0 of { _ALG_ A# (u2 :: Addr#) -> case u1 of { _ALG_ A# (u3 :: Addr#) -> _#_ eqAddr# [] [u2, u3]; _NO_DEFLT_ }; _NO_DEFLT_ } _N_,
- (/=) = _A_ 2 _U_ 11 _N_ _S_ "U(P)U(P)" {_A_ 2 _U_ 22 _N_ _N_ _F_ _IF_ARGS_ 0 2 XX 1 \ (u0 :: Addr#) (u1 :: Addr#) -> _#_ neAddr# [] [u0, u1] _N_} _F_ _IF_ARGS_ 0 2 CC 3 \ (u0 :: _Addr) (u1 :: _Addr) -> case u0 of { _ALG_ A# (u2 :: Addr#) -> case u1 of { _ALG_ A# (u3 :: Addr#) -> _#_ neAddr# [] [u2, u3]; _NO_DEFLT_ }; _NO_DEFLT_ } _N_ #-}
+ (==) = { _A_ 2 _U_ 11 _N_ _S_ "U(P)U(P)" {_A_ 2 _U_ 22 _N_ _N_ _F_ _IF_ARGS_ 0 2 XX 1 \ (u0 :: Addr#) (u1 :: Addr#) -> _#_ eqAddr# [] [u0, u1] _N_} _F_ _IF_ARGS_ 0 2 CC 3 \ (u0 :: _Addr) (u1 :: _Addr) -> case u0 of { _ALG_ A# (u2 :: Addr#) -> case u1 of { _ALG_ A# (u3 :: Addr#) -> _#_ eqAddr# [] [u2, u3]; _NO_DEFLT_ }; _NO_DEFLT_ } _N_ },
+ (/=) = { _A_ 2 _U_ 11 _N_ _S_ "U(P)U(P)" {_A_ 2 _U_ 22 _N_ _N_ _F_ _IF_ARGS_ 0 2 XX 1 \ (u0 :: Addr#) (u1 :: Addr#) -> _#_ neAddr# [] [u0, u1] _N_} _F_ _IF_ARGS_ 0 2 CC 3 \ (u0 :: _Addr) (u1 :: _Addr) -> case u0 of { _ALG_ A# (u2 :: Addr#) -> case u1 of { _ALG_ A# (u3 :: Addr#) -> _#_ neAddr# [] [u2, u3]; _NO_DEFLT_ }; _NO_DEFLT_ } _N_ } #-}
instance Eq _PackedString
{-# GHC_PRAGMA _M_ PreludePS {-dfun-} _A_ 0 _N_ _N_ _N_ _F_ _IF_ARGS_ 0 0 X 3 _!_ _TUP_2 [(_PackedString -> _PackedString -> Bool), (_PackedString -> _PackedString -> Bool)] [_CONSTM_ Eq (==) (_PackedString), _CONSTM_ Eq (/=) (_PackedString)] _N_
- (==) = _A_ 2 _U_ 22 _N_ _S_ "SS" _N_ _N_,
- (/=) = _A_ 2 _U_ 22 _N_ _S_ "SS" _N_ _N_ #-}
+ (==) = { _A_ 2 _U_ 22 _N_ _S_ "SS" _N_ _N_ },
+ (/=) = { _A_ 2 _U_ 22 _N_ _S_ "SS" _N_ _N_ } #-}
instance Eq _Word
{-# GHC_PRAGMA _M_ PreludeCore {-dfun-} _A_ 0 _N_ _N_ _N_ _F_ _IF_ARGS_ 0 0 X 3 _!_ _TUP_2 [(_Word -> _Word -> Bool), (_Word -> _Word -> Bool)] [_CONSTM_ Eq (==) (_Word), _CONSTM_ Eq (/=) (_Word)] _N_
- (==) = _A_ 2 _U_ 11 _N_ _S_ "U(P)U(P)" {_A_ 2 _U_ 22 _N_ _N_ _F_ _IF_ARGS_ 0 2 XX 1 \ (u0 :: Word#) (u1 :: Word#) -> _#_ eqWord# [] [u0, u1] _N_} _F_ _IF_ARGS_ 0 2 CC 3 \ (u0 :: _Word) (u1 :: _Word) -> case u0 of { _ALG_ W# (u2 :: Word#) -> case u1 of { _ALG_ W# (u3 :: Word#) -> _#_ eqWord# [] [u2, u3]; _NO_DEFLT_ }; _NO_DEFLT_ } _N_,
- (/=) = _A_ 2 _U_ 11 _N_ _S_ "U(P)U(P)" {_A_ 2 _U_ 22 _N_ _N_ _F_ _IF_ARGS_ 0 2 XX 1 \ (u0 :: Word#) (u1 :: Word#) -> _#_ neWord# [] [u0, u1] _N_} _F_ _IF_ARGS_ 0 2 CC 3 \ (u0 :: _Word) (u1 :: _Word) -> case u0 of { _ALG_ W# (u2 :: Word#) -> case u1 of { _ALG_ W# (u3 :: Word#) -> _#_ neWord# [] [u2, u3]; _NO_DEFLT_ }; _NO_DEFLT_ } _N_ #-}
+ (==) = { _A_ 2 _U_ 11 _N_ _S_ "U(P)U(P)" {_A_ 2 _U_ 22 _N_ _N_ _F_ _IF_ARGS_ 0 2 XX 1 \ (u0 :: Word#) (u1 :: Word#) -> _#_ eqWord# [] [u0, u1] _N_} _F_ _IF_ARGS_ 0 2 CC 3 \ (u0 :: _Word) (u1 :: _Word) -> case u0 of { _ALG_ W# (u2 :: Word#) -> case u1 of { _ALG_ W# (u3 :: Word#) -> _#_ eqWord# [] [u2, u3]; _NO_DEFLT_ }; _NO_DEFLT_ } _N_ },
+ (/=) = { _A_ 2 _U_ 11 _N_ _S_ "U(P)U(P)" {_A_ 2 _U_ 22 _N_ _N_ _F_ _IF_ARGS_ 0 2 XX 1 \ (u0 :: Word#) (u1 :: Word#) -> _#_ neWord# [] [u0, u1] _N_} _F_ _IF_ARGS_ 0 2 CC 3 \ (u0 :: _Word) (u1 :: _Word) -> case u0 of { _ALG_ W# (u2 :: Word#) -> case u1 of { _ALG_ W# (u3 :: Word#) -> _#_ neWord# [] [u2, u3]; _NO_DEFLT_ }; _NO_DEFLT_ } _N_ } #-}
instance RealFloat a => Floating (Complex a)
{-# GHC_PRAGMA _M_ PreludeComplex {-dfun-} _A_ 2 _U_ 22 _N_ _N_ _N_ _N_ #-}
instance Floating (Complex Double)
{-# GHC_PRAGMA _M_ PreludeComplex {-dfun-} _A_ 0 _N_ _N_ _N_ _F_ _IF_ARGS_ 0 0 X 20 _!_ _TUP_19 [{{Fractional (Complex Double)}}, (Complex Double), (Complex Double -> Complex Double), (Complex Double -> Complex Double), (Complex Double -> Complex Double), (Complex Double -> Complex Double -> Complex Double), (Complex Double -> Complex Double -> Complex Double), (Complex Double -> Complex Double), (Complex Double -> Complex Double), (Complex Double -> Complex Double), (Complex Double -> Complex Double), (Complex Double -> Complex Double), (Complex Double -> Complex Double), (Complex Double -> Complex Double), (Complex Double -> Complex Double), (Complex Double -> Complex Double), (Complex Double -> Complex Double), (Complex Double -> Complex Double), (Complex Double -> Complex Double)] [_DFUN_ Fractional (Complex Double), _CONSTM_ Floating pi (Complex Double), _CONSTM_ Floating exp (Complex Double), _CONSTM_ Floating log (Complex Double), _CONSTM_ Floating sqrt (Complex Double), _CONSTM_ Floating (**) (Complex Double), _CONSTM_ Floating logBase (Complex Double), _CONSTM_ Floating sin (Complex Double), _CONSTM_ Floating cos (Complex Double), _CONSTM_ Floating tan (Complex Double), _CONSTM_ Floating asin (Complex Double), _CONSTM_ Floating acos (Complex Double), _CONSTM_ Floating atan (Complex Double), _CONSTM_ Floating sinh (Complex Double), _CONSTM_ Floating cosh (Complex Double), _CONSTM_ Floating tanh (Complex Double), _CONSTM_ Floating asinh (Complex Double), _CONSTM_ Floating acosh (Complex Double), _CONSTM_ Floating atanh (Complex Double)] _N_
- pi = _A_ 0 _N_ _N_ _N_ _N_ _N_,
- exp = _A_ 1 _U_ 1 _N_ _S_ "U(LL)" {_A_ 2 _U_ 12 _N_ _N_ _N_ _N_} _N_ _N_,
- log = _A_ 1 _U_ 2 _N_ _N_ _N_ _N_,
- sqrt = _A_ 1 _U_ 1 _N_ _S_ "U(U(P)L)" {_A_ 2 _U_ 22 _N_ _N_ _N_ _N_} _N_ _N_,
- (**) = _A_ 2 _U_ 21 _N_ _S_ "LU(LL)" {_A_ 3 _U_ 222 _N_ _N_ _N_ _N_} _N_ _N_,
- logBase = _A_ 2 _U_ 22 _N_ _N_ _N_ _N_,
- sin = _A_ 1 _U_ 1 _N_ _S_ "U(LL)" {_A_ 2 _U_ 22 _N_ _N_ _N_ _N_} _N_ _N_,
- cos = _A_ 1 _U_ 1 _N_ _S_ "U(LL)" {_A_ 2 _U_ 22 _N_ _N_ _N_ _N_} _N_ _N_,
- tan = _A_ 1 _U_ 1 _N_ _S_ "U(LL)" {_A_ 2 _U_ 22 _N_ _N_ _N_ _N_} _N_ _N_,
- asin = _A_ 1 _U_ 1 _N_ _S_ "U(LL)" {_A_ 2 _U_ 22 _N_ _N_ _N_ _N_} _N_ _N_,
- acos = _A_ 1 _U_ 1 _N_ _S_ "U(LL)" {_A_ 2 _U_ 22 _N_ _N_ _N_ _N_} _N_ _N_,
- atan = _A_ 1 _U_ 1 _N_ _S_ "U(LL)" {_A_ 2 _U_ 22 _N_ _N_ _N_ _N_} _N_ _N_,
- sinh = _A_ 1 _U_ 1 _N_ _S_ "U(LL)" {_A_ 2 _U_ 22 _N_ _N_ _N_ _N_} _N_ _N_,
- cosh = _A_ 1 _U_ 1 _N_ _S_ "U(LL)" {_A_ 2 _U_ 22 _N_ _N_ _N_ _N_} _N_ _N_,
- tanh = _A_ 1 _U_ 1 _N_ _S_ "U(LL)" {_A_ 2 _U_ 22 _N_ _N_ _N_ _N_} _N_ _N_,
- asinh = _A_ 1 _U_ 1 _N_ _N_ _N_ _N_,
- acosh = _A_ 1 _U_ 1 _N_ _N_ _N_ _N_,
- atanh = _A_ 1 _U_ 1 _N_ _N_ _N_ _N_ #-}
+ pi = { _A_ 0 _N_ _N_ _N_ _F_ _IF_ARGS_ 0 0 X 3 _!_ (:+) [Double] [_CONSTM_ Floating pi (Double), _SPEC_ _ORIG_ PreludeCore __i0 [ (Double) ]] _N_ },
+ exp = { _A_ 1 _U_ 1 _N_ _S_ "U(LL)" {_A_ 2 _U_ 12 _N_ _N_ _N_ _N_} _N_ _N_ },
+ log = { _A_ 1 _U_ 2 _N_ _N_ _N_ _N_ },
+ sqrt = { _A_ 1 _U_ 1 _N_ _S_ "U(U(P)L)" {_A_ 2 _U_ 22 _N_ _N_ _N_ _N_} _N_ _N_ },
+ (**) = { _A_ 2 _U_ 21 _N_ _S_ "LU(LL)" {_A_ 3 _U_ 222 _N_ _N_ _N_ _N_} _N_ _N_ },
+ logBase = { _A_ 2 _U_ 22 _N_ _N_ _N_ _N_ },
+ sin = { _A_ 1 _U_ 1 _N_ _S_ "U(LL)" {_A_ 2 _U_ 22 _N_ _N_ _N_ _N_} _N_ _N_ },
+ cos = { _A_ 1 _U_ 1 _N_ _S_ "U(LL)" {_A_ 2 _U_ 22 _N_ _N_ _N_ _N_} _N_ _N_ },
+ tan = { _A_ 1 _U_ 1 _N_ _S_ "U(LL)" {_A_ 2 _U_ 22 _N_ _N_ _N_ _N_} _N_ _N_ },
+ asin = { _A_ 1 _U_ 1 _N_ _S_ "U(LL)" {_A_ 2 _U_ 22 _N_ _N_ _N_ _N_} _N_ _N_ },
+ acos = { _A_ 1 _U_ 1 _N_ _S_ "U(LL)" {_A_ 2 _U_ 22 _N_ _N_ _N_ _N_} _N_ _N_ },
+ atan = { _A_ 1 _U_ 1 _N_ _S_ "U(LL)" {_A_ 2 _U_ 22 _N_ _N_ _N_ _N_} _N_ _N_ },
+ sinh = { _A_ 1 _U_ 1 _N_ _S_ "U(LL)" {_A_ 2 _U_ 22 _N_ _N_ _N_ _N_} _N_ _N_ },
+ cosh = { _A_ 1 _U_ 1 _N_ _S_ "U(LL)" {_A_ 2 _U_ 22 _N_ _N_ _N_ _N_} _N_ _N_ },
+ tanh = { _A_ 1 _U_ 1 _N_ _S_ "U(LL)" {_A_ 2 _U_ 22 _N_ _N_ _N_ _N_} _N_ _N_ },
+ asinh = { _A_ 1 _U_ 1 _N_ _N_ _N_ _N_ },
+ acosh = { _A_ 1 _U_ 1 _N_ _N_ _N_ _N_ },
+ atanh = { _A_ 1 _U_ 1 _N_ _N_ _N_ _N_ } #-}
instance Floating Double
{-# GHC_PRAGMA _M_ PreludeCore {-dfun-} _A_ 0 _N_ _N_ _N_ _F_ _IF_ARGS_ 0 0 X 20 _!_ _TUP_19 [{{Fractional Double}}, Double, (Double -> Double), (Double -> Double), (Double -> Double), (Double -> Double -> Double), (Double -> Double -> Double), (Double -> Double), (Double -> Double), (Double -> Double), (Double -> Double), (Double -> Double), (Double -> Double), (Double -> Double), (Double -> Double), (Double -> Double), (Double -> Double), (Double -> Double), (Double -> Double)] [_DFUN_ Fractional (Double), _CONSTM_ Floating pi (Double), _CONSTM_ Floating exp (Double), _CONSTM_ Floating log (Double), _CONSTM_ Floating sqrt (Double), _CONSTM_ Floating (**) (Double), _CONSTM_ Floating logBase (Double), _CONSTM_ Floating sin (Double), _CONSTM_ Floating cos (Double), _CONSTM_ Floating tan (Double), _CONSTM_ Floating asin (Double), _CONSTM_ Floating acos (Double), _CONSTM_ Floating atan (Double), _CONSTM_ Floating sinh (Double), _CONSTM_ Floating cosh (Double), _CONSTM_ Floating tanh (Double), _CONSTM_ Floating asinh (Double), _CONSTM_ Floating acosh (Double), _CONSTM_ Floating atanh (Double)] _N_
- pi = _A_ 0 _N_ _N_ _N_ _F_ _IF_ARGS_ 0 0 X 2 _!_ D# [] [3.1415926535897931##] _N_,
- exp = _A_ 1 _U_ 1 _N_ _S_ "U(P)" {_A_ 1 _U_ 2 _N_ _N_ _F_ _IF_ARGS_ 0 1 X 3 \ (u0 :: Double#) -> case _#_ expDouble# [] [u0] of { _PRIM_ (u1 :: Double#) -> _!_ D# [] [u1] } _N_} _F_ _IF_ARGS_ 0 1 C 4 \ (u0 :: Double) -> case u0 of { _ALG_ D# (u1 :: Double#) -> case _#_ expDouble# [] [u1] of { _PRIM_ (u2 :: Double#) -> _!_ D# [] [u2] }; _NO_DEFLT_ } _N_,
- log = _A_ 1 _U_ 1 _N_ _S_ "U(P)" {_A_ 1 _U_ 2 _N_ _N_ _F_ _IF_ARGS_ 0 1 X 3 \ (u0 :: Double#) -> case _#_ logDouble# [] [u0] of { _PRIM_ (u1 :: Double#) -> _!_ D# [] [u1] } _N_} _F_ _IF_ARGS_ 0 1 C 4 \ (u0 :: Double) -> case u0 of { _ALG_ D# (u1 :: Double#) -> case _#_ logDouble# [] [u1] of { _PRIM_ (u2 :: Double#) -> _!_ D# [] [u2] }; _NO_DEFLT_ } _N_,
- sqrt = _A_ 1 _U_ 1 _N_ _S_ "U(P)" {_A_ 1 _U_ 2 _N_ _N_ _F_ _IF_ARGS_ 0 1 X 3 \ (u0 :: Double#) -> case _#_ sqrtDouble# [] [u0] of { _PRIM_ (u1 :: Double#) -> _!_ D# [] [u1] } _N_} _F_ _IF_ARGS_ 0 1 C 4 \ (u0 :: Double) -> case u0 of { _ALG_ D# (u1 :: Double#) -> case _#_ sqrtDouble# [] [u1] of { _PRIM_ (u2 :: Double#) -> _!_ D# [] [u2] }; _NO_DEFLT_ } _N_,
- (**) = _A_ 2 _U_ 11 _N_ _S_ "U(P)U(P)" {_A_ 2 _U_ 22 _N_ _N_ _F_ _IF_ARGS_ 0 2 XX 3 \ (u0 :: Double#) (u1 :: Double#) -> case _#_ powerDouble# [] [u0, u1] of { _PRIM_ (u2 :: Double#) -> _!_ D# [] [u2] } _N_} _F_ _IF_ARGS_ 0 2 CC 5 \ (u0 :: Double) (u1 :: Double) -> case u0 of { _ALG_ D# (u2 :: Double#) -> case u1 of { _ALG_ D# (u3 :: Double#) -> case _#_ powerDouble# [] [u2, u3] of { _PRIM_ (u4 :: Double#) -> _!_ D# [] [u4] }; _NO_DEFLT_ }; _NO_DEFLT_ } _N_,
- logBase = _A_ 2 _U_ 11 _N_ _S_ "U(P)U(P)" {_A_ 2 _U_ 22 _N_ _N_ _F_ _IF_ARGS_ 0 2 XX 5 \ (u0 :: Double#) (u1 :: Double#) -> case _#_ logDouble# [] [u1] of { _PRIM_ (u2 :: Double#) -> case _#_ logDouble# [] [u0] of { _PRIM_ (u3 :: Double#) -> case _#_ divideDouble# [] [u2, u3] of { _PRIM_ (u4 :: Double#) -> _!_ D# [] [u4] } } } _N_} _F_ _IF_ARGS_ 0 2 CC 7 \ (u0 :: Double) (u1 :: Double) -> case u1 of { _ALG_ D# (u2 :: Double#) -> case _#_ logDouble# [] [u2] of { _PRIM_ (u3 :: Double#) -> case u0 of { _ALG_ D# (u4 :: Double#) -> case _#_ logDouble# [] [u4] of { _PRIM_ (u5 :: Double#) -> case _#_ divideDouble# [] [u3, u5] of { _PRIM_ (u6 :: Double#) -> _!_ D# [] [u6] } }; _NO_DEFLT_ } }; _NO_DEFLT_ } _N_,
- sin = _A_ 1 _U_ 1 _N_ _S_ "U(P)" {_A_ 1 _U_ 2 _N_ _N_ _F_ _IF_ARGS_ 0 1 X 3 \ (u0 :: Double#) -> case _#_ sinDouble# [] [u0] of { _PRIM_ (u1 :: Double#) -> _!_ D# [] [u1] } _N_} _F_ _IF_ARGS_ 0 1 C 4 \ (u0 :: Double) -> case u0 of { _ALG_ D# (u1 :: Double#) -> case _#_ sinDouble# [] [u1] of { _PRIM_ (u2 :: Double#) -> _!_ D# [] [u2] }; _NO_DEFLT_ } _N_,
- cos = _A_ 1 _U_ 1 _N_ _S_ "U(P)" {_A_ 1 _U_ 2 _N_ _N_ _F_ _IF_ARGS_ 0 1 X 3 \ (u0 :: Double#) -> case _#_ cosDouble# [] [u0] of { _PRIM_ (u1 :: Double#) -> _!_ D# [] [u1] } _N_} _F_ _IF_ARGS_ 0 1 C 4 \ (u0 :: Double) -> case u0 of { _ALG_ D# (u1 :: Double#) -> case _#_ cosDouble# [] [u1] of { _PRIM_ (u2 :: Double#) -> _!_ D# [] [u2] }; _NO_DEFLT_ } _N_,
- tan = _A_ 1 _U_ 1 _N_ _S_ "U(P)" {_A_ 1 _U_ 2 _N_ _N_ _F_ _IF_ARGS_ 0 1 X 3 \ (u0 :: Double#) -> case _#_ tanDouble# [] [u0] of { _PRIM_ (u1 :: Double#) -> _!_ D# [] [u1] } _N_} _F_ _IF_ARGS_ 0 1 C 4 \ (u0 :: Double) -> case u0 of { _ALG_ D# (u1 :: Double#) -> case _#_ tanDouble# [] [u1] of { _PRIM_ (u2 :: Double#) -> _!_ D# [] [u2] }; _NO_DEFLT_ } _N_,
- asin = _A_ 1 _U_ 1 _N_ _S_ "U(P)" {_A_ 1 _U_ 2 _N_ _N_ _F_ _IF_ARGS_ 0 1 X 3 \ (u0 :: Double#) -> case _#_ asinDouble# [] [u0] of { _PRIM_ (u1 :: Double#) -> _!_ D# [] [u1] } _N_} _F_ _IF_ARGS_ 0 1 C 4 \ (u0 :: Double) -> case u0 of { _ALG_ D# (u1 :: Double#) -> case _#_ asinDouble# [] [u1] of { _PRIM_ (u2 :: Double#) -> _!_ D# [] [u2] }; _NO_DEFLT_ } _N_,
- acos = _A_ 1 _U_ 1 _N_ _S_ "U(P)" {_A_ 1 _U_ 2 _N_ _N_ _F_ _IF_ARGS_ 0 1 X 3 \ (u0 :: Double#) -> case _#_ acosDouble# [] [u0] of { _PRIM_ (u1 :: Double#) -> _!_ D# [] [u1] } _N_} _F_ _IF_ARGS_ 0 1 C 4 \ (u0 :: Double) -> case u0 of { _ALG_ D# (u1 :: Double#) -> case _#_ acosDouble# [] [u1] of { _PRIM_ (u2 :: Double#) -> _!_ D# [] [u2] }; _NO_DEFLT_ } _N_,
- atan = _A_ 1 _U_ 1 _N_ _S_ "U(P)" {_A_ 1 _U_ 2 _N_ _N_ _F_ _IF_ARGS_ 0 1 X 3 \ (u0 :: Double#) -> case _#_ atanDouble# [] [u0] of { _PRIM_ (u1 :: Double#) -> _!_ D# [] [u1] } _N_} _F_ _IF_ARGS_ 0 1 C 4 \ (u0 :: Double) -> case u0 of { _ALG_ D# (u1 :: Double#) -> case _#_ atanDouble# [] [u1] of { _PRIM_ (u2 :: Double#) -> _!_ D# [] [u2] }; _NO_DEFLT_ } _N_,
- sinh = _A_ 1 _U_ 1 _N_ _S_ "U(P)" {_A_ 1 _U_ 2 _N_ _N_ _F_ _IF_ARGS_ 0 1 X 3 \ (u0 :: Double#) -> case _#_ sinhDouble# [] [u0] of { _PRIM_ (u1 :: Double#) -> _!_ D# [] [u1] } _N_} _F_ _IF_ARGS_ 0 1 C 4 \ (u0 :: Double) -> case u0 of { _ALG_ D# (u1 :: Double#) -> case _#_ sinhDouble# [] [u1] of { _PRIM_ (u2 :: Double#) -> _!_ D# [] [u2] }; _NO_DEFLT_ } _N_,
- cosh = _A_ 1 _U_ 1 _N_ _S_ "U(P)" {_A_ 1 _U_ 2 _N_ _N_ _F_ _IF_ARGS_ 0 1 X 3 \ (u0 :: Double#) -> case _#_ coshDouble# [] [u0] of { _PRIM_ (u1 :: Double#) -> _!_ D# [] [u1] } _N_} _F_ _IF_ARGS_ 0 1 C 4 \ (u0 :: Double) -> case u0 of { _ALG_ D# (u1 :: Double#) -> case _#_ coshDouble# [] [u1] of { _PRIM_ (u2 :: Double#) -> _!_ D# [] [u2] }; _NO_DEFLT_ } _N_,
- tanh = _A_ 1 _U_ 1 _N_ _S_ "U(P)" {_A_ 1 _U_ 2 _N_ _N_ _F_ _IF_ARGS_ 0 1 X 3 \ (u0 :: Double#) -> case _#_ tanhDouble# [] [u0] of { _PRIM_ (u1 :: Double#) -> _!_ D# [] [u1] } _N_} _F_ _IF_ARGS_ 0 1 C 4 \ (u0 :: Double) -> case u0 of { _ALG_ D# (u1 :: Double#) -> case _#_ tanhDouble# [] [u1] of { _PRIM_ (u2 :: Double#) -> _!_ D# [] [u2] }; _NO_DEFLT_ } _N_,
- asinh = _A_ 1 _U_ 1 _N_ _S_ "U(P)" {_A_ 1 _U_ 2 _N_ _N_ _N_ _N_} _N_ _N_,
- acosh = _A_ 1 _U_ 1 _N_ _S_ "U(P)" {_A_ 1 _U_ 2 _N_ _N_ _N_ _N_} _N_ _N_,
- atanh = _A_ 1 _U_ 1 _N_ _S_ "U(P)" {_A_ 1 _U_ 2 _N_ _N_ _N_ _N_} _N_ _N_ #-}
+ pi = { _A_ 0 _N_ _N_ _N_ _F_ _IF_ARGS_ 0 0 X 2 _!_ D# [] [3.1415926535897931##] _N_ },
+ exp = { _A_ 1 _U_ 1 _N_ _S_ "U(P)" {_A_ 1 _U_ 2 _N_ _N_ _F_ _IF_ARGS_ 0 1 X 3 \ (u0 :: Double#) -> case _#_ expDouble# [] [u0] of { _PRIM_ (u1 :: Double#) -> _!_ D# [] [u1] } _N_} _F_ _IF_ARGS_ 0 1 C 4 \ (u0 :: Double) -> case u0 of { _ALG_ D# (u1 :: Double#) -> case _#_ expDouble# [] [u1] of { _PRIM_ (u2 :: Double#) -> _!_ D# [] [u2] }; _NO_DEFLT_ } _N_ },
+ log = { _A_ 1 _U_ 1 _N_ _S_ "U(P)" {_A_ 1 _U_ 2 _N_ _N_ _F_ _IF_ARGS_ 0 1 X 3 \ (u0 :: Double#) -> case _#_ logDouble# [] [u0] of { _PRIM_ (u1 :: Double#) -> _!_ D# [] [u1] } _N_} _F_ _IF_ARGS_ 0 1 C 4 \ (u0 :: Double) -> case u0 of { _ALG_ D# (u1 :: Double#) -> case _#_ logDouble# [] [u1] of { _PRIM_ (u2 :: Double#) -> _!_ D# [] [u2] }; _NO_DEFLT_ } _N_ },
+ sqrt = { _A_ 1 _U_ 1 _N_ _S_ "U(P)" {_A_ 1 _U_ 2 _N_ _N_ _F_ _IF_ARGS_ 0 1 X 3 \ (u0 :: Double#) -> case _#_ sqrtDouble# [] [u0] of { _PRIM_ (u1 :: Double#) -> _!_ D# [] [u1] } _N_} _F_ _IF_ARGS_ 0 1 C 4 \ (u0 :: Double) -> case u0 of { _ALG_ D# (u1 :: Double#) -> case _#_ sqrtDouble# [] [u1] of { _PRIM_ (u2 :: Double#) -> _!_ D# [] [u2] }; _NO_DEFLT_ } _N_ },
+ (**) = { _A_ 2 _U_ 11 _N_ _S_ "U(P)U(P)" {_A_ 2 _U_ 22 _N_ _N_ _F_ _IF_ARGS_ 0 2 XX 3 \ (u0 :: Double#) (u1 :: Double#) -> case _#_ powerDouble# [] [u0, u1] of { _PRIM_ (u2 :: Double#) -> _!_ D# [] [u2] } _N_} _F_ _IF_ARGS_ 0 2 CC 5 \ (u0 :: Double) (u1 :: Double) -> case u0 of { _ALG_ D# (u2 :: Double#) -> case u1 of { _ALG_ D# (u3 :: Double#) -> case _#_ powerDouble# [] [u2, u3] of { _PRIM_ (u4 :: Double#) -> _!_ D# [] [u4] }; _NO_DEFLT_ }; _NO_DEFLT_ } _N_ },
+ logBase = { _A_ 2 _U_ 11 _N_ _S_ "U(P)U(P)" {_A_ 2 _U_ 22 _N_ _N_ _F_ _IF_ARGS_ 0 2 XX 5 \ (u0 :: Double#) (u1 :: Double#) -> case _#_ logDouble# [] [u1] of { _PRIM_ (u2 :: Double#) -> case _#_ logDouble# [] [u0] of { _PRIM_ (u3 :: Double#) -> case _#_ divideDouble# [] [u2, u3] of { _PRIM_ (u4 :: Double#) -> _!_ D# [] [u4] } } } _N_} _F_ _IF_ARGS_ 0 2 CC 7 \ (u0 :: Double) (u1 :: Double) -> case u1 of { _ALG_ D# (u2 :: Double#) -> case _#_ logDouble# [] [u2] of { _PRIM_ (u3 :: Double#) -> case u0 of { _ALG_ D# (u4 :: Double#) -> case _#_ logDouble# [] [u4] of { _PRIM_ (u5 :: Double#) -> case _#_ divideDouble# [] [u3, u5] of { _PRIM_ (u6 :: Double#) -> _!_ D# [] [u6] } }; _NO_DEFLT_ } }; _NO_DEFLT_ } _N_ },
+ sin = { _A_ 1 _U_ 1 _N_ _S_ "U(P)" {_A_ 1 _U_ 2 _N_ _N_ _F_ _IF_ARGS_ 0 1 X 3 \ (u0 :: Double#) -> case _#_ sinDouble# [] [u0] of { _PRIM_ (u1 :: Double#) -> _!_ D# [] [u1] } _N_} _F_ _IF_ARGS_ 0 1 C 4 \ (u0 :: Double) -> case u0 of { _ALG_ D# (u1 :: Double#) -> case _#_ sinDouble# [] [u1] of { _PRIM_ (u2 :: Double#) -> _!_ D# [] [u2] }; _NO_DEFLT_ } _N_ },
+ cos = { _A_ 1 _U_ 1 _N_ _S_ "U(P)" {_A_ 1 _U_ 2 _N_ _N_ _F_ _IF_ARGS_ 0 1 X 3 \ (u0 :: Double#) -> case _#_ cosDouble# [] [u0] of { _PRIM_ (u1 :: Double#) -> _!_ D# [] [u1] } _N_} _F_ _IF_ARGS_ 0 1 C 4 \ (u0 :: Double) -> case u0 of { _ALG_ D# (u1 :: Double#) -> case _#_ cosDouble# [] [u1] of { _PRIM_ (u2 :: Double#) -> _!_ D# [] [u2] }; _NO_DEFLT_ } _N_ },
+ tan = { _A_ 1 _U_ 1 _N_ _S_ "U(P)" {_A_ 1 _U_ 2 _N_ _N_ _F_ _IF_ARGS_ 0 1 X 3 \ (u0 :: Double#) -> case _#_ tanDouble# [] [u0] of { _PRIM_ (u1 :: Double#) -> _!_ D# [] [u1] } _N_} _F_ _IF_ARGS_ 0 1 C 4 \ (u0 :: Double) -> case u0 of { _ALG_ D# (u1 :: Double#) -> case _#_ tanDouble# [] [u1] of { _PRIM_ (u2 :: Double#) -> _!_ D# [] [u2] }; _NO_DEFLT_ } _N_ },
+ asin = { _A_ 1 _U_ 1 _N_ _S_ "U(P)" {_A_ 1 _U_ 2 _N_ _N_ _F_ _IF_ARGS_ 0 1 X 3 \ (u0 :: Double#) -> case _#_ asinDouble# [] [u0] of { _PRIM_ (u1 :: Double#) -> _!_ D# [] [u1] } _N_} _F_ _IF_ARGS_ 0 1 C 4 \ (u0 :: Double) -> case u0 of { _ALG_ D# (u1 :: Double#) -> case _#_ asinDouble# [] [u1] of { _PRIM_ (u2 :: Double#) -> _!_ D# [] [u2] }; _NO_DEFLT_ } _N_ },
+ acos = { _A_ 1 _U_ 1 _N_ _S_ "U(P)" {_A_ 1 _U_ 2 _N_ _N_ _F_ _IF_ARGS_ 0 1 X 3 \ (u0 :: Double#) -> case _#_ acosDouble# [] [u0] of { _PRIM_ (u1 :: Double#) -> _!_ D# [] [u1] } _N_} _F_ _IF_ARGS_ 0 1 C 4 \ (u0 :: Double) -> case u0 of { _ALG_ D# (u1 :: Double#) -> case _#_ acosDouble# [] [u1] of { _PRIM_ (u2 :: Double#) -> _!_ D# [] [u2] }; _NO_DEFLT_ } _N_ },
+ atan = { _A_ 1 _U_ 1 _N_ _S_ "U(P)" {_A_ 1 _U_ 2 _N_ _N_ _F_ _IF_ARGS_ 0 1 X 3 \ (u0 :: Double#) -> case _#_ atanDouble# [] [u0] of { _PRIM_ (u1 :: Double#) -> _!_ D# [] [u1] } _N_} _F_ _IF_ARGS_ 0 1 C 4 \ (u0 :: Double) -> case u0 of { _ALG_ D# (u1 :: Double#) -> case _#_ atanDouble# [] [u1] of { _PRIM_ (u2 :: Double#) -> _!_ D# [] [u2] }; _NO_DEFLT_ } _N_ },
+ sinh = { _A_ 1 _U_ 1 _N_ _S_ "U(P)" {_A_ 1 _U_ 2 _N_ _N_ _F_ _IF_ARGS_ 0 1 X 3 \ (u0 :: Double#) -> case _#_ sinhDouble# [] [u0] of { _PRIM_ (u1 :: Double#) -> _!_ D# [] [u1] } _N_} _F_ _IF_ARGS_ 0 1 C 4 \ (u0 :: Double) -> case u0 of { _ALG_ D# (u1 :: Double#) -> case _#_ sinhDouble# [] [u1] of { _PRIM_ (u2 :: Double#) -> _!_ D# [] [u2] }; _NO_DEFLT_ } _N_ },
+ cosh = { _A_ 1 _U_ 1 _N_ _S_ "U(P)" {_A_ 1 _U_ 2 _N_ _N_ _F_ _IF_ARGS_ 0 1 X 3 \ (u0 :: Double#) -> case _#_ coshDouble# [] [u0] of { _PRIM_ (u1 :: Double#) -> _!_ D# [] [u1] } _N_} _F_ _IF_ARGS_ 0 1 C 4 \ (u0 :: Double) -> case u0 of { _ALG_ D# (u1 :: Double#) -> case _#_ coshDouble# [] [u1] of { _PRIM_ (u2 :: Double#) -> _!_ D# [] [u2] }; _NO_DEFLT_ } _N_ },
+ tanh = { _A_ 1 _U_ 1 _N_ _S_ "U(P)" {_A_ 1 _U_ 2 _N_ _N_ _F_ _IF_ARGS_ 0 1 X 3 \ (u0 :: Double#) -> case _#_ tanhDouble# [] [u0] of { _PRIM_ (u1 :: Double#) -> _!_ D# [] [u1] } _N_} _F_ _IF_ARGS_ 0 1 C 4 \ (u0 :: Double) -> case u0 of { _ALG_ D# (u1 :: Double#) -> case _#_ tanhDouble# [] [u1] of { _PRIM_ (u2 :: Double#) -> _!_ D# [] [u2] }; _NO_DEFLT_ } _N_ },
+ asinh = { _A_ 1 _U_ 1 _N_ _S_ "U(P)" {_A_ 1 _U_ 2 _N_ _N_ _N_ _N_} _N_ _N_ },
+ acosh = { _A_ 1 _U_ 1 _N_ _S_ "U(P)" {_A_ 1 _U_ 2 _N_ _N_ _N_ _N_} _N_ _N_ },
+ atanh = { _A_ 1 _U_ 1 _N_ _S_ "U(P)" {_A_ 1 _U_ 2 _N_ _N_ _N_ _N_} _N_ _N_ } #-}
instance Floating Float
{-# GHC_PRAGMA _M_ PreludeCore {-dfun-} _A_ 0 _N_ _N_ _N_ _F_ _IF_ARGS_ 0 0 X 20 _!_ _TUP_19 [{{Fractional Float}}, Float, (Float -> Float), (Float -> Float), (Float -> Float), (Float -> Float -> Float), (Float -> Float -> Float), (Float -> Float), (Float -> Float), (Float -> Float), (Float -> Float), (Float -> Float), (Float -> Float), (Float -> Float), (Float -> Float), (Float -> Float), (Float -> Float), (Float -> Float), (Float -> Float)] [_DFUN_ Fractional (Float), _CONSTM_ Floating pi (Float), _CONSTM_ Floating exp (Float), _CONSTM_ Floating log (Float), _CONSTM_ Floating sqrt (Float), _CONSTM_ Floating (**) (Float), _CONSTM_ Floating logBase (Float), _CONSTM_ Floating sin (Float), _CONSTM_ Floating cos (Float), _CONSTM_ Floating tan (Float), _CONSTM_ Floating asin (Float), _CONSTM_ Floating acos (Float), _CONSTM_ Floating atan (Float), _CONSTM_ Floating sinh (Float), _CONSTM_ Floating cosh (Float), _CONSTM_ Floating tanh (Float), _CONSTM_ Floating asinh (Float), _CONSTM_ Floating acosh (Float), _CONSTM_ Floating atanh (Float)] _N_
- pi = _A_ 0 _N_ _N_ _N_ _F_ _IF_ARGS_ 0 0 X 2 _!_ F# [] [3.1415926535897931#] _N_,
- exp = _A_ 1 _U_ 1 _N_ _S_ "U(P)" {_A_ 1 _U_ 2 _N_ _N_ _F_ _IF_ARGS_ 0 1 X 3 \ (u0 :: Float#) -> case _#_ expFloat# [] [u0] of { _PRIM_ (u1 :: Float#) -> _!_ F# [] [u1] } _N_} _F_ _IF_ARGS_ 0 1 C 4 \ (u0 :: Float) -> case u0 of { _ALG_ F# (u1 :: Float#) -> case _#_ expFloat# [] [u1] of { _PRIM_ (u2 :: Float#) -> _!_ F# [] [u2] }; _NO_DEFLT_ } _N_,
- log = _A_ 1 _U_ 1 _N_ _S_ "U(P)" {_A_ 1 _U_ 2 _N_ _N_ _F_ _IF_ARGS_ 0 1 X 3 \ (u0 :: Float#) -> case _#_ logFloat# [] [u0] of { _PRIM_ (u1 :: Float#) -> _!_ F# [] [u1] } _N_} _F_ _IF_ARGS_ 0 1 C 4 \ (u0 :: Float) -> case u0 of { _ALG_ F# (u1 :: Float#) -> case _#_ logFloat# [] [u1] of { _PRIM_ (u2 :: Float#) -> _!_ F# [] [u2] }; _NO_DEFLT_ } _N_,
- sqrt = _A_ 1 _U_ 1 _N_ _S_ "U(P)" {_A_ 1 _U_ 2 _N_ _N_ _F_ _IF_ARGS_ 0 1 X 3 \ (u0 :: Float#) -> case _#_ sqrtFloat# [] [u0] of { _PRIM_ (u1 :: Float#) -> _!_ F# [] [u1] } _N_} _F_ _IF_ARGS_ 0 1 C 4 \ (u0 :: Float) -> case u0 of { _ALG_ F# (u1 :: Float#) -> case _#_ sqrtFloat# [] [u1] of { _PRIM_ (u2 :: Float#) -> _!_ F# [] [u2] }; _NO_DEFLT_ } _N_,
- (**) = _A_ 2 _U_ 11 _N_ _S_ "U(P)U(P)" {_A_ 2 _U_ 22 _N_ _N_ _F_ _IF_ARGS_ 0 2 XX 3 \ (u0 :: Float#) (u1 :: Float#) -> case _#_ powerFloat# [] [u0, u1] of { _PRIM_ (u2 :: Float#) -> _!_ F# [] [u2] } _N_} _F_ _IF_ARGS_ 0 2 CC 5 \ (u0 :: Float) (u1 :: Float) -> case u0 of { _ALG_ F# (u2 :: Float#) -> case u1 of { _ALG_ F# (u3 :: Float#) -> case _#_ powerFloat# [] [u2, u3] of { _PRIM_ (u4 :: Float#) -> _!_ F# [] [u4] }; _NO_DEFLT_ }; _NO_DEFLT_ } _N_,
- logBase = _A_ 2 _U_ 22 _N_ _N_ _N_ _N_,
- sin = _A_ 1 _U_ 1 _N_ _S_ "U(P)" {_A_ 1 _U_ 2 _N_ _N_ _F_ _IF_ARGS_ 0 1 X 3 \ (u0 :: Float#) -> case _#_ sinFloat# [] [u0] of { _PRIM_ (u1 :: Float#) -> _!_ F# [] [u1] } _N_} _F_ _IF_ARGS_ 0 1 C 4 \ (u0 :: Float) -> case u0 of { _ALG_ F# (u1 :: Float#) -> case _#_ sinFloat# [] [u1] of { _PRIM_ (u2 :: Float#) -> _!_ F# [] [u2] }; _NO_DEFLT_ } _N_,
- cos = _A_ 1 _U_ 1 _N_ _S_ "U(P)" {_A_ 1 _U_ 2 _N_ _N_ _F_ _IF_ARGS_ 0 1 X 3 \ (u0 :: Float#) -> case _#_ cosFloat# [] [u0] of { _PRIM_ (u1 :: Float#) -> _!_ F# [] [u1] } _N_} _F_ _IF_ARGS_ 0 1 C 4 \ (u0 :: Float) -> case u0 of { _ALG_ F# (u1 :: Float#) -> case _#_ cosFloat# [] [u1] of { _PRIM_ (u2 :: Float#) -> _!_ F# [] [u2] }; _NO_DEFLT_ } _N_,
- tan = _A_ 1 _U_ 1 _N_ _S_ "U(P)" {_A_ 1 _U_ 2 _N_ _N_ _F_ _IF_ARGS_ 0 1 X 3 \ (u0 :: Float#) -> case _#_ tanFloat# [] [u0] of { _PRIM_ (u1 :: Float#) -> _!_ F# [] [u1] } _N_} _F_ _IF_ARGS_ 0 1 C 4 \ (u0 :: Float) -> case u0 of { _ALG_ F# (u1 :: Float#) -> case _#_ tanFloat# [] [u1] of { _PRIM_ (u2 :: Float#) -> _!_ F# [] [u2] }; _NO_DEFLT_ } _N_,
- asin = _A_ 1 _U_ 1 _N_ _S_ "U(P)" {_A_ 1 _U_ 2 _N_ _N_ _F_ _IF_ARGS_ 0 1 X 3 \ (u0 :: Float#) -> case _#_ asinFloat# [] [u0] of { _PRIM_ (u1 :: Float#) -> _!_ F# [] [u1] } _N_} _F_ _IF_ARGS_ 0 1 C 4 \ (u0 :: Float) -> case u0 of { _ALG_ F# (u1 :: Float#) -> case _#_ asinFloat# [] [u1] of { _PRIM_ (u2 :: Float#) -> _!_ F# [] [u2] }; _NO_DEFLT_ } _N_,
- acos = _A_ 1 _U_ 1 _N_ _S_ "U(P)" {_A_ 1 _U_ 2 _N_ _N_ _F_ _IF_ARGS_ 0 1 X 3 \ (u0 :: Float#) -> case _#_ acosFloat# [] [u0] of { _PRIM_ (u1 :: Float#) -> _!_ F# [] [u1] } _N_} _F_ _IF_ARGS_ 0 1 C 4 \ (u0 :: Float) -> case u0 of { _ALG_ F# (u1 :: Float#) -> case _#_ acosFloat# [] [u1] of { _PRIM_ (u2 :: Float#) -> _!_ F# [] [u2] }; _NO_DEFLT_ } _N_,
- atan = _A_ 1 _U_ 1 _N_ _S_ "U(P)" {_A_ 1 _U_ 2 _N_ _N_ _F_ _IF_ARGS_ 0 1 X 3 \ (u0 :: Float#) -> case _#_ atanFloat# [] [u0] of { _PRIM_ (u1 :: Float#) -> _!_ F# [] [u1] } _N_} _F_ _IF_ARGS_ 0 1 C 4 \ (u0 :: Float) -> case u0 of { _ALG_ F# (u1 :: Float#) -> case _#_ atanFloat# [] [u1] of { _PRIM_ (u2 :: Float#) -> _!_ F# [] [u2] }; _NO_DEFLT_ } _N_,
- sinh = _A_ 1 _U_ 1 _N_ _S_ "U(P)" {_A_ 1 _U_ 2 _N_ _N_ _F_ _IF_ARGS_ 0 1 X 3 \ (u0 :: Float#) -> case _#_ sinhFloat# [] [u0] of { _PRIM_ (u1 :: Float#) -> _!_ F# [] [u1] } _N_} _F_ _IF_ARGS_ 0 1 C 4 \ (u0 :: Float) -> case u0 of { _ALG_ F# (u1 :: Float#) -> case _#_ sinhFloat# [] [u1] of { _PRIM_ (u2 :: Float#) -> _!_ F# [] [u2] }; _NO_DEFLT_ } _N_,
- cosh = _A_ 1 _U_ 1 _N_ _S_ "U(P)" {_A_ 1 _U_ 2 _N_ _N_ _F_ _IF_ARGS_ 0 1 X 3 \ (u0 :: Float#) -> case _#_ coshFloat# [] [u0] of { _PRIM_ (u1 :: Float#) -> _!_ F# [] [u1] } _N_} _F_ _IF_ARGS_ 0 1 C 4 \ (u0 :: Float) -> case u0 of { _ALG_ F# (u1 :: Float#) -> case _#_ coshFloat# [] [u1] of { _PRIM_ (u2 :: Float#) -> _!_ F# [] [u2] }; _NO_DEFLT_ } _N_,
- tanh = _A_ 1 _U_ 1 _N_ _S_ "U(P)" {_A_ 1 _U_ 2 _N_ _N_ _F_ _IF_ARGS_ 0 1 X 3 \ (u0 :: Float#) -> case _#_ tanhFloat# [] [u0] of { _PRIM_ (u1 :: Float#) -> _!_ F# [] [u1] } _N_} _F_ _IF_ARGS_ 0 1 C 4 \ (u0 :: Float) -> case u0 of { _ALG_ F# (u1 :: Float#) -> case _#_ tanhFloat# [] [u1] of { _PRIM_ (u2 :: Float#) -> _!_ F# [] [u2] }; _NO_DEFLT_ } _N_,
- asinh = _A_ 1 _U_ 1 _N_ _S_ "U(P)" {_A_ 1 _U_ 2 _N_ _N_ _N_ _N_} _N_ _N_,
- acosh = _A_ 1 _U_ 1 _N_ _S_ "U(P)" {_A_ 1 _U_ 2 _N_ _N_ _N_ _N_} _N_ _N_,
- atanh = _A_ 1 _U_ 1 _N_ _S_ "U(P)" {_A_ 1 _U_ 2 _N_ _N_ _N_ _N_} _N_ _N_ #-}
+ pi = { _A_ 0 _N_ _N_ _N_ _F_ _IF_ARGS_ 0 0 X 2 _!_ F# [] [3.1415926535897931#] _N_ },
+ exp = { _A_ 1 _U_ 1 _N_ _S_ "U(P)" {_A_ 1 _U_ 2 _N_ _N_ _F_ _IF_ARGS_ 0 1 X 3 \ (u0 :: Float#) -> case _#_ expFloat# [] [u0] of { _PRIM_ (u1 :: Float#) -> _!_ F# [] [u1] } _N_} _F_ _IF_ARGS_ 0 1 C 4 \ (u0 :: Float) -> case u0 of { _ALG_ F# (u1 :: Float#) -> case _#_ expFloat# [] [u1] of { _PRIM_ (u2 :: Float#) -> _!_ F# [] [u2] }; _NO_DEFLT_ } _N_ },
+ log = { _A_ 1 _U_ 1 _N_ _S_ "U(P)" {_A_ 1 _U_ 2 _N_ _N_ _F_ _IF_ARGS_ 0 1 X 3 \ (u0 :: Float#) -> case _#_ logFloat# [] [u0] of { _PRIM_ (u1 :: Float#) -> _!_ F# [] [u1] } _N_} _F_ _IF_ARGS_ 0 1 C 4 \ (u0 :: Float) -> case u0 of { _ALG_ F# (u1 :: Float#) -> case _#_ logFloat# [] [u1] of { _PRIM_ (u2 :: Float#) -> _!_ F# [] [u2] }; _NO_DEFLT_ } _N_ },
+ sqrt = { _A_ 1 _U_ 1 _N_ _S_ "U(P)" {_A_ 1 _U_ 2 _N_ _N_ _F_ _IF_ARGS_ 0 1 X 3 \ (u0 :: Float#) -> case _#_ sqrtFloat# [] [u0] of { _PRIM_ (u1 :: Float#) -> _!_ F# [] [u1] } _N_} _F_ _IF_ARGS_ 0 1 C 4 \ (u0 :: Float) -> case u0 of { _ALG_ F# (u1 :: Float#) -> case _#_ sqrtFloat# [] [u1] of { _PRIM_ (u2 :: Float#) -> _!_ F# [] [u2] }; _NO_DEFLT_ } _N_ },
+ (**) = { _A_ 2 _U_ 11 _N_ _S_ "U(P)U(P)" {_A_ 2 _U_ 22 _N_ _N_ _F_ _IF_ARGS_ 0 2 XX 3 \ (u0 :: Float#) (u1 :: Float#) -> case _#_ powerFloat# [] [u0, u1] of { _PRIM_ (u2 :: Float#) -> _!_ F# [] [u2] } _N_} _F_ _IF_ARGS_ 0 2 CC 5 \ (u0 :: Float) (u1 :: Float) -> case u0 of { _ALG_ F# (u2 :: Float#) -> case u1 of { _ALG_ F# (u3 :: Float#) -> case _#_ powerFloat# [] [u2, u3] of { _PRIM_ (u4 :: Float#) -> _!_ F# [] [u4] }; _NO_DEFLT_ }; _NO_DEFLT_ } _N_ },
+ logBase = { _A_ 2 _U_ 11 _N_ _S_ "U(P)U(P)" {_A_ 2 _U_ 22 _N_ _N_ _F_ _IF_ARGS_ 0 2 XX 5 \ (u0 :: Float#) (u1 :: Float#) -> case _#_ logFloat# [] [u1] of { _PRIM_ (u2 :: Float#) -> case _#_ logFloat# [] [u0] of { _PRIM_ (u3 :: Float#) -> case _#_ divideFloat# [] [u2, u3] of { _PRIM_ (u4 :: Float#) -> _!_ F# [] [u4] } } } _N_} _F_ _IF_ARGS_ 0 2 CC 7 \ (u0 :: Float) (u1 :: Float) -> case u1 of { _ALG_ F# (u2 :: Float#) -> case _#_ logFloat# [] [u2] of { _PRIM_ (u3 :: Float#) -> case u0 of { _ALG_ F# (u4 :: Float#) -> case _#_ logFloat# [] [u4] of { _PRIM_ (u5 :: Float#) -> case _#_ divideFloat# [] [u3, u5] of { _PRIM_ (u6 :: Float#) -> _!_ F# [] [u6] } }; _NO_DEFLT_ } }; _NO_DEFLT_ } _N_ },
+ sin = { _A_ 1 _U_ 1 _N_ _S_ "U(P)" {_A_ 1 _U_ 2 _N_ _N_ _F_ _IF_ARGS_ 0 1 X 3 \ (u0 :: Float#) -> case _#_ sinFloat# [] [u0] of { _PRIM_ (u1 :: Float#) -> _!_ F# [] [u1] } _N_} _F_ _IF_ARGS_ 0 1 C 4 \ (u0 :: Float) -> case u0 of { _ALG_ F# (u1 :: Float#) -> case _#_ sinFloat# [] [u1] of { _PRIM_ (u2 :: Float#) -> _!_ F# [] [u2] }; _NO_DEFLT_ } _N_ },
+ cos = { _A_ 1 _U_ 1 _N_ _S_ "U(P)" {_A_ 1 _U_ 2 _N_ _N_ _F_ _IF_ARGS_ 0 1 X 3 \ (u0 :: Float#) -> case _#_ cosFloat# [] [u0] of { _PRIM_ (u1 :: Float#) -> _!_ F# [] [u1] } _N_} _F_ _IF_ARGS_ 0 1 C 4 \ (u0 :: Float) -> case u0 of { _ALG_ F# (u1 :: Float#) -> case _#_ cosFloat# [] [u1] of { _PRIM_ (u2 :: Float#) -> _!_ F# [] [u2] }; _NO_DEFLT_ } _N_ },
+ tan = { _A_ 1 _U_ 1 _N_ _S_ "U(P)" {_A_ 1 _U_ 2 _N_ _N_ _F_ _IF_ARGS_ 0 1 X 3 \ (u0 :: Float#) -> case _#_ tanFloat# [] [u0] of { _PRIM_ (u1 :: Float#) -> _!_ F# [] [u1] } _N_} _F_ _IF_ARGS_ 0 1 C 4 \ (u0 :: Float) -> case u0 of { _ALG_ F# (u1 :: Float#) -> case _#_ tanFloat# [] [u1] of { _PRIM_ (u2 :: Float#) -> _!_ F# [] [u2] }; _NO_DEFLT_ } _N_ },
+ asin = { _A_ 1 _U_ 1 _N_ _S_ "U(P)" {_A_ 1 _U_ 2 _N_ _N_ _F_ _IF_ARGS_ 0 1 X 3 \ (u0 :: Float#) -> case _#_ asinFloat# [] [u0] of { _PRIM_ (u1 :: Float#) -> _!_ F# [] [u1] } _N_} _F_ _IF_ARGS_ 0 1 C 4 \ (u0 :: Float) -> case u0 of { _ALG_ F# (u1 :: Float#) -> case _#_ asinFloat# [] [u1] of { _PRIM_ (u2 :: Float#) -> _!_ F# [] [u2] }; _NO_DEFLT_ } _N_ },
+ acos = { _A_ 1 _U_ 1 _N_ _S_ "U(P)" {_A_ 1 _U_ 2 _N_ _N_ _F_ _IF_ARGS_ 0 1 X 3 \ (u0 :: Float#) -> case _#_ acosFloat# [] [u0] of { _PRIM_ (u1 :: Float#) -> _!_ F# [] [u1] } _N_} _F_ _IF_ARGS_ 0 1 C 4 \ (u0 :: Float) -> case u0 of { _ALG_ F# (u1 :: Float#) -> case _#_ acosFloat# [] [u1] of { _PRIM_ (u2 :: Float#) -> _!_ F# [] [u2] }; _NO_DEFLT_ } _N_ },
+ atan = { _A_ 1 _U_ 1 _N_ _S_ "U(P)" {_A_ 1 _U_ 2 _N_ _N_ _F_ _IF_ARGS_ 0 1 X 3 \ (u0 :: Float#) -> case _#_ atanFloat# [] [u0] of { _PRIM_ (u1 :: Float#) -> _!_ F# [] [u1] } _N_} _F_ _IF_ARGS_ 0 1 C 4 \ (u0 :: Float) -> case u0 of { _ALG_ F# (u1 :: Float#) -> case _#_ atanFloat# [] [u1] of { _PRIM_ (u2 :: Float#) -> _!_ F# [] [u2] }; _NO_DEFLT_ } _N_ },
+ sinh = { _A_ 1 _U_ 1 _N_ _S_ "U(P)" {_A_ 1 _U_ 2 _N_ _N_ _F_ _IF_ARGS_ 0 1 X 3 \ (u0 :: Float#) -> case _#_ sinhFloat# [] [u0] of { _PRIM_ (u1 :: Float#) -> _!_ F# [] [u1] } _N_} _F_ _IF_ARGS_ 0 1 C 4 \ (u0 :: Float) -> case u0 of { _ALG_ F# (u1 :: Float#) -> case _#_ sinhFloat# [] [u1] of { _PRIM_ (u2 :: Float#) -> _!_ F# [] [u2] }; _NO_DEFLT_ } _N_ },
+ cosh = { _A_ 1 _U_ 1 _N_ _S_ "U(P)" {_A_ 1 _U_ 2 _N_ _N_ _F_ _IF_ARGS_ 0 1 X 3 \ (u0 :: Float#) -> case _#_ coshFloat# [] [u0] of { _PRIM_ (u1 :: Float#) -> _!_ F# [] [u1] } _N_} _F_ _IF_ARGS_ 0 1 C 4 \ (u0 :: Float) -> case u0 of { _ALG_ F# (u1 :: Float#) -> case _#_ coshFloat# [] [u1] of { _PRIM_ (u2 :: Float#) -> _!_ F# [] [u2] }; _NO_DEFLT_ } _N_ },
+ tanh = { _A_ 1 _U_ 1 _N_ _S_ "U(P)" {_A_ 1 _U_ 2 _N_ _N_ _F_ _IF_ARGS_ 0 1 X 3 \ (u0 :: Float#) -> case _#_ tanhFloat# [] [u0] of { _PRIM_ (u1 :: Float#) -> _!_ F# [] [u1] } _N_} _F_ _IF_ARGS_ 0 1 C 4 \ (u0 :: Float) -> case u0 of { _ALG_ F# (u1 :: Float#) -> case _#_ tanhFloat# [] [u1] of { _PRIM_ (u2 :: Float#) -> _!_ F# [] [u2] }; _NO_DEFLT_ } _N_ },
+ asinh = { _A_ 1 _U_ 1 _N_ _S_ "U(P)" {_A_ 1 _U_ 2 _N_ _N_ _N_ _N_} _N_ _N_ },
+ acosh = { _A_ 1 _U_ 1 _N_ _S_ "U(P)" {_A_ 1 _U_ 2 _N_ _N_ _N_ _N_} _N_ _N_ },
+ atanh = { _A_ 1 _U_ 1 _N_ _S_ "U(P)" {_A_ 1 _U_ 2 _N_ _N_ _N_ _N_} _N_ _N_ } #-}
instance RealFloat a => Fractional (Complex a)
{-# GHC_PRAGMA _M_ PreludeComplex {-dfun-} _A_ 2 _U_ 22 _N_ _N_ _N_ _N_ #-}
instance Fractional (Complex Double)
{-# GHC_PRAGMA _M_ PreludeComplex {-dfun-} _A_ 0 _N_ _N_ _N_ _F_ _IF_ARGS_ 0 0 X 5 _!_ _TUP_4 [{{Num (Complex Double)}}, (Complex Double -> Complex Double -> Complex Double), (Complex Double -> Complex Double), (Ratio Integer -> Complex Double)] [_DFUN_ Num (Complex Double), _CONSTM_ Fractional (/) (Complex Double), _CONSTM_ Fractional recip (Complex Double), _CONSTM_ Fractional fromRational (Complex Double)] _N_
- (/) = _A_ 2 _U_ 11 _N_ _S_ "U(LL)U(LL)" {_A_ 4 _U_ 2222 _N_ _N_ _N_ _N_} _N_ _N_,
- recip = _A_ 1 _U_ 1 _N_ _S_ "U(LL)" {_A_ 2 _U_ 22 _N_ _N_ _N_ _N_} _N_ _N_,
- fromRational = _A_ 1 _U_ 2 _N_ _N_ _N_ _N_ #-}
+ (/) = { _A_ 2 _U_ 11 _N_ _S_ "U(LL)U(LL)" {_A_ 4 _U_ 2222 _N_ _N_ _N_ _N_} _N_ _N_ },
+ recip = { _A_ 1 _U_ 1 _N_ _S_ "U(LL)" {_A_ 2 _U_ 22 _N_ _N_ _N_ _N_} _F_ _IF_ARGS_ 0 1 X 3 \ (u0 :: Complex Double) -> _APP_ _CONSTM_ Fractional (/) (Complex Double) [ _SPEC_ _ORIG_ PreludeCore __i1 [ (Complex Double) ], u0 ] _N_ },
+ fromRational = { _A_ 1 _U_ 1 _N_ _N_ _N_ _N_ } #-}
instance Fractional Double
{-# GHC_PRAGMA _M_ PreludeCore {-dfun-} _A_ 0 _N_ _N_ _N_ _F_ _IF_ARGS_ 0 0 X 5 _!_ _TUP_4 [{{Num Double}}, (Double -> Double -> Double), (Double -> Double), (Ratio Integer -> Double)] [_DFUN_ Num (Double), _CONSTM_ Fractional (/) (Double), _CONSTM_ Fractional recip (Double), _CONSTM_ Fractional fromRational (Double)] _N_
- (/) = _A_ 2 _U_ 11 _N_ _S_ "U(P)U(P)" {_A_ 2 _U_ 22 _N_ _N_ _F_ _IF_ARGS_ 0 2 XX 3 \ (u0 :: Double#) (u1 :: Double#) -> case _#_ divideDouble# [] [u0, u1] of { _PRIM_ (u2 :: Double#) -> _!_ D# [] [u2] } _N_} _F_ _IF_ARGS_ 0 2 CC 5 \ (u0 :: Double) (u1 :: Double) -> case u0 of { _ALG_ D# (u2 :: Double#) -> case u1 of { _ALG_ D# (u3 :: Double#) -> case _#_ divideDouble# [] [u2, u3] of { _PRIM_ (u4 :: Double#) -> _!_ D# [] [u4] }; _NO_DEFLT_ }; _NO_DEFLT_ } _N_,
- recip = _A_ 1 _U_ 1 _N_ _S_ "U(P)" {_A_ 1 _U_ 2 _N_ _N_ _F_ _IF_ARGS_ 0 1 X 3 \ (u0 :: Double#) -> case _#_ divideDouble# [] [1.0000000000000000##, u0] of { _PRIM_ (u1 :: Double#) -> _!_ D# [] [u1] } _N_} _F_ _IF_ARGS_ 0 1 C 4 \ (u0 :: Double) -> case u0 of { _ALG_ D# (u1 :: Double#) -> case _#_ divideDouble# [] [1.0000000000000000##, u1] of { _PRIM_ (u2 :: Double#) -> _!_ D# [] [u2] }; _NO_DEFLT_ } _N_,
- fromRational = _A_ 0 _U_ 2 _N_ _N_ _N_ _N_ #-}
+ (/) = { _A_ 2 _U_ 11 _N_ _S_ "U(P)U(P)" {_A_ 2 _U_ 22 _N_ _N_ _F_ _IF_ARGS_ 0 2 XX 3 \ (u0 :: Double#) (u1 :: Double#) -> case _#_ divideDouble# [] [u0, u1] of { _PRIM_ (u2 :: Double#) -> _!_ D# [] [u2] } _N_} _F_ _IF_ARGS_ 0 2 CC 5 \ (u0 :: Double) (u1 :: Double) -> case u0 of { _ALG_ D# (u2 :: Double#) -> case u1 of { _ALG_ D# (u3 :: Double#) -> case _#_ divideDouble# [] [u2, u3] of { _PRIM_ (u4 :: Double#) -> _!_ D# [] [u4] }; _NO_DEFLT_ }; _NO_DEFLT_ } _N_ },
+ recip = { _A_ 1 _U_ 1 _N_ _S_ "U(P)" {_A_ 1 _U_ 2 _N_ _N_ _F_ _IF_ARGS_ 0 1 X 3 \ (u0 :: Double#) -> case _#_ divideDouble# [] [1.0000000000000000##, u0] of { _PRIM_ (u1 :: Double#) -> _!_ D# [] [u1] } _N_} _F_ _IF_ARGS_ 0 1 C 4 \ (u0 :: Double) -> case u0 of { _ALG_ D# (u1 :: Double#) -> case _#_ divideDouble# [] [1.0000000000000000##, u1] of { _PRIM_ (u2 :: Double#) -> _!_ D# [] [u2] }; _NO_DEFLT_ } _N_ },
+ fromRational = { _A_ 1 _U_ 1 _N_ _S_ "U(U(PPP)U(PPP))" {_A_ 4 _U_ 2222 _N_ _N_ _N_ _N_} _N_ _N_ } #-}
instance Fractional Float
{-# GHC_PRAGMA _M_ PreludeCore {-dfun-} _A_ 0 _N_ _N_ _N_ _F_ _IF_ARGS_ 0 0 X 5 _!_ _TUP_4 [{{Num Float}}, (Float -> Float -> Float), (Float -> Float), (Ratio Integer -> Float)] [_DFUN_ Num (Float), _CONSTM_ Fractional (/) (Float), _CONSTM_ Fractional recip (Float), _CONSTM_ Fractional fromRational (Float)] _N_
- (/) = _A_ 2 _U_ 11 _N_ _S_ "U(P)U(P)" {_A_ 2 _U_ 22 _N_ _N_ _F_ _IF_ARGS_ 0 2 XX 3 \ (u0 :: Float#) (u1 :: Float#) -> case _#_ divideFloat# [] [u0, u1] of { _PRIM_ (u2 :: Float#) -> _!_ F# [] [u2] } _N_} _F_ _IF_ARGS_ 0 2 CC 5 \ (u0 :: Float) (u1 :: Float) -> case u0 of { _ALG_ F# (u2 :: Float#) -> case u1 of { _ALG_ F# (u3 :: Float#) -> case _#_ divideFloat# [] [u2, u3] of { _PRIM_ (u4 :: Float#) -> _!_ F# [] [u4] }; _NO_DEFLT_ }; _NO_DEFLT_ } _N_,
- recip = _A_ 0 _U_ 2 _N_ _N_ _N_ _N_,
- fromRational = _A_ 0 _U_ 2 _N_ _N_ _N_ _N_ #-}
+ (/) = { _A_ 2 _U_ 11 _N_ _S_ "U(P)U(P)" {_A_ 2 _U_ 22 _N_ _N_ _F_ _IF_ARGS_ 0 2 XX 3 \ (u0 :: Float#) (u1 :: Float#) -> case _#_ divideFloat# [] [u0, u1] of { _PRIM_ (u2 :: Float#) -> _!_ F# [] [u2] } _N_} _F_ _IF_ARGS_ 0 2 CC 5 \ (u0 :: Float) (u1 :: Float) -> case u0 of { _ALG_ F# (u2 :: Float#) -> case u1 of { _ALG_ F# (u3 :: Float#) -> case _#_ divideFloat# [] [u2, u3] of { _PRIM_ (u4 :: Float#) -> _!_ F# [] [u4] }; _NO_DEFLT_ }; _NO_DEFLT_ } _N_ },
+ recip = { _A_ 1 _U_ 1 _N_ _S_ "U(P)" {_A_ 1 _U_ 2 _N_ _N_ _F_ _IF_ARGS_ 0 1 X 3 \ (u0 :: Float#) -> case _#_ divideFloat# [] [1.0000000000000000#, u0] of { _PRIM_ (u1 :: Float#) -> _!_ F# [] [u1] } _N_} _F_ _IF_ARGS_ 0 1 C 4 \ (u0 :: Float) -> case u0 of { _ALG_ F# (u1 :: Float#) -> case _#_ divideFloat# [] [1.0000000000000000#, u1] of { _PRIM_ (u2 :: Float#) -> _!_ F# [] [u2] }; _NO_DEFLT_ } _N_ },
+ fromRational = { _A_ 1 _U_ 2 _N_ _N_ _N_ _N_ } #-}
instance Integral a => Fractional (Ratio a)
{-# GHC_PRAGMA _M_ PreludeRatio {-dfun-} _A_ 2 _U_ 22 _N_ _N_ _N_ _N_ #-}
instance Fractional (Ratio Integer)
{-# GHC_PRAGMA _M_ PreludeRatio {-dfun-} _A_ 0 _N_ _N_ _N_ _F_ _IF_ARGS_ 0 0 X 5 _!_ _TUP_4 [{{Num (Ratio Integer)}}, (Ratio Integer -> Ratio Integer -> Ratio Integer), (Ratio Integer -> Ratio Integer), (Ratio Integer -> Ratio Integer)] [_DFUN_ Num (Ratio Integer), _CONSTM_ Fractional (/) (Ratio Integer), _CONSTM_ Fractional recip (Ratio Integer), _CONSTM_ Fractional fromRational (Ratio Integer)] _N_
- (/) = _A_ 2 _U_ 11 _N_ _S_ "U(LU(PPP))U(U(PPP)L)" {_A_ 5 _U_ 22221 _N_ _N_ _N_ _N_} _N_ _N_,
- recip = _A_ 1 _U_ 1 _N_ _S_ "U(U(PPP)L)" {_A_ 4 _U_ 2222 _N_ _N_ _N_ _N_} _N_ _N_,
- fromRational = _A_ 1 _U_ 1 _N_ _S_ "U(LL)" {_A_ 2 _U_ 22 _N_ _N_ _F_ _IF_ARGS_ 0 2 XX 3 \ (u0 :: Integer) (u1 :: Integer) -> _!_ (:%) [Integer] [u0, u1] _N_} _F_ _IF_ARGS_ 0 1 X 1 \ (u0 :: Ratio Integer) -> u0 _N_ #-}
+ (/) = { _A_ 2 _U_ 11 _N_ _S_ "U(LU(PPP))U(U(PPP)L)" {_A_ 5 _U_ 22221 _N_ _N_ _N_ _N_} _N_ _N_ },
+ recip = { _A_ 1 _U_ 1 _N_ _S_ "U(U(PPP)L)" {_A_ 4 _U_ 2222 _N_ _N_ _N_ _N_} _N_ _N_ },
+ fromRational = { _A_ 1 _U_ 1 _N_ _S_ "U(LL)" {_A_ 2 _U_ 22 _N_ _N_ _F_ _IF_ARGS_ 0 2 XX 3 \ (u0 :: Integer) (u1 :: Integer) -> _!_ (:%) [Integer] [u0, u1] _N_} _F_ _IF_ARGS_ 0 1 X 1 \ (u0 :: Ratio Integer) -> u0 _N_ } #-}
instance Integral Int
{-# GHC_PRAGMA _M_ PreludeCore {-dfun-} _A_ 0 _N_ _N_ _N_ _F_ _IF_ARGS_ 0 0 X 13 _!_ _TUP_12 [{{Real Int}}, {{Ix Int}}, (Int -> Int -> Int), (Int -> Int -> Int), (Int -> Int -> Int), (Int -> Int -> Int), (Int -> Int -> (Int, Int)), (Int -> Int -> (Int, Int)), (Int -> Bool), (Int -> Bool), (Int -> Integer), (Int -> Int)] [_DFUN_ Real (Int), _DFUN_ Ix (Int), _CONSTM_ Integral quot (Int), _CONSTM_ Integral rem (Int), _CONSTM_ Integral div (Int), _CONSTM_ Integral mod (Int), _CONSTM_ Integral quotRem (Int), _CONSTM_ Integral divMod (Int), _CONSTM_ Integral even (Int), _CONSTM_ Integral odd (Int), _CONSTM_ Integral toInteger (Int), _CONSTM_ Integral toInt (Int)] _N_
- quot = _A_ 2 _U_ 11 _N_ _S_ "U(P)U(P)" {_A_ 2 _U_ 22 _N_ _N_ _F_ _IF_ARGS_ 0 2 XC 5 \ (u0 :: Int#) (u1 :: Int#) -> case u1 of { _PRIM_ 0# -> _APP_ _TYAPP_ error { Int } [ _NOREP_S_ "Integral.Int.quot{PreludeCore}: divide by 0\n" ]; (u2 :: Int#) -> case _#_ quotInt# [] [u0, u1] of { _PRIM_ (u3 :: Int#) -> _!_ I# [] [u3] } } _N_} _F_ _IF_ARGS_ 0 2 CC 7 \ (u0 :: Int) (u1 :: Int) -> case u1 of { _ALG_ I# (u2 :: Int#) -> case u2 of { _PRIM_ 0# -> _APP_ _TYAPP_ error { Int } [ _NOREP_S_ "Integral.Int.quot{PreludeCore}: divide by 0\n" ]; (u3 :: Int#) -> case u0 of { _ALG_ I# (u4 :: Int#) -> case _#_ quotInt# [] [u4, u2] of { _PRIM_ (u5 :: Int#) -> _!_ I# [] [u5] }; _NO_DEFLT_ } }; _NO_DEFLT_ } _N_,
- rem = _A_ 2 _U_ 11 _N_ _S_ "U(P)U(P)" {_A_ 2 _U_ 22 _N_ _N_ _F_ _IF_ARGS_ 0 2 XC 5 \ (u0 :: Int#) (u1 :: Int#) -> case u1 of { _PRIM_ 0# -> _APP_ _TYAPP_ error { Int } [ _NOREP_S_ "Integral.Int.rem{PreludeCore}: divide by 0\n" ]; (u2 :: Int#) -> case _#_ remInt# [] [u0, u1] of { _PRIM_ (u3 :: Int#) -> _!_ I# [] [u3] } } _N_} _F_ _IF_ARGS_ 0 2 CC 7 \ (u0 :: Int) (u1 :: Int) -> case u1 of { _ALG_ I# (u2 :: Int#) -> case u2 of { _PRIM_ 0# -> _APP_ _TYAPP_ error { Int } [ _NOREP_S_ "Integral.Int.rem{PreludeCore}: divide by 0\n" ]; (u3 :: Int#) -> case u0 of { _ALG_ I# (u4 :: Int#) -> case _#_ remInt# [] [u4, u2] of { _PRIM_ (u5 :: Int#) -> _!_ I# [] [u5] }; _NO_DEFLT_ } }; _NO_DEFLT_ } _N_,
- div = _A_ 2 _U_ 11 _N_ _S_ "U(P)U(P)" {_A_ 2 _U_ 22 _N_ _N_ _N_ _N_} _N_ _N_,
- mod = _A_ 2 _U_ 11 _N_ _S_ "U(P)U(P)" {_A_ 2 _U_ 22 _N_ _N_ _N_ _N_} _N_ _N_,
- quotRem = _A_ 2 _U_ 11 _N_ _S_ "U(P)U(P)" {_A_ 2 _U_ 22 _N_ _N_ _N_ _N_} _N_ _N_,
- divMod = _A_ 2 _U_ 11 _N_ _S_ "U(P)U(P)" {_A_ 2 _U_ 22 _N_ _N_ _N_ _N_} _N_ _N_,
- even = _A_ 1 _U_ 1 _N_ _S_ "U(P)" {_A_ 1 _U_ 2 _N_ _N_ _N_ _N_} _N_ _N_,
- odd = _A_ 1 _U_ 1 _N_ _S_ "U(P)" {_A_ 1 _U_ 2 _N_ _N_ _N_ _N_} _N_ _N_,
- toInteger = _A_ 1 _U_ 1 _N_ _S_ "U(P)" {_A_ 1 _U_ 2 _N_ _N_ _F_ _IF_ARGS_ 0 1 X 1 \ (u0 :: Int#) -> _#_ int2Integer# [] [u0] _N_} _F_ _IF_ARGS_ 0 1 C 2 \ (u0 :: Int) -> case u0 of { _ALG_ I# (u1 :: Int#) -> _#_ int2Integer# [] [u1]; _NO_DEFLT_ } _N_,
- toInt = _A_ 1 _U_ 1 _N_ _S_ "U(P)" {_A_ 1 _U_ 2 _N_ _N_ _F_ _IF_ARGS_ 0 1 X 2 \ (u0 :: Int#) -> _!_ I# [] [u0] _N_} _F_ _IF_ARGS_ 0 1 X 1 \ (u0 :: Int) -> u0 _N_ #-}
+ quot = { _A_ 2 _U_ 11 _N_ _S_ "U(P)U(P)" {_A_ 2 _U_ 22 _N_ _N_ _F_ _IF_ARGS_ 0 2 XC 5 \ (u0 :: Int#) (u1 :: Int#) -> case u1 of { _PRIM_ 0# -> _APP_ _TYAPP_ error { Int } [ _NOREP_S_ "Integral.Int.quot{PreludeCore}: divide by 0\n" ]; (u2 :: Int#) -> case _#_ quotInt# [] [u0, u1] of { _PRIM_ (u3 :: Int#) -> _!_ I# [] [u3] } } _N_} _F_ _IF_ARGS_ 0 2 CC 7 \ (u0 :: Int) (u1 :: Int) -> case u1 of { _ALG_ I# (u2 :: Int#) -> case u2 of { _PRIM_ 0# -> _APP_ _TYAPP_ error { Int } [ _NOREP_S_ "Integral.Int.quot{PreludeCore}: divide by 0\n" ]; (u3 :: Int#) -> case u0 of { _ALG_ I# (u4 :: Int#) -> case _#_ quotInt# [] [u4, u2] of { _PRIM_ (u5 :: Int#) -> _!_ I# [] [u5] }; _NO_DEFLT_ } }; _NO_DEFLT_ } _N_ },
+ rem = { _A_ 2 _U_ 11 _N_ _S_ "U(P)U(P)" {_A_ 2 _U_ 22 _N_ _N_ _F_ _IF_ARGS_ 0 2 XC 5 \ (u0 :: Int#) (u1 :: Int#) -> case u1 of { _PRIM_ 0# -> _APP_ _TYAPP_ error { Int } [ _NOREP_S_ "Integral.Int.rem{PreludeCore}: divide by 0\n" ]; (u2 :: Int#) -> case _#_ remInt# [] [u0, u1] of { _PRIM_ (u3 :: Int#) -> _!_ I# [] [u3] } } _N_} _F_ _IF_ARGS_ 0 2 CC 7 \ (u0 :: Int) (u1 :: Int) -> case u1 of { _ALG_ I# (u2 :: Int#) -> case u2 of { _PRIM_ 0# -> _APP_ _TYAPP_ error { Int } [ _NOREP_S_ "Integral.Int.rem{PreludeCore}: divide by 0\n" ]; (u3 :: Int#) -> case u0 of { _ALG_ I# (u4 :: Int#) -> case _#_ remInt# [] [u4, u2] of { _PRIM_ (u5 :: Int#) -> _!_ I# [] [u5] }; _NO_DEFLT_ } }; _NO_DEFLT_ } _N_ },
+ div = { _A_ 2 _U_ 11 _N_ _S_ "U(P)U(P)" {_A_ 2 _U_ 22 _N_ _N_ _N_ _N_} _N_ _N_ },
+ mod = { _A_ 2 _U_ 11 _N_ _S_ "U(P)U(P)" {_A_ 2 _U_ 22 _N_ _N_ _N_ _N_} _N_ _N_ },
+ quotRem = { _A_ 2 _U_ 11 _N_ _S_ "U(P)U(P)" {_A_ 2 _U_ 22 _N_ _N_ _N_ _N_} _N_ _N_ },
+ divMod = { _A_ 2 _U_ 11 _N_ _S_ "U(P)U(P)" {_A_ 2 _U_ 22 _N_ _N_ _N_ _N_} _N_ _N_ },
+ even = { _A_ 1 _U_ 1 _N_ _S_ "U(P)" {_A_ 1 _U_ 2 _N_ _N_ _N_ _N_} _N_ _N_ },
+ odd = { _A_ 1 _U_ 1 _N_ _S_ "U(P)" {_A_ 1 _U_ 2 _N_ _N_ _N_ _N_} _N_ _N_ },
+ toInteger = { _A_ 1 _U_ 1 _N_ _S_ "U(P)" {_A_ 1 _U_ 2 _N_ _N_ _F_ _IF_ARGS_ 0 1 X 1 \ (u0 :: Int#) -> _#_ int2Integer# [] [u0] _N_} _F_ _IF_ARGS_ 0 1 C 2 \ (u0 :: Int) -> case u0 of { _ALG_ I# (u1 :: Int#) -> _#_ int2Integer# [] [u1]; _NO_DEFLT_ } _N_ },
+ toInt = { _A_ 1 _U_ 1 _N_ _S_ "U(P)" {_A_ 1 _U_ 2 _N_ _N_ _F_ _IF_ARGS_ 0 1 X 2 \ (u0 :: Int#) -> _!_ I# [] [u0] _N_} _F_ _IF_ARGS_ 0 1 X 1 \ (u0 :: Int) -> u0 _N_ } #-}
instance Integral Integer
{-# GHC_PRAGMA _M_ PreludeCore {-dfun-} _A_ 0 _N_ _N_ _N_ _F_ _IF_ARGS_ 0 0 X 13 _!_ _TUP_12 [{{Real Integer}}, {{Ix Integer}}, (Integer -> Integer -> Integer), (Integer -> Integer -> Integer), (Integer -> Integer -> Integer), (Integer -> Integer -> Integer), (Integer -> Integer -> (Integer, Integer)), (Integer -> Integer -> (Integer, Integer)), (Integer -> Bool), (Integer -> Bool), (Integer -> Integer), (Integer -> Int)] [_DFUN_ Real (Integer), _DFUN_ Ix (Integer), _CONSTM_ Integral quot (Integer), _CONSTM_ Integral rem (Integer), _CONSTM_ Integral div (Integer), _CONSTM_ Integral mod (Integer), _CONSTM_ Integral quotRem (Integer), _CONSTM_ Integral divMod (Integer), _CONSTM_ Integral even (Integer), _CONSTM_ Integral odd (Integer), _CONSTM_ Integral toInteger (Integer), _CONSTM_ Integral toInt (Integer)] _N_
- quot = _A_ 2 _U_ 11 _N_ _S_ "U(PPP)U(PPP)" {_A_ 4 _U_ 2221 _N_ _N_ _F_ _IF_ARGS_ 0 4 XXXX 7 \ (u0 :: Int#) (u1 :: Int#) (u2 :: ByteArray#) (u3 :: Integer) -> case _APP_ _WRKR_ _CONSTM_ Integral quotRem (Integer) [ u0, u1, u2, u3 ] of { _ALG_ _TUP_2 (u4 :: Integer) (u5 :: Integer) -> u4; _NO_DEFLT_ } _N_} _F_ _IF_ARGS_ 0 2 XX 5 \ (u0 :: Integer) (u1 :: Integer) -> case _APP_ _CONSTM_ Integral quotRem (Integer) [ u0, u1 ] of { _ALG_ _TUP_2 (u2 :: Integer) (u3 :: Integer) -> u2; _NO_DEFLT_ } _N_,
- rem = _A_ 2 _U_ 11 _N_ _S_ "U(PPP)U(PPP)" {_A_ 4 _U_ 2221 _N_ _N_ _F_ _IF_ARGS_ 0 4 XXXX 7 \ (u0 :: Int#) (u1 :: Int#) (u2 :: ByteArray#) (u3 :: Integer) -> case _APP_ _WRKR_ _CONSTM_ Integral quotRem (Integer) [ u0, u1, u2, u3 ] of { _ALG_ _TUP_2 (u4 :: Integer) (u5 :: Integer) -> u5; _NO_DEFLT_ } _N_} _F_ _IF_ARGS_ 0 2 XX 5 \ (u0 :: Integer) (u1 :: Integer) -> case _APP_ _CONSTM_ Integral quotRem (Integer) [ u0, u1 ] of { _ALG_ _TUP_2 (u2 :: Integer) (u3 :: Integer) -> u3; _NO_DEFLT_ } _N_,
- div = _A_ 2 _U_ 12 _N_ _S_ "U(PPP)U(PPP)" {_A_ 4 _U_ 2222 _N_ _N_ _F_ _IF_ARGS_ 0 4 XXXX 7 \ (u0 :: Int#) (u1 :: Int#) (u2 :: ByteArray#) (u3 :: Integer) -> case _APP_ _WRKR_ _CONSTM_ Integral divMod (Integer) [ u0, u1, u2, u3 ] of { _ALG_ _TUP_2 (u4 :: Integer) (u5 :: Integer) -> u4; _NO_DEFLT_ } _N_} _F_ _IF_ARGS_ 0 2 XX 5 \ (u0 :: Integer) (u1 :: Integer) -> case _APP_ _CONSTM_ Integral divMod (Integer) [ u0, u1 ] of { _ALG_ _TUP_2 (u2 :: Integer) (u3 :: Integer) -> u2; _NO_DEFLT_ } _N_,
- mod = _A_ 2 _U_ 12 _N_ _S_ "U(PPP)U(PPP)" {_A_ 4 _U_ 2222 _N_ _N_ _F_ _IF_ARGS_ 0 4 XXXX 7 \ (u0 :: Int#) (u1 :: Int#) (u2 :: ByteArray#) (u3 :: Integer) -> case _APP_ _WRKR_ _CONSTM_ Integral divMod (Integer) [ u0, u1, u2, u3 ] of { _ALG_ _TUP_2 (u4 :: Integer) (u5 :: Integer) -> u5; _NO_DEFLT_ } _N_} _F_ _IF_ARGS_ 0 2 XX 5 \ (u0 :: Integer) (u1 :: Integer) -> case _APP_ _CONSTM_ Integral divMod (Integer) [ u0, u1 ] of { _ALG_ _TUP_2 (u2 :: Integer) (u3 :: Integer) -> u3; _NO_DEFLT_ } _N_,
- quotRem = _A_ 2 _U_ 11 _N_ _S_ "U(PPP)U(PPP)" {_A_ 4 _U_ 2221 _N_ _N_ _N_ _N_} _N_ _N_,
- divMod = _A_ 2 _U_ 12 _N_ _S_ "U(PPP)U(PPP)" {_A_ 4 _U_ 2222 _N_ _N_ _N_ _N_} _N_ _N_,
- even = _A_ 1 _U_ 1 _N_ _S_ "U(PPP)" {_A_ 3 _U_ 222 _N_ _N_ _N_ _N_} _N_ _N_,
- odd = _A_ 1 _U_ 1 _N_ _S_ "U(PPP)" {_A_ 3 _U_ 222 _N_ _N_ _N_ _N_} _N_ _N_,
- toInteger = _A_ 1 _U_ 1 _N_ _S_ "U(PPP)" {_A_ 3 _U_ 222 _N_ _N_ _F_ _IF_ARGS_ 0 3 XXX 4 \ (u0 :: Int#) (u1 :: Int#) (u2 :: ByteArray#) -> _!_ J# [] [u0, u1, u2] _N_} _F_ _IF_ARGS_ 0 1 X 1 \ (u0 :: Integer) -> u0 _N_,
- toInt = _A_ 1 _U_ 1 _N_ _S_ "U(PPP)" {_A_ 3 _U_ 222 _N_ _N_ _F_ _IF_ARGS_ 0 3 XXX 3 \ (u0 :: Int#) (u1 :: Int#) (u2 :: ByteArray#) -> case _#_ integer2Int# [] [u0, u1, u2] of { _PRIM_ (u3 :: Int#) -> _!_ I# [] [u3] } _N_} _F_ _IF_ARGS_ 0 1 C 4 \ (u0 :: Integer) -> case u0 of { _ALG_ J# (u1 :: Int#) (u2 :: Int#) (u3 :: ByteArray#) -> case _#_ integer2Int# [] [u1, u2, u3] of { _PRIM_ (u4 :: Int#) -> _!_ I# [] [u4] }; _NO_DEFLT_ } _N_ #-}
+ quot = { _A_ 2 _U_ 11 _N_ _S_ "U(PPP)U(PPP)" {_A_ 4 _U_ 2221 _N_ _N_ _F_ _IF_ARGS_ 0 4 XXXX 7 \ (u0 :: Int#) (u1 :: Int#) (u2 :: ByteArray#) (u3 :: Integer) -> case _APP_ _WRKR_ _CONSTM_ Integral quotRem (Integer) [ u0, u1, u2, u3 ] of { _ALG_ _TUP_2 (u4 :: Integer) (u5 :: Integer) -> u4; _NO_DEFLT_ } _N_} _F_ _IF_ARGS_ 0 2 XX 5 \ (u0 :: Integer) (u1 :: Integer) -> case _APP_ _CONSTM_ Integral quotRem (Integer) [ u0, u1 ] of { _ALG_ _TUP_2 (u2 :: Integer) (u3 :: Integer) -> u2; _NO_DEFLT_ } _N_ },
+ rem = { _A_ 2 _U_ 11 _N_ _S_ "U(PPP)U(PPP)" {_A_ 4 _U_ 2221 _N_ _N_ _F_ _IF_ARGS_ 0 4 XXXX 7 \ (u0 :: Int#) (u1 :: Int#) (u2 :: ByteArray#) (u3 :: Integer) -> case _APP_ _WRKR_ _CONSTM_ Integral quotRem (Integer) [ u0, u1, u2, u3 ] of { _ALG_ _TUP_2 (u4 :: Integer) (u5 :: Integer) -> u5; _NO_DEFLT_ } _N_} _F_ _IF_ARGS_ 0 2 XX 5 \ (u0 :: Integer) (u1 :: Integer) -> case _APP_ _CONSTM_ Integral quotRem (Integer) [ u0, u1 ] of { _ALG_ _TUP_2 (u2 :: Integer) (u3 :: Integer) -> u3; _NO_DEFLT_ } _N_ },
+ div = { _A_ 2 _U_ 12 _N_ _S_ "U(PPP)U(PPP)" {_A_ 4 _U_ 2222 _N_ _N_ _F_ _IF_ARGS_ 0 4 XXXX 7 \ (u0 :: Int#) (u1 :: Int#) (u2 :: ByteArray#) (u3 :: Integer) -> case _APP_ _WRKR_ _CONSTM_ Integral divMod (Integer) [ u0, u1, u2, u3 ] of { _ALG_ _TUP_2 (u4 :: Integer) (u5 :: Integer) -> u4; _NO_DEFLT_ } _N_} _F_ _IF_ARGS_ 0 2 XX 5 \ (u0 :: Integer) (u1 :: Integer) -> case _APP_ _CONSTM_ Integral divMod (Integer) [ u0, u1 ] of { _ALG_ _TUP_2 (u2 :: Integer) (u3 :: Integer) -> u2; _NO_DEFLT_ } _N_ },
+ mod = { _A_ 2 _U_ 12 _N_ _S_ "U(PPP)U(PPP)" {_A_ 4 _U_ 2222 _N_ _N_ _F_ _IF_ARGS_ 0 4 XXXX 7 \ (u0 :: Int#) (u1 :: Int#) (u2 :: ByteArray#) (u3 :: Integer) -> case _APP_ _WRKR_ _CONSTM_ Integral divMod (Integer) [ u0, u1, u2, u3 ] of { _ALG_ _TUP_2 (u4 :: Integer) (u5 :: Integer) -> u5; _NO_DEFLT_ } _N_} _F_ _IF_ARGS_ 0 2 XX 5 \ (u0 :: Integer) (u1 :: Integer) -> case _APP_ _CONSTM_ Integral divMod (Integer) [ u0, u1 ] of { _ALG_ _TUP_2 (u2 :: Integer) (u3 :: Integer) -> u3; _NO_DEFLT_ } _N_ },
+ quotRem = { _A_ 2 _U_ 11 _N_ _S_ "U(PPP)U(PPP)" {_A_ 4 _U_ 2221 _N_ _N_ _N_ _N_} _N_ _N_ },
+ divMod = { _A_ 2 _U_ 12 _N_ _S_ "U(PPP)U(PPP)" {_A_ 4 _U_ 2222 _N_ _N_ _N_ _N_} _N_ _N_ },
+ even = { _A_ 1 _U_ 1 _N_ _S_ "U(PPP)" {_A_ 3 _U_ 222 _N_ _N_ _N_ _N_} _N_ _N_ },
+ odd = { _A_ 1 _U_ 1 _N_ _S_ "U(PPP)" {_A_ 3 _U_ 222 _N_ _N_ _N_ _N_} _N_ _N_ },
+ toInteger = { _A_ 1 _U_ 1 _N_ _S_ "U(PPP)" {_A_ 3 _U_ 222 _N_ _N_ _F_ _IF_ARGS_ 0 3 XXX 4 \ (u0 :: Int#) (u1 :: Int#) (u2 :: ByteArray#) -> _!_ J# [] [u0, u1, u2] _N_} _F_ _IF_ARGS_ 0 1 X 1 \ (u0 :: Integer) -> u0 _N_ },
+ toInt = { _A_ 1 _U_ 1 _N_ _S_ "U(PPP)" {_A_ 3 _U_ 222 _N_ _N_ _F_ _IF_ARGS_ 0 3 XXX 3 \ (u0 :: Int#) (u1 :: Int#) (u2 :: ByteArray#) -> case _#_ integer2Int# [] [u0, u1, u2] of { _PRIM_ (u3 :: Int#) -> _!_ I# [] [u3] } _N_} _F_ _IF_ARGS_ 0 1 C 4 \ (u0 :: Integer) -> case u0 of { _ALG_ J# (u1 :: Int#) (u2 :: Int#) (u3 :: ByteArray#) -> case _#_ integer2Int# [] [u1, u2, u3] of { _PRIM_ (u4 :: Int#) -> _!_ I# [] [u4] }; _NO_DEFLT_ } _N_ } #-}
instance Ix ()
{-# GHC_PRAGMA _M_ PreludeBuiltin {-dfun-} _A_ 0 _N_ _N_ _N_ _F_ _IF_ARGS_ 0 0 X 5 _!_ _TUP_4 [{{Ord ()}}, (((), ()) -> [()]), (((), ()) -> () -> Int), (((), ()) -> () -> Bool)] [_DFUN_ Ord (()), _CONSTM_ Ix range (()), _CONSTM_ Ix index (()), _CONSTM_ Ix inRange (())] _N_
- range = _A_ 1 _U_ 1 _N_ _S_ "U(EE)" {_A_ 2 _U_ 21 _N_ _N_ _N_ _N_} _N_ _N_,
- index = _A_ 2 _U_ 11 _N_ _S_ "U(EE)E" {_A_ 3 _U_ 111 _N_ _N_ _F_ _IF_ARGS_ 0 3 CCC 5 \ (u0 :: ()) (u1 :: ()) (u2 :: ()) -> case u0 of { _ALG_ _TUP_0 -> case u1 of { _ALG_ _TUP_0 -> case u2 of { _ALG_ _TUP_0 -> _!_ I# [] [0#]; _NO_DEFLT_ }; _NO_DEFLT_ }; _NO_DEFLT_ } _N_} _F_ _IF_ARGS_ 0 2 CC 6 \ (u0 :: ((), ())) (u1 :: ()) -> case u0 of { _ALG_ _TUP_2 (u2 :: ()) (u3 :: ()) -> case u2 of { _ALG_ _TUP_0 -> case u3 of { _ALG_ _TUP_0 -> case u1 of { _ALG_ _TUP_0 -> _!_ I# [] [0#]; _NO_DEFLT_ }; _NO_DEFLT_ }; _NO_DEFLT_ }; _NO_DEFLT_ } _N_,
- inRange = _A_ 2 _U_ 11 _N_ _S_ "U(EE)E" {_A_ 3 _U_ 111 _N_ _N_ _F_ _IF_ARGS_ 0 3 CCC 4 \ (u0 :: ()) (u1 :: ()) (u2 :: ()) -> case u0 of { _ALG_ _TUP_0 -> case u1 of { _ALG_ _TUP_0 -> case u2 of { _ALG_ _TUP_0 -> _!_ True [] []; _NO_DEFLT_ }; _NO_DEFLT_ }; _NO_DEFLT_ } _N_} _F_ _IF_ARGS_ 0 2 CC 5 \ (u0 :: ((), ())) (u1 :: ()) -> case u0 of { _ALG_ _TUP_2 (u2 :: ()) (u3 :: ()) -> case u2 of { _ALG_ _TUP_0 -> case u3 of { _ALG_ _TUP_0 -> case u1 of { _ALG_ _TUP_0 -> _!_ True [] []; _NO_DEFLT_ }; _NO_DEFLT_ }; _NO_DEFLT_ }; _NO_DEFLT_ } _N_ #-}
+ range = { _A_ 1 _U_ 1 _N_ _S_ "U(EE)" {_A_ 2 _U_ 21 _N_ _N_ _N_ _N_} _N_ _N_ },
+ index = { _A_ 2 _U_ 11 _N_ _S_ "U(EE)E" {_A_ 3 _U_ 111 _N_ _N_ _F_ _IF_ARGS_ 0 3 CCC 5 \ (u0 :: ()) (u1 :: ()) (u2 :: ()) -> case u0 of { _ALG_ _TUP_0 -> case u1 of { _ALG_ _TUP_0 -> case u2 of { _ALG_ _TUP_0 -> _!_ I# [] [0#]; _NO_DEFLT_ }; _NO_DEFLT_ }; _NO_DEFLT_ } _N_} _F_ _IF_ARGS_ 0 2 CC 6 \ (u0 :: ((), ())) (u1 :: ()) -> case u0 of { _ALG_ _TUP_2 (u2 :: ()) (u3 :: ()) -> case u2 of { _ALG_ _TUP_0 -> case u3 of { _ALG_ _TUP_0 -> case u1 of { _ALG_ _TUP_0 -> _!_ I# [] [0#]; _NO_DEFLT_ }; _NO_DEFLT_ }; _NO_DEFLT_ }; _NO_DEFLT_ } _N_ },
+ inRange = { _A_ 2 _U_ 11 _N_ _S_ "U(EE)E" {_A_ 3 _U_ 111 _N_ _N_ _F_ _IF_ARGS_ 0 3 CCC 4 \ (u0 :: ()) (u1 :: ()) (u2 :: ()) -> case u0 of { _ALG_ _TUP_0 -> case u1 of { _ALG_ _TUP_0 -> case u2 of { _ALG_ _TUP_0 -> _!_ True [] []; _NO_DEFLT_ }; _NO_DEFLT_ }; _NO_DEFLT_ } _N_} _F_ _IF_ARGS_ 0 2 CC 5 \ (u0 :: ((), ())) (u1 :: ()) -> case u0 of { _ALG_ _TUP_2 (u2 :: ()) (u3 :: ()) -> case u2 of { _ALG_ _TUP_0 -> case u3 of { _ALG_ _TUP_0 -> case u1 of { _ALG_ _TUP_0 -> _!_ True [] []; _NO_DEFLT_ }; _NO_DEFLT_ }; _NO_DEFLT_ }; _NO_DEFLT_ } _N_ } #-}
instance (Ix a, Ix b) => Ix (a, b)
{-# GHC_PRAGMA _M_ PreludeBuiltin {-dfun-} _A_ 3 _U_ 222 _N_ _N_ _N_ _N_ #-}
instance (Ix a, Ix b, Ix c) => Ix (a, b, c)
{-# GHC_PRAGMA _M_ PreludeBuiltin {-dfun-} _A_ 6 _U_ 222222 _N_ _N_ _N_ _N_ #-}
instance Ix (Int, Int)
{-# GHC_PRAGMA _M_ PreludeBuiltin {-dfun-} _A_ 0 _N_ _N_ _N_ _F_ _IF_ARGS_ 0 0 X 5 _!_ _TUP_4 [{{Ord (Int, Int)}}, (((Int, Int), (Int, Int)) -> [(Int, Int)]), (((Int, Int), (Int, Int)) -> (Int, Int) -> Int), (((Int, Int), (Int, Int)) -> (Int, Int) -> Bool)] [_DFUN_ Ord ((Int, Int)), _CONSTM_ Ix range ((Int, Int)), _CONSTM_ Ix index ((Int, Int)), _CONSTM_ Ix inRange ((Int, Int))] _N_
- range = _A_ 1 _U_ 1 _N_ _S_ "U(SS)" {_A_ 2 _U_ 11 _N_ _N_ _N_ _N_} _N_ _N_,
- index = _A_ 2 _U_ 11 _N_ _S_ "U(SS)U(U(P)U(P))" {_A_ 4 _U_ 1122 _N_ _N_ _N_ _N_} _N_ _N_,
- inRange = _A_ 2 _U_ 11 _N_ _S_ "U(SS)U(U(P)L)" {_A_ 4 _U_ 1121 _N_ _N_ _N_ _N_} _N_ _N_ #-}
+ range = { _A_ 1 _U_ 1 _N_ _S_ "U(SS)" {_A_ 2 _U_ 11 _N_ _N_ _N_ _N_} _N_ _N_ },
+ index = { _A_ 2 _U_ 11 _N_ _S_ "U(SS)U(U(P)U(P))" {_A_ 4 _U_ 1122 _N_ _N_ _N_ _N_} _N_ _N_ },
+ inRange = { _A_ 2 _U_ 11 _N_ _S_ "U(SS)U(U(P)L)" {_A_ 4 _U_ 1121 _N_ _N_ _N_ _N_} _N_ _N_ } #-}
instance (Ix a, Ix b) => Ix (Assoc a b)
{-# GHC_PRAGMA _M_ PreludeArray {-dfun-} _A_ 3 _U_ 222 _N_ _N_ _N_ _N_ #-}
instance Ix Bool
{-# GHC_PRAGMA _M_ PreludeCore {-dfun-} _A_ 0 _N_ _N_ _N_ _F_ _IF_ARGS_ 0 0 X 5 _!_ _TUP_4 [{{Ord Bool}}, ((Bool, Bool) -> [Bool]), ((Bool, Bool) -> Bool -> Int), ((Bool, Bool) -> Bool -> Bool)] [_DFUN_ Ord (Bool), _CONSTM_ Ix range (Bool), _CONSTM_ Ix index (Bool), _CONSTM_ Ix inRange (Bool)] _N_
- range = _A_ 1 _U_ 1 _N_ _S_ "U(EE)" {_A_ 2 _U_ 11 _N_ _N_ _N_ _N_} _N_ _N_,
- index = _A_ 2 _U_ 11 _N_ _S_ "U(EA)E" {_A_ 2 _U_ 11 _N_ _N_ _N_ _N_} _N_ _N_,
- inRange = _A_ 2 _U_ 12 _N_ _S_ "U(EL)E" {_A_ 3 _U_ 112 _N_ _N_ _N_ _N_} _N_ _N_ #-}
+ range = { _A_ 1 _U_ 1 _N_ _S_ "U(EE)" {_A_ 2 _U_ 11 _N_ _N_ _N_ _N_} _N_ _N_ },
+ index = { _A_ 2 _U_ 11 _N_ _S_ "U(EA)E" {_A_ 2 _U_ 11 _N_ _N_ _N_ _N_} _N_ _N_ },
+ inRange = { _A_ 2 _U_ 12 _N_ _S_ "U(EL)E" {_A_ 3 _U_ 112 _N_ _N_ _N_ _N_} _N_ _N_ } #-}
instance Ix Char
{-# GHC_PRAGMA _M_ PreludeCore {-dfun-} _A_ 0 _N_ _N_ _N_ _F_ _IF_ARGS_ 0 0 X 5 _!_ _TUP_4 [{{Ord Char}}, ((Char, Char) -> [Char]), ((Char, Char) -> Char -> Int), ((Char, Char) -> Char -> Bool)] [_DFUN_ Ord (Char), _CONSTM_ Ix range (Char), _CONSTM_ Ix index (Char), _CONSTM_ Ix inRange (Char)] _N_
- range = _A_ 1 _U_ 1 _N_ _S_ "U(LL)" {_A_ 2 _U_ 22 _N_ _N_ _F_ _IF_ARGS_ 0 0 X 1 _CONSTM_ Enum enumFromTo (Char) _N_} _F_ _IF_ARGS_ 0 1 C 4 \ (u0 :: (Char, Char)) -> case u0 of { _ALG_ _TUP_2 (u1 :: Char) (u2 :: Char) -> _APP_ _CONSTM_ Enum enumFromTo (Char) [ u1, u2 ]; _NO_DEFLT_ } _N_,
- index = _A_ 2 _U_ 11 _N_ _S_ "U(U(P)L)U(P)" {_A_ 3 _U_ 212 _N_ _N_ _N_ _N_} _N_ _N_,
- inRange = _A_ 2 _U_ 11 _N_ _S_ "U(U(P)L)U(P)" {_A_ 3 _U_ 212 _N_ _N_ _N_ _N_} _N_ _N_ #-}
+ range = { _A_ 1 _U_ 1 _N_ _S_ "U(U(P)L)" {_A_ 2 _U_ 22 _N_ _N_ _N_ _N_} _F_ _IF_ARGS_ 0 1 C 4 \ (u0 :: (Char, Char)) -> case u0 of { _ALG_ _TUP_2 (u1 :: Char) (u2 :: Char) -> _APP_ _CONSTM_ Enum enumFromTo (Char) [ u1, u2 ]; _NO_DEFLT_ } _N_ },
+ index = { _A_ 2 _U_ 11 _N_ _S_ "U(U(P)L)U(P)" {_A_ 3 _U_ 212 _N_ _N_ _N_ _N_} _N_ _N_ },
+ inRange = { _A_ 2 _U_ 11 _N_ _S_ "U(U(P)L)U(P)" {_A_ 3 _U_ 212 _N_ _N_ _N_ _N_} _N_ _N_ } #-}
instance Ix Int
{-# GHC_PRAGMA _M_ PreludeCore {-dfun-} _A_ 0 _N_ _N_ _N_ _F_ _IF_ARGS_ 0 0 X 5 _!_ _TUP_4 [{{Ord Int}}, ((Int, Int) -> [Int]), ((Int, Int) -> Int -> Int), ((Int, Int) -> Int -> Bool)] [_DFUN_ Ord (Int), _CONSTM_ Ix range (Int), _CONSTM_ Ix index (Int), _CONSTM_ Ix inRange (Int)] _N_
- range = _A_ 1 _U_ 1 _N_ _S_ "U(U(P)U(P))" {_A_ 2 _U_ 22 _N_ _N_ _N_ _N_} _N_ _N_,
- index = _A_ 2 _U_ 11 _N_ _S_ "U(U(P)U(P))U(P)" {_A_ 3 _U_ 222 _N_ _N_ _N_ _N_} _N_ _N_,
- inRange = _A_ 2 _U_ 11 _N_ _S_ "U(U(P)U(P))U(P)" {_A_ 3 _U_ 222 _N_ _N_ _F_ _IF_ARGS_ 0 3 XXX 5 \ (u0 :: Int#) (u1 :: Int#) (u2 :: Int#) -> case _#_ leInt# [] [u0, u2] of { _ALG_ True -> _#_ leInt# [] [u2, u1]; False -> _!_ False [] []; _NO_DEFLT_ } _N_} _F_ _ALWAYS_ \ (u0 :: (Int, Int)) (u1 :: Int) -> case u0 of { _ALG_ _TUP_2 (u2 :: Int) (u3 :: Int) -> case u2 of { _ALG_ I# (u4 :: Int#) -> case u3 of { _ALG_ I# (u5 :: Int#) -> case u1 of { _ALG_ I# (u6 :: Int#) -> case _#_ leInt# [] [u4, u6] of { _ALG_ True -> _#_ leInt# [] [u6, u5]; False -> _!_ False [] []; _NO_DEFLT_ }; _NO_DEFLT_ }; _NO_DEFLT_ }; _NO_DEFLT_ }; _NO_DEFLT_ } _N_ #-}
+ range = { _A_ 1 _U_ 1 _N_ _S_ "U(U(P)U(P))" {_A_ 2 _U_ 22 _N_ _N_ _N_ _N_} _N_ _N_ },
+ index = { _A_ 2 _U_ 11 _N_ _S_ "U(U(P)U(P))U(P)" {_A_ 3 _U_ 222 _N_ _N_ _N_ _N_} _N_ _N_ },
+ inRange = { _A_ 2 _U_ 11 _N_ _S_ "U(U(P)U(P))U(P)" {_A_ 3 _U_ 222 _N_ _N_ _F_ _IF_ARGS_ 0 3 XXX 5 \ (u0 :: Int#) (u1 :: Int#) (u2 :: Int#) -> case _#_ leInt# [] [u0, u2] of { _ALG_ True -> _#_ leInt# [] [u2, u1]; False -> _!_ False [] []; _NO_DEFLT_ } _N_} _F_ _ALWAYS_ \ (u0 :: (Int, Int)) (u1 :: Int) -> case u0 of { _ALG_ _TUP_2 (u2 :: Int) (u3 :: Int) -> case u2 of { _ALG_ I# (u4 :: Int#) -> case u3 of { _ALG_ I# (u5 :: Int#) -> case u1 of { _ALG_ I# (u6 :: Int#) -> case _#_ leInt# [] [u4, u6] of { _ALG_ True -> _#_ leInt# [] [u6, u5]; False -> _!_ False [] []; _NO_DEFLT_ }; _NO_DEFLT_ }; _NO_DEFLT_ }; _NO_DEFLT_ }; _NO_DEFLT_ } _N_ } #-}
instance Ix Integer
{-# GHC_PRAGMA _M_ PreludeCore {-dfun-} _A_ 0 _N_ _N_ _N_ _F_ _IF_ARGS_ 0 0 X 5 _!_ _TUP_4 [{{Ord Integer}}, ((Integer, Integer) -> [Integer]), ((Integer, Integer) -> Integer -> Int), ((Integer, Integer) -> Integer -> Bool)] [_DFUN_ Ord (Integer), _CONSTM_ Ix range (Integer), _CONSTM_ Ix index (Integer), _CONSTM_ Ix inRange (Integer)] _N_
- range = _A_ 1 _U_ 1 _N_ _S_ "U(LL)" {_A_ 2 _U_ 22 _N_ _N_ _F_ _IF_ARGS_ 0 0 X 1 _CONSTM_ Enum enumFromTo (Integer) _N_} _F_ _IF_ARGS_ 0 1 C 4 \ (u0 :: (Integer, Integer)) -> case u0 of { _ALG_ _TUP_2 (u1 :: Integer) (u2 :: Integer) -> _APP_ _CONSTM_ Enum enumFromTo (Integer) [ u1, u2 ]; _NO_DEFLT_ } _N_,
- index = _A_ 2 _U_ 12 _N_ _S_ "U(U(PPP)L)U(PPP)" {_A_ 5 _U_ 22222 _N_ _N_ _N_ _N_} _N_ _N_,
- inRange = _A_ 2 _U_ 11 _N_ _S_ "U(U(PPP)L)U(PPP)" {_A_ 5 _U_ 22211 _N_ _N_ _F_ _IF_ARGS_ 0 5 XXXCC 9 \ (u0 :: Int#) (u1 :: Int#) (u2 :: ByteArray#) (u3 :: Integer) (u4 :: Integer) -> case u4 of { _ALG_ J# (u5 :: Int#) (u6 :: Int#) (u7 :: ByteArray#) -> case _#_ cmpInteger# [] [u0, u1, u2, u5, u6, u7] of { _PRIM_ (u8 :: Int#) -> case _#_ leInt# [] [u8, 0#] of { _ALG_ True -> case u3 of { _ALG_ J# (u9 :: Int#) (ua :: Int#) (ub :: ByteArray#) -> case _#_ cmpInteger# [] [u5, u6, u7, u9, ua, ub] of { _PRIM_ (uc :: Int#) -> _#_ leInt# [] [uc, 0#] }; _NO_DEFLT_ }; False -> _!_ False [] []; _NO_DEFLT_ } }; _NO_DEFLT_ } _N_} _N_ _N_ #-}
+ range = { _A_ 1 _U_ 1 _N_ _S_ "U(LL)" {_A_ 2 _U_ 22 _N_ _N_ _F_ _IF_ARGS_ 0 0 X 1 _CONSTM_ Enum enumFromTo (Integer) _N_} _F_ _IF_ARGS_ 0 1 C 4 \ (u0 :: (Integer, Integer)) -> case u0 of { _ALG_ _TUP_2 (u1 :: Integer) (u2 :: Integer) -> _APP_ _CONSTM_ Enum enumFromTo (Integer) [ u1, u2 ]; _NO_DEFLT_ } _N_ },
+ index = { _A_ 2 _U_ 12 _N_ _S_ "U(U(PPP)L)U(PPP)" {_A_ 5 _U_ 22222 _N_ _N_ _N_ _N_} _N_ _N_ },
+ inRange = { _A_ 2 _U_ 11 _N_ _S_ "U(U(PPP)L)U(PPP)" {_A_ 5 _U_ 22211 _N_ _N_ _F_ _IF_ARGS_ 0 5 XXXCC 9 \ (u0 :: Int#) (u1 :: Int#) (u2 :: ByteArray#) (u3 :: Integer) (u4 :: Integer) -> case u4 of { _ALG_ J# (u5 :: Int#) (u6 :: Int#) (u7 :: ByteArray#) -> case _#_ cmpInteger# [] [u0, u1, u2, u5, u6, u7] of { _PRIM_ (u8 :: Int#) -> case _#_ leInt# [] [u8, 0#] of { _ALG_ True -> case u3 of { _ALG_ J# (u9 :: Int#) (ua :: Int#) (ub :: ByteArray#) -> case _#_ cmpInteger# [] [u5, u6, u7, u9, ua, ub] of { _PRIM_ (uc :: Int#) -> _#_ leInt# [] [uc, 0#] }; _NO_DEFLT_ }; False -> _!_ False [] []; _NO_DEFLT_ } }; _NO_DEFLT_ } _N_} _N_ _N_ } #-}
instance RealFloat a => Num (Complex a)
{-# GHC_PRAGMA _M_ PreludeComplex {-dfun-} _A_ 3 _U_ 222 _N_ _N_ _N_ _N_ #-}
instance Num (Complex Double)
- {-# GHC_PRAGMA _M_ PreludeComplex {-dfun-} _A_ 0 _N_ _N_ _N_ _N_ _N_
- (+) = _A_ 2 _U_ 11 _N_ _S_ "U(LL)U(LL)" {_A_ 4 _U_ 1111 _N_ _N_ _N_ _N_} _N_ _N_,
- (-) = _A_ 2 _U_ 11 _N_ _S_ "U(LL)U(LL)" {_A_ 4 _U_ 1111 _N_ _N_ _N_ _N_} _N_ _N_,
- (*) = _A_ 2 _U_ 11 _N_ _S_ "U(LL)U(LL)" {_A_ 4 _U_ 2222 _N_ _N_ _N_ _N_} _N_ _N_,
- negate = _A_ 1 _U_ 1 _N_ _S_ "U(LL)" {_A_ 2 _U_ 11 _N_ _N_ _N_ _N_} _N_ _N_,
- abs = _A_ 1 _U_ 1 _N_ _N_ _N_ _N_,
- signum = _A_ 1 _U_ 1 _N_ _S_ "U(U(P)L)" {_A_ 2 _U_ 22 _N_ _N_ _N_ _N_} _N_ _N_,
- fromInteger = _A_ 1 _U_ 1 _N_ _N_ _N_ _N_,
- fromInt = _A_ 1 _U_ 1 _N_ _N_ _N_ _N_ #-}
+ {-# GHC_PRAGMA _M_ PreludeComplex {-dfun-} _A_ 0 _N_ _N_ _N_ _F_ _IF_ARGS_ 0 0 X 11 _!_ _TUP_10 [{{Eq (Complex Double)}}, {{Text (Complex Double)}}, (Complex Double -> Complex Double -> Complex Double), (Complex Double -> Complex Double -> Complex Double), (Complex Double -> Complex Double -> Complex Double), (Complex Double -> Complex Double), (Complex Double -> Complex Double), (Complex Double -> Complex Double), (Integer -> Complex Double), (Int -> Complex Double)] [_DFUN_ Eq (Complex Double), _DFUN_ Text (Complex Double), _CONSTM_ Num (+) (Complex Double), _CONSTM_ Num (-) (Complex Double), _CONSTM_ Num (*) (Complex Double), _CONSTM_ Num negate (Complex Double), _CONSTM_ Num abs (Complex Double), _CONSTM_ Num signum (Complex Double), _CONSTM_ Num fromInteger (Complex Double), _CONSTM_ Num fromInt (Complex Double)] _N_
+ (+) = { _A_ 2 _U_ 11 _N_ _S_ "U(LL)U(LL)" {_A_ 4 _U_ 1111 _N_ _N_ _N_ _N_} _N_ _N_ },
+ (-) = { _A_ 2 _U_ 11 _N_ _S_ "U(LL)U(LL)" {_A_ 4 _U_ 1111 _N_ _N_ _N_ _N_} _N_ _N_ },
+ (*) = { _A_ 2 _U_ 11 _N_ _S_ "U(LL)U(LL)" {_A_ 4 _U_ 2222 _N_ _N_ _N_ _N_} _N_ _N_ },
+ negate = { _A_ 1 _U_ 1 _N_ _S_ "U(LL)" {_A_ 2 _U_ 11 _N_ _N_ _N_ _N_} _N_ _N_ },
+ abs = { _A_ 1 _U_ 1 _N_ _N_ _N_ _N_ },
+ signum = { _A_ 1 _U_ 1 _N_ _S_ "U(U(P)L)" {_A_ 2 _U_ 22 _N_ _N_ _N_ _N_} _N_ _N_ },
+ fromInteger = { _A_ 1 _U_ 1 _N_ _N_ _N_ _N_ },
+ fromInt = { _A_ 1 _U_ 1 _N_ _N_ _N_ _N_ } #-}
instance Num Double
{-# GHC_PRAGMA _M_ PreludeCore {-dfun-} _A_ 0 _N_ _N_ _N_ _F_ _IF_ARGS_ 0 0 X 11 _!_ _TUP_10 [{{Eq Double}}, {{Text Double}}, (Double -> Double -> Double), (Double -> Double -> Double), (Double -> Double -> Double), (Double -> Double), (Double -> Double), (Double -> Double), (Integer -> Double), (Int -> Double)] [_DFUN_ Eq (Double), _DFUN_ Text (Double), _CONSTM_ Num (+) (Double), _CONSTM_ Num (-) (Double), _CONSTM_ Num (*) (Double), _CONSTM_ Num negate (Double), _CONSTM_ Num abs (Double), _CONSTM_ Num signum (Double), _CONSTM_ Num fromInteger (Double), _CONSTM_ Num fromInt (Double)] _N_
- (+) = _A_ 2 _U_ 11 _N_ _S_ "U(P)U(P)" {_A_ 2 _U_ 22 _N_ _N_ _F_ _IF_ARGS_ 0 2 XX 3 \ (u0 :: Double#) (u1 :: Double#) -> case _#_ plusDouble# [] [u0, u1] of { _PRIM_ (u2 :: Double#) -> _!_ D# [] [u2] } _N_} _F_ _IF_ARGS_ 0 2 CC 5 \ (u0 :: Double) (u1 :: Double) -> case u0 of { _ALG_ D# (u2 :: Double#) -> case u1 of { _ALG_ D# (u3 :: Double#) -> case _#_ plusDouble# [] [u2, u3] of { _PRIM_ (u4 :: Double#) -> _!_ D# [] [u4] }; _NO_DEFLT_ }; _NO_DEFLT_ } _N_,
- (-) = _A_ 2 _U_ 11 _N_ _S_ "U(P)U(P)" {_A_ 2 _U_ 22 _N_ _N_ _F_ _IF_ARGS_ 0 2 XX 3 \ (u0 :: Double#) (u1 :: Double#) -> case _#_ minusDouble# [] [u0, u1] of { _PRIM_ (u2 :: Double#) -> _!_ D# [] [u2] } _N_} _F_ _IF_ARGS_ 0 2 CC 5 \ (u0 :: Double) (u1 :: Double) -> case u0 of { _ALG_ D# (u2 :: Double#) -> case u1 of { _ALG_ D# (u3 :: Double#) -> case _#_ minusDouble# [] [u2, u3] of { _PRIM_ (u4 :: Double#) -> _!_ D# [] [u4] }; _NO_DEFLT_ }; _NO_DEFLT_ } _N_,
- (*) = _A_ 2 _U_ 11 _N_ _S_ "U(P)U(P)" {_A_ 2 _U_ 22 _N_ _N_ _F_ _IF_ARGS_ 0 2 XX 3 \ (u0 :: Double#) (u1 :: Double#) -> case _#_ timesDouble# [] [u0, u1] of { _PRIM_ (u2 :: Double#) -> _!_ D# [] [u2] } _N_} _F_ _IF_ARGS_ 0 2 CC 5 \ (u0 :: Double) (u1 :: Double) -> case u0 of { _ALG_ D# (u2 :: Double#) -> case u1 of { _ALG_ D# (u3 :: Double#) -> case _#_ timesDouble# [] [u2, u3] of { _PRIM_ (u4 :: Double#) -> _!_ D# [] [u4] }; _NO_DEFLT_ }; _NO_DEFLT_ } _N_,
- negate = _A_ 1 _U_ 1 _N_ _S_ "U(P)" {_A_ 1 _U_ 2 _N_ _N_ _F_ _IF_ARGS_ 0 1 X 3 \ (u0 :: Double#) -> case _#_ negateDouble# [] [u0] of { _PRIM_ (u1 :: Double#) -> _!_ D# [] [u1] } _N_} _F_ _IF_ARGS_ 0 1 C 4 \ (u0 :: Double) -> case u0 of { _ALG_ D# (u1 :: Double#) -> case _#_ negateDouble# [] [u1] of { _PRIM_ (u2 :: Double#) -> _!_ D# [] [u2] }; _NO_DEFLT_ } _N_,
- abs = _A_ 1 _U_ 1 _N_ _S_ "U(P)" {_A_ 1 _U_ 2 _N_ _N_ _N_ _N_} _N_ _N_,
- signum = _A_ 1 _U_ 1 _N_ _S_ "U(P)" {_A_ 1 _U_ 2 _N_ _N_ _N_ _N_} _N_ _N_,
- fromInteger = _A_ 1 _U_ 1 _N_ _S_ "U(PPP)" {_A_ 3 _U_ 222 _N_ _N_ _F_ _IF_ARGS_ 0 3 XXX 3 \ (u0 :: Int#) (u1 :: Int#) (u2 :: ByteArray#) -> case _#_ encodeDouble# [] [u0, u1, u2, 0#] of { _PRIM_ (u3 :: Double#) -> _!_ D# [] [u3] } _N_} _F_ _IF_ARGS_ 0 1 C 4 \ (u0 :: Integer) -> case u0 of { _ALG_ J# (u1 :: Int#) (u2 :: Int#) (u3 :: ByteArray#) -> case _#_ encodeDouble# [] [u1, u2, u3, 0#] of { _PRIM_ (u4 :: Double#) -> _!_ D# [] [u4] }; _NO_DEFLT_ } _N_,
- fromInt = _A_ 1 _U_ 1 _N_ _S_ "U(P)" {_A_ 1 _U_ 2 _N_ _N_ _F_ _IF_ARGS_ 0 1 X 3 \ (u0 :: Int#) -> case _#_ int2Double# [] [u0] of { _PRIM_ (u1 :: Double#) -> _!_ D# [] [u1] } _N_} _F_ _IF_ARGS_ 0 1 C 4 \ (u0 :: Int) -> case u0 of { _ALG_ I# (u1 :: Int#) -> case _#_ int2Double# [] [u1] of { _PRIM_ (u2 :: Double#) -> _!_ D# [] [u2] }; _NO_DEFLT_ } _N_ #-}
+ (+) = { _A_ 2 _U_ 11 _N_ _S_ "U(P)U(P)" {_A_ 2 _U_ 22 _N_ _N_ _F_ _IF_ARGS_ 0 2 XX 3 \ (u0 :: Double#) (u1 :: Double#) -> case _#_ plusDouble# [] [u0, u1] of { _PRIM_ (u2 :: Double#) -> _!_ D# [] [u2] } _N_} _F_ _IF_ARGS_ 0 2 CC 5 \ (u0 :: Double) (u1 :: Double) -> case u0 of { _ALG_ D# (u2 :: Double#) -> case u1 of { _ALG_ D# (u3 :: Double#) -> case _#_ plusDouble# [] [u2, u3] of { _PRIM_ (u4 :: Double#) -> _!_ D# [] [u4] }; _NO_DEFLT_ }; _NO_DEFLT_ } _N_ },
+ (-) = { _A_ 2 _U_ 11 _N_ _S_ "U(P)U(P)" {_A_ 2 _U_ 22 _N_ _N_ _F_ _IF_ARGS_ 0 2 XX 3 \ (u0 :: Double#) (u1 :: Double#) -> case _#_ minusDouble# [] [u0, u1] of { _PRIM_ (u2 :: Double#) -> _!_ D# [] [u2] } _N_} _F_ _IF_ARGS_ 0 2 CC 5 \ (u0 :: Double) (u1 :: Double) -> case u0 of { _ALG_ D# (u2 :: Double#) -> case u1 of { _ALG_ D# (u3 :: Double#) -> case _#_ minusDouble# [] [u2, u3] of { _PRIM_ (u4 :: Double#) -> _!_ D# [] [u4] }; _NO_DEFLT_ }; _NO_DEFLT_ } _N_ },
+ (*) = { _A_ 2 _U_ 11 _N_ _S_ "U(P)U(P)" {_A_ 2 _U_ 22 _N_ _N_ _F_ _IF_ARGS_ 0 2 XX 3 \ (u0 :: Double#) (u1 :: Double#) -> case _#_ timesDouble# [] [u0, u1] of { _PRIM_ (u2 :: Double#) -> _!_ D# [] [u2] } _N_} _F_ _IF_ARGS_ 0 2 CC 5 \ (u0 :: Double) (u1 :: Double) -> case u0 of { _ALG_ D# (u2 :: Double#) -> case u1 of { _ALG_ D# (u3 :: Double#) -> case _#_ timesDouble# [] [u2, u3] of { _PRIM_ (u4 :: Double#) -> _!_ D# [] [u4] }; _NO_DEFLT_ }; _NO_DEFLT_ } _N_ },
+ negate = { _A_ 1 _U_ 1 _N_ _S_ "U(P)" {_A_ 1 _U_ 2 _N_ _N_ _F_ _IF_ARGS_ 0 1 X 3 \ (u0 :: Double#) -> case _#_ negateDouble# [] [u0] of { _PRIM_ (u1 :: Double#) -> _!_ D# [] [u1] } _N_} _F_ _IF_ARGS_ 0 1 C 4 \ (u0 :: Double) -> case u0 of { _ALG_ D# (u1 :: Double#) -> case _#_ negateDouble# [] [u1] of { _PRIM_ (u2 :: Double#) -> _!_ D# [] [u2] }; _NO_DEFLT_ } _N_ },
+ abs = { _A_ 1 _U_ 1 _N_ _S_ "U(P)" {_A_ 1 _U_ 2 _N_ _N_ _N_ _N_} _N_ _N_ },
+ signum = { _A_ 1 _U_ 1 _N_ _S_ "U(P)" {_A_ 1 _U_ 2 _N_ _N_ _N_ _N_} _N_ _N_ },
+ fromInteger = { _A_ 1 _U_ 1 _N_ _S_ "U(PPP)" {_A_ 3 _U_ 222 _N_ _N_ _F_ _IF_ARGS_ 0 3 XXX 3 \ (u0 :: Int#) (u1 :: Int#) (u2 :: ByteArray#) -> case _#_ encodeDouble# [] [u0, u1, u2, 0#] of { _PRIM_ (u3 :: Double#) -> _!_ D# [] [u3] } _N_} _F_ _IF_ARGS_ 0 1 C 4 \ (u0 :: Integer) -> case u0 of { _ALG_ J# (u1 :: Int#) (u2 :: Int#) (u3 :: ByteArray#) -> case _#_ encodeDouble# [] [u1, u2, u3, 0#] of { _PRIM_ (u4 :: Double#) -> _!_ D# [] [u4] }; _NO_DEFLT_ } _N_ },
+ fromInt = { _A_ 1 _U_ 1 _N_ _S_ "U(P)" {_A_ 1 _U_ 2 _N_ _N_ _F_ _IF_ARGS_ 0 1 X 3 \ (u0 :: Int#) -> case _#_ int2Double# [] [u0] of { _PRIM_ (u1 :: Double#) -> _!_ D# [] [u1] } _N_} _F_ _IF_ARGS_ 0 1 C 4 \ (u0 :: Int) -> case u0 of { _ALG_ I# (u1 :: Int#) -> case _#_ int2Double# [] [u1] of { _PRIM_ (u2 :: Double#) -> _!_ D# [] [u2] }; _NO_DEFLT_ } _N_ } #-}
instance Num Float
{-# GHC_PRAGMA _M_ PreludeCore {-dfun-} _A_ 0 _N_ _N_ _N_ _F_ _IF_ARGS_ 0 0 X 11 _!_ _TUP_10 [{{Eq Float}}, {{Text Float}}, (Float -> Float -> Float), (Float -> Float -> Float), (Float -> Float -> Float), (Float -> Float), (Float -> Float), (Float -> Float), (Integer -> Float), (Int -> Float)] [_DFUN_ Eq (Float), _DFUN_ Text (Float), _CONSTM_ Num (+) (Float), _CONSTM_ Num (-) (Float), _CONSTM_ Num (*) (Float), _CONSTM_ Num negate (Float), _CONSTM_ Num abs (Float), _CONSTM_ Num signum (Float), _CONSTM_ Num fromInteger (Float), _CONSTM_ Num fromInt (Float)] _N_
- (+) = _A_ 2 _U_ 11 _N_ _S_ "U(P)U(P)" {_A_ 2 _U_ 22 _N_ _N_ _F_ _IF_ARGS_ 0 2 XX 3 \ (u0 :: Float#) (u1 :: Float#) -> case _#_ plusFloat# [] [u0, u1] of { _PRIM_ (u2 :: Float#) -> _!_ F# [] [u2] } _N_} _F_ _IF_ARGS_ 0 2 CC 5 \ (u0 :: Float) (u1 :: Float) -> case u0 of { _ALG_ F# (u2 :: Float#) -> case u1 of { _ALG_ F# (u3 :: Float#) -> case _#_ plusFloat# [] [u2, u3] of { _PRIM_ (u4 :: Float#) -> _!_ F# [] [u4] }; _NO_DEFLT_ }; _NO_DEFLT_ } _N_,
- (-) = _A_ 2 _U_ 11 _N_ _S_ "U(P)U(P)" {_A_ 2 _U_ 22 _N_ _N_ _F_ _IF_ARGS_ 0 2 XX 3 \ (u0 :: Float#) (u1 :: Float#) -> case _#_ minusFloat# [] [u0, u1] of { _PRIM_ (u2 :: Float#) -> _!_ F# [] [u2] } _N_} _F_ _IF_ARGS_ 0 2 CC 5 \ (u0 :: Float) (u1 :: Float) -> case u0 of { _ALG_ F# (u2 :: Float#) -> case u1 of { _ALG_ F# (u3 :: Float#) -> case _#_ minusFloat# [] [u2, u3] of { _PRIM_ (u4 :: Float#) -> _!_ F# [] [u4] }; _NO_DEFLT_ }; _NO_DEFLT_ } _N_,
- (*) = _A_ 2 _U_ 11 _N_ _S_ "U(P)U(P)" {_A_ 2 _U_ 22 _N_ _N_ _F_ _IF_ARGS_ 0 2 XX 3 \ (u0 :: Float#) (u1 :: Float#) -> case _#_ timesFloat# [] [u0, u1] of { _PRIM_ (u2 :: Float#) -> _!_ F# [] [u2] } _N_} _F_ _IF_ARGS_ 0 2 CC 5 \ (u0 :: Float) (u1 :: Float) -> case u0 of { _ALG_ F# (u2 :: Float#) -> case u1 of { _ALG_ F# (u3 :: Float#) -> case _#_ timesFloat# [] [u2, u3] of { _PRIM_ (u4 :: Float#) -> _!_ F# [] [u4] }; _NO_DEFLT_ }; _NO_DEFLT_ } _N_,
- negate = _A_ 1 _U_ 1 _N_ _S_ "U(P)" {_A_ 1 _U_ 2 _N_ _N_ _F_ _IF_ARGS_ 0 1 X 3 \ (u0 :: Float#) -> case _#_ negateFloat# [] [u0] of { _PRIM_ (u1 :: Float#) -> _!_ F# [] [u1] } _N_} _F_ _IF_ARGS_ 0 1 C 4 \ (u0 :: Float) -> case u0 of { _ALG_ F# (u1 :: Float#) -> case _#_ negateFloat# [] [u1] of { _PRIM_ (u2 :: Float#) -> _!_ F# [] [u2] }; _NO_DEFLT_ } _N_,
- abs = _A_ 1 _U_ 1 _N_ _S_ "U(P)" {_A_ 1 _U_ 2 _N_ _N_ _N_ _N_} _N_ _N_,
- signum = _A_ 1 _U_ 1 _N_ _S_ "U(P)" {_A_ 1 _U_ 2 _N_ _N_ _N_ _N_} _N_ _N_,
- fromInteger = _A_ 1 _U_ 1 _N_ _S_ "U(PPP)" {_A_ 3 _U_ 222 _N_ _N_ _F_ _IF_ARGS_ 0 3 XXX 3 \ (u0 :: Int#) (u1 :: Int#) (u2 :: ByteArray#) -> case _#_ encodeFloat# [] [u0, u1, u2, 0#] of { _PRIM_ (u3 :: Float#) -> _!_ F# [] [u3] } _N_} _F_ _IF_ARGS_ 0 1 C 4 \ (u0 :: Integer) -> case u0 of { _ALG_ J# (u1 :: Int#) (u2 :: Int#) (u3 :: ByteArray#) -> case _#_ encodeFloat# [] [u1, u2, u3, 0#] of { _PRIM_ (u4 :: Float#) -> _!_ F# [] [u4] }; _NO_DEFLT_ } _N_,
- fromInt = _A_ 1 _U_ 1 _N_ _S_ "U(P)" {_A_ 1 _U_ 2 _N_ _N_ _F_ _IF_ARGS_ 0 1 X 3 \ (u0 :: Int#) -> case _#_ int2Float# [] [u0] of { _PRIM_ (u1 :: Float#) -> _!_ F# [] [u1] } _N_} _F_ _IF_ARGS_ 0 1 C 4 \ (u0 :: Int) -> case u0 of { _ALG_ I# (u1 :: Int#) -> case _#_ int2Float# [] [u1] of { _PRIM_ (u2 :: Float#) -> _!_ F# [] [u2] }; _NO_DEFLT_ } _N_ #-}
+ (+) = { _A_ 2 _U_ 11 _N_ _S_ "U(P)U(P)" {_A_ 2 _U_ 22 _N_ _N_ _F_ _IF_ARGS_ 0 2 XX 3 \ (u0 :: Float#) (u1 :: Float#) -> case _#_ plusFloat# [] [u0, u1] of { _PRIM_ (u2 :: Float#) -> _!_ F# [] [u2] } _N_} _F_ _IF_ARGS_ 0 2 CC 5 \ (u0 :: Float) (u1 :: Float) -> case u0 of { _ALG_ F# (u2 :: Float#) -> case u1 of { _ALG_ F# (u3 :: Float#) -> case _#_ plusFloat# [] [u2, u3] of { _PRIM_ (u4 :: Float#) -> _!_ F# [] [u4] }; _NO_DEFLT_ }; _NO_DEFLT_ } _N_ },
+ (-) = { _A_ 2 _U_ 11 _N_ _S_ "U(P)U(P)" {_A_ 2 _U_ 22 _N_ _N_ _F_ _IF_ARGS_ 0 2 XX 3 \ (u0 :: Float#) (u1 :: Float#) -> case _#_ minusFloat# [] [u0, u1] of { _PRIM_ (u2 :: Float#) -> _!_ F# [] [u2] } _N_} _F_ _IF_ARGS_ 0 2 CC 5 \ (u0 :: Float) (u1 :: Float) -> case u0 of { _ALG_ F# (u2 :: Float#) -> case u1 of { _ALG_ F# (u3 :: Float#) -> case _#_ minusFloat# [] [u2, u3] of { _PRIM_ (u4 :: Float#) -> _!_ F# [] [u4] }; _NO_DEFLT_ }; _NO_DEFLT_ } _N_ },
+ (*) = { _A_ 2 _U_ 11 _N_ _S_ "U(P)U(P)" {_A_ 2 _U_ 22 _N_ _N_ _F_ _IF_ARGS_ 0 2 XX 3 \ (u0 :: Float#) (u1 :: Float#) -> case _#_ timesFloat# [] [u0, u1] of { _PRIM_ (u2 :: Float#) -> _!_ F# [] [u2] } _N_} _F_ _IF_ARGS_ 0 2 CC 5 \ (u0 :: Float) (u1 :: Float) -> case u0 of { _ALG_ F# (u2 :: Float#) -> case u1 of { _ALG_ F# (u3 :: Float#) -> case _#_ timesFloat# [] [u2, u3] of { _PRIM_ (u4 :: Float#) -> _!_ F# [] [u4] }; _NO_DEFLT_ }; _NO_DEFLT_ } _N_ },
+ negate = { _A_ 1 _U_ 1 _N_ _S_ "U(P)" {_A_ 1 _U_ 2 _N_ _N_ _F_ _IF_ARGS_ 0 1 X 3 \ (u0 :: Float#) -> case _#_ negateFloat# [] [u0] of { _PRIM_ (u1 :: Float#) -> _!_ F# [] [u1] } _N_} _F_ _IF_ARGS_ 0 1 C 4 \ (u0 :: Float) -> case u0 of { _ALG_ F# (u1 :: Float#) -> case _#_ negateFloat# [] [u1] of { _PRIM_ (u2 :: Float#) -> _!_ F# [] [u2] }; _NO_DEFLT_ } _N_ },
+ abs = { _A_ 1 _U_ 1 _N_ _S_ "U(P)" {_A_ 1 _U_ 2 _N_ _N_ _N_ _N_} _N_ _N_ },
+ signum = { _A_ 1 _U_ 1 _N_ _S_ "U(P)" {_A_ 1 _U_ 2 _N_ _N_ _N_ _N_} _N_ _N_ },
+ fromInteger = { _A_ 1 _U_ 1 _N_ _S_ "U(PPP)" {_A_ 3 _U_ 222 _N_ _N_ _F_ _IF_ARGS_ 0 3 XXX 3 \ (u0 :: Int#) (u1 :: Int#) (u2 :: ByteArray#) -> case _#_ encodeFloat# [] [u0, u1, u2, 0#] of { _PRIM_ (u3 :: Float#) -> _!_ F# [] [u3] } _N_} _F_ _IF_ARGS_ 0 1 C 4 \ (u0 :: Integer) -> case u0 of { _ALG_ J# (u1 :: Int#) (u2 :: Int#) (u3 :: ByteArray#) -> case _#_ encodeFloat# [] [u1, u2, u3, 0#] of { _PRIM_ (u4 :: Float#) -> _!_ F# [] [u4] }; _NO_DEFLT_ } _N_ },
+ fromInt = { _A_ 1 _U_ 1 _N_ _S_ "U(P)" {_A_ 1 _U_ 2 _N_ _N_ _F_ _IF_ARGS_ 0 1 X 3 \ (u0 :: Int#) -> case _#_ int2Float# [] [u0] of { _PRIM_ (u1 :: Float#) -> _!_ F# [] [u1] } _N_} _F_ _IF_ARGS_ 0 1 C 4 \ (u0 :: Int) -> case u0 of { _ALG_ I# (u1 :: Int#) -> case _#_ int2Float# [] [u1] of { _PRIM_ (u2 :: Float#) -> _!_ F# [] [u2] }; _NO_DEFLT_ } _N_ } #-}
instance Num Int
{-# GHC_PRAGMA _M_ PreludeCore {-dfun-} _A_ 0 _N_ _N_ _N_ _F_ _IF_ARGS_ 0 0 X 11 _!_ _TUP_10 [{{Eq Int}}, {{Text Int}}, (Int -> Int -> Int), (Int -> Int -> Int), (Int -> Int -> Int), (Int -> Int), (Int -> Int), (Int -> Int), (Integer -> Int), (Int -> Int)] [_DFUN_ Eq (Int), _DFUN_ Text (Int), _CONSTM_ Num (+) (Int), _CONSTM_ Num (-) (Int), _CONSTM_ Num (*) (Int), _CONSTM_ Num negate (Int), _CONSTM_ Num abs (Int), _CONSTM_ Num signum (Int), _CONSTM_ Num fromInteger (Int), _CONSTM_ Num fromInt (Int)] _N_
- (+) = _A_ 2 _U_ 11 _N_ _S_ "U(P)U(P)" {_A_ 2 _U_ 22 _N_ _N_ _F_ _IF_ARGS_ 0 2 XX 3 \ (u0 :: Int#) (u1 :: Int#) -> case _#_ plusInt# [] [u0, u1] of { _PRIM_ (u2 :: Int#) -> _!_ I# [] [u2] } _N_} _F_ _IF_ARGS_ 0 2 CC 5 \ (u0 :: Int) (u1 :: Int) -> case u0 of { _ALG_ I# (u2 :: Int#) -> case u1 of { _ALG_ I# (u3 :: Int#) -> case _#_ plusInt# [] [u2, u3] of { _PRIM_ (u4 :: Int#) -> _!_ I# [] [u4] }; _NO_DEFLT_ }; _NO_DEFLT_ } _N_,
- (-) = _A_ 2 _U_ 11 _N_ _S_ "U(P)U(P)" {_A_ 2 _U_ 22 _N_ _N_ _F_ _IF_ARGS_ 0 2 XX 3 \ (u0 :: Int#) (u1 :: Int#) -> case _#_ minusInt# [] [u0, u1] of { _PRIM_ (u2 :: Int#) -> _!_ I# [] [u2] } _N_} _F_ _IF_ARGS_ 0 2 CC 5 \ (u0 :: Int) (u1 :: Int) -> case u0 of { _ALG_ I# (u2 :: Int#) -> case u1 of { _ALG_ I# (u3 :: Int#) -> case _#_ minusInt# [] [u2, u3] of { _PRIM_ (u4 :: Int#) -> _!_ I# [] [u4] }; _NO_DEFLT_ }; _NO_DEFLT_ } _N_,
- (*) = _A_ 2 _U_ 11 _N_ _S_ "U(P)U(P)" {_A_ 2 _U_ 22 _N_ _N_ _F_ _IF_ARGS_ 0 2 XX 3 \ (u0 :: Int#) (u1 :: Int#) -> case _#_ timesInt# [] [u0, u1] of { _PRIM_ (u2 :: Int#) -> _!_ I# [] [u2] } _N_} _F_ _IF_ARGS_ 0 2 CC 5 \ (u0 :: Int) (u1 :: Int) -> case u0 of { _ALG_ I# (u2 :: Int#) -> case u1 of { _ALG_ I# (u3 :: Int#) -> case _#_ timesInt# [] [u2, u3] of { _PRIM_ (u4 :: Int#) -> _!_ I# [] [u4] }; _NO_DEFLT_ }; _NO_DEFLT_ } _N_,
- negate = _A_ 1 _U_ 1 _N_ _S_ "U(P)" {_A_ 1 _U_ 2 _N_ _N_ _F_ _IF_ARGS_ 0 1 X 3 \ (u0 :: Int#) -> case _#_ negateInt# [] [u0] of { _PRIM_ (u1 :: Int#) -> _!_ I# [] [u1] } _N_} _F_ _IF_ARGS_ 0 1 C 4 \ (u0 :: Int) -> case u0 of { _ALG_ I# (u1 :: Int#) -> case _#_ negateInt# [] [u1] of { _PRIM_ (u2 :: Int#) -> _!_ I# [] [u2] }; _NO_DEFLT_ } _N_,
- abs = _A_ 1 _U_ 1 _N_ _S_ "U(P)" {_A_ 1 _U_ 2 _N_ _N_ _N_ _N_} _N_ _N_,
- signum = _A_ 1 _U_ 1 _N_ _S_ "U(P)" {_A_ 1 _U_ 2 _N_ _N_ _N_ _N_} _N_ _N_,
- fromInteger = _A_ 1 _U_ 1 _N_ _S_ "U(PPP)" {_A_ 3 _U_ 222 _N_ _N_ _F_ _IF_ARGS_ 0 3 XXX 3 \ (u0 :: Int#) (u1 :: Int#) (u2 :: ByteArray#) -> case _#_ integer2Int# [] [u0, u1, u2] of { _PRIM_ (u3 :: Int#) -> _!_ I# [] [u3] } _N_} _F_ _IF_ARGS_ 0 1 C 4 \ (u0 :: Integer) -> case u0 of { _ALG_ J# (u1 :: Int#) (u2 :: Int#) (u3 :: ByteArray#) -> case _#_ integer2Int# [] [u1, u2, u3] of { _PRIM_ (u4 :: Int#) -> _!_ I# [] [u4] }; _NO_DEFLT_ } _N_,
- fromInt = _A_ 1 _U_ 1 _N_ _S_ "U(P)" {_A_ 1 _U_ 2 _N_ _N_ _F_ _IF_ARGS_ 0 1 X 2 \ (u0 :: Int#) -> _!_ I# [] [u0] _N_} _F_ _IF_ARGS_ 0 1 X 1 \ (u0 :: Int) -> u0 _N_ #-}
+ (+) = { _A_ 2 _U_ 11 _N_ _S_ "U(P)U(P)" {_A_ 2 _U_ 22 _N_ _N_ _F_ _IF_ARGS_ 0 2 XX 3 \ (u0 :: Int#) (u1 :: Int#) -> case _#_ plusInt# [] [u0, u1] of { _PRIM_ (u2 :: Int#) -> _!_ I# [] [u2] } _N_} _F_ _IF_ARGS_ 0 2 CC 5 \ (u0 :: Int) (u1 :: Int) -> case u0 of { _ALG_ I# (u2 :: Int#) -> case u1 of { _ALG_ I# (u3 :: Int#) -> case _#_ plusInt# [] [u2, u3] of { _PRIM_ (u4 :: Int#) -> _!_ I# [] [u4] }; _NO_DEFLT_ }; _NO_DEFLT_ } _N_ },
+ (-) = { _A_ 2 _U_ 11 _N_ _S_ "U(P)U(P)" {_A_ 2 _U_ 22 _N_ _N_ _F_ _IF_ARGS_ 0 2 XX 3 \ (u0 :: Int#) (u1 :: Int#) -> case _#_ minusInt# [] [u0, u1] of { _PRIM_ (u2 :: Int#) -> _!_ I# [] [u2] } _N_} _F_ _IF_ARGS_ 0 2 CC 5 \ (u0 :: Int) (u1 :: Int) -> case u0 of { _ALG_ I# (u2 :: Int#) -> case u1 of { _ALG_ I# (u3 :: Int#) -> case _#_ minusInt# [] [u2, u3] of { _PRIM_ (u4 :: Int#) -> _!_ I# [] [u4] }; _NO_DEFLT_ }; _NO_DEFLT_ } _N_ },
+ (*) = { _A_ 2 _U_ 11 _N_ _S_ "U(P)U(P)" {_A_ 2 _U_ 22 _N_ _N_ _F_ _IF_ARGS_ 0 2 XX 3 \ (u0 :: Int#) (u1 :: Int#) -> case _#_ timesInt# [] [u0, u1] of { _PRIM_ (u2 :: Int#) -> _!_ I# [] [u2] } _N_} _F_ _IF_ARGS_ 0 2 CC 5 \ (u0 :: Int) (u1 :: Int) -> case u0 of { _ALG_ I# (u2 :: Int#) -> case u1 of { _ALG_ I# (u3 :: Int#) -> case _#_ timesInt# [] [u2, u3] of { _PRIM_ (u4 :: Int#) -> _!_ I# [] [u4] }; _NO_DEFLT_ }; _NO_DEFLT_ } _N_ },
+ negate = { _A_ 1 _U_ 1 _N_ _S_ "U(P)" {_A_ 1 _U_ 2 _N_ _N_ _F_ _IF_ARGS_ 0 1 X 3 \ (u0 :: Int#) -> case _#_ negateInt# [] [u0] of { _PRIM_ (u1 :: Int#) -> _!_ I# [] [u1] } _N_} _F_ _IF_ARGS_ 0 1 C 4 \ (u0 :: Int) -> case u0 of { _ALG_ I# (u1 :: Int#) -> case _#_ negateInt# [] [u1] of { _PRIM_ (u2 :: Int#) -> _!_ I# [] [u2] }; _NO_DEFLT_ } _N_ },
+ abs = { _A_ 1 _U_ 1 _N_ _S_ "U(P)" {_A_ 1 _U_ 2 _N_ _N_ _N_ _N_} _N_ _N_ },
+ signum = { _A_ 1 _U_ 1 _N_ _S_ "U(P)" {_A_ 1 _U_ 2 _N_ _N_ _N_ _N_} _N_ _N_ },
+ fromInteger = { _A_ 1 _U_ 1 _N_ _S_ "U(PPP)" {_A_ 3 _U_ 222 _N_ _N_ _F_ _IF_ARGS_ 0 3 XXX 3 \ (u0 :: Int#) (u1 :: Int#) (u2 :: ByteArray#) -> case _#_ integer2Int# [] [u0, u1, u2] of { _PRIM_ (u3 :: Int#) -> _!_ I# [] [u3] } _N_} _F_ _IF_ARGS_ 0 1 C 4 \ (u0 :: Integer) -> case u0 of { _ALG_ J# (u1 :: Int#) (u2 :: Int#) (u3 :: ByteArray#) -> case _#_ integer2Int# [] [u1, u2, u3] of { _PRIM_ (u4 :: Int#) -> _!_ I# [] [u4] }; _NO_DEFLT_ } _N_ },
+ fromInt = { _A_ 1 _U_ 1 _N_ _S_ "U(P)" {_A_ 1 _U_ 2 _N_ _N_ _F_ _IF_ARGS_ 0 1 X 2 \ (u0 :: Int#) -> _!_ I# [] [u0] _N_} _F_ _IF_ARGS_ 0 1 X 1 \ (u0 :: Int) -> u0 _N_ } #-}
instance Num Integer
{-# GHC_PRAGMA _M_ PreludeCore {-dfun-} _A_ 0 _N_ _N_ _N_ _F_ _IF_ARGS_ 0 0 X 11 _!_ _TUP_10 [{{Eq Integer}}, {{Text Integer}}, (Integer -> Integer -> Integer), (Integer -> Integer -> Integer), (Integer -> Integer -> Integer), (Integer -> Integer), (Integer -> Integer), (Integer -> Integer), (Integer -> Integer), (Int -> Integer)] [_DFUN_ Eq (Integer), _DFUN_ Text (Integer), _CONSTM_ Num (+) (Integer), _CONSTM_ Num (-) (Integer), _CONSTM_ Num (*) (Integer), _CONSTM_ Num negate (Integer), _CONSTM_ Num abs (Integer), _CONSTM_ Num signum (Integer), _CONSTM_ Num fromInteger (Integer), _CONSTM_ Num fromInt (Integer)] _N_
- (+) = _A_ 2 _U_ 11 _N_ _S_ "U(PPP)U(PPP)" {_A_ 4 _U_ 2221 _N_ _N_ _F_ _IF_ARGS_ 0 4 XXXC 5 \ (u0 :: Int#) (u1 :: Int#) (u2 :: ByteArray#) (u3 :: Integer) -> case u3 of { _ALG_ J# (u4 :: Int#) (u5 :: Int#) (u6 :: ByteArray#) -> _#_ plusInteger# [] [u0, u1, u2, u4, u5, u6]; _NO_DEFLT_ } _N_} _F_ _IF_ARGS_ 0 2 CC 6 \ (u0 :: Integer) (u1 :: Integer) -> case u0 of { _ALG_ J# (u2 :: Int#) (u3 :: Int#) (u4 :: ByteArray#) -> case u1 of { _ALG_ J# (u5 :: Int#) (u6 :: Int#) (u7 :: ByteArray#) -> _#_ plusInteger# [] [u2, u3, u4, u5, u6, u7]; _NO_DEFLT_ }; _NO_DEFLT_ } _N_,
- (-) = _A_ 2 _U_ 11 _N_ _S_ "U(PPP)U(PPP)" {_A_ 4 _U_ 2221 _N_ _N_ _F_ _IF_ARGS_ 0 4 XXXC 5 \ (u0 :: Int#) (u1 :: Int#) (u2 :: ByteArray#) (u3 :: Integer) -> case u3 of { _ALG_ J# (u4 :: Int#) (u5 :: Int#) (u6 :: ByteArray#) -> _#_ minusInteger# [] [u0, u1, u2, u4, u5, u6]; _NO_DEFLT_ } _N_} _F_ _IF_ARGS_ 0 2 CC 6 \ (u0 :: Integer) (u1 :: Integer) -> case u0 of { _ALG_ J# (u2 :: Int#) (u3 :: Int#) (u4 :: ByteArray#) -> case u1 of { _ALG_ J# (u5 :: Int#) (u6 :: Int#) (u7 :: ByteArray#) -> _#_ minusInteger# [] [u2, u3, u4, u5, u6, u7]; _NO_DEFLT_ }; _NO_DEFLT_ } _N_,
- (*) = _A_ 2 _U_ 11 _N_ _S_ "U(PPP)U(PPP)" {_A_ 4 _U_ 2221 _N_ _N_ _F_ _IF_ARGS_ 0 4 XXXC 5 \ (u0 :: Int#) (u1 :: Int#) (u2 :: ByteArray#) (u3 :: Integer) -> case u3 of { _ALG_ J# (u4 :: Int#) (u5 :: Int#) (u6 :: ByteArray#) -> _#_ timesInteger# [] [u0, u1, u2, u4, u5, u6]; _NO_DEFLT_ } _N_} _F_ _IF_ARGS_ 0 2 CC 6 \ (u0 :: Integer) (u1 :: Integer) -> case u0 of { _ALG_ J# (u2 :: Int#) (u3 :: Int#) (u4 :: ByteArray#) -> case u1 of { _ALG_ J# (u5 :: Int#) (u6 :: Int#) (u7 :: ByteArray#) -> _#_ timesInteger# [] [u2, u3, u4, u5, u6, u7]; _NO_DEFLT_ }; _NO_DEFLT_ } _N_,
- negate = _A_ 1 _U_ 1 _N_ _S_ "U(PPP)" {_A_ 3 _U_ 222 _N_ _N_ _F_ _IF_ARGS_ 0 3 XXX 4 \ (u0 :: Int#) (u1 :: Int#) (u2 :: ByteArray#) -> _#_ negateInteger# [] [u0, u1, u2] _N_} _F_ _IF_ARGS_ 0 1 C 5 \ (u0 :: Integer) -> case u0 of { _ALG_ J# (u1 :: Int#) (u2 :: Int#) (u3 :: ByteArray#) -> _#_ negateInteger# [] [u1, u2, u3]; _NO_DEFLT_ } _N_,
- abs = _A_ 1 _U_ 1 _N_ _S_ "U(PPP)" {_A_ 3 _U_ 222 _N_ _N_ _N_ _N_} _N_ _N_,
- signum = _A_ 1 _U_ 1 _N_ _S_ "U(PPP)" {_A_ 3 _U_ 222 _N_ _N_ _N_ _N_} _N_ _N_,
- fromInteger = _A_ 1 _U_ 1 _N_ _S_ "U(PPP)" {_A_ 3 _U_ 222 _N_ _N_ _F_ _IF_ARGS_ 0 3 XXX 4 \ (u0 :: Int#) (u1 :: Int#) (u2 :: ByteArray#) -> _!_ J# [] [u0, u1, u2] _N_} _F_ _IF_ARGS_ 0 1 X 1 \ (u0 :: Integer) -> u0 _N_,
- fromInt = _A_ 1 _U_ 1 _N_ _S_ "U(P)" {_A_ 1 _U_ 2 _N_ _N_ _F_ _IF_ARGS_ 0 1 X 1 \ (u0 :: Int#) -> _#_ int2Integer# [] [u0] _N_} _F_ _IF_ARGS_ 0 1 C 2 \ (u0 :: Int) -> case u0 of { _ALG_ I# (u1 :: Int#) -> _#_ int2Integer# [] [u1]; _NO_DEFLT_ } _N_ #-}
+ (+) = { _A_ 2 _U_ 11 _N_ _S_ "U(PPP)U(PPP)" {_A_ 4 _U_ 2221 _N_ _N_ _F_ _IF_ARGS_ 0 4 XXXC 5 \ (u0 :: Int#) (u1 :: Int#) (u2 :: ByteArray#) (u3 :: Integer) -> case u3 of { _ALG_ J# (u4 :: Int#) (u5 :: Int#) (u6 :: ByteArray#) -> _#_ plusInteger# [] [u0, u1, u2, u4, u5, u6]; _NO_DEFLT_ } _N_} _F_ _IF_ARGS_ 0 2 CC 6 \ (u0 :: Integer) (u1 :: Integer) -> case u0 of { _ALG_ J# (u2 :: Int#) (u3 :: Int#) (u4 :: ByteArray#) -> case u1 of { _ALG_ J# (u5 :: Int#) (u6 :: Int#) (u7 :: ByteArray#) -> _#_ plusInteger# [] [u2, u3, u4, u5, u6, u7]; _NO_DEFLT_ }; _NO_DEFLT_ } _N_ },
+ (-) = { _A_ 2 _U_ 11 _N_ _S_ "U(PPP)U(PPP)" {_A_ 4 _U_ 2221 _N_ _N_ _F_ _IF_ARGS_ 0 4 XXXC 5 \ (u0 :: Int#) (u1 :: Int#) (u2 :: ByteArray#) (u3 :: Integer) -> case u3 of { _ALG_ J# (u4 :: Int#) (u5 :: Int#) (u6 :: ByteArray#) -> _#_ minusInteger# [] [u0, u1, u2, u4, u5, u6]; _NO_DEFLT_ } _N_} _F_ _IF_ARGS_ 0 2 CC 6 \ (u0 :: Integer) (u1 :: Integer) -> case u0 of { _ALG_ J# (u2 :: Int#) (u3 :: Int#) (u4 :: ByteArray#) -> case u1 of { _ALG_ J# (u5 :: Int#) (u6 :: Int#) (u7 :: ByteArray#) -> _#_ minusInteger# [] [u2, u3, u4, u5, u6, u7]; _NO_DEFLT_ }; _NO_DEFLT_ } _N_ },
+ (*) = { _A_ 2 _U_ 11 _N_ _S_ "U(PPP)U(PPP)" {_A_ 4 _U_ 2221 _N_ _N_ _F_ _IF_ARGS_ 0 4 XXXC 5 \ (u0 :: Int#) (u1 :: Int#) (u2 :: ByteArray#) (u3 :: Integer) -> case u3 of { _ALG_ J# (u4 :: Int#) (u5 :: Int#) (u6 :: ByteArray#) -> _#_ timesInteger# [] [u0, u1, u2, u4, u5, u6]; _NO_DEFLT_ } _N_} _F_ _IF_ARGS_ 0 2 CC 6 \ (u0 :: Integer) (u1 :: Integer) -> case u0 of { _ALG_ J# (u2 :: Int#) (u3 :: Int#) (u4 :: ByteArray#) -> case u1 of { _ALG_ J# (u5 :: Int#) (u6 :: Int#) (u7 :: ByteArray#) -> _#_ timesInteger# [] [u2, u3, u4, u5, u6, u7]; _NO_DEFLT_ }; _NO_DEFLT_ } _N_ },
+ negate = { _A_ 1 _U_ 1 _N_ _S_ "U(PPP)" {_A_ 3 _U_ 222 _N_ _N_ _F_ _IF_ARGS_ 0 3 XXX 4 \ (u0 :: Int#) (u1 :: Int#) (u2 :: ByteArray#) -> _#_ negateInteger# [] [u0, u1, u2] _N_} _F_ _IF_ARGS_ 0 1 C 5 \ (u0 :: Integer) -> case u0 of { _ALG_ J# (u1 :: Int#) (u2 :: Int#) (u3 :: ByteArray#) -> _#_ negateInteger# [] [u1, u2, u3]; _NO_DEFLT_ } _N_ },
+ abs = { _A_ 1 _U_ 1 _N_ _S_ "U(PPP)" {_A_ 3 _U_ 222 _N_ _N_ _N_ _N_} _N_ _N_ },
+ signum = { _A_ 1 _U_ 1 _N_ _S_ "U(PPP)" {_A_ 3 _U_ 222 _N_ _N_ _N_ _N_} _N_ _N_ },
+ fromInteger = { _A_ 1 _U_ 1 _N_ _S_ "U(PPP)" {_A_ 3 _U_ 222 _N_ _N_ _F_ _IF_ARGS_ 0 3 XXX 4 \ (u0 :: Int#) (u1 :: Int#) (u2 :: ByteArray#) -> _!_ J# [] [u0, u1, u2] _N_} _F_ _IF_ARGS_ 0 1 X 1 \ (u0 :: Integer) -> u0 _N_ },
+ fromInt = { _A_ 1 _U_ 1 _N_ _S_ "U(P)" {_A_ 1 _U_ 2 _N_ _N_ _F_ _IF_ARGS_ 0 1 X 1 \ (u0 :: Int#) -> _#_ int2Integer# [] [u0] _N_} _F_ _IF_ARGS_ 0 1 C 2 \ (u0 :: Int) -> case u0 of { _ALG_ I# (u1 :: Int#) -> _#_ int2Integer# [] [u1]; _NO_DEFLT_ } _N_ } #-}
instance Integral a => Num (Ratio a)
{-# GHC_PRAGMA _M_ PreludeRatio {-dfun-} _A_ 3 _U_ 222 _N_ _N_ _N_ _N_ #-}
instance Num (Ratio Integer)
{-# GHC_PRAGMA _M_ PreludeRatio {-dfun-} _A_ 0 _N_ _N_ _N_ _F_ _IF_ARGS_ 0 0 X 11 _!_ _TUP_10 [{{Eq (Ratio Integer)}}, {{Text (Ratio Integer)}}, (Ratio Integer -> Ratio Integer -> Ratio Integer), (Ratio Integer -> Ratio Integer -> Ratio Integer), (Ratio Integer -> Ratio Integer -> Ratio Integer), (Ratio Integer -> Ratio Integer), (Ratio Integer -> Ratio Integer), (Ratio Integer -> Ratio Integer), (Integer -> Ratio Integer), (Int -> Ratio Integer)] [_DFUN_ Eq (Ratio Integer), _DFUN_ Text (Ratio Integer), _CONSTM_ Num (+) (Ratio Integer), _CONSTM_ Num (-) (Ratio Integer), _CONSTM_ Num (*) (Ratio Integer), _CONSTM_ Num negate (Ratio Integer), _CONSTM_ Num abs (Ratio Integer), _CONSTM_ Num signum (Ratio Integer), _CONSTM_ Num fromInteger (Ratio Integer), _CONSTM_ Num fromInt (Ratio Integer)] _N_
- (+) = _A_ 2 _U_ 11 _N_ _S_ "U(LU(PPP))U(LU(PPP))" {_A_ 5 _U_ 12221 _N_ _N_ _N_ _N_} _N_ _N_,
- (-) = _A_ 2 _U_ 11 _N_ _S_ "U(LU(PPP))U(LU(PPP))" {_A_ 5 _U_ 12221 _N_ _N_ _N_ _N_} _N_ _N_,
- (*) = _A_ 2 _U_ 11 _N_ _S_ "U(LU(PPP))U(LU(PPP))" {_A_ 5 _U_ 22221 _N_ _N_ _N_ _N_} _N_ _N_,
- negate = _A_ 1 _U_ 1 _N_ _S_ "U(LL)" {_A_ 2 _U_ 22 _N_ _N_ _N_ _N_} _N_ _N_,
- abs = _A_ 1 _U_ 1 _N_ _S_ "U(LL)" {_A_ 2 _U_ 12 _N_ _N_ _N_ _N_} _N_ _N_,
- signum = _A_ 1 _U_ 1 _N_ _S_ "U(LA)" {_A_ 1 _U_ 1 _N_ _N_ _N_ _N_} _N_ _N_,
- fromInteger = _A_ 1 _U_ 2 _N_ _N_ _N_ _N_,
- fromInt = _A_ 1 _U_ 1 _N_ _N_ _N_ _N_ #-}
+ (+) = { _A_ 2 _U_ 11 _N_ _S_ "U(LU(PPP))U(LU(PPP))" {_A_ 5 _U_ 12221 _N_ _N_ _N_ _N_} _N_ _N_ },
+ (-) = { _A_ 2 _U_ 11 _N_ _S_ "U(LU(PPP))U(LU(PPP))" {_A_ 5 _U_ 12221 _N_ _N_ _N_ _N_} _N_ _N_ },
+ (*) = { _A_ 2 _U_ 11 _N_ _S_ "U(LU(PPP))U(LU(PPP))" {_A_ 5 _U_ 22221 _N_ _N_ _N_ _N_} _N_ _N_ },
+ negate = { _A_ 1 _U_ 1 _N_ _S_ "U(LL)" {_A_ 2 _U_ 22 _N_ _N_ _N_ _N_} _N_ _N_ },
+ abs = { _A_ 1 _U_ 1 _N_ _S_ "U(LL)" {_A_ 2 _U_ 12 _N_ _N_ _N_ _N_} _N_ _N_ },
+ signum = { _A_ 1 _U_ 1 _N_ _S_ "U(LA)" {_A_ 1 _U_ 1 _N_ _N_ _N_ _N_} _N_ _N_ },
+ fromInteger = { _A_ 1 _U_ 2 _N_ _N_ _F_ _IF_ARGS_ 0 1 X 3 \ (u0 :: Integer) -> _!_ (:%) [Integer] [u0, _SPEC_ _ORIG_ PreludeCore __i1 [ (Integer) ]] _N_ },
+ fromInt = { _A_ 1 _U_ 1 _N_ _N_ _N_ _N_ } #-}
instance Ord ()
{-# GHC_PRAGMA _M_ PreludeBuiltin {-dfun-} _A_ 0 _N_ _N_ _N_ _F_ _IF_ARGS_ 0 0 X 9 _!_ _TUP_8 [{{Eq ()}}, (() -> () -> Bool), (() -> () -> Bool), (() -> () -> Bool), (() -> () -> Bool), (() -> () -> ()), (() -> () -> ()), (() -> () -> _CMP_TAG)] [_DFUN_ Eq (()), _CONSTM_ Ord (<) (()), _CONSTM_ Ord (<=) (()), _CONSTM_ Ord (>=) (()), _CONSTM_ Ord (>) (()), _CONSTM_ Ord max (()), _CONSTM_ Ord min (()), _CONSTM_ Ord _tagCmp (())] _N_
- (<) = _A_ 2 _U_ 11 _N_ _S_ "EE" _F_ _IF_ARGS_ 0 2 CC 3 \ (u0 :: ()) (u1 :: ()) -> case u0 of { _ALG_ _TUP_0 -> case u1 of { _ALG_ _TUP_0 -> _!_ False [] []; _NO_DEFLT_ }; _NO_DEFLT_ } _N_,
- (<=) = _A_ 2 _U_ 11 _N_ _S_ "EE" _F_ _IF_ARGS_ 0 2 CC 3 \ (u0 :: ()) (u1 :: ()) -> case u0 of { _ALG_ _TUP_0 -> case u1 of { _ALG_ _TUP_0 -> _!_ True [] []; _NO_DEFLT_ }; _NO_DEFLT_ } _N_,
- (>=) = _A_ 2 _U_ 11 _N_ _S_ "EE" _F_ _IF_ARGS_ 0 2 CC 3 \ (u0 :: ()) (u1 :: ()) -> case u0 of { _ALG_ _TUP_0 -> case u1 of { _ALG_ _TUP_0 -> _!_ True [] []; _NO_DEFLT_ }; _NO_DEFLT_ } _N_,
- (>) = _A_ 2 _U_ 11 _N_ _S_ "EE" _F_ _IF_ARGS_ 0 2 CC 3 \ (u0 :: ()) (u1 :: ()) -> case u0 of { _ALG_ _TUP_0 -> case u1 of { _ALG_ _TUP_0 -> _!_ False [] []; _NO_DEFLT_ }; _NO_DEFLT_ } _N_,
- max = _A_ 2 _U_ 11 _N_ _S_ "EE" _F_ _IF_ARGS_ 0 2 CX 2 \ (u0 :: ()) (u1 :: ()) -> case u0 of { _ALG_ _TUP_0 -> u1; _NO_DEFLT_ } _N_,
- min = _A_ 2 _U_ 11 _N_ _S_ "EE" _F_ _IF_ARGS_ 0 2 CX 2 \ (u0 :: ()) (u1 :: ()) -> case u0 of { _ALG_ _TUP_0 -> u1; _NO_DEFLT_ } _N_,
- _tagCmp = _A_ 2 _U_ 11 _N_ _S_ "EE" _F_ _IF_ARGS_ 0 2 CC 3 \ (u0 :: ()) (u1 :: ()) -> case u0 of { _ALG_ _TUP_0 -> case u1 of { _ALG_ _TUP_0 -> _!_ _EQ [] []; _NO_DEFLT_ }; _NO_DEFLT_ } _N_ #-}
+ (<) = { _A_ 2 _U_ 11 _N_ _S_ "EE" _F_ _IF_ARGS_ 0 2 CC 3 \ (u0 :: ()) (u1 :: ()) -> case u0 of { _ALG_ _TUP_0 -> case u1 of { _ALG_ _TUP_0 -> _!_ False [] []; _NO_DEFLT_ }; _NO_DEFLT_ } _N_ },
+ (<=) = { _A_ 2 _U_ 11 _N_ _S_ "EE" _F_ _IF_ARGS_ 0 2 CC 3 \ (u0 :: ()) (u1 :: ()) -> case u0 of { _ALG_ _TUP_0 -> case u1 of { _ALG_ _TUP_0 -> _!_ True [] []; _NO_DEFLT_ }; _NO_DEFLT_ } _N_ },
+ (>=) = { _A_ 2 _U_ 11 _N_ _S_ "EE" _F_ _IF_ARGS_ 0 2 CC 3 \ (u0 :: ()) (u1 :: ()) -> case u0 of { _ALG_ _TUP_0 -> case u1 of { _ALG_ _TUP_0 -> _!_ True [] []; _NO_DEFLT_ }; _NO_DEFLT_ } _N_ },
+ (>) = { _A_ 2 _U_ 11 _N_ _S_ "EE" _F_ _IF_ARGS_ 0 2 CC 3 \ (u0 :: ()) (u1 :: ()) -> case u0 of { _ALG_ _TUP_0 -> case u1 of { _ALG_ _TUP_0 -> _!_ False [] []; _NO_DEFLT_ }; _NO_DEFLT_ } _N_ },
+ max = { _A_ 2 _U_ 11 _N_ _S_ "EE" _F_ _IF_ARGS_ 0 2 CX 2 \ (u0 :: ()) (u1 :: ()) -> case u0 of { _ALG_ _TUP_0 -> u1; _NO_DEFLT_ } _N_ },
+ min = { _A_ 2 _U_ 11 _N_ _S_ "EE" _F_ _IF_ARGS_ 0 2 CX 2 \ (u0 :: ()) (u1 :: ()) -> case u0 of { _ALG_ _TUP_0 -> u1; _NO_DEFLT_ } _N_ },
+ _tagCmp = { _A_ 2 _U_ 11 _N_ _S_ "EE" _F_ _IF_ARGS_ 0 2 CC 3 \ (u0 :: ()) (u1 :: ()) -> case u0 of { _ALG_ _TUP_0 -> case u1 of { _ALG_ _TUP_0 -> _!_ _EQ [] []; _NO_DEFLT_ }; _NO_DEFLT_ } _N_ } #-}
instance (Ord a, Ord b) => Ord (a, b)
{-# GHC_PRAGMA _M_ PreludeBuiltin {-dfun-} _A_ 3 _U_ 112 _N_ _N_ _N_ _N_ #-}
instance (Ord a, Ord b, Ord c) => Ord (a, b, c)
{-# GHC_PRAGMA _M_ PreludeBuiltin {-dfun-} _A_ 6 _U_ 111112 _N_ _N_ _N_ _N_ #-}
instance Ord (Int, Int)
{-# GHC_PRAGMA _M_ PreludeBuiltin {-dfun-} _A_ 0 _N_ _N_ _N_ _F_ _IF_ARGS_ 0 0 X 9 _!_ _TUP_8 [{{Eq (Int, Int)}}, ((Int, Int) -> (Int, Int) -> Bool), ((Int, Int) -> (Int, Int) -> Bool), ((Int, Int) -> (Int, Int) -> Bool), ((Int, Int) -> (Int, Int) -> Bool), ((Int, Int) -> (Int, Int) -> (Int, Int)), ((Int, Int) -> (Int, Int) -> (Int, Int)), ((Int, Int) -> (Int, Int) -> _CMP_TAG)] [_DFUN_ Eq ((Int, Int)), _CONSTM_ Ord (<) ((Int, Int)), _CONSTM_ Ord (<=) ((Int, Int)), _CONSTM_ Ord (>=) ((Int, Int)), _CONSTM_ Ord (>) ((Int, Int)), _CONSTM_ Ord max ((Int, Int)), _CONSTM_ Ord min ((Int, Int)), _CONSTM_ Ord _tagCmp ((Int, Int))] _N_
- (<) = _A_ 2 _U_ 11 _N_ _S_ "U(U(P)L)U(U(P)L)" {_A_ 4 _U_ 2121 _N_ _N_ _N_ _N_} _N_ _N_,
- (<=) = _A_ 2 _U_ 11 _N_ _S_ "U(U(P)L)U(U(P)L)" {_A_ 4 _U_ 2121 _N_ _N_ _N_ _N_} _N_ _N_,
- (>=) = _A_ 2 _U_ 11 _N_ _S_ "U(U(P)L)U(U(P)L)" {_A_ 4 _U_ 2121 _N_ _N_ _N_ _N_} _N_ _N_,
- (>) = _A_ 2 _U_ 11 _N_ _S_ "U(U(P)L)U(U(P)L)" {_A_ 4 _U_ 2121 _N_ _N_ _N_ _N_} _N_ _N_,
- max = _A_ 2 _U_ 11 _N_ _S_ "U(U(P)L)U(U(P)L)" {_A_ 4 _U_ 2222 _N_ _N_ _N_ _N_} _N_ _N_,
- min = _A_ 2 _U_ 11 _N_ _S_ "U(U(P)L)U(U(P)L)" {_A_ 4 _U_ 2222 _N_ _N_ _N_ _N_} _N_ _N_,
- _tagCmp = _A_ 2 _U_ 11 _N_ _S_ "U(U(P)L)U(U(P)L)" {_A_ 4 _U_ 2121 _N_ _N_ _N_ _N_} _N_ _N_ #-}
+ (<) = { _A_ 2 _U_ 11 _N_ _S_ "U(U(P)L)U(U(P)L)" {_A_ 4 _U_ 2121 _N_ _N_ _N_ _N_} _N_ _N_ },
+ (<=) = { _A_ 2 _U_ 11 _N_ _S_ "U(U(P)L)U(U(P)L)" {_A_ 4 _U_ 2121 _N_ _N_ _N_ _N_} _N_ _N_ },
+ (>=) = { _A_ 2 _U_ 11 _N_ _S_ "U(U(P)L)U(U(P)L)" {_A_ 4 _U_ 2121 _N_ _N_ _N_ _N_} _N_ _N_ },
+ (>) = { _A_ 2 _U_ 11 _N_ _S_ "U(U(P)L)U(U(P)L)" {_A_ 4 _U_ 2121 _N_ _N_ _N_ _N_} _N_ _N_ },
+ max = { _A_ 2 _U_ 11 _N_ _S_ "U(U(P)L)U(U(P)L)" {_A_ 4 _U_ 2222 _N_ _N_ _N_ _N_} _N_ _N_ },
+ min = { _A_ 2 _U_ 11 _N_ _S_ "U(U(P)L)U(U(P)L)" {_A_ 4 _U_ 2222 _N_ _N_ _N_ _N_} _N_ _N_ },
+ _tagCmp = { _A_ 2 _U_ 11 _N_ _S_ "U(U(P)L)U(U(P)L)" {_A_ 4 _U_ 2121 _N_ _N_ _N_ _N_} _N_ _N_ } #-}
+instance Ord (Int, Int, Int)
+ {-# GHC_PRAGMA _M_ PreludeBuiltin {-dfun-} _A_ 0 _N_ _N_ _N_ _F_ _IF_ARGS_ 0 0 X 9 _!_ _TUP_8 [{{Eq (Int, Int, Int)}}, ((Int, Int, Int) -> (Int, Int, Int) -> Bool), ((Int, Int, Int) -> (Int, Int, Int) -> Bool), ((Int, Int, Int) -> (Int, Int, Int) -> Bool), ((Int, Int, Int) -> (Int, Int, Int) -> Bool), ((Int, Int, Int) -> (Int, Int, Int) -> (Int, Int, Int)), ((Int, Int, Int) -> (Int, Int, Int) -> (Int, Int, Int)), ((Int, Int, Int) -> (Int, Int, Int) -> _CMP_TAG)] [_DFUN_ Eq ((Int, Int, Int)), _CONSTM_ Ord (<) ((Int, Int, Int)), _CONSTM_ Ord (<=) ((Int, Int, Int)), _CONSTM_ Ord (>=) ((Int, Int, Int)), _CONSTM_ Ord (>) ((Int, Int, Int)), _CONSTM_ Ord max ((Int, Int, Int)), _CONSTM_ Ord min ((Int, Int, Int)), _CONSTM_ Ord _tagCmp ((Int, Int, Int))] _N_
+ (<) = { _A_ 2 _U_ 11 _N_ _S_ "U(U(P)LL)U(U(P)LL)" {_A_ 4 _U_ 2111 _N_ _N_ _N_ _N_} _N_ _N_ },
+ (<=) = { _A_ 2 _U_ 11 _N_ _S_ "U(U(P)LL)U(U(P)LL)" {_A_ 4 _U_ 2111 _N_ _N_ _N_ _N_} _N_ _N_ },
+ (>=) = { _A_ 2 _U_ 11 _N_ _S_ "U(U(P)LL)U(U(P)LL)" {_A_ 4 _U_ 2111 _N_ _N_ _N_ _N_} _N_ _N_ },
+ (>) = { _A_ 2 _U_ 11 _N_ _S_ "U(U(P)LL)U(U(P)LL)" {_A_ 4 _U_ 2111 _N_ _N_ _N_ _N_} _N_ _N_ },
+ max = { _A_ 2 _U_ 12 _N_ _S_ "U(U(P)LL)U(U(P)LL)" {_A_ 4 _U_ 2222 _N_ _N_ _N_ _N_} _N_ _N_ },
+ min = { _A_ 2 _U_ 12 _N_ _S_ "U(U(P)LL)U(U(P)LL)" {_A_ 4 _U_ 2222 _N_ _N_ _N_ _N_} _N_ _N_ },
+ _tagCmp = { _A_ 2 _U_ 11 _N_ _S_ "U(U(P)LL)U(U(P)LL)" {_A_ 4 _U_ 2111 _N_ _N_ _N_ _N_} _N_ _N_ } #-}
+instance Ord (Int, Int, Int, Int)
+ {-# GHC_PRAGMA _M_ PreludeBuiltin {-dfun-} _A_ 0 _N_ _N_ _N_ _F_ _IF_ARGS_ 0 0 X 9 _!_ _TUP_8 [{{Eq (Int, Int, Int, Int)}}, ((Int, Int, Int, Int) -> (Int, Int, Int, Int) -> Bool), ((Int, Int, Int, Int) -> (Int, Int, Int, Int) -> Bool), ((Int, Int, Int, Int) -> (Int, Int, Int, Int) -> Bool), ((Int, Int, Int, Int) -> (Int, Int, Int, Int) -> Bool), ((Int, Int, Int, Int) -> (Int, Int, Int, Int) -> (Int, Int, Int, Int)), ((Int, Int, Int, Int) -> (Int, Int, Int, Int) -> (Int, Int, Int, Int)), ((Int, Int, Int, Int) -> (Int, Int, Int, Int) -> _CMP_TAG)] [_DFUN_ Eq ((Int, Int, Int, Int)), _CONSTM_ Ord (<) ((Int, Int, Int, Int)), _CONSTM_ Ord (<=) ((Int, Int, Int, Int)), _CONSTM_ Ord (>=) ((Int, Int, Int, Int)), _CONSTM_ Ord (>) ((Int, Int, Int, Int)), _CONSTM_ Ord max ((Int, Int, Int, Int)), _CONSTM_ Ord min ((Int, Int, Int, Int)), _CONSTM_ Ord _tagCmp ((Int, Int, Int, Int))] _N_
+ (<) = { _A_ 2 _U_ 11 _N_ _S_ "U(U(P)LLL)U(U(P)LLL)" {_A_ 5 _U_ 21111 _N_ _N_ _N_ _N_} _N_ _N_ },
+ (<=) = { _A_ 2 _U_ 11 _N_ _S_ "U(U(P)LLL)U(U(P)LLL)" {_A_ 5 _U_ 21111 _N_ _N_ _N_ _N_} _N_ _N_ },
+ (>=) = { _A_ 2 _U_ 11 _N_ _S_ "U(U(P)LLL)U(U(P)LLL)" {_A_ 5 _U_ 21111 _N_ _N_ _N_ _N_} _N_ _N_ },
+ (>) = { _A_ 2 _U_ 11 _N_ _S_ "U(U(P)LLL)U(U(P)LLL)" {_A_ 5 _U_ 21111 _N_ _N_ _N_ _N_} _N_ _N_ },
+ max = { _A_ 2 _U_ 12 _N_ _S_ "U(U(P)LLL)U(U(P)LLL)" {_A_ 5 _U_ 22222 _N_ _N_ _N_ _N_} _N_ _N_ },
+ min = { _A_ 2 _U_ 12 _N_ _S_ "U(U(P)LLL)U(U(P)LLL)" {_A_ 5 _U_ 22222 _N_ _N_ _N_ _N_} _N_ _N_ },
+ _tagCmp = { _A_ 2 _U_ 11 _N_ _S_ "U(U(P)LLL)U(U(P)LLL)" {_A_ 5 _U_ 21111 _N_ _N_ _N_ _N_} _N_ _N_ } #-}
+instance Ord (Int, Int, Int, Int, Int)
+ {-# GHC_PRAGMA _M_ PreludeBuiltin {-dfun-} _A_ 0 _N_ _N_ _N_ _F_ _IF_ARGS_ 0 0 X 9 _!_ _TUP_8 [{{Eq (Int, Int, Int, Int, Int)}}, ((Int, Int, Int, Int, Int) -> (Int, Int, Int, Int, Int) -> Bool), ((Int, Int, Int, Int, Int) -> (Int, Int, Int, Int, Int) -> Bool), ((Int, Int, Int, Int, Int) -> (Int, Int, Int, Int, Int) -> Bool), ((Int, Int, Int, Int, Int) -> (Int, Int, Int, Int, Int) -> Bool), ((Int, Int, Int, Int, Int) -> (Int, Int, Int, Int, Int) -> (Int, Int, Int, Int, Int)), ((Int, Int, Int, Int, Int) -> (Int, Int, Int, Int, Int) -> (Int, Int, Int, Int, Int)), ((Int, Int, Int, Int, Int) -> (Int, Int, Int, Int, Int) -> _CMP_TAG)] [_DFUN_ Eq ((Int, Int, Int, Int, Int)), _CONSTM_ Ord (<) ((Int, Int, Int, Int, Int)), _CONSTM_ Ord (<=) ((Int, Int, Int, Int, Int)), _CONSTM_ Ord (>=) ((Int, Int, Int, Int, Int)), _CONSTM_ Ord (>) ((Int, Int, Int, Int, Int)), _CONSTM_ Ord max ((Int, Int, Int, Int, Int)), _CONSTM_ Ord min ((Int, Int, Int, Int, Int)), _CONSTM_ Ord _tagCmp ((Int, Int, Int, Int, Int))] _N_
+ (<) = { _A_ 2 _U_ 11 _N_ _S_ "U(U(P)LLLL)U(U(P)LLLL)" _N_ _N_ },
+ (<=) = { _A_ 2 _U_ 11 _N_ _S_ "U(U(P)LLLL)U(U(P)LLLL)" _N_ _N_ },
+ (>=) = { _A_ 2 _U_ 11 _N_ _S_ "U(U(P)LLLL)U(U(P)LLLL)" _N_ _N_ },
+ (>) = { _A_ 2 _U_ 11 _N_ _S_ "U(U(P)LLLL)U(U(P)LLLL)" _N_ _N_ },
+ max = { _A_ 2 _U_ 22 _N_ _S_ "U(U(P)LLLL)U(U(P)LLLL)" _N_ _N_ },
+ min = { _A_ 2 _U_ 22 _N_ _S_ "U(U(P)LLLL)U(U(P)LLLL)" _N_ _N_ },
+ _tagCmp = { _A_ 2 _U_ 11 _N_ _S_ "U(U(P)LLLL)U(U(P)LLLL)" _N_ _N_ } #-}
+instance Ord ([Char], [Char])
+ {-# GHC_PRAGMA _M_ PreludeBuiltin {-dfun-} _A_ 0 _N_ _N_ _N_ _F_ _IF_ARGS_ 0 0 X 9 _!_ _TUP_8 [{{Eq ([Char], [Char])}}, (([Char], [Char]) -> ([Char], [Char]) -> Bool), (([Char], [Char]) -> ([Char], [Char]) -> Bool), (([Char], [Char]) -> ([Char], [Char]) -> Bool), (([Char], [Char]) -> ([Char], [Char]) -> Bool), (([Char], [Char]) -> ([Char], [Char]) -> ([Char], [Char])), (([Char], [Char]) -> ([Char], [Char]) -> ([Char], [Char])), (([Char], [Char]) -> ([Char], [Char]) -> _CMP_TAG)] [_DFUN_ Eq (([Char], [Char])), _CONSTM_ Ord (<) (([Char], [Char])), _CONSTM_ Ord (<=) (([Char], [Char])), _CONSTM_ Ord (>=) (([Char], [Char])), _CONSTM_ Ord (>) (([Char], [Char])), _CONSTM_ Ord max (([Char], [Char])), _CONSTM_ Ord min (([Char], [Char])), _CONSTM_ Ord _tagCmp (([Char], [Char]))] _N_
+ (<) = { _A_ 2 _U_ 11 _N_ _S_ "U(SL)U(SL)" {_A_ 4 _U_ 2222 _N_ _N_ _N_ _N_} _N_ _N_ },
+ (<=) = { _A_ 2 _U_ 11 _N_ _S_ "U(SL)U(SL)" {_A_ 4 _U_ 2222 _N_ _N_ _N_ _N_} _N_ _N_ },
+ (>=) = { _A_ 2 _U_ 11 _N_ _S_ "U(SL)U(SL)" {_A_ 4 _U_ 2222 _N_ _N_ _N_ _N_} _N_ _N_ },
+ (>) = { _A_ 2 _U_ 11 _N_ _S_ "U(SL)U(SL)" {_A_ 4 _U_ 2222 _N_ _N_ _N_ _N_} _N_ _N_ },
+ max = { _A_ 2 _U_ 11 _N_ _S_ "U(SL)U(SL)" {_A_ 4 _U_ 2222 _N_ _N_ _N_ _N_} _N_ _N_ },
+ min = { _A_ 2 _U_ 11 _N_ _S_ "U(SL)U(SL)" {_A_ 4 _U_ 2222 _N_ _N_ _N_ _N_} _N_ _N_ },
+ _tagCmp = { _A_ 2 _U_ 11 _N_ _S_ "U(SL)U(SL)" {_A_ 4 _U_ 2222 _N_ _N_ _N_ _N_} _N_ _N_ } #-}
+instance Ord ([Int], [Int])
+ {-# GHC_PRAGMA _M_ PreludeBuiltin {-dfun-} _A_ 0 _N_ _N_ _N_ _F_ _IF_ARGS_ 0 0 X 9 _!_ _TUP_8 [{{Eq ([Int], [Int])}}, (([Int], [Int]) -> ([Int], [Int]) -> Bool), (([Int], [Int]) -> ([Int], [Int]) -> Bool), (([Int], [Int]) -> ([Int], [Int]) -> Bool), (([Int], [Int]) -> ([Int], [Int]) -> Bool), (([Int], [Int]) -> ([Int], [Int]) -> ([Int], [Int])), (([Int], [Int]) -> ([Int], [Int]) -> ([Int], [Int])), (([Int], [Int]) -> ([Int], [Int]) -> _CMP_TAG)] [_DFUN_ Eq (([Int], [Int])), _CONSTM_ Ord (<) (([Int], [Int])), _CONSTM_ Ord (<=) (([Int], [Int])), _CONSTM_ Ord (>=) (([Int], [Int])), _CONSTM_ Ord (>) (([Int], [Int])), _CONSTM_ Ord max (([Int], [Int])), _CONSTM_ Ord min (([Int], [Int])), _CONSTM_ Ord _tagCmp (([Int], [Int]))] _N_
+ (<) = { _A_ 2 _U_ 11 _N_ _S_ "U(SL)U(SL)" {_A_ 4 _U_ 2222 _N_ _N_ _N_ _N_} _N_ _N_ },
+ (<=) = { _A_ 2 _U_ 11 _N_ _S_ "U(SL)U(SL)" {_A_ 4 _U_ 2222 _N_ _N_ _N_ _N_} _N_ _N_ },
+ (>=) = { _A_ 2 _U_ 11 _N_ _S_ "U(SL)U(SL)" {_A_ 4 _U_ 2222 _N_ _N_ _N_ _N_} _N_ _N_ },
+ (>) = { _A_ 2 _U_ 11 _N_ _S_ "U(SL)U(SL)" {_A_ 4 _U_ 2222 _N_ _N_ _N_ _N_} _N_ _N_ },
+ max = { _A_ 2 _U_ 11 _N_ _S_ "U(SL)U(SL)" {_A_ 4 _U_ 2222 _N_ _N_ _N_ _N_} _N_ _N_ },
+ min = { _A_ 2 _U_ 11 _N_ _S_ "U(SL)U(SL)" {_A_ 4 _U_ 2222 _N_ _N_ _N_ _N_} _N_ _N_ },
+ _tagCmp = { _A_ 2 _U_ 11 _N_ _S_ "U(SL)U(SL)" {_A_ 4 _U_ 2222 _N_ _N_ _N_ _N_} _N_ _N_ } #-}
instance Ord (_PackedString, _PackedString)
{-# GHC_PRAGMA _M_ PreludeBuiltin {-dfun-} _A_ 0 _N_ _N_ _N_ _F_ _IF_ARGS_ 0 0 X 9 _!_ _TUP_8 [{{Eq (_PackedString, _PackedString)}}, ((_PackedString, _PackedString) -> (_PackedString, _PackedString) -> Bool), ((_PackedString, _PackedString) -> (_PackedString, _PackedString) -> Bool), ((_PackedString, _PackedString) -> (_PackedString, _PackedString) -> Bool), ((_PackedString, _PackedString) -> (_PackedString, _PackedString) -> Bool), ((_PackedString, _PackedString) -> (_PackedString, _PackedString) -> (_PackedString, _PackedString)), ((_PackedString, _PackedString) -> (_PackedString, _PackedString) -> (_PackedString, _PackedString)), ((_PackedString, _PackedString) -> (_PackedString, _PackedString) -> _CMP_TAG)] [_DFUN_ Eq ((_PackedString, _PackedString)), _CONSTM_ Ord (<) ((_PackedString, _PackedString)), _CONSTM_ Ord (<=) ((_PackedString, _PackedString)), _CONSTM_ Ord (>=) ((_PackedString, _PackedString)), _CONSTM_ Ord (>) ((_PackedString, _PackedString)), _CONSTM_ Ord max ((_PackedString, _PackedString)), _CONSTM_ Ord min ((_PackedString, _PackedString)), _CONSTM_ Ord _tagCmp ((_PackedString, _PackedString))] _N_
- (<) = _A_ 2 _U_ 11 _N_ _S_ "U(SL)U(SL)" {_A_ 4 _U_ 2222 _N_ _N_ _N_ _N_} _N_ _N_,
- (<=) = _A_ 2 _U_ 11 _N_ _S_ "U(SL)U(SL)" {_A_ 4 _U_ 2222 _N_ _N_ _N_ _N_} _N_ _N_,
- (>=) = _A_ 2 _U_ 11 _N_ _S_ "U(SL)U(SL)" {_A_ 4 _U_ 2222 _N_ _N_ _N_ _N_} _N_ _N_,
- (>) = _A_ 2 _U_ 11 _N_ _S_ "U(SL)U(SL)" {_A_ 4 _U_ 2222 _N_ _N_ _N_ _N_} _N_ _N_,
- max = _A_ 2 _U_ 11 _N_ _S_ "U(SL)U(SL)" {_A_ 4 _U_ 2222 _N_ _N_ _N_ _N_} _N_ _N_,
- min = _A_ 2 _U_ 11 _N_ _S_ "U(SL)U(SL)" {_A_ 4 _U_ 2222 _N_ _N_ _N_ _N_} _N_ _N_,
- _tagCmp = _A_ 2 _U_ 11 _N_ _S_ "U(SL)U(SL)" {_A_ 4 _U_ 2222 _N_ _N_ _N_ _N_} _N_ _N_ #-}
+ (<) = { _A_ 2 _U_ 11 _N_ _S_ "U(SL)U(SL)" {_A_ 4 _U_ 2222 _N_ _N_ _N_ _N_} _N_ _N_ },
+ (<=) = { _A_ 2 _U_ 11 _N_ _S_ "U(SL)U(SL)" {_A_ 4 _U_ 2222 _N_ _N_ _N_ _N_} _N_ _N_ },
+ (>=) = { _A_ 2 _U_ 11 _N_ _S_ "U(SL)U(SL)" {_A_ 4 _U_ 2222 _N_ _N_ _N_ _N_} _N_ _N_ },
+ (>) = { _A_ 2 _U_ 11 _N_ _S_ "U(SL)U(SL)" {_A_ 4 _U_ 2222 _N_ _N_ _N_ _N_} _N_ _N_ },
+ max = { _A_ 2 _U_ 11 _N_ _S_ "U(SL)U(SL)" {_A_ 4 _U_ 2222 _N_ _N_ _N_ _N_} _N_ _N_ },
+ min = { _A_ 2 _U_ 11 _N_ _S_ "U(SL)U(SL)" {_A_ 4 _U_ 2222 _N_ _N_ _N_ _N_} _N_ _N_ },
+ _tagCmp = { _A_ 2 _U_ 11 _N_ _S_ "U(SL)U(SL)" {_A_ 4 _U_ 2222 _N_ _N_ _N_ _N_} _N_ _N_ } #-}
instance (Ix a, Ord b) => Ord (Array a b)
{-# GHC_PRAGMA _M_ PreludeArray {-dfun-} _A_ 3 _U_ 222 _N_ _N_ _N_ _N_ #-}
instance (Ord a, Ord b) => Ord (Assoc a b)
{-# GHC_PRAGMA _M_ PreludeArray {-dfun-} _A_ 3 _U_ 112 _N_ _N_ _N_ _N_ #-}
instance Ord Bool
{-# GHC_PRAGMA _M_ PreludeCore {-dfun-} _A_ 0 _N_ _N_ _N_ _F_ _IF_ARGS_ 0 0 X 9 _!_ _TUP_8 [{{Eq Bool}}, (Bool -> Bool -> Bool), (Bool -> Bool -> Bool), (Bool -> Bool -> Bool), (Bool -> Bool -> Bool), (Bool -> Bool -> Bool), (Bool -> Bool -> Bool), (Bool -> Bool -> _CMP_TAG)] [_DFUN_ Eq (Bool), _CONSTM_ Ord (<) (Bool), _CONSTM_ Ord (<=) (Bool), _CONSTM_ Ord (>=) (Bool), _CONSTM_ Ord (>) (Bool), _CONSTM_ Ord max (Bool), _CONSTM_ Ord min (Bool), _CONSTM_ Ord _tagCmp (Bool)] _N_
- (<) = _A_ 2 _U_ 11 _N_ _S_ "EE" _N_ _N_,
- (<=) = _A_ 2 _U_ 11 _N_ _S_ "EE" _N_ _N_,
- (>=) = _A_ 2 _U_ 11 _N_ _S_ "EE" _N_ _N_,
- (>) = _A_ 2 _U_ 11 _N_ _S_ "EE" _N_ _N_,
- max = _A_ 2 _U_ 22 _N_ _S_ "EE" _N_ _N_,
- min = _A_ 2 _U_ 22 _N_ _S_ "EE" _N_ _N_,
- _tagCmp = _A_ 2 _U_ 11 _N_ _S_ "EE" _N_ _N_ #-}
+ (<) = { _A_ 2 _U_ 11 _N_ _S_ "EE" _N_ _N_ },
+ (<=) = { _A_ 2 _U_ 11 _N_ _S_ "EE" _N_ _N_ },
+ (>=) = { _A_ 2 _U_ 11 _N_ _S_ "EE" _N_ _N_ },
+ (>) = { _A_ 2 _U_ 11 _N_ _S_ "EE" _N_ _N_ },
+ max = { _A_ 2 _U_ 22 _N_ _S_ "EE" _N_ _N_ },
+ min = { _A_ 2 _U_ 22 _N_ _S_ "EE" _N_ _N_ },
+ _tagCmp = { _A_ 2 _U_ 11 _N_ _S_ "EE" _N_ _N_ } #-}
instance Ord Char
{-# GHC_PRAGMA _M_ PreludeCore {-dfun-} _A_ 0 _N_ _N_ _N_ _F_ _IF_ARGS_ 0 0 X 9 _!_ _TUP_8 [{{Eq Char}}, (Char -> Char -> Bool), (Char -> Char -> Bool), (Char -> Char -> Bool), (Char -> Char -> Bool), (Char -> Char -> Char), (Char -> Char -> Char), (Char -> Char -> _CMP_TAG)] [_DFUN_ Eq (Char), _CONSTM_ Ord (<) (Char), _CONSTM_ Ord (<=) (Char), _CONSTM_ Ord (>=) (Char), _CONSTM_ Ord (>) (Char), _CONSTM_ Ord max (Char), _CONSTM_ Ord min (Char), _CONSTM_ Ord _tagCmp (Char)] _N_
- (<) = _A_ 2 _U_ 11 _N_ _S_ "U(P)U(P)" {_A_ 2 _U_ 22 _N_ _N_ _F_ _IF_ARGS_ 0 2 XX 1 \ (u0 :: Char#) (u1 :: Char#) -> _#_ ltChar# [] [u0, u1] _N_} _F_ _IF_ARGS_ 0 2 CC 3 \ (u0 :: Char) (u1 :: Char) -> case u0 of { _ALG_ C# (u2 :: Char#) -> case u1 of { _ALG_ C# (u3 :: Char#) -> _#_ ltChar# [] [u2, u3]; _NO_DEFLT_ }; _NO_DEFLT_ } _N_,
- (<=) = _A_ 2 _U_ 11 _N_ _S_ "U(P)U(P)" {_A_ 2 _U_ 22 _N_ _N_ _F_ _IF_ARGS_ 0 2 XX 1 \ (u0 :: Char#) (u1 :: Char#) -> _#_ leChar# [] [u0, u1] _N_} _F_ _IF_ARGS_ 0 2 CC 3 \ (u0 :: Char) (u1 :: Char) -> case u0 of { _ALG_ C# (u2 :: Char#) -> case u1 of { _ALG_ C# (u3 :: Char#) -> _#_ leChar# [] [u2, u3]; _NO_DEFLT_ }; _NO_DEFLT_ } _N_,
- (>=) = _A_ 2 _U_ 11 _N_ _S_ "U(P)U(P)" {_A_ 2 _U_ 22 _N_ _N_ _F_ _IF_ARGS_ 0 2 XX 1 \ (u0 :: Char#) (u1 :: Char#) -> _#_ geChar# [] [u0, u1] _N_} _F_ _IF_ARGS_ 0 2 CC 3 \ (u0 :: Char) (u1 :: Char) -> case u0 of { _ALG_ C# (u2 :: Char#) -> case u1 of { _ALG_ C# (u3 :: Char#) -> _#_ geChar# [] [u2, u3]; _NO_DEFLT_ }; _NO_DEFLT_ } _N_,
- (>) = _A_ 2 _U_ 11 _N_ _S_ "U(P)U(P)" {_A_ 2 _U_ 22 _N_ _N_ _F_ _IF_ARGS_ 0 2 XX 1 \ (u0 :: Char#) (u1 :: Char#) -> _#_ gtChar# [] [u0, u1] _N_} _F_ _IF_ARGS_ 0 2 CC 3 \ (u0 :: Char) (u1 :: Char) -> case u0 of { _ALG_ C# (u2 :: Char#) -> case u1 of { _ALG_ C# (u3 :: Char#) -> _#_ gtChar# [] [u2, u3]; _NO_DEFLT_ }; _NO_DEFLT_ } _N_,
- max = _A_ 2 _U_ 11 _N_ _S_ "U(P)U(P)" {_A_ 2 _U_ 22 _N_ _N_ _N_ _N_} _N_ _N_,
- min = _A_ 2 _U_ 11 _N_ _S_ "U(P)U(P)" {_A_ 2 _U_ 22 _N_ _N_ _N_ _N_} _N_ _N_,
- _tagCmp = _A_ 2 _U_ 11 _N_ _S_ "U(P)U(P)" {_A_ 2 _U_ 22 _N_ _N_ _N_ _N_} _N_ _N_ #-}
+ (<) = { _A_ 2 _U_ 11 _N_ _S_ "U(P)U(P)" {_A_ 2 _U_ 22 _N_ _N_ _F_ _IF_ARGS_ 0 2 XX 1 \ (u0 :: Char#) (u1 :: Char#) -> _#_ ltChar# [] [u0, u1] _N_} _F_ _IF_ARGS_ 0 2 CC 3 \ (u0 :: Char) (u1 :: Char) -> case u0 of { _ALG_ C# (u2 :: Char#) -> case u1 of { _ALG_ C# (u3 :: Char#) -> _#_ ltChar# [] [u2, u3]; _NO_DEFLT_ }; _NO_DEFLT_ } _N_ },
+ (<=) = { _A_ 2 _U_ 11 _N_ _S_ "U(P)U(P)" {_A_ 2 _U_ 22 _N_ _N_ _F_ _IF_ARGS_ 0 2 XX 1 \ (u0 :: Char#) (u1 :: Char#) -> _#_ leChar# [] [u0, u1] _N_} _F_ _IF_ARGS_ 0 2 CC 3 \ (u0 :: Char) (u1 :: Char) -> case u0 of { _ALG_ C# (u2 :: Char#) -> case u1 of { _ALG_ C# (u3 :: Char#) -> _#_ leChar# [] [u2, u3]; _NO_DEFLT_ }; _NO_DEFLT_ } _N_ },
+ (>=) = { _A_ 2 _U_ 11 _N_ _S_ "U(P)U(P)" {_A_ 2 _U_ 22 _N_ _N_ _F_ _IF_ARGS_ 0 2 XX 1 \ (u0 :: Char#) (u1 :: Char#) -> _#_ geChar# [] [u0, u1] _N_} _F_ _IF_ARGS_ 0 2 CC 3 \ (u0 :: Char) (u1 :: Char) -> case u0 of { _ALG_ C# (u2 :: Char#) -> case u1 of { _ALG_ C# (u3 :: Char#) -> _#_ geChar# [] [u2, u3]; _NO_DEFLT_ }; _NO_DEFLT_ } _N_ },
+ (>) = { _A_ 2 _U_ 11 _N_ _S_ "U(P)U(P)" {_A_ 2 _U_ 22 _N_ _N_ _F_ _IF_ARGS_ 0 2 XX 1 \ (u0 :: Char#) (u1 :: Char#) -> _#_ gtChar# [] [u0, u1] _N_} _F_ _IF_ARGS_ 0 2 CC 3 \ (u0 :: Char) (u1 :: Char) -> case u0 of { _ALG_ C# (u2 :: Char#) -> case u1 of { _ALG_ C# (u3 :: Char#) -> _#_ gtChar# [] [u2, u3]; _NO_DEFLT_ }; _NO_DEFLT_ } _N_ },
+ max = { _A_ 2 _U_ 11 _N_ _S_ "U(P)U(P)" {_A_ 2 _U_ 22 _N_ _N_ _N_ _N_} _N_ _N_ },
+ min = { _A_ 2 _U_ 11 _N_ _S_ "U(P)U(P)" {_A_ 2 _U_ 22 _N_ _N_ _N_ _N_} _N_ _N_ },
+ _tagCmp = { _A_ 2 _U_ 11 _N_ _S_ "U(P)U(P)" {_A_ 2 _U_ 22 _N_ _N_ _N_ _N_} _N_ _N_ } #-}
instance Ord Double
{-# GHC_PRAGMA _M_ PreludeCore {-dfun-} _A_ 0 _N_ _N_ _N_ _F_ _IF_ARGS_ 0 0 X 9 _!_ _TUP_8 [{{Eq Double}}, (Double -> Double -> Bool), (Double -> Double -> Bool), (Double -> Double -> Bool), (Double -> Double -> Bool), (Double -> Double -> Double), (Double -> Double -> Double), (Double -> Double -> _CMP_TAG)] [_DFUN_ Eq (Double), _CONSTM_ Ord (<) (Double), _CONSTM_ Ord (<=) (Double), _CONSTM_ Ord (>=) (Double), _CONSTM_ Ord (>) (Double), _CONSTM_ Ord max (Double), _CONSTM_ Ord min (Double), _CONSTM_ Ord _tagCmp (Double)] _N_
- (<) = _A_ 2 _U_ 11 _N_ _S_ "U(P)U(P)" {_A_ 2 _U_ 22 _N_ _N_ _F_ _IF_ARGS_ 0 2 XX 1 \ (u0 :: Double#) (u1 :: Double#) -> _#_ ltDouble# [] [u0, u1] _N_} _F_ _IF_ARGS_ 0 2 CC 3 \ (u0 :: Double) (u1 :: Double) -> case u0 of { _ALG_ D# (u2 :: Double#) -> case u1 of { _ALG_ D# (u3 :: Double#) -> _#_ ltDouble# [] [u2, u3]; _NO_DEFLT_ }; _NO_DEFLT_ } _N_,
- (<=) = _A_ 2 _U_ 11 _N_ _S_ "U(P)U(P)" {_A_ 2 _U_ 22 _N_ _N_ _F_ _IF_ARGS_ 0 2 XX 1 \ (u0 :: Double#) (u1 :: Double#) -> _#_ leDouble# [] [u0, u1] _N_} _F_ _IF_ARGS_ 0 2 CC 3 \ (u0 :: Double) (u1 :: Double) -> case u0 of { _ALG_ D# (u2 :: Double#) -> case u1 of { _ALG_ D# (u3 :: Double#) -> _#_ leDouble# [] [u2, u3]; _NO_DEFLT_ }; _NO_DEFLT_ } _N_,
- (>=) = _A_ 2 _U_ 11 _N_ _S_ "U(P)U(P)" {_A_ 2 _U_ 22 _N_ _N_ _F_ _IF_ARGS_ 0 2 XX 1 \ (u0 :: Double#) (u1 :: Double#) -> _#_ geDouble# [] [u0, u1] _N_} _F_ _IF_ARGS_ 0 2 CC 3 \ (u0 :: Double) (u1 :: Double) -> case u0 of { _ALG_ D# (u2 :: Double#) -> case u1 of { _ALG_ D# (u3 :: Double#) -> _#_ geDouble# [] [u2, u3]; _NO_DEFLT_ }; _NO_DEFLT_ } _N_,
- (>) = _A_ 2 _U_ 11 _N_ _S_ "U(P)U(P)" {_A_ 2 _U_ 22 _N_ _N_ _F_ _IF_ARGS_ 0 2 XX 1 \ (u0 :: Double#) (u1 :: Double#) -> _#_ gtDouble# [] [u0, u1] _N_} _F_ _IF_ARGS_ 0 2 CC 3 \ (u0 :: Double) (u1 :: Double) -> case u0 of { _ALG_ D# (u2 :: Double#) -> case u1 of { _ALG_ D# (u3 :: Double#) -> _#_ gtDouble# [] [u2, u3]; _NO_DEFLT_ }; _NO_DEFLT_ } _N_,
- max = _A_ 2 _U_ 11 _N_ _S_ "U(P)U(P)" {_A_ 2 _U_ 22 _N_ _N_ _N_ _N_} _N_ _N_,
- min = _A_ 2 _U_ 11 _N_ _S_ "U(P)U(P)" {_A_ 2 _U_ 22 _N_ _N_ _N_ _N_} _N_ _N_,
- _tagCmp = _A_ 2 _U_ 11 _N_ _S_ "U(P)U(P)" {_A_ 2 _U_ 22 _N_ _N_ _N_ _N_} _N_ _N_ #-}
+ (<) = { _A_ 2 _U_ 11 _N_ _S_ "U(P)U(P)" {_A_ 2 _U_ 22 _N_ _N_ _F_ _IF_ARGS_ 0 2 XX 1 \ (u0 :: Double#) (u1 :: Double#) -> _#_ ltDouble# [] [u0, u1] _N_} _F_ _IF_ARGS_ 0 2 CC 3 \ (u0 :: Double) (u1 :: Double) -> case u0 of { _ALG_ D# (u2 :: Double#) -> case u1 of { _ALG_ D# (u3 :: Double#) -> _#_ ltDouble# [] [u2, u3]; _NO_DEFLT_ }; _NO_DEFLT_ } _N_ },
+ (<=) = { _A_ 2 _U_ 11 _N_ _S_ "U(P)U(P)" {_A_ 2 _U_ 22 _N_ _N_ _F_ _IF_ARGS_ 0 2 XX 1 \ (u0 :: Double#) (u1 :: Double#) -> _#_ leDouble# [] [u0, u1] _N_} _F_ _IF_ARGS_ 0 2 CC 3 \ (u0 :: Double) (u1 :: Double) -> case u0 of { _ALG_ D# (u2 :: Double#) -> case u1 of { _ALG_ D# (u3 :: Double#) -> _#_ leDouble# [] [u2, u3]; _NO_DEFLT_ }; _NO_DEFLT_ } _N_ },
+ (>=) = { _A_ 2 _U_ 11 _N_ _S_ "U(P)U(P)" {_A_ 2 _U_ 22 _N_ _N_ _F_ _IF_ARGS_ 0 2 XX 1 \ (u0 :: Double#) (u1 :: Double#) -> _#_ geDouble# [] [u0, u1] _N_} _F_ _IF_ARGS_ 0 2 CC 3 \ (u0 :: Double) (u1 :: Double) -> case u0 of { _ALG_ D# (u2 :: Double#) -> case u1 of { _ALG_ D# (u3 :: Double#) -> _#_ geDouble# [] [u2, u3]; _NO_DEFLT_ }; _NO_DEFLT_ } _N_ },
+ (>) = { _A_ 2 _U_ 11 _N_ _S_ "U(P)U(P)" {_A_ 2 _U_ 22 _N_ _N_ _F_ _IF_ARGS_ 0 2 XX 1 \ (u0 :: Double#) (u1 :: Double#) -> _#_ gtDouble# [] [u0, u1] _N_} _F_ _IF_ARGS_ 0 2 CC 3 \ (u0 :: Double) (u1 :: Double) -> case u0 of { _ALG_ D# (u2 :: Double#) -> case u1 of { _ALG_ D# (u3 :: Double#) -> _#_ gtDouble# [] [u2, u3]; _NO_DEFLT_ }; _NO_DEFLT_ } _N_ },
+ max = { _A_ 2 _U_ 11 _N_ _S_ "U(P)U(P)" {_A_ 2 _U_ 22 _N_ _N_ _N_ _N_} _N_ _N_ },
+ min = { _A_ 2 _U_ 11 _N_ _S_ "U(P)U(P)" {_A_ 2 _U_ 22 _N_ _N_ _N_ _N_} _N_ _N_ },
+ _tagCmp = { _A_ 2 _U_ 11 _N_ _S_ "U(P)U(P)" {_A_ 2 _U_ 22 _N_ _N_ _N_ _N_} _N_ _N_ } #-}
instance (Ord a, Ord b) => Ord (Either a b)
{-# GHC_PRAGMA _M_ PreludeMonadicIO {-dfun-} _A_ 3 _U_ 222 _N_ _N_ _N_ _N_ #-}
instance Ord Float
{-# GHC_PRAGMA _M_ PreludeCore {-dfun-} _A_ 0 _N_ _N_ _N_ _F_ _IF_ARGS_ 0 0 X 9 _!_ _TUP_8 [{{Eq Float}}, (Float -> Float -> Bool), (Float -> Float -> Bool), (Float -> Float -> Bool), (Float -> Float -> Bool), (Float -> Float -> Float), (Float -> Float -> Float), (Float -> Float -> _CMP_TAG)] [_DFUN_ Eq (Float), _CONSTM_ Ord (<) (Float), _CONSTM_ Ord (<=) (Float), _CONSTM_ Ord (>=) (Float), _CONSTM_ Ord (>) (Float), _CONSTM_ Ord max (Float), _CONSTM_ Ord min (Float), _CONSTM_ Ord _tagCmp (Float)] _N_
- (<) = _A_ 2 _U_ 11 _N_ _S_ "U(P)U(P)" {_A_ 2 _U_ 22 _N_ _N_ _F_ _IF_ARGS_ 0 2 XX 1 \ (u0 :: Float#) (u1 :: Float#) -> _#_ ltFloat# [] [u0, u1] _N_} _F_ _IF_ARGS_ 0 2 CC 3 \ (u0 :: Float) (u1 :: Float) -> case u0 of { _ALG_ F# (u2 :: Float#) -> case u1 of { _ALG_ F# (u3 :: Float#) -> _#_ ltFloat# [] [u2, u3]; _NO_DEFLT_ }; _NO_DEFLT_ } _N_,
- (<=) = _A_ 2 _U_ 11 _N_ _S_ "U(P)U(P)" {_A_ 2 _U_ 22 _N_ _N_ _F_ _IF_ARGS_ 0 2 XX 1 \ (u0 :: Float#) (u1 :: Float#) -> _#_ leFloat# [] [u0, u1] _N_} _F_ _IF_ARGS_ 0 2 CC 3 \ (u0 :: Float) (u1 :: Float) -> case u0 of { _ALG_ F# (u2 :: Float#) -> case u1 of { _ALG_ F# (u3 :: Float#) -> _#_ leFloat# [] [u2, u3]; _NO_DEFLT_ }; _NO_DEFLT_ } _N_,
- (>=) = _A_ 2 _U_ 11 _N_ _S_ "U(P)U(P)" {_A_ 2 _U_ 22 _N_ _N_ _F_ _IF_ARGS_ 0 2 XX 1 \ (u0 :: Float#) (u1 :: Float#) -> _#_ geFloat# [] [u0, u1] _N_} _F_ _IF_ARGS_ 0 2 CC 3 \ (u0 :: Float) (u1 :: Float) -> case u0 of { _ALG_ F# (u2 :: Float#) -> case u1 of { _ALG_ F# (u3 :: Float#) -> _#_ geFloat# [] [u2, u3]; _NO_DEFLT_ }; _NO_DEFLT_ } _N_,
- (>) = _A_ 2 _U_ 11 _N_ _S_ "U(P)U(P)" {_A_ 2 _U_ 22 _N_ _N_ _F_ _IF_ARGS_ 0 2 XX 1 \ (u0 :: Float#) (u1 :: Float#) -> _#_ gtFloat# [] [u0, u1] _N_} _F_ _IF_ARGS_ 0 2 CC 3 \ (u0 :: Float) (u1 :: Float) -> case u0 of { _ALG_ F# (u2 :: Float#) -> case u1 of { _ALG_ F# (u3 :: Float#) -> _#_ gtFloat# [] [u2, u3]; _NO_DEFLT_ }; _NO_DEFLT_ } _N_,
- max = _A_ 2 _U_ 11 _N_ _S_ "U(P)U(P)" {_A_ 2 _U_ 22 _N_ _N_ _N_ _N_} _N_ _N_,
- min = _A_ 2 _U_ 11 _N_ _S_ "U(P)U(P)" {_A_ 2 _U_ 22 _N_ _N_ _N_ _N_} _N_ _N_,
- _tagCmp = _A_ 2 _U_ 11 _N_ _S_ "U(P)U(P)" {_A_ 2 _U_ 22 _N_ _N_ _N_ _N_} _N_ _N_ #-}
+ (<) = { _A_ 2 _U_ 11 _N_ _S_ "U(P)U(P)" {_A_ 2 _U_ 22 _N_ _N_ _F_ _IF_ARGS_ 0 2 XX 1 \ (u0 :: Float#) (u1 :: Float#) -> _#_ ltFloat# [] [u0, u1] _N_} _F_ _IF_ARGS_ 0 2 CC 3 \ (u0 :: Float) (u1 :: Float) -> case u0 of { _ALG_ F# (u2 :: Float#) -> case u1 of { _ALG_ F# (u3 :: Float#) -> _#_ ltFloat# [] [u2, u3]; _NO_DEFLT_ }; _NO_DEFLT_ } _N_ },
+ (<=) = { _A_ 2 _U_ 11 _N_ _S_ "U(P)U(P)" {_A_ 2 _U_ 22 _N_ _N_ _F_ _IF_ARGS_ 0 2 XX 1 \ (u0 :: Float#) (u1 :: Float#) -> _#_ leFloat# [] [u0, u1] _N_} _F_ _IF_ARGS_ 0 2 CC 3 \ (u0 :: Float) (u1 :: Float) -> case u0 of { _ALG_ F# (u2 :: Float#) -> case u1 of { _ALG_ F# (u3 :: Float#) -> _#_ leFloat# [] [u2, u3]; _NO_DEFLT_ }; _NO_DEFLT_ } _N_ },
+ (>=) = { _A_ 2 _U_ 11 _N_ _S_ "U(P)U(P)" {_A_ 2 _U_ 22 _N_ _N_ _F_ _IF_ARGS_ 0 2 XX 1 \ (u0 :: Float#) (u1 :: Float#) -> _#_ geFloat# [] [u0, u1] _N_} _F_ _IF_ARGS_ 0 2 CC 3 \ (u0 :: Float) (u1 :: Float) -> case u0 of { _ALG_ F# (u2 :: Float#) -> case u1 of { _ALG_ F# (u3 :: Float#) -> _#_ geFloat# [] [u2, u3]; _NO_DEFLT_ }; _NO_DEFLT_ } _N_ },
+ (>) = { _A_ 2 _U_ 11 _N_ _S_ "U(P)U(P)" {_A_ 2 _U_ 22 _N_ _N_ _F_ _IF_ARGS_ 0 2 XX 1 \ (u0 :: Float#) (u1 :: Float#) -> _#_ gtFloat# [] [u0, u1] _N_} _F_ _IF_ARGS_ 0 2 CC 3 \ (u0 :: Float) (u1 :: Float) -> case u0 of { _ALG_ F# (u2 :: Float#) -> case u1 of { _ALG_ F# (u3 :: Float#) -> _#_ gtFloat# [] [u2, u3]; _NO_DEFLT_ }; _NO_DEFLT_ } _N_ },
+ max = { _A_ 2 _U_ 11 _N_ _S_ "U(P)U(P)" {_A_ 2 _U_ 22 _N_ _N_ _N_ _N_} _N_ _N_ },
+ min = { _A_ 2 _U_ 11 _N_ _S_ "U(P)U(P)" {_A_ 2 _U_ 22 _N_ _N_ _N_ _N_} _N_ _N_ },
+ _tagCmp = { _A_ 2 _U_ 11 _N_ _S_ "U(P)U(P)" {_A_ 2 _U_ 22 _N_ _N_ _N_ _N_} _N_ _N_ } #-}
instance Ord Int
{-# GHC_PRAGMA _M_ PreludeCore {-dfun-} _A_ 0 _N_ _N_ _N_ _F_ _IF_ARGS_ 0 0 X 9 _!_ _TUP_8 [{{Eq Int}}, (Int -> Int -> Bool), (Int -> Int -> Bool), (Int -> Int -> Bool), (Int -> Int -> Bool), (Int -> Int -> Int), (Int -> Int -> Int), (Int -> Int -> _CMP_TAG)] [_DFUN_ Eq (Int), _CONSTM_ Ord (<) (Int), _CONSTM_ Ord (<=) (Int), _CONSTM_ Ord (>=) (Int), _CONSTM_ Ord (>) (Int), _CONSTM_ Ord max (Int), _CONSTM_ Ord min (Int), _CONSTM_ Ord _tagCmp (Int)] _N_
- (<) = _A_ 2 _U_ 11 _N_ _S_ "U(P)U(P)" {_A_ 2 _U_ 22 _N_ _N_ _F_ _IF_ARGS_ 0 2 XX 1 \ (u0 :: Int#) (u1 :: Int#) -> _#_ ltInt# [] [u0, u1] _N_} _F_ _IF_ARGS_ 0 2 CC 3 \ (u0 :: Int) (u1 :: Int) -> case u0 of { _ALG_ I# (u2 :: Int#) -> case u1 of { _ALG_ I# (u3 :: Int#) -> _#_ ltInt# [] [u2, u3]; _NO_DEFLT_ }; _NO_DEFLT_ } _N_,
- (<=) = _A_ 2 _U_ 11 _N_ _S_ "U(P)U(P)" {_A_ 2 _U_ 22 _N_ _N_ _F_ _IF_ARGS_ 0 2 XX 1 \ (u0 :: Int#) (u1 :: Int#) -> _#_ leInt# [] [u0, u1] _N_} _F_ _IF_ARGS_ 0 2 CC 3 \ (u0 :: Int) (u1 :: Int) -> case u0 of { _ALG_ I# (u2 :: Int#) -> case u1 of { _ALG_ I# (u3 :: Int#) -> _#_ leInt# [] [u2, u3]; _NO_DEFLT_ }; _NO_DEFLT_ } _N_,
- (>=) = _A_ 2 _U_ 11 _N_ _S_ "U(P)U(P)" {_A_ 2 _U_ 22 _N_ _N_ _F_ _IF_ARGS_ 0 2 XX 1 \ (u0 :: Int#) (u1 :: Int#) -> _#_ geInt# [] [u0, u1] _N_} _F_ _IF_ARGS_ 0 2 CC 3 \ (u0 :: Int) (u1 :: Int) -> case u0 of { _ALG_ I# (u2 :: Int#) -> case u1 of { _ALG_ I# (u3 :: Int#) -> _#_ geInt# [] [u2, u3]; _NO_DEFLT_ }; _NO_DEFLT_ } _N_,
- (>) = _A_ 2 _U_ 11 _N_ _S_ "U(P)U(P)" {_A_ 2 _U_ 22 _N_ _N_ _F_ _IF_ARGS_ 0 2 XX 1 \ (u0 :: Int#) (u1 :: Int#) -> _#_ gtInt# [] [u0, u1] _N_} _F_ _IF_ARGS_ 0 2 CC 3 \ (u0 :: Int) (u1 :: Int) -> case u0 of { _ALG_ I# (u2 :: Int#) -> case u1 of { _ALG_ I# (u3 :: Int#) -> _#_ gtInt# [] [u2, u3]; _NO_DEFLT_ }; _NO_DEFLT_ } _N_,
- max = _A_ 2 _U_ 11 _N_ _S_ "U(P)U(P)" {_A_ 2 _U_ 22 _N_ _N_ _N_ _N_} _N_ _N_,
- min = _A_ 2 _U_ 11 _N_ _S_ "U(P)U(P)" {_A_ 2 _U_ 22 _N_ _N_ _N_ _N_} _N_ _N_,
- _tagCmp = _A_ 2 _U_ 11 _N_ _S_ "U(P)U(P)" {_A_ 2 _U_ 22 _N_ _N_ _N_ _N_} _N_ _N_ #-}
+ (<) = { _A_ 2 _U_ 11 _N_ _S_ "U(P)U(P)" {_A_ 2 _U_ 22 _N_ _N_ _F_ _IF_ARGS_ 0 2 XX 1 \ (u0 :: Int#) (u1 :: Int#) -> _#_ ltInt# [] [u0, u1] _N_} _F_ _IF_ARGS_ 0 2 CC 3 \ (u0 :: Int) (u1 :: Int) -> case u0 of { _ALG_ I# (u2 :: Int#) -> case u1 of { _ALG_ I# (u3 :: Int#) -> _#_ ltInt# [] [u2, u3]; _NO_DEFLT_ }; _NO_DEFLT_ } _N_ },
+ (<=) = { _A_ 2 _U_ 11 _N_ _S_ "U(P)U(P)" {_A_ 2 _U_ 22 _N_ _N_ _F_ _IF_ARGS_ 0 2 XX 1 \ (u0 :: Int#) (u1 :: Int#) -> _#_ leInt# [] [u0, u1] _N_} _F_ _IF_ARGS_ 0 2 CC 3 \ (u0 :: Int) (u1 :: Int) -> case u0 of { _ALG_ I# (u2 :: Int#) -> case u1 of { _ALG_ I# (u3 :: Int#) -> _#_ leInt# [] [u2, u3]; _NO_DEFLT_ }; _NO_DEFLT_ } _N_ },
+ (>=) = { _A_ 2 _U_ 11 _N_ _S_ "U(P)U(P)" {_A_ 2 _U_ 22 _N_ _N_ _F_ _IF_ARGS_ 0 2 XX 1 \ (u0 :: Int#) (u1 :: Int#) -> _#_ geInt# [] [u0, u1] _N_} _F_ _IF_ARGS_ 0 2 CC 3 \ (u0 :: Int) (u1 :: Int) -> case u0 of { _ALG_ I# (u2 :: Int#) -> case u1 of { _ALG_ I# (u3 :: Int#) -> _#_ geInt# [] [u2, u3]; _NO_DEFLT_ }; _NO_DEFLT_ } _N_ },
+ (>) = { _A_ 2 _U_ 11 _N_ _S_ "U(P)U(P)" {_A_ 2 _U_ 22 _N_ _N_ _F_ _IF_ARGS_ 0 2 XX 1 \ (u0 :: Int#) (u1 :: Int#) -> _#_ gtInt# [] [u0, u1] _N_} _F_ _IF_ARGS_ 0 2 CC 3 \ (u0 :: Int) (u1 :: Int) -> case u0 of { _ALG_ I# (u2 :: Int#) -> case u1 of { _ALG_ I# (u3 :: Int#) -> _#_ gtInt# [] [u2, u3]; _NO_DEFLT_ }; _NO_DEFLT_ } _N_ },
+ max = { _A_ 2 _U_ 11 _N_ _S_ "U(P)U(P)" {_A_ 2 _U_ 22 _N_ _N_ _N_ _N_} _N_ _N_ },
+ min = { _A_ 2 _U_ 11 _N_ _S_ "U(P)U(P)" {_A_ 2 _U_ 22 _N_ _N_ _N_ _N_} _N_ _N_ },
+ _tagCmp = { _A_ 2 _U_ 11 _N_ _S_ "U(P)U(P)" {_A_ 2 _U_ 22 _N_ _N_ _N_ _N_} _N_ _N_ } #-}
instance Ord Integer
{-# GHC_PRAGMA _M_ PreludeCore {-dfun-} _A_ 0 _N_ _N_ _N_ _F_ _IF_ARGS_ 0 0 X 9 _!_ _TUP_8 [{{Eq Integer}}, (Integer -> Integer -> Bool), (Integer -> Integer -> Bool), (Integer -> Integer -> Bool), (Integer -> Integer -> Bool), (Integer -> Integer -> Integer), (Integer -> Integer -> Integer), (Integer -> Integer -> _CMP_TAG)] [_DFUN_ Eq (Integer), _CONSTM_ Ord (<) (Integer), _CONSTM_ Ord (<=) (Integer), _CONSTM_ Ord (>=) (Integer), _CONSTM_ Ord (>) (Integer), _CONSTM_ Ord max (Integer), _CONSTM_ Ord min (Integer), _CONSTM_ Ord _tagCmp (Integer)] _N_
- (<) = _A_ 2 _U_ 11 _N_ _S_ "U(PPP)U(PPP)" {_A_ 4 _U_ 2221 _N_ _N_ _F_ _IF_ARGS_ 0 4 XXXC 3 \ (u0 :: Int#) (u1 :: Int#) (u2 :: ByteArray#) (u3 :: Integer) -> case u3 of { _ALG_ J# (u4 :: Int#) (u5 :: Int#) (u6 :: ByteArray#) -> case _#_ cmpInteger# [] [u0, u1, u2, u4, u5, u6] of { _PRIM_ (u7 :: Int#) -> _#_ ltInt# [] [u7, 0#] }; _NO_DEFLT_ } _N_} _F_ _IF_ARGS_ 0 2 CC 4 \ (u0 :: Integer) (u1 :: Integer) -> case u0 of { _ALG_ J# (u2 :: Int#) (u3 :: Int#) (u4 :: ByteArray#) -> case u1 of { _ALG_ J# (u5 :: Int#) (u6 :: Int#) (u7 :: ByteArray#) -> case _#_ cmpInteger# [] [u2, u3, u4, u5, u6, u7] of { _PRIM_ (u8 :: Int#) -> _#_ ltInt# [] [u8, 0#] }; _NO_DEFLT_ }; _NO_DEFLT_ } _N_,
- (<=) = _A_ 2 _U_ 11 _N_ _S_ "U(PPP)U(PPP)" {_A_ 4 _U_ 2221 _N_ _N_ _F_ _IF_ARGS_ 0 4 XXXC 3 \ (u0 :: Int#) (u1 :: Int#) (u2 :: ByteArray#) (u3 :: Integer) -> case u3 of { _ALG_ J# (u4 :: Int#) (u5 :: Int#) (u6 :: ByteArray#) -> case _#_ cmpInteger# [] [u0, u1, u2, u4, u5, u6] of { _PRIM_ (u7 :: Int#) -> _#_ leInt# [] [u7, 0#] }; _NO_DEFLT_ } _N_} _F_ _IF_ARGS_ 0 2 CC 4 \ (u0 :: Integer) (u1 :: Integer) -> case u0 of { _ALG_ J# (u2 :: Int#) (u3 :: Int#) (u4 :: ByteArray#) -> case u1 of { _ALG_ J# (u5 :: Int#) (u6 :: Int#) (u7 :: ByteArray#) -> case _#_ cmpInteger# [] [u2, u3, u4, u5, u6, u7] of { _PRIM_ (u8 :: Int#) -> _#_ leInt# [] [u8, 0#] }; _NO_DEFLT_ }; _NO_DEFLT_ } _N_,
- (>=) = _A_ 2 _U_ 11 _N_ _S_ "U(PPP)U(PPP)" {_A_ 4 _U_ 2221 _N_ _N_ _F_ _IF_ARGS_ 0 4 XXXC 3 \ (u0 :: Int#) (u1 :: Int#) (u2 :: ByteArray#) (u3 :: Integer) -> case u3 of { _ALG_ J# (u4 :: Int#) (u5 :: Int#) (u6 :: ByteArray#) -> case _#_ cmpInteger# [] [u0, u1, u2, u4, u5, u6] of { _PRIM_ (u7 :: Int#) -> _#_ geInt# [] [u7, 0#] }; _NO_DEFLT_ } _N_} _F_ _IF_ARGS_ 0 2 CC 4 \ (u0 :: Integer) (u1 :: Integer) -> case u0 of { _ALG_ J# (u2 :: Int#) (u3 :: Int#) (u4 :: ByteArray#) -> case u1 of { _ALG_ J# (u5 :: Int#) (u6 :: Int#) (u7 :: ByteArray#) -> case _#_ cmpInteger# [] [u2, u3, u4, u5, u6, u7] of { _PRIM_ (u8 :: Int#) -> _#_ geInt# [] [u8, 0#] }; _NO_DEFLT_ }; _NO_DEFLT_ } _N_,
- (>) = _A_ 2 _U_ 11 _N_ _S_ "U(PPP)U(PPP)" {_A_ 4 _U_ 2221 _N_ _N_ _F_ _IF_ARGS_ 0 4 XXXC 3 \ (u0 :: Int#) (u1 :: Int#) (u2 :: ByteArray#) (u3 :: Integer) -> case u3 of { _ALG_ J# (u4 :: Int#) (u5 :: Int#) (u6 :: ByteArray#) -> case _#_ cmpInteger# [] [u0, u1, u2, u4, u5, u6] of { _PRIM_ (u7 :: Int#) -> _#_ gtInt# [] [u7, 0#] }; _NO_DEFLT_ } _N_} _F_ _IF_ARGS_ 0 2 CC 4 \ (u0 :: Integer) (u1 :: Integer) -> case u0 of { _ALG_ J# (u2 :: Int#) (u3 :: Int#) (u4 :: ByteArray#) -> case u1 of { _ALG_ J# (u5 :: Int#) (u6 :: Int#) (u7 :: ByteArray#) -> case _#_ cmpInteger# [] [u2, u3, u4, u5, u6, u7] of { _PRIM_ (u8 :: Int#) -> _#_ gtInt# [] [u8, 0#] }; _NO_DEFLT_ }; _NO_DEFLT_ } _N_,
- max = _A_ 2 _U_ 11 _N_ _S_ "U(PPP)U(PPP)" {_A_ 4 _U_ 2221 _N_ _N_ _N_ _N_} _N_ _N_,
- min = _A_ 2 _U_ 11 _N_ _S_ "U(PPP)U(PPP)" {_A_ 4 _U_ 2221 _N_ _N_ _N_ _N_} _N_ _N_,
- _tagCmp = _A_ 2 _U_ 11 _N_ _S_ "U(PPP)U(PPP)" {_A_ 4 _U_ 2221 _N_ _N_ _N_ _N_} _N_ _N_ #-}
+ (<) = { _A_ 2 _U_ 11 _N_ _S_ "U(PPP)U(PPP)" {_A_ 4 _U_ 2221 _N_ _N_ _F_ _IF_ARGS_ 0 4 XXXC 3 \ (u0 :: Int#) (u1 :: Int#) (u2 :: ByteArray#) (u3 :: Integer) -> case u3 of { _ALG_ J# (u4 :: Int#) (u5 :: Int#) (u6 :: ByteArray#) -> case _#_ cmpInteger# [] [u0, u1, u2, u4, u5, u6] of { _PRIM_ (u7 :: Int#) -> _#_ ltInt# [] [u7, 0#] }; _NO_DEFLT_ } _N_} _F_ _IF_ARGS_ 0 2 CC 4 \ (u0 :: Integer) (u1 :: Integer) -> case u0 of { _ALG_ J# (u2 :: Int#) (u3 :: Int#) (u4 :: ByteArray#) -> case u1 of { _ALG_ J# (u5 :: Int#) (u6 :: Int#) (u7 :: ByteArray#) -> case _#_ cmpInteger# [] [u2, u3, u4, u5, u6, u7] of { _PRIM_ (u8 :: Int#) -> _#_ ltInt# [] [u8, 0#] }; _NO_DEFLT_ }; _NO_DEFLT_ } _N_ },
+ (<=) = { _A_ 2 _U_ 11 _N_ _S_ "U(PPP)U(PPP)" {_A_ 4 _U_ 2221 _N_ _N_ _F_ _IF_ARGS_ 0 4 XXXC 3 \ (u0 :: Int#) (u1 :: Int#) (u2 :: ByteArray#) (u3 :: Integer) -> case u3 of { _ALG_ J# (u4 :: Int#) (u5 :: Int#) (u6 :: ByteArray#) -> case _#_ cmpInteger# [] [u0, u1, u2, u4, u5, u6] of { _PRIM_ (u7 :: Int#) -> _#_ leInt# [] [u7, 0#] }; _NO_DEFLT_ } _N_} _F_ _IF_ARGS_ 0 2 CC 4 \ (u0 :: Integer) (u1 :: Integer) -> case u0 of { _ALG_ J# (u2 :: Int#) (u3 :: Int#) (u4 :: ByteArray#) -> case u1 of { _ALG_ J# (u5 :: Int#) (u6 :: Int#) (u7 :: ByteArray#) -> case _#_ cmpInteger# [] [u2, u3, u4, u5, u6, u7] of { _PRIM_ (u8 :: Int#) -> _#_ leInt# [] [u8, 0#] }; _NO_DEFLT_ }; _NO_DEFLT_ } _N_ },
+ (>=) = { _A_ 2 _U_ 11 _N_ _S_ "U(PPP)U(PPP)" {_A_ 4 _U_ 2221 _N_ _N_ _F_ _IF_ARGS_ 0 4 XXXC 3 \ (u0 :: Int#) (u1 :: Int#) (u2 :: ByteArray#) (u3 :: Integer) -> case u3 of { _ALG_ J# (u4 :: Int#) (u5 :: Int#) (u6 :: ByteArray#) -> case _#_ cmpInteger# [] [u0, u1, u2, u4, u5, u6] of { _PRIM_ (u7 :: Int#) -> _#_ geInt# [] [u7, 0#] }; _NO_DEFLT_ } _N_} _F_ _IF_ARGS_ 0 2 CC 4 \ (u0 :: Integer) (u1 :: Integer) -> case u0 of { _ALG_ J# (u2 :: Int#) (u3 :: Int#) (u4 :: ByteArray#) -> case u1 of { _ALG_ J# (u5 :: Int#) (u6 :: Int#) (u7 :: ByteArray#) -> case _#_ cmpInteger# [] [u2, u3, u4, u5, u6, u7] of { _PRIM_ (u8 :: Int#) -> _#_ geInt# [] [u8, 0#] }; _NO_DEFLT_ }; _NO_DEFLT_ } _N_ },
+ (>) = { _A_ 2 _U_ 11 _N_ _S_ "U(PPP)U(PPP)" {_A_ 4 _U_ 2221 _N_ _N_ _F_ _IF_ARGS_ 0 4 XXXC 3 \ (u0 :: Int#) (u1 :: Int#) (u2 :: ByteArray#) (u3 :: Integer) -> case u3 of { _ALG_ J# (u4 :: Int#) (u5 :: Int#) (u6 :: ByteArray#) -> case _#_ cmpInteger# [] [u0, u1, u2, u4, u5, u6] of { _PRIM_ (u7 :: Int#) -> _#_ gtInt# [] [u7, 0#] }; _NO_DEFLT_ } _N_} _F_ _IF_ARGS_ 0 2 CC 4 \ (u0 :: Integer) (u1 :: Integer) -> case u0 of { _ALG_ J# (u2 :: Int#) (u3 :: Int#) (u4 :: ByteArray#) -> case u1 of { _ALG_ J# (u5 :: Int#) (u6 :: Int#) (u7 :: ByteArray#) -> case _#_ cmpInteger# [] [u2, u3, u4, u5, u6, u7] of { _PRIM_ (u8 :: Int#) -> _#_ gtInt# [] [u8, 0#] }; _NO_DEFLT_ }; _NO_DEFLT_ } _N_ },
+ max = { _A_ 2 _U_ 11 _N_ _S_ "U(PPP)U(PPP)" {_A_ 4 _U_ 2221 _N_ _N_ _N_ _N_} _N_ _N_ },
+ min = { _A_ 2 _U_ 11 _N_ _S_ "U(PPP)U(PPP)" {_A_ 4 _U_ 2221 _N_ _N_ _N_ _N_} _N_ _N_ },
+ _tagCmp = { _A_ 2 _U_ 11 _N_ _S_ "U(PPP)U(PPP)" {_A_ 4 _U_ 2221 _N_ _N_ _N_ _N_} _N_ _N_ } #-}
instance Ord a => Ord (Maybe a)
{-# GHC_PRAGMA _M_ PreludeStdIO {-dfun-} _A_ 2 _U_ 22 _N_ _N_ _N_ _N_ #-}
instance Integral a => Ord (Ratio a)
{-# GHC_PRAGMA _M_ PreludeRatio {-dfun-} _A_ 2 _U_ 22 _N_ _N_ _N_ _N_ #-}
instance Ord (Ratio Integer)
{-# GHC_PRAGMA _M_ PreludeRatio {-dfun-} _A_ 0 _N_ _N_ _N_ _F_ _IF_ARGS_ 0 0 X 9 _!_ _TUP_8 [{{Eq (Ratio Integer)}}, (Ratio Integer -> Ratio Integer -> Bool), (Ratio Integer -> Ratio Integer -> Bool), (Ratio Integer -> Ratio Integer -> Bool), (Ratio Integer -> Ratio Integer -> Bool), (Ratio Integer -> Ratio Integer -> Ratio Integer), (Ratio Integer -> Ratio Integer -> Ratio Integer), (Ratio Integer -> Ratio Integer -> _CMP_TAG)] [_DFUN_ Eq (Ratio Integer), _CONSTM_ Ord (<) (Ratio Integer), _CONSTM_ Ord (<=) (Ratio Integer), _CONSTM_ Ord (>=) (Ratio Integer), _CONSTM_ Ord (>) (Ratio Integer), _CONSTM_ Ord max (Ratio Integer), _CONSTM_ Ord min (Ratio Integer), _CONSTM_ Ord _tagCmp (Ratio Integer)] _N_
- (<) = _A_ 2 _U_ 11 _N_ _S_ "U(U(PPP)U(PPP))U(U(PPP)U(PPP))" {_A_ 5 _U_ 22221 _N_ _N_ _N_ _N_} _N_ _N_,
- (<=) = _A_ 2 _U_ 11 _N_ _S_ "U(U(PPP)U(PPP))U(U(PPP)U(PPP))" {_A_ 5 _U_ 22221 _N_ _N_ _N_ _N_} _N_ _N_,
- (>=) = _A_ 2 _U_ 11 _N_ _S_ "U(U(PPP)U(PPP))U(U(PPP)U(PPP))" {_A_ 5 _U_ 22221 _N_ _N_ _N_ _N_} _N_ _N_,
- (>) = _A_ 2 _U_ 11 _N_ _S_ "U(U(PPP)U(PPP))U(U(PPP)U(PPP))" {_A_ 5 _U_ 22221 _N_ _N_ _N_ _N_} _N_ _N_,
- max = _A_ 2 _U_ 12 _N_ _S_ "U(U(PPP)U(PPP))U(U(PPP)U(PPP))" {_A_ 5 _U_ 22222 _N_ _N_ _N_ _N_} _N_ _N_,
- min = _A_ 2 _U_ 12 _N_ _S_ "U(U(PPP)U(PPP))U(U(PPP)U(PPP))" {_A_ 5 _U_ 22222 _N_ _N_ _N_ _N_} _N_ _N_,
- _tagCmp = _A_ 2 _U_ 11 _N_ _S_ "U(U(PPP)U(PPP))U(U(PPP)U(PPP))" {_A_ 5 _U_ 22221 _N_ _N_ _N_ _N_} _N_ _N_ #-}
+ (<) = { _A_ 2 _U_ 11 _N_ _S_ "U(U(PPP)U(PPP))U(U(PPP)U(PPP))" {_A_ 5 _U_ 22221 _N_ _N_ _N_ _N_} _N_ _N_ },
+ (<=) = { _A_ 2 _U_ 11 _N_ _S_ "U(U(PPP)U(PPP))U(U(PPP)U(PPP))" {_A_ 5 _U_ 22221 _N_ _N_ _N_ _N_} _N_ _N_ },
+ (>=) = { _A_ 2 _U_ 11 _N_ _S_ "U(U(PPP)U(PPP))U(U(PPP)U(PPP))" {_A_ 5 _U_ 22221 _N_ _N_ _N_ _N_} _N_ _N_ },
+ (>) = { _A_ 2 _U_ 11 _N_ _S_ "U(U(PPP)U(PPP))U(U(PPP)U(PPP))" {_A_ 5 _U_ 22221 _N_ _N_ _N_ _N_} _N_ _N_ },
+ max = { _A_ 2 _U_ 12 _N_ _S_ "U(U(PPP)U(PPP))U(U(PPP)U(PPP))" {_A_ 5 _U_ 22222 _N_ _N_ _N_ _N_} _N_ _N_ },
+ min = { _A_ 2 _U_ 12 _N_ _S_ "U(U(PPP)U(PPP))U(U(PPP)U(PPP))" {_A_ 5 _U_ 22222 _N_ _N_ _N_ _N_} _N_ _N_ },
+ _tagCmp = { _A_ 2 _U_ 11 _N_ _S_ "U(U(PPP)U(PPP))U(U(PPP)U(PPP))" {_A_ 5 _U_ 22221 _N_ _N_ _N_ _N_} _N_ _N_ } #-}
instance Ord a => Ord [a]
{-# GHC_PRAGMA _M_ PreludeBuiltin {-dfun-} _A_ 2 _U_ 12 _N_ _N_ _N_ _N_ #-}
+instance Ord [Bool]
+ {-# GHC_PRAGMA _M_ PreludeBuiltin {-dfun-} _A_ 0 _N_ _N_ _N_ _F_ _IF_ARGS_ 0 0 X 9 _!_ _TUP_8 [{{Eq [Bool]}}, ([Bool] -> [Bool] -> Bool), ([Bool] -> [Bool] -> Bool), ([Bool] -> [Bool] -> Bool), ([Bool] -> [Bool] -> Bool), ([Bool] -> [Bool] -> [Bool]), ([Bool] -> [Bool] -> [Bool]), ([Bool] -> [Bool] -> _CMP_TAG)] [_DFUN_ Eq ([Bool]), _CONSTM_ Ord (<) ([Bool]), _CONSTM_ Ord (<=) ([Bool]), _CONSTM_ Ord (>=) ([Bool]), _CONSTM_ Ord (>) ([Bool]), _CONSTM_ Ord max ([Bool]), _CONSTM_ Ord min ([Bool]), _CONSTM_ Ord _tagCmp ([Bool])] _N_
+ (<) = { _A_ 2 _U_ 11 _N_ _S_ "SS" _N_ _N_ },
+ (<=) = { _A_ 2 _U_ 11 _N_ _S_ "SS" _N_ _N_ },
+ (>=) = { _A_ 2 _U_ 11 _N_ _S_ "SS" _N_ _N_ },
+ (>) = { _A_ 2 _U_ 11 _N_ _S_ "SS" _N_ _N_ },
+ max = { _A_ 2 _U_ 22 _N_ _S_ "SS" _N_ _N_ },
+ min = { _A_ 2 _U_ 22 _N_ _S_ "SS" _N_ _N_ },
+ _tagCmp = { _A_ 2 _U_ 11 _N_ _S_ "SS" _N_ _N_ } #-}
instance Ord [Char]
{-# GHC_PRAGMA _M_ PreludeBuiltin {-dfun-} _A_ 0 _N_ _N_ _N_ _F_ _IF_ARGS_ 0 0 X 9 _!_ _TUP_8 [{{Eq [Char]}}, ([Char] -> [Char] -> Bool), ([Char] -> [Char] -> Bool), ([Char] -> [Char] -> Bool), ([Char] -> [Char] -> Bool), ([Char] -> [Char] -> [Char]), ([Char] -> [Char] -> [Char]), ([Char] -> [Char] -> _CMP_TAG)] [_DFUN_ Eq ([Char]), _CONSTM_ Ord (<) ([Char]), _CONSTM_ Ord (<=) ([Char]), _CONSTM_ Ord (>=) ([Char]), _CONSTM_ Ord (>) ([Char]), _CONSTM_ Ord max ([Char]), _CONSTM_ Ord min ([Char]), _CONSTM_ Ord _tagCmp ([Char])] _N_
- (<) = _A_ 2 _U_ 11 _N_ _S_ "SS" _N_ _N_,
- (<=) = _A_ 2 _U_ 11 _N_ _S_ "SS" _N_ _N_,
- (>=) = _A_ 2 _U_ 11 _N_ _S_ "SS" _N_ _N_,
- (>) = _A_ 2 _U_ 11 _N_ _S_ "SS" _N_ _N_,
- max = _A_ 2 _U_ 22 _N_ _S_ "SS" _N_ _N_,
- min = _A_ 2 _U_ 22 _N_ _S_ "SS" _N_ _N_,
- _tagCmp = _A_ 2 _U_ 11 _N_ _S_ "SS" _N_ _N_ #-}
+ (<) = { _A_ 2 _U_ 11 _N_ _S_ "SS" _N_ _N_ },
+ (<=) = { _A_ 2 _U_ 11 _N_ _S_ "SS" _N_ _N_ },
+ (>=) = { _A_ 2 _U_ 11 _N_ _S_ "SS" _N_ _N_ },
+ (>) = { _A_ 2 _U_ 11 _N_ _S_ "SS" _N_ _N_ },
+ max = { _A_ 2 _U_ 22 _N_ _S_ "SS" _N_ _N_ },
+ min = { _A_ 2 _U_ 22 _N_ _S_ "SS" _N_ _N_ },
+ _tagCmp = { _A_ 2 _U_ 11 _N_ _S_ "SS" _N_ _N_ } #-}
+instance Ord [Double]
+ {-# GHC_PRAGMA _M_ PreludeBuiltin {-dfun-} _A_ 0 _N_ _N_ _N_ _F_ _IF_ARGS_ 0 0 X 9 _!_ _TUP_8 [{{Eq [Double]}}, ([Double] -> [Double] -> Bool), ([Double] -> [Double] -> Bool), ([Double] -> [Double] -> Bool), ([Double] -> [Double] -> Bool), ([Double] -> [Double] -> [Double]), ([Double] -> [Double] -> [Double]), ([Double] -> [Double] -> _CMP_TAG)] [_DFUN_ Eq ([Double]), _CONSTM_ Ord (<) ([Double]), _CONSTM_ Ord (<=) ([Double]), _CONSTM_ Ord (>=) ([Double]), _CONSTM_ Ord (>) ([Double]), _CONSTM_ Ord max ([Double]), _CONSTM_ Ord min ([Double]), _CONSTM_ Ord _tagCmp ([Double])] _N_
+ (<) = { _A_ 2 _U_ 11 _N_ _S_ "SS" _N_ _N_ },
+ (<=) = { _A_ 2 _U_ 11 _N_ _S_ "SS" _N_ _N_ },
+ (>=) = { _A_ 2 _U_ 11 _N_ _S_ "SS" _N_ _N_ },
+ (>) = { _A_ 2 _U_ 11 _N_ _S_ "SS" _N_ _N_ },
+ max = { _A_ 2 _U_ 22 _N_ _S_ "SS" _N_ _N_ },
+ min = { _A_ 2 _U_ 22 _N_ _S_ "SS" _N_ _N_ },
+ _tagCmp = { _A_ 2 _U_ 11 _N_ _S_ "SS" _N_ _N_ } #-}
instance Ord [Int]
{-# GHC_PRAGMA _M_ PreludeBuiltin {-dfun-} _A_ 0 _N_ _N_ _N_ _F_ _IF_ARGS_ 0 0 X 9 _!_ _TUP_8 [{{Eq [Int]}}, ([Int] -> [Int] -> Bool), ([Int] -> [Int] -> Bool), ([Int] -> [Int] -> Bool), ([Int] -> [Int] -> Bool), ([Int] -> [Int] -> [Int]), ([Int] -> [Int] -> [Int]), ([Int] -> [Int] -> _CMP_TAG)] [_DFUN_ Eq ([Int]), _CONSTM_ Ord (<) ([Int]), _CONSTM_ Ord (<=) ([Int]), _CONSTM_ Ord (>=) ([Int]), _CONSTM_ Ord (>) ([Int]), _CONSTM_ Ord max ([Int]), _CONSTM_ Ord min ([Int]), _CONSTM_ Ord _tagCmp ([Int])] _N_
- (<) = _A_ 2 _U_ 11 _N_ _S_ "SS" _N_ _N_,
- (<=) = _A_ 2 _U_ 11 _N_ _S_ "SS" _N_ _N_,
- (>=) = _A_ 2 _U_ 11 _N_ _S_ "SS" _N_ _N_,
- (>) = _A_ 2 _U_ 11 _N_ _S_ "SS" _N_ _N_,
- max = _A_ 2 _U_ 22 _N_ _S_ "SS" _N_ _N_,
- min = _A_ 2 _U_ 22 _N_ _S_ "SS" _N_ _N_,
- _tagCmp = _A_ 2 _U_ 11 _N_ _S_ "SS" _N_ _N_ #-}
+ (<) = { _A_ 2 _U_ 11 _N_ _S_ "SS" _N_ _N_ },
+ (<=) = { _A_ 2 _U_ 11 _N_ _S_ "SS" _N_ _N_ },
+ (>=) = { _A_ 2 _U_ 11 _N_ _S_ "SS" _N_ _N_ },
+ (>) = { _A_ 2 _U_ 11 _N_ _S_ "SS" _N_ _N_ },
+ max = { _A_ 2 _U_ 22 _N_ _S_ "SS" _N_ _N_ },
+ min = { _A_ 2 _U_ 22 _N_ _S_ "SS" _N_ _N_ },
+ _tagCmp = { _A_ 2 _U_ 11 _N_ _S_ "SS" _N_ _N_ } #-}
+instance Ord [Integer]
+ {-# GHC_PRAGMA _M_ PreludeBuiltin {-dfun-} _A_ 0 _N_ _N_ _N_ _F_ _IF_ARGS_ 0 0 X 9 _!_ _TUP_8 [{{Eq [Integer]}}, ([Integer] -> [Integer] -> Bool), ([Integer] -> [Integer] -> Bool), ([Integer] -> [Integer] -> Bool), ([Integer] -> [Integer] -> Bool), ([Integer] -> [Integer] -> [Integer]), ([Integer] -> [Integer] -> [Integer]), ([Integer] -> [Integer] -> _CMP_TAG)] [_DFUN_ Eq ([Integer]), _CONSTM_ Ord (<) ([Integer]), _CONSTM_ Ord (<=) ([Integer]), _CONSTM_ Ord (>=) ([Integer]), _CONSTM_ Ord (>) ([Integer]), _CONSTM_ Ord max ([Integer]), _CONSTM_ Ord min ([Integer]), _CONSTM_ Ord _tagCmp ([Integer])] _N_
+ (<) = { _A_ 2 _U_ 11 _N_ _S_ "SS" _N_ _N_ },
+ (<=) = { _A_ 2 _U_ 11 _N_ _S_ "SS" _N_ _N_ },
+ (>=) = { _A_ 2 _U_ 11 _N_ _S_ "SS" _N_ _N_ },
+ (>) = { _A_ 2 _U_ 11 _N_ _S_ "SS" _N_ _N_ },
+ max = { _A_ 2 _U_ 22 _N_ _S_ "SS" _N_ _N_ },
+ min = { _A_ 2 _U_ 22 _N_ _S_ "SS" _N_ _N_ },
+ _tagCmp = { _A_ 2 _U_ 11 _N_ _S_ "SS" _N_ _N_ } #-}
+instance Ord [[Char]]
+ {-# GHC_PRAGMA _M_ PreludeBuiltin {-dfun-} _A_ 0 _N_ _N_ _N_ _F_ _IF_ARGS_ 0 0 X 9 _!_ _TUP_8 [{{Eq [[Char]]}}, ([[Char]] -> [[Char]] -> Bool), ([[Char]] -> [[Char]] -> Bool), ([[Char]] -> [[Char]] -> Bool), ([[Char]] -> [[Char]] -> Bool), ([[Char]] -> [[Char]] -> [[Char]]), ([[Char]] -> [[Char]] -> [[Char]]), ([[Char]] -> [[Char]] -> _CMP_TAG)] [_DFUN_ Eq ([[Char]]), _CONSTM_ Ord (<) ([[Char]]), _CONSTM_ Ord (<=) ([[Char]]), _CONSTM_ Ord (>=) ([[Char]]), _CONSTM_ Ord (>) ([[Char]]), _CONSTM_ Ord max ([[Char]]), _CONSTM_ Ord min ([[Char]]), _CONSTM_ Ord _tagCmp ([[Char]])] _N_
+ (<) = { _A_ 2 _U_ 11 _N_ _S_ "SS" _N_ _N_ },
+ (<=) = { _A_ 2 _U_ 11 _N_ _S_ "SS" _N_ _N_ },
+ (>=) = { _A_ 2 _U_ 11 _N_ _S_ "SS" _N_ _N_ },
+ (>) = { _A_ 2 _U_ 11 _N_ _S_ "SS" _N_ _N_ },
+ max = { _A_ 2 _U_ 22 _N_ _S_ "SS" _N_ _N_ },
+ min = { _A_ 2 _U_ 22 _N_ _S_ "SS" _N_ _N_ },
+ _tagCmp = { _A_ 2 _U_ 11 _N_ _S_ "SS" _N_ _N_ } #-}
+instance Ord [[Int]]
+ {-# GHC_PRAGMA _M_ PreludeBuiltin {-dfun-} _A_ 0 _N_ _N_ _N_ _F_ _IF_ARGS_ 0 0 X 9 _!_ _TUP_8 [{{Eq [[Int]]}}, ([[Int]] -> [[Int]] -> Bool), ([[Int]] -> [[Int]] -> Bool), ([[Int]] -> [[Int]] -> Bool), ([[Int]] -> [[Int]] -> Bool), ([[Int]] -> [[Int]] -> [[Int]]), ([[Int]] -> [[Int]] -> [[Int]]), ([[Int]] -> [[Int]] -> _CMP_TAG)] [_DFUN_ Eq ([[Int]]), _CONSTM_ Ord (<) ([[Int]]), _CONSTM_ Ord (<=) ([[Int]]), _CONSTM_ Ord (>=) ([[Int]]), _CONSTM_ Ord (>) ([[Int]]), _CONSTM_ Ord max ([[Int]]), _CONSTM_ Ord min ([[Int]]), _CONSTM_ Ord _tagCmp ([[Int]])] _N_
+ (<) = { _A_ 2 _U_ 11 _N_ _S_ "SS" _N_ _N_ },
+ (<=) = { _A_ 2 _U_ 11 _N_ _S_ "SS" _N_ _N_ },
+ (>=) = { _A_ 2 _U_ 11 _N_ _S_ "SS" _N_ _N_ },
+ (>) = { _A_ 2 _U_ 11 _N_ _S_ "SS" _N_ _N_ },
+ max = { _A_ 2 _U_ 22 _N_ _S_ "SS" _N_ _N_ },
+ min = { _A_ 2 _U_ 22 _N_ _S_ "SS" _N_ _N_ },
+ _tagCmp = { _A_ 2 _U_ 11 _N_ _S_ "SS" _N_ _N_ } #-}
instance Ord _Addr
{-# GHC_PRAGMA _M_ PreludeCore {-dfun-} _A_ 0 _N_ _N_ _N_ _F_ _IF_ARGS_ 0 0 X 9 _!_ _TUP_8 [{{Eq _Addr}}, (_Addr -> _Addr -> Bool), (_Addr -> _Addr -> Bool), (_Addr -> _Addr -> Bool), (_Addr -> _Addr -> Bool), (_Addr -> _Addr -> _Addr), (_Addr -> _Addr -> _Addr), (_Addr -> _Addr -> _CMP_TAG)] [_DFUN_ Eq (_Addr), _CONSTM_ Ord (<) (_Addr), _CONSTM_ Ord (<=) (_Addr), _CONSTM_ Ord (>=) (_Addr), _CONSTM_ Ord (>) (_Addr), _CONSTM_ Ord max (_Addr), _CONSTM_ Ord min (_Addr), _CONSTM_ Ord _tagCmp (_Addr)] _N_
- (<) = _A_ 2 _U_ 11 _N_ _S_ "U(P)U(P)" {_A_ 2 _U_ 22 _N_ _N_ _F_ _IF_ARGS_ 0 2 XX 1 \ (u0 :: Addr#) (u1 :: Addr#) -> _#_ ltAddr# [] [u0, u1] _N_} _F_ _IF_ARGS_ 0 2 CC 3 \ (u0 :: _Addr) (u1 :: _Addr) -> case u0 of { _ALG_ A# (u2 :: Addr#) -> case u1 of { _ALG_ A# (u3 :: Addr#) -> _#_ ltAddr# [] [u2, u3]; _NO_DEFLT_ }; _NO_DEFLT_ } _N_,
- (<=) = _A_ 2 _U_ 11 _N_ _S_ "U(P)U(P)" {_A_ 2 _U_ 22 _N_ _N_ _F_ _IF_ARGS_ 0 2 XX 1 \ (u0 :: Addr#) (u1 :: Addr#) -> _#_ leAddr# [] [u0, u1] _N_} _F_ _IF_ARGS_ 0 2 CC 3 \ (u0 :: _Addr) (u1 :: _Addr) -> case u0 of { _ALG_ A# (u2 :: Addr#) -> case u1 of { _ALG_ A# (u3 :: Addr#) -> _#_ leAddr# [] [u2, u3]; _NO_DEFLT_ }; _NO_DEFLT_ } _N_,
- (>=) = _A_ 2 _U_ 11 _N_ _S_ "U(P)U(P)" {_A_ 2 _U_ 22 _N_ _N_ _F_ _IF_ARGS_ 0 2 XX 1 \ (u0 :: Addr#) (u1 :: Addr#) -> _#_ geAddr# [] [u0, u1] _N_} _F_ _IF_ARGS_ 0 2 CC 3 \ (u0 :: _Addr) (u1 :: _Addr) -> case u0 of { _ALG_ A# (u2 :: Addr#) -> case u1 of { _ALG_ A# (u3 :: Addr#) -> _#_ geAddr# [] [u2, u3]; _NO_DEFLT_ }; _NO_DEFLT_ } _N_,
- (>) = _A_ 2 _U_ 11 _N_ _S_ "U(P)U(P)" {_A_ 2 _U_ 22 _N_ _N_ _F_ _IF_ARGS_ 0 2 XX 1 \ (u0 :: Addr#) (u1 :: Addr#) -> _#_ gtAddr# [] [u0, u1] _N_} _F_ _IF_ARGS_ 0 2 CC 3 \ (u0 :: _Addr) (u1 :: _Addr) -> case u0 of { _ALG_ A# (u2 :: Addr#) -> case u1 of { _ALG_ A# (u3 :: Addr#) -> _#_ gtAddr# [] [u2, u3]; _NO_DEFLT_ }; _NO_DEFLT_ } _N_,
- max = _A_ 2 _U_ 11 _N_ _S_ "U(P)U(P)" {_A_ 2 _U_ 22 _N_ _N_ _N_ _N_} _N_ _N_,
- min = _A_ 2 _U_ 11 _N_ _S_ "U(P)U(P)" {_A_ 2 _U_ 22 _N_ _N_ _N_ _N_} _N_ _N_,
- _tagCmp = _A_ 2 _U_ 11 _N_ _S_ "U(P)U(P)" {_A_ 2 _U_ 22 _N_ _N_ _N_ _N_} _N_ _N_ #-}
+ (<) = { _A_ 2 _U_ 11 _N_ _S_ "U(P)U(P)" {_A_ 2 _U_ 22 _N_ _N_ _F_ _IF_ARGS_ 0 2 XX 1 \ (u0 :: Addr#) (u1 :: Addr#) -> _#_ ltAddr# [] [u0, u1] _N_} _F_ _IF_ARGS_ 0 2 CC 3 \ (u0 :: _Addr) (u1 :: _Addr) -> case u0 of { _ALG_ A# (u2 :: Addr#) -> case u1 of { _ALG_ A# (u3 :: Addr#) -> _#_ ltAddr# [] [u2, u3]; _NO_DEFLT_ }; _NO_DEFLT_ } _N_ },
+ (<=) = { _A_ 2 _U_ 11 _N_ _S_ "U(P)U(P)" {_A_ 2 _U_ 22 _N_ _N_ _F_ _IF_ARGS_ 0 2 XX 1 \ (u0 :: Addr#) (u1 :: Addr#) -> _#_ leAddr# [] [u0, u1] _N_} _F_ _IF_ARGS_ 0 2 CC 3 \ (u0 :: _Addr) (u1 :: _Addr) -> case u0 of { _ALG_ A# (u2 :: Addr#) -> case u1 of { _ALG_ A# (u3 :: Addr#) -> _#_ leAddr# [] [u2, u3]; _NO_DEFLT_ }; _NO_DEFLT_ } _N_ },
+ (>=) = { _A_ 2 _U_ 11 _N_ _S_ "U(P)U(P)" {_A_ 2 _U_ 22 _N_ _N_ _F_ _IF_ARGS_ 0 2 XX 1 \ (u0 :: Addr#) (u1 :: Addr#) -> _#_ geAddr# [] [u0, u1] _N_} _F_ _IF_ARGS_ 0 2 CC 3 \ (u0 :: _Addr) (u1 :: _Addr) -> case u0 of { _ALG_ A# (u2 :: Addr#) -> case u1 of { _ALG_ A# (u3 :: Addr#) -> _#_ geAddr# [] [u2, u3]; _NO_DEFLT_ }; _NO_DEFLT_ } _N_ },
+ (>) = { _A_ 2 _U_ 11 _N_ _S_ "U(P)U(P)" {_A_ 2 _U_ 22 _N_ _N_ _F_ _IF_ARGS_ 0 2 XX 1 \ (u0 :: Addr#) (u1 :: Addr#) -> _#_ gtAddr# [] [u0, u1] _N_} _F_ _IF_ARGS_ 0 2 CC 3 \ (u0 :: _Addr) (u1 :: _Addr) -> case u0 of { _ALG_ A# (u2 :: Addr#) -> case u1 of { _ALG_ A# (u3 :: Addr#) -> _#_ gtAddr# [] [u2, u3]; _NO_DEFLT_ }; _NO_DEFLT_ } _N_ },
+ max = { _A_ 2 _U_ 11 _N_ _S_ "U(P)U(P)" {_A_ 2 _U_ 22 _N_ _N_ _N_ _N_} _N_ _N_ },
+ min = { _A_ 2 _U_ 11 _N_ _S_ "U(P)U(P)" {_A_ 2 _U_ 22 _N_ _N_ _N_ _N_} _N_ _N_ },
+ _tagCmp = { _A_ 2 _U_ 11 _N_ _S_ "U(P)U(P)" {_A_ 2 _U_ 22 _N_ _N_ _N_ _N_} _N_ _N_ } #-}
instance Ord _PackedString
{-# GHC_PRAGMA _M_ PreludePS {-dfun-} _A_ 0 _N_ _N_ _N_ _F_ _IF_ARGS_ 0 0 X 9 _!_ _TUP_8 [{{Eq _PackedString}}, (_PackedString -> _PackedString -> Bool), (_PackedString -> _PackedString -> Bool), (_PackedString -> _PackedString -> Bool), (_PackedString -> _PackedString -> Bool), (_PackedString -> _PackedString -> _PackedString), (_PackedString -> _PackedString -> _PackedString), (_PackedString -> _PackedString -> _CMP_TAG)] [_DFUN_ Eq (_PackedString), _CONSTM_ Ord (<) (_PackedString), _CONSTM_ Ord (<=) (_PackedString), _CONSTM_ Ord (>=) (_PackedString), _CONSTM_ Ord (>) (_PackedString), _CONSTM_ Ord max (_PackedString), _CONSTM_ Ord min (_PackedString), _CONSTM_ Ord _tagCmp (_PackedString)] _N_
- (<) = _A_ 2 _U_ 22 _N_ _S_ "SS" _N_ _N_,
- (<=) = _A_ 2 _U_ 22 _N_ _S_ "SS" _N_ _N_,
- (>=) = _A_ 2 _U_ 22 _N_ _S_ "SS" _N_ _N_,
- (>) = _A_ 2 _U_ 22 _N_ _S_ "SS" _N_ _N_,
- max = _A_ 2 _U_ 22 _N_ _N_ _N_ _N_,
- min = _A_ 2 _U_ 22 _N_ _N_ _N_ _N_,
- _tagCmp = _A_ 2 _U_ 22 _N_ _S_ "SS" _N_ _N_ #-}
+ (<) = { _A_ 2 _U_ 22 _N_ _S_ "SS" _N_ _N_ },
+ (<=) = { _A_ 2 _U_ 22 _N_ _S_ "SS" _N_ _N_ },
+ (>=) = { _A_ 2 _U_ 22 _N_ _S_ "SS" _N_ _N_ },
+ (>) = { _A_ 2 _U_ 22 _N_ _S_ "SS" _N_ _N_ },
+ max = { _A_ 2 _U_ 22 _N_ _S_ "SS" _N_ _N_ },
+ min = { _A_ 2 _U_ 22 _N_ _S_ "SS" _N_ _N_ },
+ _tagCmp = { _A_ 2 _U_ 22 _N_ _S_ "SS" _N_ _N_ } #-}
instance Ord _Word
{-# GHC_PRAGMA _M_ PreludeCore {-dfun-} _A_ 0 _N_ _N_ _N_ _F_ _IF_ARGS_ 0 0 X 9 _!_ _TUP_8 [{{Eq _Word}}, (_Word -> _Word -> Bool), (_Word -> _Word -> Bool), (_Word -> _Word -> Bool), (_Word -> _Word -> Bool), (_Word -> _Word -> _Word), (_Word -> _Word -> _Word), (_Word -> _Word -> _CMP_TAG)] [_DFUN_ Eq (_Word), _CONSTM_ Ord (<) (_Word), _CONSTM_ Ord (<=) (_Word), _CONSTM_ Ord (>=) (_Word), _CONSTM_ Ord (>) (_Word), _CONSTM_ Ord max (_Word), _CONSTM_ Ord min (_Word), _CONSTM_ Ord _tagCmp (_Word)] _N_
- (<) = _A_ 2 _U_ 11 _N_ _S_ "U(P)U(P)" {_A_ 2 _U_ 22 _N_ _N_ _F_ _IF_ARGS_ 0 2 XX 1 \ (u0 :: Word#) (u1 :: Word#) -> _#_ ltWord# [] [u0, u1] _N_} _F_ _IF_ARGS_ 0 2 CC 3 \ (u0 :: _Word) (u1 :: _Word) -> case u0 of { _ALG_ W# (u2 :: Word#) -> case u1 of { _ALG_ W# (u3 :: Word#) -> _#_ ltWord# [] [u2, u3]; _NO_DEFLT_ }; _NO_DEFLT_ } _N_,
- (<=) = _A_ 2 _U_ 11 _N_ _S_ "U(P)U(P)" {_A_ 2 _U_ 22 _N_ _N_ _F_ _IF_ARGS_ 0 2 XX 1 \ (u0 :: Word#) (u1 :: Word#) -> _#_ leWord# [] [u0, u1] _N_} _F_ _IF_ARGS_ 0 2 CC 3 \ (u0 :: _Word) (u1 :: _Word) -> case u0 of { _ALG_ W# (u2 :: Word#) -> case u1 of { _ALG_ W# (u3 :: Word#) -> _#_ leWord# [] [u2, u3]; _NO_DEFLT_ }; _NO_DEFLT_ } _N_,
- (>=) = _A_ 2 _U_ 11 _N_ _S_ "U(P)U(P)" {_A_ 2 _U_ 22 _N_ _N_ _F_ _IF_ARGS_ 0 2 XX 1 \ (u0 :: Word#) (u1 :: Word#) -> _#_ geWord# [] [u0, u1] _N_} _F_ _IF_ARGS_ 0 2 CC 3 \ (u0 :: _Word) (u1 :: _Word) -> case u0 of { _ALG_ W# (u2 :: Word#) -> case u1 of { _ALG_ W# (u3 :: Word#) -> _#_ geWord# [] [u2, u3]; _NO_DEFLT_ }; _NO_DEFLT_ } _N_,
- (>) = _A_ 2 _U_ 11 _N_ _S_ "U(P)U(P)" {_A_ 2 _U_ 22 _N_ _N_ _F_ _IF_ARGS_ 0 2 XX 1 \ (u0 :: Word#) (u1 :: Word#) -> _#_ gtWord# [] [u0, u1] _N_} _F_ _IF_ARGS_ 0 2 CC 3 \ (u0 :: _Word) (u1 :: _Word) -> case u0 of { _ALG_ W# (u2 :: Word#) -> case u1 of { _ALG_ W# (u3 :: Word#) -> _#_ gtWord# [] [u2, u3]; _NO_DEFLT_ }; _NO_DEFLT_ } _N_,
- max = _A_ 2 _U_ 11 _N_ _S_ "U(P)U(P)" {_A_ 2 _U_ 22 _N_ _N_ _N_ _N_} _N_ _N_,
- min = _A_ 2 _U_ 11 _N_ _S_ "U(P)U(P)" {_A_ 2 _U_ 22 _N_ _N_ _N_ _N_} _N_ _N_,
- _tagCmp = _A_ 2 _U_ 11 _N_ _S_ "U(P)U(P)" {_A_ 2 _U_ 22 _N_ _N_ _N_ _N_} _N_ _N_ #-}
+ (<) = { _A_ 2 _U_ 11 _N_ _S_ "U(P)U(P)" {_A_ 2 _U_ 22 _N_ _N_ _F_ _IF_ARGS_ 0 2 XX 1 \ (u0 :: Word#) (u1 :: Word#) -> _#_ ltWord# [] [u0, u1] _N_} _F_ _IF_ARGS_ 0 2 CC 3 \ (u0 :: _Word) (u1 :: _Word) -> case u0 of { _ALG_ W# (u2 :: Word#) -> case u1 of { _ALG_ W# (u3 :: Word#) -> _#_ ltWord# [] [u2, u3]; _NO_DEFLT_ }; _NO_DEFLT_ } _N_ },
+ (<=) = { _A_ 2 _U_ 11 _N_ _S_ "U(P)U(P)" {_A_ 2 _U_ 22 _N_ _N_ _F_ _IF_ARGS_ 0 2 XX 1 \ (u0 :: Word#) (u1 :: Word#) -> _#_ leWord# [] [u0, u1] _N_} _F_ _IF_ARGS_ 0 2 CC 3 \ (u0 :: _Word) (u1 :: _Word) -> case u0 of { _ALG_ W# (u2 :: Word#) -> case u1 of { _ALG_ W# (u3 :: Word#) -> _#_ leWord# [] [u2, u3]; _NO_DEFLT_ }; _NO_DEFLT_ } _N_ },
+ (>=) = { _A_ 2 _U_ 11 _N_ _S_ "U(P)U(P)" {_A_ 2 _U_ 22 _N_ _N_ _F_ _IF_ARGS_ 0 2 XX 1 \ (u0 :: Word#) (u1 :: Word#) -> _#_ geWord# [] [u0, u1] _N_} _F_ _IF_ARGS_ 0 2 CC 3 \ (u0 :: _Word) (u1 :: _Word) -> case u0 of { _ALG_ W# (u2 :: Word#) -> case u1 of { _ALG_ W# (u3 :: Word#) -> _#_ geWord# [] [u2, u3]; _NO_DEFLT_ }; _NO_DEFLT_ } _N_ },
+ (>) = { _A_ 2 _U_ 11 _N_ _S_ "U(P)U(P)" {_A_ 2 _U_ 22 _N_ _N_ _F_ _IF_ARGS_ 0 2 XX 1 \ (u0 :: Word#) (u1 :: Word#) -> _#_ gtWord# [] [u0, u1] _N_} _F_ _IF_ARGS_ 0 2 CC 3 \ (u0 :: _Word) (u1 :: _Word) -> case u0 of { _ALG_ W# (u2 :: Word#) -> case u1 of { _ALG_ W# (u3 :: Word#) -> _#_ gtWord# [] [u2, u3]; _NO_DEFLT_ }; _NO_DEFLT_ } _N_ },
+ max = { _A_ 2 _U_ 11 _N_ _S_ "U(P)U(P)" {_A_ 2 _U_ 22 _N_ _N_ _N_ _N_} _N_ _N_ },
+ min = { _A_ 2 _U_ 11 _N_ _S_ "U(P)U(P)" {_A_ 2 _U_ 22 _N_ _N_ _N_ _N_} _N_ _N_ },
+ _tagCmp = { _A_ 2 _U_ 11 _N_ _S_ "U(P)U(P)" {_A_ 2 _U_ 22 _N_ _N_ _N_ _N_} _N_ _N_ } #-}
instance Real Double
{-# GHC_PRAGMA _M_ PreludeCore {-dfun-} _A_ 0 _N_ _N_ _N_ _F_ _IF_ARGS_ 0 0 X 4 _!_ _TUP_3 [{{Num Double}}, {{Enum Double}}, (Double -> Ratio Integer)] [_DFUN_ Num (Double), _DFUN_ Enum (Double), _CONSTM_ Real toRational (Double)] _N_
- toRational = _A_ 1 _U_ 1 _N_ _S_ "U(P)" {_A_ 1 _U_ 2 _N_ _N_ _N_ _N_} _N_ _N_ #-}
+ toRational = { _A_ 1 _U_ 1 _N_ _S_ "U(P)" {_A_ 1 _U_ 2 _N_ _N_ _N_ _N_} _N_ _N_ } #-}
instance Real Float
{-# GHC_PRAGMA _M_ PreludeCore {-dfun-} _A_ 0 _N_ _N_ _N_ _F_ _IF_ARGS_ 0 0 X 4 _!_ _TUP_3 [{{Num Float}}, {{Enum Float}}, (Float -> Ratio Integer)] [_DFUN_ Num (Float), _DFUN_ Enum (Float), _CONSTM_ Real toRational (Float)] _N_
- toRational = _A_ 1 _U_ 1 _N_ _S_ "U(P)" {_A_ 1 _U_ 2 _N_ _N_ _N_ _N_} _N_ _N_ #-}
+ toRational = { _A_ 1 _U_ 1 _N_ _S_ "U(P)" {_A_ 1 _U_ 2 _N_ _N_ _N_ _N_} _N_ _N_ } #-}
instance Real Int
{-# GHC_PRAGMA _M_ PreludeCore {-dfun-} _A_ 0 _N_ _N_ _N_ _F_ _IF_ARGS_ 0 0 X 4 _!_ _TUP_3 [{{Num Int}}, {{Enum Int}}, (Int -> Ratio Integer)] [_DFUN_ Num (Int), _DFUN_ Enum (Int), _CONSTM_ Real toRational (Int)] _N_
- toRational = _A_ 1 _U_ 1 _N_ _N_ _N_ _N_ #-}
+ toRational = { _A_ 1 _U_ 1 _N_ _N_ _N_ _N_ } #-}
instance Real Integer
{-# GHC_PRAGMA _M_ PreludeCore {-dfun-} _A_ 0 _N_ _N_ _N_ _F_ _IF_ARGS_ 0 0 X 4 _!_ _TUP_3 [{{Num Integer}}, {{Enum Integer}}, (Integer -> Ratio Integer)] [_DFUN_ Num (Integer), _DFUN_ Enum (Integer), _CONSTM_ Real toRational (Integer)] _N_
- toRational = _A_ 1 _U_ 2 _N_ _N_ _N_ _N_ #-}
+ toRational = { _A_ 1 _U_ 2 _N_ _N_ _F_ _IF_ARGS_ 0 1 X 3 \ (u0 :: Integer) -> _!_ (:%) [Integer] [u0, _ORIG_ PreludeCore __integer1] _N_ } #-}
instance Integral a => Real (Ratio a)
{-# GHC_PRAGMA _M_ PreludeRatio {-dfun-} _A_ 3 _U_ 122 _N_ _N_ _N_ _N_ #-}
instance Real (Ratio Integer)
{-# GHC_PRAGMA _M_ PreludeRatio {-dfun-} _A_ 0 _N_ _N_ _N_ _F_ _IF_ARGS_ 0 0 X 4 _!_ _TUP_3 [{{Num (Ratio Integer)}}, {{Enum (Ratio Integer)}}, (Ratio Integer -> Ratio Integer)] [_DFUN_ Num (Ratio Integer), _DFUN_ Enum (Ratio Integer), _CONSTM_ Real toRational (Ratio Integer)] _N_
- toRational = _A_ 1 _U_ 1 _N_ _S_ "U(LL)" {_A_ 2 _U_ 22 _N_ _N_ _F_ _IF_ARGS_ 0 2 XX 3 \ (u0 :: Integer) (u1 :: Integer) -> _!_ (:%) [Integer] [u0, u1] _N_} _F_ _IF_ARGS_ 0 1 X 1 \ (u0 :: Ratio Integer) -> u0 _N_ #-}
+ toRational = { _A_ 1 _U_ 1 _N_ _S_ "U(LL)" {_A_ 2 _U_ 22 _N_ _N_ _F_ _IF_ARGS_ 0 2 XX 3 \ (u0 :: Integer) (u1 :: Integer) -> _!_ (:%) [Integer] [u0, u1] _N_} _F_ _IF_ARGS_ 0 1 X 1 \ (u0 :: Ratio Integer) -> u0 _N_ } #-}
instance RealFloat Double
{-# GHC_PRAGMA _M_ PreludeCore {-dfun-} _A_ 0 _N_ _N_ _N_ _F_ _IF_ARGS_ 0 0 X 11 _!_ _TUP_10 [{{RealFrac Double}}, {{Floating Double}}, (Double -> Integer), (Double -> Int), (Double -> (Int, Int)), (Double -> (Integer, Int)), (Integer -> Int -> Double), (Double -> Int), (Double -> Double), (Int -> Double -> Double)] [_DFUN_ RealFrac (Double), _DFUN_ Floating (Double), _CONSTM_ RealFloat floatRadix (Double), _CONSTM_ RealFloat floatDigits (Double), _CONSTM_ RealFloat floatRange (Double), _CONSTM_ RealFloat decodeFloat (Double), _CONSTM_ RealFloat encodeFloat (Double), _CONSTM_ RealFloat exponent (Double), _CONSTM_ RealFloat significand (Double), _CONSTM_ RealFloat scaleFloat (Double)] _N_
- floatRadix = _A_ 1 _U_ 0 _N_ _S_ "A" {_A_ 0 _N_ _N_ _N_ _F_ _IF_ARGS_ 0 0 X 1 _#_ int2Integer# [] [2#] _N_} _N_ _N_,
- floatDigits = _A_ 1 _U_ 0 _N_ _S_ "A" {_A_ 0 _N_ _N_ _N_ _F_ _IF_ARGS_ 0 0 X 2 _!_ I# [] [53#] _N_} _F_ _IF_ARGS_ 0 1 X 2 \ (u0 :: Double) -> _!_ I# [] [53#] _N_,
- floatRange = _A_ 1 _U_ 0 _N_ _S_ "A" {_A_ 0 _N_ _N_ _N_ _N_ _N_} _N_ _N_,
- decodeFloat = _A_ 1 _U_ 1 _N_ _S_ "U(P)" {_A_ 1 _U_ 2 _N_ _N_ _N_ _N_} _N_ _N_,
- encodeFloat = _A_ 2 _U_ 11 _N_ _S_ "U(PPP)U(P)" {_A_ 4 _U_ 2222 _N_ _N_ _F_ _IF_ARGS_ 0 4 XXXX 3 \ (u0 :: Int#) (u1 :: Int#) (u2 :: ByteArray#) (u3 :: Int#) -> case _#_ encodeDouble# [] [u0, u1, u2, u3] of { _PRIM_ (u4 :: Double#) -> _!_ D# [] [u4] } _N_} _F_ _IF_ARGS_ 0 2 CC 5 \ (u0 :: Integer) (u1 :: Int) -> case u0 of { _ALG_ J# (u2 :: Int#) (u3 :: Int#) (u4 :: ByteArray#) -> case u1 of { _ALG_ I# (u5 :: Int#) -> case _#_ encodeDouble# [] [u2, u3, u4, u5] of { _PRIM_ (u6 :: Double#) -> _!_ D# [] [u6] }; _NO_DEFLT_ }; _NO_DEFLT_ } _N_,
- exponent = _A_ 1 _U_ 2 _N_ _N_ _N_ _N_,
- significand = _A_ 1 _U_ 2 _N_ _N_ _N_ _N_,
- scaleFloat = _A_ 2 _U_ 22 _N_ _N_ _N_ _N_ #-}
+ floatRadix = { _A_ 1 _U_ 0 _N_ _S_ "A" {_A_ 0 _N_ _N_ _N_ _N_ _N_} _N_ _N_ },
+ floatDigits = { _A_ 1 _U_ 0 _N_ _S_ "A" {_A_ 0 _N_ _N_ _N_ _F_ _IF_ARGS_ 0 0 X 2 _!_ I# [] [53#] _N_} _F_ _IF_ARGS_ 0 1 X 2 \ (u0 :: Double) -> _!_ I# [] [53#] _N_ },
+ floatRange = { _A_ 1 _U_ 0 _N_ _S_ "A" {_A_ 0 _N_ _N_ _N_ _N_ _N_} _N_ _N_ },
+ decodeFloat = { _A_ 1 _U_ 1 _N_ _S_ "U(P)" {_A_ 1 _U_ 2 _N_ _N_ _N_ _N_} _N_ _N_ },
+ encodeFloat = { _A_ 2 _U_ 11 _N_ _S_ "U(PPP)U(P)" {_A_ 4 _U_ 2222 _N_ _N_ _F_ _IF_ARGS_ 0 4 XXXX 3 \ (u0 :: Int#) (u1 :: Int#) (u2 :: ByteArray#) (u3 :: Int#) -> case _#_ encodeDouble# [] [u0, u1, u2, u3] of { _PRIM_ (u4 :: Double#) -> _!_ D# [] [u4] } _N_} _F_ _IF_ARGS_ 0 2 CC 5 \ (u0 :: Integer) (u1 :: Int) -> case u0 of { _ALG_ J# (u2 :: Int#) (u3 :: Int#) (u4 :: ByteArray#) -> case u1 of { _ALG_ I# (u5 :: Int#) -> case _#_ encodeDouble# [] [u2, u3, u4, u5] of { _PRIM_ (u6 :: Double#) -> _!_ D# [] [u6] }; _NO_DEFLT_ }; _NO_DEFLT_ } _N_ },
+ exponent = { _A_ 1 _U_ 1 _N_ _S_ "U(P)" {_A_ 1 _U_ 2 _N_ _N_ _N_ _N_} _N_ _N_ },
+ significand = { _A_ 1 _U_ 1 _N_ _S_ "U(P)" {_A_ 1 _U_ 2 _N_ _N_ _N_ _N_} _N_ _N_ },
+ scaleFloat = { _A_ 2 _U_ 11 _N_ _S_ "U(P)U(P)" {_A_ 2 _U_ 22 _N_ _N_ _N_ _N_} _N_ _N_ } #-}
instance RealFloat Float
{-# GHC_PRAGMA _M_ PreludeCore {-dfun-} _A_ 0 _N_ _N_ _N_ _F_ _IF_ARGS_ 0 0 X 11 _!_ _TUP_10 [{{RealFrac Float}}, {{Floating Float}}, (Float -> Integer), (Float -> Int), (Float -> (Int, Int)), (Float -> (Integer, Int)), (Integer -> Int -> Float), (Float -> Int), (Float -> Float), (Int -> Float -> Float)] [_DFUN_ RealFrac (Float), _DFUN_ Floating (Float), _CONSTM_ RealFloat floatRadix (Float), _CONSTM_ RealFloat floatDigits (Float), _CONSTM_ RealFloat floatRange (Float), _CONSTM_ RealFloat decodeFloat (Float), _CONSTM_ RealFloat encodeFloat (Float), _CONSTM_ RealFloat exponent (Float), _CONSTM_ RealFloat significand (Float), _CONSTM_ RealFloat scaleFloat (Float)] _N_
- floatRadix = _A_ 1 _U_ 0 _N_ _S_ "A" {_A_ 0 _N_ _N_ _N_ _F_ _IF_ARGS_ 0 0 X 1 _#_ int2Integer# [] [2#] _N_} _N_ _N_,
- floatDigits = _A_ 1 _U_ 0 _N_ _S_ "A" {_A_ 0 _N_ _N_ _N_ _F_ _IF_ARGS_ 0 0 X 2 _!_ I# [] [24#] _N_} _F_ _IF_ARGS_ 0 1 X 2 \ (u0 :: Float) -> _!_ I# [] [24#] _N_,
- floatRange = _A_ 1 _U_ 0 _N_ _S_ "A" {_A_ 0 _N_ _N_ _N_ _N_ _N_} _N_ _N_,
- decodeFloat = _A_ 1 _U_ 1 _N_ _S_ "U(P)" {_A_ 1 _U_ 2 _N_ _N_ _N_ _N_} _N_ _N_,
- encodeFloat = _A_ 2 _U_ 11 _N_ _S_ "U(PPP)U(P)" {_A_ 4 _U_ 2222 _N_ _N_ _F_ _IF_ARGS_ 0 4 XXXX 3 \ (u0 :: Int#) (u1 :: Int#) (u2 :: ByteArray#) (u3 :: Int#) -> case _#_ encodeFloat# [] [u0, u1, u2, u3] of { _PRIM_ (u4 :: Float#) -> _!_ F# [] [u4] } _N_} _F_ _IF_ARGS_ 0 2 CC 5 \ (u0 :: Integer) (u1 :: Int) -> case u0 of { _ALG_ J# (u2 :: Int#) (u3 :: Int#) (u4 :: ByteArray#) -> case u1 of { _ALG_ I# (u5 :: Int#) -> case _#_ encodeFloat# [] [u2, u3, u4, u5] of { _PRIM_ (u6 :: Float#) -> _!_ F# [] [u6] }; _NO_DEFLT_ }; _NO_DEFLT_ } _N_,
- exponent = _A_ 1 _U_ 2 _N_ _N_ _N_ _N_,
- significand = _A_ 1 _U_ 2 _N_ _N_ _N_ _N_,
- scaleFloat = _A_ 2 _U_ 22 _N_ _N_ _N_ _N_ #-}
+ floatRadix = { _A_ 1 _U_ 0 _N_ _S_ "A" {_A_ 0 _N_ _N_ _N_ _N_ _N_} _N_ _N_ },
+ floatDigits = { _A_ 1 _U_ 0 _N_ _S_ "A" {_A_ 0 _N_ _N_ _N_ _F_ _IF_ARGS_ 0 0 X 2 _!_ I# [] [24#] _N_} _F_ _IF_ARGS_ 0 1 X 2 \ (u0 :: Float) -> _!_ I# [] [24#] _N_ },
+ floatRange = { _A_ 1 _U_ 0 _N_ _S_ "A" {_A_ 0 _N_ _N_ _N_ _N_ _N_} _N_ _N_ },
+ decodeFloat = { _A_ 1 _U_ 1 _N_ _S_ "U(P)" {_A_ 1 _U_ 2 _N_ _N_ _N_ _N_} _N_ _N_ },
+ encodeFloat = { _A_ 2 _U_ 11 _N_ _S_ "U(PPP)U(P)" {_A_ 4 _U_ 2222 _N_ _N_ _F_ _IF_ARGS_ 0 4 XXXX 3 \ (u0 :: Int#) (u1 :: Int#) (u2 :: ByteArray#) (u3 :: Int#) -> case _#_ encodeFloat# [] [u0, u1, u2, u3] of { _PRIM_ (u4 :: Float#) -> _!_ F# [] [u4] } _N_} _F_ _IF_ARGS_ 0 2 CC 5 \ (u0 :: Integer) (u1 :: Int) -> case u0 of { _ALG_ J# (u2 :: Int#) (u3 :: Int#) (u4 :: ByteArray#) -> case u1 of { _ALG_ I# (u5 :: Int#) -> case _#_ encodeFloat# [] [u2, u3, u4, u5] of { _PRIM_ (u6 :: Float#) -> _!_ F# [] [u6] }; _NO_DEFLT_ }; _NO_DEFLT_ } _N_ },
+ exponent = { _A_ 1 _U_ 1 _N_ _S_ "U(P)" {_A_ 1 _U_ 2 _N_ _N_ _N_ _N_} _N_ _N_ },
+ significand = { _A_ 1 _U_ 1 _N_ _S_ "U(P)" {_A_ 1 _U_ 2 _N_ _N_ _N_ _N_} _N_ _N_ },
+ scaleFloat = { _A_ 2 _U_ 11 _N_ _S_ "U(P)U(P)" {_A_ 2 _U_ 22 _N_ _N_ _N_ _N_} _N_ _N_ } #-}
instance RealFrac Double
{-# GHC_PRAGMA _M_ PreludeCore {-dfun-} _A_ 0 _N_ _N_ _N_ _F_ _IF_ARGS_ 0 0 X 8 _!_ _TUP_7 [{{Real Double}}, {{Fractional Double}}, _forall_ a$z1 =>{{Integral a$z1}} -> (Double -> (a$z1, Double)), _forall_ a$z1 =>{{Integral a$z1}} -> (Double -> a$z1), _forall_ a$z1 =>{{Integral a$z1}} -> (Double -> a$z1), _forall_ a$z1 =>{{Integral a$z1}} -> (Double -> a$z1), _forall_ a$z1 =>{{Integral a$z1}} -> (Double -> a$z1)] [_DFUN_ Real (Double), _DFUN_ Fractional (Double), _CONSTM_ RealFrac properFraction (Double), _CONSTM_ RealFrac truncate (Double), _CONSTM_ RealFrac round (Double), _CONSTM_ RealFrac ceiling (Double), _CONSTM_ RealFrac floor (Double)] _N_
- properFraction = _A_ 1 _U_ 22 _N_ _N_ _N_ _N_,
- truncate = _A_ 1 _U_ 22 _N_ _N_ _N_ _N_,
- round = _A_ 1 _U_ 22 _N_ _N_ _N_ _N_,
- ceiling = _A_ 1 _U_ 22 _N_ _N_ _N_ _N_,
- floor = _A_ 1 _U_ 22 _N_ _N_ _N_ _N_ #-}
+ properFraction = { _A_ 1 _U_ 11 _N_ _N_ _N_ _SPECIALISE_ [ Int ] 1 { _A_ 1 _U_ 1 _N_ _S_ "U(P)" {_A_ 1 _U_ 2 _N_ _N_ _N_ _N_} _N_ _N_ }, [ Integer ] 1 { _A_ 1 _U_ 1 _N_ _S_ "U(P)" {_A_ 1 _U_ 2 _N_ _N_ _N_ _N_} _N_ _N_ } },
+ truncate = { _A_ 1 _U_ 11 _N_ _N_ _N_ _SPECIALISE_ [ Int ] 1 { _A_ 1 _U_ 1 _N_ _S_ "U(P)" {_A_ 1 _U_ 2 _N_ _N_ _F_ _IF_ARGS_ 0 1 X 4 \ (u0 :: Double#) -> case _APP_ _WRKR_ _SPEC_ _CONSTM_ RealFrac properFraction (Double) [ (Int) ] [ u0 ] of { _ALG_ _TUP_2 (u1 :: Int) (u2 :: Double) -> u1; _NO_DEFLT_ } _N_} _F_ _IF_ARGS_ 0 1 X 4 \ (u0 :: Double) -> case _APP_ _SPEC_ _CONSTM_ RealFrac properFraction (Double) [ (Int) ] [ u0 ] of { _ALG_ _TUP_2 (u1 :: Int) (u2 :: Double) -> u1; _NO_DEFLT_ } _N_ }, [ Integer ] 1 { _A_ 1 _U_ 1 _N_ _S_ "U(P)" {_A_ 1 _U_ 2 _N_ _N_ _F_ _IF_ARGS_ 0 1 X 4 \ (u0 :: Double#) -> case _APP_ _WRKR_ _SPEC_ _CONSTM_ RealFrac properFraction (Double) [ (Integer) ] [ u0 ] of { _ALG_ _TUP_2 (u1 :: Integer) (u2 :: Double) -> u1; _NO_DEFLT_ } _N_} _F_ _IF_ARGS_ 0 1 X 4 \ (u0 :: Double) -> case _APP_ _SPEC_ _CONSTM_ RealFrac properFraction (Double) [ (Integer) ] [ u0 ] of { _ALG_ _TUP_2 (u1 :: Integer) (u2 :: Double) -> u1; _NO_DEFLT_ } _N_ } },
+ round = { _A_ 1 _U_ 21 _N_ _N_ _N_ _SPECIALISE_ [ Int ] 1 { _A_ 1 _U_ 1 _N_ _S_ "U(P)" {_A_ 1 _U_ 2 _N_ _N_ _N_ _N_} _N_ _N_ }, [ Integer ] 1 { _A_ 1 _U_ 1 _N_ _S_ "U(P)" {_A_ 1 _U_ 2 _N_ _N_ _N_ _N_} _N_ _N_ } },
+ ceiling = { _A_ 1 _U_ 21 _N_ _N_ _N_ _SPECIALISE_ [ Int ] 1 { _A_ 1 _U_ 1 _N_ _S_ "U(P)" {_A_ 1 _U_ 2 _N_ _N_ _N_ _N_} _N_ _N_ }, [ Integer ] 1 { _A_ 1 _U_ 1 _N_ _S_ "U(P)" {_A_ 1 _U_ 2 _N_ _N_ _N_ _N_} _N_ _N_ } },
+ floor = { _A_ 1 _U_ 21 _N_ _N_ _N_ _SPECIALISE_ [ Int ] 1 { _A_ 1 _U_ 1 _N_ _S_ "U(P)" {_A_ 1 _U_ 2 _N_ _N_ _N_ _N_} _N_ _N_ }, [ Integer ] 1 { _A_ 1 _U_ 1 _N_ _S_ "U(P)" {_A_ 1 _U_ 2 _N_ _N_ _N_ _N_} _N_ _N_ } } #-}
instance RealFrac Float
{-# GHC_PRAGMA _M_ PreludeCore {-dfun-} _A_ 0 _N_ _N_ _N_ _F_ _IF_ARGS_ 0 0 X 8 _!_ _TUP_7 [{{Real Float}}, {{Fractional Float}}, _forall_ a$z1 =>{{Integral a$z1}} -> (Float -> (a$z1, Float)), _forall_ a$z1 =>{{Integral a$z1}} -> (Float -> a$z1), _forall_ a$z1 =>{{Integral a$z1}} -> (Float -> a$z1), _forall_ a$z1 =>{{Integral a$z1}} -> (Float -> a$z1), _forall_ a$z1 =>{{Integral a$z1}} -> (Float -> a$z1)] [_DFUN_ Real (Float), _DFUN_ Fractional (Float), _CONSTM_ RealFrac properFraction (Float), _CONSTM_ RealFrac truncate (Float), _CONSTM_ RealFrac round (Float), _CONSTM_ RealFrac ceiling (Float), _CONSTM_ RealFrac floor (Float)] _N_
- properFraction = _A_ 1 _U_ 22 _N_ _N_ _N_ _N_,
- truncate = _A_ 1 _U_ 22 _N_ _N_ _N_ _N_,
- round = _A_ 1 _U_ 22 _N_ _N_ _N_ _N_,
- ceiling = _A_ 1 _U_ 22 _N_ _N_ _N_ _N_,
- floor = _A_ 1 _U_ 22 _N_ _N_ _N_ _N_ #-}
-instance Integral a => RealFrac (Ratio a)
- {-# GHC_PRAGMA _M_ PreludeRatio {-dfun-} _A_ 3 _U_ 222 _N_ _N_ _N_ _N_ #-}
+ properFraction = { _A_ 1 _U_ 11 _N_ _N_ _N_ _SPECIALISE_ [ Int ] 1 { _A_ 1 _U_ 1 _N_ _S_ "U(P)" {_A_ 1 _U_ 2 _N_ _N_ _N_ _N_} _N_ _N_ }, [ Integer ] 1 { _A_ 1 _U_ 1 _N_ _S_ "U(P)" {_A_ 1 _U_ 2 _N_ _N_ _N_ _N_} _N_ _N_ } },
+ truncate = { _A_ 1 _U_ 11 _N_ _N_ _N_ _SPECIALISE_ [ Int ] 1 { _A_ 1 _U_ 1 _N_ _S_ "U(P)" {_A_ 1 _U_ 2 _N_ _N_ _F_ _IF_ARGS_ 0 1 X 4 \ (u0 :: Float#) -> case _APP_ _WRKR_ _SPEC_ _CONSTM_ RealFrac properFraction (Float) [ (Int) ] [ u0 ] of { _ALG_ _TUP_2 (u1 :: Int) (u2 :: Float) -> u1; _NO_DEFLT_ } _N_} _F_ _IF_ARGS_ 0 1 X 4 \ (u0 :: Float) -> case _APP_ _SPEC_ _CONSTM_ RealFrac properFraction (Float) [ (Int) ] [ u0 ] of { _ALG_ _TUP_2 (u1 :: Int) (u2 :: Float) -> u1; _NO_DEFLT_ } _N_ }, [ Integer ] 1 { _A_ 1 _U_ 1 _N_ _S_ "U(P)" {_A_ 1 _U_ 2 _N_ _N_ _F_ _IF_ARGS_ 0 1 X 4 \ (u0 :: Float#) -> case _APP_ _WRKR_ _SPEC_ _CONSTM_ RealFrac properFraction (Float) [ (Integer) ] [ u0 ] of { _ALG_ _TUP_2 (u1 :: Integer) (u2 :: Float) -> u1; _NO_DEFLT_ } _N_} _F_ _IF_ARGS_ 0 1 X 4 \ (u0 :: Float) -> case _APP_ _SPEC_ _CONSTM_ RealFrac properFraction (Float) [ (Integer) ] [ u0 ] of { _ALG_ _TUP_2 (u1 :: Integer) (u2 :: Float) -> u1; _NO_DEFLT_ } _N_ } },
+ round = { _A_ 1 _U_ 21 _N_ _N_ _N_ _SPECIALISE_ [ Int ] 1 { _A_ 1 _U_ 1 _N_ _S_ "U(P)" {_A_ 1 _U_ 2 _N_ _N_ _N_ _N_} _N_ _N_ }, [ Integer ] 1 { _A_ 1 _U_ 1 _N_ _S_ "U(P)" {_A_ 1 _U_ 2 _N_ _N_ _N_ _N_} _N_ _N_ } },
+ ceiling = { _A_ 1 _U_ 21 _N_ _N_ _N_ _SPECIALISE_ [ Int ] 1 { _A_ 1 _U_ 1 _N_ _S_ "U(P)" {_A_ 1 _U_ 2 _N_ _N_ _N_ _N_} _N_ _N_ }, [ Integer ] 1 { _A_ 1 _U_ 1 _N_ _S_ "U(P)" {_A_ 1 _U_ 2 _N_ _N_ _N_ _N_} _N_ _N_ } },
+ floor = { _A_ 1 _U_ 21 _N_ _N_ _N_ _SPECIALISE_ [ Int ] 1 { _A_ 1 _U_ 1 _N_ _S_ "U(P)" {_A_ 1 _U_ 2 _N_ _N_ _N_ _N_} _N_ _N_ }, [ Integer ] 1 { _A_ 1 _U_ 1 _N_ _S_ "U(P)" {_A_ 1 _U_ 2 _N_ _N_ _N_ _N_} _N_ _N_ } } #-}
instance RealFrac (Ratio Integer)
{-# GHC_PRAGMA _M_ PreludeRatio {-dfun-} _A_ 0 _N_ _N_ _N_ _F_ _IF_ARGS_ 0 0 X 8 _!_ _TUP_7 [{{Real (Ratio Integer)}}, {{Fractional (Ratio Integer)}}, _forall_ a$z1 =>{{Integral a$z1}} -> (Ratio Integer -> (a$z1, Ratio Integer)), _forall_ a$z1 =>{{Integral a$z1}} -> (Ratio Integer -> a$z1), _forall_ a$z1 =>{{Integral a$z1}} -> (Ratio Integer -> a$z1), _forall_ a$z1 =>{{Integral a$z1}} -> (Ratio Integer -> a$z1), _forall_ a$z1 =>{{Integral a$z1}} -> (Ratio Integer -> a$z1)] [_DFUN_ Real (Ratio Integer), _DFUN_ Fractional (Ratio Integer), _CONSTM_ RealFrac properFraction (Ratio Integer), _CONSTM_ RealFrac truncate (Ratio Integer), _CONSTM_ RealFrac round (Ratio Integer), _CONSTM_ RealFrac ceiling (Ratio Integer), _CONSTM_ RealFrac floor (Ratio Integer)] _N_
- properFraction = _A_ 2 _U_ 11 _N_ _S_ "LU(LL)" {_A_ 3 _U_ 112 _N_ _N_ _N_ _N_} _N_ _N_,
- truncate = _A_ 1 _U_ 22 _N_ _N_ _F_ _IF_ARGS_ 1 1 X 3 _/\_ u0 -> \ (u1 :: {{Integral u0}}) -> _APP_ _TYAPP_ _TYAPP_ _WRKR_ _ORIG_ PreludeCore _truncate { (Ratio Integer) } { u0 } [ _CONSTM_ RealFrac properFraction (Ratio Integer), u1 ] _N_,
- round = _A_ 1 _U_ 22 _N_ _N_ _N_ _N_,
- ceiling = _A_ 1 _U_ 22 _N_ _N_ _N_ _N_,
- floor = _A_ 1 _U_ 22 _N_ _N_ _N_ _N_ #-}
+ properFraction = { _A_ 2 _U_ 11 _N_ _S_ "LU(U(PPP)U(PPP))" {_A_ 5 _U_ 12222 _N_ _N_ _N_ _N_} _N_ _SPECIALISE_ [ Int ] 1 { _A_ 1 _U_ 1 _N_ _S_ "U(U(PPP)U(PPP))" {_A_ 4 _U_ 2222 _N_ _N_ _N_ _N_} _N_ _N_ }, [ Integer ] 1 { _A_ 1 _U_ 1 _N_ _S_ "U(U(PPP)U(PPP))" {_A_ 4 _U_ 2222 _N_ _N_ _N_ _N_} _N_ _N_ } },
+ truncate = { _A_ 2 _U_ 11 _N_ _N_ _N_ _SPECIALISE_ [ Int ] 1 { _A_ 1 _U_ 1 _N_ _S_ "U(U(PPP)U(PPP))" {_A_ 4 _U_ 2222 _N_ _N_ _F_ _IF_ARGS_ 0 4 XXXX 7 \ (u0 :: Int#) (u1 :: Int#) (u2 :: ByteArray#) (u3 :: Integer) -> case _APP_ _WRKR_ _SPEC_ _CONSTM_ RealFrac properFraction (Ratio Integer) [ (Int) ] [ u0, u1, u2, u3 ] of { _ALG_ _TUP_2 (u4 :: Int) (u5 :: Ratio Integer) -> u4; _NO_DEFLT_ } _N_} _F_ _IF_ARGS_ 0 1 X 4 \ (u0 :: Ratio Integer) -> case _APP_ _SPEC_ _CONSTM_ RealFrac properFraction (Ratio Integer) [ (Int) ] [ u0 ] of { _ALG_ _TUP_2 (u1 :: Int) (u2 :: Ratio Integer) -> u1; _NO_DEFLT_ } _N_ }, [ Integer ] 1 { _A_ 1 _U_ 1 _N_ _S_ "U(U(PPP)U(PPP))" {_A_ 4 _U_ 2222 _N_ _N_ _F_ _IF_ARGS_ 0 4 XXXX 7 \ (u0 :: Int#) (u1 :: Int#) (u2 :: ByteArray#) (u3 :: Integer) -> case _APP_ _WRKR_ _SPEC_ _CONSTM_ RealFrac properFraction (Ratio Integer) [ (Integer) ] [ u0, u1, u2, u3 ] of { _ALG_ _TUP_2 (u4 :: Integer) (u5 :: Ratio Integer) -> u4; _NO_DEFLT_ } _N_} _F_ _IF_ARGS_ 0 1 X 4 \ (u0 :: Ratio Integer) -> case _APP_ _SPEC_ _CONSTM_ RealFrac properFraction (Ratio Integer) [ (Integer) ] [ u0 ] of { _ALG_ _TUP_2 (u1 :: Integer) (u2 :: Ratio Integer) -> u1; _NO_DEFLT_ } _N_ } },
+ round = { _A_ 1 _U_ 21 _N_ _N_ _N_ _SPECIALISE_ [ Int ] 1 { _A_ 1 _U_ 1 _N_ _S_ "U(U(PPP)U(PPP))" {_A_ 4 _U_ 2222 _N_ _N_ _N_ _N_} _N_ _N_ }, [ Integer ] 1 { _A_ 1 _U_ 1 _N_ _S_ "U(U(PPP)U(PPP))" {_A_ 4 _U_ 2222 _N_ _N_ _N_ _N_} _N_ _N_ } },
+ ceiling = { _A_ 1 _U_ 21 _N_ _N_ _N_ _SPECIALISE_ [ Int ] 1 { _A_ 1 _U_ 1 _N_ _S_ "U(U(PPP)U(PPP))" {_A_ 4 _U_ 2222 _N_ _N_ _N_ _N_} _N_ _N_ }, [ Integer ] 1 { _A_ 1 _U_ 1 _N_ _S_ "U(U(PPP)U(PPP))" {_A_ 4 _U_ 2222 _N_ _N_ _N_ _N_} _N_ _N_ } },
+ floor = { _A_ 1 _U_ 21 _N_ _N_ _N_ _SPECIALISE_ [ Int ] 1 { _A_ 1 _U_ 1 _N_ _S_ "U(U(PPP)U(PPP))" {_A_ 4 _U_ 2222 _N_ _N_ _N_ _N_} _N_ _N_ }, [ Integer ] 1 { _A_ 1 _U_ 1 _N_ _S_ "U(U(PPP)U(PPP))" {_A_ 4 _U_ 2222 _N_ _N_ _N_ _N_} _N_ _N_ } } #-}
+instance Text ((Int, Int), (Int, Int))
+ {-# GHC_PRAGMA _M_ PreludeBuiltin {-dfun-} _A_ 0 _N_ _N_ _N_ _F_ _IF_ARGS_ 0 0 X 5 _!_ _TUP_4 [(Int -> [Char] -> [(((Int, Int), (Int, Int)), [Char])]), (Int -> ((Int, Int), (Int, Int)) -> [Char] -> [Char]), ([Char] -> [([((Int, Int), (Int, Int))], [Char])]), ([((Int, Int), (Int, Int))] -> [Char] -> [Char])] [_CONSTM_ Text readsPrec (((Int, Int), (Int, Int))), _CONSTM_ Text showsPrec (((Int, Int), (Int, Int))), _CONSTM_ Text readList (((Int, Int), (Int, Int))), _CONSTM_ Text showList (((Int, Int), (Int, Int)))] _N_
+ readsPrec = { _A_ 1 _U_ 02 _N_ _S_ "A" {_A_ 0 _U_ 2 _N_ _N_ _N_ _N_} _N_ _N_ },
+ showsPrec = { _A_ 3 _U_ 012 _N_ _S_ "AU(LL)L" {_A_ 3 _U_ 112 _N_ _N_ _N_ _N_} _N_ _N_ },
+ readList = { _A_ 0 _U_ 2 _N_ _N_ _N_ _N_ },
+ showList = { _A_ 1 _U_ 12 _N_ _N_ _N_ _N_ } #-}
instance Text ()
{-# GHC_PRAGMA _M_ PreludeBuiltin {-dfun-} _A_ 0 _N_ _N_ _N_ _F_ _IF_ARGS_ 0 0 X 5 _!_ _TUP_4 [(Int -> [Char] -> [((), [Char])]), (Int -> () -> [Char] -> [Char]), ([Char] -> [([()], [Char])]), ([()] -> [Char] -> [Char])] [_CONSTM_ Text readsPrec (()), _CONSTM_ Text showsPrec (()), _CONSTM_ Text readList (()), _CONSTM_ Text showList (())] _N_
- readsPrec = _A_ 1 _U_ 02 _N_ _S_ "A" {_A_ 0 _U_ 2 _N_ _N_ _N_ _N_} _N_ _N_,
- showsPrec = _A_ 3 _U_ 012 _N_ _S_ "AEL" {_A_ 2 _U_ 12 _N_ _N_ _F_ _IF_ARGS_ 0 2 CX 4 \ (u0 :: ()) (u1 :: [Char]) -> case u0 of { _ALG_ _TUP_0 -> _APP_ _TYAPP_ _ORIG_ PreludeList (++) { Char } [ _NOREP_S_ "()", u1 ]; _NO_DEFLT_ } _N_} _F_ _IF_ARGS_ 0 3 XCX 4 \ (u0 :: Int) (u1 :: ()) (u2 :: [Char]) -> case u1 of { _ALG_ _TUP_0 -> _APP_ _TYAPP_ _ORIG_ PreludeList (++) { Char } [ _NOREP_S_ "()", u2 ]; _NO_DEFLT_ } _N_,
- readList = _A_ 0 _U_ 2 _N_ _N_ _N_ _N_,
- showList = _A_ 0 _U_ 12 _N_ _N_ _N_ _N_ #-}
+ readsPrec = { _A_ 1 _U_ 02 _N_ _S_ "A" {_A_ 0 _U_ 2 _N_ _N_ _N_ _N_} _N_ _N_ },
+ showsPrec = { _A_ 3 _U_ 012 _N_ _S_ "AEL" {_A_ 2 _U_ 12 _N_ _N_ _F_ _IF_ARGS_ 0 2 CX 4 \ (u0 :: ()) (u1 :: [Char]) -> case u0 of { _ALG_ _TUP_0 -> _APP_ _TYAPP_ _ORIG_ PreludeList (++) { Char } [ _NOREP_S_ "()", u1 ]; _NO_DEFLT_ } _N_} _F_ _IF_ARGS_ 0 3 XCX 4 \ (u0 :: Int) (u1 :: ()) (u2 :: [Char]) -> case u1 of { _ALG_ _TUP_0 -> _APP_ _TYAPP_ _ORIG_ PreludeList (++) { Char } [ _NOREP_S_ "()", u2 ]; _NO_DEFLT_ } _N_ },
+ readList = { _A_ 0 _U_ 2 _N_ _N_ _N_ _N_ },
+ showList = { _A_ 1 _U_ 12 _N_ _N_ _N_ _N_ } #-}
instance (Text a, Text b) => Text (a, b)
{-# GHC_PRAGMA _M_ PreludeBuiltin {-dfun-} _A_ 2 _U_ 22 _N_ _N_ _N_ _N_ #-}
instance (Text a, Text b, Text c) => Text (a, b, c)
{-# GHC_PRAGMA _M_ PreludeBuiltin {-dfun-} _A_ 5 _U_ 22222 _N_ _N_ _N_ _N_ #-}
instance Text (Int, Int)
{-# GHC_PRAGMA _M_ PreludeBuiltin {-dfun-} _A_ 0 _N_ _N_ _N_ _F_ _IF_ARGS_ 0 0 X 5 _!_ _TUP_4 [(Int -> [Char] -> [((Int, Int), [Char])]), (Int -> (Int, Int) -> [Char] -> [Char]), ([Char] -> [([(Int, Int)], [Char])]), ([(Int, Int)] -> [Char] -> [Char])] [_CONSTM_ Text readsPrec ((Int, Int)), _CONSTM_ Text showsPrec ((Int, Int)), _CONSTM_ Text readList ((Int, Int)), _CONSTM_ Text showList ((Int, Int))] _N_
- readsPrec = _A_ 1 _U_ 02 _N_ _S_ "A" {_A_ 0 _U_ 2 _N_ _N_ _N_ _N_} _N_ _N_,
- showsPrec = _A_ 3 _U_ 012 _N_ _S_ "AU(LL)L" {_A_ 3 _U_ 112 _N_ _N_ _N_ _N_} _N_ _N_,
- readList = _A_ 0 _U_ 2 _N_ _N_ _N_ _N_,
- showList = _A_ 0 _U_ 12 _N_ _N_ _N_ _N_ #-}
+ readsPrec = { _A_ 1 _U_ 02 _N_ _S_ "A" {_A_ 0 _U_ 2 _N_ _N_ _N_ _N_} _N_ _N_ },
+ showsPrec = { _A_ 3 _U_ 012 _N_ _S_ "AU(LL)L" {_A_ 3 _U_ 112 _N_ _N_ _N_ _N_} _N_ _N_ },
+ readList = { _A_ 0 _U_ 2 _N_ _N_ _N_ _N_ },
+ showList = { _A_ 1 _U_ 12 _N_ _N_ _N_ _N_ } #-}
+instance Text (Int, Int, Int)
+ {-# GHC_PRAGMA _M_ PreludeBuiltin {-dfun-} _A_ 0 _N_ _N_ _N_ _F_ _IF_ARGS_ 0 0 X 5 _!_ _TUP_4 [(Int -> [Char] -> [((Int, Int, Int), [Char])]), (Int -> (Int, Int, Int) -> [Char] -> [Char]), ([Char] -> [([(Int, Int, Int)], [Char])]), ([(Int, Int, Int)] -> [Char] -> [Char])] [_CONSTM_ Text readsPrec ((Int, Int, Int)), _CONSTM_ Text showsPrec ((Int, Int, Int)), _CONSTM_ Text readList ((Int, Int, Int)), _CONSTM_ Text showList ((Int, Int, Int))] _N_
+ readsPrec = { _A_ 1 _U_ 02 _N_ _S_ "A" {_A_ 0 _U_ 2 _N_ _N_ _N_ _N_} _N_ _N_ },
+ showsPrec = { _A_ 3 _U_ 012 _N_ _S_ "AU(LLL)L" {_A_ 4 _U_ 1112 _N_ _N_ _N_ _N_} _N_ _N_ },
+ readList = { _A_ 0 _U_ 2 _N_ _N_ _N_ _N_ },
+ showList = { _A_ 1 _U_ 12 _N_ _N_ _N_ _N_ } #-}
instance Text (Integer, Integer)
{-# GHC_PRAGMA _M_ PreludeBuiltin {-dfun-} _A_ 0 _N_ _N_ _N_ _F_ _IF_ARGS_ 0 0 X 5 _!_ _TUP_4 [(Int -> [Char] -> [((Integer, Integer), [Char])]), (Int -> (Integer, Integer) -> [Char] -> [Char]), ([Char] -> [([(Integer, Integer)], [Char])]), ([(Integer, Integer)] -> [Char] -> [Char])] [_CONSTM_ Text readsPrec ((Integer, Integer)), _CONSTM_ Text showsPrec ((Integer, Integer)), _CONSTM_ Text readList ((Integer, Integer)), _CONSTM_ Text showList ((Integer, Integer))] _N_
- readsPrec = _A_ 1 _U_ 02 _N_ _S_ "A" {_A_ 0 _U_ 2 _N_ _N_ _N_ _N_} _N_ _N_,
- showsPrec = _A_ 3 _U_ 012 _N_ _S_ "AU(LL)L" {_A_ 3 _U_ 112 _N_ _N_ _N_ _N_} _N_ _N_,
- readList = _A_ 0 _U_ 2 _N_ _N_ _N_ _N_,
- showList = _A_ 0 _U_ 12 _N_ _N_ _N_ _N_ #-}
+ readsPrec = { _A_ 1 _U_ 02 _N_ _S_ "A" {_A_ 0 _U_ 2 _N_ _N_ _N_ _N_} _N_ _N_ },
+ showsPrec = { _A_ 3 _U_ 012 _N_ _S_ "AU(LL)L" {_A_ 3 _U_ 112 _N_ _N_ _N_ _N_} _N_ _N_ },
+ readList = { _A_ 0 _U_ 2 _N_ _N_ _N_ _N_ },
+ showList = { _A_ 1 _U_ 12 _N_ _N_ _N_ _N_ } #-}
instance Text (a -> b)
{-# GHC_PRAGMA _M_ PreludeCore {-dfun-} _A_ 0 _N_ _N_ _N_ _N_ _N_ #-}
+instance Text (Array (Int, Int) Double)
+ {-# GHC_PRAGMA _M_ PreludeArray {-dfun-} _A_ 0 _N_ _N_ _N_ _F_ _IF_ARGS_ 0 0 X 5 _!_ _TUP_4 [(Int -> [Char] -> [(Array (Int, Int) Double, [Char])]), (Int -> Array (Int, Int) Double -> [Char] -> [Char]), ([Char] -> [([Array (Int, Int) Double], [Char])]), ([Array (Int, Int) Double] -> [Char] -> [Char])] [_CONSTM_ Text readsPrec (Array (Int, Int) Double), _CONSTM_ Text showsPrec (Array (Int, Int) Double), _CONSTM_ Text readList (Array (Int, Int) Double), _CONSTM_ Text showList (Array (Int, Int) Double)] _N_
+ readsPrec = { _A_ 1 _U_ 12 _N_ _S_ "U(P)" {_A_ 1 _U_ 22 _N_ _N_ _N_ _N_} _N_ _N_ },
+ showsPrec = { _A_ 2 _U_ 122 _N_ _N_ _N_ _N_ },
+ readList = { _A_ 0 _U_ 2 _N_ _N_ _N_ _N_ },
+ showList = { _A_ 0 _U_ 12 _N_ _N_ _N_ _N_ } #-}
instance (Ix a, Text a, Text b) => Text (Array a b)
{-# GHC_PRAGMA _M_ PreludeArray {-dfun-} _A_ 3 _U_ 222 _N_ _N_ _N_ _N_ #-}
+instance Text (Array Int Double)
+ {-# GHC_PRAGMA _M_ PreludeArray {-dfun-} _A_ 0 _N_ _N_ _N_ _F_ _IF_ARGS_ 0 0 X 5 _!_ _TUP_4 [(Int -> [Char] -> [(Array Int Double, [Char])]), (Int -> Array Int Double -> [Char] -> [Char]), ([Char] -> [([Array Int Double], [Char])]), ([Array Int Double] -> [Char] -> [Char])] [_CONSTM_ Text readsPrec (Array Int Double), _CONSTM_ Text showsPrec (Array Int Double), _CONSTM_ Text readList (Array Int Double), _CONSTM_ Text showList (Array Int Double)] _N_
+ readsPrec = { _A_ 1 _U_ 12 _N_ _S_ "U(P)" {_A_ 1 _U_ 22 _N_ _N_ _N_ _N_} _N_ _N_ },
+ showsPrec = { _A_ 2 _U_ 122 _N_ _N_ _N_ _N_ },
+ readList = { _A_ 0 _U_ 2 _N_ _N_ _N_ _N_ },
+ showList = { _A_ 0 _U_ 12 _N_ _N_ _N_ _N_ } #-}
instance (Text a, Text b) => Text (Assoc a b)
{-# GHC_PRAGMA _M_ PreludeArray {-dfun-} _A_ 2 _U_ 22 _N_ _N_ _N_ _N_ #-}
instance Text Bool
{-# GHC_PRAGMA _M_ PreludeCore {-dfun-} _A_ 0 _N_ _N_ _N_ _F_ _IF_ARGS_ 0 0 X 5 _!_ _TUP_4 [(Int -> [Char] -> [(Bool, [Char])]), (Int -> Bool -> [Char] -> [Char]), ([Char] -> [([Bool], [Char])]), ([Bool] -> [Char] -> [Char])] [_CONSTM_ Text readsPrec (Bool), _CONSTM_ Text showsPrec (Bool), _CONSTM_ Text readList (Bool), _CONSTM_ Text showList (Bool)] _N_
- readsPrec = _A_ 2 _U_ 02 _N_ _S_ "AL" {_A_ 1 _U_ 2 _N_ _N_ _N_ _N_} _N_ _N_,
- showsPrec = _A_ 3 _U_ 012 _N_ _S_ "AEL" {_A_ 2 _U_ 12 _N_ _N_ _N_ _N_} _N_ _N_,
- readList = _A_ 0 _U_ 2 _N_ _N_ _N_ _N_,
- showList = _A_ 0 _U_ 12 _N_ _N_ _N_ _N_ #-}
+ readsPrec = { _A_ 2 _U_ 02 _N_ _S_ "AL" {_A_ 1 _U_ 2 _N_ _N_ _N_ _N_} _N_ _N_ },
+ showsPrec = { _A_ 3 _U_ 012 _N_ _S_ "AEL" {_A_ 2 _U_ 12 _N_ _N_ _N_ _N_} _N_ _N_ },
+ readList = { _A_ 0 _U_ 2 _N_ _N_ _N_ _N_ },
+ showList = { _A_ 1 _U_ 12 _N_ _N_ _F_ _IF_ARGS_ 0 1 X 3 \ (u0 :: [Bool]) -> _APP_ _TYAPP_ _ORIG_ PreludeCore _showList { Bool } [ _WRKR_ _CONSTM_ Text showsPrec (Bool), u0 ] _N_ } #-}
instance Text Char
{-# GHC_PRAGMA _M_ PreludeCore {-dfun-} _A_ 0 _N_ _N_ _N_ _F_ _IF_ARGS_ 0 0 X 5 _!_ _TUP_4 [(Int -> [Char] -> [(Char, [Char])]), (Int -> Char -> [Char] -> [Char]), ([Char] -> [([Char], [Char])]), ([Char] -> [Char] -> [Char])] [_CONSTM_ Text readsPrec (Char), _CONSTM_ Text showsPrec (Char), _CONSTM_ Text readList (Char), _CONSTM_ Text showList (Char)] _N_
- readsPrec = _A_ 1 _U_ 02 _N_ _S_ "A" {_A_ 0 _U_ 2 _N_ _N_ _N_ _N_} _N_ _N_,
- showsPrec = _A_ 3 _U_ 012 _N_ _S_ "AU(P)L" {_A_ 2 _U_ 22 _N_ _N_ _N_ _N_} _N_ _N_,
- readList = _A_ 0 _U_ 2 _N_ _N_ _N_ _N_,
- showList = _A_ 1 _U_ 22 _N_ _N_ _N_ _N_ #-}
+ readsPrec = { _A_ 1 _U_ 02 _N_ _S_ "A" {_A_ 0 _U_ 2 _N_ _N_ _N_ _N_} _N_ _N_ },
+ showsPrec = { _A_ 3 _U_ 012 _N_ _S_ "AU(P)L" {_A_ 2 _U_ 22 _N_ _N_ _N_ _N_} _N_ _N_ },
+ readList = { _A_ 0 _U_ 2 _N_ _N_ _N_ _N_ },
+ showList = { _A_ 1 _U_ 22 _N_ _N_ _N_ _N_ } #-}
instance Text a => Text (Complex a)
{-# GHC_PRAGMA _M_ PreludeComplex {-dfun-} _A_ 1 _U_ 2 _N_ _N_ _N_ _N_ #-}
+instance Text (Complex Double)
+ {-# GHC_PRAGMA _M_ PreludeComplex {-dfun-} _A_ 0 _N_ _N_ _N_ _F_ _IF_ARGS_ 0 0 X 5 _!_ _TUP_4 [(Int -> [Char] -> [(Complex Double, [Char])]), (Int -> Complex Double -> [Char] -> [Char]), ([Char] -> [([Complex Double], [Char])]), ([Complex Double] -> [Char] -> [Char])] [_CONSTM_ Text readsPrec (Complex Double), _CONSTM_ Text showsPrec (Complex Double), _CONSTM_ Text readList (Complex Double), _CONSTM_ Text showList (Complex Double)] _N_
+ readsPrec = { _A_ 1 _U_ 12 _N_ _S_ "U(P)" {_A_ 1 _U_ 22 _N_ _N_ _N_ _N_} _N_ _N_ },
+ showsPrec = { _A_ 2 _U_ 112 _N_ _S_ "LU(LL)" {_A_ 3 _U_ 1222 _N_ _N_ _N_ _N_} _N_ _N_ },
+ readList = { _A_ 0 _U_ 2 _N_ _N_ _N_ _N_ },
+ showList = { _A_ 1 _U_ 12 _N_ _N_ _N_ _N_ } #-}
instance Text Double
{-# GHC_PRAGMA _M_ PreludeCore {-dfun-} _A_ 0 _N_ _N_ _N_ _F_ _IF_ARGS_ 0 0 X 5 _!_ _TUP_4 [(Int -> [Char] -> [(Double, [Char])]), (Int -> Double -> [Char] -> [Char]), ([Char] -> [([Double], [Char])]), ([Double] -> [Char] -> [Char])] [_CONSTM_ Text readsPrec (Double), _CONSTM_ Text showsPrec (Double), _CONSTM_ Text readList (Double), _CONSTM_ Text showList (Double)] _N_
- readsPrec = _A_ 2 _U_ 02 _N_ _S_ "AL" {_A_ 1 _U_ 2 _N_ _N_ _F_ _IF_ARGS_ 0 1 X 3 \ (u0 :: [Char]) -> _APP_ _SPEC_ _ORIG_ PreludeText readSigned [ (Double) ] [ _SPEC_ _ORIG_ PreludeText readFloat [ (Double) ], u0 ] _N_} _F_ _IF_ARGS_ 0 2 XX 3 \ (u0 :: Int) (u1 :: [Char]) -> _APP_ _SPEC_ _ORIG_ PreludeText readSigned [ (Double) ] [ _SPEC_ _ORIG_ PreludeText readFloat [ (Double) ], u1 ] _N_,
- showsPrec = _A_ 2 _U_ 212 _N_ _S_ "LU(P)" {_A_ 2 _U_ 222 _N_ _N_ _F_ _IF_ARGS_ 0 2 XX 4 \ (u0 :: Int) (u1 :: Double#) -> _APP_ _WRKR_ _SPEC_ _ORIG_ PreludeText showSigned [ (Double) ] [ _SPEC_ _ORIG_ PreludeText showFloat [ (Double) ], u0, u1 ] _N_} _F_ _IF_ARGS_ 0 2 XC 5 \ (u0 :: Int) (u1 :: Double) -> case u1 of { _ALG_ D# (u2 :: Double#) -> _APP_ _WRKR_ _SPEC_ _ORIG_ PreludeText showSigned [ (Double) ] [ _SPEC_ _ORIG_ PreludeText showFloat [ (Double) ], u0, u2 ]; _NO_DEFLT_ } _N_,
- readList = _A_ 0 _U_ 2 _N_ _N_ _N_ _N_,
- showList = _A_ 0 _U_ 12 _N_ _N_ _N_ _N_ #-}
+ readsPrec = { _A_ 2 _U_ 02 _N_ _S_ "AL" {_A_ 1 _U_ 2 _N_ _N_ _F_ _IF_ARGS_ 0 1 X 3 \ (u0 :: [Char]) -> _APP_ _SPEC_ _ORIG_ PreludeText readSigned [ (Double) ] [ _SPEC_ _ORIG_ PreludeText readFloat [ (Double) ], u0 ] _N_} _F_ _IF_ARGS_ 0 2 XX 3 \ (u0 :: Int) (u1 :: [Char]) -> _APP_ _SPEC_ _ORIG_ PreludeText readSigned [ (Double) ] [ _SPEC_ _ORIG_ PreludeText readFloat [ (Double) ], u1 ] _N_ },
+ showsPrec = { _A_ 2 _U_ 212 _N_ _S_ "LU(P)" {_A_ 2 _U_ 222 _N_ _N_ _F_ _IF_ARGS_ 0 2 XX 4 \ (u0 :: Int) (u1 :: Double#) -> _APP_ _WRKR_ _SPEC_ _ORIG_ PreludeText showSigned [ (Double) ] [ _SPEC_ _ORIG_ PreludeText showFloat [ (Double) ], u0, u1 ] _N_} _F_ _IF_ARGS_ 0 2 XC 5 \ (u0 :: Int) (u1 :: Double) -> case u1 of { _ALG_ D# (u2 :: Double#) -> _APP_ _WRKR_ _SPEC_ _ORIG_ PreludeText showSigned [ (Double) ] [ _SPEC_ _ORIG_ PreludeText showFloat [ (Double) ], u0, u2 ]; _NO_DEFLT_ } _N_ },
+ readList = { _A_ 0 _U_ 2 _N_ _N_ _N_ _N_ },
+ showList = { _A_ 1 _U_ 12 _N_ _N_ _N_ _N_ } #-}
instance (Text a, Text b) => Text (Either a b)
{-# GHC_PRAGMA _M_ PreludeMonadicIO {-dfun-} _A_ 2 _U_ 22 _N_ _N_ _N_ _N_ #-}
instance Text Float
{-# GHC_PRAGMA _M_ PreludeCore {-dfun-} _A_ 0 _N_ _N_ _N_ _F_ _IF_ARGS_ 0 0 X 5 _!_ _TUP_4 [(Int -> [Char] -> [(Float, [Char])]), (Int -> Float -> [Char] -> [Char]), ([Char] -> [([Float], [Char])]), ([Float] -> [Char] -> [Char])] [_CONSTM_ Text readsPrec (Float), _CONSTM_ Text showsPrec (Float), _CONSTM_ Text readList (Float), _CONSTM_ Text showList (Float)] _N_
- readsPrec = _A_ 2 _U_ 02 _N_ _S_ "AL" {_A_ 1 _U_ 2 _N_ _N_ _N_ _N_} _N_ _N_,
- showsPrec = _A_ 1 _U_ 222 _N_ _N_ _N_ _N_,
- readList = _A_ 0 _U_ 2 _N_ _N_ _N_ _N_,
- showList = _A_ 0 _U_ 12 _N_ _N_ _N_ _N_ #-}
+ readsPrec = { _A_ 2 _U_ 02 _N_ _S_ "AL" {_A_ 1 _U_ 2 _N_ _N_ _N_ _N_} _N_ _N_ },
+ showsPrec = { _A_ 1 _U_ 222 _N_ _N_ _N_ _N_ },
+ readList = { _A_ 0 _U_ 2 _N_ _N_ _N_ _N_ },
+ showList = { _A_ 0 _U_ 12 _N_ _N_ _N_ _N_ } #-}
instance Text IOError13
{-# GHC_PRAGMA _M_ PreludeIOError {-dfun-} _A_ 0 _N_ _N_ _N_ _F_ _IF_ARGS_ 0 0 X 5 _!_ _TUP_4 [(Int -> [Char] -> [(IOError13, [Char])]), (Int -> IOError13 -> [Char] -> [Char]), ([Char] -> [([IOError13], [Char])]), ([IOError13] -> [Char] -> [Char])] [_CONSTM_ Text readsPrec (IOError13), _CONSTM_ Text showsPrec (IOError13), _CONSTM_ Text readList (IOError13), _CONSTM_ Text showList (IOError13)] _N_
- readsPrec = _A_ 2 _U_ 22 _N_ _S_ _!_ _F_ _IF_ARGS_ 0 2 XX 4 \ (u0 :: Int) (u1 :: [Char]) -> _APP_ _TYAPP_ patError# { (Int -> [Char] -> [(IOError13, [Char])]) } [ _NOREP_S_ "%DPreludeCore.Text.readsPrec\"", u0, u1 ] _N_,
- showsPrec = _A_ 2 _U_ 012 _N_ _S_ "AS" {_A_ 1 _U_ 12 _N_ _N_ _N_ _N_} _N_ _N_,
- readList = _A_ 0 _U_ 2 _N_ _N_ _N_ _N_,
- showList = _A_ 0 _U_ 12 _N_ _N_ _N_ _N_ #-}
+ readsPrec = { _A_ 2 _U_ 02 _N_ _S_ _!_ _N_ _N_ },
+ showsPrec = { _A_ 2 _U_ 012 _N_ _S_ "AS" {_A_ 1 _U_ 12 _N_ _N_ _N_ _N_} _N_ _N_ },
+ readList = { _A_ 0 _U_ 2 _N_ _N_ _N_ _N_ },
+ showList = { _A_ 1 _U_ 12 _N_ _N_ _F_ _IF_ARGS_ 0 1 X 3 \ (u0 :: [IOError13]) -> _APP_ _TYAPP_ _ORIG_ PreludeCore _showList { IOError13 } [ _WRKR_ _CONSTM_ Text showsPrec (IOError13), u0 ] _N_ } #-}
instance Text Int
{-# GHC_PRAGMA _M_ PreludeCore {-dfun-} _A_ 0 _N_ _N_ _N_ _F_ _IF_ARGS_ 0 0 X 5 _!_ _TUP_4 [(Int -> [Char] -> [(Int, [Char])]), (Int -> Int -> [Char] -> [Char]), ([Char] -> [([Int], [Char])]), ([Int] -> [Char] -> [Char])] [_CONSTM_ Text readsPrec (Int), _CONSTM_ Text showsPrec (Int), _CONSTM_ Text readList (Int), _CONSTM_ Text showList (Int)] _N_
- readsPrec = _A_ 2 _U_ 02 _N_ _S_ "AL" {_A_ 1 _U_ 2 _N_ _N_ _F_ _IF_ARGS_ 0 1 X 3 \ (u0 :: [Char]) -> _APP_ _SPEC_ _ORIG_ PreludeText readSigned [ (Int) ] [ _SPEC_ _ORIG_ PreludeText readDec [ (Int) ], u0 ] _N_} _F_ _IF_ARGS_ 0 2 XX 3 \ (u0 :: Int) (u1 :: [Char]) -> _APP_ _SPEC_ _ORIG_ PreludeText readSigned [ (Int) ] [ _SPEC_ _ORIG_ PreludeText readDec [ (Int) ], u1 ] _N_,
- showsPrec = _A_ 3 _U_ 212 _N_ _S_ "LU(P)L" {_A_ 3 _U_ 222 _N_ _N_ _N_ _N_} _N_ _N_,
- readList = _A_ 0 _U_ 2 _N_ _N_ _N_ _N_,
- showList = _A_ 0 _U_ 12 _N_ _N_ _N_ _N_ #-}
+ readsPrec = { _A_ 2 _U_ 02 _N_ _S_ "AL" {_A_ 1 _U_ 2 _N_ _N_ _F_ _IF_ARGS_ 0 1 X 3 \ (u0 :: [Char]) -> _APP_ _SPEC_ _ORIG_ PreludeText readSigned [ (Int) ] [ _SPEC_ _ORIG_ PreludeText readDec [ (Int) ], u0 ] _N_} _F_ _IF_ARGS_ 0 2 XX 3 \ (u0 :: Int) (u1 :: [Char]) -> _APP_ _SPEC_ _ORIG_ PreludeText readSigned [ (Int) ] [ _SPEC_ _ORIG_ PreludeText readDec [ (Int) ], u1 ] _N_ },
+ showsPrec = { _A_ 3 _U_ 212 _N_ _S_ "LU(P)L" {_A_ 3 _U_ 222 _N_ _N_ _N_ _N_} _N_ _N_ },
+ readList = { _A_ 0 _U_ 2 _N_ _N_ _N_ _N_ },
+ showList = { _A_ 1 _U_ 12 _N_ _N_ _N_ _N_ } #-}
instance Text Integer
{-# GHC_PRAGMA _M_ PreludeCore {-dfun-} _A_ 0 _N_ _N_ _N_ _F_ _IF_ARGS_ 0 0 X 5 _!_ _TUP_4 [(Int -> [Char] -> [(Integer, [Char])]), (Int -> Integer -> [Char] -> [Char]), ([Char] -> [([Integer], [Char])]), ([Integer] -> [Char] -> [Char])] [_CONSTM_ Text readsPrec (Integer), _CONSTM_ Text showsPrec (Integer), _CONSTM_ Text readList (Integer), _CONSTM_ Text showList (Integer)] _N_
- readsPrec = _A_ 2 _U_ 02 _N_ _S_ "AL" {_A_ 1 _U_ 2 _N_ _N_ _F_ _IF_ARGS_ 0 1 X 3 \ (u0 :: [Char]) -> _APP_ _SPEC_ _ORIG_ PreludeText readSigned [ (Integer) ] [ _SPEC_ _ORIG_ PreludeText readDec [ (Integer) ], u0 ] _N_} _F_ _IF_ARGS_ 0 2 XX 3 \ (u0 :: Int) (u1 :: [Char]) -> _APP_ _SPEC_ _ORIG_ PreludeText readSigned [ (Integer) ] [ _SPEC_ _ORIG_ PreludeText readDec [ (Integer) ], u1 ] _N_,
- showsPrec = _A_ 3 _U_ 212 _N_ _S_ "LU(PPP)L" {_A_ 5 _U_ 22222 _N_ _N_ _N_ _N_} _N_ _N_,
- readList = _A_ 0 _U_ 2 _N_ _N_ _N_ _N_,
- showList = _A_ 0 _U_ 12 _N_ _N_ _N_ _N_ #-}
+ readsPrec = { _A_ 2 _U_ 02 _N_ _S_ "AL" {_A_ 1 _U_ 2 _N_ _N_ _F_ _IF_ARGS_ 0 1 X 3 \ (u0 :: [Char]) -> _APP_ _SPEC_ _ORIG_ PreludeText readSigned [ (Integer) ] [ _SPEC_ _ORIG_ PreludeText readDec [ (Integer) ], u0 ] _N_} _F_ _IF_ARGS_ 0 2 XX 3 \ (u0 :: Int) (u1 :: [Char]) -> _APP_ _SPEC_ _ORIG_ PreludeText readSigned [ (Integer) ] [ _SPEC_ _ORIG_ PreludeText readDec [ (Integer) ], u1 ] _N_ },
+ showsPrec = { _A_ 3 _U_ 212 _N_ _S_ "LU(PPP)L" {_A_ 5 _U_ 22222 _N_ _N_ _N_ _N_} _N_ _N_ },
+ readList = { _A_ 0 _U_ 2 _N_ _N_ _N_ _N_ },
+ showList = { _A_ 1 _U_ 12 _N_ _N_ _N_ _N_ } #-}
instance Text a => Text (Maybe a)
{-# GHC_PRAGMA _M_ PreludeStdIO {-dfun-} _A_ 1 _U_ 2 _N_ _N_ _N_ _N_ #-}
instance Integral a => Text (Ratio a)
{-# GHC_PRAGMA _M_ PreludeRatio {-dfun-} _A_ 1 _U_ 2 _N_ _N_ _N_ _N_ #-}
instance Text (Ratio Integer)
{-# GHC_PRAGMA _M_ PreludeRatio {-dfun-} _A_ 0 _N_ _N_ _N_ _F_ _IF_ARGS_ 0 0 X 5 _!_ _TUP_4 [(Int -> [Char] -> [(Ratio Integer, [Char])]), (Int -> Ratio Integer -> [Char] -> [Char]), ([Char] -> [([Ratio Integer], [Char])]), ([Ratio Integer] -> [Char] -> [Char])] [_CONSTM_ Text readsPrec (Ratio Integer), _CONSTM_ Text showsPrec (Ratio Integer), _CONSTM_ Text readList (Ratio Integer), _CONSTM_ Text showList (Ratio Integer)] _N_
- readsPrec = _A_ 1 _U_ 12 _N_ _S_ "U(P)" {_A_ 1 _U_ 22 _N_ _N_ _N_ _N_} _N_ _N_,
- showsPrec = _A_ 2 _U_ 112 _N_ _S_ "LU(LL)" {_A_ 3 _U_ 1222 _N_ _N_ _N_ _N_} _N_ _N_,
- readList = _A_ 0 _U_ 2 _N_ _N_ _N_ _N_,
- showList = _A_ 0 _U_ 12 _N_ _N_ _N_ _N_ #-}
+ readsPrec = { _A_ 1 _U_ 12 _N_ _S_ "U(P)" {_A_ 1 _U_ 22 _N_ _N_ _N_ _N_} _N_ _N_ },
+ showsPrec = { _A_ 2 _U_ 112 _N_ _S_ "LU(LL)" {_A_ 3 _U_ 1222 _N_ _N_ _N_ _N_} _N_ _N_ },
+ readList = { _A_ 0 _U_ 2 _N_ _N_ _N_ _N_ },
+ showList = { _A_ 1 _U_ 12 _N_ _N_ _N_ _N_ } #-}
instance Text a => Text [a]
{-# GHC_PRAGMA _M_ PreludeBuiltin {-dfun-} _A_ 1 _U_ 2 _N_ _N_ _N_ _N_ #-}
+instance Text [Bool]
+ {-# GHC_PRAGMA _M_ PreludeBuiltin {-dfun-} _A_ 0 _N_ _N_ _N_ _F_ _IF_ARGS_ 0 0 X 5 _!_ _TUP_4 [(Int -> [Char] -> [([Bool], [Char])]), (Int -> [Bool] -> [Char] -> [Char]), ([Char] -> [([[Bool]], [Char])]), ([[Bool]] -> [Char] -> [Char])] [_CONSTM_ Text readsPrec ([Bool]), _CONSTM_ Text showsPrec ([Bool]), _CONSTM_ Text readList ([Bool]), _CONSTM_ Text showList ([Bool])] _N_
+ readsPrec = { _A_ 1 _U_ 02 _N_ _S_ "A" {_A_ 0 _U_ 2 _N_ _N_ _F_ _IF_ARGS_ 0 0 X 1 _CONSTM_ Text readList (Bool) _N_} _F_ _IF_ARGS_ 0 1 X 1 \ (u0 :: Int) -> _CONSTM_ Text readList (Bool) _N_ },
+ showsPrec = { _A_ 2 _U_ 012 _N_ _S_ "AS" {_A_ 1 _U_ 12 _N_ _N_ _F_ _IF_ARGS_ 0 1 X 3 \ (u0 :: [Bool]) -> _APP_ _TYAPP_ _ORIG_ PreludeCore _showList { Bool } [ _WRKR_ _CONSTM_ Text showsPrec (Bool), u0 ] _N_} _F_ _IF_ARGS_ 0 2 XX 3 \ (u0 :: Int) (u1 :: [Bool]) -> _APP_ _TYAPP_ _ORIG_ PreludeCore _showList { Bool } [ _WRKR_ _CONSTM_ Text showsPrec (Bool), u1 ] _N_ },
+ readList = { _A_ 0 _U_ 2 _N_ _N_ _N_ _N_ },
+ showList = { _A_ 1 _U_ 12 _N_ _N_ _N_ _N_ } #-}
instance Text [Char]
{-# GHC_PRAGMA _M_ PreludeBuiltin {-dfun-} _A_ 0 _N_ _N_ _N_ _F_ _IF_ARGS_ 0 0 X 5 _!_ _TUP_4 [(Int -> [Char] -> [([Char], [Char])]), (Int -> [Char] -> [Char] -> [Char]), ([Char] -> [([[Char]], [Char])]), ([[Char]] -> [Char] -> [Char])] [_CONSTM_ Text readsPrec ([Char]), _CONSTM_ Text showsPrec ([Char]), _CONSTM_ Text readList ([Char]), _CONSTM_ Text showList ([Char])] _N_
- readsPrec = _A_ 1 _U_ 02 _N_ _S_ "A" {_A_ 0 _U_ 2 _N_ _N_ _F_ _IF_ARGS_ 0 0 X 1 _CONSTM_ Text readList (Char) _N_} _F_ _IF_ARGS_ 0 1 X 1 \ (u0 :: Int) -> _CONSTM_ Text readList (Char) _N_,
- showsPrec = _A_ 2 _U_ 022 _N_ _S_ "AL" {_A_ 1 _U_ 22 _N_ _N_ _F_ _IF_ARGS_ 0 0 X 1 _CONSTM_ Text showList (Char) _N_} _F_ _IF_ARGS_ 0 2 XX 2 \ (u0 :: Int) (u1 :: [Char]) -> _APP_ _CONSTM_ Text showList (Char) [ u1 ] _N_,
- readList = _A_ 0 _U_ 2 _N_ _N_ _N_ _N_,
- showList = _A_ 0 _U_ 12 _N_ _N_ _N_ _N_ #-}
+ readsPrec = { _A_ 1 _U_ 02 _N_ _S_ "A" {_A_ 0 _U_ 2 _N_ _N_ _F_ _IF_ARGS_ 0 0 X 1 _CONSTM_ Text readList (Char) _N_} _F_ _IF_ARGS_ 0 1 X 1 \ (u0 :: Int) -> _CONSTM_ Text readList (Char) _N_ },
+ showsPrec = { _A_ 2 _U_ 022 _N_ _S_ "AL" {_A_ 1 _U_ 22 _N_ _N_ _F_ _IF_ARGS_ 0 0 X 1 _CONSTM_ Text showList (Char) _N_} _F_ _IF_ARGS_ 0 2 XX 2 \ (u0 :: Int) (u1 :: [Char]) -> _APP_ _CONSTM_ Text showList (Char) [ u1 ] _N_ },
+ readList = { _A_ 0 _U_ 2 _N_ _N_ _N_ _N_ },
+ showList = { _A_ 1 _U_ 12 _N_ _N_ _F_ _IF_ARGS_ 0 1 X 3 \ (u0 :: [[Char]]) -> _APP_ _TYAPP_ _ORIG_ PreludeCore _showList { [Char] } [ _CONSTM_ Text showList (Char), u0 ] _N_ } #-}
+instance Text [Complex Double]
+ {-# GHC_PRAGMA _M_ PreludeBuiltin {-dfun-} _A_ 0 _N_ _N_ _N_ _F_ _IF_ARGS_ 0 0 X 5 _!_ _TUP_4 [(Int -> [Char] -> [([Complex Double], [Char])]), (Int -> [Complex Double] -> [Char] -> [Char]), ([Char] -> [([[Complex Double]], [Char])]), ([[Complex Double]] -> [Char] -> [Char])] [_CONSTM_ Text readsPrec ([Complex Double]), _CONSTM_ Text showsPrec ([Complex Double]), _CONSTM_ Text readList ([Complex Double]), _CONSTM_ Text showList ([Complex Double])] _N_
+ readsPrec = { _A_ 1 _U_ 02 _N_ _S_ "A" {_A_ 0 _U_ 2 _N_ _N_ _F_ _IF_ARGS_ 0 0 X 1 _CONSTM_ Text readList (Complex Double) _N_} _F_ _IF_ARGS_ 0 1 X 1 \ (u0 :: Int) -> _CONSTM_ Text readList (Complex Double) _N_ },
+ showsPrec = { _A_ 2 _U_ 022 _N_ _S_ "AL" {_A_ 1 _U_ 22 _N_ _N_ _F_ _IF_ARGS_ 0 0 X 1 _CONSTM_ Text showList (Complex Double) _N_} _F_ _IF_ARGS_ 0 2 XX 2 \ (u0 :: Int) (u1 :: [Complex Double]) -> _APP_ _CONSTM_ Text showList (Complex Double) [ u1 ] _N_ },
+ readList = { _A_ 0 _U_ 2 _N_ _N_ _N_ _N_ },
+ showList = { _A_ 1 _U_ 12 _N_ _N_ _F_ _IF_ARGS_ 0 1 X 3 \ (u0 :: [[Complex Double]]) -> _APP_ _TYAPP_ _ORIG_ PreludeCore _showList { [Complex Double] } [ _CONSTM_ Text showList (Complex Double), u0 ] _N_ } #-}
+instance Text [Double]
+ {-# GHC_PRAGMA _M_ PreludeBuiltin {-dfun-} _A_ 0 _N_ _N_ _N_ _F_ _IF_ARGS_ 0 0 X 5 _!_ _TUP_4 [(Int -> [Char] -> [([Double], [Char])]), (Int -> [Double] -> [Char] -> [Char]), ([Char] -> [([[Double]], [Char])]), ([[Double]] -> [Char] -> [Char])] [_CONSTM_ Text readsPrec ([Double]), _CONSTM_ Text showsPrec ([Double]), _CONSTM_ Text readList ([Double]), _CONSTM_ Text showList ([Double])] _N_
+ readsPrec = { _A_ 1 _U_ 02 _N_ _S_ "A" {_A_ 0 _U_ 2 _N_ _N_ _F_ _IF_ARGS_ 0 0 X 1 _CONSTM_ Text readList (Double) _N_} _F_ _IF_ARGS_ 0 1 X 1 \ (u0 :: Int) -> _CONSTM_ Text readList (Double) _N_ },
+ showsPrec = { _A_ 2 _U_ 022 _N_ _S_ "AL" {_A_ 1 _U_ 22 _N_ _N_ _F_ _IF_ARGS_ 0 0 X 1 _CONSTM_ Text showList (Double) _N_} _F_ _IF_ARGS_ 0 2 XX 2 \ (u0 :: Int) (u1 :: [Double]) -> _APP_ _CONSTM_ Text showList (Double) [ u1 ] _N_ },
+ readList = { _A_ 0 _U_ 2 _N_ _N_ _N_ _N_ },
+ showList = { _A_ 1 _U_ 12 _N_ _N_ _F_ _IF_ARGS_ 0 1 X 3 \ (u0 :: [[Double]]) -> _APP_ _TYAPP_ _ORIG_ PreludeCore _showList { [Double] } [ _CONSTM_ Text showList (Double), u0 ] _N_ } #-}
instance Text [Int]
{-# GHC_PRAGMA _M_ PreludeBuiltin {-dfun-} _A_ 0 _N_ _N_ _N_ _F_ _IF_ARGS_ 0 0 X 5 _!_ _TUP_4 [(Int -> [Char] -> [([Int], [Char])]), (Int -> [Int] -> [Char] -> [Char]), ([Char] -> [([[Int]], [Char])]), ([[Int]] -> [Char] -> [Char])] [_CONSTM_ Text readsPrec ([Int]), _CONSTM_ Text showsPrec ([Int]), _CONSTM_ Text readList ([Int]), _CONSTM_ Text showList ([Int])] _N_
- readsPrec = _A_ 1 _U_ 02 _N_ _S_ "A" {_A_ 0 _U_ 2 _N_ _N_ _F_ _IF_ARGS_ 0 0 X 1 _CONSTM_ Text readList (Int) _N_} _F_ _IF_ARGS_ 0 1 X 1 \ (u0 :: Int) -> _CONSTM_ Text readList (Int) _N_,
- showsPrec = _A_ 1 _U_ 022 _N_ _S_ "A" {_A_ 0 _U_ 22 _N_ _N_ _F_ _IF_ARGS_ 0 0 X 1 _CONSTM_ Text showList (Int) _N_} _F_ _IF_ARGS_ 0 1 X 1 \ (u0 :: Int) -> _CONSTM_ Text showList (Int) _N_,
- readList = _A_ 0 _U_ 2 _N_ _N_ _N_ _N_,
- showList = _A_ 0 _U_ 12 _N_ _N_ _N_ _N_ #-}
+ readsPrec = { _A_ 1 _U_ 02 _N_ _S_ "A" {_A_ 0 _U_ 2 _N_ _N_ _F_ _IF_ARGS_ 0 0 X 1 _CONSTM_ Text readList (Int) _N_} _F_ _IF_ARGS_ 0 1 X 1 \ (u0 :: Int) -> _CONSTM_ Text readList (Int) _N_ },
+ showsPrec = { _A_ 2 _U_ 022 _N_ _S_ "AL" {_A_ 1 _U_ 22 _N_ _N_ _F_ _IF_ARGS_ 0 0 X 1 _CONSTM_ Text showList (Int) _N_} _F_ _IF_ARGS_ 0 2 XX 2 \ (u0 :: Int) (u1 :: [Int]) -> _APP_ _CONSTM_ Text showList (Int) [ u1 ] _N_ },
+ readList = { _A_ 0 _U_ 2 _N_ _N_ _N_ _N_ },
+ showList = { _A_ 1 _U_ 12 _N_ _N_ _F_ _IF_ARGS_ 0 1 X 3 \ (u0 :: [[Int]]) -> _APP_ _TYAPP_ _ORIG_ PreludeCore _showList { [Int] } [ _CONSTM_ Text showList (Int), u0 ] _N_ } #-}
+instance Text [Integer]
+ {-# GHC_PRAGMA _M_ PreludeBuiltin {-dfun-} _A_ 0 _N_ _N_ _N_ _F_ _IF_ARGS_ 0 0 X 5 _!_ _TUP_4 [(Int -> [Char] -> [([Integer], [Char])]), (Int -> [Integer] -> [Char] -> [Char]), ([Char] -> [([[Integer]], [Char])]), ([[Integer]] -> [Char] -> [Char])] [_CONSTM_ Text readsPrec ([Integer]), _CONSTM_ Text showsPrec ([Integer]), _CONSTM_ Text readList ([Integer]), _CONSTM_ Text showList ([Integer])] _N_
+ readsPrec = { _A_ 1 _U_ 02 _N_ _S_ "A" {_A_ 0 _U_ 2 _N_ _N_ _F_ _IF_ARGS_ 0 0 X 1 _CONSTM_ Text readList (Integer) _N_} _F_ _IF_ARGS_ 0 1 X 1 \ (u0 :: Int) -> _CONSTM_ Text readList (Integer) _N_ },
+ showsPrec = { _A_ 2 _U_ 022 _N_ _S_ "AL" {_A_ 1 _U_ 22 _N_ _N_ _F_ _IF_ARGS_ 0 0 X 1 _CONSTM_ Text showList (Integer) _N_} _F_ _IF_ARGS_ 0 2 XX 2 \ (u0 :: Int) (u1 :: [Integer]) -> _APP_ _CONSTM_ Text showList (Integer) [ u1 ] _N_ },
+ readList = { _A_ 0 _U_ 2 _N_ _N_ _N_ _N_ },
+ showList = { _A_ 1 _U_ 12 _N_ _N_ _F_ _IF_ARGS_ 0 1 X 3 \ (u0 :: [[Integer]]) -> _APP_ _TYAPP_ _ORIG_ PreludeCore _showList { [Integer] } [ _CONSTM_ Text showList (Integer), u0 ] _N_ } #-}
+instance Text [[Char]]
+ {-# GHC_PRAGMA _M_ PreludeBuiltin {-dfun-} _A_ 0 _N_ _N_ _N_ _F_ _IF_ARGS_ 0 0 X 5 _!_ _TUP_4 [(Int -> [Char] -> [([[Char]], [Char])]), (Int -> [[Char]] -> [Char] -> [Char]), ([Char] -> [([[[Char]]], [Char])]), ([[[Char]]] -> [Char] -> [Char])] [_CONSTM_ Text readsPrec ([[Char]]), _CONSTM_ Text showsPrec ([[Char]]), _CONSTM_ Text readList ([[Char]]), _CONSTM_ Text showList ([[Char]])] _N_
+ readsPrec = { _A_ 1 _U_ 02 _N_ _S_ "A" {_A_ 0 _U_ 2 _N_ _N_ _F_ _IF_ARGS_ 0 0 X 1 _CONSTM_ Text readList ([Char]) _N_} _F_ _IF_ARGS_ 0 1 X 1 \ (u0 :: Int) -> _CONSTM_ Text readList ([Char]) _N_ },
+ showsPrec = { _A_ 2 _U_ 012 _N_ _S_ "AS" {_A_ 1 _U_ 12 _N_ _N_ _F_ _IF_ARGS_ 0 1 X 3 \ (u0 :: [[Char]]) -> _APP_ _TYAPP_ _ORIG_ PreludeCore _showList { [Char] } [ _CONSTM_ Text showList (Char), u0 ] _N_} _F_ _IF_ARGS_ 0 2 XX 2 \ (u0 :: Int) (u1 :: [[Char]]) -> _APP_ _CONSTM_ Text showList ([Char]) [ u1 ] _N_ },
+ readList = { _A_ 0 _U_ 2 _N_ _N_ _N_ _N_ },
+ showList = { _A_ 1 _U_ 12 _N_ _N_ _N_ _N_ } #-}
+instance Text [[Int]]
+ {-# GHC_PRAGMA _M_ PreludeBuiltin {-dfun-} _A_ 0 _N_ _N_ _N_ _F_ _IF_ARGS_ 0 0 X 5 _!_ _TUP_4 [(Int -> [Char] -> [([[Int]], [Char])]), (Int -> [[Int]] -> [Char] -> [Char]), ([Char] -> [([[[Int]]], [Char])]), ([[[Int]]] -> [Char] -> [Char])] [_CONSTM_ Text readsPrec ([[Int]]), _CONSTM_ Text showsPrec ([[Int]]), _CONSTM_ Text readList ([[Int]]), _CONSTM_ Text showList ([[Int]])] _N_
+ readsPrec = { _A_ 1 _U_ 02 _N_ _S_ "A" {_A_ 0 _U_ 2 _N_ _N_ _F_ _IF_ARGS_ 0 0 X 1 _CONSTM_ Text readList ([Int]) _N_} _F_ _IF_ARGS_ 0 1 X 1 \ (u0 :: Int) -> _CONSTM_ Text readList ([Int]) _N_ },
+ showsPrec = { _A_ 2 _U_ 012 _N_ _S_ "AS" {_A_ 1 _U_ 12 _N_ _N_ _F_ _IF_ARGS_ 0 1 X 3 \ (u0 :: [[Int]]) -> _APP_ _TYAPP_ _ORIG_ PreludeCore _showList { [Int] } [ _CONSTM_ Text showList (Int), u0 ] _N_} _F_ _IF_ARGS_ 0 2 XX 2 \ (u0 :: Int) (u1 :: [[Int]]) -> _APP_ _CONSTM_ Text showList ([Int]) [ u1 ] _N_ },
+ readList = { _A_ 0 _U_ 2 _N_ _N_ _N_ _N_ },
+ showList = { _A_ 1 _U_ 12 _N_ _N_ _N_ _N_ } #-}
instance Text _PackedString
{-# GHC_PRAGMA _M_ PreludePS {-dfun-} _A_ 0 _N_ _N_ _N_ _F_ _IF_ARGS_ 0 0 X 5 _!_ _TUP_4 [(Int -> [Char] -> [(_PackedString, [Char])]), (Int -> _PackedString -> [Char] -> [Char]), ([Char] -> [([_PackedString], [Char])]), ([_PackedString] -> [Char] -> [Char])] [_CONSTM_ Text readsPrec (_PackedString), _CONSTM_ Text showsPrec (_PackedString), _CONSTM_ Text readList (_PackedString), _CONSTM_ Text showList (_PackedString)] _N_
- readsPrec = _A_ 2 _U_ 02 _N_ _S_ _!_ _F_ _IF_ARGS_ 0 2 XX 3 \ (u0 :: Int) (u1 :: [Char]) -> _APP_ _TYAPP_ error { ([Char] -> [(_PackedString, [Char])]) } [ _NOREP_S_ "readsPrec: _PackedString: ToDo", u1 ] _N_,
- showsPrec = _A_ 3 _U_ 012 _N_ _S_ "ALL" {_A_ 2 _U_ 12 _N_ _N_ _N_ _N_} _F_ _IF_ARGS_ 0 3 XXX 6 \ (u0 :: Int) (u1 :: _PackedString) (u2 :: [Char]) -> let {(u3 :: [Char]) = _APP_ _ORIG_ PreludePS _unpackPS [ u1 ]} in _APP_ _CONSTM_ Text showList (Char) [ u3, u2 ] _N_,
- readList = _A_ 0 _U_ 2 _N_ _N_ _N_ _N_,
- showList = _A_ 0 _U_ 12 _N_ _N_ _N_ _N_ #-}
+ readsPrec = { _A_ 2 _U_ 02 _N_ _S_ _!_ _N_ _N_ },
+ showsPrec = { _A_ 3 _U_ 012 _N_ _S_ "ALL" {_A_ 2 _U_ 12 _N_ _N_ _N_ _N_} _F_ _IF_ARGS_ 0 3 XXX 6 \ (u0 :: Int) (u1 :: _PackedString) (u2 :: [Char]) -> let {(u3 :: [Char]) = _APP_ _ORIG_ PreludePS _unpackPS [ u1 ]} in _APP_ _CONSTM_ Text showList (Char) [ u3, u2 ] _N_ },
+ readList = { _A_ 0 _U_ 2 _N_ _N_ _N_ _N_ },
+ showList = { _A_ 1 _U_ 12 _N_ _N_ _F_ _IF_ARGS_ 0 1 X 3 \ (u0 :: [_PackedString]) -> _APP_ _TYAPP_ _ORIG_ PreludeCore _showList { _PackedString } [ _WRKR_ _CONSTM_ Text showsPrec (_PackedString), u0 ] _N_ } #-}
instance _CCallable Char
{-# GHC_PRAGMA _M_ PreludeCore {-dfun-} _A_ 0 _N_ _N_ _N_ _F_ _IF_ARGS_ 0 0 X 1 _!_ _TUP_0 [] [] _N_ #-}
instance _CCallable Double
HandlePosn(..),
IO(..),
_Handle,
- _MVar
+ _MVar,
+ -- for unfoldings ...
+ _fromRational, __i0, __i1, __i2, __im1, __i8, __i10, __i16, __rhalf,
+ __integer0, __integer1, __integer2, __integerm1
) where
-- few *Ty(s) imports
-{-# GHC_PRAGMA INTERFACE VERSION 5 #-}
+{-# GHC_PRAGMA INTERFACE VERSION 6 #-}
interface PreludeCore where
import PreludeArray(Array, Assoc(..), _ByteArray)
import PreludeBuiltin(Bin, Char(..), Double(..), Float(..), Int(..), Integer(..), List(..), Tuple0, Tuple2, Tuple3, Tuple4, Tuple5, _Addr(..), _CMP_TAG(..), _RealWorld(..), _State(..), _Word(..))
class Binary a where
readBin :: Bin -> (a, Bin)
{-# GHC_PRAGMA {-meth-} _A_ 1 _U_ 12 _N_ _S_ "S" _F_ _IF_ARGS_ 1 1 C 2 _/\_ u0 -> \ (u1 :: (Bin -> (u0, Bin), u0 -> Bin -> Bin)) -> case u1 of { _ALG_ _TUP_2 (u2 :: Bin -> (u0, Bin)) (u3 :: u0 -> Bin -> Bin) -> u2; _NO_DEFLT_ } _N_
- {-defm-} _A_ 2 _U_ 02 _N_ _S_ _!_ _F_ _IF_ARGS_ 1 2 XX 3 _/\_ u0 -> \ (u1 :: {{Binary u0}}) (u2 :: Bin) -> _APP_ _TYAPP_ patError# { (Bin -> (u0, Bin)) } [ _NOREP_S_ "%DPreludeCore.Binary.readBin\"", u2 ] _N_ #-}
+ {-defm-} _A_ 2 _U_ 02 _N_ _S_ _!_ _N_ _N_ #-}
showBin :: a -> Bin -> Bin
{-# GHC_PRAGMA {-meth-} _A_ 1 _U_ 122 _N_ _S_ "S" _F_ _IF_ARGS_ 1 1 C 2 _/\_ u0 -> \ (u1 :: (Bin -> (u0, Bin), u0 -> Bin -> Bin)) -> case u1 of { _ALG_ _TUP_2 (u2 :: Bin -> (u0, Bin)) (u3 :: u0 -> Bin -> Bin) -> u3; _NO_DEFLT_ } _N_
- {-defm-} _A_ 3 _U_ 022 _N_ _S_ _!_ _F_ _IF_ARGS_ 1 3 XXX 4 _/\_ u0 -> \ (u1 :: {{Binary u0}}) (u2 :: u0) (u3 :: Bin) -> _APP_ _TYAPP_ patError# { (u0 -> Bin -> Bin) } [ _NOREP_S_ "%DPreludeCore.Binary.showBin\"", u2, u3 ] _N_ #-}
+ {-defm-} _A_ 3 _U_ 022 _N_ _S_ _!_ _N_ _N_ #-}
class (Ord a) => Enum a {-# GHC_PRAGMA {-superdicts-} _A_ 1 _U_ 1 _N_ _S_ "S" _F_ _IF_ARGS_ 1 1 C 2 _/\_ u0 -> \ (u1 :: ({{Ord u0}}, u0 -> [u0], u0 -> u0 -> [u0], u0 -> u0 -> [u0], u0 -> u0 -> u0 -> [u0])) -> case u1 of { _ALG_ _TUP_5 (u2 :: {{Ord u0}}) (u3 :: u0 -> [u0]) (u4 :: u0 -> u0 -> [u0]) (u5 :: u0 -> u0 -> [u0]) (u6 :: u0 -> u0 -> u0 -> [u0]) -> u2; _NO_DEFLT_ } _N_ #-} where
enumFrom :: a -> [a]
{-# GHC_PRAGMA {-meth-} _A_ 1 _U_ 12 _N_ _S_ "S" _F_ _IF_ARGS_ 1 1 C 2 _/\_ u0 -> \ (u1 :: ({{Ord u0}}, u0 -> [u0], u0 -> u0 -> [u0], u0 -> u0 -> [u0], u0 -> u0 -> u0 -> [u0])) -> case u1 of { _ALG_ _TUP_5 (u2 :: {{Ord u0}}) (u3 :: u0 -> [u0]) (u4 :: u0 -> u0 -> [u0]) (u5 :: u0 -> u0 -> [u0]) (u6 :: u0 -> u0 -> u0 -> [u0]) -> u3; _NO_DEFLT_ } _N_
- {-defm-} _A_ 2 _U_ 02 _N_ _S_ _!_ _F_ _IF_ARGS_ 1 2 XX 3 _/\_ u0 -> \ (u1 :: {{Enum u0}}) (u2 :: u0) -> _APP_ _TYAPP_ patError# { (u0 -> [u0]) } [ _NOREP_S_ "%DPreludeCore.Enum.enumFrom\"", u2 ] _N_ #-}
+ {-defm-} _A_ 2 _U_ 02 _N_ _S_ _!_ _N_ _N_ #-}
enumFromThen :: a -> a -> [a]
{-# GHC_PRAGMA {-meth-} _A_ 1 _U_ 122 _N_ _S_ "S" _F_ _IF_ARGS_ 1 1 C 2 _/\_ u0 -> \ (u1 :: ({{Ord u0}}, u0 -> [u0], u0 -> u0 -> [u0], u0 -> u0 -> [u0], u0 -> u0 -> u0 -> [u0])) -> case u1 of { _ALG_ _TUP_5 (u2 :: {{Ord u0}}) (u3 :: u0 -> [u0]) (u4 :: u0 -> u0 -> [u0]) (u5 :: u0 -> u0 -> [u0]) (u6 :: u0 -> u0 -> u0 -> [u0]) -> u4; _NO_DEFLT_ } _N_
- {-defm-} _A_ 3 _U_ 022 _N_ _S_ _!_ _F_ _IF_ARGS_ 1 3 XXX 4 _/\_ u0 -> \ (u1 :: {{Enum u0}}) (u2 :: u0) (u3 :: u0) -> _APP_ _TYAPP_ patError# { (u0 -> u0 -> [u0]) } [ _NOREP_S_ "%DPreludeCore.Enum.enumFromThen\"", u2, u3 ] _N_ #-}
+ {-defm-} _A_ 3 _U_ 022 _N_ _S_ _!_ _N_ _N_ #-}
enumFromTo :: a -> a -> [a]
{-# GHC_PRAGMA {-meth-} _A_ 1 _U_ 122 _N_ _S_ "S" _F_ _IF_ARGS_ 1 1 C 2 _/\_ u0 -> \ (u1 :: ({{Ord u0}}, u0 -> [u0], u0 -> u0 -> [u0], u0 -> u0 -> [u0], u0 -> u0 -> u0 -> [u0])) -> case u1 of { _ALG_ _TUP_5 (u2 :: {{Ord u0}}) (u3 :: u0 -> [u0]) (u4 :: u0 -> u0 -> [u0]) (u5 :: u0 -> u0 -> [u0]) (u6 :: u0 -> u0 -> u0 -> [u0]) -> u5; _NO_DEFLT_ } _N_
{-defm-} _A_ 3 _U_ 122 _N_ _S_ "SLL" _N_ _N_ #-}
class Eq a where
(==) :: a -> a -> Bool
{-# GHC_PRAGMA {-meth-} _A_ 1 _U_ 122 _N_ _S_ "S" _F_ _IF_ARGS_ 1 1 C 2 _/\_ u0 -> \ (u1 :: (u0 -> u0 -> Bool, u0 -> u0 -> Bool)) -> case u1 of { _ALG_ _TUP_2 (u2 :: u0 -> u0 -> Bool) (u3 :: u0 -> u0 -> Bool) -> u2; _NO_DEFLT_ } _N_
- {-defm-} _A_ 3 _U_ 022 _N_ _S_ _!_ _F_ _IF_ARGS_ 1 3 XXX 4 _/\_ u0 -> \ (u1 :: {{Eq u0}}) (u2 :: u0) (u3 :: u0) -> _APP_ _TYAPP_ patError# { (u0 -> u0 -> Bool) } [ _NOREP_S_ "%DPreludeCore.Eq.(==)\"", u2, u3 ] _N_ #-}
+ {-defm-} _A_ 3 _U_ 022 _N_ _S_ _!_ _N_ _N_ #-}
(/=) :: a -> a -> Bool
{-# GHC_PRAGMA {-meth-} _A_ 1 _U_ 122 _N_ _S_ "S" _F_ _IF_ARGS_ 1 1 C 2 _/\_ u0 -> \ (u1 :: (u0 -> u0 -> Bool, u0 -> u0 -> Bool)) -> case u1 of { _ALG_ _TUP_2 (u2 :: u0 -> u0 -> Bool) (u3 :: u0 -> u0 -> Bool) -> u3; _NO_DEFLT_ } _N_
{-defm-} _A_ 3 _U_ 122 _N_ _S_ "SLL" _N_ _N_ #-}
class (Fractional a) => Floating a {-# GHC_PRAGMA {-superdicts-} _A_ 1 _U_ 1 _N_ _S_ "S" _F_ _IF_ARGS_ 1 1 C 2 _/\_ u0 -> \ (u1 :: ({{Fractional u0}}, u0, u0 -> u0, u0 -> u0, u0 -> u0, u0 -> u0 -> u0, u0 -> u0 -> u0, u0 -> u0, u0 -> u0, u0 -> u0, u0 -> u0, u0 -> u0, u0 -> u0, u0 -> u0, u0 -> u0, u0 -> u0, u0 -> u0, u0 -> u0, u0 -> u0)) -> case u1 of { _ALG_ _TUP_19 (u2 :: {{Fractional u0}}) (u3 :: u0) (u4 :: u0 -> u0) (u5 :: u0 -> u0) (u6 :: u0 -> u0) (u7 :: u0 -> u0 -> u0) (u8 :: u0 -> u0 -> u0) (u9 :: u0 -> u0) (ua :: u0 -> u0) (ub :: u0 -> u0) (uc :: u0 -> u0) (ud :: u0 -> u0) (ue :: u0 -> u0) (uf :: u0 -> u0) (ug :: u0 -> u0) (uh :: u0 -> u0) (ui :: u0 -> u0) (uj :: u0 -> u0) (uk :: u0 -> u0) -> u2; _NO_DEFLT_ } _N_ #-} where
pi :: a
{-# GHC_PRAGMA {-meth-} _A_ 1 _U_ 1 _N_ _S_ "S" _F_ _IF_ARGS_ 1 1 C 2 _/\_ u0 -> \ (u1 :: ({{Fractional u0}}, u0, u0 -> u0, u0 -> u0, u0 -> u0, u0 -> u0 -> u0, u0 -> u0 -> u0, u0 -> u0, u0 -> u0, u0 -> u0, u0 -> u0, u0 -> u0, u0 -> u0, u0 -> u0, u0 -> u0, u0 -> u0, u0 -> u0, u0 -> u0, u0 -> u0)) -> case u1 of { _ALG_ _TUP_19 (u2 :: {{Fractional u0}}) (u3 :: u0) (u4 :: u0 -> u0) (u5 :: u0 -> u0) (u6 :: u0 -> u0) (u7 :: u0 -> u0 -> u0) (u8 :: u0 -> u0 -> u0) (u9 :: u0 -> u0) (ua :: u0 -> u0) (ub :: u0 -> u0) (uc :: u0 -> u0) (ud :: u0 -> u0) (ue :: u0 -> u0) (uf :: u0 -> u0) (ug :: u0 -> u0) (uh :: u0 -> u0) (ui :: u0 -> u0) (uj :: u0 -> u0) (uk :: u0 -> u0) -> u3; _NO_DEFLT_ } _N_
- {-defm-} _A_ 1 _U_ 0 _N_ _S_ _!_ _F_ _IF_ARGS_ 1 1 X 2 _/\_ u0 -> \ (u1 :: {{Floating u0}}) -> _APP_ _TYAPP_ patError# { u0 } [ _NOREP_S_ "%DPreludeCore.Floating.pi\"" ] _N_ #-}
+ {-defm-} _A_ 1 _U_ 0 _N_ _S_ _!_ _N_ _N_ #-}
exp :: a -> a
{-# GHC_PRAGMA {-meth-} _A_ 1 _U_ 12 _N_ _S_ "S" _F_ _IF_ARGS_ 1 1 C 2 _/\_ u0 -> \ (u1 :: ({{Fractional u0}}, u0, u0 -> u0, u0 -> u0, u0 -> u0, u0 -> u0 -> u0, u0 -> u0 -> u0, u0 -> u0, u0 -> u0, u0 -> u0, u0 -> u0, u0 -> u0, u0 -> u0, u0 -> u0, u0 -> u0, u0 -> u0, u0 -> u0, u0 -> u0, u0 -> u0)) -> case u1 of { _ALG_ _TUP_19 (u2 :: {{Fractional u0}}) (u3 :: u0) (u4 :: u0 -> u0) (u5 :: u0 -> u0) (u6 :: u0 -> u0) (u7 :: u0 -> u0 -> u0) (u8 :: u0 -> u0 -> u0) (u9 :: u0 -> u0) (ua :: u0 -> u0) (ub :: u0 -> u0) (uc :: u0 -> u0) (ud :: u0 -> u0) (ue :: u0 -> u0) (uf :: u0 -> u0) (ug :: u0 -> u0) (uh :: u0 -> u0) (ui :: u0 -> u0) (uj :: u0 -> u0) (uk :: u0 -> u0) -> u4; _NO_DEFLT_ } _N_
- {-defm-} _A_ 2 _U_ 02 _N_ _S_ _!_ _F_ _IF_ARGS_ 1 2 XX 3 _/\_ u0 -> \ (u1 :: {{Floating u0}}) (u2 :: u0) -> _APP_ _TYAPP_ patError# { (u0 -> u0) } [ _NOREP_S_ "%DPreludeCore.Floating.exp\"", u2 ] _N_ #-}
+ {-defm-} _A_ 2 _U_ 02 _N_ _S_ _!_ _N_ _N_ #-}
log :: a -> a
{-# GHC_PRAGMA {-meth-} _A_ 1 _U_ 12 _N_ _S_ "S" _F_ _IF_ARGS_ 1 1 C 2 _/\_ u0 -> \ (u1 :: ({{Fractional u0}}, u0, u0 -> u0, u0 -> u0, u0 -> u0, u0 -> u0 -> u0, u0 -> u0 -> u0, u0 -> u0, u0 -> u0, u0 -> u0, u0 -> u0, u0 -> u0, u0 -> u0, u0 -> u0, u0 -> u0, u0 -> u0, u0 -> u0, u0 -> u0, u0 -> u0)) -> case u1 of { _ALG_ _TUP_19 (u2 :: {{Fractional u0}}) (u3 :: u0) (u4 :: u0 -> u0) (u5 :: u0 -> u0) (u6 :: u0 -> u0) (u7 :: u0 -> u0 -> u0) (u8 :: u0 -> u0 -> u0) (u9 :: u0 -> u0) (ua :: u0 -> u0) (ub :: u0 -> u0) (uc :: u0 -> u0) (ud :: u0 -> u0) (ue :: u0 -> u0) (uf :: u0 -> u0) (ug :: u0 -> u0) (uh :: u0 -> u0) (ui :: u0 -> u0) (uj :: u0 -> u0) (uk :: u0 -> u0) -> u5; _NO_DEFLT_ } _N_
- {-defm-} _A_ 2 _U_ 02 _N_ _S_ _!_ _F_ _IF_ARGS_ 1 2 XX 3 _/\_ u0 -> \ (u1 :: {{Floating u0}}) (u2 :: u0) -> _APP_ _TYAPP_ patError# { (u0 -> u0) } [ _NOREP_S_ "%DPreludeCore.Floating.log\"", u2 ] _N_ #-}
+ {-defm-} _A_ 2 _U_ 02 _N_ _S_ _!_ _N_ _N_ #-}
sqrt :: a -> a
{-# GHC_PRAGMA {-meth-} _A_ 1 _U_ 12 _N_ _S_ "S" _F_ _IF_ARGS_ 1 1 C 2 _/\_ u0 -> \ (u1 :: ({{Fractional u0}}, u0, u0 -> u0, u0 -> u0, u0 -> u0, u0 -> u0 -> u0, u0 -> u0 -> u0, u0 -> u0, u0 -> u0, u0 -> u0, u0 -> u0, u0 -> u0, u0 -> u0, u0 -> u0, u0 -> u0, u0 -> u0, u0 -> u0, u0 -> u0, u0 -> u0)) -> case u1 of { _ALG_ _TUP_19 (u2 :: {{Fractional u0}}) (u3 :: u0) (u4 :: u0 -> u0) (u5 :: u0 -> u0) (u6 :: u0 -> u0) (u7 :: u0 -> u0 -> u0) (u8 :: u0 -> u0 -> u0) (u9 :: u0 -> u0) (ua :: u0 -> u0) (ub :: u0 -> u0) (uc :: u0 -> u0) (ud :: u0 -> u0) (ue :: u0 -> u0) (uf :: u0 -> u0) (ug :: u0 -> u0) (uh :: u0 -> u0) (ui :: u0 -> u0) (uj :: u0 -> u0) (uk :: u0 -> u0) -> u6; _NO_DEFLT_ } _N_
{-defm-} _A_ 1 _U_ 12 _N_ _S_ "S" _N_ _N_ #-}
{-defm-} _A_ 3 _U_ 122 _N_ _S_ "SLL" _N_ _N_ #-}
sin :: a -> a
{-# GHC_PRAGMA {-meth-} _A_ 1 _U_ 12 _N_ _S_ "S" _F_ _IF_ARGS_ 1 1 C 2 _/\_ u0 -> \ (u1 :: ({{Fractional u0}}, u0, u0 -> u0, u0 -> u0, u0 -> u0, u0 -> u0 -> u0, u0 -> u0 -> u0, u0 -> u0, u0 -> u0, u0 -> u0, u0 -> u0, u0 -> u0, u0 -> u0, u0 -> u0, u0 -> u0, u0 -> u0, u0 -> u0, u0 -> u0, u0 -> u0)) -> case u1 of { _ALG_ _TUP_19 (u2 :: {{Fractional u0}}) (u3 :: u0) (u4 :: u0 -> u0) (u5 :: u0 -> u0) (u6 :: u0 -> u0) (u7 :: u0 -> u0 -> u0) (u8 :: u0 -> u0 -> u0) (u9 :: u0 -> u0) (ua :: u0 -> u0) (ub :: u0 -> u0) (uc :: u0 -> u0) (ud :: u0 -> u0) (ue :: u0 -> u0) (uf :: u0 -> u0) (ug :: u0 -> u0) (uh :: u0 -> u0) (ui :: u0 -> u0) (uj :: u0 -> u0) (uk :: u0 -> u0) -> u9; _NO_DEFLT_ } _N_
- {-defm-} _A_ 2 _U_ 02 _N_ _S_ _!_ _F_ _IF_ARGS_ 1 2 XX 3 _/\_ u0 -> \ (u1 :: {{Floating u0}}) (u2 :: u0) -> _APP_ _TYAPP_ patError# { (u0 -> u0) } [ _NOREP_S_ "%DPreludeCore.Floating.sin\"", u2 ] _N_ #-}
+ {-defm-} _A_ 2 _U_ 02 _N_ _S_ _!_ _N_ _N_ #-}
cos :: a -> a
{-# GHC_PRAGMA {-meth-} _A_ 1 _U_ 12 _N_ _S_ "S" _F_ _IF_ARGS_ 1 1 C 2 _/\_ u0 -> \ (u1 :: ({{Fractional u0}}, u0, u0 -> u0, u0 -> u0, u0 -> u0, u0 -> u0 -> u0, u0 -> u0 -> u0, u0 -> u0, u0 -> u0, u0 -> u0, u0 -> u0, u0 -> u0, u0 -> u0, u0 -> u0, u0 -> u0, u0 -> u0, u0 -> u0, u0 -> u0, u0 -> u0)) -> case u1 of { _ALG_ _TUP_19 (u2 :: {{Fractional u0}}) (u3 :: u0) (u4 :: u0 -> u0) (u5 :: u0 -> u0) (u6 :: u0 -> u0) (u7 :: u0 -> u0 -> u0) (u8 :: u0 -> u0 -> u0) (u9 :: u0 -> u0) (ua :: u0 -> u0) (ub :: u0 -> u0) (uc :: u0 -> u0) (ud :: u0 -> u0) (ue :: u0 -> u0) (uf :: u0 -> u0) (ug :: u0 -> u0) (uh :: u0 -> u0) (ui :: u0 -> u0) (uj :: u0 -> u0) (uk :: u0 -> u0) -> ua; _NO_DEFLT_ } _N_
- {-defm-} _A_ 2 _U_ 02 _N_ _S_ _!_ _F_ _IF_ARGS_ 1 2 XX 3 _/\_ u0 -> \ (u1 :: {{Floating u0}}) (u2 :: u0) -> _APP_ _TYAPP_ patError# { (u0 -> u0) } [ _NOREP_S_ "%DPreludeCore.Floating.cos\"", u2 ] _N_ #-}
+ {-defm-} _A_ 2 _U_ 02 _N_ _S_ _!_ _N_ _N_ #-}
tan :: a -> a
{-# GHC_PRAGMA {-meth-} _A_ 1 _U_ 12 _N_ _S_ "S" _F_ _IF_ARGS_ 1 1 C 2 _/\_ u0 -> \ (u1 :: ({{Fractional u0}}, u0, u0 -> u0, u0 -> u0, u0 -> u0, u0 -> u0 -> u0, u0 -> u0 -> u0, u0 -> u0, u0 -> u0, u0 -> u0, u0 -> u0, u0 -> u0, u0 -> u0, u0 -> u0, u0 -> u0, u0 -> u0, u0 -> u0, u0 -> u0, u0 -> u0)) -> case u1 of { _ALG_ _TUP_19 (u2 :: {{Fractional u0}}) (u3 :: u0) (u4 :: u0 -> u0) (u5 :: u0 -> u0) (u6 :: u0 -> u0) (u7 :: u0 -> u0 -> u0) (u8 :: u0 -> u0 -> u0) (u9 :: u0 -> u0) (ua :: u0 -> u0) (ub :: u0 -> u0) (uc :: u0 -> u0) (ud :: u0 -> u0) (ue :: u0 -> u0) (uf :: u0 -> u0) (ug :: u0 -> u0) (uh :: u0 -> u0) (ui :: u0 -> u0) (uj :: u0 -> u0) (uk :: u0 -> u0) -> ub; _NO_DEFLT_ } _N_
{-defm-} _A_ 2 _U_ 12 _N_ _S_ "SL" _N_ _N_ #-}
asin :: a -> a
{-# GHC_PRAGMA {-meth-} _A_ 1 _U_ 12 _N_ _S_ "S" _F_ _IF_ARGS_ 1 1 C 2 _/\_ u0 -> \ (u1 :: ({{Fractional u0}}, u0, u0 -> u0, u0 -> u0, u0 -> u0, u0 -> u0 -> u0, u0 -> u0 -> u0, u0 -> u0, u0 -> u0, u0 -> u0, u0 -> u0, u0 -> u0, u0 -> u0, u0 -> u0, u0 -> u0, u0 -> u0, u0 -> u0, u0 -> u0, u0 -> u0)) -> case u1 of { _ALG_ _TUP_19 (u2 :: {{Fractional u0}}) (u3 :: u0) (u4 :: u0 -> u0) (u5 :: u0 -> u0) (u6 :: u0 -> u0) (u7 :: u0 -> u0 -> u0) (u8 :: u0 -> u0 -> u0) (u9 :: u0 -> u0) (ua :: u0 -> u0) (ub :: u0 -> u0) (uc :: u0 -> u0) (ud :: u0 -> u0) (ue :: u0 -> u0) (uf :: u0 -> u0) (ug :: u0 -> u0) (uh :: u0 -> u0) (ui :: u0 -> u0) (uj :: u0 -> u0) (uk :: u0 -> u0) -> uc; _NO_DEFLT_ } _N_
- {-defm-} _A_ 2 _U_ 02 _N_ _S_ _!_ _F_ _IF_ARGS_ 1 2 XX 3 _/\_ u0 -> \ (u1 :: {{Floating u0}}) (u2 :: u0) -> _APP_ _TYAPP_ patError# { (u0 -> u0) } [ _NOREP_S_ "%DPreludeCore.Floating.asin\"", u2 ] _N_ #-}
+ {-defm-} _A_ 2 _U_ 02 _N_ _S_ _!_ _N_ _N_ #-}
acos :: a -> a
{-# GHC_PRAGMA {-meth-} _A_ 1 _U_ 12 _N_ _S_ "S" _F_ _IF_ARGS_ 1 1 C 2 _/\_ u0 -> \ (u1 :: ({{Fractional u0}}, u0, u0 -> u0, u0 -> u0, u0 -> u0, u0 -> u0 -> u0, u0 -> u0 -> u0, u0 -> u0, u0 -> u0, u0 -> u0, u0 -> u0, u0 -> u0, u0 -> u0, u0 -> u0, u0 -> u0, u0 -> u0, u0 -> u0, u0 -> u0, u0 -> u0)) -> case u1 of { _ALG_ _TUP_19 (u2 :: {{Fractional u0}}) (u3 :: u0) (u4 :: u0 -> u0) (u5 :: u0 -> u0) (u6 :: u0 -> u0) (u7 :: u0 -> u0 -> u0) (u8 :: u0 -> u0 -> u0) (u9 :: u0 -> u0) (ua :: u0 -> u0) (ub :: u0 -> u0) (uc :: u0 -> u0) (ud :: u0 -> u0) (ue :: u0 -> u0) (uf :: u0 -> u0) (ug :: u0 -> u0) (uh :: u0 -> u0) (ui :: u0 -> u0) (uj :: u0 -> u0) (uk :: u0 -> u0) -> ud; _NO_DEFLT_ } _N_
- {-defm-} _A_ 2 _U_ 02 _N_ _S_ _!_ _F_ _IF_ARGS_ 1 2 XX 3 _/\_ u0 -> \ (u1 :: {{Floating u0}}) (u2 :: u0) -> _APP_ _TYAPP_ patError# { (u0 -> u0) } [ _NOREP_S_ "%DPreludeCore.Floating.acos\"", u2 ] _N_ #-}
+ {-defm-} _A_ 2 _U_ 02 _N_ _S_ _!_ _N_ _N_ #-}
atan :: a -> a
{-# GHC_PRAGMA {-meth-} _A_ 1 _U_ 12 _N_ _S_ "S" _F_ _IF_ARGS_ 1 1 C 2 _/\_ u0 -> \ (u1 :: ({{Fractional u0}}, u0, u0 -> u0, u0 -> u0, u0 -> u0, u0 -> u0 -> u0, u0 -> u0 -> u0, u0 -> u0, u0 -> u0, u0 -> u0, u0 -> u0, u0 -> u0, u0 -> u0, u0 -> u0, u0 -> u0, u0 -> u0, u0 -> u0, u0 -> u0, u0 -> u0)) -> case u1 of { _ALG_ _TUP_19 (u2 :: {{Fractional u0}}) (u3 :: u0) (u4 :: u0 -> u0) (u5 :: u0 -> u0) (u6 :: u0 -> u0) (u7 :: u0 -> u0 -> u0) (u8 :: u0 -> u0 -> u0) (u9 :: u0 -> u0) (ua :: u0 -> u0) (ub :: u0 -> u0) (uc :: u0 -> u0) (ud :: u0 -> u0) (ue :: u0 -> u0) (uf :: u0 -> u0) (ug :: u0 -> u0) (uh :: u0 -> u0) (ui :: u0 -> u0) (uj :: u0 -> u0) (uk :: u0 -> u0) -> ue; _NO_DEFLT_ } _N_
- {-defm-} _A_ 2 _U_ 02 _N_ _S_ _!_ _F_ _IF_ARGS_ 1 2 XX 3 _/\_ u0 -> \ (u1 :: {{Floating u0}}) (u2 :: u0) -> _APP_ _TYAPP_ patError# { (u0 -> u0) } [ _NOREP_S_ "%DPreludeCore.Floating.atan\"", u2 ] _N_ #-}
+ {-defm-} _A_ 2 _U_ 02 _N_ _S_ _!_ _N_ _N_ #-}
sinh :: a -> a
{-# GHC_PRAGMA {-meth-} _A_ 1 _U_ 12 _N_ _S_ "S" _F_ _IF_ARGS_ 1 1 C 2 _/\_ u0 -> \ (u1 :: ({{Fractional u0}}, u0, u0 -> u0, u0 -> u0, u0 -> u0, u0 -> u0 -> u0, u0 -> u0 -> u0, u0 -> u0, u0 -> u0, u0 -> u0, u0 -> u0, u0 -> u0, u0 -> u0, u0 -> u0, u0 -> u0, u0 -> u0, u0 -> u0, u0 -> u0, u0 -> u0)) -> case u1 of { _ALG_ _TUP_19 (u2 :: {{Fractional u0}}) (u3 :: u0) (u4 :: u0 -> u0) (u5 :: u0 -> u0) (u6 :: u0 -> u0) (u7 :: u0 -> u0 -> u0) (u8 :: u0 -> u0 -> u0) (u9 :: u0 -> u0) (ua :: u0 -> u0) (ub :: u0 -> u0) (uc :: u0 -> u0) (ud :: u0 -> u0) (ue :: u0 -> u0) (uf :: u0 -> u0) (ug :: u0 -> u0) (uh :: u0 -> u0) (ui :: u0 -> u0) (uj :: u0 -> u0) (uk :: u0 -> u0) -> uf; _NO_DEFLT_ } _N_
- {-defm-} _A_ 2 _U_ 02 _N_ _S_ _!_ _F_ _IF_ARGS_ 1 2 XX 3 _/\_ u0 -> \ (u1 :: {{Floating u0}}) (u2 :: u0) -> _APP_ _TYAPP_ patError# { (u0 -> u0) } [ _NOREP_S_ "%DPreludeCore.Floating.sinh\"", u2 ] _N_ #-}
+ {-defm-} _A_ 2 _U_ 02 _N_ _S_ _!_ _N_ _N_ #-}
cosh :: a -> a
{-# GHC_PRAGMA {-meth-} _A_ 1 _U_ 12 _N_ _S_ "S" _F_ _IF_ARGS_ 1 1 C 2 _/\_ u0 -> \ (u1 :: ({{Fractional u0}}, u0, u0 -> u0, u0 -> u0, u0 -> u0, u0 -> u0 -> u0, u0 -> u0 -> u0, u0 -> u0, u0 -> u0, u0 -> u0, u0 -> u0, u0 -> u0, u0 -> u0, u0 -> u0, u0 -> u0, u0 -> u0, u0 -> u0, u0 -> u0, u0 -> u0)) -> case u1 of { _ALG_ _TUP_19 (u2 :: {{Fractional u0}}) (u3 :: u0) (u4 :: u0 -> u0) (u5 :: u0 -> u0) (u6 :: u0 -> u0) (u7 :: u0 -> u0 -> u0) (u8 :: u0 -> u0 -> u0) (u9 :: u0 -> u0) (ua :: u0 -> u0) (ub :: u0 -> u0) (uc :: u0 -> u0) (ud :: u0 -> u0) (ue :: u0 -> u0) (uf :: u0 -> u0) (ug :: u0 -> u0) (uh :: u0 -> u0) (ui :: u0 -> u0) (uj :: u0 -> u0) (uk :: u0 -> u0) -> ug; _NO_DEFLT_ } _N_
- {-defm-} _A_ 2 _U_ 02 _N_ _S_ _!_ _F_ _IF_ARGS_ 1 2 XX 3 _/\_ u0 -> \ (u1 :: {{Floating u0}}) (u2 :: u0) -> _APP_ _TYAPP_ patError# { (u0 -> u0) } [ _NOREP_S_ "%DPreludeCore.Floating.cosh\"", u2 ] _N_ #-}
+ {-defm-} _A_ 2 _U_ 02 _N_ _S_ _!_ _N_ _N_ #-}
tanh :: a -> a
{-# GHC_PRAGMA {-meth-} _A_ 1 _U_ 12 _N_ _S_ "S" _F_ _IF_ARGS_ 1 1 C 2 _/\_ u0 -> \ (u1 :: ({{Fractional u0}}, u0, u0 -> u0, u0 -> u0, u0 -> u0, u0 -> u0 -> u0, u0 -> u0 -> u0, u0 -> u0, u0 -> u0, u0 -> u0, u0 -> u0, u0 -> u0, u0 -> u0, u0 -> u0, u0 -> u0, u0 -> u0, u0 -> u0, u0 -> u0, u0 -> u0)) -> case u1 of { _ALG_ _TUP_19 (u2 :: {{Fractional u0}}) (u3 :: u0) (u4 :: u0 -> u0) (u5 :: u0 -> u0) (u6 :: u0 -> u0) (u7 :: u0 -> u0 -> u0) (u8 :: u0 -> u0 -> u0) (u9 :: u0 -> u0) (ua :: u0 -> u0) (ub :: u0 -> u0) (uc :: u0 -> u0) (ud :: u0 -> u0) (ue :: u0 -> u0) (uf :: u0 -> u0) (ug :: u0 -> u0) (uh :: u0 -> u0) (ui :: u0 -> u0) (uj :: u0 -> u0) (uk :: u0 -> u0) -> uh; _NO_DEFLT_ } _N_
{-defm-} _A_ 2 _U_ 12 _N_ _S_ "SL" _N_ _N_ #-}
asinh :: a -> a
{-# GHC_PRAGMA {-meth-} _A_ 1 _U_ 12 _N_ _S_ "S" _F_ _IF_ARGS_ 1 1 C 2 _/\_ u0 -> \ (u1 :: ({{Fractional u0}}, u0, u0 -> u0, u0 -> u0, u0 -> u0, u0 -> u0 -> u0, u0 -> u0 -> u0, u0 -> u0, u0 -> u0, u0 -> u0, u0 -> u0, u0 -> u0, u0 -> u0, u0 -> u0, u0 -> u0, u0 -> u0, u0 -> u0, u0 -> u0, u0 -> u0)) -> case u1 of { _ALG_ _TUP_19 (u2 :: {{Fractional u0}}) (u3 :: u0) (u4 :: u0 -> u0) (u5 :: u0 -> u0) (u6 :: u0 -> u0) (u7 :: u0 -> u0 -> u0) (u8 :: u0 -> u0 -> u0) (u9 :: u0 -> u0) (ua :: u0 -> u0) (ub :: u0 -> u0) (uc :: u0 -> u0) (ud :: u0 -> u0) (ue :: u0 -> u0) (uf :: u0 -> u0) (ug :: u0 -> u0) (uh :: u0 -> u0) (ui :: u0 -> u0) (uj :: u0 -> u0) (uk :: u0 -> u0) -> ui; _NO_DEFLT_ } _N_
- {-defm-} _A_ 2 _U_ 02 _N_ _S_ _!_ _F_ _IF_ARGS_ 1 2 XX 3 _/\_ u0 -> \ (u1 :: {{Floating u0}}) (u2 :: u0) -> _APP_ _TYAPP_ patError# { (u0 -> u0) } [ _NOREP_S_ "%DPreludeCore.Floating.asinh\"", u2 ] _N_ #-}
+ {-defm-} _A_ 2 _U_ 02 _N_ _S_ _!_ _N_ _N_ #-}
acosh :: a -> a
{-# GHC_PRAGMA {-meth-} _A_ 1 _U_ 12 _N_ _S_ "S" _F_ _IF_ARGS_ 1 1 C 2 _/\_ u0 -> \ (u1 :: ({{Fractional u0}}, u0, u0 -> u0, u0 -> u0, u0 -> u0, u0 -> u0 -> u0, u0 -> u0 -> u0, u0 -> u0, u0 -> u0, u0 -> u0, u0 -> u0, u0 -> u0, u0 -> u0, u0 -> u0, u0 -> u0, u0 -> u0, u0 -> u0, u0 -> u0, u0 -> u0)) -> case u1 of { _ALG_ _TUP_19 (u2 :: {{Fractional u0}}) (u3 :: u0) (u4 :: u0 -> u0) (u5 :: u0 -> u0) (u6 :: u0 -> u0) (u7 :: u0 -> u0 -> u0) (u8 :: u0 -> u0 -> u0) (u9 :: u0 -> u0) (ua :: u0 -> u0) (ub :: u0 -> u0) (uc :: u0 -> u0) (ud :: u0 -> u0) (ue :: u0 -> u0) (uf :: u0 -> u0) (ug :: u0 -> u0) (uh :: u0 -> u0) (ui :: u0 -> u0) (uj :: u0 -> u0) (uk :: u0 -> u0) -> uj; _NO_DEFLT_ } _N_
- {-defm-} _A_ 2 _U_ 02 _N_ _S_ _!_ _F_ _IF_ARGS_ 1 2 XX 3 _/\_ u0 -> \ (u1 :: {{Floating u0}}) (u2 :: u0) -> _APP_ _TYAPP_ patError# { (u0 -> u0) } [ _NOREP_S_ "%DPreludeCore.Floating.acosh\"", u2 ] _N_ #-}
+ {-defm-} _A_ 2 _U_ 02 _N_ _S_ _!_ _N_ _N_ #-}
atanh :: a -> a
{-# GHC_PRAGMA {-meth-} _A_ 1 _U_ 12 _N_ _S_ "S" _F_ _IF_ARGS_ 1 1 C 2 _/\_ u0 -> \ (u1 :: ({{Fractional u0}}, u0, u0 -> u0, u0 -> u0, u0 -> u0, u0 -> u0 -> u0, u0 -> u0 -> u0, u0 -> u0, u0 -> u0, u0 -> u0, u0 -> u0, u0 -> u0, u0 -> u0, u0 -> u0, u0 -> u0, u0 -> u0, u0 -> u0, u0 -> u0, u0 -> u0)) -> case u1 of { _ALG_ _TUP_19 (u2 :: {{Fractional u0}}) (u3 :: u0) (u4 :: u0 -> u0) (u5 :: u0 -> u0) (u6 :: u0 -> u0) (u7 :: u0 -> u0 -> u0) (u8 :: u0 -> u0 -> u0) (u9 :: u0 -> u0) (ua :: u0 -> u0) (ub :: u0 -> u0) (uc :: u0 -> u0) (ud :: u0 -> u0) (ue :: u0 -> u0) (uf :: u0 -> u0) (ug :: u0 -> u0) (uh :: u0 -> u0) (ui :: u0 -> u0) (uj :: u0 -> u0) (uk :: u0 -> u0) -> uk; _NO_DEFLT_ } _N_
- {-defm-} _A_ 2 _U_ 02 _N_ _S_ _!_ _F_ _IF_ARGS_ 1 2 XX 3 _/\_ u0 -> \ (u1 :: {{Floating u0}}) (u2 :: u0) -> _APP_ _TYAPP_ patError# { (u0 -> u0) } [ _NOREP_S_ "%DPreludeCore.Floating.atanh\"", u2 ] _N_ #-}
+ {-defm-} _A_ 2 _U_ 02 _N_ _S_ _!_ _N_ _N_ #-}
class (Num a) => Fractional a {-# GHC_PRAGMA {-superdicts-} _A_ 1 _U_ 1 _N_ _S_ "S" _F_ _IF_ARGS_ 1 1 C 2 _/\_ u0 -> \ (u1 :: ({{Num u0}}, u0 -> u0 -> u0, u0 -> u0, Ratio Integer -> u0)) -> case u1 of { _ALG_ _TUP_4 (u2 :: {{Num u0}}) (u3 :: u0 -> u0 -> u0) (u4 :: u0 -> u0) (u5 :: Ratio Integer -> u0) -> u2; _NO_DEFLT_ } _N_ #-} where
(/) :: a -> a -> a
{-# GHC_PRAGMA {-meth-} _A_ 1 _U_ 122 _N_ _S_ "S" _F_ _IF_ARGS_ 1 1 C 2 _/\_ u0 -> \ (u1 :: ({{Num u0}}, u0 -> u0 -> u0, u0 -> u0, Ratio Integer -> u0)) -> case u1 of { _ALG_ _TUP_4 (u2 :: {{Num u0}}) (u3 :: u0 -> u0 -> u0) (u4 :: u0 -> u0) (u5 :: Ratio Integer -> u0) -> u3; _NO_DEFLT_ } _N_
- {-defm-} _A_ 3 _U_ 022 _N_ _S_ _!_ _F_ _IF_ARGS_ 1 3 XXX 4 _/\_ u0 -> \ (u1 :: {{Fractional u0}}) (u2 :: u0) (u3 :: u0) -> _APP_ _TYAPP_ patError# { (u0 -> u0 -> u0) } [ _NOREP_S_ "%DPreludeCore.Fractional.(/)\"", u2, u3 ] _N_ #-}
+ {-defm-} _A_ 3 _U_ 022 _N_ _S_ _!_ _N_ _N_ #-}
recip :: a -> a
{-# GHC_PRAGMA {-meth-} _A_ 1 _U_ 12 _N_ _S_ "S" _F_ _IF_ARGS_ 1 1 C 2 _/\_ u0 -> \ (u1 :: ({{Num u0}}, u0 -> u0 -> u0, u0 -> u0, Ratio Integer -> u0)) -> case u1 of { _ALG_ _TUP_4 (u2 :: {{Num u0}}) (u3 :: u0 -> u0 -> u0) (u4 :: u0 -> u0) (u5 :: Ratio Integer -> u0) -> u4; _NO_DEFLT_ } _N_
{-defm-} _A_ 1 _U_ 12 _N_ _S_ "S" _N_ _N_ #-}
fromRational :: Ratio Integer -> a
{-# GHC_PRAGMA {-meth-} _A_ 1 _U_ 12 _N_ _S_ "S" _F_ _IF_ARGS_ 1 1 C 2 _/\_ u0 -> \ (u1 :: ({{Num u0}}, u0 -> u0 -> u0, u0 -> u0, Ratio Integer -> u0)) -> case u1 of { _ALG_ _TUP_4 (u2 :: {{Num u0}}) (u3 :: u0 -> u0 -> u0) (u4 :: u0 -> u0) (u5 :: Ratio Integer -> u0) -> u5; _NO_DEFLT_ } _N_
- {-defm-} _A_ 2 _U_ 02 _N_ _S_ _!_ _F_ _IF_ARGS_ 1 2 XX 3 _/\_ u0 -> \ (u1 :: {{Fractional u0}}) (u2 :: Ratio Integer) -> _APP_ _TYAPP_ patError# { (Ratio Integer -> u0) } [ _NOREP_S_ "%DPreludeCore.Fractional.fromRational\"", u2 ] _N_ #-}
+ {-defm-} _A_ 2 _U_ 02 _N_ _S_ _!_ _N_ _N_ #-}
class (Real a, Ix a) => Integral a {-# GHC_PRAGMA {-superdicts-} _A_ 1 _U_ 1 _N_ _S_ "S" _F_ _IF_ARGS_ 1 1 C 2 _/\_ u0 -> \ (u1 :: ({{Real u0}}, {{Ix u0}}, u0 -> u0 -> u0, u0 -> u0 -> u0, u0 -> u0 -> u0, u0 -> u0 -> u0, u0 -> u0 -> (u0, u0), u0 -> u0 -> (u0, u0), u0 -> Bool, u0 -> Bool, u0 -> Integer, u0 -> Int)) -> case u1 of { _ALG_ _TUP_12 (u2 :: {{Real u0}}) (u3 :: {{Ix u0}}) (u4 :: u0 -> u0 -> u0) (u5 :: u0 -> u0 -> u0) (u6 :: u0 -> u0 -> u0) (u7 :: u0 -> u0 -> u0) (u8 :: u0 -> u0 -> (u0, u0)) (u9 :: u0 -> u0 -> (u0, u0)) (ua :: u0 -> Bool) (ub :: u0 -> Bool) (uc :: u0 -> Integer) (ud :: u0 -> Int) -> u2; _NO_DEFLT_ } _N_, _A_ 1 _U_ 1 _N_ _S_ "S" _F_ _IF_ARGS_ 1 1 C 2 _/\_ u0 -> \ (u1 :: ({{Real u0}}, {{Ix u0}}, u0 -> u0 -> u0, u0 -> u0 -> u0, u0 -> u0 -> u0, u0 -> u0 -> u0, u0 -> u0 -> (u0, u0), u0 -> u0 -> (u0, u0), u0 -> Bool, u0 -> Bool, u0 -> Integer, u0 -> Int)) -> case u1 of { _ALG_ _TUP_12 (u2 :: {{Real u0}}) (u3 :: {{Ix u0}}) (u4 :: u0 -> u0 -> u0) (u5 :: u0 -> u0 -> u0) (u6 :: u0 -> u0 -> u0) (u7 :: u0 -> u0 -> u0) (u8 :: u0 -> u0 -> (u0, u0)) (u9 :: u0 -> u0 -> (u0, u0)) (ua :: u0 -> Bool) (ub :: u0 -> Bool) (uc :: u0 -> Integer) (ud :: u0 -> Int) -> u3; _NO_DEFLT_ } _N_ #-} where
quot :: a -> a -> a
{-# GHC_PRAGMA {-meth-} _A_ 1 _U_ 122 _N_ _S_ "S" _F_ _IF_ARGS_ 1 1 C 2 _/\_ u0 -> \ (u1 :: ({{Real u0}}, {{Ix u0}}, u0 -> u0 -> u0, u0 -> u0 -> u0, u0 -> u0 -> u0, u0 -> u0 -> u0, u0 -> u0 -> (u0, u0), u0 -> u0 -> (u0, u0), u0 -> Bool, u0 -> Bool, u0 -> Integer, u0 -> Int)) -> case u1 of { _ALG_ _TUP_12 (u2 :: {{Real u0}}) (u3 :: {{Ix u0}}) (u4 :: u0 -> u0 -> u0) (u5 :: u0 -> u0 -> u0) (u6 :: u0 -> u0 -> u0) (u7 :: u0 -> u0 -> u0) (u8 :: u0 -> u0 -> (u0, u0)) (u9 :: u0 -> u0 -> (u0, u0)) (ua :: u0 -> Bool) (ub :: u0 -> Bool) (uc :: u0 -> Integer) (ud :: u0 -> Int) -> u4; _NO_DEFLT_ } _N_
{-defm-} _A_ 3 _U_ 122 _N_ _S_ "SLL" _F_ _IF_ARGS_ 1 3 CXX 6 _/\_ u0 -> \ (u1 :: {{Integral u0}}) (u2 :: u0) (u3 :: u0) -> case case u1 of { _ALG_ _TUP_12 (u4 :: {{Real u0}}) (u5 :: {{Ix u0}}) (u6 :: u0 -> u0 -> u0) (u7 :: u0 -> u0 -> u0) (u8 :: u0 -> u0 -> u0) (u9 :: u0 -> u0 -> u0) (ua :: u0 -> u0 -> (u0, u0)) (ub :: u0 -> u0 -> (u0, u0)) (uc :: u0 -> Bool) (ud :: u0 -> Bool) (ue :: u0 -> Integer) (uf :: u0 -> Int) -> _APP_ ub [ u2, u3 ]; _NO_DEFLT_ } of { _ALG_ _TUP_2 (ug :: u0) (uh :: u0) -> uh; _NO_DEFLT_ } _N_ #-}
quotRem :: a -> a -> (a, a)
{-# GHC_PRAGMA {-meth-} _A_ 1 _U_ 122 _N_ _S_ "S" _F_ _IF_ARGS_ 1 1 C 2 _/\_ u0 -> \ (u1 :: ({{Real u0}}, {{Ix u0}}, u0 -> u0 -> u0, u0 -> u0 -> u0, u0 -> u0 -> u0, u0 -> u0 -> u0, u0 -> u0 -> (u0, u0), u0 -> u0 -> (u0, u0), u0 -> Bool, u0 -> Bool, u0 -> Integer, u0 -> Int)) -> case u1 of { _ALG_ _TUP_12 (u2 :: {{Real u0}}) (u3 :: {{Ix u0}}) (u4 :: u0 -> u0 -> u0) (u5 :: u0 -> u0 -> u0) (u6 :: u0 -> u0 -> u0) (u7 :: u0 -> u0 -> u0) (u8 :: u0 -> u0 -> (u0, u0)) (u9 :: u0 -> u0 -> (u0, u0)) (ua :: u0 -> Bool) (ub :: u0 -> Bool) (uc :: u0 -> Integer) (ud :: u0 -> Int) -> u8; _NO_DEFLT_ } _N_
- {-defm-} _A_ 3 _U_ 022 _N_ _S_ _!_ _F_ _IF_ARGS_ 1 3 XXX 4 _/\_ u0 -> \ (u1 :: {{Integral u0}}) (u2 :: u0) (u3 :: u0) -> _APP_ _TYAPP_ patError# { (u0 -> u0 -> (u0, u0)) } [ _NOREP_S_ "%DPreludeCore.Integral.quotRem\"", u2, u3 ] _N_ #-}
+ {-defm-} _A_ 3 _U_ 022 _N_ _S_ _!_ _N_ _N_ #-}
divMod :: a -> a -> (a, a)
{-# GHC_PRAGMA {-meth-} _A_ 1 _U_ 122 _N_ _S_ "S" _F_ _IF_ARGS_ 1 1 C 2 _/\_ u0 -> \ (u1 :: ({{Real u0}}, {{Ix u0}}, u0 -> u0 -> u0, u0 -> u0 -> u0, u0 -> u0 -> u0, u0 -> u0 -> u0, u0 -> u0 -> (u0, u0), u0 -> u0 -> (u0, u0), u0 -> Bool, u0 -> Bool, u0 -> Integer, u0 -> Int)) -> case u1 of { _ALG_ _TUP_12 (u2 :: {{Real u0}}) (u3 :: {{Ix u0}}) (u4 :: u0 -> u0 -> u0) (u5 :: u0 -> u0 -> u0) (u6 :: u0 -> u0 -> u0) (u7 :: u0 -> u0 -> u0) (u8 :: u0 -> u0 -> (u0, u0)) (u9 :: u0 -> u0 -> (u0, u0)) (ua :: u0 -> Bool) (ub :: u0 -> Bool) (uc :: u0 -> Integer) (ud :: u0 -> Int) -> u9; _NO_DEFLT_ } _N_
{-defm-} _A_ 1 _U_ 122 _N_ _S_ "S" _N_ _N_ #-}
{-defm-} _A_ 1 _U_ 12 _N_ _S_ "S" _N_ _N_ #-}
toInteger :: a -> Integer
{-# GHC_PRAGMA {-meth-} _A_ 1 _U_ 12 _N_ _S_ "S" _F_ _IF_ARGS_ 1 1 C 2 _/\_ u0 -> \ (u1 :: ({{Real u0}}, {{Ix u0}}, u0 -> u0 -> u0, u0 -> u0 -> u0, u0 -> u0 -> u0, u0 -> u0 -> u0, u0 -> u0 -> (u0, u0), u0 -> u0 -> (u0, u0), u0 -> Bool, u0 -> Bool, u0 -> Integer, u0 -> Int)) -> case u1 of { _ALG_ _TUP_12 (u2 :: {{Real u0}}) (u3 :: {{Ix u0}}) (u4 :: u0 -> u0 -> u0) (u5 :: u0 -> u0 -> u0) (u6 :: u0 -> u0 -> u0) (u7 :: u0 -> u0 -> u0) (u8 :: u0 -> u0 -> (u0, u0)) (u9 :: u0 -> u0 -> (u0, u0)) (ua :: u0 -> Bool) (ub :: u0 -> Bool) (uc :: u0 -> Integer) (ud :: u0 -> Int) -> uc; _NO_DEFLT_ } _N_
- {-defm-} _A_ 2 _U_ 02 _N_ _S_ _!_ _F_ _IF_ARGS_ 1 2 XX 3 _/\_ u0 -> \ (u1 :: {{Integral u0}}) (u2 :: u0) -> _APP_ _TYAPP_ patError# { (u0 -> Integer) } [ _NOREP_S_ "%DPreludeCore.Integral.toInteger\"", u2 ] _N_ #-}
+ {-defm-} _A_ 2 _U_ 02 _N_ _S_ _!_ _N_ _N_ #-}
toInt :: a -> Int
{-# GHC_PRAGMA {-meth-} _A_ 1 _U_ 12 _N_ _S_ "S" _F_ _IF_ARGS_ 1 1 C 2 _/\_ u0 -> \ (u1 :: ({{Real u0}}, {{Ix u0}}, u0 -> u0 -> u0, u0 -> u0 -> u0, u0 -> u0 -> u0, u0 -> u0 -> u0, u0 -> u0 -> (u0, u0), u0 -> u0 -> (u0, u0), u0 -> Bool, u0 -> Bool, u0 -> Integer, u0 -> Int)) -> case u1 of { _ALG_ _TUP_12 (u2 :: {{Real u0}}) (u3 :: {{Ix u0}}) (u4 :: u0 -> u0 -> u0) (u5 :: u0 -> u0 -> u0) (u6 :: u0 -> u0 -> u0) (u7 :: u0 -> u0 -> u0) (u8 :: u0 -> u0 -> (u0, u0)) (u9 :: u0 -> u0 -> (u0, u0)) (ua :: u0 -> Bool) (ub :: u0 -> Bool) (uc :: u0 -> Integer) (ud :: u0 -> Int) -> ud; _NO_DEFLT_ } _N_
- {-defm-} _A_ 2 _U_ 02 _N_ _S_ _!_ _F_ _IF_ARGS_ 1 2 XX 3 _/\_ u0 -> \ (u1 :: {{Integral u0}}) (u2 :: u0) -> _APP_ _TYAPP_ patError# { (u0 -> Int) } [ _NOREP_S_ "%DPreludeCore.Integral.toInt\"", u2 ] _N_ #-}
+ {-defm-} _A_ 2 _U_ 02 _N_ _S_ _!_ _N_ _N_ #-}
class (Ord a) => Ix a {-# GHC_PRAGMA {-superdicts-} _A_ 1 _U_ 1 _N_ _S_ "S" _F_ _IF_ARGS_ 1 1 C 2 _/\_ u0 -> \ (u1 :: ({{Ord u0}}, (u0, u0) -> [u0], (u0, u0) -> u0 -> Int, (u0, u0) -> u0 -> Bool)) -> case u1 of { _ALG_ _TUP_4 (u2 :: {{Ord u0}}) (u3 :: (u0, u0) -> [u0]) (u4 :: (u0, u0) -> u0 -> Int) (u5 :: (u0, u0) -> u0 -> Bool) -> u2; _NO_DEFLT_ } _N_ #-} where
range :: (a, a) -> [a]
{-# GHC_PRAGMA {-meth-} _A_ 1 _U_ 12 _N_ _S_ "S" _F_ _IF_ARGS_ 1 1 C 2 _/\_ u0 -> \ (u1 :: ({{Ord u0}}, (u0, u0) -> [u0], (u0, u0) -> u0 -> Int, (u0, u0) -> u0 -> Bool)) -> case u1 of { _ALG_ _TUP_4 (u2 :: {{Ord u0}}) (u3 :: (u0, u0) -> [u0]) (u4 :: (u0, u0) -> u0 -> Int) (u5 :: (u0, u0) -> u0 -> Bool) -> u3; _NO_DEFLT_ } _N_
- {-defm-} _A_ 2 _U_ 02 _N_ _S_ _!_ _F_ _IF_ARGS_ 1 2 XX 3 _/\_ u0 -> \ (u1 :: {{Ix u0}}) (u2 :: (u0, u0)) -> _APP_ _TYAPP_ patError# { ((u0, u0) -> [u0]) } [ _NOREP_S_ "%DPreludeCore.Ix.range\"", u2 ] _N_ #-}
+ {-defm-} _A_ 2 _U_ 02 _N_ _S_ _!_ _N_ _N_ #-}
index :: (a, a) -> a -> Int
{-# GHC_PRAGMA {-meth-} _A_ 1 _U_ 122 _N_ _S_ "S" _F_ _IF_ARGS_ 1 1 C 2 _/\_ u0 -> \ (u1 :: ({{Ord u0}}, (u0, u0) -> [u0], (u0, u0) -> u0 -> Int, (u0, u0) -> u0 -> Bool)) -> case u1 of { _ALG_ _TUP_4 (u2 :: {{Ord u0}}) (u3 :: (u0, u0) -> [u0]) (u4 :: (u0, u0) -> u0 -> Int) (u5 :: (u0, u0) -> u0 -> Bool) -> u4; _NO_DEFLT_ } _N_
- {-defm-} _A_ 3 _U_ 022 _N_ _S_ _!_ _F_ _IF_ARGS_ 1 3 XXX 4 _/\_ u0 -> \ (u1 :: {{Ix u0}}) (u2 :: (u0, u0)) (u3 :: u0) -> _APP_ _TYAPP_ patError# { ((u0, u0) -> u0 -> Int) } [ _NOREP_S_ "%DPreludeCore.Ix.index\"", u2, u3 ] _N_ #-}
+ {-defm-} _A_ 3 _U_ 022 _N_ _S_ _!_ _N_ _N_ #-}
inRange :: (a, a) -> a -> Bool
{-# GHC_PRAGMA {-meth-} _A_ 1 _U_ 122 _N_ _S_ "S" _F_ _IF_ARGS_ 1 1 C 2 _/\_ u0 -> \ (u1 :: ({{Ord u0}}, (u0, u0) -> [u0], (u0, u0) -> u0 -> Int, (u0, u0) -> u0 -> Bool)) -> case u1 of { _ALG_ _TUP_4 (u2 :: {{Ord u0}}) (u3 :: (u0, u0) -> [u0]) (u4 :: (u0, u0) -> u0 -> Int) (u5 :: (u0, u0) -> u0 -> Bool) -> u5; _NO_DEFLT_ } _N_
- {-defm-} _A_ 3 _U_ 022 _N_ _S_ _!_ _F_ _IF_ARGS_ 1 3 XXX 4 _/\_ u0 -> \ (u1 :: {{Ix u0}}) (u2 :: (u0, u0)) (u3 :: u0) -> _APP_ _TYAPP_ patError# { ((u0, u0) -> u0 -> Bool) } [ _NOREP_S_ "%DPreludeCore.Ix.inRange\"", u2, u3 ] _N_ #-}
+ {-defm-} _A_ 3 _U_ 022 _N_ _S_ _!_ _N_ _N_ #-}
class (Eq a, Text a) => Num a {-# GHC_PRAGMA {-superdicts-} _A_ 1 _U_ 1 _N_ _S_ "S" _F_ _IF_ARGS_ 1 1 C 2 _/\_ u0 -> \ (u1 :: ({{Eq u0}}, {{Text u0}}, u0 -> u0 -> u0, u0 -> u0 -> u0, u0 -> u0 -> u0, u0 -> u0, u0 -> u0, u0 -> u0, Integer -> u0, Int -> u0)) -> case u1 of { _ALG_ _TUP_10 (u2 :: {{Eq u0}}) (u3 :: {{Text u0}}) (u4 :: u0 -> u0 -> u0) (u5 :: u0 -> u0 -> u0) (u6 :: u0 -> u0 -> u0) (u7 :: u0 -> u0) (u8 :: u0 -> u0) (u9 :: u0 -> u0) (ua :: Integer -> u0) (ub :: Int -> u0) -> u2; _NO_DEFLT_ } _N_, _A_ 1 _U_ 1 _N_ _S_ "S" _F_ _IF_ARGS_ 1 1 C 2 _/\_ u0 -> \ (u1 :: ({{Eq u0}}, {{Text u0}}, u0 -> u0 -> u0, u0 -> u0 -> u0, u0 -> u0 -> u0, u0 -> u0, u0 -> u0, u0 -> u0, Integer -> u0, Int -> u0)) -> case u1 of { _ALG_ _TUP_10 (u2 :: {{Eq u0}}) (u3 :: {{Text u0}}) (u4 :: u0 -> u0 -> u0) (u5 :: u0 -> u0 -> u0) (u6 :: u0 -> u0 -> u0) (u7 :: u0 -> u0) (u8 :: u0 -> u0) (u9 :: u0 -> u0) (ua :: Integer -> u0) (ub :: Int -> u0) -> u3; _NO_DEFLT_ } _N_ #-} where
(+) :: a -> a -> a
{-# GHC_PRAGMA {-meth-} _A_ 1 _U_ 122 _N_ _S_ "S" _F_ _IF_ARGS_ 1 1 C 2 _/\_ u0 -> \ (u1 :: ({{Eq u0}}, {{Text u0}}, u0 -> u0 -> u0, u0 -> u0 -> u0, u0 -> u0 -> u0, u0 -> u0, u0 -> u0, u0 -> u0, Integer -> u0, Int -> u0)) -> case u1 of { _ALG_ _TUP_10 (u2 :: {{Eq u0}}) (u3 :: {{Text u0}}) (u4 :: u0 -> u0 -> u0) (u5 :: u0 -> u0 -> u0) (u6 :: u0 -> u0 -> u0) (u7 :: u0 -> u0) (u8 :: u0 -> u0) (u9 :: u0 -> u0) (ua :: Integer -> u0) (ub :: Int -> u0) -> u4; _NO_DEFLT_ } _N_
- {-defm-} _A_ 3 _U_ 022 _N_ _S_ _!_ _F_ _IF_ARGS_ 1 3 XXX 4 _/\_ u0 -> \ (u1 :: {{Num u0}}) (u2 :: u0) (u3 :: u0) -> _APP_ _TYAPP_ patError# { (u0 -> u0 -> u0) } [ _NOREP_S_ "%DPreludeCore.Num.(+)\"", u2, u3 ] _N_ #-}
+ {-defm-} _A_ 3 _U_ 022 _N_ _S_ _!_ _N_ _N_ #-}
(-) :: a -> a -> a
{-# GHC_PRAGMA {-meth-} _A_ 1 _U_ 122 _N_ _S_ "S" _F_ _IF_ARGS_ 1 1 C 2 _/\_ u0 -> \ (u1 :: ({{Eq u0}}, {{Text u0}}, u0 -> u0 -> u0, u0 -> u0 -> u0, u0 -> u0 -> u0, u0 -> u0, u0 -> u0, u0 -> u0, Integer -> u0, Int -> u0)) -> case u1 of { _ALG_ _TUP_10 (u2 :: {{Eq u0}}) (u3 :: {{Text u0}}) (u4 :: u0 -> u0 -> u0) (u5 :: u0 -> u0 -> u0) (u6 :: u0 -> u0 -> u0) (u7 :: u0 -> u0) (u8 :: u0 -> u0) (u9 :: u0 -> u0) (ua :: Integer -> u0) (ub :: Int -> u0) -> u5; _NO_DEFLT_ } _N_
{-defm-} _A_ 3 _U_ 122 _N_ _S_ "SLL" _F_ _ALWAYS_ _/\_ u0 -> \ (u1 :: {{Num u0}}) (u2 :: u0) (u3 :: u0) -> case u1 of { _ALG_ _TUP_10 (u4 :: {{Eq u0}}) (u5 :: {{Text u0}}) (u6 :: u0 -> u0 -> u0) (u7 :: u0 -> u0 -> u0) (u8 :: u0 -> u0 -> u0) (u9 :: u0 -> u0) (ua :: u0 -> u0) (ub :: u0 -> u0) (uc :: Integer -> u0) (ud :: Int -> u0) -> let {(ue :: u0) = _APP_ u9 [ u3 ]} in _APP_ u6 [ u2, ue ]; _NO_DEFLT_ } _N_ #-}
(*) :: a -> a -> a
{-# GHC_PRAGMA {-meth-} _A_ 1 _U_ 122 _N_ _S_ "S" _F_ _IF_ARGS_ 1 1 C 2 _/\_ u0 -> \ (u1 :: ({{Eq u0}}, {{Text u0}}, u0 -> u0 -> u0, u0 -> u0 -> u0, u0 -> u0 -> u0, u0 -> u0, u0 -> u0, u0 -> u0, Integer -> u0, Int -> u0)) -> case u1 of { _ALG_ _TUP_10 (u2 :: {{Eq u0}}) (u3 :: {{Text u0}}) (u4 :: u0 -> u0 -> u0) (u5 :: u0 -> u0 -> u0) (u6 :: u0 -> u0 -> u0) (u7 :: u0 -> u0) (u8 :: u0 -> u0) (u9 :: u0 -> u0) (ua :: Integer -> u0) (ub :: Int -> u0) -> u6; _NO_DEFLT_ } _N_
- {-defm-} _A_ 3 _U_ 022 _N_ _S_ _!_ _F_ _IF_ARGS_ 1 3 XXX 4 _/\_ u0 -> \ (u1 :: {{Num u0}}) (u2 :: u0) (u3 :: u0) -> _APP_ _TYAPP_ patError# { (u0 -> u0 -> u0) } [ _NOREP_S_ "%DPreludeCore.Num.(*)\"", u2, u3 ] _N_ #-}
+ {-defm-} _A_ 3 _U_ 022 _N_ _S_ _!_ _N_ _N_ #-}
negate :: a -> a
{-# GHC_PRAGMA {-meth-} _A_ 1 _U_ 12 _N_ _S_ "S" _F_ _IF_ARGS_ 1 1 C 2 _/\_ u0 -> \ (u1 :: ({{Eq u0}}, {{Text u0}}, u0 -> u0 -> u0, u0 -> u0 -> u0, u0 -> u0 -> u0, u0 -> u0, u0 -> u0, u0 -> u0, Integer -> u0, Int -> u0)) -> case u1 of { _ALG_ _TUP_10 (u2 :: {{Eq u0}}) (u3 :: {{Text u0}}) (u4 :: u0 -> u0 -> u0) (u5 :: u0 -> u0 -> u0) (u6 :: u0 -> u0 -> u0) (u7 :: u0 -> u0) (u8 :: u0 -> u0) (u9 :: u0 -> u0) (ua :: Integer -> u0) (ub :: Int -> u0) -> u7; _NO_DEFLT_ } _N_
- {-defm-} _A_ 2 _U_ 02 _N_ _S_ _!_ _F_ _IF_ARGS_ 1 2 XX 3 _/\_ u0 -> \ (u1 :: {{Num u0}}) (u2 :: u0) -> _APP_ _TYAPP_ patError# { (u0 -> u0) } [ _NOREP_S_ "%DPreludeCore.Num.negate\"", u2 ] _N_ #-}
+ {-defm-} _A_ 2 _U_ 02 _N_ _S_ _!_ _N_ _N_ #-}
abs :: a -> a
{-# GHC_PRAGMA {-meth-} _A_ 1 _U_ 12 _N_ _S_ "S" _F_ _IF_ARGS_ 1 1 C 2 _/\_ u0 -> \ (u1 :: ({{Eq u0}}, {{Text u0}}, u0 -> u0 -> u0, u0 -> u0 -> u0, u0 -> u0 -> u0, u0 -> u0, u0 -> u0, u0 -> u0, Integer -> u0, Int -> u0)) -> case u1 of { _ALG_ _TUP_10 (u2 :: {{Eq u0}}) (u3 :: {{Text u0}}) (u4 :: u0 -> u0 -> u0) (u5 :: u0 -> u0 -> u0) (u6 :: u0 -> u0 -> u0) (u7 :: u0 -> u0) (u8 :: u0 -> u0) (u9 :: u0 -> u0) (ua :: Integer -> u0) (ub :: Int -> u0) -> u8; _NO_DEFLT_ } _N_
- {-defm-} _A_ 2 _U_ 02 _N_ _S_ _!_ _F_ _IF_ARGS_ 1 2 XX 3 _/\_ u0 -> \ (u1 :: {{Num u0}}) (u2 :: u0) -> _APP_ _TYAPP_ patError# { (u0 -> u0) } [ _NOREP_S_ "%DPreludeCore.Num.abs\"", u2 ] _N_ #-}
+ {-defm-} _A_ 2 _U_ 02 _N_ _S_ _!_ _N_ _N_ #-}
signum :: a -> a
{-# GHC_PRAGMA {-meth-} _A_ 1 _U_ 12 _N_ _S_ "S" _F_ _IF_ARGS_ 1 1 C 2 _/\_ u0 -> \ (u1 :: ({{Eq u0}}, {{Text u0}}, u0 -> u0 -> u0, u0 -> u0 -> u0, u0 -> u0 -> u0, u0 -> u0, u0 -> u0, u0 -> u0, Integer -> u0, Int -> u0)) -> case u1 of { _ALG_ _TUP_10 (u2 :: {{Eq u0}}) (u3 :: {{Text u0}}) (u4 :: u0 -> u0 -> u0) (u5 :: u0 -> u0 -> u0) (u6 :: u0 -> u0 -> u0) (u7 :: u0 -> u0) (u8 :: u0 -> u0) (u9 :: u0 -> u0) (ua :: Integer -> u0) (ub :: Int -> u0) -> u9; _NO_DEFLT_ } _N_
- {-defm-} _A_ 2 _U_ 02 _N_ _S_ _!_ _F_ _IF_ARGS_ 1 2 XX 3 _/\_ u0 -> \ (u1 :: {{Num u0}}) (u2 :: u0) -> _APP_ _TYAPP_ patError# { (u0 -> u0) } [ _NOREP_S_ "%DPreludeCore.Num.signum\"", u2 ] _N_ #-}
+ {-defm-} _A_ 2 _U_ 02 _N_ _S_ _!_ _N_ _N_ #-}
fromInteger :: Integer -> a
{-# GHC_PRAGMA {-meth-} _A_ 1 _U_ 12 _N_ _S_ "S" _F_ _IF_ARGS_ 1 1 C 2 _/\_ u0 -> \ (u1 :: ({{Eq u0}}, {{Text u0}}, u0 -> u0 -> u0, u0 -> u0 -> u0, u0 -> u0 -> u0, u0 -> u0, u0 -> u0, u0 -> u0, Integer -> u0, Int -> u0)) -> case u1 of { _ALG_ _TUP_10 (u2 :: {{Eq u0}}) (u3 :: {{Text u0}}) (u4 :: u0 -> u0 -> u0) (u5 :: u0 -> u0 -> u0) (u6 :: u0 -> u0 -> u0) (u7 :: u0 -> u0) (u8 :: u0 -> u0) (u9 :: u0 -> u0) (ua :: Integer -> u0) (ub :: Int -> u0) -> ua; _NO_DEFLT_ } _N_
- {-defm-} _A_ 2 _U_ 02 _N_ _S_ _!_ _F_ _IF_ARGS_ 1 2 XX 3 _/\_ u0 -> \ (u1 :: {{Num u0}}) (u2 :: Integer) -> _APP_ _TYAPP_ patError# { (Integer -> u0) } [ _NOREP_S_ "%DPreludeCore.Num.fromInteger\"", u2 ] _N_ #-}
+ {-defm-} _A_ 2 _U_ 02 _N_ _S_ _!_ _N_ _N_ #-}
fromInt :: Int -> a
{-# GHC_PRAGMA {-meth-} _A_ 1 _U_ 12 _N_ _S_ "S" _F_ _IF_ARGS_ 1 1 C 2 _/\_ u0 -> \ (u1 :: ({{Eq u0}}, {{Text u0}}, u0 -> u0 -> u0, u0 -> u0 -> u0, u0 -> u0 -> u0, u0 -> u0, u0 -> u0, u0 -> u0, Integer -> u0, Int -> u0)) -> case u1 of { _ALG_ _TUP_10 (u2 :: {{Eq u0}}) (u3 :: {{Text u0}}) (u4 :: u0 -> u0 -> u0) (u5 :: u0 -> u0 -> u0) (u6 :: u0 -> u0 -> u0) (u7 :: u0 -> u0) (u8 :: u0 -> u0) (u9 :: u0 -> u0) (ua :: Integer -> u0) (ub :: Int -> u0) -> ub; _NO_DEFLT_ } _N_
{-defm-} _A_ 2 _U_ 11 _N_ _S_ "SL" _F_ _IF_ARGS_ 1 2 CC 6 _/\_ u0 -> \ (u1 :: {{Num u0}}) (u2 :: Int) -> let {(u4 :: Integer) = case u2 of { _ALG_ I# (u3 :: Int#) -> _#_ int2Integer# [] [u3]; _NO_DEFLT_ }} in case u1 of { _ALG_ _TUP_10 (u5 :: {{Eq u0}}) (u6 :: {{Text u0}}) (u7 :: u0 -> u0 -> u0) (u8 :: u0 -> u0 -> u0) (u9 :: u0 -> u0 -> u0) (ua :: u0 -> u0) (ub :: u0 -> u0) (uc :: u0 -> u0) (ud :: Integer -> u0) (ue :: Int -> u0) -> _APP_ ud [ u4 ]; _NO_DEFLT_ } _N_ #-}
{-defm-} _A_ 3 _U_ 122 _N_ _S_ "SLL" _N_ _N_ #-}
(<=) :: a -> a -> Bool
{-# GHC_PRAGMA {-meth-} _A_ 1 _U_ 122 _N_ _S_ "S" _F_ _IF_ARGS_ 1 1 C 2 _/\_ u0 -> \ (u1 :: ({{Eq u0}}, u0 -> u0 -> Bool, u0 -> u0 -> Bool, u0 -> u0 -> Bool, u0 -> u0 -> Bool, u0 -> u0 -> u0, u0 -> u0 -> u0, u0 -> u0 -> _CMP_TAG)) -> case u1 of { _ALG_ _TUP_8 (u2 :: {{Eq u0}}) (u3 :: u0 -> u0 -> Bool) (u4 :: u0 -> u0 -> Bool) (u5 :: u0 -> u0 -> Bool) (u6 :: u0 -> u0 -> Bool) (u7 :: u0 -> u0 -> u0) (u8 :: u0 -> u0 -> u0) (u9 :: u0 -> u0 -> _CMP_TAG) -> u4; _NO_DEFLT_ } _N_
- {-defm-} _A_ 3 _U_ 022 _N_ _S_ _!_ _F_ _IF_ARGS_ 1 3 XXX 4 _/\_ u0 -> \ (u1 :: {{Ord u0}}) (u2 :: u0) (u3 :: u0) -> _APP_ _TYAPP_ patError# { (u0 -> u0 -> Bool) } [ _NOREP_S_ "%DPreludeCore.Ord.(<=)\"", u2, u3 ] _N_ #-}
+ {-defm-} _A_ 3 _U_ 022 _N_ _S_ _!_ _N_ _N_ #-}
(>=) :: a -> a -> Bool
{-# GHC_PRAGMA {-meth-} _A_ 1 _U_ 122 _N_ _S_ "S" _F_ _IF_ARGS_ 1 1 C 2 _/\_ u0 -> \ (u1 :: ({{Eq u0}}, u0 -> u0 -> Bool, u0 -> u0 -> Bool, u0 -> u0 -> Bool, u0 -> u0 -> Bool, u0 -> u0 -> u0, u0 -> u0 -> u0, u0 -> u0 -> _CMP_TAG)) -> case u1 of { _ALG_ _TUP_8 (u2 :: {{Eq u0}}) (u3 :: u0 -> u0 -> Bool) (u4 :: u0 -> u0 -> Bool) (u5 :: u0 -> u0 -> Bool) (u6 :: u0 -> u0 -> Bool) (u7 :: u0 -> u0 -> u0) (u8 :: u0 -> u0 -> u0) (u9 :: u0 -> u0 -> _CMP_TAG) -> u5; _NO_DEFLT_ } _N_
{-defm-} _A_ 3 _U_ 122 _N_ _S_ "SLL" _F_ _IF_ARGS_ 1 3 CXX 4 _/\_ u0 -> \ (u1 :: {{Ord u0}}) (u2 :: u0) (u3 :: u0) -> case u1 of { _ALG_ _TUP_8 (u4 :: {{Eq u0}}) (u5 :: u0 -> u0 -> Bool) (u6 :: u0 -> u0 -> Bool) (u7 :: u0 -> u0 -> Bool) (u8 :: u0 -> u0 -> Bool) (u9 :: u0 -> u0 -> u0) (ua :: u0 -> u0 -> u0) (ub :: u0 -> u0 -> _CMP_TAG) -> _APP_ u6 [ u3, u2 ]; _NO_DEFLT_ } _N_ #-}
class (Num a, Enum a) => Real a {-# GHC_PRAGMA {-superdicts-} _A_ 1 _U_ 1 _N_ _S_ "S" _F_ _IF_ARGS_ 1 1 C 2 _/\_ u0 -> \ (u1 :: ({{Num u0}}, {{Enum u0}}, u0 -> Ratio Integer)) -> case u1 of { _ALG_ _TUP_3 (u2 :: {{Num u0}}) (u3 :: {{Enum u0}}) (u4 :: u0 -> Ratio Integer) -> u2; _NO_DEFLT_ } _N_, _A_ 1 _U_ 1 _N_ _S_ "S" _F_ _IF_ARGS_ 1 1 C 2 _/\_ u0 -> \ (u1 :: ({{Num u0}}, {{Enum u0}}, u0 -> Ratio Integer)) -> case u1 of { _ALG_ _TUP_3 (u2 :: {{Num u0}}) (u3 :: {{Enum u0}}) (u4 :: u0 -> Ratio Integer) -> u3; _NO_DEFLT_ } _N_ #-} where
toRational :: a -> Ratio Integer
{-# GHC_PRAGMA {-meth-} _A_ 1 _U_ 12 _N_ _S_ "S" _F_ _IF_ARGS_ 1 1 C 2 _/\_ u0 -> \ (u1 :: ({{Num u0}}, {{Enum u0}}, u0 -> Ratio Integer)) -> case u1 of { _ALG_ _TUP_3 (u2 :: {{Num u0}}) (u3 :: {{Enum u0}}) (u4 :: u0 -> Ratio Integer) -> u4; _NO_DEFLT_ } _N_
- {-defm-} _A_ 2 _U_ 02 _N_ _S_ _!_ _F_ _IF_ARGS_ 1 2 XX 3 _/\_ u0 -> \ (u1 :: {{Real u0}}) (u2 :: u0) -> _APP_ _TYAPP_ patError# { (u0 -> Ratio Integer) } [ _NOREP_S_ "%DPreludeCore.Real.toRational\"", u2 ] _N_ #-}
+ {-defm-} _A_ 2 _U_ 02 _N_ _S_ _!_ _N_ _N_ #-}
class (RealFrac a, Floating a) => RealFloat a {-# GHC_PRAGMA {-superdicts-} _A_ 1 _U_ 1 _N_ _S_ "S" _F_ _IF_ARGS_ 1 1 C 2 _/\_ u0 -> \ (u1 :: ({{RealFrac u0}}, {{Floating u0}}, u0 -> Integer, u0 -> Int, u0 -> (Int, Int), u0 -> (Integer, Int), Integer -> Int -> u0, u0 -> Int, u0 -> u0, Int -> u0 -> u0)) -> case u1 of { _ALG_ _TUP_10 (u2 :: {{RealFrac u0}}) (u3 :: {{Floating u0}}) (u4 :: u0 -> Integer) (u5 :: u0 -> Int) (u6 :: u0 -> (Int, Int)) (u7 :: u0 -> (Integer, Int)) (u8 :: Integer -> Int -> u0) (u9 :: u0 -> Int) (ua :: u0 -> u0) (ub :: Int -> u0 -> u0) -> u2; _NO_DEFLT_ } _N_, _A_ 1 _U_ 1 _N_ _S_ "S" _F_ _IF_ARGS_ 1 1 C 2 _/\_ u0 -> \ (u1 :: ({{RealFrac u0}}, {{Floating u0}}, u0 -> Integer, u0 -> Int, u0 -> (Int, Int), u0 -> (Integer, Int), Integer -> Int -> u0, u0 -> Int, u0 -> u0, Int -> u0 -> u0)) -> case u1 of { _ALG_ _TUP_10 (u2 :: {{RealFrac u0}}) (u3 :: {{Floating u0}}) (u4 :: u0 -> Integer) (u5 :: u0 -> Int) (u6 :: u0 -> (Int, Int)) (u7 :: u0 -> (Integer, Int)) (u8 :: Integer -> Int -> u0) (u9 :: u0 -> Int) (ua :: u0 -> u0) (ub :: Int -> u0 -> u0) -> u3; _NO_DEFLT_ } _N_ #-} where
floatRadix :: a -> Integer
{-# GHC_PRAGMA {-meth-} _A_ 1 _U_ 12 _N_ _S_ "S" _F_ _IF_ARGS_ 1 1 C 2 _/\_ u0 -> \ (u1 :: ({{RealFrac u0}}, {{Floating u0}}, u0 -> Integer, u0 -> Int, u0 -> (Int, Int), u0 -> (Integer, Int), Integer -> Int -> u0, u0 -> Int, u0 -> u0, Int -> u0 -> u0)) -> case u1 of { _ALG_ _TUP_10 (u2 :: {{RealFrac u0}}) (u3 :: {{Floating u0}}) (u4 :: u0 -> Integer) (u5 :: u0 -> Int) (u6 :: u0 -> (Int, Int)) (u7 :: u0 -> (Integer, Int)) (u8 :: Integer -> Int -> u0) (u9 :: u0 -> Int) (ua :: u0 -> u0) (ub :: Int -> u0 -> u0) -> u4; _NO_DEFLT_ } _N_
- {-defm-} _A_ 2 _U_ 02 _N_ _S_ _!_ _F_ _IF_ARGS_ 1 2 XX 3 _/\_ u0 -> \ (u1 :: {{RealFloat u0}}) (u2 :: u0) -> _APP_ _TYAPP_ patError# { (u0 -> Integer) } [ _NOREP_S_ "%DPreludeCore.RealFloat.floatRadix\"", u2 ] _N_ #-}
+ {-defm-} _A_ 2 _U_ 02 _N_ _S_ _!_ _N_ _N_ #-}
floatDigits :: a -> Int
{-# GHC_PRAGMA {-meth-} _A_ 1 _U_ 12 _N_ _S_ "S" _F_ _IF_ARGS_ 1 1 C 2 _/\_ u0 -> \ (u1 :: ({{RealFrac u0}}, {{Floating u0}}, u0 -> Integer, u0 -> Int, u0 -> (Int, Int), u0 -> (Integer, Int), Integer -> Int -> u0, u0 -> Int, u0 -> u0, Int -> u0 -> u0)) -> case u1 of { _ALG_ _TUP_10 (u2 :: {{RealFrac u0}}) (u3 :: {{Floating u0}}) (u4 :: u0 -> Integer) (u5 :: u0 -> Int) (u6 :: u0 -> (Int, Int)) (u7 :: u0 -> (Integer, Int)) (u8 :: Integer -> Int -> u0) (u9 :: u0 -> Int) (ua :: u0 -> u0) (ub :: Int -> u0 -> u0) -> u5; _NO_DEFLT_ } _N_
- {-defm-} _A_ 2 _U_ 02 _N_ _S_ _!_ _F_ _IF_ARGS_ 1 2 XX 3 _/\_ u0 -> \ (u1 :: {{RealFloat u0}}) (u2 :: u0) -> _APP_ _TYAPP_ patError# { (u0 -> Int) } [ _NOREP_S_ "%DPreludeCore.RealFloat.floatDigits\"", u2 ] _N_ #-}
+ {-defm-} _A_ 2 _U_ 02 _N_ _S_ _!_ _N_ _N_ #-}
floatRange :: a -> (Int, Int)
{-# GHC_PRAGMA {-meth-} _A_ 1 _U_ 12 _N_ _S_ "S" _F_ _IF_ARGS_ 1 1 C 2 _/\_ u0 -> \ (u1 :: ({{RealFrac u0}}, {{Floating u0}}, u0 -> Integer, u0 -> Int, u0 -> (Int, Int), u0 -> (Integer, Int), Integer -> Int -> u0, u0 -> Int, u0 -> u0, Int -> u0 -> u0)) -> case u1 of { _ALG_ _TUP_10 (u2 :: {{RealFrac u0}}) (u3 :: {{Floating u0}}) (u4 :: u0 -> Integer) (u5 :: u0 -> Int) (u6 :: u0 -> (Int, Int)) (u7 :: u0 -> (Integer, Int)) (u8 :: Integer -> Int -> u0) (u9 :: u0 -> Int) (ua :: u0 -> u0) (ub :: Int -> u0 -> u0) -> u6; _NO_DEFLT_ } _N_
- {-defm-} _A_ 2 _U_ 02 _N_ _S_ _!_ _F_ _IF_ARGS_ 1 2 XX 3 _/\_ u0 -> \ (u1 :: {{RealFloat u0}}) (u2 :: u0) -> _APP_ _TYAPP_ patError# { (u0 -> (Int, Int)) } [ _NOREP_S_ "%DPreludeCore.RealFloat.floatRange\"", u2 ] _N_ #-}
+ {-defm-} _A_ 2 _U_ 02 _N_ _S_ _!_ _N_ _N_ #-}
decodeFloat :: a -> (Integer, Int)
{-# GHC_PRAGMA {-meth-} _A_ 1 _U_ 12 _N_ _S_ "S" _F_ _IF_ARGS_ 1 1 C 2 _/\_ u0 -> \ (u1 :: ({{RealFrac u0}}, {{Floating u0}}, u0 -> Integer, u0 -> Int, u0 -> (Int, Int), u0 -> (Integer, Int), Integer -> Int -> u0, u0 -> Int, u0 -> u0, Int -> u0 -> u0)) -> case u1 of { _ALG_ _TUP_10 (u2 :: {{RealFrac u0}}) (u3 :: {{Floating u0}}) (u4 :: u0 -> Integer) (u5 :: u0 -> Int) (u6 :: u0 -> (Int, Int)) (u7 :: u0 -> (Integer, Int)) (u8 :: Integer -> Int -> u0) (u9 :: u0 -> Int) (ua :: u0 -> u0) (ub :: Int -> u0 -> u0) -> u7; _NO_DEFLT_ } _N_
- {-defm-} _A_ 2 _U_ 02 _N_ _S_ _!_ _F_ _IF_ARGS_ 1 2 XX 3 _/\_ u0 -> \ (u1 :: {{RealFloat u0}}) (u2 :: u0) -> _APP_ _TYAPP_ patError# { (u0 -> (Integer, Int)) } [ _NOREP_S_ "%DPreludeCore.RealFloat.decodeFloat\"", u2 ] _N_ #-}
+ {-defm-} _A_ 2 _U_ 02 _N_ _S_ _!_ _N_ _N_ #-}
encodeFloat :: Integer -> Int -> a
{-# GHC_PRAGMA {-meth-} _A_ 1 _U_ 122 _N_ _S_ "S" _F_ _IF_ARGS_ 1 1 C 2 _/\_ u0 -> \ (u1 :: ({{RealFrac u0}}, {{Floating u0}}, u0 -> Integer, u0 -> Int, u0 -> (Int, Int), u0 -> (Integer, Int), Integer -> Int -> u0, u0 -> Int, u0 -> u0, Int -> u0 -> u0)) -> case u1 of { _ALG_ _TUP_10 (u2 :: {{RealFrac u0}}) (u3 :: {{Floating u0}}) (u4 :: u0 -> Integer) (u5 :: u0 -> Int) (u6 :: u0 -> (Int, Int)) (u7 :: u0 -> (Integer, Int)) (u8 :: Integer -> Int -> u0) (u9 :: u0 -> Int) (ua :: u0 -> u0) (ub :: Int -> u0 -> u0) -> u8; _NO_DEFLT_ } _N_
- {-defm-} _A_ 3 _U_ 022 _N_ _S_ _!_ _F_ _IF_ARGS_ 1 3 XXX 4 _/\_ u0 -> \ (u1 :: {{RealFloat u0}}) (u2 :: Integer) (u3 :: Int) -> _APP_ _TYAPP_ patError# { (Integer -> Int -> u0) } [ _NOREP_S_ "%DPreludeCore.RealFloat.encodeFloat\"", u2, u3 ] _N_ #-}
+ {-defm-} _A_ 3 _U_ 022 _N_ _S_ _!_ _N_ _N_ #-}
exponent :: a -> Int
{-# GHC_PRAGMA {-meth-} _A_ 1 _U_ 12 _N_ _S_ "S" _F_ _IF_ARGS_ 1 1 C 2 _/\_ u0 -> \ (u1 :: ({{RealFrac u0}}, {{Floating u0}}, u0 -> Integer, u0 -> Int, u0 -> (Int, Int), u0 -> (Integer, Int), Integer -> Int -> u0, u0 -> Int, u0 -> u0, Int -> u0 -> u0)) -> case u1 of { _ALG_ _TUP_10 (u2 :: {{RealFrac u0}}) (u3 :: {{Floating u0}}) (u4 :: u0 -> Integer) (u5 :: u0 -> Int) (u6 :: u0 -> (Int, Int)) (u7 :: u0 -> (Integer, Int)) (u8 :: Integer -> Int -> u0) (u9 :: u0 -> Int) (ua :: u0 -> u0) (ub :: Int -> u0 -> u0) -> u9; _NO_DEFLT_ } _N_
{-defm-} _A_ 2 _U_ 12 _N_ _S_ "SL" _N_ _N_ #-}
class (Real a, Fractional a) => RealFrac a {-# GHC_PRAGMA {-superdicts-} _A_ 1 _U_ 1 _N_ _S_ "S" _F_ _IF_ARGS_ 1 1 C 2 _/\_ u0 -> \ (u1 :: ({{Real u0}}, {{Fractional u0}}, (_forall_ z$z1 =>{{Integral z$z1}} -> u0 -> (z$z1, u0)), (_forall_ z$z1 =>{{Integral z$z1}} -> u0 -> z$z1), (_forall_ z$z1 =>{{Integral z$z1}} -> u0 -> z$z1), (_forall_ z$z1 =>{{Integral z$z1}} -> u0 -> z$z1), (_forall_ z$z1 =>{{Integral z$z1}} -> u0 -> z$z1))) -> case u1 of { _ALG_ _TUP_7 (u2 :: {{Real u0}}) (u3 :: {{Fractional u0}}) (u4 :: _forall_ a$z1 =>{{Integral a$z1}} -> u0 -> (a$z1, u0)) (u5 :: _forall_ a$z1 =>{{Integral a$z1}} -> u0 -> a$z1) (u6 :: _forall_ a$z1 =>{{Integral a$z1}} -> u0 -> a$z1) (u7 :: _forall_ a$z1 =>{{Integral a$z1}} -> u0 -> a$z1) (u8 :: _forall_ a$z1 =>{{Integral a$z1}} -> u0 -> a$z1) -> u2; _NO_DEFLT_ } _N_, _A_ 1 _U_ 1 _N_ _S_ "S" _F_ _IF_ARGS_ 1 1 C 2 _/\_ u0 -> \ (u1 :: ({{Real u0}}, {{Fractional u0}}, (_forall_ z$z1 =>{{Integral z$z1}} -> u0 -> (z$z1, u0)), (_forall_ z$z1 =>{{Integral z$z1}} -> u0 -> z$z1), (_forall_ z$z1 =>{{Integral z$z1}} -> u0 -> z$z1), (_forall_ z$z1 =>{{Integral z$z1}} -> u0 -> z$z1), (_forall_ z$z1 =>{{Integral z$z1}} -> u0 -> z$z1))) -> case u1 of { _ALG_ _TUP_7 (u2 :: {{Real u0}}) (u3 :: {{Fractional u0}}) (u4 :: _forall_ a$z1 =>{{Integral a$z1}} -> u0 -> (a$z1, u0)) (u5 :: _forall_ a$z1 =>{{Integral a$z1}} -> u0 -> a$z1) (u6 :: _forall_ a$z1 =>{{Integral a$z1}} -> u0 -> a$z1) (u7 :: _forall_ a$z1 =>{{Integral a$z1}} -> u0 -> a$z1) (u8 :: _forall_ a$z1 =>{{Integral a$z1}} -> u0 -> a$z1) -> u3; _NO_DEFLT_ } _N_ #-} where
properFraction :: Integral b => a -> (b, a)
{-# GHC_PRAGMA {-meth-} _A_ 2 _U_ 122 _N_ _S_ "SL" _F_ _IF_ARGS_ 2 2 CX 3 _/\_ u0 u1 -> \ (u2 :: ({{Real u0}}, {{Fractional u0}}, (_forall_ z$z1 =>{{Integral z$z1}} -> u0 -> (z$z1, u0)), (_forall_ z$z1 =>{{Integral z$z1}} -> u0 -> z$z1), (_forall_ z$z1 =>{{Integral z$z1}} -> u0 -> z$z1), (_forall_ z$z1 =>{{Integral z$z1}} -> u0 -> z$z1), (_forall_ z$z1 =>{{Integral z$z1}} -> u0 -> z$z1))) (u3 :: {{Integral u1}}) -> case u2 of { _ALG_ _TUP_7 (u4 :: {{Real u0}}) (u5 :: {{Fractional u0}}) (u6 :: _forall_ a$z1 =>{{Integral a$z1}} -> u0 -> (a$z1, u0)) (u7 :: _forall_ a$z1 =>{{Integral a$z1}} -> u0 -> a$z1) (u8 :: _forall_ a$z1 =>{{Integral a$z1}} -> u0 -> a$z1) (u9 :: _forall_ a$z1 =>{{Integral a$z1}} -> u0 -> a$z1) (ua :: _forall_ a$z1 =>{{Integral a$z1}} -> u0 -> a$z1) -> _APP_ _TYAPP_ u6 { u1 } [ u3 ]; _NO_DEFLT_ } _N_
- {-defm-} _A_ 3 _U_ 002 _N_ _S_ _!_ _F_ _IF_ARGS_ 2 3 XXX 3 _/\_ u0 u1 -> \ (u2 :: {{RealFrac u0}}) (u3 :: {{Integral u1}}) (u4 :: u0) -> _APP_ _TYAPP_ patError# { (u0 -> (u1, u0)) } [ _NOREP_S_ "%DPreludeCore.RealFrac.properFraction\"", u4 ] _N_ #-}
+ {-defm-} _A_ 3 _U_ 002 _N_ _S_ _!_ _N_ _N_ #-}
truncate :: Integral b => a -> b
{-# GHC_PRAGMA {-meth-} _A_ 2 _U_ 122 _N_ _S_ "SL" _F_ _IF_ARGS_ 2 2 CX 3 _/\_ u0 u1 -> \ (u2 :: ({{Real u0}}, {{Fractional u0}}, (_forall_ z$z1 =>{{Integral z$z1}} -> u0 -> (z$z1, u0)), (_forall_ z$z1 =>{{Integral z$z1}} -> u0 -> z$z1), (_forall_ z$z1 =>{{Integral z$z1}} -> u0 -> z$z1), (_forall_ z$z1 =>{{Integral z$z1}} -> u0 -> z$z1), (_forall_ z$z1 =>{{Integral z$z1}} -> u0 -> z$z1))) (u3 :: {{Integral u1}}) -> case u2 of { _ALG_ _TUP_7 (u4 :: {{Real u0}}) (u5 :: {{Fractional u0}}) (u6 :: _forall_ a$z1 =>{{Integral a$z1}} -> u0 -> (a$z1, u0)) (u7 :: _forall_ a$z1 =>{{Integral a$z1}} -> u0 -> a$z1) (u8 :: _forall_ a$z1 =>{{Integral a$z1}} -> u0 -> a$z1) (u9 :: _forall_ a$z1 =>{{Integral a$z1}} -> u0 -> a$z1) (ua :: _forall_ a$z1 =>{{Integral a$z1}} -> u0 -> a$z1) -> _APP_ _TYAPP_ u7 { u1 } [ u3 ]; _NO_DEFLT_ } _N_
{-defm-} _A_ 2 _U_ 122 _N_ _S_ "SL" _N_ _N_ #-}
class Text a where
readsPrec :: Int -> [Char] -> [(a, [Char])]
{-# GHC_PRAGMA {-meth-} _A_ 1 _U_ 122 _N_ _S_ "S" _F_ _IF_ARGS_ 1 1 C 2 _/\_ u0 -> \ (u1 :: (Int -> [Char] -> [(u0, [Char])], Int -> u0 -> [Char] -> [Char], [Char] -> [([u0], [Char])], [u0] -> [Char] -> [Char])) -> case u1 of { _ALG_ _TUP_4 (u2 :: Int -> [Char] -> [(u0, [Char])]) (u3 :: Int -> u0 -> [Char] -> [Char]) (u4 :: [Char] -> [([u0], [Char])]) (u5 :: [u0] -> [Char] -> [Char]) -> u2; _NO_DEFLT_ } _N_
- {-defm-} _A_ 3 _U_ 022 _N_ _S_ _!_ _F_ _IF_ARGS_ 1 3 XXX 4 _/\_ u0 -> \ (u1 :: {{Text u0}}) (u2 :: Int) (u3 :: [Char]) -> _APP_ _TYAPP_ patError# { (Int -> [Char] -> [(u0, [Char])]) } [ _NOREP_S_ "%DPreludeCore.Text.readsPrec\"", u2, u3 ] _N_ #-}
+ {-defm-} _A_ 3 _U_ 022 _N_ _S_ _!_ _N_ _N_ #-}
showsPrec :: Int -> a -> [Char] -> [Char]
{-# GHC_PRAGMA {-meth-} _A_ 1 _U_ 1222 _N_ _S_ "S" _F_ _IF_ARGS_ 1 1 C 2 _/\_ u0 -> \ (u1 :: (Int -> [Char] -> [(u0, [Char])], Int -> u0 -> [Char] -> [Char], [Char] -> [([u0], [Char])], [u0] -> [Char] -> [Char])) -> case u1 of { _ALG_ _TUP_4 (u2 :: Int -> [Char] -> [(u0, [Char])]) (u3 :: Int -> u0 -> [Char] -> [Char]) (u4 :: [Char] -> [([u0], [Char])]) (u5 :: [u0] -> [Char] -> [Char]) -> u3; _NO_DEFLT_ } _N_
- {-defm-} _A_ 4 _U_ 0222 _N_ _S_ _!_ _F_ _IF_ARGS_ 1 4 XXXX 5 _/\_ u0 -> \ (u1 :: {{Text u0}}) (u2 :: Int) (u3 :: u0) (u4 :: [Char]) -> _APP_ _TYAPP_ patError# { (Int -> u0 -> [Char] -> [Char]) } [ _NOREP_S_ "%DPreludeCore.Text.showsPrec\"", u2, u3, u4 ] _N_ #-}
+ {-defm-} _A_ 4 _U_ 0222 _N_ _S_ _!_ _N_ _N_ #-}
readList :: [Char] -> [([a], [Char])]
{-# GHC_PRAGMA {-meth-} _A_ 1 _U_ 12 _N_ _S_ "S" _F_ _IF_ARGS_ 1 1 C 2 _/\_ u0 -> \ (u1 :: (Int -> [Char] -> [(u0, [Char])], Int -> u0 -> [Char] -> [Char], [Char] -> [([u0], [Char])], [u0] -> [Char] -> [Char])) -> case u1 of { _ALG_ _TUP_4 (u2 :: Int -> [Char] -> [(u0, [Char])]) (u3 :: Int -> u0 -> [Char] -> [Char]) (u4 :: [Char] -> [([u0], [Char])]) (u5 :: [u0] -> [Char] -> [Char]) -> u4; _NO_DEFLT_ } _N_
- {-defm-} _A_ 1 _U_ 22 _N_ _N_ _F_ _IF_ARGS_ 0 0 X 1 _ORIG_ PreludeCore _readList _N_ #-}
+ {-defm-} _A_ 1 _U_ 12 _N_ _N_ _N_ _N_ #-}
showList :: [a] -> [Char] -> [Char]
{-# GHC_PRAGMA {-meth-} _A_ 1 _U_ 122 _N_ _S_ "S" _F_ _IF_ARGS_ 1 1 C 2 _/\_ u0 -> \ (u1 :: (Int -> [Char] -> [(u0, [Char])], Int -> u0 -> [Char] -> [Char], [Char] -> [([u0], [Char])], [u0] -> [Char] -> [Char])) -> case u1 of { _ALG_ _TUP_4 (u2 :: Int -> [Char] -> [(u0, [Char])]) (u3 :: Int -> u0 -> [Char] -> [Char]) (u4 :: [Char] -> [([u0], [Char])]) (u5 :: [u0] -> [Char] -> [Char]) -> u5; _NO_DEFLT_ } _N_
- {-defm-} _A_ 1 _U_ 212 _N_ _N_ _F_ _IF_ARGS_ 0 0 X 1 _ORIG_ PreludeCore _showList _N_ #-}
+ {-defm-} _A_ 1 _U_ 112 _N_ _N_ _N_ _N_ #-}
class _CCallable a
class _CReturnable a
data Array a b {-# GHC_PRAGMA _Array (a, a) (Array# b) #-}
data Assoc a b = (:=) a b
data _ByteArray a {-# GHC_PRAGMA _ByteArray (a, a) ByteArray# #-}
data Bin
-data Complex a = (:+) a a
+data Complex a = (:+) a a {-# GHC_PRAGMA _SPECIALISE_ [ Double# ] #-}
data _MutableArray a b c {-# GHC_PRAGMA _MutableArray (b, b) (MutableArray# a c) #-}
data _MutableByteArray a b {-# GHC_PRAGMA _MutableByteArray (b, b) (MutableByteArray# a) #-}
data IOError13 = AlreadyExists [Char] | HardwareFault [Char] | IllegalOperation [Char] | InappropriateType [Char] | Interrupted [Char] | InvalidArgument [Char] | NoSuchThing [Char] | OtherError13 [Char] | PermissionDenied [Char] | ProtocolError [Char] | ResourceBusy [Char] | ResourceExhausted [Char] | ResourceVanished [Char] | SystemError [Char] | TimeExpired [Char] | UnsatisfiedConstraints [Char] | UnsupportedOperation [Char] | UserError [Char] | EOF
type ReadS a = [Char] -> [(a, [Char])]
type ShowS = [Char] -> [Char]
data _FILE {-# GHC_PRAGMA _FILE Addr# #-}
+__i0 :: Num a => a
+ {-# GHC_PRAGMA _A_ 1 _U_ 1 _N_ _S_ "U(AAAAAAAAAS)" {_A_ 1 _U_ 1 _N_ _N_ _N_ _N_} _N_ _SPECIALISE_ [ Double ] 1 { _A_ 0 _N_ _N_ _N_ _F_ _IF_ARGS_ 0 0 X 2 _!_ D# [] [0.0000000000000000##] _N_ }, [ Int ] 1 { _A_ 0 _N_ _N_ _N_ _F_ _IF_ARGS_ 0 0 X 2 _!_ I# [] [0#] _N_ }, [ Integer ] 1 { _A_ 0 _N_ _N_ _N_ _N_ _N_ }, [ (Ratio Integer) ] 1 { _A_ 0 _N_ _N_ _N_ _N_ _N_ }, [ (Complex Double) ] 1 { _A_ 0 _N_ _N_ _N_ _N_ _N_ } #-}
+__i1 :: Num a => a
+ {-# GHC_PRAGMA _A_ 1 _U_ 1 _N_ _S_ "U(AAAAAAAAAS)" {_A_ 1 _U_ 1 _N_ _N_ _N_ _N_} _N_ _SPECIALISE_ [ Double ] 1 { _A_ 0 _N_ _N_ _N_ _F_ _IF_ARGS_ 0 0 X 2 _!_ D# [] [1.0000000000000000##] _N_ }, [ Int ] 1 { _A_ 0 _N_ _N_ _N_ _F_ _IF_ARGS_ 0 0 X 2 _!_ I# [] [1#] _N_ }, [ Integer ] 1 { _A_ 0 _N_ _N_ _N_ _N_ _N_ }, [ (Ratio Integer) ] 1 { _A_ 0 _N_ _N_ _N_ _N_ _N_ }, [ (Complex Double) ] 1 { _A_ 0 _N_ _N_ _N_ _N_ _N_ } #-}
+__i10 :: Num a => a
+ {-# GHC_PRAGMA _A_ 1 _U_ 1 _N_ _S_ "U(AAAAAAAAAS)" {_A_ 1 _U_ 1 _N_ _N_ _N_ _N_} _N_ _SPECIALISE_ [ Double ] 1 { _A_ 0 _N_ _N_ _N_ _F_ _IF_ARGS_ 0 0 X 2 _!_ D# [] [10.000000000000000##] _N_ }, [ Int ] 1 { _A_ 0 _N_ _N_ _N_ _F_ _IF_ARGS_ 0 0 X 2 _!_ I# [] [10#] _N_ }, [ Integer ] 1 { _A_ 0 _N_ _N_ _N_ _N_ _N_ }, [ (Ratio Integer) ] 1 { _A_ 0 _N_ _N_ _N_ _N_ _N_ }, [ (Complex Double) ] 1 { _A_ 0 _N_ _N_ _N_ _N_ _N_ } #-}
+__i16 :: Num a => a
+ {-# GHC_PRAGMA _A_ 1 _U_ 1 _N_ _S_ "U(AAAAAAAAAS)" {_A_ 1 _U_ 1 _N_ _N_ _N_ _N_} _N_ _SPECIALISE_ [ Double ] 1 { _A_ 0 _N_ _N_ _N_ _F_ _IF_ARGS_ 0 0 X 2 _!_ D# [] [16.000000000000000##] _N_ }, [ Int ] 1 { _A_ 0 _N_ _N_ _N_ _F_ _IF_ARGS_ 0 0 X 2 _!_ I# [] [16#] _N_ }, [ Integer ] 1 { _A_ 0 _N_ _N_ _N_ _N_ _N_ }, [ (Ratio Integer) ] 1 { _A_ 0 _N_ _N_ _N_ _N_ _N_ }, [ (Complex Double) ] 1 { _A_ 0 _N_ _N_ _N_ _N_ _N_ } #-}
+__i2 :: Num a => a
+ {-# GHC_PRAGMA _A_ 1 _U_ 1 _N_ _S_ "U(AAAAAAAAAS)" {_A_ 1 _U_ 1 _N_ _N_ _N_ _N_} _N_ _SPECIALISE_ [ Double ] 1 { _A_ 0 _N_ _N_ _N_ _F_ _IF_ARGS_ 0 0 X 2 _!_ D# [] [2.0000000000000000##] _N_ }, [ Int ] 1 { _A_ 0 _N_ _N_ _N_ _F_ _IF_ARGS_ 0 0 X 2 _!_ I# [] [2#] _N_ }, [ Integer ] 1 { _A_ 0 _N_ _N_ _N_ _N_ _N_ }, [ (Ratio Integer) ] 1 { _A_ 0 _N_ _N_ _N_ _N_ _N_ }, [ (Complex Double) ] 1 { _A_ 0 _N_ _N_ _N_ _N_ _N_ } #-}
+__i8 :: Num a => a
+ {-# GHC_PRAGMA _A_ 1 _U_ 1 _N_ _S_ "U(AAAAAAAAAS)" {_A_ 1 _U_ 1 _N_ _N_ _N_ _N_} _N_ _SPECIALISE_ [ Double ] 1 { _A_ 0 _N_ _N_ _N_ _F_ _IF_ARGS_ 0 0 X 2 _!_ D# [] [8.0000000000000000##] _N_ }, [ Int ] 1 { _A_ 0 _N_ _N_ _N_ _F_ _IF_ARGS_ 0 0 X 2 _!_ I# [] [8#] _N_ }, [ Integer ] 1 { _A_ 0 _N_ _N_ _N_ _N_ _N_ }, [ (Ratio Integer) ] 1 { _A_ 0 _N_ _N_ _N_ _N_ _N_ }, [ (Complex Double) ] 1 { _A_ 0 _N_ _N_ _N_ _N_ _N_ } #-}
+__im1 :: Num a => a
+ {-# GHC_PRAGMA _A_ 1 _U_ 1 _N_ _S_ "U(AAAAAAAAAS)" {_A_ 1 _U_ 1 _N_ _N_ _N_ _N_} _N_ _SPECIALISE_ [ Double ] 1 { _A_ 0 _N_ _N_ _N_ _F_ _IF_ARGS_ 0 0 X 2 _!_ D# [] [-1.0000000000000000##] _N_ }, [ Int ] 1 { _A_ 0 _N_ _N_ _N_ _F_ _IF_ARGS_ 0 0 X 2 _!_ I# [] [-1#] _N_ }, [ Integer ] 1 { _A_ 0 _N_ _N_ _N_ _N_ _N_ }, [ (Ratio Integer) ] 1 { _A_ 0 _N_ _N_ _N_ _N_ _N_ }, [ (Complex Double) ] 1 { _A_ 0 _N_ _N_ _N_ _N_ _N_ } #-}
+__integer0 :: Integer
+ {-# GHC_PRAGMA _A_ 0 _N_ _N_ _N_ _N_ _N_ #-}
+__integer1 :: Integer
+ {-# GHC_PRAGMA _A_ 0 _N_ _N_ _N_ _N_ _N_ #-}
+__integer2 :: Integer
+ {-# GHC_PRAGMA _A_ 0 _N_ _N_ _N_ _N_ _N_ #-}
+__integerm1 :: Integer
+ {-# GHC_PRAGMA _A_ 0 _N_ _N_ _N_ _N_ _N_ #-}
+__rhalf :: Fractional a => a
+ {-# GHC_PRAGMA _A_ 1 _U_ 1 _N_ _S_ "U(AAAS)" {_A_ 1 _U_ 1 _N_ _N_ _N_ _N_} _N_ _SPECIALISE_ [ Double ] 1 { _A_ 0 _N_ _N_ _N_ _N_ _N_ }, [ (Ratio Integer) ] 1 { _A_ 0 _N_ _N_ _N_ _F_ _IF_ARGS_ 0 0 X 3 _!_ (:%) [Integer] [_SPEC_ _ORIG_ PreludeCore __i1 [ (Integer) ], _SPEC_ _ORIG_ PreludeCore __i2 [ (Integer) ]] _N_ }, [ (Complex Double) ] 1 { _A_ 0 _N_ _N_ _N_ _N_ _N_ } #-}
+_fromRational :: RealFloat a => Ratio Integer -> a
+ {-# GHC_PRAGMA _A_ 2 _U_ 22 _N_ _N_ _N_ _SPECIALISE_ [ Double ] 1 { _A_ 1 _U_ 1 _N_ _S_ "U(U(PPP)U(PPP))" {_A_ 4 _U_ 2221 _N_ _N_ _N_ _N_} _N_ _N_ } #-}
instance Enum ()
{-# GHC_PRAGMA _M_ PreludeBuiltin {-dfun-} _A_ 0 _N_ _N_ _N_ _F_ _IF_ARGS_ 0 0 X 6 _!_ _TUP_5 [{{Ord ()}}, (() -> [()]), (() -> () -> [()]), (() -> () -> [()]), (() -> () -> () -> [()])] [_DFUN_ Ord (()), _CONSTM_ Enum enumFrom (()), _CONSTM_ Enum enumFromThen (()), _CONSTM_ Enum enumFromTo (()), _CONSTM_ Enum enumFromThenTo (())] _N_
- enumFrom = _A_ 1 _U_ 2 _N_ _S_ "E" _N_ _N_,
- enumFromThen = _A_ 2 _U_ 21 _N_ _S_ "EE" _F_ _IF_ARGS_ 0 2 CC 7 \ (u0 :: ()) (u1 :: ()) -> case u0 of { _ALG_ _TUP_0 -> case u1 of { _ALG_ _TUP_0 -> let {(u2 :: [()]) = _!_ _NIL_ [()] []} in _!_ (:) [()] [u0, u2]; _NO_DEFLT_ }; _NO_DEFLT_ } _N_,
- enumFromTo = _A_ 2 _U_ 21 _N_ _S_ "EE" _F_ _IF_ARGS_ 0 2 CC 7 \ (u0 :: ()) (u1 :: ()) -> case u0 of { _ALG_ _TUP_0 -> case u1 of { _ALG_ _TUP_0 -> let {(u2 :: [()]) = _!_ _NIL_ [()] []} in _!_ (:) [()] [u0, u2]; _NO_DEFLT_ }; _NO_DEFLT_ } _N_,
- enumFromThenTo = _A_ 3 _U_ 211 _N_ _S_ "EEE" _F_ _IF_ARGS_ 0 3 CCC 8 \ (u0 :: ()) (u1 :: ()) (u2 :: ()) -> case u0 of { _ALG_ _TUP_0 -> case u1 of { _ALG_ _TUP_0 -> case u2 of { _ALG_ _TUP_0 -> let {(u3 :: [()]) = _!_ _NIL_ [()] []} in _!_ (:) [()] [u0, u3]; _NO_DEFLT_ }; _NO_DEFLT_ }; _NO_DEFLT_ } _N_ #-}
+ enumFrom = { _A_ 1 _U_ 2 _N_ _S_ "E" _N_ _N_ },
+ enumFromThen = { _A_ 2 _U_ 21 _N_ _S_ "EE" _F_ _IF_ARGS_ 0 2 CC 7 \ (u0 :: ()) (u1 :: ()) -> case u0 of { _ALG_ _TUP_0 -> case u1 of { _ALG_ _TUP_0 -> let {(u2 :: [()]) = _!_ _NIL_ [()] []} in _!_ (:) [()] [u0, u2]; _NO_DEFLT_ }; _NO_DEFLT_ } _N_ },
+ enumFromTo = { _A_ 2 _U_ 21 _N_ _S_ "EE" _F_ _IF_ARGS_ 0 2 CC 7 \ (u0 :: ()) (u1 :: ()) -> case u0 of { _ALG_ _TUP_0 -> case u1 of { _ALG_ _TUP_0 -> let {(u2 :: [()]) = _!_ _NIL_ [()] []} in _!_ (:) [()] [u0, u2]; _NO_DEFLT_ }; _NO_DEFLT_ } _N_ },
+ enumFromThenTo = { _A_ 3 _U_ 211 _N_ _S_ "EEE" _F_ _IF_ARGS_ 0 3 CCC 8 \ (u0 :: ()) (u1 :: ()) (u2 :: ()) -> case u0 of { _ALG_ _TUP_0 -> case u1 of { _ALG_ _TUP_0 -> case u2 of { _ALG_ _TUP_0 -> let {(u3 :: [()]) = _!_ _NIL_ [()] []} in _!_ (:) [()] [u0, u3]; _NO_DEFLT_ }; _NO_DEFLT_ }; _NO_DEFLT_ } _N_ } #-}
instance Enum Bool
{-# GHC_PRAGMA _M_ PreludeCore {-dfun-} _A_ 0 _N_ _N_ _N_ _F_ _IF_ARGS_ 0 0 X 6 _!_ _TUP_5 [{{Ord Bool}}, (Bool -> [Bool]), (Bool -> Bool -> [Bool]), (Bool -> Bool -> [Bool]), (Bool -> Bool -> Bool -> [Bool])] [_DFUN_ Ord (Bool), _CONSTM_ Enum enumFrom (Bool), _CONSTM_ Enum enumFromThen (Bool), _CONSTM_ Enum enumFromTo (Bool), _CONSTM_ Enum enumFromThenTo (Bool)] _N_
- enumFrom = _A_ 1 _U_ 2 _N_ _S_ "E" _N_ _N_,
- enumFromThen = _A_ 2 _U_ 22 _N_ _S_ "EE" _N_ _N_,
- enumFromTo = _A_ 2 _U_ 22 _N_ _N_ _N_ _N_,
- enumFromThenTo = _A_ 3 _U_ 222 _N_ _N_ _N_ _N_ #-}
+ enumFrom = { _A_ 1 _U_ 2 _N_ _S_ "E" _N_ _N_ },
+ enumFromThen = { _A_ 2 _U_ 22 _N_ _S_ "EE" _N_ _N_ },
+ enumFromTo = { _A_ 2 _U_ 22 _N_ _S_ "EL" _N_ _N_ },
+ enumFromThenTo = { _A_ 3 _U_ 222 _N_ _S_ "EEL" _N_ _N_ } #-}
instance Enum Char
{-# GHC_PRAGMA _M_ PreludeCore {-dfun-} _A_ 0 _N_ _N_ _N_ _F_ _IF_ARGS_ 0 0 X 6 _!_ _TUP_5 [{{Ord Char}}, (Char -> [Char]), (Char -> Char -> [Char]), (Char -> Char -> [Char]), (Char -> Char -> Char -> [Char])] [_DFUN_ Ord (Char), _CONSTM_ Enum enumFrom (Char), _CONSTM_ Enum enumFromThen (Char), _CONSTM_ Enum enumFromTo (Char), _CONSTM_ Enum enumFromThenTo (Char)] _N_
- enumFrom = _A_ 1 _U_ 1 _N_ _S_ "U(P)" {_A_ 1 _U_ 2 _N_ _N_ _N_ _N_} _N_ _N_,
- enumFromThen = _A_ 2 _U_ 22 _N_ _N_ _N_ _N_,
- enumFromTo = _A_ 2 _U_ 22 _N_ _N_ _N_ _N_,
- enumFromThenTo = _A_ 3 _U_ 222 _N_ _N_ _N_ _N_ #-}
+ enumFrom = { _A_ 1 _U_ 1 _N_ _S_ "U(P)" {_A_ 1 _U_ 2 _N_ _N_ _N_ _N_} _N_ _N_ },
+ enumFromThen = { _A_ 2 _U_ 22 _N_ _N_ _N_ _N_ },
+ enumFromTo = { _A_ 2 _U_ 12 _N_ _S_ "U(P)L" {_A_ 2 _U_ 22 _N_ _N_ _N_ _N_} _N_ _N_ },
+ enumFromThenTo = { _A_ 3 _U_ 222 _N_ _N_ _N_ _N_ } #-}
instance Enum Double
{-# GHC_PRAGMA _M_ PreludeCore {-dfun-} _A_ 0 _N_ _N_ _N_ _F_ _IF_ARGS_ 0 0 X 6 _!_ _TUP_5 [{{Ord Double}}, (Double -> [Double]), (Double -> Double -> [Double]), (Double -> Double -> [Double]), (Double -> Double -> Double -> [Double])] [_DFUN_ Ord (Double), _CONSTM_ Enum enumFrom (Double), _CONSTM_ Enum enumFromThen (Double), _CONSTM_ Enum enumFromTo (Double), _CONSTM_ Enum enumFromThenTo (Double)] _N_
- enumFrom = _A_ 1 _U_ 2 _N_ _N_ _N_ _N_,
- enumFromThen = _A_ 2 _U_ 21 _N_ _N_ _N_ _N_,
- enumFromTo = _A_ 2 _U_ 22 _N_ _N_ _N_ _N_,
- enumFromThenTo = _A_ 3 _U_ 222 _N_ _N_ _N_ _N_ #-}
+ enumFrom = { _A_ 1 _U_ 2 _N_ _N_ _N_ _N_ },
+ enumFromThen = { _A_ 2 _U_ 21 _N_ _N_ _N_ _N_ },
+ enumFromTo = { _A_ 2 _U_ 22 _N_ _N_ _N_ _N_ },
+ enumFromThenTo = { _A_ 3 _U_ 222 _N_ _N_ _N_ _N_ } #-}
instance Enum Float
{-# GHC_PRAGMA _M_ PreludeCore {-dfun-} _A_ 0 _N_ _N_ _N_ _F_ _IF_ARGS_ 0 0 X 6 _!_ _TUP_5 [{{Ord Float}}, (Float -> [Float]), (Float -> Float -> [Float]), (Float -> Float -> [Float]), (Float -> Float -> Float -> [Float])] [_DFUN_ Ord (Float), _CONSTM_ Enum enumFrom (Float), _CONSTM_ Enum enumFromThen (Float), _CONSTM_ Enum enumFromTo (Float), _CONSTM_ Enum enumFromThenTo (Float)] _N_
- enumFrom = _A_ 1 _U_ 2 _N_ _N_ _N_ _N_,
- enumFromThen = _A_ 2 _U_ 21 _N_ _N_ _N_ _N_,
- enumFromTo = _A_ 2 _U_ 22 _N_ _N_ _N_ _N_,
- enumFromThenTo = _A_ 3 _U_ 222 _N_ _N_ _N_ _N_ #-}
+ enumFrom = { _A_ 1 _U_ 2 _N_ _N_ _N_ _N_ },
+ enumFromThen = { _A_ 2 _U_ 21 _N_ _N_ _N_ _N_ },
+ enumFromTo = { _A_ 2 _U_ 22 _N_ _N_ _N_ _N_ },
+ enumFromThenTo = { _A_ 3 _U_ 222 _N_ _N_ _N_ _N_ } #-}
instance Enum Int
{-# GHC_PRAGMA _M_ PreludeCore {-dfun-} _A_ 0 _N_ _N_ _N_ _F_ _IF_ARGS_ 0 0 X 6 _!_ _TUP_5 [{{Ord Int}}, (Int -> [Int]), (Int -> Int -> [Int]), (Int -> Int -> [Int]), (Int -> Int -> Int -> [Int])] [_DFUN_ Ord (Int), _CONSTM_ Enum enumFrom (Int), _CONSTM_ Enum enumFromThen (Int), _CONSTM_ Enum enumFromTo (Int), _CONSTM_ Enum enumFromThenTo (Int)] _N_
- enumFrom = _A_ 1 _U_ 2 _N_ _N_ _F_ _ALWAYS_ \ (u0 :: Int) -> _LETREC_ {(u1 :: Int -> [Int]) = \ (u2 :: Int) -> let {(u6 :: [Int]) = let {(u5 :: Int) = case u2 of { _ALG_ I# (u3 :: Int#) -> case _#_ plusInt# [] [u3, 1#] of { _PRIM_ (u4 :: Int#) -> _!_ I# [] [u4] }; _NO_DEFLT_ }} in _APP_ u1 [ u5 ]} in _!_ (:) [Int] [u2, u6]} in _APP_ u1 [ u0 ] _N_,
- enumFromThen = _A_ 2 _U_ 21 _N_ _N_ _N_ _N_,
- enumFromTo = _A_ 2 _U_ 12 _N_ _S_ "SS" _F_ _ALWAYS_ \ (u0 :: Int) (u1 :: Int) -> case u0 of { _ALG_ I# (u2 :: Int#) -> _LETREC_ {(u3 :: Int# -> [Int]) = \ (u4 :: Int#) -> case u1 of { _ALG_ I# (u5 :: Int#) -> case _#_ leInt# [] [u4, u5] of { _ALG_ True -> let {(u7 :: [Int]) = case _#_ plusInt# [] [u4, 1#] of { _PRIM_ (u6 :: Int#) -> _APP_ u3 [ u6 ] }} in let {(u8 :: Int) = _!_ I# [] [u4]} in _!_ (:) [Int] [u8, u7]; False -> _!_ _NIL_ [Int] []; _NO_DEFLT_ }; _NO_DEFLT_ }} in _APP_ u3 [ u2 ]; _NO_DEFLT_ } _N_,
- enumFromThenTo = _A_ 3 _U_ 222 _N_ _N_ _N_ _N_ #-}
+ enumFrom = { _A_ 1 _U_ 2 _N_ _N_ _F_ _ALWAYS_ \ (u0 :: Int) -> _LETREC_ {(u1 :: Int -> [Int]) = \ (u2 :: Int) -> let {(u6 :: [Int]) = let {(u5 :: Int) = case u2 of { _ALG_ I# (u3 :: Int#) -> case _#_ plusInt# [] [u3, 1#] of { _PRIM_ (u4 :: Int#) -> _!_ I# [] [u4] }; _NO_DEFLT_ }} in _APP_ u1 [ u5 ]} in _!_ (:) [Int] [u2, u6]} in _APP_ u1 [ u0 ] _N_ },
+ enumFromThen = { _A_ 2 _U_ 21 _N_ _N_ _N_ _N_ },
+ enumFromTo = { _A_ 2 _U_ 12 _N_ _S_ "SS" _F_ _ALWAYS_ \ (u0 :: Int) (u1 :: Int) -> case u0 of { _ALG_ I# (u2 :: Int#) -> _LETREC_ {(u3 :: Int# -> [Int]) = \ (u4 :: Int#) -> case u1 of { _ALG_ I# (u5 :: Int#) -> case _#_ leInt# [] [u4, u5] of { _ALG_ True -> let {(u7 :: [Int]) = case _#_ plusInt# [] [u4, 1#] of { _PRIM_ (u6 :: Int#) -> _APP_ u3 [ u6 ] }} in let {(u8 :: Int) = _!_ I# [] [u4]} in _!_ (:) [Int] [u8, u7]; False -> _!_ _NIL_ [Int] []; _NO_DEFLT_ }; _NO_DEFLT_ }} in _APP_ u3 [ u2 ]; _NO_DEFLT_ } _N_ },
+ enumFromThenTo = { _A_ 3 _U_ 222 _N_ _N_ _N_ _N_ } #-}
instance Enum Integer
{-# GHC_PRAGMA _M_ PreludeCore {-dfun-} _A_ 0 _N_ _N_ _N_ _F_ _IF_ARGS_ 0 0 X 6 _!_ _TUP_5 [{{Ord Integer}}, (Integer -> [Integer]), (Integer -> Integer -> [Integer]), (Integer -> Integer -> [Integer]), (Integer -> Integer -> Integer -> [Integer])] [_DFUN_ Ord (Integer), _CONSTM_ Enum enumFrom (Integer), _CONSTM_ Enum enumFromThen (Integer), _CONSTM_ Enum enumFromTo (Integer), _CONSTM_ Enum enumFromThenTo (Integer)] _N_
- enumFrom = _A_ 1 _U_ 2 _N_ _N_ _N_ _N_,
- enumFromThen = _A_ 2 _U_ 21 _N_ _N_ _N_ _N_,
- enumFromTo = _A_ 2 _U_ 22 _N_ _N_ _N_ _N_,
- enumFromThenTo = _A_ 3 _U_ 222 _N_ _N_ _N_ _N_ #-}
+ enumFrom = { _A_ 1 _U_ 2 _N_ _N_ _N_ _N_ },
+ enumFromThen = { _A_ 2 _U_ 21 _N_ _N_ _N_ _N_ },
+ enumFromTo = { _A_ 2 _U_ 22 _N_ _N_ _N_ _N_ },
+ enumFromThenTo = { _A_ 3 _U_ 222 _N_ _N_ _N_ _N_ } #-}
instance Integral a => Enum (Ratio a)
{-# GHC_PRAGMA _M_ PreludeRatio {-dfun-} _A_ 2 _U_ 22 _N_ _N_ _N_ _N_ #-}
instance Enum (Ratio Integer)
{-# GHC_PRAGMA _M_ PreludeRatio {-dfun-} _A_ 0 _N_ _N_ _N_ _F_ _IF_ARGS_ 0 0 X 6 _!_ _TUP_5 [{{Ord (Ratio Integer)}}, (Ratio Integer -> [Ratio Integer]), (Ratio Integer -> Ratio Integer -> [Ratio Integer]), (Ratio Integer -> Ratio Integer -> [Ratio Integer]), (Ratio Integer -> Ratio Integer -> Ratio Integer -> [Ratio Integer])] [_DFUN_ Ord (Ratio Integer), _CONSTM_ Enum enumFrom (Ratio Integer), _CONSTM_ Enum enumFromThen (Ratio Integer), _CONSTM_ Enum enumFromTo (Ratio Integer), _CONSTM_ Enum enumFromThenTo (Ratio Integer)] _N_
- enumFrom = _A_ 1 _U_ 2 _N_ _N_ _N_ _N_,
- enumFromThen = _A_ 2 _U_ 21 _N_ _N_ _N_ _N_,
- enumFromTo = _A_ 2 _U_ 22 _N_ _N_ _N_ _N_,
- enumFromThenTo = _A_ 3 _U_ 222 _N_ _N_ _N_ _N_ #-}
+ enumFrom = { _A_ 1 _U_ 2 _N_ _N_ _N_ _N_ },
+ enumFromThen = { _A_ 2 _U_ 21 _N_ _N_ _N_ _N_ },
+ enumFromTo = { _A_ 2 _U_ 22 _N_ _N_ _N_ _N_ },
+ enumFromThenTo = { _A_ 3 _U_ 222 _N_ _N_ _N_ _N_ } #-}
instance Eq ()
{-# GHC_PRAGMA _M_ PreludeBuiltin {-dfun-} _A_ 0 _N_ _N_ _N_ _F_ _IF_ARGS_ 0 0 X 3 _!_ _TUP_2 [(() -> () -> Bool), (() -> () -> Bool)] [_CONSTM_ Eq (==) (()), _CONSTM_ Eq (/=) (())] _N_
- (==) = _A_ 2 _U_ 11 _N_ _S_ "EE" _F_ _IF_ARGS_ 0 2 CC 3 \ (u0 :: ()) (u1 :: ()) -> case u0 of { _ALG_ _TUP_0 -> case u1 of { _ALG_ _TUP_0 -> _!_ True [] []; _NO_DEFLT_ }; _NO_DEFLT_ } _N_,
- (/=) = _A_ 2 _U_ 11 _N_ _S_ "EE" _F_ _IF_ARGS_ 0 2 CC 3 \ (u0 :: ()) (u1 :: ()) -> case u0 of { _ALG_ _TUP_0 -> case u1 of { _ALG_ _TUP_0 -> _!_ False [] []; _NO_DEFLT_ }; _NO_DEFLT_ } _N_ #-}
+ (==) = { _A_ 2 _U_ 11 _N_ _S_ "EE" _F_ _IF_ARGS_ 0 2 CC 3 \ (u0 :: ()) (u1 :: ()) -> case u0 of { _ALG_ _TUP_0 -> case u1 of { _ALG_ _TUP_0 -> _!_ True [] []; _NO_DEFLT_ }; _NO_DEFLT_ } _N_ },
+ (/=) = { _A_ 2 _U_ 11 _N_ _S_ "EE" _F_ _IF_ARGS_ 0 2 CC 3 \ (u0 :: ()) (u1 :: ()) -> case u0 of { _ALG_ _TUP_0 -> case u1 of { _ALG_ _TUP_0 -> _!_ False [] []; _NO_DEFLT_ }; _NO_DEFLT_ } _N_ } #-}
instance (Eq a, Eq b) => Eq (a, b)
- {-# GHC_PRAGMA _M_ PreludeBuiltin {-dfun-} _A_ 2 _U_ 11 _N_ _N_ _N_ _N_ #-}
+ {-# GHC_PRAGMA _M_ PreludeBuiltin {-dfun-} _A_ 2 _U_ 22 _N_ _N_ _N_ _N_ #-}
instance (Eq a, Eq b, Eq c) => Eq (a, b, c)
{-# GHC_PRAGMA _M_ PreludeBuiltin {-dfun-} _A_ 3 _U_ 111 _N_ _N_ _N_ _N_ #-}
instance (Eq a, Eq b, Eq c, Eq d) => Eq (a, b, c, d)
{-# GHC_PRAGMA _M_ PreludeBuiltin {-dfun-} _A_ 5 _U_ 11111 _N_ _N_ _N_ _N_ #-}
instance Eq (Int, Int)
{-# GHC_PRAGMA _M_ PreludeBuiltin {-dfun-} _A_ 0 _N_ _N_ _N_ _F_ _IF_ARGS_ 0 0 X 3 _!_ _TUP_2 [((Int, Int) -> (Int, Int) -> Bool), ((Int, Int) -> (Int, Int) -> Bool)] [_CONSTM_ Eq (==) ((Int, Int)), _CONSTM_ Eq (/=) ((Int, Int))] _N_
- (==) = _A_ 2 _U_ 11 _N_ _S_ "U(U(P)L)U(U(P)L)" {_A_ 4 _U_ 2121 _N_ _N_ _F_ _IF_ARGS_ 0 4 XCXC 7 \ (u0 :: Int#) (u1 :: Int) (u2 :: Int#) (u3 :: Int) -> case _#_ eqInt# [] [u0, u2] of { _ALG_ True -> case u1 of { _ALG_ I# (u4 :: Int#) -> case u3 of { _ALG_ I# (u5 :: Int#) -> _#_ eqInt# [] [u4, u5]; _NO_DEFLT_ }; _NO_DEFLT_ }; False -> _!_ False [] []; _NO_DEFLT_ } _N_} _F_ _ALWAYS_ \ (u0 :: (Int, Int)) (u1 :: (Int, Int)) -> case u0 of { _ALG_ _TUP_2 (u2 :: Int) (u3 :: Int) -> case u2 of { _ALG_ I# (u4 :: Int#) -> case u1 of { _ALG_ _TUP_2 (u5 :: Int) (u6 :: Int) -> case u5 of { _ALG_ I# (u7 :: Int#) -> case _#_ eqInt# [] [u4, u7] of { _ALG_ True -> case u3 of { _ALG_ I# (u8 :: Int#) -> case u6 of { _ALG_ I# (u9 :: Int#) -> _#_ eqInt# [] [u8, u9]; _NO_DEFLT_ }; _NO_DEFLT_ }; False -> _!_ False [] []; _NO_DEFLT_ }; _NO_DEFLT_ }; _NO_DEFLT_ }; _NO_DEFLT_ }; _NO_DEFLT_ } _N_,
- (/=) = _A_ 2 _U_ 22 _N_ _N_ _N_ _N_ #-}
+ (==) = { _A_ 2 _U_ 11 _N_ _S_ "U(U(P)L)U(U(P)L)" {_A_ 4 _U_ 2121 _N_ _N_ _F_ _IF_ARGS_ 0 4 XCXC 7 \ (u0 :: Int#) (u1 :: Int) (u2 :: Int#) (u3 :: Int) -> case _#_ eqInt# [] [u0, u2] of { _ALG_ True -> case u1 of { _ALG_ I# (u4 :: Int#) -> case u3 of { _ALG_ I# (u5 :: Int#) -> _#_ eqInt# [] [u4, u5]; _NO_DEFLT_ }; _NO_DEFLT_ }; False -> _!_ False [] []; _NO_DEFLT_ } _N_} _F_ _ALWAYS_ \ (u0 :: (Int, Int)) (u1 :: (Int, Int)) -> case u0 of { _ALG_ _TUP_2 (u2 :: Int) (u3 :: Int) -> case u2 of { _ALG_ I# (u4 :: Int#) -> case u1 of { _ALG_ _TUP_2 (u5 :: Int) (u6 :: Int) -> case u5 of { _ALG_ I# (u7 :: Int#) -> case _#_ eqInt# [] [u4, u7] of { _ALG_ True -> case u3 of { _ALG_ I# (u8 :: Int#) -> case u6 of { _ALG_ I# (u9 :: Int#) -> _#_ eqInt# [] [u8, u9]; _NO_DEFLT_ }; _NO_DEFLT_ }; False -> _!_ False [] []; _NO_DEFLT_ }; _NO_DEFLT_ }; _NO_DEFLT_ }; _NO_DEFLT_ }; _NO_DEFLT_ } _N_ },
+ (/=) = { _A_ 2 _U_ 11 _N_ _S_ "U(U(P)L)U(U(P)L)" {_A_ 4 _U_ 2121 _N_ _N_ _F_ _IF_ARGS_ 0 4 XCXC 7 \ (u0 :: Int#) (u1 :: Int) (u2 :: Int#) (u3 :: Int) -> case _#_ neInt# [] [u0, u2] of { _ALG_ True -> _!_ True [] []; False -> case u1 of { _ALG_ I# (u4 :: Int#) -> case u3 of { _ALG_ I# (u5 :: Int#) -> _#_ neInt# [] [u4, u5]; _NO_DEFLT_ }; _NO_DEFLT_ }; _NO_DEFLT_ } _N_} _F_ _ALWAYS_ \ (u0 :: (Int, Int)) (u1 :: (Int, Int)) -> case u0 of { _ALG_ _TUP_2 (u2 :: Int) (u3 :: Int) -> case u2 of { _ALG_ I# (u4 :: Int#) -> case u1 of { _ALG_ _TUP_2 (u5 :: Int) (u6 :: Int) -> case u5 of { _ALG_ I# (u7 :: Int#) -> case _#_ neInt# [] [u4, u7] of { _ALG_ True -> _!_ True [] []; False -> case u3 of { _ALG_ I# (u8 :: Int#) -> case u6 of { _ALG_ I# (u9 :: Int#) -> _#_ neInt# [] [u8, u9]; _NO_DEFLT_ }; _NO_DEFLT_ }; _NO_DEFLT_ }; _NO_DEFLT_ }; _NO_DEFLT_ }; _NO_DEFLT_ }; _NO_DEFLT_ } _N_ } #-}
+instance Eq (Int, Int, Int)
+ {-# GHC_PRAGMA _M_ PreludeBuiltin {-dfun-} _A_ 0 _N_ _N_ _N_ _F_ _IF_ARGS_ 0 0 X 3 _!_ _TUP_2 [((Int, Int, Int) -> (Int, Int, Int) -> Bool), ((Int, Int, Int) -> (Int, Int, Int) -> Bool)] [_CONSTM_ Eq (==) ((Int, Int, Int)), _CONSTM_ Eq (/=) ((Int, Int, Int))] _N_
+ (==) = { _A_ 2 _U_ 11 _N_ _S_ "U(U(P)LL)U(U(P)LL)" {_A_ 4 _U_ 2111 _N_ _N_ _N_ _N_} _N_ _N_ },
+ (/=) = { _A_ 2 _U_ 11 _N_ _S_ "U(U(P)LL)U(U(P)LL)" {_A_ 4 _U_ 2111 _N_ _N_ _N_ _N_} _N_ _N_ } #-}
+instance Eq (Int, Int, Int, Int)
+ {-# GHC_PRAGMA _M_ PreludeBuiltin {-dfun-} _A_ 0 _N_ _N_ _N_ _F_ _IF_ARGS_ 0 0 X 3 _!_ _TUP_2 [((Int, Int, Int, Int) -> (Int, Int, Int, Int) -> Bool), ((Int, Int, Int, Int) -> (Int, Int, Int, Int) -> Bool)] [_CONSTM_ Eq (==) ((Int, Int, Int, Int)), _CONSTM_ Eq (/=) ((Int, Int, Int, Int))] _N_
+ (==) = { _A_ 2 _U_ 11 _N_ _S_ "U(U(P)LLL)U(U(P)LLL)" {_A_ 5 _U_ 21111 _N_ _N_ _N_ _N_} _N_ _N_ },
+ (/=) = { _A_ 2 _U_ 11 _N_ _S_ "U(U(P)LLL)U(U(P)LLL)" {_A_ 5 _U_ 21111 _N_ _N_ _N_ _N_} _N_ _N_ } #-}
+instance Eq (Int, Int, Int, Int, Int)
+ {-# GHC_PRAGMA _M_ PreludeBuiltin {-dfun-} _A_ 0 _N_ _N_ _N_ _F_ _IF_ARGS_ 0 0 X 3 _!_ _TUP_2 [((Int, Int, Int, Int, Int) -> (Int, Int, Int, Int, Int) -> Bool), ((Int, Int, Int, Int, Int) -> (Int, Int, Int, Int, Int) -> Bool)] [_CONSTM_ Eq (==) ((Int, Int, Int, Int, Int)), _CONSTM_ Eq (/=) ((Int, Int, Int, Int, Int))] _N_
+ (==) = { _A_ 2 _U_ 11 _N_ _S_ "U(U(P)LLLL)U(U(P)LLLL)" _N_ _N_ },
+ (/=) = { _A_ 2 _U_ 11 _N_ _S_ "U(U(P)LLLL)U(U(P)LLLL)" _N_ _N_ } #-}
+instance Eq ([Char], [Char])
+ {-# GHC_PRAGMA _M_ PreludeBuiltin {-dfun-} _A_ 0 _N_ _N_ _N_ _F_ _IF_ARGS_ 0 0 X 3 _!_ _TUP_2 [(([Char], [Char]) -> ([Char], [Char]) -> Bool), (([Char], [Char]) -> ([Char], [Char]) -> Bool)] [_CONSTM_ Eq (==) (([Char], [Char])), _CONSTM_ Eq (/=) (([Char], [Char]))] _N_
+ (==) = { _A_ 2 _U_ 11 _N_ _S_ "U(SL)U(SL)" {_A_ 4 _U_ 2222 _N_ _N_ _N_ _N_} _N_ _N_ },
+ (/=) = { _A_ 2 _U_ 11 _N_ _S_ "U(SL)U(SL)" {_A_ 4 _U_ 2222 _N_ _N_ _N_ _N_} _N_ _N_ } #-}
+instance Eq ([Int], [Int])
+ {-# GHC_PRAGMA _M_ PreludeBuiltin {-dfun-} _A_ 0 _N_ _N_ _N_ _F_ _IF_ARGS_ 0 0 X 3 _!_ _TUP_2 [(([Int], [Int]) -> ([Int], [Int]) -> Bool), (([Int], [Int]) -> ([Int], [Int]) -> Bool)] [_CONSTM_ Eq (==) (([Int], [Int])), _CONSTM_ Eq (/=) (([Int], [Int]))] _N_
+ (==) = { _A_ 2 _U_ 11 _N_ _S_ "U(SL)U(SL)" {_A_ 4 _U_ 2222 _N_ _N_ _N_ _N_} _N_ _N_ },
+ (/=) = { _A_ 2 _U_ 11 _N_ _S_ "U(SL)U(SL)" {_A_ 4 _U_ 2222 _N_ _N_ _N_ _N_} _N_ _N_ } #-}
instance Eq (_PackedString, _PackedString)
{-# GHC_PRAGMA _M_ PreludeBuiltin {-dfun-} _A_ 0 _N_ _N_ _N_ _F_ _IF_ARGS_ 0 0 X 3 _!_ _TUP_2 [((_PackedString, _PackedString) -> (_PackedString, _PackedString) -> Bool), ((_PackedString, _PackedString) -> (_PackedString, _PackedString) -> Bool)] [_CONSTM_ Eq (==) ((_PackedString, _PackedString)), _CONSTM_ Eq (/=) ((_PackedString, _PackedString))] _N_
- (==) = _A_ 2 _U_ 11 _N_ _S_ "U(SL)U(SL)" {_A_ 4 _U_ 2222 _N_ _N_ _N_ _N_} _N_ _N_,
- (/=) = _A_ 2 _U_ 22 _N_ _N_ _N_ _N_ #-}
+ (==) = { _A_ 2 _U_ 11 _N_ _S_ "U(SL)U(SL)" {_A_ 4 _U_ 2222 _N_ _N_ _N_ _N_} _N_ _N_ },
+ (/=) = { _A_ 2 _U_ 11 _N_ _S_ "U(SL)U(SL)" {_A_ 4 _U_ 2222 _N_ _N_ _N_ _N_} _N_ _N_ } #-}
instance (Ix a, Eq b) => Eq (Array a b)
{-# GHC_PRAGMA _M_ PreludeArray {-dfun-} _A_ 2 _U_ 21 _N_ _N_ _N_ _N_ #-}
instance (Eq a, Eq b) => Eq (Assoc a b)
{-# GHC_PRAGMA _M_ PreludeArray {-dfun-} _A_ 2 _U_ 11 _N_ _N_ _N_ _N_ #-}
instance Eq Bool
{-# GHC_PRAGMA _M_ PreludeCore {-dfun-} _A_ 0 _N_ _N_ _N_ _F_ _IF_ARGS_ 0 0 X 3 _!_ _TUP_2 [(Bool -> Bool -> Bool), (Bool -> Bool -> Bool)] [_CONSTM_ Eq (==) (Bool), _CONSTM_ Eq (/=) (Bool)] _N_
- (==) = _A_ 2 _U_ 11 _N_ _S_ "EE" _F_ _IF_ARGS_ 0 2 CC 7 \ (u0 :: Bool) (u1 :: Bool) -> case u0 of { _ALG_ True -> u1; False -> case u1 of { _ALG_ True -> _!_ False [] []; False -> _!_ True [] []; _NO_DEFLT_ }; _NO_DEFLT_ } _N_,
- (/=) = _A_ 2 _U_ 11 _N_ _S_ "EE" _F_ _IF_ARGS_ 0 2 CC 7 \ (u0 :: Bool) (u1 :: Bool) -> case u0 of { _ALG_ True -> case u1 of { _ALG_ True -> _!_ False [] []; False -> _!_ True [] []; _NO_DEFLT_ }; False -> u1; _NO_DEFLT_ } _N_ #-}
+ (==) = { _A_ 2 _U_ 11 _N_ _S_ "EE" _F_ _IF_ARGS_ 0 2 CC 7 \ (u0 :: Bool) (u1 :: Bool) -> case u0 of { _ALG_ True -> u1; False -> case u1 of { _ALG_ True -> _!_ False [] []; False -> _!_ True [] []; _NO_DEFLT_ }; _NO_DEFLT_ } _N_ },
+ (/=) = { _A_ 2 _U_ 11 _N_ _S_ "EE" _F_ _IF_ARGS_ 0 2 CC 7 \ (u0 :: Bool) (u1 :: Bool) -> case u0 of { _ALG_ True -> case u1 of { _ALG_ True -> _!_ False [] []; False -> _!_ True [] []; _NO_DEFLT_ }; False -> u1; _NO_DEFLT_ } _N_ } #-}
instance Eq Char
{-# GHC_PRAGMA _M_ PreludeCore {-dfun-} _A_ 0 _N_ _N_ _N_ _F_ _IF_ARGS_ 0 0 X 3 _!_ _TUP_2 [(Char -> Char -> Bool), (Char -> Char -> Bool)] [_CONSTM_ Eq (==) (Char), _CONSTM_ Eq (/=) (Char)] _N_
- (==) = _A_ 2 _U_ 11 _N_ _S_ "U(P)U(P)" {_A_ 2 _U_ 22 _N_ _N_ _F_ _IF_ARGS_ 0 2 XX 1 \ (u0 :: Char#) (u1 :: Char#) -> _#_ eqChar# [] [u0, u1] _N_} _F_ _IF_ARGS_ 0 2 CC 3 \ (u0 :: Char) (u1 :: Char) -> case u0 of { _ALG_ C# (u2 :: Char#) -> case u1 of { _ALG_ C# (u3 :: Char#) -> _#_ eqChar# [] [u2, u3]; _NO_DEFLT_ }; _NO_DEFLT_ } _N_,
- (/=) = _A_ 2 _U_ 11 _N_ _S_ "U(P)U(P)" {_A_ 2 _U_ 22 _N_ _N_ _F_ _IF_ARGS_ 0 2 XX 1 \ (u0 :: Char#) (u1 :: Char#) -> _#_ neChar# [] [u0, u1] _N_} _F_ _IF_ARGS_ 0 2 CC 3 \ (u0 :: Char) (u1 :: Char) -> case u0 of { _ALG_ C# (u2 :: Char#) -> case u1 of { _ALG_ C# (u3 :: Char#) -> _#_ neChar# [] [u2, u3]; _NO_DEFLT_ }; _NO_DEFLT_ } _N_ #-}
+ (==) = { _A_ 2 _U_ 11 _N_ _S_ "U(P)U(P)" {_A_ 2 _U_ 22 _N_ _N_ _F_ _IF_ARGS_ 0 2 XX 1 \ (u0 :: Char#) (u1 :: Char#) -> _#_ eqChar# [] [u0, u1] _N_} _F_ _IF_ARGS_ 0 2 CC 3 \ (u0 :: Char) (u1 :: Char) -> case u0 of { _ALG_ C# (u2 :: Char#) -> case u1 of { _ALG_ C# (u3 :: Char#) -> _#_ eqChar# [] [u2, u3]; _NO_DEFLT_ }; _NO_DEFLT_ } _N_ },
+ (/=) = { _A_ 2 _U_ 11 _N_ _S_ "U(P)U(P)" {_A_ 2 _U_ 22 _N_ _N_ _F_ _IF_ARGS_ 0 2 XX 1 \ (u0 :: Char#) (u1 :: Char#) -> _#_ neChar# [] [u0, u1] _N_} _F_ _IF_ARGS_ 0 2 CC 3 \ (u0 :: Char) (u1 :: Char) -> case u0 of { _ALG_ C# (u2 :: Char#) -> case u1 of { _ALG_ C# (u3 :: Char#) -> _#_ neChar# [] [u2, u3]; _NO_DEFLT_ }; _NO_DEFLT_ } _N_ } #-}
instance Eq a => Eq (Complex a)
{-# GHC_PRAGMA _M_ PreludeComplex {-dfun-} _A_ 1 _U_ 2 _N_ _N_ _N_ _N_ #-}
instance Eq (Complex Double)
{-# GHC_PRAGMA _M_ PreludeComplex {-dfun-} _A_ 0 _N_ _N_ _N_ _F_ _IF_ARGS_ 0 0 X 3 _!_ _TUP_2 [(Complex Double -> Complex Double -> Bool), (Complex Double -> Complex Double -> Bool)] [_CONSTM_ Eq (==) (Complex Double), _CONSTM_ Eq (/=) (Complex Double)] _N_
- (==) = _A_ 2 _U_ 11 _N_ _S_ "U(U(P)L)U(U(P)L)" {_A_ 4 _U_ 2121 _N_ _N_ _F_ _IF_ARGS_ 0 4 XCXC 7 \ (u0 :: Double#) (u1 :: Double) (u2 :: Double#) (u3 :: Double) -> case _#_ eqDouble# [] [u0, u2] of { _ALG_ True -> case u1 of { _ALG_ D# (u4 :: Double#) -> case u3 of { _ALG_ D# (u5 :: Double#) -> _#_ eqDouble# [] [u4, u5]; _NO_DEFLT_ }; _NO_DEFLT_ }; False -> _!_ False [] []; _NO_DEFLT_ } _N_} _F_ _ALWAYS_ \ (u0 :: Complex Double) (u1 :: Complex Double) -> case u0 of { _ALG_ (:+) (u2 :: Double) (u3 :: Double) -> case u2 of { _ALG_ D# (u4 :: Double#) -> case u1 of { _ALG_ (:+) (u5 :: Double) (u6 :: Double) -> case u5 of { _ALG_ D# (u7 :: Double#) -> case _#_ eqDouble# [] [u4, u7] of { _ALG_ True -> case u3 of { _ALG_ D# (u8 :: Double#) -> case u6 of { _ALG_ D# (u9 :: Double#) -> _#_ eqDouble# [] [u8, u9]; _NO_DEFLT_ }; _NO_DEFLT_ }; False -> _!_ False [] []; _NO_DEFLT_ }; _NO_DEFLT_ }; _NO_DEFLT_ }; _NO_DEFLT_ }; _NO_DEFLT_ } _N_,
- (/=) = _A_ 2 _U_ 11 _N_ _S_ "U(U(P)L)U(U(P)L)" {_A_ 4 _U_ 2121 _N_ _N_ _F_ _IF_ARGS_ 0 4 XCXC 7 \ (u0 :: Double#) (u1 :: Double) (u2 :: Double#) (u3 :: Double) -> case _#_ neDouble# [] [u0, u2] of { _ALG_ True -> _!_ True [] []; False -> case u1 of { _ALG_ D# (u4 :: Double#) -> case u3 of { _ALG_ D# (u5 :: Double#) -> _#_ neDouble# [] [u4, u5]; _NO_DEFLT_ }; _NO_DEFLT_ }; _NO_DEFLT_ } _N_} _F_ _ALWAYS_ \ (u0 :: Complex Double) (u1 :: Complex Double) -> case u0 of { _ALG_ (:+) (u2 :: Double) (u3 :: Double) -> case u2 of { _ALG_ D# (u4 :: Double#) -> case u1 of { _ALG_ (:+) (u5 :: Double) (u6 :: Double) -> case u5 of { _ALG_ D# (u7 :: Double#) -> case _#_ neDouble# [] [u4, u7] of { _ALG_ True -> _!_ True [] []; False -> case u3 of { _ALG_ D# (u8 :: Double#) -> case u6 of { _ALG_ D# (u9 :: Double#) -> _#_ neDouble# [] [u8, u9]; _NO_DEFLT_ }; _NO_DEFLT_ }; _NO_DEFLT_ }; _NO_DEFLT_ }; _NO_DEFLT_ }; _NO_DEFLT_ }; _NO_DEFLT_ } _N_ #-}
+ (==) = { _A_ 2 _U_ 11 _N_ _S_ "U(U(P)L)U(U(P)L)" {_A_ 4 _U_ 2121 _N_ _N_ _F_ _IF_ARGS_ 0 4 XCXC 7 \ (u0 :: Double#) (u1 :: Double) (u2 :: Double#) (u3 :: Double) -> case _#_ eqDouble# [] [u0, u2] of { _ALG_ True -> case u1 of { _ALG_ D# (u4 :: Double#) -> case u3 of { _ALG_ D# (u5 :: Double#) -> _#_ eqDouble# [] [u4, u5]; _NO_DEFLT_ }; _NO_DEFLT_ }; False -> _!_ False [] []; _NO_DEFLT_ } _N_} _F_ _ALWAYS_ \ (u0 :: Complex Double) (u1 :: Complex Double) -> case u0 of { _ALG_ (:+) (u2 :: Double) (u3 :: Double) -> case u2 of { _ALG_ D# (u4 :: Double#) -> case u1 of { _ALG_ (:+) (u5 :: Double) (u6 :: Double) -> case u5 of { _ALG_ D# (u7 :: Double#) -> case _#_ eqDouble# [] [u4, u7] of { _ALG_ True -> case u3 of { _ALG_ D# (u8 :: Double#) -> case u6 of { _ALG_ D# (u9 :: Double#) -> _#_ eqDouble# [] [u8, u9]; _NO_DEFLT_ }; _NO_DEFLT_ }; False -> _!_ False [] []; _NO_DEFLT_ }; _NO_DEFLT_ }; _NO_DEFLT_ }; _NO_DEFLT_ }; _NO_DEFLT_ } _N_ },
+ (/=) = { _A_ 2 _U_ 11 _N_ _S_ "U(U(P)L)U(U(P)L)" {_A_ 4 _U_ 2121 _N_ _N_ _F_ _IF_ARGS_ 0 4 XCXC 7 \ (u0 :: Double#) (u1 :: Double) (u2 :: Double#) (u3 :: Double) -> case _#_ neDouble# [] [u0, u2] of { _ALG_ True -> _!_ True [] []; False -> case u1 of { _ALG_ D# (u4 :: Double#) -> case u3 of { _ALG_ D# (u5 :: Double#) -> _#_ neDouble# [] [u4, u5]; _NO_DEFLT_ }; _NO_DEFLT_ }; _NO_DEFLT_ } _N_} _F_ _ALWAYS_ \ (u0 :: Complex Double) (u1 :: Complex Double) -> case u0 of { _ALG_ (:+) (u2 :: Double) (u3 :: Double) -> case u2 of { _ALG_ D# (u4 :: Double#) -> case u1 of { _ALG_ (:+) (u5 :: Double) (u6 :: Double) -> case u5 of { _ALG_ D# (u7 :: Double#) -> case _#_ neDouble# [] [u4, u7] of { _ALG_ True -> _!_ True [] []; False -> case u3 of { _ALG_ D# (u8 :: Double#) -> case u6 of { _ALG_ D# (u9 :: Double#) -> _#_ neDouble# [] [u8, u9]; _NO_DEFLT_ }; _NO_DEFLT_ }; _NO_DEFLT_ }; _NO_DEFLT_ }; _NO_DEFLT_ }; _NO_DEFLT_ }; _NO_DEFLT_ } _N_ } #-}
instance Eq Double
{-# GHC_PRAGMA _M_ PreludeCore {-dfun-} _A_ 0 _N_ _N_ _N_ _F_ _IF_ARGS_ 0 0 X 3 _!_ _TUP_2 [(Double -> Double -> Bool), (Double -> Double -> Bool)] [_CONSTM_ Eq (==) (Double), _CONSTM_ Eq (/=) (Double)] _N_
- (==) = _A_ 2 _U_ 11 _N_ _S_ "U(P)U(P)" {_A_ 2 _U_ 22 _N_ _N_ _F_ _IF_ARGS_ 0 2 XX 1 \ (u0 :: Double#) (u1 :: Double#) -> _#_ eqDouble# [] [u0, u1] _N_} _F_ _IF_ARGS_ 0 2 CC 3 \ (u0 :: Double) (u1 :: Double) -> case u0 of { _ALG_ D# (u2 :: Double#) -> case u1 of { _ALG_ D# (u3 :: Double#) -> _#_ eqDouble# [] [u2, u3]; _NO_DEFLT_ }; _NO_DEFLT_ } _N_,
- (/=) = _A_ 2 _U_ 11 _N_ _S_ "U(P)U(P)" {_A_ 2 _U_ 22 _N_ _N_ _F_ _IF_ARGS_ 0 2 XX 1 \ (u0 :: Double#) (u1 :: Double#) -> _#_ neDouble# [] [u0, u1] _N_} _F_ _IF_ARGS_ 0 2 CC 3 \ (u0 :: Double) (u1 :: Double) -> case u0 of { _ALG_ D# (u2 :: Double#) -> case u1 of { _ALG_ D# (u3 :: Double#) -> _#_ neDouble# [] [u2, u3]; _NO_DEFLT_ }; _NO_DEFLT_ } _N_ #-}
+ (==) = { _A_ 2 _U_ 11 _N_ _S_ "U(P)U(P)" {_A_ 2 _U_ 22 _N_ _N_ _F_ _IF_ARGS_ 0 2 XX 1 \ (u0 :: Double#) (u1 :: Double#) -> _#_ eqDouble# [] [u0, u1] _N_} _F_ _IF_ARGS_ 0 2 CC 3 \ (u0 :: Double) (u1 :: Double) -> case u0 of { _ALG_ D# (u2 :: Double#) -> case u1 of { _ALG_ D# (u3 :: Double#) -> _#_ eqDouble# [] [u2, u3]; _NO_DEFLT_ }; _NO_DEFLT_ } _N_ },
+ (/=) = { _A_ 2 _U_ 11 _N_ _S_ "U(P)U(P)" {_A_ 2 _U_ 22 _N_ _N_ _F_ _IF_ARGS_ 0 2 XX 1 \ (u0 :: Double#) (u1 :: Double#) -> _#_ neDouble# [] [u0, u1] _N_} _F_ _IF_ARGS_ 0 2 CC 3 \ (u0 :: Double) (u1 :: Double) -> case u0 of { _ALG_ D# (u2 :: Double#) -> case u1 of { _ALG_ D# (u3 :: Double#) -> _#_ neDouble# [] [u2, u3]; _NO_DEFLT_ }; _NO_DEFLT_ } _N_ } #-}
instance (Eq a, Eq b) => Eq (Either a b)
{-# GHC_PRAGMA _M_ PreludeMonadicIO {-dfun-} _A_ 2 _U_ 11 _N_ _N_ _N_ _N_ #-}
instance Eq Float
{-# GHC_PRAGMA _M_ PreludeCore {-dfun-} _A_ 0 _N_ _N_ _N_ _F_ _IF_ARGS_ 0 0 X 3 _!_ _TUP_2 [(Float -> Float -> Bool), (Float -> Float -> Bool)] [_CONSTM_ Eq (==) (Float), _CONSTM_ Eq (/=) (Float)] _N_
- (==) = _A_ 2 _U_ 11 _N_ _S_ "U(P)U(P)" {_A_ 2 _U_ 22 _N_ _N_ _F_ _IF_ARGS_ 0 2 XX 1 \ (u0 :: Float#) (u1 :: Float#) -> _#_ eqFloat# [] [u0, u1] _N_} _F_ _IF_ARGS_ 0 2 CC 3 \ (u0 :: Float) (u1 :: Float) -> case u0 of { _ALG_ F# (u2 :: Float#) -> case u1 of { _ALG_ F# (u3 :: Float#) -> _#_ eqFloat# [] [u2, u3]; _NO_DEFLT_ }; _NO_DEFLT_ } _N_,
- (/=) = _A_ 2 _U_ 11 _N_ _S_ "U(P)U(P)" {_A_ 2 _U_ 22 _N_ _N_ _F_ _IF_ARGS_ 0 2 XX 1 \ (u0 :: Float#) (u1 :: Float#) -> _#_ neFloat# [] [u0, u1] _N_} _F_ _IF_ARGS_ 0 2 CC 3 \ (u0 :: Float) (u1 :: Float) -> case u0 of { _ALG_ F# (u2 :: Float#) -> case u1 of { _ALG_ F# (u3 :: Float#) -> _#_ neFloat# [] [u2, u3]; _NO_DEFLT_ }; _NO_DEFLT_ } _N_ #-}
+ (==) = { _A_ 2 _U_ 11 _N_ _S_ "U(P)U(P)" {_A_ 2 _U_ 22 _N_ _N_ _F_ _IF_ARGS_ 0 2 XX 1 \ (u0 :: Float#) (u1 :: Float#) -> _#_ eqFloat# [] [u0, u1] _N_} _F_ _IF_ARGS_ 0 2 CC 3 \ (u0 :: Float) (u1 :: Float) -> case u0 of { _ALG_ F# (u2 :: Float#) -> case u1 of { _ALG_ F# (u3 :: Float#) -> _#_ eqFloat# [] [u2, u3]; _NO_DEFLT_ }; _NO_DEFLT_ } _N_ },
+ (/=) = { _A_ 2 _U_ 11 _N_ _S_ "U(P)U(P)" {_A_ 2 _U_ 22 _N_ _N_ _F_ _IF_ARGS_ 0 2 XX 1 \ (u0 :: Float#) (u1 :: Float#) -> _#_ neFloat# [] [u0, u1] _N_} _F_ _IF_ARGS_ 0 2 CC 3 \ (u0 :: Float) (u1 :: Float) -> case u0 of { _ALG_ F# (u2 :: Float#) -> case u1 of { _ALG_ F# (u3 :: Float#) -> _#_ neFloat# [] [u2, u3]; _NO_DEFLT_ }; _NO_DEFLT_ } _N_ } #-}
instance Eq Int
{-# GHC_PRAGMA _M_ PreludeCore {-dfun-} _A_ 0 _N_ _N_ _N_ _F_ _IF_ARGS_ 0 0 X 3 _!_ _TUP_2 [(Int -> Int -> Bool), (Int -> Int -> Bool)] [_CONSTM_ Eq (==) (Int), _CONSTM_ Eq (/=) (Int)] _N_
- (==) = _A_ 2 _U_ 11 _N_ _S_ "U(P)U(P)" {_A_ 2 _U_ 22 _N_ _N_ _F_ _IF_ARGS_ 0 2 XX 1 \ (u0 :: Int#) (u1 :: Int#) -> _#_ eqInt# [] [u0, u1] _N_} _F_ _IF_ARGS_ 0 2 CC 3 \ (u0 :: Int) (u1 :: Int) -> case u0 of { _ALG_ I# (u2 :: Int#) -> case u1 of { _ALG_ I# (u3 :: Int#) -> _#_ eqInt# [] [u2, u3]; _NO_DEFLT_ }; _NO_DEFLT_ } _N_,
- (/=) = _A_ 2 _U_ 11 _N_ _S_ "U(P)U(P)" {_A_ 2 _U_ 22 _N_ _N_ _F_ _IF_ARGS_ 0 2 XX 1 \ (u0 :: Int#) (u1 :: Int#) -> _#_ neInt# [] [u0, u1] _N_} _F_ _IF_ARGS_ 0 2 CC 3 \ (u0 :: Int) (u1 :: Int) -> case u0 of { _ALG_ I# (u2 :: Int#) -> case u1 of { _ALG_ I# (u3 :: Int#) -> _#_ neInt# [] [u2, u3]; _NO_DEFLT_ }; _NO_DEFLT_ } _N_ #-}
+ (==) = { _A_ 2 _U_ 11 _N_ _S_ "U(P)U(P)" {_A_ 2 _U_ 22 _N_ _N_ _F_ _IF_ARGS_ 0 2 XX 1 \ (u0 :: Int#) (u1 :: Int#) -> _#_ eqInt# [] [u0, u1] _N_} _F_ _IF_ARGS_ 0 2 CC 3 \ (u0 :: Int) (u1 :: Int) -> case u0 of { _ALG_ I# (u2 :: Int#) -> case u1 of { _ALG_ I# (u3 :: Int#) -> _#_ eqInt# [] [u2, u3]; _NO_DEFLT_ }; _NO_DEFLT_ } _N_ },
+ (/=) = { _A_ 2 _U_ 11 _N_ _S_ "U(P)U(P)" {_A_ 2 _U_ 22 _N_ _N_ _F_ _IF_ARGS_ 0 2 XX 1 \ (u0 :: Int#) (u1 :: Int#) -> _#_ neInt# [] [u0, u1] _N_} _F_ _IF_ARGS_ 0 2 CC 3 \ (u0 :: Int) (u1 :: Int) -> case u0 of { _ALG_ I# (u2 :: Int#) -> case u1 of { _ALG_ I# (u3 :: Int#) -> _#_ neInt# [] [u2, u3]; _NO_DEFLT_ }; _NO_DEFLT_ } _N_ } #-}
instance Eq Integer
{-# GHC_PRAGMA _M_ PreludeCore {-dfun-} _A_ 0 _N_ _N_ _N_ _F_ _IF_ARGS_ 0 0 X 3 _!_ _TUP_2 [(Integer -> Integer -> Bool), (Integer -> Integer -> Bool)] [_CONSTM_ Eq (==) (Integer), _CONSTM_ Eq (/=) (Integer)] _N_
- (==) = _A_ 2 _U_ 11 _N_ _S_ "U(PPP)U(PPP)" {_A_ 4 _U_ 2221 _N_ _N_ _F_ _IF_ARGS_ 0 4 XXXC 4 \ (u0 :: Int#) (u1 :: Int#) (u2 :: ByteArray#) (u3 :: Integer) -> case u3 of { _ALG_ J# (u4 :: Int#) (u5 :: Int#) (u6 :: ByteArray#) -> case _#_ cmpInteger# [] [u0, u1, u2, u4, u5, u6] of { _PRIM_ 0# -> _!_ True [] []; (u7 :: Int#) -> _!_ False [] [] }; _NO_DEFLT_ } _N_} _F_ _IF_ARGS_ 0 2 CC 5 \ (u0 :: Integer) (u1 :: Integer) -> case u0 of { _ALG_ J# (u2 :: Int#) (u3 :: Int#) (u4 :: ByteArray#) -> case u1 of { _ALG_ J# (u5 :: Int#) (u6 :: Int#) (u7 :: ByteArray#) -> case _#_ cmpInteger# [] [u2, u3, u4, u5, u6, u7] of { _PRIM_ 0# -> _!_ True [] []; (u8 :: Int#) -> _!_ False [] [] }; _NO_DEFLT_ }; _NO_DEFLT_ } _N_,
- (/=) = _A_ 2 _U_ 11 _N_ _S_ "U(PPP)U(PPP)" {_A_ 4 _U_ 2221 _N_ _N_ _F_ _IF_ARGS_ 0 4 XXXC 4 \ (u0 :: Int#) (u1 :: Int#) (u2 :: ByteArray#) (u3 :: Integer) -> case u3 of { _ALG_ J# (u4 :: Int#) (u5 :: Int#) (u6 :: ByteArray#) -> case _#_ cmpInteger# [] [u0, u1, u2, u4, u5, u6] of { _PRIM_ 0# -> _!_ False [] []; (u7 :: Int#) -> _!_ True [] [] }; _NO_DEFLT_ } _N_} _F_ _IF_ARGS_ 0 2 CC 5 \ (u0 :: Integer) (u1 :: Integer) -> case u0 of { _ALG_ J# (u2 :: Int#) (u3 :: Int#) (u4 :: ByteArray#) -> case u1 of { _ALG_ J# (u5 :: Int#) (u6 :: Int#) (u7 :: ByteArray#) -> case _#_ cmpInteger# [] [u2, u3, u4, u5, u6, u7] of { _PRIM_ 0# -> _!_ False [] []; (u8 :: Int#) -> _!_ True [] [] }; _NO_DEFLT_ }; _NO_DEFLT_ } _N_ #-}
+ (==) = { _A_ 2 _U_ 11 _N_ _S_ "U(PPP)U(PPP)" {_A_ 4 _U_ 2221 _N_ _N_ _F_ _IF_ARGS_ 0 4 XXXC 4 \ (u0 :: Int#) (u1 :: Int#) (u2 :: ByteArray#) (u3 :: Integer) -> case u3 of { _ALG_ J# (u4 :: Int#) (u5 :: Int#) (u6 :: ByteArray#) -> case _#_ cmpInteger# [] [u0, u1, u2, u4, u5, u6] of { _PRIM_ 0# -> _!_ True [] []; (u7 :: Int#) -> _!_ False [] [] }; _NO_DEFLT_ } _N_} _F_ _IF_ARGS_ 0 2 CC 5 \ (u0 :: Integer) (u1 :: Integer) -> case u0 of { _ALG_ J# (u2 :: Int#) (u3 :: Int#) (u4 :: ByteArray#) -> case u1 of { _ALG_ J# (u5 :: Int#) (u6 :: Int#) (u7 :: ByteArray#) -> case _#_ cmpInteger# [] [u2, u3, u4, u5, u6, u7] of { _PRIM_ 0# -> _!_ True [] []; (u8 :: Int#) -> _!_ False [] [] }; _NO_DEFLT_ }; _NO_DEFLT_ } _N_ },
+ (/=) = { _A_ 2 _U_ 11 _N_ _S_ "U(PPP)U(PPP)" {_A_ 4 _U_ 2221 _N_ _N_ _F_ _IF_ARGS_ 0 4 XXXC 4 \ (u0 :: Int#) (u1 :: Int#) (u2 :: ByteArray#) (u3 :: Integer) -> case u3 of { _ALG_ J# (u4 :: Int#) (u5 :: Int#) (u6 :: ByteArray#) -> case _#_ cmpInteger# [] [u0, u1, u2, u4, u5, u6] of { _PRIM_ 0# -> _!_ False [] []; (u7 :: Int#) -> _!_ True [] [] }; _NO_DEFLT_ } _N_} _F_ _IF_ARGS_ 0 2 CC 5 \ (u0 :: Integer) (u1 :: Integer) -> case u0 of { _ALG_ J# (u2 :: Int#) (u3 :: Int#) (u4 :: ByteArray#) -> case u1 of { _ALG_ J# (u5 :: Int#) (u6 :: Int#) (u7 :: ByteArray#) -> case _#_ cmpInteger# [] [u2, u3, u4, u5, u6, u7] of { _PRIM_ 0# -> _!_ False [] []; (u8 :: Int#) -> _!_ True [] [] }; _NO_DEFLT_ }; _NO_DEFLT_ } _N_ } #-}
instance Eq a => Eq (Maybe a)
{-# GHC_PRAGMA _M_ PreludeStdIO {-dfun-} _A_ 1 _U_ 1 _N_ _N_ _N_ _N_ #-}
instance Integral a => Eq (Ratio a)
{-# GHC_PRAGMA _M_ PreludeRatio {-dfun-} _A_ 1 _U_ 1 _N_ _N_ _N_ _N_ #-}
instance Eq (Ratio Integer)
{-# GHC_PRAGMA _M_ PreludeRatio {-dfun-} _A_ 0 _N_ _N_ _N_ _F_ _IF_ARGS_ 0 0 X 3 _!_ _TUP_2 [(Ratio Integer -> Ratio Integer -> Bool), (Ratio Integer -> Ratio Integer -> Bool)] [_CONSTM_ Eq (==) (Ratio Integer), _CONSTM_ Eq (/=) (Ratio Integer)] _N_
- (==) = _A_ 2 _U_ 11 _N_ _S_ "U(U(PPP)L)U(U(PPP)L)" {_A_ 5 _U_ 22211 _N_ _N_ _F_ _IF_ARGS_ 0 5 XXXCC 9 \ (u0 :: Int#) (u1 :: Int#) (u2 :: ByteArray#) (u3 :: Integer) (u4 :: Ratio Integer) -> case u4 of { _ALG_ (:%) (u5 :: Integer) (u6 :: Integer) -> case u5 of { _ALG_ J# (u7 :: Int#) (u8 :: Int#) (u9 :: ByteArray#) -> case _#_ cmpInteger# [] [u0, u1, u2, u7, u8, u9] of { _PRIM_ 0# -> case u3 of { _ALG_ J# (ua :: Int#) (ub :: Int#) (uc :: ByteArray#) -> case u6 of { _ALG_ J# (ud :: Int#) (ue :: Int#) (uf :: ByteArray#) -> case _#_ cmpInteger# [] [ua, ub, uc, ud, ue, uf] of { _PRIM_ 0# -> _!_ True [] []; (ug :: Int#) -> _!_ False [] [] }; _NO_DEFLT_ }; _NO_DEFLT_ }; (uh :: Int#) -> _!_ False [] [] }; _NO_DEFLT_ }; _NO_DEFLT_ } _N_} _N_ _N_,
- (/=) = _A_ 2 _U_ 11 _N_ _S_ "U(U(PPP)L)U(U(PPP)L)" {_A_ 5 _U_ 22211 _N_ _N_ _F_ _IF_ARGS_ 0 5 XXXCC 9 \ (u0 :: Int#) (u1 :: Int#) (u2 :: ByteArray#) (u3 :: Integer) (u4 :: Ratio Integer) -> case u4 of { _ALG_ (:%) (u5 :: Integer) (u6 :: Integer) -> case u5 of { _ALG_ J# (u7 :: Int#) (u8 :: Int#) (u9 :: ByteArray#) -> case _#_ cmpInteger# [] [u0, u1, u2, u7, u8, u9] of { _PRIM_ 0# -> case u3 of { _ALG_ J# (ua :: Int#) (ub :: Int#) (uc :: ByteArray#) -> case u6 of { _ALG_ J# (ud :: Int#) (ue :: Int#) (uf :: ByteArray#) -> case _#_ cmpInteger# [] [ua, ub, uc, ud, ue, uf] of { _PRIM_ 0# -> _!_ False [] []; (ug :: Int#) -> _!_ True [] [] }; _NO_DEFLT_ }; _NO_DEFLT_ }; (uh :: Int#) -> _!_ True [] [] }; _NO_DEFLT_ }; _NO_DEFLT_ } _N_} _N_ _N_ #-}
+ (==) = { _A_ 2 _U_ 11 _N_ _S_ "U(U(PPP)L)U(U(PPP)L)" {_A_ 5 _U_ 22211 _N_ _N_ _F_ _IF_ARGS_ 0 5 XXXCC 9 \ (u0 :: Int#) (u1 :: Int#) (u2 :: ByteArray#) (u3 :: Integer) (u4 :: Ratio Integer) -> case u4 of { _ALG_ (:%) (u5 :: Integer) (u6 :: Integer) -> case u5 of { _ALG_ J# (u7 :: Int#) (u8 :: Int#) (u9 :: ByteArray#) -> case _#_ cmpInteger# [] [u0, u1, u2, u7, u8, u9] of { _PRIM_ 0# -> case u3 of { _ALG_ J# (ua :: Int#) (ub :: Int#) (uc :: ByteArray#) -> case u6 of { _ALG_ J# (ud :: Int#) (ue :: Int#) (uf :: ByteArray#) -> case _#_ cmpInteger# [] [ua, ub, uc, ud, ue, uf] of { _PRIM_ 0# -> _!_ True [] []; (ug :: Int#) -> _!_ False [] [] }; _NO_DEFLT_ }; _NO_DEFLT_ }; (uh :: Int#) -> _!_ False [] [] }; _NO_DEFLT_ }; _NO_DEFLT_ } _N_} _N_ _N_ },
+ (/=) = { _A_ 2 _U_ 11 _N_ _S_ "U(U(PPP)L)U(U(PPP)L)" {_A_ 5 _U_ 22211 _N_ _N_ _F_ _IF_ARGS_ 0 5 XXXCC 9 \ (u0 :: Int#) (u1 :: Int#) (u2 :: ByteArray#) (u3 :: Integer) (u4 :: Ratio Integer) -> case u4 of { _ALG_ (:%) (u5 :: Integer) (u6 :: Integer) -> case u5 of { _ALG_ J# (u7 :: Int#) (u8 :: Int#) (u9 :: ByteArray#) -> case _#_ cmpInteger# [] [u0, u1, u2, u7, u8, u9] of { _PRIM_ 0# -> case u3 of { _ALG_ J# (ua :: Int#) (ub :: Int#) (uc :: ByteArray#) -> case u6 of { _ALG_ J# (ud :: Int#) (ue :: Int#) (uf :: ByteArray#) -> case _#_ cmpInteger# [] [ua, ub, uc, ud, ue, uf] of { _PRIM_ 0# -> _!_ False [] []; (ug :: Int#) -> _!_ True [] [] }; _NO_DEFLT_ }; _NO_DEFLT_ }; (uh :: Int#) -> _!_ True [] [] }; _NO_DEFLT_ }; _NO_DEFLT_ } _N_} _N_ _N_ } #-}
+instance Eq [(Int, Int)]
+ {-# GHC_PRAGMA _M_ PreludeBuiltin {-dfun-} _A_ 0 _N_ _N_ _N_ _F_ _IF_ARGS_ 0 0 X 3 _!_ _TUP_2 [([(Int, Int)] -> [(Int, Int)] -> Bool), ([(Int, Int)] -> [(Int, Int)] -> Bool)] [_CONSTM_ Eq (==) ([(Int, Int)]), _CONSTM_ Eq (/=) ([(Int, Int)])] _N_
+ (==) = { _A_ 2 _U_ 11 _N_ _S_ "SS" _N_ _N_ },
+ (/=) = { _A_ 2 _U_ 11 _N_ _S_ "SS" _N_ _N_ } #-}
instance Eq a => Eq [a]
{-# GHC_PRAGMA _M_ PreludeBuiltin {-dfun-} _A_ 1 _U_ 1 _N_ _N_ _N_ _N_ #-}
+instance Eq [Bool]
+ {-# GHC_PRAGMA _M_ PreludeBuiltin {-dfun-} _A_ 0 _N_ _N_ _N_ _F_ _IF_ARGS_ 0 0 X 3 _!_ _TUP_2 [([Bool] -> [Bool] -> Bool), ([Bool] -> [Bool] -> Bool)] [_CONSTM_ Eq (==) ([Bool]), _CONSTM_ Eq (/=) ([Bool])] _N_
+ (==) = { _A_ 2 _U_ 11 _N_ _S_ "SS" _N_ _N_ },
+ (/=) = { _A_ 2 _U_ 11 _N_ _S_ "SS" _N_ _N_ } #-}
instance Eq [Char]
{-# GHC_PRAGMA _M_ PreludeBuiltin {-dfun-} _A_ 0 _N_ _N_ _N_ _F_ _IF_ARGS_ 0 0 X 3 _!_ _TUP_2 [([Char] -> [Char] -> Bool), ([Char] -> [Char] -> Bool)] [_CONSTM_ Eq (==) ([Char]), _CONSTM_ Eq (/=) ([Char])] _N_
- (==) = _A_ 2 _U_ 11 _N_ _S_ "SS" _N_ _N_,
- (/=) = _A_ 2 _U_ 11 _N_ _S_ "SS" _N_ _N_ #-}
+ (==) = { _A_ 2 _U_ 11 _N_ _S_ "SS" _N_ _N_ },
+ (/=) = { _A_ 2 _U_ 11 _N_ _S_ "SS" _N_ _N_ } #-}
+instance Eq [Complex Double]
+ {-# GHC_PRAGMA _M_ PreludeBuiltin {-dfun-} _A_ 0 _N_ _N_ _N_ _F_ _IF_ARGS_ 0 0 X 3 _!_ _TUP_2 [([Complex Double] -> [Complex Double] -> Bool), ([Complex Double] -> [Complex Double] -> Bool)] [_CONSTM_ Eq (==) ([Complex Double]), _CONSTM_ Eq (/=) ([Complex Double])] _N_
+ (==) = { _A_ 2 _U_ 11 _N_ _S_ "SS" _N_ _N_ },
+ (/=) = { _A_ 2 _U_ 11 _N_ _S_ "SS" _N_ _N_ } #-}
+instance Eq [Double]
+ {-# GHC_PRAGMA _M_ PreludeBuiltin {-dfun-} _A_ 0 _N_ _N_ _N_ _F_ _IF_ARGS_ 0 0 X 3 _!_ _TUP_2 [([Double] -> [Double] -> Bool), ([Double] -> [Double] -> Bool)] [_CONSTM_ Eq (==) ([Double]), _CONSTM_ Eq (/=) ([Double])] _N_
+ (==) = { _A_ 2 _U_ 11 _N_ _S_ "SS" _N_ _N_ },
+ (/=) = { _A_ 2 _U_ 11 _N_ _S_ "SS" _N_ _N_ } #-}
instance Eq [Int]
{-# GHC_PRAGMA _M_ PreludeBuiltin {-dfun-} _A_ 0 _N_ _N_ _N_ _F_ _IF_ARGS_ 0 0 X 3 _!_ _TUP_2 [([Int] -> [Int] -> Bool), ([Int] -> [Int] -> Bool)] [_CONSTM_ Eq (==) ([Int]), _CONSTM_ Eq (/=) ([Int])] _N_
- (==) = _A_ 2 _U_ 11 _N_ _S_ "SS" _N_ _N_,
- (/=) = _A_ 2 _U_ 11 _N_ _S_ "SS" _N_ _N_ #-}
+ (==) = { _A_ 2 _U_ 11 _N_ _S_ "SS" _N_ _N_ },
+ (/=) = { _A_ 2 _U_ 11 _N_ _S_ "SS" _N_ _N_ } #-}
+instance Eq [Integer]
+ {-# GHC_PRAGMA _M_ PreludeBuiltin {-dfun-} _A_ 0 _N_ _N_ _N_ _F_ _IF_ARGS_ 0 0 X 3 _!_ _TUP_2 [([Integer] -> [Integer] -> Bool), ([Integer] -> [Integer] -> Bool)] [_CONSTM_ Eq (==) ([Integer]), _CONSTM_ Eq (/=) ([Integer])] _N_
+ (==) = { _A_ 2 _U_ 11 _N_ _S_ "SS" _N_ _N_ },
+ (/=) = { _A_ 2 _U_ 11 _N_ _S_ "SS" _N_ _N_ } #-}
+instance Eq [[Char]]
+ {-# GHC_PRAGMA _M_ PreludeBuiltin {-dfun-} _A_ 0 _N_ _N_ _N_ _F_ _IF_ARGS_ 0 0 X 3 _!_ _TUP_2 [([[Char]] -> [[Char]] -> Bool), ([[Char]] -> [[Char]] -> Bool)] [_CONSTM_ Eq (==) ([[Char]]), _CONSTM_ Eq (/=) ([[Char]])] _N_
+ (==) = { _A_ 2 _U_ 11 _N_ _S_ "SS" _N_ _N_ },
+ (/=) = { _A_ 2 _U_ 11 _N_ _S_ "SS" _N_ _N_ } #-}
+instance Eq [[Int]]
+ {-# GHC_PRAGMA _M_ PreludeBuiltin {-dfun-} _A_ 0 _N_ _N_ _N_ _F_ _IF_ARGS_ 0 0 X 3 _!_ _TUP_2 [([[Int]] -> [[Int]] -> Bool), ([[Int]] -> [[Int]] -> Bool)] [_CONSTM_ Eq (==) ([[Int]]), _CONSTM_ Eq (/=) ([[Int]])] _N_
+ (==) = { _A_ 2 _U_ 11 _N_ _S_ "SS" _N_ _N_ },
+ (/=) = { _A_ 2 _U_ 11 _N_ _S_ "SS" _N_ _N_ } #-}
instance Eq _Addr
{-# GHC_PRAGMA _M_ PreludeCore {-dfun-} _A_ 0 _N_ _N_ _N_ _F_ _IF_ARGS_ 0 0 X 3 _!_ _TUP_2 [(_Addr -> _Addr -> Bool), (_Addr -> _Addr -> Bool)] [_CONSTM_ Eq (==) (_Addr), _CONSTM_ Eq (/=) (_Addr)] _N_
- (==) = _A_ 2 _U_ 11 _N_ _S_ "U(P)U(P)" {_A_ 2 _U_ 22 _N_ _N_ _F_ _IF_ARGS_ 0 2 XX 1 \ (u0 :: Addr#) (u1 :: Addr#) -> _#_ eqAddr# [] [u0, u1] _N_} _F_ _IF_ARGS_ 0 2 CC 3 \ (u0 :: _Addr) (u1 :: _Addr) -> case u0 of { _ALG_ A# (u2 :: Addr#) -> case u1 of { _ALG_ A# (u3 :: Addr#) -> _#_ eqAddr# [] [u2, u3]; _NO_DEFLT_ }; _NO_DEFLT_ } _N_,
- (/=) = _A_ 2 _U_ 11 _N_ _S_ "U(P)U(P)" {_A_ 2 _U_ 22 _N_ _N_ _F_ _IF_ARGS_ 0 2 XX 1 \ (u0 :: Addr#) (u1 :: Addr#) -> _#_ neAddr# [] [u0, u1] _N_} _F_ _IF_ARGS_ 0 2 CC 3 \ (u0 :: _Addr) (u1 :: _Addr) -> case u0 of { _ALG_ A# (u2 :: Addr#) -> case u1 of { _ALG_ A# (u3 :: Addr#) -> _#_ neAddr# [] [u2, u3]; _NO_DEFLT_ }; _NO_DEFLT_ } _N_ #-}
+ (==) = { _A_ 2 _U_ 11 _N_ _S_ "U(P)U(P)" {_A_ 2 _U_ 22 _N_ _N_ _F_ _IF_ARGS_ 0 2 XX 1 \ (u0 :: Addr#) (u1 :: Addr#) -> _#_ eqAddr# [] [u0, u1] _N_} _F_ _IF_ARGS_ 0 2 CC 3 \ (u0 :: _Addr) (u1 :: _Addr) -> case u0 of { _ALG_ A# (u2 :: Addr#) -> case u1 of { _ALG_ A# (u3 :: Addr#) -> _#_ eqAddr# [] [u2, u3]; _NO_DEFLT_ }; _NO_DEFLT_ } _N_ },
+ (/=) = { _A_ 2 _U_ 11 _N_ _S_ "U(P)U(P)" {_A_ 2 _U_ 22 _N_ _N_ _F_ _IF_ARGS_ 0 2 XX 1 \ (u0 :: Addr#) (u1 :: Addr#) -> _#_ neAddr# [] [u0, u1] _N_} _F_ _IF_ARGS_ 0 2 CC 3 \ (u0 :: _Addr) (u1 :: _Addr) -> case u0 of { _ALG_ A# (u2 :: Addr#) -> case u1 of { _ALG_ A# (u3 :: Addr#) -> _#_ neAddr# [] [u2, u3]; _NO_DEFLT_ }; _NO_DEFLT_ } _N_ } #-}
instance Eq _PackedString
{-# GHC_PRAGMA _M_ PreludePS {-dfun-} _A_ 0 _N_ _N_ _N_ _F_ _IF_ARGS_ 0 0 X 3 _!_ _TUP_2 [(_PackedString -> _PackedString -> Bool), (_PackedString -> _PackedString -> Bool)] [_CONSTM_ Eq (==) (_PackedString), _CONSTM_ Eq (/=) (_PackedString)] _N_
- (==) = _A_ 2 _U_ 22 _N_ _S_ "SS" _N_ _N_,
- (/=) = _A_ 2 _U_ 22 _N_ _S_ "SS" _N_ _N_ #-}
+ (==) = { _A_ 2 _U_ 22 _N_ _S_ "SS" _N_ _N_ },
+ (/=) = { _A_ 2 _U_ 22 _N_ _S_ "SS" _N_ _N_ } #-}
instance Eq _Word
{-# GHC_PRAGMA _M_ PreludeCore {-dfun-} _A_ 0 _N_ _N_ _N_ _F_ _IF_ARGS_ 0 0 X 3 _!_ _TUP_2 [(_Word -> _Word -> Bool), (_Word -> _Word -> Bool)] [_CONSTM_ Eq (==) (_Word), _CONSTM_ Eq (/=) (_Word)] _N_
- (==) = _A_ 2 _U_ 11 _N_ _S_ "U(P)U(P)" {_A_ 2 _U_ 22 _N_ _N_ _F_ _IF_ARGS_ 0 2 XX 1 \ (u0 :: Word#) (u1 :: Word#) -> _#_ eqWord# [] [u0, u1] _N_} _F_ _IF_ARGS_ 0 2 CC 3 \ (u0 :: _Word) (u1 :: _Word) -> case u0 of { _ALG_ W# (u2 :: Word#) -> case u1 of { _ALG_ W# (u3 :: Word#) -> _#_ eqWord# [] [u2, u3]; _NO_DEFLT_ }; _NO_DEFLT_ } _N_,
- (/=) = _A_ 2 _U_ 11 _N_ _S_ "U(P)U(P)" {_A_ 2 _U_ 22 _N_ _N_ _F_ _IF_ARGS_ 0 2 XX 1 \ (u0 :: Word#) (u1 :: Word#) -> _#_ neWord# [] [u0, u1] _N_} _F_ _IF_ARGS_ 0 2 CC 3 \ (u0 :: _Word) (u1 :: _Word) -> case u0 of { _ALG_ W# (u2 :: Word#) -> case u1 of { _ALG_ W# (u3 :: Word#) -> _#_ neWord# [] [u2, u3]; _NO_DEFLT_ }; _NO_DEFLT_ } _N_ #-}
+ (==) = { _A_ 2 _U_ 11 _N_ _S_ "U(P)U(P)" {_A_ 2 _U_ 22 _N_ _N_ _F_ _IF_ARGS_ 0 2 XX 1 \ (u0 :: Word#) (u1 :: Word#) -> _#_ eqWord# [] [u0, u1] _N_} _F_ _IF_ARGS_ 0 2 CC 3 \ (u0 :: _Word) (u1 :: _Word) -> case u0 of { _ALG_ W# (u2 :: Word#) -> case u1 of { _ALG_ W# (u3 :: Word#) -> _#_ eqWord# [] [u2, u3]; _NO_DEFLT_ }; _NO_DEFLT_ } _N_ },
+ (/=) = { _A_ 2 _U_ 11 _N_ _S_ "U(P)U(P)" {_A_ 2 _U_ 22 _N_ _N_ _F_ _IF_ARGS_ 0 2 XX 1 \ (u0 :: Word#) (u1 :: Word#) -> _#_ neWord# [] [u0, u1] _N_} _F_ _IF_ARGS_ 0 2 CC 3 \ (u0 :: _Word) (u1 :: _Word) -> case u0 of { _ALG_ W# (u2 :: Word#) -> case u1 of { _ALG_ W# (u3 :: Word#) -> _#_ neWord# [] [u2, u3]; _NO_DEFLT_ }; _NO_DEFLT_ } _N_ } #-}
instance RealFloat a => Floating (Complex a)
{-# GHC_PRAGMA _M_ PreludeComplex {-dfun-} _A_ 2 _U_ 22 _N_ _N_ _N_ _N_ #-}
instance Floating (Complex Double)
{-# GHC_PRAGMA _M_ PreludeComplex {-dfun-} _A_ 0 _N_ _N_ _N_ _F_ _IF_ARGS_ 0 0 X 20 _!_ _TUP_19 [{{Fractional (Complex Double)}}, (Complex Double), (Complex Double -> Complex Double), (Complex Double -> Complex Double), (Complex Double -> Complex Double), (Complex Double -> Complex Double -> Complex Double), (Complex Double -> Complex Double -> Complex Double), (Complex Double -> Complex Double), (Complex Double -> Complex Double), (Complex Double -> Complex Double), (Complex Double -> Complex Double), (Complex Double -> Complex Double), (Complex Double -> Complex Double), (Complex Double -> Complex Double), (Complex Double -> Complex Double), (Complex Double -> Complex Double), (Complex Double -> Complex Double), (Complex Double -> Complex Double), (Complex Double -> Complex Double)] [_DFUN_ Fractional (Complex Double), _CONSTM_ Floating pi (Complex Double), _CONSTM_ Floating exp (Complex Double), _CONSTM_ Floating log (Complex Double), _CONSTM_ Floating sqrt (Complex Double), _CONSTM_ Floating (**) (Complex Double), _CONSTM_ Floating logBase (Complex Double), _CONSTM_ Floating sin (Complex Double), _CONSTM_ Floating cos (Complex Double), _CONSTM_ Floating tan (Complex Double), _CONSTM_ Floating asin (Complex Double), _CONSTM_ Floating acos (Complex Double), _CONSTM_ Floating atan (Complex Double), _CONSTM_ Floating sinh (Complex Double), _CONSTM_ Floating cosh (Complex Double), _CONSTM_ Floating tanh (Complex Double), _CONSTM_ Floating asinh (Complex Double), _CONSTM_ Floating acosh (Complex Double), _CONSTM_ Floating atanh (Complex Double)] _N_
- pi = _A_ 0 _N_ _N_ _N_ _N_ _N_,
- exp = _A_ 1 _U_ 1 _N_ _S_ "U(LL)" {_A_ 2 _U_ 12 _N_ _N_ _N_ _N_} _N_ _N_,
- log = _A_ 1 _U_ 2 _N_ _N_ _N_ _N_,
- sqrt = _A_ 1 _U_ 1 _N_ _S_ "U(U(P)L)" {_A_ 2 _U_ 22 _N_ _N_ _N_ _N_} _N_ _N_,
- (**) = _A_ 2 _U_ 21 _N_ _S_ "LU(LL)" {_A_ 3 _U_ 222 _N_ _N_ _N_ _N_} _N_ _N_,
- logBase = _A_ 2 _U_ 22 _N_ _N_ _N_ _N_,
- sin = _A_ 1 _U_ 1 _N_ _S_ "U(LL)" {_A_ 2 _U_ 22 _N_ _N_ _N_ _N_} _N_ _N_,
- cos = _A_ 1 _U_ 1 _N_ _S_ "U(LL)" {_A_ 2 _U_ 22 _N_ _N_ _N_ _N_} _N_ _N_,
- tan = _A_ 1 _U_ 1 _N_ _S_ "U(LL)" {_A_ 2 _U_ 22 _N_ _N_ _N_ _N_} _N_ _N_,
- asin = _A_ 1 _U_ 1 _N_ _S_ "U(LL)" {_A_ 2 _U_ 22 _N_ _N_ _N_ _N_} _N_ _N_,
- acos = _A_ 1 _U_ 1 _N_ _S_ "U(LL)" {_A_ 2 _U_ 22 _N_ _N_ _N_ _N_} _N_ _N_,
- atan = _A_ 1 _U_ 1 _N_ _S_ "U(LL)" {_A_ 2 _U_ 22 _N_ _N_ _N_ _N_} _N_ _N_,
- sinh = _A_ 1 _U_ 1 _N_ _S_ "U(LL)" {_A_ 2 _U_ 22 _N_ _N_ _N_ _N_} _N_ _N_,
- cosh = _A_ 1 _U_ 1 _N_ _S_ "U(LL)" {_A_ 2 _U_ 22 _N_ _N_ _N_ _N_} _N_ _N_,
- tanh = _A_ 1 _U_ 1 _N_ _S_ "U(LL)" {_A_ 2 _U_ 22 _N_ _N_ _N_ _N_} _N_ _N_,
- asinh = _A_ 1 _U_ 1 _N_ _N_ _N_ _N_,
- acosh = _A_ 1 _U_ 1 _N_ _N_ _N_ _N_,
- atanh = _A_ 1 _U_ 1 _N_ _N_ _N_ _N_ #-}
+ pi = { _A_ 0 _N_ _N_ _N_ _F_ _IF_ARGS_ 0 0 X 3 _!_ (:+) [Double] [_CONSTM_ Floating pi (Double), _SPEC_ _ORIG_ PreludeCore __i0 [ (Double) ]] _N_ },
+ exp = { _A_ 1 _U_ 1 _N_ _S_ "U(LL)" {_A_ 2 _U_ 12 _N_ _N_ _N_ _N_} _N_ _N_ },
+ log = { _A_ 1 _U_ 2 _N_ _N_ _N_ _N_ },
+ sqrt = { _A_ 1 _U_ 1 _N_ _S_ "U(U(P)L)" {_A_ 2 _U_ 22 _N_ _N_ _N_ _N_} _N_ _N_ },
+ (**) = { _A_ 2 _U_ 21 _N_ _S_ "LU(LL)" {_A_ 3 _U_ 222 _N_ _N_ _N_ _N_} _N_ _N_ },
+ logBase = { _A_ 2 _U_ 22 _N_ _N_ _N_ _N_ },
+ sin = { _A_ 1 _U_ 1 _N_ _S_ "U(LL)" {_A_ 2 _U_ 22 _N_ _N_ _N_ _N_} _N_ _N_ },
+ cos = { _A_ 1 _U_ 1 _N_ _S_ "U(LL)" {_A_ 2 _U_ 22 _N_ _N_ _N_ _N_} _N_ _N_ },
+ tan = { _A_ 1 _U_ 1 _N_ _S_ "U(LL)" {_A_ 2 _U_ 22 _N_ _N_ _N_ _N_} _N_ _N_ },
+ asin = { _A_ 1 _U_ 1 _N_ _S_ "U(LL)" {_A_ 2 _U_ 22 _N_ _N_ _N_ _N_} _N_ _N_ },
+ acos = { _A_ 1 _U_ 1 _N_ _S_ "U(LL)" {_A_ 2 _U_ 22 _N_ _N_ _N_ _N_} _N_ _N_ },
+ atan = { _A_ 1 _U_ 1 _N_ _S_ "U(LL)" {_A_ 2 _U_ 22 _N_ _N_ _N_ _N_} _N_ _N_ },
+ sinh = { _A_ 1 _U_ 1 _N_ _S_ "U(LL)" {_A_ 2 _U_ 22 _N_ _N_ _N_ _N_} _N_ _N_ },
+ cosh = { _A_ 1 _U_ 1 _N_ _S_ "U(LL)" {_A_ 2 _U_ 22 _N_ _N_ _N_ _N_} _N_ _N_ },
+ tanh = { _A_ 1 _U_ 1 _N_ _S_ "U(LL)" {_A_ 2 _U_ 22 _N_ _N_ _N_ _N_} _N_ _N_ },
+ asinh = { _A_ 1 _U_ 1 _N_ _N_ _N_ _N_ },
+ acosh = { _A_ 1 _U_ 1 _N_ _N_ _N_ _N_ },
+ atanh = { _A_ 1 _U_ 1 _N_ _N_ _N_ _N_ } #-}
instance Floating Double
{-# GHC_PRAGMA _M_ PreludeCore {-dfun-} _A_ 0 _N_ _N_ _N_ _F_ _IF_ARGS_ 0 0 X 20 _!_ _TUP_19 [{{Fractional Double}}, Double, (Double -> Double), (Double -> Double), (Double -> Double), (Double -> Double -> Double), (Double -> Double -> Double), (Double -> Double), (Double -> Double), (Double -> Double), (Double -> Double), (Double -> Double), (Double -> Double), (Double -> Double), (Double -> Double), (Double -> Double), (Double -> Double), (Double -> Double), (Double -> Double)] [_DFUN_ Fractional (Double), _CONSTM_ Floating pi (Double), _CONSTM_ Floating exp (Double), _CONSTM_ Floating log (Double), _CONSTM_ Floating sqrt (Double), _CONSTM_ Floating (**) (Double), _CONSTM_ Floating logBase (Double), _CONSTM_ Floating sin (Double), _CONSTM_ Floating cos (Double), _CONSTM_ Floating tan (Double), _CONSTM_ Floating asin (Double), _CONSTM_ Floating acos (Double), _CONSTM_ Floating atan (Double), _CONSTM_ Floating sinh (Double), _CONSTM_ Floating cosh (Double), _CONSTM_ Floating tanh (Double), _CONSTM_ Floating asinh (Double), _CONSTM_ Floating acosh (Double), _CONSTM_ Floating atanh (Double)] _N_
- pi = _A_ 0 _N_ _N_ _N_ _F_ _IF_ARGS_ 0 0 X 2 _!_ D# [] [3.1415926535897931##] _N_,
- exp = _A_ 1 _U_ 1 _N_ _S_ "U(P)" {_A_ 1 _U_ 2 _N_ _N_ _F_ _IF_ARGS_ 0 1 X 3 \ (u0 :: Double#) -> case _#_ expDouble# [] [u0] of { _PRIM_ (u1 :: Double#) -> _!_ D# [] [u1] } _N_} _F_ _IF_ARGS_ 0 1 C 4 \ (u0 :: Double) -> case u0 of { _ALG_ D# (u1 :: Double#) -> case _#_ expDouble# [] [u1] of { _PRIM_ (u2 :: Double#) -> _!_ D# [] [u2] }; _NO_DEFLT_ } _N_,
- log = _A_ 1 _U_ 1 _N_ _S_ "U(P)" {_A_ 1 _U_ 2 _N_ _N_ _F_ _IF_ARGS_ 0 1 X 3 \ (u0 :: Double#) -> case _#_ logDouble# [] [u0] of { _PRIM_ (u1 :: Double#) -> _!_ D# [] [u1] } _N_} _F_ _IF_ARGS_ 0 1 C 4 \ (u0 :: Double) -> case u0 of { _ALG_ D# (u1 :: Double#) -> case _#_ logDouble# [] [u1] of { _PRIM_ (u2 :: Double#) -> _!_ D# [] [u2] }; _NO_DEFLT_ } _N_,
- sqrt = _A_ 1 _U_ 1 _N_ _S_ "U(P)" {_A_ 1 _U_ 2 _N_ _N_ _F_ _IF_ARGS_ 0 1 X 3 \ (u0 :: Double#) -> case _#_ sqrtDouble# [] [u0] of { _PRIM_ (u1 :: Double#) -> _!_ D# [] [u1] } _N_} _F_ _IF_ARGS_ 0 1 C 4 \ (u0 :: Double) -> case u0 of { _ALG_ D# (u1 :: Double#) -> case _#_ sqrtDouble# [] [u1] of { _PRIM_ (u2 :: Double#) -> _!_ D# [] [u2] }; _NO_DEFLT_ } _N_,
- (**) = _A_ 2 _U_ 11 _N_ _S_ "U(P)U(P)" {_A_ 2 _U_ 22 _N_ _N_ _F_ _IF_ARGS_ 0 2 XX 3 \ (u0 :: Double#) (u1 :: Double#) -> case _#_ powerDouble# [] [u0, u1] of { _PRIM_ (u2 :: Double#) -> _!_ D# [] [u2] } _N_} _F_ _IF_ARGS_ 0 2 CC 5 \ (u0 :: Double) (u1 :: Double) -> case u0 of { _ALG_ D# (u2 :: Double#) -> case u1 of { _ALG_ D# (u3 :: Double#) -> case _#_ powerDouble# [] [u2, u3] of { _PRIM_ (u4 :: Double#) -> _!_ D# [] [u4] }; _NO_DEFLT_ }; _NO_DEFLT_ } _N_,
- logBase = _A_ 2 _U_ 11 _N_ _S_ "U(P)U(P)" {_A_ 2 _U_ 22 _N_ _N_ _F_ _IF_ARGS_ 0 2 XX 5 \ (u0 :: Double#) (u1 :: Double#) -> case _#_ logDouble# [] [u1] of { _PRIM_ (u2 :: Double#) -> case _#_ logDouble# [] [u0] of { _PRIM_ (u3 :: Double#) -> case _#_ divideDouble# [] [u2, u3] of { _PRIM_ (u4 :: Double#) -> _!_ D# [] [u4] } } } _N_} _F_ _IF_ARGS_ 0 2 CC 7 \ (u0 :: Double) (u1 :: Double) -> case u1 of { _ALG_ D# (u2 :: Double#) -> case _#_ logDouble# [] [u2] of { _PRIM_ (u3 :: Double#) -> case u0 of { _ALG_ D# (u4 :: Double#) -> case _#_ logDouble# [] [u4] of { _PRIM_ (u5 :: Double#) -> case _#_ divideDouble# [] [u3, u5] of { _PRIM_ (u6 :: Double#) -> _!_ D# [] [u6] } }; _NO_DEFLT_ } }; _NO_DEFLT_ } _N_,
- sin = _A_ 1 _U_ 1 _N_ _S_ "U(P)" {_A_ 1 _U_ 2 _N_ _N_ _F_ _IF_ARGS_ 0 1 X 3 \ (u0 :: Double#) -> case _#_ sinDouble# [] [u0] of { _PRIM_ (u1 :: Double#) -> _!_ D# [] [u1] } _N_} _F_ _IF_ARGS_ 0 1 C 4 \ (u0 :: Double) -> case u0 of { _ALG_ D# (u1 :: Double#) -> case _#_ sinDouble# [] [u1] of { _PRIM_ (u2 :: Double#) -> _!_ D# [] [u2] }; _NO_DEFLT_ } _N_,
- cos = _A_ 1 _U_ 1 _N_ _S_ "U(P)" {_A_ 1 _U_ 2 _N_ _N_ _F_ _IF_ARGS_ 0 1 X 3 \ (u0 :: Double#) -> case _#_ cosDouble# [] [u0] of { _PRIM_ (u1 :: Double#) -> _!_ D# [] [u1] } _N_} _F_ _IF_ARGS_ 0 1 C 4 \ (u0 :: Double) -> case u0 of { _ALG_ D# (u1 :: Double#) -> case _#_ cosDouble# [] [u1] of { _PRIM_ (u2 :: Double#) -> _!_ D# [] [u2] }; _NO_DEFLT_ } _N_,
- tan = _A_ 1 _U_ 1 _N_ _S_ "U(P)" {_A_ 1 _U_ 2 _N_ _N_ _F_ _IF_ARGS_ 0 1 X 3 \ (u0 :: Double#) -> case _#_ tanDouble# [] [u0] of { _PRIM_ (u1 :: Double#) -> _!_ D# [] [u1] } _N_} _F_ _IF_ARGS_ 0 1 C 4 \ (u0 :: Double) -> case u0 of { _ALG_ D# (u1 :: Double#) -> case _#_ tanDouble# [] [u1] of { _PRIM_ (u2 :: Double#) -> _!_ D# [] [u2] }; _NO_DEFLT_ } _N_,
- asin = _A_ 1 _U_ 1 _N_ _S_ "U(P)" {_A_ 1 _U_ 2 _N_ _N_ _F_ _IF_ARGS_ 0 1 X 3 \ (u0 :: Double#) -> case _#_ asinDouble# [] [u0] of { _PRIM_ (u1 :: Double#) -> _!_ D# [] [u1] } _N_} _F_ _IF_ARGS_ 0 1 C 4 \ (u0 :: Double) -> case u0 of { _ALG_ D# (u1 :: Double#) -> case _#_ asinDouble# [] [u1] of { _PRIM_ (u2 :: Double#) -> _!_ D# [] [u2] }; _NO_DEFLT_ } _N_,
- acos = _A_ 1 _U_ 1 _N_ _S_ "U(P)" {_A_ 1 _U_ 2 _N_ _N_ _F_ _IF_ARGS_ 0 1 X 3 \ (u0 :: Double#) -> case _#_ acosDouble# [] [u0] of { _PRIM_ (u1 :: Double#) -> _!_ D# [] [u1] } _N_} _F_ _IF_ARGS_ 0 1 C 4 \ (u0 :: Double) -> case u0 of { _ALG_ D# (u1 :: Double#) -> case _#_ acosDouble# [] [u1] of { _PRIM_ (u2 :: Double#) -> _!_ D# [] [u2] }; _NO_DEFLT_ } _N_,
- atan = _A_ 1 _U_ 1 _N_ _S_ "U(P)" {_A_ 1 _U_ 2 _N_ _N_ _F_ _IF_ARGS_ 0 1 X 3 \ (u0 :: Double#) -> case _#_ atanDouble# [] [u0] of { _PRIM_ (u1 :: Double#) -> _!_ D# [] [u1] } _N_} _F_ _IF_ARGS_ 0 1 C 4 \ (u0 :: Double) -> case u0 of { _ALG_ D# (u1 :: Double#) -> case _#_ atanDouble# [] [u1] of { _PRIM_ (u2 :: Double#) -> _!_ D# [] [u2] }; _NO_DEFLT_ } _N_,
- sinh = _A_ 1 _U_ 1 _N_ _S_ "U(P)" {_A_ 1 _U_ 2 _N_ _N_ _F_ _IF_ARGS_ 0 1 X 3 \ (u0 :: Double#) -> case _#_ sinhDouble# [] [u0] of { _PRIM_ (u1 :: Double#) -> _!_ D# [] [u1] } _N_} _F_ _IF_ARGS_ 0 1 C 4 \ (u0 :: Double) -> case u0 of { _ALG_ D# (u1 :: Double#) -> case _#_ sinhDouble# [] [u1] of { _PRIM_ (u2 :: Double#) -> _!_ D# [] [u2] }; _NO_DEFLT_ } _N_,
- cosh = _A_ 1 _U_ 1 _N_ _S_ "U(P)" {_A_ 1 _U_ 2 _N_ _N_ _F_ _IF_ARGS_ 0 1 X 3 \ (u0 :: Double#) -> case _#_ coshDouble# [] [u0] of { _PRIM_ (u1 :: Double#) -> _!_ D# [] [u1] } _N_} _F_ _IF_ARGS_ 0 1 C 4 \ (u0 :: Double) -> case u0 of { _ALG_ D# (u1 :: Double#) -> case _#_ coshDouble# [] [u1] of { _PRIM_ (u2 :: Double#) -> _!_ D# [] [u2] }; _NO_DEFLT_ } _N_,
- tanh = _A_ 1 _U_ 1 _N_ _S_ "U(P)" {_A_ 1 _U_ 2 _N_ _N_ _F_ _IF_ARGS_ 0 1 X 3 \ (u0 :: Double#) -> case _#_ tanhDouble# [] [u0] of { _PRIM_ (u1 :: Double#) -> _!_ D# [] [u1] } _N_} _F_ _IF_ARGS_ 0 1 C 4 \ (u0 :: Double) -> case u0 of { _ALG_ D# (u1 :: Double#) -> case _#_ tanhDouble# [] [u1] of { _PRIM_ (u2 :: Double#) -> _!_ D# [] [u2] }; _NO_DEFLT_ } _N_,
- asinh = _A_ 1 _U_ 1 _N_ _S_ "U(P)" {_A_ 1 _U_ 2 _N_ _N_ _N_ _N_} _N_ _N_,
- acosh = _A_ 1 _U_ 1 _N_ _S_ "U(P)" {_A_ 1 _U_ 2 _N_ _N_ _N_ _N_} _N_ _N_,
- atanh = _A_ 1 _U_ 1 _N_ _S_ "U(P)" {_A_ 1 _U_ 2 _N_ _N_ _N_ _N_} _N_ _N_ #-}
+ pi = { _A_ 0 _N_ _N_ _N_ _F_ _IF_ARGS_ 0 0 X 2 _!_ D# [] [3.1415926535897931##] _N_ },
+ exp = { _A_ 1 _U_ 1 _N_ _S_ "U(P)" {_A_ 1 _U_ 2 _N_ _N_ _F_ _IF_ARGS_ 0 1 X 3 \ (u0 :: Double#) -> case _#_ expDouble# [] [u0] of { _PRIM_ (u1 :: Double#) -> _!_ D# [] [u1] } _N_} _F_ _IF_ARGS_ 0 1 C 4 \ (u0 :: Double) -> case u0 of { _ALG_ D# (u1 :: Double#) -> case _#_ expDouble# [] [u1] of { _PRIM_ (u2 :: Double#) -> _!_ D# [] [u2] }; _NO_DEFLT_ } _N_ },
+ log = { _A_ 1 _U_ 1 _N_ _S_ "U(P)" {_A_ 1 _U_ 2 _N_ _N_ _F_ _IF_ARGS_ 0 1 X 3 \ (u0 :: Double#) -> case _#_ logDouble# [] [u0] of { _PRIM_ (u1 :: Double#) -> _!_ D# [] [u1] } _N_} _F_ _IF_ARGS_ 0 1 C 4 \ (u0 :: Double) -> case u0 of { _ALG_ D# (u1 :: Double#) -> case _#_ logDouble# [] [u1] of { _PRIM_ (u2 :: Double#) -> _!_ D# [] [u2] }; _NO_DEFLT_ } _N_ },
+ sqrt = { _A_ 1 _U_ 1 _N_ _S_ "U(P)" {_A_ 1 _U_ 2 _N_ _N_ _F_ _IF_ARGS_ 0 1 X 3 \ (u0 :: Double#) -> case _#_ sqrtDouble# [] [u0] of { _PRIM_ (u1 :: Double#) -> _!_ D# [] [u1] } _N_} _F_ _IF_ARGS_ 0 1 C 4 \ (u0 :: Double) -> case u0 of { _ALG_ D# (u1 :: Double#) -> case _#_ sqrtDouble# [] [u1] of { _PRIM_ (u2 :: Double#) -> _!_ D# [] [u2] }; _NO_DEFLT_ } _N_ },
+ (**) = { _A_ 2 _U_ 11 _N_ _S_ "U(P)U(P)" {_A_ 2 _U_ 22 _N_ _N_ _F_ _IF_ARGS_ 0 2 XX 3 \ (u0 :: Double#) (u1 :: Double#) -> case _#_ powerDouble# [] [u0, u1] of { _PRIM_ (u2 :: Double#) -> _!_ D# [] [u2] } _N_} _F_ _IF_ARGS_ 0 2 CC 5 \ (u0 :: Double) (u1 :: Double) -> case u0 of { _ALG_ D# (u2 :: Double#) -> case u1 of { _ALG_ D# (u3 :: Double#) -> case _#_ powerDouble# [] [u2, u3] of { _PRIM_ (u4 :: Double#) -> _!_ D# [] [u4] }; _NO_DEFLT_ }; _NO_DEFLT_ } _N_ },
+ logBase = { _A_ 2 _U_ 11 _N_ _S_ "U(P)U(P)" {_A_ 2 _U_ 22 _N_ _N_ _F_ _IF_ARGS_ 0 2 XX 5 \ (u0 :: Double#) (u1 :: Double#) -> case _#_ logDouble# [] [u1] of { _PRIM_ (u2 :: Double#) -> case _#_ logDouble# [] [u0] of { _PRIM_ (u3 :: Double#) -> case _#_ divideDouble# [] [u2, u3] of { _PRIM_ (u4 :: Double#) -> _!_ D# [] [u4] } } } _N_} _F_ _IF_ARGS_ 0 2 CC 7 \ (u0 :: Double) (u1 :: Double) -> case u1 of { _ALG_ D# (u2 :: Double#) -> case _#_ logDouble# [] [u2] of { _PRIM_ (u3 :: Double#) -> case u0 of { _ALG_ D# (u4 :: Double#) -> case _#_ logDouble# [] [u4] of { _PRIM_ (u5 :: Double#) -> case _#_ divideDouble# [] [u3, u5] of { _PRIM_ (u6 :: Double#) -> _!_ D# [] [u6] } }; _NO_DEFLT_ } }; _NO_DEFLT_ } _N_ },
+ sin = { _A_ 1 _U_ 1 _N_ _S_ "U(P)" {_A_ 1 _U_ 2 _N_ _N_ _F_ _IF_ARGS_ 0 1 X 3 \ (u0 :: Double#) -> case _#_ sinDouble# [] [u0] of { _PRIM_ (u1 :: Double#) -> _!_ D# [] [u1] } _N_} _F_ _IF_ARGS_ 0 1 C 4 \ (u0 :: Double) -> case u0 of { _ALG_ D# (u1 :: Double#) -> case _#_ sinDouble# [] [u1] of { _PRIM_ (u2 :: Double#) -> _!_ D# [] [u2] }; _NO_DEFLT_ } _N_ },
+ cos = { _A_ 1 _U_ 1 _N_ _S_ "U(P)" {_A_ 1 _U_ 2 _N_ _N_ _F_ _IF_ARGS_ 0 1 X 3 \ (u0 :: Double#) -> case _#_ cosDouble# [] [u0] of { _PRIM_ (u1 :: Double#) -> _!_ D# [] [u1] } _N_} _F_ _IF_ARGS_ 0 1 C 4 \ (u0 :: Double) -> case u0 of { _ALG_ D# (u1 :: Double#) -> case _#_ cosDouble# [] [u1] of { _PRIM_ (u2 :: Double#) -> _!_ D# [] [u2] }; _NO_DEFLT_ } _N_ },
+ tan = { _A_ 1 _U_ 1 _N_ _S_ "U(P)" {_A_ 1 _U_ 2 _N_ _N_ _F_ _IF_ARGS_ 0 1 X 3 \ (u0 :: Double#) -> case _#_ tanDouble# [] [u0] of { _PRIM_ (u1 :: Double#) -> _!_ D# [] [u1] } _N_} _F_ _IF_ARGS_ 0 1 C 4 \ (u0 :: Double) -> case u0 of { _ALG_ D# (u1 :: Double#) -> case _#_ tanDouble# [] [u1] of { _PRIM_ (u2 :: Double#) -> _!_ D# [] [u2] }; _NO_DEFLT_ } _N_ },
+ asin = { _A_ 1 _U_ 1 _N_ _S_ "U(P)" {_A_ 1 _U_ 2 _N_ _N_ _F_ _IF_ARGS_ 0 1 X 3 \ (u0 :: Double#) -> case _#_ asinDouble# [] [u0] of { _PRIM_ (u1 :: Double#) -> _!_ D# [] [u1] } _N_} _F_ _IF_ARGS_ 0 1 C 4 \ (u0 :: Double) -> case u0 of { _ALG_ D# (u1 :: Double#) -> case _#_ asinDouble# [] [u1] of { _PRIM_ (u2 :: Double#) -> _!_ D# [] [u2] }; _NO_DEFLT_ } _N_ },
+ acos = { _A_ 1 _U_ 1 _N_ _S_ "U(P)" {_A_ 1 _U_ 2 _N_ _N_ _F_ _IF_ARGS_ 0 1 X 3 \ (u0 :: Double#) -> case _#_ acosDouble# [] [u0] of { _PRIM_ (u1 :: Double#) -> _!_ D# [] [u1] } _N_} _F_ _IF_ARGS_ 0 1 C 4 \ (u0 :: Double) -> case u0 of { _ALG_ D# (u1 :: Double#) -> case _#_ acosDouble# [] [u1] of { _PRIM_ (u2 :: Double#) -> _!_ D# [] [u2] }; _NO_DEFLT_ } _N_ },
+ atan = { _A_ 1 _U_ 1 _N_ _S_ "U(P)" {_A_ 1 _U_ 2 _N_ _N_ _F_ _IF_ARGS_ 0 1 X 3 \ (u0 :: Double#) -> case _#_ atanDouble# [] [u0] of { _PRIM_ (u1 :: Double#) -> _!_ D# [] [u1] } _N_} _F_ _IF_ARGS_ 0 1 C 4 \ (u0 :: Double) -> case u0 of { _ALG_ D# (u1 :: Double#) -> case _#_ atanDouble# [] [u1] of { _PRIM_ (u2 :: Double#) -> _!_ D# [] [u2] }; _NO_DEFLT_ } _N_ },
+ sinh = { _A_ 1 _U_ 1 _N_ _S_ "U(P)" {_A_ 1 _U_ 2 _N_ _N_ _F_ _IF_ARGS_ 0 1 X 3 \ (u0 :: Double#) -> case _#_ sinhDouble# [] [u0] of { _PRIM_ (u1 :: Double#) -> _!_ D# [] [u1] } _N_} _F_ _IF_ARGS_ 0 1 C 4 \ (u0 :: Double) -> case u0 of { _ALG_ D# (u1 :: Double#) -> case _#_ sinhDouble# [] [u1] of { _PRIM_ (u2 :: Double#) -> _!_ D# [] [u2] }; _NO_DEFLT_ } _N_ },
+ cosh = { _A_ 1 _U_ 1 _N_ _S_ "U(P)" {_A_ 1 _U_ 2 _N_ _N_ _F_ _IF_ARGS_ 0 1 X 3 \ (u0 :: Double#) -> case _#_ coshDouble# [] [u0] of { _PRIM_ (u1 :: Double#) -> _!_ D# [] [u1] } _N_} _F_ _IF_ARGS_ 0 1 C 4 \ (u0 :: Double) -> case u0 of { _ALG_ D# (u1 :: Double#) -> case _#_ coshDouble# [] [u1] of { _PRIM_ (u2 :: Double#) -> _!_ D# [] [u2] }; _NO_DEFLT_ } _N_ },
+ tanh = { _A_ 1 _U_ 1 _N_ _S_ "U(P)" {_A_ 1 _U_ 2 _N_ _N_ _F_ _IF_ARGS_ 0 1 X 3 \ (u0 :: Double#) -> case _#_ tanhDouble# [] [u0] of { _PRIM_ (u1 :: Double#) -> _!_ D# [] [u1] } _N_} _F_ _IF_ARGS_ 0 1 C 4 \ (u0 :: Double) -> case u0 of { _ALG_ D# (u1 :: Double#) -> case _#_ tanhDouble# [] [u1] of { _PRIM_ (u2 :: Double#) -> _!_ D# [] [u2] }; _NO_DEFLT_ } _N_ },
+ asinh = { _A_ 1 _U_ 1 _N_ _S_ "U(P)" {_A_ 1 _U_ 2 _N_ _N_ _N_ _N_} _N_ _N_ },
+ acosh = { _A_ 1 _U_ 1 _N_ _S_ "U(P)" {_A_ 1 _U_ 2 _N_ _N_ _N_ _N_} _N_ _N_ },
+ atanh = { _A_ 1 _U_ 1 _N_ _S_ "U(P)" {_A_ 1 _U_ 2 _N_ _N_ _N_ _N_} _N_ _N_ } #-}
instance Floating Float
{-# GHC_PRAGMA _M_ PreludeCore {-dfun-} _A_ 0 _N_ _N_ _N_ _F_ _IF_ARGS_ 0 0 X 20 _!_ _TUP_19 [{{Fractional Float}}, Float, (Float -> Float), (Float -> Float), (Float -> Float), (Float -> Float -> Float), (Float -> Float -> Float), (Float -> Float), (Float -> Float), (Float -> Float), (Float -> Float), (Float -> Float), (Float -> Float), (Float -> Float), (Float -> Float), (Float -> Float), (Float -> Float), (Float -> Float), (Float -> Float)] [_DFUN_ Fractional (Float), _CONSTM_ Floating pi (Float), _CONSTM_ Floating exp (Float), _CONSTM_ Floating log (Float), _CONSTM_ Floating sqrt (Float), _CONSTM_ Floating (**) (Float), _CONSTM_ Floating logBase (Float), _CONSTM_ Floating sin (Float), _CONSTM_ Floating cos (Float), _CONSTM_ Floating tan (Float), _CONSTM_ Floating asin (Float), _CONSTM_ Floating acos (Float), _CONSTM_ Floating atan (Float), _CONSTM_ Floating sinh (Float), _CONSTM_ Floating cosh (Float), _CONSTM_ Floating tanh (Float), _CONSTM_ Floating asinh (Float), _CONSTM_ Floating acosh (Float), _CONSTM_ Floating atanh (Float)] _N_
- pi = _A_ 0 _N_ _N_ _N_ _F_ _IF_ARGS_ 0 0 X 2 _!_ F# [] [3.1415926535897931#] _N_,
- exp = _A_ 1 _U_ 1 _N_ _S_ "U(P)" {_A_ 1 _U_ 2 _N_ _N_ _F_ _IF_ARGS_ 0 1 X 3 \ (u0 :: Float#) -> case _#_ expFloat# [] [u0] of { _PRIM_ (u1 :: Float#) -> _!_ F# [] [u1] } _N_} _F_ _IF_ARGS_ 0 1 C 4 \ (u0 :: Float) -> case u0 of { _ALG_ F# (u1 :: Float#) -> case _#_ expFloat# [] [u1] of { _PRIM_ (u2 :: Float#) -> _!_ F# [] [u2] }; _NO_DEFLT_ } _N_,
- log = _A_ 1 _U_ 1 _N_ _S_ "U(P)" {_A_ 1 _U_ 2 _N_ _N_ _F_ _IF_ARGS_ 0 1 X 3 \ (u0 :: Float#) -> case _#_ logFloat# [] [u0] of { _PRIM_ (u1 :: Float#) -> _!_ F# [] [u1] } _N_} _F_ _IF_ARGS_ 0 1 C 4 \ (u0 :: Float) -> case u0 of { _ALG_ F# (u1 :: Float#) -> case _#_ logFloat# [] [u1] of { _PRIM_ (u2 :: Float#) -> _!_ F# [] [u2] }; _NO_DEFLT_ } _N_,
- sqrt = _A_ 1 _U_ 1 _N_ _S_ "U(P)" {_A_ 1 _U_ 2 _N_ _N_ _F_ _IF_ARGS_ 0 1 X 3 \ (u0 :: Float#) -> case _#_ sqrtFloat# [] [u0] of { _PRIM_ (u1 :: Float#) -> _!_ F# [] [u1] } _N_} _F_ _IF_ARGS_ 0 1 C 4 \ (u0 :: Float) -> case u0 of { _ALG_ F# (u1 :: Float#) -> case _#_ sqrtFloat# [] [u1] of { _PRIM_ (u2 :: Float#) -> _!_ F# [] [u2] }; _NO_DEFLT_ } _N_,
- (**) = _A_ 2 _U_ 11 _N_ _S_ "U(P)U(P)" {_A_ 2 _U_ 22 _N_ _N_ _F_ _IF_ARGS_ 0 2 XX 3 \ (u0 :: Float#) (u1 :: Float#) -> case _#_ powerFloat# [] [u0, u1] of { _PRIM_ (u2 :: Float#) -> _!_ F# [] [u2] } _N_} _F_ _IF_ARGS_ 0 2 CC 5 \ (u0 :: Float) (u1 :: Float) -> case u0 of { _ALG_ F# (u2 :: Float#) -> case u1 of { _ALG_ F# (u3 :: Float#) -> case _#_ powerFloat# [] [u2, u3] of { _PRIM_ (u4 :: Float#) -> _!_ F# [] [u4] }; _NO_DEFLT_ }; _NO_DEFLT_ } _N_,
- logBase = _A_ 2 _U_ 22 _N_ _N_ _N_ _N_,
- sin = _A_ 1 _U_ 1 _N_ _S_ "U(P)" {_A_ 1 _U_ 2 _N_ _N_ _F_ _IF_ARGS_ 0 1 X 3 \ (u0 :: Float#) -> case _#_ sinFloat# [] [u0] of { _PRIM_ (u1 :: Float#) -> _!_ F# [] [u1] } _N_} _F_ _IF_ARGS_ 0 1 C 4 \ (u0 :: Float) -> case u0 of { _ALG_ F# (u1 :: Float#) -> case _#_ sinFloat# [] [u1] of { _PRIM_ (u2 :: Float#) -> _!_ F# [] [u2] }; _NO_DEFLT_ } _N_,
- cos = _A_ 1 _U_ 1 _N_ _S_ "U(P)" {_A_ 1 _U_ 2 _N_ _N_ _F_ _IF_ARGS_ 0 1 X 3 \ (u0 :: Float#) -> case _#_ cosFloat# [] [u0] of { _PRIM_ (u1 :: Float#) -> _!_ F# [] [u1] } _N_} _F_ _IF_ARGS_ 0 1 C 4 \ (u0 :: Float) -> case u0 of { _ALG_ F# (u1 :: Float#) -> case _#_ cosFloat# [] [u1] of { _PRIM_ (u2 :: Float#) -> _!_ F# [] [u2] }; _NO_DEFLT_ } _N_,
- tan = _A_ 1 _U_ 1 _N_ _S_ "U(P)" {_A_ 1 _U_ 2 _N_ _N_ _F_ _IF_ARGS_ 0 1 X 3 \ (u0 :: Float#) -> case _#_ tanFloat# [] [u0] of { _PRIM_ (u1 :: Float#) -> _!_ F# [] [u1] } _N_} _F_ _IF_ARGS_ 0 1 C 4 \ (u0 :: Float) -> case u0 of { _ALG_ F# (u1 :: Float#) -> case _#_ tanFloat# [] [u1] of { _PRIM_ (u2 :: Float#) -> _!_ F# [] [u2] }; _NO_DEFLT_ } _N_,
- asin = _A_ 1 _U_ 1 _N_ _S_ "U(P)" {_A_ 1 _U_ 2 _N_ _N_ _F_ _IF_ARGS_ 0 1 X 3 \ (u0 :: Float#) -> case _#_ asinFloat# [] [u0] of { _PRIM_ (u1 :: Float#) -> _!_ F# [] [u1] } _N_} _F_ _IF_ARGS_ 0 1 C 4 \ (u0 :: Float) -> case u0 of { _ALG_ F# (u1 :: Float#) -> case _#_ asinFloat# [] [u1] of { _PRIM_ (u2 :: Float#) -> _!_ F# [] [u2] }; _NO_DEFLT_ } _N_,
- acos = _A_ 1 _U_ 1 _N_ _S_ "U(P)" {_A_ 1 _U_ 2 _N_ _N_ _F_ _IF_ARGS_ 0 1 X 3 \ (u0 :: Float#) -> case _#_ acosFloat# [] [u0] of { _PRIM_ (u1 :: Float#) -> _!_ F# [] [u1] } _N_} _F_ _IF_ARGS_ 0 1 C 4 \ (u0 :: Float) -> case u0 of { _ALG_ F# (u1 :: Float#) -> case _#_ acosFloat# [] [u1] of { _PRIM_ (u2 :: Float#) -> _!_ F# [] [u2] }; _NO_DEFLT_ } _N_,
- atan = _A_ 1 _U_ 1 _N_ _S_ "U(P)" {_A_ 1 _U_ 2 _N_ _N_ _F_ _IF_ARGS_ 0 1 X 3 \ (u0 :: Float#) -> case _#_ atanFloat# [] [u0] of { _PRIM_ (u1 :: Float#) -> _!_ F# [] [u1] } _N_} _F_ _IF_ARGS_ 0 1 C 4 \ (u0 :: Float) -> case u0 of { _ALG_ F# (u1 :: Float#) -> case _#_ atanFloat# [] [u1] of { _PRIM_ (u2 :: Float#) -> _!_ F# [] [u2] }; _NO_DEFLT_ } _N_,
- sinh = _A_ 1 _U_ 1 _N_ _S_ "U(P)" {_A_ 1 _U_ 2 _N_ _N_ _F_ _IF_ARGS_ 0 1 X 3 \ (u0 :: Float#) -> case _#_ sinhFloat# [] [u0] of { _PRIM_ (u1 :: Float#) -> _!_ F# [] [u1] } _N_} _F_ _IF_ARGS_ 0 1 C 4 \ (u0 :: Float) -> case u0 of { _ALG_ F# (u1 :: Float#) -> case _#_ sinhFloat# [] [u1] of { _PRIM_ (u2 :: Float#) -> _!_ F# [] [u2] }; _NO_DEFLT_ } _N_,
- cosh = _A_ 1 _U_ 1 _N_ _S_ "U(P)" {_A_ 1 _U_ 2 _N_ _N_ _F_ _IF_ARGS_ 0 1 X 3 \ (u0 :: Float#) -> case _#_ coshFloat# [] [u0] of { _PRIM_ (u1 :: Float#) -> _!_ F# [] [u1] } _N_} _F_ _IF_ARGS_ 0 1 C 4 \ (u0 :: Float) -> case u0 of { _ALG_ F# (u1 :: Float#) -> case _#_ coshFloat# [] [u1] of { _PRIM_ (u2 :: Float#) -> _!_ F# [] [u2] }; _NO_DEFLT_ } _N_,
- tanh = _A_ 1 _U_ 1 _N_ _S_ "U(P)" {_A_ 1 _U_ 2 _N_ _N_ _F_ _IF_ARGS_ 0 1 X 3 \ (u0 :: Float#) -> case _#_ tanhFloat# [] [u0] of { _PRIM_ (u1 :: Float#) -> _!_ F# [] [u1] } _N_} _F_ _IF_ARGS_ 0 1 C 4 \ (u0 :: Float) -> case u0 of { _ALG_ F# (u1 :: Float#) -> case _#_ tanhFloat# [] [u1] of { _PRIM_ (u2 :: Float#) -> _!_ F# [] [u2] }; _NO_DEFLT_ } _N_,
- asinh = _A_ 1 _U_ 1 _N_ _S_ "U(P)" {_A_ 1 _U_ 2 _N_ _N_ _N_ _N_} _N_ _N_,
- acosh = _A_ 1 _U_ 1 _N_ _S_ "U(P)" {_A_ 1 _U_ 2 _N_ _N_ _N_ _N_} _N_ _N_,
- atanh = _A_ 1 _U_ 1 _N_ _S_ "U(P)" {_A_ 1 _U_ 2 _N_ _N_ _N_ _N_} _N_ _N_ #-}
+ pi = { _A_ 0 _N_ _N_ _N_ _F_ _IF_ARGS_ 0 0 X 2 _!_ F# [] [3.1415926535897931#] _N_ },
+ exp = { _A_ 1 _U_ 1 _N_ _S_ "U(P)" {_A_ 1 _U_ 2 _N_ _N_ _F_ _IF_ARGS_ 0 1 X 3 \ (u0 :: Float#) -> case _#_ expFloat# [] [u0] of { _PRIM_ (u1 :: Float#) -> _!_ F# [] [u1] } _N_} _F_ _IF_ARGS_ 0 1 C 4 \ (u0 :: Float) -> case u0 of { _ALG_ F# (u1 :: Float#) -> case _#_ expFloat# [] [u1] of { _PRIM_ (u2 :: Float#) -> _!_ F# [] [u2] }; _NO_DEFLT_ } _N_ },
+ log = { _A_ 1 _U_ 1 _N_ _S_ "U(P)" {_A_ 1 _U_ 2 _N_ _N_ _F_ _IF_ARGS_ 0 1 X 3 \ (u0 :: Float#) -> case _#_ logFloat# [] [u0] of { _PRIM_ (u1 :: Float#) -> _!_ F# [] [u1] } _N_} _F_ _IF_ARGS_ 0 1 C 4 \ (u0 :: Float) -> case u0 of { _ALG_ F# (u1 :: Float#) -> case _#_ logFloat# [] [u1] of { _PRIM_ (u2 :: Float#) -> _!_ F# [] [u2] }; _NO_DEFLT_ } _N_ },
+ sqrt = { _A_ 1 _U_ 1 _N_ _S_ "U(P)" {_A_ 1 _U_ 2 _N_ _N_ _F_ _IF_ARGS_ 0 1 X 3 \ (u0 :: Float#) -> case _#_ sqrtFloat# [] [u0] of { _PRIM_ (u1 :: Float#) -> _!_ F# [] [u1] } _N_} _F_ _IF_ARGS_ 0 1 C 4 \ (u0 :: Float) -> case u0 of { _ALG_ F# (u1 :: Float#) -> case _#_ sqrtFloat# [] [u1] of { _PRIM_ (u2 :: Float#) -> _!_ F# [] [u2] }; _NO_DEFLT_ } _N_ },
+ (**) = { _A_ 2 _U_ 11 _N_ _S_ "U(P)U(P)" {_A_ 2 _U_ 22 _N_ _N_ _F_ _IF_ARGS_ 0 2 XX 3 \ (u0 :: Float#) (u1 :: Float#) -> case _#_ powerFloat# [] [u0, u1] of { _PRIM_ (u2 :: Float#) -> _!_ F# [] [u2] } _N_} _F_ _IF_ARGS_ 0 2 CC 5 \ (u0 :: Float) (u1 :: Float) -> case u0 of { _ALG_ F# (u2 :: Float#) -> case u1 of { _ALG_ F# (u3 :: Float#) -> case _#_ powerFloat# [] [u2, u3] of { _PRIM_ (u4 :: Float#) -> _!_ F# [] [u4] }; _NO_DEFLT_ }; _NO_DEFLT_ } _N_ },
+ logBase = { _A_ 2 _U_ 11 _N_ _S_ "U(P)U(P)" {_A_ 2 _U_ 22 _N_ _N_ _F_ _IF_ARGS_ 0 2 XX 5 \ (u0 :: Float#) (u1 :: Float#) -> case _#_ logFloat# [] [u1] of { _PRIM_ (u2 :: Float#) -> case _#_ logFloat# [] [u0] of { _PRIM_ (u3 :: Float#) -> case _#_ divideFloat# [] [u2, u3] of { _PRIM_ (u4 :: Float#) -> _!_ F# [] [u4] } } } _N_} _F_ _IF_ARGS_ 0 2 CC 7 \ (u0 :: Float) (u1 :: Float) -> case u1 of { _ALG_ F# (u2 :: Float#) -> case _#_ logFloat# [] [u2] of { _PRIM_ (u3 :: Float#) -> case u0 of { _ALG_ F# (u4 :: Float#) -> case _#_ logFloat# [] [u4] of { _PRIM_ (u5 :: Float#) -> case _#_ divideFloat# [] [u3, u5] of { _PRIM_ (u6 :: Float#) -> _!_ F# [] [u6] } }; _NO_DEFLT_ } }; _NO_DEFLT_ } _N_ },
+ sin = { _A_ 1 _U_ 1 _N_ _S_ "U(P)" {_A_ 1 _U_ 2 _N_ _N_ _F_ _IF_ARGS_ 0 1 X 3 \ (u0 :: Float#) -> case _#_ sinFloat# [] [u0] of { _PRIM_ (u1 :: Float#) -> _!_ F# [] [u1] } _N_} _F_ _IF_ARGS_ 0 1 C 4 \ (u0 :: Float) -> case u0 of { _ALG_ F# (u1 :: Float#) -> case _#_ sinFloat# [] [u1] of { _PRIM_ (u2 :: Float#) -> _!_ F# [] [u2] }; _NO_DEFLT_ } _N_ },
+ cos = { _A_ 1 _U_ 1 _N_ _S_ "U(P)" {_A_ 1 _U_ 2 _N_ _N_ _F_ _IF_ARGS_ 0 1 X 3 \ (u0 :: Float#) -> case _#_ cosFloat# [] [u0] of { _PRIM_ (u1 :: Float#) -> _!_ F# [] [u1] } _N_} _F_ _IF_ARGS_ 0 1 C 4 \ (u0 :: Float) -> case u0 of { _ALG_ F# (u1 :: Float#) -> case _#_ cosFloat# [] [u1] of { _PRIM_ (u2 :: Float#) -> _!_ F# [] [u2] }; _NO_DEFLT_ } _N_ },
+ tan = { _A_ 1 _U_ 1 _N_ _S_ "U(P)" {_A_ 1 _U_ 2 _N_ _N_ _F_ _IF_ARGS_ 0 1 X 3 \ (u0 :: Float#) -> case _#_ tanFloat# [] [u0] of { _PRIM_ (u1 :: Float#) -> _!_ F# [] [u1] } _N_} _F_ _IF_ARGS_ 0 1 C 4 \ (u0 :: Float) -> case u0 of { _ALG_ F# (u1 :: Float#) -> case _#_ tanFloat# [] [u1] of { _PRIM_ (u2 :: Float#) -> _!_ F# [] [u2] }; _NO_DEFLT_ } _N_ },
+ asin = { _A_ 1 _U_ 1 _N_ _S_ "U(P)" {_A_ 1 _U_ 2 _N_ _N_ _F_ _IF_ARGS_ 0 1 X 3 \ (u0 :: Float#) -> case _#_ asinFloat# [] [u0] of { _PRIM_ (u1 :: Float#) -> _!_ F# [] [u1] } _N_} _F_ _IF_ARGS_ 0 1 C 4 \ (u0 :: Float) -> case u0 of { _ALG_ F# (u1 :: Float#) -> case _#_ asinFloat# [] [u1] of { _PRIM_ (u2 :: Float#) -> _!_ F# [] [u2] }; _NO_DEFLT_ } _N_ },
+ acos = { _A_ 1 _U_ 1 _N_ _S_ "U(P)" {_A_ 1 _U_ 2 _N_ _N_ _F_ _IF_ARGS_ 0 1 X 3 \ (u0 :: Float#) -> case _#_ acosFloat# [] [u0] of { _PRIM_ (u1 :: Float#) -> _!_ F# [] [u1] } _N_} _F_ _IF_ARGS_ 0 1 C 4 \ (u0 :: Float) -> case u0 of { _ALG_ F# (u1 :: Float#) -> case _#_ acosFloat# [] [u1] of { _PRIM_ (u2 :: Float#) -> _!_ F# [] [u2] }; _NO_DEFLT_ } _N_ },
+ atan = { _A_ 1 _U_ 1 _N_ _S_ "U(P)" {_A_ 1 _U_ 2 _N_ _N_ _F_ _IF_ARGS_ 0 1 X 3 \ (u0 :: Float#) -> case _#_ atanFloat# [] [u0] of { _PRIM_ (u1 :: Float#) -> _!_ F# [] [u1] } _N_} _F_ _IF_ARGS_ 0 1 C 4 \ (u0 :: Float) -> case u0 of { _ALG_ F# (u1 :: Float#) -> case _#_ atanFloat# [] [u1] of { _PRIM_ (u2 :: Float#) -> _!_ F# [] [u2] }; _NO_DEFLT_ } _N_ },
+ sinh = { _A_ 1 _U_ 1 _N_ _S_ "U(P)" {_A_ 1 _U_ 2 _N_ _N_ _F_ _IF_ARGS_ 0 1 X 3 \ (u0 :: Float#) -> case _#_ sinhFloat# [] [u0] of { _PRIM_ (u1 :: Float#) -> _!_ F# [] [u1] } _N_} _F_ _IF_ARGS_ 0 1 C 4 \ (u0 :: Float) -> case u0 of { _ALG_ F# (u1 :: Float#) -> case _#_ sinhFloat# [] [u1] of { _PRIM_ (u2 :: Float#) -> _!_ F# [] [u2] }; _NO_DEFLT_ } _N_ },
+ cosh = { _A_ 1 _U_ 1 _N_ _S_ "U(P)" {_A_ 1 _U_ 2 _N_ _N_ _F_ _IF_ARGS_ 0 1 X 3 \ (u0 :: Float#) -> case _#_ coshFloat# [] [u0] of { _PRIM_ (u1 :: Float#) -> _!_ F# [] [u1] } _N_} _F_ _IF_ARGS_ 0 1 C 4 \ (u0 :: Float) -> case u0 of { _ALG_ F# (u1 :: Float#) -> case _#_ coshFloat# [] [u1] of { _PRIM_ (u2 :: Float#) -> _!_ F# [] [u2] }; _NO_DEFLT_ } _N_ },
+ tanh = { _A_ 1 _U_ 1 _N_ _S_ "U(P)" {_A_ 1 _U_ 2 _N_ _N_ _F_ _IF_ARGS_ 0 1 X 3 \ (u0 :: Float#) -> case _#_ tanhFloat# [] [u0] of { _PRIM_ (u1 :: Float#) -> _!_ F# [] [u1] } _N_} _F_ _IF_ARGS_ 0 1 C 4 \ (u0 :: Float) -> case u0 of { _ALG_ F# (u1 :: Float#) -> case _#_ tanhFloat# [] [u1] of { _PRIM_ (u2 :: Float#) -> _!_ F# [] [u2] }; _NO_DEFLT_ } _N_ },
+ asinh = { _A_ 1 _U_ 1 _N_ _S_ "U(P)" {_A_ 1 _U_ 2 _N_ _N_ _N_ _N_} _N_ _N_ },
+ acosh = { _A_ 1 _U_ 1 _N_ _S_ "U(P)" {_A_ 1 _U_ 2 _N_ _N_ _N_ _N_} _N_ _N_ },
+ atanh = { _A_ 1 _U_ 1 _N_ _S_ "U(P)" {_A_ 1 _U_ 2 _N_ _N_ _N_ _N_} _N_ _N_ } #-}
instance RealFloat a => Fractional (Complex a)
{-# GHC_PRAGMA _M_ PreludeComplex {-dfun-} _A_ 2 _U_ 22 _N_ _N_ _N_ _N_ #-}
instance Fractional (Complex Double)
{-# GHC_PRAGMA _M_ PreludeComplex {-dfun-} _A_ 0 _N_ _N_ _N_ _F_ _IF_ARGS_ 0 0 X 5 _!_ _TUP_4 [{{Num (Complex Double)}}, (Complex Double -> Complex Double -> Complex Double), (Complex Double -> Complex Double), (Ratio Integer -> Complex Double)] [_DFUN_ Num (Complex Double), _CONSTM_ Fractional (/) (Complex Double), _CONSTM_ Fractional recip (Complex Double), _CONSTM_ Fractional fromRational (Complex Double)] _N_
- (/) = _A_ 2 _U_ 11 _N_ _S_ "U(LL)U(LL)" {_A_ 4 _U_ 2222 _N_ _N_ _N_ _N_} _N_ _N_,
- recip = _A_ 1 _U_ 1 _N_ _S_ "U(LL)" {_A_ 2 _U_ 22 _N_ _N_ _N_ _N_} _N_ _N_,
- fromRational = _A_ 1 _U_ 2 _N_ _N_ _N_ _N_ #-}
+ (/) = { _A_ 2 _U_ 11 _N_ _S_ "U(LL)U(LL)" {_A_ 4 _U_ 2222 _N_ _N_ _N_ _N_} _N_ _N_ },
+ recip = { _A_ 1 _U_ 1 _N_ _S_ "U(LL)" {_A_ 2 _U_ 22 _N_ _N_ _N_ _N_} _F_ _IF_ARGS_ 0 1 X 3 \ (u0 :: Complex Double) -> _APP_ _CONSTM_ Fractional (/) (Complex Double) [ _SPEC_ _ORIG_ PreludeCore __i1 [ (Complex Double) ], u0 ] _N_ },
+ fromRational = { _A_ 1 _U_ 1 _N_ _N_ _N_ _N_ } #-}
instance Fractional Double
{-# GHC_PRAGMA _M_ PreludeCore {-dfun-} _A_ 0 _N_ _N_ _N_ _F_ _IF_ARGS_ 0 0 X 5 _!_ _TUP_4 [{{Num Double}}, (Double -> Double -> Double), (Double -> Double), (Ratio Integer -> Double)] [_DFUN_ Num (Double), _CONSTM_ Fractional (/) (Double), _CONSTM_ Fractional recip (Double), _CONSTM_ Fractional fromRational (Double)] _N_
- (/) = _A_ 2 _U_ 11 _N_ _S_ "U(P)U(P)" {_A_ 2 _U_ 22 _N_ _N_ _F_ _IF_ARGS_ 0 2 XX 3 \ (u0 :: Double#) (u1 :: Double#) -> case _#_ divideDouble# [] [u0, u1] of { _PRIM_ (u2 :: Double#) -> _!_ D# [] [u2] } _N_} _F_ _IF_ARGS_ 0 2 CC 5 \ (u0 :: Double) (u1 :: Double) -> case u0 of { _ALG_ D# (u2 :: Double#) -> case u1 of { _ALG_ D# (u3 :: Double#) -> case _#_ divideDouble# [] [u2, u3] of { _PRIM_ (u4 :: Double#) -> _!_ D# [] [u4] }; _NO_DEFLT_ }; _NO_DEFLT_ } _N_,
- recip = _A_ 1 _U_ 1 _N_ _S_ "U(P)" {_A_ 1 _U_ 2 _N_ _N_ _F_ _IF_ARGS_ 0 1 X 3 \ (u0 :: Double#) -> case _#_ divideDouble# [] [1.0000000000000000##, u0] of { _PRIM_ (u1 :: Double#) -> _!_ D# [] [u1] } _N_} _F_ _IF_ARGS_ 0 1 C 4 \ (u0 :: Double) -> case u0 of { _ALG_ D# (u1 :: Double#) -> case _#_ divideDouble# [] [1.0000000000000000##, u1] of { _PRIM_ (u2 :: Double#) -> _!_ D# [] [u2] }; _NO_DEFLT_ } _N_,
- fromRational = _A_ 0 _U_ 2 _N_ _N_ _N_ _N_ #-}
+ (/) = { _A_ 2 _U_ 11 _N_ _S_ "U(P)U(P)" {_A_ 2 _U_ 22 _N_ _N_ _F_ _IF_ARGS_ 0 2 XX 3 \ (u0 :: Double#) (u1 :: Double#) -> case _#_ divideDouble# [] [u0, u1] of { _PRIM_ (u2 :: Double#) -> _!_ D# [] [u2] } _N_} _F_ _IF_ARGS_ 0 2 CC 5 \ (u0 :: Double) (u1 :: Double) -> case u0 of { _ALG_ D# (u2 :: Double#) -> case u1 of { _ALG_ D# (u3 :: Double#) -> case _#_ divideDouble# [] [u2, u3] of { _PRIM_ (u4 :: Double#) -> _!_ D# [] [u4] }; _NO_DEFLT_ }; _NO_DEFLT_ } _N_ },
+ recip = { _A_ 1 _U_ 1 _N_ _S_ "U(P)" {_A_ 1 _U_ 2 _N_ _N_ _F_ _IF_ARGS_ 0 1 X 3 \ (u0 :: Double#) -> case _#_ divideDouble# [] [1.0000000000000000##, u0] of { _PRIM_ (u1 :: Double#) -> _!_ D# [] [u1] } _N_} _F_ _IF_ARGS_ 0 1 C 4 \ (u0 :: Double) -> case u0 of { _ALG_ D# (u1 :: Double#) -> case _#_ divideDouble# [] [1.0000000000000000##, u1] of { _PRIM_ (u2 :: Double#) -> _!_ D# [] [u2] }; _NO_DEFLT_ } _N_ },
+ fromRational = { _A_ 1 _U_ 1 _N_ _S_ "U(U(PPP)U(PPP))" {_A_ 4 _U_ 2222 _N_ _N_ _N_ _N_} _N_ _N_ } #-}
instance Fractional Float
{-# GHC_PRAGMA _M_ PreludeCore {-dfun-} _A_ 0 _N_ _N_ _N_ _F_ _IF_ARGS_ 0 0 X 5 _!_ _TUP_4 [{{Num Float}}, (Float -> Float -> Float), (Float -> Float), (Ratio Integer -> Float)] [_DFUN_ Num (Float), _CONSTM_ Fractional (/) (Float), _CONSTM_ Fractional recip (Float), _CONSTM_ Fractional fromRational (Float)] _N_
- (/) = _A_ 2 _U_ 11 _N_ _S_ "U(P)U(P)" {_A_ 2 _U_ 22 _N_ _N_ _F_ _IF_ARGS_ 0 2 XX 3 \ (u0 :: Float#) (u1 :: Float#) -> case _#_ divideFloat# [] [u0, u1] of { _PRIM_ (u2 :: Float#) -> _!_ F# [] [u2] } _N_} _F_ _IF_ARGS_ 0 2 CC 5 \ (u0 :: Float) (u1 :: Float) -> case u0 of { _ALG_ F# (u2 :: Float#) -> case u1 of { _ALG_ F# (u3 :: Float#) -> case _#_ divideFloat# [] [u2, u3] of { _PRIM_ (u4 :: Float#) -> _!_ F# [] [u4] }; _NO_DEFLT_ }; _NO_DEFLT_ } _N_,
- recip = _A_ 0 _U_ 2 _N_ _N_ _N_ _N_,
- fromRational = _A_ 0 _U_ 2 _N_ _N_ _N_ _N_ #-}
+ (/) = { _A_ 2 _U_ 11 _N_ _S_ "U(P)U(P)" {_A_ 2 _U_ 22 _N_ _N_ _F_ _IF_ARGS_ 0 2 XX 3 \ (u0 :: Float#) (u1 :: Float#) -> case _#_ divideFloat# [] [u0, u1] of { _PRIM_ (u2 :: Float#) -> _!_ F# [] [u2] } _N_} _F_ _IF_ARGS_ 0 2 CC 5 \ (u0 :: Float) (u1 :: Float) -> case u0 of { _ALG_ F# (u2 :: Float#) -> case u1 of { _ALG_ F# (u3 :: Float#) -> case _#_ divideFloat# [] [u2, u3] of { _PRIM_ (u4 :: Float#) -> _!_ F# [] [u4] }; _NO_DEFLT_ }; _NO_DEFLT_ } _N_ },
+ recip = { _A_ 1 _U_ 1 _N_ _S_ "U(P)" {_A_ 1 _U_ 2 _N_ _N_ _F_ _IF_ARGS_ 0 1 X 3 \ (u0 :: Float#) -> case _#_ divideFloat# [] [1.0000000000000000#, u0] of { _PRIM_ (u1 :: Float#) -> _!_ F# [] [u1] } _N_} _F_ _IF_ARGS_ 0 1 C 4 \ (u0 :: Float) -> case u0 of { _ALG_ F# (u1 :: Float#) -> case _#_ divideFloat# [] [1.0000000000000000#, u1] of { _PRIM_ (u2 :: Float#) -> _!_ F# [] [u2] }; _NO_DEFLT_ } _N_ },
+ fromRational = { _A_ 1 _U_ 2 _N_ _N_ _N_ _N_ } #-}
instance Integral a => Fractional (Ratio a)
{-# GHC_PRAGMA _M_ PreludeRatio {-dfun-} _A_ 2 _U_ 22 _N_ _N_ _N_ _N_ #-}
instance Fractional (Ratio Integer)
{-# GHC_PRAGMA _M_ PreludeRatio {-dfun-} _A_ 0 _N_ _N_ _N_ _F_ _IF_ARGS_ 0 0 X 5 _!_ _TUP_4 [{{Num (Ratio Integer)}}, (Ratio Integer -> Ratio Integer -> Ratio Integer), (Ratio Integer -> Ratio Integer), (Ratio Integer -> Ratio Integer)] [_DFUN_ Num (Ratio Integer), _CONSTM_ Fractional (/) (Ratio Integer), _CONSTM_ Fractional recip (Ratio Integer), _CONSTM_ Fractional fromRational (Ratio Integer)] _N_
- (/) = _A_ 2 _U_ 11 _N_ _S_ "U(LU(PPP))U(U(PPP)L)" {_A_ 5 _U_ 22221 _N_ _N_ _N_ _N_} _N_ _N_,
- recip = _A_ 1 _U_ 1 _N_ _S_ "U(U(PPP)L)" {_A_ 4 _U_ 2222 _N_ _N_ _N_ _N_} _N_ _N_,
- fromRational = _A_ 1 _U_ 1 _N_ _S_ "U(LL)" {_A_ 2 _U_ 22 _N_ _N_ _F_ _IF_ARGS_ 0 2 XX 3 \ (u0 :: Integer) (u1 :: Integer) -> _!_ (:%) [Integer] [u0, u1] _N_} _F_ _IF_ARGS_ 0 1 X 1 \ (u0 :: Ratio Integer) -> u0 _N_ #-}
+ (/) = { _A_ 2 _U_ 11 _N_ _S_ "U(LU(PPP))U(U(PPP)L)" {_A_ 5 _U_ 22221 _N_ _N_ _N_ _N_} _N_ _N_ },
+ recip = { _A_ 1 _U_ 1 _N_ _S_ "U(U(PPP)L)" {_A_ 4 _U_ 2222 _N_ _N_ _N_ _N_} _N_ _N_ },
+ fromRational = { _A_ 1 _U_ 1 _N_ _S_ "U(LL)" {_A_ 2 _U_ 22 _N_ _N_ _F_ _IF_ARGS_ 0 2 XX 3 \ (u0 :: Integer) (u1 :: Integer) -> _!_ (:%) [Integer] [u0, u1] _N_} _F_ _IF_ARGS_ 0 1 X 1 \ (u0 :: Ratio Integer) -> u0 _N_ } #-}
instance Integral Int
{-# GHC_PRAGMA _M_ PreludeCore {-dfun-} _A_ 0 _N_ _N_ _N_ _F_ _IF_ARGS_ 0 0 X 13 _!_ _TUP_12 [{{Real Int}}, {{Ix Int}}, (Int -> Int -> Int), (Int -> Int -> Int), (Int -> Int -> Int), (Int -> Int -> Int), (Int -> Int -> (Int, Int)), (Int -> Int -> (Int, Int)), (Int -> Bool), (Int -> Bool), (Int -> Integer), (Int -> Int)] [_DFUN_ Real (Int), _DFUN_ Ix (Int), _CONSTM_ Integral quot (Int), _CONSTM_ Integral rem (Int), _CONSTM_ Integral div (Int), _CONSTM_ Integral mod (Int), _CONSTM_ Integral quotRem (Int), _CONSTM_ Integral divMod (Int), _CONSTM_ Integral even (Int), _CONSTM_ Integral odd (Int), _CONSTM_ Integral toInteger (Int), _CONSTM_ Integral toInt (Int)] _N_
- quot = _A_ 2 _U_ 11 _N_ _S_ "U(P)U(P)" {_A_ 2 _U_ 22 _N_ _N_ _F_ _IF_ARGS_ 0 2 XC 5 \ (u0 :: Int#) (u1 :: Int#) -> case u1 of { _PRIM_ 0# -> _APP_ _TYAPP_ error { Int } [ _NOREP_S_ "Integral.Int.quot{PreludeCore}: divide by 0\n" ]; (u2 :: Int#) -> case _#_ quotInt# [] [u0, u1] of { _PRIM_ (u3 :: Int#) -> _!_ I# [] [u3] } } _N_} _F_ _IF_ARGS_ 0 2 CC 7 \ (u0 :: Int) (u1 :: Int) -> case u1 of { _ALG_ I# (u2 :: Int#) -> case u2 of { _PRIM_ 0# -> _APP_ _TYAPP_ error { Int } [ _NOREP_S_ "Integral.Int.quot{PreludeCore}: divide by 0\n" ]; (u3 :: Int#) -> case u0 of { _ALG_ I# (u4 :: Int#) -> case _#_ quotInt# [] [u4, u2] of { _PRIM_ (u5 :: Int#) -> _!_ I# [] [u5] }; _NO_DEFLT_ } }; _NO_DEFLT_ } _N_,
- rem = _A_ 2 _U_ 11 _N_ _S_ "U(P)U(P)" {_A_ 2 _U_ 22 _N_ _N_ _F_ _IF_ARGS_ 0 2 XC 5 \ (u0 :: Int#) (u1 :: Int#) -> case u1 of { _PRIM_ 0# -> _APP_ _TYAPP_ error { Int } [ _NOREP_S_ "Integral.Int.rem{PreludeCore}: divide by 0\n" ]; (u2 :: Int#) -> case _#_ remInt# [] [u0, u1] of { _PRIM_ (u3 :: Int#) -> _!_ I# [] [u3] } } _N_} _F_ _IF_ARGS_ 0 2 CC 7 \ (u0 :: Int) (u1 :: Int) -> case u1 of { _ALG_ I# (u2 :: Int#) -> case u2 of { _PRIM_ 0# -> _APP_ _TYAPP_ error { Int } [ _NOREP_S_ "Integral.Int.rem{PreludeCore}: divide by 0\n" ]; (u3 :: Int#) -> case u0 of { _ALG_ I# (u4 :: Int#) -> case _#_ remInt# [] [u4, u2] of { _PRIM_ (u5 :: Int#) -> _!_ I# [] [u5] }; _NO_DEFLT_ } }; _NO_DEFLT_ } _N_,
- div = _A_ 2 _U_ 11 _N_ _S_ "U(P)U(P)" {_A_ 2 _U_ 22 _N_ _N_ _N_ _N_} _N_ _N_,
- mod = _A_ 2 _U_ 11 _N_ _S_ "U(P)U(P)" {_A_ 2 _U_ 22 _N_ _N_ _N_ _N_} _N_ _N_,
- quotRem = _A_ 2 _U_ 11 _N_ _S_ "U(P)U(P)" {_A_ 2 _U_ 22 _N_ _N_ _N_ _N_} _N_ _N_,
- divMod = _A_ 2 _U_ 11 _N_ _S_ "U(P)U(P)" {_A_ 2 _U_ 22 _N_ _N_ _N_ _N_} _N_ _N_,
- even = _A_ 1 _U_ 1 _N_ _S_ "U(P)" {_A_ 1 _U_ 2 _N_ _N_ _N_ _N_} _N_ _N_,
- odd = _A_ 1 _U_ 1 _N_ _S_ "U(P)" {_A_ 1 _U_ 2 _N_ _N_ _N_ _N_} _N_ _N_,
- toInteger = _A_ 1 _U_ 1 _N_ _S_ "U(P)" {_A_ 1 _U_ 2 _N_ _N_ _F_ _IF_ARGS_ 0 1 X 1 \ (u0 :: Int#) -> _#_ int2Integer# [] [u0] _N_} _F_ _IF_ARGS_ 0 1 C 2 \ (u0 :: Int) -> case u0 of { _ALG_ I# (u1 :: Int#) -> _#_ int2Integer# [] [u1]; _NO_DEFLT_ } _N_,
- toInt = _A_ 1 _U_ 1 _N_ _S_ "U(P)" {_A_ 1 _U_ 2 _N_ _N_ _F_ _IF_ARGS_ 0 1 X 2 \ (u0 :: Int#) -> _!_ I# [] [u0] _N_} _F_ _IF_ARGS_ 0 1 X 1 \ (u0 :: Int) -> u0 _N_ #-}
+ quot = { _A_ 2 _U_ 11 _N_ _S_ "U(P)U(P)" {_A_ 2 _U_ 22 _N_ _N_ _F_ _IF_ARGS_ 0 2 XC 5 \ (u0 :: Int#) (u1 :: Int#) -> case u1 of { _PRIM_ 0# -> _APP_ _TYAPP_ error { Int } [ _NOREP_S_ "Integral.Int.quot{PreludeCore}: divide by 0\n" ]; (u2 :: Int#) -> case _#_ quotInt# [] [u0, u1] of { _PRIM_ (u3 :: Int#) -> _!_ I# [] [u3] } } _N_} _F_ _IF_ARGS_ 0 2 CC 7 \ (u0 :: Int) (u1 :: Int) -> case u1 of { _ALG_ I# (u2 :: Int#) -> case u2 of { _PRIM_ 0# -> _APP_ _TYAPP_ error { Int } [ _NOREP_S_ "Integral.Int.quot{PreludeCore}: divide by 0\n" ]; (u3 :: Int#) -> case u0 of { _ALG_ I# (u4 :: Int#) -> case _#_ quotInt# [] [u4, u2] of { _PRIM_ (u5 :: Int#) -> _!_ I# [] [u5] }; _NO_DEFLT_ } }; _NO_DEFLT_ } _N_ },
+ rem = { _A_ 2 _U_ 11 _N_ _S_ "U(P)U(P)" {_A_ 2 _U_ 22 _N_ _N_ _F_ _IF_ARGS_ 0 2 XC 5 \ (u0 :: Int#) (u1 :: Int#) -> case u1 of { _PRIM_ 0# -> _APP_ _TYAPP_ error { Int } [ _NOREP_S_ "Integral.Int.rem{PreludeCore}: divide by 0\n" ]; (u2 :: Int#) -> case _#_ remInt# [] [u0, u1] of { _PRIM_ (u3 :: Int#) -> _!_ I# [] [u3] } } _N_} _F_ _IF_ARGS_ 0 2 CC 7 \ (u0 :: Int) (u1 :: Int) -> case u1 of { _ALG_ I# (u2 :: Int#) -> case u2 of { _PRIM_ 0# -> _APP_ _TYAPP_ error { Int } [ _NOREP_S_ "Integral.Int.rem{PreludeCore}: divide by 0\n" ]; (u3 :: Int#) -> case u0 of { _ALG_ I# (u4 :: Int#) -> case _#_ remInt# [] [u4, u2] of { _PRIM_ (u5 :: Int#) -> _!_ I# [] [u5] }; _NO_DEFLT_ } }; _NO_DEFLT_ } _N_ },
+ div = { _A_ 2 _U_ 11 _N_ _S_ "U(P)U(P)" {_A_ 2 _U_ 22 _N_ _N_ _N_ _N_} _N_ _N_ },
+ mod = { _A_ 2 _U_ 11 _N_ _S_ "U(P)U(P)" {_A_ 2 _U_ 22 _N_ _N_ _N_ _N_} _N_ _N_ },
+ quotRem = { _A_ 2 _U_ 11 _N_ _S_ "U(P)U(P)" {_A_ 2 _U_ 22 _N_ _N_ _N_ _N_} _N_ _N_ },
+ divMod = { _A_ 2 _U_ 11 _N_ _S_ "U(P)U(P)" {_A_ 2 _U_ 22 _N_ _N_ _N_ _N_} _N_ _N_ },
+ even = { _A_ 1 _U_ 1 _N_ _S_ "U(P)" {_A_ 1 _U_ 2 _N_ _N_ _N_ _N_} _N_ _N_ },
+ odd = { _A_ 1 _U_ 1 _N_ _S_ "U(P)" {_A_ 1 _U_ 2 _N_ _N_ _N_ _N_} _N_ _N_ },
+ toInteger = { _A_ 1 _U_ 1 _N_ _S_ "U(P)" {_A_ 1 _U_ 2 _N_ _N_ _F_ _IF_ARGS_ 0 1 X 1 \ (u0 :: Int#) -> _#_ int2Integer# [] [u0] _N_} _F_ _IF_ARGS_ 0 1 C 2 \ (u0 :: Int) -> case u0 of { _ALG_ I# (u1 :: Int#) -> _#_ int2Integer# [] [u1]; _NO_DEFLT_ } _N_ },
+ toInt = { _A_ 1 _U_ 1 _N_ _S_ "U(P)" {_A_ 1 _U_ 2 _N_ _N_ _F_ _IF_ARGS_ 0 1 X 2 \ (u0 :: Int#) -> _!_ I# [] [u0] _N_} _F_ _IF_ARGS_ 0 1 X 1 \ (u0 :: Int) -> u0 _N_ } #-}
instance Integral Integer
{-# GHC_PRAGMA _M_ PreludeCore {-dfun-} _A_ 0 _N_ _N_ _N_ _F_ _IF_ARGS_ 0 0 X 13 _!_ _TUP_12 [{{Real Integer}}, {{Ix Integer}}, (Integer -> Integer -> Integer), (Integer -> Integer -> Integer), (Integer -> Integer -> Integer), (Integer -> Integer -> Integer), (Integer -> Integer -> (Integer, Integer)), (Integer -> Integer -> (Integer, Integer)), (Integer -> Bool), (Integer -> Bool), (Integer -> Integer), (Integer -> Int)] [_DFUN_ Real (Integer), _DFUN_ Ix (Integer), _CONSTM_ Integral quot (Integer), _CONSTM_ Integral rem (Integer), _CONSTM_ Integral div (Integer), _CONSTM_ Integral mod (Integer), _CONSTM_ Integral quotRem (Integer), _CONSTM_ Integral divMod (Integer), _CONSTM_ Integral even (Integer), _CONSTM_ Integral odd (Integer), _CONSTM_ Integral toInteger (Integer), _CONSTM_ Integral toInt (Integer)] _N_
- quot = _A_ 2 _U_ 11 _N_ _S_ "U(PPP)U(PPP)" {_A_ 4 _U_ 2221 _N_ _N_ _F_ _IF_ARGS_ 0 4 XXXX 7 \ (u0 :: Int#) (u1 :: Int#) (u2 :: ByteArray#) (u3 :: Integer) -> case _APP_ _WRKR_ _CONSTM_ Integral quotRem (Integer) [ u0, u1, u2, u3 ] of { _ALG_ _TUP_2 (u4 :: Integer) (u5 :: Integer) -> u4; _NO_DEFLT_ } _N_} _F_ _IF_ARGS_ 0 2 XX 5 \ (u0 :: Integer) (u1 :: Integer) -> case _APP_ _CONSTM_ Integral quotRem (Integer) [ u0, u1 ] of { _ALG_ _TUP_2 (u2 :: Integer) (u3 :: Integer) -> u2; _NO_DEFLT_ } _N_,
- rem = _A_ 2 _U_ 11 _N_ _S_ "U(PPP)U(PPP)" {_A_ 4 _U_ 2221 _N_ _N_ _F_ _IF_ARGS_ 0 4 XXXX 7 \ (u0 :: Int#) (u1 :: Int#) (u2 :: ByteArray#) (u3 :: Integer) -> case _APP_ _WRKR_ _CONSTM_ Integral quotRem (Integer) [ u0, u1, u2, u3 ] of { _ALG_ _TUP_2 (u4 :: Integer) (u5 :: Integer) -> u5; _NO_DEFLT_ } _N_} _F_ _IF_ARGS_ 0 2 XX 5 \ (u0 :: Integer) (u1 :: Integer) -> case _APP_ _CONSTM_ Integral quotRem (Integer) [ u0, u1 ] of { _ALG_ _TUP_2 (u2 :: Integer) (u3 :: Integer) -> u3; _NO_DEFLT_ } _N_,
- div = _A_ 2 _U_ 12 _N_ _S_ "U(PPP)U(PPP)" {_A_ 4 _U_ 2222 _N_ _N_ _F_ _IF_ARGS_ 0 4 XXXX 7 \ (u0 :: Int#) (u1 :: Int#) (u2 :: ByteArray#) (u3 :: Integer) -> case _APP_ _WRKR_ _CONSTM_ Integral divMod (Integer) [ u0, u1, u2, u3 ] of { _ALG_ _TUP_2 (u4 :: Integer) (u5 :: Integer) -> u4; _NO_DEFLT_ } _N_} _F_ _IF_ARGS_ 0 2 XX 5 \ (u0 :: Integer) (u1 :: Integer) -> case _APP_ _CONSTM_ Integral divMod (Integer) [ u0, u1 ] of { _ALG_ _TUP_2 (u2 :: Integer) (u3 :: Integer) -> u2; _NO_DEFLT_ } _N_,
- mod = _A_ 2 _U_ 12 _N_ _S_ "U(PPP)U(PPP)" {_A_ 4 _U_ 2222 _N_ _N_ _F_ _IF_ARGS_ 0 4 XXXX 7 \ (u0 :: Int#) (u1 :: Int#) (u2 :: ByteArray#) (u3 :: Integer) -> case _APP_ _WRKR_ _CONSTM_ Integral divMod (Integer) [ u0, u1, u2, u3 ] of { _ALG_ _TUP_2 (u4 :: Integer) (u5 :: Integer) -> u5; _NO_DEFLT_ } _N_} _F_ _IF_ARGS_ 0 2 XX 5 \ (u0 :: Integer) (u1 :: Integer) -> case _APP_ _CONSTM_ Integral divMod (Integer) [ u0, u1 ] of { _ALG_ _TUP_2 (u2 :: Integer) (u3 :: Integer) -> u3; _NO_DEFLT_ } _N_,
- quotRem = _A_ 2 _U_ 11 _N_ _S_ "U(PPP)U(PPP)" {_A_ 4 _U_ 2221 _N_ _N_ _N_ _N_} _N_ _N_,
- divMod = _A_ 2 _U_ 12 _N_ _S_ "U(PPP)U(PPP)" {_A_ 4 _U_ 2222 _N_ _N_ _N_ _N_} _N_ _N_,
- even = _A_ 1 _U_ 1 _N_ _S_ "U(PPP)" {_A_ 3 _U_ 222 _N_ _N_ _N_ _N_} _N_ _N_,
- odd = _A_ 1 _U_ 1 _N_ _S_ "U(PPP)" {_A_ 3 _U_ 222 _N_ _N_ _N_ _N_} _N_ _N_,
- toInteger = _A_ 1 _U_ 1 _N_ _S_ "U(PPP)" {_A_ 3 _U_ 222 _N_ _N_ _F_ _IF_ARGS_ 0 3 XXX 4 \ (u0 :: Int#) (u1 :: Int#) (u2 :: ByteArray#) -> _!_ J# [] [u0, u1, u2] _N_} _F_ _IF_ARGS_ 0 1 X 1 \ (u0 :: Integer) -> u0 _N_,
- toInt = _A_ 1 _U_ 1 _N_ _S_ "U(PPP)" {_A_ 3 _U_ 222 _N_ _N_ _F_ _IF_ARGS_ 0 3 XXX 3 \ (u0 :: Int#) (u1 :: Int#) (u2 :: ByteArray#) -> case _#_ integer2Int# [] [u0, u1, u2] of { _PRIM_ (u3 :: Int#) -> _!_ I# [] [u3] } _N_} _F_ _IF_ARGS_ 0 1 C 4 \ (u0 :: Integer) -> case u0 of { _ALG_ J# (u1 :: Int#) (u2 :: Int#) (u3 :: ByteArray#) -> case _#_ integer2Int# [] [u1, u2, u3] of { _PRIM_ (u4 :: Int#) -> _!_ I# [] [u4] }; _NO_DEFLT_ } _N_ #-}
+ quot = { _A_ 2 _U_ 11 _N_ _S_ "U(PPP)U(PPP)" {_A_ 4 _U_ 2221 _N_ _N_ _F_ _IF_ARGS_ 0 4 XXXX 7 \ (u0 :: Int#) (u1 :: Int#) (u2 :: ByteArray#) (u3 :: Integer) -> case _APP_ _WRKR_ _CONSTM_ Integral quotRem (Integer) [ u0, u1, u2, u3 ] of { _ALG_ _TUP_2 (u4 :: Integer) (u5 :: Integer) -> u4; _NO_DEFLT_ } _N_} _F_ _IF_ARGS_ 0 2 XX 5 \ (u0 :: Integer) (u1 :: Integer) -> case _APP_ _CONSTM_ Integral quotRem (Integer) [ u0, u1 ] of { _ALG_ _TUP_2 (u2 :: Integer) (u3 :: Integer) -> u2; _NO_DEFLT_ } _N_ },
+ rem = { _A_ 2 _U_ 11 _N_ _S_ "U(PPP)U(PPP)" {_A_ 4 _U_ 2221 _N_ _N_ _F_ _IF_ARGS_ 0 4 XXXX 7 \ (u0 :: Int#) (u1 :: Int#) (u2 :: ByteArray#) (u3 :: Integer) -> case _APP_ _WRKR_ _CONSTM_ Integral quotRem (Integer) [ u0, u1, u2, u3 ] of { _ALG_ _TUP_2 (u4 :: Integer) (u5 :: Integer) -> u5; _NO_DEFLT_ } _N_} _F_ _IF_ARGS_ 0 2 XX 5 \ (u0 :: Integer) (u1 :: Integer) -> case _APP_ _CONSTM_ Integral quotRem (Integer) [ u0, u1 ] of { _ALG_ _TUP_2 (u2 :: Integer) (u3 :: Integer) -> u3; _NO_DEFLT_ } _N_ },
+ div = { _A_ 2 _U_ 12 _N_ _S_ "U(PPP)U(PPP)" {_A_ 4 _U_ 2222 _N_ _N_ _F_ _IF_ARGS_ 0 4 XXXX 7 \ (u0 :: Int#) (u1 :: Int#) (u2 :: ByteArray#) (u3 :: Integer) -> case _APP_ _WRKR_ _CONSTM_ Integral divMod (Integer) [ u0, u1, u2, u3 ] of { _ALG_ _TUP_2 (u4 :: Integer) (u5 :: Integer) -> u4; _NO_DEFLT_ } _N_} _F_ _IF_ARGS_ 0 2 XX 5 \ (u0 :: Integer) (u1 :: Integer) -> case _APP_ _CONSTM_ Integral divMod (Integer) [ u0, u1 ] of { _ALG_ _TUP_2 (u2 :: Integer) (u3 :: Integer) -> u2; _NO_DEFLT_ } _N_ },
+ mod = { _A_ 2 _U_ 12 _N_ _S_ "U(PPP)U(PPP)" {_A_ 4 _U_ 2222 _N_ _N_ _F_ _IF_ARGS_ 0 4 XXXX 7 \ (u0 :: Int#) (u1 :: Int#) (u2 :: ByteArray#) (u3 :: Integer) -> case _APP_ _WRKR_ _CONSTM_ Integral divMod (Integer) [ u0, u1, u2, u3 ] of { _ALG_ _TUP_2 (u4 :: Integer) (u5 :: Integer) -> u5; _NO_DEFLT_ } _N_} _F_ _IF_ARGS_ 0 2 XX 5 \ (u0 :: Integer) (u1 :: Integer) -> case _APP_ _CONSTM_ Integral divMod (Integer) [ u0, u1 ] of { _ALG_ _TUP_2 (u2 :: Integer) (u3 :: Integer) -> u3; _NO_DEFLT_ } _N_ },
+ quotRem = { _A_ 2 _U_ 11 _N_ _S_ "U(PPP)U(PPP)" {_A_ 4 _U_ 2221 _N_ _N_ _N_ _N_} _N_ _N_ },
+ divMod = { _A_ 2 _U_ 12 _N_ _S_ "U(PPP)U(PPP)" {_A_ 4 _U_ 2222 _N_ _N_ _N_ _N_} _N_ _N_ },
+ even = { _A_ 1 _U_ 1 _N_ _S_ "U(PPP)" {_A_ 3 _U_ 222 _N_ _N_ _N_ _N_} _N_ _N_ },
+ odd = { _A_ 1 _U_ 1 _N_ _S_ "U(PPP)" {_A_ 3 _U_ 222 _N_ _N_ _N_ _N_} _N_ _N_ },
+ toInteger = { _A_ 1 _U_ 1 _N_ _S_ "U(PPP)" {_A_ 3 _U_ 222 _N_ _N_ _F_ _IF_ARGS_ 0 3 XXX 4 \ (u0 :: Int#) (u1 :: Int#) (u2 :: ByteArray#) -> _!_ J# [] [u0, u1, u2] _N_} _F_ _IF_ARGS_ 0 1 X 1 \ (u0 :: Integer) -> u0 _N_ },
+ toInt = { _A_ 1 _U_ 1 _N_ _S_ "U(PPP)" {_A_ 3 _U_ 222 _N_ _N_ _F_ _IF_ARGS_ 0 3 XXX 3 \ (u0 :: Int#) (u1 :: Int#) (u2 :: ByteArray#) -> case _#_ integer2Int# [] [u0, u1, u2] of { _PRIM_ (u3 :: Int#) -> _!_ I# [] [u3] } _N_} _F_ _IF_ARGS_ 0 1 C 4 \ (u0 :: Integer) -> case u0 of { _ALG_ J# (u1 :: Int#) (u2 :: Int#) (u3 :: ByteArray#) -> case _#_ integer2Int# [] [u1, u2, u3] of { _PRIM_ (u4 :: Int#) -> _!_ I# [] [u4] }; _NO_DEFLT_ } _N_ } #-}
instance Ix ()
{-# GHC_PRAGMA _M_ PreludeBuiltin {-dfun-} _A_ 0 _N_ _N_ _N_ _F_ _IF_ARGS_ 0 0 X 5 _!_ _TUP_4 [{{Ord ()}}, (((), ()) -> [()]), (((), ()) -> () -> Int), (((), ()) -> () -> Bool)] [_DFUN_ Ord (()), _CONSTM_ Ix range (()), _CONSTM_ Ix index (()), _CONSTM_ Ix inRange (())] _N_
- range = _A_ 1 _U_ 1 _N_ _S_ "U(EE)" {_A_ 2 _U_ 21 _N_ _N_ _N_ _N_} _N_ _N_,
- index = _A_ 2 _U_ 11 _N_ _S_ "U(EE)E" {_A_ 3 _U_ 111 _N_ _N_ _F_ _IF_ARGS_ 0 3 CCC 5 \ (u0 :: ()) (u1 :: ()) (u2 :: ()) -> case u0 of { _ALG_ _TUP_0 -> case u1 of { _ALG_ _TUP_0 -> case u2 of { _ALG_ _TUP_0 -> _!_ I# [] [0#]; _NO_DEFLT_ }; _NO_DEFLT_ }; _NO_DEFLT_ } _N_} _F_ _IF_ARGS_ 0 2 CC 6 \ (u0 :: ((), ())) (u1 :: ()) -> case u0 of { _ALG_ _TUP_2 (u2 :: ()) (u3 :: ()) -> case u2 of { _ALG_ _TUP_0 -> case u3 of { _ALG_ _TUP_0 -> case u1 of { _ALG_ _TUP_0 -> _!_ I# [] [0#]; _NO_DEFLT_ }; _NO_DEFLT_ }; _NO_DEFLT_ }; _NO_DEFLT_ } _N_,
- inRange = _A_ 2 _U_ 11 _N_ _S_ "U(EE)E" {_A_ 3 _U_ 111 _N_ _N_ _F_ _IF_ARGS_ 0 3 CCC 4 \ (u0 :: ()) (u1 :: ()) (u2 :: ()) -> case u0 of { _ALG_ _TUP_0 -> case u1 of { _ALG_ _TUP_0 -> case u2 of { _ALG_ _TUP_0 -> _!_ True [] []; _NO_DEFLT_ }; _NO_DEFLT_ }; _NO_DEFLT_ } _N_} _F_ _IF_ARGS_ 0 2 CC 5 \ (u0 :: ((), ())) (u1 :: ()) -> case u0 of { _ALG_ _TUP_2 (u2 :: ()) (u3 :: ()) -> case u2 of { _ALG_ _TUP_0 -> case u3 of { _ALG_ _TUP_0 -> case u1 of { _ALG_ _TUP_0 -> _!_ True [] []; _NO_DEFLT_ }; _NO_DEFLT_ }; _NO_DEFLT_ }; _NO_DEFLT_ } _N_ #-}
+ range = { _A_ 1 _U_ 1 _N_ _S_ "U(EE)" {_A_ 2 _U_ 21 _N_ _N_ _N_ _N_} _N_ _N_ },
+ index = { _A_ 2 _U_ 11 _N_ _S_ "U(EE)E" {_A_ 3 _U_ 111 _N_ _N_ _F_ _IF_ARGS_ 0 3 CCC 5 \ (u0 :: ()) (u1 :: ()) (u2 :: ()) -> case u0 of { _ALG_ _TUP_0 -> case u1 of { _ALG_ _TUP_0 -> case u2 of { _ALG_ _TUP_0 -> _!_ I# [] [0#]; _NO_DEFLT_ }; _NO_DEFLT_ }; _NO_DEFLT_ } _N_} _F_ _IF_ARGS_ 0 2 CC 6 \ (u0 :: ((), ())) (u1 :: ()) -> case u0 of { _ALG_ _TUP_2 (u2 :: ()) (u3 :: ()) -> case u2 of { _ALG_ _TUP_0 -> case u3 of { _ALG_ _TUP_0 -> case u1 of { _ALG_ _TUP_0 -> _!_ I# [] [0#]; _NO_DEFLT_ }; _NO_DEFLT_ }; _NO_DEFLT_ }; _NO_DEFLT_ } _N_ },
+ inRange = { _A_ 2 _U_ 11 _N_ _S_ "U(EE)E" {_A_ 3 _U_ 111 _N_ _N_ _F_ _IF_ARGS_ 0 3 CCC 4 \ (u0 :: ()) (u1 :: ()) (u2 :: ()) -> case u0 of { _ALG_ _TUP_0 -> case u1 of { _ALG_ _TUP_0 -> case u2 of { _ALG_ _TUP_0 -> _!_ True [] []; _NO_DEFLT_ }; _NO_DEFLT_ }; _NO_DEFLT_ } _N_} _F_ _IF_ARGS_ 0 2 CC 5 \ (u0 :: ((), ())) (u1 :: ()) -> case u0 of { _ALG_ _TUP_2 (u2 :: ()) (u3 :: ()) -> case u2 of { _ALG_ _TUP_0 -> case u3 of { _ALG_ _TUP_0 -> case u1 of { _ALG_ _TUP_0 -> _!_ True [] []; _NO_DEFLT_ }; _NO_DEFLT_ }; _NO_DEFLT_ }; _NO_DEFLT_ } _N_ } #-}
instance (Ix a, Ix b) => Ix (a, b)
{-# GHC_PRAGMA _M_ PreludeBuiltin {-dfun-} _A_ 3 _U_ 222 _N_ _N_ _N_ _N_ #-}
instance (Ix a, Ix b, Ix c) => Ix (a, b, c)
{-# GHC_PRAGMA _M_ PreludeBuiltin {-dfun-} _A_ 6 _U_ 222222 _N_ _N_ _N_ _N_ #-}
instance Ix (Int, Int)
{-# GHC_PRAGMA _M_ PreludeBuiltin {-dfun-} _A_ 0 _N_ _N_ _N_ _F_ _IF_ARGS_ 0 0 X 5 _!_ _TUP_4 [{{Ord (Int, Int)}}, (((Int, Int), (Int, Int)) -> [(Int, Int)]), (((Int, Int), (Int, Int)) -> (Int, Int) -> Int), (((Int, Int), (Int, Int)) -> (Int, Int) -> Bool)] [_DFUN_ Ord ((Int, Int)), _CONSTM_ Ix range ((Int, Int)), _CONSTM_ Ix index ((Int, Int)), _CONSTM_ Ix inRange ((Int, Int))] _N_
- range = _A_ 1 _U_ 1 _N_ _S_ "U(SS)" {_A_ 2 _U_ 11 _N_ _N_ _N_ _N_} _N_ _N_,
- index = _A_ 2 _U_ 11 _N_ _S_ "U(SS)U(U(P)U(P))" {_A_ 4 _U_ 1122 _N_ _N_ _N_ _N_} _N_ _N_,
- inRange = _A_ 2 _U_ 11 _N_ _S_ "U(SS)U(U(P)L)" {_A_ 4 _U_ 1121 _N_ _N_ _N_ _N_} _N_ _N_ #-}
+ range = { _A_ 1 _U_ 1 _N_ _S_ "U(SS)" {_A_ 2 _U_ 11 _N_ _N_ _N_ _N_} _N_ _N_ },
+ index = { _A_ 2 _U_ 11 _N_ _S_ "U(SS)U(U(P)U(P))" {_A_ 4 _U_ 1122 _N_ _N_ _N_ _N_} _N_ _N_ },
+ inRange = { _A_ 2 _U_ 11 _N_ _S_ "U(SS)U(U(P)L)" {_A_ 4 _U_ 1121 _N_ _N_ _N_ _N_} _N_ _N_ } #-}
instance (Ix a, Ix b) => Ix (Assoc a b)
{-# GHC_PRAGMA _M_ PreludeArray {-dfun-} _A_ 3 _U_ 222 _N_ _N_ _N_ _N_ #-}
instance Ix Bool
{-# GHC_PRAGMA _M_ PreludeCore {-dfun-} _A_ 0 _N_ _N_ _N_ _F_ _IF_ARGS_ 0 0 X 5 _!_ _TUP_4 [{{Ord Bool}}, ((Bool, Bool) -> [Bool]), ((Bool, Bool) -> Bool -> Int), ((Bool, Bool) -> Bool -> Bool)] [_DFUN_ Ord (Bool), _CONSTM_ Ix range (Bool), _CONSTM_ Ix index (Bool), _CONSTM_ Ix inRange (Bool)] _N_
- range = _A_ 1 _U_ 1 _N_ _S_ "U(EE)" {_A_ 2 _U_ 11 _N_ _N_ _N_ _N_} _N_ _N_,
- index = _A_ 2 _U_ 11 _N_ _S_ "U(EA)E" {_A_ 2 _U_ 11 _N_ _N_ _N_ _N_} _N_ _N_,
- inRange = _A_ 2 _U_ 12 _N_ _S_ "U(EL)E" {_A_ 3 _U_ 112 _N_ _N_ _N_ _N_} _N_ _N_ #-}
+ range = { _A_ 1 _U_ 1 _N_ _S_ "U(EE)" {_A_ 2 _U_ 11 _N_ _N_ _N_ _N_} _N_ _N_ },
+ index = { _A_ 2 _U_ 11 _N_ _S_ "U(EA)E" {_A_ 2 _U_ 11 _N_ _N_ _N_ _N_} _N_ _N_ },
+ inRange = { _A_ 2 _U_ 12 _N_ _S_ "U(EL)E" {_A_ 3 _U_ 112 _N_ _N_ _N_ _N_} _N_ _N_ } #-}
instance Ix Char
{-# GHC_PRAGMA _M_ PreludeCore {-dfun-} _A_ 0 _N_ _N_ _N_ _F_ _IF_ARGS_ 0 0 X 5 _!_ _TUP_4 [{{Ord Char}}, ((Char, Char) -> [Char]), ((Char, Char) -> Char -> Int), ((Char, Char) -> Char -> Bool)] [_DFUN_ Ord (Char), _CONSTM_ Ix range (Char), _CONSTM_ Ix index (Char), _CONSTM_ Ix inRange (Char)] _N_
- range = _A_ 1 _U_ 1 _N_ _S_ "U(LL)" {_A_ 2 _U_ 22 _N_ _N_ _F_ _IF_ARGS_ 0 0 X 1 _CONSTM_ Enum enumFromTo (Char) _N_} _F_ _IF_ARGS_ 0 1 C 4 \ (u0 :: (Char, Char)) -> case u0 of { _ALG_ _TUP_2 (u1 :: Char) (u2 :: Char) -> _APP_ _CONSTM_ Enum enumFromTo (Char) [ u1, u2 ]; _NO_DEFLT_ } _N_,
- index = _A_ 2 _U_ 11 _N_ _S_ "U(U(P)L)U(P)" {_A_ 3 _U_ 212 _N_ _N_ _N_ _N_} _N_ _N_,
- inRange = _A_ 2 _U_ 11 _N_ _S_ "U(U(P)L)U(P)" {_A_ 3 _U_ 212 _N_ _N_ _N_ _N_} _N_ _N_ #-}
+ range = { _A_ 1 _U_ 1 _N_ _S_ "U(U(P)L)" {_A_ 2 _U_ 22 _N_ _N_ _N_ _N_} _F_ _IF_ARGS_ 0 1 C 4 \ (u0 :: (Char, Char)) -> case u0 of { _ALG_ _TUP_2 (u1 :: Char) (u2 :: Char) -> _APP_ _CONSTM_ Enum enumFromTo (Char) [ u1, u2 ]; _NO_DEFLT_ } _N_ },
+ index = { _A_ 2 _U_ 11 _N_ _S_ "U(U(P)L)U(P)" {_A_ 3 _U_ 212 _N_ _N_ _N_ _N_} _N_ _N_ },
+ inRange = { _A_ 2 _U_ 11 _N_ _S_ "U(U(P)L)U(P)" {_A_ 3 _U_ 212 _N_ _N_ _N_ _N_} _N_ _N_ } #-}
instance Ix Int
{-# GHC_PRAGMA _M_ PreludeCore {-dfun-} _A_ 0 _N_ _N_ _N_ _F_ _IF_ARGS_ 0 0 X 5 _!_ _TUP_4 [{{Ord Int}}, ((Int, Int) -> [Int]), ((Int, Int) -> Int -> Int), ((Int, Int) -> Int -> Bool)] [_DFUN_ Ord (Int), _CONSTM_ Ix range (Int), _CONSTM_ Ix index (Int), _CONSTM_ Ix inRange (Int)] _N_
- range = _A_ 1 _U_ 1 _N_ _S_ "U(U(P)U(P))" {_A_ 2 _U_ 22 _N_ _N_ _N_ _N_} _N_ _N_,
- index = _A_ 2 _U_ 11 _N_ _S_ "U(U(P)U(P))U(P)" {_A_ 3 _U_ 222 _N_ _N_ _N_ _N_} _N_ _N_,
- inRange = _A_ 2 _U_ 11 _N_ _S_ "U(U(P)U(P))U(P)" {_A_ 3 _U_ 222 _N_ _N_ _F_ _IF_ARGS_ 0 3 XXX 5 \ (u0 :: Int#) (u1 :: Int#) (u2 :: Int#) -> case _#_ leInt# [] [u0, u2] of { _ALG_ True -> _#_ leInt# [] [u2, u1]; False -> _!_ False [] []; _NO_DEFLT_ } _N_} _F_ _ALWAYS_ \ (u0 :: (Int, Int)) (u1 :: Int) -> case u0 of { _ALG_ _TUP_2 (u2 :: Int) (u3 :: Int) -> case u2 of { _ALG_ I# (u4 :: Int#) -> case u3 of { _ALG_ I# (u5 :: Int#) -> case u1 of { _ALG_ I# (u6 :: Int#) -> case _#_ leInt# [] [u4, u6] of { _ALG_ True -> _#_ leInt# [] [u6, u5]; False -> _!_ False [] []; _NO_DEFLT_ }; _NO_DEFLT_ }; _NO_DEFLT_ }; _NO_DEFLT_ }; _NO_DEFLT_ } _N_ #-}
+ range = { _A_ 1 _U_ 1 _N_ _S_ "U(U(P)U(P))" {_A_ 2 _U_ 22 _N_ _N_ _N_ _N_} _N_ _N_ },
+ index = { _A_ 2 _U_ 11 _N_ _S_ "U(U(P)U(P))U(P)" {_A_ 3 _U_ 222 _N_ _N_ _N_ _N_} _N_ _N_ },
+ inRange = { _A_ 2 _U_ 11 _N_ _S_ "U(U(P)U(P))U(P)" {_A_ 3 _U_ 222 _N_ _N_ _F_ _IF_ARGS_ 0 3 XXX 5 \ (u0 :: Int#) (u1 :: Int#) (u2 :: Int#) -> case _#_ leInt# [] [u0, u2] of { _ALG_ True -> _#_ leInt# [] [u2, u1]; False -> _!_ False [] []; _NO_DEFLT_ } _N_} _F_ _ALWAYS_ \ (u0 :: (Int, Int)) (u1 :: Int) -> case u0 of { _ALG_ _TUP_2 (u2 :: Int) (u3 :: Int) -> case u2 of { _ALG_ I# (u4 :: Int#) -> case u3 of { _ALG_ I# (u5 :: Int#) -> case u1 of { _ALG_ I# (u6 :: Int#) -> case _#_ leInt# [] [u4, u6] of { _ALG_ True -> _#_ leInt# [] [u6, u5]; False -> _!_ False [] []; _NO_DEFLT_ }; _NO_DEFLT_ }; _NO_DEFLT_ }; _NO_DEFLT_ }; _NO_DEFLT_ } _N_ } #-}
instance Ix Integer
{-# GHC_PRAGMA _M_ PreludeCore {-dfun-} _A_ 0 _N_ _N_ _N_ _F_ _IF_ARGS_ 0 0 X 5 _!_ _TUP_4 [{{Ord Integer}}, ((Integer, Integer) -> [Integer]), ((Integer, Integer) -> Integer -> Int), ((Integer, Integer) -> Integer -> Bool)] [_DFUN_ Ord (Integer), _CONSTM_ Ix range (Integer), _CONSTM_ Ix index (Integer), _CONSTM_ Ix inRange (Integer)] _N_
- range = _A_ 1 _U_ 1 _N_ _S_ "U(LL)" {_A_ 2 _U_ 22 _N_ _N_ _F_ _IF_ARGS_ 0 0 X 1 _CONSTM_ Enum enumFromTo (Integer) _N_} _F_ _IF_ARGS_ 0 1 C 4 \ (u0 :: (Integer, Integer)) -> case u0 of { _ALG_ _TUP_2 (u1 :: Integer) (u2 :: Integer) -> _APP_ _CONSTM_ Enum enumFromTo (Integer) [ u1, u2 ]; _NO_DEFLT_ } _N_,
- index = _A_ 2 _U_ 12 _N_ _S_ "U(U(PPP)L)U(PPP)" {_A_ 5 _U_ 22222 _N_ _N_ _N_ _N_} _N_ _N_,
- inRange = _A_ 2 _U_ 11 _N_ _S_ "U(U(PPP)L)U(PPP)" {_A_ 5 _U_ 22211 _N_ _N_ _F_ _IF_ARGS_ 0 5 XXXCC 9 \ (u0 :: Int#) (u1 :: Int#) (u2 :: ByteArray#) (u3 :: Integer) (u4 :: Integer) -> case u4 of { _ALG_ J# (u5 :: Int#) (u6 :: Int#) (u7 :: ByteArray#) -> case _#_ cmpInteger# [] [u0, u1, u2, u5, u6, u7] of { _PRIM_ (u8 :: Int#) -> case _#_ leInt# [] [u8, 0#] of { _ALG_ True -> case u3 of { _ALG_ J# (u9 :: Int#) (ua :: Int#) (ub :: ByteArray#) -> case _#_ cmpInteger# [] [u5, u6, u7, u9, ua, ub] of { _PRIM_ (uc :: Int#) -> _#_ leInt# [] [uc, 0#] }; _NO_DEFLT_ }; False -> _!_ False [] []; _NO_DEFLT_ } }; _NO_DEFLT_ } _N_} _N_ _N_ #-}
+ range = { _A_ 1 _U_ 1 _N_ _S_ "U(LL)" {_A_ 2 _U_ 22 _N_ _N_ _F_ _IF_ARGS_ 0 0 X 1 _CONSTM_ Enum enumFromTo (Integer) _N_} _F_ _IF_ARGS_ 0 1 C 4 \ (u0 :: (Integer, Integer)) -> case u0 of { _ALG_ _TUP_2 (u1 :: Integer) (u2 :: Integer) -> _APP_ _CONSTM_ Enum enumFromTo (Integer) [ u1, u2 ]; _NO_DEFLT_ } _N_ },
+ index = { _A_ 2 _U_ 12 _N_ _S_ "U(U(PPP)L)U(PPP)" {_A_ 5 _U_ 22222 _N_ _N_ _N_ _N_} _N_ _N_ },
+ inRange = { _A_ 2 _U_ 11 _N_ _S_ "U(U(PPP)L)U(PPP)" {_A_ 5 _U_ 22211 _N_ _N_ _F_ _IF_ARGS_ 0 5 XXXCC 9 \ (u0 :: Int#) (u1 :: Int#) (u2 :: ByteArray#) (u3 :: Integer) (u4 :: Integer) -> case u4 of { _ALG_ J# (u5 :: Int#) (u6 :: Int#) (u7 :: ByteArray#) -> case _#_ cmpInteger# [] [u0, u1, u2, u5, u6, u7] of { _PRIM_ (u8 :: Int#) -> case _#_ leInt# [] [u8, 0#] of { _ALG_ True -> case u3 of { _ALG_ J# (u9 :: Int#) (ua :: Int#) (ub :: ByteArray#) -> case _#_ cmpInteger# [] [u5, u6, u7, u9, ua, ub] of { _PRIM_ (uc :: Int#) -> _#_ leInt# [] [uc, 0#] }; _NO_DEFLT_ }; False -> _!_ False [] []; _NO_DEFLT_ } }; _NO_DEFLT_ } _N_} _N_ _N_ } #-}
instance RealFloat a => Num (Complex a)
{-# GHC_PRAGMA _M_ PreludeComplex {-dfun-} _A_ 3 _U_ 222 _N_ _N_ _N_ _N_ #-}
instance Num (Complex Double)
- {-# GHC_PRAGMA _M_ PreludeComplex {-dfun-} _A_ 0 _N_ _N_ _N_ _N_ _N_
- (+) = _A_ 2 _U_ 11 _N_ _S_ "U(LL)U(LL)" {_A_ 4 _U_ 1111 _N_ _N_ _N_ _N_} _N_ _N_,
- (-) = _A_ 2 _U_ 11 _N_ _S_ "U(LL)U(LL)" {_A_ 4 _U_ 1111 _N_ _N_ _N_ _N_} _N_ _N_,
- (*) = _A_ 2 _U_ 11 _N_ _S_ "U(LL)U(LL)" {_A_ 4 _U_ 2222 _N_ _N_ _N_ _N_} _N_ _N_,
- negate = _A_ 1 _U_ 1 _N_ _S_ "U(LL)" {_A_ 2 _U_ 11 _N_ _N_ _N_ _N_} _N_ _N_,
- abs = _A_ 1 _U_ 1 _N_ _N_ _N_ _N_,
- signum = _A_ 1 _U_ 1 _N_ _S_ "U(U(P)L)" {_A_ 2 _U_ 22 _N_ _N_ _N_ _N_} _N_ _N_,
- fromInteger = _A_ 1 _U_ 1 _N_ _N_ _N_ _N_,
- fromInt = _A_ 1 _U_ 1 _N_ _N_ _N_ _N_ #-}
+ {-# GHC_PRAGMA _M_ PreludeComplex {-dfun-} _A_ 0 _N_ _N_ _N_ _F_ _IF_ARGS_ 0 0 X 11 _!_ _TUP_10 [{{Eq (Complex Double)}}, {{Text (Complex Double)}}, (Complex Double -> Complex Double -> Complex Double), (Complex Double -> Complex Double -> Complex Double), (Complex Double -> Complex Double -> Complex Double), (Complex Double -> Complex Double), (Complex Double -> Complex Double), (Complex Double -> Complex Double), (Integer -> Complex Double), (Int -> Complex Double)] [_DFUN_ Eq (Complex Double), _DFUN_ Text (Complex Double), _CONSTM_ Num (+) (Complex Double), _CONSTM_ Num (-) (Complex Double), _CONSTM_ Num (*) (Complex Double), _CONSTM_ Num negate (Complex Double), _CONSTM_ Num abs (Complex Double), _CONSTM_ Num signum (Complex Double), _CONSTM_ Num fromInteger (Complex Double), _CONSTM_ Num fromInt (Complex Double)] _N_
+ (+) = { _A_ 2 _U_ 11 _N_ _S_ "U(LL)U(LL)" {_A_ 4 _U_ 1111 _N_ _N_ _N_ _N_} _N_ _N_ },
+ (-) = { _A_ 2 _U_ 11 _N_ _S_ "U(LL)U(LL)" {_A_ 4 _U_ 1111 _N_ _N_ _N_ _N_} _N_ _N_ },
+ (*) = { _A_ 2 _U_ 11 _N_ _S_ "U(LL)U(LL)" {_A_ 4 _U_ 2222 _N_ _N_ _N_ _N_} _N_ _N_ },
+ negate = { _A_ 1 _U_ 1 _N_ _S_ "U(LL)" {_A_ 2 _U_ 11 _N_ _N_ _N_ _N_} _N_ _N_ },
+ abs = { _A_ 1 _U_ 1 _N_ _N_ _N_ _N_ },
+ signum = { _A_ 1 _U_ 1 _N_ _S_ "U(U(P)L)" {_A_ 2 _U_ 22 _N_ _N_ _N_ _N_} _N_ _N_ },
+ fromInteger = { _A_ 1 _U_ 1 _N_ _N_ _N_ _N_ },
+ fromInt = { _A_ 1 _U_ 1 _N_ _N_ _N_ _N_ } #-}
instance Num Double
{-# GHC_PRAGMA _M_ PreludeCore {-dfun-} _A_ 0 _N_ _N_ _N_ _F_ _IF_ARGS_ 0 0 X 11 _!_ _TUP_10 [{{Eq Double}}, {{Text Double}}, (Double -> Double -> Double), (Double -> Double -> Double), (Double -> Double -> Double), (Double -> Double), (Double -> Double), (Double -> Double), (Integer -> Double), (Int -> Double)] [_DFUN_ Eq (Double), _DFUN_ Text (Double), _CONSTM_ Num (+) (Double), _CONSTM_ Num (-) (Double), _CONSTM_ Num (*) (Double), _CONSTM_ Num negate (Double), _CONSTM_ Num abs (Double), _CONSTM_ Num signum (Double), _CONSTM_ Num fromInteger (Double), _CONSTM_ Num fromInt (Double)] _N_
- (+) = _A_ 2 _U_ 11 _N_ _S_ "U(P)U(P)" {_A_ 2 _U_ 22 _N_ _N_ _F_ _IF_ARGS_ 0 2 XX 3 \ (u0 :: Double#) (u1 :: Double#) -> case _#_ plusDouble# [] [u0, u1] of { _PRIM_ (u2 :: Double#) -> _!_ D# [] [u2] } _N_} _F_ _IF_ARGS_ 0 2 CC 5 \ (u0 :: Double) (u1 :: Double) -> case u0 of { _ALG_ D# (u2 :: Double#) -> case u1 of { _ALG_ D# (u3 :: Double#) -> case _#_ plusDouble# [] [u2, u3] of { _PRIM_ (u4 :: Double#) -> _!_ D# [] [u4] }; _NO_DEFLT_ }; _NO_DEFLT_ } _N_,
- (-) = _A_ 2 _U_ 11 _N_ _S_ "U(P)U(P)" {_A_ 2 _U_ 22 _N_ _N_ _F_ _IF_ARGS_ 0 2 XX 3 \ (u0 :: Double#) (u1 :: Double#) -> case _#_ minusDouble# [] [u0, u1] of { _PRIM_ (u2 :: Double#) -> _!_ D# [] [u2] } _N_} _F_ _IF_ARGS_ 0 2 CC 5 \ (u0 :: Double) (u1 :: Double) -> case u0 of { _ALG_ D# (u2 :: Double#) -> case u1 of { _ALG_ D# (u3 :: Double#) -> case _#_ minusDouble# [] [u2, u3] of { _PRIM_ (u4 :: Double#) -> _!_ D# [] [u4] }; _NO_DEFLT_ }; _NO_DEFLT_ } _N_,
- (*) = _A_ 2 _U_ 11 _N_ _S_ "U(P)U(P)" {_A_ 2 _U_ 22 _N_ _N_ _F_ _IF_ARGS_ 0 2 XX 3 \ (u0 :: Double#) (u1 :: Double#) -> case _#_ timesDouble# [] [u0, u1] of { _PRIM_ (u2 :: Double#) -> _!_ D# [] [u2] } _N_} _F_ _IF_ARGS_ 0 2 CC 5 \ (u0 :: Double) (u1 :: Double) -> case u0 of { _ALG_ D# (u2 :: Double#) -> case u1 of { _ALG_ D# (u3 :: Double#) -> case _#_ timesDouble# [] [u2, u3] of { _PRIM_ (u4 :: Double#) -> _!_ D# [] [u4] }; _NO_DEFLT_ }; _NO_DEFLT_ } _N_,
- negate = _A_ 1 _U_ 1 _N_ _S_ "U(P)" {_A_ 1 _U_ 2 _N_ _N_ _F_ _IF_ARGS_ 0 1 X 3 \ (u0 :: Double#) -> case _#_ negateDouble# [] [u0] of { _PRIM_ (u1 :: Double#) -> _!_ D# [] [u1] } _N_} _F_ _IF_ARGS_ 0 1 C 4 \ (u0 :: Double) -> case u0 of { _ALG_ D# (u1 :: Double#) -> case _#_ negateDouble# [] [u1] of { _PRIM_ (u2 :: Double#) -> _!_ D# [] [u2] }; _NO_DEFLT_ } _N_,
- abs = _A_ 1 _U_ 1 _N_ _S_ "U(P)" {_A_ 1 _U_ 2 _N_ _N_ _N_ _N_} _N_ _N_,
- signum = _A_ 1 _U_ 1 _N_ _S_ "U(P)" {_A_ 1 _U_ 2 _N_ _N_ _N_ _N_} _N_ _N_,
- fromInteger = _A_ 1 _U_ 1 _N_ _S_ "U(PPP)" {_A_ 3 _U_ 222 _N_ _N_ _F_ _IF_ARGS_ 0 3 XXX 3 \ (u0 :: Int#) (u1 :: Int#) (u2 :: ByteArray#) -> case _#_ encodeDouble# [] [u0, u1, u2, 0#] of { _PRIM_ (u3 :: Double#) -> _!_ D# [] [u3] } _N_} _F_ _IF_ARGS_ 0 1 C 4 \ (u0 :: Integer) -> case u0 of { _ALG_ J# (u1 :: Int#) (u2 :: Int#) (u3 :: ByteArray#) -> case _#_ encodeDouble# [] [u1, u2, u3, 0#] of { _PRIM_ (u4 :: Double#) -> _!_ D# [] [u4] }; _NO_DEFLT_ } _N_,
- fromInt = _A_ 1 _U_ 1 _N_ _S_ "U(P)" {_A_ 1 _U_ 2 _N_ _N_ _F_ _IF_ARGS_ 0 1 X 3 \ (u0 :: Int#) -> case _#_ int2Double# [] [u0] of { _PRIM_ (u1 :: Double#) -> _!_ D# [] [u1] } _N_} _F_ _IF_ARGS_ 0 1 C 4 \ (u0 :: Int) -> case u0 of { _ALG_ I# (u1 :: Int#) -> case _#_ int2Double# [] [u1] of { _PRIM_ (u2 :: Double#) -> _!_ D# [] [u2] }; _NO_DEFLT_ } _N_ #-}
+ (+) = { _A_ 2 _U_ 11 _N_ _S_ "U(P)U(P)" {_A_ 2 _U_ 22 _N_ _N_ _F_ _IF_ARGS_ 0 2 XX 3 \ (u0 :: Double#) (u1 :: Double#) -> case _#_ plusDouble# [] [u0, u1] of { _PRIM_ (u2 :: Double#) -> _!_ D# [] [u2] } _N_} _F_ _IF_ARGS_ 0 2 CC 5 \ (u0 :: Double) (u1 :: Double) -> case u0 of { _ALG_ D# (u2 :: Double#) -> case u1 of { _ALG_ D# (u3 :: Double#) -> case _#_ plusDouble# [] [u2, u3] of { _PRIM_ (u4 :: Double#) -> _!_ D# [] [u4] }; _NO_DEFLT_ }; _NO_DEFLT_ } _N_ },
+ (-) = { _A_ 2 _U_ 11 _N_ _S_ "U(P)U(P)" {_A_ 2 _U_ 22 _N_ _N_ _F_ _IF_ARGS_ 0 2 XX 3 \ (u0 :: Double#) (u1 :: Double#) -> case _#_ minusDouble# [] [u0, u1] of { _PRIM_ (u2 :: Double#) -> _!_ D# [] [u2] } _N_} _F_ _IF_ARGS_ 0 2 CC 5 \ (u0 :: Double) (u1 :: Double) -> case u0 of { _ALG_ D# (u2 :: Double#) -> case u1 of { _ALG_ D# (u3 :: Double#) -> case _#_ minusDouble# [] [u2, u3] of { _PRIM_ (u4 :: Double#) -> _!_ D# [] [u4] }; _NO_DEFLT_ }; _NO_DEFLT_ } _N_ },
+ (*) = { _A_ 2 _U_ 11 _N_ _S_ "U(P)U(P)" {_A_ 2 _U_ 22 _N_ _N_ _F_ _IF_ARGS_ 0 2 XX 3 \ (u0 :: Double#) (u1 :: Double#) -> case _#_ timesDouble# [] [u0, u1] of { _PRIM_ (u2 :: Double#) -> _!_ D# [] [u2] } _N_} _F_ _IF_ARGS_ 0 2 CC 5 \ (u0 :: Double) (u1 :: Double) -> case u0 of { _ALG_ D# (u2 :: Double#) -> case u1 of { _ALG_ D# (u3 :: Double#) -> case _#_ timesDouble# [] [u2, u3] of { _PRIM_ (u4 :: Double#) -> _!_ D# [] [u4] }; _NO_DEFLT_ }; _NO_DEFLT_ } _N_ },
+ negate = { _A_ 1 _U_ 1 _N_ _S_ "U(P)" {_A_ 1 _U_ 2 _N_ _N_ _F_ _IF_ARGS_ 0 1 X 3 \ (u0 :: Double#) -> case _#_ negateDouble# [] [u0] of { _PRIM_ (u1 :: Double#) -> _!_ D# [] [u1] } _N_} _F_ _IF_ARGS_ 0 1 C 4 \ (u0 :: Double) -> case u0 of { _ALG_ D# (u1 :: Double#) -> case _#_ negateDouble# [] [u1] of { _PRIM_ (u2 :: Double#) -> _!_ D# [] [u2] }; _NO_DEFLT_ } _N_ },
+ abs = { _A_ 1 _U_ 1 _N_ _S_ "U(P)" {_A_ 1 _U_ 2 _N_ _N_ _N_ _N_} _N_ _N_ },
+ signum = { _A_ 1 _U_ 1 _N_ _S_ "U(P)" {_A_ 1 _U_ 2 _N_ _N_ _N_ _N_} _N_ _N_ },
+ fromInteger = { _A_ 1 _U_ 1 _N_ _S_ "U(PPP)" {_A_ 3 _U_ 222 _N_ _N_ _F_ _IF_ARGS_ 0 3 XXX 3 \ (u0 :: Int#) (u1 :: Int#) (u2 :: ByteArray#) -> case _#_ encodeDouble# [] [u0, u1, u2, 0#] of { _PRIM_ (u3 :: Double#) -> _!_ D# [] [u3] } _N_} _F_ _IF_ARGS_ 0 1 C 4 \ (u0 :: Integer) -> case u0 of { _ALG_ J# (u1 :: Int#) (u2 :: Int#) (u3 :: ByteArray#) -> case _#_ encodeDouble# [] [u1, u2, u3, 0#] of { _PRIM_ (u4 :: Double#) -> _!_ D# [] [u4] }; _NO_DEFLT_ } _N_ },
+ fromInt = { _A_ 1 _U_ 1 _N_ _S_ "U(P)" {_A_ 1 _U_ 2 _N_ _N_ _F_ _IF_ARGS_ 0 1 X 3 \ (u0 :: Int#) -> case _#_ int2Double# [] [u0] of { _PRIM_ (u1 :: Double#) -> _!_ D# [] [u1] } _N_} _F_ _IF_ARGS_ 0 1 C 4 \ (u0 :: Int) -> case u0 of { _ALG_ I# (u1 :: Int#) -> case _#_ int2Double# [] [u1] of { _PRIM_ (u2 :: Double#) -> _!_ D# [] [u2] }; _NO_DEFLT_ } _N_ } #-}
instance Num Float
{-# GHC_PRAGMA _M_ PreludeCore {-dfun-} _A_ 0 _N_ _N_ _N_ _F_ _IF_ARGS_ 0 0 X 11 _!_ _TUP_10 [{{Eq Float}}, {{Text Float}}, (Float -> Float -> Float), (Float -> Float -> Float), (Float -> Float -> Float), (Float -> Float), (Float -> Float), (Float -> Float), (Integer -> Float), (Int -> Float)] [_DFUN_ Eq (Float), _DFUN_ Text (Float), _CONSTM_ Num (+) (Float), _CONSTM_ Num (-) (Float), _CONSTM_ Num (*) (Float), _CONSTM_ Num negate (Float), _CONSTM_ Num abs (Float), _CONSTM_ Num signum (Float), _CONSTM_ Num fromInteger (Float), _CONSTM_ Num fromInt (Float)] _N_
- (+) = _A_ 2 _U_ 11 _N_ _S_ "U(P)U(P)" {_A_ 2 _U_ 22 _N_ _N_ _F_ _IF_ARGS_ 0 2 XX 3 \ (u0 :: Float#) (u1 :: Float#) -> case _#_ plusFloat# [] [u0, u1] of { _PRIM_ (u2 :: Float#) -> _!_ F# [] [u2] } _N_} _F_ _IF_ARGS_ 0 2 CC 5 \ (u0 :: Float) (u1 :: Float) -> case u0 of { _ALG_ F# (u2 :: Float#) -> case u1 of { _ALG_ F# (u3 :: Float#) -> case _#_ plusFloat# [] [u2, u3] of { _PRIM_ (u4 :: Float#) -> _!_ F# [] [u4] }; _NO_DEFLT_ }; _NO_DEFLT_ } _N_,
- (-) = _A_ 2 _U_ 11 _N_ _S_ "U(P)U(P)" {_A_ 2 _U_ 22 _N_ _N_ _F_ _IF_ARGS_ 0 2 XX 3 \ (u0 :: Float#) (u1 :: Float#) -> case _#_ minusFloat# [] [u0, u1] of { _PRIM_ (u2 :: Float#) -> _!_ F# [] [u2] } _N_} _F_ _IF_ARGS_ 0 2 CC 5 \ (u0 :: Float) (u1 :: Float) -> case u0 of { _ALG_ F# (u2 :: Float#) -> case u1 of { _ALG_ F# (u3 :: Float#) -> case _#_ minusFloat# [] [u2, u3] of { _PRIM_ (u4 :: Float#) -> _!_ F# [] [u4] }; _NO_DEFLT_ }; _NO_DEFLT_ } _N_,
- (*) = _A_ 2 _U_ 11 _N_ _S_ "U(P)U(P)" {_A_ 2 _U_ 22 _N_ _N_ _F_ _IF_ARGS_ 0 2 XX 3 \ (u0 :: Float#) (u1 :: Float#) -> case _#_ timesFloat# [] [u0, u1] of { _PRIM_ (u2 :: Float#) -> _!_ F# [] [u2] } _N_} _F_ _IF_ARGS_ 0 2 CC 5 \ (u0 :: Float) (u1 :: Float) -> case u0 of { _ALG_ F# (u2 :: Float#) -> case u1 of { _ALG_ F# (u3 :: Float#) -> case _#_ timesFloat# [] [u2, u3] of { _PRIM_ (u4 :: Float#) -> _!_ F# [] [u4] }; _NO_DEFLT_ }; _NO_DEFLT_ } _N_,
- negate = _A_ 1 _U_ 1 _N_ _S_ "U(P)" {_A_ 1 _U_ 2 _N_ _N_ _F_ _IF_ARGS_ 0 1 X 3 \ (u0 :: Float#) -> case _#_ negateFloat# [] [u0] of { _PRIM_ (u1 :: Float#) -> _!_ F# [] [u1] } _N_} _F_ _IF_ARGS_ 0 1 C 4 \ (u0 :: Float) -> case u0 of { _ALG_ F# (u1 :: Float#) -> case _#_ negateFloat# [] [u1] of { _PRIM_ (u2 :: Float#) -> _!_ F# [] [u2] }; _NO_DEFLT_ } _N_,
- abs = _A_ 1 _U_ 1 _N_ _S_ "U(P)" {_A_ 1 _U_ 2 _N_ _N_ _N_ _N_} _N_ _N_,
- signum = _A_ 1 _U_ 1 _N_ _S_ "U(P)" {_A_ 1 _U_ 2 _N_ _N_ _N_ _N_} _N_ _N_,
- fromInteger = _A_ 1 _U_ 1 _N_ _S_ "U(PPP)" {_A_ 3 _U_ 222 _N_ _N_ _F_ _IF_ARGS_ 0 3 XXX 3 \ (u0 :: Int#) (u1 :: Int#) (u2 :: ByteArray#) -> case _#_ encodeFloat# [] [u0, u1, u2, 0#] of { _PRIM_ (u3 :: Float#) -> _!_ F# [] [u3] } _N_} _F_ _IF_ARGS_ 0 1 C 4 \ (u0 :: Integer) -> case u0 of { _ALG_ J# (u1 :: Int#) (u2 :: Int#) (u3 :: ByteArray#) -> case _#_ encodeFloat# [] [u1, u2, u3, 0#] of { _PRIM_ (u4 :: Float#) -> _!_ F# [] [u4] }; _NO_DEFLT_ } _N_,
- fromInt = _A_ 1 _U_ 1 _N_ _S_ "U(P)" {_A_ 1 _U_ 2 _N_ _N_ _F_ _IF_ARGS_ 0 1 X 3 \ (u0 :: Int#) -> case _#_ int2Float# [] [u0] of { _PRIM_ (u1 :: Float#) -> _!_ F# [] [u1] } _N_} _F_ _IF_ARGS_ 0 1 C 4 \ (u0 :: Int) -> case u0 of { _ALG_ I# (u1 :: Int#) -> case _#_ int2Float# [] [u1] of { _PRIM_ (u2 :: Float#) -> _!_ F# [] [u2] }; _NO_DEFLT_ } _N_ #-}
+ (+) = { _A_ 2 _U_ 11 _N_ _S_ "U(P)U(P)" {_A_ 2 _U_ 22 _N_ _N_ _F_ _IF_ARGS_ 0 2 XX 3 \ (u0 :: Float#) (u1 :: Float#) -> case _#_ plusFloat# [] [u0, u1] of { _PRIM_ (u2 :: Float#) -> _!_ F# [] [u2] } _N_} _F_ _IF_ARGS_ 0 2 CC 5 \ (u0 :: Float) (u1 :: Float) -> case u0 of { _ALG_ F# (u2 :: Float#) -> case u1 of { _ALG_ F# (u3 :: Float#) -> case _#_ plusFloat# [] [u2, u3] of { _PRIM_ (u4 :: Float#) -> _!_ F# [] [u4] }; _NO_DEFLT_ }; _NO_DEFLT_ } _N_ },
+ (-) = { _A_ 2 _U_ 11 _N_ _S_ "U(P)U(P)" {_A_ 2 _U_ 22 _N_ _N_ _F_ _IF_ARGS_ 0 2 XX 3 \ (u0 :: Float#) (u1 :: Float#) -> case _#_ minusFloat# [] [u0, u1] of { _PRIM_ (u2 :: Float#) -> _!_ F# [] [u2] } _N_} _F_ _IF_ARGS_ 0 2 CC 5 \ (u0 :: Float) (u1 :: Float) -> case u0 of { _ALG_ F# (u2 :: Float#) -> case u1 of { _ALG_ F# (u3 :: Float#) -> case _#_ minusFloat# [] [u2, u3] of { _PRIM_ (u4 :: Float#) -> _!_ F# [] [u4] }; _NO_DEFLT_ }; _NO_DEFLT_ } _N_ },
+ (*) = { _A_ 2 _U_ 11 _N_ _S_ "U(P)U(P)" {_A_ 2 _U_ 22 _N_ _N_ _F_ _IF_ARGS_ 0 2 XX 3 \ (u0 :: Float#) (u1 :: Float#) -> case _#_ timesFloat# [] [u0, u1] of { _PRIM_ (u2 :: Float#) -> _!_ F# [] [u2] } _N_} _F_ _IF_ARGS_ 0 2 CC 5 \ (u0 :: Float) (u1 :: Float) -> case u0 of { _ALG_ F# (u2 :: Float#) -> case u1 of { _ALG_ F# (u3 :: Float#) -> case _#_ timesFloat# [] [u2, u3] of { _PRIM_ (u4 :: Float#) -> _!_ F# [] [u4] }; _NO_DEFLT_ }; _NO_DEFLT_ } _N_ },
+ negate = { _A_ 1 _U_ 1 _N_ _S_ "U(P)" {_A_ 1 _U_ 2 _N_ _N_ _F_ _IF_ARGS_ 0 1 X 3 \ (u0 :: Float#) -> case _#_ negateFloat# [] [u0] of { _PRIM_ (u1 :: Float#) -> _!_ F# [] [u1] } _N_} _F_ _IF_ARGS_ 0 1 C 4 \ (u0 :: Float) -> case u0 of { _ALG_ F# (u1 :: Float#) -> case _#_ negateFloat# [] [u1] of { _PRIM_ (u2 :: Float#) -> _!_ F# [] [u2] }; _NO_DEFLT_ } _N_ },
+ abs = { _A_ 1 _U_ 1 _N_ _S_ "U(P)" {_A_ 1 _U_ 2 _N_ _N_ _N_ _N_} _N_ _N_ },
+ signum = { _A_ 1 _U_ 1 _N_ _S_ "U(P)" {_A_ 1 _U_ 2 _N_ _N_ _N_ _N_} _N_ _N_ },
+ fromInteger = { _A_ 1 _U_ 1 _N_ _S_ "U(PPP)" {_A_ 3 _U_ 222 _N_ _N_ _F_ _IF_ARGS_ 0 3 XXX 3 \ (u0 :: Int#) (u1 :: Int#) (u2 :: ByteArray#) -> case _#_ encodeFloat# [] [u0, u1, u2, 0#] of { _PRIM_ (u3 :: Float#) -> _!_ F# [] [u3] } _N_} _F_ _IF_ARGS_ 0 1 C 4 \ (u0 :: Integer) -> case u0 of { _ALG_ J# (u1 :: Int#) (u2 :: Int#) (u3 :: ByteArray#) -> case _#_ encodeFloat# [] [u1, u2, u3, 0#] of { _PRIM_ (u4 :: Float#) -> _!_ F# [] [u4] }; _NO_DEFLT_ } _N_ },
+ fromInt = { _A_ 1 _U_ 1 _N_ _S_ "U(P)" {_A_ 1 _U_ 2 _N_ _N_ _F_ _IF_ARGS_ 0 1 X 3 \ (u0 :: Int#) -> case _#_ int2Float# [] [u0] of { _PRIM_ (u1 :: Float#) -> _!_ F# [] [u1] } _N_} _F_ _IF_ARGS_ 0 1 C 4 \ (u0 :: Int) -> case u0 of { _ALG_ I# (u1 :: Int#) -> case _#_ int2Float# [] [u1] of { _PRIM_ (u2 :: Float#) -> _!_ F# [] [u2] }; _NO_DEFLT_ } _N_ } #-}
instance Num Int
{-# GHC_PRAGMA _M_ PreludeCore {-dfun-} _A_ 0 _N_ _N_ _N_ _F_ _IF_ARGS_ 0 0 X 11 _!_ _TUP_10 [{{Eq Int}}, {{Text Int}}, (Int -> Int -> Int), (Int -> Int -> Int), (Int -> Int -> Int), (Int -> Int), (Int -> Int), (Int -> Int), (Integer -> Int), (Int -> Int)] [_DFUN_ Eq (Int), _DFUN_ Text (Int), _CONSTM_ Num (+) (Int), _CONSTM_ Num (-) (Int), _CONSTM_ Num (*) (Int), _CONSTM_ Num negate (Int), _CONSTM_ Num abs (Int), _CONSTM_ Num signum (Int), _CONSTM_ Num fromInteger (Int), _CONSTM_ Num fromInt (Int)] _N_
- (+) = _A_ 2 _U_ 11 _N_ _S_ "U(P)U(P)" {_A_ 2 _U_ 22 _N_ _N_ _F_ _IF_ARGS_ 0 2 XX 3 \ (u0 :: Int#) (u1 :: Int#) -> case _#_ plusInt# [] [u0, u1] of { _PRIM_ (u2 :: Int#) -> _!_ I# [] [u2] } _N_} _F_ _IF_ARGS_ 0 2 CC 5 \ (u0 :: Int) (u1 :: Int) -> case u0 of { _ALG_ I# (u2 :: Int#) -> case u1 of { _ALG_ I# (u3 :: Int#) -> case _#_ plusInt# [] [u2, u3] of { _PRIM_ (u4 :: Int#) -> _!_ I# [] [u4] }; _NO_DEFLT_ }; _NO_DEFLT_ } _N_,
- (-) = _A_ 2 _U_ 11 _N_ _S_ "U(P)U(P)" {_A_ 2 _U_ 22 _N_ _N_ _F_ _IF_ARGS_ 0 2 XX 3 \ (u0 :: Int#) (u1 :: Int#) -> case _#_ minusInt# [] [u0, u1] of { _PRIM_ (u2 :: Int#) -> _!_ I# [] [u2] } _N_} _F_ _IF_ARGS_ 0 2 CC 5 \ (u0 :: Int) (u1 :: Int) -> case u0 of { _ALG_ I# (u2 :: Int#) -> case u1 of { _ALG_ I# (u3 :: Int#) -> case _#_ minusInt# [] [u2, u3] of { _PRIM_ (u4 :: Int#) -> _!_ I# [] [u4] }; _NO_DEFLT_ }; _NO_DEFLT_ } _N_,
- (*) = _A_ 2 _U_ 11 _N_ _S_ "U(P)U(P)" {_A_ 2 _U_ 22 _N_ _N_ _F_ _IF_ARGS_ 0 2 XX 3 \ (u0 :: Int#) (u1 :: Int#) -> case _#_ timesInt# [] [u0, u1] of { _PRIM_ (u2 :: Int#) -> _!_ I# [] [u2] } _N_} _F_ _IF_ARGS_ 0 2 CC 5 \ (u0 :: Int) (u1 :: Int) -> case u0 of { _ALG_ I# (u2 :: Int#) -> case u1 of { _ALG_ I# (u3 :: Int#) -> case _#_ timesInt# [] [u2, u3] of { _PRIM_ (u4 :: Int#) -> _!_ I# [] [u4] }; _NO_DEFLT_ }; _NO_DEFLT_ } _N_,
- negate = _A_ 1 _U_ 1 _N_ _S_ "U(P)" {_A_ 1 _U_ 2 _N_ _N_ _F_ _IF_ARGS_ 0 1 X 3 \ (u0 :: Int#) -> case _#_ negateInt# [] [u0] of { _PRIM_ (u1 :: Int#) -> _!_ I# [] [u1] } _N_} _F_ _IF_ARGS_ 0 1 C 4 \ (u0 :: Int) -> case u0 of { _ALG_ I# (u1 :: Int#) -> case _#_ negateInt# [] [u1] of { _PRIM_ (u2 :: Int#) -> _!_ I# [] [u2] }; _NO_DEFLT_ } _N_,
- abs = _A_ 1 _U_ 1 _N_ _S_ "U(P)" {_A_ 1 _U_ 2 _N_ _N_ _N_ _N_} _N_ _N_,
- signum = _A_ 1 _U_ 1 _N_ _S_ "U(P)" {_A_ 1 _U_ 2 _N_ _N_ _N_ _N_} _N_ _N_,
- fromInteger = _A_ 1 _U_ 1 _N_ _S_ "U(PPP)" {_A_ 3 _U_ 222 _N_ _N_ _F_ _IF_ARGS_ 0 3 XXX 3 \ (u0 :: Int#) (u1 :: Int#) (u2 :: ByteArray#) -> case _#_ integer2Int# [] [u0, u1, u2] of { _PRIM_ (u3 :: Int#) -> _!_ I# [] [u3] } _N_} _F_ _IF_ARGS_ 0 1 C 4 \ (u0 :: Integer) -> case u0 of { _ALG_ J# (u1 :: Int#) (u2 :: Int#) (u3 :: ByteArray#) -> case _#_ integer2Int# [] [u1, u2, u3] of { _PRIM_ (u4 :: Int#) -> _!_ I# [] [u4] }; _NO_DEFLT_ } _N_,
- fromInt = _A_ 1 _U_ 1 _N_ _S_ "U(P)" {_A_ 1 _U_ 2 _N_ _N_ _F_ _IF_ARGS_ 0 1 X 2 \ (u0 :: Int#) -> _!_ I# [] [u0] _N_} _F_ _IF_ARGS_ 0 1 X 1 \ (u0 :: Int) -> u0 _N_ #-}
+ (+) = { _A_ 2 _U_ 11 _N_ _S_ "U(P)U(P)" {_A_ 2 _U_ 22 _N_ _N_ _F_ _IF_ARGS_ 0 2 XX 3 \ (u0 :: Int#) (u1 :: Int#) -> case _#_ plusInt# [] [u0, u1] of { _PRIM_ (u2 :: Int#) -> _!_ I# [] [u2] } _N_} _F_ _IF_ARGS_ 0 2 CC 5 \ (u0 :: Int) (u1 :: Int) -> case u0 of { _ALG_ I# (u2 :: Int#) -> case u1 of { _ALG_ I# (u3 :: Int#) -> case _#_ plusInt# [] [u2, u3] of { _PRIM_ (u4 :: Int#) -> _!_ I# [] [u4] }; _NO_DEFLT_ }; _NO_DEFLT_ } _N_ },
+ (-) = { _A_ 2 _U_ 11 _N_ _S_ "U(P)U(P)" {_A_ 2 _U_ 22 _N_ _N_ _F_ _IF_ARGS_ 0 2 XX 3 \ (u0 :: Int#) (u1 :: Int#) -> case _#_ minusInt# [] [u0, u1] of { _PRIM_ (u2 :: Int#) -> _!_ I# [] [u2] } _N_} _F_ _IF_ARGS_ 0 2 CC 5 \ (u0 :: Int) (u1 :: Int) -> case u0 of { _ALG_ I# (u2 :: Int#) -> case u1 of { _ALG_ I# (u3 :: Int#) -> case _#_ minusInt# [] [u2, u3] of { _PRIM_ (u4 :: Int#) -> _!_ I# [] [u4] }; _NO_DEFLT_ }; _NO_DEFLT_ } _N_ },
+ (*) = { _A_ 2 _U_ 11 _N_ _S_ "U(P)U(P)" {_A_ 2 _U_ 22 _N_ _N_ _F_ _IF_ARGS_ 0 2 XX 3 \ (u0 :: Int#) (u1 :: Int#) -> case _#_ timesInt# [] [u0, u1] of { _PRIM_ (u2 :: Int#) -> _!_ I# [] [u2] } _N_} _F_ _IF_ARGS_ 0 2 CC 5 \ (u0 :: Int) (u1 :: Int) -> case u0 of { _ALG_ I# (u2 :: Int#) -> case u1 of { _ALG_ I# (u3 :: Int#) -> case _#_ timesInt# [] [u2, u3] of { _PRIM_ (u4 :: Int#) -> _!_ I# [] [u4] }; _NO_DEFLT_ }; _NO_DEFLT_ } _N_ },
+ negate = { _A_ 1 _U_ 1 _N_ _S_ "U(P)" {_A_ 1 _U_ 2 _N_ _N_ _F_ _IF_ARGS_ 0 1 X 3 \ (u0 :: Int#) -> case _#_ negateInt# [] [u0] of { _PRIM_ (u1 :: Int#) -> _!_ I# [] [u1] } _N_} _F_ _IF_ARGS_ 0 1 C 4 \ (u0 :: Int) -> case u0 of { _ALG_ I# (u1 :: Int#) -> case _#_ negateInt# [] [u1] of { _PRIM_ (u2 :: Int#) -> _!_ I# [] [u2] }; _NO_DEFLT_ } _N_ },
+ abs = { _A_ 1 _U_ 1 _N_ _S_ "U(P)" {_A_ 1 _U_ 2 _N_ _N_ _N_ _N_} _N_ _N_ },
+ signum = { _A_ 1 _U_ 1 _N_ _S_ "U(P)" {_A_ 1 _U_ 2 _N_ _N_ _N_ _N_} _N_ _N_ },
+ fromInteger = { _A_ 1 _U_ 1 _N_ _S_ "U(PPP)" {_A_ 3 _U_ 222 _N_ _N_ _F_ _IF_ARGS_ 0 3 XXX 3 \ (u0 :: Int#) (u1 :: Int#) (u2 :: ByteArray#) -> case _#_ integer2Int# [] [u0, u1, u2] of { _PRIM_ (u3 :: Int#) -> _!_ I# [] [u3] } _N_} _F_ _IF_ARGS_ 0 1 C 4 \ (u0 :: Integer) -> case u0 of { _ALG_ J# (u1 :: Int#) (u2 :: Int#) (u3 :: ByteArray#) -> case _#_ integer2Int# [] [u1, u2, u3] of { _PRIM_ (u4 :: Int#) -> _!_ I# [] [u4] }; _NO_DEFLT_ } _N_ },
+ fromInt = { _A_ 1 _U_ 1 _N_ _S_ "U(P)" {_A_ 1 _U_ 2 _N_ _N_ _F_ _IF_ARGS_ 0 1 X 2 \ (u0 :: Int#) -> _!_ I# [] [u0] _N_} _F_ _IF_ARGS_ 0 1 X 1 \ (u0 :: Int) -> u0 _N_ } #-}
instance Num Integer
{-# GHC_PRAGMA _M_ PreludeCore {-dfun-} _A_ 0 _N_ _N_ _N_ _F_ _IF_ARGS_ 0 0 X 11 _!_ _TUP_10 [{{Eq Integer}}, {{Text Integer}}, (Integer -> Integer -> Integer), (Integer -> Integer -> Integer), (Integer -> Integer -> Integer), (Integer -> Integer), (Integer -> Integer), (Integer -> Integer), (Integer -> Integer), (Int -> Integer)] [_DFUN_ Eq (Integer), _DFUN_ Text (Integer), _CONSTM_ Num (+) (Integer), _CONSTM_ Num (-) (Integer), _CONSTM_ Num (*) (Integer), _CONSTM_ Num negate (Integer), _CONSTM_ Num abs (Integer), _CONSTM_ Num signum (Integer), _CONSTM_ Num fromInteger (Integer), _CONSTM_ Num fromInt (Integer)] _N_
- (+) = _A_ 2 _U_ 11 _N_ _S_ "U(PPP)U(PPP)" {_A_ 4 _U_ 2221 _N_ _N_ _F_ _IF_ARGS_ 0 4 XXXC 5 \ (u0 :: Int#) (u1 :: Int#) (u2 :: ByteArray#) (u3 :: Integer) -> case u3 of { _ALG_ J# (u4 :: Int#) (u5 :: Int#) (u6 :: ByteArray#) -> _#_ plusInteger# [] [u0, u1, u2, u4, u5, u6]; _NO_DEFLT_ } _N_} _F_ _IF_ARGS_ 0 2 CC 6 \ (u0 :: Integer) (u1 :: Integer) -> case u0 of { _ALG_ J# (u2 :: Int#) (u3 :: Int#) (u4 :: ByteArray#) -> case u1 of { _ALG_ J# (u5 :: Int#) (u6 :: Int#) (u7 :: ByteArray#) -> _#_ plusInteger# [] [u2, u3, u4, u5, u6, u7]; _NO_DEFLT_ }; _NO_DEFLT_ } _N_,
- (-) = _A_ 2 _U_ 11 _N_ _S_ "U(PPP)U(PPP)" {_A_ 4 _U_ 2221 _N_ _N_ _F_ _IF_ARGS_ 0 4 XXXC 5 \ (u0 :: Int#) (u1 :: Int#) (u2 :: ByteArray#) (u3 :: Integer) -> case u3 of { _ALG_ J# (u4 :: Int#) (u5 :: Int#) (u6 :: ByteArray#) -> _#_ minusInteger# [] [u0, u1, u2, u4, u5, u6]; _NO_DEFLT_ } _N_} _F_ _IF_ARGS_ 0 2 CC 6 \ (u0 :: Integer) (u1 :: Integer) -> case u0 of { _ALG_ J# (u2 :: Int#) (u3 :: Int#) (u4 :: ByteArray#) -> case u1 of { _ALG_ J# (u5 :: Int#) (u6 :: Int#) (u7 :: ByteArray#) -> _#_ minusInteger# [] [u2, u3, u4, u5, u6, u7]; _NO_DEFLT_ }; _NO_DEFLT_ } _N_,
- (*) = _A_ 2 _U_ 11 _N_ _S_ "U(PPP)U(PPP)" {_A_ 4 _U_ 2221 _N_ _N_ _F_ _IF_ARGS_ 0 4 XXXC 5 \ (u0 :: Int#) (u1 :: Int#) (u2 :: ByteArray#) (u3 :: Integer) -> case u3 of { _ALG_ J# (u4 :: Int#) (u5 :: Int#) (u6 :: ByteArray#) -> _#_ timesInteger# [] [u0, u1, u2, u4, u5, u6]; _NO_DEFLT_ } _N_} _F_ _IF_ARGS_ 0 2 CC 6 \ (u0 :: Integer) (u1 :: Integer) -> case u0 of { _ALG_ J# (u2 :: Int#) (u3 :: Int#) (u4 :: ByteArray#) -> case u1 of { _ALG_ J# (u5 :: Int#) (u6 :: Int#) (u7 :: ByteArray#) -> _#_ timesInteger# [] [u2, u3, u4, u5, u6, u7]; _NO_DEFLT_ }; _NO_DEFLT_ } _N_,
- negate = _A_ 1 _U_ 1 _N_ _S_ "U(PPP)" {_A_ 3 _U_ 222 _N_ _N_ _F_ _IF_ARGS_ 0 3 XXX 4 \ (u0 :: Int#) (u1 :: Int#) (u2 :: ByteArray#) -> _#_ negateInteger# [] [u0, u1, u2] _N_} _F_ _IF_ARGS_ 0 1 C 5 \ (u0 :: Integer) -> case u0 of { _ALG_ J# (u1 :: Int#) (u2 :: Int#) (u3 :: ByteArray#) -> _#_ negateInteger# [] [u1, u2, u3]; _NO_DEFLT_ } _N_,
- abs = _A_ 1 _U_ 1 _N_ _S_ "U(PPP)" {_A_ 3 _U_ 222 _N_ _N_ _N_ _N_} _N_ _N_,
- signum = _A_ 1 _U_ 1 _N_ _S_ "U(PPP)" {_A_ 3 _U_ 222 _N_ _N_ _N_ _N_} _N_ _N_,
- fromInteger = _A_ 1 _U_ 1 _N_ _S_ "U(PPP)" {_A_ 3 _U_ 222 _N_ _N_ _F_ _IF_ARGS_ 0 3 XXX 4 \ (u0 :: Int#) (u1 :: Int#) (u2 :: ByteArray#) -> _!_ J# [] [u0, u1, u2] _N_} _F_ _IF_ARGS_ 0 1 X 1 \ (u0 :: Integer) -> u0 _N_,
- fromInt = _A_ 1 _U_ 1 _N_ _S_ "U(P)" {_A_ 1 _U_ 2 _N_ _N_ _F_ _IF_ARGS_ 0 1 X 1 \ (u0 :: Int#) -> _#_ int2Integer# [] [u0] _N_} _F_ _IF_ARGS_ 0 1 C 2 \ (u0 :: Int) -> case u0 of { _ALG_ I# (u1 :: Int#) -> _#_ int2Integer# [] [u1]; _NO_DEFLT_ } _N_ #-}
+ (+) = { _A_ 2 _U_ 11 _N_ _S_ "U(PPP)U(PPP)" {_A_ 4 _U_ 2221 _N_ _N_ _F_ _IF_ARGS_ 0 4 XXXC 5 \ (u0 :: Int#) (u1 :: Int#) (u2 :: ByteArray#) (u3 :: Integer) -> case u3 of { _ALG_ J# (u4 :: Int#) (u5 :: Int#) (u6 :: ByteArray#) -> _#_ plusInteger# [] [u0, u1, u2, u4, u5, u6]; _NO_DEFLT_ } _N_} _F_ _IF_ARGS_ 0 2 CC 6 \ (u0 :: Integer) (u1 :: Integer) -> case u0 of { _ALG_ J# (u2 :: Int#) (u3 :: Int#) (u4 :: ByteArray#) -> case u1 of { _ALG_ J# (u5 :: Int#) (u6 :: Int#) (u7 :: ByteArray#) -> _#_ plusInteger# [] [u2, u3, u4, u5, u6, u7]; _NO_DEFLT_ }; _NO_DEFLT_ } _N_ },
+ (-) = { _A_ 2 _U_ 11 _N_ _S_ "U(PPP)U(PPP)" {_A_ 4 _U_ 2221 _N_ _N_ _F_ _IF_ARGS_ 0 4 XXXC 5 \ (u0 :: Int#) (u1 :: Int#) (u2 :: ByteArray#) (u3 :: Integer) -> case u3 of { _ALG_ J# (u4 :: Int#) (u5 :: Int#) (u6 :: ByteArray#) -> _#_ minusInteger# [] [u0, u1, u2, u4, u5, u6]; _NO_DEFLT_ } _N_} _F_ _IF_ARGS_ 0 2 CC 6 \ (u0 :: Integer) (u1 :: Integer) -> case u0 of { _ALG_ J# (u2 :: Int#) (u3 :: Int#) (u4 :: ByteArray#) -> case u1 of { _ALG_ J# (u5 :: Int#) (u6 :: Int#) (u7 :: ByteArray#) -> _#_ minusInteger# [] [u2, u3, u4, u5, u6, u7]; _NO_DEFLT_ }; _NO_DEFLT_ } _N_ },
+ (*) = { _A_ 2 _U_ 11 _N_ _S_ "U(PPP)U(PPP)" {_A_ 4 _U_ 2221 _N_ _N_ _F_ _IF_ARGS_ 0 4 XXXC 5 \ (u0 :: Int#) (u1 :: Int#) (u2 :: ByteArray#) (u3 :: Integer) -> case u3 of { _ALG_ J# (u4 :: Int#) (u5 :: Int#) (u6 :: ByteArray#) -> _#_ timesInteger# [] [u0, u1, u2, u4, u5, u6]; _NO_DEFLT_ } _N_} _F_ _IF_ARGS_ 0 2 CC 6 \ (u0 :: Integer) (u1 :: Integer) -> case u0 of { _ALG_ J# (u2 :: Int#) (u3 :: Int#) (u4 :: ByteArray#) -> case u1 of { _ALG_ J# (u5 :: Int#) (u6 :: Int#) (u7 :: ByteArray#) -> _#_ timesInteger# [] [u2, u3, u4, u5, u6, u7]; _NO_DEFLT_ }; _NO_DEFLT_ } _N_ },
+ negate = { _A_ 1 _U_ 1 _N_ _S_ "U(PPP)" {_A_ 3 _U_ 222 _N_ _N_ _F_ _IF_ARGS_ 0 3 XXX 4 \ (u0 :: Int#) (u1 :: Int#) (u2 :: ByteArray#) -> _#_ negateInteger# [] [u0, u1, u2] _N_} _F_ _IF_ARGS_ 0 1 C 5 \ (u0 :: Integer) -> case u0 of { _ALG_ J# (u1 :: Int#) (u2 :: Int#) (u3 :: ByteArray#) -> _#_ negateInteger# [] [u1, u2, u3]; _NO_DEFLT_ } _N_ },
+ abs = { _A_ 1 _U_ 1 _N_ _S_ "U(PPP)" {_A_ 3 _U_ 222 _N_ _N_ _N_ _N_} _N_ _N_ },
+ signum = { _A_ 1 _U_ 1 _N_ _S_ "U(PPP)" {_A_ 3 _U_ 222 _N_ _N_ _N_ _N_} _N_ _N_ },
+ fromInteger = { _A_ 1 _U_ 1 _N_ _S_ "U(PPP)" {_A_ 3 _U_ 222 _N_ _N_ _F_ _IF_ARGS_ 0 3 XXX 4 \ (u0 :: Int#) (u1 :: Int#) (u2 :: ByteArray#) -> _!_ J# [] [u0, u1, u2] _N_} _F_ _IF_ARGS_ 0 1 X 1 \ (u0 :: Integer) -> u0 _N_ },
+ fromInt = { _A_ 1 _U_ 1 _N_ _S_ "U(P)" {_A_ 1 _U_ 2 _N_ _N_ _F_ _IF_ARGS_ 0 1 X 1 \ (u0 :: Int#) -> _#_ int2Integer# [] [u0] _N_} _F_ _IF_ARGS_ 0 1 C 2 \ (u0 :: Int) -> case u0 of { _ALG_ I# (u1 :: Int#) -> _#_ int2Integer# [] [u1]; _NO_DEFLT_ } _N_ } #-}
instance Integral a => Num (Ratio a)
{-# GHC_PRAGMA _M_ PreludeRatio {-dfun-} _A_ 3 _U_ 222 _N_ _N_ _N_ _N_ #-}
instance Num (Ratio Integer)
{-# GHC_PRAGMA _M_ PreludeRatio {-dfun-} _A_ 0 _N_ _N_ _N_ _F_ _IF_ARGS_ 0 0 X 11 _!_ _TUP_10 [{{Eq (Ratio Integer)}}, {{Text (Ratio Integer)}}, (Ratio Integer -> Ratio Integer -> Ratio Integer), (Ratio Integer -> Ratio Integer -> Ratio Integer), (Ratio Integer -> Ratio Integer -> Ratio Integer), (Ratio Integer -> Ratio Integer), (Ratio Integer -> Ratio Integer), (Ratio Integer -> Ratio Integer), (Integer -> Ratio Integer), (Int -> Ratio Integer)] [_DFUN_ Eq (Ratio Integer), _DFUN_ Text (Ratio Integer), _CONSTM_ Num (+) (Ratio Integer), _CONSTM_ Num (-) (Ratio Integer), _CONSTM_ Num (*) (Ratio Integer), _CONSTM_ Num negate (Ratio Integer), _CONSTM_ Num abs (Ratio Integer), _CONSTM_ Num signum (Ratio Integer), _CONSTM_ Num fromInteger (Ratio Integer), _CONSTM_ Num fromInt (Ratio Integer)] _N_
- (+) = _A_ 2 _U_ 11 _N_ _S_ "U(LU(PPP))U(LU(PPP))" {_A_ 5 _U_ 12221 _N_ _N_ _N_ _N_} _N_ _N_,
- (-) = _A_ 2 _U_ 11 _N_ _S_ "U(LU(PPP))U(LU(PPP))" {_A_ 5 _U_ 12221 _N_ _N_ _N_ _N_} _N_ _N_,
- (*) = _A_ 2 _U_ 11 _N_ _S_ "U(LU(PPP))U(LU(PPP))" {_A_ 5 _U_ 22221 _N_ _N_ _N_ _N_} _N_ _N_,
- negate = _A_ 1 _U_ 1 _N_ _S_ "U(LL)" {_A_ 2 _U_ 22 _N_ _N_ _N_ _N_} _N_ _N_,
- abs = _A_ 1 _U_ 1 _N_ _S_ "U(LL)" {_A_ 2 _U_ 12 _N_ _N_ _N_ _N_} _N_ _N_,
- signum = _A_ 1 _U_ 1 _N_ _S_ "U(LA)" {_A_ 1 _U_ 1 _N_ _N_ _N_ _N_} _N_ _N_,
- fromInteger = _A_ 1 _U_ 2 _N_ _N_ _N_ _N_,
- fromInt = _A_ 1 _U_ 1 _N_ _N_ _N_ _N_ #-}
+ (+) = { _A_ 2 _U_ 11 _N_ _S_ "U(LU(PPP))U(LU(PPP))" {_A_ 5 _U_ 12221 _N_ _N_ _N_ _N_} _N_ _N_ },
+ (-) = { _A_ 2 _U_ 11 _N_ _S_ "U(LU(PPP))U(LU(PPP))" {_A_ 5 _U_ 12221 _N_ _N_ _N_ _N_} _N_ _N_ },
+ (*) = { _A_ 2 _U_ 11 _N_ _S_ "U(LU(PPP))U(LU(PPP))" {_A_ 5 _U_ 22221 _N_ _N_ _N_ _N_} _N_ _N_ },
+ negate = { _A_ 1 _U_ 1 _N_ _S_ "U(LL)" {_A_ 2 _U_ 22 _N_ _N_ _N_ _N_} _N_ _N_ },
+ abs = { _A_ 1 _U_ 1 _N_ _S_ "U(LL)" {_A_ 2 _U_ 12 _N_ _N_ _N_ _N_} _N_ _N_ },
+ signum = { _A_ 1 _U_ 1 _N_ _S_ "U(LA)" {_A_ 1 _U_ 1 _N_ _N_ _N_ _N_} _N_ _N_ },
+ fromInteger = { _A_ 1 _U_ 2 _N_ _N_ _F_ _IF_ARGS_ 0 1 X 3 \ (u0 :: Integer) -> _!_ (:%) [Integer] [u0, _SPEC_ _ORIG_ PreludeCore __i1 [ (Integer) ]] _N_ },
+ fromInt = { _A_ 1 _U_ 1 _N_ _N_ _N_ _N_ } #-}
instance Ord ()
{-# GHC_PRAGMA _M_ PreludeBuiltin {-dfun-} _A_ 0 _N_ _N_ _N_ _F_ _IF_ARGS_ 0 0 X 9 _!_ _TUP_8 [{{Eq ()}}, (() -> () -> Bool), (() -> () -> Bool), (() -> () -> Bool), (() -> () -> Bool), (() -> () -> ()), (() -> () -> ()), (() -> () -> _CMP_TAG)] [_DFUN_ Eq (()), _CONSTM_ Ord (<) (()), _CONSTM_ Ord (<=) (()), _CONSTM_ Ord (>=) (()), _CONSTM_ Ord (>) (()), _CONSTM_ Ord max (()), _CONSTM_ Ord min (()), _CONSTM_ Ord _tagCmp (())] _N_
- (<) = _A_ 2 _U_ 11 _N_ _S_ "EE" _F_ _IF_ARGS_ 0 2 CC 3 \ (u0 :: ()) (u1 :: ()) -> case u0 of { _ALG_ _TUP_0 -> case u1 of { _ALG_ _TUP_0 -> _!_ False [] []; _NO_DEFLT_ }; _NO_DEFLT_ } _N_,
- (<=) = _A_ 2 _U_ 11 _N_ _S_ "EE" _F_ _IF_ARGS_ 0 2 CC 3 \ (u0 :: ()) (u1 :: ()) -> case u0 of { _ALG_ _TUP_0 -> case u1 of { _ALG_ _TUP_0 -> _!_ True [] []; _NO_DEFLT_ }; _NO_DEFLT_ } _N_,
- (>=) = _A_ 2 _U_ 11 _N_ _S_ "EE" _F_ _IF_ARGS_ 0 2 CC 3 \ (u0 :: ()) (u1 :: ()) -> case u0 of { _ALG_ _TUP_0 -> case u1 of { _ALG_ _TUP_0 -> _!_ True [] []; _NO_DEFLT_ }; _NO_DEFLT_ } _N_,
- (>) = _A_ 2 _U_ 11 _N_ _S_ "EE" _F_ _IF_ARGS_ 0 2 CC 3 \ (u0 :: ()) (u1 :: ()) -> case u0 of { _ALG_ _TUP_0 -> case u1 of { _ALG_ _TUP_0 -> _!_ False [] []; _NO_DEFLT_ }; _NO_DEFLT_ } _N_,
- max = _A_ 2 _U_ 11 _N_ _S_ "EE" _F_ _IF_ARGS_ 0 2 CX 2 \ (u0 :: ()) (u1 :: ()) -> case u0 of { _ALG_ _TUP_0 -> u1; _NO_DEFLT_ } _N_,
- min = _A_ 2 _U_ 11 _N_ _S_ "EE" _F_ _IF_ARGS_ 0 2 CX 2 \ (u0 :: ()) (u1 :: ()) -> case u0 of { _ALG_ _TUP_0 -> u1; _NO_DEFLT_ } _N_,
- _tagCmp = _A_ 2 _U_ 11 _N_ _S_ "EE" _F_ _IF_ARGS_ 0 2 CC 3 \ (u0 :: ()) (u1 :: ()) -> case u0 of { _ALG_ _TUP_0 -> case u1 of { _ALG_ _TUP_0 -> _!_ _EQ [] []; _NO_DEFLT_ }; _NO_DEFLT_ } _N_ #-}
+ (<) = { _A_ 2 _U_ 11 _N_ _S_ "EE" _F_ _IF_ARGS_ 0 2 CC 3 \ (u0 :: ()) (u1 :: ()) -> case u0 of { _ALG_ _TUP_0 -> case u1 of { _ALG_ _TUP_0 -> _!_ False [] []; _NO_DEFLT_ }; _NO_DEFLT_ } _N_ },
+ (<=) = { _A_ 2 _U_ 11 _N_ _S_ "EE" _F_ _IF_ARGS_ 0 2 CC 3 \ (u0 :: ()) (u1 :: ()) -> case u0 of { _ALG_ _TUP_0 -> case u1 of { _ALG_ _TUP_0 -> _!_ True [] []; _NO_DEFLT_ }; _NO_DEFLT_ } _N_ },
+ (>=) = { _A_ 2 _U_ 11 _N_ _S_ "EE" _F_ _IF_ARGS_ 0 2 CC 3 \ (u0 :: ()) (u1 :: ()) -> case u0 of { _ALG_ _TUP_0 -> case u1 of { _ALG_ _TUP_0 -> _!_ True [] []; _NO_DEFLT_ }; _NO_DEFLT_ } _N_ },
+ (>) = { _A_ 2 _U_ 11 _N_ _S_ "EE" _F_ _IF_ARGS_ 0 2 CC 3 \ (u0 :: ()) (u1 :: ()) -> case u0 of { _ALG_ _TUP_0 -> case u1 of { _ALG_ _TUP_0 -> _!_ False [] []; _NO_DEFLT_ }; _NO_DEFLT_ } _N_ },
+ max = { _A_ 2 _U_ 11 _N_ _S_ "EE" _F_ _IF_ARGS_ 0 2 CX 2 \ (u0 :: ()) (u1 :: ()) -> case u0 of { _ALG_ _TUP_0 -> u1; _NO_DEFLT_ } _N_ },
+ min = { _A_ 2 _U_ 11 _N_ _S_ "EE" _F_ _IF_ARGS_ 0 2 CX 2 \ (u0 :: ()) (u1 :: ()) -> case u0 of { _ALG_ _TUP_0 -> u1; _NO_DEFLT_ } _N_ },
+ _tagCmp = { _A_ 2 _U_ 11 _N_ _S_ "EE" _F_ _IF_ARGS_ 0 2 CC 3 \ (u0 :: ()) (u1 :: ()) -> case u0 of { _ALG_ _TUP_0 -> case u1 of { _ALG_ _TUP_0 -> _!_ _EQ [] []; _NO_DEFLT_ }; _NO_DEFLT_ } _N_ } #-}
instance (Ord a, Ord b) => Ord (a, b)
{-# GHC_PRAGMA _M_ PreludeBuiltin {-dfun-} _A_ 3 _U_ 112 _N_ _N_ _N_ _N_ #-}
instance (Ord a, Ord b, Ord c) => Ord (a, b, c)
{-# GHC_PRAGMA _M_ PreludeBuiltin {-dfun-} _A_ 6 _U_ 111112 _N_ _N_ _N_ _N_ #-}
instance Ord (Int, Int)
{-# GHC_PRAGMA _M_ PreludeBuiltin {-dfun-} _A_ 0 _N_ _N_ _N_ _F_ _IF_ARGS_ 0 0 X 9 _!_ _TUP_8 [{{Eq (Int, Int)}}, ((Int, Int) -> (Int, Int) -> Bool), ((Int, Int) -> (Int, Int) -> Bool), ((Int, Int) -> (Int, Int) -> Bool), ((Int, Int) -> (Int, Int) -> Bool), ((Int, Int) -> (Int, Int) -> (Int, Int)), ((Int, Int) -> (Int, Int) -> (Int, Int)), ((Int, Int) -> (Int, Int) -> _CMP_TAG)] [_DFUN_ Eq ((Int, Int)), _CONSTM_ Ord (<) ((Int, Int)), _CONSTM_ Ord (<=) ((Int, Int)), _CONSTM_ Ord (>=) ((Int, Int)), _CONSTM_ Ord (>) ((Int, Int)), _CONSTM_ Ord max ((Int, Int)), _CONSTM_ Ord min ((Int, Int)), _CONSTM_ Ord _tagCmp ((Int, Int))] _N_
- (<) = _A_ 2 _U_ 11 _N_ _S_ "U(U(P)L)U(U(P)L)" {_A_ 4 _U_ 2121 _N_ _N_ _N_ _N_} _N_ _N_,
- (<=) = _A_ 2 _U_ 11 _N_ _S_ "U(U(P)L)U(U(P)L)" {_A_ 4 _U_ 2121 _N_ _N_ _N_ _N_} _N_ _N_,
- (>=) = _A_ 2 _U_ 11 _N_ _S_ "U(U(P)L)U(U(P)L)" {_A_ 4 _U_ 2121 _N_ _N_ _N_ _N_} _N_ _N_,
- (>) = _A_ 2 _U_ 11 _N_ _S_ "U(U(P)L)U(U(P)L)" {_A_ 4 _U_ 2121 _N_ _N_ _N_ _N_} _N_ _N_,
- max = _A_ 2 _U_ 11 _N_ _S_ "U(U(P)L)U(U(P)L)" {_A_ 4 _U_ 2222 _N_ _N_ _N_ _N_} _N_ _N_,
- min = _A_ 2 _U_ 11 _N_ _S_ "U(U(P)L)U(U(P)L)" {_A_ 4 _U_ 2222 _N_ _N_ _N_ _N_} _N_ _N_,
- _tagCmp = _A_ 2 _U_ 11 _N_ _S_ "U(U(P)L)U(U(P)L)" {_A_ 4 _U_ 2121 _N_ _N_ _N_ _N_} _N_ _N_ #-}
+ (<) = { _A_ 2 _U_ 11 _N_ _S_ "U(U(P)L)U(U(P)L)" {_A_ 4 _U_ 2121 _N_ _N_ _N_ _N_} _N_ _N_ },
+ (<=) = { _A_ 2 _U_ 11 _N_ _S_ "U(U(P)L)U(U(P)L)" {_A_ 4 _U_ 2121 _N_ _N_ _N_ _N_} _N_ _N_ },
+ (>=) = { _A_ 2 _U_ 11 _N_ _S_ "U(U(P)L)U(U(P)L)" {_A_ 4 _U_ 2121 _N_ _N_ _N_ _N_} _N_ _N_ },
+ (>) = { _A_ 2 _U_ 11 _N_ _S_ "U(U(P)L)U(U(P)L)" {_A_ 4 _U_ 2121 _N_ _N_ _N_ _N_} _N_ _N_ },
+ max = { _A_ 2 _U_ 11 _N_ _S_ "U(U(P)L)U(U(P)L)" {_A_ 4 _U_ 2222 _N_ _N_ _N_ _N_} _N_ _N_ },
+ min = { _A_ 2 _U_ 11 _N_ _S_ "U(U(P)L)U(U(P)L)" {_A_ 4 _U_ 2222 _N_ _N_ _N_ _N_} _N_ _N_ },
+ _tagCmp = { _A_ 2 _U_ 11 _N_ _S_ "U(U(P)L)U(U(P)L)" {_A_ 4 _U_ 2121 _N_ _N_ _N_ _N_} _N_ _N_ } #-}
+instance Ord (Int, Int, Int)
+ {-# GHC_PRAGMA _M_ PreludeBuiltin {-dfun-} _A_ 0 _N_ _N_ _N_ _F_ _IF_ARGS_ 0 0 X 9 _!_ _TUP_8 [{{Eq (Int, Int, Int)}}, ((Int, Int, Int) -> (Int, Int, Int) -> Bool), ((Int, Int, Int) -> (Int, Int, Int) -> Bool), ((Int, Int, Int) -> (Int, Int, Int) -> Bool), ((Int, Int, Int) -> (Int, Int, Int) -> Bool), ((Int, Int, Int) -> (Int, Int, Int) -> (Int, Int, Int)), ((Int, Int, Int) -> (Int, Int, Int) -> (Int, Int, Int)), ((Int, Int, Int) -> (Int, Int, Int) -> _CMP_TAG)] [_DFUN_ Eq ((Int, Int, Int)), _CONSTM_ Ord (<) ((Int, Int, Int)), _CONSTM_ Ord (<=) ((Int, Int, Int)), _CONSTM_ Ord (>=) ((Int, Int, Int)), _CONSTM_ Ord (>) ((Int, Int, Int)), _CONSTM_ Ord max ((Int, Int, Int)), _CONSTM_ Ord min ((Int, Int, Int)), _CONSTM_ Ord _tagCmp ((Int, Int, Int))] _N_
+ (<) = { _A_ 2 _U_ 11 _N_ _S_ "U(U(P)LL)U(U(P)LL)" {_A_ 4 _U_ 2111 _N_ _N_ _N_ _N_} _N_ _N_ },
+ (<=) = { _A_ 2 _U_ 11 _N_ _S_ "U(U(P)LL)U(U(P)LL)" {_A_ 4 _U_ 2111 _N_ _N_ _N_ _N_} _N_ _N_ },
+ (>=) = { _A_ 2 _U_ 11 _N_ _S_ "U(U(P)LL)U(U(P)LL)" {_A_ 4 _U_ 2111 _N_ _N_ _N_ _N_} _N_ _N_ },
+ (>) = { _A_ 2 _U_ 11 _N_ _S_ "U(U(P)LL)U(U(P)LL)" {_A_ 4 _U_ 2111 _N_ _N_ _N_ _N_} _N_ _N_ },
+ max = { _A_ 2 _U_ 12 _N_ _S_ "U(U(P)LL)U(U(P)LL)" {_A_ 4 _U_ 2222 _N_ _N_ _N_ _N_} _N_ _N_ },
+ min = { _A_ 2 _U_ 12 _N_ _S_ "U(U(P)LL)U(U(P)LL)" {_A_ 4 _U_ 2222 _N_ _N_ _N_ _N_} _N_ _N_ },
+ _tagCmp = { _A_ 2 _U_ 11 _N_ _S_ "U(U(P)LL)U(U(P)LL)" {_A_ 4 _U_ 2111 _N_ _N_ _N_ _N_} _N_ _N_ } #-}
+instance Ord (Int, Int, Int, Int)
+ {-# GHC_PRAGMA _M_ PreludeBuiltin {-dfun-} _A_ 0 _N_ _N_ _N_ _F_ _IF_ARGS_ 0 0 X 9 _!_ _TUP_8 [{{Eq (Int, Int, Int, Int)}}, ((Int, Int, Int, Int) -> (Int, Int, Int, Int) -> Bool), ((Int, Int, Int, Int) -> (Int, Int, Int, Int) -> Bool), ((Int, Int, Int, Int) -> (Int, Int, Int, Int) -> Bool), ((Int, Int, Int, Int) -> (Int, Int, Int, Int) -> Bool), ((Int, Int, Int, Int) -> (Int, Int, Int, Int) -> (Int, Int, Int, Int)), ((Int, Int, Int, Int) -> (Int, Int, Int, Int) -> (Int, Int, Int, Int)), ((Int, Int, Int, Int) -> (Int, Int, Int, Int) -> _CMP_TAG)] [_DFUN_ Eq ((Int, Int, Int, Int)), _CONSTM_ Ord (<) ((Int, Int, Int, Int)), _CONSTM_ Ord (<=) ((Int, Int, Int, Int)), _CONSTM_ Ord (>=) ((Int, Int, Int, Int)), _CONSTM_ Ord (>) ((Int, Int, Int, Int)), _CONSTM_ Ord max ((Int, Int, Int, Int)), _CONSTM_ Ord min ((Int, Int, Int, Int)), _CONSTM_ Ord _tagCmp ((Int, Int, Int, Int))] _N_
+ (<) = { _A_ 2 _U_ 11 _N_ _S_ "U(U(P)LLL)U(U(P)LLL)" {_A_ 5 _U_ 21111 _N_ _N_ _N_ _N_} _N_ _N_ },
+ (<=) = { _A_ 2 _U_ 11 _N_ _S_ "U(U(P)LLL)U(U(P)LLL)" {_A_ 5 _U_ 21111 _N_ _N_ _N_ _N_} _N_ _N_ },
+ (>=) = { _A_ 2 _U_ 11 _N_ _S_ "U(U(P)LLL)U(U(P)LLL)" {_A_ 5 _U_ 21111 _N_ _N_ _N_ _N_} _N_ _N_ },
+ (>) = { _A_ 2 _U_ 11 _N_ _S_ "U(U(P)LLL)U(U(P)LLL)" {_A_ 5 _U_ 21111 _N_ _N_ _N_ _N_} _N_ _N_ },
+ max = { _A_ 2 _U_ 12 _N_ _S_ "U(U(P)LLL)U(U(P)LLL)" {_A_ 5 _U_ 22222 _N_ _N_ _N_ _N_} _N_ _N_ },
+ min = { _A_ 2 _U_ 12 _N_ _S_ "U(U(P)LLL)U(U(P)LLL)" {_A_ 5 _U_ 22222 _N_ _N_ _N_ _N_} _N_ _N_ },
+ _tagCmp = { _A_ 2 _U_ 11 _N_ _S_ "U(U(P)LLL)U(U(P)LLL)" {_A_ 5 _U_ 21111 _N_ _N_ _N_ _N_} _N_ _N_ } #-}
+instance Ord (Int, Int, Int, Int, Int)
+ {-# GHC_PRAGMA _M_ PreludeBuiltin {-dfun-} _A_ 0 _N_ _N_ _N_ _F_ _IF_ARGS_ 0 0 X 9 _!_ _TUP_8 [{{Eq (Int, Int, Int, Int, Int)}}, ((Int, Int, Int, Int, Int) -> (Int, Int, Int, Int, Int) -> Bool), ((Int, Int, Int, Int, Int) -> (Int, Int, Int, Int, Int) -> Bool), ((Int, Int, Int, Int, Int) -> (Int, Int, Int, Int, Int) -> Bool), ((Int, Int, Int, Int, Int) -> (Int, Int, Int, Int, Int) -> Bool), ((Int, Int, Int, Int, Int) -> (Int, Int, Int, Int, Int) -> (Int, Int, Int, Int, Int)), ((Int, Int, Int, Int, Int) -> (Int, Int, Int, Int, Int) -> (Int, Int, Int, Int, Int)), ((Int, Int, Int, Int, Int) -> (Int, Int, Int, Int, Int) -> _CMP_TAG)] [_DFUN_ Eq ((Int, Int, Int, Int, Int)), _CONSTM_ Ord (<) ((Int, Int, Int, Int, Int)), _CONSTM_ Ord (<=) ((Int, Int, Int, Int, Int)), _CONSTM_ Ord (>=) ((Int, Int, Int, Int, Int)), _CONSTM_ Ord (>) ((Int, Int, Int, Int, Int)), _CONSTM_ Ord max ((Int, Int, Int, Int, Int)), _CONSTM_ Ord min ((Int, Int, Int, Int, Int)), _CONSTM_ Ord _tagCmp ((Int, Int, Int, Int, Int))] _N_
+ (<) = { _A_ 2 _U_ 11 _N_ _S_ "U(U(P)LLLL)U(U(P)LLLL)" _N_ _N_ },
+ (<=) = { _A_ 2 _U_ 11 _N_ _S_ "U(U(P)LLLL)U(U(P)LLLL)" _N_ _N_ },
+ (>=) = { _A_ 2 _U_ 11 _N_ _S_ "U(U(P)LLLL)U(U(P)LLLL)" _N_ _N_ },
+ (>) = { _A_ 2 _U_ 11 _N_ _S_ "U(U(P)LLLL)U(U(P)LLLL)" _N_ _N_ },
+ max = { _A_ 2 _U_ 22 _N_ _S_ "U(U(P)LLLL)U(U(P)LLLL)" _N_ _N_ },
+ min = { _A_ 2 _U_ 22 _N_ _S_ "U(U(P)LLLL)U(U(P)LLLL)" _N_ _N_ },
+ _tagCmp = { _A_ 2 _U_ 11 _N_ _S_ "U(U(P)LLLL)U(U(P)LLLL)" _N_ _N_ } #-}
+instance Ord ([Char], [Char])
+ {-# GHC_PRAGMA _M_ PreludeBuiltin {-dfun-} _A_ 0 _N_ _N_ _N_ _F_ _IF_ARGS_ 0 0 X 9 _!_ _TUP_8 [{{Eq ([Char], [Char])}}, (([Char], [Char]) -> ([Char], [Char]) -> Bool), (([Char], [Char]) -> ([Char], [Char]) -> Bool), (([Char], [Char]) -> ([Char], [Char]) -> Bool), (([Char], [Char]) -> ([Char], [Char]) -> Bool), (([Char], [Char]) -> ([Char], [Char]) -> ([Char], [Char])), (([Char], [Char]) -> ([Char], [Char]) -> ([Char], [Char])), (([Char], [Char]) -> ([Char], [Char]) -> _CMP_TAG)] [_DFUN_ Eq (([Char], [Char])), _CONSTM_ Ord (<) (([Char], [Char])), _CONSTM_ Ord (<=) (([Char], [Char])), _CONSTM_ Ord (>=) (([Char], [Char])), _CONSTM_ Ord (>) (([Char], [Char])), _CONSTM_ Ord max (([Char], [Char])), _CONSTM_ Ord min (([Char], [Char])), _CONSTM_ Ord _tagCmp (([Char], [Char]))] _N_
+ (<) = { _A_ 2 _U_ 11 _N_ _S_ "U(SL)U(SL)" {_A_ 4 _U_ 2222 _N_ _N_ _N_ _N_} _N_ _N_ },
+ (<=) = { _A_ 2 _U_ 11 _N_ _S_ "U(SL)U(SL)" {_A_ 4 _U_ 2222 _N_ _N_ _N_ _N_} _N_ _N_ },
+ (>=) = { _A_ 2 _U_ 11 _N_ _S_ "U(SL)U(SL)" {_A_ 4 _U_ 2222 _N_ _N_ _N_ _N_} _N_ _N_ },
+ (>) = { _A_ 2 _U_ 11 _N_ _S_ "U(SL)U(SL)" {_A_ 4 _U_ 2222 _N_ _N_ _N_ _N_} _N_ _N_ },
+ max = { _A_ 2 _U_ 11 _N_ _S_ "U(SL)U(SL)" {_A_ 4 _U_ 2222 _N_ _N_ _N_ _N_} _N_ _N_ },
+ min = { _A_ 2 _U_ 11 _N_ _S_ "U(SL)U(SL)" {_A_ 4 _U_ 2222 _N_ _N_ _N_ _N_} _N_ _N_ },
+ _tagCmp = { _A_ 2 _U_ 11 _N_ _S_ "U(SL)U(SL)" {_A_ 4 _U_ 2222 _N_ _N_ _N_ _N_} _N_ _N_ } #-}
+instance Ord ([Int], [Int])
+ {-# GHC_PRAGMA _M_ PreludeBuiltin {-dfun-} _A_ 0 _N_ _N_ _N_ _F_ _IF_ARGS_ 0 0 X 9 _!_ _TUP_8 [{{Eq ([Int], [Int])}}, (([Int], [Int]) -> ([Int], [Int]) -> Bool), (([Int], [Int]) -> ([Int], [Int]) -> Bool), (([Int], [Int]) -> ([Int], [Int]) -> Bool), (([Int], [Int]) -> ([Int], [Int]) -> Bool), (([Int], [Int]) -> ([Int], [Int]) -> ([Int], [Int])), (([Int], [Int]) -> ([Int], [Int]) -> ([Int], [Int])), (([Int], [Int]) -> ([Int], [Int]) -> _CMP_TAG)] [_DFUN_ Eq (([Int], [Int])), _CONSTM_ Ord (<) (([Int], [Int])), _CONSTM_ Ord (<=) (([Int], [Int])), _CONSTM_ Ord (>=) (([Int], [Int])), _CONSTM_ Ord (>) (([Int], [Int])), _CONSTM_ Ord max (([Int], [Int])), _CONSTM_ Ord min (([Int], [Int])), _CONSTM_ Ord _tagCmp (([Int], [Int]))] _N_
+ (<) = { _A_ 2 _U_ 11 _N_ _S_ "U(SL)U(SL)" {_A_ 4 _U_ 2222 _N_ _N_ _N_ _N_} _N_ _N_ },
+ (<=) = { _A_ 2 _U_ 11 _N_ _S_ "U(SL)U(SL)" {_A_ 4 _U_ 2222 _N_ _N_ _N_ _N_} _N_ _N_ },
+ (>=) = { _A_ 2 _U_ 11 _N_ _S_ "U(SL)U(SL)" {_A_ 4 _U_ 2222 _N_ _N_ _N_ _N_} _N_ _N_ },
+ (>) = { _A_ 2 _U_ 11 _N_ _S_ "U(SL)U(SL)" {_A_ 4 _U_ 2222 _N_ _N_ _N_ _N_} _N_ _N_ },
+ max = { _A_ 2 _U_ 11 _N_ _S_ "U(SL)U(SL)" {_A_ 4 _U_ 2222 _N_ _N_ _N_ _N_} _N_ _N_ },
+ min = { _A_ 2 _U_ 11 _N_ _S_ "U(SL)U(SL)" {_A_ 4 _U_ 2222 _N_ _N_ _N_ _N_} _N_ _N_ },
+ _tagCmp = { _A_ 2 _U_ 11 _N_ _S_ "U(SL)U(SL)" {_A_ 4 _U_ 2222 _N_ _N_ _N_ _N_} _N_ _N_ } #-}
instance Ord (_PackedString, _PackedString)
{-# GHC_PRAGMA _M_ PreludeBuiltin {-dfun-} _A_ 0 _N_ _N_ _N_ _F_ _IF_ARGS_ 0 0 X 9 _!_ _TUP_8 [{{Eq (_PackedString, _PackedString)}}, ((_PackedString, _PackedString) -> (_PackedString, _PackedString) -> Bool), ((_PackedString, _PackedString) -> (_PackedString, _PackedString) -> Bool), ((_PackedString, _PackedString) -> (_PackedString, _PackedString) -> Bool), ((_PackedString, _PackedString) -> (_PackedString, _PackedString) -> Bool), ((_PackedString, _PackedString) -> (_PackedString, _PackedString) -> (_PackedString, _PackedString)), ((_PackedString, _PackedString) -> (_PackedString, _PackedString) -> (_PackedString, _PackedString)), ((_PackedString, _PackedString) -> (_PackedString, _PackedString) -> _CMP_TAG)] [_DFUN_ Eq ((_PackedString, _PackedString)), _CONSTM_ Ord (<) ((_PackedString, _PackedString)), _CONSTM_ Ord (<=) ((_PackedString, _PackedString)), _CONSTM_ Ord (>=) ((_PackedString, _PackedString)), _CONSTM_ Ord (>) ((_PackedString, _PackedString)), _CONSTM_ Ord max ((_PackedString, _PackedString)), _CONSTM_ Ord min ((_PackedString, _PackedString)), _CONSTM_ Ord _tagCmp ((_PackedString, _PackedString))] _N_
- (<) = _A_ 2 _U_ 11 _N_ _S_ "U(SL)U(SL)" {_A_ 4 _U_ 2222 _N_ _N_ _N_ _N_} _N_ _N_,
- (<=) = _A_ 2 _U_ 11 _N_ _S_ "U(SL)U(SL)" {_A_ 4 _U_ 2222 _N_ _N_ _N_ _N_} _N_ _N_,
- (>=) = _A_ 2 _U_ 11 _N_ _S_ "U(SL)U(SL)" {_A_ 4 _U_ 2222 _N_ _N_ _N_ _N_} _N_ _N_,
- (>) = _A_ 2 _U_ 11 _N_ _S_ "U(SL)U(SL)" {_A_ 4 _U_ 2222 _N_ _N_ _N_ _N_} _N_ _N_,
- max = _A_ 2 _U_ 11 _N_ _S_ "U(SL)U(SL)" {_A_ 4 _U_ 2222 _N_ _N_ _N_ _N_} _N_ _N_,
- min = _A_ 2 _U_ 11 _N_ _S_ "U(SL)U(SL)" {_A_ 4 _U_ 2222 _N_ _N_ _N_ _N_} _N_ _N_,
- _tagCmp = _A_ 2 _U_ 11 _N_ _S_ "U(SL)U(SL)" {_A_ 4 _U_ 2222 _N_ _N_ _N_ _N_} _N_ _N_ #-}
+ (<) = { _A_ 2 _U_ 11 _N_ _S_ "U(SL)U(SL)" {_A_ 4 _U_ 2222 _N_ _N_ _N_ _N_} _N_ _N_ },
+ (<=) = { _A_ 2 _U_ 11 _N_ _S_ "U(SL)U(SL)" {_A_ 4 _U_ 2222 _N_ _N_ _N_ _N_} _N_ _N_ },
+ (>=) = { _A_ 2 _U_ 11 _N_ _S_ "U(SL)U(SL)" {_A_ 4 _U_ 2222 _N_ _N_ _N_ _N_} _N_ _N_ },
+ (>) = { _A_ 2 _U_ 11 _N_ _S_ "U(SL)U(SL)" {_A_ 4 _U_ 2222 _N_ _N_ _N_ _N_} _N_ _N_ },
+ max = { _A_ 2 _U_ 11 _N_ _S_ "U(SL)U(SL)" {_A_ 4 _U_ 2222 _N_ _N_ _N_ _N_} _N_ _N_ },
+ min = { _A_ 2 _U_ 11 _N_ _S_ "U(SL)U(SL)" {_A_ 4 _U_ 2222 _N_ _N_ _N_ _N_} _N_ _N_ },
+ _tagCmp = { _A_ 2 _U_ 11 _N_ _S_ "U(SL)U(SL)" {_A_ 4 _U_ 2222 _N_ _N_ _N_ _N_} _N_ _N_ } #-}
instance (Ix a, Ord b) => Ord (Array a b)
{-# GHC_PRAGMA _M_ PreludeArray {-dfun-} _A_ 3 _U_ 222 _N_ _N_ _N_ _N_ #-}
instance (Ord a, Ord b) => Ord (Assoc a b)
{-# GHC_PRAGMA _M_ PreludeArray {-dfun-} _A_ 3 _U_ 112 _N_ _N_ _N_ _N_ #-}
instance Ord Bool
{-# GHC_PRAGMA _M_ PreludeCore {-dfun-} _A_ 0 _N_ _N_ _N_ _F_ _IF_ARGS_ 0 0 X 9 _!_ _TUP_8 [{{Eq Bool}}, (Bool -> Bool -> Bool), (Bool -> Bool -> Bool), (Bool -> Bool -> Bool), (Bool -> Bool -> Bool), (Bool -> Bool -> Bool), (Bool -> Bool -> Bool), (Bool -> Bool -> _CMP_TAG)] [_DFUN_ Eq (Bool), _CONSTM_ Ord (<) (Bool), _CONSTM_ Ord (<=) (Bool), _CONSTM_ Ord (>=) (Bool), _CONSTM_ Ord (>) (Bool), _CONSTM_ Ord max (Bool), _CONSTM_ Ord min (Bool), _CONSTM_ Ord _tagCmp (Bool)] _N_
- (<) = _A_ 2 _U_ 11 _N_ _S_ "EE" _N_ _N_,
- (<=) = _A_ 2 _U_ 11 _N_ _S_ "EE" _N_ _N_,
- (>=) = _A_ 2 _U_ 11 _N_ _S_ "EE" _N_ _N_,
- (>) = _A_ 2 _U_ 11 _N_ _S_ "EE" _N_ _N_,
- max = _A_ 2 _U_ 22 _N_ _S_ "EE" _N_ _N_,
- min = _A_ 2 _U_ 22 _N_ _S_ "EE" _N_ _N_,
- _tagCmp = _A_ 2 _U_ 11 _N_ _S_ "EE" _N_ _N_ #-}
+ (<) = { _A_ 2 _U_ 11 _N_ _S_ "EE" _N_ _N_ },
+ (<=) = { _A_ 2 _U_ 11 _N_ _S_ "EE" _N_ _N_ },
+ (>=) = { _A_ 2 _U_ 11 _N_ _S_ "EE" _N_ _N_ },
+ (>) = { _A_ 2 _U_ 11 _N_ _S_ "EE" _N_ _N_ },
+ max = { _A_ 2 _U_ 22 _N_ _S_ "EE" _N_ _N_ },
+ min = { _A_ 2 _U_ 22 _N_ _S_ "EE" _N_ _N_ },
+ _tagCmp = { _A_ 2 _U_ 11 _N_ _S_ "EE" _N_ _N_ } #-}
instance Ord Char
{-# GHC_PRAGMA _M_ PreludeCore {-dfun-} _A_ 0 _N_ _N_ _N_ _F_ _IF_ARGS_ 0 0 X 9 _!_ _TUP_8 [{{Eq Char}}, (Char -> Char -> Bool), (Char -> Char -> Bool), (Char -> Char -> Bool), (Char -> Char -> Bool), (Char -> Char -> Char), (Char -> Char -> Char), (Char -> Char -> _CMP_TAG)] [_DFUN_ Eq (Char), _CONSTM_ Ord (<) (Char), _CONSTM_ Ord (<=) (Char), _CONSTM_ Ord (>=) (Char), _CONSTM_ Ord (>) (Char), _CONSTM_ Ord max (Char), _CONSTM_ Ord min (Char), _CONSTM_ Ord _tagCmp (Char)] _N_
- (<) = _A_ 2 _U_ 11 _N_ _S_ "U(P)U(P)" {_A_ 2 _U_ 22 _N_ _N_ _F_ _IF_ARGS_ 0 2 XX 1 \ (u0 :: Char#) (u1 :: Char#) -> _#_ ltChar# [] [u0, u1] _N_} _F_ _IF_ARGS_ 0 2 CC 3 \ (u0 :: Char) (u1 :: Char) -> case u0 of { _ALG_ C# (u2 :: Char#) -> case u1 of { _ALG_ C# (u3 :: Char#) -> _#_ ltChar# [] [u2, u3]; _NO_DEFLT_ }; _NO_DEFLT_ } _N_,
- (<=) = _A_ 2 _U_ 11 _N_ _S_ "U(P)U(P)" {_A_ 2 _U_ 22 _N_ _N_ _F_ _IF_ARGS_ 0 2 XX 1 \ (u0 :: Char#) (u1 :: Char#) -> _#_ leChar# [] [u0, u1] _N_} _F_ _IF_ARGS_ 0 2 CC 3 \ (u0 :: Char) (u1 :: Char) -> case u0 of { _ALG_ C# (u2 :: Char#) -> case u1 of { _ALG_ C# (u3 :: Char#) -> _#_ leChar# [] [u2, u3]; _NO_DEFLT_ }; _NO_DEFLT_ } _N_,
- (>=) = _A_ 2 _U_ 11 _N_ _S_ "U(P)U(P)" {_A_ 2 _U_ 22 _N_ _N_ _F_ _IF_ARGS_ 0 2 XX 1 \ (u0 :: Char#) (u1 :: Char#) -> _#_ geChar# [] [u0, u1] _N_} _F_ _IF_ARGS_ 0 2 CC 3 \ (u0 :: Char) (u1 :: Char) -> case u0 of { _ALG_ C# (u2 :: Char#) -> case u1 of { _ALG_ C# (u3 :: Char#) -> _#_ geChar# [] [u2, u3]; _NO_DEFLT_ }; _NO_DEFLT_ } _N_,
- (>) = _A_ 2 _U_ 11 _N_ _S_ "U(P)U(P)" {_A_ 2 _U_ 22 _N_ _N_ _F_ _IF_ARGS_ 0 2 XX 1 \ (u0 :: Char#) (u1 :: Char#) -> _#_ gtChar# [] [u0, u1] _N_} _F_ _IF_ARGS_ 0 2 CC 3 \ (u0 :: Char) (u1 :: Char) -> case u0 of { _ALG_ C# (u2 :: Char#) -> case u1 of { _ALG_ C# (u3 :: Char#) -> _#_ gtChar# [] [u2, u3]; _NO_DEFLT_ }; _NO_DEFLT_ } _N_,
- max = _A_ 2 _U_ 11 _N_ _S_ "U(P)U(P)" {_A_ 2 _U_ 22 _N_ _N_ _N_ _N_} _N_ _N_,
- min = _A_ 2 _U_ 11 _N_ _S_ "U(P)U(P)" {_A_ 2 _U_ 22 _N_ _N_ _N_ _N_} _N_ _N_,
- _tagCmp = _A_ 2 _U_ 11 _N_ _S_ "U(P)U(P)" {_A_ 2 _U_ 22 _N_ _N_ _N_ _N_} _N_ _N_ #-}
+ (<) = { _A_ 2 _U_ 11 _N_ _S_ "U(P)U(P)" {_A_ 2 _U_ 22 _N_ _N_ _F_ _IF_ARGS_ 0 2 XX 1 \ (u0 :: Char#) (u1 :: Char#) -> _#_ ltChar# [] [u0, u1] _N_} _F_ _IF_ARGS_ 0 2 CC 3 \ (u0 :: Char) (u1 :: Char) -> case u0 of { _ALG_ C# (u2 :: Char#) -> case u1 of { _ALG_ C# (u3 :: Char#) -> _#_ ltChar# [] [u2, u3]; _NO_DEFLT_ }; _NO_DEFLT_ } _N_ },
+ (<=) = { _A_ 2 _U_ 11 _N_ _S_ "U(P)U(P)" {_A_ 2 _U_ 22 _N_ _N_ _F_ _IF_ARGS_ 0 2 XX 1 \ (u0 :: Char#) (u1 :: Char#) -> _#_ leChar# [] [u0, u1] _N_} _F_ _IF_ARGS_ 0 2 CC 3 \ (u0 :: Char) (u1 :: Char) -> case u0 of { _ALG_ C# (u2 :: Char#) -> case u1 of { _ALG_ C# (u3 :: Char#) -> _#_ leChar# [] [u2, u3]; _NO_DEFLT_ }; _NO_DEFLT_ } _N_ },
+ (>=) = { _A_ 2 _U_ 11 _N_ _S_ "U(P)U(P)" {_A_ 2 _U_ 22 _N_ _N_ _F_ _IF_ARGS_ 0 2 XX 1 \ (u0 :: Char#) (u1 :: Char#) -> _#_ geChar# [] [u0, u1] _N_} _F_ _IF_ARGS_ 0 2 CC 3 \ (u0 :: Char) (u1 :: Char) -> case u0 of { _ALG_ C# (u2 :: Char#) -> case u1 of { _ALG_ C# (u3 :: Char#) -> _#_ geChar# [] [u2, u3]; _NO_DEFLT_ }; _NO_DEFLT_ } _N_ },
+ (>) = { _A_ 2 _U_ 11 _N_ _S_ "U(P)U(P)" {_A_ 2 _U_ 22 _N_ _N_ _F_ _IF_ARGS_ 0 2 XX 1 \ (u0 :: Char#) (u1 :: Char#) -> _#_ gtChar# [] [u0, u1] _N_} _F_ _IF_ARGS_ 0 2 CC 3 \ (u0 :: Char) (u1 :: Char) -> case u0 of { _ALG_ C# (u2 :: Char#) -> case u1 of { _ALG_ C# (u3 :: Char#) -> _#_ gtChar# [] [u2, u3]; _NO_DEFLT_ }; _NO_DEFLT_ } _N_ },
+ max = { _A_ 2 _U_ 11 _N_ _S_ "U(P)U(P)" {_A_ 2 _U_ 22 _N_ _N_ _N_ _N_} _N_ _N_ },
+ min = { _A_ 2 _U_ 11 _N_ _S_ "U(P)U(P)" {_A_ 2 _U_ 22 _N_ _N_ _N_ _N_} _N_ _N_ },
+ _tagCmp = { _A_ 2 _U_ 11 _N_ _S_ "U(P)U(P)" {_A_ 2 _U_ 22 _N_ _N_ _N_ _N_} _N_ _N_ } #-}
instance Ord Double
{-# GHC_PRAGMA _M_ PreludeCore {-dfun-} _A_ 0 _N_ _N_ _N_ _F_ _IF_ARGS_ 0 0 X 9 _!_ _TUP_8 [{{Eq Double}}, (Double -> Double -> Bool), (Double -> Double -> Bool), (Double -> Double -> Bool), (Double -> Double -> Bool), (Double -> Double -> Double), (Double -> Double -> Double), (Double -> Double -> _CMP_TAG)] [_DFUN_ Eq (Double), _CONSTM_ Ord (<) (Double), _CONSTM_ Ord (<=) (Double), _CONSTM_ Ord (>=) (Double), _CONSTM_ Ord (>) (Double), _CONSTM_ Ord max (Double), _CONSTM_ Ord min (Double), _CONSTM_ Ord _tagCmp (Double)] _N_
- (<) = _A_ 2 _U_ 11 _N_ _S_ "U(P)U(P)" {_A_ 2 _U_ 22 _N_ _N_ _F_ _IF_ARGS_ 0 2 XX 1 \ (u0 :: Double#) (u1 :: Double#) -> _#_ ltDouble# [] [u0, u1] _N_} _F_ _IF_ARGS_ 0 2 CC 3 \ (u0 :: Double) (u1 :: Double) -> case u0 of { _ALG_ D# (u2 :: Double#) -> case u1 of { _ALG_ D# (u3 :: Double#) -> _#_ ltDouble# [] [u2, u3]; _NO_DEFLT_ }; _NO_DEFLT_ } _N_,
- (<=) = _A_ 2 _U_ 11 _N_ _S_ "U(P)U(P)" {_A_ 2 _U_ 22 _N_ _N_ _F_ _IF_ARGS_ 0 2 XX 1 \ (u0 :: Double#) (u1 :: Double#) -> _#_ leDouble# [] [u0, u1] _N_} _F_ _IF_ARGS_ 0 2 CC 3 \ (u0 :: Double) (u1 :: Double) -> case u0 of { _ALG_ D# (u2 :: Double#) -> case u1 of { _ALG_ D# (u3 :: Double#) -> _#_ leDouble# [] [u2, u3]; _NO_DEFLT_ }; _NO_DEFLT_ } _N_,
- (>=) = _A_ 2 _U_ 11 _N_ _S_ "U(P)U(P)" {_A_ 2 _U_ 22 _N_ _N_ _F_ _IF_ARGS_ 0 2 XX 1 \ (u0 :: Double#) (u1 :: Double#) -> _#_ geDouble# [] [u0, u1] _N_} _F_ _IF_ARGS_ 0 2 CC 3 \ (u0 :: Double) (u1 :: Double) -> case u0 of { _ALG_ D# (u2 :: Double#) -> case u1 of { _ALG_ D# (u3 :: Double#) -> _#_ geDouble# [] [u2, u3]; _NO_DEFLT_ }; _NO_DEFLT_ } _N_,
- (>) = _A_ 2 _U_ 11 _N_ _S_ "U(P)U(P)" {_A_ 2 _U_ 22 _N_ _N_ _F_ _IF_ARGS_ 0 2 XX 1 \ (u0 :: Double#) (u1 :: Double#) -> _#_ gtDouble# [] [u0, u1] _N_} _F_ _IF_ARGS_ 0 2 CC 3 \ (u0 :: Double) (u1 :: Double) -> case u0 of { _ALG_ D# (u2 :: Double#) -> case u1 of { _ALG_ D# (u3 :: Double#) -> _#_ gtDouble# [] [u2, u3]; _NO_DEFLT_ }; _NO_DEFLT_ } _N_,
- max = _A_ 2 _U_ 11 _N_ _S_ "U(P)U(P)" {_A_ 2 _U_ 22 _N_ _N_ _N_ _N_} _N_ _N_,
- min = _A_ 2 _U_ 11 _N_ _S_ "U(P)U(P)" {_A_ 2 _U_ 22 _N_ _N_ _N_ _N_} _N_ _N_,
- _tagCmp = _A_ 2 _U_ 11 _N_ _S_ "U(P)U(P)" {_A_ 2 _U_ 22 _N_ _N_ _N_ _N_} _N_ _N_ #-}
+ (<) = { _A_ 2 _U_ 11 _N_ _S_ "U(P)U(P)" {_A_ 2 _U_ 22 _N_ _N_ _F_ _IF_ARGS_ 0 2 XX 1 \ (u0 :: Double#) (u1 :: Double#) -> _#_ ltDouble# [] [u0, u1] _N_} _F_ _IF_ARGS_ 0 2 CC 3 \ (u0 :: Double) (u1 :: Double) -> case u0 of { _ALG_ D# (u2 :: Double#) -> case u1 of { _ALG_ D# (u3 :: Double#) -> _#_ ltDouble# [] [u2, u3]; _NO_DEFLT_ }; _NO_DEFLT_ } _N_ },
+ (<=) = { _A_ 2 _U_ 11 _N_ _S_ "U(P)U(P)" {_A_ 2 _U_ 22 _N_ _N_ _F_ _IF_ARGS_ 0 2 XX 1 \ (u0 :: Double#) (u1 :: Double#) -> _#_ leDouble# [] [u0, u1] _N_} _F_ _IF_ARGS_ 0 2 CC 3 \ (u0 :: Double) (u1 :: Double) -> case u0 of { _ALG_ D# (u2 :: Double#) -> case u1 of { _ALG_ D# (u3 :: Double#) -> _#_ leDouble# [] [u2, u3]; _NO_DEFLT_ }; _NO_DEFLT_ } _N_ },
+ (>=) = { _A_ 2 _U_ 11 _N_ _S_ "U(P)U(P)" {_A_ 2 _U_ 22 _N_ _N_ _F_ _IF_ARGS_ 0 2 XX 1 \ (u0 :: Double#) (u1 :: Double#) -> _#_ geDouble# [] [u0, u1] _N_} _F_ _IF_ARGS_ 0 2 CC 3 \ (u0 :: Double) (u1 :: Double) -> case u0 of { _ALG_ D# (u2 :: Double#) -> case u1 of { _ALG_ D# (u3 :: Double#) -> _#_ geDouble# [] [u2, u3]; _NO_DEFLT_ }; _NO_DEFLT_ } _N_ },
+ (>) = { _A_ 2 _U_ 11 _N_ _S_ "U(P)U(P)" {_A_ 2 _U_ 22 _N_ _N_ _F_ _IF_ARGS_ 0 2 XX 1 \ (u0 :: Double#) (u1 :: Double#) -> _#_ gtDouble# [] [u0, u1] _N_} _F_ _IF_ARGS_ 0 2 CC 3 \ (u0 :: Double) (u1 :: Double) -> case u0 of { _ALG_ D# (u2 :: Double#) -> case u1 of { _ALG_ D# (u3 :: Double#) -> _#_ gtDouble# [] [u2, u3]; _NO_DEFLT_ }; _NO_DEFLT_ } _N_ },
+ max = { _A_ 2 _U_ 11 _N_ _S_ "U(P)U(P)" {_A_ 2 _U_ 22 _N_ _N_ _N_ _N_} _N_ _N_ },
+ min = { _A_ 2 _U_ 11 _N_ _S_ "U(P)U(P)" {_A_ 2 _U_ 22 _N_ _N_ _N_ _N_} _N_ _N_ },
+ _tagCmp = { _A_ 2 _U_ 11 _N_ _S_ "U(P)U(P)" {_A_ 2 _U_ 22 _N_ _N_ _N_ _N_} _N_ _N_ } #-}
instance (Ord a, Ord b) => Ord (Either a b)
{-# GHC_PRAGMA _M_ PreludeMonadicIO {-dfun-} _A_ 3 _U_ 222 _N_ _N_ _N_ _N_ #-}
instance Ord Float
{-# GHC_PRAGMA _M_ PreludeCore {-dfun-} _A_ 0 _N_ _N_ _N_ _F_ _IF_ARGS_ 0 0 X 9 _!_ _TUP_8 [{{Eq Float}}, (Float -> Float -> Bool), (Float -> Float -> Bool), (Float -> Float -> Bool), (Float -> Float -> Bool), (Float -> Float -> Float), (Float -> Float -> Float), (Float -> Float -> _CMP_TAG)] [_DFUN_ Eq (Float), _CONSTM_ Ord (<) (Float), _CONSTM_ Ord (<=) (Float), _CONSTM_ Ord (>=) (Float), _CONSTM_ Ord (>) (Float), _CONSTM_ Ord max (Float), _CONSTM_ Ord min (Float), _CONSTM_ Ord _tagCmp (Float)] _N_
- (<) = _A_ 2 _U_ 11 _N_ _S_ "U(P)U(P)" {_A_ 2 _U_ 22 _N_ _N_ _F_ _IF_ARGS_ 0 2 XX 1 \ (u0 :: Float#) (u1 :: Float#) -> _#_ ltFloat# [] [u0, u1] _N_} _F_ _IF_ARGS_ 0 2 CC 3 \ (u0 :: Float) (u1 :: Float) -> case u0 of { _ALG_ F# (u2 :: Float#) -> case u1 of { _ALG_ F# (u3 :: Float#) -> _#_ ltFloat# [] [u2, u3]; _NO_DEFLT_ }; _NO_DEFLT_ } _N_,
- (<=) = _A_ 2 _U_ 11 _N_ _S_ "U(P)U(P)" {_A_ 2 _U_ 22 _N_ _N_ _F_ _IF_ARGS_ 0 2 XX 1 \ (u0 :: Float#) (u1 :: Float#) -> _#_ leFloat# [] [u0, u1] _N_} _F_ _IF_ARGS_ 0 2 CC 3 \ (u0 :: Float) (u1 :: Float) -> case u0 of { _ALG_ F# (u2 :: Float#) -> case u1 of { _ALG_ F# (u3 :: Float#) -> _#_ leFloat# [] [u2, u3]; _NO_DEFLT_ }; _NO_DEFLT_ } _N_,
- (>=) = _A_ 2 _U_ 11 _N_ _S_ "U(P)U(P)" {_A_ 2 _U_ 22 _N_ _N_ _F_ _IF_ARGS_ 0 2 XX 1 \ (u0 :: Float#) (u1 :: Float#) -> _#_ geFloat# [] [u0, u1] _N_} _F_ _IF_ARGS_ 0 2 CC 3 \ (u0 :: Float) (u1 :: Float) -> case u0 of { _ALG_ F# (u2 :: Float#) -> case u1 of { _ALG_ F# (u3 :: Float#) -> _#_ geFloat# [] [u2, u3]; _NO_DEFLT_ }; _NO_DEFLT_ } _N_,
- (>) = _A_ 2 _U_ 11 _N_ _S_ "U(P)U(P)" {_A_ 2 _U_ 22 _N_ _N_ _F_ _IF_ARGS_ 0 2 XX 1 \ (u0 :: Float#) (u1 :: Float#) -> _#_ gtFloat# [] [u0, u1] _N_} _F_ _IF_ARGS_ 0 2 CC 3 \ (u0 :: Float) (u1 :: Float) -> case u0 of { _ALG_ F# (u2 :: Float#) -> case u1 of { _ALG_ F# (u3 :: Float#) -> _#_ gtFloat# [] [u2, u3]; _NO_DEFLT_ }; _NO_DEFLT_ } _N_,
- max = _A_ 2 _U_ 11 _N_ _S_ "U(P)U(P)" {_A_ 2 _U_ 22 _N_ _N_ _N_ _N_} _N_ _N_,
- min = _A_ 2 _U_ 11 _N_ _S_ "U(P)U(P)" {_A_ 2 _U_ 22 _N_ _N_ _N_ _N_} _N_ _N_,
- _tagCmp = _A_ 2 _U_ 11 _N_ _S_ "U(P)U(P)" {_A_ 2 _U_ 22 _N_ _N_ _N_ _N_} _N_ _N_ #-}
+ (<) = { _A_ 2 _U_ 11 _N_ _S_ "U(P)U(P)" {_A_ 2 _U_ 22 _N_ _N_ _F_ _IF_ARGS_ 0 2 XX 1 \ (u0 :: Float#) (u1 :: Float#) -> _#_ ltFloat# [] [u0, u1] _N_} _F_ _IF_ARGS_ 0 2 CC 3 \ (u0 :: Float) (u1 :: Float) -> case u0 of { _ALG_ F# (u2 :: Float#) -> case u1 of { _ALG_ F# (u3 :: Float#) -> _#_ ltFloat# [] [u2, u3]; _NO_DEFLT_ }; _NO_DEFLT_ } _N_ },
+ (<=) = { _A_ 2 _U_ 11 _N_ _S_ "U(P)U(P)" {_A_ 2 _U_ 22 _N_ _N_ _F_ _IF_ARGS_ 0 2 XX 1 \ (u0 :: Float#) (u1 :: Float#) -> _#_ leFloat# [] [u0, u1] _N_} _F_ _IF_ARGS_ 0 2 CC 3 \ (u0 :: Float) (u1 :: Float) -> case u0 of { _ALG_ F# (u2 :: Float#) -> case u1 of { _ALG_ F# (u3 :: Float#) -> _#_ leFloat# [] [u2, u3]; _NO_DEFLT_ }; _NO_DEFLT_ } _N_ },
+ (>=) = { _A_ 2 _U_ 11 _N_ _S_ "U(P)U(P)" {_A_ 2 _U_ 22 _N_ _N_ _F_ _IF_ARGS_ 0 2 XX 1 \ (u0 :: Float#) (u1 :: Float#) -> _#_ geFloat# [] [u0, u1] _N_} _F_ _IF_ARGS_ 0 2 CC 3 \ (u0 :: Float) (u1 :: Float) -> case u0 of { _ALG_ F# (u2 :: Float#) -> case u1 of { _ALG_ F# (u3 :: Float#) -> _#_ geFloat# [] [u2, u3]; _NO_DEFLT_ }; _NO_DEFLT_ } _N_ },
+ (>) = { _A_ 2 _U_ 11 _N_ _S_ "U(P)U(P)" {_A_ 2 _U_ 22 _N_ _N_ _F_ _IF_ARGS_ 0 2 XX 1 \ (u0 :: Float#) (u1 :: Float#) -> _#_ gtFloat# [] [u0, u1] _N_} _F_ _IF_ARGS_ 0 2 CC 3 \ (u0 :: Float) (u1 :: Float) -> case u0 of { _ALG_ F# (u2 :: Float#) -> case u1 of { _ALG_ F# (u3 :: Float#) -> _#_ gtFloat# [] [u2, u3]; _NO_DEFLT_ }; _NO_DEFLT_ } _N_ },
+ max = { _A_ 2 _U_ 11 _N_ _S_ "U(P)U(P)" {_A_ 2 _U_ 22 _N_ _N_ _N_ _N_} _N_ _N_ },
+ min = { _A_ 2 _U_ 11 _N_ _S_ "U(P)U(P)" {_A_ 2 _U_ 22 _N_ _N_ _N_ _N_} _N_ _N_ },
+ _tagCmp = { _A_ 2 _U_ 11 _N_ _S_ "U(P)U(P)" {_A_ 2 _U_ 22 _N_ _N_ _N_ _N_} _N_ _N_ } #-}
instance Ord Int
{-# GHC_PRAGMA _M_ PreludeCore {-dfun-} _A_ 0 _N_ _N_ _N_ _F_ _IF_ARGS_ 0 0 X 9 _!_ _TUP_8 [{{Eq Int}}, (Int -> Int -> Bool), (Int -> Int -> Bool), (Int -> Int -> Bool), (Int -> Int -> Bool), (Int -> Int -> Int), (Int -> Int -> Int), (Int -> Int -> _CMP_TAG)] [_DFUN_ Eq (Int), _CONSTM_ Ord (<) (Int), _CONSTM_ Ord (<=) (Int), _CONSTM_ Ord (>=) (Int), _CONSTM_ Ord (>) (Int), _CONSTM_ Ord max (Int), _CONSTM_ Ord min (Int), _CONSTM_ Ord _tagCmp (Int)] _N_
- (<) = _A_ 2 _U_ 11 _N_ _S_ "U(P)U(P)" {_A_ 2 _U_ 22 _N_ _N_ _F_ _IF_ARGS_ 0 2 XX 1 \ (u0 :: Int#) (u1 :: Int#) -> _#_ ltInt# [] [u0, u1] _N_} _F_ _IF_ARGS_ 0 2 CC 3 \ (u0 :: Int) (u1 :: Int) -> case u0 of { _ALG_ I# (u2 :: Int#) -> case u1 of { _ALG_ I# (u3 :: Int#) -> _#_ ltInt# [] [u2, u3]; _NO_DEFLT_ }; _NO_DEFLT_ } _N_,
- (<=) = _A_ 2 _U_ 11 _N_ _S_ "U(P)U(P)" {_A_ 2 _U_ 22 _N_ _N_ _F_ _IF_ARGS_ 0 2 XX 1 \ (u0 :: Int#) (u1 :: Int#) -> _#_ leInt# [] [u0, u1] _N_} _F_ _IF_ARGS_ 0 2 CC 3 \ (u0 :: Int) (u1 :: Int) -> case u0 of { _ALG_ I# (u2 :: Int#) -> case u1 of { _ALG_ I# (u3 :: Int#) -> _#_ leInt# [] [u2, u3]; _NO_DEFLT_ }; _NO_DEFLT_ } _N_,
- (>=) = _A_ 2 _U_ 11 _N_ _S_ "U(P)U(P)" {_A_ 2 _U_ 22 _N_ _N_ _F_ _IF_ARGS_ 0 2 XX 1 \ (u0 :: Int#) (u1 :: Int#) -> _#_ geInt# [] [u0, u1] _N_} _F_ _IF_ARGS_ 0 2 CC 3 \ (u0 :: Int) (u1 :: Int) -> case u0 of { _ALG_ I# (u2 :: Int#) -> case u1 of { _ALG_ I# (u3 :: Int#) -> _#_ geInt# [] [u2, u3]; _NO_DEFLT_ }; _NO_DEFLT_ } _N_,
- (>) = _A_ 2 _U_ 11 _N_ _S_ "U(P)U(P)" {_A_ 2 _U_ 22 _N_ _N_ _F_ _IF_ARGS_ 0 2 XX 1 \ (u0 :: Int#) (u1 :: Int#) -> _#_ gtInt# [] [u0, u1] _N_} _F_ _IF_ARGS_ 0 2 CC 3 \ (u0 :: Int) (u1 :: Int) -> case u0 of { _ALG_ I# (u2 :: Int#) -> case u1 of { _ALG_ I# (u3 :: Int#) -> _#_ gtInt# [] [u2, u3]; _NO_DEFLT_ }; _NO_DEFLT_ } _N_,
- max = _A_ 2 _U_ 11 _N_ _S_ "U(P)U(P)" {_A_ 2 _U_ 22 _N_ _N_ _N_ _N_} _N_ _N_,
- min = _A_ 2 _U_ 11 _N_ _S_ "U(P)U(P)" {_A_ 2 _U_ 22 _N_ _N_ _N_ _N_} _N_ _N_,
- _tagCmp = _A_ 2 _U_ 11 _N_ _S_ "U(P)U(P)" {_A_ 2 _U_ 22 _N_ _N_ _N_ _N_} _N_ _N_ #-}
+ (<) = { _A_ 2 _U_ 11 _N_ _S_ "U(P)U(P)" {_A_ 2 _U_ 22 _N_ _N_ _F_ _IF_ARGS_ 0 2 XX 1 \ (u0 :: Int#) (u1 :: Int#) -> _#_ ltInt# [] [u0, u1] _N_} _F_ _IF_ARGS_ 0 2 CC 3 \ (u0 :: Int) (u1 :: Int) -> case u0 of { _ALG_ I# (u2 :: Int#) -> case u1 of { _ALG_ I# (u3 :: Int#) -> _#_ ltInt# [] [u2, u3]; _NO_DEFLT_ }; _NO_DEFLT_ } _N_ },
+ (<=) = { _A_ 2 _U_ 11 _N_ _S_ "U(P)U(P)" {_A_ 2 _U_ 22 _N_ _N_ _F_ _IF_ARGS_ 0 2 XX 1 \ (u0 :: Int#) (u1 :: Int#) -> _#_ leInt# [] [u0, u1] _N_} _F_ _IF_ARGS_ 0 2 CC 3 \ (u0 :: Int) (u1 :: Int) -> case u0 of { _ALG_ I# (u2 :: Int#) -> case u1 of { _ALG_ I# (u3 :: Int#) -> _#_ leInt# [] [u2, u3]; _NO_DEFLT_ }; _NO_DEFLT_ } _N_ },
+ (>=) = { _A_ 2 _U_ 11 _N_ _S_ "U(P)U(P)" {_A_ 2 _U_ 22 _N_ _N_ _F_ _IF_ARGS_ 0 2 XX 1 \ (u0 :: Int#) (u1 :: Int#) -> _#_ geInt# [] [u0, u1] _N_} _F_ _IF_ARGS_ 0 2 CC 3 \ (u0 :: Int) (u1 :: Int) -> case u0 of { _ALG_ I# (u2 :: Int#) -> case u1 of { _ALG_ I# (u3 :: Int#) -> _#_ geInt# [] [u2, u3]; _NO_DEFLT_ }; _NO_DEFLT_ } _N_ },
+ (>) = { _A_ 2 _U_ 11 _N_ _S_ "U(P)U(P)" {_A_ 2 _U_ 22 _N_ _N_ _F_ _IF_ARGS_ 0 2 XX 1 \ (u0 :: Int#) (u1 :: Int#) -> _#_ gtInt# [] [u0, u1] _N_} _F_ _IF_ARGS_ 0 2 CC 3 \ (u0 :: Int) (u1 :: Int) -> case u0 of { _ALG_ I# (u2 :: Int#) -> case u1 of { _ALG_ I# (u3 :: Int#) -> _#_ gtInt# [] [u2, u3]; _NO_DEFLT_ }; _NO_DEFLT_ } _N_ },
+ max = { _A_ 2 _U_ 11 _N_ _S_ "U(P)U(P)" {_A_ 2 _U_ 22 _N_ _N_ _N_ _N_} _N_ _N_ },
+ min = { _A_ 2 _U_ 11 _N_ _S_ "U(P)U(P)" {_A_ 2 _U_ 22 _N_ _N_ _N_ _N_} _N_ _N_ },
+ _tagCmp = { _A_ 2 _U_ 11 _N_ _S_ "U(P)U(P)" {_A_ 2 _U_ 22 _N_ _N_ _N_ _N_} _N_ _N_ } #-}
instance Ord Integer
{-# GHC_PRAGMA _M_ PreludeCore {-dfun-} _A_ 0 _N_ _N_ _N_ _F_ _IF_ARGS_ 0 0 X 9 _!_ _TUP_8 [{{Eq Integer}}, (Integer -> Integer -> Bool), (Integer -> Integer -> Bool), (Integer -> Integer -> Bool), (Integer -> Integer -> Bool), (Integer -> Integer -> Integer), (Integer -> Integer -> Integer), (Integer -> Integer -> _CMP_TAG)] [_DFUN_ Eq (Integer), _CONSTM_ Ord (<) (Integer), _CONSTM_ Ord (<=) (Integer), _CONSTM_ Ord (>=) (Integer), _CONSTM_ Ord (>) (Integer), _CONSTM_ Ord max (Integer), _CONSTM_ Ord min (Integer), _CONSTM_ Ord _tagCmp (Integer)] _N_
- (<) = _A_ 2 _U_ 11 _N_ _S_ "U(PPP)U(PPP)" {_A_ 4 _U_ 2221 _N_ _N_ _F_ _IF_ARGS_ 0 4 XXXC 3 \ (u0 :: Int#) (u1 :: Int#) (u2 :: ByteArray#) (u3 :: Integer) -> case u3 of { _ALG_ J# (u4 :: Int#) (u5 :: Int#) (u6 :: ByteArray#) -> case _#_ cmpInteger# [] [u0, u1, u2, u4, u5, u6] of { _PRIM_ (u7 :: Int#) -> _#_ ltInt# [] [u7, 0#] }; _NO_DEFLT_ } _N_} _F_ _IF_ARGS_ 0 2 CC 4 \ (u0 :: Integer) (u1 :: Integer) -> case u0 of { _ALG_ J# (u2 :: Int#) (u3 :: Int#) (u4 :: ByteArray#) -> case u1 of { _ALG_ J# (u5 :: Int#) (u6 :: Int#) (u7 :: ByteArray#) -> case _#_ cmpInteger# [] [u2, u3, u4, u5, u6, u7] of { _PRIM_ (u8 :: Int#) -> _#_ ltInt# [] [u8, 0#] }; _NO_DEFLT_ }; _NO_DEFLT_ } _N_,
- (<=) = _A_ 2 _U_ 11 _N_ _S_ "U(PPP)U(PPP)" {_A_ 4 _U_ 2221 _N_ _N_ _F_ _IF_ARGS_ 0 4 XXXC 3 \ (u0 :: Int#) (u1 :: Int#) (u2 :: ByteArray#) (u3 :: Integer) -> case u3 of { _ALG_ J# (u4 :: Int#) (u5 :: Int#) (u6 :: ByteArray#) -> case _#_ cmpInteger# [] [u0, u1, u2, u4, u5, u6] of { _PRIM_ (u7 :: Int#) -> _#_ leInt# [] [u7, 0#] }; _NO_DEFLT_ } _N_} _F_ _IF_ARGS_ 0 2 CC 4 \ (u0 :: Integer) (u1 :: Integer) -> case u0 of { _ALG_ J# (u2 :: Int#) (u3 :: Int#) (u4 :: ByteArray#) -> case u1 of { _ALG_ J# (u5 :: Int#) (u6 :: Int#) (u7 :: ByteArray#) -> case _#_ cmpInteger# [] [u2, u3, u4, u5, u6, u7] of { _PRIM_ (u8 :: Int#) -> _#_ leInt# [] [u8, 0#] }; _NO_DEFLT_ }; _NO_DEFLT_ } _N_,
- (>=) = _A_ 2 _U_ 11 _N_ _S_ "U(PPP)U(PPP)" {_A_ 4 _U_ 2221 _N_ _N_ _F_ _IF_ARGS_ 0 4 XXXC 3 \ (u0 :: Int#) (u1 :: Int#) (u2 :: ByteArray#) (u3 :: Integer) -> case u3 of { _ALG_ J# (u4 :: Int#) (u5 :: Int#) (u6 :: ByteArray#) -> case _#_ cmpInteger# [] [u0, u1, u2, u4, u5, u6] of { _PRIM_ (u7 :: Int#) -> _#_ geInt# [] [u7, 0#] }; _NO_DEFLT_ } _N_} _F_ _IF_ARGS_ 0 2 CC 4 \ (u0 :: Integer) (u1 :: Integer) -> case u0 of { _ALG_ J# (u2 :: Int#) (u3 :: Int#) (u4 :: ByteArray#) -> case u1 of { _ALG_ J# (u5 :: Int#) (u6 :: Int#) (u7 :: ByteArray#) -> case _#_ cmpInteger# [] [u2, u3, u4, u5, u6, u7] of { _PRIM_ (u8 :: Int#) -> _#_ geInt# [] [u8, 0#] }; _NO_DEFLT_ }; _NO_DEFLT_ } _N_,
- (>) = _A_ 2 _U_ 11 _N_ _S_ "U(PPP)U(PPP)" {_A_ 4 _U_ 2221 _N_ _N_ _F_ _IF_ARGS_ 0 4 XXXC 3 \ (u0 :: Int#) (u1 :: Int#) (u2 :: ByteArray#) (u3 :: Integer) -> case u3 of { _ALG_ J# (u4 :: Int#) (u5 :: Int#) (u6 :: ByteArray#) -> case _#_ cmpInteger# [] [u0, u1, u2, u4, u5, u6] of { _PRIM_ (u7 :: Int#) -> _#_ gtInt# [] [u7, 0#] }; _NO_DEFLT_ } _N_} _F_ _IF_ARGS_ 0 2 CC 4 \ (u0 :: Integer) (u1 :: Integer) -> case u0 of { _ALG_ J# (u2 :: Int#) (u3 :: Int#) (u4 :: ByteArray#) -> case u1 of { _ALG_ J# (u5 :: Int#) (u6 :: Int#) (u7 :: ByteArray#) -> case _#_ cmpInteger# [] [u2, u3, u4, u5, u6, u7] of { _PRIM_ (u8 :: Int#) -> _#_ gtInt# [] [u8, 0#] }; _NO_DEFLT_ }; _NO_DEFLT_ } _N_,
- max = _A_ 2 _U_ 11 _N_ _S_ "U(PPP)U(PPP)" {_A_ 4 _U_ 2221 _N_ _N_ _N_ _N_} _N_ _N_,
- min = _A_ 2 _U_ 11 _N_ _S_ "U(PPP)U(PPP)" {_A_ 4 _U_ 2221 _N_ _N_ _N_ _N_} _N_ _N_,
- _tagCmp = _A_ 2 _U_ 11 _N_ _S_ "U(PPP)U(PPP)" {_A_ 4 _U_ 2221 _N_ _N_ _N_ _N_} _N_ _N_ #-}
+ (<) = { _A_ 2 _U_ 11 _N_ _S_ "U(PPP)U(PPP)" {_A_ 4 _U_ 2221 _N_ _N_ _F_ _IF_ARGS_ 0 4 XXXC 3 \ (u0 :: Int#) (u1 :: Int#) (u2 :: ByteArray#) (u3 :: Integer) -> case u3 of { _ALG_ J# (u4 :: Int#) (u5 :: Int#) (u6 :: ByteArray#) -> case _#_ cmpInteger# [] [u0, u1, u2, u4, u5, u6] of { _PRIM_ (u7 :: Int#) -> _#_ ltInt# [] [u7, 0#] }; _NO_DEFLT_ } _N_} _F_ _IF_ARGS_ 0 2 CC 4 \ (u0 :: Integer) (u1 :: Integer) -> case u0 of { _ALG_ J# (u2 :: Int#) (u3 :: Int#) (u4 :: ByteArray#) -> case u1 of { _ALG_ J# (u5 :: Int#) (u6 :: Int#) (u7 :: ByteArray#) -> case _#_ cmpInteger# [] [u2, u3, u4, u5, u6, u7] of { _PRIM_ (u8 :: Int#) -> _#_ ltInt# [] [u8, 0#] }; _NO_DEFLT_ }; _NO_DEFLT_ } _N_ },
+ (<=) = { _A_ 2 _U_ 11 _N_ _S_ "U(PPP)U(PPP)" {_A_ 4 _U_ 2221 _N_ _N_ _F_ _IF_ARGS_ 0 4 XXXC 3 \ (u0 :: Int#) (u1 :: Int#) (u2 :: ByteArray#) (u3 :: Integer) -> case u3 of { _ALG_ J# (u4 :: Int#) (u5 :: Int#) (u6 :: ByteArray#) -> case _#_ cmpInteger# [] [u0, u1, u2, u4, u5, u6] of { _PRIM_ (u7 :: Int#) -> _#_ leInt# [] [u7, 0#] }; _NO_DEFLT_ } _N_} _F_ _IF_ARGS_ 0 2 CC 4 \ (u0 :: Integer) (u1 :: Integer) -> case u0 of { _ALG_ J# (u2 :: Int#) (u3 :: Int#) (u4 :: ByteArray#) -> case u1 of { _ALG_ J# (u5 :: Int#) (u6 :: Int#) (u7 :: ByteArray#) -> case _#_ cmpInteger# [] [u2, u3, u4, u5, u6, u7] of { _PRIM_ (u8 :: Int#) -> _#_ leInt# [] [u8, 0#] }; _NO_DEFLT_ }; _NO_DEFLT_ } _N_ },
+ (>=) = { _A_ 2 _U_ 11 _N_ _S_ "U(PPP)U(PPP)" {_A_ 4 _U_ 2221 _N_ _N_ _F_ _IF_ARGS_ 0 4 XXXC 3 \ (u0 :: Int#) (u1 :: Int#) (u2 :: ByteArray#) (u3 :: Integer) -> case u3 of { _ALG_ J# (u4 :: Int#) (u5 :: Int#) (u6 :: ByteArray#) -> case _#_ cmpInteger# [] [u0, u1, u2, u4, u5, u6] of { _PRIM_ (u7 :: Int#) -> _#_ geInt# [] [u7, 0#] }; _NO_DEFLT_ } _N_} _F_ _IF_ARGS_ 0 2 CC 4 \ (u0 :: Integer) (u1 :: Integer) -> case u0 of { _ALG_ J# (u2 :: Int#) (u3 :: Int#) (u4 :: ByteArray#) -> case u1 of { _ALG_ J# (u5 :: Int#) (u6 :: Int#) (u7 :: ByteArray#) -> case _#_ cmpInteger# [] [u2, u3, u4, u5, u6, u7] of { _PRIM_ (u8 :: Int#) -> _#_ geInt# [] [u8, 0#] }; _NO_DEFLT_ }; _NO_DEFLT_ } _N_ },
+ (>) = { _A_ 2 _U_ 11 _N_ _S_ "U(PPP)U(PPP)" {_A_ 4 _U_ 2221 _N_ _N_ _F_ _IF_ARGS_ 0 4 XXXC 3 \ (u0 :: Int#) (u1 :: Int#) (u2 :: ByteArray#) (u3 :: Integer) -> case u3 of { _ALG_ J# (u4 :: Int#) (u5 :: Int#) (u6 :: ByteArray#) -> case _#_ cmpInteger# [] [u0, u1, u2, u4, u5, u6] of { _PRIM_ (u7 :: Int#) -> _#_ gtInt# [] [u7, 0#] }; _NO_DEFLT_ } _N_} _F_ _IF_ARGS_ 0 2 CC 4 \ (u0 :: Integer) (u1 :: Integer) -> case u0 of { _ALG_ J# (u2 :: Int#) (u3 :: Int#) (u4 :: ByteArray#) -> case u1 of { _ALG_ J# (u5 :: Int#) (u6 :: Int#) (u7 :: ByteArray#) -> case _#_ cmpInteger# [] [u2, u3, u4, u5, u6, u7] of { _PRIM_ (u8 :: Int#) -> _#_ gtInt# [] [u8, 0#] }; _NO_DEFLT_ }; _NO_DEFLT_ } _N_ },
+ max = { _A_ 2 _U_ 11 _N_ _S_ "U(PPP)U(PPP)" {_A_ 4 _U_ 2221 _N_ _N_ _N_ _N_} _N_ _N_ },
+ min = { _A_ 2 _U_ 11 _N_ _S_ "U(PPP)U(PPP)" {_A_ 4 _U_ 2221 _N_ _N_ _N_ _N_} _N_ _N_ },
+ _tagCmp = { _A_ 2 _U_ 11 _N_ _S_ "U(PPP)U(PPP)" {_A_ 4 _U_ 2221 _N_ _N_ _N_ _N_} _N_ _N_ } #-}
instance Ord a => Ord (Maybe a)
{-# GHC_PRAGMA _M_ PreludeStdIO {-dfun-} _A_ 2 _U_ 22 _N_ _N_ _N_ _N_ #-}
instance Integral a => Ord (Ratio a)
{-# GHC_PRAGMA _M_ PreludeRatio {-dfun-} _A_ 2 _U_ 22 _N_ _N_ _N_ _N_ #-}
instance Ord (Ratio Integer)
{-# GHC_PRAGMA _M_ PreludeRatio {-dfun-} _A_ 0 _N_ _N_ _N_ _F_ _IF_ARGS_ 0 0 X 9 _!_ _TUP_8 [{{Eq (Ratio Integer)}}, (Ratio Integer -> Ratio Integer -> Bool), (Ratio Integer -> Ratio Integer -> Bool), (Ratio Integer -> Ratio Integer -> Bool), (Ratio Integer -> Ratio Integer -> Bool), (Ratio Integer -> Ratio Integer -> Ratio Integer), (Ratio Integer -> Ratio Integer -> Ratio Integer), (Ratio Integer -> Ratio Integer -> _CMP_TAG)] [_DFUN_ Eq (Ratio Integer), _CONSTM_ Ord (<) (Ratio Integer), _CONSTM_ Ord (<=) (Ratio Integer), _CONSTM_ Ord (>=) (Ratio Integer), _CONSTM_ Ord (>) (Ratio Integer), _CONSTM_ Ord max (Ratio Integer), _CONSTM_ Ord min (Ratio Integer), _CONSTM_ Ord _tagCmp (Ratio Integer)] _N_
- (<) = _A_ 2 _U_ 11 _N_ _S_ "U(U(PPP)U(PPP))U(U(PPP)U(PPP))" {_A_ 5 _U_ 22221 _N_ _N_ _N_ _N_} _N_ _N_,
- (<=) = _A_ 2 _U_ 11 _N_ _S_ "U(U(PPP)U(PPP))U(U(PPP)U(PPP))" {_A_ 5 _U_ 22221 _N_ _N_ _N_ _N_} _N_ _N_,
- (>=) = _A_ 2 _U_ 11 _N_ _S_ "U(U(PPP)U(PPP))U(U(PPP)U(PPP))" {_A_ 5 _U_ 22221 _N_ _N_ _N_ _N_} _N_ _N_,
- (>) = _A_ 2 _U_ 11 _N_ _S_ "U(U(PPP)U(PPP))U(U(PPP)U(PPP))" {_A_ 5 _U_ 22221 _N_ _N_ _N_ _N_} _N_ _N_,
- max = _A_ 2 _U_ 12 _N_ _S_ "U(U(PPP)U(PPP))U(U(PPP)U(PPP))" {_A_ 5 _U_ 22222 _N_ _N_ _N_ _N_} _N_ _N_,
- min = _A_ 2 _U_ 12 _N_ _S_ "U(U(PPP)U(PPP))U(U(PPP)U(PPP))" {_A_ 5 _U_ 22222 _N_ _N_ _N_ _N_} _N_ _N_,
- _tagCmp = _A_ 2 _U_ 11 _N_ _S_ "U(U(PPP)U(PPP))U(U(PPP)U(PPP))" {_A_ 5 _U_ 22221 _N_ _N_ _N_ _N_} _N_ _N_ #-}
+ (<) = { _A_ 2 _U_ 11 _N_ _S_ "U(U(PPP)U(PPP))U(U(PPP)U(PPP))" {_A_ 5 _U_ 22221 _N_ _N_ _N_ _N_} _N_ _N_ },
+ (<=) = { _A_ 2 _U_ 11 _N_ _S_ "U(U(PPP)U(PPP))U(U(PPP)U(PPP))" {_A_ 5 _U_ 22221 _N_ _N_ _N_ _N_} _N_ _N_ },
+ (>=) = { _A_ 2 _U_ 11 _N_ _S_ "U(U(PPP)U(PPP))U(U(PPP)U(PPP))" {_A_ 5 _U_ 22221 _N_ _N_ _N_ _N_} _N_ _N_ },
+ (>) = { _A_ 2 _U_ 11 _N_ _S_ "U(U(PPP)U(PPP))U(U(PPP)U(PPP))" {_A_ 5 _U_ 22221 _N_ _N_ _N_ _N_} _N_ _N_ },
+ max = { _A_ 2 _U_ 12 _N_ _S_ "U(U(PPP)U(PPP))U(U(PPP)U(PPP))" {_A_ 5 _U_ 22222 _N_ _N_ _N_ _N_} _N_ _N_ },
+ min = { _A_ 2 _U_ 12 _N_ _S_ "U(U(PPP)U(PPP))U(U(PPP)U(PPP))" {_A_ 5 _U_ 22222 _N_ _N_ _N_ _N_} _N_ _N_ },
+ _tagCmp = { _A_ 2 _U_ 11 _N_ _S_ "U(U(PPP)U(PPP))U(U(PPP)U(PPP))" {_A_ 5 _U_ 22221 _N_ _N_ _N_ _N_} _N_ _N_ } #-}
instance Ord a => Ord [a]
{-# GHC_PRAGMA _M_ PreludeBuiltin {-dfun-} _A_ 2 _U_ 12 _N_ _N_ _N_ _N_ #-}
+instance Ord [Bool]
+ {-# GHC_PRAGMA _M_ PreludeBuiltin {-dfun-} _A_ 0 _N_ _N_ _N_ _F_ _IF_ARGS_ 0 0 X 9 _!_ _TUP_8 [{{Eq [Bool]}}, ([Bool] -> [Bool] -> Bool), ([Bool] -> [Bool] -> Bool), ([Bool] -> [Bool] -> Bool), ([Bool] -> [Bool] -> Bool), ([Bool] -> [Bool] -> [Bool]), ([Bool] -> [Bool] -> [Bool]), ([Bool] -> [Bool] -> _CMP_TAG)] [_DFUN_ Eq ([Bool]), _CONSTM_ Ord (<) ([Bool]), _CONSTM_ Ord (<=) ([Bool]), _CONSTM_ Ord (>=) ([Bool]), _CONSTM_ Ord (>) ([Bool]), _CONSTM_ Ord max ([Bool]), _CONSTM_ Ord min ([Bool]), _CONSTM_ Ord _tagCmp ([Bool])] _N_
+ (<) = { _A_ 2 _U_ 11 _N_ _S_ "SS" _N_ _N_ },
+ (<=) = { _A_ 2 _U_ 11 _N_ _S_ "SS" _N_ _N_ },
+ (>=) = { _A_ 2 _U_ 11 _N_ _S_ "SS" _N_ _N_ },
+ (>) = { _A_ 2 _U_ 11 _N_ _S_ "SS" _N_ _N_ },
+ max = { _A_ 2 _U_ 22 _N_ _S_ "SS" _N_ _N_ },
+ min = { _A_ 2 _U_ 22 _N_ _S_ "SS" _N_ _N_ },
+ _tagCmp = { _A_ 2 _U_ 11 _N_ _S_ "SS" _N_ _N_ } #-}
instance Ord [Char]
{-# GHC_PRAGMA _M_ PreludeBuiltin {-dfun-} _A_ 0 _N_ _N_ _N_ _F_ _IF_ARGS_ 0 0 X 9 _!_ _TUP_8 [{{Eq [Char]}}, ([Char] -> [Char] -> Bool), ([Char] -> [Char] -> Bool), ([Char] -> [Char] -> Bool), ([Char] -> [Char] -> Bool), ([Char] -> [Char] -> [Char]), ([Char] -> [Char] -> [Char]), ([Char] -> [Char] -> _CMP_TAG)] [_DFUN_ Eq ([Char]), _CONSTM_ Ord (<) ([Char]), _CONSTM_ Ord (<=) ([Char]), _CONSTM_ Ord (>=) ([Char]), _CONSTM_ Ord (>) ([Char]), _CONSTM_ Ord max ([Char]), _CONSTM_ Ord min ([Char]), _CONSTM_ Ord _tagCmp ([Char])] _N_
- (<) = _A_ 2 _U_ 11 _N_ _S_ "SS" _N_ _N_,
- (<=) = _A_ 2 _U_ 11 _N_ _S_ "SS" _N_ _N_,
- (>=) = _A_ 2 _U_ 11 _N_ _S_ "SS" _N_ _N_,
- (>) = _A_ 2 _U_ 11 _N_ _S_ "SS" _N_ _N_,
- max = _A_ 2 _U_ 22 _N_ _S_ "SS" _N_ _N_,
- min = _A_ 2 _U_ 22 _N_ _S_ "SS" _N_ _N_,
- _tagCmp = _A_ 2 _U_ 11 _N_ _S_ "SS" _N_ _N_ #-}
+ (<) = { _A_ 2 _U_ 11 _N_ _S_ "SS" _N_ _N_ },
+ (<=) = { _A_ 2 _U_ 11 _N_ _S_ "SS" _N_ _N_ },
+ (>=) = { _A_ 2 _U_ 11 _N_ _S_ "SS" _N_ _N_ },
+ (>) = { _A_ 2 _U_ 11 _N_ _S_ "SS" _N_ _N_ },
+ max = { _A_ 2 _U_ 22 _N_ _S_ "SS" _N_ _N_ },
+ min = { _A_ 2 _U_ 22 _N_ _S_ "SS" _N_ _N_ },
+ _tagCmp = { _A_ 2 _U_ 11 _N_ _S_ "SS" _N_ _N_ } #-}
+instance Ord [Double]
+ {-# GHC_PRAGMA _M_ PreludeBuiltin {-dfun-} _A_ 0 _N_ _N_ _N_ _F_ _IF_ARGS_ 0 0 X 9 _!_ _TUP_8 [{{Eq [Double]}}, ([Double] -> [Double] -> Bool), ([Double] -> [Double] -> Bool), ([Double] -> [Double] -> Bool), ([Double] -> [Double] -> Bool), ([Double] -> [Double] -> [Double]), ([Double] -> [Double] -> [Double]), ([Double] -> [Double] -> _CMP_TAG)] [_DFUN_ Eq ([Double]), _CONSTM_ Ord (<) ([Double]), _CONSTM_ Ord (<=) ([Double]), _CONSTM_ Ord (>=) ([Double]), _CONSTM_ Ord (>) ([Double]), _CONSTM_ Ord max ([Double]), _CONSTM_ Ord min ([Double]), _CONSTM_ Ord _tagCmp ([Double])] _N_
+ (<) = { _A_ 2 _U_ 11 _N_ _S_ "SS" _N_ _N_ },
+ (<=) = { _A_ 2 _U_ 11 _N_ _S_ "SS" _N_ _N_ },
+ (>=) = { _A_ 2 _U_ 11 _N_ _S_ "SS" _N_ _N_ },
+ (>) = { _A_ 2 _U_ 11 _N_ _S_ "SS" _N_ _N_ },
+ max = { _A_ 2 _U_ 22 _N_ _S_ "SS" _N_ _N_ },
+ min = { _A_ 2 _U_ 22 _N_ _S_ "SS" _N_ _N_ },
+ _tagCmp = { _A_ 2 _U_ 11 _N_ _S_ "SS" _N_ _N_ } #-}
instance Ord [Int]
{-# GHC_PRAGMA _M_ PreludeBuiltin {-dfun-} _A_ 0 _N_ _N_ _N_ _F_ _IF_ARGS_ 0 0 X 9 _!_ _TUP_8 [{{Eq [Int]}}, ([Int] -> [Int] -> Bool), ([Int] -> [Int] -> Bool), ([Int] -> [Int] -> Bool), ([Int] -> [Int] -> Bool), ([Int] -> [Int] -> [Int]), ([Int] -> [Int] -> [Int]), ([Int] -> [Int] -> _CMP_TAG)] [_DFUN_ Eq ([Int]), _CONSTM_ Ord (<) ([Int]), _CONSTM_ Ord (<=) ([Int]), _CONSTM_ Ord (>=) ([Int]), _CONSTM_ Ord (>) ([Int]), _CONSTM_ Ord max ([Int]), _CONSTM_ Ord min ([Int]), _CONSTM_ Ord _tagCmp ([Int])] _N_
- (<) = _A_ 2 _U_ 11 _N_ _S_ "SS" _N_ _N_,
- (<=) = _A_ 2 _U_ 11 _N_ _S_ "SS" _N_ _N_,
- (>=) = _A_ 2 _U_ 11 _N_ _S_ "SS" _N_ _N_,
- (>) = _A_ 2 _U_ 11 _N_ _S_ "SS" _N_ _N_,
- max = _A_ 2 _U_ 22 _N_ _S_ "SS" _N_ _N_,
- min = _A_ 2 _U_ 22 _N_ _S_ "SS" _N_ _N_,
- _tagCmp = _A_ 2 _U_ 11 _N_ _S_ "SS" _N_ _N_ #-}
+ (<) = { _A_ 2 _U_ 11 _N_ _S_ "SS" _N_ _N_ },
+ (<=) = { _A_ 2 _U_ 11 _N_ _S_ "SS" _N_ _N_ },
+ (>=) = { _A_ 2 _U_ 11 _N_ _S_ "SS" _N_ _N_ },
+ (>) = { _A_ 2 _U_ 11 _N_ _S_ "SS" _N_ _N_ },
+ max = { _A_ 2 _U_ 22 _N_ _S_ "SS" _N_ _N_ },
+ min = { _A_ 2 _U_ 22 _N_ _S_ "SS" _N_ _N_ },
+ _tagCmp = { _A_ 2 _U_ 11 _N_ _S_ "SS" _N_ _N_ } #-}
+instance Ord [Integer]
+ {-# GHC_PRAGMA _M_ PreludeBuiltin {-dfun-} _A_ 0 _N_ _N_ _N_ _F_ _IF_ARGS_ 0 0 X 9 _!_ _TUP_8 [{{Eq [Integer]}}, ([Integer] -> [Integer] -> Bool), ([Integer] -> [Integer] -> Bool), ([Integer] -> [Integer] -> Bool), ([Integer] -> [Integer] -> Bool), ([Integer] -> [Integer] -> [Integer]), ([Integer] -> [Integer] -> [Integer]), ([Integer] -> [Integer] -> _CMP_TAG)] [_DFUN_ Eq ([Integer]), _CONSTM_ Ord (<) ([Integer]), _CONSTM_ Ord (<=) ([Integer]), _CONSTM_ Ord (>=) ([Integer]), _CONSTM_ Ord (>) ([Integer]), _CONSTM_ Ord max ([Integer]), _CONSTM_ Ord min ([Integer]), _CONSTM_ Ord _tagCmp ([Integer])] _N_
+ (<) = { _A_ 2 _U_ 11 _N_ _S_ "SS" _N_ _N_ },
+ (<=) = { _A_ 2 _U_ 11 _N_ _S_ "SS" _N_ _N_ },
+ (>=) = { _A_ 2 _U_ 11 _N_ _S_ "SS" _N_ _N_ },
+ (>) = { _A_ 2 _U_ 11 _N_ _S_ "SS" _N_ _N_ },
+ max = { _A_ 2 _U_ 22 _N_ _S_ "SS" _N_ _N_ },
+ min = { _A_ 2 _U_ 22 _N_ _S_ "SS" _N_ _N_ },
+ _tagCmp = { _A_ 2 _U_ 11 _N_ _S_ "SS" _N_ _N_ } #-}
+instance Ord [[Char]]
+ {-# GHC_PRAGMA _M_ PreludeBuiltin {-dfun-} _A_ 0 _N_ _N_ _N_ _F_ _IF_ARGS_ 0 0 X 9 _!_ _TUP_8 [{{Eq [[Char]]}}, ([[Char]] -> [[Char]] -> Bool), ([[Char]] -> [[Char]] -> Bool), ([[Char]] -> [[Char]] -> Bool), ([[Char]] -> [[Char]] -> Bool), ([[Char]] -> [[Char]] -> [[Char]]), ([[Char]] -> [[Char]] -> [[Char]]), ([[Char]] -> [[Char]] -> _CMP_TAG)] [_DFUN_ Eq ([[Char]]), _CONSTM_ Ord (<) ([[Char]]), _CONSTM_ Ord (<=) ([[Char]]), _CONSTM_ Ord (>=) ([[Char]]), _CONSTM_ Ord (>) ([[Char]]), _CONSTM_ Ord max ([[Char]]), _CONSTM_ Ord min ([[Char]]), _CONSTM_ Ord _tagCmp ([[Char]])] _N_
+ (<) = { _A_ 2 _U_ 11 _N_ _S_ "SS" _N_ _N_ },
+ (<=) = { _A_ 2 _U_ 11 _N_ _S_ "SS" _N_ _N_ },
+ (>=) = { _A_ 2 _U_ 11 _N_ _S_ "SS" _N_ _N_ },
+ (>) = { _A_ 2 _U_ 11 _N_ _S_ "SS" _N_ _N_ },
+ max = { _A_ 2 _U_ 22 _N_ _S_ "SS" _N_ _N_ },
+ min = { _A_ 2 _U_ 22 _N_ _S_ "SS" _N_ _N_ },
+ _tagCmp = { _A_ 2 _U_ 11 _N_ _S_ "SS" _N_ _N_ } #-}
+instance Ord [[Int]]
+ {-# GHC_PRAGMA _M_ PreludeBuiltin {-dfun-} _A_ 0 _N_ _N_ _N_ _F_ _IF_ARGS_ 0 0 X 9 _!_ _TUP_8 [{{Eq [[Int]]}}, ([[Int]] -> [[Int]] -> Bool), ([[Int]] -> [[Int]] -> Bool), ([[Int]] -> [[Int]] -> Bool), ([[Int]] -> [[Int]] -> Bool), ([[Int]] -> [[Int]] -> [[Int]]), ([[Int]] -> [[Int]] -> [[Int]]), ([[Int]] -> [[Int]] -> _CMP_TAG)] [_DFUN_ Eq ([[Int]]), _CONSTM_ Ord (<) ([[Int]]), _CONSTM_ Ord (<=) ([[Int]]), _CONSTM_ Ord (>=) ([[Int]]), _CONSTM_ Ord (>) ([[Int]]), _CONSTM_ Ord max ([[Int]]), _CONSTM_ Ord min ([[Int]]), _CONSTM_ Ord _tagCmp ([[Int]])] _N_
+ (<) = { _A_ 2 _U_ 11 _N_ _S_ "SS" _N_ _N_ },
+ (<=) = { _A_ 2 _U_ 11 _N_ _S_ "SS" _N_ _N_ },
+ (>=) = { _A_ 2 _U_ 11 _N_ _S_ "SS" _N_ _N_ },
+ (>) = { _A_ 2 _U_ 11 _N_ _S_ "SS" _N_ _N_ },
+ max = { _A_ 2 _U_ 22 _N_ _S_ "SS" _N_ _N_ },
+ min = { _A_ 2 _U_ 22 _N_ _S_ "SS" _N_ _N_ },
+ _tagCmp = { _A_ 2 _U_ 11 _N_ _S_ "SS" _N_ _N_ } #-}
instance Ord _Addr
{-# GHC_PRAGMA _M_ PreludeCore {-dfun-} _A_ 0 _N_ _N_ _N_ _F_ _IF_ARGS_ 0 0 X 9 _!_ _TUP_8 [{{Eq _Addr}}, (_Addr -> _Addr -> Bool), (_Addr -> _Addr -> Bool), (_Addr -> _Addr -> Bool), (_Addr -> _Addr -> Bool), (_Addr -> _Addr -> _Addr), (_Addr -> _Addr -> _Addr), (_Addr -> _Addr -> _CMP_TAG)] [_DFUN_ Eq (_Addr), _CONSTM_ Ord (<) (_Addr), _CONSTM_ Ord (<=) (_Addr), _CONSTM_ Ord (>=) (_Addr), _CONSTM_ Ord (>) (_Addr), _CONSTM_ Ord max (_Addr), _CONSTM_ Ord min (_Addr), _CONSTM_ Ord _tagCmp (_Addr)] _N_
- (<) = _A_ 2 _U_ 11 _N_ _S_ "U(P)U(P)" {_A_ 2 _U_ 22 _N_ _N_ _F_ _IF_ARGS_ 0 2 XX 1 \ (u0 :: Addr#) (u1 :: Addr#) -> _#_ ltAddr# [] [u0, u1] _N_} _F_ _IF_ARGS_ 0 2 CC 3 \ (u0 :: _Addr) (u1 :: _Addr) -> case u0 of { _ALG_ A# (u2 :: Addr#) -> case u1 of { _ALG_ A# (u3 :: Addr#) -> _#_ ltAddr# [] [u2, u3]; _NO_DEFLT_ }; _NO_DEFLT_ } _N_,
- (<=) = _A_ 2 _U_ 11 _N_ _S_ "U(P)U(P)" {_A_ 2 _U_ 22 _N_ _N_ _F_ _IF_ARGS_ 0 2 XX 1 \ (u0 :: Addr#) (u1 :: Addr#) -> _#_ leAddr# [] [u0, u1] _N_} _F_ _IF_ARGS_ 0 2 CC 3 \ (u0 :: _Addr) (u1 :: _Addr) -> case u0 of { _ALG_ A# (u2 :: Addr#) -> case u1 of { _ALG_ A# (u3 :: Addr#) -> _#_ leAddr# [] [u2, u3]; _NO_DEFLT_ }; _NO_DEFLT_ } _N_,
- (>=) = _A_ 2 _U_ 11 _N_ _S_ "U(P)U(P)" {_A_ 2 _U_ 22 _N_ _N_ _F_ _IF_ARGS_ 0 2 XX 1 \ (u0 :: Addr#) (u1 :: Addr#) -> _#_ geAddr# [] [u0, u1] _N_} _F_ _IF_ARGS_ 0 2 CC 3 \ (u0 :: _Addr) (u1 :: _Addr) -> case u0 of { _ALG_ A# (u2 :: Addr#) -> case u1 of { _ALG_ A# (u3 :: Addr#) -> _#_ geAddr# [] [u2, u3]; _NO_DEFLT_ }; _NO_DEFLT_ } _N_,
- (>) = _A_ 2 _U_ 11 _N_ _S_ "U(P)U(P)" {_A_ 2 _U_ 22 _N_ _N_ _F_ _IF_ARGS_ 0 2 XX 1 \ (u0 :: Addr#) (u1 :: Addr#) -> _#_ gtAddr# [] [u0, u1] _N_} _F_ _IF_ARGS_ 0 2 CC 3 \ (u0 :: _Addr) (u1 :: _Addr) -> case u0 of { _ALG_ A# (u2 :: Addr#) -> case u1 of { _ALG_ A# (u3 :: Addr#) -> _#_ gtAddr# [] [u2, u3]; _NO_DEFLT_ }; _NO_DEFLT_ } _N_,
- max = _A_ 2 _U_ 11 _N_ _S_ "U(P)U(P)" {_A_ 2 _U_ 22 _N_ _N_ _N_ _N_} _N_ _N_,
- min = _A_ 2 _U_ 11 _N_ _S_ "U(P)U(P)" {_A_ 2 _U_ 22 _N_ _N_ _N_ _N_} _N_ _N_,
- _tagCmp = _A_ 2 _U_ 11 _N_ _S_ "U(P)U(P)" {_A_ 2 _U_ 22 _N_ _N_ _N_ _N_} _N_ _N_ #-}
+ (<) = { _A_ 2 _U_ 11 _N_ _S_ "U(P)U(P)" {_A_ 2 _U_ 22 _N_ _N_ _F_ _IF_ARGS_ 0 2 XX 1 \ (u0 :: Addr#) (u1 :: Addr#) -> _#_ ltAddr# [] [u0, u1] _N_} _F_ _IF_ARGS_ 0 2 CC 3 \ (u0 :: _Addr) (u1 :: _Addr) -> case u0 of { _ALG_ A# (u2 :: Addr#) -> case u1 of { _ALG_ A# (u3 :: Addr#) -> _#_ ltAddr# [] [u2, u3]; _NO_DEFLT_ }; _NO_DEFLT_ } _N_ },
+ (<=) = { _A_ 2 _U_ 11 _N_ _S_ "U(P)U(P)" {_A_ 2 _U_ 22 _N_ _N_ _F_ _IF_ARGS_ 0 2 XX 1 \ (u0 :: Addr#) (u1 :: Addr#) -> _#_ leAddr# [] [u0, u1] _N_} _F_ _IF_ARGS_ 0 2 CC 3 \ (u0 :: _Addr) (u1 :: _Addr) -> case u0 of { _ALG_ A# (u2 :: Addr#) -> case u1 of { _ALG_ A# (u3 :: Addr#) -> _#_ leAddr# [] [u2, u3]; _NO_DEFLT_ }; _NO_DEFLT_ } _N_ },
+ (>=) = { _A_ 2 _U_ 11 _N_ _S_ "U(P)U(P)" {_A_ 2 _U_ 22 _N_ _N_ _F_ _IF_ARGS_ 0 2 XX 1 \ (u0 :: Addr#) (u1 :: Addr#) -> _#_ geAddr# [] [u0, u1] _N_} _F_ _IF_ARGS_ 0 2 CC 3 \ (u0 :: _Addr) (u1 :: _Addr) -> case u0 of { _ALG_ A# (u2 :: Addr#) -> case u1 of { _ALG_ A# (u3 :: Addr#) -> _#_ geAddr# [] [u2, u3]; _NO_DEFLT_ }; _NO_DEFLT_ } _N_ },
+ (>) = { _A_ 2 _U_ 11 _N_ _S_ "U(P)U(P)" {_A_ 2 _U_ 22 _N_ _N_ _F_ _IF_ARGS_ 0 2 XX 1 \ (u0 :: Addr#) (u1 :: Addr#) -> _#_ gtAddr# [] [u0, u1] _N_} _F_ _IF_ARGS_ 0 2 CC 3 \ (u0 :: _Addr) (u1 :: _Addr) -> case u0 of { _ALG_ A# (u2 :: Addr#) -> case u1 of { _ALG_ A# (u3 :: Addr#) -> _#_ gtAddr# [] [u2, u3]; _NO_DEFLT_ }; _NO_DEFLT_ } _N_ },
+ max = { _A_ 2 _U_ 11 _N_ _S_ "U(P)U(P)" {_A_ 2 _U_ 22 _N_ _N_ _N_ _N_} _N_ _N_ },
+ min = { _A_ 2 _U_ 11 _N_ _S_ "U(P)U(P)" {_A_ 2 _U_ 22 _N_ _N_ _N_ _N_} _N_ _N_ },
+ _tagCmp = { _A_ 2 _U_ 11 _N_ _S_ "U(P)U(P)" {_A_ 2 _U_ 22 _N_ _N_ _N_ _N_} _N_ _N_ } #-}
instance Ord _PackedString
{-# GHC_PRAGMA _M_ PreludePS {-dfun-} _A_ 0 _N_ _N_ _N_ _F_ _IF_ARGS_ 0 0 X 9 _!_ _TUP_8 [{{Eq _PackedString}}, (_PackedString -> _PackedString -> Bool), (_PackedString -> _PackedString -> Bool), (_PackedString -> _PackedString -> Bool), (_PackedString -> _PackedString -> Bool), (_PackedString -> _PackedString -> _PackedString), (_PackedString -> _PackedString -> _PackedString), (_PackedString -> _PackedString -> _CMP_TAG)] [_DFUN_ Eq (_PackedString), _CONSTM_ Ord (<) (_PackedString), _CONSTM_ Ord (<=) (_PackedString), _CONSTM_ Ord (>=) (_PackedString), _CONSTM_ Ord (>) (_PackedString), _CONSTM_ Ord max (_PackedString), _CONSTM_ Ord min (_PackedString), _CONSTM_ Ord _tagCmp (_PackedString)] _N_
- (<) = _A_ 2 _U_ 22 _N_ _S_ "SS" _N_ _N_,
- (<=) = _A_ 2 _U_ 22 _N_ _S_ "SS" _N_ _N_,
- (>=) = _A_ 2 _U_ 22 _N_ _S_ "SS" _N_ _N_,
- (>) = _A_ 2 _U_ 22 _N_ _S_ "SS" _N_ _N_,
- max = _A_ 2 _U_ 22 _N_ _N_ _N_ _N_,
- min = _A_ 2 _U_ 22 _N_ _N_ _N_ _N_,
- _tagCmp = _A_ 2 _U_ 22 _N_ _S_ "SS" _N_ _N_ #-}
+ (<) = { _A_ 2 _U_ 22 _N_ _S_ "SS" _N_ _N_ },
+ (<=) = { _A_ 2 _U_ 22 _N_ _S_ "SS" _N_ _N_ },
+ (>=) = { _A_ 2 _U_ 22 _N_ _S_ "SS" _N_ _N_ },
+ (>) = { _A_ 2 _U_ 22 _N_ _S_ "SS" _N_ _N_ },
+ max = { _A_ 2 _U_ 22 _N_ _S_ "SS" _N_ _N_ },
+ min = { _A_ 2 _U_ 22 _N_ _S_ "SS" _N_ _N_ },
+ _tagCmp = { _A_ 2 _U_ 22 _N_ _S_ "SS" _N_ _N_ } #-}
instance Ord _Word
{-# GHC_PRAGMA _M_ PreludeCore {-dfun-} _A_ 0 _N_ _N_ _N_ _F_ _IF_ARGS_ 0 0 X 9 _!_ _TUP_8 [{{Eq _Word}}, (_Word -> _Word -> Bool), (_Word -> _Word -> Bool), (_Word -> _Word -> Bool), (_Word -> _Word -> Bool), (_Word -> _Word -> _Word), (_Word -> _Word -> _Word), (_Word -> _Word -> _CMP_TAG)] [_DFUN_ Eq (_Word), _CONSTM_ Ord (<) (_Word), _CONSTM_ Ord (<=) (_Word), _CONSTM_ Ord (>=) (_Word), _CONSTM_ Ord (>) (_Word), _CONSTM_ Ord max (_Word), _CONSTM_ Ord min (_Word), _CONSTM_ Ord _tagCmp (_Word)] _N_
- (<) = _A_ 2 _U_ 11 _N_ _S_ "U(P)U(P)" {_A_ 2 _U_ 22 _N_ _N_ _F_ _IF_ARGS_ 0 2 XX 1 \ (u0 :: Word#) (u1 :: Word#) -> _#_ ltWord# [] [u0, u1] _N_} _F_ _IF_ARGS_ 0 2 CC 3 \ (u0 :: _Word) (u1 :: _Word) -> case u0 of { _ALG_ W# (u2 :: Word#) -> case u1 of { _ALG_ W# (u3 :: Word#) -> _#_ ltWord# [] [u2, u3]; _NO_DEFLT_ }; _NO_DEFLT_ } _N_,
- (<=) = _A_ 2 _U_ 11 _N_ _S_ "U(P)U(P)" {_A_ 2 _U_ 22 _N_ _N_ _F_ _IF_ARGS_ 0 2 XX 1 \ (u0 :: Word#) (u1 :: Word#) -> _#_ leWord# [] [u0, u1] _N_} _F_ _IF_ARGS_ 0 2 CC 3 \ (u0 :: _Word) (u1 :: _Word) -> case u0 of { _ALG_ W# (u2 :: Word#) -> case u1 of { _ALG_ W# (u3 :: Word#) -> _#_ leWord# [] [u2, u3]; _NO_DEFLT_ }; _NO_DEFLT_ } _N_,
- (>=) = _A_ 2 _U_ 11 _N_ _S_ "U(P)U(P)" {_A_ 2 _U_ 22 _N_ _N_ _F_ _IF_ARGS_ 0 2 XX 1 \ (u0 :: Word#) (u1 :: Word#) -> _#_ geWord# [] [u0, u1] _N_} _F_ _IF_ARGS_ 0 2 CC 3 \ (u0 :: _Word) (u1 :: _Word) -> case u0 of { _ALG_ W# (u2 :: Word#) -> case u1 of { _ALG_ W# (u3 :: Word#) -> _#_ geWord# [] [u2, u3]; _NO_DEFLT_ }; _NO_DEFLT_ } _N_,
- (>) = _A_ 2 _U_ 11 _N_ _S_ "U(P)U(P)" {_A_ 2 _U_ 22 _N_ _N_ _F_ _IF_ARGS_ 0 2 XX 1 \ (u0 :: Word#) (u1 :: Word#) -> _#_ gtWord# [] [u0, u1] _N_} _F_ _IF_ARGS_ 0 2 CC 3 \ (u0 :: _Word) (u1 :: _Word) -> case u0 of { _ALG_ W# (u2 :: Word#) -> case u1 of { _ALG_ W# (u3 :: Word#) -> _#_ gtWord# [] [u2, u3]; _NO_DEFLT_ }; _NO_DEFLT_ } _N_,
- max = _A_ 2 _U_ 11 _N_ _S_ "U(P)U(P)" {_A_ 2 _U_ 22 _N_ _N_ _N_ _N_} _N_ _N_,
- min = _A_ 2 _U_ 11 _N_ _S_ "U(P)U(P)" {_A_ 2 _U_ 22 _N_ _N_ _N_ _N_} _N_ _N_,
- _tagCmp = _A_ 2 _U_ 11 _N_ _S_ "U(P)U(P)" {_A_ 2 _U_ 22 _N_ _N_ _N_ _N_} _N_ _N_ #-}
+ (<) = { _A_ 2 _U_ 11 _N_ _S_ "U(P)U(P)" {_A_ 2 _U_ 22 _N_ _N_ _F_ _IF_ARGS_ 0 2 XX 1 \ (u0 :: Word#) (u1 :: Word#) -> _#_ ltWord# [] [u0, u1] _N_} _F_ _IF_ARGS_ 0 2 CC 3 \ (u0 :: _Word) (u1 :: _Word) -> case u0 of { _ALG_ W# (u2 :: Word#) -> case u1 of { _ALG_ W# (u3 :: Word#) -> _#_ ltWord# [] [u2, u3]; _NO_DEFLT_ }; _NO_DEFLT_ } _N_ },
+ (<=) = { _A_ 2 _U_ 11 _N_ _S_ "U(P)U(P)" {_A_ 2 _U_ 22 _N_ _N_ _F_ _IF_ARGS_ 0 2 XX 1 \ (u0 :: Word#) (u1 :: Word#) -> _#_ leWord# [] [u0, u1] _N_} _F_ _IF_ARGS_ 0 2 CC 3 \ (u0 :: _Word) (u1 :: _Word) -> case u0 of { _ALG_ W# (u2 :: Word#) -> case u1 of { _ALG_ W# (u3 :: Word#) -> _#_ leWord# [] [u2, u3]; _NO_DEFLT_ }; _NO_DEFLT_ } _N_ },
+ (>=) = { _A_ 2 _U_ 11 _N_ _S_ "U(P)U(P)" {_A_ 2 _U_ 22 _N_ _N_ _F_ _IF_ARGS_ 0 2 XX 1 \ (u0 :: Word#) (u1 :: Word#) -> _#_ geWord# [] [u0, u1] _N_} _F_ _IF_ARGS_ 0 2 CC 3 \ (u0 :: _Word) (u1 :: _Word) -> case u0 of { _ALG_ W# (u2 :: Word#) -> case u1 of { _ALG_ W# (u3 :: Word#) -> _#_ geWord# [] [u2, u3]; _NO_DEFLT_ }; _NO_DEFLT_ } _N_ },
+ (>) = { _A_ 2 _U_ 11 _N_ _S_ "U(P)U(P)" {_A_ 2 _U_ 22 _N_ _N_ _F_ _IF_ARGS_ 0 2 XX 1 \ (u0 :: Word#) (u1 :: Word#) -> _#_ gtWord# [] [u0, u1] _N_} _F_ _IF_ARGS_ 0 2 CC 3 \ (u0 :: _Word) (u1 :: _Word) -> case u0 of { _ALG_ W# (u2 :: Word#) -> case u1 of { _ALG_ W# (u3 :: Word#) -> _#_ gtWord# [] [u2, u3]; _NO_DEFLT_ }; _NO_DEFLT_ } _N_ },
+ max = { _A_ 2 _U_ 11 _N_ _S_ "U(P)U(P)" {_A_ 2 _U_ 22 _N_ _N_ _N_ _N_} _N_ _N_ },
+ min = { _A_ 2 _U_ 11 _N_ _S_ "U(P)U(P)" {_A_ 2 _U_ 22 _N_ _N_ _N_ _N_} _N_ _N_ },
+ _tagCmp = { _A_ 2 _U_ 11 _N_ _S_ "U(P)U(P)" {_A_ 2 _U_ 22 _N_ _N_ _N_ _N_} _N_ _N_ } #-}
instance Real Double
{-# GHC_PRAGMA _M_ PreludeCore {-dfun-} _A_ 0 _N_ _N_ _N_ _F_ _IF_ARGS_ 0 0 X 4 _!_ _TUP_3 [{{Num Double}}, {{Enum Double}}, (Double -> Ratio Integer)] [_DFUN_ Num (Double), _DFUN_ Enum (Double), _CONSTM_ Real toRational (Double)] _N_
- toRational = _A_ 1 _U_ 1 _N_ _S_ "U(P)" {_A_ 1 _U_ 2 _N_ _N_ _N_ _N_} _N_ _N_ #-}
+ toRational = { _A_ 1 _U_ 1 _N_ _S_ "U(P)" {_A_ 1 _U_ 2 _N_ _N_ _N_ _N_} _N_ _N_ } #-}
instance Real Float
{-# GHC_PRAGMA _M_ PreludeCore {-dfun-} _A_ 0 _N_ _N_ _N_ _F_ _IF_ARGS_ 0 0 X 4 _!_ _TUP_3 [{{Num Float}}, {{Enum Float}}, (Float -> Ratio Integer)] [_DFUN_ Num (Float), _DFUN_ Enum (Float), _CONSTM_ Real toRational (Float)] _N_
- toRational = _A_ 1 _U_ 1 _N_ _S_ "U(P)" {_A_ 1 _U_ 2 _N_ _N_ _N_ _N_} _N_ _N_ #-}
+ toRational = { _A_ 1 _U_ 1 _N_ _S_ "U(P)" {_A_ 1 _U_ 2 _N_ _N_ _N_ _N_} _N_ _N_ } #-}
instance Real Int
{-# GHC_PRAGMA _M_ PreludeCore {-dfun-} _A_ 0 _N_ _N_ _N_ _F_ _IF_ARGS_ 0 0 X 4 _!_ _TUP_3 [{{Num Int}}, {{Enum Int}}, (Int -> Ratio Integer)] [_DFUN_ Num (Int), _DFUN_ Enum (Int), _CONSTM_ Real toRational (Int)] _N_
- toRational = _A_ 1 _U_ 1 _N_ _N_ _N_ _N_ #-}
+ toRational = { _A_ 1 _U_ 1 _N_ _N_ _N_ _N_ } #-}
instance Real Integer
{-# GHC_PRAGMA _M_ PreludeCore {-dfun-} _A_ 0 _N_ _N_ _N_ _F_ _IF_ARGS_ 0 0 X 4 _!_ _TUP_3 [{{Num Integer}}, {{Enum Integer}}, (Integer -> Ratio Integer)] [_DFUN_ Num (Integer), _DFUN_ Enum (Integer), _CONSTM_ Real toRational (Integer)] _N_
- toRational = _A_ 1 _U_ 2 _N_ _N_ _N_ _N_ #-}
+ toRational = { _A_ 1 _U_ 2 _N_ _N_ _F_ _IF_ARGS_ 0 1 X 3 \ (u0 :: Integer) -> _!_ (:%) [Integer] [u0, _ORIG_ PreludeCore __integer1] _N_ } #-}
instance Integral a => Real (Ratio a)
{-# GHC_PRAGMA _M_ PreludeRatio {-dfun-} _A_ 3 _U_ 122 _N_ _N_ _N_ _N_ #-}
instance Real (Ratio Integer)
{-# GHC_PRAGMA _M_ PreludeRatio {-dfun-} _A_ 0 _N_ _N_ _N_ _F_ _IF_ARGS_ 0 0 X 4 _!_ _TUP_3 [{{Num (Ratio Integer)}}, {{Enum (Ratio Integer)}}, (Ratio Integer -> Ratio Integer)] [_DFUN_ Num (Ratio Integer), _DFUN_ Enum (Ratio Integer), _CONSTM_ Real toRational (Ratio Integer)] _N_
- toRational = _A_ 1 _U_ 1 _N_ _S_ "U(LL)" {_A_ 2 _U_ 22 _N_ _N_ _F_ _IF_ARGS_ 0 2 XX 3 \ (u0 :: Integer) (u1 :: Integer) -> _!_ (:%) [Integer] [u0, u1] _N_} _F_ _IF_ARGS_ 0 1 X 1 \ (u0 :: Ratio Integer) -> u0 _N_ #-}
+ toRational = { _A_ 1 _U_ 1 _N_ _S_ "U(LL)" {_A_ 2 _U_ 22 _N_ _N_ _F_ _IF_ARGS_ 0 2 XX 3 \ (u0 :: Integer) (u1 :: Integer) -> _!_ (:%) [Integer] [u0, u1] _N_} _F_ _IF_ARGS_ 0 1 X 1 \ (u0 :: Ratio Integer) -> u0 _N_ } #-}
instance RealFloat Double
{-# GHC_PRAGMA _M_ PreludeCore {-dfun-} _A_ 0 _N_ _N_ _N_ _F_ _IF_ARGS_ 0 0 X 11 _!_ _TUP_10 [{{RealFrac Double}}, {{Floating Double}}, (Double -> Integer), (Double -> Int), (Double -> (Int, Int)), (Double -> (Integer, Int)), (Integer -> Int -> Double), (Double -> Int), (Double -> Double), (Int -> Double -> Double)] [_DFUN_ RealFrac (Double), _DFUN_ Floating (Double), _CONSTM_ RealFloat floatRadix (Double), _CONSTM_ RealFloat floatDigits (Double), _CONSTM_ RealFloat floatRange (Double), _CONSTM_ RealFloat decodeFloat (Double), _CONSTM_ RealFloat encodeFloat (Double), _CONSTM_ RealFloat exponent (Double), _CONSTM_ RealFloat significand (Double), _CONSTM_ RealFloat scaleFloat (Double)] _N_
- floatRadix = _A_ 1 _U_ 0 _N_ _S_ "A" {_A_ 0 _N_ _N_ _N_ _F_ _IF_ARGS_ 0 0 X 1 _#_ int2Integer# [] [2#] _N_} _N_ _N_,
- floatDigits = _A_ 1 _U_ 0 _N_ _S_ "A" {_A_ 0 _N_ _N_ _N_ _F_ _IF_ARGS_ 0 0 X 2 _!_ I# [] [53#] _N_} _F_ _IF_ARGS_ 0 1 X 2 \ (u0 :: Double) -> _!_ I# [] [53#] _N_,
- floatRange = _A_ 1 _U_ 0 _N_ _S_ "A" {_A_ 0 _N_ _N_ _N_ _N_ _N_} _N_ _N_,
- decodeFloat = _A_ 1 _U_ 1 _N_ _S_ "U(P)" {_A_ 1 _U_ 2 _N_ _N_ _N_ _N_} _N_ _N_,
- encodeFloat = _A_ 2 _U_ 11 _N_ _S_ "U(PPP)U(P)" {_A_ 4 _U_ 2222 _N_ _N_ _F_ _IF_ARGS_ 0 4 XXXX 3 \ (u0 :: Int#) (u1 :: Int#) (u2 :: ByteArray#) (u3 :: Int#) -> case _#_ encodeDouble# [] [u0, u1, u2, u3] of { _PRIM_ (u4 :: Double#) -> _!_ D# [] [u4] } _N_} _F_ _IF_ARGS_ 0 2 CC 5 \ (u0 :: Integer) (u1 :: Int) -> case u0 of { _ALG_ J# (u2 :: Int#) (u3 :: Int#) (u4 :: ByteArray#) -> case u1 of { _ALG_ I# (u5 :: Int#) -> case _#_ encodeDouble# [] [u2, u3, u4, u5] of { _PRIM_ (u6 :: Double#) -> _!_ D# [] [u6] }; _NO_DEFLT_ }; _NO_DEFLT_ } _N_,
- exponent = _A_ 1 _U_ 2 _N_ _N_ _N_ _N_,
- significand = _A_ 1 _U_ 2 _N_ _N_ _N_ _N_,
- scaleFloat = _A_ 2 _U_ 22 _N_ _N_ _N_ _N_ #-}
+ floatRadix = { _A_ 1 _U_ 0 _N_ _S_ "A" {_A_ 0 _N_ _N_ _N_ _N_ _N_} _N_ _N_ },
+ floatDigits = { _A_ 1 _U_ 0 _N_ _S_ "A" {_A_ 0 _N_ _N_ _N_ _F_ _IF_ARGS_ 0 0 X 2 _!_ I# [] [53#] _N_} _F_ _IF_ARGS_ 0 1 X 2 \ (u0 :: Double) -> _!_ I# [] [53#] _N_ },
+ floatRange = { _A_ 1 _U_ 0 _N_ _S_ "A" {_A_ 0 _N_ _N_ _N_ _N_ _N_} _N_ _N_ },
+ decodeFloat = { _A_ 1 _U_ 1 _N_ _S_ "U(P)" {_A_ 1 _U_ 2 _N_ _N_ _N_ _N_} _N_ _N_ },
+ encodeFloat = { _A_ 2 _U_ 11 _N_ _S_ "U(PPP)U(P)" {_A_ 4 _U_ 2222 _N_ _N_ _F_ _IF_ARGS_ 0 4 XXXX 3 \ (u0 :: Int#) (u1 :: Int#) (u2 :: ByteArray#) (u3 :: Int#) -> case _#_ encodeDouble# [] [u0, u1, u2, u3] of { _PRIM_ (u4 :: Double#) -> _!_ D# [] [u4] } _N_} _F_ _IF_ARGS_ 0 2 CC 5 \ (u0 :: Integer) (u1 :: Int) -> case u0 of { _ALG_ J# (u2 :: Int#) (u3 :: Int#) (u4 :: ByteArray#) -> case u1 of { _ALG_ I# (u5 :: Int#) -> case _#_ encodeDouble# [] [u2, u3, u4, u5] of { _PRIM_ (u6 :: Double#) -> _!_ D# [] [u6] }; _NO_DEFLT_ }; _NO_DEFLT_ } _N_ },
+ exponent = { _A_ 1 _U_ 1 _N_ _S_ "U(P)" {_A_ 1 _U_ 2 _N_ _N_ _N_ _N_} _N_ _N_ },
+ significand = { _A_ 1 _U_ 1 _N_ _S_ "U(P)" {_A_ 1 _U_ 2 _N_ _N_ _N_ _N_} _N_ _N_ },
+ scaleFloat = { _A_ 2 _U_ 11 _N_ _S_ "U(P)U(P)" {_A_ 2 _U_ 22 _N_ _N_ _N_ _N_} _N_ _N_ } #-}
instance RealFloat Float
{-# GHC_PRAGMA _M_ PreludeCore {-dfun-} _A_ 0 _N_ _N_ _N_ _F_ _IF_ARGS_ 0 0 X 11 _!_ _TUP_10 [{{RealFrac Float}}, {{Floating Float}}, (Float -> Integer), (Float -> Int), (Float -> (Int, Int)), (Float -> (Integer, Int)), (Integer -> Int -> Float), (Float -> Int), (Float -> Float), (Int -> Float -> Float)] [_DFUN_ RealFrac (Float), _DFUN_ Floating (Float), _CONSTM_ RealFloat floatRadix (Float), _CONSTM_ RealFloat floatDigits (Float), _CONSTM_ RealFloat floatRange (Float), _CONSTM_ RealFloat decodeFloat (Float), _CONSTM_ RealFloat encodeFloat (Float), _CONSTM_ RealFloat exponent (Float), _CONSTM_ RealFloat significand (Float), _CONSTM_ RealFloat scaleFloat (Float)] _N_
- floatRadix = _A_ 1 _U_ 0 _N_ _S_ "A" {_A_ 0 _N_ _N_ _N_ _F_ _IF_ARGS_ 0 0 X 1 _#_ int2Integer# [] [2#] _N_} _N_ _N_,
- floatDigits = _A_ 1 _U_ 0 _N_ _S_ "A" {_A_ 0 _N_ _N_ _N_ _F_ _IF_ARGS_ 0 0 X 2 _!_ I# [] [24#] _N_} _F_ _IF_ARGS_ 0 1 X 2 \ (u0 :: Float) -> _!_ I# [] [24#] _N_,
- floatRange = _A_ 1 _U_ 0 _N_ _S_ "A" {_A_ 0 _N_ _N_ _N_ _N_ _N_} _N_ _N_,
- decodeFloat = _A_ 1 _U_ 1 _N_ _S_ "U(P)" {_A_ 1 _U_ 2 _N_ _N_ _N_ _N_} _N_ _N_,
- encodeFloat = _A_ 2 _U_ 11 _N_ _S_ "U(PPP)U(P)" {_A_ 4 _U_ 2222 _N_ _N_ _F_ _IF_ARGS_ 0 4 XXXX 3 \ (u0 :: Int#) (u1 :: Int#) (u2 :: ByteArray#) (u3 :: Int#) -> case _#_ encodeFloat# [] [u0, u1, u2, u3] of { _PRIM_ (u4 :: Float#) -> _!_ F# [] [u4] } _N_} _F_ _IF_ARGS_ 0 2 CC 5 \ (u0 :: Integer) (u1 :: Int) -> case u0 of { _ALG_ J# (u2 :: Int#) (u3 :: Int#) (u4 :: ByteArray#) -> case u1 of { _ALG_ I# (u5 :: Int#) -> case _#_ encodeFloat# [] [u2, u3, u4, u5] of { _PRIM_ (u6 :: Float#) -> _!_ F# [] [u6] }; _NO_DEFLT_ }; _NO_DEFLT_ } _N_,
- exponent = _A_ 1 _U_ 2 _N_ _N_ _N_ _N_,
- significand = _A_ 1 _U_ 2 _N_ _N_ _N_ _N_,
- scaleFloat = _A_ 2 _U_ 22 _N_ _N_ _N_ _N_ #-}
+ floatRadix = { _A_ 1 _U_ 0 _N_ _S_ "A" {_A_ 0 _N_ _N_ _N_ _N_ _N_} _N_ _N_ },
+ floatDigits = { _A_ 1 _U_ 0 _N_ _S_ "A" {_A_ 0 _N_ _N_ _N_ _F_ _IF_ARGS_ 0 0 X 2 _!_ I# [] [24#] _N_} _F_ _IF_ARGS_ 0 1 X 2 \ (u0 :: Float) -> _!_ I# [] [24#] _N_ },
+ floatRange = { _A_ 1 _U_ 0 _N_ _S_ "A" {_A_ 0 _N_ _N_ _N_ _N_ _N_} _N_ _N_ },
+ decodeFloat = { _A_ 1 _U_ 1 _N_ _S_ "U(P)" {_A_ 1 _U_ 2 _N_ _N_ _N_ _N_} _N_ _N_ },
+ encodeFloat = { _A_ 2 _U_ 11 _N_ _S_ "U(PPP)U(P)" {_A_ 4 _U_ 2222 _N_ _N_ _F_ _IF_ARGS_ 0 4 XXXX 3 \ (u0 :: Int#) (u1 :: Int#) (u2 :: ByteArray#) (u3 :: Int#) -> case _#_ encodeFloat# [] [u0, u1, u2, u3] of { _PRIM_ (u4 :: Float#) -> _!_ F# [] [u4] } _N_} _F_ _IF_ARGS_ 0 2 CC 5 \ (u0 :: Integer) (u1 :: Int) -> case u0 of { _ALG_ J# (u2 :: Int#) (u3 :: Int#) (u4 :: ByteArray#) -> case u1 of { _ALG_ I# (u5 :: Int#) -> case _#_ encodeFloat# [] [u2, u3, u4, u5] of { _PRIM_ (u6 :: Float#) -> _!_ F# [] [u6] }; _NO_DEFLT_ }; _NO_DEFLT_ } _N_ },
+ exponent = { _A_ 1 _U_ 1 _N_ _S_ "U(P)" {_A_ 1 _U_ 2 _N_ _N_ _N_ _N_} _N_ _N_ },
+ significand = { _A_ 1 _U_ 1 _N_ _S_ "U(P)" {_A_ 1 _U_ 2 _N_ _N_ _N_ _N_} _N_ _N_ },
+ scaleFloat = { _A_ 2 _U_ 11 _N_ _S_ "U(P)U(P)" {_A_ 2 _U_ 22 _N_ _N_ _N_ _N_} _N_ _N_ } #-}
instance RealFrac Double
{-# GHC_PRAGMA _M_ PreludeCore {-dfun-} _A_ 0 _N_ _N_ _N_ _F_ _IF_ARGS_ 0 0 X 8 _!_ _TUP_7 [{{Real Double}}, {{Fractional Double}}, _forall_ a$z1 =>{{Integral a$z1}} -> (Double -> (a$z1, Double)), _forall_ a$z1 =>{{Integral a$z1}} -> (Double -> a$z1), _forall_ a$z1 =>{{Integral a$z1}} -> (Double -> a$z1), _forall_ a$z1 =>{{Integral a$z1}} -> (Double -> a$z1), _forall_ a$z1 =>{{Integral a$z1}} -> (Double -> a$z1)] [_DFUN_ Real (Double), _DFUN_ Fractional (Double), _CONSTM_ RealFrac properFraction (Double), _CONSTM_ RealFrac truncate (Double), _CONSTM_ RealFrac round (Double), _CONSTM_ RealFrac ceiling (Double), _CONSTM_ RealFrac floor (Double)] _N_
- properFraction = _A_ 1 _U_ 22 _N_ _N_ _N_ _N_,
- truncate = _A_ 1 _U_ 22 _N_ _N_ _N_ _N_,
- round = _A_ 1 _U_ 22 _N_ _N_ _N_ _N_,
- ceiling = _A_ 1 _U_ 22 _N_ _N_ _N_ _N_,
- floor = _A_ 1 _U_ 22 _N_ _N_ _N_ _N_ #-}
+ properFraction = { _A_ 1 _U_ 11 _N_ _N_ _N_ _SPECIALISE_ [ Int ] 1 { _A_ 1 _U_ 1 _N_ _S_ "U(P)" {_A_ 1 _U_ 2 _N_ _N_ _N_ _N_} _N_ _N_ }, [ Integer ] 1 { _A_ 1 _U_ 1 _N_ _S_ "U(P)" {_A_ 1 _U_ 2 _N_ _N_ _N_ _N_} _N_ _N_ } },
+ truncate = { _A_ 1 _U_ 11 _N_ _N_ _N_ _SPECIALISE_ [ Int ] 1 { _A_ 1 _U_ 1 _N_ _S_ "U(P)" {_A_ 1 _U_ 2 _N_ _N_ _F_ _IF_ARGS_ 0 1 X 4 \ (u0 :: Double#) -> case _APP_ _WRKR_ _SPEC_ _CONSTM_ RealFrac properFraction (Double) [ (Int) ] [ u0 ] of { _ALG_ _TUP_2 (u1 :: Int) (u2 :: Double) -> u1; _NO_DEFLT_ } _N_} _F_ _IF_ARGS_ 0 1 X 4 \ (u0 :: Double) -> case _APP_ _SPEC_ _CONSTM_ RealFrac properFraction (Double) [ (Int) ] [ u0 ] of { _ALG_ _TUP_2 (u1 :: Int) (u2 :: Double) -> u1; _NO_DEFLT_ } _N_ }, [ Integer ] 1 { _A_ 1 _U_ 1 _N_ _S_ "U(P)" {_A_ 1 _U_ 2 _N_ _N_ _F_ _IF_ARGS_ 0 1 X 4 \ (u0 :: Double#) -> case _APP_ _WRKR_ _SPEC_ _CONSTM_ RealFrac properFraction (Double) [ (Integer) ] [ u0 ] of { _ALG_ _TUP_2 (u1 :: Integer) (u2 :: Double) -> u1; _NO_DEFLT_ } _N_} _F_ _IF_ARGS_ 0 1 X 4 \ (u0 :: Double) -> case _APP_ _SPEC_ _CONSTM_ RealFrac properFraction (Double) [ (Integer) ] [ u0 ] of { _ALG_ _TUP_2 (u1 :: Integer) (u2 :: Double) -> u1; _NO_DEFLT_ } _N_ } },
+ round = { _A_ 1 _U_ 21 _N_ _N_ _N_ _SPECIALISE_ [ Int ] 1 { _A_ 1 _U_ 1 _N_ _S_ "U(P)" {_A_ 1 _U_ 2 _N_ _N_ _N_ _N_} _N_ _N_ }, [ Integer ] 1 { _A_ 1 _U_ 1 _N_ _S_ "U(P)" {_A_ 1 _U_ 2 _N_ _N_ _N_ _N_} _N_ _N_ } },
+ ceiling = { _A_ 1 _U_ 21 _N_ _N_ _N_ _SPECIALISE_ [ Int ] 1 { _A_ 1 _U_ 1 _N_ _S_ "U(P)" {_A_ 1 _U_ 2 _N_ _N_ _N_ _N_} _N_ _N_ }, [ Integer ] 1 { _A_ 1 _U_ 1 _N_ _S_ "U(P)" {_A_ 1 _U_ 2 _N_ _N_ _N_ _N_} _N_ _N_ } },
+ floor = { _A_ 1 _U_ 21 _N_ _N_ _N_ _SPECIALISE_ [ Int ] 1 { _A_ 1 _U_ 1 _N_ _S_ "U(P)" {_A_ 1 _U_ 2 _N_ _N_ _N_ _N_} _N_ _N_ }, [ Integer ] 1 { _A_ 1 _U_ 1 _N_ _S_ "U(P)" {_A_ 1 _U_ 2 _N_ _N_ _N_ _N_} _N_ _N_ } } #-}
instance RealFrac Float
{-# GHC_PRAGMA _M_ PreludeCore {-dfun-} _A_ 0 _N_ _N_ _N_ _F_ _IF_ARGS_ 0 0 X 8 _!_ _TUP_7 [{{Real Float}}, {{Fractional Float}}, _forall_ a$z1 =>{{Integral a$z1}} -> (Float -> (a$z1, Float)), _forall_ a$z1 =>{{Integral a$z1}} -> (Float -> a$z1), _forall_ a$z1 =>{{Integral a$z1}} -> (Float -> a$z1), _forall_ a$z1 =>{{Integral a$z1}} -> (Float -> a$z1), _forall_ a$z1 =>{{Integral a$z1}} -> (Float -> a$z1)] [_DFUN_ Real (Float), _DFUN_ Fractional (Float), _CONSTM_ RealFrac properFraction (Float), _CONSTM_ RealFrac truncate (Float), _CONSTM_ RealFrac round (Float), _CONSTM_ RealFrac ceiling (Float), _CONSTM_ RealFrac floor (Float)] _N_
- properFraction = _A_ 1 _U_ 22 _N_ _N_ _N_ _N_,
- truncate = _A_ 1 _U_ 22 _N_ _N_ _N_ _N_,
- round = _A_ 1 _U_ 22 _N_ _N_ _N_ _N_,
- ceiling = _A_ 1 _U_ 22 _N_ _N_ _N_ _N_,
- floor = _A_ 1 _U_ 22 _N_ _N_ _N_ _N_ #-}
-instance Integral a => RealFrac (Ratio a)
- {-# GHC_PRAGMA _M_ PreludeRatio {-dfun-} _A_ 3 _U_ 222 _N_ _N_ _N_ _N_ #-}
+ properFraction = { _A_ 1 _U_ 11 _N_ _N_ _N_ _SPECIALISE_ [ Int ] 1 { _A_ 1 _U_ 1 _N_ _S_ "U(P)" {_A_ 1 _U_ 2 _N_ _N_ _N_ _N_} _N_ _N_ }, [ Integer ] 1 { _A_ 1 _U_ 1 _N_ _S_ "U(P)" {_A_ 1 _U_ 2 _N_ _N_ _N_ _N_} _N_ _N_ } },
+ truncate = { _A_ 1 _U_ 11 _N_ _N_ _N_ _SPECIALISE_ [ Int ] 1 { _A_ 1 _U_ 1 _N_ _S_ "U(P)" {_A_ 1 _U_ 2 _N_ _N_ _F_ _IF_ARGS_ 0 1 X 4 \ (u0 :: Float#) -> case _APP_ _WRKR_ _SPEC_ _CONSTM_ RealFrac properFraction (Float) [ (Int) ] [ u0 ] of { _ALG_ _TUP_2 (u1 :: Int) (u2 :: Float) -> u1; _NO_DEFLT_ } _N_} _F_ _IF_ARGS_ 0 1 X 4 \ (u0 :: Float) -> case _APP_ _SPEC_ _CONSTM_ RealFrac properFraction (Float) [ (Int) ] [ u0 ] of { _ALG_ _TUP_2 (u1 :: Int) (u2 :: Float) -> u1; _NO_DEFLT_ } _N_ }, [ Integer ] 1 { _A_ 1 _U_ 1 _N_ _S_ "U(P)" {_A_ 1 _U_ 2 _N_ _N_ _F_ _IF_ARGS_ 0 1 X 4 \ (u0 :: Float#) -> case _APP_ _WRKR_ _SPEC_ _CONSTM_ RealFrac properFraction (Float) [ (Integer) ] [ u0 ] of { _ALG_ _TUP_2 (u1 :: Integer) (u2 :: Float) -> u1; _NO_DEFLT_ } _N_} _F_ _IF_ARGS_ 0 1 X 4 \ (u0 :: Float) -> case _APP_ _SPEC_ _CONSTM_ RealFrac properFraction (Float) [ (Integer) ] [ u0 ] of { _ALG_ _TUP_2 (u1 :: Integer) (u2 :: Float) -> u1; _NO_DEFLT_ } _N_ } },
+ round = { _A_ 1 _U_ 21 _N_ _N_ _N_ _SPECIALISE_ [ Int ] 1 { _A_ 1 _U_ 1 _N_ _S_ "U(P)" {_A_ 1 _U_ 2 _N_ _N_ _N_ _N_} _N_ _N_ }, [ Integer ] 1 { _A_ 1 _U_ 1 _N_ _S_ "U(P)" {_A_ 1 _U_ 2 _N_ _N_ _N_ _N_} _N_ _N_ } },
+ ceiling = { _A_ 1 _U_ 21 _N_ _N_ _N_ _SPECIALISE_ [ Int ] 1 { _A_ 1 _U_ 1 _N_ _S_ "U(P)" {_A_ 1 _U_ 2 _N_ _N_ _N_ _N_} _N_ _N_ }, [ Integer ] 1 { _A_ 1 _U_ 1 _N_ _S_ "U(P)" {_A_ 1 _U_ 2 _N_ _N_ _N_ _N_} _N_ _N_ } },
+ floor = { _A_ 1 _U_ 21 _N_ _N_ _N_ _SPECIALISE_ [ Int ] 1 { _A_ 1 _U_ 1 _N_ _S_ "U(P)" {_A_ 1 _U_ 2 _N_ _N_ _N_ _N_} _N_ _N_ }, [ Integer ] 1 { _A_ 1 _U_ 1 _N_ _S_ "U(P)" {_A_ 1 _U_ 2 _N_ _N_ _N_ _N_} _N_ _N_ } } #-}
instance RealFrac (Ratio Integer)
{-# GHC_PRAGMA _M_ PreludeRatio {-dfun-} _A_ 0 _N_ _N_ _N_ _F_ _IF_ARGS_ 0 0 X 8 _!_ _TUP_7 [{{Real (Ratio Integer)}}, {{Fractional (Ratio Integer)}}, _forall_ a$z1 =>{{Integral a$z1}} -> (Ratio Integer -> (a$z1, Ratio Integer)), _forall_ a$z1 =>{{Integral a$z1}} -> (Ratio Integer -> a$z1), _forall_ a$z1 =>{{Integral a$z1}} -> (Ratio Integer -> a$z1), _forall_ a$z1 =>{{Integral a$z1}} -> (Ratio Integer -> a$z1), _forall_ a$z1 =>{{Integral a$z1}} -> (Ratio Integer -> a$z1)] [_DFUN_ Real (Ratio Integer), _DFUN_ Fractional (Ratio Integer), _CONSTM_ RealFrac properFraction (Ratio Integer), _CONSTM_ RealFrac truncate (Ratio Integer), _CONSTM_ RealFrac round (Ratio Integer), _CONSTM_ RealFrac ceiling (Ratio Integer), _CONSTM_ RealFrac floor (Ratio Integer)] _N_
- properFraction = _A_ 2 _U_ 11 _N_ _S_ "LU(LL)" {_A_ 3 _U_ 112 _N_ _N_ _N_ _N_} _N_ _N_,
- truncate = _A_ 1 _U_ 22 _N_ _N_ _F_ _IF_ARGS_ 1 1 X 3 _/\_ u0 -> \ (u1 :: {{Integral u0}}) -> _APP_ _TYAPP_ _TYAPP_ _WRKR_ _ORIG_ PreludeCore _truncate { (Ratio Integer) } { u0 } [ _CONSTM_ RealFrac properFraction (Ratio Integer), u1 ] _N_,
- round = _A_ 1 _U_ 22 _N_ _N_ _N_ _N_,
- ceiling = _A_ 1 _U_ 22 _N_ _N_ _N_ _N_,
- floor = _A_ 1 _U_ 22 _N_ _N_ _N_ _N_ #-}
+ properFraction = { _A_ 2 _U_ 11 _N_ _S_ "LU(U(PPP)U(PPP))" {_A_ 5 _U_ 12222 _N_ _N_ _N_ _N_} _N_ _SPECIALISE_ [ Int ] 1 { _A_ 1 _U_ 1 _N_ _S_ "U(U(PPP)U(PPP))" {_A_ 4 _U_ 2222 _N_ _N_ _N_ _N_} _N_ _N_ }, [ Integer ] 1 { _A_ 1 _U_ 1 _N_ _S_ "U(U(PPP)U(PPP))" {_A_ 4 _U_ 2222 _N_ _N_ _N_ _N_} _N_ _N_ } },
+ truncate = { _A_ 2 _U_ 11 _N_ _N_ _N_ _SPECIALISE_ [ Int ] 1 { _A_ 1 _U_ 1 _N_ _S_ "U(U(PPP)U(PPP))" {_A_ 4 _U_ 2222 _N_ _N_ _F_ _IF_ARGS_ 0 4 XXXX 7 \ (u0 :: Int#) (u1 :: Int#) (u2 :: ByteArray#) (u3 :: Integer) -> case _APP_ _WRKR_ _SPEC_ _CONSTM_ RealFrac properFraction (Ratio Integer) [ (Int) ] [ u0, u1, u2, u3 ] of { _ALG_ _TUP_2 (u4 :: Int) (u5 :: Ratio Integer) -> u4; _NO_DEFLT_ } _N_} _F_ _IF_ARGS_ 0 1 X 4 \ (u0 :: Ratio Integer) -> case _APP_ _SPEC_ _CONSTM_ RealFrac properFraction (Ratio Integer) [ (Int) ] [ u0 ] of { _ALG_ _TUP_2 (u1 :: Int) (u2 :: Ratio Integer) -> u1; _NO_DEFLT_ } _N_ }, [ Integer ] 1 { _A_ 1 _U_ 1 _N_ _S_ "U(U(PPP)U(PPP))" {_A_ 4 _U_ 2222 _N_ _N_ _F_ _IF_ARGS_ 0 4 XXXX 7 \ (u0 :: Int#) (u1 :: Int#) (u2 :: ByteArray#) (u3 :: Integer) -> case _APP_ _WRKR_ _SPEC_ _CONSTM_ RealFrac properFraction (Ratio Integer) [ (Integer) ] [ u0, u1, u2, u3 ] of { _ALG_ _TUP_2 (u4 :: Integer) (u5 :: Ratio Integer) -> u4; _NO_DEFLT_ } _N_} _F_ _IF_ARGS_ 0 1 X 4 \ (u0 :: Ratio Integer) -> case _APP_ _SPEC_ _CONSTM_ RealFrac properFraction (Ratio Integer) [ (Integer) ] [ u0 ] of { _ALG_ _TUP_2 (u1 :: Integer) (u2 :: Ratio Integer) -> u1; _NO_DEFLT_ } _N_ } },
+ round = { _A_ 1 _U_ 21 _N_ _N_ _N_ _SPECIALISE_ [ Int ] 1 { _A_ 1 _U_ 1 _N_ _S_ "U(U(PPP)U(PPP))" {_A_ 4 _U_ 2222 _N_ _N_ _N_ _N_} _N_ _N_ }, [ Integer ] 1 { _A_ 1 _U_ 1 _N_ _S_ "U(U(PPP)U(PPP))" {_A_ 4 _U_ 2222 _N_ _N_ _N_ _N_} _N_ _N_ } },
+ ceiling = { _A_ 1 _U_ 21 _N_ _N_ _N_ _SPECIALISE_ [ Int ] 1 { _A_ 1 _U_ 1 _N_ _S_ "U(U(PPP)U(PPP))" {_A_ 4 _U_ 2222 _N_ _N_ _N_ _N_} _N_ _N_ }, [ Integer ] 1 { _A_ 1 _U_ 1 _N_ _S_ "U(U(PPP)U(PPP))" {_A_ 4 _U_ 2222 _N_ _N_ _N_ _N_} _N_ _N_ } },
+ floor = { _A_ 1 _U_ 21 _N_ _N_ _N_ _SPECIALISE_ [ Int ] 1 { _A_ 1 _U_ 1 _N_ _S_ "U(U(PPP)U(PPP))" {_A_ 4 _U_ 2222 _N_ _N_ _N_ _N_} _N_ _N_ }, [ Integer ] 1 { _A_ 1 _U_ 1 _N_ _S_ "U(U(PPP)U(PPP))" {_A_ 4 _U_ 2222 _N_ _N_ _N_ _N_} _N_ _N_ } } #-}
+instance Text ((Int, Int), (Int, Int))
+ {-# GHC_PRAGMA _M_ PreludeBuiltin {-dfun-} _A_ 0 _N_ _N_ _N_ _F_ _IF_ARGS_ 0 0 X 5 _!_ _TUP_4 [(Int -> [Char] -> [(((Int, Int), (Int, Int)), [Char])]), (Int -> ((Int, Int), (Int, Int)) -> [Char] -> [Char]), ([Char] -> [([((Int, Int), (Int, Int))], [Char])]), ([((Int, Int), (Int, Int))] -> [Char] -> [Char])] [_CONSTM_ Text readsPrec (((Int, Int), (Int, Int))), _CONSTM_ Text showsPrec (((Int, Int), (Int, Int))), _CONSTM_ Text readList (((Int, Int), (Int, Int))), _CONSTM_ Text showList (((Int, Int), (Int, Int)))] _N_
+ readsPrec = { _A_ 1 _U_ 02 _N_ _S_ "A" {_A_ 0 _U_ 2 _N_ _N_ _N_ _N_} _N_ _N_ },
+ showsPrec = { _A_ 3 _U_ 012 _N_ _S_ "AU(LL)L" {_A_ 3 _U_ 112 _N_ _N_ _N_ _N_} _N_ _N_ },
+ readList = { _A_ 0 _U_ 2 _N_ _N_ _N_ _N_ },
+ showList = { _A_ 1 _U_ 12 _N_ _N_ _N_ _N_ } #-}
instance Text ()
{-# GHC_PRAGMA _M_ PreludeBuiltin {-dfun-} _A_ 0 _N_ _N_ _N_ _F_ _IF_ARGS_ 0 0 X 5 _!_ _TUP_4 [(Int -> [Char] -> [((), [Char])]), (Int -> () -> [Char] -> [Char]), ([Char] -> [([()], [Char])]), ([()] -> [Char] -> [Char])] [_CONSTM_ Text readsPrec (()), _CONSTM_ Text showsPrec (()), _CONSTM_ Text readList (()), _CONSTM_ Text showList (())] _N_
- readsPrec = _A_ 1 _U_ 02 _N_ _S_ "A" {_A_ 0 _U_ 2 _N_ _N_ _N_ _N_} _N_ _N_,
- showsPrec = _A_ 3 _U_ 012 _N_ _S_ "AEL" {_A_ 2 _U_ 12 _N_ _N_ _F_ _IF_ARGS_ 0 2 CX 4 \ (u0 :: ()) (u1 :: [Char]) -> case u0 of { _ALG_ _TUP_0 -> _APP_ _TYAPP_ _ORIG_ PreludeList (++) { Char } [ _NOREP_S_ "()", u1 ]; _NO_DEFLT_ } _N_} _F_ _IF_ARGS_ 0 3 XCX 4 \ (u0 :: Int) (u1 :: ()) (u2 :: [Char]) -> case u1 of { _ALG_ _TUP_0 -> _APP_ _TYAPP_ _ORIG_ PreludeList (++) { Char } [ _NOREP_S_ "()", u2 ]; _NO_DEFLT_ } _N_,
- readList = _A_ 0 _U_ 2 _N_ _N_ _N_ _N_,
- showList = _A_ 0 _U_ 12 _N_ _N_ _N_ _N_ #-}
+ readsPrec = { _A_ 1 _U_ 02 _N_ _S_ "A" {_A_ 0 _U_ 2 _N_ _N_ _N_ _N_} _N_ _N_ },
+ showsPrec = { _A_ 3 _U_ 012 _N_ _S_ "AEL" {_A_ 2 _U_ 12 _N_ _N_ _F_ _IF_ARGS_ 0 2 CX 4 \ (u0 :: ()) (u1 :: [Char]) -> case u0 of { _ALG_ _TUP_0 -> _APP_ _TYAPP_ _ORIG_ PreludeList (++) { Char } [ _NOREP_S_ "()", u1 ]; _NO_DEFLT_ } _N_} _F_ _IF_ARGS_ 0 3 XCX 4 \ (u0 :: Int) (u1 :: ()) (u2 :: [Char]) -> case u1 of { _ALG_ _TUP_0 -> _APP_ _TYAPP_ _ORIG_ PreludeList (++) { Char } [ _NOREP_S_ "()", u2 ]; _NO_DEFLT_ } _N_ },
+ readList = { _A_ 0 _U_ 2 _N_ _N_ _N_ _N_ },
+ showList = { _A_ 1 _U_ 12 _N_ _N_ _N_ _N_ } #-}
instance (Text a, Text b) => Text (a, b)
{-# GHC_PRAGMA _M_ PreludeBuiltin {-dfun-} _A_ 2 _U_ 22 _N_ _N_ _N_ _N_ #-}
instance (Text a, Text b, Text c) => Text (a, b, c)
{-# GHC_PRAGMA _M_ PreludeBuiltin {-dfun-} _A_ 5 _U_ 22222 _N_ _N_ _N_ _N_ #-}
instance Text (Int, Int)
{-# GHC_PRAGMA _M_ PreludeBuiltin {-dfun-} _A_ 0 _N_ _N_ _N_ _F_ _IF_ARGS_ 0 0 X 5 _!_ _TUP_4 [(Int -> [Char] -> [((Int, Int), [Char])]), (Int -> (Int, Int) -> [Char] -> [Char]), ([Char] -> [([(Int, Int)], [Char])]), ([(Int, Int)] -> [Char] -> [Char])] [_CONSTM_ Text readsPrec ((Int, Int)), _CONSTM_ Text showsPrec ((Int, Int)), _CONSTM_ Text readList ((Int, Int)), _CONSTM_ Text showList ((Int, Int))] _N_
- readsPrec = _A_ 1 _U_ 02 _N_ _S_ "A" {_A_ 0 _U_ 2 _N_ _N_ _N_ _N_} _N_ _N_,
- showsPrec = _A_ 3 _U_ 012 _N_ _S_ "AU(LL)L" {_A_ 3 _U_ 112 _N_ _N_ _N_ _N_} _N_ _N_,
- readList = _A_ 0 _U_ 2 _N_ _N_ _N_ _N_,
- showList = _A_ 0 _U_ 12 _N_ _N_ _N_ _N_ #-}
+ readsPrec = { _A_ 1 _U_ 02 _N_ _S_ "A" {_A_ 0 _U_ 2 _N_ _N_ _N_ _N_} _N_ _N_ },
+ showsPrec = { _A_ 3 _U_ 012 _N_ _S_ "AU(LL)L" {_A_ 3 _U_ 112 _N_ _N_ _N_ _N_} _N_ _N_ },
+ readList = { _A_ 0 _U_ 2 _N_ _N_ _N_ _N_ },
+ showList = { _A_ 1 _U_ 12 _N_ _N_ _N_ _N_ } #-}
+instance Text (Int, Int, Int)
+ {-# GHC_PRAGMA _M_ PreludeBuiltin {-dfun-} _A_ 0 _N_ _N_ _N_ _F_ _IF_ARGS_ 0 0 X 5 _!_ _TUP_4 [(Int -> [Char] -> [((Int, Int, Int), [Char])]), (Int -> (Int, Int, Int) -> [Char] -> [Char]), ([Char] -> [([(Int, Int, Int)], [Char])]), ([(Int, Int, Int)] -> [Char] -> [Char])] [_CONSTM_ Text readsPrec ((Int, Int, Int)), _CONSTM_ Text showsPrec ((Int, Int, Int)), _CONSTM_ Text readList ((Int, Int, Int)), _CONSTM_ Text showList ((Int, Int, Int))] _N_
+ readsPrec = { _A_ 1 _U_ 02 _N_ _S_ "A" {_A_ 0 _U_ 2 _N_ _N_ _N_ _N_} _N_ _N_ },
+ showsPrec = { _A_ 3 _U_ 012 _N_ _S_ "AU(LLL)L" {_A_ 4 _U_ 1112 _N_ _N_ _N_ _N_} _N_ _N_ },
+ readList = { _A_ 0 _U_ 2 _N_ _N_ _N_ _N_ },
+ showList = { _A_ 1 _U_ 12 _N_ _N_ _N_ _N_ } #-}
instance Text (Integer, Integer)
{-# GHC_PRAGMA _M_ PreludeBuiltin {-dfun-} _A_ 0 _N_ _N_ _N_ _F_ _IF_ARGS_ 0 0 X 5 _!_ _TUP_4 [(Int -> [Char] -> [((Integer, Integer), [Char])]), (Int -> (Integer, Integer) -> [Char] -> [Char]), ([Char] -> [([(Integer, Integer)], [Char])]), ([(Integer, Integer)] -> [Char] -> [Char])] [_CONSTM_ Text readsPrec ((Integer, Integer)), _CONSTM_ Text showsPrec ((Integer, Integer)), _CONSTM_ Text readList ((Integer, Integer)), _CONSTM_ Text showList ((Integer, Integer))] _N_
- readsPrec = _A_ 1 _U_ 02 _N_ _S_ "A" {_A_ 0 _U_ 2 _N_ _N_ _N_ _N_} _N_ _N_,
- showsPrec = _A_ 3 _U_ 012 _N_ _S_ "AU(LL)L" {_A_ 3 _U_ 112 _N_ _N_ _N_ _N_} _N_ _N_,
- readList = _A_ 0 _U_ 2 _N_ _N_ _N_ _N_,
- showList = _A_ 0 _U_ 12 _N_ _N_ _N_ _N_ #-}
+ readsPrec = { _A_ 1 _U_ 02 _N_ _S_ "A" {_A_ 0 _U_ 2 _N_ _N_ _N_ _N_} _N_ _N_ },
+ showsPrec = { _A_ 3 _U_ 012 _N_ _S_ "AU(LL)L" {_A_ 3 _U_ 112 _N_ _N_ _N_ _N_} _N_ _N_ },
+ readList = { _A_ 0 _U_ 2 _N_ _N_ _N_ _N_ },
+ showList = { _A_ 1 _U_ 12 _N_ _N_ _N_ _N_ } #-}
instance Text (a -> b)
{-# GHC_PRAGMA _M_ PreludeCore {-dfun-} _A_ 0 _N_ _N_ _N_ _N_ _N_ #-}
+instance Text (Array (Int, Int) Double)
+ {-# GHC_PRAGMA _M_ PreludeArray {-dfun-} _A_ 0 _N_ _N_ _N_ _F_ _IF_ARGS_ 0 0 X 5 _!_ _TUP_4 [(Int -> [Char] -> [(Array (Int, Int) Double, [Char])]), (Int -> Array (Int, Int) Double -> [Char] -> [Char]), ([Char] -> [([Array (Int, Int) Double], [Char])]), ([Array (Int, Int) Double] -> [Char] -> [Char])] [_CONSTM_ Text readsPrec (Array (Int, Int) Double), _CONSTM_ Text showsPrec (Array (Int, Int) Double), _CONSTM_ Text readList (Array (Int, Int) Double), _CONSTM_ Text showList (Array (Int, Int) Double)] _N_
+ readsPrec = { _A_ 1 _U_ 12 _N_ _S_ "U(P)" {_A_ 1 _U_ 22 _N_ _N_ _N_ _N_} _N_ _N_ },
+ showsPrec = { _A_ 2 _U_ 122 _N_ _N_ _N_ _N_ },
+ readList = { _A_ 0 _U_ 2 _N_ _N_ _N_ _N_ },
+ showList = { _A_ 0 _U_ 12 _N_ _N_ _N_ _N_ } #-}
instance (Ix a, Text a, Text b) => Text (Array a b)
{-# GHC_PRAGMA _M_ PreludeArray {-dfun-} _A_ 3 _U_ 222 _N_ _N_ _N_ _N_ #-}
+instance Text (Array Int Double)
+ {-# GHC_PRAGMA _M_ PreludeArray {-dfun-} _A_ 0 _N_ _N_ _N_ _F_ _IF_ARGS_ 0 0 X 5 _!_ _TUP_4 [(Int -> [Char] -> [(Array Int Double, [Char])]), (Int -> Array Int Double -> [Char] -> [Char]), ([Char] -> [([Array Int Double], [Char])]), ([Array Int Double] -> [Char] -> [Char])] [_CONSTM_ Text readsPrec (Array Int Double), _CONSTM_ Text showsPrec (Array Int Double), _CONSTM_ Text readList (Array Int Double), _CONSTM_ Text showList (Array Int Double)] _N_
+ readsPrec = { _A_ 1 _U_ 12 _N_ _S_ "U(P)" {_A_ 1 _U_ 22 _N_ _N_ _N_ _N_} _N_ _N_ },
+ showsPrec = { _A_ 2 _U_ 122 _N_ _N_ _N_ _N_ },
+ readList = { _A_ 0 _U_ 2 _N_ _N_ _N_ _N_ },
+ showList = { _A_ 0 _U_ 12 _N_ _N_ _N_ _N_ } #-}
instance (Text a, Text b) => Text (Assoc a b)
{-# GHC_PRAGMA _M_ PreludeArray {-dfun-} _A_ 2 _U_ 22 _N_ _N_ _N_ _N_ #-}
instance Text Bool
{-# GHC_PRAGMA _M_ PreludeCore {-dfun-} _A_ 0 _N_ _N_ _N_ _F_ _IF_ARGS_ 0 0 X 5 _!_ _TUP_4 [(Int -> [Char] -> [(Bool, [Char])]), (Int -> Bool -> [Char] -> [Char]), ([Char] -> [([Bool], [Char])]), ([Bool] -> [Char] -> [Char])] [_CONSTM_ Text readsPrec (Bool), _CONSTM_ Text showsPrec (Bool), _CONSTM_ Text readList (Bool), _CONSTM_ Text showList (Bool)] _N_
- readsPrec = _A_ 2 _U_ 02 _N_ _S_ "AL" {_A_ 1 _U_ 2 _N_ _N_ _N_ _N_} _N_ _N_,
- showsPrec = _A_ 3 _U_ 012 _N_ _S_ "AEL" {_A_ 2 _U_ 12 _N_ _N_ _N_ _N_} _N_ _N_,
- readList = _A_ 0 _U_ 2 _N_ _N_ _N_ _N_,
- showList = _A_ 0 _U_ 12 _N_ _N_ _N_ _N_ #-}
+ readsPrec = { _A_ 2 _U_ 02 _N_ _S_ "AL" {_A_ 1 _U_ 2 _N_ _N_ _N_ _N_} _N_ _N_ },
+ showsPrec = { _A_ 3 _U_ 012 _N_ _S_ "AEL" {_A_ 2 _U_ 12 _N_ _N_ _N_ _N_} _N_ _N_ },
+ readList = { _A_ 0 _U_ 2 _N_ _N_ _N_ _N_ },
+ showList = { _A_ 1 _U_ 12 _N_ _N_ _F_ _IF_ARGS_ 0 1 X 3 \ (u0 :: [Bool]) -> _APP_ _TYAPP_ _ORIG_ PreludeCore _showList { Bool } [ _WRKR_ _CONSTM_ Text showsPrec (Bool), u0 ] _N_ } #-}
instance Text Char
{-# GHC_PRAGMA _M_ PreludeCore {-dfun-} _A_ 0 _N_ _N_ _N_ _F_ _IF_ARGS_ 0 0 X 5 _!_ _TUP_4 [(Int -> [Char] -> [(Char, [Char])]), (Int -> Char -> [Char] -> [Char]), ([Char] -> [([Char], [Char])]), ([Char] -> [Char] -> [Char])] [_CONSTM_ Text readsPrec (Char), _CONSTM_ Text showsPrec (Char), _CONSTM_ Text readList (Char), _CONSTM_ Text showList (Char)] _N_
- readsPrec = _A_ 1 _U_ 02 _N_ _S_ "A" {_A_ 0 _U_ 2 _N_ _N_ _N_ _N_} _N_ _N_,
- showsPrec = _A_ 3 _U_ 012 _N_ _S_ "AU(P)L" {_A_ 2 _U_ 22 _N_ _N_ _N_ _N_} _N_ _N_,
- readList = _A_ 0 _U_ 2 _N_ _N_ _N_ _N_,
- showList = _A_ 1 _U_ 22 _N_ _N_ _N_ _N_ #-}
+ readsPrec = { _A_ 1 _U_ 02 _N_ _S_ "A" {_A_ 0 _U_ 2 _N_ _N_ _N_ _N_} _N_ _N_ },
+ showsPrec = { _A_ 3 _U_ 012 _N_ _S_ "AU(P)L" {_A_ 2 _U_ 22 _N_ _N_ _N_ _N_} _N_ _N_ },
+ readList = { _A_ 0 _U_ 2 _N_ _N_ _N_ _N_ },
+ showList = { _A_ 1 _U_ 22 _N_ _N_ _N_ _N_ } #-}
instance Text a => Text (Complex a)
{-# GHC_PRAGMA _M_ PreludeComplex {-dfun-} _A_ 1 _U_ 2 _N_ _N_ _N_ _N_ #-}
+instance Text (Complex Double)
+ {-# GHC_PRAGMA _M_ PreludeComplex {-dfun-} _A_ 0 _N_ _N_ _N_ _F_ _IF_ARGS_ 0 0 X 5 _!_ _TUP_4 [(Int -> [Char] -> [(Complex Double, [Char])]), (Int -> Complex Double -> [Char] -> [Char]), ([Char] -> [([Complex Double], [Char])]), ([Complex Double] -> [Char] -> [Char])] [_CONSTM_ Text readsPrec (Complex Double), _CONSTM_ Text showsPrec (Complex Double), _CONSTM_ Text readList (Complex Double), _CONSTM_ Text showList (Complex Double)] _N_
+ readsPrec = { _A_ 1 _U_ 12 _N_ _S_ "U(P)" {_A_ 1 _U_ 22 _N_ _N_ _N_ _N_} _N_ _N_ },
+ showsPrec = { _A_ 2 _U_ 112 _N_ _S_ "LU(LL)" {_A_ 3 _U_ 1222 _N_ _N_ _N_ _N_} _N_ _N_ },
+ readList = { _A_ 0 _U_ 2 _N_ _N_ _N_ _N_ },
+ showList = { _A_ 1 _U_ 12 _N_ _N_ _N_ _N_ } #-}
instance Text Double
{-# GHC_PRAGMA _M_ PreludeCore {-dfun-} _A_ 0 _N_ _N_ _N_ _F_ _IF_ARGS_ 0 0 X 5 _!_ _TUP_4 [(Int -> [Char] -> [(Double, [Char])]), (Int -> Double -> [Char] -> [Char]), ([Char] -> [([Double], [Char])]), ([Double] -> [Char] -> [Char])] [_CONSTM_ Text readsPrec (Double), _CONSTM_ Text showsPrec (Double), _CONSTM_ Text readList (Double), _CONSTM_ Text showList (Double)] _N_
- readsPrec = _A_ 2 _U_ 02 _N_ _S_ "AL" {_A_ 1 _U_ 2 _N_ _N_ _F_ _IF_ARGS_ 0 1 X 3 \ (u0 :: [Char]) -> _APP_ _SPEC_ _ORIG_ PreludeText readSigned [ (Double) ] [ _SPEC_ _ORIG_ PreludeText readFloat [ (Double) ], u0 ] _N_} _F_ _IF_ARGS_ 0 2 XX 3 \ (u0 :: Int) (u1 :: [Char]) -> _APP_ _SPEC_ _ORIG_ PreludeText readSigned [ (Double) ] [ _SPEC_ _ORIG_ PreludeText readFloat [ (Double) ], u1 ] _N_,
- showsPrec = _A_ 2 _U_ 212 _N_ _S_ "LU(P)" {_A_ 2 _U_ 222 _N_ _N_ _F_ _IF_ARGS_ 0 2 XX 4 \ (u0 :: Int) (u1 :: Double#) -> _APP_ _WRKR_ _SPEC_ _ORIG_ PreludeText showSigned [ (Double) ] [ _SPEC_ _ORIG_ PreludeText showFloat [ (Double) ], u0, u1 ] _N_} _F_ _IF_ARGS_ 0 2 XC 5 \ (u0 :: Int) (u1 :: Double) -> case u1 of { _ALG_ D# (u2 :: Double#) -> _APP_ _WRKR_ _SPEC_ _ORIG_ PreludeText showSigned [ (Double) ] [ _SPEC_ _ORIG_ PreludeText showFloat [ (Double) ], u0, u2 ]; _NO_DEFLT_ } _N_,
- readList = _A_ 0 _U_ 2 _N_ _N_ _N_ _N_,
- showList = _A_ 0 _U_ 12 _N_ _N_ _N_ _N_ #-}
+ readsPrec = { _A_ 2 _U_ 02 _N_ _S_ "AL" {_A_ 1 _U_ 2 _N_ _N_ _F_ _IF_ARGS_ 0 1 X 3 \ (u0 :: [Char]) -> _APP_ _SPEC_ _ORIG_ PreludeText readSigned [ (Double) ] [ _SPEC_ _ORIG_ PreludeText readFloat [ (Double) ], u0 ] _N_} _F_ _IF_ARGS_ 0 2 XX 3 \ (u0 :: Int) (u1 :: [Char]) -> _APP_ _SPEC_ _ORIG_ PreludeText readSigned [ (Double) ] [ _SPEC_ _ORIG_ PreludeText readFloat [ (Double) ], u1 ] _N_ },
+ showsPrec = { _A_ 2 _U_ 212 _N_ _S_ "LU(P)" {_A_ 2 _U_ 222 _N_ _N_ _F_ _IF_ARGS_ 0 2 XX 4 \ (u0 :: Int) (u1 :: Double#) -> _APP_ _WRKR_ _SPEC_ _ORIG_ PreludeText showSigned [ (Double) ] [ _SPEC_ _ORIG_ PreludeText showFloat [ (Double) ], u0, u1 ] _N_} _F_ _IF_ARGS_ 0 2 XC 5 \ (u0 :: Int) (u1 :: Double) -> case u1 of { _ALG_ D# (u2 :: Double#) -> _APP_ _WRKR_ _SPEC_ _ORIG_ PreludeText showSigned [ (Double) ] [ _SPEC_ _ORIG_ PreludeText showFloat [ (Double) ], u0, u2 ]; _NO_DEFLT_ } _N_ },
+ readList = { _A_ 0 _U_ 2 _N_ _N_ _N_ _N_ },
+ showList = { _A_ 1 _U_ 12 _N_ _N_ _N_ _N_ } #-}
instance (Text a, Text b) => Text (Either a b)
{-# GHC_PRAGMA _M_ PreludeMonadicIO {-dfun-} _A_ 2 _U_ 22 _N_ _N_ _N_ _N_ #-}
instance Text Float
{-# GHC_PRAGMA _M_ PreludeCore {-dfun-} _A_ 0 _N_ _N_ _N_ _F_ _IF_ARGS_ 0 0 X 5 _!_ _TUP_4 [(Int -> [Char] -> [(Float, [Char])]), (Int -> Float -> [Char] -> [Char]), ([Char] -> [([Float], [Char])]), ([Float] -> [Char] -> [Char])] [_CONSTM_ Text readsPrec (Float), _CONSTM_ Text showsPrec (Float), _CONSTM_ Text readList (Float), _CONSTM_ Text showList (Float)] _N_
- readsPrec = _A_ 2 _U_ 02 _N_ _S_ "AL" {_A_ 1 _U_ 2 _N_ _N_ _N_ _N_} _N_ _N_,
- showsPrec = _A_ 1 _U_ 222 _N_ _N_ _N_ _N_,
- readList = _A_ 0 _U_ 2 _N_ _N_ _N_ _N_,
- showList = _A_ 0 _U_ 12 _N_ _N_ _N_ _N_ #-}
+ readsPrec = { _A_ 2 _U_ 02 _N_ _S_ "AL" {_A_ 1 _U_ 2 _N_ _N_ _N_ _N_} _N_ _N_ },
+ showsPrec = { _A_ 1 _U_ 222 _N_ _N_ _N_ _N_ },
+ readList = { _A_ 0 _U_ 2 _N_ _N_ _N_ _N_ },
+ showList = { _A_ 0 _U_ 12 _N_ _N_ _N_ _N_ } #-}
instance Text IOError13
{-# GHC_PRAGMA _M_ PreludeIOError {-dfun-} _A_ 0 _N_ _N_ _N_ _F_ _IF_ARGS_ 0 0 X 5 _!_ _TUP_4 [(Int -> [Char] -> [(IOError13, [Char])]), (Int -> IOError13 -> [Char] -> [Char]), ([Char] -> [([IOError13], [Char])]), ([IOError13] -> [Char] -> [Char])] [_CONSTM_ Text readsPrec (IOError13), _CONSTM_ Text showsPrec (IOError13), _CONSTM_ Text readList (IOError13), _CONSTM_ Text showList (IOError13)] _N_
- readsPrec = _A_ 2 _U_ 22 _N_ _S_ _!_ _F_ _IF_ARGS_ 0 2 XX 4 \ (u0 :: Int) (u1 :: [Char]) -> _APP_ _TYAPP_ patError# { (Int -> [Char] -> [(IOError13, [Char])]) } [ _NOREP_S_ "%DPreludeCore.Text.readsPrec\"", u0, u1 ] _N_,
- showsPrec = _A_ 2 _U_ 012 _N_ _S_ "AS" {_A_ 1 _U_ 12 _N_ _N_ _N_ _N_} _N_ _N_,
- readList = _A_ 0 _U_ 2 _N_ _N_ _N_ _N_,
- showList = _A_ 0 _U_ 12 _N_ _N_ _N_ _N_ #-}
+ readsPrec = { _A_ 2 _U_ 02 _N_ _S_ _!_ _N_ _N_ },
+ showsPrec = { _A_ 2 _U_ 012 _N_ _S_ "AS" {_A_ 1 _U_ 12 _N_ _N_ _N_ _N_} _N_ _N_ },
+ readList = { _A_ 0 _U_ 2 _N_ _N_ _N_ _N_ },
+ showList = { _A_ 1 _U_ 12 _N_ _N_ _F_ _IF_ARGS_ 0 1 X 3 \ (u0 :: [IOError13]) -> _APP_ _TYAPP_ _ORIG_ PreludeCore _showList { IOError13 } [ _WRKR_ _CONSTM_ Text showsPrec (IOError13), u0 ] _N_ } #-}
instance Text Int
{-# GHC_PRAGMA _M_ PreludeCore {-dfun-} _A_ 0 _N_ _N_ _N_ _F_ _IF_ARGS_ 0 0 X 5 _!_ _TUP_4 [(Int -> [Char] -> [(Int, [Char])]), (Int -> Int -> [Char] -> [Char]), ([Char] -> [([Int], [Char])]), ([Int] -> [Char] -> [Char])] [_CONSTM_ Text readsPrec (Int), _CONSTM_ Text showsPrec (Int), _CONSTM_ Text readList (Int), _CONSTM_ Text showList (Int)] _N_
- readsPrec = _A_ 2 _U_ 02 _N_ _S_ "AL" {_A_ 1 _U_ 2 _N_ _N_ _F_ _IF_ARGS_ 0 1 X 3 \ (u0 :: [Char]) -> _APP_ _SPEC_ _ORIG_ PreludeText readSigned [ (Int) ] [ _SPEC_ _ORIG_ PreludeText readDec [ (Int) ], u0 ] _N_} _F_ _IF_ARGS_ 0 2 XX 3 \ (u0 :: Int) (u1 :: [Char]) -> _APP_ _SPEC_ _ORIG_ PreludeText readSigned [ (Int) ] [ _SPEC_ _ORIG_ PreludeText readDec [ (Int) ], u1 ] _N_,
- showsPrec = _A_ 3 _U_ 212 _N_ _S_ "LU(P)L" {_A_ 3 _U_ 222 _N_ _N_ _N_ _N_} _N_ _N_,
- readList = _A_ 0 _U_ 2 _N_ _N_ _N_ _N_,
- showList = _A_ 0 _U_ 12 _N_ _N_ _N_ _N_ #-}
+ readsPrec = { _A_ 2 _U_ 02 _N_ _S_ "AL" {_A_ 1 _U_ 2 _N_ _N_ _F_ _IF_ARGS_ 0 1 X 3 \ (u0 :: [Char]) -> _APP_ _SPEC_ _ORIG_ PreludeText readSigned [ (Int) ] [ _SPEC_ _ORIG_ PreludeText readDec [ (Int) ], u0 ] _N_} _F_ _IF_ARGS_ 0 2 XX 3 \ (u0 :: Int) (u1 :: [Char]) -> _APP_ _SPEC_ _ORIG_ PreludeText readSigned [ (Int) ] [ _SPEC_ _ORIG_ PreludeText readDec [ (Int) ], u1 ] _N_ },
+ showsPrec = { _A_ 3 _U_ 212 _N_ _S_ "LU(P)L" {_A_ 3 _U_ 222 _N_ _N_ _N_ _N_} _N_ _N_ },
+ readList = { _A_ 0 _U_ 2 _N_ _N_ _N_ _N_ },
+ showList = { _A_ 1 _U_ 12 _N_ _N_ _N_ _N_ } #-}
instance Text Integer
{-# GHC_PRAGMA _M_ PreludeCore {-dfun-} _A_ 0 _N_ _N_ _N_ _F_ _IF_ARGS_ 0 0 X 5 _!_ _TUP_4 [(Int -> [Char] -> [(Integer, [Char])]), (Int -> Integer -> [Char] -> [Char]), ([Char] -> [([Integer], [Char])]), ([Integer] -> [Char] -> [Char])] [_CONSTM_ Text readsPrec (Integer), _CONSTM_ Text showsPrec (Integer), _CONSTM_ Text readList (Integer), _CONSTM_ Text showList (Integer)] _N_
- readsPrec = _A_ 2 _U_ 02 _N_ _S_ "AL" {_A_ 1 _U_ 2 _N_ _N_ _F_ _IF_ARGS_ 0 1 X 3 \ (u0 :: [Char]) -> _APP_ _SPEC_ _ORIG_ PreludeText readSigned [ (Integer) ] [ _SPEC_ _ORIG_ PreludeText readDec [ (Integer) ], u0 ] _N_} _F_ _IF_ARGS_ 0 2 XX 3 \ (u0 :: Int) (u1 :: [Char]) -> _APP_ _SPEC_ _ORIG_ PreludeText readSigned [ (Integer) ] [ _SPEC_ _ORIG_ PreludeText readDec [ (Integer) ], u1 ] _N_,
- showsPrec = _A_ 3 _U_ 212 _N_ _S_ "LU(PPP)L" {_A_ 5 _U_ 22222 _N_ _N_ _N_ _N_} _N_ _N_,
- readList = _A_ 0 _U_ 2 _N_ _N_ _N_ _N_,
- showList = _A_ 0 _U_ 12 _N_ _N_ _N_ _N_ #-}
+ readsPrec = { _A_ 2 _U_ 02 _N_ _S_ "AL" {_A_ 1 _U_ 2 _N_ _N_ _F_ _IF_ARGS_ 0 1 X 3 \ (u0 :: [Char]) -> _APP_ _SPEC_ _ORIG_ PreludeText readSigned [ (Integer) ] [ _SPEC_ _ORIG_ PreludeText readDec [ (Integer) ], u0 ] _N_} _F_ _IF_ARGS_ 0 2 XX 3 \ (u0 :: Int) (u1 :: [Char]) -> _APP_ _SPEC_ _ORIG_ PreludeText readSigned [ (Integer) ] [ _SPEC_ _ORIG_ PreludeText readDec [ (Integer) ], u1 ] _N_ },
+ showsPrec = { _A_ 3 _U_ 212 _N_ _S_ "LU(PPP)L" {_A_ 5 _U_ 22222 _N_ _N_ _N_ _N_} _N_ _N_ },
+ readList = { _A_ 0 _U_ 2 _N_ _N_ _N_ _N_ },
+ showList = { _A_ 1 _U_ 12 _N_ _N_ _N_ _N_ } #-}
instance Text a => Text (Maybe a)
{-# GHC_PRAGMA _M_ PreludeStdIO {-dfun-} _A_ 1 _U_ 2 _N_ _N_ _N_ _N_ #-}
instance Integral a => Text (Ratio a)
{-# GHC_PRAGMA _M_ PreludeRatio {-dfun-} _A_ 1 _U_ 2 _N_ _N_ _N_ _N_ #-}
instance Text (Ratio Integer)
{-# GHC_PRAGMA _M_ PreludeRatio {-dfun-} _A_ 0 _N_ _N_ _N_ _F_ _IF_ARGS_ 0 0 X 5 _!_ _TUP_4 [(Int -> [Char] -> [(Ratio Integer, [Char])]), (Int -> Ratio Integer -> [Char] -> [Char]), ([Char] -> [([Ratio Integer], [Char])]), ([Ratio Integer] -> [Char] -> [Char])] [_CONSTM_ Text readsPrec (Ratio Integer), _CONSTM_ Text showsPrec (Ratio Integer), _CONSTM_ Text readList (Ratio Integer), _CONSTM_ Text showList (Ratio Integer)] _N_
- readsPrec = _A_ 1 _U_ 12 _N_ _S_ "U(P)" {_A_ 1 _U_ 22 _N_ _N_ _N_ _N_} _N_ _N_,
- showsPrec = _A_ 2 _U_ 112 _N_ _S_ "LU(LL)" {_A_ 3 _U_ 1222 _N_ _N_ _N_ _N_} _N_ _N_,
- readList = _A_ 0 _U_ 2 _N_ _N_ _N_ _N_,
- showList = _A_ 0 _U_ 12 _N_ _N_ _N_ _N_ #-}
+ readsPrec = { _A_ 1 _U_ 12 _N_ _S_ "U(P)" {_A_ 1 _U_ 22 _N_ _N_ _N_ _N_} _N_ _N_ },
+ showsPrec = { _A_ 2 _U_ 112 _N_ _S_ "LU(LL)" {_A_ 3 _U_ 1222 _N_ _N_ _N_ _N_} _N_ _N_ },
+ readList = { _A_ 0 _U_ 2 _N_ _N_ _N_ _N_ },
+ showList = { _A_ 1 _U_ 12 _N_ _N_ _N_ _N_ } #-}
instance Text a => Text [a]
{-# GHC_PRAGMA _M_ PreludeBuiltin {-dfun-} _A_ 1 _U_ 2 _N_ _N_ _N_ _N_ #-}
+instance Text [Bool]
+ {-# GHC_PRAGMA _M_ PreludeBuiltin {-dfun-} _A_ 0 _N_ _N_ _N_ _F_ _IF_ARGS_ 0 0 X 5 _!_ _TUP_4 [(Int -> [Char] -> [([Bool], [Char])]), (Int -> [Bool] -> [Char] -> [Char]), ([Char] -> [([[Bool]], [Char])]), ([[Bool]] -> [Char] -> [Char])] [_CONSTM_ Text readsPrec ([Bool]), _CONSTM_ Text showsPrec ([Bool]), _CONSTM_ Text readList ([Bool]), _CONSTM_ Text showList ([Bool])] _N_
+ readsPrec = { _A_ 1 _U_ 02 _N_ _S_ "A" {_A_ 0 _U_ 2 _N_ _N_ _F_ _IF_ARGS_ 0 0 X 1 _CONSTM_ Text readList (Bool) _N_} _F_ _IF_ARGS_ 0 1 X 1 \ (u0 :: Int) -> _CONSTM_ Text readList (Bool) _N_ },
+ showsPrec = { _A_ 2 _U_ 012 _N_ _S_ "AS" {_A_ 1 _U_ 12 _N_ _N_ _F_ _IF_ARGS_ 0 1 X 3 \ (u0 :: [Bool]) -> _APP_ _TYAPP_ _ORIG_ PreludeCore _showList { Bool } [ _WRKR_ _CONSTM_ Text showsPrec (Bool), u0 ] _N_} _F_ _IF_ARGS_ 0 2 XX 3 \ (u0 :: Int) (u1 :: [Bool]) -> _APP_ _TYAPP_ _ORIG_ PreludeCore _showList { Bool } [ _WRKR_ _CONSTM_ Text showsPrec (Bool), u1 ] _N_ },
+ readList = { _A_ 0 _U_ 2 _N_ _N_ _N_ _N_ },
+ showList = { _A_ 1 _U_ 12 _N_ _N_ _N_ _N_ } #-}
instance Text [Char]
{-# GHC_PRAGMA _M_ PreludeBuiltin {-dfun-} _A_ 0 _N_ _N_ _N_ _F_ _IF_ARGS_ 0 0 X 5 _!_ _TUP_4 [(Int -> [Char] -> [([Char], [Char])]), (Int -> [Char] -> [Char] -> [Char]), ([Char] -> [([[Char]], [Char])]), ([[Char]] -> [Char] -> [Char])] [_CONSTM_ Text readsPrec ([Char]), _CONSTM_ Text showsPrec ([Char]), _CONSTM_ Text readList ([Char]), _CONSTM_ Text showList ([Char])] _N_
- readsPrec = _A_ 1 _U_ 02 _N_ _S_ "A" {_A_ 0 _U_ 2 _N_ _N_ _F_ _IF_ARGS_ 0 0 X 1 _CONSTM_ Text readList (Char) _N_} _F_ _IF_ARGS_ 0 1 X 1 \ (u0 :: Int) -> _CONSTM_ Text readList (Char) _N_,
- showsPrec = _A_ 2 _U_ 022 _N_ _S_ "AL" {_A_ 1 _U_ 22 _N_ _N_ _F_ _IF_ARGS_ 0 0 X 1 _CONSTM_ Text showList (Char) _N_} _F_ _IF_ARGS_ 0 2 XX 2 \ (u0 :: Int) (u1 :: [Char]) -> _APP_ _CONSTM_ Text showList (Char) [ u1 ] _N_,
- readList = _A_ 0 _U_ 2 _N_ _N_ _N_ _N_,
- showList = _A_ 0 _U_ 12 _N_ _N_ _N_ _N_ #-}
+ readsPrec = { _A_ 1 _U_ 02 _N_ _S_ "A" {_A_ 0 _U_ 2 _N_ _N_ _F_ _IF_ARGS_ 0 0 X 1 _CONSTM_ Text readList (Char) _N_} _F_ _IF_ARGS_ 0 1 X 1 \ (u0 :: Int) -> _CONSTM_ Text readList (Char) _N_ },
+ showsPrec = { _A_ 2 _U_ 022 _N_ _S_ "AL" {_A_ 1 _U_ 22 _N_ _N_ _F_ _IF_ARGS_ 0 0 X 1 _CONSTM_ Text showList (Char) _N_} _F_ _IF_ARGS_ 0 2 XX 2 \ (u0 :: Int) (u1 :: [Char]) -> _APP_ _CONSTM_ Text showList (Char) [ u1 ] _N_ },
+ readList = { _A_ 0 _U_ 2 _N_ _N_ _N_ _N_ },
+ showList = { _A_ 1 _U_ 12 _N_ _N_ _F_ _IF_ARGS_ 0 1 X 3 \ (u0 :: [[Char]]) -> _APP_ _TYAPP_ _ORIG_ PreludeCore _showList { [Char] } [ _CONSTM_ Text showList (Char), u0 ] _N_ } #-}
+instance Text [Complex Double]
+ {-# GHC_PRAGMA _M_ PreludeBuiltin {-dfun-} _A_ 0 _N_ _N_ _N_ _F_ _IF_ARGS_ 0 0 X 5 _!_ _TUP_4 [(Int -> [Char] -> [([Complex Double], [Char])]), (Int -> [Complex Double] -> [Char] -> [Char]), ([Char] -> [([[Complex Double]], [Char])]), ([[Complex Double]] -> [Char] -> [Char])] [_CONSTM_ Text readsPrec ([Complex Double]), _CONSTM_ Text showsPrec ([Complex Double]), _CONSTM_ Text readList ([Complex Double]), _CONSTM_ Text showList ([Complex Double])] _N_
+ readsPrec = { _A_ 1 _U_ 02 _N_ _S_ "A" {_A_ 0 _U_ 2 _N_ _N_ _F_ _IF_ARGS_ 0 0 X 1 _CONSTM_ Text readList (Complex Double) _N_} _F_ _IF_ARGS_ 0 1 X 1 \ (u0 :: Int) -> _CONSTM_ Text readList (Complex Double) _N_ },
+ showsPrec = { _A_ 2 _U_ 022 _N_ _S_ "AL" {_A_ 1 _U_ 22 _N_ _N_ _F_ _IF_ARGS_ 0 0 X 1 _CONSTM_ Text showList (Complex Double) _N_} _F_ _IF_ARGS_ 0 2 XX 2 \ (u0 :: Int) (u1 :: [Complex Double]) -> _APP_ _CONSTM_ Text showList (Complex Double) [ u1 ] _N_ },
+ readList = { _A_ 0 _U_ 2 _N_ _N_ _N_ _N_ },
+ showList = { _A_ 1 _U_ 12 _N_ _N_ _F_ _IF_ARGS_ 0 1 X 3 \ (u0 :: [[Complex Double]]) -> _APP_ _TYAPP_ _ORIG_ PreludeCore _showList { [Complex Double] } [ _CONSTM_ Text showList (Complex Double), u0 ] _N_ } #-}
+instance Text [Double]
+ {-# GHC_PRAGMA _M_ PreludeBuiltin {-dfun-} _A_ 0 _N_ _N_ _N_ _F_ _IF_ARGS_ 0 0 X 5 _!_ _TUP_4 [(Int -> [Char] -> [([Double], [Char])]), (Int -> [Double] -> [Char] -> [Char]), ([Char] -> [([[Double]], [Char])]), ([[Double]] -> [Char] -> [Char])] [_CONSTM_ Text readsPrec ([Double]), _CONSTM_ Text showsPrec ([Double]), _CONSTM_ Text readList ([Double]), _CONSTM_ Text showList ([Double])] _N_
+ readsPrec = { _A_ 1 _U_ 02 _N_ _S_ "A" {_A_ 0 _U_ 2 _N_ _N_ _F_ _IF_ARGS_ 0 0 X 1 _CONSTM_ Text readList (Double) _N_} _F_ _IF_ARGS_ 0 1 X 1 \ (u0 :: Int) -> _CONSTM_ Text readList (Double) _N_ },
+ showsPrec = { _A_ 2 _U_ 022 _N_ _S_ "AL" {_A_ 1 _U_ 22 _N_ _N_ _F_ _IF_ARGS_ 0 0 X 1 _CONSTM_ Text showList (Double) _N_} _F_ _IF_ARGS_ 0 2 XX 2 \ (u0 :: Int) (u1 :: [Double]) -> _APP_ _CONSTM_ Text showList (Double) [ u1 ] _N_ },
+ readList = { _A_ 0 _U_ 2 _N_ _N_ _N_ _N_ },
+ showList = { _A_ 1 _U_ 12 _N_ _N_ _F_ _IF_ARGS_ 0 1 X 3 \ (u0 :: [[Double]]) -> _APP_ _TYAPP_ _ORIG_ PreludeCore _showList { [Double] } [ _CONSTM_ Text showList (Double), u0 ] _N_ } #-}
instance Text [Int]
{-# GHC_PRAGMA _M_ PreludeBuiltin {-dfun-} _A_ 0 _N_ _N_ _N_ _F_ _IF_ARGS_ 0 0 X 5 _!_ _TUP_4 [(Int -> [Char] -> [([Int], [Char])]), (Int -> [Int] -> [Char] -> [Char]), ([Char] -> [([[Int]], [Char])]), ([[Int]] -> [Char] -> [Char])] [_CONSTM_ Text readsPrec ([Int]), _CONSTM_ Text showsPrec ([Int]), _CONSTM_ Text readList ([Int]), _CONSTM_ Text showList ([Int])] _N_
- readsPrec = _A_ 1 _U_ 02 _N_ _S_ "A" {_A_ 0 _U_ 2 _N_ _N_ _F_ _IF_ARGS_ 0 0 X 1 _CONSTM_ Text readList (Int) _N_} _F_ _IF_ARGS_ 0 1 X 1 \ (u0 :: Int) -> _CONSTM_ Text readList (Int) _N_,
- showsPrec = _A_ 1 _U_ 022 _N_ _S_ "A" {_A_ 0 _U_ 22 _N_ _N_ _F_ _IF_ARGS_ 0 0 X 1 _CONSTM_ Text showList (Int) _N_} _F_ _IF_ARGS_ 0 1 X 1 \ (u0 :: Int) -> _CONSTM_ Text showList (Int) _N_,
- readList = _A_ 0 _U_ 2 _N_ _N_ _N_ _N_,
- showList = _A_ 0 _U_ 12 _N_ _N_ _N_ _N_ #-}
+ readsPrec = { _A_ 1 _U_ 02 _N_ _S_ "A" {_A_ 0 _U_ 2 _N_ _N_ _F_ _IF_ARGS_ 0 0 X 1 _CONSTM_ Text readList (Int) _N_} _F_ _IF_ARGS_ 0 1 X 1 \ (u0 :: Int) -> _CONSTM_ Text readList (Int) _N_ },
+ showsPrec = { _A_ 2 _U_ 022 _N_ _S_ "AL" {_A_ 1 _U_ 22 _N_ _N_ _F_ _IF_ARGS_ 0 0 X 1 _CONSTM_ Text showList (Int) _N_} _F_ _IF_ARGS_ 0 2 XX 2 \ (u0 :: Int) (u1 :: [Int]) -> _APP_ _CONSTM_ Text showList (Int) [ u1 ] _N_ },
+ readList = { _A_ 0 _U_ 2 _N_ _N_ _N_ _N_ },
+ showList = { _A_ 1 _U_ 12 _N_ _N_ _F_ _IF_ARGS_ 0 1 X 3 \ (u0 :: [[Int]]) -> _APP_ _TYAPP_ _ORIG_ PreludeCore _showList { [Int] } [ _CONSTM_ Text showList (Int), u0 ] _N_ } #-}
+instance Text [Integer]
+ {-# GHC_PRAGMA _M_ PreludeBuiltin {-dfun-} _A_ 0 _N_ _N_ _N_ _F_ _IF_ARGS_ 0 0 X 5 _!_ _TUP_4 [(Int -> [Char] -> [([Integer], [Char])]), (Int -> [Integer] -> [Char] -> [Char]), ([Char] -> [([[Integer]], [Char])]), ([[Integer]] -> [Char] -> [Char])] [_CONSTM_ Text readsPrec ([Integer]), _CONSTM_ Text showsPrec ([Integer]), _CONSTM_ Text readList ([Integer]), _CONSTM_ Text showList ([Integer])] _N_
+ readsPrec = { _A_ 1 _U_ 02 _N_ _S_ "A" {_A_ 0 _U_ 2 _N_ _N_ _F_ _IF_ARGS_ 0 0 X 1 _CONSTM_ Text readList (Integer) _N_} _F_ _IF_ARGS_ 0 1 X 1 \ (u0 :: Int) -> _CONSTM_ Text readList (Integer) _N_ },
+ showsPrec = { _A_ 2 _U_ 022 _N_ _S_ "AL" {_A_ 1 _U_ 22 _N_ _N_ _F_ _IF_ARGS_ 0 0 X 1 _CONSTM_ Text showList (Integer) _N_} _F_ _IF_ARGS_ 0 2 XX 2 \ (u0 :: Int) (u1 :: [Integer]) -> _APP_ _CONSTM_ Text showList (Integer) [ u1 ] _N_ },
+ readList = { _A_ 0 _U_ 2 _N_ _N_ _N_ _N_ },
+ showList = { _A_ 1 _U_ 12 _N_ _N_ _F_ _IF_ARGS_ 0 1 X 3 \ (u0 :: [[Integer]]) -> _APP_ _TYAPP_ _ORIG_ PreludeCore _showList { [Integer] } [ _CONSTM_ Text showList (Integer), u0 ] _N_ } #-}
+instance Text [[Char]]
+ {-# GHC_PRAGMA _M_ PreludeBuiltin {-dfun-} _A_ 0 _N_ _N_ _N_ _F_ _IF_ARGS_ 0 0 X 5 _!_ _TUP_4 [(Int -> [Char] -> [([[Char]], [Char])]), (Int -> [[Char]] -> [Char] -> [Char]), ([Char] -> [([[[Char]]], [Char])]), ([[[Char]]] -> [Char] -> [Char])] [_CONSTM_ Text readsPrec ([[Char]]), _CONSTM_ Text showsPrec ([[Char]]), _CONSTM_ Text readList ([[Char]]), _CONSTM_ Text showList ([[Char]])] _N_
+ readsPrec = { _A_ 1 _U_ 02 _N_ _S_ "A" {_A_ 0 _U_ 2 _N_ _N_ _F_ _IF_ARGS_ 0 0 X 1 _CONSTM_ Text readList ([Char]) _N_} _F_ _IF_ARGS_ 0 1 X 1 \ (u0 :: Int) -> _CONSTM_ Text readList ([Char]) _N_ },
+ showsPrec = { _A_ 2 _U_ 012 _N_ _S_ "AS" {_A_ 1 _U_ 12 _N_ _N_ _F_ _IF_ARGS_ 0 1 X 3 \ (u0 :: [[Char]]) -> _APP_ _TYAPP_ _ORIG_ PreludeCore _showList { [Char] } [ _CONSTM_ Text showList (Char), u0 ] _N_} _F_ _IF_ARGS_ 0 2 XX 2 \ (u0 :: Int) (u1 :: [[Char]]) -> _APP_ _CONSTM_ Text showList ([Char]) [ u1 ] _N_ },
+ readList = { _A_ 0 _U_ 2 _N_ _N_ _N_ _N_ },
+ showList = { _A_ 1 _U_ 12 _N_ _N_ _N_ _N_ } #-}
+instance Text [[Int]]
+ {-# GHC_PRAGMA _M_ PreludeBuiltin {-dfun-} _A_ 0 _N_ _N_ _N_ _F_ _IF_ARGS_ 0 0 X 5 _!_ _TUP_4 [(Int -> [Char] -> [([[Int]], [Char])]), (Int -> [[Int]] -> [Char] -> [Char]), ([Char] -> [([[[Int]]], [Char])]), ([[[Int]]] -> [Char] -> [Char])] [_CONSTM_ Text readsPrec ([[Int]]), _CONSTM_ Text showsPrec ([[Int]]), _CONSTM_ Text readList ([[Int]]), _CONSTM_ Text showList ([[Int]])] _N_
+ readsPrec = { _A_ 1 _U_ 02 _N_ _S_ "A" {_A_ 0 _U_ 2 _N_ _N_ _F_ _IF_ARGS_ 0 0 X 1 _CONSTM_ Text readList ([Int]) _N_} _F_ _IF_ARGS_ 0 1 X 1 \ (u0 :: Int) -> _CONSTM_ Text readList ([Int]) _N_ },
+ showsPrec = { _A_ 2 _U_ 012 _N_ _S_ "AS" {_A_ 1 _U_ 12 _N_ _N_ _F_ _IF_ARGS_ 0 1 X 3 \ (u0 :: [[Int]]) -> _APP_ _TYAPP_ _ORIG_ PreludeCore _showList { [Int] } [ _CONSTM_ Text showList (Int), u0 ] _N_} _F_ _IF_ARGS_ 0 2 XX 2 \ (u0 :: Int) (u1 :: [[Int]]) -> _APP_ _CONSTM_ Text showList ([Int]) [ u1 ] _N_ },
+ readList = { _A_ 0 _U_ 2 _N_ _N_ _N_ _N_ },
+ showList = { _A_ 1 _U_ 12 _N_ _N_ _N_ _N_ } #-}
instance Text _PackedString
{-# GHC_PRAGMA _M_ PreludePS {-dfun-} _A_ 0 _N_ _N_ _N_ _F_ _IF_ARGS_ 0 0 X 5 _!_ _TUP_4 [(Int -> [Char] -> [(_PackedString, [Char])]), (Int -> _PackedString -> [Char] -> [Char]), ([Char] -> [([_PackedString], [Char])]), ([_PackedString] -> [Char] -> [Char])] [_CONSTM_ Text readsPrec (_PackedString), _CONSTM_ Text showsPrec (_PackedString), _CONSTM_ Text readList (_PackedString), _CONSTM_ Text showList (_PackedString)] _N_
- readsPrec = _A_ 2 _U_ 02 _N_ _S_ _!_ _F_ _IF_ARGS_ 0 2 XX 3 \ (u0 :: Int) (u1 :: [Char]) -> _APP_ _TYAPP_ error { ([Char] -> [(_PackedString, [Char])]) } [ _NOREP_S_ "readsPrec: _PackedString: ToDo", u1 ] _N_,
- showsPrec = _A_ 3 _U_ 012 _N_ _S_ "ALL" {_A_ 2 _U_ 12 _N_ _N_ _N_ _N_} _F_ _IF_ARGS_ 0 3 XXX 6 \ (u0 :: Int) (u1 :: _PackedString) (u2 :: [Char]) -> let {(u3 :: [Char]) = _APP_ _ORIG_ PreludePS _unpackPS [ u1 ]} in _APP_ _CONSTM_ Text showList (Char) [ u3, u2 ] _N_,
- readList = _A_ 0 _U_ 2 _N_ _N_ _N_ _N_,
- showList = _A_ 0 _U_ 12 _N_ _N_ _N_ _N_ #-}
+ readsPrec = { _A_ 2 _U_ 02 _N_ _S_ _!_ _N_ _N_ },
+ showsPrec = { _A_ 3 _U_ 012 _N_ _S_ "ALL" {_A_ 2 _U_ 12 _N_ _N_ _N_ _N_} _F_ _IF_ARGS_ 0 3 XXX 6 \ (u0 :: Int) (u1 :: _PackedString) (u2 :: [Char]) -> let {(u3 :: [Char]) = _APP_ _ORIG_ PreludePS _unpackPS [ u1 ]} in _APP_ _CONSTM_ Text showList (Char) [ u3, u2 ] _N_ },
+ readList = { _A_ 0 _U_ 2 _N_ _N_ _N_ _N_ },
+ showList = { _A_ 1 _U_ 12 _N_ _N_ _F_ _IF_ARGS_ 0 1 X 3 \ (u0 :: [_PackedString]) -> _APP_ _TYAPP_ _ORIG_ PreludeCore _showList { _PackedString } [ _WRKR_ _CONSTM_ Text showsPrec (_PackedString), u0 ] _N_ } #-}
instance _CCallable Char
{-# GHC_PRAGMA _M_ PreludeCore {-dfun-} _A_ 0 _N_ _N_ _N_ _F_ _IF_ARGS_ 0 0 X 1 _!_ _TUP_0 [] [] _N_ #-}
instance _CCallable Double
-{-# GHC_PRAGMA INTERFACE VERSION 5 #-}
+{-# GHC_PRAGMA INTERFACE VERSION 6 #-}
interface PreludeCore where
import PreludeArray(Array, Assoc(..), _ByteArray)
import PreludeBuiltin(Bin, Char(..), Double(..), Float(..), Int(..), Integer(..), List(..), Tuple0, Tuple2, Tuple3, Tuple4, Tuple5, _Addr(..), _CMP_TAG(..), _RealWorld(..), _State(..), _Word(..))
import PreludeComplex(Complex(..))
-import PreludeGlaMisc(_MallocPtr(..))
+import PreludeGlaMisc(_MallocPtr(..), _StablePtr(..))
import PreludeGlaST(_MutableArray, _MutableByteArray)
import PreludeIOError(IOError13(..))
import PreludeMonadicIO(Either(..), IO(..))
class Binary a where
readBin :: Bin -> (a, Bin)
{-# GHC_PRAGMA {-meth-} _A_ 1 _U_ 12 _N_ _S_ "S" _F_ _IF_ARGS_ 1 1 C 2 _/\_ u0 -> \ (u1 :: (Bin -> (u0, Bin), u0 -> Bin -> Bin)) -> case u1 of { _ALG_ _TUP_2 (u2 :: Bin -> (u0, Bin)) (u3 :: u0 -> Bin -> Bin) -> u2; _NO_DEFLT_ } _N_
- {-defm-} _A_ 2 _U_ 02 _N_ _S_ _!_ _F_ _IF_ARGS_ 1 2 XX 3 _/\_ u0 -> \ (u1 :: {{Binary u0}}) (u2 :: Bin) -> _APP_ _TYAPP_ patError# { (Bin -> (u0, Bin)) } [ _NOREP_S_ "%DPreludeCore.Binary.readBin\"", u2 ] _N_ #-}
+ {-defm-} _A_ 2 _U_ 02 _N_ _S_ _!_ _N_ _N_ #-}
showBin :: a -> Bin -> Bin
{-# GHC_PRAGMA {-meth-} _A_ 1 _U_ 122 _N_ _S_ "S" _F_ _IF_ARGS_ 1 1 C 2 _/\_ u0 -> \ (u1 :: (Bin -> (u0, Bin), u0 -> Bin -> Bin)) -> case u1 of { _ALG_ _TUP_2 (u2 :: Bin -> (u0, Bin)) (u3 :: u0 -> Bin -> Bin) -> u3; _NO_DEFLT_ } _N_
- {-defm-} _A_ 3 _U_ 022 _N_ _S_ _!_ _F_ _IF_ARGS_ 1 3 XXX 4 _/\_ u0 -> \ (u1 :: {{Binary u0}}) (u2 :: u0) (u3 :: Bin) -> _APP_ _TYAPP_ patError# { (u0 -> Bin -> Bin) } [ _NOREP_S_ "%DPreludeCore.Binary.showBin\"", u2, u3 ] _N_ #-}
+ {-defm-} _A_ 3 _U_ 022 _N_ _S_ _!_ _N_ _N_ #-}
class (Ord a) => Enum a {-# GHC_PRAGMA {-superdicts-} _A_ 1 _U_ 1 _N_ _S_ "S" _F_ _IF_ARGS_ 1 1 C 2 _/\_ u0 -> \ (u1 :: ({{Ord u0}}, u0 -> [u0], u0 -> u0 -> [u0], u0 -> u0 -> [u0], u0 -> u0 -> u0 -> [u0])) -> case u1 of { _ALG_ _TUP_5 (u2 :: {{Ord u0}}) (u3 :: u0 -> [u0]) (u4 :: u0 -> u0 -> [u0]) (u5 :: u0 -> u0 -> [u0]) (u6 :: u0 -> u0 -> u0 -> [u0]) -> u2; _NO_DEFLT_ } _N_ #-} where
enumFrom :: a -> [a]
{-# GHC_PRAGMA {-meth-} _A_ 1 _U_ 12 _N_ _S_ "S" _F_ _IF_ARGS_ 1 1 C 2 _/\_ u0 -> \ (u1 :: ({{Ord u0}}, u0 -> [u0], u0 -> u0 -> [u0], u0 -> u0 -> [u0], u0 -> u0 -> u0 -> [u0])) -> case u1 of { _ALG_ _TUP_5 (u2 :: {{Ord u0}}) (u3 :: u0 -> [u0]) (u4 :: u0 -> u0 -> [u0]) (u5 :: u0 -> u0 -> [u0]) (u6 :: u0 -> u0 -> u0 -> [u0]) -> u3; _NO_DEFLT_ } _N_
- {-defm-} _A_ 2 _U_ 02 _N_ _S_ _!_ _F_ _IF_ARGS_ 1 2 XX 3 _/\_ u0 -> \ (u1 :: {{Enum u0}}) (u2 :: u0) -> _APP_ _TYAPP_ patError# { (u0 -> [u0]) } [ _NOREP_S_ "%DPreludeCore.Enum.enumFrom\"", u2 ] _N_ #-}
+ {-defm-} _A_ 2 _U_ 02 _N_ _S_ _!_ _N_ _N_ #-}
enumFromThen :: a -> a -> [a]
{-# GHC_PRAGMA {-meth-} _A_ 1 _U_ 122 _N_ _S_ "S" _F_ _IF_ARGS_ 1 1 C 2 _/\_ u0 -> \ (u1 :: ({{Ord u0}}, u0 -> [u0], u0 -> u0 -> [u0], u0 -> u0 -> [u0], u0 -> u0 -> u0 -> [u0])) -> case u1 of { _ALG_ _TUP_5 (u2 :: {{Ord u0}}) (u3 :: u0 -> [u0]) (u4 :: u0 -> u0 -> [u0]) (u5 :: u0 -> u0 -> [u0]) (u6 :: u0 -> u0 -> u0 -> [u0]) -> u4; _NO_DEFLT_ } _N_
- {-defm-} _A_ 3 _U_ 022 _N_ _S_ _!_ _F_ _IF_ARGS_ 1 3 XXX 4 _/\_ u0 -> \ (u1 :: {{Enum u0}}) (u2 :: u0) (u3 :: u0) -> _APP_ _TYAPP_ patError# { (u0 -> u0 -> [u0]) } [ _NOREP_S_ "%DPreludeCore.Enum.enumFromThen\"", u2, u3 ] _N_ #-}
+ {-defm-} _A_ 3 _U_ 022 _N_ _S_ _!_ _N_ _N_ #-}
enumFromTo :: a -> a -> [a]
{-# GHC_PRAGMA {-meth-} _A_ 1 _U_ 122 _N_ _S_ "S" _F_ _IF_ARGS_ 1 1 C 2 _/\_ u0 -> \ (u1 :: ({{Ord u0}}, u0 -> [u0], u0 -> u0 -> [u0], u0 -> u0 -> [u0], u0 -> u0 -> u0 -> [u0])) -> case u1 of { _ALG_ _TUP_5 (u2 :: {{Ord u0}}) (u3 :: u0 -> [u0]) (u4 :: u0 -> u0 -> [u0]) (u5 :: u0 -> u0 -> [u0]) (u6 :: u0 -> u0 -> u0 -> [u0]) -> u5; _NO_DEFLT_ } _N_
{-defm-} _A_ 3 _U_ 122 _N_ _S_ "SLL" _N_ _N_ #-}
class Eq a where
(==) :: a -> a -> Bool
{-# GHC_PRAGMA {-meth-} _A_ 1 _U_ 122 _N_ _S_ "S" _F_ _IF_ARGS_ 1 1 C 2 _/\_ u0 -> \ (u1 :: (u0 -> u0 -> Bool, u0 -> u0 -> Bool)) -> case u1 of { _ALG_ _TUP_2 (u2 :: u0 -> u0 -> Bool) (u3 :: u0 -> u0 -> Bool) -> u2; _NO_DEFLT_ } _N_
- {-defm-} _A_ 3 _U_ 022 _N_ _S_ _!_ _F_ _IF_ARGS_ 1 3 XXX 4 _/\_ u0 -> \ (u1 :: {{Eq u0}}) (u2 :: u0) (u3 :: u0) -> _APP_ _TYAPP_ patError# { (u0 -> u0 -> Bool) } [ _NOREP_S_ "%DPreludeCore.Eq.(==)\"", u2, u3 ] _N_ #-}
+ {-defm-} _A_ 3 _U_ 022 _N_ _S_ _!_ _N_ _N_ #-}
(/=) :: a -> a -> Bool
{-# GHC_PRAGMA {-meth-} _A_ 1 _U_ 122 _N_ _S_ "S" _F_ _IF_ARGS_ 1 1 C 2 _/\_ u0 -> \ (u1 :: (u0 -> u0 -> Bool, u0 -> u0 -> Bool)) -> case u1 of { _ALG_ _TUP_2 (u2 :: u0 -> u0 -> Bool) (u3 :: u0 -> u0 -> Bool) -> u3; _NO_DEFLT_ } _N_
{-defm-} _A_ 3 _U_ 122 _N_ _S_ "SLL" _N_ _N_ #-}
class (Fractional a) => Floating a {-# GHC_PRAGMA {-superdicts-} _A_ 1 _U_ 1 _N_ _S_ "S" _F_ _IF_ARGS_ 1 1 C 2 _/\_ u0 -> \ (u1 :: ({{Fractional u0}}, u0, u0 -> u0, u0 -> u0, u0 -> u0, u0 -> u0 -> u0, u0 -> u0 -> u0, u0 -> u0, u0 -> u0, u0 -> u0, u0 -> u0, u0 -> u0, u0 -> u0, u0 -> u0, u0 -> u0, u0 -> u0, u0 -> u0, u0 -> u0, u0 -> u0)) -> case u1 of { _ALG_ _TUP_19 (u2 :: {{Fractional u0}}) (u3 :: u0) (u4 :: u0 -> u0) (u5 :: u0 -> u0) (u6 :: u0 -> u0) (u7 :: u0 -> u0 -> u0) (u8 :: u0 -> u0 -> u0) (u9 :: u0 -> u0) (ua :: u0 -> u0) (ub :: u0 -> u0) (uc :: u0 -> u0) (ud :: u0 -> u0) (ue :: u0 -> u0) (uf :: u0 -> u0) (ug :: u0 -> u0) (uh :: u0 -> u0) (ui :: u0 -> u0) (uj :: u0 -> u0) (uk :: u0 -> u0) -> u2; _NO_DEFLT_ } _N_ #-} where
pi :: a
{-# GHC_PRAGMA {-meth-} _A_ 1 _U_ 1 _N_ _S_ "S" _F_ _IF_ARGS_ 1 1 C 2 _/\_ u0 -> \ (u1 :: ({{Fractional u0}}, u0, u0 -> u0, u0 -> u0, u0 -> u0, u0 -> u0 -> u0, u0 -> u0 -> u0, u0 -> u0, u0 -> u0, u0 -> u0, u0 -> u0, u0 -> u0, u0 -> u0, u0 -> u0, u0 -> u0, u0 -> u0, u0 -> u0, u0 -> u0, u0 -> u0)) -> case u1 of { _ALG_ _TUP_19 (u2 :: {{Fractional u0}}) (u3 :: u0) (u4 :: u0 -> u0) (u5 :: u0 -> u0) (u6 :: u0 -> u0) (u7 :: u0 -> u0 -> u0) (u8 :: u0 -> u0 -> u0) (u9 :: u0 -> u0) (ua :: u0 -> u0) (ub :: u0 -> u0) (uc :: u0 -> u0) (ud :: u0 -> u0) (ue :: u0 -> u0) (uf :: u0 -> u0) (ug :: u0 -> u0) (uh :: u0 -> u0) (ui :: u0 -> u0) (uj :: u0 -> u0) (uk :: u0 -> u0) -> u3; _NO_DEFLT_ } _N_
- {-defm-} _A_ 1 _U_ 0 _N_ _S_ _!_ _F_ _IF_ARGS_ 1 1 X 2 _/\_ u0 -> \ (u1 :: {{Floating u0}}) -> _APP_ _TYAPP_ patError# { u0 } [ _NOREP_S_ "%DPreludeCore.Floating.pi\"" ] _N_ #-}
+ {-defm-} _A_ 1 _U_ 0 _N_ _S_ _!_ _N_ _N_ #-}
exp :: a -> a
{-# GHC_PRAGMA {-meth-} _A_ 1 _U_ 12 _N_ _S_ "S" _F_ _IF_ARGS_ 1 1 C 2 _/\_ u0 -> \ (u1 :: ({{Fractional u0}}, u0, u0 -> u0, u0 -> u0, u0 -> u0, u0 -> u0 -> u0, u0 -> u0 -> u0, u0 -> u0, u0 -> u0, u0 -> u0, u0 -> u0, u0 -> u0, u0 -> u0, u0 -> u0, u0 -> u0, u0 -> u0, u0 -> u0, u0 -> u0, u0 -> u0)) -> case u1 of { _ALG_ _TUP_19 (u2 :: {{Fractional u0}}) (u3 :: u0) (u4 :: u0 -> u0) (u5 :: u0 -> u0) (u6 :: u0 -> u0) (u7 :: u0 -> u0 -> u0) (u8 :: u0 -> u0 -> u0) (u9 :: u0 -> u0) (ua :: u0 -> u0) (ub :: u0 -> u0) (uc :: u0 -> u0) (ud :: u0 -> u0) (ue :: u0 -> u0) (uf :: u0 -> u0) (ug :: u0 -> u0) (uh :: u0 -> u0) (ui :: u0 -> u0) (uj :: u0 -> u0) (uk :: u0 -> u0) -> u4; _NO_DEFLT_ } _N_
- {-defm-} _A_ 2 _U_ 02 _N_ _S_ _!_ _F_ _IF_ARGS_ 1 2 XX 3 _/\_ u0 -> \ (u1 :: {{Floating u0}}) (u2 :: u0) -> _APP_ _TYAPP_ patError# { (u0 -> u0) } [ _NOREP_S_ "%DPreludeCore.Floating.exp\"", u2 ] _N_ #-}
+ {-defm-} _A_ 2 _U_ 02 _N_ _S_ _!_ _N_ _N_ #-}
log :: a -> a
{-# GHC_PRAGMA {-meth-} _A_ 1 _U_ 12 _N_ _S_ "S" _F_ _IF_ARGS_ 1 1 C 2 _/\_ u0 -> \ (u1 :: ({{Fractional u0}}, u0, u0 -> u0, u0 -> u0, u0 -> u0, u0 -> u0 -> u0, u0 -> u0 -> u0, u0 -> u0, u0 -> u0, u0 -> u0, u0 -> u0, u0 -> u0, u0 -> u0, u0 -> u0, u0 -> u0, u0 -> u0, u0 -> u0, u0 -> u0, u0 -> u0)) -> case u1 of { _ALG_ _TUP_19 (u2 :: {{Fractional u0}}) (u3 :: u0) (u4 :: u0 -> u0) (u5 :: u0 -> u0) (u6 :: u0 -> u0) (u7 :: u0 -> u0 -> u0) (u8 :: u0 -> u0 -> u0) (u9 :: u0 -> u0) (ua :: u0 -> u0) (ub :: u0 -> u0) (uc :: u0 -> u0) (ud :: u0 -> u0) (ue :: u0 -> u0) (uf :: u0 -> u0) (ug :: u0 -> u0) (uh :: u0 -> u0) (ui :: u0 -> u0) (uj :: u0 -> u0) (uk :: u0 -> u0) -> u5; _NO_DEFLT_ } _N_
- {-defm-} _A_ 2 _U_ 02 _N_ _S_ _!_ _F_ _IF_ARGS_ 1 2 XX 3 _/\_ u0 -> \ (u1 :: {{Floating u0}}) (u2 :: u0) -> _APP_ _TYAPP_ patError# { (u0 -> u0) } [ _NOREP_S_ "%DPreludeCore.Floating.log\"", u2 ] _N_ #-}
+ {-defm-} _A_ 2 _U_ 02 _N_ _S_ _!_ _N_ _N_ #-}
sqrt :: a -> a
{-# GHC_PRAGMA {-meth-} _A_ 1 _U_ 12 _N_ _S_ "S" _F_ _IF_ARGS_ 1 1 C 2 _/\_ u0 -> \ (u1 :: ({{Fractional u0}}, u0, u0 -> u0, u0 -> u0, u0 -> u0, u0 -> u0 -> u0, u0 -> u0 -> u0, u0 -> u0, u0 -> u0, u0 -> u0, u0 -> u0, u0 -> u0, u0 -> u0, u0 -> u0, u0 -> u0, u0 -> u0, u0 -> u0, u0 -> u0, u0 -> u0)) -> case u1 of { _ALG_ _TUP_19 (u2 :: {{Fractional u0}}) (u3 :: u0) (u4 :: u0 -> u0) (u5 :: u0 -> u0) (u6 :: u0 -> u0) (u7 :: u0 -> u0 -> u0) (u8 :: u0 -> u0 -> u0) (u9 :: u0 -> u0) (ua :: u0 -> u0) (ub :: u0 -> u0) (uc :: u0 -> u0) (ud :: u0 -> u0) (ue :: u0 -> u0) (uf :: u0 -> u0) (ug :: u0 -> u0) (uh :: u0 -> u0) (ui :: u0 -> u0) (uj :: u0 -> u0) (uk :: u0 -> u0) -> u6; _NO_DEFLT_ } _N_
{-defm-} _A_ 1 _U_ 12 _N_ _S_ "S" _N_ _N_ #-}
{-defm-} _A_ 3 _U_ 122 _N_ _S_ "SLL" _N_ _N_ #-}
sin :: a -> a
{-# GHC_PRAGMA {-meth-} _A_ 1 _U_ 12 _N_ _S_ "S" _F_ _IF_ARGS_ 1 1 C 2 _/\_ u0 -> \ (u1 :: ({{Fractional u0}}, u0, u0 -> u0, u0 -> u0, u0 -> u0, u0 -> u0 -> u0, u0 -> u0 -> u0, u0 -> u0, u0 -> u0, u0 -> u0, u0 -> u0, u0 -> u0, u0 -> u0, u0 -> u0, u0 -> u0, u0 -> u0, u0 -> u0, u0 -> u0, u0 -> u0)) -> case u1 of { _ALG_ _TUP_19 (u2 :: {{Fractional u0}}) (u3 :: u0) (u4 :: u0 -> u0) (u5 :: u0 -> u0) (u6 :: u0 -> u0) (u7 :: u0 -> u0 -> u0) (u8 :: u0 -> u0 -> u0) (u9 :: u0 -> u0) (ua :: u0 -> u0) (ub :: u0 -> u0) (uc :: u0 -> u0) (ud :: u0 -> u0) (ue :: u0 -> u0) (uf :: u0 -> u0) (ug :: u0 -> u0) (uh :: u0 -> u0) (ui :: u0 -> u0) (uj :: u0 -> u0) (uk :: u0 -> u0) -> u9; _NO_DEFLT_ } _N_
- {-defm-} _A_ 2 _U_ 02 _N_ _S_ _!_ _F_ _IF_ARGS_ 1 2 XX 3 _/\_ u0 -> \ (u1 :: {{Floating u0}}) (u2 :: u0) -> _APP_ _TYAPP_ patError# { (u0 -> u0) } [ _NOREP_S_ "%DPreludeCore.Floating.sin\"", u2 ] _N_ #-}
+ {-defm-} _A_ 2 _U_ 02 _N_ _S_ _!_ _N_ _N_ #-}
cos :: a -> a
{-# GHC_PRAGMA {-meth-} _A_ 1 _U_ 12 _N_ _S_ "S" _F_ _IF_ARGS_ 1 1 C 2 _/\_ u0 -> \ (u1 :: ({{Fractional u0}}, u0, u0 -> u0, u0 -> u0, u0 -> u0, u0 -> u0 -> u0, u0 -> u0 -> u0, u0 -> u0, u0 -> u0, u0 -> u0, u0 -> u0, u0 -> u0, u0 -> u0, u0 -> u0, u0 -> u0, u0 -> u0, u0 -> u0, u0 -> u0, u0 -> u0)) -> case u1 of { _ALG_ _TUP_19 (u2 :: {{Fractional u0}}) (u3 :: u0) (u4 :: u0 -> u0) (u5 :: u0 -> u0) (u6 :: u0 -> u0) (u7 :: u0 -> u0 -> u0) (u8 :: u0 -> u0 -> u0) (u9 :: u0 -> u0) (ua :: u0 -> u0) (ub :: u0 -> u0) (uc :: u0 -> u0) (ud :: u0 -> u0) (ue :: u0 -> u0) (uf :: u0 -> u0) (ug :: u0 -> u0) (uh :: u0 -> u0) (ui :: u0 -> u0) (uj :: u0 -> u0) (uk :: u0 -> u0) -> ua; _NO_DEFLT_ } _N_
- {-defm-} _A_ 2 _U_ 02 _N_ _S_ _!_ _F_ _IF_ARGS_ 1 2 XX 3 _/\_ u0 -> \ (u1 :: {{Floating u0}}) (u2 :: u0) -> _APP_ _TYAPP_ patError# { (u0 -> u0) } [ _NOREP_S_ "%DPreludeCore.Floating.cos\"", u2 ] _N_ #-}
+ {-defm-} _A_ 2 _U_ 02 _N_ _S_ _!_ _N_ _N_ #-}
tan :: a -> a
{-# GHC_PRAGMA {-meth-} _A_ 1 _U_ 12 _N_ _S_ "S" _F_ _IF_ARGS_ 1 1 C 2 _/\_ u0 -> \ (u1 :: ({{Fractional u0}}, u0, u0 -> u0, u0 -> u0, u0 -> u0, u0 -> u0 -> u0, u0 -> u0 -> u0, u0 -> u0, u0 -> u0, u0 -> u0, u0 -> u0, u0 -> u0, u0 -> u0, u0 -> u0, u0 -> u0, u0 -> u0, u0 -> u0, u0 -> u0, u0 -> u0)) -> case u1 of { _ALG_ _TUP_19 (u2 :: {{Fractional u0}}) (u3 :: u0) (u4 :: u0 -> u0) (u5 :: u0 -> u0) (u6 :: u0 -> u0) (u7 :: u0 -> u0 -> u0) (u8 :: u0 -> u0 -> u0) (u9 :: u0 -> u0) (ua :: u0 -> u0) (ub :: u0 -> u0) (uc :: u0 -> u0) (ud :: u0 -> u0) (ue :: u0 -> u0) (uf :: u0 -> u0) (ug :: u0 -> u0) (uh :: u0 -> u0) (ui :: u0 -> u0) (uj :: u0 -> u0) (uk :: u0 -> u0) -> ub; _NO_DEFLT_ } _N_
{-defm-} _A_ 2 _U_ 12 _N_ _S_ "SL" _N_ _N_ #-}
asin :: a -> a
{-# GHC_PRAGMA {-meth-} _A_ 1 _U_ 12 _N_ _S_ "S" _F_ _IF_ARGS_ 1 1 C 2 _/\_ u0 -> \ (u1 :: ({{Fractional u0}}, u0, u0 -> u0, u0 -> u0, u0 -> u0, u0 -> u0 -> u0, u0 -> u0 -> u0, u0 -> u0, u0 -> u0, u0 -> u0, u0 -> u0, u0 -> u0, u0 -> u0, u0 -> u0, u0 -> u0, u0 -> u0, u0 -> u0, u0 -> u0, u0 -> u0)) -> case u1 of { _ALG_ _TUP_19 (u2 :: {{Fractional u0}}) (u3 :: u0) (u4 :: u0 -> u0) (u5 :: u0 -> u0) (u6 :: u0 -> u0) (u7 :: u0 -> u0 -> u0) (u8 :: u0 -> u0 -> u0) (u9 :: u0 -> u0) (ua :: u0 -> u0) (ub :: u0 -> u0) (uc :: u0 -> u0) (ud :: u0 -> u0) (ue :: u0 -> u0) (uf :: u0 -> u0) (ug :: u0 -> u0) (uh :: u0 -> u0) (ui :: u0 -> u0) (uj :: u0 -> u0) (uk :: u0 -> u0) -> uc; _NO_DEFLT_ } _N_
- {-defm-} _A_ 2 _U_ 02 _N_ _S_ _!_ _F_ _IF_ARGS_ 1 2 XX 3 _/\_ u0 -> \ (u1 :: {{Floating u0}}) (u2 :: u0) -> _APP_ _TYAPP_ patError# { (u0 -> u0) } [ _NOREP_S_ "%DPreludeCore.Floating.asin\"", u2 ] _N_ #-}
+ {-defm-} _A_ 2 _U_ 02 _N_ _S_ _!_ _N_ _N_ #-}
acos :: a -> a
{-# GHC_PRAGMA {-meth-} _A_ 1 _U_ 12 _N_ _S_ "S" _F_ _IF_ARGS_ 1 1 C 2 _/\_ u0 -> \ (u1 :: ({{Fractional u0}}, u0, u0 -> u0, u0 -> u0, u0 -> u0, u0 -> u0 -> u0, u0 -> u0 -> u0, u0 -> u0, u0 -> u0, u0 -> u0, u0 -> u0, u0 -> u0, u0 -> u0, u0 -> u0, u0 -> u0, u0 -> u0, u0 -> u0, u0 -> u0, u0 -> u0)) -> case u1 of { _ALG_ _TUP_19 (u2 :: {{Fractional u0}}) (u3 :: u0) (u4 :: u0 -> u0) (u5 :: u0 -> u0) (u6 :: u0 -> u0) (u7 :: u0 -> u0 -> u0) (u8 :: u0 -> u0 -> u0) (u9 :: u0 -> u0) (ua :: u0 -> u0) (ub :: u0 -> u0) (uc :: u0 -> u0) (ud :: u0 -> u0) (ue :: u0 -> u0) (uf :: u0 -> u0) (ug :: u0 -> u0) (uh :: u0 -> u0) (ui :: u0 -> u0) (uj :: u0 -> u0) (uk :: u0 -> u0) -> ud; _NO_DEFLT_ } _N_
- {-defm-} _A_ 2 _U_ 02 _N_ _S_ _!_ _F_ _IF_ARGS_ 1 2 XX 3 _/\_ u0 -> \ (u1 :: {{Floating u0}}) (u2 :: u0) -> _APP_ _TYAPP_ patError# { (u0 -> u0) } [ _NOREP_S_ "%DPreludeCore.Floating.acos\"", u2 ] _N_ #-}
+ {-defm-} _A_ 2 _U_ 02 _N_ _S_ _!_ _N_ _N_ #-}
atan :: a -> a
{-# GHC_PRAGMA {-meth-} _A_ 1 _U_ 12 _N_ _S_ "S" _F_ _IF_ARGS_ 1 1 C 2 _/\_ u0 -> \ (u1 :: ({{Fractional u0}}, u0, u0 -> u0, u0 -> u0, u0 -> u0, u0 -> u0 -> u0, u0 -> u0 -> u0, u0 -> u0, u0 -> u0, u0 -> u0, u0 -> u0, u0 -> u0, u0 -> u0, u0 -> u0, u0 -> u0, u0 -> u0, u0 -> u0, u0 -> u0, u0 -> u0)) -> case u1 of { _ALG_ _TUP_19 (u2 :: {{Fractional u0}}) (u3 :: u0) (u4 :: u0 -> u0) (u5 :: u0 -> u0) (u6 :: u0 -> u0) (u7 :: u0 -> u0 -> u0) (u8 :: u0 -> u0 -> u0) (u9 :: u0 -> u0) (ua :: u0 -> u0) (ub :: u0 -> u0) (uc :: u0 -> u0) (ud :: u0 -> u0) (ue :: u0 -> u0) (uf :: u0 -> u0) (ug :: u0 -> u0) (uh :: u0 -> u0) (ui :: u0 -> u0) (uj :: u0 -> u0) (uk :: u0 -> u0) -> ue; _NO_DEFLT_ } _N_
- {-defm-} _A_ 2 _U_ 02 _N_ _S_ _!_ _F_ _IF_ARGS_ 1 2 XX 3 _/\_ u0 -> \ (u1 :: {{Floating u0}}) (u2 :: u0) -> _APP_ _TYAPP_ patError# { (u0 -> u0) } [ _NOREP_S_ "%DPreludeCore.Floating.atan\"", u2 ] _N_ #-}
+ {-defm-} _A_ 2 _U_ 02 _N_ _S_ _!_ _N_ _N_ #-}
sinh :: a -> a
{-# GHC_PRAGMA {-meth-} _A_ 1 _U_ 12 _N_ _S_ "S" _F_ _IF_ARGS_ 1 1 C 2 _/\_ u0 -> \ (u1 :: ({{Fractional u0}}, u0, u0 -> u0, u0 -> u0, u0 -> u0, u0 -> u0 -> u0, u0 -> u0 -> u0, u0 -> u0, u0 -> u0, u0 -> u0, u0 -> u0, u0 -> u0, u0 -> u0, u0 -> u0, u0 -> u0, u0 -> u0, u0 -> u0, u0 -> u0, u0 -> u0)) -> case u1 of { _ALG_ _TUP_19 (u2 :: {{Fractional u0}}) (u3 :: u0) (u4 :: u0 -> u0) (u5 :: u0 -> u0) (u6 :: u0 -> u0) (u7 :: u0 -> u0 -> u0) (u8 :: u0 -> u0 -> u0) (u9 :: u0 -> u0) (ua :: u0 -> u0) (ub :: u0 -> u0) (uc :: u0 -> u0) (ud :: u0 -> u0) (ue :: u0 -> u0) (uf :: u0 -> u0) (ug :: u0 -> u0) (uh :: u0 -> u0) (ui :: u0 -> u0) (uj :: u0 -> u0) (uk :: u0 -> u0) -> uf; _NO_DEFLT_ } _N_
- {-defm-} _A_ 2 _U_ 02 _N_ _S_ _!_ _F_ _IF_ARGS_ 1 2 XX 3 _/\_ u0 -> \ (u1 :: {{Floating u0}}) (u2 :: u0) -> _APP_ _TYAPP_ patError# { (u0 -> u0) } [ _NOREP_S_ "%DPreludeCore.Floating.sinh\"", u2 ] _N_ #-}
+ {-defm-} _A_ 2 _U_ 02 _N_ _S_ _!_ _N_ _N_ #-}
cosh :: a -> a
{-# GHC_PRAGMA {-meth-} _A_ 1 _U_ 12 _N_ _S_ "S" _F_ _IF_ARGS_ 1 1 C 2 _/\_ u0 -> \ (u1 :: ({{Fractional u0}}, u0, u0 -> u0, u0 -> u0, u0 -> u0, u0 -> u0 -> u0, u0 -> u0 -> u0, u0 -> u0, u0 -> u0, u0 -> u0, u0 -> u0, u0 -> u0, u0 -> u0, u0 -> u0, u0 -> u0, u0 -> u0, u0 -> u0, u0 -> u0, u0 -> u0)) -> case u1 of { _ALG_ _TUP_19 (u2 :: {{Fractional u0}}) (u3 :: u0) (u4 :: u0 -> u0) (u5 :: u0 -> u0) (u6 :: u0 -> u0) (u7 :: u0 -> u0 -> u0) (u8 :: u0 -> u0 -> u0) (u9 :: u0 -> u0) (ua :: u0 -> u0) (ub :: u0 -> u0) (uc :: u0 -> u0) (ud :: u0 -> u0) (ue :: u0 -> u0) (uf :: u0 -> u0) (ug :: u0 -> u0) (uh :: u0 -> u0) (ui :: u0 -> u0) (uj :: u0 -> u0) (uk :: u0 -> u0) -> ug; _NO_DEFLT_ } _N_
- {-defm-} _A_ 2 _U_ 02 _N_ _S_ _!_ _F_ _IF_ARGS_ 1 2 XX 3 _/\_ u0 -> \ (u1 :: {{Floating u0}}) (u2 :: u0) -> _APP_ _TYAPP_ patError# { (u0 -> u0) } [ _NOREP_S_ "%DPreludeCore.Floating.cosh\"", u2 ] _N_ #-}
+ {-defm-} _A_ 2 _U_ 02 _N_ _S_ _!_ _N_ _N_ #-}
tanh :: a -> a
{-# GHC_PRAGMA {-meth-} _A_ 1 _U_ 12 _N_ _S_ "S" _F_ _IF_ARGS_ 1 1 C 2 _/\_ u0 -> \ (u1 :: ({{Fractional u0}}, u0, u0 -> u0, u0 -> u0, u0 -> u0, u0 -> u0 -> u0, u0 -> u0 -> u0, u0 -> u0, u0 -> u0, u0 -> u0, u0 -> u0, u0 -> u0, u0 -> u0, u0 -> u0, u0 -> u0, u0 -> u0, u0 -> u0, u0 -> u0, u0 -> u0)) -> case u1 of { _ALG_ _TUP_19 (u2 :: {{Fractional u0}}) (u3 :: u0) (u4 :: u0 -> u0) (u5 :: u0 -> u0) (u6 :: u0 -> u0) (u7 :: u0 -> u0 -> u0) (u8 :: u0 -> u0 -> u0) (u9 :: u0 -> u0) (ua :: u0 -> u0) (ub :: u0 -> u0) (uc :: u0 -> u0) (ud :: u0 -> u0) (ue :: u0 -> u0) (uf :: u0 -> u0) (ug :: u0 -> u0) (uh :: u0 -> u0) (ui :: u0 -> u0) (uj :: u0 -> u0) (uk :: u0 -> u0) -> uh; _NO_DEFLT_ } _N_
{-defm-} _A_ 2 _U_ 12 _N_ _S_ "SL" _N_ _N_ #-}
asinh :: a -> a
{-# GHC_PRAGMA {-meth-} _A_ 1 _U_ 12 _N_ _S_ "S" _F_ _IF_ARGS_ 1 1 C 2 _/\_ u0 -> \ (u1 :: ({{Fractional u0}}, u0, u0 -> u0, u0 -> u0, u0 -> u0, u0 -> u0 -> u0, u0 -> u0 -> u0, u0 -> u0, u0 -> u0, u0 -> u0, u0 -> u0, u0 -> u0, u0 -> u0, u0 -> u0, u0 -> u0, u0 -> u0, u0 -> u0, u0 -> u0, u0 -> u0)) -> case u1 of { _ALG_ _TUP_19 (u2 :: {{Fractional u0}}) (u3 :: u0) (u4 :: u0 -> u0) (u5 :: u0 -> u0) (u6 :: u0 -> u0) (u7 :: u0 -> u0 -> u0) (u8 :: u0 -> u0 -> u0) (u9 :: u0 -> u0) (ua :: u0 -> u0) (ub :: u0 -> u0) (uc :: u0 -> u0) (ud :: u0 -> u0) (ue :: u0 -> u0) (uf :: u0 -> u0) (ug :: u0 -> u0) (uh :: u0 -> u0) (ui :: u0 -> u0) (uj :: u0 -> u0) (uk :: u0 -> u0) -> ui; _NO_DEFLT_ } _N_
- {-defm-} _A_ 2 _U_ 02 _N_ _S_ _!_ _F_ _IF_ARGS_ 1 2 XX 3 _/\_ u0 -> \ (u1 :: {{Floating u0}}) (u2 :: u0) -> _APP_ _TYAPP_ patError# { (u0 -> u0) } [ _NOREP_S_ "%DPreludeCore.Floating.asinh\"", u2 ] _N_ #-}
+ {-defm-} _A_ 2 _U_ 02 _N_ _S_ _!_ _N_ _N_ #-}
acosh :: a -> a
{-# GHC_PRAGMA {-meth-} _A_ 1 _U_ 12 _N_ _S_ "S" _F_ _IF_ARGS_ 1 1 C 2 _/\_ u0 -> \ (u1 :: ({{Fractional u0}}, u0, u0 -> u0, u0 -> u0, u0 -> u0, u0 -> u0 -> u0, u0 -> u0 -> u0, u0 -> u0, u0 -> u0, u0 -> u0, u0 -> u0, u0 -> u0, u0 -> u0, u0 -> u0, u0 -> u0, u0 -> u0, u0 -> u0, u0 -> u0, u0 -> u0)) -> case u1 of { _ALG_ _TUP_19 (u2 :: {{Fractional u0}}) (u3 :: u0) (u4 :: u0 -> u0) (u5 :: u0 -> u0) (u6 :: u0 -> u0) (u7 :: u0 -> u0 -> u0) (u8 :: u0 -> u0 -> u0) (u9 :: u0 -> u0) (ua :: u0 -> u0) (ub :: u0 -> u0) (uc :: u0 -> u0) (ud :: u0 -> u0) (ue :: u0 -> u0) (uf :: u0 -> u0) (ug :: u0 -> u0) (uh :: u0 -> u0) (ui :: u0 -> u0) (uj :: u0 -> u0) (uk :: u0 -> u0) -> uj; _NO_DEFLT_ } _N_
- {-defm-} _A_ 2 _U_ 02 _N_ _S_ _!_ _F_ _IF_ARGS_ 1 2 XX 3 _/\_ u0 -> \ (u1 :: {{Floating u0}}) (u2 :: u0) -> _APP_ _TYAPP_ patError# { (u0 -> u0) } [ _NOREP_S_ "%DPreludeCore.Floating.acosh\"", u2 ] _N_ #-}
+ {-defm-} _A_ 2 _U_ 02 _N_ _S_ _!_ _N_ _N_ #-}
atanh :: a -> a
{-# GHC_PRAGMA {-meth-} _A_ 1 _U_ 12 _N_ _S_ "S" _F_ _IF_ARGS_ 1 1 C 2 _/\_ u0 -> \ (u1 :: ({{Fractional u0}}, u0, u0 -> u0, u0 -> u0, u0 -> u0, u0 -> u0 -> u0, u0 -> u0 -> u0, u0 -> u0, u0 -> u0, u0 -> u0, u0 -> u0, u0 -> u0, u0 -> u0, u0 -> u0, u0 -> u0, u0 -> u0, u0 -> u0, u0 -> u0, u0 -> u0)) -> case u1 of { _ALG_ _TUP_19 (u2 :: {{Fractional u0}}) (u3 :: u0) (u4 :: u0 -> u0) (u5 :: u0 -> u0) (u6 :: u0 -> u0) (u7 :: u0 -> u0 -> u0) (u8 :: u0 -> u0 -> u0) (u9 :: u0 -> u0) (ua :: u0 -> u0) (ub :: u0 -> u0) (uc :: u0 -> u0) (ud :: u0 -> u0) (ue :: u0 -> u0) (uf :: u0 -> u0) (ug :: u0 -> u0) (uh :: u0 -> u0) (ui :: u0 -> u0) (uj :: u0 -> u0) (uk :: u0 -> u0) -> uk; _NO_DEFLT_ } _N_
- {-defm-} _A_ 2 _U_ 02 _N_ _S_ _!_ _F_ _IF_ARGS_ 1 2 XX 3 _/\_ u0 -> \ (u1 :: {{Floating u0}}) (u2 :: u0) -> _APP_ _TYAPP_ patError# { (u0 -> u0) } [ _NOREP_S_ "%DPreludeCore.Floating.atanh\"", u2 ] _N_ #-}
+ {-defm-} _A_ 2 _U_ 02 _N_ _S_ _!_ _N_ _N_ #-}
class (Num a) => Fractional a {-# GHC_PRAGMA {-superdicts-} _A_ 1 _U_ 1 _N_ _S_ "S" _F_ _IF_ARGS_ 1 1 C 2 _/\_ u0 -> \ (u1 :: ({{Num u0}}, u0 -> u0 -> u0, u0 -> u0, Ratio Integer -> u0)) -> case u1 of { _ALG_ _TUP_4 (u2 :: {{Num u0}}) (u3 :: u0 -> u0 -> u0) (u4 :: u0 -> u0) (u5 :: Ratio Integer -> u0) -> u2; _NO_DEFLT_ } _N_ #-} where
(/) :: a -> a -> a
{-# GHC_PRAGMA {-meth-} _A_ 1 _U_ 122 _N_ _S_ "S" _F_ _IF_ARGS_ 1 1 C 2 _/\_ u0 -> \ (u1 :: ({{Num u0}}, u0 -> u0 -> u0, u0 -> u0, Ratio Integer -> u0)) -> case u1 of { _ALG_ _TUP_4 (u2 :: {{Num u0}}) (u3 :: u0 -> u0 -> u0) (u4 :: u0 -> u0) (u5 :: Ratio Integer -> u0) -> u3; _NO_DEFLT_ } _N_
- {-defm-} _A_ 3 _U_ 022 _N_ _S_ _!_ _F_ _IF_ARGS_ 1 3 XXX 4 _/\_ u0 -> \ (u1 :: {{Fractional u0}}) (u2 :: u0) (u3 :: u0) -> _APP_ _TYAPP_ patError# { (u0 -> u0 -> u0) } [ _NOREP_S_ "%DPreludeCore.Fractional.(/)\"", u2, u3 ] _N_ #-}
+ {-defm-} _A_ 3 _U_ 022 _N_ _S_ _!_ _N_ _N_ #-}
recip :: a -> a
{-# GHC_PRAGMA {-meth-} _A_ 1 _U_ 12 _N_ _S_ "S" _F_ _IF_ARGS_ 1 1 C 2 _/\_ u0 -> \ (u1 :: ({{Num u0}}, u0 -> u0 -> u0, u0 -> u0, Ratio Integer -> u0)) -> case u1 of { _ALG_ _TUP_4 (u2 :: {{Num u0}}) (u3 :: u0 -> u0 -> u0) (u4 :: u0 -> u0) (u5 :: Ratio Integer -> u0) -> u4; _NO_DEFLT_ } _N_
{-defm-} _A_ 1 _U_ 12 _N_ _S_ "S" _N_ _N_ #-}
fromRational :: Ratio Integer -> a
{-# GHC_PRAGMA {-meth-} _A_ 1 _U_ 12 _N_ _S_ "S" _F_ _IF_ARGS_ 1 1 C 2 _/\_ u0 -> \ (u1 :: ({{Num u0}}, u0 -> u0 -> u0, u0 -> u0, Ratio Integer -> u0)) -> case u1 of { _ALG_ _TUP_4 (u2 :: {{Num u0}}) (u3 :: u0 -> u0 -> u0) (u4 :: u0 -> u0) (u5 :: Ratio Integer -> u0) -> u5; _NO_DEFLT_ } _N_
- {-defm-} _A_ 2 _U_ 02 _N_ _S_ _!_ _F_ _IF_ARGS_ 1 2 XX 3 _/\_ u0 -> \ (u1 :: {{Fractional u0}}) (u2 :: Ratio Integer) -> _APP_ _TYAPP_ patError# { (Ratio Integer -> u0) } [ _NOREP_S_ "%DPreludeCore.Fractional.fromRational\"", u2 ] _N_ #-}
+ {-defm-} _A_ 2 _U_ 02 _N_ _S_ _!_ _N_ _N_ #-}
class (Real a, Ix a) => Integral a {-# GHC_PRAGMA {-superdicts-} _A_ 1 _U_ 1 _N_ _S_ "S" _F_ _IF_ARGS_ 1 1 C 2 _/\_ u0 -> \ (u1 :: ({{Real u0}}, {{Ix u0}}, u0 -> u0 -> u0, u0 -> u0 -> u0, u0 -> u0 -> u0, u0 -> u0 -> u0, u0 -> u0 -> (u0, u0), u0 -> u0 -> (u0, u0), u0 -> Bool, u0 -> Bool, u0 -> Integer, u0 -> Int)) -> case u1 of { _ALG_ _TUP_12 (u2 :: {{Real u0}}) (u3 :: {{Ix u0}}) (u4 :: u0 -> u0 -> u0) (u5 :: u0 -> u0 -> u0) (u6 :: u0 -> u0 -> u0) (u7 :: u0 -> u0 -> u0) (u8 :: u0 -> u0 -> (u0, u0)) (u9 :: u0 -> u0 -> (u0, u0)) (ua :: u0 -> Bool) (ub :: u0 -> Bool) (uc :: u0 -> Integer) (ud :: u0 -> Int) -> u2; _NO_DEFLT_ } _N_, _A_ 1 _U_ 1 _N_ _S_ "S" _F_ _IF_ARGS_ 1 1 C 2 _/\_ u0 -> \ (u1 :: ({{Real u0}}, {{Ix u0}}, u0 -> u0 -> u0, u0 -> u0 -> u0, u0 -> u0 -> u0, u0 -> u0 -> u0, u0 -> u0 -> (u0, u0), u0 -> u0 -> (u0, u0), u0 -> Bool, u0 -> Bool, u0 -> Integer, u0 -> Int)) -> case u1 of { _ALG_ _TUP_12 (u2 :: {{Real u0}}) (u3 :: {{Ix u0}}) (u4 :: u0 -> u0 -> u0) (u5 :: u0 -> u0 -> u0) (u6 :: u0 -> u0 -> u0) (u7 :: u0 -> u0 -> u0) (u8 :: u0 -> u0 -> (u0, u0)) (u9 :: u0 -> u0 -> (u0, u0)) (ua :: u0 -> Bool) (ub :: u0 -> Bool) (uc :: u0 -> Integer) (ud :: u0 -> Int) -> u3; _NO_DEFLT_ } _N_ #-} where
quot :: a -> a -> a
{-# GHC_PRAGMA {-meth-} _A_ 1 _U_ 122 _N_ _S_ "S" _F_ _IF_ARGS_ 1 1 C 2 _/\_ u0 -> \ (u1 :: ({{Real u0}}, {{Ix u0}}, u0 -> u0 -> u0, u0 -> u0 -> u0, u0 -> u0 -> u0, u0 -> u0 -> u0, u0 -> u0 -> (u0, u0), u0 -> u0 -> (u0, u0), u0 -> Bool, u0 -> Bool, u0 -> Integer, u0 -> Int)) -> case u1 of { _ALG_ _TUP_12 (u2 :: {{Real u0}}) (u3 :: {{Ix u0}}) (u4 :: u0 -> u0 -> u0) (u5 :: u0 -> u0 -> u0) (u6 :: u0 -> u0 -> u0) (u7 :: u0 -> u0 -> u0) (u8 :: u0 -> u0 -> (u0, u0)) (u9 :: u0 -> u0 -> (u0, u0)) (ua :: u0 -> Bool) (ub :: u0 -> Bool) (uc :: u0 -> Integer) (ud :: u0 -> Int) -> u4; _NO_DEFLT_ } _N_
{-defm-} _A_ 3 _U_ 122 _N_ _S_ "SLL" _F_ _IF_ARGS_ 1 3 CXX 6 _/\_ u0 -> \ (u1 :: {{Integral u0}}) (u2 :: u0) (u3 :: u0) -> case case u1 of { _ALG_ _TUP_12 (u4 :: {{Real u0}}) (u5 :: {{Ix u0}}) (u6 :: u0 -> u0 -> u0) (u7 :: u0 -> u0 -> u0) (u8 :: u0 -> u0 -> u0) (u9 :: u0 -> u0 -> u0) (ua :: u0 -> u0 -> (u0, u0)) (ub :: u0 -> u0 -> (u0, u0)) (uc :: u0 -> Bool) (ud :: u0 -> Bool) (ue :: u0 -> Integer) (uf :: u0 -> Int) -> _APP_ ub [ u2, u3 ]; _NO_DEFLT_ } of { _ALG_ _TUP_2 (ug :: u0) (uh :: u0) -> uh; _NO_DEFLT_ } _N_ #-}
quotRem :: a -> a -> (a, a)
{-# GHC_PRAGMA {-meth-} _A_ 1 _U_ 122 _N_ _S_ "S" _F_ _IF_ARGS_ 1 1 C 2 _/\_ u0 -> \ (u1 :: ({{Real u0}}, {{Ix u0}}, u0 -> u0 -> u0, u0 -> u0 -> u0, u0 -> u0 -> u0, u0 -> u0 -> u0, u0 -> u0 -> (u0, u0), u0 -> u0 -> (u0, u0), u0 -> Bool, u0 -> Bool, u0 -> Integer, u0 -> Int)) -> case u1 of { _ALG_ _TUP_12 (u2 :: {{Real u0}}) (u3 :: {{Ix u0}}) (u4 :: u0 -> u0 -> u0) (u5 :: u0 -> u0 -> u0) (u6 :: u0 -> u0 -> u0) (u7 :: u0 -> u0 -> u0) (u8 :: u0 -> u0 -> (u0, u0)) (u9 :: u0 -> u0 -> (u0, u0)) (ua :: u0 -> Bool) (ub :: u0 -> Bool) (uc :: u0 -> Integer) (ud :: u0 -> Int) -> u8; _NO_DEFLT_ } _N_
- {-defm-} _A_ 3 _U_ 022 _N_ _S_ _!_ _F_ _IF_ARGS_ 1 3 XXX 4 _/\_ u0 -> \ (u1 :: {{Integral u0}}) (u2 :: u0) (u3 :: u0) -> _APP_ _TYAPP_ patError# { (u0 -> u0 -> (u0, u0)) } [ _NOREP_S_ "%DPreludeCore.Integral.quotRem\"", u2, u3 ] _N_ #-}
+ {-defm-} _A_ 3 _U_ 022 _N_ _S_ _!_ _N_ _N_ #-}
divMod :: a -> a -> (a, a)
{-# GHC_PRAGMA {-meth-} _A_ 1 _U_ 122 _N_ _S_ "S" _F_ _IF_ARGS_ 1 1 C 2 _/\_ u0 -> \ (u1 :: ({{Real u0}}, {{Ix u0}}, u0 -> u0 -> u0, u0 -> u0 -> u0, u0 -> u0 -> u0, u0 -> u0 -> u0, u0 -> u0 -> (u0, u0), u0 -> u0 -> (u0, u0), u0 -> Bool, u0 -> Bool, u0 -> Integer, u0 -> Int)) -> case u1 of { _ALG_ _TUP_12 (u2 :: {{Real u0}}) (u3 :: {{Ix u0}}) (u4 :: u0 -> u0 -> u0) (u5 :: u0 -> u0 -> u0) (u6 :: u0 -> u0 -> u0) (u7 :: u0 -> u0 -> u0) (u8 :: u0 -> u0 -> (u0, u0)) (u9 :: u0 -> u0 -> (u0, u0)) (ua :: u0 -> Bool) (ub :: u0 -> Bool) (uc :: u0 -> Integer) (ud :: u0 -> Int) -> u9; _NO_DEFLT_ } _N_
{-defm-} _A_ 1 _U_ 122 _N_ _S_ "S" _N_ _N_ #-}
{-defm-} _A_ 1 _U_ 12 _N_ _S_ "S" _N_ _N_ #-}
toInteger :: a -> Integer
{-# GHC_PRAGMA {-meth-} _A_ 1 _U_ 12 _N_ _S_ "S" _F_ _IF_ARGS_ 1 1 C 2 _/\_ u0 -> \ (u1 :: ({{Real u0}}, {{Ix u0}}, u0 -> u0 -> u0, u0 -> u0 -> u0, u0 -> u0 -> u0, u0 -> u0 -> u0, u0 -> u0 -> (u0, u0), u0 -> u0 -> (u0, u0), u0 -> Bool, u0 -> Bool, u0 -> Integer, u0 -> Int)) -> case u1 of { _ALG_ _TUP_12 (u2 :: {{Real u0}}) (u3 :: {{Ix u0}}) (u4 :: u0 -> u0 -> u0) (u5 :: u0 -> u0 -> u0) (u6 :: u0 -> u0 -> u0) (u7 :: u0 -> u0 -> u0) (u8 :: u0 -> u0 -> (u0, u0)) (u9 :: u0 -> u0 -> (u0, u0)) (ua :: u0 -> Bool) (ub :: u0 -> Bool) (uc :: u0 -> Integer) (ud :: u0 -> Int) -> uc; _NO_DEFLT_ } _N_
- {-defm-} _A_ 2 _U_ 02 _N_ _S_ _!_ _F_ _IF_ARGS_ 1 2 XX 3 _/\_ u0 -> \ (u1 :: {{Integral u0}}) (u2 :: u0) -> _APP_ _TYAPP_ patError# { (u0 -> Integer) } [ _NOREP_S_ "%DPreludeCore.Integral.toInteger\"", u2 ] _N_ #-}
+ {-defm-} _A_ 2 _U_ 02 _N_ _S_ _!_ _N_ _N_ #-}
toInt :: a -> Int
{-# GHC_PRAGMA {-meth-} _A_ 1 _U_ 12 _N_ _S_ "S" _F_ _IF_ARGS_ 1 1 C 2 _/\_ u0 -> \ (u1 :: ({{Real u0}}, {{Ix u0}}, u0 -> u0 -> u0, u0 -> u0 -> u0, u0 -> u0 -> u0, u0 -> u0 -> u0, u0 -> u0 -> (u0, u0), u0 -> u0 -> (u0, u0), u0 -> Bool, u0 -> Bool, u0 -> Integer, u0 -> Int)) -> case u1 of { _ALG_ _TUP_12 (u2 :: {{Real u0}}) (u3 :: {{Ix u0}}) (u4 :: u0 -> u0 -> u0) (u5 :: u0 -> u0 -> u0) (u6 :: u0 -> u0 -> u0) (u7 :: u0 -> u0 -> u0) (u8 :: u0 -> u0 -> (u0, u0)) (u9 :: u0 -> u0 -> (u0, u0)) (ua :: u0 -> Bool) (ub :: u0 -> Bool) (uc :: u0 -> Integer) (ud :: u0 -> Int) -> ud; _NO_DEFLT_ } _N_
- {-defm-} _A_ 2 _U_ 02 _N_ _S_ _!_ _F_ _IF_ARGS_ 1 2 XX 3 _/\_ u0 -> \ (u1 :: {{Integral u0}}) (u2 :: u0) -> _APP_ _TYAPP_ patError# { (u0 -> Int) } [ _NOREP_S_ "%DPreludeCore.Integral.toInt\"", u2 ] _N_ #-}
+ {-defm-} _A_ 2 _U_ 02 _N_ _S_ _!_ _N_ _N_ #-}
class (Ord a) => Ix a {-# GHC_PRAGMA {-superdicts-} _A_ 1 _U_ 1 _N_ _S_ "S" _F_ _IF_ARGS_ 1 1 C 2 _/\_ u0 -> \ (u1 :: ({{Ord u0}}, (u0, u0) -> [u0], (u0, u0) -> u0 -> Int, (u0, u0) -> u0 -> Bool)) -> case u1 of { _ALG_ _TUP_4 (u2 :: {{Ord u0}}) (u3 :: (u0, u0) -> [u0]) (u4 :: (u0, u0) -> u0 -> Int) (u5 :: (u0, u0) -> u0 -> Bool) -> u2; _NO_DEFLT_ } _N_ #-} where
range :: (a, a) -> [a]
{-# GHC_PRAGMA {-meth-} _A_ 1 _U_ 12 _N_ _S_ "S" _F_ _IF_ARGS_ 1 1 C 2 _/\_ u0 -> \ (u1 :: ({{Ord u0}}, (u0, u0) -> [u0], (u0, u0) -> u0 -> Int, (u0, u0) -> u0 -> Bool)) -> case u1 of { _ALG_ _TUP_4 (u2 :: {{Ord u0}}) (u3 :: (u0, u0) -> [u0]) (u4 :: (u0, u0) -> u0 -> Int) (u5 :: (u0, u0) -> u0 -> Bool) -> u3; _NO_DEFLT_ } _N_
- {-defm-} _A_ 2 _U_ 02 _N_ _S_ _!_ _F_ _IF_ARGS_ 1 2 XX 3 _/\_ u0 -> \ (u1 :: {{Ix u0}}) (u2 :: (u0, u0)) -> _APP_ _TYAPP_ patError# { ((u0, u0) -> [u0]) } [ _NOREP_S_ "%DPreludeCore.Ix.range\"", u2 ] _N_ #-}
+ {-defm-} _A_ 2 _U_ 02 _N_ _S_ _!_ _N_ _N_ #-}
index :: (a, a) -> a -> Int
{-# GHC_PRAGMA {-meth-} _A_ 1 _U_ 122 _N_ _S_ "S" _F_ _IF_ARGS_ 1 1 C 2 _/\_ u0 -> \ (u1 :: ({{Ord u0}}, (u0, u0) -> [u0], (u0, u0) -> u0 -> Int, (u0, u0) -> u0 -> Bool)) -> case u1 of { _ALG_ _TUP_4 (u2 :: {{Ord u0}}) (u3 :: (u0, u0) -> [u0]) (u4 :: (u0, u0) -> u0 -> Int) (u5 :: (u0, u0) -> u0 -> Bool) -> u4; _NO_DEFLT_ } _N_
- {-defm-} _A_ 3 _U_ 022 _N_ _S_ _!_ _F_ _IF_ARGS_ 1 3 XXX 4 _/\_ u0 -> \ (u1 :: {{Ix u0}}) (u2 :: (u0, u0)) (u3 :: u0) -> _APP_ _TYAPP_ patError# { ((u0, u0) -> u0 -> Int) } [ _NOREP_S_ "%DPreludeCore.Ix.index\"", u2, u3 ] _N_ #-}
+ {-defm-} _A_ 3 _U_ 022 _N_ _S_ _!_ _N_ _N_ #-}
inRange :: (a, a) -> a -> Bool
{-# GHC_PRAGMA {-meth-} _A_ 1 _U_ 122 _N_ _S_ "S" _F_ _IF_ARGS_ 1 1 C 2 _/\_ u0 -> \ (u1 :: ({{Ord u0}}, (u0, u0) -> [u0], (u0, u0) -> u0 -> Int, (u0, u0) -> u0 -> Bool)) -> case u1 of { _ALG_ _TUP_4 (u2 :: {{Ord u0}}) (u3 :: (u0, u0) -> [u0]) (u4 :: (u0, u0) -> u0 -> Int) (u5 :: (u0, u0) -> u0 -> Bool) -> u5; _NO_DEFLT_ } _N_
- {-defm-} _A_ 3 _U_ 022 _N_ _S_ _!_ _F_ _IF_ARGS_ 1 3 XXX 4 _/\_ u0 -> \ (u1 :: {{Ix u0}}) (u2 :: (u0, u0)) (u3 :: u0) -> _APP_ _TYAPP_ patError# { ((u0, u0) -> u0 -> Bool) } [ _NOREP_S_ "%DPreludeCore.Ix.inRange\"", u2, u3 ] _N_ #-}
+ {-defm-} _A_ 3 _U_ 022 _N_ _S_ _!_ _N_ _N_ #-}
class (Eq a, Text a) => Num a {-# GHC_PRAGMA {-superdicts-} _A_ 1 _U_ 1 _N_ _S_ "S" _F_ _IF_ARGS_ 1 1 C 2 _/\_ u0 -> \ (u1 :: ({{Eq u0}}, {{Text u0}}, u0 -> u0 -> u0, u0 -> u0 -> u0, u0 -> u0 -> u0, u0 -> u0, u0 -> u0, u0 -> u0, Integer -> u0, Int -> u0)) -> case u1 of { _ALG_ _TUP_10 (u2 :: {{Eq u0}}) (u3 :: {{Text u0}}) (u4 :: u0 -> u0 -> u0) (u5 :: u0 -> u0 -> u0) (u6 :: u0 -> u0 -> u0) (u7 :: u0 -> u0) (u8 :: u0 -> u0) (u9 :: u0 -> u0) (ua :: Integer -> u0) (ub :: Int -> u0) -> u2; _NO_DEFLT_ } _N_, _A_ 1 _U_ 1 _N_ _S_ "S" _F_ _IF_ARGS_ 1 1 C 2 _/\_ u0 -> \ (u1 :: ({{Eq u0}}, {{Text u0}}, u0 -> u0 -> u0, u0 -> u0 -> u0, u0 -> u0 -> u0, u0 -> u0, u0 -> u0, u0 -> u0, Integer -> u0, Int -> u0)) -> case u1 of { _ALG_ _TUP_10 (u2 :: {{Eq u0}}) (u3 :: {{Text u0}}) (u4 :: u0 -> u0 -> u0) (u5 :: u0 -> u0 -> u0) (u6 :: u0 -> u0 -> u0) (u7 :: u0 -> u0) (u8 :: u0 -> u0) (u9 :: u0 -> u0) (ua :: Integer -> u0) (ub :: Int -> u0) -> u3; _NO_DEFLT_ } _N_ #-} where
(+) :: a -> a -> a
{-# GHC_PRAGMA {-meth-} _A_ 1 _U_ 122 _N_ _S_ "S" _F_ _IF_ARGS_ 1 1 C 2 _/\_ u0 -> \ (u1 :: ({{Eq u0}}, {{Text u0}}, u0 -> u0 -> u0, u0 -> u0 -> u0, u0 -> u0 -> u0, u0 -> u0, u0 -> u0, u0 -> u0, Integer -> u0, Int -> u0)) -> case u1 of { _ALG_ _TUP_10 (u2 :: {{Eq u0}}) (u3 :: {{Text u0}}) (u4 :: u0 -> u0 -> u0) (u5 :: u0 -> u0 -> u0) (u6 :: u0 -> u0 -> u0) (u7 :: u0 -> u0) (u8 :: u0 -> u0) (u9 :: u0 -> u0) (ua :: Integer -> u0) (ub :: Int -> u0) -> u4; _NO_DEFLT_ } _N_
- {-defm-} _A_ 3 _U_ 022 _N_ _S_ _!_ _F_ _IF_ARGS_ 1 3 XXX 4 _/\_ u0 -> \ (u1 :: {{Num u0}}) (u2 :: u0) (u3 :: u0) -> _APP_ _TYAPP_ patError# { (u0 -> u0 -> u0) } [ _NOREP_S_ "%DPreludeCore.Num.(+)\"", u2, u3 ] _N_ #-}
+ {-defm-} _A_ 3 _U_ 022 _N_ _S_ _!_ _N_ _N_ #-}
(-) :: a -> a -> a
{-# GHC_PRAGMA {-meth-} _A_ 1 _U_ 122 _N_ _S_ "S" _F_ _IF_ARGS_ 1 1 C 2 _/\_ u0 -> \ (u1 :: ({{Eq u0}}, {{Text u0}}, u0 -> u0 -> u0, u0 -> u0 -> u0, u0 -> u0 -> u0, u0 -> u0, u0 -> u0, u0 -> u0, Integer -> u0, Int -> u0)) -> case u1 of { _ALG_ _TUP_10 (u2 :: {{Eq u0}}) (u3 :: {{Text u0}}) (u4 :: u0 -> u0 -> u0) (u5 :: u0 -> u0 -> u0) (u6 :: u0 -> u0 -> u0) (u7 :: u0 -> u0) (u8 :: u0 -> u0) (u9 :: u0 -> u0) (ua :: Integer -> u0) (ub :: Int -> u0) -> u5; _NO_DEFLT_ } _N_
{-defm-} _A_ 3 _U_ 122 _N_ _S_ "SLL" _F_ _ALWAYS_ _/\_ u0 -> \ (u1 :: {{Num u0}}) (u2 :: u0) (u3 :: u0) -> case u1 of { _ALG_ _TUP_10 (u4 :: {{Eq u0}}) (u5 :: {{Text u0}}) (u6 :: u0 -> u0 -> u0) (u7 :: u0 -> u0 -> u0) (u8 :: u0 -> u0 -> u0) (u9 :: u0 -> u0) (ua :: u0 -> u0) (ub :: u0 -> u0) (uc :: Integer -> u0) (ud :: Int -> u0) -> let {(ue :: u0) = _APP_ u9 [ u3 ]} in _APP_ u6 [ u2, ue ]; _NO_DEFLT_ } _N_ #-}
(*) :: a -> a -> a
{-# GHC_PRAGMA {-meth-} _A_ 1 _U_ 122 _N_ _S_ "S" _F_ _IF_ARGS_ 1 1 C 2 _/\_ u0 -> \ (u1 :: ({{Eq u0}}, {{Text u0}}, u0 -> u0 -> u0, u0 -> u0 -> u0, u0 -> u0 -> u0, u0 -> u0, u0 -> u0, u0 -> u0, Integer -> u0, Int -> u0)) -> case u1 of { _ALG_ _TUP_10 (u2 :: {{Eq u0}}) (u3 :: {{Text u0}}) (u4 :: u0 -> u0 -> u0) (u5 :: u0 -> u0 -> u0) (u6 :: u0 -> u0 -> u0) (u7 :: u0 -> u0) (u8 :: u0 -> u0) (u9 :: u0 -> u0) (ua :: Integer -> u0) (ub :: Int -> u0) -> u6; _NO_DEFLT_ } _N_
- {-defm-} _A_ 3 _U_ 022 _N_ _S_ _!_ _F_ _IF_ARGS_ 1 3 XXX 4 _/\_ u0 -> \ (u1 :: {{Num u0}}) (u2 :: u0) (u3 :: u0) -> _APP_ _TYAPP_ patError# { (u0 -> u0 -> u0) } [ _NOREP_S_ "%DPreludeCore.Num.(*)\"", u2, u3 ] _N_ #-}
+ {-defm-} _A_ 3 _U_ 022 _N_ _S_ _!_ _N_ _N_ #-}
negate :: a -> a
{-# GHC_PRAGMA {-meth-} _A_ 1 _U_ 12 _N_ _S_ "S" _F_ _IF_ARGS_ 1 1 C 2 _/\_ u0 -> \ (u1 :: ({{Eq u0}}, {{Text u0}}, u0 -> u0 -> u0, u0 -> u0 -> u0, u0 -> u0 -> u0, u0 -> u0, u0 -> u0, u0 -> u0, Integer -> u0, Int -> u0)) -> case u1 of { _ALG_ _TUP_10 (u2 :: {{Eq u0}}) (u3 :: {{Text u0}}) (u4 :: u0 -> u0 -> u0) (u5 :: u0 -> u0 -> u0) (u6 :: u0 -> u0 -> u0) (u7 :: u0 -> u0) (u8 :: u0 -> u0) (u9 :: u0 -> u0) (ua :: Integer -> u0) (ub :: Int -> u0) -> u7; _NO_DEFLT_ } _N_
- {-defm-} _A_ 2 _U_ 02 _N_ _S_ _!_ _F_ _IF_ARGS_ 1 2 XX 3 _/\_ u0 -> \ (u1 :: {{Num u0}}) (u2 :: u0) -> _APP_ _TYAPP_ patError# { (u0 -> u0) } [ _NOREP_S_ "%DPreludeCore.Num.negate\"", u2 ] _N_ #-}
+ {-defm-} _A_ 2 _U_ 02 _N_ _S_ _!_ _N_ _N_ #-}
abs :: a -> a
{-# GHC_PRAGMA {-meth-} _A_ 1 _U_ 12 _N_ _S_ "S" _F_ _IF_ARGS_ 1 1 C 2 _/\_ u0 -> \ (u1 :: ({{Eq u0}}, {{Text u0}}, u0 -> u0 -> u0, u0 -> u0 -> u0, u0 -> u0 -> u0, u0 -> u0, u0 -> u0, u0 -> u0, Integer -> u0, Int -> u0)) -> case u1 of { _ALG_ _TUP_10 (u2 :: {{Eq u0}}) (u3 :: {{Text u0}}) (u4 :: u0 -> u0 -> u0) (u5 :: u0 -> u0 -> u0) (u6 :: u0 -> u0 -> u0) (u7 :: u0 -> u0) (u8 :: u0 -> u0) (u9 :: u0 -> u0) (ua :: Integer -> u0) (ub :: Int -> u0) -> u8; _NO_DEFLT_ } _N_
- {-defm-} _A_ 2 _U_ 02 _N_ _S_ _!_ _F_ _IF_ARGS_ 1 2 XX 3 _/\_ u0 -> \ (u1 :: {{Num u0}}) (u2 :: u0) -> _APP_ _TYAPP_ patError# { (u0 -> u0) } [ _NOREP_S_ "%DPreludeCore.Num.abs\"", u2 ] _N_ #-}
+ {-defm-} _A_ 2 _U_ 02 _N_ _S_ _!_ _N_ _N_ #-}
signum :: a -> a
{-# GHC_PRAGMA {-meth-} _A_ 1 _U_ 12 _N_ _S_ "S" _F_ _IF_ARGS_ 1 1 C 2 _/\_ u0 -> \ (u1 :: ({{Eq u0}}, {{Text u0}}, u0 -> u0 -> u0, u0 -> u0 -> u0, u0 -> u0 -> u0, u0 -> u0, u0 -> u0, u0 -> u0, Integer -> u0, Int -> u0)) -> case u1 of { _ALG_ _TUP_10 (u2 :: {{Eq u0}}) (u3 :: {{Text u0}}) (u4 :: u0 -> u0 -> u0) (u5 :: u0 -> u0 -> u0) (u6 :: u0 -> u0 -> u0) (u7 :: u0 -> u0) (u8 :: u0 -> u0) (u9 :: u0 -> u0) (ua :: Integer -> u0) (ub :: Int -> u0) -> u9; _NO_DEFLT_ } _N_
- {-defm-} _A_ 2 _U_ 02 _N_ _S_ _!_ _F_ _IF_ARGS_ 1 2 XX 3 _/\_ u0 -> \ (u1 :: {{Num u0}}) (u2 :: u0) -> _APP_ _TYAPP_ patError# { (u0 -> u0) } [ _NOREP_S_ "%DPreludeCore.Num.signum\"", u2 ] _N_ #-}
+ {-defm-} _A_ 2 _U_ 02 _N_ _S_ _!_ _N_ _N_ #-}
fromInteger :: Integer -> a
{-# GHC_PRAGMA {-meth-} _A_ 1 _U_ 12 _N_ _S_ "S" _F_ _IF_ARGS_ 1 1 C 2 _/\_ u0 -> \ (u1 :: ({{Eq u0}}, {{Text u0}}, u0 -> u0 -> u0, u0 -> u0 -> u0, u0 -> u0 -> u0, u0 -> u0, u0 -> u0, u0 -> u0, Integer -> u0, Int -> u0)) -> case u1 of { _ALG_ _TUP_10 (u2 :: {{Eq u0}}) (u3 :: {{Text u0}}) (u4 :: u0 -> u0 -> u0) (u5 :: u0 -> u0 -> u0) (u6 :: u0 -> u0 -> u0) (u7 :: u0 -> u0) (u8 :: u0 -> u0) (u9 :: u0 -> u0) (ua :: Integer -> u0) (ub :: Int -> u0) -> ua; _NO_DEFLT_ } _N_
- {-defm-} _A_ 2 _U_ 02 _N_ _S_ _!_ _F_ _IF_ARGS_ 1 2 XX 3 _/\_ u0 -> \ (u1 :: {{Num u0}}) (u2 :: Integer) -> _APP_ _TYAPP_ patError# { (Integer -> u0) } [ _NOREP_S_ "%DPreludeCore.Num.fromInteger\"", u2 ] _N_ #-}
+ {-defm-} _A_ 2 _U_ 02 _N_ _S_ _!_ _N_ _N_ #-}
fromInt :: Int -> a
{-# GHC_PRAGMA {-meth-} _A_ 1 _U_ 12 _N_ _S_ "S" _F_ _IF_ARGS_ 1 1 C 2 _/\_ u0 -> \ (u1 :: ({{Eq u0}}, {{Text u0}}, u0 -> u0 -> u0, u0 -> u0 -> u0, u0 -> u0 -> u0, u0 -> u0, u0 -> u0, u0 -> u0, Integer -> u0, Int -> u0)) -> case u1 of { _ALG_ _TUP_10 (u2 :: {{Eq u0}}) (u3 :: {{Text u0}}) (u4 :: u0 -> u0 -> u0) (u5 :: u0 -> u0 -> u0) (u6 :: u0 -> u0 -> u0) (u7 :: u0 -> u0) (u8 :: u0 -> u0) (u9 :: u0 -> u0) (ua :: Integer -> u0) (ub :: Int -> u0) -> ub; _NO_DEFLT_ } _N_
{-defm-} _A_ 2 _U_ 11 _N_ _S_ "SL" _F_ _IF_ARGS_ 1 2 CC 6 _/\_ u0 -> \ (u1 :: {{Num u0}}) (u2 :: Int) -> let {(u4 :: Integer) = case u2 of { _ALG_ I# (u3 :: Int#) -> _#_ int2Integer# [] [u3]; _NO_DEFLT_ }} in case u1 of { _ALG_ _TUP_10 (u5 :: {{Eq u0}}) (u6 :: {{Text u0}}) (u7 :: u0 -> u0 -> u0) (u8 :: u0 -> u0 -> u0) (u9 :: u0 -> u0 -> u0) (ua :: u0 -> u0) (ub :: u0 -> u0) (uc :: u0 -> u0) (ud :: Integer -> u0) (ue :: Int -> u0) -> _APP_ ud [ u4 ]; _NO_DEFLT_ } _N_ #-}
{-defm-} _A_ 3 _U_ 122 _N_ _S_ "SLL" _N_ _N_ #-}
(<=) :: a -> a -> Bool
{-# GHC_PRAGMA {-meth-} _A_ 1 _U_ 122 _N_ _S_ "S" _F_ _IF_ARGS_ 1 1 C 2 _/\_ u0 -> \ (u1 :: ({{Eq u0}}, u0 -> u0 -> Bool, u0 -> u0 -> Bool, u0 -> u0 -> Bool, u0 -> u0 -> Bool, u0 -> u0 -> u0, u0 -> u0 -> u0, u0 -> u0 -> _CMP_TAG)) -> case u1 of { _ALG_ _TUP_8 (u2 :: {{Eq u0}}) (u3 :: u0 -> u0 -> Bool) (u4 :: u0 -> u0 -> Bool) (u5 :: u0 -> u0 -> Bool) (u6 :: u0 -> u0 -> Bool) (u7 :: u0 -> u0 -> u0) (u8 :: u0 -> u0 -> u0) (u9 :: u0 -> u0 -> _CMP_TAG) -> u4; _NO_DEFLT_ } _N_
- {-defm-} _A_ 3 _U_ 022 _N_ _S_ _!_ _F_ _IF_ARGS_ 1 3 XXX 4 _/\_ u0 -> \ (u1 :: {{Ord u0}}) (u2 :: u0) (u3 :: u0) -> _APP_ _TYAPP_ patError# { (u0 -> u0 -> Bool) } [ _NOREP_S_ "%DPreludeCore.Ord.(<=)\"", u2, u3 ] _N_ #-}
+ {-defm-} _A_ 3 _U_ 022 _N_ _S_ _!_ _N_ _N_ #-}
(>=) :: a -> a -> Bool
{-# GHC_PRAGMA {-meth-} _A_ 1 _U_ 122 _N_ _S_ "S" _F_ _IF_ARGS_ 1 1 C 2 _/\_ u0 -> \ (u1 :: ({{Eq u0}}, u0 -> u0 -> Bool, u0 -> u0 -> Bool, u0 -> u0 -> Bool, u0 -> u0 -> Bool, u0 -> u0 -> u0, u0 -> u0 -> u0, u0 -> u0 -> _CMP_TAG)) -> case u1 of { _ALG_ _TUP_8 (u2 :: {{Eq u0}}) (u3 :: u0 -> u0 -> Bool) (u4 :: u0 -> u0 -> Bool) (u5 :: u0 -> u0 -> Bool) (u6 :: u0 -> u0 -> Bool) (u7 :: u0 -> u0 -> u0) (u8 :: u0 -> u0 -> u0) (u9 :: u0 -> u0 -> _CMP_TAG) -> u5; _NO_DEFLT_ } _N_
{-defm-} _A_ 3 _U_ 122 _N_ _S_ "SLL" _F_ _IF_ARGS_ 1 3 CXX 4 _/\_ u0 -> \ (u1 :: {{Ord u0}}) (u2 :: u0) (u3 :: u0) -> case u1 of { _ALG_ _TUP_8 (u4 :: {{Eq u0}}) (u5 :: u0 -> u0 -> Bool) (u6 :: u0 -> u0 -> Bool) (u7 :: u0 -> u0 -> Bool) (u8 :: u0 -> u0 -> Bool) (u9 :: u0 -> u0 -> u0) (ua :: u0 -> u0 -> u0) (ub :: u0 -> u0 -> _CMP_TAG) -> _APP_ u6 [ u3, u2 ]; _NO_DEFLT_ } _N_ #-}
class (Num a, Enum a) => Real a {-# GHC_PRAGMA {-superdicts-} _A_ 1 _U_ 1 _N_ _S_ "S" _F_ _IF_ARGS_ 1 1 C 2 _/\_ u0 -> \ (u1 :: ({{Num u0}}, {{Enum u0}}, u0 -> Ratio Integer)) -> case u1 of { _ALG_ _TUP_3 (u2 :: {{Num u0}}) (u3 :: {{Enum u0}}) (u4 :: u0 -> Ratio Integer) -> u2; _NO_DEFLT_ } _N_, _A_ 1 _U_ 1 _N_ _S_ "S" _F_ _IF_ARGS_ 1 1 C 2 _/\_ u0 -> \ (u1 :: ({{Num u0}}, {{Enum u0}}, u0 -> Ratio Integer)) -> case u1 of { _ALG_ _TUP_3 (u2 :: {{Num u0}}) (u3 :: {{Enum u0}}) (u4 :: u0 -> Ratio Integer) -> u3; _NO_DEFLT_ } _N_ #-} where
toRational :: a -> Ratio Integer
{-# GHC_PRAGMA {-meth-} _A_ 1 _U_ 12 _N_ _S_ "S" _F_ _IF_ARGS_ 1 1 C 2 _/\_ u0 -> \ (u1 :: ({{Num u0}}, {{Enum u0}}, u0 -> Ratio Integer)) -> case u1 of { _ALG_ _TUP_3 (u2 :: {{Num u0}}) (u3 :: {{Enum u0}}) (u4 :: u0 -> Ratio Integer) -> u4; _NO_DEFLT_ } _N_
- {-defm-} _A_ 2 _U_ 02 _N_ _S_ _!_ _F_ _IF_ARGS_ 1 2 XX 3 _/\_ u0 -> \ (u1 :: {{Real u0}}) (u2 :: u0) -> _APP_ _TYAPP_ patError# { (u0 -> Ratio Integer) } [ _NOREP_S_ "%DPreludeCore.Real.toRational\"", u2 ] _N_ #-}
+ {-defm-} _A_ 2 _U_ 02 _N_ _S_ _!_ _N_ _N_ #-}
class (RealFrac a, Floating a) => RealFloat a {-# GHC_PRAGMA {-superdicts-} _A_ 1 _U_ 1 _N_ _S_ "S" _F_ _IF_ARGS_ 1 1 C 2 _/\_ u0 -> \ (u1 :: ({{RealFrac u0}}, {{Floating u0}}, u0 -> Integer, u0 -> Int, u0 -> (Int, Int), u0 -> (Integer, Int), Integer -> Int -> u0, u0 -> Int, u0 -> u0, Int -> u0 -> u0)) -> case u1 of { _ALG_ _TUP_10 (u2 :: {{RealFrac u0}}) (u3 :: {{Floating u0}}) (u4 :: u0 -> Integer) (u5 :: u0 -> Int) (u6 :: u0 -> (Int, Int)) (u7 :: u0 -> (Integer, Int)) (u8 :: Integer -> Int -> u0) (u9 :: u0 -> Int) (ua :: u0 -> u0) (ub :: Int -> u0 -> u0) -> u2; _NO_DEFLT_ } _N_, _A_ 1 _U_ 1 _N_ _S_ "S" _F_ _IF_ARGS_ 1 1 C 2 _/\_ u0 -> \ (u1 :: ({{RealFrac u0}}, {{Floating u0}}, u0 -> Integer, u0 -> Int, u0 -> (Int, Int), u0 -> (Integer, Int), Integer -> Int -> u0, u0 -> Int, u0 -> u0, Int -> u0 -> u0)) -> case u1 of { _ALG_ _TUP_10 (u2 :: {{RealFrac u0}}) (u3 :: {{Floating u0}}) (u4 :: u0 -> Integer) (u5 :: u0 -> Int) (u6 :: u0 -> (Int, Int)) (u7 :: u0 -> (Integer, Int)) (u8 :: Integer -> Int -> u0) (u9 :: u0 -> Int) (ua :: u0 -> u0) (ub :: Int -> u0 -> u0) -> u3; _NO_DEFLT_ } _N_ #-} where
floatRadix :: a -> Integer
{-# GHC_PRAGMA {-meth-} _A_ 1 _U_ 12 _N_ _S_ "S" _F_ _IF_ARGS_ 1 1 C 2 _/\_ u0 -> \ (u1 :: ({{RealFrac u0}}, {{Floating u0}}, u0 -> Integer, u0 -> Int, u0 -> (Int, Int), u0 -> (Integer, Int), Integer -> Int -> u0, u0 -> Int, u0 -> u0, Int -> u0 -> u0)) -> case u1 of { _ALG_ _TUP_10 (u2 :: {{RealFrac u0}}) (u3 :: {{Floating u0}}) (u4 :: u0 -> Integer) (u5 :: u0 -> Int) (u6 :: u0 -> (Int, Int)) (u7 :: u0 -> (Integer, Int)) (u8 :: Integer -> Int -> u0) (u9 :: u0 -> Int) (ua :: u0 -> u0) (ub :: Int -> u0 -> u0) -> u4; _NO_DEFLT_ } _N_
- {-defm-} _A_ 2 _U_ 02 _N_ _S_ _!_ _F_ _IF_ARGS_ 1 2 XX 3 _/\_ u0 -> \ (u1 :: {{RealFloat u0}}) (u2 :: u0) -> _APP_ _TYAPP_ patError# { (u0 -> Integer) } [ _NOREP_S_ "%DPreludeCore.RealFloat.floatRadix\"", u2 ] _N_ #-}
+ {-defm-} _A_ 2 _U_ 02 _N_ _S_ _!_ _N_ _N_ #-}
floatDigits :: a -> Int
{-# GHC_PRAGMA {-meth-} _A_ 1 _U_ 12 _N_ _S_ "S" _F_ _IF_ARGS_ 1 1 C 2 _/\_ u0 -> \ (u1 :: ({{RealFrac u0}}, {{Floating u0}}, u0 -> Integer, u0 -> Int, u0 -> (Int, Int), u0 -> (Integer, Int), Integer -> Int -> u0, u0 -> Int, u0 -> u0, Int -> u0 -> u0)) -> case u1 of { _ALG_ _TUP_10 (u2 :: {{RealFrac u0}}) (u3 :: {{Floating u0}}) (u4 :: u0 -> Integer) (u5 :: u0 -> Int) (u6 :: u0 -> (Int, Int)) (u7 :: u0 -> (Integer, Int)) (u8 :: Integer -> Int -> u0) (u9 :: u0 -> Int) (ua :: u0 -> u0) (ub :: Int -> u0 -> u0) -> u5; _NO_DEFLT_ } _N_
- {-defm-} _A_ 2 _U_ 02 _N_ _S_ _!_ _F_ _IF_ARGS_ 1 2 XX 3 _/\_ u0 -> \ (u1 :: {{RealFloat u0}}) (u2 :: u0) -> _APP_ _TYAPP_ patError# { (u0 -> Int) } [ _NOREP_S_ "%DPreludeCore.RealFloat.floatDigits\"", u2 ] _N_ #-}
+ {-defm-} _A_ 2 _U_ 02 _N_ _S_ _!_ _N_ _N_ #-}
floatRange :: a -> (Int, Int)
{-# GHC_PRAGMA {-meth-} _A_ 1 _U_ 12 _N_ _S_ "S" _F_ _IF_ARGS_ 1 1 C 2 _/\_ u0 -> \ (u1 :: ({{RealFrac u0}}, {{Floating u0}}, u0 -> Integer, u0 -> Int, u0 -> (Int, Int), u0 -> (Integer, Int), Integer -> Int -> u0, u0 -> Int, u0 -> u0, Int -> u0 -> u0)) -> case u1 of { _ALG_ _TUP_10 (u2 :: {{RealFrac u0}}) (u3 :: {{Floating u0}}) (u4 :: u0 -> Integer) (u5 :: u0 -> Int) (u6 :: u0 -> (Int, Int)) (u7 :: u0 -> (Integer, Int)) (u8 :: Integer -> Int -> u0) (u9 :: u0 -> Int) (ua :: u0 -> u0) (ub :: Int -> u0 -> u0) -> u6; _NO_DEFLT_ } _N_
- {-defm-} _A_ 2 _U_ 02 _N_ _S_ _!_ _F_ _IF_ARGS_ 1 2 XX 3 _/\_ u0 -> \ (u1 :: {{RealFloat u0}}) (u2 :: u0) -> _APP_ _TYAPP_ patError# { (u0 -> (Int, Int)) } [ _NOREP_S_ "%DPreludeCore.RealFloat.floatRange\"", u2 ] _N_ #-}
+ {-defm-} _A_ 2 _U_ 02 _N_ _S_ _!_ _N_ _N_ #-}
decodeFloat :: a -> (Integer, Int)
{-# GHC_PRAGMA {-meth-} _A_ 1 _U_ 12 _N_ _S_ "S" _F_ _IF_ARGS_ 1 1 C 2 _/\_ u0 -> \ (u1 :: ({{RealFrac u0}}, {{Floating u0}}, u0 -> Integer, u0 -> Int, u0 -> (Int, Int), u0 -> (Integer, Int), Integer -> Int -> u0, u0 -> Int, u0 -> u0, Int -> u0 -> u0)) -> case u1 of { _ALG_ _TUP_10 (u2 :: {{RealFrac u0}}) (u3 :: {{Floating u0}}) (u4 :: u0 -> Integer) (u5 :: u0 -> Int) (u6 :: u0 -> (Int, Int)) (u7 :: u0 -> (Integer, Int)) (u8 :: Integer -> Int -> u0) (u9 :: u0 -> Int) (ua :: u0 -> u0) (ub :: Int -> u0 -> u0) -> u7; _NO_DEFLT_ } _N_
- {-defm-} _A_ 2 _U_ 02 _N_ _S_ _!_ _F_ _IF_ARGS_ 1 2 XX 3 _/\_ u0 -> \ (u1 :: {{RealFloat u0}}) (u2 :: u0) -> _APP_ _TYAPP_ patError# { (u0 -> (Integer, Int)) } [ _NOREP_S_ "%DPreludeCore.RealFloat.decodeFloat\"", u2 ] _N_ #-}
+ {-defm-} _A_ 2 _U_ 02 _N_ _S_ _!_ _N_ _N_ #-}
encodeFloat :: Integer -> Int -> a
{-# GHC_PRAGMA {-meth-} _A_ 1 _U_ 122 _N_ _S_ "S" _F_ _IF_ARGS_ 1 1 C 2 _/\_ u0 -> \ (u1 :: ({{RealFrac u0}}, {{Floating u0}}, u0 -> Integer, u0 -> Int, u0 -> (Int, Int), u0 -> (Integer, Int), Integer -> Int -> u0, u0 -> Int, u0 -> u0, Int -> u0 -> u0)) -> case u1 of { _ALG_ _TUP_10 (u2 :: {{RealFrac u0}}) (u3 :: {{Floating u0}}) (u4 :: u0 -> Integer) (u5 :: u0 -> Int) (u6 :: u0 -> (Int, Int)) (u7 :: u0 -> (Integer, Int)) (u8 :: Integer -> Int -> u0) (u9 :: u0 -> Int) (ua :: u0 -> u0) (ub :: Int -> u0 -> u0) -> u8; _NO_DEFLT_ } _N_
- {-defm-} _A_ 3 _U_ 022 _N_ _S_ _!_ _F_ _IF_ARGS_ 1 3 XXX 4 _/\_ u0 -> \ (u1 :: {{RealFloat u0}}) (u2 :: Integer) (u3 :: Int) -> _APP_ _TYAPP_ patError# { (Integer -> Int -> u0) } [ _NOREP_S_ "%DPreludeCore.RealFloat.encodeFloat\"", u2, u3 ] _N_ #-}
+ {-defm-} _A_ 3 _U_ 022 _N_ _S_ _!_ _N_ _N_ #-}
exponent :: a -> Int
{-# GHC_PRAGMA {-meth-} _A_ 1 _U_ 12 _N_ _S_ "S" _F_ _IF_ARGS_ 1 1 C 2 _/\_ u0 -> \ (u1 :: ({{RealFrac u0}}, {{Floating u0}}, u0 -> Integer, u0 -> Int, u0 -> (Int, Int), u0 -> (Integer, Int), Integer -> Int -> u0, u0 -> Int, u0 -> u0, Int -> u0 -> u0)) -> case u1 of { _ALG_ _TUP_10 (u2 :: {{RealFrac u0}}) (u3 :: {{Floating u0}}) (u4 :: u0 -> Integer) (u5 :: u0 -> Int) (u6 :: u0 -> (Int, Int)) (u7 :: u0 -> (Integer, Int)) (u8 :: Integer -> Int -> u0) (u9 :: u0 -> Int) (ua :: u0 -> u0) (ub :: Int -> u0 -> u0) -> u9; _NO_DEFLT_ } _N_
{-defm-} _A_ 2 _U_ 12 _N_ _S_ "SL" _N_ _N_ #-}
class (Real a, Fractional a) => RealFrac a {-# GHC_PRAGMA {-superdicts-} _A_ 1 _U_ 1 _N_ _S_ "S" _F_ _IF_ARGS_ 1 1 C 2 _/\_ u0 -> \ (u1 :: ({{Real u0}}, {{Fractional u0}}, (_forall_ z$z1 =>{{Integral z$z1}} -> u0 -> (z$z1, u0)), (_forall_ z$z1 =>{{Integral z$z1}} -> u0 -> z$z1), (_forall_ z$z1 =>{{Integral z$z1}} -> u0 -> z$z1), (_forall_ z$z1 =>{{Integral z$z1}} -> u0 -> z$z1), (_forall_ z$z1 =>{{Integral z$z1}} -> u0 -> z$z1))) -> case u1 of { _ALG_ _TUP_7 (u2 :: {{Real u0}}) (u3 :: {{Fractional u0}}) (u4 :: _forall_ a$z1 =>{{Integral a$z1}} -> u0 -> (a$z1, u0)) (u5 :: _forall_ a$z1 =>{{Integral a$z1}} -> u0 -> a$z1) (u6 :: _forall_ a$z1 =>{{Integral a$z1}} -> u0 -> a$z1) (u7 :: _forall_ a$z1 =>{{Integral a$z1}} -> u0 -> a$z1) (u8 :: _forall_ a$z1 =>{{Integral a$z1}} -> u0 -> a$z1) -> u2; _NO_DEFLT_ } _N_, _A_ 1 _U_ 1 _N_ _S_ "S" _F_ _IF_ARGS_ 1 1 C 2 _/\_ u0 -> \ (u1 :: ({{Real u0}}, {{Fractional u0}}, (_forall_ z$z1 =>{{Integral z$z1}} -> u0 -> (z$z1, u0)), (_forall_ z$z1 =>{{Integral z$z1}} -> u0 -> z$z1), (_forall_ z$z1 =>{{Integral z$z1}} -> u0 -> z$z1), (_forall_ z$z1 =>{{Integral z$z1}} -> u0 -> z$z1), (_forall_ z$z1 =>{{Integral z$z1}} -> u0 -> z$z1))) -> case u1 of { _ALG_ _TUP_7 (u2 :: {{Real u0}}) (u3 :: {{Fractional u0}}) (u4 :: _forall_ a$z1 =>{{Integral a$z1}} -> u0 -> (a$z1, u0)) (u5 :: _forall_ a$z1 =>{{Integral a$z1}} -> u0 -> a$z1) (u6 :: _forall_ a$z1 =>{{Integral a$z1}} -> u0 -> a$z1) (u7 :: _forall_ a$z1 =>{{Integral a$z1}} -> u0 -> a$z1) (u8 :: _forall_ a$z1 =>{{Integral a$z1}} -> u0 -> a$z1) -> u3; _NO_DEFLT_ } _N_ #-} where
properFraction :: Integral b => a -> (b, a)
{-# GHC_PRAGMA {-meth-} _A_ 2 _U_ 122 _N_ _S_ "SL" _F_ _IF_ARGS_ 2 2 CX 3 _/\_ u0 u1 -> \ (u2 :: ({{Real u0}}, {{Fractional u0}}, (_forall_ z$z1 =>{{Integral z$z1}} -> u0 -> (z$z1, u0)), (_forall_ z$z1 =>{{Integral z$z1}} -> u0 -> z$z1), (_forall_ z$z1 =>{{Integral z$z1}} -> u0 -> z$z1), (_forall_ z$z1 =>{{Integral z$z1}} -> u0 -> z$z1), (_forall_ z$z1 =>{{Integral z$z1}} -> u0 -> z$z1))) (u3 :: {{Integral u1}}) -> case u2 of { _ALG_ _TUP_7 (u4 :: {{Real u0}}) (u5 :: {{Fractional u0}}) (u6 :: _forall_ a$z1 =>{{Integral a$z1}} -> u0 -> (a$z1, u0)) (u7 :: _forall_ a$z1 =>{{Integral a$z1}} -> u0 -> a$z1) (u8 :: _forall_ a$z1 =>{{Integral a$z1}} -> u0 -> a$z1) (u9 :: _forall_ a$z1 =>{{Integral a$z1}} -> u0 -> a$z1) (ua :: _forall_ a$z1 =>{{Integral a$z1}} -> u0 -> a$z1) -> _APP_ _TYAPP_ u6 { u1 } [ u3 ]; _NO_DEFLT_ } _N_
- {-defm-} _A_ 3 _U_ 002 _N_ _S_ _!_ _F_ _IF_ARGS_ 2 3 XXX 3 _/\_ u0 u1 -> \ (u2 :: {{RealFrac u0}}) (u3 :: {{Integral u1}}) (u4 :: u0) -> _APP_ _TYAPP_ patError# { (u0 -> (u1, u0)) } [ _NOREP_S_ "%DPreludeCore.RealFrac.properFraction\"", u4 ] _N_ #-}
+ {-defm-} _A_ 3 _U_ 002 _N_ _S_ _!_ _N_ _N_ #-}
truncate :: Integral b => a -> b
{-# GHC_PRAGMA {-meth-} _A_ 2 _U_ 122 _N_ _S_ "SL" _F_ _IF_ARGS_ 2 2 CX 3 _/\_ u0 u1 -> \ (u2 :: ({{Real u0}}, {{Fractional u0}}, (_forall_ z$z1 =>{{Integral z$z1}} -> u0 -> (z$z1, u0)), (_forall_ z$z1 =>{{Integral z$z1}} -> u0 -> z$z1), (_forall_ z$z1 =>{{Integral z$z1}} -> u0 -> z$z1), (_forall_ z$z1 =>{{Integral z$z1}} -> u0 -> z$z1), (_forall_ z$z1 =>{{Integral z$z1}} -> u0 -> z$z1))) (u3 :: {{Integral u1}}) -> case u2 of { _ALG_ _TUP_7 (u4 :: {{Real u0}}) (u5 :: {{Fractional u0}}) (u6 :: _forall_ a$z1 =>{{Integral a$z1}} -> u0 -> (a$z1, u0)) (u7 :: _forall_ a$z1 =>{{Integral a$z1}} -> u0 -> a$z1) (u8 :: _forall_ a$z1 =>{{Integral a$z1}} -> u0 -> a$z1) (u9 :: _forall_ a$z1 =>{{Integral a$z1}} -> u0 -> a$z1) (ua :: _forall_ a$z1 =>{{Integral a$z1}} -> u0 -> a$z1) -> _APP_ _TYAPP_ u7 { u1 } [ u3 ]; _NO_DEFLT_ } _N_
{-defm-} _A_ 2 _U_ 122 _N_ _S_ "SL" _N_ _N_ #-}
class Text a where
readsPrec :: Int -> [Char] -> [(a, [Char])]
{-# GHC_PRAGMA {-meth-} _A_ 1 _U_ 122 _N_ _S_ "S" _F_ _IF_ARGS_ 1 1 C 2 _/\_ u0 -> \ (u1 :: (Int -> [Char] -> [(u0, [Char])], Int -> u0 -> [Char] -> [Char], [Char] -> [([u0], [Char])], [u0] -> [Char] -> [Char])) -> case u1 of { _ALG_ _TUP_4 (u2 :: Int -> [Char] -> [(u0, [Char])]) (u3 :: Int -> u0 -> [Char] -> [Char]) (u4 :: [Char] -> [([u0], [Char])]) (u5 :: [u0] -> [Char] -> [Char]) -> u2; _NO_DEFLT_ } _N_
- {-defm-} _A_ 3 _U_ 022 _N_ _S_ _!_ _F_ _IF_ARGS_ 1 3 XXX 4 _/\_ u0 -> \ (u1 :: {{Text u0}}) (u2 :: Int) (u3 :: [Char]) -> _APP_ _TYAPP_ patError# { (Int -> [Char] -> [(u0, [Char])]) } [ _NOREP_S_ "%DPreludeCore.Text.readsPrec\"", u2, u3 ] _N_ #-}
+ {-defm-} _A_ 3 _U_ 022 _N_ _S_ _!_ _N_ _N_ #-}
showsPrec :: Int -> a -> [Char] -> [Char]
{-# GHC_PRAGMA {-meth-} _A_ 1 _U_ 1222 _N_ _S_ "S" _F_ _IF_ARGS_ 1 1 C 2 _/\_ u0 -> \ (u1 :: (Int -> [Char] -> [(u0, [Char])], Int -> u0 -> [Char] -> [Char], [Char] -> [([u0], [Char])], [u0] -> [Char] -> [Char])) -> case u1 of { _ALG_ _TUP_4 (u2 :: Int -> [Char] -> [(u0, [Char])]) (u3 :: Int -> u0 -> [Char] -> [Char]) (u4 :: [Char] -> [([u0], [Char])]) (u5 :: [u0] -> [Char] -> [Char]) -> u3; _NO_DEFLT_ } _N_
- {-defm-} _A_ 4 _U_ 0222 _N_ _S_ _!_ _F_ _IF_ARGS_ 1 4 XXXX 5 _/\_ u0 -> \ (u1 :: {{Text u0}}) (u2 :: Int) (u3 :: u0) (u4 :: [Char]) -> _APP_ _TYAPP_ patError# { (Int -> u0 -> [Char] -> [Char]) } [ _NOREP_S_ "%DPreludeCore.Text.showsPrec\"", u2, u3, u4 ] _N_ #-}
+ {-defm-} _A_ 4 _U_ 0222 _N_ _S_ _!_ _N_ _N_ #-}
readList :: [Char] -> [([a], [Char])]
{-# GHC_PRAGMA {-meth-} _A_ 1 _U_ 12 _N_ _S_ "S" _F_ _IF_ARGS_ 1 1 C 2 _/\_ u0 -> \ (u1 :: (Int -> [Char] -> [(u0, [Char])], Int -> u0 -> [Char] -> [Char], [Char] -> [([u0], [Char])], [u0] -> [Char] -> [Char])) -> case u1 of { _ALG_ _TUP_4 (u2 :: Int -> [Char] -> [(u0, [Char])]) (u3 :: Int -> u0 -> [Char] -> [Char]) (u4 :: [Char] -> [([u0], [Char])]) (u5 :: [u0] -> [Char] -> [Char]) -> u4; _NO_DEFLT_ } _N_
- {-defm-} _A_ 1 _U_ 22 _N_ _N_ _F_ _IF_ARGS_ 0 0 X 1 _ORIG_ PreludeCore _readList _N_ #-}
+ {-defm-} _A_ 1 _U_ 12 _N_ _N_ _N_ _N_ #-}
showList :: [a] -> [Char] -> [Char]
{-# GHC_PRAGMA {-meth-} _A_ 1 _U_ 122 _N_ _S_ "S" _F_ _IF_ARGS_ 1 1 C 2 _/\_ u0 -> \ (u1 :: (Int -> [Char] -> [(u0, [Char])], Int -> u0 -> [Char] -> [Char], [Char] -> [([u0], [Char])], [u0] -> [Char] -> [Char])) -> case u1 of { _ALG_ _TUP_4 (u2 :: Int -> [Char] -> [(u0, [Char])]) (u3 :: Int -> u0 -> [Char] -> [Char]) (u4 :: [Char] -> [([u0], [Char])]) (u5 :: [u0] -> [Char] -> [Char]) -> u5; _NO_DEFLT_ } _N_
- {-defm-} _A_ 1 _U_ 212 _N_ _N_ _F_ _IF_ARGS_ 0 0 X 1 _ORIG_ PreludeCore _showList _N_ #-}
+ {-defm-} _A_ 1 _U_ 112 _N_ _N_ _N_ _N_ #-}
class _CCallable a
class _CReturnable a
data Array a b {-# GHC_PRAGMA _Array (a, a) (Array# b) #-}
data Assoc a b = (:=) a b
data _ByteArray a {-# GHC_PRAGMA _ByteArray (a, a) ByteArray# #-}
data Bin
-data Complex a = (:+) a a
+data Complex a = (:+) a a {-# GHC_PRAGMA _SPECIALISE_ [ Double# ] #-}
data _MutableArray a b c {-# GHC_PRAGMA _MutableArray (b, b) (MutableArray# a c) #-}
data _MutableByteArray a b {-# GHC_PRAGMA _MutableByteArray (b, b) (MutableByteArray# a) #-}
data IOError13 = AlreadyExists [Char] | HardwareFault [Char] | IllegalOperation [Char] | InappropriateType [Char] | Interrupted [Char] | InvalidArgument [Char] | NoSuchThing [Char] | OtherError13 [Char] | PermissionDenied [Char] | ProtocolError [Char] | ResourceBusy [Char] | ResourceExhausted [Char] | ResourceVanished [Char] | SystemError [Char] | TimeExpired [Char] | UnsatisfiedConstraints [Char] | UnsupportedOperation [Char] | UserError [Char] | EOF
type ReadS a = [Char] -> [(a, [Char])]
type ShowS = [Char] -> [Char]
data _FILE {-# GHC_PRAGMA _FILE Addr# #-}
+__i0 :: Num a => a
+ {-# GHC_PRAGMA _A_ 1 _U_ 1 _N_ _S_ "U(AAAAAAAAAS)" {_A_ 1 _U_ 1 _N_ _N_ _N_ _N_} _N_ _SPECIALISE_ [ Double ] 1 { _A_ 0 _N_ _N_ _N_ _F_ _IF_ARGS_ 0 0 X 2 _!_ D# [] [0.0000000000000000##] _N_ }, [ Int ] 1 { _A_ 0 _N_ _N_ _N_ _F_ _IF_ARGS_ 0 0 X 2 _!_ I# [] [0#] _N_ }, [ Integer ] 1 { _A_ 0 _N_ _N_ _N_ _N_ _N_ }, [ (Ratio Integer) ] 1 { _A_ 0 _N_ _N_ _N_ _N_ _N_ }, [ (Complex Double) ] 1 { _A_ 0 _N_ _N_ _N_ _N_ _N_ } #-}
+__i1 :: Num a => a
+ {-# GHC_PRAGMA _A_ 1 _U_ 1 _N_ _S_ "U(AAAAAAAAAS)" {_A_ 1 _U_ 1 _N_ _N_ _N_ _N_} _N_ _SPECIALISE_ [ Double ] 1 { _A_ 0 _N_ _N_ _N_ _F_ _IF_ARGS_ 0 0 X 2 _!_ D# [] [1.0000000000000000##] _N_ }, [ Int ] 1 { _A_ 0 _N_ _N_ _N_ _F_ _IF_ARGS_ 0 0 X 2 _!_ I# [] [1#] _N_ }, [ Integer ] 1 { _A_ 0 _N_ _N_ _N_ _N_ _N_ }, [ (Ratio Integer) ] 1 { _A_ 0 _N_ _N_ _N_ _N_ _N_ }, [ (Complex Double) ] 1 { _A_ 0 _N_ _N_ _N_ _N_ _N_ } #-}
+__i10 :: Num a => a
+ {-# GHC_PRAGMA _A_ 1 _U_ 1 _N_ _S_ "U(AAAAAAAAAS)" {_A_ 1 _U_ 1 _N_ _N_ _N_ _N_} _N_ _SPECIALISE_ [ Double ] 1 { _A_ 0 _N_ _N_ _N_ _F_ _IF_ARGS_ 0 0 X 2 _!_ D# [] [10.000000000000000##] _N_ }, [ Int ] 1 { _A_ 0 _N_ _N_ _N_ _F_ _IF_ARGS_ 0 0 X 2 _!_ I# [] [10#] _N_ }, [ Integer ] 1 { _A_ 0 _N_ _N_ _N_ _N_ _N_ }, [ (Ratio Integer) ] 1 { _A_ 0 _N_ _N_ _N_ _N_ _N_ }, [ (Complex Double) ] 1 { _A_ 0 _N_ _N_ _N_ _N_ _N_ } #-}
+__i16 :: Num a => a
+ {-# GHC_PRAGMA _A_ 1 _U_ 1 _N_ _S_ "U(AAAAAAAAAS)" {_A_ 1 _U_ 1 _N_ _N_ _N_ _N_} _N_ _SPECIALISE_ [ Double ] 1 { _A_ 0 _N_ _N_ _N_ _F_ _IF_ARGS_ 0 0 X 2 _!_ D# [] [16.000000000000000##] _N_ }, [ Int ] 1 { _A_ 0 _N_ _N_ _N_ _F_ _IF_ARGS_ 0 0 X 2 _!_ I# [] [16#] _N_ }, [ Integer ] 1 { _A_ 0 _N_ _N_ _N_ _N_ _N_ }, [ (Ratio Integer) ] 1 { _A_ 0 _N_ _N_ _N_ _N_ _N_ }, [ (Complex Double) ] 1 { _A_ 0 _N_ _N_ _N_ _N_ _N_ } #-}
+__i2 :: Num a => a
+ {-# GHC_PRAGMA _A_ 1 _U_ 1 _N_ _S_ "U(AAAAAAAAAS)" {_A_ 1 _U_ 1 _N_ _N_ _N_ _N_} _N_ _SPECIALISE_ [ Double ] 1 { _A_ 0 _N_ _N_ _N_ _F_ _IF_ARGS_ 0 0 X 2 _!_ D# [] [2.0000000000000000##] _N_ }, [ Int ] 1 { _A_ 0 _N_ _N_ _N_ _F_ _IF_ARGS_ 0 0 X 2 _!_ I# [] [2#] _N_ }, [ Integer ] 1 { _A_ 0 _N_ _N_ _N_ _N_ _N_ }, [ (Ratio Integer) ] 1 { _A_ 0 _N_ _N_ _N_ _N_ _N_ }, [ (Complex Double) ] 1 { _A_ 0 _N_ _N_ _N_ _N_ _N_ } #-}
+__i8 :: Num a => a
+ {-# GHC_PRAGMA _A_ 1 _U_ 1 _N_ _S_ "U(AAAAAAAAAS)" {_A_ 1 _U_ 1 _N_ _N_ _N_ _N_} _N_ _SPECIALISE_ [ Double ] 1 { _A_ 0 _N_ _N_ _N_ _F_ _IF_ARGS_ 0 0 X 2 _!_ D# [] [8.0000000000000000##] _N_ }, [ Int ] 1 { _A_ 0 _N_ _N_ _N_ _F_ _IF_ARGS_ 0 0 X 2 _!_ I# [] [8#] _N_ }, [ Integer ] 1 { _A_ 0 _N_ _N_ _N_ _N_ _N_ }, [ (Ratio Integer) ] 1 { _A_ 0 _N_ _N_ _N_ _N_ _N_ }, [ (Complex Double) ] 1 { _A_ 0 _N_ _N_ _N_ _N_ _N_ } #-}
+__im1 :: Num a => a
+ {-# GHC_PRAGMA _A_ 1 _U_ 1 _N_ _S_ "U(AAAAAAAAAS)" {_A_ 1 _U_ 1 _N_ _N_ _N_ _N_} _N_ _SPECIALISE_ [ Double ] 1 { _A_ 0 _N_ _N_ _N_ _F_ _IF_ARGS_ 0 0 X 2 _!_ D# [] [-1.0000000000000000##] _N_ }, [ Int ] 1 { _A_ 0 _N_ _N_ _N_ _F_ _IF_ARGS_ 0 0 X 2 _!_ I# [] [-1#] _N_ }, [ Integer ] 1 { _A_ 0 _N_ _N_ _N_ _N_ _N_ }, [ (Ratio Integer) ] 1 { _A_ 0 _N_ _N_ _N_ _N_ _N_ }, [ (Complex Double) ] 1 { _A_ 0 _N_ _N_ _N_ _N_ _N_ } #-}
+__integer0 :: Integer
+ {-# GHC_PRAGMA _A_ 0 _N_ _N_ _N_ _N_ _N_ #-}
+__integer1 :: Integer
+ {-# GHC_PRAGMA _A_ 0 _N_ _N_ _N_ _N_ _N_ #-}
+__integer2 :: Integer
+ {-# GHC_PRAGMA _A_ 0 _N_ _N_ _N_ _N_ _N_ #-}
+__integerm1 :: Integer
+ {-# GHC_PRAGMA _A_ 0 _N_ _N_ _N_ _N_ _N_ #-}
+__rhalf :: Fractional a => a
+ {-# GHC_PRAGMA _A_ 1 _U_ 1 _N_ _S_ "U(AAAS)" {_A_ 1 _U_ 1 _N_ _N_ _N_ _N_} _N_ _SPECIALISE_ [ Double ] 1 { _A_ 0 _N_ _N_ _N_ _N_ _N_ }, [ (Ratio Integer) ] 1 { _A_ 0 _N_ _N_ _N_ _F_ _IF_ARGS_ 0 0 X 3 _!_ (:%) [Integer] [_SPEC_ _ORIG_ PreludeCore __i1 [ (Integer) ], _SPEC_ _ORIG_ PreludeCore __i2 [ (Integer) ]] _N_ }, [ (Complex Double) ] 1 { _A_ 0 _N_ _N_ _N_ _N_ _N_ } #-}
+_fromRational :: RealFloat a => Ratio Integer -> a
+ {-# GHC_PRAGMA _A_ 2 _U_ 22 _N_ _N_ _N_ _SPECIALISE_ [ Double ] 1 { _A_ 1 _U_ 1 _N_ _S_ "U(U(PPP)U(PPP))" {_A_ 4 _U_ 2221 _N_ _N_ _N_ _N_} _N_ _N_ } #-}
instance Enum ()
{-# GHC_PRAGMA _M_ PreludeBuiltin {-dfun-} _A_ 0 _N_ _N_ _N_ _F_ _IF_ARGS_ 0 0 X 6 _!_ _TUP_5 [{{Ord ()}}, (() -> [()]), (() -> () -> [()]), (() -> () -> [()]), (() -> () -> () -> [()])] [_DFUN_ Ord (()), _CONSTM_ Enum enumFrom (()), _CONSTM_ Enum enumFromThen (()), _CONSTM_ Enum enumFromTo (()), _CONSTM_ Enum enumFromThenTo (())] _N_
- enumFrom = _A_ 1 _U_ 2 _N_ _S_ "E" _N_ _N_,
- enumFromThen = _A_ 2 _U_ 21 _N_ _S_ "EE" _F_ _IF_ARGS_ 0 2 CC 7 \ (u0 :: ()) (u1 :: ()) -> case u0 of { _ALG_ _TUP_0 -> case u1 of { _ALG_ _TUP_0 -> let {(u2 :: [()]) = _!_ _NIL_ [()] []} in _!_ (:) [()] [u0, u2]; _NO_DEFLT_ }; _NO_DEFLT_ } _N_,
- enumFromTo = _A_ 2 _U_ 21 _N_ _S_ "EE" _F_ _IF_ARGS_ 0 2 CC 7 \ (u0 :: ()) (u1 :: ()) -> case u0 of { _ALG_ _TUP_0 -> case u1 of { _ALG_ _TUP_0 -> let {(u2 :: [()]) = _!_ _NIL_ [()] []} in _!_ (:) [()] [u0, u2]; _NO_DEFLT_ }; _NO_DEFLT_ } _N_,
- enumFromThenTo = _A_ 3 _U_ 211 _N_ _S_ "EEE" _F_ _IF_ARGS_ 0 3 CCC 8 \ (u0 :: ()) (u1 :: ()) (u2 :: ()) -> case u0 of { _ALG_ _TUP_0 -> case u1 of { _ALG_ _TUP_0 -> case u2 of { _ALG_ _TUP_0 -> let {(u3 :: [()]) = _!_ _NIL_ [()] []} in _!_ (:) [()] [u0, u3]; _NO_DEFLT_ }; _NO_DEFLT_ }; _NO_DEFLT_ } _N_ #-}
+ enumFrom = { _A_ 1 _U_ 2 _N_ _S_ "E" _N_ _N_ },
+ enumFromThen = { _A_ 2 _U_ 21 _N_ _S_ "EE" _F_ _IF_ARGS_ 0 2 CC 7 \ (u0 :: ()) (u1 :: ()) -> case u0 of { _ALG_ _TUP_0 -> case u1 of { _ALG_ _TUP_0 -> let {(u2 :: [()]) = _!_ _NIL_ [()] []} in _!_ (:) [()] [u0, u2]; _NO_DEFLT_ }; _NO_DEFLT_ } _N_ },
+ enumFromTo = { _A_ 2 _U_ 21 _N_ _S_ "EE" _F_ _IF_ARGS_ 0 2 CC 7 \ (u0 :: ()) (u1 :: ()) -> case u0 of { _ALG_ _TUP_0 -> case u1 of { _ALG_ _TUP_0 -> let {(u2 :: [()]) = _!_ _NIL_ [()] []} in _!_ (:) [()] [u0, u2]; _NO_DEFLT_ }; _NO_DEFLT_ } _N_ },
+ enumFromThenTo = { _A_ 3 _U_ 211 _N_ _S_ "EEE" _F_ _IF_ARGS_ 0 3 CCC 8 \ (u0 :: ()) (u1 :: ()) (u2 :: ()) -> case u0 of { _ALG_ _TUP_0 -> case u1 of { _ALG_ _TUP_0 -> case u2 of { _ALG_ _TUP_0 -> let {(u3 :: [()]) = _!_ _NIL_ [()] []} in _!_ (:) [()] [u0, u3]; _NO_DEFLT_ }; _NO_DEFLT_ }; _NO_DEFLT_ } _N_ } #-}
instance Enum Bool
{-# GHC_PRAGMA _M_ PreludeCore {-dfun-} _A_ 0 _N_ _N_ _N_ _F_ _IF_ARGS_ 0 0 X 6 _!_ _TUP_5 [{{Ord Bool}}, (Bool -> [Bool]), (Bool -> Bool -> [Bool]), (Bool -> Bool -> [Bool]), (Bool -> Bool -> Bool -> [Bool])] [_DFUN_ Ord (Bool), _CONSTM_ Enum enumFrom (Bool), _CONSTM_ Enum enumFromThen (Bool), _CONSTM_ Enum enumFromTo (Bool), _CONSTM_ Enum enumFromThenTo (Bool)] _N_
- enumFrom = _A_ 1 _U_ 2 _N_ _S_ "E" _N_ _N_,
- enumFromThen = _A_ 2 _U_ 22 _N_ _S_ "EE" _N_ _N_,
- enumFromTo = _A_ 2 _U_ 22 _N_ _N_ _N_ _N_,
- enumFromThenTo = _A_ 3 _U_ 222 _N_ _N_ _N_ _N_ #-}
+ enumFrom = { _A_ 1 _U_ 2 _N_ _S_ "E" _N_ _N_ },
+ enumFromThen = { _A_ 2 _U_ 22 _N_ _S_ "EE" _N_ _N_ },
+ enumFromTo = { _A_ 2 _U_ 22 _N_ _S_ "EL" _N_ _N_ },
+ enumFromThenTo = { _A_ 3 _U_ 222 _N_ _S_ "EEL" _N_ _N_ } #-}
instance Enum Char
{-# GHC_PRAGMA _M_ PreludeCore {-dfun-} _A_ 0 _N_ _N_ _N_ _F_ _IF_ARGS_ 0 0 X 6 _!_ _TUP_5 [{{Ord Char}}, (Char -> [Char]), (Char -> Char -> [Char]), (Char -> Char -> [Char]), (Char -> Char -> Char -> [Char])] [_DFUN_ Ord (Char), _CONSTM_ Enum enumFrom (Char), _CONSTM_ Enum enumFromThen (Char), _CONSTM_ Enum enumFromTo (Char), _CONSTM_ Enum enumFromThenTo (Char)] _N_
- enumFrom = _A_ 1 _U_ 1 _N_ _S_ "U(P)" {_A_ 1 _U_ 2 _N_ _N_ _N_ _N_} _N_ _N_,
- enumFromThen = _A_ 2 _U_ 22 _N_ _N_ _N_ _N_,
- enumFromTo = _A_ 2 _U_ 22 _N_ _N_ _N_ _N_,
- enumFromThenTo = _A_ 3 _U_ 222 _N_ _N_ _N_ _N_ #-}
+ enumFrom = { _A_ 1 _U_ 1 _N_ _S_ "U(P)" {_A_ 1 _U_ 2 _N_ _N_ _N_ _N_} _N_ _N_ },
+ enumFromThen = { _A_ 2 _U_ 22 _N_ _N_ _N_ _N_ },
+ enumFromTo = { _A_ 2 _U_ 12 _N_ _S_ "U(P)L" {_A_ 2 _U_ 22 _N_ _N_ _N_ _N_} _N_ _N_ },
+ enumFromThenTo = { _A_ 3 _U_ 222 _N_ _N_ _N_ _N_ } #-}
instance Enum Double
{-# GHC_PRAGMA _M_ PreludeCore {-dfun-} _A_ 0 _N_ _N_ _N_ _F_ _IF_ARGS_ 0 0 X 6 _!_ _TUP_5 [{{Ord Double}}, (Double -> [Double]), (Double -> Double -> [Double]), (Double -> Double -> [Double]), (Double -> Double -> Double -> [Double])] [_DFUN_ Ord (Double), _CONSTM_ Enum enumFrom (Double), _CONSTM_ Enum enumFromThen (Double), _CONSTM_ Enum enumFromTo (Double), _CONSTM_ Enum enumFromThenTo (Double)] _N_
- enumFrom = _A_ 1 _U_ 2 _N_ _N_ _N_ _N_,
- enumFromThen = _A_ 2 _U_ 21 _N_ _N_ _N_ _N_,
- enumFromTo = _A_ 2 _U_ 22 _N_ _N_ _N_ _N_,
- enumFromThenTo = _A_ 3 _U_ 222 _N_ _N_ _N_ _N_ #-}
+ enumFrom = { _A_ 1 _U_ 2 _N_ _N_ _N_ _N_ },
+ enumFromThen = { _A_ 2 _U_ 21 _N_ _N_ _N_ _N_ },
+ enumFromTo = { _A_ 2 _U_ 22 _N_ _N_ _N_ _N_ },
+ enumFromThenTo = { _A_ 3 _U_ 222 _N_ _N_ _N_ _N_ } #-}
instance Enum Float
{-# GHC_PRAGMA _M_ PreludeCore {-dfun-} _A_ 0 _N_ _N_ _N_ _F_ _IF_ARGS_ 0 0 X 6 _!_ _TUP_5 [{{Ord Float}}, (Float -> [Float]), (Float -> Float -> [Float]), (Float -> Float -> [Float]), (Float -> Float -> Float -> [Float])] [_DFUN_ Ord (Float), _CONSTM_ Enum enumFrom (Float), _CONSTM_ Enum enumFromThen (Float), _CONSTM_ Enum enumFromTo (Float), _CONSTM_ Enum enumFromThenTo (Float)] _N_
- enumFrom = _A_ 1 _U_ 2 _N_ _N_ _N_ _N_,
- enumFromThen = _A_ 2 _U_ 21 _N_ _N_ _N_ _N_,
- enumFromTo = _A_ 2 _U_ 22 _N_ _N_ _N_ _N_,
- enumFromThenTo = _A_ 3 _U_ 222 _N_ _N_ _N_ _N_ #-}
+ enumFrom = { _A_ 1 _U_ 2 _N_ _N_ _N_ _N_ },
+ enumFromThen = { _A_ 2 _U_ 21 _N_ _N_ _N_ _N_ },
+ enumFromTo = { _A_ 2 _U_ 22 _N_ _N_ _N_ _N_ },
+ enumFromThenTo = { _A_ 3 _U_ 222 _N_ _N_ _N_ _N_ } #-}
instance Enum Int
{-# GHC_PRAGMA _M_ PreludeCore {-dfun-} _A_ 0 _N_ _N_ _N_ _F_ _IF_ARGS_ 0 0 X 6 _!_ _TUP_5 [{{Ord Int}}, (Int -> [Int]), (Int -> Int -> [Int]), (Int -> Int -> [Int]), (Int -> Int -> Int -> [Int])] [_DFUN_ Ord (Int), _CONSTM_ Enum enumFrom (Int), _CONSTM_ Enum enumFromThen (Int), _CONSTM_ Enum enumFromTo (Int), _CONSTM_ Enum enumFromThenTo (Int)] _N_
- enumFrom = _A_ 1 _U_ 2 _N_ _N_ _F_ _ALWAYS_ \ (u0 :: Int) -> _LETREC_ {(u1 :: Int -> [Int]) = \ (u2 :: Int) -> let {(u6 :: [Int]) = let {(u5 :: Int) = case u2 of { _ALG_ I# (u3 :: Int#) -> case _#_ plusInt# [] [u3, 1#] of { _PRIM_ (u4 :: Int#) -> _!_ I# [] [u4] }; _NO_DEFLT_ }} in _APP_ u1 [ u5 ]} in _!_ (:) [Int] [u2, u6]} in _APP_ u1 [ u0 ] _N_,
- enumFromThen = _A_ 2 _U_ 21 _N_ _N_ _N_ _N_,
- enumFromTo = _A_ 2 _U_ 12 _N_ _S_ "SS" _F_ _ALWAYS_ \ (u0 :: Int) (u1 :: Int) -> case u0 of { _ALG_ I# (u2 :: Int#) -> _LETREC_ {(u3 :: Int# -> [Int]) = \ (u4 :: Int#) -> case u1 of { _ALG_ I# (u5 :: Int#) -> case _#_ leInt# [] [u4, u5] of { _ALG_ True -> let {(u7 :: [Int]) = case _#_ plusInt# [] [u4, 1#] of { _PRIM_ (u6 :: Int#) -> _APP_ u3 [ u6 ] }} in let {(u8 :: Int) = _!_ I# [] [u4]} in _!_ (:) [Int] [u8, u7]; False -> _!_ _NIL_ [Int] []; _NO_DEFLT_ }; _NO_DEFLT_ }} in _APP_ u3 [ u2 ]; _NO_DEFLT_ } _N_,
- enumFromThenTo = _A_ 3 _U_ 222 _N_ _N_ _N_ _N_ #-}
+ enumFrom = { _A_ 1 _U_ 2 _N_ _N_ _F_ _ALWAYS_ \ (u0 :: Int) -> _LETREC_ {(u1 :: Int -> [Int]) = \ (u2 :: Int) -> let {(u6 :: [Int]) = let {(u5 :: Int) = case u2 of { _ALG_ I# (u3 :: Int#) -> case _#_ plusInt# [] [u3, 1#] of { _PRIM_ (u4 :: Int#) -> _!_ I# [] [u4] }; _NO_DEFLT_ }} in _APP_ u1 [ u5 ]} in _!_ (:) [Int] [u2, u6]} in _APP_ u1 [ u0 ] _N_ },
+ enumFromThen = { _A_ 2 _U_ 21 _N_ _N_ _N_ _N_ },
+ enumFromTo = { _A_ 2 _U_ 12 _N_ _S_ "SS" _F_ _ALWAYS_ \ (u0 :: Int) (u1 :: Int) -> case u0 of { _ALG_ I# (u2 :: Int#) -> _LETREC_ {(u3 :: Int# -> [Int]) = \ (u4 :: Int#) -> case u1 of { _ALG_ I# (u5 :: Int#) -> case _#_ leInt# [] [u4, u5] of { _ALG_ True -> let {(u7 :: [Int]) = case _#_ plusInt# [] [u4, 1#] of { _PRIM_ (u6 :: Int#) -> _APP_ u3 [ u6 ] }} in let {(u8 :: Int) = _!_ I# [] [u4]} in _!_ (:) [Int] [u8, u7]; False -> _!_ _NIL_ [Int] []; _NO_DEFLT_ }; _NO_DEFLT_ }} in _APP_ u3 [ u2 ]; _NO_DEFLT_ } _N_ },
+ enumFromThenTo = { _A_ 3 _U_ 222 _N_ _N_ _N_ _N_ } #-}
instance Enum Integer
{-# GHC_PRAGMA _M_ PreludeCore {-dfun-} _A_ 0 _N_ _N_ _N_ _F_ _IF_ARGS_ 0 0 X 6 _!_ _TUP_5 [{{Ord Integer}}, (Integer -> [Integer]), (Integer -> Integer -> [Integer]), (Integer -> Integer -> [Integer]), (Integer -> Integer -> Integer -> [Integer])] [_DFUN_ Ord (Integer), _CONSTM_ Enum enumFrom (Integer), _CONSTM_ Enum enumFromThen (Integer), _CONSTM_ Enum enumFromTo (Integer), _CONSTM_ Enum enumFromThenTo (Integer)] _N_
- enumFrom = _A_ 1 _U_ 2 _N_ _N_ _N_ _N_,
- enumFromThen = _A_ 2 _U_ 21 _N_ _N_ _N_ _N_,
- enumFromTo = _A_ 2 _U_ 22 _N_ _N_ _N_ _N_,
- enumFromThenTo = _A_ 3 _U_ 222 _N_ _N_ _N_ _N_ #-}
+ enumFrom = { _A_ 1 _U_ 2 _N_ _N_ _N_ _N_ },
+ enumFromThen = { _A_ 2 _U_ 21 _N_ _N_ _N_ _N_ },
+ enumFromTo = { _A_ 2 _U_ 22 _N_ _N_ _N_ _N_ },
+ enumFromThenTo = { _A_ 3 _U_ 222 _N_ _N_ _N_ _N_ } #-}
instance Integral a => Enum (Ratio a)
{-# GHC_PRAGMA _M_ PreludeRatio {-dfun-} _A_ 2 _U_ 22 _N_ _N_ _N_ _N_ #-}
instance Enum (Ratio Integer)
{-# GHC_PRAGMA _M_ PreludeRatio {-dfun-} _A_ 0 _N_ _N_ _N_ _F_ _IF_ARGS_ 0 0 X 6 _!_ _TUP_5 [{{Ord (Ratio Integer)}}, (Ratio Integer -> [Ratio Integer]), (Ratio Integer -> Ratio Integer -> [Ratio Integer]), (Ratio Integer -> Ratio Integer -> [Ratio Integer]), (Ratio Integer -> Ratio Integer -> Ratio Integer -> [Ratio Integer])] [_DFUN_ Ord (Ratio Integer), _CONSTM_ Enum enumFrom (Ratio Integer), _CONSTM_ Enum enumFromThen (Ratio Integer), _CONSTM_ Enum enumFromTo (Ratio Integer), _CONSTM_ Enum enumFromThenTo (Ratio Integer)] _N_
- enumFrom = _A_ 1 _U_ 2 _N_ _N_ _N_ _N_,
- enumFromThen = _A_ 2 _U_ 21 _N_ _N_ _N_ _N_,
- enumFromTo = _A_ 2 _U_ 22 _N_ _N_ _N_ _N_,
- enumFromThenTo = _A_ 3 _U_ 222 _N_ _N_ _N_ _N_ #-}
+ enumFrom = { _A_ 1 _U_ 2 _N_ _N_ _N_ _N_ },
+ enumFromThen = { _A_ 2 _U_ 21 _N_ _N_ _N_ _N_ },
+ enumFromTo = { _A_ 2 _U_ 22 _N_ _N_ _N_ _N_ },
+ enumFromThenTo = { _A_ 3 _U_ 222 _N_ _N_ _N_ _N_ } #-}
instance Eq ()
{-# GHC_PRAGMA _M_ PreludeBuiltin {-dfun-} _A_ 0 _N_ _N_ _N_ _F_ _IF_ARGS_ 0 0 X 3 _!_ _TUP_2 [(() -> () -> Bool), (() -> () -> Bool)] [_CONSTM_ Eq (==) (()), _CONSTM_ Eq (/=) (())] _N_
- (==) = _A_ 2 _U_ 11 _N_ _S_ "EE" _F_ _IF_ARGS_ 0 2 CC 3 \ (u0 :: ()) (u1 :: ()) -> case u0 of { _ALG_ _TUP_0 -> case u1 of { _ALG_ _TUP_0 -> _!_ True [] []; _NO_DEFLT_ }; _NO_DEFLT_ } _N_,
- (/=) = _A_ 2 _U_ 11 _N_ _S_ "EE" _F_ _IF_ARGS_ 0 2 CC 3 \ (u0 :: ()) (u1 :: ()) -> case u0 of { _ALG_ _TUP_0 -> case u1 of { _ALG_ _TUP_0 -> _!_ False [] []; _NO_DEFLT_ }; _NO_DEFLT_ } _N_ #-}
+ (==) = { _A_ 2 _U_ 11 _N_ _S_ "EE" _F_ _IF_ARGS_ 0 2 CC 3 \ (u0 :: ()) (u1 :: ()) -> case u0 of { _ALG_ _TUP_0 -> case u1 of { _ALG_ _TUP_0 -> _!_ True [] []; _NO_DEFLT_ }; _NO_DEFLT_ } _N_ },
+ (/=) = { _A_ 2 _U_ 11 _N_ _S_ "EE" _F_ _IF_ARGS_ 0 2 CC 3 \ (u0 :: ()) (u1 :: ()) -> case u0 of { _ALG_ _TUP_0 -> case u1 of { _ALG_ _TUP_0 -> _!_ False [] []; _NO_DEFLT_ }; _NO_DEFLT_ } _N_ } #-}
instance (Eq a, Eq b) => Eq (a, b)
- {-# GHC_PRAGMA _M_ PreludeBuiltin {-dfun-} _A_ 2 _U_ 11 _N_ _N_ _N_ _N_ #-}
+ {-# GHC_PRAGMA _M_ PreludeBuiltin {-dfun-} _A_ 2 _U_ 22 _N_ _N_ _N_ _N_ #-}
instance (Eq a, Eq b, Eq c) => Eq (a, b, c)
{-# GHC_PRAGMA _M_ PreludeBuiltin {-dfun-} _A_ 3 _U_ 111 _N_ _N_ _N_ _N_ #-}
instance (Eq a, Eq b, Eq c, Eq d) => Eq (a, b, c, d)
{-# GHC_PRAGMA _M_ PreludeBuiltin {-dfun-} _A_ 5 _U_ 11111 _N_ _N_ _N_ _N_ #-}
instance Eq (Int, Int)
{-# GHC_PRAGMA _M_ PreludeBuiltin {-dfun-} _A_ 0 _N_ _N_ _N_ _F_ _IF_ARGS_ 0 0 X 3 _!_ _TUP_2 [((Int, Int) -> (Int, Int) -> Bool), ((Int, Int) -> (Int, Int) -> Bool)] [_CONSTM_ Eq (==) ((Int, Int)), _CONSTM_ Eq (/=) ((Int, Int))] _N_
- (==) = _A_ 2 _U_ 11 _N_ _S_ "U(U(P)L)U(U(P)L)" {_A_ 4 _U_ 2121 _N_ _N_ _F_ _IF_ARGS_ 0 4 XCXC 7 \ (u0 :: Int#) (u1 :: Int) (u2 :: Int#) (u3 :: Int) -> case _#_ eqInt# [] [u0, u2] of { _ALG_ True -> case u1 of { _ALG_ I# (u4 :: Int#) -> case u3 of { _ALG_ I# (u5 :: Int#) -> _#_ eqInt# [] [u4, u5]; _NO_DEFLT_ }; _NO_DEFLT_ }; False -> _!_ False [] []; _NO_DEFLT_ } _N_} _F_ _ALWAYS_ \ (u0 :: (Int, Int)) (u1 :: (Int, Int)) -> case u0 of { _ALG_ _TUP_2 (u2 :: Int) (u3 :: Int) -> case u2 of { _ALG_ I# (u4 :: Int#) -> case u1 of { _ALG_ _TUP_2 (u5 :: Int) (u6 :: Int) -> case u5 of { _ALG_ I# (u7 :: Int#) -> case _#_ eqInt# [] [u4, u7] of { _ALG_ True -> case u3 of { _ALG_ I# (u8 :: Int#) -> case u6 of { _ALG_ I# (u9 :: Int#) -> _#_ eqInt# [] [u8, u9]; _NO_DEFLT_ }; _NO_DEFLT_ }; False -> _!_ False [] []; _NO_DEFLT_ }; _NO_DEFLT_ }; _NO_DEFLT_ }; _NO_DEFLT_ }; _NO_DEFLT_ } _N_,
- (/=) = _A_ 2 _U_ 22 _N_ _N_ _N_ _N_ #-}
+ (==) = { _A_ 2 _U_ 11 _N_ _S_ "U(U(P)L)U(U(P)L)" {_A_ 4 _U_ 2121 _N_ _N_ _F_ _IF_ARGS_ 0 4 XCXC 7 \ (u0 :: Int#) (u1 :: Int) (u2 :: Int#) (u3 :: Int) -> case _#_ eqInt# [] [u0, u2] of { _ALG_ True -> case u1 of { _ALG_ I# (u4 :: Int#) -> case u3 of { _ALG_ I# (u5 :: Int#) -> _#_ eqInt# [] [u4, u5]; _NO_DEFLT_ }; _NO_DEFLT_ }; False -> _!_ False [] []; _NO_DEFLT_ } _N_} _F_ _ALWAYS_ \ (u0 :: (Int, Int)) (u1 :: (Int, Int)) -> case u0 of { _ALG_ _TUP_2 (u2 :: Int) (u3 :: Int) -> case u2 of { _ALG_ I# (u4 :: Int#) -> case u1 of { _ALG_ _TUP_2 (u5 :: Int) (u6 :: Int) -> case u5 of { _ALG_ I# (u7 :: Int#) -> case _#_ eqInt# [] [u4, u7] of { _ALG_ True -> case u3 of { _ALG_ I# (u8 :: Int#) -> case u6 of { _ALG_ I# (u9 :: Int#) -> _#_ eqInt# [] [u8, u9]; _NO_DEFLT_ }; _NO_DEFLT_ }; False -> _!_ False [] []; _NO_DEFLT_ }; _NO_DEFLT_ }; _NO_DEFLT_ }; _NO_DEFLT_ }; _NO_DEFLT_ } _N_ },
+ (/=) = { _A_ 2 _U_ 11 _N_ _S_ "U(U(P)L)U(U(P)L)" {_A_ 4 _U_ 2121 _N_ _N_ _F_ _IF_ARGS_ 0 4 XCXC 7 \ (u0 :: Int#) (u1 :: Int) (u2 :: Int#) (u3 :: Int) -> case _#_ neInt# [] [u0, u2] of { _ALG_ True -> _!_ True [] []; False -> case u1 of { _ALG_ I# (u4 :: Int#) -> case u3 of { _ALG_ I# (u5 :: Int#) -> _#_ neInt# [] [u4, u5]; _NO_DEFLT_ }; _NO_DEFLT_ }; _NO_DEFLT_ } _N_} _F_ _ALWAYS_ \ (u0 :: (Int, Int)) (u1 :: (Int, Int)) -> case u0 of { _ALG_ _TUP_2 (u2 :: Int) (u3 :: Int) -> case u2 of { _ALG_ I# (u4 :: Int#) -> case u1 of { _ALG_ _TUP_2 (u5 :: Int) (u6 :: Int) -> case u5 of { _ALG_ I# (u7 :: Int#) -> case _#_ neInt# [] [u4, u7] of { _ALG_ True -> _!_ True [] []; False -> case u3 of { _ALG_ I# (u8 :: Int#) -> case u6 of { _ALG_ I# (u9 :: Int#) -> _#_ neInt# [] [u8, u9]; _NO_DEFLT_ }; _NO_DEFLT_ }; _NO_DEFLT_ }; _NO_DEFLT_ }; _NO_DEFLT_ }; _NO_DEFLT_ }; _NO_DEFLT_ } _N_ } #-}
+instance Eq (Int, Int, Int)
+ {-# GHC_PRAGMA _M_ PreludeBuiltin {-dfun-} _A_ 0 _N_ _N_ _N_ _F_ _IF_ARGS_ 0 0 X 3 _!_ _TUP_2 [((Int, Int, Int) -> (Int, Int, Int) -> Bool), ((Int, Int, Int) -> (Int, Int, Int) -> Bool)] [_CONSTM_ Eq (==) ((Int, Int, Int)), _CONSTM_ Eq (/=) ((Int, Int, Int))] _N_
+ (==) = { _A_ 2 _U_ 11 _N_ _S_ "U(U(P)LL)U(U(P)LL)" {_A_ 4 _U_ 2111 _N_ _N_ _N_ _N_} _N_ _N_ },
+ (/=) = { _A_ 2 _U_ 11 _N_ _S_ "U(U(P)LL)U(U(P)LL)" {_A_ 4 _U_ 2111 _N_ _N_ _N_ _N_} _N_ _N_ } #-}
+instance Eq (Int, Int, Int, Int)
+ {-# GHC_PRAGMA _M_ PreludeBuiltin {-dfun-} _A_ 0 _N_ _N_ _N_ _F_ _IF_ARGS_ 0 0 X 3 _!_ _TUP_2 [((Int, Int, Int, Int) -> (Int, Int, Int, Int) -> Bool), ((Int, Int, Int, Int) -> (Int, Int, Int, Int) -> Bool)] [_CONSTM_ Eq (==) ((Int, Int, Int, Int)), _CONSTM_ Eq (/=) ((Int, Int, Int, Int))] _N_
+ (==) = { _A_ 2 _U_ 11 _N_ _S_ "U(U(P)LLL)U(U(P)LLL)" {_A_ 5 _U_ 21111 _N_ _N_ _N_ _N_} _N_ _N_ },
+ (/=) = { _A_ 2 _U_ 11 _N_ _S_ "U(U(P)LLL)U(U(P)LLL)" {_A_ 5 _U_ 21111 _N_ _N_ _N_ _N_} _N_ _N_ } #-}
+instance Eq (Int, Int, Int, Int, Int)
+ {-# GHC_PRAGMA _M_ PreludeBuiltin {-dfun-} _A_ 0 _N_ _N_ _N_ _F_ _IF_ARGS_ 0 0 X 3 _!_ _TUP_2 [((Int, Int, Int, Int, Int) -> (Int, Int, Int, Int, Int) -> Bool), ((Int, Int, Int, Int, Int) -> (Int, Int, Int, Int, Int) -> Bool)] [_CONSTM_ Eq (==) ((Int, Int, Int, Int, Int)), _CONSTM_ Eq (/=) ((Int, Int, Int, Int, Int))] _N_
+ (==) = { _A_ 2 _U_ 11 _N_ _S_ "U(U(P)LLLL)U(U(P)LLLL)" _N_ _N_ },
+ (/=) = { _A_ 2 _U_ 11 _N_ _S_ "U(U(P)LLLL)U(U(P)LLLL)" _N_ _N_ } #-}
+instance Eq ([Char], [Char])
+ {-# GHC_PRAGMA _M_ PreludeBuiltin {-dfun-} _A_ 0 _N_ _N_ _N_ _F_ _IF_ARGS_ 0 0 X 3 _!_ _TUP_2 [(([Char], [Char]) -> ([Char], [Char]) -> Bool), (([Char], [Char]) -> ([Char], [Char]) -> Bool)] [_CONSTM_ Eq (==) (([Char], [Char])), _CONSTM_ Eq (/=) (([Char], [Char]))] _N_
+ (==) = { _A_ 2 _U_ 11 _N_ _S_ "U(SL)U(SL)" {_A_ 4 _U_ 2222 _N_ _N_ _N_ _N_} _N_ _N_ },
+ (/=) = { _A_ 2 _U_ 11 _N_ _S_ "U(SL)U(SL)" {_A_ 4 _U_ 2222 _N_ _N_ _N_ _N_} _N_ _N_ } #-}
+instance Eq ([Int], [Int])
+ {-# GHC_PRAGMA _M_ PreludeBuiltin {-dfun-} _A_ 0 _N_ _N_ _N_ _F_ _IF_ARGS_ 0 0 X 3 _!_ _TUP_2 [(([Int], [Int]) -> ([Int], [Int]) -> Bool), (([Int], [Int]) -> ([Int], [Int]) -> Bool)] [_CONSTM_ Eq (==) (([Int], [Int])), _CONSTM_ Eq (/=) (([Int], [Int]))] _N_
+ (==) = { _A_ 2 _U_ 11 _N_ _S_ "U(SL)U(SL)" {_A_ 4 _U_ 2222 _N_ _N_ _N_ _N_} _N_ _N_ },
+ (/=) = { _A_ 2 _U_ 11 _N_ _S_ "U(SL)U(SL)" {_A_ 4 _U_ 2222 _N_ _N_ _N_ _N_} _N_ _N_ } #-}
instance Eq (_PackedString, _PackedString)
{-# GHC_PRAGMA _M_ PreludeBuiltin {-dfun-} _A_ 0 _N_ _N_ _N_ _F_ _IF_ARGS_ 0 0 X 3 _!_ _TUP_2 [((_PackedString, _PackedString) -> (_PackedString, _PackedString) -> Bool), ((_PackedString, _PackedString) -> (_PackedString, _PackedString) -> Bool)] [_CONSTM_ Eq (==) ((_PackedString, _PackedString)), _CONSTM_ Eq (/=) ((_PackedString, _PackedString))] _N_
- (==) = _A_ 2 _U_ 11 _N_ _S_ "U(SL)U(SL)" {_A_ 4 _U_ 2222 _N_ _N_ _N_ _N_} _N_ _N_,
- (/=) = _A_ 2 _U_ 22 _N_ _N_ _N_ _N_ #-}
+ (==) = { _A_ 2 _U_ 11 _N_ _S_ "U(SL)U(SL)" {_A_ 4 _U_ 2222 _N_ _N_ _N_ _N_} _N_ _N_ },
+ (/=) = { _A_ 2 _U_ 11 _N_ _S_ "U(SL)U(SL)" {_A_ 4 _U_ 2222 _N_ _N_ _N_ _N_} _N_ _N_ } #-}
instance (Ix a, Eq b) => Eq (Array a b)
{-# GHC_PRAGMA _M_ PreludeArray {-dfun-} _A_ 2 _U_ 21 _N_ _N_ _N_ _N_ #-}
instance (Eq a, Eq b) => Eq (Assoc a b)
{-# GHC_PRAGMA _M_ PreludeArray {-dfun-} _A_ 2 _U_ 11 _N_ _N_ _N_ _N_ #-}
instance Eq Bool
{-# GHC_PRAGMA _M_ PreludeCore {-dfun-} _A_ 0 _N_ _N_ _N_ _F_ _IF_ARGS_ 0 0 X 3 _!_ _TUP_2 [(Bool -> Bool -> Bool), (Bool -> Bool -> Bool)] [_CONSTM_ Eq (==) (Bool), _CONSTM_ Eq (/=) (Bool)] _N_
- (==) = _A_ 2 _U_ 11 _N_ _S_ "EE" _F_ _IF_ARGS_ 0 2 CC 7 \ (u0 :: Bool) (u1 :: Bool) -> case u0 of { _ALG_ True -> u1; False -> case u1 of { _ALG_ True -> _!_ False [] []; False -> _!_ True [] []; _NO_DEFLT_ }; _NO_DEFLT_ } _N_,
- (/=) = _A_ 2 _U_ 11 _N_ _S_ "EE" _F_ _IF_ARGS_ 0 2 CC 7 \ (u0 :: Bool) (u1 :: Bool) -> case u0 of { _ALG_ True -> case u1 of { _ALG_ True -> _!_ False [] []; False -> _!_ True [] []; _NO_DEFLT_ }; False -> u1; _NO_DEFLT_ } _N_ #-}
+ (==) = { _A_ 2 _U_ 11 _N_ _S_ "EE" _F_ _IF_ARGS_ 0 2 CC 7 \ (u0 :: Bool) (u1 :: Bool) -> case u0 of { _ALG_ True -> u1; False -> case u1 of { _ALG_ True -> _!_ False [] []; False -> _!_ True [] []; _NO_DEFLT_ }; _NO_DEFLT_ } _N_ },
+ (/=) = { _A_ 2 _U_ 11 _N_ _S_ "EE" _F_ _IF_ARGS_ 0 2 CC 7 \ (u0 :: Bool) (u1 :: Bool) -> case u0 of { _ALG_ True -> case u1 of { _ALG_ True -> _!_ False [] []; False -> _!_ True [] []; _NO_DEFLT_ }; False -> u1; _NO_DEFLT_ } _N_ } #-}
instance Eq Char
{-# GHC_PRAGMA _M_ PreludeCore {-dfun-} _A_ 0 _N_ _N_ _N_ _F_ _IF_ARGS_ 0 0 X 3 _!_ _TUP_2 [(Char -> Char -> Bool), (Char -> Char -> Bool)] [_CONSTM_ Eq (==) (Char), _CONSTM_ Eq (/=) (Char)] _N_
- (==) = _A_ 2 _U_ 11 _N_ _S_ "U(P)U(P)" {_A_ 2 _U_ 22 _N_ _N_ _F_ _IF_ARGS_ 0 2 XX 1 \ (u0 :: Char#) (u1 :: Char#) -> _#_ eqChar# [] [u0, u1] _N_} _F_ _IF_ARGS_ 0 2 CC 3 \ (u0 :: Char) (u1 :: Char) -> case u0 of { _ALG_ C# (u2 :: Char#) -> case u1 of { _ALG_ C# (u3 :: Char#) -> _#_ eqChar# [] [u2, u3]; _NO_DEFLT_ }; _NO_DEFLT_ } _N_,
- (/=) = _A_ 2 _U_ 11 _N_ _S_ "U(P)U(P)" {_A_ 2 _U_ 22 _N_ _N_ _F_ _IF_ARGS_ 0 2 XX 1 \ (u0 :: Char#) (u1 :: Char#) -> _#_ neChar# [] [u0, u1] _N_} _F_ _IF_ARGS_ 0 2 CC 3 \ (u0 :: Char) (u1 :: Char) -> case u0 of { _ALG_ C# (u2 :: Char#) -> case u1 of { _ALG_ C# (u3 :: Char#) -> _#_ neChar# [] [u2, u3]; _NO_DEFLT_ }; _NO_DEFLT_ } _N_ #-}
+ (==) = { _A_ 2 _U_ 11 _N_ _S_ "U(P)U(P)" {_A_ 2 _U_ 22 _N_ _N_ _F_ _IF_ARGS_ 0 2 XX 1 \ (u0 :: Char#) (u1 :: Char#) -> _#_ eqChar# [] [u0, u1] _N_} _F_ _IF_ARGS_ 0 2 CC 3 \ (u0 :: Char) (u1 :: Char) -> case u0 of { _ALG_ C# (u2 :: Char#) -> case u1 of { _ALG_ C# (u3 :: Char#) -> _#_ eqChar# [] [u2, u3]; _NO_DEFLT_ }; _NO_DEFLT_ } _N_ },
+ (/=) = { _A_ 2 _U_ 11 _N_ _S_ "U(P)U(P)" {_A_ 2 _U_ 22 _N_ _N_ _F_ _IF_ARGS_ 0 2 XX 1 \ (u0 :: Char#) (u1 :: Char#) -> _#_ neChar# [] [u0, u1] _N_} _F_ _IF_ARGS_ 0 2 CC 3 \ (u0 :: Char) (u1 :: Char) -> case u0 of { _ALG_ C# (u2 :: Char#) -> case u1 of { _ALG_ C# (u3 :: Char#) -> _#_ neChar# [] [u2, u3]; _NO_DEFLT_ }; _NO_DEFLT_ } _N_ } #-}
instance Eq a => Eq (Complex a)
{-# GHC_PRAGMA _M_ PreludeComplex {-dfun-} _A_ 1 _U_ 2 _N_ _N_ _N_ _N_ #-}
instance Eq (Complex Double)
{-# GHC_PRAGMA _M_ PreludeComplex {-dfun-} _A_ 0 _N_ _N_ _N_ _F_ _IF_ARGS_ 0 0 X 3 _!_ _TUP_2 [(Complex Double -> Complex Double -> Bool), (Complex Double -> Complex Double -> Bool)] [_CONSTM_ Eq (==) (Complex Double), _CONSTM_ Eq (/=) (Complex Double)] _N_
- (==) = _A_ 2 _U_ 11 _N_ _S_ "U(U(P)L)U(U(P)L)" {_A_ 4 _U_ 2121 _N_ _N_ _F_ _IF_ARGS_ 0 4 XCXC 7 \ (u0 :: Double#) (u1 :: Double) (u2 :: Double#) (u3 :: Double) -> case _#_ eqDouble# [] [u0, u2] of { _ALG_ True -> case u1 of { _ALG_ D# (u4 :: Double#) -> case u3 of { _ALG_ D# (u5 :: Double#) -> _#_ eqDouble# [] [u4, u5]; _NO_DEFLT_ }; _NO_DEFLT_ }; False -> _!_ False [] []; _NO_DEFLT_ } _N_} _F_ _ALWAYS_ \ (u0 :: Complex Double) (u1 :: Complex Double) -> case u0 of { _ALG_ (:+) (u2 :: Double) (u3 :: Double) -> case u2 of { _ALG_ D# (u4 :: Double#) -> case u1 of { _ALG_ (:+) (u5 :: Double) (u6 :: Double) -> case u5 of { _ALG_ D# (u7 :: Double#) -> case _#_ eqDouble# [] [u4, u7] of { _ALG_ True -> case u3 of { _ALG_ D# (u8 :: Double#) -> case u6 of { _ALG_ D# (u9 :: Double#) -> _#_ eqDouble# [] [u8, u9]; _NO_DEFLT_ }; _NO_DEFLT_ }; False -> _!_ False [] []; _NO_DEFLT_ }; _NO_DEFLT_ }; _NO_DEFLT_ }; _NO_DEFLT_ }; _NO_DEFLT_ } _N_,
- (/=) = _A_ 2 _U_ 11 _N_ _S_ "U(U(P)L)U(U(P)L)" {_A_ 4 _U_ 2121 _N_ _N_ _F_ _IF_ARGS_ 0 4 XCXC 7 \ (u0 :: Double#) (u1 :: Double) (u2 :: Double#) (u3 :: Double) -> case _#_ neDouble# [] [u0, u2] of { _ALG_ True -> _!_ True [] []; False -> case u1 of { _ALG_ D# (u4 :: Double#) -> case u3 of { _ALG_ D# (u5 :: Double#) -> _#_ neDouble# [] [u4, u5]; _NO_DEFLT_ }; _NO_DEFLT_ }; _NO_DEFLT_ } _N_} _F_ _ALWAYS_ \ (u0 :: Complex Double) (u1 :: Complex Double) -> case u0 of { _ALG_ (:+) (u2 :: Double) (u3 :: Double) -> case u2 of { _ALG_ D# (u4 :: Double#) -> case u1 of { _ALG_ (:+) (u5 :: Double) (u6 :: Double) -> case u5 of { _ALG_ D# (u7 :: Double#) -> case _#_ neDouble# [] [u4, u7] of { _ALG_ True -> _!_ True [] []; False -> case u3 of { _ALG_ D# (u8 :: Double#) -> case u6 of { _ALG_ D# (u9 :: Double#) -> _#_ neDouble# [] [u8, u9]; _NO_DEFLT_ }; _NO_DEFLT_ }; _NO_DEFLT_ }; _NO_DEFLT_ }; _NO_DEFLT_ }; _NO_DEFLT_ }; _NO_DEFLT_ } _N_ #-}
+ (==) = { _A_ 2 _U_ 11 _N_ _S_ "U(U(P)L)U(U(P)L)" {_A_ 4 _U_ 2121 _N_ _N_ _F_ _IF_ARGS_ 0 4 XCXC 7 \ (u0 :: Double#) (u1 :: Double) (u2 :: Double#) (u3 :: Double) -> case _#_ eqDouble# [] [u0, u2] of { _ALG_ True -> case u1 of { _ALG_ D# (u4 :: Double#) -> case u3 of { _ALG_ D# (u5 :: Double#) -> _#_ eqDouble# [] [u4, u5]; _NO_DEFLT_ }; _NO_DEFLT_ }; False -> _!_ False [] []; _NO_DEFLT_ } _N_} _F_ _ALWAYS_ \ (u0 :: Complex Double) (u1 :: Complex Double) -> case u0 of { _ALG_ (:+) (u2 :: Double) (u3 :: Double) -> case u2 of { _ALG_ D# (u4 :: Double#) -> case u1 of { _ALG_ (:+) (u5 :: Double) (u6 :: Double) -> case u5 of { _ALG_ D# (u7 :: Double#) -> case _#_ eqDouble# [] [u4, u7] of { _ALG_ True -> case u3 of { _ALG_ D# (u8 :: Double#) -> case u6 of { _ALG_ D# (u9 :: Double#) -> _#_ eqDouble# [] [u8, u9]; _NO_DEFLT_ }; _NO_DEFLT_ }; False -> _!_ False [] []; _NO_DEFLT_ }; _NO_DEFLT_ }; _NO_DEFLT_ }; _NO_DEFLT_ }; _NO_DEFLT_ } _N_ },
+ (/=) = { _A_ 2 _U_ 11 _N_ _S_ "U(U(P)L)U(U(P)L)" {_A_ 4 _U_ 2121 _N_ _N_ _F_ _IF_ARGS_ 0 4 XCXC 7 \ (u0 :: Double#) (u1 :: Double) (u2 :: Double#) (u3 :: Double) -> case _#_ neDouble# [] [u0, u2] of { _ALG_ True -> _!_ True [] []; False -> case u1 of { _ALG_ D# (u4 :: Double#) -> case u3 of { _ALG_ D# (u5 :: Double#) -> _#_ neDouble# [] [u4, u5]; _NO_DEFLT_ }; _NO_DEFLT_ }; _NO_DEFLT_ } _N_} _F_ _ALWAYS_ \ (u0 :: Complex Double) (u1 :: Complex Double) -> case u0 of { _ALG_ (:+) (u2 :: Double) (u3 :: Double) -> case u2 of { _ALG_ D# (u4 :: Double#) -> case u1 of { _ALG_ (:+) (u5 :: Double) (u6 :: Double) -> case u5 of { _ALG_ D# (u7 :: Double#) -> case _#_ neDouble# [] [u4, u7] of { _ALG_ True -> _!_ True [] []; False -> case u3 of { _ALG_ D# (u8 :: Double#) -> case u6 of { _ALG_ D# (u9 :: Double#) -> _#_ neDouble# [] [u8, u9]; _NO_DEFLT_ }; _NO_DEFLT_ }; _NO_DEFLT_ }; _NO_DEFLT_ }; _NO_DEFLT_ }; _NO_DEFLT_ }; _NO_DEFLT_ } _N_ } #-}
instance Eq Double
{-# GHC_PRAGMA _M_ PreludeCore {-dfun-} _A_ 0 _N_ _N_ _N_ _F_ _IF_ARGS_ 0 0 X 3 _!_ _TUP_2 [(Double -> Double -> Bool), (Double -> Double -> Bool)] [_CONSTM_ Eq (==) (Double), _CONSTM_ Eq (/=) (Double)] _N_
- (==) = _A_ 2 _U_ 11 _N_ _S_ "U(P)U(P)" {_A_ 2 _U_ 22 _N_ _N_ _F_ _IF_ARGS_ 0 2 XX 1 \ (u0 :: Double#) (u1 :: Double#) -> _#_ eqDouble# [] [u0, u1] _N_} _F_ _IF_ARGS_ 0 2 CC 3 \ (u0 :: Double) (u1 :: Double) -> case u0 of { _ALG_ D# (u2 :: Double#) -> case u1 of { _ALG_ D# (u3 :: Double#) -> _#_ eqDouble# [] [u2, u3]; _NO_DEFLT_ }; _NO_DEFLT_ } _N_,
- (/=) = _A_ 2 _U_ 11 _N_ _S_ "U(P)U(P)" {_A_ 2 _U_ 22 _N_ _N_ _F_ _IF_ARGS_ 0 2 XX 1 \ (u0 :: Double#) (u1 :: Double#) -> _#_ neDouble# [] [u0, u1] _N_} _F_ _IF_ARGS_ 0 2 CC 3 \ (u0 :: Double) (u1 :: Double) -> case u0 of { _ALG_ D# (u2 :: Double#) -> case u1 of { _ALG_ D# (u3 :: Double#) -> _#_ neDouble# [] [u2, u3]; _NO_DEFLT_ }; _NO_DEFLT_ } _N_ #-}
+ (==) = { _A_ 2 _U_ 11 _N_ _S_ "U(P)U(P)" {_A_ 2 _U_ 22 _N_ _N_ _F_ _IF_ARGS_ 0 2 XX 1 \ (u0 :: Double#) (u1 :: Double#) -> _#_ eqDouble# [] [u0, u1] _N_} _F_ _IF_ARGS_ 0 2 CC 3 \ (u0 :: Double) (u1 :: Double) -> case u0 of { _ALG_ D# (u2 :: Double#) -> case u1 of { _ALG_ D# (u3 :: Double#) -> _#_ eqDouble# [] [u2, u3]; _NO_DEFLT_ }; _NO_DEFLT_ } _N_ },
+ (/=) = { _A_ 2 _U_ 11 _N_ _S_ "U(P)U(P)" {_A_ 2 _U_ 22 _N_ _N_ _F_ _IF_ARGS_ 0 2 XX 1 \ (u0 :: Double#) (u1 :: Double#) -> _#_ neDouble# [] [u0, u1] _N_} _F_ _IF_ARGS_ 0 2 CC 3 \ (u0 :: Double) (u1 :: Double) -> case u0 of { _ALG_ D# (u2 :: Double#) -> case u1 of { _ALG_ D# (u3 :: Double#) -> _#_ neDouble# [] [u2, u3]; _NO_DEFLT_ }; _NO_DEFLT_ } _N_ } #-}
instance (Eq a, Eq b) => Eq (Either a b)
{-# GHC_PRAGMA _M_ PreludeMonadicIO {-dfun-} _A_ 2 _U_ 11 _N_ _N_ _N_ _N_ #-}
instance Eq Float
{-# GHC_PRAGMA _M_ PreludeCore {-dfun-} _A_ 0 _N_ _N_ _N_ _F_ _IF_ARGS_ 0 0 X 3 _!_ _TUP_2 [(Float -> Float -> Bool), (Float -> Float -> Bool)] [_CONSTM_ Eq (==) (Float), _CONSTM_ Eq (/=) (Float)] _N_
- (==) = _A_ 2 _U_ 11 _N_ _S_ "U(P)U(P)" {_A_ 2 _U_ 22 _N_ _N_ _F_ _IF_ARGS_ 0 2 XX 1 \ (u0 :: Float#) (u1 :: Float#) -> _#_ eqFloat# [] [u0, u1] _N_} _F_ _IF_ARGS_ 0 2 CC 3 \ (u0 :: Float) (u1 :: Float) -> case u0 of { _ALG_ F# (u2 :: Float#) -> case u1 of { _ALG_ F# (u3 :: Float#) -> _#_ eqFloat# [] [u2, u3]; _NO_DEFLT_ }; _NO_DEFLT_ } _N_,
- (/=) = _A_ 2 _U_ 11 _N_ _S_ "U(P)U(P)" {_A_ 2 _U_ 22 _N_ _N_ _F_ _IF_ARGS_ 0 2 XX 1 \ (u0 :: Float#) (u1 :: Float#) -> _#_ neFloat# [] [u0, u1] _N_} _F_ _IF_ARGS_ 0 2 CC 3 \ (u0 :: Float) (u1 :: Float) -> case u0 of { _ALG_ F# (u2 :: Float#) -> case u1 of { _ALG_ F# (u3 :: Float#) -> _#_ neFloat# [] [u2, u3]; _NO_DEFLT_ }; _NO_DEFLT_ } _N_ #-}
+ (==) = { _A_ 2 _U_ 11 _N_ _S_ "U(P)U(P)" {_A_ 2 _U_ 22 _N_ _N_ _F_ _IF_ARGS_ 0 2 XX 1 \ (u0 :: Float#) (u1 :: Float#) -> _#_ eqFloat# [] [u0, u1] _N_} _F_ _IF_ARGS_ 0 2 CC 3 \ (u0 :: Float) (u1 :: Float) -> case u0 of { _ALG_ F# (u2 :: Float#) -> case u1 of { _ALG_ F# (u3 :: Float#) -> _#_ eqFloat# [] [u2, u3]; _NO_DEFLT_ }; _NO_DEFLT_ } _N_ },
+ (/=) = { _A_ 2 _U_ 11 _N_ _S_ "U(P)U(P)" {_A_ 2 _U_ 22 _N_ _N_ _F_ _IF_ARGS_ 0 2 XX 1 \ (u0 :: Float#) (u1 :: Float#) -> _#_ neFloat# [] [u0, u1] _N_} _F_ _IF_ARGS_ 0 2 CC 3 \ (u0 :: Float) (u1 :: Float) -> case u0 of { _ALG_ F# (u2 :: Float#) -> case u1 of { _ALG_ F# (u3 :: Float#) -> _#_ neFloat# [] [u2, u3]; _NO_DEFLT_ }; _NO_DEFLT_ } _N_ } #-}
instance Eq Int
{-# GHC_PRAGMA _M_ PreludeCore {-dfun-} _A_ 0 _N_ _N_ _N_ _F_ _IF_ARGS_ 0 0 X 3 _!_ _TUP_2 [(Int -> Int -> Bool), (Int -> Int -> Bool)] [_CONSTM_ Eq (==) (Int), _CONSTM_ Eq (/=) (Int)] _N_
- (==) = _A_ 2 _U_ 11 _N_ _S_ "U(P)U(P)" {_A_ 2 _U_ 22 _N_ _N_ _F_ _IF_ARGS_ 0 2 XX 1 \ (u0 :: Int#) (u1 :: Int#) -> _#_ eqInt# [] [u0, u1] _N_} _F_ _IF_ARGS_ 0 2 CC 3 \ (u0 :: Int) (u1 :: Int) -> case u0 of { _ALG_ I# (u2 :: Int#) -> case u1 of { _ALG_ I# (u3 :: Int#) -> _#_ eqInt# [] [u2, u3]; _NO_DEFLT_ }; _NO_DEFLT_ } _N_,
- (/=) = _A_ 2 _U_ 11 _N_ _S_ "U(P)U(P)" {_A_ 2 _U_ 22 _N_ _N_ _F_ _IF_ARGS_ 0 2 XX 1 \ (u0 :: Int#) (u1 :: Int#) -> _#_ neInt# [] [u0, u1] _N_} _F_ _IF_ARGS_ 0 2 CC 3 \ (u0 :: Int) (u1 :: Int) -> case u0 of { _ALG_ I# (u2 :: Int#) -> case u1 of { _ALG_ I# (u3 :: Int#) -> _#_ neInt# [] [u2, u3]; _NO_DEFLT_ }; _NO_DEFLT_ } _N_ #-}
+ (==) = { _A_ 2 _U_ 11 _N_ _S_ "U(P)U(P)" {_A_ 2 _U_ 22 _N_ _N_ _F_ _IF_ARGS_ 0 2 XX 1 \ (u0 :: Int#) (u1 :: Int#) -> _#_ eqInt# [] [u0, u1] _N_} _F_ _IF_ARGS_ 0 2 CC 3 \ (u0 :: Int) (u1 :: Int) -> case u0 of { _ALG_ I# (u2 :: Int#) -> case u1 of { _ALG_ I# (u3 :: Int#) -> _#_ eqInt# [] [u2, u3]; _NO_DEFLT_ }; _NO_DEFLT_ } _N_ },
+ (/=) = { _A_ 2 _U_ 11 _N_ _S_ "U(P)U(P)" {_A_ 2 _U_ 22 _N_ _N_ _F_ _IF_ARGS_ 0 2 XX 1 \ (u0 :: Int#) (u1 :: Int#) -> _#_ neInt# [] [u0, u1] _N_} _F_ _IF_ARGS_ 0 2 CC 3 \ (u0 :: Int) (u1 :: Int) -> case u0 of { _ALG_ I# (u2 :: Int#) -> case u1 of { _ALG_ I# (u3 :: Int#) -> _#_ neInt# [] [u2, u3]; _NO_DEFLT_ }; _NO_DEFLT_ } _N_ } #-}
instance Eq Integer
{-# GHC_PRAGMA _M_ PreludeCore {-dfun-} _A_ 0 _N_ _N_ _N_ _F_ _IF_ARGS_ 0 0 X 3 _!_ _TUP_2 [(Integer -> Integer -> Bool), (Integer -> Integer -> Bool)] [_CONSTM_ Eq (==) (Integer), _CONSTM_ Eq (/=) (Integer)] _N_
- (==) = _A_ 2 _U_ 11 _N_ _S_ "U(PPP)U(PPP)" {_A_ 4 _U_ 2221 _N_ _N_ _F_ _IF_ARGS_ 0 4 XXXC 4 \ (u0 :: Int#) (u1 :: Int#) (u2 :: ByteArray#) (u3 :: Integer) -> case u3 of { _ALG_ J# (u4 :: Int#) (u5 :: Int#) (u6 :: ByteArray#) -> case _#_ cmpInteger# [] [u0, u1, u2, u4, u5, u6] of { _PRIM_ 0# -> _!_ True [] []; (u7 :: Int#) -> _!_ False [] [] }; _NO_DEFLT_ } _N_} _F_ _IF_ARGS_ 0 2 CC 5 \ (u0 :: Integer) (u1 :: Integer) -> case u0 of { _ALG_ J# (u2 :: Int#) (u3 :: Int#) (u4 :: ByteArray#) -> case u1 of { _ALG_ J# (u5 :: Int#) (u6 :: Int#) (u7 :: ByteArray#) -> case _#_ cmpInteger# [] [u2, u3, u4, u5, u6, u7] of { _PRIM_ 0# -> _!_ True [] []; (u8 :: Int#) -> _!_ False [] [] }; _NO_DEFLT_ }; _NO_DEFLT_ } _N_,
- (/=) = _A_ 2 _U_ 11 _N_ _S_ "U(PPP)U(PPP)" {_A_ 4 _U_ 2221 _N_ _N_ _F_ _IF_ARGS_ 0 4 XXXC 4 \ (u0 :: Int#) (u1 :: Int#) (u2 :: ByteArray#) (u3 :: Integer) -> case u3 of { _ALG_ J# (u4 :: Int#) (u5 :: Int#) (u6 :: ByteArray#) -> case _#_ cmpInteger# [] [u0, u1, u2, u4, u5, u6] of { _PRIM_ 0# -> _!_ False [] []; (u7 :: Int#) -> _!_ True [] [] }; _NO_DEFLT_ } _N_} _F_ _IF_ARGS_ 0 2 CC 5 \ (u0 :: Integer) (u1 :: Integer) -> case u0 of { _ALG_ J# (u2 :: Int#) (u3 :: Int#) (u4 :: ByteArray#) -> case u1 of { _ALG_ J# (u5 :: Int#) (u6 :: Int#) (u7 :: ByteArray#) -> case _#_ cmpInteger# [] [u2, u3, u4, u5, u6, u7] of { _PRIM_ 0# -> _!_ False [] []; (u8 :: Int#) -> _!_ True [] [] }; _NO_DEFLT_ }; _NO_DEFLT_ } _N_ #-}
+ (==) = { _A_ 2 _U_ 11 _N_ _S_ "U(PPP)U(PPP)" {_A_ 4 _U_ 2221 _N_ _N_ _F_ _IF_ARGS_ 0 4 XXXC 4 \ (u0 :: Int#) (u1 :: Int#) (u2 :: ByteArray#) (u3 :: Integer) -> case u3 of { _ALG_ J# (u4 :: Int#) (u5 :: Int#) (u6 :: ByteArray#) -> case _#_ cmpInteger# [] [u0, u1, u2, u4, u5, u6] of { _PRIM_ 0# -> _!_ True [] []; (u7 :: Int#) -> _!_ False [] [] }; _NO_DEFLT_ } _N_} _F_ _IF_ARGS_ 0 2 CC 5 \ (u0 :: Integer) (u1 :: Integer) -> case u0 of { _ALG_ J# (u2 :: Int#) (u3 :: Int#) (u4 :: ByteArray#) -> case u1 of { _ALG_ J# (u5 :: Int#) (u6 :: Int#) (u7 :: ByteArray#) -> case _#_ cmpInteger# [] [u2, u3, u4, u5, u6, u7] of { _PRIM_ 0# -> _!_ True [] []; (u8 :: Int#) -> _!_ False [] [] }; _NO_DEFLT_ }; _NO_DEFLT_ } _N_ },
+ (/=) = { _A_ 2 _U_ 11 _N_ _S_ "U(PPP)U(PPP)" {_A_ 4 _U_ 2221 _N_ _N_ _F_ _IF_ARGS_ 0 4 XXXC 4 \ (u0 :: Int#) (u1 :: Int#) (u2 :: ByteArray#) (u3 :: Integer) -> case u3 of { _ALG_ J# (u4 :: Int#) (u5 :: Int#) (u6 :: ByteArray#) -> case _#_ cmpInteger# [] [u0, u1, u2, u4, u5, u6] of { _PRIM_ 0# -> _!_ False [] []; (u7 :: Int#) -> _!_ True [] [] }; _NO_DEFLT_ } _N_} _F_ _IF_ARGS_ 0 2 CC 5 \ (u0 :: Integer) (u1 :: Integer) -> case u0 of { _ALG_ J# (u2 :: Int#) (u3 :: Int#) (u4 :: ByteArray#) -> case u1 of { _ALG_ J# (u5 :: Int#) (u6 :: Int#) (u7 :: ByteArray#) -> case _#_ cmpInteger# [] [u2, u3, u4, u5, u6, u7] of { _PRIM_ 0# -> _!_ False [] []; (u8 :: Int#) -> _!_ True [] [] }; _NO_DEFLT_ }; _NO_DEFLT_ } _N_ } #-}
instance Eq a => Eq (Maybe a)
{-# GHC_PRAGMA _M_ PreludeStdIO {-dfun-} _A_ 1 _U_ 1 _N_ _N_ _N_ _N_ #-}
instance Integral a => Eq (Ratio a)
{-# GHC_PRAGMA _M_ PreludeRatio {-dfun-} _A_ 1 _U_ 1 _N_ _N_ _N_ _N_ #-}
instance Eq (Ratio Integer)
{-# GHC_PRAGMA _M_ PreludeRatio {-dfun-} _A_ 0 _N_ _N_ _N_ _F_ _IF_ARGS_ 0 0 X 3 _!_ _TUP_2 [(Ratio Integer -> Ratio Integer -> Bool), (Ratio Integer -> Ratio Integer -> Bool)] [_CONSTM_ Eq (==) (Ratio Integer), _CONSTM_ Eq (/=) (Ratio Integer)] _N_
- (==) = _A_ 2 _U_ 11 _N_ _S_ "U(U(PPP)L)U(U(PPP)L)" {_A_ 5 _U_ 22211 _N_ _N_ _F_ _IF_ARGS_ 0 5 XXXCC 9 \ (u0 :: Int#) (u1 :: Int#) (u2 :: ByteArray#) (u3 :: Integer) (u4 :: Ratio Integer) -> case u4 of { _ALG_ (:%) (u5 :: Integer) (u6 :: Integer) -> case u5 of { _ALG_ J# (u7 :: Int#) (u8 :: Int#) (u9 :: ByteArray#) -> case _#_ cmpInteger# [] [u0, u1, u2, u7, u8, u9] of { _PRIM_ 0# -> case u3 of { _ALG_ J# (ua :: Int#) (ub :: Int#) (uc :: ByteArray#) -> case u6 of { _ALG_ J# (ud :: Int#) (ue :: Int#) (uf :: ByteArray#) -> case _#_ cmpInteger# [] [ua, ub, uc, ud, ue, uf] of { _PRIM_ 0# -> _!_ True [] []; (ug :: Int#) -> _!_ False [] [] }; _NO_DEFLT_ }; _NO_DEFLT_ }; (uh :: Int#) -> _!_ False [] [] }; _NO_DEFLT_ }; _NO_DEFLT_ } _N_} _N_ _N_,
- (/=) = _A_ 2 _U_ 11 _N_ _S_ "U(U(PPP)L)U(U(PPP)L)" {_A_ 5 _U_ 22211 _N_ _N_ _F_ _IF_ARGS_ 0 5 XXXCC 9 \ (u0 :: Int#) (u1 :: Int#) (u2 :: ByteArray#) (u3 :: Integer) (u4 :: Ratio Integer) -> case u4 of { _ALG_ (:%) (u5 :: Integer) (u6 :: Integer) -> case u5 of { _ALG_ J# (u7 :: Int#) (u8 :: Int#) (u9 :: ByteArray#) -> case _#_ cmpInteger# [] [u0, u1, u2, u7, u8, u9] of { _PRIM_ 0# -> case u3 of { _ALG_ J# (ua :: Int#) (ub :: Int#) (uc :: ByteArray#) -> case u6 of { _ALG_ J# (ud :: Int#) (ue :: Int#) (uf :: ByteArray#) -> case _#_ cmpInteger# [] [ua, ub, uc, ud, ue, uf] of { _PRIM_ 0# -> _!_ False [] []; (ug :: Int#) -> _!_ True [] [] }; _NO_DEFLT_ }; _NO_DEFLT_ }; (uh :: Int#) -> _!_ True [] [] }; _NO_DEFLT_ }; _NO_DEFLT_ } _N_} _N_ _N_ #-}
+ (==) = { _A_ 2 _U_ 11 _N_ _S_ "U(U(PPP)L)U(U(PPP)L)" {_A_ 5 _U_ 22211 _N_ _N_ _F_ _IF_ARGS_ 0 5 XXXCC 9 \ (u0 :: Int#) (u1 :: Int#) (u2 :: ByteArray#) (u3 :: Integer) (u4 :: Ratio Integer) -> case u4 of { _ALG_ (:%) (u5 :: Integer) (u6 :: Integer) -> case u5 of { _ALG_ J# (u7 :: Int#) (u8 :: Int#) (u9 :: ByteArray#) -> case _#_ cmpInteger# [] [u0, u1, u2, u7, u8, u9] of { _PRIM_ 0# -> case u3 of { _ALG_ J# (ua :: Int#) (ub :: Int#) (uc :: ByteArray#) -> case u6 of { _ALG_ J# (ud :: Int#) (ue :: Int#) (uf :: ByteArray#) -> case _#_ cmpInteger# [] [ua, ub, uc, ud, ue, uf] of { _PRIM_ 0# -> _!_ True [] []; (ug :: Int#) -> _!_ False [] [] }; _NO_DEFLT_ }; _NO_DEFLT_ }; (uh :: Int#) -> _!_ False [] [] }; _NO_DEFLT_ }; _NO_DEFLT_ } _N_} _N_ _N_ },
+ (/=) = { _A_ 2 _U_ 11 _N_ _S_ "U(U(PPP)L)U(U(PPP)L)" {_A_ 5 _U_ 22211 _N_ _N_ _F_ _IF_ARGS_ 0 5 XXXCC 9 \ (u0 :: Int#) (u1 :: Int#) (u2 :: ByteArray#) (u3 :: Integer) (u4 :: Ratio Integer) -> case u4 of { _ALG_ (:%) (u5 :: Integer) (u6 :: Integer) -> case u5 of { _ALG_ J# (u7 :: Int#) (u8 :: Int#) (u9 :: ByteArray#) -> case _#_ cmpInteger# [] [u0, u1, u2, u7, u8, u9] of { _PRIM_ 0# -> case u3 of { _ALG_ J# (ua :: Int#) (ub :: Int#) (uc :: ByteArray#) -> case u6 of { _ALG_ J# (ud :: Int#) (ue :: Int#) (uf :: ByteArray#) -> case _#_ cmpInteger# [] [ua, ub, uc, ud, ue, uf] of { _PRIM_ 0# -> _!_ False [] []; (ug :: Int#) -> _!_ True [] [] }; _NO_DEFLT_ }; _NO_DEFLT_ }; (uh :: Int#) -> _!_ True [] [] }; _NO_DEFLT_ }; _NO_DEFLT_ } _N_} _N_ _N_ } #-}
+instance Eq [(Int, Int)]
+ {-# GHC_PRAGMA _M_ PreludeBuiltin {-dfun-} _A_ 0 _N_ _N_ _N_ _F_ _IF_ARGS_ 0 0 X 3 _!_ _TUP_2 [([(Int, Int)] -> [(Int, Int)] -> Bool), ([(Int, Int)] -> [(Int, Int)] -> Bool)] [_CONSTM_ Eq (==) ([(Int, Int)]), _CONSTM_ Eq (/=) ([(Int, Int)])] _N_
+ (==) = { _A_ 2 _U_ 11 _N_ _S_ "SS" _N_ _N_ },
+ (/=) = { _A_ 2 _U_ 11 _N_ _S_ "SS" _N_ _N_ } #-}
instance Eq a => Eq [a]
{-# GHC_PRAGMA _M_ PreludeBuiltin {-dfun-} _A_ 1 _U_ 1 _N_ _N_ _N_ _N_ #-}
+instance Eq [Bool]
+ {-# GHC_PRAGMA _M_ PreludeBuiltin {-dfun-} _A_ 0 _N_ _N_ _N_ _F_ _IF_ARGS_ 0 0 X 3 _!_ _TUP_2 [([Bool] -> [Bool] -> Bool), ([Bool] -> [Bool] -> Bool)] [_CONSTM_ Eq (==) ([Bool]), _CONSTM_ Eq (/=) ([Bool])] _N_
+ (==) = { _A_ 2 _U_ 11 _N_ _S_ "SS" _N_ _N_ },
+ (/=) = { _A_ 2 _U_ 11 _N_ _S_ "SS" _N_ _N_ } #-}
instance Eq [Char]
{-# GHC_PRAGMA _M_ PreludeBuiltin {-dfun-} _A_ 0 _N_ _N_ _N_ _F_ _IF_ARGS_ 0 0 X 3 _!_ _TUP_2 [([Char] -> [Char] -> Bool), ([Char] -> [Char] -> Bool)] [_CONSTM_ Eq (==) ([Char]), _CONSTM_ Eq (/=) ([Char])] _N_
- (==) = _A_ 2 _U_ 11 _N_ _S_ "SS" _N_ _N_,
- (/=) = _A_ 2 _U_ 11 _N_ _S_ "SS" _N_ _N_ #-}
+ (==) = { _A_ 2 _U_ 11 _N_ _S_ "SS" _N_ _N_ },
+ (/=) = { _A_ 2 _U_ 11 _N_ _S_ "SS" _N_ _N_ } #-}
+instance Eq [Complex Double]
+ {-# GHC_PRAGMA _M_ PreludeBuiltin {-dfun-} _A_ 0 _N_ _N_ _N_ _F_ _IF_ARGS_ 0 0 X 3 _!_ _TUP_2 [([Complex Double] -> [Complex Double] -> Bool), ([Complex Double] -> [Complex Double] -> Bool)] [_CONSTM_ Eq (==) ([Complex Double]), _CONSTM_ Eq (/=) ([Complex Double])] _N_
+ (==) = { _A_ 2 _U_ 11 _N_ _S_ "SS" _N_ _N_ },
+ (/=) = { _A_ 2 _U_ 11 _N_ _S_ "SS" _N_ _N_ } #-}
+instance Eq [Double]
+ {-# GHC_PRAGMA _M_ PreludeBuiltin {-dfun-} _A_ 0 _N_ _N_ _N_ _F_ _IF_ARGS_ 0 0 X 3 _!_ _TUP_2 [([Double] -> [Double] -> Bool), ([Double] -> [Double] -> Bool)] [_CONSTM_ Eq (==) ([Double]), _CONSTM_ Eq (/=) ([Double])] _N_
+ (==) = { _A_ 2 _U_ 11 _N_ _S_ "SS" _N_ _N_ },
+ (/=) = { _A_ 2 _U_ 11 _N_ _S_ "SS" _N_ _N_ } #-}
instance Eq [Int]
{-# GHC_PRAGMA _M_ PreludeBuiltin {-dfun-} _A_ 0 _N_ _N_ _N_ _F_ _IF_ARGS_ 0 0 X 3 _!_ _TUP_2 [([Int] -> [Int] -> Bool), ([Int] -> [Int] -> Bool)] [_CONSTM_ Eq (==) ([Int]), _CONSTM_ Eq (/=) ([Int])] _N_
- (==) = _A_ 2 _U_ 11 _N_ _S_ "SS" _N_ _N_,
- (/=) = _A_ 2 _U_ 11 _N_ _S_ "SS" _N_ _N_ #-}
+ (==) = { _A_ 2 _U_ 11 _N_ _S_ "SS" _N_ _N_ },
+ (/=) = { _A_ 2 _U_ 11 _N_ _S_ "SS" _N_ _N_ } #-}
+instance Eq [Integer]
+ {-# GHC_PRAGMA _M_ PreludeBuiltin {-dfun-} _A_ 0 _N_ _N_ _N_ _F_ _IF_ARGS_ 0 0 X 3 _!_ _TUP_2 [([Integer] -> [Integer] -> Bool), ([Integer] -> [Integer] -> Bool)] [_CONSTM_ Eq (==) ([Integer]), _CONSTM_ Eq (/=) ([Integer])] _N_
+ (==) = { _A_ 2 _U_ 11 _N_ _S_ "SS" _N_ _N_ },
+ (/=) = { _A_ 2 _U_ 11 _N_ _S_ "SS" _N_ _N_ } #-}
+instance Eq [[Char]]
+ {-# GHC_PRAGMA _M_ PreludeBuiltin {-dfun-} _A_ 0 _N_ _N_ _N_ _F_ _IF_ARGS_ 0 0 X 3 _!_ _TUP_2 [([[Char]] -> [[Char]] -> Bool), ([[Char]] -> [[Char]] -> Bool)] [_CONSTM_ Eq (==) ([[Char]]), _CONSTM_ Eq (/=) ([[Char]])] _N_
+ (==) = { _A_ 2 _U_ 11 _N_ _S_ "SS" _N_ _N_ },
+ (/=) = { _A_ 2 _U_ 11 _N_ _S_ "SS" _N_ _N_ } #-}
+instance Eq [[Int]]
+ {-# GHC_PRAGMA _M_ PreludeBuiltin {-dfun-} _A_ 0 _N_ _N_ _N_ _F_ _IF_ARGS_ 0 0 X 3 _!_ _TUP_2 [([[Int]] -> [[Int]] -> Bool), ([[Int]] -> [[Int]] -> Bool)] [_CONSTM_ Eq (==) ([[Int]]), _CONSTM_ Eq (/=) ([[Int]])] _N_
+ (==) = { _A_ 2 _U_ 11 _N_ _S_ "SS" _N_ _N_ },
+ (/=) = { _A_ 2 _U_ 11 _N_ _S_ "SS" _N_ _N_ } #-}
instance Eq _Addr
{-# GHC_PRAGMA _M_ PreludeCore {-dfun-} _A_ 0 _N_ _N_ _N_ _F_ _IF_ARGS_ 0 0 X 3 _!_ _TUP_2 [(_Addr -> _Addr -> Bool), (_Addr -> _Addr -> Bool)] [_CONSTM_ Eq (==) (_Addr), _CONSTM_ Eq (/=) (_Addr)] _N_
- (==) = _A_ 2 _U_ 11 _N_ _S_ "U(P)U(P)" {_A_ 2 _U_ 22 _N_ _N_ _F_ _IF_ARGS_ 0 2 XX 1 \ (u0 :: Addr#) (u1 :: Addr#) -> _#_ eqAddr# [] [u0, u1] _N_} _F_ _IF_ARGS_ 0 2 CC 3 \ (u0 :: _Addr) (u1 :: _Addr) -> case u0 of { _ALG_ A# (u2 :: Addr#) -> case u1 of { _ALG_ A# (u3 :: Addr#) -> _#_ eqAddr# [] [u2, u3]; _NO_DEFLT_ }; _NO_DEFLT_ } _N_,
- (/=) = _A_ 2 _U_ 11 _N_ _S_ "U(P)U(P)" {_A_ 2 _U_ 22 _N_ _N_ _F_ _IF_ARGS_ 0 2 XX 1 \ (u0 :: Addr#) (u1 :: Addr#) -> _#_ neAddr# [] [u0, u1] _N_} _F_ _IF_ARGS_ 0 2 CC 3 \ (u0 :: _Addr) (u1 :: _Addr) -> case u0 of { _ALG_ A# (u2 :: Addr#) -> case u1 of { _ALG_ A# (u3 :: Addr#) -> _#_ neAddr# [] [u2, u3]; _NO_DEFLT_ }; _NO_DEFLT_ } _N_ #-}
+ (==) = { _A_ 2 _U_ 11 _N_ _S_ "U(P)U(P)" {_A_ 2 _U_ 22 _N_ _N_ _F_ _IF_ARGS_ 0 2 XX 1 \ (u0 :: Addr#) (u1 :: Addr#) -> _#_ eqAddr# [] [u0, u1] _N_} _F_ _IF_ARGS_ 0 2 CC 3 \ (u0 :: _Addr) (u1 :: _Addr) -> case u0 of { _ALG_ A# (u2 :: Addr#) -> case u1 of { _ALG_ A# (u3 :: Addr#) -> _#_ eqAddr# [] [u2, u3]; _NO_DEFLT_ }; _NO_DEFLT_ } _N_ },
+ (/=) = { _A_ 2 _U_ 11 _N_ _S_ "U(P)U(P)" {_A_ 2 _U_ 22 _N_ _N_ _F_ _IF_ARGS_ 0 2 XX 1 \ (u0 :: Addr#) (u1 :: Addr#) -> _#_ neAddr# [] [u0, u1] _N_} _F_ _IF_ARGS_ 0 2 CC 3 \ (u0 :: _Addr) (u1 :: _Addr) -> case u0 of { _ALG_ A# (u2 :: Addr#) -> case u1 of { _ALG_ A# (u3 :: Addr#) -> _#_ neAddr# [] [u2, u3]; _NO_DEFLT_ }; _NO_DEFLT_ } _N_ } #-}
instance Eq _PackedString
{-# GHC_PRAGMA _M_ PreludePS {-dfun-} _A_ 0 _N_ _N_ _N_ _F_ _IF_ARGS_ 0 0 X 3 _!_ _TUP_2 [(_PackedString -> _PackedString -> Bool), (_PackedString -> _PackedString -> Bool)] [_CONSTM_ Eq (==) (_PackedString), _CONSTM_ Eq (/=) (_PackedString)] _N_
- (==) = _A_ 2 _U_ 22 _N_ _S_ "SS" _N_ _N_,
- (/=) = _A_ 2 _U_ 22 _N_ _S_ "SS" _N_ _N_ #-}
+ (==) = { _A_ 2 _U_ 22 _N_ _S_ "SS" _N_ _N_ },
+ (/=) = { _A_ 2 _U_ 22 _N_ _S_ "SS" _N_ _N_ } #-}
instance Eq _Word
{-# GHC_PRAGMA _M_ PreludeCore {-dfun-} _A_ 0 _N_ _N_ _N_ _F_ _IF_ARGS_ 0 0 X 3 _!_ _TUP_2 [(_Word -> _Word -> Bool), (_Word -> _Word -> Bool)] [_CONSTM_ Eq (==) (_Word), _CONSTM_ Eq (/=) (_Word)] _N_
- (==) = _A_ 2 _U_ 11 _N_ _S_ "U(P)U(P)" {_A_ 2 _U_ 22 _N_ _N_ _F_ _IF_ARGS_ 0 2 XX 1 \ (u0 :: Word#) (u1 :: Word#) -> _#_ eqWord# [] [u0, u1] _N_} _F_ _IF_ARGS_ 0 2 CC 3 \ (u0 :: _Word) (u1 :: _Word) -> case u0 of { _ALG_ W# (u2 :: Word#) -> case u1 of { _ALG_ W# (u3 :: Word#) -> _#_ eqWord# [] [u2, u3]; _NO_DEFLT_ }; _NO_DEFLT_ } _N_,
- (/=) = _A_ 2 _U_ 11 _N_ _S_ "U(P)U(P)" {_A_ 2 _U_ 22 _N_ _N_ _F_ _IF_ARGS_ 0 2 XX 1 \ (u0 :: Word#) (u1 :: Word#) -> _#_ neWord# [] [u0, u1] _N_} _F_ _IF_ARGS_ 0 2 CC 3 \ (u0 :: _Word) (u1 :: _Word) -> case u0 of { _ALG_ W# (u2 :: Word#) -> case u1 of { _ALG_ W# (u3 :: Word#) -> _#_ neWord# [] [u2, u3]; _NO_DEFLT_ }; _NO_DEFLT_ } _N_ #-}
+ (==) = { _A_ 2 _U_ 11 _N_ _S_ "U(P)U(P)" {_A_ 2 _U_ 22 _N_ _N_ _F_ _IF_ARGS_ 0 2 XX 1 \ (u0 :: Word#) (u1 :: Word#) -> _#_ eqWord# [] [u0, u1] _N_} _F_ _IF_ARGS_ 0 2 CC 3 \ (u0 :: _Word) (u1 :: _Word) -> case u0 of { _ALG_ W# (u2 :: Word#) -> case u1 of { _ALG_ W# (u3 :: Word#) -> _#_ eqWord# [] [u2, u3]; _NO_DEFLT_ }; _NO_DEFLT_ } _N_ },
+ (/=) = { _A_ 2 _U_ 11 _N_ _S_ "U(P)U(P)" {_A_ 2 _U_ 22 _N_ _N_ _F_ _IF_ARGS_ 0 2 XX 1 \ (u0 :: Word#) (u1 :: Word#) -> _#_ neWord# [] [u0, u1] _N_} _F_ _IF_ARGS_ 0 2 CC 3 \ (u0 :: _Word) (u1 :: _Word) -> case u0 of { _ALG_ W# (u2 :: Word#) -> case u1 of { _ALG_ W# (u3 :: Word#) -> _#_ neWord# [] [u2, u3]; _NO_DEFLT_ }; _NO_DEFLT_ } _N_ } #-}
instance RealFloat a => Floating (Complex a)
{-# GHC_PRAGMA _M_ PreludeComplex {-dfun-} _A_ 2 _U_ 22 _N_ _N_ _N_ _N_ #-}
instance Floating (Complex Double)
{-# GHC_PRAGMA _M_ PreludeComplex {-dfun-} _A_ 0 _N_ _N_ _N_ _F_ _IF_ARGS_ 0 0 X 20 _!_ _TUP_19 [{{Fractional (Complex Double)}}, (Complex Double), (Complex Double -> Complex Double), (Complex Double -> Complex Double), (Complex Double -> Complex Double), (Complex Double -> Complex Double -> Complex Double), (Complex Double -> Complex Double -> Complex Double), (Complex Double -> Complex Double), (Complex Double -> Complex Double), (Complex Double -> Complex Double), (Complex Double -> Complex Double), (Complex Double -> Complex Double), (Complex Double -> Complex Double), (Complex Double -> Complex Double), (Complex Double -> Complex Double), (Complex Double -> Complex Double), (Complex Double -> Complex Double), (Complex Double -> Complex Double), (Complex Double -> Complex Double)] [_DFUN_ Fractional (Complex Double), _CONSTM_ Floating pi (Complex Double), _CONSTM_ Floating exp (Complex Double), _CONSTM_ Floating log (Complex Double), _CONSTM_ Floating sqrt (Complex Double), _CONSTM_ Floating (**) (Complex Double), _CONSTM_ Floating logBase (Complex Double), _CONSTM_ Floating sin (Complex Double), _CONSTM_ Floating cos (Complex Double), _CONSTM_ Floating tan (Complex Double), _CONSTM_ Floating asin (Complex Double), _CONSTM_ Floating acos (Complex Double), _CONSTM_ Floating atan (Complex Double), _CONSTM_ Floating sinh (Complex Double), _CONSTM_ Floating cosh (Complex Double), _CONSTM_ Floating tanh (Complex Double), _CONSTM_ Floating asinh (Complex Double), _CONSTM_ Floating acosh (Complex Double), _CONSTM_ Floating atanh (Complex Double)] _N_
- pi = _A_ 0 _N_ _N_ _N_ _N_ _N_,
- exp = _A_ 1 _U_ 1 _N_ _S_ "U(LL)" {_A_ 2 _U_ 12 _N_ _N_ _N_ _N_} _N_ _N_,
- log = _A_ 1 _U_ 2 _N_ _N_ _N_ _N_,
- sqrt = _A_ 1 _U_ 1 _N_ _S_ "U(U(P)L)" {_A_ 2 _U_ 22 _N_ _N_ _N_ _N_} _N_ _N_,
- (**) = _A_ 2 _U_ 21 _N_ _S_ "LU(LL)" {_A_ 3 _U_ 222 _N_ _N_ _N_ _N_} _N_ _N_,
- logBase = _A_ 2 _U_ 22 _N_ _N_ _N_ _N_,
- sin = _A_ 1 _U_ 1 _N_ _S_ "U(LL)" {_A_ 2 _U_ 22 _N_ _N_ _N_ _N_} _N_ _N_,
- cos = _A_ 1 _U_ 1 _N_ _S_ "U(LL)" {_A_ 2 _U_ 22 _N_ _N_ _N_ _N_} _N_ _N_,
- tan = _A_ 1 _U_ 1 _N_ _S_ "U(LL)" {_A_ 2 _U_ 22 _N_ _N_ _N_ _N_} _N_ _N_,
- asin = _A_ 1 _U_ 1 _N_ _S_ "U(LL)" {_A_ 2 _U_ 22 _N_ _N_ _N_ _N_} _N_ _N_,
- acos = _A_ 1 _U_ 1 _N_ _S_ "U(LL)" {_A_ 2 _U_ 22 _N_ _N_ _N_ _N_} _N_ _N_,
- atan = _A_ 1 _U_ 1 _N_ _S_ "U(LL)" {_A_ 2 _U_ 22 _N_ _N_ _N_ _N_} _N_ _N_,
- sinh = _A_ 1 _U_ 1 _N_ _S_ "U(LL)" {_A_ 2 _U_ 22 _N_ _N_ _N_ _N_} _N_ _N_,
- cosh = _A_ 1 _U_ 1 _N_ _S_ "U(LL)" {_A_ 2 _U_ 22 _N_ _N_ _N_ _N_} _N_ _N_,
- tanh = _A_ 1 _U_ 1 _N_ _S_ "U(LL)" {_A_ 2 _U_ 22 _N_ _N_ _N_ _N_} _N_ _N_,
- asinh = _A_ 1 _U_ 1 _N_ _N_ _N_ _N_,
- acosh = _A_ 1 _U_ 1 _N_ _N_ _N_ _N_,
- atanh = _A_ 1 _U_ 1 _N_ _N_ _N_ _N_ #-}
+ pi = { _A_ 0 _N_ _N_ _N_ _F_ _IF_ARGS_ 0 0 X 3 _!_ (:+) [Double] [_CONSTM_ Floating pi (Double), _SPEC_ _ORIG_ PreludeCore __i0 [ (Double) ]] _N_ },
+ exp = { _A_ 1 _U_ 1 _N_ _S_ "U(LL)" {_A_ 2 _U_ 12 _N_ _N_ _N_ _N_} _N_ _N_ },
+ log = { _A_ 1 _U_ 2 _N_ _N_ _N_ _N_ },
+ sqrt = { _A_ 1 _U_ 1 _N_ _S_ "U(U(P)L)" {_A_ 2 _U_ 22 _N_ _N_ _N_ _N_} _N_ _N_ },
+ (**) = { _A_ 2 _U_ 21 _N_ _S_ "LU(LL)" {_A_ 3 _U_ 222 _N_ _N_ _N_ _N_} _N_ _N_ },
+ logBase = { _A_ 2 _U_ 22 _N_ _N_ _N_ _N_ },
+ sin = { _A_ 1 _U_ 1 _N_ _S_ "U(LL)" {_A_ 2 _U_ 22 _N_ _N_ _N_ _N_} _N_ _N_ },
+ cos = { _A_ 1 _U_ 1 _N_ _S_ "U(LL)" {_A_ 2 _U_ 22 _N_ _N_ _N_ _N_} _N_ _N_ },
+ tan = { _A_ 1 _U_ 1 _N_ _S_ "U(LL)" {_A_ 2 _U_ 22 _N_ _N_ _N_ _N_} _N_ _N_ },
+ asin = { _A_ 1 _U_ 1 _N_ _S_ "U(LL)" {_A_ 2 _U_ 22 _N_ _N_ _N_ _N_} _N_ _N_ },
+ acos = { _A_ 1 _U_ 1 _N_ _S_ "U(LL)" {_A_ 2 _U_ 22 _N_ _N_ _N_ _N_} _N_ _N_ },
+ atan = { _A_ 1 _U_ 1 _N_ _S_ "U(LL)" {_A_ 2 _U_ 22 _N_ _N_ _N_ _N_} _N_ _N_ },
+ sinh = { _A_ 1 _U_ 1 _N_ _S_ "U(LL)" {_A_ 2 _U_ 22 _N_ _N_ _N_ _N_} _N_ _N_ },
+ cosh = { _A_ 1 _U_ 1 _N_ _S_ "U(LL)" {_A_ 2 _U_ 22 _N_ _N_ _N_ _N_} _N_ _N_ },
+ tanh = { _A_ 1 _U_ 1 _N_ _S_ "U(LL)" {_A_ 2 _U_ 22 _N_ _N_ _N_ _N_} _N_ _N_ },
+ asinh = { _A_ 1 _U_ 1 _N_ _N_ _N_ _N_ },
+ acosh = { _A_ 1 _U_ 1 _N_ _N_ _N_ _N_ },
+ atanh = { _A_ 1 _U_ 1 _N_ _N_ _N_ _N_ } #-}
instance Floating Double
{-# GHC_PRAGMA _M_ PreludeCore {-dfun-} _A_ 0 _N_ _N_ _N_ _F_ _IF_ARGS_ 0 0 X 20 _!_ _TUP_19 [{{Fractional Double}}, Double, (Double -> Double), (Double -> Double), (Double -> Double), (Double -> Double -> Double), (Double -> Double -> Double), (Double -> Double), (Double -> Double), (Double -> Double), (Double -> Double), (Double -> Double), (Double -> Double), (Double -> Double), (Double -> Double), (Double -> Double), (Double -> Double), (Double -> Double), (Double -> Double)] [_DFUN_ Fractional (Double), _CONSTM_ Floating pi (Double), _CONSTM_ Floating exp (Double), _CONSTM_ Floating log (Double), _CONSTM_ Floating sqrt (Double), _CONSTM_ Floating (**) (Double), _CONSTM_ Floating logBase (Double), _CONSTM_ Floating sin (Double), _CONSTM_ Floating cos (Double), _CONSTM_ Floating tan (Double), _CONSTM_ Floating asin (Double), _CONSTM_ Floating acos (Double), _CONSTM_ Floating atan (Double), _CONSTM_ Floating sinh (Double), _CONSTM_ Floating cosh (Double), _CONSTM_ Floating tanh (Double), _CONSTM_ Floating asinh (Double), _CONSTM_ Floating acosh (Double), _CONSTM_ Floating atanh (Double)] _N_
- pi = _A_ 0 _N_ _N_ _N_ _F_ _IF_ARGS_ 0 0 X 2 _!_ D# [] [3.1415926535897931##] _N_,
- exp = _A_ 1 _U_ 1 _N_ _S_ "U(P)" {_A_ 1 _U_ 2 _N_ _N_ _F_ _IF_ARGS_ 0 1 X 3 \ (u0 :: Double#) -> case _#_ expDouble# [] [u0] of { _PRIM_ (u1 :: Double#) -> _!_ D# [] [u1] } _N_} _F_ _IF_ARGS_ 0 1 C 4 \ (u0 :: Double) -> case u0 of { _ALG_ D# (u1 :: Double#) -> case _#_ expDouble# [] [u1] of { _PRIM_ (u2 :: Double#) -> _!_ D# [] [u2] }; _NO_DEFLT_ } _N_,
- log = _A_ 1 _U_ 1 _N_ _S_ "U(P)" {_A_ 1 _U_ 2 _N_ _N_ _F_ _IF_ARGS_ 0 1 X 3 \ (u0 :: Double#) -> case _#_ logDouble# [] [u0] of { _PRIM_ (u1 :: Double#) -> _!_ D# [] [u1] } _N_} _F_ _IF_ARGS_ 0 1 C 4 \ (u0 :: Double) -> case u0 of { _ALG_ D# (u1 :: Double#) -> case _#_ logDouble# [] [u1] of { _PRIM_ (u2 :: Double#) -> _!_ D# [] [u2] }; _NO_DEFLT_ } _N_,
- sqrt = _A_ 1 _U_ 1 _N_ _S_ "U(P)" {_A_ 1 _U_ 2 _N_ _N_ _F_ _IF_ARGS_ 0 1 X 3 \ (u0 :: Double#) -> case _#_ sqrtDouble# [] [u0] of { _PRIM_ (u1 :: Double#) -> _!_ D# [] [u1] } _N_} _F_ _IF_ARGS_ 0 1 C 4 \ (u0 :: Double) -> case u0 of { _ALG_ D# (u1 :: Double#) -> case _#_ sqrtDouble# [] [u1] of { _PRIM_ (u2 :: Double#) -> _!_ D# [] [u2] }; _NO_DEFLT_ } _N_,
- (**) = _A_ 2 _U_ 11 _N_ _S_ "U(P)U(P)" {_A_ 2 _U_ 22 _N_ _N_ _F_ _IF_ARGS_ 0 2 XX 3 \ (u0 :: Double#) (u1 :: Double#) -> case _#_ powerDouble# [] [u0, u1] of { _PRIM_ (u2 :: Double#) -> _!_ D# [] [u2] } _N_} _F_ _IF_ARGS_ 0 2 CC 5 \ (u0 :: Double) (u1 :: Double) -> case u0 of { _ALG_ D# (u2 :: Double#) -> case u1 of { _ALG_ D# (u3 :: Double#) -> case _#_ powerDouble# [] [u2, u3] of { _PRIM_ (u4 :: Double#) -> _!_ D# [] [u4] }; _NO_DEFLT_ }; _NO_DEFLT_ } _N_,
- logBase = _A_ 2 _U_ 11 _N_ _S_ "U(P)U(P)" {_A_ 2 _U_ 22 _N_ _N_ _F_ _IF_ARGS_ 0 2 XX 5 \ (u0 :: Double#) (u1 :: Double#) -> case _#_ logDouble# [] [u1] of { _PRIM_ (u2 :: Double#) -> case _#_ logDouble# [] [u0] of { _PRIM_ (u3 :: Double#) -> case _#_ divideDouble# [] [u2, u3] of { _PRIM_ (u4 :: Double#) -> _!_ D# [] [u4] } } } _N_} _F_ _IF_ARGS_ 0 2 CC 7 \ (u0 :: Double) (u1 :: Double) -> case u1 of { _ALG_ D# (u2 :: Double#) -> case _#_ logDouble# [] [u2] of { _PRIM_ (u3 :: Double#) -> case u0 of { _ALG_ D# (u4 :: Double#) -> case _#_ logDouble# [] [u4] of { _PRIM_ (u5 :: Double#) -> case _#_ divideDouble# [] [u3, u5] of { _PRIM_ (u6 :: Double#) -> _!_ D# [] [u6] } }; _NO_DEFLT_ } }; _NO_DEFLT_ } _N_,
- sin = _A_ 1 _U_ 1 _N_ _S_ "U(P)" {_A_ 1 _U_ 2 _N_ _N_ _F_ _IF_ARGS_ 0 1 X 3 \ (u0 :: Double#) -> case _#_ sinDouble# [] [u0] of { _PRIM_ (u1 :: Double#) -> _!_ D# [] [u1] } _N_} _F_ _IF_ARGS_ 0 1 C 4 \ (u0 :: Double) -> case u0 of { _ALG_ D# (u1 :: Double#) -> case _#_ sinDouble# [] [u1] of { _PRIM_ (u2 :: Double#) -> _!_ D# [] [u2] }; _NO_DEFLT_ } _N_,
- cos = _A_ 1 _U_ 1 _N_ _S_ "U(P)" {_A_ 1 _U_ 2 _N_ _N_ _F_ _IF_ARGS_ 0 1 X 3 \ (u0 :: Double#) -> case _#_ cosDouble# [] [u0] of { _PRIM_ (u1 :: Double#) -> _!_ D# [] [u1] } _N_} _F_ _IF_ARGS_ 0 1 C 4 \ (u0 :: Double) -> case u0 of { _ALG_ D# (u1 :: Double#) -> case _#_ cosDouble# [] [u1] of { _PRIM_ (u2 :: Double#) -> _!_ D# [] [u2] }; _NO_DEFLT_ } _N_,
- tan = _A_ 1 _U_ 1 _N_ _S_ "U(P)" {_A_ 1 _U_ 2 _N_ _N_ _F_ _IF_ARGS_ 0 1 X 3 \ (u0 :: Double#) -> case _#_ tanDouble# [] [u0] of { _PRIM_ (u1 :: Double#) -> _!_ D# [] [u1] } _N_} _F_ _IF_ARGS_ 0 1 C 4 \ (u0 :: Double) -> case u0 of { _ALG_ D# (u1 :: Double#) -> case _#_ tanDouble# [] [u1] of { _PRIM_ (u2 :: Double#) -> _!_ D# [] [u2] }; _NO_DEFLT_ } _N_,
- asin = _A_ 1 _U_ 1 _N_ _S_ "U(P)" {_A_ 1 _U_ 2 _N_ _N_ _F_ _IF_ARGS_ 0 1 X 3 \ (u0 :: Double#) -> case _#_ asinDouble# [] [u0] of { _PRIM_ (u1 :: Double#) -> _!_ D# [] [u1] } _N_} _F_ _IF_ARGS_ 0 1 C 4 \ (u0 :: Double) -> case u0 of { _ALG_ D# (u1 :: Double#) -> case _#_ asinDouble# [] [u1] of { _PRIM_ (u2 :: Double#) -> _!_ D# [] [u2] }; _NO_DEFLT_ } _N_,
- acos = _A_ 1 _U_ 1 _N_ _S_ "U(P)" {_A_ 1 _U_ 2 _N_ _N_ _F_ _IF_ARGS_ 0 1 X 3 \ (u0 :: Double#) -> case _#_ acosDouble# [] [u0] of { _PRIM_ (u1 :: Double#) -> _!_ D# [] [u1] } _N_} _F_ _IF_ARGS_ 0 1 C 4 \ (u0 :: Double) -> case u0 of { _ALG_ D# (u1 :: Double#) -> case _#_ acosDouble# [] [u1] of { _PRIM_ (u2 :: Double#) -> _!_ D# [] [u2] }; _NO_DEFLT_ } _N_,
- atan = _A_ 1 _U_ 1 _N_ _S_ "U(P)" {_A_ 1 _U_ 2 _N_ _N_ _F_ _IF_ARGS_ 0 1 X 3 \ (u0 :: Double#) -> case _#_ atanDouble# [] [u0] of { _PRIM_ (u1 :: Double#) -> _!_ D# [] [u1] } _N_} _F_ _IF_ARGS_ 0 1 C 4 \ (u0 :: Double) -> case u0 of { _ALG_ D# (u1 :: Double#) -> case _#_ atanDouble# [] [u1] of { _PRIM_ (u2 :: Double#) -> _!_ D# [] [u2] }; _NO_DEFLT_ } _N_,
- sinh = _A_ 1 _U_ 1 _N_ _S_ "U(P)" {_A_ 1 _U_ 2 _N_ _N_ _F_ _IF_ARGS_ 0 1 X 3 \ (u0 :: Double#) -> case _#_ sinhDouble# [] [u0] of { _PRIM_ (u1 :: Double#) -> _!_ D# [] [u1] } _N_} _F_ _IF_ARGS_ 0 1 C 4 \ (u0 :: Double) -> case u0 of { _ALG_ D# (u1 :: Double#) -> case _#_ sinhDouble# [] [u1] of { _PRIM_ (u2 :: Double#) -> _!_ D# [] [u2] }; _NO_DEFLT_ } _N_,
- cosh = _A_ 1 _U_ 1 _N_ _S_ "U(P)" {_A_ 1 _U_ 2 _N_ _N_ _F_ _IF_ARGS_ 0 1 X 3 \ (u0 :: Double#) -> case _#_ coshDouble# [] [u0] of { _PRIM_ (u1 :: Double#) -> _!_ D# [] [u1] } _N_} _F_ _IF_ARGS_ 0 1 C 4 \ (u0 :: Double) -> case u0 of { _ALG_ D# (u1 :: Double#) -> case _#_ coshDouble# [] [u1] of { _PRIM_ (u2 :: Double#) -> _!_ D# [] [u2] }; _NO_DEFLT_ } _N_,
- tanh = _A_ 1 _U_ 1 _N_ _S_ "U(P)" {_A_ 1 _U_ 2 _N_ _N_ _F_ _IF_ARGS_ 0 1 X 3 \ (u0 :: Double#) -> case _#_ tanhDouble# [] [u0] of { _PRIM_ (u1 :: Double#) -> _!_ D# [] [u1] } _N_} _F_ _IF_ARGS_ 0 1 C 4 \ (u0 :: Double) -> case u0 of { _ALG_ D# (u1 :: Double#) -> case _#_ tanhDouble# [] [u1] of { _PRIM_ (u2 :: Double#) -> _!_ D# [] [u2] }; _NO_DEFLT_ } _N_,
- asinh = _A_ 1 _U_ 1 _N_ _S_ "U(P)" {_A_ 1 _U_ 2 _N_ _N_ _N_ _N_} _N_ _N_,
- acosh = _A_ 1 _U_ 1 _N_ _S_ "U(P)" {_A_ 1 _U_ 2 _N_ _N_ _N_ _N_} _N_ _N_,
- atanh = _A_ 1 _U_ 1 _N_ _S_ "U(P)" {_A_ 1 _U_ 2 _N_ _N_ _N_ _N_} _N_ _N_ #-}
+ pi = { _A_ 0 _N_ _N_ _N_ _F_ _IF_ARGS_ 0 0 X 2 _!_ D# [] [3.1415926535897931##] _N_ },
+ exp = { _A_ 1 _U_ 1 _N_ _S_ "U(P)" {_A_ 1 _U_ 2 _N_ _N_ _F_ _IF_ARGS_ 0 1 X 3 \ (u0 :: Double#) -> case _#_ expDouble# [] [u0] of { _PRIM_ (u1 :: Double#) -> _!_ D# [] [u1] } _N_} _F_ _IF_ARGS_ 0 1 C 4 \ (u0 :: Double) -> case u0 of { _ALG_ D# (u1 :: Double#) -> case _#_ expDouble# [] [u1] of { _PRIM_ (u2 :: Double#) -> _!_ D# [] [u2] }; _NO_DEFLT_ } _N_ },
+ log = { _A_ 1 _U_ 1 _N_ _S_ "U(P)" {_A_ 1 _U_ 2 _N_ _N_ _F_ _IF_ARGS_ 0 1 X 3 \ (u0 :: Double#) -> case _#_ logDouble# [] [u0] of { _PRIM_ (u1 :: Double#) -> _!_ D# [] [u1] } _N_} _F_ _IF_ARGS_ 0 1 C 4 \ (u0 :: Double) -> case u0 of { _ALG_ D# (u1 :: Double#) -> case _#_ logDouble# [] [u1] of { _PRIM_ (u2 :: Double#) -> _!_ D# [] [u2] }; _NO_DEFLT_ } _N_ },
+ sqrt = { _A_ 1 _U_ 1 _N_ _S_ "U(P)" {_A_ 1 _U_ 2 _N_ _N_ _F_ _IF_ARGS_ 0 1 X 3 \ (u0 :: Double#) -> case _#_ sqrtDouble# [] [u0] of { _PRIM_ (u1 :: Double#) -> _!_ D# [] [u1] } _N_} _F_ _IF_ARGS_ 0 1 C 4 \ (u0 :: Double) -> case u0 of { _ALG_ D# (u1 :: Double#) -> case _#_ sqrtDouble# [] [u1] of { _PRIM_ (u2 :: Double#) -> _!_ D# [] [u2] }; _NO_DEFLT_ } _N_ },
+ (**) = { _A_ 2 _U_ 11 _N_ _S_ "U(P)U(P)" {_A_ 2 _U_ 22 _N_ _N_ _F_ _IF_ARGS_ 0 2 XX 3 \ (u0 :: Double#) (u1 :: Double#) -> case _#_ powerDouble# [] [u0, u1] of { _PRIM_ (u2 :: Double#) -> _!_ D# [] [u2] } _N_} _F_ _IF_ARGS_ 0 2 CC 5 \ (u0 :: Double) (u1 :: Double) -> case u0 of { _ALG_ D# (u2 :: Double#) -> case u1 of { _ALG_ D# (u3 :: Double#) -> case _#_ powerDouble# [] [u2, u3] of { _PRIM_ (u4 :: Double#) -> _!_ D# [] [u4] }; _NO_DEFLT_ }; _NO_DEFLT_ } _N_ },
+ logBase = { _A_ 2 _U_ 11 _N_ _S_ "U(P)U(P)" {_A_ 2 _U_ 22 _N_ _N_ _F_ _IF_ARGS_ 0 2 XX 5 \ (u0 :: Double#) (u1 :: Double#) -> case _#_ logDouble# [] [u1] of { _PRIM_ (u2 :: Double#) -> case _#_ logDouble# [] [u0] of { _PRIM_ (u3 :: Double#) -> case _#_ divideDouble# [] [u2, u3] of { _PRIM_ (u4 :: Double#) -> _!_ D# [] [u4] } } } _N_} _F_ _IF_ARGS_ 0 2 CC 7 \ (u0 :: Double) (u1 :: Double) -> case u1 of { _ALG_ D# (u2 :: Double#) -> case _#_ logDouble# [] [u2] of { _PRIM_ (u3 :: Double#) -> case u0 of { _ALG_ D# (u4 :: Double#) -> case _#_ logDouble# [] [u4] of { _PRIM_ (u5 :: Double#) -> case _#_ divideDouble# [] [u3, u5] of { _PRIM_ (u6 :: Double#) -> _!_ D# [] [u6] } }; _NO_DEFLT_ } }; _NO_DEFLT_ } _N_ },
+ sin = { _A_ 1 _U_ 1 _N_ _S_ "U(P)" {_A_ 1 _U_ 2 _N_ _N_ _F_ _IF_ARGS_ 0 1 X 3 \ (u0 :: Double#) -> case _#_ sinDouble# [] [u0] of { _PRIM_ (u1 :: Double#) -> _!_ D# [] [u1] } _N_} _F_ _IF_ARGS_ 0 1 C 4 \ (u0 :: Double) -> case u0 of { _ALG_ D# (u1 :: Double#) -> case _#_ sinDouble# [] [u1] of { _PRIM_ (u2 :: Double#) -> _!_ D# [] [u2] }; _NO_DEFLT_ } _N_ },
+ cos = { _A_ 1 _U_ 1 _N_ _S_ "U(P)" {_A_ 1 _U_ 2 _N_ _N_ _F_ _IF_ARGS_ 0 1 X 3 \ (u0 :: Double#) -> case _#_ cosDouble# [] [u0] of { _PRIM_ (u1 :: Double#) -> _!_ D# [] [u1] } _N_} _F_ _IF_ARGS_ 0 1 C 4 \ (u0 :: Double) -> case u0 of { _ALG_ D# (u1 :: Double#) -> case _#_ cosDouble# [] [u1] of { _PRIM_ (u2 :: Double#) -> _!_ D# [] [u2] }; _NO_DEFLT_ } _N_ },
+ tan = { _A_ 1 _U_ 1 _N_ _S_ "U(P)" {_A_ 1 _U_ 2 _N_ _N_ _F_ _IF_ARGS_ 0 1 X 3 \ (u0 :: Double#) -> case _#_ tanDouble# [] [u0] of { _PRIM_ (u1 :: Double#) -> _!_ D# [] [u1] } _N_} _F_ _IF_ARGS_ 0 1 C 4 \ (u0 :: Double) -> case u0 of { _ALG_ D# (u1 :: Double#) -> case _#_ tanDouble# [] [u1] of { _PRIM_ (u2 :: Double#) -> _!_ D# [] [u2] }; _NO_DEFLT_ } _N_ },
+ asin = { _A_ 1 _U_ 1 _N_ _S_ "U(P)" {_A_ 1 _U_ 2 _N_ _N_ _F_ _IF_ARGS_ 0 1 X 3 \ (u0 :: Double#) -> case _#_ asinDouble# [] [u0] of { _PRIM_ (u1 :: Double#) -> _!_ D# [] [u1] } _N_} _F_ _IF_ARGS_ 0 1 C 4 \ (u0 :: Double) -> case u0 of { _ALG_ D# (u1 :: Double#) -> case _#_ asinDouble# [] [u1] of { _PRIM_ (u2 :: Double#) -> _!_ D# [] [u2] }; _NO_DEFLT_ } _N_ },
+ acos = { _A_ 1 _U_ 1 _N_ _S_ "U(P)" {_A_ 1 _U_ 2 _N_ _N_ _F_ _IF_ARGS_ 0 1 X 3 \ (u0 :: Double#) -> case _#_ acosDouble# [] [u0] of { _PRIM_ (u1 :: Double#) -> _!_ D# [] [u1] } _N_} _F_ _IF_ARGS_ 0 1 C 4 \ (u0 :: Double) -> case u0 of { _ALG_ D# (u1 :: Double#) -> case _#_ acosDouble# [] [u1] of { _PRIM_ (u2 :: Double#) -> _!_ D# [] [u2] }; _NO_DEFLT_ } _N_ },
+ atan = { _A_ 1 _U_ 1 _N_ _S_ "U(P)" {_A_ 1 _U_ 2 _N_ _N_ _F_ _IF_ARGS_ 0 1 X 3 \ (u0 :: Double#) -> case _#_ atanDouble# [] [u0] of { _PRIM_ (u1 :: Double#) -> _!_ D# [] [u1] } _N_} _F_ _IF_ARGS_ 0 1 C 4 \ (u0 :: Double) -> case u0 of { _ALG_ D# (u1 :: Double#) -> case _#_ atanDouble# [] [u1] of { _PRIM_ (u2 :: Double#) -> _!_ D# [] [u2] }; _NO_DEFLT_ } _N_ },
+ sinh = { _A_ 1 _U_ 1 _N_ _S_ "U(P)" {_A_ 1 _U_ 2 _N_ _N_ _F_ _IF_ARGS_ 0 1 X 3 \ (u0 :: Double#) -> case _#_ sinhDouble# [] [u0] of { _PRIM_ (u1 :: Double#) -> _!_ D# [] [u1] } _N_} _F_ _IF_ARGS_ 0 1 C 4 \ (u0 :: Double) -> case u0 of { _ALG_ D# (u1 :: Double#) -> case _#_ sinhDouble# [] [u1] of { _PRIM_ (u2 :: Double#) -> _!_ D# [] [u2] }; _NO_DEFLT_ } _N_ },
+ cosh = { _A_ 1 _U_ 1 _N_ _S_ "U(P)" {_A_ 1 _U_ 2 _N_ _N_ _F_ _IF_ARGS_ 0 1 X 3 \ (u0 :: Double#) -> case _#_ coshDouble# [] [u0] of { _PRIM_ (u1 :: Double#) -> _!_ D# [] [u1] } _N_} _F_ _IF_ARGS_ 0 1 C 4 \ (u0 :: Double) -> case u0 of { _ALG_ D# (u1 :: Double#) -> case _#_ coshDouble# [] [u1] of { _PRIM_ (u2 :: Double#) -> _!_ D# [] [u2] }; _NO_DEFLT_ } _N_ },
+ tanh = { _A_ 1 _U_ 1 _N_ _S_ "U(P)" {_A_ 1 _U_ 2 _N_ _N_ _F_ _IF_ARGS_ 0 1 X 3 \ (u0 :: Double#) -> case _#_ tanhDouble# [] [u0] of { _PRIM_ (u1 :: Double#) -> _!_ D# [] [u1] } _N_} _F_ _IF_ARGS_ 0 1 C 4 \ (u0 :: Double) -> case u0 of { _ALG_ D# (u1 :: Double#) -> case _#_ tanhDouble# [] [u1] of { _PRIM_ (u2 :: Double#) -> _!_ D# [] [u2] }; _NO_DEFLT_ } _N_ },
+ asinh = { _A_ 1 _U_ 1 _N_ _S_ "U(P)" {_A_ 1 _U_ 2 _N_ _N_ _N_ _N_} _N_ _N_ },
+ acosh = { _A_ 1 _U_ 1 _N_ _S_ "U(P)" {_A_ 1 _U_ 2 _N_ _N_ _N_ _N_} _N_ _N_ },
+ atanh = { _A_ 1 _U_ 1 _N_ _S_ "U(P)" {_A_ 1 _U_ 2 _N_ _N_ _N_ _N_} _N_ _N_ } #-}
instance Floating Float
{-# GHC_PRAGMA _M_ PreludeCore {-dfun-} _A_ 0 _N_ _N_ _N_ _F_ _IF_ARGS_ 0 0 X 20 _!_ _TUP_19 [{{Fractional Float}}, Float, (Float -> Float), (Float -> Float), (Float -> Float), (Float -> Float -> Float), (Float -> Float -> Float), (Float -> Float), (Float -> Float), (Float -> Float), (Float -> Float), (Float -> Float), (Float -> Float), (Float -> Float), (Float -> Float), (Float -> Float), (Float -> Float), (Float -> Float), (Float -> Float)] [_DFUN_ Fractional (Float), _CONSTM_ Floating pi (Float), _CONSTM_ Floating exp (Float), _CONSTM_ Floating log (Float), _CONSTM_ Floating sqrt (Float), _CONSTM_ Floating (**) (Float), _CONSTM_ Floating logBase (Float), _CONSTM_ Floating sin (Float), _CONSTM_ Floating cos (Float), _CONSTM_ Floating tan (Float), _CONSTM_ Floating asin (Float), _CONSTM_ Floating acos (Float), _CONSTM_ Floating atan (Float), _CONSTM_ Floating sinh (Float), _CONSTM_ Floating cosh (Float), _CONSTM_ Floating tanh (Float), _CONSTM_ Floating asinh (Float), _CONSTM_ Floating acosh (Float), _CONSTM_ Floating atanh (Float)] _N_
- pi = _A_ 0 _N_ _N_ _N_ _F_ _IF_ARGS_ 0 0 X 2 _!_ F# [] [3.1415926535897931#] _N_,
- exp = _A_ 1 _U_ 1 _N_ _S_ "U(P)" {_A_ 1 _U_ 2 _N_ _N_ _F_ _IF_ARGS_ 0 1 X 3 \ (u0 :: Float#) -> case _#_ expFloat# [] [u0] of { _PRIM_ (u1 :: Float#) -> _!_ F# [] [u1] } _N_} _F_ _IF_ARGS_ 0 1 C 4 \ (u0 :: Float) -> case u0 of { _ALG_ F# (u1 :: Float#) -> case _#_ expFloat# [] [u1] of { _PRIM_ (u2 :: Float#) -> _!_ F# [] [u2] }; _NO_DEFLT_ } _N_,
- log = _A_ 1 _U_ 1 _N_ _S_ "U(P)" {_A_ 1 _U_ 2 _N_ _N_ _F_ _IF_ARGS_ 0 1 X 3 \ (u0 :: Float#) -> case _#_ logFloat# [] [u0] of { _PRIM_ (u1 :: Float#) -> _!_ F# [] [u1] } _N_} _F_ _IF_ARGS_ 0 1 C 4 \ (u0 :: Float) -> case u0 of { _ALG_ F# (u1 :: Float#) -> case _#_ logFloat# [] [u1] of { _PRIM_ (u2 :: Float#) -> _!_ F# [] [u2] }; _NO_DEFLT_ } _N_,
- sqrt = _A_ 1 _U_ 1 _N_ _S_ "U(P)" {_A_ 1 _U_ 2 _N_ _N_ _F_ _IF_ARGS_ 0 1 X 3 \ (u0 :: Float#) -> case _#_ sqrtFloat# [] [u0] of { _PRIM_ (u1 :: Float#) -> _!_ F# [] [u1] } _N_} _F_ _IF_ARGS_ 0 1 C 4 \ (u0 :: Float) -> case u0 of { _ALG_ F# (u1 :: Float#) -> case _#_ sqrtFloat# [] [u1] of { _PRIM_ (u2 :: Float#) -> _!_ F# [] [u2] }; _NO_DEFLT_ } _N_,
- (**) = _A_ 2 _U_ 11 _N_ _S_ "U(P)U(P)" {_A_ 2 _U_ 22 _N_ _N_ _F_ _IF_ARGS_ 0 2 XX 3 \ (u0 :: Float#) (u1 :: Float#) -> case _#_ powerFloat# [] [u0, u1] of { _PRIM_ (u2 :: Float#) -> _!_ F# [] [u2] } _N_} _F_ _IF_ARGS_ 0 2 CC 5 \ (u0 :: Float) (u1 :: Float) -> case u0 of { _ALG_ F# (u2 :: Float#) -> case u1 of { _ALG_ F# (u3 :: Float#) -> case _#_ powerFloat# [] [u2, u3] of { _PRIM_ (u4 :: Float#) -> _!_ F# [] [u4] }; _NO_DEFLT_ }; _NO_DEFLT_ } _N_,
- logBase = _A_ 2 _U_ 22 _N_ _N_ _N_ _N_,
- sin = _A_ 1 _U_ 1 _N_ _S_ "U(P)" {_A_ 1 _U_ 2 _N_ _N_ _F_ _IF_ARGS_ 0 1 X 3 \ (u0 :: Float#) -> case _#_ sinFloat# [] [u0] of { _PRIM_ (u1 :: Float#) -> _!_ F# [] [u1] } _N_} _F_ _IF_ARGS_ 0 1 C 4 \ (u0 :: Float) -> case u0 of { _ALG_ F# (u1 :: Float#) -> case _#_ sinFloat# [] [u1] of { _PRIM_ (u2 :: Float#) -> _!_ F# [] [u2] }; _NO_DEFLT_ } _N_,
- cos = _A_ 1 _U_ 1 _N_ _S_ "U(P)" {_A_ 1 _U_ 2 _N_ _N_ _F_ _IF_ARGS_ 0 1 X 3 \ (u0 :: Float#) -> case _#_ cosFloat# [] [u0] of { _PRIM_ (u1 :: Float#) -> _!_ F# [] [u1] } _N_} _F_ _IF_ARGS_ 0 1 C 4 \ (u0 :: Float) -> case u0 of { _ALG_ F# (u1 :: Float#) -> case _#_ cosFloat# [] [u1] of { _PRIM_ (u2 :: Float#) -> _!_ F# [] [u2] }; _NO_DEFLT_ } _N_,
- tan = _A_ 1 _U_ 1 _N_ _S_ "U(P)" {_A_ 1 _U_ 2 _N_ _N_ _F_ _IF_ARGS_ 0 1 X 3 \ (u0 :: Float#) -> case _#_ tanFloat# [] [u0] of { _PRIM_ (u1 :: Float#) -> _!_ F# [] [u1] } _N_} _F_ _IF_ARGS_ 0 1 C 4 \ (u0 :: Float) -> case u0 of { _ALG_ F# (u1 :: Float#) -> case _#_ tanFloat# [] [u1] of { _PRIM_ (u2 :: Float#) -> _!_ F# [] [u2] }; _NO_DEFLT_ } _N_,
- asin = _A_ 1 _U_ 1 _N_ _S_ "U(P)" {_A_ 1 _U_ 2 _N_ _N_ _F_ _IF_ARGS_ 0 1 X 3 \ (u0 :: Float#) -> case _#_ asinFloat# [] [u0] of { _PRIM_ (u1 :: Float#) -> _!_ F# [] [u1] } _N_} _F_ _IF_ARGS_ 0 1 C 4 \ (u0 :: Float) -> case u0 of { _ALG_ F# (u1 :: Float#) -> case _#_ asinFloat# [] [u1] of { _PRIM_ (u2 :: Float#) -> _!_ F# [] [u2] }; _NO_DEFLT_ } _N_,
- acos = _A_ 1 _U_ 1 _N_ _S_ "U(P)" {_A_ 1 _U_ 2 _N_ _N_ _F_ _IF_ARGS_ 0 1 X 3 \ (u0 :: Float#) -> case _#_ acosFloat# [] [u0] of { _PRIM_ (u1 :: Float#) -> _!_ F# [] [u1] } _N_} _F_ _IF_ARGS_ 0 1 C 4 \ (u0 :: Float) -> case u0 of { _ALG_ F# (u1 :: Float#) -> case _#_ acosFloat# [] [u1] of { _PRIM_ (u2 :: Float#) -> _!_ F# [] [u2] }; _NO_DEFLT_ } _N_,
- atan = _A_ 1 _U_ 1 _N_ _S_ "U(P)" {_A_ 1 _U_ 2 _N_ _N_ _F_ _IF_ARGS_ 0 1 X 3 \ (u0 :: Float#) -> case _#_ atanFloat# [] [u0] of { _PRIM_ (u1 :: Float#) -> _!_ F# [] [u1] } _N_} _F_ _IF_ARGS_ 0 1 C 4 \ (u0 :: Float) -> case u0 of { _ALG_ F# (u1 :: Float#) -> case _#_ atanFloat# [] [u1] of { _PRIM_ (u2 :: Float#) -> _!_ F# [] [u2] }; _NO_DEFLT_ } _N_,
- sinh = _A_ 1 _U_ 1 _N_ _S_ "U(P)" {_A_ 1 _U_ 2 _N_ _N_ _F_ _IF_ARGS_ 0 1 X 3 \ (u0 :: Float#) -> case _#_ sinhFloat# [] [u0] of { _PRIM_ (u1 :: Float#) -> _!_ F# [] [u1] } _N_} _F_ _IF_ARGS_ 0 1 C 4 \ (u0 :: Float) -> case u0 of { _ALG_ F# (u1 :: Float#) -> case _#_ sinhFloat# [] [u1] of { _PRIM_ (u2 :: Float#) -> _!_ F# [] [u2] }; _NO_DEFLT_ } _N_,
- cosh = _A_ 1 _U_ 1 _N_ _S_ "U(P)" {_A_ 1 _U_ 2 _N_ _N_ _F_ _IF_ARGS_ 0 1 X 3 \ (u0 :: Float#) -> case _#_ coshFloat# [] [u0] of { _PRIM_ (u1 :: Float#) -> _!_ F# [] [u1] } _N_} _F_ _IF_ARGS_ 0 1 C 4 \ (u0 :: Float) -> case u0 of { _ALG_ F# (u1 :: Float#) -> case _#_ coshFloat# [] [u1] of { _PRIM_ (u2 :: Float#) -> _!_ F# [] [u2] }; _NO_DEFLT_ } _N_,
- tanh = _A_ 1 _U_ 1 _N_ _S_ "U(P)" {_A_ 1 _U_ 2 _N_ _N_ _F_ _IF_ARGS_ 0 1 X 3 \ (u0 :: Float#) -> case _#_ tanhFloat# [] [u0] of { _PRIM_ (u1 :: Float#) -> _!_ F# [] [u1] } _N_} _F_ _IF_ARGS_ 0 1 C 4 \ (u0 :: Float) -> case u0 of { _ALG_ F# (u1 :: Float#) -> case _#_ tanhFloat# [] [u1] of { _PRIM_ (u2 :: Float#) -> _!_ F# [] [u2] }; _NO_DEFLT_ } _N_,
- asinh = _A_ 1 _U_ 1 _N_ _S_ "U(P)" {_A_ 1 _U_ 2 _N_ _N_ _N_ _N_} _N_ _N_,
- acosh = _A_ 1 _U_ 1 _N_ _S_ "U(P)" {_A_ 1 _U_ 2 _N_ _N_ _N_ _N_} _N_ _N_,
- atanh = _A_ 1 _U_ 1 _N_ _S_ "U(P)" {_A_ 1 _U_ 2 _N_ _N_ _N_ _N_} _N_ _N_ #-}
+ pi = { _A_ 0 _N_ _N_ _N_ _F_ _IF_ARGS_ 0 0 X 2 _!_ F# [] [3.1415926535897931#] _N_ },
+ exp = { _A_ 1 _U_ 1 _N_ _S_ "U(P)" {_A_ 1 _U_ 2 _N_ _N_ _F_ _IF_ARGS_ 0 1 X 3 \ (u0 :: Float#) -> case _#_ expFloat# [] [u0] of { _PRIM_ (u1 :: Float#) -> _!_ F# [] [u1] } _N_} _F_ _IF_ARGS_ 0 1 C 4 \ (u0 :: Float) -> case u0 of { _ALG_ F# (u1 :: Float#) -> case _#_ expFloat# [] [u1] of { _PRIM_ (u2 :: Float#) -> _!_ F# [] [u2] }; _NO_DEFLT_ } _N_ },
+ log = { _A_ 1 _U_ 1 _N_ _S_ "U(P)" {_A_ 1 _U_ 2 _N_ _N_ _F_ _IF_ARGS_ 0 1 X 3 \ (u0 :: Float#) -> case _#_ logFloat# [] [u0] of { _PRIM_ (u1 :: Float#) -> _!_ F# [] [u1] } _N_} _F_ _IF_ARGS_ 0 1 C 4 \ (u0 :: Float) -> case u0 of { _ALG_ F# (u1 :: Float#) -> case _#_ logFloat# [] [u1] of { _PRIM_ (u2 :: Float#) -> _!_ F# [] [u2] }; _NO_DEFLT_ } _N_ },
+ sqrt = { _A_ 1 _U_ 1 _N_ _S_ "U(P)" {_A_ 1 _U_ 2 _N_ _N_ _F_ _IF_ARGS_ 0 1 X 3 \ (u0 :: Float#) -> case _#_ sqrtFloat# [] [u0] of { _PRIM_ (u1 :: Float#) -> _!_ F# [] [u1] } _N_} _F_ _IF_ARGS_ 0 1 C 4 \ (u0 :: Float) -> case u0 of { _ALG_ F# (u1 :: Float#) -> case _#_ sqrtFloat# [] [u1] of { _PRIM_ (u2 :: Float#) -> _!_ F# [] [u2] }; _NO_DEFLT_ } _N_ },
+ (**) = { _A_ 2 _U_ 11 _N_ _S_ "U(P)U(P)" {_A_ 2 _U_ 22 _N_ _N_ _F_ _IF_ARGS_ 0 2 XX 3 \ (u0 :: Float#) (u1 :: Float#) -> case _#_ powerFloat# [] [u0, u1] of { _PRIM_ (u2 :: Float#) -> _!_ F# [] [u2] } _N_} _F_ _IF_ARGS_ 0 2 CC 5 \ (u0 :: Float) (u1 :: Float) -> case u0 of { _ALG_ F# (u2 :: Float#) -> case u1 of { _ALG_ F# (u3 :: Float#) -> case _#_ powerFloat# [] [u2, u3] of { _PRIM_ (u4 :: Float#) -> _!_ F# [] [u4] }; _NO_DEFLT_ }; _NO_DEFLT_ } _N_ },
+ logBase = { _A_ 2 _U_ 11 _N_ _S_ "U(P)U(P)" {_A_ 2 _U_ 22 _N_ _N_ _F_ _IF_ARGS_ 0 2 XX 5 \ (u0 :: Float#) (u1 :: Float#) -> case _#_ logFloat# [] [u1] of { _PRIM_ (u2 :: Float#) -> case _#_ logFloat# [] [u0] of { _PRIM_ (u3 :: Float#) -> case _#_ divideFloat# [] [u2, u3] of { _PRIM_ (u4 :: Float#) -> _!_ F# [] [u4] } } } _N_} _F_ _IF_ARGS_ 0 2 CC 7 \ (u0 :: Float) (u1 :: Float) -> case u1 of { _ALG_ F# (u2 :: Float#) -> case _#_ logFloat# [] [u2] of { _PRIM_ (u3 :: Float#) -> case u0 of { _ALG_ F# (u4 :: Float#) -> case _#_ logFloat# [] [u4] of { _PRIM_ (u5 :: Float#) -> case _#_ divideFloat# [] [u3, u5] of { _PRIM_ (u6 :: Float#) -> _!_ F# [] [u6] } }; _NO_DEFLT_ } }; _NO_DEFLT_ } _N_ },
+ sin = { _A_ 1 _U_ 1 _N_ _S_ "U(P)" {_A_ 1 _U_ 2 _N_ _N_ _F_ _IF_ARGS_ 0 1 X 3 \ (u0 :: Float#) -> case _#_ sinFloat# [] [u0] of { _PRIM_ (u1 :: Float#) -> _!_ F# [] [u1] } _N_} _F_ _IF_ARGS_ 0 1 C 4 \ (u0 :: Float) -> case u0 of { _ALG_ F# (u1 :: Float#) -> case _#_ sinFloat# [] [u1] of { _PRIM_ (u2 :: Float#) -> _!_ F# [] [u2] }; _NO_DEFLT_ } _N_ },
+ cos = { _A_ 1 _U_ 1 _N_ _S_ "U(P)" {_A_ 1 _U_ 2 _N_ _N_ _F_ _IF_ARGS_ 0 1 X 3 \ (u0 :: Float#) -> case _#_ cosFloat# [] [u0] of { _PRIM_ (u1 :: Float#) -> _!_ F# [] [u1] } _N_} _F_ _IF_ARGS_ 0 1 C 4 \ (u0 :: Float) -> case u0 of { _ALG_ F# (u1 :: Float#) -> case _#_ cosFloat# [] [u1] of { _PRIM_ (u2 :: Float#) -> _!_ F# [] [u2] }; _NO_DEFLT_ } _N_ },
+ tan = { _A_ 1 _U_ 1 _N_ _S_ "U(P)" {_A_ 1 _U_ 2 _N_ _N_ _F_ _IF_ARGS_ 0 1 X 3 \ (u0 :: Float#) -> case _#_ tanFloat# [] [u0] of { _PRIM_ (u1 :: Float#) -> _!_ F# [] [u1] } _N_} _F_ _IF_ARGS_ 0 1 C 4 \ (u0 :: Float) -> case u0 of { _ALG_ F# (u1 :: Float#) -> case _#_ tanFloat# [] [u1] of { _PRIM_ (u2 :: Float#) -> _!_ F# [] [u2] }; _NO_DEFLT_ } _N_ },
+ asin = { _A_ 1 _U_ 1 _N_ _S_ "U(P)" {_A_ 1 _U_ 2 _N_ _N_ _F_ _IF_ARGS_ 0 1 X 3 \ (u0 :: Float#) -> case _#_ asinFloat# [] [u0] of { _PRIM_ (u1 :: Float#) -> _!_ F# [] [u1] } _N_} _F_ _IF_ARGS_ 0 1 C 4 \ (u0 :: Float) -> case u0 of { _ALG_ F# (u1 :: Float#) -> case _#_ asinFloat# [] [u1] of { _PRIM_ (u2 :: Float#) -> _!_ F# [] [u2] }; _NO_DEFLT_ } _N_ },
+ acos = { _A_ 1 _U_ 1 _N_ _S_ "U(P)" {_A_ 1 _U_ 2 _N_ _N_ _F_ _IF_ARGS_ 0 1 X 3 \ (u0 :: Float#) -> case _#_ acosFloat# [] [u0] of { _PRIM_ (u1 :: Float#) -> _!_ F# [] [u1] } _N_} _F_ _IF_ARGS_ 0 1 C 4 \ (u0 :: Float) -> case u0 of { _ALG_ F# (u1 :: Float#) -> case _#_ acosFloat# [] [u1] of { _PRIM_ (u2 :: Float#) -> _!_ F# [] [u2] }; _NO_DEFLT_ } _N_ },
+ atan = { _A_ 1 _U_ 1 _N_ _S_ "U(P)" {_A_ 1 _U_ 2 _N_ _N_ _F_ _IF_ARGS_ 0 1 X 3 \ (u0 :: Float#) -> case _#_ atanFloat# [] [u0] of { _PRIM_ (u1 :: Float#) -> _!_ F# [] [u1] } _N_} _F_ _IF_ARGS_ 0 1 C 4 \ (u0 :: Float) -> case u0 of { _ALG_ F# (u1 :: Float#) -> case _#_ atanFloat# [] [u1] of { _PRIM_ (u2 :: Float#) -> _!_ F# [] [u2] }; _NO_DEFLT_ } _N_ },
+ sinh = { _A_ 1 _U_ 1 _N_ _S_ "U(P)" {_A_ 1 _U_ 2 _N_ _N_ _F_ _IF_ARGS_ 0 1 X 3 \ (u0 :: Float#) -> case _#_ sinhFloat# [] [u0] of { _PRIM_ (u1 :: Float#) -> _!_ F# [] [u1] } _N_} _F_ _IF_ARGS_ 0 1 C 4 \ (u0 :: Float) -> case u0 of { _ALG_ F# (u1 :: Float#) -> case _#_ sinhFloat# [] [u1] of { _PRIM_ (u2 :: Float#) -> _!_ F# [] [u2] }; _NO_DEFLT_ } _N_ },
+ cosh = { _A_ 1 _U_ 1 _N_ _S_ "U(P)" {_A_ 1 _U_ 2 _N_ _N_ _F_ _IF_ARGS_ 0 1 X 3 \ (u0 :: Float#) -> case _#_ coshFloat# [] [u0] of { _PRIM_ (u1 :: Float#) -> _!_ F# [] [u1] } _N_} _F_ _IF_ARGS_ 0 1 C 4 \ (u0 :: Float) -> case u0 of { _ALG_ F# (u1 :: Float#) -> case _#_ coshFloat# [] [u1] of { _PRIM_ (u2 :: Float#) -> _!_ F# [] [u2] }; _NO_DEFLT_ } _N_ },
+ tanh = { _A_ 1 _U_ 1 _N_ _S_ "U(P)" {_A_ 1 _U_ 2 _N_ _N_ _F_ _IF_ARGS_ 0 1 X 3 \ (u0 :: Float#) -> case _#_ tanhFloat# [] [u0] of { _PRIM_ (u1 :: Float#) -> _!_ F# [] [u1] } _N_} _F_ _IF_ARGS_ 0 1 C 4 \ (u0 :: Float) -> case u0 of { _ALG_ F# (u1 :: Float#) -> case _#_ tanhFloat# [] [u1] of { _PRIM_ (u2 :: Float#) -> _!_ F# [] [u2] }; _NO_DEFLT_ } _N_ },
+ asinh = { _A_ 1 _U_ 1 _N_ _S_ "U(P)" {_A_ 1 _U_ 2 _N_ _N_ _N_ _N_} _N_ _N_ },
+ acosh = { _A_ 1 _U_ 1 _N_ _S_ "U(P)" {_A_ 1 _U_ 2 _N_ _N_ _N_ _N_} _N_ _N_ },
+ atanh = { _A_ 1 _U_ 1 _N_ _S_ "U(P)" {_A_ 1 _U_ 2 _N_ _N_ _N_ _N_} _N_ _N_ } #-}
instance RealFloat a => Fractional (Complex a)
{-# GHC_PRAGMA _M_ PreludeComplex {-dfun-} _A_ 2 _U_ 22 _N_ _N_ _N_ _N_ #-}
instance Fractional (Complex Double)
{-# GHC_PRAGMA _M_ PreludeComplex {-dfun-} _A_ 0 _N_ _N_ _N_ _F_ _IF_ARGS_ 0 0 X 5 _!_ _TUP_4 [{{Num (Complex Double)}}, (Complex Double -> Complex Double -> Complex Double), (Complex Double -> Complex Double), (Ratio Integer -> Complex Double)] [_DFUN_ Num (Complex Double), _CONSTM_ Fractional (/) (Complex Double), _CONSTM_ Fractional recip (Complex Double), _CONSTM_ Fractional fromRational (Complex Double)] _N_
- (/) = _A_ 2 _U_ 11 _N_ _S_ "U(LL)U(LL)" {_A_ 4 _U_ 2222 _N_ _N_ _N_ _N_} _N_ _N_,
- recip = _A_ 1 _U_ 1 _N_ _S_ "U(LL)" {_A_ 2 _U_ 22 _N_ _N_ _N_ _N_} _N_ _N_,
- fromRational = _A_ 1 _U_ 2 _N_ _N_ _N_ _N_ #-}
+ (/) = { _A_ 2 _U_ 11 _N_ _S_ "U(LL)U(LL)" {_A_ 4 _U_ 2222 _N_ _N_ _N_ _N_} _N_ _N_ },
+ recip = { _A_ 1 _U_ 1 _N_ _S_ "U(LL)" {_A_ 2 _U_ 22 _N_ _N_ _N_ _N_} _F_ _IF_ARGS_ 0 1 X 3 \ (u0 :: Complex Double) -> _APP_ _CONSTM_ Fractional (/) (Complex Double) [ _SPEC_ _ORIG_ PreludeCore __i1 [ (Complex Double) ], u0 ] _N_ },
+ fromRational = { _A_ 1 _U_ 1 _N_ _N_ _N_ _N_ } #-}
instance Fractional Double
{-# GHC_PRAGMA _M_ PreludeCore {-dfun-} _A_ 0 _N_ _N_ _N_ _F_ _IF_ARGS_ 0 0 X 5 _!_ _TUP_4 [{{Num Double}}, (Double -> Double -> Double), (Double -> Double), (Ratio Integer -> Double)] [_DFUN_ Num (Double), _CONSTM_ Fractional (/) (Double), _CONSTM_ Fractional recip (Double), _CONSTM_ Fractional fromRational (Double)] _N_
- (/) = _A_ 2 _U_ 11 _N_ _S_ "U(P)U(P)" {_A_ 2 _U_ 22 _N_ _N_ _F_ _IF_ARGS_ 0 2 XX 3 \ (u0 :: Double#) (u1 :: Double#) -> case _#_ divideDouble# [] [u0, u1] of { _PRIM_ (u2 :: Double#) -> _!_ D# [] [u2] } _N_} _F_ _IF_ARGS_ 0 2 CC 5 \ (u0 :: Double) (u1 :: Double) -> case u0 of { _ALG_ D# (u2 :: Double#) -> case u1 of { _ALG_ D# (u3 :: Double#) -> case _#_ divideDouble# [] [u2, u3] of { _PRIM_ (u4 :: Double#) -> _!_ D# [] [u4] }; _NO_DEFLT_ }; _NO_DEFLT_ } _N_,
- recip = _A_ 1 _U_ 1 _N_ _S_ "U(P)" {_A_ 1 _U_ 2 _N_ _N_ _F_ _IF_ARGS_ 0 1 X 3 \ (u0 :: Double#) -> case _#_ divideDouble# [] [1.0000000000000000##, u0] of { _PRIM_ (u1 :: Double#) -> _!_ D# [] [u1] } _N_} _F_ _IF_ARGS_ 0 1 C 4 \ (u0 :: Double) -> case u0 of { _ALG_ D# (u1 :: Double#) -> case _#_ divideDouble# [] [1.0000000000000000##, u1] of { _PRIM_ (u2 :: Double#) -> _!_ D# [] [u2] }; _NO_DEFLT_ } _N_,
- fromRational = _A_ 0 _U_ 2 _N_ _N_ _N_ _N_ #-}
+ (/) = { _A_ 2 _U_ 11 _N_ _S_ "U(P)U(P)" {_A_ 2 _U_ 22 _N_ _N_ _F_ _IF_ARGS_ 0 2 XX 3 \ (u0 :: Double#) (u1 :: Double#) -> case _#_ divideDouble# [] [u0, u1] of { _PRIM_ (u2 :: Double#) -> _!_ D# [] [u2] } _N_} _F_ _IF_ARGS_ 0 2 CC 5 \ (u0 :: Double) (u1 :: Double) -> case u0 of { _ALG_ D# (u2 :: Double#) -> case u1 of { _ALG_ D# (u3 :: Double#) -> case _#_ divideDouble# [] [u2, u3] of { _PRIM_ (u4 :: Double#) -> _!_ D# [] [u4] }; _NO_DEFLT_ }; _NO_DEFLT_ } _N_ },
+ recip = { _A_ 1 _U_ 1 _N_ _S_ "U(P)" {_A_ 1 _U_ 2 _N_ _N_ _F_ _IF_ARGS_ 0 1 X 3 \ (u0 :: Double#) -> case _#_ divideDouble# [] [1.0000000000000000##, u0] of { _PRIM_ (u1 :: Double#) -> _!_ D# [] [u1] } _N_} _F_ _IF_ARGS_ 0 1 C 4 \ (u0 :: Double) -> case u0 of { _ALG_ D# (u1 :: Double#) -> case _#_ divideDouble# [] [1.0000000000000000##, u1] of { _PRIM_ (u2 :: Double#) -> _!_ D# [] [u2] }; _NO_DEFLT_ } _N_ },
+ fromRational = { _A_ 1 _U_ 1 _N_ _S_ "U(U(PPP)U(PPP))" {_A_ 4 _U_ 2222 _N_ _N_ _N_ _N_} _N_ _N_ } #-}
instance Fractional Float
{-# GHC_PRAGMA _M_ PreludeCore {-dfun-} _A_ 0 _N_ _N_ _N_ _F_ _IF_ARGS_ 0 0 X 5 _!_ _TUP_4 [{{Num Float}}, (Float -> Float -> Float), (Float -> Float), (Ratio Integer -> Float)] [_DFUN_ Num (Float), _CONSTM_ Fractional (/) (Float), _CONSTM_ Fractional recip (Float), _CONSTM_ Fractional fromRational (Float)] _N_
- (/) = _A_ 2 _U_ 11 _N_ _S_ "U(P)U(P)" {_A_ 2 _U_ 22 _N_ _N_ _F_ _IF_ARGS_ 0 2 XX 3 \ (u0 :: Float#) (u1 :: Float#) -> case _#_ divideFloat# [] [u0, u1] of { _PRIM_ (u2 :: Float#) -> _!_ F# [] [u2] } _N_} _F_ _IF_ARGS_ 0 2 CC 5 \ (u0 :: Float) (u1 :: Float) -> case u0 of { _ALG_ F# (u2 :: Float#) -> case u1 of { _ALG_ F# (u3 :: Float#) -> case _#_ divideFloat# [] [u2, u3] of { _PRIM_ (u4 :: Float#) -> _!_ F# [] [u4] }; _NO_DEFLT_ }; _NO_DEFLT_ } _N_,
- recip = _A_ 0 _U_ 2 _N_ _N_ _N_ _N_,
- fromRational = _A_ 0 _U_ 2 _N_ _N_ _N_ _N_ #-}
+ (/) = { _A_ 2 _U_ 11 _N_ _S_ "U(P)U(P)" {_A_ 2 _U_ 22 _N_ _N_ _F_ _IF_ARGS_ 0 2 XX 3 \ (u0 :: Float#) (u1 :: Float#) -> case _#_ divideFloat# [] [u0, u1] of { _PRIM_ (u2 :: Float#) -> _!_ F# [] [u2] } _N_} _F_ _IF_ARGS_ 0 2 CC 5 \ (u0 :: Float) (u1 :: Float) -> case u0 of { _ALG_ F# (u2 :: Float#) -> case u1 of { _ALG_ F# (u3 :: Float#) -> case _#_ divideFloat# [] [u2, u3] of { _PRIM_ (u4 :: Float#) -> _!_ F# [] [u4] }; _NO_DEFLT_ }; _NO_DEFLT_ } _N_ },
+ recip = { _A_ 1 _U_ 1 _N_ _S_ "U(P)" {_A_ 1 _U_ 2 _N_ _N_ _F_ _IF_ARGS_ 0 1 X 3 \ (u0 :: Float#) -> case _#_ divideFloat# [] [1.0000000000000000#, u0] of { _PRIM_ (u1 :: Float#) -> _!_ F# [] [u1] } _N_} _F_ _IF_ARGS_ 0 1 C 4 \ (u0 :: Float) -> case u0 of { _ALG_ F# (u1 :: Float#) -> case _#_ divideFloat# [] [1.0000000000000000#, u1] of { _PRIM_ (u2 :: Float#) -> _!_ F# [] [u2] }; _NO_DEFLT_ } _N_ },
+ fromRational = { _A_ 1 _U_ 2 _N_ _N_ _N_ _N_ } #-}
instance Integral a => Fractional (Ratio a)
{-# GHC_PRAGMA _M_ PreludeRatio {-dfun-} _A_ 2 _U_ 22 _N_ _N_ _N_ _N_ #-}
instance Fractional (Ratio Integer)
{-# GHC_PRAGMA _M_ PreludeRatio {-dfun-} _A_ 0 _N_ _N_ _N_ _F_ _IF_ARGS_ 0 0 X 5 _!_ _TUP_4 [{{Num (Ratio Integer)}}, (Ratio Integer -> Ratio Integer -> Ratio Integer), (Ratio Integer -> Ratio Integer), (Ratio Integer -> Ratio Integer)] [_DFUN_ Num (Ratio Integer), _CONSTM_ Fractional (/) (Ratio Integer), _CONSTM_ Fractional recip (Ratio Integer), _CONSTM_ Fractional fromRational (Ratio Integer)] _N_
- (/) = _A_ 2 _U_ 11 _N_ _S_ "U(LU(PPP))U(U(PPP)L)" {_A_ 5 _U_ 22221 _N_ _N_ _N_ _N_} _N_ _N_,
- recip = _A_ 1 _U_ 1 _N_ _S_ "U(U(PPP)L)" {_A_ 4 _U_ 2222 _N_ _N_ _N_ _N_} _N_ _N_,
- fromRational = _A_ 1 _U_ 1 _N_ _S_ "U(LL)" {_A_ 2 _U_ 22 _N_ _N_ _F_ _IF_ARGS_ 0 2 XX 3 \ (u0 :: Integer) (u1 :: Integer) -> _!_ (:%) [Integer] [u0, u1] _N_} _F_ _IF_ARGS_ 0 1 X 1 \ (u0 :: Ratio Integer) -> u0 _N_ #-}
+ (/) = { _A_ 2 _U_ 11 _N_ _S_ "U(LU(PPP))U(U(PPP)L)" {_A_ 5 _U_ 22221 _N_ _N_ _N_ _N_} _N_ _N_ },
+ recip = { _A_ 1 _U_ 1 _N_ _S_ "U(U(PPP)L)" {_A_ 4 _U_ 2222 _N_ _N_ _N_ _N_} _N_ _N_ },
+ fromRational = { _A_ 1 _U_ 1 _N_ _S_ "U(LL)" {_A_ 2 _U_ 22 _N_ _N_ _F_ _IF_ARGS_ 0 2 XX 3 \ (u0 :: Integer) (u1 :: Integer) -> _!_ (:%) [Integer] [u0, u1] _N_} _F_ _IF_ARGS_ 0 1 X 1 \ (u0 :: Ratio Integer) -> u0 _N_ } #-}
instance Integral Int
{-# GHC_PRAGMA _M_ PreludeCore {-dfun-} _A_ 0 _N_ _N_ _N_ _F_ _IF_ARGS_ 0 0 X 13 _!_ _TUP_12 [{{Real Int}}, {{Ix Int}}, (Int -> Int -> Int), (Int -> Int -> Int), (Int -> Int -> Int), (Int -> Int -> Int), (Int -> Int -> (Int, Int)), (Int -> Int -> (Int, Int)), (Int -> Bool), (Int -> Bool), (Int -> Integer), (Int -> Int)] [_DFUN_ Real (Int), _DFUN_ Ix (Int), _CONSTM_ Integral quot (Int), _CONSTM_ Integral rem (Int), _CONSTM_ Integral div (Int), _CONSTM_ Integral mod (Int), _CONSTM_ Integral quotRem (Int), _CONSTM_ Integral divMod (Int), _CONSTM_ Integral even (Int), _CONSTM_ Integral odd (Int), _CONSTM_ Integral toInteger (Int), _CONSTM_ Integral toInt (Int)] _N_
- quot = _A_ 2 _U_ 11 _N_ _S_ "U(P)U(P)" {_A_ 2 _U_ 22 _N_ _N_ _F_ _IF_ARGS_ 0 2 XC 5 \ (u0 :: Int#) (u1 :: Int#) -> case u1 of { _PRIM_ 0# -> _APP_ _TYAPP_ error { Int } [ _NOREP_S_ "Integral.Int.quot{PreludeCore}: divide by 0\n" ]; (u2 :: Int#) -> case _#_ quotInt# [] [u0, u1] of { _PRIM_ (u3 :: Int#) -> _!_ I# [] [u3] } } _N_} _F_ _IF_ARGS_ 0 2 CC 7 \ (u0 :: Int) (u1 :: Int) -> case u1 of { _ALG_ I# (u2 :: Int#) -> case u2 of { _PRIM_ 0# -> _APP_ _TYAPP_ error { Int } [ _NOREP_S_ "Integral.Int.quot{PreludeCore}: divide by 0\n" ]; (u3 :: Int#) -> case u0 of { _ALG_ I# (u4 :: Int#) -> case _#_ quotInt# [] [u4, u2] of { _PRIM_ (u5 :: Int#) -> _!_ I# [] [u5] }; _NO_DEFLT_ } }; _NO_DEFLT_ } _N_,
- rem = _A_ 2 _U_ 11 _N_ _S_ "U(P)U(P)" {_A_ 2 _U_ 22 _N_ _N_ _F_ _IF_ARGS_ 0 2 XC 5 \ (u0 :: Int#) (u1 :: Int#) -> case u1 of { _PRIM_ 0# -> _APP_ _TYAPP_ error { Int } [ _NOREP_S_ "Integral.Int.rem{PreludeCore}: divide by 0\n" ]; (u2 :: Int#) -> case _#_ remInt# [] [u0, u1] of { _PRIM_ (u3 :: Int#) -> _!_ I# [] [u3] } } _N_} _F_ _IF_ARGS_ 0 2 CC 7 \ (u0 :: Int) (u1 :: Int) -> case u1 of { _ALG_ I# (u2 :: Int#) -> case u2 of { _PRIM_ 0# -> _APP_ _TYAPP_ error { Int } [ _NOREP_S_ "Integral.Int.rem{PreludeCore}: divide by 0\n" ]; (u3 :: Int#) -> case u0 of { _ALG_ I# (u4 :: Int#) -> case _#_ remInt# [] [u4, u2] of { _PRIM_ (u5 :: Int#) -> _!_ I# [] [u5] }; _NO_DEFLT_ } }; _NO_DEFLT_ } _N_,
- div = _A_ 2 _U_ 11 _N_ _S_ "U(P)U(P)" {_A_ 2 _U_ 22 _N_ _N_ _N_ _N_} _N_ _N_,
- mod = _A_ 2 _U_ 11 _N_ _S_ "U(P)U(P)" {_A_ 2 _U_ 22 _N_ _N_ _N_ _N_} _N_ _N_,
- quotRem = _A_ 2 _U_ 11 _N_ _S_ "U(P)U(P)" {_A_ 2 _U_ 22 _N_ _N_ _N_ _N_} _N_ _N_,
- divMod = _A_ 2 _U_ 11 _N_ _S_ "U(P)U(P)" {_A_ 2 _U_ 22 _N_ _N_ _N_ _N_} _N_ _N_,
- even = _A_ 1 _U_ 1 _N_ _S_ "U(P)" {_A_ 1 _U_ 2 _N_ _N_ _N_ _N_} _N_ _N_,
- odd = _A_ 1 _U_ 1 _N_ _S_ "U(P)" {_A_ 1 _U_ 2 _N_ _N_ _N_ _N_} _N_ _N_,
- toInteger = _A_ 1 _U_ 1 _N_ _S_ "U(P)" {_A_ 1 _U_ 2 _N_ _N_ _F_ _IF_ARGS_ 0 1 X 1 \ (u0 :: Int#) -> _#_ int2Integer# [] [u0] _N_} _F_ _IF_ARGS_ 0 1 C 2 \ (u0 :: Int) -> case u0 of { _ALG_ I# (u1 :: Int#) -> _#_ int2Integer# [] [u1]; _NO_DEFLT_ } _N_,
- toInt = _A_ 1 _U_ 1 _N_ _S_ "U(P)" {_A_ 1 _U_ 2 _N_ _N_ _F_ _IF_ARGS_ 0 1 X 2 \ (u0 :: Int#) -> _!_ I# [] [u0] _N_} _F_ _IF_ARGS_ 0 1 X 1 \ (u0 :: Int) -> u0 _N_ #-}
+ quot = { _A_ 2 _U_ 11 _N_ _S_ "U(P)U(P)" {_A_ 2 _U_ 22 _N_ _N_ _F_ _IF_ARGS_ 0 2 XC 5 \ (u0 :: Int#) (u1 :: Int#) -> case u1 of { _PRIM_ 0# -> _APP_ _TYAPP_ error { Int } [ _NOREP_S_ "Integral.Int.quot{PreludeCore}: divide by 0\n" ]; (u2 :: Int#) -> case _#_ quotInt# [] [u0, u1] of { _PRIM_ (u3 :: Int#) -> _!_ I# [] [u3] } } _N_} _F_ _IF_ARGS_ 0 2 CC 7 \ (u0 :: Int) (u1 :: Int) -> case u1 of { _ALG_ I# (u2 :: Int#) -> case u2 of { _PRIM_ 0# -> _APP_ _TYAPP_ error { Int } [ _NOREP_S_ "Integral.Int.quot{PreludeCore}: divide by 0\n" ]; (u3 :: Int#) -> case u0 of { _ALG_ I# (u4 :: Int#) -> case _#_ quotInt# [] [u4, u2] of { _PRIM_ (u5 :: Int#) -> _!_ I# [] [u5] }; _NO_DEFLT_ } }; _NO_DEFLT_ } _N_ },
+ rem = { _A_ 2 _U_ 11 _N_ _S_ "U(P)U(P)" {_A_ 2 _U_ 22 _N_ _N_ _F_ _IF_ARGS_ 0 2 XC 5 \ (u0 :: Int#) (u1 :: Int#) -> case u1 of { _PRIM_ 0# -> _APP_ _TYAPP_ error { Int } [ _NOREP_S_ "Integral.Int.rem{PreludeCore}: divide by 0\n" ]; (u2 :: Int#) -> case _#_ remInt# [] [u0, u1] of { _PRIM_ (u3 :: Int#) -> _!_ I# [] [u3] } } _N_} _F_ _IF_ARGS_ 0 2 CC 7 \ (u0 :: Int) (u1 :: Int) -> case u1 of { _ALG_ I# (u2 :: Int#) -> case u2 of { _PRIM_ 0# -> _APP_ _TYAPP_ error { Int } [ _NOREP_S_ "Integral.Int.rem{PreludeCore}: divide by 0\n" ]; (u3 :: Int#) -> case u0 of { _ALG_ I# (u4 :: Int#) -> case _#_ remInt# [] [u4, u2] of { _PRIM_ (u5 :: Int#) -> _!_ I# [] [u5] }; _NO_DEFLT_ } }; _NO_DEFLT_ } _N_ },
+ div = { _A_ 2 _U_ 11 _N_ _S_ "U(P)U(P)" {_A_ 2 _U_ 22 _N_ _N_ _N_ _N_} _N_ _N_ },
+ mod = { _A_ 2 _U_ 11 _N_ _S_ "U(P)U(P)" {_A_ 2 _U_ 22 _N_ _N_ _N_ _N_} _N_ _N_ },
+ quotRem = { _A_ 2 _U_ 11 _N_ _S_ "U(P)U(P)" {_A_ 2 _U_ 22 _N_ _N_ _N_ _N_} _N_ _N_ },
+ divMod = { _A_ 2 _U_ 11 _N_ _S_ "U(P)U(P)" {_A_ 2 _U_ 22 _N_ _N_ _N_ _N_} _N_ _N_ },
+ even = { _A_ 1 _U_ 1 _N_ _S_ "U(P)" {_A_ 1 _U_ 2 _N_ _N_ _N_ _N_} _N_ _N_ },
+ odd = { _A_ 1 _U_ 1 _N_ _S_ "U(P)" {_A_ 1 _U_ 2 _N_ _N_ _N_ _N_} _N_ _N_ },
+ toInteger = { _A_ 1 _U_ 1 _N_ _S_ "U(P)" {_A_ 1 _U_ 2 _N_ _N_ _F_ _IF_ARGS_ 0 1 X 1 \ (u0 :: Int#) -> _#_ int2Integer# [] [u0] _N_} _F_ _IF_ARGS_ 0 1 C 2 \ (u0 :: Int) -> case u0 of { _ALG_ I# (u1 :: Int#) -> _#_ int2Integer# [] [u1]; _NO_DEFLT_ } _N_ },
+ toInt = { _A_ 1 _U_ 1 _N_ _S_ "U(P)" {_A_ 1 _U_ 2 _N_ _N_ _F_ _IF_ARGS_ 0 1 X 2 \ (u0 :: Int#) -> _!_ I# [] [u0] _N_} _F_ _IF_ARGS_ 0 1 X 1 \ (u0 :: Int) -> u0 _N_ } #-}
instance Integral Integer
{-# GHC_PRAGMA _M_ PreludeCore {-dfun-} _A_ 0 _N_ _N_ _N_ _F_ _IF_ARGS_ 0 0 X 13 _!_ _TUP_12 [{{Real Integer}}, {{Ix Integer}}, (Integer -> Integer -> Integer), (Integer -> Integer -> Integer), (Integer -> Integer -> Integer), (Integer -> Integer -> Integer), (Integer -> Integer -> (Integer, Integer)), (Integer -> Integer -> (Integer, Integer)), (Integer -> Bool), (Integer -> Bool), (Integer -> Integer), (Integer -> Int)] [_DFUN_ Real (Integer), _DFUN_ Ix (Integer), _CONSTM_ Integral quot (Integer), _CONSTM_ Integral rem (Integer), _CONSTM_ Integral div (Integer), _CONSTM_ Integral mod (Integer), _CONSTM_ Integral quotRem (Integer), _CONSTM_ Integral divMod (Integer), _CONSTM_ Integral even (Integer), _CONSTM_ Integral odd (Integer), _CONSTM_ Integral toInteger (Integer), _CONSTM_ Integral toInt (Integer)] _N_
- quot = _A_ 2 _U_ 11 _N_ _S_ "U(PPP)U(PPP)" {_A_ 4 _U_ 2221 _N_ _N_ _F_ _IF_ARGS_ 0 4 XXXX 7 \ (u0 :: Int#) (u1 :: Int#) (u2 :: ByteArray#) (u3 :: Integer) -> case _APP_ _WRKR_ _CONSTM_ Integral quotRem (Integer) [ u0, u1, u2, u3 ] of { _ALG_ _TUP_2 (u4 :: Integer) (u5 :: Integer) -> u4; _NO_DEFLT_ } _N_} _F_ _IF_ARGS_ 0 2 XX 5 \ (u0 :: Integer) (u1 :: Integer) -> case _APP_ _CONSTM_ Integral quotRem (Integer) [ u0, u1 ] of { _ALG_ _TUP_2 (u2 :: Integer) (u3 :: Integer) -> u2; _NO_DEFLT_ } _N_,
- rem = _A_ 2 _U_ 11 _N_ _S_ "U(PPP)U(PPP)" {_A_ 4 _U_ 2221 _N_ _N_ _F_ _IF_ARGS_ 0 4 XXXX 7 \ (u0 :: Int#) (u1 :: Int#) (u2 :: ByteArray#) (u3 :: Integer) -> case _APP_ _WRKR_ _CONSTM_ Integral quotRem (Integer) [ u0, u1, u2, u3 ] of { _ALG_ _TUP_2 (u4 :: Integer) (u5 :: Integer) -> u5; _NO_DEFLT_ } _N_} _F_ _IF_ARGS_ 0 2 XX 5 \ (u0 :: Integer) (u1 :: Integer) -> case _APP_ _CONSTM_ Integral quotRem (Integer) [ u0, u1 ] of { _ALG_ _TUP_2 (u2 :: Integer) (u3 :: Integer) -> u3; _NO_DEFLT_ } _N_,
- div = _A_ 2 _U_ 12 _N_ _S_ "U(PPP)U(PPP)" {_A_ 4 _U_ 2222 _N_ _N_ _F_ _IF_ARGS_ 0 4 XXXX 7 \ (u0 :: Int#) (u1 :: Int#) (u2 :: ByteArray#) (u3 :: Integer) -> case _APP_ _WRKR_ _CONSTM_ Integral divMod (Integer) [ u0, u1, u2, u3 ] of { _ALG_ _TUP_2 (u4 :: Integer) (u5 :: Integer) -> u4; _NO_DEFLT_ } _N_} _F_ _IF_ARGS_ 0 2 XX 5 \ (u0 :: Integer) (u1 :: Integer) -> case _APP_ _CONSTM_ Integral divMod (Integer) [ u0, u1 ] of { _ALG_ _TUP_2 (u2 :: Integer) (u3 :: Integer) -> u2; _NO_DEFLT_ } _N_,
- mod = _A_ 2 _U_ 12 _N_ _S_ "U(PPP)U(PPP)" {_A_ 4 _U_ 2222 _N_ _N_ _F_ _IF_ARGS_ 0 4 XXXX 7 \ (u0 :: Int#) (u1 :: Int#) (u2 :: ByteArray#) (u3 :: Integer) -> case _APP_ _WRKR_ _CONSTM_ Integral divMod (Integer) [ u0, u1, u2, u3 ] of { _ALG_ _TUP_2 (u4 :: Integer) (u5 :: Integer) -> u5; _NO_DEFLT_ } _N_} _F_ _IF_ARGS_ 0 2 XX 5 \ (u0 :: Integer) (u1 :: Integer) -> case _APP_ _CONSTM_ Integral divMod (Integer) [ u0, u1 ] of { _ALG_ _TUP_2 (u2 :: Integer) (u3 :: Integer) -> u3; _NO_DEFLT_ } _N_,
- quotRem = _A_ 2 _U_ 11 _N_ _S_ "U(PPP)U(PPP)" {_A_ 4 _U_ 2221 _N_ _N_ _N_ _N_} _N_ _N_,
- divMod = _A_ 2 _U_ 12 _N_ _S_ "U(PPP)U(PPP)" {_A_ 4 _U_ 2222 _N_ _N_ _N_ _N_} _N_ _N_,
- even = _A_ 1 _U_ 1 _N_ _S_ "U(PPP)" {_A_ 3 _U_ 222 _N_ _N_ _N_ _N_} _N_ _N_,
- odd = _A_ 1 _U_ 1 _N_ _S_ "U(PPP)" {_A_ 3 _U_ 222 _N_ _N_ _N_ _N_} _N_ _N_,
- toInteger = _A_ 1 _U_ 1 _N_ _S_ "U(PPP)" {_A_ 3 _U_ 222 _N_ _N_ _F_ _IF_ARGS_ 0 3 XXX 4 \ (u0 :: Int#) (u1 :: Int#) (u2 :: ByteArray#) -> _!_ J# [] [u0, u1, u2] _N_} _F_ _IF_ARGS_ 0 1 X 1 \ (u0 :: Integer) -> u0 _N_,
- toInt = _A_ 1 _U_ 1 _N_ _S_ "U(PPP)" {_A_ 3 _U_ 222 _N_ _N_ _F_ _IF_ARGS_ 0 3 XXX 3 \ (u0 :: Int#) (u1 :: Int#) (u2 :: ByteArray#) -> case _#_ integer2Int# [] [u0, u1, u2] of { _PRIM_ (u3 :: Int#) -> _!_ I# [] [u3] } _N_} _F_ _IF_ARGS_ 0 1 C 4 \ (u0 :: Integer) -> case u0 of { _ALG_ J# (u1 :: Int#) (u2 :: Int#) (u3 :: ByteArray#) -> case _#_ integer2Int# [] [u1, u2, u3] of { _PRIM_ (u4 :: Int#) -> _!_ I# [] [u4] }; _NO_DEFLT_ } _N_ #-}
+ quot = { _A_ 2 _U_ 11 _N_ _S_ "U(PPP)U(PPP)" {_A_ 4 _U_ 2221 _N_ _N_ _F_ _IF_ARGS_ 0 4 XXXX 7 \ (u0 :: Int#) (u1 :: Int#) (u2 :: ByteArray#) (u3 :: Integer) -> case _APP_ _WRKR_ _CONSTM_ Integral quotRem (Integer) [ u0, u1, u2, u3 ] of { _ALG_ _TUP_2 (u4 :: Integer) (u5 :: Integer) -> u4; _NO_DEFLT_ } _N_} _F_ _IF_ARGS_ 0 2 XX 5 \ (u0 :: Integer) (u1 :: Integer) -> case _APP_ _CONSTM_ Integral quotRem (Integer) [ u0, u1 ] of { _ALG_ _TUP_2 (u2 :: Integer) (u3 :: Integer) -> u2; _NO_DEFLT_ } _N_ },
+ rem = { _A_ 2 _U_ 11 _N_ _S_ "U(PPP)U(PPP)" {_A_ 4 _U_ 2221 _N_ _N_ _F_ _IF_ARGS_ 0 4 XXXX 7 \ (u0 :: Int#) (u1 :: Int#) (u2 :: ByteArray#) (u3 :: Integer) -> case _APP_ _WRKR_ _CONSTM_ Integral quotRem (Integer) [ u0, u1, u2, u3 ] of { _ALG_ _TUP_2 (u4 :: Integer) (u5 :: Integer) -> u5; _NO_DEFLT_ } _N_} _F_ _IF_ARGS_ 0 2 XX 5 \ (u0 :: Integer) (u1 :: Integer) -> case _APP_ _CONSTM_ Integral quotRem (Integer) [ u0, u1 ] of { _ALG_ _TUP_2 (u2 :: Integer) (u3 :: Integer) -> u3; _NO_DEFLT_ } _N_ },
+ div = { _A_ 2 _U_ 12 _N_ _S_ "U(PPP)U(PPP)" {_A_ 4 _U_ 2222 _N_ _N_ _F_ _IF_ARGS_ 0 4 XXXX 7 \ (u0 :: Int#) (u1 :: Int#) (u2 :: ByteArray#) (u3 :: Integer) -> case _APP_ _WRKR_ _CONSTM_ Integral divMod (Integer) [ u0, u1, u2, u3 ] of { _ALG_ _TUP_2 (u4 :: Integer) (u5 :: Integer) -> u4; _NO_DEFLT_ } _N_} _F_ _IF_ARGS_ 0 2 XX 5 \ (u0 :: Integer) (u1 :: Integer) -> case _APP_ _CONSTM_ Integral divMod (Integer) [ u0, u1 ] of { _ALG_ _TUP_2 (u2 :: Integer) (u3 :: Integer) -> u2; _NO_DEFLT_ } _N_ },
+ mod = { _A_ 2 _U_ 12 _N_ _S_ "U(PPP)U(PPP)" {_A_ 4 _U_ 2222 _N_ _N_ _F_ _IF_ARGS_ 0 4 XXXX 7 \ (u0 :: Int#) (u1 :: Int#) (u2 :: ByteArray#) (u3 :: Integer) -> case _APP_ _WRKR_ _CONSTM_ Integral divMod (Integer) [ u0, u1, u2, u3 ] of { _ALG_ _TUP_2 (u4 :: Integer) (u5 :: Integer) -> u5; _NO_DEFLT_ } _N_} _F_ _IF_ARGS_ 0 2 XX 5 \ (u0 :: Integer) (u1 :: Integer) -> case _APP_ _CONSTM_ Integral divMod (Integer) [ u0, u1 ] of { _ALG_ _TUP_2 (u2 :: Integer) (u3 :: Integer) -> u3; _NO_DEFLT_ } _N_ },
+ quotRem = { _A_ 2 _U_ 11 _N_ _S_ "U(PPP)U(PPP)" {_A_ 4 _U_ 2221 _N_ _N_ _N_ _N_} _N_ _N_ },
+ divMod = { _A_ 2 _U_ 12 _N_ _S_ "U(PPP)U(PPP)" {_A_ 4 _U_ 2222 _N_ _N_ _N_ _N_} _N_ _N_ },
+ even = { _A_ 1 _U_ 1 _N_ _S_ "U(PPP)" {_A_ 3 _U_ 222 _N_ _N_ _N_ _N_} _N_ _N_ },
+ odd = { _A_ 1 _U_ 1 _N_ _S_ "U(PPP)" {_A_ 3 _U_ 222 _N_ _N_ _N_ _N_} _N_ _N_ },
+ toInteger = { _A_ 1 _U_ 1 _N_ _S_ "U(PPP)" {_A_ 3 _U_ 222 _N_ _N_ _F_ _IF_ARGS_ 0 3 XXX 4 \ (u0 :: Int#) (u1 :: Int#) (u2 :: ByteArray#) -> _!_ J# [] [u0, u1, u2] _N_} _F_ _IF_ARGS_ 0 1 X 1 \ (u0 :: Integer) -> u0 _N_ },
+ toInt = { _A_ 1 _U_ 1 _N_ _S_ "U(PPP)" {_A_ 3 _U_ 222 _N_ _N_ _F_ _IF_ARGS_ 0 3 XXX 3 \ (u0 :: Int#) (u1 :: Int#) (u2 :: ByteArray#) -> case _#_ integer2Int# [] [u0, u1, u2] of { _PRIM_ (u3 :: Int#) -> _!_ I# [] [u3] } _N_} _F_ _IF_ARGS_ 0 1 C 4 \ (u0 :: Integer) -> case u0 of { _ALG_ J# (u1 :: Int#) (u2 :: Int#) (u3 :: ByteArray#) -> case _#_ integer2Int# [] [u1, u2, u3] of { _PRIM_ (u4 :: Int#) -> _!_ I# [] [u4] }; _NO_DEFLT_ } _N_ } #-}
instance Ix ()
{-# GHC_PRAGMA _M_ PreludeBuiltin {-dfun-} _A_ 0 _N_ _N_ _N_ _F_ _IF_ARGS_ 0 0 X 5 _!_ _TUP_4 [{{Ord ()}}, (((), ()) -> [()]), (((), ()) -> () -> Int), (((), ()) -> () -> Bool)] [_DFUN_ Ord (()), _CONSTM_ Ix range (()), _CONSTM_ Ix index (()), _CONSTM_ Ix inRange (())] _N_
- range = _A_ 1 _U_ 1 _N_ _S_ "U(EE)" {_A_ 2 _U_ 21 _N_ _N_ _N_ _N_} _N_ _N_,
- index = _A_ 2 _U_ 11 _N_ _S_ "U(EE)E" {_A_ 3 _U_ 111 _N_ _N_ _F_ _IF_ARGS_ 0 3 CCC 5 \ (u0 :: ()) (u1 :: ()) (u2 :: ()) -> case u0 of { _ALG_ _TUP_0 -> case u1 of { _ALG_ _TUP_0 -> case u2 of { _ALG_ _TUP_0 -> _!_ I# [] [0#]; _NO_DEFLT_ }; _NO_DEFLT_ }; _NO_DEFLT_ } _N_} _F_ _IF_ARGS_ 0 2 CC 6 \ (u0 :: ((), ())) (u1 :: ()) -> case u0 of { _ALG_ _TUP_2 (u2 :: ()) (u3 :: ()) -> case u2 of { _ALG_ _TUP_0 -> case u3 of { _ALG_ _TUP_0 -> case u1 of { _ALG_ _TUP_0 -> _!_ I# [] [0#]; _NO_DEFLT_ }; _NO_DEFLT_ }; _NO_DEFLT_ }; _NO_DEFLT_ } _N_,
- inRange = _A_ 2 _U_ 11 _N_ _S_ "U(EE)E" {_A_ 3 _U_ 111 _N_ _N_ _F_ _IF_ARGS_ 0 3 CCC 4 \ (u0 :: ()) (u1 :: ()) (u2 :: ()) -> case u0 of { _ALG_ _TUP_0 -> case u1 of { _ALG_ _TUP_0 -> case u2 of { _ALG_ _TUP_0 -> _!_ True [] []; _NO_DEFLT_ }; _NO_DEFLT_ }; _NO_DEFLT_ } _N_} _F_ _IF_ARGS_ 0 2 CC 5 \ (u0 :: ((), ())) (u1 :: ()) -> case u0 of { _ALG_ _TUP_2 (u2 :: ()) (u3 :: ()) -> case u2 of { _ALG_ _TUP_0 -> case u3 of { _ALG_ _TUP_0 -> case u1 of { _ALG_ _TUP_0 -> _!_ True [] []; _NO_DEFLT_ }; _NO_DEFLT_ }; _NO_DEFLT_ }; _NO_DEFLT_ } _N_ #-}
+ range = { _A_ 1 _U_ 1 _N_ _S_ "U(EE)" {_A_ 2 _U_ 21 _N_ _N_ _N_ _N_} _N_ _N_ },
+ index = { _A_ 2 _U_ 11 _N_ _S_ "U(EE)E" {_A_ 3 _U_ 111 _N_ _N_ _F_ _IF_ARGS_ 0 3 CCC 5 \ (u0 :: ()) (u1 :: ()) (u2 :: ()) -> case u0 of { _ALG_ _TUP_0 -> case u1 of { _ALG_ _TUP_0 -> case u2 of { _ALG_ _TUP_0 -> _!_ I# [] [0#]; _NO_DEFLT_ }; _NO_DEFLT_ }; _NO_DEFLT_ } _N_} _F_ _IF_ARGS_ 0 2 CC 6 \ (u0 :: ((), ())) (u1 :: ()) -> case u0 of { _ALG_ _TUP_2 (u2 :: ()) (u3 :: ()) -> case u2 of { _ALG_ _TUP_0 -> case u3 of { _ALG_ _TUP_0 -> case u1 of { _ALG_ _TUP_0 -> _!_ I# [] [0#]; _NO_DEFLT_ }; _NO_DEFLT_ }; _NO_DEFLT_ }; _NO_DEFLT_ } _N_ },
+ inRange = { _A_ 2 _U_ 11 _N_ _S_ "U(EE)E" {_A_ 3 _U_ 111 _N_ _N_ _F_ _IF_ARGS_ 0 3 CCC 4 \ (u0 :: ()) (u1 :: ()) (u2 :: ()) -> case u0 of { _ALG_ _TUP_0 -> case u1 of { _ALG_ _TUP_0 -> case u2 of { _ALG_ _TUP_0 -> _!_ True [] []; _NO_DEFLT_ }; _NO_DEFLT_ }; _NO_DEFLT_ } _N_} _F_ _IF_ARGS_ 0 2 CC 5 \ (u0 :: ((), ())) (u1 :: ()) -> case u0 of { _ALG_ _TUP_2 (u2 :: ()) (u3 :: ()) -> case u2 of { _ALG_ _TUP_0 -> case u3 of { _ALG_ _TUP_0 -> case u1 of { _ALG_ _TUP_0 -> _!_ True [] []; _NO_DEFLT_ }; _NO_DEFLT_ }; _NO_DEFLT_ }; _NO_DEFLT_ } _N_ } #-}
instance (Ix a, Ix b) => Ix (a, b)
{-# GHC_PRAGMA _M_ PreludeBuiltin {-dfun-} _A_ 3 _U_ 222 _N_ _N_ _N_ _N_ #-}
instance (Ix a, Ix b, Ix c) => Ix (a, b, c)
{-# GHC_PRAGMA _M_ PreludeBuiltin {-dfun-} _A_ 6 _U_ 222222 _N_ _N_ _N_ _N_ #-}
instance Ix (Int, Int)
{-# GHC_PRAGMA _M_ PreludeBuiltin {-dfun-} _A_ 0 _N_ _N_ _N_ _F_ _IF_ARGS_ 0 0 X 5 _!_ _TUP_4 [{{Ord (Int, Int)}}, (((Int, Int), (Int, Int)) -> [(Int, Int)]), (((Int, Int), (Int, Int)) -> (Int, Int) -> Int), (((Int, Int), (Int, Int)) -> (Int, Int) -> Bool)] [_DFUN_ Ord ((Int, Int)), _CONSTM_ Ix range ((Int, Int)), _CONSTM_ Ix index ((Int, Int)), _CONSTM_ Ix inRange ((Int, Int))] _N_
- range = _A_ 1 _U_ 1 _N_ _S_ "U(SS)" {_A_ 2 _U_ 11 _N_ _N_ _N_ _N_} _N_ _N_,
- index = _A_ 2 _U_ 11 _N_ _S_ "U(SS)U(U(P)U(P))" {_A_ 4 _U_ 1122 _N_ _N_ _N_ _N_} _N_ _N_,
- inRange = _A_ 2 _U_ 11 _N_ _S_ "U(SS)U(U(P)L)" {_A_ 4 _U_ 1121 _N_ _N_ _N_ _N_} _N_ _N_ #-}
+ range = { _A_ 1 _U_ 1 _N_ _S_ "U(SS)" {_A_ 2 _U_ 11 _N_ _N_ _N_ _N_} _N_ _N_ },
+ index = { _A_ 2 _U_ 11 _N_ _S_ "U(SS)U(U(P)U(P))" {_A_ 4 _U_ 1122 _N_ _N_ _N_ _N_} _N_ _N_ },
+ inRange = { _A_ 2 _U_ 11 _N_ _S_ "U(SS)U(U(P)L)" {_A_ 4 _U_ 1121 _N_ _N_ _N_ _N_} _N_ _N_ } #-}
instance (Ix a, Ix b) => Ix (Assoc a b)
{-# GHC_PRAGMA _M_ PreludeArray {-dfun-} _A_ 3 _U_ 222 _N_ _N_ _N_ _N_ #-}
instance Ix Bool
{-# GHC_PRAGMA _M_ PreludeCore {-dfun-} _A_ 0 _N_ _N_ _N_ _F_ _IF_ARGS_ 0 0 X 5 _!_ _TUP_4 [{{Ord Bool}}, ((Bool, Bool) -> [Bool]), ((Bool, Bool) -> Bool -> Int), ((Bool, Bool) -> Bool -> Bool)] [_DFUN_ Ord (Bool), _CONSTM_ Ix range (Bool), _CONSTM_ Ix index (Bool), _CONSTM_ Ix inRange (Bool)] _N_
- range = _A_ 1 _U_ 1 _N_ _S_ "U(EE)" {_A_ 2 _U_ 11 _N_ _N_ _N_ _N_} _N_ _N_,
- index = _A_ 2 _U_ 11 _N_ _S_ "U(EA)E" {_A_ 2 _U_ 11 _N_ _N_ _N_ _N_} _N_ _N_,
- inRange = _A_ 2 _U_ 12 _N_ _S_ "U(EL)E" {_A_ 3 _U_ 112 _N_ _N_ _N_ _N_} _N_ _N_ #-}
+ range = { _A_ 1 _U_ 1 _N_ _S_ "U(EE)" {_A_ 2 _U_ 11 _N_ _N_ _N_ _N_} _N_ _N_ },
+ index = { _A_ 2 _U_ 11 _N_ _S_ "U(EA)E" {_A_ 2 _U_ 11 _N_ _N_ _N_ _N_} _N_ _N_ },
+ inRange = { _A_ 2 _U_ 12 _N_ _S_ "U(EL)E" {_A_ 3 _U_ 112 _N_ _N_ _N_ _N_} _N_ _N_ } #-}
instance Ix Char
{-# GHC_PRAGMA _M_ PreludeCore {-dfun-} _A_ 0 _N_ _N_ _N_ _F_ _IF_ARGS_ 0 0 X 5 _!_ _TUP_4 [{{Ord Char}}, ((Char, Char) -> [Char]), ((Char, Char) -> Char -> Int), ((Char, Char) -> Char -> Bool)] [_DFUN_ Ord (Char), _CONSTM_ Ix range (Char), _CONSTM_ Ix index (Char), _CONSTM_ Ix inRange (Char)] _N_
- range = _A_ 1 _U_ 1 _N_ _S_ "U(LL)" {_A_ 2 _U_ 22 _N_ _N_ _F_ _IF_ARGS_ 0 0 X 1 _CONSTM_ Enum enumFromTo (Char) _N_} _F_ _IF_ARGS_ 0 1 C 4 \ (u0 :: (Char, Char)) -> case u0 of { _ALG_ _TUP_2 (u1 :: Char) (u2 :: Char) -> _APP_ _CONSTM_ Enum enumFromTo (Char) [ u1, u2 ]; _NO_DEFLT_ } _N_,
- index = _A_ 2 _U_ 11 _N_ _S_ "U(U(P)L)U(P)" {_A_ 3 _U_ 212 _N_ _N_ _N_ _N_} _N_ _N_,
- inRange = _A_ 2 _U_ 11 _N_ _S_ "U(U(P)L)U(P)" {_A_ 3 _U_ 212 _N_ _N_ _N_ _N_} _N_ _N_ #-}
+ range = { _A_ 1 _U_ 1 _N_ _S_ "U(U(P)L)" {_A_ 2 _U_ 22 _N_ _N_ _N_ _N_} _F_ _IF_ARGS_ 0 1 C 4 \ (u0 :: (Char, Char)) -> case u0 of { _ALG_ _TUP_2 (u1 :: Char) (u2 :: Char) -> _APP_ _CONSTM_ Enum enumFromTo (Char) [ u1, u2 ]; _NO_DEFLT_ } _N_ },
+ index = { _A_ 2 _U_ 11 _N_ _S_ "U(U(P)L)U(P)" {_A_ 3 _U_ 212 _N_ _N_ _N_ _N_} _N_ _N_ },
+ inRange = { _A_ 2 _U_ 11 _N_ _S_ "U(U(P)L)U(P)" {_A_ 3 _U_ 212 _N_ _N_ _N_ _N_} _N_ _N_ } #-}
instance Ix Int
{-# GHC_PRAGMA _M_ PreludeCore {-dfun-} _A_ 0 _N_ _N_ _N_ _F_ _IF_ARGS_ 0 0 X 5 _!_ _TUP_4 [{{Ord Int}}, ((Int, Int) -> [Int]), ((Int, Int) -> Int -> Int), ((Int, Int) -> Int -> Bool)] [_DFUN_ Ord (Int), _CONSTM_ Ix range (Int), _CONSTM_ Ix index (Int), _CONSTM_ Ix inRange (Int)] _N_
- range = _A_ 1 _U_ 1 _N_ _S_ "U(U(P)U(P))" {_A_ 2 _U_ 22 _N_ _N_ _N_ _N_} _N_ _N_,
- index = _A_ 2 _U_ 11 _N_ _S_ "U(U(P)U(P))U(P)" {_A_ 3 _U_ 222 _N_ _N_ _N_ _N_} _N_ _N_,
- inRange = _A_ 2 _U_ 11 _N_ _S_ "U(U(P)U(P))U(P)" {_A_ 3 _U_ 222 _N_ _N_ _F_ _IF_ARGS_ 0 3 XXX 5 \ (u0 :: Int#) (u1 :: Int#) (u2 :: Int#) -> case _#_ leInt# [] [u0, u2] of { _ALG_ True -> _#_ leInt# [] [u2, u1]; False -> _!_ False [] []; _NO_DEFLT_ } _N_} _F_ _ALWAYS_ \ (u0 :: (Int, Int)) (u1 :: Int) -> case u0 of { _ALG_ _TUP_2 (u2 :: Int) (u3 :: Int) -> case u2 of { _ALG_ I# (u4 :: Int#) -> case u3 of { _ALG_ I# (u5 :: Int#) -> case u1 of { _ALG_ I# (u6 :: Int#) -> case _#_ leInt# [] [u4, u6] of { _ALG_ True -> _#_ leInt# [] [u6, u5]; False -> _!_ False [] []; _NO_DEFLT_ }; _NO_DEFLT_ }; _NO_DEFLT_ }; _NO_DEFLT_ }; _NO_DEFLT_ } _N_ #-}
+ range = { _A_ 1 _U_ 1 _N_ _S_ "U(U(P)U(P))" {_A_ 2 _U_ 22 _N_ _N_ _N_ _N_} _N_ _N_ },
+ index = { _A_ 2 _U_ 11 _N_ _S_ "U(U(P)U(P))U(P)" {_A_ 3 _U_ 222 _N_ _N_ _N_ _N_} _N_ _N_ },
+ inRange = { _A_ 2 _U_ 11 _N_ _S_ "U(U(P)U(P))U(P)" {_A_ 3 _U_ 222 _N_ _N_ _F_ _IF_ARGS_ 0 3 XXX 5 \ (u0 :: Int#) (u1 :: Int#) (u2 :: Int#) -> case _#_ leInt# [] [u0, u2] of { _ALG_ True -> _#_ leInt# [] [u2, u1]; False -> _!_ False [] []; _NO_DEFLT_ } _N_} _F_ _ALWAYS_ \ (u0 :: (Int, Int)) (u1 :: Int) -> case u0 of { _ALG_ _TUP_2 (u2 :: Int) (u3 :: Int) -> case u2 of { _ALG_ I# (u4 :: Int#) -> case u3 of { _ALG_ I# (u5 :: Int#) -> case u1 of { _ALG_ I# (u6 :: Int#) -> case _#_ leInt# [] [u4, u6] of { _ALG_ True -> _#_ leInt# [] [u6, u5]; False -> _!_ False [] []; _NO_DEFLT_ }; _NO_DEFLT_ }; _NO_DEFLT_ }; _NO_DEFLT_ }; _NO_DEFLT_ } _N_ } #-}
instance Ix Integer
{-# GHC_PRAGMA _M_ PreludeCore {-dfun-} _A_ 0 _N_ _N_ _N_ _F_ _IF_ARGS_ 0 0 X 5 _!_ _TUP_4 [{{Ord Integer}}, ((Integer, Integer) -> [Integer]), ((Integer, Integer) -> Integer -> Int), ((Integer, Integer) -> Integer -> Bool)] [_DFUN_ Ord (Integer), _CONSTM_ Ix range (Integer), _CONSTM_ Ix index (Integer), _CONSTM_ Ix inRange (Integer)] _N_
- range = _A_ 1 _U_ 1 _N_ _S_ "U(LL)" {_A_ 2 _U_ 22 _N_ _N_ _F_ _IF_ARGS_ 0 0 X 1 _CONSTM_ Enum enumFromTo (Integer) _N_} _F_ _IF_ARGS_ 0 1 C 4 \ (u0 :: (Integer, Integer)) -> case u0 of { _ALG_ _TUP_2 (u1 :: Integer) (u2 :: Integer) -> _APP_ _CONSTM_ Enum enumFromTo (Integer) [ u1, u2 ]; _NO_DEFLT_ } _N_,
- index = _A_ 2 _U_ 12 _N_ _S_ "U(U(PPP)L)U(PPP)" {_A_ 5 _U_ 22222 _N_ _N_ _N_ _N_} _N_ _N_,
- inRange = _A_ 2 _U_ 11 _N_ _S_ "U(U(PPP)L)U(PPP)" {_A_ 5 _U_ 22211 _N_ _N_ _F_ _IF_ARGS_ 0 5 XXXCC 9 \ (u0 :: Int#) (u1 :: Int#) (u2 :: ByteArray#) (u3 :: Integer) (u4 :: Integer) -> case u4 of { _ALG_ J# (u5 :: Int#) (u6 :: Int#) (u7 :: ByteArray#) -> case _#_ cmpInteger# [] [u0, u1, u2, u5, u6, u7] of { _PRIM_ (u8 :: Int#) -> case _#_ leInt# [] [u8, 0#] of { _ALG_ True -> case u3 of { _ALG_ J# (u9 :: Int#) (ua :: Int#) (ub :: ByteArray#) -> case _#_ cmpInteger# [] [u5, u6, u7, u9, ua, ub] of { _PRIM_ (uc :: Int#) -> _#_ leInt# [] [uc, 0#] }; _NO_DEFLT_ }; False -> _!_ False [] []; _NO_DEFLT_ } }; _NO_DEFLT_ } _N_} _N_ _N_ #-}
+ range = { _A_ 1 _U_ 1 _N_ _S_ "U(LL)" {_A_ 2 _U_ 22 _N_ _N_ _F_ _IF_ARGS_ 0 0 X 1 _CONSTM_ Enum enumFromTo (Integer) _N_} _F_ _IF_ARGS_ 0 1 C 4 \ (u0 :: (Integer, Integer)) -> case u0 of { _ALG_ _TUP_2 (u1 :: Integer) (u2 :: Integer) -> _APP_ _CONSTM_ Enum enumFromTo (Integer) [ u1, u2 ]; _NO_DEFLT_ } _N_ },
+ index = { _A_ 2 _U_ 12 _N_ _S_ "U(U(PPP)L)U(PPP)" {_A_ 5 _U_ 22222 _N_ _N_ _N_ _N_} _N_ _N_ },
+ inRange = { _A_ 2 _U_ 11 _N_ _S_ "U(U(PPP)L)U(PPP)" {_A_ 5 _U_ 22211 _N_ _N_ _F_ _IF_ARGS_ 0 5 XXXCC 9 \ (u0 :: Int#) (u1 :: Int#) (u2 :: ByteArray#) (u3 :: Integer) (u4 :: Integer) -> case u4 of { _ALG_ J# (u5 :: Int#) (u6 :: Int#) (u7 :: ByteArray#) -> case _#_ cmpInteger# [] [u0, u1, u2, u5, u6, u7] of { _PRIM_ (u8 :: Int#) -> case _#_ leInt# [] [u8, 0#] of { _ALG_ True -> case u3 of { _ALG_ J# (u9 :: Int#) (ua :: Int#) (ub :: ByteArray#) -> case _#_ cmpInteger# [] [u5, u6, u7, u9, ua, ub] of { _PRIM_ (uc :: Int#) -> _#_ leInt# [] [uc, 0#] }; _NO_DEFLT_ }; False -> _!_ False [] []; _NO_DEFLT_ } }; _NO_DEFLT_ } _N_} _N_ _N_ } #-}
instance RealFloat a => Num (Complex a)
{-# GHC_PRAGMA _M_ PreludeComplex {-dfun-} _A_ 3 _U_ 222 _N_ _N_ _N_ _N_ #-}
instance Num (Complex Double)
- {-# GHC_PRAGMA _M_ PreludeComplex {-dfun-} _A_ 0 _N_ _N_ _N_ _N_ _N_
- (+) = _A_ 2 _U_ 11 _N_ _S_ "U(LL)U(LL)" {_A_ 4 _U_ 1111 _N_ _N_ _N_ _N_} _N_ _N_,
- (-) = _A_ 2 _U_ 11 _N_ _S_ "U(LL)U(LL)" {_A_ 4 _U_ 1111 _N_ _N_ _N_ _N_} _N_ _N_,
- (*) = _A_ 2 _U_ 11 _N_ _S_ "U(LL)U(LL)" {_A_ 4 _U_ 2222 _N_ _N_ _N_ _N_} _N_ _N_,
- negate = _A_ 1 _U_ 1 _N_ _S_ "U(LL)" {_A_ 2 _U_ 11 _N_ _N_ _N_ _N_} _N_ _N_,
- abs = _A_ 1 _U_ 1 _N_ _N_ _N_ _N_,
- signum = _A_ 1 _U_ 1 _N_ _S_ "U(U(P)L)" {_A_ 2 _U_ 22 _N_ _N_ _N_ _N_} _N_ _N_,
- fromInteger = _A_ 1 _U_ 1 _N_ _N_ _N_ _N_,
- fromInt = _A_ 1 _U_ 1 _N_ _N_ _N_ _N_ #-}
+ {-# GHC_PRAGMA _M_ PreludeComplex {-dfun-} _A_ 0 _N_ _N_ _N_ _F_ _IF_ARGS_ 0 0 X 11 _!_ _TUP_10 [{{Eq (Complex Double)}}, {{Text (Complex Double)}}, (Complex Double -> Complex Double -> Complex Double), (Complex Double -> Complex Double -> Complex Double), (Complex Double -> Complex Double -> Complex Double), (Complex Double -> Complex Double), (Complex Double -> Complex Double), (Complex Double -> Complex Double), (Integer -> Complex Double), (Int -> Complex Double)] [_DFUN_ Eq (Complex Double), _DFUN_ Text (Complex Double), _CONSTM_ Num (+) (Complex Double), _CONSTM_ Num (-) (Complex Double), _CONSTM_ Num (*) (Complex Double), _CONSTM_ Num negate (Complex Double), _CONSTM_ Num abs (Complex Double), _CONSTM_ Num signum (Complex Double), _CONSTM_ Num fromInteger (Complex Double), _CONSTM_ Num fromInt (Complex Double)] _N_
+ (+) = { _A_ 2 _U_ 11 _N_ _S_ "U(LL)U(LL)" {_A_ 4 _U_ 1111 _N_ _N_ _N_ _N_} _N_ _N_ },
+ (-) = { _A_ 2 _U_ 11 _N_ _S_ "U(LL)U(LL)" {_A_ 4 _U_ 1111 _N_ _N_ _N_ _N_} _N_ _N_ },
+ (*) = { _A_ 2 _U_ 11 _N_ _S_ "U(LL)U(LL)" {_A_ 4 _U_ 2222 _N_ _N_ _N_ _N_} _N_ _N_ },
+ negate = { _A_ 1 _U_ 1 _N_ _S_ "U(LL)" {_A_ 2 _U_ 11 _N_ _N_ _N_ _N_} _N_ _N_ },
+ abs = { _A_ 1 _U_ 1 _N_ _N_ _N_ _N_ },
+ signum = { _A_ 1 _U_ 1 _N_ _S_ "U(U(P)L)" {_A_ 2 _U_ 22 _N_ _N_ _N_ _N_} _N_ _N_ },
+ fromInteger = { _A_ 1 _U_ 1 _N_ _N_ _N_ _N_ },
+ fromInt = { _A_ 1 _U_ 1 _N_ _N_ _N_ _N_ } #-}
instance Num Double
{-# GHC_PRAGMA _M_ PreludeCore {-dfun-} _A_ 0 _N_ _N_ _N_ _F_ _IF_ARGS_ 0 0 X 11 _!_ _TUP_10 [{{Eq Double}}, {{Text Double}}, (Double -> Double -> Double), (Double -> Double -> Double), (Double -> Double -> Double), (Double -> Double), (Double -> Double), (Double -> Double), (Integer -> Double), (Int -> Double)] [_DFUN_ Eq (Double), _DFUN_ Text (Double), _CONSTM_ Num (+) (Double), _CONSTM_ Num (-) (Double), _CONSTM_ Num (*) (Double), _CONSTM_ Num negate (Double), _CONSTM_ Num abs (Double), _CONSTM_ Num signum (Double), _CONSTM_ Num fromInteger (Double), _CONSTM_ Num fromInt (Double)] _N_
- (+) = _A_ 2 _U_ 11 _N_ _S_ "U(P)U(P)" {_A_ 2 _U_ 22 _N_ _N_ _F_ _IF_ARGS_ 0 2 XX 3 \ (u0 :: Double#) (u1 :: Double#) -> case _#_ plusDouble# [] [u0, u1] of { _PRIM_ (u2 :: Double#) -> _!_ D# [] [u2] } _N_} _F_ _IF_ARGS_ 0 2 CC 5 \ (u0 :: Double) (u1 :: Double) -> case u0 of { _ALG_ D# (u2 :: Double#) -> case u1 of { _ALG_ D# (u3 :: Double#) -> case _#_ plusDouble# [] [u2, u3] of { _PRIM_ (u4 :: Double#) -> _!_ D# [] [u4] }; _NO_DEFLT_ }; _NO_DEFLT_ } _N_,
- (-) = _A_ 2 _U_ 11 _N_ _S_ "U(P)U(P)" {_A_ 2 _U_ 22 _N_ _N_ _F_ _IF_ARGS_ 0 2 XX 3 \ (u0 :: Double#) (u1 :: Double#) -> case _#_ minusDouble# [] [u0, u1] of { _PRIM_ (u2 :: Double#) -> _!_ D# [] [u2] } _N_} _F_ _IF_ARGS_ 0 2 CC 5 \ (u0 :: Double) (u1 :: Double) -> case u0 of { _ALG_ D# (u2 :: Double#) -> case u1 of { _ALG_ D# (u3 :: Double#) -> case _#_ minusDouble# [] [u2, u3] of { _PRIM_ (u4 :: Double#) -> _!_ D# [] [u4] }; _NO_DEFLT_ }; _NO_DEFLT_ } _N_,
- (*) = _A_ 2 _U_ 11 _N_ _S_ "U(P)U(P)" {_A_ 2 _U_ 22 _N_ _N_ _F_ _IF_ARGS_ 0 2 XX 3 \ (u0 :: Double#) (u1 :: Double#) -> case _#_ timesDouble# [] [u0, u1] of { _PRIM_ (u2 :: Double#) -> _!_ D# [] [u2] } _N_} _F_ _IF_ARGS_ 0 2 CC 5 \ (u0 :: Double) (u1 :: Double) -> case u0 of { _ALG_ D# (u2 :: Double#) -> case u1 of { _ALG_ D# (u3 :: Double#) -> case _#_ timesDouble# [] [u2, u3] of { _PRIM_ (u4 :: Double#) -> _!_ D# [] [u4] }; _NO_DEFLT_ }; _NO_DEFLT_ } _N_,
- negate = _A_ 1 _U_ 1 _N_ _S_ "U(P)" {_A_ 1 _U_ 2 _N_ _N_ _F_ _IF_ARGS_ 0 1 X 3 \ (u0 :: Double#) -> case _#_ negateDouble# [] [u0] of { _PRIM_ (u1 :: Double#) -> _!_ D# [] [u1] } _N_} _F_ _IF_ARGS_ 0 1 C 4 \ (u0 :: Double) -> case u0 of { _ALG_ D# (u1 :: Double#) -> case _#_ negateDouble# [] [u1] of { _PRIM_ (u2 :: Double#) -> _!_ D# [] [u2] }; _NO_DEFLT_ } _N_,
- abs = _A_ 1 _U_ 1 _N_ _S_ "U(P)" {_A_ 1 _U_ 2 _N_ _N_ _N_ _N_} _N_ _N_,
- signum = _A_ 1 _U_ 1 _N_ _S_ "U(P)" {_A_ 1 _U_ 2 _N_ _N_ _N_ _N_} _N_ _N_,
- fromInteger = _A_ 1 _U_ 1 _N_ _S_ "U(PPP)" {_A_ 3 _U_ 222 _N_ _N_ _F_ _IF_ARGS_ 0 3 XXX 3 \ (u0 :: Int#) (u1 :: Int#) (u2 :: ByteArray#) -> case _#_ encodeDouble# [] [u0, u1, u2, 0#] of { _PRIM_ (u3 :: Double#) -> _!_ D# [] [u3] } _N_} _F_ _IF_ARGS_ 0 1 C 4 \ (u0 :: Integer) -> case u0 of { _ALG_ J# (u1 :: Int#) (u2 :: Int#) (u3 :: ByteArray#) -> case _#_ encodeDouble# [] [u1, u2, u3, 0#] of { _PRIM_ (u4 :: Double#) -> _!_ D# [] [u4] }; _NO_DEFLT_ } _N_,
- fromInt = _A_ 1 _U_ 1 _N_ _S_ "U(P)" {_A_ 1 _U_ 2 _N_ _N_ _F_ _IF_ARGS_ 0 1 X 3 \ (u0 :: Int#) -> case _#_ int2Double# [] [u0] of { _PRIM_ (u1 :: Double#) -> _!_ D# [] [u1] } _N_} _F_ _IF_ARGS_ 0 1 C 4 \ (u0 :: Int) -> case u0 of { _ALG_ I# (u1 :: Int#) -> case _#_ int2Double# [] [u1] of { _PRIM_ (u2 :: Double#) -> _!_ D# [] [u2] }; _NO_DEFLT_ } _N_ #-}
+ (+) = { _A_ 2 _U_ 11 _N_ _S_ "U(P)U(P)" {_A_ 2 _U_ 22 _N_ _N_ _F_ _IF_ARGS_ 0 2 XX 3 \ (u0 :: Double#) (u1 :: Double#) -> case _#_ plusDouble# [] [u0, u1] of { _PRIM_ (u2 :: Double#) -> _!_ D# [] [u2] } _N_} _F_ _IF_ARGS_ 0 2 CC 5 \ (u0 :: Double) (u1 :: Double) -> case u0 of { _ALG_ D# (u2 :: Double#) -> case u1 of { _ALG_ D# (u3 :: Double#) -> case _#_ plusDouble# [] [u2, u3] of { _PRIM_ (u4 :: Double#) -> _!_ D# [] [u4] }; _NO_DEFLT_ }; _NO_DEFLT_ } _N_ },
+ (-) = { _A_ 2 _U_ 11 _N_ _S_ "U(P)U(P)" {_A_ 2 _U_ 22 _N_ _N_ _F_ _IF_ARGS_ 0 2 XX 3 \ (u0 :: Double#) (u1 :: Double#) -> case _#_ minusDouble# [] [u0, u1] of { _PRIM_ (u2 :: Double#) -> _!_ D# [] [u2] } _N_} _F_ _IF_ARGS_ 0 2 CC 5 \ (u0 :: Double) (u1 :: Double) -> case u0 of { _ALG_ D# (u2 :: Double#) -> case u1 of { _ALG_ D# (u3 :: Double#) -> case _#_ minusDouble# [] [u2, u3] of { _PRIM_ (u4 :: Double#) -> _!_ D# [] [u4] }; _NO_DEFLT_ }; _NO_DEFLT_ } _N_ },
+ (*) = { _A_ 2 _U_ 11 _N_ _S_ "U(P)U(P)" {_A_ 2 _U_ 22 _N_ _N_ _F_ _IF_ARGS_ 0 2 XX 3 \ (u0 :: Double#) (u1 :: Double#) -> case _#_ timesDouble# [] [u0, u1] of { _PRIM_ (u2 :: Double#) -> _!_ D# [] [u2] } _N_} _F_ _IF_ARGS_ 0 2 CC 5 \ (u0 :: Double) (u1 :: Double) -> case u0 of { _ALG_ D# (u2 :: Double#) -> case u1 of { _ALG_ D# (u3 :: Double#) -> case _#_ timesDouble# [] [u2, u3] of { _PRIM_ (u4 :: Double#) -> _!_ D# [] [u4] }; _NO_DEFLT_ }; _NO_DEFLT_ } _N_ },
+ negate = { _A_ 1 _U_ 1 _N_ _S_ "U(P)" {_A_ 1 _U_ 2 _N_ _N_ _F_ _IF_ARGS_ 0 1 X 3 \ (u0 :: Double#) -> case _#_ negateDouble# [] [u0] of { _PRIM_ (u1 :: Double#) -> _!_ D# [] [u1] } _N_} _F_ _IF_ARGS_ 0 1 C 4 \ (u0 :: Double) -> case u0 of { _ALG_ D# (u1 :: Double#) -> case _#_ negateDouble# [] [u1] of { _PRIM_ (u2 :: Double#) -> _!_ D# [] [u2] }; _NO_DEFLT_ } _N_ },
+ abs = { _A_ 1 _U_ 1 _N_ _S_ "U(P)" {_A_ 1 _U_ 2 _N_ _N_ _N_ _N_} _N_ _N_ },
+ signum = { _A_ 1 _U_ 1 _N_ _S_ "U(P)" {_A_ 1 _U_ 2 _N_ _N_ _N_ _N_} _N_ _N_ },
+ fromInteger = { _A_ 1 _U_ 1 _N_ _S_ "U(PPP)" {_A_ 3 _U_ 222 _N_ _N_ _F_ _IF_ARGS_ 0 3 XXX 3 \ (u0 :: Int#) (u1 :: Int#) (u2 :: ByteArray#) -> case _#_ encodeDouble# [] [u0, u1, u2, 0#] of { _PRIM_ (u3 :: Double#) -> _!_ D# [] [u3] } _N_} _F_ _IF_ARGS_ 0 1 C 4 \ (u0 :: Integer) -> case u0 of { _ALG_ J# (u1 :: Int#) (u2 :: Int#) (u3 :: ByteArray#) -> case _#_ encodeDouble# [] [u1, u2, u3, 0#] of { _PRIM_ (u4 :: Double#) -> _!_ D# [] [u4] }; _NO_DEFLT_ } _N_ },
+ fromInt = { _A_ 1 _U_ 1 _N_ _S_ "U(P)" {_A_ 1 _U_ 2 _N_ _N_ _F_ _IF_ARGS_ 0 1 X 3 \ (u0 :: Int#) -> case _#_ int2Double# [] [u0] of { _PRIM_ (u1 :: Double#) -> _!_ D# [] [u1] } _N_} _F_ _IF_ARGS_ 0 1 C 4 \ (u0 :: Int) -> case u0 of { _ALG_ I# (u1 :: Int#) -> case _#_ int2Double# [] [u1] of { _PRIM_ (u2 :: Double#) -> _!_ D# [] [u2] }; _NO_DEFLT_ } _N_ } #-}
instance Num Float
{-# GHC_PRAGMA _M_ PreludeCore {-dfun-} _A_ 0 _N_ _N_ _N_ _F_ _IF_ARGS_ 0 0 X 11 _!_ _TUP_10 [{{Eq Float}}, {{Text Float}}, (Float -> Float -> Float), (Float -> Float -> Float), (Float -> Float -> Float), (Float -> Float), (Float -> Float), (Float -> Float), (Integer -> Float), (Int -> Float)] [_DFUN_ Eq (Float), _DFUN_ Text (Float), _CONSTM_ Num (+) (Float), _CONSTM_ Num (-) (Float), _CONSTM_ Num (*) (Float), _CONSTM_ Num negate (Float), _CONSTM_ Num abs (Float), _CONSTM_ Num signum (Float), _CONSTM_ Num fromInteger (Float), _CONSTM_ Num fromInt (Float)] _N_
- (+) = _A_ 2 _U_ 11 _N_ _S_ "U(P)U(P)" {_A_ 2 _U_ 22 _N_ _N_ _F_ _IF_ARGS_ 0 2 XX 3 \ (u0 :: Float#) (u1 :: Float#) -> case _#_ plusFloat# [] [u0, u1] of { _PRIM_ (u2 :: Float#) -> _!_ F# [] [u2] } _N_} _F_ _IF_ARGS_ 0 2 CC 5 \ (u0 :: Float) (u1 :: Float) -> case u0 of { _ALG_ F# (u2 :: Float#) -> case u1 of { _ALG_ F# (u3 :: Float#) -> case _#_ plusFloat# [] [u2, u3] of { _PRIM_ (u4 :: Float#) -> _!_ F# [] [u4] }; _NO_DEFLT_ }; _NO_DEFLT_ } _N_,
- (-) = _A_ 2 _U_ 11 _N_ _S_ "U(P)U(P)" {_A_ 2 _U_ 22 _N_ _N_ _F_ _IF_ARGS_ 0 2 XX 3 \ (u0 :: Float#) (u1 :: Float#) -> case _#_ minusFloat# [] [u0, u1] of { _PRIM_ (u2 :: Float#) -> _!_ F# [] [u2] } _N_} _F_ _IF_ARGS_ 0 2 CC 5 \ (u0 :: Float) (u1 :: Float) -> case u0 of { _ALG_ F# (u2 :: Float#) -> case u1 of { _ALG_ F# (u3 :: Float#) -> case _#_ minusFloat# [] [u2, u3] of { _PRIM_ (u4 :: Float#) -> _!_ F# [] [u4] }; _NO_DEFLT_ }; _NO_DEFLT_ } _N_,
- (*) = _A_ 2 _U_ 11 _N_ _S_ "U(P)U(P)" {_A_ 2 _U_ 22 _N_ _N_ _F_ _IF_ARGS_ 0 2 XX 3 \ (u0 :: Float#) (u1 :: Float#) -> case _#_ timesFloat# [] [u0, u1] of { _PRIM_ (u2 :: Float#) -> _!_ F# [] [u2] } _N_} _F_ _IF_ARGS_ 0 2 CC 5 \ (u0 :: Float) (u1 :: Float) -> case u0 of { _ALG_ F# (u2 :: Float#) -> case u1 of { _ALG_ F# (u3 :: Float#) -> case _#_ timesFloat# [] [u2, u3] of { _PRIM_ (u4 :: Float#) -> _!_ F# [] [u4] }; _NO_DEFLT_ }; _NO_DEFLT_ } _N_,
- negate = _A_ 1 _U_ 1 _N_ _S_ "U(P)" {_A_ 1 _U_ 2 _N_ _N_ _F_ _IF_ARGS_ 0 1 X 3 \ (u0 :: Float#) -> case _#_ negateFloat# [] [u0] of { _PRIM_ (u1 :: Float#) -> _!_ F# [] [u1] } _N_} _F_ _IF_ARGS_ 0 1 C 4 \ (u0 :: Float) -> case u0 of { _ALG_ F# (u1 :: Float#) -> case _#_ negateFloat# [] [u1] of { _PRIM_ (u2 :: Float#) -> _!_ F# [] [u2] }; _NO_DEFLT_ } _N_,
- abs = _A_ 1 _U_ 1 _N_ _S_ "U(P)" {_A_ 1 _U_ 2 _N_ _N_ _N_ _N_} _N_ _N_,
- signum = _A_ 1 _U_ 1 _N_ _S_ "U(P)" {_A_ 1 _U_ 2 _N_ _N_ _N_ _N_} _N_ _N_,
- fromInteger = _A_ 1 _U_ 1 _N_ _S_ "U(PPP)" {_A_ 3 _U_ 222 _N_ _N_ _F_ _IF_ARGS_ 0 3 XXX 3 \ (u0 :: Int#) (u1 :: Int#) (u2 :: ByteArray#) -> case _#_ encodeFloat# [] [u0, u1, u2, 0#] of { _PRIM_ (u3 :: Float#) -> _!_ F# [] [u3] } _N_} _F_ _IF_ARGS_ 0 1 C 4 \ (u0 :: Integer) -> case u0 of { _ALG_ J# (u1 :: Int#) (u2 :: Int#) (u3 :: ByteArray#) -> case _#_ encodeFloat# [] [u1, u2, u3, 0#] of { _PRIM_ (u4 :: Float#) -> _!_ F# [] [u4] }; _NO_DEFLT_ } _N_,
- fromInt = _A_ 1 _U_ 1 _N_ _S_ "U(P)" {_A_ 1 _U_ 2 _N_ _N_ _F_ _IF_ARGS_ 0 1 X 3 \ (u0 :: Int#) -> case _#_ int2Float# [] [u0] of { _PRIM_ (u1 :: Float#) -> _!_ F# [] [u1] } _N_} _F_ _IF_ARGS_ 0 1 C 4 \ (u0 :: Int) -> case u0 of { _ALG_ I# (u1 :: Int#) -> case _#_ int2Float# [] [u1] of { _PRIM_ (u2 :: Float#) -> _!_ F# [] [u2] }; _NO_DEFLT_ } _N_ #-}
+ (+) = { _A_ 2 _U_ 11 _N_ _S_ "U(P)U(P)" {_A_ 2 _U_ 22 _N_ _N_ _F_ _IF_ARGS_ 0 2 XX 3 \ (u0 :: Float#) (u1 :: Float#) -> case _#_ plusFloat# [] [u0, u1] of { _PRIM_ (u2 :: Float#) -> _!_ F# [] [u2] } _N_} _F_ _IF_ARGS_ 0 2 CC 5 \ (u0 :: Float) (u1 :: Float) -> case u0 of { _ALG_ F# (u2 :: Float#) -> case u1 of { _ALG_ F# (u3 :: Float#) -> case _#_ plusFloat# [] [u2, u3] of { _PRIM_ (u4 :: Float#) -> _!_ F# [] [u4] }; _NO_DEFLT_ }; _NO_DEFLT_ } _N_ },
+ (-) = { _A_ 2 _U_ 11 _N_ _S_ "U(P)U(P)" {_A_ 2 _U_ 22 _N_ _N_ _F_ _IF_ARGS_ 0 2 XX 3 \ (u0 :: Float#) (u1 :: Float#) -> case _#_ minusFloat# [] [u0, u1] of { _PRIM_ (u2 :: Float#) -> _!_ F# [] [u2] } _N_} _F_ _IF_ARGS_ 0 2 CC 5 \ (u0 :: Float) (u1 :: Float) -> case u0 of { _ALG_ F# (u2 :: Float#) -> case u1 of { _ALG_ F# (u3 :: Float#) -> case _#_ minusFloat# [] [u2, u3] of { _PRIM_ (u4 :: Float#) -> _!_ F# [] [u4] }; _NO_DEFLT_ }; _NO_DEFLT_ } _N_ },
+ (*) = { _A_ 2 _U_ 11 _N_ _S_ "U(P)U(P)" {_A_ 2 _U_ 22 _N_ _N_ _F_ _IF_ARGS_ 0 2 XX 3 \ (u0 :: Float#) (u1 :: Float#) -> case _#_ timesFloat# [] [u0, u1] of { _PRIM_ (u2 :: Float#) -> _!_ F# [] [u2] } _N_} _F_ _IF_ARGS_ 0 2 CC 5 \ (u0 :: Float) (u1 :: Float) -> case u0 of { _ALG_ F# (u2 :: Float#) -> case u1 of { _ALG_ F# (u3 :: Float#) -> case _#_ timesFloat# [] [u2, u3] of { _PRIM_ (u4 :: Float#) -> _!_ F# [] [u4] }; _NO_DEFLT_ }; _NO_DEFLT_ } _N_ },
+ negate = { _A_ 1 _U_ 1 _N_ _S_ "U(P)" {_A_ 1 _U_ 2 _N_ _N_ _F_ _IF_ARGS_ 0 1 X 3 \ (u0 :: Float#) -> case _#_ negateFloat# [] [u0] of { _PRIM_ (u1 :: Float#) -> _!_ F# [] [u1] } _N_} _F_ _IF_ARGS_ 0 1 C 4 \ (u0 :: Float) -> case u0 of { _ALG_ F# (u1 :: Float#) -> case _#_ negateFloat# [] [u1] of { _PRIM_ (u2 :: Float#) -> _!_ F# [] [u2] }; _NO_DEFLT_ } _N_ },
+ abs = { _A_ 1 _U_ 1 _N_ _S_ "U(P)" {_A_ 1 _U_ 2 _N_ _N_ _N_ _N_} _N_ _N_ },
+ signum = { _A_ 1 _U_ 1 _N_ _S_ "U(P)" {_A_ 1 _U_ 2 _N_ _N_ _N_ _N_} _N_ _N_ },
+ fromInteger = { _A_ 1 _U_ 1 _N_ _S_ "U(PPP)" {_A_ 3 _U_ 222 _N_ _N_ _F_ _IF_ARGS_ 0 3 XXX 3 \ (u0 :: Int#) (u1 :: Int#) (u2 :: ByteArray#) -> case _#_ encodeFloat# [] [u0, u1, u2, 0#] of { _PRIM_ (u3 :: Float#) -> _!_ F# [] [u3] } _N_} _F_ _IF_ARGS_ 0 1 C 4 \ (u0 :: Integer) -> case u0 of { _ALG_ J# (u1 :: Int#) (u2 :: Int#) (u3 :: ByteArray#) -> case _#_ encodeFloat# [] [u1, u2, u3, 0#] of { _PRIM_ (u4 :: Float#) -> _!_ F# [] [u4] }; _NO_DEFLT_ } _N_ },
+ fromInt = { _A_ 1 _U_ 1 _N_ _S_ "U(P)" {_A_ 1 _U_ 2 _N_ _N_ _F_ _IF_ARGS_ 0 1 X 3 \ (u0 :: Int#) -> case _#_ int2Float# [] [u0] of { _PRIM_ (u1 :: Float#) -> _!_ F# [] [u1] } _N_} _F_ _IF_ARGS_ 0 1 C 4 \ (u0 :: Int) -> case u0 of { _ALG_ I# (u1 :: Int#) -> case _#_ int2Float# [] [u1] of { _PRIM_ (u2 :: Float#) -> _!_ F# [] [u2] }; _NO_DEFLT_ } _N_ } #-}
instance Num Int
{-# GHC_PRAGMA _M_ PreludeCore {-dfun-} _A_ 0 _N_ _N_ _N_ _F_ _IF_ARGS_ 0 0 X 11 _!_ _TUP_10 [{{Eq Int}}, {{Text Int}}, (Int -> Int -> Int), (Int -> Int -> Int), (Int -> Int -> Int), (Int -> Int), (Int -> Int), (Int -> Int), (Integer -> Int), (Int -> Int)] [_DFUN_ Eq (Int), _DFUN_ Text (Int), _CONSTM_ Num (+) (Int), _CONSTM_ Num (-) (Int), _CONSTM_ Num (*) (Int), _CONSTM_ Num negate (Int), _CONSTM_ Num abs (Int), _CONSTM_ Num signum (Int), _CONSTM_ Num fromInteger (Int), _CONSTM_ Num fromInt (Int)] _N_
- (+) = _A_ 2 _U_ 11 _N_ _S_ "U(P)U(P)" {_A_ 2 _U_ 22 _N_ _N_ _F_ _IF_ARGS_ 0 2 XX 3 \ (u0 :: Int#) (u1 :: Int#) -> case _#_ plusInt# [] [u0, u1] of { _PRIM_ (u2 :: Int#) -> _!_ I# [] [u2] } _N_} _F_ _IF_ARGS_ 0 2 CC 5 \ (u0 :: Int) (u1 :: Int) -> case u0 of { _ALG_ I# (u2 :: Int#) -> case u1 of { _ALG_ I# (u3 :: Int#) -> case _#_ plusInt# [] [u2, u3] of { _PRIM_ (u4 :: Int#) -> _!_ I# [] [u4] }; _NO_DEFLT_ }; _NO_DEFLT_ } _N_,
- (-) = _A_ 2 _U_ 11 _N_ _S_ "U(P)U(P)" {_A_ 2 _U_ 22 _N_ _N_ _F_ _IF_ARGS_ 0 2 XX 3 \ (u0 :: Int#) (u1 :: Int#) -> case _#_ minusInt# [] [u0, u1] of { _PRIM_ (u2 :: Int#) -> _!_ I# [] [u2] } _N_} _F_ _IF_ARGS_ 0 2 CC 5 \ (u0 :: Int) (u1 :: Int) -> case u0 of { _ALG_ I# (u2 :: Int#) -> case u1 of { _ALG_ I# (u3 :: Int#) -> case _#_ minusInt# [] [u2, u3] of { _PRIM_ (u4 :: Int#) -> _!_ I# [] [u4] }; _NO_DEFLT_ }; _NO_DEFLT_ } _N_,
- (*) = _A_ 2 _U_ 11 _N_ _S_ "U(P)U(P)" {_A_ 2 _U_ 22 _N_ _N_ _F_ _IF_ARGS_ 0 2 XX 3 \ (u0 :: Int#) (u1 :: Int#) -> case _#_ timesInt# [] [u0, u1] of { _PRIM_ (u2 :: Int#) -> _!_ I# [] [u2] } _N_} _F_ _IF_ARGS_ 0 2 CC 5 \ (u0 :: Int) (u1 :: Int) -> case u0 of { _ALG_ I# (u2 :: Int#) -> case u1 of { _ALG_ I# (u3 :: Int#) -> case _#_ timesInt# [] [u2, u3] of { _PRIM_ (u4 :: Int#) -> _!_ I# [] [u4] }; _NO_DEFLT_ }; _NO_DEFLT_ } _N_,
- negate = _A_ 1 _U_ 1 _N_ _S_ "U(P)" {_A_ 1 _U_ 2 _N_ _N_ _F_ _IF_ARGS_ 0 1 X 3 \ (u0 :: Int#) -> case _#_ negateInt# [] [u0] of { _PRIM_ (u1 :: Int#) -> _!_ I# [] [u1] } _N_} _F_ _IF_ARGS_ 0 1 C 4 \ (u0 :: Int) -> case u0 of { _ALG_ I# (u1 :: Int#) -> case _#_ negateInt# [] [u1] of { _PRIM_ (u2 :: Int#) -> _!_ I# [] [u2] }; _NO_DEFLT_ } _N_,
- abs = _A_ 1 _U_ 1 _N_ _S_ "U(P)" {_A_ 1 _U_ 2 _N_ _N_ _N_ _N_} _N_ _N_,
- signum = _A_ 1 _U_ 1 _N_ _S_ "U(P)" {_A_ 1 _U_ 2 _N_ _N_ _N_ _N_} _N_ _N_,
- fromInteger = _A_ 1 _U_ 1 _N_ _S_ "U(PPP)" {_A_ 3 _U_ 222 _N_ _N_ _F_ _IF_ARGS_ 0 3 XXX 3 \ (u0 :: Int#) (u1 :: Int#) (u2 :: ByteArray#) -> case _#_ integer2Int# [] [u0, u1, u2] of { _PRIM_ (u3 :: Int#) -> _!_ I# [] [u3] } _N_} _F_ _IF_ARGS_ 0 1 C 4 \ (u0 :: Integer) -> case u0 of { _ALG_ J# (u1 :: Int#) (u2 :: Int#) (u3 :: ByteArray#) -> case _#_ integer2Int# [] [u1, u2, u3] of { _PRIM_ (u4 :: Int#) -> _!_ I# [] [u4] }; _NO_DEFLT_ } _N_,
- fromInt = _A_ 1 _U_ 1 _N_ _S_ "U(P)" {_A_ 1 _U_ 2 _N_ _N_ _F_ _IF_ARGS_ 0 1 X 2 \ (u0 :: Int#) -> _!_ I# [] [u0] _N_} _F_ _IF_ARGS_ 0 1 X 1 \ (u0 :: Int) -> u0 _N_ #-}
+ (+) = { _A_ 2 _U_ 11 _N_ _S_ "U(P)U(P)" {_A_ 2 _U_ 22 _N_ _N_ _F_ _IF_ARGS_ 0 2 XX 3 \ (u0 :: Int#) (u1 :: Int#) -> case _#_ plusInt# [] [u0, u1] of { _PRIM_ (u2 :: Int#) -> _!_ I# [] [u2] } _N_} _F_ _IF_ARGS_ 0 2 CC 5 \ (u0 :: Int) (u1 :: Int) -> case u0 of { _ALG_ I# (u2 :: Int#) -> case u1 of { _ALG_ I# (u3 :: Int#) -> case _#_ plusInt# [] [u2, u3] of { _PRIM_ (u4 :: Int#) -> _!_ I# [] [u4] }; _NO_DEFLT_ }; _NO_DEFLT_ } _N_ },
+ (-) = { _A_ 2 _U_ 11 _N_ _S_ "U(P)U(P)" {_A_ 2 _U_ 22 _N_ _N_ _F_ _IF_ARGS_ 0 2 XX 3 \ (u0 :: Int#) (u1 :: Int#) -> case _#_ minusInt# [] [u0, u1] of { _PRIM_ (u2 :: Int#) -> _!_ I# [] [u2] } _N_} _F_ _IF_ARGS_ 0 2 CC 5 \ (u0 :: Int) (u1 :: Int) -> case u0 of { _ALG_ I# (u2 :: Int#) -> case u1 of { _ALG_ I# (u3 :: Int#) -> case _#_ minusInt# [] [u2, u3] of { _PRIM_ (u4 :: Int#) -> _!_ I# [] [u4] }; _NO_DEFLT_ }; _NO_DEFLT_ } _N_ },
+ (*) = { _A_ 2 _U_ 11 _N_ _S_ "U(P)U(P)" {_A_ 2 _U_ 22 _N_ _N_ _F_ _IF_ARGS_ 0 2 XX 3 \ (u0 :: Int#) (u1 :: Int#) -> case _#_ timesInt# [] [u0, u1] of { _PRIM_ (u2 :: Int#) -> _!_ I# [] [u2] } _N_} _F_ _IF_ARGS_ 0 2 CC 5 \ (u0 :: Int) (u1 :: Int) -> case u0 of { _ALG_ I# (u2 :: Int#) -> case u1 of { _ALG_ I# (u3 :: Int#) -> case _#_ timesInt# [] [u2, u3] of { _PRIM_ (u4 :: Int#) -> _!_ I# [] [u4] }; _NO_DEFLT_ }; _NO_DEFLT_ } _N_ },
+ negate = { _A_ 1 _U_ 1 _N_ _S_ "U(P)" {_A_ 1 _U_ 2 _N_ _N_ _F_ _IF_ARGS_ 0 1 X 3 \ (u0 :: Int#) -> case _#_ negateInt# [] [u0] of { _PRIM_ (u1 :: Int#) -> _!_ I# [] [u1] } _N_} _F_ _IF_ARGS_ 0 1 C 4 \ (u0 :: Int) -> case u0 of { _ALG_ I# (u1 :: Int#) -> case _#_ negateInt# [] [u1] of { _PRIM_ (u2 :: Int#) -> _!_ I# [] [u2] }; _NO_DEFLT_ } _N_ },
+ abs = { _A_ 1 _U_ 1 _N_ _S_ "U(P)" {_A_ 1 _U_ 2 _N_ _N_ _N_ _N_} _N_ _N_ },
+ signum = { _A_ 1 _U_ 1 _N_ _S_ "U(P)" {_A_ 1 _U_ 2 _N_ _N_ _N_ _N_} _N_ _N_ },
+ fromInteger = { _A_ 1 _U_ 1 _N_ _S_ "U(PPP)" {_A_ 3 _U_ 222 _N_ _N_ _F_ _IF_ARGS_ 0 3 XXX 3 \ (u0 :: Int#) (u1 :: Int#) (u2 :: ByteArray#) -> case _#_ integer2Int# [] [u0, u1, u2] of { _PRIM_ (u3 :: Int#) -> _!_ I# [] [u3] } _N_} _F_ _IF_ARGS_ 0 1 C 4 \ (u0 :: Integer) -> case u0 of { _ALG_ J# (u1 :: Int#) (u2 :: Int#) (u3 :: ByteArray#) -> case _#_ integer2Int# [] [u1, u2, u3] of { _PRIM_ (u4 :: Int#) -> _!_ I# [] [u4] }; _NO_DEFLT_ } _N_ },
+ fromInt = { _A_ 1 _U_ 1 _N_ _S_ "U(P)" {_A_ 1 _U_ 2 _N_ _N_ _F_ _IF_ARGS_ 0 1 X 2 \ (u0 :: Int#) -> _!_ I# [] [u0] _N_} _F_ _IF_ARGS_ 0 1 X 1 \ (u0 :: Int) -> u0 _N_ } #-}
instance Num Integer
{-# GHC_PRAGMA _M_ PreludeCore {-dfun-} _A_ 0 _N_ _N_ _N_ _F_ _IF_ARGS_ 0 0 X 11 _!_ _TUP_10 [{{Eq Integer}}, {{Text Integer}}, (Integer -> Integer -> Integer), (Integer -> Integer -> Integer), (Integer -> Integer -> Integer), (Integer -> Integer), (Integer -> Integer), (Integer -> Integer), (Integer -> Integer), (Int -> Integer)] [_DFUN_ Eq (Integer), _DFUN_ Text (Integer), _CONSTM_ Num (+) (Integer), _CONSTM_ Num (-) (Integer), _CONSTM_ Num (*) (Integer), _CONSTM_ Num negate (Integer), _CONSTM_ Num abs (Integer), _CONSTM_ Num signum (Integer), _CONSTM_ Num fromInteger (Integer), _CONSTM_ Num fromInt (Integer)] _N_
- (+) = _A_ 2 _U_ 11 _N_ _S_ "U(PPP)U(PPP)" {_A_ 4 _U_ 2221 _N_ _N_ _F_ _IF_ARGS_ 0 4 XXXC 5 \ (u0 :: Int#) (u1 :: Int#) (u2 :: ByteArray#) (u3 :: Integer) -> case u3 of { _ALG_ J# (u4 :: Int#) (u5 :: Int#) (u6 :: ByteArray#) -> _#_ plusInteger# [] [u0, u1, u2, u4, u5, u6]; _NO_DEFLT_ } _N_} _F_ _IF_ARGS_ 0 2 CC 6 \ (u0 :: Integer) (u1 :: Integer) -> case u0 of { _ALG_ J# (u2 :: Int#) (u3 :: Int#) (u4 :: ByteArray#) -> case u1 of { _ALG_ J# (u5 :: Int#) (u6 :: Int#) (u7 :: ByteArray#) -> _#_ plusInteger# [] [u2, u3, u4, u5, u6, u7]; _NO_DEFLT_ }; _NO_DEFLT_ } _N_,
- (-) = _A_ 2 _U_ 11 _N_ _S_ "U(PPP)U(PPP)" {_A_ 4 _U_ 2221 _N_ _N_ _F_ _IF_ARGS_ 0 4 XXXC 5 \ (u0 :: Int#) (u1 :: Int#) (u2 :: ByteArray#) (u3 :: Integer) -> case u3 of { _ALG_ J# (u4 :: Int#) (u5 :: Int#) (u6 :: ByteArray#) -> _#_ minusInteger# [] [u0, u1, u2, u4, u5, u6]; _NO_DEFLT_ } _N_} _F_ _IF_ARGS_ 0 2 CC 6 \ (u0 :: Integer) (u1 :: Integer) -> case u0 of { _ALG_ J# (u2 :: Int#) (u3 :: Int#) (u4 :: ByteArray#) -> case u1 of { _ALG_ J# (u5 :: Int#) (u6 :: Int#) (u7 :: ByteArray#) -> _#_ minusInteger# [] [u2, u3, u4, u5, u6, u7]; _NO_DEFLT_ }; _NO_DEFLT_ } _N_,
- (*) = _A_ 2 _U_ 11 _N_ _S_ "U(PPP)U(PPP)" {_A_ 4 _U_ 2221 _N_ _N_ _F_ _IF_ARGS_ 0 4 XXXC 5 \ (u0 :: Int#) (u1 :: Int#) (u2 :: ByteArray#) (u3 :: Integer) -> case u3 of { _ALG_ J# (u4 :: Int#) (u5 :: Int#) (u6 :: ByteArray#) -> _#_ timesInteger# [] [u0, u1, u2, u4, u5, u6]; _NO_DEFLT_ } _N_} _F_ _IF_ARGS_ 0 2 CC 6 \ (u0 :: Integer) (u1 :: Integer) -> case u0 of { _ALG_ J# (u2 :: Int#) (u3 :: Int#) (u4 :: ByteArray#) -> case u1 of { _ALG_ J# (u5 :: Int#) (u6 :: Int#) (u7 :: ByteArray#) -> _#_ timesInteger# [] [u2, u3, u4, u5, u6, u7]; _NO_DEFLT_ }; _NO_DEFLT_ } _N_,
- negate = _A_ 1 _U_ 1 _N_ _S_ "U(PPP)" {_A_ 3 _U_ 222 _N_ _N_ _F_ _IF_ARGS_ 0 3 XXX 4 \ (u0 :: Int#) (u1 :: Int#) (u2 :: ByteArray#) -> _#_ negateInteger# [] [u0, u1, u2] _N_} _F_ _IF_ARGS_ 0 1 C 5 \ (u0 :: Integer) -> case u0 of { _ALG_ J# (u1 :: Int#) (u2 :: Int#) (u3 :: ByteArray#) -> _#_ negateInteger# [] [u1, u2, u3]; _NO_DEFLT_ } _N_,
- abs = _A_ 1 _U_ 1 _N_ _S_ "U(PPP)" {_A_ 3 _U_ 222 _N_ _N_ _N_ _N_} _N_ _N_,
- signum = _A_ 1 _U_ 1 _N_ _S_ "U(PPP)" {_A_ 3 _U_ 222 _N_ _N_ _N_ _N_} _N_ _N_,
- fromInteger = _A_ 1 _U_ 1 _N_ _S_ "U(PPP)" {_A_ 3 _U_ 222 _N_ _N_ _F_ _IF_ARGS_ 0 3 XXX 4 \ (u0 :: Int#) (u1 :: Int#) (u2 :: ByteArray#) -> _!_ J# [] [u0, u1, u2] _N_} _F_ _IF_ARGS_ 0 1 X 1 \ (u0 :: Integer) -> u0 _N_,
- fromInt = _A_ 1 _U_ 1 _N_ _S_ "U(P)" {_A_ 1 _U_ 2 _N_ _N_ _F_ _IF_ARGS_ 0 1 X 1 \ (u0 :: Int#) -> _#_ int2Integer# [] [u0] _N_} _F_ _IF_ARGS_ 0 1 C 2 \ (u0 :: Int) -> case u0 of { _ALG_ I# (u1 :: Int#) -> _#_ int2Integer# [] [u1]; _NO_DEFLT_ } _N_ #-}
+ (+) = { _A_ 2 _U_ 11 _N_ _S_ "U(PPP)U(PPP)" {_A_ 4 _U_ 2221 _N_ _N_ _F_ _IF_ARGS_ 0 4 XXXC 5 \ (u0 :: Int#) (u1 :: Int#) (u2 :: ByteArray#) (u3 :: Integer) -> case u3 of { _ALG_ J# (u4 :: Int#) (u5 :: Int#) (u6 :: ByteArray#) -> _#_ plusInteger# [] [u0, u1, u2, u4, u5, u6]; _NO_DEFLT_ } _N_} _F_ _IF_ARGS_ 0 2 CC 6 \ (u0 :: Integer) (u1 :: Integer) -> case u0 of { _ALG_ J# (u2 :: Int#) (u3 :: Int#) (u4 :: ByteArray#) -> case u1 of { _ALG_ J# (u5 :: Int#) (u6 :: Int#) (u7 :: ByteArray#) -> _#_ plusInteger# [] [u2, u3, u4, u5, u6, u7]; _NO_DEFLT_ }; _NO_DEFLT_ } _N_ },
+ (-) = { _A_ 2 _U_ 11 _N_ _S_ "U(PPP)U(PPP)" {_A_ 4 _U_ 2221 _N_ _N_ _F_ _IF_ARGS_ 0 4 XXXC 5 \ (u0 :: Int#) (u1 :: Int#) (u2 :: ByteArray#) (u3 :: Integer) -> case u3 of { _ALG_ J# (u4 :: Int#) (u5 :: Int#) (u6 :: ByteArray#) -> _#_ minusInteger# [] [u0, u1, u2, u4, u5, u6]; _NO_DEFLT_ } _N_} _F_ _IF_ARGS_ 0 2 CC 6 \ (u0 :: Integer) (u1 :: Integer) -> case u0 of { _ALG_ J# (u2 :: Int#) (u3 :: Int#) (u4 :: ByteArray#) -> case u1 of { _ALG_ J# (u5 :: Int#) (u6 :: Int#) (u7 :: ByteArray#) -> _#_ minusInteger# [] [u2, u3, u4, u5, u6, u7]; _NO_DEFLT_ }; _NO_DEFLT_ } _N_ },
+ (*) = { _A_ 2 _U_ 11 _N_ _S_ "U(PPP)U(PPP)" {_A_ 4 _U_ 2221 _N_ _N_ _F_ _IF_ARGS_ 0 4 XXXC 5 \ (u0 :: Int#) (u1 :: Int#) (u2 :: ByteArray#) (u3 :: Integer) -> case u3 of { _ALG_ J# (u4 :: Int#) (u5 :: Int#) (u6 :: ByteArray#) -> _#_ timesInteger# [] [u0, u1, u2, u4, u5, u6]; _NO_DEFLT_ } _N_} _F_ _IF_ARGS_ 0 2 CC 6 \ (u0 :: Integer) (u1 :: Integer) -> case u0 of { _ALG_ J# (u2 :: Int#) (u3 :: Int#) (u4 :: ByteArray#) -> case u1 of { _ALG_ J# (u5 :: Int#) (u6 :: Int#) (u7 :: ByteArray#) -> _#_ timesInteger# [] [u2, u3, u4, u5, u6, u7]; _NO_DEFLT_ }; _NO_DEFLT_ } _N_ },
+ negate = { _A_ 1 _U_ 1 _N_ _S_ "U(PPP)" {_A_ 3 _U_ 222 _N_ _N_ _F_ _IF_ARGS_ 0 3 XXX 4 \ (u0 :: Int#) (u1 :: Int#) (u2 :: ByteArray#) -> _#_ negateInteger# [] [u0, u1, u2] _N_} _F_ _IF_ARGS_ 0 1 C 5 \ (u0 :: Integer) -> case u0 of { _ALG_ J# (u1 :: Int#) (u2 :: Int#) (u3 :: ByteArray#) -> _#_ negateInteger# [] [u1, u2, u3]; _NO_DEFLT_ } _N_ },
+ abs = { _A_ 1 _U_ 1 _N_ _S_ "U(PPP)" {_A_ 3 _U_ 222 _N_ _N_ _N_ _N_} _N_ _N_ },
+ signum = { _A_ 1 _U_ 1 _N_ _S_ "U(PPP)" {_A_ 3 _U_ 222 _N_ _N_ _N_ _N_} _N_ _N_ },
+ fromInteger = { _A_ 1 _U_ 1 _N_ _S_ "U(PPP)" {_A_ 3 _U_ 222 _N_ _N_ _F_ _IF_ARGS_ 0 3 XXX 4 \ (u0 :: Int#) (u1 :: Int#) (u2 :: ByteArray#) -> _!_ J# [] [u0, u1, u2] _N_} _F_ _IF_ARGS_ 0 1 X 1 \ (u0 :: Integer) -> u0 _N_ },
+ fromInt = { _A_ 1 _U_ 1 _N_ _S_ "U(P)" {_A_ 1 _U_ 2 _N_ _N_ _F_ _IF_ARGS_ 0 1 X 1 \ (u0 :: Int#) -> _#_ int2Integer# [] [u0] _N_} _F_ _IF_ARGS_ 0 1 C 2 \ (u0 :: Int) -> case u0 of { _ALG_ I# (u1 :: Int#) -> _#_ int2Integer# [] [u1]; _NO_DEFLT_ } _N_ } #-}
instance Integral a => Num (Ratio a)
{-# GHC_PRAGMA _M_ PreludeRatio {-dfun-} _A_ 3 _U_ 222 _N_ _N_ _N_ _N_ #-}
instance Num (Ratio Integer)
{-# GHC_PRAGMA _M_ PreludeRatio {-dfun-} _A_ 0 _N_ _N_ _N_ _F_ _IF_ARGS_ 0 0 X 11 _!_ _TUP_10 [{{Eq (Ratio Integer)}}, {{Text (Ratio Integer)}}, (Ratio Integer -> Ratio Integer -> Ratio Integer), (Ratio Integer -> Ratio Integer -> Ratio Integer), (Ratio Integer -> Ratio Integer -> Ratio Integer), (Ratio Integer -> Ratio Integer), (Ratio Integer -> Ratio Integer), (Ratio Integer -> Ratio Integer), (Integer -> Ratio Integer), (Int -> Ratio Integer)] [_DFUN_ Eq (Ratio Integer), _DFUN_ Text (Ratio Integer), _CONSTM_ Num (+) (Ratio Integer), _CONSTM_ Num (-) (Ratio Integer), _CONSTM_ Num (*) (Ratio Integer), _CONSTM_ Num negate (Ratio Integer), _CONSTM_ Num abs (Ratio Integer), _CONSTM_ Num signum (Ratio Integer), _CONSTM_ Num fromInteger (Ratio Integer), _CONSTM_ Num fromInt (Ratio Integer)] _N_
- (+) = _A_ 2 _U_ 11 _N_ _S_ "U(LU(PPP))U(LU(PPP))" {_A_ 5 _U_ 12221 _N_ _N_ _N_ _N_} _N_ _N_,
- (-) = _A_ 2 _U_ 11 _N_ _S_ "U(LU(PPP))U(LU(PPP))" {_A_ 5 _U_ 12221 _N_ _N_ _N_ _N_} _N_ _N_,
- (*) = _A_ 2 _U_ 11 _N_ _S_ "U(LU(PPP))U(LU(PPP))" {_A_ 5 _U_ 22221 _N_ _N_ _N_ _N_} _N_ _N_,
- negate = _A_ 1 _U_ 1 _N_ _S_ "U(LL)" {_A_ 2 _U_ 22 _N_ _N_ _N_ _N_} _N_ _N_,
- abs = _A_ 1 _U_ 1 _N_ _S_ "U(LL)" {_A_ 2 _U_ 12 _N_ _N_ _N_ _N_} _N_ _N_,
- signum = _A_ 1 _U_ 1 _N_ _S_ "U(LA)" {_A_ 1 _U_ 1 _N_ _N_ _N_ _N_} _N_ _N_,
- fromInteger = _A_ 1 _U_ 2 _N_ _N_ _N_ _N_,
- fromInt = _A_ 1 _U_ 1 _N_ _N_ _N_ _N_ #-}
+ (+) = { _A_ 2 _U_ 11 _N_ _S_ "U(LU(PPP))U(LU(PPP))" {_A_ 5 _U_ 12221 _N_ _N_ _N_ _N_} _N_ _N_ },
+ (-) = { _A_ 2 _U_ 11 _N_ _S_ "U(LU(PPP))U(LU(PPP))" {_A_ 5 _U_ 12221 _N_ _N_ _N_ _N_} _N_ _N_ },
+ (*) = { _A_ 2 _U_ 11 _N_ _S_ "U(LU(PPP))U(LU(PPP))" {_A_ 5 _U_ 22221 _N_ _N_ _N_ _N_} _N_ _N_ },
+ negate = { _A_ 1 _U_ 1 _N_ _S_ "U(LL)" {_A_ 2 _U_ 22 _N_ _N_ _N_ _N_} _N_ _N_ },
+ abs = { _A_ 1 _U_ 1 _N_ _S_ "U(LL)" {_A_ 2 _U_ 12 _N_ _N_ _N_ _N_} _N_ _N_ },
+ signum = { _A_ 1 _U_ 1 _N_ _S_ "U(LA)" {_A_ 1 _U_ 1 _N_ _N_ _N_ _N_} _N_ _N_ },
+ fromInteger = { _A_ 1 _U_ 2 _N_ _N_ _F_ _IF_ARGS_ 0 1 X 3 \ (u0 :: Integer) -> _!_ (:%) [Integer] [u0, _SPEC_ _ORIG_ PreludeCore __i1 [ (Integer) ]] _N_ },
+ fromInt = { _A_ 1 _U_ 1 _N_ _N_ _N_ _N_ } #-}
instance Ord ()
{-# GHC_PRAGMA _M_ PreludeBuiltin {-dfun-} _A_ 0 _N_ _N_ _N_ _F_ _IF_ARGS_ 0 0 X 9 _!_ _TUP_8 [{{Eq ()}}, (() -> () -> Bool), (() -> () -> Bool), (() -> () -> Bool), (() -> () -> Bool), (() -> () -> ()), (() -> () -> ()), (() -> () -> _CMP_TAG)] [_DFUN_ Eq (()), _CONSTM_ Ord (<) (()), _CONSTM_ Ord (<=) (()), _CONSTM_ Ord (>=) (()), _CONSTM_ Ord (>) (()), _CONSTM_ Ord max (()), _CONSTM_ Ord min (()), _CONSTM_ Ord _tagCmp (())] _N_
- (<) = _A_ 2 _U_ 11 _N_ _S_ "EE" _F_ _IF_ARGS_ 0 2 CC 3 \ (u0 :: ()) (u1 :: ()) -> case u0 of { _ALG_ _TUP_0 -> case u1 of { _ALG_ _TUP_0 -> _!_ False [] []; _NO_DEFLT_ }; _NO_DEFLT_ } _N_,
- (<=) = _A_ 2 _U_ 11 _N_ _S_ "EE" _F_ _IF_ARGS_ 0 2 CC 3 \ (u0 :: ()) (u1 :: ()) -> case u0 of { _ALG_ _TUP_0 -> case u1 of { _ALG_ _TUP_0 -> _!_ True [] []; _NO_DEFLT_ }; _NO_DEFLT_ } _N_,
- (>=) = _A_ 2 _U_ 11 _N_ _S_ "EE" _F_ _IF_ARGS_ 0 2 CC 3 \ (u0 :: ()) (u1 :: ()) -> case u0 of { _ALG_ _TUP_0 -> case u1 of { _ALG_ _TUP_0 -> _!_ True [] []; _NO_DEFLT_ }; _NO_DEFLT_ } _N_,
- (>) = _A_ 2 _U_ 11 _N_ _S_ "EE" _F_ _IF_ARGS_ 0 2 CC 3 \ (u0 :: ()) (u1 :: ()) -> case u0 of { _ALG_ _TUP_0 -> case u1 of { _ALG_ _TUP_0 -> _!_ False [] []; _NO_DEFLT_ }; _NO_DEFLT_ } _N_,
- max = _A_ 2 _U_ 11 _N_ _S_ "EE" _F_ _IF_ARGS_ 0 2 CX 2 \ (u0 :: ()) (u1 :: ()) -> case u0 of { _ALG_ _TUP_0 -> u1; _NO_DEFLT_ } _N_,
- min = _A_ 2 _U_ 11 _N_ _S_ "EE" _F_ _IF_ARGS_ 0 2 CX 2 \ (u0 :: ()) (u1 :: ()) -> case u0 of { _ALG_ _TUP_0 -> u1; _NO_DEFLT_ } _N_,
- _tagCmp = _A_ 2 _U_ 11 _N_ _S_ "EE" _F_ _IF_ARGS_ 0 2 CC 3 \ (u0 :: ()) (u1 :: ()) -> case u0 of { _ALG_ _TUP_0 -> case u1 of { _ALG_ _TUP_0 -> _!_ _EQ [] []; _NO_DEFLT_ }; _NO_DEFLT_ } _N_ #-}
+ (<) = { _A_ 2 _U_ 11 _N_ _S_ "EE" _F_ _IF_ARGS_ 0 2 CC 3 \ (u0 :: ()) (u1 :: ()) -> case u0 of { _ALG_ _TUP_0 -> case u1 of { _ALG_ _TUP_0 -> _!_ False [] []; _NO_DEFLT_ }; _NO_DEFLT_ } _N_ },
+ (<=) = { _A_ 2 _U_ 11 _N_ _S_ "EE" _F_ _IF_ARGS_ 0 2 CC 3 \ (u0 :: ()) (u1 :: ()) -> case u0 of { _ALG_ _TUP_0 -> case u1 of { _ALG_ _TUP_0 -> _!_ True [] []; _NO_DEFLT_ }; _NO_DEFLT_ } _N_ },
+ (>=) = { _A_ 2 _U_ 11 _N_ _S_ "EE" _F_ _IF_ARGS_ 0 2 CC 3 \ (u0 :: ()) (u1 :: ()) -> case u0 of { _ALG_ _TUP_0 -> case u1 of { _ALG_ _TUP_0 -> _!_ True [] []; _NO_DEFLT_ }; _NO_DEFLT_ } _N_ },
+ (>) = { _A_ 2 _U_ 11 _N_ _S_ "EE" _F_ _IF_ARGS_ 0 2 CC 3 \ (u0 :: ()) (u1 :: ()) -> case u0 of { _ALG_ _TUP_0 -> case u1 of { _ALG_ _TUP_0 -> _!_ False [] []; _NO_DEFLT_ }; _NO_DEFLT_ } _N_ },
+ max = { _A_ 2 _U_ 11 _N_ _S_ "EE" _F_ _IF_ARGS_ 0 2 CX 2 \ (u0 :: ()) (u1 :: ()) -> case u0 of { _ALG_ _TUP_0 -> u1; _NO_DEFLT_ } _N_ },
+ min = { _A_ 2 _U_ 11 _N_ _S_ "EE" _F_ _IF_ARGS_ 0 2 CX 2 \ (u0 :: ()) (u1 :: ()) -> case u0 of { _ALG_ _TUP_0 -> u1; _NO_DEFLT_ } _N_ },
+ _tagCmp = { _A_ 2 _U_ 11 _N_ _S_ "EE" _F_ _IF_ARGS_ 0 2 CC 3 \ (u0 :: ()) (u1 :: ()) -> case u0 of { _ALG_ _TUP_0 -> case u1 of { _ALG_ _TUP_0 -> _!_ _EQ [] []; _NO_DEFLT_ }; _NO_DEFLT_ } _N_ } #-}
instance (Ord a, Ord b) => Ord (a, b)
{-# GHC_PRAGMA _M_ PreludeBuiltin {-dfun-} _A_ 3 _U_ 112 _N_ _N_ _N_ _N_ #-}
instance (Ord a, Ord b, Ord c) => Ord (a, b, c)
{-# GHC_PRAGMA _M_ PreludeBuiltin {-dfun-} _A_ 6 _U_ 111112 _N_ _N_ _N_ _N_ #-}
instance Ord (Int, Int)
{-# GHC_PRAGMA _M_ PreludeBuiltin {-dfun-} _A_ 0 _N_ _N_ _N_ _F_ _IF_ARGS_ 0 0 X 9 _!_ _TUP_8 [{{Eq (Int, Int)}}, ((Int, Int) -> (Int, Int) -> Bool), ((Int, Int) -> (Int, Int) -> Bool), ((Int, Int) -> (Int, Int) -> Bool), ((Int, Int) -> (Int, Int) -> Bool), ((Int, Int) -> (Int, Int) -> (Int, Int)), ((Int, Int) -> (Int, Int) -> (Int, Int)), ((Int, Int) -> (Int, Int) -> _CMP_TAG)] [_DFUN_ Eq ((Int, Int)), _CONSTM_ Ord (<) ((Int, Int)), _CONSTM_ Ord (<=) ((Int, Int)), _CONSTM_ Ord (>=) ((Int, Int)), _CONSTM_ Ord (>) ((Int, Int)), _CONSTM_ Ord max ((Int, Int)), _CONSTM_ Ord min ((Int, Int)), _CONSTM_ Ord _tagCmp ((Int, Int))] _N_
- (<) = _A_ 2 _U_ 11 _N_ _S_ "U(U(P)L)U(U(P)L)" {_A_ 4 _U_ 2121 _N_ _N_ _N_ _N_} _N_ _N_,
- (<=) = _A_ 2 _U_ 11 _N_ _S_ "U(U(P)L)U(U(P)L)" {_A_ 4 _U_ 2121 _N_ _N_ _N_ _N_} _N_ _N_,
- (>=) = _A_ 2 _U_ 11 _N_ _S_ "U(U(P)L)U(U(P)L)" {_A_ 4 _U_ 2121 _N_ _N_ _N_ _N_} _N_ _N_,
- (>) = _A_ 2 _U_ 11 _N_ _S_ "U(U(P)L)U(U(P)L)" {_A_ 4 _U_ 2121 _N_ _N_ _N_ _N_} _N_ _N_,
- max = _A_ 2 _U_ 11 _N_ _S_ "U(U(P)L)U(U(P)L)" {_A_ 4 _U_ 2222 _N_ _N_ _N_ _N_} _N_ _N_,
- min = _A_ 2 _U_ 11 _N_ _S_ "U(U(P)L)U(U(P)L)" {_A_ 4 _U_ 2222 _N_ _N_ _N_ _N_} _N_ _N_,
- _tagCmp = _A_ 2 _U_ 11 _N_ _S_ "U(U(P)L)U(U(P)L)" {_A_ 4 _U_ 2121 _N_ _N_ _N_ _N_} _N_ _N_ #-}
+ (<) = { _A_ 2 _U_ 11 _N_ _S_ "U(U(P)L)U(U(P)L)" {_A_ 4 _U_ 2121 _N_ _N_ _N_ _N_} _N_ _N_ },
+ (<=) = { _A_ 2 _U_ 11 _N_ _S_ "U(U(P)L)U(U(P)L)" {_A_ 4 _U_ 2121 _N_ _N_ _N_ _N_} _N_ _N_ },
+ (>=) = { _A_ 2 _U_ 11 _N_ _S_ "U(U(P)L)U(U(P)L)" {_A_ 4 _U_ 2121 _N_ _N_ _N_ _N_} _N_ _N_ },
+ (>) = { _A_ 2 _U_ 11 _N_ _S_ "U(U(P)L)U(U(P)L)" {_A_ 4 _U_ 2121 _N_ _N_ _N_ _N_} _N_ _N_ },
+ max = { _A_ 2 _U_ 11 _N_ _S_ "U(U(P)L)U(U(P)L)" {_A_ 4 _U_ 2222 _N_ _N_ _N_ _N_} _N_ _N_ },
+ min = { _A_ 2 _U_ 11 _N_ _S_ "U(U(P)L)U(U(P)L)" {_A_ 4 _U_ 2222 _N_ _N_ _N_ _N_} _N_ _N_ },
+ _tagCmp = { _A_ 2 _U_ 11 _N_ _S_ "U(U(P)L)U(U(P)L)" {_A_ 4 _U_ 2121 _N_ _N_ _N_ _N_} _N_ _N_ } #-}
+instance Ord (Int, Int, Int)
+ {-# GHC_PRAGMA _M_ PreludeBuiltin {-dfun-} _A_ 0 _N_ _N_ _N_ _F_ _IF_ARGS_ 0 0 X 9 _!_ _TUP_8 [{{Eq (Int, Int, Int)}}, ((Int, Int, Int) -> (Int, Int, Int) -> Bool), ((Int, Int, Int) -> (Int, Int, Int) -> Bool), ((Int, Int, Int) -> (Int, Int, Int) -> Bool), ((Int, Int, Int) -> (Int, Int, Int) -> Bool), ((Int, Int, Int) -> (Int, Int, Int) -> (Int, Int, Int)), ((Int, Int, Int) -> (Int, Int, Int) -> (Int, Int, Int)), ((Int, Int, Int) -> (Int, Int, Int) -> _CMP_TAG)] [_DFUN_ Eq ((Int, Int, Int)), _CONSTM_ Ord (<) ((Int, Int, Int)), _CONSTM_ Ord (<=) ((Int, Int, Int)), _CONSTM_ Ord (>=) ((Int, Int, Int)), _CONSTM_ Ord (>) ((Int, Int, Int)), _CONSTM_ Ord max ((Int, Int, Int)), _CONSTM_ Ord min ((Int, Int, Int)), _CONSTM_ Ord _tagCmp ((Int, Int, Int))] _N_
+ (<) = { _A_ 2 _U_ 11 _N_ _S_ "U(U(P)LL)U(U(P)LL)" {_A_ 4 _U_ 2111 _N_ _N_ _N_ _N_} _N_ _N_ },
+ (<=) = { _A_ 2 _U_ 11 _N_ _S_ "U(U(P)LL)U(U(P)LL)" {_A_ 4 _U_ 2111 _N_ _N_ _N_ _N_} _N_ _N_ },
+ (>=) = { _A_ 2 _U_ 11 _N_ _S_ "U(U(P)LL)U(U(P)LL)" {_A_ 4 _U_ 2111 _N_ _N_ _N_ _N_} _N_ _N_ },
+ (>) = { _A_ 2 _U_ 11 _N_ _S_ "U(U(P)LL)U(U(P)LL)" {_A_ 4 _U_ 2111 _N_ _N_ _N_ _N_} _N_ _N_ },
+ max = { _A_ 2 _U_ 12 _N_ _S_ "U(U(P)LL)U(U(P)LL)" {_A_ 4 _U_ 2222 _N_ _N_ _N_ _N_} _N_ _N_ },
+ min = { _A_ 2 _U_ 12 _N_ _S_ "U(U(P)LL)U(U(P)LL)" {_A_ 4 _U_ 2222 _N_ _N_ _N_ _N_} _N_ _N_ },
+ _tagCmp = { _A_ 2 _U_ 11 _N_ _S_ "U(U(P)LL)U(U(P)LL)" {_A_ 4 _U_ 2111 _N_ _N_ _N_ _N_} _N_ _N_ } #-}
+instance Ord (Int, Int, Int, Int)
+ {-# GHC_PRAGMA _M_ PreludeBuiltin {-dfun-} _A_ 0 _N_ _N_ _N_ _F_ _IF_ARGS_ 0 0 X 9 _!_ _TUP_8 [{{Eq (Int, Int, Int, Int)}}, ((Int, Int, Int, Int) -> (Int, Int, Int, Int) -> Bool), ((Int, Int, Int, Int) -> (Int, Int, Int, Int) -> Bool), ((Int, Int, Int, Int) -> (Int, Int, Int, Int) -> Bool), ((Int, Int, Int, Int) -> (Int, Int, Int, Int) -> Bool), ((Int, Int, Int, Int) -> (Int, Int, Int, Int) -> (Int, Int, Int, Int)), ((Int, Int, Int, Int) -> (Int, Int, Int, Int) -> (Int, Int, Int, Int)), ((Int, Int, Int, Int) -> (Int, Int, Int, Int) -> _CMP_TAG)] [_DFUN_ Eq ((Int, Int, Int, Int)), _CONSTM_ Ord (<) ((Int, Int, Int, Int)), _CONSTM_ Ord (<=) ((Int, Int, Int, Int)), _CONSTM_ Ord (>=) ((Int, Int, Int, Int)), _CONSTM_ Ord (>) ((Int, Int, Int, Int)), _CONSTM_ Ord max ((Int, Int, Int, Int)), _CONSTM_ Ord min ((Int, Int, Int, Int)), _CONSTM_ Ord _tagCmp ((Int, Int, Int, Int))] _N_
+ (<) = { _A_ 2 _U_ 11 _N_ _S_ "U(U(P)LLL)U(U(P)LLL)" {_A_ 5 _U_ 21111 _N_ _N_ _N_ _N_} _N_ _N_ },
+ (<=) = { _A_ 2 _U_ 11 _N_ _S_ "U(U(P)LLL)U(U(P)LLL)" {_A_ 5 _U_ 21111 _N_ _N_ _N_ _N_} _N_ _N_ },
+ (>=) = { _A_ 2 _U_ 11 _N_ _S_ "U(U(P)LLL)U(U(P)LLL)" {_A_ 5 _U_ 21111 _N_ _N_ _N_ _N_} _N_ _N_ },
+ (>) = { _A_ 2 _U_ 11 _N_ _S_ "U(U(P)LLL)U(U(P)LLL)" {_A_ 5 _U_ 21111 _N_ _N_ _N_ _N_} _N_ _N_ },
+ max = { _A_ 2 _U_ 12 _N_ _S_ "U(U(P)LLL)U(U(P)LLL)" {_A_ 5 _U_ 22222 _N_ _N_ _N_ _N_} _N_ _N_ },
+ min = { _A_ 2 _U_ 12 _N_ _S_ "U(U(P)LLL)U(U(P)LLL)" {_A_ 5 _U_ 22222 _N_ _N_ _N_ _N_} _N_ _N_ },
+ _tagCmp = { _A_ 2 _U_ 11 _N_ _S_ "U(U(P)LLL)U(U(P)LLL)" {_A_ 5 _U_ 21111 _N_ _N_ _N_ _N_} _N_ _N_ } #-}
+instance Ord (Int, Int, Int, Int, Int)
+ {-# GHC_PRAGMA _M_ PreludeBuiltin {-dfun-} _A_ 0 _N_ _N_ _N_ _F_ _IF_ARGS_ 0 0 X 9 _!_ _TUP_8 [{{Eq (Int, Int, Int, Int, Int)}}, ((Int, Int, Int, Int, Int) -> (Int, Int, Int, Int, Int) -> Bool), ((Int, Int, Int, Int, Int) -> (Int, Int, Int, Int, Int) -> Bool), ((Int, Int, Int, Int, Int) -> (Int, Int, Int, Int, Int) -> Bool), ((Int, Int, Int, Int, Int) -> (Int, Int, Int, Int, Int) -> Bool), ((Int, Int, Int, Int, Int) -> (Int, Int, Int, Int, Int) -> (Int, Int, Int, Int, Int)), ((Int, Int, Int, Int, Int) -> (Int, Int, Int, Int, Int) -> (Int, Int, Int, Int, Int)), ((Int, Int, Int, Int, Int) -> (Int, Int, Int, Int, Int) -> _CMP_TAG)] [_DFUN_ Eq ((Int, Int, Int, Int, Int)), _CONSTM_ Ord (<) ((Int, Int, Int, Int, Int)), _CONSTM_ Ord (<=) ((Int, Int, Int, Int, Int)), _CONSTM_ Ord (>=) ((Int, Int, Int, Int, Int)), _CONSTM_ Ord (>) ((Int, Int, Int, Int, Int)), _CONSTM_ Ord max ((Int, Int, Int, Int, Int)), _CONSTM_ Ord min ((Int, Int, Int, Int, Int)), _CONSTM_ Ord _tagCmp ((Int, Int, Int, Int, Int))] _N_
+ (<) = { _A_ 2 _U_ 11 _N_ _S_ "U(U(P)LLLL)U(U(P)LLLL)" _N_ _N_ },
+ (<=) = { _A_ 2 _U_ 11 _N_ _S_ "U(U(P)LLLL)U(U(P)LLLL)" _N_ _N_ },
+ (>=) = { _A_ 2 _U_ 11 _N_ _S_ "U(U(P)LLLL)U(U(P)LLLL)" _N_ _N_ },
+ (>) = { _A_ 2 _U_ 11 _N_ _S_ "U(U(P)LLLL)U(U(P)LLLL)" _N_ _N_ },
+ max = { _A_ 2 _U_ 22 _N_ _S_ "U(U(P)LLLL)U(U(P)LLLL)" _N_ _N_ },
+ min = { _A_ 2 _U_ 22 _N_ _S_ "U(U(P)LLLL)U(U(P)LLLL)" _N_ _N_ },
+ _tagCmp = { _A_ 2 _U_ 11 _N_ _S_ "U(U(P)LLLL)U(U(P)LLLL)" _N_ _N_ } #-}
+instance Ord ([Char], [Char])
+ {-# GHC_PRAGMA _M_ PreludeBuiltin {-dfun-} _A_ 0 _N_ _N_ _N_ _F_ _IF_ARGS_ 0 0 X 9 _!_ _TUP_8 [{{Eq ([Char], [Char])}}, (([Char], [Char]) -> ([Char], [Char]) -> Bool), (([Char], [Char]) -> ([Char], [Char]) -> Bool), (([Char], [Char]) -> ([Char], [Char]) -> Bool), (([Char], [Char]) -> ([Char], [Char]) -> Bool), (([Char], [Char]) -> ([Char], [Char]) -> ([Char], [Char])), (([Char], [Char]) -> ([Char], [Char]) -> ([Char], [Char])), (([Char], [Char]) -> ([Char], [Char]) -> _CMP_TAG)] [_DFUN_ Eq (([Char], [Char])), _CONSTM_ Ord (<) (([Char], [Char])), _CONSTM_ Ord (<=) (([Char], [Char])), _CONSTM_ Ord (>=) (([Char], [Char])), _CONSTM_ Ord (>) (([Char], [Char])), _CONSTM_ Ord max (([Char], [Char])), _CONSTM_ Ord min (([Char], [Char])), _CONSTM_ Ord _tagCmp (([Char], [Char]))] _N_
+ (<) = { _A_ 2 _U_ 11 _N_ _S_ "U(SL)U(SL)" {_A_ 4 _U_ 2222 _N_ _N_ _N_ _N_} _N_ _N_ },
+ (<=) = { _A_ 2 _U_ 11 _N_ _S_ "U(SL)U(SL)" {_A_ 4 _U_ 2222 _N_ _N_ _N_ _N_} _N_ _N_ },
+ (>=) = { _A_ 2 _U_ 11 _N_ _S_ "U(SL)U(SL)" {_A_ 4 _U_ 2222 _N_ _N_ _N_ _N_} _N_ _N_ },
+ (>) = { _A_ 2 _U_ 11 _N_ _S_ "U(SL)U(SL)" {_A_ 4 _U_ 2222 _N_ _N_ _N_ _N_} _N_ _N_ },
+ max = { _A_ 2 _U_ 11 _N_ _S_ "U(SL)U(SL)" {_A_ 4 _U_ 2222 _N_ _N_ _N_ _N_} _N_ _N_ },
+ min = { _A_ 2 _U_ 11 _N_ _S_ "U(SL)U(SL)" {_A_ 4 _U_ 2222 _N_ _N_ _N_ _N_} _N_ _N_ },
+ _tagCmp = { _A_ 2 _U_ 11 _N_ _S_ "U(SL)U(SL)" {_A_ 4 _U_ 2222 _N_ _N_ _N_ _N_} _N_ _N_ } #-}
+instance Ord ([Int], [Int])
+ {-# GHC_PRAGMA _M_ PreludeBuiltin {-dfun-} _A_ 0 _N_ _N_ _N_ _F_ _IF_ARGS_ 0 0 X 9 _!_ _TUP_8 [{{Eq ([Int], [Int])}}, (([Int], [Int]) -> ([Int], [Int]) -> Bool), (([Int], [Int]) -> ([Int], [Int]) -> Bool), (([Int], [Int]) -> ([Int], [Int]) -> Bool), (([Int], [Int]) -> ([Int], [Int]) -> Bool), (([Int], [Int]) -> ([Int], [Int]) -> ([Int], [Int])), (([Int], [Int]) -> ([Int], [Int]) -> ([Int], [Int])), (([Int], [Int]) -> ([Int], [Int]) -> _CMP_TAG)] [_DFUN_ Eq (([Int], [Int])), _CONSTM_ Ord (<) (([Int], [Int])), _CONSTM_ Ord (<=) (([Int], [Int])), _CONSTM_ Ord (>=) (([Int], [Int])), _CONSTM_ Ord (>) (([Int], [Int])), _CONSTM_ Ord max (([Int], [Int])), _CONSTM_ Ord min (([Int], [Int])), _CONSTM_ Ord _tagCmp (([Int], [Int]))] _N_
+ (<) = { _A_ 2 _U_ 11 _N_ _S_ "U(SL)U(SL)" {_A_ 4 _U_ 2222 _N_ _N_ _N_ _N_} _N_ _N_ },
+ (<=) = { _A_ 2 _U_ 11 _N_ _S_ "U(SL)U(SL)" {_A_ 4 _U_ 2222 _N_ _N_ _N_ _N_} _N_ _N_ },
+ (>=) = { _A_ 2 _U_ 11 _N_ _S_ "U(SL)U(SL)" {_A_ 4 _U_ 2222 _N_ _N_ _N_ _N_} _N_ _N_ },
+ (>) = { _A_ 2 _U_ 11 _N_ _S_ "U(SL)U(SL)" {_A_ 4 _U_ 2222 _N_ _N_ _N_ _N_} _N_ _N_ },
+ max = { _A_ 2 _U_ 11 _N_ _S_ "U(SL)U(SL)" {_A_ 4 _U_ 2222 _N_ _N_ _N_ _N_} _N_ _N_ },
+ min = { _A_ 2 _U_ 11 _N_ _S_ "U(SL)U(SL)" {_A_ 4 _U_ 2222 _N_ _N_ _N_ _N_} _N_ _N_ },
+ _tagCmp = { _A_ 2 _U_ 11 _N_ _S_ "U(SL)U(SL)" {_A_ 4 _U_ 2222 _N_ _N_ _N_ _N_} _N_ _N_ } #-}
instance Ord (_PackedString, _PackedString)
{-# GHC_PRAGMA _M_ PreludeBuiltin {-dfun-} _A_ 0 _N_ _N_ _N_ _F_ _IF_ARGS_ 0 0 X 9 _!_ _TUP_8 [{{Eq (_PackedString, _PackedString)}}, ((_PackedString, _PackedString) -> (_PackedString, _PackedString) -> Bool), ((_PackedString, _PackedString) -> (_PackedString, _PackedString) -> Bool), ((_PackedString, _PackedString) -> (_PackedString, _PackedString) -> Bool), ((_PackedString, _PackedString) -> (_PackedString, _PackedString) -> Bool), ((_PackedString, _PackedString) -> (_PackedString, _PackedString) -> (_PackedString, _PackedString)), ((_PackedString, _PackedString) -> (_PackedString, _PackedString) -> (_PackedString, _PackedString)), ((_PackedString, _PackedString) -> (_PackedString, _PackedString) -> _CMP_TAG)] [_DFUN_ Eq ((_PackedString, _PackedString)), _CONSTM_ Ord (<) ((_PackedString, _PackedString)), _CONSTM_ Ord (<=) ((_PackedString, _PackedString)), _CONSTM_ Ord (>=) ((_PackedString, _PackedString)), _CONSTM_ Ord (>) ((_PackedString, _PackedString)), _CONSTM_ Ord max ((_PackedString, _PackedString)), _CONSTM_ Ord min ((_PackedString, _PackedString)), _CONSTM_ Ord _tagCmp ((_PackedString, _PackedString))] _N_
- (<) = _A_ 2 _U_ 11 _N_ _S_ "U(SL)U(SL)" {_A_ 4 _U_ 2222 _N_ _N_ _N_ _N_} _N_ _N_,
- (<=) = _A_ 2 _U_ 11 _N_ _S_ "U(SL)U(SL)" {_A_ 4 _U_ 2222 _N_ _N_ _N_ _N_} _N_ _N_,
- (>=) = _A_ 2 _U_ 11 _N_ _S_ "U(SL)U(SL)" {_A_ 4 _U_ 2222 _N_ _N_ _N_ _N_} _N_ _N_,
- (>) = _A_ 2 _U_ 11 _N_ _S_ "U(SL)U(SL)" {_A_ 4 _U_ 2222 _N_ _N_ _N_ _N_} _N_ _N_,
- max = _A_ 2 _U_ 11 _N_ _S_ "U(SL)U(SL)" {_A_ 4 _U_ 2222 _N_ _N_ _N_ _N_} _N_ _N_,
- min = _A_ 2 _U_ 11 _N_ _S_ "U(SL)U(SL)" {_A_ 4 _U_ 2222 _N_ _N_ _N_ _N_} _N_ _N_,
- _tagCmp = _A_ 2 _U_ 11 _N_ _S_ "U(SL)U(SL)" {_A_ 4 _U_ 2222 _N_ _N_ _N_ _N_} _N_ _N_ #-}
+ (<) = { _A_ 2 _U_ 11 _N_ _S_ "U(SL)U(SL)" {_A_ 4 _U_ 2222 _N_ _N_ _N_ _N_} _N_ _N_ },
+ (<=) = { _A_ 2 _U_ 11 _N_ _S_ "U(SL)U(SL)" {_A_ 4 _U_ 2222 _N_ _N_ _N_ _N_} _N_ _N_ },
+ (>=) = { _A_ 2 _U_ 11 _N_ _S_ "U(SL)U(SL)" {_A_ 4 _U_ 2222 _N_ _N_ _N_ _N_} _N_ _N_ },
+ (>) = { _A_ 2 _U_ 11 _N_ _S_ "U(SL)U(SL)" {_A_ 4 _U_ 2222 _N_ _N_ _N_ _N_} _N_ _N_ },
+ max = { _A_ 2 _U_ 11 _N_ _S_ "U(SL)U(SL)" {_A_ 4 _U_ 2222 _N_ _N_ _N_ _N_} _N_ _N_ },
+ min = { _A_ 2 _U_ 11 _N_ _S_ "U(SL)U(SL)" {_A_ 4 _U_ 2222 _N_ _N_ _N_ _N_} _N_ _N_ },
+ _tagCmp = { _A_ 2 _U_ 11 _N_ _S_ "U(SL)U(SL)" {_A_ 4 _U_ 2222 _N_ _N_ _N_ _N_} _N_ _N_ } #-}
instance (Ix a, Ord b) => Ord (Array a b)
{-# GHC_PRAGMA _M_ PreludeArray {-dfun-} _A_ 3 _U_ 222 _N_ _N_ _N_ _N_ #-}
instance (Ord a, Ord b) => Ord (Assoc a b)
{-# GHC_PRAGMA _M_ PreludeArray {-dfun-} _A_ 3 _U_ 112 _N_ _N_ _N_ _N_ #-}
instance Ord Bool
{-# GHC_PRAGMA _M_ PreludeCore {-dfun-} _A_ 0 _N_ _N_ _N_ _F_ _IF_ARGS_ 0 0 X 9 _!_ _TUP_8 [{{Eq Bool}}, (Bool -> Bool -> Bool), (Bool -> Bool -> Bool), (Bool -> Bool -> Bool), (Bool -> Bool -> Bool), (Bool -> Bool -> Bool), (Bool -> Bool -> Bool), (Bool -> Bool -> _CMP_TAG)] [_DFUN_ Eq (Bool), _CONSTM_ Ord (<) (Bool), _CONSTM_ Ord (<=) (Bool), _CONSTM_ Ord (>=) (Bool), _CONSTM_ Ord (>) (Bool), _CONSTM_ Ord max (Bool), _CONSTM_ Ord min (Bool), _CONSTM_ Ord _tagCmp (Bool)] _N_
- (<) = _A_ 2 _U_ 11 _N_ _S_ "EE" _N_ _N_,
- (<=) = _A_ 2 _U_ 11 _N_ _S_ "EE" _N_ _N_,
- (>=) = _A_ 2 _U_ 11 _N_ _S_ "EE" _N_ _N_,
- (>) = _A_ 2 _U_ 11 _N_ _S_ "EE" _N_ _N_,
- max = _A_ 2 _U_ 22 _N_ _S_ "EE" _N_ _N_,
- min = _A_ 2 _U_ 22 _N_ _S_ "EE" _N_ _N_,
- _tagCmp = _A_ 2 _U_ 11 _N_ _S_ "EE" _N_ _N_ #-}
+ (<) = { _A_ 2 _U_ 11 _N_ _S_ "EE" _N_ _N_ },
+ (<=) = { _A_ 2 _U_ 11 _N_ _S_ "EE" _N_ _N_ },
+ (>=) = { _A_ 2 _U_ 11 _N_ _S_ "EE" _N_ _N_ },
+ (>) = { _A_ 2 _U_ 11 _N_ _S_ "EE" _N_ _N_ },
+ max = { _A_ 2 _U_ 22 _N_ _S_ "EE" _N_ _N_ },
+ min = { _A_ 2 _U_ 22 _N_ _S_ "EE" _N_ _N_ },
+ _tagCmp = { _A_ 2 _U_ 11 _N_ _S_ "EE" _N_ _N_ } #-}
instance Ord Char
{-# GHC_PRAGMA _M_ PreludeCore {-dfun-} _A_ 0 _N_ _N_ _N_ _F_ _IF_ARGS_ 0 0 X 9 _!_ _TUP_8 [{{Eq Char}}, (Char -> Char -> Bool), (Char -> Char -> Bool), (Char -> Char -> Bool), (Char -> Char -> Bool), (Char -> Char -> Char), (Char -> Char -> Char), (Char -> Char -> _CMP_TAG)] [_DFUN_ Eq (Char), _CONSTM_ Ord (<) (Char), _CONSTM_ Ord (<=) (Char), _CONSTM_ Ord (>=) (Char), _CONSTM_ Ord (>) (Char), _CONSTM_ Ord max (Char), _CONSTM_ Ord min (Char), _CONSTM_ Ord _tagCmp (Char)] _N_
- (<) = _A_ 2 _U_ 11 _N_ _S_ "U(P)U(P)" {_A_ 2 _U_ 22 _N_ _N_ _F_ _IF_ARGS_ 0 2 XX 1 \ (u0 :: Char#) (u1 :: Char#) -> _#_ ltChar# [] [u0, u1] _N_} _F_ _IF_ARGS_ 0 2 CC 3 \ (u0 :: Char) (u1 :: Char) -> case u0 of { _ALG_ C# (u2 :: Char#) -> case u1 of { _ALG_ C# (u3 :: Char#) -> _#_ ltChar# [] [u2, u3]; _NO_DEFLT_ }; _NO_DEFLT_ } _N_,
- (<=) = _A_ 2 _U_ 11 _N_ _S_ "U(P)U(P)" {_A_ 2 _U_ 22 _N_ _N_ _F_ _IF_ARGS_ 0 2 XX 1 \ (u0 :: Char#) (u1 :: Char#) -> _#_ leChar# [] [u0, u1] _N_} _F_ _IF_ARGS_ 0 2 CC 3 \ (u0 :: Char) (u1 :: Char) -> case u0 of { _ALG_ C# (u2 :: Char#) -> case u1 of { _ALG_ C# (u3 :: Char#) -> _#_ leChar# [] [u2, u3]; _NO_DEFLT_ }; _NO_DEFLT_ } _N_,
- (>=) = _A_ 2 _U_ 11 _N_ _S_ "U(P)U(P)" {_A_ 2 _U_ 22 _N_ _N_ _F_ _IF_ARGS_ 0 2 XX 1 \ (u0 :: Char#) (u1 :: Char#) -> _#_ geChar# [] [u0, u1] _N_} _F_ _IF_ARGS_ 0 2 CC 3 \ (u0 :: Char) (u1 :: Char) -> case u0 of { _ALG_ C# (u2 :: Char#) -> case u1 of { _ALG_ C# (u3 :: Char#) -> _#_ geChar# [] [u2, u3]; _NO_DEFLT_ }; _NO_DEFLT_ } _N_,
- (>) = _A_ 2 _U_ 11 _N_ _S_ "U(P)U(P)" {_A_ 2 _U_ 22 _N_ _N_ _F_ _IF_ARGS_ 0 2 XX 1 \ (u0 :: Char#) (u1 :: Char#) -> _#_ gtChar# [] [u0, u1] _N_} _F_ _IF_ARGS_ 0 2 CC 3 \ (u0 :: Char) (u1 :: Char) -> case u0 of { _ALG_ C# (u2 :: Char#) -> case u1 of { _ALG_ C# (u3 :: Char#) -> _#_ gtChar# [] [u2, u3]; _NO_DEFLT_ }; _NO_DEFLT_ } _N_,
- max = _A_ 2 _U_ 11 _N_ _S_ "U(P)U(P)" {_A_ 2 _U_ 22 _N_ _N_ _N_ _N_} _N_ _N_,
- min = _A_ 2 _U_ 11 _N_ _S_ "U(P)U(P)" {_A_ 2 _U_ 22 _N_ _N_ _N_ _N_} _N_ _N_,
- _tagCmp = _A_ 2 _U_ 11 _N_ _S_ "U(P)U(P)" {_A_ 2 _U_ 22 _N_ _N_ _N_ _N_} _N_ _N_ #-}
+ (<) = { _A_ 2 _U_ 11 _N_ _S_ "U(P)U(P)" {_A_ 2 _U_ 22 _N_ _N_ _F_ _IF_ARGS_ 0 2 XX 1 \ (u0 :: Char#) (u1 :: Char#) -> _#_ ltChar# [] [u0, u1] _N_} _F_ _IF_ARGS_ 0 2 CC 3 \ (u0 :: Char) (u1 :: Char) -> case u0 of { _ALG_ C# (u2 :: Char#) -> case u1 of { _ALG_ C# (u3 :: Char#) -> _#_ ltChar# [] [u2, u3]; _NO_DEFLT_ }; _NO_DEFLT_ } _N_ },
+ (<=) = { _A_ 2 _U_ 11 _N_ _S_ "U(P)U(P)" {_A_ 2 _U_ 22 _N_ _N_ _F_ _IF_ARGS_ 0 2 XX 1 \ (u0 :: Char#) (u1 :: Char#) -> _#_ leChar# [] [u0, u1] _N_} _F_ _IF_ARGS_ 0 2 CC 3 \ (u0 :: Char) (u1 :: Char) -> case u0 of { _ALG_ C# (u2 :: Char#) -> case u1 of { _ALG_ C# (u3 :: Char#) -> _#_ leChar# [] [u2, u3]; _NO_DEFLT_ }; _NO_DEFLT_ } _N_ },
+ (>=) = { _A_ 2 _U_ 11 _N_ _S_ "U(P)U(P)" {_A_ 2 _U_ 22 _N_ _N_ _F_ _IF_ARGS_ 0 2 XX 1 \ (u0 :: Char#) (u1 :: Char#) -> _#_ geChar# [] [u0, u1] _N_} _F_ _IF_ARGS_ 0 2 CC 3 \ (u0 :: Char) (u1 :: Char) -> case u0 of { _ALG_ C# (u2 :: Char#) -> case u1 of { _ALG_ C# (u3 :: Char#) -> _#_ geChar# [] [u2, u3]; _NO_DEFLT_ }; _NO_DEFLT_ } _N_ },
+ (>) = { _A_ 2 _U_ 11 _N_ _S_ "U(P)U(P)" {_A_ 2 _U_ 22 _N_ _N_ _F_ _IF_ARGS_ 0 2 XX 1 \ (u0 :: Char#) (u1 :: Char#) -> _#_ gtChar# [] [u0, u1] _N_} _F_ _IF_ARGS_ 0 2 CC 3 \ (u0 :: Char) (u1 :: Char) -> case u0 of { _ALG_ C# (u2 :: Char#) -> case u1 of { _ALG_ C# (u3 :: Char#) -> _#_ gtChar# [] [u2, u3]; _NO_DEFLT_ }; _NO_DEFLT_ } _N_ },
+ max = { _A_ 2 _U_ 11 _N_ _S_ "U(P)U(P)" {_A_ 2 _U_ 22 _N_ _N_ _N_ _N_} _N_ _N_ },
+ min = { _A_ 2 _U_ 11 _N_ _S_ "U(P)U(P)" {_A_ 2 _U_ 22 _N_ _N_ _N_ _N_} _N_ _N_ },
+ _tagCmp = { _A_ 2 _U_ 11 _N_ _S_ "U(P)U(P)" {_A_ 2 _U_ 22 _N_ _N_ _N_ _N_} _N_ _N_ } #-}
instance Ord Double
{-# GHC_PRAGMA _M_ PreludeCore {-dfun-} _A_ 0 _N_ _N_ _N_ _F_ _IF_ARGS_ 0 0 X 9 _!_ _TUP_8 [{{Eq Double}}, (Double -> Double -> Bool), (Double -> Double -> Bool), (Double -> Double -> Bool), (Double -> Double -> Bool), (Double -> Double -> Double), (Double -> Double -> Double), (Double -> Double -> _CMP_TAG)] [_DFUN_ Eq (Double), _CONSTM_ Ord (<) (Double), _CONSTM_ Ord (<=) (Double), _CONSTM_ Ord (>=) (Double), _CONSTM_ Ord (>) (Double), _CONSTM_ Ord max (Double), _CONSTM_ Ord min (Double), _CONSTM_ Ord _tagCmp (Double)] _N_
- (<) = _A_ 2 _U_ 11 _N_ _S_ "U(P)U(P)" {_A_ 2 _U_ 22 _N_ _N_ _F_ _IF_ARGS_ 0 2 XX 1 \ (u0 :: Double#) (u1 :: Double#) -> _#_ ltDouble# [] [u0, u1] _N_} _F_ _IF_ARGS_ 0 2 CC 3 \ (u0 :: Double) (u1 :: Double) -> case u0 of { _ALG_ D# (u2 :: Double#) -> case u1 of { _ALG_ D# (u3 :: Double#) -> _#_ ltDouble# [] [u2, u3]; _NO_DEFLT_ }; _NO_DEFLT_ } _N_,
- (<=) = _A_ 2 _U_ 11 _N_ _S_ "U(P)U(P)" {_A_ 2 _U_ 22 _N_ _N_ _F_ _IF_ARGS_ 0 2 XX 1 \ (u0 :: Double#) (u1 :: Double#) -> _#_ leDouble# [] [u0, u1] _N_} _F_ _IF_ARGS_ 0 2 CC 3 \ (u0 :: Double) (u1 :: Double) -> case u0 of { _ALG_ D# (u2 :: Double#) -> case u1 of { _ALG_ D# (u3 :: Double#) -> _#_ leDouble# [] [u2, u3]; _NO_DEFLT_ }; _NO_DEFLT_ } _N_,
- (>=) = _A_ 2 _U_ 11 _N_ _S_ "U(P)U(P)" {_A_ 2 _U_ 22 _N_ _N_ _F_ _IF_ARGS_ 0 2 XX 1 \ (u0 :: Double#) (u1 :: Double#) -> _#_ geDouble# [] [u0, u1] _N_} _F_ _IF_ARGS_ 0 2 CC 3 \ (u0 :: Double) (u1 :: Double) -> case u0 of { _ALG_ D# (u2 :: Double#) -> case u1 of { _ALG_ D# (u3 :: Double#) -> _#_ geDouble# [] [u2, u3]; _NO_DEFLT_ }; _NO_DEFLT_ } _N_,
- (>) = _A_ 2 _U_ 11 _N_ _S_ "U(P)U(P)" {_A_ 2 _U_ 22 _N_ _N_ _F_ _IF_ARGS_ 0 2 XX 1 \ (u0 :: Double#) (u1 :: Double#) -> _#_ gtDouble# [] [u0, u1] _N_} _F_ _IF_ARGS_ 0 2 CC 3 \ (u0 :: Double) (u1 :: Double) -> case u0 of { _ALG_ D# (u2 :: Double#) -> case u1 of { _ALG_ D# (u3 :: Double#) -> _#_ gtDouble# [] [u2, u3]; _NO_DEFLT_ }; _NO_DEFLT_ } _N_,
- max = _A_ 2 _U_ 11 _N_ _S_ "U(P)U(P)" {_A_ 2 _U_ 22 _N_ _N_ _N_ _N_} _N_ _N_,
- min = _A_ 2 _U_ 11 _N_ _S_ "U(P)U(P)" {_A_ 2 _U_ 22 _N_ _N_ _N_ _N_} _N_ _N_,
- _tagCmp = _A_ 2 _U_ 11 _N_ _S_ "U(P)U(P)" {_A_ 2 _U_ 22 _N_ _N_ _N_ _N_} _N_ _N_ #-}
+ (<) = { _A_ 2 _U_ 11 _N_ _S_ "U(P)U(P)" {_A_ 2 _U_ 22 _N_ _N_ _F_ _IF_ARGS_ 0 2 XX 1 \ (u0 :: Double#) (u1 :: Double#) -> _#_ ltDouble# [] [u0, u1] _N_} _F_ _IF_ARGS_ 0 2 CC 3 \ (u0 :: Double) (u1 :: Double) -> case u0 of { _ALG_ D# (u2 :: Double#) -> case u1 of { _ALG_ D# (u3 :: Double#) -> _#_ ltDouble# [] [u2, u3]; _NO_DEFLT_ }; _NO_DEFLT_ } _N_ },
+ (<=) = { _A_ 2 _U_ 11 _N_ _S_ "U(P)U(P)" {_A_ 2 _U_ 22 _N_ _N_ _F_ _IF_ARGS_ 0 2 XX 1 \ (u0 :: Double#) (u1 :: Double#) -> _#_ leDouble# [] [u0, u1] _N_} _F_ _IF_ARGS_ 0 2 CC 3 \ (u0 :: Double) (u1 :: Double) -> case u0 of { _ALG_ D# (u2 :: Double#) -> case u1 of { _ALG_ D# (u3 :: Double#) -> _#_ leDouble# [] [u2, u3]; _NO_DEFLT_ }; _NO_DEFLT_ } _N_ },
+ (>=) = { _A_ 2 _U_ 11 _N_ _S_ "U(P)U(P)" {_A_ 2 _U_ 22 _N_ _N_ _F_ _IF_ARGS_ 0 2 XX 1 \ (u0 :: Double#) (u1 :: Double#) -> _#_ geDouble# [] [u0, u1] _N_} _F_ _IF_ARGS_ 0 2 CC 3 \ (u0 :: Double) (u1 :: Double) -> case u0 of { _ALG_ D# (u2 :: Double#) -> case u1 of { _ALG_ D# (u3 :: Double#) -> _#_ geDouble# [] [u2, u3]; _NO_DEFLT_ }; _NO_DEFLT_ } _N_ },
+ (>) = { _A_ 2 _U_ 11 _N_ _S_ "U(P)U(P)" {_A_ 2 _U_ 22 _N_ _N_ _F_ _IF_ARGS_ 0 2 XX 1 \ (u0 :: Double#) (u1 :: Double#) -> _#_ gtDouble# [] [u0, u1] _N_} _F_ _IF_ARGS_ 0 2 CC 3 \ (u0 :: Double) (u1 :: Double) -> case u0 of { _ALG_ D# (u2 :: Double#) -> case u1 of { _ALG_ D# (u3 :: Double#) -> _#_ gtDouble# [] [u2, u3]; _NO_DEFLT_ }; _NO_DEFLT_ } _N_ },
+ max = { _A_ 2 _U_ 11 _N_ _S_ "U(P)U(P)" {_A_ 2 _U_ 22 _N_ _N_ _N_ _N_} _N_ _N_ },
+ min = { _A_ 2 _U_ 11 _N_ _S_ "U(P)U(P)" {_A_ 2 _U_ 22 _N_ _N_ _N_ _N_} _N_ _N_ },
+ _tagCmp = { _A_ 2 _U_ 11 _N_ _S_ "U(P)U(P)" {_A_ 2 _U_ 22 _N_ _N_ _N_ _N_} _N_ _N_ } #-}
instance (Ord a, Ord b) => Ord (Either a b)
{-# GHC_PRAGMA _M_ PreludeMonadicIO {-dfun-} _A_ 3 _U_ 222 _N_ _N_ _N_ _N_ #-}
instance Ord Float
{-# GHC_PRAGMA _M_ PreludeCore {-dfun-} _A_ 0 _N_ _N_ _N_ _F_ _IF_ARGS_ 0 0 X 9 _!_ _TUP_8 [{{Eq Float}}, (Float -> Float -> Bool), (Float -> Float -> Bool), (Float -> Float -> Bool), (Float -> Float -> Bool), (Float -> Float -> Float), (Float -> Float -> Float), (Float -> Float -> _CMP_TAG)] [_DFUN_ Eq (Float), _CONSTM_ Ord (<) (Float), _CONSTM_ Ord (<=) (Float), _CONSTM_ Ord (>=) (Float), _CONSTM_ Ord (>) (Float), _CONSTM_ Ord max (Float), _CONSTM_ Ord min (Float), _CONSTM_ Ord _tagCmp (Float)] _N_
- (<) = _A_ 2 _U_ 11 _N_ _S_ "U(P)U(P)" {_A_ 2 _U_ 22 _N_ _N_ _F_ _IF_ARGS_ 0 2 XX 1 \ (u0 :: Float#) (u1 :: Float#) -> _#_ ltFloat# [] [u0, u1] _N_} _F_ _IF_ARGS_ 0 2 CC 3 \ (u0 :: Float) (u1 :: Float) -> case u0 of { _ALG_ F# (u2 :: Float#) -> case u1 of { _ALG_ F# (u3 :: Float#) -> _#_ ltFloat# [] [u2, u3]; _NO_DEFLT_ }; _NO_DEFLT_ } _N_,
- (<=) = _A_ 2 _U_ 11 _N_ _S_ "U(P)U(P)" {_A_ 2 _U_ 22 _N_ _N_ _F_ _IF_ARGS_ 0 2 XX 1 \ (u0 :: Float#) (u1 :: Float#) -> _#_ leFloat# [] [u0, u1] _N_} _F_ _IF_ARGS_ 0 2 CC 3 \ (u0 :: Float) (u1 :: Float) -> case u0 of { _ALG_ F# (u2 :: Float#) -> case u1 of { _ALG_ F# (u3 :: Float#) -> _#_ leFloat# [] [u2, u3]; _NO_DEFLT_ }; _NO_DEFLT_ } _N_,
- (>=) = _A_ 2 _U_ 11 _N_ _S_ "U(P)U(P)" {_A_ 2 _U_ 22 _N_ _N_ _F_ _IF_ARGS_ 0 2 XX 1 \ (u0 :: Float#) (u1 :: Float#) -> _#_ geFloat# [] [u0, u1] _N_} _F_ _IF_ARGS_ 0 2 CC 3 \ (u0 :: Float) (u1 :: Float) -> case u0 of { _ALG_ F# (u2 :: Float#) -> case u1 of { _ALG_ F# (u3 :: Float#) -> _#_ geFloat# [] [u2, u3]; _NO_DEFLT_ }; _NO_DEFLT_ } _N_,
- (>) = _A_ 2 _U_ 11 _N_ _S_ "U(P)U(P)" {_A_ 2 _U_ 22 _N_ _N_ _F_ _IF_ARGS_ 0 2 XX 1 \ (u0 :: Float#) (u1 :: Float#) -> _#_ gtFloat# [] [u0, u1] _N_} _F_ _IF_ARGS_ 0 2 CC 3 \ (u0 :: Float) (u1 :: Float) -> case u0 of { _ALG_ F# (u2 :: Float#) -> case u1 of { _ALG_ F# (u3 :: Float#) -> _#_ gtFloat# [] [u2, u3]; _NO_DEFLT_ }; _NO_DEFLT_ } _N_,
- max = _A_ 2 _U_ 11 _N_ _S_ "U(P)U(P)" {_A_ 2 _U_ 22 _N_ _N_ _N_ _N_} _N_ _N_,
- min = _A_ 2 _U_ 11 _N_ _S_ "U(P)U(P)" {_A_ 2 _U_ 22 _N_ _N_ _N_ _N_} _N_ _N_,
- _tagCmp = _A_ 2 _U_ 11 _N_ _S_ "U(P)U(P)" {_A_ 2 _U_ 22 _N_ _N_ _N_ _N_} _N_ _N_ #-}
+ (<) = { _A_ 2 _U_ 11 _N_ _S_ "U(P)U(P)" {_A_ 2 _U_ 22 _N_ _N_ _F_ _IF_ARGS_ 0 2 XX 1 \ (u0 :: Float#) (u1 :: Float#) -> _#_ ltFloat# [] [u0, u1] _N_} _F_ _IF_ARGS_ 0 2 CC 3 \ (u0 :: Float) (u1 :: Float) -> case u0 of { _ALG_ F# (u2 :: Float#) -> case u1 of { _ALG_ F# (u3 :: Float#) -> _#_ ltFloat# [] [u2, u3]; _NO_DEFLT_ }; _NO_DEFLT_ } _N_ },
+ (<=) = { _A_ 2 _U_ 11 _N_ _S_ "U(P)U(P)" {_A_ 2 _U_ 22 _N_ _N_ _F_ _IF_ARGS_ 0 2 XX 1 \ (u0 :: Float#) (u1 :: Float#) -> _#_ leFloat# [] [u0, u1] _N_} _F_ _IF_ARGS_ 0 2 CC 3 \ (u0 :: Float) (u1 :: Float) -> case u0 of { _ALG_ F# (u2 :: Float#) -> case u1 of { _ALG_ F# (u3 :: Float#) -> _#_ leFloat# [] [u2, u3]; _NO_DEFLT_ }; _NO_DEFLT_ } _N_ },
+ (>=) = { _A_ 2 _U_ 11 _N_ _S_ "U(P)U(P)" {_A_ 2 _U_ 22 _N_ _N_ _F_ _IF_ARGS_ 0 2 XX 1 \ (u0 :: Float#) (u1 :: Float#) -> _#_ geFloat# [] [u0, u1] _N_} _F_ _IF_ARGS_ 0 2 CC 3 \ (u0 :: Float) (u1 :: Float) -> case u0 of { _ALG_ F# (u2 :: Float#) -> case u1 of { _ALG_ F# (u3 :: Float#) -> _#_ geFloat# [] [u2, u3]; _NO_DEFLT_ }; _NO_DEFLT_ } _N_ },
+ (>) = { _A_ 2 _U_ 11 _N_ _S_ "U(P)U(P)" {_A_ 2 _U_ 22 _N_ _N_ _F_ _IF_ARGS_ 0 2 XX 1 \ (u0 :: Float#) (u1 :: Float#) -> _#_ gtFloat# [] [u0, u1] _N_} _F_ _IF_ARGS_ 0 2 CC 3 \ (u0 :: Float) (u1 :: Float) -> case u0 of { _ALG_ F# (u2 :: Float#) -> case u1 of { _ALG_ F# (u3 :: Float#) -> _#_ gtFloat# [] [u2, u3]; _NO_DEFLT_ }; _NO_DEFLT_ } _N_ },
+ max = { _A_ 2 _U_ 11 _N_ _S_ "U(P)U(P)" {_A_ 2 _U_ 22 _N_ _N_ _N_ _N_} _N_ _N_ },
+ min = { _A_ 2 _U_ 11 _N_ _S_ "U(P)U(P)" {_A_ 2 _U_ 22 _N_ _N_ _N_ _N_} _N_ _N_ },
+ _tagCmp = { _A_ 2 _U_ 11 _N_ _S_ "U(P)U(P)" {_A_ 2 _U_ 22 _N_ _N_ _N_ _N_} _N_ _N_ } #-}
instance Ord Int
{-# GHC_PRAGMA _M_ PreludeCore {-dfun-} _A_ 0 _N_ _N_ _N_ _F_ _IF_ARGS_ 0 0 X 9 _!_ _TUP_8 [{{Eq Int}}, (Int -> Int -> Bool), (Int -> Int -> Bool), (Int -> Int -> Bool), (Int -> Int -> Bool), (Int -> Int -> Int), (Int -> Int -> Int), (Int -> Int -> _CMP_TAG)] [_DFUN_ Eq (Int), _CONSTM_ Ord (<) (Int), _CONSTM_ Ord (<=) (Int), _CONSTM_ Ord (>=) (Int), _CONSTM_ Ord (>) (Int), _CONSTM_ Ord max (Int), _CONSTM_ Ord min (Int), _CONSTM_ Ord _tagCmp (Int)] _N_
- (<) = _A_ 2 _U_ 11 _N_ _S_ "U(P)U(P)" {_A_ 2 _U_ 22 _N_ _N_ _F_ _IF_ARGS_ 0 2 XX 1 \ (u0 :: Int#) (u1 :: Int#) -> _#_ ltInt# [] [u0, u1] _N_} _F_ _IF_ARGS_ 0 2 CC 3 \ (u0 :: Int) (u1 :: Int) -> case u0 of { _ALG_ I# (u2 :: Int#) -> case u1 of { _ALG_ I# (u3 :: Int#) -> _#_ ltInt# [] [u2, u3]; _NO_DEFLT_ }; _NO_DEFLT_ } _N_,
- (<=) = _A_ 2 _U_ 11 _N_ _S_ "U(P)U(P)" {_A_ 2 _U_ 22 _N_ _N_ _F_ _IF_ARGS_ 0 2 XX 1 \ (u0 :: Int#) (u1 :: Int#) -> _#_ leInt# [] [u0, u1] _N_} _F_ _IF_ARGS_ 0 2 CC 3 \ (u0 :: Int) (u1 :: Int) -> case u0 of { _ALG_ I# (u2 :: Int#) -> case u1 of { _ALG_ I# (u3 :: Int#) -> _#_ leInt# [] [u2, u3]; _NO_DEFLT_ }; _NO_DEFLT_ } _N_,
- (>=) = _A_ 2 _U_ 11 _N_ _S_ "U(P)U(P)" {_A_ 2 _U_ 22 _N_ _N_ _F_ _IF_ARGS_ 0 2 XX 1 \ (u0 :: Int#) (u1 :: Int#) -> _#_ geInt# [] [u0, u1] _N_} _F_ _IF_ARGS_ 0 2 CC 3 \ (u0 :: Int) (u1 :: Int) -> case u0 of { _ALG_ I# (u2 :: Int#) -> case u1 of { _ALG_ I# (u3 :: Int#) -> _#_ geInt# [] [u2, u3]; _NO_DEFLT_ }; _NO_DEFLT_ } _N_,
- (>) = _A_ 2 _U_ 11 _N_ _S_ "U(P)U(P)" {_A_ 2 _U_ 22 _N_ _N_ _F_ _IF_ARGS_ 0 2 XX 1 \ (u0 :: Int#) (u1 :: Int#) -> _#_ gtInt# [] [u0, u1] _N_} _F_ _IF_ARGS_ 0 2 CC 3 \ (u0 :: Int) (u1 :: Int) -> case u0 of { _ALG_ I# (u2 :: Int#) -> case u1 of { _ALG_ I# (u3 :: Int#) -> _#_ gtInt# [] [u2, u3]; _NO_DEFLT_ }; _NO_DEFLT_ } _N_,
- max = _A_ 2 _U_ 11 _N_ _S_ "U(P)U(P)" {_A_ 2 _U_ 22 _N_ _N_ _N_ _N_} _N_ _N_,
- min = _A_ 2 _U_ 11 _N_ _S_ "U(P)U(P)" {_A_ 2 _U_ 22 _N_ _N_ _N_ _N_} _N_ _N_,
- _tagCmp = _A_ 2 _U_ 11 _N_ _S_ "U(P)U(P)" {_A_ 2 _U_ 22 _N_ _N_ _N_ _N_} _N_ _N_ #-}
+ (<) = { _A_ 2 _U_ 11 _N_ _S_ "U(P)U(P)" {_A_ 2 _U_ 22 _N_ _N_ _F_ _IF_ARGS_ 0 2 XX 1 \ (u0 :: Int#) (u1 :: Int#) -> _#_ ltInt# [] [u0, u1] _N_} _F_ _IF_ARGS_ 0 2 CC 3 \ (u0 :: Int) (u1 :: Int) -> case u0 of { _ALG_ I# (u2 :: Int#) -> case u1 of { _ALG_ I# (u3 :: Int#) -> _#_ ltInt# [] [u2, u3]; _NO_DEFLT_ }; _NO_DEFLT_ } _N_ },
+ (<=) = { _A_ 2 _U_ 11 _N_ _S_ "U(P)U(P)" {_A_ 2 _U_ 22 _N_ _N_ _F_ _IF_ARGS_ 0 2 XX 1 \ (u0 :: Int#) (u1 :: Int#) -> _#_ leInt# [] [u0, u1] _N_} _F_ _IF_ARGS_ 0 2 CC 3 \ (u0 :: Int) (u1 :: Int) -> case u0 of { _ALG_ I# (u2 :: Int#) -> case u1 of { _ALG_ I# (u3 :: Int#) -> _#_ leInt# [] [u2, u3]; _NO_DEFLT_ }; _NO_DEFLT_ } _N_ },
+ (>=) = { _A_ 2 _U_ 11 _N_ _S_ "U(P)U(P)" {_A_ 2 _U_ 22 _N_ _N_ _F_ _IF_ARGS_ 0 2 XX 1 \ (u0 :: Int#) (u1 :: Int#) -> _#_ geInt# [] [u0, u1] _N_} _F_ _IF_ARGS_ 0 2 CC 3 \ (u0 :: Int) (u1 :: Int) -> case u0 of { _ALG_ I# (u2 :: Int#) -> case u1 of { _ALG_ I# (u3 :: Int#) -> _#_ geInt# [] [u2, u3]; _NO_DEFLT_ }; _NO_DEFLT_ } _N_ },
+ (>) = { _A_ 2 _U_ 11 _N_ _S_ "U(P)U(P)" {_A_ 2 _U_ 22 _N_ _N_ _F_ _IF_ARGS_ 0 2 XX 1 \ (u0 :: Int#) (u1 :: Int#) -> _#_ gtInt# [] [u0, u1] _N_} _F_ _IF_ARGS_ 0 2 CC 3 \ (u0 :: Int) (u1 :: Int) -> case u0 of { _ALG_ I# (u2 :: Int#) -> case u1 of { _ALG_ I# (u3 :: Int#) -> _#_ gtInt# [] [u2, u3]; _NO_DEFLT_ }; _NO_DEFLT_ } _N_ },
+ max = { _A_ 2 _U_ 11 _N_ _S_ "U(P)U(P)" {_A_ 2 _U_ 22 _N_ _N_ _N_ _N_} _N_ _N_ },
+ min = { _A_ 2 _U_ 11 _N_ _S_ "U(P)U(P)" {_A_ 2 _U_ 22 _N_ _N_ _N_ _N_} _N_ _N_ },
+ _tagCmp = { _A_ 2 _U_ 11 _N_ _S_ "U(P)U(P)" {_A_ 2 _U_ 22 _N_ _N_ _N_ _N_} _N_ _N_ } #-}
instance Ord Integer
{-# GHC_PRAGMA _M_ PreludeCore {-dfun-} _A_ 0 _N_ _N_ _N_ _F_ _IF_ARGS_ 0 0 X 9 _!_ _TUP_8 [{{Eq Integer}}, (Integer -> Integer -> Bool), (Integer -> Integer -> Bool), (Integer -> Integer -> Bool), (Integer -> Integer -> Bool), (Integer -> Integer -> Integer), (Integer -> Integer -> Integer), (Integer -> Integer -> _CMP_TAG)] [_DFUN_ Eq (Integer), _CONSTM_ Ord (<) (Integer), _CONSTM_ Ord (<=) (Integer), _CONSTM_ Ord (>=) (Integer), _CONSTM_ Ord (>) (Integer), _CONSTM_ Ord max (Integer), _CONSTM_ Ord min (Integer), _CONSTM_ Ord _tagCmp (Integer)] _N_
- (<) = _A_ 2 _U_ 11 _N_ _S_ "U(PPP)U(PPP)" {_A_ 4 _U_ 2221 _N_ _N_ _F_ _IF_ARGS_ 0 4 XXXC 3 \ (u0 :: Int#) (u1 :: Int#) (u2 :: ByteArray#) (u3 :: Integer) -> case u3 of { _ALG_ J# (u4 :: Int#) (u5 :: Int#) (u6 :: ByteArray#) -> case _#_ cmpInteger# [] [u0, u1, u2, u4, u5, u6] of { _PRIM_ (u7 :: Int#) -> _#_ ltInt# [] [u7, 0#] }; _NO_DEFLT_ } _N_} _F_ _IF_ARGS_ 0 2 CC 4 \ (u0 :: Integer) (u1 :: Integer) -> case u0 of { _ALG_ J# (u2 :: Int#) (u3 :: Int#) (u4 :: ByteArray#) -> case u1 of { _ALG_ J# (u5 :: Int#) (u6 :: Int#) (u7 :: ByteArray#) -> case _#_ cmpInteger# [] [u2, u3, u4, u5, u6, u7] of { _PRIM_ (u8 :: Int#) -> _#_ ltInt# [] [u8, 0#] }; _NO_DEFLT_ }; _NO_DEFLT_ } _N_,
- (<=) = _A_ 2 _U_ 11 _N_ _S_ "U(PPP)U(PPP)" {_A_ 4 _U_ 2221 _N_ _N_ _F_ _IF_ARGS_ 0 4 XXXC 3 \ (u0 :: Int#) (u1 :: Int#) (u2 :: ByteArray#) (u3 :: Integer) -> case u3 of { _ALG_ J# (u4 :: Int#) (u5 :: Int#) (u6 :: ByteArray#) -> case _#_ cmpInteger# [] [u0, u1, u2, u4, u5, u6] of { _PRIM_ (u7 :: Int#) -> _#_ leInt# [] [u7, 0#] }; _NO_DEFLT_ } _N_} _F_ _IF_ARGS_ 0 2 CC 4 \ (u0 :: Integer) (u1 :: Integer) -> case u0 of { _ALG_ J# (u2 :: Int#) (u3 :: Int#) (u4 :: ByteArray#) -> case u1 of { _ALG_ J# (u5 :: Int#) (u6 :: Int#) (u7 :: ByteArray#) -> case _#_ cmpInteger# [] [u2, u3, u4, u5, u6, u7] of { _PRIM_ (u8 :: Int#) -> _#_ leInt# [] [u8, 0#] }; _NO_DEFLT_ }; _NO_DEFLT_ } _N_,
- (>=) = _A_ 2 _U_ 11 _N_ _S_ "U(PPP)U(PPP)" {_A_ 4 _U_ 2221 _N_ _N_ _F_ _IF_ARGS_ 0 4 XXXC 3 \ (u0 :: Int#) (u1 :: Int#) (u2 :: ByteArray#) (u3 :: Integer) -> case u3 of { _ALG_ J# (u4 :: Int#) (u5 :: Int#) (u6 :: ByteArray#) -> case _#_ cmpInteger# [] [u0, u1, u2, u4, u5, u6] of { _PRIM_ (u7 :: Int#) -> _#_ geInt# [] [u7, 0#] }; _NO_DEFLT_ } _N_} _F_ _IF_ARGS_ 0 2 CC 4 \ (u0 :: Integer) (u1 :: Integer) -> case u0 of { _ALG_ J# (u2 :: Int#) (u3 :: Int#) (u4 :: ByteArray#) -> case u1 of { _ALG_ J# (u5 :: Int#) (u6 :: Int#) (u7 :: ByteArray#) -> case _#_ cmpInteger# [] [u2, u3, u4, u5, u6, u7] of { _PRIM_ (u8 :: Int#) -> _#_ geInt# [] [u8, 0#] }; _NO_DEFLT_ }; _NO_DEFLT_ } _N_,
- (>) = _A_ 2 _U_ 11 _N_ _S_ "U(PPP)U(PPP)" {_A_ 4 _U_ 2221 _N_ _N_ _F_ _IF_ARGS_ 0 4 XXXC 3 \ (u0 :: Int#) (u1 :: Int#) (u2 :: ByteArray#) (u3 :: Integer) -> case u3 of { _ALG_ J# (u4 :: Int#) (u5 :: Int#) (u6 :: ByteArray#) -> case _#_ cmpInteger# [] [u0, u1, u2, u4, u5, u6] of { _PRIM_ (u7 :: Int#) -> _#_ gtInt# [] [u7, 0#] }; _NO_DEFLT_ } _N_} _F_ _IF_ARGS_ 0 2 CC 4 \ (u0 :: Integer) (u1 :: Integer) -> case u0 of { _ALG_ J# (u2 :: Int#) (u3 :: Int#) (u4 :: ByteArray#) -> case u1 of { _ALG_ J# (u5 :: Int#) (u6 :: Int#) (u7 :: ByteArray#) -> case _#_ cmpInteger# [] [u2, u3, u4, u5, u6, u7] of { _PRIM_ (u8 :: Int#) -> _#_ gtInt# [] [u8, 0#] }; _NO_DEFLT_ }; _NO_DEFLT_ } _N_,
- max = _A_ 2 _U_ 11 _N_ _S_ "U(PPP)U(PPP)" {_A_ 4 _U_ 2221 _N_ _N_ _N_ _N_} _N_ _N_,
- min = _A_ 2 _U_ 11 _N_ _S_ "U(PPP)U(PPP)" {_A_ 4 _U_ 2221 _N_ _N_ _N_ _N_} _N_ _N_,
- _tagCmp = _A_ 2 _U_ 11 _N_ _S_ "U(PPP)U(PPP)" {_A_ 4 _U_ 2221 _N_ _N_ _N_ _N_} _N_ _N_ #-}
+ (<) = { _A_ 2 _U_ 11 _N_ _S_ "U(PPP)U(PPP)" {_A_ 4 _U_ 2221 _N_ _N_ _F_ _IF_ARGS_ 0 4 XXXC 3 \ (u0 :: Int#) (u1 :: Int#) (u2 :: ByteArray#) (u3 :: Integer) -> case u3 of { _ALG_ J# (u4 :: Int#) (u5 :: Int#) (u6 :: ByteArray#) -> case _#_ cmpInteger# [] [u0, u1, u2, u4, u5, u6] of { _PRIM_ (u7 :: Int#) -> _#_ ltInt# [] [u7, 0#] }; _NO_DEFLT_ } _N_} _F_ _IF_ARGS_ 0 2 CC 4 \ (u0 :: Integer) (u1 :: Integer) -> case u0 of { _ALG_ J# (u2 :: Int#) (u3 :: Int#) (u4 :: ByteArray#) -> case u1 of { _ALG_ J# (u5 :: Int#) (u6 :: Int#) (u7 :: ByteArray#) -> case _#_ cmpInteger# [] [u2, u3, u4, u5, u6, u7] of { _PRIM_ (u8 :: Int#) -> _#_ ltInt# [] [u8, 0#] }; _NO_DEFLT_ }; _NO_DEFLT_ } _N_ },
+ (<=) = { _A_ 2 _U_ 11 _N_ _S_ "U(PPP)U(PPP)" {_A_ 4 _U_ 2221 _N_ _N_ _F_ _IF_ARGS_ 0 4 XXXC 3 \ (u0 :: Int#) (u1 :: Int#) (u2 :: ByteArray#) (u3 :: Integer) -> case u3 of { _ALG_ J# (u4 :: Int#) (u5 :: Int#) (u6 :: ByteArray#) -> case _#_ cmpInteger# [] [u0, u1, u2, u4, u5, u6] of { _PRIM_ (u7 :: Int#) -> _#_ leInt# [] [u7, 0#] }; _NO_DEFLT_ } _N_} _F_ _IF_ARGS_ 0 2 CC 4 \ (u0 :: Integer) (u1 :: Integer) -> case u0 of { _ALG_ J# (u2 :: Int#) (u3 :: Int#) (u4 :: ByteArray#) -> case u1 of { _ALG_ J# (u5 :: Int#) (u6 :: Int#) (u7 :: ByteArray#) -> case _#_ cmpInteger# [] [u2, u3, u4, u5, u6, u7] of { _PRIM_ (u8 :: Int#) -> _#_ leInt# [] [u8, 0#] }; _NO_DEFLT_ }; _NO_DEFLT_ } _N_ },
+ (>=) = { _A_ 2 _U_ 11 _N_ _S_ "U(PPP)U(PPP)" {_A_ 4 _U_ 2221 _N_ _N_ _F_ _IF_ARGS_ 0 4 XXXC 3 \ (u0 :: Int#) (u1 :: Int#) (u2 :: ByteArray#) (u3 :: Integer) -> case u3 of { _ALG_ J# (u4 :: Int#) (u5 :: Int#) (u6 :: ByteArray#) -> case _#_ cmpInteger# [] [u0, u1, u2, u4, u5, u6] of { _PRIM_ (u7 :: Int#) -> _#_ geInt# [] [u7, 0#] }; _NO_DEFLT_ } _N_} _F_ _IF_ARGS_ 0 2 CC 4 \ (u0 :: Integer) (u1 :: Integer) -> case u0 of { _ALG_ J# (u2 :: Int#) (u3 :: Int#) (u4 :: ByteArray#) -> case u1 of { _ALG_ J# (u5 :: Int#) (u6 :: Int#) (u7 :: ByteArray#) -> case _#_ cmpInteger# [] [u2, u3, u4, u5, u6, u7] of { _PRIM_ (u8 :: Int#) -> _#_ geInt# [] [u8, 0#] }; _NO_DEFLT_ }; _NO_DEFLT_ } _N_ },
+ (>) = { _A_ 2 _U_ 11 _N_ _S_ "U(PPP)U(PPP)" {_A_ 4 _U_ 2221 _N_ _N_ _F_ _IF_ARGS_ 0 4 XXXC 3 \ (u0 :: Int#) (u1 :: Int#) (u2 :: ByteArray#) (u3 :: Integer) -> case u3 of { _ALG_ J# (u4 :: Int#) (u5 :: Int#) (u6 :: ByteArray#) -> case _#_ cmpInteger# [] [u0, u1, u2, u4, u5, u6] of { _PRIM_ (u7 :: Int#) -> _#_ gtInt# [] [u7, 0#] }; _NO_DEFLT_ } _N_} _F_ _IF_ARGS_ 0 2 CC 4 \ (u0 :: Integer) (u1 :: Integer) -> case u0 of { _ALG_ J# (u2 :: Int#) (u3 :: Int#) (u4 :: ByteArray#) -> case u1 of { _ALG_ J# (u5 :: Int#) (u6 :: Int#) (u7 :: ByteArray#) -> case _#_ cmpInteger# [] [u2, u3, u4, u5, u6, u7] of { _PRIM_ (u8 :: Int#) -> _#_ gtInt# [] [u8, 0#] }; _NO_DEFLT_ }; _NO_DEFLT_ } _N_ },
+ max = { _A_ 2 _U_ 11 _N_ _S_ "U(PPP)U(PPP)" {_A_ 4 _U_ 2221 _N_ _N_ _N_ _N_} _N_ _N_ },
+ min = { _A_ 2 _U_ 11 _N_ _S_ "U(PPP)U(PPP)" {_A_ 4 _U_ 2221 _N_ _N_ _N_ _N_} _N_ _N_ },
+ _tagCmp = { _A_ 2 _U_ 11 _N_ _S_ "U(PPP)U(PPP)" {_A_ 4 _U_ 2221 _N_ _N_ _N_ _N_} _N_ _N_ } #-}
instance Ord a => Ord (Maybe a)
{-# GHC_PRAGMA _M_ PreludeStdIO {-dfun-} _A_ 2 _U_ 22 _N_ _N_ _N_ _N_ #-}
instance Integral a => Ord (Ratio a)
{-# GHC_PRAGMA _M_ PreludeRatio {-dfun-} _A_ 2 _U_ 22 _N_ _N_ _N_ _N_ #-}
instance Ord (Ratio Integer)
{-# GHC_PRAGMA _M_ PreludeRatio {-dfun-} _A_ 0 _N_ _N_ _N_ _F_ _IF_ARGS_ 0 0 X 9 _!_ _TUP_8 [{{Eq (Ratio Integer)}}, (Ratio Integer -> Ratio Integer -> Bool), (Ratio Integer -> Ratio Integer -> Bool), (Ratio Integer -> Ratio Integer -> Bool), (Ratio Integer -> Ratio Integer -> Bool), (Ratio Integer -> Ratio Integer -> Ratio Integer), (Ratio Integer -> Ratio Integer -> Ratio Integer), (Ratio Integer -> Ratio Integer -> _CMP_TAG)] [_DFUN_ Eq (Ratio Integer), _CONSTM_ Ord (<) (Ratio Integer), _CONSTM_ Ord (<=) (Ratio Integer), _CONSTM_ Ord (>=) (Ratio Integer), _CONSTM_ Ord (>) (Ratio Integer), _CONSTM_ Ord max (Ratio Integer), _CONSTM_ Ord min (Ratio Integer), _CONSTM_ Ord _tagCmp (Ratio Integer)] _N_
- (<) = _A_ 2 _U_ 11 _N_ _S_ "U(U(PPP)U(PPP))U(U(PPP)U(PPP))" {_A_ 5 _U_ 22221 _N_ _N_ _N_ _N_} _N_ _N_,
- (<=) = _A_ 2 _U_ 11 _N_ _S_ "U(U(PPP)U(PPP))U(U(PPP)U(PPP))" {_A_ 5 _U_ 22221 _N_ _N_ _N_ _N_} _N_ _N_,
- (>=) = _A_ 2 _U_ 11 _N_ _S_ "U(U(PPP)U(PPP))U(U(PPP)U(PPP))" {_A_ 5 _U_ 22221 _N_ _N_ _N_ _N_} _N_ _N_,
- (>) = _A_ 2 _U_ 11 _N_ _S_ "U(U(PPP)U(PPP))U(U(PPP)U(PPP))" {_A_ 5 _U_ 22221 _N_ _N_ _N_ _N_} _N_ _N_,
- max = _A_ 2 _U_ 12 _N_ _S_ "U(U(PPP)U(PPP))U(U(PPP)U(PPP))" {_A_ 5 _U_ 22222 _N_ _N_ _N_ _N_} _N_ _N_,
- min = _A_ 2 _U_ 12 _N_ _S_ "U(U(PPP)U(PPP))U(U(PPP)U(PPP))" {_A_ 5 _U_ 22222 _N_ _N_ _N_ _N_} _N_ _N_,
- _tagCmp = _A_ 2 _U_ 11 _N_ _S_ "U(U(PPP)U(PPP))U(U(PPP)U(PPP))" {_A_ 5 _U_ 22221 _N_ _N_ _N_ _N_} _N_ _N_ #-}
+ (<) = { _A_ 2 _U_ 11 _N_ _S_ "U(U(PPP)U(PPP))U(U(PPP)U(PPP))" {_A_ 5 _U_ 22221 _N_ _N_ _N_ _N_} _N_ _N_ },
+ (<=) = { _A_ 2 _U_ 11 _N_ _S_ "U(U(PPP)U(PPP))U(U(PPP)U(PPP))" {_A_ 5 _U_ 22221 _N_ _N_ _N_ _N_} _N_ _N_ },
+ (>=) = { _A_ 2 _U_ 11 _N_ _S_ "U(U(PPP)U(PPP))U(U(PPP)U(PPP))" {_A_ 5 _U_ 22221 _N_ _N_ _N_ _N_} _N_ _N_ },
+ (>) = { _A_ 2 _U_ 11 _N_ _S_ "U(U(PPP)U(PPP))U(U(PPP)U(PPP))" {_A_ 5 _U_ 22221 _N_ _N_ _N_ _N_} _N_ _N_ },
+ max = { _A_ 2 _U_ 12 _N_ _S_ "U(U(PPP)U(PPP))U(U(PPP)U(PPP))" {_A_ 5 _U_ 22222 _N_ _N_ _N_ _N_} _N_ _N_ },
+ min = { _A_ 2 _U_ 12 _N_ _S_ "U(U(PPP)U(PPP))U(U(PPP)U(PPP))" {_A_ 5 _U_ 22222 _N_ _N_ _N_ _N_} _N_ _N_ },
+ _tagCmp = { _A_ 2 _U_ 11 _N_ _S_ "U(U(PPP)U(PPP))U(U(PPP)U(PPP))" {_A_ 5 _U_ 22221 _N_ _N_ _N_ _N_} _N_ _N_ } #-}
instance Ord a => Ord [a]
{-# GHC_PRAGMA _M_ PreludeBuiltin {-dfun-} _A_ 2 _U_ 12 _N_ _N_ _N_ _N_ #-}
+instance Ord [Bool]
+ {-# GHC_PRAGMA _M_ PreludeBuiltin {-dfun-} _A_ 0 _N_ _N_ _N_ _F_ _IF_ARGS_ 0 0 X 9 _!_ _TUP_8 [{{Eq [Bool]}}, ([Bool] -> [Bool] -> Bool), ([Bool] -> [Bool] -> Bool), ([Bool] -> [Bool] -> Bool), ([Bool] -> [Bool] -> Bool), ([Bool] -> [Bool] -> [Bool]), ([Bool] -> [Bool] -> [Bool]), ([Bool] -> [Bool] -> _CMP_TAG)] [_DFUN_ Eq ([Bool]), _CONSTM_ Ord (<) ([Bool]), _CONSTM_ Ord (<=) ([Bool]), _CONSTM_ Ord (>=) ([Bool]), _CONSTM_ Ord (>) ([Bool]), _CONSTM_ Ord max ([Bool]), _CONSTM_ Ord min ([Bool]), _CONSTM_ Ord _tagCmp ([Bool])] _N_
+ (<) = { _A_ 2 _U_ 11 _N_ _S_ "SS" _N_ _N_ },
+ (<=) = { _A_ 2 _U_ 11 _N_ _S_ "SS" _N_ _N_ },
+ (>=) = { _A_ 2 _U_ 11 _N_ _S_ "SS" _N_ _N_ },
+ (>) = { _A_ 2 _U_ 11 _N_ _S_ "SS" _N_ _N_ },
+ max = { _A_ 2 _U_ 22 _N_ _S_ "SS" _N_ _N_ },
+ min = { _A_ 2 _U_ 22 _N_ _S_ "SS" _N_ _N_ },
+ _tagCmp = { _A_ 2 _U_ 11 _N_ _S_ "SS" _N_ _N_ } #-}
instance Ord [Char]
{-# GHC_PRAGMA _M_ PreludeBuiltin {-dfun-} _A_ 0 _N_ _N_ _N_ _F_ _IF_ARGS_ 0 0 X 9 _!_ _TUP_8 [{{Eq [Char]}}, ([Char] -> [Char] -> Bool), ([Char] -> [Char] -> Bool), ([Char] -> [Char] -> Bool), ([Char] -> [Char] -> Bool), ([Char] -> [Char] -> [Char]), ([Char] -> [Char] -> [Char]), ([Char] -> [Char] -> _CMP_TAG)] [_DFUN_ Eq ([Char]), _CONSTM_ Ord (<) ([Char]), _CONSTM_ Ord (<=) ([Char]), _CONSTM_ Ord (>=) ([Char]), _CONSTM_ Ord (>) ([Char]), _CONSTM_ Ord max ([Char]), _CONSTM_ Ord min ([Char]), _CONSTM_ Ord _tagCmp ([Char])] _N_
- (<) = _A_ 2 _U_ 11 _N_ _S_ "SS" _N_ _N_,
- (<=) = _A_ 2 _U_ 11 _N_ _S_ "SS" _N_ _N_,
- (>=) = _A_ 2 _U_ 11 _N_ _S_ "SS" _N_ _N_,
- (>) = _A_ 2 _U_ 11 _N_ _S_ "SS" _N_ _N_,
- max = _A_ 2 _U_ 22 _N_ _S_ "SS" _N_ _N_,
- min = _A_ 2 _U_ 22 _N_ _S_ "SS" _N_ _N_,
- _tagCmp = _A_ 2 _U_ 11 _N_ _S_ "SS" _N_ _N_ #-}
+ (<) = { _A_ 2 _U_ 11 _N_ _S_ "SS" _N_ _N_ },
+ (<=) = { _A_ 2 _U_ 11 _N_ _S_ "SS" _N_ _N_ },
+ (>=) = { _A_ 2 _U_ 11 _N_ _S_ "SS" _N_ _N_ },
+ (>) = { _A_ 2 _U_ 11 _N_ _S_ "SS" _N_ _N_ },
+ max = { _A_ 2 _U_ 22 _N_ _S_ "SS" _N_ _N_ },
+ min = { _A_ 2 _U_ 22 _N_ _S_ "SS" _N_ _N_ },
+ _tagCmp = { _A_ 2 _U_ 11 _N_ _S_ "SS" _N_ _N_ } #-}
+instance Ord [Double]
+ {-# GHC_PRAGMA _M_ PreludeBuiltin {-dfun-} _A_ 0 _N_ _N_ _N_ _F_ _IF_ARGS_ 0 0 X 9 _!_ _TUP_8 [{{Eq [Double]}}, ([Double] -> [Double] -> Bool), ([Double] -> [Double] -> Bool), ([Double] -> [Double] -> Bool), ([Double] -> [Double] -> Bool), ([Double] -> [Double] -> [Double]), ([Double] -> [Double] -> [Double]), ([Double] -> [Double] -> _CMP_TAG)] [_DFUN_ Eq ([Double]), _CONSTM_ Ord (<) ([Double]), _CONSTM_ Ord (<=) ([Double]), _CONSTM_ Ord (>=) ([Double]), _CONSTM_ Ord (>) ([Double]), _CONSTM_ Ord max ([Double]), _CONSTM_ Ord min ([Double]), _CONSTM_ Ord _tagCmp ([Double])] _N_
+ (<) = { _A_ 2 _U_ 11 _N_ _S_ "SS" _N_ _N_ },
+ (<=) = { _A_ 2 _U_ 11 _N_ _S_ "SS" _N_ _N_ },
+ (>=) = { _A_ 2 _U_ 11 _N_ _S_ "SS" _N_ _N_ },
+ (>) = { _A_ 2 _U_ 11 _N_ _S_ "SS" _N_ _N_ },
+ max = { _A_ 2 _U_ 22 _N_ _S_ "SS" _N_ _N_ },
+ min = { _A_ 2 _U_ 22 _N_ _S_ "SS" _N_ _N_ },
+ _tagCmp = { _A_ 2 _U_ 11 _N_ _S_ "SS" _N_ _N_ } #-}
instance Ord [Int]
{-# GHC_PRAGMA _M_ PreludeBuiltin {-dfun-} _A_ 0 _N_ _N_ _N_ _F_ _IF_ARGS_ 0 0 X 9 _!_ _TUP_8 [{{Eq [Int]}}, ([Int] -> [Int] -> Bool), ([Int] -> [Int] -> Bool), ([Int] -> [Int] -> Bool), ([Int] -> [Int] -> Bool), ([Int] -> [Int] -> [Int]), ([Int] -> [Int] -> [Int]), ([Int] -> [Int] -> _CMP_TAG)] [_DFUN_ Eq ([Int]), _CONSTM_ Ord (<) ([Int]), _CONSTM_ Ord (<=) ([Int]), _CONSTM_ Ord (>=) ([Int]), _CONSTM_ Ord (>) ([Int]), _CONSTM_ Ord max ([Int]), _CONSTM_ Ord min ([Int]), _CONSTM_ Ord _tagCmp ([Int])] _N_
- (<) = _A_ 2 _U_ 11 _N_ _S_ "SS" _N_ _N_,
- (<=) = _A_ 2 _U_ 11 _N_ _S_ "SS" _N_ _N_,
- (>=) = _A_ 2 _U_ 11 _N_ _S_ "SS" _N_ _N_,
- (>) = _A_ 2 _U_ 11 _N_ _S_ "SS" _N_ _N_,
- max = _A_ 2 _U_ 22 _N_ _S_ "SS" _N_ _N_,
- min = _A_ 2 _U_ 22 _N_ _S_ "SS" _N_ _N_,
- _tagCmp = _A_ 2 _U_ 11 _N_ _S_ "SS" _N_ _N_ #-}
+ (<) = { _A_ 2 _U_ 11 _N_ _S_ "SS" _N_ _N_ },
+ (<=) = { _A_ 2 _U_ 11 _N_ _S_ "SS" _N_ _N_ },
+ (>=) = { _A_ 2 _U_ 11 _N_ _S_ "SS" _N_ _N_ },
+ (>) = { _A_ 2 _U_ 11 _N_ _S_ "SS" _N_ _N_ },
+ max = { _A_ 2 _U_ 22 _N_ _S_ "SS" _N_ _N_ },
+ min = { _A_ 2 _U_ 22 _N_ _S_ "SS" _N_ _N_ },
+ _tagCmp = { _A_ 2 _U_ 11 _N_ _S_ "SS" _N_ _N_ } #-}
+instance Ord [Integer]
+ {-# GHC_PRAGMA _M_ PreludeBuiltin {-dfun-} _A_ 0 _N_ _N_ _N_ _F_ _IF_ARGS_ 0 0 X 9 _!_ _TUP_8 [{{Eq [Integer]}}, ([Integer] -> [Integer] -> Bool), ([Integer] -> [Integer] -> Bool), ([Integer] -> [Integer] -> Bool), ([Integer] -> [Integer] -> Bool), ([Integer] -> [Integer] -> [Integer]), ([Integer] -> [Integer] -> [Integer]), ([Integer] -> [Integer] -> _CMP_TAG)] [_DFUN_ Eq ([Integer]), _CONSTM_ Ord (<) ([Integer]), _CONSTM_ Ord (<=) ([Integer]), _CONSTM_ Ord (>=) ([Integer]), _CONSTM_ Ord (>) ([Integer]), _CONSTM_ Ord max ([Integer]), _CONSTM_ Ord min ([Integer]), _CONSTM_ Ord _tagCmp ([Integer])] _N_
+ (<) = { _A_ 2 _U_ 11 _N_ _S_ "SS" _N_ _N_ },
+ (<=) = { _A_ 2 _U_ 11 _N_ _S_ "SS" _N_ _N_ },
+ (>=) = { _A_ 2 _U_ 11 _N_ _S_ "SS" _N_ _N_ },
+ (>) = { _A_ 2 _U_ 11 _N_ _S_ "SS" _N_ _N_ },
+ max = { _A_ 2 _U_ 22 _N_ _S_ "SS" _N_ _N_ },
+ min = { _A_ 2 _U_ 22 _N_ _S_ "SS" _N_ _N_ },
+ _tagCmp = { _A_ 2 _U_ 11 _N_ _S_ "SS" _N_ _N_ } #-}
+instance Ord [[Char]]
+ {-# GHC_PRAGMA _M_ PreludeBuiltin {-dfun-} _A_ 0 _N_ _N_ _N_ _F_ _IF_ARGS_ 0 0 X 9 _!_ _TUP_8 [{{Eq [[Char]]}}, ([[Char]] -> [[Char]] -> Bool), ([[Char]] -> [[Char]] -> Bool), ([[Char]] -> [[Char]] -> Bool), ([[Char]] -> [[Char]] -> Bool), ([[Char]] -> [[Char]] -> [[Char]]), ([[Char]] -> [[Char]] -> [[Char]]), ([[Char]] -> [[Char]] -> _CMP_TAG)] [_DFUN_ Eq ([[Char]]), _CONSTM_ Ord (<) ([[Char]]), _CONSTM_ Ord (<=) ([[Char]]), _CONSTM_ Ord (>=) ([[Char]]), _CONSTM_ Ord (>) ([[Char]]), _CONSTM_ Ord max ([[Char]]), _CONSTM_ Ord min ([[Char]]), _CONSTM_ Ord _tagCmp ([[Char]])] _N_
+ (<) = { _A_ 2 _U_ 11 _N_ _S_ "SS" _N_ _N_ },
+ (<=) = { _A_ 2 _U_ 11 _N_ _S_ "SS" _N_ _N_ },
+ (>=) = { _A_ 2 _U_ 11 _N_ _S_ "SS" _N_ _N_ },
+ (>) = { _A_ 2 _U_ 11 _N_ _S_ "SS" _N_ _N_ },
+ max = { _A_ 2 _U_ 22 _N_ _S_ "SS" _N_ _N_ },
+ min = { _A_ 2 _U_ 22 _N_ _S_ "SS" _N_ _N_ },
+ _tagCmp = { _A_ 2 _U_ 11 _N_ _S_ "SS" _N_ _N_ } #-}
+instance Ord [[Int]]
+ {-# GHC_PRAGMA _M_ PreludeBuiltin {-dfun-} _A_ 0 _N_ _N_ _N_ _F_ _IF_ARGS_ 0 0 X 9 _!_ _TUP_8 [{{Eq [[Int]]}}, ([[Int]] -> [[Int]] -> Bool), ([[Int]] -> [[Int]] -> Bool), ([[Int]] -> [[Int]] -> Bool), ([[Int]] -> [[Int]] -> Bool), ([[Int]] -> [[Int]] -> [[Int]]), ([[Int]] -> [[Int]] -> [[Int]]), ([[Int]] -> [[Int]] -> _CMP_TAG)] [_DFUN_ Eq ([[Int]]), _CONSTM_ Ord (<) ([[Int]]), _CONSTM_ Ord (<=) ([[Int]]), _CONSTM_ Ord (>=) ([[Int]]), _CONSTM_ Ord (>) ([[Int]]), _CONSTM_ Ord max ([[Int]]), _CONSTM_ Ord min ([[Int]]), _CONSTM_ Ord _tagCmp ([[Int]])] _N_
+ (<) = { _A_ 2 _U_ 11 _N_ _S_ "SS" _N_ _N_ },
+ (<=) = { _A_ 2 _U_ 11 _N_ _S_ "SS" _N_ _N_ },
+ (>=) = { _A_ 2 _U_ 11 _N_ _S_ "SS" _N_ _N_ },
+ (>) = { _A_ 2 _U_ 11 _N_ _S_ "SS" _N_ _N_ },
+ max = { _A_ 2 _U_ 22 _N_ _S_ "SS" _N_ _N_ },
+ min = { _A_ 2 _U_ 22 _N_ _S_ "SS" _N_ _N_ },
+ _tagCmp = { _A_ 2 _U_ 11 _N_ _S_ "SS" _N_ _N_ } #-}
instance Ord _Addr
{-# GHC_PRAGMA _M_ PreludeCore {-dfun-} _A_ 0 _N_ _N_ _N_ _F_ _IF_ARGS_ 0 0 X 9 _!_ _TUP_8 [{{Eq _Addr}}, (_Addr -> _Addr -> Bool), (_Addr -> _Addr -> Bool), (_Addr -> _Addr -> Bool), (_Addr -> _Addr -> Bool), (_Addr -> _Addr -> _Addr), (_Addr -> _Addr -> _Addr), (_Addr -> _Addr -> _CMP_TAG)] [_DFUN_ Eq (_Addr), _CONSTM_ Ord (<) (_Addr), _CONSTM_ Ord (<=) (_Addr), _CONSTM_ Ord (>=) (_Addr), _CONSTM_ Ord (>) (_Addr), _CONSTM_ Ord max (_Addr), _CONSTM_ Ord min (_Addr), _CONSTM_ Ord _tagCmp (_Addr)] _N_
- (<) = _A_ 2 _U_ 11 _N_ _S_ "U(P)U(P)" {_A_ 2 _U_ 22 _N_ _N_ _F_ _IF_ARGS_ 0 2 XX 1 \ (u0 :: Addr#) (u1 :: Addr#) -> _#_ ltAddr# [] [u0, u1] _N_} _F_ _IF_ARGS_ 0 2 CC 3 \ (u0 :: _Addr) (u1 :: _Addr) -> case u0 of { _ALG_ A# (u2 :: Addr#) -> case u1 of { _ALG_ A# (u3 :: Addr#) -> _#_ ltAddr# [] [u2, u3]; _NO_DEFLT_ }; _NO_DEFLT_ } _N_,
- (<=) = _A_ 2 _U_ 11 _N_ _S_ "U(P)U(P)" {_A_ 2 _U_ 22 _N_ _N_ _F_ _IF_ARGS_ 0 2 XX 1 \ (u0 :: Addr#) (u1 :: Addr#) -> _#_ leAddr# [] [u0, u1] _N_} _F_ _IF_ARGS_ 0 2 CC 3 \ (u0 :: _Addr) (u1 :: _Addr) -> case u0 of { _ALG_ A# (u2 :: Addr#) -> case u1 of { _ALG_ A# (u3 :: Addr#) -> _#_ leAddr# [] [u2, u3]; _NO_DEFLT_ }; _NO_DEFLT_ } _N_,
- (>=) = _A_ 2 _U_ 11 _N_ _S_ "U(P)U(P)" {_A_ 2 _U_ 22 _N_ _N_ _F_ _IF_ARGS_ 0 2 XX 1 \ (u0 :: Addr#) (u1 :: Addr#) -> _#_ geAddr# [] [u0, u1] _N_} _F_ _IF_ARGS_ 0 2 CC 3 \ (u0 :: _Addr) (u1 :: _Addr) -> case u0 of { _ALG_ A# (u2 :: Addr#) -> case u1 of { _ALG_ A# (u3 :: Addr#) -> _#_ geAddr# [] [u2, u3]; _NO_DEFLT_ }; _NO_DEFLT_ } _N_,
- (>) = _A_ 2 _U_ 11 _N_ _S_ "U(P)U(P)" {_A_ 2 _U_ 22 _N_ _N_ _F_ _IF_ARGS_ 0 2 XX 1 \ (u0 :: Addr#) (u1 :: Addr#) -> _#_ gtAddr# [] [u0, u1] _N_} _F_ _IF_ARGS_ 0 2 CC 3 \ (u0 :: _Addr) (u1 :: _Addr) -> case u0 of { _ALG_ A# (u2 :: Addr#) -> case u1 of { _ALG_ A# (u3 :: Addr#) -> _#_ gtAddr# [] [u2, u3]; _NO_DEFLT_ }; _NO_DEFLT_ } _N_,
- max = _A_ 2 _U_ 11 _N_ _S_ "U(P)U(P)" {_A_ 2 _U_ 22 _N_ _N_ _N_ _N_} _N_ _N_,
- min = _A_ 2 _U_ 11 _N_ _S_ "U(P)U(P)" {_A_ 2 _U_ 22 _N_ _N_ _N_ _N_} _N_ _N_,
- _tagCmp = _A_ 2 _U_ 11 _N_ _S_ "U(P)U(P)" {_A_ 2 _U_ 22 _N_ _N_ _N_ _N_} _N_ _N_ #-}
+ (<) = { _A_ 2 _U_ 11 _N_ _S_ "U(P)U(P)" {_A_ 2 _U_ 22 _N_ _N_ _F_ _IF_ARGS_ 0 2 XX 1 \ (u0 :: Addr#) (u1 :: Addr#) -> _#_ ltAddr# [] [u0, u1] _N_} _F_ _IF_ARGS_ 0 2 CC 3 \ (u0 :: _Addr) (u1 :: _Addr) -> case u0 of { _ALG_ A# (u2 :: Addr#) -> case u1 of { _ALG_ A# (u3 :: Addr#) -> _#_ ltAddr# [] [u2, u3]; _NO_DEFLT_ }; _NO_DEFLT_ } _N_ },
+ (<=) = { _A_ 2 _U_ 11 _N_ _S_ "U(P)U(P)" {_A_ 2 _U_ 22 _N_ _N_ _F_ _IF_ARGS_ 0 2 XX 1 \ (u0 :: Addr#) (u1 :: Addr#) -> _#_ leAddr# [] [u0, u1] _N_} _F_ _IF_ARGS_ 0 2 CC 3 \ (u0 :: _Addr) (u1 :: _Addr) -> case u0 of { _ALG_ A# (u2 :: Addr#) -> case u1 of { _ALG_ A# (u3 :: Addr#) -> _#_ leAddr# [] [u2, u3]; _NO_DEFLT_ }; _NO_DEFLT_ } _N_ },
+ (>=) = { _A_ 2 _U_ 11 _N_ _S_ "U(P)U(P)" {_A_ 2 _U_ 22 _N_ _N_ _F_ _IF_ARGS_ 0 2 XX 1 \ (u0 :: Addr#) (u1 :: Addr#) -> _#_ geAddr# [] [u0, u1] _N_} _F_ _IF_ARGS_ 0 2 CC 3 \ (u0 :: _Addr) (u1 :: _Addr) -> case u0 of { _ALG_ A# (u2 :: Addr#) -> case u1 of { _ALG_ A# (u3 :: Addr#) -> _#_ geAddr# [] [u2, u3]; _NO_DEFLT_ }; _NO_DEFLT_ } _N_ },
+ (>) = { _A_ 2 _U_ 11 _N_ _S_ "U(P)U(P)" {_A_ 2 _U_ 22 _N_ _N_ _F_ _IF_ARGS_ 0 2 XX 1 \ (u0 :: Addr#) (u1 :: Addr#) -> _#_ gtAddr# [] [u0, u1] _N_} _F_ _IF_ARGS_ 0 2 CC 3 \ (u0 :: _Addr) (u1 :: _Addr) -> case u0 of { _ALG_ A# (u2 :: Addr#) -> case u1 of { _ALG_ A# (u3 :: Addr#) -> _#_ gtAddr# [] [u2, u3]; _NO_DEFLT_ }; _NO_DEFLT_ } _N_ },
+ max = { _A_ 2 _U_ 11 _N_ _S_ "U(P)U(P)" {_A_ 2 _U_ 22 _N_ _N_ _N_ _N_} _N_ _N_ },
+ min = { _A_ 2 _U_ 11 _N_ _S_ "U(P)U(P)" {_A_ 2 _U_ 22 _N_ _N_ _N_ _N_} _N_ _N_ },
+ _tagCmp = { _A_ 2 _U_ 11 _N_ _S_ "U(P)U(P)" {_A_ 2 _U_ 22 _N_ _N_ _N_ _N_} _N_ _N_ } #-}
instance Ord _PackedString
{-# GHC_PRAGMA _M_ PreludePS {-dfun-} _A_ 0 _N_ _N_ _N_ _F_ _IF_ARGS_ 0 0 X 9 _!_ _TUP_8 [{{Eq _PackedString}}, (_PackedString -> _PackedString -> Bool), (_PackedString -> _PackedString -> Bool), (_PackedString -> _PackedString -> Bool), (_PackedString -> _PackedString -> Bool), (_PackedString -> _PackedString -> _PackedString), (_PackedString -> _PackedString -> _PackedString), (_PackedString -> _PackedString -> _CMP_TAG)] [_DFUN_ Eq (_PackedString), _CONSTM_ Ord (<) (_PackedString), _CONSTM_ Ord (<=) (_PackedString), _CONSTM_ Ord (>=) (_PackedString), _CONSTM_ Ord (>) (_PackedString), _CONSTM_ Ord max (_PackedString), _CONSTM_ Ord min (_PackedString), _CONSTM_ Ord _tagCmp (_PackedString)] _N_
- (<) = _A_ 2 _U_ 22 _N_ _S_ "SS" _N_ _N_,
- (<=) = _A_ 2 _U_ 22 _N_ _S_ "SS" _N_ _N_,
- (>=) = _A_ 2 _U_ 22 _N_ _S_ "SS" _N_ _N_,
- (>) = _A_ 2 _U_ 22 _N_ _S_ "SS" _N_ _N_,
- max = _A_ 2 _U_ 22 _N_ _N_ _N_ _N_,
- min = _A_ 2 _U_ 22 _N_ _N_ _N_ _N_,
- _tagCmp = _A_ 2 _U_ 22 _N_ _S_ "SS" _N_ _N_ #-}
+ (<) = { _A_ 2 _U_ 22 _N_ _S_ "SS" _N_ _N_ },
+ (<=) = { _A_ 2 _U_ 22 _N_ _S_ "SS" _N_ _N_ },
+ (>=) = { _A_ 2 _U_ 22 _N_ _S_ "SS" _N_ _N_ },
+ (>) = { _A_ 2 _U_ 22 _N_ _S_ "SS" _N_ _N_ },
+ max = { _A_ 2 _U_ 22 _N_ _S_ "SS" _N_ _N_ },
+ min = { _A_ 2 _U_ 22 _N_ _S_ "SS" _N_ _N_ },
+ _tagCmp = { _A_ 2 _U_ 22 _N_ _S_ "SS" _N_ _N_ } #-}
instance Ord _Word
{-# GHC_PRAGMA _M_ PreludeCore {-dfun-} _A_ 0 _N_ _N_ _N_ _F_ _IF_ARGS_ 0 0 X 9 _!_ _TUP_8 [{{Eq _Word}}, (_Word -> _Word -> Bool), (_Word -> _Word -> Bool), (_Word -> _Word -> Bool), (_Word -> _Word -> Bool), (_Word -> _Word -> _Word), (_Word -> _Word -> _Word), (_Word -> _Word -> _CMP_TAG)] [_DFUN_ Eq (_Word), _CONSTM_ Ord (<) (_Word), _CONSTM_ Ord (<=) (_Word), _CONSTM_ Ord (>=) (_Word), _CONSTM_ Ord (>) (_Word), _CONSTM_ Ord max (_Word), _CONSTM_ Ord min (_Word), _CONSTM_ Ord _tagCmp (_Word)] _N_
- (<) = _A_ 2 _U_ 11 _N_ _S_ "U(P)U(P)" {_A_ 2 _U_ 22 _N_ _N_ _F_ _IF_ARGS_ 0 2 XX 1 \ (u0 :: Word#) (u1 :: Word#) -> _#_ ltWord# [] [u0, u1] _N_} _F_ _IF_ARGS_ 0 2 CC 3 \ (u0 :: _Word) (u1 :: _Word) -> case u0 of { _ALG_ W# (u2 :: Word#) -> case u1 of { _ALG_ W# (u3 :: Word#) -> _#_ ltWord# [] [u2, u3]; _NO_DEFLT_ }; _NO_DEFLT_ } _N_,
- (<=) = _A_ 2 _U_ 11 _N_ _S_ "U(P)U(P)" {_A_ 2 _U_ 22 _N_ _N_ _F_ _IF_ARGS_ 0 2 XX 1 \ (u0 :: Word#) (u1 :: Word#) -> _#_ leWord# [] [u0, u1] _N_} _F_ _IF_ARGS_ 0 2 CC 3 \ (u0 :: _Word) (u1 :: _Word) -> case u0 of { _ALG_ W# (u2 :: Word#) -> case u1 of { _ALG_ W# (u3 :: Word#) -> _#_ leWord# [] [u2, u3]; _NO_DEFLT_ }; _NO_DEFLT_ } _N_,
- (>=) = _A_ 2 _U_ 11 _N_ _S_ "U(P)U(P)" {_A_ 2 _U_ 22 _N_ _N_ _F_ _IF_ARGS_ 0 2 XX 1 \ (u0 :: Word#) (u1 :: Word#) -> _#_ geWord# [] [u0, u1] _N_} _F_ _IF_ARGS_ 0 2 CC 3 \ (u0 :: _Word) (u1 :: _Word) -> case u0 of { _ALG_ W# (u2 :: Word#) -> case u1 of { _ALG_ W# (u3 :: Word#) -> _#_ geWord# [] [u2, u3]; _NO_DEFLT_ }; _NO_DEFLT_ } _N_,
- (>) = _A_ 2 _U_ 11 _N_ _S_ "U(P)U(P)" {_A_ 2 _U_ 22 _N_ _N_ _F_ _IF_ARGS_ 0 2 XX 1 \ (u0 :: Word#) (u1 :: Word#) -> _#_ gtWord# [] [u0, u1] _N_} _F_ _IF_ARGS_ 0 2 CC 3 \ (u0 :: _Word) (u1 :: _Word) -> case u0 of { _ALG_ W# (u2 :: Word#) -> case u1 of { _ALG_ W# (u3 :: Word#) -> _#_ gtWord# [] [u2, u3]; _NO_DEFLT_ }; _NO_DEFLT_ } _N_,
- max = _A_ 2 _U_ 11 _N_ _S_ "U(P)U(P)" {_A_ 2 _U_ 22 _N_ _N_ _N_ _N_} _N_ _N_,
- min = _A_ 2 _U_ 11 _N_ _S_ "U(P)U(P)" {_A_ 2 _U_ 22 _N_ _N_ _N_ _N_} _N_ _N_,
- _tagCmp = _A_ 2 _U_ 11 _N_ _S_ "U(P)U(P)" {_A_ 2 _U_ 22 _N_ _N_ _N_ _N_} _N_ _N_ #-}
+ (<) = { _A_ 2 _U_ 11 _N_ _S_ "U(P)U(P)" {_A_ 2 _U_ 22 _N_ _N_ _F_ _IF_ARGS_ 0 2 XX 1 \ (u0 :: Word#) (u1 :: Word#) -> _#_ ltWord# [] [u0, u1] _N_} _F_ _IF_ARGS_ 0 2 CC 3 \ (u0 :: _Word) (u1 :: _Word) -> case u0 of { _ALG_ W# (u2 :: Word#) -> case u1 of { _ALG_ W# (u3 :: Word#) -> _#_ ltWord# [] [u2, u3]; _NO_DEFLT_ }; _NO_DEFLT_ } _N_ },
+ (<=) = { _A_ 2 _U_ 11 _N_ _S_ "U(P)U(P)" {_A_ 2 _U_ 22 _N_ _N_ _F_ _IF_ARGS_ 0 2 XX 1 \ (u0 :: Word#) (u1 :: Word#) -> _#_ leWord# [] [u0, u1] _N_} _F_ _IF_ARGS_ 0 2 CC 3 \ (u0 :: _Word) (u1 :: _Word) -> case u0 of { _ALG_ W# (u2 :: Word#) -> case u1 of { _ALG_ W# (u3 :: Word#) -> _#_ leWord# [] [u2, u3]; _NO_DEFLT_ }; _NO_DEFLT_ } _N_ },
+ (>=) = { _A_ 2 _U_ 11 _N_ _S_ "U(P)U(P)" {_A_ 2 _U_ 22 _N_ _N_ _F_ _IF_ARGS_ 0 2 XX 1 \ (u0 :: Word#) (u1 :: Word#) -> _#_ geWord# [] [u0, u1] _N_} _F_ _IF_ARGS_ 0 2 CC 3 \ (u0 :: _Word) (u1 :: _Word) -> case u0 of { _ALG_ W# (u2 :: Word#) -> case u1 of { _ALG_ W# (u3 :: Word#) -> _#_ geWord# [] [u2, u3]; _NO_DEFLT_ }; _NO_DEFLT_ } _N_ },
+ (>) = { _A_ 2 _U_ 11 _N_ _S_ "U(P)U(P)" {_A_ 2 _U_ 22 _N_ _N_ _F_ _IF_ARGS_ 0 2 XX 1 \ (u0 :: Word#) (u1 :: Word#) -> _#_ gtWord# [] [u0, u1] _N_} _F_ _IF_ARGS_ 0 2 CC 3 \ (u0 :: _Word) (u1 :: _Word) -> case u0 of { _ALG_ W# (u2 :: Word#) -> case u1 of { _ALG_ W# (u3 :: Word#) -> _#_ gtWord# [] [u2, u3]; _NO_DEFLT_ }; _NO_DEFLT_ } _N_ },
+ max = { _A_ 2 _U_ 11 _N_ _S_ "U(P)U(P)" {_A_ 2 _U_ 22 _N_ _N_ _N_ _N_} _N_ _N_ },
+ min = { _A_ 2 _U_ 11 _N_ _S_ "U(P)U(P)" {_A_ 2 _U_ 22 _N_ _N_ _N_ _N_} _N_ _N_ },
+ _tagCmp = { _A_ 2 _U_ 11 _N_ _S_ "U(P)U(P)" {_A_ 2 _U_ 22 _N_ _N_ _N_ _N_} _N_ _N_ } #-}
instance Real Double
{-# GHC_PRAGMA _M_ PreludeCore {-dfun-} _A_ 0 _N_ _N_ _N_ _F_ _IF_ARGS_ 0 0 X 4 _!_ _TUP_3 [{{Num Double}}, {{Enum Double}}, (Double -> Ratio Integer)] [_DFUN_ Num (Double), _DFUN_ Enum (Double), _CONSTM_ Real toRational (Double)] _N_
- toRational = _A_ 1 _U_ 1 _N_ _S_ "U(P)" {_A_ 1 _U_ 2 _N_ _N_ _N_ _N_} _N_ _N_ #-}
+ toRational = { _A_ 1 _U_ 1 _N_ _S_ "U(P)" {_A_ 1 _U_ 2 _N_ _N_ _N_ _N_} _N_ _N_ } #-}
instance Real Float
{-# GHC_PRAGMA _M_ PreludeCore {-dfun-} _A_ 0 _N_ _N_ _N_ _F_ _IF_ARGS_ 0 0 X 4 _!_ _TUP_3 [{{Num Float}}, {{Enum Float}}, (Float -> Ratio Integer)] [_DFUN_ Num (Float), _DFUN_ Enum (Float), _CONSTM_ Real toRational (Float)] _N_
- toRational = _A_ 1 _U_ 1 _N_ _S_ "U(P)" {_A_ 1 _U_ 2 _N_ _N_ _N_ _N_} _N_ _N_ #-}
+ toRational = { _A_ 1 _U_ 1 _N_ _S_ "U(P)" {_A_ 1 _U_ 2 _N_ _N_ _N_ _N_} _N_ _N_ } #-}
instance Real Int
{-# GHC_PRAGMA _M_ PreludeCore {-dfun-} _A_ 0 _N_ _N_ _N_ _F_ _IF_ARGS_ 0 0 X 4 _!_ _TUP_3 [{{Num Int}}, {{Enum Int}}, (Int -> Ratio Integer)] [_DFUN_ Num (Int), _DFUN_ Enum (Int), _CONSTM_ Real toRational (Int)] _N_
- toRational = _A_ 1 _U_ 1 _N_ _N_ _N_ _N_ #-}
+ toRational = { _A_ 1 _U_ 1 _N_ _N_ _N_ _N_ } #-}
instance Real Integer
{-# GHC_PRAGMA _M_ PreludeCore {-dfun-} _A_ 0 _N_ _N_ _N_ _F_ _IF_ARGS_ 0 0 X 4 _!_ _TUP_3 [{{Num Integer}}, {{Enum Integer}}, (Integer -> Ratio Integer)] [_DFUN_ Num (Integer), _DFUN_ Enum (Integer), _CONSTM_ Real toRational (Integer)] _N_
- toRational = _A_ 1 _U_ 2 _N_ _N_ _N_ _N_ #-}
+ toRational = { _A_ 1 _U_ 2 _N_ _N_ _F_ _IF_ARGS_ 0 1 X 3 \ (u0 :: Integer) -> _!_ (:%) [Integer] [u0, _ORIG_ PreludeCore __integer1] _N_ } #-}
instance Integral a => Real (Ratio a)
{-# GHC_PRAGMA _M_ PreludeRatio {-dfun-} _A_ 3 _U_ 122 _N_ _N_ _N_ _N_ #-}
instance Real (Ratio Integer)
{-# GHC_PRAGMA _M_ PreludeRatio {-dfun-} _A_ 0 _N_ _N_ _N_ _F_ _IF_ARGS_ 0 0 X 4 _!_ _TUP_3 [{{Num (Ratio Integer)}}, {{Enum (Ratio Integer)}}, (Ratio Integer -> Ratio Integer)] [_DFUN_ Num (Ratio Integer), _DFUN_ Enum (Ratio Integer), _CONSTM_ Real toRational (Ratio Integer)] _N_
- toRational = _A_ 1 _U_ 1 _N_ _S_ "U(LL)" {_A_ 2 _U_ 22 _N_ _N_ _F_ _IF_ARGS_ 0 2 XX 3 \ (u0 :: Integer) (u1 :: Integer) -> _!_ (:%) [Integer] [u0, u1] _N_} _F_ _IF_ARGS_ 0 1 X 1 \ (u0 :: Ratio Integer) -> u0 _N_ #-}
+ toRational = { _A_ 1 _U_ 1 _N_ _S_ "U(LL)" {_A_ 2 _U_ 22 _N_ _N_ _F_ _IF_ARGS_ 0 2 XX 3 \ (u0 :: Integer) (u1 :: Integer) -> _!_ (:%) [Integer] [u0, u1] _N_} _F_ _IF_ARGS_ 0 1 X 1 \ (u0 :: Ratio Integer) -> u0 _N_ } #-}
instance RealFloat Double
{-# GHC_PRAGMA _M_ PreludeCore {-dfun-} _A_ 0 _N_ _N_ _N_ _F_ _IF_ARGS_ 0 0 X 11 _!_ _TUP_10 [{{RealFrac Double}}, {{Floating Double}}, (Double -> Integer), (Double -> Int), (Double -> (Int, Int)), (Double -> (Integer, Int)), (Integer -> Int -> Double), (Double -> Int), (Double -> Double), (Int -> Double -> Double)] [_DFUN_ RealFrac (Double), _DFUN_ Floating (Double), _CONSTM_ RealFloat floatRadix (Double), _CONSTM_ RealFloat floatDigits (Double), _CONSTM_ RealFloat floatRange (Double), _CONSTM_ RealFloat decodeFloat (Double), _CONSTM_ RealFloat encodeFloat (Double), _CONSTM_ RealFloat exponent (Double), _CONSTM_ RealFloat significand (Double), _CONSTM_ RealFloat scaleFloat (Double)] _N_
- floatRadix = _A_ 1 _U_ 0 _N_ _S_ "A" {_A_ 0 _N_ _N_ _N_ _F_ _IF_ARGS_ 0 0 X 1 _#_ int2Integer# [] [2#] _N_} _N_ _N_,
- floatDigits = _A_ 1 _U_ 0 _N_ _S_ "A" {_A_ 0 _N_ _N_ _N_ _F_ _IF_ARGS_ 0 0 X 2 _!_ I# [] [53#] _N_} _F_ _IF_ARGS_ 0 1 X 2 \ (u0 :: Double) -> _!_ I# [] [53#] _N_,
- floatRange = _A_ 1 _U_ 0 _N_ _S_ "A" {_A_ 0 _N_ _N_ _N_ _N_ _N_} _N_ _N_,
- decodeFloat = _A_ 1 _U_ 1 _N_ _S_ "U(P)" {_A_ 1 _U_ 2 _N_ _N_ _N_ _N_} _N_ _N_,
- encodeFloat = _A_ 2 _U_ 11 _N_ _S_ "U(PPP)U(P)" {_A_ 4 _U_ 2222 _N_ _N_ _F_ _IF_ARGS_ 0 4 XXXX 3 \ (u0 :: Int#) (u1 :: Int#) (u2 :: ByteArray#) (u3 :: Int#) -> case _#_ encodeDouble# [] [u0, u1, u2, u3] of { _PRIM_ (u4 :: Double#) -> _!_ D# [] [u4] } _N_} _F_ _IF_ARGS_ 0 2 CC 5 \ (u0 :: Integer) (u1 :: Int) -> case u0 of { _ALG_ J# (u2 :: Int#) (u3 :: Int#) (u4 :: ByteArray#) -> case u1 of { _ALG_ I# (u5 :: Int#) -> case _#_ encodeDouble# [] [u2, u3, u4, u5] of { _PRIM_ (u6 :: Double#) -> _!_ D# [] [u6] }; _NO_DEFLT_ }; _NO_DEFLT_ } _N_,
- exponent = _A_ 1 _U_ 2 _N_ _N_ _N_ _N_,
- significand = _A_ 1 _U_ 2 _N_ _N_ _N_ _N_,
- scaleFloat = _A_ 2 _U_ 22 _N_ _N_ _N_ _N_ #-}
+ floatRadix = { _A_ 1 _U_ 0 _N_ _S_ "A" {_A_ 0 _N_ _N_ _N_ _N_ _N_} _N_ _N_ },
+ floatDigits = { _A_ 1 _U_ 0 _N_ _S_ "A" {_A_ 0 _N_ _N_ _N_ _F_ _IF_ARGS_ 0 0 X 2 _!_ I# [] [53#] _N_} _F_ _IF_ARGS_ 0 1 X 2 \ (u0 :: Double) -> _!_ I# [] [53#] _N_ },
+ floatRange = { _A_ 1 _U_ 0 _N_ _S_ "A" {_A_ 0 _N_ _N_ _N_ _N_ _N_} _N_ _N_ },
+ decodeFloat = { _A_ 1 _U_ 1 _N_ _S_ "U(P)" {_A_ 1 _U_ 2 _N_ _N_ _N_ _N_} _N_ _N_ },
+ encodeFloat = { _A_ 2 _U_ 11 _N_ _S_ "U(PPP)U(P)" {_A_ 4 _U_ 2222 _N_ _N_ _F_ _IF_ARGS_ 0 4 XXXX 3 \ (u0 :: Int#) (u1 :: Int#) (u2 :: ByteArray#) (u3 :: Int#) -> case _#_ encodeDouble# [] [u0, u1, u2, u3] of { _PRIM_ (u4 :: Double#) -> _!_ D# [] [u4] } _N_} _F_ _IF_ARGS_ 0 2 CC 5 \ (u0 :: Integer) (u1 :: Int) -> case u0 of { _ALG_ J# (u2 :: Int#) (u3 :: Int#) (u4 :: ByteArray#) -> case u1 of { _ALG_ I# (u5 :: Int#) -> case _#_ encodeDouble# [] [u2, u3, u4, u5] of { _PRIM_ (u6 :: Double#) -> _!_ D# [] [u6] }; _NO_DEFLT_ }; _NO_DEFLT_ } _N_ },
+ exponent = { _A_ 1 _U_ 1 _N_ _S_ "U(P)" {_A_ 1 _U_ 2 _N_ _N_ _N_ _N_} _N_ _N_ },
+ significand = { _A_ 1 _U_ 1 _N_ _S_ "U(P)" {_A_ 1 _U_ 2 _N_ _N_ _N_ _N_} _N_ _N_ },
+ scaleFloat = { _A_ 2 _U_ 11 _N_ _S_ "U(P)U(P)" {_A_ 2 _U_ 22 _N_ _N_ _N_ _N_} _N_ _N_ } #-}
instance RealFloat Float
{-# GHC_PRAGMA _M_ PreludeCore {-dfun-} _A_ 0 _N_ _N_ _N_ _F_ _IF_ARGS_ 0 0 X 11 _!_ _TUP_10 [{{RealFrac Float}}, {{Floating Float}}, (Float -> Integer), (Float -> Int), (Float -> (Int, Int)), (Float -> (Integer, Int)), (Integer -> Int -> Float), (Float -> Int), (Float -> Float), (Int -> Float -> Float)] [_DFUN_ RealFrac (Float), _DFUN_ Floating (Float), _CONSTM_ RealFloat floatRadix (Float), _CONSTM_ RealFloat floatDigits (Float), _CONSTM_ RealFloat floatRange (Float), _CONSTM_ RealFloat decodeFloat (Float), _CONSTM_ RealFloat encodeFloat (Float), _CONSTM_ RealFloat exponent (Float), _CONSTM_ RealFloat significand (Float), _CONSTM_ RealFloat scaleFloat (Float)] _N_
- floatRadix = _A_ 1 _U_ 0 _N_ _S_ "A" {_A_ 0 _N_ _N_ _N_ _F_ _IF_ARGS_ 0 0 X 1 _#_ int2Integer# [] [2#] _N_} _N_ _N_,
- floatDigits = _A_ 1 _U_ 0 _N_ _S_ "A" {_A_ 0 _N_ _N_ _N_ _F_ _IF_ARGS_ 0 0 X 2 _!_ I# [] [24#] _N_} _F_ _IF_ARGS_ 0 1 X 2 \ (u0 :: Float) -> _!_ I# [] [24#] _N_,
- floatRange = _A_ 1 _U_ 0 _N_ _S_ "A" {_A_ 0 _N_ _N_ _N_ _N_ _N_} _N_ _N_,
- decodeFloat = _A_ 1 _U_ 1 _N_ _S_ "U(P)" {_A_ 1 _U_ 2 _N_ _N_ _N_ _N_} _N_ _N_,
- encodeFloat = _A_ 2 _U_ 11 _N_ _S_ "U(PPP)U(P)" {_A_ 4 _U_ 2222 _N_ _N_ _F_ _IF_ARGS_ 0 4 XXXX 3 \ (u0 :: Int#) (u1 :: Int#) (u2 :: ByteArray#) (u3 :: Int#) -> case _#_ encodeFloat# [] [u0, u1, u2, u3] of { _PRIM_ (u4 :: Float#) -> _!_ F# [] [u4] } _N_} _F_ _IF_ARGS_ 0 2 CC 5 \ (u0 :: Integer) (u1 :: Int) -> case u0 of { _ALG_ J# (u2 :: Int#) (u3 :: Int#) (u4 :: ByteArray#) -> case u1 of { _ALG_ I# (u5 :: Int#) -> case _#_ encodeFloat# [] [u2, u3, u4, u5] of { _PRIM_ (u6 :: Float#) -> _!_ F# [] [u6] }; _NO_DEFLT_ }; _NO_DEFLT_ } _N_,
- exponent = _A_ 1 _U_ 2 _N_ _N_ _N_ _N_,
- significand = _A_ 1 _U_ 2 _N_ _N_ _N_ _N_,
- scaleFloat = _A_ 2 _U_ 22 _N_ _N_ _N_ _N_ #-}
+ floatRadix = { _A_ 1 _U_ 0 _N_ _S_ "A" {_A_ 0 _N_ _N_ _N_ _N_ _N_} _N_ _N_ },
+ floatDigits = { _A_ 1 _U_ 0 _N_ _S_ "A" {_A_ 0 _N_ _N_ _N_ _F_ _IF_ARGS_ 0 0 X 2 _!_ I# [] [24#] _N_} _F_ _IF_ARGS_ 0 1 X 2 \ (u0 :: Float) -> _!_ I# [] [24#] _N_ },
+ floatRange = { _A_ 1 _U_ 0 _N_ _S_ "A" {_A_ 0 _N_ _N_ _N_ _N_ _N_} _N_ _N_ },
+ decodeFloat = { _A_ 1 _U_ 1 _N_ _S_ "U(P)" {_A_ 1 _U_ 2 _N_ _N_ _N_ _N_} _N_ _N_ },
+ encodeFloat = { _A_ 2 _U_ 11 _N_ _S_ "U(PPP)U(P)" {_A_ 4 _U_ 2222 _N_ _N_ _F_ _IF_ARGS_ 0 4 XXXX 3 \ (u0 :: Int#) (u1 :: Int#) (u2 :: ByteArray#) (u3 :: Int#) -> case _#_ encodeFloat# [] [u0, u1, u2, u3] of { _PRIM_ (u4 :: Float#) -> _!_ F# [] [u4] } _N_} _F_ _IF_ARGS_ 0 2 CC 5 \ (u0 :: Integer) (u1 :: Int) -> case u0 of { _ALG_ J# (u2 :: Int#) (u3 :: Int#) (u4 :: ByteArray#) -> case u1 of { _ALG_ I# (u5 :: Int#) -> case _#_ encodeFloat# [] [u2, u3, u4, u5] of { _PRIM_ (u6 :: Float#) -> _!_ F# [] [u6] }; _NO_DEFLT_ }; _NO_DEFLT_ } _N_ },
+ exponent = { _A_ 1 _U_ 1 _N_ _S_ "U(P)" {_A_ 1 _U_ 2 _N_ _N_ _N_ _N_} _N_ _N_ },
+ significand = { _A_ 1 _U_ 1 _N_ _S_ "U(P)" {_A_ 1 _U_ 2 _N_ _N_ _N_ _N_} _N_ _N_ },
+ scaleFloat = { _A_ 2 _U_ 11 _N_ _S_ "U(P)U(P)" {_A_ 2 _U_ 22 _N_ _N_ _N_ _N_} _N_ _N_ } #-}
instance RealFrac Double
{-# GHC_PRAGMA _M_ PreludeCore {-dfun-} _A_ 0 _N_ _N_ _N_ _F_ _IF_ARGS_ 0 0 X 8 _!_ _TUP_7 [{{Real Double}}, {{Fractional Double}}, _forall_ a$z1 =>{{Integral a$z1}} -> (Double -> (a$z1, Double)), _forall_ a$z1 =>{{Integral a$z1}} -> (Double -> a$z1), _forall_ a$z1 =>{{Integral a$z1}} -> (Double -> a$z1), _forall_ a$z1 =>{{Integral a$z1}} -> (Double -> a$z1), _forall_ a$z1 =>{{Integral a$z1}} -> (Double -> a$z1)] [_DFUN_ Real (Double), _DFUN_ Fractional (Double), _CONSTM_ RealFrac properFraction (Double), _CONSTM_ RealFrac truncate (Double), _CONSTM_ RealFrac round (Double), _CONSTM_ RealFrac ceiling (Double), _CONSTM_ RealFrac floor (Double)] _N_
- properFraction = _A_ 1 _U_ 22 _N_ _N_ _N_ _N_,
- truncate = _A_ 1 _U_ 22 _N_ _N_ _N_ _N_,
- round = _A_ 1 _U_ 22 _N_ _N_ _N_ _N_,
- ceiling = _A_ 1 _U_ 22 _N_ _N_ _N_ _N_,
- floor = _A_ 1 _U_ 22 _N_ _N_ _N_ _N_ #-}
+ properFraction = { _A_ 1 _U_ 11 _N_ _N_ _N_ _SPECIALISE_ [ Int ] 1 { _A_ 1 _U_ 1 _N_ _S_ "U(P)" {_A_ 1 _U_ 2 _N_ _N_ _N_ _N_} _N_ _N_ }, [ Integer ] 1 { _A_ 1 _U_ 1 _N_ _S_ "U(P)" {_A_ 1 _U_ 2 _N_ _N_ _N_ _N_} _N_ _N_ } },
+ truncate = { _A_ 1 _U_ 11 _N_ _N_ _N_ _SPECIALISE_ [ Int ] 1 { _A_ 1 _U_ 1 _N_ _S_ "U(P)" {_A_ 1 _U_ 2 _N_ _N_ _F_ _IF_ARGS_ 0 1 X 4 \ (u0 :: Double#) -> case _APP_ _WRKR_ _SPEC_ _CONSTM_ RealFrac properFraction (Double) [ (Int) ] [ u0 ] of { _ALG_ _TUP_2 (u1 :: Int) (u2 :: Double) -> u1; _NO_DEFLT_ } _N_} _F_ _IF_ARGS_ 0 1 X 4 \ (u0 :: Double) -> case _APP_ _SPEC_ _CONSTM_ RealFrac properFraction (Double) [ (Int) ] [ u0 ] of { _ALG_ _TUP_2 (u1 :: Int) (u2 :: Double) -> u1; _NO_DEFLT_ } _N_ }, [ Integer ] 1 { _A_ 1 _U_ 1 _N_ _S_ "U(P)" {_A_ 1 _U_ 2 _N_ _N_ _F_ _IF_ARGS_ 0 1 X 4 \ (u0 :: Double#) -> case _APP_ _WRKR_ _SPEC_ _CONSTM_ RealFrac properFraction (Double) [ (Integer) ] [ u0 ] of { _ALG_ _TUP_2 (u1 :: Integer) (u2 :: Double) -> u1; _NO_DEFLT_ } _N_} _F_ _IF_ARGS_ 0 1 X 4 \ (u0 :: Double) -> case _APP_ _SPEC_ _CONSTM_ RealFrac properFraction (Double) [ (Integer) ] [ u0 ] of { _ALG_ _TUP_2 (u1 :: Integer) (u2 :: Double) -> u1; _NO_DEFLT_ } _N_ } },
+ round = { _A_ 1 _U_ 21 _N_ _N_ _N_ _SPECIALISE_ [ Int ] 1 { _A_ 1 _U_ 1 _N_ _S_ "U(P)" {_A_ 1 _U_ 2 _N_ _N_ _N_ _N_} _N_ _N_ }, [ Integer ] 1 { _A_ 1 _U_ 1 _N_ _S_ "U(P)" {_A_ 1 _U_ 2 _N_ _N_ _N_ _N_} _N_ _N_ } },
+ ceiling = { _A_ 1 _U_ 21 _N_ _N_ _N_ _SPECIALISE_ [ Int ] 1 { _A_ 1 _U_ 1 _N_ _S_ "U(P)" {_A_ 1 _U_ 2 _N_ _N_ _N_ _N_} _N_ _N_ }, [ Integer ] 1 { _A_ 1 _U_ 1 _N_ _S_ "U(P)" {_A_ 1 _U_ 2 _N_ _N_ _N_ _N_} _N_ _N_ } },
+ floor = { _A_ 1 _U_ 21 _N_ _N_ _N_ _SPECIALISE_ [ Int ] 1 { _A_ 1 _U_ 1 _N_ _S_ "U(P)" {_A_ 1 _U_ 2 _N_ _N_ _N_ _N_} _N_ _N_ }, [ Integer ] 1 { _A_ 1 _U_ 1 _N_ _S_ "U(P)" {_A_ 1 _U_ 2 _N_ _N_ _N_ _N_} _N_ _N_ } } #-}
instance RealFrac Float
{-# GHC_PRAGMA _M_ PreludeCore {-dfun-} _A_ 0 _N_ _N_ _N_ _F_ _IF_ARGS_ 0 0 X 8 _!_ _TUP_7 [{{Real Float}}, {{Fractional Float}}, _forall_ a$z1 =>{{Integral a$z1}} -> (Float -> (a$z1, Float)), _forall_ a$z1 =>{{Integral a$z1}} -> (Float -> a$z1), _forall_ a$z1 =>{{Integral a$z1}} -> (Float -> a$z1), _forall_ a$z1 =>{{Integral a$z1}} -> (Float -> a$z1), _forall_ a$z1 =>{{Integral a$z1}} -> (Float -> a$z1)] [_DFUN_ Real (Float), _DFUN_ Fractional (Float), _CONSTM_ RealFrac properFraction (Float), _CONSTM_ RealFrac truncate (Float), _CONSTM_ RealFrac round (Float), _CONSTM_ RealFrac ceiling (Float), _CONSTM_ RealFrac floor (Float)] _N_
- properFraction = _A_ 1 _U_ 22 _N_ _N_ _N_ _N_,
- truncate = _A_ 1 _U_ 22 _N_ _N_ _N_ _N_,
- round = _A_ 1 _U_ 22 _N_ _N_ _N_ _N_,
- ceiling = _A_ 1 _U_ 22 _N_ _N_ _N_ _N_,
- floor = _A_ 1 _U_ 22 _N_ _N_ _N_ _N_ #-}
-instance Integral a => RealFrac (Ratio a)
- {-# GHC_PRAGMA _M_ PreludeRatio {-dfun-} _A_ 3 _U_ 222 _N_ _N_ _N_ _N_ #-}
+ properFraction = { _A_ 1 _U_ 11 _N_ _N_ _N_ _SPECIALISE_ [ Int ] 1 { _A_ 1 _U_ 1 _N_ _S_ "U(P)" {_A_ 1 _U_ 2 _N_ _N_ _N_ _N_} _N_ _N_ }, [ Integer ] 1 { _A_ 1 _U_ 1 _N_ _S_ "U(P)" {_A_ 1 _U_ 2 _N_ _N_ _N_ _N_} _N_ _N_ } },
+ truncate = { _A_ 1 _U_ 11 _N_ _N_ _N_ _SPECIALISE_ [ Int ] 1 { _A_ 1 _U_ 1 _N_ _S_ "U(P)" {_A_ 1 _U_ 2 _N_ _N_ _F_ _IF_ARGS_ 0 1 X 4 \ (u0 :: Float#) -> case _APP_ _WRKR_ _SPEC_ _CONSTM_ RealFrac properFraction (Float) [ (Int) ] [ u0 ] of { _ALG_ _TUP_2 (u1 :: Int) (u2 :: Float) -> u1; _NO_DEFLT_ } _N_} _F_ _IF_ARGS_ 0 1 X 4 \ (u0 :: Float) -> case _APP_ _SPEC_ _CONSTM_ RealFrac properFraction (Float) [ (Int) ] [ u0 ] of { _ALG_ _TUP_2 (u1 :: Int) (u2 :: Float) -> u1; _NO_DEFLT_ } _N_ }, [ Integer ] 1 { _A_ 1 _U_ 1 _N_ _S_ "U(P)" {_A_ 1 _U_ 2 _N_ _N_ _F_ _IF_ARGS_ 0 1 X 4 \ (u0 :: Float#) -> case _APP_ _WRKR_ _SPEC_ _CONSTM_ RealFrac properFraction (Float) [ (Integer) ] [ u0 ] of { _ALG_ _TUP_2 (u1 :: Integer) (u2 :: Float) -> u1; _NO_DEFLT_ } _N_} _F_ _IF_ARGS_ 0 1 X 4 \ (u0 :: Float) -> case _APP_ _SPEC_ _CONSTM_ RealFrac properFraction (Float) [ (Integer) ] [ u0 ] of { _ALG_ _TUP_2 (u1 :: Integer) (u2 :: Float) -> u1; _NO_DEFLT_ } _N_ } },
+ round = { _A_ 1 _U_ 21 _N_ _N_ _N_ _SPECIALISE_ [ Int ] 1 { _A_ 1 _U_ 1 _N_ _S_ "U(P)" {_A_ 1 _U_ 2 _N_ _N_ _N_ _N_} _N_ _N_ }, [ Integer ] 1 { _A_ 1 _U_ 1 _N_ _S_ "U(P)" {_A_ 1 _U_ 2 _N_ _N_ _N_ _N_} _N_ _N_ } },
+ ceiling = { _A_ 1 _U_ 21 _N_ _N_ _N_ _SPECIALISE_ [ Int ] 1 { _A_ 1 _U_ 1 _N_ _S_ "U(P)" {_A_ 1 _U_ 2 _N_ _N_ _N_ _N_} _N_ _N_ }, [ Integer ] 1 { _A_ 1 _U_ 1 _N_ _S_ "U(P)" {_A_ 1 _U_ 2 _N_ _N_ _N_ _N_} _N_ _N_ } },
+ floor = { _A_ 1 _U_ 21 _N_ _N_ _N_ _SPECIALISE_ [ Int ] 1 { _A_ 1 _U_ 1 _N_ _S_ "U(P)" {_A_ 1 _U_ 2 _N_ _N_ _N_ _N_} _N_ _N_ }, [ Integer ] 1 { _A_ 1 _U_ 1 _N_ _S_ "U(P)" {_A_ 1 _U_ 2 _N_ _N_ _N_ _N_} _N_ _N_ } } #-}
instance RealFrac (Ratio Integer)
{-# GHC_PRAGMA _M_ PreludeRatio {-dfun-} _A_ 0 _N_ _N_ _N_ _F_ _IF_ARGS_ 0 0 X 8 _!_ _TUP_7 [{{Real (Ratio Integer)}}, {{Fractional (Ratio Integer)}}, _forall_ a$z1 =>{{Integral a$z1}} -> (Ratio Integer -> (a$z1, Ratio Integer)), _forall_ a$z1 =>{{Integral a$z1}} -> (Ratio Integer -> a$z1), _forall_ a$z1 =>{{Integral a$z1}} -> (Ratio Integer -> a$z1), _forall_ a$z1 =>{{Integral a$z1}} -> (Ratio Integer -> a$z1), _forall_ a$z1 =>{{Integral a$z1}} -> (Ratio Integer -> a$z1)] [_DFUN_ Real (Ratio Integer), _DFUN_ Fractional (Ratio Integer), _CONSTM_ RealFrac properFraction (Ratio Integer), _CONSTM_ RealFrac truncate (Ratio Integer), _CONSTM_ RealFrac round (Ratio Integer), _CONSTM_ RealFrac ceiling (Ratio Integer), _CONSTM_ RealFrac floor (Ratio Integer)] _N_
- properFraction = _A_ 2 _U_ 11 _N_ _S_ "LU(LL)" {_A_ 3 _U_ 112 _N_ _N_ _N_ _N_} _N_ _N_,
- truncate = _A_ 1 _U_ 22 _N_ _N_ _F_ _IF_ARGS_ 1 1 X 3 _/\_ u0 -> \ (u1 :: {{Integral u0}}) -> _APP_ _TYAPP_ _TYAPP_ _WRKR_ _ORIG_ PreludeCore _truncate { (Ratio Integer) } { u0 } [ _CONSTM_ RealFrac properFraction (Ratio Integer), u1 ] _N_,
- round = _A_ 1 _U_ 22 _N_ _N_ _N_ _N_,
- ceiling = _A_ 1 _U_ 22 _N_ _N_ _N_ _N_,
- floor = _A_ 1 _U_ 22 _N_ _N_ _N_ _N_ #-}
+ properFraction = { _A_ 2 _U_ 11 _N_ _S_ "LU(U(PPP)U(PPP))" {_A_ 5 _U_ 12222 _N_ _N_ _N_ _N_} _N_ _SPECIALISE_ [ Int ] 1 { _A_ 1 _U_ 1 _N_ _S_ "U(U(PPP)U(PPP))" {_A_ 4 _U_ 2222 _N_ _N_ _N_ _N_} _N_ _N_ }, [ Integer ] 1 { _A_ 1 _U_ 1 _N_ _S_ "U(U(PPP)U(PPP))" {_A_ 4 _U_ 2222 _N_ _N_ _N_ _N_} _N_ _N_ } },
+ truncate = { _A_ 2 _U_ 11 _N_ _N_ _N_ _SPECIALISE_ [ Int ] 1 { _A_ 1 _U_ 1 _N_ _S_ "U(U(PPP)U(PPP))" {_A_ 4 _U_ 2222 _N_ _N_ _F_ _IF_ARGS_ 0 4 XXXX 7 \ (u0 :: Int#) (u1 :: Int#) (u2 :: ByteArray#) (u3 :: Integer) -> case _APP_ _WRKR_ _SPEC_ _CONSTM_ RealFrac properFraction (Ratio Integer) [ (Int) ] [ u0, u1, u2, u3 ] of { _ALG_ _TUP_2 (u4 :: Int) (u5 :: Ratio Integer) -> u4; _NO_DEFLT_ } _N_} _F_ _IF_ARGS_ 0 1 X 4 \ (u0 :: Ratio Integer) -> case _APP_ _SPEC_ _CONSTM_ RealFrac properFraction (Ratio Integer) [ (Int) ] [ u0 ] of { _ALG_ _TUP_2 (u1 :: Int) (u2 :: Ratio Integer) -> u1; _NO_DEFLT_ } _N_ }, [ Integer ] 1 { _A_ 1 _U_ 1 _N_ _S_ "U(U(PPP)U(PPP))" {_A_ 4 _U_ 2222 _N_ _N_ _F_ _IF_ARGS_ 0 4 XXXX 7 \ (u0 :: Int#) (u1 :: Int#) (u2 :: ByteArray#) (u3 :: Integer) -> case _APP_ _WRKR_ _SPEC_ _CONSTM_ RealFrac properFraction (Ratio Integer) [ (Integer) ] [ u0, u1, u2, u3 ] of { _ALG_ _TUP_2 (u4 :: Integer) (u5 :: Ratio Integer) -> u4; _NO_DEFLT_ } _N_} _F_ _IF_ARGS_ 0 1 X 4 \ (u0 :: Ratio Integer) -> case _APP_ _SPEC_ _CONSTM_ RealFrac properFraction (Ratio Integer) [ (Integer) ] [ u0 ] of { _ALG_ _TUP_2 (u1 :: Integer) (u2 :: Ratio Integer) -> u1; _NO_DEFLT_ } _N_ } },
+ round = { _A_ 1 _U_ 21 _N_ _N_ _N_ _SPECIALISE_ [ Int ] 1 { _A_ 1 _U_ 1 _N_ _S_ "U(U(PPP)U(PPP))" {_A_ 4 _U_ 2222 _N_ _N_ _N_ _N_} _N_ _N_ }, [ Integer ] 1 { _A_ 1 _U_ 1 _N_ _S_ "U(U(PPP)U(PPP))" {_A_ 4 _U_ 2222 _N_ _N_ _N_ _N_} _N_ _N_ } },
+ ceiling = { _A_ 1 _U_ 21 _N_ _N_ _N_ _SPECIALISE_ [ Int ] 1 { _A_ 1 _U_ 1 _N_ _S_ "U(U(PPP)U(PPP))" {_A_ 4 _U_ 2222 _N_ _N_ _N_ _N_} _N_ _N_ }, [ Integer ] 1 { _A_ 1 _U_ 1 _N_ _S_ "U(U(PPP)U(PPP))" {_A_ 4 _U_ 2222 _N_ _N_ _N_ _N_} _N_ _N_ } },
+ floor = { _A_ 1 _U_ 21 _N_ _N_ _N_ _SPECIALISE_ [ Int ] 1 { _A_ 1 _U_ 1 _N_ _S_ "U(U(PPP)U(PPP))" {_A_ 4 _U_ 2222 _N_ _N_ _N_ _N_} _N_ _N_ }, [ Integer ] 1 { _A_ 1 _U_ 1 _N_ _S_ "U(U(PPP)U(PPP))" {_A_ 4 _U_ 2222 _N_ _N_ _N_ _N_} _N_ _N_ } } #-}
+instance Text ((Int, Int), (Int, Int))
+ {-# GHC_PRAGMA _M_ PreludeBuiltin {-dfun-} _A_ 0 _N_ _N_ _N_ _F_ _IF_ARGS_ 0 0 X 5 _!_ _TUP_4 [(Int -> [Char] -> [(((Int, Int), (Int, Int)), [Char])]), (Int -> ((Int, Int), (Int, Int)) -> [Char] -> [Char]), ([Char] -> [([((Int, Int), (Int, Int))], [Char])]), ([((Int, Int), (Int, Int))] -> [Char] -> [Char])] [_CONSTM_ Text readsPrec (((Int, Int), (Int, Int))), _CONSTM_ Text showsPrec (((Int, Int), (Int, Int))), _CONSTM_ Text readList (((Int, Int), (Int, Int))), _CONSTM_ Text showList (((Int, Int), (Int, Int)))] _N_
+ readsPrec = { _A_ 1 _U_ 02 _N_ _S_ "A" {_A_ 0 _U_ 2 _N_ _N_ _N_ _N_} _N_ _N_ },
+ showsPrec = { _A_ 3 _U_ 012 _N_ _S_ "AU(LL)L" {_A_ 3 _U_ 112 _N_ _N_ _N_ _N_} _N_ _N_ },
+ readList = { _A_ 0 _U_ 2 _N_ _N_ _N_ _N_ },
+ showList = { _A_ 1 _U_ 12 _N_ _N_ _N_ _N_ } #-}
instance Text ()
{-# GHC_PRAGMA _M_ PreludeBuiltin {-dfun-} _A_ 0 _N_ _N_ _N_ _F_ _IF_ARGS_ 0 0 X 5 _!_ _TUP_4 [(Int -> [Char] -> [((), [Char])]), (Int -> () -> [Char] -> [Char]), ([Char] -> [([()], [Char])]), ([()] -> [Char] -> [Char])] [_CONSTM_ Text readsPrec (()), _CONSTM_ Text showsPrec (()), _CONSTM_ Text readList (()), _CONSTM_ Text showList (())] _N_
- readsPrec = _A_ 1 _U_ 02 _N_ _S_ "A" {_A_ 0 _U_ 2 _N_ _N_ _N_ _N_} _N_ _N_,
- showsPrec = _A_ 3 _U_ 012 _N_ _S_ "AEL" {_A_ 2 _U_ 12 _N_ _N_ _F_ _IF_ARGS_ 0 2 CX 4 \ (u0 :: ()) (u1 :: [Char]) -> case u0 of { _ALG_ _TUP_0 -> _APP_ _TYAPP_ _ORIG_ PreludeList (++) { Char } [ _NOREP_S_ "()", u1 ]; _NO_DEFLT_ } _N_} _F_ _IF_ARGS_ 0 3 XCX 4 \ (u0 :: Int) (u1 :: ()) (u2 :: [Char]) -> case u1 of { _ALG_ _TUP_0 -> _APP_ _TYAPP_ _ORIG_ PreludeList (++) { Char } [ _NOREP_S_ "()", u2 ]; _NO_DEFLT_ } _N_,
- readList = _A_ 0 _U_ 2 _N_ _N_ _N_ _N_,
- showList = _A_ 0 _U_ 12 _N_ _N_ _N_ _N_ #-}
+ readsPrec = { _A_ 1 _U_ 02 _N_ _S_ "A" {_A_ 0 _U_ 2 _N_ _N_ _N_ _N_} _N_ _N_ },
+ showsPrec = { _A_ 3 _U_ 012 _N_ _S_ "AEL" {_A_ 2 _U_ 12 _N_ _N_ _F_ _IF_ARGS_ 0 2 CX 4 \ (u0 :: ()) (u1 :: [Char]) -> case u0 of { _ALG_ _TUP_0 -> _APP_ _TYAPP_ _ORIG_ PreludeList (++) { Char } [ _NOREP_S_ "()", u1 ]; _NO_DEFLT_ } _N_} _F_ _IF_ARGS_ 0 3 XCX 4 \ (u0 :: Int) (u1 :: ()) (u2 :: [Char]) -> case u1 of { _ALG_ _TUP_0 -> _APP_ _TYAPP_ _ORIG_ PreludeList (++) { Char } [ _NOREP_S_ "()", u2 ]; _NO_DEFLT_ } _N_ },
+ readList = { _A_ 0 _U_ 2 _N_ _N_ _N_ _N_ },
+ showList = { _A_ 1 _U_ 12 _N_ _N_ _N_ _N_ } #-}
instance (Text a, Text b) => Text (a, b)
{-# GHC_PRAGMA _M_ PreludeBuiltin {-dfun-} _A_ 2 _U_ 22 _N_ _N_ _N_ _N_ #-}
instance (Text a, Text b, Text c) => Text (a, b, c)
{-# GHC_PRAGMA _M_ PreludeBuiltin {-dfun-} _A_ 5 _U_ 22222 _N_ _N_ _N_ _N_ #-}
instance Text (Int, Int)
{-# GHC_PRAGMA _M_ PreludeBuiltin {-dfun-} _A_ 0 _N_ _N_ _N_ _F_ _IF_ARGS_ 0 0 X 5 _!_ _TUP_4 [(Int -> [Char] -> [((Int, Int), [Char])]), (Int -> (Int, Int) -> [Char] -> [Char]), ([Char] -> [([(Int, Int)], [Char])]), ([(Int, Int)] -> [Char] -> [Char])] [_CONSTM_ Text readsPrec ((Int, Int)), _CONSTM_ Text showsPrec ((Int, Int)), _CONSTM_ Text readList ((Int, Int)), _CONSTM_ Text showList ((Int, Int))] _N_
- readsPrec = _A_ 1 _U_ 02 _N_ _S_ "A" {_A_ 0 _U_ 2 _N_ _N_ _N_ _N_} _N_ _N_,
- showsPrec = _A_ 3 _U_ 012 _N_ _S_ "AU(LL)L" {_A_ 3 _U_ 112 _N_ _N_ _N_ _N_} _N_ _N_,
- readList = _A_ 0 _U_ 2 _N_ _N_ _N_ _N_,
- showList = _A_ 0 _U_ 12 _N_ _N_ _N_ _N_ #-}
+ readsPrec = { _A_ 1 _U_ 02 _N_ _S_ "A" {_A_ 0 _U_ 2 _N_ _N_ _N_ _N_} _N_ _N_ },
+ showsPrec = { _A_ 3 _U_ 012 _N_ _S_ "AU(LL)L" {_A_ 3 _U_ 112 _N_ _N_ _N_ _N_} _N_ _N_ },
+ readList = { _A_ 0 _U_ 2 _N_ _N_ _N_ _N_ },
+ showList = { _A_ 1 _U_ 12 _N_ _N_ _N_ _N_ } #-}
+instance Text (Int, Int, Int)
+ {-# GHC_PRAGMA _M_ PreludeBuiltin {-dfun-} _A_ 0 _N_ _N_ _N_ _F_ _IF_ARGS_ 0 0 X 5 _!_ _TUP_4 [(Int -> [Char] -> [((Int, Int, Int), [Char])]), (Int -> (Int, Int, Int) -> [Char] -> [Char]), ([Char] -> [([(Int, Int, Int)], [Char])]), ([(Int, Int, Int)] -> [Char] -> [Char])] [_CONSTM_ Text readsPrec ((Int, Int, Int)), _CONSTM_ Text showsPrec ((Int, Int, Int)), _CONSTM_ Text readList ((Int, Int, Int)), _CONSTM_ Text showList ((Int, Int, Int))] _N_
+ readsPrec = { _A_ 1 _U_ 02 _N_ _S_ "A" {_A_ 0 _U_ 2 _N_ _N_ _N_ _N_} _N_ _N_ },
+ showsPrec = { _A_ 3 _U_ 012 _N_ _S_ "AU(LLL)L" {_A_ 4 _U_ 1112 _N_ _N_ _N_ _N_} _N_ _N_ },
+ readList = { _A_ 0 _U_ 2 _N_ _N_ _N_ _N_ },
+ showList = { _A_ 1 _U_ 12 _N_ _N_ _N_ _N_ } #-}
instance Text (Integer, Integer)
{-# GHC_PRAGMA _M_ PreludeBuiltin {-dfun-} _A_ 0 _N_ _N_ _N_ _F_ _IF_ARGS_ 0 0 X 5 _!_ _TUP_4 [(Int -> [Char] -> [((Integer, Integer), [Char])]), (Int -> (Integer, Integer) -> [Char] -> [Char]), ([Char] -> [([(Integer, Integer)], [Char])]), ([(Integer, Integer)] -> [Char] -> [Char])] [_CONSTM_ Text readsPrec ((Integer, Integer)), _CONSTM_ Text showsPrec ((Integer, Integer)), _CONSTM_ Text readList ((Integer, Integer)), _CONSTM_ Text showList ((Integer, Integer))] _N_
- readsPrec = _A_ 1 _U_ 02 _N_ _S_ "A" {_A_ 0 _U_ 2 _N_ _N_ _N_ _N_} _N_ _N_,
- showsPrec = _A_ 3 _U_ 012 _N_ _S_ "AU(LL)L" {_A_ 3 _U_ 112 _N_ _N_ _N_ _N_} _N_ _N_,
- readList = _A_ 0 _U_ 2 _N_ _N_ _N_ _N_,
- showList = _A_ 0 _U_ 12 _N_ _N_ _N_ _N_ #-}
+ readsPrec = { _A_ 1 _U_ 02 _N_ _S_ "A" {_A_ 0 _U_ 2 _N_ _N_ _N_ _N_} _N_ _N_ },
+ showsPrec = { _A_ 3 _U_ 012 _N_ _S_ "AU(LL)L" {_A_ 3 _U_ 112 _N_ _N_ _N_ _N_} _N_ _N_ },
+ readList = { _A_ 0 _U_ 2 _N_ _N_ _N_ _N_ },
+ showList = { _A_ 1 _U_ 12 _N_ _N_ _N_ _N_ } #-}
instance Text (a -> b)
{-# GHC_PRAGMA _M_ PreludeCore {-dfun-} _A_ 0 _N_ _N_ _N_ _N_ _N_ #-}
+instance Text (Array (Int, Int) Double)
+ {-# GHC_PRAGMA _M_ PreludeArray {-dfun-} _A_ 0 _N_ _N_ _N_ _F_ _IF_ARGS_ 0 0 X 5 _!_ _TUP_4 [(Int -> [Char] -> [(Array (Int, Int) Double, [Char])]), (Int -> Array (Int, Int) Double -> [Char] -> [Char]), ([Char] -> [([Array (Int, Int) Double], [Char])]), ([Array (Int, Int) Double] -> [Char] -> [Char])] [_CONSTM_ Text readsPrec (Array (Int, Int) Double), _CONSTM_ Text showsPrec (Array (Int, Int) Double), _CONSTM_ Text readList (Array (Int, Int) Double), _CONSTM_ Text showList (Array (Int, Int) Double)] _N_
+ readsPrec = { _A_ 1 _U_ 12 _N_ _S_ "U(P)" {_A_ 1 _U_ 22 _N_ _N_ _N_ _N_} _N_ _N_ },
+ showsPrec = { _A_ 2 _U_ 122 _N_ _N_ _N_ _N_ },
+ readList = { _A_ 0 _U_ 2 _N_ _N_ _N_ _N_ },
+ showList = { _A_ 0 _U_ 12 _N_ _N_ _N_ _N_ } #-}
instance (Ix a, Text a, Text b) => Text (Array a b)
{-# GHC_PRAGMA _M_ PreludeArray {-dfun-} _A_ 3 _U_ 222 _N_ _N_ _N_ _N_ #-}
+instance Text (Array Int Double)
+ {-# GHC_PRAGMA _M_ PreludeArray {-dfun-} _A_ 0 _N_ _N_ _N_ _F_ _IF_ARGS_ 0 0 X 5 _!_ _TUP_4 [(Int -> [Char] -> [(Array Int Double, [Char])]), (Int -> Array Int Double -> [Char] -> [Char]), ([Char] -> [([Array Int Double], [Char])]), ([Array Int Double] -> [Char] -> [Char])] [_CONSTM_ Text readsPrec (Array Int Double), _CONSTM_ Text showsPrec (Array Int Double), _CONSTM_ Text readList (Array Int Double), _CONSTM_ Text showList (Array Int Double)] _N_
+ readsPrec = { _A_ 1 _U_ 12 _N_ _S_ "U(P)" {_A_ 1 _U_ 22 _N_ _N_ _N_ _N_} _N_ _N_ },
+ showsPrec = { _A_ 2 _U_ 122 _N_ _N_ _N_ _N_ },
+ readList = { _A_ 0 _U_ 2 _N_ _N_ _N_ _N_ },
+ showList = { _A_ 0 _U_ 12 _N_ _N_ _N_ _N_ } #-}
instance (Text a, Text b) => Text (Assoc a b)
{-# GHC_PRAGMA _M_ PreludeArray {-dfun-} _A_ 2 _U_ 22 _N_ _N_ _N_ _N_ #-}
instance Text Bool
{-# GHC_PRAGMA _M_ PreludeCore {-dfun-} _A_ 0 _N_ _N_ _N_ _F_ _IF_ARGS_ 0 0 X 5 _!_ _TUP_4 [(Int -> [Char] -> [(Bool, [Char])]), (Int -> Bool -> [Char] -> [Char]), ([Char] -> [([Bool], [Char])]), ([Bool] -> [Char] -> [Char])] [_CONSTM_ Text readsPrec (Bool), _CONSTM_ Text showsPrec (Bool), _CONSTM_ Text readList (Bool), _CONSTM_ Text showList (Bool)] _N_
- readsPrec = _A_ 2 _U_ 02 _N_ _S_ "AL" {_A_ 1 _U_ 2 _N_ _N_ _N_ _N_} _N_ _N_,
- showsPrec = _A_ 3 _U_ 012 _N_ _S_ "AEL" {_A_ 2 _U_ 12 _N_ _N_ _N_ _N_} _N_ _N_,
- readList = _A_ 0 _U_ 2 _N_ _N_ _N_ _N_,
- showList = _A_ 0 _U_ 12 _N_ _N_ _N_ _N_ #-}
+ readsPrec = { _A_ 2 _U_ 02 _N_ _S_ "AL" {_A_ 1 _U_ 2 _N_ _N_ _N_ _N_} _N_ _N_ },
+ showsPrec = { _A_ 3 _U_ 012 _N_ _S_ "AEL" {_A_ 2 _U_ 12 _N_ _N_ _N_ _N_} _N_ _N_ },
+ readList = { _A_ 0 _U_ 2 _N_ _N_ _N_ _N_ },
+ showList = { _A_ 1 _U_ 12 _N_ _N_ _F_ _IF_ARGS_ 0 1 X 3 \ (u0 :: [Bool]) -> _APP_ _TYAPP_ _ORIG_ PreludeCore _showList { Bool } [ _WRKR_ _CONSTM_ Text showsPrec (Bool), u0 ] _N_ } #-}
instance Text Char
{-# GHC_PRAGMA _M_ PreludeCore {-dfun-} _A_ 0 _N_ _N_ _N_ _F_ _IF_ARGS_ 0 0 X 5 _!_ _TUP_4 [(Int -> [Char] -> [(Char, [Char])]), (Int -> Char -> [Char] -> [Char]), ([Char] -> [([Char], [Char])]), ([Char] -> [Char] -> [Char])] [_CONSTM_ Text readsPrec (Char), _CONSTM_ Text showsPrec (Char), _CONSTM_ Text readList (Char), _CONSTM_ Text showList (Char)] _N_
- readsPrec = _A_ 1 _U_ 02 _N_ _S_ "A" {_A_ 0 _U_ 2 _N_ _N_ _N_ _N_} _N_ _N_,
- showsPrec = _A_ 3 _U_ 012 _N_ _S_ "AU(P)L" {_A_ 2 _U_ 22 _N_ _N_ _N_ _N_} _N_ _N_,
- readList = _A_ 0 _U_ 2 _N_ _N_ _N_ _N_,
- showList = _A_ 1 _U_ 22 _N_ _N_ _N_ _N_ #-}
+ readsPrec = { _A_ 1 _U_ 02 _N_ _S_ "A" {_A_ 0 _U_ 2 _N_ _N_ _N_ _N_} _N_ _N_ },
+ showsPrec = { _A_ 3 _U_ 012 _N_ _S_ "AU(P)L" {_A_ 2 _U_ 22 _N_ _N_ _N_ _N_} _N_ _N_ },
+ readList = { _A_ 0 _U_ 2 _N_ _N_ _N_ _N_ },
+ showList = { _A_ 1 _U_ 22 _N_ _N_ _N_ _N_ } #-}
instance Text a => Text (Complex a)
{-# GHC_PRAGMA _M_ PreludeComplex {-dfun-} _A_ 1 _U_ 2 _N_ _N_ _N_ _N_ #-}
+instance Text (Complex Double)
+ {-# GHC_PRAGMA _M_ PreludeComplex {-dfun-} _A_ 0 _N_ _N_ _N_ _F_ _IF_ARGS_ 0 0 X 5 _!_ _TUP_4 [(Int -> [Char] -> [(Complex Double, [Char])]), (Int -> Complex Double -> [Char] -> [Char]), ([Char] -> [([Complex Double], [Char])]), ([Complex Double] -> [Char] -> [Char])] [_CONSTM_ Text readsPrec (Complex Double), _CONSTM_ Text showsPrec (Complex Double), _CONSTM_ Text readList (Complex Double), _CONSTM_ Text showList (Complex Double)] _N_
+ readsPrec = { _A_ 1 _U_ 12 _N_ _S_ "U(P)" {_A_ 1 _U_ 22 _N_ _N_ _N_ _N_} _N_ _N_ },
+ showsPrec = { _A_ 2 _U_ 112 _N_ _S_ "LU(LL)" {_A_ 3 _U_ 1222 _N_ _N_ _N_ _N_} _N_ _N_ },
+ readList = { _A_ 0 _U_ 2 _N_ _N_ _N_ _N_ },
+ showList = { _A_ 1 _U_ 12 _N_ _N_ _N_ _N_ } #-}
instance Text Double
{-# GHC_PRAGMA _M_ PreludeCore {-dfun-} _A_ 0 _N_ _N_ _N_ _F_ _IF_ARGS_ 0 0 X 5 _!_ _TUP_4 [(Int -> [Char] -> [(Double, [Char])]), (Int -> Double -> [Char] -> [Char]), ([Char] -> [([Double], [Char])]), ([Double] -> [Char] -> [Char])] [_CONSTM_ Text readsPrec (Double), _CONSTM_ Text showsPrec (Double), _CONSTM_ Text readList (Double), _CONSTM_ Text showList (Double)] _N_
- readsPrec = _A_ 2 _U_ 02 _N_ _S_ "AL" {_A_ 1 _U_ 2 _N_ _N_ _F_ _IF_ARGS_ 0 1 X 3 \ (u0 :: [Char]) -> _APP_ _SPEC_ _ORIG_ PreludeText readSigned [ (Double) ] [ _SPEC_ _ORIG_ PreludeText readFloat [ (Double) ], u0 ] _N_} _F_ _IF_ARGS_ 0 2 XX 3 \ (u0 :: Int) (u1 :: [Char]) -> _APP_ _SPEC_ _ORIG_ PreludeText readSigned [ (Double) ] [ _SPEC_ _ORIG_ PreludeText readFloat [ (Double) ], u1 ] _N_,
- showsPrec = _A_ 2 _U_ 212 _N_ _S_ "LU(P)" {_A_ 2 _U_ 222 _N_ _N_ _F_ _IF_ARGS_ 0 2 XX 4 \ (u0 :: Int) (u1 :: Double#) -> _APP_ _WRKR_ _SPEC_ _ORIG_ PreludeText showSigned [ (Double) ] [ _SPEC_ _ORIG_ PreludeText showFloat [ (Double) ], u0, u1 ] _N_} _F_ _IF_ARGS_ 0 2 XC 5 \ (u0 :: Int) (u1 :: Double) -> case u1 of { _ALG_ D# (u2 :: Double#) -> _APP_ _WRKR_ _SPEC_ _ORIG_ PreludeText showSigned [ (Double) ] [ _SPEC_ _ORIG_ PreludeText showFloat [ (Double) ], u0, u2 ]; _NO_DEFLT_ } _N_,
- readList = _A_ 0 _U_ 2 _N_ _N_ _N_ _N_,
- showList = _A_ 0 _U_ 12 _N_ _N_ _N_ _N_ #-}
+ readsPrec = { _A_ 2 _U_ 02 _N_ _S_ "AL" {_A_ 1 _U_ 2 _N_ _N_ _F_ _IF_ARGS_ 0 1 X 3 \ (u0 :: [Char]) -> _APP_ _SPEC_ _ORIG_ PreludeText readSigned [ (Double) ] [ _SPEC_ _ORIG_ PreludeText readFloat [ (Double) ], u0 ] _N_} _F_ _IF_ARGS_ 0 2 XX 3 \ (u0 :: Int) (u1 :: [Char]) -> _APP_ _SPEC_ _ORIG_ PreludeText readSigned [ (Double) ] [ _SPEC_ _ORIG_ PreludeText readFloat [ (Double) ], u1 ] _N_ },
+ showsPrec = { _A_ 2 _U_ 212 _N_ _S_ "LU(P)" {_A_ 2 _U_ 222 _N_ _N_ _F_ _IF_ARGS_ 0 2 XX 4 \ (u0 :: Int) (u1 :: Double#) -> _APP_ _WRKR_ _SPEC_ _ORIG_ PreludeText showSigned [ (Double) ] [ _SPEC_ _ORIG_ PreludeText showFloat [ (Double) ], u0, u1 ] _N_} _F_ _IF_ARGS_ 0 2 XC 5 \ (u0 :: Int) (u1 :: Double) -> case u1 of { _ALG_ D# (u2 :: Double#) -> _APP_ _WRKR_ _SPEC_ _ORIG_ PreludeText showSigned [ (Double) ] [ _SPEC_ _ORIG_ PreludeText showFloat [ (Double) ], u0, u2 ]; _NO_DEFLT_ } _N_ },
+ readList = { _A_ 0 _U_ 2 _N_ _N_ _N_ _N_ },
+ showList = { _A_ 1 _U_ 12 _N_ _N_ _N_ _N_ } #-}
instance (Text a, Text b) => Text (Either a b)
{-# GHC_PRAGMA _M_ PreludeMonadicIO {-dfun-} _A_ 2 _U_ 22 _N_ _N_ _N_ _N_ #-}
instance Text Float
{-# GHC_PRAGMA _M_ PreludeCore {-dfun-} _A_ 0 _N_ _N_ _N_ _F_ _IF_ARGS_ 0 0 X 5 _!_ _TUP_4 [(Int -> [Char] -> [(Float, [Char])]), (Int -> Float -> [Char] -> [Char]), ([Char] -> [([Float], [Char])]), ([Float] -> [Char] -> [Char])] [_CONSTM_ Text readsPrec (Float), _CONSTM_ Text showsPrec (Float), _CONSTM_ Text readList (Float), _CONSTM_ Text showList (Float)] _N_
- readsPrec = _A_ 2 _U_ 02 _N_ _S_ "AL" {_A_ 1 _U_ 2 _N_ _N_ _N_ _N_} _N_ _N_,
- showsPrec = _A_ 1 _U_ 222 _N_ _N_ _N_ _N_,
- readList = _A_ 0 _U_ 2 _N_ _N_ _N_ _N_,
- showList = _A_ 0 _U_ 12 _N_ _N_ _N_ _N_ #-}
+ readsPrec = { _A_ 2 _U_ 02 _N_ _S_ "AL" {_A_ 1 _U_ 2 _N_ _N_ _N_ _N_} _N_ _N_ },
+ showsPrec = { _A_ 1 _U_ 222 _N_ _N_ _N_ _N_ },
+ readList = { _A_ 0 _U_ 2 _N_ _N_ _N_ _N_ },
+ showList = { _A_ 0 _U_ 12 _N_ _N_ _N_ _N_ } #-}
instance Text IOError13
{-# GHC_PRAGMA _M_ PreludeIOError {-dfun-} _A_ 0 _N_ _N_ _N_ _F_ _IF_ARGS_ 0 0 X 5 _!_ _TUP_4 [(Int -> [Char] -> [(IOError13, [Char])]), (Int -> IOError13 -> [Char] -> [Char]), ([Char] -> [([IOError13], [Char])]), ([IOError13] -> [Char] -> [Char])] [_CONSTM_ Text readsPrec (IOError13), _CONSTM_ Text showsPrec (IOError13), _CONSTM_ Text readList (IOError13), _CONSTM_ Text showList (IOError13)] _N_
- readsPrec = _A_ 2 _U_ 22 _N_ _S_ _!_ _F_ _IF_ARGS_ 0 2 XX 4 \ (u0 :: Int) (u1 :: [Char]) -> _APP_ _TYAPP_ patError# { (Int -> [Char] -> [(IOError13, [Char])]) } [ _NOREP_S_ "%DPreludeCore.Text.readsPrec\"", u0, u1 ] _N_,
- showsPrec = _A_ 2 _U_ 012 _N_ _S_ "AS" {_A_ 1 _U_ 12 _N_ _N_ _N_ _N_} _N_ _N_,
- readList = _A_ 0 _U_ 2 _N_ _N_ _N_ _N_,
- showList = _A_ 0 _U_ 12 _N_ _N_ _N_ _N_ #-}
+ readsPrec = { _A_ 2 _U_ 02 _N_ _S_ _!_ _N_ _N_ },
+ showsPrec = { _A_ 2 _U_ 012 _N_ _S_ "AS" {_A_ 1 _U_ 12 _N_ _N_ _N_ _N_} _N_ _N_ },
+ readList = { _A_ 0 _U_ 2 _N_ _N_ _N_ _N_ },
+ showList = { _A_ 1 _U_ 12 _N_ _N_ _F_ _IF_ARGS_ 0 1 X 3 \ (u0 :: [IOError13]) -> _APP_ _TYAPP_ _ORIG_ PreludeCore _showList { IOError13 } [ _WRKR_ _CONSTM_ Text showsPrec (IOError13), u0 ] _N_ } #-}
instance Text Int
{-# GHC_PRAGMA _M_ PreludeCore {-dfun-} _A_ 0 _N_ _N_ _N_ _F_ _IF_ARGS_ 0 0 X 5 _!_ _TUP_4 [(Int -> [Char] -> [(Int, [Char])]), (Int -> Int -> [Char] -> [Char]), ([Char] -> [([Int], [Char])]), ([Int] -> [Char] -> [Char])] [_CONSTM_ Text readsPrec (Int), _CONSTM_ Text showsPrec (Int), _CONSTM_ Text readList (Int), _CONSTM_ Text showList (Int)] _N_
- readsPrec = _A_ 2 _U_ 02 _N_ _S_ "AL" {_A_ 1 _U_ 2 _N_ _N_ _F_ _IF_ARGS_ 0 1 X 3 \ (u0 :: [Char]) -> _APP_ _SPEC_ _ORIG_ PreludeText readSigned [ (Int) ] [ _SPEC_ _ORIG_ PreludeText readDec [ (Int) ], u0 ] _N_} _F_ _IF_ARGS_ 0 2 XX 3 \ (u0 :: Int) (u1 :: [Char]) -> _APP_ _SPEC_ _ORIG_ PreludeText readSigned [ (Int) ] [ _SPEC_ _ORIG_ PreludeText readDec [ (Int) ], u1 ] _N_,
- showsPrec = _A_ 3 _U_ 212 _N_ _S_ "LU(P)L" {_A_ 3 _U_ 222 _N_ _N_ _N_ _N_} _N_ _N_,
- readList = _A_ 0 _U_ 2 _N_ _N_ _N_ _N_,
- showList = _A_ 0 _U_ 12 _N_ _N_ _N_ _N_ #-}
+ readsPrec = { _A_ 2 _U_ 02 _N_ _S_ "AL" {_A_ 1 _U_ 2 _N_ _N_ _F_ _IF_ARGS_ 0 1 X 3 \ (u0 :: [Char]) -> _APP_ _SPEC_ _ORIG_ PreludeText readSigned [ (Int) ] [ _SPEC_ _ORIG_ PreludeText readDec [ (Int) ], u0 ] _N_} _F_ _IF_ARGS_ 0 2 XX 3 \ (u0 :: Int) (u1 :: [Char]) -> _APP_ _SPEC_ _ORIG_ PreludeText readSigned [ (Int) ] [ _SPEC_ _ORIG_ PreludeText readDec [ (Int) ], u1 ] _N_ },
+ showsPrec = { _A_ 3 _U_ 212 _N_ _S_ "LU(P)L" {_A_ 3 _U_ 222 _N_ _N_ _N_ _N_} _N_ _N_ },
+ readList = { _A_ 0 _U_ 2 _N_ _N_ _N_ _N_ },
+ showList = { _A_ 1 _U_ 12 _N_ _N_ _N_ _N_ } #-}
instance Text Integer
{-# GHC_PRAGMA _M_ PreludeCore {-dfun-} _A_ 0 _N_ _N_ _N_ _F_ _IF_ARGS_ 0 0 X 5 _!_ _TUP_4 [(Int -> [Char] -> [(Integer, [Char])]), (Int -> Integer -> [Char] -> [Char]), ([Char] -> [([Integer], [Char])]), ([Integer] -> [Char] -> [Char])] [_CONSTM_ Text readsPrec (Integer), _CONSTM_ Text showsPrec (Integer), _CONSTM_ Text readList (Integer), _CONSTM_ Text showList (Integer)] _N_
- readsPrec = _A_ 2 _U_ 02 _N_ _S_ "AL" {_A_ 1 _U_ 2 _N_ _N_ _F_ _IF_ARGS_ 0 1 X 3 \ (u0 :: [Char]) -> _APP_ _SPEC_ _ORIG_ PreludeText readSigned [ (Integer) ] [ _SPEC_ _ORIG_ PreludeText readDec [ (Integer) ], u0 ] _N_} _F_ _IF_ARGS_ 0 2 XX 3 \ (u0 :: Int) (u1 :: [Char]) -> _APP_ _SPEC_ _ORIG_ PreludeText readSigned [ (Integer) ] [ _SPEC_ _ORIG_ PreludeText readDec [ (Integer) ], u1 ] _N_,
- showsPrec = _A_ 3 _U_ 212 _N_ _S_ "LU(PPP)L" {_A_ 5 _U_ 22222 _N_ _N_ _N_ _N_} _N_ _N_,
- readList = _A_ 0 _U_ 2 _N_ _N_ _N_ _N_,
- showList = _A_ 0 _U_ 12 _N_ _N_ _N_ _N_ #-}
+ readsPrec = { _A_ 2 _U_ 02 _N_ _S_ "AL" {_A_ 1 _U_ 2 _N_ _N_ _F_ _IF_ARGS_ 0 1 X 3 \ (u0 :: [Char]) -> _APP_ _SPEC_ _ORIG_ PreludeText readSigned [ (Integer) ] [ _SPEC_ _ORIG_ PreludeText readDec [ (Integer) ], u0 ] _N_} _F_ _IF_ARGS_ 0 2 XX 3 \ (u0 :: Int) (u1 :: [Char]) -> _APP_ _SPEC_ _ORIG_ PreludeText readSigned [ (Integer) ] [ _SPEC_ _ORIG_ PreludeText readDec [ (Integer) ], u1 ] _N_ },
+ showsPrec = { _A_ 3 _U_ 212 _N_ _S_ "LU(PPP)L" {_A_ 5 _U_ 22222 _N_ _N_ _N_ _N_} _N_ _N_ },
+ readList = { _A_ 0 _U_ 2 _N_ _N_ _N_ _N_ },
+ showList = { _A_ 1 _U_ 12 _N_ _N_ _N_ _N_ } #-}
instance Text a => Text (Maybe a)
{-# GHC_PRAGMA _M_ PreludeStdIO {-dfun-} _A_ 1 _U_ 2 _N_ _N_ _N_ _N_ #-}
instance Integral a => Text (Ratio a)
{-# GHC_PRAGMA _M_ PreludeRatio {-dfun-} _A_ 1 _U_ 2 _N_ _N_ _N_ _N_ #-}
instance Text (Ratio Integer)
{-# GHC_PRAGMA _M_ PreludeRatio {-dfun-} _A_ 0 _N_ _N_ _N_ _F_ _IF_ARGS_ 0 0 X 5 _!_ _TUP_4 [(Int -> [Char] -> [(Ratio Integer, [Char])]), (Int -> Ratio Integer -> [Char] -> [Char]), ([Char] -> [([Ratio Integer], [Char])]), ([Ratio Integer] -> [Char] -> [Char])] [_CONSTM_ Text readsPrec (Ratio Integer), _CONSTM_ Text showsPrec (Ratio Integer), _CONSTM_ Text readList (Ratio Integer), _CONSTM_ Text showList (Ratio Integer)] _N_
- readsPrec = _A_ 1 _U_ 12 _N_ _S_ "U(P)" {_A_ 1 _U_ 22 _N_ _N_ _N_ _N_} _N_ _N_,
- showsPrec = _A_ 2 _U_ 112 _N_ _S_ "LU(LL)" {_A_ 3 _U_ 1222 _N_ _N_ _N_ _N_} _N_ _N_,
- readList = _A_ 0 _U_ 2 _N_ _N_ _N_ _N_,
- showList = _A_ 0 _U_ 12 _N_ _N_ _N_ _N_ #-}
+ readsPrec = { _A_ 1 _U_ 12 _N_ _S_ "U(P)" {_A_ 1 _U_ 22 _N_ _N_ _N_ _N_} _N_ _N_ },
+ showsPrec = { _A_ 2 _U_ 112 _N_ _S_ "LU(LL)" {_A_ 3 _U_ 1222 _N_ _N_ _N_ _N_} _N_ _N_ },
+ readList = { _A_ 0 _U_ 2 _N_ _N_ _N_ _N_ },
+ showList = { _A_ 1 _U_ 12 _N_ _N_ _N_ _N_ } #-}
instance Text a => Text [a]
{-# GHC_PRAGMA _M_ PreludeBuiltin {-dfun-} _A_ 1 _U_ 2 _N_ _N_ _N_ _N_ #-}
+instance Text [Bool]
+ {-# GHC_PRAGMA _M_ PreludeBuiltin {-dfun-} _A_ 0 _N_ _N_ _N_ _F_ _IF_ARGS_ 0 0 X 5 _!_ _TUP_4 [(Int -> [Char] -> [([Bool], [Char])]), (Int -> [Bool] -> [Char] -> [Char]), ([Char] -> [([[Bool]], [Char])]), ([[Bool]] -> [Char] -> [Char])] [_CONSTM_ Text readsPrec ([Bool]), _CONSTM_ Text showsPrec ([Bool]), _CONSTM_ Text readList ([Bool]), _CONSTM_ Text showList ([Bool])] _N_
+ readsPrec = { _A_ 1 _U_ 02 _N_ _S_ "A" {_A_ 0 _U_ 2 _N_ _N_ _F_ _IF_ARGS_ 0 0 X 1 _CONSTM_ Text readList (Bool) _N_} _F_ _IF_ARGS_ 0 1 X 1 \ (u0 :: Int) -> _CONSTM_ Text readList (Bool) _N_ },
+ showsPrec = { _A_ 2 _U_ 012 _N_ _S_ "AS" {_A_ 1 _U_ 12 _N_ _N_ _F_ _IF_ARGS_ 0 1 X 3 \ (u0 :: [Bool]) -> _APP_ _TYAPP_ _ORIG_ PreludeCore _showList { Bool } [ _WRKR_ _CONSTM_ Text showsPrec (Bool), u0 ] _N_} _F_ _IF_ARGS_ 0 2 XX 3 \ (u0 :: Int) (u1 :: [Bool]) -> _APP_ _TYAPP_ _ORIG_ PreludeCore _showList { Bool } [ _WRKR_ _CONSTM_ Text showsPrec (Bool), u1 ] _N_ },
+ readList = { _A_ 0 _U_ 2 _N_ _N_ _N_ _N_ },
+ showList = { _A_ 1 _U_ 12 _N_ _N_ _N_ _N_ } #-}
instance Text [Char]
{-# GHC_PRAGMA _M_ PreludeBuiltin {-dfun-} _A_ 0 _N_ _N_ _N_ _F_ _IF_ARGS_ 0 0 X 5 _!_ _TUP_4 [(Int -> [Char] -> [([Char], [Char])]), (Int -> [Char] -> [Char] -> [Char]), ([Char] -> [([[Char]], [Char])]), ([[Char]] -> [Char] -> [Char])] [_CONSTM_ Text readsPrec ([Char]), _CONSTM_ Text showsPrec ([Char]), _CONSTM_ Text readList ([Char]), _CONSTM_ Text showList ([Char])] _N_
- readsPrec = _A_ 1 _U_ 02 _N_ _S_ "A" {_A_ 0 _U_ 2 _N_ _N_ _F_ _IF_ARGS_ 0 0 X 1 _CONSTM_ Text readList (Char) _N_} _F_ _IF_ARGS_ 0 1 X 1 \ (u0 :: Int) -> _CONSTM_ Text readList (Char) _N_,
- showsPrec = _A_ 2 _U_ 022 _N_ _S_ "AL" {_A_ 1 _U_ 22 _N_ _N_ _F_ _IF_ARGS_ 0 0 X 1 _CONSTM_ Text showList (Char) _N_} _F_ _IF_ARGS_ 0 2 XX 2 \ (u0 :: Int) (u1 :: [Char]) -> _APP_ _CONSTM_ Text showList (Char) [ u1 ] _N_,
- readList = _A_ 0 _U_ 2 _N_ _N_ _N_ _N_,
- showList = _A_ 0 _U_ 12 _N_ _N_ _N_ _N_ #-}
+ readsPrec = { _A_ 1 _U_ 02 _N_ _S_ "A" {_A_ 0 _U_ 2 _N_ _N_ _F_ _IF_ARGS_ 0 0 X 1 _CONSTM_ Text readList (Char) _N_} _F_ _IF_ARGS_ 0 1 X 1 \ (u0 :: Int) -> _CONSTM_ Text readList (Char) _N_ },
+ showsPrec = { _A_ 2 _U_ 022 _N_ _S_ "AL" {_A_ 1 _U_ 22 _N_ _N_ _F_ _IF_ARGS_ 0 0 X 1 _CONSTM_ Text showList (Char) _N_} _F_ _IF_ARGS_ 0 2 XX 2 \ (u0 :: Int) (u1 :: [Char]) -> _APP_ _CONSTM_ Text showList (Char) [ u1 ] _N_ },
+ readList = { _A_ 0 _U_ 2 _N_ _N_ _N_ _N_ },
+ showList = { _A_ 1 _U_ 12 _N_ _N_ _F_ _IF_ARGS_ 0 1 X 3 \ (u0 :: [[Char]]) -> _APP_ _TYAPP_ _ORIG_ PreludeCore _showList { [Char] } [ _CONSTM_ Text showList (Char), u0 ] _N_ } #-}
+instance Text [Complex Double]
+ {-# GHC_PRAGMA _M_ PreludeBuiltin {-dfun-} _A_ 0 _N_ _N_ _N_ _F_ _IF_ARGS_ 0 0 X 5 _!_ _TUP_4 [(Int -> [Char] -> [([Complex Double], [Char])]), (Int -> [Complex Double] -> [Char] -> [Char]), ([Char] -> [([[Complex Double]], [Char])]), ([[Complex Double]] -> [Char] -> [Char])] [_CONSTM_ Text readsPrec ([Complex Double]), _CONSTM_ Text showsPrec ([Complex Double]), _CONSTM_ Text readList ([Complex Double]), _CONSTM_ Text showList ([Complex Double])] _N_
+ readsPrec = { _A_ 1 _U_ 02 _N_ _S_ "A" {_A_ 0 _U_ 2 _N_ _N_ _F_ _IF_ARGS_ 0 0 X 1 _CONSTM_ Text readList (Complex Double) _N_} _F_ _IF_ARGS_ 0 1 X 1 \ (u0 :: Int) -> _CONSTM_ Text readList (Complex Double) _N_ },
+ showsPrec = { _A_ 2 _U_ 022 _N_ _S_ "AL" {_A_ 1 _U_ 22 _N_ _N_ _F_ _IF_ARGS_ 0 0 X 1 _CONSTM_ Text showList (Complex Double) _N_} _F_ _IF_ARGS_ 0 2 XX 2 \ (u0 :: Int) (u1 :: [Complex Double]) -> _APP_ _CONSTM_ Text showList (Complex Double) [ u1 ] _N_ },
+ readList = { _A_ 0 _U_ 2 _N_ _N_ _N_ _N_ },
+ showList = { _A_ 1 _U_ 12 _N_ _N_ _F_ _IF_ARGS_ 0 1 X 3 \ (u0 :: [[Complex Double]]) -> _APP_ _TYAPP_ _ORIG_ PreludeCore _showList { [Complex Double] } [ _CONSTM_ Text showList (Complex Double), u0 ] _N_ } #-}
+instance Text [Double]
+ {-# GHC_PRAGMA _M_ PreludeBuiltin {-dfun-} _A_ 0 _N_ _N_ _N_ _F_ _IF_ARGS_ 0 0 X 5 _!_ _TUP_4 [(Int -> [Char] -> [([Double], [Char])]), (Int -> [Double] -> [Char] -> [Char]), ([Char] -> [([[Double]], [Char])]), ([[Double]] -> [Char] -> [Char])] [_CONSTM_ Text readsPrec ([Double]), _CONSTM_ Text showsPrec ([Double]), _CONSTM_ Text readList ([Double]), _CONSTM_ Text showList ([Double])] _N_
+ readsPrec = { _A_ 1 _U_ 02 _N_ _S_ "A" {_A_ 0 _U_ 2 _N_ _N_ _F_ _IF_ARGS_ 0 0 X 1 _CONSTM_ Text readList (Double) _N_} _F_ _IF_ARGS_ 0 1 X 1 \ (u0 :: Int) -> _CONSTM_ Text readList (Double) _N_ },
+ showsPrec = { _A_ 2 _U_ 022 _N_ _S_ "AL" {_A_ 1 _U_ 22 _N_ _N_ _F_ _IF_ARGS_ 0 0 X 1 _CONSTM_ Text showList (Double) _N_} _F_ _IF_ARGS_ 0 2 XX 2 \ (u0 :: Int) (u1 :: [Double]) -> _APP_ _CONSTM_ Text showList (Double) [ u1 ] _N_ },
+ readList = { _A_ 0 _U_ 2 _N_ _N_ _N_ _N_ },
+ showList = { _A_ 1 _U_ 12 _N_ _N_ _F_ _IF_ARGS_ 0 1 X 3 \ (u0 :: [[Double]]) -> _APP_ _TYAPP_ _ORIG_ PreludeCore _showList { [Double] } [ _CONSTM_ Text showList (Double), u0 ] _N_ } #-}
instance Text [Int]
{-# GHC_PRAGMA _M_ PreludeBuiltin {-dfun-} _A_ 0 _N_ _N_ _N_ _F_ _IF_ARGS_ 0 0 X 5 _!_ _TUP_4 [(Int -> [Char] -> [([Int], [Char])]), (Int -> [Int] -> [Char] -> [Char]), ([Char] -> [([[Int]], [Char])]), ([[Int]] -> [Char] -> [Char])] [_CONSTM_ Text readsPrec ([Int]), _CONSTM_ Text showsPrec ([Int]), _CONSTM_ Text readList ([Int]), _CONSTM_ Text showList ([Int])] _N_
- readsPrec = _A_ 1 _U_ 02 _N_ _S_ "A" {_A_ 0 _U_ 2 _N_ _N_ _F_ _IF_ARGS_ 0 0 X 1 _CONSTM_ Text readList (Int) _N_} _F_ _IF_ARGS_ 0 1 X 1 \ (u0 :: Int) -> _CONSTM_ Text readList (Int) _N_,
- showsPrec = _A_ 1 _U_ 022 _N_ _S_ "A" {_A_ 0 _U_ 22 _N_ _N_ _F_ _IF_ARGS_ 0 0 X 1 _CONSTM_ Text showList (Int) _N_} _F_ _IF_ARGS_ 0 1 X 1 \ (u0 :: Int) -> _CONSTM_ Text showList (Int) _N_,
- readList = _A_ 0 _U_ 2 _N_ _N_ _N_ _N_,
- showList = _A_ 0 _U_ 12 _N_ _N_ _N_ _N_ #-}
+ readsPrec = { _A_ 1 _U_ 02 _N_ _S_ "A" {_A_ 0 _U_ 2 _N_ _N_ _F_ _IF_ARGS_ 0 0 X 1 _CONSTM_ Text readList (Int) _N_} _F_ _IF_ARGS_ 0 1 X 1 \ (u0 :: Int) -> _CONSTM_ Text readList (Int) _N_ },
+ showsPrec = { _A_ 2 _U_ 022 _N_ _S_ "AL" {_A_ 1 _U_ 22 _N_ _N_ _F_ _IF_ARGS_ 0 0 X 1 _CONSTM_ Text showList (Int) _N_} _F_ _IF_ARGS_ 0 2 XX 2 \ (u0 :: Int) (u1 :: [Int]) -> _APP_ _CONSTM_ Text showList (Int) [ u1 ] _N_ },
+ readList = { _A_ 0 _U_ 2 _N_ _N_ _N_ _N_ },
+ showList = { _A_ 1 _U_ 12 _N_ _N_ _F_ _IF_ARGS_ 0 1 X 3 \ (u0 :: [[Int]]) -> _APP_ _TYAPP_ _ORIG_ PreludeCore _showList { [Int] } [ _CONSTM_ Text showList (Int), u0 ] _N_ } #-}
+instance Text [Integer]
+ {-# GHC_PRAGMA _M_ PreludeBuiltin {-dfun-} _A_ 0 _N_ _N_ _N_ _F_ _IF_ARGS_ 0 0 X 5 _!_ _TUP_4 [(Int -> [Char] -> [([Integer], [Char])]), (Int -> [Integer] -> [Char] -> [Char]), ([Char] -> [([[Integer]], [Char])]), ([[Integer]] -> [Char] -> [Char])] [_CONSTM_ Text readsPrec ([Integer]), _CONSTM_ Text showsPrec ([Integer]), _CONSTM_ Text readList ([Integer]), _CONSTM_ Text showList ([Integer])] _N_
+ readsPrec = { _A_ 1 _U_ 02 _N_ _S_ "A" {_A_ 0 _U_ 2 _N_ _N_ _F_ _IF_ARGS_ 0 0 X 1 _CONSTM_ Text readList (Integer) _N_} _F_ _IF_ARGS_ 0 1 X 1 \ (u0 :: Int) -> _CONSTM_ Text readList (Integer) _N_ },
+ showsPrec = { _A_ 2 _U_ 022 _N_ _S_ "AL" {_A_ 1 _U_ 22 _N_ _N_ _F_ _IF_ARGS_ 0 0 X 1 _CONSTM_ Text showList (Integer) _N_} _F_ _IF_ARGS_ 0 2 XX 2 \ (u0 :: Int) (u1 :: [Integer]) -> _APP_ _CONSTM_ Text showList (Integer) [ u1 ] _N_ },
+ readList = { _A_ 0 _U_ 2 _N_ _N_ _N_ _N_ },
+ showList = { _A_ 1 _U_ 12 _N_ _N_ _F_ _IF_ARGS_ 0 1 X 3 \ (u0 :: [[Integer]]) -> _APP_ _TYAPP_ _ORIG_ PreludeCore _showList { [Integer] } [ _CONSTM_ Text showList (Integer), u0 ] _N_ } #-}
+instance Text [[Char]]
+ {-# GHC_PRAGMA _M_ PreludeBuiltin {-dfun-} _A_ 0 _N_ _N_ _N_ _F_ _IF_ARGS_ 0 0 X 5 _!_ _TUP_4 [(Int -> [Char] -> [([[Char]], [Char])]), (Int -> [[Char]] -> [Char] -> [Char]), ([Char] -> [([[[Char]]], [Char])]), ([[[Char]]] -> [Char] -> [Char])] [_CONSTM_ Text readsPrec ([[Char]]), _CONSTM_ Text showsPrec ([[Char]]), _CONSTM_ Text readList ([[Char]]), _CONSTM_ Text showList ([[Char]])] _N_
+ readsPrec = { _A_ 1 _U_ 02 _N_ _S_ "A" {_A_ 0 _U_ 2 _N_ _N_ _F_ _IF_ARGS_ 0 0 X 1 _CONSTM_ Text readList ([Char]) _N_} _F_ _IF_ARGS_ 0 1 X 1 \ (u0 :: Int) -> _CONSTM_ Text readList ([Char]) _N_ },
+ showsPrec = { _A_ 2 _U_ 012 _N_ _S_ "AS" {_A_ 1 _U_ 12 _N_ _N_ _F_ _IF_ARGS_ 0 1 X 3 \ (u0 :: [[Char]]) -> _APP_ _TYAPP_ _ORIG_ PreludeCore _showList { [Char] } [ _CONSTM_ Text showList (Char), u0 ] _N_} _F_ _IF_ARGS_ 0 2 XX 2 \ (u0 :: Int) (u1 :: [[Char]]) -> _APP_ _CONSTM_ Text showList ([Char]) [ u1 ] _N_ },
+ readList = { _A_ 0 _U_ 2 _N_ _N_ _N_ _N_ },
+ showList = { _A_ 1 _U_ 12 _N_ _N_ _N_ _N_ } #-}
+instance Text [[Int]]
+ {-# GHC_PRAGMA _M_ PreludeBuiltin {-dfun-} _A_ 0 _N_ _N_ _N_ _F_ _IF_ARGS_ 0 0 X 5 _!_ _TUP_4 [(Int -> [Char] -> [([[Int]], [Char])]), (Int -> [[Int]] -> [Char] -> [Char]), ([Char] -> [([[[Int]]], [Char])]), ([[[Int]]] -> [Char] -> [Char])] [_CONSTM_ Text readsPrec ([[Int]]), _CONSTM_ Text showsPrec ([[Int]]), _CONSTM_ Text readList ([[Int]]), _CONSTM_ Text showList ([[Int]])] _N_
+ readsPrec = { _A_ 1 _U_ 02 _N_ _S_ "A" {_A_ 0 _U_ 2 _N_ _N_ _F_ _IF_ARGS_ 0 0 X 1 _CONSTM_ Text readList ([Int]) _N_} _F_ _IF_ARGS_ 0 1 X 1 \ (u0 :: Int) -> _CONSTM_ Text readList ([Int]) _N_ },
+ showsPrec = { _A_ 2 _U_ 012 _N_ _S_ "AS" {_A_ 1 _U_ 12 _N_ _N_ _F_ _IF_ARGS_ 0 1 X 3 \ (u0 :: [[Int]]) -> _APP_ _TYAPP_ _ORIG_ PreludeCore _showList { [Int] } [ _CONSTM_ Text showList (Int), u0 ] _N_} _F_ _IF_ARGS_ 0 2 XX 2 \ (u0 :: Int) (u1 :: [[Int]]) -> _APP_ _CONSTM_ Text showList ([Int]) [ u1 ] _N_ },
+ readList = { _A_ 0 _U_ 2 _N_ _N_ _N_ _N_ },
+ showList = { _A_ 1 _U_ 12 _N_ _N_ _N_ _N_ } #-}
instance Text _PackedString
{-# GHC_PRAGMA _M_ PreludePS {-dfun-} _A_ 0 _N_ _N_ _N_ _F_ _IF_ARGS_ 0 0 X 5 _!_ _TUP_4 [(Int -> [Char] -> [(_PackedString, [Char])]), (Int -> _PackedString -> [Char] -> [Char]), ([Char] -> [([_PackedString], [Char])]), ([_PackedString] -> [Char] -> [Char])] [_CONSTM_ Text readsPrec (_PackedString), _CONSTM_ Text showsPrec (_PackedString), _CONSTM_ Text readList (_PackedString), _CONSTM_ Text showList (_PackedString)] _N_
- readsPrec = _A_ 2 _U_ 02 _N_ _S_ _!_ _F_ _IF_ARGS_ 0 2 XX 3 \ (u0 :: Int) (u1 :: [Char]) -> _APP_ _TYAPP_ error { ([Char] -> [(_PackedString, [Char])]) } [ _NOREP_S_ "readsPrec: _PackedString: ToDo", u1 ] _N_,
- showsPrec = _A_ 3 _U_ 012 _N_ _S_ "ALL" {_A_ 2 _U_ 12 _N_ _N_ _N_ _N_} _F_ _IF_ARGS_ 0 3 XXX 6 \ (u0 :: Int) (u1 :: _PackedString) (u2 :: [Char]) -> let {(u3 :: [Char]) = _APP_ _ORIG_ PreludePS _unpackPS [ u1 ]} in _APP_ _CONSTM_ Text showList (Char) [ u3, u2 ] _N_,
- readList = _A_ 0 _U_ 2 _N_ _N_ _N_ _N_,
- showList = _A_ 0 _U_ 12 _N_ _N_ _N_ _N_ #-}
+ readsPrec = { _A_ 2 _U_ 02 _N_ _S_ _!_ _N_ _N_ },
+ showsPrec = { _A_ 3 _U_ 012 _N_ _S_ "ALL" {_A_ 2 _U_ 12 _N_ _N_ _N_ _N_} _F_ _IF_ARGS_ 0 3 XXX 6 \ (u0 :: Int) (u1 :: _PackedString) (u2 :: [Char]) -> let {(u3 :: [Char]) = _APP_ _ORIG_ PreludePS _unpackPS [ u1 ]} in _APP_ _CONSTM_ Text showList (Char) [ u3, u2 ] _N_ },
+ readList = { _A_ 0 _U_ 2 _N_ _N_ _N_ _N_ },
+ showList = { _A_ 1 _U_ 12 _N_ _N_ _F_ _IF_ARGS_ 0 1 X 3 \ (u0 :: [_PackedString]) -> _APP_ _TYAPP_ _ORIG_ PreludeCore _showList { _PackedString } [ _WRKR_ _CONSTM_ Text showsPrec (_PackedString), u0 ] _N_ } #-}
instance _CCallable Char
{-# GHC_PRAGMA _M_ PreludeCore {-dfun-} _A_ 0 _N_ _N_ _N_ _F_ _IF_ARGS_ 0 0 X 1 _!_ _TUP_0 [] [] _N_ #-}
instance _CCallable Double
{-# GHC_PRAGMA _M_ PreludeCore {-dfun-} _A_ 0 _N_ _N_ _N_ _F_ _IF_ARGS_ 0 0 X 1 _!_ _TUP_0 [] [] _N_ #-}
instance _CCallable (_MutableByteArray a b)
{-# GHC_PRAGMA _M_ PreludeGlaST {-dfun-} _A_ 0 _N_ _N_ _N_ _F_ _IF_ARGS_ 2 0 X 1 _/\_ u0 u1 -> _!_ _TUP_0 [] [] _N_ #-}
+instance _CCallable (_StablePtr a)
+ {-# GHC_PRAGMA _M_ PreludeCore {-dfun-} _A_ 0 _N_ _N_ _N_ _F_ _IF_ARGS_ 1 0 X 1 _/\_ u0 -> _!_ _TUP_0 [] [] _N_ #-}
instance _CCallable _Word
{-# GHC_PRAGMA _M_ PreludeCore {-dfun-} _A_ 0 _N_ _N_ _N_ _F_ _IF_ARGS_ 0 0 X 1 _!_ _TUP_0 [] [] _N_ #-}
instance _CReturnable ()
{-# GHC_PRAGMA _M_ PreludeCore {-dfun-} _A_ 0 _N_ _N_ _N_ _F_ _IF_ARGS_ 0 0 X 1 _!_ _TUP_0 [] [] _N_ #-}
instance _CReturnable _MallocPtr
{-# GHC_PRAGMA _M_ PreludeCore {-dfun-} _A_ 0 _N_ _N_ _N_ _F_ _IF_ARGS_ 0 0 X 1 _!_ _TUP_0 [] [] _N_ #-}
+instance _CReturnable (_StablePtr a)
+ {-# GHC_PRAGMA _M_ PreludeCore {-dfun-} _A_ 0 _N_ _N_ _N_ _F_ _IF_ARGS_ 1 0 X 1 _/\_ u0 -> _!_ _TUP_0 [] [] _N_ #-}
instance _CReturnable _Word
{-# GHC_PRAGMA _M_ PreludeCore {-dfun-} _A_ 0 _N_ _N_ _N_ _F_ _IF_ARGS_ 0 0 X 1 _!_ _TUP_0 [] [] _N_ #-}
-{-# GHC_PRAGMA INTERFACE VERSION 5 #-}
+{-# GHC_PRAGMA INTERFACE VERSION 6 #-}
interface PreludeCore where
import PreludeArray(Array, Assoc(..), _ByteArray)
import PreludeBuiltin(Bin, Char(..), Double(..), Float(..), Int(..), Integer(..), List(..), Tuple0, Tuple2, Tuple3, Tuple4, Tuple5, _Addr(..), _CMP_TAG(..), _RealWorld(..), _State(..), _Word(..))
class Binary a where
readBin :: Bin -> (a, Bin)
{-# GHC_PRAGMA {-meth-} _A_ 1 _U_ 12 _N_ _S_ "S" _F_ _IF_ARGS_ 1 1 C 2 _/\_ u0 -> \ (u1 :: (Bin -> (u0, Bin), u0 -> Bin -> Bin)) -> case u1 of { _ALG_ _TUP_2 (u2 :: Bin -> (u0, Bin)) (u3 :: u0 -> Bin -> Bin) -> u2; _NO_DEFLT_ } _N_
- {-defm-} _A_ 2 _U_ 02 _N_ _S_ _!_ _F_ _IF_ARGS_ 1 2 XX 3 _/\_ u0 -> \ (u1 :: {{Binary u0}}) (u2 :: Bin) -> _APP_ _TYAPP_ patError# { (Bin -> (u0, Bin)) } [ _NOREP_S_ "%DPreludeCore.Binary.readBin\"", u2 ] _N_ #-}
+ {-defm-} _A_ 2 _U_ 02 _N_ _S_ _!_ _N_ _N_ #-}
showBin :: a -> Bin -> Bin
{-# GHC_PRAGMA {-meth-} _A_ 1 _U_ 122 _N_ _S_ "S" _F_ _IF_ARGS_ 1 1 C 2 _/\_ u0 -> \ (u1 :: (Bin -> (u0, Bin), u0 -> Bin -> Bin)) -> case u1 of { _ALG_ _TUP_2 (u2 :: Bin -> (u0, Bin)) (u3 :: u0 -> Bin -> Bin) -> u3; _NO_DEFLT_ } _N_
- {-defm-} _A_ 3 _U_ 022 _N_ _S_ _!_ _F_ _IF_ARGS_ 1 3 XXX 4 _/\_ u0 -> \ (u1 :: {{Binary u0}}) (u2 :: u0) (u3 :: Bin) -> _APP_ _TYAPP_ patError# { (u0 -> Bin -> Bin) } [ _NOREP_S_ "%DPreludeCore.Binary.showBin\"", u2, u3 ] _N_ #-}
+ {-defm-} _A_ 3 _U_ 022 _N_ _S_ _!_ _N_ _N_ #-}
class (Ord a) => Enum a {-# GHC_PRAGMA {-superdicts-} _A_ 1 _U_ 1 _N_ _S_ "S" _F_ _IF_ARGS_ 1 1 C 2 _/\_ u0 -> \ (u1 :: ({{Ord u0}}, u0 -> [u0], u0 -> u0 -> [u0], u0 -> u0 -> [u0], u0 -> u0 -> u0 -> [u0])) -> case u1 of { _ALG_ _TUP_5 (u2 :: {{Ord u0}}) (u3 :: u0 -> [u0]) (u4 :: u0 -> u0 -> [u0]) (u5 :: u0 -> u0 -> [u0]) (u6 :: u0 -> u0 -> u0 -> [u0]) -> u2; _NO_DEFLT_ } _N_ #-} where
enumFrom :: a -> [a]
{-# GHC_PRAGMA {-meth-} _A_ 1 _U_ 12 _N_ _S_ "S" _F_ _IF_ARGS_ 1 1 C 2 _/\_ u0 -> \ (u1 :: ({{Ord u0}}, u0 -> [u0], u0 -> u0 -> [u0], u0 -> u0 -> [u0], u0 -> u0 -> u0 -> [u0])) -> case u1 of { _ALG_ _TUP_5 (u2 :: {{Ord u0}}) (u3 :: u0 -> [u0]) (u4 :: u0 -> u0 -> [u0]) (u5 :: u0 -> u0 -> [u0]) (u6 :: u0 -> u0 -> u0 -> [u0]) -> u3; _NO_DEFLT_ } _N_
- {-defm-} _A_ 2 _U_ 02 _N_ _S_ _!_ _F_ _IF_ARGS_ 1 2 XX 3 _/\_ u0 -> \ (u1 :: {{Enum u0}}) (u2 :: u0) -> _APP_ _TYAPP_ patError# { (u0 -> [u0]) } [ _NOREP_S_ "%DPreludeCore.Enum.enumFrom\"", u2 ] _N_ #-}
+ {-defm-} _A_ 2 _U_ 02 _N_ _S_ _!_ _N_ _N_ #-}
enumFromThen :: a -> a -> [a]
{-# GHC_PRAGMA {-meth-} _A_ 1 _U_ 122 _N_ _S_ "S" _F_ _IF_ARGS_ 1 1 C 2 _/\_ u0 -> \ (u1 :: ({{Ord u0}}, u0 -> [u0], u0 -> u0 -> [u0], u0 -> u0 -> [u0], u0 -> u0 -> u0 -> [u0])) -> case u1 of { _ALG_ _TUP_5 (u2 :: {{Ord u0}}) (u3 :: u0 -> [u0]) (u4 :: u0 -> u0 -> [u0]) (u5 :: u0 -> u0 -> [u0]) (u6 :: u0 -> u0 -> u0 -> [u0]) -> u4; _NO_DEFLT_ } _N_
- {-defm-} _A_ 3 _U_ 022 _N_ _S_ _!_ _F_ _IF_ARGS_ 1 3 XXX 4 _/\_ u0 -> \ (u1 :: {{Enum u0}}) (u2 :: u0) (u3 :: u0) -> _APP_ _TYAPP_ patError# { (u0 -> u0 -> [u0]) } [ _NOREP_S_ "%DPreludeCore.Enum.enumFromThen\"", u2, u3 ] _N_ #-}
+ {-defm-} _A_ 3 _U_ 022 _N_ _S_ _!_ _N_ _N_ #-}
enumFromTo :: a -> a -> [a]
{-# GHC_PRAGMA {-meth-} _A_ 1 _U_ 122 _N_ _S_ "S" _F_ _IF_ARGS_ 1 1 C 2 _/\_ u0 -> \ (u1 :: ({{Ord u0}}, u0 -> [u0], u0 -> u0 -> [u0], u0 -> u0 -> [u0], u0 -> u0 -> u0 -> [u0])) -> case u1 of { _ALG_ _TUP_5 (u2 :: {{Ord u0}}) (u3 :: u0 -> [u0]) (u4 :: u0 -> u0 -> [u0]) (u5 :: u0 -> u0 -> [u0]) (u6 :: u0 -> u0 -> u0 -> [u0]) -> u5; _NO_DEFLT_ } _N_
{-defm-} _A_ 3 _U_ 122 _N_ _S_ "SLL" _N_ _N_ #-}
class Eq a where
(==) :: a -> a -> Bool
{-# GHC_PRAGMA {-meth-} _A_ 1 _U_ 122 _N_ _S_ "S" _F_ _IF_ARGS_ 1 1 C 2 _/\_ u0 -> \ (u1 :: (u0 -> u0 -> Bool, u0 -> u0 -> Bool)) -> case u1 of { _ALG_ _TUP_2 (u2 :: u0 -> u0 -> Bool) (u3 :: u0 -> u0 -> Bool) -> u2; _NO_DEFLT_ } _N_
- {-defm-} _A_ 3 _U_ 022 _N_ _S_ _!_ _F_ _IF_ARGS_ 1 3 XXX 4 _/\_ u0 -> \ (u1 :: {{Eq u0}}) (u2 :: u0) (u3 :: u0) -> _APP_ _TYAPP_ patError# { (u0 -> u0 -> Bool) } [ _NOREP_S_ "%DPreludeCore.Eq.(==)\"", u2, u3 ] _N_ #-}
+ {-defm-} _A_ 3 _U_ 022 _N_ _S_ _!_ _N_ _N_ #-}
(/=) :: a -> a -> Bool
{-# GHC_PRAGMA {-meth-} _A_ 1 _U_ 122 _N_ _S_ "S" _F_ _IF_ARGS_ 1 1 C 2 _/\_ u0 -> \ (u1 :: (u0 -> u0 -> Bool, u0 -> u0 -> Bool)) -> case u1 of { _ALG_ _TUP_2 (u2 :: u0 -> u0 -> Bool) (u3 :: u0 -> u0 -> Bool) -> u3; _NO_DEFLT_ } _N_
{-defm-} _A_ 3 _U_ 122 _N_ _S_ "SLL" _N_ _N_ #-}
class (Fractional a) => Floating a {-# GHC_PRAGMA {-superdicts-} _A_ 1 _U_ 1 _N_ _S_ "S" _F_ _IF_ARGS_ 1 1 C 2 _/\_ u0 -> \ (u1 :: ({{Fractional u0}}, u0, u0 -> u0, u0 -> u0, u0 -> u0, u0 -> u0 -> u0, u0 -> u0 -> u0, u0 -> u0, u0 -> u0, u0 -> u0, u0 -> u0, u0 -> u0, u0 -> u0, u0 -> u0, u0 -> u0, u0 -> u0, u0 -> u0, u0 -> u0, u0 -> u0)) -> case u1 of { _ALG_ _TUP_19 (u2 :: {{Fractional u0}}) (u3 :: u0) (u4 :: u0 -> u0) (u5 :: u0 -> u0) (u6 :: u0 -> u0) (u7 :: u0 -> u0 -> u0) (u8 :: u0 -> u0 -> u0) (u9 :: u0 -> u0) (ua :: u0 -> u0) (ub :: u0 -> u0) (uc :: u0 -> u0) (ud :: u0 -> u0) (ue :: u0 -> u0) (uf :: u0 -> u0) (ug :: u0 -> u0) (uh :: u0 -> u0) (ui :: u0 -> u0) (uj :: u0 -> u0) (uk :: u0 -> u0) -> u2; _NO_DEFLT_ } _N_ #-} where
pi :: a
{-# GHC_PRAGMA {-meth-} _A_ 1 _U_ 1 _N_ _S_ "S" _F_ _IF_ARGS_ 1 1 C 2 _/\_ u0 -> \ (u1 :: ({{Fractional u0}}, u0, u0 -> u0, u0 -> u0, u0 -> u0, u0 -> u0 -> u0, u0 -> u0 -> u0, u0 -> u0, u0 -> u0, u0 -> u0, u0 -> u0, u0 -> u0, u0 -> u0, u0 -> u0, u0 -> u0, u0 -> u0, u0 -> u0, u0 -> u0, u0 -> u0)) -> case u1 of { _ALG_ _TUP_19 (u2 :: {{Fractional u0}}) (u3 :: u0) (u4 :: u0 -> u0) (u5 :: u0 -> u0) (u6 :: u0 -> u0) (u7 :: u0 -> u0 -> u0) (u8 :: u0 -> u0 -> u0) (u9 :: u0 -> u0) (ua :: u0 -> u0) (ub :: u0 -> u0) (uc :: u0 -> u0) (ud :: u0 -> u0) (ue :: u0 -> u0) (uf :: u0 -> u0) (ug :: u0 -> u0) (uh :: u0 -> u0) (ui :: u0 -> u0) (uj :: u0 -> u0) (uk :: u0 -> u0) -> u3; _NO_DEFLT_ } _N_
- {-defm-} _A_ 1 _U_ 0 _N_ _S_ _!_ _F_ _IF_ARGS_ 1 1 X 2 _/\_ u0 -> \ (u1 :: {{Floating u0}}) -> _APP_ _TYAPP_ patError# { u0 } [ _NOREP_S_ "%DPreludeCore.Floating.pi\"" ] _N_ #-}
+ {-defm-} _A_ 1 _U_ 0 _N_ _S_ _!_ _N_ _N_ #-}
exp :: a -> a
{-# GHC_PRAGMA {-meth-} _A_ 1 _U_ 12 _N_ _S_ "S" _F_ _IF_ARGS_ 1 1 C 2 _/\_ u0 -> \ (u1 :: ({{Fractional u0}}, u0, u0 -> u0, u0 -> u0, u0 -> u0, u0 -> u0 -> u0, u0 -> u0 -> u0, u0 -> u0, u0 -> u0, u0 -> u0, u0 -> u0, u0 -> u0, u0 -> u0, u0 -> u0, u0 -> u0, u0 -> u0, u0 -> u0, u0 -> u0, u0 -> u0)) -> case u1 of { _ALG_ _TUP_19 (u2 :: {{Fractional u0}}) (u3 :: u0) (u4 :: u0 -> u0) (u5 :: u0 -> u0) (u6 :: u0 -> u0) (u7 :: u0 -> u0 -> u0) (u8 :: u0 -> u0 -> u0) (u9 :: u0 -> u0) (ua :: u0 -> u0) (ub :: u0 -> u0) (uc :: u0 -> u0) (ud :: u0 -> u0) (ue :: u0 -> u0) (uf :: u0 -> u0) (ug :: u0 -> u0) (uh :: u0 -> u0) (ui :: u0 -> u0) (uj :: u0 -> u0) (uk :: u0 -> u0) -> u4; _NO_DEFLT_ } _N_
- {-defm-} _A_ 2 _U_ 02 _N_ _S_ _!_ _F_ _IF_ARGS_ 1 2 XX 3 _/\_ u0 -> \ (u1 :: {{Floating u0}}) (u2 :: u0) -> _APP_ _TYAPP_ patError# { (u0 -> u0) } [ _NOREP_S_ "%DPreludeCore.Floating.exp\"", u2 ] _N_ #-}
+ {-defm-} _A_ 2 _U_ 02 _N_ _S_ _!_ _N_ _N_ #-}
log :: a -> a
{-# GHC_PRAGMA {-meth-} _A_ 1 _U_ 12 _N_ _S_ "S" _F_ _IF_ARGS_ 1 1 C 2 _/\_ u0 -> \ (u1 :: ({{Fractional u0}}, u0, u0 -> u0, u0 -> u0, u0 -> u0, u0 -> u0 -> u0, u0 -> u0 -> u0, u0 -> u0, u0 -> u0, u0 -> u0, u0 -> u0, u0 -> u0, u0 -> u0, u0 -> u0, u0 -> u0, u0 -> u0, u0 -> u0, u0 -> u0, u0 -> u0)) -> case u1 of { _ALG_ _TUP_19 (u2 :: {{Fractional u0}}) (u3 :: u0) (u4 :: u0 -> u0) (u5 :: u0 -> u0) (u6 :: u0 -> u0) (u7 :: u0 -> u0 -> u0) (u8 :: u0 -> u0 -> u0) (u9 :: u0 -> u0) (ua :: u0 -> u0) (ub :: u0 -> u0) (uc :: u0 -> u0) (ud :: u0 -> u0) (ue :: u0 -> u0) (uf :: u0 -> u0) (ug :: u0 -> u0) (uh :: u0 -> u0) (ui :: u0 -> u0) (uj :: u0 -> u0) (uk :: u0 -> u0) -> u5; _NO_DEFLT_ } _N_
- {-defm-} _A_ 2 _U_ 02 _N_ _S_ _!_ _F_ _IF_ARGS_ 1 2 XX 3 _/\_ u0 -> \ (u1 :: {{Floating u0}}) (u2 :: u0) -> _APP_ _TYAPP_ patError# { (u0 -> u0) } [ _NOREP_S_ "%DPreludeCore.Floating.log\"", u2 ] _N_ #-}
+ {-defm-} _A_ 2 _U_ 02 _N_ _S_ _!_ _N_ _N_ #-}
sqrt :: a -> a
{-# GHC_PRAGMA {-meth-} _A_ 1 _U_ 12 _N_ _S_ "S" _F_ _IF_ARGS_ 1 1 C 2 _/\_ u0 -> \ (u1 :: ({{Fractional u0}}, u0, u0 -> u0, u0 -> u0, u0 -> u0, u0 -> u0 -> u0, u0 -> u0 -> u0, u0 -> u0, u0 -> u0, u0 -> u0, u0 -> u0, u0 -> u0, u0 -> u0, u0 -> u0, u0 -> u0, u0 -> u0, u0 -> u0, u0 -> u0, u0 -> u0)) -> case u1 of { _ALG_ _TUP_19 (u2 :: {{Fractional u0}}) (u3 :: u0) (u4 :: u0 -> u0) (u5 :: u0 -> u0) (u6 :: u0 -> u0) (u7 :: u0 -> u0 -> u0) (u8 :: u0 -> u0 -> u0) (u9 :: u0 -> u0) (ua :: u0 -> u0) (ub :: u0 -> u0) (uc :: u0 -> u0) (ud :: u0 -> u0) (ue :: u0 -> u0) (uf :: u0 -> u0) (ug :: u0 -> u0) (uh :: u0 -> u0) (ui :: u0 -> u0) (uj :: u0 -> u0) (uk :: u0 -> u0) -> u6; _NO_DEFLT_ } _N_
{-defm-} _A_ 1 _U_ 12 _N_ _S_ "S" _N_ _N_ #-}
{-defm-} _A_ 3 _U_ 122 _N_ _S_ "SLL" _N_ _N_ #-}
sin :: a -> a
{-# GHC_PRAGMA {-meth-} _A_ 1 _U_ 12 _N_ _S_ "S" _F_ _IF_ARGS_ 1 1 C 2 _/\_ u0 -> \ (u1 :: ({{Fractional u0}}, u0, u0 -> u0, u0 -> u0, u0 -> u0, u0 -> u0 -> u0, u0 -> u0 -> u0, u0 -> u0, u0 -> u0, u0 -> u0, u0 -> u0, u0 -> u0, u0 -> u0, u0 -> u0, u0 -> u0, u0 -> u0, u0 -> u0, u0 -> u0, u0 -> u0)) -> case u1 of { _ALG_ _TUP_19 (u2 :: {{Fractional u0}}) (u3 :: u0) (u4 :: u0 -> u0) (u5 :: u0 -> u0) (u6 :: u0 -> u0) (u7 :: u0 -> u0 -> u0) (u8 :: u0 -> u0 -> u0) (u9 :: u0 -> u0) (ua :: u0 -> u0) (ub :: u0 -> u0) (uc :: u0 -> u0) (ud :: u0 -> u0) (ue :: u0 -> u0) (uf :: u0 -> u0) (ug :: u0 -> u0) (uh :: u0 -> u0) (ui :: u0 -> u0) (uj :: u0 -> u0) (uk :: u0 -> u0) -> u9; _NO_DEFLT_ } _N_
- {-defm-} _A_ 2 _U_ 02 _N_ _S_ _!_ _F_ _IF_ARGS_ 1 2 XX 3 _/\_ u0 -> \ (u1 :: {{Floating u0}}) (u2 :: u0) -> _APP_ _TYAPP_ patError# { (u0 -> u0) } [ _NOREP_S_ "%DPreludeCore.Floating.sin\"", u2 ] _N_ #-}
+ {-defm-} _A_ 2 _U_ 02 _N_ _S_ _!_ _N_ _N_ #-}
cos :: a -> a
{-# GHC_PRAGMA {-meth-} _A_ 1 _U_ 12 _N_ _S_ "S" _F_ _IF_ARGS_ 1 1 C 2 _/\_ u0 -> \ (u1 :: ({{Fractional u0}}, u0, u0 -> u0, u0 -> u0, u0 -> u0, u0 -> u0 -> u0, u0 -> u0 -> u0, u0 -> u0, u0 -> u0, u0 -> u0, u0 -> u0, u0 -> u0, u0 -> u0, u0 -> u0, u0 -> u0, u0 -> u0, u0 -> u0, u0 -> u0, u0 -> u0)) -> case u1 of { _ALG_ _TUP_19 (u2 :: {{Fractional u0}}) (u3 :: u0) (u4 :: u0 -> u0) (u5 :: u0 -> u0) (u6 :: u0 -> u0) (u7 :: u0 -> u0 -> u0) (u8 :: u0 -> u0 -> u0) (u9 :: u0 -> u0) (ua :: u0 -> u0) (ub :: u0 -> u0) (uc :: u0 -> u0) (ud :: u0 -> u0) (ue :: u0 -> u0) (uf :: u0 -> u0) (ug :: u0 -> u0) (uh :: u0 -> u0) (ui :: u0 -> u0) (uj :: u0 -> u0) (uk :: u0 -> u0) -> ua; _NO_DEFLT_ } _N_
- {-defm-} _A_ 2 _U_ 02 _N_ _S_ _!_ _F_ _IF_ARGS_ 1 2 XX 3 _/\_ u0 -> \ (u1 :: {{Floating u0}}) (u2 :: u0) -> _APP_ _TYAPP_ patError# { (u0 -> u0) } [ _NOREP_S_ "%DPreludeCore.Floating.cos\"", u2 ] _N_ #-}
+ {-defm-} _A_ 2 _U_ 02 _N_ _S_ _!_ _N_ _N_ #-}
tan :: a -> a
{-# GHC_PRAGMA {-meth-} _A_ 1 _U_ 12 _N_ _S_ "S" _F_ _IF_ARGS_ 1 1 C 2 _/\_ u0 -> \ (u1 :: ({{Fractional u0}}, u0, u0 -> u0, u0 -> u0, u0 -> u0, u0 -> u0 -> u0, u0 -> u0 -> u0, u0 -> u0, u0 -> u0, u0 -> u0, u0 -> u0, u0 -> u0, u0 -> u0, u0 -> u0, u0 -> u0, u0 -> u0, u0 -> u0, u0 -> u0, u0 -> u0)) -> case u1 of { _ALG_ _TUP_19 (u2 :: {{Fractional u0}}) (u3 :: u0) (u4 :: u0 -> u0) (u5 :: u0 -> u0) (u6 :: u0 -> u0) (u7 :: u0 -> u0 -> u0) (u8 :: u0 -> u0 -> u0) (u9 :: u0 -> u0) (ua :: u0 -> u0) (ub :: u0 -> u0) (uc :: u0 -> u0) (ud :: u0 -> u0) (ue :: u0 -> u0) (uf :: u0 -> u0) (ug :: u0 -> u0) (uh :: u0 -> u0) (ui :: u0 -> u0) (uj :: u0 -> u0) (uk :: u0 -> u0) -> ub; _NO_DEFLT_ } _N_
{-defm-} _A_ 2 _U_ 12 _N_ _S_ "SL" _N_ _N_ #-}
asin :: a -> a
{-# GHC_PRAGMA {-meth-} _A_ 1 _U_ 12 _N_ _S_ "S" _F_ _IF_ARGS_ 1 1 C 2 _/\_ u0 -> \ (u1 :: ({{Fractional u0}}, u0, u0 -> u0, u0 -> u0, u0 -> u0, u0 -> u0 -> u0, u0 -> u0 -> u0, u0 -> u0, u0 -> u0, u0 -> u0, u0 -> u0, u0 -> u0, u0 -> u0, u0 -> u0, u0 -> u0, u0 -> u0, u0 -> u0, u0 -> u0, u0 -> u0)) -> case u1 of { _ALG_ _TUP_19 (u2 :: {{Fractional u0}}) (u3 :: u0) (u4 :: u0 -> u0) (u5 :: u0 -> u0) (u6 :: u0 -> u0) (u7 :: u0 -> u0 -> u0) (u8 :: u0 -> u0 -> u0) (u9 :: u0 -> u0) (ua :: u0 -> u0) (ub :: u0 -> u0) (uc :: u0 -> u0) (ud :: u0 -> u0) (ue :: u0 -> u0) (uf :: u0 -> u0) (ug :: u0 -> u0) (uh :: u0 -> u0) (ui :: u0 -> u0) (uj :: u0 -> u0) (uk :: u0 -> u0) -> uc; _NO_DEFLT_ } _N_
- {-defm-} _A_ 2 _U_ 02 _N_ _S_ _!_ _F_ _IF_ARGS_ 1 2 XX 3 _/\_ u0 -> \ (u1 :: {{Floating u0}}) (u2 :: u0) -> _APP_ _TYAPP_ patError# { (u0 -> u0) } [ _NOREP_S_ "%DPreludeCore.Floating.asin\"", u2 ] _N_ #-}
+ {-defm-} _A_ 2 _U_ 02 _N_ _S_ _!_ _N_ _N_ #-}
acos :: a -> a
{-# GHC_PRAGMA {-meth-} _A_ 1 _U_ 12 _N_ _S_ "S" _F_ _IF_ARGS_ 1 1 C 2 _/\_ u0 -> \ (u1 :: ({{Fractional u0}}, u0, u0 -> u0, u0 -> u0, u0 -> u0, u0 -> u0 -> u0, u0 -> u0 -> u0, u0 -> u0, u0 -> u0, u0 -> u0, u0 -> u0, u0 -> u0, u0 -> u0, u0 -> u0, u0 -> u0, u0 -> u0, u0 -> u0, u0 -> u0, u0 -> u0)) -> case u1 of { _ALG_ _TUP_19 (u2 :: {{Fractional u0}}) (u3 :: u0) (u4 :: u0 -> u0) (u5 :: u0 -> u0) (u6 :: u0 -> u0) (u7 :: u0 -> u0 -> u0) (u8 :: u0 -> u0 -> u0) (u9 :: u0 -> u0) (ua :: u0 -> u0) (ub :: u0 -> u0) (uc :: u0 -> u0) (ud :: u0 -> u0) (ue :: u0 -> u0) (uf :: u0 -> u0) (ug :: u0 -> u0) (uh :: u0 -> u0) (ui :: u0 -> u0) (uj :: u0 -> u0) (uk :: u0 -> u0) -> ud; _NO_DEFLT_ } _N_
- {-defm-} _A_ 2 _U_ 02 _N_ _S_ _!_ _F_ _IF_ARGS_ 1 2 XX 3 _/\_ u0 -> \ (u1 :: {{Floating u0}}) (u2 :: u0) -> _APP_ _TYAPP_ patError# { (u0 -> u0) } [ _NOREP_S_ "%DPreludeCore.Floating.acos\"", u2 ] _N_ #-}
+ {-defm-} _A_ 2 _U_ 02 _N_ _S_ _!_ _N_ _N_ #-}
atan :: a -> a
{-# GHC_PRAGMA {-meth-} _A_ 1 _U_ 12 _N_ _S_ "S" _F_ _IF_ARGS_ 1 1 C 2 _/\_ u0 -> \ (u1 :: ({{Fractional u0}}, u0, u0 -> u0, u0 -> u0, u0 -> u0, u0 -> u0 -> u0, u0 -> u0 -> u0, u0 -> u0, u0 -> u0, u0 -> u0, u0 -> u0, u0 -> u0, u0 -> u0, u0 -> u0, u0 -> u0, u0 -> u0, u0 -> u0, u0 -> u0, u0 -> u0)) -> case u1 of { _ALG_ _TUP_19 (u2 :: {{Fractional u0}}) (u3 :: u0) (u4 :: u0 -> u0) (u5 :: u0 -> u0) (u6 :: u0 -> u0) (u7 :: u0 -> u0 -> u0) (u8 :: u0 -> u0 -> u0) (u9 :: u0 -> u0) (ua :: u0 -> u0) (ub :: u0 -> u0) (uc :: u0 -> u0) (ud :: u0 -> u0) (ue :: u0 -> u0) (uf :: u0 -> u0) (ug :: u0 -> u0) (uh :: u0 -> u0) (ui :: u0 -> u0) (uj :: u0 -> u0) (uk :: u0 -> u0) -> ue; _NO_DEFLT_ } _N_
- {-defm-} _A_ 2 _U_ 02 _N_ _S_ _!_ _F_ _IF_ARGS_ 1 2 XX 3 _/\_ u0 -> \ (u1 :: {{Floating u0}}) (u2 :: u0) -> _APP_ _TYAPP_ patError# { (u0 -> u0) } [ _NOREP_S_ "%DPreludeCore.Floating.atan\"", u2 ] _N_ #-}
+ {-defm-} _A_ 2 _U_ 02 _N_ _S_ _!_ _N_ _N_ #-}
sinh :: a -> a
{-# GHC_PRAGMA {-meth-} _A_ 1 _U_ 12 _N_ _S_ "S" _F_ _IF_ARGS_ 1 1 C 2 _/\_ u0 -> \ (u1 :: ({{Fractional u0}}, u0, u0 -> u0, u0 -> u0, u0 -> u0, u0 -> u0 -> u0, u0 -> u0 -> u0, u0 -> u0, u0 -> u0, u0 -> u0, u0 -> u0, u0 -> u0, u0 -> u0, u0 -> u0, u0 -> u0, u0 -> u0, u0 -> u0, u0 -> u0, u0 -> u0)) -> case u1 of { _ALG_ _TUP_19 (u2 :: {{Fractional u0}}) (u3 :: u0) (u4 :: u0 -> u0) (u5 :: u0 -> u0) (u6 :: u0 -> u0) (u7 :: u0 -> u0 -> u0) (u8 :: u0 -> u0 -> u0) (u9 :: u0 -> u0) (ua :: u0 -> u0) (ub :: u0 -> u0) (uc :: u0 -> u0) (ud :: u0 -> u0) (ue :: u0 -> u0) (uf :: u0 -> u0) (ug :: u0 -> u0) (uh :: u0 -> u0) (ui :: u0 -> u0) (uj :: u0 -> u0) (uk :: u0 -> u0) -> uf; _NO_DEFLT_ } _N_
- {-defm-} _A_ 2 _U_ 02 _N_ _S_ _!_ _F_ _IF_ARGS_ 1 2 XX 3 _/\_ u0 -> \ (u1 :: {{Floating u0}}) (u2 :: u0) -> _APP_ _TYAPP_ patError# { (u0 -> u0) } [ _NOREP_S_ "%DPreludeCore.Floating.sinh\"", u2 ] _N_ #-}
+ {-defm-} _A_ 2 _U_ 02 _N_ _S_ _!_ _N_ _N_ #-}
cosh :: a -> a
{-# GHC_PRAGMA {-meth-} _A_ 1 _U_ 12 _N_ _S_ "S" _F_ _IF_ARGS_ 1 1 C 2 _/\_ u0 -> \ (u1 :: ({{Fractional u0}}, u0, u0 -> u0, u0 -> u0, u0 -> u0, u0 -> u0 -> u0, u0 -> u0 -> u0, u0 -> u0, u0 -> u0, u0 -> u0, u0 -> u0, u0 -> u0, u0 -> u0, u0 -> u0, u0 -> u0, u0 -> u0, u0 -> u0, u0 -> u0, u0 -> u0)) -> case u1 of { _ALG_ _TUP_19 (u2 :: {{Fractional u0}}) (u3 :: u0) (u4 :: u0 -> u0) (u5 :: u0 -> u0) (u6 :: u0 -> u0) (u7 :: u0 -> u0 -> u0) (u8 :: u0 -> u0 -> u0) (u9 :: u0 -> u0) (ua :: u0 -> u0) (ub :: u0 -> u0) (uc :: u0 -> u0) (ud :: u0 -> u0) (ue :: u0 -> u0) (uf :: u0 -> u0) (ug :: u0 -> u0) (uh :: u0 -> u0) (ui :: u0 -> u0) (uj :: u0 -> u0) (uk :: u0 -> u0) -> ug; _NO_DEFLT_ } _N_
- {-defm-} _A_ 2 _U_ 02 _N_ _S_ _!_ _F_ _IF_ARGS_ 1 2 XX 3 _/\_ u0 -> \ (u1 :: {{Floating u0}}) (u2 :: u0) -> _APP_ _TYAPP_ patError# { (u0 -> u0) } [ _NOREP_S_ "%DPreludeCore.Floating.cosh\"", u2 ] _N_ #-}
+ {-defm-} _A_ 2 _U_ 02 _N_ _S_ _!_ _N_ _N_ #-}
tanh :: a -> a
{-# GHC_PRAGMA {-meth-} _A_ 1 _U_ 12 _N_ _S_ "S" _F_ _IF_ARGS_ 1 1 C 2 _/\_ u0 -> \ (u1 :: ({{Fractional u0}}, u0, u0 -> u0, u0 -> u0, u0 -> u0, u0 -> u0 -> u0, u0 -> u0 -> u0, u0 -> u0, u0 -> u0, u0 -> u0, u0 -> u0, u0 -> u0, u0 -> u0, u0 -> u0, u0 -> u0, u0 -> u0, u0 -> u0, u0 -> u0, u0 -> u0)) -> case u1 of { _ALG_ _TUP_19 (u2 :: {{Fractional u0}}) (u3 :: u0) (u4 :: u0 -> u0) (u5 :: u0 -> u0) (u6 :: u0 -> u0) (u7 :: u0 -> u0 -> u0) (u8 :: u0 -> u0 -> u0) (u9 :: u0 -> u0) (ua :: u0 -> u0) (ub :: u0 -> u0) (uc :: u0 -> u0) (ud :: u0 -> u0) (ue :: u0 -> u0) (uf :: u0 -> u0) (ug :: u0 -> u0) (uh :: u0 -> u0) (ui :: u0 -> u0) (uj :: u0 -> u0) (uk :: u0 -> u0) -> uh; _NO_DEFLT_ } _N_
{-defm-} _A_ 2 _U_ 12 _N_ _S_ "SL" _N_ _N_ #-}
asinh :: a -> a
{-# GHC_PRAGMA {-meth-} _A_ 1 _U_ 12 _N_ _S_ "S" _F_ _IF_ARGS_ 1 1 C 2 _/\_ u0 -> \ (u1 :: ({{Fractional u0}}, u0, u0 -> u0, u0 -> u0, u0 -> u0, u0 -> u0 -> u0, u0 -> u0 -> u0, u0 -> u0, u0 -> u0, u0 -> u0, u0 -> u0, u0 -> u0, u0 -> u0, u0 -> u0, u0 -> u0, u0 -> u0, u0 -> u0, u0 -> u0, u0 -> u0)) -> case u1 of { _ALG_ _TUP_19 (u2 :: {{Fractional u0}}) (u3 :: u0) (u4 :: u0 -> u0) (u5 :: u0 -> u0) (u6 :: u0 -> u0) (u7 :: u0 -> u0 -> u0) (u8 :: u0 -> u0 -> u0) (u9 :: u0 -> u0) (ua :: u0 -> u0) (ub :: u0 -> u0) (uc :: u0 -> u0) (ud :: u0 -> u0) (ue :: u0 -> u0) (uf :: u0 -> u0) (ug :: u0 -> u0) (uh :: u0 -> u0) (ui :: u0 -> u0) (uj :: u0 -> u0) (uk :: u0 -> u0) -> ui; _NO_DEFLT_ } _N_
- {-defm-} _A_ 2 _U_ 02 _N_ _S_ _!_ _F_ _IF_ARGS_ 1 2 XX 3 _/\_ u0 -> \ (u1 :: {{Floating u0}}) (u2 :: u0) -> _APP_ _TYAPP_ patError# { (u0 -> u0) } [ _NOREP_S_ "%DPreludeCore.Floating.asinh\"", u2 ] _N_ #-}
+ {-defm-} _A_ 2 _U_ 02 _N_ _S_ _!_ _N_ _N_ #-}
acosh :: a -> a
{-# GHC_PRAGMA {-meth-} _A_ 1 _U_ 12 _N_ _S_ "S" _F_ _IF_ARGS_ 1 1 C 2 _/\_ u0 -> \ (u1 :: ({{Fractional u0}}, u0, u0 -> u0, u0 -> u0, u0 -> u0, u0 -> u0 -> u0, u0 -> u0 -> u0, u0 -> u0, u0 -> u0, u0 -> u0, u0 -> u0, u0 -> u0, u0 -> u0, u0 -> u0, u0 -> u0, u0 -> u0, u0 -> u0, u0 -> u0, u0 -> u0)) -> case u1 of { _ALG_ _TUP_19 (u2 :: {{Fractional u0}}) (u3 :: u0) (u4 :: u0 -> u0) (u5 :: u0 -> u0) (u6 :: u0 -> u0) (u7 :: u0 -> u0 -> u0) (u8 :: u0 -> u0 -> u0) (u9 :: u0 -> u0) (ua :: u0 -> u0) (ub :: u0 -> u0) (uc :: u0 -> u0) (ud :: u0 -> u0) (ue :: u0 -> u0) (uf :: u0 -> u0) (ug :: u0 -> u0) (uh :: u0 -> u0) (ui :: u0 -> u0) (uj :: u0 -> u0) (uk :: u0 -> u0) -> uj; _NO_DEFLT_ } _N_
- {-defm-} _A_ 2 _U_ 02 _N_ _S_ _!_ _F_ _IF_ARGS_ 1 2 XX 3 _/\_ u0 -> \ (u1 :: {{Floating u0}}) (u2 :: u0) -> _APP_ _TYAPP_ patError# { (u0 -> u0) } [ _NOREP_S_ "%DPreludeCore.Floating.acosh\"", u2 ] _N_ #-}
+ {-defm-} _A_ 2 _U_ 02 _N_ _S_ _!_ _N_ _N_ #-}
atanh :: a -> a
{-# GHC_PRAGMA {-meth-} _A_ 1 _U_ 12 _N_ _S_ "S" _F_ _IF_ARGS_ 1 1 C 2 _/\_ u0 -> \ (u1 :: ({{Fractional u0}}, u0, u0 -> u0, u0 -> u0, u0 -> u0, u0 -> u0 -> u0, u0 -> u0 -> u0, u0 -> u0, u0 -> u0, u0 -> u0, u0 -> u0, u0 -> u0, u0 -> u0, u0 -> u0, u0 -> u0, u0 -> u0, u0 -> u0, u0 -> u0, u0 -> u0)) -> case u1 of { _ALG_ _TUP_19 (u2 :: {{Fractional u0}}) (u3 :: u0) (u4 :: u0 -> u0) (u5 :: u0 -> u0) (u6 :: u0 -> u0) (u7 :: u0 -> u0 -> u0) (u8 :: u0 -> u0 -> u0) (u9 :: u0 -> u0) (ua :: u0 -> u0) (ub :: u0 -> u0) (uc :: u0 -> u0) (ud :: u0 -> u0) (ue :: u0 -> u0) (uf :: u0 -> u0) (ug :: u0 -> u0) (uh :: u0 -> u0) (ui :: u0 -> u0) (uj :: u0 -> u0) (uk :: u0 -> u0) -> uk; _NO_DEFLT_ } _N_
- {-defm-} _A_ 2 _U_ 02 _N_ _S_ _!_ _F_ _IF_ARGS_ 1 2 XX 3 _/\_ u0 -> \ (u1 :: {{Floating u0}}) (u2 :: u0) -> _APP_ _TYAPP_ patError# { (u0 -> u0) } [ _NOREP_S_ "%DPreludeCore.Floating.atanh\"", u2 ] _N_ #-}
+ {-defm-} _A_ 2 _U_ 02 _N_ _S_ _!_ _N_ _N_ #-}
class (Num a) => Fractional a {-# GHC_PRAGMA {-superdicts-} _A_ 1 _U_ 1 _N_ _S_ "S" _F_ _IF_ARGS_ 1 1 C 2 _/\_ u0 -> \ (u1 :: ({{Num u0}}, u0 -> u0 -> u0, u0 -> u0, Ratio Integer -> u0)) -> case u1 of { _ALG_ _TUP_4 (u2 :: {{Num u0}}) (u3 :: u0 -> u0 -> u0) (u4 :: u0 -> u0) (u5 :: Ratio Integer -> u0) -> u2; _NO_DEFLT_ } _N_ #-} where
(/) :: a -> a -> a
{-# GHC_PRAGMA {-meth-} _A_ 1 _U_ 122 _N_ _S_ "S" _F_ _IF_ARGS_ 1 1 C 2 _/\_ u0 -> \ (u1 :: ({{Num u0}}, u0 -> u0 -> u0, u0 -> u0, Ratio Integer -> u0)) -> case u1 of { _ALG_ _TUP_4 (u2 :: {{Num u0}}) (u3 :: u0 -> u0 -> u0) (u4 :: u0 -> u0) (u5 :: Ratio Integer -> u0) -> u3; _NO_DEFLT_ } _N_
- {-defm-} _A_ 3 _U_ 022 _N_ _S_ _!_ _F_ _IF_ARGS_ 1 3 XXX 4 _/\_ u0 -> \ (u1 :: {{Fractional u0}}) (u2 :: u0) (u3 :: u0) -> _APP_ _TYAPP_ patError# { (u0 -> u0 -> u0) } [ _NOREP_S_ "%DPreludeCore.Fractional.(/)\"", u2, u3 ] _N_ #-}
+ {-defm-} _A_ 3 _U_ 022 _N_ _S_ _!_ _N_ _N_ #-}
recip :: a -> a
{-# GHC_PRAGMA {-meth-} _A_ 1 _U_ 12 _N_ _S_ "S" _F_ _IF_ARGS_ 1 1 C 2 _/\_ u0 -> \ (u1 :: ({{Num u0}}, u0 -> u0 -> u0, u0 -> u0, Ratio Integer -> u0)) -> case u1 of { _ALG_ _TUP_4 (u2 :: {{Num u0}}) (u3 :: u0 -> u0 -> u0) (u4 :: u0 -> u0) (u5 :: Ratio Integer -> u0) -> u4; _NO_DEFLT_ } _N_
{-defm-} _A_ 1 _U_ 12 _N_ _S_ "S" _N_ _N_ #-}
fromRational :: Ratio Integer -> a
{-# GHC_PRAGMA {-meth-} _A_ 1 _U_ 12 _N_ _S_ "S" _F_ _IF_ARGS_ 1 1 C 2 _/\_ u0 -> \ (u1 :: ({{Num u0}}, u0 -> u0 -> u0, u0 -> u0, Ratio Integer -> u0)) -> case u1 of { _ALG_ _TUP_4 (u2 :: {{Num u0}}) (u3 :: u0 -> u0 -> u0) (u4 :: u0 -> u0) (u5 :: Ratio Integer -> u0) -> u5; _NO_DEFLT_ } _N_
- {-defm-} _A_ 2 _U_ 02 _N_ _S_ _!_ _F_ _IF_ARGS_ 1 2 XX 3 _/\_ u0 -> \ (u1 :: {{Fractional u0}}) (u2 :: Ratio Integer) -> _APP_ _TYAPP_ patError# { (Ratio Integer -> u0) } [ _NOREP_S_ "%DPreludeCore.Fractional.fromRational\"", u2 ] _N_ #-}
+ {-defm-} _A_ 2 _U_ 02 _N_ _S_ _!_ _N_ _N_ #-}
class (Real a, Ix a) => Integral a {-# GHC_PRAGMA {-superdicts-} _A_ 1 _U_ 1 _N_ _S_ "S" _F_ _IF_ARGS_ 1 1 C 2 _/\_ u0 -> \ (u1 :: ({{Real u0}}, {{Ix u0}}, u0 -> u0 -> u0, u0 -> u0 -> u0, u0 -> u0 -> u0, u0 -> u0 -> u0, u0 -> u0 -> (u0, u0), u0 -> u0 -> (u0, u0), u0 -> Bool, u0 -> Bool, u0 -> Integer, u0 -> Int)) -> case u1 of { _ALG_ _TUP_12 (u2 :: {{Real u0}}) (u3 :: {{Ix u0}}) (u4 :: u0 -> u0 -> u0) (u5 :: u0 -> u0 -> u0) (u6 :: u0 -> u0 -> u0) (u7 :: u0 -> u0 -> u0) (u8 :: u0 -> u0 -> (u0, u0)) (u9 :: u0 -> u0 -> (u0, u0)) (ua :: u0 -> Bool) (ub :: u0 -> Bool) (uc :: u0 -> Integer) (ud :: u0 -> Int) -> u2; _NO_DEFLT_ } _N_, _A_ 1 _U_ 1 _N_ _S_ "S" _F_ _IF_ARGS_ 1 1 C 2 _/\_ u0 -> \ (u1 :: ({{Real u0}}, {{Ix u0}}, u0 -> u0 -> u0, u0 -> u0 -> u0, u0 -> u0 -> u0, u0 -> u0 -> u0, u0 -> u0 -> (u0, u0), u0 -> u0 -> (u0, u0), u0 -> Bool, u0 -> Bool, u0 -> Integer, u0 -> Int)) -> case u1 of { _ALG_ _TUP_12 (u2 :: {{Real u0}}) (u3 :: {{Ix u0}}) (u4 :: u0 -> u0 -> u0) (u5 :: u0 -> u0 -> u0) (u6 :: u0 -> u0 -> u0) (u7 :: u0 -> u0 -> u0) (u8 :: u0 -> u0 -> (u0, u0)) (u9 :: u0 -> u0 -> (u0, u0)) (ua :: u0 -> Bool) (ub :: u0 -> Bool) (uc :: u0 -> Integer) (ud :: u0 -> Int) -> u3; _NO_DEFLT_ } _N_ #-} where
quot :: a -> a -> a
{-# GHC_PRAGMA {-meth-} _A_ 1 _U_ 122 _N_ _S_ "S" _F_ _IF_ARGS_ 1 1 C 2 _/\_ u0 -> \ (u1 :: ({{Real u0}}, {{Ix u0}}, u0 -> u0 -> u0, u0 -> u0 -> u0, u0 -> u0 -> u0, u0 -> u0 -> u0, u0 -> u0 -> (u0, u0), u0 -> u0 -> (u0, u0), u0 -> Bool, u0 -> Bool, u0 -> Integer, u0 -> Int)) -> case u1 of { _ALG_ _TUP_12 (u2 :: {{Real u0}}) (u3 :: {{Ix u0}}) (u4 :: u0 -> u0 -> u0) (u5 :: u0 -> u0 -> u0) (u6 :: u0 -> u0 -> u0) (u7 :: u0 -> u0 -> u0) (u8 :: u0 -> u0 -> (u0, u0)) (u9 :: u0 -> u0 -> (u0, u0)) (ua :: u0 -> Bool) (ub :: u0 -> Bool) (uc :: u0 -> Integer) (ud :: u0 -> Int) -> u4; _NO_DEFLT_ } _N_
{-defm-} _A_ 3 _U_ 122 _N_ _S_ "SLL" _F_ _IF_ARGS_ 1 3 CXX 6 _/\_ u0 -> \ (u1 :: {{Integral u0}}) (u2 :: u0) (u3 :: u0) -> case case u1 of { _ALG_ _TUP_12 (u4 :: {{Real u0}}) (u5 :: {{Ix u0}}) (u6 :: u0 -> u0 -> u0) (u7 :: u0 -> u0 -> u0) (u8 :: u0 -> u0 -> u0) (u9 :: u0 -> u0 -> u0) (ua :: u0 -> u0 -> (u0, u0)) (ub :: u0 -> u0 -> (u0, u0)) (uc :: u0 -> Bool) (ud :: u0 -> Bool) (ue :: u0 -> Integer) (uf :: u0 -> Int) -> _APP_ ub [ u2, u3 ]; _NO_DEFLT_ } of { _ALG_ _TUP_2 (ug :: u0) (uh :: u0) -> uh; _NO_DEFLT_ } _N_ #-}
quotRem :: a -> a -> (a, a)
{-# GHC_PRAGMA {-meth-} _A_ 1 _U_ 122 _N_ _S_ "S" _F_ _IF_ARGS_ 1 1 C 2 _/\_ u0 -> \ (u1 :: ({{Real u0}}, {{Ix u0}}, u0 -> u0 -> u0, u0 -> u0 -> u0, u0 -> u0 -> u0, u0 -> u0 -> u0, u0 -> u0 -> (u0, u0), u0 -> u0 -> (u0, u0), u0 -> Bool, u0 -> Bool, u0 -> Integer, u0 -> Int)) -> case u1 of { _ALG_ _TUP_12 (u2 :: {{Real u0}}) (u3 :: {{Ix u0}}) (u4 :: u0 -> u0 -> u0) (u5 :: u0 -> u0 -> u0) (u6 :: u0 -> u0 -> u0) (u7 :: u0 -> u0 -> u0) (u8 :: u0 -> u0 -> (u0, u0)) (u9 :: u0 -> u0 -> (u0, u0)) (ua :: u0 -> Bool) (ub :: u0 -> Bool) (uc :: u0 -> Integer) (ud :: u0 -> Int) -> u8; _NO_DEFLT_ } _N_
- {-defm-} _A_ 3 _U_ 022 _N_ _S_ _!_ _F_ _IF_ARGS_ 1 3 XXX 4 _/\_ u0 -> \ (u1 :: {{Integral u0}}) (u2 :: u0) (u3 :: u0) -> _APP_ _TYAPP_ patError# { (u0 -> u0 -> (u0, u0)) } [ _NOREP_S_ "%DPreludeCore.Integral.quotRem\"", u2, u3 ] _N_ #-}
+ {-defm-} _A_ 3 _U_ 022 _N_ _S_ _!_ _N_ _N_ #-}
divMod :: a -> a -> (a, a)
{-# GHC_PRAGMA {-meth-} _A_ 1 _U_ 122 _N_ _S_ "S" _F_ _IF_ARGS_ 1 1 C 2 _/\_ u0 -> \ (u1 :: ({{Real u0}}, {{Ix u0}}, u0 -> u0 -> u0, u0 -> u0 -> u0, u0 -> u0 -> u0, u0 -> u0 -> u0, u0 -> u0 -> (u0, u0), u0 -> u0 -> (u0, u0), u0 -> Bool, u0 -> Bool, u0 -> Integer, u0 -> Int)) -> case u1 of { _ALG_ _TUP_12 (u2 :: {{Real u0}}) (u3 :: {{Ix u0}}) (u4 :: u0 -> u0 -> u0) (u5 :: u0 -> u0 -> u0) (u6 :: u0 -> u0 -> u0) (u7 :: u0 -> u0 -> u0) (u8 :: u0 -> u0 -> (u0, u0)) (u9 :: u0 -> u0 -> (u0, u0)) (ua :: u0 -> Bool) (ub :: u0 -> Bool) (uc :: u0 -> Integer) (ud :: u0 -> Int) -> u9; _NO_DEFLT_ } _N_
{-defm-} _A_ 1 _U_ 122 _N_ _S_ "S" _N_ _N_ #-}
{-defm-} _A_ 1 _U_ 12 _N_ _S_ "S" _N_ _N_ #-}
toInteger :: a -> Integer
{-# GHC_PRAGMA {-meth-} _A_ 1 _U_ 12 _N_ _S_ "S" _F_ _IF_ARGS_ 1 1 C 2 _/\_ u0 -> \ (u1 :: ({{Real u0}}, {{Ix u0}}, u0 -> u0 -> u0, u0 -> u0 -> u0, u0 -> u0 -> u0, u0 -> u0 -> u0, u0 -> u0 -> (u0, u0), u0 -> u0 -> (u0, u0), u0 -> Bool, u0 -> Bool, u0 -> Integer, u0 -> Int)) -> case u1 of { _ALG_ _TUP_12 (u2 :: {{Real u0}}) (u3 :: {{Ix u0}}) (u4 :: u0 -> u0 -> u0) (u5 :: u0 -> u0 -> u0) (u6 :: u0 -> u0 -> u0) (u7 :: u0 -> u0 -> u0) (u8 :: u0 -> u0 -> (u0, u0)) (u9 :: u0 -> u0 -> (u0, u0)) (ua :: u0 -> Bool) (ub :: u0 -> Bool) (uc :: u0 -> Integer) (ud :: u0 -> Int) -> uc; _NO_DEFLT_ } _N_
- {-defm-} _A_ 2 _U_ 02 _N_ _S_ _!_ _F_ _IF_ARGS_ 1 2 XX 3 _/\_ u0 -> \ (u1 :: {{Integral u0}}) (u2 :: u0) -> _APP_ _TYAPP_ patError# { (u0 -> Integer) } [ _NOREP_S_ "%DPreludeCore.Integral.toInteger\"", u2 ] _N_ #-}
+ {-defm-} _A_ 2 _U_ 02 _N_ _S_ _!_ _N_ _N_ #-}
toInt :: a -> Int
{-# GHC_PRAGMA {-meth-} _A_ 1 _U_ 12 _N_ _S_ "S" _F_ _IF_ARGS_ 1 1 C 2 _/\_ u0 -> \ (u1 :: ({{Real u0}}, {{Ix u0}}, u0 -> u0 -> u0, u0 -> u0 -> u0, u0 -> u0 -> u0, u0 -> u0 -> u0, u0 -> u0 -> (u0, u0), u0 -> u0 -> (u0, u0), u0 -> Bool, u0 -> Bool, u0 -> Integer, u0 -> Int)) -> case u1 of { _ALG_ _TUP_12 (u2 :: {{Real u0}}) (u3 :: {{Ix u0}}) (u4 :: u0 -> u0 -> u0) (u5 :: u0 -> u0 -> u0) (u6 :: u0 -> u0 -> u0) (u7 :: u0 -> u0 -> u0) (u8 :: u0 -> u0 -> (u0, u0)) (u9 :: u0 -> u0 -> (u0, u0)) (ua :: u0 -> Bool) (ub :: u0 -> Bool) (uc :: u0 -> Integer) (ud :: u0 -> Int) -> ud; _NO_DEFLT_ } _N_
- {-defm-} _A_ 2 _U_ 02 _N_ _S_ _!_ _F_ _IF_ARGS_ 1 2 XX 3 _/\_ u0 -> \ (u1 :: {{Integral u0}}) (u2 :: u0) -> _APP_ _TYAPP_ patError# { (u0 -> Int) } [ _NOREP_S_ "%DPreludeCore.Integral.toInt\"", u2 ] _N_ #-}
+ {-defm-} _A_ 2 _U_ 02 _N_ _S_ _!_ _N_ _N_ #-}
class (Ord a) => Ix a {-# GHC_PRAGMA {-superdicts-} _A_ 1 _U_ 1 _N_ _S_ "S" _F_ _IF_ARGS_ 1 1 C 2 _/\_ u0 -> \ (u1 :: ({{Ord u0}}, (u0, u0) -> [u0], (u0, u0) -> u0 -> Int, (u0, u0) -> u0 -> Bool)) -> case u1 of { _ALG_ _TUP_4 (u2 :: {{Ord u0}}) (u3 :: (u0, u0) -> [u0]) (u4 :: (u0, u0) -> u0 -> Int) (u5 :: (u0, u0) -> u0 -> Bool) -> u2; _NO_DEFLT_ } _N_ #-} where
range :: (a, a) -> [a]
{-# GHC_PRAGMA {-meth-} _A_ 1 _U_ 12 _N_ _S_ "S" _F_ _IF_ARGS_ 1 1 C 2 _/\_ u0 -> \ (u1 :: ({{Ord u0}}, (u0, u0) -> [u0], (u0, u0) -> u0 -> Int, (u0, u0) -> u0 -> Bool)) -> case u1 of { _ALG_ _TUP_4 (u2 :: {{Ord u0}}) (u3 :: (u0, u0) -> [u0]) (u4 :: (u0, u0) -> u0 -> Int) (u5 :: (u0, u0) -> u0 -> Bool) -> u3; _NO_DEFLT_ } _N_
- {-defm-} _A_ 2 _U_ 02 _N_ _S_ _!_ _F_ _IF_ARGS_ 1 2 XX 3 _/\_ u0 -> \ (u1 :: {{Ix u0}}) (u2 :: (u0, u0)) -> _APP_ _TYAPP_ patError# { ((u0, u0) -> [u0]) } [ _NOREP_S_ "%DPreludeCore.Ix.range\"", u2 ] _N_ #-}
+ {-defm-} _A_ 2 _U_ 02 _N_ _S_ _!_ _N_ _N_ #-}
index :: (a, a) -> a -> Int
{-# GHC_PRAGMA {-meth-} _A_ 1 _U_ 122 _N_ _S_ "S" _F_ _IF_ARGS_ 1 1 C 2 _/\_ u0 -> \ (u1 :: ({{Ord u0}}, (u0, u0) -> [u0], (u0, u0) -> u0 -> Int, (u0, u0) -> u0 -> Bool)) -> case u1 of { _ALG_ _TUP_4 (u2 :: {{Ord u0}}) (u3 :: (u0, u0) -> [u0]) (u4 :: (u0, u0) -> u0 -> Int) (u5 :: (u0, u0) -> u0 -> Bool) -> u4; _NO_DEFLT_ } _N_
- {-defm-} _A_ 3 _U_ 022 _N_ _S_ _!_ _F_ _IF_ARGS_ 1 3 XXX 4 _/\_ u0 -> \ (u1 :: {{Ix u0}}) (u2 :: (u0, u0)) (u3 :: u0) -> _APP_ _TYAPP_ patError# { ((u0, u0) -> u0 -> Int) } [ _NOREP_S_ "%DPreludeCore.Ix.index\"", u2, u3 ] _N_ #-}
+ {-defm-} _A_ 3 _U_ 022 _N_ _S_ _!_ _N_ _N_ #-}
inRange :: (a, a) -> a -> Bool
{-# GHC_PRAGMA {-meth-} _A_ 1 _U_ 122 _N_ _S_ "S" _F_ _IF_ARGS_ 1 1 C 2 _/\_ u0 -> \ (u1 :: ({{Ord u0}}, (u0, u0) -> [u0], (u0, u0) -> u0 -> Int, (u0, u0) -> u0 -> Bool)) -> case u1 of { _ALG_ _TUP_4 (u2 :: {{Ord u0}}) (u3 :: (u0, u0) -> [u0]) (u4 :: (u0, u0) -> u0 -> Int) (u5 :: (u0, u0) -> u0 -> Bool) -> u5; _NO_DEFLT_ } _N_
- {-defm-} _A_ 3 _U_ 022 _N_ _S_ _!_ _F_ _IF_ARGS_ 1 3 XXX 4 _/\_ u0 -> \ (u1 :: {{Ix u0}}) (u2 :: (u0, u0)) (u3 :: u0) -> _APP_ _TYAPP_ patError# { ((u0, u0) -> u0 -> Bool) } [ _NOREP_S_ "%DPreludeCore.Ix.inRange\"", u2, u3 ] _N_ #-}
+ {-defm-} _A_ 3 _U_ 022 _N_ _S_ _!_ _N_ _N_ #-}
class (Eq a, Text a) => Num a {-# GHC_PRAGMA {-superdicts-} _A_ 1 _U_ 1 _N_ _S_ "S" _F_ _IF_ARGS_ 1 1 C 2 _/\_ u0 -> \ (u1 :: ({{Eq u0}}, {{Text u0}}, u0 -> u0 -> u0, u0 -> u0 -> u0, u0 -> u0 -> u0, u0 -> u0, u0 -> u0, u0 -> u0, Integer -> u0, Int -> u0)) -> case u1 of { _ALG_ _TUP_10 (u2 :: {{Eq u0}}) (u3 :: {{Text u0}}) (u4 :: u0 -> u0 -> u0) (u5 :: u0 -> u0 -> u0) (u6 :: u0 -> u0 -> u0) (u7 :: u0 -> u0) (u8 :: u0 -> u0) (u9 :: u0 -> u0) (ua :: Integer -> u0) (ub :: Int -> u0) -> u2; _NO_DEFLT_ } _N_, _A_ 1 _U_ 1 _N_ _S_ "S" _F_ _IF_ARGS_ 1 1 C 2 _/\_ u0 -> \ (u1 :: ({{Eq u0}}, {{Text u0}}, u0 -> u0 -> u0, u0 -> u0 -> u0, u0 -> u0 -> u0, u0 -> u0, u0 -> u0, u0 -> u0, Integer -> u0, Int -> u0)) -> case u1 of { _ALG_ _TUP_10 (u2 :: {{Eq u0}}) (u3 :: {{Text u0}}) (u4 :: u0 -> u0 -> u0) (u5 :: u0 -> u0 -> u0) (u6 :: u0 -> u0 -> u0) (u7 :: u0 -> u0) (u8 :: u0 -> u0) (u9 :: u0 -> u0) (ua :: Integer -> u0) (ub :: Int -> u0) -> u3; _NO_DEFLT_ } _N_ #-} where
(+) :: a -> a -> a
{-# GHC_PRAGMA {-meth-} _A_ 1 _U_ 122 _N_ _S_ "S" _F_ _IF_ARGS_ 1 1 C 2 _/\_ u0 -> \ (u1 :: ({{Eq u0}}, {{Text u0}}, u0 -> u0 -> u0, u0 -> u0 -> u0, u0 -> u0 -> u0, u0 -> u0, u0 -> u0, u0 -> u0, Integer -> u0, Int -> u0)) -> case u1 of { _ALG_ _TUP_10 (u2 :: {{Eq u0}}) (u3 :: {{Text u0}}) (u4 :: u0 -> u0 -> u0) (u5 :: u0 -> u0 -> u0) (u6 :: u0 -> u0 -> u0) (u7 :: u0 -> u0) (u8 :: u0 -> u0) (u9 :: u0 -> u0) (ua :: Integer -> u0) (ub :: Int -> u0) -> u4; _NO_DEFLT_ } _N_
- {-defm-} _A_ 3 _U_ 022 _N_ _S_ _!_ _F_ _IF_ARGS_ 1 3 XXX 4 _/\_ u0 -> \ (u1 :: {{Num u0}}) (u2 :: u0) (u3 :: u0) -> _APP_ _TYAPP_ patError# { (u0 -> u0 -> u0) } [ _NOREP_S_ "%DPreludeCore.Num.(+)\"", u2, u3 ] _N_ #-}
+ {-defm-} _A_ 3 _U_ 022 _N_ _S_ _!_ _N_ _N_ #-}
(-) :: a -> a -> a
{-# GHC_PRAGMA {-meth-} _A_ 1 _U_ 122 _N_ _S_ "S" _F_ _IF_ARGS_ 1 1 C 2 _/\_ u0 -> \ (u1 :: ({{Eq u0}}, {{Text u0}}, u0 -> u0 -> u0, u0 -> u0 -> u0, u0 -> u0 -> u0, u0 -> u0, u0 -> u0, u0 -> u0, Integer -> u0, Int -> u0)) -> case u1 of { _ALG_ _TUP_10 (u2 :: {{Eq u0}}) (u3 :: {{Text u0}}) (u4 :: u0 -> u0 -> u0) (u5 :: u0 -> u0 -> u0) (u6 :: u0 -> u0 -> u0) (u7 :: u0 -> u0) (u8 :: u0 -> u0) (u9 :: u0 -> u0) (ua :: Integer -> u0) (ub :: Int -> u0) -> u5; _NO_DEFLT_ } _N_
{-defm-} _A_ 3 _U_ 122 _N_ _S_ "SLL" _F_ _ALWAYS_ _/\_ u0 -> \ (u1 :: {{Num u0}}) (u2 :: u0) (u3 :: u0) -> case u1 of { _ALG_ _TUP_10 (u4 :: {{Eq u0}}) (u5 :: {{Text u0}}) (u6 :: u0 -> u0 -> u0) (u7 :: u0 -> u0 -> u0) (u8 :: u0 -> u0 -> u0) (u9 :: u0 -> u0) (ua :: u0 -> u0) (ub :: u0 -> u0) (uc :: Integer -> u0) (ud :: Int -> u0) -> let {(ue :: u0) = _APP_ u9 [ u3 ]} in _APP_ u6 [ u2, ue ]; _NO_DEFLT_ } _N_ #-}
(*) :: a -> a -> a
{-# GHC_PRAGMA {-meth-} _A_ 1 _U_ 122 _N_ _S_ "S" _F_ _IF_ARGS_ 1 1 C 2 _/\_ u0 -> \ (u1 :: ({{Eq u0}}, {{Text u0}}, u0 -> u0 -> u0, u0 -> u0 -> u0, u0 -> u0 -> u0, u0 -> u0, u0 -> u0, u0 -> u0, Integer -> u0, Int -> u0)) -> case u1 of { _ALG_ _TUP_10 (u2 :: {{Eq u0}}) (u3 :: {{Text u0}}) (u4 :: u0 -> u0 -> u0) (u5 :: u0 -> u0 -> u0) (u6 :: u0 -> u0 -> u0) (u7 :: u0 -> u0) (u8 :: u0 -> u0) (u9 :: u0 -> u0) (ua :: Integer -> u0) (ub :: Int -> u0) -> u6; _NO_DEFLT_ } _N_
- {-defm-} _A_ 3 _U_ 022 _N_ _S_ _!_ _F_ _IF_ARGS_ 1 3 XXX 4 _/\_ u0 -> \ (u1 :: {{Num u0}}) (u2 :: u0) (u3 :: u0) -> _APP_ _TYAPP_ patError# { (u0 -> u0 -> u0) } [ _NOREP_S_ "%DPreludeCore.Num.(*)\"", u2, u3 ] _N_ #-}
+ {-defm-} _A_ 3 _U_ 022 _N_ _S_ _!_ _N_ _N_ #-}
negate :: a -> a
{-# GHC_PRAGMA {-meth-} _A_ 1 _U_ 12 _N_ _S_ "S" _F_ _IF_ARGS_ 1 1 C 2 _/\_ u0 -> \ (u1 :: ({{Eq u0}}, {{Text u0}}, u0 -> u0 -> u0, u0 -> u0 -> u0, u0 -> u0 -> u0, u0 -> u0, u0 -> u0, u0 -> u0, Integer -> u0, Int -> u0)) -> case u1 of { _ALG_ _TUP_10 (u2 :: {{Eq u0}}) (u3 :: {{Text u0}}) (u4 :: u0 -> u0 -> u0) (u5 :: u0 -> u0 -> u0) (u6 :: u0 -> u0 -> u0) (u7 :: u0 -> u0) (u8 :: u0 -> u0) (u9 :: u0 -> u0) (ua :: Integer -> u0) (ub :: Int -> u0) -> u7; _NO_DEFLT_ } _N_
- {-defm-} _A_ 2 _U_ 02 _N_ _S_ _!_ _F_ _IF_ARGS_ 1 2 XX 3 _/\_ u0 -> \ (u1 :: {{Num u0}}) (u2 :: u0) -> _APP_ _TYAPP_ patError# { (u0 -> u0) } [ _NOREP_S_ "%DPreludeCore.Num.negate\"", u2 ] _N_ #-}
+ {-defm-} _A_ 2 _U_ 02 _N_ _S_ _!_ _N_ _N_ #-}
abs :: a -> a
{-# GHC_PRAGMA {-meth-} _A_ 1 _U_ 12 _N_ _S_ "S" _F_ _IF_ARGS_ 1 1 C 2 _/\_ u0 -> \ (u1 :: ({{Eq u0}}, {{Text u0}}, u0 -> u0 -> u0, u0 -> u0 -> u0, u0 -> u0 -> u0, u0 -> u0, u0 -> u0, u0 -> u0, Integer -> u0, Int -> u0)) -> case u1 of { _ALG_ _TUP_10 (u2 :: {{Eq u0}}) (u3 :: {{Text u0}}) (u4 :: u0 -> u0 -> u0) (u5 :: u0 -> u0 -> u0) (u6 :: u0 -> u0 -> u0) (u7 :: u0 -> u0) (u8 :: u0 -> u0) (u9 :: u0 -> u0) (ua :: Integer -> u0) (ub :: Int -> u0) -> u8; _NO_DEFLT_ } _N_
- {-defm-} _A_ 2 _U_ 02 _N_ _S_ _!_ _F_ _IF_ARGS_ 1 2 XX 3 _/\_ u0 -> \ (u1 :: {{Num u0}}) (u2 :: u0) -> _APP_ _TYAPP_ patError# { (u0 -> u0) } [ _NOREP_S_ "%DPreludeCore.Num.abs\"", u2 ] _N_ #-}
+ {-defm-} _A_ 2 _U_ 02 _N_ _S_ _!_ _N_ _N_ #-}
signum :: a -> a
{-# GHC_PRAGMA {-meth-} _A_ 1 _U_ 12 _N_ _S_ "S" _F_ _IF_ARGS_ 1 1 C 2 _/\_ u0 -> \ (u1 :: ({{Eq u0}}, {{Text u0}}, u0 -> u0 -> u0, u0 -> u0 -> u0, u0 -> u0 -> u0, u0 -> u0, u0 -> u0, u0 -> u0, Integer -> u0, Int -> u0)) -> case u1 of { _ALG_ _TUP_10 (u2 :: {{Eq u0}}) (u3 :: {{Text u0}}) (u4 :: u0 -> u0 -> u0) (u5 :: u0 -> u0 -> u0) (u6 :: u0 -> u0 -> u0) (u7 :: u0 -> u0) (u8 :: u0 -> u0) (u9 :: u0 -> u0) (ua :: Integer -> u0) (ub :: Int -> u0) -> u9; _NO_DEFLT_ } _N_
- {-defm-} _A_ 2 _U_ 02 _N_ _S_ _!_ _F_ _IF_ARGS_ 1 2 XX 3 _/\_ u0 -> \ (u1 :: {{Num u0}}) (u2 :: u0) -> _APP_ _TYAPP_ patError# { (u0 -> u0) } [ _NOREP_S_ "%DPreludeCore.Num.signum\"", u2 ] _N_ #-}
+ {-defm-} _A_ 2 _U_ 02 _N_ _S_ _!_ _N_ _N_ #-}
fromInteger :: Integer -> a
{-# GHC_PRAGMA {-meth-} _A_ 1 _U_ 12 _N_ _S_ "S" _F_ _IF_ARGS_ 1 1 C 2 _/\_ u0 -> \ (u1 :: ({{Eq u0}}, {{Text u0}}, u0 -> u0 -> u0, u0 -> u0 -> u0, u0 -> u0 -> u0, u0 -> u0, u0 -> u0, u0 -> u0, Integer -> u0, Int -> u0)) -> case u1 of { _ALG_ _TUP_10 (u2 :: {{Eq u0}}) (u3 :: {{Text u0}}) (u4 :: u0 -> u0 -> u0) (u5 :: u0 -> u0 -> u0) (u6 :: u0 -> u0 -> u0) (u7 :: u0 -> u0) (u8 :: u0 -> u0) (u9 :: u0 -> u0) (ua :: Integer -> u0) (ub :: Int -> u0) -> ua; _NO_DEFLT_ } _N_
- {-defm-} _A_ 2 _U_ 02 _N_ _S_ _!_ _F_ _IF_ARGS_ 1 2 XX 3 _/\_ u0 -> \ (u1 :: {{Num u0}}) (u2 :: Integer) -> _APP_ _TYAPP_ patError# { (Integer -> u0) } [ _NOREP_S_ "%DPreludeCore.Num.fromInteger\"", u2 ] _N_ #-}
+ {-defm-} _A_ 2 _U_ 02 _N_ _S_ _!_ _N_ _N_ #-}
fromInt :: Int -> a
{-# GHC_PRAGMA {-meth-} _A_ 1 _U_ 12 _N_ _S_ "S" _F_ _IF_ARGS_ 1 1 C 2 _/\_ u0 -> \ (u1 :: ({{Eq u0}}, {{Text u0}}, u0 -> u0 -> u0, u0 -> u0 -> u0, u0 -> u0 -> u0, u0 -> u0, u0 -> u0, u0 -> u0, Integer -> u0, Int -> u0)) -> case u1 of { _ALG_ _TUP_10 (u2 :: {{Eq u0}}) (u3 :: {{Text u0}}) (u4 :: u0 -> u0 -> u0) (u5 :: u0 -> u0 -> u0) (u6 :: u0 -> u0 -> u0) (u7 :: u0 -> u0) (u8 :: u0 -> u0) (u9 :: u0 -> u0) (ua :: Integer -> u0) (ub :: Int -> u0) -> ub; _NO_DEFLT_ } _N_
{-defm-} _A_ 2 _U_ 11 _N_ _S_ "SL" _F_ _IF_ARGS_ 1 2 CC 6 _/\_ u0 -> \ (u1 :: {{Num u0}}) (u2 :: Int) -> let {(u4 :: Integer) = case u2 of { _ALG_ I# (u3 :: Int#) -> _#_ int2Integer# [] [u3]; _NO_DEFLT_ }} in case u1 of { _ALG_ _TUP_10 (u5 :: {{Eq u0}}) (u6 :: {{Text u0}}) (u7 :: u0 -> u0 -> u0) (u8 :: u0 -> u0 -> u0) (u9 :: u0 -> u0 -> u0) (ua :: u0 -> u0) (ub :: u0 -> u0) (uc :: u0 -> u0) (ud :: Integer -> u0) (ue :: Int -> u0) -> _APP_ ud [ u4 ]; _NO_DEFLT_ } _N_ #-}
{-defm-} _A_ 3 _U_ 122 _N_ _S_ "SLL" _N_ _N_ #-}
(<=) :: a -> a -> Bool
{-# GHC_PRAGMA {-meth-} _A_ 1 _U_ 122 _N_ _S_ "S" _F_ _IF_ARGS_ 1 1 C 2 _/\_ u0 -> \ (u1 :: ({{Eq u0}}, u0 -> u0 -> Bool, u0 -> u0 -> Bool, u0 -> u0 -> Bool, u0 -> u0 -> Bool, u0 -> u0 -> u0, u0 -> u0 -> u0, u0 -> u0 -> _CMP_TAG)) -> case u1 of { _ALG_ _TUP_8 (u2 :: {{Eq u0}}) (u3 :: u0 -> u0 -> Bool) (u4 :: u0 -> u0 -> Bool) (u5 :: u0 -> u0 -> Bool) (u6 :: u0 -> u0 -> Bool) (u7 :: u0 -> u0 -> u0) (u8 :: u0 -> u0 -> u0) (u9 :: u0 -> u0 -> _CMP_TAG) -> u4; _NO_DEFLT_ } _N_
- {-defm-} _A_ 3 _U_ 022 _N_ _S_ _!_ _F_ _IF_ARGS_ 1 3 XXX 4 _/\_ u0 -> \ (u1 :: {{Ord u0}}) (u2 :: u0) (u3 :: u0) -> _APP_ _TYAPP_ patError# { (u0 -> u0 -> Bool) } [ _NOREP_S_ "%DPreludeCore.Ord.(<=)\"", u2, u3 ] _N_ #-}
+ {-defm-} _A_ 3 _U_ 022 _N_ _S_ _!_ _N_ _N_ #-}
(>=) :: a -> a -> Bool
{-# GHC_PRAGMA {-meth-} _A_ 1 _U_ 122 _N_ _S_ "S" _F_ _IF_ARGS_ 1 1 C 2 _/\_ u0 -> \ (u1 :: ({{Eq u0}}, u0 -> u0 -> Bool, u0 -> u0 -> Bool, u0 -> u0 -> Bool, u0 -> u0 -> Bool, u0 -> u0 -> u0, u0 -> u0 -> u0, u0 -> u0 -> _CMP_TAG)) -> case u1 of { _ALG_ _TUP_8 (u2 :: {{Eq u0}}) (u3 :: u0 -> u0 -> Bool) (u4 :: u0 -> u0 -> Bool) (u5 :: u0 -> u0 -> Bool) (u6 :: u0 -> u0 -> Bool) (u7 :: u0 -> u0 -> u0) (u8 :: u0 -> u0 -> u0) (u9 :: u0 -> u0 -> _CMP_TAG) -> u5; _NO_DEFLT_ } _N_
{-defm-} _A_ 3 _U_ 122 _N_ _S_ "SLL" _F_ _IF_ARGS_ 1 3 CXX 4 _/\_ u0 -> \ (u1 :: {{Ord u0}}) (u2 :: u0) (u3 :: u0) -> case u1 of { _ALG_ _TUP_8 (u4 :: {{Eq u0}}) (u5 :: u0 -> u0 -> Bool) (u6 :: u0 -> u0 -> Bool) (u7 :: u0 -> u0 -> Bool) (u8 :: u0 -> u0 -> Bool) (u9 :: u0 -> u0 -> u0) (ua :: u0 -> u0 -> u0) (ub :: u0 -> u0 -> _CMP_TAG) -> _APP_ u6 [ u3, u2 ]; _NO_DEFLT_ } _N_ #-}
class (Num a, Enum a) => Real a {-# GHC_PRAGMA {-superdicts-} _A_ 1 _U_ 1 _N_ _S_ "S" _F_ _IF_ARGS_ 1 1 C 2 _/\_ u0 -> \ (u1 :: ({{Num u0}}, {{Enum u0}}, u0 -> Ratio Integer)) -> case u1 of { _ALG_ _TUP_3 (u2 :: {{Num u0}}) (u3 :: {{Enum u0}}) (u4 :: u0 -> Ratio Integer) -> u2; _NO_DEFLT_ } _N_, _A_ 1 _U_ 1 _N_ _S_ "S" _F_ _IF_ARGS_ 1 1 C 2 _/\_ u0 -> \ (u1 :: ({{Num u0}}, {{Enum u0}}, u0 -> Ratio Integer)) -> case u1 of { _ALG_ _TUP_3 (u2 :: {{Num u0}}) (u3 :: {{Enum u0}}) (u4 :: u0 -> Ratio Integer) -> u3; _NO_DEFLT_ } _N_ #-} where
toRational :: a -> Ratio Integer
{-# GHC_PRAGMA {-meth-} _A_ 1 _U_ 12 _N_ _S_ "S" _F_ _IF_ARGS_ 1 1 C 2 _/\_ u0 -> \ (u1 :: ({{Num u0}}, {{Enum u0}}, u0 -> Ratio Integer)) -> case u1 of { _ALG_ _TUP_3 (u2 :: {{Num u0}}) (u3 :: {{Enum u0}}) (u4 :: u0 -> Ratio Integer) -> u4; _NO_DEFLT_ } _N_
- {-defm-} _A_ 2 _U_ 02 _N_ _S_ _!_ _F_ _IF_ARGS_ 1 2 XX 3 _/\_ u0 -> \ (u1 :: {{Real u0}}) (u2 :: u0) -> _APP_ _TYAPP_ patError# { (u0 -> Ratio Integer) } [ _NOREP_S_ "%DPreludeCore.Real.toRational\"", u2 ] _N_ #-}
+ {-defm-} _A_ 2 _U_ 02 _N_ _S_ _!_ _N_ _N_ #-}
class (RealFrac a, Floating a) => RealFloat a {-# GHC_PRAGMA {-superdicts-} _A_ 1 _U_ 1 _N_ _S_ "S" _F_ _IF_ARGS_ 1 1 C 2 _/\_ u0 -> \ (u1 :: ({{RealFrac u0}}, {{Floating u0}}, u0 -> Integer, u0 -> Int, u0 -> (Int, Int), u0 -> (Integer, Int), Integer -> Int -> u0, u0 -> Int, u0 -> u0, Int -> u0 -> u0)) -> case u1 of { _ALG_ _TUP_10 (u2 :: {{RealFrac u0}}) (u3 :: {{Floating u0}}) (u4 :: u0 -> Integer) (u5 :: u0 -> Int) (u6 :: u0 -> (Int, Int)) (u7 :: u0 -> (Integer, Int)) (u8 :: Integer -> Int -> u0) (u9 :: u0 -> Int) (ua :: u0 -> u0) (ub :: Int -> u0 -> u0) -> u2; _NO_DEFLT_ } _N_, _A_ 1 _U_ 1 _N_ _S_ "S" _F_ _IF_ARGS_ 1 1 C 2 _/\_ u0 -> \ (u1 :: ({{RealFrac u0}}, {{Floating u0}}, u0 -> Integer, u0 -> Int, u0 -> (Int, Int), u0 -> (Integer, Int), Integer -> Int -> u0, u0 -> Int, u0 -> u0, Int -> u0 -> u0)) -> case u1 of { _ALG_ _TUP_10 (u2 :: {{RealFrac u0}}) (u3 :: {{Floating u0}}) (u4 :: u0 -> Integer) (u5 :: u0 -> Int) (u6 :: u0 -> (Int, Int)) (u7 :: u0 -> (Integer, Int)) (u8 :: Integer -> Int -> u0) (u9 :: u0 -> Int) (ua :: u0 -> u0) (ub :: Int -> u0 -> u0) -> u3; _NO_DEFLT_ } _N_ #-} where
floatRadix :: a -> Integer
{-# GHC_PRAGMA {-meth-} _A_ 1 _U_ 12 _N_ _S_ "S" _F_ _IF_ARGS_ 1 1 C 2 _/\_ u0 -> \ (u1 :: ({{RealFrac u0}}, {{Floating u0}}, u0 -> Integer, u0 -> Int, u0 -> (Int, Int), u0 -> (Integer, Int), Integer -> Int -> u0, u0 -> Int, u0 -> u0, Int -> u0 -> u0)) -> case u1 of { _ALG_ _TUP_10 (u2 :: {{RealFrac u0}}) (u3 :: {{Floating u0}}) (u4 :: u0 -> Integer) (u5 :: u0 -> Int) (u6 :: u0 -> (Int, Int)) (u7 :: u0 -> (Integer, Int)) (u8 :: Integer -> Int -> u0) (u9 :: u0 -> Int) (ua :: u0 -> u0) (ub :: Int -> u0 -> u0) -> u4; _NO_DEFLT_ } _N_
- {-defm-} _A_ 2 _U_ 02 _N_ _S_ _!_ _F_ _IF_ARGS_ 1 2 XX 3 _/\_ u0 -> \ (u1 :: {{RealFloat u0}}) (u2 :: u0) -> _APP_ _TYAPP_ patError# { (u0 -> Integer) } [ _NOREP_S_ "%DPreludeCore.RealFloat.floatRadix\"", u2 ] _N_ #-}
+ {-defm-} _A_ 2 _U_ 02 _N_ _S_ _!_ _N_ _N_ #-}
floatDigits :: a -> Int
{-# GHC_PRAGMA {-meth-} _A_ 1 _U_ 12 _N_ _S_ "S" _F_ _IF_ARGS_ 1 1 C 2 _/\_ u0 -> \ (u1 :: ({{RealFrac u0}}, {{Floating u0}}, u0 -> Integer, u0 -> Int, u0 -> (Int, Int), u0 -> (Integer, Int), Integer -> Int -> u0, u0 -> Int, u0 -> u0, Int -> u0 -> u0)) -> case u1 of { _ALG_ _TUP_10 (u2 :: {{RealFrac u0}}) (u3 :: {{Floating u0}}) (u4 :: u0 -> Integer) (u5 :: u0 -> Int) (u6 :: u0 -> (Int, Int)) (u7 :: u0 -> (Integer, Int)) (u8 :: Integer -> Int -> u0) (u9 :: u0 -> Int) (ua :: u0 -> u0) (ub :: Int -> u0 -> u0) -> u5; _NO_DEFLT_ } _N_
- {-defm-} _A_ 2 _U_ 02 _N_ _S_ _!_ _F_ _IF_ARGS_ 1 2 XX 3 _/\_ u0 -> \ (u1 :: {{RealFloat u0}}) (u2 :: u0) -> _APP_ _TYAPP_ patError# { (u0 -> Int) } [ _NOREP_S_ "%DPreludeCore.RealFloat.floatDigits\"", u2 ] _N_ #-}
+ {-defm-} _A_ 2 _U_ 02 _N_ _S_ _!_ _N_ _N_ #-}
floatRange :: a -> (Int, Int)
{-# GHC_PRAGMA {-meth-} _A_ 1 _U_ 12 _N_ _S_ "S" _F_ _IF_ARGS_ 1 1 C 2 _/\_ u0 -> \ (u1 :: ({{RealFrac u0}}, {{Floating u0}}, u0 -> Integer, u0 -> Int, u0 -> (Int, Int), u0 -> (Integer, Int), Integer -> Int -> u0, u0 -> Int, u0 -> u0, Int -> u0 -> u0)) -> case u1 of { _ALG_ _TUP_10 (u2 :: {{RealFrac u0}}) (u3 :: {{Floating u0}}) (u4 :: u0 -> Integer) (u5 :: u0 -> Int) (u6 :: u0 -> (Int, Int)) (u7 :: u0 -> (Integer, Int)) (u8 :: Integer -> Int -> u0) (u9 :: u0 -> Int) (ua :: u0 -> u0) (ub :: Int -> u0 -> u0) -> u6; _NO_DEFLT_ } _N_
- {-defm-} _A_ 2 _U_ 02 _N_ _S_ _!_ _F_ _IF_ARGS_ 1 2 XX 3 _/\_ u0 -> \ (u1 :: {{RealFloat u0}}) (u2 :: u0) -> _APP_ _TYAPP_ patError# { (u0 -> (Int, Int)) } [ _NOREP_S_ "%DPreludeCore.RealFloat.floatRange\"", u2 ] _N_ #-}
+ {-defm-} _A_ 2 _U_ 02 _N_ _S_ _!_ _N_ _N_ #-}
decodeFloat :: a -> (Integer, Int)
{-# GHC_PRAGMA {-meth-} _A_ 1 _U_ 12 _N_ _S_ "S" _F_ _IF_ARGS_ 1 1 C 2 _/\_ u0 -> \ (u1 :: ({{RealFrac u0}}, {{Floating u0}}, u0 -> Integer, u0 -> Int, u0 -> (Int, Int), u0 -> (Integer, Int), Integer -> Int -> u0, u0 -> Int, u0 -> u0, Int -> u0 -> u0)) -> case u1 of { _ALG_ _TUP_10 (u2 :: {{RealFrac u0}}) (u3 :: {{Floating u0}}) (u4 :: u0 -> Integer) (u5 :: u0 -> Int) (u6 :: u0 -> (Int, Int)) (u7 :: u0 -> (Integer, Int)) (u8 :: Integer -> Int -> u0) (u9 :: u0 -> Int) (ua :: u0 -> u0) (ub :: Int -> u0 -> u0) -> u7; _NO_DEFLT_ } _N_
- {-defm-} _A_ 2 _U_ 02 _N_ _S_ _!_ _F_ _IF_ARGS_ 1 2 XX 3 _/\_ u0 -> \ (u1 :: {{RealFloat u0}}) (u2 :: u0) -> _APP_ _TYAPP_ patError# { (u0 -> (Integer, Int)) } [ _NOREP_S_ "%DPreludeCore.RealFloat.decodeFloat\"", u2 ] _N_ #-}
+ {-defm-} _A_ 2 _U_ 02 _N_ _S_ _!_ _N_ _N_ #-}
encodeFloat :: Integer -> Int -> a
{-# GHC_PRAGMA {-meth-} _A_ 1 _U_ 122 _N_ _S_ "S" _F_ _IF_ARGS_ 1 1 C 2 _/\_ u0 -> \ (u1 :: ({{RealFrac u0}}, {{Floating u0}}, u0 -> Integer, u0 -> Int, u0 -> (Int, Int), u0 -> (Integer, Int), Integer -> Int -> u0, u0 -> Int, u0 -> u0, Int -> u0 -> u0)) -> case u1 of { _ALG_ _TUP_10 (u2 :: {{RealFrac u0}}) (u3 :: {{Floating u0}}) (u4 :: u0 -> Integer) (u5 :: u0 -> Int) (u6 :: u0 -> (Int, Int)) (u7 :: u0 -> (Integer, Int)) (u8 :: Integer -> Int -> u0) (u9 :: u0 -> Int) (ua :: u0 -> u0) (ub :: Int -> u0 -> u0) -> u8; _NO_DEFLT_ } _N_
- {-defm-} _A_ 3 _U_ 022 _N_ _S_ _!_ _F_ _IF_ARGS_ 1 3 XXX 4 _/\_ u0 -> \ (u1 :: {{RealFloat u0}}) (u2 :: Integer) (u3 :: Int) -> _APP_ _TYAPP_ patError# { (Integer -> Int -> u0) } [ _NOREP_S_ "%DPreludeCore.RealFloat.encodeFloat\"", u2, u3 ] _N_ #-}
+ {-defm-} _A_ 3 _U_ 022 _N_ _S_ _!_ _N_ _N_ #-}
exponent :: a -> Int
{-# GHC_PRAGMA {-meth-} _A_ 1 _U_ 12 _N_ _S_ "S" _F_ _IF_ARGS_ 1 1 C 2 _/\_ u0 -> \ (u1 :: ({{RealFrac u0}}, {{Floating u0}}, u0 -> Integer, u0 -> Int, u0 -> (Int, Int), u0 -> (Integer, Int), Integer -> Int -> u0, u0 -> Int, u0 -> u0, Int -> u0 -> u0)) -> case u1 of { _ALG_ _TUP_10 (u2 :: {{RealFrac u0}}) (u3 :: {{Floating u0}}) (u4 :: u0 -> Integer) (u5 :: u0 -> Int) (u6 :: u0 -> (Int, Int)) (u7 :: u0 -> (Integer, Int)) (u8 :: Integer -> Int -> u0) (u9 :: u0 -> Int) (ua :: u0 -> u0) (ub :: Int -> u0 -> u0) -> u9; _NO_DEFLT_ } _N_
{-defm-} _A_ 2 _U_ 12 _N_ _S_ "SL" _N_ _N_ #-}
class (Real a, Fractional a) => RealFrac a {-# GHC_PRAGMA {-superdicts-} _A_ 1 _U_ 1 _N_ _S_ "S" _F_ _IF_ARGS_ 1 1 C 2 _/\_ u0 -> \ (u1 :: ({{Real u0}}, {{Fractional u0}}, (_forall_ z$z1 =>{{Integral z$z1}} -> u0 -> (z$z1, u0)), (_forall_ z$z1 =>{{Integral z$z1}} -> u0 -> z$z1), (_forall_ z$z1 =>{{Integral z$z1}} -> u0 -> z$z1), (_forall_ z$z1 =>{{Integral z$z1}} -> u0 -> z$z1), (_forall_ z$z1 =>{{Integral z$z1}} -> u0 -> z$z1))) -> case u1 of { _ALG_ _TUP_7 (u2 :: {{Real u0}}) (u3 :: {{Fractional u0}}) (u4 :: _forall_ a$z1 =>{{Integral a$z1}} -> u0 -> (a$z1, u0)) (u5 :: _forall_ a$z1 =>{{Integral a$z1}} -> u0 -> a$z1) (u6 :: _forall_ a$z1 =>{{Integral a$z1}} -> u0 -> a$z1) (u7 :: _forall_ a$z1 =>{{Integral a$z1}} -> u0 -> a$z1) (u8 :: _forall_ a$z1 =>{{Integral a$z1}} -> u0 -> a$z1) -> u2; _NO_DEFLT_ } _N_, _A_ 1 _U_ 1 _N_ _S_ "S" _F_ _IF_ARGS_ 1 1 C 2 _/\_ u0 -> \ (u1 :: ({{Real u0}}, {{Fractional u0}}, (_forall_ z$z1 =>{{Integral z$z1}} -> u0 -> (z$z1, u0)), (_forall_ z$z1 =>{{Integral z$z1}} -> u0 -> z$z1), (_forall_ z$z1 =>{{Integral z$z1}} -> u0 -> z$z1), (_forall_ z$z1 =>{{Integral z$z1}} -> u0 -> z$z1), (_forall_ z$z1 =>{{Integral z$z1}} -> u0 -> z$z1))) -> case u1 of { _ALG_ _TUP_7 (u2 :: {{Real u0}}) (u3 :: {{Fractional u0}}) (u4 :: _forall_ a$z1 =>{{Integral a$z1}} -> u0 -> (a$z1, u0)) (u5 :: _forall_ a$z1 =>{{Integral a$z1}} -> u0 -> a$z1) (u6 :: _forall_ a$z1 =>{{Integral a$z1}} -> u0 -> a$z1) (u7 :: _forall_ a$z1 =>{{Integral a$z1}} -> u0 -> a$z1) (u8 :: _forall_ a$z1 =>{{Integral a$z1}} -> u0 -> a$z1) -> u3; _NO_DEFLT_ } _N_ #-} where
properFraction :: Integral b => a -> (b, a)
{-# GHC_PRAGMA {-meth-} _A_ 2 _U_ 122 _N_ _S_ "SL" _F_ _IF_ARGS_ 2 2 CX 3 _/\_ u0 u1 -> \ (u2 :: ({{Real u0}}, {{Fractional u0}}, (_forall_ z$z1 =>{{Integral z$z1}} -> u0 -> (z$z1, u0)), (_forall_ z$z1 =>{{Integral z$z1}} -> u0 -> z$z1), (_forall_ z$z1 =>{{Integral z$z1}} -> u0 -> z$z1), (_forall_ z$z1 =>{{Integral z$z1}} -> u0 -> z$z1), (_forall_ z$z1 =>{{Integral z$z1}} -> u0 -> z$z1))) (u3 :: {{Integral u1}}) -> case u2 of { _ALG_ _TUP_7 (u4 :: {{Real u0}}) (u5 :: {{Fractional u0}}) (u6 :: _forall_ a$z1 =>{{Integral a$z1}} -> u0 -> (a$z1, u0)) (u7 :: _forall_ a$z1 =>{{Integral a$z1}} -> u0 -> a$z1) (u8 :: _forall_ a$z1 =>{{Integral a$z1}} -> u0 -> a$z1) (u9 :: _forall_ a$z1 =>{{Integral a$z1}} -> u0 -> a$z1) (ua :: _forall_ a$z1 =>{{Integral a$z1}} -> u0 -> a$z1) -> _APP_ _TYAPP_ u6 { u1 } [ u3 ]; _NO_DEFLT_ } _N_
- {-defm-} _A_ 3 _U_ 002 _N_ _S_ _!_ _F_ _IF_ARGS_ 2 3 XXX 3 _/\_ u0 u1 -> \ (u2 :: {{RealFrac u0}}) (u3 :: {{Integral u1}}) (u4 :: u0) -> _APP_ _TYAPP_ patError# { (u0 -> (u1, u0)) } [ _NOREP_S_ "%DPreludeCore.RealFrac.properFraction\"", u4 ] _N_ #-}
+ {-defm-} _A_ 3 _U_ 002 _N_ _S_ _!_ _N_ _N_ #-}
truncate :: Integral b => a -> b
{-# GHC_PRAGMA {-meth-} _A_ 2 _U_ 122 _N_ _S_ "SL" _F_ _IF_ARGS_ 2 2 CX 3 _/\_ u0 u1 -> \ (u2 :: ({{Real u0}}, {{Fractional u0}}, (_forall_ z$z1 =>{{Integral z$z1}} -> u0 -> (z$z1, u0)), (_forall_ z$z1 =>{{Integral z$z1}} -> u0 -> z$z1), (_forall_ z$z1 =>{{Integral z$z1}} -> u0 -> z$z1), (_forall_ z$z1 =>{{Integral z$z1}} -> u0 -> z$z1), (_forall_ z$z1 =>{{Integral z$z1}} -> u0 -> z$z1))) (u3 :: {{Integral u1}}) -> case u2 of { _ALG_ _TUP_7 (u4 :: {{Real u0}}) (u5 :: {{Fractional u0}}) (u6 :: _forall_ a$z1 =>{{Integral a$z1}} -> u0 -> (a$z1, u0)) (u7 :: _forall_ a$z1 =>{{Integral a$z1}} -> u0 -> a$z1) (u8 :: _forall_ a$z1 =>{{Integral a$z1}} -> u0 -> a$z1) (u9 :: _forall_ a$z1 =>{{Integral a$z1}} -> u0 -> a$z1) (ua :: _forall_ a$z1 =>{{Integral a$z1}} -> u0 -> a$z1) -> _APP_ _TYAPP_ u7 { u1 } [ u3 ]; _NO_DEFLT_ } _N_
{-defm-} _A_ 2 _U_ 122 _N_ _S_ "SL" _N_ _N_ #-}
class Text a where
readsPrec :: Int -> [Char] -> [(a, [Char])]
{-# GHC_PRAGMA {-meth-} _A_ 1 _U_ 122 _N_ _S_ "S" _F_ _IF_ARGS_ 1 1 C 2 _/\_ u0 -> \ (u1 :: (Int -> [Char] -> [(u0, [Char])], Int -> u0 -> [Char] -> [Char], [Char] -> [([u0], [Char])], [u0] -> [Char] -> [Char])) -> case u1 of { _ALG_ _TUP_4 (u2 :: Int -> [Char] -> [(u0, [Char])]) (u3 :: Int -> u0 -> [Char] -> [Char]) (u4 :: [Char] -> [([u0], [Char])]) (u5 :: [u0] -> [Char] -> [Char]) -> u2; _NO_DEFLT_ } _N_
- {-defm-} _A_ 3 _U_ 022 _N_ _S_ _!_ _F_ _IF_ARGS_ 1 3 XXX 4 _/\_ u0 -> \ (u1 :: {{Text u0}}) (u2 :: Int) (u3 :: [Char]) -> _APP_ _TYAPP_ patError# { (Int -> [Char] -> [(u0, [Char])]) } [ _NOREP_S_ "%DPreludeCore.Text.readsPrec\"", u2, u3 ] _N_ #-}
+ {-defm-} _A_ 3 _U_ 022 _N_ _S_ _!_ _N_ _N_ #-}
showsPrec :: Int -> a -> [Char] -> [Char]
{-# GHC_PRAGMA {-meth-} _A_ 1 _U_ 1222 _N_ _S_ "S" _F_ _IF_ARGS_ 1 1 C 2 _/\_ u0 -> \ (u1 :: (Int -> [Char] -> [(u0, [Char])], Int -> u0 -> [Char] -> [Char], [Char] -> [([u0], [Char])], [u0] -> [Char] -> [Char])) -> case u1 of { _ALG_ _TUP_4 (u2 :: Int -> [Char] -> [(u0, [Char])]) (u3 :: Int -> u0 -> [Char] -> [Char]) (u4 :: [Char] -> [([u0], [Char])]) (u5 :: [u0] -> [Char] -> [Char]) -> u3; _NO_DEFLT_ } _N_
- {-defm-} _A_ 4 _U_ 0222 _N_ _S_ _!_ _F_ _IF_ARGS_ 1 4 XXXX 5 _/\_ u0 -> \ (u1 :: {{Text u0}}) (u2 :: Int) (u3 :: u0) (u4 :: [Char]) -> _APP_ _TYAPP_ patError# { (Int -> u0 -> [Char] -> [Char]) } [ _NOREP_S_ "%DPreludeCore.Text.showsPrec\"", u2, u3, u4 ] _N_ #-}
+ {-defm-} _A_ 4 _U_ 0222 _N_ _S_ _!_ _N_ _N_ #-}
readList :: [Char] -> [([a], [Char])]
{-# GHC_PRAGMA {-meth-} _A_ 1 _U_ 12 _N_ _S_ "S" _F_ _IF_ARGS_ 1 1 C 2 _/\_ u0 -> \ (u1 :: (Int -> [Char] -> [(u0, [Char])], Int -> u0 -> [Char] -> [Char], [Char] -> [([u0], [Char])], [u0] -> [Char] -> [Char])) -> case u1 of { _ALG_ _TUP_4 (u2 :: Int -> [Char] -> [(u0, [Char])]) (u3 :: Int -> u0 -> [Char] -> [Char]) (u4 :: [Char] -> [([u0], [Char])]) (u5 :: [u0] -> [Char] -> [Char]) -> u4; _NO_DEFLT_ } _N_
- {-defm-} _A_ 1 _U_ 22 _N_ _N_ _F_ _IF_ARGS_ 0 0 X 1 _ORIG_ PreludeCore _readList _N_ #-}
+ {-defm-} _A_ 1 _U_ 12 _N_ _N_ _N_ _N_ #-}
showList :: [a] -> [Char] -> [Char]
{-# GHC_PRAGMA {-meth-} _A_ 1 _U_ 122 _N_ _S_ "S" _F_ _IF_ARGS_ 1 1 C 2 _/\_ u0 -> \ (u1 :: (Int -> [Char] -> [(u0, [Char])], Int -> u0 -> [Char] -> [Char], [Char] -> [([u0], [Char])], [u0] -> [Char] -> [Char])) -> case u1 of { _ALG_ _TUP_4 (u2 :: Int -> [Char] -> [(u0, [Char])]) (u3 :: Int -> u0 -> [Char] -> [Char]) (u4 :: [Char] -> [([u0], [Char])]) (u5 :: [u0] -> [Char] -> [Char]) -> u5; _NO_DEFLT_ } _N_
- {-defm-} _A_ 1 _U_ 212 _N_ _N_ _F_ _IF_ARGS_ 0 0 X 1 _ORIG_ PreludeCore _showList _N_ #-}
+ {-defm-} _A_ 1 _U_ 112 _N_ _N_ _N_ _N_ #-}
class _CCallable a
class _CReturnable a
data Array a b {-# GHC_PRAGMA _Array (a, a) (Array# b) #-}
data Assoc a b = (:=) a b
data _ByteArray a {-# GHC_PRAGMA _ByteArray (a, a) ByteArray# #-}
data Bin
-data Complex a = (:+) a a
+data Complex a = (:+) a a {-# GHC_PRAGMA _SPECIALISE_ [ Double# ] #-}
data _MutableArray a b c {-# GHC_PRAGMA _MutableArray (b, b) (MutableArray# a c) #-}
data _MutableByteArray a b {-# GHC_PRAGMA _MutableByteArray (b, b) (MutableByteArray# a) #-}
data IOError13 = AlreadyExists [Char] | HardwareFault [Char] | IllegalOperation [Char] | InappropriateType [Char] | Interrupted [Char] | InvalidArgument [Char] | NoSuchThing [Char] | OtherError13 [Char] | PermissionDenied [Char] | ProtocolError [Char] | ResourceBusy [Char] | ResourceExhausted [Char] | ResourceVanished [Char] | SystemError [Char] | TimeExpired [Char] | UnsatisfiedConstraints [Char] | UnsupportedOperation [Char] | UserError [Char] | EOF
type ReadS a = [Char] -> [(a, [Char])]
type ShowS = [Char] -> [Char]
data _FILE {-# GHC_PRAGMA _FILE Addr# #-}
+__i0 :: Num a => a
+ {-# GHC_PRAGMA _A_ 1 _U_ 1 _N_ _S_ "U(AAAAAAAAAS)" {_A_ 1 _U_ 1 _N_ _N_ _N_ _N_} _N_ _SPECIALISE_ [ Double ] 1 { _A_ 0 _N_ _N_ _N_ _F_ _IF_ARGS_ 0 0 X 2 _!_ D# [] [0.0000000000000000##] _N_ }, [ Int ] 1 { _A_ 0 _N_ _N_ _N_ _F_ _IF_ARGS_ 0 0 X 2 _!_ I# [] [0#] _N_ }, [ Integer ] 1 { _A_ 0 _N_ _N_ _N_ _N_ _N_ }, [ (Ratio Integer) ] 1 { _A_ 0 _N_ _N_ _N_ _N_ _N_ }, [ (Complex Double) ] 1 { _A_ 0 _N_ _N_ _N_ _N_ _N_ } #-}
+__i1 :: Num a => a
+ {-# GHC_PRAGMA _A_ 1 _U_ 1 _N_ _S_ "U(AAAAAAAAAS)" {_A_ 1 _U_ 1 _N_ _N_ _N_ _N_} _N_ _SPECIALISE_ [ Double ] 1 { _A_ 0 _N_ _N_ _N_ _F_ _IF_ARGS_ 0 0 X 2 _!_ D# [] [1.0000000000000000##] _N_ }, [ Int ] 1 { _A_ 0 _N_ _N_ _N_ _F_ _IF_ARGS_ 0 0 X 2 _!_ I# [] [1#] _N_ }, [ Integer ] 1 { _A_ 0 _N_ _N_ _N_ _N_ _N_ }, [ (Ratio Integer) ] 1 { _A_ 0 _N_ _N_ _N_ _N_ _N_ }, [ (Complex Double) ] 1 { _A_ 0 _N_ _N_ _N_ _N_ _N_ } #-}
+__i10 :: Num a => a
+ {-# GHC_PRAGMA _A_ 1 _U_ 1 _N_ _S_ "U(AAAAAAAAAS)" {_A_ 1 _U_ 1 _N_ _N_ _N_ _N_} _N_ _SPECIALISE_ [ Double ] 1 { _A_ 0 _N_ _N_ _N_ _F_ _IF_ARGS_ 0 0 X 2 _!_ D# [] [10.000000000000000##] _N_ }, [ Int ] 1 { _A_ 0 _N_ _N_ _N_ _F_ _IF_ARGS_ 0 0 X 2 _!_ I# [] [10#] _N_ }, [ Integer ] 1 { _A_ 0 _N_ _N_ _N_ _N_ _N_ }, [ (Ratio Integer) ] 1 { _A_ 0 _N_ _N_ _N_ _N_ _N_ }, [ (Complex Double) ] 1 { _A_ 0 _N_ _N_ _N_ _N_ _N_ } #-}
+__i16 :: Num a => a
+ {-# GHC_PRAGMA _A_ 1 _U_ 1 _N_ _S_ "U(AAAAAAAAAS)" {_A_ 1 _U_ 1 _N_ _N_ _N_ _N_} _N_ _SPECIALISE_ [ Double ] 1 { _A_ 0 _N_ _N_ _N_ _F_ _IF_ARGS_ 0 0 X 2 _!_ D# [] [16.000000000000000##] _N_ }, [ Int ] 1 { _A_ 0 _N_ _N_ _N_ _F_ _IF_ARGS_ 0 0 X 2 _!_ I# [] [16#] _N_ }, [ Integer ] 1 { _A_ 0 _N_ _N_ _N_ _N_ _N_ }, [ (Ratio Integer) ] 1 { _A_ 0 _N_ _N_ _N_ _N_ _N_ }, [ (Complex Double) ] 1 { _A_ 0 _N_ _N_ _N_ _N_ _N_ } #-}
+__i2 :: Num a => a
+ {-# GHC_PRAGMA _A_ 1 _U_ 1 _N_ _S_ "U(AAAAAAAAAS)" {_A_ 1 _U_ 1 _N_ _N_ _N_ _N_} _N_ _SPECIALISE_ [ Double ] 1 { _A_ 0 _N_ _N_ _N_ _F_ _IF_ARGS_ 0 0 X 2 _!_ D# [] [2.0000000000000000##] _N_ }, [ Int ] 1 { _A_ 0 _N_ _N_ _N_ _F_ _IF_ARGS_ 0 0 X 2 _!_ I# [] [2#] _N_ }, [ Integer ] 1 { _A_ 0 _N_ _N_ _N_ _N_ _N_ }, [ (Ratio Integer) ] 1 { _A_ 0 _N_ _N_ _N_ _N_ _N_ }, [ (Complex Double) ] 1 { _A_ 0 _N_ _N_ _N_ _N_ _N_ } #-}
+__i8 :: Num a => a
+ {-# GHC_PRAGMA _A_ 1 _U_ 1 _N_ _S_ "U(AAAAAAAAAS)" {_A_ 1 _U_ 1 _N_ _N_ _N_ _N_} _N_ _SPECIALISE_ [ Double ] 1 { _A_ 0 _N_ _N_ _N_ _F_ _IF_ARGS_ 0 0 X 2 _!_ D# [] [8.0000000000000000##] _N_ }, [ Int ] 1 { _A_ 0 _N_ _N_ _N_ _F_ _IF_ARGS_ 0 0 X 2 _!_ I# [] [8#] _N_ }, [ Integer ] 1 { _A_ 0 _N_ _N_ _N_ _N_ _N_ }, [ (Ratio Integer) ] 1 { _A_ 0 _N_ _N_ _N_ _N_ _N_ }, [ (Complex Double) ] 1 { _A_ 0 _N_ _N_ _N_ _N_ _N_ } #-}
+__im1 :: Num a => a
+ {-# GHC_PRAGMA _A_ 1 _U_ 1 _N_ _S_ "U(AAAAAAAAAS)" {_A_ 1 _U_ 1 _N_ _N_ _N_ _N_} _N_ _SPECIALISE_ [ Double ] 1 { _A_ 0 _N_ _N_ _N_ _F_ _IF_ARGS_ 0 0 X 2 _!_ D# [] [-1.0000000000000000##] _N_ }, [ Int ] 1 { _A_ 0 _N_ _N_ _N_ _F_ _IF_ARGS_ 0 0 X 2 _!_ I# [] [-1#] _N_ }, [ Integer ] 1 { _A_ 0 _N_ _N_ _N_ _N_ _N_ }, [ (Ratio Integer) ] 1 { _A_ 0 _N_ _N_ _N_ _N_ _N_ }, [ (Complex Double) ] 1 { _A_ 0 _N_ _N_ _N_ _N_ _N_ } #-}
+__integer0 :: Integer
+ {-# GHC_PRAGMA _A_ 0 _N_ _N_ _N_ _N_ _N_ #-}
+__integer1 :: Integer
+ {-# GHC_PRAGMA _A_ 0 _N_ _N_ _N_ _N_ _N_ #-}
+__integer2 :: Integer
+ {-# GHC_PRAGMA _A_ 0 _N_ _N_ _N_ _N_ _N_ #-}
+__integerm1 :: Integer
+ {-# GHC_PRAGMA _A_ 0 _N_ _N_ _N_ _N_ _N_ #-}
+__rhalf :: Fractional a => a
+ {-# GHC_PRAGMA _A_ 1 _U_ 1 _N_ _S_ "U(AAAS)" {_A_ 1 _U_ 1 _N_ _N_ _N_ _N_} _N_ _SPECIALISE_ [ Double ] 1 { _A_ 0 _N_ _N_ _N_ _N_ _N_ }, [ (Ratio Integer) ] 1 { _A_ 0 _N_ _N_ _N_ _F_ _IF_ARGS_ 0 0 X 3 _!_ (:%) [Integer] [_SPEC_ _ORIG_ PreludeCore __i1 [ (Integer) ], _SPEC_ _ORIG_ PreludeCore __i2 [ (Integer) ]] _N_ }, [ (Complex Double) ] 1 { _A_ 0 _N_ _N_ _N_ _N_ _N_ } #-}
+_fromRational :: RealFloat a => Ratio Integer -> a
+ {-# GHC_PRAGMA _A_ 2 _U_ 22 _N_ _N_ _N_ _SPECIALISE_ [ Double ] 1 { _A_ 1 _U_ 1 _N_ _S_ "U(U(PPP)U(PPP))" {_A_ 4 _U_ 2221 _N_ _N_ _N_ _N_} _N_ _N_ } #-}
instance Enum ()
{-# GHC_PRAGMA _M_ PreludeBuiltin {-dfun-} _A_ 0 _N_ _N_ _N_ _F_ _IF_ARGS_ 0 0 X 6 _!_ _TUP_5 [{{Ord ()}}, (() -> [()]), (() -> () -> [()]), (() -> () -> [()]), (() -> () -> () -> [()])] [_DFUN_ Ord (()), _CONSTM_ Enum enumFrom (()), _CONSTM_ Enum enumFromThen (()), _CONSTM_ Enum enumFromTo (()), _CONSTM_ Enum enumFromThenTo (())] _N_
- enumFrom = _A_ 1 _U_ 2 _N_ _S_ "E" _N_ _N_,
- enumFromThen = _A_ 2 _U_ 21 _N_ _S_ "EE" _F_ _IF_ARGS_ 0 2 CC 7 \ (u0 :: ()) (u1 :: ()) -> case u0 of { _ALG_ _TUP_0 -> case u1 of { _ALG_ _TUP_0 -> let {(u2 :: [()]) = _!_ _NIL_ [()] []} in _!_ (:) [()] [u0, u2]; _NO_DEFLT_ }; _NO_DEFLT_ } _N_,
- enumFromTo = _A_ 2 _U_ 21 _N_ _S_ "EE" _F_ _IF_ARGS_ 0 2 CC 7 \ (u0 :: ()) (u1 :: ()) -> case u0 of { _ALG_ _TUP_0 -> case u1 of { _ALG_ _TUP_0 -> let {(u2 :: [()]) = _!_ _NIL_ [()] []} in _!_ (:) [()] [u0, u2]; _NO_DEFLT_ }; _NO_DEFLT_ } _N_,
- enumFromThenTo = _A_ 3 _U_ 211 _N_ _S_ "EEE" _F_ _IF_ARGS_ 0 3 CCC 8 \ (u0 :: ()) (u1 :: ()) (u2 :: ()) -> case u0 of { _ALG_ _TUP_0 -> case u1 of { _ALG_ _TUP_0 -> case u2 of { _ALG_ _TUP_0 -> let {(u3 :: [()]) = _!_ _NIL_ [()] []} in _!_ (:) [()] [u0, u3]; _NO_DEFLT_ }; _NO_DEFLT_ }; _NO_DEFLT_ } _N_ #-}
+ enumFrom = { _A_ 1 _U_ 2 _N_ _S_ "E" _N_ _N_ },
+ enumFromThen = { _A_ 2 _U_ 21 _N_ _S_ "EE" _F_ _IF_ARGS_ 0 2 CC 7 \ (u0 :: ()) (u1 :: ()) -> case u0 of { _ALG_ _TUP_0 -> case u1 of { _ALG_ _TUP_0 -> let {(u2 :: [()]) = _!_ _NIL_ [()] []} in _!_ (:) [()] [u0, u2]; _NO_DEFLT_ }; _NO_DEFLT_ } _N_ },
+ enumFromTo = { _A_ 2 _U_ 21 _N_ _S_ "EE" _F_ _IF_ARGS_ 0 2 CC 7 \ (u0 :: ()) (u1 :: ()) -> case u0 of { _ALG_ _TUP_0 -> case u1 of { _ALG_ _TUP_0 -> let {(u2 :: [()]) = _!_ _NIL_ [()] []} in _!_ (:) [()] [u0, u2]; _NO_DEFLT_ }; _NO_DEFLT_ } _N_ },
+ enumFromThenTo = { _A_ 3 _U_ 211 _N_ _S_ "EEE" _F_ _IF_ARGS_ 0 3 CCC 8 \ (u0 :: ()) (u1 :: ()) (u2 :: ()) -> case u0 of { _ALG_ _TUP_0 -> case u1 of { _ALG_ _TUP_0 -> case u2 of { _ALG_ _TUP_0 -> let {(u3 :: [()]) = _!_ _NIL_ [()] []} in _!_ (:) [()] [u0, u3]; _NO_DEFLT_ }; _NO_DEFLT_ }; _NO_DEFLT_ } _N_ } #-}
instance Enum Bool
{-# GHC_PRAGMA _M_ PreludeCore {-dfun-} _A_ 0 _N_ _N_ _N_ _F_ _IF_ARGS_ 0 0 X 6 _!_ _TUP_5 [{{Ord Bool}}, (Bool -> [Bool]), (Bool -> Bool -> [Bool]), (Bool -> Bool -> [Bool]), (Bool -> Bool -> Bool -> [Bool])] [_DFUN_ Ord (Bool), _CONSTM_ Enum enumFrom (Bool), _CONSTM_ Enum enumFromThen (Bool), _CONSTM_ Enum enumFromTo (Bool), _CONSTM_ Enum enumFromThenTo (Bool)] _N_
- enumFrom = _A_ 1 _U_ 2 _N_ _S_ "E" _N_ _N_,
- enumFromThen = _A_ 2 _U_ 22 _N_ _S_ "EE" _N_ _N_,
- enumFromTo = _A_ 2 _U_ 22 _N_ _N_ _N_ _N_,
- enumFromThenTo = _A_ 3 _U_ 222 _N_ _N_ _N_ _N_ #-}
+ enumFrom = { _A_ 1 _U_ 2 _N_ _S_ "E" _N_ _N_ },
+ enumFromThen = { _A_ 2 _U_ 22 _N_ _S_ "EE" _N_ _N_ },
+ enumFromTo = { _A_ 2 _U_ 22 _N_ _S_ "EL" _N_ _N_ },
+ enumFromThenTo = { _A_ 3 _U_ 222 _N_ _S_ "EEL" _N_ _N_ } #-}
instance Enum Char
{-# GHC_PRAGMA _M_ PreludeCore {-dfun-} _A_ 0 _N_ _N_ _N_ _F_ _IF_ARGS_ 0 0 X 6 _!_ _TUP_5 [{{Ord Char}}, (Char -> [Char]), (Char -> Char -> [Char]), (Char -> Char -> [Char]), (Char -> Char -> Char -> [Char])] [_DFUN_ Ord (Char), _CONSTM_ Enum enumFrom (Char), _CONSTM_ Enum enumFromThen (Char), _CONSTM_ Enum enumFromTo (Char), _CONSTM_ Enum enumFromThenTo (Char)] _N_
- enumFrom = _A_ 1 _U_ 1 _N_ _S_ "U(P)" {_A_ 1 _U_ 2 _N_ _N_ _N_ _N_} _N_ _N_,
- enumFromThen = _A_ 2 _U_ 22 _N_ _N_ _N_ _N_,
- enumFromTo = _A_ 2 _U_ 22 _N_ _N_ _N_ _N_,
- enumFromThenTo = _A_ 3 _U_ 222 _N_ _N_ _N_ _N_ #-}
+ enumFrom = { _A_ 1 _U_ 1 _N_ _S_ "U(P)" {_A_ 1 _U_ 2 _N_ _N_ _N_ _N_} _N_ _N_ },
+ enumFromThen = { _A_ 2 _U_ 22 _N_ _N_ _N_ _N_ },
+ enumFromTo = { _A_ 2 _U_ 12 _N_ _S_ "U(P)L" {_A_ 2 _U_ 22 _N_ _N_ _N_ _N_} _N_ _N_ },
+ enumFromThenTo = { _A_ 3 _U_ 222 _N_ _N_ _N_ _N_ } #-}
instance Enum Double
{-# GHC_PRAGMA _M_ PreludeCore {-dfun-} _A_ 0 _N_ _N_ _N_ _F_ _IF_ARGS_ 0 0 X 6 _!_ _TUP_5 [{{Ord Double}}, (Double -> [Double]), (Double -> Double -> [Double]), (Double -> Double -> [Double]), (Double -> Double -> Double -> [Double])] [_DFUN_ Ord (Double), _CONSTM_ Enum enumFrom (Double), _CONSTM_ Enum enumFromThen (Double), _CONSTM_ Enum enumFromTo (Double), _CONSTM_ Enum enumFromThenTo (Double)] _N_
- enumFrom = _A_ 1 _U_ 2 _N_ _N_ _N_ _N_,
- enumFromThen = _A_ 2 _U_ 21 _N_ _N_ _N_ _N_,
- enumFromTo = _A_ 2 _U_ 22 _N_ _N_ _N_ _N_,
- enumFromThenTo = _A_ 3 _U_ 222 _N_ _N_ _N_ _N_ #-}
+ enumFrom = { _A_ 1 _U_ 2 _N_ _N_ _N_ _N_ },
+ enumFromThen = { _A_ 2 _U_ 21 _N_ _N_ _N_ _N_ },
+ enumFromTo = { _A_ 2 _U_ 22 _N_ _N_ _N_ _N_ },
+ enumFromThenTo = { _A_ 3 _U_ 222 _N_ _N_ _N_ _N_ } #-}
instance Enum Float
{-# GHC_PRAGMA _M_ PreludeCore {-dfun-} _A_ 0 _N_ _N_ _N_ _F_ _IF_ARGS_ 0 0 X 6 _!_ _TUP_5 [{{Ord Float}}, (Float -> [Float]), (Float -> Float -> [Float]), (Float -> Float -> [Float]), (Float -> Float -> Float -> [Float])] [_DFUN_ Ord (Float), _CONSTM_ Enum enumFrom (Float), _CONSTM_ Enum enumFromThen (Float), _CONSTM_ Enum enumFromTo (Float), _CONSTM_ Enum enumFromThenTo (Float)] _N_
- enumFrom = _A_ 1 _U_ 2 _N_ _N_ _N_ _N_,
- enumFromThen = _A_ 2 _U_ 21 _N_ _N_ _N_ _N_,
- enumFromTo = _A_ 2 _U_ 22 _N_ _N_ _N_ _N_,
- enumFromThenTo = _A_ 3 _U_ 222 _N_ _N_ _N_ _N_ #-}
+ enumFrom = { _A_ 1 _U_ 2 _N_ _N_ _N_ _N_ },
+ enumFromThen = { _A_ 2 _U_ 21 _N_ _N_ _N_ _N_ },
+ enumFromTo = { _A_ 2 _U_ 22 _N_ _N_ _N_ _N_ },
+ enumFromThenTo = { _A_ 3 _U_ 222 _N_ _N_ _N_ _N_ } #-}
instance Enum Int
{-# GHC_PRAGMA _M_ PreludeCore {-dfun-} _A_ 0 _N_ _N_ _N_ _F_ _IF_ARGS_ 0 0 X 6 _!_ _TUP_5 [{{Ord Int}}, (Int -> [Int]), (Int -> Int -> [Int]), (Int -> Int -> [Int]), (Int -> Int -> Int -> [Int])] [_DFUN_ Ord (Int), _CONSTM_ Enum enumFrom (Int), _CONSTM_ Enum enumFromThen (Int), _CONSTM_ Enum enumFromTo (Int), _CONSTM_ Enum enumFromThenTo (Int)] _N_
- enumFrom = _A_ 1 _U_ 2 _N_ _N_ _F_ _ALWAYS_ \ (u0 :: Int) -> _LETREC_ {(u1 :: Int -> [Int]) = \ (u2 :: Int) -> let {(u6 :: [Int]) = let {(u5 :: Int) = case u2 of { _ALG_ I# (u3 :: Int#) -> case _#_ plusInt# [] [u3, 1#] of { _PRIM_ (u4 :: Int#) -> _!_ I# [] [u4] }; _NO_DEFLT_ }} in _APP_ u1 [ u5 ]} in _!_ (:) [Int] [u2, u6]} in _APP_ u1 [ u0 ] _N_,
- enumFromThen = _A_ 2 _U_ 21 _N_ _N_ _N_ _N_,
- enumFromTo = _A_ 2 _U_ 12 _N_ _S_ "SS" _F_ _ALWAYS_ \ (u0 :: Int) (u1 :: Int) -> case u0 of { _ALG_ I# (u2 :: Int#) -> _LETREC_ {(u3 :: Int# -> [Int]) = \ (u4 :: Int#) -> case u1 of { _ALG_ I# (u5 :: Int#) -> case _#_ leInt# [] [u4, u5] of { _ALG_ True -> let {(u7 :: [Int]) = case _#_ plusInt# [] [u4, 1#] of { _PRIM_ (u6 :: Int#) -> _APP_ u3 [ u6 ] }} in let {(u8 :: Int) = _!_ I# [] [u4]} in _!_ (:) [Int] [u8, u7]; False -> _!_ _NIL_ [Int] []; _NO_DEFLT_ }; _NO_DEFLT_ }} in _APP_ u3 [ u2 ]; _NO_DEFLT_ } _N_,
- enumFromThenTo = _A_ 3 _U_ 222 _N_ _N_ _N_ _N_ #-}
+ enumFrom = { _A_ 1 _U_ 2 _N_ _N_ _F_ _ALWAYS_ \ (u0 :: Int) -> _LETREC_ {(u1 :: Int -> [Int]) = \ (u2 :: Int) -> let {(u6 :: [Int]) = let {(u5 :: Int) = case u2 of { _ALG_ I# (u3 :: Int#) -> case _#_ plusInt# [] [u3, 1#] of { _PRIM_ (u4 :: Int#) -> _!_ I# [] [u4] }; _NO_DEFLT_ }} in _APP_ u1 [ u5 ]} in _!_ (:) [Int] [u2, u6]} in _APP_ u1 [ u0 ] _N_ },
+ enumFromThen = { _A_ 2 _U_ 21 _N_ _N_ _N_ _N_ },
+ enumFromTo = { _A_ 2 _U_ 12 _N_ _S_ "SS" _F_ _ALWAYS_ \ (u0 :: Int) (u1 :: Int) -> case u0 of { _ALG_ I# (u2 :: Int#) -> _LETREC_ {(u3 :: Int# -> [Int]) = \ (u4 :: Int#) -> case u1 of { _ALG_ I# (u5 :: Int#) -> case _#_ leInt# [] [u4, u5] of { _ALG_ True -> let {(u7 :: [Int]) = case _#_ plusInt# [] [u4, 1#] of { _PRIM_ (u6 :: Int#) -> _APP_ u3 [ u6 ] }} in let {(u8 :: Int) = _!_ I# [] [u4]} in _!_ (:) [Int] [u8, u7]; False -> _!_ _NIL_ [Int] []; _NO_DEFLT_ }; _NO_DEFLT_ }} in _APP_ u3 [ u2 ]; _NO_DEFLT_ } _N_ },
+ enumFromThenTo = { _A_ 3 _U_ 222 _N_ _N_ _N_ _N_ } #-}
instance Enum Integer
{-# GHC_PRAGMA _M_ PreludeCore {-dfun-} _A_ 0 _N_ _N_ _N_ _F_ _IF_ARGS_ 0 0 X 6 _!_ _TUP_5 [{{Ord Integer}}, (Integer -> [Integer]), (Integer -> Integer -> [Integer]), (Integer -> Integer -> [Integer]), (Integer -> Integer -> Integer -> [Integer])] [_DFUN_ Ord (Integer), _CONSTM_ Enum enumFrom (Integer), _CONSTM_ Enum enumFromThen (Integer), _CONSTM_ Enum enumFromTo (Integer), _CONSTM_ Enum enumFromThenTo (Integer)] _N_
- enumFrom = _A_ 1 _U_ 2 _N_ _N_ _N_ _N_,
- enumFromThen = _A_ 2 _U_ 21 _N_ _N_ _N_ _N_,
- enumFromTo = _A_ 2 _U_ 22 _N_ _N_ _N_ _N_,
- enumFromThenTo = _A_ 3 _U_ 222 _N_ _N_ _N_ _N_ #-}
+ enumFrom = { _A_ 1 _U_ 2 _N_ _N_ _N_ _N_ },
+ enumFromThen = { _A_ 2 _U_ 21 _N_ _N_ _N_ _N_ },
+ enumFromTo = { _A_ 2 _U_ 22 _N_ _N_ _N_ _N_ },
+ enumFromThenTo = { _A_ 3 _U_ 222 _N_ _N_ _N_ _N_ } #-}
instance Integral a => Enum (Ratio a)
{-# GHC_PRAGMA _M_ PreludeRatio {-dfun-} _A_ 2 _U_ 22 _N_ _N_ _N_ _N_ #-}
instance Enum (Ratio Integer)
{-# GHC_PRAGMA _M_ PreludeRatio {-dfun-} _A_ 0 _N_ _N_ _N_ _F_ _IF_ARGS_ 0 0 X 6 _!_ _TUP_5 [{{Ord (Ratio Integer)}}, (Ratio Integer -> [Ratio Integer]), (Ratio Integer -> Ratio Integer -> [Ratio Integer]), (Ratio Integer -> Ratio Integer -> [Ratio Integer]), (Ratio Integer -> Ratio Integer -> Ratio Integer -> [Ratio Integer])] [_DFUN_ Ord (Ratio Integer), _CONSTM_ Enum enumFrom (Ratio Integer), _CONSTM_ Enum enumFromThen (Ratio Integer), _CONSTM_ Enum enumFromTo (Ratio Integer), _CONSTM_ Enum enumFromThenTo (Ratio Integer)] _N_
- enumFrom = _A_ 1 _U_ 2 _N_ _N_ _N_ _N_,
- enumFromThen = _A_ 2 _U_ 21 _N_ _N_ _N_ _N_,
- enumFromTo = _A_ 2 _U_ 22 _N_ _N_ _N_ _N_,
- enumFromThenTo = _A_ 3 _U_ 222 _N_ _N_ _N_ _N_ #-}
+ enumFrom = { _A_ 1 _U_ 2 _N_ _N_ _N_ _N_ },
+ enumFromThen = { _A_ 2 _U_ 21 _N_ _N_ _N_ _N_ },
+ enumFromTo = { _A_ 2 _U_ 22 _N_ _N_ _N_ _N_ },
+ enumFromThenTo = { _A_ 3 _U_ 222 _N_ _N_ _N_ _N_ } #-}
instance Eq ()
{-# GHC_PRAGMA _M_ PreludeBuiltin {-dfun-} _A_ 0 _N_ _N_ _N_ _F_ _IF_ARGS_ 0 0 X 3 _!_ _TUP_2 [(() -> () -> Bool), (() -> () -> Bool)] [_CONSTM_ Eq (==) (()), _CONSTM_ Eq (/=) (())] _N_
- (==) = _A_ 2 _U_ 11 _N_ _S_ "EE" _F_ _IF_ARGS_ 0 2 CC 3 \ (u0 :: ()) (u1 :: ()) -> case u0 of { _ALG_ _TUP_0 -> case u1 of { _ALG_ _TUP_0 -> _!_ True [] []; _NO_DEFLT_ }; _NO_DEFLT_ } _N_,
- (/=) = _A_ 2 _U_ 11 _N_ _S_ "EE" _F_ _IF_ARGS_ 0 2 CC 3 \ (u0 :: ()) (u1 :: ()) -> case u0 of { _ALG_ _TUP_0 -> case u1 of { _ALG_ _TUP_0 -> _!_ False [] []; _NO_DEFLT_ }; _NO_DEFLT_ } _N_ #-}
+ (==) = { _A_ 2 _U_ 11 _N_ _S_ "EE" _F_ _IF_ARGS_ 0 2 CC 3 \ (u0 :: ()) (u1 :: ()) -> case u0 of { _ALG_ _TUP_0 -> case u1 of { _ALG_ _TUP_0 -> _!_ True [] []; _NO_DEFLT_ }; _NO_DEFLT_ } _N_ },
+ (/=) = { _A_ 2 _U_ 11 _N_ _S_ "EE" _F_ _IF_ARGS_ 0 2 CC 3 \ (u0 :: ()) (u1 :: ()) -> case u0 of { _ALG_ _TUP_0 -> case u1 of { _ALG_ _TUP_0 -> _!_ False [] []; _NO_DEFLT_ }; _NO_DEFLT_ } _N_ } #-}
instance (Eq a, Eq b) => Eq (a, b)
- {-# GHC_PRAGMA _M_ PreludeBuiltin {-dfun-} _A_ 2 _U_ 11 _N_ _N_ _N_ _N_ #-}
+ {-# GHC_PRAGMA _M_ PreludeBuiltin {-dfun-} _A_ 2 _U_ 22 _N_ _N_ _N_ _N_ #-}
instance (Eq a, Eq b, Eq c) => Eq (a, b, c)
{-# GHC_PRAGMA _M_ PreludeBuiltin {-dfun-} _A_ 3 _U_ 111 _N_ _N_ _N_ _N_ #-}
instance (Eq a, Eq b, Eq c, Eq d) => Eq (a, b, c, d)
{-# GHC_PRAGMA _M_ PreludeBuiltin {-dfun-} _A_ 5 _U_ 11111 _N_ _N_ _N_ _N_ #-}
instance Eq (Int, Int)
{-# GHC_PRAGMA _M_ PreludeBuiltin {-dfun-} _A_ 0 _N_ _N_ _N_ _F_ _IF_ARGS_ 0 0 X 3 _!_ _TUP_2 [((Int, Int) -> (Int, Int) -> Bool), ((Int, Int) -> (Int, Int) -> Bool)] [_CONSTM_ Eq (==) ((Int, Int)), _CONSTM_ Eq (/=) ((Int, Int))] _N_
- (==) = _A_ 2 _U_ 11 _N_ _S_ "U(U(P)L)U(U(P)L)" {_A_ 4 _U_ 2121 _N_ _N_ _F_ _IF_ARGS_ 0 4 XCXC 7 \ (u0 :: Int#) (u1 :: Int) (u2 :: Int#) (u3 :: Int) -> case _#_ eqInt# [] [u0, u2] of { _ALG_ True -> case u1 of { _ALG_ I# (u4 :: Int#) -> case u3 of { _ALG_ I# (u5 :: Int#) -> _#_ eqInt# [] [u4, u5]; _NO_DEFLT_ }; _NO_DEFLT_ }; False -> _!_ False [] []; _NO_DEFLT_ } _N_} _F_ _ALWAYS_ \ (u0 :: (Int, Int)) (u1 :: (Int, Int)) -> case u0 of { _ALG_ _TUP_2 (u2 :: Int) (u3 :: Int) -> case u2 of { _ALG_ I# (u4 :: Int#) -> case u1 of { _ALG_ _TUP_2 (u5 :: Int) (u6 :: Int) -> case u5 of { _ALG_ I# (u7 :: Int#) -> case _#_ eqInt# [] [u4, u7] of { _ALG_ True -> case u3 of { _ALG_ I# (u8 :: Int#) -> case u6 of { _ALG_ I# (u9 :: Int#) -> _#_ eqInt# [] [u8, u9]; _NO_DEFLT_ }; _NO_DEFLT_ }; False -> _!_ False [] []; _NO_DEFLT_ }; _NO_DEFLT_ }; _NO_DEFLT_ }; _NO_DEFLT_ }; _NO_DEFLT_ } _N_,
- (/=) = _A_ 2 _U_ 22 _N_ _N_ _N_ _N_ #-}
+ (==) = { _A_ 2 _U_ 11 _N_ _S_ "U(U(P)L)U(U(P)L)" {_A_ 4 _U_ 2121 _N_ _N_ _F_ _IF_ARGS_ 0 4 XCXC 7 \ (u0 :: Int#) (u1 :: Int) (u2 :: Int#) (u3 :: Int) -> case _#_ eqInt# [] [u0, u2] of { _ALG_ True -> case u1 of { _ALG_ I# (u4 :: Int#) -> case u3 of { _ALG_ I# (u5 :: Int#) -> _#_ eqInt# [] [u4, u5]; _NO_DEFLT_ }; _NO_DEFLT_ }; False -> _!_ False [] []; _NO_DEFLT_ } _N_} _F_ _ALWAYS_ \ (u0 :: (Int, Int)) (u1 :: (Int, Int)) -> case u0 of { _ALG_ _TUP_2 (u2 :: Int) (u3 :: Int) -> case u2 of { _ALG_ I# (u4 :: Int#) -> case u1 of { _ALG_ _TUP_2 (u5 :: Int) (u6 :: Int) -> case u5 of { _ALG_ I# (u7 :: Int#) -> case _#_ eqInt# [] [u4, u7] of { _ALG_ True -> case u3 of { _ALG_ I# (u8 :: Int#) -> case u6 of { _ALG_ I# (u9 :: Int#) -> _#_ eqInt# [] [u8, u9]; _NO_DEFLT_ }; _NO_DEFLT_ }; False -> _!_ False [] []; _NO_DEFLT_ }; _NO_DEFLT_ }; _NO_DEFLT_ }; _NO_DEFLT_ }; _NO_DEFLT_ } _N_ },
+ (/=) = { _A_ 2 _U_ 11 _N_ _S_ "U(U(P)L)U(U(P)L)" {_A_ 4 _U_ 2121 _N_ _N_ _F_ _IF_ARGS_ 0 4 XCXC 7 \ (u0 :: Int#) (u1 :: Int) (u2 :: Int#) (u3 :: Int) -> case _#_ neInt# [] [u0, u2] of { _ALG_ True -> _!_ True [] []; False -> case u1 of { _ALG_ I# (u4 :: Int#) -> case u3 of { _ALG_ I# (u5 :: Int#) -> _#_ neInt# [] [u4, u5]; _NO_DEFLT_ }; _NO_DEFLT_ }; _NO_DEFLT_ } _N_} _F_ _ALWAYS_ \ (u0 :: (Int, Int)) (u1 :: (Int, Int)) -> case u0 of { _ALG_ _TUP_2 (u2 :: Int) (u3 :: Int) -> case u2 of { _ALG_ I# (u4 :: Int#) -> case u1 of { _ALG_ _TUP_2 (u5 :: Int) (u6 :: Int) -> case u5 of { _ALG_ I# (u7 :: Int#) -> case _#_ neInt# [] [u4, u7] of { _ALG_ True -> _!_ True [] []; False -> case u3 of { _ALG_ I# (u8 :: Int#) -> case u6 of { _ALG_ I# (u9 :: Int#) -> _#_ neInt# [] [u8, u9]; _NO_DEFLT_ }; _NO_DEFLT_ }; _NO_DEFLT_ }; _NO_DEFLT_ }; _NO_DEFLT_ }; _NO_DEFLT_ }; _NO_DEFLT_ } _N_ } #-}
+instance Eq (Int, Int, Int)
+ {-# GHC_PRAGMA _M_ PreludeBuiltin {-dfun-} _A_ 0 _N_ _N_ _N_ _F_ _IF_ARGS_ 0 0 X 3 _!_ _TUP_2 [((Int, Int, Int) -> (Int, Int, Int) -> Bool), ((Int, Int, Int) -> (Int, Int, Int) -> Bool)] [_CONSTM_ Eq (==) ((Int, Int, Int)), _CONSTM_ Eq (/=) ((Int, Int, Int))] _N_
+ (==) = { _A_ 2 _U_ 11 _N_ _S_ "U(U(P)LL)U(U(P)LL)" {_A_ 4 _U_ 2111 _N_ _N_ _N_ _N_} _N_ _N_ },
+ (/=) = { _A_ 2 _U_ 11 _N_ _S_ "U(U(P)LL)U(U(P)LL)" {_A_ 4 _U_ 2111 _N_ _N_ _N_ _N_} _N_ _N_ } #-}
+instance Eq (Int, Int, Int, Int)
+ {-# GHC_PRAGMA _M_ PreludeBuiltin {-dfun-} _A_ 0 _N_ _N_ _N_ _F_ _IF_ARGS_ 0 0 X 3 _!_ _TUP_2 [((Int, Int, Int, Int) -> (Int, Int, Int, Int) -> Bool), ((Int, Int, Int, Int) -> (Int, Int, Int, Int) -> Bool)] [_CONSTM_ Eq (==) ((Int, Int, Int, Int)), _CONSTM_ Eq (/=) ((Int, Int, Int, Int))] _N_
+ (==) = { _A_ 2 _U_ 11 _N_ _S_ "U(U(P)LLL)U(U(P)LLL)" {_A_ 5 _U_ 21111 _N_ _N_ _N_ _N_} _N_ _N_ },
+ (/=) = { _A_ 2 _U_ 11 _N_ _S_ "U(U(P)LLL)U(U(P)LLL)" {_A_ 5 _U_ 21111 _N_ _N_ _N_ _N_} _N_ _N_ } #-}
+instance Eq (Int, Int, Int, Int, Int)
+ {-# GHC_PRAGMA _M_ PreludeBuiltin {-dfun-} _A_ 0 _N_ _N_ _N_ _F_ _IF_ARGS_ 0 0 X 3 _!_ _TUP_2 [((Int, Int, Int, Int, Int) -> (Int, Int, Int, Int, Int) -> Bool), ((Int, Int, Int, Int, Int) -> (Int, Int, Int, Int, Int) -> Bool)] [_CONSTM_ Eq (==) ((Int, Int, Int, Int, Int)), _CONSTM_ Eq (/=) ((Int, Int, Int, Int, Int))] _N_
+ (==) = { _A_ 2 _U_ 11 _N_ _S_ "U(U(P)LLLL)U(U(P)LLLL)" _N_ _N_ },
+ (/=) = { _A_ 2 _U_ 11 _N_ _S_ "U(U(P)LLLL)U(U(P)LLLL)" _N_ _N_ } #-}
+instance Eq ([Char], [Char])
+ {-# GHC_PRAGMA _M_ PreludeBuiltin {-dfun-} _A_ 0 _N_ _N_ _N_ _F_ _IF_ARGS_ 0 0 X 3 _!_ _TUP_2 [(([Char], [Char]) -> ([Char], [Char]) -> Bool), (([Char], [Char]) -> ([Char], [Char]) -> Bool)] [_CONSTM_ Eq (==) (([Char], [Char])), _CONSTM_ Eq (/=) (([Char], [Char]))] _N_
+ (==) = { _A_ 2 _U_ 11 _N_ _S_ "U(SL)U(SL)" {_A_ 4 _U_ 2222 _N_ _N_ _N_ _N_} _N_ _N_ },
+ (/=) = { _A_ 2 _U_ 11 _N_ _S_ "U(SL)U(SL)" {_A_ 4 _U_ 2222 _N_ _N_ _N_ _N_} _N_ _N_ } #-}
+instance Eq ([Int], [Int])
+ {-# GHC_PRAGMA _M_ PreludeBuiltin {-dfun-} _A_ 0 _N_ _N_ _N_ _F_ _IF_ARGS_ 0 0 X 3 _!_ _TUP_2 [(([Int], [Int]) -> ([Int], [Int]) -> Bool), (([Int], [Int]) -> ([Int], [Int]) -> Bool)] [_CONSTM_ Eq (==) (([Int], [Int])), _CONSTM_ Eq (/=) (([Int], [Int]))] _N_
+ (==) = { _A_ 2 _U_ 11 _N_ _S_ "U(SL)U(SL)" {_A_ 4 _U_ 2222 _N_ _N_ _N_ _N_} _N_ _N_ },
+ (/=) = { _A_ 2 _U_ 11 _N_ _S_ "U(SL)U(SL)" {_A_ 4 _U_ 2222 _N_ _N_ _N_ _N_} _N_ _N_ } #-}
instance Eq (_PackedString, _PackedString)
{-# GHC_PRAGMA _M_ PreludeBuiltin {-dfun-} _A_ 0 _N_ _N_ _N_ _F_ _IF_ARGS_ 0 0 X 3 _!_ _TUP_2 [((_PackedString, _PackedString) -> (_PackedString, _PackedString) -> Bool), ((_PackedString, _PackedString) -> (_PackedString, _PackedString) -> Bool)] [_CONSTM_ Eq (==) ((_PackedString, _PackedString)), _CONSTM_ Eq (/=) ((_PackedString, _PackedString))] _N_
- (==) = _A_ 2 _U_ 11 _N_ _S_ "U(SL)U(SL)" {_A_ 4 _U_ 2222 _N_ _N_ _N_ _N_} _N_ _N_,
- (/=) = _A_ 2 _U_ 22 _N_ _N_ _N_ _N_ #-}
+ (==) = { _A_ 2 _U_ 11 _N_ _S_ "U(SL)U(SL)" {_A_ 4 _U_ 2222 _N_ _N_ _N_ _N_} _N_ _N_ },
+ (/=) = { _A_ 2 _U_ 11 _N_ _S_ "U(SL)U(SL)" {_A_ 4 _U_ 2222 _N_ _N_ _N_ _N_} _N_ _N_ } #-}
instance (Ix a, Eq b) => Eq (Array a b)
{-# GHC_PRAGMA _M_ PreludeArray {-dfun-} _A_ 2 _U_ 21 _N_ _N_ _N_ _N_ #-}
instance (Eq a, Eq b) => Eq (Assoc a b)
{-# GHC_PRAGMA _M_ PreludeArray {-dfun-} _A_ 2 _U_ 11 _N_ _N_ _N_ _N_ #-}
instance Eq Bool
{-# GHC_PRAGMA _M_ PreludeCore {-dfun-} _A_ 0 _N_ _N_ _N_ _F_ _IF_ARGS_ 0 0 X 3 _!_ _TUP_2 [(Bool -> Bool -> Bool), (Bool -> Bool -> Bool)] [_CONSTM_ Eq (==) (Bool), _CONSTM_ Eq (/=) (Bool)] _N_
- (==) = _A_ 2 _U_ 11 _N_ _S_ "EE" _F_ _IF_ARGS_ 0 2 CC 7 \ (u0 :: Bool) (u1 :: Bool) -> case u0 of { _ALG_ True -> u1; False -> case u1 of { _ALG_ True -> _!_ False [] []; False -> _!_ True [] []; _NO_DEFLT_ }; _NO_DEFLT_ } _N_,
- (/=) = _A_ 2 _U_ 11 _N_ _S_ "EE" _F_ _IF_ARGS_ 0 2 CC 7 \ (u0 :: Bool) (u1 :: Bool) -> case u0 of { _ALG_ True -> case u1 of { _ALG_ True -> _!_ False [] []; False -> _!_ True [] []; _NO_DEFLT_ }; False -> u1; _NO_DEFLT_ } _N_ #-}
+ (==) = { _A_ 2 _U_ 11 _N_ _S_ "EE" _F_ _IF_ARGS_ 0 2 CC 7 \ (u0 :: Bool) (u1 :: Bool) -> case u0 of { _ALG_ True -> u1; False -> case u1 of { _ALG_ True -> _!_ False [] []; False -> _!_ True [] []; _NO_DEFLT_ }; _NO_DEFLT_ } _N_ },
+ (/=) = { _A_ 2 _U_ 11 _N_ _S_ "EE" _F_ _IF_ARGS_ 0 2 CC 7 \ (u0 :: Bool) (u1 :: Bool) -> case u0 of { _ALG_ True -> case u1 of { _ALG_ True -> _!_ False [] []; False -> _!_ True [] []; _NO_DEFLT_ }; False -> u1; _NO_DEFLT_ } _N_ } #-}
instance Eq Char
{-# GHC_PRAGMA _M_ PreludeCore {-dfun-} _A_ 0 _N_ _N_ _N_ _F_ _IF_ARGS_ 0 0 X 3 _!_ _TUP_2 [(Char -> Char -> Bool), (Char -> Char -> Bool)] [_CONSTM_ Eq (==) (Char), _CONSTM_ Eq (/=) (Char)] _N_
- (==) = _A_ 2 _U_ 11 _N_ _S_ "U(P)U(P)" {_A_ 2 _U_ 22 _N_ _N_ _F_ _IF_ARGS_ 0 2 XX 1 \ (u0 :: Char#) (u1 :: Char#) -> _#_ eqChar# [] [u0, u1] _N_} _F_ _IF_ARGS_ 0 2 CC 3 \ (u0 :: Char) (u1 :: Char) -> case u0 of { _ALG_ C# (u2 :: Char#) -> case u1 of { _ALG_ C# (u3 :: Char#) -> _#_ eqChar# [] [u2, u3]; _NO_DEFLT_ }; _NO_DEFLT_ } _N_,
- (/=) = _A_ 2 _U_ 11 _N_ _S_ "U(P)U(P)" {_A_ 2 _U_ 22 _N_ _N_ _F_ _IF_ARGS_ 0 2 XX 1 \ (u0 :: Char#) (u1 :: Char#) -> _#_ neChar# [] [u0, u1] _N_} _F_ _IF_ARGS_ 0 2 CC 3 \ (u0 :: Char) (u1 :: Char) -> case u0 of { _ALG_ C# (u2 :: Char#) -> case u1 of { _ALG_ C# (u3 :: Char#) -> _#_ neChar# [] [u2, u3]; _NO_DEFLT_ }; _NO_DEFLT_ } _N_ #-}
+ (==) = { _A_ 2 _U_ 11 _N_ _S_ "U(P)U(P)" {_A_ 2 _U_ 22 _N_ _N_ _F_ _IF_ARGS_ 0 2 XX 1 \ (u0 :: Char#) (u1 :: Char#) -> _#_ eqChar# [] [u0, u1] _N_} _F_ _IF_ARGS_ 0 2 CC 3 \ (u0 :: Char) (u1 :: Char) -> case u0 of { _ALG_ C# (u2 :: Char#) -> case u1 of { _ALG_ C# (u3 :: Char#) -> _#_ eqChar# [] [u2, u3]; _NO_DEFLT_ }; _NO_DEFLT_ } _N_ },
+ (/=) = { _A_ 2 _U_ 11 _N_ _S_ "U(P)U(P)" {_A_ 2 _U_ 22 _N_ _N_ _F_ _IF_ARGS_ 0 2 XX 1 \ (u0 :: Char#) (u1 :: Char#) -> _#_ neChar# [] [u0, u1] _N_} _F_ _IF_ARGS_ 0 2 CC 3 \ (u0 :: Char) (u1 :: Char) -> case u0 of { _ALG_ C# (u2 :: Char#) -> case u1 of { _ALG_ C# (u3 :: Char#) -> _#_ neChar# [] [u2, u3]; _NO_DEFLT_ }; _NO_DEFLT_ } _N_ } #-}
instance Eq a => Eq (Complex a)
{-# GHC_PRAGMA _M_ PreludeComplex {-dfun-} _A_ 1 _U_ 2 _N_ _N_ _N_ _N_ #-}
instance Eq (Complex Double)
{-# GHC_PRAGMA _M_ PreludeComplex {-dfun-} _A_ 0 _N_ _N_ _N_ _F_ _IF_ARGS_ 0 0 X 3 _!_ _TUP_2 [(Complex Double -> Complex Double -> Bool), (Complex Double -> Complex Double -> Bool)] [_CONSTM_ Eq (==) (Complex Double), _CONSTM_ Eq (/=) (Complex Double)] _N_
- (==) = _A_ 2 _U_ 11 _N_ _S_ "U(U(P)L)U(U(P)L)" {_A_ 4 _U_ 2121 _N_ _N_ _F_ _IF_ARGS_ 0 4 XCXC 7 \ (u0 :: Double#) (u1 :: Double) (u2 :: Double#) (u3 :: Double) -> case _#_ eqDouble# [] [u0, u2] of { _ALG_ True -> case u1 of { _ALG_ D# (u4 :: Double#) -> case u3 of { _ALG_ D# (u5 :: Double#) -> _#_ eqDouble# [] [u4, u5]; _NO_DEFLT_ }; _NO_DEFLT_ }; False -> _!_ False [] []; _NO_DEFLT_ } _N_} _F_ _ALWAYS_ \ (u0 :: Complex Double) (u1 :: Complex Double) -> case u0 of { _ALG_ (:+) (u2 :: Double) (u3 :: Double) -> case u2 of { _ALG_ D# (u4 :: Double#) -> case u1 of { _ALG_ (:+) (u5 :: Double) (u6 :: Double) -> case u5 of { _ALG_ D# (u7 :: Double#) -> case _#_ eqDouble# [] [u4, u7] of { _ALG_ True -> case u3 of { _ALG_ D# (u8 :: Double#) -> case u6 of { _ALG_ D# (u9 :: Double#) -> _#_ eqDouble# [] [u8, u9]; _NO_DEFLT_ }; _NO_DEFLT_ }; False -> _!_ False [] []; _NO_DEFLT_ }; _NO_DEFLT_ }; _NO_DEFLT_ }; _NO_DEFLT_ }; _NO_DEFLT_ } _N_,
- (/=) = _A_ 2 _U_ 11 _N_ _S_ "U(U(P)L)U(U(P)L)" {_A_ 4 _U_ 2121 _N_ _N_ _F_ _IF_ARGS_ 0 4 XCXC 7 \ (u0 :: Double#) (u1 :: Double) (u2 :: Double#) (u3 :: Double) -> case _#_ neDouble# [] [u0, u2] of { _ALG_ True -> _!_ True [] []; False -> case u1 of { _ALG_ D# (u4 :: Double#) -> case u3 of { _ALG_ D# (u5 :: Double#) -> _#_ neDouble# [] [u4, u5]; _NO_DEFLT_ }; _NO_DEFLT_ }; _NO_DEFLT_ } _N_} _F_ _ALWAYS_ \ (u0 :: Complex Double) (u1 :: Complex Double) -> case u0 of { _ALG_ (:+) (u2 :: Double) (u3 :: Double) -> case u2 of { _ALG_ D# (u4 :: Double#) -> case u1 of { _ALG_ (:+) (u5 :: Double) (u6 :: Double) -> case u5 of { _ALG_ D# (u7 :: Double#) -> case _#_ neDouble# [] [u4, u7] of { _ALG_ True -> _!_ True [] []; False -> case u3 of { _ALG_ D# (u8 :: Double#) -> case u6 of { _ALG_ D# (u9 :: Double#) -> _#_ neDouble# [] [u8, u9]; _NO_DEFLT_ }; _NO_DEFLT_ }; _NO_DEFLT_ }; _NO_DEFLT_ }; _NO_DEFLT_ }; _NO_DEFLT_ }; _NO_DEFLT_ } _N_ #-}
+ (==) = { _A_ 2 _U_ 11 _N_ _S_ "U(U(P)L)U(U(P)L)" {_A_ 4 _U_ 2121 _N_ _N_ _F_ _IF_ARGS_ 0 4 XCXC 7 \ (u0 :: Double#) (u1 :: Double) (u2 :: Double#) (u3 :: Double) -> case _#_ eqDouble# [] [u0, u2] of { _ALG_ True -> case u1 of { _ALG_ D# (u4 :: Double#) -> case u3 of { _ALG_ D# (u5 :: Double#) -> _#_ eqDouble# [] [u4, u5]; _NO_DEFLT_ }; _NO_DEFLT_ }; False -> _!_ False [] []; _NO_DEFLT_ } _N_} _F_ _ALWAYS_ \ (u0 :: Complex Double) (u1 :: Complex Double) -> case u0 of { _ALG_ (:+) (u2 :: Double) (u3 :: Double) -> case u2 of { _ALG_ D# (u4 :: Double#) -> case u1 of { _ALG_ (:+) (u5 :: Double) (u6 :: Double) -> case u5 of { _ALG_ D# (u7 :: Double#) -> case _#_ eqDouble# [] [u4, u7] of { _ALG_ True -> case u3 of { _ALG_ D# (u8 :: Double#) -> case u6 of { _ALG_ D# (u9 :: Double#) -> _#_ eqDouble# [] [u8, u9]; _NO_DEFLT_ }; _NO_DEFLT_ }; False -> _!_ False [] []; _NO_DEFLT_ }; _NO_DEFLT_ }; _NO_DEFLT_ }; _NO_DEFLT_ }; _NO_DEFLT_ } _N_ },
+ (/=) = { _A_ 2 _U_ 11 _N_ _S_ "U(U(P)L)U(U(P)L)" {_A_ 4 _U_ 2121 _N_ _N_ _F_ _IF_ARGS_ 0 4 XCXC 7 \ (u0 :: Double#) (u1 :: Double) (u2 :: Double#) (u3 :: Double) -> case _#_ neDouble# [] [u0, u2] of { _ALG_ True -> _!_ True [] []; False -> case u1 of { _ALG_ D# (u4 :: Double#) -> case u3 of { _ALG_ D# (u5 :: Double#) -> _#_ neDouble# [] [u4, u5]; _NO_DEFLT_ }; _NO_DEFLT_ }; _NO_DEFLT_ } _N_} _F_ _ALWAYS_ \ (u0 :: Complex Double) (u1 :: Complex Double) -> case u0 of { _ALG_ (:+) (u2 :: Double) (u3 :: Double) -> case u2 of { _ALG_ D# (u4 :: Double#) -> case u1 of { _ALG_ (:+) (u5 :: Double) (u6 :: Double) -> case u5 of { _ALG_ D# (u7 :: Double#) -> case _#_ neDouble# [] [u4, u7] of { _ALG_ True -> _!_ True [] []; False -> case u3 of { _ALG_ D# (u8 :: Double#) -> case u6 of { _ALG_ D# (u9 :: Double#) -> _#_ neDouble# [] [u8, u9]; _NO_DEFLT_ }; _NO_DEFLT_ }; _NO_DEFLT_ }; _NO_DEFLT_ }; _NO_DEFLT_ }; _NO_DEFLT_ }; _NO_DEFLT_ } _N_ } #-}
instance Eq Double
{-# GHC_PRAGMA _M_ PreludeCore {-dfun-} _A_ 0 _N_ _N_ _N_ _F_ _IF_ARGS_ 0 0 X 3 _!_ _TUP_2 [(Double -> Double -> Bool), (Double -> Double -> Bool)] [_CONSTM_ Eq (==) (Double), _CONSTM_ Eq (/=) (Double)] _N_
- (==) = _A_ 2 _U_ 11 _N_ _S_ "U(P)U(P)" {_A_ 2 _U_ 22 _N_ _N_ _F_ _IF_ARGS_ 0 2 XX 1 \ (u0 :: Double#) (u1 :: Double#) -> _#_ eqDouble# [] [u0, u1] _N_} _F_ _IF_ARGS_ 0 2 CC 3 \ (u0 :: Double) (u1 :: Double) -> case u0 of { _ALG_ D# (u2 :: Double#) -> case u1 of { _ALG_ D# (u3 :: Double#) -> _#_ eqDouble# [] [u2, u3]; _NO_DEFLT_ }; _NO_DEFLT_ } _N_,
- (/=) = _A_ 2 _U_ 11 _N_ _S_ "U(P)U(P)" {_A_ 2 _U_ 22 _N_ _N_ _F_ _IF_ARGS_ 0 2 XX 1 \ (u0 :: Double#) (u1 :: Double#) -> _#_ neDouble# [] [u0, u1] _N_} _F_ _IF_ARGS_ 0 2 CC 3 \ (u0 :: Double) (u1 :: Double) -> case u0 of { _ALG_ D# (u2 :: Double#) -> case u1 of { _ALG_ D# (u3 :: Double#) -> _#_ neDouble# [] [u2, u3]; _NO_DEFLT_ }; _NO_DEFLT_ } _N_ #-}
+ (==) = { _A_ 2 _U_ 11 _N_ _S_ "U(P)U(P)" {_A_ 2 _U_ 22 _N_ _N_ _F_ _IF_ARGS_ 0 2 XX 1 \ (u0 :: Double#) (u1 :: Double#) -> _#_ eqDouble# [] [u0, u1] _N_} _F_ _IF_ARGS_ 0 2 CC 3 \ (u0 :: Double) (u1 :: Double) -> case u0 of { _ALG_ D# (u2 :: Double#) -> case u1 of { _ALG_ D# (u3 :: Double#) -> _#_ eqDouble# [] [u2, u3]; _NO_DEFLT_ }; _NO_DEFLT_ } _N_ },
+ (/=) = { _A_ 2 _U_ 11 _N_ _S_ "U(P)U(P)" {_A_ 2 _U_ 22 _N_ _N_ _F_ _IF_ARGS_ 0 2 XX 1 \ (u0 :: Double#) (u1 :: Double#) -> _#_ neDouble# [] [u0, u1] _N_} _F_ _IF_ARGS_ 0 2 CC 3 \ (u0 :: Double) (u1 :: Double) -> case u0 of { _ALG_ D# (u2 :: Double#) -> case u1 of { _ALG_ D# (u3 :: Double#) -> _#_ neDouble# [] [u2, u3]; _NO_DEFLT_ }; _NO_DEFLT_ } _N_ } #-}
instance (Eq a, Eq b) => Eq (Either a b)
{-# GHC_PRAGMA _M_ PreludeMonadicIO {-dfun-} _A_ 2 _U_ 11 _N_ _N_ _N_ _N_ #-}
instance Eq Float
{-# GHC_PRAGMA _M_ PreludeCore {-dfun-} _A_ 0 _N_ _N_ _N_ _F_ _IF_ARGS_ 0 0 X 3 _!_ _TUP_2 [(Float -> Float -> Bool), (Float -> Float -> Bool)] [_CONSTM_ Eq (==) (Float), _CONSTM_ Eq (/=) (Float)] _N_
- (==) = _A_ 2 _U_ 11 _N_ _S_ "U(P)U(P)" {_A_ 2 _U_ 22 _N_ _N_ _F_ _IF_ARGS_ 0 2 XX 1 \ (u0 :: Float#) (u1 :: Float#) -> _#_ eqFloat# [] [u0, u1] _N_} _F_ _IF_ARGS_ 0 2 CC 3 \ (u0 :: Float) (u1 :: Float) -> case u0 of { _ALG_ F# (u2 :: Float#) -> case u1 of { _ALG_ F# (u3 :: Float#) -> _#_ eqFloat# [] [u2, u3]; _NO_DEFLT_ }; _NO_DEFLT_ } _N_,
- (/=) = _A_ 2 _U_ 11 _N_ _S_ "U(P)U(P)" {_A_ 2 _U_ 22 _N_ _N_ _F_ _IF_ARGS_ 0 2 XX 1 \ (u0 :: Float#) (u1 :: Float#) -> _#_ neFloat# [] [u0, u1] _N_} _F_ _IF_ARGS_ 0 2 CC 3 \ (u0 :: Float) (u1 :: Float) -> case u0 of { _ALG_ F# (u2 :: Float#) -> case u1 of { _ALG_ F# (u3 :: Float#) -> _#_ neFloat# [] [u2, u3]; _NO_DEFLT_ }; _NO_DEFLT_ } _N_ #-}
+ (==) = { _A_ 2 _U_ 11 _N_ _S_ "U(P)U(P)" {_A_ 2 _U_ 22 _N_ _N_ _F_ _IF_ARGS_ 0 2 XX 1 \ (u0 :: Float#) (u1 :: Float#) -> _#_ eqFloat# [] [u0, u1] _N_} _F_ _IF_ARGS_ 0 2 CC 3 \ (u0 :: Float) (u1 :: Float) -> case u0 of { _ALG_ F# (u2 :: Float#) -> case u1 of { _ALG_ F# (u3 :: Float#) -> _#_ eqFloat# [] [u2, u3]; _NO_DEFLT_ }; _NO_DEFLT_ } _N_ },
+ (/=) = { _A_ 2 _U_ 11 _N_ _S_ "U(P)U(P)" {_A_ 2 _U_ 22 _N_ _N_ _F_ _IF_ARGS_ 0 2 XX 1 \ (u0 :: Float#) (u1 :: Float#) -> _#_ neFloat# [] [u0, u1] _N_} _F_ _IF_ARGS_ 0 2 CC 3 \ (u0 :: Float) (u1 :: Float) -> case u0 of { _ALG_ F# (u2 :: Float#) -> case u1 of { _ALG_ F# (u3 :: Float#) -> _#_ neFloat# [] [u2, u3]; _NO_DEFLT_ }; _NO_DEFLT_ } _N_ } #-}
instance Eq Int
{-# GHC_PRAGMA _M_ PreludeCore {-dfun-} _A_ 0 _N_ _N_ _N_ _F_ _IF_ARGS_ 0 0 X 3 _!_ _TUP_2 [(Int -> Int -> Bool), (Int -> Int -> Bool)] [_CONSTM_ Eq (==) (Int), _CONSTM_ Eq (/=) (Int)] _N_
- (==) = _A_ 2 _U_ 11 _N_ _S_ "U(P)U(P)" {_A_ 2 _U_ 22 _N_ _N_ _F_ _IF_ARGS_ 0 2 XX 1 \ (u0 :: Int#) (u1 :: Int#) -> _#_ eqInt# [] [u0, u1] _N_} _F_ _IF_ARGS_ 0 2 CC 3 \ (u0 :: Int) (u1 :: Int) -> case u0 of { _ALG_ I# (u2 :: Int#) -> case u1 of { _ALG_ I# (u3 :: Int#) -> _#_ eqInt# [] [u2, u3]; _NO_DEFLT_ }; _NO_DEFLT_ } _N_,
- (/=) = _A_ 2 _U_ 11 _N_ _S_ "U(P)U(P)" {_A_ 2 _U_ 22 _N_ _N_ _F_ _IF_ARGS_ 0 2 XX 1 \ (u0 :: Int#) (u1 :: Int#) -> _#_ neInt# [] [u0, u1] _N_} _F_ _IF_ARGS_ 0 2 CC 3 \ (u0 :: Int) (u1 :: Int) -> case u0 of { _ALG_ I# (u2 :: Int#) -> case u1 of { _ALG_ I# (u3 :: Int#) -> _#_ neInt# [] [u2, u3]; _NO_DEFLT_ }; _NO_DEFLT_ } _N_ #-}
+ (==) = { _A_ 2 _U_ 11 _N_ _S_ "U(P)U(P)" {_A_ 2 _U_ 22 _N_ _N_ _F_ _IF_ARGS_ 0 2 XX 1 \ (u0 :: Int#) (u1 :: Int#) -> _#_ eqInt# [] [u0, u1] _N_} _F_ _IF_ARGS_ 0 2 CC 3 \ (u0 :: Int) (u1 :: Int) -> case u0 of { _ALG_ I# (u2 :: Int#) -> case u1 of { _ALG_ I# (u3 :: Int#) -> _#_ eqInt# [] [u2, u3]; _NO_DEFLT_ }; _NO_DEFLT_ } _N_ },
+ (/=) = { _A_ 2 _U_ 11 _N_ _S_ "U(P)U(P)" {_A_ 2 _U_ 22 _N_ _N_ _F_ _IF_ARGS_ 0 2 XX 1 \ (u0 :: Int#) (u1 :: Int#) -> _#_ neInt# [] [u0, u1] _N_} _F_ _IF_ARGS_ 0 2 CC 3 \ (u0 :: Int) (u1 :: Int) -> case u0 of { _ALG_ I# (u2 :: Int#) -> case u1 of { _ALG_ I# (u3 :: Int#) -> _#_ neInt# [] [u2, u3]; _NO_DEFLT_ }; _NO_DEFLT_ } _N_ } #-}
instance Eq Integer
{-# GHC_PRAGMA _M_ PreludeCore {-dfun-} _A_ 0 _N_ _N_ _N_ _F_ _IF_ARGS_ 0 0 X 3 _!_ _TUP_2 [(Integer -> Integer -> Bool), (Integer -> Integer -> Bool)] [_CONSTM_ Eq (==) (Integer), _CONSTM_ Eq (/=) (Integer)] _N_
- (==) = _A_ 2 _U_ 11 _N_ _S_ "U(PPP)U(PPP)" {_A_ 4 _U_ 2221 _N_ _N_ _F_ _IF_ARGS_ 0 4 XXXC 4 \ (u0 :: Int#) (u1 :: Int#) (u2 :: ByteArray#) (u3 :: Integer) -> case u3 of { _ALG_ J# (u4 :: Int#) (u5 :: Int#) (u6 :: ByteArray#) -> case _#_ cmpInteger# [] [u0, u1, u2, u4, u5, u6] of { _PRIM_ 0# -> _!_ True [] []; (u7 :: Int#) -> _!_ False [] [] }; _NO_DEFLT_ } _N_} _F_ _IF_ARGS_ 0 2 CC 5 \ (u0 :: Integer) (u1 :: Integer) -> case u0 of { _ALG_ J# (u2 :: Int#) (u3 :: Int#) (u4 :: ByteArray#) -> case u1 of { _ALG_ J# (u5 :: Int#) (u6 :: Int#) (u7 :: ByteArray#) -> case _#_ cmpInteger# [] [u2, u3, u4, u5, u6, u7] of { _PRIM_ 0# -> _!_ True [] []; (u8 :: Int#) -> _!_ False [] [] }; _NO_DEFLT_ }; _NO_DEFLT_ } _N_,
- (/=) = _A_ 2 _U_ 11 _N_ _S_ "U(PPP)U(PPP)" {_A_ 4 _U_ 2221 _N_ _N_ _F_ _IF_ARGS_ 0 4 XXXC 4 \ (u0 :: Int#) (u1 :: Int#) (u2 :: ByteArray#) (u3 :: Integer) -> case u3 of { _ALG_ J# (u4 :: Int#) (u5 :: Int#) (u6 :: ByteArray#) -> case _#_ cmpInteger# [] [u0, u1, u2, u4, u5, u6] of { _PRIM_ 0# -> _!_ False [] []; (u7 :: Int#) -> _!_ True [] [] }; _NO_DEFLT_ } _N_} _F_ _IF_ARGS_ 0 2 CC 5 \ (u0 :: Integer) (u1 :: Integer) -> case u0 of { _ALG_ J# (u2 :: Int#) (u3 :: Int#) (u4 :: ByteArray#) -> case u1 of { _ALG_ J# (u5 :: Int#) (u6 :: Int#) (u7 :: ByteArray#) -> case _#_ cmpInteger# [] [u2, u3, u4, u5, u6, u7] of { _PRIM_ 0# -> _!_ False [] []; (u8 :: Int#) -> _!_ True [] [] }; _NO_DEFLT_ }; _NO_DEFLT_ } _N_ #-}
+ (==) = { _A_ 2 _U_ 11 _N_ _S_ "U(PPP)U(PPP)" {_A_ 4 _U_ 2221 _N_ _N_ _F_ _IF_ARGS_ 0 4 XXXC 4 \ (u0 :: Int#) (u1 :: Int#) (u2 :: ByteArray#) (u3 :: Integer) -> case u3 of { _ALG_ J# (u4 :: Int#) (u5 :: Int#) (u6 :: ByteArray#) -> case _#_ cmpInteger# [] [u0, u1, u2, u4, u5, u6] of { _PRIM_ 0# -> _!_ True [] []; (u7 :: Int#) -> _!_ False [] [] }; _NO_DEFLT_ } _N_} _F_ _IF_ARGS_ 0 2 CC 5 \ (u0 :: Integer) (u1 :: Integer) -> case u0 of { _ALG_ J# (u2 :: Int#) (u3 :: Int#) (u4 :: ByteArray#) -> case u1 of { _ALG_ J# (u5 :: Int#) (u6 :: Int#) (u7 :: ByteArray#) -> case _#_ cmpInteger# [] [u2, u3, u4, u5, u6, u7] of { _PRIM_ 0# -> _!_ True [] []; (u8 :: Int#) -> _!_ False [] [] }; _NO_DEFLT_ }; _NO_DEFLT_ } _N_ },
+ (/=) = { _A_ 2 _U_ 11 _N_ _S_ "U(PPP)U(PPP)" {_A_ 4 _U_ 2221 _N_ _N_ _F_ _IF_ARGS_ 0 4 XXXC 4 \ (u0 :: Int#) (u1 :: Int#) (u2 :: ByteArray#) (u3 :: Integer) -> case u3 of { _ALG_ J# (u4 :: Int#) (u5 :: Int#) (u6 :: ByteArray#) -> case _#_ cmpInteger# [] [u0, u1, u2, u4, u5, u6] of { _PRIM_ 0# -> _!_ False [] []; (u7 :: Int#) -> _!_ True [] [] }; _NO_DEFLT_ } _N_} _F_ _IF_ARGS_ 0 2 CC 5 \ (u0 :: Integer) (u1 :: Integer) -> case u0 of { _ALG_ J# (u2 :: Int#) (u3 :: Int#) (u4 :: ByteArray#) -> case u1 of { _ALG_ J# (u5 :: Int#) (u6 :: Int#) (u7 :: ByteArray#) -> case _#_ cmpInteger# [] [u2, u3, u4, u5, u6, u7] of { _PRIM_ 0# -> _!_ False [] []; (u8 :: Int#) -> _!_ True [] [] }; _NO_DEFLT_ }; _NO_DEFLT_ } _N_ } #-}
instance Eq a => Eq (Maybe a)
{-# GHC_PRAGMA _M_ PreludeStdIO {-dfun-} _A_ 1 _U_ 1 _N_ _N_ _N_ _N_ #-}
instance Integral a => Eq (Ratio a)
{-# GHC_PRAGMA _M_ PreludeRatio {-dfun-} _A_ 1 _U_ 1 _N_ _N_ _N_ _N_ #-}
instance Eq (Ratio Integer)
{-# GHC_PRAGMA _M_ PreludeRatio {-dfun-} _A_ 0 _N_ _N_ _N_ _F_ _IF_ARGS_ 0 0 X 3 _!_ _TUP_2 [(Ratio Integer -> Ratio Integer -> Bool), (Ratio Integer -> Ratio Integer -> Bool)] [_CONSTM_ Eq (==) (Ratio Integer), _CONSTM_ Eq (/=) (Ratio Integer)] _N_
- (==) = _A_ 2 _U_ 11 _N_ _S_ "U(U(PPP)L)U(U(PPP)L)" {_A_ 5 _U_ 22211 _N_ _N_ _F_ _IF_ARGS_ 0 5 XXXCC 9 \ (u0 :: Int#) (u1 :: Int#) (u2 :: ByteArray#) (u3 :: Integer) (u4 :: Ratio Integer) -> case u4 of { _ALG_ (:%) (u5 :: Integer) (u6 :: Integer) -> case u5 of { _ALG_ J# (u7 :: Int#) (u8 :: Int#) (u9 :: ByteArray#) -> case _#_ cmpInteger# [] [u0, u1, u2, u7, u8, u9] of { _PRIM_ 0# -> case u3 of { _ALG_ J# (ua :: Int#) (ub :: Int#) (uc :: ByteArray#) -> case u6 of { _ALG_ J# (ud :: Int#) (ue :: Int#) (uf :: ByteArray#) -> case _#_ cmpInteger# [] [ua, ub, uc, ud, ue, uf] of { _PRIM_ 0# -> _!_ True [] []; (ug :: Int#) -> _!_ False [] [] }; _NO_DEFLT_ }; _NO_DEFLT_ }; (uh :: Int#) -> _!_ False [] [] }; _NO_DEFLT_ }; _NO_DEFLT_ } _N_} _N_ _N_,
- (/=) = _A_ 2 _U_ 11 _N_ _S_ "U(U(PPP)L)U(U(PPP)L)" {_A_ 5 _U_ 22211 _N_ _N_ _F_ _IF_ARGS_ 0 5 XXXCC 9 \ (u0 :: Int#) (u1 :: Int#) (u2 :: ByteArray#) (u3 :: Integer) (u4 :: Ratio Integer) -> case u4 of { _ALG_ (:%) (u5 :: Integer) (u6 :: Integer) -> case u5 of { _ALG_ J# (u7 :: Int#) (u8 :: Int#) (u9 :: ByteArray#) -> case _#_ cmpInteger# [] [u0, u1, u2, u7, u8, u9] of { _PRIM_ 0# -> case u3 of { _ALG_ J# (ua :: Int#) (ub :: Int#) (uc :: ByteArray#) -> case u6 of { _ALG_ J# (ud :: Int#) (ue :: Int#) (uf :: ByteArray#) -> case _#_ cmpInteger# [] [ua, ub, uc, ud, ue, uf] of { _PRIM_ 0# -> _!_ False [] []; (ug :: Int#) -> _!_ True [] [] }; _NO_DEFLT_ }; _NO_DEFLT_ }; (uh :: Int#) -> _!_ True [] [] }; _NO_DEFLT_ }; _NO_DEFLT_ } _N_} _N_ _N_ #-}
+ (==) = { _A_ 2 _U_ 11 _N_ _S_ "U(U(PPP)L)U(U(PPP)L)" {_A_ 5 _U_ 22211 _N_ _N_ _F_ _IF_ARGS_ 0 5 XXXCC 9 \ (u0 :: Int#) (u1 :: Int#) (u2 :: ByteArray#) (u3 :: Integer) (u4 :: Ratio Integer) -> case u4 of { _ALG_ (:%) (u5 :: Integer) (u6 :: Integer) -> case u5 of { _ALG_ J# (u7 :: Int#) (u8 :: Int#) (u9 :: ByteArray#) -> case _#_ cmpInteger# [] [u0, u1, u2, u7, u8, u9] of { _PRIM_ 0# -> case u3 of { _ALG_ J# (ua :: Int#) (ub :: Int#) (uc :: ByteArray#) -> case u6 of { _ALG_ J# (ud :: Int#) (ue :: Int#) (uf :: ByteArray#) -> case _#_ cmpInteger# [] [ua, ub, uc, ud, ue, uf] of { _PRIM_ 0# -> _!_ True [] []; (ug :: Int#) -> _!_ False [] [] }; _NO_DEFLT_ }; _NO_DEFLT_ }; (uh :: Int#) -> _!_ False [] [] }; _NO_DEFLT_ }; _NO_DEFLT_ } _N_} _N_ _N_ },
+ (/=) = { _A_ 2 _U_ 11 _N_ _S_ "U(U(PPP)L)U(U(PPP)L)" {_A_ 5 _U_ 22211 _N_ _N_ _F_ _IF_ARGS_ 0 5 XXXCC 9 \ (u0 :: Int#) (u1 :: Int#) (u2 :: ByteArray#) (u3 :: Integer) (u4 :: Ratio Integer) -> case u4 of { _ALG_ (:%) (u5 :: Integer) (u6 :: Integer) -> case u5 of { _ALG_ J# (u7 :: Int#) (u8 :: Int#) (u9 :: ByteArray#) -> case _#_ cmpInteger# [] [u0, u1, u2, u7, u8, u9] of { _PRIM_ 0# -> case u3 of { _ALG_ J# (ua :: Int#) (ub :: Int#) (uc :: ByteArray#) -> case u6 of { _ALG_ J# (ud :: Int#) (ue :: Int#) (uf :: ByteArray#) -> case _#_ cmpInteger# [] [ua, ub, uc, ud, ue, uf] of { _PRIM_ 0# -> _!_ False [] []; (ug :: Int#) -> _!_ True [] [] }; _NO_DEFLT_ }; _NO_DEFLT_ }; (uh :: Int#) -> _!_ True [] [] }; _NO_DEFLT_ }; _NO_DEFLT_ } _N_} _N_ _N_ } #-}
+instance Eq [(Int, Int)]
+ {-# GHC_PRAGMA _M_ PreludeBuiltin {-dfun-} _A_ 0 _N_ _N_ _N_ _F_ _IF_ARGS_ 0 0 X 3 _!_ _TUP_2 [([(Int, Int)] -> [(Int, Int)] -> Bool), ([(Int, Int)] -> [(Int, Int)] -> Bool)] [_CONSTM_ Eq (==) ([(Int, Int)]), _CONSTM_ Eq (/=) ([(Int, Int)])] _N_
+ (==) = { _A_ 2 _U_ 11 _N_ _S_ "SS" _N_ _N_ },
+ (/=) = { _A_ 2 _U_ 11 _N_ _S_ "SS" _N_ _N_ } #-}
instance Eq a => Eq [a]
{-# GHC_PRAGMA _M_ PreludeBuiltin {-dfun-} _A_ 1 _U_ 1 _N_ _N_ _N_ _N_ #-}
+instance Eq [Bool]
+ {-# GHC_PRAGMA _M_ PreludeBuiltin {-dfun-} _A_ 0 _N_ _N_ _N_ _F_ _IF_ARGS_ 0 0 X 3 _!_ _TUP_2 [([Bool] -> [Bool] -> Bool), ([Bool] -> [Bool] -> Bool)] [_CONSTM_ Eq (==) ([Bool]), _CONSTM_ Eq (/=) ([Bool])] _N_
+ (==) = { _A_ 2 _U_ 11 _N_ _S_ "SS" _N_ _N_ },
+ (/=) = { _A_ 2 _U_ 11 _N_ _S_ "SS" _N_ _N_ } #-}
instance Eq [Char]
{-# GHC_PRAGMA _M_ PreludeBuiltin {-dfun-} _A_ 0 _N_ _N_ _N_ _F_ _IF_ARGS_ 0 0 X 3 _!_ _TUP_2 [([Char] -> [Char] -> Bool), ([Char] -> [Char] -> Bool)] [_CONSTM_ Eq (==) ([Char]), _CONSTM_ Eq (/=) ([Char])] _N_
- (==) = _A_ 2 _U_ 11 _N_ _S_ "SS" _N_ _N_,
- (/=) = _A_ 2 _U_ 11 _N_ _S_ "SS" _N_ _N_ #-}
+ (==) = { _A_ 2 _U_ 11 _N_ _S_ "SS" _N_ _N_ },
+ (/=) = { _A_ 2 _U_ 11 _N_ _S_ "SS" _N_ _N_ } #-}
+instance Eq [Complex Double]
+ {-# GHC_PRAGMA _M_ PreludeBuiltin {-dfun-} _A_ 0 _N_ _N_ _N_ _F_ _IF_ARGS_ 0 0 X 3 _!_ _TUP_2 [([Complex Double] -> [Complex Double] -> Bool), ([Complex Double] -> [Complex Double] -> Bool)] [_CONSTM_ Eq (==) ([Complex Double]), _CONSTM_ Eq (/=) ([Complex Double])] _N_
+ (==) = { _A_ 2 _U_ 11 _N_ _S_ "SS" _N_ _N_ },
+ (/=) = { _A_ 2 _U_ 11 _N_ _S_ "SS" _N_ _N_ } #-}
+instance Eq [Double]
+ {-# GHC_PRAGMA _M_ PreludeBuiltin {-dfun-} _A_ 0 _N_ _N_ _N_ _F_ _IF_ARGS_ 0 0 X 3 _!_ _TUP_2 [([Double] -> [Double] -> Bool), ([Double] -> [Double] -> Bool)] [_CONSTM_ Eq (==) ([Double]), _CONSTM_ Eq (/=) ([Double])] _N_
+ (==) = { _A_ 2 _U_ 11 _N_ _S_ "SS" _N_ _N_ },
+ (/=) = { _A_ 2 _U_ 11 _N_ _S_ "SS" _N_ _N_ } #-}
instance Eq [Int]
{-# GHC_PRAGMA _M_ PreludeBuiltin {-dfun-} _A_ 0 _N_ _N_ _N_ _F_ _IF_ARGS_ 0 0 X 3 _!_ _TUP_2 [([Int] -> [Int] -> Bool), ([Int] -> [Int] -> Bool)] [_CONSTM_ Eq (==) ([Int]), _CONSTM_ Eq (/=) ([Int])] _N_
- (==) = _A_ 2 _U_ 11 _N_ _S_ "SS" _N_ _N_,
- (/=) = _A_ 2 _U_ 11 _N_ _S_ "SS" _N_ _N_ #-}
+ (==) = { _A_ 2 _U_ 11 _N_ _S_ "SS" _N_ _N_ },
+ (/=) = { _A_ 2 _U_ 11 _N_ _S_ "SS" _N_ _N_ } #-}
+instance Eq [Integer]
+ {-# GHC_PRAGMA _M_ PreludeBuiltin {-dfun-} _A_ 0 _N_ _N_ _N_ _F_ _IF_ARGS_ 0 0 X 3 _!_ _TUP_2 [([Integer] -> [Integer] -> Bool), ([Integer] -> [Integer] -> Bool)] [_CONSTM_ Eq (==) ([Integer]), _CONSTM_ Eq (/=) ([Integer])] _N_
+ (==) = { _A_ 2 _U_ 11 _N_ _S_ "SS" _N_ _N_ },
+ (/=) = { _A_ 2 _U_ 11 _N_ _S_ "SS" _N_ _N_ } #-}
+instance Eq [[Char]]
+ {-# GHC_PRAGMA _M_ PreludeBuiltin {-dfun-} _A_ 0 _N_ _N_ _N_ _F_ _IF_ARGS_ 0 0 X 3 _!_ _TUP_2 [([[Char]] -> [[Char]] -> Bool), ([[Char]] -> [[Char]] -> Bool)] [_CONSTM_ Eq (==) ([[Char]]), _CONSTM_ Eq (/=) ([[Char]])] _N_
+ (==) = { _A_ 2 _U_ 11 _N_ _S_ "SS" _N_ _N_ },
+ (/=) = { _A_ 2 _U_ 11 _N_ _S_ "SS" _N_ _N_ } #-}
+instance Eq [[Int]]
+ {-# GHC_PRAGMA _M_ PreludeBuiltin {-dfun-} _A_ 0 _N_ _N_ _N_ _F_ _IF_ARGS_ 0 0 X 3 _!_ _TUP_2 [([[Int]] -> [[Int]] -> Bool), ([[Int]] -> [[Int]] -> Bool)] [_CONSTM_ Eq (==) ([[Int]]), _CONSTM_ Eq (/=) ([[Int]])] _N_
+ (==) = { _A_ 2 _U_ 11 _N_ _S_ "SS" _N_ _N_ },
+ (/=) = { _A_ 2 _U_ 11 _N_ _S_ "SS" _N_ _N_ } #-}
instance Eq _Addr
{-# GHC_PRAGMA _M_ PreludeCore {-dfun-} _A_ 0 _N_ _N_ _N_ _F_ _IF_ARGS_ 0 0 X 3 _!_ _TUP_2 [(_Addr -> _Addr -> Bool), (_Addr -> _Addr -> Bool)] [_CONSTM_ Eq (==) (_Addr), _CONSTM_ Eq (/=) (_Addr)] _N_
- (==) = _A_ 2 _U_ 11 _N_ _S_ "U(P)U(P)" {_A_ 2 _U_ 22 _N_ _N_ _F_ _IF_ARGS_ 0 2 XX 1 \ (u0 :: Addr#) (u1 :: Addr#) -> _#_ eqAddr# [] [u0, u1] _N_} _F_ _IF_ARGS_ 0 2 CC 3 \ (u0 :: _Addr) (u1 :: _Addr) -> case u0 of { _ALG_ A# (u2 :: Addr#) -> case u1 of { _ALG_ A# (u3 :: Addr#) -> _#_ eqAddr# [] [u2, u3]; _NO_DEFLT_ }; _NO_DEFLT_ } _N_,
- (/=) = _A_ 2 _U_ 11 _N_ _S_ "U(P)U(P)" {_A_ 2 _U_ 22 _N_ _N_ _F_ _IF_ARGS_ 0 2 XX 1 \ (u0 :: Addr#) (u1 :: Addr#) -> _#_ neAddr# [] [u0, u1] _N_} _F_ _IF_ARGS_ 0 2 CC 3 \ (u0 :: _Addr) (u1 :: _Addr) -> case u0 of { _ALG_ A# (u2 :: Addr#) -> case u1 of { _ALG_ A# (u3 :: Addr#) -> _#_ neAddr# [] [u2, u3]; _NO_DEFLT_ }; _NO_DEFLT_ } _N_ #-}
+ (==) = { _A_ 2 _U_ 11 _N_ _S_ "U(P)U(P)" {_A_ 2 _U_ 22 _N_ _N_ _F_ _IF_ARGS_ 0 2 XX 1 \ (u0 :: Addr#) (u1 :: Addr#) -> _#_ eqAddr# [] [u0, u1] _N_} _F_ _IF_ARGS_ 0 2 CC 3 \ (u0 :: _Addr) (u1 :: _Addr) -> case u0 of { _ALG_ A# (u2 :: Addr#) -> case u1 of { _ALG_ A# (u3 :: Addr#) -> _#_ eqAddr# [] [u2, u3]; _NO_DEFLT_ }; _NO_DEFLT_ } _N_ },
+ (/=) = { _A_ 2 _U_ 11 _N_ _S_ "U(P)U(P)" {_A_ 2 _U_ 22 _N_ _N_ _F_ _IF_ARGS_ 0 2 XX 1 \ (u0 :: Addr#) (u1 :: Addr#) -> _#_ neAddr# [] [u0, u1] _N_} _F_ _IF_ARGS_ 0 2 CC 3 \ (u0 :: _Addr) (u1 :: _Addr) -> case u0 of { _ALG_ A# (u2 :: Addr#) -> case u1 of { _ALG_ A# (u3 :: Addr#) -> _#_ neAddr# [] [u2, u3]; _NO_DEFLT_ }; _NO_DEFLT_ } _N_ } #-}
instance Eq _PackedString
{-# GHC_PRAGMA _M_ PreludePS {-dfun-} _A_ 0 _N_ _N_ _N_ _F_ _IF_ARGS_ 0 0 X 3 _!_ _TUP_2 [(_PackedString -> _PackedString -> Bool), (_PackedString -> _PackedString -> Bool)] [_CONSTM_ Eq (==) (_PackedString), _CONSTM_ Eq (/=) (_PackedString)] _N_
- (==) = _A_ 2 _U_ 22 _N_ _S_ "SS" _N_ _N_,
- (/=) = _A_ 2 _U_ 22 _N_ _S_ "SS" _N_ _N_ #-}
+ (==) = { _A_ 2 _U_ 22 _N_ _S_ "SS" _N_ _N_ },
+ (/=) = { _A_ 2 _U_ 22 _N_ _S_ "SS" _N_ _N_ } #-}
instance Eq _Word
{-# GHC_PRAGMA _M_ PreludeCore {-dfun-} _A_ 0 _N_ _N_ _N_ _F_ _IF_ARGS_ 0 0 X 3 _!_ _TUP_2 [(_Word -> _Word -> Bool), (_Word -> _Word -> Bool)] [_CONSTM_ Eq (==) (_Word), _CONSTM_ Eq (/=) (_Word)] _N_
- (==) = _A_ 2 _U_ 11 _N_ _S_ "U(P)U(P)" {_A_ 2 _U_ 22 _N_ _N_ _F_ _IF_ARGS_ 0 2 XX 1 \ (u0 :: Word#) (u1 :: Word#) -> _#_ eqWord# [] [u0, u1] _N_} _F_ _IF_ARGS_ 0 2 CC 3 \ (u0 :: _Word) (u1 :: _Word) -> case u0 of { _ALG_ W# (u2 :: Word#) -> case u1 of { _ALG_ W# (u3 :: Word#) -> _#_ eqWord# [] [u2, u3]; _NO_DEFLT_ }; _NO_DEFLT_ } _N_,
- (/=) = _A_ 2 _U_ 11 _N_ _S_ "U(P)U(P)" {_A_ 2 _U_ 22 _N_ _N_ _F_ _IF_ARGS_ 0 2 XX 1 \ (u0 :: Word#) (u1 :: Word#) -> _#_ neWord# [] [u0, u1] _N_} _F_ _IF_ARGS_ 0 2 CC 3 \ (u0 :: _Word) (u1 :: _Word) -> case u0 of { _ALG_ W# (u2 :: Word#) -> case u1 of { _ALG_ W# (u3 :: Word#) -> _#_ neWord# [] [u2, u3]; _NO_DEFLT_ }; _NO_DEFLT_ } _N_ #-}
+ (==) = { _A_ 2 _U_ 11 _N_ _S_ "U(P)U(P)" {_A_ 2 _U_ 22 _N_ _N_ _F_ _IF_ARGS_ 0 2 XX 1 \ (u0 :: Word#) (u1 :: Word#) -> _#_ eqWord# [] [u0, u1] _N_} _F_ _IF_ARGS_ 0 2 CC 3 \ (u0 :: _Word) (u1 :: _Word) -> case u0 of { _ALG_ W# (u2 :: Word#) -> case u1 of { _ALG_ W# (u3 :: Word#) -> _#_ eqWord# [] [u2, u3]; _NO_DEFLT_ }; _NO_DEFLT_ } _N_ },
+ (/=) = { _A_ 2 _U_ 11 _N_ _S_ "U(P)U(P)" {_A_ 2 _U_ 22 _N_ _N_ _F_ _IF_ARGS_ 0 2 XX 1 \ (u0 :: Word#) (u1 :: Word#) -> _#_ neWord# [] [u0, u1] _N_} _F_ _IF_ARGS_ 0 2 CC 3 \ (u0 :: _Word) (u1 :: _Word) -> case u0 of { _ALG_ W# (u2 :: Word#) -> case u1 of { _ALG_ W# (u3 :: Word#) -> _#_ neWord# [] [u2, u3]; _NO_DEFLT_ }; _NO_DEFLT_ } _N_ } #-}
instance RealFloat a => Floating (Complex a)
{-# GHC_PRAGMA _M_ PreludeComplex {-dfun-} _A_ 2 _U_ 22 _N_ _N_ _N_ _N_ #-}
instance Floating (Complex Double)
{-# GHC_PRAGMA _M_ PreludeComplex {-dfun-} _A_ 0 _N_ _N_ _N_ _F_ _IF_ARGS_ 0 0 X 20 _!_ _TUP_19 [{{Fractional (Complex Double)}}, (Complex Double), (Complex Double -> Complex Double), (Complex Double -> Complex Double), (Complex Double -> Complex Double), (Complex Double -> Complex Double -> Complex Double), (Complex Double -> Complex Double -> Complex Double), (Complex Double -> Complex Double), (Complex Double -> Complex Double), (Complex Double -> Complex Double), (Complex Double -> Complex Double), (Complex Double -> Complex Double), (Complex Double -> Complex Double), (Complex Double -> Complex Double), (Complex Double -> Complex Double), (Complex Double -> Complex Double), (Complex Double -> Complex Double), (Complex Double -> Complex Double), (Complex Double -> Complex Double)] [_DFUN_ Fractional (Complex Double), _CONSTM_ Floating pi (Complex Double), _CONSTM_ Floating exp (Complex Double), _CONSTM_ Floating log (Complex Double), _CONSTM_ Floating sqrt (Complex Double), _CONSTM_ Floating (**) (Complex Double), _CONSTM_ Floating logBase (Complex Double), _CONSTM_ Floating sin (Complex Double), _CONSTM_ Floating cos (Complex Double), _CONSTM_ Floating tan (Complex Double), _CONSTM_ Floating asin (Complex Double), _CONSTM_ Floating acos (Complex Double), _CONSTM_ Floating atan (Complex Double), _CONSTM_ Floating sinh (Complex Double), _CONSTM_ Floating cosh (Complex Double), _CONSTM_ Floating tanh (Complex Double), _CONSTM_ Floating asinh (Complex Double), _CONSTM_ Floating acosh (Complex Double), _CONSTM_ Floating atanh (Complex Double)] _N_
- pi = _A_ 0 _N_ _N_ _N_ _N_ _N_,
- exp = _A_ 1 _U_ 1 _N_ _S_ "U(LL)" {_A_ 2 _U_ 12 _N_ _N_ _N_ _N_} _N_ _N_,
- log = _A_ 1 _U_ 2 _N_ _N_ _N_ _N_,
- sqrt = _A_ 1 _U_ 1 _N_ _S_ "U(U(P)L)" {_A_ 2 _U_ 22 _N_ _N_ _N_ _N_} _N_ _N_,
- (**) = _A_ 2 _U_ 21 _N_ _S_ "LU(LL)" {_A_ 3 _U_ 222 _N_ _N_ _N_ _N_} _N_ _N_,
- logBase = _A_ 2 _U_ 22 _N_ _N_ _N_ _N_,
- sin = _A_ 1 _U_ 1 _N_ _S_ "U(LL)" {_A_ 2 _U_ 22 _N_ _N_ _N_ _N_} _N_ _N_,
- cos = _A_ 1 _U_ 1 _N_ _S_ "U(LL)" {_A_ 2 _U_ 22 _N_ _N_ _N_ _N_} _N_ _N_,
- tan = _A_ 1 _U_ 1 _N_ _S_ "U(LL)" {_A_ 2 _U_ 22 _N_ _N_ _N_ _N_} _N_ _N_,
- asin = _A_ 1 _U_ 1 _N_ _S_ "U(LL)" {_A_ 2 _U_ 22 _N_ _N_ _N_ _N_} _N_ _N_,
- acos = _A_ 1 _U_ 1 _N_ _S_ "U(LL)" {_A_ 2 _U_ 22 _N_ _N_ _N_ _N_} _N_ _N_,
- atan = _A_ 1 _U_ 1 _N_ _S_ "U(LL)" {_A_ 2 _U_ 22 _N_ _N_ _N_ _N_} _N_ _N_,
- sinh = _A_ 1 _U_ 1 _N_ _S_ "U(LL)" {_A_ 2 _U_ 22 _N_ _N_ _N_ _N_} _N_ _N_,
- cosh = _A_ 1 _U_ 1 _N_ _S_ "U(LL)" {_A_ 2 _U_ 22 _N_ _N_ _N_ _N_} _N_ _N_,
- tanh = _A_ 1 _U_ 1 _N_ _S_ "U(LL)" {_A_ 2 _U_ 22 _N_ _N_ _N_ _N_} _N_ _N_,
- asinh = _A_ 1 _U_ 1 _N_ _N_ _N_ _N_,
- acosh = _A_ 1 _U_ 1 _N_ _N_ _N_ _N_,
- atanh = _A_ 1 _U_ 1 _N_ _N_ _N_ _N_ #-}
+ pi = { _A_ 0 _N_ _N_ _N_ _F_ _IF_ARGS_ 0 0 X 3 _!_ (:+) [Double] [_CONSTM_ Floating pi (Double), _SPEC_ _ORIG_ PreludeCore __i0 [ (Double) ]] _N_ },
+ exp = { _A_ 1 _U_ 1 _N_ _S_ "U(LL)" {_A_ 2 _U_ 12 _N_ _N_ _N_ _N_} _N_ _N_ },
+ log = { _A_ 1 _U_ 2 _N_ _N_ _N_ _N_ },
+ sqrt = { _A_ 1 _U_ 1 _N_ _S_ "U(U(P)L)" {_A_ 2 _U_ 22 _N_ _N_ _N_ _N_} _N_ _N_ },
+ (**) = { _A_ 2 _U_ 21 _N_ _S_ "LU(LL)" {_A_ 3 _U_ 222 _N_ _N_ _N_ _N_} _N_ _N_ },
+ logBase = { _A_ 2 _U_ 22 _N_ _N_ _N_ _N_ },
+ sin = { _A_ 1 _U_ 1 _N_ _S_ "U(LL)" {_A_ 2 _U_ 22 _N_ _N_ _N_ _N_} _N_ _N_ },
+ cos = { _A_ 1 _U_ 1 _N_ _S_ "U(LL)" {_A_ 2 _U_ 22 _N_ _N_ _N_ _N_} _N_ _N_ },
+ tan = { _A_ 1 _U_ 1 _N_ _S_ "U(LL)" {_A_ 2 _U_ 22 _N_ _N_ _N_ _N_} _N_ _N_ },
+ asin = { _A_ 1 _U_ 1 _N_ _S_ "U(LL)" {_A_ 2 _U_ 22 _N_ _N_ _N_ _N_} _N_ _N_ },
+ acos = { _A_ 1 _U_ 1 _N_ _S_ "U(LL)" {_A_ 2 _U_ 22 _N_ _N_ _N_ _N_} _N_ _N_ },
+ atan = { _A_ 1 _U_ 1 _N_ _S_ "U(LL)" {_A_ 2 _U_ 22 _N_ _N_ _N_ _N_} _N_ _N_ },
+ sinh = { _A_ 1 _U_ 1 _N_ _S_ "U(LL)" {_A_ 2 _U_ 22 _N_ _N_ _N_ _N_} _N_ _N_ },
+ cosh = { _A_ 1 _U_ 1 _N_ _S_ "U(LL)" {_A_ 2 _U_ 22 _N_ _N_ _N_ _N_} _N_ _N_ },
+ tanh = { _A_ 1 _U_ 1 _N_ _S_ "U(LL)" {_A_ 2 _U_ 22 _N_ _N_ _N_ _N_} _N_ _N_ },
+ asinh = { _A_ 1 _U_ 1 _N_ _N_ _N_ _N_ },
+ acosh = { _A_ 1 _U_ 1 _N_ _N_ _N_ _N_ },
+ atanh = { _A_ 1 _U_ 1 _N_ _N_ _N_ _N_ } #-}
instance Floating Double
{-# GHC_PRAGMA _M_ PreludeCore {-dfun-} _A_ 0 _N_ _N_ _N_ _F_ _IF_ARGS_ 0 0 X 20 _!_ _TUP_19 [{{Fractional Double}}, Double, (Double -> Double), (Double -> Double), (Double -> Double), (Double -> Double -> Double), (Double -> Double -> Double), (Double -> Double), (Double -> Double), (Double -> Double), (Double -> Double), (Double -> Double), (Double -> Double), (Double -> Double), (Double -> Double), (Double -> Double), (Double -> Double), (Double -> Double), (Double -> Double)] [_DFUN_ Fractional (Double), _CONSTM_ Floating pi (Double), _CONSTM_ Floating exp (Double), _CONSTM_ Floating log (Double), _CONSTM_ Floating sqrt (Double), _CONSTM_ Floating (**) (Double), _CONSTM_ Floating logBase (Double), _CONSTM_ Floating sin (Double), _CONSTM_ Floating cos (Double), _CONSTM_ Floating tan (Double), _CONSTM_ Floating asin (Double), _CONSTM_ Floating acos (Double), _CONSTM_ Floating atan (Double), _CONSTM_ Floating sinh (Double), _CONSTM_ Floating cosh (Double), _CONSTM_ Floating tanh (Double), _CONSTM_ Floating asinh (Double), _CONSTM_ Floating acosh (Double), _CONSTM_ Floating atanh (Double)] _N_
- pi = _A_ 0 _N_ _N_ _N_ _F_ _IF_ARGS_ 0 0 X 2 _!_ D# [] [3.1415926535897931##] _N_,
- exp = _A_ 1 _U_ 1 _N_ _S_ "U(P)" {_A_ 1 _U_ 2 _N_ _N_ _F_ _IF_ARGS_ 0 1 X 3 \ (u0 :: Double#) -> case _#_ expDouble# [] [u0] of { _PRIM_ (u1 :: Double#) -> _!_ D# [] [u1] } _N_} _F_ _IF_ARGS_ 0 1 C 4 \ (u0 :: Double) -> case u0 of { _ALG_ D# (u1 :: Double#) -> case _#_ expDouble# [] [u1] of { _PRIM_ (u2 :: Double#) -> _!_ D# [] [u2] }; _NO_DEFLT_ } _N_,
- log = _A_ 1 _U_ 1 _N_ _S_ "U(P)" {_A_ 1 _U_ 2 _N_ _N_ _F_ _IF_ARGS_ 0 1 X 3 \ (u0 :: Double#) -> case _#_ logDouble# [] [u0] of { _PRIM_ (u1 :: Double#) -> _!_ D# [] [u1] } _N_} _F_ _IF_ARGS_ 0 1 C 4 \ (u0 :: Double) -> case u0 of { _ALG_ D# (u1 :: Double#) -> case _#_ logDouble# [] [u1] of { _PRIM_ (u2 :: Double#) -> _!_ D# [] [u2] }; _NO_DEFLT_ } _N_,
- sqrt = _A_ 1 _U_ 1 _N_ _S_ "U(P)" {_A_ 1 _U_ 2 _N_ _N_ _F_ _IF_ARGS_ 0 1 X 3 \ (u0 :: Double#) -> case _#_ sqrtDouble# [] [u0] of { _PRIM_ (u1 :: Double#) -> _!_ D# [] [u1] } _N_} _F_ _IF_ARGS_ 0 1 C 4 \ (u0 :: Double) -> case u0 of { _ALG_ D# (u1 :: Double#) -> case _#_ sqrtDouble# [] [u1] of { _PRIM_ (u2 :: Double#) -> _!_ D# [] [u2] }; _NO_DEFLT_ } _N_,
- (**) = _A_ 2 _U_ 11 _N_ _S_ "U(P)U(P)" {_A_ 2 _U_ 22 _N_ _N_ _F_ _IF_ARGS_ 0 2 XX 3 \ (u0 :: Double#) (u1 :: Double#) -> case _#_ powerDouble# [] [u0, u1] of { _PRIM_ (u2 :: Double#) -> _!_ D# [] [u2] } _N_} _F_ _IF_ARGS_ 0 2 CC 5 \ (u0 :: Double) (u1 :: Double) -> case u0 of { _ALG_ D# (u2 :: Double#) -> case u1 of { _ALG_ D# (u3 :: Double#) -> case _#_ powerDouble# [] [u2, u3] of { _PRIM_ (u4 :: Double#) -> _!_ D# [] [u4] }; _NO_DEFLT_ }; _NO_DEFLT_ } _N_,
- logBase = _A_ 2 _U_ 11 _N_ _S_ "U(P)U(P)" {_A_ 2 _U_ 22 _N_ _N_ _F_ _IF_ARGS_ 0 2 XX 5 \ (u0 :: Double#) (u1 :: Double#) -> case _#_ logDouble# [] [u1] of { _PRIM_ (u2 :: Double#) -> case _#_ logDouble# [] [u0] of { _PRIM_ (u3 :: Double#) -> case _#_ divideDouble# [] [u2, u3] of { _PRIM_ (u4 :: Double#) -> _!_ D# [] [u4] } } } _N_} _F_ _IF_ARGS_ 0 2 CC 7 \ (u0 :: Double) (u1 :: Double) -> case u1 of { _ALG_ D# (u2 :: Double#) -> case _#_ logDouble# [] [u2] of { _PRIM_ (u3 :: Double#) -> case u0 of { _ALG_ D# (u4 :: Double#) -> case _#_ logDouble# [] [u4] of { _PRIM_ (u5 :: Double#) -> case _#_ divideDouble# [] [u3, u5] of { _PRIM_ (u6 :: Double#) -> _!_ D# [] [u6] } }; _NO_DEFLT_ } }; _NO_DEFLT_ } _N_,
- sin = _A_ 1 _U_ 1 _N_ _S_ "U(P)" {_A_ 1 _U_ 2 _N_ _N_ _F_ _IF_ARGS_ 0 1 X 3 \ (u0 :: Double#) -> case _#_ sinDouble# [] [u0] of { _PRIM_ (u1 :: Double#) -> _!_ D# [] [u1] } _N_} _F_ _IF_ARGS_ 0 1 C 4 \ (u0 :: Double) -> case u0 of { _ALG_ D# (u1 :: Double#) -> case _#_ sinDouble# [] [u1] of { _PRIM_ (u2 :: Double#) -> _!_ D# [] [u2] }; _NO_DEFLT_ } _N_,
- cos = _A_ 1 _U_ 1 _N_ _S_ "U(P)" {_A_ 1 _U_ 2 _N_ _N_ _F_ _IF_ARGS_ 0 1 X 3 \ (u0 :: Double#) -> case _#_ cosDouble# [] [u0] of { _PRIM_ (u1 :: Double#) -> _!_ D# [] [u1] } _N_} _F_ _IF_ARGS_ 0 1 C 4 \ (u0 :: Double) -> case u0 of { _ALG_ D# (u1 :: Double#) -> case _#_ cosDouble# [] [u1] of { _PRIM_ (u2 :: Double#) -> _!_ D# [] [u2] }; _NO_DEFLT_ } _N_,
- tan = _A_ 1 _U_ 1 _N_ _S_ "U(P)" {_A_ 1 _U_ 2 _N_ _N_ _F_ _IF_ARGS_ 0 1 X 3 \ (u0 :: Double#) -> case _#_ tanDouble# [] [u0] of { _PRIM_ (u1 :: Double#) -> _!_ D# [] [u1] } _N_} _F_ _IF_ARGS_ 0 1 C 4 \ (u0 :: Double) -> case u0 of { _ALG_ D# (u1 :: Double#) -> case _#_ tanDouble# [] [u1] of { _PRIM_ (u2 :: Double#) -> _!_ D# [] [u2] }; _NO_DEFLT_ } _N_,
- asin = _A_ 1 _U_ 1 _N_ _S_ "U(P)" {_A_ 1 _U_ 2 _N_ _N_ _F_ _IF_ARGS_ 0 1 X 3 \ (u0 :: Double#) -> case _#_ asinDouble# [] [u0] of { _PRIM_ (u1 :: Double#) -> _!_ D# [] [u1] } _N_} _F_ _IF_ARGS_ 0 1 C 4 \ (u0 :: Double) -> case u0 of { _ALG_ D# (u1 :: Double#) -> case _#_ asinDouble# [] [u1] of { _PRIM_ (u2 :: Double#) -> _!_ D# [] [u2] }; _NO_DEFLT_ } _N_,
- acos = _A_ 1 _U_ 1 _N_ _S_ "U(P)" {_A_ 1 _U_ 2 _N_ _N_ _F_ _IF_ARGS_ 0 1 X 3 \ (u0 :: Double#) -> case _#_ acosDouble# [] [u0] of { _PRIM_ (u1 :: Double#) -> _!_ D# [] [u1] } _N_} _F_ _IF_ARGS_ 0 1 C 4 \ (u0 :: Double) -> case u0 of { _ALG_ D# (u1 :: Double#) -> case _#_ acosDouble# [] [u1] of { _PRIM_ (u2 :: Double#) -> _!_ D# [] [u2] }; _NO_DEFLT_ } _N_,
- atan = _A_ 1 _U_ 1 _N_ _S_ "U(P)" {_A_ 1 _U_ 2 _N_ _N_ _F_ _IF_ARGS_ 0 1 X 3 \ (u0 :: Double#) -> case _#_ atanDouble# [] [u0] of { _PRIM_ (u1 :: Double#) -> _!_ D# [] [u1] } _N_} _F_ _IF_ARGS_ 0 1 C 4 \ (u0 :: Double) -> case u0 of { _ALG_ D# (u1 :: Double#) -> case _#_ atanDouble# [] [u1] of { _PRIM_ (u2 :: Double#) -> _!_ D# [] [u2] }; _NO_DEFLT_ } _N_,
- sinh = _A_ 1 _U_ 1 _N_ _S_ "U(P)" {_A_ 1 _U_ 2 _N_ _N_ _F_ _IF_ARGS_ 0 1 X 3 \ (u0 :: Double#) -> case _#_ sinhDouble# [] [u0] of { _PRIM_ (u1 :: Double#) -> _!_ D# [] [u1] } _N_} _F_ _IF_ARGS_ 0 1 C 4 \ (u0 :: Double) -> case u0 of { _ALG_ D# (u1 :: Double#) -> case _#_ sinhDouble# [] [u1] of { _PRIM_ (u2 :: Double#) -> _!_ D# [] [u2] }; _NO_DEFLT_ } _N_,
- cosh = _A_ 1 _U_ 1 _N_ _S_ "U(P)" {_A_ 1 _U_ 2 _N_ _N_ _F_ _IF_ARGS_ 0 1 X 3 \ (u0 :: Double#) -> case _#_ coshDouble# [] [u0] of { _PRIM_ (u1 :: Double#) -> _!_ D# [] [u1] } _N_} _F_ _IF_ARGS_ 0 1 C 4 \ (u0 :: Double) -> case u0 of { _ALG_ D# (u1 :: Double#) -> case _#_ coshDouble# [] [u1] of { _PRIM_ (u2 :: Double#) -> _!_ D# [] [u2] }; _NO_DEFLT_ } _N_,
- tanh = _A_ 1 _U_ 1 _N_ _S_ "U(P)" {_A_ 1 _U_ 2 _N_ _N_ _F_ _IF_ARGS_ 0 1 X 3 \ (u0 :: Double#) -> case _#_ tanhDouble# [] [u0] of { _PRIM_ (u1 :: Double#) -> _!_ D# [] [u1] } _N_} _F_ _IF_ARGS_ 0 1 C 4 \ (u0 :: Double) -> case u0 of { _ALG_ D# (u1 :: Double#) -> case _#_ tanhDouble# [] [u1] of { _PRIM_ (u2 :: Double#) -> _!_ D# [] [u2] }; _NO_DEFLT_ } _N_,
- asinh = _A_ 1 _U_ 1 _N_ _S_ "U(P)" {_A_ 1 _U_ 2 _N_ _N_ _N_ _N_} _N_ _N_,
- acosh = _A_ 1 _U_ 1 _N_ _S_ "U(P)" {_A_ 1 _U_ 2 _N_ _N_ _N_ _N_} _N_ _N_,
- atanh = _A_ 1 _U_ 1 _N_ _S_ "U(P)" {_A_ 1 _U_ 2 _N_ _N_ _N_ _N_} _N_ _N_ #-}
+ pi = { _A_ 0 _N_ _N_ _N_ _F_ _IF_ARGS_ 0 0 X 2 _!_ D# [] [3.1415926535897931##] _N_ },
+ exp = { _A_ 1 _U_ 1 _N_ _S_ "U(P)" {_A_ 1 _U_ 2 _N_ _N_ _F_ _IF_ARGS_ 0 1 X 3 \ (u0 :: Double#) -> case _#_ expDouble# [] [u0] of { _PRIM_ (u1 :: Double#) -> _!_ D# [] [u1] } _N_} _F_ _IF_ARGS_ 0 1 C 4 \ (u0 :: Double) -> case u0 of { _ALG_ D# (u1 :: Double#) -> case _#_ expDouble# [] [u1] of { _PRIM_ (u2 :: Double#) -> _!_ D# [] [u2] }; _NO_DEFLT_ } _N_ },
+ log = { _A_ 1 _U_ 1 _N_ _S_ "U(P)" {_A_ 1 _U_ 2 _N_ _N_ _F_ _IF_ARGS_ 0 1 X 3 \ (u0 :: Double#) -> case _#_ logDouble# [] [u0] of { _PRIM_ (u1 :: Double#) -> _!_ D# [] [u1] } _N_} _F_ _IF_ARGS_ 0 1 C 4 \ (u0 :: Double) -> case u0 of { _ALG_ D# (u1 :: Double#) -> case _#_ logDouble# [] [u1] of { _PRIM_ (u2 :: Double#) -> _!_ D# [] [u2] }; _NO_DEFLT_ } _N_ },
+ sqrt = { _A_ 1 _U_ 1 _N_ _S_ "U(P)" {_A_ 1 _U_ 2 _N_ _N_ _F_ _IF_ARGS_ 0 1 X 3 \ (u0 :: Double#) -> case _#_ sqrtDouble# [] [u0] of { _PRIM_ (u1 :: Double#) -> _!_ D# [] [u1] } _N_} _F_ _IF_ARGS_ 0 1 C 4 \ (u0 :: Double) -> case u0 of { _ALG_ D# (u1 :: Double#) -> case _#_ sqrtDouble# [] [u1] of { _PRIM_ (u2 :: Double#) -> _!_ D# [] [u2] }; _NO_DEFLT_ } _N_ },
+ (**) = { _A_ 2 _U_ 11 _N_ _S_ "U(P)U(P)" {_A_ 2 _U_ 22 _N_ _N_ _F_ _IF_ARGS_ 0 2 XX 3 \ (u0 :: Double#) (u1 :: Double#) -> case _#_ powerDouble# [] [u0, u1] of { _PRIM_ (u2 :: Double#) -> _!_ D# [] [u2] } _N_} _F_ _IF_ARGS_ 0 2 CC 5 \ (u0 :: Double) (u1 :: Double) -> case u0 of { _ALG_ D# (u2 :: Double#) -> case u1 of { _ALG_ D# (u3 :: Double#) -> case _#_ powerDouble# [] [u2, u3] of { _PRIM_ (u4 :: Double#) -> _!_ D# [] [u4] }; _NO_DEFLT_ }; _NO_DEFLT_ } _N_ },
+ logBase = { _A_ 2 _U_ 11 _N_ _S_ "U(P)U(P)" {_A_ 2 _U_ 22 _N_ _N_ _F_ _IF_ARGS_ 0 2 XX 5 \ (u0 :: Double#) (u1 :: Double#) -> case _#_ logDouble# [] [u1] of { _PRIM_ (u2 :: Double#) -> case _#_ logDouble# [] [u0] of { _PRIM_ (u3 :: Double#) -> case _#_ divideDouble# [] [u2, u3] of { _PRIM_ (u4 :: Double#) -> _!_ D# [] [u4] } } } _N_} _F_ _IF_ARGS_ 0 2 CC 7 \ (u0 :: Double) (u1 :: Double) -> case u1 of { _ALG_ D# (u2 :: Double#) -> case _#_ logDouble# [] [u2] of { _PRIM_ (u3 :: Double#) -> case u0 of { _ALG_ D# (u4 :: Double#) -> case _#_ logDouble# [] [u4] of { _PRIM_ (u5 :: Double#) -> case _#_ divideDouble# [] [u3, u5] of { _PRIM_ (u6 :: Double#) -> _!_ D# [] [u6] } }; _NO_DEFLT_ } }; _NO_DEFLT_ } _N_ },
+ sin = { _A_ 1 _U_ 1 _N_ _S_ "U(P)" {_A_ 1 _U_ 2 _N_ _N_ _F_ _IF_ARGS_ 0 1 X 3 \ (u0 :: Double#) -> case _#_ sinDouble# [] [u0] of { _PRIM_ (u1 :: Double#) -> _!_ D# [] [u1] } _N_} _F_ _IF_ARGS_ 0 1 C 4 \ (u0 :: Double) -> case u0 of { _ALG_ D# (u1 :: Double#) -> case _#_ sinDouble# [] [u1] of { _PRIM_ (u2 :: Double#) -> _!_ D# [] [u2] }; _NO_DEFLT_ } _N_ },
+ cos = { _A_ 1 _U_ 1 _N_ _S_ "U(P)" {_A_ 1 _U_ 2 _N_ _N_ _F_ _IF_ARGS_ 0 1 X 3 \ (u0 :: Double#) -> case _#_ cosDouble# [] [u0] of { _PRIM_ (u1 :: Double#) -> _!_ D# [] [u1] } _N_} _F_ _IF_ARGS_ 0 1 C 4 \ (u0 :: Double) -> case u0 of { _ALG_ D# (u1 :: Double#) -> case _#_ cosDouble# [] [u1] of { _PRIM_ (u2 :: Double#) -> _!_ D# [] [u2] }; _NO_DEFLT_ } _N_ },
+ tan = { _A_ 1 _U_ 1 _N_ _S_ "U(P)" {_A_ 1 _U_ 2 _N_ _N_ _F_ _IF_ARGS_ 0 1 X 3 \ (u0 :: Double#) -> case _#_ tanDouble# [] [u0] of { _PRIM_ (u1 :: Double#) -> _!_ D# [] [u1] } _N_} _F_ _IF_ARGS_ 0 1 C 4 \ (u0 :: Double) -> case u0 of { _ALG_ D# (u1 :: Double#) -> case _#_ tanDouble# [] [u1] of { _PRIM_ (u2 :: Double#) -> _!_ D# [] [u2] }; _NO_DEFLT_ } _N_ },
+ asin = { _A_ 1 _U_ 1 _N_ _S_ "U(P)" {_A_ 1 _U_ 2 _N_ _N_ _F_ _IF_ARGS_ 0 1 X 3 \ (u0 :: Double#) -> case _#_ asinDouble# [] [u0] of { _PRIM_ (u1 :: Double#) -> _!_ D# [] [u1] } _N_} _F_ _IF_ARGS_ 0 1 C 4 \ (u0 :: Double) -> case u0 of { _ALG_ D# (u1 :: Double#) -> case _#_ asinDouble# [] [u1] of { _PRIM_ (u2 :: Double#) -> _!_ D# [] [u2] }; _NO_DEFLT_ } _N_ },
+ acos = { _A_ 1 _U_ 1 _N_ _S_ "U(P)" {_A_ 1 _U_ 2 _N_ _N_ _F_ _IF_ARGS_ 0 1 X 3 \ (u0 :: Double#) -> case _#_ acosDouble# [] [u0] of { _PRIM_ (u1 :: Double#) -> _!_ D# [] [u1] } _N_} _F_ _IF_ARGS_ 0 1 C 4 \ (u0 :: Double) -> case u0 of { _ALG_ D# (u1 :: Double#) -> case _#_ acosDouble# [] [u1] of { _PRIM_ (u2 :: Double#) -> _!_ D# [] [u2] }; _NO_DEFLT_ } _N_ },
+ atan = { _A_ 1 _U_ 1 _N_ _S_ "U(P)" {_A_ 1 _U_ 2 _N_ _N_ _F_ _IF_ARGS_ 0 1 X 3 \ (u0 :: Double#) -> case _#_ atanDouble# [] [u0] of { _PRIM_ (u1 :: Double#) -> _!_ D# [] [u1] } _N_} _F_ _IF_ARGS_ 0 1 C 4 \ (u0 :: Double) -> case u0 of { _ALG_ D# (u1 :: Double#) -> case _#_ atanDouble# [] [u1] of { _PRIM_ (u2 :: Double#) -> _!_ D# [] [u2] }; _NO_DEFLT_ } _N_ },
+ sinh = { _A_ 1 _U_ 1 _N_ _S_ "U(P)" {_A_ 1 _U_ 2 _N_ _N_ _F_ _IF_ARGS_ 0 1 X 3 \ (u0 :: Double#) -> case _#_ sinhDouble# [] [u0] of { _PRIM_ (u1 :: Double#) -> _!_ D# [] [u1] } _N_} _F_ _IF_ARGS_ 0 1 C 4 \ (u0 :: Double) -> case u0 of { _ALG_ D# (u1 :: Double#) -> case _#_ sinhDouble# [] [u1] of { _PRIM_ (u2 :: Double#) -> _!_ D# [] [u2] }; _NO_DEFLT_ } _N_ },
+ cosh = { _A_ 1 _U_ 1 _N_ _S_ "U(P)" {_A_ 1 _U_ 2 _N_ _N_ _F_ _IF_ARGS_ 0 1 X 3 \ (u0 :: Double#) -> case _#_ coshDouble# [] [u0] of { _PRIM_ (u1 :: Double#) -> _!_ D# [] [u1] } _N_} _F_ _IF_ARGS_ 0 1 C 4 \ (u0 :: Double) -> case u0 of { _ALG_ D# (u1 :: Double#) -> case _#_ coshDouble# [] [u1] of { _PRIM_ (u2 :: Double#) -> _!_ D# [] [u2] }; _NO_DEFLT_ } _N_ },
+ tanh = { _A_ 1 _U_ 1 _N_ _S_ "U(P)" {_A_ 1 _U_ 2 _N_ _N_ _F_ _IF_ARGS_ 0 1 X 3 \ (u0 :: Double#) -> case _#_ tanhDouble# [] [u0] of { _PRIM_ (u1 :: Double#) -> _!_ D# [] [u1] } _N_} _F_ _IF_ARGS_ 0 1 C 4 \ (u0 :: Double) -> case u0 of { _ALG_ D# (u1 :: Double#) -> case _#_ tanhDouble# [] [u1] of { _PRIM_ (u2 :: Double#) -> _!_ D# [] [u2] }; _NO_DEFLT_ } _N_ },
+ asinh = { _A_ 1 _U_ 1 _N_ _S_ "U(P)" {_A_ 1 _U_ 2 _N_ _N_ _N_ _N_} _N_ _N_ },
+ acosh = { _A_ 1 _U_ 1 _N_ _S_ "U(P)" {_A_ 1 _U_ 2 _N_ _N_ _N_ _N_} _N_ _N_ },
+ atanh = { _A_ 1 _U_ 1 _N_ _S_ "U(P)" {_A_ 1 _U_ 2 _N_ _N_ _N_ _N_} _N_ _N_ } #-}
instance Floating Float
{-# GHC_PRAGMA _M_ PreludeCore {-dfun-} _A_ 0 _N_ _N_ _N_ _F_ _IF_ARGS_ 0 0 X 20 _!_ _TUP_19 [{{Fractional Float}}, Float, (Float -> Float), (Float -> Float), (Float -> Float), (Float -> Float -> Float), (Float -> Float -> Float), (Float -> Float), (Float -> Float), (Float -> Float), (Float -> Float), (Float -> Float), (Float -> Float), (Float -> Float), (Float -> Float), (Float -> Float), (Float -> Float), (Float -> Float), (Float -> Float)] [_DFUN_ Fractional (Float), _CONSTM_ Floating pi (Float), _CONSTM_ Floating exp (Float), _CONSTM_ Floating log (Float), _CONSTM_ Floating sqrt (Float), _CONSTM_ Floating (**) (Float), _CONSTM_ Floating logBase (Float), _CONSTM_ Floating sin (Float), _CONSTM_ Floating cos (Float), _CONSTM_ Floating tan (Float), _CONSTM_ Floating asin (Float), _CONSTM_ Floating acos (Float), _CONSTM_ Floating atan (Float), _CONSTM_ Floating sinh (Float), _CONSTM_ Floating cosh (Float), _CONSTM_ Floating tanh (Float), _CONSTM_ Floating asinh (Float), _CONSTM_ Floating acosh (Float), _CONSTM_ Floating atanh (Float)] _N_
- pi = _A_ 0 _N_ _N_ _N_ _F_ _IF_ARGS_ 0 0 X 2 _!_ F# [] [3.1415926535897931#] _N_,
- exp = _A_ 1 _U_ 1 _N_ _S_ "U(P)" {_A_ 1 _U_ 2 _N_ _N_ _F_ _IF_ARGS_ 0 1 X 3 \ (u0 :: Float#) -> case _#_ expFloat# [] [u0] of { _PRIM_ (u1 :: Float#) -> _!_ F# [] [u1] } _N_} _F_ _IF_ARGS_ 0 1 C 4 \ (u0 :: Float) -> case u0 of { _ALG_ F# (u1 :: Float#) -> case _#_ expFloat# [] [u1] of { _PRIM_ (u2 :: Float#) -> _!_ F# [] [u2] }; _NO_DEFLT_ } _N_,
- log = _A_ 1 _U_ 1 _N_ _S_ "U(P)" {_A_ 1 _U_ 2 _N_ _N_ _F_ _IF_ARGS_ 0 1 X 3 \ (u0 :: Float#) -> case _#_ logFloat# [] [u0] of { _PRIM_ (u1 :: Float#) -> _!_ F# [] [u1] } _N_} _F_ _IF_ARGS_ 0 1 C 4 \ (u0 :: Float) -> case u0 of { _ALG_ F# (u1 :: Float#) -> case _#_ logFloat# [] [u1] of { _PRIM_ (u2 :: Float#) -> _!_ F# [] [u2] }; _NO_DEFLT_ } _N_,
- sqrt = _A_ 1 _U_ 1 _N_ _S_ "U(P)" {_A_ 1 _U_ 2 _N_ _N_ _F_ _IF_ARGS_ 0 1 X 3 \ (u0 :: Float#) -> case _#_ sqrtFloat# [] [u0] of { _PRIM_ (u1 :: Float#) -> _!_ F# [] [u1] } _N_} _F_ _IF_ARGS_ 0 1 C 4 \ (u0 :: Float) -> case u0 of { _ALG_ F# (u1 :: Float#) -> case _#_ sqrtFloat# [] [u1] of { _PRIM_ (u2 :: Float#) -> _!_ F# [] [u2] }; _NO_DEFLT_ } _N_,
- (**) = _A_ 2 _U_ 11 _N_ _S_ "U(P)U(P)" {_A_ 2 _U_ 22 _N_ _N_ _F_ _IF_ARGS_ 0 2 XX 3 \ (u0 :: Float#) (u1 :: Float#) -> case _#_ powerFloat# [] [u0, u1] of { _PRIM_ (u2 :: Float#) -> _!_ F# [] [u2] } _N_} _F_ _IF_ARGS_ 0 2 CC 5 \ (u0 :: Float) (u1 :: Float) -> case u0 of { _ALG_ F# (u2 :: Float#) -> case u1 of { _ALG_ F# (u3 :: Float#) -> case _#_ powerFloat# [] [u2, u3] of { _PRIM_ (u4 :: Float#) -> _!_ F# [] [u4] }; _NO_DEFLT_ }; _NO_DEFLT_ } _N_,
- logBase = _A_ 2 _U_ 22 _N_ _N_ _N_ _N_,
- sin = _A_ 1 _U_ 1 _N_ _S_ "U(P)" {_A_ 1 _U_ 2 _N_ _N_ _F_ _IF_ARGS_ 0 1 X 3 \ (u0 :: Float#) -> case _#_ sinFloat# [] [u0] of { _PRIM_ (u1 :: Float#) -> _!_ F# [] [u1] } _N_} _F_ _IF_ARGS_ 0 1 C 4 \ (u0 :: Float) -> case u0 of { _ALG_ F# (u1 :: Float#) -> case _#_ sinFloat# [] [u1] of { _PRIM_ (u2 :: Float#) -> _!_ F# [] [u2] }; _NO_DEFLT_ } _N_,
- cos = _A_ 1 _U_ 1 _N_ _S_ "U(P)" {_A_ 1 _U_ 2 _N_ _N_ _F_ _IF_ARGS_ 0 1 X 3 \ (u0 :: Float#) -> case _#_ cosFloat# [] [u0] of { _PRIM_ (u1 :: Float#) -> _!_ F# [] [u1] } _N_} _F_ _IF_ARGS_ 0 1 C 4 \ (u0 :: Float) -> case u0 of { _ALG_ F# (u1 :: Float#) -> case _#_ cosFloat# [] [u1] of { _PRIM_ (u2 :: Float#) -> _!_ F# [] [u2] }; _NO_DEFLT_ } _N_,
- tan = _A_ 1 _U_ 1 _N_ _S_ "U(P)" {_A_ 1 _U_ 2 _N_ _N_ _F_ _IF_ARGS_ 0 1 X 3 \ (u0 :: Float#) -> case _#_ tanFloat# [] [u0] of { _PRIM_ (u1 :: Float#) -> _!_ F# [] [u1] } _N_} _F_ _IF_ARGS_ 0 1 C 4 \ (u0 :: Float) -> case u0 of { _ALG_ F# (u1 :: Float#) -> case _#_ tanFloat# [] [u1] of { _PRIM_ (u2 :: Float#) -> _!_ F# [] [u2] }; _NO_DEFLT_ } _N_,
- asin = _A_ 1 _U_ 1 _N_ _S_ "U(P)" {_A_ 1 _U_ 2 _N_ _N_ _F_ _IF_ARGS_ 0 1 X 3 \ (u0 :: Float#) -> case _#_ asinFloat# [] [u0] of { _PRIM_ (u1 :: Float#) -> _!_ F# [] [u1] } _N_} _F_ _IF_ARGS_ 0 1 C 4 \ (u0 :: Float) -> case u0 of { _ALG_ F# (u1 :: Float#) -> case _#_ asinFloat# [] [u1] of { _PRIM_ (u2 :: Float#) -> _!_ F# [] [u2] }; _NO_DEFLT_ } _N_,
- acos = _A_ 1 _U_ 1 _N_ _S_ "U(P)" {_A_ 1 _U_ 2 _N_ _N_ _F_ _IF_ARGS_ 0 1 X 3 \ (u0 :: Float#) -> case _#_ acosFloat# [] [u0] of { _PRIM_ (u1 :: Float#) -> _!_ F# [] [u1] } _N_} _F_ _IF_ARGS_ 0 1 C 4 \ (u0 :: Float) -> case u0 of { _ALG_ F# (u1 :: Float#) -> case _#_ acosFloat# [] [u1] of { _PRIM_ (u2 :: Float#) -> _!_ F# [] [u2] }; _NO_DEFLT_ } _N_,
- atan = _A_ 1 _U_ 1 _N_ _S_ "U(P)" {_A_ 1 _U_ 2 _N_ _N_ _F_ _IF_ARGS_ 0 1 X 3 \ (u0 :: Float#) -> case _#_ atanFloat# [] [u0] of { _PRIM_ (u1 :: Float#) -> _!_ F# [] [u1] } _N_} _F_ _IF_ARGS_ 0 1 C 4 \ (u0 :: Float) -> case u0 of { _ALG_ F# (u1 :: Float#) -> case _#_ atanFloat# [] [u1] of { _PRIM_ (u2 :: Float#) -> _!_ F# [] [u2] }; _NO_DEFLT_ } _N_,
- sinh = _A_ 1 _U_ 1 _N_ _S_ "U(P)" {_A_ 1 _U_ 2 _N_ _N_ _F_ _IF_ARGS_ 0 1 X 3 \ (u0 :: Float#) -> case _#_ sinhFloat# [] [u0] of { _PRIM_ (u1 :: Float#) -> _!_ F# [] [u1] } _N_} _F_ _IF_ARGS_ 0 1 C 4 \ (u0 :: Float) -> case u0 of { _ALG_ F# (u1 :: Float#) -> case _#_ sinhFloat# [] [u1] of { _PRIM_ (u2 :: Float#) -> _!_ F# [] [u2] }; _NO_DEFLT_ } _N_,
- cosh = _A_ 1 _U_ 1 _N_ _S_ "U(P)" {_A_ 1 _U_ 2 _N_ _N_ _F_ _IF_ARGS_ 0 1 X 3 \ (u0 :: Float#) -> case _#_ coshFloat# [] [u0] of { _PRIM_ (u1 :: Float#) -> _!_ F# [] [u1] } _N_} _F_ _IF_ARGS_ 0 1 C 4 \ (u0 :: Float) -> case u0 of { _ALG_ F# (u1 :: Float#) -> case _#_ coshFloat# [] [u1] of { _PRIM_ (u2 :: Float#) -> _!_ F# [] [u2] }; _NO_DEFLT_ } _N_,
- tanh = _A_ 1 _U_ 1 _N_ _S_ "U(P)" {_A_ 1 _U_ 2 _N_ _N_ _F_ _IF_ARGS_ 0 1 X 3 \ (u0 :: Float#) -> case _#_ tanhFloat# [] [u0] of { _PRIM_ (u1 :: Float#) -> _!_ F# [] [u1] } _N_} _F_ _IF_ARGS_ 0 1 C 4 \ (u0 :: Float) -> case u0 of { _ALG_ F# (u1 :: Float#) -> case _#_ tanhFloat# [] [u1] of { _PRIM_ (u2 :: Float#) -> _!_ F# [] [u2] }; _NO_DEFLT_ } _N_,
- asinh = _A_ 1 _U_ 1 _N_ _S_ "U(P)" {_A_ 1 _U_ 2 _N_ _N_ _N_ _N_} _N_ _N_,
- acosh = _A_ 1 _U_ 1 _N_ _S_ "U(P)" {_A_ 1 _U_ 2 _N_ _N_ _N_ _N_} _N_ _N_,
- atanh = _A_ 1 _U_ 1 _N_ _S_ "U(P)" {_A_ 1 _U_ 2 _N_ _N_ _N_ _N_} _N_ _N_ #-}
+ pi = { _A_ 0 _N_ _N_ _N_ _F_ _IF_ARGS_ 0 0 X 2 _!_ F# [] [3.1415926535897931#] _N_ },
+ exp = { _A_ 1 _U_ 1 _N_ _S_ "U(P)" {_A_ 1 _U_ 2 _N_ _N_ _F_ _IF_ARGS_ 0 1 X 3 \ (u0 :: Float#) -> case _#_ expFloat# [] [u0] of { _PRIM_ (u1 :: Float#) -> _!_ F# [] [u1] } _N_} _F_ _IF_ARGS_ 0 1 C 4 \ (u0 :: Float) -> case u0 of { _ALG_ F# (u1 :: Float#) -> case _#_ expFloat# [] [u1] of { _PRIM_ (u2 :: Float#) -> _!_ F# [] [u2] }; _NO_DEFLT_ } _N_ },
+ log = { _A_ 1 _U_ 1 _N_ _S_ "U(P)" {_A_ 1 _U_ 2 _N_ _N_ _F_ _IF_ARGS_ 0 1 X 3 \ (u0 :: Float#) -> case _#_ logFloat# [] [u0] of { _PRIM_ (u1 :: Float#) -> _!_ F# [] [u1] } _N_} _F_ _IF_ARGS_ 0 1 C 4 \ (u0 :: Float) -> case u0 of { _ALG_ F# (u1 :: Float#) -> case _#_ logFloat# [] [u1] of { _PRIM_ (u2 :: Float#) -> _!_ F# [] [u2] }; _NO_DEFLT_ } _N_ },
+ sqrt = { _A_ 1 _U_ 1 _N_ _S_ "U(P)" {_A_ 1 _U_ 2 _N_ _N_ _F_ _IF_ARGS_ 0 1 X 3 \ (u0 :: Float#) -> case _#_ sqrtFloat# [] [u0] of { _PRIM_ (u1 :: Float#) -> _!_ F# [] [u1] } _N_} _F_ _IF_ARGS_ 0 1 C 4 \ (u0 :: Float) -> case u0 of { _ALG_ F# (u1 :: Float#) -> case _#_ sqrtFloat# [] [u1] of { _PRIM_ (u2 :: Float#) -> _!_ F# [] [u2] }; _NO_DEFLT_ } _N_ },
+ (**) = { _A_ 2 _U_ 11 _N_ _S_ "U(P)U(P)" {_A_ 2 _U_ 22 _N_ _N_ _F_ _IF_ARGS_ 0 2 XX 3 \ (u0 :: Float#) (u1 :: Float#) -> case _#_ powerFloat# [] [u0, u1] of { _PRIM_ (u2 :: Float#) -> _!_ F# [] [u2] } _N_} _F_ _IF_ARGS_ 0 2 CC 5 \ (u0 :: Float) (u1 :: Float) -> case u0 of { _ALG_ F# (u2 :: Float#) -> case u1 of { _ALG_ F# (u3 :: Float#) -> case _#_ powerFloat# [] [u2, u3] of { _PRIM_ (u4 :: Float#) -> _!_ F# [] [u4] }; _NO_DEFLT_ }; _NO_DEFLT_ } _N_ },
+ logBase = { _A_ 2 _U_ 11 _N_ _S_ "U(P)U(P)" {_A_ 2 _U_ 22 _N_ _N_ _F_ _IF_ARGS_ 0 2 XX 5 \ (u0 :: Float#) (u1 :: Float#) -> case _#_ logFloat# [] [u1] of { _PRIM_ (u2 :: Float#) -> case _#_ logFloat# [] [u0] of { _PRIM_ (u3 :: Float#) -> case _#_ divideFloat# [] [u2, u3] of { _PRIM_ (u4 :: Float#) -> _!_ F# [] [u4] } } } _N_} _F_ _IF_ARGS_ 0 2 CC 7 \ (u0 :: Float) (u1 :: Float) -> case u1 of { _ALG_ F# (u2 :: Float#) -> case _#_ logFloat# [] [u2] of { _PRIM_ (u3 :: Float#) -> case u0 of { _ALG_ F# (u4 :: Float#) -> case _#_ logFloat# [] [u4] of { _PRIM_ (u5 :: Float#) -> case _#_ divideFloat# [] [u3, u5] of { _PRIM_ (u6 :: Float#) -> _!_ F# [] [u6] } }; _NO_DEFLT_ } }; _NO_DEFLT_ } _N_ },
+ sin = { _A_ 1 _U_ 1 _N_ _S_ "U(P)" {_A_ 1 _U_ 2 _N_ _N_ _F_ _IF_ARGS_ 0 1 X 3 \ (u0 :: Float#) -> case _#_ sinFloat# [] [u0] of { _PRIM_ (u1 :: Float#) -> _!_ F# [] [u1] } _N_} _F_ _IF_ARGS_ 0 1 C 4 \ (u0 :: Float) -> case u0 of { _ALG_ F# (u1 :: Float#) -> case _#_ sinFloat# [] [u1] of { _PRIM_ (u2 :: Float#) -> _!_ F# [] [u2] }; _NO_DEFLT_ } _N_ },
+ cos = { _A_ 1 _U_ 1 _N_ _S_ "U(P)" {_A_ 1 _U_ 2 _N_ _N_ _F_ _IF_ARGS_ 0 1 X 3 \ (u0 :: Float#) -> case _#_ cosFloat# [] [u0] of { _PRIM_ (u1 :: Float#) -> _!_ F# [] [u1] } _N_} _F_ _IF_ARGS_ 0 1 C 4 \ (u0 :: Float) -> case u0 of { _ALG_ F# (u1 :: Float#) -> case _#_ cosFloat# [] [u1] of { _PRIM_ (u2 :: Float#) -> _!_ F# [] [u2] }; _NO_DEFLT_ } _N_ },
+ tan = { _A_ 1 _U_ 1 _N_ _S_ "U(P)" {_A_ 1 _U_ 2 _N_ _N_ _F_ _IF_ARGS_ 0 1 X 3 \ (u0 :: Float#) -> case _#_ tanFloat# [] [u0] of { _PRIM_ (u1 :: Float#) -> _!_ F# [] [u1] } _N_} _F_ _IF_ARGS_ 0 1 C 4 \ (u0 :: Float) -> case u0 of { _ALG_ F# (u1 :: Float#) -> case _#_ tanFloat# [] [u1] of { _PRIM_ (u2 :: Float#) -> _!_ F# [] [u2] }; _NO_DEFLT_ } _N_ },
+ asin = { _A_ 1 _U_ 1 _N_ _S_ "U(P)" {_A_ 1 _U_ 2 _N_ _N_ _F_ _IF_ARGS_ 0 1 X 3 \ (u0 :: Float#) -> case _#_ asinFloat# [] [u0] of { _PRIM_ (u1 :: Float#) -> _!_ F# [] [u1] } _N_} _F_ _IF_ARGS_ 0 1 C 4 \ (u0 :: Float) -> case u0 of { _ALG_ F# (u1 :: Float#) -> case _#_ asinFloat# [] [u1] of { _PRIM_ (u2 :: Float#) -> _!_ F# [] [u2] }; _NO_DEFLT_ } _N_ },
+ acos = { _A_ 1 _U_ 1 _N_ _S_ "U(P)" {_A_ 1 _U_ 2 _N_ _N_ _F_ _IF_ARGS_ 0 1 X 3 \ (u0 :: Float#) -> case _#_ acosFloat# [] [u0] of { _PRIM_ (u1 :: Float#) -> _!_ F# [] [u1] } _N_} _F_ _IF_ARGS_ 0 1 C 4 \ (u0 :: Float) -> case u0 of { _ALG_ F# (u1 :: Float#) -> case _#_ acosFloat# [] [u1] of { _PRIM_ (u2 :: Float#) -> _!_ F# [] [u2] }; _NO_DEFLT_ } _N_ },
+ atan = { _A_ 1 _U_ 1 _N_ _S_ "U(P)" {_A_ 1 _U_ 2 _N_ _N_ _F_ _IF_ARGS_ 0 1 X 3 \ (u0 :: Float#) -> case _#_ atanFloat# [] [u0] of { _PRIM_ (u1 :: Float#) -> _!_ F# [] [u1] } _N_} _F_ _IF_ARGS_ 0 1 C 4 \ (u0 :: Float) -> case u0 of { _ALG_ F# (u1 :: Float#) -> case _#_ atanFloat# [] [u1] of { _PRIM_ (u2 :: Float#) -> _!_ F# [] [u2] }; _NO_DEFLT_ } _N_ },
+ sinh = { _A_ 1 _U_ 1 _N_ _S_ "U(P)" {_A_ 1 _U_ 2 _N_ _N_ _F_ _IF_ARGS_ 0 1 X 3 \ (u0 :: Float#) -> case _#_ sinhFloat# [] [u0] of { _PRIM_ (u1 :: Float#) -> _!_ F# [] [u1] } _N_} _F_ _IF_ARGS_ 0 1 C 4 \ (u0 :: Float) -> case u0 of { _ALG_ F# (u1 :: Float#) -> case _#_ sinhFloat# [] [u1] of { _PRIM_ (u2 :: Float#) -> _!_ F# [] [u2] }; _NO_DEFLT_ } _N_ },
+ cosh = { _A_ 1 _U_ 1 _N_ _S_ "U(P)" {_A_ 1 _U_ 2 _N_ _N_ _F_ _IF_ARGS_ 0 1 X 3 \ (u0 :: Float#) -> case _#_ coshFloat# [] [u0] of { _PRIM_ (u1 :: Float#) -> _!_ F# [] [u1] } _N_} _F_ _IF_ARGS_ 0 1 C 4 \ (u0 :: Float) -> case u0 of { _ALG_ F# (u1 :: Float#) -> case _#_ coshFloat# [] [u1] of { _PRIM_ (u2 :: Float#) -> _!_ F# [] [u2] }; _NO_DEFLT_ } _N_ },
+ tanh = { _A_ 1 _U_ 1 _N_ _S_ "U(P)" {_A_ 1 _U_ 2 _N_ _N_ _F_ _IF_ARGS_ 0 1 X 3 \ (u0 :: Float#) -> case _#_ tanhFloat# [] [u0] of { _PRIM_ (u1 :: Float#) -> _!_ F# [] [u1] } _N_} _F_ _IF_ARGS_ 0 1 C 4 \ (u0 :: Float) -> case u0 of { _ALG_ F# (u1 :: Float#) -> case _#_ tanhFloat# [] [u1] of { _PRIM_ (u2 :: Float#) -> _!_ F# [] [u2] }; _NO_DEFLT_ } _N_ },
+ asinh = { _A_ 1 _U_ 1 _N_ _S_ "U(P)" {_A_ 1 _U_ 2 _N_ _N_ _N_ _N_} _N_ _N_ },
+ acosh = { _A_ 1 _U_ 1 _N_ _S_ "U(P)" {_A_ 1 _U_ 2 _N_ _N_ _N_ _N_} _N_ _N_ },
+ atanh = { _A_ 1 _U_ 1 _N_ _S_ "U(P)" {_A_ 1 _U_ 2 _N_ _N_ _N_ _N_} _N_ _N_ } #-}
instance RealFloat a => Fractional (Complex a)
{-# GHC_PRAGMA _M_ PreludeComplex {-dfun-} _A_ 2 _U_ 22 _N_ _N_ _N_ _N_ #-}
instance Fractional (Complex Double)
{-# GHC_PRAGMA _M_ PreludeComplex {-dfun-} _A_ 0 _N_ _N_ _N_ _F_ _IF_ARGS_ 0 0 X 5 _!_ _TUP_4 [{{Num (Complex Double)}}, (Complex Double -> Complex Double -> Complex Double), (Complex Double -> Complex Double), (Ratio Integer -> Complex Double)] [_DFUN_ Num (Complex Double), _CONSTM_ Fractional (/) (Complex Double), _CONSTM_ Fractional recip (Complex Double), _CONSTM_ Fractional fromRational (Complex Double)] _N_
- (/) = _A_ 2 _U_ 11 _N_ _S_ "U(LL)U(LL)" {_A_ 4 _U_ 2222 _N_ _N_ _N_ _N_} _N_ _N_,
- recip = _A_ 1 _U_ 1 _N_ _S_ "U(LL)" {_A_ 2 _U_ 22 _N_ _N_ _N_ _N_} _N_ _N_,
- fromRational = _A_ 1 _U_ 2 _N_ _N_ _N_ _N_ #-}
+ (/) = { _A_ 2 _U_ 11 _N_ _S_ "U(LL)U(LL)" {_A_ 4 _U_ 2222 _N_ _N_ _N_ _N_} _N_ _N_ },
+ recip = { _A_ 1 _U_ 1 _N_ _S_ "U(LL)" {_A_ 2 _U_ 22 _N_ _N_ _N_ _N_} _F_ _IF_ARGS_ 0 1 X 3 \ (u0 :: Complex Double) -> _APP_ _CONSTM_ Fractional (/) (Complex Double) [ _SPEC_ _ORIG_ PreludeCore __i1 [ (Complex Double) ], u0 ] _N_ },
+ fromRational = { _A_ 1 _U_ 1 _N_ _N_ _N_ _N_ } #-}
instance Fractional Double
{-# GHC_PRAGMA _M_ PreludeCore {-dfun-} _A_ 0 _N_ _N_ _N_ _F_ _IF_ARGS_ 0 0 X 5 _!_ _TUP_4 [{{Num Double}}, (Double -> Double -> Double), (Double -> Double), (Ratio Integer -> Double)] [_DFUN_ Num (Double), _CONSTM_ Fractional (/) (Double), _CONSTM_ Fractional recip (Double), _CONSTM_ Fractional fromRational (Double)] _N_
- (/) = _A_ 2 _U_ 11 _N_ _S_ "U(P)U(P)" {_A_ 2 _U_ 22 _N_ _N_ _F_ _IF_ARGS_ 0 2 XX 3 \ (u0 :: Double#) (u1 :: Double#) -> case _#_ divideDouble# [] [u0, u1] of { _PRIM_ (u2 :: Double#) -> _!_ D# [] [u2] } _N_} _F_ _IF_ARGS_ 0 2 CC 5 \ (u0 :: Double) (u1 :: Double) -> case u0 of { _ALG_ D# (u2 :: Double#) -> case u1 of { _ALG_ D# (u3 :: Double#) -> case _#_ divideDouble# [] [u2, u3] of { _PRIM_ (u4 :: Double#) -> _!_ D# [] [u4] }; _NO_DEFLT_ }; _NO_DEFLT_ } _N_,
- recip = _A_ 1 _U_ 1 _N_ _S_ "U(P)" {_A_ 1 _U_ 2 _N_ _N_ _F_ _IF_ARGS_ 0 1 X 3 \ (u0 :: Double#) -> case _#_ divideDouble# [] [1.0000000000000000##, u0] of { _PRIM_ (u1 :: Double#) -> _!_ D# [] [u1] } _N_} _F_ _IF_ARGS_ 0 1 C 4 \ (u0 :: Double) -> case u0 of { _ALG_ D# (u1 :: Double#) -> case _#_ divideDouble# [] [1.0000000000000000##, u1] of { _PRIM_ (u2 :: Double#) -> _!_ D# [] [u2] }; _NO_DEFLT_ } _N_,
- fromRational = _A_ 0 _U_ 2 _N_ _N_ _N_ _N_ #-}
+ (/) = { _A_ 2 _U_ 11 _N_ _S_ "U(P)U(P)" {_A_ 2 _U_ 22 _N_ _N_ _F_ _IF_ARGS_ 0 2 XX 3 \ (u0 :: Double#) (u1 :: Double#) -> case _#_ divideDouble# [] [u0, u1] of { _PRIM_ (u2 :: Double#) -> _!_ D# [] [u2] } _N_} _F_ _IF_ARGS_ 0 2 CC 5 \ (u0 :: Double) (u1 :: Double) -> case u0 of { _ALG_ D# (u2 :: Double#) -> case u1 of { _ALG_ D# (u3 :: Double#) -> case _#_ divideDouble# [] [u2, u3] of { _PRIM_ (u4 :: Double#) -> _!_ D# [] [u4] }; _NO_DEFLT_ }; _NO_DEFLT_ } _N_ },
+ recip = { _A_ 1 _U_ 1 _N_ _S_ "U(P)" {_A_ 1 _U_ 2 _N_ _N_ _F_ _IF_ARGS_ 0 1 X 3 \ (u0 :: Double#) -> case _#_ divideDouble# [] [1.0000000000000000##, u0] of { _PRIM_ (u1 :: Double#) -> _!_ D# [] [u1] } _N_} _F_ _IF_ARGS_ 0 1 C 4 \ (u0 :: Double) -> case u0 of { _ALG_ D# (u1 :: Double#) -> case _#_ divideDouble# [] [1.0000000000000000##, u1] of { _PRIM_ (u2 :: Double#) -> _!_ D# [] [u2] }; _NO_DEFLT_ } _N_ },
+ fromRational = { _A_ 1 _U_ 1 _N_ _S_ "U(U(PPP)U(PPP))" {_A_ 4 _U_ 2222 _N_ _N_ _N_ _N_} _N_ _N_ } #-}
instance Fractional Float
{-# GHC_PRAGMA _M_ PreludeCore {-dfun-} _A_ 0 _N_ _N_ _N_ _F_ _IF_ARGS_ 0 0 X 5 _!_ _TUP_4 [{{Num Float}}, (Float -> Float -> Float), (Float -> Float), (Ratio Integer -> Float)] [_DFUN_ Num (Float), _CONSTM_ Fractional (/) (Float), _CONSTM_ Fractional recip (Float), _CONSTM_ Fractional fromRational (Float)] _N_
- (/) = _A_ 2 _U_ 11 _N_ _S_ "U(P)U(P)" {_A_ 2 _U_ 22 _N_ _N_ _F_ _IF_ARGS_ 0 2 XX 3 \ (u0 :: Float#) (u1 :: Float#) -> case _#_ divideFloat# [] [u0, u1] of { _PRIM_ (u2 :: Float#) -> _!_ F# [] [u2] } _N_} _F_ _IF_ARGS_ 0 2 CC 5 \ (u0 :: Float) (u1 :: Float) -> case u0 of { _ALG_ F# (u2 :: Float#) -> case u1 of { _ALG_ F# (u3 :: Float#) -> case _#_ divideFloat# [] [u2, u3] of { _PRIM_ (u4 :: Float#) -> _!_ F# [] [u4] }; _NO_DEFLT_ }; _NO_DEFLT_ } _N_,
- recip = _A_ 0 _U_ 2 _N_ _N_ _N_ _N_,
- fromRational = _A_ 0 _U_ 2 _N_ _N_ _N_ _N_ #-}
+ (/) = { _A_ 2 _U_ 11 _N_ _S_ "U(P)U(P)" {_A_ 2 _U_ 22 _N_ _N_ _F_ _IF_ARGS_ 0 2 XX 3 \ (u0 :: Float#) (u1 :: Float#) -> case _#_ divideFloat# [] [u0, u1] of { _PRIM_ (u2 :: Float#) -> _!_ F# [] [u2] } _N_} _F_ _IF_ARGS_ 0 2 CC 5 \ (u0 :: Float) (u1 :: Float) -> case u0 of { _ALG_ F# (u2 :: Float#) -> case u1 of { _ALG_ F# (u3 :: Float#) -> case _#_ divideFloat# [] [u2, u3] of { _PRIM_ (u4 :: Float#) -> _!_ F# [] [u4] }; _NO_DEFLT_ }; _NO_DEFLT_ } _N_ },
+ recip = { _A_ 1 _U_ 1 _N_ _S_ "U(P)" {_A_ 1 _U_ 2 _N_ _N_ _F_ _IF_ARGS_ 0 1 X 3 \ (u0 :: Float#) -> case _#_ divideFloat# [] [1.0000000000000000#, u0] of { _PRIM_ (u1 :: Float#) -> _!_ F# [] [u1] } _N_} _F_ _IF_ARGS_ 0 1 C 4 \ (u0 :: Float) -> case u0 of { _ALG_ F# (u1 :: Float#) -> case _#_ divideFloat# [] [1.0000000000000000#, u1] of { _PRIM_ (u2 :: Float#) -> _!_ F# [] [u2] }; _NO_DEFLT_ } _N_ },
+ fromRational = { _A_ 1 _U_ 2 _N_ _N_ _N_ _N_ } #-}
instance Integral a => Fractional (Ratio a)
{-# GHC_PRAGMA _M_ PreludeRatio {-dfun-} _A_ 2 _U_ 22 _N_ _N_ _N_ _N_ #-}
instance Fractional (Ratio Integer)
{-# GHC_PRAGMA _M_ PreludeRatio {-dfun-} _A_ 0 _N_ _N_ _N_ _F_ _IF_ARGS_ 0 0 X 5 _!_ _TUP_4 [{{Num (Ratio Integer)}}, (Ratio Integer -> Ratio Integer -> Ratio Integer), (Ratio Integer -> Ratio Integer), (Ratio Integer -> Ratio Integer)] [_DFUN_ Num (Ratio Integer), _CONSTM_ Fractional (/) (Ratio Integer), _CONSTM_ Fractional recip (Ratio Integer), _CONSTM_ Fractional fromRational (Ratio Integer)] _N_
- (/) = _A_ 2 _U_ 11 _N_ _S_ "U(LU(PPP))U(U(PPP)L)" {_A_ 5 _U_ 22221 _N_ _N_ _N_ _N_} _N_ _N_,
- recip = _A_ 1 _U_ 1 _N_ _S_ "U(U(PPP)L)" {_A_ 4 _U_ 2222 _N_ _N_ _N_ _N_} _N_ _N_,
- fromRational = _A_ 1 _U_ 1 _N_ _S_ "U(LL)" {_A_ 2 _U_ 22 _N_ _N_ _F_ _IF_ARGS_ 0 2 XX 3 \ (u0 :: Integer) (u1 :: Integer) -> _!_ (:%) [Integer] [u0, u1] _N_} _F_ _IF_ARGS_ 0 1 X 1 \ (u0 :: Ratio Integer) -> u0 _N_ #-}
+ (/) = { _A_ 2 _U_ 11 _N_ _S_ "U(LU(PPP))U(U(PPP)L)" {_A_ 5 _U_ 22221 _N_ _N_ _N_ _N_} _N_ _N_ },
+ recip = { _A_ 1 _U_ 1 _N_ _S_ "U(U(PPP)L)" {_A_ 4 _U_ 2222 _N_ _N_ _N_ _N_} _N_ _N_ },
+ fromRational = { _A_ 1 _U_ 1 _N_ _S_ "U(LL)" {_A_ 2 _U_ 22 _N_ _N_ _F_ _IF_ARGS_ 0 2 XX 3 \ (u0 :: Integer) (u1 :: Integer) -> _!_ (:%) [Integer] [u0, u1] _N_} _F_ _IF_ARGS_ 0 1 X 1 \ (u0 :: Ratio Integer) -> u0 _N_ } #-}
instance Integral Int
{-# GHC_PRAGMA _M_ PreludeCore {-dfun-} _A_ 0 _N_ _N_ _N_ _F_ _IF_ARGS_ 0 0 X 13 _!_ _TUP_12 [{{Real Int}}, {{Ix Int}}, (Int -> Int -> Int), (Int -> Int -> Int), (Int -> Int -> Int), (Int -> Int -> Int), (Int -> Int -> (Int, Int)), (Int -> Int -> (Int, Int)), (Int -> Bool), (Int -> Bool), (Int -> Integer), (Int -> Int)] [_DFUN_ Real (Int), _DFUN_ Ix (Int), _CONSTM_ Integral quot (Int), _CONSTM_ Integral rem (Int), _CONSTM_ Integral div (Int), _CONSTM_ Integral mod (Int), _CONSTM_ Integral quotRem (Int), _CONSTM_ Integral divMod (Int), _CONSTM_ Integral even (Int), _CONSTM_ Integral odd (Int), _CONSTM_ Integral toInteger (Int), _CONSTM_ Integral toInt (Int)] _N_
- quot = _A_ 2 _U_ 11 _N_ _S_ "U(P)U(P)" {_A_ 2 _U_ 22 _N_ _N_ _F_ _IF_ARGS_ 0 2 XC 5 \ (u0 :: Int#) (u1 :: Int#) -> case u1 of { _PRIM_ 0# -> _APP_ _TYAPP_ error { Int } [ _NOREP_S_ "Integral.Int.quot{PreludeCore}: divide by 0\n" ]; (u2 :: Int#) -> case _#_ quotInt# [] [u0, u1] of { _PRIM_ (u3 :: Int#) -> _!_ I# [] [u3] } } _N_} _F_ _IF_ARGS_ 0 2 CC 7 \ (u0 :: Int) (u1 :: Int) -> case u1 of { _ALG_ I# (u2 :: Int#) -> case u2 of { _PRIM_ 0# -> _APP_ _TYAPP_ error { Int } [ _NOREP_S_ "Integral.Int.quot{PreludeCore}: divide by 0\n" ]; (u3 :: Int#) -> case u0 of { _ALG_ I# (u4 :: Int#) -> case _#_ quotInt# [] [u4, u2] of { _PRIM_ (u5 :: Int#) -> _!_ I# [] [u5] }; _NO_DEFLT_ } }; _NO_DEFLT_ } _N_,
- rem = _A_ 2 _U_ 11 _N_ _S_ "U(P)U(P)" {_A_ 2 _U_ 22 _N_ _N_ _F_ _IF_ARGS_ 0 2 XC 5 \ (u0 :: Int#) (u1 :: Int#) -> case u1 of { _PRIM_ 0# -> _APP_ _TYAPP_ error { Int } [ _NOREP_S_ "Integral.Int.rem{PreludeCore}: divide by 0\n" ]; (u2 :: Int#) -> case _#_ remInt# [] [u0, u1] of { _PRIM_ (u3 :: Int#) -> _!_ I# [] [u3] } } _N_} _F_ _IF_ARGS_ 0 2 CC 7 \ (u0 :: Int) (u1 :: Int) -> case u1 of { _ALG_ I# (u2 :: Int#) -> case u2 of { _PRIM_ 0# -> _APP_ _TYAPP_ error { Int } [ _NOREP_S_ "Integral.Int.rem{PreludeCore}: divide by 0\n" ]; (u3 :: Int#) -> case u0 of { _ALG_ I# (u4 :: Int#) -> case _#_ remInt# [] [u4, u2] of { _PRIM_ (u5 :: Int#) -> _!_ I# [] [u5] }; _NO_DEFLT_ } }; _NO_DEFLT_ } _N_,
- div = _A_ 2 _U_ 11 _N_ _S_ "U(P)U(P)" {_A_ 2 _U_ 22 _N_ _N_ _N_ _N_} _N_ _N_,
- mod = _A_ 2 _U_ 11 _N_ _S_ "U(P)U(P)" {_A_ 2 _U_ 22 _N_ _N_ _N_ _N_} _N_ _N_,
- quotRem = _A_ 2 _U_ 11 _N_ _S_ "U(P)U(P)" {_A_ 2 _U_ 22 _N_ _N_ _N_ _N_} _N_ _N_,
- divMod = _A_ 2 _U_ 11 _N_ _S_ "U(P)U(P)" {_A_ 2 _U_ 22 _N_ _N_ _N_ _N_} _N_ _N_,
- even = _A_ 1 _U_ 1 _N_ _S_ "U(P)" {_A_ 1 _U_ 2 _N_ _N_ _N_ _N_} _N_ _N_,
- odd = _A_ 1 _U_ 1 _N_ _S_ "U(P)" {_A_ 1 _U_ 2 _N_ _N_ _N_ _N_} _N_ _N_,
- toInteger = _A_ 1 _U_ 1 _N_ _S_ "U(P)" {_A_ 1 _U_ 2 _N_ _N_ _F_ _IF_ARGS_ 0 1 X 1 \ (u0 :: Int#) -> _#_ int2Integer# [] [u0] _N_} _F_ _IF_ARGS_ 0 1 C 2 \ (u0 :: Int) -> case u0 of { _ALG_ I# (u1 :: Int#) -> _#_ int2Integer# [] [u1]; _NO_DEFLT_ } _N_,
- toInt = _A_ 1 _U_ 1 _N_ _S_ "U(P)" {_A_ 1 _U_ 2 _N_ _N_ _F_ _IF_ARGS_ 0 1 X 2 \ (u0 :: Int#) -> _!_ I# [] [u0] _N_} _F_ _IF_ARGS_ 0 1 X 1 \ (u0 :: Int) -> u0 _N_ #-}
+ quot = { _A_ 2 _U_ 11 _N_ _S_ "U(P)U(P)" {_A_ 2 _U_ 22 _N_ _N_ _F_ _IF_ARGS_ 0 2 XC 5 \ (u0 :: Int#) (u1 :: Int#) -> case u1 of { _PRIM_ 0# -> _APP_ _TYAPP_ error { Int } [ _NOREP_S_ "Integral.Int.quot{PreludeCore}: divide by 0\n" ]; (u2 :: Int#) -> case _#_ quotInt# [] [u0, u1] of { _PRIM_ (u3 :: Int#) -> _!_ I# [] [u3] } } _N_} _F_ _IF_ARGS_ 0 2 CC 7 \ (u0 :: Int) (u1 :: Int) -> case u1 of { _ALG_ I# (u2 :: Int#) -> case u2 of { _PRIM_ 0# -> _APP_ _TYAPP_ error { Int } [ _NOREP_S_ "Integral.Int.quot{PreludeCore}: divide by 0\n" ]; (u3 :: Int#) -> case u0 of { _ALG_ I# (u4 :: Int#) -> case _#_ quotInt# [] [u4, u2] of { _PRIM_ (u5 :: Int#) -> _!_ I# [] [u5] }; _NO_DEFLT_ } }; _NO_DEFLT_ } _N_ },
+ rem = { _A_ 2 _U_ 11 _N_ _S_ "U(P)U(P)" {_A_ 2 _U_ 22 _N_ _N_ _F_ _IF_ARGS_ 0 2 XC 5 \ (u0 :: Int#) (u1 :: Int#) -> case u1 of { _PRIM_ 0# -> _APP_ _TYAPP_ error { Int } [ _NOREP_S_ "Integral.Int.rem{PreludeCore}: divide by 0\n" ]; (u2 :: Int#) -> case _#_ remInt# [] [u0, u1] of { _PRIM_ (u3 :: Int#) -> _!_ I# [] [u3] } } _N_} _F_ _IF_ARGS_ 0 2 CC 7 \ (u0 :: Int) (u1 :: Int) -> case u1 of { _ALG_ I# (u2 :: Int#) -> case u2 of { _PRIM_ 0# -> _APP_ _TYAPP_ error { Int } [ _NOREP_S_ "Integral.Int.rem{PreludeCore}: divide by 0\n" ]; (u3 :: Int#) -> case u0 of { _ALG_ I# (u4 :: Int#) -> case _#_ remInt# [] [u4, u2] of { _PRIM_ (u5 :: Int#) -> _!_ I# [] [u5] }; _NO_DEFLT_ } }; _NO_DEFLT_ } _N_ },
+ div = { _A_ 2 _U_ 11 _N_ _S_ "U(P)U(P)" {_A_ 2 _U_ 22 _N_ _N_ _N_ _N_} _N_ _N_ },
+ mod = { _A_ 2 _U_ 11 _N_ _S_ "U(P)U(P)" {_A_ 2 _U_ 22 _N_ _N_ _N_ _N_} _N_ _N_ },
+ quotRem = { _A_ 2 _U_ 11 _N_ _S_ "U(P)U(P)" {_A_ 2 _U_ 22 _N_ _N_ _N_ _N_} _N_ _N_ },
+ divMod = { _A_ 2 _U_ 11 _N_ _S_ "U(P)U(P)" {_A_ 2 _U_ 22 _N_ _N_ _N_ _N_} _N_ _N_ },
+ even = { _A_ 1 _U_ 1 _N_ _S_ "U(P)" {_A_ 1 _U_ 2 _N_ _N_ _N_ _N_} _N_ _N_ },
+ odd = { _A_ 1 _U_ 1 _N_ _S_ "U(P)" {_A_ 1 _U_ 2 _N_ _N_ _N_ _N_} _N_ _N_ },
+ toInteger = { _A_ 1 _U_ 1 _N_ _S_ "U(P)" {_A_ 1 _U_ 2 _N_ _N_ _F_ _IF_ARGS_ 0 1 X 1 \ (u0 :: Int#) -> _#_ int2Integer# [] [u0] _N_} _F_ _IF_ARGS_ 0 1 C 2 \ (u0 :: Int) -> case u0 of { _ALG_ I# (u1 :: Int#) -> _#_ int2Integer# [] [u1]; _NO_DEFLT_ } _N_ },
+ toInt = { _A_ 1 _U_ 1 _N_ _S_ "U(P)" {_A_ 1 _U_ 2 _N_ _N_ _F_ _IF_ARGS_ 0 1 X 2 \ (u0 :: Int#) -> _!_ I# [] [u0] _N_} _F_ _IF_ARGS_ 0 1 X 1 \ (u0 :: Int) -> u0 _N_ } #-}
instance Integral Integer
{-# GHC_PRAGMA _M_ PreludeCore {-dfun-} _A_ 0 _N_ _N_ _N_ _F_ _IF_ARGS_ 0 0 X 13 _!_ _TUP_12 [{{Real Integer}}, {{Ix Integer}}, (Integer -> Integer -> Integer), (Integer -> Integer -> Integer), (Integer -> Integer -> Integer), (Integer -> Integer -> Integer), (Integer -> Integer -> (Integer, Integer)), (Integer -> Integer -> (Integer, Integer)), (Integer -> Bool), (Integer -> Bool), (Integer -> Integer), (Integer -> Int)] [_DFUN_ Real (Integer), _DFUN_ Ix (Integer), _CONSTM_ Integral quot (Integer), _CONSTM_ Integral rem (Integer), _CONSTM_ Integral div (Integer), _CONSTM_ Integral mod (Integer), _CONSTM_ Integral quotRem (Integer), _CONSTM_ Integral divMod (Integer), _CONSTM_ Integral even (Integer), _CONSTM_ Integral odd (Integer), _CONSTM_ Integral toInteger (Integer), _CONSTM_ Integral toInt (Integer)] _N_
- quot = _A_ 2 _U_ 11 _N_ _S_ "U(PPP)U(PPP)" {_A_ 4 _U_ 2221 _N_ _N_ _F_ _IF_ARGS_ 0 4 XXXX 7 \ (u0 :: Int#) (u1 :: Int#) (u2 :: ByteArray#) (u3 :: Integer) -> case _APP_ _WRKR_ _CONSTM_ Integral quotRem (Integer) [ u0, u1, u2, u3 ] of { _ALG_ _TUP_2 (u4 :: Integer) (u5 :: Integer) -> u4; _NO_DEFLT_ } _N_} _F_ _IF_ARGS_ 0 2 XX 5 \ (u0 :: Integer) (u1 :: Integer) -> case _APP_ _CONSTM_ Integral quotRem (Integer) [ u0, u1 ] of { _ALG_ _TUP_2 (u2 :: Integer) (u3 :: Integer) -> u2; _NO_DEFLT_ } _N_,
- rem = _A_ 2 _U_ 11 _N_ _S_ "U(PPP)U(PPP)" {_A_ 4 _U_ 2221 _N_ _N_ _F_ _IF_ARGS_ 0 4 XXXX 7 \ (u0 :: Int#) (u1 :: Int#) (u2 :: ByteArray#) (u3 :: Integer) -> case _APP_ _WRKR_ _CONSTM_ Integral quotRem (Integer) [ u0, u1, u2, u3 ] of { _ALG_ _TUP_2 (u4 :: Integer) (u5 :: Integer) -> u5; _NO_DEFLT_ } _N_} _F_ _IF_ARGS_ 0 2 XX 5 \ (u0 :: Integer) (u1 :: Integer) -> case _APP_ _CONSTM_ Integral quotRem (Integer) [ u0, u1 ] of { _ALG_ _TUP_2 (u2 :: Integer) (u3 :: Integer) -> u3; _NO_DEFLT_ } _N_,
- div = _A_ 2 _U_ 12 _N_ _S_ "U(PPP)U(PPP)" {_A_ 4 _U_ 2222 _N_ _N_ _F_ _IF_ARGS_ 0 4 XXXX 7 \ (u0 :: Int#) (u1 :: Int#) (u2 :: ByteArray#) (u3 :: Integer) -> case _APP_ _WRKR_ _CONSTM_ Integral divMod (Integer) [ u0, u1, u2, u3 ] of { _ALG_ _TUP_2 (u4 :: Integer) (u5 :: Integer) -> u4; _NO_DEFLT_ } _N_} _F_ _IF_ARGS_ 0 2 XX 5 \ (u0 :: Integer) (u1 :: Integer) -> case _APP_ _CONSTM_ Integral divMod (Integer) [ u0, u1 ] of { _ALG_ _TUP_2 (u2 :: Integer) (u3 :: Integer) -> u2; _NO_DEFLT_ } _N_,
- mod = _A_ 2 _U_ 12 _N_ _S_ "U(PPP)U(PPP)" {_A_ 4 _U_ 2222 _N_ _N_ _F_ _IF_ARGS_ 0 4 XXXX 7 \ (u0 :: Int#) (u1 :: Int#) (u2 :: ByteArray#) (u3 :: Integer) -> case _APP_ _WRKR_ _CONSTM_ Integral divMod (Integer) [ u0, u1, u2, u3 ] of { _ALG_ _TUP_2 (u4 :: Integer) (u5 :: Integer) -> u5; _NO_DEFLT_ } _N_} _F_ _IF_ARGS_ 0 2 XX 5 \ (u0 :: Integer) (u1 :: Integer) -> case _APP_ _CONSTM_ Integral divMod (Integer) [ u0, u1 ] of { _ALG_ _TUP_2 (u2 :: Integer) (u3 :: Integer) -> u3; _NO_DEFLT_ } _N_,
- quotRem = _A_ 2 _U_ 11 _N_ _S_ "U(PPP)U(PPP)" {_A_ 4 _U_ 2221 _N_ _N_ _N_ _N_} _N_ _N_,
- divMod = _A_ 2 _U_ 12 _N_ _S_ "U(PPP)U(PPP)" {_A_ 4 _U_ 2222 _N_ _N_ _N_ _N_} _N_ _N_,
- even = _A_ 1 _U_ 1 _N_ _S_ "U(PPP)" {_A_ 3 _U_ 222 _N_ _N_ _N_ _N_} _N_ _N_,
- odd = _A_ 1 _U_ 1 _N_ _S_ "U(PPP)" {_A_ 3 _U_ 222 _N_ _N_ _N_ _N_} _N_ _N_,
- toInteger = _A_ 1 _U_ 1 _N_ _S_ "U(PPP)" {_A_ 3 _U_ 222 _N_ _N_ _F_ _IF_ARGS_ 0 3 XXX 4 \ (u0 :: Int#) (u1 :: Int#) (u2 :: ByteArray#) -> _!_ J# [] [u0, u1, u2] _N_} _F_ _IF_ARGS_ 0 1 X 1 \ (u0 :: Integer) -> u0 _N_,
- toInt = _A_ 1 _U_ 1 _N_ _S_ "U(PPP)" {_A_ 3 _U_ 222 _N_ _N_ _F_ _IF_ARGS_ 0 3 XXX 3 \ (u0 :: Int#) (u1 :: Int#) (u2 :: ByteArray#) -> case _#_ integer2Int# [] [u0, u1, u2] of { _PRIM_ (u3 :: Int#) -> _!_ I# [] [u3] } _N_} _F_ _IF_ARGS_ 0 1 C 4 \ (u0 :: Integer) -> case u0 of { _ALG_ J# (u1 :: Int#) (u2 :: Int#) (u3 :: ByteArray#) -> case _#_ integer2Int# [] [u1, u2, u3] of { _PRIM_ (u4 :: Int#) -> _!_ I# [] [u4] }; _NO_DEFLT_ } _N_ #-}
+ quot = { _A_ 2 _U_ 11 _N_ _S_ "U(PPP)U(PPP)" {_A_ 4 _U_ 2221 _N_ _N_ _F_ _IF_ARGS_ 0 4 XXXX 7 \ (u0 :: Int#) (u1 :: Int#) (u2 :: ByteArray#) (u3 :: Integer) -> case _APP_ _WRKR_ _CONSTM_ Integral quotRem (Integer) [ u0, u1, u2, u3 ] of { _ALG_ _TUP_2 (u4 :: Integer) (u5 :: Integer) -> u4; _NO_DEFLT_ } _N_} _F_ _IF_ARGS_ 0 2 XX 5 \ (u0 :: Integer) (u1 :: Integer) -> case _APP_ _CONSTM_ Integral quotRem (Integer) [ u0, u1 ] of { _ALG_ _TUP_2 (u2 :: Integer) (u3 :: Integer) -> u2; _NO_DEFLT_ } _N_ },
+ rem = { _A_ 2 _U_ 11 _N_ _S_ "U(PPP)U(PPP)" {_A_ 4 _U_ 2221 _N_ _N_ _F_ _IF_ARGS_ 0 4 XXXX 7 \ (u0 :: Int#) (u1 :: Int#) (u2 :: ByteArray#) (u3 :: Integer) -> case _APP_ _WRKR_ _CONSTM_ Integral quotRem (Integer) [ u0, u1, u2, u3 ] of { _ALG_ _TUP_2 (u4 :: Integer) (u5 :: Integer) -> u5; _NO_DEFLT_ } _N_} _F_ _IF_ARGS_ 0 2 XX 5 \ (u0 :: Integer) (u1 :: Integer) -> case _APP_ _CONSTM_ Integral quotRem (Integer) [ u0, u1 ] of { _ALG_ _TUP_2 (u2 :: Integer) (u3 :: Integer) -> u3; _NO_DEFLT_ } _N_ },
+ div = { _A_ 2 _U_ 12 _N_ _S_ "U(PPP)U(PPP)" {_A_ 4 _U_ 2222 _N_ _N_ _F_ _IF_ARGS_ 0 4 XXXX 7 \ (u0 :: Int#) (u1 :: Int#) (u2 :: ByteArray#) (u3 :: Integer) -> case _APP_ _WRKR_ _CONSTM_ Integral divMod (Integer) [ u0, u1, u2, u3 ] of { _ALG_ _TUP_2 (u4 :: Integer) (u5 :: Integer) -> u4; _NO_DEFLT_ } _N_} _F_ _IF_ARGS_ 0 2 XX 5 \ (u0 :: Integer) (u1 :: Integer) -> case _APP_ _CONSTM_ Integral divMod (Integer) [ u0, u1 ] of { _ALG_ _TUP_2 (u2 :: Integer) (u3 :: Integer) -> u2; _NO_DEFLT_ } _N_ },
+ mod = { _A_ 2 _U_ 12 _N_ _S_ "U(PPP)U(PPP)" {_A_ 4 _U_ 2222 _N_ _N_ _F_ _IF_ARGS_ 0 4 XXXX 7 \ (u0 :: Int#) (u1 :: Int#) (u2 :: ByteArray#) (u3 :: Integer) -> case _APP_ _WRKR_ _CONSTM_ Integral divMod (Integer) [ u0, u1, u2, u3 ] of { _ALG_ _TUP_2 (u4 :: Integer) (u5 :: Integer) -> u5; _NO_DEFLT_ } _N_} _F_ _IF_ARGS_ 0 2 XX 5 \ (u0 :: Integer) (u1 :: Integer) -> case _APP_ _CONSTM_ Integral divMod (Integer) [ u0, u1 ] of { _ALG_ _TUP_2 (u2 :: Integer) (u3 :: Integer) -> u3; _NO_DEFLT_ } _N_ },
+ quotRem = { _A_ 2 _U_ 11 _N_ _S_ "U(PPP)U(PPP)" {_A_ 4 _U_ 2221 _N_ _N_ _N_ _N_} _N_ _N_ },
+ divMod = { _A_ 2 _U_ 12 _N_ _S_ "U(PPP)U(PPP)" {_A_ 4 _U_ 2222 _N_ _N_ _N_ _N_} _N_ _N_ },
+ even = { _A_ 1 _U_ 1 _N_ _S_ "U(PPP)" {_A_ 3 _U_ 222 _N_ _N_ _N_ _N_} _N_ _N_ },
+ odd = { _A_ 1 _U_ 1 _N_ _S_ "U(PPP)" {_A_ 3 _U_ 222 _N_ _N_ _N_ _N_} _N_ _N_ },
+ toInteger = { _A_ 1 _U_ 1 _N_ _S_ "U(PPP)" {_A_ 3 _U_ 222 _N_ _N_ _F_ _IF_ARGS_ 0 3 XXX 4 \ (u0 :: Int#) (u1 :: Int#) (u2 :: ByteArray#) -> _!_ J# [] [u0, u1, u2] _N_} _F_ _IF_ARGS_ 0 1 X 1 \ (u0 :: Integer) -> u0 _N_ },
+ toInt = { _A_ 1 _U_ 1 _N_ _S_ "U(PPP)" {_A_ 3 _U_ 222 _N_ _N_ _F_ _IF_ARGS_ 0 3 XXX 3 \ (u0 :: Int#) (u1 :: Int#) (u2 :: ByteArray#) -> case _#_ integer2Int# [] [u0, u1, u2] of { _PRIM_ (u3 :: Int#) -> _!_ I# [] [u3] } _N_} _F_ _IF_ARGS_ 0 1 C 4 \ (u0 :: Integer) -> case u0 of { _ALG_ J# (u1 :: Int#) (u2 :: Int#) (u3 :: ByteArray#) -> case _#_ integer2Int# [] [u1, u2, u3] of { _PRIM_ (u4 :: Int#) -> _!_ I# [] [u4] }; _NO_DEFLT_ } _N_ } #-}
instance Ix ()
{-# GHC_PRAGMA _M_ PreludeBuiltin {-dfun-} _A_ 0 _N_ _N_ _N_ _F_ _IF_ARGS_ 0 0 X 5 _!_ _TUP_4 [{{Ord ()}}, (((), ()) -> [()]), (((), ()) -> () -> Int), (((), ()) -> () -> Bool)] [_DFUN_ Ord (()), _CONSTM_ Ix range (()), _CONSTM_ Ix index (()), _CONSTM_ Ix inRange (())] _N_
- range = _A_ 1 _U_ 1 _N_ _S_ "U(EE)" {_A_ 2 _U_ 21 _N_ _N_ _N_ _N_} _N_ _N_,
- index = _A_ 2 _U_ 11 _N_ _S_ "U(EE)E" {_A_ 3 _U_ 111 _N_ _N_ _F_ _IF_ARGS_ 0 3 CCC 5 \ (u0 :: ()) (u1 :: ()) (u2 :: ()) -> case u0 of { _ALG_ _TUP_0 -> case u1 of { _ALG_ _TUP_0 -> case u2 of { _ALG_ _TUP_0 -> _!_ I# [] [0#]; _NO_DEFLT_ }; _NO_DEFLT_ }; _NO_DEFLT_ } _N_} _F_ _IF_ARGS_ 0 2 CC 6 \ (u0 :: ((), ())) (u1 :: ()) -> case u0 of { _ALG_ _TUP_2 (u2 :: ()) (u3 :: ()) -> case u2 of { _ALG_ _TUP_0 -> case u3 of { _ALG_ _TUP_0 -> case u1 of { _ALG_ _TUP_0 -> _!_ I# [] [0#]; _NO_DEFLT_ }; _NO_DEFLT_ }; _NO_DEFLT_ }; _NO_DEFLT_ } _N_,
- inRange = _A_ 2 _U_ 11 _N_ _S_ "U(EE)E" {_A_ 3 _U_ 111 _N_ _N_ _F_ _IF_ARGS_ 0 3 CCC 4 \ (u0 :: ()) (u1 :: ()) (u2 :: ()) -> case u0 of { _ALG_ _TUP_0 -> case u1 of { _ALG_ _TUP_0 -> case u2 of { _ALG_ _TUP_0 -> _!_ True [] []; _NO_DEFLT_ }; _NO_DEFLT_ }; _NO_DEFLT_ } _N_} _F_ _IF_ARGS_ 0 2 CC 5 \ (u0 :: ((), ())) (u1 :: ()) -> case u0 of { _ALG_ _TUP_2 (u2 :: ()) (u3 :: ()) -> case u2 of { _ALG_ _TUP_0 -> case u3 of { _ALG_ _TUP_0 -> case u1 of { _ALG_ _TUP_0 -> _!_ True [] []; _NO_DEFLT_ }; _NO_DEFLT_ }; _NO_DEFLT_ }; _NO_DEFLT_ } _N_ #-}
+ range = { _A_ 1 _U_ 1 _N_ _S_ "U(EE)" {_A_ 2 _U_ 21 _N_ _N_ _N_ _N_} _N_ _N_ },
+ index = { _A_ 2 _U_ 11 _N_ _S_ "U(EE)E" {_A_ 3 _U_ 111 _N_ _N_ _F_ _IF_ARGS_ 0 3 CCC 5 \ (u0 :: ()) (u1 :: ()) (u2 :: ()) -> case u0 of { _ALG_ _TUP_0 -> case u1 of { _ALG_ _TUP_0 -> case u2 of { _ALG_ _TUP_0 -> _!_ I# [] [0#]; _NO_DEFLT_ }; _NO_DEFLT_ }; _NO_DEFLT_ } _N_} _F_ _IF_ARGS_ 0 2 CC 6 \ (u0 :: ((), ())) (u1 :: ()) -> case u0 of { _ALG_ _TUP_2 (u2 :: ()) (u3 :: ()) -> case u2 of { _ALG_ _TUP_0 -> case u3 of { _ALG_ _TUP_0 -> case u1 of { _ALG_ _TUP_0 -> _!_ I# [] [0#]; _NO_DEFLT_ }; _NO_DEFLT_ }; _NO_DEFLT_ }; _NO_DEFLT_ } _N_ },
+ inRange = { _A_ 2 _U_ 11 _N_ _S_ "U(EE)E" {_A_ 3 _U_ 111 _N_ _N_ _F_ _IF_ARGS_ 0 3 CCC 4 \ (u0 :: ()) (u1 :: ()) (u2 :: ()) -> case u0 of { _ALG_ _TUP_0 -> case u1 of { _ALG_ _TUP_0 -> case u2 of { _ALG_ _TUP_0 -> _!_ True [] []; _NO_DEFLT_ }; _NO_DEFLT_ }; _NO_DEFLT_ } _N_} _F_ _IF_ARGS_ 0 2 CC 5 \ (u0 :: ((), ())) (u1 :: ()) -> case u0 of { _ALG_ _TUP_2 (u2 :: ()) (u3 :: ()) -> case u2 of { _ALG_ _TUP_0 -> case u3 of { _ALG_ _TUP_0 -> case u1 of { _ALG_ _TUP_0 -> _!_ True [] []; _NO_DEFLT_ }; _NO_DEFLT_ }; _NO_DEFLT_ }; _NO_DEFLT_ } _N_ } #-}
instance (Ix a, Ix b) => Ix (a, b)
{-# GHC_PRAGMA _M_ PreludeBuiltin {-dfun-} _A_ 3 _U_ 222 _N_ _N_ _N_ _N_ #-}
instance (Ix a, Ix b, Ix c) => Ix (a, b, c)
{-# GHC_PRAGMA _M_ PreludeBuiltin {-dfun-} _A_ 6 _U_ 222222 _N_ _N_ _N_ _N_ #-}
instance Ix (Int, Int)
{-# GHC_PRAGMA _M_ PreludeBuiltin {-dfun-} _A_ 0 _N_ _N_ _N_ _F_ _IF_ARGS_ 0 0 X 5 _!_ _TUP_4 [{{Ord (Int, Int)}}, (((Int, Int), (Int, Int)) -> [(Int, Int)]), (((Int, Int), (Int, Int)) -> (Int, Int) -> Int), (((Int, Int), (Int, Int)) -> (Int, Int) -> Bool)] [_DFUN_ Ord ((Int, Int)), _CONSTM_ Ix range ((Int, Int)), _CONSTM_ Ix index ((Int, Int)), _CONSTM_ Ix inRange ((Int, Int))] _N_
- range = _A_ 1 _U_ 1 _N_ _S_ "U(SS)" {_A_ 2 _U_ 11 _N_ _N_ _N_ _N_} _N_ _N_,
- index = _A_ 2 _U_ 11 _N_ _S_ "U(SS)U(U(P)U(P))" {_A_ 4 _U_ 1122 _N_ _N_ _N_ _N_} _N_ _N_,
- inRange = _A_ 2 _U_ 11 _N_ _S_ "U(SS)U(U(P)L)" {_A_ 4 _U_ 1121 _N_ _N_ _N_ _N_} _N_ _N_ #-}
+ range = { _A_ 1 _U_ 1 _N_ _S_ "U(SS)" {_A_ 2 _U_ 11 _N_ _N_ _N_ _N_} _N_ _N_ },
+ index = { _A_ 2 _U_ 11 _N_ _S_ "U(SS)U(U(P)U(P))" {_A_ 4 _U_ 1122 _N_ _N_ _N_ _N_} _N_ _N_ },
+ inRange = { _A_ 2 _U_ 11 _N_ _S_ "U(SS)U(U(P)L)" {_A_ 4 _U_ 1121 _N_ _N_ _N_ _N_} _N_ _N_ } #-}
instance (Ix a, Ix b) => Ix (Assoc a b)
{-# GHC_PRAGMA _M_ PreludeArray {-dfun-} _A_ 3 _U_ 222 _N_ _N_ _N_ _N_ #-}
instance Ix Bool
{-# GHC_PRAGMA _M_ PreludeCore {-dfun-} _A_ 0 _N_ _N_ _N_ _F_ _IF_ARGS_ 0 0 X 5 _!_ _TUP_4 [{{Ord Bool}}, ((Bool, Bool) -> [Bool]), ((Bool, Bool) -> Bool -> Int), ((Bool, Bool) -> Bool -> Bool)] [_DFUN_ Ord (Bool), _CONSTM_ Ix range (Bool), _CONSTM_ Ix index (Bool), _CONSTM_ Ix inRange (Bool)] _N_
- range = _A_ 1 _U_ 1 _N_ _S_ "U(EE)" {_A_ 2 _U_ 11 _N_ _N_ _N_ _N_} _N_ _N_,
- index = _A_ 2 _U_ 11 _N_ _S_ "U(EA)E" {_A_ 2 _U_ 11 _N_ _N_ _N_ _N_} _N_ _N_,
- inRange = _A_ 2 _U_ 12 _N_ _S_ "U(EL)E" {_A_ 3 _U_ 112 _N_ _N_ _N_ _N_} _N_ _N_ #-}
+ range = { _A_ 1 _U_ 1 _N_ _S_ "U(EE)" {_A_ 2 _U_ 11 _N_ _N_ _N_ _N_} _N_ _N_ },
+ index = { _A_ 2 _U_ 11 _N_ _S_ "U(EA)E" {_A_ 2 _U_ 11 _N_ _N_ _N_ _N_} _N_ _N_ },
+ inRange = { _A_ 2 _U_ 12 _N_ _S_ "U(EL)E" {_A_ 3 _U_ 112 _N_ _N_ _N_ _N_} _N_ _N_ } #-}
instance Ix Char
{-# GHC_PRAGMA _M_ PreludeCore {-dfun-} _A_ 0 _N_ _N_ _N_ _F_ _IF_ARGS_ 0 0 X 5 _!_ _TUP_4 [{{Ord Char}}, ((Char, Char) -> [Char]), ((Char, Char) -> Char -> Int), ((Char, Char) -> Char -> Bool)] [_DFUN_ Ord (Char), _CONSTM_ Ix range (Char), _CONSTM_ Ix index (Char), _CONSTM_ Ix inRange (Char)] _N_
- range = _A_ 1 _U_ 1 _N_ _S_ "U(LL)" {_A_ 2 _U_ 22 _N_ _N_ _F_ _IF_ARGS_ 0 0 X 1 _CONSTM_ Enum enumFromTo (Char) _N_} _F_ _IF_ARGS_ 0 1 C 4 \ (u0 :: (Char, Char)) -> case u0 of { _ALG_ _TUP_2 (u1 :: Char) (u2 :: Char) -> _APP_ _CONSTM_ Enum enumFromTo (Char) [ u1, u2 ]; _NO_DEFLT_ } _N_,
- index = _A_ 2 _U_ 11 _N_ _S_ "U(U(P)L)U(P)" {_A_ 3 _U_ 212 _N_ _N_ _N_ _N_} _N_ _N_,
- inRange = _A_ 2 _U_ 11 _N_ _S_ "U(U(P)L)U(P)" {_A_ 3 _U_ 212 _N_ _N_ _N_ _N_} _N_ _N_ #-}
+ range = { _A_ 1 _U_ 1 _N_ _S_ "U(U(P)L)" {_A_ 2 _U_ 22 _N_ _N_ _N_ _N_} _F_ _IF_ARGS_ 0 1 C 4 \ (u0 :: (Char, Char)) -> case u0 of { _ALG_ _TUP_2 (u1 :: Char) (u2 :: Char) -> _APP_ _CONSTM_ Enum enumFromTo (Char) [ u1, u2 ]; _NO_DEFLT_ } _N_ },
+ index = { _A_ 2 _U_ 11 _N_ _S_ "U(U(P)L)U(P)" {_A_ 3 _U_ 212 _N_ _N_ _N_ _N_} _N_ _N_ },
+ inRange = { _A_ 2 _U_ 11 _N_ _S_ "U(U(P)L)U(P)" {_A_ 3 _U_ 212 _N_ _N_ _N_ _N_} _N_ _N_ } #-}
instance Ix Int
{-# GHC_PRAGMA _M_ PreludeCore {-dfun-} _A_ 0 _N_ _N_ _N_ _F_ _IF_ARGS_ 0 0 X 5 _!_ _TUP_4 [{{Ord Int}}, ((Int, Int) -> [Int]), ((Int, Int) -> Int -> Int), ((Int, Int) -> Int -> Bool)] [_DFUN_ Ord (Int), _CONSTM_ Ix range (Int), _CONSTM_ Ix index (Int), _CONSTM_ Ix inRange (Int)] _N_
- range = _A_ 1 _U_ 1 _N_ _S_ "U(U(P)U(P))" {_A_ 2 _U_ 22 _N_ _N_ _N_ _N_} _N_ _N_,
- index = _A_ 2 _U_ 11 _N_ _S_ "U(U(P)U(P))U(P)" {_A_ 3 _U_ 222 _N_ _N_ _N_ _N_} _N_ _N_,
- inRange = _A_ 2 _U_ 11 _N_ _S_ "U(U(P)U(P))U(P)" {_A_ 3 _U_ 222 _N_ _N_ _F_ _IF_ARGS_ 0 3 XXX 5 \ (u0 :: Int#) (u1 :: Int#) (u2 :: Int#) -> case _#_ leInt# [] [u0, u2] of { _ALG_ True -> _#_ leInt# [] [u2, u1]; False -> _!_ False [] []; _NO_DEFLT_ } _N_} _F_ _ALWAYS_ \ (u0 :: (Int, Int)) (u1 :: Int) -> case u0 of { _ALG_ _TUP_2 (u2 :: Int) (u3 :: Int) -> case u2 of { _ALG_ I# (u4 :: Int#) -> case u3 of { _ALG_ I# (u5 :: Int#) -> case u1 of { _ALG_ I# (u6 :: Int#) -> case _#_ leInt# [] [u4, u6] of { _ALG_ True -> _#_ leInt# [] [u6, u5]; False -> _!_ False [] []; _NO_DEFLT_ }; _NO_DEFLT_ }; _NO_DEFLT_ }; _NO_DEFLT_ }; _NO_DEFLT_ } _N_ #-}
+ range = { _A_ 1 _U_ 1 _N_ _S_ "U(U(P)U(P))" {_A_ 2 _U_ 22 _N_ _N_ _N_ _N_} _N_ _N_ },
+ index = { _A_ 2 _U_ 11 _N_ _S_ "U(U(P)U(P))U(P)" {_A_ 3 _U_ 222 _N_ _N_ _N_ _N_} _N_ _N_ },
+ inRange = { _A_ 2 _U_ 11 _N_ _S_ "U(U(P)U(P))U(P)" {_A_ 3 _U_ 222 _N_ _N_ _F_ _IF_ARGS_ 0 3 XXX 5 \ (u0 :: Int#) (u1 :: Int#) (u2 :: Int#) -> case _#_ leInt# [] [u0, u2] of { _ALG_ True -> _#_ leInt# [] [u2, u1]; False -> _!_ False [] []; _NO_DEFLT_ } _N_} _F_ _ALWAYS_ \ (u0 :: (Int, Int)) (u1 :: Int) -> case u0 of { _ALG_ _TUP_2 (u2 :: Int) (u3 :: Int) -> case u2 of { _ALG_ I# (u4 :: Int#) -> case u3 of { _ALG_ I# (u5 :: Int#) -> case u1 of { _ALG_ I# (u6 :: Int#) -> case _#_ leInt# [] [u4, u6] of { _ALG_ True -> _#_ leInt# [] [u6, u5]; False -> _!_ False [] []; _NO_DEFLT_ }; _NO_DEFLT_ }; _NO_DEFLT_ }; _NO_DEFLT_ }; _NO_DEFLT_ } _N_ } #-}
instance Ix Integer
{-# GHC_PRAGMA _M_ PreludeCore {-dfun-} _A_ 0 _N_ _N_ _N_ _F_ _IF_ARGS_ 0 0 X 5 _!_ _TUP_4 [{{Ord Integer}}, ((Integer, Integer) -> [Integer]), ((Integer, Integer) -> Integer -> Int), ((Integer, Integer) -> Integer -> Bool)] [_DFUN_ Ord (Integer), _CONSTM_ Ix range (Integer), _CONSTM_ Ix index (Integer), _CONSTM_ Ix inRange (Integer)] _N_
- range = _A_ 1 _U_ 1 _N_ _S_ "U(LL)" {_A_ 2 _U_ 22 _N_ _N_ _F_ _IF_ARGS_ 0 0 X 1 _CONSTM_ Enum enumFromTo (Integer) _N_} _F_ _IF_ARGS_ 0 1 C 4 \ (u0 :: (Integer, Integer)) -> case u0 of { _ALG_ _TUP_2 (u1 :: Integer) (u2 :: Integer) -> _APP_ _CONSTM_ Enum enumFromTo (Integer) [ u1, u2 ]; _NO_DEFLT_ } _N_,
- index = _A_ 2 _U_ 12 _N_ _S_ "U(U(PPP)L)U(PPP)" {_A_ 5 _U_ 22222 _N_ _N_ _N_ _N_} _N_ _N_,
- inRange = _A_ 2 _U_ 11 _N_ _S_ "U(U(PPP)L)U(PPP)" {_A_ 5 _U_ 22211 _N_ _N_ _F_ _IF_ARGS_ 0 5 XXXCC 9 \ (u0 :: Int#) (u1 :: Int#) (u2 :: ByteArray#) (u3 :: Integer) (u4 :: Integer) -> case u4 of { _ALG_ J# (u5 :: Int#) (u6 :: Int#) (u7 :: ByteArray#) -> case _#_ cmpInteger# [] [u0, u1, u2, u5, u6, u7] of { _PRIM_ (u8 :: Int#) -> case _#_ leInt# [] [u8, 0#] of { _ALG_ True -> case u3 of { _ALG_ J# (u9 :: Int#) (ua :: Int#) (ub :: ByteArray#) -> case _#_ cmpInteger# [] [u5, u6, u7, u9, ua, ub] of { _PRIM_ (uc :: Int#) -> _#_ leInt# [] [uc, 0#] }; _NO_DEFLT_ }; False -> _!_ False [] []; _NO_DEFLT_ } }; _NO_DEFLT_ } _N_} _N_ _N_ #-}
+ range = { _A_ 1 _U_ 1 _N_ _S_ "U(LL)" {_A_ 2 _U_ 22 _N_ _N_ _F_ _IF_ARGS_ 0 0 X 1 _CONSTM_ Enum enumFromTo (Integer) _N_} _F_ _IF_ARGS_ 0 1 C 4 \ (u0 :: (Integer, Integer)) -> case u0 of { _ALG_ _TUP_2 (u1 :: Integer) (u2 :: Integer) -> _APP_ _CONSTM_ Enum enumFromTo (Integer) [ u1, u2 ]; _NO_DEFLT_ } _N_ },
+ index = { _A_ 2 _U_ 12 _N_ _S_ "U(U(PPP)L)U(PPP)" {_A_ 5 _U_ 22222 _N_ _N_ _N_ _N_} _N_ _N_ },
+ inRange = { _A_ 2 _U_ 11 _N_ _S_ "U(U(PPP)L)U(PPP)" {_A_ 5 _U_ 22211 _N_ _N_ _F_ _IF_ARGS_ 0 5 XXXCC 9 \ (u0 :: Int#) (u1 :: Int#) (u2 :: ByteArray#) (u3 :: Integer) (u4 :: Integer) -> case u4 of { _ALG_ J# (u5 :: Int#) (u6 :: Int#) (u7 :: ByteArray#) -> case _#_ cmpInteger# [] [u0, u1, u2, u5, u6, u7] of { _PRIM_ (u8 :: Int#) -> case _#_ leInt# [] [u8, 0#] of { _ALG_ True -> case u3 of { _ALG_ J# (u9 :: Int#) (ua :: Int#) (ub :: ByteArray#) -> case _#_ cmpInteger# [] [u5, u6, u7, u9, ua, ub] of { _PRIM_ (uc :: Int#) -> _#_ leInt# [] [uc, 0#] }; _NO_DEFLT_ }; False -> _!_ False [] []; _NO_DEFLT_ } }; _NO_DEFLT_ } _N_} _N_ _N_ } #-}
instance RealFloat a => Num (Complex a)
{-# GHC_PRAGMA _M_ PreludeComplex {-dfun-} _A_ 3 _U_ 222 _N_ _N_ _N_ _N_ #-}
instance Num (Complex Double)
- {-# GHC_PRAGMA _M_ PreludeComplex {-dfun-} _A_ 0 _N_ _N_ _N_ _N_ _N_
- (+) = _A_ 2 _U_ 11 _N_ _S_ "U(LL)U(LL)" {_A_ 4 _U_ 1111 _N_ _N_ _N_ _N_} _N_ _N_,
- (-) = _A_ 2 _U_ 11 _N_ _S_ "U(LL)U(LL)" {_A_ 4 _U_ 1111 _N_ _N_ _N_ _N_} _N_ _N_,
- (*) = _A_ 2 _U_ 11 _N_ _S_ "U(LL)U(LL)" {_A_ 4 _U_ 2222 _N_ _N_ _N_ _N_} _N_ _N_,
- negate = _A_ 1 _U_ 1 _N_ _S_ "U(LL)" {_A_ 2 _U_ 11 _N_ _N_ _N_ _N_} _N_ _N_,
- abs = _A_ 1 _U_ 1 _N_ _N_ _N_ _N_,
- signum = _A_ 1 _U_ 1 _N_ _S_ "U(U(P)L)" {_A_ 2 _U_ 22 _N_ _N_ _N_ _N_} _N_ _N_,
- fromInteger = _A_ 1 _U_ 1 _N_ _N_ _N_ _N_,
- fromInt = _A_ 1 _U_ 1 _N_ _N_ _N_ _N_ #-}
+ {-# GHC_PRAGMA _M_ PreludeComplex {-dfun-} _A_ 0 _N_ _N_ _N_ _F_ _IF_ARGS_ 0 0 X 11 _!_ _TUP_10 [{{Eq (Complex Double)}}, {{Text (Complex Double)}}, (Complex Double -> Complex Double -> Complex Double), (Complex Double -> Complex Double -> Complex Double), (Complex Double -> Complex Double -> Complex Double), (Complex Double -> Complex Double), (Complex Double -> Complex Double), (Complex Double -> Complex Double), (Integer -> Complex Double), (Int -> Complex Double)] [_DFUN_ Eq (Complex Double), _DFUN_ Text (Complex Double), _CONSTM_ Num (+) (Complex Double), _CONSTM_ Num (-) (Complex Double), _CONSTM_ Num (*) (Complex Double), _CONSTM_ Num negate (Complex Double), _CONSTM_ Num abs (Complex Double), _CONSTM_ Num signum (Complex Double), _CONSTM_ Num fromInteger (Complex Double), _CONSTM_ Num fromInt (Complex Double)] _N_
+ (+) = { _A_ 2 _U_ 11 _N_ _S_ "U(LL)U(LL)" {_A_ 4 _U_ 1111 _N_ _N_ _N_ _N_} _N_ _N_ },
+ (-) = { _A_ 2 _U_ 11 _N_ _S_ "U(LL)U(LL)" {_A_ 4 _U_ 1111 _N_ _N_ _N_ _N_} _N_ _N_ },
+ (*) = { _A_ 2 _U_ 11 _N_ _S_ "U(LL)U(LL)" {_A_ 4 _U_ 2222 _N_ _N_ _N_ _N_} _N_ _N_ },
+ negate = { _A_ 1 _U_ 1 _N_ _S_ "U(LL)" {_A_ 2 _U_ 11 _N_ _N_ _N_ _N_} _N_ _N_ },
+ abs = { _A_ 1 _U_ 1 _N_ _N_ _N_ _N_ },
+ signum = { _A_ 1 _U_ 1 _N_ _S_ "U(U(P)L)" {_A_ 2 _U_ 22 _N_ _N_ _N_ _N_} _N_ _N_ },
+ fromInteger = { _A_ 1 _U_ 1 _N_ _N_ _N_ _N_ },
+ fromInt = { _A_ 1 _U_ 1 _N_ _N_ _N_ _N_ } #-}
instance Num Double
{-# GHC_PRAGMA _M_ PreludeCore {-dfun-} _A_ 0 _N_ _N_ _N_ _F_ _IF_ARGS_ 0 0 X 11 _!_ _TUP_10 [{{Eq Double}}, {{Text Double}}, (Double -> Double -> Double), (Double -> Double -> Double), (Double -> Double -> Double), (Double -> Double), (Double -> Double), (Double -> Double), (Integer -> Double), (Int -> Double)] [_DFUN_ Eq (Double), _DFUN_ Text (Double), _CONSTM_ Num (+) (Double), _CONSTM_ Num (-) (Double), _CONSTM_ Num (*) (Double), _CONSTM_ Num negate (Double), _CONSTM_ Num abs (Double), _CONSTM_ Num signum (Double), _CONSTM_ Num fromInteger (Double), _CONSTM_ Num fromInt (Double)] _N_
- (+) = _A_ 2 _U_ 11 _N_ _S_ "U(P)U(P)" {_A_ 2 _U_ 22 _N_ _N_ _F_ _IF_ARGS_ 0 2 XX 3 \ (u0 :: Double#) (u1 :: Double#) -> case _#_ plusDouble# [] [u0, u1] of { _PRIM_ (u2 :: Double#) -> _!_ D# [] [u2] } _N_} _F_ _IF_ARGS_ 0 2 CC 5 \ (u0 :: Double) (u1 :: Double) -> case u0 of { _ALG_ D# (u2 :: Double#) -> case u1 of { _ALG_ D# (u3 :: Double#) -> case _#_ plusDouble# [] [u2, u3] of { _PRIM_ (u4 :: Double#) -> _!_ D# [] [u4] }; _NO_DEFLT_ }; _NO_DEFLT_ } _N_,
- (-) = _A_ 2 _U_ 11 _N_ _S_ "U(P)U(P)" {_A_ 2 _U_ 22 _N_ _N_ _F_ _IF_ARGS_ 0 2 XX 3 \ (u0 :: Double#) (u1 :: Double#) -> case _#_ minusDouble# [] [u0, u1] of { _PRIM_ (u2 :: Double#) -> _!_ D# [] [u2] } _N_} _F_ _IF_ARGS_ 0 2 CC 5 \ (u0 :: Double) (u1 :: Double) -> case u0 of { _ALG_ D# (u2 :: Double#) -> case u1 of { _ALG_ D# (u3 :: Double#) -> case _#_ minusDouble# [] [u2, u3] of { _PRIM_ (u4 :: Double#) -> _!_ D# [] [u4] }; _NO_DEFLT_ }; _NO_DEFLT_ } _N_,
- (*) = _A_ 2 _U_ 11 _N_ _S_ "U(P)U(P)" {_A_ 2 _U_ 22 _N_ _N_ _F_ _IF_ARGS_ 0 2 XX 3 \ (u0 :: Double#) (u1 :: Double#) -> case _#_ timesDouble# [] [u0, u1] of { _PRIM_ (u2 :: Double#) -> _!_ D# [] [u2] } _N_} _F_ _IF_ARGS_ 0 2 CC 5 \ (u0 :: Double) (u1 :: Double) -> case u0 of { _ALG_ D# (u2 :: Double#) -> case u1 of { _ALG_ D# (u3 :: Double#) -> case _#_ timesDouble# [] [u2, u3] of { _PRIM_ (u4 :: Double#) -> _!_ D# [] [u4] }; _NO_DEFLT_ }; _NO_DEFLT_ } _N_,
- negate = _A_ 1 _U_ 1 _N_ _S_ "U(P)" {_A_ 1 _U_ 2 _N_ _N_ _F_ _IF_ARGS_ 0 1 X 3 \ (u0 :: Double#) -> case _#_ negateDouble# [] [u0] of { _PRIM_ (u1 :: Double#) -> _!_ D# [] [u1] } _N_} _F_ _IF_ARGS_ 0 1 C 4 \ (u0 :: Double) -> case u0 of { _ALG_ D# (u1 :: Double#) -> case _#_ negateDouble# [] [u1] of { _PRIM_ (u2 :: Double#) -> _!_ D# [] [u2] }; _NO_DEFLT_ } _N_,
- abs = _A_ 1 _U_ 1 _N_ _S_ "U(P)" {_A_ 1 _U_ 2 _N_ _N_ _N_ _N_} _N_ _N_,
- signum = _A_ 1 _U_ 1 _N_ _S_ "U(P)" {_A_ 1 _U_ 2 _N_ _N_ _N_ _N_} _N_ _N_,
- fromInteger = _A_ 1 _U_ 1 _N_ _S_ "U(PPP)" {_A_ 3 _U_ 222 _N_ _N_ _F_ _IF_ARGS_ 0 3 XXX 3 \ (u0 :: Int#) (u1 :: Int#) (u2 :: ByteArray#) -> case _#_ encodeDouble# [] [u0, u1, u2, 0#] of { _PRIM_ (u3 :: Double#) -> _!_ D# [] [u3] } _N_} _F_ _IF_ARGS_ 0 1 C 4 \ (u0 :: Integer) -> case u0 of { _ALG_ J# (u1 :: Int#) (u2 :: Int#) (u3 :: ByteArray#) -> case _#_ encodeDouble# [] [u1, u2, u3, 0#] of { _PRIM_ (u4 :: Double#) -> _!_ D# [] [u4] }; _NO_DEFLT_ } _N_,
- fromInt = _A_ 1 _U_ 1 _N_ _S_ "U(P)" {_A_ 1 _U_ 2 _N_ _N_ _F_ _IF_ARGS_ 0 1 X 3 \ (u0 :: Int#) -> case _#_ int2Double# [] [u0] of { _PRIM_ (u1 :: Double#) -> _!_ D# [] [u1] } _N_} _F_ _IF_ARGS_ 0 1 C 4 \ (u0 :: Int) -> case u0 of { _ALG_ I# (u1 :: Int#) -> case _#_ int2Double# [] [u1] of { _PRIM_ (u2 :: Double#) -> _!_ D# [] [u2] }; _NO_DEFLT_ } _N_ #-}
+ (+) = { _A_ 2 _U_ 11 _N_ _S_ "U(P)U(P)" {_A_ 2 _U_ 22 _N_ _N_ _F_ _IF_ARGS_ 0 2 XX 3 \ (u0 :: Double#) (u1 :: Double#) -> case _#_ plusDouble# [] [u0, u1] of { _PRIM_ (u2 :: Double#) -> _!_ D# [] [u2] } _N_} _F_ _IF_ARGS_ 0 2 CC 5 \ (u0 :: Double) (u1 :: Double) -> case u0 of { _ALG_ D# (u2 :: Double#) -> case u1 of { _ALG_ D# (u3 :: Double#) -> case _#_ plusDouble# [] [u2, u3] of { _PRIM_ (u4 :: Double#) -> _!_ D# [] [u4] }; _NO_DEFLT_ }; _NO_DEFLT_ } _N_ },
+ (-) = { _A_ 2 _U_ 11 _N_ _S_ "U(P)U(P)" {_A_ 2 _U_ 22 _N_ _N_ _F_ _IF_ARGS_ 0 2 XX 3 \ (u0 :: Double#) (u1 :: Double#) -> case _#_ minusDouble# [] [u0, u1] of { _PRIM_ (u2 :: Double#) -> _!_ D# [] [u2] } _N_} _F_ _IF_ARGS_ 0 2 CC 5 \ (u0 :: Double) (u1 :: Double) -> case u0 of { _ALG_ D# (u2 :: Double#) -> case u1 of { _ALG_ D# (u3 :: Double#) -> case _#_ minusDouble# [] [u2, u3] of { _PRIM_ (u4 :: Double#) -> _!_ D# [] [u4] }; _NO_DEFLT_ }; _NO_DEFLT_ } _N_ },
+ (*) = { _A_ 2 _U_ 11 _N_ _S_ "U(P)U(P)" {_A_ 2 _U_ 22 _N_ _N_ _F_ _IF_ARGS_ 0 2 XX 3 \ (u0 :: Double#) (u1 :: Double#) -> case _#_ timesDouble# [] [u0, u1] of { _PRIM_ (u2 :: Double#) -> _!_ D# [] [u2] } _N_} _F_ _IF_ARGS_ 0 2 CC 5 \ (u0 :: Double) (u1 :: Double) -> case u0 of { _ALG_ D# (u2 :: Double#) -> case u1 of { _ALG_ D# (u3 :: Double#) -> case _#_ timesDouble# [] [u2, u3] of { _PRIM_ (u4 :: Double#) -> _!_ D# [] [u4] }; _NO_DEFLT_ }; _NO_DEFLT_ } _N_ },
+ negate = { _A_ 1 _U_ 1 _N_ _S_ "U(P)" {_A_ 1 _U_ 2 _N_ _N_ _F_ _IF_ARGS_ 0 1 X 3 \ (u0 :: Double#) -> case _#_ negateDouble# [] [u0] of { _PRIM_ (u1 :: Double#) -> _!_ D# [] [u1] } _N_} _F_ _IF_ARGS_ 0 1 C 4 \ (u0 :: Double) -> case u0 of { _ALG_ D# (u1 :: Double#) -> case _#_ negateDouble# [] [u1] of { _PRIM_ (u2 :: Double#) -> _!_ D# [] [u2] }; _NO_DEFLT_ } _N_ },
+ abs = { _A_ 1 _U_ 1 _N_ _S_ "U(P)" {_A_ 1 _U_ 2 _N_ _N_ _N_ _N_} _N_ _N_ },
+ signum = { _A_ 1 _U_ 1 _N_ _S_ "U(P)" {_A_ 1 _U_ 2 _N_ _N_ _N_ _N_} _N_ _N_ },
+ fromInteger = { _A_ 1 _U_ 1 _N_ _S_ "U(PPP)" {_A_ 3 _U_ 222 _N_ _N_ _F_ _IF_ARGS_ 0 3 XXX 3 \ (u0 :: Int#) (u1 :: Int#) (u2 :: ByteArray#) -> case _#_ encodeDouble# [] [u0, u1, u2, 0#] of { _PRIM_ (u3 :: Double#) -> _!_ D# [] [u3] } _N_} _F_ _IF_ARGS_ 0 1 C 4 \ (u0 :: Integer) -> case u0 of { _ALG_ J# (u1 :: Int#) (u2 :: Int#) (u3 :: ByteArray#) -> case _#_ encodeDouble# [] [u1, u2, u3, 0#] of { _PRIM_ (u4 :: Double#) -> _!_ D# [] [u4] }; _NO_DEFLT_ } _N_ },
+ fromInt = { _A_ 1 _U_ 1 _N_ _S_ "U(P)" {_A_ 1 _U_ 2 _N_ _N_ _F_ _IF_ARGS_ 0 1 X 3 \ (u0 :: Int#) -> case _#_ int2Double# [] [u0] of { _PRIM_ (u1 :: Double#) -> _!_ D# [] [u1] } _N_} _F_ _IF_ARGS_ 0 1 C 4 \ (u0 :: Int) -> case u0 of { _ALG_ I# (u1 :: Int#) -> case _#_ int2Double# [] [u1] of { _PRIM_ (u2 :: Double#) -> _!_ D# [] [u2] }; _NO_DEFLT_ } _N_ } #-}
instance Num Float
{-# GHC_PRAGMA _M_ PreludeCore {-dfun-} _A_ 0 _N_ _N_ _N_ _F_ _IF_ARGS_ 0 0 X 11 _!_ _TUP_10 [{{Eq Float}}, {{Text Float}}, (Float -> Float -> Float), (Float -> Float -> Float), (Float -> Float -> Float), (Float -> Float), (Float -> Float), (Float -> Float), (Integer -> Float), (Int -> Float)] [_DFUN_ Eq (Float), _DFUN_ Text (Float), _CONSTM_ Num (+) (Float), _CONSTM_ Num (-) (Float), _CONSTM_ Num (*) (Float), _CONSTM_ Num negate (Float), _CONSTM_ Num abs (Float), _CONSTM_ Num signum (Float), _CONSTM_ Num fromInteger (Float), _CONSTM_ Num fromInt (Float)] _N_
- (+) = _A_ 2 _U_ 11 _N_ _S_ "U(P)U(P)" {_A_ 2 _U_ 22 _N_ _N_ _F_ _IF_ARGS_ 0 2 XX 3 \ (u0 :: Float#) (u1 :: Float#) -> case _#_ plusFloat# [] [u0, u1] of { _PRIM_ (u2 :: Float#) -> _!_ F# [] [u2] } _N_} _F_ _IF_ARGS_ 0 2 CC 5 \ (u0 :: Float) (u1 :: Float) -> case u0 of { _ALG_ F# (u2 :: Float#) -> case u1 of { _ALG_ F# (u3 :: Float#) -> case _#_ plusFloat# [] [u2, u3] of { _PRIM_ (u4 :: Float#) -> _!_ F# [] [u4] }; _NO_DEFLT_ }; _NO_DEFLT_ } _N_,
- (-) = _A_ 2 _U_ 11 _N_ _S_ "U(P)U(P)" {_A_ 2 _U_ 22 _N_ _N_ _F_ _IF_ARGS_ 0 2 XX 3 \ (u0 :: Float#) (u1 :: Float#) -> case _#_ minusFloat# [] [u0, u1] of { _PRIM_ (u2 :: Float#) -> _!_ F# [] [u2] } _N_} _F_ _IF_ARGS_ 0 2 CC 5 \ (u0 :: Float) (u1 :: Float) -> case u0 of { _ALG_ F# (u2 :: Float#) -> case u1 of { _ALG_ F# (u3 :: Float#) -> case _#_ minusFloat# [] [u2, u3] of { _PRIM_ (u4 :: Float#) -> _!_ F# [] [u4] }; _NO_DEFLT_ }; _NO_DEFLT_ } _N_,
- (*) = _A_ 2 _U_ 11 _N_ _S_ "U(P)U(P)" {_A_ 2 _U_ 22 _N_ _N_ _F_ _IF_ARGS_ 0 2 XX 3 \ (u0 :: Float#) (u1 :: Float#) -> case _#_ timesFloat# [] [u0, u1] of { _PRIM_ (u2 :: Float#) -> _!_ F# [] [u2] } _N_} _F_ _IF_ARGS_ 0 2 CC 5 \ (u0 :: Float) (u1 :: Float) -> case u0 of { _ALG_ F# (u2 :: Float#) -> case u1 of { _ALG_ F# (u3 :: Float#) -> case _#_ timesFloat# [] [u2, u3] of { _PRIM_ (u4 :: Float#) -> _!_ F# [] [u4] }; _NO_DEFLT_ }; _NO_DEFLT_ } _N_,
- negate = _A_ 1 _U_ 1 _N_ _S_ "U(P)" {_A_ 1 _U_ 2 _N_ _N_ _F_ _IF_ARGS_ 0 1 X 3 \ (u0 :: Float#) -> case _#_ negateFloat# [] [u0] of { _PRIM_ (u1 :: Float#) -> _!_ F# [] [u1] } _N_} _F_ _IF_ARGS_ 0 1 C 4 \ (u0 :: Float) -> case u0 of { _ALG_ F# (u1 :: Float#) -> case _#_ negateFloat# [] [u1] of { _PRIM_ (u2 :: Float#) -> _!_ F# [] [u2] }; _NO_DEFLT_ } _N_,
- abs = _A_ 1 _U_ 1 _N_ _S_ "U(P)" {_A_ 1 _U_ 2 _N_ _N_ _N_ _N_} _N_ _N_,
- signum = _A_ 1 _U_ 1 _N_ _S_ "U(P)" {_A_ 1 _U_ 2 _N_ _N_ _N_ _N_} _N_ _N_,
- fromInteger = _A_ 1 _U_ 1 _N_ _S_ "U(PPP)" {_A_ 3 _U_ 222 _N_ _N_ _F_ _IF_ARGS_ 0 3 XXX 3 \ (u0 :: Int#) (u1 :: Int#) (u2 :: ByteArray#) -> case _#_ encodeFloat# [] [u0, u1, u2, 0#] of { _PRIM_ (u3 :: Float#) -> _!_ F# [] [u3] } _N_} _F_ _IF_ARGS_ 0 1 C 4 \ (u0 :: Integer) -> case u0 of { _ALG_ J# (u1 :: Int#) (u2 :: Int#) (u3 :: ByteArray#) -> case _#_ encodeFloat# [] [u1, u2, u3, 0#] of { _PRIM_ (u4 :: Float#) -> _!_ F# [] [u4] }; _NO_DEFLT_ } _N_,
- fromInt = _A_ 1 _U_ 1 _N_ _S_ "U(P)" {_A_ 1 _U_ 2 _N_ _N_ _F_ _IF_ARGS_ 0 1 X 3 \ (u0 :: Int#) -> case _#_ int2Float# [] [u0] of { _PRIM_ (u1 :: Float#) -> _!_ F# [] [u1] } _N_} _F_ _IF_ARGS_ 0 1 C 4 \ (u0 :: Int) -> case u0 of { _ALG_ I# (u1 :: Int#) -> case _#_ int2Float# [] [u1] of { _PRIM_ (u2 :: Float#) -> _!_ F# [] [u2] }; _NO_DEFLT_ } _N_ #-}
+ (+) = { _A_ 2 _U_ 11 _N_ _S_ "U(P)U(P)" {_A_ 2 _U_ 22 _N_ _N_ _F_ _IF_ARGS_ 0 2 XX 3 \ (u0 :: Float#) (u1 :: Float#) -> case _#_ plusFloat# [] [u0, u1] of { _PRIM_ (u2 :: Float#) -> _!_ F# [] [u2] } _N_} _F_ _IF_ARGS_ 0 2 CC 5 \ (u0 :: Float) (u1 :: Float) -> case u0 of { _ALG_ F# (u2 :: Float#) -> case u1 of { _ALG_ F# (u3 :: Float#) -> case _#_ plusFloat# [] [u2, u3] of { _PRIM_ (u4 :: Float#) -> _!_ F# [] [u4] }; _NO_DEFLT_ }; _NO_DEFLT_ } _N_ },
+ (-) = { _A_ 2 _U_ 11 _N_ _S_ "U(P)U(P)" {_A_ 2 _U_ 22 _N_ _N_ _F_ _IF_ARGS_ 0 2 XX 3 \ (u0 :: Float#) (u1 :: Float#) -> case _#_ minusFloat# [] [u0, u1] of { _PRIM_ (u2 :: Float#) -> _!_ F# [] [u2] } _N_} _F_ _IF_ARGS_ 0 2 CC 5 \ (u0 :: Float) (u1 :: Float) -> case u0 of { _ALG_ F# (u2 :: Float#) -> case u1 of { _ALG_ F# (u3 :: Float#) -> case _#_ minusFloat# [] [u2, u3] of { _PRIM_ (u4 :: Float#) -> _!_ F# [] [u4] }; _NO_DEFLT_ }; _NO_DEFLT_ } _N_ },
+ (*) = { _A_ 2 _U_ 11 _N_ _S_ "U(P)U(P)" {_A_ 2 _U_ 22 _N_ _N_ _F_ _IF_ARGS_ 0 2 XX 3 \ (u0 :: Float#) (u1 :: Float#) -> case _#_ timesFloat# [] [u0, u1] of { _PRIM_ (u2 :: Float#) -> _!_ F# [] [u2] } _N_} _F_ _IF_ARGS_ 0 2 CC 5 \ (u0 :: Float) (u1 :: Float) -> case u0 of { _ALG_ F# (u2 :: Float#) -> case u1 of { _ALG_ F# (u3 :: Float#) -> case _#_ timesFloat# [] [u2, u3] of { _PRIM_ (u4 :: Float#) -> _!_ F# [] [u4] }; _NO_DEFLT_ }; _NO_DEFLT_ } _N_ },
+ negate = { _A_ 1 _U_ 1 _N_ _S_ "U(P)" {_A_ 1 _U_ 2 _N_ _N_ _F_ _IF_ARGS_ 0 1 X 3 \ (u0 :: Float#) -> case _#_ negateFloat# [] [u0] of { _PRIM_ (u1 :: Float#) -> _!_ F# [] [u1] } _N_} _F_ _IF_ARGS_ 0 1 C 4 \ (u0 :: Float) -> case u0 of { _ALG_ F# (u1 :: Float#) -> case _#_ negateFloat# [] [u1] of { _PRIM_ (u2 :: Float#) -> _!_ F# [] [u2] }; _NO_DEFLT_ } _N_ },
+ abs = { _A_ 1 _U_ 1 _N_ _S_ "U(P)" {_A_ 1 _U_ 2 _N_ _N_ _N_ _N_} _N_ _N_ },
+ signum = { _A_ 1 _U_ 1 _N_ _S_ "U(P)" {_A_ 1 _U_ 2 _N_ _N_ _N_ _N_} _N_ _N_ },
+ fromInteger = { _A_ 1 _U_ 1 _N_ _S_ "U(PPP)" {_A_ 3 _U_ 222 _N_ _N_ _F_ _IF_ARGS_ 0 3 XXX 3 \ (u0 :: Int#) (u1 :: Int#) (u2 :: ByteArray#) -> case _#_ encodeFloat# [] [u0, u1, u2, 0#] of { _PRIM_ (u3 :: Float#) -> _!_ F# [] [u3] } _N_} _F_ _IF_ARGS_ 0 1 C 4 \ (u0 :: Integer) -> case u0 of { _ALG_ J# (u1 :: Int#) (u2 :: Int#) (u3 :: ByteArray#) -> case _#_ encodeFloat# [] [u1, u2, u3, 0#] of { _PRIM_ (u4 :: Float#) -> _!_ F# [] [u4] }; _NO_DEFLT_ } _N_ },
+ fromInt = { _A_ 1 _U_ 1 _N_ _S_ "U(P)" {_A_ 1 _U_ 2 _N_ _N_ _F_ _IF_ARGS_ 0 1 X 3 \ (u0 :: Int#) -> case _#_ int2Float# [] [u0] of { _PRIM_ (u1 :: Float#) -> _!_ F# [] [u1] } _N_} _F_ _IF_ARGS_ 0 1 C 4 \ (u0 :: Int) -> case u0 of { _ALG_ I# (u1 :: Int#) -> case _#_ int2Float# [] [u1] of { _PRIM_ (u2 :: Float#) -> _!_ F# [] [u2] }; _NO_DEFLT_ } _N_ } #-}
instance Num Int
{-# GHC_PRAGMA _M_ PreludeCore {-dfun-} _A_ 0 _N_ _N_ _N_ _F_ _IF_ARGS_ 0 0 X 11 _!_ _TUP_10 [{{Eq Int}}, {{Text Int}}, (Int -> Int -> Int), (Int -> Int -> Int), (Int -> Int -> Int), (Int -> Int), (Int -> Int), (Int -> Int), (Integer -> Int), (Int -> Int)] [_DFUN_ Eq (Int), _DFUN_ Text (Int), _CONSTM_ Num (+) (Int), _CONSTM_ Num (-) (Int), _CONSTM_ Num (*) (Int), _CONSTM_ Num negate (Int), _CONSTM_ Num abs (Int), _CONSTM_ Num signum (Int), _CONSTM_ Num fromInteger (Int), _CONSTM_ Num fromInt (Int)] _N_
- (+) = _A_ 2 _U_ 11 _N_ _S_ "U(P)U(P)" {_A_ 2 _U_ 22 _N_ _N_ _F_ _IF_ARGS_ 0 2 XX 3 \ (u0 :: Int#) (u1 :: Int#) -> case _#_ plusInt# [] [u0, u1] of { _PRIM_ (u2 :: Int#) -> _!_ I# [] [u2] } _N_} _F_ _IF_ARGS_ 0 2 CC 5 \ (u0 :: Int) (u1 :: Int) -> case u0 of { _ALG_ I# (u2 :: Int#) -> case u1 of { _ALG_ I# (u3 :: Int#) -> case _#_ plusInt# [] [u2, u3] of { _PRIM_ (u4 :: Int#) -> _!_ I# [] [u4] }; _NO_DEFLT_ }; _NO_DEFLT_ } _N_,
- (-) = _A_ 2 _U_ 11 _N_ _S_ "U(P)U(P)" {_A_ 2 _U_ 22 _N_ _N_ _F_ _IF_ARGS_ 0 2 XX 3 \ (u0 :: Int#) (u1 :: Int#) -> case _#_ minusInt# [] [u0, u1] of { _PRIM_ (u2 :: Int#) -> _!_ I# [] [u2] } _N_} _F_ _IF_ARGS_ 0 2 CC 5 \ (u0 :: Int) (u1 :: Int) -> case u0 of { _ALG_ I# (u2 :: Int#) -> case u1 of { _ALG_ I# (u3 :: Int#) -> case _#_ minusInt# [] [u2, u3] of { _PRIM_ (u4 :: Int#) -> _!_ I# [] [u4] }; _NO_DEFLT_ }; _NO_DEFLT_ } _N_,
- (*) = _A_ 2 _U_ 11 _N_ _S_ "U(P)U(P)" {_A_ 2 _U_ 22 _N_ _N_ _F_ _IF_ARGS_ 0 2 XX 3 \ (u0 :: Int#) (u1 :: Int#) -> case _#_ timesInt# [] [u0, u1] of { _PRIM_ (u2 :: Int#) -> _!_ I# [] [u2] } _N_} _F_ _IF_ARGS_ 0 2 CC 5 \ (u0 :: Int) (u1 :: Int) -> case u0 of { _ALG_ I# (u2 :: Int#) -> case u1 of { _ALG_ I# (u3 :: Int#) -> case _#_ timesInt# [] [u2, u3] of { _PRIM_ (u4 :: Int#) -> _!_ I# [] [u4] }; _NO_DEFLT_ }; _NO_DEFLT_ } _N_,
- negate = _A_ 1 _U_ 1 _N_ _S_ "U(P)" {_A_ 1 _U_ 2 _N_ _N_ _F_ _IF_ARGS_ 0 1 X 3 \ (u0 :: Int#) -> case _#_ negateInt# [] [u0] of { _PRIM_ (u1 :: Int#) -> _!_ I# [] [u1] } _N_} _F_ _IF_ARGS_ 0 1 C 4 \ (u0 :: Int) -> case u0 of { _ALG_ I# (u1 :: Int#) -> case _#_ negateInt# [] [u1] of { _PRIM_ (u2 :: Int#) -> _!_ I# [] [u2] }; _NO_DEFLT_ } _N_,
- abs = _A_ 1 _U_ 1 _N_ _S_ "U(P)" {_A_ 1 _U_ 2 _N_ _N_ _N_ _N_} _N_ _N_,
- signum = _A_ 1 _U_ 1 _N_ _S_ "U(P)" {_A_ 1 _U_ 2 _N_ _N_ _N_ _N_} _N_ _N_,
- fromInteger = _A_ 1 _U_ 1 _N_ _S_ "U(PPP)" {_A_ 3 _U_ 222 _N_ _N_ _F_ _IF_ARGS_ 0 3 XXX 3 \ (u0 :: Int#) (u1 :: Int#) (u2 :: ByteArray#) -> case _#_ integer2Int# [] [u0, u1, u2] of { _PRIM_ (u3 :: Int#) -> _!_ I# [] [u3] } _N_} _F_ _IF_ARGS_ 0 1 C 4 \ (u0 :: Integer) -> case u0 of { _ALG_ J# (u1 :: Int#) (u2 :: Int#) (u3 :: ByteArray#) -> case _#_ integer2Int# [] [u1, u2, u3] of { _PRIM_ (u4 :: Int#) -> _!_ I# [] [u4] }; _NO_DEFLT_ } _N_,
- fromInt = _A_ 1 _U_ 1 _N_ _S_ "U(P)" {_A_ 1 _U_ 2 _N_ _N_ _F_ _IF_ARGS_ 0 1 X 2 \ (u0 :: Int#) -> _!_ I# [] [u0] _N_} _F_ _IF_ARGS_ 0 1 X 1 \ (u0 :: Int) -> u0 _N_ #-}
+ (+) = { _A_ 2 _U_ 11 _N_ _S_ "U(P)U(P)" {_A_ 2 _U_ 22 _N_ _N_ _F_ _IF_ARGS_ 0 2 XX 3 \ (u0 :: Int#) (u1 :: Int#) -> case _#_ plusInt# [] [u0, u1] of { _PRIM_ (u2 :: Int#) -> _!_ I# [] [u2] } _N_} _F_ _IF_ARGS_ 0 2 CC 5 \ (u0 :: Int) (u1 :: Int) -> case u0 of { _ALG_ I# (u2 :: Int#) -> case u1 of { _ALG_ I# (u3 :: Int#) -> case _#_ plusInt# [] [u2, u3] of { _PRIM_ (u4 :: Int#) -> _!_ I# [] [u4] }; _NO_DEFLT_ }; _NO_DEFLT_ } _N_ },
+ (-) = { _A_ 2 _U_ 11 _N_ _S_ "U(P)U(P)" {_A_ 2 _U_ 22 _N_ _N_ _F_ _IF_ARGS_ 0 2 XX 3 \ (u0 :: Int#) (u1 :: Int#) -> case _#_ minusInt# [] [u0, u1] of { _PRIM_ (u2 :: Int#) -> _!_ I# [] [u2] } _N_} _F_ _IF_ARGS_ 0 2 CC 5 \ (u0 :: Int) (u1 :: Int) -> case u0 of { _ALG_ I# (u2 :: Int#) -> case u1 of { _ALG_ I# (u3 :: Int#) -> case _#_ minusInt# [] [u2, u3] of { _PRIM_ (u4 :: Int#) -> _!_ I# [] [u4] }; _NO_DEFLT_ }; _NO_DEFLT_ } _N_ },
+ (*) = { _A_ 2 _U_ 11 _N_ _S_ "U(P)U(P)" {_A_ 2 _U_ 22 _N_ _N_ _F_ _IF_ARGS_ 0 2 XX 3 \ (u0 :: Int#) (u1 :: Int#) -> case _#_ timesInt# [] [u0, u1] of { _PRIM_ (u2 :: Int#) -> _!_ I# [] [u2] } _N_} _F_ _IF_ARGS_ 0 2 CC 5 \ (u0 :: Int) (u1 :: Int) -> case u0 of { _ALG_ I# (u2 :: Int#) -> case u1 of { _ALG_ I# (u3 :: Int#) -> case _#_ timesInt# [] [u2, u3] of { _PRIM_ (u4 :: Int#) -> _!_ I# [] [u4] }; _NO_DEFLT_ }; _NO_DEFLT_ } _N_ },
+ negate = { _A_ 1 _U_ 1 _N_ _S_ "U(P)" {_A_ 1 _U_ 2 _N_ _N_ _F_ _IF_ARGS_ 0 1 X 3 \ (u0 :: Int#) -> case _#_ negateInt# [] [u0] of { _PRIM_ (u1 :: Int#) -> _!_ I# [] [u1] } _N_} _F_ _IF_ARGS_ 0 1 C 4 \ (u0 :: Int) -> case u0 of { _ALG_ I# (u1 :: Int#) -> case _#_ negateInt# [] [u1] of { _PRIM_ (u2 :: Int#) -> _!_ I# [] [u2] }; _NO_DEFLT_ } _N_ },
+ abs = { _A_ 1 _U_ 1 _N_ _S_ "U(P)" {_A_ 1 _U_ 2 _N_ _N_ _N_ _N_} _N_ _N_ },
+ signum = { _A_ 1 _U_ 1 _N_ _S_ "U(P)" {_A_ 1 _U_ 2 _N_ _N_ _N_ _N_} _N_ _N_ },
+ fromInteger = { _A_ 1 _U_ 1 _N_ _S_ "U(PPP)" {_A_ 3 _U_ 222 _N_ _N_ _F_ _IF_ARGS_ 0 3 XXX 3 \ (u0 :: Int#) (u1 :: Int#) (u2 :: ByteArray#) -> case _#_ integer2Int# [] [u0, u1, u2] of { _PRIM_ (u3 :: Int#) -> _!_ I# [] [u3] } _N_} _F_ _IF_ARGS_ 0 1 C 4 \ (u0 :: Integer) -> case u0 of { _ALG_ J# (u1 :: Int#) (u2 :: Int#) (u3 :: ByteArray#) -> case _#_ integer2Int# [] [u1, u2, u3] of { _PRIM_ (u4 :: Int#) -> _!_ I# [] [u4] }; _NO_DEFLT_ } _N_ },
+ fromInt = { _A_ 1 _U_ 1 _N_ _S_ "U(P)" {_A_ 1 _U_ 2 _N_ _N_ _F_ _IF_ARGS_ 0 1 X 2 \ (u0 :: Int#) -> _!_ I# [] [u0] _N_} _F_ _IF_ARGS_ 0 1 X 1 \ (u0 :: Int) -> u0 _N_ } #-}
instance Num Integer
{-# GHC_PRAGMA _M_ PreludeCore {-dfun-} _A_ 0 _N_ _N_ _N_ _F_ _IF_ARGS_ 0 0 X 11 _!_ _TUP_10 [{{Eq Integer}}, {{Text Integer}}, (Integer -> Integer -> Integer), (Integer -> Integer -> Integer), (Integer -> Integer -> Integer), (Integer -> Integer), (Integer -> Integer), (Integer -> Integer), (Integer -> Integer), (Int -> Integer)] [_DFUN_ Eq (Integer), _DFUN_ Text (Integer), _CONSTM_ Num (+) (Integer), _CONSTM_ Num (-) (Integer), _CONSTM_ Num (*) (Integer), _CONSTM_ Num negate (Integer), _CONSTM_ Num abs (Integer), _CONSTM_ Num signum (Integer), _CONSTM_ Num fromInteger (Integer), _CONSTM_ Num fromInt (Integer)] _N_
- (+) = _A_ 2 _U_ 11 _N_ _S_ "U(PPP)U(PPP)" {_A_ 4 _U_ 2221 _N_ _N_ _F_ _IF_ARGS_ 0 4 XXXC 5 \ (u0 :: Int#) (u1 :: Int#) (u2 :: ByteArray#) (u3 :: Integer) -> case u3 of { _ALG_ J# (u4 :: Int#) (u5 :: Int#) (u6 :: ByteArray#) -> _#_ plusInteger# [] [u0, u1, u2, u4, u5, u6]; _NO_DEFLT_ } _N_} _F_ _IF_ARGS_ 0 2 CC 6 \ (u0 :: Integer) (u1 :: Integer) -> case u0 of { _ALG_ J# (u2 :: Int#) (u3 :: Int#) (u4 :: ByteArray#) -> case u1 of { _ALG_ J# (u5 :: Int#) (u6 :: Int#) (u7 :: ByteArray#) -> _#_ plusInteger# [] [u2, u3, u4, u5, u6, u7]; _NO_DEFLT_ }; _NO_DEFLT_ } _N_,
- (-) = _A_ 2 _U_ 11 _N_ _S_ "U(PPP)U(PPP)" {_A_ 4 _U_ 2221 _N_ _N_ _F_ _IF_ARGS_ 0 4 XXXC 5 \ (u0 :: Int#) (u1 :: Int#) (u2 :: ByteArray#) (u3 :: Integer) -> case u3 of { _ALG_ J# (u4 :: Int#) (u5 :: Int#) (u6 :: ByteArray#) -> _#_ minusInteger# [] [u0, u1, u2, u4, u5, u6]; _NO_DEFLT_ } _N_} _F_ _IF_ARGS_ 0 2 CC 6 \ (u0 :: Integer) (u1 :: Integer) -> case u0 of { _ALG_ J# (u2 :: Int#) (u3 :: Int#) (u4 :: ByteArray#) -> case u1 of { _ALG_ J# (u5 :: Int#) (u6 :: Int#) (u7 :: ByteArray#) -> _#_ minusInteger# [] [u2, u3, u4, u5, u6, u7]; _NO_DEFLT_ }; _NO_DEFLT_ } _N_,
- (*) = _A_ 2 _U_ 11 _N_ _S_ "U(PPP)U(PPP)" {_A_ 4 _U_ 2221 _N_ _N_ _F_ _IF_ARGS_ 0 4 XXXC 5 \ (u0 :: Int#) (u1 :: Int#) (u2 :: ByteArray#) (u3 :: Integer) -> case u3 of { _ALG_ J# (u4 :: Int#) (u5 :: Int#) (u6 :: ByteArray#) -> _#_ timesInteger# [] [u0, u1, u2, u4, u5, u6]; _NO_DEFLT_ } _N_} _F_ _IF_ARGS_ 0 2 CC 6 \ (u0 :: Integer) (u1 :: Integer) -> case u0 of { _ALG_ J# (u2 :: Int#) (u3 :: Int#) (u4 :: ByteArray#) -> case u1 of { _ALG_ J# (u5 :: Int#) (u6 :: Int#) (u7 :: ByteArray#) -> _#_ timesInteger# [] [u2, u3, u4, u5, u6, u7]; _NO_DEFLT_ }; _NO_DEFLT_ } _N_,
- negate = _A_ 1 _U_ 1 _N_ _S_ "U(PPP)" {_A_ 3 _U_ 222 _N_ _N_ _F_ _IF_ARGS_ 0 3 XXX 4 \ (u0 :: Int#) (u1 :: Int#) (u2 :: ByteArray#) -> _#_ negateInteger# [] [u0, u1, u2] _N_} _F_ _IF_ARGS_ 0 1 C 5 \ (u0 :: Integer) -> case u0 of { _ALG_ J# (u1 :: Int#) (u2 :: Int#) (u3 :: ByteArray#) -> _#_ negateInteger# [] [u1, u2, u3]; _NO_DEFLT_ } _N_,
- abs = _A_ 1 _U_ 1 _N_ _S_ "U(PPP)" {_A_ 3 _U_ 222 _N_ _N_ _N_ _N_} _N_ _N_,
- signum = _A_ 1 _U_ 1 _N_ _S_ "U(PPP)" {_A_ 3 _U_ 222 _N_ _N_ _N_ _N_} _N_ _N_,
- fromInteger = _A_ 1 _U_ 1 _N_ _S_ "U(PPP)" {_A_ 3 _U_ 222 _N_ _N_ _F_ _IF_ARGS_ 0 3 XXX 4 \ (u0 :: Int#) (u1 :: Int#) (u2 :: ByteArray#) -> _!_ J# [] [u0, u1, u2] _N_} _F_ _IF_ARGS_ 0 1 X 1 \ (u0 :: Integer) -> u0 _N_,
- fromInt = _A_ 1 _U_ 1 _N_ _S_ "U(P)" {_A_ 1 _U_ 2 _N_ _N_ _F_ _IF_ARGS_ 0 1 X 1 \ (u0 :: Int#) -> _#_ int2Integer# [] [u0] _N_} _F_ _IF_ARGS_ 0 1 C 2 \ (u0 :: Int) -> case u0 of { _ALG_ I# (u1 :: Int#) -> _#_ int2Integer# [] [u1]; _NO_DEFLT_ } _N_ #-}
+ (+) = { _A_ 2 _U_ 11 _N_ _S_ "U(PPP)U(PPP)" {_A_ 4 _U_ 2221 _N_ _N_ _F_ _IF_ARGS_ 0 4 XXXC 5 \ (u0 :: Int#) (u1 :: Int#) (u2 :: ByteArray#) (u3 :: Integer) -> case u3 of { _ALG_ J# (u4 :: Int#) (u5 :: Int#) (u6 :: ByteArray#) -> _#_ plusInteger# [] [u0, u1, u2, u4, u5, u6]; _NO_DEFLT_ } _N_} _F_ _IF_ARGS_ 0 2 CC 6 \ (u0 :: Integer) (u1 :: Integer) -> case u0 of { _ALG_ J# (u2 :: Int#) (u3 :: Int#) (u4 :: ByteArray#) -> case u1 of { _ALG_ J# (u5 :: Int#) (u6 :: Int#) (u7 :: ByteArray#) -> _#_ plusInteger# [] [u2, u3, u4, u5, u6, u7]; _NO_DEFLT_ }; _NO_DEFLT_ } _N_ },
+ (-) = { _A_ 2 _U_ 11 _N_ _S_ "U(PPP)U(PPP)" {_A_ 4 _U_ 2221 _N_ _N_ _F_ _IF_ARGS_ 0 4 XXXC 5 \ (u0 :: Int#) (u1 :: Int#) (u2 :: ByteArray#) (u3 :: Integer) -> case u3 of { _ALG_ J# (u4 :: Int#) (u5 :: Int#) (u6 :: ByteArray#) -> _#_ minusInteger# [] [u0, u1, u2, u4, u5, u6]; _NO_DEFLT_ } _N_} _F_ _IF_ARGS_ 0 2 CC 6 \ (u0 :: Integer) (u1 :: Integer) -> case u0 of { _ALG_ J# (u2 :: Int#) (u3 :: Int#) (u4 :: ByteArray#) -> case u1 of { _ALG_ J# (u5 :: Int#) (u6 :: Int#) (u7 :: ByteArray#) -> _#_ minusInteger# [] [u2, u3, u4, u5, u6, u7]; _NO_DEFLT_ }; _NO_DEFLT_ } _N_ },
+ (*) = { _A_ 2 _U_ 11 _N_ _S_ "U(PPP)U(PPP)" {_A_ 4 _U_ 2221 _N_ _N_ _F_ _IF_ARGS_ 0 4 XXXC 5 \ (u0 :: Int#) (u1 :: Int#) (u2 :: ByteArray#) (u3 :: Integer) -> case u3 of { _ALG_ J# (u4 :: Int#) (u5 :: Int#) (u6 :: ByteArray#) -> _#_ timesInteger# [] [u0, u1, u2, u4, u5, u6]; _NO_DEFLT_ } _N_} _F_ _IF_ARGS_ 0 2 CC 6 \ (u0 :: Integer) (u1 :: Integer) -> case u0 of { _ALG_ J# (u2 :: Int#) (u3 :: Int#) (u4 :: ByteArray#) -> case u1 of { _ALG_ J# (u5 :: Int#) (u6 :: Int#) (u7 :: ByteArray#) -> _#_ timesInteger# [] [u2, u3, u4, u5, u6, u7]; _NO_DEFLT_ }; _NO_DEFLT_ } _N_ },
+ negate = { _A_ 1 _U_ 1 _N_ _S_ "U(PPP)" {_A_ 3 _U_ 222 _N_ _N_ _F_ _IF_ARGS_ 0 3 XXX 4 \ (u0 :: Int#) (u1 :: Int#) (u2 :: ByteArray#) -> _#_ negateInteger# [] [u0, u1, u2] _N_} _F_ _IF_ARGS_ 0 1 C 5 \ (u0 :: Integer) -> case u0 of { _ALG_ J# (u1 :: Int#) (u2 :: Int#) (u3 :: ByteArray#) -> _#_ negateInteger# [] [u1, u2, u3]; _NO_DEFLT_ } _N_ },
+ abs = { _A_ 1 _U_ 1 _N_ _S_ "U(PPP)" {_A_ 3 _U_ 222 _N_ _N_ _N_ _N_} _N_ _N_ },
+ signum = { _A_ 1 _U_ 1 _N_ _S_ "U(PPP)" {_A_ 3 _U_ 222 _N_ _N_ _N_ _N_} _N_ _N_ },
+ fromInteger = { _A_ 1 _U_ 1 _N_ _S_ "U(PPP)" {_A_ 3 _U_ 222 _N_ _N_ _F_ _IF_ARGS_ 0 3 XXX 4 \ (u0 :: Int#) (u1 :: Int#) (u2 :: ByteArray#) -> _!_ J# [] [u0, u1, u2] _N_} _F_ _IF_ARGS_ 0 1 X 1 \ (u0 :: Integer) -> u0 _N_ },
+ fromInt = { _A_ 1 _U_ 1 _N_ _S_ "U(P)" {_A_ 1 _U_ 2 _N_ _N_ _F_ _IF_ARGS_ 0 1 X 1 \ (u0 :: Int#) -> _#_ int2Integer# [] [u0] _N_} _F_ _IF_ARGS_ 0 1 C 2 \ (u0 :: Int) -> case u0 of { _ALG_ I# (u1 :: Int#) -> _#_ int2Integer# [] [u1]; _NO_DEFLT_ } _N_ } #-}
instance Integral a => Num (Ratio a)
{-# GHC_PRAGMA _M_ PreludeRatio {-dfun-} _A_ 3 _U_ 222 _N_ _N_ _N_ _N_ #-}
instance Num (Ratio Integer)
{-# GHC_PRAGMA _M_ PreludeRatio {-dfun-} _A_ 0 _N_ _N_ _N_ _F_ _IF_ARGS_ 0 0 X 11 _!_ _TUP_10 [{{Eq (Ratio Integer)}}, {{Text (Ratio Integer)}}, (Ratio Integer -> Ratio Integer -> Ratio Integer), (Ratio Integer -> Ratio Integer -> Ratio Integer), (Ratio Integer -> Ratio Integer -> Ratio Integer), (Ratio Integer -> Ratio Integer), (Ratio Integer -> Ratio Integer), (Ratio Integer -> Ratio Integer), (Integer -> Ratio Integer), (Int -> Ratio Integer)] [_DFUN_ Eq (Ratio Integer), _DFUN_ Text (Ratio Integer), _CONSTM_ Num (+) (Ratio Integer), _CONSTM_ Num (-) (Ratio Integer), _CONSTM_ Num (*) (Ratio Integer), _CONSTM_ Num negate (Ratio Integer), _CONSTM_ Num abs (Ratio Integer), _CONSTM_ Num signum (Ratio Integer), _CONSTM_ Num fromInteger (Ratio Integer), _CONSTM_ Num fromInt (Ratio Integer)] _N_
- (+) = _A_ 2 _U_ 11 _N_ _S_ "U(LU(PPP))U(LU(PPP))" {_A_ 5 _U_ 12221 _N_ _N_ _N_ _N_} _N_ _N_,
- (-) = _A_ 2 _U_ 11 _N_ _S_ "U(LU(PPP))U(LU(PPP))" {_A_ 5 _U_ 12221 _N_ _N_ _N_ _N_} _N_ _N_,
- (*) = _A_ 2 _U_ 11 _N_ _S_ "U(LU(PPP))U(LU(PPP))" {_A_ 5 _U_ 22221 _N_ _N_ _N_ _N_} _N_ _N_,
- negate = _A_ 1 _U_ 1 _N_ _S_ "U(LL)" {_A_ 2 _U_ 22 _N_ _N_ _N_ _N_} _N_ _N_,
- abs = _A_ 1 _U_ 1 _N_ _S_ "U(LL)" {_A_ 2 _U_ 12 _N_ _N_ _N_ _N_} _N_ _N_,
- signum = _A_ 1 _U_ 1 _N_ _S_ "U(LA)" {_A_ 1 _U_ 1 _N_ _N_ _N_ _N_} _N_ _N_,
- fromInteger = _A_ 1 _U_ 2 _N_ _N_ _N_ _N_,
- fromInt = _A_ 1 _U_ 1 _N_ _N_ _N_ _N_ #-}
+ (+) = { _A_ 2 _U_ 11 _N_ _S_ "U(LU(PPP))U(LU(PPP))" {_A_ 5 _U_ 12221 _N_ _N_ _N_ _N_} _N_ _N_ },
+ (-) = { _A_ 2 _U_ 11 _N_ _S_ "U(LU(PPP))U(LU(PPP))" {_A_ 5 _U_ 12221 _N_ _N_ _N_ _N_} _N_ _N_ },
+ (*) = { _A_ 2 _U_ 11 _N_ _S_ "U(LU(PPP))U(LU(PPP))" {_A_ 5 _U_ 22221 _N_ _N_ _N_ _N_} _N_ _N_ },
+ negate = { _A_ 1 _U_ 1 _N_ _S_ "U(LL)" {_A_ 2 _U_ 22 _N_ _N_ _N_ _N_} _N_ _N_ },
+ abs = { _A_ 1 _U_ 1 _N_ _S_ "U(LL)" {_A_ 2 _U_ 12 _N_ _N_ _N_ _N_} _N_ _N_ },
+ signum = { _A_ 1 _U_ 1 _N_ _S_ "U(LA)" {_A_ 1 _U_ 1 _N_ _N_ _N_ _N_} _N_ _N_ },
+ fromInteger = { _A_ 1 _U_ 2 _N_ _N_ _F_ _IF_ARGS_ 0 1 X 3 \ (u0 :: Integer) -> _!_ (:%) [Integer] [u0, _SPEC_ _ORIG_ PreludeCore __i1 [ (Integer) ]] _N_ },
+ fromInt = { _A_ 1 _U_ 1 _N_ _N_ _N_ _N_ } #-}
instance Ord ()
{-# GHC_PRAGMA _M_ PreludeBuiltin {-dfun-} _A_ 0 _N_ _N_ _N_ _F_ _IF_ARGS_ 0 0 X 9 _!_ _TUP_8 [{{Eq ()}}, (() -> () -> Bool), (() -> () -> Bool), (() -> () -> Bool), (() -> () -> Bool), (() -> () -> ()), (() -> () -> ()), (() -> () -> _CMP_TAG)] [_DFUN_ Eq (()), _CONSTM_ Ord (<) (()), _CONSTM_ Ord (<=) (()), _CONSTM_ Ord (>=) (()), _CONSTM_ Ord (>) (()), _CONSTM_ Ord max (()), _CONSTM_ Ord min (()), _CONSTM_ Ord _tagCmp (())] _N_
- (<) = _A_ 2 _U_ 11 _N_ _S_ "EE" _F_ _IF_ARGS_ 0 2 CC 3 \ (u0 :: ()) (u1 :: ()) -> case u0 of { _ALG_ _TUP_0 -> case u1 of { _ALG_ _TUP_0 -> _!_ False [] []; _NO_DEFLT_ }; _NO_DEFLT_ } _N_,
- (<=) = _A_ 2 _U_ 11 _N_ _S_ "EE" _F_ _IF_ARGS_ 0 2 CC 3 \ (u0 :: ()) (u1 :: ()) -> case u0 of { _ALG_ _TUP_0 -> case u1 of { _ALG_ _TUP_0 -> _!_ True [] []; _NO_DEFLT_ }; _NO_DEFLT_ } _N_,
- (>=) = _A_ 2 _U_ 11 _N_ _S_ "EE" _F_ _IF_ARGS_ 0 2 CC 3 \ (u0 :: ()) (u1 :: ()) -> case u0 of { _ALG_ _TUP_0 -> case u1 of { _ALG_ _TUP_0 -> _!_ True [] []; _NO_DEFLT_ }; _NO_DEFLT_ } _N_,
- (>) = _A_ 2 _U_ 11 _N_ _S_ "EE" _F_ _IF_ARGS_ 0 2 CC 3 \ (u0 :: ()) (u1 :: ()) -> case u0 of { _ALG_ _TUP_0 -> case u1 of { _ALG_ _TUP_0 -> _!_ False [] []; _NO_DEFLT_ }; _NO_DEFLT_ } _N_,
- max = _A_ 2 _U_ 11 _N_ _S_ "EE" _F_ _IF_ARGS_ 0 2 CX 2 \ (u0 :: ()) (u1 :: ()) -> case u0 of { _ALG_ _TUP_0 -> u1; _NO_DEFLT_ } _N_,
- min = _A_ 2 _U_ 11 _N_ _S_ "EE" _F_ _IF_ARGS_ 0 2 CX 2 \ (u0 :: ()) (u1 :: ()) -> case u0 of { _ALG_ _TUP_0 -> u1; _NO_DEFLT_ } _N_,
- _tagCmp = _A_ 2 _U_ 11 _N_ _S_ "EE" _F_ _IF_ARGS_ 0 2 CC 3 \ (u0 :: ()) (u1 :: ()) -> case u0 of { _ALG_ _TUP_0 -> case u1 of { _ALG_ _TUP_0 -> _!_ _EQ [] []; _NO_DEFLT_ }; _NO_DEFLT_ } _N_ #-}
+ (<) = { _A_ 2 _U_ 11 _N_ _S_ "EE" _F_ _IF_ARGS_ 0 2 CC 3 \ (u0 :: ()) (u1 :: ()) -> case u0 of { _ALG_ _TUP_0 -> case u1 of { _ALG_ _TUP_0 -> _!_ False [] []; _NO_DEFLT_ }; _NO_DEFLT_ } _N_ },
+ (<=) = { _A_ 2 _U_ 11 _N_ _S_ "EE" _F_ _IF_ARGS_ 0 2 CC 3 \ (u0 :: ()) (u1 :: ()) -> case u0 of { _ALG_ _TUP_0 -> case u1 of { _ALG_ _TUP_0 -> _!_ True [] []; _NO_DEFLT_ }; _NO_DEFLT_ } _N_ },
+ (>=) = { _A_ 2 _U_ 11 _N_ _S_ "EE" _F_ _IF_ARGS_ 0 2 CC 3 \ (u0 :: ()) (u1 :: ()) -> case u0 of { _ALG_ _TUP_0 -> case u1 of { _ALG_ _TUP_0 -> _!_ True [] []; _NO_DEFLT_ }; _NO_DEFLT_ } _N_ },
+ (>) = { _A_ 2 _U_ 11 _N_ _S_ "EE" _F_ _IF_ARGS_ 0 2 CC 3 \ (u0 :: ()) (u1 :: ()) -> case u0 of { _ALG_ _TUP_0 -> case u1 of { _ALG_ _TUP_0 -> _!_ False [] []; _NO_DEFLT_ }; _NO_DEFLT_ } _N_ },
+ max = { _A_ 2 _U_ 11 _N_ _S_ "EE" _F_ _IF_ARGS_ 0 2 CX 2 \ (u0 :: ()) (u1 :: ()) -> case u0 of { _ALG_ _TUP_0 -> u1; _NO_DEFLT_ } _N_ },
+ min = { _A_ 2 _U_ 11 _N_ _S_ "EE" _F_ _IF_ARGS_ 0 2 CX 2 \ (u0 :: ()) (u1 :: ()) -> case u0 of { _ALG_ _TUP_0 -> u1; _NO_DEFLT_ } _N_ },
+ _tagCmp = { _A_ 2 _U_ 11 _N_ _S_ "EE" _F_ _IF_ARGS_ 0 2 CC 3 \ (u0 :: ()) (u1 :: ()) -> case u0 of { _ALG_ _TUP_0 -> case u1 of { _ALG_ _TUP_0 -> _!_ _EQ [] []; _NO_DEFLT_ }; _NO_DEFLT_ } _N_ } #-}
instance (Ord a, Ord b) => Ord (a, b)
{-# GHC_PRAGMA _M_ PreludeBuiltin {-dfun-} _A_ 3 _U_ 112 _N_ _N_ _N_ _N_ #-}
instance (Ord a, Ord b, Ord c) => Ord (a, b, c)
{-# GHC_PRAGMA _M_ PreludeBuiltin {-dfun-} _A_ 6 _U_ 111112 _N_ _N_ _N_ _N_ #-}
instance Ord (Int, Int)
{-# GHC_PRAGMA _M_ PreludeBuiltin {-dfun-} _A_ 0 _N_ _N_ _N_ _F_ _IF_ARGS_ 0 0 X 9 _!_ _TUP_8 [{{Eq (Int, Int)}}, ((Int, Int) -> (Int, Int) -> Bool), ((Int, Int) -> (Int, Int) -> Bool), ((Int, Int) -> (Int, Int) -> Bool), ((Int, Int) -> (Int, Int) -> Bool), ((Int, Int) -> (Int, Int) -> (Int, Int)), ((Int, Int) -> (Int, Int) -> (Int, Int)), ((Int, Int) -> (Int, Int) -> _CMP_TAG)] [_DFUN_ Eq ((Int, Int)), _CONSTM_ Ord (<) ((Int, Int)), _CONSTM_ Ord (<=) ((Int, Int)), _CONSTM_ Ord (>=) ((Int, Int)), _CONSTM_ Ord (>) ((Int, Int)), _CONSTM_ Ord max ((Int, Int)), _CONSTM_ Ord min ((Int, Int)), _CONSTM_ Ord _tagCmp ((Int, Int))] _N_
- (<) = _A_ 2 _U_ 11 _N_ _S_ "U(U(P)L)U(U(P)L)" {_A_ 4 _U_ 2121 _N_ _N_ _N_ _N_} _N_ _N_,
- (<=) = _A_ 2 _U_ 11 _N_ _S_ "U(U(P)L)U(U(P)L)" {_A_ 4 _U_ 2121 _N_ _N_ _N_ _N_} _N_ _N_,
- (>=) = _A_ 2 _U_ 11 _N_ _S_ "U(U(P)L)U(U(P)L)" {_A_ 4 _U_ 2121 _N_ _N_ _N_ _N_} _N_ _N_,
- (>) = _A_ 2 _U_ 11 _N_ _S_ "U(U(P)L)U(U(P)L)" {_A_ 4 _U_ 2121 _N_ _N_ _N_ _N_} _N_ _N_,
- max = _A_ 2 _U_ 11 _N_ _S_ "U(U(P)L)U(U(P)L)" {_A_ 4 _U_ 2222 _N_ _N_ _N_ _N_} _N_ _N_,
- min = _A_ 2 _U_ 11 _N_ _S_ "U(U(P)L)U(U(P)L)" {_A_ 4 _U_ 2222 _N_ _N_ _N_ _N_} _N_ _N_,
- _tagCmp = _A_ 2 _U_ 11 _N_ _S_ "U(U(P)L)U(U(P)L)" {_A_ 4 _U_ 2121 _N_ _N_ _N_ _N_} _N_ _N_ #-}
+ (<) = { _A_ 2 _U_ 11 _N_ _S_ "U(U(P)L)U(U(P)L)" {_A_ 4 _U_ 2121 _N_ _N_ _N_ _N_} _N_ _N_ },
+ (<=) = { _A_ 2 _U_ 11 _N_ _S_ "U(U(P)L)U(U(P)L)" {_A_ 4 _U_ 2121 _N_ _N_ _N_ _N_} _N_ _N_ },
+ (>=) = { _A_ 2 _U_ 11 _N_ _S_ "U(U(P)L)U(U(P)L)" {_A_ 4 _U_ 2121 _N_ _N_ _N_ _N_} _N_ _N_ },
+ (>) = { _A_ 2 _U_ 11 _N_ _S_ "U(U(P)L)U(U(P)L)" {_A_ 4 _U_ 2121 _N_ _N_ _N_ _N_} _N_ _N_ },
+ max = { _A_ 2 _U_ 11 _N_ _S_ "U(U(P)L)U(U(P)L)" {_A_ 4 _U_ 2222 _N_ _N_ _N_ _N_} _N_ _N_ },
+ min = { _A_ 2 _U_ 11 _N_ _S_ "U(U(P)L)U(U(P)L)" {_A_ 4 _U_ 2222 _N_ _N_ _N_ _N_} _N_ _N_ },
+ _tagCmp = { _A_ 2 _U_ 11 _N_ _S_ "U(U(P)L)U(U(P)L)" {_A_ 4 _U_ 2121 _N_ _N_ _N_ _N_} _N_ _N_ } #-}
+instance Ord (Int, Int, Int)
+ {-# GHC_PRAGMA _M_ PreludeBuiltin {-dfun-} _A_ 0 _N_ _N_ _N_ _F_ _IF_ARGS_ 0 0 X 9 _!_ _TUP_8 [{{Eq (Int, Int, Int)}}, ((Int, Int, Int) -> (Int, Int, Int) -> Bool), ((Int, Int, Int) -> (Int, Int, Int) -> Bool), ((Int, Int, Int) -> (Int, Int, Int) -> Bool), ((Int, Int, Int) -> (Int, Int, Int) -> Bool), ((Int, Int, Int) -> (Int, Int, Int) -> (Int, Int, Int)), ((Int, Int, Int) -> (Int, Int, Int) -> (Int, Int, Int)), ((Int, Int, Int) -> (Int, Int, Int) -> _CMP_TAG)] [_DFUN_ Eq ((Int, Int, Int)), _CONSTM_ Ord (<) ((Int, Int, Int)), _CONSTM_ Ord (<=) ((Int, Int, Int)), _CONSTM_ Ord (>=) ((Int, Int, Int)), _CONSTM_ Ord (>) ((Int, Int, Int)), _CONSTM_ Ord max ((Int, Int, Int)), _CONSTM_ Ord min ((Int, Int, Int)), _CONSTM_ Ord _tagCmp ((Int, Int, Int))] _N_
+ (<) = { _A_ 2 _U_ 11 _N_ _S_ "U(U(P)LL)U(U(P)LL)" {_A_ 4 _U_ 2111 _N_ _N_ _N_ _N_} _N_ _N_ },
+ (<=) = { _A_ 2 _U_ 11 _N_ _S_ "U(U(P)LL)U(U(P)LL)" {_A_ 4 _U_ 2111 _N_ _N_ _N_ _N_} _N_ _N_ },
+ (>=) = { _A_ 2 _U_ 11 _N_ _S_ "U(U(P)LL)U(U(P)LL)" {_A_ 4 _U_ 2111 _N_ _N_ _N_ _N_} _N_ _N_ },
+ (>) = { _A_ 2 _U_ 11 _N_ _S_ "U(U(P)LL)U(U(P)LL)" {_A_ 4 _U_ 2111 _N_ _N_ _N_ _N_} _N_ _N_ },
+ max = { _A_ 2 _U_ 12 _N_ _S_ "U(U(P)LL)U(U(P)LL)" {_A_ 4 _U_ 2222 _N_ _N_ _N_ _N_} _N_ _N_ },
+ min = { _A_ 2 _U_ 12 _N_ _S_ "U(U(P)LL)U(U(P)LL)" {_A_ 4 _U_ 2222 _N_ _N_ _N_ _N_} _N_ _N_ },
+ _tagCmp = { _A_ 2 _U_ 11 _N_ _S_ "U(U(P)LL)U(U(P)LL)" {_A_ 4 _U_ 2111 _N_ _N_ _N_ _N_} _N_ _N_ } #-}
+instance Ord (Int, Int, Int, Int)
+ {-# GHC_PRAGMA _M_ PreludeBuiltin {-dfun-} _A_ 0 _N_ _N_ _N_ _F_ _IF_ARGS_ 0 0 X 9 _!_ _TUP_8 [{{Eq (Int, Int, Int, Int)}}, ((Int, Int, Int, Int) -> (Int, Int, Int, Int) -> Bool), ((Int, Int, Int, Int) -> (Int, Int, Int, Int) -> Bool), ((Int, Int, Int, Int) -> (Int, Int, Int, Int) -> Bool), ((Int, Int, Int, Int) -> (Int, Int, Int, Int) -> Bool), ((Int, Int, Int, Int) -> (Int, Int, Int, Int) -> (Int, Int, Int, Int)), ((Int, Int, Int, Int) -> (Int, Int, Int, Int) -> (Int, Int, Int, Int)), ((Int, Int, Int, Int) -> (Int, Int, Int, Int) -> _CMP_TAG)] [_DFUN_ Eq ((Int, Int, Int, Int)), _CONSTM_ Ord (<) ((Int, Int, Int, Int)), _CONSTM_ Ord (<=) ((Int, Int, Int, Int)), _CONSTM_ Ord (>=) ((Int, Int, Int, Int)), _CONSTM_ Ord (>) ((Int, Int, Int, Int)), _CONSTM_ Ord max ((Int, Int, Int, Int)), _CONSTM_ Ord min ((Int, Int, Int, Int)), _CONSTM_ Ord _tagCmp ((Int, Int, Int, Int))] _N_
+ (<) = { _A_ 2 _U_ 11 _N_ _S_ "U(U(P)LLL)U(U(P)LLL)" {_A_ 5 _U_ 21111 _N_ _N_ _N_ _N_} _N_ _N_ },
+ (<=) = { _A_ 2 _U_ 11 _N_ _S_ "U(U(P)LLL)U(U(P)LLL)" {_A_ 5 _U_ 21111 _N_ _N_ _N_ _N_} _N_ _N_ },
+ (>=) = { _A_ 2 _U_ 11 _N_ _S_ "U(U(P)LLL)U(U(P)LLL)" {_A_ 5 _U_ 21111 _N_ _N_ _N_ _N_} _N_ _N_ },
+ (>) = { _A_ 2 _U_ 11 _N_ _S_ "U(U(P)LLL)U(U(P)LLL)" {_A_ 5 _U_ 21111 _N_ _N_ _N_ _N_} _N_ _N_ },
+ max = { _A_ 2 _U_ 12 _N_ _S_ "U(U(P)LLL)U(U(P)LLL)" {_A_ 5 _U_ 22222 _N_ _N_ _N_ _N_} _N_ _N_ },
+ min = { _A_ 2 _U_ 12 _N_ _S_ "U(U(P)LLL)U(U(P)LLL)" {_A_ 5 _U_ 22222 _N_ _N_ _N_ _N_} _N_ _N_ },
+ _tagCmp = { _A_ 2 _U_ 11 _N_ _S_ "U(U(P)LLL)U(U(P)LLL)" {_A_ 5 _U_ 21111 _N_ _N_ _N_ _N_} _N_ _N_ } #-}
+instance Ord (Int, Int, Int, Int, Int)
+ {-# GHC_PRAGMA _M_ PreludeBuiltin {-dfun-} _A_ 0 _N_ _N_ _N_ _F_ _IF_ARGS_ 0 0 X 9 _!_ _TUP_8 [{{Eq (Int, Int, Int, Int, Int)}}, ((Int, Int, Int, Int, Int) -> (Int, Int, Int, Int, Int) -> Bool), ((Int, Int, Int, Int, Int) -> (Int, Int, Int, Int, Int) -> Bool), ((Int, Int, Int, Int, Int) -> (Int, Int, Int, Int, Int) -> Bool), ((Int, Int, Int, Int, Int) -> (Int, Int, Int, Int, Int) -> Bool), ((Int, Int, Int, Int, Int) -> (Int, Int, Int, Int, Int) -> (Int, Int, Int, Int, Int)), ((Int, Int, Int, Int, Int) -> (Int, Int, Int, Int, Int) -> (Int, Int, Int, Int, Int)), ((Int, Int, Int, Int, Int) -> (Int, Int, Int, Int, Int) -> _CMP_TAG)] [_DFUN_ Eq ((Int, Int, Int, Int, Int)), _CONSTM_ Ord (<) ((Int, Int, Int, Int, Int)), _CONSTM_ Ord (<=) ((Int, Int, Int, Int, Int)), _CONSTM_ Ord (>=) ((Int, Int, Int, Int, Int)), _CONSTM_ Ord (>) ((Int, Int, Int, Int, Int)), _CONSTM_ Ord max ((Int, Int, Int, Int, Int)), _CONSTM_ Ord min ((Int, Int, Int, Int, Int)), _CONSTM_ Ord _tagCmp ((Int, Int, Int, Int, Int))] _N_
+ (<) = { _A_ 2 _U_ 11 _N_ _S_ "U(U(P)LLLL)U(U(P)LLLL)" _N_ _N_ },
+ (<=) = { _A_ 2 _U_ 11 _N_ _S_ "U(U(P)LLLL)U(U(P)LLLL)" _N_ _N_ },
+ (>=) = { _A_ 2 _U_ 11 _N_ _S_ "U(U(P)LLLL)U(U(P)LLLL)" _N_ _N_ },
+ (>) = { _A_ 2 _U_ 11 _N_ _S_ "U(U(P)LLLL)U(U(P)LLLL)" _N_ _N_ },
+ max = { _A_ 2 _U_ 22 _N_ _S_ "U(U(P)LLLL)U(U(P)LLLL)" _N_ _N_ },
+ min = { _A_ 2 _U_ 22 _N_ _S_ "U(U(P)LLLL)U(U(P)LLLL)" _N_ _N_ },
+ _tagCmp = { _A_ 2 _U_ 11 _N_ _S_ "U(U(P)LLLL)U(U(P)LLLL)" _N_ _N_ } #-}
+instance Ord ([Char], [Char])
+ {-# GHC_PRAGMA _M_ PreludeBuiltin {-dfun-} _A_ 0 _N_ _N_ _N_ _F_ _IF_ARGS_ 0 0 X 9 _!_ _TUP_8 [{{Eq ([Char], [Char])}}, (([Char], [Char]) -> ([Char], [Char]) -> Bool), (([Char], [Char]) -> ([Char], [Char]) -> Bool), (([Char], [Char]) -> ([Char], [Char]) -> Bool), (([Char], [Char]) -> ([Char], [Char]) -> Bool), (([Char], [Char]) -> ([Char], [Char]) -> ([Char], [Char])), (([Char], [Char]) -> ([Char], [Char]) -> ([Char], [Char])), (([Char], [Char]) -> ([Char], [Char]) -> _CMP_TAG)] [_DFUN_ Eq (([Char], [Char])), _CONSTM_ Ord (<) (([Char], [Char])), _CONSTM_ Ord (<=) (([Char], [Char])), _CONSTM_ Ord (>=) (([Char], [Char])), _CONSTM_ Ord (>) (([Char], [Char])), _CONSTM_ Ord max (([Char], [Char])), _CONSTM_ Ord min (([Char], [Char])), _CONSTM_ Ord _tagCmp (([Char], [Char]))] _N_
+ (<) = { _A_ 2 _U_ 11 _N_ _S_ "U(SL)U(SL)" {_A_ 4 _U_ 2222 _N_ _N_ _N_ _N_} _N_ _N_ },
+ (<=) = { _A_ 2 _U_ 11 _N_ _S_ "U(SL)U(SL)" {_A_ 4 _U_ 2222 _N_ _N_ _N_ _N_} _N_ _N_ },
+ (>=) = { _A_ 2 _U_ 11 _N_ _S_ "U(SL)U(SL)" {_A_ 4 _U_ 2222 _N_ _N_ _N_ _N_} _N_ _N_ },
+ (>) = { _A_ 2 _U_ 11 _N_ _S_ "U(SL)U(SL)" {_A_ 4 _U_ 2222 _N_ _N_ _N_ _N_} _N_ _N_ },
+ max = { _A_ 2 _U_ 11 _N_ _S_ "U(SL)U(SL)" {_A_ 4 _U_ 2222 _N_ _N_ _N_ _N_} _N_ _N_ },
+ min = { _A_ 2 _U_ 11 _N_ _S_ "U(SL)U(SL)" {_A_ 4 _U_ 2222 _N_ _N_ _N_ _N_} _N_ _N_ },
+ _tagCmp = { _A_ 2 _U_ 11 _N_ _S_ "U(SL)U(SL)" {_A_ 4 _U_ 2222 _N_ _N_ _N_ _N_} _N_ _N_ } #-}
+instance Ord ([Int], [Int])
+ {-# GHC_PRAGMA _M_ PreludeBuiltin {-dfun-} _A_ 0 _N_ _N_ _N_ _F_ _IF_ARGS_ 0 0 X 9 _!_ _TUP_8 [{{Eq ([Int], [Int])}}, (([Int], [Int]) -> ([Int], [Int]) -> Bool), (([Int], [Int]) -> ([Int], [Int]) -> Bool), (([Int], [Int]) -> ([Int], [Int]) -> Bool), (([Int], [Int]) -> ([Int], [Int]) -> Bool), (([Int], [Int]) -> ([Int], [Int]) -> ([Int], [Int])), (([Int], [Int]) -> ([Int], [Int]) -> ([Int], [Int])), (([Int], [Int]) -> ([Int], [Int]) -> _CMP_TAG)] [_DFUN_ Eq (([Int], [Int])), _CONSTM_ Ord (<) (([Int], [Int])), _CONSTM_ Ord (<=) (([Int], [Int])), _CONSTM_ Ord (>=) (([Int], [Int])), _CONSTM_ Ord (>) (([Int], [Int])), _CONSTM_ Ord max (([Int], [Int])), _CONSTM_ Ord min (([Int], [Int])), _CONSTM_ Ord _tagCmp (([Int], [Int]))] _N_
+ (<) = { _A_ 2 _U_ 11 _N_ _S_ "U(SL)U(SL)" {_A_ 4 _U_ 2222 _N_ _N_ _N_ _N_} _N_ _N_ },
+ (<=) = { _A_ 2 _U_ 11 _N_ _S_ "U(SL)U(SL)" {_A_ 4 _U_ 2222 _N_ _N_ _N_ _N_} _N_ _N_ },
+ (>=) = { _A_ 2 _U_ 11 _N_ _S_ "U(SL)U(SL)" {_A_ 4 _U_ 2222 _N_ _N_ _N_ _N_} _N_ _N_ },
+ (>) = { _A_ 2 _U_ 11 _N_ _S_ "U(SL)U(SL)" {_A_ 4 _U_ 2222 _N_ _N_ _N_ _N_} _N_ _N_ },
+ max = { _A_ 2 _U_ 11 _N_ _S_ "U(SL)U(SL)" {_A_ 4 _U_ 2222 _N_ _N_ _N_ _N_} _N_ _N_ },
+ min = { _A_ 2 _U_ 11 _N_ _S_ "U(SL)U(SL)" {_A_ 4 _U_ 2222 _N_ _N_ _N_ _N_} _N_ _N_ },
+ _tagCmp = { _A_ 2 _U_ 11 _N_ _S_ "U(SL)U(SL)" {_A_ 4 _U_ 2222 _N_ _N_ _N_ _N_} _N_ _N_ } #-}
instance Ord (_PackedString, _PackedString)
{-# GHC_PRAGMA _M_ PreludeBuiltin {-dfun-} _A_ 0 _N_ _N_ _N_ _F_ _IF_ARGS_ 0 0 X 9 _!_ _TUP_8 [{{Eq (_PackedString, _PackedString)}}, ((_PackedString, _PackedString) -> (_PackedString, _PackedString) -> Bool), ((_PackedString, _PackedString) -> (_PackedString, _PackedString) -> Bool), ((_PackedString, _PackedString) -> (_PackedString, _PackedString) -> Bool), ((_PackedString, _PackedString) -> (_PackedString, _PackedString) -> Bool), ((_PackedString, _PackedString) -> (_PackedString, _PackedString) -> (_PackedString, _PackedString)), ((_PackedString, _PackedString) -> (_PackedString, _PackedString) -> (_PackedString, _PackedString)), ((_PackedString, _PackedString) -> (_PackedString, _PackedString) -> _CMP_TAG)] [_DFUN_ Eq ((_PackedString, _PackedString)), _CONSTM_ Ord (<) ((_PackedString, _PackedString)), _CONSTM_ Ord (<=) ((_PackedString, _PackedString)), _CONSTM_ Ord (>=) ((_PackedString, _PackedString)), _CONSTM_ Ord (>) ((_PackedString, _PackedString)), _CONSTM_ Ord max ((_PackedString, _PackedString)), _CONSTM_ Ord min ((_PackedString, _PackedString)), _CONSTM_ Ord _tagCmp ((_PackedString, _PackedString))] _N_
- (<) = _A_ 2 _U_ 11 _N_ _S_ "U(SL)U(SL)" {_A_ 4 _U_ 2222 _N_ _N_ _N_ _N_} _N_ _N_,
- (<=) = _A_ 2 _U_ 11 _N_ _S_ "U(SL)U(SL)" {_A_ 4 _U_ 2222 _N_ _N_ _N_ _N_} _N_ _N_,
- (>=) = _A_ 2 _U_ 11 _N_ _S_ "U(SL)U(SL)" {_A_ 4 _U_ 2222 _N_ _N_ _N_ _N_} _N_ _N_,
- (>) = _A_ 2 _U_ 11 _N_ _S_ "U(SL)U(SL)" {_A_ 4 _U_ 2222 _N_ _N_ _N_ _N_} _N_ _N_,
- max = _A_ 2 _U_ 11 _N_ _S_ "U(SL)U(SL)" {_A_ 4 _U_ 2222 _N_ _N_ _N_ _N_} _N_ _N_,
- min = _A_ 2 _U_ 11 _N_ _S_ "U(SL)U(SL)" {_A_ 4 _U_ 2222 _N_ _N_ _N_ _N_} _N_ _N_,
- _tagCmp = _A_ 2 _U_ 11 _N_ _S_ "U(SL)U(SL)" {_A_ 4 _U_ 2222 _N_ _N_ _N_ _N_} _N_ _N_ #-}
+ (<) = { _A_ 2 _U_ 11 _N_ _S_ "U(SL)U(SL)" {_A_ 4 _U_ 2222 _N_ _N_ _N_ _N_} _N_ _N_ },
+ (<=) = { _A_ 2 _U_ 11 _N_ _S_ "U(SL)U(SL)" {_A_ 4 _U_ 2222 _N_ _N_ _N_ _N_} _N_ _N_ },
+ (>=) = { _A_ 2 _U_ 11 _N_ _S_ "U(SL)U(SL)" {_A_ 4 _U_ 2222 _N_ _N_ _N_ _N_} _N_ _N_ },
+ (>) = { _A_ 2 _U_ 11 _N_ _S_ "U(SL)U(SL)" {_A_ 4 _U_ 2222 _N_ _N_ _N_ _N_} _N_ _N_ },
+ max = { _A_ 2 _U_ 11 _N_ _S_ "U(SL)U(SL)" {_A_ 4 _U_ 2222 _N_ _N_ _N_ _N_} _N_ _N_ },
+ min = { _A_ 2 _U_ 11 _N_ _S_ "U(SL)U(SL)" {_A_ 4 _U_ 2222 _N_ _N_ _N_ _N_} _N_ _N_ },
+ _tagCmp = { _A_ 2 _U_ 11 _N_ _S_ "U(SL)U(SL)" {_A_ 4 _U_ 2222 _N_ _N_ _N_ _N_} _N_ _N_ } #-}
instance (Ix a, Ord b) => Ord (Array a b)
{-# GHC_PRAGMA _M_ PreludeArray {-dfun-} _A_ 3 _U_ 222 _N_ _N_ _N_ _N_ #-}
instance (Ord a, Ord b) => Ord (Assoc a b)
{-# GHC_PRAGMA _M_ PreludeArray {-dfun-} _A_ 3 _U_ 112 _N_ _N_ _N_ _N_ #-}
instance Ord Bool
{-# GHC_PRAGMA _M_ PreludeCore {-dfun-} _A_ 0 _N_ _N_ _N_ _F_ _IF_ARGS_ 0 0 X 9 _!_ _TUP_8 [{{Eq Bool}}, (Bool -> Bool -> Bool), (Bool -> Bool -> Bool), (Bool -> Bool -> Bool), (Bool -> Bool -> Bool), (Bool -> Bool -> Bool), (Bool -> Bool -> Bool), (Bool -> Bool -> _CMP_TAG)] [_DFUN_ Eq (Bool), _CONSTM_ Ord (<) (Bool), _CONSTM_ Ord (<=) (Bool), _CONSTM_ Ord (>=) (Bool), _CONSTM_ Ord (>) (Bool), _CONSTM_ Ord max (Bool), _CONSTM_ Ord min (Bool), _CONSTM_ Ord _tagCmp (Bool)] _N_
- (<) = _A_ 2 _U_ 11 _N_ _S_ "EE" _N_ _N_,
- (<=) = _A_ 2 _U_ 11 _N_ _S_ "EE" _N_ _N_,
- (>=) = _A_ 2 _U_ 11 _N_ _S_ "EE" _N_ _N_,
- (>) = _A_ 2 _U_ 11 _N_ _S_ "EE" _N_ _N_,
- max = _A_ 2 _U_ 22 _N_ _S_ "EE" _N_ _N_,
- min = _A_ 2 _U_ 22 _N_ _S_ "EE" _N_ _N_,
- _tagCmp = _A_ 2 _U_ 11 _N_ _S_ "EE" _N_ _N_ #-}
+ (<) = { _A_ 2 _U_ 11 _N_ _S_ "EE" _N_ _N_ },
+ (<=) = { _A_ 2 _U_ 11 _N_ _S_ "EE" _N_ _N_ },
+ (>=) = { _A_ 2 _U_ 11 _N_ _S_ "EE" _N_ _N_ },
+ (>) = { _A_ 2 _U_ 11 _N_ _S_ "EE" _N_ _N_ },
+ max = { _A_ 2 _U_ 22 _N_ _S_ "EE" _N_ _N_ },
+ min = { _A_ 2 _U_ 22 _N_ _S_ "EE" _N_ _N_ },
+ _tagCmp = { _A_ 2 _U_ 11 _N_ _S_ "EE" _N_ _N_ } #-}
instance Ord Char
{-# GHC_PRAGMA _M_ PreludeCore {-dfun-} _A_ 0 _N_ _N_ _N_ _F_ _IF_ARGS_ 0 0 X 9 _!_ _TUP_8 [{{Eq Char}}, (Char -> Char -> Bool), (Char -> Char -> Bool), (Char -> Char -> Bool), (Char -> Char -> Bool), (Char -> Char -> Char), (Char -> Char -> Char), (Char -> Char -> _CMP_TAG)] [_DFUN_ Eq (Char), _CONSTM_ Ord (<) (Char), _CONSTM_ Ord (<=) (Char), _CONSTM_ Ord (>=) (Char), _CONSTM_ Ord (>) (Char), _CONSTM_ Ord max (Char), _CONSTM_ Ord min (Char), _CONSTM_ Ord _tagCmp (Char)] _N_
- (<) = _A_ 2 _U_ 11 _N_ _S_ "U(P)U(P)" {_A_ 2 _U_ 22 _N_ _N_ _F_ _IF_ARGS_ 0 2 XX 1 \ (u0 :: Char#) (u1 :: Char#) -> _#_ ltChar# [] [u0, u1] _N_} _F_ _IF_ARGS_ 0 2 CC 3 \ (u0 :: Char) (u1 :: Char) -> case u0 of { _ALG_ C# (u2 :: Char#) -> case u1 of { _ALG_ C# (u3 :: Char#) -> _#_ ltChar# [] [u2, u3]; _NO_DEFLT_ }; _NO_DEFLT_ } _N_,
- (<=) = _A_ 2 _U_ 11 _N_ _S_ "U(P)U(P)" {_A_ 2 _U_ 22 _N_ _N_ _F_ _IF_ARGS_ 0 2 XX 1 \ (u0 :: Char#) (u1 :: Char#) -> _#_ leChar# [] [u0, u1] _N_} _F_ _IF_ARGS_ 0 2 CC 3 \ (u0 :: Char) (u1 :: Char) -> case u0 of { _ALG_ C# (u2 :: Char#) -> case u1 of { _ALG_ C# (u3 :: Char#) -> _#_ leChar# [] [u2, u3]; _NO_DEFLT_ }; _NO_DEFLT_ } _N_,
- (>=) = _A_ 2 _U_ 11 _N_ _S_ "U(P)U(P)" {_A_ 2 _U_ 22 _N_ _N_ _F_ _IF_ARGS_ 0 2 XX 1 \ (u0 :: Char#) (u1 :: Char#) -> _#_ geChar# [] [u0, u1] _N_} _F_ _IF_ARGS_ 0 2 CC 3 \ (u0 :: Char) (u1 :: Char) -> case u0 of { _ALG_ C# (u2 :: Char#) -> case u1 of { _ALG_ C# (u3 :: Char#) -> _#_ geChar# [] [u2, u3]; _NO_DEFLT_ }; _NO_DEFLT_ } _N_,
- (>) = _A_ 2 _U_ 11 _N_ _S_ "U(P)U(P)" {_A_ 2 _U_ 22 _N_ _N_ _F_ _IF_ARGS_ 0 2 XX 1 \ (u0 :: Char#) (u1 :: Char#) -> _#_ gtChar# [] [u0, u1] _N_} _F_ _IF_ARGS_ 0 2 CC 3 \ (u0 :: Char) (u1 :: Char) -> case u0 of { _ALG_ C# (u2 :: Char#) -> case u1 of { _ALG_ C# (u3 :: Char#) -> _#_ gtChar# [] [u2, u3]; _NO_DEFLT_ }; _NO_DEFLT_ } _N_,
- max = _A_ 2 _U_ 11 _N_ _S_ "U(P)U(P)" {_A_ 2 _U_ 22 _N_ _N_ _N_ _N_} _N_ _N_,
- min = _A_ 2 _U_ 11 _N_ _S_ "U(P)U(P)" {_A_ 2 _U_ 22 _N_ _N_ _N_ _N_} _N_ _N_,
- _tagCmp = _A_ 2 _U_ 11 _N_ _S_ "U(P)U(P)" {_A_ 2 _U_ 22 _N_ _N_ _N_ _N_} _N_ _N_ #-}
+ (<) = { _A_ 2 _U_ 11 _N_ _S_ "U(P)U(P)" {_A_ 2 _U_ 22 _N_ _N_ _F_ _IF_ARGS_ 0 2 XX 1 \ (u0 :: Char#) (u1 :: Char#) -> _#_ ltChar# [] [u0, u1] _N_} _F_ _IF_ARGS_ 0 2 CC 3 \ (u0 :: Char) (u1 :: Char) -> case u0 of { _ALG_ C# (u2 :: Char#) -> case u1 of { _ALG_ C# (u3 :: Char#) -> _#_ ltChar# [] [u2, u3]; _NO_DEFLT_ }; _NO_DEFLT_ } _N_ },
+ (<=) = { _A_ 2 _U_ 11 _N_ _S_ "U(P)U(P)" {_A_ 2 _U_ 22 _N_ _N_ _F_ _IF_ARGS_ 0 2 XX 1 \ (u0 :: Char#) (u1 :: Char#) -> _#_ leChar# [] [u0, u1] _N_} _F_ _IF_ARGS_ 0 2 CC 3 \ (u0 :: Char) (u1 :: Char) -> case u0 of { _ALG_ C# (u2 :: Char#) -> case u1 of { _ALG_ C# (u3 :: Char#) -> _#_ leChar# [] [u2, u3]; _NO_DEFLT_ }; _NO_DEFLT_ } _N_ },
+ (>=) = { _A_ 2 _U_ 11 _N_ _S_ "U(P)U(P)" {_A_ 2 _U_ 22 _N_ _N_ _F_ _IF_ARGS_ 0 2 XX 1 \ (u0 :: Char#) (u1 :: Char#) -> _#_ geChar# [] [u0, u1] _N_} _F_ _IF_ARGS_ 0 2 CC 3 \ (u0 :: Char) (u1 :: Char) -> case u0 of { _ALG_ C# (u2 :: Char#) -> case u1 of { _ALG_ C# (u3 :: Char#) -> _#_ geChar# [] [u2, u3]; _NO_DEFLT_ }; _NO_DEFLT_ } _N_ },
+ (>) = { _A_ 2 _U_ 11 _N_ _S_ "U(P)U(P)" {_A_ 2 _U_ 22 _N_ _N_ _F_ _IF_ARGS_ 0 2 XX 1 \ (u0 :: Char#) (u1 :: Char#) -> _#_ gtChar# [] [u0, u1] _N_} _F_ _IF_ARGS_ 0 2 CC 3 \ (u0 :: Char) (u1 :: Char) -> case u0 of { _ALG_ C# (u2 :: Char#) -> case u1 of { _ALG_ C# (u3 :: Char#) -> _#_ gtChar# [] [u2, u3]; _NO_DEFLT_ }; _NO_DEFLT_ } _N_ },
+ max = { _A_ 2 _U_ 11 _N_ _S_ "U(P)U(P)" {_A_ 2 _U_ 22 _N_ _N_ _N_ _N_} _N_ _N_ },
+ min = { _A_ 2 _U_ 11 _N_ _S_ "U(P)U(P)" {_A_ 2 _U_ 22 _N_ _N_ _N_ _N_} _N_ _N_ },
+ _tagCmp = { _A_ 2 _U_ 11 _N_ _S_ "U(P)U(P)" {_A_ 2 _U_ 22 _N_ _N_ _N_ _N_} _N_ _N_ } #-}
instance Ord Double
{-# GHC_PRAGMA _M_ PreludeCore {-dfun-} _A_ 0 _N_ _N_ _N_ _F_ _IF_ARGS_ 0 0 X 9 _!_ _TUP_8 [{{Eq Double}}, (Double -> Double -> Bool), (Double -> Double -> Bool), (Double -> Double -> Bool), (Double -> Double -> Bool), (Double -> Double -> Double), (Double -> Double -> Double), (Double -> Double -> _CMP_TAG)] [_DFUN_ Eq (Double), _CONSTM_ Ord (<) (Double), _CONSTM_ Ord (<=) (Double), _CONSTM_ Ord (>=) (Double), _CONSTM_ Ord (>) (Double), _CONSTM_ Ord max (Double), _CONSTM_ Ord min (Double), _CONSTM_ Ord _tagCmp (Double)] _N_
- (<) = _A_ 2 _U_ 11 _N_ _S_ "U(P)U(P)" {_A_ 2 _U_ 22 _N_ _N_ _F_ _IF_ARGS_ 0 2 XX 1 \ (u0 :: Double#) (u1 :: Double#) -> _#_ ltDouble# [] [u0, u1] _N_} _F_ _IF_ARGS_ 0 2 CC 3 \ (u0 :: Double) (u1 :: Double) -> case u0 of { _ALG_ D# (u2 :: Double#) -> case u1 of { _ALG_ D# (u3 :: Double#) -> _#_ ltDouble# [] [u2, u3]; _NO_DEFLT_ }; _NO_DEFLT_ } _N_,
- (<=) = _A_ 2 _U_ 11 _N_ _S_ "U(P)U(P)" {_A_ 2 _U_ 22 _N_ _N_ _F_ _IF_ARGS_ 0 2 XX 1 \ (u0 :: Double#) (u1 :: Double#) -> _#_ leDouble# [] [u0, u1] _N_} _F_ _IF_ARGS_ 0 2 CC 3 \ (u0 :: Double) (u1 :: Double) -> case u0 of { _ALG_ D# (u2 :: Double#) -> case u1 of { _ALG_ D# (u3 :: Double#) -> _#_ leDouble# [] [u2, u3]; _NO_DEFLT_ }; _NO_DEFLT_ } _N_,
- (>=) = _A_ 2 _U_ 11 _N_ _S_ "U(P)U(P)" {_A_ 2 _U_ 22 _N_ _N_ _F_ _IF_ARGS_ 0 2 XX 1 \ (u0 :: Double#) (u1 :: Double#) -> _#_ geDouble# [] [u0, u1] _N_} _F_ _IF_ARGS_ 0 2 CC 3 \ (u0 :: Double) (u1 :: Double) -> case u0 of { _ALG_ D# (u2 :: Double#) -> case u1 of { _ALG_ D# (u3 :: Double#) -> _#_ geDouble# [] [u2, u3]; _NO_DEFLT_ }; _NO_DEFLT_ } _N_,
- (>) = _A_ 2 _U_ 11 _N_ _S_ "U(P)U(P)" {_A_ 2 _U_ 22 _N_ _N_ _F_ _IF_ARGS_ 0 2 XX 1 \ (u0 :: Double#) (u1 :: Double#) -> _#_ gtDouble# [] [u0, u1] _N_} _F_ _IF_ARGS_ 0 2 CC 3 \ (u0 :: Double) (u1 :: Double) -> case u0 of { _ALG_ D# (u2 :: Double#) -> case u1 of { _ALG_ D# (u3 :: Double#) -> _#_ gtDouble# [] [u2, u3]; _NO_DEFLT_ }; _NO_DEFLT_ } _N_,
- max = _A_ 2 _U_ 11 _N_ _S_ "U(P)U(P)" {_A_ 2 _U_ 22 _N_ _N_ _N_ _N_} _N_ _N_,
- min = _A_ 2 _U_ 11 _N_ _S_ "U(P)U(P)" {_A_ 2 _U_ 22 _N_ _N_ _N_ _N_} _N_ _N_,
- _tagCmp = _A_ 2 _U_ 11 _N_ _S_ "U(P)U(P)" {_A_ 2 _U_ 22 _N_ _N_ _N_ _N_} _N_ _N_ #-}
+ (<) = { _A_ 2 _U_ 11 _N_ _S_ "U(P)U(P)" {_A_ 2 _U_ 22 _N_ _N_ _F_ _IF_ARGS_ 0 2 XX 1 \ (u0 :: Double#) (u1 :: Double#) -> _#_ ltDouble# [] [u0, u1] _N_} _F_ _IF_ARGS_ 0 2 CC 3 \ (u0 :: Double) (u1 :: Double) -> case u0 of { _ALG_ D# (u2 :: Double#) -> case u1 of { _ALG_ D# (u3 :: Double#) -> _#_ ltDouble# [] [u2, u3]; _NO_DEFLT_ }; _NO_DEFLT_ } _N_ },
+ (<=) = { _A_ 2 _U_ 11 _N_ _S_ "U(P)U(P)" {_A_ 2 _U_ 22 _N_ _N_ _F_ _IF_ARGS_ 0 2 XX 1 \ (u0 :: Double#) (u1 :: Double#) -> _#_ leDouble# [] [u0, u1] _N_} _F_ _IF_ARGS_ 0 2 CC 3 \ (u0 :: Double) (u1 :: Double) -> case u0 of { _ALG_ D# (u2 :: Double#) -> case u1 of { _ALG_ D# (u3 :: Double#) -> _#_ leDouble# [] [u2, u3]; _NO_DEFLT_ }; _NO_DEFLT_ } _N_ },
+ (>=) = { _A_ 2 _U_ 11 _N_ _S_ "U(P)U(P)" {_A_ 2 _U_ 22 _N_ _N_ _F_ _IF_ARGS_ 0 2 XX 1 \ (u0 :: Double#) (u1 :: Double#) -> _#_ geDouble# [] [u0, u1] _N_} _F_ _IF_ARGS_ 0 2 CC 3 \ (u0 :: Double) (u1 :: Double) -> case u0 of { _ALG_ D# (u2 :: Double#) -> case u1 of { _ALG_ D# (u3 :: Double#) -> _#_ geDouble# [] [u2, u3]; _NO_DEFLT_ }; _NO_DEFLT_ } _N_ },
+ (>) = { _A_ 2 _U_ 11 _N_ _S_ "U(P)U(P)" {_A_ 2 _U_ 22 _N_ _N_ _F_ _IF_ARGS_ 0 2 XX 1 \ (u0 :: Double#) (u1 :: Double#) -> _#_ gtDouble# [] [u0, u1] _N_} _F_ _IF_ARGS_ 0 2 CC 3 \ (u0 :: Double) (u1 :: Double) -> case u0 of { _ALG_ D# (u2 :: Double#) -> case u1 of { _ALG_ D# (u3 :: Double#) -> _#_ gtDouble# [] [u2, u3]; _NO_DEFLT_ }; _NO_DEFLT_ } _N_ },
+ max = { _A_ 2 _U_ 11 _N_ _S_ "U(P)U(P)" {_A_ 2 _U_ 22 _N_ _N_ _N_ _N_} _N_ _N_ },
+ min = { _A_ 2 _U_ 11 _N_ _S_ "U(P)U(P)" {_A_ 2 _U_ 22 _N_ _N_ _N_ _N_} _N_ _N_ },
+ _tagCmp = { _A_ 2 _U_ 11 _N_ _S_ "U(P)U(P)" {_A_ 2 _U_ 22 _N_ _N_ _N_ _N_} _N_ _N_ } #-}
instance (Ord a, Ord b) => Ord (Either a b)
{-# GHC_PRAGMA _M_ PreludeMonadicIO {-dfun-} _A_ 3 _U_ 222 _N_ _N_ _N_ _N_ #-}
instance Ord Float
{-# GHC_PRAGMA _M_ PreludeCore {-dfun-} _A_ 0 _N_ _N_ _N_ _F_ _IF_ARGS_ 0 0 X 9 _!_ _TUP_8 [{{Eq Float}}, (Float -> Float -> Bool), (Float -> Float -> Bool), (Float -> Float -> Bool), (Float -> Float -> Bool), (Float -> Float -> Float), (Float -> Float -> Float), (Float -> Float -> _CMP_TAG)] [_DFUN_ Eq (Float), _CONSTM_ Ord (<) (Float), _CONSTM_ Ord (<=) (Float), _CONSTM_ Ord (>=) (Float), _CONSTM_ Ord (>) (Float), _CONSTM_ Ord max (Float), _CONSTM_ Ord min (Float), _CONSTM_ Ord _tagCmp (Float)] _N_
- (<) = _A_ 2 _U_ 11 _N_ _S_ "U(P)U(P)" {_A_ 2 _U_ 22 _N_ _N_ _F_ _IF_ARGS_ 0 2 XX 1 \ (u0 :: Float#) (u1 :: Float#) -> _#_ ltFloat# [] [u0, u1] _N_} _F_ _IF_ARGS_ 0 2 CC 3 \ (u0 :: Float) (u1 :: Float) -> case u0 of { _ALG_ F# (u2 :: Float#) -> case u1 of { _ALG_ F# (u3 :: Float#) -> _#_ ltFloat# [] [u2, u3]; _NO_DEFLT_ }; _NO_DEFLT_ } _N_,
- (<=) = _A_ 2 _U_ 11 _N_ _S_ "U(P)U(P)" {_A_ 2 _U_ 22 _N_ _N_ _F_ _IF_ARGS_ 0 2 XX 1 \ (u0 :: Float#) (u1 :: Float#) -> _#_ leFloat# [] [u0, u1] _N_} _F_ _IF_ARGS_ 0 2 CC 3 \ (u0 :: Float) (u1 :: Float) -> case u0 of { _ALG_ F# (u2 :: Float#) -> case u1 of { _ALG_ F# (u3 :: Float#) -> _#_ leFloat# [] [u2, u3]; _NO_DEFLT_ }; _NO_DEFLT_ } _N_,
- (>=) = _A_ 2 _U_ 11 _N_ _S_ "U(P)U(P)" {_A_ 2 _U_ 22 _N_ _N_ _F_ _IF_ARGS_ 0 2 XX 1 \ (u0 :: Float#) (u1 :: Float#) -> _#_ geFloat# [] [u0, u1] _N_} _F_ _IF_ARGS_ 0 2 CC 3 \ (u0 :: Float) (u1 :: Float) -> case u0 of { _ALG_ F# (u2 :: Float#) -> case u1 of { _ALG_ F# (u3 :: Float#) -> _#_ geFloat# [] [u2, u3]; _NO_DEFLT_ }; _NO_DEFLT_ } _N_,
- (>) = _A_ 2 _U_ 11 _N_ _S_ "U(P)U(P)" {_A_ 2 _U_ 22 _N_ _N_ _F_ _IF_ARGS_ 0 2 XX 1 \ (u0 :: Float#) (u1 :: Float#) -> _#_ gtFloat# [] [u0, u1] _N_} _F_ _IF_ARGS_ 0 2 CC 3 \ (u0 :: Float) (u1 :: Float) -> case u0 of { _ALG_ F# (u2 :: Float#) -> case u1 of { _ALG_ F# (u3 :: Float#) -> _#_ gtFloat# [] [u2, u3]; _NO_DEFLT_ }; _NO_DEFLT_ } _N_,
- max = _A_ 2 _U_ 11 _N_ _S_ "U(P)U(P)" {_A_ 2 _U_ 22 _N_ _N_ _N_ _N_} _N_ _N_,
- min = _A_ 2 _U_ 11 _N_ _S_ "U(P)U(P)" {_A_ 2 _U_ 22 _N_ _N_ _N_ _N_} _N_ _N_,
- _tagCmp = _A_ 2 _U_ 11 _N_ _S_ "U(P)U(P)" {_A_ 2 _U_ 22 _N_ _N_ _N_ _N_} _N_ _N_ #-}
+ (<) = { _A_ 2 _U_ 11 _N_ _S_ "U(P)U(P)" {_A_ 2 _U_ 22 _N_ _N_ _F_ _IF_ARGS_ 0 2 XX 1 \ (u0 :: Float#) (u1 :: Float#) -> _#_ ltFloat# [] [u0, u1] _N_} _F_ _IF_ARGS_ 0 2 CC 3 \ (u0 :: Float) (u1 :: Float) -> case u0 of { _ALG_ F# (u2 :: Float#) -> case u1 of { _ALG_ F# (u3 :: Float#) -> _#_ ltFloat# [] [u2, u3]; _NO_DEFLT_ }; _NO_DEFLT_ } _N_ },
+ (<=) = { _A_ 2 _U_ 11 _N_ _S_ "U(P)U(P)" {_A_ 2 _U_ 22 _N_ _N_ _F_ _IF_ARGS_ 0 2 XX 1 \ (u0 :: Float#) (u1 :: Float#) -> _#_ leFloat# [] [u0, u1] _N_} _F_ _IF_ARGS_ 0 2 CC 3 \ (u0 :: Float) (u1 :: Float) -> case u0 of { _ALG_ F# (u2 :: Float#) -> case u1 of { _ALG_ F# (u3 :: Float#) -> _#_ leFloat# [] [u2, u3]; _NO_DEFLT_ }; _NO_DEFLT_ } _N_ },
+ (>=) = { _A_ 2 _U_ 11 _N_ _S_ "U(P)U(P)" {_A_ 2 _U_ 22 _N_ _N_ _F_ _IF_ARGS_ 0 2 XX 1 \ (u0 :: Float#) (u1 :: Float#) -> _#_ geFloat# [] [u0, u1] _N_} _F_ _IF_ARGS_ 0 2 CC 3 \ (u0 :: Float) (u1 :: Float) -> case u0 of { _ALG_ F# (u2 :: Float#) -> case u1 of { _ALG_ F# (u3 :: Float#) -> _#_ geFloat# [] [u2, u3]; _NO_DEFLT_ }; _NO_DEFLT_ } _N_ },
+ (>) = { _A_ 2 _U_ 11 _N_ _S_ "U(P)U(P)" {_A_ 2 _U_ 22 _N_ _N_ _F_ _IF_ARGS_ 0 2 XX 1 \ (u0 :: Float#) (u1 :: Float#) -> _#_ gtFloat# [] [u0, u1] _N_} _F_ _IF_ARGS_ 0 2 CC 3 \ (u0 :: Float) (u1 :: Float) -> case u0 of { _ALG_ F# (u2 :: Float#) -> case u1 of { _ALG_ F# (u3 :: Float#) -> _#_ gtFloat# [] [u2, u3]; _NO_DEFLT_ }; _NO_DEFLT_ } _N_ },
+ max = { _A_ 2 _U_ 11 _N_ _S_ "U(P)U(P)" {_A_ 2 _U_ 22 _N_ _N_ _N_ _N_} _N_ _N_ },
+ min = { _A_ 2 _U_ 11 _N_ _S_ "U(P)U(P)" {_A_ 2 _U_ 22 _N_ _N_ _N_ _N_} _N_ _N_ },
+ _tagCmp = { _A_ 2 _U_ 11 _N_ _S_ "U(P)U(P)" {_A_ 2 _U_ 22 _N_ _N_ _N_ _N_} _N_ _N_ } #-}
instance Ord Int
{-# GHC_PRAGMA _M_ PreludeCore {-dfun-} _A_ 0 _N_ _N_ _N_ _F_ _IF_ARGS_ 0 0 X 9 _!_ _TUP_8 [{{Eq Int}}, (Int -> Int -> Bool), (Int -> Int -> Bool), (Int -> Int -> Bool), (Int -> Int -> Bool), (Int -> Int -> Int), (Int -> Int -> Int), (Int -> Int -> _CMP_TAG)] [_DFUN_ Eq (Int), _CONSTM_ Ord (<) (Int), _CONSTM_ Ord (<=) (Int), _CONSTM_ Ord (>=) (Int), _CONSTM_ Ord (>) (Int), _CONSTM_ Ord max (Int), _CONSTM_ Ord min (Int), _CONSTM_ Ord _tagCmp (Int)] _N_
- (<) = _A_ 2 _U_ 11 _N_ _S_ "U(P)U(P)" {_A_ 2 _U_ 22 _N_ _N_ _F_ _IF_ARGS_ 0 2 XX 1 \ (u0 :: Int#) (u1 :: Int#) -> _#_ ltInt# [] [u0, u1] _N_} _F_ _IF_ARGS_ 0 2 CC 3 \ (u0 :: Int) (u1 :: Int) -> case u0 of { _ALG_ I# (u2 :: Int#) -> case u1 of { _ALG_ I# (u3 :: Int#) -> _#_ ltInt# [] [u2, u3]; _NO_DEFLT_ }; _NO_DEFLT_ } _N_,
- (<=) = _A_ 2 _U_ 11 _N_ _S_ "U(P)U(P)" {_A_ 2 _U_ 22 _N_ _N_ _F_ _IF_ARGS_ 0 2 XX 1 \ (u0 :: Int#) (u1 :: Int#) -> _#_ leInt# [] [u0, u1] _N_} _F_ _IF_ARGS_ 0 2 CC 3 \ (u0 :: Int) (u1 :: Int) -> case u0 of { _ALG_ I# (u2 :: Int#) -> case u1 of { _ALG_ I# (u3 :: Int#) -> _#_ leInt# [] [u2, u3]; _NO_DEFLT_ }; _NO_DEFLT_ } _N_,
- (>=) = _A_ 2 _U_ 11 _N_ _S_ "U(P)U(P)" {_A_ 2 _U_ 22 _N_ _N_ _F_ _IF_ARGS_ 0 2 XX 1 \ (u0 :: Int#) (u1 :: Int#) -> _#_ geInt# [] [u0, u1] _N_} _F_ _IF_ARGS_ 0 2 CC 3 \ (u0 :: Int) (u1 :: Int) -> case u0 of { _ALG_ I# (u2 :: Int#) -> case u1 of { _ALG_ I# (u3 :: Int#) -> _#_ geInt# [] [u2, u3]; _NO_DEFLT_ }; _NO_DEFLT_ } _N_,
- (>) = _A_ 2 _U_ 11 _N_ _S_ "U(P)U(P)" {_A_ 2 _U_ 22 _N_ _N_ _F_ _IF_ARGS_ 0 2 XX 1 \ (u0 :: Int#) (u1 :: Int#) -> _#_ gtInt# [] [u0, u1] _N_} _F_ _IF_ARGS_ 0 2 CC 3 \ (u0 :: Int) (u1 :: Int) -> case u0 of { _ALG_ I# (u2 :: Int#) -> case u1 of { _ALG_ I# (u3 :: Int#) -> _#_ gtInt# [] [u2, u3]; _NO_DEFLT_ }; _NO_DEFLT_ } _N_,
- max = _A_ 2 _U_ 11 _N_ _S_ "U(P)U(P)" {_A_ 2 _U_ 22 _N_ _N_ _N_ _N_} _N_ _N_,
- min = _A_ 2 _U_ 11 _N_ _S_ "U(P)U(P)" {_A_ 2 _U_ 22 _N_ _N_ _N_ _N_} _N_ _N_,
- _tagCmp = _A_ 2 _U_ 11 _N_ _S_ "U(P)U(P)" {_A_ 2 _U_ 22 _N_ _N_ _N_ _N_} _N_ _N_ #-}
+ (<) = { _A_ 2 _U_ 11 _N_ _S_ "U(P)U(P)" {_A_ 2 _U_ 22 _N_ _N_ _F_ _IF_ARGS_ 0 2 XX 1 \ (u0 :: Int#) (u1 :: Int#) -> _#_ ltInt# [] [u0, u1] _N_} _F_ _IF_ARGS_ 0 2 CC 3 \ (u0 :: Int) (u1 :: Int) -> case u0 of { _ALG_ I# (u2 :: Int#) -> case u1 of { _ALG_ I# (u3 :: Int#) -> _#_ ltInt# [] [u2, u3]; _NO_DEFLT_ }; _NO_DEFLT_ } _N_ },
+ (<=) = { _A_ 2 _U_ 11 _N_ _S_ "U(P)U(P)" {_A_ 2 _U_ 22 _N_ _N_ _F_ _IF_ARGS_ 0 2 XX 1 \ (u0 :: Int#) (u1 :: Int#) -> _#_ leInt# [] [u0, u1] _N_} _F_ _IF_ARGS_ 0 2 CC 3 \ (u0 :: Int) (u1 :: Int) -> case u0 of { _ALG_ I# (u2 :: Int#) -> case u1 of { _ALG_ I# (u3 :: Int#) -> _#_ leInt# [] [u2, u3]; _NO_DEFLT_ }; _NO_DEFLT_ } _N_ },
+ (>=) = { _A_ 2 _U_ 11 _N_ _S_ "U(P)U(P)" {_A_ 2 _U_ 22 _N_ _N_ _F_ _IF_ARGS_ 0 2 XX 1 \ (u0 :: Int#) (u1 :: Int#) -> _#_ geInt# [] [u0, u1] _N_} _F_ _IF_ARGS_ 0 2 CC 3 \ (u0 :: Int) (u1 :: Int) -> case u0 of { _ALG_ I# (u2 :: Int#) -> case u1 of { _ALG_ I# (u3 :: Int#) -> _#_ geInt# [] [u2, u3]; _NO_DEFLT_ }; _NO_DEFLT_ } _N_ },
+ (>) = { _A_ 2 _U_ 11 _N_ _S_ "U(P)U(P)" {_A_ 2 _U_ 22 _N_ _N_ _F_ _IF_ARGS_ 0 2 XX 1 \ (u0 :: Int#) (u1 :: Int#) -> _#_ gtInt# [] [u0, u1] _N_} _F_ _IF_ARGS_ 0 2 CC 3 \ (u0 :: Int) (u1 :: Int) -> case u0 of { _ALG_ I# (u2 :: Int#) -> case u1 of { _ALG_ I# (u3 :: Int#) -> _#_ gtInt# [] [u2, u3]; _NO_DEFLT_ }; _NO_DEFLT_ } _N_ },
+ max = { _A_ 2 _U_ 11 _N_ _S_ "U(P)U(P)" {_A_ 2 _U_ 22 _N_ _N_ _N_ _N_} _N_ _N_ },
+ min = { _A_ 2 _U_ 11 _N_ _S_ "U(P)U(P)" {_A_ 2 _U_ 22 _N_ _N_ _N_ _N_} _N_ _N_ },
+ _tagCmp = { _A_ 2 _U_ 11 _N_ _S_ "U(P)U(P)" {_A_ 2 _U_ 22 _N_ _N_ _N_ _N_} _N_ _N_ } #-}
instance Ord Integer
{-# GHC_PRAGMA _M_ PreludeCore {-dfun-} _A_ 0 _N_ _N_ _N_ _F_ _IF_ARGS_ 0 0 X 9 _!_ _TUP_8 [{{Eq Integer}}, (Integer -> Integer -> Bool), (Integer -> Integer -> Bool), (Integer -> Integer -> Bool), (Integer -> Integer -> Bool), (Integer -> Integer -> Integer), (Integer -> Integer -> Integer), (Integer -> Integer -> _CMP_TAG)] [_DFUN_ Eq (Integer), _CONSTM_ Ord (<) (Integer), _CONSTM_ Ord (<=) (Integer), _CONSTM_ Ord (>=) (Integer), _CONSTM_ Ord (>) (Integer), _CONSTM_ Ord max (Integer), _CONSTM_ Ord min (Integer), _CONSTM_ Ord _tagCmp (Integer)] _N_
- (<) = _A_ 2 _U_ 11 _N_ _S_ "U(PPP)U(PPP)" {_A_ 4 _U_ 2221 _N_ _N_ _F_ _IF_ARGS_ 0 4 XXXC 3 \ (u0 :: Int#) (u1 :: Int#) (u2 :: ByteArray#) (u3 :: Integer) -> case u3 of { _ALG_ J# (u4 :: Int#) (u5 :: Int#) (u6 :: ByteArray#) -> case _#_ cmpInteger# [] [u0, u1, u2, u4, u5, u6] of { _PRIM_ (u7 :: Int#) -> _#_ ltInt# [] [u7, 0#] }; _NO_DEFLT_ } _N_} _F_ _IF_ARGS_ 0 2 CC 4 \ (u0 :: Integer) (u1 :: Integer) -> case u0 of { _ALG_ J# (u2 :: Int#) (u3 :: Int#) (u4 :: ByteArray#) -> case u1 of { _ALG_ J# (u5 :: Int#) (u6 :: Int#) (u7 :: ByteArray#) -> case _#_ cmpInteger# [] [u2, u3, u4, u5, u6, u7] of { _PRIM_ (u8 :: Int#) -> _#_ ltInt# [] [u8, 0#] }; _NO_DEFLT_ }; _NO_DEFLT_ } _N_,
- (<=) = _A_ 2 _U_ 11 _N_ _S_ "U(PPP)U(PPP)" {_A_ 4 _U_ 2221 _N_ _N_ _F_ _IF_ARGS_ 0 4 XXXC 3 \ (u0 :: Int#) (u1 :: Int#) (u2 :: ByteArray#) (u3 :: Integer) -> case u3 of { _ALG_ J# (u4 :: Int#) (u5 :: Int#) (u6 :: ByteArray#) -> case _#_ cmpInteger# [] [u0, u1, u2, u4, u5, u6] of { _PRIM_ (u7 :: Int#) -> _#_ leInt# [] [u7, 0#] }; _NO_DEFLT_ } _N_} _F_ _IF_ARGS_ 0 2 CC 4 \ (u0 :: Integer) (u1 :: Integer) -> case u0 of { _ALG_ J# (u2 :: Int#) (u3 :: Int#) (u4 :: ByteArray#) -> case u1 of { _ALG_ J# (u5 :: Int#) (u6 :: Int#) (u7 :: ByteArray#) -> case _#_ cmpInteger# [] [u2, u3, u4, u5, u6, u7] of { _PRIM_ (u8 :: Int#) -> _#_ leInt# [] [u8, 0#] }; _NO_DEFLT_ }; _NO_DEFLT_ } _N_,
- (>=) = _A_ 2 _U_ 11 _N_ _S_ "U(PPP)U(PPP)" {_A_ 4 _U_ 2221 _N_ _N_ _F_ _IF_ARGS_ 0 4 XXXC 3 \ (u0 :: Int#) (u1 :: Int#) (u2 :: ByteArray#) (u3 :: Integer) -> case u3 of { _ALG_ J# (u4 :: Int#) (u5 :: Int#) (u6 :: ByteArray#) -> case _#_ cmpInteger# [] [u0, u1, u2, u4, u5, u6] of { _PRIM_ (u7 :: Int#) -> _#_ geInt# [] [u7, 0#] }; _NO_DEFLT_ } _N_} _F_ _IF_ARGS_ 0 2 CC 4 \ (u0 :: Integer) (u1 :: Integer) -> case u0 of { _ALG_ J# (u2 :: Int#) (u3 :: Int#) (u4 :: ByteArray#) -> case u1 of { _ALG_ J# (u5 :: Int#) (u6 :: Int#) (u7 :: ByteArray#) -> case _#_ cmpInteger# [] [u2, u3, u4, u5, u6, u7] of { _PRIM_ (u8 :: Int#) -> _#_ geInt# [] [u8, 0#] }; _NO_DEFLT_ }; _NO_DEFLT_ } _N_,
- (>) = _A_ 2 _U_ 11 _N_ _S_ "U(PPP)U(PPP)" {_A_ 4 _U_ 2221 _N_ _N_ _F_ _IF_ARGS_ 0 4 XXXC 3 \ (u0 :: Int#) (u1 :: Int#) (u2 :: ByteArray#) (u3 :: Integer) -> case u3 of { _ALG_ J# (u4 :: Int#) (u5 :: Int#) (u6 :: ByteArray#) -> case _#_ cmpInteger# [] [u0, u1, u2, u4, u5, u6] of { _PRIM_ (u7 :: Int#) -> _#_ gtInt# [] [u7, 0#] }; _NO_DEFLT_ } _N_} _F_ _IF_ARGS_ 0 2 CC 4 \ (u0 :: Integer) (u1 :: Integer) -> case u0 of { _ALG_ J# (u2 :: Int#) (u3 :: Int#) (u4 :: ByteArray#) -> case u1 of { _ALG_ J# (u5 :: Int#) (u6 :: Int#) (u7 :: ByteArray#) -> case _#_ cmpInteger# [] [u2, u3, u4, u5, u6, u7] of { _PRIM_ (u8 :: Int#) -> _#_ gtInt# [] [u8, 0#] }; _NO_DEFLT_ }; _NO_DEFLT_ } _N_,
- max = _A_ 2 _U_ 11 _N_ _S_ "U(PPP)U(PPP)" {_A_ 4 _U_ 2221 _N_ _N_ _N_ _N_} _N_ _N_,
- min = _A_ 2 _U_ 11 _N_ _S_ "U(PPP)U(PPP)" {_A_ 4 _U_ 2221 _N_ _N_ _N_ _N_} _N_ _N_,
- _tagCmp = _A_ 2 _U_ 11 _N_ _S_ "U(PPP)U(PPP)" {_A_ 4 _U_ 2221 _N_ _N_ _N_ _N_} _N_ _N_ #-}
+ (<) = { _A_ 2 _U_ 11 _N_ _S_ "U(PPP)U(PPP)" {_A_ 4 _U_ 2221 _N_ _N_ _F_ _IF_ARGS_ 0 4 XXXC 3 \ (u0 :: Int#) (u1 :: Int#) (u2 :: ByteArray#) (u3 :: Integer) -> case u3 of { _ALG_ J# (u4 :: Int#) (u5 :: Int#) (u6 :: ByteArray#) -> case _#_ cmpInteger# [] [u0, u1, u2, u4, u5, u6] of { _PRIM_ (u7 :: Int#) -> _#_ ltInt# [] [u7, 0#] }; _NO_DEFLT_ } _N_} _F_ _IF_ARGS_ 0 2 CC 4 \ (u0 :: Integer) (u1 :: Integer) -> case u0 of { _ALG_ J# (u2 :: Int#) (u3 :: Int#) (u4 :: ByteArray#) -> case u1 of { _ALG_ J# (u5 :: Int#) (u6 :: Int#) (u7 :: ByteArray#) -> case _#_ cmpInteger# [] [u2, u3, u4, u5, u6, u7] of { _PRIM_ (u8 :: Int#) -> _#_ ltInt# [] [u8, 0#] }; _NO_DEFLT_ }; _NO_DEFLT_ } _N_ },
+ (<=) = { _A_ 2 _U_ 11 _N_ _S_ "U(PPP)U(PPP)" {_A_ 4 _U_ 2221 _N_ _N_ _F_ _IF_ARGS_ 0 4 XXXC 3 \ (u0 :: Int#) (u1 :: Int#) (u2 :: ByteArray#) (u3 :: Integer) -> case u3 of { _ALG_ J# (u4 :: Int#) (u5 :: Int#) (u6 :: ByteArray#) -> case _#_ cmpInteger# [] [u0, u1, u2, u4, u5, u6] of { _PRIM_ (u7 :: Int#) -> _#_ leInt# [] [u7, 0#] }; _NO_DEFLT_ } _N_} _F_ _IF_ARGS_ 0 2 CC 4 \ (u0 :: Integer) (u1 :: Integer) -> case u0 of { _ALG_ J# (u2 :: Int#) (u3 :: Int#) (u4 :: ByteArray#) -> case u1 of { _ALG_ J# (u5 :: Int#) (u6 :: Int#) (u7 :: ByteArray#) -> case _#_ cmpInteger# [] [u2, u3, u4, u5, u6, u7] of { _PRIM_ (u8 :: Int#) -> _#_ leInt# [] [u8, 0#] }; _NO_DEFLT_ }; _NO_DEFLT_ } _N_ },
+ (>=) = { _A_ 2 _U_ 11 _N_ _S_ "U(PPP)U(PPP)" {_A_ 4 _U_ 2221 _N_ _N_ _F_ _IF_ARGS_ 0 4 XXXC 3 \ (u0 :: Int#) (u1 :: Int#) (u2 :: ByteArray#) (u3 :: Integer) -> case u3 of { _ALG_ J# (u4 :: Int#) (u5 :: Int#) (u6 :: ByteArray#) -> case _#_ cmpInteger# [] [u0, u1, u2, u4, u5, u6] of { _PRIM_ (u7 :: Int#) -> _#_ geInt# [] [u7, 0#] }; _NO_DEFLT_ } _N_} _F_ _IF_ARGS_ 0 2 CC 4 \ (u0 :: Integer) (u1 :: Integer) -> case u0 of { _ALG_ J# (u2 :: Int#) (u3 :: Int#) (u4 :: ByteArray#) -> case u1 of { _ALG_ J# (u5 :: Int#) (u6 :: Int#) (u7 :: ByteArray#) -> case _#_ cmpInteger# [] [u2, u3, u4, u5, u6, u7] of { _PRIM_ (u8 :: Int#) -> _#_ geInt# [] [u8, 0#] }; _NO_DEFLT_ }; _NO_DEFLT_ } _N_ },
+ (>) = { _A_ 2 _U_ 11 _N_ _S_ "U(PPP)U(PPP)" {_A_ 4 _U_ 2221 _N_ _N_ _F_ _IF_ARGS_ 0 4 XXXC 3 \ (u0 :: Int#) (u1 :: Int#) (u2 :: ByteArray#) (u3 :: Integer) -> case u3 of { _ALG_ J# (u4 :: Int#) (u5 :: Int#) (u6 :: ByteArray#) -> case _#_ cmpInteger# [] [u0, u1, u2, u4, u5, u6] of { _PRIM_ (u7 :: Int#) -> _#_ gtInt# [] [u7, 0#] }; _NO_DEFLT_ } _N_} _F_ _IF_ARGS_ 0 2 CC 4 \ (u0 :: Integer) (u1 :: Integer) -> case u0 of { _ALG_ J# (u2 :: Int#) (u3 :: Int#) (u4 :: ByteArray#) -> case u1 of { _ALG_ J# (u5 :: Int#) (u6 :: Int#) (u7 :: ByteArray#) -> case _#_ cmpInteger# [] [u2, u3, u4, u5, u6, u7] of { _PRIM_ (u8 :: Int#) -> _#_ gtInt# [] [u8, 0#] }; _NO_DEFLT_ }; _NO_DEFLT_ } _N_ },
+ max = { _A_ 2 _U_ 11 _N_ _S_ "U(PPP)U(PPP)" {_A_ 4 _U_ 2221 _N_ _N_ _N_ _N_} _N_ _N_ },
+ min = { _A_ 2 _U_ 11 _N_ _S_ "U(PPP)U(PPP)" {_A_ 4 _U_ 2221 _N_ _N_ _N_ _N_} _N_ _N_ },
+ _tagCmp = { _A_ 2 _U_ 11 _N_ _S_ "U(PPP)U(PPP)" {_A_ 4 _U_ 2221 _N_ _N_ _N_ _N_} _N_ _N_ } #-}
instance Ord a => Ord (Maybe a)
{-# GHC_PRAGMA _M_ PreludeStdIO {-dfun-} _A_ 2 _U_ 22 _N_ _N_ _N_ _N_ #-}
instance Integral a => Ord (Ratio a)
{-# GHC_PRAGMA _M_ PreludeRatio {-dfun-} _A_ 2 _U_ 22 _N_ _N_ _N_ _N_ #-}
instance Ord (Ratio Integer)
{-# GHC_PRAGMA _M_ PreludeRatio {-dfun-} _A_ 0 _N_ _N_ _N_ _F_ _IF_ARGS_ 0 0 X 9 _!_ _TUP_8 [{{Eq (Ratio Integer)}}, (Ratio Integer -> Ratio Integer -> Bool), (Ratio Integer -> Ratio Integer -> Bool), (Ratio Integer -> Ratio Integer -> Bool), (Ratio Integer -> Ratio Integer -> Bool), (Ratio Integer -> Ratio Integer -> Ratio Integer), (Ratio Integer -> Ratio Integer -> Ratio Integer), (Ratio Integer -> Ratio Integer -> _CMP_TAG)] [_DFUN_ Eq (Ratio Integer), _CONSTM_ Ord (<) (Ratio Integer), _CONSTM_ Ord (<=) (Ratio Integer), _CONSTM_ Ord (>=) (Ratio Integer), _CONSTM_ Ord (>) (Ratio Integer), _CONSTM_ Ord max (Ratio Integer), _CONSTM_ Ord min (Ratio Integer), _CONSTM_ Ord _tagCmp (Ratio Integer)] _N_
- (<) = _A_ 2 _U_ 11 _N_ _S_ "U(U(PPP)U(PPP))U(U(PPP)U(PPP))" {_A_ 5 _U_ 22221 _N_ _N_ _N_ _N_} _N_ _N_,
- (<=) = _A_ 2 _U_ 11 _N_ _S_ "U(U(PPP)U(PPP))U(U(PPP)U(PPP))" {_A_ 5 _U_ 22221 _N_ _N_ _N_ _N_} _N_ _N_,
- (>=) = _A_ 2 _U_ 11 _N_ _S_ "U(U(PPP)U(PPP))U(U(PPP)U(PPP))" {_A_ 5 _U_ 22221 _N_ _N_ _N_ _N_} _N_ _N_,
- (>) = _A_ 2 _U_ 11 _N_ _S_ "U(U(PPP)U(PPP))U(U(PPP)U(PPP))" {_A_ 5 _U_ 22221 _N_ _N_ _N_ _N_} _N_ _N_,
- max = _A_ 2 _U_ 12 _N_ _S_ "U(U(PPP)U(PPP))U(U(PPP)U(PPP))" {_A_ 5 _U_ 22222 _N_ _N_ _N_ _N_} _N_ _N_,
- min = _A_ 2 _U_ 12 _N_ _S_ "U(U(PPP)U(PPP))U(U(PPP)U(PPP))" {_A_ 5 _U_ 22222 _N_ _N_ _N_ _N_} _N_ _N_,
- _tagCmp = _A_ 2 _U_ 11 _N_ _S_ "U(U(PPP)U(PPP))U(U(PPP)U(PPP))" {_A_ 5 _U_ 22221 _N_ _N_ _N_ _N_} _N_ _N_ #-}
+ (<) = { _A_ 2 _U_ 11 _N_ _S_ "U(U(PPP)U(PPP))U(U(PPP)U(PPP))" {_A_ 5 _U_ 22221 _N_ _N_ _N_ _N_} _N_ _N_ },
+ (<=) = { _A_ 2 _U_ 11 _N_ _S_ "U(U(PPP)U(PPP))U(U(PPP)U(PPP))" {_A_ 5 _U_ 22221 _N_ _N_ _N_ _N_} _N_ _N_ },
+ (>=) = { _A_ 2 _U_ 11 _N_ _S_ "U(U(PPP)U(PPP))U(U(PPP)U(PPP))" {_A_ 5 _U_ 22221 _N_ _N_ _N_ _N_} _N_ _N_ },
+ (>) = { _A_ 2 _U_ 11 _N_ _S_ "U(U(PPP)U(PPP))U(U(PPP)U(PPP))" {_A_ 5 _U_ 22221 _N_ _N_ _N_ _N_} _N_ _N_ },
+ max = { _A_ 2 _U_ 12 _N_ _S_ "U(U(PPP)U(PPP))U(U(PPP)U(PPP))" {_A_ 5 _U_ 22222 _N_ _N_ _N_ _N_} _N_ _N_ },
+ min = { _A_ 2 _U_ 12 _N_ _S_ "U(U(PPP)U(PPP))U(U(PPP)U(PPP))" {_A_ 5 _U_ 22222 _N_ _N_ _N_ _N_} _N_ _N_ },
+ _tagCmp = { _A_ 2 _U_ 11 _N_ _S_ "U(U(PPP)U(PPP))U(U(PPP)U(PPP))" {_A_ 5 _U_ 22221 _N_ _N_ _N_ _N_} _N_ _N_ } #-}
instance Ord a => Ord [a]
{-# GHC_PRAGMA _M_ PreludeBuiltin {-dfun-} _A_ 2 _U_ 12 _N_ _N_ _N_ _N_ #-}
+instance Ord [Bool]
+ {-# GHC_PRAGMA _M_ PreludeBuiltin {-dfun-} _A_ 0 _N_ _N_ _N_ _F_ _IF_ARGS_ 0 0 X 9 _!_ _TUP_8 [{{Eq [Bool]}}, ([Bool] -> [Bool] -> Bool), ([Bool] -> [Bool] -> Bool), ([Bool] -> [Bool] -> Bool), ([Bool] -> [Bool] -> Bool), ([Bool] -> [Bool] -> [Bool]), ([Bool] -> [Bool] -> [Bool]), ([Bool] -> [Bool] -> _CMP_TAG)] [_DFUN_ Eq ([Bool]), _CONSTM_ Ord (<) ([Bool]), _CONSTM_ Ord (<=) ([Bool]), _CONSTM_ Ord (>=) ([Bool]), _CONSTM_ Ord (>) ([Bool]), _CONSTM_ Ord max ([Bool]), _CONSTM_ Ord min ([Bool]), _CONSTM_ Ord _tagCmp ([Bool])] _N_
+ (<) = { _A_ 2 _U_ 11 _N_ _S_ "SS" _N_ _N_ },
+ (<=) = { _A_ 2 _U_ 11 _N_ _S_ "SS" _N_ _N_ },
+ (>=) = { _A_ 2 _U_ 11 _N_ _S_ "SS" _N_ _N_ },
+ (>) = { _A_ 2 _U_ 11 _N_ _S_ "SS" _N_ _N_ },
+ max = { _A_ 2 _U_ 22 _N_ _S_ "SS" _N_ _N_ },
+ min = { _A_ 2 _U_ 22 _N_ _S_ "SS" _N_ _N_ },
+ _tagCmp = { _A_ 2 _U_ 11 _N_ _S_ "SS" _N_ _N_ } #-}
instance Ord [Char]
{-# GHC_PRAGMA _M_ PreludeBuiltin {-dfun-} _A_ 0 _N_ _N_ _N_ _F_ _IF_ARGS_ 0 0 X 9 _!_ _TUP_8 [{{Eq [Char]}}, ([Char] -> [Char] -> Bool), ([Char] -> [Char] -> Bool), ([Char] -> [Char] -> Bool), ([Char] -> [Char] -> Bool), ([Char] -> [Char] -> [Char]), ([Char] -> [Char] -> [Char]), ([Char] -> [Char] -> _CMP_TAG)] [_DFUN_ Eq ([Char]), _CONSTM_ Ord (<) ([Char]), _CONSTM_ Ord (<=) ([Char]), _CONSTM_ Ord (>=) ([Char]), _CONSTM_ Ord (>) ([Char]), _CONSTM_ Ord max ([Char]), _CONSTM_ Ord min ([Char]), _CONSTM_ Ord _tagCmp ([Char])] _N_
- (<) = _A_ 2 _U_ 11 _N_ _S_ "SS" _N_ _N_,
- (<=) = _A_ 2 _U_ 11 _N_ _S_ "SS" _N_ _N_,
- (>=) = _A_ 2 _U_ 11 _N_ _S_ "SS" _N_ _N_,
- (>) = _A_ 2 _U_ 11 _N_ _S_ "SS" _N_ _N_,
- max = _A_ 2 _U_ 22 _N_ _S_ "SS" _N_ _N_,
- min = _A_ 2 _U_ 22 _N_ _S_ "SS" _N_ _N_,
- _tagCmp = _A_ 2 _U_ 11 _N_ _S_ "SS" _N_ _N_ #-}
+ (<) = { _A_ 2 _U_ 11 _N_ _S_ "SS" _N_ _N_ },
+ (<=) = { _A_ 2 _U_ 11 _N_ _S_ "SS" _N_ _N_ },
+ (>=) = { _A_ 2 _U_ 11 _N_ _S_ "SS" _N_ _N_ },
+ (>) = { _A_ 2 _U_ 11 _N_ _S_ "SS" _N_ _N_ },
+ max = { _A_ 2 _U_ 22 _N_ _S_ "SS" _N_ _N_ },
+ min = { _A_ 2 _U_ 22 _N_ _S_ "SS" _N_ _N_ },
+ _tagCmp = { _A_ 2 _U_ 11 _N_ _S_ "SS" _N_ _N_ } #-}
+instance Ord [Double]
+ {-# GHC_PRAGMA _M_ PreludeBuiltin {-dfun-} _A_ 0 _N_ _N_ _N_ _F_ _IF_ARGS_ 0 0 X 9 _!_ _TUP_8 [{{Eq [Double]}}, ([Double] -> [Double] -> Bool), ([Double] -> [Double] -> Bool), ([Double] -> [Double] -> Bool), ([Double] -> [Double] -> Bool), ([Double] -> [Double] -> [Double]), ([Double] -> [Double] -> [Double]), ([Double] -> [Double] -> _CMP_TAG)] [_DFUN_ Eq ([Double]), _CONSTM_ Ord (<) ([Double]), _CONSTM_ Ord (<=) ([Double]), _CONSTM_ Ord (>=) ([Double]), _CONSTM_ Ord (>) ([Double]), _CONSTM_ Ord max ([Double]), _CONSTM_ Ord min ([Double]), _CONSTM_ Ord _tagCmp ([Double])] _N_
+ (<) = { _A_ 2 _U_ 11 _N_ _S_ "SS" _N_ _N_ },
+ (<=) = { _A_ 2 _U_ 11 _N_ _S_ "SS" _N_ _N_ },
+ (>=) = { _A_ 2 _U_ 11 _N_ _S_ "SS" _N_ _N_ },
+ (>) = { _A_ 2 _U_ 11 _N_ _S_ "SS" _N_ _N_ },
+ max = { _A_ 2 _U_ 22 _N_ _S_ "SS" _N_ _N_ },
+ min = { _A_ 2 _U_ 22 _N_ _S_ "SS" _N_ _N_ },
+ _tagCmp = { _A_ 2 _U_ 11 _N_ _S_ "SS" _N_ _N_ } #-}
instance Ord [Int]
{-# GHC_PRAGMA _M_ PreludeBuiltin {-dfun-} _A_ 0 _N_ _N_ _N_ _F_ _IF_ARGS_ 0 0 X 9 _!_ _TUP_8 [{{Eq [Int]}}, ([Int] -> [Int] -> Bool), ([Int] -> [Int] -> Bool), ([Int] -> [Int] -> Bool), ([Int] -> [Int] -> Bool), ([Int] -> [Int] -> [Int]), ([Int] -> [Int] -> [Int]), ([Int] -> [Int] -> _CMP_TAG)] [_DFUN_ Eq ([Int]), _CONSTM_ Ord (<) ([Int]), _CONSTM_ Ord (<=) ([Int]), _CONSTM_ Ord (>=) ([Int]), _CONSTM_ Ord (>) ([Int]), _CONSTM_ Ord max ([Int]), _CONSTM_ Ord min ([Int]), _CONSTM_ Ord _tagCmp ([Int])] _N_
- (<) = _A_ 2 _U_ 11 _N_ _S_ "SS" _N_ _N_,
- (<=) = _A_ 2 _U_ 11 _N_ _S_ "SS" _N_ _N_,
- (>=) = _A_ 2 _U_ 11 _N_ _S_ "SS" _N_ _N_,
- (>) = _A_ 2 _U_ 11 _N_ _S_ "SS" _N_ _N_,
- max = _A_ 2 _U_ 22 _N_ _S_ "SS" _N_ _N_,
- min = _A_ 2 _U_ 22 _N_ _S_ "SS" _N_ _N_,
- _tagCmp = _A_ 2 _U_ 11 _N_ _S_ "SS" _N_ _N_ #-}
+ (<) = { _A_ 2 _U_ 11 _N_ _S_ "SS" _N_ _N_ },
+ (<=) = { _A_ 2 _U_ 11 _N_ _S_ "SS" _N_ _N_ },
+ (>=) = { _A_ 2 _U_ 11 _N_ _S_ "SS" _N_ _N_ },
+ (>) = { _A_ 2 _U_ 11 _N_ _S_ "SS" _N_ _N_ },
+ max = { _A_ 2 _U_ 22 _N_ _S_ "SS" _N_ _N_ },
+ min = { _A_ 2 _U_ 22 _N_ _S_ "SS" _N_ _N_ },
+ _tagCmp = { _A_ 2 _U_ 11 _N_ _S_ "SS" _N_ _N_ } #-}
+instance Ord [Integer]
+ {-# GHC_PRAGMA _M_ PreludeBuiltin {-dfun-} _A_ 0 _N_ _N_ _N_ _F_ _IF_ARGS_ 0 0 X 9 _!_ _TUP_8 [{{Eq [Integer]}}, ([Integer] -> [Integer] -> Bool), ([Integer] -> [Integer] -> Bool), ([Integer] -> [Integer] -> Bool), ([Integer] -> [Integer] -> Bool), ([Integer] -> [Integer] -> [Integer]), ([Integer] -> [Integer] -> [Integer]), ([Integer] -> [Integer] -> _CMP_TAG)] [_DFUN_ Eq ([Integer]), _CONSTM_ Ord (<) ([Integer]), _CONSTM_ Ord (<=) ([Integer]), _CONSTM_ Ord (>=) ([Integer]), _CONSTM_ Ord (>) ([Integer]), _CONSTM_ Ord max ([Integer]), _CONSTM_ Ord min ([Integer]), _CONSTM_ Ord _tagCmp ([Integer])] _N_
+ (<) = { _A_ 2 _U_ 11 _N_ _S_ "SS" _N_ _N_ },
+ (<=) = { _A_ 2 _U_ 11 _N_ _S_ "SS" _N_ _N_ },
+ (>=) = { _A_ 2 _U_ 11 _N_ _S_ "SS" _N_ _N_ },
+ (>) = { _A_ 2 _U_ 11 _N_ _S_ "SS" _N_ _N_ },
+ max = { _A_ 2 _U_ 22 _N_ _S_ "SS" _N_ _N_ },
+ min = { _A_ 2 _U_ 22 _N_ _S_ "SS" _N_ _N_ },
+ _tagCmp = { _A_ 2 _U_ 11 _N_ _S_ "SS" _N_ _N_ } #-}
+instance Ord [[Char]]
+ {-# GHC_PRAGMA _M_ PreludeBuiltin {-dfun-} _A_ 0 _N_ _N_ _N_ _F_ _IF_ARGS_ 0 0 X 9 _!_ _TUP_8 [{{Eq [[Char]]}}, ([[Char]] -> [[Char]] -> Bool), ([[Char]] -> [[Char]] -> Bool), ([[Char]] -> [[Char]] -> Bool), ([[Char]] -> [[Char]] -> Bool), ([[Char]] -> [[Char]] -> [[Char]]), ([[Char]] -> [[Char]] -> [[Char]]), ([[Char]] -> [[Char]] -> _CMP_TAG)] [_DFUN_ Eq ([[Char]]), _CONSTM_ Ord (<) ([[Char]]), _CONSTM_ Ord (<=) ([[Char]]), _CONSTM_ Ord (>=) ([[Char]]), _CONSTM_ Ord (>) ([[Char]]), _CONSTM_ Ord max ([[Char]]), _CONSTM_ Ord min ([[Char]]), _CONSTM_ Ord _tagCmp ([[Char]])] _N_
+ (<) = { _A_ 2 _U_ 11 _N_ _S_ "SS" _N_ _N_ },
+ (<=) = { _A_ 2 _U_ 11 _N_ _S_ "SS" _N_ _N_ },
+ (>=) = { _A_ 2 _U_ 11 _N_ _S_ "SS" _N_ _N_ },
+ (>) = { _A_ 2 _U_ 11 _N_ _S_ "SS" _N_ _N_ },
+ max = { _A_ 2 _U_ 22 _N_ _S_ "SS" _N_ _N_ },
+ min = { _A_ 2 _U_ 22 _N_ _S_ "SS" _N_ _N_ },
+ _tagCmp = { _A_ 2 _U_ 11 _N_ _S_ "SS" _N_ _N_ } #-}
+instance Ord [[Int]]
+ {-# GHC_PRAGMA _M_ PreludeBuiltin {-dfun-} _A_ 0 _N_ _N_ _N_ _F_ _IF_ARGS_ 0 0 X 9 _!_ _TUP_8 [{{Eq [[Int]]}}, ([[Int]] -> [[Int]] -> Bool), ([[Int]] -> [[Int]] -> Bool), ([[Int]] -> [[Int]] -> Bool), ([[Int]] -> [[Int]] -> Bool), ([[Int]] -> [[Int]] -> [[Int]]), ([[Int]] -> [[Int]] -> [[Int]]), ([[Int]] -> [[Int]] -> _CMP_TAG)] [_DFUN_ Eq ([[Int]]), _CONSTM_ Ord (<) ([[Int]]), _CONSTM_ Ord (<=) ([[Int]]), _CONSTM_ Ord (>=) ([[Int]]), _CONSTM_ Ord (>) ([[Int]]), _CONSTM_ Ord max ([[Int]]), _CONSTM_ Ord min ([[Int]]), _CONSTM_ Ord _tagCmp ([[Int]])] _N_
+ (<) = { _A_ 2 _U_ 11 _N_ _S_ "SS" _N_ _N_ },
+ (<=) = { _A_ 2 _U_ 11 _N_ _S_ "SS" _N_ _N_ },
+ (>=) = { _A_ 2 _U_ 11 _N_ _S_ "SS" _N_ _N_ },
+ (>) = { _A_ 2 _U_ 11 _N_ _S_ "SS" _N_ _N_ },
+ max = { _A_ 2 _U_ 22 _N_ _S_ "SS" _N_ _N_ },
+ min = { _A_ 2 _U_ 22 _N_ _S_ "SS" _N_ _N_ },
+ _tagCmp = { _A_ 2 _U_ 11 _N_ _S_ "SS" _N_ _N_ } #-}
instance Ord _Addr
{-# GHC_PRAGMA _M_ PreludeCore {-dfun-} _A_ 0 _N_ _N_ _N_ _F_ _IF_ARGS_ 0 0 X 9 _!_ _TUP_8 [{{Eq _Addr}}, (_Addr -> _Addr -> Bool), (_Addr -> _Addr -> Bool), (_Addr -> _Addr -> Bool), (_Addr -> _Addr -> Bool), (_Addr -> _Addr -> _Addr), (_Addr -> _Addr -> _Addr), (_Addr -> _Addr -> _CMP_TAG)] [_DFUN_ Eq (_Addr), _CONSTM_ Ord (<) (_Addr), _CONSTM_ Ord (<=) (_Addr), _CONSTM_ Ord (>=) (_Addr), _CONSTM_ Ord (>) (_Addr), _CONSTM_ Ord max (_Addr), _CONSTM_ Ord min (_Addr), _CONSTM_ Ord _tagCmp (_Addr)] _N_
- (<) = _A_ 2 _U_ 11 _N_ _S_ "U(P)U(P)" {_A_ 2 _U_ 22 _N_ _N_ _F_ _IF_ARGS_ 0 2 XX 1 \ (u0 :: Addr#) (u1 :: Addr#) -> _#_ ltAddr# [] [u0, u1] _N_} _F_ _IF_ARGS_ 0 2 CC 3 \ (u0 :: _Addr) (u1 :: _Addr) -> case u0 of { _ALG_ A# (u2 :: Addr#) -> case u1 of { _ALG_ A# (u3 :: Addr#) -> _#_ ltAddr# [] [u2, u3]; _NO_DEFLT_ }; _NO_DEFLT_ } _N_,
- (<=) = _A_ 2 _U_ 11 _N_ _S_ "U(P)U(P)" {_A_ 2 _U_ 22 _N_ _N_ _F_ _IF_ARGS_ 0 2 XX 1 \ (u0 :: Addr#) (u1 :: Addr#) -> _#_ leAddr# [] [u0, u1] _N_} _F_ _IF_ARGS_ 0 2 CC 3 \ (u0 :: _Addr) (u1 :: _Addr) -> case u0 of { _ALG_ A# (u2 :: Addr#) -> case u1 of { _ALG_ A# (u3 :: Addr#) -> _#_ leAddr# [] [u2, u3]; _NO_DEFLT_ }; _NO_DEFLT_ } _N_,
- (>=) = _A_ 2 _U_ 11 _N_ _S_ "U(P)U(P)" {_A_ 2 _U_ 22 _N_ _N_ _F_ _IF_ARGS_ 0 2 XX 1 \ (u0 :: Addr#) (u1 :: Addr#) -> _#_ geAddr# [] [u0, u1] _N_} _F_ _IF_ARGS_ 0 2 CC 3 \ (u0 :: _Addr) (u1 :: _Addr) -> case u0 of { _ALG_ A# (u2 :: Addr#) -> case u1 of { _ALG_ A# (u3 :: Addr#) -> _#_ geAddr# [] [u2, u3]; _NO_DEFLT_ }; _NO_DEFLT_ } _N_,
- (>) = _A_ 2 _U_ 11 _N_ _S_ "U(P)U(P)" {_A_ 2 _U_ 22 _N_ _N_ _F_ _IF_ARGS_ 0 2 XX 1 \ (u0 :: Addr#) (u1 :: Addr#) -> _#_ gtAddr# [] [u0, u1] _N_} _F_ _IF_ARGS_ 0 2 CC 3 \ (u0 :: _Addr) (u1 :: _Addr) -> case u0 of { _ALG_ A# (u2 :: Addr#) -> case u1 of { _ALG_ A# (u3 :: Addr#) -> _#_ gtAddr# [] [u2, u3]; _NO_DEFLT_ }; _NO_DEFLT_ } _N_,
- max = _A_ 2 _U_ 11 _N_ _S_ "U(P)U(P)" {_A_ 2 _U_ 22 _N_ _N_ _N_ _N_} _N_ _N_,
- min = _A_ 2 _U_ 11 _N_ _S_ "U(P)U(P)" {_A_ 2 _U_ 22 _N_ _N_ _N_ _N_} _N_ _N_,
- _tagCmp = _A_ 2 _U_ 11 _N_ _S_ "U(P)U(P)" {_A_ 2 _U_ 22 _N_ _N_ _N_ _N_} _N_ _N_ #-}
+ (<) = { _A_ 2 _U_ 11 _N_ _S_ "U(P)U(P)" {_A_ 2 _U_ 22 _N_ _N_ _F_ _IF_ARGS_ 0 2 XX 1 \ (u0 :: Addr#) (u1 :: Addr#) -> _#_ ltAddr# [] [u0, u1] _N_} _F_ _IF_ARGS_ 0 2 CC 3 \ (u0 :: _Addr) (u1 :: _Addr) -> case u0 of { _ALG_ A# (u2 :: Addr#) -> case u1 of { _ALG_ A# (u3 :: Addr#) -> _#_ ltAddr# [] [u2, u3]; _NO_DEFLT_ }; _NO_DEFLT_ } _N_ },
+ (<=) = { _A_ 2 _U_ 11 _N_ _S_ "U(P)U(P)" {_A_ 2 _U_ 22 _N_ _N_ _F_ _IF_ARGS_ 0 2 XX 1 \ (u0 :: Addr#) (u1 :: Addr#) -> _#_ leAddr# [] [u0, u1] _N_} _F_ _IF_ARGS_ 0 2 CC 3 \ (u0 :: _Addr) (u1 :: _Addr) -> case u0 of { _ALG_ A# (u2 :: Addr#) -> case u1 of { _ALG_ A# (u3 :: Addr#) -> _#_ leAddr# [] [u2, u3]; _NO_DEFLT_ }; _NO_DEFLT_ } _N_ },
+ (>=) = { _A_ 2 _U_ 11 _N_ _S_ "U(P)U(P)" {_A_ 2 _U_ 22 _N_ _N_ _F_ _IF_ARGS_ 0 2 XX 1 \ (u0 :: Addr#) (u1 :: Addr#) -> _#_ geAddr# [] [u0, u1] _N_} _F_ _IF_ARGS_ 0 2 CC 3 \ (u0 :: _Addr) (u1 :: _Addr) -> case u0 of { _ALG_ A# (u2 :: Addr#) -> case u1 of { _ALG_ A# (u3 :: Addr#) -> _#_ geAddr# [] [u2, u3]; _NO_DEFLT_ }; _NO_DEFLT_ } _N_ },
+ (>) = { _A_ 2 _U_ 11 _N_ _S_ "U(P)U(P)" {_A_ 2 _U_ 22 _N_ _N_ _F_ _IF_ARGS_ 0 2 XX 1 \ (u0 :: Addr#) (u1 :: Addr#) -> _#_ gtAddr# [] [u0, u1] _N_} _F_ _IF_ARGS_ 0 2 CC 3 \ (u0 :: _Addr) (u1 :: _Addr) -> case u0 of { _ALG_ A# (u2 :: Addr#) -> case u1 of { _ALG_ A# (u3 :: Addr#) -> _#_ gtAddr# [] [u2, u3]; _NO_DEFLT_ }; _NO_DEFLT_ } _N_ },
+ max = { _A_ 2 _U_ 11 _N_ _S_ "U(P)U(P)" {_A_ 2 _U_ 22 _N_ _N_ _N_ _N_} _N_ _N_ },
+ min = { _A_ 2 _U_ 11 _N_ _S_ "U(P)U(P)" {_A_ 2 _U_ 22 _N_ _N_ _N_ _N_} _N_ _N_ },
+ _tagCmp = { _A_ 2 _U_ 11 _N_ _S_ "U(P)U(P)" {_A_ 2 _U_ 22 _N_ _N_ _N_ _N_} _N_ _N_ } #-}
instance Ord _PackedString
{-# GHC_PRAGMA _M_ PreludePS {-dfun-} _A_ 0 _N_ _N_ _N_ _F_ _IF_ARGS_ 0 0 X 9 _!_ _TUP_8 [{{Eq _PackedString}}, (_PackedString -> _PackedString -> Bool), (_PackedString -> _PackedString -> Bool), (_PackedString -> _PackedString -> Bool), (_PackedString -> _PackedString -> Bool), (_PackedString -> _PackedString -> _PackedString), (_PackedString -> _PackedString -> _PackedString), (_PackedString -> _PackedString -> _CMP_TAG)] [_DFUN_ Eq (_PackedString), _CONSTM_ Ord (<) (_PackedString), _CONSTM_ Ord (<=) (_PackedString), _CONSTM_ Ord (>=) (_PackedString), _CONSTM_ Ord (>) (_PackedString), _CONSTM_ Ord max (_PackedString), _CONSTM_ Ord min (_PackedString), _CONSTM_ Ord _tagCmp (_PackedString)] _N_
- (<) = _A_ 2 _U_ 22 _N_ _S_ "SS" _N_ _N_,
- (<=) = _A_ 2 _U_ 22 _N_ _S_ "SS" _N_ _N_,
- (>=) = _A_ 2 _U_ 22 _N_ _S_ "SS" _N_ _N_,
- (>) = _A_ 2 _U_ 22 _N_ _S_ "SS" _N_ _N_,
- max = _A_ 2 _U_ 22 _N_ _N_ _N_ _N_,
- min = _A_ 2 _U_ 22 _N_ _N_ _N_ _N_,
- _tagCmp = _A_ 2 _U_ 22 _N_ _S_ "SS" _N_ _N_ #-}
+ (<) = { _A_ 2 _U_ 22 _N_ _S_ "SS" _N_ _N_ },
+ (<=) = { _A_ 2 _U_ 22 _N_ _S_ "SS" _N_ _N_ },
+ (>=) = { _A_ 2 _U_ 22 _N_ _S_ "SS" _N_ _N_ },
+ (>) = { _A_ 2 _U_ 22 _N_ _S_ "SS" _N_ _N_ },
+ max = { _A_ 2 _U_ 22 _N_ _S_ "SS" _N_ _N_ },
+ min = { _A_ 2 _U_ 22 _N_ _S_ "SS" _N_ _N_ },
+ _tagCmp = { _A_ 2 _U_ 22 _N_ _S_ "SS" _N_ _N_ } #-}
instance Ord _Word
{-# GHC_PRAGMA _M_ PreludeCore {-dfun-} _A_ 0 _N_ _N_ _N_ _F_ _IF_ARGS_ 0 0 X 9 _!_ _TUP_8 [{{Eq _Word}}, (_Word -> _Word -> Bool), (_Word -> _Word -> Bool), (_Word -> _Word -> Bool), (_Word -> _Word -> Bool), (_Word -> _Word -> _Word), (_Word -> _Word -> _Word), (_Word -> _Word -> _CMP_TAG)] [_DFUN_ Eq (_Word), _CONSTM_ Ord (<) (_Word), _CONSTM_ Ord (<=) (_Word), _CONSTM_ Ord (>=) (_Word), _CONSTM_ Ord (>) (_Word), _CONSTM_ Ord max (_Word), _CONSTM_ Ord min (_Word), _CONSTM_ Ord _tagCmp (_Word)] _N_
- (<) = _A_ 2 _U_ 11 _N_ _S_ "U(P)U(P)" {_A_ 2 _U_ 22 _N_ _N_ _F_ _IF_ARGS_ 0 2 XX 1 \ (u0 :: Word#) (u1 :: Word#) -> _#_ ltWord# [] [u0, u1] _N_} _F_ _IF_ARGS_ 0 2 CC 3 \ (u0 :: _Word) (u1 :: _Word) -> case u0 of { _ALG_ W# (u2 :: Word#) -> case u1 of { _ALG_ W# (u3 :: Word#) -> _#_ ltWord# [] [u2, u3]; _NO_DEFLT_ }; _NO_DEFLT_ } _N_,
- (<=) = _A_ 2 _U_ 11 _N_ _S_ "U(P)U(P)" {_A_ 2 _U_ 22 _N_ _N_ _F_ _IF_ARGS_ 0 2 XX 1 \ (u0 :: Word#) (u1 :: Word#) -> _#_ leWord# [] [u0, u1] _N_} _F_ _IF_ARGS_ 0 2 CC 3 \ (u0 :: _Word) (u1 :: _Word) -> case u0 of { _ALG_ W# (u2 :: Word#) -> case u1 of { _ALG_ W# (u3 :: Word#) -> _#_ leWord# [] [u2, u3]; _NO_DEFLT_ }; _NO_DEFLT_ } _N_,
- (>=) = _A_ 2 _U_ 11 _N_ _S_ "U(P)U(P)" {_A_ 2 _U_ 22 _N_ _N_ _F_ _IF_ARGS_ 0 2 XX 1 \ (u0 :: Word#) (u1 :: Word#) -> _#_ geWord# [] [u0, u1] _N_} _F_ _IF_ARGS_ 0 2 CC 3 \ (u0 :: _Word) (u1 :: _Word) -> case u0 of { _ALG_ W# (u2 :: Word#) -> case u1 of { _ALG_ W# (u3 :: Word#) -> _#_ geWord# [] [u2, u3]; _NO_DEFLT_ }; _NO_DEFLT_ } _N_,
- (>) = _A_ 2 _U_ 11 _N_ _S_ "U(P)U(P)" {_A_ 2 _U_ 22 _N_ _N_ _F_ _IF_ARGS_ 0 2 XX 1 \ (u0 :: Word#) (u1 :: Word#) -> _#_ gtWord# [] [u0, u1] _N_} _F_ _IF_ARGS_ 0 2 CC 3 \ (u0 :: _Word) (u1 :: _Word) -> case u0 of { _ALG_ W# (u2 :: Word#) -> case u1 of { _ALG_ W# (u3 :: Word#) -> _#_ gtWord# [] [u2, u3]; _NO_DEFLT_ }; _NO_DEFLT_ } _N_,
- max = _A_ 2 _U_ 11 _N_ _S_ "U(P)U(P)" {_A_ 2 _U_ 22 _N_ _N_ _N_ _N_} _N_ _N_,
- min = _A_ 2 _U_ 11 _N_ _S_ "U(P)U(P)" {_A_ 2 _U_ 22 _N_ _N_ _N_ _N_} _N_ _N_,
- _tagCmp = _A_ 2 _U_ 11 _N_ _S_ "U(P)U(P)" {_A_ 2 _U_ 22 _N_ _N_ _N_ _N_} _N_ _N_ #-}
+ (<) = { _A_ 2 _U_ 11 _N_ _S_ "U(P)U(P)" {_A_ 2 _U_ 22 _N_ _N_ _F_ _IF_ARGS_ 0 2 XX 1 \ (u0 :: Word#) (u1 :: Word#) -> _#_ ltWord# [] [u0, u1] _N_} _F_ _IF_ARGS_ 0 2 CC 3 \ (u0 :: _Word) (u1 :: _Word) -> case u0 of { _ALG_ W# (u2 :: Word#) -> case u1 of { _ALG_ W# (u3 :: Word#) -> _#_ ltWord# [] [u2, u3]; _NO_DEFLT_ }; _NO_DEFLT_ } _N_ },
+ (<=) = { _A_ 2 _U_ 11 _N_ _S_ "U(P)U(P)" {_A_ 2 _U_ 22 _N_ _N_ _F_ _IF_ARGS_ 0 2 XX 1 \ (u0 :: Word#) (u1 :: Word#) -> _#_ leWord# [] [u0, u1] _N_} _F_ _IF_ARGS_ 0 2 CC 3 \ (u0 :: _Word) (u1 :: _Word) -> case u0 of { _ALG_ W# (u2 :: Word#) -> case u1 of { _ALG_ W# (u3 :: Word#) -> _#_ leWord# [] [u2, u3]; _NO_DEFLT_ }; _NO_DEFLT_ } _N_ },
+ (>=) = { _A_ 2 _U_ 11 _N_ _S_ "U(P)U(P)" {_A_ 2 _U_ 22 _N_ _N_ _F_ _IF_ARGS_ 0 2 XX 1 \ (u0 :: Word#) (u1 :: Word#) -> _#_ geWord# [] [u0, u1] _N_} _F_ _IF_ARGS_ 0 2 CC 3 \ (u0 :: _Word) (u1 :: _Word) -> case u0 of { _ALG_ W# (u2 :: Word#) -> case u1 of { _ALG_ W# (u3 :: Word#) -> _#_ geWord# [] [u2, u3]; _NO_DEFLT_ }; _NO_DEFLT_ } _N_ },
+ (>) = { _A_ 2 _U_ 11 _N_ _S_ "U(P)U(P)" {_A_ 2 _U_ 22 _N_ _N_ _F_ _IF_ARGS_ 0 2 XX 1 \ (u0 :: Word#) (u1 :: Word#) -> _#_ gtWord# [] [u0, u1] _N_} _F_ _IF_ARGS_ 0 2 CC 3 \ (u0 :: _Word) (u1 :: _Word) -> case u0 of { _ALG_ W# (u2 :: Word#) -> case u1 of { _ALG_ W# (u3 :: Word#) -> _#_ gtWord# [] [u2, u3]; _NO_DEFLT_ }; _NO_DEFLT_ } _N_ },
+ max = { _A_ 2 _U_ 11 _N_ _S_ "U(P)U(P)" {_A_ 2 _U_ 22 _N_ _N_ _N_ _N_} _N_ _N_ },
+ min = { _A_ 2 _U_ 11 _N_ _S_ "U(P)U(P)" {_A_ 2 _U_ 22 _N_ _N_ _N_ _N_} _N_ _N_ },
+ _tagCmp = { _A_ 2 _U_ 11 _N_ _S_ "U(P)U(P)" {_A_ 2 _U_ 22 _N_ _N_ _N_ _N_} _N_ _N_ } #-}
instance Real Double
{-# GHC_PRAGMA _M_ PreludeCore {-dfun-} _A_ 0 _N_ _N_ _N_ _F_ _IF_ARGS_ 0 0 X 4 _!_ _TUP_3 [{{Num Double}}, {{Enum Double}}, (Double -> Ratio Integer)] [_DFUN_ Num (Double), _DFUN_ Enum (Double), _CONSTM_ Real toRational (Double)] _N_
- toRational = _A_ 1 _U_ 1 _N_ _S_ "U(P)" {_A_ 1 _U_ 2 _N_ _N_ _N_ _N_} _N_ _N_ #-}
+ toRational = { _A_ 1 _U_ 1 _N_ _S_ "U(P)" {_A_ 1 _U_ 2 _N_ _N_ _N_ _N_} _N_ _N_ } #-}
instance Real Float
{-# GHC_PRAGMA _M_ PreludeCore {-dfun-} _A_ 0 _N_ _N_ _N_ _F_ _IF_ARGS_ 0 0 X 4 _!_ _TUP_3 [{{Num Float}}, {{Enum Float}}, (Float -> Ratio Integer)] [_DFUN_ Num (Float), _DFUN_ Enum (Float), _CONSTM_ Real toRational (Float)] _N_
- toRational = _A_ 1 _U_ 1 _N_ _S_ "U(P)" {_A_ 1 _U_ 2 _N_ _N_ _N_ _N_} _N_ _N_ #-}
+ toRational = { _A_ 1 _U_ 1 _N_ _S_ "U(P)" {_A_ 1 _U_ 2 _N_ _N_ _N_ _N_} _N_ _N_ } #-}
instance Real Int
{-# GHC_PRAGMA _M_ PreludeCore {-dfun-} _A_ 0 _N_ _N_ _N_ _F_ _IF_ARGS_ 0 0 X 4 _!_ _TUP_3 [{{Num Int}}, {{Enum Int}}, (Int -> Ratio Integer)] [_DFUN_ Num (Int), _DFUN_ Enum (Int), _CONSTM_ Real toRational (Int)] _N_
- toRational = _A_ 1 _U_ 1 _N_ _N_ _N_ _N_ #-}
+ toRational = { _A_ 1 _U_ 1 _N_ _N_ _N_ _N_ } #-}
instance Real Integer
{-# GHC_PRAGMA _M_ PreludeCore {-dfun-} _A_ 0 _N_ _N_ _N_ _F_ _IF_ARGS_ 0 0 X 4 _!_ _TUP_3 [{{Num Integer}}, {{Enum Integer}}, (Integer -> Ratio Integer)] [_DFUN_ Num (Integer), _DFUN_ Enum (Integer), _CONSTM_ Real toRational (Integer)] _N_
- toRational = _A_ 1 _U_ 2 _N_ _N_ _N_ _N_ #-}
+ toRational = { _A_ 1 _U_ 2 _N_ _N_ _F_ _IF_ARGS_ 0 1 X 3 \ (u0 :: Integer) -> _!_ (:%) [Integer] [u0, _ORIG_ PreludeCore __integer1] _N_ } #-}
instance Integral a => Real (Ratio a)
{-# GHC_PRAGMA _M_ PreludeRatio {-dfun-} _A_ 3 _U_ 122 _N_ _N_ _N_ _N_ #-}
instance Real (Ratio Integer)
{-# GHC_PRAGMA _M_ PreludeRatio {-dfun-} _A_ 0 _N_ _N_ _N_ _F_ _IF_ARGS_ 0 0 X 4 _!_ _TUP_3 [{{Num (Ratio Integer)}}, {{Enum (Ratio Integer)}}, (Ratio Integer -> Ratio Integer)] [_DFUN_ Num (Ratio Integer), _DFUN_ Enum (Ratio Integer), _CONSTM_ Real toRational (Ratio Integer)] _N_
- toRational = _A_ 1 _U_ 1 _N_ _S_ "U(LL)" {_A_ 2 _U_ 22 _N_ _N_ _F_ _IF_ARGS_ 0 2 XX 3 \ (u0 :: Integer) (u1 :: Integer) -> _!_ (:%) [Integer] [u0, u1] _N_} _F_ _IF_ARGS_ 0 1 X 1 \ (u0 :: Ratio Integer) -> u0 _N_ #-}
+ toRational = { _A_ 1 _U_ 1 _N_ _S_ "U(LL)" {_A_ 2 _U_ 22 _N_ _N_ _F_ _IF_ARGS_ 0 2 XX 3 \ (u0 :: Integer) (u1 :: Integer) -> _!_ (:%) [Integer] [u0, u1] _N_} _F_ _IF_ARGS_ 0 1 X 1 \ (u0 :: Ratio Integer) -> u0 _N_ } #-}
instance RealFloat Double
{-# GHC_PRAGMA _M_ PreludeCore {-dfun-} _A_ 0 _N_ _N_ _N_ _F_ _IF_ARGS_ 0 0 X 11 _!_ _TUP_10 [{{RealFrac Double}}, {{Floating Double}}, (Double -> Integer), (Double -> Int), (Double -> (Int, Int)), (Double -> (Integer, Int)), (Integer -> Int -> Double), (Double -> Int), (Double -> Double), (Int -> Double -> Double)] [_DFUN_ RealFrac (Double), _DFUN_ Floating (Double), _CONSTM_ RealFloat floatRadix (Double), _CONSTM_ RealFloat floatDigits (Double), _CONSTM_ RealFloat floatRange (Double), _CONSTM_ RealFloat decodeFloat (Double), _CONSTM_ RealFloat encodeFloat (Double), _CONSTM_ RealFloat exponent (Double), _CONSTM_ RealFloat significand (Double), _CONSTM_ RealFloat scaleFloat (Double)] _N_
- floatRadix = _A_ 1 _U_ 0 _N_ _S_ "A" {_A_ 0 _N_ _N_ _N_ _F_ _IF_ARGS_ 0 0 X 1 _#_ int2Integer# [] [2#] _N_} _N_ _N_,
- floatDigits = _A_ 1 _U_ 0 _N_ _S_ "A" {_A_ 0 _N_ _N_ _N_ _F_ _IF_ARGS_ 0 0 X 2 _!_ I# [] [53#] _N_} _F_ _IF_ARGS_ 0 1 X 2 \ (u0 :: Double) -> _!_ I# [] [53#] _N_,
- floatRange = _A_ 1 _U_ 0 _N_ _S_ "A" {_A_ 0 _N_ _N_ _N_ _N_ _N_} _N_ _N_,
- decodeFloat = _A_ 1 _U_ 1 _N_ _S_ "U(P)" {_A_ 1 _U_ 2 _N_ _N_ _N_ _N_} _N_ _N_,
- encodeFloat = _A_ 2 _U_ 11 _N_ _S_ "U(PPP)U(P)" {_A_ 4 _U_ 2222 _N_ _N_ _F_ _IF_ARGS_ 0 4 XXXX 3 \ (u0 :: Int#) (u1 :: Int#) (u2 :: ByteArray#) (u3 :: Int#) -> case _#_ encodeDouble# [] [u0, u1, u2, u3] of { _PRIM_ (u4 :: Double#) -> _!_ D# [] [u4] } _N_} _F_ _IF_ARGS_ 0 2 CC 5 \ (u0 :: Integer) (u1 :: Int) -> case u0 of { _ALG_ J# (u2 :: Int#) (u3 :: Int#) (u4 :: ByteArray#) -> case u1 of { _ALG_ I# (u5 :: Int#) -> case _#_ encodeDouble# [] [u2, u3, u4, u5] of { _PRIM_ (u6 :: Double#) -> _!_ D# [] [u6] }; _NO_DEFLT_ }; _NO_DEFLT_ } _N_,
- exponent = _A_ 1 _U_ 2 _N_ _N_ _N_ _N_,
- significand = _A_ 1 _U_ 2 _N_ _N_ _N_ _N_,
- scaleFloat = _A_ 2 _U_ 22 _N_ _N_ _N_ _N_ #-}
+ floatRadix = { _A_ 1 _U_ 0 _N_ _S_ "A" {_A_ 0 _N_ _N_ _N_ _N_ _N_} _N_ _N_ },
+ floatDigits = { _A_ 1 _U_ 0 _N_ _S_ "A" {_A_ 0 _N_ _N_ _N_ _F_ _IF_ARGS_ 0 0 X 2 _!_ I# [] [53#] _N_} _F_ _IF_ARGS_ 0 1 X 2 \ (u0 :: Double) -> _!_ I# [] [53#] _N_ },
+ floatRange = { _A_ 1 _U_ 0 _N_ _S_ "A" {_A_ 0 _N_ _N_ _N_ _N_ _N_} _N_ _N_ },
+ decodeFloat = { _A_ 1 _U_ 1 _N_ _S_ "U(P)" {_A_ 1 _U_ 2 _N_ _N_ _N_ _N_} _N_ _N_ },
+ encodeFloat = { _A_ 2 _U_ 11 _N_ _S_ "U(PPP)U(P)" {_A_ 4 _U_ 2222 _N_ _N_ _F_ _IF_ARGS_ 0 4 XXXX 3 \ (u0 :: Int#) (u1 :: Int#) (u2 :: ByteArray#) (u3 :: Int#) -> case _#_ encodeDouble# [] [u0, u1, u2, u3] of { _PRIM_ (u4 :: Double#) -> _!_ D# [] [u4] } _N_} _F_ _IF_ARGS_ 0 2 CC 5 \ (u0 :: Integer) (u1 :: Int) -> case u0 of { _ALG_ J# (u2 :: Int#) (u3 :: Int#) (u4 :: ByteArray#) -> case u1 of { _ALG_ I# (u5 :: Int#) -> case _#_ encodeDouble# [] [u2, u3, u4, u5] of { _PRIM_ (u6 :: Double#) -> _!_ D# [] [u6] }; _NO_DEFLT_ }; _NO_DEFLT_ } _N_ },
+ exponent = { _A_ 1 _U_ 1 _N_ _S_ "U(P)" {_A_ 1 _U_ 2 _N_ _N_ _N_ _N_} _N_ _N_ },
+ significand = { _A_ 1 _U_ 1 _N_ _S_ "U(P)" {_A_ 1 _U_ 2 _N_ _N_ _N_ _N_} _N_ _N_ },
+ scaleFloat = { _A_ 2 _U_ 11 _N_ _S_ "U(P)U(P)" {_A_ 2 _U_ 22 _N_ _N_ _N_ _N_} _N_ _N_ } #-}
instance RealFloat Float
{-# GHC_PRAGMA _M_ PreludeCore {-dfun-} _A_ 0 _N_ _N_ _N_ _F_ _IF_ARGS_ 0 0 X 11 _!_ _TUP_10 [{{RealFrac Float}}, {{Floating Float}}, (Float -> Integer), (Float -> Int), (Float -> (Int, Int)), (Float -> (Integer, Int)), (Integer -> Int -> Float), (Float -> Int), (Float -> Float), (Int -> Float -> Float)] [_DFUN_ RealFrac (Float), _DFUN_ Floating (Float), _CONSTM_ RealFloat floatRadix (Float), _CONSTM_ RealFloat floatDigits (Float), _CONSTM_ RealFloat floatRange (Float), _CONSTM_ RealFloat decodeFloat (Float), _CONSTM_ RealFloat encodeFloat (Float), _CONSTM_ RealFloat exponent (Float), _CONSTM_ RealFloat significand (Float), _CONSTM_ RealFloat scaleFloat (Float)] _N_
- floatRadix = _A_ 1 _U_ 0 _N_ _S_ "A" {_A_ 0 _N_ _N_ _N_ _F_ _IF_ARGS_ 0 0 X 1 _#_ int2Integer# [] [2#] _N_} _N_ _N_,
- floatDigits = _A_ 1 _U_ 0 _N_ _S_ "A" {_A_ 0 _N_ _N_ _N_ _F_ _IF_ARGS_ 0 0 X 2 _!_ I# [] [24#] _N_} _F_ _IF_ARGS_ 0 1 X 2 \ (u0 :: Float) -> _!_ I# [] [24#] _N_,
- floatRange = _A_ 1 _U_ 0 _N_ _S_ "A" {_A_ 0 _N_ _N_ _N_ _N_ _N_} _N_ _N_,
- decodeFloat = _A_ 1 _U_ 1 _N_ _S_ "U(P)" {_A_ 1 _U_ 2 _N_ _N_ _N_ _N_} _N_ _N_,
- encodeFloat = _A_ 2 _U_ 11 _N_ _S_ "U(PPP)U(P)" {_A_ 4 _U_ 2222 _N_ _N_ _F_ _IF_ARGS_ 0 4 XXXX 3 \ (u0 :: Int#) (u1 :: Int#) (u2 :: ByteArray#) (u3 :: Int#) -> case _#_ encodeFloat# [] [u0, u1, u2, u3] of { _PRIM_ (u4 :: Float#) -> _!_ F# [] [u4] } _N_} _F_ _IF_ARGS_ 0 2 CC 5 \ (u0 :: Integer) (u1 :: Int) -> case u0 of { _ALG_ J# (u2 :: Int#) (u3 :: Int#) (u4 :: ByteArray#) -> case u1 of { _ALG_ I# (u5 :: Int#) -> case _#_ encodeFloat# [] [u2, u3, u4, u5] of { _PRIM_ (u6 :: Float#) -> _!_ F# [] [u6] }; _NO_DEFLT_ }; _NO_DEFLT_ } _N_,
- exponent = _A_ 1 _U_ 2 _N_ _N_ _N_ _N_,
- significand = _A_ 1 _U_ 2 _N_ _N_ _N_ _N_,
- scaleFloat = _A_ 2 _U_ 22 _N_ _N_ _N_ _N_ #-}
+ floatRadix = { _A_ 1 _U_ 0 _N_ _S_ "A" {_A_ 0 _N_ _N_ _N_ _N_ _N_} _N_ _N_ },
+ floatDigits = { _A_ 1 _U_ 0 _N_ _S_ "A" {_A_ 0 _N_ _N_ _N_ _F_ _IF_ARGS_ 0 0 X 2 _!_ I# [] [24#] _N_} _F_ _IF_ARGS_ 0 1 X 2 \ (u0 :: Float) -> _!_ I# [] [24#] _N_ },
+ floatRange = { _A_ 1 _U_ 0 _N_ _S_ "A" {_A_ 0 _N_ _N_ _N_ _N_ _N_} _N_ _N_ },
+ decodeFloat = { _A_ 1 _U_ 1 _N_ _S_ "U(P)" {_A_ 1 _U_ 2 _N_ _N_ _N_ _N_} _N_ _N_ },
+ encodeFloat = { _A_ 2 _U_ 11 _N_ _S_ "U(PPP)U(P)" {_A_ 4 _U_ 2222 _N_ _N_ _F_ _IF_ARGS_ 0 4 XXXX 3 \ (u0 :: Int#) (u1 :: Int#) (u2 :: ByteArray#) (u3 :: Int#) -> case _#_ encodeFloat# [] [u0, u1, u2, u3] of { _PRIM_ (u4 :: Float#) -> _!_ F# [] [u4] } _N_} _F_ _IF_ARGS_ 0 2 CC 5 \ (u0 :: Integer) (u1 :: Int) -> case u0 of { _ALG_ J# (u2 :: Int#) (u3 :: Int#) (u4 :: ByteArray#) -> case u1 of { _ALG_ I# (u5 :: Int#) -> case _#_ encodeFloat# [] [u2, u3, u4, u5] of { _PRIM_ (u6 :: Float#) -> _!_ F# [] [u6] }; _NO_DEFLT_ }; _NO_DEFLT_ } _N_ },
+ exponent = { _A_ 1 _U_ 1 _N_ _S_ "U(P)" {_A_ 1 _U_ 2 _N_ _N_ _N_ _N_} _N_ _N_ },
+ significand = { _A_ 1 _U_ 1 _N_ _S_ "U(P)" {_A_ 1 _U_ 2 _N_ _N_ _N_ _N_} _N_ _N_ },
+ scaleFloat = { _A_ 2 _U_ 11 _N_ _S_ "U(P)U(P)" {_A_ 2 _U_ 22 _N_ _N_ _N_ _N_} _N_ _N_ } #-}
instance RealFrac Double
{-# GHC_PRAGMA _M_ PreludeCore {-dfun-} _A_ 0 _N_ _N_ _N_ _F_ _IF_ARGS_ 0 0 X 8 _!_ _TUP_7 [{{Real Double}}, {{Fractional Double}}, _forall_ a$z1 =>{{Integral a$z1}} -> (Double -> (a$z1, Double)), _forall_ a$z1 =>{{Integral a$z1}} -> (Double -> a$z1), _forall_ a$z1 =>{{Integral a$z1}} -> (Double -> a$z1), _forall_ a$z1 =>{{Integral a$z1}} -> (Double -> a$z1), _forall_ a$z1 =>{{Integral a$z1}} -> (Double -> a$z1)] [_DFUN_ Real (Double), _DFUN_ Fractional (Double), _CONSTM_ RealFrac properFraction (Double), _CONSTM_ RealFrac truncate (Double), _CONSTM_ RealFrac round (Double), _CONSTM_ RealFrac ceiling (Double), _CONSTM_ RealFrac floor (Double)] _N_
- properFraction = _A_ 1 _U_ 22 _N_ _N_ _N_ _N_,
- truncate = _A_ 1 _U_ 22 _N_ _N_ _N_ _N_,
- round = _A_ 1 _U_ 22 _N_ _N_ _N_ _N_,
- ceiling = _A_ 1 _U_ 22 _N_ _N_ _N_ _N_,
- floor = _A_ 1 _U_ 22 _N_ _N_ _N_ _N_ #-}
+ properFraction = { _A_ 1 _U_ 11 _N_ _N_ _N_ _SPECIALISE_ [ Int ] 1 { _A_ 1 _U_ 1 _N_ _S_ "U(P)" {_A_ 1 _U_ 2 _N_ _N_ _N_ _N_} _N_ _N_ }, [ Integer ] 1 { _A_ 1 _U_ 1 _N_ _S_ "U(P)" {_A_ 1 _U_ 2 _N_ _N_ _N_ _N_} _N_ _N_ } },
+ truncate = { _A_ 1 _U_ 11 _N_ _N_ _N_ _SPECIALISE_ [ Int ] 1 { _A_ 1 _U_ 1 _N_ _S_ "U(P)" {_A_ 1 _U_ 2 _N_ _N_ _F_ _IF_ARGS_ 0 1 X 4 \ (u0 :: Double#) -> case _APP_ _WRKR_ _SPEC_ _CONSTM_ RealFrac properFraction (Double) [ (Int) ] [ u0 ] of { _ALG_ _TUP_2 (u1 :: Int) (u2 :: Double) -> u1; _NO_DEFLT_ } _N_} _F_ _IF_ARGS_ 0 1 X 4 \ (u0 :: Double) -> case _APP_ _SPEC_ _CONSTM_ RealFrac properFraction (Double) [ (Int) ] [ u0 ] of { _ALG_ _TUP_2 (u1 :: Int) (u2 :: Double) -> u1; _NO_DEFLT_ } _N_ }, [ Integer ] 1 { _A_ 1 _U_ 1 _N_ _S_ "U(P)" {_A_ 1 _U_ 2 _N_ _N_ _F_ _IF_ARGS_ 0 1 X 4 \ (u0 :: Double#) -> case _APP_ _WRKR_ _SPEC_ _CONSTM_ RealFrac properFraction (Double) [ (Integer) ] [ u0 ] of { _ALG_ _TUP_2 (u1 :: Integer) (u2 :: Double) -> u1; _NO_DEFLT_ } _N_} _F_ _IF_ARGS_ 0 1 X 4 \ (u0 :: Double) -> case _APP_ _SPEC_ _CONSTM_ RealFrac properFraction (Double) [ (Integer) ] [ u0 ] of { _ALG_ _TUP_2 (u1 :: Integer) (u2 :: Double) -> u1; _NO_DEFLT_ } _N_ } },
+ round = { _A_ 1 _U_ 21 _N_ _N_ _N_ _SPECIALISE_ [ Int ] 1 { _A_ 1 _U_ 1 _N_ _S_ "U(P)" {_A_ 1 _U_ 2 _N_ _N_ _N_ _N_} _N_ _N_ }, [ Integer ] 1 { _A_ 1 _U_ 1 _N_ _S_ "U(P)" {_A_ 1 _U_ 2 _N_ _N_ _N_ _N_} _N_ _N_ } },
+ ceiling = { _A_ 1 _U_ 21 _N_ _N_ _N_ _SPECIALISE_ [ Int ] 1 { _A_ 1 _U_ 1 _N_ _S_ "U(P)" {_A_ 1 _U_ 2 _N_ _N_ _N_ _N_} _N_ _N_ }, [ Integer ] 1 { _A_ 1 _U_ 1 _N_ _S_ "U(P)" {_A_ 1 _U_ 2 _N_ _N_ _N_ _N_} _N_ _N_ } },
+ floor = { _A_ 1 _U_ 21 _N_ _N_ _N_ _SPECIALISE_ [ Int ] 1 { _A_ 1 _U_ 1 _N_ _S_ "U(P)" {_A_ 1 _U_ 2 _N_ _N_ _N_ _N_} _N_ _N_ }, [ Integer ] 1 { _A_ 1 _U_ 1 _N_ _S_ "U(P)" {_A_ 1 _U_ 2 _N_ _N_ _N_ _N_} _N_ _N_ } } #-}
instance RealFrac Float
{-# GHC_PRAGMA _M_ PreludeCore {-dfun-} _A_ 0 _N_ _N_ _N_ _F_ _IF_ARGS_ 0 0 X 8 _!_ _TUP_7 [{{Real Float}}, {{Fractional Float}}, _forall_ a$z1 =>{{Integral a$z1}} -> (Float -> (a$z1, Float)), _forall_ a$z1 =>{{Integral a$z1}} -> (Float -> a$z1), _forall_ a$z1 =>{{Integral a$z1}} -> (Float -> a$z1), _forall_ a$z1 =>{{Integral a$z1}} -> (Float -> a$z1), _forall_ a$z1 =>{{Integral a$z1}} -> (Float -> a$z1)] [_DFUN_ Real (Float), _DFUN_ Fractional (Float), _CONSTM_ RealFrac properFraction (Float), _CONSTM_ RealFrac truncate (Float), _CONSTM_ RealFrac round (Float), _CONSTM_ RealFrac ceiling (Float), _CONSTM_ RealFrac floor (Float)] _N_
- properFraction = _A_ 1 _U_ 22 _N_ _N_ _N_ _N_,
- truncate = _A_ 1 _U_ 22 _N_ _N_ _N_ _N_,
- round = _A_ 1 _U_ 22 _N_ _N_ _N_ _N_,
- ceiling = _A_ 1 _U_ 22 _N_ _N_ _N_ _N_,
- floor = _A_ 1 _U_ 22 _N_ _N_ _N_ _N_ #-}
-instance Integral a => RealFrac (Ratio a)
- {-# GHC_PRAGMA _M_ PreludeRatio {-dfun-} _A_ 3 _U_ 222 _N_ _N_ _N_ _N_ #-}
+ properFraction = { _A_ 1 _U_ 11 _N_ _N_ _N_ _SPECIALISE_ [ Int ] 1 { _A_ 1 _U_ 1 _N_ _S_ "U(P)" {_A_ 1 _U_ 2 _N_ _N_ _N_ _N_} _N_ _N_ }, [ Integer ] 1 { _A_ 1 _U_ 1 _N_ _S_ "U(P)" {_A_ 1 _U_ 2 _N_ _N_ _N_ _N_} _N_ _N_ } },
+ truncate = { _A_ 1 _U_ 11 _N_ _N_ _N_ _SPECIALISE_ [ Int ] 1 { _A_ 1 _U_ 1 _N_ _S_ "U(P)" {_A_ 1 _U_ 2 _N_ _N_ _F_ _IF_ARGS_ 0 1 X 4 \ (u0 :: Float#) -> case _APP_ _WRKR_ _SPEC_ _CONSTM_ RealFrac properFraction (Float) [ (Int) ] [ u0 ] of { _ALG_ _TUP_2 (u1 :: Int) (u2 :: Float) -> u1; _NO_DEFLT_ } _N_} _F_ _IF_ARGS_ 0 1 X 4 \ (u0 :: Float) -> case _APP_ _SPEC_ _CONSTM_ RealFrac properFraction (Float) [ (Int) ] [ u0 ] of { _ALG_ _TUP_2 (u1 :: Int) (u2 :: Float) -> u1; _NO_DEFLT_ } _N_ }, [ Integer ] 1 { _A_ 1 _U_ 1 _N_ _S_ "U(P)" {_A_ 1 _U_ 2 _N_ _N_ _F_ _IF_ARGS_ 0 1 X 4 \ (u0 :: Float#) -> case _APP_ _WRKR_ _SPEC_ _CONSTM_ RealFrac properFraction (Float) [ (Integer) ] [ u0 ] of { _ALG_ _TUP_2 (u1 :: Integer) (u2 :: Float) -> u1; _NO_DEFLT_ } _N_} _F_ _IF_ARGS_ 0 1 X 4 \ (u0 :: Float) -> case _APP_ _SPEC_ _CONSTM_ RealFrac properFraction (Float) [ (Integer) ] [ u0 ] of { _ALG_ _TUP_2 (u1 :: Integer) (u2 :: Float) -> u1; _NO_DEFLT_ } _N_ } },
+ round = { _A_ 1 _U_ 21 _N_ _N_ _N_ _SPECIALISE_ [ Int ] 1 { _A_ 1 _U_ 1 _N_ _S_ "U(P)" {_A_ 1 _U_ 2 _N_ _N_ _N_ _N_} _N_ _N_ }, [ Integer ] 1 { _A_ 1 _U_ 1 _N_ _S_ "U(P)" {_A_ 1 _U_ 2 _N_ _N_ _N_ _N_} _N_ _N_ } },
+ ceiling = { _A_ 1 _U_ 21 _N_ _N_ _N_ _SPECIALISE_ [ Int ] 1 { _A_ 1 _U_ 1 _N_ _S_ "U(P)" {_A_ 1 _U_ 2 _N_ _N_ _N_ _N_} _N_ _N_ }, [ Integer ] 1 { _A_ 1 _U_ 1 _N_ _S_ "U(P)" {_A_ 1 _U_ 2 _N_ _N_ _N_ _N_} _N_ _N_ } },
+ floor = { _A_ 1 _U_ 21 _N_ _N_ _N_ _SPECIALISE_ [ Int ] 1 { _A_ 1 _U_ 1 _N_ _S_ "U(P)" {_A_ 1 _U_ 2 _N_ _N_ _N_ _N_} _N_ _N_ }, [ Integer ] 1 { _A_ 1 _U_ 1 _N_ _S_ "U(P)" {_A_ 1 _U_ 2 _N_ _N_ _N_ _N_} _N_ _N_ } } #-}
instance RealFrac (Ratio Integer)
{-# GHC_PRAGMA _M_ PreludeRatio {-dfun-} _A_ 0 _N_ _N_ _N_ _F_ _IF_ARGS_ 0 0 X 8 _!_ _TUP_7 [{{Real (Ratio Integer)}}, {{Fractional (Ratio Integer)}}, _forall_ a$z1 =>{{Integral a$z1}} -> (Ratio Integer -> (a$z1, Ratio Integer)), _forall_ a$z1 =>{{Integral a$z1}} -> (Ratio Integer -> a$z1), _forall_ a$z1 =>{{Integral a$z1}} -> (Ratio Integer -> a$z1), _forall_ a$z1 =>{{Integral a$z1}} -> (Ratio Integer -> a$z1), _forall_ a$z1 =>{{Integral a$z1}} -> (Ratio Integer -> a$z1)] [_DFUN_ Real (Ratio Integer), _DFUN_ Fractional (Ratio Integer), _CONSTM_ RealFrac properFraction (Ratio Integer), _CONSTM_ RealFrac truncate (Ratio Integer), _CONSTM_ RealFrac round (Ratio Integer), _CONSTM_ RealFrac ceiling (Ratio Integer), _CONSTM_ RealFrac floor (Ratio Integer)] _N_
- properFraction = _A_ 2 _U_ 11 _N_ _S_ "LU(LL)" {_A_ 3 _U_ 112 _N_ _N_ _N_ _N_} _N_ _N_,
- truncate = _A_ 1 _U_ 22 _N_ _N_ _F_ _IF_ARGS_ 1 1 X 3 _/\_ u0 -> \ (u1 :: {{Integral u0}}) -> _APP_ _TYAPP_ _TYAPP_ _WRKR_ _ORIG_ PreludeCore _truncate { (Ratio Integer) } { u0 } [ _CONSTM_ RealFrac properFraction (Ratio Integer), u1 ] _N_,
- round = _A_ 1 _U_ 22 _N_ _N_ _N_ _N_,
- ceiling = _A_ 1 _U_ 22 _N_ _N_ _N_ _N_,
- floor = _A_ 1 _U_ 22 _N_ _N_ _N_ _N_ #-}
+ properFraction = { _A_ 2 _U_ 11 _N_ _S_ "LU(U(PPP)U(PPP))" {_A_ 5 _U_ 12222 _N_ _N_ _N_ _N_} _N_ _SPECIALISE_ [ Int ] 1 { _A_ 1 _U_ 1 _N_ _S_ "U(U(PPP)U(PPP))" {_A_ 4 _U_ 2222 _N_ _N_ _N_ _N_} _N_ _N_ }, [ Integer ] 1 { _A_ 1 _U_ 1 _N_ _S_ "U(U(PPP)U(PPP))" {_A_ 4 _U_ 2222 _N_ _N_ _N_ _N_} _N_ _N_ } },
+ truncate = { _A_ 2 _U_ 11 _N_ _N_ _N_ _SPECIALISE_ [ Int ] 1 { _A_ 1 _U_ 1 _N_ _S_ "U(U(PPP)U(PPP))" {_A_ 4 _U_ 2222 _N_ _N_ _F_ _IF_ARGS_ 0 4 XXXX 7 \ (u0 :: Int#) (u1 :: Int#) (u2 :: ByteArray#) (u3 :: Integer) -> case _APP_ _WRKR_ _SPEC_ _CONSTM_ RealFrac properFraction (Ratio Integer) [ (Int) ] [ u0, u1, u2, u3 ] of { _ALG_ _TUP_2 (u4 :: Int) (u5 :: Ratio Integer) -> u4; _NO_DEFLT_ } _N_} _F_ _IF_ARGS_ 0 1 X 4 \ (u0 :: Ratio Integer) -> case _APP_ _SPEC_ _CONSTM_ RealFrac properFraction (Ratio Integer) [ (Int) ] [ u0 ] of { _ALG_ _TUP_2 (u1 :: Int) (u2 :: Ratio Integer) -> u1; _NO_DEFLT_ } _N_ }, [ Integer ] 1 { _A_ 1 _U_ 1 _N_ _S_ "U(U(PPP)U(PPP))" {_A_ 4 _U_ 2222 _N_ _N_ _F_ _IF_ARGS_ 0 4 XXXX 7 \ (u0 :: Int#) (u1 :: Int#) (u2 :: ByteArray#) (u3 :: Integer) -> case _APP_ _WRKR_ _SPEC_ _CONSTM_ RealFrac properFraction (Ratio Integer) [ (Integer) ] [ u0, u1, u2, u3 ] of { _ALG_ _TUP_2 (u4 :: Integer) (u5 :: Ratio Integer) -> u4; _NO_DEFLT_ } _N_} _F_ _IF_ARGS_ 0 1 X 4 \ (u0 :: Ratio Integer) -> case _APP_ _SPEC_ _CONSTM_ RealFrac properFraction (Ratio Integer) [ (Integer) ] [ u0 ] of { _ALG_ _TUP_2 (u1 :: Integer) (u2 :: Ratio Integer) -> u1; _NO_DEFLT_ } _N_ } },
+ round = { _A_ 1 _U_ 21 _N_ _N_ _N_ _SPECIALISE_ [ Int ] 1 { _A_ 1 _U_ 1 _N_ _S_ "U(U(PPP)U(PPP))" {_A_ 4 _U_ 2222 _N_ _N_ _N_ _N_} _N_ _N_ }, [ Integer ] 1 { _A_ 1 _U_ 1 _N_ _S_ "U(U(PPP)U(PPP))" {_A_ 4 _U_ 2222 _N_ _N_ _N_ _N_} _N_ _N_ } },
+ ceiling = { _A_ 1 _U_ 21 _N_ _N_ _N_ _SPECIALISE_ [ Int ] 1 { _A_ 1 _U_ 1 _N_ _S_ "U(U(PPP)U(PPP))" {_A_ 4 _U_ 2222 _N_ _N_ _N_ _N_} _N_ _N_ }, [ Integer ] 1 { _A_ 1 _U_ 1 _N_ _S_ "U(U(PPP)U(PPP))" {_A_ 4 _U_ 2222 _N_ _N_ _N_ _N_} _N_ _N_ } },
+ floor = { _A_ 1 _U_ 21 _N_ _N_ _N_ _SPECIALISE_ [ Int ] 1 { _A_ 1 _U_ 1 _N_ _S_ "U(U(PPP)U(PPP))" {_A_ 4 _U_ 2222 _N_ _N_ _N_ _N_} _N_ _N_ }, [ Integer ] 1 { _A_ 1 _U_ 1 _N_ _S_ "U(U(PPP)U(PPP))" {_A_ 4 _U_ 2222 _N_ _N_ _N_ _N_} _N_ _N_ } } #-}
+instance Text ((Int, Int), (Int, Int))
+ {-# GHC_PRAGMA _M_ PreludeBuiltin {-dfun-} _A_ 0 _N_ _N_ _N_ _F_ _IF_ARGS_ 0 0 X 5 _!_ _TUP_4 [(Int -> [Char] -> [(((Int, Int), (Int, Int)), [Char])]), (Int -> ((Int, Int), (Int, Int)) -> [Char] -> [Char]), ([Char] -> [([((Int, Int), (Int, Int))], [Char])]), ([((Int, Int), (Int, Int))] -> [Char] -> [Char])] [_CONSTM_ Text readsPrec (((Int, Int), (Int, Int))), _CONSTM_ Text showsPrec (((Int, Int), (Int, Int))), _CONSTM_ Text readList (((Int, Int), (Int, Int))), _CONSTM_ Text showList (((Int, Int), (Int, Int)))] _N_
+ readsPrec = { _A_ 1 _U_ 02 _N_ _S_ "A" {_A_ 0 _U_ 2 _N_ _N_ _N_ _N_} _N_ _N_ },
+ showsPrec = { _A_ 3 _U_ 012 _N_ _S_ "AU(LL)L" {_A_ 3 _U_ 112 _N_ _N_ _N_ _N_} _N_ _N_ },
+ readList = { _A_ 0 _U_ 2 _N_ _N_ _N_ _N_ },
+ showList = { _A_ 1 _U_ 12 _N_ _N_ _N_ _N_ } #-}
instance Text ()
{-# GHC_PRAGMA _M_ PreludeBuiltin {-dfun-} _A_ 0 _N_ _N_ _N_ _F_ _IF_ARGS_ 0 0 X 5 _!_ _TUP_4 [(Int -> [Char] -> [((), [Char])]), (Int -> () -> [Char] -> [Char]), ([Char] -> [([()], [Char])]), ([()] -> [Char] -> [Char])] [_CONSTM_ Text readsPrec (()), _CONSTM_ Text showsPrec (()), _CONSTM_ Text readList (()), _CONSTM_ Text showList (())] _N_
- readsPrec = _A_ 1 _U_ 02 _N_ _S_ "A" {_A_ 0 _U_ 2 _N_ _N_ _N_ _N_} _N_ _N_,
- showsPrec = _A_ 3 _U_ 012 _N_ _S_ "AEL" {_A_ 2 _U_ 12 _N_ _N_ _F_ _IF_ARGS_ 0 2 CX 4 \ (u0 :: ()) (u1 :: [Char]) -> case u0 of { _ALG_ _TUP_0 -> _APP_ _TYAPP_ _ORIG_ PreludeList (++) { Char } [ _NOREP_S_ "()", u1 ]; _NO_DEFLT_ } _N_} _F_ _IF_ARGS_ 0 3 XCX 4 \ (u0 :: Int) (u1 :: ()) (u2 :: [Char]) -> case u1 of { _ALG_ _TUP_0 -> _APP_ _TYAPP_ _ORIG_ PreludeList (++) { Char } [ _NOREP_S_ "()", u2 ]; _NO_DEFLT_ } _N_,
- readList = _A_ 0 _U_ 2 _N_ _N_ _N_ _N_,
- showList = _A_ 0 _U_ 12 _N_ _N_ _N_ _N_ #-}
+ readsPrec = { _A_ 1 _U_ 02 _N_ _S_ "A" {_A_ 0 _U_ 2 _N_ _N_ _N_ _N_} _N_ _N_ },
+ showsPrec = { _A_ 3 _U_ 012 _N_ _S_ "AEL" {_A_ 2 _U_ 12 _N_ _N_ _F_ _IF_ARGS_ 0 2 CX 4 \ (u0 :: ()) (u1 :: [Char]) -> case u0 of { _ALG_ _TUP_0 -> _APP_ _TYAPP_ _ORIG_ PreludeList (++) { Char } [ _NOREP_S_ "()", u1 ]; _NO_DEFLT_ } _N_} _F_ _IF_ARGS_ 0 3 XCX 4 \ (u0 :: Int) (u1 :: ()) (u2 :: [Char]) -> case u1 of { _ALG_ _TUP_0 -> _APP_ _TYAPP_ _ORIG_ PreludeList (++) { Char } [ _NOREP_S_ "()", u2 ]; _NO_DEFLT_ } _N_ },
+ readList = { _A_ 0 _U_ 2 _N_ _N_ _N_ _N_ },
+ showList = { _A_ 1 _U_ 12 _N_ _N_ _N_ _N_ } #-}
instance (Text a, Text b) => Text (a, b)
{-# GHC_PRAGMA _M_ PreludeBuiltin {-dfun-} _A_ 2 _U_ 22 _N_ _N_ _N_ _N_ #-}
instance (Text a, Text b, Text c) => Text (a, b, c)
{-# GHC_PRAGMA _M_ PreludeBuiltin {-dfun-} _A_ 5 _U_ 22222 _N_ _N_ _N_ _N_ #-}
instance Text (Int, Int)
{-# GHC_PRAGMA _M_ PreludeBuiltin {-dfun-} _A_ 0 _N_ _N_ _N_ _F_ _IF_ARGS_ 0 0 X 5 _!_ _TUP_4 [(Int -> [Char] -> [((Int, Int), [Char])]), (Int -> (Int, Int) -> [Char] -> [Char]), ([Char] -> [([(Int, Int)], [Char])]), ([(Int, Int)] -> [Char] -> [Char])] [_CONSTM_ Text readsPrec ((Int, Int)), _CONSTM_ Text showsPrec ((Int, Int)), _CONSTM_ Text readList ((Int, Int)), _CONSTM_ Text showList ((Int, Int))] _N_
- readsPrec = _A_ 1 _U_ 02 _N_ _S_ "A" {_A_ 0 _U_ 2 _N_ _N_ _N_ _N_} _N_ _N_,
- showsPrec = _A_ 3 _U_ 012 _N_ _S_ "AU(LL)L" {_A_ 3 _U_ 112 _N_ _N_ _N_ _N_} _N_ _N_,
- readList = _A_ 0 _U_ 2 _N_ _N_ _N_ _N_,
- showList = _A_ 0 _U_ 12 _N_ _N_ _N_ _N_ #-}
+ readsPrec = { _A_ 1 _U_ 02 _N_ _S_ "A" {_A_ 0 _U_ 2 _N_ _N_ _N_ _N_} _N_ _N_ },
+ showsPrec = { _A_ 3 _U_ 012 _N_ _S_ "AU(LL)L" {_A_ 3 _U_ 112 _N_ _N_ _N_ _N_} _N_ _N_ },
+ readList = { _A_ 0 _U_ 2 _N_ _N_ _N_ _N_ },
+ showList = { _A_ 1 _U_ 12 _N_ _N_ _N_ _N_ } #-}
+instance Text (Int, Int, Int)
+ {-# GHC_PRAGMA _M_ PreludeBuiltin {-dfun-} _A_ 0 _N_ _N_ _N_ _F_ _IF_ARGS_ 0 0 X 5 _!_ _TUP_4 [(Int -> [Char] -> [((Int, Int, Int), [Char])]), (Int -> (Int, Int, Int) -> [Char] -> [Char]), ([Char] -> [([(Int, Int, Int)], [Char])]), ([(Int, Int, Int)] -> [Char] -> [Char])] [_CONSTM_ Text readsPrec ((Int, Int, Int)), _CONSTM_ Text showsPrec ((Int, Int, Int)), _CONSTM_ Text readList ((Int, Int, Int)), _CONSTM_ Text showList ((Int, Int, Int))] _N_
+ readsPrec = { _A_ 1 _U_ 02 _N_ _S_ "A" {_A_ 0 _U_ 2 _N_ _N_ _N_ _N_} _N_ _N_ },
+ showsPrec = { _A_ 3 _U_ 012 _N_ _S_ "AU(LLL)L" {_A_ 4 _U_ 1112 _N_ _N_ _N_ _N_} _N_ _N_ },
+ readList = { _A_ 0 _U_ 2 _N_ _N_ _N_ _N_ },
+ showList = { _A_ 1 _U_ 12 _N_ _N_ _N_ _N_ } #-}
instance Text (Integer, Integer)
{-# GHC_PRAGMA _M_ PreludeBuiltin {-dfun-} _A_ 0 _N_ _N_ _N_ _F_ _IF_ARGS_ 0 0 X 5 _!_ _TUP_4 [(Int -> [Char] -> [((Integer, Integer), [Char])]), (Int -> (Integer, Integer) -> [Char] -> [Char]), ([Char] -> [([(Integer, Integer)], [Char])]), ([(Integer, Integer)] -> [Char] -> [Char])] [_CONSTM_ Text readsPrec ((Integer, Integer)), _CONSTM_ Text showsPrec ((Integer, Integer)), _CONSTM_ Text readList ((Integer, Integer)), _CONSTM_ Text showList ((Integer, Integer))] _N_
- readsPrec = _A_ 1 _U_ 02 _N_ _S_ "A" {_A_ 0 _U_ 2 _N_ _N_ _N_ _N_} _N_ _N_,
- showsPrec = _A_ 3 _U_ 012 _N_ _S_ "AU(LL)L" {_A_ 3 _U_ 112 _N_ _N_ _N_ _N_} _N_ _N_,
- readList = _A_ 0 _U_ 2 _N_ _N_ _N_ _N_,
- showList = _A_ 0 _U_ 12 _N_ _N_ _N_ _N_ #-}
+ readsPrec = { _A_ 1 _U_ 02 _N_ _S_ "A" {_A_ 0 _U_ 2 _N_ _N_ _N_ _N_} _N_ _N_ },
+ showsPrec = { _A_ 3 _U_ 012 _N_ _S_ "AU(LL)L" {_A_ 3 _U_ 112 _N_ _N_ _N_ _N_} _N_ _N_ },
+ readList = { _A_ 0 _U_ 2 _N_ _N_ _N_ _N_ },
+ showList = { _A_ 1 _U_ 12 _N_ _N_ _N_ _N_ } #-}
instance Text (a -> b)
{-# GHC_PRAGMA _M_ PreludeCore {-dfun-} _A_ 0 _N_ _N_ _N_ _N_ _N_ #-}
+instance Text (Array (Int, Int) Double)
+ {-# GHC_PRAGMA _M_ PreludeArray {-dfun-} _A_ 0 _N_ _N_ _N_ _F_ _IF_ARGS_ 0 0 X 5 _!_ _TUP_4 [(Int -> [Char] -> [(Array (Int, Int) Double, [Char])]), (Int -> Array (Int, Int) Double -> [Char] -> [Char]), ([Char] -> [([Array (Int, Int) Double], [Char])]), ([Array (Int, Int) Double] -> [Char] -> [Char])] [_CONSTM_ Text readsPrec (Array (Int, Int) Double), _CONSTM_ Text showsPrec (Array (Int, Int) Double), _CONSTM_ Text readList (Array (Int, Int) Double), _CONSTM_ Text showList (Array (Int, Int) Double)] _N_
+ readsPrec = { _A_ 1 _U_ 12 _N_ _S_ "U(P)" {_A_ 1 _U_ 22 _N_ _N_ _N_ _N_} _N_ _N_ },
+ showsPrec = { _A_ 2 _U_ 122 _N_ _N_ _N_ _N_ },
+ readList = { _A_ 0 _U_ 2 _N_ _N_ _N_ _N_ },
+ showList = { _A_ 0 _U_ 12 _N_ _N_ _N_ _N_ } #-}
instance (Ix a, Text a, Text b) => Text (Array a b)
{-# GHC_PRAGMA _M_ PreludeArray {-dfun-} _A_ 3 _U_ 222 _N_ _N_ _N_ _N_ #-}
+instance Text (Array Int Double)
+ {-# GHC_PRAGMA _M_ PreludeArray {-dfun-} _A_ 0 _N_ _N_ _N_ _F_ _IF_ARGS_ 0 0 X 5 _!_ _TUP_4 [(Int -> [Char] -> [(Array Int Double, [Char])]), (Int -> Array Int Double -> [Char] -> [Char]), ([Char] -> [([Array Int Double], [Char])]), ([Array Int Double] -> [Char] -> [Char])] [_CONSTM_ Text readsPrec (Array Int Double), _CONSTM_ Text showsPrec (Array Int Double), _CONSTM_ Text readList (Array Int Double), _CONSTM_ Text showList (Array Int Double)] _N_
+ readsPrec = { _A_ 1 _U_ 12 _N_ _S_ "U(P)" {_A_ 1 _U_ 22 _N_ _N_ _N_ _N_} _N_ _N_ },
+ showsPrec = { _A_ 2 _U_ 122 _N_ _N_ _N_ _N_ },
+ readList = { _A_ 0 _U_ 2 _N_ _N_ _N_ _N_ },
+ showList = { _A_ 0 _U_ 12 _N_ _N_ _N_ _N_ } #-}
instance (Text a, Text b) => Text (Assoc a b)
{-# GHC_PRAGMA _M_ PreludeArray {-dfun-} _A_ 2 _U_ 22 _N_ _N_ _N_ _N_ #-}
instance Text Bool
{-# GHC_PRAGMA _M_ PreludeCore {-dfun-} _A_ 0 _N_ _N_ _N_ _F_ _IF_ARGS_ 0 0 X 5 _!_ _TUP_4 [(Int -> [Char] -> [(Bool, [Char])]), (Int -> Bool -> [Char] -> [Char]), ([Char] -> [([Bool], [Char])]), ([Bool] -> [Char] -> [Char])] [_CONSTM_ Text readsPrec (Bool), _CONSTM_ Text showsPrec (Bool), _CONSTM_ Text readList (Bool), _CONSTM_ Text showList (Bool)] _N_
- readsPrec = _A_ 2 _U_ 02 _N_ _S_ "AL" {_A_ 1 _U_ 2 _N_ _N_ _N_ _N_} _N_ _N_,
- showsPrec = _A_ 3 _U_ 012 _N_ _S_ "AEL" {_A_ 2 _U_ 12 _N_ _N_ _N_ _N_} _N_ _N_,
- readList = _A_ 0 _U_ 2 _N_ _N_ _N_ _N_,
- showList = _A_ 0 _U_ 12 _N_ _N_ _N_ _N_ #-}
+ readsPrec = { _A_ 2 _U_ 02 _N_ _S_ "AL" {_A_ 1 _U_ 2 _N_ _N_ _N_ _N_} _N_ _N_ },
+ showsPrec = { _A_ 3 _U_ 012 _N_ _S_ "AEL" {_A_ 2 _U_ 12 _N_ _N_ _N_ _N_} _N_ _N_ },
+ readList = { _A_ 0 _U_ 2 _N_ _N_ _N_ _N_ },
+ showList = { _A_ 1 _U_ 12 _N_ _N_ _F_ _IF_ARGS_ 0 1 X 3 \ (u0 :: [Bool]) -> _APP_ _TYAPP_ _ORIG_ PreludeCore _showList { Bool } [ _WRKR_ _CONSTM_ Text showsPrec (Bool), u0 ] _N_ } #-}
instance Text Char
{-# GHC_PRAGMA _M_ PreludeCore {-dfun-} _A_ 0 _N_ _N_ _N_ _F_ _IF_ARGS_ 0 0 X 5 _!_ _TUP_4 [(Int -> [Char] -> [(Char, [Char])]), (Int -> Char -> [Char] -> [Char]), ([Char] -> [([Char], [Char])]), ([Char] -> [Char] -> [Char])] [_CONSTM_ Text readsPrec (Char), _CONSTM_ Text showsPrec (Char), _CONSTM_ Text readList (Char), _CONSTM_ Text showList (Char)] _N_
- readsPrec = _A_ 1 _U_ 02 _N_ _S_ "A" {_A_ 0 _U_ 2 _N_ _N_ _N_ _N_} _N_ _N_,
- showsPrec = _A_ 3 _U_ 012 _N_ _S_ "AU(P)L" {_A_ 2 _U_ 22 _N_ _N_ _N_ _N_} _N_ _N_,
- readList = _A_ 0 _U_ 2 _N_ _N_ _N_ _N_,
- showList = _A_ 1 _U_ 22 _N_ _N_ _N_ _N_ #-}
+ readsPrec = { _A_ 1 _U_ 02 _N_ _S_ "A" {_A_ 0 _U_ 2 _N_ _N_ _N_ _N_} _N_ _N_ },
+ showsPrec = { _A_ 3 _U_ 012 _N_ _S_ "AU(P)L" {_A_ 2 _U_ 22 _N_ _N_ _N_ _N_} _N_ _N_ },
+ readList = { _A_ 0 _U_ 2 _N_ _N_ _N_ _N_ },
+ showList = { _A_ 1 _U_ 22 _N_ _N_ _N_ _N_ } #-}
instance Text a => Text (Complex a)
{-# GHC_PRAGMA _M_ PreludeComplex {-dfun-} _A_ 1 _U_ 2 _N_ _N_ _N_ _N_ #-}
+instance Text (Complex Double)
+ {-# GHC_PRAGMA _M_ PreludeComplex {-dfun-} _A_ 0 _N_ _N_ _N_ _F_ _IF_ARGS_ 0 0 X 5 _!_ _TUP_4 [(Int -> [Char] -> [(Complex Double, [Char])]), (Int -> Complex Double -> [Char] -> [Char]), ([Char] -> [([Complex Double], [Char])]), ([Complex Double] -> [Char] -> [Char])] [_CONSTM_ Text readsPrec (Complex Double), _CONSTM_ Text showsPrec (Complex Double), _CONSTM_ Text readList (Complex Double), _CONSTM_ Text showList (Complex Double)] _N_
+ readsPrec = { _A_ 1 _U_ 12 _N_ _S_ "U(P)" {_A_ 1 _U_ 22 _N_ _N_ _N_ _N_} _N_ _N_ },
+ showsPrec = { _A_ 2 _U_ 112 _N_ _S_ "LU(LL)" {_A_ 3 _U_ 1222 _N_ _N_ _N_ _N_} _N_ _N_ },
+ readList = { _A_ 0 _U_ 2 _N_ _N_ _N_ _N_ },
+ showList = { _A_ 1 _U_ 12 _N_ _N_ _N_ _N_ } #-}
instance Text Double
{-# GHC_PRAGMA _M_ PreludeCore {-dfun-} _A_ 0 _N_ _N_ _N_ _F_ _IF_ARGS_ 0 0 X 5 _!_ _TUP_4 [(Int -> [Char] -> [(Double, [Char])]), (Int -> Double -> [Char] -> [Char]), ([Char] -> [([Double], [Char])]), ([Double] -> [Char] -> [Char])] [_CONSTM_ Text readsPrec (Double), _CONSTM_ Text showsPrec (Double), _CONSTM_ Text readList (Double), _CONSTM_ Text showList (Double)] _N_
- readsPrec = _A_ 2 _U_ 02 _N_ _S_ "AL" {_A_ 1 _U_ 2 _N_ _N_ _F_ _IF_ARGS_ 0 1 X 3 \ (u0 :: [Char]) -> _APP_ _SPEC_ _ORIG_ PreludeText readSigned [ (Double) ] [ _SPEC_ _ORIG_ PreludeText readFloat [ (Double) ], u0 ] _N_} _F_ _IF_ARGS_ 0 2 XX 3 \ (u0 :: Int) (u1 :: [Char]) -> _APP_ _SPEC_ _ORIG_ PreludeText readSigned [ (Double) ] [ _SPEC_ _ORIG_ PreludeText readFloat [ (Double) ], u1 ] _N_,
- showsPrec = _A_ 2 _U_ 212 _N_ _S_ "LU(P)" {_A_ 2 _U_ 222 _N_ _N_ _F_ _IF_ARGS_ 0 2 XX 4 \ (u0 :: Int) (u1 :: Double#) -> _APP_ _WRKR_ _SPEC_ _ORIG_ PreludeText showSigned [ (Double) ] [ _SPEC_ _ORIG_ PreludeText showFloat [ (Double) ], u0, u1 ] _N_} _F_ _IF_ARGS_ 0 2 XC 5 \ (u0 :: Int) (u1 :: Double) -> case u1 of { _ALG_ D# (u2 :: Double#) -> _APP_ _WRKR_ _SPEC_ _ORIG_ PreludeText showSigned [ (Double) ] [ _SPEC_ _ORIG_ PreludeText showFloat [ (Double) ], u0, u2 ]; _NO_DEFLT_ } _N_,
- readList = _A_ 0 _U_ 2 _N_ _N_ _N_ _N_,
- showList = _A_ 0 _U_ 12 _N_ _N_ _N_ _N_ #-}
+ readsPrec = { _A_ 2 _U_ 02 _N_ _S_ "AL" {_A_ 1 _U_ 2 _N_ _N_ _F_ _IF_ARGS_ 0 1 X 3 \ (u0 :: [Char]) -> _APP_ _SPEC_ _ORIG_ PreludeText readSigned [ (Double) ] [ _SPEC_ _ORIG_ PreludeText readFloat [ (Double) ], u0 ] _N_} _F_ _IF_ARGS_ 0 2 XX 3 \ (u0 :: Int) (u1 :: [Char]) -> _APP_ _SPEC_ _ORIG_ PreludeText readSigned [ (Double) ] [ _SPEC_ _ORIG_ PreludeText readFloat [ (Double) ], u1 ] _N_ },
+ showsPrec = { _A_ 2 _U_ 212 _N_ _S_ "LU(P)" {_A_ 2 _U_ 222 _N_ _N_ _F_ _IF_ARGS_ 0 2 XX 4 \ (u0 :: Int) (u1 :: Double#) -> _APP_ _WRKR_ _SPEC_ _ORIG_ PreludeText showSigned [ (Double) ] [ _SPEC_ _ORIG_ PreludeText showFloat [ (Double) ], u0, u1 ] _N_} _F_ _IF_ARGS_ 0 2 XC 5 \ (u0 :: Int) (u1 :: Double) -> case u1 of { _ALG_ D# (u2 :: Double#) -> _APP_ _WRKR_ _SPEC_ _ORIG_ PreludeText showSigned [ (Double) ] [ _SPEC_ _ORIG_ PreludeText showFloat [ (Double) ], u0, u2 ]; _NO_DEFLT_ } _N_ },
+ readList = { _A_ 0 _U_ 2 _N_ _N_ _N_ _N_ },
+ showList = { _A_ 1 _U_ 12 _N_ _N_ _N_ _N_ } #-}
instance (Text a, Text b) => Text (Either a b)
{-# GHC_PRAGMA _M_ PreludeMonadicIO {-dfun-} _A_ 2 _U_ 22 _N_ _N_ _N_ _N_ #-}
instance Text Float
{-# GHC_PRAGMA _M_ PreludeCore {-dfun-} _A_ 0 _N_ _N_ _N_ _F_ _IF_ARGS_ 0 0 X 5 _!_ _TUP_4 [(Int -> [Char] -> [(Float, [Char])]), (Int -> Float -> [Char] -> [Char]), ([Char] -> [([Float], [Char])]), ([Float] -> [Char] -> [Char])] [_CONSTM_ Text readsPrec (Float), _CONSTM_ Text showsPrec (Float), _CONSTM_ Text readList (Float), _CONSTM_ Text showList (Float)] _N_
- readsPrec = _A_ 2 _U_ 02 _N_ _S_ "AL" {_A_ 1 _U_ 2 _N_ _N_ _N_ _N_} _N_ _N_,
- showsPrec = _A_ 1 _U_ 222 _N_ _N_ _N_ _N_,
- readList = _A_ 0 _U_ 2 _N_ _N_ _N_ _N_,
- showList = _A_ 0 _U_ 12 _N_ _N_ _N_ _N_ #-}
+ readsPrec = { _A_ 2 _U_ 02 _N_ _S_ "AL" {_A_ 1 _U_ 2 _N_ _N_ _N_ _N_} _N_ _N_ },
+ showsPrec = { _A_ 1 _U_ 222 _N_ _N_ _N_ _N_ },
+ readList = { _A_ 0 _U_ 2 _N_ _N_ _N_ _N_ },
+ showList = { _A_ 0 _U_ 12 _N_ _N_ _N_ _N_ } #-}
instance Text IOError13
{-# GHC_PRAGMA _M_ PreludeIOError {-dfun-} _A_ 0 _N_ _N_ _N_ _F_ _IF_ARGS_ 0 0 X 5 _!_ _TUP_4 [(Int -> [Char] -> [(IOError13, [Char])]), (Int -> IOError13 -> [Char] -> [Char]), ([Char] -> [([IOError13], [Char])]), ([IOError13] -> [Char] -> [Char])] [_CONSTM_ Text readsPrec (IOError13), _CONSTM_ Text showsPrec (IOError13), _CONSTM_ Text readList (IOError13), _CONSTM_ Text showList (IOError13)] _N_
- readsPrec = _A_ 2 _U_ 22 _N_ _S_ _!_ _F_ _IF_ARGS_ 0 2 XX 4 \ (u0 :: Int) (u1 :: [Char]) -> _APP_ _TYAPP_ patError# { (Int -> [Char] -> [(IOError13, [Char])]) } [ _NOREP_S_ "%DPreludeCore.Text.readsPrec\"", u0, u1 ] _N_,
- showsPrec = _A_ 2 _U_ 012 _N_ _S_ "AS" {_A_ 1 _U_ 12 _N_ _N_ _N_ _N_} _N_ _N_,
- readList = _A_ 0 _U_ 2 _N_ _N_ _N_ _N_,
- showList = _A_ 0 _U_ 12 _N_ _N_ _N_ _N_ #-}
+ readsPrec = { _A_ 2 _U_ 02 _N_ _S_ _!_ _N_ _N_ },
+ showsPrec = { _A_ 2 _U_ 012 _N_ _S_ "AS" {_A_ 1 _U_ 12 _N_ _N_ _N_ _N_} _N_ _N_ },
+ readList = { _A_ 0 _U_ 2 _N_ _N_ _N_ _N_ },
+ showList = { _A_ 1 _U_ 12 _N_ _N_ _F_ _IF_ARGS_ 0 1 X 3 \ (u0 :: [IOError13]) -> _APP_ _TYAPP_ _ORIG_ PreludeCore _showList { IOError13 } [ _WRKR_ _CONSTM_ Text showsPrec (IOError13), u0 ] _N_ } #-}
instance Text Int
{-# GHC_PRAGMA _M_ PreludeCore {-dfun-} _A_ 0 _N_ _N_ _N_ _F_ _IF_ARGS_ 0 0 X 5 _!_ _TUP_4 [(Int -> [Char] -> [(Int, [Char])]), (Int -> Int -> [Char] -> [Char]), ([Char] -> [([Int], [Char])]), ([Int] -> [Char] -> [Char])] [_CONSTM_ Text readsPrec (Int), _CONSTM_ Text showsPrec (Int), _CONSTM_ Text readList (Int), _CONSTM_ Text showList (Int)] _N_
- readsPrec = _A_ 2 _U_ 02 _N_ _S_ "AL" {_A_ 1 _U_ 2 _N_ _N_ _F_ _IF_ARGS_ 0 1 X 3 \ (u0 :: [Char]) -> _APP_ _SPEC_ _ORIG_ PreludeText readSigned [ (Int) ] [ _SPEC_ _ORIG_ PreludeText readDec [ (Int) ], u0 ] _N_} _F_ _IF_ARGS_ 0 2 XX 3 \ (u0 :: Int) (u1 :: [Char]) -> _APP_ _SPEC_ _ORIG_ PreludeText readSigned [ (Int) ] [ _SPEC_ _ORIG_ PreludeText readDec [ (Int) ], u1 ] _N_,
- showsPrec = _A_ 3 _U_ 212 _N_ _S_ "LU(P)L" {_A_ 3 _U_ 222 _N_ _N_ _N_ _N_} _N_ _N_,
- readList = _A_ 0 _U_ 2 _N_ _N_ _N_ _N_,
- showList = _A_ 0 _U_ 12 _N_ _N_ _N_ _N_ #-}
+ readsPrec = { _A_ 2 _U_ 02 _N_ _S_ "AL" {_A_ 1 _U_ 2 _N_ _N_ _F_ _IF_ARGS_ 0 1 X 3 \ (u0 :: [Char]) -> _APP_ _SPEC_ _ORIG_ PreludeText readSigned [ (Int) ] [ _SPEC_ _ORIG_ PreludeText readDec [ (Int) ], u0 ] _N_} _F_ _IF_ARGS_ 0 2 XX 3 \ (u0 :: Int) (u1 :: [Char]) -> _APP_ _SPEC_ _ORIG_ PreludeText readSigned [ (Int) ] [ _SPEC_ _ORIG_ PreludeText readDec [ (Int) ], u1 ] _N_ },
+ showsPrec = { _A_ 3 _U_ 212 _N_ _S_ "LU(P)L" {_A_ 3 _U_ 222 _N_ _N_ _N_ _N_} _N_ _N_ },
+ readList = { _A_ 0 _U_ 2 _N_ _N_ _N_ _N_ },
+ showList = { _A_ 1 _U_ 12 _N_ _N_ _N_ _N_ } #-}
instance Text Integer
{-# GHC_PRAGMA _M_ PreludeCore {-dfun-} _A_ 0 _N_ _N_ _N_ _F_ _IF_ARGS_ 0 0 X 5 _!_ _TUP_4 [(Int -> [Char] -> [(Integer, [Char])]), (Int -> Integer -> [Char] -> [Char]), ([Char] -> [([Integer], [Char])]), ([Integer] -> [Char] -> [Char])] [_CONSTM_ Text readsPrec (Integer), _CONSTM_ Text showsPrec (Integer), _CONSTM_ Text readList (Integer), _CONSTM_ Text showList (Integer)] _N_
- readsPrec = _A_ 2 _U_ 02 _N_ _S_ "AL" {_A_ 1 _U_ 2 _N_ _N_ _F_ _IF_ARGS_ 0 1 X 3 \ (u0 :: [Char]) -> _APP_ _SPEC_ _ORIG_ PreludeText readSigned [ (Integer) ] [ _SPEC_ _ORIG_ PreludeText readDec [ (Integer) ], u0 ] _N_} _F_ _IF_ARGS_ 0 2 XX 3 \ (u0 :: Int) (u1 :: [Char]) -> _APP_ _SPEC_ _ORIG_ PreludeText readSigned [ (Integer) ] [ _SPEC_ _ORIG_ PreludeText readDec [ (Integer) ], u1 ] _N_,
- showsPrec = _A_ 3 _U_ 212 _N_ _S_ "LU(PPP)L" {_A_ 5 _U_ 22222 _N_ _N_ _N_ _N_} _N_ _N_,
- readList = _A_ 0 _U_ 2 _N_ _N_ _N_ _N_,
- showList = _A_ 0 _U_ 12 _N_ _N_ _N_ _N_ #-}
+ readsPrec = { _A_ 2 _U_ 02 _N_ _S_ "AL" {_A_ 1 _U_ 2 _N_ _N_ _F_ _IF_ARGS_ 0 1 X 3 \ (u0 :: [Char]) -> _APP_ _SPEC_ _ORIG_ PreludeText readSigned [ (Integer) ] [ _SPEC_ _ORIG_ PreludeText readDec [ (Integer) ], u0 ] _N_} _F_ _IF_ARGS_ 0 2 XX 3 \ (u0 :: Int) (u1 :: [Char]) -> _APP_ _SPEC_ _ORIG_ PreludeText readSigned [ (Integer) ] [ _SPEC_ _ORIG_ PreludeText readDec [ (Integer) ], u1 ] _N_ },
+ showsPrec = { _A_ 3 _U_ 212 _N_ _S_ "LU(PPP)L" {_A_ 5 _U_ 22222 _N_ _N_ _N_ _N_} _N_ _N_ },
+ readList = { _A_ 0 _U_ 2 _N_ _N_ _N_ _N_ },
+ showList = { _A_ 1 _U_ 12 _N_ _N_ _N_ _N_ } #-}
instance Text a => Text (Maybe a)
{-# GHC_PRAGMA _M_ PreludeStdIO {-dfun-} _A_ 1 _U_ 2 _N_ _N_ _N_ _N_ #-}
instance Integral a => Text (Ratio a)
{-# GHC_PRAGMA _M_ PreludeRatio {-dfun-} _A_ 1 _U_ 2 _N_ _N_ _N_ _N_ #-}
instance Text (Ratio Integer)
{-# GHC_PRAGMA _M_ PreludeRatio {-dfun-} _A_ 0 _N_ _N_ _N_ _F_ _IF_ARGS_ 0 0 X 5 _!_ _TUP_4 [(Int -> [Char] -> [(Ratio Integer, [Char])]), (Int -> Ratio Integer -> [Char] -> [Char]), ([Char] -> [([Ratio Integer], [Char])]), ([Ratio Integer] -> [Char] -> [Char])] [_CONSTM_ Text readsPrec (Ratio Integer), _CONSTM_ Text showsPrec (Ratio Integer), _CONSTM_ Text readList (Ratio Integer), _CONSTM_ Text showList (Ratio Integer)] _N_
- readsPrec = _A_ 1 _U_ 12 _N_ _S_ "U(P)" {_A_ 1 _U_ 22 _N_ _N_ _N_ _N_} _N_ _N_,
- showsPrec = _A_ 2 _U_ 112 _N_ _S_ "LU(LL)" {_A_ 3 _U_ 1222 _N_ _N_ _N_ _N_} _N_ _N_,
- readList = _A_ 0 _U_ 2 _N_ _N_ _N_ _N_,
- showList = _A_ 0 _U_ 12 _N_ _N_ _N_ _N_ #-}
+ readsPrec = { _A_ 1 _U_ 12 _N_ _S_ "U(P)" {_A_ 1 _U_ 22 _N_ _N_ _N_ _N_} _N_ _N_ },
+ showsPrec = { _A_ 2 _U_ 112 _N_ _S_ "LU(LL)" {_A_ 3 _U_ 1222 _N_ _N_ _N_ _N_} _N_ _N_ },
+ readList = { _A_ 0 _U_ 2 _N_ _N_ _N_ _N_ },
+ showList = { _A_ 1 _U_ 12 _N_ _N_ _N_ _N_ } #-}
instance Text a => Text [a]
{-# GHC_PRAGMA _M_ PreludeBuiltin {-dfun-} _A_ 1 _U_ 2 _N_ _N_ _N_ _N_ #-}
+instance Text [Bool]
+ {-# GHC_PRAGMA _M_ PreludeBuiltin {-dfun-} _A_ 0 _N_ _N_ _N_ _F_ _IF_ARGS_ 0 0 X 5 _!_ _TUP_4 [(Int -> [Char] -> [([Bool], [Char])]), (Int -> [Bool] -> [Char] -> [Char]), ([Char] -> [([[Bool]], [Char])]), ([[Bool]] -> [Char] -> [Char])] [_CONSTM_ Text readsPrec ([Bool]), _CONSTM_ Text showsPrec ([Bool]), _CONSTM_ Text readList ([Bool]), _CONSTM_ Text showList ([Bool])] _N_
+ readsPrec = { _A_ 1 _U_ 02 _N_ _S_ "A" {_A_ 0 _U_ 2 _N_ _N_ _F_ _IF_ARGS_ 0 0 X 1 _CONSTM_ Text readList (Bool) _N_} _F_ _IF_ARGS_ 0 1 X 1 \ (u0 :: Int) -> _CONSTM_ Text readList (Bool) _N_ },
+ showsPrec = { _A_ 2 _U_ 012 _N_ _S_ "AS" {_A_ 1 _U_ 12 _N_ _N_ _F_ _IF_ARGS_ 0 1 X 3 \ (u0 :: [Bool]) -> _APP_ _TYAPP_ _ORIG_ PreludeCore _showList { Bool } [ _WRKR_ _CONSTM_ Text showsPrec (Bool), u0 ] _N_} _F_ _IF_ARGS_ 0 2 XX 3 \ (u0 :: Int) (u1 :: [Bool]) -> _APP_ _TYAPP_ _ORIG_ PreludeCore _showList { Bool } [ _WRKR_ _CONSTM_ Text showsPrec (Bool), u1 ] _N_ },
+ readList = { _A_ 0 _U_ 2 _N_ _N_ _N_ _N_ },
+ showList = { _A_ 1 _U_ 12 _N_ _N_ _N_ _N_ } #-}
instance Text [Char]
{-# GHC_PRAGMA _M_ PreludeBuiltin {-dfun-} _A_ 0 _N_ _N_ _N_ _F_ _IF_ARGS_ 0 0 X 5 _!_ _TUP_4 [(Int -> [Char] -> [([Char], [Char])]), (Int -> [Char] -> [Char] -> [Char]), ([Char] -> [([[Char]], [Char])]), ([[Char]] -> [Char] -> [Char])] [_CONSTM_ Text readsPrec ([Char]), _CONSTM_ Text showsPrec ([Char]), _CONSTM_ Text readList ([Char]), _CONSTM_ Text showList ([Char])] _N_
- readsPrec = _A_ 1 _U_ 02 _N_ _S_ "A" {_A_ 0 _U_ 2 _N_ _N_ _F_ _IF_ARGS_ 0 0 X 1 _CONSTM_ Text readList (Char) _N_} _F_ _IF_ARGS_ 0 1 X 1 \ (u0 :: Int) -> _CONSTM_ Text readList (Char) _N_,
- showsPrec = _A_ 2 _U_ 022 _N_ _S_ "AL" {_A_ 1 _U_ 22 _N_ _N_ _F_ _IF_ARGS_ 0 0 X 1 _CONSTM_ Text showList (Char) _N_} _F_ _IF_ARGS_ 0 2 XX 2 \ (u0 :: Int) (u1 :: [Char]) -> _APP_ _CONSTM_ Text showList (Char) [ u1 ] _N_,
- readList = _A_ 0 _U_ 2 _N_ _N_ _N_ _N_,
- showList = _A_ 0 _U_ 12 _N_ _N_ _N_ _N_ #-}
+ readsPrec = { _A_ 1 _U_ 02 _N_ _S_ "A" {_A_ 0 _U_ 2 _N_ _N_ _F_ _IF_ARGS_ 0 0 X 1 _CONSTM_ Text readList (Char) _N_} _F_ _IF_ARGS_ 0 1 X 1 \ (u0 :: Int) -> _CONSTM_ Text readList (Char) _N_ },
+ showsPrec = { _A_ 2 _U_ 022 _N_ _S_ "AL" {_A_ 1 _U_ 22 _N_ _N_ _F_ _IF_ARGS_ 0 0 X 1 _CONSTM_ Text showList (Char) _N_} _F_ _IF_ARGS_ 0 2 XX 2 \ (u0 :: Int) (u1 :: [Char]) -> _APP_ _CONSTM_ Text showList (Char) [ u1 ] _N_ },
+ readList = { _A_ 0 _U_ 2 _N_ _N_ _N_ _N_ },
+ showList = { _A_ 1 _U_ 12 _N_ _N_ _F_ _IF_ARGS_ 0 1 X 3 \ (u0 :: [[Char]]) -> _APP_ _TYAPP_ _ORIG_ PreludeCore _showList { [Char] } [ _CONSTM_ Text showList (Char), u0 ] _N_ } #-}
+instance Text [Complex Double]
+ {-# GHC_PRAGMA _M_ PreludeBuiltin {-dfun-} _A_ 0 _N_ _N_ _N_ _F_ _IF_ARGS_ 0 0 X 5 _!_ _TUP_4 [(Int -> [Char] -> [([Complex Double], [Char])]), (Int -> [Complex Double] -> [Char] -> [Char]), ([Char] -> [([[Complex Double]], [Char])]), ([[Complex Double]] -> [Char] -> [Char])] [_CONSTM_ Text readsPrec ([Complex Double]), _CONSTM_ Text showsPrec ([Complex Double]), _CONSTM_ Text readList ([Complex Double]), _CONSTM_ Text showList ([Complex Double])] _N_
+ readsPrec = { _A_ 1 _U_ 02 _N_ _S_ "A" {_A_ 0 _U_ 2 _N_ _N_ _F_ _IF_ARGS_ 0 0 X 1 _CONSTM_ Text readList (Complex Double) _N_} _F_ _IF_ARGS_ 0 1 X 1 \ (u0 :: Int) -> _CONSTM_ Text readList (Complex Double) _N_ },
+ showsPrec = { _A_ 2 _U_ 022 _N_ _S_ "AL" {_A_ 1 _U_ 22 _N_ _N_ _F_ _IF_ARGS_ 0 0 X 1 _CONSTM_ Text showList (Complex Double) _N_} _F_ _IF_ARGS_ 0 2 XX 2 \ (u0 :: Int) (u1 :: [Complex Double]) -> _APP_ _CONSTM_ Text showList (Complex Double) [ u1 ] _N_ },
+ readList = { _A_ 0 _U_ 2 _N_ _N_ _N_ _N_ },
+ showList = { _A_ 1 _U_ 12 _N_ _N_ _F_ _IF_ARGS_ 0 1 X 3 \ (u0 :: [[Complex Double]]) -> _APP_ _TYAPP_ _ORIG_ PreludeCore _showList { [Complex Double] } [ _CONSTM_ Text showList (Complex Double), u0 ] _N_ } #-}
+instance Text [Double]
+ {-# GHC_PRAGMA _M_ PreludeBuiltin {-dfun-} _A_ 0 _N_ _N_ _N_ _F_ _IF_ARGS_ 0 0 X 5 _!_ _TUP_4 [(Int -> [Char] -> [([Double], [Char])]), (Int -> [Double] -> [Char] -> [Char]), ([Char] -> [([[Double]], [Char])]), ([[Double]] -> [Char] -> [Char])] [_CONSTM_ Text readsPrec ([Double]), _CONSTM_ Text showsPrec ([Double]), _CONSTM_ Text readList ([Double]), _CONSTM_ Text showList ([Double])] _N_
+ readsPrec = { _A_ 1 _U_ 02 _N_ _S_ "A" {_A_ 0 _U_ 2 _N_ _N_ _F_ _IF_ARGS_ 0 0 X 1 _CONSTM_ Text readList (Double) _N_} _F_ _IF_ARGS_ 0 1 X 1 \ (u0 :: Int) -> _CONSTM_ Text readList (Double) _N_ },
+ showsPrec = { _A_ 2 _U_ 022 _N_ _S_ "AL" {_A_ 1 _U_ 22 _N_ _N_ _F_ _IF_ARGS_ 0 0 X 1 _CONSTM_ Text showList (Double) _N_} _F_ _IF_ARGS_ 0 2 XX 2 \ (u0 :: Int) (u1 :: [Double]) -> _APP_ _CONSTM_ Text showList (Double) [ u1 ] _N_ },
+ readList = { _A_ 0 _U_ 2 _N_ _N_ _N_ _N_ },
+ showList = { _A_ 1 _U_ 12 _N_ _N_ _F_ _IF_ARGS_ 0 1 X 3 \ (u0 :: [[Double]]) -> _APP_ _TYAPP_ _ORIG_ PreludeCore _showList { [Double] } [ _CONSTM_ Text showList (Double), u0 ] _N_ } #-}
instance Text [Int]
{-# GHC_PRAGMA _M_ PreludeBuiltin {-dfun-} _A_ 0 _N_ _N_ _N_ _F_ _IF_ARGS_ 0 0 X 5 _!_ _TUP_4 [(Int -> [Char] -> [([Int], [Char])]), (Int -> [Int] -> [Char] -> [Char]), ([Char] -> [([[Int]], [Char])]), ([[Int]] -> [Char] -> [Char])] [_CONSTM_ Text readsPrec ([Int]), _CONSTM_ Text showsPrec ([Int]), _CONSTM_ Text readList ([Int]), _CONSTM_ Text showList ([Int])] _N_
- readsPrec = _A_ 1 _U_ 02 _N_ _S_ "A" {_A_ 0 _U_ 2 _N_ _N_ _F_ _IF_ARGS_ 0 0 X 1 _CONSTM_ Text readList (Int) _N_} _F_ _IF_ARGS_ 0 1 X 1 \ (u0 :: Int) -> _CONSTM_ Text readList (Int) _N_,
- showsPrec = _A_ 1 _U_ 022 _N_ _S_ "A" {_A_ 0 _U_ 22 _N_ _N_ _F_ _IF_ARGS_ 0 0 X 1 _CONSTM_ Text showList (Int) _N_} _F_ _IF_ARGS_ 0 1 X 1 \ (u0 :: Int) -> _CONSTM_ Text showList (Int) _N_,
- readList = _A_ 0 _U_ 2 _N_ _N_ _N_ _N_,
- showList = _A_ 0 _U_ 12 _N_ _N_ _N_ _N_ #-}
+ readsPrec = { _A_ 1 _U_ 02 _N_ _S_ "A" {_A_ 0 _U_ 2 _N_ _N_ _F_ _IF_ARGS_ 0 0 X 1 _CONSTM_ Text readList (Int) _N_} _F_ _IF_ARGS_ 0 1 X 1 \ (u0 :: Int) -> _CONSTM_ Text readList (Int) _N_ },
+ showsPrec = { _A_ 2 _U_ 022 _N_ _S_ "AL" {_A_ 1 _U_ 22 _N_ _N_ _F_ _IF_ARGS_ 0 0 X 1 _CONSTM_ Text showList (Int) _N_} _F_ _IF_ARGS_ 0 2 XX 2 \ (u0 :: Int) (u1 :: [Int]) -> _APP_ _CONSTM_ Text showList (Int) [ u1 ] _N_ },
+ readList = { _A_ 0 _U_ 2 _N_ _N_ _N_ _N_ },
+ showList = { _A_ 1 _U_ 12 _N_ _N_ _F_ _IF_ARGS_ 0 1 X 3 \ (u0 :: [[Int]]) -> _APP_ _TYAPP_ _ORIG_ PreludeCore _showList { [Int] } [ _CONSTM_ Text showList (Int), u0 ] _N_ } #-}
+instance Text [Integer]
+ {-# GHC_PRAGMA _M_ PreludeBuiltin {-dfun-} _A_ 0 _N_ _N_ _N_ _F_ _IF_ARGS_ 0 0 X 5 _!_ _TUP_4 [(Int -> [Char] -> [([Integer], [Char])]), (Int -> [Integer] -> [Char] -> [Char]), ([Char] -> [([[Integer]], [Char])]), ([[Integer]] -> [Char] -> [Char])] [_CONSTM_ Text readsPrec ([Integer]), _CONSTM_ Text showsPrec ([Integer]), _CONSTM_ Text readList ([Integer]), _CONSTM_ Text showList ([Integer])] _N_
+ readsPrec = { _A_ 1 _U_ 02 _N_ _S_ "A" {_A_ 0 _U_ 2 _N_ _N_ _F_ _IF_ARGS_ 0 0 X 1 _CONSTM_ Text readList (Integer) _N_} _F_ _IF_ARGS_ 0 1 X 1 \ (u0 :: Int) -> _CONSTM_ Text readList (Integer) _N_ },
+ showsPrec = { _A_ 2 _U_ 022 _N_ _S_ "AL" {_A_ 1 _U_ 22 _N_ _N_ _F_ _IF_ARGS_ 0 0 X 1 _CONSTM_ Text showList (Integer) _N_} _F_ _IF_ARGS_ 0 2 XX 2 \ (u0 :: Int) (u1 :: [Integer]) -> _APP_ _CONSTM_ Text showList (Integer) [ u1 ] _N_ },
+ readList = { _A_ 0 _U_ 2 _N_ _N_ _N_ _N_ },
+ showList = { _A_ 1 _U_ 12 _N_ _N_ _F_ _IF_ARGS_ 0 1 X 3 \ (u0 :: [[Integer]]) -> _APP_ _TYAPP_ _ORIG_ PreludeCore _showList { [Integer] } [ _CONSTM_ Text showList (Integer), u0 ] _N_ } #-}
+instance Text [[Char]]
+ {-# GHC_PRAGMA _M_ PreludeBuiltin {-dfun-} _A_ 0 _N_ _N_ _N_ _F_ _IF_ARGS_ 0 0 X 5 _!_ _TUP_4 [(Int -> [Char] -> [([[Char]], [Char])]), (Int -> [[Char]] -> [Char] -> [Char]), ([Char] -> [([[[Char]]], [Char])]), ([[[Char]]] -> [Char] -> [Char])] [_CONSTM_ Text readsPrec ([[Char]]), _CONSTM_ Text showsPrec ([[Char]]), _CONSTM_ Text readList ([[Char]]), _CONSTM_ Text showList ([[Char]])] _N_
+ readsPrec = { _A_ 1 _U_ 02 _N_ _S_ "A" {_A_ 0 _U_ 2 _N_ _N_ _F_ _IF_ARGS_ 0 0 X 1 _CONSTM_ Text readList ([Char]) _N_} _F_ _IF_ARGS_ 0 1 X 1 \ (u0 :: Int) -> _CONSTM_ Text readList ([Char]) _N_ },
+ showsPrec = { _A_ 2 _U_ 012 _N_ _S_ "AS" {_A_ 1 _U_ 12 _N_ _N_ _F_ _IF_ARGS_ 0 1 X 3 \ (u0 :: [[Char]]) -> _APP_ _TYAPP_ _ORIG_ PreludeCore _showList { [Char] } [ _CONSTM_ Text showList (Char), u0 ] _N_} _F_ _IF_ARGS_ 0 2 XX 2 \ (u0 :: Int) (u1 :: [[Char]]) -> _APP_ _CONSTM_ Text showList ([Char]) [ u1 ] _N_ },
+ readList = { _A_ 0 _U_ 2 _N_ _N_ _N_ _N_ },
+ showList = { _A_ 1 _U_ 12 _N_ _N_ _N_ _N_ } #-}
+instance Text [[Int]]
+ {-# GHC_PRAGMA _M_ PreludeBuiltin {-dfun-} _A_ 0 _N_ _N_ _N_ _F_ _IF_ARGS_ 0 0 X 5 _!_ _TUP_4 [(Int -> [Char] -> [([[Int]], [Char])]), (Int -> [[Int]] -> [Char] -> [Char]), ([Char] -> [([[[Int]]], [Char])]), ([[[Int]]] -> [Char] -> [Char])] [_CONSTM_ Text readsPrec ([[Int]]), _CONSTM_ Text showsPrec ([[Int]]), _CONSTM_ Text readList ([[Int]]), _CONSTM_ Text showList ([[Int]])] _N_
+ readsPrec = { _A_ 1 _U_ 02 _N_ _S_ "A" {_A_ 0 _U_ 2 _N_ _N_ _F_ _IF_ARGS_ 0 0 X 1 _CONSTM_ Text readList ([Int]) _N_} _F_ _IF_ARGS_ 0 1 X 1 \ (u0 :: Int) -> _CONSTM_ Text readList ([Int]) _N_ },
+ showsPrec = { _A_ 2 _U_ 012 _N_ _S_ "AS" {_A_ 1 _U_ 12 _N_ _N_ _F_ _IF_ARGS_ 0 1 X 3 \ (u0 :: [[Int]]) -> _APP_ _TYAPP_ _ORIG_ PreludeCore _showList { [Int] } [ _CONSTM_ Text showList (Int), u0 ] _N_} _F_ _IF_ARGS_ 0 2 XX 2 \ (u0 :: Int) (u1 :: [[Int]]) -> _APP_ _CONSTM_ Text showList ([Int]) [ u1 ] _N_ },
+ readList = { _A_ 0 _U_ 2 _N_ _N_ _N_ _N_ },
+ showList = { _A_ 1 _U_ 12 _N_ _N_ _N_ _N_ } #-}
instance Text _PackedString
{-# GHC_PRAGMA _M_ PreludePS {-dfun-} _A_ 0 _N_ _N_ _N_ _F_ _IF_ARGS_ 0 0 X 5 _!_ _TUP_4 [(Int -> [Char] -> [(_PackedString, [Char])]), (Int -> _PackedString -> [Char] -> [Char]), ([Char] -> [([_PackedString], [Char])]), ([_PackedString] -> [Char] -> [Char])] [_CONSTM_ Text readsPrec (_PackedString), _CONSTM_ Text showsPrec (_PackedString), _CONSTM_ Text readList (_PackedString), _CONSTM_ Text showList (_PackedString)] _N_
- readsPrec = _A_ 2 _U_ 02 _N_ _S_ _!_ _F_ _IF_ARGS_ 0 2 XX 3 \ (u0 :: Int) (u1 :: [Char]) -> _APP_ _TYAPP_ error { ([Char] -> [(_PackedString, [Char])]) } [ _NOREP_S_ "readsPrec: _PackedString: ToDo", u1 ] _N_,
- showsPrec = _A_ 3 _U_ 012 _N_ _S_ "ALL" {_A_ 2 _U_ 12 _N_ _N_ _N_ _N_} _F_ _IF_ARGS_ 0 3 XXX 6 \ (u0 :: Int) (u1 :: _PackedString) (u2 :: [Char]) -> let {(u3 :: [Char]) = _APP_ _ORIG_ PreludePS _unpackPS [ u1 ]} in _APP_ _CONSTM_ Text showList (Char) [ u3, u2 ] _N_,
- readList = _A_ 0 _U_ 2 _N_ _N_ _N_ _N_,
- showList = _A_ 0 _U_ 12 _N_ _N_ _N_ _N_ #-}
+ readsPrec = { _A_ 2 _U_ 02 _N_ _S_ _!_ _N_ _N_ },
+ showsPrec = { _A_ 3 _U_ 012 _N_ _S_ "ALL" {_A_ 2 _U_ 12 _N_ _N_ _N_ _N_} _F_ _IF_ARGS_ 0 3 XXX 6 \ (u0 :: Int) (u1 :: _PackedString) (u2 :: [Char]) -> let {(u3 :: [Char]) = _APP_ _ORIG_ PreludePS _unpackPS [ u1 ]} in _APP_ _CONSTM_ Text showList (Char) [ u3, u2 ] _N_ },
+ readList = { _A_ 0 _U_ 2 _N_ _N_ _N_ _N_ },
+ showList = { _A_ 1 _U_ 12 _N_ _N_ _F_ _IF_ARGS_ 0 1 X 3 \ (u0 :: [_PackedString]) -> _APP_ _TYAPP_ _ORIG_ PreludeCore _showList { _PackedString } [ _WRKR_ _CONSTM_ Text showsPrec (_PackedString), u0 ] _N_ } #-}
instance _CCallable Char
{-# GHC_PRAGMA _M_ PreludeCore {-dfun-} _A_ 0 _N_ _N_ _N_ _F_ _IF_ARGS_ 0 0 X 1 _!_ _TUP_0 [] [] _N_ #-}
instance _CCallable Double
-{-# GHC_PRAGMA INTERFACE VERSION 5 #-}
+{-# GHC_PRAGMA INTERFACE VERSION 6 #-}
interface PreludeCore where
import PreludeArray(Array, Assoc(..), _ByteArray)
import PreludeBuiltin(Bin, Char(..), Double(..), Float(..), Int(..), Integer(..), List(..), Tuple0, Tuple2, Tuple3, Tuple4, Tuple5, _Addr(..), _CMP_TAG(..), _RealWorld(..), _State(..), _Word(..))
class Binary a where
readBin :: Bin -> (a, Bin)
{-# GHC_PRAGMA {-meth-} _A_ 1 _U_ 12 _N_ _S_ "S" _F_ _IF_ARGS_ 1 1 C 2 _/\_ u0 -> \ (u1 :: (Bin -> (u0, Bin), u0 -> Bin -> Bin)) -> case u1 of { _ALG_ _TUP_2 (u2 :: Bin -> (u0, Bin)) (u3 :: u0 -> Bin -> Bin) -> u2; _NO_DEFLT_ } _N_
- {-defm-} _A_ 2 _U_ 02 _N_ _S_ _!_ _F_ _IF_ARGS_ 1 2 XX 3 _/\_ u0 -> \ (u1 :: {{Binary u0}}) (u2 :: Bin) -> _APP_ _TYAPP_ patError# { (Bin -> (u0, Bin)) } [ _NOREP_S_ "%DPreludeCore.Binary.readBin\"", u2 ] _N_ #-}
+ {-defm-} _A_ 2 _U_ 02 _N_ _S_ _!_ _N_ _N_ #-}
showBin :: a -> Bin -> Bin
{-# GHC_PRAGMA {-meth-} _A_ 1 _U_ 122 _N_ _S_ "S" _F_ _IF_ARGS_ 1 1 C 2 _/\_ u0 -> \ (u1 :: (Bin -> (u0, Bin), u0 -> Bin -> Bin)) -> case u1 of { _ALG_ _TUP_2 (u2 :: Bin -> (u0, Bin)) (u3 :: u0 -> Bin -> Bin) -> u3; _NO_DEFLT_ } _N_
- {-defm-} _A_ 3 _U_ 022 _N_ _S_ _!_ _F_ _IF_ARGS_ 1 3 XXX 4 _/\_ u0 -> \ (u1 :: {{Binary u0}}) (u2 :: u0) (u3 :: Bin) -> _APP_ _TYAPP_ patError# { (u0 -> Bin -> Bin) } [ _NOREP_S_ "%DPreludeCore.Binary.showBin\"", u2, u3 ] _N_ #-}
+ {-defm-} _A_ 3 _U_ 022 _N_ _S_ _!_ _N_ _N_ #-}
class (Ord a) => Enum a {-# GHC_PRAGMA {-superdicts-} _A_ 1 _U_ 1 _N_ _S_ "S" _F_ _IF_ARGS_ 1 1 C 2 _/\_ u0 -> \ (u1 :: ({{Ord u0}}, u0 -> [u0], u0 -> u0 -> [u0], u0 -> u0 -> [u0], u0 -> u0 -> u0 -> [u0])) -> case u1 of { _ALG_ _TUP_5 (u2 :: {{Ord u0}}) (u3 :: u0 -> [u0]) (u4 :: u0 -> u0 -> [u0]) (u5 :: u0 -> u0 -> [u0]) (u6 :: u0 -> u0 -> u0 -> [u0]) -> u2; _NO_DEFLT_ } _N_ #-} where
enumFrom :: a -> [a]
{-# GHC_PRAGMA {-meth-} _A_ 1 _U_ 12 _N_ _S_ "S" _F_ _IF_ARGS_ 1 1 C 2 _/\_ u0 -> \ (u1 :: ({{Ord u0}}, u0 -> [u0], u0 -> u0 -> [u0], u0 -> u0 -> [u0], u0 -> u0 -> u0 -> [u0])) -> case u1 of { _ALG_ _TUP_5 (u2 :: {{Ord u0}}) (u3 :: u0 -> [u0]) (u4 :: u0 -> u0 -> [u0]) (u5 :: u0 -> u0 -> [u0]) (u6 :: u0 -> u0 -> u0 -> [u0]) -> u3; _NO_DEFLT_ } _N_
- {-defm-} _A_ 2 _U_ 02 _N_ _S_ _!_ _F_ _IF_ARGS_ 1 2 XX 3 _/\_ u0 -> \ (u1 :: {{Enum u0}}) (u2 :: u0) -> _APP_ _TYAPP_ patError# { (u0 -> [u0]) } [ _NOREP_S_ "%DPreludeCore.Enum.enumFrom\"", u2 ] _N_ #-}
+ {-defm-} _A_ 2 _U_ 02 _N_ _S_ _!_ _N_ _N_ #-}
enumFromThen :: a -> a -> [a]
{-# GHC_PRAGMA {-meth-} _A_ 1 _U_ 122 _N_ _S_ "S" _F_ _IF_ARGS_ 1 1 C 2 _/\_ u0 -> \ (u1 :: ({{Ord u0}}, u0 -> [u0], u0 -> u0 -> [u0], u0 -> u0 -> [u0], u0 -> u0 -> u0 -> [u0])) -> case u1 of { _ALG_ _TUP_5 (u2 :: {{Ord u0}}) (u3 :: u0 -> [u0]) (u4 :: u0 -> u0 -> [u0]) (u5 :: u0 -> u0 -> [u0]) (u6 :: u0 -> u0 -> u0 -> [u0]) -> u4; _NO_DEFLT_ } _N_
- {-defm-} _A_ 3 _U_ 022 _N_ _S_ _!_ _F_ _IF_ARGS_ 1 3 XXX 4 _/\_ u0 -> \ (u1 :: {{Enum u0}}) (u2 :: u0) (u3 :: u0) -> _APP_ _TYAPP_ patError# { (u0 -> u0 -> [u0]) } [ _NOREP_S_ "%DPreludeCore.Enum.enumFromThen\"", u2, u3 ] _N_ #-}
+ {-defm-} _A_ 3 _U_ 022 _N_ _S_ _!_ _N_ _N_ #-}
enumFromTo :: a -> a -> [a]
{-# GHC_PRAGMA {-meth-} _A_ 1 _U_ 122 _N_ _S_ "S" _F_ _IF_ARGS_ 1 1 C 2 _/\_ u0 -> \ (u1 :: ({{Ord u0}}, u0 -> [u0], u0 -> u0 -> [u0], u0 -> u0 -> [u0], u0 -> u0 -> u0 -> [u0])) -> case u1 of { _ALG_ _TUP_5 (u2 :: {{Ord u0}}) (u3 :: u0 -> [u0]) (u4 :: u0 -> u0 -> [u0]) (u5 :: u0 -> u0 -> [u0]) (u6 :: u0 -> u0 -> u0 -> [u0]) -> u5; _NO_DEFLT_ } _N_
{-defm-} _A_ 3 _U_ 122 _N_ _S_ "SLL" _N_ _N_ #-}
class Eq a where
(==) :: a -> a -> Bool
{-# GHC_PRAGMA {-meth-} _A_ 1 _U_ 122 _N_ _S_ "S" _F_ _IF_ARGS_ 1 1 C 2 _/\_ u0 -> \ (u1 :: (u0 -> u0 -> Bool, u0 -> u0 -> Bool)) -> case u1 of { _ALG_ _TUP_2 (u2 :: u0 -> u0 -> Bool) (u3 :: u0 -> u0 -> Bool) -> u2; _NO_DEFLT_ } _N_
- {-defm-} _A_ 3 _U_ 022 _N_ _S_ _!_ _F_ _IF_ARGS_ 1 3 XXX 4 _/\_ u0 -> \ (u1 :: {{Eq u0}}) (u2 :: u0) (u3 :: u0) -> _APP_ _TYAPP_ patError# { (u0 -> u0 -> Bool) } [ _NOREP_S_ "%DPreludeCore.Eq.(==)\"", u2, u3 ] _N_ #-}
+ {-defm-} _A_ 3 _U_ 022 _N_ _S_ _!_ _N_ _N_ #-}
(/=) :: a -> a -> Bool
{-# GHC_PRAGMA {-meth-} _A_ 1 _U_ 122 _N_ _S_ "S" _F_ _IF_ARGS_ 1 1 C 2 _/\_ u0 -> \ (u1 :: (u0 -> u0 -> Bool, u0 -> u0 -> Bool)) -> case u1 of { _ALG_ _TUP_2 (u2 :: u0 -> u0 -> Bool) (u3 :: u0 -> u0 -> Bool) -> u3; _NO_DEFLT_ } _N_
{-defm-} _A_ 3 _U_ 122 _N_ _S_ "SLL" _N_ _N_ #-}
class (Fractional a) => Floating a {-# GHC_PRAGMA {-superdicts-} _A_ 1 _U_ 1 _N_ _S_ "S" _F_ _IF_ARGS_ 1 1 C 2 _/\_ u0 -> \ (u1 :: ({{Fractional u0}}, u0, u0 -> u0, u0 -> u0, u0 -> u0, u0 -> u0 -> u0, u0 -> u0 -> u0, u0 -> u0, u0 -> u0, u0 -> u0, u0 -> u0, u0 -> u0, u0 -> u0, u0 -> u0, u0 -> u0, u0 -> u0, u0 -> u0, u0 -> u0, u0 -> u0)) -> case u1 of { _ALG_ _TUP_19 (u2 :: {{Fractional u0}}) (u3 :: u0) (u4 :: u0 -> u0) (u5 :: u0 -> u0) (u6 :: u0 -> u0) (u7 :: u0 -> u0 -> u0) (u8 :: u0 -> u0 -> u0) (u9 :: u0 -> u0) (ua :: u0 -> u0) (ub :: u0 -> u0) (uc :: u0 -> u0) (ud :: u0 -> u0) (ue :: u0 -> u0) (uf :: u0 -> u0) (ug :: u0 -> u0) (uh :: u0 -> u0) (ui :: u0 -> u0) (uj :: u0 -> u0) (uk :: u0 -> u0) -> u2; _NO_DEFLT_ } _N_ #-} where
pi :: a
{-# GHC_PRAGMA {-meth-} _A_ 1 _U_ 1 _N_ _S_ "S" _F_ _IF_ARGS_ 1 1 C 2 _/\_ u0 -> \ (u1 :: ({{Fractional u0}}, u0, u0 -> u0, u0 -> u0, u0 -> u0, u0 -> u0 -> u0, u0 -> u0 -> u0, u0 -> u0, u0 -> u0, u0 -> u0, u0 -> u0, u0 -> u0, u0 -> u0, u0 -> u0, u0 -> u0, u0 -> u0, u0 -> u0, u0 -> u0, u0 -> u0)) -> case u1 of { _ALG_ _TUP_19 (u2 :: {{Fractional u0}}) (u3 :: u0) (u4 :: u0 -> u0) (u5 :: u0 -> u0) (u6 :: u0 -> u0) (u7 :: u0 -> u0 -> u0) (u8 :: u0 -> u0 -> u0) (u9 :: u0 -> u0) (ua :: u0 -> u0) (ub :: u0 -> u0) (uc :: u0 -> u0) (ud :: u0 -> u0) (ue :: u0 -> u0) (uf :: u0 -> u0) (ug :: u0 -> u0) (uh :: u0 -> u0) (ui :: u0 -> u0) (uj :: u0 -> u0) (uk :: u0 -> u0) -> u3; _NO_DEFLT_ } _N_
- {-defm-} _A_ 1 _U_ 0 _N_ _S_ _!_ _F_ _IF_ARGS_ 1 1 X 2 _/\_ u0 -> \ (u1 :: {{Floating u0}}) -> _APP_ _TYAPP_ patError# { u0 } [ _NOREP_S_ "%DPreludeCore.Floating.pi\"" ] _N_ #-}
+ {-defm-} _A_ 1 _U_ 0 _N_ _S_ _!_ _N_ _N_ #-}
exp :: a -> a
{-# GHC_PRAGMA {-meth-} _A_ 1 _U_ 12 _N_ _S_ "S" _F_ _IF_ARGS_ 1 1 C 2 _/\_ u0 -> \ (u1 :: ({{Fractional u0}}, u0, u0 -> u0, u0 -> u0, u0 -> u0, u0 -> u0 -> u0, u0 -> u0 -> u0, u0 -> u0, u0 -> u0, u0 -> u0, u0 -> u0, u0 -> u0, u0 -> u0, u0 -> u0, u0 -> u0, u0 -> u0, u0 -> u0, u0 -> u0, u0 -> u0)) -> case u1 of { _ALG_ _TUP_19 (u2 :: {{Fractional u0}}) (u3 :: u0) (u4 :: u0 -> u0) (u5 :: u0 -> u0) (u6 :: u0 -> u0) (u7 :: u0 -> u0 -> u0) (u8 :: u0 -> u0 -> u0) (u9 :: u0 -> u0) (ua :: u0 -> u0) (ub :: u0 -> u0) (uc :: u0 -> u0) (ud :: u0 -> u0) (ue :: u0 -> u0) (uf :: u0 -> u0) (ug :: u0 -> u0) (uh :: u0 -> u0) (ui :: u0 -> u0) (uj :: u0 -> u0) (uk :: u0 -> u0) -> u4; _NO_DEFLT_ } _N_
- {-defm-} _A_ 2 _U_ 02 _N_ _S_ _!_ _F_ _IF_ARGS_ 1 2 XX 3 _/\_ u0 -> \ (u1 :: {{Floating u0}}) (u2 :: u0) -> _APP_ _TYAPP_ patError# { (u0 -> u0) } [ _NOREP_S_ "%DPreludeCore.Floating.exp\"", u2 ] _N_ #-}
+ {-defm-} _A_ 2 _U_ 02 _N_ _S_ _!_ _N_ _N_ #-}
log :: a -> a
{-# GHC_PRAGMA {-meth-} _A_ 1 _U_ 12 _N_ _S_ "S" _F_ _IF_ARGS_ 1 1 C 2 _/\_ u0 -> \ (u1 :: ({{Fractional u0}}, u0, u0 -> u0, u0 -> u0, u0 -> u0, u0 -> u0 -> u0, u0 -> u0 -> u0, u0 -> u0, u0 -> u0, u0 -> u0, u0 -> u0, u0 -> u0, u0 -> u0, u0 -> u0, u0 -> u0, u0 -> u0, u0 -> u0, u0 -> u0, u0 -> u0)) -> case u1 of { _ALG_ _TUP_19 (u2 :: {{Fractional u0}}) (u3 :: u0) (u4 :: u0 -> u0) (u5 :: u0 -> u0) (u6 :: u0 -> u0) (u7 :: u0 -> u0 -> u0) (u8 :: u0 -> u0 -> u0) (u9 :: u0 -> u0) (ua :: u0 -> u0) (ub :: u0 -> u0) (uc :: u0 -> u0) (ud :: u0 -> u0) (ue :: u0 -> u0) (uf :: u0 -> u0) (ug :: u0 -> u0) (uh :: u0 -> u0) (ui :: u0 -> u0) (uj :: u0 -> u0) (uk :: u0 -> u0) -> u5; _NO_DEFLT_ } _N_
- {-defm-} _A_ 2 _U_ 02 _N_ _S_ _!_ _F_ _IF_ARGS_ 1 2 XX 3 _/\_ u0 -> \ (u1 :: {{Floating u0}}) (u2 :: u0) -> _APP_ _TYAPP_ patError# { (u0 -> u0) } [ _NOREP_S_ "%DPreludeCore.Floating.log\"", u2 ] _N_ #-}
+ {-defm-} _A_ 2 _U_ 02 _N_ _S_ _!_ _N_ _N_ #-}
sqrt :: a -> a
{-# GHC_PRAGMA {-meth-} _A_ 1 _U_ 12 _N_ _S_ "S" _F_ _IF_ARGS_ 1 1 C 2 _/\_ u0 -> \ (u1 :: ({{Fractional u0}}, u0, u0 -> u0, u0 -> u0, u0 -> u0, u0 -> u0 -> u0, u0 -> u0 -> u0, u0 -> u0, u0 -> u0, u0 -> u0, u0 -> u0, u0 -> u0, u0 -> u0, u0 -> u0, u0 -> u0, u0 -> u0, u0 -> u0, u0 -> u0, u0 -> u0)) -> case u1 of { _ALG_ _TUP_19 (u2 :: {{Fractional u0}}) (u3 :: u0) (u4 :: u0 -> u0) (u5 :: u0 -> u0) (u6 :: u0 -> u0) (u7 :: u0 -> u0 -> u0) (u8 :: u0 -> u0 -> u0) (u9 :: u0 -> u0) (ua :: u0 -> u0) (ub :: u0 -> u0) (uc :: u0 -> u0) (ud :: u0 -> u0) (ue :: u0 -> u0) (uf :: u0 -> u0) (ug :: u0 -> u0) (uh :: u0 -> u0) (ui :: u0 -> u0) (uj :: u0 -> u0) (uk :: u0 -> u0) -> u6; _NO_DEFLT_ } _N_
{-defm-} _A_ 1 _U_ 12 _N_ _S_ "S" _N_ _N_ #-}
{-defm-} _A_ 3 _U_ 122 _N_ _S_ "SLL" _N_ _N_ #-}
sin :: a -> a
{-# GHC_PRAGMA {-meth-} _A_ 1 _U_ 12 _N_ _S_ "S" _F_ _IF_ARGS_ 1 1 C 2 _/\_ u0 -> \ (u1 :: ({{Fractional u0}}, u0, u0 -> u0, u0 -> u0, u0 -> u0, u0 -> u0 -> u0, u0 -> u0 -> u0, u0 -> u0, u0 -> u0, u0 -> u0, u0 -> u0, u0 -> u0, u0 -> u0, u0 -> u0, u0 -> u0, u0 -> u0, u0 -> u0, u0 -> u0, u0 -> u0)) -> case u1 of { _ALG_ _TUP_19 (u2 :: {{Fractional u0}}) (u3 :: u0) (u4 :: u0 -> u0) (u5 :: u0 -> u0) (u6 :: u0 -> u0) (u7 :: u0 -> u0 -> u0) (u8 :: u0 -> u0 -> u0) (u9 :: u0 -> u0) (ua :: u0 -> u0) (ub :: u0 -> u0) (uc :: u0 -> u0) (ud :: u0 -> u0) (ue :: u0 -> u0) (uf :: u0 -> u0) (ug :: u0 -> u0) (uh :: u0 -> u0) (ui :: u0 -> u0) (uj :: u0 -> u0) (uk :: u0 -> u0) -> u9; _NO_DEFLT_ } _N_
- {-defm-} _A_ 2 _U_ 02 _N_ _S_ _!_ _F_ _IF_ARGS_ 1 2 XX 3 _/\_ u0 -> \ (u1 :: {{Floating u0}}) (u2 :: u0) -> _APP_ _TYAPP_ patError# { (u0 -> u0) } [ _NOREP_S_ "%DPreludeCore.Floating.sin\"", u2 ] _N_ #-}
+ {-defm-} _A_ 2 _U_ 02 _N_ _S_ _!_ _N_ _N_ #-}
cos :: a -> a
{-# GHC_PRAGMA {-meth-} _A_ 1 _U_ 12 _N_ _S_ "S" _F_ _IF_ARGS_ 1 1 C 2 _/\_ u0 -> \ (u1 :: ({{Fractional u0}}, u0, u0 -> u0, u0 -> u0, u0 -> u0, u0 -> u0 -> u0, u0 -> u0 -> u0, u0 -> u0, u0 -> u0, u0 -> u0, u0 -> u0, u0 -> u0, u0 -> u0, u0 -> u0, u0 -> u0, u0 -> u0, u0 -> u0, u0 -> u0, u0 -> u0)) -> case u1 of { _ALG_ _TUP_19 (u2 :: {{Fractional u0}}) (u3 :: u0) (u4 :: u0 -> u0) (u5 :: u0 -> u0) (u6 :: u0 -> u0) (u7 :: u0 -> u0 -> u0) (u8 :: u0 -> u0 -> u0) (u9 :: u0 -> u0) (ua :: u0 -> u0) (ub :: u0 -> u0) (uc :: u0 -> u0) (ud :: u0 -> u0) (ue :: u0 -> u0) (uf :: u0 -> u0) (ug :: u0 -> u0) (uh :: u0 -> u0) (ui :: u0 -> u0) (uj :: u0 -> u0) (uk :: u0 -> u0) -> ua; _NO_DEFLT_ } _N_
- {-defm-} _A_ 2 _U_ 02 _N_ _S_ _!_ _F_ _IF_ARGS_ 1 2 XX 3 _/\_ u0 -> \ (u1 :: {{Floating u0}}) (u2 :: u0) -> _APP_ _TYAPP_ patError# { (u0 -> u0) } [ _NOREP_S_ "%DPreludeCore.Floating.cos\"", u2 ] _N_ #-}
+ {-defm-} _A_ 2 _U_ 02 _N_ _S_ _!_ _N_ _N_ #-}
tan :: a -> a
{-# GHC_PRAGMA {-meth-} _A_ 1 _U_ 12 _N_ _S_ "S" _F_ _IF_ARGS_ 1 1 C 2 _/\_ u0 -> \ (u1 :: ({{Fractional u0}}, u0, u0 -> u0, u0 -> u0, u0 -> u0, u0 -> u0 -> u0, u0 -> u0 -> u0, u0 -> u0, u0 -> u0, u0 -> u0, u0 -> u0, u0 -> u0, u0 -> u0, u0 -> u0, u0 -> u0, u0 -> u0, u0 -> u0, u0 -> u0, u0 -> u0)) -> case u1 of { _ALG_ _TUP_19 (u2 :: {{Fractional u0}}) (u3 :: u0) (u4 :: u0 -> u0) (u5 :: u0 -> u0) (u6 :: u0 -> u0) (u7 :: u0 -> u0 -> u0) (u8 :: u0 -> u0 -> u0) (u9 :: u0 -> u0) (ua :: u0 -> u0) (ub :: u0 -> u0) (uc :: u0 -> u0) (ud :: u0 -> u0) (ue :: u0 -> u0) (uf :: u0 -> u0) (ug :: u0 -> u0) (uh :: u0 -> u0) (ui :: u0 -> u0) (uj :: u0 -> u0) (uk :: u0 -> u0) -> ub; _NO_DEFLT_ } _N_
{-defm-} _A_ 2 _U_ 12 _N_ _S_ "SL" _N_ _N_ #-}
asin :: a -> a
{-# GHC_PRAGMA {-meth-} _A_ 1 _U_ 12 _N_ _S_ "S" _F_ _IF_ARGS_ 1 1 C 2 _/\_ u0 -> \ (u1 :: ({{Fractional u0}}, u0, u0 -> u0, u0 -> u0, u0 -> u0, u0 -> u0 -> u0, u0 -> u0 -> u0, u0 -> u0, u0 -> u0, u0 -> u0, u0 -> u0, u0 -> u0, u0 -> u0, u0 -> u0, u0 -> u0, u0 -> u0, u0 -> u0, u0 -> u0, u0 -> u0)) -> case u1 of { _ALG_ _TUP_19 (u2 :: {{Fractional u0}}) (u3 :: u0) (u4 :: u0 -> u0) (u5 :: u0 -> u0) (u6 :: u0 -> u0) (u7 :: u0 -> u0 -> u0) (u8 :: u0 -> u0 -> u0) (u9 :: u0 -> u0) (ua :: u0 -> u0) (ub :: u0 -> u0) (uc :: u0 -> u0) (ud :: u0 -> u0) (ue :: u0 -> u0) (uf :: u0 -> u0) (ug :: u0 -> u0) (uh :: u0 -> u0) (ui :: u0 -> u0) (uj :: u0 -> u0) (uk :: u0 -> u0) -> uc; _NO_DEFLT_ } _N_
- {-defm-} _A_ 2 _U_ 02 _N_ _S_ _!_ _F_ _IF_ARGS_ 1 2 XX 3 _/\_ u0 -> \ (u1 :: {{Floating u0}}) (u2 :: u0) -> _APP_ _TYAPP_ patError# { (u0 -> u0) } [ _NOREP_S_ "%DPreludeCore.Floating.asin\"", u2 ] _N_ #-}
+ {-defm-} _A_ 2 _U_ 02 _N_ _S_ _!_ _N_ _N_ #-}
acos :: a -> a
{-# GHC_PRAGMA {-meth-} _A_ 1 _U_ 12 _N_ _S_ "S" _F_ _IF_ARGS_ 1 1 C 2 _/\_ u0 -> \ (u1 :: ({{Fractional u0}}, u0, u0 -> u0, u0 -> u0, u0 -> u0, u0 -> u0 -> u0, u0 -> u0 -> u0, u0 -> u0, u0 -> u0, u0 -> u0, u0 -> u0, u0 -> u0, u0 -> u0, u0 -> u0, u0 -> u0, u0 -> u0, u0 -> u0, u0 -> u0, u0 -> u0)) -> case u1 of { _ALG_ _TUP_19 (u2 :: {{Fractional u0}}) (u3 :: u0) (u4 :: u0 -> u0) (u5 :: u0 -> u0) (u6 :: u0 -> u0) (u7 :: u0 -> u0 -> u0) (u8 :: u0 -> u0 -> u0) (u9 :: u0 -> u0) (ua :: u0 -> u0) (ub :: u0 -> u0) (uc :: u0 -> u0) (ud :: u0 -> u0) (ue :: u0 -> u0) (uf :: u0 -> u0) (ug :: u0 -> u0) (uh :: u0 -> u0) (ui :: u0 -> u0) (uj :: u0 -> u0) (uk :: u0 -> u0) -> ud; _NO_DEFLT_ } _N_
- {-defm-} _A_ 2 _U_ 02 _N_ _S_ _!_ _F_ _IF_ARGS_ 1 2 XX 3 _/\_ u0 -> \ (u1 :: {{Floating u0}}) (u2 :: u0) -> _APP_ _TYAPP_ patError# { (u0 -> u0) } [ _NOREP_S_ "%DPreludeCore.Floating.acos\"", u2 ] _N_ #-}
+ {-defm-} _A_ 2 _U_ 02 _N_ _S_ _!_ _N_ _N_ #-}
atan :: a -> a
{-# GHC_PRAGMA {-meth-} _A_ 1 _U_ 12 _N_ _S_ "S" _F_ _IF_ARGS_ 1 1 C 2 _/\_ u0 -> \ (u1 :: ({{Fractional u0}}, u0, u0 -> u0, u0 -> u0, u0 -> u0, u0 -> u0 -> u0, u0 -> u0 -> u0, u0 -> u0, u0 -> u0, u0 -> u0, u0 -> u0, u0 -> u0, u0 -> u0, u0 -> u0, u0 -> u0, u0 -> u0, u0 -> u0, u0 -> u0, u0 -> u0)) -> case u1 of { _ALG_ _TUP_19 (u2 :: {{Fractional u0}}) (u3 :: u0) (u4 :: u0 -> u0) (u5 :: u0 -> u0) (u6 :: u0 -> u0) (u7 :: u0 -> u0 -> u0) (u8 :: u0 -> u0 -> u0) (u9 :: u0 -> u0) (ua :: u0 -> u0) (ub :: u0 -> u0) (uc :: u0 -> u0) (ud :: u0 -> u0) (ue :: u0 -> u0) (uf :: u0 -> u0) (ug :: u0 -> u0) (uh :: u0 -> u0) (ui :: u0 -> u0) (uj :: u0 -> u0) (uk :: u0 -> u0) -> ue; _NO_DEFLT_ } _N_
- {-defm-} _A_ 2 _U_ 02 _N_ _S_ _!_ _F_ _IF_ARGS_ 1 2 XX 3 _/\_ u0 -> \ (u1 :: {{Floating u0}}) (u2 :: u0) -> _APP_ _TYAPP_ patError# { (u0 -> u0) } [ _NOREP_S_ "%DPreludeCore.Floating.atan\"", u2 ] _N_ #-}
+ {-defm-} _A_ 2 _U_ 02 _N_ _S_ _!_ _N_ _N_ #-}
sinh :: a -> a
{-# GHC_PRAGMA {-meth-} _A_ 1 _U_ 12 _N_ _S_ "S" _F_ _IF_ARGS_ 1 1 C 2 _/\_ u0 -> \ (u1 :: ({{Fractional u0}}, u0, u0 -> u0, u0 -> u0, u0 -> u0, u0 -> u0 -> u0, u0 -> u0 -> u0, u0 -> u0, u0 -> u0, u0 -> u0, u0 -> u0, u0 -> u0, u0 -> u0, u0 -> u0, u0 -> u0, u0 -> u0, u0 -> u0, u0 -> u0, u0 -> u0)) -> case u1 of { _ALG_ _TUP_19 (u2 :: {{Fractional u0}}) (u3 :: u0) (u4 :: u0 -> u0) (u5 :: u0 -> u0) (u6 :: u0 -> u0) (u7 :: u0 -> u0 -> u0) (u8 :: u0 -> u0 -> u0) (u9 :: u0 -> u0) (ua :: u0 -> u0) (ub :: u0 -> u0) (uc :: u0 -> u0) (ud :: u0 -> u0) (ue :: u0 -> u0) (uf :: u0 -> u0) (ug :: u0 -> u0) (uh :: u0 -> u0) (ui :: u0 -> u0) (uj :: u0 -> u0) (uk :: u0 -> u0) -> uf; _NO_DEFLT_ } _N_
- {-defm-} _A_ 2 _U_ 02 _N_ _S_ _!_ _F_ _IF_ARGS_ 1 2 XX 3 _/\_ u0 -> \ (u1 :: {{Floating u0}}) (u2 :: u0) -> _APP_ _TYAPP_ patError# { (u0 -> u0) } [ _NOREP_S_ "%DPreludeCore.Floating.sinh\"", u2 ] _N_ #-}
+ {-defm-} _A_ 2 _U_ 02 _N_ _S_ _!_ _N_ _N_ #-}
cosh :: a -> a
{-# GHC_PRAGMA {-meth-} _A_ 1 _U_ 12 _N_ _S_ "S" _F_ _IF_ARGS_ 1 1 C 2 _/\_ u0 -> \ (u1 :: ({{Fractional u0}}, u0, u0 -> u0, u0 -> u0, u0 -> u0, u0 -> u0 -> u0, u0 -> u0 -> u0, u0 -> u0, u0 -> u0, u0 -> u0, u0 -> u0, u0 -> u0, u0 -> u0, u0 -> u0, u0 -> u0, u0 -> u0, u0 -> u0, u0 -> u0, u0 -> u0)) -> case u1 of { _ALG_ _TUP_19 (u2 :: {{Fractional u0}}) (u3 :: u0) (u4 :: u0 -> u0) (u5 :: u0 -> u0) (u6 :: u0 -> u0) (u7 :: u0 -> u0 -> u0) (u8 :: u0 -> u0 -> u0) (u9 :: u0 -> u0) (ua :: u0 -> u0) (ub :: u0 -> u0) (uc :: u0 -> u0) (ud :: u0 -> u0) (ue :: u0 -> u0) (uf :: u0 -> u0) (ug :: u0 -> u0) (uh :: u0 -> u0) (ui :: u0 -> u0) (uj :: u0 -> u0) (uk :: u0 -> u0) -> ug; _NO_DEFLT_ } _N_
- {-defm-} _A_ 2 _U_ 02 _N_ _S_ _!_ _F_ _IF_ARGS_ 1 2 XX 3 _/\_ u0 -> \ (u1 :: {{Floating u0}}) (u2 :: u0) -> _APP_ _TYAPP_ patError# { (u0 -> u0) } [ _NOREP_S_ "%DPreludeCore.Floating.cosh\"", u2 ] _N_ #-}
+ {-defm-} _A_ 2 _U_ 02 _N_ _S_ _!_ _N_ _N_ #-}
tanh :: a -> a
{-# GHC_PRAGMA {-meth-} _A_ 1 _U_ 12 _N_ _S_ "S" _F_ _IF_ARGS_ 1 1 C 2 _/\_ u0 -> \ (u1 :: ({{Fractional u0}}, u0, u0 -> u0, u0 -> u0, u0 -> u0, u0 -> u0 -> u0, u0 -> u0 -> u0, u0 -> u0, u0 -> u0, u0 -> u0, u0 -> u0, u0 -> u0, u0 -> u0, u0 -> u0, u0 -> u0, u0 -> u0, u0 -> u0, u0 -> u0, u0 -> u0)) -> case u1 of { _ALG_ _TUP_19 (u2 :: {{Fractional u0}}) (u3 :: u0) (u4 :: u0 -> u0) (u5 :: u0 -> u0) (u6 :: u0 -> u0) (u7 :: u0 -> u0 -> u0) (u8 :: u0 -> u0 -> u0) (u9 :: u0 -> u0) (ua :: u0 -> u0) (ub :: u0 -> u0) (uc :: u0 -> u0) (ud :: u0 -> u0) (ue :: u0 -> u0) (uf :: u0 -> u0) (ug :: u0 -> u0) (uh :: u0 -> u0) (ui :: u0 -> u0) (uj :: u0 -> u0) (uk :: u0 -> u0) -> uh; _NO_DEFLT_ } _N_
{-defm-} _A_ 2 _U_ 12 _N_ _S_ "SL" _N_ _N_ #-}
asinh :: a -> a
{-# GHC_PRAGMA {-meth-} _A_ 1 _U_ 12 _N_ _S_ "S" _F_ _IF_ARGS_ 1 1 C 2 _/\_ u0 -> \ (u1 :: ({{Fractional u0}}, u0, u0 -> u0, u0 -> u0, u0 -> u0, u0 -> u0 -> u0, u0 -> u0 -> u0, u0 -> u0, u0 -> u0, u0 -> u0, u0 -> u0, u0 -> u0, u0 -> u0, u0 -> u0, u0 -> u0, u0 -> u0, u0 -> u0, u0 -> u0, u0 -> u0)) -> case u1 of { _ALG_ _TUP_19 (u2 :: {{Fractional u0}}) (u3 :: u0) (u4 :: u0 -> u0) (u5 :: u0 -> u0) (u6 :: u0 -> u0) (u7 :: u0 -> u0 -> u0) (u8 :: u0 -> u0 -> u0) (u9 :: u0 -> u0) (ua :: u0 -> u0) (ub :: u0 -> u0) (uc :: u0 -> u0) (ud :: u0 -> u0) (ue :: u0 -> u0) (uf :: u0 -> u0) (ug :: u0 -> u0) (uh :: u0 -> u0) (ui :: u0 -> u0) (uj :: u0 -> u0) (uk :: u0 -> u0) -> ui; _NO_DEFLT_ } _N_
- {-defm-} _A_ 2 _U_ 02 _N_ _S_ _!_ _F_ _IF_ARGS_ 1 2 XX 3 _/\_ u0 -> \ (u1 :: {{Floating u0}}) (u2 :: u0) -> _APP_ _TYAPP_ patError# { (u0 -> u0) } [ _NOREP_S_ "%DPreludeCore.Floating.asinh\"", u2 ] _N_ #-}
+ {-defm-} _A_ 2 _U_ 02 _N_ _S_ _!_ _N_ _N_ #-}
acosh :: a -> a
{-# GHC_PRAGMA {-meth-} _A_ 1 _U_ 12 _N_ _S_ "S" _F_ _IF_ARGS_ 1 1 C 2 _/\_ u0 -> \ (u1 :: ({{Fractional u0}}, u0, u0 -> u0, u0 -> u0, u0 -> u0, u0 -> u0 -> u0, u0 -> u0 -> u0, u0 -> u0, u0 -> u0, u0 -> u0, u0 -> u0, u0 -> u0, u0 -> u0, u0 -> u0, u0 -> u0, u0 -> u0, u0 -> u0, u0 -> u0, u0 -> u0)) -> case u1 of { _ALG_ _TUP_19 (u2 :: {{Fractional u0}}) (u3 :: u0) (u4 :: u0 -> u0) (u5 :: u0 -> u0) (u6 :: u0 -> u0) (u7 :: u0 -> u0 -> u0) (u8 :: u0 -> u0 -> u0) (u9 :: u0 -> u0) (ua :: u0 -> u0) (ub :: u0 -> u0) (uc :: u0 -> u0) (ud :: u0 -> u0) (ue :: u0 -> u0) (uf :: u0 -> u0) (ug :: u0 -> u0) (uh :: u0 -> u0) (ui :: u0 -> u0) (uj :: u0 -> u0) (uk :: u0 -> u0) -> uj; _NO_DEFLT_ } _N_
- {-defm-} _A_ 2 _U_ 02 _N_ _S_ _!_ _F_ _IF_ARGS_ 1 2 XX 3 _/\_ u0 -> \ (u1 :: {{Floating u0}}) (u2 :: u0) -> _APP_ _TYAPP_ patError# { (u0 -> u0) } [ _NOREP_S_ "%DPreludeCore.Floating.acosh\"", u2 ] _N_ #-}
+ {-defm-} _A_ 2 _U_ 02 _N_ _S_ _!_ _N_ _N_ #-}
atanh :: a -> a
{-# GHC_PRAGMA {-meth-} _A_ 1 _U_ 12 _N_ _S_ "S" _F_ _IF_ARGS_ 1 1 C 2 _/\_ u0 -> \ (u1 :: ({{Fractional u0}}, u0, u0 -> u0, u0 -> u0, u0 -> u0, u0 -> u0 -> u0, u0 -> u0 -> u0, u0 -> u0, u0 -> u0, u0 -> u0, u0 -> u0, u0 -> u0, u0 -> u0, u0 -> u0, u0 -> u0, u0 -> u0, u0 -> u0, u0 -> u0, u0 -> u0)) -> case u1 of { _ALG_ _TUP_19 (u2 :: {{Fractional u0}}) (u3 :: u0) (u4 :: u0 -> u0) (u5 :: u0 -> u0) (u6 :: u0 -> u0) (u7 :: u0 -> u0 -> u0) (u8 :: u0 -> u0 -> u0) (u9 :: u0 -> u0) (ua :: u0 -> u0) (ub :: u0 -> u0) (uc :: u0 -> u0) (ud :: u0 -> u0) (ue :: u0 -> u0) (uf :: u0 -> u0) (ug :: u0 -> u0) (uh :: u0 -> u0) (ui :: u0 -> u0) (uj :: u0 -> u0) (uk :: u0 -> u0) -> uk; _NO_DEFLT_ } _N_
- {-defm-} _A_ 2 _U_ 02 _N_ _S_ _!_ _F_ _IF_ARGS_ 1 2 XX 3 _/\_ u0 -> \ (u1 :: {{Floating u0}}) (u2 :: u0) -> _APP_ _TYAPP_ patError# { (u0 -> u0) } [ _NOREP_S_ "%DPreludeCore.Floating.atanh\"", u2 ] _N_ #-}
+ {-defm-} _A_ 2 _U_ 02 _N_ _S_ _!_ _N_ _N_ #-}
class (Num a) => Fractional a {-# GHC_PRAGMA {-superdicts-} _A_ 1 _U_ 1 _N_ _S_ "S" _F_ _IF_ARGS_ 1 1 C 2 _/\_ u0 -> \ (u1 :: ({{Num u0}}, u0 -> u0 -> u0, u0 -> u0, Ratio Integer -> u0)) -> case u1 of { _ALG_ _TUP_4 (u2 :: {{Num u0}}) (u3 :: u0 -> u0 -> u0) (u4 :: u0 -> u0) (u5 :: Ratio Integer -> u0) -> u2; _NO_DEFLT_ } _N_ #-} where
(/) :: a -> a -> a
{-# GHC_PRAGMA {-meth-} _A_ 1 _U_ 122 _N_ _S_ "S" _F_ _IF_ARGS_ 1 1 C 2 _/\_ u0 -> \ (u1 :: ({{Num u0}}, u0 -> u0 -> u0, u0 -> u0, Ratio Integer -> u0)) -> case u1 of { _ALG_ _TUP_4 (u2 :: {{Num u0}}) (u3 :: u0 -> u0 -> u0) (u4 :: u0 -> u0) (u5 :: Ratio Integer -> u0) -> u3; _NO_DEFLT_ } _N_
- {-defm-} _A_ 3 _U_ 022 _N_ _S_ _!_ _F_ _IF_ARGS_ 1 3 XXX 4 _/\_ u0 -> \ (u1 :: {{Fractional u0}}) (u2 :: u0) (u3 :: u0) -> _APP_ _TYAPP_ patError# { (u0 -> u0 -> u0) } [ _NOREP_S_ "%DPreludeCore.Fractional.(/)\"", u2, u3 ] _N_ #-}
+ {-defm-} _A_ 3 _U_ 022 _N_ _S_ _!_ _N_ _N_ #-}
recip :: a -> a
{-# GHC_PRAGMA {-meth-} _A_ 1 _U_ 12 _N_ _S_ "S" _F_ _IF_ARGS_ 1 1 C 2 _/\_ u0 -> \ (u1 :: ({{Num u0}}, u0 -> u0 -> u0, u0 -> u0, Ratio Integer -> u0)) -> case u1 of { _ALG_ _TUP_4 (u2 :: {{Num u0}}) (u3 :: u0 -> u0 -> u0) (u4 :: u0 -> u0) (u5 :: Ratio Integer -> u0) -> u4; _NO_DEFLT_ } _N_
{-defm-} _A_ 1 _U_ 12 _N_ _S_ "S" _N_ _N_ #-}
fromRational :: Ratio Integer -> a
{-# GHC_PRAGMA {-meth-} _A_ 1 _U_ 12 _N_ _S_ "S" _F_ _IF_ARGS_ 1 1 C 2 _/\_ u0 -> \ (u1 :: ({{Num u0}}, u0 -> u0 -> u0, u0 -> u0, Ratio Integer -> u0)) -> case u1 of { _ALG_ _TUP_4 (u2 :: {{Num u0}}) (u3 :: u0 -> u0 -> u0) (u4 :: u0 -> u0) (u5 :: Ratio Integer -> u0) -> u5; _NO_DEFLT_ } _N_
- {-defm-} _A_ 2 _U_ 02 _N_ _S_ _!_ _F_ _IF_ARGS_ 1 2 XX 3 _/\_ u0 -> \ (u1 :: {{Fractional u0}}) (u2 :: Ratio Integer) -> _APP_ _TYAPP_ patError# { (Ratio Integer -> u0) } [ _NOREP_S_ "%DPreludeCore.Fractional.fromRational\"", u2 ] _N_ #-}
+ {-defm-} _A_ 2 _U_ 02 _N_ _S_ _!_ _N_ _N_ #-}
class (Real a, Ix a) => Integral a {-# GHC_PRAGMA {-superdicts-} _A_ 1 _U_ 1 _N_ _S_ "S" _F_ _IF_ARGS_ 1 1 C 2 _/\_ u0 -> \ (u1 :: ({{Real u0}}, {{Ix u0}}, u0 -> u0 -> u0, u0 -> u0 -> u0, u0 -> u0 -> u0, u0 -> u0 -> u0, u0 -> u0 -> (u0, u0), u0 -> u0 -> (u0, u0), u0 -> Bool, u0 -> Bool, u0 -> Integer, u0 -> Int)) -> case u1 of { _ALG_ _TUP_12 (u2 :: {{Real u0}}) (u3 :: {{Ix u0}}) (u4 :: u0 -> u0 -> u0) (u5 :: u0 -> u0 -> u0) (u6 :: u0 -> u0 -> u0) (u7 :: u0 -> u0 -> u0) (u8 :: u0 -> u0 -> (u0, u0)) (u9 :: u0 -> u0 -> (u0, u0)) (ua :: u0 -> Bool) (ub :: u0 -> Bool) (uc :: u0 -> Integer) (ud :: u0 -> Int) -> u2; _NO_DEFLT_ } _N_, _A_ 1 _U_ 1 _N_ _S_ "S" _F_ _IF_ARGS_ 1 1 C 2 _/\_ u0 -> \ (u1 :: ({{Real u0}}, {{Ix u0}}, u0 -> u0 -> u0, u0 -> u0 -> u0, u0 -> u0 -> u0, u0 -> u0 -> u0, u0 -> u0 -> (u0, u0), u0 -> u0 -> (u0, u0), u0 -> Bool, u0 -> Bool, u0 -> Integer, u0 -> Int)) -> case u1 of { _ALG_ _TUP_12 (u2 :: {{Real u0}}) (u3 :: {{Ix u0}}) (u4 :: u0 -> u0 -> u0) (u5 :: u0 -> u0 -> u0) (u6 :: u0 -> u0 -> u0) (u7 :: u0 -> u0 -> u0) (u8 :: u0 -> u0 -> (u0, u0)) (u9 :: u0 -> u0 -> (u0, u0)) (ua :: u0 -> Bool) (ub :: u0 -> Bool) (uc :: u0 -> Integer) (ud :: u0 -> Int) -> u3; _NO_DEFLT_ } _N_ #-} where
quot :: a -> a -> a
{-# GHC_PRAGMA {-meth-} _A_ 1 _U_ 122 _N_ _S_ "S" _F_ _IF_ARGS_ 1 1 C 2 _/\_ u0 -> \ (u1 :: ({{Real u0}}, {{Ix u0}}, u0 -> u0 -> u0, u0 -> u0 -> u0, u0 -> u0 -> u0, u0 -> u0 -> u0, u0 -> u0 -> (u0, u0), u0 -> u0 -> (u0, u0), u0 -> Bool, u0 -> Bool, u0 -> Integer, u0 -> Int)) -> case u1 of { _ALG_ _TUP_12 (u2 :: {{Real u0}}) (u3 :: {{Ix u0}}) (u4 :: u0 -> u0 -> u0) (u5 :: u0 -> u0 -> u0) (u6 :: u0 -> u0 -> u0) (u7 :: u0 -> u0 -> u0) (u8 :: u0 -> u0 -> (u0, u0)) (u9 :: u0 -> u0 -> (u0, u0)) (ua :: u0 -> Bool) (ub :: u0 -> Bool) (uc :: u0 -> Integer) (ud :: u0 -> Int) -> u4; _NO_DEFLT_ } _N_
{-defm-} _A_ 3 _U_ 122 _N_ _S_ "SLL" _F_ _IF_ARGS_ 1 3 CXX 6 _/\_ u0 -> \ (u1 :: {{Integral u0}}) (u2 :: u0) (u3 :: u0) -> case case u1 of { _ALG_ _TUP_12 (u4 :: {{Real u0}}) (u5 :: {{Ix u0}}) (u6 :: u0 -> u0 -> u0) (u7 :: u0 -> u0 -> u0) (u8 :: u0 -> u0 -> u0) (u9 :: u0 -> u0 -> u0) (ua :: u0 -> u0 -> (u0, u0)) (ub :: u0 -> u0 -> (u0, u0)) (uc :: u0 -> Bool) (ud :: u0 -> Bool) (ue :: u0 -> Integer) (uf :: u0 -> Int) -> _APP_ ub [ u2, u3 ]; _NO_DEFLT_ } of { _ALG_ _TUP_2 (ug :: u0) (uh :: u0) -> uh; _NO_DEFLT_ } _N_ #-}
quotRem :: a -> a -> (a, a)
{-# GHC_PRAGMA {-meth-} _A_ 1 _U_ 122 _N_ _S_ "S" _F_ _IF_ARGS_ 1 1 C 2 _/\_ u0 -> \ (u1 :: ({{Real u0}}, {{Ix u0}}, u0 -> u0 -> u0, u0 -> u0 -> u0, u0 -> u0 -> u0, u0 -> u0 -> u0, u0 -> u0 -> (u0, u0), u0 -> u0 -> (u0, u0), u0 -> Bool, u0 -> Bool, u0 -> Integer, u0 -> Int)) -> case u1 of { _ALG_ _TUP_12 (u2 :: {{Real u0}}) (u3 :: {{Ix u0}}) (u4 :: u0 -> u0 -> u0) (u5 :: u0 -> u0 -> u0) (u6 :: u0 -> u0 -> u0) (u7 :: u0 -> u0 -> u0) (u8 :: u0 -> u0 -> (u0, u0)) (u9 :: u0 -> u0 -> (u0, u0)) (ua :: u0 -> Bool) (ub :: u0 -> Bool) (uc :: u0 -> Integer) (ud :: u0 -> Int) -> u8; _NO_DEFLT_ } _N_
- {-defm-} _A_ 3 _U_ 022 _N_ _S_ _!_ _F_ _IF_ARGS_ 1 3 XXX 4 _/\_ u0 -> \ (u1 :: {{Integral u0}}) (u2 :: u0) (u3 :: u0) -> _APP_ _TYAPP_ patError# { (u0 -> u0 -> (u0, u0)) } [ _NOREP_S_ "%DPreludeCore.Integral.quotRem\"", u2, u3 ] _N_ #-}
+ {-defm-} _A_ 3 _U_ 022 _N_ _S_ _!_ _N_ _N_ #-}
divMod :: a -> a -> (a, a)
{-# GHC_PRAGMA {-meth-} _A_ 1 _U_ 122 _N_ _S_ "S" _F_ _IF_ARGS_ 1 1 C 2 _/\_ u0 -> \ (u1 :: ({{Real u0}}, {{Ix u0}}, u0 -> u0 -> u0, u0 -> u0 -> u0, u0 -> u0 -> u0, u0 -> u0 -> u0, u0 -> u0 -> (u0, u0), u0 -> u0 -> (u0, u0), u0 -> Bool, u0 -> Bool, u0 -> Integer, u0 -> Int)) -> case u1 of { _ALG_ _TUP_12 (u2 :: {{Real u0}}) (u3 :: {{Ix u0}}) (u4 :: u0 -> u0 -> u0) (u5 :: u0 -> u0 -> u0) (u6 :: u0 -> u0 -> u0) (u7 :: u0 -> u0 -> u0) (u8 :: u0 -> u0 -> (u0, u0)) (u9 :: u0 -> u0 -> (u0, u0)) (ua :: u0 -> Bool) (ub :: u0 -> Bool) (uc :: u0 -> Integer) (ud :: u0 -> Int) -> u9; _NO_DEFLT_ } _N_
{-defm-} _A_ 1 _U_ 122 _N_ _S_ "S" _N_ _N_ #-}
{-defm-} _A_ 1 _U_ 12 _N_ _S_ "S" _N_ _N_ #-}
toInteger :: a -> Integer
{-# GHC_PRAGMA {-meth-} _A_ 1 _U_ 12 _N_ _S_ "S" _F_ _IF_ARGS_ 1 1 C 2 _/\_ u0 -> \ (u1 :: ({{Real u0}}, {{Ix u0}}, u0 -> u0 -> u0, u0 -> u0 -> u0, u0 -> u0 -> u0, u0 -> u0 -> u0, u0 -> u0 -> (u0, u0), u0 -> u0 -> (u0, u0), u0 -> Bool, u0 -> Bool, u0 -> Integer, u0 -> Int)) -> case u1 of { _ALG_ _TUP_12 (u2 :: {{Real u0}}) (u3 :: {{Ix u0}}) (u4 :: u0 -> u0 -> u0) (u5 :: u0 -> u0 -> u0) (u6 :: u0 -> u0 -> u0) (u7 :: u0 -> u0 -> u0) (u8 :: u0 -> u0 -> (u0, u0)) (u9 :: u0 -> u0 -> (u0, u0)) (ua :: u0 -> Bool) (ub :: u0 -> Bool) (uc :: u0 -> Integer) (ud :: u0 -> Int) -> uc; _NO_DEFLT_ } _N_
- {-defm-} _A_ 2 _U_ 02 _N_ _S_ _!_ _F_ _IF_ARGS_ 1 2 XX 3 _/\_ u0 -> \ (u1 :: {{Integral u0}}) (u2 :: u0) -> _APP_ _TYAPP_ patError# { (u0 -> Integer) } [ _NOREP_S_ "%DPreludeCore.Integral.toInteger\"", u2 ] _N_ #-}
+ {-defm-} _A_ 2 _U_ 02 _N_ _S_ _!_ _N_ _N_ #-}
toInt :: a -> Int
{-# GHC_PRAGMA {-meth-} _A_ 1 _U_ 12 _N_ _S_ "S" _F_ _IF_ARGS_ 1 1 C 2 _/\_ u0 -> \ (u1 :: ({{Real u0}}, {{Ix u0}}, u0 -> u0 -> u0, u0 -> u0 -> u0, u0 -> u0 -> u0, u0 -> u0 -> u0, u0 -> u0 -> (u0, u0), u0 -> u0 -> (u0, u0), u0 -> Bool, u0 -> Bool, u0 -> Integer, u0 -> Int)) -> case u1 of { _ALG_ _TUP_12 (u2 :: {{Real u0}}) (u3 :: {{Ix u0}}) (u4 :: u0 -> u0 -> u0) (u5 :: u0 -> u0 -> u0) (u6 :: u0 -> u0 -> u0) (u7 :: u0 -> u0 -> u0) (u8 :: u0 -> u0 -> (u0, u0)) (u9 :: u0 -> u0 -> (u0, u0)) (ua :: u0 -> Bool) (ub :: u0 -> Bool) (uc :: u0 -> Integer) (ud :: u0 -> Int) -> ud; _NO_DEFLT_ } _N_
- {-defm-} _A_ 2 _U_ 02 _N_ _S_ _!_ _F_ _IF_ARGS_ 1 2 XX 3 _/\_ u0 -> \ (u1 :: {{Integral u0}}) (u2 :: u0) -> _APP_ _TYAPP_ patError# { (u0 -> Int) } [ _NOREP_S_ "%DPreludeCore.Integral.toInt\"", u2 ] _N_ #-}
+ {-defm-} _A_ 2 _U_ 02 _N_ _S_ _!_ _N_ _N_ #-}
class (Ord a) => Ix a {-# GHC_PRAGMA {-superdicts-} _A_ 1 _U_ 1 _N_ _S_ "S" _F_ _IF_ARGS_ 1 1 C 2 _/\_ u0 -> \ (u1 :: ({{Ord u0}}, (u0, u0) -> [u0], (u0, u0) -> u0 -> Int, (u0, u0) -> u0 -> Bool)) -> case u1 of { _ALG_ _TUP_4 (u2 :: {{Ord u0}}) (u3 :: (u0, u0) -> [u0]) (u4 :: (u0, u0) -> u0 -> Int) (u5 :: (u0, u0) -> u0 -> Bool) -> u2; _NO_DEFLT_ } _N_ #-} where
range :: (a, a) -> [a]
{-# GHC_PRAGMA {-meth-} _A_ 1 _U_ 12 _N_ _S_ "S" _F_ _IF_ARGS_ 1 1 C 2 _/\_ u0 -> \ (u1 :: ({{Ord u0}}, (u0, u0) -> [u0], (u0, u0) -> u0 -> Int, (u0, u0) -> u0 -> Bool)) -> case u1 of { _ALG_ _TUP_4 (u2 :: {{Ord u0}}) (u3 :: (u0, u0) -> [u0]) (u4 :: (u0, u0) -> u0 -> Int) (u5 :: (u0, u0) -> u0 -> Bool) -> u3; _NO_DEFLT_ } _N_
- {-defm-} _A_ 2 _U_ 02 _N_ _S_ _!_ _F_ _IF_ARGS_ 1 2 XX 3 _/\_ u0 -> \ (u1 :: {{Ix u0}}) (u2 :: (u0, u0)) -> _APP_ _TYAPP_ patError# { ((u0, u0) -> [u0]) } [ _NOREP_S_ "%DPreludeCore.Ix.range\"", u2 ] _N_ #-}
+ {-defm-} _A_ 2 _U_ 02 _N_ _S_ _!_ _N_ _N_ #-}
index :: (a, a) -> a -> Int
{-# GHC_PRAGMA {-meth-} _A_ 1 _U_ 122 _N_ _S_ "S" _F_ _IF_ARGS_ 1 1 C 2 _/\_ u0 -> \ (u1 :: ({{Ord u0}}, (u0, u0) -> [u0], (u0, u0) -> u0 -> Int, (u0, u0) -> u0 -> Bool)) -> case u1 of { _ALG_ _TUP_4 (u2 :: {{Ord u0}}) (u3 :: (u0, u0) -> [u0]) (u4 :: (u0, u0) -> u0 -> Int) (u5 :: (u0, u0) -> u0 -> Bool) -> u4; _NO_DEFLT_ } _N_
- {-defm-} _A_ 3 _U_ 022 _N_ _S_ _!_ _F_ _IF_ARGS_ 1 3 XXX 4 _/\_ u0 -> \ (u1 :: {{Ix u0}}) (u2 :: (u0, u0)) (u3 :: u0) -> _APP_ _TYAPP_ patError# { ((u0, u0) -> u0 -> Int) } [ _NOREP_S_ "%DPreludeCore.Ix.index\"", u2, u3 ] _N_ #-}
+ {-defm-} _A_ 3 _U_ 022 _N_ _S_ _!_ _N_ _N_ #-}
inRange :: (a, a) -> a -> Bool
{-# GHC_PRAGMA {-meth-} _A_ 1 _U_ 122 _N_ _S_ "S" _F_ _IF_ARGS_ 1 1 C 2 _/\_ u0 -> \ (u1 :: ({{Ord u0}}, (u0, u0) -> [u0], (u0, u0) -> u0 -> Int, (u0, u0) -> u0 -> Bool)) -> case u1 of { _ALG_ _TUP_4 (u2 :: {{Ord u0}}) (u3 :: (u0, u0) -> [u0]) (u4 :: (u0, u0) -> u0 -> Int) (u5 :: (u0, u0) -> u0 -> Bool) -> u5; _NO_DEFLT_ } _N_
- {-defm-} _A_ 3 _U_ 022 _N_ _S_ _!_ _F_ _IF_ARGS_ 1 3 XXX 4 _/\_ u0 -> \ (u1 :: {{Ix u0}}) (u2 :: (u0, u0)) (u3 :: u0) -> _APP_ _TYAPP_ patError# { ((u0, u0) -> u0 -> Bool) } [ _NOREP_S_ "%DPreludeCore.Ix.inRange\"", u2, u3 ] _N_ #-}
+ {-defm-} _A_ 3 _U_ 022 _N_ _S_ _!_ _N_ _N_ #-}
class (Eq a, Text a) => Num a {-# GHC_PRAGMA {-superdicts-} _A_ 1 _U_ 1 _N_ _S_ "S" _F_ _IF_ARGS_ 1 1 C 2 _/\_ u0 -> \ (u1 :: ({{Eq u0}}, {{Text u0}}, u0 -> u0 -> u0, u0 -> u0 -> u0, u0 -> u0 -> u0, u0 -> u0, u0 -> u0, u0 -> u0, Integer -> u0, Int -> u0)) -> case u1 of { _ALG_ _TUP_10 (u2 :: {{Eq u0}}) (u3 :: {{Text u0}}) (u4 :: u0 -> u0 -> u0) (u5 :: u0 -> u0 -> u0) (u6 :: u0 -> u0 -> u0) (u7 :: u0 -> u0) (u8 :: u0 -> u0) (u9 :: u0 -> u0) (ua :: Integer -> u0) (ub :: Int -> u0) -> u2; _NO_DEFLT_ } _N_, _A_ 1 _U_ 1 _N_ _S_ "S" _F_ _IF_ARGS_ 1 1 C 2 _/\_ u0 -> \ (u1 :: ({{Eq u0}}, {{Text u0}}, u0 -> u0 -> u0, u0 -> u0 -> u0, u0 -> u0 -> u0, u0 -> u0, u0 -> u0, u0 -> u0, Integer -> u0, Int -> u0)) -> case u1 of { _ALG_ _TUP_10 (u2 :: {{Eq u0}}) (u3 :: {{Text u0}}) (u4 :: u0 -> u0 -> u0) (u5 :: u0 -> u0 -> u0) (u6 :: u0 -> u0 -> u0) (u7 :: u0 -> u0) (u8 :: u0 -> u0) (u9 :: u0 -> u0) (ua :: Integer -> u0) (ub :: Int -> u0) -> u3; _NO_DEFLT_ } _N_ #-} where
(+) :: a -> a -> a
{-# GHC_PRAGMA {-meth-} _A_ 1 _U_ 122 _N_ _S_ "S" _F_ _IF_ARGS_ 1 1 C 2 _/\_ u0 -> \ (u1 :: ({{Eq u0}}, {{Text u0}}, u0 -> u0 -> u0, u0 -> u0 -> u0, u0 -> u0 -> u0, u0 -> u0, u0 -> u0, u0 -> u0, Integer -> u0, Int -> u0)) -> case u1 of { _ALG_ _TUP_10 (u2 :: {{Eq u0}}) (u3 :: {{Text u0}}) (u4 :: u0 -> u0 -> u0) (u5 :: u0 -> u0 -> u0) (u6 :: u0 -> u0 -> u0) (u7 :: u0 -> u0) (u8 :: u0 -> u0) (u9 :: u0 -> u0) (ua :: Integer -> u0) (ub :: Int -> u0) -> u4; _NO_DEFLT_ } _N_
- {-defm-} _A_ 3 _U_ 022 _N_ _S_ _!_ _F_ _IF_ARGS_ 1 3 XXX 4 _/\_ u0 -> \ (u1 :: {{Num u0}}) (u2 :: u0) (u3 :: u0) -> _APP_ _TYAPP_ patError# { (u0 -> u0 -> u0) } [ _NOREP_S_ "%DPreludeCore.Num.(+)\"", u2, u3 ] _N_ #-}
+ {-defm-} _A_ 3 _U_ 022 _N_ _S_ _!_ _N_ _N_ #-}
(-) :: a -> a -> a
{-# GHC_PRAGMA {-meth-} _A_ 1 _U_ 122 _N_ _S_ "S" _F_ _IF_ARGS_ 1 1 C 2 _/\_ u0 -> \ (u1 :: ({{Eq u0}}, {{Text u0}}, u0 -> u0 -> u0, u0 -> u0 -> u0, u0 -> u0 -> u0, u0 -> u0, u0 -> u0, u0 -> u0, Integer -> u0, Int -> u0)) -> case u1 of { _ALG_ _TUP_10 (u2 :: {{Eq u0}}) (u3 :: {{Text u0}}) (u4 :: u0 -> u0 -> u0) (u5 :: u0 -> u0 -> u0) (u6 :: u0 -> u0 -> u0) (u7 :: u0 -> u0) (u8 :: u0 -> u0) (u9 :: u0 -> u0) (ua :: Integer -> u0) (ub :: Int -> u0) -> u5; _NO_DEFLT_ } _N_
{-defm-} _A_ 3 _U_ 122 _N_ _S_ "SLL" _F_ _ALWAYS_ _/\_ u0 -> \ (u1 :: {{Num u0}}) (u2 :: u0) (u3 :: u0) -> case u1 of { _ALG_ _TUP_10 (u4 :: {{Eq u0}}) (u5 :: {{Text u0}}) (u6 :: u0 -> u0 -> u0) (u7 :: u0 -> u0 -> u0) (u8 :: u0 -> u0 -> u0) (u9 :: u0 -> u0) (ua :: u0 -> u0) (ub :: u0 -> u0) (uc :: Integer -> u0) (ud :: Int -> u0) -> let {(ue :: u0) = _APP_ u9 [ u3 ]} in _APP_ u6 [ u2, ue ]; _NO_DEFLT_ } _N_ #-}
(*) :: a -> a -> a
{-# GHC_PRAGMA {-meth-} _A_ 1 _U_ 122 _N_ _S_ "S" _F_ _IF_ARGS_ 1 1 C 2 _/\_ u0 -> \ (u1 :: ({{Eq u0}}, {{Text u0}}, u0 -> u0 -> u0, u0 -> u0 -> u0, u0 -> u0 -> u0, u0 -> u0, u0 -> u0, u0 -> u0, Integer -> u0, Int -> u0)) -> case u1 of { _ALG_ _TUP_10 (u2 :: {{Eq u0}}) (u3 :: {{Text u0}}) (u4 :: u0 -> u0 -> u0) (u5 :: u0 -> u0 -> u0) (u6 :: u0 -> u0 -> u0) (u7 :: u0 -> u0) (u8 :: u0 -> u0) (u9 :: u0 -> u0) (ua :: Integer -> u0) (ub :: Int -> u0) -> u6; _NO_DEFLT_ } _N_
- {-defm-} _A_ 3 _U_ 022 _N_ _S_ _!_ _F_ _IF_ARGS_ 1 3 XXX 4 _/\_ u0 -> \ (u1 :: {{Num u0}}) (u2 :: u0) (u3 :: u0) -> _APP_ _TYAPP_ patError# { (u0 -> u0 -> u0) } [ _NOREP_S_ "%DPreludeCore.Num.(*)\"", u2, u3 ] _N_ #-}
+ {-defm-} _A_ 3 _U_ 022 _N_ _S_ _!_ _N_ _N_ #-}
negate :: a -> a
{-# GHC_PRAGMA {-meth-} _A_ 1 _U_ 12 _N_ _S_ "S" _F_ _IF_ARGS_ 1 1 C 2 _/\_ u0 -> \ (u1 :: ({{Eq u0}}, {{Text u0}}, u0 -> u0 -> u0, u0 -> u0 -> u0, u0 -> u0 -> u0, u0 -> u0, u0 -> u0, u0 -> u0, Integer -> u0, Int -> u0)) -> case u1 of { _ALG_ _TUP_10 (u2 :: {{Eq u0}}) (u3 :: {{Text u0}}) (u4 :: u0 -> u0 -> u0) (u5 :: u0 -> u0 -> u0) (u6 :: u0 -> u0 -> u0) (u7 :: u0 -> u0) (u8 :: u0 -> u0) (u9 :: u0 -> u0) (ua :: Integer -> u0) (ub :: Int -> u0) -> u7; _NO_DEFLT_ } _N_
- {-defm-} _A_ 2 _U_ 02 _N_ _S_ _!_ _F_ _IF_ARGS_ 1 2 XX 3 _/\_ u0 -> \ (u1 :: {{Num u0}}) (u2 :: u0) -> _APP_ _TYAPP_ patError# { (u0 -> u0) } [ _NOREP_S_ "%DPreludeCore.Num.negate\"", u2 ] _N_ #-}
+ {-defm-} _A_ 2 _U_ 02 _N_ _S_ _!_ _N_ _N_ #-}
abs :: a -> a
{-# GHC_PRAGMA {-meth-} _A_ 1 _U_ 12 _N_ _S_ "S" _F_ _IF_ARGS_ 1 1 C 2 _/\_ u0 -> \ (u1 :: ({{Eq u0}}, {{Text u0}}, u0 -> u0 -> u0, u0 -> u0 -> u0, u0 -> u0 -> u0, u0 -> u0, u0 -> u0, u0 -> u0, Integer -> u0, Int -> u0)) -> case u1 of { _ALG_ _TUP_10 (u2 :: {{Eq u0}}) (u3 :: {{Text u0}}) (u4 :: u0 -> u0 -> u0) (u5 :: u0 -> u0 -> u0) (u6 :: u0 -> u0 -> u0) (u7 :: u0 -> u0) (u8 :: u0 -> u0) (u9 :: u0 -> u0) (ua :: Integer -> u0) (ub :: Int -> u0) -> u8; _NO_DEFLT_ } _N_
- {-defm-} _A_ 2 _U_ 02 _N_ _S_ _!_ _F_ _IF_ARGS_ 1 2 XX 3 _/\_ u0 -> \ (u1 :: {{Num u0}}) (u2 :: u0) -> _APP_ _TYAPP_ patError# { (u0 -> u0) } [ _NOREP_S_ "%DPreludeCore.Num.abs\"", u2 ] _N_ #-}
+ {-defm-} _A_ 2 _U_ 02 _N_ _S_ _!_ _N_ _N_ #-}
signum :: a -> a
{-# GHC_PRAGMA {-meth-} _A_ 1 _U_ 12 _N_ _S_ "S" _F_ _IF_ARGS_ 1 1 C 2 _/\_ u0 -> \ (u1 :: ({{Eq u0}}, {{Text u0}}, u0 -> u0 -> u0, u0 -> u0 -> u0, u0 -> u0 -> u0, u0 -> u0, u0 -> u0, u0 -> u0, Integer -> u0, Int -> u0)) -> case u1 of { _ALG_ _TUP_10 (u2 :: {{Eq u0}}) (u3 :: {{Text u0}}) (u4 :: u0 -> u0 -> u0) (u5 :: u0 -> u0 -> u0) (u6 :: u0 -> u0 -> u0) (u7 :: u0 -> u0) (u8 :: u0 -> u0) (u9 :: u0 -> u0) (ua :: Integer -> u0) (ub :: Int -> u0) -> u9; _NO_DEFLT_ } _N_
- {-defm-} _A_ 2 _U_ 02 _N_ _S_ _!_ _F_ _IF_ARGS_ 1 2 XX 3 _/\_ u0 -> \ (u1 :: {{Num u0}}) (u2 :: u0) -> _APP_ _TYAPP_ patError# { (u0 -> u0) } [ _NOREP_S_ "%DPreludeCore.Num.signum\"", u2 ] _N_ #-}
+ {-defm-} _A_ 2 _U_ 02 _N_ _S_ _!_ _N_ _N_ #-}
fromInteger :: Integer -> a
{-# GHC_PRAGMA {-meth-} _A_ 1 _U_ 12 _N_ _S_ "S" _F_ _IF_ARGS_ 1 1 C 2 _/\_ u0 -> \ (u1 :: ({{Eq u0}}, {{Text u0}}, u0 -> u0 -> u0, u0 -> u0 -> u0, u0 -> u0 -> u0, u0 -> u0, u0 -> u0, u0 -> u0, Integer -> u0, Int -> u0)) -> case u1 of { _ALG_ _TUP_10 (u2 :: {{Eq u0}}) (u3 :: {{Text u0}}) (u4 :: u0 -> u0 -> u0) (u5 :: u0 -> u0 -> u0) (u6 :: u0 -> u0 -> u0) (u7 :: u0 -> u0) (u8 :: u0 -> u0) (u9 :: u0 -> u0) (ua :: Integer -> u0) (ub :: Int -> u0) -> ua; _NO_DEFLT_ } _N_
- {-defm-} _A_ 2 _U_ 02 _N_ _S_ _!_ _F_ _IF_ARGS_ 1 2 XX 3 _/\_ u0 -> \ (u1 :: {{Num u0}}) (u2 :: Integer) -> _APP_ _TYAPP_ patError# { (Integer -> u0) } [ _NOREP_S_ "%DPreludeCore.Num.fromInteger\"", u2 ] _N_ #-}
+ {-defm-} _A_ 2 _U_ 02 _N_ _S_ _!_ _N_ _N_ #-}
fromInt :: Int -> a
{-# GHC_PRAGMA {-meth-} _A_ 1 _U_ 12 _N_ _S_ "S" _F_ _IF_ARGS_ 1 1 C 2 _/\_ u0 -> \ (u1 :: ({{Eq u0}}, {{Text u0}}, u0 -> u0 -> u0, u0 -> u0 -> u0, u0 -> u0 -> u0, u0 -> u0, u0 -> u0, u0 -> u0, Integer -> u0, Int -> u0)) -> case u1 of { _ALG_ _TUP_10 (u2 :: {{Eq u0}}) (u3 :: {{Text u0}}) (u4 :: u0 -> u0 -> u0) (u5 :: u0 -> u0 -> u0) (u6 :: u0 -> u0 -> u0) (u7 :: u0 -> u0) (u8 :: u0 -> u0) (u9 :: u0 -> u0) (ua :: Integer -> u0) (ub :: Int -> u0) -> ub; _NO_DEFLT_ } _N_
{-defm-} _A_ 2 _U_ 11 _N_ _S_ "SL" _F_ _IF_ARGS_ 1 2 CC 6 _/\_ u0 -> \ (u1 :: {{Num u0}}) (u2 :: Int) -> let {(u4 :: Integer) = case u2 of { _ALG_ I# (u3 :: Int#) -> _#_ int2Integer# [] [u3]; _NO_DEFLT_ }} in case u1 of { _ALG_ _TUP_10 (u5 :: {{Eq u0}}) (u6 :: {{Text u0}}) (u7 :: u0 -> u0 -> u0) (u8 :: u0 -> u0 -> u0) (u9 :: u0 -> u0 -> u0) (ua :: u0 -> u0) (ub :: u0 -> u0) (uc :: u0 -> u0) (ud :: Integer -> u0) (ue :: Int -> u0) -> _APP_ ud [ u4 ]; _NO_DEFLT_ } _N_ #-}
{-defm-} _A_ 3 _U_ 122 _N_ _S_ "SLL" _N_ _N_ #-}
(<=) :: a -> a -> Bool
{-# GHC_PRAGMA {-meth-} _A_ 1 _U_ 122 _N_ _S_ "S" _F_ _IF_ARGS_ 1 1 C 2 _/\_ u0 -> \ (u1 :: ({{Eq u0}}, u0 -> u0 -> Bool, u0 -> u0 -> Bool, u0 -> u0 -> Bool, u0 -> u0 -> Bool, u0 -> u0 -> u0, u0 -> u0 -> u0, u0 -> u0 -> _CMP_TAG)) -> case u1 of { _ALG_ _TUP_8 (u2 :: {{Eq u0}}) (u3 :: u0 -> u0 -> Bool) (u4 :: u0 -> u0 -> Bool) (u5 :: u0 -> u0 -> Bool) (u6 :: u0 -> u0 -> Bool) (u7 :: u0 -> u0 -> u0) (u8 :: u0 -> u0 -> u0) (u9 :: u0 -> u0 -> _CMP_TAG) -> u4; _NO_DEFLT_ } _N_
- {-defm-} _A_ 3 _U_ 022 _N_ _S_ _!_ _F_ _IF_ARGS_ 1 3 XXX 4 _/\_ u0 -> \ (u1 :: {{Ord u0}}) (u2 :: u0) (u3 :: u0) -> _APP_ _TYAPP_ patError# { (u0 -> u0 -> Bool) } [ _NOREP_S_ "%DPreludeCore.Ord.(<=)\"", u2, u3 ] _N_ #-}
+ {-defm-} _A_ 3 _U_ 022 _N_ _S_ _!_ _N_ _N_ #-}
(>=) :: a -> a -> Bool
{-# GHC_PRAGMA {-meth-} _A_ 1 _U_ 122 _N_ _S_ "S" _F_ _IF_ARGS_ 1 1 C 2 _/\_ u0 -> \ (u1 :: ({{Eq u0}}, u0 -> u0 -> Bool, u0 -> u0 -> Bool, u0 -> u0 -> Bool, u0 -> u0 -> Bool, u0 -> u0 -> u0, u0 -> u0 -> u0, u0 -> u0 -> _CMP_TAG)) -> case u1 of { _ALG_ _TUP_8 (u2 :: {{Eq u0}}) (u3 :: u0 -> u0 -> Bool) (u4 :: u0 -> u0 -> Bool) (u5 :: u0 -> u0 -> Bool) (u6 :: u0 -> u0 -> Bool) (u7 :: u0 -> u0 -> u0) (u8 :: u0 -> u0 -> u0) (u9 :: u0 -> u0 -> _CMP_TAG) -> u5; _NO_DEFLT_ } _N_
{-defm-} _A_ 3 _U_ 122 _N_ _S_ "SLL" _F_ _IF_ARGS_ 1 3 CXX 4 _/\_ u0 -> \ (u1 :: {{Ord u0}}) (u2 :: u0) (u3 :: u0) -> case u1 of { _ALG_ _TUP_8 (u4 :: {{Eq u0}}) (u5 :: u0 -> u0 -> Bool) (u6 :: u0 -> u0 -> Bool) (u7 :: u0 -> u0 -> Bool) (u8 :: u0 -> u0 -> Bool) (u9 :: u0 -> u0 -> u0) (ua :: u0 -> u0 -> u0) (ub :: u0 -> u0 -> _CMP_TAG) -> _APP_ u6 [ u3, u2 ]; _NO_DEFLT_ } _N_ #-}
class (Num a, Enum a) => Real a {-# GHC_PRAGMA {-superdicts-} _A_ 1 _U_ 1 _N_ _S_ "S" _F_ _IF_ARGS_ 1 1 C 2 _/\_ u0 -> \ (u1 :: ({{Num u0}}, {{Enum u0}}, u0 -> Ratio Integer)) -> case u1 of { _ALG_ _TUP_3 (u2 :: {{Num u0}}) (u3 :: {{Enum u0}}) (u4 :: u0 -> Ratio Integer) -> u2; _NO_DEFLT_ } _N_, _A_ 1 _U_ 1 _N_ _S_ "S" _F_ _IF_ARGS_ 1 1 C 2 _/\_ u0 -> \ (u1 :: ({{Num u0}}, {{Enum u0}}, u0 -> Ratio Integer)) -> case u1 of { _ALG_ _TUP_3 (u2 :: {{Num u0}}) (u3 :: {{Enum u0}}) (u4 :: u0 -> Ratio Integer) -> u3; _NO_DEFLT_ } _N_ #-} where
toRational :: a -> Ratio Integer
{-# GHC_PRAGMA {-meth-} _A_ 1 _U_ 12 _N_ _S_ "S" _F_ _IF_ARGS_ 1 1 C 2 _/\_ u0 -> \ (u1 :: ({{Num u0}}, {{Enum u0}}, u0 -> Ratio Integer)) -> case u1 of { _ALG_ _TUP_3 (u2 :: {{Num u0}}) (u3 :: {{Enum u0}}) (u4 :: u0 -> Ratio Integer) -> u4; _NO_DEFLT_ } _N_
- {-defm-} _A_ 2 _U_ 02 _N_ _S_ _!_ _F_ _IF_ARGS_ 1 2 XX 3 _/\_ u0 -> \ (u1 :: {{Real u0}}) (u2 :: u0) -> _APP_ _TYAPP_ patError# { (u0 -> Ratio Integer) } [ _NOREP_S_ "%DPreludeCore.Real.toRational\"", u2 ] _N_ #-}
+ {-defm-} _A_ 2 _U_ 02 _N_ _S_ _!_ _N_ _N_ #-}
class (RealFrac a, Floating a) => RealFloat a {-# GHC_PRAGMA {-superdicts-} _A_ 1 _U_ 1 _N_ _S_ "S" _F_ _IF_ARGS_ 1 1 C 2 _/\_ u0 -> \ (u1 :: ({{RealFrac u0}}, {{Floating u0}}, u0 -> Integer, u0 -> Int, u0 -> (Int, Int), u0 -> (Integer, Int), Integer -> Int -> u0, u0 -> Int, u0 -> u0, Int -> u0 -> u0)) -> case u1 of { _ALG_ _TUP_10 (u2 :: {{RealFrac u0}}) (u3 :: {{Floating u0}}) (u4 :: u0 -> Integer) (u5 :: u0 -> Int) (u6 :: u0 -> (Int, Int)) (u7 :: u0 -> (Integer, Int)) (u8 :: Integer -> Int -> u0) (u9 :: u0 -> Int) (ua :: u0 -> u0) (ub :: Int -> u0 -> u0) -> u2; _NO_DEFLT_ } _N_, _A_ 1 _U_ 1 _N_ _S_ "S" _F_ _IF_ARGS_ 1 1 C 2 _/\_ u0 -> \ (u1 :: ({{RealFrac u0}}, {{Floating u0}}, u0 -> Integer, u0 -> Int, u0 -> (Int, Int), u0 -> (Integer, Int), Integer -> Int -> u0, u0 -> Int, u0 -> u0, Int -> u0 -> u0)) -> case u1 of { _ALG_ _TUP_10 (u2 :: {{RealFrac u0}}) (u3 :: {{Floating u0}}) (u4 :: u0 -> Integer) (u5 :: u0 -> Int) (u6 :: u0 -> (Int, Int)) (u7 :: u0 -> (Integer, Int)) (u8 :: Integer -> Int -> u0) (u9 :: u0 -> Int) (ua :: u0 -> u0) (ub :: Int -> u0 -> u0) -> u3; _NO_DEFLT_ } _N_ #-} where
floatRadix :: a -> Integer
{-# GHC_PRAGMA {-meth-} _A_ 1 _U_ 12 _N_ _S_ "S" _F_ _IF_ARGS_ 1 1 C 2 _/\_ u0 -> \ (u1 :: ({{RealFrac u0}}, {{Floating u0}}, u0 -> Integer, u0 -> Int, u0 -> (Int, Int), u0 -> (Integer, Int), Integer -> Int -> u0, u0 -> Int, u0 -> u0, Int -> u0 -> u0)) -> case u1 of { _ALG_ _TUP_10 (u2 :: {{RealFrac u0}}) (u3 :: {{Floating u0}}) (u4 :: u0 -> Integer) (u5 :: u0 -> Int) (u6 :: u0 -> (Int, Int)) (u7 :: u0 -> (Integer, Int)) (u8 :: Integer -> Int -> u0) (u9 :: u0 -> Int) (ua :: u0 -> u0) (ub :: Int -> u0 -> u0) -> u4; _NO_DEFLT_ } _N_
- {-defm-} _A_ 2 _U_ 02 _N_ _S_ _!_ _F_ _IF_ARGS_ 1 2 XX 3 _/\_ u0 -> \ (u1 :: {{RealFloat u0}}) (u2 :: u0) -> _APP_ _TYAPP_ patError# { (u0 -> Integer) } [ _NOREP_S_ "%DPreludeCore.RealFloat.floatRadix\"", u2 ] _N_ #-}
+ {-defm-} _A_ 2 _U_ 02 _N_ _S_ _!_ _N_ _N_ #-}
floatDigits :: a -> Int
{-# GHC_PRAGMA {-meth-} _A_ 1 _U_ 12 _N_ _S_ "S" _F_ _IF_ARGS_ 1 1 C 2 _/\_ u0 -> \ (u1 :: ({{RealFrac u0}}, {{Floating u0}}, u0 -> Integer, u0 -> Int, u0 -> (Int, Int), u0 -> (Integer, Int), Integer -> Int -> u0, u0 -> Int, u0 -> u0, Int -> u0 -> u0)) -> case u1 of { _ALG_ _TUP_10 (u2 :: {{RealFrac u0}}) (u3 :: {{Floating u0}}) (u4 :: u0 -> Integer) (u5 :: u0 -> Int) (u6 :: u0 -> (Int, Int)) (u7 :: u0 -> (Integer, Int)) (u8 :: Integer -> Int -> u0) (u9 :: u0 -> Int) (ua :: u0 -> u0) (ub :: Int -> u0 -> u0) -> u5; _NO_DEFLT_ } _N_
- {-defm-} _A_ 2 _U_ 02 _N_ _S_ _!_ _F_ _IF_ARGS_ 1 2 XX 3 _/\_ u0 -> \ (u1 :: {{RealFloat u0}}) (u2 :: u0) -> _APP_ _TYAPP_ patError# { (u0 -> Int) } [ _NOREP_S_ "%DPreludeCore.RealFloat.floatDigits\"", u2 ] _N_ #-}
+ {-defm-} _A_ 2 _U_ 02 _N_ _S_ _!_ _N_ _N_ #-}
floatRange :: a -> (Int, Int)
{-# GHC_PRAGMA {-meth-} _A_ 1 _U_ 12 _N_ _S_ "S" _F_ _IF_ARGS_ 1 1 C 2 _/\_ u0 -> \ (u1 :: ({{RealFrac u0}}, {{Floating u0}}, u0 -> Integer, u0 -> Int, u0 -> (Int, Int), u0 -> (Integer, Int), Integer -> Int -> u0, u0 -> Int, u0 -> u0, Int -> u0 -> u0)) -> case u1 of { _ALG_ _TUP_10 (u2 :: {{RealFrac u0}}) (u3 :: {{Floating u0}}) (u4 :: u0 -> Integer) (u5 :: u0 -> Int) (u6 :: u0 -> (Int, Int)) (u7 :: u0 -> (Integer, Int)) (u8 :: Integer -> Int -> u0) (u9 :: u0 -> Int) (ua :: u0 -> u0) (ub :: Int -> u0 -> u0) -> u6; _NO_DEFLT_ } _N_
- {-defm-} _A_ 2 _U_ 02 _N_ _S_ _!_ _F_ _IF_ARGS_ 1 2 XX 3 _/\_ u0 -> \ (u1 :: {{RealFloat u0}}) (u2 :: u0) -> _APP_ _TYAPP_ patError# { (u0 -> (Int, Int)) } [ _NOREP_S_ "%DPreludeCore.RealFloat.floatRange\"", u2 ] _N_ #-}
+ {-defm-} _A_ 2 _U_ 02 _N_ _S_ _!_ _N_ _N_ #-}
decodeFloat :: a -> (Integer, Int)
{-# GHC_PRAGMA {-meth-} _A_ 1 _U_ 12 _N_ _S_ "S" _F_ _IF_ARGS_ 1 1 C 2 _/\_ u0 -> \ (u1 :: ({{RealFrac u0}}, {{Floating u0}}, u0 -> Integer, u0 -> Int, u0 -> (Int, Int), u0 -> (Integer, Int), Integer -> Int -> u0, u0 -> Int, u0 -> u0, Int -> u0 -> u0)) -> case u1 of { _ALG_ _TUP_10 (u2 :: {{RealFrac u0}}) (u3 :: {{Floating u0}}) (u4 :: u0 -> Integer) (u5 :: u0 -> Int) (u6 :: u0 -> (Int, Int)) (u7 :: u0 -> (Integer, Int)) (u8 :: Integer -> Int -> u0) (u9 :: u0 -> Int) (ua :: u0 -> u0) (ub :: Int -> u0 -> u0) -> u7; _NO_DEFLT_ } _N_
- {-defm-} _A_ 2 _U_ 02 _N_ _S_ _!_ _F_ _IF_ARGS_ 1 2 XX 3 _/\_ u0 -> \ (u1 :: {{RealFloat u0}}) (u2 :: u0) -> _APP_ _TYAPP_ patError# { (u0 -> (Integer, Int)) } [ _NOREP_S_ "%DPreludeCore.RealFloat.decodeFloat\"", u2 ] _N_ #-}
+ {-defm-} _A_ 2 _U_ 02 _N_ _S_ _!_ _N_ _N_ #-}
encodeFloat :: Integer -> Int -> a
{-# GHC_PRAGMA {-meth-} _A_ 1 _U_ 122 _N_ _S_ "S" _F_ _IF_ARGS_ 1 1 C 2 _/\_ u0 -> \ (u1 :: ({{RealFrac u0}}, {{Floating u0}}, u0 -> Integer, u0 -> Int, u0 -> (Int, Int), u0 -> (Integer, Int), Integer -> Int -> u0, u0 -> Int, u0 -> u0, Int -> u0 -> u0)) -> case u1 of { _ALG_ _TUP_10 (u2 :: {{RealFrac u0}}) (u3 :: {{Floating u0}}) (u4 :: u0 -> Integer) (u5 :: u0 -> Int) (u6 :: u0 -> (Int, Int)) (u7 :: u0 -> (Integer, Int)) (u8 :: Integer -> Int -> u0) (u9 :: u0 -> Int) (ua :: u0 -> u0) (ub :: Int -> u0 -> u0) -> u8; _NO_DEFLT_ } _N_
- {-defm-} _A_ 3 _U_ 022 _N_ _S_ _!_ _F_ _IF_ARGS_ 1 3 XXX 4 _/\_ u0 -> \ (u1 :: {{RealFloat u0}}) (u2 :: Integer) (u3 :: Int) -> _APP_ _TYAPP_ patError# { (Integer -> Int -> u0) } [ _NOREP_S_ "%DPreludeCore.RealFloat.encodeFloat\"", u2, u3 ] _N_ #-}
+ {-defm-} _A_ 3 _U_ 022 _N_ _S_ _!_ _N_ _N_ #-}
exponent :: a -> Int
{-# GHC_PRAGMA {-meth-} _A_ 1 _U_ 12 _N_ _S_ "S" _F_ _IF_ARGS_ 1 1 C 2 _/\_ u0 -> \ (u1 :: ({{RealFrac u0}}, {{Floating u0}}, u0 -> Integer, u0 -> Int, u0 -> (Int, Int), u0 -> (Integer, Int), Integer -> Int -> u0, u0 -> Int, u0 -> u0, Int -> u0 -> u0)) -> case u1 of { _ALG_ _TUP_10 (u2 :: {{RealFrac u0}}) (u3 :: {{Floating u0}}) (u4 :: u0 -> Integer) (u5 :: u0 -> Int) (u6 :: u0 -> (Int, Int)) (u7 :: u0 -> (Integer, Int)) (u8 :: Integer -> Int -> u0) (u9 :: u0 -> Int) (ua :: u0 -> u0) (ub :: Int -> u0 -> u0) -> u9; _NO_DEFLT_ } _N_
{-defm-} _A_ 2 _U_ 12 _N_ _S_ "SL" _N_ _N_ #-}
class (Real a, Fractional a) => RealFrac a {-# GHC_PRAGMA {-superdicts-} _A_ 1 _U_ 1 _N_ _S_ "S" _F_ _IF_ARGS_ 1 1 C 2 _/\_ u0 -> \ (u1 :: ({{Real u0}}, {{Fractional u0}}, (_forall_ z$z1 =>{{Integral z$z1}} -> u0 -> (z$z1, u0)), (_forall_ z$z1 =>{{Integral z$z1}} -> u0 -> z$z1), (_forall_ z$z1 =>{{Integral z$z1}} -> u0 -> z$z1), (_forall_ z$z1 =>{{Integral z$z1}} -> u0 -> z$z1), (_forall_ z$z1 =>{{Integral z$z1}} -> u0 -> z$z1))) -> case u1 of { _ALG_ _TUP_7 (u2 :: {{Real u0}}) (u3 :: {{Fractional u0}}) (u4 :: _forall_ a$z1 =>{{Integral a$z1}} -> u0 -> (a$z1, u0)) (u5 :: _forall_ a$z1 =>{{Integral a$z1}} -> u0 -> a$z1) (u6 :: _forall_ a$z1 =>{{Integral a$z1}} -> u0 -> a$z1) (u7 :: _forall_ a$z1 =>{{Integral a$z1}} -> u0 -> a$z1) (u8 :: _forall_ a$z1 =>{{Integral a$z1}} -> u0 -> a$z1) -> u2; _NO_DEFLT_ } _N_, _A_ 1 _U_ 1 _N_ _S_ "S" _F_ _IF_ARGS_ 1 1 C 2 _/\_ u0 -> \ (u1 :: ({{Real u0}}, {{Fractional u0}}, (_forall_ z$z1 =>{{Integral z$z1}} -> u0 -> (z$z1, u0)), (_forall_ z$z1 =>{{Integral z$z1}} -> u0 -> z$z1), (_forall_ z$z1 =>{{Integral z$z1}} -> u0 -> z$z1), (_forall_ z$z1 =>{{Integral z$z1}} -> u0 -> z$z1), (_forall_ z$z1 =>{{Integral z$z1}} -> u0 -> z$z1))) -> case u1 of { _ALG_ _TUP_7 (u2 :: {{Real u0}}) (u3 :: {{Fractional u0}}) (u4 :: _forall_ a$z1 =>{{Integral a$z1}} -> u0 -> (a$z1, u0)) (u5 :: _forall_ a$z1 =>{{Integral a$z1}} -> u0 -> a$z1) (u6 :: _forall_ a$z1 =>{{Integral a$z1}} -> u0 -> a$z1) (u7 :: _forall_ a$z1 =>{{Integral a$z1}} -> u0 -> a$z1) (u8 :: _forall_ a$z1 =>{{Integral a$z1}} -> u0 -> a$z1) -> u3; _NO_DEFLT_ } _N_ #-} where
properFraction :: Integral b => a -> (b, a)
{-# GHC_PRAGMA {-meth-} _A_ 2 _U_ 122 _N_ _S_ "SL" _F_ _IF_ARGS_ 2 2 CX 3 _/\_ u0 u1 -> \ (u2 :: ({{Real u0}}, {{Fractional u0}}, (_forall_ z$z1 =>{{Integral z$z1}} -> u0 -> (z$z1, u0)), (_forall_ z$z1 =>{{Integral z$z1}} -> u0 -> z$z1), (_forall_ z$z1 =>{{Integral z$z1}} -> u0 -> z$z1), (_forall_ z$z1 =>{{Integral z$z1}} -> u0 -> z$z1), (_forall_ z$z1 =>{{Integral z$z1}} -> u0 -> z$z1))) (u3 :: {{Integral u1}}) -> case u2 of { _ALG_ _TUP_7 (u4 :: {{Real u0}}) (u5 :: {{Fractional u0}}) (u6 :: _forall_ a$z1 =>{{Integral a$z1}} -> u0 -> (a$z1, u0)) (u7 :: _forall_ a$z1 =>{{Integral a$z1}} -> u0 -> a$z1) (u8 :: _forall_ a$z1 =>{{Integral a$z1}} -> u0 -> a$z1) (u9 :: _forall_ a$z1 =>{{Integral a$z1}} -> u0 -> a$z1) (ua :: _forall_ a$z1 =>{{Integral a$z1}} -> u0 -> a$z1) -> _APP_ _TYAPP_ u6 { u1 } [ u3 ]; _NO_DEFLT_ } _N_
- {-defm-} _A_ 3 _U_ 002 _N_ _S_ _!_ _F_ _IF_ARGS_ 2 3 XXX 3 _/\_ u0 u1 -> \ (u2 :: {{RealFrac u0}}) (u3 :: {{Integral u1}}) (u4 :: u0) -> _APP_ _TYAPP_ patError# { (u0 -> (u1, u0)) } [ _NOREP_S_ "%DPreludeCore.RealFrac.properFraction\"", u4 ] _N_ #-}
+ {-defm-} _A_ 3 _U_ 002 _N_ _S_ _!_ _N_ _N_ #-}
truncate :: Integral b => a -> b
{-# GHC_PRAGMA {-meth-} _A_ 2 _U_ 122 _N_ _S_ "SL" _F_ _IF_ARGS_ 2 2 CX 3 _/\_ u0 u1 -> \ (u2 :: ({{Real u0}}, {{Fractional u0}}, (_forall_ z$z1 =>{{Integral z$z1}} -> u0 -> (z$z1, u0)), (_forall_ z$z1 =>{{Integral z$z1}} -> u0 -> z$z1), (_forall_ z$z1 =>{{Integral z$z1}} -> u0 -> z$z1), (_forall_ z$z1 =>{{Integral z$z1}} -> u0 -> z$z1), (_forall_ z$z1 =>{{Integral z$z1}} -> u0 -> z$z1))) (u3 :: {{Integral u1}}) -> case u2 of { _ALG_ _TUP_7 (u4 :: {{Real u0}}) (u5 :: {{Fractional u0}}) (u6 :: _forall_ a$z1 =>{{Integral a$z1}} -> u0 -> (a$z1, u0)) (u7 :: _forall_ a$z1 =>{{Integral a$z1}} -> u0 -> a$z1) (u8 :: _forall_ a$z1 =>{{Integral a$z1}} -> u0 -> a$z1) (u9 :: _forall_ a$z1 =>{{Integral a$z1}} -> u0 -> a$z1) (ua :: _forall_ a$z1 =>{{Integral a$z1}} -> u0 -> a$z1) -> _APP_ _TYAPP_ u7 { u1 } [ u3 ]; _NO_DEFLT_ } _N_
{-defm-} _A_ 2 _U_ 122 _N_ _S_ "SL" _N_ _N_ #-}
class Text a where
readsPrec :: Int -> [Char] -> [(a, [Char])]
{-# GHC_PRAGMA {-meth-} _A_ 1 _U_ 122 _N_ _S_ "S" _F_ _IF_ARGS_ 1 1 C 2 _/\_ u0 -> \ (u1 :: (Int -> [Char] -> [(u0, [Char])], Int -> u0 -> [Char] -> [Char], [Char] -> [([u0], [Char])], [u0] -> [Char] -> [Char])) -> case u1 of { _ALG_ _TUP_4 (u2 :: Int -> [Char] -> [(u0, [Char])]) (u3 :: Int -> u0 -> [Char] -> [Char]) (u4 :: [Char] -> [([u0], [Char])]) (u5 :: [u0] -> [Char] -> [Char]) -> u2; _NO_DEFLT_ } _N_
- {-defm-} _A_ 3 _U_ 022 _N_ _S_ _!_ _F_ _IF_ARGS_ 1 3 XXX 4 _/\_ u0 -> \ (u1 :: {{Text u0}}) (u2 :: Int) (u3 :: [Char]) -> _APP_ _TYAPP_ patError# { (Int -> [Char] -> [(u0, [Char])]) } [ _NOREP_S_ "%DPreludeCore.Text.readsPrec\"", u2, u3 ] _N_ #-}
+ {-defm-} _A_ 3 _U_ 022 _N_ _S_ _!_ _N_ _N_ #-}
showsPrec :: Int -> a -> [Char] -> [Char]
{-# GHC_PRAGMA {-meth-} _A_ 1 _U_ 1222 _N_ _S_ "S" _F_ _IF_ARGS_ 1 1 C 2 _/\_ u0 -> \ (u1 :: (Int -> [Char] -> [(u0, [Char])], Int -> u0 -> [Char] -> [Char], [Char] -> [([u0], [Char])], [u0] -> [Char] -> [Char])) -> case u1 of { _ALG_ _TUP_4 (u2 :: Int -> [Char] -> [(u0, [Char])]) (u3 :: Int -> u0 -> [Char] -> [Char]) (u4 :: [Char] -> [([u0], [Char])]) (u5 :: [u0] -> [Char] -> [Char]) -> u3; _NO_DEFLT_ } _N_
- {-defm-} _A_ 4 _U_ 0222 _N_ _S_ _!_ _F_ _IF_ARGS_ 1 4 XXXX 5 _/\_ u0 -> \ (u1 :: {{Text u0}}) (u2 :: Int) (u3 :: u0) (u4 :: [Char]) -> _APP_ _TYAPP_ patError# { (Int -> u0 -> [Char] -> [Char]) } [ _NOREP_S_ "%DPreludeCore.Text.showsPrec\"", u2, u3, u4 ] _N_ #-}
+ {-defm-} _A_ 4 _U_ 0222 _N_ _S_ _!_ _N_ _N_ #-}
readList :: [Char] -> [([a], [Char])]
{-# GHC_PRAGMA {-meth-} _A_ 1 _U_ 12 _N_ _S_ "S" _F_ _IF_ARGS_ 1 1 C 2 _/\_ u0 -> \ (u1 :: (Int -> [Char] -> [(u0, [Char])], Int -> u0 -> [Char] -> [Char], [Char] -> [([u0], [Char])], [u0] -> [Char] -> [Char])) -> case u1 of { _ALG_ _TUP_4 (u2 :: Int -> [Char] -> [(u0, [Char])]) (u3 :: Int -> u0 -> [Char] -> [Char]) (u4 :: [Char] -> [([u0], [Char])]) (u5 :: [u0] -> [Char] -> [Char]) -> u4; _NO_DEFLT_ } _N_
- {-defm-} _A_ 1 _U_ 22 _N_ _N_ _F_ _IF_ARGS_ 0 0 X 1 _ORIG_ PreludeCore _readList _N_ #-}
+ {-defm-} _A_ 1 _U_ 12 _N_ _N_ _N_ _N_ #-}
showList :: [a] -> [Char] -> [Char]
{-# GHC_PRAGMA {-meth-} _A_ 1 _U_ 122 _N_ _S_ "S" _F_ _IF_ARGS_ 1 1 C 2 _/\_ u0 -> \ (u1 :: (Int -> [Char] -> [(u0, [Char])], Int -> u0 -> [Char] -> [Char], [Char] -> [([u0], [Char])], [u0] -> [Char] -> [Char])) -> case u1 of { _ALG_ _TUP_4 (u2 :: Int -> [Char] -> [(u0, [Char])]) (u3 :: Int -> u0 -> [Char] -> [Char]) (u4 :: [Char] -> [([u0], [Char])]) (u5 :: [u0] -> [Char] -> [Char]) -> u5; _NO_DEFLT_ } _N_
- {-defm-} _A_ 1 _U_ 212 _N_ _N_ _F_ _IF_ARGS_ 0 0 X 1 _ORIG_ PreludeCore _showList _N_ #-}
+ {-defm-} _A_ 1 _U_ 112 _N_ _N_ _N_ _N_ #-}
class _CCallable a
class _CReturnable a
data Array a b {-# GHC_PRAGMA _Array (a, a) (Array# b) #-}
data Assoc a b = (:=) a b
data _ByteArray a {-# GHC_PRAGMA _ByteArray (a, a) ByteArray# #-}
data Bin
-data Complex a = (:+) a a
+data Complex a = (:+) a a {-# GHC_PRAGMA _SPECIALISE_ [ Double# ] #-}
data _MutableArray a b c {-# GHC_PRAGMA _MutableArray (b, b) (MutableArray# a c) #-}
data _MutableByteArray a b {-# GHC_PRAGMA _MutableByteArray (b, b) (MutableByteArray# a) #-}
data IOError13 = AlreadyExists [Char] | HardwareFault [Char] | IllegalOperation [Char] | InappropriateType [Char] | Interrupted [Char] | InvalidArgument [Char] | NoSuchThing [Char] | OtherError13 [Char] | PermissionDenied [Char] | ProtocolError [Char] | ResourceBusy [Char] | ResourceExhausted [Char] | ResourceVanished [Char] | SystemError [Char] | TimeExpired [Char] | UnsatisfiedConstraints [Char] | UnsupportedOperation [Char] | UserError [Char] | EOF
type ReadS a = [Char] -> [(a, [Char])]
type ShowS = [Char] -> [Char]
data _FILE {-# GHC_PRAGMA _FILE Addr# #-}
+__i0 :: Num a => a
+ {-# GHC_PRAGMA _A_ 1 _U_ 1 _N_ _S_ "U(AAAAAAAAAS)" {_A_ 1 _U_ 1 _N_ _N_ _N_ _N_} _N_ _SPECIALISE_ [ Double ] 1 { _A_ 0 _N_ _N_ _N_ _F_ _IF_ARGS_ 0 0 X 2 _!_ D# [] [0.0000000000000000##] _N_ }, [ Int ] 1 { _A_ 0 _N_ _N_ _N_ _F_ _IF_ARGS_ 0 0 X 2 _!_ I# [] [0#] _N_ }, [ Integer ] 1 { _A_ 0 _N_ _N_ _N_ _N_ _N_ }, [ (Ratio Integer) ] 1 { _A_ 0 _N_ _N_ _N_ _N_ _N_ }, [ (Complex Double) ] 1 { _A_ 0 _N_ _N_ _N_ _N_ _N_ } #-}
+__i1 :: Num a => a
+ {-# GHC_PRAGMA _A_ 1 _U_ 1 _N_ _S_ "U(AAAAAAAAAS)" {_A_ 1 _U_ 1 _N_ _N_ _N_ _N_} _N_ _SPECIALISE_ [ Double ] 1 { _A_ 0 _N_ _N_ _N_ _F_ _IF_ARGS_ 0 0 X 2 _!_ D# [] [1.0000000000000000##] _N_ }, [ Int ] 1 { _A_ 0 _N_ _N_ _N_ _F_ _IF_ARGS_ 0 0 X 2 _!_ I# [] [1#] _N_ }, [ Integer ] 1 { _A_ 0 _N_ _N_ _N_ _N_ _N_ }, [ (Ratio Integer) ] 1 { _A_ 0 _N_ _N_ _N_ _N_ _N_ }, [ (Complex Double) ] 1 { _A_ 0 _N_ _N_ _N_ _N_ _N_ } #-}
+__i10 :: Num a => a
+ {-# GHC_PRAGMA _A_ 1 _U_ 1 _N_ _S_ "U(AAAAAAAAAS)" {_A_ 1 _U_ 1 _N_ _N_ _N_ _N_} _N_ _SPECIALISE_ [ Double ] 1 { _A_ 0 _N_ _N_ _N_ _F_ _IF_ARGS_ 0 0 X 2 _!_ D# [] [10.000000000000000##] _N_ }, [ Int ] 1 { _A_ 0 _N_ _N_ _N_ _F_ _IF_ARGS_ 0 0 X 2 _!_ I# [] [10#] _N_ }, [ Integer ] 1 { _A_ 0 _N_ _N_ _N_ _N_ _N_ }, [ (Ratio Integer) ] 1 { _A_ 0 _N_ _N_ _N_ _N_ _N_ }, [ (Complex Double) ] 1 { _A_ 0 _N_ _N_ _N_ _N_ _N_ } #-}
+__i16 :: Num a => a
+ {-# GHC_PRAGMA _A_ 1 _U_ 1 _N_ _S_ "U(AAAAAAAAAS)" {_A_ 1 _U_ 1 _N_ _N_ _N_ _N_} _N_ _SPECIALISE_ [ Double ] 1 { _A_ 0 _N_ _N_ _N_ _F_ _IF_ARGS_ 0 0 X 2 _!_ D# [] [16.000000000000000##] _N_ }, [ Int ] 1 { _A_ 0 _N_ _N_ _N_ _F_ _IF_ARGS_ 0 0 X 2 _!_ I# [] [16#] _N_ }, [ Integer ] 1 { _A_ 0 _N_ _N_ _N_ _N_ _N_ }, [ (Ratio Integer) ] 1 { _A_ 0 _N_ _N_ _N_ _N_ _N_ }, [ (Complex Double) ] 1 { _A_ 0 _N_ _N_ _N_ _N_ _N_ } #-}
+__i2 :: Num a => a
+ {-# GHC_PRAGMA _A_ 1 _U_ 1 _N_ _S_ "U(AAAAAAAAAS)" {_A_ 1 _U_ 1 _N_ _N_ _N_ _N_} _N_ _SPECIALISE_ [ Double ] 1 { _A_ 0 _N_ _N_ _N_ _F_ _IF_ARGS_ 0 0 X 2 _!_ D# [] [2.0000000000000000##] _N_ }, [ Int ] 1 { _A_ 0 _N_ _N_ _N_ _F_ _IF_ARGS_ 0 0 X 2 _!_ I# [] [2#] _N_ }, [ Integer ] 1 { _A_ 0 _N_ _N_ _N_ _N_ _N_ }, [ (Ratio Integer) ] 1 { _A_ 0 _N_ _N_ _N_ _N_ _N_ }, [ (Complex Double) ] 1 { _A_ 0 _N_ _N_ _N_ _N_ _N_ } #-}
+__i8 :: Num a => a
+ {-# GHC_PRAGMA _A_ 1 _U_ 1 _N_ _S_ "U(AAAAAAAAAS)" {_A_ 1 _U_ 1 _N_ _N_ _N_ _N_} _N_ _SPECIALISE_ [ Double ] 1 { _A_ 0 _N_ _N_ _N_ _F_ _IF_ARGS_ 0 0 X 2 _!_ D# [] [8.0000000000000000##] _N_ }, [ Int ] 1 { _A_ 0 _N_ _N_ _N_ _F_ _IF_ARGS_ 0 0 X 2 _!_ I# [] [8#] _N_ }, [ Integer ] 1 { _A_ 0 _N_ _N_ _N_ _N_ _N_ }, [ (Ratio Integer) ] 1 { _A_ 0 _N_ _N_ _N_ _N_ _N_ }, [ (Complex Double) ] 1 { _A_ 0 _N_ _N_ _N_ _N_ _N_ } #-}
+__im1 :: Num a => a
+ {-# GHC_PRAGMA _A_ 1 _U_ 1 _N_ _S_ "U(AAAAAAAAAS)" {_A_ 1 _U_ 1 _N_ _N_ _N_ _N_} _N_ _SPECIALISE_ [ Double ] 1 { _A_ 0 _N_ _N_ _N_ _F_ _IF_ARGS_ 0 0 X 2 _!_ D# [] [-1.0000000000000000##] _N_ }, [ Int ] 1 { _A_ 0 _N_ _N_ _N_ _F_ _IF_ARGS_ 0 0 X 2 _!_ I# [] [-1#] _N_ }, [ Integer ] 1 { _A_ 0 _N_ _N_ _N_ _N_ _N_ }, [ (Ratio Integer) ] 1 { _A_ 0 _N_ _N_ _N_ _N_ _N_ }, [ (Complex Double) ] 1 { _A_ 0 _N_ _N_ _N_ _N_ _N_ } #-}
+__integer0 :: Integer
+ {-# GHC_PRAGMA _A_ 0 _N_ _N_ _N_ _N_ _N_ #-}
+__integer1 :: Integer
+ {-# GHC_PRAGMA _A_ 0 _N_ _N_ _N_ _N_ _N_ #-}
+__integer2 :: Integer
+ {-# GHC_PRAGMA _A_ 0 _N_ _N_ _N_ _N_ _N_ #-}
+__integerm1 :: Integer
+ {-# GHC_PRAGMA _A_ 0 _N_ _N_ _N_ _N_ _N_ #-}
+__rhalf :: Fractional a => a
+ {-# GHC_PRAGMA _A_ 1 _U_ 1 _N_ _S_ "U(AAAS)" {_A_ 1 _U_ 1 _N_ _N_ _N_ _N_} _N_ _SPECIALISE_ [ Double ] 1 { _A_ 0 _N_ _N_ _N_ _N_ _N_ }, [ (Ratio Integer) ] 1 { _A_ 0 _N_ _N_ _N_ _F_ _IF_ARGS_ 0 0 X 3 _!_ (:%) [Integer] [_SPEC_ _ORIG_ PreludeCore __i1 [ (Integer) ], _SPEC_ _ORIG_ PreludeCore __i2 [ (Integer) ]] _N_ }, [ (Complex Double) ] 1 { _A_ 0 _N_ _N_ _N_ _N_ _N_ } #-}
+_fromRational :: RealFloat a => Ratio Integer -> a
+ {-# GHC_PRAGMA _A_ 2 _U_ 22 _N_ _N_ _N_ _SPECIALISE_ [ Double ] 1 { _A_ 1 _U_ 1 _N_ _S_ "U(U(PPP)U(PPP))" {_A_ 4 _U_ 2221 _N_ _N_ _N_ _N_} _N_ _N_ } #-}
instance Enum ()
{-# GHC_PRAGMA _M_ PreludeBuiltin {-dfun-} _A_ 0 _N_ _N_ _N_ _F_ _IF_ARGS_ 0 0 X 6 _!_ _TUP_5 [{{Ord ()}}, (() -> [()]), (() -> () -> [()]), (() -> () -> [()]), (() -> () -> () -> [()])] [_DFUN_ Ord (()), _CONSTM_ Enum enumFrom (()), _CONSTM_ Enum enumFromThen (()), _CONSTM_ Enum enumFromTo (()), _CONSTM_ Enum enumFromThenTo (())] _N_
- enumFrom = _A_ 1 _U_ 2 _N_ _S_ "E" _N_ _N_,
- enumFromThen = _A_ 2 _U_ 21 _N_ _S_ "EE" _F_ _IF_ARGS_ 0 2 CC 7 \ (u0 :: ()) (u1 :: ()) -> case u0 of { _ALG_ _TUP_0 -> case u1 of { _ALG_ _TUP_0 -> let {(u2 :: [()]) = _!_ _NIL_ [()] []} in _!_ (:) [()] [u0, u2]; _NO_DEFLT_ }; _NO_DEFLT_ } _N_,
- enumFromTo = _A_ 2 _U_ 21 _N_ _S_ "EE" _F_ _IF_ARGS_ 0 2 CC 7 \ (u0 :: ()) (u1 :: ()) -> case u0 of { _ALG_ _TUP_0 -> case u1 of { _ALG_ _TUP_0 -> let {(u2 :: [()]) = _!_ _NIL_ [()] []} in _!_ (:) [()] [u0, u2]; _NO_DEFLT_ }; _NO_DEFLT_ } _N_,
- enumFromThenTo = _A_ 3 _U_ 211 _N_ _S_ "EEE" _F_ _IF_ARGS_ 0 3 CCC 8 \ (u0 :: ()) (u1 :: ()) (u2 :: ()) -> case u0 of { _ALG_ _TUP_0 -> case u1 of { _ALG_ _TUP_0 -> case u2 of { _ALG_ _TUP_0 -> let {(u3 :: [()]) = _!_ _NIL_ [()] []} in _!_ (:) [()] [u0, u3]; _NO_DEFLT_ }; _NO_DEFLT_ }; _NO_DEFLT_ } _N_ #-}
+ enumFrom = { _A_ 1 _U_ 2 _N_ _S_ "E" _N_ _N_ },
+ enumFromThen = { _A_ 2 _U_ 21 _N_ _S_ "EE" _F_ _IF_ARGS_ 0 2 CC 7 \ (u0 :: ()) (u1 :: ()) -> case u0 of { _ALG_ _TUP_0 -> case u1 of { _ALG_ _TUP_0 -> let {(u2 :: [()]) = _!_ _NIL_ [()] []} in _!_ (:) [()] [u0, u2]; _NO_DEFLT_ }; _NO_DEFLT_ } _N_ },
+ enumFromTo = { _A_ 2 _U_ 21 _N_ _S_ "EE" _F_ _IF_ARGS_ 0 2 CC 7 \ (u0 :: ()) (u1 :: ()) -> case u0 of { _ALG_ _TUP_0 -> case u1 of { _ALG_ _TUP_0 -> let {(u2 :: [()]) = _!_ _NIL_ [()] []} in _!_ (:) [()] [u0, u2]; _NO_DEFLT_ }; _NO_DEFLT_ } _N_ },
+ enumFromThenTo = { _A_ 3 _U_ 211 _N_ _S_ "EEE" _F_ _IF_ARGS_ 0 3 CCC 8 \ (u0 :: ()) (u1 :: ()) (u2 :: ()) -> case u0 of { _ALG_ _TUP_0 -> case u1 of { _ALG_ _TUP_0 -> case u2 of { _ALG_ _TUP_0 -> let {(u3 :: [()]) = _!_ _NIL_ [()] []} in _!_ (:) [()] [u0, u3]; _NO_DEFLT_ }; _NO_DEFLT_ }; _NO_DEFLT_ } _N_ } #-}
instance Enum Bool
{-# GHC_PRAGMA _M_ PreludeCore {-dfun-} _A_ 0 _N_ _N_ _N_ _F_ _IF_ARGS_ 0 0 X 6 _!_ _TUP_5 [{{Ord Bool}}, (Bool -> [Bool]), (Bool -> Bool -> [Bool]), (Bool -> Bool -> [Bool]), (Bool -> Bool -> Bool -> [Bool])] [_DFUN_ Ord (Bool), _CONSTM_ Enum enumFrom (Bool), _CONSTM_ Enum enumFromThen (Bool), _CONSTM_ Enum enumFromTo (Bool), _CONSTM_ Enum enumFromThenTo (Bool)] _N_
- enumFrom = _A_ 1 _U_ 2 _N_ _S_ "E" _N_ _N_,
- enumFromThen = _A_ 2 _U_ 22 _N_ _S_ "EE" _N_ _N_,
- enumFromTo = _A_ 2 _U_ 22 _N_ _N_ _N_ _N_,
- enumFromThenTo = _A_ 3 _U_ 222 _N_ _N_ _N_ _N_ #-}
+ enumFrom = { _A_ 1 _U_ 2 _N_ _S_ "E" _N_ _N_ },
+ enumFromThen = { _A_ 2 _U_ 22 _N_ _S_ "EE" _N_ _N_ },
+ enumFromTo = { _A_ 2 _U_ 22 _N_ _S_ "EL" _N_ _N_ },
+ enumFromThenTo = { _A_ 3 _U_ 222 _N_ _S_ "EEL" _N_ _N_ } #-}
instance Enum Char
{-# GHC_PRAGMA _M_ PreludeCore {-dfun-} _A_ 0 _N_ _N_ _N_ _F_ _IF_ARGS_ 0 0 X 6 _!_ _TUP_5 [{{Ord Char}}, (Char -> [Char]), (Char -> Char -> [Char]), (Char -> Char -> [Char]), (Char -> Char -> Char -> [Char])] [_DFUN_ Ord (Char), _CONSTM_ Enum enumFrom (Char), _CONSTM_ Enum enumFromThen (Char), _CONSTM_ Enum enumFromTo (Char), _CONSTM_ Enum enumFromThenTo (Char)] _N_
- enumFrom = _A_ 1 _U_ 1 _N_ _S_ "U(P)" {_A_ 1 _U_ 2 _N_ _N_ _N_ _N_} _N_ _N_,
- enumFromThen = _A_ 2 _U_ 22 _N_ _N_ _N_ _N_,
- enumFromTo = _A_ 2 _U_ 22 _N_ _N_ _N_ _N_,
- enumFromThenTo = _A_ 3 _U_ 222 _N_ _N_ _N_ _N_ #-}
+ enumFrom = { _A_ 1 _U_ 1 _N_ _S_ "U(P)" {_A_ 1 _U_ 2 _N_ _N_ _N_ _N_} _N_ _N_ },
+ enumFromThen = { _A_ 2 _U_ 22 _N_ _N_ _N_ _N_ },
+ enumFromTo = { _A_ 2 _U_ 12 _N_ _S_ "U(P)L" {_A_ 2 _U_ 22 _N_ _N_ _N_ _N_} _N_ _N_ },
+ enumFromThenTo = { _A_ 3 _U_ 222 _N_ _N_ _N_ _N_ } #-}
instance Enum Double
{-# GHC_PRAGMA _M_ PreludeCore {-dfun-} _A_ 0 _N_ _N_ _N_ _F_ _IF_ARGS_ 0 0 X 6 _!_ _TUP_5 [{{Ord Double}}, (Double -> [Double]), (Double -> Double -> [Double]), (Double -> Double -> [Double]), (Double -> Double -> Double -> [Double])] [_DFUN_ Ord (Double), _CONSTM_ Enum enumFrom (Double), _CONSTM_ Enum enumFromThen (Double), _CONSTM_ Enum enumFromTo (Double), _CONSTM_ Enum enumFromThenTo (Double)] _N_
- enumFrom = _A_ 1 _U_ 2 _N_ _N_ _N_ _N_,
- enumFromThen = _A_ 2 _U_ 21 _N_ _N_ _N_ _N_,
- enumFromTo = _A_ 2 _U_ 22 _N_ _N_ _N_ _N_,
- enumFromThenTo = _A_ 3 _U_ 222 _N_ _N_ _N_ _N_ #-}
+ enumFrom = { _A_ 1 _U_ 2 _N_ _N_ _N_ _N_ },
+ enumFromThen = { _A_ 2 _U_ 21 _N_ _N_ _N_ _N_ },
+ enumFromTo = { _A_ 2 _U_ 22 _N_ _N_ _N_ _N_ },
+ enumFromThenTo = { _A_ 3 _U_ 222 _N_ _N_ _N_ _N_ } #-}
instance Enum Float
{-# GHC_PRAGMA _M_ PreludeCore {-dfun-} _A_ 0 _N_ _N_ _N_ _F_ _IF_ARGS_ 0 0 X 6 _!_ _TUP_5 [{{Ord Float}}, (Float -> [Float]), (Float -> Float -> [Float]), (Float -> Float -> [Float]), (Float -> Float -> Float -> [Float])] [_DFUN_ Ord (Float), _CONSTM_ Enum enumFrom (Float), _CONSTM_ Enum enumFromThen (Float), _CONSTM_ Enum enumFromTo (Float), _CONSTM_ Enum enumFromThenTo (Float)] _N_
- enumFrom = _A_ 1 _U_ 2 _N_ _N_ _N_ _N_,
- enumFromThen = _A_ 2 _U_ 21 _N_ _N_ _N_ _N_,
- enumFromTo = _A_ 2 _U_ 22 _N_ _N_ _N_ _N_,
- enumFromThenTo = _A_ 3 _U_ 222 _N_ _N_ _N_ _N_ #-}
+ enumFrom = { _A_ 1 _U_ 2 _N_ _N_ _N_ _N_ },
+ enumFromThen = { _A_ 2 _U_ 21 _N_ _N_ _N_ _N_ },
+ enumFromTo = { _A_ 2 _U_ 22 _N_ _N_ _N_ _N_ },
+ enumFromThenTo = { _A_ 3 _U_ 222 _N_ _N_ _N_ _N_ } #-}
instance Enum Int
{-# GHC_PRAGMA _M_ PreludeCore {-dfun-} _A_ 0 _N_ _N_ _N_ _F_ _IF_ARGS_ 0 0 X 6 _!_ _TUP_5 [{{Ord Int}}, (Int -> [Int]), (Int -> Int -> [Int]), (Int -> Int -> [Int]), (Int -> Int -> Int -> [Int])] [_DFUN_ Ord (Int), _CONSTM_ Enum enumFrom (Int), _CONSTM_ Enum enumFromThen (Int), _CONSTM_ Enum enumFromTo (Int), _CONSTM_ Enum enumFromThenTo (Int)] _N_
- enumFrom = _A_ 1 _U_ 2 _N_ _N_ _F_ _ALWAYS_ \ (u0 :: Int) -> _LETREC_ {(u1 :: Int -> [Int]) = \ (u2 :: Int) -> let {(u6 :: [Int]) = let {(u5 :: Int) = case u2 of { _ALG_ I# (u3 :: Int#) -> case _#_ plusInt# [] [u3, 1#] of { _PRIM_ (u4 :: Int#) -> _!_ I# [] [u4] }; _NO_DEFLT_ }} in _APP_ u1 [ u5 ]} in _!_ (:) [Int] [u2, u6]} in _APP_ u1 [ u0 ] _N_,
- enumFromThen = _A_ 2 _U_ 21 _N_ _N_ _N_ _N_,
- enumFromTo = _A_ 2 _U_ 12 _N_ _S_ "SS" _F_ _ALWAYS_ \ (u0 :: Int) (u1 :: Int) -> case u0 of { _ALG_ I# (u2 :: Int#) -> _LETREC_ {(u3 :: Int# -> [Int]) = \ (u4 :: Int#) -> case u1 of { _ALG_ I# (u5 :: Int#) -> case _#_ leInt# [] [u4, u5] of { _ALG_ True -> let {(u7 :: [Int]) = case _#_ plusInt# [] [u4, 1#] of { _PRIM_ (u6 :: Int#) -> _APP_ u3 [ u6 ] }} in let {(u8 :: Int) = _!_ I# [] [u4]} in _!_ (:) [Int] [u8, u7]; False -> _!_ _NIL_ [Int] []; _NO_DEFLT_ }; _NO_DEFLT_ }} in _APP_ u3 [ u2 ]; _NO_DEFLT_ } _N_,
- enumFromThenTo = _A_ 3 _U_ 222 _N_ _N_ _N_ _N_ #-}
+ enumFrom = { _A_ 1 _U_ 2 _N_ _N_ _F_ _ALWAYS_ \ (u0 :: Int) -> _LETREC_ {(u1 :: Int -> [Int]) = \ (u2 :: Int) -> let {(u6 :: [Int]) = let {(u5 :: Int) = case u2 of { _ALG_ I# (u3 :: Int#) -> case _#_ plusInt# [] [u3, 1#] of { _PRIM_ (u4 :: Int#) -> _!_ I# [] [u4] }; _NO_DEFLT_ }} in _APP_ u1 [ u5 ]} in _!_ (:) [Int] [u2, u6]} in _APP_ u1 [ u0 ] _N_ },
+ enumFromThen = { _A_ 2 _U_ 21 _N_ _N_ _N_ _N_ },
+ enumFromTo = { _A_ 2 _U_ 12 _N_ _S_ "SS" _F_ _ALWAYS_ \ (u0 :: Int) (u1 :: Int) -> case u0 of { _ALG_ I# (u2 :: Int#) -> _LETREC_ {(u3 :: Int# -> [Int]) = \ (u4 :: Int#) -> case u1 of { _ALG_ I# (u5 :: Int#) -> case _#_ leInt# [] [u4, u5] of { _ALG_ True -> let {(u7 :: [Int]) = case _#_ plusInt# [] [u4, 1#] of { _PRIM_ (u6 :: Int#) -> _APP_ u3 [ u6 ] }} in let {(u8 :: Int) = _!_ I# [] [u4]} in _!_ (:) [Int] [u8, u7]; False -> _!_ _NIL_ [Int] []; _NO_DEFLT_ }; _NO_DEFLT_ }} in _APP_ u3 [ u2 ]; _NO_DEFLT_ } _N_ },
+ enumFromThenTo = { _A_ 3 _U_ 222 _N_ _N_ _N_ _N_ } #-}
instance Enum Integer
{-# GHC_PRAGMA _M_ PreludeCore {-dfun-} _A_ 0 _N_ _N_ _N_ _F_ _IF_ARGS_ 0 0 X 6 _!_ _TUP_5 [{{Ord Integer}}, (Integer -> [Integer]), (Integer -> Integer -> [Integer]), (Integer -> Integer -> [Integer]), (Integer -> Integer -> Integer -> [Integer])] [_DFUN_ Ord (Integer), _CONSTM_ Enum enumFrom (Integer), _CONSTM_ Enum enumFromThen (Integer), _CONSTM_ Enum enumFromTo (Integer), _CONSTM_ Enum enumFromThenTo (Integer)] _N_
- enumFrom = _A_ 1 _U_ 2 _N_ _N_ _N_ _N_,
- enumFromThen = _A_ 2 _U_ 21 _N_ _N_ _N_ _N_,
- enumFromTo = _A_ 2 _U_ 22 _N_ _N_ _N_ _N_,
- enumFromThenTo = _A_ 3 _U_ 222 _N_ _N_ _N_ _N_ #-}
+ enumFrom = { _A_ 1 _U_ 2 _N_ _N_ _N_ _N_ },
+ enumFromThen = { _A_ 2 _U_ 21 _N_ _N_ _N_ _N_ },
+ enumFromTo = { _A_ 2 _U_ 22 _N_ _N_ _N_ _N_ },
+ enumFromThenTo = { _A_ 3 _U_ 222 _N_ _N_ _N_ _N_ } #-}
instance Integral a => Enum (Ratio a)
{-# GHC_PRAGMA _M_ PreludeRatio {-dfun-} _A_ 2 _U_ 22 _N_ _N_ _N_ _N_ #-}
instance Enum (Ratio Integer)
{-# GHC_PRAGMA _M_ PreludeRatio {-dfun-} _A_ 0 _N_ _N_ _N_ _F_ _IF_ARGS_ 0 0 X 6 _!_ _TUP_5 [{{Ord (Ratio Integer)}}, (Ratio Integer -> [Ratio Integer]), (Ratio Integer -> Ratio Integer -> [Ratio Integer]), (Ratio Integer -> Ratio Integer -> [Ratio Integer]), (Ratio Integer -> Ratio Integer -> Ratio Integer -> [Ratio Integer])] [_DFUN_ Ord (Ratio Integer), _CONSTM_ Enum enumFrom (Ratio Integer), _CONSTM_ Enum enumFromThen (Ratio Integer), _CONSTM_ Enum enumFromTo (Ratio Integer), _CONSTM_ Enum enumFromThenTo (Ratio Integer)] _N_
- enumFrom = _A_ 1 _U_ 2 _N_ _N_ _N_ _N_,
- enumFromThen = _A_ 2 _U_ 21 _N_ _N_ _N_ _N_,
- enumFromTo = _A_ 2 _U_ 22 _N_ _N_ _N_ _N_,
- enumFromThenTo = _A_ 3 _U_ 222 _N_ _N_ _N_ _N_ #-}
+ enumFrom = { _A_ 1 _U_ 2 _N_ _N_ _N_ _N_ },
+ enumFromThen = { _A_ 2 _U_ 21 _N_ _N_ _N_ _N_ },
+ enumFromTo = { _A_ 2 _U_ 22 _N_ _N_ _N_ _N_ },
+ enumFromThenTo = { _A_ 3 _U_ 222 _N_ _N_ _N_ _N_ } #-}
instance Eq ()
{-# GHC_PRAGMA _M_ PreludeBuiltin {-dfun-} _A_ 0 _N_ _N_ _N_ _F_ _IF_ARGS_ 0 0 X 3 _!_ _TUP_2 [(() -> () -> Bool), (() -> () -> Bool)] [_CONSTM_ Eq (==) (()), _CONSTM_ Eq (/=) (())] _N_
- (==) = _A_ 2 _U_ 11 _N_ _S_ "EE" _F_ _IF_ARGS_ 0 2 CC 3 \ (u0 :: ()) (u1 :: ()) -> case u0 of { _ALG_ _TUP_0 -> case u1 of { _ALG_ _TUP_0 -> _!_ True [] []; _NO_DEFLT_ }; _NO_DEFLT_ } _N_,
- (/=) = _A_ 2 _U_ 11 _N_ _S_ "EE" _F_ _IF_ARGS_ 0 2 CC 3 \ (u0 :: ()) (u1 :: ()) -> case u0 of { _ALG_ _TUP_0 -> case u1 of { _ALG_ _TUP_0 -> _!_ False [] []; _NO_DEFLT_ }; _NO_DEFLT_ } _N_ #-}
+ (==) = { _A_ 2 _U_ 11 _N_ _S_ "EE" _F_ _IF_ARGS_ 0 2 CC 3 \ (u0 :: ()) (u1 :: ()) -> case u0 of { _ALG_ _TUP_0 -> case u1 of { _ALG_ _TUP_0 -> _!_ True [] []; _NO_DEFLT_ }; _NO_DEFLT_ } _N_ },
+ (/=) = { _A_ 2 _U_ 11 _N_ _S_ "EE" _F_ _IF_ARGS_ 0 2 CC 3 \ (u0 :: ()) (u1 :: ()) -> case u0 of { _ALG_ _TUP_0 -> case u1 of { _ALG_ _TUP_0 -> _!_ False [] []; _NO_DEFLT_ }; _NO_DEFLT_ } _N_ } #-}
instance (Eq a, Eq b) => Eq (a, b)
- {-# GHC_PRAGMA _M_ PreludeBuiltin {-dfun-} _A_ 2 _U_ 11 _N_ _N_ _N_ _N_ #-}
+ {-# GHC_PRAGMA _M_ PreludeBuiltin {-dfun-} _A_ 2 _U_ 22 _N_ _N_ _N_ _N_ #-}
instance (Eq a, Eq b, Eq c) => Eq (a, b, c)
{-# GHC_PRAGMA _M_ PreludeBuiltin {-dfun-} _A_ 3 _U_ 111 _N_ _N_ _N_ _N_ #-}
instance (Eq a, Eq b, Eq c, Eq d) => Eq (a, b, c, d)
{-# GHC_PRAGMA _M_ PreludeBuiltin {-dfun-} _A_ 5 _U_ 11111 _N_ _N_ _N_ _N_ #-}
instance Eq (Int, Int)
{-# GHC_PRAGMA _M_ PreludeBuiltin {-dfun-} _A_ 0 _N_ _N_ _N_ _F_ _IF_ARGS_ 0 0 X 3 _!_ _TUP_2 [((Int, Int) -> (Int, Int) -> Bool), ((Int, Int) -> (Int, Int) -> Bool)] [_CONSTM_ Eq (==) ((Int, Int)), _CONSTM_ Eq (/=) ((Int, Int))] _N_
- (==) = _A_ 2 _U_ 11 _N_ _S_ "U(U(P)L)U(U(P)L)" {_A_ 4 _U_ 2121 _N_ _N_ _F_ _IF_ARGS_ 0 4 XCXC 7 \ (u0 :: Int#) (u1 :: Int) (u2 :: Int#) (u3 :: Int) -> case _#_ eqInt# [] [u0, u2] of { _ALG_ True -> case u1 of { _ALG_ I# (u4 :: Int#) -> case u3 of { _ALG_ I# (u5 :: Int#) -> _#_ eqInt# [] [u4, u5]; _NO_DEFLT_ }; _NO_DEFLT_ }; False -> _!_ False [] []; _NO_DEFLT_ } _N_} _F_ _ALWAYS_ \ (u0 :: (Int, Int)) (u1 :: (Int, Int)) -> case u0 of { _ALG_ _TUP_2 (u2 :: Int) (u3 :: Int) -> case u2 of { _ALG_ I# (u4 :: Int#) -> case u1 of { _ALG_ _TUP_2 (u5 :: Int) (u6 :: Int) -> case u5 of { _ALG_ I# (u7 :: Int#) -> case _#_ eqInt# [] [u4, u7] of { _ALG_ True -> case u3 of { _ALG_ I# (u8 :: Int#) -> case u6 of { _ALG_ I# (u9 :: Int#) -> _#_ eqInt# [] [u8, u9]; _NO_DEFLT_ }; _NO_DEFLT_ }; False -> _!_ False [] []; _NO_DEFLT_ }; _NO_DEFLT_ }; _NO_DEFLT_ }; _NO_DEFLT_ }; _NO_DEFLT_ } _N_,
- (/=) = _A_ 2 _U_ 22 _N_ _N_ _N_ _N_ #-}
+ (==) = { _A_ 2 _U_ 11 _N_ _S_ "U(U(P)L)U(U(P)L)" {_A_ 4 _U_ 2121 _N_ _N_ _F_ _IF_ARGS_ 0 4 XCXC 7 \ (u0 :: Int#) (u1 :: Int) (u2 :: Int#) (u3 :: Int) -> case _#_ eqInt# [] [u0, u2] of { _ALG_ True -> case u1 of { _ALG_ I# (u4 :: Int#) -> case u3 of { _ALG_ I# (u5 :: Int#) -> _#_ eqInt# [] [u4, u5]; _NO_DEFLT_ }; _NO_DEFLT_ }; False -> _!_ False [] []; _NO_DEFLT_ } _N_} _F_ _ALWAYS_ \ (u0 :: (Int, Int)) (u1 :: (Int, Int)) -> case u0 of { _ALG_ _TUP_2 (u2 :: Int) (u3 :: Int) -> case u2 of { _ALG_ I# (u4 :: Int#) -> case u1 of { _ALG_ _TUP_2 (u5 :: Int) (u6 :: Int) -> case u5 of { _ALG_ I# (u7 :: Int#) -> case _#_ eqInt# [] [u4, u7] of { _ALG_ True -> case u3 of { _ALG_ I# (u8 :: Int#) -> case u6 of { _ALG_ I# (u9 :: Int#) -> _#_ eqInt# [] [u8, u9]; _NO_DEFLT_ }; _NO_DEFLT_ }; False -> _!_ False [] []; _NO_DEFLT_ }; _NO_DEFLT_ }; _NO_DEFLT_ }; _NO_DEFLT_ }; _NO_DEFLT_ } _N_ },
+ (/=) = { _A_ 2 _U_ 11 _N_ _S_ "U(U(P)L)U(U(P)L)" {_A_ 4 _U_ 2121 _N_ _N_ _F_ _IF_ARGS_ 0 4 XCXC 7 \ (u0 :: Int#) (u1 :: Int) (u2 :: Int#) (u3 :: Int) -> case _#_ neInt# [] [u0, u2] of { _ALG_ True -> _!_ True [] []; False -> case u1 of { _ALG_ I# (u4 :: Int#) -> case u3 of { _ALG_ I# (u5 :: Int#) -> _#_ neInt# [] [u4, u5]; _NO_DEFLT_ }; _NO_DEFLT_ }; _NO_DEFLT_ } _N_} _F_ _ALWAYS_ \ (u0 :: (Int, Int)) (u1 :: (Int, Int)) -> case u0 of { _ALG_ _TUP_2 (u2 :: Int) (u3 :: Int) -> case u2 of { _ALG_ I# (u4 :: Int#) -> case u1 of { _ALG_ _TUP_2 (u5 :: Int) (u6 :: Int) -> case u5 of { _ALG_ I# (u7 :: Int#) -> case _#_ neInt# [] [u4, u7] of { _ALG_ True -> _!_ True [] []; False -> case u3 of { _ALG_ I# (u8 :: Int#) -> case u6 of { _ALG_ I# (u9 :: Int#) -> _#_ neInt# [] [u8, u9]; _NO_DEFLT_ }; _NO_DEFLT_ }; _NO_DEFLT_ }; _NO_DEFLT_ }; _NO_DEFLT_ }; _NO_DEFLT_ }; _NO_DEFLT_ } _N_ } #-}
+instance Eq (Int, Int, Int)
+ {-# GHC_PRAGMA _M_ PreludeBuiltin {-dfun-} _A_ 0 _N_ _N_ _N_ _F_ _IF_ARGS_ 0 0 X 3 _!_ _TUP_2 [((Int, Int, Int) -> (Int, Int, Int) -> Bool), ((Int, Int, Int) -> (Int, Int, Int) -> Bool)] [_CONSTM_ Eq (==) ((Int, Int, Int)), _CONSTM_ Eq (/=) ((Int, Int, Int))] _N_
+ (==) = { _A_ 2 _U_ 11 _N_ _S_ "U(U(P)LL)U(U(P)LL)" {_A_ 4 _U_ 2111 _N_ _N_ _N_ _N_} _N_ _N_ },
+ (/=) = { _A_ 2 _U_ 11 _N_ _S_ "U(U(P)LL)U(U(P)LL)" {_A_ 4 _U_ 2111 _N_ _N_ _N_ _N_} _N_ _N_ } #-}
+instance Eq (Int, Int, Int, Int)
+ {-# GHC_PRAGMA _M_ PreludeBuiltin {-dfun-} _A_ 0 _N_ _N_ _N_ _F_ _IF_ARGS_ 0 0 X 3 _!_ _TUP_2 [((Int, Int, Int, Int) -> (Int, Int, Int, Int) -> Bool), ((Int, Int, Int, Int) -> (Int, Int, Int, Int) -> Bool)] [_CONSTM_ Eq (==) ((Int, Int, Int, Int)), _CONSTM_ Eq (/=) ((Int, Int, Int, Int))] _N_
+ (==) = { _A_ 2 _U_ 11 _N_ _S_ "U(U(P)LLL)U(U(P)LLL)" {_A_ 5 _U_ 21111 _N_ _N_ _N_ _N_} _N_ _N_ },
+ (/=) = { _A_ 2 _U_ 11 _N_ _S_ "U(U(P)LLL)U(U(P)LLL)" {_A_ 5 _U_ 21111 _N_ _N_ _N_ _N_} _N_ _N_ } #-}
+instance Eq (Int, Int, Int, Int, Int)
+ {-# GHC_PRAGMA _M_ PreludeBuiltin {-dfun-} _A_ 0 _N_ _N_ _N_ _F_ _IF_ARGS_ 0 0 X 3 _!_ _TUP_2 [((Int, Int, Int, Int, Int) -> (Int, Int, Int, Int, Int) -> Bool), ((Int, Int, Int, Int, Int) -> (Int, Int, Int, Int, Int) -> Bool)] [_CONSTM_ Eq (==) ((Int, Int, Int, Int, Int)), _CONSTM_ Eq (/=) ((Int, Int, Int, Int, Int))] _N_
+ (==) = { _A_ 2 _U_ 11 _N_ _S_ "U(U(P)LLLL)U(U(P)LLLL)" _N_ _N_ },
+ (/=) = { _A_ 2 _U_ 11 _N_ _S_ "U(U(P)LLLL)U(U(P)LLLL)" _N_ _N_ } #-}
+instance Eq ([Char], [Char])
+ {-# GHC_PRAGMA _M_ PreludeBuiltin {-dfun-} _A_ 0 _N_ _N_ _N_ _F_ _IF_ARGS_ 0 0 X 3 _!_ _TUP_2 [(([Char], [Char]) -> ([Char], [Char]) -> Bool), (([Char], [Char]) -> ([Char], [Char]) -> Bool)] [_CONSTM_ Eq (==) (([Char], [Char])), _CONSTM_ Eq (/=) (([Char], [Char]))] _N_
+ (==) = { _A_ 2 _U_ 11 _N_ _S_ "U(SL)U(SL)" {_A_ 4 _U_ 2222 _N_ _N_ _N_ _N_} _N_ _N_ },
+ (/=) = { _A_ 2 _U_ 11 _N_ _S_ "U(SL)U(SL)" {_A_ 4 _U_ 2222 _N_ _N_ _N_ _N_} _N_ _N_ } #-}
+instance Eq ([Int], [Int])
+ {-# GHC_PRAGMA _M_ PreludeBuiltin {-dfun-} _A_ 0 _N_ _N_ _N_ _F_ _IF_ARGS_ 0 0 X 3 _!_ _TUP_2 [(([Int], [Int]) -> ([Int], [Int]) -> Bool), (([Int], [Int]) -> ([Int], [Int]) -> Bool)] [_CONSTM_ Eq (==) (([Int], [Int])), _CONSTM_ Eq (/=) (([Int], [Int]))] _N_
+ (==) = { _A_ 2 _U_ 11 _N_ _S_ "U(SL)U(SL)" {_A_ 4 _U_ 2222 _N_ _N_ _N_ _N_} _N_ _N_ },
+ (/=) = { _A_ 2 _U_ 11 _N_ _S_ "U(SL)U(SL)" {_A_ 4 _U_ 2222 _N_ _N_ _N_ _N_} _N_ _N_ } #-}
instance Eq (_PackedString, _PackedString)
{-# GHC_PRAGMA _M_ PreludeBuiltin {-dfun-} _A_ 0 _N_ _N_ _N_ _F_ _IF_ARGS_ 0 0 X 3 _!_ _TUP_2 [((_PackedString, _PackedString) -> (_PackedString, _PackedString) -> Bool), ((_PackedString, _PackedString) -> (_PackedString, _PackedString) -> Bool)] [_CONSTM_ Eq (==) ((_PackedString, _PackedString)), _CONSTM_ Eq (/=) ((_PackedString, _PackedString))] _N_
- (==) = _A_ 2 _U_ 11 _N_ _S_ "U(SL)U(SL)" {_A_ 4 _U_ 2222 _N_ _N_ _N_ _N_} _N_ _N_,
- (/=) = _A_ 2 _U_ 22 _N_ _N_ _N_ _N_ #-}
+ (==) = { _A_ 2 _U_ 11 _N_ _S_ "U(SL)U(SL)" {_A_ 4 _U_ 2222 _N_ _N_ _N_ _N_} _N_ _N_ },
+ (/=) = { _A_ 2 _U_ 11 _N_ _S_ "U(SL)U(SL)" {_A_ 4 _U_ 2222 _N_ _N_ _N_ _N_} _N_ _N_ } #-}
instance (Ix a, Eq b) => Eq (Array a b)
{-# GHC_PRAGMA _M_ PreludeArray {-dfun-} _A_ 2 _U_ 21 _N_ _N_ _N_ _N_ #-}
instance (Eq a, Eq b) => Eq (Assoc a b)
{-# GHC_PRAGMA _M_ PreludeArray {-dfun-} _A_ 2 _U_ 11 _N_ _N_ _N_ _N_ #-}
instance Eq Bool
{-# GHC_PRAGMA _M_ PreludeCore {-dfun-} _A_ 0 _N_ _N_ _N_ _F_ _IF_ARGS_ 0 0 X 3 _!_ _TUP_2 [(Bool -> Bool -> Bool), (Bool -> Bool -> Bool)] [_CONSTM_ Eq (==) (Bool), _CONSTM_ Eq (/=) (Bool)] _N_
- (==) = _A_ 2 _U_ 11 _N_ _S_ "EE" _F_ _IF_ARGS_ 0 2 CC 7 \ (u0 :: Bool) (u1 :: Bool) -> case u0 of { _ALG_ True -> u1; False -> case u1 of { _ALG_ True -> _!_ False [] []; False -> _!_ True [] []; _NO_DEFLT_ }; _NO_DEFLT_ } _N_,
- (/=) = _A_ 2 _U_ 11 _N_ _S_ "EE" _F_ _IF_ARGS_ 0 2 CC 7 \ (u0 :: Bool) (u1 :: Bool) -> case u0 of { _ALG_ True -> case u1 of { _ALG_ True -> _!_ False [] []; False -> _!_ True [] []; _NO_DEFLT_ }; False -> u1; _NO_DEFLT_ } _N_ #-}
+ (==) = { _A_ 2 _U_ 11 _N_ _S_ "EE" _F_ _IF_ARGS_ 0 2 CC 7 \ (u0 :: Bool) (u1 :: Bool) -> case u0 of { _ALG_ True -> u1; False -> case u1 of { _ALG_ True -> _!_ False [] []; False -> _!_ True [] []; _NO_DEFLT_ }; _NO_DEFLT_ } _N_ },
+ (/=) = { _A_ 2 _U_ 11 _N_ _S_ "EE" _F_ _IF_ARGS_ 0 2 CC 7 \ (u0 :: Bool) (u1 :: Bool) -> case u0 of { _ALG_ True -> case u1 of { _ALG_ True -> _!_ False [] []; False -> _!_ True [] []; _NO_DEFLT_ }; False -> u1; _NO_DEFLT_ } _N_ } #-}
instance Eq Char
{-# GHC_PRAGMA _M_ PreludeCore {-dfun-} _A_ 0 _N_ _N_ _N_ _F_ _IF_ARGS_ 0 0 X 3 _!_ _TUP_2 [(Char -> Char -> Bool), (Char -> Char -> Bool)] [_CONSTM_ Eq (==) (Char), _CONSTM_ Eq (/=) (Char)] _N_
- (==) = _A_ 2 _U_ 11 _N_ _S_ "U(P)U(P)" {_A_ 2 _U_ 22 _N_ _N_ _F_ _IF_ARGS_ 0 2 XX 1 \ (u0 :: Char#) (u1 :: Char#) -> _#_ eqChar# [] [u0, u1] _N_} _F_ _IF_ARGS_ 0 2 CC 3 \ (u0 :: Char) (u1 :: Char) -> case u0 of { _ALG_ C# (u2 :: Char#) -> case u1 of { _ALG_ C# (u3 :: Char#) -> _#_ eqChar# [] [u2, u3]; _NO_DEFLT_ }; _NO_DEFLT_ } _N_,
- (/=) = _A_ 2 _U_ 11 _N_ _S_ "U(P)U(P)" {_A_ 2 _U_ 22 _N_ _N_ _F_ _IF_ARGS_ 0 2 XX 1 \ (u0 :: Char#) (u1 :: Char#) -> _#_ neChar# [] [u0, u1] _N_} _F_ _IF_ARGS_ 0 2 CC 3 \ (u0 :: Char) (u1 :: Char) -> case u0 of { _ALG_ C# (u2 :: Char#) -> case u1 of { _ALG_ C# (u3 :: Char#) -> _#_ neChar# [] [u2, u3]; _NO_DEFLT_ }; _NO_DEFLT_ } _N_ #-}
+ (==) = { _A_ 2 _U_ 11 _N_ _S_ "U(P)U(P)" {_A_ 2 _U_ 22 _N_ _N_ _F_ _IF_ARGS_ 0 2 XX 1 \ (u0 :: Char#) (u1 :: Char#) -> _#_ eqChar# [] [u0, u1] _N_} _F_ _IF_ARGS_ 0 2 CC 3 \ (u0 :: Char) (u1 :: Char) -> case u0 of { _ALG_ C# (u2 :: Char#) -> case u1 of { _ALG_ C# (u3 :: Char#) -> _#_ eqChar# [] [u2, u3]; _NO_DEFLT_ }; _NO_DEFLT_ } _N_ },
+ (/=) = { _A_ 2 _U_ 11 _N_ _S_ "U(P)U(P)" {_A_ 2 _U_ 22 _N_ _N_ _F_ _IF_ARGS_ 0 2 XX 1 \ (u0 :: Char#) (u1 :: Char#) -> _#_ neChar# [] [u0, u1] _N_} _F_ _IF_ARGS_ 0 2 CC 3 \ (u0 :: Char) (u1 :: Char) -> case u0 of { _ALG_ C# (u2 :: Char#) -> case u1 of { _ALG_ C# (u3 :: Char#) -> _#_ neChar# [] [u2, u3]; _NO_DEFLT_ }; _NO_DEFLT_ } _N_ } #-}
instance Eq a => Eq (Complex a)
{-# GHC_PRAGMA _M_ PreludeComplex {-dfun-} _A_ 1 _U_ 2 _N_ _N_ _N_ _N_ #-}
instance Eq (Complex Double)
{-# GHC_PRAGMA _M_ PreludeComplex {-dfun-} _A_ 0 _N_ _N_ _N_ _F_ _IF_ARGS_ 0 0 X 3 _!_ _TUP_2 [(Complex Double -> Complex Double -> Bool), (Complex Double -> Complex Double -> Bool)] [_CONSTM_ Eq (==) (Complex Double), _CONSTM_ Eq (/=) (Complex Double)] _N_
- (==) = _A_ 2 _U_ 11 _N_ _S_ "U(U(P)L)U(U(P)L)" {_A_ 4 _U_ 2121 _N_ _N_ _F_ _IF_ARGS_ 0 4 XCXC 7 \ (u0 :: Double#) (u1 :: Double) (u2 :: Double#) (u3 :: Double) -> case _#_ eqDouble# [] [u0, u2] of { _ALG_ True -> case u1 of { _ALG_ D# (u4 :: Double#) -> case u3 of { _ALG_ D# (u5 :: Double#) -> _#_ eqDouble# [] [u4, u5]; _NO_DEFLT_ }; _NO_DEFLT_ }; False -> _!_ False [] []; _NO_DEFLT_ } _N_} _F_ _ALWAYS_ \ (u0 :: Complex Double) (u1 :: Complex Double) -> case u0 of { _ALG_ (:+) (u2 :: Double) (u3 :: Double) -> case u2 of { _ALG_ D# (u4 :: Double#) -> case u1 of { _ALG_ (:+) (u5 :: Double) (u6 :: Double) -> case u5 of { _ALG_ D# (u7 :: Double#) -> case _#_ eqDouble# [] [u4, u7] of { _ALG_ True -> case u3 of { _ALG_ D# (u8 :: Double#) -> case u6 of { _ALG_ D# (u9 :: Double#) -> _#_ eqDouble# [] [u8, u9]; _NO_DEFLT_ }; _NO_DEFLT_ }; False -> _!_ False [] []; _NO_DEFLT_ }; _NO_DEFLT_ }; _NO_DEFLT_ }; _NO_DEFLT_ }; _NO_DEFLT_ } _N_,
- (/=) = _A_ 2 _U_ 11 _N_ _S_ "U(U(P)L)U(U(P)L)" {_A_ 4 _U_ 2121 _N_ _N_ _F_ _IF_ARGS_ 0 4 XCXC 7 \ (u0 :: Double#) (u1 :: Double) (u2 :: Double#) (u3 :: Double) -> case _#_ neDouble# [] [u0, u2] of { _ALG_ True -> _!_ True [] []; False -> case u1 of { _ALG_ D# (u4 :: Double#) -> case u3 of { _ALG_ D# (u5 :: Double#) -> _#_ neDouble# [] [u4, u5]; _NO_DEFLT_ }; _NO_DEFLT_ }; _NO_DEFLT_ } _N_} _F_ _ALWAYS_ \ (u0 :: Complex Double) (u1 :: Complex Double) -> case u0 of { _ALG_ (:+) (u2 :: Double) (u3 :: Double) -> case u2 of { _ALG_ D# (u4 :: Double#) -> case u1 of { _ALG_ (:+) (u5 :: Double) (u6 :: Double) -> case u5 of { _ALG_ D# (u7 :: Double#) -> case _#_ neDouble# [] [u4, u7] of { _ALG_ True -> _!_ True [] []; False -> case u3 of { _ALG_ D# (u8 :: Double#) -> case u6 of { _ALG_ D# (u9 :: Double#) -> _#_ neDouble# [] [u8, u9]; _NO_DEFLT_ }; _NO_DEFLT_ }; _NO_DEFLT_ }; _NO_DEFLT_ }; _NO_DEFLT_ }; _NO_DEFLT_ }; _NO_DEFLT_ } _N_ #-}
+ (==) = { _A_ 2 _U_ 11 _N_ _S_ "U(U(P)L)U(U(P)L)" {_A_ 4 _U_ 2121 _N_ _N_ _F_ _IF_ARGS_ 0 4 XCXC 7 \ (u0 :: Double#) (u1 :: Double) (u2 :: Double#) (u3 :: Double) -> case _#_ eqDouble# [] [u0, u2] of { _ALG_ True -> case u1 of { _ALG_ D# (u4 :: Double#) -> case u3 of { _ALG_ D# (u5 :: Double#) -> _#_ eqDouble# [] [u4, u5]; _NO_DEFLT_ }; _NO_DEFLT_ }; False -> _!_ False [] []; _NO_DEFLT_ } _N_} _F_ _ALWAYS_ \ (u0 :: Complex Double) (u1 :: Complex Double) -> case u0 of { _ALG_ (:+) (u2 :: Double) (u3 :: Double) -> case u2 of { _ALG_ D# (u4 :: Double#) -> case u1 of { _ALG_ (:+) (u5 :: Double) (u6 :: Double) -> case u5 of { _ALG_ D# (u7 :: Double#) -> case _#_ eqDouble# [] [u4, u7] of { _ALG_ True -> case u3 of { _ALG_ D# (u8 :: Double#) -> case u6 of { _ALG_ D# (u9 :: Double#) -> _#_ eqDouble# [] [u8, u9]; _NO_DEFLT_ }; _NO_DEFLT_ }; False -> _!_ False [] []; _NO_DEFLT_ }; _NO_DEFLT_ }; _NO_DEFLT_ }; _NO_DEFLT_ }; _NO_DEFLT_ } _N_ },
+ (/=) = { _A_ 2 _U_ 11 _N_ _S_ "U(U(P)L)U(U(P)L)" {_A_ 4 _U_ 2121 _N_ _N_ _F_ _IF_ARGS_ 0 4 XCXC 7 \ (u0 :: Double#) (u1 :: Double) (u2 :: Double#) (u3 :: Double) -> case _#_ neDouble# [] [u0, u2] of { _ALG_ True -> _!_ True [] []; False -> case u1 of { _ALG_ D# (u4 :: Double#) -> case u3 of { _ALG_ D# (u5 :: Double#) -> _#_ neDouble# [] [u4, u5]; _NO_DEFLT_ }; _NO_DEFLT_ }; _NO_DEFLT_ } _N_} _F_ _ALWAYS_ \ (u0 :: Complex Double) (u1 :: Complex Double) -> case u0 of { _ALG_ (:+) (u2 :: Double) (u3 :: Double) -> case u2 of { _ALG_ D# (u4 :: Double#) -> case u1 of { _ALG_ (:+) (u5 :: Double) (u6 :: Double) -> case u5 of { _ALG_ D# (u7 :: Double#) -> case _#_ neDouble# [] [u4, u7] of { _ALG_ True -> _!_ True [] []; False -> case u3 of { _ALG_ D# (u8 :: Double#) -> case u6 of { _ALG_ D# (u9 :: Double#) -> _#_ neDouble# [] [u8, u9]; _NO_DEFLT_ }; _NO_DEFLT_ }; _NO_DEFLT_ }; _NO_DEFLT_ }; _NO_DEFLT_ }; _NO_DEFLT_ }; _NO_DEFLT_ } _N_ } #-}
instance Eq Double
{-# GHC_PRAGMA _M_ PreludeCore {-dfun-} _A_ 0 _N_ _N_ _N_ _F_ _IF_ARGS_ 0 0 X 3 _!_ _TUP_2 [(Double -> Double -> Bool), (Double -> Double -> Bool)] [_CONSTM_ Eq (==) (Double), _CONSTM_ Eq (/=) (Double)] _N_
- (==) = _A_ 2 _U_ 11 _N_ _S_ "U(P)U(P)" {_A_ 2 _U_ 22 _N_ _N_ _F_ _IF_ARGS_ 0 2 XX 1 \ (u0 :: Double#) (u1 :: Double#) -> _#_ eqDouble# [] [u0, u1] _N_} _F_ _IF_ARGS_ 0 2 CC 3 \ (u0 :: Double) (u1 :: Double) -> case u0 of { _ALG_ D# (u2 :: Double#) -> case u1 of { _ALG_ D# (u3 :: Double#) -> _#_ eqDouble# [] [u2, u3]; _NO_DEFLT_ }; _NO_DEFLT_ } _N_,
- (/=) = _A_ 2 _U_ 11 _N_ _S_ "U(P)U(P)" {_A_ 2 _U_ 22 _N_ _N_ _F_ _IF_ARGS_ 0 2 XX 1 \ (u0 :: Double#) (u1 :: Double#) -> _#_ neDouble# [] [u0, u1] _N_} _F_ _IF_ARGS_ 0 2 CC 3 \ (u0 :: Double) (u1 :: Double) -> case u0 of { _ALG_ D# (u2 :: Double#) -> case u1 of { _ALG_ D# (u3 :: Double#) -> _#_ neDouble# [] [u2, u3]; _NO_DEFLT_ }; _NO_DEFLT_ } _N_ #-}
+ (==) = { _A_ 2 _U_ 11 _N_ _S_ "U(P)U(P)" {_A_ 2 _U_ 22 _N_ _N_ _F_ _IF_ARGS_ 0 2 XX 1 \ (u0 :: Double#) (u1 :: Double#) -> _#_ eqDouble# [] [u0, u1] _N_} _F_ _IF_ARGS_ 0 2 CC 3 \ (u0 :: Double) (u1 :: Double) -> case u0 of { _ALG_ D# (u2 :: Double#) -> case u1 of { _ALG_ D# (u3 :: Double#) -> _#_ eqDouble# [] [u2, u3]; _NO_DEFLT_ }; _NO_DEFLT_ } _N_ },
+ (/=) = { _A_ 2 _U_ 11 _N_ _S_ "U(P)U(P)" {_A_ 2 _U_ 22 _N_ _N_ _F_ _IF_ARGS_ 0 2 XX 1 \ (u0 :: Double#) (u1 :: Double#) -> _#_ neDouble# [] [u0, u1] _N_} _F_ _IF_ARGS_ 0 2 CC 3 \ (u0 :: Double) (u1 :: Double) -> case u0 of { _ALG_ D# (u2 :: Double#) -> case u1 of { _ALG_ D# (u3 :: Double#) -> _#_ neDouble# [] [u2, u3]; _NO_DEFLT_ }; _NO_DEFLT_ } _N_ } #-}
instance (Eq a, Eq b) => Eq (Either a b)
{-# GHC_PRAGMA _M_ PreludeMonadicIO {-dfun-} _A_ 2 _U_ 11 _N_ _N_ _N_ _N_ #-}
instance Eq Float
{-# GHC_PRAGMA _M_ PreludeCore {-dfun-} _A_ 0 _N_ _N_ _N_ _F_ _IF_ARGS_ 0 0 X 3 _!_ _TUP_2 [(Float -> Float -> Bool), (Float -> Float -> Bool)] [_CONSTM_ Eq (==) (Float), _CONSTM_ Eq (/=) (Float)] _N_
- (==) = _A_ 2 _U_ 11 _N_ _S_ "U(P)U(P)" {_A_ 2 _U_ 22 _N_ _N_ _F_ _IF_ARGS_ 0 2 XX 1 \ (u0 :: Float#) (u1 :: Float#) -> _#_ eqFloat# [] [u0, u1] _N_} _F_ _IF_ARGS_ 0 2 CC 3 \ (u0 :: Float) (u1 :: Float) -> case u0 of { _ALG_ F# (u2 :: Float#) -> case u1 of { _ALG_ F# (u3 :: Float#) -> _#_ eqFloat# [] [u2, u3]; _NO_DEFLT_ }; _NO_DEFLT_ } _N_,
- (/=) = _A_ 2 _U_ 11 _N_ _S_ "U(P)U(P)" {_A_ 2 _U_ 22 _N_ _N_ _F_ _IF_ARGS_ 0 2 XX 1 \ (u0 :: Float#) (u1 :: Float#) -> _#_ neFloat# [] [u0, u1] _N_} _F_ _IF_ARGS_ 0 2 CC 3 \ (u0 :: Float) (u1 :: Float) -> case u0 of { _ALG_ F# (u2 :: Float#) -> case u1 of { _ALG_ F# (u3 :: Float#) -> _#_ neFloat# [] [u2, u3]; _NO_DEFLT_ }; _NO_DEFLT_ } _N_ #-}
+ (==) = { _A_ 2 _U_ 11 _N_ _S_ "U(P)U(P)" {_A_ 2 _U_ 22 _N_ _N_ _F_ _IF_ARGS_ 0 2 XX 1 \ (u0 :: Float#) (u1 :: Float#) -> _#_ eqFloat# [] [u0, u1] _N_} _F_ _IF_ARGS_ 0 2 CC 3 \ (u0 :: Float) (u1 :: Float) -> case u0 of { _ALG_ F# (u2 :: Float#) -> case u1 of { _ALG_ F# (u3 :: Float#) -> _#_ eqFloat# [] [u2, u3]; _NO_DEFLT_ }; _NO_DEFLT_ } _N_ },
+ (/=) = { _A_ 2 _U_ 11 _N_ _S_ "U(P)U(P)" {_A_ 2 _U_ 22 _N_ _N_ _F_ _IF_ARGS_ 0 2 XX 1 \ (u0 :: Float#) (u1 :: Float#) -> _#_ neFloat# [] [u0, u1] _N_} _F_ _IF_ARGS_ 0 2 CC 3 \ (u0 :: Float) (u1 :: Float) -> case u0 of { _ALG_ F# (u2 :: Float#) -> case u1 of { _ALG_ F# (u3 :: Float#) -> _#_ neFloat# [] [u2, u3]; _NO_DEFLT_ }; _NO_DEFLT_ } _N_ } #-}
instance Eq Int
{-# GHC_PRAGMA _M_ PreludeCore {-dfun-} _A_ 0 _N_ _N_ _N_ _F_ _IF_ARGS_ 0 0 X 3 _!_ _TUP_2 [(Int -> Int -> Bool), (Int -> Int -> Bool)] [_CONSTM_ Eq (==) (Int), _CONSTM_ Eq (/=) (Int)] _N_
- (==) = _A_ 2 _U_ 11 _N_ _S_ "U(P)U(P)" {_A_ 2 _U_ 22 _N_ _N_ _F_ _IF_ARGS_ 0 2 XX 1 \ (u0 :: Int#) (u1 :: Int#) -> _#_ eqInt# [] [u0, u1] _N_} _F_ _IF_ARGS_ 0 2 CC 3 \ (u0 :: Int) (u1 :: Int) -> case u0 of { _ALG_ I# (u2 :: Int#) -> case u1 of { _ALG_ I# (u3 :: Int#) -> _#_ eqInt# [] [u2, u3]; _NO_DEFLT_ }; _NO_DEFLT_ } _N_,
- (/=) = _A_ 2 _U_ 11 _N_ _S_ "U(P)U(P)" {_A_ 2 _U_ 22 _N_ _N_ _F_ _IF_ARGS_ 0 2 XX 1 \ (u0 :: Int#) (u1 :: Int#) -> _#_ neInt# [] [u0, u1] _N_} _F_ _IF_ARGS_ 0 2 CC 3 \ (u0 :: Int) (u1 :: Int) -> case u0 of { _ALG_ I# (u2 :: Int#) -> case u1 of { _ALG_ I# (u3 :: Int#) -> _#_ neInt# [] [u2, u3]; _NO_DEFLT_ }; _NO_DEFLT_ } _N_ #-}
+ (==) = { _A_ 2 _U_ 11 _N_ _S_ "U(P)U(P)" {_A_ 2 _U_ 22 _N_ _N_ _F_ _IF_ARGS_ 0 2 XX 1 \ (u0 :: Int#) (u1 :: Int#) -> _#_ eqInt# [] [u0, u1] _N_} _F_ _IF_ARGS_ 0 2 CC 3 \ (u0 :: Int) (u1 :: Int) -> case u0 of { _ALG_ I# (u2 :: Int#) -> case u1 of { _ALG_ I# (u3 :: Int#) -> _#_ eqInt# [] [u2, u3]; _NO_DEFLT_ }; _NO_DEFLT_ } _N_ },
+ (/=) = { _A_ 2 _U_ 11 _N_ _S_ "U(P)U(P)" {_A_ 2 _U_ 22 _N_ _N_ _F_ _IF_ARGS_ 0 2 XX 1 \ (u0 :: Int#) (u1 :: Int#) -> _#_ neInt# [] [u0, u1] _N_} _F_ _IF_ARGS_ 0 2 CC 3 \ (u0 :: Int) (u1 :: Int) -> case u0 of { _ALG_ I# (u2 :: Int#) -> case u1 of { _ALG_ I# (u3 :: Int#) -> _#_ neInt# [] [u2, u3]; _NO_DEFLT_ }; _NO_DEFLT_ } _N_ } #-}
instance Eq Integer
{-# GHC_PRAGMA _M_ PreludeCore {-dfun-} _A_ 0 _N_ _N_ _N_ _F_ _IF_ARGS_ 0 0 X 3 _!_ _TUP_2 [(Integer -> Integer -> Bool), (Integer -> Integer -> Bool)] [_CONSTM_ Eq (==) (Integer), _CONSTM_ Eq (/=) (Integer)] _N_
- (==) = _A_ 2 _U_ 11 _N_ _S_ "U(PPP)U(PPP)" {_A_ 4 _U_ 2221 _N_ _N_ _F_ _IF_ARGS_ 0 4 XXXC 4 \ (u0 :: Int#) (u1 :: Int#) (u2 :: ByteArray#) (u3 :: Integer) -> case u3 of { _ALG_ J# (u4 :: Int#) (u5 :: Int#) (u6 :: ByteArray#) -> case _#_ cmpInteger# [] [u0, u1, u2, u4, u5, u6] of { _PRIM_ 0# -> _!_ True [] []; (u7 :: Int#) -> _!_ False [] [] }; _NO_DEFLT_ } _N_} _F_ _IF_ARGS_ 0 2 CC 5 \ (u0 :: Integer) (u1 :: Integer) -> case u0 of { _ALG_ J# (u2 :: Int#) (u3 :: Int#) (u4 :: ByteArray#) -> case u1 of { _ALG_ J# (u5 :: Int#) (u6 :: Int#) (u7 :: ByteArray#) -> case _#_ cmpInteger# [] [u2, u3, u4, u5, u6, u7] of { _PRIM_ 0# -> _!_ True [] []; (u8 :: Int#) -> _!_ False [] [] }; _NO_DEFLT_ }; _NO_DEFLT_ } _N_,
- (/=) = _A_ 2 _U_ 11 _N_ _S_ "U(PPP)U(PPP)" {_A_ 4 _U_ 2221 _N_ _N_ _F_ _IF_ARGS_ 0 4 XXXC 4 \ (u0 :: Int#) (u1 :: Int#) (u2 :: ByteArray#) (u3 :: Integer) -> case u3 of { _ALG_ J# (u4 :: Int#) (u5 :: Int#) (u6 :: ByteArray#) -> case _#_ cmpInteger# [] [u0, u1, u2, u4, u5, u6] of { _PRIM_ 0# -> _!_ False [] []; (u7 :: Int#) -> _!_ True [] [] }; _NO_DEFLT_ } _N_} _F_ _IF_ARGS_ 0 2 CC 5 \ (u0 :: Integer) (u1 :: Integer) -> case u0 of { _ALG_ J# (u2 :: Int#) (u3 :: Int#) (u4 :: ByteArray#) -> case u1 of { _ALG_ J# (u5 :: Int#) (u6 :: Int#) (u7 :: ByteArray#) -> case _#_ cmpInteger# [] [u2, u3, u4, u5, u6, u7] of { _PRIM_ 0# -> _!_ False [] []; (u8 :: Int#) -> _!_ True [] [] }; _NO_DEFLT_ }; _NO_DEFLT_ } _N_ #-}
+ (==) = { _A_ 2 _U_ 11 _N_ _S_ "U(PPP)U(PPP)" {_A_ 4 _U_ 2221 _N_ _N_ _F_ _IF_ARGS_ 0 4 XXXC 4 \ (u0 :: Int#) (u1 :: Int#) (u2 :: ByteArray#) (u3 :: Integer) -> case u3 of { _ALG_ J# (u4 :: Int#) (u5 :: Int#) (u6 :: ByteArray#) -> case _#_ cmpInteger# [] [u0, u1, u2, u4, u5, u6] of { _PRIM_ 0# -> _!_ True [] []; (u7 :: Int#) -> _!_ False [] [] }; _NO_DEFLT_ } _N_} _F_ _IF_ARGS_ 0 2 CC 5 \ (u0 :: Integer) (u1 :: Integer) -> case u0 of { _ALG_ J# (u2 :: Int#) (u3 :: Int#) (u4 :: ByteArray#) -> case u1 of { _ALG_ J# (u5 :: Int#) (u6 :: Int#) (u7 :: ByteArray#) -> case _#_ cmpInteger# [] [u2, u3, u4, u5, u6, u7] of { _PRIM_ 0# -> _!_ True [] []; (u8 :: Int#) -> _!_ False [] [] }; _NO_DEFLT_ }; _NO_DEFLT_ } _N_ },
+ (/=) = { _A_ 2 _U_ 11 _N_ _S_ "U(PPP)U(PPP)" {_A_ 4 _U_ 2221 _N_ _N_ _F_ _IF_ARGS_ 0 4 XXXC 4 \ (u0 :: Int#) (u1 :: Int#) (u2 :: ByteArray#) (u3 :: Integer) -> case u3 of { _ALG_ J# (u4 :: Int#) (u5 :: Int#) (u6 :: ByteArray#) -> case _#_ cmpInteger# [] [u0, u1, u2, u4, u5, u6] of { _PRIM_ 0# -> _!_ False [] []; (u7 :: Int#) -> _!_ True [] [] }; _NO_DEFLT_ } _N_} _F_ _IF_ARGS_ 0 2 CC 5 \ (u0 :: Integer) (u1 :: Integer) -> case u0 of { _ALG_ J# (u2 :: Int#) (u3 :: Int#) (u4 :: ByteArray#) -> case u1 of { _ALG_ J# (u5 :: Int#) (u6 :: Int#) (u7 :: ByteArray#) -> case _#_ cmpInteger# [] [u2, u3, u4, u5, u6, u7] of { _PRIM_ 0# -> _!_ False [] []; (u8 :: Int#) -> _!_ True [] [] }; _NO_DEFLT_ }; _NO_DEFLT_ } _N_ } #-}
instance Eq a => Eq (Maybe a)
{-# GHC_PRAGMA _M_ PreludeStdIO {-dfun-} _A_ 1 _U_ 1 _N_ _N_ _N_ _N_ #-}
instance Integral a => Eq (Ratio a)
{-# GHC_PRAGMA _M_ PreludeRatio {-dfun-} _A_ 1 _U_ 1 _N_ _N_ _N_ _N_ #-}
instance Eq (Ratio Integer)
{-# GHC_PRAGMA _M_ PreludeRatio {-dfun-} _A_ 0 _N_ _N_ _N_ _F_ _IF_ARGS_ 0 0 X 3 _!_ _TUP_2 [(Ratio Integer -> Ratio Integer -> Bool), (Ratio Integer -> Ratio Integer -> Bool)] [_CONSTM_ Eq (==) (Ratio Integer), _CONSTM_ Eq (/=) (Ratio Integer)] _N_
- (==) = _A_ 2 _U_ 11 _N_ _S_ "U(U(PPP)L)U(U(PPP)L)" {_A_ 5 _U_ 22211 _N_ _N_ _F_ _IF_ARGS_ 0 5 XXXCC 9 \ (u0 :: Int#) (u1 :: Int#) (u2 :: ByteArray#) (u3 :: Integer) (u4 :: Ratio Integer) -> case u4 of { _ALG_ (:%) (u5 :: Integer) (u6 :: Integer) -> case u5 of { _ALG_ J# (u7 :: Int#) (u8 :: Int#) (u9 :: ByteArray#) -> case _#_ cmpInteger# [] [u0, u1, u2, u7, u8, u9] of { _PRIM_ 0# -> case u3 of { _ALG_ J# (ua :: Int#) (ub :: Int#) (uc :: ByteArray#) -> case u6 of { _ALG_ J# (ud :: Int#) (ue :: Int#) (uf :: ByteArray#) -> case _#_ cmpInteger# [] [ua, ub, uc, ud, ue, uf] of { _PRIM_ 0# -> _!_ True [] []; (ug :: Int#) -> _!_ False [] [] }; _NO_DEFLT_ }; _NO_DEFLT_ }; (uh :: Int#) -> _!_ False [] [] }; _NO_DEFLT_ }; _NO_DEFLT_ } _N_} _N_ _N_,
- (/=) = _A_ 2 _U_ 11 _N_ _S_ "U(U(PPP)L)U(U(PPP)L)" {_A_ 5 _U_ 22211 _N_ _N_ _F_ _IF_ARGS_ 0 5 XXXCC 9 \ (u0 :: Int#) (u1 :: Int#) (u2 :: ByteArray#) (u3 :: Integer) (u4 :: Ratio Integer) -> case u4 of { _ALG_ (:%) (u5 :: Integer) (u6 :: Integer) -> case u5 of { _ALG_ J# (u7 :: Int#) (u8 :: Int#) (u9 :: ByteArray#) -> case _#_ cmpInteger# [] [u0, u1, u2, u7, u8, u9] of { _PRIM_ 0# -> case u3 of { _ALG_ J# (ua :: Int#) (ub :: Int#) (uc :: ByteArray#) -> case u6 of { _ALG_ J# (ud :: Int#) (ue :: Int#) (uf :: ByteArray#) -> case _#_ cmpInteger# [] [ua, ub, uc, ud, ue, uf] of { _PRIM_ 0# -> _!_ False [] []; (ug :: Int#) -> _!_ True [] [] }; _NO_DEFLT_ }; _NO_DEFLT_ }; (uh :: Int#) -> _!_ True [] [] }; _NO_DEFLT_ }; _NO_DEFLT_ } _N_} _N_ _N_ #-}
+ (==) = { _A_ 2 _U_ 11 _N_ _S_ "U(U(PPP)L)U(U(PPP)L)" {_A_ 5 _U_ 22211 _N_ _N_ _F_ _IF_ARGS_ 0 5 XXXCC 9 \ (u0 :: Int#) (u1 :: Int#) (u2 :: ByteArray#) (u3 :: Integer) (u4 :: Ratio Integer) -> case u4 of { _ALG_ (:%) (u5 :: Integer) (u6 :: Integer) -> case u5 of { _ALG_ J# (u7 :: Int#) (u8 :: Int#) (u9 :: ByteArray#) -> case _#_ cmpInteger# [] [u0, u1, u2, u7, u8, u9] of { _PRIM_ 0# -> case u3 of { _ALG_ J# (ua :: Int#) (ub :: Int#) (uc :: ByteArray#) -> case u6 of { _ALG_ J# (ud :: Int#) (ue :: Int#) (uf :: ByteArray#) -> case _#_ cmpInteger# [] [ua, ub, uc, ud, ue, uf] of { _PRIM_ 0# -> _!_ True [] []; (ug :: Int#) -> _!_ False [] [] }; _NO_DEFLT_ }; _NO_DEFLT_ }; (uh :: Int#) -> _!_ False [] [] }; _NO_DEFLT_ }; _NO_DEFLT_ } _N_} _N_ _N_ },
+ (/=) = { _A_ 2 _U_ 11 _N_ _S_ "U(U(PPP)L)U(U(PPP)L)" {_A_ 5 _U_ 22211 _N_ _N_ _F_ _IF_ARGS_ 0 5 XXXCC 9 \ (u0 :: Int#) (u1 :: Int#) (u2 :: ByteArray#) (u3 :: Integer) (u4 :: Ratio Integer) -> case u4 of { _ALG_ (:%) (u5 :: Integer) (u6 :: Integer) -> case u5 of { _ALG_ J# (u7 :: Int#) (u8 :: Int#) (u9 :: ByteArray#) -> case _#_ cmpInteger# [] [u0, u1, u2, u7, u8, u9] of { _PRIM_ 0# -> case u3 of { _ALG_ J# (ua :: Int#) (ub :: Int#) (uc :: ByteArray#) -> case u6 of { _ALG_ J# (ud :: Int#) (ue :: Int#) (uf :: ByteArray#) -> case _#_ cmpInteger# [] [ua, ub, uc, ud, ue, uf] of { _PRIM_ 0# -> _!_ False [] []; (ug :: Int#) -> _!_ True [] [] }; _NO_DEFLT_ }; _NO_DEFLT_ }; (uh :: Int#) -> _!_ True [] [] }; _NO_DEFLT_ }; _NO_DEFLT_ } _N_} _N_ _N_ } #-}
+instance Eq [(Int, Int)]
+ {-# GHC_PRAGMA _M_ PreludeBuiltin {-dfun-} _A_ 0 _N_ _N_ _N_ _F_ _IF_ARGS_ 0 0 X 3 _!_ _TUP_2 [([(Int, Int)] -> [(Int, Int)] -> Bool), ([(Int, Int)] -> [(Int, Int)] -> Bool)] [_CONSTM_ Eq (==) ([(Int, Int)]), _CONSTM_ Eq (/=) ([(Int, Int)])] _N_
+ (==) = { _A_ 2 _U_ 11 _N_ _S_ "SS" _N_ _N_ },
+ (/=) = { _A_ 2 _U_ 11 _N_ _S_ "SS" _N_ _N_ } #-}
instance Eq a => Eq [a]
{-# GHC_PRAGMA _M_ PreludeBuiltin {-dfun-} _A_ 1 _U_ 1 _N_ _N_ _N_ _N_ #-}
+instance Eq [Bool]
+ {-# GHC_PRAGMA _M_ PreludeBuiltin {-dfun-} _A_ 0 _N_ _N_ _N_ _F_ _IF_ARGS_ 0 0 X 3 _!_ _TUP_2 [([Bool] -> [Bool] -> Bool), ([Bool] -> [Bool] -> Bool)] [_CONSTM_ Eq (==) ([Bool]), _CONSTM_ Eq (/=) ([Bool])] _N_
+ (==) = { _A_ 2 _U_ 11 _N_ _S_ "SS" _N_ _N_ },
+ (/=) = { _A_ 2 _U_ 11 _N_ _S_ "SS" _N_ _N_ } #-}
instance Eq [Char]
{-# GHC_PRAGMA _M_ PreludeBuiltin {-dfun-} _A_ 0 _N_ _N_ _N_ _F_ _IF_ARGS_ 0 0 X 3 _!_ _TUP_2 [([Char] -> [Char] -> Bool), ([Char] -> [Char] -> Bool)] [_CONSTM_ Eq (==) ([Char]), _CONSTM_ Eq (/=) ([Char])] _N_
- (==) = _A_ 2 _U_ 11 _N_ _S_ "SS" _N_ _N_,
- (/=) = _A_ 2 _U_ 11 _N_ _S_ "SS" _N_ _N_ #-}
+ (==) = { _A_ 2 _U_ 11 _N_ _S_ "SS" _N_ _N_ },
+ (/=) = { _A_ 2 _U_ 11 _N_ _S_ "SS" _N_ _N_ } #-}
+instance Eq [Complex Double]
+ {-# GHC_PRAGMA _M_ PreludeBuiltin {-dfun-} _A_ 0 _N_ _N_ _N_ _F_ _IF_ARGS_ 0 0 X 3 _!_ _TUP_2 [([Complex Double] -> [Complex Double] -> Bool), ([Complex Double] -> [Complex Double] -> Bool)] [_CONSTM_ Eq (==) ([Complex Double]), _CONSTM_ Eq (/=) ([Complex Double])] _N_
+ (==) = { _A_ 2 _U_ 11 _N_ _S_ "SS" _N_ _N_ },
+ (/=) = { _A_ 2 _U_ 11 _N_ _S_ "SS" _N_ _N_ } #-}
+instance Eq [Double]
+ {-# GHC_PRAGMA _M_ PreludeBuiltin {-dfun-} _A_ 0 _N_ _N_ _N_ _F_ _IF_ARGS_ 0 0 X 3 _!_ _TUP_2 [([Double] -> [Double] -> Bool), ([Double] -> [Double] -> Bool)] [_CONSTM_ Eq (==) ([Double]), _CONSTM_ Eq (/=) ([Double])] _N_
+ (==) = { _A_ 2 _U_ 11 _N_ _S_ "SS" _N_ _N_ },
+ (/=) = { _A_ 2 _U_ 11 _N_ _S_ "SS" _N_ _N_ } #-}
instance Eq [Int]
{-# GHC_PRAGMA _M_ PreludeBuiltin {-dfun-} _A_ 0 _N_ _N_ _N_ _F_ _IF_ARGS_ 0 0 X 3 _!_ _TUP_2 [([Int] -> [Int] -> Bool), ([Int] -> [Int] -> Bool)] [_CONSTM_ Eq (==) ([Int]), _CONSTM_ Eq (/=) ([Int])] _N_
- (==) = _A_ 2 _U_ 11 _N_ _S_ "SS" _N_ _N_,
- (/=) = _A_ 2 _U_ 11 _N_ _S_ "SS" _N_ _N_ #-}
+ (==) = { _A_ 2 _U_ 11 _N_ _S_ "SS" _N_ _N_ },
+ (/=) = { _A_ 2 _U_ 11 _N_ _S_ "SS" _N_ _N_ } #-}
+instance Eq [Integer]
+ {-# GHC_PRAGMA _M_ PreludeBuiltin {-dfun-} _A_ 0 _N_ _N_ _N_ _F_ _IF_ARGS_ 0 0 X 3 _!_ _TUP_2 [([Integer] -> [Integer] -> Bool), ([Integer] -> [Integer] -> Bool)] [_CONSTM_ Eq (==) ([Integer]), _CONSTM_ Eq (/=) ([Integer])] _N_
+ (==) = { _A_ 2 _U_ 11 _N_ _S_ "SS" _N_ _N_ },
+ (/=) = { _A_ 2 _U_ 11 _N_ _S_ "SS" _N_ _N_ } #-}
+instance Eq [[Char]]
+ {-# GHC_PRAGMA _M_ PreludeBuiltin {-dfun-} _A_ 0 _N_ _N_ _N_ _F_ _IF_ARGS_ 0 0 X 3 _!_ _TUP_2 [([[Char]] -> [[Char]] -> Bool), ([[Char]] -> [[Char]] -> Bool)] [_CONSTM_ Eq (==) ([[Char]]), _CONSTM_ Eq (/=) ([[Char]])] _N_
+ (==) = { _A_ 2 _U_ 11 _N_ _S_ "SS" _N_ _N_ },
+ (/=) = { _A_ 2 _U_ 11 _N_ _S_ "SS" _N_ _N_ } #-}
+instance Eq [[Int]]
+ {-# GHC_PRAGMA _M_ PreludeBuiltin {-dfun-} _A_ 0 _N_ _N_ _N_ _F_ _IF_ARGS_ 0 0 X 3 _!_ _TUP_2 [([[Int]] -> [[Int]] -> Bool), ([[Int]] -> [[Int]] -> Bool)] [_CONSTM_ Eq (==) ([[Int]]), _CONSTM_ Eq (/=) ([[Int]])] _N_
+ (==) = { _A_ 2 _U_ 11 _N_ _S_ "SS" _N_ _N_ },
+ (/=) = { _A_ 2 _U_ 11 _N_ _S_ "SS" _N_ _N_ } #-}
instance Eq _Addr
{-# GHC_PRAGMA _M_ PreludeCore {-dfun-} _A_ 0 _N_ _N_ _N_ _F_ _IF_ARGS_ 0 0 X 3 _!_ _TUP_2 [(_Addr -> _Addr -> Bool), (_Addr -> _Addr -> Bool)] [_CONSTM_ Eq (==) (_Addr), _CONSTM_ Eq (/=) (_Addr)] _N_
- (==) = _A_ 2 _U_ 11 _N_ _S_ "U(P)U(P)" {_A_ 2 _U_ 22 _N_ _N_ _F_ _IF_ARGS_ 0 2 XX 1 \ (u0 :: Addr#) (u1 :: Addr#) -> _#_ eqAddr# [] [u0, u1] _N_} _F_ _IF_ARGS_ 0 2 CC 3 \ (u0 :: _Addr) (u1 :: _Addr) -> case u0 of { _ALG_ A# (u2 :: Addr#) -> case u1 of { _ALG_ A# (u3 :: Addr#) -> _#_ eqAddr# [] [u2, u3]; _NO_DEFLT_ }; _NO_DEFLT_ } _N_,
- (/=) = _A_ 2 _U_ 11 _N_ _S_ "U(P)U(P)" {_A_ 2 _U_ 22 _N_ _N_ _F_ _IF_ARGS_ 0 2 XX 1 \ (u0 :: Addr#) (u1 :: Addr#) -> _#_ neAddr# [] [u0, u1] _N_} _F_ _IF_ARGS_ 0 2 CC 3 \ (u0 :: _Addr) (u1 :: _Addr) -> case u0 of { _ALG_ A# (u2 :: Addr#) -> case u1 of { _ALG_ A# (u3 :: Addr#) -> _#_ neAddr# [] [u2, u3]; _NO_DEFLT_ }; _NO_DEFLT_ } _N_ #-}
+ (==) = { _A_ 2 _U_ 11 _N_ _S_ "U(P)U(P)" {_A_ 2 _U_ 22 _N_ _N_ _F_ _IF_ARGS_ 0 2 XX 1 \ (u0 :: Addr#) (u1 :: Addr#) -> _#_ eqAddr# [] [u0, u1] _N_} _F_ _IF_ARGS_ 0 2 CC 3 \ (u0 :: _Addr) (u1 :: _Addr) -> case u0 of { _ALG_ A# (u2 :: Addr#) -> case u1 of { _ALG_ A# (u3 :: Addr#) -> _#_ eqAddr# [] [u2, u3]; _NO_DEFLT_ }; _NO_DEFLT_ } _N_ },
+ (/=) = { _A_ 2 _U_ 11 _N_ _S_ "U(P)U(P)" {_A_ 2 _U_ 22 _N_ _N_ _F_ _IF_ARGS_ 0 2 XX 1 \ (u0 :: Addr#) (u1 :: Addr#) -> _#_ neAddr# [] [u0, u1] _N_} _F_ _IF_ARGS_ 0 2 CC 3 \ (u0 :: _Addr) (u1 :: _Addr) -> case u0 of { _ALG_ A# (u2 :: Addr#) -> case u1 of { _ALG_ A# (u3 :: Addr#) -> _#_ neAddr# [] [u2, u3]; _NO_DEFLT_ }; _NO_DEFLT_ } _N_ } #-}
instance Eq _PackedString
{-# GHC_PRAGMA _M_ PreludePS {-dfun-} _A_ 0 _N_ _N_ _N_ _F_ _IF_ARGS_ 0 0 X 3 _!_ _TUP_2 [(_PackedString -> _PackedString -> Bool), (_PackedString -> _PackedString -> Bool)] [_CONSTM_ Eq (==) (_PackedString), _CONSTM_ Eq (/=) (_PackedString)] _N_
- (==) = _A_ 2 _U_ 22 _N_ _S_ "SS" _N_ _N_,
- (/=) = _A_ 2 _U_ 22 _N_ _S_ "SS" _N_ _N_ #-}
+ (==) = { _A_ 2 _U_ 22 _N_ _S_ "SS" _N_ _N_ },
+ (/=) = { _A_ 2 _U_ 22 _N_ _S_ "SS" _N_ _N_ } #-}
instance Eq _Word
{-# GHC_PRAGMA _M_ PreludeCore {-dfun-} _A_ 0 _N_ _N_ _N_ _F_ _IF_ARGS_ 0 0 X 3 _!_ _TUP_2 [(_Word -> _Word -> Bool), (_Word -> _Word -> Bool)] [_CONSTM_ Eq (==) (_Word), _CONSTM_ Eq (/=) (_Word)] _N_
- (==) = _A_ 2 _U_ 11 _N_ _S_ "U(P)U(P)" {_A_ 2 _U_ 22 _N_ _N_ _F_ _IF_ARGS_ 0 2 XX 1 \ (u0 :: Word#) (u1 :: Word#) -> _#_ eqWord# [] [u0, u1] _N_} _F_ _IF_ARGS_ 0 2 CC 3 \ (u0 :: _Word) (u1 :: _Word) -> case u0 of { _ALG_ W# (u2 :: Word#) -> case u1 of { _ALG_ W# (u3 :: Word#) -> _#_ eqWord# [] [u2, u3]; _NO_DEFLT_ }; _NO_DEFLT_ } _N_,
- (/=) = _A_ 2 _U_ 11 _N_ _S_ "U(P)U(P)" {_A_ 2 _U_ 22 _N_ _N_ _F_ _IF_ARGS_ 0 2 XX 1 \ (u0 :: Word#) (u1 :: Word#) -> _#_ neWord# [] [u0, u1] _N_} _F_ _IF_ARGS_ 0 2 CC 3 \ (u0 :: _Word) (u1 :: _Word) -> case u0 of { _ALG_ W# (u2 :: Word#) -> case u1 of { _ALG_ W# (u3 :: Word#) -> _#_ neWord# [] [u2, u3]; _NO_DEFLT_ }; _NO_DEFLT_ } _N_ #-}
+ (==) = { _A_ 2 _U_ 11 _N_ _S_ "U(P)U(P)" {_A_ 2 _U_ 22 _N_ _N_ _F_ _IF_ARGS_ 0 2 XX 1 \ (u0 :: Word#) (u1 :: Word#) -> _#_ eqWord# [] [u0, u1] _N_} _F_ _IF_ARGS_ 0 2 CC 3 \ (u0 :: _Word) (u1 :: _Word) -> case u0 of { _ALG_ W# (u2 :: Word#) -> case u1 of { _ALG_ W# (u3 :: Word#) -> _#_ eqWord# [] [u2, u3]; _NO_DEFLT_ }; _NO_DEFLT_ } _N_ },
+ (/=) = { _A_ 2 _U_ 11 _N_ _S_ "U(P)U(P)" {_A_ 2 _U_ 22 _N_ _N_ _F_ _IF_ARGS_ 0 2 XX 1 \ (u0 :: Word#) (u1 :: Word#) -> _#_ neWord# [] [u0, u1] _N_} _F_ _IF_ARGS_ 0 2 CC 3 \ (u0 :: _Word) (u1 :: _Word) -> case u0 of { _ALG_ W# (u2 :: Word#) -> case u1 of { _ALG_ W# (u3 :: Word#) -> _#_ neWord# [] [u2, u3]; _NO_DEFLT_ }; _NO_DEFLT_ } _N_ } #-}
instance RealFloat a => Floating (Complex a)
{-# GHC_PRAGMA _M_ PreludeComplex {-dfun-} _A_ 2 _U_ 22 _N_ _N_ _N_ _N_ #-}
instance Floating (Complex Double)
{-# GHC_PRAGMA _M_ PreludeComplex {-dfun-} _A_ 0 _N_ _N_ _N_ _F_ _IF_ARGS_ 0 0 X 20 _!_ _TUP_19 [{{Fractional (Complex Double)}}, (Complex Double), (Complex Double -> Complex Double), (Complex Double -> Complex Double), (Complex Double -> Complex Double), (Complex Double -> Complex Double -> Complex Double), (Complex Double -> Complex Double -> Complex Double), (Complex Double -> Complex Double), (Complex Double -> Complex Double), (Complex Double -> Complex Double), (Complex Double -> Complex Double), (Complex Double -> Complex Double), (Complex Double -> Complex Double), (Complex Double -> Complex Double), (Complex Double -> Complex Double), (Complex Double -> Complex Double), (Complex Double -> Complex Double), (Complex Double -> Complex Double), (Complex Double -> Complex Double)] [_DFUN_ Fractional (Complex Double), _CONSTM_ Floating pi (Complex Double), _CONSTM_ Floating exp (Complex Double), _CONSTM_ Floating log (Complex Double), _CONSTM_ Floating sqrt (Complex Double), _CONSTM_ Floating (**) (Complex Double), _CONSTM_ Floating logBase (Complex Double), _CONSTM_ Floating sin (Complex Double), _CONSTM_ Floating cos (Complex Double), _CONSTM_ Floating tan (Complex Double), _CONSTM_ Floating asin (Complex Double), _CONSTM_ Floating acos (Complex Double), _CONSTM_ Floating atan (Complex Double), _CONSTM_ Floating sinh (Complex Double), _CONSTM_ Floating cosh (Complex Double), _CONSTM_ Floating tanh (Complex Double), _CONSTM_ Floating asinh (Complex Double), _CONSTM_ Floating acosh (Complex Double), _CONSTM_ Floating atanh (Complex Double)] _N_
- pi = _A_ 0 _N_ _N_ _N_ _N_ _N_,
- exp = _A_ 1 _U_ 1 _N_ _S_ "U(LL)" {_A_ 2 _U_ 12 _N_ _N_ _N_ _N_} _N_ _N_,
- log = _A_ 1 _U_ 2 _N_ _N_ _N_ _N_,
- sqrt = _A_ 1 _U_ 1 _N_ _S_ "U(U(P)L)" {_A_ 2 _U_ 22 _N_ _N_ _N_ _N_} _N_ _N_,
- (**) = _A_ 2 _U_ 21 _N_ _S_ "LU(LL)" {_A_ 3 _U_ 222 _N_ _N_ _N_ _N_} _N_ _N_,
- logBase = _A_ 2 _U_ 22 _N_ _N_ _N_ _N_,
- sin = _A_ 1 _U_ 1 _N_ _S_ "U(LL)" {_A_ 2 _U_ 22 _N_ _N_ _N_ _N_} _N_ _N_,
- cos = _A_ 1 _U_ 1 _N_ _S_ "U(LL)" {_A_ 2 _U_ 22 _N_ _N_ _N_ _N_} _N_ _N_,
- tan = _A_ 1 _U_ 1 _N_ _S_ "U(LL)" {_A_ 2 _U_ 22 _N_ _N_ _N_ _N_} _N_ _N_,
- asin = _A_ 1 _U_ 1 _N_ _S_ "U(LL)" {_A_ 2 _U_ 22 _N_ _N_ _N_ _N_} _N_ _N_,
- acos = _A_ 1 _U_ 1 _N_ _S_ "U(LL)" {_A_ 2 _U_ 22 _N_ _N_ _N_ _N_} _N_ _N_,
- atan = _A_ 1 _U_ 1 _N_ _S_ "U(LL)" {_A_ 2 _U_ 22 _N_ _N_ _N_ _N_} _N_ _N_,
- sinh = _A_ 1 _U_ 1 _N_ _S_ "U(LL)" {_A_ 2 _U_ 22 _N_ _N_ _N_ _N_} _N_ _N_,
- cosh = _A_ 1 _U_ 1 _N_ _S_ "U(LL)" {_A_ 2 _U_ 22 _N_ _N_ _N_ _N_} _N_ _N_,
- tanh = _A_ 1 _U_ 1 _N_ _S_ "U(LL)" {_A_ 2 _U_ 22 _N_ _N_ _N_ _N_} _N_ _N_,
- asinh = _A_ 1 _U_ 1 _N_ _N_ _N_ _N_,
- acosh = _A_ 1 _U_ 1 _N_ _N_ _N_ _N_,
- atanh = _A_ 1 _U_ 1 _N_ _N_ _N_ _N_ #-}
+ pi = { _A_ 0 _N_ _N_ _N_ _F_ _IF_ARGS_ 0 0 X 3 _!_ (:+) [Double] [_CONSTM_ Floating pi (Double), _SPEC_ _ORIG_ PreludeCore __i0 [ (Double) ]] _N_ },
+ exp = { _A_ 1 _U_ 1 _N_ _S_ "U(LL)" {_A_ 2 _U_ 12 _N_ _N_ _N_ _N_} _N_ _N_ },
+ log = { _A_ 1 _U_ 2 _N_ _N_ _N_ _N_ },
+ sqrt = { _A_ 1 _U_ 1 _N_ _S_ "U(U(P)L)" {_A_ 2 _U_ 22 _N_ _N_ _N_ _N_} _N_ _N_ },
+ (**) = { _A_ 2 _U_ 21 _N_ _S_ "LU(LL)" {_A_ 3 _U_ 222 _N_ _N_ _N_ _N_} _N_ _N_ },
+ logBase = { _A_ 2 _U_ 22 _N_ _N_ _N_ _N_ },
+ sin = { _A_ 1 _U_ 1 _N_ _S_ "U(LL)" {_A_ 2 _U_ 22 _N_ _N_ _N_ _N_} _N_ _N_ },
+ cos = { _A_ 1 _U_ 1 _N_ _S_ "U(LL)" {_A_ 2 _U_ 22 _N_ _N_ _N_ _N_} _N_ _N_ },
+ tan = { _A_ 1 _U_ 1 _N_ _S_ "U(LL)" {_A_ 2 _U_ 22 _N_ _N_ _N_ _N_} _N_ _N_ },
+ asin = { _A_ 1 _U_ 1 _N_ _S_ "U(LL)" {_A_ 2 _U_ 22 _N_ _N_ _N_ _N_} _N_ _N_ },
+ acos = { _A_ 1 _U_ 1 _N_ _S_ "U(LL)" {_A_ 2 _U_ 22 _N_ _N_ _N_ _N_} _N_ _N_ },
+ atan = { _A_ 1 _U_ 1 _N_ _S_ "U(LL)" {_A_ 2 _U_ 22 _N_ _N_ _N_ _N_} _N_ _N_ },
+ sinh = { _A_ 1 _U_ 1 _N_ _S_ "U(LL)" {_A_ 2 _U_ 22 _N_ _N_ _N_ _N_} _N_ _N_ },
+ cosh = { _A_ 1 _U_ 1 _N_ _S_ "U(LL)" {_A_ 2 _U_ 22 _N_ _N_ _N_ _N_} _N_ _N_ },
+ tanh = { _A_ 1 _U_ 1 _N_ _S_ "U(LL)" {_A_ 2 _U_ 22 _N_ _N_ _N_ _N_} _N_ _N_ },
+ asinh = { _A_ 1 _U_ 1 _N_ _N_ _N_ _N_ },
+ acosh = { _A_ 1 _U_ 1 _N_ _N_ _N_ _N_ },
+ atanh = { _A_ 1 _U_ 1 _N_ _N_ _N_ _N_ } #-}
instance Floating Double
{-# GHC_PRAGMA _M_ PreludeCore {-dfun-} _A_ 0 _N_ _N_ _N_ _F_ _IF_ARGS_ 0 0 X 20 _!_ _TUP_19 [{{Fractional Double}}, Double, (Double -> Double), (Double -> Double), (Double -> Double), (Double -> Double -> Double), (Double -> Double -> Double), (Double -> Double), (Double -> Double), (Double -> Double), (Double -> Double), (Double -> Double), (Double -> Double), (Double -> Double), (Double -> Double), (Double -> Double), (Double -> Double), (Double -> Double), (Double -> Double)] [_DFUN_ Fractional (Double), _CONSTM_ Floating pi (Double), _CONSTM_ Floating exp (Double), _CONSTM_ Floating log (Double), _CONSTM_ Floating sqrt (Double), _CONSTM_ Floating (**) (Double), _CONSTM_ Floating logBase (Double), _CONSTM_ Floating sin (Double), _CONSTM_ Floating cos (Double), _CONSTM_ Floating tan (Double), _CONSTM_ Floating asin (Double), _CONSTM_ Floating acos (Double), _CONSTM_ Floating atan (Double), _CONSTM_ Floating sinh (Double), _CONSTM_ Floating cosh (Double), _CONSTM_ Floating tanh (Double), _CONSTM_ Floating asinh (Double), _CONSTM_ Floating acosh (Double), _CONSTM_ Floating atanh (Double)] _N_
- pi = _A_ 0 _N_ _N_ _N_ _F_ _IF_ARGS_ 0 0 X 2 _!_ D# [] [3.1415926535897931##] _N_,
- exp = _A_ 1 _U_ 1 _N_ _S_ "U(P)" {_A_ 1 _U_ 2 _N_ _N_ _F_ _IF_ARGS_ 0 1 X 3 \ (u0 :: Double#) -> case _#_ expDouble# [] [u0] of { _PRIM_ (u1 :: Double#) -> _!_ D# [] [u1] } _N_} _F_ _IF_ARGS_ 0 1 C 4 \ (u0 :: Double) -> case u0 of { _ALG_ D# (u1 :: Double#) -> case _#_ expDouble# [] [u1] of { _PRIM_ (u2 :: Double#) -> _!_ D# [] [u2] }; _NO_DEFLT_ } _N_,
- log = _A_ 1 _U_ 1 _N_ _S_ "U(P)" {_A_ 1 _U_ 2 _N_ _N_ _F_ _IF_ARGS_ 0 1 X 3 \ (u0 :: Double#) -> case _#_ logDouble# [] [u0] of { _PRIM_ (u1 :: Double#) -> _!_ D# [] [u1] } _N_} _F_ _IF_ARGS_ 0 1 C 4 \ (u0 :: Double) -> case u0 of { _ALG_ D# (u1 :: Double#) -> case _#_ logDouble# [] [u1] of { _PRIM_ (u2 :: Double#) -> _!_ D# [] [u2] }; _NO_DEFLT_ } _N_,
- sqrt = _A_ 1 _U_ 1 _N_ _S_ "U(P)" {_A_ 1 _U_ 2 _N_ _N_ _F_ _IF_ARGS_ 0 1 X 3 \ (u0 :: Double#) -> case _#_ sqrtDouble# [] [u0] of { _PRIM_ (u1 :: Double#) -> _!_ D# [] [u1] } _N_} _F_ _IF_ARGS_ 0 1 C 4 \ (u0 :: Double) -> case u0 of { _ALG_ D# (u1 :: Double#) -> case _#_ sqrtDouble# [] [u1] of { _PRIM_ (u2 :: Double#) -> _!_ D# [] [u2] }; _NO_DEFLT_ } _N_,
- (**) = _A_ 2 _U_ 11 _N_ _S_ "U(P)U(P)" {_A_ 2 _U_ 22 _N_ _N_ _F_ _IF_ARGS_ 0 2 XX 3 \ (u0 :: Double#) (u1 :: Double#) -> case _#_ powerDouble# [] [u0, u1] of { _PRIM_ (u2 :: Double#) -> _!_ D# [] [u2] } _N_} _F_ _IF_ARGS_ 0 2 CC 5 \ (u0 :: Double) (u1 :: Double) -> case u0 of { _ALG_ D# (u2 :: Double#) -> case u1 of { _ALG_ D# (u3 :: Double#) -> case _#_ powerDouble# [] [u2, u3] of { _PRIM_ (u4 :: Double#) -> _!_ D# [] [u4] }; _NO_DEFLT_ }; _NO_DEFLT_ } _N_,
- logBase = _A_ 2 _U_ 11 _N_ _S_ "U(P)U(P)" {_A_ 2 _U_ 22 _N_ _N_ _F_ _IF_ARGS_ 0 2 XX 5 \ (u0 :: Double#) (u1 :: Double#) -> case _#_ logDouble# [] [u1] of { _PRIM_ (u2 :: Double#) -> case _#_ logDouble# [] [u0] of { _PRIM_ (u3 :: Double#) -> case _#_ divideDouble# [] [u2, u3] of { _PRIM_ (u4 :: Double#) -> _!_ D# [] [u4] } } } _N_} _F_ _IF_ARGS_ 0 2 CC 7 \ (u0 :: Double) (u1 :: Double) -> case u1 of { _ALG_ D# (u2 :: Double#) -> case _#_ logDouble# [] [u2] of { _PRIM_ (u3 :: Double#) -> case u0 of { _ALG_ D# (u4 :: Double#) -> case _#_ logDouble# [] [u4] of { _PRIM_ (u5 :: Double#) -> case _#_ divideDouble# [] [u3, u5] of { _PRIM_ (u6 :: Double#) -> _!_ D# [] [u6] } }; _NO_DEFLT_ } }; _NO_DEFLT_ } _N_,
- sin = _A_ 1 _U_ 1 _N_ _S_ "U(P)" {_A_ 1 _U_ 2 _N_ _N_ _F_ _IF_ARGS_ 0 1 X 3 \ (u0 :: Double#) -> case _#_ sinDouble# [] [u0] of { _PRIM_ (u1 :: Double#) -> _!_ D# [] [u1] } _N_} _F_ _IF_ARGS_ 0 1 C 4 \ (u0 :: Double) -> case u0 of { _ALG_ D# (u1 :: Double#) -> case _#_ sinDouble# [] [u1] of { _PRIM_ (u2 :: Double#) -> _!_ D# [] [u2] }; _NO_DEFLT_ } _N_,
- cos = _A_ 1 _U_ 1 _N_ _S_ "U(P)" {_A_ 1 _U_ 2 _N_ _N_ _F_ _IF_ARGS_ 0 1 X 3 \ (u0 :: Double#) -> case _#_ cosDouble# [] [u0] of { _PRIM_ (u1 :: Double#) -> _!_ D# [] [u1] } _N_} _F_ _IF_ARGS_ 0 1 C 4 \ (u0 :: Double) -> case u0 of { _ALG_ D# (u1 :: Double#) -> case _#_ cosDouble# [] [u1] of { _PRIM_ (u2 :: Double#) -> _!_ D# [] [u2] }; _NO_DEFLT_ } _N_,
- tan = _A_ 1 _U_ 1 _N_ _S_ "U(P)" {_A_ 1 _U_ 2 _N_ _N_ _F_ _IF_ARGS_ 0 1 X 3 \ (u0 :: Double#) -> case _#_ tanDouble# [] [u0] of { _PRIM_ (u1 :: Double#) -> _!_ D# [] [u1] } _N_} _F_ _IF_ARGS_ 0 1 C 4 \ (u0 :: Double) -> case u0 of { _ALG_ D# (u1 :: Double#) -> case _#_ tanDouble# [] [u1] of { _PRIM_ (u2 :: Double#) -> _!_ D# [] [u2] }; _NO_DEFLT_ } _N_,
- asin = _A_ 1 _U_ 1 _N_ _S_ "U(P)" {_A_ 1 _U_ 2 _N_ _N_ _F_ _IF_ARGS_ 0 1 X 3 \ (u0 :: Double#) -> case _#_ asinDouble# [] [u0] of { _PRIM_ (u1 :: Double#) -> _!_ D# [] [u1] } _N_} _F_ _IF_ARGS_ 0 1 C 4 \ (u0 :: Double) -> case u0 of { _ALG_ D# (u1 :: Double#) -> case _#_ asinDouble# [] [u1] of { _PRIM_ (u2 :: Double#) -> _!_ D# [] [u2] }; _NO_DEFLT_ } _N_,
- acos = _A_ 1 _U_ 1 _N_ _S_ "U(P)" {_A_ 1 _U_ 2 _N_ _N_ _F_ _IF_ARGS_ 0 1 X 3 \ (u0 :: Double#) -> case _#_ acosDouble# [] [u0] of { _PRIM_ (u1 :: Double#) -> _!_ D# [] [u1] } _N_} _F_ _IF_ARGS_ 0 1 C 4 \ (u0 :: Double) -> case u0 of { _ALG_ D# (u1 :: Double#) -> case _#_ acosDouble# [] [u1] of { _PRIM_ (u2 :: Double#) -> _!_ D# [] [u2] }; _NO_DEFLT_ } _N_,
- atan = _A_ 1 _U_ 1 _N_ _S_ "U(P)" {_A_ 1 _U_ 2 _N_ _N_ _F_ _IF_ARGS_ 0 1 X 3 \ (u0 :: Double#) -> case _#_ atanDouble# [] [u0] of { _PRIM_ (u1 :: Double#) -> _!_ D# [] [u1] } _N_} _F_ _IF_ARGS_ 0 1 C 4 \ (u0 :: Double) -> case u0 of { _ALG_ D# (u1 :: Double#) -> case _#_ atanDouble# [] [u1] of { _PRIM_ (u2 :: Double#) -> _!_ D# [] [u2] }; _NO_DEFLT_ } _N_,
- sinh = _A_ 1 _U_ 1 _N_ _S_ "U(P)" {_A_ 1 _U_ 2 _N_ _N_ _F_ _IF_ARGS_ 0 1 X 3 \ (u0 :: Double#) -> case _#_ sinhDouble# [] [u0] of { _PRIM_ (u1 :: Double#) -> _!_ D# [] [u1] } _N_} _F_ _IF_ARGS_ 0 1 C 4 \ (u0 :: Double) -> case u0 of { _ALG_ D# (u1 :: Double#) -> case _#_ sinhDouble# [] [u1] of { _PRIM_ (u2 :: Double#) -> _!_ D# [] [u2] }; _NO_DEFLT_ } _N_,
- cosh = _A_ 1 _U_ 1 _N_ _S_ "U(P)" {_A_ 1 _U_ 2 _N_ _N_ _F_ _IF_ARGS_ 0 1 X 3 \ (u0 :: Double#) -> case _#_ coshDouble# [] [u0] of { _PRIM_ (u1 :: Double#) -> _!_ D# [] [u1] } _N_} _F_ _IF_ARGS_ 0 1 C 4 \ (u0 :: Double) -> case u0 of { _ALG_ D# (u1 :: Double#) -> case _#_ coshDouble# [] [u1] of { _PRIM_ (u2 :: Double#) -> _!_ D# [] [u2] }; _NO_DEFLT_ } _N_,
- tanh = _A_ 1 _U_ 1 _N_ _S_ "U(P)" {_A_ 1 _U_ 2 _N_ _N_ _F_ _IF_ARGS_ 0 1 X 3 \ (u0 :: Double#) -> case _#_ tanhDouble# [] [u0] of { _PRIM_ (u1 :: Double#) -> _!_ D# [] [u1] } _N_} _F_ _IF_ARGS_ 0 1 C 4 \ (u0 :: Double) -> case u0 of { _ALG_ D# (u1 :: Double#) -> case _#_ tanhDouble# [] [u1] of { _PRIM_ (u2 :: Double#) -> _!_ D# [] [u2] }; _NO_DEFLT_ } _N_,
- asinh = _A_ 1 _U_ 1 _N_ _S_ "U(P)" {_A_ 1 _U_ 2 _N_ _N_ _N_ _N_} _N_ _N_,
- acosh = _A_ 1 _U_ 1 _N_ _S_ "U(P)" {_A_ 1 _U_ 2 _N_ _N_ _N_ _N_} _N_ _N_,
- atanh = _A_ 1 _U_ 1 _N_ _S_ "U(P)" {_A_ 1 _U_ 2 _N_ _N_ _N_ _N_} _N_ _N_ #-}
+ pi = { _A_ 0 _N_ _N_ _N_ _F_ _IF_ARGS_ 0 0 X 2 _!_ D# [] [3.1415926535897931##] _N_ },
+ exp = { _A_ 1 _U_ 1 _N_ _S_ "U(P)" {_A_ 1 _U_ 2 _N_ _N_ _F_ _IF_ARGS_ 0 1 X 3 \ (u0 :: Double#) -> case _#_ expDouble# [] [u0] of { _PRIM_ (u1 :: Double#) -> _!_ D# [] [u1] } _N_} _F_ _IF_ARGS_ 0 1 C 4 \ (u0 :: Double) -> case u0 of { _ALG_ D# (u1 :: Double#) -> case _#_ expDouble# [] [u1] of { _PRIM_ (u2 :: Double#) -> _!_ D# [] [u2] }; _NO_DEFLT_ } _N_ },
+ log = { _A_ 1 _U_ 1 _N_ _S_ "U(P)" {_A_ 1 _U_ 2 _N_ _N_ _F_ _IF_ARGS_ 0 1 X 3 \ (u0 :: Double#) -> case _#_ logDouble# [] [u0] of { _PRIM_ (u1 :: Double#) -> _!_ D# [] [u1] } _N_} _F_ _IF_ARGS_ 0 1 C 4 \ (u0 :: Double) -> case u0 of { _ALG_ D# (u1 :: Double#) -> case _#_ logDouble# [] [u1] of { _PRIM_ (u2 :: Double#) -> _!_ D# [] [u2] }; _NO_DEFLT_ } _N_ },
+ sqrt = { _A_ 1 _U_ 1 _N_ _S_ "U(P)" {_A_ 1 _U_ 2 _N_ _N_ _F_ _IF_ARGS_ 0 1 X 3 \ (u0 :: Double#) -> case _#_ sqrtDouble# [] [u0] of { _PRIM_ (u1 :: Double#) -> _!_ D# [] [u1] } _N_} _F_ _IF_ARGS_ 0 1 C 4 \ (u0 :: Double) -> case u0 of { _ALG_ D# (u1 :: Double#) -> case _#_ sqrtDouble# [] [u1] of { _PRIM_ (u2 :: Double#) -> _!_ D# [] [u2] }; _NO_DEFLT_ } _N_ },
+ (**) = { _A_ 2 _U_ 11 _N_ _S_ "U(P)U(P)" {_A_ 2 _U_ 22 _N_ _N_ _F_ _IF_ARGS_ 0 2 XX 3 \ (u0 :: Double#) (u1 :: Double#) -> case _#_ powerDouble# [] [u0, u1] of { _PRIM_ (u2 :: Double#) -> _!_ D# [] [u2] } _N_} _F_ _IF_ARGS_ 0 2 CC 5 \ (u0 :: Double) (u1 :: Double) -> case u0 of { _ALG_ D# (u2 :: Double#) -> case u1 of { _ALG_ D# (u3 :: Double#) -> case _#_ powerDouble# [] [u2, u3] of { _PRIM_ (u4 :: Double#) -> _!_ D# [] [u4] }; _NO_DEFLT_ }; _NO_DEFLT_ } _N_ },
+ logBase = { _A_ 2 _U_ 11 _N_ _S_ "U(P)U(P)" {_A_ 2 _U_ 22 _N_ _N_ _F_ _IF_ARGS_ 0 2 XX 5 \ (u0 :: Double#) (u1 :: Double#) -> case _#_ logDouble# [] [u1] of { _PRIM_ (u2 :: Double#) -> case _#_ logDouble# [] [u0] of { _PRIM_ (u3 :: Double#) -> case _#_ divideDouble# [] [u2, u3] of { _PRIM_ (u4 :: Double#) -> _!_ D# [] [u4] } } } _N_} _F_ _IF_ARGS_ 0 2 CC 7 \ (u0 :: Double) (u1 :: Double) -> case u1 of { _ALG_ D# (u2 :: Double#) -> case _#_ logDouble# [] [u2] of { _PRIM_ (u3 :: Double#) -> case u0 of { _ALG_ D# (u4 :: Double#) -> case _#_ logDouble# [] [u4] of { _PRIM_ (u5 :: Double#) -> case _#_ divideDouble# [] [u3, u5] of { _PRIM_ (u6 :: Double#) -> _!_ D# [] [u6] } }; _NO_DEFLT_ } }; _NO_DEFLT_ } _N_ },
+ sin = { _A_ 1 _U_ 1 _N_ _S_ "U(P)" {_A_ 1 _U_ 2 _N_ _N_ _F_ _IF_ARGS_ 0 1 X 3 \ (u0 :: Double#) -> case _#_ sinDouble# [] [u0] of { _PRIM_ (u1 :: Double#) -> _!_ D# [] [u1] } _N_} _F_ _IF_ARGS_ 0 1 C 4 \ (u0 :: Double) -> case u0 of { _ALG_ D# (u1 :: Double#) -> case _#_ sinDouble# [] [u1] of { _PRIM_ (u2 :: Double#) -> _!_ D# [] [u2] }; _NO_DEFLT_ } _N_ },
+ cos = { _A_ 1 _U_ 1 _N_ _S_ "U(P)" {_A_ 1 _U_ 2 _N_ _N_ _F_ _IF_ARGS_ 0 1 X 3 \ (u0 :: Double#) -> case _#_ cosDouble# [] [u0] of { _PRIM_ (u1 :: Double#) -> _!_ D# [] [u1] } _N_} _F_ _IF_ARGS_ 0 1 C 4 \ (u0 :: Double) -> case u0 of { _ALG_ D# (u1 :: Double#) -> case _#_ cosDouble# [] [u1] of { _PRIM_ (u2 :: Double#) -> _!_ D# [] [u2] }; _NO_DEFLT_ } _N_ },
+ tan = { _A_ 1 _U_ 1 _N_ _S_ "U(P)" {_A_ 1 _U_ 2 _N_ _N_ _F_ _IF_ARGS_ 0 1 X 3 \ (u0 :: Double#) -> case _#_ tanDouble# [] [u0] of { _PRIM_ (u1 :: Double#) -> _!_ D# [] [u1] } _N_} _F_ _IF_ARGS_ 0 1 C 4 \ (u0 :: Double) -> case u0 of { _ALG_ D# (u1 :: Double#) -> case _#_ tanDouble# [] [u1] of { _PRIM_ (u2 :: Double#) -> _!_ D# [] [u2] }; _NO_DEFLT_ } _N_ },
+ asin = { _A_ 1 _U_ 1 _N_ _S_ "U(P)" {_A_ 1 _U_ 2 _N_ _N_ _F_ _IF_ARGS_ 0 1 X 3 \ (u0 :: Double#) -> case _#_ asinDouble# [] [u0] of { _PRIM_ (u1 :: Double#) -> _!_ D# [] [u1] } _N_} _F_ _IF_ARGS_ 0 1 C 4 \ (u0 :: Double) -> case u0 of { _ALG_ D# (u1 :: Double#) -> case _#_ asinDouble# [] [u1] of { _PRIM_ (u2 :: Double#) -> _!_ D# [] [u2] }; _NO_DEFLT_ } _N_ },
+ acos = { _A_ 1 _U_ 1 _N_ _S_ "U(P)" {_A_ 1 _U_ 2 _N_ _N_ _F_ _IF_ARGS_ 0 1 X 3 \ (u0 :: Double#) -> case _#_ acosDouble# [] [u0] of { _PRIM_ (u1 :: Double#) -> _!_ D# [] [u1] } _N_} _F_ _IF_ARGS_ 0 1 C 4 \ (u0 :: Double) -> case u0 of { _ALG_ D# (u1 :: Double#) -> case _#_ acosDouble# [] [u1] of { _PRIM_ (u2 :: Double#) -> _!_ D# [] [u2] }; _NO_DEFLT_ } _N_ },
+ atan = { _A_ 1 _U_ 1 _N_ _S_ "U(P)" {_A_ 1 _U_ 2 _N_ _N_ _F_ _IF_ARGS_ 0 1 X 3 \ (u0 :: Double#) -> case _#_ atanDouble# [] [u0] of { _PRIM_ (u1 :: Double#) -> _!_ D# [] [u1] } _N_} _F_ _IF_ARGS_ 0 1 C 4 \ (u0 :: Double) -> case u0 of { _ALG_ D# (u1 :: Double#) -> case _#_ atanDouble# [] [u1] of { _PRIM_ (u2 :: Double#) -> _!_ D# [] [u2] }; _NO_DEFLT_ } _N_ },
+ sinh = { _A_ 1 _U_ 1 _N_ _S_ "U(P)" {_A_ 1 _U_ 2 _N_ _N_ _F_ _IF_ARGS_ 0 1 X 3 \ (u0 :: Double#) -> case _#_ sinhDouble# [] [u0] of { _PRIM_ (u1 :: Double#) -> _!_ D# [] [u1] } _N_} _F_ _IF_ARGS_ 0 1 C 4 \ (u0 :: Double) -> case u0 of { _ALG_ D# (u1 :: Double#) -> case _#_ sinhDouble# [] [u1] of { _PRIM_ (u2 :: Double#) -> _!_ D# [] [u2] }; _NO_DEFLT_ } _N_ },
+ cosh = { _A_ 1 _U_ 1 _N_ _S_ "U(P)" {_A_ 1 _U_ 2 _N_ _N_ _F_ _IF_ARGS_ 0 1 X 3 \ (u0 :: Double#) -> case _#_ coshDouble# [] [u0] of { _PRIM_ (u1 :: Double#) -> _!_ D# [] [u1] } _N_} _F_ _IF_ARGS_ 0 1 C 4 \ (u0 :: Double) -> case u0 of { _ALG_ D# (u1 :: Double#) -> case _#_ coshDouble# [] [u1] of { _PRIM_ (u2 :: Double#) -> _!_ D# [] [u2] }; _NO_DEFLT_ } _N_ },
+ tanh = { _A_ 1 _U_ 1 _N_ _S_ "U(P)" {_A_ 1 _U_ 2 _N_ _N_ _F_ _IF_ARGS_ 0 1 X 3 \ (u0 :: Double#) -> case _#_ tanhDouble# [] [u0] of { _PRIM_ (u1 :: Double#) -> _!_ D# [] [u1] } _N_} _F_ _IF_ARGS_ 0 1 C 4 \ (u0 :: Double) -> case u0 of { _ALG_ D# (u1 :: Double#) -> case _#_ tanhDouble# [] [u1] of { _PRIM_ (u2 :: Double#) -> _!_ D# [] [u2] }; _NO_DEFLT_ } _N_ },
+ asinh = { _A_ 1 _U_ 1 _N_ _S_ "U(P)" {_A_ 1 _U_ 2 _N_ _N_ _N_ _N_} _N_ _N_ },
+ acosh = { _A_ 1 _U_ 1 _N_ _S_ "U(P)" {_A_ 1 _U_ 2 _N_ _N_ _N_ _N_} _N_ _N_ },
+ atanh = { _A_ 1 _U_ 1 _N_ _S_ "U(P)" {_A_ 1 _U_ 2 _N_ _N_ _N_ _N_} _N_ _N_ } #-}
instance Floating Float
{-# GHC_PRAGMA _M_ PreludeCore {-dfun-} _A_ 0 _N_ _N_ _N_ _F_ _IF_ARGS_ 0 0 X 20 _!_ _TUP_19 [{{Fractional Float}}, Float, (Float -> Float), (Float -> Float), (Float -> Float), (Float -> Float -> Float), (Float -> Float -> Float), (Float -> Float), (Float -> Float), (Float -> Float), (Float -> Float), (Float -> Float), (Float -> Float), (Float -> Float), (Float -> Float), (Float -> Float), (Float -> Float), (Float -> Float), (Float -> Float)] [_DFUN_ Fractional (Float), _CONSTM_ Floating pi (Float), _CONSTM_ Floating exp (Float), _CONSTM_ Floating log (Float), _CONSTM_ Floating sqrt (Float), _CONSTM_ Floating (**) (Float), _CONSTM_ Floating logBase (Float), _CONSTM_ Floating sin (Float), _CONSTM_ Floating cos (Float), _CONSTM_ Floating tan (Float), _CONSTM_ Floating asin (Float), _CONSTM_ Floating acos (Float), _CONSTM_ Floating atan (Float), _CONSTM_ Floating sinh (Float), _CONSTM_ Floating cosh (Float), _CONSTM_ Floating tanh (Float), _CONSTM_ Floating asinh (Float), _CONSTM_ Floating acosh (Float), _CONSTM_ Floating atanh (Float)] _N_
- pi = _A_ 0 _N_ _N_ _N_ _F_ _IF_ARGS_ 0 0 X 2 _!_ F# [] [3.1415926535897931#] _N_,
- exp = _A_ 1 _U_ 1 _N_ _S_ "U(P)" {_A_ 1 _U_ 2 _N_ _N_ _F_ _IF_ARGS_ 0 1 X 3 \ (u0 :: Float#) -> case _#_ expFloat# [] [u0] of { _PRIM_ (u1 :: Float#) -> _!_ F# [] [u1] } _N_} _F_ _IF_ARGS_ 0 1 C 4 \ (u0 :: Float) -> case u0 of { _ALG_ F# (u1 :: Float#) -> case _#_ expFloat# [] [u1] of { _PRIM_ (u2 :: Float#) -> _!_ F# [] [u2] }; _NO_DEFLT_ } _N_,
- log = _A_ 1 _U_ 1 _N_ _S_ "U(P)" {_A_ 1 _U_ 2 _N_ _N_ _F_ _IF_ARGS_ 0 1 X 3 \ (u0 :: Float#) -> case _#_ logFloat# [] [u0] of { _PRIM_ (u1 :: Float#) -> _!_ F# [] [u1] } _N_} _F_ _IF_ARGS_ 0 1 C 4 \ (u0 :: Float) -> case u0 of { _ALG_ F# (u1 :: Float#) -> case _#_ logFloat# [] [u1] of { _PRIM_ (u2 :: Float#) -> _!_ F# [] [u2] }; _NO_DEFLT_ } _N_,
- sqrt = _A_ 1 _U_ 1 _N_ _S_ "U(P)" {_A_ 1 _U_ 2 _N_ _N_ _F_ _IF_ARGS_ 0 1 X 3 \ (u0 :: Float#) -> case _#_ sqrtFloat# [] [u0] of { _PRIM_ (u1 :: Float#) -> _!_ F# [] [u1] } _N_} _F_ _IF_ARGS_ 0 1 C 4 \ (u0 :: Float) -> case u0 of { _ALG_ F# (u1 :: Float#) -> case _#_ sqrtFloat# [] [u1] of { _PRIM_ (u2 :: Float#) -> _!_ F# [] [u2] }; _NO_DEFLT_ } _N_,
- (**) = _A_ 2 _U_ 11 _N_ _S_ "U(P)U(P)" {_A_ 2 _U_ 22 _N_ _N_ _F_ _IF_ARGS_ 0 2 XX 3 \ (u0 :: Float#) (u1 :: Float#) -> case _#_ powerFloat# [] [u0, u1] of { _PRIM_ (u2 :: Float#) -> _!_ F# [] [u2] } _N_} _F_ _IF_ARGS_ 0 2 CC 5 \ (u0 :: Float) (u1 :: Float) -> case u0 of { _ALG_ F# (u2 :: Float#) -> case u1 of { _ALG_ F# (u3 :: Float#) -> case _#_ powerFloat# [] [u2, u3] of { _PRIM_ (u4 :: Float#) -> _!_ F# [] [u4] }; _NO_DEFLT_ }; _NO_DEFLT_ } _N_,
- logBase = _A_ 2 _U_ 22 _N_ _N_ _N_ _N_,
- sin = _A_ 1 _U_ 1 _N_ _S_ "U(P)" {_A_ 1 _U_ 2 _N_ _N_ _F_ _IF_ARGS_ 0 1 X 3 \ (u0 :: Float#) -> case _#_ sinFloat# [] [u0] of { _PRIM_ (u1 :: Float#) -> _!_ F# [] [u1] } _N_} _F_ _IF_ARGS_ 0 1 C 4 \ (u0 :: Float) -> case u0 of { _ALG_ F# (u1 :: Float#) -> case _#_ sinFloat# [] [u1] of { _PRIM_ (u2 :: Float#) -> _!_ F# [] [u2] }; _NO_DEFLT_ } _N_,
- cos = _A_ 1 _U_ 1 _N_ _S_ "U(P)" {_A_ 1 _U_ 2 _N_ _N_ _F_ _IF_ARGS_ 0 1 X 3 \ (u0 :: Float#) -> case _#_ cosFloat# [] [u0] of { _PRIM_ (u1 :: Float#) -> _!_ F# [] [u1] } _N_} _F_ _IF_ARGS_ 0 1 C 4 \ (u0 :: Float) -> case u0 of { _ALG_ F# (u1 :: Float#) -> case _#_ cosFloat# [] [u1] of { _PRIM_ (u2 :: Float#) -> _!_ F# [] [u2] }; _NO_DEFLT_ } _N_,
- tan = _A_ 1 _U_ 1 _N_ _S_ "U(P)" {_A_ 1 _U_ 2 _N_ _N_ _F_ _IF_ARGS_ 0 1 X 3 \ (u0 :: Float#) -> case _#_ tanFloat# [] [u0] of { _PRIM_ (u1 :: Float#) -> _!_ F# [] [u1] } _N_} _F_ _IF_ARGS_ 0 1 C 4 \ (u0 :: Float) -> case u0 of { _ALG_ F# (u1 :: Float#) -> case _#_ tanFloat# [] [u1] of { _PRIM_ (u2 :: Float#) -> _!_ F# [] [u2] }; _NO_DEFLT_ } _N_,
- asin = _A_ 1 _U_ 1 _N_ _S_ "U(P)" {_A_ 1 _U_ 2 _N_ _N_ _F_ _IF_ARGS_ 0 1 X 3 \ (u0 :: Float#) -> case _#_ asinFloat# [] [u0] of { _PRIM_ (u1 :: Float#) -> _!_ F# [] [u1] } _N_} _F_ _IF_ARGS_ 0 1 C 4 \ (u0 :: Float) -> case u0 of { _ALG_ F# (u1 :: Float#) -> case _#_ asinFloat# [] [u1] of { _PRIM_ (u2 :: Float#) -> _!_ F# [] [u2] }; _NO_DEFLT_ } _N_,
- acos = _A_ 1 _U_ 1 _N_ _S_ "U(P)" {_A_ 1 _U_ 2 _N_ _N_ _F_ _IF_ARGS_ 0 1 X 3 \ (u0 :: Float#) -> case _#_ acosFloat# [] [u0] of { _PRIM_ (u1 :: Float#) -> _!_ F# [] [u1] } _N_} _F_ _IF_ARGS_ 0 1 C 4 \ (u0 :: Float) -> case u0 of { _ALG_ F# (u1 :: Float#) -> case _#_ acosFloat# [] [u1] of { _PRIM_ (u2 :: Float#) -> _!_ F# [] [u2] }; _NO_DEFLT_ } _N_,
- atan = _A_ 1 _U_ 1 _N_ _S_ "U(P)" {_A_ 1 _U_ 2 _N_ _N_ _F_ _IF_ARGS_ 0 1 X 3 \ (u0 :: Float#) -> case _#_ atanFloat# [] [u0] of { _PRIM_ (u1 :: Float#) -> _!_ F# [] [u1] } _N_} _F_ _IF_ARGS_ 0 1 C 4 \ (u0 :: Float) -> case u0 of { _ALG_ F# (u1 :: Float#) -> case _#_ atanFloat# [] [u1] of { _PRIM_ (u2 :: Float#) -> _!_ F# [] [u2] }; _NO_DEFLT_ } _N_,
- sinh = _A_ 1 _U_ 1 _N_ _S_ "U(P)" {_A_ 1 _U_ 2 _N_ _N_ _F_ _IF_ARGS_ 0 1 X 3 \ (u0 :: Float#) -> case _#_ sinhFloat# [] [u0] of { _PRIM_ (u1 :: Float#) -> _!_ F# [] [u1] } _N_} _F_ _IF_ARGS_ 0 1 C 4 \ (u0 :: Float) -> case u0 of { _ALG_ F# (u1 :: Float#) -> case _#_ sinhFloat# [] [u1] of { _PRIM_ (u2 :: Float#) -> _!_ F# [] [u2] }; _NO_DEFLT_ } _N_,
- cosh = _A_ 1 _U_ 1 _N_ _S_ "U(P)" {_A_ 1 _U_ 2 _N_ _N_ _F_ _IF_ARGS_ 0 1 X 3 \ (u0 :: Float#) -> case _#_ coshFloat# [] [u0] of { _PRIM_ (u1 :: Float#) -> _!_ F# [] [u1] } _N_} _F_ _IF_ARGS_ 0 1 C 4 \ (u0 :: Float) -> case u0 of { _ALG_ F# (u1 :: Float#) -> case _#_ coshFloat# [] [u1] of { _PRIM_ (u2 :: Float#) -> _!_ F# [] [u2] }; _NO_DEFLT_ } _N_,
- tanh = _A_ 1 _U_ 1 _N_ _S_ "U(P)" {_A_ 1 _U_ 2 _N_ _N_ _F_ _IF_ARGS_ 0 1 X 3 \ (u0 :: Float#) -> case _#_ tanhFloat# [] [u0] of { _PRIM_ (u1 :: Float#) -> _!_ F# [] [u1] } _N_} _F_ _IF_ARGS_ 0 1 C 4 \ (u0 :: Float) -> case u0 of { _ALG_ F# (u1 :: Float#) -> case _#_ tanhFloat# [] [u1] of { _PRIM_ (u2 :: Float#) -> _!_ F# [] [u2] }; _NO_DEFLT_ } _N_,
- asinh = _A_ 1 _U_ 1 _N_ _S_ "U(P)" {_A_ 1 _U_ 2 _N_ _N_ _N_ _N_} _N_ _N_,
- acosh = _A_ 1 _U_ 1 _N_ _S_ "U(P)" {_A_ 1 _U_ 2 _N_ _N_ _N_ _N_} _N_ _N_,
- atanh = _A_ 1 _U_ 1 _N_ _S_ "U(P)" {_A_ 1 _U_ 2 _N_ _N_ _N_ _N_} _N_ _N_ #-}
+ pi = { _A_ 0 _N_ _N_ _N_ _F_ _IF_ARGS_ 0 0 X 2 _!_ F# [] [3.1415926535897931#] _N_ },
+ exp = { _A_ 1 _U_ 1 _N_ _S_ "U(P)" {_A_ 1 _U_ 2 _N_ _N_ _F_ _IF_ARGS_ 0 1 X 3 \ (u0 :: Float#) -> case _#_ expFloat# [] [u0] of { _PRIM_ (u1 :: Float#) -> _!_ F# [] [u1] } _N_} _F_ _IF_ARGS_ 0 1 C 4 \ (u0 :: Float) -> case u0 of { _ALG_ F# (u1 :: Float#) -> case _#_ expFloat# [] [u1] of { _PRIM_ (u2 :: Float#) -> _!_ F# [] [u2] }; _NO_DEFLT_ } _N_ },
+ log = { _A_ 1 _U_ 1 _N_ _S_ "U(P)" {_A_ 1 _U_ 2 _N_ _N_ _F_ _IF_ARGS_ 0 1 X 3 \ (u0 :: Float#) -> case _#_ logFloat# [] [u0] of { _PRIM_ (u1 :: Float#) -> _!_ F# [] [u1] } _N_} _F_ _IF_ARGS_ 0 1 C 4 \ (u0 :: Float) -> case u0 of { _ALG_ F# (u1 :: Float#) -> case _#_ logFloat# [] [u1] of { _PRIM_ (u2 :: Float#) -> _!_ F# [] [u2] }; _NO_DEFLT_ } _N_ },
+ sqrt = { _A_ 1 _U_ 1 _N_ _S_ "U(P)" {_A_ 1 _U_ 2 _N_ _N_ _F_ _IF_ARGS_ 0 1 X 3 \ (u0 :: Float#) -> case _#_ sqrtFloat# [] [u0] of { _PRIM_ (u1 :: Float#) -> _!_ F# [] [u1] } _N_} _F_ _IF_ARGS_ 0 1 C 4 \ (u0 :: Float) -> case u0 of { _ALG_ F# (u1 :: Float#) -> case _#_ sqrtFloat# [] [u1] of { _PRIM_ (u2 :: Float#) -> _!_ F# [] [u2] }; _NO_DEFLT_ } _N_ },
+ (**) = { _A_ 2 _U_ 11 _N_ _S_ "U(P)U(P)" {_A_ 2 _U_ 22 _N_ _N_ _F_ _IF_ARGS_ 0 2 XX 3 \ (u0 :: Float#) (u1 :: Float#) -> case _#_ powerFloat# [] [u0, u1] of { _PRIM_ (u2 :: Float#) -> _!_ F# [] [u2] } _N_} _F_ _IF_ARGS_ 0 2 CC 5 \ (u0 :: Float) (u1 :: Float) -> case u0 of { _ALG_ F# (u2 :: Float#) -> case u1 of { _ALG_ F# (u3 :: Float#) -> case _#_ powerFloat# [] [u2, u3] of { _PRIM_ (u4 :: Float#) -> _!_ F# [] [u4] }; _NO_DEFLT_ }; _NO_DEFLT_ } _N_ },
+ logBase = { _A_ 2 _U_ 11 _N_ _S_ "U(P)U(P)" {_A_ 2 _U_ 22 _N_ _N_ _F_ _IF_ARGS_ 0 2 XX 5 \ (u0 :: Float#) (u1 :: Float#) -> case _#_ logFloat# [] [u1] of { _PRIM_ (u2 :: Float#) -> case _#_ logFloat# [] [u0] of { _PRIM_ (u3 :: Float#) -> case _#_ divideFloat# [] [u2, u3] of { _PRIM_ (u4 :: Float#) -> _!_ F# [] [u4] } } } _N_} _F_ _IF_ARGS_ 0 2 CC 7 \ (u0 :: Float) (u1 :: Float) -> case u1 of { _ALG_ F# (u2 :: Float#) -> case _#_ logFloat# [] [u2] of { _PRIM_ (u3 :: Float#) -> case u0 of { _ALG_ F# (u4 :: Float#) -> case _#_ logFloat# [] [u4] of { _PRIM_ (u5 :: Float#) -> case _#_ divideFloat# [] [u3, u5] of { _PRIM_ (u6 :: Float#) -> _!_ F# [] [u6] } }; _NO_DEFLT_ } }; _NO_DEFLT_ } _N_ },
+ sin = { _A_ 1 _U_ 1 _N_ _S_ "U(P)" {_A_ 1 _U_ 2 _N_ _N_ _F_ _IF_ARGS_ 0 1 X 3 \ (u0 :: Float#) -> case _#_ sinFloat# [] [u0] of { _PRIM_ (u1 :: Float#) -> _!_ F# [] [u1] } _N_} _F_ _IF_ARGS_ 0 1 C 4 \ (u0 :: Float) -> case u0 of { _ALG_ F# (u1 :: Float#) -> case _#_ sinFloat# [] [u1] of { _PRIM_ (u2 :: Float#) -> _!_ F# [] [u2] }; _NO_DEFLT_ } _N_ },
+ cos = { _A_ 1 _U_ 1 _N_ _S_ "U(P)" {_A_ 1 _U_ 2 _N_ _N_ _F_ _IF_ARGS_ 0 1 X 3 \ (u0 :: Float#) -> case _#_ cosFloat# [] [u0] of { _PRIM_ (u1 :: Float#) -> _!_ F# [] [u1] } _N_} _F_ _IF_ARGS_ 0 1 C 4 \ (u0 :: Float) -> case u0 of { _ALG_ F# (u1 :: Float#) -> case _#_ cosFloat# [] [u1] of { _PRIM_ (u2 :: Float#) -> _!_ F# [] [u2] }; _NO_DEFLT_ } _N_ },
+ tan = { _A_ 1 _U_ 1 _N_ _S_ "U(P)" {_A_ 1 _U_ 2 _N_ _N_ _F_ _IF_ARGS_ 0 1 X 3 \ (u0 :: Float#) -> case _#_ tanFloat# [] [u0] of { _PRIM_ (u1 :: Float#) -> _!_ F# [] [u1] } _N_} _F_ _IF_ARGS_ 0 1 C 4 \ (u0 :: Float) -> case u0 of { _ALG_ F# (u1 :: Float#) -> case _#_ tanFloat# [] [u1] of { _PRIM_ (u2 :: Float#) -> _!_ F# [] [u2] }; _NO_DEFLT_ } _N_ },
+ asin = { _A_ 1 _U_ 1 _N_ _S_ "U(P)" {_A_ 1 _U_ 2 _N_ _N_ _F_ _IF_ARGS_ 0 1 X 3 \ (u0 :: Float#) -> case _#_ asinFloat# [] [u0] of { _PRIM_ (u1 :: Float#) -> _!_ F# [] [u1] } _N_} _F_ _IF_ARGS_ 0 1 C 4 \ (u0 :: Float) -> case u0 of { _ALG_ F# (u1 :: Float#) -> case _#_ asinFloat# [] [u1] of { _PRIM_ (u2 :: Float#) -> _!_ F# [] [u2] }; _NO_DEFLT_ } _N_ },
+ acos = { _A_ 1 _U_ 1 _N_ _S_ "U(P)" {_A_ 1 _U_ 2 _N_ _N_ _F_ _IF_ARGS_ 0 1 X 3 \ (u0 :: Float#) -> case _#_ acosFloat# [] [u0] of { _PRIM_ (u1 :: Float#) -> _!_ F# [] [u1] } _N_} _F_ _IF_ARGS_ 0 1 C 4 \ (u0 :: Float) -> case u0 of { _ALG_ F# (u1 :: Float#) -> case _#_ acosFloat# [] [u1] of { _PRIM_ (u2 :: Float#) -> _!_ F# [] [u2] }; _NO_DEFLT_ } _N_ },
+ atan = { _A_ 1 _U_ 1 _N_ _S_ "U(P)" {_A_ 1 _U_ 2 _N_ _N_ _F_ _IF_ARGS_ 0 1 X 3 \ (u0 :: Float#) -> case _#_ atanFloat# [] [u0] of { _PRIM_ (u1 :: Float#) -> _!_ F# [] [u1] } _N_} _F_ _IF_ARGS_ 0 1 C 4 \ (u0 :: Float) -> case u0 of { _ALG_ F# (u1 :: Float#) -> case _#_ atanFloat# [] [u1] of { _PRIM_ (u2 :: Float#) -> _!_ F# [] [u2] }; _NO_DEFLT_ } _N_ },
+ sinh = { _A_ 1 _U_ 1 _N_ _S_ "U(P)" {_A_ 1 _U_ 2 _N_ _N_ _F_ _IF_ARGS_ 0 1 X 3 \ (u0 :: Float#) -> case _#_ sinhFloat# [] [u0] of { _PRIM_ (u1 :: Float#) -> _!_ F# [] [u1] } _N_} _F_ _IF_ARGS_ 0 1 C 4 \ (u0 :: Float) -> case u0 of { _ALG_ F# (u1 :: Float#) -> case _#_ sinhFloat# [] [u1] of { _PRIM_ (u2 :: Float#) -> _!_ F# [] [u2] }; _NO_DEFLT_ } _N_ },
+ cosh = { _A_ 1 _U_ 1 _N_ _S_ "U(P)" {_A_ 1 _U_ 2 _N_ _N_ _F_ _IF_ARGS_ 0 1 X 3 \ (u0 :: Float#) -> case _#_ coshFloat# [] [u0] of { _PRIM_ (u1 :: Float#) -> _!_ F# [] [u1] } _N_} _F_ _IF_ARGS_ 0 1 C 4 \ (u0 :: Float) -> case u0 of { _ALG_ F# (u1 :: Float#) -> case _#_ coshFloat# [] [u1] of { _PRIM_ (u2 :: Float#) -> _!_ F# [] [u2] }; _NO_DEFLT_ } _N_ },
+ tanh = { _A_ 1 _U_ 1 _N_ _S_ "U(P)" {_A_ 1 _U_ 2 _N_ _N_ _F_ _IF_ARGS_ 0 1 X 3 \ (u0 :: Float#) -> case _#_ tanhFloat# [] [u0] of { _PRIM_ (u1 :: Float#) -> _!_ F# [] [u1] } _N_} _F_ _IF_ARGS_ 0 1 C 4 \ (u0 :: Float) -> case u0 of { _ALG_ F# (u1 :: Float#) -> case _#_ tanhFloat# [] [u1] of { _PRIM_ (u2 :: Float#) -> _!_ F# [] [u2] }; _NO_DEFLT_ } _N_ },
+ asinh = { _A_ 1 _U_ 1 _N_ _S_ "U(P)" {_A_ 1 _U_ 2 _N_ _N_ _N_ _N_} _N_ _N_ },
+ acosh = { _A_ 1 _U_ 1 _N_ _S_ "U(P)" {_A_ 1 _U_ 2 _N_ _N_ _N_ _N_} _N_ _N_ },
+ atanh = { _A_ 1 _U_ 1 _N_ _S_ "U(P)" {_A_ 1 _U_ 2 _N_ _N_ _N_ _N_} _N_ _N_ } #-}
instance RealFloat a => Fractional (Complex a)
{-# GHC_PRAGMA _M_ PreludeComplex {-dfun-} _A_ 2 _U_ 22 _N_ _N_ _N_ _N_ #-}
instance Fractional (Complex Double)
{-# GHC_PRAGMA _M_ PreludeComplex {-dfun-} _A_ 0 _N_ _N_ _N_ _F_ _IF_ARGS_ 0 0 X 5 _!_ _TUP_4 [{{Num (Complex Double)}}, (Complex Double -> Complex Double -> Complex Double), (Complex Double -> Complex Double), (Ratio Integer -> Complex Double)] [_DFUN_ Num (Complex Double), _CONSTM_ Fractional (/) (Complex Double), _CONSTM_ Fractional recip (Complex Double), _CONSTM_ Fractional fromRational (Complex Double)] _N_
- (/) = _A_ 2 _U_ 11 _N_ _S_ "U(LL)U(LL)" {_A_ 4 _U_ 2222 _N_ _N_ _N_ _N_} _N_ _N_,
- recip = _A_ 1 _U_ 1 _N_ _S_ "U(LL)" {_A_ 2 _U_ 22 _N_ _N_ _N_ _N_} _N_ _N_,
- fromRational = _A_ 1 _U_ 2 _N_ _N_ _N_ _N_ #-}
+ (/) = { _A_ 2 _U_ 11 _N_ _S_ "U(LL)U(LL)" {_A_ 4 _U_ 2222 _N_ _N_ _N_ _N_} _N_ _N_ },
+ recip = { _A_ 1 _U_ 1 _N_ _S_ "U(LL)" {_A_ 2 _U_ 22 _N_ _N_ _N_ _N_} _F_ _IF_ARGS_ 0 1 X 3 \ (u0 :: Complex Double) -> _APP_ _CONSTM_ Fractional (/) (Complex Double) [ _SPEC_ _ORIG_ PreludeCore __i1 [ (Complex Double) ], u0 ] _N_ },
+ fromRational = { _A_ 1 _U_ 1 _N_ _N_ _N_ _N_ } #-}
instance Fractional Double
{-# GHC_PRAGMA _M_ PreludeCore {-dfun-} _A_ 0 _N_ _N_ _N_ _F_ _IF_ARGS_ 0 0 X 5 _!_ _TUP_4 [{{Num Double}}, (Double -> Double -> Double), (Double -> Double), (Ratio Integer -> Double)] [_DFUN_ Num (Double), _CONSTM_ Fractional (/) (Double), _CONSTM_ Fractional recip (Double), _CONSTM_ Fractional fromRational (Double)] _N_
- (/) = _A_ 2 _U_ 11 _N_ _S_ "U(P)U(P)" {_A_ 2 _U_ 22 _N_ _N_ _F_ _IF_ARGS_ 0 2 XX 3 \ (u0 :: Double#) (u1 :: Double#) -> case _#_ divideDouble# [] [u0, u1] of { _PRIM_ (u2 :: Double#) -> _!_ D# [] [u2] } _N_} _F_ _IF_ARGS_ 0 2 CC 5 \ (u0 :: Double) (u1 :: Double) -> case u0 of { _ALG_ D# (u2 :: Double#) -> case u1 of { _ALG_ D# (u3 :: Double#) -> case _#_ divideDouble# [] [u2, u3] of { _PRIM_ (u4 :: Double#) -> _!_ D# [] [u4] }; _NO_DEFLT_ }; _NO_DEFLT_ } _N_,
- recip = _A_ 1 _U_ 1 _N_ _S_ "U(P)" {_A_ 1 _U_ 2 _N_ _N_ _F_ _IF_ARGS_ 0 1 X 3 \ (u0 :: Double#) -> case _#_ divideDouble# [] [1.0000000000000000##, u0] of { _PRIM_ (u1 :: Double#) -> _!_ D# [] [u1] } _N_} _F_ _IF_ARGS_ 0 1 C 4 \ (u0 :: Double) -> case u0 of { _ALG_ D# (u1 :: Double#) -> case _#_ divideDouble# [] [1.0000000000000000##, u1] of { _PRIM_ (u2 :: Double#) -> _!_ D# [] [u2] }; _NO_DEFLT_ } _N_,
- fromRational = _A_ 0 _U_ 2 _N_ _N_ _N_ _N_ #-}
+ (/) = { _A_ 2 _U_ 11 _N_ _S_ "U(P)U(P)" {_A_ 2 _U_ 22 _N_ _N_ _F_ _IF_ARGS_ 0 2 XX 3 \ (u0 :: Double#) (u1 :: Double#) -> case _#_ divideDouble# [] [u0, u1] of { _PRIM_ (u2 :: Double#) -> _!_ D# [] [u2] } _N_} _F_ _IF_ARGS_ 0 2 CC 5 \ (u0 :: Double) (u1 :: Double) -> case u0 of { _ALG_ D# (u2 :: Double#) -> case u1 of { _ALG_ D# (u3 :: Double#) -> case _#_ divideDouble# [] [u2, u3] of { _PRIM_ (u4 :: Double#) -> _!_ D# [] [u4] }; _NO_DEFLT_ }; _NO_DEFLT_ } _N_ },
+ recip = { _A_ 1 _U_ 1 _N_ _S_ "U(P)" {_A_ 1 _U_ 2 _N_ _N_ _F_ _IF_ARGS_ 0 1 X 3 \ (u0 :: Double#) -> case _#_ divideDouble# [] [1.0000000000000000##, u0] of { _PRIM_ (u1 :: Double#) -> _!_ D# [] [u1] } _N_} _F_ _IF_ARGS_ 0 1 C 4 \ (u0 :: Double) -> case u0 of { _ALG_ D# (u1 :: Double#) -> case _#_ divideDouble# [] [1.0000000000000000##, u1] of { _PRIM_ (u2 :: Double#) -> _!_ D# [] [u2] }; _NO_DEFLT_ } _N_ },
+ fromRational = { _A_ 1 _U_ 1 _N_ _S_ "U(U(PPP)U(PPP))" {_A_ 4 _U_ 2222 _N_ _N_ _N_ _N_} _N_ _N_ } #-}
instance Fractional Float
{-# GHC_PRAGMA _M_ PreludeCore {-dfun-} _A_ 0 _N_ _N_ _N_ _F_ _IF_ARGS_ 0 0 X 5 _!_ _TUP_4 [{{Num Float}}, (Float -> Float -> Float), (Float -> Float), (Ratio Integer -> Float)] [_DFUN_ Num (Float), _CONSTM_ Fractional (/) (Float), _CONSTM_ Fractional recip (Float), _CONSTM_ Fractional fromRational (Float)] _N_
- (/) = _A_ 2 _U_ 11 _N_ _S_ "U(P)U(P)" {_A_ 2 _U_ 22 _N_ _N_ _F_ _IF_ARGS_ 0 2 XX 3 \ (u0 :: Float#) (u1 :: Float#) -> case _#_ divideFloat# [] [u0, u1] of { _PRIM_ (u2 :: Float#) -> _!_ F# [] [u2] } _N_} _F_ _IF_ARGS_ 0 2 CC 5 \ (u0 :: Float) (u1 :: Float) -> case u0 of { _ALG_ F# (u2 :: Float#) -> case u1 of { _ALG_ F# (u3 :: Float#) -> case _#_ divideFloat# [] [u2, u3] of { _PRIM_ (u4 :: Float#) -> _!_ F# [] [u4] }; _NO_DEFLT_ }; _NO_DEFLT_ } _N_,
- recip = _A_ 0 _U_ 2 _N_ _N_ _N_ _N_,
- fromRational = _A_ 0 _U_ 2 _N_ _N_ _N_ _N_ #-}
+ (/) = { _A_ 2 _U_ 11 _N_ _S_ "U(P)U(P)" {_A_ 2 _U_ 22 _N_ _N_ _F_ _IF_ARGS_ 0 2 XX 3 \ (u0 :: Float#) (u1 :: Float#) -> case _#_ divideFloat# [] [u0, u1] of { _PRIM_ (u2 :: Float#) -> _!_ F# [] [u2] } _N_} _F_ _IF_ARGS_ 0 2 CC 5 \ (u0 :: Float) (u1 :: Float) -> case u0 of { _ALG_ F# (u2 :: Float#) -> case u1 of { _ALG_ F# (u3 :: Float#) -> case _#_ divideFloat# [] [u2, u3] of { _PRIM_ (u4 :: Float#) -> _!_ F# [] [u4] }; _NO_DEFLT_ }; _NO_DEFLT_ } _N_ },
+ recip = { _A_ 1 _U_ 1 _N_ _S_ "U(P)" {_A_ 1 _U_ 2 _N_ _N_ _F_ _IF_ARGS_ 0 1 X 3 \ (u0 :: Float#) -> case _#_ divideFloat# [] [1.0000000000000000#, u0] of { _PRIM_ (u1 :: Float#) -> _!_ F# [] [u1] } _N_} _F_ _IF_ARGS_ 0 1 C 4 \ (u0 :: Float) -> case u0 of { _ALG_ F# (u1 :: Float#) -> case _#_ divideFloat# [] [1.0000000000000000#, u1] of { _PRIM_ (u2 :: Float#) -> _!_ F# [] [u2] }; _NO_DEFLT_ } _N_ },
+ fromRational = { _A_ 1 _U_ 2 _N_ _N_ _N_ _N_ } #-}
instance Integral a => Fractional (Ratio a)
{-# GHC_PRAGMA _M_ PreludeRatio {-dfun-} _A_ 2 _U_ 22 _N_ _N_ _N_ _N_ #-}
instance Fractional (Ratio Integer)
{-# GHC_PRAGMA _M_ PreludeRatio {-dfun-} _A_ 0 _N_ _N_ _N_ _F_ _IF_ARGS_ 0 0 X 5 _!_ _TUP_4 [{{Num (Ratio Integer)}}, (Ratio Integer -> Ratio Integer -> Ratio Integer), (Ratio Integer -> Ratio Integer), (Ratio Integer -> Ratio Integer)] [_DFUN_ Num (Ratio Integer), _CONSTM_ Fractional (/) (Ratio Integer), _CONSTM_ Fractional recip (Ratio Integer), _CONSTM_ Fractional fromRational (Ratio Integer)] _N_
- (/) = _A_ 2 _U_ 11 _N_ _S_ "U(LU(PPP))U(U(PPP)L)" {_A_ 5 _U_ 22221 _N_ _N_ _N_ _N_} _N_ _N_,
- recip = _A_ 1 _U_ 1 _N_ _S_ "U(U(PPP)L)" {_A_ 4 _U_ 2222 _N_ _N_ _N_ _N_} _N_ _N_,
- fromRational = _A_ 1 _U_ 1 _N_ _S_ "U(LL)" {_A_ 2 _U_ 22 _N_ _N_ _F_ _IF_ARGS_ 0 2 XX 3 \ (u0 :: Integer) (u1 :: Integer) -> _!_ (:%) [Integer] [u0, u1] _N_} _F_ _IF_ARGS_ 0 1 X 1 \ (u0 :: Ratio Integer) -> u0 _N_ #-}
+ (/) = { _A_ 2 _U_ 11 _N_ _S_ "U(LU(PPP))U(U(PPP)L)" {_A_ 5 _U_ 22221 _N_ _N_ _N_ _N_} _N_ _N_ },
+ recip = { _A_ 1 _U_ 1 _N_ _S_ "U(U(PPP)L)" {_A_ 4 _U_ 2222 _N_ _N_ _N_ _N_} _N_ _N_ },
+ fromRational = { _A_ 1 _U_ 1 _N_ _S_ "U(LL)" {_A_ 2 _U_ 22 _N_ _N_ _F_ _IF_ARGS_ 0 2 XX 3 \ (u0 :: Integer) (u1 :: Integer) -> _!_ (:%) [Integer] [u0, u1] _N_} _F_ _IF_ARGS_ 0 1 X 1 \ (u0 :: Ratio Integer) -> u0 _N_ } #-}
instance Integral Int
{-# GHC_PRAGMA _M_ PreludeCore {-dfun-} _A_ 0 _N_ _N_ _N_ _F_ _IF_ARGS_ 0 0 X 13 _!_ _TUP_12 [{{Real Int}}, {{Ix Int}}, (Int -> Int -> Int), (Int -> Int -> Int), (Int -> Int -> Int), (Int -> Int -> Int), (Int -> Int -> (Int, Int)), (Int -> Int -> (Int, Int)), (Int -> Bool), (Int -> Bool), (Int -> Integer), (Int -> Int)] [_DFUN_ Real (Int), _DFUN_ Ix (Int), _CONSTM_ Integral quot (Int), _CONSTM_ Integral rem (Int), _CONSTM_ Integral div (Int), _CONSTM_ Integral mod (Int), _CONSTM_ Integral quotRem (Int), _CONSTM_ Integral divMod (Int), _CONSTM_ Integral even (Int), _CONSTM_ Integral odd (Int), _CONSTM_ Integral toInteger (Int), _CONSTM_ Integral toInt (Int)] _N_
- quot = _A_ 2 _U_ 11 _N_ _S_ "U(P)U(P)" {_A_ 2 _U_ 22 _N_ _N_ _F_ _IF_ARGS_ 0 2 XC 5 \ (u0 :: Int#) (u1 :: Int#) -> case u1 of { _PRIM_ 0# -> _APP_ _TYAPP_ error { Int } [ _NOREP_S_ "Integral.Int.quot{PreludeCore}: divide by 0\n" ]; (u2 :: Int#) -> case _#_ quotInt# [] [u0, u1] of { _PRIM_ (u3 :: Int#) -> _!_ I# [] [u3] } } _N_} _F_ _IF_ARGS_ 0 2 CC 7 \ (u0 :: Int) (u1 :: Int) -> case u1 of { _ALG_ I# (u2 :: Int#) -> case u2 of { _PRIM_ 0# -> _APP_ _TYAPP_ error { Int } [ _NOREP_S_ "Integral.Int.quot{PreludeCore}: divide by 0\n" ]; (u3 :: Int#) -> case u0 of { _ALG_ I# (u4 :: Int#) -> case _#_ quotInt# [] [u4, u2] of { _PRIM_ (u5 :: Int#) -> _!_ I# [] [u5] }; _NO_DEFLT_ } }; _NO_DEFLT_ } _N_,
- rem = _A_ 2 _U_ 11 _N_ _S_ "U(P)U(P)" {_A_ 2 _U_ 22 _N_ _N_ _F_ _IF_ARGS_ 0 2 XC 5 \ (u0 :: Int#) (u1 :: Int#) -> case u1 of { _PRIM_ 0# -> _APP_ _TYAPP_ error { Int } [ _NOREP_S_ "Integral.Int.rem{PreludeCore}: divide by 0\n" ]; (u2 :: Int#) -> case _#_ remInt# [] [u0, u1] of { _PRIM_ (u3 :: Int#) -> _!_ I# [] [u3] } } _N_} _F_ _IF_ARGS_ 0 2 CC 7 \ (u0 :: Int) (u1 :: Int) -> case u1 of { _ALG_ I# (u2 :: Int#) -> case u2 of { _PRIM_ 0# -> _APP_ _TYAPP_ error { Int } [ _NOREP_S_ "Integral.Int.rem{PreludeCore}: divide by 0\n" ]; (u3 :: Int#) -> case u0 of { _ALG_ I# (u4 :: Int#) -> case _#_ remInt# [] [u4, u2] of { _PRIM_ (u5 :: Int#) -> _!_ I# [] [u5] }; _NO_DEFLT_ } }; _NO_DEFLT_ } _N_,
- div = _A_ 2 _U_ 11 _N_ _S_ "U(P)U(P)" {_A_ 2 _U_ 22 _N_ _N_ _N_ _N_} _N_ _N_,
- mod = _A_ 2 _U_ 11 _N_ _S_ "U(P)U(P)" {_A_ 2 _U_ 22 _N_ _N_ _N_ _N_} _N_ _N_,
- quotRem = _A_ 2 _U_ 11 _N_ _S_ "U(P)U(P)" {_A_ 2 _U_ 22 _N_ _N_ _N_ _N_} _N_ _N_,
- divMod = _A_ 2 _U_ 11 _N_ _S_ "U(P)U(P)" {_A_ 2 _U_ 22 _N_ _N_ _N_ _N_} _N_ _N_,
- even = _A_ 1 _U_ 1 _N_ _S_ "U(P)" {_A_ 1 _U_ 2 _N_ _N_ _N_ _N_} _N_ _N_,
- odd = _A_ 1 _U_ 1 _N_ _S_ "U(P)" {_A_ 1 _U_ 2 _N_ _N_ _N_ _N_} _N_ _N_,
- toInteger = _A_ 1 _U_ 1 _N_ _S_ "U(P)" {_A_ 1 _U_ 2 _N_ _N_ _F_ _IF_ARGS_ 0 1 X 1 \ (u0 :: Int#) -> _#_ int2Integer# [] [u0] _N_} _F_ _IF_ARGS_ 0 1 C 2 \ (u0 :: Int) -> case u0 of { _ALG_ I# (u1 :: Int#) -> _#_ int2Integer# [] [u1]; _NO_DEFLT_ } _N_,
- toInt = _A_ 1 _U_ 1 _N_ _S_ "U(P)" {_A_ 1 _U_ 2 _N_ _N_ _F_ _IF_ARGS_ 0 1 X 2 \ (u0 :: Int#) -> _!_ I# [] [u0] _N_} _F_ _IF_ARGS_ 0 1 X 1 \ (u0 :: Int) -> u0 _N_ #-}
+ quot = { _A_ 2 _U_ 11 _N_ _S_ "U(P)U(P)" {_A_ 2 _U_ 22 _N_ _N_ _F_ _IF_ARGS_ 0 2 XC 5 \ (u0 :: Int#) (u1 :: Int#) -> case u1 of { _PRIM_ 0# -> _APP_ _TYAPP_ error { Int } [ _NOREP_S_ "Integral.Int.quot{PreludeCore}: divide by 0\n" ]; (u2 :: Int#) -> case _#_ quotInt# [] [u0, u1] of { _PRIM_ (u3 :: Int#) -> _!_ I# [] [u3] } } _N_} _F_ _IF_ARGS_ 0 2 CC 7 \ (u0 :: Int) (u1 :: Int) -> case u1 of { _ALG_ I# (u2 :: Int#) -> case u2 of { _PRIM_ 0# -> _APP_ _TYAPP_ error { Int } [ _NOREP_S_ "Integral.Int.quot{PreludeCore}: divide by 0\n" ]; (u3 :: Int#) -> case u0 of { _ALG_ I# (u4 :: Int#) -> case _#_ quotInt# [] [u4, u2] of { _PRIM_ (u5 :: Int#) -> _!_ I# [] [u5] }; _NO_DEFLT_ } }; _NO_DEFLT_ } _N_ },
+ rem = { _A_ 2 _U_ 11 _N_ _S_ "U(P)U(P)" {_A_ 2 _U_ 22 _N_ _N_ _F_ _IF_ARGS_ 0 2 XC 5 \ (u0 :: Int#) (u1 :: Int#) -> case u1 of { _PRIM_ 0# -> _APP_ _TYAPP_ error { Int } [ _NOREP_S_ "Integral.Int.rem{PreludeCore}: divide by 0\n" ]; (u2 :: Int#) -> case _#_ remInt# [] [u0, u1] of { _PRIM_ (u3 :: Int#) -> _!_ I# [] [u3] } } _N_} _F_ _IF_ARGS_ 0 2 CC 7 \ (u0 :: Int) (u1 :: Int) -> case u1 of { _ALG_ I# (u2 :: Int#) -> case u2 of { _PRIM_ 0# -> _APP_ _TYAPP_ error { Int } [ _NOREP_S_ "Integral.Int.rem{PreludeCore}: divide by 0\n" ]; (u3 :: Int#) -> case u0 of { _ALG_ I# (u4 :: Int#) -> case _#_ remInt# [] [u4, u2] of { _PRIM_ (u5 :: Int#) -> _!_ I# [] [u5] }; _NO_DEFLT_ } }; _NO_DEFLT_ } _N_ },
+ div = { _A_ 2 _U_ 11 _N_ _S_ "U(P)U(P)" {_A_ 2 _U_ 22 _N_ _N_ _N_ _N_} _N_ _N_ },
+ mod = { _A_ 2 _U_ 11 _N_ _S_ "U(P)U(P)" {_A_ 2 _U_ 22 _N_ _N_ _N_ _N_} _N_ _N_ },
+ quotRem = { _A_ 2 _U_ 11 _N_ _S_ "U(P)U(P)" {_A_ 2 _U_ 22 _N_ _N_ _N_ _N_} _N_ _N_ },
+ divMod = { _A_ 2 _U_ 11 _N_ _S_ "U(P)U(P)" {_A_ 2 _U_ 22 _N_ _N_ _N_ _N_} _N_ _N_ },
+ even = { _A_ 1 _U_ 1 _N_ _S_ "U(P)" {_A_ 1 _U_ 2 _N_ _N_ _N_ _N_} _N_ _N_ },
+ odd = { _A_ 1 _U_ 1 _N_ _S_ "U(P)" {_A_ 1 _U_ 2 _N_ _N_ _N_ _N_} _N_ _N_ },
+ toInteger = { _A_ 1 _U_ 1 _N_ _S_ "U(P)" {_A_ 1 _U_ 2 _N_ _N_ _F_ _IF_ARGS_ 0 1 X 1 \ (u0 :: Int#) -> _#_ int2Integer# [] [u0] _N_} _F_ _IF_ARGS_ 0 1 C 2 \ (u0 :: Int) -> case u0 of { _ALG_ I# (u1 :: Int#) -> _#_ int2Integer# [] [u1]; _NO_DEFLT_ } _N_ },
+ toInt = { _A_ 1 _U_ 1 _N_ _S_ "U(P)" {_A_ 1 _U_ 2 _N_ _N_ _F_ _IF_ARGS_ 0 1 X 2 \ (u0 :: Int#) -> _!_ I# [] [u0] _N_} _F_ _IF_ARGS_ 0 1 X 1 \ (u0 :: Int) -> u0 _N_ } #-}
instance Integral Integer
{-# GHC_PRAGMA _M_ PreludeCore {-dfun-} _A_ 0 _N_ _N_ _N_ _F_ _IF_ARGS_ 0 0 X 13 _!_ _TUP_12 [{{Real Integer}}, {{Ix Integer}}, (Integer -> Integer -> Integer), (Integer -> Integer -> Integer), (Integer -> Integer -> Integer), (Integer -> Integer -> Integer), (Integer -> Integer -> (Integer, Integer)), (Integer -> Integer -> (Integer, Integer)), (Integer -> Bool), (Integer -> Bool), (Integer -> Integer), (Integer -> Int)] [_DFUN_ Real (Integer), _DFUN_ Ix (Integer), _CONSTM_ Integral quot (Integer), _CONSTM_ Integral rem (Integer), _CONSTM_ Integral div (Integer), _CONSTM_ Integral mod (Integer), _CONSTM_ Integral quotRem (Integer), _CONSTM_ Integral divMod (Integer), _CONSTM_ Integral even (Integer), _CONSTM_ Integral odd (Integer), _CONSTM_ Integral toInteger (Integer), _CONSTM_ Integral toInt (Integer)] _N_
- quot = _A_ 2 _U_ 11 _N_ _S_ "U(PPP)U(PPP)" {_A_ 4 _U_ 2221 _N_ _N_ _F_ _IF_ARGS_ 0 4 XXXX 7 \ (u0 :: Int#) (u1 :: Int#) (u2 :: ByteArray#) (u3 :: Integer) -> case _APP_ _WRKR_ _CONSTM_ Integral quotRem (Integer) [ u0, u1, u2, u3 ] of { _ALG_ _TUP_2 (u4 :: Integer) (u5 :: Integer) -> u4; _NO_DEFLT_ } _N_} _F_ _IF_ARGS_ 0 2 XX 5 \ (u0 :: Integer) (u1 :: Integer) -> case _APP_ _CONSTM_ Integral quotRem (Integer) [ u0, u1 ] of { _ALG_ _TUP_2 (u2 :: Integer) (u3 :: Integer) -> u2; _NO_DEFLT_ } _N_,
- rem = _A_ 2 _U_ 11 _N_ _S_ "U(PPP)U(PPP)" {_A_ 4 _U_ 2221 _N_ _N_ _F_ _IF_ARGS_ 0 4 XXXX 7 \ (u0 :: Int#) (u1 :: Int#) (u2 :: ByteArray#) (u3 :: Integer) -> case _APP_ _WRKR_ _CONSTM_ Integral quotRem (Integer) [ u0, u1, u2, u3 ] of { _ALG_ _TUP_2 (u4 :: Integer) (u5 :: Integer) -> u5; _NO_DEFLT_ } _N_} _F_ _IF_ARGS_ 0 2 XX 5 \ (u0 :: Integer) (u1 :: Integer) -> case _APP_ _CONSTM_ Integral quotRem (Integer) [ u0, u1 ] of { _ALG_ _TUP_2 (u2 :: Integer) (u3 :: Integer) -> u3; _NO_DEFLT_ } _N_,
- div = _A_ 2 _U_ 12 _N_ _S_ "U(PPP)U(PPP)" {_A_ 4 _U_ 2222 _N_ _N_ _F_ _IF_ARGS_ 0 4 XXXX 7 \ (u0 :: Int#) (u1 :: Int#) (u2 :: ByteArray#) (u3 :: Integer) -> case _APP_ _WRKR_ _CONSTM_ Integral divMod (Integer) [ u0, u1, u2, u3 ] of { _ALG_ _TUP_2 (u4 :: Integer) (u5 :: Integer) -> u4; _NO_DEFLT_ } _N_} _F_ _IF_ARGS_ 0 2 XX 5 \ (u0 :: Integer) (u1 :: Integer) -> case _APP_ _CONSTM_ Integral divMod (Integer) [ u0, u1 ] of { _ALG_ _TUP_2 (u2 :: Integer) (u3 :: Integer) -> u2; _NO_DEFLT_ } _N_,
- mod = _A_ 2 _U_ 12 _N_ _S_ "U(PPP)U(PPP)" {_A_ 4 _U_ 2222 _N_ _N_ _F_ _IF_ARGS_ 0 4 XXXX 7 \ (u0 :: Int#) (u1 :: Int#) (u2 :: ByteArray#) (u3 :: Integer) -> case _APP_ _WRKR_ _CONSTM_ Integral divMod (Integer) [ u0, u1, u2, u3 ] of { _ALG_ _TUP_2 (u4 :: Integer) (u5 :: Integer) -> u5; _NO_DEFLT_ } _N_} _F_ _IF_ARGS_ 0 2 XX 5 \ (u0 :: Integer) (u1 :: Integer) -> case _APP_ _CONSTM_ Integral divMod (Integer) [ u0, u1 ] of { _ALG_ _TUP_2 (u2 :: Integer) (u3 :: Integer) -> u3; _NO_DEFLT_ } _N_,
- quotRem = _A_ 2 _U_ 11 _N_ _S_ "U(PPP)U(PPP)" {_A_ 4 _U_ 2221 _N_ _N_ _N_ _N_} _N_ _N_,
- divMod = _A_ 2 _U_ 12 _N_ _S_ "U(PPP)U(PPP)" {_A_ 4 _U_ 2222 _N_ _N_ _N_ _N_} _N_ _N_,
- even = _A_ 1 _U_ 1 _N_ _S_ "U(PPP)" {_A_ 3 _U_ 222 _N_ _N_ _N_ _N_} _N_ _N_,
- odd = _A_ 1 _U_ 1 _N_ _S_ "U(PPP)" {_A_ 3 _U_ 222 _N_ _N_ _N_ _N_} _N_ _N_,
- toInteger = _A_ 1 _U_ 1 _N_ _S_ "U(PPP)" {_A_ 3 _U_ 222 _N_ _N_ _F_ _IF_ARGS_ 0 3 XXX 4 \ (u0 :: Int#) (u1 :: Int#) (u2 :: ByteArray#) -> _!_ J# [] [u0, u1, u2] _N_} _F_ _IF_ARGS_ 0 1 X 1 \ (u0 :: Integer) -> u0 _N_,
- toInt = _A_ 1 _U_ 1 _N_ _S_ "U(PPP)" {_A_ 3 _U_ 222 _N_ _N_ _F_ _IF_ARGS_ 0 3 XXX 3 \ (u0 :: Int#) (u1 :: Int#) (u2 :: ByteArray#) -> case _#_ integer2Int# [] [u0, u1, u2] of { _PRIM_ (u3 :: Int#) -> _!_ I# [] [u3] } _N_} _F_ _IF_ARGS_ 0 1 C 4 \ (u0 :: Integer) -> case u0 of { _ALG_ J# (u1 :: Int#) (u2 :: Int#) (u3 :: ByteArray#) -> case _#_ integer2Int# [] [u1, u2, u3] of { _PRIM_ (u4 :: Int#) -> _!_ I# [] [u4] }; _NO_DEFLT_ } _N_ #-}
+ quot = { _A_ 2 _U_ 11 _N_ _S_ "U(PPP)U(PPP)" {_A_ 4 _U_ 2221 _N_ _N_ _F_ _IF_ARGS_ 0 4 XXXX 7 \ (u0 :: Int#) (u1 :: Int#) (u2 :: ByteArray#) (u3 :: Integer) -> case _APP_ _WRKR_ _CONSTM_ Integral quotRem (Integer) [ u0, u1, u2, u3 ] of { _ALG_ _TUP_2 (u4 :: Integer) (u5 :: Integer) -> u4; _NO_DEFLT_ } _N_} _F_ _IF_ARGS_ 0 2 XX 5 \ (u0 :: Integer) (u1 :: Integer) -> case _APP_ _CONSTM_ Integral quotRem (Integer) [ u0, u1 ] of { _ALG_ _TUP_2 (u2 :: Integer) (u3 :: Integer) -> u2; _NO_DEFLT_ } _N_ },
+ rem = { _A_ 2 _U_ 11 _N_ _S_ "U(PPP)U(PPP)" {_A_ 4 _U_ 2221 _N_ _N_ _F_ _IF_ARGS_ 0 4 XXXX 7 \ (u0 :: Int#) (u1 :: Int#) (u2 :: ByteArray#) (u3 :: Integer) -> case _APP_ _WRKR_ _CONSTM_ Integral quotRem (Integer) [ u0, u1, u2, u3 ] of { _ALG_ _TUP_2 (u4 :: Integer) (u5 :: Integer) -> u5; _NO_DEFLT_ } _N_} _F_ _IF_ARGS_ 0 2 XX 5 \ (u0 :: Integer) (u1 :: Integer) -> case _APP_ _CONSTM_ Integral quotRem (Integer) [ u0, u1 ] of { _ALG_ _TUP_2 (u2 :: Integer) (u3 :: Integer) -> u3; _NO_DEFLT_ } _N_ },
+ div = { _A_ 2 _U_ 12 _N_ _S_ "U(PPP)U(PPP)" {_A_ 4 _U_ 2222 _N_ _N_ _F_ _IF_ARGS_ 0 4 XXXX 7 \ (u0 :: Int#) (u1 :: Int#) (u2 :: ByteArray#) (u3 :: Integer) -> case _APP_ _WRKR_ _CONSTM_ Integral divMod (Integer) [ u0, u1, u2, u3 ] of { _ALG_ _TUP_2 (u4 :: Integer) (u5 :: Integer) -> u4; _NO_DEFLT_ } _N_} _F_ _IF_ARGS_ 0 2 XX 5 \ (u0 :: Integer) (u1 :: Integer) -> case _APP_ _CONSTM_ Integral divMod (Integer) [ u0, u1 ] of { _ALG_ _TUP_2 (u2 :: Integer) (u3 :: Integer) -> u2; _NO_DEFLT_ } _N_ },
+ mod = { _A_ 2 _U_ 12 _N_ _S_ "U(PPP)U(PPP)" {_A_ 4 _U_ 2222 _N_ _N_ _F_ _IF_ARGS_ 0 4 XXXX 7 \ (u0 :: Int#) (u1 :: Int#) (u2 :: ByteArray#) (u3 :: Integer) -> case _APP_ _WRKR_ _CONSTM_ Integral divMod (Integer) [ u0, u1, u2, u3 ] of { _ALG_ _TUP_2 (u4 :: Integer) (u5 :: Integer) -> u5; _NO_DEFLT_ } _N_} _F_ _IF_ARGS_ 0 2 XX 5 \ (u0 :: Integer) (u1 :: Integer) -> case _APP_ _CONSTM_ Integral divMod (Integer) [ u0, u1 ] of { _ALG_ _TUP_2 (u2 :: Integer) (u3 :: Integer) -> u3; _NO_DEFLT_ } _N_ },
+ quotRem = { _A_ 2 _U_ 11 _N_ _S_ "U(PPP)U(PPP)" {_A_ 4 _U_ 2221 _N_ _N_ _N_ _N_} _N_ _N_ },
+ divMod = { _A_ 2 _U_ 12 _N_ _S_ "U(PPP)U(PPP)" {_A_ 4 _U_ 2222 _N_ _N_ _N_ _N_} _N_ _N_ },
+ even = { _A_ 1 _U_ 1 _N_ _S_ "U(PPP)" {_A_ 3 _U_ 222 _N_ _N_ _N_ _N_} _N_ _N_ },
+ odd = { _A_ 1 _U_ 1 _N_ _S_ "U(PPP)" {_A_ 3 _U_ 222 _N_ _N_ _N_ _N_} _N_ _N_ },
+ toInteger = { _A_ 1 _U_ 1 _N_ _S_ "U(PPP)" {_A_ 3 _U_ 222 _N_ _N_ _F_ _IF_ARGS_ 0 3 XXX 4 \ (u0 :: Int#) (u1 :: Int#) (u2 :: ByteArray#) -> _!_ J# [] [u0, u1, u2] _N_} _F_ _IF_ARGS_ 0 1 X 1 \ (u0 :: Integer) -> u0 _N_ },
+ toInt = { _A_ 1 _U_ 1 _N_ _S_ "U(PPP)" {_A_ 3 _U_ 222 _N_ _N_ _F_ _IF_ARGS_ 0 3 XXX 3 \ (u0 :: Int#) (u1 :: Int#) (u2 :: ByteArray#) -> case _#_ integer2Int# [] [u0, u1, u2] of { _PRIM_ (u3 :: Int#) -> _!_ I# [] [u3] } _N_} _F_ _IF_ARGS_ 0 1 C 4 \ (u0 :: Integer) -> case u0 of { _ALG_ J# (u1 :: Int#) (u2 :: Int#) (u3 :: ByteArray#) -> case _#_ integer2Int# [] [u1, u2, u3] of { _PRIM_ (u4 :: Int#) -> _!_ I# [] [u4] }; _NO_DEFLT_ } _N_ } #-}
instance Ix ()
{-# GHC_PRAGMA _M_ PreludeBuiltin {-dfun-} _A_ 0 _N_ _N_ _N_ _F_ _IF_ARGS_ 0 0 X 5 _!_ _TUP_4 [{{Ord ()}}, (((), ()) -> [()]), (((), ()) -> () -> Int), (((), ()) -> () -> Bool)] [_DFUN_ Ord (()), _CONSTM_ Ix range (()), _CONSTM_ Ix index (()), _CONSTM_ Ix inRange (())] _N_
- range = _A_ 1 _U_ 1 _N_ _S_ "U(EE)" {_A_ 2 _U_ 21 _N_ _N_ _N_ _N_} _N_ _N_,
- index = _A_ 2 _U_ 11 _N_ _S_ "U(EE)E" {_A_ 3 _U_ 111 _N_ _N_ _F_ _IF_ARGS_ 0 3 CCC 5 \ (u0 :: ()) (u1 :: ()) (u2 :: ()) -> case u0 of { _ALG_ _TUP_0 -> case u1 of { _ALG_ _TUP_0 -> case u2 of { _ALG_ _TUP_0 -> _!_ I# [] [0#]; _NO_DEFLT_ }; _NO_DEFLT_ }; _NO_DEFLT_ } _N_} _F_ _IF_ARGS_ 0 2 CC 6 \ (u0 :: ((), ())) (u1 :: ()) -> case u0 of { _ALG_ _TUP_2 (u2 :: ()) (u3 :: ()) -> case u2 of { _ALG_ _TUP_0 -> case u3 of { _ALG_ _TUP_0 -> case u1 of { _ALG_ _TUP_0 -> _!_ I# [] [0#]; _NO_DEFLT_ }; _NO_DEFLT_ }; _NO_DEFLT_ }; _NO_DEFLT_ } _N_,
- inRange = _A_ 2 _U_ 11 _N_ _S_ "U(EE)E" {_A_ 3 _U_ 111 _N_ _N_ _F_ _IF_ARGS_ 0 3 CCC 4 \ (u0 :: ()) (u1 :: ()) (u2 :: ()) -> case u0 of { _ALG_ _TUP_0 -> case u1 of { _ALG_ _TUP_0 -> case u2 of { _ALG_ _TUP_0 -> _!_ True [] []; _NO_DEFLT_ }; _NO_DEFLT_ }; _NO_DEFLT_ } _N_} _F_ _IF_ARGS_ 0 2 CC 5 \ (u0 :: ((), ())) (u1 :: ()) -> case u0 of { _ALG_ _TUP_2 (u2 :: ()) (u3 :: ()) -> case u2 of { _ALG_ _TUP_0 -> case u3 of { _ALG_ _TUP_0 -> case u1 of { _ALG_ _TUP_0 -> _!_ True [] []; _NO_DEFLT_ }; _NO_DEFLT_ }; _NO_DEFLT_ }; _NO_DEFLT_ } _N_ #-}
+ range = { _A_ 1 _U_ 1 _N_ _S_ "U(EE)" {_A_ 2 _U_ 21 _N_ _N_ _N_ _N_} _N_ _N_ },
+ index = { _A_ 2 _U_ 11 _N_ _S_ "U(EE)E" {_A_ 3 _U_ 111 _N_ _N_ _F_ _IF_ARGS_ 0 3 CCC 5 \ (u0 :: ()) (u1 :: ()) (u2 :: ()) -> case u0 of { _ALG_ _TUP_0 -> case u1 of { _ALG_ _TUP_0 -> case u2 of { _ALG_ _TUP_0 -> _!_ I# [] [0#]; _NO_DEFLT_ }; _NO_DEFLT_ }; _NO_DEFLT_ } _N_} _F_ _IF_ARGS_ 0 2 CC 6 \ (u0 :: ((), ())) (u1 :: ()) -> case u0 of { _ALG_ _TUP_2 (u2 :: ()) (u3 :: ()) -> case u2 of { _ALG_ _TUP_0 -> case u3 of { _ALG_ _TUP_0 -> case u1 of { _ALG_ _TUP_0 -> _!_ I# [] [0#]; _NO_DEFLT_ }; _NO_DEFLT_ }; _NO_DEFLT_ }; _NO_DEFLT_ } _N_ },
+ inRange = { _A_ 2 _U_ 11 _N_ _S_ "U(EE)E" {_A_ 3 _U_ 111 _N_ _N_ _F_ _IF_ARGS_ 0 3 CCC 4 \ (u0 :: ()) (u1 :: ()) (u2 :: ()) -> case u0 of { _ALG_ _TUP_0 -> case u1 of { _ALG_ _TUP_0 -> case u2 of { _ALG_ _TUP_0 -> _!_ True [] []; _NO_DEFLT_ }; _NO_DEFLT_ }; _NO_DEFLT_ } _N_} _F_ _IF_ARGS_ 0 2 CC 5 \ (u0 :: ((), ())) (u1 :: ()) -> case u0 of { _ALG_ _TUP_2 (u2 :: ()) (u3 :: ()) -> case u2 of { _ALG_ _TUP_0 -> case u3 of { _ALG_ _TUP_0 -> case u1 of { _ALG_ _TUP_0 -> _!_ True [] []; _NO_DEFLT_ }; _NO_DEFLT_ }; _NO_DEFLT_ }; _NO_DEFLT_ } _N_ } #-}
instance (Ix a, Ix b) => Ix (a, b)
{-# GHC_PRAGMA _M_ PreludeBuiltin {-dfun-} _A_ 3 _U_ 222 _N_ _N_ _N_ _N_ #-}
instance (Ix a, Ix b, Ix c) => Ix (a, b, c)
{-# GHC_PRAGMA _M_ PreludeBuiltin {-dfun-} _A_ 6 _U_ 222222 _N_ _N_ _N_ _N_ #-}
instance Ix (Int, Int)
{-# GHC_PRAGMA _M_ PreludeBuiltin {-dfun-} _A_ 0 _N_ _N_ _N_ _F_ _IF_ARGS_ 0 0 X 5 _!_ _TUP_4 [{{Ord (Int, Int)}}, (((Int, Int), (Int, Int)) -> [(Int, Int)]), (((Int, Int), (Int, Int)) -> (Int, Int) -> Int), (((Int, Int), (Int, Int)) -> (Int, Int) -> Bool)] [_DFUN_ Ord ((Int, Int)), _CONSTM_ Ix range ((Int, Int)), _CONSTM_ Ix index ((Int, Int)), _CONSTM_ Ix inRange ((Int, Int))] _N_
- range = _A_ 1 _U_ 1 _N_ _S_ "U(SS)" {_A_ 2 _U_ 11 _N_ _N_ _N_ _N_} _N_ _N_,
- index = _A_ 2 _U_ 11 _N_ _S_ "U(SS)U(U(P)U(P))" {_A_ 4 _U_ 1122 _N_ _N_ _N_ _N_} _N_ _N_,
- inRange = _A_ 2 _U_ 11 _N_ _S_ "U(SS)U(U(P)L)" {_A_ 4 _U_ 1121 _N_ _N_ _N_ _N_} _N_ _N_ #-}
+ range = { _A_ 1 _U_ 1 _N_ _S_ "U(SS)" {_A_ 2 _U_ 11 _N_ _N_ _N_ _N_} _N_ _N_ },
+ index = { _A_ 2 _U_ 11 _N_ _S_ "U(SS)U(U(P)U(P))" {_A_ 4 _U_ 1122 _N_ _N_ _N_ _N_} _N_ _N_ },
+ inRange = { _A_ 2 _U_ 11 _N_ _S_ "U(SS)U(U(P)L)" {_A_ 4 _U_ 1121 _N_ _N_ _N_ _N_} _N_ _N_ } #-}
instance (Ix a, Ix b) => Ix (Assoc a b)
{-# GHC_PRAGMA _M_ PreludeArray {-dfun-} _A_ 3 _U_ 222 _N_ _N_ _N_ _N_ #-}
instance Ix Bool
{-# GHC_PRAGMA _M_ PreludeCore {-dfun-} _A_ 0 _N_ _N_ _N_ _F_ _IF_ARGS_ 0 0 X 5 _!_ _TUP_4 [{{Ord Bool}}, ((Bool, Bool) -> [Bool]), ((Bool, Bool) -> Bool -> Int), ((Bool, Bool) -> Bool -> Bool)] [_DFUN_ Ord (Bool), _CONSTM_ Ix range (Bool), _CONSTM_ Ix index (Bool), _CONSTM_ Ix inRange (Bool)] _N_
- range = _A_ 1 _U_ 1 _N_ _S_ "U(EE)" {_A_ 2 _U_ 11 _N_ _N_ _N_ _N_} _N_ _N_,
- index = _A_ 2 _U_ 11 _N_ _S_ "U(EA)E" {_A_ 2 _U_ 11 _N_ _N_ _N_ _N_} _N_ _N_,
- inRange = _A_ 2 _U_ 12 _N_ _S_ "U(EL)E" {_A_ 3 _U_ 112 _N_ _N_ _N_ _N_} _N_ _N_ #-}
+ range = { _A_ 1 _U_ 1 _N_ _S_ "U(EE)" {_A_ 2 _U_ 11 _N_ _N_ _N_ _N_} _N_ _N_ },
+ index = { _A_ 2 _U_ 11 _N_ _S_ "U(EA)E" {_A_ 2 _U_ 11 _N_ _N_ _N_ _N_} _N_ _N_ },
+ inRange = { _A_ 2 _U_ 12 _N_ _S_ "U(EL)E" {_A_ 3 _U_ 112 _N_ _N_ _N_ _N_} _N_ _N_ } #-}
instance Ix Char
{-# GHC_PRAGMA _M_ PreludeCore {-dfun-} _A_ 0 _N_ _N_ _N_ _F_ _IF_ARGS_ 0 0 X 5 _!_ _TUP_4 [{{Ord Char}}, ((Char, Char) -> [Char]), ((Char, Char) -> Char -> Int), ((Char, Char) -> Char -> Bool)] [_DFUN_ Ord (Char), _CONSTM_ Ix range (Char), _CONSTM_ Ix index (Char), _CONSTM_ Ix inRange (Char)] _N_
- range = _A_ 1 _U_ 1 _N_ _S_ "U(LL)" {_A_ 2 _U_ 22 _N_ _N_ _F_ _IF_ARGS_ 0 0 X 1 _CONSTM_ Enum enumFromTo (Char) _N_} _F_ _IF_ARGS_ 0 1 C 4 \ (u0 :: (Char, Char)) -> case u0 of { _ALG_ _TUP_2 (u1 :: Char) (u2 :: Char) -> _APP_ _CONSTM_ Enum enumFromTo (Char) [ u1, u2 ]; _NO_DEFLT_ } _N_,
- index = _A_ 2 _U_ 11 _N_ _S_ "U(U(P)L)U(P)" {_A_ 3 _U_ 212 _N_ _N_ _N_ _N_} _N_ _N_,
- inRange = _A_ 2 _U_ 11 _N_ _S_ "U(U(P)L)U(P)" {_A_ 3 _U_ 212 _N_ _N_ _N_ _N_} _N_ _N_ #-}
+ range = { _A_ 1 _U_ 1 _N_ _S_ "U(U(P)L)" {_A_ 2 _U_ 22 _N_ _N_ _N_ _N_} _F_ _IF_ARGS_ 0 1 C 4 \ (u0 :: (Char, Char)) -> case u0 of { _ALG_ _TUP_2 (u1 :: Char) (u2 :: Char) -> _APP_ _CONSTM_ Enum enumFromTo (Char) [ u1, u2 ]; _NO_DEFLT_ } _N_ },
+ index = { _A_ 2 _U_ 11 _N_ _S_ "U(U(P)L)U(P)" {_A_ 3 _U_ 212 _N_ _N_ _N_ _N_} _N_ _N_ },
+ inRange = { _A_ 2 _U_ 11 _N_ _S_ "U(U(P)L)U(P)" {_A_ 3 _U_ 212 _N_ _N_ _N_ _N_} _N_ _N_ } #-}
instance Ix Int
{-# GHC_PRAGMA _M_ PreludeCore {-dfun-} _A_ 0 _N_ _N_ _N_ _F_ _IF_ARGS_ 0 0 X 5 _!_ _TUP_4 [{{Ord Int}}, ((Int, Int) -> [Int]), ((Int, Int) -> Int -> Int), ((Int, Int) -> Int -> Bool)] [_DFUN_ Ord (Int), _CONSTM_ Ix range (Int), _CONSTM_ Ix index (Int), _CONSTM_ Ix inRange (Int)] _N_
- range = _A_ 1 _U_ 1 _N_ _S_ "U(U(P)U(P))" {_A_ 2 _U_ 22 _N_ _N_ _N_ _N_} _N_ _N_,
- index = _A_ 2 _U_ 11 _N_ _S_ "U(U(P)U(P))U(P)" {_A_ 3 _U_ 222 _N_ _N_ _N_ _N_} _N_ _N_,
- inRange = _A_ 2 _U_ 11 _N_ _S_ "U(U(P)U(P))U(P)" {_A_ 3 _U_ 222 _N_ _N_ _F_ _IF_ARGS_ 0 3 XXX 5 \ (u0 :: Int#) (u1 :: Int#) (u2 :: Int#) -> case _#_ leInt# [] [u0, u2] of { _ALG_ True -> _#_ leInt# [] [u2, u1]; False -> _!_ False [] []; _NO_DEFLT_ } _N_} _F_ _ALWAYS_ \ (u0 :: (Int, Int)) (u1 :: Int) -> case u0 of { _ALG_ _TUP_2 (u2 :: Int) (u3 :: Int) -> case u2 of { _ALG_ I# (u4 :: Int#) -> case u3 of { _ALG_ I# (u5 :: Int#) -> case u1 of { _ALG_ I# (u6 :: Int#) -> case _#_ leInt# [] [u4, u6] of { _ALG_ True -> _#_ leInt# [] [u6, u5]; False -> _!_ False [] []; _NO_DEFLT_ }; _NO_DEFLT_ }; _NO_DEFLT_ }; _NO_DEFLT_ }; _NO_DEFLT_ } _N_ #-}
+ range = { _A_ 1 _U_ 1 _N_ _S_ "U(U(P)U(P))" {_A_ 2 _U_ 22 _N_ _N_ _N_ _N_} _N_ _N_ },
+ index = { _A_ 2 _U_ 11 _N_ _S_ "U(U(P)U(P))U(P)" {_A_ 3 _U_ 222 _N_ _N_ _N_ _N_} _N_ _N_ },
+ inRange = { _A_ 2 _U_ 11 _N_ _S_ "U(U(P)U(P))U(P)" {_A_ 3 _U_ 222 _N_ _N_ _F_ _IF_ARGS_ 0 3 XXX 5 \ (u0 :: Int#) (u1 :: Int#) (u2 :: Int#) -> case _#_ leInt# [] [u0, u2] of { _ALG_ True -> _#_ leInt# [] [u2, u1]; False -> _!_ False [] []; _NO_DEFLT_ } _N_} _F_ _ALWAYS_ \ (u0 :: (Int, Int)) (u1 :: Int) -> case u0 of { _ALG_ _TUP_2 (u2 :: Int) (u3 :: Int) -> case u2 of { _ALG_ I# (u4 :: Int#) -> case u3 of { _ALG_ I# (u5 :: Int#) -> case u1 of { _ALG_ I# (u6 :: Int#) -> case _#_ leInt# [] [u4, u6] of { _ALG_ True -> _#_ leInt# [] [u6, u5]; False -> _!_ False [] []; _NO_DEFLT_ }; _NO_DEFLT_ }; _NO_DEFLT_ }; _NO_DEFLT_ }; _NO_DEFLT_ } _N_ } #-}
instance Ix Integer
{-# GHC_PRAGMA _M_ PreludeCore {-dfun-} _A_ 0 _N_ _N_ _N_ _F_ _IF_ARGS_ 0 0 X 5 _!_ _TUP_4 [{{Ord Integer}}, ((Integer, Integer) -> [Integer]), ((Integer, Integer) -> Integer -> Int), ((Integer, Integer) -> Integer -> Bool)] [_DFUN_ Ord (Integer), _CONSTM_ Ix range (Integer), _CONSTM_ Ix index (Integer), _CONSTM_ Ix inRange (Integer)] _N_
- range = _A_ 1 _U_ 1 _N_ _S_ "U(LL)" {_A_ 2 _U_ 22 _N_ _N_ _F_ _IF_ARGS_ 0 0 X 1 _CONSTM_ Enum enumFromTo (Integer) _N_} _F_ _IF_ARGS_ 0 1 C 4 \ (u0 :: (Integer, Integer)) -> case u0 of { _ALG_ _TUP_2 (u1 :: Integer) (u2 :: Integer) -> _APP_ _CONSTM_ Enum enumFromTo (Integer) [ u1, u2 ]; _NO_DEFLT_ } _N_,
- index = _A_ 2 _U_ 12 _N_ _S_ "U(U(PPP)L)U(PPP)" {_A_ 5 _U_ 22222 _N_ _N_ _N_ _N_} _N_ _N_,
- inRange = _A_ 2 _U_ 11 _N_ _S_ "U(U(PPP)L)U(PPP)" {_A_ 5 _U_ 22211 _N_ _N_ _F_ _IF_ARGS_ 0 5 XXXCC 9 \ (u0 :: Int#) (u1 :: Int#) (u2 :: ByteArray#) (u3 :: Integer) (u4 :: Integer) -> case u4 of { _ALG_ J# (u5 :: Int#) (u6 :: Int#) (u7 :: ByteArray#) -> case _#_ cmpInteger# [] [u0, u1, u2, u5, u6, u7] of { _PRIM_ (u8 :: Int#) -> case _#_ leInt# [] [u8, 0#] of { _ALG_ True -> case u3 of { _ALG_ J# (u9 :: Int#) (ua :: Int#) (ub :: ByteArray#) -> case _#_ cmpInteger# [] [u5, u6, u7, u9, ua, ub] of { _PRIM_ (uc :: Int#) -> _#_ leInt# [] [uc, 0#] }; _NO_DEFLT_ }; False -> _!_ False [] []; _NO_DEFLT_ } }; _NO_DEFLT_ } _N_} _N_ _N_ #-}
+ range = { _A_ 1 _U_ 1 _N_ _S_ "U(LL)" {_A_ 2 _U_ 22 _N_ _N_ _F_ _IF_ARGS_ 0 0 X 1 _CONSTM_ Enum enumFromTo (Integer) _N_} _F_ _IF_ARGS_ 0 1 C 4 \ (u0 :: (Integer, Integer)) -> case u0 of { _ALG_ _TUP_2 (u1 :: Integer) (u2 :: Integer) -> _APP_ _CONSTM_ Enum enumFromTo (Integer) [ u1, u2 ]; _NO_DEFLT_ } _N_ },
+ index = { _A_ 2 _U_ 12 _N_ _S_ "U(U(PPP)L)U(PPP)" {_A_ 5 _U_ 22222 _N_ _N_ _N_ _N_} _N_ _N_ },
+ inRange = { _A_ 2 _U_ 11 _N_ _S_ "U(U(PPP)L)U(PPP)" {_A_ 5 _U_ 22211 _N_ _N_ _F_ _IF_ARGS_ 0 5 XXXCC 9 \ (u0 :: Int#) (u1 :: Int#) (u2 :: ByteArray#) (u3 :: Integer) (u4 :: Integer) -> case u4 of { _ALG_ J# (u5 :: Int#) (u6 :: Int#) (u7 :: ByteArray#) -> case _#_ cmpInteger# [] [u0, u1, u2, u5, u6, u7] of { _PRIM_ (u8 :: Int#) -> case _#_ leInt# [] [u8, 0#] of { _ALG_ True -> case u3 of { _ALG_ J# (u9 :: Int#) (ua :: Int#) (ub :: ByteArray#) -> case _#_ cmpInteger# [] [u5, u6, u7, u9, ua, ub] of { _PRIM_ (uc :: Int#) -> _#_ leInt# [] [uc, 0#] }; _NO_DEFLT_ }; False -> _!_ False [] []; _NO_DEFLT_ } }; _NO_DEFLT_ } _N_} _N_ _N_ } #-}
instance RealFloat a => Num (Complex a)
{-# GHC_PRAGMA _M_ PreludeComplex {-dfun-} _A_ 3 _U_ 222 _N_ _N_ _N_ _N_ #-}
instance Num (Complex Double)
- {-# GHC_PRAGMA _M_ PreludeComplex {-dfun-} _A_ 0 _N_ _N_ _N_ _N_ _N_
- (+) = _A_ 2 _U_ 11 _N_ _S_ "U(LL)U(LL)" {_A_ 4 _U_ 1111 _N_ _N_ _N_ _N_} _N_ _N_,
- (-) = _A_ 2 _U_ 11 _N_ _S_ "U(LL)U(LL)" {_A_ 4 _U_ 1111 _N_ _N_ _N_ _N_} _N_ _N_,
- (*) = _A_ 2 _U_ 11 _N_ _S_ "U(LL)U(LL)" {_A_ 4 _U_ 2222 _N_ _N_ _N_ _N_} _N_ _N_,
- negate = _A_ 1 _U_ 1 _N_ _S_ "U(LL)" {_A_ 2 _U_ 11 _N_ _N_ _N_ _N_} _N_ _N_,
- abs = _A_ 1 _U_ 1 _N_ _N_ _N_ _N_,
- signum = _A_ 1 _U_ 1 _N_ _S_ "U(U(P)L)" {_A_ 2 _U_ 22 _N_ _N_ _N_ _N_} _N_ _N_,
- fromInteger = _A_ 1 _U_ 1 _N_ _N_ _N_ _N_,
- fromInt = _A_ 1 _U_ 1 _N_ _N_ _N_ _N_ #-}
+ {-# GHC_PRAGMA _M_ PreludeComplex {-dfun-} _A_ 0 _N_ _N_ _N_ _F_ _IF_ARGS_ 0 0 X 11 _!_ _TUP_10 [{{Eq (Complex Double)}}, {{Text (Complex Double)}}, (Complex Double -> Complex Double -> Complex Double), (Complex Double -> Complex Double -> Complex Double), (Complex Double -> Complex Double -> Complex Double), (Complex Double -> Complex Double), (Complex Double -> Complex Double), (Complex Double -> Complex Double), (Integer -> Complex Double), (Int -> Complex Double)] [_DFUN_ Eq (Complex Double), _DFUN_ Text (Complex Double), _CONSTM_ Num (+) (Complex Double), _CONSTM_ Num (-) (Complex Double), _CONSTM_ Num (*) (Complex Double), _CONSTM_ Num negate (Complex Double), _CONSTM_ Num abs (Complex Double), _CONSTM_ Num signum (Complex Double), _CONSTM_ Num fromInteger (Complex Double), _CONSTM_ Num fromInt (Complex Double)] _N_
+ (+) = { _A_ 2 _U_ 11 _N_ _S_ "U(LL)U(LL)" {_A_ 4 _U_ 1111 _N_ _N_ _N_ _N_} _N_ _N_ },
+ (-) = { _A_ 2 _U_ 11 _N_ _S_ "U(LL)U(LL)" {_A_ 4 _U_ 1111 _N_ _N_ _N_ _N_} _N_ _N_ },
+ (*) = { _A_ 2 _U_ 11 _N_ _S_ "U(LL)U(LL)" {_A_ 4 _U_ 2222 _N_ _N_ _N_ _N_} _N_ _N_ },
+ negate = { _A_ 1 _U_ 1 _N_ _S_ "U(LL)" {_A_ 2 _U_ 11 _N_ _N_ _N_ _N_} _N_ _N_ },
+ abs = { _A_ 1 _U_ 1 _N_ _N_ _N_ _N_ },
+ signum = { _A_ 1 _U_ 1 _N_ _S_ "U(U(P)L)" {_A_ 2 _U_ 22 _N_ _N_ _N_ _N_} _N_ _N_ },
+ fromInteger = { _A_ 1 _U_ 1 _N_ _N_ _N_ _N_ },
+ fromInt = { _A_ 1 _U_ 1 _N_ _N_ _N_ _N_ } #-}
instance Num Double
{-# GHC_PRAGMA _M_ PreludeCore {-dfun-} _A_ 0 _N_ _N_ _N_ _F_ _IF_ARGS_ 0 0 X 11 _!_ _TUP_10 [{{Eq Double}}, {{Text Double}}, (Double -> Double -> Double), (Double -> Double -> Double), (Double -> Double -> Double), (Double -> Double), (Double -> Double), (Double -> Double), (Integer -> Double), (Int -> Double)] [_DFUN_ Eq (Double), _DFUN_ Text (Double), _CONSTM_ Num (+) (Double), _CONSTM_ Num (-) (Double), _CONSTM_ Num (*) (Double), _CONSTM_ Num negate (Double), _CONSTM_ Num abs (Double), _CONSTM_ Num signum (Double), _CONSTM_ Num fromInteger (Double), _CONSTM_ Num fromInt (Double)] _N_
- (+) = _A_ 2 _U_ 11 _N_ _S_ "U(P)U(P)" {_A_ 2 _U_ 22 _N_ _N_ _F_ _IF_ARGS_ 0 2 XX 3 \ (u0 :: Double#) (u1 :: Double#) -> case _#_ plusDouble# [] [u0, u1] of { _PRIM_ (u2 :: Double#) -> _!_ D# [] [u2] } _N_} _F_ _IF_ARGS_ 0 2 CC 5 \ (u0 :: Double) (u1 :: Double) -> case u0 of { _ALG_ D# (u2 :: Double#) -> case u1 of { _ALG_ D# (u3 :: Double#) -> case _#_ plusDouble# [] [u2, u3] of { _PRIM_ (u4 :: Double#) -> _!_ D# [] [u4] }; _NO_DEFLT_ }; _NO_DEFLT_ } _N_,
- (-) = _A_ 2 _U_ 11 _N_ _S_ "U(P)U(P)" {_A_ 2 _U_ 22 _N_ _N_ _F_ _IF_ARGS_ 0 2 XX 3 \ (u0 :: Double#) (u1 :: Double#) -> case _#_ minusDouble# [] [u0, u1] of { _PRIM_ (u2 :: Double#) -> _!_ D# [] [u2] } _N_} _F_ _IF_ARGS_ 0 2 CC 5 \ (u0 :: Double) (u1 :: Double) -> case u0 of { _ALG_ D# (u2 :: Double#) -> case u1 of { _ALG_ D# (u3 :: Double#) -> case _#_ minusDouble# [] [u2, u3] of { _PRIM_ (u4 :: Double#) -> _!_ D# [] [u4] }; _NO_DEFLT_ }; _NO_DEFLT_ } _N_,
- (*) = _A_ 2 _U_ 11 _N_ _S_ "U(P)U(P)" {_A_ 2 _U_ 22 _N_ _N_ _F_ _IF_ARGS_ 0 2 XX 3 \ (u0 :: Double#) (u1 :: Double#) -> case _#_ timesDouble# [] [u0, u1] of { _PRIM_ (u2 :: Double#) -> _!_ D# [] [u2] } _N_} _F_ _IF_ARGS_ 0 2 CC 5 \ (u0 :: Double) (u1 :: Double) -> case u0 of { _ALG_ D# (u2 :: Double#) -> case u1 of { _ALG_ D# (u3 :: Double#) -> case _#_ timesDouble# [] [u2, u3] of { _PRIM_ (u4 :: Double#) -> _!_ D# [] [u4] }; _NO_DEFLT_ }; _NO_DEFLT_ } _N_,
- negate = _A_ 1 _U_ 1 _N_ _S_ "U(P)" {_A_ 1 _U_ 2 _N_ _N_ _F_ _IF_ARGS_ 0 1 X 3 \ (u0 :: Double#) -> case _#_ negateDouble# [] [u0] of { _PRIM_ (u1 :: Double#) -> _!_ D# [] [u1] } _N_} _F_ _IF_ARGS_ 0 1 C 4 \ (u0 :: Double) -> case u0 of { _ALG_ D# (u1 :: Double#) -> case _#_ negateDouble# [] [u1] of { _PRIM_ (u2 :: Double#) -> _!_ D# [] [u2] }; _NO_DEFLT_ } _N_,
- abs = _A_ 1 _U_ 1 _N_ _S_ "U(P)" {_A_ 1 _U_ 2 _N_ _N_ _N_ _N_} _N_ _N_,
- signum = _A_ 1 _U_ 1 _N_ _S_ "U(P)" {_A_ 1 _U_ 2 _N_ _N_ _N_ _N_} _N_ _N_,
- fromInteger = _A_ 1 _U_ 1 _N_ _S_ "U(PPP)" {_A_ 3 _U_ 222 _N_ _N_ _F_ _IF_ARGS_ 0 3 XXX 3 \ (u0 :: Int#) (u1 :: Int#) (u2 :: ByteArray#) -> case _#_ encodeDouble# [] [u0, u1, u2, 0#] of { _PRIM_ (u3 :: Double#) -> _!_ D# [] [u3] } _N_} _F_ _IF_ARGS_ 0 1 C 4 \ (u0 :: Integer) -> case u0 of { _ALG_ J# (u1 :: Int#) (u2 :: Int#) (u3 :: ByteArray#) -> case _#_ encodeDouble# [] [u1, u2, u3, 0#] of { _PRIM_ (u4 :: Double#) -> _!_ D# [] [u4] }; _NO_DEFLT_ } _N_,
- fromInt = _A_ 1 _U_ 1 _N_ _S_ "U(P)" {_A_ 1 _U_ 2 _N_ _N_ _F_ _IF_ARGS_ 0 1 X 3 \ (u0 :: Int#) -> case _#_ int2Double# [] [u0] of { _PRIM_ (u1 :: Double#) -> _!_ D# [] [u1] } _N_} _F_ _IF_ARGS_ 0 1 C 4 \ (u0 :: Int) -> case u0 of { _ALG_ I# (u1 :: Int#) -> case _#_ int2Double# [] [u1] of { _PRIM_ (u2 :: Double#) -> _!_ D# [] [u2] }; _NO_DEFLT_ } _N_ #-}
+ (+) = { _A_ 2 _U_ 11 _N_ _S_ "U(P)U(P)" {_A_ 2 _U_ 22 _N_ _N_ _F_ _IF_ARGS_ 0 2 XX 3 \ (u0 :: Double#) (u1 :: Double#) -> case _#_ plusDouble# [] [u0, u1] of { _PRIM_ (u2 :: Double#) -> _!_ D# [] [u2] } _N_} _F_ _IF_ARGS_ 0 2 CC 5 \ (u0 :: Double) (u1 :: Double) -> case u0 of { _ALG_ D# (u2 :: Double#) -> case u1 of { _ALG_ D# (u3 :: Double#) -> case _#_ plusDouble# [] [u2, u3] of { _PRIM_ (u4 :: Double#) -> _!_ D# [] [u4] }; _NO_DEFLT_ }; _NO_DEFLT_ } _N_ },
+ (-) = { _A_ 2 _U_ 11 _N_ _S_ "U(P)U(P)" {_A_ 2 _U_ 22 _N_ _N_ _F_ _IF_ARGS_ 0 2 XX 3 \ (u0 :: Double#) (u1 :: Double#) -> case _#_ minusDouble# [] [u0, u1] of { _PRIM_ (u2 :: Double#) -> _!_ D# [] [u2] } _N_} _F_ _IF_ARGS_ 0 2 CC 5 \ (u0 :: Double) (u1 :: Double) -> case u0 of { _ALG_ D# (u2 :: Double#) -> case u1 of { _ALG_ D# (u3 :: Double#) -> case _#_ minusDouble# [] [u2, u3] of { _PRIM_ (u4 :: Double#) -> _!_ D# [] [u4] }; _NO_DEFLT_ }; _NO_DEFLT_ } _N_ },
+ (*) = { _A_ 2 _U_ 11 _N_ _S_ "U(P)U(P)" {_A_ 2 _U_ 22 _N_ _N_ _F_ _IF_ARGS_ 0 2 XX 3 \ (u0 :: Double#) (u1 :: Double#) -> case _#_ timesDouble# [] [u0, u1] of { _PRIM_ (u2 :: Double#) -> _!_ D# [] [u2] } _N_} _F_ _IF_ARGS_ 0 2 CC 5 \ (u0 :: Double) (u1 :: Double) -> case u0 of { _ALG_ D# (u2 :: Double#) -> case u1 of { _ALG_ D# (u3 :: Double#) -> case _#_ timesDouble# [] [u2, u3] of { _PRIM_ (u4 :: Double#) -> _!_ D# [] [u4] }; _NO_DEFLT_ }; _NO_DEFLT_ } _N_ },
+ negate = { _A_ 1 _U_ 1 _N_ _S_ "U(P)" {_A_ 1 _U_ 2 _N_ _N_ _F_ _IF_ARGS_ 0 1 X 3 \ (u0 :: Double#) -> case _#_ negateDouble# [] [u0] of { _PRIM_ (u1 :: Double#) -> _!_ D# [] [u1] } _N_} _F_ _IF_ARGS_ 0 1 C 4 \ (u0 :: Double) -> case u0 of { _ALG_ D# (u1 :: Double#) -> case _#_ negateDouble# [] [u1] of { _PRIM_ (u2 :: Double#) -> _!_ D# [] [u2] }; _NO_DEFLT_ } _N_ },
+ abs = { _A_ 1 _U_ 1 _N_ _S_ "U(P)" {_A_ 1 _U_ 2 _N_ _N_ _N_ _N_} _N_ _N_ },
+ signum = { _A_ 1 _U_ 1 _N_ _S_ "U(P)" {_A_ 1 _U_ 2 _N_ _N_ _N_ _N_} _N_ _N_ },
+ fromInteger = { _A_ 1 _U_ 1 _N_ _S_ "U(PPP)" {_A_ 3 _U_ 222 _N_ _N_ _F_ _IF_ARGS_ 0 3 XXX 3 \ (u0 :: Int#) (u1 :: Int#) (u2 :: ByteArray#) -> case _#_ encodeDouble# [] [u0, u1, u2, 0#] of { _PRIM_ (u3 :: Double#) -> _!_ D# [] [u3] } _N_} _F_ _IF_ARGS_ 0 1 C 4 \ (u0 :: Integer) -> case u0 of { _ALG_ J# (u1 :: Int#) (u2 :: Int#) (u3 :: ByteArray#) -> case _#_ encodeDouble# [] [u1, u2, u3, 0#] of { _PRIM_ (u4 :: Double#) -> _!_ D# [] [u4] }; _NO_DEFLT_ } _N_ },
+ fromInt = { _A_ 1 _U_ 1 _N_ _S_ "U(P)" {_A_ 1 _U_ 2 _N_ _N_ _F_ _IF_ARGS_ 0 1 X 3 \ (u0 :: Int#) -> case _#_ int2Double# [] [u0] of { _PRIM_ (u1 :: Double#) -> _!_ D# [] [u1] } _N_} _F_ _IF_ARGS_ 0 1 C 4 \ (u0 :: Int) -> case u0 of { _ALG_ I# (u1 :: Int#) -> case _#_ int2Double# [] [u1] of { _PRIM_ (u2 :: Double#) -> _!_ D# [] [u2] }; _NO_DEFLT_ } _N_ } #-}
instance Num Float
{-# GHC_PRAGMA _M_ PreludeCore {-dfun-} _A_ 0 _N_ _N_ _N_ _F_ _IF_ARGS_ 0 0 X 11 _!_ _TUP_10 [{{Eq Float}}, {{Text Float}}, (Float -> Float -> Float), (Float -> Float -> Float), (Float -> Float -> Float), (Float -> Float), (Float -> Float), (Float -> Float), (Integer -> Float), (Int -> Float)] [_DFUN_ Eq (Float), _DFUN_ Text (Float), _CONSTM_ Num (+) (Float), _CONSTM_ Num (-) (Float), _CONSTM_ Num (*) (Float), _CONSTM_ Num negate (Float), _CONSTM_ Num abs (Float), _CONSTM_ Num signum (Float), _CONSTM_ Num fromInteger (Float), _CONSTM_ Num fromInt (Float)] _N_
- (+) = _A_ 2 _U_ 11 _N_ _S_ "U(P)U(P)" {_A_ 2 _U_ 22 _N_ _N_ _F_ _IF_ARGS_ 0 2 XX 3 \ (u0 :: Float#) (u1 :: Float#) -> case _#_ plusFloat# [] [u0, u1] of { _PRIM_ (u2 :: Float#) -> _!_ F# [] [u2] } _N_} _F_ _IF_ARGS_ 0 2 CC 5 \ (u0 :: Float) (u1 :: Float) -> case u0 of { _ALG_ F# (u2 :: Float#) -> case u1 of { _ALG_ F# (u3 :: Float#) -> case _#_ plusFloat# [] [u2, u3] of { _PRIM_ (u4 :: Float#) -> _!_ F# [] [u4] }; _NO_DEFLT_ }; _NO_DEFLT_ } _N_,
- (-) = _A_ 2 _U_ 11 _N_ _S_ "U(P)U(P)" {_A_ 2 _U_ 22 _N_ _N_ _F_ _IF_ARGS_ 0 2 XX 3 \ (u0 :: Float#) (u1 :: Float#) -> case _#_ minusFloat# [] [u0, u1] of { _PRIM_ (u2 :: Float#) -> _!_ F# [] [u2] } _N_} _F_ _IF_ARGS_ 0 2 CC 5 \ (u0 :: Float) (u1 :: Float) -> case u0 of { _ALG_ F# (u2 :: Float#) -> case u1 of { _ALG_ F# (u3 :: Float#) -> case _#_ minusFloat# [] [u2, u3] of { _PRIM_ (u4 :: Float#) -> _!_ F# [] [u4] }; _NO_DEFLT_ }; _NO_DEFLT_ } _N_,
- (*) = _A_ 2 _U_ 11 _N_ _S_ "U(P)U(P)" {_A_ 2 _U_ 22 _N_ _N_ _F_ _IF_ARGS_ 0 2 XX 3 \ (u0 :: Float#) (u1 :: Float#) -> case _#_ timesFloat# [] [u0, u1] of { _PRIM_ (u2 :: Float#) -> _!_ F# [] [u2] } _N_} _F_ _IF_ARGS_ 0 2 CC 5 \ (u0 :: Float) (u1 :: Float) -> case u0 of { _ALG_ F# (u2 :: Float#) -> case u1 of { _ALG_ F# (u3 :: Float#) -> case _#_ timesFloat# [] [u2, u3] of { _PRIM_ (u4 :: Float#) -> _!_ F# [] [u4] }; _NO_DEFLT_ }; _NO_DEFLT_ } _N_,
- negate = _A_ 1 _U_ 1 _N_ _S_ "U(P)" {_A_ 1 _U_ 2 _N_ _N_ _F_ _IF_ARGS_ 0 1 X 3 \ (u0 :: Float#) -> case _#_ negateFloat# [] [u0] of { _PRIM_ (u1 :: Float#) -> _!_ F# [] [u1] } _N_} _F_ _IF_ARGS_ 0 1 C 4 \ (u0 :: Float) -> case u0 of { _ALG_ F# (u1 :: Float#) -> case _#_ negateFloat# [] [u1] of { _PRIM_ (u2 :: Float#) -> _!_ F# [] [u2] }; _NO_DEFLT_ } _N_,
- abs = _A_ 1 _U_ 1 _N_ _S_ "U(P)" {_A_ 1 _U_ 2 _N_ _N_ _N_ _N_} _N_ _N_,
- signum = _A_ 1 _U_ 1 _N_ _S_ "U(P)" {_A_ 1 _U_ 2 _N_ _N_ _N_ _N_} _N_ _N_,
- fromInteger = _A_ 1 _U_ 1 _N_ _S_ "U(PPP)" {_A_ 3 _U_ 222 _N_ _N_ _F_ _IF_ARGS_ 0 3 XXX 3 \ (u0 :: Int#) (u1 :: Int#) (u2 :: ByteArray#) -> case _#_ encodeFloat# [] [u0, u1, u2, 0#] of { _PRIM_ (u3 :: Float#) -> _!_ F# [] [u3] } _N_} _F_ _IF_ARGS_ 0 1 C 4 \ (u0 :: Integer) -> case u0 of { _ALG_ J# (u1 :: Int#) (u2 :: Int#) (u3 :: ByteArray#) -> case _#_ encodeFloat# [] [u1, u2, u3, 0#] of { _PRIM_ (u4 :: Float#) -> _!_ F# [] [u4] }; _NO_DEFLT_ } _N_,
- fromInt = _A_ 1 _U_ 1 _N_ _S_ "U(P)" {_A_ 1 _U_ 2 _N_ _N_ _F_ _IF_ARGS_ 0 1 X 3 \ (u0 :: Int#) -> case _#_ int2Float# [] [u0] of { _PRIM_ (u1 :: Float#) -> _!_ F# [] [u1] } _N_} _F_ _IF_ARGS_ 0 1 C 4 \ (u0 :: Int) -> case u0 of { _ALG_ I# (u1 :: Int#) -> case _#_ int2Float# [] [u1] of { _PRIM_ (u2 :: Float#) -> _!_ F# [] [u2] }; _NO_DEFLT_ } _N_ #-}
+ (+) = { _A_ 2 _U_ 11 _N_ _S_ "U(P)U(P)" {_A_ 2 _U_ 22 _N_ _N_ _F_ _IF_ARGS_ 0 2 XX 3 \ (u0 :: Float#) (u1 :: Float#) -> case _#_ plusFloat# [] [u0, u1] of { _PRIM_ (u2 :: Float#) -> _!_ F# [] [u2] } _N_} _F_ _IF_ARGS_ 0 2 CC 5 \ (u0 :: Float) (u1 :: Float) -> case u0 of { _ALG_ F# (u2 :: Float#) -> case u1 of { _ALG_ F# (u3 :: Float#) -> case _#_ plusFloat# [] [u2, u3] of { _PRIM_ (u4 :: Float#) -> _!_ F# [] [u4] }; _NO_DEFLT_ }; _NO_DEFLT_ } _N_ },
+ (-) = { _A_ 2 _U_ 11 _N_ _S_ "U(P)U(P)" {_A_ 2 _U_ 22 _N_ _N_ _F_ _IF_ARGS_ 0 2 XX 3 \ (u0 :: Float#) (u1 :: Float#) -> case _#_ minusFloat# [] [u0, u1] of { _PRIM_ (u2 :: Float#) -> _!_ F# [] [u2] } _N_} _F_ _IF_ARGS_ 0 2 CC 5 \ (u0 :: Float) (u1 :: Float) -> case u0 of { _ALG_ F# (u2 :: Float#) -> case u1 of { _ALG_ F# (u3 :: Float#) -> case _#_ minusFloat# [] [u2, u3] of { _PRIM_ (u4 :: Float#) -> _!_ F# [] [u4] }; _NO_DEFLT_ }; _NO_DEFLT_ } _N_ },
+ (*) = { _A_ 2 _U_ 11 _N_ _S_ "U(P)U(P)" {_A_ 2 _U_ 22 _N_ _N_ _F_ _IF_ARGS_ 0 2 XX 3 \ (u0 :: Float#) (u1 :: Float#) -> case _#_ timesFloat# [] [u0, u1] of { _PRIM_ (u2 :: Float#) -> _!_ F# [] [u2] } _N_} _F_ _IF_ARGS_ 0 2 CC 5 \ (u0 :: Float) (u1 :: Float) -> case u0 of { _ALG_ F# (u2 :: Float#) -> case u1 of { _ALG_ F# (u3 :: Float#) -> case _#_ timesFloat# [] [u2, u3] of { _PRIM_ (u4 :: Float#) -> _!_ F# [] [u4] }; _NO_DEFLT_ }; _NO_DEFLT_ } _N_ },
+ negate = { _A_ 1 _U_ 1 _N_ _S_ "U(P)" {_A_ 1 _U_ 2 _N_ _N_ _F_ _IF_ARGS_ 0 1 X 3 \ (u0 :: Float#) -> case _#_ negateFloat# [] [u0] of { _PRIM_ (u1 :: Float#) -> _!_ F# [] [u1] } _N_} _F_ _IF_ARGS_ 0 1 C 4 \ (u0 :: Float) -> case u0 of { _ALG_ F# (u1 :: Float#) -> case _#_ negateFloat# [] [u1] of { _PRIM_ (u2 :: Float#) -> _!_ F# [] [u2] }; _NO_DEFLT_ } _N_ },
+ abs = { _A_ 1 _U_ 1 _N_ _S_ "U(P)" {_A_ 1 _U_ 2 _N_ _N_ _N_ _N_} _N_ _N_ },
+ signum = { _A_ 1 _U_ 1 _N_ _S_ "U(P)" {_A_ 1 _U_ 2 _N_ _N_ _N_ _N_} _N_ _N_ },
+ fromInteger = { _A_ 1 _U_ 1 _N_ _S_ "U(PPP)" {_A_ 3 _U_ 222 _N_ _N_ _F_ _IF_ARGS_ 0 3 XXX 3 \ (u0 :: Int#) (u1 :: Int#) (u2 :: ByteArray#) -> case _#_ encodeFloat# [] [u0, u1, u2, 0#] of { _PRIM_ (u3 :: Float#) -> _!_ F# [] [u3] } _N_} _F_ _IF_ARGS_ 0 1 C 4 \ (u0 :: Integer) -> case u0 of { _ALG_ J# (u1 :: Int#) (u2 :: Int#) (u3 :: ByteArray#) -> case _#_ encodeFloat# [] [u1, u2, u3, 0#] of { _PRIM_ (u4 :: Float#) -> _!_ F# [] [u4] }; _NO_DEFLT_ } _N_ },
+ fromInt = { _A_ 1 _U_ 1 _N_ _S_ "U(P)" {_A_ 1 _U_ 2 _N_ _N_ _F_ _IF_ARGS_ 0 1 X 3 \ (u0 :: Int#) -> case _#_ int2Float# [] [u0] of { _PRIM_ (u1 :: Float#) -> _!_ F# [] [u1] } _N_} _F_ _IF_ARGS_ 0 1 C 4 \ (u0 :: Int) -> case u0 of { _ALG_ I# (u1 :: Int#) -> case _#_ int2Float# [] [u1] of { _PRIM_ (u2 :: Float#) -> _!_ F# [] [u2] }; _NO_DEFLT_ } _N_ } #-}
instance Num Int
{-# GHC_PRAGMA _M_ PreludeCore {-dfun-} _A_ 0 _N_ _N_ _N_ _F_ _IF_ARGS_ 0 0 X 11 _!_ _TUP_10 [{{Eq Int}}, {{Text Int}}, (Int -> Int -> Int), (Int -> Int -> Int), (Int -> Int -> Int), (Int -> Int), (Int -> Int), (Int -> Int), (Integer -> Int), (Int -> Int)] [_DFUN_ Eq (Int), _DFUN_ Text (Int), _CONSTM_ Num (+) (Int), _CONSTM_ Num (-) (Int), _CONSTM_ Num (*) (Int), _CONSTM_ Num negate (Int), _CONSTM_ Num abs (Int), _CONSTM_ Num signum (Int), _CONSTM_ Num fromInteger (Int), _CONSTM_ Num fromInt (Int)] _N_
- (+) = _A_ 2 _U_ 11 _N_ _S_ "U(P)U(P)" {_A_ 2 _U_ 22 _N_ _N_ _F_ _IF_ARGS_ 0 2 XX 3 \ (u0 :: Int#) (u1 :: Int#) -> case _#_ plusInt# [] [u0, u1] of { _PRIM_ (u2 :: Int#) -> _!_ I# [] [u2] } _N_} _F_ _IF_ARGS_ 0 2 CC 5 \ (u0 :: Int) (u1 :: Int) -> case u0 of { _ALG_ I# (u2 :: Int#) -> case u1 of { _ALG_ I# (u3 :: Int#) -> case _#_ plusInt# [] [u2, u3] of { _PRIM_ (u4 :: Int#) -> _!_ I# [] [u4] }; _NO_DEFLT_ }; _NO_DEFLT_ } _N_,
- (-) = _A_ 2 _U_ 11 _N_ _S_ "U(P)U(P)" {_A_ 2 _U_ 22 _N_ _N_ _F_ _IF_ARGS_ 0 2 XX 3 \ (u0 :: Int#) (u1 :: Int#) -> case _#_ minusInt# [] [u0, u1] of { _PRIM_ (u2 :: Int#) -> _!_ I# [] [u2] } _N_} _F_ _IF_ARGS_ 0 2 CC 5 \ (u0 :: Int) (u1 :: Int) -> case u0 of { _ALG_ I# (u2 :: Int#) -> case u1 of { _ALG_ I# (u3 :: Int#) -> case _#_ minusInt# [] [u2, u3] of { _PRIM_ (u4 :: Int#) -> _!_ I# [] [u4] }; _NO_DEFLT_ }; _NO_DEFLT_ } _N_,
- (*) = _A_ 2 _U_ 11 _N_ _S_ "U(P)U(P)" {_A_ 2 _U_ 22 _N_ _N_ _F_ _IF_ARGS_ 0 2 XX 3 \ (u0 :: Int#) (u1 :: Int#) -> case _#_ timesInt# [] [u0, u1] of { _PRIM_ (u2 :: Int#) -> _!_ I# [] [u2] } _N_} _F_ _IF_ARGS_ 0 2 CC 5 \ (u0 :: Int) (u1 :: Int) -> case u0 of { _ALG_ I# (u2 :: Int#) -> case u1 of { _ALG_ I# (u3 :: Int#) -> case _#_ timesInt# [] [u2, u3] of { _PRIM_ (u4 :: Int#) -> _!_ I# [] [u4] }; _NO_DEFLT_ }; _NO_DEFLT_ } _N_,
- negate = _A_ 1 _U_ 1 _N_ _S_ "U(P)" {_A_ 1 _U_ 2 _N_ _N_ _F_ _IF_ARGS_ 0 1 X 3 \ (u0 :: Int#) -> case _#_ negateInt# [] [u0] of { _PRIM_ (u1 :: Int#) -> _!_ I# [] [u1] } _N_} _F_ _IF_ARGS_ 0 1 C 4 \ (u0 :: Int) -> case u0 of { _ALG_ I# (u1 :: Int#) -> case _#_ negateInt# [] [u1] of { _PRIM_ (u2 :: Int#) -> _!_ I# [] [u2] }; _NO_DEFLT_ } _N_,
- abs = _A_ 1 _U_ 1 _N_ _S_ "U(P)" {_A_ 1 _U_ 2 _N_ _N_ _N_ _N_} _N_ _N_,
- signum = _A_ 1 _U_ 1 _N_ _S_ "U(P)" {_A_ 1 _U_ 2 _N_ _N_ _N_ _N_} _N_ _N_,
- fromInteger = _A_ 1 _U_ 1 _N_ _S_ "U(PPP)" {_A_ 3 _U_ 222 _N_ _N_ _F_ _IF_ARGS_ 0 3 XXX 3 \ (u0 :: Int#) (u1 :: Int#) (u2 :: ByteArray#) -> case _#_ integer2Int# [] [u0, u1, u2] of { _PRIM_ (u3 :: Int#) -> _!_ I# [] [u3] } _N_} _F_ _IF_ARGS_ 0 1 C 4 \ (u0 :: Integer) -> case u0 of { _ALG_ J# (u1 :: Int#) (u2 :: Int#) (u3 :: ByteArray#) -> case _#_ integer2Int# [] [u1, u2, u3] of { _PRIM_ (u4 :: Int#) -> _!_ I# [] [u4] }; _NO_DEFLT_ } _N_,
- fromInt = _A_ 1 _U_ 1 _N_ _S_ "U(P)" {_A_ 1 _U_ 2 _N_ _N_ _F_ _IF_ARGS_ 0 1 X 2 \ (u0 :: Int#) -> _!_ I# [] [u0] _N_} _F_ _IF_ARGS_ 0 1 X 1 \ (u0 :: Int) -> u0 _N_ #-}
+ (+) = { _A_ 2 _U_ 11 _N_ _S_ "U(P)U(P)" {_A_ 2 _U_ 22 _N_ _N_ _F_ _IF_ARGS_ 0 2 XX 3 \ (u0 :: Int#) (u1 :: Int#) -> case _#_ plusInt# [] [u0, u1] of { _PRIM_ (u2 :: Int#) -> _!_ I# [] [u2] } _N_} _F_ _IF_ARGS_ 0 2 CC 5 \ (u0 :: Int) (u1 :: Int) -> case u0 of { _ALG_ I# (u2 :: Int#) -> case u1 of { _ALG_ I# (u3 :: Int#) -> case _#_ plusInt# [] [u2, u3] of { _PRIM_ (u4 :: Int#) -> _!_ I# [] [u4] }; _NO_DEFLT_ }; _NO_DEFLT_ } _N_ },
+ (-) = { _A_ 2 _U_ 11 _N_ _S_ "U(P)U(P)" {_A_ 2 _U_ 22 _N_ _N_ _F_ _IF_ARGS_ 0 2 XX 3 \ (u0 :: Int#) (u1 :: Int#) -> case _#_ minusInt# [] [u0, u1] of { _PRIM_ (u2 :: Int#) -> _!_ I# [] [u2] } _N_} _F_ _IF_ARGS_ 0 2 CC 5 \ (u0 :: Int) (u1 :: Int) -> case u0 of { _ALG_ I# (u2 :: Int#) -> case u1 of { _ALG_ I# (u3 :: Int#) -> case _#_ minusInt# [] [u2, u3] of { _PRIM_ (u4 :: Int#) -> _!_ I# [] [u4] }; _NO_DEFLT_ }; _NO_DEFLT_ } _N_ },
+ (*) = { _A_ 2 _U_ 11 _N_ _S_ "U(P)U(P)" {_A_ 2 _U_ 22 _N_ _N_ _F_ _IF_ARGS_ 0 2 XX 3 \ (u0 :: Int#) (u1 :: Int#) -> case _#_ timesInt# [] [u0, u1] of { _PRIM_ (u2 :: Int#) -> _!_ I# [] [u2] } _N_} _F_ _IF_ARGS_ 0 2 CC 5 \ (u0 :: Int) (u1 :: Int) -> case u0 of { _ALG_ I# (u2 :: Int#) -> case u1 of { _ALG_ I# (u3 :: Int#) -> case _#_ timesInt# [] [u2, u3] of { _PRIM_ (u4 :: Int#) -> _!_ I# [] [u4] }; _NO_DEFLT_ }; _NO_DEFLT_ } _N_ },
+ negate = { _A_ 1 _U_ 1 _N_ _S_ "U(P)" {_A_ 1 _U_ 2 _N_ _N_ _F_ _IF_ARGS_ 0 1 X 3 \ (u0 :: Int#) -> case _#_ negateInt# [] [u0] of { _PRIM_ (u1 :: Int#) -> _!_ I# [] [u1] } _N_} _F_ _IF_ARGS_ 0 1 C 4 \ (u0 :: Int) -> case u0 of { _ALG_ I# (u1 :: Int#) -> case _#_ negateInt# [] [u1] of { _PRIM_ (u2 :: Int#) -> _!_ I# [] [u2] }; _NO_DEFLT_ } _N_ },
+ abs = { _A_ 1 _U_ 1 _N_ _S_ "U(P)" {_A_ 1 _U_ 2 _N_ _N_ _N_ _N_} _N_ _N_ },
+ signum = { _A_ 1 _U_ 1 _N_ _S_ "U(P)" {_A_ 1 _U_ 2 _N_ _N_ _N_ _N_} _N_ _N_ },
+ fromInteger = { _A_ 1 _U_ 1 _N_ _S_ "U(PPP)" {_A_ 3 _U_ 222 _N_ _N_ _F_ _IF_ARGS_ 0 3 XXX 3 \ (u0 :: Int#) (u1 :: Int#) (u2 :: ByteArray#) -> case _#_ integer2Int# [] [u0, u1, u2] of { _PRIM_ (u3 :: Int#) -> _!_ I# [] [u3] } _N_} _F_ _IF_ARGS_ 0 1 C 4 \ (u0 :: Integer) -> case u0 of { _ALG_ J# (u1 :: Int#) (u2 :: Int#) (u3 :: ByteArray#) -> case _#_ integer2Int# [] [u1, u2, u3] of { _PRIM_ (u4 :: Int#) -> _!_ I# [] [u4] }; _NO_DEFLT_ } _N_ },
+ fromInt = { _A_ 1 _U_ 1 _N_ _S_ "U(P)" {_A_ 1 _U_ 2 _N_ _N_ _F_ _IF_ARGS_ 0 1 X 2 \ (u0 :: Int#) -> _!_ I# [] [u0] _N_} _F_ _IF_ARGS_ 0 1 X 1 \ (u0 :: Int) -> u0 _N_ } #-}
instance Num Integer
{-# GHC_PRAGMA _M_ PreludeCore {-dfun-} _A_ 0 _N_ _N_ _N_ _F_ _IF_ARGS_ 0 0 X 11 _!_ _TUP_10 [{{Eq Integer}}, {{Text Integer}}, (Integer -> Integer -> Integer), (Integer -> Integer -> Integer), (Integer -> Integer -> Integer), (Integer -> Integer), (Integer -> Integer), (Integer -> Integer), (Integer -> Integer), (Int -> Integer)] [_DFUN_ Eq (Integer), _DFUN_ Text (Integer), _CONSTM_ Num (+) (Integer), _CONSTM_ Num (-) (Integer), _CONSTM_ Num (*) (Integer), _CONSTM_ Num negate (Integer), _CONSTM_ Num abs (Integer), _CONSTM_ Num signum (Integer), _CONSTM_ Num fromInteger (Integer), _CONSTM_ Num fromInt (Integer)] _N_
- (+) = _A_ 2 _U_ 11 _N_ _S_ "U(PPP)U(PPP)" {_A_ 4 _U_ 2221 _N_ _N_ _F_ _IF_ARGS_ 0 4 XXXC 5 \ (u0 :: Int#) (u1 :: Int#) (u2 :: ByteArray#) (u3 :: Integer) -> case u3 of { _ALG_ J# (u4 :: Int#) (u5 :: Int#) (u6 :: ByteArray#) -> _#_ plusInteger# [] [u0, u1, u2, u4, u5, u6]; _NO_DEFLT_ } _N_} _F_ _IF_ARGS_ 0 2 CC 6 \ (u0 :: Integer) (u1 :: Integer) -> case u0 of { _ALG_ J# (u2 :: Int#) (u3 :: Int#) (u4 :: ByteArray#) -> case u1 of { _ALG_ J# (u5 :: Int#) (u6 :: Int#) (u7 :: ByteArray#) -> _#_ plusInteger# [] [u2, u3, u4, u5, u6, u7]; _NO_DEFLT_ }; _NO_DEFLT_ } _N_,
- (-) = _A_ 2 _U_ 11 _N_ _S_ "U(PPP)U(PPP)" {_A_ 4 _U_ 2221 _N_ _N_ _F_ _IF_ARGS_ 0 4 XXXC 5 \ (u0 :: Int#) (u1 :: Int#) (u2 :: ByteArray#) (u3 :: Integer) -> case u3 of { _ALG_ J# (u4 :: Int#) (u5 :: Int#) (u6 :: ByteArray#) -> _#_ minusInteger# [] [u0, u1, u2, u4, u5, u6]; _NO_DEFLT_ } _N_} _F_ _IF_ARGS_ 0 2 CC 6 \ (u0 :: Integer) (u1 :: Integer) -> case u0 of { _ALG_ J# (u2 :: Int#) (u3 :: Int#) (u4 :: ByteArray#) -> case u1 of { _ALG_ J# (u5 :: Int#) (u6 :: Int#) (u7 :: ByteArray#) -> _#_ minusInteger# [] [u2, u3, u4, u5, u6, u7]; _NO_DEFLT_ }; _NO_DEFLT_ } _N_,
- (*) = _A_ 2 _U_ 11 _N_ _S_ "U(PPP)U(PPP)" {_A_ 4 _U_ 2221 _N_ _N_ _F_ _IF_ARGS_ 0 4 XXXC 5 \ (u0 :: Int#) (u1 :: Int#) (u2 :: ByteArray#) (u3 :: Integer) -> case u3 of { _ALG_ J# (u4 :: Int#) (u5 :: Int#) (u6 :: ByteArray#) -> _#_ timesInteger# [] [u0, u1, u2, u4, u5, u6]; _NO_DEFLT_ } _N_} _F_ _IF_ARGS_ 0 2 CC 6 \ (u0 :: Integer) (u1 :: Integer) -> case u0 of { _ALG_ J# (u2 :: Int#) (u3 :: Int#) (u4 :: ByteArray#) -> case u1 of { _ALG_ J# (u5 :: Int#) (u6 :: Int#) (u7 :: ByteArray#) -> _#_ timesInteger# [] [u2, u3, u4, u5, u6, u7]; _NO_DEFLT_ }; _NO_DEFLT_ } _N_,
- negate = _A_ 1 _U_ 1 _N_ _S_ "U(PPP)" {_A_ 3 _U_ 222 _N_ _N_ _F_ _IF_ARGS_ 0 3 XXX 4 \ (u0 :: Int#) (u1 :: Int#) (u2 :: ByteArray#) -> _#_ negateInteger# [] [u0, u1, u2] _N_} _F_ _IF_ARGS_ 0 1 C 5 \ (u0 :: Integer) -> case u0 of { _ALG_ J# (u1 :: Int#) (u2 :: Int#) (u3 :: ByteArray#) -> _#_ negateInteger# [] [u1, u2, u3]; _NO_DEFLT_ } _N_,
- abs = _A_ 1 _U_ 1 _N_ _S_ "U(PPP)" {_A_ 3 _U_ 222 _N_ _N_ _N_ _N_} _N_ _N_,
- signum = _A_ 1 _U_ 1 _N_ _S_ "U(PPP)" {_A_ 3 _U_ 222 _N_ _N_ _N_ _N_} _N_ _N_,
- fromInteger = _A_ 1 _U_ 1 _N_ _S_ "U(PPP)" {_A_ 3 _U_ 222 _N_ _N_ _F_ _IF_ARGS_ 0 3 XXX 4 \ (u0 :: Int#) (u1 :: Int#) (u2 :: ByteArray#) -> _!_ J# [] [u0, u1, u2] _N_} _F_ _IF_ARGS_ 0 1 X 1 \ (u0 :: Integer) -> u0 _N_,
- fromInt = _A_ 1 _U_ 1 _N_ _S_ "U(P)" {_A_ 1 _U_ 2 _N_ _N_ _F_ _IF_ARGS_ 0 1 X 1 \ (u0 :: Int#) -> _#_ int2Integer# [] [u0] _N_} _F_ _IF_ARGS_ 0 1 C 2 \ (u0 :: Int) -> case u0 of { _ALG_ I# (u1 :: Int#) -> _#_ int2Integer# [] [u1]; _NO_DEFLT_ } _N_ #-}
+ (+) = { _A_ 2 _U_ 11 _N_ _S_ "U(PPP)U(PPP)" {_A_ 4 _U_ 2221 _N_ _N_ _F_ _IF_ARGS_ 0 4 XXXC 5 \ (u0 :: Int#) (u1 :: Int#) (u2 :: ByteArray#) (u3 :: Integer) -> case u3 of { _ALG_ J# (u4 :: Int#) (u5 :: Int#) (u6 :: ByteArray#) -> _#_ plusInteger# [] [u0, u1, u2, u4, u5, u6]; _NO_DEFLT_ } _N_} _F_ _IF_ARGS_ 0 2 CC 6 \ (u0 :: Integer) (u1 :: Integer) -> case u0 of { _ALG_ J# (u2 :: Int#) (u3 :: Int#) (u4 :: ByteArray#) -> case u1 of { _ALG_ J# (u5 :: Int#) (u6 :: Int#) (u7 :: ByteArray#) -> _#_ plusInteger# [] [u2, u3, u4, u5, u6, u7]; _NO_DEFLT_ }; _NO_DEFLT_ } _N_ },
+ (-) = { _A_ 2 _U_ 11 _N_ _S_ "U(PPP)U(PPP)" {_A_ 4 _U_ 2221 _N_ _N_ _F_ _IF_ARGS_ 0 4 XXXC 5 \ (u0 :: Int#) (u1 :: Int#) (u2 :: ByteArray#) (u3 :: Integer) -> case u3 of { _ALG_ J# (u4 :: Int#) (u5 :: Int#) (u6 :: ByteArray#) -> _#_ minusInteger# [] [u0, u1, u2, u4, u5, u6]; _NO_DEFLT_ } _N_} _F_ _IF_ARGS_ 0 2 CC 6 \ (u0 :: Integer) (u1 :: Integer) -> case u0 of { _ALG_ J# (u2 :: Int#) (u3 :: Int#) (u4 :: ByteArray#) -> case u1 of { _ALG_ J# (u5 :: Int#) (u6 :: Int#) (u7 :: ByteArray#) -> _#_ minusInteger# [] [u2, u3, u4, u5, u6, u7]; _NO_DEFLT_ }; _NO_DEFLT_ } _N_ },
+ (*) = { _A_ 2 _U_ 11 _N_ _S_ "U(PPP)U(PPP)" {_A_ 4 _U_ 2221 _N_ _N_ _F_ _IF_ARGS_ 0 4 XXXC 5 \ (u0 :: Int#) (u1 :: Int#) (u2 :: ByteArray#) (u3 :: Integer) -> case u3 of { _ALG_ J# (u4 :: Int#) (u5 :: Int#) (u6 :: ByteArray#) -> _#_ timesInteger# [] [u0, u1, u2, u4, u5, u6]; _NO_DEFLT_ } _N_} _F_ _IF_ARGS_ 0 2 CC 6 \ (u0 :: Integer) (u1 :: Integer) -> case u0 of { _ALG_ J# (u2 :: Int#) (u3 :: Int#) (u4 :: ByteArray#) -> case u1 of { _ALG_ J# (u5 :: Int#) (u6 :: Int#) (u7 :: ByteArray#) -> _#_ timesInteger# [] [u2, u3, u4, u5, u6, u7]; _NO_DEFLT_ }; _NO_DEFLT_ } _N_ },
+ negate = { _A_ 1 _U_ 1 _N_ _S_ "U(PPP)" {_A_ 3 _U_ 222 _N_ _N_ _F_ _IF_ARGS_ 0 3 XXX 4 \ (u0 :: Int#) (u1 :: Int#) (u2 :: ByteArray#) -> _#_ negateInteger# [] [u0, u1, u2] _N_} _F_ _IF_ARGS_ 0 1 C 5 \ (u0 :: Integer) -> case u0 of { _ALG_ J# (u1 :: Int#) (u2 :: Int#) (u3 :: ByteArray#) -> _#_ negateInteger# [] [u1, u2, u3]; _NO_DEFLT_ } _N_ },
+ abs = { _A_ 1 _U_ 1 _N_ _S_ "U(PPP)" {_A_ 3 _U_ 222 _N_ _N_ _N_ _N_} _N_ _N_ },
+ signum = { _A_ 1 _U_ 1 _N_ _S_ "U(PPP)" {_A_ 3 _U_ 222 _N_ _N_ _N_ _N_} _N_ _N_ },
+ fromInteger = { _A_ 1 _U_ 1 _N_ _S_ "U(PPP)" {_A_ 3 _U_ 222 _N_ _N_ _F_ _IF_ARGS_ 0 3 XXX 4 \ (u0 :: Int#) (u1 :: Int#) (u2 :: ByteArray#) -> _!_ J# [] [u0, u1, u2] _N_} _F_ _IF_ARGS_ 0 1 X 1 \ (u0 :: Integer) -> u0 _N_ },
+ fromInt = { _A_ 1 _U_ 1 _N_ _S_ "U(P)" {_A_ 1 _U_ 2 _N_ _N_ _F_ _IF_ARGS_ 0 1 X 1 \ (u0 :: Int#) -> _#_ int2Integer# [] [u0] _N_} _F_ _IF_ARGS_ 0 1 C 2 \ (u0 :: Int) -> case u0 of { _ALG_ I# (u1 :: Int#) -> _#_ int2Integer# [] [u1]; _NO_DEFLT_ } _N_ } #-}
instance Integral a => Num (Ratio a)
{-# GHC_PRAGMA _M_ PreludeRatio {-dfun-} _A_ 3 _U_ 222 _N_ _N_ _N_ _N_ #-}
instance Num (Ratio Integer)
{-# GHC_PRAGMA _M_ PreludeRatio {-dfun-} _A_ 0 _N_ _N_ _N_ _F_ _IF_ARGS_ 0 0 X 11 _!_ _TUP_10 [{{Eq (Ratio Integer)}}, {{Text (Ratio Integer)}}, (Ratio Integer -> Ratio Integer -> Ratio Integer), (Ratio Integer -> Ratio Integer -> Ratio Integer), (Ratio Integer -> Ratio Integer -> Ratio Integer), (Ratio Integer -> Ratio Integer), (Ratio Integer -> Ratio Integer), (Ratio Integer -> Ratio Integer), (Integer -> Ratio Integer), (Int -> Ratio Integer)] [_DFUN_ Eq (Ratio Integer), _DFUN_ Text (Ratio Integer), _CONSTM_ Num (+) (Ratio Integer), _CONSTM_ Num (-) (Ratio Integer), _CONSTM_ Num (*) (Ratio Integer), _CONSTM_ Num negate (Ratio Integer), _CONSTM_ Num abs (Ratio Integer), _CONSTM_ Num signum (Ratio Integer), _CONSTM_ Num fromInteger (Ratio Integer), _CONSTM_ Num fromInt (Ratio Integer)] _N_
- (+) = _A_ 2 _U_ 11 _N_ _S_ "U(LU(PPP))U(LU(PPP))" {_A_ 5 _U_ 12221 _N_ _N_ _N_ _N_} _N_ _N_,
- (-) = _A_ 2 _U_ 11 _N_ _S_ "U(LU(PPP))U(LU(PPP))" {_A_ 5 _U_ 12221 _N_ _N_ _N_ _N_} _N_ _N_,
- (*) = _A_ 2 _U_ 11 _N_ _S_ "U(LU(PPP))U(LU(PPP))" {_A_ 5 _U_ 22221 _N_ _N_ _N_ _N_} _N_ _N_,
- negate = _A_ 1 _U_ 1 _N_ _S_ "U(LL)" {_A_ 2 _U_ 22 _N_ _N_ _N_ _N_} _N_ _N_,
- abs = _A_ 1 _U_ 1 _N_ _S_ "U(LL)" {_A_ 2 _U_ 12 _N_ _N_ _N_ _N_} _N_ _N_,
- signum = _A_ 1 _U_ 1 _N_ _S_ "U(LA)" {_A_ 1 _U_ 1 _N_ _N_ _N_ _N_} _N_ _N_,
- fromInteger = _A_ 1 _U_ 2 _N_ _N_ _N_ _N_,
- fromInt = _A_ 1 _U_ 1 _N_ _N_ _N_ _N_ #-}
+ (+) = { _A_ 2 _U_ 11 _N_ _S_ "U(LU(PPP))U(LU(PPP))" {_A_ 5 _U_ 12221 _N_ _N_ _N_ _N_} _N_ _N_ },
+ (-) = { _A_ 2 _U_ 11 _N_ _S_ "U(LU(PPP))U(LU(PPP))" {_A_ 5 _U_ 12221 _N_ _N_ _N_ _N_} _N_ _N_ },
+ (*) = { _A_ 2 _U_ 11 _N_ _S_ "U(LU(PPP))U(LU(PPP))" {_A_ 5 _U_ 22221 _N_ _N_ _N_ _N_} _N_ _N_ },
+ negate = { _A_ 1 _U_ 1 _N_ _S_ "U(LL)" {_A_ 2 _U_ 22 _N_ _N_ _N_ _N_} _N_ _N_ },
+ abs = { _A_ 1 _U_ 1 _N_ _S_ "U(LL)" {_A_ 2 _U_ 12 _N_ _N_ _N_ _N_} _N_ _N_ },
+ signum = { _A_ 1 _U_ 1 _N_ _S_ "U(LA)" {_A_ 1 _U_ 1 _N_ _N_ _N_ _N_} _N_ _N_ },
+ fromInteger = { _A_ 1 _U_ 2 _N_ _N_ _F_ _IF_ARGS_ 0 1 X 3 \ (u0 :: Integer) -> _!_ (:%) [Integer] [u0, _SPEC_ _ORIG_ PreludeCore __i1 [ (Integer) ]] _N_ },
+ fromInt = { _A_ 1 _U_ 1 _N_ _N_ _N_ _N_ } #-}
instance Ord ()
{-# GHC_PRAGMA _M_ PreludeBuiltin {-dfun-} _A_ 0 _N_ _N_ _N_ _F_ _IF_ARGS_ 0 0 X 9 _!_ _TUP_8 [{{Eq ()}}, (() -> () -> Bool), (() -> () -> Bool), (() -> () -> Bool), (() -> () -> Bool), (() -> () -> ()), (() -> () -> ()), (() -> () -> _CMP_TAG)] [_DFUN_ Eq (()), _CONSTM_ Ord (<) (()), _CONSTM_ Ord (<=) (()), _CONSTM_ Ord (>=) (()), _CONSTM_ Ord (>) (()), _CONSTM_ Ord max (()), _CONSTM_ Ord min (()), _CONSTM_ Ord _tagCmp (())] _N_
- (<) = _A_ 2 _U_ 11 _N_ _S_ "EE" _F_ _IF_ARGS_ 0 2 CC 3 \ (u0 :: ()) (u1 :: ()) -> case u0 of { _ALG_ _TUP_0 -> case u1 of { _ALG_ _TUP_0 -> _!_ False [] []; _NO_DEFLT_ }; _NO_DEFLT_ } _N_,
- (<=) = _A_ 2 _U_ 11 _N_ _S_ "EE" _F_ _IF_ARGS_ 0 2 CC 3 \ (u0 :: ()) (u1 :: ()) -> case u0 of { _ALG_ _TUP_0 -> case u1 of { _ALG_ _TUP_0 -> _!_ True [] []; _NO_DEFLT_ }; _NO_DEFLT_ } _N_,
- (>=) = _A_ 2 _U_ 11 _N_ _S_ "EE" _F_ _IF_ARGS_ 0 2 CC 3 \ (u0 :: ()) (u1 :: ()) -> case u0 of { _ALG_ _TUP_0 -> case u1 of { _ALG_ _TUP_0 -> _!_ True [] []; _NO_DEFLT_ }; _NO_DEFLT_ } _N_,
- (>) = _A_ 2 _U_ 11 _N_ _S_ "EE" _F_ _IF_ARGS_ 0 2 CC 3 \ (u0 :: ()) (u1 :: ()) -> case u0 of { _ALG_ _TUP_0 -> case u1 of { _ALG_ _TUP_0 -> _!_ False [] []; _NO_DEFLT_ }; _NO_DEFLT_ } _N_,
- max = _A_ 2 _U_ 11 _N_ _S_ "EE" _F_ _IF_ARGS_ 0 2 CX 2 \ (u0 :: ()) (u1 :: ()) -> case u0 of { _ALG_ _TUP_0 -> u1; _NO_DEFLT_ } _N_,
- min = _A_ 2 _U_ 11 _N_ _S_ "EE" _F_ _IF_ARGS_ 0 2 CX 2 \ (u0 :: ()) (u1 :: ()) -> case u0 of { _ALG_ _TUP_0 -> u1; _NO_DEFLT_ } _N_,
- _tagCmp = _A_ 2 _U_ 11 _N_ _S_ "EE" _F_ _IF_ARGS_ 0 2 CC 3 \ (u0 :: ()) (u1 :: ()) -> case u0 of { _ALG_ _TUP_0 -> case u1 of { _ALG_ _TUP_0 -> _!_ _EQ [] []; _NO_DEFLT_ }; _NO_DEFLT_ } _N_ #-}
+ (<) = { _A_ 2 _U_ 11 _N_ _S_ "EE" _F_ _IF_ARGS_ 0 2 CC 3 \ (u0 :: ()) (u1 :: ()) -> case u0 of { _ALG_ _TUP_0 -> case u1 of { _ALG_ _TUP_0 -> _!_ False [] []; _NO_DEFLT_ }; _NO_DEFLT_ } _N_ },
+ (<=) = { _A_ 2 _U_ 11 _N_ _S_ "EE" _F_ _IF_ARGS_ 0 2 CC 3 \ (u0 :: ()) (u1 :: ()) -> case u0 of { _ALG_ _TUP_0 -> case u1 of { _ALG_ _TUP_0 -> _!_ True [] []; _NO_DEFLT_ }; _NO_DEFLT_ } _N_ },
+ (>=) = { _A_ 2 _U_ 11 _N_ _S_ "EE" _F_ _IF_ARGS_ 0 2 CC 3 \ (u0 :: ()) (u1 :: ()) -> case u0 of { _ALG_ _TUP_0 -> case u1 of { _ALG_ _TUP_0 -> _!_ True [] []; _NO_DEFLT_ }; _NO_DEFLT_ } _N_ },
+ (>) = { _A_ 2 _U_ 11 _N_ _S_ "EE" _F_ _IF_ARGS_ 0 2 CC 3 \ (u0 :: ()) (u1 :: ()) -> case u0 of { _ALG_ _TUP_0 -> case u1 of { _ALG_ _TUP_0 -> _!_ False [] []; _NO_DEFLT_ }; _NO_DEFLT_ } _N_ },
+ max = { _A_ 2 _U_ 11 _N_ _S_ "EE" _F_ _IF_ARGS_ 0 2 CX 2 \ (u0 :: ()) (u1 :: ()) -> case u0 of { _ALG_ _TUP_0 -> u1; _NO_DEFLT_ } _N_ },
+ min = { _A_ 2 _U_ 11 _N_ _S_ "EE" _F_ _IF_ARGS_ 0 2 CX 2 \ (u0 :: ()) (u1 :: ()) -> case u0 of { _ALG_ _TUP_0 -> u1; _NO_DEFLT_ } _N_ },
+ _tagCmp = { _A_ 2 _U_ 11 _N_ _S_ "EE" _F_ _IF_ARGS_ 0 2 CC 3 \ (u0 :: ()) (u1 :: ()) -> case u0 of { _ALG_ _TUP_0 -> case u1 of { _ALG_ _TUP_0 -> _!_ _EQ [] []; _NO_DEFLT_ }; _NO_DEFLT_ } _N_ } #-}
instance (Ord a, Ord b) => Ord (a, b)
{-# GHC_PRAGMA _M_ PreludeBuiltin {-dfun-} _A_ 3 _U_ 112 _N_ _N_ _N_ _N_ #-}
instance (Ord a, Ord b, Ord c) => Ord (a, b, c)
{-# GHC_PRAGMA _M_ PreludeBuiltin {-dfun-} _A_ 6 _U_ 111112 _N_ _N_ _N_ _N_ #-}
instance Ord (Int, Int)
{-# GHC_PRAGMA _M_ PreludeBuiltin {-dfun-} _A_ 0 _N_ _N_ _N_ _F_ _IF_ARGS_ 0 0 X 9 _!_ _TUP_8 [{{Eq (Int, Int)}}, ((Int, Int) -> (Int, Int) -> Bool), ((Int, Int) -> (Int, Int) -> Bool), ((Int, Int) -> (Int, Int) -> Bool), ((Int, Int) -> (Int, Int) -> Bool), ((Int, Int) -> (Int, Int) -> (Int, Int)), ((Int, Int) -> (Int, Int) -> (Int, Int)), ((Int, Int) -> (Int, Int) -> _CMP_TAG)] [_DFUN_ Eq ((Int, Int)), _CONSTM_ Ord (<) ((Int, Int)), _CONSTM_ Ord (<=) ((Int, Int)), _CONSTM_ Ord (>=) ((Int, Int)), _CONSTM_ Ord (>) ((Int, Int)), _CONSTM_ Ord max ((Int, Int)), _CONSTM_ Ord min ((Int, Int)), _CONSTM_ Ord _tagCmp ((Int, Int))] _N_
- (<) = _A_ 2 _U_ 11 _N_ _S_ "U(U(P)L)U(U(P)L)" {_A_ 4 _U_ 2121 _N_ _N_ _N_ _N_} _N_ _N_,
- (<=) = _A_ 2 _U_ 11 _N_ _S_ "U(U(P)L)U(U(P)L)" {_A_ 4 _U_ 2121 _N_ _N_ _N_ _N_} _N_ _N_,
- (>=) = _A_ 2 _U_ 11 _N_ _S_ "U(U(P)L)U(U(P)L)" {_A_ 4 _U_ 2121 _N_ _N_ _N_ _N_} _N_ _N_,
- (>) = _A_ 2 _U_ 11 _N_ _S_ "U(U(P)L)U(U(P)L)" {_A_ 4 _U_ 2121 _N_ _N_ _N_ _N_} _N_ _N_,
- max = _A_ 2 _U_ 11 _N_ _S_ "U(U(P)L)U(U(P)L)" {_A_ 4 _U_ 2222 _N_ _N_ _N_ _N_} _N_ _N_,
- min = _A_ 2 _U_ 11 _N_ _S_ "U(U(P)L)U(U(P)L)" {_A_ 4 _U_ 2222 _N_ _N_ _N_ _N_} _N_ _N_,
- _tagCmp = _A_ 2 _U_ 11 _N_ _S_ "U(U(P)L)U(U(P)L)" {_A_ 4 _U_ 2121 _N_ _N_ _N_ _N_} _N_ _N_ #-}
+ (<) = { _A_ 2 _U_ 11 _N_ _S_ "U(U(P)L)U(U(P)L)" {_A_ 4 _U_ 2121 _N_ _N_ _N_ _N_} _N_ _N_ },
+ (<=) = { _A_ 2 _U_ 11 _N_ _S_ "U(U(P)L)U(U(P)L)" {_A_ 4 _U_ 2121 _N_ _N_ _N_ _N_} _N_ _N_ },
+ (>=) = { _A_ 2 _U_ 11 _N_ _S_ "U(U(P)L)U(U(P)L)" {_A_ 4 _U_ 2121 _N_ _N_ _N_ _N_} _N_ _N_ },
+ (>) = { _A_ 2 _U_ 11 _N_ _S_ "U(U(P)L)U(U(P)L)" {_A_ 4 _U_ 2121 _N_ _N_ _N_ _N_} _N_ _N_ },
+ max = { _A_ 2 _U_ 11 _N_ _S_ "U(U(P)L)U(U(P)L)" {_A_ 4 _U_ 2222 _N_ _N_ _N_ _N_} _N_ _N_ },
+ min = { _A_ 2 _U_ 11 _N_ _S_ "U(U(P)L)U(U(P)L)" {_A_ 4 _U_ 2222 _N_ _N_ _N_ _N_} _N_ _N_ },
+ _tagCmp = { _A_ 2 _U_ 11 _N_ _S_ "U(U(P)L)U(U(P)L)" {_A_ 4 _U_ 2121 _N_ _N_ _N_ _N_} _N_ _N_ } #-}
+instance Ord (Int, Int, Int)
+ {-# GHC_PRAGMA _M_ PreludeBuiltin {-dfun-} _A_ 0 _N_ _N_ _N_ _F_ _IF_ARGS_ 0 0 X 9 _!_ _TUP_8 [{{Eq (Int, Int, Int)}}, ((Int, Int, Int) -> (Int, Int, Int) -> Bool), ((Int, Int, Int) -> (Int, Int, Int) -> Bool), ((Int, Int, Int) -> (Int, Int, Int) -> Bool), ((Int, Int, Int) -> (Int, Int, Int) -> Bool), ((Int, Int, Int) -> (Int, Int, Int) -> (Int, Int, Int)), ((Int, Int, Int) -> (Int, Int, Int) -> (Int, Int, Int)), ((Int, Int, Int) -> (Int, Int, Int) -> _CMP_TAG)] [_DFUN_ Eq ((Int, Int, Int)), _CONSTM_ Ord (<) ((Int, Int, Int)), _CONSTM_ Ord (<=) ((Int, Int, Int)), _CONSTM_ Ord (>=) ((Int, Int, Int)), _CONSTM_ Ord (>) ((Int, Int, Int)), _CONSTM_ Ord max ((Int, Int, Int)), _CONSTM_ Ord min ((Int, Int, Int)), _CONSTM_ Ord _tagCmp ((Int, Int, Int))] _N_
+ (<) = { _A_ 2 _U_ 11 _N_ _S_ "U(U(P)LL)U(U(P)LL)" {_A_ 4 _U_ 2111 _N_ _N_ _N_ _N_} _N_ _N_ },
+ (<=) = { _A_ 2 _U_ 11 _N_ _S_ "U(U(P)LL)U(U(P)LL)" {_A_ 4 _U_ 2111 _N_ _N_ _N_ _N_} _N_ _N_ },
+ (>=) = { _A_ 2 _U_ 11 _N_ _S_ "U(U(P)LL)U(U(P)LL)" {_A_ 4 _U_ 2111 _N_ _N_ _N_ _N_} _N_ _N_ },
+ (>) = { _A_ 2 _U_ 11 _N_ _S_ "U(U(P)LL)U(U(P)LL)" {_A_ 4 _U_ 2111 _N_ _N_ _N_ _N_} _N_ _N_ },
+ max = { _A_ 2 _U_ 12 _N_ _S_ "U(U(P)LL)U(U(P)LL)" {_A_ 4 _U_ 2222 _N_ _N_ _N_ _N_} _N_ _N_ },
+ min = { _A_ 2 _U_ 12 _N_ _S_ "U(U(P)LL)U(U(P)LL)" {_A_ 4 _U_ 2222 _N_ _N_ _N_ _N_} _N_ _N_ },
+ _tagCmp = { _A_ 2 _U_ 11 _N_ _S_ "U(U(P)LL)U(U(P)LL)" {_A_ 4 _U_ 2111 _N_ _N_ _N_ _N_} _N_ _N_ } #-}
+instance Ord (Int, Int, Int, Int)
+ {-# GHC_PRAGMA _M_ PreludeBuiltin {-dfun-} _A_ 0 _N_ _N_ _N_ _F_ _IF_ARGS_ 0 0 X 9 _!_ _TUP_8 [{{Eq (Int, Int, Int, Int)}}, ((Int, Int, Int, Int) -> (Int, Int, Int, Int) -> Bool), ((Int, Int, Int, Int) -> (Int, Int, Int, Int) -> Bool), ((Int, Int, Int, Int) -> (Int, Int, Int, Int) -> Bool), ((Int, Int, Int, Int) -> (Int, Int, Int, Int) -> Bool), ((Int, Int, Int, Int) -> (Int, Int, Int, Int) -> (Int, Int, Int, Int)), ((Int, Int, Int, Int) -> (Int, Int, Int, Int) -> (Int, Int, Int, Int)), ((Int, Int, Int, Int) -> (Int, Int, Int, Int) -> _CMP_TAG)] [_DFUN_ Eq ((Int, Int, Int, Int)), _CONSTM_ Ord (<) ((Int, Int, Int, Int)), _CONSTM_ Ord (<=) ((Int, Int, Int, Int)), _CONSTM_ Ord (>=) ((Int, Int, Int, Int)), _CONSTM_ Ord (>) ((Int, Int, Int, Int)), _CONSTM_ Ord max ((Int, Int, Int, Int)), _CONSTM_ Ord min ((Int, Int, Int, Int)), _CONSTM_ Ord _tagCmp ((Int, Int, Int, Int))] _N_
+ (<) = { _A_ 2 _U_ 11 _N_ _S_ "U(U(P)LLL)U(U(P)LLL)" {_A_ 5 _U_ 21111 _N_ _N_ _N_ _N_} _N_ _N_ },
+ (<=) = { _A_ 2 _U_ 11 _N_ _S_ "U(U(P)LLL)U(U(P)LLL)" {_A_ 5 _U_ 21111 _N_ _N_ _N_ _N_} _N_ _N_ },
+ (>=) = { _A_ 2 _U_ 11 _N_ _S_ "U(U(P)LLL)U(U(P)LLL)" {_A_ 5 _U_ 21111 _N_ _N_ _N_ _N_} _N_ _N_ },
+ (>) = { _A_ 2 _U_ 11 _N_ _S_ "U(U(P)LLL)U(U(P)LLL)" {_A_ 5 _U_ 21111 _N_ _N_ _N_ _N_} _N_ _N_ },
+ max = { _A_ 2 _U_ 12 _N_ _S_ "U(U(P)LLL)U(U(P)LLL)" {_A_ 5 _U_ 22222 _N_ _N_ _N_ _N_} _N_ _N_ },
+ min = { _A_ 2 _U_ 12 _N_ _S_ "U(U(P)LLL)U(U(P)LLL)" {_A_ 5 _U_ 22222 _N_ _N_ _N_ _N_} _N_ _N_ },
+ _tagCmp = { _A_ 2 _U_ 11 _N_ _S_ "U(U(P)LLL)U(U(P)LLL)" {_A_ 5 _U_ 21111 _N_ _N_ _N_ _N_} _N_ _N_ } #-}
+instance Ord (Int, Int, Int, Int, Int)
+ {-# GHC_PRAGMA _M_ PreludeBuiltin {-dfun-} _A_ 0 _N_ _N_ _N_ _F_ _IF_ARGS_ 0 0 X 9 _!_ _TUP_8 [{{Eq (Int, Int, Int, Int, Int)}}, ((Int, Int, Int, Int, Int) -> (Int, Int, Int, Int, Int) -> Bool), ((Int, Int, Int, Int, Int) -> (Int, Int, Int, Int, Int) -> Bool), ((Int, Int, Int, Int, Int) -> (Int, Int, Int, Int, Int) -> Bool), ((Int, Int, Int, Int, Int) -> (Int, Int, Int, Int, Int) -> Bool), ((Int, Int, Int, Int, Int) -> (Int, Int, Int, Int, Int) -> (Int, Int, Int, Int, Int)), ((Int, Int, Int, Int, Int) -> (Int, Int, Int, Int, Int) -> (Int, Int, Int, Int, Int)), ((Int, Int, Int, Int, Int) -> (Int, Int, Int, Int, Int) -> _CMP_TAG)] [_DFUN_ Eq ((Int, Int, Int, Int, Int)), _CONSTM_ Ord (<) ((Int, Int, Int, Int, Int)), _CONSTM_ Ord (<=) ((Int, Int, Int, Int, Int)), _CONSTM_ Ord (>=) ((Int, Int, Int, Int, Int)), _CONSTM_ Ord (>) ((Int, Int, Int, Int, Int)), _CONSTM_ Ord max ((Int, Int, Int, Int, Int)), _CONSTM_ Ord min ((Int, Int, Int, Int, Int)), _CONSTM_ Ord _tagCmp ((Int, Int, Int, Int, Int))] _N_
+ (<) = { _A_ 2 _U_ 11 _N_ _S_ "U(U(P)LLLL)U(U(P)LLLL)" _N_ _N_ },
+ (<=) = { _A_ 2 _U_ 11 _N_ _S_ "U(U(P)LLLL)U(U(P)LLLL)" _N_ _N_ },
+ (>=) = { _A_ 2 _U_ 11 _N_ _S_ "U(U(P)LLLL)U(U(P)LLLL)" _N_ _N_ },
+ (>) = { _A_ 2 _U_ 11 _N_ _S_ "U(U(P)LLLL)U(U(P)LLLL)" _N_ _N_ },
+ max = { _A_ 2 _U_ 22 _N_ _S_ "U(U(P)LLLL)U(U(P)LLLL)" _N_ _N_ },
+ min = { _A_ 2 _U_ 22 _N_ _S_ "U(U(P)LLLL)U(U(P)LLLL)" _N_ _N_ },
+ _tagCmp = { _A_ 2 _U_ 11 _N_ _S_ "U(U(P)LLLL)U(U(P)LLLL)" _N_ _N_ } #-}
+instance Ord ([Char], [Char])
+ {-# GHC_PRAGMA _M_ PreludeBuiltin {-dfun-} _A_ 0 _N_ _N_ _N_ _F_ _IF_ARGS_ 0 0 X 9 _!_ _TUP_8 [{{Eq ([Char], [Char])}}, (([Char], [Char]) -> ([Char], [Char]) -> Bool), (([Char], [Char]) -> ([Char], [Char]) -> Bool), (([Char], [Char]) -> ([Char], [Char]) -> Bool), (([Char], [Char]) -> ([Char], [Char]) -> Bool), (([Char], [Char]) -> ([Char], [Char]) -> ([Char], [Char])), (([Char], [Char]) -> ([Char], [Char]) -> ([Char], [Char])), (([Char], [Char]) -> ([Char], [Char]) -> _CMP_TAG)] [_DFUN_ Eq (([Char], [Char])), _CONSTM_ Ord (<) (([Char], [Char])), _CONSTM_ Ord (<=) (([Char], [Char])), _CONSTM_ Ord (>=) (([Char], [Char])), _CONSTM_ Ord (>) (([Char], [Char])), _CONSTM_ Ord max (([Char], [Char])), _CONSTM_ Ord min (([Char], [Char])), _CONSTM_ Ord _tagCmp (([Char], [Char]))] _N_
+ (<) = { _A_ 2 _U_ 11 _N_ _S_ "U(SL)U(SL)" {_A_ 4 _U_ 2222 _N_ _N_ _N_ _N_} _N_ _N_ },
+ (<=) = { _A_ 2 _U_ 11 _N_ _S_ "U(SL)U(SL)" {_A_ 4 _U_ 2222 _N_ _N_ _N_ _N_} _N_ _N_ },
+ (>=) = { _A_ 2 _U_ 11 _N_ _S_ "U(SL)U(SL)" {_A_ 4 _U_ 2222 _N_ _N_ _N_ _N_} _N_ _N_ },
+ (>) = { _A_ 2 _U_ 11 _N_ _S_ "U(SL)U(SL)" {_A_ 4 _U_ 2222 _N_ _N_ _N_ _N_} _N_ _N_ },
+ max = { _A_ 2 _U_ 11 _N_ _S_ "U(SL)U(SL)" {_A_ 4 _U_ 2222 _N_ _N_ _N_ _N_} _N_ _N_ },
+ min = { _A_ 2 _U_ 11 _N_ _S_ "U(SL)U(SL)" {_A_ 4 _U_ 2222 _N_ _N_ _N_ _N_} _N_ _N_ },
+ _tagCmp = { _A_ 2 _U_ 11 _N_ _S_ "U(SL)U(SL)" {_A_ 4 _U_ 2222 _N_ _N_ _N_ _N_} _N_ _N_ } #-}
+instance Ord ([Int], [Int])
+ {-# GHC_PRAGMA _M_ PreludeBuiltin {-dfun-} _A_ 0 _N_ _N_ _N_ _F_ _IF_ARGS_ 0 0 X 9 _!_ _TUP_8 [{{Eq ([Int], [Int])}}, (([Int], [Int]) -> ([Int], [Int]) -> Bool), (([Int], [Int]) -> ([Int], [Int]) -> Bool), (([Int], [Int]) -> ([Int], [Int]) -> Bool), (([Int], [Int]) -> ([Int], [Int]) -> Bool), (([Int], [Int]) -> ([Int], [Int]) -> ([Int], [Int])), (([Int], [Int]) -> ([Int], [Int]) -> ([Int], [Int])), (([Int], [Int]) -> ([Int], [Int]) -> _CMP_TAG)] [_DFUN_ Eq (([Int], [Int])), _CONSTM_ Ord (<) (([Int], [Int])), _CONSTM_ Ord (<=) (([Int], [Int])), _CONSTM_ Ord (>=) (([Int], [Int])), _CONSTM_ Ord (>) (([Int], [Int])), _CONSTM_ Ord max (([Int], [Int])), _CONSTM_ Ord min (([Int], [Int])), _CONSTM_ Ord _tagCmp (([Int], [Int]))] _N_
+ (<) = { _A_ 2 _U_ 11 _N_ _S_ "U(SL)U(SL)" {_A_ 4 _U_ 2222 _N_ _N_ _N_ _N_} _N_ _N_ },
+ (<=) = { _A_ 2 _U_ 11 _N_ _S_ "U(SL)U(SL)" {_A_ 4 _U_ 2222 _N_ _N_ _N_ _N_} _N_ _N_ },
+ (>=) = { _A_ 2 _U_ 11 _N_ _S_ "U(SL)U(SL)" {_A_ 4 _U_ 2222 _N_ _N_ _N_ _N_} _N_ _N_ },
+ (>) = { _A_ 2 _U_ 11 _N_ _S_ "U(SL)U(SL)" {_A_ 4 _U_ 2222 _N_ _N_ _N_ _N_} _N_ _N_ },
+ max = { _A_ 2 _U_ 11 _N_ _S_ "U(SL)U(SL)" {_A_ 4 _U_ 2222 _N_ _N_ _N_ _N_} _N_ _N_ },
+ min = { _A_ 2 _U_ 11 _N_ _S_ "U(SL)U(SL)" {_A_ 4 _U_ 2222 _N_ _N_ _N_ _N_} _N_ _N_ },
+ _tagCmp = { _A_ 2 _U_ 11 _N_ _S_ "U(SL)U(SL)" {_A_ 4 _U_ 2222 _N_ _N_ _N_ _N_} _N_ _N_ } #-}
instance Ord (_PackedString, _PackedString)
{-# GHC_PRAGMA _M_ PreludeBuiltin {-dfun-} _A_ 0 _N_ _N_ _N_ _F_ _IF_ARGS_ 0 0 X 9 _!_ _TUP_8 [{{Eq (_PackedString, _PackedString)}}, ((_PackedString, _PackedString) -> (_PackedString, _PackedString) -> Bool), ((_PackedString, _PackedString) -> (_PackedString, _PackedString) -> Bool), ((_PackedString, _PackedString) -> (_PackedString, _PackedString) -> Bool), ((_PackedString, _PackedString) -> (_PackedString, _PackedString) -> Bool), ((_PackedString, _PackedString) -> (_PackedString, _PackedString) -> (_PackedString, _PackedString)), ((_PackedString, _PackedString) -> (_PackedString, _PackedString) -> (_PackedString, _PackedString)), ((_PackedString, _PackedString) -> (_PackedString, _PackedString) -> _CMP_TAG)] [_DFUN_ Eq ((_PackedString, _PackedString)), _CONSTM_ Ord (<) ((_PackedString, _PackedString)), _CONSTM_ Ord (<=) ((_PackedString, _PackedString)), _CONSTM_ Ord (>=) ((_PackedString, _PackedString)), _CONSTM_ Ord (>) ((_PackedString, _PackedString)), _CONSTM_ Ord max ((_PackedString, _PackedString)), _CONSTM_ Ord min ((_PackedString, _PackedString)), _CONSTM_ Ord _tagCmp ((_PackedString, _PackedString))] _N_
- (<) = _A_ 2 _U_ 11 _N_ _S_ "U(SL)U(SL)" {_A_ 4 _U_ 2222 _N_ _N_ _N_ _N_} _N_ _N_,
- (<=) = _A_ 2 _U_ 11 _N_ _S_ "U(SL)U(SL)" {_A_ 4 _U_ 2222 _N_ _N_ _N_ _N_} _N_ _N_,
- (>=) = _A_ 2 _U_ 11 _N_ _S_ "U(SL)U(SL)" {_A_ 4 _U_ 2222 _N_ _N_ _N_ _N_} _N_ _N_,
- (>) = _A_ 2 _U_ 11 _N_ _S_ "U(SL)U(SL)" {_A_ 4 _U_ 2222 _N_ _N_ _N_ _N_} _N_ _N_,
- max = _A_ 2 _U_ 11 _N_ _S_ "U(SL)U(SL)" {_A_ 4 _U_ 2222 _N_ _N_ _N_ _N_} _N_ _N_,
- min = _A_ 2 _U_ 11 _N_ _S_ "U(SL)U(SL)" {_A_ 4 _U_ 2222 _N_ _N_ _N_ _N_} _N_ _N_,
- _tagCmp = _A_ 2 _U_ 11 _N_ _S_ "U(SL)U(SL)" {_A_ 4 _U_ 2222 _N_ _N_ _N_ _N_} _N_ _N_ #-}
+ (<) = { _A_ 2 _U_ 11 _N_ _S_ "U(SL)U(SL)" {_A_ 4 _U_ 2222 _N_ _N_ _N_ _N_} _N_ _N_ },
+ (<=) = { _A_ 2 _U_ 11 _N_ _S_ "U(SL)U(SL)" {_A_ 4 _U_ 2222 _N_ _N_ _N_ _N_} _N_ _N_ },
+ (>=) = { _A_ 2 _U_ 11 _N_ _S_ "U(SL)U(SL)" {_A_ 4 _U_ 2222 _N_ _N_ _N_ _N_} _N_ _N_ },
+ (>) = { _A_ 2 _U_ 11 _N_ _S_ "U(SL)U(SL)" {_A_ 4 _U_ 2222 _N_ _N_ _N_ _N_} _N_ _N_ },
+ max = { _A_ 2 _U_ 11 _N_ _S_ "U(SL)U(SL)" {_A_ 4 _U_ 2222 _N_ _N_ _N_ _N_} _N_ _N_ },
+ min = { _A_ 2 _U_ 11 _N_ _S_ "U(SL)U(SL)" {_A_ 4 _U_ 2222 _N_ _N_ _N_ _N_} _N_ _N_ },
+ _tagCmp = { _A_ 2 _U_ 11 _N_ _S_ "U(SL)U(SL)" {_A_ 4 _U_ 2222 _N_ _N_ _N_ _N_} _N_ _N_ } #-}
instance (Ix a, Ord b) => Ord (Array a b)
{-# GHC_PRAGMA _M_ PreludeArray {-dfun-} _A_ 3 _U_ 222 _N_ _N_ _N_ _N_ #-}
instance (Ord a, Ord b) => Ord (Assoc a b)
{-# GHC_PRAGMA _M_ PreludeArray {-dfun-} _A_ 3 _U_ 112 _N_ _N_ _N_ _N_ #-}
instance Ord Bool
{-# GHC_PRAGMA _M_ PreludeCore {-dfun-} _A_ 0 _N_ _N_ _N_ _F_ _IF_ARGS_ 0 0 X 9 _!_ _TUP_8 [{{Eq Bool}}, (Bool -> Bool -> Bool), (Bool -> Bool -> Bool), (Bool -> Bool -> Bool), (Bool -> Bool -> Bool), (Bool -> Bool -> Bool), (Bool -> Bool -> Bool), (Bool -> Bool -> _CMP_TAG)] [_DFUN_ Eq (Bool), _CONSTM_ Ord (<) (Bool), _CONSTM_ Ord (<=) (Bool), _CONSTM_ Ord (>=) (Bool), _CONSTM_ Ord (>) (Bool), _CONSTM_ Ord max (Bool), _CONSTM_ Ord min (Bool), _CONSTM_ Ord _tagCmp (Bool)] _N_
- (<) = _A_ 2 _U_ 11 _N_ _S_ "EE" _N_ _N_,
- (<=) = _A_ 2 _U_ 11 _N_ _S_ "EE" _N_ _N_,
- (>=) = _A_ 2 _U_ 11 _N_ _S_ "EE" _N_ _N_,
- (>) = _A_ 2 _U_ 11 _N_ _S_ "EE" _N_ _N_,
- max = _A_ 2 _U_ 22 _N_ _S_ "EE" _N_ _N_,
- min = _A_ 2 _U_ 22 _N_ _S_ "EE" _N_ _N_,
- _tagCmp = _A_ 2 _U_ 11 _N_ _S_ "EE" _N_ _N_ #-}
+ (<) = { _A_ 2 _U_ 11 _N_ _S_ "EE" _N_ _N_ },
+ (<=) = { _A_ 2 _U_ 11 _N_ _S_ "EE" _N_ _N_ },
+ (>=) = { _A_ 2 _U_ 11 _N_ _S_ "EE" _N_ _N_ },
+ (>) = { _A_ 2 _U_ 11 _N_ _S_ "EE" _N_ _N_ },
+ max = { _A_ 2 _U_ 22 _N_ _S_ "EE" _N_ _N_ },
+ min = { _A_ 2 _U_ 22 _N_ _S_ "EE" _N_ _N_ },
+ _tagCmp = { _A_ 2 _U_ 11 _N_ _S_ "EE" _N_ _N_ } #-}
instance Ord Char
{-# GHC_PRAGMA _M_ PreludeCore {-dfun-} _A_ 0 _N_ _N_ _N_ _F_ _IF_ARGS_ 0 0 X 9 _!_ _TUP_8 [{{Eq Char}}, (Char -> Char -> Bool), (Char -> Char -> Bool), (Char -> Char -> Bool), (Char -> Char -> Bool), (Char -> Char -> Char), (Char -> Char -> Char), (Char -> Char -> _CMP_TAG)] [_DFUN_ Eq (Char), _CONSTM_ Ord (<) (Char), _CONSTM_ Ord (<=) (Char), _CONSTM_ Ord (>=) (Char), _CONSTM_ Ord (>) (Char), _CONSTM_ Ord max (Char), _CONSTM_ Ord min (Char), _CONSTM_ Ord _tagCmp (Char)] _N_
- (<) = _A_ 2 _U_ 11 _N_ _S_ "U(P)U(P)" {_A_ 2 _U_ 22 _N_ _N_ _F_ _IF_ARGS_ 0 2 XX 1 \ (u0 :: Char#) (u1 :: Char#) -> _#_ ltChar# [] [u0, u1] _N_} _F_ _IF_ARGS_ 0 2 CC 3 \ (u0 :: Char) (u1 :: Char) -> case u0 of { _ALG_ C# (u2 :: Char#) -> case u1 of { _ALG_ C# (u3 :: Char#) -> _#_ ltChar# [] [u2, u3]; _NO_DEFLT_ }; _NO_DEFLT_ } _N_,
- (<=) = _A_ 2 _U_ 11 _N_ _S_ "U(P)U(P)" {_A_ 2 _U_ 22 _N_ _N_ _F_ _IF_ARGS_ 0 2 XX 1 \ (u0 :: Char#) (u1 :: Char#) -> _#_ leChar# [] [u0, u1] _N_} _F_ _IF_ARGS_ 0 2 CC 3 \ (u0 :: Char) (u1 :: Char) -> case u0 of { _ALG_ C# (u2 :: Char#) -> case u1 of { _ALG_ C# (u3 :: Char#) -> _#_ leChar# [] [u2, u3]; _NO_DEFLT_ }; _NO_DEFLT_ } _N_,
- (>=) = _A_ 2 _U_ 11 _N_ _S_ "U(P)U(P)" {_A_ 2 _U_ 22 _N_ _N_ _F_ _IF_ARGS_ 0 2 XX 1 \ (u0 :: Char#) (u1 :: Char#) -> _#_ geChar# [] [u0, u1] _N_} _F_ _IF_ARGS_ 0 2 CC 3 \ (u0 :: Char) (u1 :: Char) -> case u0 of { _ALG_ C# (u2 :: Char#) -> case u1 of { _ALG_ C# (u3 :: Char#) -> _#_ geChar# [] [u2, u3]; _NO_DEFLT_ }; _NO_DEFLT_ } _N_,
- (>) = _A_ 2 _U_ 11 _N_ _S_ "U(P)U(P)" {_A_ 2 _U_ 22 _N_ _N_ _F_ _IF_ARGS_ 0 2 XX 1 \ (u0 :: Char#) (u1 :: Char#) -> _#_ gtChar# [] [u0, u1] _N_} _F_ _IF_ARGS_ 0 2 CC 3 \ (u0 :: Char) (u1 :: Char) -> case u0 of { _ALG_ C# (u2 :: Char#) -> case u1 of { _ALG_ C# (u3 :: Char#) -> _#_ gtChar# [] [u2, u3]; _NO_DEFLT_ }; _NO_DEFLT_ } _N_,
- max = _A_ 2 _U_ 11 _N_ _S_ "U(P)U(P)" {_A_ 2 _U_ 22 _N_ _N_ _N_ _N_} _N_ _N_,
- min = _A_ 2 _U_ 11 _N_ _S_ "U(P)U(P)" {_A_ 2 _U_ 22 _N_ _N_ _N_ _N_} _N_ _N_,
- _tagCmp = _A_ 2 _U_ 11 _N_ _S_ "U(P)U(P)" {_A_ 2 _U_ 22 _N_ _N_ _N_ _N_} _N_ _N_ #-}
+ (<) = { _A_ 2 _U_ 11 _N_ _S_ "U(P)U(P)" {_A_ 2 _U_ 22 _N_ _N_ _F_ _IF_ARGS_ 0 2 XX 1 \ (u0 :: Char#) (u1 :: Char#) -> _#_ ltChar# [] [u0, u1] _N_} _F_ _IF_ARGS_ 0 2 CC 3 \ (u0 :: Char) (u1 :: Char) -> case u0 of { _ALG_ C# (u2 :: Char#) -> case u1 of { _ALG_ C# (u3 :: Char#) -> _#_ ltChar# [] [u2, u3]; _NO_DEFLT_ }; _NO_DEFLT_ } _N_ },
+ (<=) = { _A_ 2 _U_ 11 _N_ _S_ "U(P)U(P)" {_A_ 2 _U_ 22 _N_ _N_ _F_ _IF_ARGS_ 0 2 XX 1 \ (u0 :: Char#) (u1 :: Char#) -> _#_ leChar# [] [u0, u1] _N_} _F_ _IF_ARGS_ 0 2 CC 3 \ (u0 :: Char) (u1 :: Char) -> case u0 of { _ALG_ C# (u2 :: Char#) -> case u1 of { _ALG_ C# (u3 :: Char#) -> _#_ leChar# [] [u2, u3]; _NO_DEFLT_ }; _NO_DEFLT_ } _N_ },
+ (>=) = { _A_ 2 _U_ 11 _N_ _S_ "U(P)U(P)" {_A_ 2 _U_ 22 _N_ _N_ _F_ _IF_ARGS_ 0 2 XX 1 \ (u0 :: Char#) (u1 :: Char#) -> _#_ geChar# [] [u0, u1] _N_} _F_ _IF_ARGS_ 0 2 CC 3 \ (u0 :: Char) (u1 :: Char) -> case u0 of { _ALG_ C# (u2 :: Char#) -> case u1 of { _ALG_ C# (u3 :: Char#) -> _#_ geChar# [] [u2, u3]; _NO_DEFLT_ }; _NO_DEFLT_ } _N_ },
+ (>) = { _A_ 2 _U_ 11 _N_ _S_ "U(P)U(P)" {_A_ 2 _U_ 22 _N_ _N_ _F_ _IF_ARGS_ 0 2 XX 1 \ (u0 :: Char#) (u1 :: Char#) -> _#_ gtChar# [] [u0, u1] _N_} _F_ _IF_ARGS_ 0 2 CC 3 \ (u0 :: Char) (u1 :: Char) -> case u0 of { _ALG_ C# (u2 :: Char#) -> case u1 of { _ALG_ C# (u3 :: Char#) -> _#_ gtChar# [] [u2, u3]; _NO_DEFLT_ }; _NO_DEFLT_ } _N_ },
+ max = { _A_ 2 _U_ 11 _N_ _S_ "U(P)U(P)" {_A_ 2 _U_ 22 _N_ _N_ _N_ _N_} _N_ _N_ },
+ min = { _A_ 2 _U_ 11 _N_ _S_ "U(P)U(P)" {_A_ 2 _U_ 22 _N_ _N_ _N_ _N_} _N_ _N_ },
+ _tagCmp = { _A_ 2 _U_ 11 _N_ _S_ "U(P)U(P)" {_A_ 2 _U_ 22 _N_ _N_ _N_ _N_} _N_ _N_ } #-}
instance Ord Double
{-# GHC_PRAGMA _M_ PreludeCore {-dfun-} _A_ 0 _N_ _N_ _N_ _F_ _IF_ARGS_ 0 0 X 9 _!_ _TUP_8 [{{Eq Double}}, (Double -> Double -> Bool), (Double -> Double -> Bool), (Double -> Double -> Bool), (Double -> Double -> Bool), (Double -> Double -> Double), (Double -> Double -> Double), (Double -> Double -> _CMP_TAG)] [_DFUN_ Eq (Double), _CONSTM_ Ord (<) (Double), _CONSTM_ Ord (<=) (Double), _CONSTM_ Ord (>=) (Double), _CONSTM_ Ord (>) (Double), _CONSTM_ Ord max (Double), _CONSTM_ Ord min (Double), _CONSTM_ Ord _tagCmp (Double)] _N_
- (<) = _A_ 2 _U_ 11 _N_ _S_ "U(P)U(P)" {_A_ 2 _U_ 22 _N_ _N_ _F_ _IF_ARGS_ 0 2 XX 1 \ (u0 :: Double#) (u1 :: Double#) -> _#_ ltDouble# [] [u0, u1] _N_} _F_ _IF_ARGS_ 0 2 CC 3 \ (u0 :: Double) (u1 :: Double) -> case u0 of { _ALG_ D# (u2 :: Double#) -> case u1 of { _ALG_ D# (u3 :: Double#) -> _#_ ltDouble# [] [u2, u3]; _NO_DEFLT_ }; _NO_DEFLT_ } _N_,
- (<=) = _A_ 2 _U_ 11 _N_ _S_ "U(P)U(P)" {_A_ 2 _U_ 22 _N_ _N_ _F_ _IF_ARGS_ 0 2 XX 1 \ (u0 :: Double#) (u1 :: Double#) -> _#_ leDouble# [] [u0, u1] _N_} _F_ _IF_ARGS_ 0 2 CC 3 \ (u0 :: Double) (u1 :: Double) -> case u0 of { _ALG_ D# (u2 :: Double#) -> case u1 of { _ALG_ D# (u3 :: Double#) -> _#_ leDouble# [] [u2, u3]; _NO_DEFLT_ }; _NO_DEFLT_ } _N_,
- (>=) = _A_ 2 _U_ 11 _N_ _S_ "U(P)U(P)" {_A_ 2 _U_ 22 _N_ _N_ _F_ _IF_ARGS_ 0 2 XX 1 \ (u0 :: Double#) (u1 :: Double#) -> _#_ geDouble# [] [u0, u1] _N_} _F_ _IF_ARGS_ 0 2 CC 3 \ (u0 :: Double) (u1 :: Double) -> case u0 of { _ALG_ D# (u2 :: Double#) -> case u1 of { _ALG_ D# (u3 :: Double#) -> _#_ geDouble# [] [u2, u3]; _NO_DEFLT_ }; _NO_DEFLT_ } _N_,
- (>) = _A_ 2 _U_ 11 _N_ _S_ "U(P)U(P)" {_A_ 2 _U_ 22 _N_ _N_ _F_ _IF_ARGS_ 0 2 XX 1 \ (u0 :: Double#) (u1 :: Double#) -> _#_ gtDouble# [] [u0, u1] _N_} _F_ _IF_ARGS_ 0 2 CC 3 \ (u0 :: Double) (u1 :: Double) -> case u0 of { _ALG_ D# (u2 :: Double#) -> case u1 of { _ALG_ D# (u3 :: Double#) -> _#_ gtDouble# [] [u2, u3]; _NO_DEFLT_ }; _NO_DEFLT_ } _N_,
- max = _A_ 2 _U_ 11 _N_ _S_ "U(P)U(P)" {_A_ 2 _U_ 22 _N_ _N_ _N_ _N_} _N_ _N_,
- min = _A_ 2 _U_ 11 _N_ _S_ "U(P)U(P)" {_A_ 2 _U_ 22 _N_ _N_ _N_ _N_} _N_ _N_,
- _tagCmp = _A_ 2 _U_ 11 _N_ _S_ "U(P)U(P)" {_A_ 2 _U_ 22 _N_ _N_ _N_ _N_} _N_ _N_ #-}
+ (<) = { _A_ 2 _U_ 11 _N_ _S_ "U(P)U(P)" {_A_ 2 _U_ 22 _N_ _N_ _F_ _IF_ARGS_ 0 2 XX 1 \ (u0 :: Double#) (u1 :: Double#) -> _#_ ltDouble# [] [u0, u1] _N_} _F_ _IF_ARGS_ 0 2 CC 3 \ (u0 :: Double) (u1 :: Double) -> case u0 of { _ALG_ D# (u2 :: Double#) -> case u1 of { _ALG_ D# (u3 :: Double#) -> _#_ ltDouble# [] [u2, u3]; _NO_DEFLT_ }; _NO_DEFLT_ } _N_ },
+ (<=) = { _A_ 2 _U_ 11 _N_ _S_ "U(P)U(P)" {_A_ 2 _U_ 22 _N_ _N_ _F_ _IF_ARGS_ 0 2 XX 1 \ (u0 :: Double#) (u1 :: Double#) -> _#_ leDouble# [] [u0, u1] _N_} _F_ _IF_ARGS_ 0 2 CC 3 \ (u0 :: Double) (u1 :: Double) -> case u0 of { _ALG_ D# (u2 :: Double#) -> case u1 of { _ALG_ D# (u3 :: Double#) -> _#_ leDouble# [] [u2, u3]; _NO_DEFLT_ }; _NO_DEFLT_ } _N_ },
+ (>=) = { _A_ 2 _U_ 11 _N_ _S_ "U(P)U(P)" {_A_ 2 _U_ 22 _N_ _N_ _F_ _IF_ARGS_ 0 2 XX 1 \ (u0 :: Double#) (u1 :: Double#) -> _#_ geDouble# [] [u0, u1] _N_} _F_ _IF_ARGS_ 0 2 CC 3 \ (u0 :: Double) (u1 :: Double) -> case u0 of { _ALG_ D# (u2 :: Double#) -> case u1 of { _ALG_ D# (u3 :: Double#) -> _#_ geDouble# [] [u2, u3]; _NO_DEFLT_ }; _NO_DEFLT_ } _N_ },
+ (>) = { _A_ 2 _U_ 11 _N_ _S_ "U(P)U(P)" {_A_ 2 _U_ 22 _N_ _N_ _F_ _IF_ARGS_ 0 2 XX 1 \ (u0 :: Double#) (u1 :: Double#) -> _#_ gtDouble# [] [u0, u1] _N_} _F_ _IF_ARGS_ 0 2 CC 3 \ (u0 :: Double) (u1 :: Double) -> case u0 of { _ALG_ D# (u2 :: Double#) -> case u1 of { _ALG_ D# (u3 :: Double#) -> _#_ gtDouble# [] [u2, u3]; _NO_DEFLT_ }; _NO_DEFLT_ } _N_ },
+ max = { _A_ 2 _U_ 11 _N_ _S_ "U(P)U(P)" {_A_ 2 _U_ 22 _N_ _N_ _N_ _N_} _N_ _N_ },
+ min = { _A_ 2 _U_ 11 _N_ _S_ "U(P)U(P)" {_A_ 2 _U_ 22 _N_ _N_ _N_ _N_} _N_ _N_ },
+ _tagCmp = { _A_ 2 _U_ 11 _N_ _S_ "U(P)U(P)" {_A_ 2 _U_ 22 _N_ _N_ _N_ _N_} _N_ _N_ } #-}
instance (Ord a, Ord b) => Ord (Either a b)
{-# GHC_PRAGMA _M_ PreludeMonadicIO {-dfun-} _A_ 3 _U_ 222 _N_ _N_ _N_ _N_ #-}
instance Ord Float
{-# GHC_PRAGMA _M_ PreludeCore {-dfun-} _A_ 0 _N_ _N_ _N_ _F_ _IF_ARGS_ 0 0 X 9 _!_ _TUP_8 [{{Eq Float}}, (Float -> Float -> Bool), (Float -> Float -> Bool), (Float -> Float -> Bool), (Float -> Float -> Bool), (Float -> Float -> Float), (Float -> Float -> Float), (Float -> Float -> _CMP_TAG)] [_DFUN_ Eq (Float), _CONSTM_ Ord (<) (Float), _CONSTM_ Ord (<=) (Float), _CONSTM_ Ord (>=) (Float), _CONSTM_ Ord (>) (Float), _CONSTM_ Ord max (Float), _CONSTM_ Ord min (Float), _CONSTM_ Ord _tagCmp (Float)] _N_
- (<) = _A_ 2 _U_ 11 _N_ _S_ "U(P)U(P)" {_A_ 2 _U_ 22 _N_ _N_ _F_ _IF_ARGS_ 0 2 XX 1 \ (u0 :: Float#) (u1 :: Float#) -> _#_ ltFloat# [] [u0, u1] _N_} _F_ _IF_ARGS_ 0 2 CC 3 \ (u0 :: Float) (u1 :: Float) -> case u0 of { _ALG_ F# (u2 :: Float#) -> case u1 of { _ALG_ F# (u3 :: Float#) -> _#_ ltFloat# [] [u2, u3]; _NO_DEFLT_ }; _NO_DEFLT_ } _N_,
- (<=) = _A_ 2 _U_ 11 _N_ _S_ "U(P)U(P)" {_A_ 2 _U_ 22 _N_ _N_ _F_ _IF_ARGS_ 0 2 XX 1 \ (u0 :: Float#) (u1 :: Float#) -> _#_ leFloat# [] [u0, u1] _N_} _F_ _IF_ARGS_ 0 2 CC 3 \ (u0 :: Float) (u1 :: Float) -> case u0 of { _ALG_ F# (u2 :: Float#) -> case u1 of { _ALG_ F# (u3 :: Float#) -> _#_ leFloat# [] [u2, u3]; _NO_DEFLT_ }; _NO_DEFLT_ } _N_,
- (>=) = _A_ 2 _U_ 11 _N_ _S_ "U(P)U(P)" {_A_ 2 _U_ 22 _N_ _N_ _F_ _IF_ARGS_ 0 2 XX 1 \ (u0 :: Float#) (u1 :: Float#) -> _#_ geFloat# [] [u0, u1] _N_} _F_ _IF_ARGS_ 0 2 CC 3 \ (u0 :: Float) (u1 :: Float) -> case u0 of { _ALG_ F# (u2 :: Float#) -> case u1 of { _ALG_ F# (u3 :: Float#) -> _#_ geFloat# [] [u2, u3]; _NO_DEFLT_ }; _NO_DEFLT_ } _N_,
- (>) = _A_ 2 _U_ 11 _N_ _S_ "U(P)U(P)" {_A_ 2 _U_ 22 _N_ _N_ _F_ _IF_ARGS_ 0 2 XX 1 \ (u0 :: Float#) (u1 :: Float#) -> _#_ gtFloat# [] [u0, u1] _N_} _F_ _IF_ARGS_ 0 2 CC 3 \ (u0 :: Float) (u1 :: Float) -> case u0 of { _ALG_ F# (u2 :: Float#) -> case u1 of { _ALG_ F# (u3 :: Float#) -> _#_ gtFloat# [] [u2, u3]; _NO_DEFLT_ }; _NO_DEFLT_ } _N_,
- max = _A_ 2 _U_ 11 _N_ _S_ "U(P)U(P)" {_A_ 2 _U_ 22 _N_ _N_ _N_ _N_} _N_ _N_,
- min = _A_ 2 _U_ 11 _N_ _S_ "U(P)U(P)" {_A_ 2 _U_ 22 _N_ _N_ _N_ _N_} _N_ _N_,
- _tagCmp = _A_ 2 _U_ 11 _N_ _S_ "U(P)U(P)" {_A_ 2 _U_ 22 _N_ _N_ _N_ _N_} _N_ _N_ #-}
+ (<) = { _A_ 2 _U_ 11 _N_ _S_ "U(P)U(P)" {_A_ 2 _U_ 22 _N_ _N_ _F_ _IF_ARGS_ 0 2 XX 1 \ (u0 :: Float#) (u1 :: Float#) -> _#_ ltFloat# [] [u0, u1] _N_} _F_ _IF_ARGS_ 0 2 CC 3 \ (u0 :: Float) (u1 :: Float) -> case u0 of { _ALG_ F# (u2 :: Float#) -> case u1 of { _ALG_ F# (u3 :: Float#) -> _#_ ltFloat# [] [u2, u3]; _NO_DEFLT_ }; _NO_DEFLT_ } _N_ },
+ (<=) = { _A_ 2 _U_ 11 _N_ _S_ "U(P)U(P)" {_A_ 2 _U_ 22 _N_ _N_ _F_ _IF_ARGS_ 0 2 XX 1 \ (u0 :: Float#) (u1 :: Float#) -> _#_ leFloat# [] [u0, u1] _N_} _F_ _IF_ARGS_ 0 2 CC 3 \ (u0 :: Float) (u1 :: Float) -> case u0 of { _ALG_ F# (u2 :: Float#) -> case u1 of { _ALG_ F# (u3 :: Float#) -> _#_ leFloat# [] [u2, u3]; _NO_DEFLT_ }; _NO_DEFLT_ } _N_ },
+ (>=) = { _A_ 2 _U_ 11 _N_ _S_ "U(P)U(P)" {_A_ 2 _U_ 22 _N_ _N_ _F_ _IF_ARGS_ 0 2 XX 1 \ (u0 :: Float#) (u1 :: Float#) -> _#_ geFloat# [] [u0, u1] _N_} _F_ _IF_ARGS_ 0 2 CC 3 \ (u0 :: Float) (u1 :: Float) -> case u0 of { _ALG_ F# (u2 :: Float#) -> case u1 of { _ALG_ F# (u3 :: Float#) -> _#_ geFloat# [] [u2, u3]; _NO_DEFLT_ }; _NO_DEFLT_ } _N_ },
+ (>) = { _A_ 2 _U_ 11 _N_ _S_ "U(P)U(P)" {_A_ 2 _U_ 22 _N_ _N_ _F_ _IF_ARGS_ 0 2 XX 1 \ (u0 :: Float#) (u1 :: Float#) -> _#_ gtFloat# [] [u0, u1] _N_} _F_ _IF_ARGS_ 0 2 CC 3 \ (u0 :: Float) (u1 :: Float) -> case u0 of { _ALG_ F# (u2 :: Float#) -> case u1 of { _ALG_ F# (u3 :: Float#) -> _#_ gtFloat# [] [u2, u3]; _NO_DEFLT_ }; _NO_DEFLT_ } _N_ },
+ max = { _A_ 2 _U_ 11 _N_ _S_ "U(P)U(P)" {_A_ 2 _U_ 22 _N_ _N_ _N_ _N_} _N_ _N_ },
+ min = { _A_ 2 _U_ 11 _N_ _S_ "U(P)U(P)" {_A_ 2 _U_ 22 _N_ _N_ _N_ _N_} _N_ _N_ },
+ _tagCmp = { _A_ 2 _U_ 11 _N_ _S_ "U(P)U(P)" {_A_ 2 _U_ 22 _N_ _N_ _N_ _N_} _N_ _N_ } #-}
instance Ord Int
{-# GHC_PRAGMA _M_ PreludeCore {-dfun-} _A_ 0 _N_ _N_ _N_ _F_ _IF_ARGS_ 0 0 X 9 _!_ _TUP_8 [{{Eq Int}}, (Int -> Int -> Bool), (Int -> Int -> Bool), (Int -> Int -> Bool), (Int -> Int -> Bool), (Int -> Int -> Int), (Int -> Int -> Int), (Int -> Int -> _CMP_TAG)] [_DFUN_ Eq (Int), _CONSTM_ Ord (<) (Int), _CONSTM_ Ord (<=) (Int), _CONSTM_ Ord (>=) (Int), _CONSTM_ Ord (>) (Int), _CONSTM_ Ord max (Int), _CONSTM_ Ord min (Int), _CONSTM_ Ord _tagCmp (Int)] _N_
- (<) = _A_ 2 _U_ 11 _N_ _S_ "U(P)U(P)" {_A_ 2 _U_ 22 _N_ _N_ _F_ _IF_ARGS_ 0 2 XX 1 \ (u0 :: Int#) (u1 :: Int#) -> _#_ ltInt# [] [u0, u1] _N_} _F_ _IF_ARGS_ 0 2 CC 3 \ (u0 :: Int) (u1 :: Int) -> case u0 of { _ALG_ I# (u2 :: Int#) -> case u1 of { _ALG_ I# (u3 :: Int#) -> _#_ ltInt# [] [u2, u3]; _NO_DEFLT_ }; _NO_DEFLT_ } _N_,
- (<=) = _A_ 2 _U_ 11 _N_ _S_ "U(P)U(P)" {_A_ 2 _U_ 22 _N_ _N_ _F_ _IF_ARGS_ 0 2 XX 1 \ (u0 :: Int#) (u1 :: Int#) -> _#_ leInt# [] [u0, u1] _N_} _F_ _IF_ARGS_ 0 2 CC 3 \ (u0 :: Int) (u1 :: Int) -> case u0 of { _ALG_ I# (u2 :: Int#) -> case u1 of { _ALG_ I# (u3 :: Int#) -> _#_ leInt# [] [u2, u3]; _NO_DEFLT_ }; _NO_DEFLT_ } _N_,
- (>=) = _A_ 2 _U_ 11 _N_ _S_ "U(P)U(P)" {_A_ 2 _U_ 22 _N_ _N_ _F_ _IF_ARGS_ 0 2 XX 1 \ (u0 :: Int#) (u1 :: Int#) -> _#_ geInt# [] [u0, u1] _N_} _F_ _IF_ARGS_ 0 2 CC 3 \ (u0 :: Int) (u1 :: Int) -> case u0 of { _ALG_ I# (u2 :: Int#) -> case u1 of { _ALG_ I# (u3 :: Int#) -> _#_ geInt# [] [u2, u3]; _NO_DEFLT_ }; _NO_DEFLT_ } _N_,
- (>) = _A_ 2 _U_ 11 _N_ _S_ "U(P)U(P)" {_A_ 2 _U_ 22 _N_ _N_ _F_ _IF_ARGS_ 0 2 XX 1 \ (u0 :: Int#) (u1 :: Int#) -> _#_ gtInt# [] [u0, u1] _N_} _F_ _IF_ARGS_ 0 2 CC 3 \ (u0 :: Int) (u1 :: Int) -> case u0 of { _ALG_ I# (u2 :: Int#) -> case u1 of { _ALG_ I# (u3 :: Int#) -> _#_ gtInt# [] [u2, u3]; _NO_DEFLT_ }; _NO_DEFLT_ } _N_,
- max = _A_ 2 _U_ 11 _N_ _S_ "U(P)U(P)" {_A_ 2 _U_ 22 _N_ _N_ _N_ _N_} _N_ _N_,
- min = _A_ 2 _U_ 11 _N_ _S_ "U(P)U(P)" {_A_ 2 _U_ 22 _N_ _N_ _N_ _N_} _N_ _N_,
- _tagCmp = _A_ 2 _U_ 11 _N_ _S_ "U(P)U(P)" {_A_ 2 _U_ 22 _N_ _N_ _N_ _N_} _N_ _N_ #-}
+ (<) = { _A_ 2 _U_ 11 _N_ _S_ "U(P)U(P)" {_A_ 2 _U_ 22 _N_ _N_ _F_ _IF_ARGS_ 0 2 XX 1 \ (u0 :: Int#) (u1 :: Int#) -> _#_ ltInt# [] [u0, u1] _N_} _F_ _IF_ARGS_ 0 2 CC 3 \ (u0 :: Int) (u1 :: Int) -> case u0 of { _ALG_ I# (u2 :: Int#) -> case u1 of { _ALG_ I# (u3 :: Int#) -> _#_ ltInt# [] [u2, u3]; _NO_DEFLT_ }; _NO_DEFLT_ } _N_ },
+ (<=) = { _A_ 2 _U_ 11 _N_ _S_ "U(P)U(P)" {_A_ 2 _U_ 22 _N_ _N_ _F_ _IF_ARGS_ 0 2 XX 1 \ (u0 :: Int#) (u1 :: Int#) -> _#_ leInt# [] [u0, u1] _N_} _F_ _IF_ARGS_ 0 2 CC 3 \ (u0 :: Int) (u1 :: Int) -> case u0 of { _ALG_ I# (u2 :: Int#) -> case u1 of { _ALG_ I# (u3 :: Int#) -> _#_ leInt# [] [u2, u3]; _NO_DEFLT_ }; _NO_DEFLT_ } _N_ },
+ (>=) = { _A_ 2 _U_ 11 _N_ _S_ "U(P)U(P)" {_A_ 2 _U_ 22 _N_ _N_ _F_ _IF_ARGS_ 0 2 XX 1 \ (u0 :: Int#) (u1 :: Int#) -> _#_ geInt# [] [u0, u1] _N_} _F_ _IF_ARGS_ 0 2 CC 3 \ (u0 :: Int) (u1 :: Int) -> case u0 of { _ALG_ I# (u2 :: Int#) -> case u1 of { _ALG_ I# (u3 :: Int#) -> _#_ geInt# [] [u2, u3]; _NO_DEFLT_ }; _NO_DEFLT_ } _N_ },
+ (>) = { _A_ 2 _U_ 11 _N_ _S_ "U(P)U(P)" {_A_ 2 _U_ 22 _N_ _N_ _F_ _IF_ARGS_ 0 2 XX 1 \ (u0 :: Int#) (u1 :: Int#) -> _#_ gtInt# [] [u0, u1] _N_} _F_ _IF_ARGS_ 0 2 CC 3 \ (u0 :: Int) (u1 :: Int) -> case u0 of { _ALG_ I# (u2 :: Int#) -> case u1 of { _ALG_ I# (u3 :: Int#) -> _#_ gtInt# [] [u2, u3]; _NO_DEFLT_ }; _NO_DEFLT_ } _N_ },
+ max = { _A_ 2 _U_ 11 _N_ _S_ "U(P)U(P)" {_A_ 2 _U_ 22 _N_ _N_ _N_ _N_} _N_ _N_ },
+ min = { _A_ 2 _U_ 11 _N_ _S_ "U(P)U(P)" {_A_ 2 _U_ 22 _N_ _N_ _N_ _N_} _N_ _N_ },
+ _tagCmp = { _A_ 2 _U_ 11 _N_ _S_ "U(P)U(P)" {_A_ 2 _U_ 22 _N_ _N_ _N_ _N_} _N_ _N_ } #-}
instance Ord Integer
{-# GHC_PRAGMA _M_ PreludeCore {-dfun-} _A_ 0 _N_ _N_ _N_ _F_ _IF_ARGS_ 0 0 X 9 _!_ _TUP_8 [{{Eq Integer}}, (Integer -> Integer -> Bool), (Integer -> Integer -> Bool), (Integer -> Integer -> Bool), (Integer -> Integer -> Bool), (Integer -> Integer -> Integer), (Integer -> Integer -> Integer), (Integer -> Integer -> _CMP_TAG)] [_DFUN_ Eq (Integer), _CONSTM_ Ord (<) (Integer), _CONSTM_ Ord (<=) (Integer), _CONSTM_ Ord (>=) (Integer), _CONSTM_ Ord (>) (Integer), _CONSTM_ Ord max (Integer), _CONSTM_ Ord min (Integer), _CONSTM_ Ord _tagCmp (Integer)] _N_
- (<) = _A_ 2 _U_ 11 _N_ _S_ "U(PPP)U(PPP)" {_A_ 4 _U_ 2221 _N_ _N_ _F_ _IF_ARGS_ 0 4 XXXC 3 \ (u0 :: Int#) (u1 :: Int#) (u2 :: ByteArray#) (u3 :: Integer) -> case u3 of { _ALG_ J# (u4 :: Int#) (u5 :: Int#) (u6 :: ByteArray#) -> case _#_ cmpInteger# [] [u0, u1, u2, u4, u5, u6] of { _PRIM_ (u7 :: Int#) -> _#_ ltInt# [] [u7, 0#] }; _NO_DEFLT_ } _N_} _F_ _IF_ARGS_ 0 2 CC 4 \ (u0 :: Integer) (u1 :: Integer) -> case u0 of { _ALG_ J# (u2 :: Int#) (u3 :: Int#) (u4 :: ByteArray#) -> case u1 of { _ALG_ J# (u5 :: Int#) (u6 :: Int#) (u7 :: ByteArray#) -> case _#_ cmpInteger# [] [u2, u3, u4, u5, u6, u7] of { _PRIM_ (u8 :: Int#) -> _#_ ltInt# [] [u8, 0#] }; _NO_DEFLT_ }; _NO_DEFLT_ } _N_,
- (<=) = _A_ 2 _U_ 11 _N_ _S_ "U(PPP)U(PPP)" {_A_ 4 _U_ 2221 _N_ _N_ _F_ _IF_ARGS_ 0 4 XXXC 3 \ (u0 :: Int#) (u1 :: Int#) (u2 :: ByteArray#) (u3 :: Integer) -> case u3 of { _ALG_ J# (u4 :: Int#) (u5 :: Int#) (u6 :: ByteArray#) -> case _#_ cmpInteger# [] [u0, u1, u2, u4, u5, u6] of { _PRIM_ (u7 :: Int#) -> _#_ leInt# [] [u7, 0#] }; _NO_DEFLT_ } _N_} _F_ _IF_ARGS_ 0 2 CC 4 \ (u0 :: Integer) (u1 :: Integer) -> case u0 of { _ALG_ J# (u2 :: Int#) (u3 :: Int#) (u4 :: ByteArray#) -> case u1 of { _ALG_ J# (u5 :: Int#) (u6 :: Int#) (u7 :: ByteArray#) -> case _#_ cmpInteger# [] [u2, u3, u4, u5, u6, u7] of { _PRIM_ (u8 :: Int#) -> _#_ leInt# [] [u8, 0#] }; _NO_DEFLT_ }; _NO_DEFLT_ } _N_,
- (>=) = _A_ 2 _U_ 11 _N_ _S_ "U(PPP)U(PPP)" {_A_ 4 _U_ 2221 _N_ _N_ _F_ _IF_ARGS_ 0 4 XXXC 3 \ (u0 :: Int#) (u1 :: Int#) (u2 :: ByteArray#) (u3 :: Integer) -> case u3 of { _ALG_ J# (u4 :: Int#) (u5 :: Int#) (u6 :: ByteArray#) -> case _#_ cmpInteger# [] [u0, u1, u2, u4, u5, u6] of { _PRIM_ (u7 :: Int#) -> _#_ geInt# [] [u7, 0#] }; _NO_DEFLT_ } _N_} _F_ _IF_ARGS_ 0 2 CC 4 \ (u0 :: Integer) (u1 :: Integer) -> case u0 of { _ALG_ J# (u2 :: Int#) (u3 :: Int#) (u4 :: ByteArray#) -> case u1 of { _ALG_ J# (u5 :: Int#) (u6 :: Int#) (u7 :: ByteArray#) -> case _#_ cmpInteger# [] [u2, u3, u4, u5, u6, u7] of { _PRIM_ (u8 :: Int#) -> _#_ geInt# [] [u8, 0#] }; _NO_DEFLT_ }; _NO_DEFLT_ } _N_,
- (>) = _A_ 2 _U_ 11 _N_ _S_ "U(PPP)U(PPP)" {_A_ 4 _U_ 2221 _N_ _N_ _F_ _IF_ARGS_ 0 4 XXXC 3 \ (u0 :: Int#) (u1 :: Int#) (u2 :: ByteArray#) (u3 :: Integer) -> case u3 of { _ALG_ J# (u4 :: Int#) (u5 :: Int#) (u6 :: ByteArray#) -> case _#_ cmpInteger# [] [u0, u1, u2, u4, u5, u6] of { _PRIM_ (u7 :: Int#) -> _#_ gtInt# [] [u7, 0#] }; _NO_DEFLT_ } _N_} _F_ _IF_ARGS_ 0 2 CC 4 \ (u0 :: Integer) (u1 :: Integer) -> case u0 of { _ALG_ J# (u2 :: Int#) (u3 :: Int#) (u4 :: ByteArray#) -> case u1 of { _ALG_ J# (u5 :: Int#) (u6 :: Int#) (u7 :: ByteArray#) -> case _#_ cmpInteger# [] [u2, u3, u4, u5, u6, u7] of { _PRIM_ (u8 :: Int#) -> _#_ gtInt# [] [u8, 0#] }; _NO_DEFLT_ }; _NO_DEFLT_ } _N_,
- max = _A_ 2 _U_ 11 _N_ _S_ "U(PPP)U(PPP)" {_A_ 4 _U_ 2221 _N_ _N_ _N_ _N_} _N_ _N_,
- min = _A_ 2 _U_ 11 _N_ _S_ "U(PPP)U(PPP)" {_A_ 4 _U_ 2221 _N_ _N_ _N_ _N_} _N_ _N_,
- _tagCmp = _A_ 2 _U_ 11 _N_ _S_ "U(PPP)U(PPP)" {_A_ 4 _U_ 2221 _N_ _N_ _N_ _N_} _N_ _N_ #-}
+ (<) = { _A_ 2 _U_ 11 _N_ _S_ "U(PPP)U(PPP)" {_A_ 4 _U_ 2221 _N_ _N_ _F_ _IF_ARGS_ 0 4 XXXC 3 \ (u0 :: Int#) (u1 :: Int#) (u2 :: ByteArray#) (u3 :: Integer) -> case u3 of { _ALG_ J# (u4 :: Int#) (u5 :: Int#) (u6 :: ByteArray#) -> case _#_ cmpInteger# [] [u0, u1, u2, u4, u5, u6] of { _PRIM_ (u7 :: Int#) -> _#_ ltInt# [] [u7, 0#] }; _NO_DEFLT_ } _N_} _F_ _IF_ARGS_ 0 2 CC 4 \ (u0 :: Integer) (u1 :: Integer) -> case u0 of { _ALG_ J# (u2 :: Int#) (u3 :: Int#) (u4 :: ByteArray#) -> case u1 of { _ALG_ J# (u5 :: Int#) (u6 :: Int#) (u7 :: ByteArray#) -> case _#_ cmpInteger# [] [u2, u3, u4, u5, u6, u7] of { _PRIM_ (u8 :: Int#) -> _#_ ltInt# [] [u8, 0#] }; _NO_DEFLT_ }; _NO_DEFLT_ } _N_ },
+ (<=) = { _A_ 2 _U_ 11 _N_ _S_ "U(PPP)U(PPP)" {_A_ 4 _U_ 2221 _N_ _N_ _F_ _IF_ARGS_ 0 4 XXXC 3 \ (u0 :: Int#) (u1 :: Int#) (u2 :: ByteArray#) (u3 :: Integer) -> case u3 of { _ALG_ J# (u4 :: Int#) (u5 :: Int#) (u6 :: ByteArray#) -> case _#_ cmpInteger# [] [u0, u1, u2, u4, u5, u6] of { _PRIM_ (u7 :: Int#) -> _#_ leInt# [] [u7, 0#] }; _NO_DEFLT_ } _N_} _F_ _IF_ARGS_ 0 2 CC 4 \ (u0 :: Integer) (u1 :: Integer) -> case u0 of { _ALG_ J# (u2 :: Int#) (u3 :: Int#) (u4 :: ByteArray#) -> case u1 of { _ALG_ J# (u5 :: Int#) (u6 :: Int#) (u7 :: ByteArray#) -> case _#_ cmpInteger# [] [u2, u3, u4, u5, u6, u7] of { _PRIM_ (u8 :: Int#) -> _#_ leInt# [] [u8, 0#] }; _NO_DEFLT_ }; _NO_DEFLT_ } _N_ },
+ (>=) = { _A_ 2 _U_ 11 _N_ _S_ "U(PPP)U(PPP)" {_A_ 4 _U_ 2221 _N_ _N_ _F_ _IF_ARGS_ 0 4 XXXC 3 \ (u0 :: Int#) (u1 :: Int#) (u2 :: ByteArray#) (u3 :: Integer) -> case u3 of { _ALG_ J# (u4 :: Int#) (u5 :: Int#) (u6 :: ByteArray#) -> case _#_ cmpInteger# [] [u0, u1, u2, u4, u5, u6] of { _PRIM_ (u7 :: Int#) -> _#_ geInt# [] [u7, 0#] }; _NO_DEFLT_ } _N_} _F_ _IF_ARGS_ 0 2 CC 4 \ (u0 :: Integer) (u1 :: Integer) -> case u0 of { _ALG_ J# (u2 :: Int#) (u3 :: Int#) (u4 :: ByteArray#) -> case u1 of { _ALG_ J# (u5 :: Int#) (u6 :: Int#) (u7 :: ByteArray#) -> case _#_ cmpInteger# [] [u2, u3, u4, u5, u6, u7] of { _PRIM_ (u8 :: Int#) -> _#_ geInt# [] [u8, 0#] }; _NO_DEFLT_ }; _NO_DEFLT_ } _N_ },
+ (>) = { _A_ 2 _U_ 11 _N_ _S_ "U(PPP)U(PPP)" {_A_ 4 _U_ 2221 _N_ _N_ _F_ _IF_ARGS_ 0 4 XXXC 3 \ (u0 :: Int#) (u1 :: Int#) (u2 :: ByteArray#) (u3 :: Integer) -> case u3 of { _ALG_ J# (u4 :: Int#) (u5 :: Int#) (u6 :: ByteArray#) -> case _#_ cmpInteger# [] [u0, u1, u2, u4, u5, u6] of { _PRIM_ (u7 :: Int#) -> _#_ gtInt# [] [u7, 0#] }; _NO_DEFLT_ } _N_} _F_ _IF_ARGS_ 0 2 CC 4 \ (u0 :: Integer) (u1 :: Integer) -> case u0 of { _ALG_ J# (u2 :: Int#) (u3 :: Int#) (u4 :: ByteArray#) -> case u1 of { _ALG_ J# (u5 :: Int#) (u6 :: Int#) (u7 :: ByteArray#) -> case _#_ cmpInteger# [] [u2, u3, u4, u5, u6, u7] of { _PRIM_ (u8 :: Int#) -> _#_ gtInt# [] [u8, 0#] }; _NO_DEFLT_ }; _NO_DEFLT_ } _N_ },
+ max = { _A_ 2 _U_ 11 _N_ _S_ "U(PPP)U(PPP)" {_A_ 4 _U_ 2221 _N_ _N_ _N_ _N_} _N_ _N_ },
+ min = { _A_ 2 _U_ 11 _N_ _S_ "U(PPP)U(PPP)" {_A_ 4 _U_ 2221 _N_ _N_ _N_ _N_} _N_ _N_ },
+ _tagCmp = { _A_ 2 _U_ 11 _N_ _S_ "U(PPP)U(PPP)" {_A_ 4 _U_ 2221 _N_ _N_ _N_ _N_} _N_ _N_ } #-}
instance Ord a => Ord (Maybe a)
{-# GHC_PRAGMA _M_ PreludeStdIO {-dfun-} _A_ 2 _U_ 22 _N_ _N_ _N_ _N_ #-}
instance Integral a => Ord (Ratio a)
{-# GHC_PRAGMA _M_ PreludeRatio {-dfun-} _A_ 2 _U_ 22 _N_ _N_ _N_ _N_ #-}
instance Ord (Ratio Integer)
{-# GHC_PRAGMA _M_ PreludeRatio {-dfun-} _A_ 0 _N_ _N_ _N_ _F_ _IF_ARGS_ 0 0 X 9 _!_ _TUP_8 [{{Eq (Ratio Integer)}}, (Ratio Integer -> Ratio Integer -> Bool), (Ratio Integer -> Ratio Integer -> Bool), (Ratio Integer -> Ratio Integer -> Bool), (Ratio Integer -> Ratio Integer -> Bool), (Ratio Integer -> Ratio Integer -> Ratio Integer), (Ratio Integer -> Ratio Integer -> Ratio Integer), (Ratio Integer -> Ratio Integer -> _CMP_TAG)] [_DFUN_ Eq (Ratio Integer), _CONSTM_ Ord (<) (Ratio Integer), _CONSTM_ Ord (<=) (Ratio Integer), _CONSTM_ Ord (>=) (Ratio Integer), _CONSTM_ Ord (>) (Ratio Integer), _CONSTM_ Ord max (Ratio Integer), _CONSTM_ Ord min (Ratio Integer), _CONSTM_ Ord _tagCmp (Ratio Integer)] _N_
- (<) = _A_ 2 _U_ 11 _N_ _S_ "U(U(PPP)U(PPP))U(U(PPP)U(PPP))" {_A_ 5 _U_ 22221 _N_ _N_ _N_ _N_} _N_ _N_,
- (<=) = _A_ 2 _U_ 11 _N_ _S_ "U(U(PPP)U(PPP))U(U(PPP)U(PPP))" {_A_ 5 _U_ 22221 _N_ _N_ _N_ _N_} _N_ _N_,
- (>=) = _A_ 2 _U_ 11 _N_ _S_ "U(U(PPP)U(PPP))U(U(PPP)U(PPP))" {_A_ 5 _U_ 22221 _N_ _N_ _N_ _N_} _N_ _N_,
- (>) = _A_ 2 _U_ 11 _N_ _S_ "U(U(PPP)U(PPP))U(U(PPP)U(PPP))" {_A_ 5 _U_ 22221 _N_ _N_ _N_ _N_} _N_ _N_,
- max = _A_ 2 _U_ 12 _N_ _S_ "U(U(PPP)U(PPP))U(U(PPP)U(PPP))" {_A_ 5 _U_ 22222 _N_ _N_ _N_ _N_} _N_ _N_,
- min = _A_ 2 _U_ 12 _N_ _S_ "U(U(PPP)U(PPP))U(U(PPP)U(PPP))" {_A_ 5 _U_ 22222 _N_ _N_ _N_ _N_} _N_ _N_,
- _tagCmp = _A_ 2 _U_ 11 _N_ _S_ "U(U(PPP)U(PPP))U(U(PPP)U(PPP))" {_A_ 5 _U_ 22221 _N_ _N_ _N_ _N_} _N_ _N_ #-}
+ (<) = { _A_ 2 _U_ 11 _N_ _S_ "U(U(PPP)U(PPP))U(U(PPP)U(PPP))" {_A_ 5 _U_ 22221 _N_ _N_ _N_ _N_} _N_ _N_ },
+ (<=) = { _A_ 2 _U_ 11 _N_ _S_ "U(U(PPP)U(PPP))U(U(PPP)U(PPP))" {_A_ 5 _U_ 22221 _N_ _N_ _N_ _N_} _N_ _N_ },
+ (>=) = { _A_ 2 _U_ 11 _N_ _S_ "U(U(PPP)U(PPP))U(U(PPP)U(PPP))" {_A_ 5 _U_ 22221 _N_ _N_ _N_ _N_} _N_ _N_ },
+ (>) = { _A_ 2 _U_ 11 _N_ _S_ "U(U(PPP)U(PPP))U(U(PPP)U(PPP))" {_A_ 5 _U_ 22221 _N_ _N_ _N_ _N_} _N_ _N_ },
+ max = { _A_ 2 _U_ 12 _N_ _S_ "U(U(PPP)U(PPP))U(U(PPP)U(PPP))" {_A_ 5 _U_ 22222 _N_ _N_ _N_ _N_} _N_ _N_ },
+ min = { _A_ 2 _U_ 12 _N_ _S_ "U(U(PPP)U(PPP))U(U(PPP)U(PPP))" {_A_ 5 _U_ 22222 _N_ _N_ _N_ _N_} _N_ _N_ },
+ _tagCmp = { _A_ 2 _U_ 11 _N_ _S_ "U(U(PPP)U(PPP))U(U(PPP)U(PPP))" {_A_ 5 _U_ 22221 _N_ _N_ _N_ _N_} _N_ _N_ } #-}
instance Ord a => Ord [a]
{-# GHC_PRAGMA _M_ PreludeBuiltin {-dfun-} _A_ 2 _U_ 12 _N_ _N_ _N_ _N_ #-}
+instance Ord [Bool]
+ {-# GHC_PRAGMA _M_ PreludeBuiltin {-dfun-} _A_ 0 _N_ _N_ _N_ _F_ _IF_ARGS_ 0 0 X 9 _!_ _TUP_8 [{{Eq [Bool]}}, ([Bool] -> [Bool] -> Bool), ([Bool] -> [Bool] -> Bool), ([Bool] -> [Bool] -> Bool), ([Bool] -> [Bool] -> Bool), ([Bool] -> [Bool] -> [Bool]), ([Bool] -> [Bool] -> [Bool]), ([Bool] -> [Bool] -> _CMP_TAG)] [_DFUN_ Eq ([Bool]), _CONSTM_ Ord (<) ([Bool]), _CONSTM_ Ord (<=) ([Bool]), _CONSTM_ Ord (>=) ([Bool]), _CONSTM_ Ord (>) ([Bool]), _CONSTM_ Ord max ([Bool]), _CONSTM_ Ord min ([Bool]), _CONSTM_ Ord _tagCmp ([Bool])] _N_
+ (<) = { _A_ 2 _U_ 11 _N_ _S_ "SS" _N_ _N_ },
+ (<=) = { _A_ 2 _U_ 11 _N_ _S_ "SS" _N_ _N_ },
+ (>=) = { _A_ 2 _U_ 11 _N_ _S_ "SS" _N_ _N_ },
+ (>) = { _A_ 2 _U_ 11 _N_ _S_ "SS" _N_ _N_ },
+ max = { _A_ 2 _U_ 22 _N_ _S_ "SS" _N_ _N_ },
+ min = { _A_ 2 _U_ 22 _N_ _S_ "SS" _N_ _N_ },
+ _tagCmp = { _A_ 2 _U_ 11 _N_ _S_ "SS" _N_ _N_ } #-}
instance Ord [Char]
{-# GHC_PRAGMA _M_ PreludeBuiltin {-dfun-} _A_ 0 _N_ _N_ _N_ _F_ _IF_ARGS_ 0 0 X 9 _!_ _TUP_8 [{{Eq [Char]}}, ([Char] -> [Char] -> Bool), ([Char] -> [Char] -> Bool), ([Char] -> [Char] -> Bool), ([Char] -> [Char] -> Bool), ([Char] -> [Char] -> [Char]), ([Char] -> [Char] -> [Char]), ([Char] -> [Char] -> _CMP_TAG)] [_DFUN_ Eq ([Char]), _CONSTM_ Ord (<) ([Char]), _CONSTM_ Ord (<=) ([Char]), _CONSTM_ Ord (>=) ([Char]), _CONSTM_ Ord (>) ([Char]), _CONSTM_ Ord max ([Char]), _CONSTM_ Ord min ([Char]), _CONSTM_ Ord _tagCmp ([Char])] _N_
- (<) = _A_ 2 _U_ 11 _N_ _S_ "SS" _N_ _N_,
- (<=) = _A_ 2 _U_ 11 _N_ _S_ "SS" _N_ _N_,
- (>=) = _A_ 2 _U_ 11 _N_ _S_ "SS" _N_ _N_,
- (>) = _A_ 2 _U_ 11 _N_ _S_ "SS" _N_ _N_,
- max = _A_ 2 _U_ 22 _N_ _S_ "SS" _N_ _N_,
- min = _A_ 2 _U_ 22 _N_ _S_ "SS" _N_ _N_,
- _tagCmp = _A_ 2 _U_ 11 _N_ _S_ "SS" _N_ _N_ #-}
+ (<) = { _A_ 2 _U_ 11 _N_ _S_ "SS" _N_ _N_ },
+ (<=) = { _A_ 2 _U_ 11 _N_ _S_ "SS" _N_ _N_ },
+ (>=) = { _A_ 2 _U_ 11 _N_ _S_ "SS" _N_ _N_ },
+ (>) = { _A_ 2 _U_ 11 _N_ _S_ "SS" _N_ _N_ },
+ max = { _A_ 2 _U_ 22 _N_ _S_ "SS" _N_ _N_ },
+ min = { _A_ 2 _U_ 22 _N_ _S_ "SS" _N_ _N_ },
+ _tagCmp = { _A_ 2 _U_ 11 _N_ _S_ "SS" _N_ _N_ } #-}
+instance Ord [Double]
+ {-# GHC_PRAGMA _M_ PreludeBuiltin {-dfun-} _A_ 0 _N_ _N_ _N_ _F_ _IF_ARGS_ 0 0 X 9 _!_ _TUP_8 [{{Eq [Double]}}, ([Double] -> [Double] -> Bool), ([Double] -> [Double] -> Bool), ([Double] -> [Double] -> Bool), ([Double] -> [Double] -> Bool), ([Double] -> [Double] -> [Double]), ([Double] -> [Double] -> [Double]), ([Double] -> [Double] -> _CMP_TAG)] [_DFUN_ Eq ([Double]), _CONSTM_ Ord (<) ([Double]), _CONSTM_ Ord (<=) ([Double]), _CONSTM_ Ord (>=) ([Double]), _CONSTM_ Ord (>) ([Double]), _CONSTM_ Ord max ([Double]), _CONSTM_ Ord min ([Double]), _CONSTM_ Ord _tagCmp ([Double])] _N_
+ (<) = { _A_ 2 _U_ 11 _N_ _S_ "SS" _N_ _N_ },
+ (<=) = { _A_ 2 _U_ 11 _N_ _S_ "SS" _N_ _N_ },
+ (>=) = { _A_ 2 _U_ 11 _N_ _S_ "SS" _N_ _N_ },
+ (>) = { _A_ 2 _U_ 11 _N_ _S_ "SS" _N_ _N_ },
+ max = { _A_ 2 _U_ 22 _N_ _S_ "SS" _N_ _N_ },
+ min = { _A_ 2 _U_ 22 _N_ _S_ "SS" _N_ _N_ },
+ _tagCmp = { _A_ 2 _U_ 11 _N_ _S_ "SS" _N_ _N_ } #-}
instance Ord [Int]
{-# GHC_PRAGMA _M_ PreludeBuiltin {-dfun-} _A_ 0 _N_ _N_ _N_ _F_ _IF_ARGS_ 0 0 X 9 _!_ _TUP_8 [{{Eq [Int]}}, ([Int] -> [Int] -> Bool), ([Int] -> [Int] -> Bool), ([Int] -> [Int] -> Bool), ([Int] -> [Int] -> Bool), ([Int] -> [Int] -> [Int]), ([Int] -> [Int] -> [Int]), ([Int] -> [Int] -> _CMP_TAG)] [_DFUN_ Eq ([Int]), _CONSTM_ Ord (<) ([Int]), _CONSTM_ Ord (<=) ([Int]), _CONSTM_ Ord (>=) ([Int]), _CONSTM_ Ord (>) ([Int]), _CONSTM_ Ord max ([Int]), _CONSTM_ Ord min ([Int]), _CONSTM_ Ord _tagCmp ([Int])] _N_
- (<) = _A_ 2 _U_ 11 _N_ _S_ "SS" _N_ _N_,
- (<=) = _A_ 2 _U_ 11 _N_ _S_ "SS" _N_ _N_,
- (>=) = _A_ 2 _U_ 11 _N_ _S_ "SS" _N_ _N_,
- (>) = _A_ 2 _U_ 11 _N_ _S_ "SS" _N_ _N_,
- max = _A_ 2 _U_ 22 _N_ _S_ "SS" _N_ _N_,
- min = _A_ 2 _U_ 22 _N_ _S_ "SS" _N_ _N_,
- _tagCmp = _A_ 2 _U_ 11 _N_ _S_ "SS" _N_ _N_ #-}
+ (<) = { _A_ 2 _U_ 11 _N_ _S_ "SS" _N_ _N_ },
+ (<=) = { _A_ 2 _U_ 11 _N_ _S_ "SS" _N_ _N_ },
+ (>=) = { _A_ 2 _U_ 11 _N_ _S_ "SS" _N_ _N_ },
+ (>) = { _A_ 2 _U_ 11 _N_ _S_ "SS" _N_ _N_ },
+ max = { _A_ 2 _U_ 22 _N_ _S_ "SS" _N_ _N_ },
+ min = { _A_ 2 _U_ 22 _N_ _S_ "SS" _N_ _N_ },
+ _tagCmp = { _A_ 2 _U_ 11 _N_ _S_ "SS" _N_ _N_ } #-}
+instance Ord [Integer]
+ {-# GHC_PRAGMA _M_ PreludeBuiltin {-dfun-} _A_ 0 _N_ _N_ _N_ _F_ _IF_ARGS_ 0 0 X 9 _!_ _TUP_8 [{{Eq [Integer]}}, ([Integer] -> [Integer] -> Bool), ([Integer] -> [Integer] -> Bool), ([Integer] -> [Integer] -> Bool), ([Integer] -> [Integer] -> Bool), ([Integer] -> [Integer] -> [Integer]), ([Integer] -> [Integer] -> [Integer]), ([Integer] -> [Integer] -> _CMP_TAG)] [_DFUN_ Eq ([Integer]), _CONSTM_ Ord (<) ([Integer]), _CONSTM_ Ord (<=) ([Integer]), _CONSTM_ Ord (>=) ([Integer]), _CONSTM_ Ord (>) ([Integer]), _CONSTM_ Ord max ([Integer]), _CONSTM_ Ord min ([Integer]), _CONSTM_ Ord _tagCmp ([Integer])] _N_
+ (<) = { _A_ 2 _U_ 11 _N_ _S_ "SS" _N_ _N_ },
+ (<=) = { _A_ 2 _U_ 11 _N_ _S_ "SS" _N_ _N_ },
+ (>=) = { _A_ 2 _U_ 11 _N_ _S_ "SS" _N_ _N_ },
+ (>) = { _A_ 2 _U_ 11 _N_ _S_ "SS" _N_ _N_ },
+ max = { _A_ 2 _U_ 22 _N_ _S_ "SS" _N_ _N_ },
+ min = { _A_ 2 _U_ 22 _N_ _S_ "SS" _N_ _N_ },
+ _tagCmp = { _A_ 2 _U_ 11 _N_ _S_ "SS" _N_ _N_ } #-}
+instance Ord [[Char]]
+ {-# GHC_PRAGMA _M_ PreludeBuiltin {-dfun-} _A_ 0 _N_ _N_ _N_ _F_ _IF_ARGS_ 0 0 X 9 _!_ _TUP_8 [{{Eq [[Char]]}}, ([[Char]] -> [[Char]] -> Bool), ([[Char]] -> [[Char]] -> Bool), ([[Char]] -> [[Char]] -> Bool), ([[Char]] -> [[Char]] -> Bool), ([[Char]] -> [[Char]] -> [[Char]]), ([[Char]] -> [[Char]] -> [[Char]]), ([[Char]] -> [[Char]] -> _CMP_TAG)] [_DFUN_ Eq ([[Char]]), _CONSTM_ Ord (<) ([[Char]]), _CONSTM_ Ord (<=) ([[Char]]), _CONSTM_ Ord (>=) ([[Char]]), _CONSTM_ Ord (>) ([[Char]]), _CONSTM_ Ord max ([[Char]]), _CONSTM_ Ord min ([[Char]]), _CONSTM_ Ord _tagCmp ([[Char]])] _N_
+ (<) = { _A_ 2 _U_ 11 _N_ _S_ "SS" _N_ _N_ },
+ (<=) = { _A_ 2 _U_ 11 _N_ _S_ "SS" _N_ _N_ },
+ (>=) = { _A_ 2 _U_ 11 _N_ _S_ "SS" _N_ _N_ },
+ (>) = { _A_ 2 _U_ 11 _N_ _S_ "SS" _N_ _N_ },
+ max = { _A_ 2 _U_ 22 _N_ _S_ "SS" _N_ _N_ },
+ min = { _A_ 2 _U_ 22 _N_ _S_ "SS" _N_ _N_ },
+ _tagCmp = { _A_ 2 _U_ 11 _N_ _S_ "SS" _N_ _N_ } #-}
+instance Ord [[Int]]
+ {-# GHC_PRAGMA _M_ PreludeBuiltin {-dfun-} _A_ 0 _N_ _N_ _N_ _F_ _IF_ARGS_ 0 0 X 9 _!_ _TUP_8 [{{Eq [[Int]]}}, ([[Int]] -> [[Int]] -> Bool), ([[Int]] -> [[Int]] -> Bool), ([[Int]] -> [[Int]] -> Bool), ([[Int]] -> [[Int]] -> Bool), ([[Int]] -> [[Int]] -> [[Int]]), ([[Int]] -> [[Int]] -> [[Int]]), ([[Int]] -> [[Int]] -> _CMP_TAG)] [_DFUN_ Eq ([[Int]]), _CONSTM_ Ord (<) ([[Int]]), _CONSTM_ Ord (<=) ([[Int]]), _CONSTM_ Ord (>=) ([[Int]]), _CONSTM_ Ord (>) ([[Int]]), _CONSTM_ Ord max ([[Int]]), _CONSTM_ Ord min ([[Int]]), _CONSTM_ Ord _tagCmp ([[Int]])] _N_
+ (<) = { _A_ 2 _U_ 11 _N_ _S_ "SS" _N_ _N_ },
+ (<=) = { _A_ 2 _U_ 11 _N_ _S_ "SS" _N_ _N_ },
+ (>=) = { _A_ 2 _U_ 11 _N_ _S_ "SS" _N_ _N_ },
+ (>) = { _A_ 2 _U_ 11 _N_ _S_ "SS" _N_ _N_ },
+ max = { _A_ 2 _U_ 22 _N_ _S_ "SS" _N_ _N_ },
+ min = { _A_ 2 _U_ 22 _N_ _S_ "SS" _N_ _N_ },
+ _tagCmp = { _A_ 2 _U_ 11 _N_ _S_ "SS" _N_ _N_ } #-}
instance Ord _Addr
{-# GHC_PRAGMA _M_ PreludeCore {-dfun-} _A_ 0 _N_ _N_ _N_ _F_ _IF_ARGS_ 0 0 X 9 _!_ _TUP_8 [{{Eq _Addr}}, (_Addr -> _Addr -> Bool), (_Addr -> _Addr -> Bool), (_Addr -> _Addr -> Bool), (_Addr -> _Addr -> Bool), (_Addr -> _Addr -> _Addr), (_Addr -> _Addr -> _Addr), (_Addr -> _Addr -> _CMP_TAG)] [_DFUN_ Eq (_Addr), _CONSTM_ Ord (<) (_Addr), _CONSTM_ Ord (<=) (_Addr), _CONSTM_ Ord (>=) (_Addr), _CONSTM_ Ord (>) (_Addr), _CONSTM_ Ord max (_Addr), _CONSTM_ Ord min (_Addr), _CONSTM_ Ord _tagCmp (_Addr)] _N_
- (<) = _A_ 2 _U_ 11 _N_ _S_ "U(P)U(P)" {_A_ 2 _U_ 22 _N_ _N_ _F_ _IF_ARGS_ 0 2 XX 1 \ (u0 :: Addr#) (u1 :: Addr#) -> _#_ ltAddr# [] [u0, u1] _N_} _F_ _IF_ARGS_ 0 2 CC 3 \ (u0 :: _Addr) (u1 :: _Addr) -> case u0 of { _ALG_ A# (u2 :: Addr#) -> case u1 of { _ALG_ A# (u3 :: Addr#) -> _#_ ltAddr# [] [u2, u3]; _NO_DEFLT_ }; _NO_DEFLT_ } _N_,
- (<=) = _A_ 2 _U_ 11 _N_ _S_ "U(P)U(P)" {_A_ 2 _U_ 22 _N_ _N_ _F_ _IF_ARGS_ 0 2 XX 1 \ (u0 :: Addr#) (u1 :: Addr#) -> _#_ leAddr# [] [u0, u1] _N_} _F_ _IF_ARGS_ 0 2 CC 3 \ (u0 :: _Addr) (u1 :: _Addr) -> case u0 of { _ALG_ A# (u2 :: Addr#) -> case u1 of { _ALG_ A# (u3 :: Addr#) -> _#_ leAddr# [] [u2, u3]; _NO_DEFLT_ }; _NO_DEFLT_ } _N_,
- (>=) = _A_ 2 _U_ 11 _N_ _S_ "U(P)U(P)" {_A_ 2 _U_ 22 _N_ _N_ _F_ _IF_ARGS_ 0 2 XX 1 \ (u0 :: Addr#) (u1 :: Addr#) -> _#_ geAddr# [] [u0, u1] _N_} _F_ _IF_ARGS_ 0 2 CC 3 \ (u0 :: _Addr) (u1 :: _Addr) -> case u0 of { _ALG_ A# (u2 :: Addr#) -> case u1 of { _ALG_ A# (u3 :: Addr#) -> _#_ geAddr# [] [u2, u3]; _NO_DEFLT_ }; _NO_DEFLT_ } _N_,
- (>) = _A_ 2 _U_ 11 _N_ _S_ "U(P)U(P)" {_A_ 2 _U_ 22 _N_ _N_ _F_ _IF_ARGS_ 0 2 XX 1 \ (u0 :: Addr#) (u1 :: Addr#) -> _#_ gtAddr# [] [u0, u1] _N_} _F_ _IF_ARGS_ 0 2 CC 3 \ (u0 :: _Addr) (u1 :: _Addr) -> case u0 of { _ALG_ A# (u2 :: Addr#) -> case u1 of { _ALG_ A# (u3 :: Addr#) -> _#_ gtAddr# [] [u2, u3]; _NO_DEFLT_ }; _NO_DEFLT_ } _N_,
- max = _A_ 2 _U_ 11 _N_ _S_ "U(P)U(P)" {_A_ 2 _U_ 22 _N_ _N_ _N_ _N_} _N_ _N_,
- min = _A_ 2 _U_ 11 _N_ _S_ "U(P)U(P)" {_A_ 2 _U_ 22 _N_ _N_ _N_ _N_} _N_ _N_,
- _tagCmp = _A_ 2 _U_ 11 _N_ _S_ "U(P)U(P)" {_A_ 2 _U_ 22 _N_ _N_ _N_ _N_} _N_ _N_ #-}
+ (<) = { _A_ 2 _U_ 11 _N_ _S_ "U(P)U(P)" {_A_ 2 _U_ 22 _N_ _N_ _F_ _IF_ARGS_ 0 2 XX 1 \ (u0 :: Addr#) (u1 :: Addr#) -> _#_ ltAddr# [] [u0, u1] _N_} _F_ _IF_ARGS_ 0 2 CC 3 \ (u0 :: _Addr) (u1 :: _Addr) -> case u0 of { _ALG_ A# (u2 :: Addr#) -> case u1 of { _ALG_ A# (u3 :: Addr#) -> _#_ ltAddr# [] [u2, u3]; _NO_DEFLT_ }; _NO_DEFLT_ } _N_ },
+ (<=) = { _A_ 2 _U_ 11 _N_ _S_ "U(P)U(P)" {_A_ 2 _U_ 22 _N_ _N_ _F_ _IF_ARGS_ 0 2 XX 1 \ (u0 :: Addr#) (u1 :: Addr#) -> _#_ leAddr# [] [u0, u1] _N_} _F_ _IF_ARGS_ 0 2 CC 3 \ (u0 :: _Addr) (u1 :: _Addr) -> case u0 of { _ALG_ A# (u2 :: Addr#) -> case u1 of { _ALG_ A# (u3 :: Addr#) -> _#_ leAddr# [] [u2, u3]; _NO_DEFLT_ }; _NO_DEFLT_ } _N_ },
+ (>=) = { _A_ 2 _U_ 11 _N_ _S_ "U(P)U(P)" {_A_ 2 _U_ 22 _N_ _N_ _F_ _IF_ARGS_ 0 2 XX 1 \ (u0 :: Addr#) (u1 :: Addr#) -> _#_ geAddr# [] [u0, u1] _N_} _F_ _IF_ARGS_ 0 2 CC 3 \ (u0 :: _Addr) (u1 :: _Addr) -> case u0 of { _ALG_ A# (u2 :: Addr#) -> case u1 of { _ALG_ A# (u3 :: Addr#) -> _#_ geAddr# [] [u2, u3]; _NO_DEFLT_ }; _NO_DEFLT_ } _N_ },
+ (>) = { _A_ 2 _U_ 11 _N_ _S_ "U(P)U(P)" {_A_ 2 _U_ 22 _N_ _N_ _F_ _IF_ARGS_ 0 2 XX 1 \ (u0 :: Addr#) (u1 :: Addr#) -> _#_ gtAddr# [] [u0, u1] _N_} _F_ _IF_ARGS_ 0 2 CC 3 \ (u0 :: _Addr) (u1 :: _Addr) -> case u0 of { _ALG_ A# (u2 :: Addr#) -> case u1 of { _ALG_ A# (u3 :: Addr#) -> _#_ gtAddr# [] [u2, u3]; _NO_DEFLT_ }; _NO_DEFLT_ } _N_ },
+ max = { _A_ 2 _U_ 11 _N_ _S_ "U(P)U(P)" {_A_ 2 _U_ 22 _N_ _N_ _N_ _N_} _N_ _N_ },
+ min = { _A_ 2 _U_ 11 _N_ _S_ "U(P)U(P)" {_A_ 2 _U_ 22 _N_ _N_ _N_ _N_} _N_ _N_ },
+ _tagCmp = { _A_ 2 _U_ 11 _N_ _S_ "U(P)U(P)" {_A_ 2 _U_ 22 _N_ _N_ _N_ _N_} _N_ _N_ } #-}
instance Ord _PackedString
{-# GHC_PRAGMA _M_ PreludePS {-dfun-} _A_ 0 _N_ _N_ _N_ _F_ _IF_ARGS_ 0 0 X 9 _!_ _TUP_8 [{{Eq _PackedString}}, (_PackedString -> _PackedString -> Bool), (_PackedString -> _PackedString -> Bool), (_PackedString -> _PackedString -> Bool), (_PackedString -> _PackedString -> Bool), (_PackedString -> _PackedString -> _PackedString), (_PackedString -> _PackedString -> _PackedString), (_PackedString -> _PackedString -> _CMP_TAG)] [_DFUN_ Eq (_PackedString), _CONSTM_ Ord (<) (_PackedString), _CONSTM_ Ord (<=) (_PackedString), _CONSTM_ Ord (>=) (_PackedString), _CONSTM_ Ord (>) (_PackedString), _CONSTM_ Ord max (_PackedString), _CONSTM_ Ord min (_PackedString), _CONSTM_ Ord _tagCmp (_PackedString)] _N_
- (<) = _A_ 2 _U_ 22 _N_ _S_ "SS" _N_ _N_,
- (<=) = _A_ 2 _U_ 22 _N_ _S_ "SS" _N_ _N_,
- (>=) = _A_ 2 _U_ 22 _N_ _S_ "SS" _N_ _N_,
- (>) = _A_ 2 _U_ 22 _N_ _S_ "SS" _N_ _N_,
- max = _A_ 2 _U_ 22 _N_ _N_ _N_ _N_,
- min = _A_ 2 _U_ 22 _N_ _N_ _N_ _N_,
- _tagCmp = _A_ 2 _U_ 22 _N_ _S_ "SS" _N_ _N_ #-}
+ (<) = { _A_ 2 _U_ 22 _N_ _S_ "SS" _N_ _N_ },
+ (<=) = { _A_ 2 _U_ 22 _N_ _S_ "SS" _N_ _N_ },
+ (>=) = { _A_ 2 _U_ 22 _N_ _S_ "SS" _N_ _N_ },
+ (>) = { _A_ 2 _U_ 22 _N_ _S_ "SS" _N_ _N_ },
+ max = { _A_ 2 _U_ 22 _N_ _S_ "SS" _N_ _N_ },
+ min = { _A_ 2 _U_ 22 _N_ _S_ "SS" _N_ _N_ },
+ _tagCmp = { _A_ 2 _U_ 22 _N_ _S_ "SS" _N_ _N_ } #-}
instance Ord _Word
{-# GHC_PRAGMA _M_ PreludeCore {-dfun-} _A_ 0 _N_ _N_ _N_ _F_ _IF_ARGS_ 0 0 X 9 _!_ _TUP_8 [{{Eq _Word}}, (_Word -> _Word -> Bool), (_Word -> _Word -> Bool), (_Word -> _Word -> Bool), (_Word -> _Word -> Bool), (_Word -> _Word -> _Word), (_Word -> _Word -> _Word), (_Word -> _Word -> _CMP_TAG)] [_DFUN_ Eq (_Word), _CONSTM_ Ord (<) (_Word), _CONSTM_ Ord (<=) (_Word), _CONSTM_ Ord (>=) (_Word), _CONSTM_ Ord (>) (_Word), _CONSTM_ Ord max (_Word), _CONSTM_ Ord min (_Word), _CONSTM_ Ord _tagCmp (_Word)] _N_
- (<) = _A_ 2 _U_ 11 _N_ _S_ "U(P)U(P)" {_A_ 2 _U_ 22 _N_ _N_ _F_ _IF_ARGS_ 0 2 XX 1 \ (u0 :: Word#) (u1 :: Word#) -> _#_ ltWord# [] [u0, u1] _N_} _F_ _IF_ARGS_ 0 2 CC 3 \ (u0 :: _Word) (u1 :: _Word) -> case u0 of { _ALG_ W# (u2 :: Word#) -> case u1 of { _ALG_ W# (u3 :: Word#) -> _#_ ltWord# [] [u2, u3]; _NO_DEFLT_ }; _NO_DEFLT_ } _N_,
- (<=) = _A_ 2 _U_ 11 _N_ _S_ "U(P)U(P)" {_A_ 2 _U_ 22 _N_ _N_ _F_ _IF_ARGS_ 0 2 XX 1 \ (u0 :: Word#) (u1 :: Word#) -> _#_ leWord# [] [u0, u1] _N_} _F_ _IF_ARGS_ 0 2 CC 3 \ (u0 :: _Word) (u1 :: _Word) -> case u0 of { _ALG_ W# (u2 :: Word#) -> case u1 of { _ALG_ W# (u3 :: Word#) -> _#_ leWord# [] [u2, u3]; _NO_DEFLT_ }; _NO_DEFLT_ } _N_,
- (>=) = _A_ 2 _U_ 11 _N_ _S_ "U(P)U(P)" {_A_ 2 _U_ 22 _N_ _N_ _F_ _IF_ARGS_ 0 2 XX 1 \ (u0 :: Word#) (u1 :: Word#) -> _#_ geWord# [] [u0, u1] _N_} _F_ _IF_ARGS_ 0 2 CC 3 \ (u0 :: _Word) (u1 :: _Word) -> case u0 of { _ALG_ W# (u2 :: Word#) -> case u1 of { _ALG_ W# (u3 :: Word#) -> _#_ geWord# [] [u2, u3]; _NO_DEFLT_ }; _NO_DEFLT_ } _N_,
- (>) = _A_ 2 _U_ 11 _N_ _S_ "U(P)U(P)" {_A_ 2 _U_ 22 _N_ _N_ _F_ _IF_ARGS_ 0 2 XX 1 \ (u0 :: Word#) (u1 :: Word#) -> _#_ gtWord# [] [u0, u1] _N_} _F_ _IF_ARGS_ 0 2 CC 3 \ (u0 :: _Word) (u1 :: _Word) -> case u0 of { _ALG_ W# (u2 :: Word#) -> case u1 of { _ALG_ W# (u3 :: Word#) -> _#_ gtWord# [] [u2, u3]; _NO_DEFLT_ }; _NO_DEFLT_ } _N_,
- max = _A_ 2 _U_ 11 _N_ _S_ "U(P)U(P)" {_A_ 2 _U_ 22 _N_ _N_ _N_ _N_} _N_ _N_,
- min = _A_ 2 _U_ 11 _N_ _S_ "U(P)U(P)" {_A_ 2 _U_ 22 _N_ _N_ _N_ _N_} _N_ _N_,
- _tagCmp = _A_ 2 _U_ 11 _N_ _S_ "U(P)U(P)" {_A_ 2 _U_ 22 _N_ _N_ _N_ _N_} _N_ _N_ #-}
+ (<) = { _A_ 2 _U_ 11 _N_ _S_ "U(P)U(P)" {_A_ 2 _U_ 22 _N_ _N_ _F_ _IF_ARGS_ 0 2 XX 1 \ (u0 :: Word#) (u1 :: Word#) -> _#_ ltWord# [] [u0, u1] _N_} _F_ _IF_ARGS_ 0 2 CC 3 \ (u0 :: _Word) (u1 :: _Word) -> case u0 of { _ALG_ W# (u2 :: Word#) -> case u1 of { _ALG_ W# (u3 :: Word#) -> _#_ ltWord# [] [u2, u3]; _NO_DEFLT_ }; _NO_DEFLT_ } _N_ },
+ (<=) = { _A_ 2 _U_ 11 _N_ _S_ "U(P)U(P)" {_A_ 2 _U_ 22 _N_ _N_ _F_ _IF_ARGS_ 0 2 XX 1 \ (u0 :: Word#) (u1 :: Word#) -> _#_ leWord# [] [u0, u1] _N_} _F_ _IF_ARGS_ 0 2 CC 3 \ (u0 :: _Word) (u1 :: _Word) -> case u0 of { _ALG_ W# (u2 :: Word#) -> case u1 of { _ALG_ W# (u3 :: Word#) -> _#_ leWord# [] [u2, u3]; _NO_DEFLT_ }; _NO_DEFLT_ } _N_ },
+ (>=) = { _A_ 2 _U_ 11 _N_ _S_ "U(P)U(P)" {_A_ 2 _U_ 22 _N_ _N_ _F_ _IF_ARGS_ 0 2 XX 1 \ (u0 :: Word#) (u1 :: Word#) -> _#_ geWord# [] [u0, u1] _N_} _F_ _IF_ARGS_ 0 2 CC 3 \ (u0 :: _Word) (u1 :: _Word) -> case u0 of { _ALG_ W# (u2 :: Word#) -> case u1 of { _ALG_ W# (u3 :: Word#) -> _#_ geWord# [] [u2, u3]; _NO_DEFLT_ }; _NO_DEFLT_ } _N_ },
+ (>) = { _A_ 2 _U_ 11 _N_ _S_ "U(P)U(P)" {_A_ 2 _U_ 22 _N_ _N_ _F_ _IF_ARGS_ 0 2 XX 1 \ (u0 :: Word#) (u1 :: Word#) -> _#_ gtWord# [] [u0, u1] _N_} _F_ _IF_ARGS_ 0 2 CC 3 \ (u0 :: _Word) (u1 :: _Word) -> case u0 of { _ALG_ W# (u2 :: Word#) -> case u1 of { _ALG_ W# (u3 :: Word#) -> _#_ gtWord# [] [u2, u3]; _NO_DEFLT_ }; _NO_DEFLT_ } _N_ },
+ max = { _A_ 2 _U_ 11 _N_ _S_ "U(P)U(P)" {_A_ 2 _U_ 22 _N_ _N_ _N_ _N_} _N_ _N_ },
+ min = { _A_ 2 _U_ 11 _N_ _S_ "U(P)U(P)" {_A_ 2 _U_ 22 _N_ _N_ _N_ _N_} _N_ _N_ },
+ _tagCmp = { _A_ 2 _U_ 11 _N_ _S_ "U(P)U(P)" {_A_ 2 _U_ 22 _N_ _N_ _N_ _N_} _N_ _N_ } #-}
instance Real Double
{-# GHC_PRAGMA _M_ PreludeCore {-dfun-} _A_ 0 _N_ _N_ _N_ _F_ _IF_ARGS_ 0 0 X 4 _!_ _TUP_3 [{{Num Double}}, {{Enum Double}}, (Double -> Ratio Integer)] [_DFUN_ Num (Double), _DFUN_ Enum (Double), _CONSTM_ Real toRational (Double)] _N_
- toRational = _A_ 1 _U_ 1 _N_ _S_ "U(P)" {_A_ 1 _U_ 2 _N_ _N_ _N_ _N_} _N_ _N_ #-}
+ toRational = { _A_ 1 _U_ 1 _N_ _S_ "U(P)" {_A_ 1 _U_ 2 _N_ _N_ _N_ _N_} _N_ _N_ } #-}
instance Real Float
{-# GHC_PRAGMA _M_ PreludeCore {-dfun-} _A_ 0 _N_ _N_ _N_ _F_ _IF_ARGS_ 0 0 X 4 _!_ _TUP_3 [{{Num Float}}, {{Enum Float}}, (Float -> Ratio Integer)] [_DFUN_ Num (Float), _DFUN_ Enum (Float), _CONSTM_ Real toRational (Float)] _N_
- toRational = _A_ 1 _U_ 1 _N_ _S_ "U(P)" {_A_ 1 _U_ 2 _N_ _N_ _N_ _N_} _N_ _N_ #-}
+ toRational = { _A_ 1 _U_ 1 _N_ _S_ "U(P)" {_A_ 1 _U_ 2 _N_ _N_ _N_ _N_} _N_ _N_ } #-}
instance Real Int
{-# GHC_PRAGMA _M_ PreludeCore {-dfun-} _A_ 0 _N_ _N_ _N_ _F_ _IF_ARGS_ 0 0 X 4 _!_ _TUP_3 [{{Num Int}}, {{Enum Int}}, (Int -> Ratio Integer)] [_DFUN_ Num (Int), _DFUN_ Enum (Int), _CONSTM_ Real toRational (Int)] _N_
- toRational = _A_ 1 _U_ 1 _N_ _N_ _N_ _N_ #-}
+ toRational = { _A_ 1 _U_ 1 _N_ _N_ _N_ _N_ } #-}
instance Real Integer
{-# GHC_PRAGMA _M_ PreludeCore {-dfun-} _A_ 0 _N_ _N_ _N_ _F_ _IF_ARGS_ 0 0 X 4 _!_ _TUP_3 [{{Num Integer}}, {{Enum Integer}}, (Integer -> Ratio Integer)] [_DFUN_ Num (Integer), _DFUN_ Enum (Integer), _CONSTM_ Real toRational (Integer)] _N_
- toRational = _A_ 1 _U_ 2 _N_ _N_ _N_ _N_ #-}
+ toRational = { _A_ 1 _U_ 2 _N_ _N_ _F_ _IF_ARGS_ 0 1 X 3 \ (u0 :: Integer) -> _!_ (:%) [Integer] [u0, _ORIG_ PreludeCore __integer1] _N_ } #-}
instance Integral a => Real (Ratio a)
{-# GHC_PRAGMA _M_ PreludeRatio {-dfun-} _A_ 3 _U_ 122 _N_ _N_ _N_ _N_ #-}
instance Real (Ratio Integer)
{-# GHC_PRAGMA _M_ PreludeRatio {-dfun-} _A_ 0 _N_ _N_ _N_ _F_ _IF_ARGS_ 0 0 X 4 _!_ _TUP_3 [{{Num (Ratio Integer)}}, {{Enum (Ratio Integer)}}, (Ratio Integer -> Ratio Integer)] [_DFUN_ Num (Ratio Integer), _DFUN_ Enum (Ratio Integer), _CONSTM_ Real toRational (Ratio Integer)] _N_
- toRational = _A_ 1 _U_ 1 _N_ _S_ "U(LL)" {_A_ 2 _U_ 22 _N_ _N_ _F_ _IF_ARGS_ 0 2 XX 3 \ (u0 :: Integer) (u1 :: Integer) -> _!_ (:%) [Integer] [u0, u1] _N_} _F_ _IF_ARGS_ 0 1 X 1 \ (u0 :: Ratio Integer) -> u0 _N_ #-}
+ toRational = { _A_ 1 _U_ 1 _N_ _S_ "U(LL)" {_A_ 2 _U_ 22 _N_ _N_ _F_ _IF_ARGS_ 0 2 XX 3 \ (u0 :: Integer) (u1 :: Integer) -> _!_ (:%) [Integer] [u0, u1] _N_} _F_ _IF_ARGS_ 0 1 X 1 \ (u0 :: Ratio Integer) -> u0 _N_ } #-}
instance RealFloat Double
{-# GHC_PRAGMA _M_ PreludeCore {-dfun-} _A_ 0 _N_ _N_ _N_ _F_ _IF_ARGS_ 0 0 X 11 _!_ _TUP_10 [{{RealFrac Double}}, {{Floating Double}}, (Double -> Integer), (Double -> Int), (Double -> (Int, Int)), (Double -> (Integer, Int)), (Integer -> Int -> Double), (Double -> Int), (Double -> Double), (Int -> Double -> Double)] [_DFUN_ RealFrac (Double), _DFUN_ Floating (Double), _CONSTM_ RealFloat floatRadix (Double), _CONSTM_ RealFloat floatDigits (Double), _CONSTM_ RealFloat floatRange (Double), _CONSTM_ RealFloat decodeFloat (Double), _CONSTM_ RealFloat encodeFloat (Double), _CONSTM_ RealFloat exponent (Double), _CONSTM_ RealFloat significand (Double), _CONSTM_ RealFloat scaleFloat (Double)] _N_
- floatRadix = _A_ 1 _U_ 0 _N_ _S_ "A" {_A_ 0 _N_ _N_ _N_ _F_ _IF_ARGS_ 0 0 X 1 _#_ int2Integer# [] [2#] _N_} _N_ _N_,
- floatDigits = _A_ 1 _U_ 0 _N_ _S_ "A" {_A_ 0 _N_ _N_ _N_ _F_ _IF_ARGS_ 0 0 X 2 _!_ I# [] [53#] _N_} _F_ _IF_ARGS_ 0 1 X 2 \ (u0 :: Double) -> _!_ I# [] [53#] _N_,
- floatRange = _A_ 1 _U_ 0 _N_ _S_ "A" {_A_ 0 _N_ _N_ _N_ _N_ _N_} _N_ _N_,
- decodeFloat = _A_ 1 _U_ 1 _N_ _S_ "U(P)" {_A_ 1 _U_ 2 _N_ _N_ _N_ _N_} _N_ _N_,
- encodeFloat = _A_ 2 _U_ 11 _N_ _S_ "U(PPP)U(P)" {_A_ 4 _U_ 2222 _N_ _N_ _F_ _IF_ARGS_ 0 4 XXXX 3 \ (u0 :: Int#) (u1 :: Int#) (u2 :: ByteArray#) (u3 :: Int#) -> case _#_ encodeDouble# [] [u0, u1, u2, u3] of { _PRIM_ (u4 :: Double#) -> _!_ D# [] [u4] } _N_} _F_ _IF_ARGS_ 0 2 CC 5 \ (u0 :: Integer) (u1 :: Int) -> case u0 of { _ALG_ J# (u2 :: Int#) (u3 :: Int#) (u4 :: ByteArray#) -> case u1 of { _ALG_ I# (u5 :: Int#) -> case _#_ encodeDouble# [] [u2, u3, u4, u5] of { _PRIM_ (u6 :: Double#) -> _!_ D# [] [u6] }; _NO_DEFLT_ }; _NO_DEFLT_ } _N_,
- exponent = _A_ 1 _U_ 2 _N_ _N_ _N_ _N_,
- significand = _A_ 1 _U_ 2 _N_ _N_ _N_ _N_,
- scaleFloat = _A_ 2 _U_ 22 _N_ _N_ _N_ _N_ #-}
+ floatRadix = { _A_ 1 _U_ 0 _N_ _S_ "A" {_A_ 0 _N_ _N_ _N_ _N_ _N_} _N_ _N_ },
+ floatDigits = { _A_ 1 _U_ 0 _N_ _S_ "A" {_A_ 0 _N_ _N_ _N_ _F_ _IF_ARGS_ 0 0 X 2 _!_ I# [] [53#] _N_} _F_ _IF_ARGS_ 0 1 X 2 \ (u0 :: Double) -> _!_ I# [] [53#] _N_ },
+ floatRange = { _A_ 1 _U_ 0 _N_ _S_ "A" {_A_ 0 _N_ _N_ _N_ _N_ _N_} _N_ _N_ },
+ decodeFloat = { _A_ 1 _U_ 1 _N_ _S_ "U(P)" {_A_ 1 _U_ 2 _N_ _N_ _N_ _N_} _N_ _N_ },
+ encodeFloat = { _A_ 2 _U_ 11 _N_ _S_ "U(PPP)U(P)" {_A_ 4 _U_ 2222 _N_ _N_ _F_ _IF_ARGS_ 0 4 XXXX 3 \ (u0 :: Int#) (u1 :: Int#) (u2 :: ByteArray#) (u3 :: Int#) -> case _#_ encodeDouble# [] [u0, u1, u2, u3] of { _PRIM_ (u4 :: Double#) -> _!_ D# [] [u4] } _N_} _F_ _IF_ARGS_ 0 2 CC 5 \ (u0 :: Integer) (u1 :: Int) -> case u0 of { _ALG_ J# (u2 :: Int#) (u3 :: Int#) (u4 :: ByteArray#) -> case u1 of { _ALG_ I# (u5 :: Int#) -> case _#_ encodeDouble# [] [u2, u3, u4, u5] of { _PRIM_ (u6 :: Double#) -> _!_ D# [] [u6] }; _NO_DEFLT_ }; _NO_DEFLT_ } _N_ },
+ exponent = { _A_ 1 _U_ 1 _N_ _S_ "U(P)" {_A_ 1 _U_ 2 _N_ _N_ _N_ _N_} _N_ _N_ },
+ significand = { _A_ 1 _U_ 1 _N_ _S_ "U(P)" {_A_ 1 _U_ 2 _N_ _N_ _N_ _N_} _N_ _N_ },
+ scaleFloat = { _A_ 2 _U_ 11 _N_ _S_ "U(P)U(P)" {_A_ 2 _U_ 22 _N_ _N_ _N_ _N_} _N_ _N_ } #-}
instance RealFloat Float
{-# GHC_PRAGMA _M_ PreludeCore {-dfun-} _A_ 0 _N_ _N_ _N_ _F_ _IF_ARGS_ 0 0 X 11 _!_ _TUP_10 [{{RealFrac Float}}, {{Floating Float}}, (Float -> Integer), (Float -> Int), (Float -> (Int, Int)), (Float -> (Integer, Int)), (Integer -> Int -> Float), (Float -> Int), (Float -> Float), (Int -> Float -> Float)] [_DFUN_ RealFrac (Float), _DFUN_ Floating (Float), _CONSTM_ RealFloat floatRadix (Float), _CONSTM_ RealFloat floatDigits (Float), _CONSTM_ RealFloat floatRange (Float), _CONSTM_ RealFloat decodeFloat (Float), _CONSTM_ RealFloat encodeFloat (Float), _CONSTM_ RealFloat exponent (Float), _CONSTM_ RealFloat significand (Float), _CONSTM_ RealFloat scaleFloat (Float)] _N_
- floatRadix = _A_ 1 _U_ 0 _N_ _S_ "A" {_A_ 0 _N_ _N_ _N_ _F_ _IF_ARGS_ 0 0 X 1 _#_ int2Integer# [] [2#] _N_} _N_ _N_,
- floatDigits = _A_ 1 _U_ 0 _N_ _S_ "A" {_A_ 0 _N_ _N_ _N_ _F_ _IF_ARGS_ 0 0 X 2 _!_ I# [] [24#] _N_} _F_ _IF_ARGS_ 0 1 X 2 \ (u0 :: Float) -> _!_ I# [] [24#] _N_,
- floatRange = _A_ 1 _U_ 0 _N_ _S_ "A" {_A_ 0 _N_ _N_ _N_ _N_ _N_} _N_ _N_,
- decodeFloat = _A_ 1 _U_ 1 _N_ _S_ "U(P)" {_A_ 1 _U_ 2 _N_ _N_ _N_ _N_} _N_ _N_,
- encodeFloat = _A_ 2 _U_ 11 _N_ _S_ "U(PPP)U(P)" {_A_ 4 _U_ 2222 _N_ _N_ _F_ _IF_ARGS_ 0 4 XXXX 3 \ (u0 :: Int#) (u1 :: Int#) (u2 :: ByteArray#) (u3 :: Int#) -> case _#_ encodeFloat# [] [u0, u1, u2, u3] of { _PRIM_ (u4 :: Float#) -> _!_ F# [] [u4] } _N_} _F_ _IF_ARGS_ 0 2 CC 5 \ (u0 :: Integer) (u1 :: Int) -> case u0 of { _ALG_ J# (u2 :: Int#) (u3 :: Int#) (u4 :: ByteArray#) -> case u1 of { _ALG_ I# (u5 :: Int#) -> case _#_ encodeFloat# [] [u2, u3, u4, u5] of { _PRIM_ (u6 :: Float#) -> _!_ F# [] [u6] }; _NO_DEFLT_ }; _NO_DEFLT_ } _N_,
- exponent = _A_ 1 _U_ 2 _N_ _N_ _N_ _N_,
- significand = _A_ 1 _U_ 2 _N_ _N_ _N_ _N_,
- scaleFloat = _A_ 2 _U_ 22 _N_ _N_ _N_ _N_ #-}
+ floatRadix = { _A_ 1 _U_ 0 _N_ _S_ "A" {_A_ 0 _N_ _N_ _N_ _N_ _N_} _N_ _N_ },
+ floatDigits = { _A_ 1 _U_ 0 _N_ _S_ "A" {_A_ 0 _N_ _N_ _N_ _F_ _IF_ARGS_ 0 0 X 2 _!_ I# [] [24#] _N_} _F_ _IF_ARGS_ 0 1 X 2 \ (u0 :: Float) -> _!_ I# [] [24#] _N_ },
+ floatRange = { _A_ 1 _U_ 0 _N_ _S_ "A" {_A_ 0 _N_ _N_ _N_ _N_ _N_} _N_ _N_ },
+ decodeFloat = { _A_ 1 _U_ 1 _N_ _S_ "U(P)" {_A_ 1 _U_ 2 _N_ _N_ _N_ _N_} _N_ _N_ },
+ encodeFloat = { _A_ 2 _U_ 11 _N_ _S_ "U(PPP)U(P)" {_A_ 4 _U_ 2222 _N_ _N_ _F_ _IF_ARGS_ 0 4 XXXX 3 \ (u0 :: Int#) (u1 :: Int#) (u2 :: ByteArray#) (u3 :: Int#) -> case _#_ encodeFloat# [] [u0, u1, u2, u3] of { _PRIM_ (u4 :: Float#) -> _!_ F# [] [u4] } _N_} _F_ _IF_ARGS_ 0 2 CC 5 \ (u0 :: Integer) (u1 :: Int) -> case u0 of { _ALG_ J# (u2 :: Int#) (u3 :: Int#) (u4 :: ByteArray#) -> case u1 of { _ALG_ I# (u5 :: Int#) -> case _#_ encodeFloat# [] [u2, u3, u4, u5] of { _PRIM_ (u6 :: Float#) -> _!_ F# [] [u6] }; _NO_DEFLT_ }; _NO_DEFLT_ } _N_ },
+ exponent = { _A_ 1 _U_ 1 _N_ _S_ "U(P)" {_A_ 1 _U_ 2 _N_ _N_ _N_ _N_} _N_ _N_ },
+ significand = { _A_ 1 _U_ 1 _N_ _S_ "U(P)" {_A_ 1 _U_ 2 _N_ _N_ _N_ _N_} _N_ _N_ },
+ scaleFloat = { _A_ 2 _U_ 11 _N_ _S_ "U(P)U(P)" {_A_ 2 _U_ 22 _N_ _N_ _N_ _N_} _N_ _N_ } #-}
instance RealFrac Double
{-# GHC_PRAGMA _M_ PreludeCore {-dfun-} _A_ 0 _N_ _N_ _N_ _F_ _IF_ARGS_ 0 0 X 8 _!_ _TUP_7 [{{Real Double}}, {{Fractional Double}}, _forall_ a$z1 =>{{Integral a$z1}} -> (Double -> (a$z1, Double)), _forall_ a$z1 =>{{Integral a$z1}} -> (Double -> a$z1), _forall_ a$z1 =>{{Integral a$z1}} -> (Double -> a$z1), _forall_ a$z1 =>{{Integral a$z1}} -> (Double -> a$z1), _forall_ a$z1 =>{{Integral a$z1}} -> (Double -> a$z1)] [_DFUN_ Real (Double), _DFUN_ Fractional (Double), _CONSTM_ RealFrac properFraction (Double), _CONSTM_ RealFrac truncate (Double), _CONSTM_ RealFrac round (Double), _CONSTM_ RealFrac ceiling (Double), _CONSTM_ RealFrac floor (Double)] _N_
- properFraction = _A_ 1 _U_ 22 _N_ _N_ _N_ _N_,
- truncate = _A_ 1 _U_ 22 _N_ _N_ _N_ _N_,
- round = _A_ 1 _U_ 22 _N_ _N_ _N_ _N_,
- ceiling = _A_ 1 _U_ 22 _N_ _N_ _N_ _N_,
- floor = _A_ 1 _U_ 22 _N_ _N_ _N_ _N_ #-}
+ properFraction = { _A_ 1 _U_ 11 _N_ _N_ _N_ _SPECIALISE_ [ Int ] 1 { _A_ 1 _U_ 1 _N_ _S_ "U(P)" {_A_ 1 _U_ 2 _N_ _N_ _N_ _N_} _N_ _N_ }, [ Integer ] 1 { _A_ 1 _U_ 1 _N_ _S_ "U(P)" {_A_ 1 _U_ 2 _N_ _N_ _N_ _N_} _N_ _N_ } },
+ truncate = { _A_ 1 _U_ 11 _N_ _N_ _N_ _SPECIALISE_ [ Int ] 1 { _A_ 1 _U_ 1 _N_ _S_ "U(P)" {_A_ 1 _U_ 2 _N_ _N_ _F_ _IF_ARGS_ 0 1 X 4 \ (u0 :: Double#) -> case _APP_ _WRKR_ _SPEC_ _CONSTM_ RealFrac properFraction (Double) [ (Int) ] [ u0 ] of { _ALG_ _TUP_2 (u1 :: Int) (u2 :: Double) -> u1; _NO_DEFLT_ } _N_} _F_ _IF_ARGS_ 0 1 X 4 \ (u0 :: Double) -> case _APP_ _SPEC_ _CONSTM_ RealFrac properFraction (Double) [ (Int) ] [ u0 ] of { _ALG_ _TUP_2 (u1 :: Int) (u2 :: Double) -> u1; _NO_DEFLT_ } _N_ }, [ Integer ] 1 { _A_ 1 _U_ 1 _N_ _S_ "U(P)" {_A_ 1 _U_ 2 _N_ _N_ _F_ _IF_ARGS_ 0 1 X 4 \ (u0 :: Double#) -> case _APP_ _WRKR_ _SPEC_ _CONSTM_ RealFrac properFraction (Double) [ (Integer) ] [ u0 ] of { _ALG_ _TUP_2 (u1 :: Integer) (u2 :: Double) -> u1; _NO_DEFLT_ } _N_} _F_ _IF_ARGS_ 0 1 X 4 \ (u0 :: Double) -> case _APP_ _SPEC_ _CONSTM_ RealFrac properFraction (Double) [ (Integer) ] [ u0 ] of { _ALG_ _TUP_2 (u1 :: Integer) (u2 :: Double) -> u1; _NO_DEFLT_ } _N_ } },
+ round = { _A_ 1 _U_ 21 _N_ _N_ _N_ _SPECIALISE_ [ Int ] 1 { _A_ 1 _U_ 1 _N_ _S_ "U(P)" {_A_ 1 _U_ 2 _N_ _N_ _N_ _N_} _N_ _N_ }, [ Integer ] 1 { _A_ 1 _U_ 1 _N_ _S_ "U(P)" {_A_ 1 _U_ 2 _N_ _N_ _N_ _N_} _N_ _N_ } },
+ ceiling = { _A_ 1 _U_ 21 _N_ _N_ _N_ _SPECIALISE_ [ Int ] 1 { _A_ 1 _U_ 1 _N_ _S_ "U(P)" {_A_ 1 _U_ 2 _N_ _N_ _N_ _N_} _N_ _N_ }, [ Integer ] 1 { _A_ 1 _U_ 1 _N_ _S_ "U(P)" {_A_ 1 _U_ 2 _N_ _N_ _N_ _N_} _N_ _N_ } },
+ floor = { _A_ 1 _U_ 21 _N_ _N_ _N_ _SPECIALISE_ [ Int ] 1 { _A_ 1 _U_ 1 _N_ _S_ "U(P)" {_A_ 1 _U_ 2 _N_ _N_ _N_ _N_} _N_ _N_ }, [ Integer ] 1 { _A_ 1 _U_ 1 _N_ _S_ "U(P)" {_A_ 1 _U_ 2 _N_ _N_ _N_ _N_} _N_ _N_ } } #-}
instance RealFrac Float
{-# GHC_PRAGMA _M_ PreludeCore {-dfun-} _A_ 0 _N_ _N_ _N_ _F_ _IF_ARGS_ 0 0 X 8 _!_ _TUP_7 [{{Real Float}}, {{Fractional Float}}, _forall_ a$z1 =>{{Integral a$z1}} -> (Float -> (a$z1, Float)), _forall_ a$z1 =>{{Integral a$z1}} -> (Float -> a$z1), _forall_ a$z1 =>{{Integral a$z1}} -> (Float -> a$z1), _forall_ a$z1 =>{{Integral a$z1}} -> (Float -> a$z1), _forall_ a$z1 =>{{Integral a$z1}} -> (Float -> a$z1)] [_DFUN_ Real (Float), _DFUN_ Fractional (Float), _CONSTM_ RealFrac properFraction (Float), _CONSTM_ RealFrac truncate (Float), _CONSTM_ RealFrac round (Float), _CONSTM_ RealFrac ceiling (Float), _CONSTM_ RealFrac floor (Float)] _N_
- properFraction = _A_ 1 _U_ 22 _N_ _N_ _N_ _N_,
- truncate = _A_ 1 _U_ 22 _N_ _N_ _N_ _N_,
- round = _A_ 1 _U_ 22 _N_ _N_ _N_ _N_,
- ceiling = _A_ 1 _U_ 22 _N_ _N_ _N_ _N_,
- floor = _A_ 1 _U_ 22 _N_ _N_ _N_ _N_ #-}
-instance Integral a => RealFrac (Ratio a)
- {-# GHC_PRAGMA _M_ PreludeRatio {-dfun-} _A_ 3 _U_ 222 _N_ _N_ _N_ _N_ #-}
+ properFraction = { _A_ 1 _U_ 11 _N_ _N_ _N_ _SPECIALISE_ [ Int ] 1 { _A_ 1 _U_ 1 _N_ _S_ "U(P)" {_A_ 1 _U_ 2 _N_ _N_ _N_ _N_} _N_ _N_ }, [ Integer ] 1 { _A_ 1 _U_ 1 _N_ _S_ "U(P)" {_A_ 1 _U_ 2 _N_ _N_ _N_ _N_} _N_ _N_ } },
+ truncate = { _A_ 1 _U_ 11 _N_ _N_ _N_ _SPECIALISE_ [ Int ] 1 { _A_ 1 _U_ 1 _N_ _S_ "U(P)" {_A_ 1 _U_ 2 _N_ _N_ _F_ _IF_ARGS_ 0 1 X 4 \ (u0 :: Float#) -> case _APP_ _WRKR_ _SPEC_ _CONSTM_ RealFrac properFraction (Float) [ (Int) ] [ u0 ] of { _ALG_ _TUP_2 (u1 :: Int) (u2 :: Float) -> u1; _NO_DEFLT_ } _N_} _F_ _IF_ARGS_ 0 1 X 4 \ (u0 :: Float) -> case _APP_ _SPEC_ _CONSTM_ RealFrac properFraction (Float) [ (Int) ] [ u0 ] of { _ALG_ _TUP_2 (u1 :: Int) (u2 :: Float) -> u1; _NO_DEFLT_ } _N_ }, [ Integer ] 1 { _A_ 1 _U_ 1 _N_ _S_ "U(P)" {_A_ 1 _U_ 2 _N_ _N_ _F_ _IF_ARGS_ 0 1 X 4 \ (u0 :: Float#) -> case _APP_ _WRKR_ _SPEC_ _CONSTM_ RealFrac properFraction (Float) [ (Integer) ] [ u0 ] of { _ALG_ _TUP_2 (u1 :: Integer) (u2 :: Float) -> u1; _NO_DEFLT_ } _N_} _F_ _IF_ARGS_ 0 1 X 4 \ (u0 :: Float) -> case _APP_ _SPEC_ _CONSTM_ RealFrac properFraction (Float) [ (Integer) ] [ u0 ] of { _ALG_ _TUP_2 (u1 :: Integer) (u2 :: Float) -> u1; _NO_DEFLT_ } _N_ } },
+ round = { _A_ 1 _U_ 21 _N_ _N_ _N_ _SPECIALISE_ [ Int ] 1 { _A_ 1 _U_ 1 _N_ _S_ "U(P)" {_A_ 1 _U_ 2 _N_ _N_ _N_ _N_} _N_ _N_ }, [ Integer ] 1 { _A_ 1 _U_ 1 _N_ _S_ "U(P)" {_A_ 1 _U_ 2 _N_ _N_ _N_ _N_} _N_ _N_ } },
+ ceiling = { _A_ 1 _U_ 21 _N_ _N_ _N_ _SPECIALISE_ [ Int ] 1 { _A_ 1 _U_ 1 _N_ _S_ "U(P)" {_A_ 1 _U_ 2 _N_ _N_ _N_ _N_} _N_ _N_ }, [ Integer ] 1 { _A_ 1 _U_ 1 _N_ _S_ "U(P)" {_A_ 1 _U_ 2 _N_ _N_ _N_ _N_} _N_ _N_ } },
+ floor = { _A_ 1 _U_ 21 _N_ _N_ _N_ _SPECIALISE_ [ Int ] 1 { _A_ 1 _U_ 1 _N_ _S_ "U(P)" {_A_ 1 _U_ 2 _N_ _N_ _N_ _N_} _N_ _N_ }, [ Integer ] 1 { _A_ 1 _U_ 1 _N_ _S_ "U(P)" {_A_ 1 _U_ 2 _N_ _N_ _N_ _N_} _N_ _N_ } } #-}
instance RealFrac (Ratio Integer)
{-# GHC_PRAGMA _M_ PreludeRatio {-dfun-} _A_ 0 _N_ _N_ _N_ _F_ _IF_ARGS_ 0 0 X 8 _!_ _TUP_7 [{{Real (Ratio Integer)}}, {{Fractional (Ratio Integer)}}, _forall_ a$z1 =>{{Integral a$z1}} -> (Ratio Integer -> (a$z1, Ratio Integer)), _forall_ a$z1 =>{{Integral a$z1}} -> (Ratio Integer -> a$z1), _forall_ a$z1 =>{{Integral a$z1}} -> (Ratio Integer -> a$z1), _forall_ a$z1 =>{{Integral a$z1}} -> (Ratio Integer -> a$z1), _forall_ a$z1 =>{{Integral a$z1}} -> (Ratio Integer -> a$z1)] [_DFUN_ Real (Ratio Integer), _DFUN_ Fractional (Ratio Integer), _CONSTM_ RealFrac properFraction (Ratio Integer), _CONSTM_ RealFrac truncate (Ratio Integer), _CONSTM_ RealFrac round (Ratio Integer), _CONSTM_ RealFrac ceiling (Ratio Integer), _CONSTM_ RealFrac floor (Ratio Integer)] _N_
- properFraction = _A_ 2 _U_ 11 _N_ _S_ "LU(LL)" {_A_ 3 _U_ 112 _N_ _N_ _N_ _N_} _N_ _N_,
- truncate = _A_ 1 _U_ 22 _N_ _N_ _F_ _IF_ARGS_ 1 1 X 3 _/\_ u0 -> \ (u1 :: {{Integral u0}}) -> _APP_ _TYAPP_ _TYAPP_ _WRKR_ _ORIG_ PreludeCore _truncate { (Ratio Integer) } { u0 } [ _CONSTM_ RealFrac properFraction (Ratio Integer), u1 ] _N_,
- round = _A_ 1 _U_ 22 _N_ _N_ _N_ _N_,
- ceiling = _A_ 1 _U_ 22 _N_ _N_ _N_ _N_,
- floor = _A_ 1 _U_ 22 _N_ _N_ _N_ _N_ #-}
+ properFraction = { _A_ 2 _U_ 11 _N_ _S_ "LU(U(PPP)U(PPP))" {_A_ 5 _U_ 12222 _N_ _N_ _N_ _N_} _N_ _SPECIALISE_ [ Int ] 1 { _A_ 1 _U_ 1 _N_ _S_ "U(U(PPP)U(PPP))" {_A_ 4 _U_ 2222 _N_ _N_ _N_ _N_} _N_ _N_ }, [ Integer ] 1 { _A_ 1 _U_ 1 _N_ _S_ "U(U(PPP)U(PPP))" {_A_ 4 _U_ 2222 _N_ _N_ _N_ _N_} _N_ _N_ } },
+ truncate = { _A_ 2 _U_ 11 _N_ _N_ _N_ _SPECIALISE_ [ Int ] 1 { _A_ 1 _U_ 1 _N_ _S_ "U(U(PPP)U(PPP))" {_A_ 4 _U_ 2222 _N_ _N_ _F_ _IF_ARGS_ 0 4 XXXX 7 \ (u0 :: Int#) (u1 :: Int#) (u2 :: ByteArray#) (u3 :: Integer) -> case _APP_ _WRKR_ _SPEC_ _CONSTM_ RealFrac properFraction (Ratio Integer) [ (Int) ] [ u0, u1, u2, u3 ] of { _ALG_ _TUP_2 (u4 :: Int) (u5 :: Ratio Integer) -> u4; _NO_DEFLT_ } _N_} _F_ _IF_ARGS_ 0 1 X 4 \ (u0 :: Ratio Integer) -> case _APP_ _SPEC_ _CONSTM_ RealFrac properFraction (Ratio Integer) [ (Int) ] [ u0 ] of { _ALG_ _TUP_2 (u1 :: Int) (u2 :: Ratio Integer) -> u1; _NO_DEFLT_ } _N_ }, [ Integer ] 1 { _A_ 1 _U_ 1 _N_ _S_ "U(U(PPP)U(PPP))" {_A_ 4 _U_ 2222 _N_ _N_ _F_ _IF_ARGS_ 0 4 XXXX 7 \ (u0 :: Int#) (u1 :: Int#) (u2 :: ByteArray#) (u3 :: Integer) -> case _APP_ _WRKR_ _SPEC_ _CONSTM_ RealFrac properFraction (Ratio Integer) [ (Integer) ] [ u0, u1, u2, u3 ] of { _ALG_ _TUP_2 (u4 :: Integer) (u5 :: Ratio Integer) -> u4; _NO_DEFLT_ } _N_} _F_ _IF_ARGS_ 0 1 X 4 \ (u0 :: Ratio Integer) -> case _APP_ _SPEC_ _CONSTM_ RealFrac properFraction (Ratio Integer) [ (Integer) ] [ u0 ] of { _ALG_ _TUP_2 (u1 :: Integer) (u2 :: Ratio Integer) -> u1; _NO_DEFLT_ } _N_ } },
+ round = { _A_ 1 _U_ 21 _N_ _N_ _N_ _SPECIALISE_ [ Int ] 1 { _A_ 1 _U_ 1 _N_ _S_ "U(U(PPP)U(PPP))" {_A_ 4 _U_ 2222 _N_ _N_ _N_ _N_} _N_ _N_ }, [ Integer ] 1 { _A_ 1 _U_ 1 _N_ _S_ "U(U(PPP)U(PPP))" {_A_ 4 _U_ 2222 _N_ _N_ _N_ _N_} _N_ _N_ } },
+ ceiling = { _A_ 1 _U_ 21 _N_ _N_ _N_ _SPECIALISE_ [ Int ] 1 { _A_ 1 _U_ 1 _N_ _S_ "U(U(PPP)U(PPP))" {_A_ 4 _U_ 2222 _N_ _N_ _N_ _N_} _N_ _N_ }, [ Integer ] 1 { _A_ 1 _U_ 1 _N_ _S_ "U(U(PPP)U(PPP))" {_A_ 4 _U_ 2222 _N_ _N_ _N_ _N_} _N_ _N_ } },
+ floor = { _A_ 1 _U_ 21 _N_ _N_ _N_ _SPECIALISE_ [ Int ] 1 { _A_ 1 _U_ 1 _N_ _S_ "U(U(PPP)U(PPP))" {_A_ 4 _U_ 2222 _N_ _N_ _N_ _N_} _N_ _N_ }, [ Integer ] 1 { _A_ 1 _U_ 1 _N_ _S_ "U(U(PPP)U(PPP))" {_A_ 4 _U_ 2222 _N_ _N_ _N_ _N_} _N_ _N_ } } #-}
+instance Text ((Int, Int), (Int, Int))
+ {-# GHC_PRAGMA _M_ PreludeBuiltin {-dfun-} _A_ 0 _N_ _N_ _N_ _F_ _IF_ARGS_ 0 0 X 5 _!_ _TUP_4 [(Int -> [Char] -> [(((Int, Int), (Int, Int)), [Char])]), (Int -> ((Int, Int), (Int, Int)) -> [Char] -> [Char]), ([Char] -> [([((Int, Int), (Int, Int))], [Char])]), ([((Int, Int), (Int, Int))] -> [Char] -> [Char])] [_CONSTM_ Text readsPrec (((Int, Int), (Int, Int))), _CONSTM_ Text showsPrec (((Int, Int), (Int, Int))), _CONSTM_ Text readList (((Int, Int), (Int, Int))), _CONSTM_ Text showList (((Int, Int), (Int, Int)))] _N_
+ readsPrec = { _A_ 1 _U_ 02 _N_ _S_ "A" {_A_ 0 _U_ 2 _N_ _N_ _N_ _N_} _N_ _N_ },
+ showsPrec = { _A_ 3 _U_ 012 _N_ _S_ "AU(LL)L" {_A_ 3 _U_ 112 _N_ _N_ _N_ _N_} _N_ _N_ },
+ readList = { _A_ 0 _U_ 2 _N_ _N_ _N_ _N_ },
+ showList = { _A_ 1 _U_ 12 _N_ _N_ _N_ _N_ } #-}
instance Text ()
{-# GHC_PRAGMA _M_ PreludeBuiltin {-dfun-} _A_ 0 _N_ _N_ _N_ _F_ _IF_ARGS_ 0 0 X 5 _!_ _TUP_4 [(Int -> [Char] -> [((), [Char])]), (Int -> () -> [Char] -> [Char]), ([Char] -> [([()], [Char])]), ([()] -> [Char] -> [Char])] [_CONSTM_ Text readsPrec (()), _CONSTM_ Text showsPrec (()), _CONSTM_ Text readList (()), _CONSTM_ Text showList (())] _N_
- readsPrec = _A_ 1 _U_ 02 _N_ _S_ "A" {_A_ 0 _U_ 2 _N_ _N_ _N_ _N_} _N_ _N_,
- showsPrec = _A_ 3 _U_ 012 _N_ _S_ "AEL" {_A_ 2 _U_ 12 _N_ _N_ _F_ _IF_ARGS_ 0 2 CX 4 \ (u0 :: ()) (u1 :: [Char]) -> case u0 of { _ALG_ _TUP_0 -> _APP_ _TYAPP_ _ORIG_ PreludeList (++) { Char } [ _NOREP_S_ "()", u1 ]; _NO_DEFLT_ } _N_} _F_ _IF_ARGS_ 0 3 XCX 4 \ (u0 :: Int) (u1 :: ()) (u2 :: [Char]) -> case u1 of { _ALG_ _TUP_0 -> _APP_ _TYAPP_ _ORIG_ PreludeList (++) { Char } [ _NOREP_S_ "()", u2 ]; _NO_DEFLT_ } _N_,
- readList = _A_ 0 _U_ 2 _N_ _N_ _N_ _N_,
- showList = _A_ 0 _U_ 12 _N_ _N_ _N_ _N_ #-}
+ readsPrec = { _A_ 1 _U_ 02 _N_ _S_ "A" {_A_ 0 _U_ 2 _N_ _N_ _N_ _N_} _N_ _N_ },
+ showsPrec = { _A_ 3 _U_ 012 _N_ _S_ "AEL" {_A_ 2 _U_ 12 _N_ _N_ _F_ _IF_ARGS_ 0 2 CX 4 \ (u0 :: ()) (u1 :: [Char]) -> case u0 of { _ALG_ _TUP_0 -> _APP_ _TYAPP_ _ORIG_ PreludeList (++) { Char } [ _NOREP_S_ "()", u1 ]; _NO_DEFLT_ } _N_} _F_ _IF_ARGS_ 0 3 XCX 4 \ (u0 :: Int) (u1 :: ()) (u2 :: [Char]) -> case u1 of { _ALG_ _TUP_0 -> _APP_ _TYAPP_ _ORIG_ PreludeList (++) { Char } [ _NOREP_S_ "()", u2 ]; _NO_DEFLT_ } _N_ },
+ readList = { _A_ 0 _U_ 2 _N_ _N_ _N_ _N_ },
+ showList = { _A_ 1 _U_ 12 _N_ _N_ _N_ _N_ } #-}
instance (Text a, Text b) => Text (a, b)
{-# GHC_PRAGMA _M_ PreludeBuiltin {-dfun-} _A_ 2 _U_ 22 _N_ _N_ _N_ _N_ #-}
instance (Text a, Text b, Text c) => Text (a, b, c)
{-# GHC_PRAGMA _M_ PreludeBuiltin {-dfun-} _A_ 5 _U_ 22222 _N_ _N_ _N_ _N_ #-}
instance Text (Int, Int)
{-# GHC_PRAGMA _M_ PreludeBuiltin {-dfun-} _A_ 0 _N_ _N_ _N_ _F_ _IF_ARGS_ 0 0 X 5 _!_ _TUP_4 [(Int -> [Char] -> [((Int, Int), [Char])]), (Int -> (Int, Int) -> [Char] -> [Char]), ([Char] -> [([(Int, Int)], [Char])]), ([(Int, Int)] -> [Char] -> [Char])] [_CONSTM_ Text readsPrec ((Int, Int)), _CONSTM_ Text showsPrec ((Int, Int)), _CONSTM_ Text readList ((Int, Int)), _CONSTM_ Text showList ((Int, Int))] _N_
- readsPrec = _A_ 1 _U_ 02 _N_ _S_ "A" {_A_ 0 _U_ 2 _N_ _N_ _N_ _N_} _N_ _N_,
- showsPrec = _A_ 3 _U_ 012 _N_ _S_ "AU(LL)L" {_A_ 3 _U_ 112 _N_ _N_ _N_ _N_} _N_ _N_,
- readList = _A_ 0 _U_ 2 _N_ _N_ _N_ _N_,
- showList = _A_ 0 _U_ 12 _N_ _N_ _N_ _N_ #-}
+ readsPrec = { _A_ 1 _U_ 02 _N_ _S_ "A" {_A_ 0 _U_ 2 _N_ _N_ _N_ _N_} _N_ _N_ },
+ showsPrec = { _A_ 3 _U_ 012 _N_ _S_ "AU(LL)L" {_A_ 3 _U_ 112 _N_ _N_ _N_ _N_} _N_ _N_ },
+ readList = { _A_ 0 _U_ 2 _N_ _N_ _N_ _N_ },
+ showList = { _A_ 1 _U_ 12 _N_ _N_ _N_ _N_ } #-}
+instance Text (Int, Int, Int)
+ {-# GHC_PRAGMA _M_ PreludeBuiltin {-dfun-} _A_ 0 _N_ _N_ _N_ _F_ _IF_ARGS_ 0 0 X 5 _!_ _TUP_4 [(Int -> [Char] -> [((Int, Int, Int), [Char])]), (Int -> (Int, Int, Int) -> [Char] -> [Char]), ([Char] -> [([(Int, Int, Int)], [Char])]), ([(Int, Int, Int)] -> [Char] -> [Char])] [_CONSTM_ Text readsPrec ((Int, Int, Int)), _CONSTM_ Text showsPrec ((Int, Int, Int)), _CONSTM_ Text readList ((Int, Int, Int)), _CONSTM_ Text showList ((Int, Int, Int))] _N_
+ readsPrec = { _A_ 1 _U_ 02 _N_ _S_ "A" {_A_ 0 _U_ 2 _N_ _N_ _N_ _N_} _N_ _N_ },
+ showsPrec = { _A_ 3 _U_ 012 _N_ _S_ "AU(LLL)L" {_A_ 4 _U_ 1112 _N_ _N_ _N_ _N_} _N_ _N_ },
+ readList = { _A_ 0 _U_ 2 _N_ _N_ _N_ _N_ },
+ showList = { _A_ 1 _U_ 12 _N_ _N_ _N_ _N_ } #-}
instance Text (Integer, Integer)
{-# GHC_PRAGMA _M_ PreludeBuiltin {-dfun-} _A_ 0 _N_ _N_ _N_ _F_ _IF_ARGS_ 0 0 X 5 _!_ _TUP_4 [(Int -> [Char] -> [((Integer, Integer), [Char])]), (Int -> (Integer, Integer) -> [Char] -> [Char]), ([Char] -> [([(Integer, Integer)], [Char])]), ([(Integer, Integer)] -> [Char] -> [Char])] [_CONSTM_ Text readsPrec ((Integer, Integer)), _CONSTM_ Text showsPrec ((Integer, Integer)), _CONSTM_ Text readList ((Integer, Integer)), _CONSTM_ Text showList ((Integer, Integer))] _N_
- readsPrec = _A_ 1 _U_ 02 _N_ _S_ "A" {_A_ 0 _U_ 2 _N_ _N_ _N_ _N_} _N_ _N_,
- showsPrec = _A_ 3 _U_ 012 _N_ _S_ "AU(LL)L" {_A_ 3 _U_ 112 _N_ _N_ _N_ _N_} _N_ _N_,
- readList = _A_ 0 _U_ 2 _N_ _N_ _N_ _N_,
- showList = _A_ 0 _U_ 12 _N_ _N_ _N_ _N_ #-}
+ readsPrec = { _A_ 1 _U_ 02 _N_ _S_ "A" {_A_ 0 _U_ 2 _N_ _N_ _N_ _N_} _N_ _N_ },
+ showsPrec = { _A_ 3 _U_ 012 _N_ _S_ "AU(LL)L" {_A_ 3 _U_ 112 _N_ _N_ _N_ _N_} _N_ _N_ },
+ readList = { _A_ 0 _U_ 2 _N_ _N_ _N_ _N_ },
+ showList = { _A_ 1 _U_ 12 _N_ _N_ _N_ _N_ } #-}
instance Text (a -> b)
{-# GHC_PRAGMA _M_ PreludeCore {-dfun-} _A_ 0 _N_ _N_ _N_ _N_ _N_ #-}
+instance Text (Array (Int, Int) Double)
+ {-# GHC_PRAGMA _M_ PreludeArray {-dfun-} _A_ 0 _N_ _N_ _N_ _F_ _IF_ARGS_ 0 0 X 5 _!_ _TUP_4 [(Int -> [Char] -> [(Array (Int, Int) Double, [Char])]), (Int -> Array (Int, Int) Double -> [Char] -> [Char]), ([Char] -> [([Array (Int, Int) Double], [Char])]), ([Array (Int, Int) Double] -> [Char] -> [Char])] [_CONSTM_ Text readsPrec (Array (Int, Int) Double), _CONSTM_ Text showsPrec (Array (Int, Int) Double), _CONSTM_ Text readList (Array (Int, Int) Double), _CONSTM_ Text showList (Array (Int, Int) Double)] _N_
+ readsPrec = { _A_ 1 _U_ 12 _N_ _S_ "U(P)" {_A_ 1 _U_ 22 _N_ _N_ _N_ _N_} _N_ _N_ },
+ showsPrec = { _A_ 2 _U_ 122 _N_ _N_ _N_ _N_ },
+ readList = { _A_ 0 _U_ 2 _N_ _N_ _N_ _N_ },
+ showList = { _A_ 0 _U_ 12 _N_ _N_ _N_ _N_ } #-}
instance (Ix a, Text a, Text b) => Text (Array a b)
{-# GHC_PRAGMA _M_ PreludeArray {-dfun-} _A_ 3 _U_ 222 _N_ _N_ _N_ _N_ #-}
+instance Text (Array Int Double)
+ {-# GHC_PRAGMA _M_ PreludeArray {-dfun-} _A_ 0 _N_ _N_ _N_ _F_ _IF_ARGS_ 0 0 X 5 _!_ _TUP_4 [(Int -> [Char] -> [(Array Int Double, [Char])]), (Int -> Array Int Double -> [Char] -> [Char]), ([Char] -> [([Array Int Double], [Char])]), ([Array Int Double] -> [Char] -> [Char])] [_CONSTM_ Text readsPrec (Array Int Double), _CONSTM_ Text showsPrec (Array Int Double), _CONSTM_ Text readList (Array Int Double), _CONSTM_ Text showList (Array Int Double)] _N_
+ readsPrec = { _A_ 1 _U_ 12 _N_ _S_ "U(P)" {_A_ 1 _U_ 22 _N_ _N_ _N_ _N_} _N_ _N_ },
+ showsPrec = { _A_ 2 _U_ 122 _N_ _N_ _N_ _N_ },
+ readList = { _A_ 0 _U_ 2 _N_ _N_ _N_ _N_ },
+ showList = { _A_ 0 _U_ 12 _N_ _N_ _N_ _N_ } #-}
instance (Text a, Text b) => Text (Assoc a b)
{-# GHC_PRAGMA _M_ PreludeArray {-dfun-} _A_ 2 _U_ 22 _N_ _N_ _N_ _N_ #-}
instance Text Bool
{-# GHC_PRAGMA _M_ PreludeCore {-dfun-} _A_ 0 _N_ _N_ _N_ _F_ _IF_ARGS_ 0 0 X 5 _!_ _TUP_4 [(Int -> [Char] -> [(Bool, [Char])]), (Int -> Bool -> [Char] -> [Char]), ([Char] -> [([Bool], [Char])]), ([Bool] -> [Char] -> [Char])] [_CONSTM_ Text readsPrec (Bool), _CONSTM_ Text showsPrec (Bool), _CONSTM_ Text readList (Bool), _CONSTM_ Text showList (Bool)] _N_
- readsPrec = _A_ 2 _U_ 02 _N_ _S_ "AL" {_A_ 1 _U_ 2 _N_ _N_ _N_ _N_} _N_ _N_,
- showsPrec = _A_ 3 _U_ 012 _N_ _S_ "AEL" {_A_ 2 _U_ 12 _N_ _N_ _N_ _N_} _N_ _N_,
- readList = _A_ 0 _U_ 2 _N_ _N_ _N_ _N_,
- showList = _A_ 0 _U_ 12 _N_ _N_ _N_ _N_ #-}
+ readsPrec = { _A_ 2 _U_ 02 _N_ _S_ "AL" {_A_ 1 _U_ 2 _N_ _N_ _N_ _N_} _N_ _N_ },
+ showsPrec = { _A_ 3 _U_ 012 _N_ _S_ "AEL" {_A_ 2 _U_ 12 _N_ _N_ _N_ _N_} _N_ _N_ },
+ readList = { _A_ 0 _U_ 2 _N_ _N_ _N_ _N_ },
+ showList = { _A_ 1 _U_ 12 _N_ _N_ _F_ _IF_ARGS_ 0 1 X 3 \ (u0 :: [Bool]) -> _APP_ _TYAPP_ _ORIG_ PreludeCore _showList { Bool } [ _WRKR_ _CONSTM_ Text showsPrec (Bool), u0 ] _N_ } #-}
instance Text Char
{-# GHC_PRAGMA _M_ PreludeCore {-dfun-} _A_ 0 _N_ _N_ _N_ _F_ _IF_ARGS_ 0 0 X 5 _!_ _TUP_4 [(Int -> [Char] -> [(Char, [Char])]), (Int -> Char -> [Char] -> [Char]), ([Char] -> [([Char], [Char])]), ([Char] -> [Char] -> [Char])] [_CONSTM_ Text readsPrec (Char), _CONSTM_ Text showsPrec (Char), _CONSTM_ Text readList (Char), _CONSTM_ Text showList (Char)] _N_
- readsPrec = _A_ 1 _U_ 02 _N_ _S_ "A" {_A_ 0 _U_ 2 _N_ _N_ _N_ _N_} _N_ _N_,
- showsPrec = _A_ 3 _U_ 012 _N_ _S_ "AU(P)L" {_A_ 2 _U_ 22 _N_ _N_ _N_ _N_} _N_ _N_,
- readList = _A_ 0 _U_ 2 _N_ _N_ _N_ _N_,
- showList = _A_ 1 _U_ 22 _N_ _N_ _N_ _N_ #-}
+ readsPrec = { _A_ 1 _U_ 02 _N_ _S_ "A" {_A_ 0 _U_ 2 _N_ _N_ _N_ _N_} _N_ _N_ },
+ showsPrec = { _A_ 3 _U_ 012 _N_ _S_ "AU(P)L" {_A_ 2 _U_ 22 _N_ _N_ _N_ _N_} _N_ _N_ },
+ readList = { _A_ 0 _U_ 2 _N_ _N_ _N_ _N_ },
+ showList = { _A_ 1 _U_ 22 _N_ _N_ _N_ _N_ } #-}
instance Text a => Text (Complex a)
{-# GHC_PRAGMA _M_ PreludeComplex {-dfun-} _A_ 1 _U_ 2 _N_ _N_ _N_ _N_ #-}
+instance Text (Complex Double)
+ {-# GHC_PRAGMA _M_ PreludeComplex {-dfun-} _A_ 0 _N_ _N_ _N_ _F_ _IF_ARGS_ 0 0 X 5 _!_ _TUP_4 [(Int -> [Char] -> [(Complex Double, [Char])]), (Int -> Complex Double -> [Char] -> [Char]), ([Char] -> [([Complex Double], [Char])]), ([Complex Double] -> [Char] -> [Char])] [_CONSTM_ Text readsPrec (Complex Double), _CONSTM_ Text showsPrec (Complex Double), _CONSTM_ Text readList (Complex Double), _CONSTM_ Text showList (Complex Double)] _N_
+ readsPrec = { _A_ 1 _U_ 12 _N_ _S_ "U(P)" {_A_ 1 _U_ 22 _N_ _N_ _N_ _N_} _N_ _N_ },
+ showsPrec = { _A_ 2 _U_ 112 _N_ _S_ "LU(LL)" {_A_ 3 _U_ 1222 _N_ _N_ _N_ _N_} _N_ _N_ },
+ readList = { _A_ 0 _U_ 2 _N_ _N_ _N_ _N_ },
+ showList = { _A_ 1 _U_ 12 _N_ _N_ _N_ _N_ } #-}
instance Text Double
{-# GHC_PRAGMA _M_ PreludeCore {-dfun-} _A_ 0 _N_ _N_ _N_ _F_ _IF_ARGS_ 0 0 X 5 _!_ _TUP_4 [(Int -> [Char] -> [(Double, [Char])]), (Int -> Double -> [Char] -> [Char]), ([Char] -> [([Double], [Char])]), ([Double] -> [Char] -> [Char])] [_CONSTM_ Text readsPrec (Double), _CONSTM_ Text showsPrec (Double), _CONSTM_ Text readList (Double), _CONSTM_ Text showList (Double)] _N_
- readsPrec = _A_ 2 _U_ 02 _N_ _S_ "AL" {_A_ 1 _U_ 2 _N_ _N_ _F_ _IF_ARGS_ 0 1 X 3 \ (u0 :: [Char]) -> _APP_ _SPEC_ _ORIG_ PreludeText readSigned [ (Double) ] [ _SPEC_ _ORIG_ PreludeText readFloat [ (Double) ], u0 ] _N_} _F_ _IF_ARGS_ 0 2 XX 3 \ (u0 :: Int) (u1 :: [Char]) -> _APP_ _SPEC_ _ORIG_ PreludeText readSigned [ (Double) ] [ _SPEC_ _ORIG_ PreludeText readFloat [ (Double) ], u1 ] _N_,
- showsPrec = _A_ 2 _U_ 212 _N_ _S_ "LU(P)" {_A_ 2 _U_ 222 _N_ _N_ _F_ _IF_ARGS_ 0 2 XX 4 \ (u0 :: Int) (u1 :: Double#) -> _APP_ _WRKR_ _SPEC_ _ORIG_ PreludeText showSigned [ (Double) ] [ _SPEC_ _ORIG_ PreludeText showFloat [ (Double) ], u0, u1 ] _N_} _F_ _IF_ARGS_ 0 2 XC 5 \ (u0 :: Int) (u1 :: Double) -> case u1 of { _ALG_ D# (u2 :: Double#) -> _APP_ _WRKR_ _SPEC_ _ORIG_ PreludeText showSigned [ (Double) ] [ _SPEC_ _ORIG_ PreludeText showFloat [ (Double) ], u0, u2 ]; _NO_DEFLT_ } _N_,
- readList = _A_ 0 _U_ 2 _N_ _N_ _N_ _N_,
- showList = _A_ 0 _U_ 12 _N_ _N_ _N_ _N_ #-}
+ readsPrec = { _A_ 2 _U_ 02 _N_ _S_ "AL" {_A_ 1 _U_ 2 _N_ _N_ _F_ _IF_ARGS_ 0 1 X 3 \ (u0 :: [Char]) -> _APP_ _SPEC_ _ORIG_ PreludeText readSigned [ (Double) ] [ _SPEC_ _ORIG_ PreludeText readFloat [ (Double) ], u0 ] _N_} _F_ _IF_ARGS_ 0 2 XX 3 \ (u0 :: Int) (u1 :: [Char]) -> _APP_ _SPEC_ _ORIG_ PreludeText readSigned [ (Double) ] [ _SPEC_ _ORIG_ PreludeText readFloat [ (Double) ], u1 ] _N_ },
+ showsPrec = { _A_ 2 _U_ 212 _N_ _S_ "LU(P)" {_A_ 2 _U_ 222 _N_ _N_ _F_ _IF_ARGS_ 0 2 XX 4 \ (u0 :: Int) (u1 :: Double#) -> _APP_ _WRKR_ _SPEC_ _ORIG_ PreludeText showSigned [ (Double) ] [ _SPEC_ _ORIG_ PreludeText showFloat [ (Double) ], u0, u1 ] _N_} _F_ _IF_ARGS_ 0 2 XC 5 \ (u0 :: Int) (u1 :: Double) -> case u1 of { _ALG_ D# (u2 :: Double#) -> _APP_ _WRKR_ _SPEC_ _ORIG_ PreludeText showSigned [ (Double) ] [ _SPEC_ _ORIG_ PreludeText showFloat [ (Double) ], u0, u2 ]; _NO_DEFLT_ } _N_ },
+ readList = { _A_ 0 _U_ 2 _N_ _N_ _N_ _N_ },
+ showList = { _A_ 1 _U_ 12 _N_ _N_ _N_ _N_ } #-}
instance (Text a, Text b) => Text (Either a b)
{-# GHC_PRAGMA _M_ PreludeMonadicIO {-dfun-} _A_ 2 _U_ 22 _N_ _N_ _N_ _N_ #-}
instance Text Float
{-# GHC_PRAGMA _M_ PreludeCore {-dfun-} _A_ 0 _N_ _N_ _N_ _F_ _IF_ARGS_ 0 0 X 5 _!_ _TUP_4 [(Int -> [Char] -> [(Float, [Char])]), (Int -> Float -> [Char] -> [Char]), ([Char] -> [([Float], [Char])]), ([Float] -> [Char] -> [Char])] [_CONSTM_ Text readsPrec (Float), _CONSTM_ Text showsPrec (Float), _CONSTM_ Text readList (Float), _CONSTM_ Text showList (Float)] _N_
- readsPrec = _A_ 2 _U_ 02 _N_ _S_ "AL" {_A_ 1 _U_ 2 _N_ _N_ _N_ _N_} _N_ _N_,
- showsPrec = _A_ 1 _U_ 222 _N_ _N_ _N_ _N_,
- readList = _A_ 0 _U_ 2 _N_ _N_ _N_ _N_,
- showList = _A_ 0 _U_ 12 _N_ _N_ _N_ _N_ #-}
+ readsPrec = { _A_ 2 _U_ 02 _N_ _S_ "AL" {_A_ 1 _U_ 2 _N_ _N_ _N_ _N_} _N_ _N_ },
+ showsPrec = { _A_ 1 _U_ 222 _N_ _N_ _N_ _N_ },
+ readList = { _A_ 0 _U_ 2 _N_ _N_ _N_ _N_ },
+ showList = { _A_ 0 _U_ 12 _N_ _N_ _N_ _N_ } #-}
instance Text IOError13
{-# GHC_PRAGMA _M_ PreludeIOError {-dfun-} _A_ 0 _N_ _N_ _N_ _F_ _IF_ARGS_ 0 0 X 5 _!_ _TUP_4 [(Int -> [Char] -> [(IOError13, [Char])]), (Int -> IOError13 -> [Char] -> [Char]), ([Char] -> [([IOError13], [Char])]), ([IOError13] -> [Char] -> [Char])] [_CONSTM_ Text readsPrec (IOError13), _CONSTM_ Text showsPrec (IOError13), _CONSTM_ Text readList (IOError13), _CONSTM_ Text showList (IOError13)] _N_
- readsPrec = _A_ 2 _U_ 22 _N_ _S_ _!_ _F_ _IF_ARGS_ 0 2 XX 4 \ (u0 :: Int) (u1 :: [Char]) -> _APP_ _TYAPP_ patError# { (Int -> [Char] -> [(IOError13, [Char])]) } [ _NOREP_S_ "%DPreludeCore.Text.readsPrec\"", u0, u1 ] _N_,
- showsPrec = _A_ 2 _U_ 012 _N_ _S_ "AS" {_A_ 1 _U_ 12 _N_ _N_ _N_ _N_} _N_ _N_,
- readList = _A_ 0 _U_ 2 _N_ _N_ _N_ _N_,
- showList = _A_ 0 _U_ 12 _N_ _N_ _N_ _N_ #-}
+ readsPrec = { _A_ 2 _U_ 02 _N_ _S_ _!_ _N_ _N_ },
+ showsPrec = { _A_ 2 _U_ 012 _N_ _S_ "AS" {_A_ 1 _U_ 12 _N_ _N_ _N_ _N_} _N_ _N_ },
+ readList = { _A_ 0 _U_ 2 _N_ _N_ _N_ _N_ },
+ showList = { _A_ 1 _U_ 12 _N_ _N_ _F_ _IF_ARGS_ 0 1 X 3 \ (u0 :: [IOError13]) -> _APP_ _TYAPP_ _ORIG_ PreludeCore _showList { IOError13 } [ _WRKR_ _CONSTM_ Text showsPrec (IOError13), u0 ] _N_ } #-}
instance Text Int
{-# GHC_PRAGMA _M_ PreludeCore {-dfun-} _A_ 0 _N_ _N_ _N_ _F_ _IF_ARGS_ 0 0 X 5 _!_ _TUP_4 [(Int -> [Char] -> [(Int, [Char])]), (Int -> Int -> [Char] -> [Char]), ([Char] -> [([Int], [Char])]), ([Int] -> [Char] -> [Char])] [_CONSTM_ Text readsPrec (Int), _CONSTM_ Text showsPrec (Int), _CONSTM_ Text readList (Int), _CONSTM_ Text showList (Int)] _N_
- readsPrec = _A_ 2 _U_ 02 _N_ _S_ "AL" {_A_ 1 _U_ 2 _N_ _N_ _F_ _IF_ARGS_ 0 1 X 3 \ (u0 :: [Char]) -> _APP_ _SPEC_ _ORIG_ PreludeText readSigned [ (Int) ] [ _SPEC_ _ORIG_ PreludeText readDec [ (Int) ], u0 ] _N_} _F_ _IF_ARGS_ 0 2 XX 3 \ (u0 :: Int) (u1 :: [Char]) -> _APP_ _SPEC_ _ORIG_ PreludeText readSigned [ (Int) ] [ _SPEC_ _ORIG_ PreludeText readDec [ (Int) ], u1 ] _N_,
- showsPrec = _A_ 3 _U_ 212 _N_ _S_ "LU(P)L" {_A_ 3 _U_ 222 _N_ _N_ _N_ _N_} _N_ _N_,
- readList = _A_ 0 _U_ 2 _N_ _N_ _N_ _N_,
- showList = _A_ 0 _U_ 12 _N_ _N_ _N_ _N_ #-}
+ readsPrec = { _A_ 2 _U_ 02 _N_ _S_ "AL" {_A_ 1 _U_ 2 _N_ _N_ _F_ _IF_ARGS_ 0 1 X 3 \ (u0 :: [Char]) -> _APP_ _SPEC_ _ORIG_ PreludeText readSigned [ (Int) ] [ _SPEC_ _ORIG_ PreludeText readDec [ (Int) ], u0 ] _N_} _F_ _IF_ARGS_ 0 2 XX 3 \ (u0 :: Int) (u1 :: [Char]) -> _APP_ _SPEC_ _ORIG_ PreludeText readSigned [ (Int) ] [ _SPEC_ _ORIG_ PreludeText readDec [ (Int) ], u1 ] _N_ },
+ showsPrec = { _A_ 3 _U_ 212 _N_ _S_ "LU(P)L" {_A_ 3 _U_ 222 _N_ _N_ _N_ _N_} _N_ _N_ },
+ readList = { _A_ 0 _U_ 2 _N_ _N_ _N_ _N_ },
+ showList = { _A_ 1 _U_ 12 _N_ _N_ _N_ _N_ } #-}
instance Text Integer
{-# GHC_PRAGMA _M_ PreludeCore {-dfun-} _A_ 0 _N_ _N_ _N_ _F_ _IF_ARGS_ 0 0 X 5 _!_ _TUP_4 [(Int -> [Char] -> [(Integer, [Char])]), (Int -> Integer -> [Char] -> [Char]), ([Char] -> [([Integer], [Char])]), ([Integer] -> [Char] -> [Char])] [_CONSTM_ Text readsPrec (Integer), _CONSTM_ Text showsPrec (Integer), _CONSTM_ Text readList (Integer), _CONSTM_ Text showList (Integer)] _N_
- readsPrec = _A_ 2 _U_ 02 _N_ _S_ "AL" {_A_ 1 _U_ 2 _N_ _N_ _F_ _IF_ARGS_ 0 1 X 3 \ (u0 :: [Char]) -> _APP_ _SPEC_ _ORIG_ PreludeText readSigned [ (Integer) ] [ _SPEC_ _ORIG_ PreludeText readDec [ (Integer) ], u0 ] _N_} _F_ _IF_ARGS_ 0 2 XX 3 \ (u0 :: Int) (u1 :: [Char]) -> _APP_ _SPEC_ _ORIG_ PreludeText readSigned [ (Integer) ] [ _SPEC_ _ORIG_ PreludeText readDec [ (Integer) ], u1 ] _N_,
- showsPrec = _A_ 3 _U_ 212 _N_ _S_ "LU(PPP)L" {_A_ 5 _U_ 22222 _N_ _N_ _N_ _N_} _N_ _N_,
- readList = _A_ 0 _U_ 2 _N_ _N_ _N_ _N_,
- showList = _A_ 0 _U_ 12 _N_ _N_ _N_ _N_ #-}
+ readsPrec = { _A_ 2 _U_ 02 _N_ _S_ "AL" {_A_ 1 _U_ 2 _N_ _N_ _F_ _IF_ARGS_ 0 1 X 3 \ (u0 :: [Char]) -> _APP_ _SPEC_ _ORIG_ PreludeText readSigned [ (Integer) ] [ _SPEC_ _ORIG_ PreludeText readDec [ (Integer) ], u0 ] _N_} _F_ _IF_ARGS_ 0 2 XX 3 \ (u0 :: Int) (u1 :: [Char]) -> _APP_ _SPEC_ _ORIG_ PreludeText readSigned [ (Integer) ] [ _SPEC_ _ORIG_ PreludeText readDec [ (Integer) ], u1 ] _N_ },
+ showsPrec = { _A_ 3 _U_ 212 _N_ _S_ "LU(PPP)L" {_A_ 5 _U_ 22222 _N_ _N_ _N_ _N_} _N_ _N_ },
+ readList = { _A_ 0 _U_ 2 _N_ _N_ _N_ _N_ },
+ showList = { _A_ 1 _U_ 12 _N_ _N_ _N_ _N_ } #-}
instance Text a => Text (Maybe a)
{-# GHC_PRAGMA _M_ PreludeStdIO {-dfun-} _A_ 1 _U_ 2 _N_ _N_ _N_ _N_ #-}
instance Integral a => Text (Ratio a)
{-# GHC_PRAGMA _M_ PreludeRatio {-dfun-} _A_ 1 _U_ 2 _N_ _N_ _N_ _N_ #-}
instance Text (Ratio Integer)
{-# GHC_PRAGMA _M_ PreludeRatio {-dfun-} _A_ 0 _N_ _N_ _N_ _F_ _IF_ARGS_ 0 0 X 5 _!_ _TUP_4 [(Int -> [Char] -> [(Ratio Integer, [Char])]), (Int -> Ratio Integer -> [Char] -> [Char]), ([Char] -> [([Ratio Integer], [Char])]), ([Ratio Integer] -> [Char] -> [Char])] [_CONSTM_ Text readsPrec (Ratio Integer), _CONSTM_ Text showsPrec (Ratio Integer), _CONSTM_ Text readList (Ratio Integer), _CONSTM_ Text showList (Ratio Integer)] _N_
- readsPrec = _A_ 1 _U_ 12 _N_ _S_ "U(P)" {_A_ 1 _U_ 22 _N_ _N_ _N_ _N_} _N_ _N_,
- showsPrec = _A_ 2 _U_ 112 _N_ _S_ "LU(LL)" {_A_ 3 _U_ 1222 _N_ _N_ _N_ _N_} _N_ _N_,
- readList = _A_ 0 _U_ 2 _N_ _N_ _N_ _N_,
- showList = _A_ 0 _U_ 12 _N_ _N_ _N_ _N_ #-}
+ readsPrec = { _A_ 1 _U_ 12 _N_ _S_ "U(P)" {_A_ 1 _U_ 22 _N_ _N_ _N_ _N_} _N_ _N_ },
+ showsPrec = { _A_ 2 _U_ 112 _N_ _S_ "LU(LL)" {_A_ 3 _U_ 1222 _N_ _N_ _N_ _N_} _N_ _N_ },
+ readList = { _A_ 0 _U_ 2 _N_ _N_ _N_ _N_ },
+ showList = { _A_ 1 _U_ 12 _N_ _N_ _N_ _N_ } #-}
instance Text a => Text [a]
{-# GHC_PRAGMA _M_ PreludeBuiltin {-dfun-} _A_ 1 _U_ 2 _N_ _N_ _N_ _N_ #-}
+instance Text [Bool]
+ {-# GHC_PRAGMA _M_ PreludeBuiltin {-dfun-} _A_ 0 _N_ _N_ _N_ _F_ _IF_ARGS_ 0 0 X 5 _!_ _TUP_4 [(Int -> [Char] -> [([Bool], [Char])]), (Int -> [Bool] -> [Char] -> [Char]), ([Char] -> [([[Bool]], [Char])]), ([[Bool]] -> [Char] -> [Char])] [_CONSTM_ Text readsPrec ([Bool]), _CONSTM_ Text showsPrec ([Bool]), _CONSTM_ Text readList ([Bool]), _CONSTM_ Text showList ([Bool])] _N_
+ readsPrec = { _A_ 1 _U_ 02 _N_ _S_ "A" {_A_ 0 _U_ 2 _N_ _N_ _F_ _IF_ARGS_ 0 0 X 1 _CONSTM_ Text readList (Bool) _N_} _F_ _IF_ARGS_ 0 1 X 1 \ (u0 :: Int) -> _CONSTM_ Text readList (Bool) _N_ },
+ showsPrec = { _A_ 2 _U_ 012 _N_ _S_ "AS" {_A_ 1 _U_ 12 _N_ _N_ _F_ _IF_ARGS_ 0 1 X 3 \ (u0 :: [Bool]) -> _APP_ _TYAPP_ _ORIG_ PreludeCore _showList { Bool } [ _WRKR_ _CONSTM_ Text showsPrec (Bool), u0 ] _N_} _F_ _IF_ARGS_ 0 2 XX 3 \ (u0 :: Int) (u1 :: [Bool]) -> _APP_ _TYAPP_ _ORIG_ PreludeCore _showList { Bool } [ _WRKR_ _CONSTM_ Text showsPrec (Bool), u1 ] _N_ },
+ readList = { _A_ 0 _U_ 2 _N_ _N_ _N_ _N_ },
+ showList = { _A_ 1 _U_ 12 _N_ _N_ _N_ _N_ } #-}
instance Text [Char]
{-# GHC_PRAGMA _M_ PreludeBuiltin {-dfun-} _A_ 0 _N_ _N_ _N_ _F_ _IF_ARGS_ 0 0 X 5 _!_ _TUP_4 [(Int -> [Char] -> [([Char], [Char])]), (Int -> [Char] -> [Char] -> [Char]), ([Char] -> [([[Char]], [Char])]), ([[Char]] -> [Char] -> [Char])] [_CONSTM_ Text readsPrec ([Char]), _CONSTM_ Text showsPrec ([Char]), _CONSTM_ Text readList ([Char]), _CONSTM_ Text showList ([Char])] _N_
- readsPrec = _A_ 1 _U_ 02 _N_ _S_ "A" {_A_ 0 _U_ 2 _N_ _N_ _F_ _IF_ARGS_ 0 0 X 1 _CONSTM_ Text readList (Char) _N_} _F_ _IF_ARGS_ 0 1 X 1 \ (u0 :: Int) -> _CONSTM_ Text readList (Char) _N_,
- showsPrec = _A_ 2 _U_ 022 _N_ _S_ "AL" {_A_ 1 _U_ 22 _N_ _N_ _F_ _IF_ARGS_ 0 0 X 1 _CONSTM_ Text showList (Char) _N_} _F_ _IF_ARGS_ 0 2 XX 2 \ (u0 :: Int) (u1 :: [Char]) -> _APP_ _CONSTM_ Text showList (Char) [ u1 ] _N_,
- readList = _A_ 0 _U_ 2 _N_ _N_ _N_ _N_,
- showList = _A_ 0 _U_ 12 _N_ _N_ _N_ _N_ #-}
+ readsPrec = { _A_ 1 _U_ 02 _N_ _S_ "A" {_A_ 0 _U_ 2 _N_ _N_ _F_ _IF_ARGS_ 0 0 X 1 _CONSTM_ Text readList (Char) _N_} _F_ _IF_ARGS_ 0 1 X 1 \ (u0 :: Int) -> _CONSTM_ Text readList (Char) _N_ },
+ showsPrec = { _A_ 2 _U_ 022 _N_ _S_ "AL" {_A_ 1 _U_ 22 _N_ _N_ _F_ _IF_ARGS_ 0 0 X 1 _CONSTM_ Text showList (Char) _N_} _F_ _IF_ARGS_ 0 2 XX 2 \ (u0 :: Int) (u1 :: [Char]) -> _APP_ _CONSTM_ Text showList (Char) [ u1 ] _N_ },
+ readList = { _A_ 0 _U_ 2 _N_ _N_ _N_ _N_ },
+ showList = { _A_ 1 _U_ 12 _N_ _N_ _F_ _IF_ARGS_ 0 1 X 3 \ (u0 :: [[Char]]) -> _APP_ _TYAPP_ _ORIG_ PreludeCore _showList { [Char] } [ _CONSTM_ Text showList (Char), u0 ] _N_ } #-}
+instance Text [Complex Double]
+ {-# GHC_PRAGMA _M_ PreludeBuiltin {-dfun-} _A_ 0 _N_ _N_ _N_ _F_ _IF_ARGS_ 0 0 X 5 _!_ _TUP_4 [(Int -> [Char] -> [([Complex Double], [Char])]), (Int -> [Complex Double] -> [Char] -> [Char]), ([Char] -> [([[Complex Double]], [Char])]), ([[Complex Double]] -> [Char] -> [Char])] [_CONSTM_ Text readsPrec ([Complex Double]), _CONSTM_ Text showsPrec ([Complex Double]), _CONSTM_ Text readList ([Complex Double]), _CONSTM_ Text showList ([Complex Double])] _N_
+ readsPrec = { _A_ 1 _U_ 02 _N_ _S_ "A" {_A_ 0 _U_ 2 _N_ _N_ _F_ _IF_ARGS_ 0 0 X 1 _CONSTM_ Text readList (Complex Double) _N_} _F_ _IF_ARGS_ 0 1 X 1 \ (u0 :: Int) -> _CONSTM_ Text readList (Complex Double) _N_ },
+ showsPrec = { _A_ 2 _U_ 022 _N_ _S_ "AL" {_A_ 1 _U_ 22 _N_ _N_ _F_ _IF_ARGS_ 0 0 X 1 _CONSTM_ Text showList (Complex Double) _N_} _F_ _IF_ARGS_ 0 2 XX 2 \ (u0 :: Int) (u1 :: [Complex Double]) -> _APP_ _CONSTM_ Text showList (Complex Double) [ u1 ] _N_ },
+ readList = { _A_ 0 _U_ 2 _N_ _N_ _N_ _N_ },
+ showList = { _A_ 1 _U_ 12 _N_ _N_ _F_ _IF_ARGS_ 0 1 X 3 \ (u0 :: [[Complex Double]]) -> _APP_ _TYAPP_ _ORIG_ PreludeCore _showList { [Complex Double] } [ _CONSTM_ Text showList (Complex Double), u0 ] _N_ } #-}
+instance Text [Double]
+ {-# GHC_PRAGMA _M_ PreludeBuiltin {-dfun-} _A_ 0 _N_ _N_ _N_ _F_ _IF_ARGS_ 0 0 X 5 _!_ _TUP_4 [(Int -> [Char] -> [([Double], [Char])]), (Int -> [Double] -> [Char] -> [Char]), ([Char] -> [([[Double]], [Char])]), ([[Double]] -> [Char] -> [Char])] [_CONSTM_ Text readsPrec ([Double]), _CONSTM_ Text showsPrec ([Double]), _CONSTM_ Text readList ([Double]), _CONSTM_ Text showList ([Double])] _N_
+ readsPrec = { _A_ 1 _U_ 02 _N_ _S_ "A" {_A_ 0 _U_ 2 _N_ _N_ _F_ _IF_ARGS_ 0 0 X 1 _CONSTM_ Text readList (Double) _N_} _F_ _IF_ARGS_ 0 1 X 1 \ (u0 :: Int) -> _CONSTM_ Text readList (Double) _N_ },
+ showsPrec = { _A_ 2 _U_ 022 _N_ _S_ "AL" {_A_ 1 _U_ 22 _N_ _N_ _F_ _IF_ARGS_ 0 0 X 1 _CONSTM_ Text showList (Double) _N_} _F_ _IF_ARGS_ 0 2 XX 2 \ (u0 :: Int) (u1 :: [Double]) -> _APP_ _CONSTM_ Text showList (Double) [ u1 ] _N_ },
+ readList = { _A_ 0 _U_ 2 _N_ _N_ _N_ _N_ },
+ showList = { _A_ 1 _U_ 12 _N_ _N_ _F_ _IF_ARGS_ 0 1 X 3 \ (u0 :: [[Double]]) -> _APP_ _TYAPP_ _ORIG_ PreludeCore _showList { [Double] } [ _CONSTM_ Text showList (Double), u0 ] _N_ } #-}
instance Text [Int]
{-# GHC_PRAGMA _M_ PreludeBuiltin {-dfun-} _A_ 0 _N_ _N_ _N_ _F_ _IF_ARGS_ 0 0 X 5 _!_ _TUP_4 [(Int -> [Char] -> [([Int], [Char])]), (Int -> [Int] -> [Char] -> [Char]), ([Char] -> [([[Int]], [Char])]), ([[Int]] -> [Char] -> [Char])] [_CONSTM_ Text readsPrec ([Int]), _CONSTM_ Text showsPrec ([Int]), _CONSTM_ Text readList ([Int]), _CONSTM_ Text showList ([Int])] _N_
- readsPrec = _A_ 1 _U_ 02 _N_ _S_ "A" {_A_ 0 _U_ 2 _N_ _N_ _F_ _IF_ARGS_ 0 0 X 1 _CONSTM_ Text readList (Int) _N_} _F_ _IF_ARGS_ 0 1 X 1 \ (u0 :: Int) -> _CONSTM_ Text readList (Int) _N_,
- showsPrec = _A_ 1 _U_ 022 _N_ _S_ "A" {_A_ 0 _U_ 22 _N_ _N_ _F_ _IF_ARGS_ 0 0 X 1 _CONSTM_ Text showList (Int) _N_} _F_ _IF_ARGS_ 0 1 X 1 \ (u0 :: Int) -> _CONSTM_ Text showList (Int) _N_,
- readList = _A_ 0 _U_ 2 _N_ _N_ _N_ _N_,
- showList = _A_ 0 _U_ 12 _N_ _N_ _N_ _N_ #-}
+ readsPrec = { _A_ 1 _U_ 02 _N_ _S_ "A" {_A_ 0 _U_ 2 _N_ _N_ _F_ _IF_ARGS_ 0 0 X 1 _CONSTM_ Text readList (Int) _N_} _F_ _IF_ARGS_ 0 1 X 1 \ (u0 :: Int) -> _CONSTM_ Text readList (Int) _N_ },
+ showsPrec = { _A_ 2 _U_ 022 _N_ _S_ "AL" {_A_ 1 _U_ 22 _N_ _N_ _F_ _IF_ARGS_ 0 0 X 1 _CONSTM_ Text showList (Int) _N_} _F_ _IF_ARGS_ 0 2 XX 2 \ (u0 :: Int) (u1 :: [Int]) -> _APP_ _CONSTM_ Text showList (Int) [ u1 ] _N_ },
+ readList = { _A_ 0 _U_ 2 _N_ _N_ _N_ _N_ },
+ showList = { _A_ 1 _U_ 12 _N_ _N_ _F_ _IF_ARGS_ 0 1 X 3 \ (u0 :: [[Int]]) -> _APP_ _TYAPP_ _ORIG_ PreludeCore _showList { [Int] } [ _CONSTM_ Text showList (Int), u0 ] _N_ } #-}
+instance Text [Integer]
+ {-# GHC_PRAGMA _M_ PreludeBuiltin {-dfun-} _A_ 0 _N_ _N_ _N_ _F_ _IF_ARGS_ 0 0 X 5 _!_ _TUP_4 [(Int -> [Char] -> [([Integer], [Char])]), (Int -> [Integer] -> [Char] -> [Char]), ([Char] -> [([[Integer]], [Char])]), ([[Integer]] -> [Char] -> [Char])] [_CONSTM_ Text readsPrec ([Integer]), _CONSTM_ Text showsPrec ([Integer]), _CONSTM_ Text readList ([Integer]), _CONSTM_ Text showList ([Integer])] _N_
+ readsPrec = { _A_ 1 _U_ 02 _N_ _S_ "A" {_A_ 0 _U_ 2 _N_ _N_ _F_ _IF_ARGS_ 0 0 X 1 _CONSTM_ Text readList (Integer) _N_} _F_ _IF_ARGS_ 0 1 X 1 \ (u0 :: Int) -> _CONSTM_ Text readList (Integer) _N_ },
+ showsPrec = { _A_ 2 _U_ 022 _N_ _S_ "AL" {_A_ 1 _U_ 22 _N_ _N_ _F_ _IF_ARGS_ 0 0 X 1 _CONSTM_ Text showList (Integer) _N_} _F_ _IF_ARGS_ 0 2 XX 2 \ (u0 :: Int) (u1 :: [Integer]) -> _APP_ _CONSTM_ Text showList (Integer) [ u1 ] _N_ },
+ readList = { _A_ 0 _U_ 2 _N_ _N_ _N_ _N_ },
+ showList = { _A_ 1 _U_ 12 _N_ _N_ _F_ _IF_ARGS_ 0 1 X 3 \ (u0 :: [[Integer]]) -> _APP_ _TYAPP_ _ORIG_ PreludeCore _showList { [Integer] } [ _CONSTM_ Text showList (Integer), u0 ] _N_ } #-}
+instance Text [[Char]]
+ {-# GHC_PRAGMA _M_ PreludeBuiltin {-dfun-} _A_ 0 _N_ _N_ _N_ _F_ _IF_ARGS_ 0 0 X 5 _!_ _TUP_4 [(Int -> [Char] -> [([[Char]], [Char])]), (Int -> [[Char]] -> [Char] -> [Char]), ([Char] -> [([[[Char]]], [Char])]), ([[[Char]]] -> [Char] -> [Char])] [_CONSTM_ Text readsPrec ([[Char]]), _CONSTM_ Text showsPrec ([[Char]]), _CONSTM_ Text readList ([[Char]]), _CONSTM_ Text showList ([[Char]])] _N_
+ readsPrec = { _A_ 1 _U_ 02 _N_ _S_ "A" {_A_ 0 _U_ 2 _N_ _N_ _F_ _IF_ARGS_ 0 0 X 1 _CONSTM_ Text readList ([Char]) _N_} _F_ _IF_ARGS_ 0 1 X 1 \ (u0 :: Int) -> _CONSTM_ Text readList ([Char]) _N_ },
+ showsPrec = { _A_ 2 _U_ 012 _N_ _S_ "AS" {_A_ 1 _U_ 12 _N_ _N_ _F_ _IF_ARGS_ 0 1 X 3 \ (u0 :: [[Char]]) -> _APP_ _TYAPP_ _ORIG_ PreludeCore _showList { [Char] } [ _CONSTM_ Text showList (Char), u0 ] _N_} _F_ _IF_ARGS_ 0 2 XX 2 \ (u0 :: Int) (u1 :: [[Char]]) -> _APP_ _CONSTM_ Text showList ([Char]) [ u1 ] _N_ },
+ readList = { _A_ 0 _U_ 2 _N_ _N_ _N_ _N_ },
+ showList = { _A_ 1 _U_ 12 _N_ _N_ _N_ _N_ } #-}
+instance Text [[Int]]
+ {-# GHC_PRAGMA _M_ PreludeBuiltin {-dfun-} _A_ 0 _N_ _N_ _N_ _F_ _IF_ARGS_ 0 0 X 5 _!_ _TUP_4 [(Int -> [Char] -> [([[Int]], [Char])]), (Int -> [[Int]] -> [Char] -> [Char]), ([Char] -> [([[[Int]]], [Char])]), ([[[Int]]] -> [Char] -> [Char])] [_CONSTM_ Text readsPrec ([[Int]]), _CONSTM_ Text showsPrec ([[Int]]), _CONSTM_ Text readList ([[Int]]), _CONSTM_ Text showList ([[Int]])] _N_
+ readsPrec = { _A_ 1 _U_ 02 _N_ _S_ "A" {_A_ 0 _U_ 2 _N_ _N_ _F_ _IF_ARGS_ 0 0 X 1 _CONSTM_ Text readList ([Int]) _N_} _F_ _IF_ARGS_ 0 1 X 1 \ (u0 :: Int) -> _CONSTM_ Text readList ([Int]) _N_ },
+ showsPrec = { _A_ 2 _U_ 012 _N_ _S_ "AS" {_A_ 1 _U_ 12 _N_ _N_ _F_ _IF_ARGS_ 0 1 X 3 \ (u0 :: [[Int]]) -> _APP_ _TYAPP_ _ORIG_ PreludeCore _showList { [Int] } [ _CONSTM_ Text showList (Int), u0 ] _N_} _F_ _IF_ARGS_ 0 2 XX 2 \ (u0 :: Int) (u1 :: [[Int]]) -> _APP_ _CONSTM_ Text showList ([Int]) [ u1 ] _N_ },
+ readList = { _A_ 0 _U_ 2 _N_ _N_ _N_ _N_ },
+ showList = { _A_ 1 _U_ 12 _N_ _N_ _N_ _N_ } #-}
instance Text _PackedString
{-# GHC_PRAGMA _M_ PreludePS {-dfun-} _A_ 0 _N_ _N_ _N_ _F_ _IF_ARGS_ 0 0 X 5 _!_ _TUP_4 [(Int -> [Char] -> [(_PackedString, [Char])]), (Int -> _PackedString -> [Char] -> [Char]), ([Char] -> [([_PackedString], [Char])]), ([_PackedString] -> [Char] -> [Char])] [_CONSTM_ Text readsPrec (_PackedString), _CONSTM_ Text showsPrec (_PackedString), _CONSTM_ Text readList (_PackedString), _CONSTM_ Text showList (_PackedString)] _N_
- readsPrec = _A_ 2 _U_ 02 _N_ _S_ _!_ _F_ _IF_ARGS_ 0 2 XX 3 \ (u0 :: Int) (u1 :: [Char]) -> _APP_ _TYAPP_ error { ([Char] -> [(_PackedString, [Char])]) } [ _NOREP_S_ "readsPrec: _PackedString: ToDo", u1 ] _N_,
- showsPrec = _A_ 3 _U_ 012 _N_ _S_ "ALL" {_A_ 2 _U_ 12 _N_ _N_ _N_ _N_} _F_ _IF_ARGS_ 0 3 XXX 6 \ (u0 :: Int) (u1 :: _PackedString) (u2 :: [Char]) -> let {(u3 :: [Char]) = _APP_ _ORIG_ PreludePS _unpackPS [ u1 ]} in _APP_ _CONSTM_ Text showList (Char) [ u3, u2 ] _N_,
- readList = _A_ 0 _U_ 2 _N_ _N_ _N_ _N_,
- showList = _A_ 0 _U_ 12 _N_ _N_ _N_ _N_ #-}
+ readsPrec = { _A_ 2 _U_ 02 _N_ _S_ _!_ _N_ _N_ },
+ showsPrec = { _A_ 3 _U_ 012 _N_ _S_ "ALL" {_A_ 2 _U_ 12 _N_ _N_ _N_ _N_} _F_ _IF_ARGS_ 0 3 XXX 6 \ (u0 :: Int) (u1 :: _PackedString) (u2 :: [Char]) -> let {(u3 :: [Char]) = _APP_ _ORIG_ PreludePS _unpackPS [ u1 ]} in _APP_ _CONSTM_ Text showList (Char) [ u3, u2 ] _N_ },
+ readList = { _A_ 0 _U_ 2 _N_ _N_ _N_ _N_ },
+ showList = { _A_ 1 _U_ 12 _N_ _N_ _F_ _IF_ARGS_ 0 1 X 3 \ (u0 :: [_PackedString]) -> _APP_ _TYAPP_ _ORIG_ PreludeCore _showList { _PackedString } [ _WRKR_ _CONSTM_ Text showsPrec (_PackedString), u0 ] _N_ } #-}
instance _CCallable Char
{-# GHC_PRAGMA _M_ PreludeCore {-dfun-} _A_ 0 _N_ _N_ _N_ _F_ _IF_ARGS_ 0 0 X 1 _!_ _TUP_0 [] [] _N_ #-}
instance _CCallable Double
ReadS(..), ShowS(..),
--- IOResult, -- has to be here because wired into compiler
+ -- IOResult has to be here because wired into compiler
Dialogue(..), Request(..), Response(..), SigAct(..), IOError(..),
- SuccCont(..), StrCont(..), StrListCont(..), BinCont(..), FailCont(..)
+ SuccCont(..), StrCont(..), StrListCont(..), BinCont(..), FailCont(..),
+
+ -- for unfoldings ...
+ _fromRational, __i0, __i1, __i2, __im1, __i8, __i10, __i16, __rhalf,
+ __integer0, __integer1, __integer2, __integerm1
) where
-- few *Ty(s) imports
-{-# GHC_PRAGMA INTERFACE VERSION 5 #-}
+{-# GHC_PRAGMA INTERFACE VERSION 6 #-}
interface Prelude where
import PreludeBuiltin(Bin, Char(..), Int(..), Tuple2)
import PreludeCore(Bool(..), Fractional(..), Integral(..), Num(..), RealFloat(..), RealFrac(..))
(.) :: (a -> c) -> (b -> a) -> b -> c
{-# GHC_PRAGMA _A_ 3 _U_ 112 _N_ _S_ "SLL" _F_ _ALWAYS_ _/\_ u0 u1 u2 -> \ (u3 :: u0 -> u2) (u4 :: u1 -> u0) (u5 :: u1) -> let {(u6 :: u0) = _APP_ u4 [ u5 ]} in _APP_ u3 [ u6 ] _N_ #-}
(^) :: (Num b, Integral a) => b -> a -> b
- {-# GHC_PRAGMA _A_ 2 _U_ 2122 _N_ _S_ "LU(U(LU(U(U(SA)AALAAAA)AAAA)A)AAALAAAALAA)" {_A_ 5 _U_ 2212222 _N_ _N_ _N_ _N_} _N_ _SPECIALISE_ [ Int, Double ] 2 { _A_ 2 _U_ 21 _N_ _S_ "LU(P)" {_A_ 2 _U_ 22 _N_ _N_ _N_ _N_} _N_ _N_ }, [ Int, Int ] 2 { _A_ 2 _U_ 21 _N_ _S_ "LU(P)" {_A_ 2 _U_ 22 _N_ _N_ _N_ _N_} _N_ _N_ }, [ Int, Integer ] 2 { _A_ 2 _U_ 21 _N_ _S_ "LU(P)" {_A_ 2 _U_ 22 _N_ _N_ _N_ _N_} _N_ _N_ }, [ Int, (Ratio Integer) ] 2 { _A_ 2 _U_ 21 _N_ _S_ "LU(P)" {_A_ 2 _U_ 22 _N_ _N_ _N_ _N_} _N_ _N_ }, [ Int, (Complex Double) ] 2 { _A_ 2 _U_ 21 _N_ _S_ "LU(P)" {_A_ 2 _U_ 22 _N_ _N_ _N_ _N_} _N_ _N_ } #-}
+ {-# GHC_PRAGMA _A_ 2 _U_ 2122 _N_ _S_ "LU(U(LU(U(U(SL)LLLLLLL)LLLL)L)LLLLLLLLLLL)" _N_ _SPECIALISE_ [ Int, Double ] 2 { _A_ 2 _U_ 21 _N_ _S_ "LU(P)" {_A_ 2 _U_ 22 _N_ _N_ _N_ _N_} _N_ _N_ }, [ Int, Int ] 2 { _A_ 2 _U_ 21 _N_ _S_ "LU(P)" {_A_ 2 _U_ 22 _N_ _N_ _N_ _N_} _N_ _N_ }, [ Int, Integer ] 2 { _A_ 2 _U_ 21 _N_ _S_ "LU(P)" {_A_ 2 _U_ 22 _N_ _N_ _N_ _N_} _N_ _N_ }, [ Int, (Ratio Integer) ] 2 { _A_ 2 _U_ 21 _N_ _S_ "LU(P)" {_A_ 2 _U_ 22 _N_ _N_ _N_ _N_} _N_ _N_ }, [ Int, (Complex Double) ] 2 { _A_ 2 _U_ 21 _N_ _S_ "LU(P)" {_A_ 2 _U_ 22 _N_ _N_ _N_ _N_} _N_ _N_ }, [ Integer, Integer ] 2 { _A_ 2 _U_ 21 _N_ _S_ "LU(PPP)" {_A_ 4 _U_ 2222 _N_ _N_ _N_ _N_} _N_ _N_ } #-}
(^^) :: (Fractional b, Integral a) => b -> a -> b
- {-# GHC_PRAGMA _A_ 2 _U_ 2122 _N_ _S_ "LU(LU(U(AAASAAAA)AAA)AALAAAALAA)" {_A_ 5 _U_ 2212222 _N_ _N_ _N_ _N_} _N_ _SPECIALISE_ [ Int, Double ] 2 { _A_ 2 _U_ 21 _N_ _S_ "LU(P)" {_A_ 2 _U_ 22 _N_ _N_ _N_ _N_} _N_ _N_ }, [ Int, (Ratio Integer) ] 2 { _A_ 2 _U_ 21 _N_ _S_ "LU(P)" {_A_ 2 _U_ 22 _N_ _N_ _N_ _N_} _N_ _N_ } #-}
+ {-# GHC_PRAGMA _A_ 2 _U_ 2222 _N_ _S_ "LU(LU(U(LLLSLLLL)LLL)LLLLLLLLLL)" _N_ _SPECIALISE_ [ Int, Double ] 2 { _A_ 2 _U_ 21 _N_ _S_ "LU(P)" {_A_ 2 _U_ 22 _N_ _N_ _N_ _N_} _N_ _N_ }, [ Int, (Ratio Integer) ] 2 { _A_ 2 _U_ 21 _N_ _S_ "LU(P)" {_A_ 2 _U_ 22 _N_ _N_ _N_ _N_} _N_ _N_ }, [ Int, (Complex Double) ] 2 { _A_ 2 _U_ 21 _N_ _S_ "LU(P)" {_A_ 2 _U_ 22 _N_ _N_ _N_ _N_} _N_ _N_ } #-}
appendBin :: Bin -> Bin -> Bin
- {-# GHC_PRAGMA _A_ 2 _U_ 22 _N_ _S_ _!_ _F_ _IF_ARGS_ 0 2 XX 4 \ (u0 :: Bin) (u1 :: Bin) -> _APP_ _TYAPP_ error { (Bin -> Bin -> Bin) } [ _NOREP_S_ "appendBin{Prelude}\n", u0, u1 ] _N_ #-}
+ {-# GHC_PRAGMA _A_ 2 _U_ 22 _N_ _S_ _!_ _N_ _N_ #-}
asTypeOf :: a -> a -> a
{-# GHC_PRAGMA _A_ 2 _U_ 10 _N_ _N_ _F_ _IF_ARGS_ 1 0 X 1 _/\_ u0 -> _TYAPP_ _TYAPP_ _ORIG_ Prelude const { u0 } { u0 } _N_ #-}
atan2 :: RealFloat a => a -> a -> a
{-# GHC_PRAGMA _A_ 2 _U_ 10 _N_ _S_ "SA" {_A_ 1 _U_ 1 _N_ _N_ _F_ _IF_ARGS_ 2 1 X 1 _/\_ u0 u1 -> \ (u2 :: u1) -> u2 _N_} _F_ _IF_ARGS_ 2 2 XX 1 _/\_ u0 u1 -> \ (u2 :: u1) (u3 :: u0) -> u2 _N_ #-}
flip :: (b -> a -> c) -> a -> b -> c
{-# GHC_PRAGMA _A_ 3 _U_ 122 _N_ _S_ "SLL" _F_ _IF_ARGS_ 3 3 XXX 3 _/\_ u0 u1 u2 -> \ (u3 :: u1 -> u0 -> u2) (u4 :: u0) (u5 :: u1) -> _APP_ u3 [ u5, u4 ] _N_ #-}
+fromChar# :: Char# -> Char
+ {-# GHC_PRAGMA _A_ 1 _U_ 2 _N_ _S_ "P" _F_ _IF_ARGS_ 0 1 X 2 \ (u0 :: Char#) -> _!_ C# [] [u0] _N_ #-}
+fromInt# :: Int# -> Int
+ {-# GHC_PRAGMA _A_ 1 _U_ 2 _N_ _S_ "P" _F_ _IF_ARGS_ 0 1 X 2 \ (u0 :: Int#) -> _!_ I# [] [u0] _N_ #-}
fromIntegral :: (Integral a, Num b) => a -> b
- {-# GHC_PRAGMA _A_ 3 _U_ 112 _N_ _S_ "LU(AAAAAAAASA)L" {_A_ 3 _U_ 112 _N_ _N_ _F_ _IF_ARGS_ 2 3 CXX 6 _/\_ u0 u1 -> \ (u2 :: {{Integral u0}}) (u3 :: Integer -> u1) (u4 :: u0) -> let {(uh :: Integer) = case u2 of { _ALG_ _TUP_12 (u5 :: {{Real u0}}) (u6 :: {{Ix u0}}) (u7 :: u0 -> u0 -> u0) (u8 :: u0 -> u0 -> u0) (u9 :: u0 -> u0 -> u0) (ua :: u0 -> u0 -> u0) (ub :: u0 -> u0 -> (u0, u0)) (uc :: u0 -> u0 -> (u0, u0)) (ud :: u0 -> Bool) (ue :: u0 -> Bool) (uf :: u0 -> Integer) (ug :: u0 -> Int) -> _APP_ uf [ u4 ]; _NO_DEFLT_ }} in _APP_ u3 [ uh ] _N_} _F_ _IF_ARGS_ 2 3 CCX 7 _/\_ u0 u1 -> \ (u2 :: {{Integral u0}}) (u3 :: {{Num u1}}) (u4 :: u0) -> let {(uh :: Integer) = case u2 of { _ALG_ _TUP_12 (u5 :: {{Real u0}}) (u6 :: {{Ix u0}}) (u7 :: u0 -> u0 -> u0) (u8 :: u0 -> u0 -> u0) (u9 :: u0 -> u0 -> u0) (ua :: u0 -> u0 -> u0) (ub :: u0 -> u0 -> (u0, u0)) (uc :: u0 -> u0 -> (u0, u0)) (ud :: u0 -> Bool) (ue :: u0 -> Bool) (uf :: u0 -> Integer) (ug :: u0 -> Int) -> _APP_ uf [ u4 ]; _NO_DEFLT_ }} in case u3 of { _ALG_ _TUP_10 (ui :: {{Eq u1}}) (uj :: {{Text u1}}) (uk :: u1 -> u1 -> u1) (ul :: u1 -> u1 -> u1) (um :: u1 -> u1 -> u1) (un :: u1 -> u1) (uo :: u1 -> u1) (up :: u1 -> u1) (uq :: Integer -> u1) (ur :: Int -> u1) -> _APP_ uq [ uh ]; _NO_DEFLT_ } _SPECIALISE_ [ Int, Double ] 2 { _A_ 1 _U_ 1 _N_ _S_ "U(P)" {_A_ 1 _U_ 2 _N_ _N_ _F_ _IF_ARGS_ 0 1 X 3 \ (u0 :: Int#) -> case _#_ int2Double# [] [u0] of { _PRIM_ (u1 :: Double#) -> _!_ D# [] [u1] } _N_} _F_ _IF_ARGS_ 0 1 C 4 \ (u0 :: Int) -> case u0 of { _ALG_ I# (u1 :: Int#) -> case _#_ int2Double# [] [u1] of { _PRIM_ (u2 :: Double#) -> _!_ D# [] [u2] }; _NO_DEFLT_ } _N_ }, [ Int, Int ] 2 { _A_ 1 _U_ 1 _N_ _N_ _F_ _IF_ARGS_ 0 0 X 1 _TYAPP_ _ORIG_ Prelude id { Int } _N_ }, [ Int, Integer ] 2 { _A_ 1 _U_ 1 _N_ _S_ "U(P)" {_A_ 1 _U_ 2 _N_ _N_ _F_ _IF_ARGS_ 0 1 X 1 \ (u0 :: Int#) -> _#_ int2Integer# [] [u0] _N_} _F_ _IF_ARGS_ 0 1 C 2 \ (u0 :: Int) -> case u0 of { _ALG_ I# (u1 :: Int#) -> _#_ int2Integer# [] [u1]; _NO_DEFLT_ } _N_ }, [ Integer, Double ] 2 { _A_ 1 _U_ 1 _N_ _S_ "U(PPP)" {_A_ 3 _U_ 222 _N_ _N_ _F_ _IF_ARGS_ 0 3 XXX 3 \ (u0 :: Int#) (u1 :: Int#) (u2 :: ByteArray#) -> case _#_ encodeDouble# [] [u0, u1, u2, 0#] of { _PRIM_ (u3 :: Double#) -> _!_ D# [] [u3] } _N_} _F_ _IF_ARGS_ 0 1 C 4 \ (u0 :: Integer) -> case u0 of { _ALG_ J# (u1 :: Int#) (u2 :: Int#) (u3 :: ByteArray#) -> case _#_ encodeDouble# [] [u1, u2, u3, 0#] of { _PRIM_ (u4 :: Double#) -> _!_ D# [] [u4] }; _NO_DEFLT_ } _N_ }, [ Integer, Int ] 2 { _A_ 1 _U_ 1 _N_ _S_ "U(PPP)" {_A_ 3 _U_ 222 _N_ _N_ _F_ _IF_ARGS_ 0 3 XXX 3 \ (u0 :: Int#) (u1 :: Int#) (u2 :: ByteArray#) -> case _#_ integer2Int# [] [u0, u1, u2] of { _PRIM_ (u3 :: Int#) -> _!_ I# [] [u3] } _N_} _F_ _IF_ARGS_ 0 1 C 4 \ (u0 :: Integer) -> case u0 of { _ALG_ J# (u1 :: Int#) (u2 :: Int#) (u3 :: ByteArray#) -> case _#_ integer2Int# [] [u1, u2, u3] of { _PRIM_ (u4 :: Int#) -> _!_ I# [] [u4] }; _NO_DEFLT_ } _N_ }, [ Integer, Integer ] 2 { _A_ 1 _U_ 1 _N_ _N_ _F_ _IF_ARGS_ 0 0 X 1 _TYAPP_ _ORIG_ Prelude id { Integer } _N_ } #-}
+ {-# GHC_PRAGMA _A_ 3 _U_ 112 _N_ _S_ "LU(AAAAAAAASA)L" {_A_ 3 _U_ 112 _N_ _N_ _F_ _IF_ARGS_ 2 3 CXX 6 _/\_ u0 u1 -> \ (u2 :: {{Integral u0}}) (u3 :: Integer -> u1) (u4 :: u0) -> let {(uh :: Integer) = case u2 of { _ALG_ _TUP_12 (u5 :: {{Real u0}}) (u6 :: {{Ix u0}}) (u7 :: u0 -> u0 -> u0) (u8 :: u0 -> u0 -> u0) (u9 :: u0 -> u0 -> u0) (ua :: u0 -> u0 -> u0) (ub :: u0 -> u0 -> (u0, u0)) (uc :: u0 -> u0 -> (u0, u0)) (ud :: u0 -> Bool) (ue :: u0 -> Bool) (uf :: u0 -> Integer) (ug :: u0 -> Int) -> _APP_ uf [ u4 ]; _NO_DEFLT_ }} in _APP_ u3 [ uh ] _N_} _F_ _IF_ARGS_ 2 3 CCX 7 _/\_ u0 u1 -> \ (u2 :: {{Integral u0}}) (u3 :: {{Num u1}}) (u4 :: u0) -> let {(uh :: Integer) = case u2 of { _ALG_ _TUP_12 (u5 :: {{Real u0}}) (u6 :: {{Ix u0}}) (u7 :: u0 -> u0 -> u0) (u8 :: u0 -> u0 -> u0) (u9 :: u0 -> u0 -> u0) (ua :: u0 -> u0 -> u0) (ub :: u0 -> u0 -> (u0, u0)) (uc :: u0 -> u0 -> (u0, u0)) (ud :: u0 -> Bool) (ue :: u0 -> Bool) (uf :: u0 -> Integer) (ug :: u0 -> Int) -> _APP_ uf [ u4 ]; _NO_DEFLT_ }} in case u3 of { _ALG_ _TUP_10 (ui :: {{Eq u1}}) (uj :: {{Text u1}}) (uk :: u1 -> u1 -> u1) (ul :: u1 -> u1 -> u1) (um :: u1 -> u1 -> u1) (un :: u1 -> u1) (uo :: u1 -> u1) (up :: u1 -> u1) (uq :: Integer -> u1) (ur :: Int -> u1) -> _APP_ uq [ uh ]; _NO_DEFLT_ } _SPECIALISE_ [ Int, Double ] 2 { _A_ 1 _U_ 1 _N_ _S_ "U(P)" {_A_ 1 _U_ 2 _N_ _N_ _F_ _IF_ARGS_ 0 1 X 3 \ (u0 :: Int#) -> case _#_ int2Double# [] [u0] of { _PRIM_ (u1 :: Double#) -> _!_ D# [] [u1] } _N_} _F_ _IF_ARGS_ 0 1 C 4 \ (u0 :: Int) -> case u0 of { _ALG_ I# (u1 :: Int#) -> case _#_ int2Double# [] [u1] of { _PRIM_ (u2 :: Double#) -> _!_ D# [] [u2] }; _NO_DEFLT_ } _N_ }, [ Int, Float ] 2 { _A_ 1 _U_ 1 _N_ _S_ "U(P)" {_A_ 1 _U_ 2 _N_ _N_ _F_ _IF_ARGS_ 0 1 X 3 \ (u0 :: Int#) -> case _#_ int2Float# [] [u0] of { _PRIM_ (u1 :: Float#) -> _!_ F# [] [u1] } _N_} _F_ _IF_ARGS_ 0 1 C 4 \ (u0 :: Int) -> case u0 of { _ALG_ I# (u1 :: Int#) -> case _#_ int2Float# [] [u1] of { _PRIM_ (u2 :: Float#) -> _!_ F# [] [u2] }; _NO_DEFLT_ } _N_ }, [ Int, Int ] 2 { _A_ 1 _U_ 1 _N_ _N_ _F_ _IF_ARGS_ 0 0 X 1 _TYAPP_ _ORIG_ Prelude id { Int } _N_ }, [ Int, Integer ] 2 { _A_ 1 _U_ 1 _N_ _S_ "U(P)" {_A_ 1 _U_ 2 _N_ _N_ _F_ _IF_ARGS_ 0 1 X 1 \ (u0 :: Int#) -> _#_ int2Integer# [] [u0] _N_} _F_ _IF_ARGS_ 0 1 C 2 \ (u0 :: Int) -> case u0 of { _ALG_ I# (u1 :: Int#) -> _#_ int2Integer# [] [u1]; _NO_DEFLT_ } _N_ }, [ Int, (Ratio Integer) ] 2 { _A_ 1 _U_ 1 _N_ _N_ _N_ _N_ }, [ Integer, Double ] 2 { _A_ 1 _U_ 1 _N_ _S_ "U(PPP)" {_A_ 3 _U_ 222 _N_ _N_ _F_ _IF_ARGS_ 0 3 XXX 3 \ (u0 :: Int#) (u1 :: Int#) (u2 :: ByteArray#) -> case _#_ encodeDouble# [] [u0, u1, u2, 0#] of { _PRIM_ (u3 :: Double#) -> _!_ D# [] [u3] } _N_} _F_ _IF_ARGS_ 0 1 C 4 \ (u0 :: Integer) -> case u0 of { _ALG_ J# (u1 :: Int#) (u2 :: Int#) (u3 :: ByteArray#) -> case _#_ encodeDouble# [] [u1, u2, u3, 0#] of { _PRIM_ (u4 :: Double#) -> _!_ D# [] [u4] }; _NO_DEFLT_ } _N_ }, [ Integer, Float ] 2 { _A_ 1 _U_ 1 _N_ _S_ "U(PPP)" {_A_ 3 _U_ 222 _N_ _N_ _F_ _IF_ARGS_ 0 3 XXX 3 \ (u0 :: Int#) (u1 :: Int#) (u2 :: ByteArray#) -> case _#_ encodeFloat# [] [u0, u1, u2, 0#] of { _PRIM_ (u3 :: Float#) -> _!_ F# [] [u3] } _N_} _F_ _IF_ARGS_ 0 1 C 4 \ (u0 :: Integer) -> case u0 of { _ALG_ J# (u1 :: Int#) (u2 :: Int#) (u3 :: ByteArray#) -> case _#_ encodeFloat# [] [u1, u2, u3, 0#] of { _PRIM_ (u4 :: Float#) -> _!_ F# [] [u4] }; _NO_DEFLT_ } _N_ }, [ Integer, Int ] 2 { _A_ 1 _U_ 1 _N_ _S_ "U(PPP)" {_A_ 3 _U_ 222 _N_ _N_ _F_ _IF_ARGS_ 0 3 XXX 3 \ (u0 :: Int#) (u1 :: Int#) (u2 :: ByteArray#) -> case _#_ integer2Int# [] [u0, u1, u2] of { _PRIM_ (u3 :: Int#) -> _!_ I# [] [u3] } _N_} _F_ _IF_ARGS_ 0 1 C 4 \ (u0 :: Integer) -> case u0 of { _ALG_ J# (u1 :: Int#) (u2 :: Int#) (u3 :: ByteArray#) -> case _#_ integer2Int# [] [u1, u2, u3] of { _PRIM_ (u4 :: Int#) -> _!_ I# [] [u4] }; _NO_DEFLT_ } _N_ }, [ Integer, Integer ] 2 { _A_ 1 _U_ 1 _N_ _N_ _F_ _IF_ARGS_ 0 0 X 1 _TYAPP_ _ORIG_ Prelude id { Integer } _N_ }, [ Integer, (Ratio Integer) ] 2 { _A_ 1 _U_ 2 _N_ _N_ _F_ _IF_ARGS_ 0 1 X 3 \ (u0 :: Integer) -> _!_ (:%) [Integer] [u0, _SPEC_ _ORIG_ PreludeCore __i1 [ (Integer) ]] _N_ } #-}
fromRealFrac :: (RealFrac a, Fractional b) => a -> b
- {-# GHC_PRAGMA _A_ 3 _U_ 112 _N_ _S_ "LU(AAAS)L" {_A_ 3 _U_ 112 _N_ _N_ _F_ _IF_ARGS_ 2 3 CXX 7 _/\_ u0 u1 -> \ (u2 :: {{RealFrac u0}}) (u3 :: Ratio Integer -> u1) (u4 :: u0) -> let {(uf :: Ratio Integer) = case u2 of { _ALG_ _TUP_7 (u5 :: {{Real u0}}) (u6 :: {{Fractional u0}}) (u7 :: _forall_ a$z1 =>{{Integral a$z1}} -> u0 -> (a$z1, u0)) (u8 :: _forall_ a$z1 =>{{Integral a$z1}} -> u0 -> a$z1) (u9 :: _forall_ a$z1 =>{{Integral a$z1}} -> u0 -> a$z1) (ua :: _forall_ a$z1 =>{{Integral a$z1}} -> u0 -> a$z1) (ub :: _forall_ a$z1 =>{{Integral a$z1}} -> u0 -> a$z1) -> case u5 of { _ALG_ _TUP_3 (uc :: {{Num u0}}) (ud :: {{Enum u0}}) (ue :: u0 -> Ratio Integer) -> _APP_ ue [ u4 ]; _NO_DEFLT_ }; _NO_DEFLT_ }} in _APP_ u3 [ uf ] _N_} _F_ _IF_ARGS_ 2 3 CCX 8 _/\_ u0 u1 -> \ (u2 :: {{RealFrac u0}}) (u3 :: {{Fractional u1}}) (u4 :: u0) -> let {(uf :: Ratio Integer) = case u2 of { _ALG_ _TUP_7 (u5 :: {{Real u0}}) (u6 :: {{Fractional u0}}) (u7 :: _forall_ a$z1 =>{{Integral a$z1}} -> u0 -> (a$z1, u0)) (u8 :: _forall_ a$z1 =>{{Integral a$z1}} -> u0 -> a$z1) (u9 :: _forall_ a$z1 =>{{Integral a$z1}} -> u0 -> a$z1) (ua :: _forall_ a$z1 =>{{Integral a$z1}} -> u0 -> a$z1) (ub :: _forall_ a$z1 =>{{Integral a$z1}} -> u0 -> a$z1) -> case u5 of { _ALG_ _TUP_3 (uc :: {{Num u0}}) (ud :: {{Enum u0}}) (ue :: u0 -> Ratio Integer) -> _APP_ ue [ u4 ]; _NO_DEFLT_ }; _NO_DEFLT_ }} in case u3 of { _ALG_ _TUP_4 (ug :: {{Num u1}}) (uh :: u1 -> u1 -> u1) (ui :: u1 -> u1) (uj :: Ratio Integer -> u1) -> _APP_ uj [ uf ]; _NO_DEFLT_ } _SPECIALISE_ [ Double, Double ] 2 { _A_ 1 _U_ 1 _N_ _N_ _F_ _IF_ARGS_ 0 0 X 1 _TYAPP_ _ORIG_ Prelude id { Double } _N_ }, [ Double, Float ] 2 { _A_ 1 _U_ 1 _N_ _S_ "U(P)" {_A_ 1 _U_ 2 _N_ _N_ _F_ _IF_ARGS_ 0 1 X 3 \ (u0 :: Double#) -> case _#_ double2Float# [] [u0] of { _PRIM_ (u1 :: Float#) -> _!_ F# [] [u1] } _N_} _F_ _IF_ARGS_ 0 1 C 4 \ (u0 :: Double) -> case u0 of { _ALG_ D# (u1 :: Double#) -> case _#_ double2Float# [] [u1] of { _PRIM_ (u2 :: Float#) -> _!_ F# [] [u2] }; _NO_DEFLT_ } _N_ }, [ Float, Double ] 2 { _A_ 1 _U_ 1 _N_ _S_ "U(P)" {_A_ 1 _U_ 2 _N_ _N_ _F_ _IF_ARGS_ 0 1 X 3 \ (u0 :: Float#) -> case _#_ float2Double# [] [u0] of { _PRIM_ (u1 :: Double#) -> _!_ D# [] [u1] } _N_} _F_ _IF_ARGS_ 0 1 C 4 \ (u0 :: Float) -> case u0 of { _ALG_ F# (u1 :: Float#) -> case _#_ float2Double# [] [u1] of { _PRIM_ (u2 :: Double#) -> _!_ D# [] [u2] }; _NO_DEFLT_ } _N_ }, [ Float, Float ] 2 { _A_ 1 _U_ 1 _N_ _N_ _F_ _IF_ARGS_ 0 0 X 1 _TYAPP_ _ORIG_ Prelude id { Float } _N_ } #-}
+ {-# GHC_PRAGMA _A_ 3 _U_ 112 _N_ _S_ "LU(AAAS)L" {_A_ 3 _U_ 112 _N_ _N_ _F_ _IF_ARGS_ 2 3 CXX 7 _/\_ u0 u1 -> \ (u2 :: {{RealFrac u0}}) (u3 :: Ratio Integer -> u1) (u4 :: u0) -> let {(uf :: Ratio Integer) = case u2 of { _ALG_ _TUP_7 (u5 :: {{Real u0}}) (u6 :: {{Fractional u0}}) (u7 :: _forall_ a$z1 =>{{Integral a$z1}} -> u0 -> (a$z1, u0)) (u8 :: _forall_ a$z1 =>{{Integral a$z1}} -> u0 -> a$z1) (u9 :: _forall_ a$z1 =>{{Integral a$z1}} -> u0 -> a$z1) (ua :: _forall_ a$z1 =>{{Integral a$z1}} -> u0 -> a$z1) (ub :: _forall_ a$z1 =>{{Integral a$z1}} -> u0 -> a$z1) -> case u5 of { _ALG_ _TUP_3 (uc :: {{Num u0}}) (ud :: {{Enum u0}}) (ue :: u0 -> Ratio Integer) -> _APP_ ue [ u4 ]; _NO_DEFLT_ }; _NO_DEFLT_ }} in _APP_ u3 [ uf ] _N_} _F_ _IF_ARGS_ 2 3 CCX 8 _/\_ u0 u1 -> \ (u2 :: {{RealFrac u0}}) (u3 :: {{Fractional u1}}) (u4 :: u0) -> let {(uf :: Ratio Integer) = case u2 of { _ALG_ _TUP_7 (u5 :: {{Real u0}}) (u6 :: {{Fractional u0}}) (u7 :: _forall_ a$z1 =>{{Integral a$z1}} -> u0 -> (a$z1, u0)) (u8 :: _forall_ a$z1 =>{{Integral a$z1}} -> u0 -> a$z1) (u9 :: _forall_ a$z1 =>{{Integral a$z1}} -> u0 -> a$z1) (ua :: _forall_ a$z1 =>{{Integral a$z1}} -> u0 -> a$z1) (ub :: _forall_ a$z1 =>{{Integral a$z1}} -> u0 -> a$z1) -> case u5 of { _ALG_ _TUP_3 (uc :: {{Num u0}}) (ud :: {{Enum u0}}) (ue :: u0 -> Ratio Integer) -> _APP_ ue [ u4 ]; _NO_DEFLT_ }; _NO_DEFLT_ }} in case u3 of { _ALG_ _TUP_4 (ug :: {{Num u1}}) (uh :: u1 -> u1 -> u1) (ui :: u1 -> u1) (uj :: Ratio Integer -> u1) -> _APP_ uj [ uf ]; _NO_DEFLT_ } _SPECIALISE_ [ Double, Double ] 2 { _A_ 1 _U_ 1 _N_ _N_ _F_ _IF_ARGS_ 0 0 X 1 _TYAPP_ _ORIG_ Prelude id { Double } _N_ }, [ Double, Float ] 2 { _A_ 1 _U_ 1 _N_ _S_ "U(P)" {_A_ 1 _U_ 2 _N_ _N_ _F_ _IF_ARGS_ 0 1 X 3 \ (u0 :: Double#) -> case _#_ double2Float# [] [u0] of { _PRIM_ (u1 :: Float#) -> _!_ F# [] [u1] } _N_} _F_ _IF_ARGS_ 0 1 C 4 \ (u0 :: Double) -> case u0 of { _ALG_ D# (u1 :: Double#) -> case _#_ double2Float# [] [u1] of { _PRIM_ (u2 :: Float#) -> _!_ F# [] [u2] }; _NO_DEFLT_ } _N_ }, [ Double, (Ratio Integer) ] 2 { _A_ 1 _U_ 1 _N_ _S_ "U(P)" {_A_ 1 _U_ 2 _N_ _N_ _N_ _N_} _N_ _N_ }, [ Float, Double ] 2 { _A_ 1 _U_ 1 _N_ _S_ "U(P)" {_A_ 1 _U_ 2 _N_ _N_ _F_ _IF_ARGS_ 0 1 X 3 \ (u0 :: Float#) -> case _#_ float2Double# [] [u0] of { _PRIM_ (u1 :: Double#) -> _!_ D# [] [u1] } _N_} _F_ _IF_ARGS_ 0 1 C 4 \ (u0 :: Float) -> case u0 of { _ALG_ F# (u1 :: Float#) -> case _#_ float2Double# [] [u1] of { _PRIM_ (u2 :: Double#) -> _!_ D# [] [u2] }; _NO_DEFLT_ } _N_ }, [ Float, Float ] 2 { _A_ 1 _U_ 1 _N_ _N_ _F_ _IF_ARGS_ 0 0 X 1 _TYAPP_ _ORIG_ Prelude id { Float } _N_ }, [ Float, (Ratio Integer) ] 2 { _A_ 1 _U_ 1 _N_ _S_ "U(P)" {_A_ 1 _U_ 2 _N_ _N_ _N_ _N_} _N_ _N_ }, [ (Ratio Integer), Double ] 2 { _A_ 1 _U_ 1 _N_ _S_ "U(U(PPP)U(PPP))" {_A_ 4 _U_ 2222 _N_ _N_ _N_ _N_} _N_ _N_ }, [ (Ratio Integer), Float ] 2 { _A_ 1 _U_ 2 _N_ _N_ _F_ _IF_ARGS_ 0 0 X 1 _CONSTM_ Fractional fromRational (Float) _N_ }, [ (Ratio Integer), (Ratio Integer) ] 2 { _A_ 1 _U_ 1 _N_ _N_ _F_ _IF_ARGS_ 0 0 X 1 _TYAPP_ _ORIG_ Prelude id { (Ratio Integer) } _N_ } #-}
fst :: (b, a) -> b
{-# GHC_PRAGMA _A_ 1 _U_ 1 _N_ _S_ "U(SA)" {_A_ 1 _U_ 1 _N_ _N_ _F_ _IF_ARGS_ 2 1 X 1 _/\_ u0 u1 -> \ (u2 :: u1) -> u2 _N_} _F_ _IF_ARGS_ 2 1 C 2 _/\_ u0 u1 -> \ (u2 :: (u1, u0)) -> case u2 of { _ALG_ _TUP_2 (u3 :: u1) (u4 :: u0) -> u3; _NO_DEFLT_ } _N_ #-}
gcd :: Integral a => a -> a -> a
{-# GHC_PRAGMA _A_ 1 _U_ 1 _N_ _S_ "S" _F_ _IF_ARGS_ 1 1 X 1 _/\_ u0 -> \ (u1 :: u0) -> u1 _N_ #-}
isAlpha :: Char -> Bool
{-# GHC_PRAGMA _A_ 1 _U_ 1 _N_ _S_ "U(P)" {_A_ 1 _U_ 2 _N_ _N_ _N_ _N_} _N_ _N_ #-}
+isAlpha# :: Char# -> Bool
+ {-# GHC_PRAGMA _A_ 1 _U_ 2 _N_ _S_ "P" _N_ _N_ #-}
isAlphanum :: Char -> Bool
{-# GHC_PRAGMA _A_ 1 _U_ 1 _N_ _S_ "U(P)" {_A_ 1 _U_ 2 _N_ _N_ _N_ _N_} _N_ _N_ #-}
+isAlphanum# :: Char# -> Bool
+ {-# GHC_PRAGMA _A_ 1 _U_ 2 _N_ _S_ "P" _N_ _N_ #-}
isAscii :: Char -> Bool
{-# GHC_PRAGMA _A_ 1 _U_ 1 _N_ _S_ "U(P)" {_A_ 1 _U_ 2 _N_ _N_ _F_ _IF_ARGS_ 0 1 X 2 \ (u0 :: Char#) -> case _#_ ord# [] [u0] of { _PRIM_ (u1 :: Int#) -> _#_ ltInt# [] [u1, 128#] } _N_} _F_ _IF_ARGS_ 0 1 C 3 \ (u0 :: Char) -> case u0 of { _ALG_ C# (u1 :: Char#) -> case _#_ ord# [] [u1] of { _PRIM_ (u2 :: Int#) -> _#_ ltInt# [] [u2, 128#] }; _NO_DEFLT_ } _N_ #-}
+isAscii# :: Char# -> Bool
+ {-# GHC_PRAGMA _A_ 1 _U_ 2 _N_ _S_ "P" _F_ _IF_ARGS_ 0 1 X 2 \ (u0 :: Char#) -> case _#_ ord# [] [u0] of { _PRIM_ (u1 :: Int#) -> _#_ ltInt# [] [u1, 128#] } _N_ #-}
isControl :: Char -> Bool
{-# GHC_PRAGMA _A_ 1 _U_ 1 _N_ _S_ "U(P)" {_A_ 1 _U_ 2 _N_ _N_ _N_ _N_} _N_ _N_ #-}
+isControl# :: Char# -> Bool
+ {-# GHC_PRAGMA _A_ 1 _U_ 2 _N_ _S_ "P" _N_ _N_ #-}
isDigit :: Char -> Bool
{-# GHC_PRAGMA _A_ 1 _U_ 1 _N_ _S_ "U(P)" {_A_ 1 _U_ 2 _N_ _N_ _N_ _N_} _N_ _N_ #-}
+isDigit# :: Char# -> Bool
+ {-# GHC_PRAGMA _A_ 1 _U_ 2 _N_ _S_ "P" _N_ _N_ #-}
isLower :: Char -> Bool
{-# GHC_PRAGMA _A_ 1 _U_ 1 _N_ _S_ "U(P)" {_A_ 1 _U_ 2 _N_ _N_ _N_ _N_} _N_ _N_ #-}
+isLower# :: Char# -> Bool
+ {-# GHC_PRAGMA _A_ 1 _U_ 2 _N_ _S_ "P" _N_ _N_ #-}
isNullBin :: Bin -> Bool
- {-# GHC_PRAGMA _A_ 1 _U_ 2 _N_ _S_ _!_ _F_ _IF_ARGS_ 0 1 X 3 \ (u0 :: Bin) -> _APP_ _TYAPP_ error { (Bin -> Bool) } [ _NOREP_S_ "isNullBin{Prelude}\n", u0 ] _N_ #-}
+ {-# GHC_PRAGMA _A_ 1 _U_ 2 _N_ _S_ _!_ _N_ _N_ #-}
isPrint :: Char -> Bool
{-# GHC_PRAGMA _A_ 1 _U_ 1 _N_ _S_ "U(P)" {_A_ 1 _U_ 2 _N_ _N_ _N_ _N_} _N_ _N_ #-}
+isPrint# :: Char# -> Bool
+ {-# GHC_PRAGMA _A_ 1 _U_ 2 _N_ _S_ "P" _N_ _N_ #-}
isSpace :: Char -> Bool
{-# GHC_PRAGMA _A_ 1 _U_ 1 _N_ _S_ "U(P)" {_A_ 1 _U_ 1 _N_ _N_ _N_ _N_} _N_ _N_ #-}
+isSpace# :: Char# -> Bool
+ {-# GHC_PRAGMA _A_ 1 _U_ 1 _N_ _S_ "P" _N_ _N_ #-}
isUpper :: Char -> Bool
{-# GHC_PRAGMA _A_ 1 _U_ 1 _N_ _S_ "U(P)" {_A_ 1 _U_ 2 _N_ _N_ _N_ _N_} _N_ _N_ #-}
+isUpper# :: Char# -> Bool
+ {-# GHC_PRAGMA _A_ 1 _U_ 2 _N_ _S_ "P" _N_ _N_ #-}
lcm :: Integral a => a -> a -> a
{-# GHC_PRAGMA _A_ 1 _U_ 122 _N_ _S_ "U(U(U(U(SA)AAALALAAL)AA)ALLAAAAAAAA)" {_A_ 3 _U_ 12222 _N_ _N_ _N_ _N_} _N_ _SPECIALISE_ [ Int ] 1 { _A_ 2 _U_ 11 _N_ _S_ "LU(P)" {_A_ 2 _U_ 12 _N_ _N_ _N_ _N_} _N_ _N_ }, [ Integer ] 1 { _A_ 2 _U_ 11 _N_ _S_ "LU(PPP)" {_A_ 4 _U_ 1222 _N_ _N_ _N_ _N_} _N_ _N_ } #-}
maxChar :: Char
{-# GHC_PRAGMA _A_ 0 _N_ _N_ _N_ _F_ _IF_ARGS_ 0 0 X 2 _!_ C# [] ['\o377'#] _N_ #-}
+maxChar# :: Char#
+ {-# GHC_PRAGMA _A_ 0 _N_ _N_ _N_ _F_ _IF_ARGS_ 0 0 X 2 _!_ _Lift [Char#] ['\o377'#] _N_ #-}
maxInt :: Int
{-# GHC_PRAGMA _A_ 0 _N_ _N_ _N_ _F_ _IF_ARGS_ 0 0 X 2 _!_ I# [] [2147483647#] _N_ #-}
+maxInt# :: Int#
+ {-# GHC_PRAGMA _A_ 0 _N_ _N_ _N_ _F_ _IF_ARGS_ 0 0 X 2 _!_ _Lift [Int#] [2147483647#] _N_ #-}
minChar :: Char
{-# GHC_PRAGMA _A_ 0 _N_ _N_ _N_ _F_ _IF_ARGS_ 0 0 X 2 _!_ C# [] ['\o0'#] _N_ #-}
+minChar# :: Char#
+ {-# GHC_PRAGMA _A_ 0 _N_ _N_ _N_ _F_ _IF_ARGS_ 0 0 X 2 _!_ _Lift [Char#] ['\o0'#] _N_ #-}
minInt :: Int
{-# GHC_PRAGMA _A_ 0 _N_ _N_ _N_ _F_ _IF_ARGS_ 0 0 X 2 _!_ I# [] [-2147483647#] _N_ #-}
+minInt# :: Int#
+ {-# GHC_PRAGMA _A_ 0 _N_ _N_ _N_ _F_ _IF_ARGS_ 0 0 X 2 _!_ _Lift [Int#] [-2147483647#] _N_ #-}
not :: Bool -> Bool
{-# GHC_PRAGMA _A_ 1 _U_ 1 _N_ _S_ "E" _F_ _ALWAYS_ \ (u0 :: Bool) -> case u0 of { _ALG_ True -> _!_ False [] []; False -> _!_ True [] []; _NO_DEFLT_ } _N_ #-}
nullBin :: Bin
- {-# GHC_PRAGMA _A_ 0 _N_ _N_ _S_ _!_ _F_ _IF_ARGS_ 0 0 X 2 _APP_ _TYAPP_ error { Bin } [ _NOREP_S_ "nullBin{Prelude}\n" ] _N_ #-}
+ {-# GHC_PRAGMA _A_ 0 _N_ _N_ _S_ _!_ _N_ _N_ #-}
ord :: Char -> Int
{-# GHC_PRAGMA _A_ 1 _U_ 1 _N_ _S_ "U(P)" {_A_ 1 _U_ 2 _N_ _N_ _F_ _IF_ARGS_ 0 1 X 3 \ (u0 :: Char#) -> case _#_ ord# [] [u0] of { _PRIM_ (u1 :: Int#) -> _!_ I# [] [u1] } _N_} _F_ _IF_ARGS_ 0 1 C 4 \ (u0 :: Char) -> case u0 of { _ALG_ C# (u1 :: Char#) -> case _#_ ord# [] [u1] of { _PRIM_ (u2 :: Int#) -> _!_ I# [] [u2] }; _NO_DEFLT_ } _N_ #-}
otherwise :: Bool
snd :: (a, b) -> b
{-# GHC_PRAGMA _A_ 1 _U_ 1 _N_ _S_ "U(AS)" {_A_ 1 _U_ 1 _N_ _N_ _F_ _IF_ARGS_ 2 1 X 1 _/\_ u0 u1 -> \ (u2 :: u1) -> u2 _N_} _F_ _IF_ARGS_ 2 1 C 2 _/\_ u0 u1 -> \ (u2 :: (u0, u1)) -> case u2 of { _ALG_ _TUP_2 (u3 :: u0) (u4 :: u1) -> u4; _NO_DEFLT_ } _N_ #-}
subtract :: Num a => a -> a -> a
- {-# GHC_PRAGMA _A_ 3 _U_ 122 _N_ _S_ "U(AAASAAAAAA)LL" {_A_ 3 _U_ 122 _N_ _N_ _F_ _IF_ARGS_ 1 3 XXX 3 _/\_ u0 -> \ (u1 :: u0 -> u0 -> u0) (u2 :: u0) (u3 :: u0) -> _APP_ u1 [ u3, u2 ] _N_} _F_ _IF_ARGS_ 1 3 CXX 4 _/\_ u0 -> \ (u1 :: {{Num u0}}) (u2 :: u0) (u3 :: u0) -> case u1 of { _ALG_ _TUP_10 (u4 :: {{Eq u0}}) (u5 :: {{Text u0}}) (u6 :: u0 -> u0 -> u0) (u7 :: u0 -> u0 -> u0) (u8 :: u0 -> u0 -> u0) (u9 :: u0 -> u0) (ua :: u0 -> u0) (ub :: u0 -> u0) (uc :: Integer -> u0) (ud :: Int -> u0) -> _APP_ u7 [ u3, u2 ]; _NO_DEFLT_ } _SPECIALISE_ [ Double ] 1 { _A_ 2 _U_ 11 _N_ _S_ "U(P)U(P)" {_A_ 2 _U_ 22 _N_ _N_ _F_ _IF_ARGS_ 0 2 XX 3 \ (u0 :: Double#) (u1 :: Double#) -> case _#_ minusDouble# [] [u1, u0] of { _PRIM_ (u2 :: Double#) -> _!_ D# [] [u2] } _N_} _F_ _IF_ARGS_ 0 2 CC 5 \ (u0 :: Double) (u1 :: Double) -> case u1 of { _ALG_ D# (u2 :: Double#) -> case u0 of { _ALG_ D# (u3 :: Double#) -> case _#_ minusDouble# [] [u2, u3] of { _PRIM_ (u4 :: Double#) -> _!_ D# [] [u4] }; _NO_DEFLT_ }; _NO_DEFLT_ } _N_ }, [ Int ] 1 { _A_ 2 _U_ 11 _N_ _S_ "U(P)U(P)" {_A_ 2 _U_ 22 _N_ _N_ _F_ _IF_ARGS_ 0 2 XX 3 \ (u0 :: Int#) (u1 :: Int#) -> case _#_ minusInt# [] [u1, u0] of { _PRIM_ (u2 :: Int#) -> _!_ I# [] [u2] } _N_} _F_ _IF_ARGS_ 0 2 CC 5 \ (u0 :: Int) (u1 :: Int) -> case u1 of { _ALG_ I# (u2 :: Int#) -> case u0 of { _ALG_ I# (u3 :: Int#) -> case _#_ minusInt# [] [u2, u3] of { _PRIM_ (u4 :: Int#) -> _!_ I# [] [u4] }; _NO_DEFLT_ }; _NO_DEFLT_ } _N_ } #-}
+ {-# GHC_PRAGMA _A_ 3 _U_ 122 _N_ _S_ "U(AAASAAAAAA)LL" {_A_ 3 _U_ 122 _N_ _N_ _F_ _IF_ARGS_ 1 3 XXX 3 _/\_ u0 -> \ (u1 :: u0 -> u0 -> u0) (u2 :: u0) (u3 :: u0) -> _APP_ u1 [ u3, u2 ] _N_} _F_ _IF_ARGS_ 1 3 CXX 4 _/\_ u0 -> \ (u1 :: {{Num u0}}) (u2 :: u0) (u3 :: u0) -> case u1 of { _ALG_ _TUP_10 (u4 :: {{Eq u0}}) (u5 :: {{Text u0}}) (u6 :: u0 -> u0 -> u0) (u7 :: u0 -> u0 -> u0) (u8 :: u0 -> u0 -> u0) (u9 :: u0 -> u0) (ua :: u0 -> u0) (ub :: u0 -> u0) (uc :: Integer -> u0) (ud :: Int -> u0) -> _APP_ u7 [ u3, u2 ]; _NO_DEFLT_ } _SPECIALISE_ [ Double ] 1 { _A_ 2 _U_ 11 _N_ _S_ "U(P)U(P)" {_A_ 2 _U_ 22 _N_ _N_ _F_ _IF_ARGS_ 0 2 XX 3 \ (u0 :: Double#) (u1 :: Double#) -> case _#_ minusDouble# [] [u1, u0] of { _PRIM_ (u2 :: Double#) -> _!_ D# [] [u2] } _N_} _F_ _IF_ARGS_ 0 2 CC 5 \ (u0 :: Double) (u1 :: Double) -> case u1 of { _ALG_ D# (u2 :: Double#) -> case u0 of { _ALG_ D# (u3 :: Double#) -> case _#_ minusDouble# [] [u2, u3] of { _PRIM_ (u4 :: Double#) -> _!_ D# [] [u4] }; _NO_DEFLT_ }; _NO_DEFLT_ } _N_ }, [ Int ] 1 { _A_ 2 _U_ 11 _N_ _S_ "U(P)U(P)" {_A_ 2 _U_ 22 _N_ _N_ _F_ _IF_ARGS_ 0 2 XX 3 \ (u0 :: Int#) (u1 :: Int#) -> case _#_ minusInt# [] [u1, u0] of { _PRIM_ (u2 :: Int#) -> _!_ I# [] [u2] } _N_} _F_ _IF_ARGS_ 0 2 CC 5 \ (u0 :: Int) (u1 :: Int) -> case u1 of { _ALG_ I# (u2 :: Int#) -> case u0 of { _ALG_ I# (u3 :: Int#) -> case _#_ minusInt# [] [u2, u3] of { _PRIM_ (u4 :: Int#) -> _!_ I# [] [u4] }; _NO_DEFLT_ }; _NO_DEFLT_ } _N_ }, [ (Complex Double) ] 1 { _A_ 2 _U_ 11 _N_ _S_ "U(LL)U(LL)" {_A_ 4 _U_ 2222 _N_ _N_ _N_ _N_} _N_ _N_ } #-}
+toChar# :: Char -> Char#
+ {-# GHC_PRAGMA _A_ 1 _U_ 1 _N_ _S_ "U(P)" {_A_ 1 _U_ 1 _N_ _N_ _F_ _IF_ARGS_ 0 1 X 1 \ (u0 :: Char#) -> u0 _N_} _F_ _IF_ARGS_ 0 1 C 2 \ (u0 :: Char) -> case u0 of { _ALG_ C# (u1 :: Char#) -> u1; _NO_DEFLT_ } _N_ #-}
+toInt# :: Int -> Int#
+ {-# GHC_PRAGMA _A_ 1 _U_ 1 _N_ _S_ "U(P)" {_A_ 1 _U_ 1 _N_ _N_ _F_ _IF_ARGS_ 0 1 X 1 \ (u0 :: Int#) -> u0 _N_} _F_ _IF_ARGS_ 0 1 C 2 \ (u0 :: Int) -> case u0 of { _ALG_ I# (u1 :: Int#) -> u1; _NO_DEFLT_ } _N_ #-}
toLower :: Char -> Char
{-# GHC_PRAGMA _A_ 1 _U_ 1 _N_ _S_ "U(P)" {_A_ 1 _U_ 2 _N_ _N_ _N_ _N_} _N_ _N_ #-}
+toLower# :: Char# -> Char#
+ {-# GHC_PRAGMA _A_ 1 _U_ 2 _N_ _S_ "P" _N_ _N_ #-}
toUpper :: Char -> Char
{-# GHC_PRAGMA _A_ 1 _U_ 1 _N_ _S_ "U(P)" {_A_ 1 _U_ 2 _N_ _N_ _N_ _N_} _N_ _N_ #-}
+toUpper# :: Char# -> Char#
+ {-# GHC_PRAGMA _A_ 1 _U_ 2 _N_ _S_ "P" _N_ _N_ #-}
until :: (a -> Bool) -> (a -> a) -> a -> a
{-# GHC_PRAGMA _A_ 3 _U_ 222 _N_ _S_ "SLL" _N_ _N_ #-}
(||) :: Bool -> Bool -> Bool
-{-# GHC_PRAGMA INTERFACE VERSION 5 #-}
+{-# GHC_PRAGMA INTERFACE VERSION 6 #-}
interface Prelude where
import PreludeBuiltin(Bin, Char(..), Int(..), Tuple2)
import PreludeCore(Bool(..), Fractional(..), Integral(..), Num(..), RealFloat(..), RealFrac(..))
(.) :: (a -> c) -> (b -> a) -> b -> c
{-# GHC_PRAGMA _A_ 3 _U_ 112 _N_ _S_ "SLL" _F_ _ALWAYS_ _/\_ u0 u1 u2 -> \ (u3 :: u0 -> u2) (u4 :: u1 -> u0) (u5 :: u1) -> let {(u6 :: u0) = _APP_ u4 [ u5 ]} in _APP_ u3 [ u6 ] _N_ #-}
(^) :: (Num b, Integral a) => b -> a -> b
- {-# GHC_PRAGMA _A_ 2 _U_ 2122 _N_ _S_ "LU(U(LU(U(U(SA)AALAAAA)AAAA)A)AAALAAAALAA)" {_A_ 5 _U_ 2212222 _N_ _N_ _N_ _N_} _N_ _SPECIALISE_ [ Int, Double ] 2 { _A_ 2 _U_ 21 _N_ _S_ "LU(P)" {_A_ 2 _U_ 22 _N_ _N_ _N_ _N_} _N_ _N_ }, [ Int, Int ] 2 { _A_ 2 _U_ 21 _N_ _S_ "LU(P)" {_A_ 2 _U_ 22 _N_ _N_ _N_ _N_} _N_ _N_ }, [ Int, Integer ] 2 { _A_ 2 _U_ 21 _N_ _S_ "LU(P)" {_A_ 2 _U_ 22 _N_ _N_ _N_ _N_} _N_ _N_ }, [ Int, (Ratio Integer) ] 2 { _A_ 2 _U_ 21 _N_ _S_ "LU(P)" {_A_ 2 _U_ 22 _N_ _N_ _N_ _N_} _N_ _N_ }, [ Int, (Complex Double) ] 2 { _A_ 2 _U_ 21 _N_ _S_ "LU(P)" {_A_ 2 _U_ 22 _N_ _N_ _N_ _N_} _N_ _N_ } #-}
+ {-# GHC_PRAGMA _A_ 2 _U_ 2122 _N_ _S_ "LU(U(LU(U(U(SL)LLLLLLL)LLLL)L)LLLLLLLLLLL)" _N_ _SPECIALISE_ [ Int, Double ] 2 { _A_ 2 _U_ 21 _N_ _S_ "LU(P)" {_A_ 2 _U_ 22 _N_ _N_ _N_ _N_} _N_ _N_ }, [ Int, Int ] 2 { _A_ 2 _U_ 21 _N_ _S_ "LU(P)" {_A_ 2 _U_ 22 _N_ _N_ _N_ _N_} _N_ _N_ }, [ Int, Integer ] 2 { _A_ 2 _U_ 21 _N_ _S_ "LU(P)" {_A_ 2 _U_ 22 _N_ _N_ _N_ _N_} _N_ _N_ }, [ Int, (Ratio Integer) ] 2 { _A_ 2 _U_ 21 _N_ _S_ "LU(P)" {_A_ 2 _U_ 22 _N_ _N_ _N_ _N_} _N_ _N_ }, [ Int, (Complex Double) ] 2 { _A_ 2 _U_ 21 _N_ _S_ "LU(P)" {_A_ 2 _U_ 22 _N_ _N_ _N_ _N_} _N_ _N_ }, [ Integer, Integer ] 2 { _A_ 2 _U_ 21 _N_ _S_ "LU(PPP)" {_A_ 4 _U_ 2222 _N_ _N_ _N_ _N_} _N_ _N_ } #-}
(^^) :: (Fractional b, Integral a) => b -> a -> b
- {-# GHC_PRAGMA _A_ 2 _U_ 2122 _N_ _S_ "LU(LU(U(AAASAAAA)AAA)AALAAAALAA)" {_A_ 5 _U_ 2212222 _N_ _N_ _N_ _N_} _N_ _SPECIALISE_ [ Int, Double ] 2 { _A_ 2 _U_ 21 _N_ _S_ "LU(P)" {_A_ 2 _U_ 22 _N_ _N_ _N_ _N_} _N_ _N_ }, [ Int, (Ratio Integer) ] 2 { _A_ 2 _U_ 21 _N_ _S_ "LU(P)" {_A_ 2 _U_ 22 _N_ _N_ _N_ _N_} _N_ _N_ } #-}
+ {-# GHC_PRAGMA _A_ 2 _U_ 2222 _N_ _S_ "LU(LU(U(LLLSLLLL)LLL)LLLLLLLLLL)" _N_ _SPECIALISE_ [ Int, Double ] 2 { _A_ 2 _U_ 21 _N_ _S_ "LU(P)" {_A_ 2 _U_ 22 _N_ _N_ _N_ _N_} _N_ _N_ }, [ Int, (Ratio Integer) ] 2 { _A_ 2 _U_ 21 _N_ _S_ "LU(P)" {_A_ 2 _U_ 22 _N_ _N_ _N_ _N_} _N_ _N_ }, [ Int, (Complex Double) ] 2 { _A_ 2 _U_ 21 _N_ _S_ "LU(P)" {_A_ 2 _U_ 22 _N_ _N_ _N_ _N_} _N_ _N_ } #-}
appendBin :: Bin -> Bin -> Bin
- {-# GHC_PRAGMA _A_ 2 _U_ 22 _N_ _S_ _!_ _F_ _IF_ARGS_ 0 2 XX 4 \ (u0 :: Bin) (u1 :: Bin) -> _APP_ _TYAPP_ error { (Bin -> Bin -> Bin) } [ _NOREP_S_ "appendBin{Prelude}\n", u0, u1 ] _N_ #-}
+ {-# GHC_PRAGMA _A_ 2 _U_ 22 _N_ _S_ _!_ _N_ _N_ #-}
asTypeOf :: a -> a -> a
{-# GHC_PRAGMA _A_ 2 _U_ 10 _N_ _N_ _F_ _IF_ARGS_ 1 0 X 1 _/\_ u0 -> _TYAPP_ _TYAPP_ _ORIG_ Prelude const { u0 } { u0 } _N_ #-}
atan2 :: RealFloat a => a -> a -> a
{-# GHC_PRAGMA _A_ 2 _U_ 10 _N_ _S_ "SA" {_A_ 1 _U_ 1 _N_ _N_ _F_ _IF_ARGS_ 2 1 X 1 _/\_ u0 u1 -> \ (u2 :: u1) -> u2 _N_} _F_ _IF_ARGS_ 2 2 XX 1 _/\_ u0 u1 -> \ (u2 :: u1) (u3 :: u0) -> u2 _N_ #-}
flip :: (b -> a -> c) -> a -> b -> c
{-# GHC_PRAGMA _A_ 3 _U_ 122 _N_ _S_ "SLL" _F_ _IF_ARGS_ 3 3 XXX 3 _/\_ u0 u1 u2 -> \ (u3 :: u1 -> u0 -> u2) (u4 :: u0) (u5 :: u1) -> _APP_ u3 [ u5, u4 ] _N_ #-}
+fromChar# :: Char# -> Char
+ {-# GHC_PRAGMA _A_ 1 _U_ 2 _N_ _S_ "P" _F_ _IF_ARGS_ 0 1 X 2 \ (u0 :: Char#) -> _!_ C# [] [u0] _N_ #-}
+fromInt# :: Int# -> Int
+ {-# GHC_PRAGMA _A_ 1 _U_ 2 _N_ _S_ "P" _F_ _IF_ARGS_ 0 1 X 2 \ (u0 :: Int#) -> _!_ I# [] [u0] _N_ #-}
fromIntegral :: (Integral a, Num b) => a -> b
- {-# GHC_PRAGMA _A_ 3 _U_ 112 _N_ _S_ "LU(AAAAAAAASA)L" {_A_ 3 _U_ 112 _N_ _N_ _F_ _IF_ARGS_ 2 3 CXX 6 _/\_ u0 u1 -> \ (u2 :: {{Integral u0}}) (u3 :: Integer -> u1) (u4 :: u0) -> let {(uh :: Integer) = case u2 of { _ALG_ _TUP_12 (u5 :: {{Real u0}}) (u6 :: {{Ix u0}}) (u7 :: u0 -> u0 -> u0) (u8 :: u0 -> u0 -> u0) (u9 :: u0 -> u0 -> u0) (ua :: u0 -> u0 -> u0) (ub :: u0 -> u0 -> (u0, u0)) (uc :: u0 -> u0 -> (u0, u0)) (ud :: u0 -> Bool) (ue :: u0 -> Bool) (uf :: u0 -> Integer) (ug :: u0 -> Int) -> _APP_ uf [ u4 ]; _NO_DEFLT_ }} in _APP_ u3 [ uh ] _N_} _F_ _IF_ARGS_ 2 3 CCX 7 _/\_ u0 u1 -> \ (u2 :: {{Integral u0}}) (u3 :: {{Num u1}}) (u4 :: u0) -> let {(uh :: Integer) = case u2 of { _ALG_ _TUP_12 (u5 :: {{Real u0}}) (u6 :: {{Ix u0}}) (u7 :: u0 -> u0 -> u0) (u8 :: u0 -> u0 -> u0) (u9 :: u0 -> u0 -> u0) (ua :: u0 -> u0 -> u0) (ub :: u0 -> u0 -> (u0, u0)) (uc :: u0 -> u0 -> (u0, u0)) (ud :: u0 -> Bool) (ue :: u0 -> Bool) (uf :: u0 -> Integer) (ug :: u0 -> Int) -> _APP_ uf [ u4 ]; _NO_DEFLT_ }} in case u3 of { _ALG_ _TUP_10 (ui :: {{Eq u1}}) (uj :: {{Text u1}}) (uk :: u1 -> u1 -> u1) (ul :: u1 -> u1 -> u1) (um :: u1 -> u1 -> u1) (un :: u1 -> u1) (uo :: u1 -> u1) (up :: u1 -> u1) (uq :: Integer -> u1) (ur :: Int -> u1) -> _APP_ uq [ uh ]; _NO_DEFLT_ } _SPECIALISE_ [ Int, Double ] 2 { _A_ 1 _U_ 1 _N_ _S_ "U(P)" {_A_ 1 _U_ 2 _N_ _N_ _F_ _IF_ARGS_ 0 1 X 3 \ (u0 :: Int#) -> case _#_ int2Double# [] [u0] of { _PRIM_ (u1 :: Double#) -> _!_ D# [] [u1] } _N_} _F_ _IF_ARGS_ 0 1 C 4 \ (u0 :: Int) -> case u0 of { _ALG_ I# (u1 :: Int#) -> case _#_ int2Double# [] [u1] of { _PRIM_ (u2 :: Double#) -> _!_ D# [] [u2] }; _NO_DEFLT_ } _N_ }, [ Int, Int ] 2 { _A_ 1 _U_ 1 _N_ _N_ _F_ _IF_ARGS_ 0 0 X 1 _TYAPP_ _ORIG_ Prelude id { Int } _N_ }, [ Int, Integer ] 2 { _A_ 1 _U_ 1 _N_ _S_ "U(P)" {_A_ 1 _U_ 2 _N_ _N_ _F_ _IF_ARGS_ 0 1 X 1 \ (u0 :: Int#) -> _#_ int2Integer# [] [u0] _N_} _F_ _IF_ARGS_ 0 1 C 2 \ (u0 :: Int) -> case u0 of { _ALG_ I# (u1 :: Int#) -> _#_ int2Integer# [] [u1]; _NO_DEFLT_ } _N_ }, [ Integer, Double ] 2 { _A_ 1 _U_ 1 _N_ _S_ "U(PPP)" {_A_ 3 _U_ 222 _N_ _N_ _F_ _IF_ARGS_ 0 3 XXX 3 \ (u0 :: Int#) (u1 :: Int#) (u2 :: ByteArray#) -> case _#_ encodeDouble# [] [u0, u1, u2, 0#] of { _PRIM_ (u3 :: Double#) -> _!_ D# [] [u3] } _N_} _F_ _IF_ARGS_ 0 1 C 4 \ (u0 :: Integer) -> case u0 of { _ALG_ J# (u1 :: Int#) (u2 :: Int#) (u3 :: ByteArray#) -> case _#_ encodeDouble# [] [u1, u2, u3, 0#] of { _PRIM_ (u4 :: Double#) -> _!_ D# [] [u4] }; _NO_DEFLT_ } _N_ }, [ Integer, Int ] 2 { _A_ 1 _U_ 1 _N_ _S_ "U(PPP)" {_A_ 3 _U_ 222 _N_ _N_ _F_ _IF_ARGS_ 0 3 XXX 3 \ (u0 :: Int#) (u1 :: Int#) (u2 :: ByteArray#) -> case _#_ integer2Int# [] [u0, u1, u2] of { _PRIM_ (u3 :: Int#) -> _!_ I# [] [u3] } _N_} _F_ _IF_ARGS_ 0 1 C 4 \ (u0 :: Integer) -> case u0 of { _ALG_ J# (u1 :: Int#) (u2 :: Int#) (u3 :: ByteArray#) -> case _#_ integer2Int# [] [u1, u2, u3] of { _PRIM_ (u4 :: Int#) -> _!_ I# [] [u4] }; _NO_DEFLT_ } _N_ }, [ Integer, Integer ] 2 { _A_ 1 _U_ 1 _N_ _N_ _F_ _IF_ARGS_ 0 0 X 1 _TYAPP_ _ORIG_ Prelude id { Integer } _N_ } #-}
+ {-# GHC_PRAGMA _A_ 3 _U_ 112 _N_ _S_ "LU(AAAAAAAASA)L" {_A_ 3 _U_ 112 _N_ _N_ _F_ _IF_ARGS_ 2 3 CXX 6 _/\_ u0 u1 -> \ (u2 :: {{Integral u0}}) (u3 :: Integer -> u1) (u4 :: u0) -> let {(uh :: Integer) = case u2 of { _ALG_ _TUP_12 (u5 :: {{Real u0}}) (u6 :: {{Ix u0}}) (u7 :: u0 -> u0 -> u0) (u8 :: u0 -> u0 -> u0) (u9 :: u0 -> u0 -> u0) (ua :: u0 -> u0 -> u0) (ub :: u0 -> u0 -> (u0, u0)) (uc :: u0 -> u0 -> (u0, u0)) (ud :: u0 -> Bool) (ue :: u0 -> Bool) (uf :: u0 -> Integer) (ug :: u0 -> Int) -> _APP_ uf [ u4 ]; _NO_DEFLT_ }} in _APP_ u3 [ uh ] _N_} _F_ _IF_ARGS_ 2 3 CCX 7 _/\_ u0 u1 -> \ (u2 :: {{Integral u0}}) (u3 :: {{Num u1}}) (u4 :: u0) -> let {(uh :: Integer) = case u2 of { _ALG_ _TUP_12 (u5 :: {{Real u0}}) (u6 :: {{Ix u0}}) (u7 :: u0 -> u0 -> u0) (u8 :: u0 -> u0 -> u0) (u9 :: u0 -> u0 -> u0) (ua :: u0 -> u0 -> u0) (ub :: u0 -> u0 -> (u0, u0)) (uc :: u0 -> u0 -> (u0, u0)) (ud :: u0 -> Bool) (ue :: u0 -> Bool) (uf :: u0 -> Integer) (ug :: u0 -> Int) -> _APP_ uf [ u4 ]; _NO_DEFLT_ }} in case u3 of { _ALG_ _TUP_10 (ui :: {{Eq u1}}) (uj :: {{Text u1}}) (uk :: u1 -> u1 -> u1) (ul :: u1 -> u1 -> u1) (um :: u1 -> u1 -> u1) (un :: u1 -> u1) (uo :: u1 -> u1) (up :: u1 -> u1) (uq :: Integer -> u1) (ur :: Int -> u1) -> _APP_ uq [ uh ]; _NO_DEFLT_ } _SPECIALISE_ [ Int, Double ] 2 { _A_ 1 _U_ 1 _N_ _S_ "U(P)" {_A_ 1 _U_ 2 _N_ _N_ _F_ _IF_ARGS_ 0 1 X 3 \ (u0 :: Int#) -> case _#_ int2Double# [] [u0] of { _PRIM_ (u1 :: Double#) -> _!_ D# [] [u1] } _N_} _F_ _IF_ARGS_ 0 1 C 4 \ (u0 :: Int) -> case u0 of { _ALG_ I# (u1 :: Int#) -> case _#_ int2Double# [] [u1] of { _PRIM_ (u2 :: Double#) -> _!_ D# [] [u2] }; _NO_DEFLT_ } _N_ }, [ Int, Float ] 2 { _A_ 1 _U_ 1 _N_ _S_ "U(P)" {_A_ 1 _U_ 2 _N_ _N_ _F_ _IF_ARGS_ 0 1 X 3 \ (u0 :: Int#) -> case _#_ int2Float# [] [u0] of { _PRIM_ (u1 :: Float#) -> _!_ F# [] [u1] } _N_} _F_ _IF_ARGS_ 0 1 C 4 \ (u0 :: Int) -> case u0 of { _ALG_ I# (u1 :: Int#) -> case _#_ int2Float# [] [u1] of { _PRIM_ (u2 :: Float#) -> _!_ F# [] [u2] }; _NO_DEFLT_ } _N_ }, [ Int, Int ] 2 { _A_ 1 _U_ 1 _N_ _N_ _F_ _IF_ARGS_ 0 0 X 1 _TYAPP_ _ORIG_ Prelude id { Int } _N_ }, [ Int, Integer ] 2 { _A_ 1 _U_ 1 _N_ _S_ "U(P)" {_A_ 1 _U_ 2 _N_ _N_ _F_ _IF_ARGS_ 0 1 X 1 \ (u0 :: Int#) -> _#_ int2Integer# [] [u0] _N_} _F_ _IF_ARGS_ 0 1 C 2 \ (u0 :: Int) -> case u0 of { _ALG_ I# (u1 :: Int#) -> _#_ int2Integer# [] [u1]; _NO_DEFLT_ } _N_ }, [ Int, (Ratio Integer) ] 2 { _A_ 1 _U_ 1 _N_ _N_ _N_ _N_ }, [ Integer, Double ] 2 { _A_ 1 _U_ 1 _N_ _S_ "U(PPP)" {_A_ 3 _U_ 222 _N_ _N_ _F_ _IF_ARGS_ 0 3 XXX 3 \ (u0 :: Int#) (u1 :: Int#) (u2 :: ByteArray#) -> case _#_ encodeDouble# [] [u0, u1, u2, 0#] of { _PRIM_ (u3 :: Double#) -> _!_ D# [] [u3] } _N_} _F_ _IF_ARGS_ 0 1 C 4 \ (u0 :: Integer) -> case u0 of { _ALG_ J# (u1 :: Int#) (u2 :: Int#) (u3 :: ByteArray#) -> case _#_ encodeDouble# [] [u1, u2, u3, 0#] of { _PRIM_ (u4 :: Double#) -> _!_ D# [] [u4] }; _NO_DEFLT_ } _N_ }, [ Integer, Float ] 2 { _A_ 1 _U_ 1 _N_ _S_ "U(PPP)" {_A_ 3 _U_ 222 _N_ _N_ _F_ _IF_ARGS_ 0 3 XXX 3 \ (u0 :: Int#) (u1 :: Int#) (u2 :: ByteArray#) -> case _#_ encodeFloat# [] [u0, u1, u2, 0#] of { _PRIM_ (u3 :: Float#) -> _!_ F# [] [u3] } _N_} _F_ _IF_ARGS_ 0 1 C 4 \ (u0 :: Integer) -> case u0 of { _ALG_ J# (u1 :: Int#) (u2 :: Int#) (u3 :: ByteArray#) -> case _#_ encodeFloat# [] [u1, u2, u3, 0#] of { _PRIM_ (u4 :: Float#) -> _!_ F# [] [u4] }; _NO_DEFLT_ } _N_ }, [ Integer, Int ] 2 { _A_ 1 _U_ 1 _N_ _S_ "U(PPP)" {_A_ 3 _U_ 222 _N_ _N_ _F_ _IF_ARGS_ 0 3 XXX 3 \ (u0 :: Int#) (u1 :: Int#) (u2 :: ByteArray#) -> case _#_ integer2Int# [] [u0, u1, u2] of { _PRIM_ (u3 :: Int#) -> _!_ I# [] [u3] } _N_} _F_ _IF_ARGS_ 0 1 C 4 \ (u0 :: Integer) -> case u0 of { _ALG_ J# (u1 :: Int#) (u2 :: Int#) (u3 :: ByteArray#) -> case _#_ integer2Int# [] [u1, u2, u3] of { _PRIM_ (u4 :: Int#) -> _!_ I# [] [u4] }; _NO_DEFLT_ } _N_ }, [ Integer, Integer ] 2 { _A_ 1 _U_ 1 _N_ _N_ _F_ _IF_ARGS_ 0 0 X 1 _TYAPP_ _ORIG_ Prelude id { Integer } _N_ }, [ Integer, (Ratio Integer) ] 2 { _A_ 1 _U_ 2 _N_ _N_ _F_ _IF_ARGS_ 0 1 X 3 \ (u0 :: Integer) -> _!_ (:%) [Integer] [u0, _SPEC_ _ORIG_ PreludeCore __i1 [ (Integer) ]] _N_ } #-}
fromRealFrac :: (RealFrac a, Fractional b) => a -> b
- {-# GHC_PRAGMA _A_ 3 _U_ 112 _N_ _S_ "LU(AAAS)L" {_A_ 3 _U_ 112 _N_ _N_ _F_ _IF_ARGS_ 2 3 CXX 7 _/\_ u0 u1 -> \ (u2 :: {{RealFrac u0}}) (u3 :: Ratio Integer -> u1) (u4 :: u0) -> let {(uf :: Ratio Integer) = case u2 of { _ALG_ _TUP_7 (u5 :: {{Real u0}}) (u6 :: {{Fractional u0}}) (u7 :: _forall_ a$z1 =>{{Integral a$z1}} -> u0 -> (a$z1, u0)) (u8 :: _forall_ a$z1 =>{{Integral a$z1}} -> u0 -> a$z1) (u9 :: _forall_ a$z1 =>{{Integral a$z1}} -> u0 -> a$z1) (ua :: _forall_ a$z1 =>{{Integral a$z1}} -> u0 -> a$z1) (ub :: _forall_ a$z1 =>{{Integral a$z1}} -> u0 -> a$z1) -> case u5 of { _ALG_ _TUP_3 (uc :: {{Num u0}}) (ud :: {{Enum u0}}) (ue :: u0 -> Ratio Integer) -> _APP_ ue [ u4 ]; _NO_DEFLT_ }; _NO_DEFLT_ }} in _APP_ u3 [ uf ] _N_} _F_ _IF_ARGS_ 2 3 CCX 8 _/\_ u0 u1 -> \ (u2 :: {{RealFrac u0}}) (u3 :: {{Fractional u1}}) (u4 :: u0) -> let {(uf :: Ratio Integer) = case u2 of { _ALG_ _TUP_7 (u5 :: {{Real u0}}) (u6 :: {{Fractional u0}}) (u7 :: _forall_ a$z1 =>{{Integral a$z1}} -> u0 -> (a$z1, u0)) (u8 :: _forall_ a$z1 =>{{Integral a$z1}} -> u0 -> a$z1) (u9 :: _forall_ a$z1 =>{{Integral a$z1}} -> u0 -> a$z1) (ua :: _forall_ a$z1 =>{{Integral a$z1}} -> u0 -> a$z1) (ub :: _forall_ a$z1 =>{{Integral a$z1}} -> u0 -> a$z1) -> case u5 of { _ALG_ _TUP_3 (uc :: {{Num u0}}) (ud :: {{Enum u0}}) (ue :: u0 -> Ratio Integer) -> _APP_ ue [ u4 ]; _NO_DEFLT_ }; _NO_DEFLT_ }} in case u3 of { _ALG_ _TUP_4 (ug :: {{Num u1}}) (uh :: u1 -> u1 -> u1) (ui :: u1 -> u1) (uj :: Ratio Integer -> u1) -> _APP_ uj [ uf ]; _NO_DEFLT_ } _SPECIALISE_ [ Double, Double ] 2 { _A_ 1 _U_ 1 _N_ _N_ _F_ _IF_ARGS_ 0 0 X 1 _TYAPP_ _ORIG_ Prelude id { Double } _N_ }, [ Double, Float ] 2 { _A_ 1 _U_ 1 _N_ _S_ "U(P)" {_A_ 1 _U_ 2 _N_ _N_ _F_ _IF_ARGS_ 0 1 X 3 \ (u0 :: Double#) -> case _#_ double2Float# [] [u0] of { _PRIM_ (u1 :: Float#) -> _!_ F# [] [u1] } _N_} _F_ _IF_ARGS_ 0 1 C 4 \ (u0 :: Double) -> case u0 of { _ALG_ D# (u1 :: Double#) -> case _#_ double2Float# [] [u1] of { _PRIM_ (u2 :: Float#) -> _!_ F# [] [u2] }; _NO_DEFLT_ } _N_ }, [ Float, Double ] 2 { _A_ 1 _U_ 1 _N_ _S_ "U(P)" {_A_ 1 _U_ 2 _N_ _N_ _F_ _IF_ARGS_ 0 1 X 3 \ (u0 :: Float#) -> case _#_ float2Double# [] [u0] of { _PRIM_ (u1 :: Double#) -> _!_ D# [] [u1] } _N_} _F_ _IF_ARGS_ 0 1 C 4 \ (u0 :: Float) -> case u0 of { _ALG_ F# (u1 :: Float#) -> case _#_ float2Double# [] [u1] of { _PRIM_ (u2 :: Double#) -> _!_ D# [] [u2] }; _NO_DEFLT_ } _N_ }, [ Float, Float ] 2 { _A_ 1 _U_ 1 _N_ _N_ _F_ _IF_ARGS_ 0 0 X 1 _TYAPP_ _ORIG_ Prelude id { Float } _N_ } #-}
+ {-# GHC_PRAGMA _A_ 3 _U_ 112 _N_ _S_ "LU(AAAS)L" {_A_ 3 _U_ 112 _N_ _N_ _F_ _IF_ARGS_ 2 3 CXX 7 _/\_ u0 u1 -> \ (u2 :: {{RealFrac u0}}) (u3 :: Ratio Integer -> u1) (u4 :: u0) -> let {(uf :: Ratio Integer) = case u2 of { _ALG_ _TUP_7 (u5 :: {{Real u0}}) (u6 :: {{Fractional u0}}) (u7 :: _forall_ a$z1 =>{{Integral a$z1}} -> u0 -> (a$z1, u0)) (u8 :: _forall_ a$z1 =>{{Integral a$z1}} -> u0 -> a$z1) (u9 :: _forall_ a$z1 =>{{Integral a$z1}} -> u0 -> a$z1) (ua :: _forall_ a$z1 =>{{Integral a$z1}} -> u0 -> a$z1) (ub :: _forall_ a$z1 =>{{Integral a$z1}} -> u0 -> a$z1) -> case u5 of { _ALG_ _TUP_3 (uc :: {{Num u0}}) (ud :: {{Enum u0}}) (ue :: u0 -> Ratio Integer) -> _APP_ ue [ u4 ]; _NO_DEFLT_ }; _NO_DEFLT_ }} in _APP_ u3 [ uf ] _N_} _F_ _IF_ARGS_ 2 3 CCX 8 _/\_ u0 u1 -> \ (u2 :: {{RealFrac u0}}) (u3 :: {{Fractional u1}}) (u4 :: u0) -> let {(uf :: Ratio Integer) = case u2 of { _ALG_ _TUP_7 (u5 :: {{Real u0}}) (u6 :: {{Fractional u0}}) (u7 :: _forall_ a$z1 =>{{Integral a$z1}} -> u0 -> (a$z1, u0)) (u8 :: _forall_ a$z1 =>{{Integral a$z1}} -> u0 -> a$z1) (u9 :: _forall_ a$z1 =>{{Integral a$z1}} -> u0 -> a$z1) (ua :: _forall_ a$z1 =>{{Integral a$z1}} -> u0 -> a$z1) (ub :: _forall_ a$z1 =>{{Integral a$z1}} -> u0 -> a$z1) -> case u5 of { _ALG_ _TUP_3 (uc :: {{Num u0}}) (ud :: {{Enum u0}}) (ue :: u0 -> Ratio Integer) -> _APP_ ue [ u4 ]; _NO_DEFLT_ }; _NO_DEFLT_ }} in case u3 of { _ALG_ _TUP_4 (ug :: {{Num u1}}) (uh :: u1 -> u1 -> u1) (ui :: u1 -> u1) (uj :: Ratio Integer -> u1) -> _APP_ uj [ uf ]; _NO_DEFLT_ } _SPECIALISE_ [ Double, Double ] 2 { _A_ 1 _U_ 1 _N_ _N_ _F_ _IF_ARGS_ 0 0 X 1 _TYAPP_ _ORIG_ Prelude id { Double } _N_ }, [ Double, Float ] 2 { _A_ 1 _U_ 1 _N_ _S_ "U(P)" {_A_ 1 _U_ 2 _N_ _N_ _F_ _IF_ARGS_ 0 1 X 3 \ (u0 :: Double#) -> case _#_ double2Float# [] [u0] of { _PRIM_ (u1 :: Float#) -> _!_ F# [] [u1] } _N_} _F_ _IF_ARGS_ 0 1 C 4 \ (u0 :: Double) -> case u0 of { _ALG_ D# (u1 :: Double#) -> case _#_ double2Float# [] [u1] of { _PRIM_ (u2 :: Float#) -> _!_ F# [] [u2] }; _NO_DEFLT_ } _N_ }, [ Double, (Ratio Integer) ] 2 { _A_ 1 _U_ 1 _N_ _S_ "U(P)" {_A_ 1 _U_ 2 _N_ _N_ _N_ _N_} _N_ _N_ }, [ Float, Double ] 2 { _A_ 1 _U_ 1 _N_ _S_ "U(P)" {_A_ 1 _U_ 2 _N_ _N_ _F_ _IF_ARGS_ 0 1 X 3 \ (u0 :: Float#) -> case _#_ float2Double# [] [u0] of { _PRIM_ (u1 :: Double#) -> _!_ D# [] [u1] } _N_} _F_ _IF_ARGS_ 0 1 C 4 \ (u0 :: Float) -> case u0 of { _ALG_ F# (u1 :: Float#) -> case _#_ float2Double# [] [u1] of { _PRIM_ (u2 :: Double#) -> _!_ D# [] [u2] }; _NO_DEFLT_ } _N_ }, [ Float, Float ] 2 { _A_ 1 _U_ 1 _N_ _N_ _F_ _IF_ARGS_ 0 0 X 1 _TYAPP_ _ORIG_ Prelude id { Float } _N_ }, [ Float, (Ratio Integer) ] 2 { _A_ 1 _U_ 1 _N_ _S_ "U(P)" {_A_ 1 _U_ 2 _N_ _N_ _N_ _N_} _N_ _N_ }, [ (Ratio Integer), Double ] 2 { _A_ 1 _U_ 1 _N_ _S_ "U(U(PPP)U(PPP))" {_A_ 4 _U_ 2222 _N_ _N_ _N_ _N_} _N_ _N_ }, [ (Ratio Integer), Float ] 2 { _A_ 1 _U_ 2 _N_ _N_ _F_ _IF_ARGS_ 0 0 X 1 _CONSTM_ Fractional fromRational (Float) _N_ }, [ (Ratio Integer), (Ratio Integer) ] 2 { _A_ 1 _U_ 1 _N_ _N_ _F_ _IF_ARGS_ 0 0 X 1 _TYAPP_ _ORIG_ Prelude id { (Ratio Integer) } _N_ } #-}
fst :: (b, a) -> b
{-# GHC_PRAGMA _A_ 1 _U_ 1 _N_ _S_ "U(SA)" {_A_ 1 _U_ 1 _N_ _N_ _F_ _IF_ARGS_ 2 1 X 1 _/\_ u0 u1 -> \ (u2 :: u1) -> u2 _N_} _F_ _IF_ARGS_ 2 1 C 2 _/\_ u0 u1 -> \ (u2 :: (u1, u0)) -> case u2 of { _ALG_ _TUP_2 (u3 :: u1) (u4 :: u0) -> u3; _NO_DEFLT_ } _N_ #-}
gcd :: Integral a => a -> a -> a
{-# GHC_PRAGMA _A_ 1 _U_ 1 _N_ _S_ "S" _F_ _IF_ARGS_ 1 1 X 1 _/\_ u0 -> \ (u1 :: u0) -> u1 _N_ #-}
isAlpha :: Char -> Bool
{-# GHC_PRAGMA _A_ 1 _U_ 1 _N_ _S_ "U(P)" {_A_ 1 _U_ 2 _N_ _N_ _N_ _N_} _N_ _N_ #-}
+isAlpha# :: Char# -> Bool
+ {-# GHC_PRAGMA _A_ 1 _U_ 2 _N_ _S_ "P" _N_ _N_ #-}
isAlphanum :: Char -> Bool
{-# GHC_PRAGMA _A_ 1 _U_ 1 _N_ _S_ "U(P)" {_A_ 1 _U_ 2 _N_ _N_ _N_ _N_} _N_ _N_ #-}
+isAlphanum# :: Char# -> Bool
+ {-# GHC_PRAGMA _A_ 1 _U_ 2 _N_ _S_ "P" _N_ _N_ #-}
isAscii :: Char -> Bool
{-# GHC_PRAGMA _A_ 1 _U_ 1 _N_ _S_ "U(P)" {_A_ 1 _U_ 2 _N_ _N_ _F_ _IF_ARGS_ 0 1 X 2 \ (u0 :: Char#) -> case _#_ ord# [] [u0] of { _PRIM_ (u1 :: Int#) -> _#_ ltInt# [] [u1, 128#] } _N_} _F_ _IF_ARGS_ 0 1 C 3 \ (u0 :: Char) -> case u0 of { _ALG_ C# (u1 :: Char#) -> case _#_ ord# [] [u1] of { _PRIM_ (u2 :: Int#) -> _#_ ltInt# [] [u2, 128#] }; _NO_DEFLT_ } _N_ #-}
+isAscii# :: Char# -> Bool
+ {-# GHC_PRAGMA _A_ 1 _U_ 2 _N_ _S_ "P" _F_ _IF_ARGS_ 0 1 X 2 \ (u0 :: Char#) -> case _#_ ord# [] [u0] of { _PRIM_ (u1 :: Int#) -> _#_ ltInt# [] [u1, 128#] } _N_ #-}
isControl :: Char -> Bool
{-# GHC_PRAGMA _A_ 1 _U_ 1 _N_ _S_ "U(P)" {_A_ 1 _U_ 2 _N_ _N_ _N_ _N_} _N_ _N_ #-}
+isControl# :: Char# -> Bool
+ {-# GHC_PRAGMA _A_ 1 _U_ 2 _N_ _S_ "P" _N_ _N_ #-}
isDigit :: Char -> Bool
{-# GHC_PRAGMA _A_ 1 _U_ 1 _N_ _S_ "U(P)" {_A_ 1 _U_ 2 _N_ _N_ _N_ _N_} _N_ _N_ #-}
+isDigit# :: Char# -> Bool
+ {-# GHC_PRAGMA _A_ 1 _U_ 2 _N_ _S_ "P" _N_ _N_ #-}
isLower :: Char -> Bool
{-# GHC_PRAGMA _A_ 1 _U_ 1 _N_ _S_ "U(P)" {_A_ 1 _U_ 2 _N_ _N_ _N_ _N_} _N_ _N_ #-}
+isLower# :: Char# -> Bool
+ {-# GHC_PRAGMA _A_ 1 _U_ 2 _N_ _S_ "P" _N_ _N_ #-}
isNullBin :: Bin -> Bool
- {-# GHC_PRAGMA _A_ 1 _U_ 2 _N_ _S_ _!_ _F_ _IF_ARGS_ 0 1 X 3 \ (u0 :: Bin) -> _APP_ _TYAPP_ error { (Bin -> Bool) } [ _NOREP_S_ "isNullBin{Prelude}\n", u0 ] _N_ #-}
+ {-# GHC_PRAGMA _A_ 1 _U_ 2 _N_ _S_ _!_ _N_ _N_ #-}
isPrint :: Char -> Bool
{-# GHC_PRAGMA _A_ 1 _U_ 1 _N_ _S_ "U(P)" {_A_ 1 _U_ 2 _N_ _N_ _N_ _N_} _N_ _N_ #-}
+isPrint# :: Char# -> Bool
+ {-# GHC_PRAGMA _A_ 1 _U_ 2 _N_ _S_ "P" _N_ _N_ #-}
isSpace :: Char -> Bool
{-# GHC_PRAGMA _A_ 1 _U_ 1 _N_ _S_ "U(P)" {_A_ 1 _U_ 1 _N_ _N_ _N_ _N_} _N_ _N_ #-}
+isSpace# :: Char# -> Bool
+ {-# GHC_PRAGMA _A_ 1 _U_ 1 _N_ _S_ "P" _N_ _N_ #-}
isUpper :: Char -> Bool
{-# GHC_PRAGMA _A_ 1 _U_ 1 _N_ _S_ "U(P)" {_A_ 1 _U_ 2 _N_ _N_ _N_ _N_} _N_ _N_ #-}
+isUpper# :: Char# -> Bool
+ {-# GHC_PRAGMA _A_ 1 _U_ 2 _N_ _S_ "P" _N_ _N_ #-}
lcm :: Integral a => a -> a -> a
{-# GHC_PRAGMA _A_ 1 _U_ 122 _N_ _S_ "U(U(U(U(SA)AAALALAAL)AA)ALLAAAAAAAA)" {_A_ 3 _U_ 12222 _N_ _N_ _N_ _N_} _N_ _SPECIALISE_ [ Int ] 1 { _A_ 2 _U_ 11 _N_ _S_ "LU(P)" {_A_ 2 _U_ 12 _N_ _N_ _N_ _N_} _N_ _N_ }, [ Integer ] 1 { _A_ 2 _U_ 11 _N_ _S_ "LU(PPP)" {_A_ 4 _U_ 1222 _N_ _N_ _N_ _N_} _N_ _N_ } #-}
maxChar :: Char
{-# GHC_PRAGMA _A_ 0 _N_ _N_ _N_ _F_ _IF_ARGS_ 0 0 X 2 _!_ C# [] ['\o377'#] _N_ #-}
+maxChar# :: Char#
+ {-# GHC_PRAGMA _A_ 0 _N_ _N_ _N_ _F_ _IF_ARGS_ 0 0 X 2 _!_ _Lift [Char#] ['\o377'#] _N_ #-}
maxInt :: Int
{-# GHC_PRAGMA _A_ 0 _N_ _N_ _N_ _F_ _IF_ARGS_ 0 0 X 2 _!_ I# [] [2147483647#] _N_ #-}
+maxInt# :: Int#
+ {-# GHC_PRAGMA _A_ 0 _N_ _N_ _N_ _F_ _IF_ARGS_ 0 0 X 2 _!_ _Lift [Int#] [2147483647#] _N_ #-}
minChar :: Char
{-# GHC_PRAGMA _A_ 0 _N_ _N_ _N_ _F_ _IF_ARGS_ 0 0 X 2 _!_ C# [] ['\o0'#] _N_ #-}
+minChar# :: Char#
+ {-# GHC_PRAGMA _A_ 0 _N_ _N_ _N_ _F_ _IF_ARGS_ 0 0 X 2 _!_ _Lift [Char#] ['\o0'#] _N_ #-}
minInt :: Int
{-# GHC_PRAGMA _A_ 0 _N_ _N_ _N_ _F_ _IF_ARGS_ 0 0 X 2 _!_ I# [] [-2147483647#] _N_ #-}
+minInt# :: Int#
+ {-# GHC_PRAGMA _A_ 0 _N_ _N_ _N_ _F_ _IF_ARGS_ 0 0 X 2 _!_ _Lift [Int#] [-2147483647#] _N_ #-}
not :: Bool -> Bool
{-# GHC_PRAGMA _A_ 1 _U_ 1 _N_ _S_ "E" _F_ _ALWAYS_ \ (u0 :: Bool) -> case u0 of { _ALG_ True -> _!_ False [] []; False -> _!_ True [] []; _NO_DEFLT_ } _N_ #-}
nullBin :: Bin
- {-# GHC_PRAGMA _A_ 0 _N_ _N_ _S_ _!_ _F_ _IF_ARGS_ 0 0 X 2 _APP_ _TYAPP_ error { Bin } [ _NOREP_S_ "nullBin{Prelude}\n" ] _N_ #-}
+ {-# GHC_PRAGMA _A_ 0 _N_ _N_ _S_ _!_ _N_ _N_ #-}
ord :: Char -> Int
{-# GHC_PRAGMA _A_ 1 _U_ 1 _N_ _S_ "U(P)" {_A_ 1 _U_ 2 _N_ _N_ _F_ _IF_ARGS_ 0 1 X 3 \ (u0 :: Char#) -> case _#_ ord# [] [u0] of { _PRIM_ (u1 :: Int#) -> _!_ I# [] [u1] } _N_} _F_ _IF_ARGS_ 0 1 C 4 \ (u0 :: Char) -> case u0 of { _ALG_ C# (u1 :: Char#) -> case _#_ ord# [] [u1] of { _PRIM_ (u2 :: Int#) -> _!_ I# [] [u2] }; _NO_DEFLT_ } _N_ #-}
otherwise :: Bool
snd :: (a, b) -> b
{-# GHC_PRAGMA _A_ 1 _U_ 1 _N_ _S_ "U(AS)" {_A_ 1 _U_ 1 _N_ _N_ _F_ _IF_ARGS_ 2 1 X 1 _/\_ u0 u1 -> \ (u2 :: u1) -> u2 _N_} _F_ _IF_ARGS_ 2 1 C 2 _/\_ u0 u1 -> \ (u2 :: (u0, u1)) -> case u2 of { _ALG_ _TUP_2 (u3 :: u0) (u4 :: u1) -> u4; _NO_DEFLT_ } _N_ #-}
subtract :: Num a => a -> a -> a
- {-# GHC_PRAGMA _A_ 3 _U_ 122 _N_ _S_ "U(AAASAAAAAA)LL" {_A_ 3 _U_ 122 _N_ _N_ _F_ _IF_ARGS_ 1 3 XXX 3 _/\_ u0 -> \ (u1 :: u0 -> u0 -> u0) (u2 :: u0) (u3 :: u0) -> _APP_ u1 [ u3, u2 ] _N_} _F_ _IF_ARGS_ 1 3 CXX 4 _/\_ u0 -> \ (u1 :: {{Num u0}}) (u2 :: u0) (u3 :: u0) -> case u1 of { _ALG_ _TUP_10 (u4 :: {{Eq u0}}) (u5 :: {{Text u0}}) (u6 :: u0 -> u0 -> u0) (u7 :: u0 -> u0 -> u0) (u8 :: u0 -> u0 -> u0) (u9 :: u0 -> u0) (ua :: u0 -> u0) (ub :: u0 -> u0) (uc :: Integer -> u0) (ud :: Int -> u0) -> _APP_ u7 [ u3, u2 ]; _NO_DEFLT_ } _SPECIALISE_ [ Double ] 1 { _A_ 2 _U_ 11 _N_ _S_ "U(P)U(P)" {_A_ 2 _U_ 22 _N_ _N_ _F_ _IF_ARGS_ 0 2 XX 3 \ (u0 :: Double#) (u1 :: Double#) -> case _#_ minusDouble# [] [u1, u0] of { _PRIM_ (u2 :: Double#) -> _!_ D# [] [u2] } _N_} _F_ _IF_ARGS_ 0 2 CC 5 \ (u0 :: Double) (u1 :: Double) -> case u1 of { _ALG_ D# (u2 :: Double#) -> case u0 of { _ALG_ D# (u3 :: Double#) -> case _#_ minusDouble# [] [u2, u3] of { _PRIM_ (u4 :: Double#) -> _!_ D# [] [u4] }; _NO_DEFLT_ }; _NO_DEFLT_ } _N_ }, [ Int ] 1 { _A_ 2 _U_ 11 _N_ _S_ "U(P)U(P)" {_A_ 2 _U_ 22 _N_ _N_ _F_ _IF_ARGS_ 0 2 XX 3 \ (u0 :: Int#) (u1 :: Int#) -> case _#_ minusInt# [] [u1, u0] of { _PRIM_ (u2 :: Int#) -> _!_ I# [] [u2] } _N_} _F_ _IF_ARGS_ 0 2 CC 5 \ (u0 :: Int) (u1 :: Int) -> case u1 of { _ALG_ I# (u2 :: Int#) -> case u0 of { _ALG_ I# (u3 :: Int#) -> case _#_ minusInt# [] [u2, u3] of { _PRIM_ (u4 :: Int#) -> _!_ I# [] [u4] }; _NO_DEFLT_ }; _NO_DEFLT_ } _N_ } #-}
+ {-# GHC_PRAGMA _A_ 3 _U_ 122 _N_ _S_ "U(AAASAAAAAA)LL" {_A_ 3 _U_ 122 _N_ _N_ _F_ _IF_ARGS_ 1 3 XXX 3 _/\_ u0 -> \ (u1 :: u0 -> u0 -> u0) (u2 :: u0) (u3 :: u0) -> _APP_ u1 [ u3, u2 ] _N_} _F_ _IF_ARGS_ 1 3 CXX 4 _/\_ u0 -> \ (u1 :: {{Num u0}}) (u2 :: u0) (u3 :: u0) -> case u1 of { _ALG_ _TUP_10 (u4 :: {{Eq u0}}) (u5 :: {{Text u0}}) (u6 :: u0 -> u0 -> u0) (u7 :: u0 -> u0 -> u0) (u8 :: u0 -> u0 -> u0) (u9 :: u0 -> u0) (ua :: u0 -> u0) (ub :: u0 -> u0) (uc :: Integer -> u0) (ud :: Int -> u0) -> _APP_ u7 [ u3, u2 ]; _NO_DEFLT_ } _SPECIALISE_ [ Double ] 1 { _A_ 2 _U_ 11 _N_ _S_ "U(P)U(P)" {_A_ 2 _U_ 22 _N_ _N_ _F_ _IF_ARGS_ 0 2 XX 3 \ (u0 :: Double#) (u1 :: Double#) -> case _#_ minusDouble# [] [u1, u0] of { _PRIM_ (u2 :: Double#) -> _!_ D# [] [u2] } _N_} _F_ _IF_ARGS_ 0 2 CC 5 \ (u0 :: Double) (u1 :: Double) -> case u1 of { _ALG_ D# (u2 :: Double#) -> case u0 of { _ALG_ D# (u3 :: Double#) -> case _#_ minusDouble# [] [u2, u3] of { _PRIM_ (u4 :: Double#) -> _!_ D# [] [u4] }; _NO_DEFLT_ }; _NO_DEFLT_ } _N_ }, [ Int ] 1 { _A_ 2 _U_ 11 _N_ _S_ "U(P)U(P)" {_A_ 2 _U_ 22 _N_ _N_ _F_ _IF_ARGS_ 0 2 XX 3 \ (u0 :: Int#) (u1 :: Int#) -> case _#_ minusInt# [] [u1, u0] of { _PRIM_ (u2 :: Int#) -> _!_ I# [] [u2] } _N_} _F_ _IF_ARGS_ 0 2 CC 5 \ (u0 :: Int) (u1 :: Int) -> case u1 of { _ALG_ I# (u2 :: Int#) -> case u0 of { _ALG_ I# (u3 :: Int#) -> case _#_ minusInt# [] [u2, u3] of { _PRIM_ (u4 :: Int#) -> _!_ I# [] [u4] }; _NO_DEFLT_ }; _NO_DEFLT_ } _N_ }, [ (Complex Double) ] 1 { _A_ 2 _U_ 11 _N_ _S_ "U(LL)U(LL)" {_A_ 4 _U_ 2222 _N_ _N_ _N_ _N_} _N_ _N_ } #-}
+toChar# :: Char -> Char#
+ {-# GHC_PRAGMA _A_ 1 _U_ 1 _N_ _S_ "U(P)" {_A_ 1 _U_ 1 _N_ _N_ _F_ _IF_ARGS_ 0 1 X 1 \ (u0 :: Char#) -> u0 _N_} _F_ _IF_ARGS_ 0 1 C 2 \ (u0 :: Char) -> case u0 of { _ALG_ C# (u1 :: Char#) -> u1; _NO_DEFLT_ } _N_ #-}
+toInt# :: Int -> Int#
+ {-# GHC_PRAGMA _A_ 1 _U_ 1 _N_ _S_ "U(P)" {_A_ 1 _U_ 1 _N_ _N_ _F_ _IF_ARGS_ 0 1 X 1 \ (u0 :: Int#) -> u0 _N_} _F_ _IF_ARGS_ 0 1 C 2 \ (u0 :: Int) -> case u0 of { _ALG_ I# (u1 :: Int#) -> u1; _NO_DEFLT_ } _N_ #-}
toLower :: Char -> Char
{-# GHC_PRAGMA _A_ 1 _U_ 1 _N_ _S_ "U(P)" {_A_ 1 _U_ 2 _N_ _N_ _N_ _N_} _N_ _N_ #-}
+toLower# :: Char# -> Char#
+ {-# GHC_PRAGMA _A_ 1 _U_ 2 _N_ _S_ "P" _N_ _N_ #-}
toUpper :: Char -> Char
{-# GHC_PRAGMA _A_ 1 _U_ 1 _N_ _S_ "U(P)" {_A_ 1 _U_ 2 _N_ _N_ _N_ _N_} _N_ _N_ #-}
+toUpper# :: Char# -> Char#
+ {-# GHC_PRAGMA _A_ 1 _U_ 2 _N_ _S_ "P" _N_ _N_ #-}
until :: (a -> Bool) -> (a -> a) -> a -> a
{-# GHC_PRAGMA _A_ 3 _U_ 222 _N_ _S_ "SLL" _N_ _N_ #-}
(||) :: Bool -> Bool -> Bool
-{-# GHC_PRAGMA INTERFACE VERSION 5 #-}
+{-# GHC_PRAGMA INTERFACE VERSION 6 #-}
interface Prelude where
import PreludeBuiltin(Bin, Char(..), Int(..), Tuple2)
import PreludeCore(Bool(..), Fractional(..), Integral(..), Num(..), RealFloat(..), RealFrac(..))
(.) :: (a -> c) -> (b -> a) -> b -> c
{-# GHC_PRAGMA _A_ 3 _U_ 112 _N_ _S_ "SLL" _F_ _ALWAYS_ _/\_ u0 u1 u2 -> \ (u3 :: u0 -> u2) (u4 :: u1 -> u0) (u5 :: u1) -> let {(u6 :: u0) = _APP_ u4 [ u5 ]} in _APP_ u3 [ u6 ] _N_ #-}
(^) :: (Num b, Integral a) => b -> a -> b
- {-# GHC_PRAGMA _A_ 2 _U_ 2122 _N_ _S_ "LU(U(LU(U(U(SA)AALAAAA)AAAA)A)AAALAAAALAA)" {_A_ 5 _U_ 2212222 _N_ _N_ _N_ _N_} _N_ _SPECIALISE_ [ Int, Double ] 2 { _A_ 2 _U_ 21 _N_ _S_ "LU(P)" {_A_ 2 _U_ 22 _N_ _N_ _N_ _N_} _N_ _N_ }, [ Int, Int ] 2 { _A_ 2 _U_ 21 _N_ _S_ "LU(P)" {_A_ 2 _U_ 22 _N_ _N_ _N_ _N_} _N_ _N_ }, [ Int, Integer ] 2 { _A_ 2 _U_ 21 _N_ _S_ "LU(P)" {_A_ 2 _U_ 22 _N_ _N_ _N_ _N_} _N_ _N_ }, [ Int, (Ratio Integer) ] 2 { _A_ 2 _U_ 21 _N_ _S_ "LU(P)" {_A_ 2 _U_ 22 _N_ _N_ _N_ _N_} _N_ _N_ }, [ Int, (Complex Double) ] 2 { _A_ 2 _U_ 21 _N_ _S_ "LU(P)" {_A_ 2 _U_ 22 _N_ _N_ _N_ _N_} _N_ _N_ } #-}
+ {-# GHC_PRAGMA _A_ 2 _U_ 2222 _N_ _S_ "LU(U(LU(U(U(SL)LLLLLLL)LLLL)L)LLLLLLLLLLL)" _N_ _SPECIALISE_ [ Int, Double ] 2 { _A_ 2 _U_ 21 _N_ _S_ "LU(P)" {_A_ 2 _U_ 22 _N_ _N_ _N_ _N_} _N_ _N_ }, [ Int, Int ] 2 { _A_ 2 _U_ 21 _N_ _S_ "LU(P)" {_A_ 2 _U_ 22 _N_ _N_ _N_ _N_} _N_ _N_ }, [ Int, Integer ] 2 { _A_ 2 _U_ 21 _N_ _S_ "LU(P)" {_A_ 2 _U_ 22 _N_ _N_ _N_ _N_} _N_ _N_ }, [ Int, (Ratio Integer) ] 2 { _A_ 2 _U_ 21 _N_ _S_ "LU(P)" {_A_ 2 _U_ 22 _N_ _N_ _N_ _N_} _N_ _N_ }, [ Int, (Complex Double) ] 2 { _A_ 2 _U_ 21 _N_ _S_ "LU(P)" {_A_ 2 _U_ 22 _N_ _N_ _N_ _N_} _N_ _N_ }, [ Integer, Integer ] 2 { _A_ 2 _U_ 21 _N_ _S_ "LU(PPP)" {_A_ 4 _U_ 2222 _N_ _N_ _N_ _N_} _N_ _N_ } #-}
(^^) :: (Fractional b, Integral a) => b -> a -> b
- {-# GHC_PRAGMA _A_ 2 _U_ 2122 _N_ _S_ "LU(LU(U(AAASAAAA)AAA)AALAAAALAA)" {_A_ 5 _U_ 2212222 _N_ _N_ _N_ _N_} _N_ _SPECIALISE_ [ Int, Double ] 2 { _A_ 2 _U_ 21 _N_ _S_ "LU(P)" {_A_ 2 _U_ 22 _N_ _N_ _N_ _N_} _N_ _N_ }, [ Int, (Ratio Integer) ] 2 { _A_ 2 _U_ 21 _N_ _S_ "LU(P)" {_A_ 2 _U_ 22 _N_ _N_ _N_ _N_} _N_ _N_ } #-}
+ {-# GHC_PRAGMA _A_ 2 _U_ 2222 _N_ _S_ "LU(LU(U(LLLSLLLL)LLL)LLLLLLLLLL)" _N_ _SPECIALISE_ [ Int, Double ] 2 { _A_ 2 _U_ 21 _N_ _S_ "LU(P)" {_A_ 2 _U_ 22 _N_ _N_ _N_ _N_} _N_ _N_ }, [ Int, (Ratio Integer) ] 2 { _A_ 2 _U_ 21 _N_ _S_ "LU(P)" {_A_ 2 _U_ 22 _N_ _N_ _N_ _N_} _N_ _N_ }, [ Int, (Complex Double) ] 2 { _A_ 2 _U_ 21 _N_ _S_ "LU(P)" {_A_ 2 _U_ 22 _N_ _N_ _N_ _N_} _N_ _N_ } #-}
appendBin :: Bin -> Bin -> Bin
- {-# GHC_PRAGMA _A_ 2 _U_ 22 _N_ _S_ _!_ _F_ _IF_ARGS_ 0 2 XX 4 \ (u0 :: Bin) (u1 :: Bin) -> _APP_ _TYAPP_ error { (Bin -> Bin -> Bin) } [ _NOREP_S_ "appendBin{Prelude}\n", u0, u1 ] _N_ #-}
+ {-# GHC_PRAGMA _A_ 2 _U_ 22 _N_ _S_ _!_ _N_ _N_ #-}
asTypeOf :: a -> a -> a
{-# GHC_PRAGMA _A_ 2 _U_ 10 _N_ _N_ _F_ _IF_ARGS_ 1 0 X 1 _/\_ u0 -> _TYAPP_ _TYAPP_ _ORIG_ Prelude const { u0 } { u0 } _N_ #-}
atan2 :: RealFloat a => a -> a -> a
{-# GHC_PRAGMA _A_ 2 _U_ 10 _N_ _S_ "SA" {_A_ 1 _U_ 1 _N_ _N_ _F_ _IF_ARGS_ 2 1 X 1 _/\_ u0 u1 -> \ (u2 :: u1) -> u2 _N_} _F_ _IF_ARGS_ 2 2 XX 1 _/\_ u0 u1 -> \ (u2 :: u1) (u3 :: u0) -> u2 _N_ #-}
flip :: (b -> a -> c) -> a -> b -> c
{-# GHC_PRAGMA _A_ 3 _U_ 122 _N_ _S_ "SLL" _F_ _IF_ARGS_ 3 3 XXX 3 _/\_ u0 u1 u2 -> \ (u3 :: u1 -> u0 -> u2) (u4 :: u0) (u5 :: u1) -> _APP_ u3 [ u5, u4 ] _N_ #-}
+fromChar# :: Char# -> Char
+ {-# GHC_PRAGMA _A_ 1 _U_ 2 _N_ _S_ "P" _F_ _IF_ARGS_ 0 1 X 2 \ (u0 :: Char#) -> _!_ C# [] [u0] _N_ #-}
+fromInt# :: Int# -> Int
+ {-# GHC_PRAGMA _A_ 1 _U_ 2 _N_ _S_ "P" _F_ _IF_ARGS_ 0 1 X 2 \ (u0 :: Int#) -> _!_ I# [] [u0] _N_ #-}
fromIntegral :: (Integral a, Num b) => a -> b
- {-# GHC_PRAGMA _A_ 3 _U_ 112 _N_ _S_ "LU(AAAAAAAASA)L" {_A_ 3 _U_ 112 _N_ _N_ _F_ _IF_ARGS_ 2 3 CXX 6 _/\_ u0 u1 -> \ (u2 :: {{Integral u0}}) (u3 :: Integer -> u1) (u4 :: u0) -> let {(uh :: Integer) = case u2 of { _ALG_ _TUP_12 (u5 :: {{Real u0}}) (u6 :: {{Ix u0}}) (u7 :: u0 -> u0 -> u0) (u8 :: u0 -> u0 -> u0) (u9 :: u0 -> u0 -> u0) (ua :: u0 -> u0 -> u0) (ub :: u0 -> u0 -> (u0, u0)) (uc :: u0 -> u0 -> (u0, u0)) (ud :: u0 -> Bool) (ue :: u0 -> Bool) (uf :: u0 -> Integer) (ug :: u0 -> Int) -> _APP_ uf [ u4 ]; _NO_DEFLT_ }} in _APP_ u3 [ uh ] _N_} _F_ _IF_ARGS_ 2 3 CCX 7 _/\_ u0 u1 -> \ (u2 :: {{Integral u0}}) (u3 :: {{Num u1}}) (u4 :: u0) -> let {(uh :: Integer) = case u2 of { _ALG_ _TUP_12 (u5 :: {{Real u0}}) (u6 :: {{Ix u0}}) (u7 :: u0 -> u0 -> u0) (u8 :: u0 -> u0 -> u0) (u9 :: u0 -> u0 -> u0) (ua :: u0 -> u0 -> u0) (ub :: u0 -> u0 -> (u0, u0)) (uc :: u0 -> u0 -> (u0, u0)) (ud :: u0 -> Bool) (ue :: u0 -> Bool) (uf :: u0 -> Integer) (ug :: u0 -> Int) -> _APP_ uf [ u4 ]; _NO_DEFLT_ }} in case u3 of { _ALG_ _TUP_10 (ui :: {{Eq u1}}) (uj :: {{Text u1}}) (uk :: u1 -> u1 -> u1) (ul :: u1 -> u1 -> u1) (um :: u1 -> u1 -> u1) (un :: u1 -> u1) (uo :: u1 -> u1) (up :: u1 -> u1) (uq :: Integer -> u1) (ur :: Int -> u1) -> _APP_ uq [ uh ]; _NO_DEFLT_ } _SPECIALISE_ [ Int, Double ] 2 { _A_ 1 _U_ 1 _N_ _S_ "U(P)" {_A_ 1 _U_ 2 _N_ _N_ _F_ _IF_ARGS_ 0 1 X 3 \ (u0 :: Int#) -> case _#_ int2Double# [] [u0] of { _PRIM_ (u1 :: Double#) -> _!_ D# [] [u1] } _N_} _F_ _IF_ARGS_ 0 1 C 4 \ (u0 :: Int) -> case u0 of { _ALG_ I# (u1 :: Int#) -> case _#_ int2Double# [] [u1] of { _PRIM_ (u2 :: Double#) -> _!_ D# [] [u2] }; _NO_DEFLT_ } _N_ }, [ Int, Int ] 2 { _A_ 1 _U_ 1 _N_ _N_ _F_ _IF_ARGS_ 0 0 X 1 _TYAPP_ _ORIG_ Prelude id { Int } _N_ }, [ Int, Integer ] 2 { _A_ 1 _U_ 1 _N_ _S_ "U(P)" {_A_ 1 _U_ 2 _N_ _N_ _F_ _IF_ARGS_ 0 1 X 1 \ (u0 :: Int#) -> _#_ int2Integer# [] [u0] _N_} _F_ _IF_ARGS_ 0 1 C 2 \ (u0 :: Int) -> case u0 of { _ALG_ I# (u1 :: Int#) -> _#_ int2Integer# [] [u1]; _NO_DEFLT_ } _N_ }, [ Integer, Double ] 2 { _A_ 1 _U_ 1 _N_ _S_ "U(PPP)" {_A_ 3 _U_ 222 _N_ _N_ _F_ _IF_ARGS_ 0 3 XXX 3 \ (u0 :: Int#) (u1 :: Int#) (u2 :: ByteArray#) -> case _#_ encodeDouble# [] [u0, u1, u2, 0#] of { _PRIM_ (u3 :: Double#) -> _!_ D# [] [u3] } _N_} _F_ _IF_ARGS_ 0 1 C 4 \ (u0 :: Integer) -> case u0 of { _ALG_ J# (u1 :: Int#) (u2 :: Int#) (u3 :: ByteArray#) -> case _#_ encodeDouble# [] [u1, u2, u3, 0#] of { _PRIM_ (u4 :: Double#) -> _!_ D# [] [u4] }; _NO_DEFLT_ } _N_ }, [ Integer, Int ] 2 { _A_ 1 _U_ 1 _N_ _S_ "U(PPP)" {_A_ 3 _U_ 222 _N_ _N_ _F_ _IF_ARGS_ 0 3 XXX 3 \ (u0 :: Int#) (u1 :: Int#) (u2 :: ByteArray#) -> case _#_ integer2Int# [] [u0, u1, u2] of { _PRIM_ (u3 :: Int#) -> _!_ I# [] [u3] } _N_} _F_ _IF_ARGS_ 0 1 C 4 \ (u0 :: Integer) -> case u0 of { _ALG_ J# (u1 :: Int#) (u2 :: Int#) (u3 :: ByteArray#) -> case _#_ integer2Int# [] [u1, u2, u3] of { _PRIM_ (u4 :: Int#) -> _!_ I# [] [u4] }; _NO_DEFLT_ } _N_ }, [ Integer, Integer ] 2 { _A_ 1 _U_ 1 _N_ _N_ _F_ _IF_ARGS_ 0 0 X 1 _TYAPP_ _ORIG_ Prelude id { Integer } _N_ } #-}
+ {-# GHC_PRAGMA _A_ 3 _U_ 112 _N_ _S_ "LU(AAAAAAAASA)L" {_A_ 3 _U_ 112 _N_ _N_ _F_ _IF_ARGS_ 2 3 CXX 6 _/\_ u0 u1 -> \ (u2 :: {{Integral u0}}) (u3 :: Integer -> u1) (u4 :: u0) -> let {(uh :: Integer) = case u2 of { _ALG_ _TUP_12 (u5 :: {{Real u0}}) (u6 :: {{Ix u0}}) (u7 :: u0 -> u0 -> u0) (u8 :: u0 -> u0 -> u0) (u9 :: u0 -> u0 -> u0) (ua :: u0 -> u0 -> u0) (ub :: u0 -> u0 -> (u0, u0)) (uc :: u0 -> u0 -> (u0, u0)) (ud :: u0 -> Bool) (ue :: u0 -> Bool) (uf :: u0 -> Integer) (ug :: u0 -> Int) -> _APP_ uf [ u4 ]; _NO_DEFLT_ }} in _APP_ u3 [ uh ] _N_} _F_ _IF_ARGS_ 2 3 CCX 7 _/\_ u0 u1 -> \ (u2 :: {{Integral u0}}) (u3 :: {{Num u1}}) (u4 :: u0) -> let {(uh :: Integer) = case u2 of { _ALG_ _TUP_12 (u5 :: {{Real u0}}) (u6 :: {{Ix u0}}) (u7 :: u0 -> u0 -> u0) (u8 :: u0 -> u0 -> u0) (u9 :: u0 -> u0 -> u0) (ua :: u0 -> u0 -> u0) (ub :: u0 -> u0 -> (u0, u0)) (uc :: u0 -> u0 -> (u0, u0)) (ud :: u0 -> Bool) (ue :: u0 -> Bool) (uf :: u0 -> Integer) (ug :: u0 -> Int) -> _APP_ uf [ u4 ]; _NO_DEFLT_ }} in case u3 of { _ALG_ _TUP_10 (ui :: {{Eq u1}}) (uj :: {{Text u1}}) (uk :: u1 -> u1 -> u1) (ul :: u1 -> u1 -> u1) (um :: u1 -> u1 -> u1) (un :: u1 -> u1) (uo :: u1 -> u1) (up :: u1 -> u1) (uq :: Integer -> u1) (ur :: Int -> u1) -> _APP_ uq [ uh ]; _NO_DEFLT_ } _SPECIALISE_ [ Int, Double ] 2 { _A_ 1 _U_ 1 _N_ _S_ "U(P)" {_A_ 1 _U_ 2 _N_ _N_ _F_ _IF_ARGS_ 0 1 X 3 \ (u0 :: Int#) -> case _#_ int2Double# [] [u0] of { _PRIM_ (u1 :: Double#) -> _!_ D# [] [u1] } _N_} _F_ _IF_ARGS_ 0 1 C 4 \ (u0 :: Int) -> case u0 of { _ALG_ I# (u1 :: Int#) -> case _#_ int2Double# [] [u1] of { _PRIM_ (u2 :: Double#) -> _!_ D# [] [u2] }; _NO_DEFLT_ } _N_ }, [ Int, Float ] 2 { _A_ 1 _U_ 1 _N_ _S_ "U(P)" {_A_ 1 _U_ 2 _N_ _N_ _F_ _IF_ARGS_ 0 1 X 3 \ (u0 :: Int#) -> case _#_ int2Float# [] [u0] of { _PRIM_ (u1 :: Float#) -> _!_ F# [] [u1] } _N_} _F_ _IF_ARGS_ 0 1 C 4 \ (u0 :: Int) -> case u0 of { _ALG_ I# (u1 :: Int#) -> case _#_ int2Float# [] [u1] of { _PRIM_ (u2 :: Float#) -> _!_ F# [] [u2] }; _NO_DEFLT_ } _N_ }, [ Int, Int ] 2 { _A_ 1 _U_ 1 _N_ _N_ _F_ _IF_ARGS_ 0 0 X 1 _TYAPP_ _ORIG_ Prelude id { Int } _N_ }, [ Int, Integer ] 2 { _A_ 1 _U_ 1 _N_ _S_ "U(P)" {_A_ 1 _U_ 2 _N_ _N_ _F_ _IF_ARGS_ 0 1 X 1 \ (u0 :: Int#) -> _#_ int2Integer# [] [u0] _N_} _F_ _IF_ARGS_ 0 1 C 2 \ (u0 :: Int) -> case u0 of { _ALG_ I# (u1 :: Int#) -> _#_ int2Integer# [] [u1]; _NO_DEFLT_ } _N_ }, [ Int, (Ratio Integer) ] 2 { _A_ 1 _U_ 1 _N_ _N_ _N_ _N_ }, [ Integer, Double ] 2 { _A_ 1 _U_ 1 _N_ _S_ "U(PPP)" {_A_ 3 _U_ 222 _N_ _N_ _F_ _IF_ARGS_ 0 3 XXX 3 \ (u0 :: Int#) (u1 :: Int#) (u2 :: ByteArray#) -> case _#_ encodeDouble# [] [u0, u1, u2, 0#] of { _PRIM_ (u3 :: Double#) -> _!_ D# [] [u3] } _N_} _F_ _IF_ARGS_ 0 1 C 4 \ (u0 :: Integer) -> case u0 of { _ALG_ J# (u1 :: Int#) (u2 :: Int#) (u3 :: ByteArray#) -> case _#_ encodeDouble# [] [u1, u2, u3, 0#] of { _PRIM_ (u4 :: Double#) -> _!_ D# [] [u4] }; _NO_DEFLT_ } _N_ }, [ Integer, Float ] 2 { _A_ 1 _U_ 1 _N_ _S_ "U(PPP)" {_A_ 3 _U_ 222 _N_ _N_ _F_ _IF_ARGS_ 0 3 XXX 3 \ (u0 :: Int#) (u1 :: Int#) (u2 :: ByteArray#) -> case _#_ encodeFloat# [] [u0, u1, u2, 0#] of { _PRIM_ (u3 :: Float#) -> _!_ F# [] [u3] } _N_} _F_ _IF_ARGS_ 0 1 C 4 \ (u0 :: Integer) -> case u0 of { _ALG_ J# (u1 :: Int#) (u2 :: Int#) (u3 :: ByteArray#) -> case _#_ encodeFloat# [] [u1, u2, u3, 0#] of { _PRIM_ (u4 :: Float#) -> _!_ F# [] [u4] }; _NO_DEFLT_ } _N_ }, [ Integer, Int ] 2 { _A_ 1 _U_ 1 _N_ _S_ "U(PPP)" {_A_ 3 _U_ 222 _N_ _N_ _F_ _IF_ARGS_ 0 3 XXX 3 \ (u0 :: Int#) (u1 :: Int#) (u2 :: ByteArray#) -> case _#_ integer2Int# [] [u0, u1, u2] of { _PRIM_ (u3 :: Int#) -> _!_ I# [] [u3] } _N_} _F_ _IF_ARGS_ 0 1 C 4 \ (u0 :: Integer) -> case u0 of { _ALG_ J# (u1 :: Int#) (u2 :: Int#) (u3 :: ByteArray#) -> case _#_ integer2Int# [] [u1, u2, u3] of { _PRIM_ (u4 :: Int#) -> _!_ I# [] [u4] }; _NO_DEFLT_ } _N_ }, [ Integer, Integer ] 2 { _A_ 1 _U_ 1 _N_ _N_ _F_ _IF_ARGS_ 0 0 X 1 _TYAPP_ _ORIG_ Prelude id { Integer } _N_ }, [ Integer, (Ratio Integer) ] 2 { _A_ 1 _U_ 2 _N_ _N_ _F_ _IF_ARGS_ 0 1 X 3 \ (u0 :: Integer) -> _!_ (:%) [Integer] [u0, _SPEC_ _ORIG_ PreludeCore __i1 [ (Integer) ]] _N_ } #-}
fromRealFrac :: (RealFrac a, Fractional b) => a -> b
- {-# GHC_PRAGMA _A_ 3 _U_ 112 _N_ _S_ "LU(AAAS)L" {_A_ 3 _U_ 112 _N_ _N_ _N_ _N_} _N_ _SPECIALISE_ [ Double, Double ] 2 { _A_ 1 _U_ 1 _N_ _N_ _F_ _IF_ARGS_ 0 0 X 1 _TYAPP_ _ORIG_ Prelude id { Double } _N_ }, [ Double, Float ] 2 { _A_ 1 _U_ 1 _N_ _S_ "U(P)" {_A_ 1 _U_ 2 _N_ _N_ _F_ _IF_ARGS_ 0 1 X 3 \ (u0 :: Double#) -> case _#_ double2Float# [] [u0] of { _PRIM_ (u1 :: Float#) -> _!_ F# [] [u1] } _N_} _F_ _IF_ARGS_ 0 1 C 4 \ (u0 :: Double) -> case u0 of { _ALG_ D# (u1 :: Double#) -> case _#_ double2Float# [] [u1] of { _PRIM_ (u2 :: Float#) -> _!_ F# [] [u2] }; _NO_DEFLT_ } _N_ }, [ Float, Double ] 2 { _A_ 1 _U_ 1 _N_ _S_ "U(P)" {_A_ 1 _U_ 2 _N_ _N_ _F_ _IF_ARGS_ 0 1 X 3 \ (u0 :: Float#) -> case _#_ float2Double# [] [u0] of { _PRIM_ (u1 :: Double#) -> _!_ D# [] [u1] } _N_} _F_ _IF_ARGS_ 0 1 C 4 \ (u0 :: Float) -> case u0 of { _ALG_ F# (u1 :: Float#) -> case _#_ float2Double# [] [u1] of { _PRIM_ (u2 :: Double#) -> _!_ D# [] [u2] }; _NO_DEFLT_ } _N_ }, [ Float, Float ] 2 { _A_ 1 _U_ 1 _N_ _N_ _F_ _IF_ARGS_ 0 0 X 1 _TYAPP_ _ORIG_ Prelude id { Float } _N_ } #-}
+ {-# GHC_PRAGMA _A_ 3 _U_ 112 _N_ _S_ "LU(AAAS)L" {_A_ 3 _U_ 112 _N_ _N_ _N_ _N_} _N_ _SPECIALISE_ [ Double, Double ] 2 { _A_ 1 _U_ 1 _N_ _N_ _F_ _IF_ARGS_ 0 0 X 1 _TYAPP_ _ORIG_ Prelude id { Double } _N_ }, [ Double, Float ] 2 { _A_ 1 _U_ 1 _N_ _S_ "U(P)" {_A_ 1 _U_ 2 _N_ _N_ _F_ _IF_ARGS_ 0 1 X 3 \ (u0 :: Double#) -> case _#_ double2Float# [] [u0] of { _PRIM_ (u1 :: Float#) -> _!_ F# [] [u1] } _N_} _F_ _IF_ARGS_ 0 1 C 4 \ (u0 :: Double) -> case u0 of { _ALG_ D# (u1 :: Double#) -> case _#_ double2Float# [] [u1] of { _PRIM_ (u2 :: Float#) -> _!_ F# [] [u2] }; _NO_DEFLT_ } _N_ }, [ Double, (Ratio Integer) ] 2 { _A_ 1 _U_ 1 _N_ _S_ "U(P)" {_A_ 1 _U_ 2 _N_ _N_ _N_ _N_} _N_ _N_ }, [ Float, Double ] 2 { _A_ 1 _U_ 1 _N_ _S_ "U(P)" {_A_ 1 _U_ 2 _N_ _N_ _F_ _IF_ARGS_ 0 1 X 3 \ (u0 :: Float#) -> case _#_ float2Double# [] [u0] of { _PRIM_ (u1 :: Double#) -> _!_ D# [] [u1] } _N_} _F_ _IF_ARGS_ 0 1 C 4 \ (u0 :: Float) -> case u0 of { _ALG_ F# (u1 :: Float#) -> case _#_ float2Double# [] [u1] of { _PRIM_ (u2 :: Double#) -> _!_ D# [] [u2] }; _NO_DEFLT_ } _N_ }, [ Float, Float ] 2 { _A_ 1 _U_ 1 _N_ _N_ _F_ _IF_ARGS_ 0 0 X 1 _TYAPP_ _ORIG_ Prelude id { Float } _N_ }, [ Float, (Ratio Integer) ] 2 { _A_ 1 _U_ 1 _N_ _S_ "U(P)" {_A_ 1 _U_ 2 _N_ _N_ _N_ _N_} _N_ _N_ }, [ (Ratio Integer), Double ] 2 { _A_ 1 _U_ 1 _N_ _S_ "U(U(PPP)U(PPP))" {_A_ 4 _U_ 2222 _N_ _N_ _N_ _N_} _N_ _N_ }, [ (Ratio Integer), Float ] 2 { _A_ 1 _U_ 2 _N_ _N_ _F_ _IF_ARGS_ 0 0 X 1 _CONSTM_ Fractional fromRational (Float) _N_ }, [ (Ratio Integer), (Ratio Integer) ] 2 { _A_ 1 _U_ 1 _N_ _N_ _F_ _IF_ARGS_ 0 0 X 1 _TYAPP_ _ORIG_ Prelude id { (Ratio Integer) } _N_ } #-}
fst :: (b, a) -> b
{-# GHC_PRAGMA _A_ 1 _U_ 1 _N_ _S_ "U(SA)" {_A_ 1 _U_ 1 _N_ _N_ _F_ _IF_ARGS_ 2 1 X 1 _/\_ u0 u1 -> \ (u2 :: u1) -> u2 _N_} _F_ _IF_ARGS_ 2 1 C 2 _/\_ u0 u1 -> \ (u2 :: (u1, u0)) -> case u2 of { _ALG_ _TUP_2 (u3 :: u1) (u4 :: u0) -> u3; _NO_DEFLT_ } _N_ #-}
gcd :: Integral a => a -> a -> a
{-# GHC_PRAGMA _A_ 1 _U_ 1 _N_ _S_ "S" _F_ _IF_ARGS_ 1 1 X 1 _/\_ u0 -> \ (u1 :: u0) -> u1 _N_ #-}
isAlpha :: Char -> Bool
{-# GHC_PRAGMA _A_ 1 _U_ 1 _N_ _S_ "U(P)" {_A_ 1 _U_ 2 _N_ _N_ _N_ _N_} _N_ _N_ #-}
+isAlpha# :: Char# -> Bool
+ {-# GHC_PRAGMA _A_ 1 _U_ 2 _N_ _S_ "P" _N_ _N_ #-}
isAlphanum :: Char -> Bool
{-# GHC_PRAGMA _A_ 1 _U_ 1 _N_ _S_ "U(P)" {_A_ 1 _U_ 2 _N_ _N_ _N_ _N_} _N_ _N_ #-}
+isAlphanum# :: Char# -> Bool
+ {-# GHC_PRAGMA _A_ 1 _U_ 2 _N_ _S_ "P" _N_ _N_ #-}
isAscii :: Char -> Bool
{-# GHC_PRAGMA _A_ 1 _U_ 1 _N_ _S_ "U(P)" {_A_ 1 _U_ 2 _N_ _N_ _F_ _IF_ARGS_ 0 1 X 2 \ (u0 :: Char#) -> case _#_ ord# [] [u0] of { _PRIM_ (u1 :: Int#) -> _#_ ltInt# [] [u1, 128#] } _N_} _F_ _IF_ARGS_ 0 1 C 3 \ (u0 :: Char) -> case u0 of { _ALG_ C# (u1 :: Char#) -> case _#_ ord# [] [u1] of { _PRIM_ (u2 :: Int#) -> _#_ ltInt# [] [u2, 128#] }; _NO_DEFLT_ } _N_ #-}
+isAscii# :: Char# -> Bool
+ {-# GHC_PRAGMA _A_ 1 _U_ 2 _N_ _S_ "P" _F_ _IF_ARGS_ 0 1 X 2 \ (u0 :: Char#) -> case _#_ ord# [] [u0] of { _PRIM_ (u1 :: Int#) -> _#_ ltInt# [] [u1, 128#] } _N_ #-}
isControl :: Char -> Bool
{-# GHC_PRAGMA _A_ 1 _U_ 1 _N_ _S_ "U(P)" {_A_ 1 _U_ 2 _N_ _N_ _N_ _N_} _N_ _N_ #-}
+isControl# :: Char# -> Bool
+ {-# GHC_PRAGMA _A_ 1 _U_ 2 _N_ _S_ "P" _N_ _N_ #-}
isDigit :: Char -> Bool
{-# GHC_PRAGMA _A_ 1 _U_ 1 _N_ _S_ "U(P)" {_A_ 1 _U_ 2 _N_ _N_ _N_ _N_} _N_ _N_ #-}
+isDigit# :: Char# -> Bool
+ {-# GHC_PRAGMA _A_ 1 _U_ 2 _N_ _S_ "P" _N_ _N_ #-}
isLower :: Char -> Bool
{-# GHC_PRAGMA _A_ 1 _U_ 1 _N_ _S_ "U(P)" {_A_ 1 _U_ 2 _N_ _N_ _N_ _N_} _N_ _N_ #-}
+isLower# :: Char# -> Bool
+ {-# GHC_PRAGMA _A_ 1 _U_ 2 _N_ _S_ "P" _N_ _N_ #-}
isNullBin :: Bin -> Bool
- {-# GHC_PRAGMA _A_ 1 _U_ 2 _N_ _S_ _!_ _F_ _IF_ARGS_ 0 1 X 3 \ (u0 :: Bin) -> _APP_ _TYAPP_ error { (Bin -> Bool) } [ _NOREP_S_ "isNullBin{Prelude}\n", u0 ] _N_ #-}
+ {-# GHC_PRAGMA _A_ 1 _U_ 2 _N_ _S_ _!_ _N_ _N_ #-}
isPrint :: Char -> Bool
{-# GHC_PRAGMA _A_ 1 _U_ 1 _N_ _S_ "U(P)" {_A_ 1 _U_ 2 _N_ _N_ _N_ _N_} _N_ _N_ #-}
+isPrint# :: Char# -> Bool
+ {-# GHC_PRAGMA _A_ 1 _U_ 2 _N_ _S_ "P" _N_ _N_ #-}
isSpace :: Char -> Bool
{-# GHC_PRAGMA _A_ 1 _U_ 1 _N_ _S_ "U(P)" {_A_ 1 _U_ 1 _N_ _N_ _N_ _N_} _N_ _N_ #-}
+isSpace# :: Char# -> Bool
+ {-# GHC_PRAGMA _A_ 1 _U_ 1 _N_ _S_ "P" _N_ _N_ #-}
isUpper :: Char -> Bool
{-# GHC_PRAGMA _A_ 1 _U_ 1 _N_ _S_ "U(P)" {_A_ 1 _U_ 2 _N_ _N_ _N_ _N_} _N_ _N_ #-}
+isUpper# :: Char# -> Bool
+ {-# GHC_PRAGMA _A_ 1 _U_ 2 _N_ _S_ "P" _N_ _N_ #-}
lcm :: Integral a => a -> a -> a
{-# GHC_PRAGMA _A_ 1 _U_ 122 _N_ _S_ "U(U(U(U(SA)AAALALAAL)AA)ALLAAAAAAAA)" {_A_ 3 _U_ 12222 _N_ _N_ _N_ _N_} _N_ _SPECIALISE_ [ Int ] 1 { _A_ 2 _U_ 11 _N_ _S_ "LU(P)" {_A_ 2 _U_ 12 _N_ _N_ _N_ _N_} _N_ _N_ }, [ Integer ] 1 { _A_ 2 _U_ 11 _N_ _S_ "LU(PPP)" {_A_ 4 _U_ 1222 _N_ _N_ _N_ _N_} _N_ _N_ } #-}
maxChar :: Char
{-# GHC_PRAGMA _A_ 0 _N_ _N_ _N_ _F_ _IF_ARGS_ 0 0 X 2 _!_ C# [] ['\o377'#] _N_ #-}
+maxChar# :: Char#
+ {-# GHC_PRAGMA _A_ 0 _N_ _N_ _N_ _F_ _IF_ARGS_ 0 0 X 2 _!_ _Lift [Char#] ['\o377'#] _N_ #-}
maxInt :: Int
{-# GHC_PRAGMA _A_ 0 _N_ _N_ _N_ _F_ _IF_ARGS_ 0 0 X 2 _!_ I# [] [2147483647#] _N_ #-}
+maxInt# :: Int#
+ {-# GHC_PRAGMA _A_ 0 _N_ _N_ _N_ _F_ _IF_ARGS_ 0 0 X 2 _!_ _Lift [Int#] [2147483647#] _N_ #-}
minChar :: Char
{-# GHC_PRAGMA _A_ 0 _N_ _N_ _N_ _F_ _IF_ARGS_ 0 0 X 2 _!_ C# [] ['\o0'#] _N_ #-}
+minChar# :: Char#
+ {-# GHC_PRAGMA _A_ 0 _N_ _N_ _N_ _F_ _IF_ARGS_ 0 0 X 2 _!_ _Lift [Char#] ['\o0'#] _N_ #-}
minInt :: Int
{-# GHC_PRAGMA _A_ 0 _N_ _N_ _N_ _F_ _IF_ARGS_ 0 0 X 2 _!_ I# [] [-2147483647#] _N_ #-}
+minInt# :: Int#
+ {-# GHC_PRAGMA _A_ 0 _N_ _N_ _N_ _F_ _IF_ARGS_ 0 0 X 2 _!_ _Lift [Int#] [-2147483647#] _N_ #-}
not :: Bool -> Bool
{-# GHC_PRAGMA _A_ 1 _U_ 1 _N_ _S_ "E" _F_ _ALWAYS_ \ (u0 :: Bool) -> case u0 of { _ALG_ True -> _!_ False [] []; False -> _!_ True [] []; _NO_DEFLT_ } _N_ #-}
nullBin :: Bin
- {-# GHC_PRAGMA _A_ 0 _N_ _N_ _S_ _!_ _F_ _IF_ARGS_ 0 0 X 2 _APP_ _TYAPP_ error { Bin } [ _NOREP_S_ "nullBin{Prelude}\n" ] _N_ #-}
+ {-# GHC_PRAGMA _A_ 0 _N_ _N_ _S_ _!_ _N_ _N_ #-}
ord :: Char -> Int
{-# GHC_PRAGMA _A_ 1 _U_ 1 _N_ _S_ "U(P)" {_A_ 1 _U_ 2 _N_ _N_ _F_ _IF_ARGS_ 0 1 X 3 \ (u0 :: Char#) -> case _#_ ord# [] [u0] of { _PRIM_ (u1 :: Int#) -> _!_ I# [] [u1] } _N_} _F_ _IF_ARGS_ 0 1 C 4 \ (u0 :: Char) -> case u0 of { _ALG_ C# (u1 :: Char#) -> case _#_ ord# [] [u1] of { _PRIM_ (u2 :: Int#) -> _!_ I# [] [u2] }; _NO_DEFLT_ } _N_ #-}
otherwise :: Bool
snd :: (a, b) -> b
{-# GHC_PRAGMA _A_ 1 _U_ 1 _N_ _S_ "U(AS)" {_A_ 1 _U_ 1 _N_ _N_ _F_ _IF_ARGS_ 2 1 X 1 _/\_ u0 u1 -> \ (u2 :: u1) -> u2 _N_} _F_ _IF_ARGS_ 2 1 C 2 _/\_ u0 u1 -> \ (u2 :: (u0, u1)) -> case u2 of { _ALG_ _TUP_2 (u3 :: u0) (u4 :: u1) -> u4; _NO_DEFLT_ } _N_ #-}
subtract :: Num a => a -> a -> a
- {-# GHC_PRAGMA _A_ 3 _U_ 122 _N_ _S_ "U(AAASAAAAAA)LL" {_A_ 3 _U_ 122 _N_ _N_ _F_ _IF_ARGS_ 1 3 XXX 3 _/\_ u0 -> \ (u1 :: u0 -> u0 -> u0) (u2 :: u0) (u3 :: u0) -> _APP_ u1 [ u3, u2 ] _N_} _F_ _IF_ARGS_ 1 3 CXX 4 _/\_ u0 -> \ (u1 :: {{Num u0}}) (u2 :: u0) (u3 :: u0) -> case u1 of { _ALG_ _TUP_10 (u4 :: {{Eq u0}}) (u5 :: {{Text u0}}) (u6 :: u0 -> u0 -> u0) (u7 :: u0 -> u0 -> u0) (u8 :: u0 -> u0 -> u0) (u9 :: u0 -> u0) (ua :: u0 -> u0) (ub :: u0 -> u0) (uc :: Integer -> u0) (ud :: Int -> u0) -> _APP_ u7 [ u3, u2 ]; _NO_DEFLT_ } _SPECIALISE_ [ Double ] 1 { _A_ 2 _U_ 11 _N_ _S_ "U(P)U(P)" {_A_ 2 _U_ 22 _N_ _N_ _F_ _IF_ARGS_ 0 2 XX 3 \ (u0 :: Double#) (u1 :: Double#) -> case _#_ minusDouble# [] [u1, u0] of { _PRIM_ (u2 :: Double#) -> _!_ D# [] [u2] } _N_} _F_ _IF_ARGS_ 0 2 CC 5 \ (u0 :: Double) (u1 :: Double) -> case u1 of { _ALG_ D# (u2 :: Double#) -> case u0 of { _ALG_ D# (u3 :: Double#) -> case _#_ minusDouble# [] [u2, u3] of { _PRIM_ (u4 :: Double#) -> _!_ D# [] [u4] }; _NO_DEFLT_ }; _NO_DEFLT_ } _N_ }, [ Int ] 1 { _A_ 2 _U_ 11 _N_ _S_ "U(P)U(P)" {_A_ 2 _U_ 22 _N_ _N_ _F_ _IF_ARGS_ 0 2 XX 3 \ (u0 :: Int#) (u1 :: Int#) -> case _#_ minusInt# [] [u1, u0] of { _PRIM_ (u2 :: Int#) -> _!_ I# [] [u2] } _N_} _F_ _IF_ARGS_ 0 2 CC 5 \ (u0 :: Int) (u1 :: Int) -> case u1 of { _ALG_ I# (u2 :: Int#) -> case u0 of { _ALG_ I# (u3 :: Int#) -> case _#_ minusInt# [] [u2, u3] of { _PRIM_ (u4 :: Int#) -> _!_ I# [] [u4] }; _NO_DEFLT_ }; _NO_DEFLT_ } _N_ } #-}
+ {-# GHC_PRAGMA _A_ 3 _U_ 122 _N_ _S_ "U(AAASAAAAAA)LL" {_A_ 3 _U_ 122 _N_ _N_ _F_ _IF_ARGS_ 1 3 XXX 3 _/\_ u0 -> \ (u1 :: u0 -> u0 -> u0) (u2 :: u0) (u3 :: u0) -> _APP_ u1 [ u3, u2 ] _N_} _F_ _IF_ARGS_ 1 3 CXX 4 _/\_ u0 -> \ (u1 :: {{Num u0}}) (u2 :: u0) (u3 :: u0) -> case u1 of { _ALG_ _TUP_10 (u4 :: {{Eq u0}}) (u5 :: {{Text u0}}) (u6 :: u0 -> u0 -> u0) (u7 :: u0 -> u0 -> u0) (u8 :: u0 -> u0 -> u0) (u9 :: u0 -> u0) (ua :: u0 -> u0) (ub :: u0 -> u0) (uc :: Integer -> u0) (ud :: Int -> u0) -> _APP_ u7 [ u3, u2 ]; _NO_DEFLT_ } _SPECIALISE_ [ Double ] 1 { _A_ 2 _U_ 11 _N_ _S_ "U(P)U(P)" {_A_ 2 _U_ 22 _N_ _N_ _F_ _IF_ARGS_ 0 2 XX 3 \ (u0 :: Double#) (u1 :: Double#) -> case _#_ minusDouble# [] [u1, u0] of { _PRIM_ (u2 :: Double#) -> _!_ D# [] [u2] } _N_} _F_ _IF_ARGS_ 0 2 CC 5 \ (u0 :: Double) (u1 :: Double) -> case u1 of { _ALG_ D# (u2 :: Double#) -> case u0 of { _ALG_ D# (u3 :: Double#) -> case _#_ minusDouble# [] [u2, u3] of { _PRIM_ (u4 :: Double#) -> _!_ D# [] [u4] }; _NO_DEFLT_ }; _NO_DEFLT_ } _N_ }, [ Int ] 1 { _A_ 2 _U_ 11 _N_ _S_ "U(P)U(P)" {_A_ 2 _U_ 22 _N_ _N_ _F_ _IF_ARGS_ 0 2 XX 3 \ (u0 :: Int#) (u1 :: Int#) -> case _#_ minusInt# [] [u1, u0] of { _PRIM_ (u2 :: Int#) -> _!_ I# [] [u2] } _N_} _F_ _IF_ARGS_ 0 2 CC 5 \ (u0 :: Int) (u1 :: Int) -> case u1 of { _ALG_ I# (u2 :: Int#) -> case u0 of { _ALG_ I# (u3 :: Int#) -> case _#_ minusInt# [] [u2, u3] of { _PRIM_ (u4 :: Int#) -> _!_ I# [] [u4] }; _NO_DEFLT_ }; _NO_DEFLT_ } _N_ }, [ (Complex Double) ] 1 { _A_ 2 _U_ 11 _N_ _S_ "U(LL)U(LL)" {_A_ 4 _U_ 2222 _N_ _N_ _N_ _N_} _N_ _N_ } #-}
+toChar# :: Char -> Char#
+ {-# GHC_PRAGMA _A_ 1 _U_ 1 _N_ _S_ "U(P)" {_A_ 1 _U_ 1 _N_ _N_ _F_ _IF_ARGS_ 0 1 X 1 \ (u0 :: Char#) -> u0 _N_} _F_ _IF_ARGS_ 0 1 C 2 \ (u0 :: Char) -> case u0 of { _ALG_ C# (u1 :: Char#) -> u1; _NO_DEFLT_ } _N_ #-}
+toInt# :: Int -> Int#
+ {-# GHC_PRAGMA _A_ 1 _U_ 1 _N_ _S_ "U(P)" {_A_ 1 _U_ 1 _N_ _N_ _F_ _IF_ARGS_ 0 1 X 1 \ (u0 :: Int#) -> u0 _N_} _F_ _IF_ARGS_ 0 1 C 2 \ (u0 :: Int) -> case u0 of { _ALG_ I# (u1 :: Int#) -> u1; _NO_DEFLT_ } _N_ #-}
toLower :: Char -> Char
{-# GHC_PRAGMA _A_ 1 _U_ 1 _N_ _S_ "U(P)" {_A_ 1 _U_ 2 _N_ _N_ _N_ _N_} _N_ _N_ #-}
+toLower# :: Char# -> Char#
+ {-# GHC_PRAGMA _A_ 1 _U_ 2 _N_ _S_ "P" _N_ _N_ #-}
toUpper :: Char -> Char
{-# GHC_PRAGMA _A_ 1 _U_ 1 _N_ _S_ "U(P)" {_A_ 1 _U_ 2 _N_ _N_ _N_ _N_} _N_ _N_ #-}
+toUpper# :: Char# -> Char#
+ {-# GHC_PRAGMA _A_ 1 _U_ 2 _N_ _S_ "P" _N_ _N_ #-}
until :: (a -> Bool) -> (a -> a) -> a -> a
{-# GHC_PRAGMA _A_ 3 _U_ 222 _N_ _S_ "SLL" _N_ _N_ #-}
(||) :: Bool -> Bool -> Bool
-{-# GHC_PRAGMA INTERFACE VERSION 5 #-}
+{-# GHC_PRAGMA INTERFACE VERSION 6 #-}
interface Prelude where
import PreludeBuiltin(Bin, Char(..), Int(..), Tuple2)
import PreludeCore(Bool(..), Fractional(..), Integral(..), Num(..), RealFloat(..), RealFrac(..))
(.) :: (a -> c) -> (b -> a) -> b -> c
{-# GHC_PRAGMA _A_ 3 _U_ 112 _N_ _S_ "SLL" _F_ _ALWAYS_ _/\_ u0 u1 u2 -> \ (u3 :: u0 -> u2) (u4 :: u1 -> u0) (u5 :: u1) -> let {(u6 :: u0) = _APP_ u4 [ u5 ]} in _APP_ u3 [ u6 ] _N_ #-}
(^) :: (Num b, Integral a) => b -> a -> b
- {-# GHC_PRAGMA _A_ 2 _U_ 2122 _N_ _S_ "LU(U(LU(U(U(SA)AALAAAA)AAAA)A)AAALAAAALAA)" {_A_ 5 _U_ 2212222 _N_ _N_ _N_ _N_} _N_ _SPECIALISE_ [ Int, Double ] 2 { _A_ 2 _U_ 21 _N_ _S_ "LU(P)" {_A_ 2 _U_ 22 _N_ _N_ _N_ _N_} _N_ _N_ }, [ Int, Int ] 2 { _A_ 2 _U_ 21 _N_ _S_ "LU(P)" {_A_ 2 _U_ 22 _N_ _N_ _N_ _N_} _N_ _N_ }, [ Int, Integer ] 2 { _A_ 2 _U_ 21 _N_ _S_ "LU(P)" {_A_ 2 _U_ 22 _N_ _N_ _N_ _N_} _N_ _N_ }, [ Int, (Ratio Integer) ] 2 { _A_ 2 _U_ 21 _N_ _S_ "LU(P)" {_A_ 2 _U_ 22 _N_ _N_ _N_ _N_} _N_ _N_ }, [ Int, (Complex Double) ] 2 { _A_ 2 _U_ 21 _N_ _S_ "LU(P)" {_A_ 2 _U_ 22 _N_ _N_ _N_ _N_} _N_ _N_ } #-}
+ {-# GHC_PRAGMA _A_ 2 _U_ 2122 _N_ _S_ "LU(U(LU(U(U(SL)LLLLLLL)LLLL)L)LLLLLLLLLLL)" _N_ _SPECIALISE_ [ Int, Double ] 2 { _A_ 2 _U_ 21 _N_ _S_ "LU(P)" {_A_ 2 _U_ 22 _N_ _N_ _N_ _N_} _N_ _N_ }, [ Int, Int ] 2 { _A_ 2 _U_ 21 _N_ _S_ "LU(P)" {_A_ 2 _U_ 22 _N_ _N_ _N_ _N_} _N_ _N_ }, [ Int, Integer ] 2 { _A_ 2 _U_ 21 _N_ _S_ "LU(P)" {_A_ 2 _U_ 22 _N_ _N_ _N_ _N_} _N_ _N_ }, [ Int, (Ratio Integer) ] 2 { _A_ 2 _U_ 21 _N_ _S_ "LU(P)" {_A_ 2 _U_ 22 _N_ _N_ _N_ _N_} _N_ _N_ }, [ Int, (Complex Double) ] 2 { _A_ 2 _U_ 21 _N_ _S_ "LU(P)" {_A_ 2 _U_ 22 _N_ _N_ _N_ _N_} _N_ _N_ }, [ Integer, Integer ] 2 { _A_ 2 _U_ 21 _N_ _S_ "LU(PPP)" {_A_ 4 _U_ 2222 _N_ _N_ _N_ _N_} _N_ _N_ } #-}
(^^) :: (Fractional b, Integral a) => b -> a -> b
- {-# GHC_PRAGMA _A_ 2 _U_ 2122 _N_ _S_ "LU(LU(U(AAASAAAA)AAA)AALAAAALAA)" {_A_ 5 _U_ 2212222 _N_ _N_ _N_ _N_} _N_ _SPECIALISE_ [ Int, Double ] 2 { _A_ 2 _U_ 21 _N_ _S_ "LU(P)" {_A_ 2 _U_ 22 _N_ _N_ _N_ _N_} _N_ _N_ }, [ Int, (Ratio Integer) ] 2 { _A_ 2 _U_ 21 _N_ _S_ "LU(P)" {_A_ 2 _U_ 22 _N_ _N_ _N_ _N_} _N_ _N_ } #-}
+ {-# GHC_PRAGMA _A_ 2 _U_ 2222 _N_ _S_ "LU(LU(U(LLLSLLLL)LLL)LLLLLLLLLL)" _N_ _SPECIALISE_ [ Int, Double ] 2 { _A_ 2 _U_ 21 _N_ _S_ "LU(P)" {_A_ 2 _U_ 22 _N_ _N_ _N_ _N_} _N_ _N_ }, [ Int, (Ratio Integer) ] 2 { _A_ 2 _U_ 21 _N_ _S_ "LU(P)" {_A_ 2 _U_ 22 _N_ _N_ _N_ _N_} _N_ _N_ }, [ Int, (Complex Double) ] 2 { _A_ 2 _U_ 21 _N_ _S_ "LU(P)" {_A_ 2 _U_ 22 _N_ _N_ _N_ _N_} _N_ _N_ } #-}
appendBin :: Bin -> Bin -> Bin
- {-# GHC_PRAGMA _A_ 2 _U_ 22 _N_ _S_ _!_ _F_ _IF_ARGS_ 0 2 XX 4 \ (u0 :: Bin) (u1 :: Bin) -> _APP_ _TYAPP_ error { (Bin -> Bin -> Bin) } [ _NOREP_S_ "appendBin{Prelude}\n", u0, u1 ] _N_ #-}
+ {-# GHC_PRAGMA _A_ 2 _U_ 22 _N_ _S_ _!_ _N_ _N_ #-}
asTypeOf :: a -> a -> a
{-# GHC_PRAGMA _A_ 2 _U_ 10 _N_ _N_ _F_ _IF_ARGS_ 1 0 X 1 _/\_ u0 -> _TYAPP_ _TYAPP_ _ORIG_ Prelude const { u0 } { u0 } _N_ #-}
atan2 :: RealFloat a => a -> a -> a
{-# GHC_PRAGMA _A_ 2 _U_ 10 _N_ _S_ "SA" {_A_ 1 _U_ 1 _N_ _N_ _F_ _IF_ARGS_ 2 1 X 1 _/\_ u0 u1 -> \ (u2 :: u1) -> u2 _N_} _F_ _IF_ARGS_ 2 2 XX 1 _/\_ u0 u1 -> \ (u2 :: u1) (u3 :: u0) -> u2 _N_ #-}
flip :: (b -> a -> c) -> a -> b -> c
{-# GHC_PRAGMA _A_ 3 _U_ 122 _N_ _S_ "SLL" _F_ _IF_ARGS_ 3 3 XXX 3 _/\_ u0 u1 u2 -> \ (u3 :: u1 -> u0 -> u2) (u4 :: u0) (u5 :: u1) -> _APP_ u3 [ u5, u4 ] _N_ #-}
+fromChar# :: Char# -> Char
+ {-# GHC_PRAGMA _A_ 1 _U_ 2 _N_ _S_ "P" _F_ _IF_ARGS_ 0 1 X 2 \ (u0 :: Char#) -> _!_ C# [] [u0] _N_ #-}
+fromInt# :: Int# -> Int
+ {-# GHC_PRAGMA _A_ 1 _U_ 2 _N_ _S_ "P" _F_ _IF_ARGS_ 0 1 X 2 \ (u0 :: Int#) -> _!_ I# [] [u0] _N_ #-}
fromIntegral :: (Integral a, Num b) => a -> b
- {-# GHC_PRAGMA _A_ 3 _U_ 112 _N_ _S_ "LU(AAAAAAAASA)L" {_A_ 3 _U_ 112 _N_ _N_ _F_ _IF_ARGS_ 2 3 CXX 6 _/\_ u0 u1 -> \ (u2 :: {{Integral u0}}) (u3 :: Integer -> u1) (u4 :: u0) -> let {(uh :: Integer) = case u2 of { _ALG_ _TUP_12 (u5 :: {{Real u0}}) (u6 :: {{Ix u0}}) (u7 :: u0 -> u0 -> u0) (u8 :: u0 -> u0 -> u0) (u9 :: u0 -> u0 -> u0) (ua :: u0 -> u0 -> u0) (ub :: u0 -> u0 -> (u0, u0)) (uc :: u0 -> u0 -> (u0, u0)) (ud :: u0 -> Bool) (ue :: u0 -> Bool) (uf :: u0 -> Integer) (ug :: u0 -> Int) -> _APP_ uf [ u4 ]; _NO_DEFLT_ }} in _APP_ u3 [ uh ] _N_} _F_ _IF_ARGS_ 2 3 CCX 7 _/\_ u0 u1 -> \ (u2 :: {{Integral u0}}) (u3 :: {{Num u1}}) (u4 :: u0) -> let {(uh :: Integer) = case u2 of { _ALG_ _TUP_12 (u5 :: {{Real u0}}) (u6 :: {{Ix u0}}) (u7 :: u0 -> u0 -> u0) (u8 :: u0 -> u0 -> u0) (u9 :: u0 -> u0 -> u0) (ua :: u0 -> u0 -> u0) (ub :: u0 -> u0 -> (u0, u0)) (uc :: u0 -> u0 -> (u0, u0)) (ud :: u0 -> Bool) (ue :: u0 -> Bool) (uf :: u0 -> Integer) (ug :: u0 -> Int) -> _APP_ uf [ u4 ]; _NO_DEFLT_ }} in case u3 of { _ALG_ _TUP_10 (ui :: {{Eq u1}}) (uj :: {{Text u1}}) (uk :: u1 -> u1 -> u1) (ul :: u1 -> u1 -> u1) (um :: u1 -> u1 -> u1) (un :: u1 -> u1) (uo :: u1 -> u1) (up :: u1 -> u1) (uq :: Integer -> u1) (ur :: Int -> u1) -> _APP_ uq [ uh ]; _NO_DEFLT_ } _SPECIALISE_ [ Int, Double ] 2 { _A_ 1 _U_ 1 _N_ _S_ "U(P)" {_A_ 1 _U_ 2 _N_ _N_ _F_ _IF_ARGS_ 0 1 X 3 \ (u0 :: Int#) -> case _#_ int2Double# [] [u0] of { _PRIM_ (u1 :: Double#) -> _!_ D# [] [u1] } _N_} _F_ _IF_ARGS_ 0 1 C 4 \ (u0 :: Int) -> case u0 of { _ALG_ I# (u1 :: Int#) -> case _#_ int2Double# [] [u1] of { _PRIM_ (u2 :: Double#) -> _!_ D# [] [u2] }; _NO_DEFLT_ } _N_ }, [ Int, Int ] 2 { _A_ 1 _U_ 1 _N_ _N_ _F_ _IF_ARGS_ 0 0 X 1 _TYAPP_ _ORIG_ Prelude id { Int } _N_ }, [ Int, Integer ] 2 { _A_ 1 _U_ 1 _N_ _S_ "U(P)" {_A_ 1 _U_ 2 _N_ _N_ _F_ _IF_ARGS_ 0 1 X 1 \ (u0 :: Int#) -> _#_ int2Integer# [] [u0] _N_} _F_ _IF_ARGS_ 0 1 C 2 \ (u0 :: Int) -> case u0 of { _ALG_ I# (u1 :: Int#) -> _#_ int2Integer# [] [u1]; _NO_DEFLT_ } _N_ }, [ Integer, Double ] 2 { _A_ 1 _U_ 1 _N_ _S_ "U(PPP)" {_A_ 3 _U_ 222 _N_ _N_ _F_ _IF_ARGS_ 0 3 XXX 3 \ (u0 :: Int#) (u1 :: Int#) (u2 :: ByteArray#) -> case _#_ encodeDouble# [] [u0, u1, u2, 0#] of { _PRIM_ (u3 :: Double#) -> _!_ D# [] [u3] } _N_} _F_ _IF_ARGS_ 0 1 C 4 \ (u0 :: Integer) -> case u0 of { _ALG_ J# (u1 :: Int#) (u2 :: Int#) (u3 :: ByteArray#) -> case _#_ encodeDouble# [] [u1, u2, u3, 0#] of { _PRIM_ (u4 :: Double#) -> _!_ D# [] [u4] }; _NO_DEFLT_ } _N_ }, [ Integer, Int ] 2 { _A_ 1 _U_ 1 _N_ _S_ "U(PPP)" {_A_ 3 _U_ 222 _N_ _N_ _F_ _IF_ARGS_ 0 3 XXX 3 \ (u0 :: Int#) (u1 :: Int#) (u2 :: ByteArray#) -> case _#_ integer2Int# [] [u0, u1, u2] of { _PRIM_ (u3 :: Int#) -> _!_ I# [] [u3] } _N_} _F_ _IF_ARGS_ 0 1 C 4 \ (u0 :: Integer) -> case u0 of { _ALG_ J# (u1 :: Int#) (u2 :: Int#) (u3 :: ByteArray#) -> case _#_ integer2Int# [] [u1, u2, u3] of { _PRIM_ (u4 :: Int#) -> _!_ I# [] [u4] }; _NO_DEFLT_ } _N_ }, [ Integer, Integer ] 2 { _A_ 1 _U_ 1 _N_ _N_ _F_ _IF_ARGS_ 0 0 X 1 _TYAPP_ _ORIG_ Prelude id { Integer } _N_ } #-}
+ {-# GHC_PRAGMA _A_ 3 _U_ 112 _N_ _S_ "LU(AAAAAAAASA)L" {_A_ 3 _U_ 112 _N_ _N_ _F_ _IF_ARGS_ 2 3 CXX 6 _/\_ u0 u1 -> \ (u2 :: {{Integral u0}}) (u3 :: Integer -> u1) (u4 :: u0) -> let {(uh :: Integer) = case u2 of { _ALG_ _TUP_12 (u5 :: {{Real u0}}) (u6 :: {{Ix u0}}) (u7 :: u0 -> u0 -> u0) (u8 :: u0 -> u0 -> u0) (u9 :: u0 -> u0 -> u0) (ua :: u0 -> u0 -> u0) (ub :: u0 -> u0 -> (u0, u0)) (uc :: u0 -> u0 -> (u0, u0)) (ud :: u0 -> Bool) (ue :: u0 -> Bool) (uf :: u0 -> Integer) (ug :: u0 -> Int) -> _APP_ uf [ u4 ]; _NO_DEFLT_ }} in _APP_ u3 [ uh ] _N_} _F_ _IF_ARGS_ 2 3 CCX 7 _/\_ u0 u1 -> \ (u2 :: {{Integral u0}}) (u3 :: {{Num u1}}) (u4 :: u0) -> let {(uh :: Integer) = case u2 of { _ALG_ _TUP_12 (u5 :: {{Real u0}}) (u6 :: {{Ix u0}}) (u7 :: u0 -> u0 -> u0) (u8 :: u0 -> u0 -> u0) (u9 :: u0 -> u0 -> u0) (ua :: u0 -> u0 -> u0) (ub :: u0 -> u0 -> (u0, u0)) (uc :: u0 -> u0 -> (u0, u0)) (ud :: u0 -> Bool) (ue :: u0 -> Bool) (uf :: u0 -> Integer) (ug :: u0 -> Int) -> _APP_ uf [ u4 ]; _NO_DEFLT_ }} in case u3 of { _ALG_ _TUP_10 (ui :: {{Eq u1}}) (uj :: {{Text u1}}) (uk :: u1 -> u1 -> u1) (ul :: u1 -> u1 -> u1) (um :: u1 -> u1 -> u1) (un :: u1 -> u1) (uo :: u1 -> u1) (up :: u1 -> u1) (uq :: Integer -> u1) (ur :: Int -> u1) -> _APP_ uq [ uh ]; _NO_DEFLT_ } _SPECIALISE_ [ Int, Double ] 2 { _A_ 1 _U_ 1 _N_ _S_ "U(P)" {_A_ 1 _U_ 2 _N_ _N_ _F_ _IF_ARGS_ 0 1 X 3 \ (u0 :: Int#) -> case _#_ int2Double# [] [u0] of { _PRIM_ (u1 :: Double#) -> _!_ D# [] [u1] } _N_} _F_ _IF_ARGS_ 0 1 C 4 \ (u0 :: Int) -> case u0 of { _ALG_ I# (u1 :: Int#) -> case _#_ int2Double# [] [u1] of { _PRIM_ (u2 :: Double#) -> _!_ D# [] [u2] }; _NO_DEFLT_ } _N_ }, [ Int, Float ] 2 { _A_ 1 _U_ 1 _N_ _S_ "U(P)" {_A_ 1 _U_ 2 _N_ _N_ _F_ _IF_ARGS_ 0 1 X 3 \ (u0 :: Int#) -> case _#_ int2Float# [] [u0] of { _PRIM_ (u1 :: Float#) -> _!_ F# [] [u1] } _N_} _F_ _IF_ARGS_ 0 1 C 4 \ (u0 :: Int) -> case u0 of { _ALG_ I# (u1 :: Int#) -> case _#_ int2Float# [] [u1] of { _PRIM_ (u2 :: Float#) -> _!_ F# [] [u2] }; _NO_DEFLT_ } _N_ }, [ Int, Int ] 2 { _A_ 1 _U_ 1 _N_ _N_ _F_ _IF_ARGS_ 0 0 X 1 _TYAPP_ _ORIG_ Prelude id { Int } _N_ }, [ Int, Integer ] 2 { _A_ 1 _U_ 1 _N_ _S_ "U(P)" {_A_ 1 _U_ 2 _N_ _N_ _F_ _IF_ARGS_ 0 1 X 1 \ (u0 :: Int#) -> _#_ int2Integer# [] [u0] _N_} _F_ _IF_ARGS_ 0 1 C 2 \ (u0 :: Int) -> case u0 of { _ALG_ I# (u1 :: Int#) -> _#_ int2Integer# [] [u1]; _NO_DEFLT_ } _N_ }, [ Int, (Ratio Integer) ] 2 { _A_ 1 _U_ 1 _N_ _N_ _N_ _N_ }, [ Integer, Double ] 2 { _A_ 1 _U_ 1 _N_ _S_ "U(PPP)" {_A_ 3 _U_ 222 _N_ _N_ _F_ _IF_ARGS_ 0 3 XXX 3 \ (u0 :: Int#) (u1 :: Int#) (u2 :: ByteArray#) -> case _#_ encodeDouble# [] [u0, u1, u2, 0#] of { _PRIM_ (u3 :: Double#) -> _!_ D# [] [u3] } _N_} _F_ _IF_ARGS_ 0 1 C 4 \ (u0 :: Integer) -> case u0 of { _ALG_ J# (u1 :: Int#) (u2 :: Int#) (u3 :: ByteArray#) -> case _#_ encodeDouble# [] [u1, u2, u3, 0#] of { _PRIM_ (u4 :: Double#) -> _!_ D# [] [u4] }; _NO_DEFLT_ } _N_ }, [ Integer, Float ] 2 { _A_ 1 _U_ 1 _N_ _S_ "U(PPP)" {_A_ 3 _U_ 222 _N_ _N_ _F_ _IF_ARGS_ 0 3 XXX 3 \ (u0 :: Int#) (u1 :: Int#) (u2 :: ByteArray#) -> case _#_ encodeFloat# [] [u0, u1, u2, 0#] of { _PRIM_ (u3 :: Float#) -> _!_ F# [] [u3] } _N_} _F_ _IF_ARGS_ 0 1 C 4 \ (u0 :: Integer) -> case u0 of { _ALG_ J# (u1 :: Int#) (u2 :: Int#) (u3 :: ByteArray#) -> case _#_ encodeFloat# [] [u1, u2, u3, 0#] of { _PRIM_ (u4 :: Float#) -> _!_ F# [] [u4] }; _NO_DEFLT_ } _N_ }, [ Integer, Int ] 2 { _A_ 1 _U_ 1 _N_ _S_ "U(PPP)" {_A_ 3 _U_ 222 _N_ _N_ _F_ _IF_ARGS_ 0 3 XXX 3 \ (u0 :: Int#) (u1 :: Int#) (u2 :: ByteArray#) -> case _#_ integer2Int# [] [u0, u1, u2] of { _PRIM_ (u3 :: Int#) -> _!_ I# [] [u3] } _N_} _F_ _IF_ARGS_ 0 1 C 4 \ (u0 :: Integer) -> case u0 of { _ALG_ J# (u1 :: Int#) (u2 :: Int#) (u3 :: ByteArray#) -> case _#_ integer2Int# [] [u1, u2, u3] of { _PRIM_ (u4 :: Int#) -> _!_ I# [] [u4] }; _NO_DEFLT_ } _N_ }, [ Integer, Integer ] 2 { _A_ 1 _U_ 1 _N_ _N_ _F_ _IF_ARGS_ 0 0 X 1 _TYAPP_ _ORIG_ Prelude id { Integer } _N_ }, [ Integer, (Ratio Integer) ] 2 { _A_ 1 _U_ 2 _N_ _N_ _F_ _IF_ARGS_ 0 1 X 3 \ (u0 :: Integer) -> _!_ (:%) [Integer] [u0, _SPEC_ _ORIG_ PreludeCore __i1 [ (Integer) ]] _N_ } #-}
fromRealFrac :: (RealFrac a, Fractional b) => a -> b
- {-# GHC_PRAGMA _A_ 3 _U_ 112 _N_ _S_ "LU(AAAS)L" {_A_ 3 _U_ 112 _N_ _N_ _F_ _IF_ARGS_ 2 3 CXX 7 _/\_ u0 u1 -> \ (u2 :: {{RealFrac u0}}) (u3 :: Ratio Integer -> u1) (u4 :: u0) -> let {(uf :: Ratio Integer) = case u2 of { _ALG_ _TUP_7 (u5 :: {{Real u0}}) (u6 :: {{Fractional u0}}) (u7 :: _forall_ a$z1 =>{{Integral a$z1}} -> u0 -> (a$z1, u0)) (u8 :: _forall_ a$z1 =>{{Integral a$z1}} -> u0 -> a$z1) (u9 :: _forall_ a$z1 =>{{Integral a$z1}} -> u0 -> a$z1) (ua :: _forall_ a$z1 =>{{Integral a$z1}} -> u0 -> a$z1) (ub :: _forall_ a$z1 =>{{Integral a$z1}} -> u0 -> a$z1) -> case u5 of { _ALG_ _TUP_3 (uc :: {{Num u0}}) (ud :: {{Enum u0}}) (ue :: u0 -> Ratio Integer) -> _APP_ ue [ u4 ]; _NO_DEFLT_ }; _NO_DEFLT_ }} in _APP_ u3 [ uf ] _N_} _F_ _IF_ARGS_ 2 3 CCX 8 _/\_ u0 u1 -> \ (u2 :: {{RealFrac u0}}) (u3 :: {{Fractional u1}}) (u4 :: u0) -> let {(uf :: Ratio Integer) = case u2 of { _ALG_ _TUP_7 (u5 :: {{Real u0}}) (u6 :: {{Fractional u0}}) (u7 :: _forall_ a$z1 =>{{Integral a$z1}} -> u0 -> (a$z1, u0)) (u8 :: _forall_ a$z1 =>{{Integral a$z1}} -> u0 -> a$z1) (u9 :: _forall_ a$z1 =>{{Integral a$z1}} -> u0 -> a$z1) (ua :: _forall_ a$z1 =>{{Integral a$z1}} -> u0 -> a$z1) (ub :: _forall_ a$z1 =>{{Integral a$z1}} -> u0 -> a$z1) -> case u5 of { _ALG_ _TUP_3 (uc :: {{Num u0}}) (ud :: {{Enum u0}}) (ue :: u0 -> Ratio Integer) -> _APP_ ue [ u4 ]; _NO_DEFLT_ }; _NO_DEFLT_ }} in case u3 of { _ALG_ _TUP_4 (ug :: {{Num u1}}) (uh :: u1 -> u1 -> u1) (ui :: u1 -> u1) (uj :: Ratio Integer -> u1) -> _APP_ uj [ uf ]; _NO_DEFLT_ } _SPECIALISE_ [ Double, Double ] 2 { _A_ 1 _U_ 1 _N_ _N_ _F_ _IF_ARGS_ 0 0 X 1 _TYAPP_ _ORIG_ Prelude id { Double } _N_ }, [ Double, Float ] 2 { _A_ 1 _U_ 1 _N_ _S_ "U(P)" {_A_ 1 _U_ 2 _N_ _N_ _F_ _IF_ARGS_ 0 1 X 3 \ (u0 :: Double#) -> case _#_ double2Float# [] [u0] of { _PRIM_ (u1 :: Float#) -> _!_ F# [] [u1] } _N_} _F_ _IF_ARGS_ 0 1 C 4 \ (u0 :: Double) -> case u0 of { _ALG_ D# (u1 :: Double#) -> case _#_ double2Float# [] [u1] of { _PRIM_ (u2 :: Float#) -> _!_ F# [] [u2] }; _NO_DEFLT_ } _N_ }, [ Float, Double ] 2 { _A_ 1 _U_ 1 _N_ _S_ "U(P)" {_A_ 1 _U_ 2 _N_ _N_ _F_ _IF_ARGS_ 0 1 X 3 \ (u0 :: Float#) -> case _#_ float2Double# [] [u0] of { _PRIM_ (u1 :: Double#) -> _!_ D# [] [u1] } _N_} _F_ _IF_ARGS_ 0 1 C 4 \ (u0 :: Float) -> case u0 of { _ALG_ F# (u1 :: Float#) -> case _#_ float2Double# [] [u1] of { _PRIM_ (u2 :: Double#) -> _!_ D# [] [u2] }; _NO_DEFLT_ } _N_ }, [ Float, Float ] 2 { _A_ 1 _U_ 1 _N_ _N_ _F_ _IF_ARGS_ 0 0 X 1 _TYAPP_ _ORIG_ Prelude id { Float } _N_ } #-}
+ {-# GHC_PRAGMA _A_ 3 _U_ 112 _N_ _S_ "LU(AAAS)L" {_A_ 3 _U_ 112 _N_ _N_ _F_ _IF_ARGS_ 2 3 CXX 7 _/\_ u0 u1 -> \ (u2 :: {{RealFrac u0}}) (u3 :: Ratio Integer -> u1) (u4 :: u0) -> let {(uf :: Ratio Integer) = case u2 of { _ALG_ _TUP_7 (u5 :: {{Real u0}}) (u6 :: {{Fractional u0}}) (u7 :: _forall_ a$z1 =>{{Integral a$z1}} -> u0 -> (a$z1, u0)) (u8 :: _forall_ a$z1 =>{{Integral a$z1}} -> u0 -> a$z1) (u9 :: _forall_ a$z1 =>{{Integral a$z1}} -> u0 -> a$z1) (ua :: _forall_ a$z1 =>{{Integral a$z1}} -> u0 -> a$z1) (ub :: _forall_ a$z1 =>{{Integral a$z1}} -> u0 -> a$z1) -> case u5 of { _ALG_ _TUP_3 (uc :: {{Num u0}}) (ud :: {{Enum u0}}) (ue :: u0 -> Ratio Integer) -> _APP_ ue [ u4 ]; _NO_DEFLT_ }; _NO_DEFLT_ }} in _APP_ u3 [ uf ] _N_} _F_ _IF_ARGS_ 2 3 CCX 8 _/\_ u0 u1 -> \ (u2 :: {{RealFrac u0}}) (u3 :: {{Fractional u1}}) (u4 :: u0) -> let {(uf :: Ratio Integer) = case u2 of { _ALG_ _TUP_7 (u5 :: {{Real u0}}) (u6 :: {{Fractional u0}}) (u7 :: _forall_ a$z1 =>{{Integral a$z1}} -> u0 -> (a$z1, u0)) (u8 :: _forall_ a$z1 =>{{Integral a$z1}} -> u0 -> a$z1) (u9 :: _forall_ a$z1 =>{{Integral a$z1}} -> u0 -> a$z1) (ua :: _forall_ a$z1 =>{{Integral a$z1}} -> u0 -> a$z1) (ub :: _forall_ a$z1 =>{{Integral a$z1}} -> u0 -> a$z1) -> case u5 of { _ALG_ _TUP_3 (uc :: {{Num u0}}) (ud :: {{Enum u0}}) (ue :: u0 -> Ratio Integer) -> _APP_ ue [ u4 ]; _NO_DEFLT_ }; _NO_DEFLT_ }} in case u3 of { _ALG_ _TUP_4 (ug :: {{Num u1}}) (uh :: u1 -> u1 -> u1) (ui :: u1 -> u1) (uj :: Ratio Integer -> u1) -> _APP_ uj [ uf ]; _NO_DEFLT_ } _SPECIALISE_ [ Double, Double ] 2 { _A_ 1 _U_ 1 _N_ _N_ _F_ _IF_ARGS_ 0 0 X 1 _TYAPP_ _ORIG_ Prelude id { Double } _N_ }, [ Double, Float ] 2 { _A_ 1 _U_ 1 _N_ _S_ "U(P)" {_A_ 1 _U_ 2 _N_ _N_ _F_ _IF_ARGS_ 0 1 X 3 \ (u0 :: Double#) -> case _#_ double2Float# [] [u0] of { _PRIM_ (u1 :: Float#) -> _!_ F# [] [u1] } _N_} _F_ _IF_ARGS_ 0 1 C 4 \ (u0 :: Double) -> case u0 of { _ALG_ D# (u1 :: Double#) -> case _#_ double2Float# [] [u1] of { _PRIM_ (u2 :: Float#) -> _!_ F# [] [u2] }; _NO_DEFLT_ } _N_ }, [ Double, (Ratio Integer) ] 2 { _A_ 1 _U_ 1 _N_ _S_ "U(P)" {_A_ 1 _U_ 2 _N_ _N_ _N_ _N_} _N_ _N_ }, [ Float, Double ] 2 { _A_ 1 _U_ 1 _N_ _S_ "U(P)" {_A_ 1 _U_ 2 _N_ _N_ _F_ _IF_ARGS_ 0 1 X 3 \ (u0 :: Float#) -> case _#_ float2Double# [] [u0] of { _PRIM_ (u1 :: Double#) -> _!_ D# [] [u1] } _N_} _F_ _IF_ARGS_ 0 1 C 4 \ (u0 :: Float) -> case u0 of { _ALG_ F# (u1 :: Float#) -> case _#_ float2Double# [] [u1] of { _PRIM_ (u2 :: Double#) -> _!_ D# [] [u2] }; _NO_DEFLT_ } _N_ }, [ Float, Float ] 2 { _A_ 1 _U_ 1 _N_ _N_ _F_ _IF_ARGS_ 0 0 X 1 _TYAPP_ _ORIG_ Prelude id { Float } _N_ }, [ Float, (Ratio Integer) ] 2 { _A_ 1 _U_ 1 _N_ _S_ "U(P)" {_A_ 1 _U_ 2 _N_ _N_ _N_ _N_} _N_ _N_ }, [ (Ratio Integer), Double ] 2 { _A_ 1 _U_ 1 _N_ _S_ "U(U(PPP)U(PPP))" {_A_ 4 _U_ 2222 _N_ _N_ _N_ _N_} _N_ _N_ }, [ (Ratio Integer), Float ] 2 { _A_ 1 _U_ 2 _N_ _N_ _F_ _IF_ARGS_ 0 0 X 1 _CONSTM_ Fractional fromRational (Float) _N_ }, [ (Ratio Integer), (Ratio Integer) ] 2 { _A_ 1 _U_ 1 _N_ _N_ _F_ _IF_ARGS_ 0 0 X 1 _TYAPP_ _ORIG_ Prelude id { (Ratio Integer) } _N_ } #-}
fst :: (b, a) -> b
{-# GHC_PRAGMA _A_ 1 _U_ 1 _N_ _S_ "U(SA)" {_A_ 1 _U_ 1 _N_ _N_ _F_ _IF_ARGS_ 2 1 X 1 _/\_ u0 u1 -> \ (u2 :: u1) -> u2 _N_} _F_ _IF_ARGS_ 2 1 C 2 _/\_ u0 u1 -> \ (u2 :: (u1, u0)) -> case u2 of { _ALG_ _TUP_2 (u3 :: u1) (u4 :: u0) -> u3; _NO_DEFLT_ } _N_ #-}
gcd :: Integral a => a -> a -> a
{-# GHC_PRAGMA _A_ 1 _U_ 1 _N_ _S_ "S" _F_ _IF_ARGS_ 1 1 X 1 _/\_ u0 -> \ (u1 :: u0) -> u1 _N_ #-}
isAlpha :: Char -> Bool
{-# GHC_PRAGMA _A_ 1 _U_ 1 _N_ _S_ "U(P)" {_A_ 1 _U_ 2 _N_ _N_ _N_ _N_} _N_ _N_ #-}
+isAlpha# :: Char# -> Bool
+ {-# GHC_PRAGMA _A_ 1 _U_ 2 _N_ _S_ "P" _N_ _N_ #-}
isAlphanum :: Char -> Bool
{-# GHC_PRAGMA _A_ 1 _U_ 1 _N_ _S_ "U(P)" {_A_ 1 _U_ 2 _N_ _N_ _N_ _N_} _N_ _N_ #-}
+isAlphanum# :: Char# -> Bool
+ {-# GHC_PRAGMA _A_ 1 _U_ 2 _N_ _S_ "P" _N_ _N_ #-}
isAscii :: Char -> Bool
{-# GHC_PRAGMA _A_ 1 _U_ 1 _N_ _S_ "U(P)" {_A_ 1 _U_ 2 _N_ _N_ _F_ _IF_ARGS_ 0 1 X 2 \ (u0 :: Char#) -> case _#_ ord# [] [u0] of { _PRIM_ (u1 :: Int#) -> _#_ ltInt# [] [u1, 128#] } _N_} _F_ _IF_ARGS_ 0 1 C 3 \ (u0 :: Char) -> case u0 of { _ALG_ C# (u1 :: Char#) -> case _#_ ord# [] [u1] of { _PRIM_ (u2 :: Int#) -> _#_ ltInt# [] [u2, 128#] }; _NO_DEFLT_ } _N_ #-}
+isAscii# :: Char# -> Bool
+ {-# GHC_PRAGMA _A_ 1 _U_ 2 _N_ _S_ "P" _F_ _IF_ARGS_ 0 1 X 2 \ (u0 :: Char#) -> case _#_ ord# [] [u0] of { _PRIM_ (u1 :: Int#) -> _#_ ltInt# [] [u1, 128#] } _N_ #-}
isControl :: Char -> Bool
{-# GHC_PRAGMA _A_ 1 _U_ 1 _N_ _S_ "U(P)" {_A_ 1 _U_ 2 _N_ _N_ _N_ _N_} _N_ _N_ #-}
+isControl# :: Char# -> Bool
+ {-# GHC_PRAGMA _A_ 1 _U_ 2 _N_ _S_ "P" _N_ _N_ #-}
isDigit :: Char -> Bool
{-# GHC_PRAGMA _A_ 1 _U_ 1 _N_ _S_ "U(P)" {_A_ 1 _U_ 2 _N_ _N_ _N_ _N_} _N_ _N_ #-}
+isDigit# :: Char# -> Bool
+ {-# GHC_PRAGMA _A_ 1 _U_ 2 _N_ _S_ "P" _N_ _N_ #-}
isLower :: Char -> Bool
{-# GHC_PRAGMA _A_ 1 _U_ 1 _N_ _S_ "U(P)" {_A_ 1 _U_ 2 _N_ _N_ _N_ _N_} _N_ _N_ #-}
+isLower# :: Char# -> Bool
+ {-# GHC_PRAGMA _A_ 1 _U_ 2 _N_ _S_ "P" _N_ _N_ #-}
isNullBin :: Bin -> Bool
- {-# GHC_PRAGMA _A_ 1 _U_ 2 _N_ _S_ _!_ _F_ _IF_ARGS_ 0 1 X 3 \ (u0 :: Bin) -> _APP_ _TYAPP_ error { (Bin -> Bool) } [ _NOREP_S_ "isNullBin{Prelude}\n", u0 ] _N_ #-}
+ {-# GHC_PRAGMA _A_ 1 _U_ 2 _N_ _S_ _!_ _N_ _N_ #-}
isPrint :: Char -> Bool
{-# GHC_PRAGMA _A_ 1 _U_ 1 _N_ _S_ "U(P)" {_A_ 1 _U_ 2 _N_ _N_ _N_ _N_} _N_ _N_ #-}
+isPrint# :: Char# -> Bool
+ {-# GHC_PRAGMA _A_ 1 _U_ 2 _N_ _S_ "P" _N_ _N_ #-}
isSpace :: Char -> Bool
{-# GHC_PRAGMA _A_ 1 _U_ 1 _N_ _S_ "U(P)" {_A_ 1 _U_ 1 _N_ _N_ _N_ _N_} _N_ _N_ #-}
+isSpace# :: Char# -> Bool
+ {-# GHC_PRAGMA _A_ 1 _U_ 1 _N_ _S_ "P" _N_ _N_ #-}
isUpper :: Char -> Bool
{-# GHC_PRAGMA _A_ 1 _U_ 1 _N_ _S_ "U(P)" {_A_ 1 _U_ 2 _N_ _N_ _N_ _N_} _N_ _N_ #-}
+isUpper# :: Char# -> Bool
+ {-# GHC_PRAGMA _A_ 1 _U_ 2 _N_ _S_ "P" _N_ _N_ #-}
lcm :: Integral a => a -> a -> a
{-# GHC_PRAGMA _A_ 1 _U_ 122 _N_ _S_ "U(U(U(U(SA)AAALALAAL)AA)ALLAAAAAAAA)" {_A_ 3 _U_ 12222 _N_ _N_ _N_ _N_} _N_ _SPECIALISE_ [ Int ] 1 { _A_ 2 _U_ 11 _N_ _S_ "LU(P)" {_A_ 2 _U_ 12 _N_ _N_ _N_ _N_} _N_ _N_ }, [ Integer ] 1 { _A_ 2 _U_ 11 _N_ _S_ "LU(PPP)" {_A_ 4 _U_ 1222 _N_ _N_ _N_ _N_} _N_ _N_ } #-}
maxChar :: Char
{-# GHC_PRAGMA _A_ 0 _N_ _N_ _N_ _F_ _IF_ARGS_ 0 0 X 2 _!_ C# [] ['\o377'#] _N_ #-}
+maxChar# :: Char#
+ {-# GHC_PRAGMA _A_ 0 _N_ _N_ _N_ _F_ _IF_ARGS_ 0 0 X 2 _!_ _Lift [Char#] ['\o377'#] _N_ #-}
maxInt :: Int
{-# GHC_PRAGMA _A_ 0 _N_ _N_ _N_ _F_ _IF_ARGS_ 0 0 X 2 _!_ I# [] [2147483647#] _N_ #-}
+maxInt# :: Int#
+ {-# GHC_PRAGMA _A_ 0 _N_ _N_ _N_ _F_ _IF_ARGS_ 0 0 X 2 _!_ _Lift [Int#] [2147483647#] _N_ #-}
minChar :: Char
{-# GHC_PRAGMA _A_ 0 _N_ _N_ _N_ _F_ _IF_ARGS_ 0 0 X 2 _!_ C# [] ['\o0'#] _N_ #-}
+minChar# :: Char#
+ {-# GHC_PRAGMA _A_ 0 _N_ _N_ _N_ _F_ _IF_ARGS_ 0 0 X 2 _!_ _Lift [Char#] ['\o0'#] _N_ #-}
minInt :: Int
{-# GHC_PRAGMA _A_ 0 _N_ _N_ _N_ _F_ _IF_ARGS_ 0 0 X 2 _!_ I# [] [-2147483647#] _N_ #-}
+minInt# :: Int#
+ {-# GHC_PRAGMA _A_ 0 _N_ _N_ _N_ _F_ _IF_ARGS_ 0 0 X 2 _!_ _Lift [Int#] [-2147483647#] _N_ #-}
not :: Bool -> Bool
{-# GHC_PRAGMA _A_ 1 _U_ 1 _N_ _S_ "E" _F_ _ALWAYS_ \ (u0 :: Bool) -> case u0 of { _ALG_ True -> _!_ False [] []; False -> _!_ True [] []; _NO_DEFLT_ } _N_ #-}
nullBin :: Bin
- {-# GHC_PRAGMA _A_ 0 _N_ _N_ _S_ _!_ _F_ _IF_ARGS_ 0 0 X 2 _APP_ _TYAPP_ error { Bin } [ _NOREP_S_ "nullBin{Prelude}\n" ] _N_ #-}
+ {-# GHC_PRAGMA _A_ 0 _N_ _N_ _S_ _!_ _N_ _N_ #-}
ord :: Char -> Int
{-# GHC_PRAGMA _A_ 1 _U_ 1 _N_ _S_ "U(P)" {_A_ 1 _U_ 2 _N_ _N_ _F_ _IF_ARGS_ 0 1 X 3 \ (u0 :: Char#) -> case _#_ ord# [] [u0] of { _PRIM_ (u1 :: Int#) -> _!_ I# [] [u1] } _N_} _F_ _IF_ARGS_ 0 1 C 4 \ (u0 :: Char) -> case u0 of { _ALG_ C# (u1 :: Char#) -> case _#_ ord# [] [u1] of { _PRIM_ (u2 :: Int#) -> _!_ I# [] [u2] }; _NO_DEFLT_ } _N_ #-}
otherwise :: Bool
snd :: (a, b) -> b
{-# GHC_PRAGMA _A_ 1 _U_ 1 _N_ _S_ "U(AS)" {_A_ 1 _U_ 1 _N_ _N_ _F_ _IF_ARGS_ 2 1 X 1 _/\_ u0 u1 -> \ (u2 :: u1) -> u2 _N_} _F_ _IF_ARGS_ 2 1 C 2 _/\_ u0 u1 -> \ (u2 :: (u0, u1)) -> case u2 of { _ALG_ _TUP_2 (u3 :: u0) (u4 :: u1) -> u4; _NO_DEFLT_ } _N_ #-}
subtract :: Num a => a -> a -> a
- {-# GHC_PRAGMA _A_ 3 _U_ 122 _N_ _S_ "U(AAASAAAAAA)LL" {_A_ 3 _U_ 122 _N_ _N_ _F_ _IF_ARGS_ 1 3 XXX 3 _/\_ u0 -> \ (u1 :: u0 -> u0 -> u0) (u2 :: u0) (u3 :: u0) -> _APP_ u1 [ u3, u2 ] _N_} _F_ _IF_ARGS_ 1 3 CXX 4 _/\_ u0 -> \ (u1 :: {{Num u0}}) (u2 :: u0) (u3 :: u0) -> case u1 of { _ALG_ _TUP_10 (u4 :: {{Eq u0}}) (u5 :: {{Text u0}}) (u6 :: u0 -> u0 -> u0) (u7 :: u0 -> u0 -> u0) (u8 :: u0 -> u0 -> u0) (u9 :: u0 -> u0) (ua :: u0 -> u0) (ub :: u0 -> u0) (uc :: Integer -> u0) (ud :: Int -> u0) -> _APP_ u7 [ u3, u2 ]; _NO_DEFLT_ } _SPECIALISE_ [ Double ] 1 { _A_ 2 _U_ 11 _N_ _S_ "U(P)U(P)" {_A_ 2 _U_ 22 _N_ _N_ _F_ _IF_ARGS_ 0 2 XX 3 \ (u0 :: Double#) (u1 :: Double#) -> case _#_ minusDouble# [] [u1, u0] of { _PRIM_ (u2 :: Double#) -> _!_ D# [] [u2] } _N_} _F_ _IF_ARGS_ 0 2 CC 5 \ (u0 :: Double) (u1 :: Double) -> case u1 of { _ALG_ D# (u2 :: Double#) -> case u0 of { _ALG_ D# (u3 :: Double#) -> case _#_ minusDouble# [] [u2, u3] of { _PRIM_ (u4 :: Double#) -> _!_ D# [] [u4] }; _NO_DEFLT_ }; _NO_DEFLT_ } _N_ }, [ Int ] 1 { _A_ 2 _U_ 11 _N_ _S_ "U(P)U(P)" {_A_ 2 _U_ 22 _N_ _N_ _F_ _IF_ARGS_ 0 2 XX 3 \ (u0 :: Int#) (u1 :: Int#) -> case _#_ minusInt# [] [u1, u0] of { _PRIM_ (u2 :: Int#) -> _!_ I# [] [u2] } _N_} _F_ _IF_ARGS_ 0 2 CC 5 \ (u0 :: Int) (u1 :: Int) -> case u1 of { _ALG_ I# (u2 :: Int#) -> case u0 of { _ALG_ I# (u3 :: Int#) -> case _#_ minusInt# [] [u2, u3] of { _PRIM_ (u4 :: Int#) -> _!_ I# [] [u4] }; _NO_DEFLT_ }; _NO_DEFLT_ } _N_ } #-}
+ {-# GHC_PRAGMA _A_ 3 _U_ 122 _N_ _S_ "U(AAASAAAAAA)LL" {_A_ 3 _U_ 122 _N_ _N_ _F_ _IF_ARGS_ 1 3 XXX 3 _/\_ u0 -> \ (u1 :: u0 -> u0 -> u0) (u2 :: u0) (u3 :: u0) -> _APP_ u1 [ u3, u2 ] _N_} _F_ _IF_ARGS_ 1 3 CXX 4 _/\_ u0 -> \ (u1 :: {{Num u0}}) (u2 :: u0) (u3 :: u0) -> case u1 of { _ALG_ _TUP_10 (u4 :: {{Eq u0}}) (u5 :: {{Text u0}}) (u6 :: u0 -> u0 -> u0) (u7 :: u0 -> u0 -> u0) (u8 :: u0 -> u0 -> u0) (u9 :: u0 -> u0) (ua :: u0 -> u0) (ub :: u0 -> u0) (uc :: Integer -> u0) (ud :: Int -> u0) -> _APP_ u7 [ u3, u2 ]; _NO_DEFLT_ } _SPECIALISE_ [ Double ] 1 { _A_ 2 _U_ 11 _N_ _S_ "U(P)U(P)" {_A_ 2 _U_ 22 _N_ _N_ _F_ _IF_ARGS_ 0 2 XX 3 \ (u0 :: Double#) (u1 :: Double#) -> case _#_ minusDouble# [] [u1, u0] of { _PRIM_ (u2 :: Double#) -> _!_ D# [] [u2] } _N_} _F_ _IF_ARGS_ 0 2 CC 5 \ (u0 :: Double) (u1 :: Double) -> case u1 of { _ALG_ D# (u2 :: Double#) -> case u0 of { _ALG_ D# (u3 :: Double#) -> case _#_ minusDouble# [] [u2, u3] of { _PRIM_ (u4 :: Double#) -> _!_ D# [] [u4] }; _NO_DEFLT_ }; _NO_DEFLT_ } _N_ }, [ Int ] 1 { _A_ 2 _U_ 11 _N_ _S_ "U(P)U(P)" {_A_ 2 _U_ 22 _N_ _N_ _F_ _IF_ARGS_ 0 2 XX 3 \ (u0 :: Int#) (u1 :: Int#) -> case _#_ minusInt# [] [u1, u0] of { _PRIM_ (u2 :: Int#) -> _!_ I# [] [u2] } _N_} _F_ _IF_ARGS_ 0 2 CC 5 \ (u0 :: Int) (u1 :: Int) -> case u1 of { _ALG_ I# (u2 :: Int#) -> case u0 of { _ALG_ I# (u3 :: Int#) -> case _#_ minusInt# [] [u2, u3] of { _PRIM_ (u4 :: Int#) -> _!_ I# [] [u4] }; _NO_DEFLT_ }; _NO_DEFLT_ } _N_ }, [ (Complex Double) ] 1 { _A_ 2 _U_ 11 _N_ _S_ "U(LL)U(LL)" {_A_ 4 _U_ 2222 _N_ _N_ _N_ _N_} _N_ _N_ } #-}
+toChar# :: Char -> Char#
+ {-# GHC_PRAGMA _A_ 1 _U_ 1 _N_ _S_ "U(P)" {_A_ 1 _U_ 1 _N_ _N_ _F_ _IF_ARGS_ 0 1 X 1 \ (u0 :: Char#) -> u0 _N_} _F_ _IF_ARGS_ 0 1 C 2 \ (u0 :: Char) -> case u0 of { _ALG_ C# (u1 :: Char#) -> u1; _NO_DEFLT_ } _N_ #-}
+toInt# :: Int -> Int#
+ {-# GHC_PRAGMA _A_ 1 _U_ 1 _N_ _S_ "U(P)" {_A_ 1 _U_ 1 _N_ _N_ _F_ _IF_ARGS_ 0 1 X 1 \ (u0 :: Int#) -> u0 _N_} _F_ _IF_ARGS_ 0 1 C 2 \ (u0 :: Int) -> case u0 of { _ALG_ I# (u1 :: Int#) -> u1; _NO_DEFLT_ } _N_ #-}
toLower :: Char -> Char
{-# GHC_PRAGMA _A_ 1 _U_ 1 _N_ _S_ "U(P)" {_A_ 1 _U_ 2 _N_ _N_ _N_ _N_} _N_ _N_ #-}
+toLower# :: Char# -> Char#
+ {-# GHC_PRAGMA _A_ 1 _U_ 2 _N_ _S_ "P" _N_ _N_ #-}
toUpper :: Char -> Char
{-# GHC_PRAGMA _A_ 1 _U_ 1 _N_ _S_ "U(P)" {_A_ 1 _U_ 2 _N_ _N_ _N_ _N_} _N_ _N_ #-}
+toUpper# :: Char# -> Char#
+ {-# GHC_PRAGMA _A_ 1 _U_ 2 _N_ _S_ "P" _N_ _N_ #-}
until :: (a -> Bool) -> (a -> a) -> a -> a
{-# GHC_PRAGMA _A_ 3 _U_ 222 _N_ _S_ "SLL" _N_ _N_ #-}
(||) :: Bool -> Bool -> Bool
-{-# GHC_PRAGMA INTERFACE VERSION 5 #-}
+{-# GHC_PRAGMA INTERFACE VERSION 6 #-}
interface Prelude where
import PreludeArray((!), (//), Array, Assoc, _ByteArray, accum, accumArray, amap, array, assocs, bounds, elems, indices, ixmap, listArray)
import PreludeBuiltin(Bin, Char(..), Int(..), Integer(..), List(..), Tuple0, Tuple2, Tuple3, Tuple4, Tuple5, Tuple6, Tuple7, _Addr(..), _RealWorld(..), _State(..))
import PreludeComplex(Complex, cis, conjugate, imagPart, magnitude, mkPolar, phase, polar, realPart)
-import PreludeCore(Bool(..), Eq(..), Fractional(..), Integral(..), Ix(..), Num(..), Ord(..), Real(..), RealFloat(..), RealFrac(..), Text(..), _ceiling, _floor, _readList, _round, _showList, _showRational, _truncate)
+import PreludeCore(Bool(..), Eq(..), Fractional(..), Integral(..), Ix(..), Num(..), Ord(..), Real(..), RealFloat(..), RealFrac(..), Text(..), _readList, _showList, _showRational)
import PreludeIO(IOError, Request, Response, SigAct, abort, appendBinChan, appendBinFile, appendChan, appendFile, binDispatch, deleteFile, done, echo, exit, getArgs, getEnv, getProgName, interact, print, prints, readBinChan, readBinFile, readChan, readFile, setEnv, sigAction, statusChan, statusFile, stdecho, stderr, stdin, stdout, strDispatch, strListDispatch, succDispatch, writeBinFile, writeFile)
import PreludeList((!!), (++), (\\), all, and, any, break, concat, cycle, drop, dropWhile, elem, filter, foldl1, foldr1, genericLength, head, init, iterate, last, length, lines, map, maximum, minimum, notElem, nub, null, or, partition, product, products, repeat, reverse, scanl, scanl1, scanr, scanr1, span, splitAt, sum, sums, tail, take, takeWhile, transpose, unlines, unwords, unzip, unzip3, unzip4, unzip5, unzip6, unzip7, words, zip, zip3, zip4, zip5, zip6, zip7, zipWith, zipWith3, zipWith4, zipWith5, zipWith6, zipWith7)
import PreludePS(_PackedString, _appendPS, _breakPS, _byteArrayToPS, _concatPS, _consPS, _dropPS, _dropWhilePS, _filterPS, _foldlPS, _foldrPS, _headPS, _indexPS, _lengthPS, _linesPS, _mapPS, _nilPS, _nullPS, _packCBytes, _packCString, _packString, _psToByteArray, _putPS, _reversePS, _spanPS, _splitAtPS, _substrPS, _tailPS, _takePS, _takeWhilePS, _unpackPS, _wordsPS)
(.) :: (a -> c) -> (b -> a) -> b -> c
{-# GHC_PRAGMA _A_ 3 _U_ 112 _N_ _S_ "SLL" _F_ _ALWAYS_ _/\_ u0 u1 u2 -> \ (u3 :: u0 -> u2) (u4 :: u1 -> u0) (u5 :: u1) -> let {(u6 :: u0) = _APP_ u4 [ u5 ]} in _APP_ u3 [ u6 ] _N_ #-}
(^) :: (Num b, Integral a) => b -> a -> b
- {-# GHC_PRAGMA _A_ 2 _U_ 2122 _N_ _S_ "LU(U(LU(U(U(SA)AALAAAA)AAAA)A)AAALAAAALAA)" {_A_ 5 _U_ 2212222 _N_ _N_ _N_ _N_} _N_ _SPECIALISE_ [ Int, Double ] 2 { _A_ 2 _U_ 21 _N_ _S_ "LU(P)" {_A_ 2 _U_ 22 _N_ _N_ _N_ _N_} _N_ _N_ }, [ Int, Int ] 2 { _A_ 2 _U_ 21 _N_ _S_ "LU(P)" {_A_ 2 _U_ 22 _N_ _N_ _N_ _N_} _N_ _N_ }, [ Int, Integer ] 2 { _A_ 2 _U_ 21 _N_ _S_ "LU(P)" {_A_ 2 _U_ 22 _N_ _N_ _N_ _N_} _N_ _N_ }, [ Int, (Ratio Integer) ] 2 { _A_ 2 _U_ 21 _N_ _S_ "LU(P)" {_A_ 2 _U_ 22 _N_ _N_ _N_ _N_} _N_ _N_ }, [ Int, (Complex Double) ] 2 { _A_ 2 _U_ 21 _N_ _S_ "LU(P)" {_A_ 2 _U_ 22 _N_ _N_ _N_ _N_} _N_ _N_ } #-}
+ {-# GHC_PRAGMA _A_ 2 _U_ 2122 _N_ _S_ "LU(U(LU(U(U(SL)LLLLLLL)LLLL)L)LLLLLLLLLLL)" _N_ _SPECIALISE_ [ Int, Double ] 2 { _A_ 2 _U_ 21 _N_ _S_ "LU(P)" {_A_ 2 _U_ 22 _N_ _N_ _N_ _N_} _N_ _N_ }, [ Int, Int ] 2 { _A_ 2 _U_ 21 _N_ _S_ "LU(P)" {_A_ 2 _U_ 22 _N_ _N_ _N_ _N_} _N_ _N_ }, [ Int, Integer ] 2 { _A_ 2 _U_ 21 _N_ _S_ "LU(P)" {_A_ 2 _U_ 22 _N_ _N_ _N_ _N_} _N_ _N_ }, [ Int, (Ratio Integer) ] 2 { _A_ 2 _U_ 21 _N_ _S_ "LU(P)" {_A_ 2 _U_ 22 _N_ _N_ _N_ _N_} _N_ _N_ }, [ Int, (Complex Double) ] 2 { _A_ 2 _U_ 21 _N_ _S_ "LU(P)" {_A_ 2 _U_ 22 _N_ _N_ _N_ _N_} _N_ _N_ }, [ Integer, Integer ] 2 { _A_ 2 _U_ 21 _N_ _S_ "LU(PPP)" {_A_ 4 _U_ 2222 _N_ _N_ _N_ _N_} _N_ _N_ } #-}
(^^) :: (Fractional b, Integral a) => b -> a -> b
- {-# GHC_PRAGMA _A_ 2 _U_ 2122 _N_ _S_ "LU(LU(U(AAASAAAA)AAA)AALAAAALAA)" {_A_ 5 _U_ 2212222 _N_ _N_ _N_ _N_} _N_ _SPECIALISE_ [ Int, Double ] 2 { _A_ 2 _U_ 21 _N_ _S_ "LU(P)" {_A_ 2 _U_ 22 _N_ _N_ _N_ _N_} _N_ _N_ }, [ Int, (Ratio Integer) ] 2 { _A_ 2 _U_ 21 _N_ _S_ "LU(P)" {_A_ 2 _U_ 22 _N_ _N_ _N_ _N_} _N_ _N_ } #-}
+ {-# GHC_PRAGMA _A_ 2 _U_ 2222 _N_ _S_ "LU(LU(U(LLLSLLLL)LLL)LLLLLLLLLL)" _N_ _SPECIALISE_ [ Int, Double ] 2 { _A_ 2 _U_ 21 _N_ _S_ "LU(P)" {_A_ 2 _U_ 22 _N_ _N_ _N_ _N_} _N_ _N_ }, [ Int, (Ratio Integer) ] 2 { _A_ 2 _U_ 21 _N_ _S_ "LU(P)" {_A_ 2 _U_ 22 _N_ _N_ _N_ _N_} _N_ _N_ }, [ Int, (Complex Double) ] 2 { _A_ 2 _U_ 21 _N_ _S_ "LU(P)" {_A_ 2 _U_ 22 _N_ _N_ _N_ _N_} _N_ _N_ } #-}
appendBin :: Bin -> Bin -> Bin
- {-# GHC_PRAGMA _A_ 2 _U_ 22 _N_ _S_ _!_ _F_ _IF_ARGS_ 0 2 XX 4 \ (u0 :: Bin) (u1 :: Bin) -> _APP_ _TYAPP_ error { (Bin -> Bin -> Bin) } [ _NOREP_S_ "appendBin{Prelude}\n", u0, u1 ] _N_ #-}
+ {-# GHC_PRAGMA _A_ 2 _U_ 22 _N_ _S_ _!_ _N_ _N_ #-}
asTypeOf :: a -> a -> a
{-# GHC_PRAGMA _A_ 2 _U_ 10 _N_ _N_ _F_ _IF_ARGS_ 1 0 X 1 _/\_ u0 -> _TYAPP_ _TYAPP_ _ORIG_ Prelude const { u0 } { u0 } _N_ #-}
atan2 :: RealFloat a => a -> a -> a
flip :: (b -> a -> c) -> a -> b -> c
{-# GHC_PRAGMA _A_ 3 _U_ 122 _N_ _S_ "SLL" _F_ _IF_ARGS_ 3 3 XXX 3 _/\_ u0 u1 u2 -> \ (u3 :: u1 -> u0 -> u2) (u4 :: u0) (u5 :: u1) -> _APP_ u3 [ u5, u4 ] _N_ #-}
fromIntegral :: (Integral a, Num b) => a -> b
- {-# GHC_PRAGMA _A_ 3 _U_ 112 _N_ _S_ "LU(AAAAAAAASA)L" {_A_ 3 _U_ 112 _N_ _N_ _F_ _IF_ARGS_ 2 3 CXX 6 _/\_ u0 u1 -> \ (u2 :: {{Integral u0}}) (u3 :: Integer -> u1) (u4 :: u0) -> let {(uh :: Integer) = case u2 of { _ALG_ _TUP_12 (u5 :: {{Real u0}}) (u6 :: {{Ix u0}}) (u7 :: u0 -> u0 -> u0) (u8 :: u0 -> u0 -> u0) (u9 :: u0 -> u0 -> u0) (ua :: u0 -> u0 -> u0) (ub :: u0 -> u0 -> (u0, u0)) (uc :: u0 -> u0 -> (u0, u0)) (ud :: u0 -> Bool) (ue :: u0 -> Bool) (uf :: u0 -> Integer) (ug :: u0 -> Int) -> _APP_ uf [ u4 ]; _NO_DEFLT_ }} in _APP_ u3 [ uh ] _N_} _F_ _IF_ARGS_ 2 3 CCX 7 _/\_ u0 u1 -> \ (u2 :: {{Integral u0}}) (u3 :: {{Num u1}}) (u4 :: u0) -> let {(uh :: Integer) = case u2 of { _ALG_ _TUP_12 (u5 :: {{Real u0}}) (u6 :: {{Ix u0}}) (u7 :: u0 -> u0 -> u0) (u8 :: u0 -> u0 -> u0) (u9 :: u0 -> u0 -> u0) (ua :: u0 -> u0 -> u0) (ub :: u0 -> u0 -> (u0, u0)) (uc :: u0 -> u0 -> (u0, u0)) (ud :: u0 -> Bool) (ue :: u0 -> Bool) (uf :: u0 -> Integer) (ug :: u0 -> Int) -> _APP_ uf [ u4 ]; _NO_DEFLT_ }} in case u3 of { _ALG_ _TUP_10 (ui :: {{Eq u1}}) (uj :: {{Text u1}}) (uk :: u1 -> u1 -> u1) (ul :: u1 -> u1 -> u1) (um :: u1 -> u1 -> u1) (un :: u1 -> u1) (uo :: u1 -> u1) (up :: u1 -> u1) (uq :: Integer -> u1) (ur :: Int -> u1) -> _APP_ uq [ uh ]; _NO_DEFLT_ } _SPECIALISE_ [ Int, Double ] 2 { _A_ 1 _U_ 1 _N_ _S_ "U(P)" {_A_ 1 _U_ 2 _N_ _N_ _F_ _IF_ARGS_ 0 1 X 3 \ (u0 :: Int#) -> case _#_ int2Double# [] [u0] of { _PRIM_ (u1 :: Double#) -> _!_ D# [] [u1] } _N_} _F_ _IF_ARGS_ 0 1 C 4 \ (u0 :: Int) -> case u0 of { _ALG_ I# (u1 :: Int#) -> case _#_ int2Double# [] [u1] of { _PRIM_ (u2 :: Double#) -> _!_ D# [] [u2] }; _NO_DEFLT_ } _N_ }, [ Int, Int ] 2 { _A_ 1 _U_ 1 _N_ _N_ _F_ _IF_ARGS_ 0 0 X 1 _TYAPP_ _ORIG_ Prelude id { Int } _N_ }, [ Int, Integer ] 2 { _A_ 1 _U_ 1 _N_ _S_ "U(P)" {_A_ 1 _U_ 2 _N_ _N_ _F_ _IF_ARGS_ 0 1 X 1 \ (u0 :: Int#) -> _#_ int2Integer# [] [u0] _N_} _F_ _IF_ARGS_ 0 1 C 2 \ (u0 :: Int) -> case u0 of { _ALG_ I# (u1 :: Int#) -> _#_ int2Integer# [] [u1]; _NO_DEFLT_ } _N_ }, [ Integer, Double ] 2 { _A_ 1 _U_ 1 _N_ _S_ "U(PPP)" {_A_ 3 _U_ 222 _N_ _N_ _F_ _IF_ARGS_ 0 3 XXX 3 \ (u0 :: Int#) (u1 :: Int#) (u2 :: ByteArray#) -> case _#_ encodeDouble# [] [u0, u1, u2, 0#] of { _PRIM_ (u3 :: Double#) -> _!_ D# [] [u3] } _N_} _F_ _IF_ARGS_ 0 1 C 4 \ (u0 :: Integer) -> case u0 of { _ALG_ J# (u1 :: Int#) (u2 :: Int#) (u3 :: ByteArray#) -> case _#_ encodeDouble# [] [u1, u2, u3, 0#] of { _PRIM_ (u4 :: Double#) -> _!_ D# [] [u4] }; _NO_DEFLT_ } _N_ }, [ Integer, Int ] 2 { _A_ 1 _U_ 1 _N_ _S_ "U(PPP)" {_A_ 3 _U_ 222 _N_ _N_ _F_ _IF_ARGS_ 0 3 XXX 3 \ (u0 :: Int#) (u1 :: Int#) (u2 :: ByteArray#) -> case _#_ integer2Int# [] [u0, u1, u2] of { _PRIM_ (u3 :: Int#) -> _!_ I# [] [u3] } _N_} _F_ _IF_ARGS_ 0 1 C 4 \ (u0 :: Integer) -> case u0 of { _ALG_ J# (u1 :: Int#) (u2 :: Int#) (u3 :: ByteArray#) -> case _#_ integer2Int# [] [u1, u2, u3] of { _PRIM_ (u4 :: Int#) -> _!_ I# [] [u4] }; _NO_DEFLT_ } _N_ }, [ Integer, Integer ] 2 { _A_ 1 _U_ 1 _N_ _N_ _F_ _IF_ARGS_ 0 0 X 1 _TYAPP_ _ORIG_ Prelude id { Integer } _N_ } #-}
+ {-# GHC_PRAGMA _A_ 3 _U_ 112 _N_ _S_ "LU(AAAAAAAASA)L" {_A_ 3 _U_ 112 _N_ _N_ _F_ _IF_ARGS_ 2 3 CXX 6 _/\_ u0 u1 -> \ (u2 :: {{Integral u0}}) (u3 :: Integer -> u1) (u4 :: u0) -> let {(uh :: Integer) = case u2 of { _ALG_ _TUP_12 (u5 :: {{Real u0}}) (u6 :: {{Ix u0}}) (u7 :: u0 -> u0 -> u0) (u8 :: u0 -> u0 -> u0) (u9 :: u0 -> u0 -> u0) (ua :: u0 -> u0 -> u0) (ub :: u0 -> u0 -> (u0, u0)) (uc :: u0 -> u0 -> (u0, u0)) (ud :: u0 -> Bool) (ue :: u0 -> Bool) (uf :: u0 -> Integer) (ug :: u0 -> Int) -> _APP_ uf [ u4 ]; _NO_DEFLT_ }} in _APP_ u3 [ uh ] _N_} _F_ _IF_ARGS_ 2 3 CCX 7 _/\_ u0 u1 -> \ (u2 :: {{Integral u0}}) (u3 :: {{Num u1}}) (u4 :: u0) -> let {(uh :: Integer) = case u2 of { _ALG_ _TUP_12 (u5 :: {{Real u0}}) (u6 :: {{Ix u0}}) (u7 :: u0 -> u0 -> u0) (u8 :: u0 -> u0 -> u0) (u9 :: u0 -> u0 -> u0) (ua :: u0 -> u0 -> u0) (ub :: u0 -> u0 -> (u0, u0)) (uc :: u0 -> u0 -> (u0, u0)) (ud :: u0 -> Bool) (ue :: u0 -> Bool) (uf :: u0 -> Integer) (ug :: u0 -> Int) -> _APP_ uf [ u4 ]; _NO_DEFLT_ }} in case u3 of { _ALG_ _TUP_10 (ui :: {{Eq u1}}) (uj :: {{Text u1}}) (uk :: u1 -> u1 -> u1) (ul :: u1 -> u1 -> u1) (um :: u1 -> u1 -> u1) (un :: u1 -> u1) (uo :: u1 -> u1) (up :: u1 -> u1) (uq :: Integer -> u1) (ur :: Int -> u1) -> _APP_ uq [ uh ]; _NO_DEFLT_ } _SPECIALISE_ [ Int, Double ] 2 { _A_ 1 _U_ 1 _N_ _S_ "U(P)" {_A_ 1 _U_ 2 _N_ _N_ _F_ _IF_ARGS_ 0 1 X 3 \ (u0 :: Int#) -> case _#_ int2Double# [] [u0] of { _PRIM_ (u1 :: Double#) -> _!_ D# [] [u1] } _N_} _F_ _IF_ARGS_ 0 1 C 4 \ (u0 :: Int) -> case u0 of { _ALG_ I# (u1 :: Int#) -> case _#_ int2Double# [] [u1] of { _PRIM_ (u2 :: Double#) -> _!_ D# [] [u2] }; _NO_DEFLT_ } _N_ }, [ Int, Float ] 2 { _A_ 1 _U_ 1 _N_ _S_ "U(P)" {_A_ 1 _U_ 2 _N_ _N_ _F_ _IF_ARGS_ 0 1 X 3 \ (u0 :: Int#) -> case _#_ int2Float# [] [u0] of { _PRIM_ (u1 :: Float#) -> _!_ F# [] [u1] } _N_} _F_ _IF_ARGS_ 0 1 C 4 \ (u0 :: Int) -> case u0 of { _ALG_ I# (u1 :: Int#) -> case _#_ int2Float# [] [u1] of { _PRIM_ (u2 :: Float#) -> _!_ F# [] [u2] }; _NO_DEFLT_ } _N_ }, [ Int, Int ] 2 { _A_ 1 _U_ 1 _N_ _N_ _F_ _IF_ARGS_ 0 0 X 1 _TYAPP_ _ORIG_ Prelude id { Int } _N_ }, [ Int, Integer ] 2 { _A_ 1 _U_ 1 _N_ _S_ "U(P)" {_A_ 1 _U_ 2 _N_ _N_ _F_ _IF_ARGS_ 0 1 X 1 \ (u0 :: Int#) -> _#_ int2Integer# [] [u0] _N_} _F_ _IF_ARGS_ 0 1 C 2 \ (u0 :: Int) -> case u0 of { _ALG_ I# (u1 :: Int#) -> _#_ int2Integer# [] [u1]; _NO_DEFLT_ } _N_ }, [ Int, (Ratio Integer) ] 2 { _A_ 1 _U_ 1 _N_ _N_ _N_ _N_ }, [ Integer, Double ] 2 { _A_ 1 _U_ 1 _N_ _S_ "U(PPP)" {_A_ 3 _U_ 222 _N_ _N_ _F_ _IF_ARGS_ 0 3 XXX 3 \ (u0 :: Int#) (u1 :: Int#) (u2 :: ByteArray#) -> case _#_ encodeDouble# [] [u0, u1, u2, 0#] of { _PRIM_ (u3 :: Double#) -> _!_ D# [] [u3] } _N_} _F_ _IF_ARGS_ 0 1 C 4 \ (u0 :: Integer) -> case u0 of { _ALG_ J# (u1 :: Int#) (u2 :: Int#) (u3 :: ByteArray#) -> case _#_ encodeDouble# [] [u1, u2, u3, 0#] of { _PRIM_ (u4 :: Double#) -> _!_ D# [] [u4] }; _NO_DEFLT_ } _N_ }, [ Integer, Float ] 2 { _A_ 1 _U_ 1 _N_ _S_ "U(PPP)" {_A_ 3 _U_ 222 _N_ _N_ _F_ _IF_ARGS_ 0 3 XXX 3 \ (u0 :: Int#) (u1 :: Int#) (u2 :: ByteArray#) -> case _#_ encodeFloat# [] [u0, u1, u2, 0#] of { _PRIM_ (u3 :: Float#) -> _!_ F# [] [u3] } _N_} _F_ _IF_ARGS_ 0 1 C 4 \ (u0 :: Integer) -> case u0 of { _ALG_ J# (u1 :: Int#) (u2 :: Int#) (u3 :: ByteArray#) -> case _#_ encodeFloat# [] [u1, u2, u3, 0#] of { _PRIM_ (u4 :: Float#) -> _!_ F# [] [u4] }; _NO_DEFLT_ } _N_ }, [ Integer, Int ] 2 { _A_ 1 _U_ 1 _N_ _S_ "U(PPP)" {_A_ 3 _U_ 222 _N_ _N_ _F_ _IF_ARGS_ 0 3 XXX 3 \ (u0 :: Int#) (u1 :: Int#) (u2 :: ByteArray#) -> case _#_ integer2Int# [] [u0, u1, u2] of { _PRIM_ (u3 :: Int#) -> _!_ I# [] [u3] } _N_} _F_ _IF_ARGS_ 0 1 C 4 \ (u0 :: Integer) -> case u0 of { _ALG_ J# (u1 :: Int#) (u2 :: Int#) (u3 :: ByteArray#) -> case _#_ integer2Int# [] [u1, u2, u3] of { _PRIM_ (u4 :: Int#) -> _!_ I# [] [u4] }; _NO_DEFLT_ } _N_ }, [ Integer, Integer ] 2 { _A_ 1 _U_ 1 _N_ _N_ _F_ _IF_ARGS_ 0 0 X 1 _TYAPP_ _ORIG_ Prelude id { Integer } _N_ }, [ Integer, (Ratio Integer) ] 2 { _A_ 1 _U_ 2 _N_ _N_ _F_ _IF_ARGS_ 0 1 X 3 \ (u0 :: Integer) -> _!_ (:%) [Integer] [u0, _SPEC_ _ORIG_ PreludeCore __i1 [ (Integer) ]] _N_ } #-}
fromRealFrac :: (RealFrac a, Fractional b) => a -> b
- {-# GHC_PRAGMA _A_ 3 _U_ 112 _N_ _S_ "LU(AAAS)L" {_A_ 3 _U_ 112 _N_ _N_ _F_ _IF_ARGS_ 2 3 CXX 7 _/\_ u0 u1 -> \ (u2 :: {{RealFrac u0}}) (u3 :: Ratio Integer -> u1) (u4 :: u0) -> let {(uf :: Ratio Integer) = case u2 of { _ALG_ _TUP_7 (u5 :: {{Real u0}}) (u6 :: {{Fractional u0}}) (u7 :: _forall_ a$z1 =>{{Integral a$z1}} -> u0 -> (a$z1, u0)) (u8 :: _forall_ a$z1 =>{{Integral a$z1}} -> u0 -> a$z1) (u9 :: _forall_ a$z1 =>{{Integral a$z1}} -> u0 -> a$z1) (ua :: _forall_ a$z1 =>{{Integral a$z1}} -> u0 -> a$z1) (ub :: _forall_ a$z1 =>{{Integral a$z1}} -> u0 -> a$z1) -> case u5 of { _ALG_ _TUP_3 (uc :: {{Num u0}}) (ud :: {{Enum u0}}) (ue :: u0 -> Ratio Integer) -> _APP_ ue [ u4 ]; _NO_DEFLT_ }; _NO_DEFLT_ }} in _APP_ u3 [ uf ] _N_} _F_ _IF_ARGS_ 2 3 CCX 8 _/\_ u0 u1 -> \ (u2 :: {{RealFrac u0}}) (u3 :: {{Fractional u1}}) (u4 :: u0) -> let {(uf :: Ratio Integer) = case u2 of { _ALG_ _TUP_7 (u5 :: {{Real u0}}) (u6 :: {{Fractional u0}}) (u7 :: _forall_ a$z1 =>{{Integral a$z1}} -> u0 -> (a$z1, u0)) (u8 :: _forall_ a$z1 =>{{Integral a$z1}} -> u0 -> a$z1) (u9 :: _forall_ a$z1 =>{{Integral a$z1}} -> u0 -> a$z1) (ua :: _forall_ a$z1 =>{{Integral a$z1}} -> u0 -> a$z1) (ub :: _forall_ a$z1 =>{{Integral a$z1}} -> u0 -> a$z1) -> case u5 of { _ALG_ _TUP_3 (uc :: {{Num u0}}) (ud :: {{Enum u0}}) (ue :: u0 -> Ratio Integer) -> _APP_ ue [ u4 ]; _NO_DEFLT_ }; _NO_DEFLT_ }} in case u3 of { _ALG_ _TUP_4 (ug :: {{Num u1}}) (uh :: u1 -> u1 -> u1) (ui :: u1 -> u1) (uj :: Ratio Integer -> u1) -> _APP_ uj [ uf ]; _NO_DEFLT_ } _SPECIALISE_ [ Double, Double ] 2 { _A_ 1 _U_ 1 _N_ _N_ _F_ _IF_ARGS_ 0 0 X 1 _TYAPP_ _ORIG_ Prelude id { Double } _N_ }, [ Double, Float ] 2 { _A_ 1 _U_ 1 _N_ _S_ "U(P)" {_A_ 1 _U_ 2 _N_ _N_ _F_ _IF_ARGS_ 0 1 X 3 \ (u0 :: Double#) -> case _#_ double2Float# [] [u0] of { _PRIM_ (u1 :: Float#) -> _!_ F# [] [u1] } _N_} _F_ _IF_ARGS_ 0 1 C 4 \ (u0 :: Double) -> case u0 of { _ALG_ D# (u1 :: Double#) -> case _#_ double2Float# [] [u1] of { _PRIM_ (u2 :: Float#) -> _!_ F# [] [u2] }; _NO_DEFLT_ } _N_ }, [ Float, Double ] 2 { _A_ 1 _U_ 1 _N_ _S_ "U(P)" {_A_ 1 _U_ 2 _N_ _N_ _F_ _IF_ARGS_ 0 1 X 3 \ (u0 :: Float#) -> case _#_ float2Double# [] [u0] of { _PRIM_ (u1 :: Double#) -> _!_ D# [] [u1] } _N_} _F_ _IF_ARGS_ 0 1 C 4 \ (u0 :: Float) -> case u0 of { _ALG_ F# (u1 :: Float#) -> case _#_ float2Double# [] [u1] of { _PRIM_ (u2 :: Double#) -> _!_ D# [] [u2] }; _NO_DEFLT_ } _N_ }, [ Float, Float ] 2 { _A_ 1 _U_ 1 _N_ _N_ _F_ _IF_ARGS_ 0 0 X 1 _TYAPP_ _ORIG_ Prelude id { Float } _N_ } #-}
+ {-# GHC_PRAGMA _A_ 3 _U_ 112 _N_ _S_ "LU(AAAS)L" {_A_ 3 _U_ 112 _N_ _N_ _F_ _IF_ARGS_ 2 3 CXX 7 _/\_ u0 u1 -> \ (u2 :: {{RealFrac u0}}) (u3 :: Ratio Integer -> u1) (u4 :: u0) -> let {(uf :: Ratio Integer) = case u2 of { _ALG_ _TUP_7 (u5 :: {{Real u0}}) (u6 :: {{Fractional u0}}) (u7 :: _forall_ a$z1 =>{{Integral a$z1}} -> u0 -> (a$z1, u0)) (u8 :: _forall_ a$z1 =>{{Integral a$z1}} -> u0 -> a$z1) (u9 :: _forall_ a$z1 =>{{Integral a$z1}} -> u0 -> a$z1) (ua :: _forall_ a$z1 =>{{Integral a$z1}} -> u0 -> a$z1) (ub :: _forall_ a$z1 =>{{Integral a$z1}} -> u0 -> a$z1) -> case u5 of { _ALG_ _TUP_3 (uc :: {{Num u0}}) (ud :: {{Enum u0}}) (ue :: u0 -> Ratio Integer) -> _APP_ ue [ u4 ]; _NO_DEFLT_ }; _NO_DEFLT_ }} in _APP_ u3 [ uf ] _N_} _F_ _IF_ARGS_ 2 3 CCX 8 _/\_ u0 u1 -> \ (u2 :: {{RealFrac u0}}) (u3 :: {{Fractional u1}}) (u4 :: u0) -> let {(uf :: Ratio Integer) = case u2 of { _ALG_ _TUP_7 (u5 :: {{Real u0}}) (u6 :: {{Fractional u0}}) (u7 :: _forall_ a$z1 =>{{Integral a$z1}} -> u0 -> (a$z1, u0)) (u8 :: _forall_ a$z1 =>{{Integral a$z1}} -> u0 -> a$z1) (u9 :: _forall_ a$z1 =>{{Integral a$z1}} -> u0 -> a$z1) (ua :: _forall_ a$z1 =>{{Integral a$z1}} -> u0 -> a$z1) (ub :: _forall_ a$z1 =>{{Integral a$z1}} -> u0 -> a$z1) -> case u5 of { _ALG_ _TUP_3 (uc :: {{Num u0}}) (ud :: {{Enum u0}}) (ue :: u0 -> Ratio Integer) -> _APP_ ue [ u4 ]; _NO_DEFLT_ }; _NO_DEFLT_ }} in case u3 of { _ALG_ _TUP_4 (ug :: {{Num u1}}) (uh :: u1 -> u1 -> u1) (ui :: u1 -> u1) (uj :: Ratio Integer -> u1) -> _APP_ uj [ uf ]; _NO_DEFLT_ } _SPECIALISE_ [ Double, Double ] 2 { _A_ 1 _U_ 1 _N_ _N_ _F_ _IF_ARGS_ 0 0 X 1 _TYAPP_ _ORIG_ Prelude id { Double } _N_ }, [ Double, Float ] 2 { _A_ 1 _U_ 1 _N_ _S_ "U(P)" {_A_ 1 _U_ 2 _N_ _N_ _F_ _IF_ARGS_ 0 1 X 3 \ (u0 :: Double#) -> case _#_ double2Float# [] [u0] of { _PRIM_ (u1 :: Float#) -> _!_ F# [] [u1] } _N_} _F_ _IF_ARGS_ 0 1 C 4 \ (u0 :: Double) -> case u0 of { _ALG_ D# (u1 :: Double#) -> case _#_ double2Float# [] [u1] of { _PRIM_ (u2 :: Float#) -> _!_ F# [] [u2] }; _NO_DEFLT_ } _N_ }, [ Double, (Ratio Integer) ] 2 { _A_ 1 _U_ 1 _N_ _S_ "U(P)" {_A_ 1 _U_ 2 _N_ _N_ _N_ _N_} _N_ _N_ }, [ Float, Double ] 2 { _A_ 1 _U_ 1 _N_ _S_ "U(P)" {_A_ 1 _U_ 2 _N_ _N_ _F_ _IF_ARGS_ 0 1 X 3 \ (u0 :: Float#) -> case _#_ float2Double# [] [u0] of { _PRIM_ (u1 :: Double#) -> _!_ D# [] [u1] } _N_} _F_ _IF_ARGS_ 0 1 C 4 \ (u0 :: Float) -> case u0 of { _ALG_ F# (u1 :: Float#) -> case _#_ float2Double# [] [u1] of { _PRIM_ (u2 :: Double#) -> _!_ D# [] [u2] }; _NO_DEFLT_ } _N_ }, [ Float, Float ] 2 { _A_ 1 _U_ 1 _N_ _N_ _F_ _IF_ARGS_ 0 0 X 1 _TYAPP_ _ORIG_ Prelude id { Float } _N_ }, [ Float, (Ratio Integer) ] 2 { _A_ 1 _U_ 1 _N_ _S_ "U(P)" {_A_ 1 _U_ 2 _N_ _N_ _N_ _N_} _N_ _N_ }, [ (Ratio Integer), Double ] 2 { _A_ 1 _U_ 1 _N_ _S_ "U(U(PPP)U(PPP))" {_A_ 4 _U_ 2222 _N_ _N_ _N_ _N_} _N_ _N_ }, [ (Ratio Integer), Float ] 2 { _A_ 1 _U_ 2 _N_ _N_ _F_ _IF_ARGS_ 0 0 X 1 _CONSTM_ Fractional fromRational (Float) _N_ }, [ (Ratio Integer), (Ratio Integer) ] 2 { _A_ 1 _U_ 1 _N_ _N_ _F_ _IF_ARGS_ 0 0 X 1 _TYAPP_ _ORIG_ Prelude id { (Ratio Integer) } _N_ } #-}
fst :: (b, a) -> b
{-# GHC_PRAGMA _A_ 1 _U_ 1 _N_ _S_ "U(SA)" {_A_ 1 _U_ 1 _N_ _N_ _F_ _IF_ARGS_ 2 1 X 1 _/\_ u0 u1 -> \ (u2 :: u1) -> u2 _N_} _F_ _IF_ARGS_ 2 1 C 2 _/\_ u0 u1 -> \ (u2 :: (u1, u0)) -> case u2 of { _ALG_ _TUP_2 (u3 :: u1) (u4 :: u0) -> u3; _NO_DEFLT_ } _N_ #-}
gcd :: Integral a => a -> a -> a
isLower :: Char -> Bool
{-# GHC_PRAGMA _A_ 1 _U_ 1 _N_ _S_ "U(P)" {_A_ 1 _U_ 2 _N_ _N_ _N_ _N_} _N_ _N_ #-}
isNullBin :: Bin -> Bool
- {-# GHC_PRAGMA _A_ 1 _U_ 2 _N_ _S_ _!_ _F_ _IF_ARGS_ 0 1 X 3 \ (u0 :: Bin) -> _APP_ _TYAPP_ error { (Bin -> Bool) } [ _NOREP_S_ "isNullBin{Prelude}\n", u0 ] _N_ #-}
+ {-# GHC_PRAGMA _A_ 1 _U_ 2 _N_ _S_ _!_ _N_ _N_ #-}
isPrint :: Char -> Bool
{-# GHC_PRAGMA _A_ 1 _U_ 1 _N_ _S_ "U(P)" {_A_ 1 _U_ 2 _N_ _N_ _N_ _N_} _N_ _N_ #-}
isSpace :: Char -> Bool
not :: Bool -> Bool
{-# GHC_PRAGMA _A_ 1 _U_ 1 _N_ _S_ "E" _F_ _ALWAYS_ \ (u0 :: Bool) -> case u0 of { _ALG_ True -> _!_ False [] []; False -> _!_ True [] []; _NO_DEFLT_ } _N_ #-}
nullBin :: Bin
- {-# GHC_PRAGMA _A_ 0 _N_ _N_ _S_ _!_ _F_ _IF_ARGS_ 0 0 X 2 _APP_ _TYAPP_ error { Bin } [ _NOREP_S_ "nullBin{Prelude}\n" ] _N_ #-}
+ {-# GHC_PRAGMA _A_ 0 _N_ _N_ _S_ _!_ _N_ _N_ #-}
ord :: Char -> Int
{-# GHC_PRAGMA _A_ 1 _U_ 1 _N_ _S_ "U(P)" {_A_ 1 _U_ 2 _N_ _N_ _F_ _IF_ARGS_ 0 1 X 3 \ (u0 :: Char#) -> case _#_ ord# [] [u0] of { _PRIM_ (u1 :: Int#) -> _!_ I# [] [u1] } _N_} _F_ _IF_ARGS_ 0 1 C 4 \ (u0 :: Char) -> case u0 of { _ALG_ C# (u1 :: Char#) -> case _#_ ord# [] [u1] of { _PRIM_ (u2 :: Int#) -> _!_ I# [] [u2] }; _NO_DEFLT_ } _N_ #-}
otherwise :: Bool
snd :: (a, b) -> b
{-# GHC_PRAGMA _A_ 1 _U_ 1 _N_ _S_ "U(AS)" {_A_ 1 _U_ 1 _N_ _N_ _F_ _IF_ARGS_ 2 1 X 1 _/\_ u0 u1 -> \ (u2 :: u1) -> u2 _N_} _F_ _IF_ARGS_ 2 1 C 2 _/\_ u0 u1 -> \ (u2 :: (u0, u1)) -> case u2 of { _ALG_ _TUP_2 (u3 :: u0) (u4 :: u1) -> u4; _NO_DEFLT_ } _N_ #-}
subtract :: Num a => a -> a -> a
- {-# GHC_PRAGMA _A_ 3 _U_ 122 _N_ _S_ "U(AAASAAAAAA)LL" {_A_ 3 _U_ 122 _N_ _N_ _F_ _IF_ARGS_ 1 3 XXX 3 _/\_ u0 -> \ (u1 :: u0 -> u0 -> u0) (u2 :: u0) (u3 :: u0) -> _APP_ u1 [ u3, u2 ] _N_} _F_ _IF_ARGS_ 1 3 CXX 4 _/\_ u0 -> \ (u1 :: {{Num u0}}) (u2 :: u0) (u3 :: u0) -> case u1 of { _ALG_ _TUP_10 (u4 :: {{Eq u0}}) (u5 :: {{Text u0}}) (u6 :: u0 -> u0 -> u0) (u7 :: u0 -> u0 -> u0) (u8 :: u0 -> u0 -> u0) (u9 :: u0 -> u0) (ua :: u0 -> u0) (ub :: u0 -> u0) (uc :: Integer -> u0) (ud :: Int -> u0) -> _APP_ u7 [ u3, u2 ]; _NO_DEFLT_ } _SPECIALISE_ [ Double ] 1 { _A_ 2 _U_ 11 _N_ _S_ "U(P)U(P)" {_A_ 2 _U_ 22 _N_ _N_ _F_ _IF_ARGS_ 0 2 XX 3 \ (u0 :: Double#) (u1 :: Double#) -> case _#_ minusDouble# [] [u1, u0] of { _PRIM_ (u2 :: Double#) -> _!_ D# [] [u2] } _N_} _F_ _IF_ARGS_ 0 2 CC 5 \ (u0 :: Double) (u1 :: Double) -> case u1 of { _ALG_ D# (u2 :: Double#) -> case u0 of { _ALG_ D# (u3 :: Double#) -> case _#_ minusDouble# [] [u2, u3] of { _PRIM_ (u4 :: Double#) -> _!_ D# [] [u4] }; _NO_DEFLT_ }; _NO_DEFLT_ } _N_ }, [ Int ] 1 { _A_ 2 _U_ 11 _N_ _S_ "U(P)U(P)" {_A_ 2 _U_ 22 _N_ _N_ _F_ _IF_ARGS_ 0 2 XX 3 \ (u0 :: Int#) (u1 :: Int#) -> case _#_ minusInt# [] [u1, u0] of { _PRIM_ (u2 :: Int#) -> _!_ I# [] [u2] } _N_} _F_ _IF_ARGS_ 0 2 CC 5 \ (u0 :: Int) (u1 :: Int) -> case u1 of { _ALG_ I# (u2 :: Int#) -> case u0 of { _ALG_ I# (u3 :: Int#) -> case _#_ minusInt# [] [u2, u3] of { _PRIM_ (u4 :: Int#) -> _!_ I# [] [u4] }; _NO_DEFLT_ }; _NO_DEFLT_ } _N_ } #-}
+ {-# GHC_PRAGMA _A_ 3 _U_ 122 _N_ _S_ "U(AAASAAAAAA)LL" {_A_ 3 _U_ 122 _N_ _N_ _F_ _IF_ARGS_ 1 3 XXX 3 _/\_ u0 -> \ (u1 :: u0 -> u0 -> u0) (u2 :: u0) (u3 :: u0) -> _APP_ u1 [ u3, u2 ] _N_} _F_ _IF_ARGS_ 1 3 CXX 4 _/\_ u0 -> \ (u1 :: {{Num u0}}) (u2 :: u0) (u3 :: u0) -> case u1 of { _ALG_ _TUP_10 (u4 :: {{Eq u0}}) (u5 :: {{Text u0}}) (u6 :: u0 -> u0 -> u0) (u7 :: u0 -> u0 -> u0) (u8 :: u0 -> u0 -> u0) (u9 :: u0 -> u0) (ua :: u0 -> u0) (ub :: u0 -> u0) (uc :: Integer -> u0) (ud :: Int -> u0) -> _APP_ u7 [ u3, u2 ]; _NO_DEFLT_ } _SPECIALISE_ [ Double ] 1 { _A_ 2 _U_ 11 _N_ _S_ "U(P)U(P)" {_A_ 2 _U_ 22 _N_ _N_ _F_ _IF_ARGS_ 0 2 XX 3 \ (u0 :: Double#) (u1 :: Double#) -> case _#_ minusDouble# [] [u1, u0] of { _PRIM_ (u2 :: Double#) -> _!_ D# [] [u2] } _N_} _F_ _IF_ARGS_ 0 2 CC 5 \ (u0 :: Double) (u1 :: Double) -> case u1 of { _ALG_ D# (u2 :: Double#) -> case u0 of { _ALG_ D# (u3 :: Double#) -> case _#_ minusDouble# [] [u2, u3] of { _PRIM_ (u4 :: Double#) -> _!_ D# [] [u4] }; _NO_DEFLT_ }; _NO_DEFLT_ } _N_ }, [ Int ] 1 { _A_ 2 _U_ 11 _N_ _S_ "U(P)U(P)" {_A_ 2 _U_ 22 _N_ _N_ _F_ _IF_ARGS_ 0 2 XX 3 \ (u0 :: Int#) (u1 :: Int#) -> case _#_ minusInt# [] [u1, u0] of { _PRIM_ (u2 :: Int#) -> _!_ I# [] [u2] } _N_} _F_ _IF_ARGS_ 0 2 CC 5 \ (u0 :: Int) (u1 :: Int) -> case u1 of { _ALG_ I# (u2 :: Int#) -> case u0 of { _ALG_ I# (u3 :: Int#) -> case _#_ minusInt# [] [u2, u3] of { _PRIM_ (u4 :: Int#) -> _!_ I# [] [u4] }; _NO_DEFLT_ }; _NO_DEFLT_ } _N_ }, [ (Complex Double) ] 1 { _A_ 2 _U_ 11 _N_ _S_ "U(LL)U(LL)" {_A_ 4 _U_ 2222 _N_ _N_ _N_ _N_} _N_ _N_ } #-}
toLower :: Char -> Char
{-# GHC_PRAGMA _A_ 1 _U_ 1 _N_ _S_ "U(P)" {_A_ 1 _U_ 2 _N_ _N_ _N_ _N_} _N_ _N_ #-}
toUpper :: Char -> Char
imagPart :: Complex a -> a
{-# GHC_PRAGMA _A_ 1 _U_ 1 _N_ _S_ "U(AS)" {_A_ 1 _U_ 1 _N_ _N_ _F_ _IF_ARGS_ 1 1 X 1 _/\_ u0 -> \ (u1 :: u0) -> u1 _N_} _F_ _IF_ARGS_ 1 1 C 2 _/\_ u0 -> \ (u1 :: Complex u0) -> case u1 of { _ALG_ (:+) (u2 :: u0) (u3 :: u0) -> u3; _NO_DEFLT_ } _N_ #-}
magnitude :: RealFloat a => Complex a -> a
- {-# GHC_PRAGMA _A_ 1 _U_ 12 _N_ _S_ "U(ALAAAAALAS)" {_A_ 3 _U_ 2221 _N_ _N_ _N_ _N_} _N_ _SPECIALISE_ [ Double ] 1 { _A_ 1 _U_ 1 _N_ _S_ "U(LL)" {_A_ 2 _U_ 22 _N_ _N_ _N_ _N_} _N_ _N_ } #-}
+ {-# GHC_PRAGMA _A_ 1 _U_ 12 _N_ _S_ "U(ALAAAAALAS)" {_A_ 3 _U_ 2221 _N_ _N_ _N_ _N_} _N_ _SPECIALISE_ [ Double ] 1 { _A_ 1 _U_ 1 _N_ _S_ "U(U(P)U(P))" {_A_ 2 _U_ 22 _N_ _N_ _N_ _N_} _N_ _N_ } #-}
mkPolar :: RealFloat a => a -> a -> Complex a
{-# GHC_PRAGMA _A_ 3 _U_ 122 _N_ _N_ _N_ _SPECIALISE_ [ Double ] 1 { _A_ 2 _U_ 22 _N_ _N_ _N_ _N_ } #-}
phase :: RealFloat a => Complex a -> a
{-# GHC_PRAGMA _A_ 1 _U_ 22 _N_ _N_ _N_ _SPECIALISE_ [ Double ] 1 { _A_ 1 _U_ 2 _N_ _N_ _N_ _N_ } #-}
realPart :: Complex a -> a
{-# GHC_PRAGMA _A_ 1 _U_ 1 _N_ _S_ "U(SA)" {_A_ 1 _U_ 1 _N_ _N_ _F_ _IF_ARGS_ 1 1 X 1 _/\_ u0 -> \ (u1 :: u0) -> u1 _N_} _F_ _IF_ARGS_ 1 1 C 2 _/\_ u0 -> \ (u1 :: Complex u0) -> case u1 of { _ALG_ (:+) (u2 :: u0) (u3 :: u0) -> u2; _NO_DEFLT_ } _N_ #-}
-_ceiling :: (RealFrac a, Integral b) => a -> b
- {-# GHC_PRAGMA _A_ 2 _U_ 122 _N_ _S_ "U(U(AU(U(AAAASAAA)AAAA)A)LSAAAA)L" {_A_ 4 _U_ 11122 _N_ _N_ _N_ _N_} _N_ _SPECIALISE_ [ Double, Int ] 2 { _A_ 0 _U_ 2 _N_ _N_ _N_ _N_ } #-}
-_floor :: (RealFrac a, Integral b) => a -> b
- {-# GHC_PRAGMA _A_ 2 _U_ 122 _N_ _S_ "U(U(AU(U(ASAAAAAA)AAAA)A)LSAAAA)L" {_A_ 4 _U_ 11122 _N_ _N_ _N_ _N_} _N_ _SPECIALISE_ [ Double, Int ] 2 { _A_ 0 _U_ 2 _N_ _N_ _N_ _N_ } #-}
-_readList :: Text a => [Char] -> [([a], [Char])]
+_readList :: ([Char] -> [(a, [Char])]) -> [Char] -> [([a], [Char])]
{-# GHC_PRAGMA _A_ 1 _U_ 22 _N_ _N_ _N_ _N_ #-}
-_round :: (RealFrac a, Integral b) => a -> b
- {-# GHC_PRAGMA _A_ 2 _U_ 122 _N_ _S_ "U(U(AU(U(ALAAAAAS)AAAA)A)LSAAAA)L" {_A_ 5 _U_ 112122 _N_ _N_ _N_ _N_} _N_ _SPECIALISE_ [ Double, Int ] 2 { _A_ 0 _U_ 2 _N_ _N_ _N_ _N_ }, [ (Ratio Integer), Integer ] 2 { _A_ 1 _U_ 1 _N_ _S_ "U(LL)" {_A_ 2 _U_ 22 _N_ _N_ _N_ _N_} _N_ _N_ } #-}
-_showList :: Text a => [a] -> [Char] -> [Char]
- {-# GHC_PRAGMA _A_ 1 _U_ 212 _N_ _N_ _N_ _N_ #-}
+_showList :: (a -> [Char] -> [Char]) -> [a] -> [Char] -> [Char]
+ {-# GHC_PRAGMA _A_ 2 _U_ 212 _N_ _S_ "LS" _N_ _N_ #-}
_showRational :: Int -> Ratio Integer -> [Char]
{-# GHC_PRAGMA _A_ 2 _U_ 21 _N_ _S_ "LU(U(PPP)L)" {_A_ 5 _U_ 22222 _N_ _N_ _N_ _N_} _N_ _N_ #-}
-_truncate :: (RealFrac a, Integral b) => a -> b
- {-# GHC_PRAGMA _A_ 2 _U_ 122 _N_ _S_ "U(AASAAAA)L" {_A_ 2 _U_ 122 _N_ _N_ _N_ _N_} _N_ _SPECIALISE_ [ Double, Int ] 2 { _A_ 0 _U_ 2 _N_ _N_ _N_ _N_ } #-}
abort :: IOError -> [Response] -> [Request]
{-# GHC_PRAGMA _A_ 2 _U_ 00 _N_ _S_ "A" {_A_ 1 _U_ 0 _N_ _N_ _F_ _IF_ARGS_ 0 1 X 1 \ (u0 :: [Response]) -> _!_ _NIL_ [Request] [] _N_} _F_ _IF_ARGS_ 0 1 X 1 \ (u0 :: IOError) -> _ORIG_ PreludeIO done _N_ #-}
appendBinChan :: [Char] -> Bin -> (IOError -> [Response] -> [Request]) -> ([Response] -> [Request]) -> [Response] -> [Request]
interact :: ([Char] -> [Char]) -> [Response] -> [Request]
{-# GHC_PRAGMA _A_ 1 _U_ 11 _N_ _N_ _N_ _N_ #-}
print :: Text a => a -> [Response] -> [Request]
- {-# GHC_PRAGMA _A_ 1 _U_ 121 _N_ _N_ _N_ _N_ #-}
+ {-# GHC_PRAGMA _A_ 1 _U_ 121 _N_ _N_ _N_ _SPECIALISE_ [ Bool ] 1 { _A_ 1 _U_ 21 _N_ _N_ _N_ _N_ }, [ Char ] 1 { _A_ 1 _U_ 11 _N_ _N_ _N_ _N_ }, [ Double ] 1 { _A_ 1 _U_ 11 _N_ _N_ _N_ _N_ }, [ Int ] 1 { _A_ 1 _U_ 11 _N_ _N_ _N_ _N_ }, [ Integer ] 1 { _A_ 1 _U_ 11 _N_ _N_ _N_ _N_ }, [ [Char] ] 1 { _A_ 1 _U_ 21 _N_ _N_ _N_ _N_ }, [ [Int] ] 1 { _A_ 1 _U_ 21 _N_ _N_ _N_ _N_ }, [ [[Char]] ] 1 { _A_ 1 _U_ 21 _N_ _N_ _N_ _N_ }, [ [[Int]] ] 1 { _A_ 1 _U_ 21 _N_ _N_ _N_ _N_ }, [ _PackedString ] 1 { _A_ 1 _U_ 21 _N_ _N_ _N_ _N_ }, [ () ] 1 { _A_ 1 _U_ 21 _N_ _N_ _N_ _N_ } #-}
prints :: Text a => a -> [Char] -> [Response] -> [Request]
- {-# GHC_PRAGMA _A_ 1 _U_ 1221 _N_ _N_ _N_ _N_ #-}
+ {-# GHC_PRAGMA _A_ 1 _U_ 1221 _N_ _N_ _N_ _SPECIALISE_ [ Bool ] 1 { _A_ 2 _U_ 221 _N_ _N_ _N_ _N_ }, [ Char ] 1 { _A_ 2 _U_ 121 _N_ _N_ _N_ _N_ }, [ Double ] 1 { _A_ 2 _U_ 121 _N_ _N_ _N_ _N_ }, [ Int ] 1 { _A_ 2 _U_ 121 _N_ _N_ _N_ _N_ }, [ Integer ] 1 { _A_ 2 _U_ 121 _N_ _N_ _N_ _N_ }, [ [Char] ] 1 { _A_ 2 _U_ 221 _N_ _N_ _N_ _N_ }, [ [Int] ] 1 { _A_ 2 _U_ 221 _N_ _N_ _N_ _N_ }, [ [[Char]] ] 1 { _A_ 2 _U_ 121 _N_ _N_ _N_ _N_ }, [ [[Int]] ] 1 { _A_ 2 _U_ 121 _N_ _N_ _N_ _N_ }, [ _PackedString ] 1 { _A_ 2 _U_ 221 _N_ _N_ _N_ _N_ }, [ () ] 1 { _A_ 2 _U_ 121 _N_ _N_ _N_ _N_ } #-}
readBinChan :: [Char] -> (IOError -> [Response] -> [Request]) -> (Bin -> [Response] -> [Request]) -> [Response] -> [Request]
{-# GHC_PRAGMA _A_ 4 _U_ 2111 _N_ _N_ _N_ _N_ #-}
readBinFile :: [Char] -> (IOError -> [Response] -> [Request]) -> (Bin -> [Response] -> [Request]) -> [Response] -> [Request]
(++) :: [a] -> [a] -> [a]
{-# GHC_PRAGMA _A_ 2 _U_ 12 _N_ _S_ "SL" _N_ _N_ #-}
(\\) :: Eq a => [a] -> [a] -> [a]
- {-# GHC_PRAGMA _A_ 3 _U_ 122 _N_ _S_ "LLS" _N_ _N_ #-}
+ {-# GHC_PRAGMA _A_ 3 _U_ 122 _N_ _S_ "LLS" _N_ _SPECIALISE_ [ Int ] 1 { _A_ 2 _U_ 22 _N_ _S_ "LS" _N_ _N_ }, [ [Char] ] 1 { _A_ 2 _U_ 22 _N_ _S_ "LS" _N_ _N_ } #-}
all :: (a -> Bool) -> [a] -> Bool
{-# GHC_PRAGMA _A_ 2 _U_ 21 _N_ _S_ "LS" _F_ _ALWAYS_ _/\_ u0 -> \ (u1 :: u0 -> Bool) (u2 :: [u0]) -> let {(u3 :: Bool) = _!_ True [] []} in let {(u6 :: u0 -> Bool -> Bool) = \ (u4 :: u0) (u5 :: Bool) -> case _APP_ u1 [ u4 ] of { _ALG_ True -> u5; False -> _!_ False [] []; _NO_DEFLT_ }} in _APP_ _TYAPP_ _TYAPP_ foldr { u0 } { Bool } [ u6, u3, u2 ] _N_ #-}
and :: [Bool] -> Bool
dropWhile :: (a -> Bool) -> [a] -> [a]
{-# GHC_PRAGMA _A_ 2 _U_ 21 _N_ _S_ "LS" _N_ _N_ #-}
elem :: Eq a => a -> [a] -> Bool
- {-# GHC_PRAGMA _A_ 3 _U_ 121 _N_ _S_ "LLS" _F_ _ALWAYS_ _/\_ u0 -> \ (u1 :: {{Eq u0}}) (u2 :: u0) (u3 :: [u0]) -> let {(u6 :: u0 -> u0 -> Bool) = case u1 of { _ALG_ _TUP_2 (u4 :: u0 -> u0 -> Bool) (u5 :: u0 -> u0 -> Bool) -> u4; _NO_DEFLT_ }} in let {(u8 :: u0 -> Bool) = \ (u7 :: u0) -> _APP_ u6 [ u2, u7 ]} in _APP_ _TYAPP_ _ORIG_ PreludeList any { u0 } [ u8, u3 ] _SPECIALISE_ [ Char ] 1 { _A_ 2 _U_ 21 _N_ _S_ "LS" _F_ _ALWAYS_ \ (u0 :: Char) (u1 :: [Char]) -> let {(u5 :: Char -> Bool) = \ (u2 :: Char) -> case u0 of { _ALG_ C# (u3 :: Char#) -> case u2 of { _ALG_ C# (u4 :: Char#) -> _#_ eqChar# [] [u3, u4]; _NO_DEFLT_ }; _NO_DEFLT_ }} in _APP_ _TYAPP_ _ORIG_ PreludeList any { Char } [ u5, u1 ] _N_ }, [ Int ] 1 { _A_ 2 _U_ 21 _N_ _S_ "LS" _F_ _ALWAYS_ \ (u0 :: Int) (u1 :: [Int]) -> let {(u5 :: Int -> Bool) = \ (u2 :: Int) -> case u0 of { _ALG_ I# (u3 :: Int#) -> case u2 of { _ALG_ I# (u4 :: Int#) -> _#_ eqInt# [] [u3, u4]; _NO_DEFLT_ }; _NO_DEFLT_ }} in _APP_ _TYAPP_ _ORIG_ PreludeList any { Int } [ u5, u1 ] _N_ }, [ [Char] ] 1 { _A_ 2 _U_ 21 _N_ _S_ "LS" _F_ _ALWAYS_ \ (u0 :: [Char]) (u1 :: [[Char]]) -> let {(u3 :: [Char] -> Bool) = \ (u2 :: [Char]) -> _APP_ _CONSTM_ Eq (==) ([Char]) [ u0, u2 ]} in _APP_ _TYAPP_ _ORIG_ PreludeList any { [Char] } [ u3, u1 ] _N_ } #-}
+ {-# GHC_PRAGMA _A_ 3 _U_ 121 _N_ _S_ "LLS" _F_ _ALWAYS_ _/\_ u0 -> \ (u1 :: {{Eq u0}}) (u2 :: u0) (u3 :: [u0]) -> let {(u6 :: u0 -> u0 -> Bool) = case u1 of { _ALG_ _TUP_2 (u4 :: u0 -> u0 -> Bool) (u5 :: u0 -> u0 -> Bool) -> u4; _NO_DEFLT_ }} in let {(u8 :: u0 -> Bool) = \ (u7 :: u0) -> _APP_ u6 [ u2, u7 ]} in _APP_ _TYAPP_ _ORIG_ PreludeList any { u0 } [ u8, u3 ] _SPECIALISE_ [ Char ] 1 { _A_ 2 _U_ 21 _N_ _S_ "LS" _F_ _ALWAYS_ \ (u0 :: Char) (u1 :: [Char]) -> let {(u5 :: Char -> Bool) = \ (u2 :: Char) -> case u0 of { _ALG_ C# (u3 :: Char#) -> case u2 of { _ALG_ C# (u4 :: Char#) -> _#_ eqChar# [] [u3, u4]; _NO_DEFLT_ }; _NO_DEFLT_ }} in _APP_ _TYAPP_ _ORIG_ PreludeList any { Char } [ u5, u1 ] _N_ }, [ Int ] 1 { _A_ 2 _U_ 21 _N_ _S_ "LS" _F_ _ALWAYS_ \ (u0 :: Int) (u1 :: [Int]) -> let {(u5 :: Int -> Bool) = \ (u2 :: Int) -> case u0 of { _ALG_ I# (u3 :: Int#) -> case u2 of { _ALG_ I# (u4 :: Int#) -> _#_ eqInt# [] [u3, u4]; _NO_DEFLT_ }; _NO_DEFLT_ }} in _APP_ _TYAPP_ _ORIG_ PreludeList any { Int } [ u5, u1 ] _N_ }, [ Integer ] 1 { _A_ 2 _U_ 21 _N_ _S_ "LS" _F_ _ALWAYS_ \ (u0 :: Integer) (u1 :: [Integer]) -> let {(ua :: Integer -> Bool) = \ (u2 :: Integer) -> case u0 of { _ALG_ J# (u3 :: Int#) (u4 :: Int#) (u5 :: ByteArray#) -> case u2 of { _ALG_ J# (u6 :: Int#) (u7 :: Int#) (u8 :: ByteArray#) -> case _#_ cmpInteger# [] [u3, u4, u5, u6, u7, u8] of { _PRIM_ 0# -> _!_ True [] []; (u9 :: Int#) -> _!_ False [] [] }; _NO_DEFLT_ }; _NO_DEFLT_ }} in _APP_ _TYAPP_ _ORIG_ PreludeList any { Integer } [ ua, u1 ] _N_ }, [ [Char] ] 1 { _A_ 2 _U_ 21 _N_ _S_ "LS" _F_ _ALWAYS_ \ (u0 :: [Char]) (u1 :: [[Char]]) -> let {(u3 :: [Char] -> Bool) = \ (u2 :: [Char]) -> _APP_ _CONSTM_ Eq (==) ([Char]) [ u0, u2 ]} in _APP_ _TYAPP_ _ORIG_ PreludeList any { [Char] } [ u3, u1 ] _N_ }, [ [Int] ] 1 { _A_ 2 _U_ 21 _N_ _S_ "LS" _F_ _ALWAYS_ \ (u0 :: [Int]) (u1 :: [[Int]]) -> let {(u3 :: [Int] -> Bool) = \ (u2 :: [Int]) -> _APP_ _CONSTM_ Eq (==) ([Int]) [ u0, u2 ]} in _APP_ _TYAPP_ _ORIG_ PreludeList any { [Int] } [ u3, u1 ] _N_ }, [ (Int, Int) ] 1 { _A_ 2 _U_ 21 _N_ _S_ "LS" _F_ _ALWAYS_ \ (u0 :: (Int, Int)) (u1 :: [(Int, Int)]) -> let {(ub :: (Int, Int) -> Bool) = \ (u2 :: (Int, Int)) -> case u0 of { _ALG_ _TUP_2 (u3 :: Int) (u4 :: Int) -> case u3 of { _ALG_ I# (u5 :: Int#) -> case u2 of { _ALG_ _TUP_2 (u6 :: Int) (u7 :: Int) -> case u6 of { _ALG_ I# (u8 :: Int#) -> case _#_ eqInt# [] [u5, u8] of { _ALG_ True -> case u4 of { _ALG_ I# (u9 :: Int#) -> case u7 of { _ALG_ I# (ua :: Int#) -> _#_ eqInt# [] [u9, ua]; _NO_DEFLT_ }; _NO_DEFLT_ }; False -> _!_ False [] []; _NO_DEFLT_ }; _NO_DEFLT_ }; _NO_DEFLT_ }; _NO_DEFLT_ }; _NO_DEFLT_ }} in _APP_ _TYAPP_ _ORIG_ PreludeList any { (Int, Int) } [ ub, u1 ] _N_ } #-}
filter :: (a -> Bool) -> [a] -> [a]
{-# GHC_PRAGMA _A_ 2 _U_ 21 _N_ _S_ "LS" _F_ _ALWAYS_ _/\_ u0 -> \ (u1 :: u0 -> Bool) (u2 :: [u0]) -> let {(u9 :: _forall_ a$z1 =>(u0 -> a$z1 -> a$z1) -> a$z1 -> a$z1) = _/\_ u3 -> \ (u4 :: u0 -> u3 -> u3) (u5 :: u3) -> let {(u8 :: u0 -> u3 -> u3) = \ (u6 :: u0) (u7 :: u3) -> case _APP_ u1 [ u6 ] of { _ALG_ True -> _APP_ u4 [ u6, u7 ]; False -> u7; _NO_DEFLT_ }} in _APP_ _TYAPP_ _TYAPP_ foldr { u0 } { u3 } [ u8, u5, u2 ]} in _APP_ _TYAPP_ _build { u0 } [ u9 ] _N_ #-}
foldl1 :: (a -> a -> a) -> [a] -> a
foldr1 :: (a -> a -> a) -> [a] -> a
{-# GHC_PRAGMA _A_ 2 _U_ 21 _N_ _S_ "LS" _N_ _N_ #-}
genericLength :: Num b => [a] -> b
- {-# GHC_PRAGMA _A_ 1 _U_ 21 _N_ _N_ _N_ _N_ #-}
+ {-# GHC_PRAGMA _A_ 1 _U_ 21 _N_ _N_ _N_ _SPECIALISE_ [ _N_, Int ] 1 { _A_ 1 _U_ 1 _N_ _S_ "S" _N_ _N_ }, [ _N_, Integer ] 1 { _A_ 1 _U_ 1 _N_ _S_ "S" _N_ _N_ } #-}
head :: [a] -> a
{-# GHC_PRAGMA _A_ 1 _U_ 1 _N_ _S_ "S" _F_ _ALWAYS_ _/\_ u0 -> \ (u1 :: [u0]) -> let {(u2 :: u0) = _APP_ _TYAPP_ error { u0 } [ _NOREP_S_ "head{PreludeList}: head []\n" ]} in let {(u5 :: u0 -> u0 -> u0) = \ (u3 :: u0) (u4 :: u0) -> u3} in _APP_ _TYAPP_ _TYAPP_ foldr { u0 } { u0 } [ u5, u2, u1 ] _N_ #-}
init :: [a] -> [a]
map :: (a -> b) -> [a] -> [b]
{-# GHC_PRAGMA _A_ 2 _U_ 21 _N_ _S_ "LS" _F_ _ALWAYS_ _/\_ u0 u1 -> \ (u2 :: u0 -> u1) (u3 :: [u0]) -> let {(ua :: _forall_ a$z1 =>(u1 -> a$z1 -> a$z1) -> a$z1 -> a$z1) = _/\_ u4 -> \ (u5 :: u1 -> u4 -> u4) (u6 :: u4) -> let {(u9 :: u0 -> u4 -> u4) = \ (u7 :: u0) -> let {(u8 :: u1) = _APP_ u2 [ u7 ]} in _APP_ u5 [ u8 ]} in _APP_ _TYAPP_ _TYAPP_ foldr { u0 } { u4 } [ u9, u6, u3 ]} in _APP_ _TYAPP_ _build { u1 } [ ua ] _N_ #-}
maximum :: Ord a => [a] -> a
- {-# GHC_PRAGMA _A_ 1 _U_ 11 _N_ _N_ _N_ _N_ #-}
+ {-# GHC_PRAGMA _A_ 1 _U_ 11 _N_ _N_ _N_ _SPECIALISE_ [ Double ] 1 { _A_ 1 _U_ 1 _N_ _S_ "S" _N_ _N_ }, [ Int ] 1 { _A_ 1 _U_ 1 _N_ _S_ "S" _N_ _N_ }, [ Integer ] 1 { _A_ 1 _U_ 1 _N_ _S_ "S" _N_ _N_ } #-}
minimum :: Ord a => [a] -> a
- {-# GHC_PRAGMA _A_ 1 _U_ 11 _N_ _N_ _N_ _N_ #-}
+ {-# GHC_PRAGMA _A_ 1 _U_ 11 _N_ _N_ _N_ _SPECIALISE_ [ Double ] 1 { _A_ 1 _U_ 1 _N_ _S_ "S" _N_ _N_ }, [ Int ] 1 { _A_ 1 _U_ 1 _N_ _S_ "S" _N_ _N_ }, [ Integer ] 1 { _A_ 1 _U_ 1 _N_ _S_ "S" _N_ _N_ } #-}
notElem :: Eq a => a -> [a] -> Bool
- {-# GHC_PRAGMA _A_ 3 _U_ 121 _N_ _S_ "LLS" _F_ _ALWAYS_ _/\_ u0 -> \ (u1 :: {{Eq u0}}) (u2 :: u0) (u3 :: [u0]) -> let {(u6 :: u0 -> u0 -> Bool) = case u1 of { _ALG_ _TUP_2 (u4 :: u0 -> u0 -> Bool) (u5 :: u0 -> u0 -> Bool) -> u5; _NO_DEFLT_ }} in let {(u8 :: u0 -> Bool) = \ (u7 :: u0) -> _APP_ u6 [ u2, u7 ]} in _APP_ _TYAPP_ _ORIG_ PreludeList all { u0 } [ u8, u3 ] _SPECIALISE_ [ Char ] 1 { _A_ 2 _U_ 21 _N_ _S_ "LS" _F_ _ALWAYS_ \ (u0 :: Char) (u1 :: [Char]) -> let {(u5 :: Char -> Bool) = \ (u2 :: Char) -> case u0 of { _ALG_ C# (u3 :: Char#) -> case u2 of { _ALG_ C# (u4 :: Char#) -> _#_ neChar# [] [u3, u4]; _NO_DEFLT_ }; _NO_DEFLT_ }} in _APP_ _TYAPP_ _ORIG_ PreludeList all { Char } [ u5, u1 ] _N_ }, [ Int ] 1 { _A_ 2 _U_ 21 _N_ _S_ "LS" _F_ _ALWAYS_ \ (u0 :: Int) (u1 :: [Int]) -> let {(u5 :: Int -> Bool) = \ (u2 :: Int) -> case u0 of { _ALG_ I# (u3 :: Int#) -> case u2 of { _ALG_ I# (u4 :: Int#) -> _#_ neInt# [] [u3, u4]; _NO_DEFLT_ }; _NO_DEFLT_ }} in _APP_ _TYAPP_ _ORIG_ PreludeList all { Int } [ u5, u1 ] _N_ }, [ [Char] ] 1 { _A_ 2 _U_ 21 _N_ _S_ "LS" _F_ _ALWAYS_ \ (u0 :: [Char]) (u1 :: [[Char]]) -> let {(u3 :: [Char] -> Bool) = \ (u2 :: [Char]) -> _APP_ _CONSTM_ Eq (/=) ([Char]) [ u0, u2 ]} in _APP_ _TYAPP_ _ORIG_ PreludeList all { [Char] } [ u3, u1 ] _N_ } #-}
+ {-# GHC_PRAGMA _A_ 3 _U_ 121 _N_ _S_ "LLS" _F_ _ALWAYS_ _/\_ u0 -> \ (u1 :: {{Eq u0}}) (u2 :: u0) (u3 :: [u0]) -> let {(u6 :: u0 -> u0 -> Bool) = case u1 of { _ALG_ _TUP_2 (u4 :: u0 -> u0 -> Bool) (u5 :: u0 -> u0 -> Bool) -> u5; _NO_DEFLT_ }} in let {(u8 :: u0 -> Bool) = \ (u7 :: u0) -> _APP_ u6 [ u2, u7 ]} in _APP_ _TYAPP_ _ORIG_ PreludeList all { u0 } [ u8, u3 ] _SPECIALISE_ [ Char ] 1 { _A_ 2 _U_ 21 _N_ _S_ "LS" _F_ _ALWAYS_ \ (u0 :: Char) (u1 :: [Char]) -> let {(u5 :: Char -> Bool) = \ (u2 :: Char) -> case u0 of { _ALG_ C# (u3 :: Char#) -> case u2 of { _ALG_ C# (u4 :: Char#) -> _#_ neChar# [] [u3, u4]; _NO_DEFLT_ }; _NO_DEFLT_ }} in _APP_ _TYAPP_ _ORIG_ PreludeList all { Char } [ u5, u1 ] _N_ }, [ Int ] 1 { _A_ 2 _U_ 21 _N_ _S_ "LS" _F_ _ALWAYS_ \ (u0 :: Int) (u1 :: [Int]) -> let {(u5 :: Int -> Bool) = \ (u2 :: Int) -> case u0 of { _ALG_ I# (u3 :: Int#) -> case u2 of { _ALG_ I# (u4 :: Int#) -> _#_ neInt# [] [u3, u4]; _NO_DEFLT_ }; _NO_DEFLT_ }} in _APP_ _TYAPP_ _ORIG_ PreludeList all { Int } [ u5, u1 ] _N_ }, [ Integer ] 1 { _A_ 2 _U_ 21 _N_ _S_ "LS" _F_ _ALWAYS_ \ (u0 :: Integer) (u1 :: [Integer]) -> let {(ua :: Integer -> Bool) = \ (u2 :: Integer) -> case u0 of { _ALG_ J# (u3 :: Int#) (u4 :: Int#) (u5 :: ByteArray#) -> case u2 of { _ALG_ J# (u6 :: Int#) (u7 :: Int#) (u8 :: ByteArray#) -> case _#_ cmpInteger# [] [u3, u4, u5, u6, u7, u8] of { _PRIM_ 0# -> _!_ False [] []; (u9 :: Int#) -> _!_ True [] [] }; _NO_DEFLT_ }; _NO_DEFLT_ }} in _APP_ _TYAPP_ _ORIG_ PreludeList all { Integer } [ ua, u1 ] _N_ }, [ [Char] ] 1 { _A_ 2 _U_ 21 _N_ _S_ "LS" _F_ _ALWAYS_ \ (u0 :: [Char]) (u1 :: [[Char]]) -> let {(u3 :: [Char] -> Bool) = \ (u2 :: [Char]) -> _APP_ _CONSTM_ Eq (/=) ([Char]) [ u0, u2 ]} in _APP_ _TYAPP_ _ORIG_ PreludeList all { [Char] } [ u3, u1 ] _N_ }, [ (Int, Int) ] 1 { _A_ 2 _U_ 21 _N_ _S_ "LS" _F_ _ALWAYS_ \ (u0 :: (Int, Int)) (u1 :: [(Int, Int)]) -> let {(ub :: (Int, Int) -> Bool) = \ (u2 :: (Int, Int)) -> case u0 of { _ALG_ _TUP_2 (u3 :: Int) (u4 :: Int) -> case u3 of { _ALG_ I# (u5 :: Int#) -> case u2 of { _ALG_ _TUP_2 (u6 :: Int) (u7 :: Int) -> case u6 of { _ALG_ I# (u8 :: Int#) -> case _#_ neInt# [] [u5, u8] of { _ALG_ True -> _!_ True [] []; False -> case u4 of { _ALG_ I# (u9 :: Int#) -> case u7 of { _ALG_ I# (ua :: Int#) -> _#_ neInt# [] [u9, ua]; _NO_DEFLT_ }; _NO_DEFLT_ }; _NO_DEFLT_ }; _NO_DEFLT_ }; _NO_DEFLT_ }; _NO_DEFLT_ }; _NO_DEFLT_ }} in _APP_ _TYAPP_ _ORIG_ PreludeList all { (Int, Int) } [ ub, u1 ] _N_ } #-}
nub :: Eq a => [a] -> [a]
- {-# GHC_PRAGMA _A_ 2 _U_ 11 _N_ _S_ "LS" _N_ _N_ #-}
+ {-# GHC_PRAGMA _A_ 2 _U_ 11 _N_ _S_ "LS" _N_ _SPECIALISE_ [ Int ] 1 { _A_ 1 _U_ 1 _N_ _S_ "S" _N_ _N_ }, [ [Char] ] 1 { _A_ 1 _U_ 1 _N_ _S_ "S" _N_ _N_ }, [ [Int] ] 1 { _A_ 1 _U_ 1 _N_ _S_ "S" _N_ _N_ } #-}
null :: [a] -> Bool
{-# GHC_PRAGMA _A_ 1 _U_ 1 _N_ _S_ "S" _F_ _ALWAYS_ _/\_ u0 -> \ (u1 :: [u0]) -> let {(u2 :: Bool) = _!_ True [] []} in let {(u5 :: u0 -> Bool -> Bool) = \ (u3 :: u0) (u4 :: Bool) -> _!_ False [] []} in _APP_ _TYAPP_ _TYAPP_ foldr { u0 } { Bool } [ u5, u2, u1 ] _N_ #-}
or :: [Bool] -> Bool
partition :: (a -> Bool) -> [a] -> ([a], [a])
{-# GHC_PRAGMA _A_ 2 _U_ 21 _N_ _S_ "LS" _F_ _ALWAYS_ _/\_ u0 -> \ (u1 :: u0 -> Bool) (u2 :: [u0]) -> let {(u9 :: u0 -> ([u0], [u0]) -> ([u0], [u0])) = \ (u3 :: u0) (u4 :: ([u0], [u0])) -> case u4 of { _ALG_ _TUP_2 (u5 :: [u0]) (u6 :: [u0]) -> case _APP_ u1 [ u3 ] of { _ALG_ True -> let {(u7 :: [u0]) = _!_ (:) [u0] [u3, u5]} in _!_ _TUP_2 [[u0], [u0]] [u7, u6]; False -> let {(u8 :: [u0]) = _!_ (:) [u0] [u3, u6]} in _!_ _TUP_2 [[u0], [u0]] [u5, u8]; _NO_DEFLT_ }; _NO_DEFLT_ }} in let {(ua :: [u0]) = _!_ _NIL_ [u0] []} in let {(ub :: ([u0], [u0])) = _!_ _TUP_2 [[u0], [u0]] [ua, ua]} in _APP_ _TYAPP_ _TYAPP_ foldr { u0 } { ([u0], [u0]) } [ u9, ub, u2 ] _N_ #-}
product :: Num a => [a] -> a
- {-# GHC_PRAGMA _A_ 1 _U_ 22 _N_ _N_ _F_ _ALWAYS_ _/\_ u0 -> \ (u1 :: {{Num u0}}) -> let {(uc :: u0 -> u0 -> u0) = case u1 of { _ALG_ _TUP_10 (u2 :: {{Eq u0}}) (u3 :: {{Text u0}}) (u4 :: u0 -> u0 -> u0) (u5 :: u0 -> u0 -> u0) (u6 :: u0 -> u0 -> u0) (u7 :: u0 -> u0) (u8 :: u0 -> u0) (u9 :: u0 -> u0) (ua :: Integer -> u0) (ub :: Int -> u0) -> u6; _NO_DEFLT_ }} in let {(uo :: u0) = let {(ud :: Int) = _!_ I# [] [1#]} in case u1 of { _ALG_ _TUP_10 (ue :: {{Eq u0}}) (uf :: {{Text u0}}) (ug :: u0 -> u0 -> u0) (uh :: u0 -> u0 -> u0) (ui :: u0 -> u0 -> u0) (uj :: u0 -> u0) (uk :: u0 -> u0) (ul :: u0 -> u0) (um :: Integer -> u0) (un :: Int -> u0) -> _APP_ un [ ud ]; _NO_DEFLT_ }} in \ (up :: [u0]) -> _APP_ _TYAPP_ _TYAPP_ foldl { u0 } { u0 } [ uc, uo, up ] _SPECIALISE_ [ Double ] 1 { _A_ 1 _U_ 1 _N_ _S_ "S" _F_ _ALWAYS_ \ (u0 :: [Double]) -> let {(u1 :: Double) = _!_ D# [] [1.0000000000000000##]} in _APP_ _TYAPP_ _TYAPP_ foldl { Double } { Double } [ _CONSTM_ Num (*) (Double), u1, u0 ] _N_ }, [ Int ] 1 { _A_ 1 _U_ 1 _N_ _S_ "S" _F_ _ALWAYS_ \ (u0 :: [Int]) -> let {(u1 :: Int) = _!_ I# [] [1#]} in _APP_ _TYAPP_ _TYAPP_ foldl { Int } { Int } [ _CONSTM_ Num (*) (Int), u1, u0 ] _N_ }, [ Integer ] 1 { _A_ 1 _U_ 1 _N_ _S_ "S" _F_ _ALWAYS_ \ (u0 :: [Integer]) -> let {(u1 :: Integer) = _#_ int2Integer# [] [1#]} in _APP_ _TYAPP_ _TYAPP_ foldl { Integer } { Integer } [ _CONSTM_ Num (*) (Integer), u1, u0 ] _N_ } #-}
+ {-# GHC_PRAGMA _A_ 1 _U_ 22 _N_ _N_ _F_ _ALWAYS_ _/\_ u0 -> \ (u1 :: {{Num u0}}) -> let {(uc :: u0 -> u0 -> u0) = case u1 of { _ALG_ _TUP_10 (u2 :: {{Eq u0}}) (u3 :: {{Text u0}}) (u4 :: u0 -> u0 -> u0) (u5 :: u0 -> u0 -> u0) (u6 :: u0 -> u0 -> u0) (u7 :: u0 -> u0) (u8 :: u0 -> u0) (u9 :: u0 -> u0) (ua :: Integer -> u0) (ub :: Int -> u0) -> u6; _NO_DEFLT_ }} in let {(uo :: u0) = let {(ud :: Int) = _!_ I# [] [1#]} in case u1 of { _ALG_ _TUP_10 (ue :: {{Eq u0}}) (uf :: {{Text u0}}) (ug :: u0 -> u0 -> u0) (uh :: u0 -> u0 -> u0) (ui :: u0 -> u0 -> u0) (uj :: u0 -> u0) (uk :: u0 -> u0) (ul :: u0 -> u0) (um :: Integer -> u0) (un :: Int -> u0) -> _APP_ un [ ud ]; _NO_DEFLT_ }} in \ (up :: [u0]) -> _APP_ _TYAPP_ _TYAPP_ foldl { u0 } { u0 } [ uc, uo, up ] _SPECIALISE_ [ Double ] 1 { _A_ 1 _U_ 1 _N_ _S_ "S" _F_ _ALWAYS_ \ (u0 :: [Double]) -> let {(u1 :: Double) = _!_ D# [] [1.0000000000000000##]} in _APP_ _TYAPP_ _TYAPP_ foldl { Double } { Double } [ _CONSTM_ Num (*) (Double), u1, u0 ] _N_ }, [ Int ] 1 { _A_ 1 _U_ 1 _N_ _S_ "S" _F_ _ALWAYS_ \ (u0 :: [Int]) -> let {(u1 :: Int) = _!_ I# [] [1#]} in _APP_ _TYAPP_ _TYAPP_ foldl { Int } { Int } [ _CONSTM_ Num (*) (Int), u1, u0 ] _N_ }, [ Integer ] 1 { _A_ 1 _U_ 1 _N_ _S_ "S" _F_ _ALWAYS_ \ (u0 :: [Integer]) -> let {(u1 :: Integer) = _#_ int2Integer# [] [1#]} in _APP_ _TYAPP_ _TYAPP_ foldl { Integer } { Integer } [ _CONSTM_ Num (*) (Integer), u1, u0 ] _N_ }, [ (Complex Double) ] 1 { _A_ 1 _U_ 1 _N_ _S_ "S" _F_ _ALWAYS_ let {(u6 :: Complex Double -> Complex Double -> Complex Double) = \ (u0 :: Complex Double) (u1 :: Complex Double) -> case u0 of { _ALG_ (:+) (u2 :: Double) (u3 :: Double) -> case u1 of { _ALG_ (:+) (u4 :: Double) (u5 :: Double) -> _APP_ _WRKR_ _CONSTM_ Num (*) (Complex Double) [ u2, u3, u4, u5 ]; _NO_DEFLT_ }; _NO_DEFLT_ }} in let {(u8 :: Complex Double) = let {(u7 :: Int) = _!_ I# [] [1#]} in _APP_ _CONSTM_ Num fromInt (Complex Double) [ u7 ]} in \ (u9 :: [Complex Double]) -> _APP_ _TYAPP_ _TYAPP_ foldl { (Complex Double) } { (Complex Double) } [ u6, u8, u9 ] _N_ } #-}
products :: Num a => [a] -> [a]
- {-# GHC_PRAGMA _A_ 1 _U_ 21 _N_ _N_ _N_ _N_ #-}
+ {-# GHC_PRAGMA _A_ 1 _U_ 21 _N_ _N_ _N_ _SPECIALISE_ [ Double ] 1 { _A_ 1 _U_ 1 _N_ _N_ _N_ _N_ }, [ Int ] 1 { _A_ 1 _U_ 1 _N_ _N_ _N_ _N_ }, [ Integer ] 1 { _A_ 1 _U_ 1 _N_ _N_ _F_ _IF_ARGS_ 0 1 X 4 \ (u0 :: [Integer]) -> _APP_ _TYAPP_ _TYAPP_ _ORIG_ PreludeList scanl { Integer } { Integer } [ _CONSTM_ Num (*) (Integer), _SPEC_ _ORIG_ PreludeCore __i1 [ (Integer) ], u0 ] _N_ }, [ (Complex Double) ] 1 { _A_ 1 _U_ 1 _N_ _N_ _N_ _N_ } #-}
repeat :: a -> [a]
{-# GHC_PRAGMA _A_ 1 _U_ 2 _N_ _N_ _F_ _ALWAYS_ _/\_ u0 -> \ (u1 :: u0) -> let {(u6 :: _forall_ a$z1 =>(u0 -> a$z1 -> a$z1) -> a$z1 -> a$z1) = _/\_ u2 -> \ (u3 :: u0 -> u2 -> u2) (u4 :: u2) -> _LETREC_ {(u5 :: u2) = _APP_ u3 [ u1, u5 ]} in u5} in _APP_ _TYAPP_ _build { u0 } [ u6 ] _N_ #-}
reverse :: [a] -> [a]
sum :: Num a => [a] -> a
{-# GHC_PRAGMA _A_ 1 _U_ 22 _N_ _N_ _F_ _ALWAYS_ _/\_ u0 -> \ (u1 :: {{Num u0}}) -> let {(uc :: u0 -> u0 -> u0) = case u1 of { _ALG_ _TUP_10 (u2 :: {{Eq u0}}) (u3 :: {{Text u0}}) (u4 :: u0 -> u0 -> u0) (u5 :: u0 -> u0 -> u0) (u6 :: u0 -> u0 -> u0) (u7 :: u0 -> u0) (u8 :: u0 -> u0) (u9 :: u0 -> u0) (ua :: Integer -> u0) (ub :: Int -> u0) -> u4; _NO_DEFLT_ }} in let {(uo :: u0) = let {(ud :: Int) = _!_ I# [] [0#]} in case u1 of { _ALG_ _TUP_10 (ue :: {{Eq u0}}) (uf :: {{Text u0}}) (ug :: u0 -> u0 -> u0) (uh :: u0 -> u0 -> u0) (ui :: u0 -> u0 -> u0) (uj :: u0 -> u0) (uk :: u0 -> u0) (ul :: u0 -> u0) (um :: Integer -> u0) (un :: Int -> u0) -> _APP_ un [ ud ]; _NO_DEFLT_ }} in \ (up :: [u0]) -> _APP_ _TYAPP_ _TYAPP_ foldl { u0 } { u0 } [ uc, uo, up ] _SPECIALISE_ [ Double ] 1 { _A_ 1 _U_ 1 _N_ _S_ "S" _F_ _ALWAYS_ \ (u0 :: [Double]) -> let {(u1 :: Double) = _!_ D# [] [0.0000000000000000##]} in _APP_ _TYAPP_ _TYAPP_ foldl { Double } { Double } [ _CONSTM_ Num (+) (Double), u1, u0 ] _N_ }, [ Int ] 1 { _A_ 1 _U_ 1 _N_ _S_ "S" _F_ _ALWAYS_ \ (u0 :: [Int]) -> let {(u1 :: Int) = _!_ I# [] [0#]} in _APP_ _TYAPP_ _TYAPP_ foldl { Int } { Int } [ _CONSTM_ Num (+) (Int), u1, u0 ] _N_ }, [ Integer ] 1 { _A_ 1 _U_ 1 _N_ _S_ "S" _F_ _ALWAYS_ \ (u0 :: [Integer]) -> let {(u1 :: Integer) = _#_ int2Integer# [] [0#]} in _APP_ _TYAPP_ _TYAPP_ foldl { Integer } { Integer } [ _CONSTM_ Num (+) (Integer), u1, u0 ] _N_ }, [ (Complex Double) ] 1 { _A_ 1 _U_ 1 _N_ _S_ "S" _F_ _ALWAYS_ let {(u6 :: Complex Double -> Complex Double -> Complex Double) = \ (u0 :: Complex Double) (u1 :: Complex Double) -> case u0 of { _ALG_ (:+) (u2 :: Double) (u3 :: Double) -> case u1 of { _ALG_ (:+) (u4 :: Double) (u5 :: Double) -> _APP_ _WRKR_ _CONSTM_ Num (+) (Complex Double) [ u2, u3, u4, u5 ]; _NO_DEFLT_ }; _NO_DEFLT_ }} in let {(u8 :: Complex Double) = let {(u7 :: Int) = _!_ I# [] [0#]} in _APP_ _CONSTM_ Num fromInt (Complex Double) [ u7 ]} in \ (u9 :: [Complex Double]) -> _APP_ _TYAPP_ _TYAPP_ foldl { (Complex Double) } { (Complex Double) } [ u6, u8, u9 ] _N_ } #-}
sums :: Num a => [a] -> [a]
- {-# GHC_PRAGMA _A_ 1 _U_ 21 _N_ _N_ _N_ _N_ #-}
+ {-# GHC_PRAGMA _A_ 1 _U_ 21 _N_ _N_ _N_ _SPECIALISE_ [ Double ] 1 { _A_ 1 _U_ 1 _N_ _N_ _N_ _N_ }, [ Int ] 1 { _A_ 1 _U_ 1 _N_ _N_ _N_ _N_ }, [ Integer ] 1 { _A_ 1 _U_ 1 _N_ _N_ _F_ _IF_ARGS_ 0 1 X 4 \ (u0 :: [Integer]) -> _APP_ _TYAPP_ _TYAPP_ _ORIG_ PreludeList scanl { Integer } { Integer } [ _CONSTM_ Num (+) (Integer), _SPEC_ _ORIG_ PreludeCore __i0 [ (Integer) ], u0 ] _N_ }, [ (Complex Double) ] 1 { _A_ 1 _U_ 1 _N_ _N_ _N_ _N_ } #-}
tail :: [a] -> [a]
{-# GHC_PRAGMA _A_ 1 _U_ 1 _N_ _S_ "S" _F_ _IF_ARGS_ 1 1 C 5 _/\_ u0 -> \ (u1 :: [u0]) -> case u1 of { _ALG_ (:) (u2 :: u0) (u3 :: [u0]) -> u3; _NIL_ -> _APP_ _TYAPP_ error { [u0] } [ _NOREP_S_ "tail{PreludeList}: tail []\n" ]; _NO_DEFLT_ } _N_ #-}
take :: Integral a => a -> [b] -> [b]
- {-# GHC_PRAGMA _A_ 3 _U_ 121 _N_ _S_ "U(AAAAAAAAAAAS)LL" {_A_ 3 _U_ 121 _N_ _N_ _N_ _N_} _F_ _IF_ARGS_ 2 3 CXX 7 _/\_ u0 u1 -> \ (u2 :: {{Integral u0}}) (u3 :: u0) (u4 :: [u1]) -> let {(uh :: Int) = case u2 of { _ALG_ _TUP_12 (u5 :: {{Real u0}}) (u6 :: {{Ix u0}}) (u7 :: u0 -> u0 -> u0) (u8 :: u0 -> u0 -> u0) (u9 :: u0 -> u0 -> u0) (ua :: u0 -> u0 -> u0) (ub :: u0 -> u0 -> (u0, u0)) (uc :: u0 -> u0 -> (u0, u0)) (ud :: u0 -> Bool) (ue :: u0 -> Bool) (uf :: u0 -> Integer) (ug :: u0 -> Int) -> _APP_ ug [ u3 ]; _NO_DEFLT_ }} in _APP_ _TYAPP_ _SPEC_ _ORIG_ PreludeList take [ (Int), _N_ ] { u1 } [ uh, u4 ] _SPECIALISE_ [ Int, _N_ ] 1 { _A_ 2 _U_ 11 _N_ _S_ "U(P)L" {_A_ 2 _U_ 21 _N_ _N_ _N_ _N_} _N_ _N_ }, [ Integer, _N_ ] 1 { _A_ 2 _U_ 11 _N_ _S_ "U(PPP)L" {_A_ 4 _U_ 2221 _N_ _N_ _F_ _IF_ARGS_ 1 4 XXXX 4 _/\_ u0 -> \ (u1 :: Int#) (u2 :: Int#) (u3 :: ByteArray#) (u4 :: [u0]) -> case _#_ integer2Int# [] [u1, u2, u3] of { _PRIM_ (u5 :: Int#) -> _APP_ _TYAPP_ _WRKR_ _SPEC_ _ORIG_ PreludeList take [ (Int), _N_ ] { u0 } [ u5, u4 ] } _N_} _F_ _ALWAYS_ _/\_ u0 -> \ (u1 :: Integer) (u2 :: [u0]) -> case u1 of { _ALG_ J# (u3 :: Int#) (u4 :: Int#) (u5 :: ByteArray#) -> case _#_ integer2Int# [] [u3, u4, u5] of { _PRIM_ (u6 :: Int#) -> _APP_ _TYAPP_ _WRKR_ _SPEC_ _ORIG_ PreludeList take [ (Int), _N_ ] { u0 } [ u6, u2 ] }; _NO_DEFLT_ } _N_ } #-}
+ {-# GHC_PRAGMA _A_ 1 _U_ 122 _N_ _S_ "U(LU(U(ASSAAAAA)AAA)AAAALAAAAL)" {_A_ 5 _U_ 2121222 _N_ _N_ _N_ _N_} _N_ _SPECIALISE_ [ Int, _N_ ] 1 { _A_ 2 _U_ 11 _N_ _S_ "U(P)L" {_A_ 2 _U_ 21 _N_ _N_ _N_ _N_} _N_ _N_ }, [ Integer, _N_ ] 1 { _A_ 1 _U_ 12 _N_ _S_ "U(PPP)" {_A_ 3 _U_ 2222 _N_ _N_ _N_ _N_} _N_ _N_ } #-}
takeWhile :: (a -> Bool) -> [a] -> [a]
{-# GHC_PRAGMA _A_ 2 _U_ 21 _N_ _S_ "LS" _F_ _ALWAYS_ _/\_ u0 -> \ (u1 :: u0 -> Bool) (u2 :: [u0]) -> let {(u9 :: _forall_ a$z1 =>(u0 -> a$z1 -> a$z1) -> a$z1 -> a$z1) = _/\_ u3 -> \ (u4 :: u0 -> u3 -> u3) (u5 :: u3) -> let {(u8 :: u0 -> u3 -> u3) = \ (u6 :: u0) (u7 :: u3) -> case _APP_ u1 [ u6 ] of { _ALG_ True -> _APP_ u4 [ u6, u7 ]; False -> u5; _NO_DEFLT_ }} in _APP_ _TYAPP_ _TYAPP_ foldr { u0 } { u3 } [ u8, u5, u2 ]} in _APP_ _TYAPP_ _build { u0 } [ u9 ] _N_ #-}
transpose :: [[a]] -> [[a]]
lex :: [Char] -> [([Char], [Char])]
{-# GHC_PRAGMA _A_ 1 _U_ 2 _N_ _S_ "S" _N_ _N_ #-}
read :: Text a => [Char] -> a
- {-# GHC_PRAGMA _A_ 1 _U_ 12 _N_ _S_ "U(SAAA)" {_A_ 1 _U_ 12 _N_ _N_ _N_ _N_} _N_ _SPECIALISE_ [ Double ] 1 { _A_ 1 _U_ 2 _N_ _N_ _N_ _N_ }, [ Float ] 1 { _A_ 1 _U_ 2 _N_ _N_ _N_ _N_ }, [ Int ] 1 { _A_ 1 _U_ 2 _N_ _N_ _N_ _N_ }, [ Integer ] 1 { _A_ 1 _U_ 2 _N_ _N_ _N_ _N_ } #-}
+ {-# GHC_PRAGMA _A_ 1 _U_ 12 _N_ _S_ "U(SAAA)" {_A_ 1 _U_ 12 _N_ _N_ _N_ _N_} _N_ _SPECIALISE_ [ Bool ] 1 { _A_ 1 _U_ 2 _N_ _N_ _N_ _N_ }, [ Char ] 1 { _A_ 1 _U_ 2 _N_ _N_ _N_ _N_ }, [ Double ] 1 { _A_ 1 _U_ 2 _N_ _N_ _N_ _N_ }, [ Int ] 1 { _A_ 1 _U_ 2 _N_ _N_ _N_ _N_ }, [ Integer ] 1 { _A_ 1 _U_ 2 _N_ _N_ _N_ _N_ }, [ [Bool] ] 1 { _A_ 1 _U_ 2 _N_ _N_ _N_ _N_ }, [ [Char] ] 1 { _A_ 1 _U_ 2 _N_ _N_ _N_ _N_ }, [ [Double] ] 1 { _A_ 1 _U_ 2 _N_ _N_ _N_ _N_ }, [ [Float] ] 1 { _A_ 1 _U_ 2 _N_ _N_ _N_ _N_ }, [ [Int] ] 1 { _A_ 1 _U_ 2 _N_ _N_ _N_ _N_ }, [ [Integer] ] 1 { _A_ 1 _U_ 2 _N_ _N_ _N_ _N_ }, [ [[Char]] ] 1 { _A_ 1 _U_ 2 _N_ _N_ _N_ _N_ }, [ [[Int]] ] 1 { _A_ 1 _U_ 2 _N_ _N_ _N_ _N_ }, [ [Complex Double] ] 1 { _A_ 1 _U_ 2 _N_ _N_ _N_ _N_ }, [ (Ratio Integer) ] 1 { _A_ 1 _U_ 2 _N_ _N_ _N_ _N_ }, [ (Array Int Double) ] 1 { _A_ 1 _U_ 2 _N_ _N_ _N_ _N_ }, [ (Array (Int, Int) Double) ] 1 { _A_ 1 _U_ 2 _N_ _N_ _N_ _N_ }, [ _PackedString ] 1 { _A_ 1 _U_ 2 _N_ _S_ _!_ _N_ _N_ }, [ (Complex Double) ] 1 { _A_ 1 _U_ 2 _N_ _N_ _N_ _N_ }, [ () ] 1 { _A_ 1 _U_ 2 _N_ _N_ _N_ _N_ }, [ (Int, Int) ] 1 { _A_ 1 _U_ 2 _N_ _N_ _N_ _N_ }, [ (Integer, Integer) ] 1 { _A_ 1 _U_ 2 _N_ _N_ _N_ _N_ }, [ (Int, Int, Int) ] 1 { _A_ 1 _U_ 2 _N_ _N_ _N_ _N_ } #-}
readDec :: Integral a => [Char] -> [(a, [Char])]
- {-# GHC_PRAGMA _A_ 1 _U_ 22 _N_ _N_ _N_ _SPECIALISE_ [ Int ] 1 { _A_ 1 _U_ 2 _N_ _N_ _N_ _N_ }, [ Integer ] 1 { _A_ 1 _U_ 2 _N_ _S_ "S" _N_ _N_ } #-}
+ {-# GHC_PRAGMA _A_ 1 _U_ 22 _N_ _N_ _N_ _SPECIALISE_ [ Int ] 1 { _A_ 1 _U_ 2 _N_ _N_ _N_ _N_ }, [ Integer ] 1 { _A_ 1 _U_ 2 _N_ _N_ _N_ _N_ } #-}
readFloat :: RealFloat a => [Char] -> [(a, [Char])]
- {-# GHC_PRAGMA _A_ 2 _U_ 12 _N_ _S_ "LS" _N_ _SPECIALISE_ [ Double ] 1 { _A_ 1 _U_ 2 _N_ _S_ "S" _N_ _N_ }, [ Float ] 1 { _A_ 1 _U_ 2 _N_ _S_ "S" _N_ _N_ } #-}
+ {-# GHC_PRAGMA _A_ 2 _U_ 12 _N_ _S_ "LS" _N_ _SPECIALISE_ [ Double ] 1 { _A_ 1 _U_ 2 _N_ _S_ "S" _N_ _N_ } #-}
readLitChar :: [Char] -> [(Char, [Char])]
{-# GHC_PRAGMA _A_ 0 _U_ 1 _N_ _N_ _N_ _N_ #-}
readParen :: Bool -> ([Char] -> [(a, [Char])]) -> [Char] -> [(a, [Char])]
readSigned :: Real a => ([Char] -> [(a, [Char])]) -> [Char] -> [(a, [Char])]
{-# GHC_PRAGMA _A_ 2 _U_ 122 _N_ _N_ _N_ _SPECIALISE_ [ Double ] 1 { _A_ 1 _U_ 22 _N_ _N_ _N_ _N_ }, [ Int ] 1 { _A_ 1 _U_ 22 _N_ _N_ _N_ _N_ }, [ Integer ] 1 { _A_ 1 _U_ 22 _N_ _N_ _N_ _N_ } #-}
reads :: Text a => [Char] -> [(a, [Char])]
- {-# GHC_PRAGMA _A_ 1 _U_ 12 _N_ _S_ "U(SAAA)" {_A_ 1 _U_ 12 _N_ _N_ _N_ _N_} _N_ _SPECIALISE_ [ Double ] 1 { _A_ 1 _U_ 2 _N_ _N_ _N_ _N_ }, [ Float ] 1 { _A_ 1 _U_ 2 _N_ _N_ _N_ _N_ }, [ Int ] 1 { _A_ 1 _U_ 2 _N_ _N_ _N_ _N_ }, [ Integer ] 1 { _A_ 1 _U_ 2 _N_ _N_ _N_ _N_ } #-}
+ {-# GHC_PRAGMA _A_ 1 _U_ 12 _N_ _S_ "U(SAAA)" {_A_ 1 _U_ 12 _N_ _N_ _N_ _N_} _N_ _SPECIALISE_ [ Bool ] 1 { _A_ 1 _U_ 2 _N_ _N_ _N_ _N_ }, [ Char ] 1 { _A_ 0 _U_ 2 _N_ _N_ _N_ _N_ }, [ Double ] 1 { _A_ 1 _U_ 2 _N_ _N_ _N_ _N_ }, [ Int ] 1 { _A_ 1 _U_ 2 _N_ _N_ _N_ _N_ }, [ Integer ] 1 { _A_ 1 _U_ 2 _N_ _N_ _N_ _N_ }, [ [Bool] ] 1 { _A_ 0 _U_ 2 _N_ _N_ _F_ _IF_ARGS_ 0 0 X 1 _CONSTM_ Text readList (Bool) _N_ }, [ [Char] ] 1 { _A_ 0 _U_ 2 _N_ _N_ _F_ _IF_ARGS_ 0 0 X 1 _CONSTM_ Text readList (Char) _N_ }, [ [Double] ] 1 { _A_ 0 _U_ 2 _N_ _N_ _F_ _IF_ARGS_ 0 0 X 1 _CONSTM_ Text readList (Double) _N_ }, [ [Float] ] 1 { _A_ 0 _U_ 2 _N_ _N_ _N_ _N_ }, [ [Int] ] 1 { _A_ 0 _U_ 2 _N_ _N_ _F_ _IF_ARGS_ 0 0 X 1 _CONSTM_ Text readList (Int) _N_ }, [ [Integer] ] 1 { _A_ 0 _U_ 2 _N_ _N_ _F_ _IF_ARGS_ 0 0 X 1 _CONSTM_ Text readList (Integer) _N_ }, [ [[Char]] ] 1 { _A_ 0 _U_ 2 _N_ _N_ _F_ _IF_ARGS_ 0 0 X 1 _CONSTM_ Text readList ([Char]) _N_ }, [ [[Int]] ] 1 { _A_ 0 _U_ 2 _N_ _N_ _F_ _IF_ARGS_ 0 0 X 1 _CONSTM_ Text readList ([Int]) _N_ }, [ [Complex Double] ] 1 { _A_ 0 _U_ 2 _N_ _N_ _F_ _IF_ARGS_ 0 0 X 1 _CONSTM_ Text readList (Complex Double) _N_ }, [ (Ratio Integer) ] 1 { _A_ 0 _U_ 2 _N_ _N_ _N_ _N_ }, [ (Array Int Double) ] 1 { _A_ 0 _U_ 2 _N_ _N_ _N_ _N_ }, [ (Array (Int, Int) Double) ] 1 { _A_ 0 _U_ 2 _N_ _N_ _N_ _N_ }, [ _PackedString ] 1 { _A_ 1 _U_ 2 _N_ _S_ _!_ _N_ _N_ }, [ (Complex Double) ] 1 { _A_ 0 _U_ 2 _N_ _N_ _N_ _N_ }, [ () ] 1 { _A_ 0 _U_ 2 _N_ _N_ _N_ _N_ }, [ (Int, Int) ] 1 { _A_ 0 _U_ 2 _N_ _N_ _N_ _N_ }, [ (Integer, Integer) ] 1 { _A_ 0 _U_ 2 _N_ _N_ _N_ _N_ }, [ (Int, Int, Int) ] 1 { _A_ 0 _U_ 2 _N_ _N_ _N_ _N_ } #-}
show :: Text a => a -> [Char]
- {-# GHC_PRAGMA _A_ 1 _U_ 12 _N_ _S_ "U(ASAA)" {_A_ 1 _U_ 12 _N_ _N_ _N_ _N_} _N_ _SPECIALISE_ [ Char ] 1 { _A_ 1 _U_ 1 _N_ _S_ "U(P)" {_A_ 1 _U_ 2 _N_ _N_ _N_ _N_} _N_ _N_ }, [ Double ] 1 { _A_ 1 _U_ 1 _N_ _S_ "U(P)" {_A_ 1 _U_ 2 _N_ _N_ _N_ _N_} _N_ _N_ }, [ Float ] 1 { _A_ 1 _U_ 2 _N_ _N_ _N_ _N_ }, [ Int ] 1 { _A_ 1 _U_ 1 _N_ _S_ "U(P)" {_A_ 1 _U_ 2 _N_ _N_ _N_ _N_} _N_ _N_ }, [ Integer ] 1 { _A_ 1 _U_ 1 _N_ _S_ "U(PPP)" {_A_ 3 _U_ 222 _N_ _N_ _N_ _N_} _N_ _N_ }, [ [Char] ] 1 { _A_ 1 _U_ 2 _N_ _N_ _N_ _N_ }, [ _PackedString ] 1 { _A_ 1 _U_ 1 _N_ _N_ _N_ _N_ }, [ (Int, Int) ] 1 { _A_ 1 _U_ 1 _N_ _S_ "U(LL)" {_A_ 2 _U_ 22 _N_ _N_ _N_ _N_} _N_ _N_ }, [ (Integer, Integer) ] 1 { _A_ 1 _U_ 1 _N_ _S_ "U(LL)" {_A_ 2 _U_ 22 _N_ _N_ _N_ _N_} _N_ _N_ } #-}
+ {-# GHC_PRAGMA _A_ 1 _U_ 12 _N_ _S_ "U(ASAA)" {_A_ 1 _U_ 12 _N_ _N_ _N_ _N_} _N_ _SPECIALISE_ [ Bool ] 1 { _A_ 1 _U_ 2 _N_ _S_ "E" _N_ _N_ }, [ Char ] 1 { _A_ 1 _U_ 1 _N_ _S_ "U(P)" {_A_ 1 _U_ 2 _N_ _N_ _N_ _N_} _N_ _N_ }, [ Double ] 1 { _A_ 1 _U_ 1 _N_ _S_ "U(P)" {_A_ 1 _U_ 2 _N_ _N_ _N_ _N_} _N_ _N_ }, [ Int ] 1 { _A_ 1 _U_ 1 _N_ _S_ "U(P)" {_A_ 1 _U_ 2 _N_ _N_ _N_ _N_} _N_ _N_ }, [ Integer ] 1 { _A_ 1 _U_ 1 _N_ _S_ "U(PPP)" {_A_ 3 _U_ 222 _N_ _N_ _N_ _N_} _N_ _N_ }, [ [Bool] ] 1 { _A_ 1 _U_ 1 _N_ _S_ "S" _N_ _N_ }, [ [Char] ] 1 { _A_ 1 _U_ 2 _N_ _N_ _N_ _N_ }, [ [Double] ] 1 { _A_ 1 _U_ 2 _N_ _N_ _N_ _N_ }, [ [Int] ] 1 { _A_ 1 _U_ 2 _N_ _N_ _N_ _N_ }, [ [Integer] ] 1 { _A_ 1 _U_ 2 _N_ _N_ _N_ _N_ }, [ [[Char]] ] 1 { _A_ 1 _U_ 1 _N_ _S_ "S" _N_ _N_ }, [ [[Int]] ] 1 { _A_ 1 _U_ 1 _N_ _S_ "S" _N_ _N_ }, [ [Complex Double] ] 1 { _A_ 1 _U_ 2 _N_ _N_ _N_ _N_ }, [ (Ratio Integer) ] 1 { _A_ 1 _U_ 1 _N_ _S_ "U(LL)" {_A_ 2 _U_ 22 _N_ _N_ _N_ _N_} _N_ _N_ }, [ (Array Int Double) ] 1 { _A_ 1 _U_ 2 _N_ _N_ _N_ _N_ }, [ (Array (Int, Int) Double) ] 1 { _A_ 1 _U_ 2 _N_ _N_ _N_ _N_ }, [ _PackedString ] 1 { _A_ 1 _U_ 1 _N_ _N_ _N_ _N_ }, [ (Complex Double) ] 1 { _A_ 1 _U_ 1 _N_ _S_ "U(LL)" {_A_ 2 _U_ 22 _N_ _N_ _N_ _N_} _N_ _N_ }, [ () ] 1 { _A_ 1 _U_ 1 _N_ _S_ "E" _N_ _N_ }, [ (Int, Int) ] 1 { _A_ 1 _U_ 1 _N_ _S_ "U(LL)" {_A_ 2 _U_ 22 _N_ _N_ _N_ _N_} _N_ _N_ }, [ (Integer, Integer) ] 1 { _A_ 1 _U_ 1 _N_ _S_ "U(LL)" {_A_ 2 _U_ 22 _N_ _N_ _N_ _N_} _N_ _N_ }, [ (Int, Int, Int) ] 1 { _A_ 1 _U_ 1 _N_ _S_ "U(LLL)" {_A_ 3 _U_ 222 _N_ _N_ _N_ _N_} _N_ _N_ } #-}
showChar :: Char -> [Char] -> [Char]
{-# GHC_PRAGMA _A_ 2 _U_ 22 _N_ _N_ _F_ _IF_ARGS_ 0 2 XX 3 \ (u0 :: Char) (u1 :: [Char]) -> _!_ (:) [Char] [u0, u1] _N_ #-}
showFloat :: RealFloat a => a -> [Char] -> [Char]
- {-# GHC_PRAGMA _A_ 1 _U_ 122 _N_ _S_ "U(U(LU(SLLL)LAAAA)LLLALAAAA)" {_A_ 5 _U_ 1122222 _N_ _N_ _N_ _N_} _N_ _SPECIALISE_ [ Double ] 1 { _A_ 1 _U_ 12 _N_ _S_ "U(P)" {_A_ 1 _U_ 22 _N_ _N_ _N_ _N_} _N_ _N_ }, [ Float ] 1 { _A_ 0 _U_ 22 _N_ _N_ _N_ _N_ } #-}
+ {-# GHC_PRAGMA _A_ 1 _U_ 122 _N_ _S_ "U(U(AU(SAAA)AAAAL)LLLALAAAA)" {_A_ 5 _U_ 1122222 _N_ _N_ _N_ _N_} _N_ _SPECIALISE_ [ Double ] 1 { _A_ 1 _U_ 12 _N_ _S_ "U(P)" {_A_ 1 _U_ 22 _N_ _N_ _N_ _N_} _N_ _N_ } #-}
showInt :: Integral a => a -> [Char] -> [Char]
{-# GHC_PRAGMA _A_ 1 _U_ 122 _N_ _S_ "U(U(U(U(SL)LLLLLLLLL)LL)LLLLLSLLLLL)" _N_ _SPECIALISE_ [ Int ] 1 { _A_ 2 _U_ 12 _N_ _S_ "U(P)L" {_A_ 2 _U_ 22 _N_ _N_ _N_ _N_} _N_ _N_ }, [ Integer ] 1 { _A_ 2 _U_ 12 _N_ _S_ "U(PPP)L" {_A_ 4 _U_ 2222 _N_ _N_ _N_ _N_} _N_ _N_ } #-}
showLitChar :: Char -> [Char] -> [Char]
showString :: [Char] -> [Char] -> [Char]
{-# GHC_PRAGMA _A_ 2 _U_ 12 _N_ _N_ _F_ _IF_ARGS_ 0 0 X 1 _TYAPP_ _ORIG_ PreludeList (++) { Char } _N_ #-}
shows :: Text a => a -> [Char] -> [Char]
- {-# GHC_PRAGMA _A_ 1 _U_ 122 _N_ _S_ "U(ASAA)" {_A_ 1 _U_ 122 _N_ _N_ _N_ _N_} _N_ _SPECIALISE_ [ Char ] 1 { _A_ 2 _U_ 12 _N_ _S_ "U(P)L" {_A_ 2 _U_ 22 _N_ _N_ _N_ _N_} _N_ _N_ }, [ Double ] 1 { _A_ 1 _U_ 12 _N_ _S_ "U(P)" {_A_ 1 _U_ 22 _N_ _N_ _N_ _N_} _N_ _N_ }, [ Float ] 1 { _A_ 0 _U_ 22 _N_ _N_ _N_ _N_ }, [ Int ] 1 { _A_ 2 _U_ 12 _N_ _S_ "U(P)L" {_A_ 2 _U_ 22 _N_ _N_ _N_ _N_} _N_ _N_ }, [ Integer ] 1 { _A_ 2 _U_ 12 _N_ _S_ "U(PPP)L" {_A_ 4 _U_ 2222 _N_ _N_ _N_ _N_} _N_ _N_ }, [ [Char] ] 1 { _A_ 1 _U_ 22 _N_ _N_ _F_ _IF_ARGS_ 0 0 X 1 _CONSTM_ Text showList (Char) _N_ }, [ _PackedString ] 1 { _A_ 2 _U_ 12 _N_ _N_ _N_ _N_ }, [ (Int, Int) ] 1 { _A_ 2 _U_ 12 _N_ _S_ "U(LL)L" {_A_ 3 _U_ 222 _N_ _N_ _N_ _N_} _N_ _N_ }, [ (Integer, Integer) ] 1 { _A_ 2 _U_ 12 _N_ _S_ "U(LL)L" {_A_ 3 _U_ 222 _N_ _N_ _N_ _N_} _N_ _N_ } #-}
+ {-# GHC_PRAGMA _A_ 1 _U_ 122 _N_ _S_ "U(ASAA)" {_A_ 1 _U_ 122 _N_ _N_ _N_ _N_} _N_ _SPECIALISE_ [ Bool ] 1 { _A_ 2 _U_ 22 _N_ _N_ _N_ _N_ }, [ Char ] 1 { _A_ 2 _U_ 12 _N_ _S_ "U(P)L" {_A_ 2 _U_ 22 _N_ _N_ _N_ _N_} _N_ _N_ }, [ Double ] 1 { _A_ 1 _U_ 12 _N_ _S_ "U(P)" {_A_ 1 _U_ 22 _N_ _N_ _N_ _N_} _N_ _N_ }, [ Int ] 1 { _A_ 2 _U_ 12 _N_ _S_ "U(P)L" {_A_ 2 _U_ 22 _N_ _N_ _N_ _N_} _N_ _N_ }, [ Integer ] 1 { _A_ 2 _U_ 12 _N_ _S_ "U(PPP)L" {_A_ 4 _U_ 2222 _N_ _N_ _N_ _N_} _N_ _N_ }, [ [Bool] ] 1 { _A_ 1 _U_ 12 _N_ _S_ "S" _F_ _IF_ARGS_ 0 1 X 3 \ (u0 :: [Bool]) -> _APP_ _TYAPP_ _ORIG_ PreludeCore _showList { Bool } [ _WRKR_ _CONSTM_ Text showsPrec (Bool), u0 ] _N_ }, [ [Char] ] 1 { _A_ 1 _U_ 22 _N_ _N_ _F_ _IF_ARGS_ 0 0 X 1 _CONSTM_ Text showList (Char) _N_ }, [ [Double] ] 1 { _A_ 1 _U_ 22 _N_ _N_ _F_ _IF_ARGS_ 0 0 X 1 _CONSTM_ Text showList (Double) _N_ }, [ [Int] ] 1 { _A_ 1 _U_ 22 _N_ _N_ _F_ _IF_ARGS_ 0 0 X 1 _CONSTM_ Text showList (Int) _N_ }, [ [Integer] ] 1 { _A_ 1 _U_ 22 _N_ _N_ _F_ _IF_ARGS_ 0 0 X 1 _CONSTM_ Text showList (Integer) _N_ }, [ [[Char]] ] 1 { _A_ 1 _U_ 12 _N_ _S_ "S" _F_ _IF_ARGS_ 0 1 X 3 \ (u0 :: [[Char]]) -> _APP_ _TYAPP_ _ORIG_ PreludeCore _showList { [Char] } [ _CONSTM_ Text showList (Char), u0 ] _N_ }, [ [[Int]] ] 1 { _A_ 1 _U_ 12 _N_ _S_ "S" _F_ _IF_ARGS_ 0 1 X 3 \ (u0 :: [[Int]]) -> _APP_ _TYAPP_ _ORIG_ PreludeCore _showList { [Int] } [ _CONSTM_ Text showList (Int), u0 ] _N_ }, [ [Complex Double] ] 1 { _A_ 1 _U_ 22 _N_ _N_ _F_ _IF_ARGS_ 0 0 X 1 _CONSTM_ Text showList (Complex Double) _N_ }, [ (Ratio Integer) ] 1 { _A_ 1 _U_ 12 _N_ _S_ "U(LL)" {_A_ 2 _U_ 222 _N_ _N_ _N_ _N_} _N_ _N_ }, [ (Array Int Double) ] 1 { _A_ 1 _U_ 22 _N_ _N_ _N_ _N_ }, [ (Array (Int, Int) Double) ] 1 { _A_ 1 _U_ 22 _N_ _N_ _N_ _N_ }, [ _PackedString ] 1 { _A_ 2 _U_ 12 _N_ _N_ _N_ _N_ }, [ (Complex Double) ] 1 { _A_ 1 _U_ 12 _N_ _S_ "U(LL)" {_A_ 2 _U_ 222 _N_ _N_ _N_ _N_} _N_ _N_ }, [ () ] 1 { _A_ 2 _U_ 12 _N_ _S_ "EL" _F_ _IF_ARGS_ 0 2 CX 4 \ (u0 :: ()) (u1 :: [Char]) -> case u0 of { _ALG_ _TUP_0 -> _APP_ _TYAPP_ _ORIG_ PreludeList (++) { Char } [ _NOREP_S_ "()", u1 ]; _NO_DEFLT_ } _N_ }, [ (Int, Int) ] 1 { _A_ 2 _U_ 12 _N_ _S_ "U(LL)L" {_A_ 3 _U_ 222 _N_ _N_ _N_ _N_} _N_ _N_ }, [ (Integer, Integer) ] 1 { _A_ 2 _U_ 12 _N_ _S_ "U(LL)L" {_A_ 3 _U_ 222 _N_ _N_ _N_ _N_} _N_ _N_ }, [ (Int, Int, Int) ] 1 { _A_ 2 _U_ 12 _N_ _S_ "U(LLL)L" {_A_ 4 _U_ 2222 _N_ _N_ _N_ _N_} _N_ _N_ } #-}
-{-# GHC_PRAGMA INTERFACE VERSION 5 #-}
+{-# GHC_PRAGMA INTERFACE VERSION 6 #-}
interface PreludeCore where
import PreludeArray(Array, Assoc(..), _ByteArray)
import PreludeBuiltin(Bin, Char(..), Double(..), Float(..), Int(..), Integer(..), List(..), Tuple0, Tuple2, Tuple3, Tuple4, Tuple5, _Addr(..), _CMP_TAG(..), _Word(..))
class Binary a where
readBin :: Bin -> (a, Bin)
{-# GHC_PRAGMA {-meth-} _A_ 1 _U_ 12 _N_ _S_ "S" _F_ _IF_ARGS_ 1 1 C 2 _/\_ u0 -> \ (u1 :: (Bin -> (u0, Bin), u0 -> Bin -> Bin)) -> case u1 of { _ALG_ _TUP_2 (u2 :: Bin -> (u0, Bin)) (u3 :: u0 -> Bin -> Bin) -> u2; _NO_DEFLT_ } _N_
- {-defm-} _A_ 2 _U_ 02 _N_ _S_ _!_ _F_ _IF_ARGS_ 1 2 XX 3 _/\_ u0 -> \ (u1 :: {{Binary u0}}) (u2 :: Bin) -> _APP_ _TYAPP_ patError# { (Bin -> (u0, Bin)) } [ _NOREP_S_ "%DPreludeCore.Binary.readBin\"", u2 ] _N_ #-}
+ {-defm-} _A_ 2 _U_ 02 _N_ _S_ _!_ _N_ _N_ #-}
showBin :: a -> Bin -> Bin
{-# GHC_PRAGMA {-meth-} _A_ 1 _U_ 122 _N_ _S_ "S" _F_ _IF_ARGS_ 1 1 C 2 _/\_ u0 -> \ (u1 :: (Bin -> (u0, Bin), u0 -> Bin -> Bin)) -> case u1 of { _ALG_ _TUP_2 (u2 :: Bin -> (u0, Bin)) (u3 :: u0 -> Bin -> Bin) -> u3; _NO_DEFLT_ } _N_
- {-defm-} _A_ 3 _U_ 022 _N_ _S_ _!_ _F_ _IF_ARGS_ 1 3 XXX 4 _/\_ u0 -> \ (u1 :: {{Binary u0}}) (u2 :: u0) (u3 :: Bin) -> _APP_ _TYAPP_ patError# { (u0 -> Bin -> Bin) } [ _NOREP_S_ "%DPreludeCore.Binary.showBin\"", u2, u3 ] _N_ #-}
+ {-defm-} _A_ 3 _U_ 022 _N_ _S_ _!_ _N_ _N_ #-}
class (Ord a) => Enum a {-# GHC_PRAGMA {-superdicts-} _A_ 1 _U_ 1 _N_ _S_ "S" _F_ _IF_ARGS_ 1 1 C 2 _/\_ u0 -> \ (u1 :: ({{Ord u0}}, u0 -> [u0], u0 -> u0 -> [u0], u0 -> u0 -> [u0], u0 -> u0 -> u0 -> [u0])) -> case u1 of { _ALG_ _TUP_5 (u2 :: {{Ord u0}}) (u3 :: u0 -> [u0]) (u4 :: u0 -> u0 -> [u0]) (u5 :: u0 -> u0 -> [u0]) (u6 :: u0 -> u0 -> u0 -> [u0]) -> u2; _NO_DEFLT_ } _N_ #-} where
enumFrom :: a -> [a]
{-# GHC_PRAGMA {-meth-} _A_ 1 _U_ 12 _N_ _S_ "S" _F_ _IF_ARGS_ 1 1 C 2 _/\_ u0 -> \ (u1 :: ({{Ord u0}}, u0 -> [u0], u0 -> u0 -> [u0], u0 -> u0 -> [u0], u0 -> u0 -> u0 -> [u0])) -> case u1 of { _ALG_ _TUP_5 (u2 :: {{Ord u0}}) (u3 :: u0 -> [u0]) (u4 :: u0 -> u0 -> [u0]) (u5 :: u0 -> u0 -> [u0]) (u6 :: u0 -> u0 -> u0 -> [u0]) -> u3; _NO_DEFLT_ } _N_
- {-defm-} _A_ 2 _U_ 02 _N_ _S_ _!_ _F_ _IF_ARGS_ 1 2 XX 3 _/\_ u0 -> \ (u1 :: {{Enum u0}}) (u2 :: u0) -> _APP_ _TYAPP_ patError# { (u0 -> [u0]) } [ _NOREP_S_ "%DPreludeCore.Enum.enumFrom\"", u2 ] _N_ #-}
+ {-defm-} _A_ 2 _U_ 02 _N_ _S_ _!_ _N_ _N_ #-}
enumFromThen :: a -> a -> [a]
{-# GHC_PRAGMA {-meth-} _A_ 1 _U_ 122 _N_ _S_ "S" _F_ _IF_ARGS_ 1 1 C 2 _/\_ u0 -> \ (u1 :: ({{Ord u0}}, u0 -> [u0], u0 -> u0 -> [u0], u0 -> u0 -> [u0], u0 -> u0 -> u0 -> [u0])) -> case u1 of { _ALG_ _TUP_5 (u2 :: {{Ord u0}}) (u3 :: u0 -> [u0]) (u4 :: u0 -> u0 -> [u0]) (u5 :: u0 -> u0 -> [u0]) (u6 :: u0 -> u0 -> u0 -> [u0]) -> u4; _NO_DEFLT_ } _N_
- {-defm-} _A_ 3 _U_ 022 _N_ _S_ _!_ _F_ _IF_ARGS_ 1 3 XXX 4 _/\_ u0 -> \ (u1 :: {{Enum u0}}) (u2 :: u0) (u3 :: u0) -> _APP_ _TYAPP_ patError# { (u0 -> u0 -> [u0]) } [ _NOREP_S_ "%DPreludeCore.Enum.enumFromThen\"", u2, u3 ] _N_ #-}
+ {-defm-} _A_ 3 _U_ 022 _N_ _S_ _!_ _N_ _N_ #-}
enumFromTo :: a -> a -> [a]
{-# GHC_PRAGMA {-meth-} _A_ 1 _U_ 122 _N_ _S_ "S" _F_ _IF_ARGS_ 1 1 C 2 _/\_ u0 -> \ (u1 :: ({{Ord u0}}, u0 -> [u0], u0 -> u0 -> [u0], u0 -> u0 -> [u0], u0 -> u0 -> u0 -> [u0])) -> case u1 of { _ALG_ _TUP_5 (u2 :: {{Ord u0}}) (u3 :: u0 -> [u0]) (u4 :: u0 -> u0 -> [u0]) (u5 :: u0 -> u0 -> [u0]) (u6 :: u0 -> u0 -> u0 -> [u0]) -> u5; _NO_DEFLT_ } _N_
{-defm-} _A_ 3 _U_ 122 _N_ _S_ "SLL" _N_ _N_ #-}
class Eq a where
(==) :: a -> a -> Bool
{-# GHC_PRAGMA {-meth-} _A_ 1 _U_ 122 _N_ _S_ "S" _F_ _IF_ARGS_ 1 1 C 2 _/\_ u0 -> \ (u1 :: (u0 -> u0 -> Bool, u0 -> u0 -> Bool)) -> case u1 of { _ALG_ _TUP_2 (u2 :: u0 -> u0 -> Bool) (u3 :: u0 -> u0 -> Bool) -> u2; _NO_DEFLT_ } _N_
- {-defm-} _A_ 3 _U_ 022 _N_ _S_ _!_ _F_ _IF_ARGS_ 1 3 XXX 4 _/\_ u0 -> \ (u1 :: {{Eq u0}}) (u2 :: u0) (u3 :: u0) -> _APP_ _TYAPP_ patError# { (u0 -> u0 -> Bool) } [ _NOREP_S_ "%DPreludeCore.Eq.(==)\"", u2, u3 ] _N_ #-}
+ {-defm-} _A_ 3 _U_ 022 _N_ _S_ _!_ _N_ _N_ #-}
(/=) :: a -> a -> Bool
{-# GHC_PRAGMA {-meth-} _A_ 1 _U_ 122 _N_ _S_ "S" _F_ _IF_ARGS_ 1 1 C 2 _/\_ u0 -> \ (u1 :: (u0 -> u0 -> Bool, u0 -> u0 -> Bool)) -> case u1 of { _ALG_ _TUP_2 (u2 :: u0 -> u0 -> Bool) (u3 :: u0 -> u0 -> Bool) -> u3; _NO_DEFLT_ } _N_
{-defm-} _A_ 3 _U_ 122 _N_ _S_ "SLL" _N_ _N_ #-}
class (Fractional a) => Floating a {-# GHC_PRAGMA {-superdicts-} _A_ 1 _U_ 1 _N_ _S_ "S" _F_ _IF_ARGS_ 1 1 C 2 _/\_ u0 -> \ (u1 :: ({{Fractional u0}}, u0, u0 -> u0, u0 -> u0, u0 -> u0, u0 -> u0 -> u0, u0 -> u0 -> u0, u0 -> u0, u0 -> u0, u0 -> u0, u0 -> u0, u0 -> u0, u0 -> u0, u0 -> u0, u0 -> u0, u0 -> u0, u0 -> u0, u0 -> u0, u0 -> u0)) -> case u1 of { _ALG_ _TUP_19 (u2 :: {{Fractional u0}}) (u3 :: u0) (u4 :: u0 -> u0) (u5 :: u0 -> u0) (u6 :: u0 -> u0) (u7 :: u0 -> u0 -> u0) (u8 :: u0 -> u0 -> u0) (u9 :: u0 -> u0) (ua :: u0 -> u0) (ub :: u0 -> u0) (uc :: u0 -> u0) (ud :: u0 -> u0) (ue :: u0 -> u0) (uf :: u0 -> u0) (ug :: u0 -> u0) (uh :: u0 -> u0) (ui :: u0 -> u0) (uj :: u0 -> u0) (uk :: u0 -> u0) -> u2; _NO_DEFLT_ } _N_ #-} where
pi :: a
{-# GHC_PRAGMA {-meth-} _A_ 1 _U_ 1 _N_ _S_ "S" _F_ _IF_ARGS_ 1 1 C 2 _/\_ u0 -> \ (u1 :: ({{Fractional u0}}, u0, u0 -> u0, u0 -> u0, u0 -> u0, u0 -> u0 -> u0, u0 -> u0 -> u0, u0 -> u0, u0 -> u0, u0 -> u0, u0 -> u0, u0 -> u0, u0 -> u0, u0 -> u0, u0 -> u0, u0 -> u0, u0 -> u0, u0 -> u0, u0 -> u0)) -> case u1 of { _ALG_ _TUP_19 (u2 :: {{Fractional u0}}) (u3 :: u0) (u4 :: u0 -> u0) (u5 :: u0 -> u0) (u6 :: u0 -> u0) (u7 :: u0 -> u0 -> u0) (u8 :: u0 -> u0 -> u0) (u9 :: u0 -> u0) (ua :: u0 -> u0) (ub :: u0 -> u0) (uc :: u0 -> u0) (ud :: u0 -> u0) (ue :: u0 -> u0) (uf :: u0 -> u0) (ug :: u0 -> u0) (uh :: u0 -> u0) (ui :: u0 -> u0) (uj :: u0 -> u0) (uk :: u0 -> u0) -> u3; _NO_DEFLT_ } _N_
- {-defm-} _A_ 1 _U_ 0 _N_ _S_ _!_ _F_ _IF_ARGS_ 1 1 X 2 _/\_ u0 -> \ (u1 :: {{Floating u0}}) -> _APP_ _TYAPP_ patError# { u0 } [ _NOREP_S_ "%DPreludeCore.Floating.pi\"" ] _N_ #-}
+ {-defm-} _A_ 1 _U_ 0 _N_ _S_ _!_ _N_ _N_ #-}
exp :: a -> a
{-# GHC_PRAGMA {-meth-} _A_ 1 _U_ 12 _N_ _S_ "S" _F_ _IF_ARGS_ 1 1 C 2 _/\_ u0 -> \ (u1 :: ({{Fractional u0}}, u0, u0 -> u0, u0 -> u0, u0 -> u0, u0 -> u0 -> u0, u0 -> u0 -> u0, u0 -> u0, u0 -> u0, u0 -> u0, u0 -> u0, u0 -> u0, u0 -> u0, u0 -> u0, u0 -> u0, u0 -> u0, u0 -> u0, u0 -> u0, u0 -> u0)) -> case u1 of { _ALG_ _TUP_19 (u2 :: {{Fractional u0}}) (u3 :: u0) (u4 :: u0 -> u0) (u5 :: u0 -> u0) (u6 :: u0 -> u0) (u7 :: u0 -> u0 -> u0) (u8 :: u0 -> u0 -> u0) (u9 :: u0 -> u0) (ua :: u0 -> u0) (ub :: u0 -> u0) (uc :: u0 -> u0) (ud :: u0 -> u0) (ue :: u0 -> u0) (uf :: u0 -> u0) (ug :: u0 -> u0) (uh :: u0 -> u0) (ui :: u0 -> u0) (uj :: u0 -> u0) (uk :: u0 -> u0) -> u4; _NO_DEFLT_ } _N_
- {-defm-} _A_ 2 _U_ 02 _N_ _S_ _!_ _F_ _IF_ARGS_ 1 2 XX 3 _/\_ u0 -> \ (u1 :: {{Floating u0}}) (u2 :: u0) -> _APP_ _TYAPP_ patError# { (u0 -> u0) } [ _NOREP_S_ "%DPreludeCore.Floating.exp\"", u2 ] _N_ #-}
+ {-defm-} _A_ 2 _U_ 02 _N_ _S_ _!_ _N_ _N_ #-}
log :: a -> a
{-# GHC_PRAGMA {-meth-} _A_ 1 _U_ 12 _N_ _S_ "S" _F_ _IF_ARGS_ 1 1 C 2 _/\_ u0 -> \ (u1 :: ({{Fractional u0}}, u0, u0 -> u0, u0 -> u0, u0 -> u0, u0 -> u0 -> u0, u0 -> u0 -> u0, u0 -> u0, u0 -> u0, u0 -> u0, u0 -> u0, u0 -> u0, u0 -> u0, u0 -> u0, u0 -> u0, u0 -> u0, u0 -> u0, u0 -> u0, u0 -> u0)) -> case u1 of { _ALG_ _TUP_19 (u2 :: {{Fractional u0}}) (u3 :: u0) (u4 :: u0 -> u0) (u5 :: u0 -> u0) (u6 :: u0 -> u0) (u7 :: u0 -> u0 -> u0) (u8 :: u0 -> u0 -> u0) (u9 :: u0 -> u0) (ua :: u0 -> u0) (ub :: u0 -> u0) (uc :: u0 -> u0) (ud :: u0 -> u0) (ue :: u0 -> u0) (uf :: u0 -> u0) (ug :: u0 -> u0) (uh :: u0 -> u0) (ui :: u0 -> u0) (uj :: u0 -> u0) (uk :: u0 -> u0) -> u5; _NO_DEFLT_ } _N_
- {-defm-} _A_ 2 _U_ 02 _N_ _S_ _!_ _F_ _IF_ARGS_ 1 2 XX 3 _/\_ u0 -> \ (u1 :: {{Floating u0}}) (u2 :: u0) -> _APP_ _TYAPP_ patError# { (u0 -> u0) } [ _NOREP_S_ "%DPreludeCore.Floating.log\"", u2 ] _N_ #-}
+ {-defm-} _A_ 2 _U_ 02 _N_ _S_ _!_ _N_ _N_ #-}
sqrt :: a -> a
{-# GHC_PRAGMA {-meth-} _A_ 1 _U_ 12 _N_ _S_ "S" _F_ _IF_ARGS_ 1 1 C 2 _/\_ u0 -> \ (u1 :: ({{Fractional u0}}, u0, u0 -> u0, u0 -> u0, u0 -> u0, u0 -> u0 -> u0, u0 -> u0 -> u0, u0 -> u0, u0 -> u0, u0 -> u0, u0 -> u0, u0 -> u0, u0 -> u0, u0 -> u0, u0 -> u0, u0 -> u0, u0 -> u0, u0 -> u0, u0 -> u0)) -> case u1 of { _ALG_ _TUP_19 (u2 :: {{Fractional u0}}) (u3 :: u0) (u4 :: u0 -> u0) (u5 :: u0 -> u0) (u6 :: u0 -> u0) (u7 :: u0 -> u0 -> u0) (u8 :: u0 -> u0 -> u0) (u9 :: u0 -> u0) (ua :: u0 -> u0) (ub :: u0 -> u0) (uc :: u0 -> u0) (ud :: u0 -> u0) (ue :: u0 -> u0) (uf :: u0 -> u0) (ug :: u0 -> u0) (uh :: u0 -> u0) (ui :: u0 -> u0) (uj :: u0 -> u0) (uk :: u0 -> u0) -> u6; _NO_DEFLT_ } _N_
{-defm-} _A_ 1 _U_ 12 _N_ _S_ "S" _N_ _N_ #-}
{-defm-} _A_ 3 _U_ 122 _N_ _S_ "SLL" _N_ _N_ #-}
sin :: a -> a
{-# GHC_PRAGMA {-meth-} _A_ 1 _U_ 12 _N_ _S_ "S" _F_ _IF_ARGS_ 1 1 C 2 _/\_ u0 -> \ (u1 :: ({{Fractional u0}}, u0, u0 -> u0, u0 -> u0, u0 -> u0, u0 -> u0 -> u0, u0 -> u0 -> u0, u0 -> u0, u0 -> u0, u0 -> u0, u0 -> u0, u0 -> u0, u0 -> u0, u0 -> u0, u0 -> u0, u0 -> u0, u0 -> u0, u0 -> u0, u0 -> u0)) -> case u1 of { _ALG_ _TUP_19 (u2 :: {{Fractional u0}}) (u3 :: u0) (u4 :: u0 -> u0) (u5 :: u0 -> u0) (u6 :: u0 -> u0) (u7 :: u0 -> u0 -> u0) (u8 :: u0 -> u0 -> u0) (u9 :: u0 -> u0) (ua :: u0 -> u0) (ub :: u0 -> u0) (uc :: u0 -> u0) (ud :: u0 -> u0) (ue :: u0 -> u0) (uf :: u0 -> u0) (ug :: u0 -> u0) (uh :: u0 -> u0) (ui :: u0 -> u0) (uj :: u0 -> u0) (uk :: u0 -> u0) -> u9; _NO_DEFLT_ } _N_
- {-defm-} _A_ 2 _U_ 02 _N_ _S_ _!_ _F_ _IF_ARGS_ 1 2 XX 3 _/\_ u0 -> \ (u1 :: {{Floating u0}}) (u2 :: u0) -> _APP_ _TYAPP_ patError# { (u0 -> u0) } [ _NOREP_S_ "%DPreludeCore.Floating.sin\"", u2 ] _N_ #-}
+ {-defm-} _A_ 2 _U_ 02 _N_ _S_ _!_ _N_ _N_ #-}
cos :: a -> a
{-# GHC_PRAGMA {-meth-} _A_ 1 _U_ 12 _N_ _S_ "S" _F_ _IF_ARGS_ 1 1 C 2 _/\_ u0 -> \ (u1 :: ({{Fractional u0}}, u0, u0 -> u0, u0 -> u0, u0 -> u0, u0 -> u0 -> u0, u0 -> u0 -> u0, u0 -> u0, u0 -> u0, u0 -> u0, u0 -> u0, u0 -> u0, u0 -> u0, u0 -> u0, u0 -> u0, u0 -> u0, u0 -> u0, u0 -> u0, u0 -> u0)) -> case u1 of { _ALG_ _TUP_19 (u2 :: {{Fractional u0}}) (u3 :: u0) (u4 :: u0 -> u0) (u5 :: u0 -> u0) (u6 :: u0 -> u0) (u7 :: u0 -> u0 -> u0) (u8 :: u0 -> u0 -> u0) (u9 :: u0 -> u0) (ua :: u0 -> u0) (ub :: u0 -> u0) (uc :: u0 -> u0) (ud :: u0 -> u0) (ue :: u0 -> u0) (uf :: u0 -> u0) (ug :: u0 -> u0) (uh :: u0 -> u0) (ui :: u0 -> u0) (uj :: u0 -> u0) (uk :: u0 -> u0) -> ua; _NO_DEFLT_ } _N_
- {-defm-} _A_ 2 _U_ 02 _N_ _S_ _!_ _F_ _IF_ARGS_ 1 2 XX 3 _/\_ u0 -> \ (u1 :: {{Floating u0}}) (u2 :: u0) -> _APP_ _TYAPP_ patError# { (u0 -> u0) } [ _NOREP_S_ "%DPreludeCore.Floating.cos\"", u2 ] _N_ #-}
+ {-defm-} _A_ 2 _U_ 02 _N_ _S_ _!_ _N_ _N_ #-}
tan :: a -> a
{-# GHC_PRAGMA {-meth-} _A_ 1 _U_ 12 _N_ _S_ "S" _F_ _IF_ARGS_ 1 1 C 2 _/\_ u0 -> \ (u1 :: ({{Fractional u0}}, u0, u0 -> u0, u0 -> u0, u0 -> u0, u0 -> u0 -> u0, u0 -> u0 -> u0, u0 -> u0, u0 -> u0, u0 -> u0, u0 -> u0, u0 -> u0, u0 -> u0, u0 -> u0, u0 -> u0, u0 -> u0, u0 -> u0, u0 -> u0, u0 -> u0)) -> case u1 of { _ALG_ _TUP_19 (u2 :: {{Fractional u0}}) (u3 :: u0) (u4 :: u0 -> u0) (u5 :: u0 -> u0) (u6 :: u0 -> u0) (u7 :: u0 -> u0 -> u0) (u8 :: u0 -> u0 -> u0) (u9 :: u0 -> u0) (ua :: u0 -> u0) (ub :: u0 -> u0) (uc :: u0 -> u0) (ud :: u0 -> u0) (ue :: u0 -> u0) (uf :: u0 -> u0) (ug :: u0 -> u0) (uh :: u0 -> u0) (ui :: u0 -> u0) (uj :: u0 -> u0) (uk :: u0 -> u0) -> ub; _NO_DEFLT_ } _N_
{-defm-} _A_ 2 _U_ 12 _N_ _S_ "SL" _N_ _N_ #-}
asin :: a -> a
{-# GHC_PRAGMA {-meth-} _A_ 1 _U_ 12 _N_ _S_ "S" _F_ _IF_ARGS_ 1 1 C 2 _/\_ u0 -> \ (u1 :: ({{Fractional u0}}, u0, u0 -> u0, u0 -> u0, u0 -> u0, u0 -> u0 -> u0, u0 -> u0 -> u0, u0 -> u0, u0 -> u0, u0 -> u0, u0 -> u0, u0 -> u0, u0 -> u0, u0 -> u0, u0 -> u0, u0 -> u0, u0 -> u0, u0 -> u0, u0 -> u0)) -> case u1 of { _ALG_ _TUP_19 (u2 :: {{Fractional u0}}) (u3 :: u0) (u4 :: u0 -> u0) (u5 :: u0 -> u0) (u6 :: u0 -> u0) (u7 :: u0 -> u0 -> u0) (u8 :: u0 -> u0 -> u0) (u9 :: u0 -> u0) (ua :: u0 -> u0) (ub :: u0 -> u0) (uc :: u0 -> u0) (ud :: u0 -> u0) (ue :: u0 -> u0) (uf :: u0 -> u0) (ug :: u0 -> u0) (uh :: u0 -> u0) (ui :: u0 -> u0) (uj :: u0 -> u0) (uk :: u0 -> u0) -> uc; _NO_DEFLT_ } _N_
- {-defm-} _A_ 2 _U_ 02 _N_ _S_ _!_ _F_ _IF_ARGS_ 1 2 XX 3 _/\_ u0 -> \ (u1 :: {{Floating u0}}) (u2 :: u0) -> _APP_ _TYAPP_ patError# { (u0 -> u0) } [ _NOREP_S_ "%DPreludeCore.Floating.asin\"", u2 ] _N_ #-}
+ {-defm-} _A_ 2 _U_ 02 _N_ _S_ _!_ _N_ _N_ #-}
acos :: a -> a
{-# GHC_PRAGMA {-meth-} _A_ 1 _U_ 12 _N_ _S_ "S" _F_ _IF_ARGS_ 1 1 C 2 _/\_ u0 -> \ (u1 :: ({{Fractional u0}}, u0, u0 -> u0, u0 -> u0, u0 -> u0, u0 -> u0 -> u0, u0 -> u0 -> u0, u0 -> u0, u0 -> u0, u0 -> u0, u0 -> u0, u0 -> u0, u0 -> u0, u0 -> u0, u0 -> u0, u0 -> u0, u0 -> u0, u0 -> u0, u0 -> u0)) -> case u1 of { _ALG_ _TUP_19 (u2 :: {{Fractional u0}}) (u3 :: u0) (u4 :: u0 -> u0) (u5 :: u0 -> u0) (u6 :: u0 -> u0) (u7 :: u0 -> u0 -> u0) (u8 :: u0 -> u0 -> u0) (u9 :: u0 -> u0) (ua :: u0 -> u0) (ub :: u0 -> u0) (uc :: u0 -> u0) (ud :: u0 -> u0) (ue :: u0 -> u0) (uf :: u0 -> u0) (ug :: u0 -> u0) (uh :: u0 -> u0) (ui :: u0 -> u0) (uj :: u0 -> u0) (uk :: u0 -> u0) -> ud; _NO_DEFLT_ } _N_
- {-defm-} _A_ 2 _U_ 02 _N_ _S_ _!_ _F_ _IF_ARGS_ 1 2 XX 3 _/\_ u0 -> \ (u1 :: {{Floating u0}}) (u2 :: u0) -> _APP_ _TYAPP_ patError# { (u0 -> u0) } [ _NOREP_S_ "%DPreludeCore.Floating.acos\"", u2 ] _N_ #-}
+ {-defm-} _A_ 2 _U_ 02 _N_ _S_ _!_ _N_ _N_ #-}
atan :: a -> a
{-# GHC_PRAGMA {-meth-} _A_ 1 _U_ 12 _N_ _S_ "S" _F_ _IF_ARGS_ 1 1 C 2 _/\_ u0 -> \ (u1 :: ({{Fractional u0}}, u0, u0 -> u0, u0 -> u0, u0 -> u0, u0 -> u0 -> u0, u0 -> u0 -> u0, u0 -> u0, u0 -> u0, u0 -> u0, u0 -> u0, u0 -> u0, u0 -> u0, u0 -> u0, u0 -> u0, u0 -> u0, u0 -> u0, u0 -> u0, u0 -> u0)) -> case u1 of { _ALG_ _TUP_19 (u2 :: {{Fractional u0}}) (u3 :: u0) (u4 :: u0 -> u0) (u5 :: u0 -> u0) (u6 :: u0 -> u0) (u7 :: u0 -> u0 -> u0) (u8 :: u0 -> u0 -> u0) (u9 :: u0 -> u0) (ua :: u0 -> u0) (ub :: u0 -> u0) (uc :: u0 -> u0) (ud :: u0 -> u0) (ue :: u0 -> u0) (uf :: u0 -> u0) (ug :: u0 -> u0) (uh :: u0 -> u0) (ui :: u0 -> u0) (uj :: u0 -> u0) (uk :: u0 -> u0) -> ue; _NO_DEFLT_ } _N_
- {-defm-} _A_ 2 _U_ 02 _N_ _S_ _!_ _F_ _IF_ARGS_ 1 2 XX 3 _/\_ u0 -> \ (u1 :: {{Floating u0}}) (u2 :: u0) -> _APP_ _TYAPP_ patError# { (u0 -> u0) } [ _NOREP_S_ "%DPreludeCore.Floating.atan\"", u2 ] _N_ #-}
+ {-defm-} _A_ 2 _U_ 02 _N_ _S_ _!_ _N_ _N_ #-}
sinh :: a -> a
{-# GHC_PRAGMA {-meth-} _A_ 1 _U_ 12 _N_ _S_ "S" _F_ _IF_ARGS_ 1 1 C 2 _/\_ u0 -> \ (u1 :: ({{Fractional u0}}, u0, u0 -> u0, u0 -> u0, u0 -> u0, u0 -> u0 -> u0, u0 -> u0 -> u0, u0 -> u0, u0 -> u0, u0 -> u0, u0 -> u0, u0 -> u0, u0 -> u0, u0 -> u0, u0 -> u0, u0 -> u0, u0 -> u0, u0 -> u0, u0 -> u0)) -> case u1 of { _ALG_ _TUP_19 (u2 :: {{Fractional u0}}) (u3 :: u0) (u4 :: u0 -> u0) (u5 :: u0 -> u0) (u6 :: u0 -> u0) (u7 :: u0 -> u0 -> u0) (u8 :: u0 -> u0 -> u0) (u9 :: u0 -> u0) (ua :: u0 -> u0) (ub :: u0 -> u0) (uc :: u0 -> u0) (ud :: u0 -> u0) (ue :: u0 -> u0) (uf :: u0 -> u0) (ug :: u0 -> u0) (uh :: u0 -> u0) (ui :: u0 -> u0) (uj :: u0 -> u0) (uk :: u0 -> u0) -> uf; _NO_DEFLT_ } _N_
- {-defm-} _A_ 2 _U_ 02 _N_ _S_ _!_ _F_ _IF_ARGS_ 1 2 XX 3 _/\_ u0 -> \ (u1 :: {{Floating u0}}) (u2 :: u0) -> _APP_ _TYAPP_ patError# { (u0 -> u0) } [ _NOREP_S_ "%DPreludeCore.Floating.sinh\"", u2 ] _N_ #-}
+ {-defm-} _A_ 2 _U_ 02 _N_ _S_ _!_ _N_ _N_ #-}
cosh :: a -> a
{-# GHC_PRAGMA {-meth-} _A_ 1 _U_ 12 _N_ _S_ "S" _F_ _IF_ARGS_ 1 1 C 2 _/\_ u0 -> \ (u1 :: ({{Fractional u0}}, u0, u0 -> u0, u0 -> u0, u0 -> u0, u0 -> u0 -> u0, u0 -> u0 -> u0, u0 -> u0, u0 -> u0, u0 -> u0, u0 -> u0, u0 -> u0, u0 -> u0, u0 -> u0, u0 -> u0, u0 -> u0, u0 -> u0, u0 -> u0, u0 -> u0)) -> case u1 of { _ALG_ _TUP_19 (u2 :: {{Fractional u0}}) (u3 :: u0) (u4 :: u0 -> u0) (u5 :: u0 -> u0) (u6 :: u0 -> u0) (u7 :: u0 -> u0 -> u0) (u8 :: u0 -> u0 -> u0) (u9 :: u0 -> u0) (ua :: u0 -> u0) (ub :: u0 -> u0) (uc :: u0 -> u0) (ud :: u0 -> u0) (ue :: u0 -> u0) (uf :: u0 -> u0) (ug :: u0 -> u0) (uh :: u0 -> u0) (ui :: u0 -> u0) (uj :: u0 -> u0) (uk :: u0 -> u0) -> ug; _NO_DEFLT_ } _N_
- {-defm-} _A_ 2 _U_ 02 _N_ _S_ _!_ _F_ _IF_ARGS_ 1 2 XX 3 _/\_ u0 -> \ (u1 :: {{Floating u0}}) (u2 :: u0) -> _APP_ _TYAPP_ patError# { (u0 -> u0) } [ _NOREP_S_ "%DPreludeCore.Floating.cosh\"", u2 ] _N_ #-}
+ {-defm-} _A_ 2 _U_ 02 _N_ _S_ _!_ _N_ _N_ #-}
tanh :: a -> a
{-# GHC_PRAGMA {-meth-} _A_ 1 _U_ 12 _N_ _S_ "S" _F_ _IF_ARGS_ 1 1 C 2 _/\_ u0 -> \ (u1 :: ({{Fractional u0}}, u0, u0 -> u0, u0 -> u0, u0 -> u0, u0 -> u0 -> u0, u0 -> u0 -> u0, u0 -> u0, u0 -> u0, u0 -> u0, u0 -> u0, u0 -> u0, u0 -> u0, u0 -> u0, u0 -> u0, u0 -> u0, u0 -> u0, u0 -> u0, u0 -> u0)) -> case u1 of { _ALG_ _TUP_19 (u2 :: {{Fractional u0}}) (u3 :: u0) (u4 :: u0 -> u0) (u5 :: u0 -> u0) (u6 :: u0 -> u0) (u7 :: u0 -> u0 -> u0) (u8 :: u0 -> u0 -> u0) (u9 :: u0 -> u0) (ua :: u0 -> u0) (ub :: u0 -> u0) (uc :: u0 -> u0) (ud :: u0 -> u0) (ue :: u0 -> u0) (uf :: u0 -> u0) (ug :: u0 -> u0) (uh :: u0 -> u0) (ui :: u0 -> u0) (uj :: u0 -> u0) (uk :: u0 -> u0) -> uh; _NO_DEFLT_ } _N_
{-defm-} _A_ 2 _U_ 12 _N_ _S_ "SL" _N_ _N_ #-}
asinh :: a -> a
{-# GHC_PRAGMA {-meth-} _A_ 1 _U_ 12 _N_ _S_ "S" _F_ _IF_ARGS_ 1 1 C 2 _/\_ u0 -> \ (u1 :: ({{Fractional u0}}, u0, u0 -> u0, u0 -> u0, u0 -> u0, u0 -> u0 -> u0, u0 -> u0 -> u0, u0 -> u0, u0 -> u0, u0 -> u0, u0 -> u0, u0 -> u0, u0 -> u0, u0 -> u0, u0 -> u0, u0 -> u0, u0 -> u0, u0 -> u0, u0 -> u0)) -> case u1 of { _ALG_ _TUP_19 (u2 :: {{Fractional u0}}) (u3 :: u0) (u4 :: u0 -> u0) (u5 :: u0 -> u0) (u6 :: u0 -> u0) (u7 :: u0 -> u0 -> u0) (u8 :: u0 -> u0 -> u0) (u9 :: u0 -> u0) (ua :: u0 -> u0) (ub :: u0 -> u0) (uc :: u0 -> u0) (ud :: u0 -> u0) (ue :: u0 -> u0) (uf :: u0 -> u0) (ug :: u0 -> u0) (uh :: u0 -> u0) (ui :: u0 -> u0) (uj :: u0 -> u0) (uk :: u0 -> u0) -> ui; _NO_DEFLT_ } _N_
- {-defm-} _A_ 2 _U_ 02 _N_ _S_ _!_ _F_ _IF_ARGS_ 1 2 XX 3 _/\_ u0 -> \ (u1 :: {{Floating u0}}) (u2 :: u0) -> _APP_ _TYAPP_ patError# { (u0 -> u0) } [ _NOREP_S_ "%DPreludeCore.Floating.asinh\"", u2 ] _N_ #-}
+ {-defm-} _A_ 2 _U_ 02 _N_ _S_ _!_ _N_ _N_ #-}
acosh :: a -> a
{-# GHC_PRAGMA {-meth-} _A_ 1 _U_ 12 _N_ _S_ "S" _F_ _IF_ARGS_ 1 1 C 2 _/\_ u0 -> \ (u1 :: ({{Fractional u0}}, u0, u0 -> u0, u0 -> u0, u0 -> u0, u0 -> u0 -> u0, u0 -> u0 -> u0, u0 -> u0, u0 -> u0, u0 -> u0, u0 -> u0, u0 -> u0, u0 -> u0, u0 -> u0, u0 -> u0, u0 -> u0, u0 -> u0, u0 -> u0, u0 -> u0)) -> case u1 of { _ALG_ _TUP_19 (u2 :: {{Fractional u0}}) (u3 :: u0) (u4 :: u0 -> u0) (u5 :: u0 -> u0) (u6 :: u0 -> u0) (u7 :: u0 -> u0 -> u0) (u8 :: u0 -> u0 -> u0) (u9 :: u0 -> u0) (ua :: u0 -> u0) (ub :: u0 -> u0) (uc :: u0 -> u0) (ud :: u0 -> u0) (ue :: u0 -> u0) (uf :: u0 -> u0) (ug :: u0 -> u0) (uh :: u0 -> u0) (ui :: u0 -> u0) (uj :: u0 -> u0) (uk :: u0 -> u0) -> uj; _NO_DEFLT_ } _N_
- {-defm-} _A_ 2 _U_ 02 _N_ _S_ _!_ _F_ _IF_ARGS_ 1 2 XX 3 _/\_ u0 -> \ (u1 :: {{Floating u0}}) (u2 :: u0) -> _APP_ _TYAPP_ patError# { (u0 -> u0) } [ _NOREP_S_ "%DPreludeCore.Floating.acosh\"", u2 ] _N_ #-}
+ {-defm-} _A_ 2 _U_ 02 _N_ _S_ _!_ _N_ _N_ #-}
atanh :: a -> a
{-# GHC_PRAGMA {-meth-} _A_ 1 _U_ 12 _N_ _S_ "S" _F_ _IF_ARGS_ 1 1 C 2 _/\_ u0 -> \ (u1 :: ({{Fractional u0}}, u0, u0 -> u0, u0 -> u0, u0 -> u0, u0 -> u0 -> u0, u0 -> u0 -> u0, u0 -> u0, u0 -> u0, u0 -> u0, u0 -> u0, u0 -> u0, u0 -> u0, u0 -> u0, u0 -> u0, u0 -> u0, u0 -> u0, u0 -> u0, u0 -> u0)) -> case u1 of { _ALG_ _TUP_19 (u2 :: {{Fractional u0}}) (u3 :: u0) (u4 :: u0 -> u0) (u5 :: u0 -> u0) (u6 :: u0 -> u0) (u7 :: u0 -> u0 -> u0) (u8 :: u0 -> u0 -> u0) (u9 :: u0 -> u0) (ua :: u0 -> u0) (ub :: u0 -> u0) (uc :: u0 -> u0) (ud :: u0 -> u0) (ue :: u0 -> u0) (uf :: u0 -> u0) (ug :: u0 -> u0) (uh :: u0 -> u0) (ui :: u0 -> u0) (uj :: u0 -> u0) (uk :: u0 -> u0) -> uk; _NO_DEFLT_ } _N_
- {-defm-} _A_ 2 _U_ 02 _N_ _S_ _!_ _F_ _IF_ARGS_ 1 2 XX 3 _/\_ u0 -> \ (u1 :: {{Floating u0}}) (u2 :: u0) -> _APP_ _TYAPP_ patError# { (u0 -> u0) } [ _NOREP_S_ "%DPreludeCore.Floating.atanh\"", u2 ] _N_ #-}
+ {-defm-} _A_ 2 _U_ 02 _N_ _S_ _!_ _N_ _N_ #-}
class (Num a) => Fractional a {-# GHC_PRAGMA {-superdicts-} _A_ 1 _U_ 1 _N_ _S_ "S" _F_ _IF_ARGS_ 1 1 C 2 _/\_ u0 -> \ (u1 :: ({{Num u0}}, u0 -> u0 -> u0, u0 -> u0, Ratio Integer -> u0)) -> case u1 of { _ALG_ _TUP_4 (u2 :: {{Num u0}}) (u3 :: u0 -> u0 -> u0) (u4 :: u0 -> u0) (u5 :: Ratio Integer -> u0) -> u2; _NO_DEFLT_ } _N_ #-} where
(/) :: a -> a -> a
{-# GHC_PRAGMA {-meth-} _A_ 1 _U_ 122 _N_ _S_ "S" _F_ _IF_ARGS_ 1 1 C 2 _/\_ u0 -> \ (u1 :: ({{Num u0}}, u0 -> u0 -> u0, u0 -> u0, Ratio Integer -> u0)) -> case u1 of { _ALG_ _TUP_4 (u2 :: {{Num u0}}) (u3 :: u0 -> u0 -> u0) (u4 :: u0 -> u0) (u5 :: Ratio Integer -> u0) -> u3; _NO_DEFLT_ } _N_
- {-defm-} _A_ 3 _U_ 022 _N_ _S_ _!_ _F_ _IF_ARGS_ 1 3 XXX 4 _/\_ u0 -> \ (u1 :: {{Fractional u0}}) (u2 :: u0) (u3 :: u0) -> _APP_ _TYAPP_ patError# { (u0 -> u0 -> u0) } [ _NOREP_S_ "%DPreludeCore.Fractional.(/)\"", u2, u3 ] _N_ #-}
+ {-defm-} _A_ 3 _U_ 022 _N_ _S_ _!_ _N_ _N_ #-}
recip :: a -> a
{-# GHC_PRAGMA {-meth-} _A_ 1 _U_ 12 _N_ _S_ "S" _F_ _IF_ARGS_ 1 1 C 2 _/\_ u0 -> \ (u1 :: ({{Num u0}}, u0 -> u0 -> u0, u0 -> u0, Ratio Integer -> u0)) -> case u1 of { _ALG_ _TUP_4 (u2 :: {{Num u0}}) (u3 :: u0 -> u0 -> u0) (u4 :: u0 -> u0) (u5 :: Ratio Integer -> u0) -> u4; _NO_DEFLT_ } _N_
{-defm-} _A_ 1 _U_ 12 _N_ _S_ "S" _N_ _N_ #-}
fromRational :: Ratio Integer -> a
{-# GHC_PRAGMA {-meth-} _A_ 1 _U_ 12 _N_ _S_ "S" _F_ _IF_ARGS_ 1 1 C 2 _/\_ u0 -> \ (u1 :: ({{Num u0}}, u0 -> u0 -> u0, u0 -> u0, Ratio Integer -> u0)) -> case u1 of { _ALG_ _TUP_4 (u2 :: {{Num u0}}) (u3 :: u0 -> u0 -> u0) (u4 :: u0 -> u0) (u5 :: Ratio Integer -> u0) -> u5; _NO_DEFLT_ } _N_
- {-defm-} _A_ 2 _U_ 02 _N_ _S_ _!_ _F_ _IF_ARGS_ 1 2 XX 3 _/\_ u0 -> \ (u1 :: {{Fractional u0}}) (u2 :: Ratio Integer) -> _APP_ _TYAPP_ patError# { (Ratio Integer -> u0) } [ _NOREP_S_ "%DPreludeCore.Fractional.fromRational\"", u2 ] _N_ #-}
+ {-defm-} _A_ 2 _U_ 02 _N_ _S_ _!_ _N_ _N_ #-}
class (Real a, Ix a) => Integral a {-# GHC_PRAGMA {-superdicts-} _A_ 1 _U_ 1 _N_ _S_ "S" _F_ _IF_ARGS_ 1 1 C 2 _/\_ u0 -> \ (u1 :: ({{Real u0}}, {{Ix u0}}, u0 -> u0 -> u0, u0 -> u0 -> u0, u0 -> u0 -> u0, u0 -> u0 -> u0, u0 -> u0 -> (u0, u0), u0 -> u0 -> (u0, u0), u0 -> Bool, u0 -> Bool, u0 -> Integer, u0 -> Int)) -> case u1 of { _ALG_ _TUP_12 (u2 :: {{Real u0}}) (u3 :: {{Ix u0}}) (u4 :: u0 -> u0 -> u0) (u5 :: u0 -> u0 -> u0) (u6 :: u0 -> u0 -> u0) (u7 :: u0 -> u0 -> u0) (u8 :: u0 -> u0 -> (u0, u0)) (u9 :: u0 -> u0 -> (u0, u0)) (ua :: u0 -> Bool) (ub :: u0 -> Bool) (uc :: u0 -> Integer) (ud :: u0 -> Int) -> u2; _NO_DEFLT_ } _N_, _A_ 1 _U_ 1 _N_ _S_ "S" _F_ _IF_ARGS_ 1 1 C 2 _/\_ u0 -> \ (u1 :: ({{Real u0}}, {{Ix u0}}, u0 -> u0 -> u0, u0 -> u0 -> u0, u0 -> u0 -> u0, u0 -> u0 -> u0, u0 -> u0 -> (u0, u0), u0 -> u0 -> (u0, u0), u0 -> Bool, u0 -> Bool, u0 -> Integer, u0 -> Int)) -> case u1 of { _ALG_ _TUP_12 (u2 :: {{Real u0}}) (u3 :: {{Ix u0}}) (u4 :: u0 -> u0 -> u0) (u5 :: u0 -> u0 -> u0) (u6 :: u0 -> u0 -> u0) (u7 :: u0 -> u0 -> u0) (u8 :: u0 -> u0 -> (u0, u0)) (u9 :: u0 -> u0 -> (u0, u0)) (ua :: u0 -> Bool) (ub :: u0 -> Bool) (uc :: u0 -> Integer) (ud :: u0 -> Int) -> u3; _NO_DEFLT_ } _N_ #-} where
quot :: a -> a -> a
{-# GHC_PRAGMA {-meth-} _A_ 1 _U_ 122 _N_ _S_ "S" _F_ _IF_ARGS_ 1 1 C 2 _/\_ u0 -> \ (u1 :: ({{Real u0}}, {{Ix u0}}, u0 -> u0 -> u0, u0 -> u0 -> u0, u0 -> u0 -> u0, u0 -> u0 -> u0, u0 -> u0 -> (u0, u0), u0 -> u0 -> (u0, u0), u0 -> Bool, u0 -> Bool, u0 -> Integer, u0 -> Int)) -> case u1 of { _ALG_ _TUP_12 (u2 :: {{Real u0}}) (u3 :: {{Ix u0}}) (u4 :: u0 -> u0 -> u0) (u5 :: u0 -> u0 -> u0) (u6 :: u0 -> u0 -> u0) (u7 :: u0 -> u0 -> u0) (u8 :: u0 -> u0 -> (u0, u0)) (u9 :: u0 -> u0 -> (u0, u0)) (ua :: u0 -> Bool) (ub :: u0 -> Bool) (uc :: u0 -> Integer) (ud :: u0 -> Int) -> u4; _NO_DEFLT_ } _N_
{-defm-} _A_ 3 _U_ 122 _N_ _S_ "SLL" _F_ _IF_ARGS_ 1 3 CXX 6 _/\_ u0 -> \ (u1 :: {{Integral u0}}) (u2 :: u0) (u3 :: u0) -> case case u1 of { _ALG_ _TUP_12 (u4 :: {{Real u0}}) (u5 :: {{Ix u0}}) (u6 :: u0 -> u0 -> u0) (u7 :: u0 -> u0 -> u0) (u8 :: u0 -> u0 -> u0) (u9 :: u0 -> u0 -> u0) (ua :: u0 -> u0 -> (u0, u0)) (ub :: u0 -> u0 -> (u0, u0)) (uc :: u0 -> Bool) (ud :: u0 -> Bool) (ue :: u0 -> Integer) (uf :: u0 -> Int) -> _APP_ ub [ u2, u3 ]; _NO_DEFLT_ } of { _ALG_ _TUP_2 (ug :: u0) (uh :: u0) -> uh; _NO_DEFLT_ } _N_ #-}
quotRem :: a -> a -> (a, a)
{-# GHC_PRAGMA {-meth-} _A_ 1 _U_ 122 _N_ _S_ "S" _F_ _IF_ARGS_ 1 1 C 2 _/\_ u0 -> \ (u1 :: ({{Real u0}}, {{Ix u0}}, u0 -> u0 -> u0, u0 -> u0 -> u0, u0 -> u0 -> u0, u0 -> u0 -> u0, u0 -> u0 -> (u0, u0), u0 -> u0 -> (u0, u0), u0 -> Bool, u0 -> Bool, u0 -> Integer, u0 -> Int)) -> case u1 of { _ALG_ _TUP_12 (u2 :: {{Real u0}}) (u3 :: {{Ix u0}}) (u4 :: u0 -> u0 -> u0) (u5 :: u0 -> u0 -> u0) (u6 :: u0 -> u0 -> u0) (u7 :: u0 -> u0 -> u0) (u8 :: u0 -> u0 -> (u0, u0)) (u9 :: u0 -> u0 -> (u0, u0)) (ua :: u0 -> Bool) (ub :: u0 -> Bool) (uc :: u0 -> Integer) (ud :: u0 -> Int) -> u8; _NO_DEFLT_ } _N_
- {-defm-} _A_ 3 _U_ 022 _N_ _S_ _!_ _F_ _IF_ARGS_ 1 3 XXX 4 _/\_ u0 -> \ (u1 :: {{Integral u0}}) (u2 :: u0) (u3 :: u0) -> _APP_ _TYAPP_ patError# { (u0 -> u0 -> (u0, u0)) } [ _NOREP_S_ "%DPreludeCore.Integral.quotRem\"", u2, u3 ] _N_ #-}
+ {-defm-} _A_ 3 _U_ 022 _N_ _S_ _!_ _N_ _N_ #-}
divMod :: a -> a -> (a, a)
{-# GHC_PRAGMA {-meth-} _A_ 1 _U_ 122 _N_ _S_ "S" _F_ _IF_ARGS_ 1 1 C 2 _/\_ u0 -> \ (u1 :: ({{Real u0}}, {{Ix u0}}, u0 -> u0 -> u0, u0 -> u0 -> u0, u0 -> u0 -> u0, u0 -> u0 -> u0, u0 -> u0 -> (u0, u0), u0 -> u0 -> (u0, u0), u0 -> Bool, u0 -> Bool, u0 -> Integer, u0 -> Int)) -> case u1 of { _ALG_ _TUP_12 (u2 :: {{Real u0}}) (u3 :: {{Ix u0}}) (u4 :: u0 -> u0 -> u0) (u5 :: u0 -> u0 -> u0) (u6 :: u0 -> u0 -> u0) (u7 :: u0 -> u0 -> u0) (u8 :: u0 -> u0 -> (u0, u0)) (u9 :: u0 -> u0 -> (u0, u0)) (ua :: u0 -> Bool) (ub :: u0 -> Bool) (uc :: u0 -> Integer) (ud :: u0 -> Int) -> u9; _NO_DEFLT_ } _N_
{-defm-} _A_ 1 _U_ 122 _N_ _S_ "S" _N_ _N_ #-}
{-defm-} _A_ 1 _U_ 12 _N_ _S_ "S" _N_ _N_ #-}
toInteger :: a -> Integer
{-# GHC_PRAGMA {-meth-} _A_ 1 _U_ 12 _N_ _S_ "S" _F_ _IF_ARGS_ 1 1 C 2 _/\_ u0 -> \ (u1 :: ({{Real u0}}, {{Ix u0}}, u0 -> u0 -> u0, u0 -> u0 -> u0, u0 -> u0 -> u0, u0 -> u0 -> u0, u0 -> u0 -> (u0, u0), u0 -> u0 -> (u0, u0), u0 -> Bool, u0 -> Bool, u0 -> Integer, u0 -> Int)) -> case u1 of { _ALG_ _TUP_12 (u2 :: {{Real u0}}) (u3 :: {{Ix u0}}) (u4 :: u0 -> u0 -> u0) (u5 :: u0 -> u0 -> u0) (u6 :: u0 -> u0 -> u0) (u7 :: u0 -> u0 -> u0) (u8 :: u0 -> u0 -> (u0, u0)) (u9 :: u0 -> u0 -> (u0, u0)) (ua :: u0 -> Bool) (ub :: u0 -> Bool) (uc :: u0 -> Integer) (ud :: u0 -> Int) -> uc; _NO_DEFLT_ } _N_
- {-defm-} _A_ 2 _U_ 02 _N_ _S_ _!_ _F_ _IF_ARGS_ 1 2 XX 3 _/\_ u0 -> \ (u1 :: {{Integral u0}}) (u2 :: u0) -> _APP_ _TYAPP_ patError# { (u0 -> Integer) } [ _NOREP_S_ "%DPreludeCore.Integral.toInteger\"", u2 ] _N_ #-}
+ {-defm-} _A_ 2 _U_ 02 _N_ _S_ _!_ _N_ _N_ #-}
toInt :: a -> Int
{-# GHC_PRAGMA {-meth-} _A_ 1 _U_ 12 _N_ _S_ "S" _F_ _IF_ARGS_ 1 1 C 2 _/\_ u0 -> \ (u1 :: ({{Real u0}}, {{Ix u0}}, u0 -> u0 -> u0, u0 -> u0 -> u0, u0 -> u0 -> u0, u0 -> u0 -> u0, u0 -> u0 -> (u0, u0), u0 -> u0 -> (u0, u0), u0 -> Bool, u0 -> Bool, u0 -> Integer, u0 -> Int)) -> case u1 of { _ALG_ _TUP_12 (u2 :: {{Real u0}}) (u3 :: {{Ix u0}}) (u4 :: u0 -> u0 -> u0) (u5 :: u0 -> u0 -> u0) (u6 :: u0 -> u0 -> u0) (u7 :: u0 -> u0 -> u0) (u8 :: u0 -> u0 -> (u0, u0)) (u9 :: u0 -> u0 -> (u0, u0)) (ua :: u0 -> Bool) (ub :: u0 -> Bool) (uc :: u0 -> Integer) (ud :: u0 -> Int) -> ud; _NO_DEFLT_ } _N_
- {-defm-} _A_ 2 _U_ 02 _N_ _S_ _!_ _F_ _IF_ARGS_ 1 2 XX 3 _/\_ u0 -> \ (u1 :: {{Integral u0}}) (u2 :: u0) -> _APP_ _TYAPP_ patError# { (u0 -> Int) } [ _NOREP_S_ "%DPreludeCore.Integral.toInt\"", u2 ] _N_ #-}
+ {-defm-} _A_ 2 _U_ 02 _N_ _S_ _!_ _N_ _N_ #-}
class (Ord a) => Ix a {-# GHC_PRAGMA {-superdicts-} _A_ 1 _U_ 1 _N_ _S_ "S" _F_ _IF_ARGS_ 1 1 C 2 _/\_ u0 -> \ (u1 :: ({{Ord u0}}, (u0, u0) -> [u0], (u0, u0) -> u0 -> Int, (u0, u0) -> u0 -> Bool)) -> case u1 of { _ALG_ _TUP_4 (u2 :: {{Ord u0}}) (u3 :: (u0, u0) -> [u0]) (u4 :: (u0, u0) -> u0 -> Int) (u5 :: (u0, u0) -> u0 -> Bool) -> u2; _NO_DEFLT_ } _N_ #-} where
range :: (a, a) -> [a]
{-# GHC_PRAGMA {-meth-} _A_ 1 _U_ 12 _N_ _S_ "S" _F_ _IF_ARGS_ 1 1 C 2 _/\_ u0 -> \ (u1 :: ({{Ord u0}}, (u0, u0) -> [u0], (u0, u0) -> u0 -> Int, (u0, u0) -> u0 -> Bool)) -> case u1 of { _ALG_ _TUP_4 (u2 :: {{Ord u0}}) (u3 :: (u0, u0) -> [u0]) (u4 :: (u0, u0) -> u0 -> Int) (u5 :: (u0, u0) -> u0 -> Bool) -> u3; _NO_DEFLT_ } _N_
- {-defm-} _A_ 2 _U_ 02 _N_ _S_ _!_ _F_ _IF_ARGS_ 1 2 XX 3 _/\_ u0 -> \ (u1 :: {{Ix u0}}) (u2 :: (u0, u0)) -> _APP_ _TYAPP_ patError# { ((u0, u0) -> [u0]) } [ _NOREP_S_ "%DPreludeCore.Ix.range\"", u2 ] _N_ #-}
+ {-defm-} _A_ 2 _U_ 02 _N_ _S_ _!_ _N_ _N_ #-}
index :: (a, a) -> a -> Int
{-# GHC_PRAGMA {-meth-} _A_ 1 _U_ 122 _N_ _S_ "S" _F_ _IF_ARGS_ 1 1 C 2 _/\_ u0 -> \ (u1 :: ({{Ord u0}}, (u0, u0) -> [u0], (u0, u0) -> u0 -> Int, (u0, u0) -> u0 -> Bool)) -> case u1 of { _ALG_ _TUP_4 (u2 :: {{Ord u0}}) (u3 :: (u0, u0) -> [u0]) (u4 :: (u0, u0) -> u0 -> Int) (u5 :: (u0, u0) -> u0 -> Bool) -> u4; _NO_DEFLT_ } _N_
- {-defm-} _A_ 3 _U_ 022 _N_ _S_ _!_ _F_ _IF_ARGS_ 1 3 XXX 4 _/\_ u0 -> \ (u1 :: {{Ix u0}}) (u2 :: (u0, u0)) (u3 :: u0) -> _APP_ _TYAPP_ patError# { ((u0, u0) -> u0 -> Int) } [ _NOREP_S_ "%DPreludeCore.Ix.index\"", u2, u3 ] _N_ #-}
+ {-defm-} _A_ 3 _U_ 022 _N_ _S_ _!_ _N_ _N_ #-}
inRange :: (a, a) -> a -> Bool
{-# GHC_PRAGMA {-meth-} _A_ 1 _U_ 122 _N_ _S_ "S" _F_ _IF_ARGS_ 1 1 C 2 _/\_ u0 -> \ (u1 :: ({{Ord u0}}, (u0, u0) -> [u0], (u0, u0) -> u0 -> Int, (u0, u0) -> u0 -> Bool)) -> case u1 of { _ALG_ _TUP_4 (u2 :: {{Ord u0}}) (u3 :: (u0, u0) -> [u0]) (u4 :: (u0, u0) -> u0 -> Int) (u5 :: (u0, u0) -> u0 -> Bool) -> u5; _NO_DEFLT_ } _N_
- {-defm-} _A_ 3 _U_ 022 _N_ _S_ _!_ _F_ _IF_ARGS_ 1 3 XXX 4 _/\_ u0 -> \ (u1 :: {{Ix u0}}) (u2 :: (u0, u0)) (u3 :: u0) -> _APP_ _TYAPP_ patError# { ((u0, u0) -> u0 -> Bool) } [ _NOREP_S_ "%DPreludeCore.Ix.inRange\"", u2, u3 ] _N_ #-}
+ {-defm-} _A_ 3 _U_ 022 _N_ _S_ _!_ _N_ _N_ #-}
class (Eq a, Text a) => Num a {-# GHC_PRAGMA {-superdicts-} _A_ 1 _U_ 1 _N_ _S_ "S" _F_ _IF_ARGS_ 1 1 C 2 _/\_ u0 -> \ (u1 :: ({{Eq u0}}, {{Text u0}}, u0 -> u0 -> u0, u0 -> u0 -> u0, u0 -> u0 -> u0, u0 -> u0, u0 -> u0, u0 -> u0, Integer -> u0, Int -> u0)) -> case u1 of { _ALG_ _TUP_10 (u2 :: {{Eq u0}}) (u3 :: {{Text u0}}) (u4 :: u0 -> u0 -> u0) (u5 :: u0 -> u0 -> u0) (u6 :: u0 -> u0 -> u0) (u7 :: u0 -> u0) (u8 :: u0 -> u0) (u9 :: u0 -> u0) (ua :: Integer -> u0) (ub :: Int -> u0) -> u2; _NO_DEFLT_ } _N_, _A_ 1 _U_ 1 _N_ _S_ "S" _F_ _IF_ARGS_ 1 1 C 2 _/\_ u0 -> \ (u1 :: ({{Eq u0}}, {{Text u0}}, u0 -> u0 -> u0, u0 -> u0 -> u0, u0 -> u0 -> u0, u0 -> u0, u0 -> u0, u0 -> u0, Integer -> u0, Int -> u0)) -> case u1 of { _ALG_ _TUP_10 (u2 :: {{Eq u0}}) (u3 :: {{Text u0}}) (u4 :: u0 -> u0 -> u0) (u5 :: u0 -> u0 -> u0) (u6 :: u0 -> u0 -> u0) (u7 :: u0 -> u0) (u8 :: u0 -> u0) (u9 :: u0 -> u0) (ua :: Integer -> u0) (ub :: Int -> u0) -> u3; _NO_DEFLT_ } _N_ #-} where
(+) :: a -> a -> a
{-# GHC_PRAGMA {-meth-} _A_ 1 _U_ 122 _N_ _S_ "S" _F_ _IF_ARGS_ 1 1 C 2 _/\_ u0 -> \ (u1 :: ({{Eq u0}}, {{Text u0}}, u0 -> u0 -> u0, u0 -> u0 -> u0, u0 -> u0 -> u0, u0 -> u0, u0 -> u0, u0 -> u0, Integer -> u0, Int -> u0)) -> case u1 of { _ALG_ _TUP_10 (u2 :: {{Eq u0}}) (u3 :: {{Text u0}}) (u4 :: u0 -> u0 -> u0) (u5 :: u0 -> u0 -> u0) (u6 :: u0 -> u0 -> u0) (u7 :: u0 -> u0) (u8 :: u0 -> u0) (u9 :: u0 -> u0) (ua :: Integer -> u0) (ub :: Int -> u0) -> u4; _NO_DEFLT_ } _N_
- {-defm-} _A_ 3 _U_ 022 _N_ _S_ _!_ _F_ _IF_ARGS_ 1 3 XXX 4 _/\_ u0 -> \ (u1 :: {{Num u0}}) (u2 :: u0) (u3 :: u0) -> _APP_ _TYAPP_ patError# { (u0 -> u0 -> u0) } [ _NOREP_S_ "%DPreludeCore.Num.(+)\"", u2, u3 ] _N_ #-}
+ {-defm-} _A_ 3 _U_ 022 _N_ _S_ _!_ _N_ _N_ #-}
(-) :: a -> a -> a
{-# GHC_PRAGMA {-meth-} _A_ 1 _U_ 122 _N_ _S_ "S" _F_ _IF_ARGS_ 1 1 C 2 _/\_ u0 -> \ (u1 :: ({{Eq u0}}, {{Text u0}}, u0 -> u0 -> u0, u0 -> u0 -> u0, u0 -> u0 -> u0, u0 -> u0, u0 -> u0, u0 -> u0, Integer -> u0, Int -> u0)) -> case u1 of { _ALG_ _TUP_10 (u2 :: {{Eq u0}}) (u3 :: {{Text u0}}) (u4 :: u0 -> u0 -> u0) (u5 :: u0 -> u0 -> u0) (u6 :: u0 -> u0 -> u0) (u7 :: u0 -> u0) (u8 :: u0 -> u0) (u9 :: u0 -> u0) (ua :: Integer -> u0) (ub :: Int -> u0) -> u5; _NO_DEFLT_ } _N_
{-defm-} _A_ 3 _U_ 122 _N_ _S_ "SLL" _F_ _ALWAYS_ _/\_ u0 -> \ (u1 :: {{Num u0}}) (u2 :: u0) (u3 :: u0) -> case u1 of { _ALG_ _TUP_10 (u4 :: {{Eq u0}}) (u5 :: {{Text u0}}) (u6 :: u0 -> u0 -> u0) (u7 :: u0 -> u0 -> u0) (u8 :: u0 -> u0 -> u0) (u9 :: u0 -> u0) (ua :: u0 -> u0) (ub :: u0 -> u0) (uc :: Integer -> u0) (ud :: Int -> u0) -> let {(ue :: u0) = _APP_ u9 [ u3 ]} in _APP_ u6 [ u2, ue ]; _NO_DEFLT_ } _N_ #-}
(*) :: a -> a -> a
{-# GHC_PRAGMA {-meth-} _A_ 1 _U_ 122 _N_ _S_ "S" _F_ _IF_ARGS_ 1 1 C 2 _/\_ u0 -> \ (u1 :: ({{Eq u0}}, {{Text u0}}, u0 -> u0 -> u0, u0 -> u0 -> u0, u0 -> u0 -> u0, u0 -> u0, u0 -> u0, u0 -> u0, Integer -> u0, Int -> u0)) -> case u1 of { _ALG_ _TUP_10 (u2 :: {{Eq u0}}) (u3 :: {{Text u0}}) (u4 :: u0 -> u0 -> u0) (u5 :: u0 -> u0 -> u0) (u6 :: u0 -> u0 -> u0) (u7 :: u0 -> u0) (u8 :: u0 -> u0) (u9 :: u0 -> u0) (ua :: Integer -> u0) (ub :: Int -> u0) -> u6; _NO_DEFLT_ } _N_
- {-defm-} _A_ 3 _U_ 022 _N_ _S_ _!_ _F_ _IF_ARGS_ 1 3 XXX 4 _/\_ u0 -> \ (u1 :: {{Num u0}}) (u2 :: u0) (u3 :: u0) -> _APP_ _TYAPP_ patError# { (u0 -> u0 -> u0) } [ _NOREP_S_ "%DPreludeCore.Num.(*)\"", u2, u3 ] _N_ #-}
+ {-defm-} _A_ 3 _U_ 022 _N_ _S_ _!_ _N_ _N_ #-}
negate :: a -> a
{-# GHC_PRAGMA {-meth-} _A_ 1 _U_ 12 _N_ _S_ "S" _F_ _IF_ARGS_ 1 1 C 2 _/\_ u0 -> \ (u1 :: ({{Eq u0}}, {{Text u0}}, u0 -> u0 -> u0, u0 -> u0 -> u0, u0 -> u0 -> u0, u0 -> u0, u0 -> u0, u0 -> u0, Integer -> u0, Int -> u0)) -> case u1 of { _ALG_ _TUP_10 (u2 :: {{Eq u0}}) (u3 :: {{Text u0}}) (u4 :: u0 -> u0 -> u0) (u5 :: u0 -> u0 -> u0) (u6 :: u0 -> u0 -> u0) (u7 :: u0 -> u0) (u8 :: u0 -> u0) (u9 :: u0 -> u0) (ua :: Integer -> u0) (ub :: Int -> u0) -> u7; _NO_DEFLT_ } _N_
- {-defm-} _A_ 2 _U_ 02 _N_ _S_ _!_ _F_ _IF_ARGS_ 1 2 XX 3 _/\_ u0 -> \ (u1 :: {{Num u0}}) (u2 :: u0) -> _APP_ _TYAPP_ patError# { (u0 -> u0) } [ _NOREP_S_ "%DPreludeCore.Num.negate\"", u2 ] _N_ #-}
+ {-defm-} _A_ 2 _U_ 02 _N_ _S_ _!_ _N_ _N_ #-}
abs :: a -> a
{-# GHC_PRAGMA {-meth-} _A_ 1 _U_ 12 _N_ _S_ "S" _F_ _IF_ARGS_ 1 1 C 2 _/\_ u0 -> \ (u1 :: ({{Eq u0}}, {{Text u0}}, u0 -> u0 -> u0, u0 -> u0 -> u0, u0 -> u0 -> u0, u0 -> u0, u0 -> u0, u0 -> u0, Integer -> u0, Int -> u0)) -> case u1 of { _ALG_ _TUP_10 (u2 :: {{Eq u0}}) (u3 :: {{Text u0}}) (u4 :: u0 -> u0 -> u0) (u5 :: u0 -> u0 -> u0) (u6 :: u0 -> u0 -> u0) (u7 :: u0 -> u0) (u8 :: u0 -> u0) (u9 :: u0 -> u0) (ua :: Integer -> u0) (ub :: Int -> u0) -> u8; _NO_DEFLT_ } _N_
- {-defm-} _A_ 2 _U_ 02 _N_ _S_ _!_ _F_ _IF_ARGS_ 1 2 XX 3 _/\_ u0 -> \ (u1 :: {{Num u0}}) (u2 :: u0) -> _APP_ _TYAPP_ patError# { (u0 -> u0) } [ _NOREP_S_ "%DPreludeCore.Num.abs\"", u2 ] _N_ #-}
+ {-defm-} _A_ 2 _U_ 02 _N_ _S_ _!_ _N_ _N_ #-}
signum :: a -> a
{-# GHC_PRAGMA {-meth-} _A_ 1 _U_ 12 _N_ _S_ "S" _F_ _IF_ARGS_ 1 1 C 2 _/\_ u0 -> \ (u1 :: ({{Eq u0}}, {{Text u0}}, u0 -> u0 -> u0, u0 -> u0 -> u0, u0 -> u0 -> u0, u0 -> u0, u0 -> u0, u0 -> u0, Integer -> u0, Int -> u0)) -> case u1 of { _ALG_ _TUP_10 (u2 :: {{Eq u0}}) (u3 :: {{Text u0}}) (u4 :: u0 -> u0 -> u0) (u5 :: u0 -> u0 -> u0) (u6 :: u0 -> u0 -> u0) (u7 :: u0 -> u0) (u8 :: u0 -> u0) (u9 :: u0 -> u0) (ua :: Integer -> u0) (ub :: Int -> u0) -> u9; _NO_DEFLT_ } _N_
- {-defm-} _A_ 2 _U_ 02 _N_ _S_ _!_ _F_ _IF_ARGS_ 1 2 XX 3 _/\_ u0 -> \ (u1 :: {{Num u0}}) (u2 :: u0) -> _APP_ _TYAPP_ patError# { (u0 -> u0) } [ _NOREP_S_ "%DPreludeCore.Num.signum\"", u2 ] _N_ #-}
+ {-defm-} _A_ 2 _U_ 02 _N_ _S_ _!_ _N_ _N_ #-}
fromInteger :: Integer -> a
{-# GHC_PRAGMA {-meth-} _A_ 1 _U_ 12 _N_ _S_ "S" _F_ _IF_ARGS_ 1 1 C 2 _/\_ u0 -> \ (u1 :: ({{Eq u0}}, {{Text u0}}, u0 -> u0 -> u0, u0 -> u0 -> u0, u0 -> u0 -> u0, u0 -> u0, u0 -> u0, u0 -> u0, Integer -> u0, Int -> u0)) -> case u1 of { _ALG_ _TUP_10 (u2 :: {{Eq u0}}) (u3 :: {{Text u0}}) (u4 :: u0 -> u0 -> u0) (u5 :: u0 -> u0 -> u0) (u6 :: u0 -> u0 -> u0) (u7 :: u0 -> u0) (u8 :: u0 -> u0) (u9 :: u0 -> u0) (ua :: Integer -> u0) (ub :: Int -> u0) -> ua; _NO_DEFLT_ } _N_
- {-defm-} _A_ 2 _U_ 02 _N_ _S_ _!_ _F_ _IF_ARGS_ 1 2 XX 3 _/\_ u0 -> \ (u1 :: {{Num u0}}) (u2 :: Integer) -> _APP_ _TYAPP_ patError# { (Integer -> u0) } [ _NOREP_S_ "%DPreludeCore.Num.fromInteger\"", u2 ] _N_ #-}
+ {-defm-} _A_ 2 _U_ 02 _N_ _S_ _!_ _N_ _N_ #-}
fromInt :: Int -> a
{-# GHC_PRAGMA {-meth-} _A_ 1 _U_ 12 _N_ _S_ "S" _F_ _IF_ARGS_ 1 1 C 2 _/\_ u0 -> \ (u1 :: ({{Eq u0}}, {{Text u0}}, u0 -> u0 -> u0, u0 -> u0 -> u0, u0 -> u0 -> u0, u0 -> u0, u0 -> u0, u0 -> u0, Integer -> u0, Int -> u0)) -> case u1 of { _ALG_ _TUP_10 (u2 :: {{Eq u0}}) (u3 :: {{Text u0}}) (u4 :: u0 -> u0 -> u0) (u5 :: u0 -> u0 -> u0) (u6 :: u0 -> u0 -> u0) (u7 :: u0 -> u0) (u8 :: u0 -> u0) (u9 :: u0 -> u0) (ua :: Integer -> u0) (ub :: Int -> u0) -> ub; _NO_DEFLT_ } _N_
{-defm-} _A_ 2 _U_ 11 _N_ _S_ "SL" _F_ _IF_ARGS_ 1 2 CC 6 _/\_ u0 -> \ (u1 :: {{Num u0}}) (u2 :: Int) -> let {(u4 :: Integer) = case u2 of { _ALG_ I# (u3 :: Int#) -> _#_ int2Integer# [] [u3]; _NO_DEFLT_ }} in case u1 of { _ALG_ _TUP_10 (u5 :: {{Eq u0}}) (u6 :: {{Text u0}}) (u7 :: u0 -> u0 -> u0) (u8 :: u0 -> u0 -> u0) (u9 :: u0 -> u0 -> u0) (ua :: u0 -> u0) (ub :: u0 -> u0) (uc :: u0 -> u0) (ud :: Integer -> u0) (ue :: Int -> u0) -> _APP_ ud [ u4 ]; _NO_DEFLT_ } _N_ #-}
{-defm-} _A_ 3 _U_ 122 _N_ _S_ "SLL" _N_ _N_ #-}
(<=) :: a -> a -> Bool
{-# GHC_PRAGMA {-meth-} _A_ 1 _U_ 122 _N_ _S_ "S" _F_ _IF_ARGS_ 1 1 C 2 _/\_ u0 -> \ (u1 :: ({{Eq u0}}, u0 -> u0 -> Bool, u0 -> u0 -> Bool, u0 -> u0 -> Bool, u0 -> u0 -> Bool, u0 -> u0 -> u0, u0 -> u0 -> u0, u0 -> u0 -> _CMP_TAG)) -> case u1 of { _ALG_ _TUP_8 (u2 :: {{Eq u0}}) (u3 :: u0 -> u0 -> Bool) (u4 :: u0 -> u0 -> Bool) (u5 :: u0 -> u0 -> Bool) (u6 :: u0 -> u0 -> Bool) (u7 :: u0 -> u0 -> u0) (u8 :: u0 -> u0 -> u0) (u9 :: u0 -> u0 -> _CMP_TAG) -> u4; _NO_DEFLT_ } _N_
- {-defm-} _A_ 3 _U_ 022 _N_ _S_ _!_ _F_ _IF_ARGS_ 1 3 XXX 4 _/\_ u0 -> \ (u1 :: {{Ord u0}}) (u2 :: u0) (u3 :: u0) -> _APP_ _TYAPP_ patError# { (u0 -> u0 -> Bool) } [ _NOREP_S_ "%DPreludeCore.Ord.(<=)\"", u2, u3 ] _N_ #-}
+ {-defm-} _A_ 3 _U_ 022 _N_ _S_ _!_ _N_ _N_ #-}
(>=) :: a -> a -> Bool
{-# GHC_PRAGMA {-meth-} _A_ 1 _U_ 122 _N_ _S_ "S" _F_ _IF_ARGS_ 1 1 C 2 _/\_ u0 -> \ (u1 :: ({{Eq u0}}, u0 -> u0 -> Bool, u0 -> u0 -> Bool, u0 -> u0 -> Bool, u0 -> u0 -> Bool, u0 -> u0 -> u0, u0 -> u0 -> u0, u0 -> u0 -> _CMP_TAG)) -> case u1 of { _ALG_ _TUP_8 (u2 :: {{Eq u0}}) (u3 :: u0 -> u0 -> Bool) (u4 :: u0 -> u0 -> Bool) (u5 :: u0 -> u0 -> Bool) (u6 :: u0 -> u0 -> Bool) (u7 :: u0 -> u0 -> u0) (u8 :: u0 -> u0 -> u0) (u9 :: u0 -> u0 -> _CMP_TAG) -> u5; _NO_DEFLT_ } _N_
{-defm-} _A_ 3 _U_ 122 _N_ _S_ "SLL" _F_ _IF_ARGS_ 1 3 CXX 4 _/\_ u0 -> \ (u1 :: {{Ord u0}}) (u2 :: u0) (u3 :: u0) -> case u1 of { _ALG_ _TUP_8 (u4 :: {{Eq u0}}) (u5 :: u0 -> u0 -> Bool) (u6 :: u0 -> u0 -> Bool) (u7 :: u0 -> u0 -> Bool) (u8 :: u0 -> u0 -> Bool) (u9 :: u0 -> u0 -> u0) (ua :: u0 -> u0 -> u0) (ub :: u0 -> u0 -> _CMP_TAG) -> _APP_ u6 [ u3, u2 ]; _NO_DEFLT_ } _N_ #-}
class (Num a, Enum a) => Real a {-# GHC_PRAGMA {-superdicts-} _A_ 1 _U_ 1 _N_ _S_ "S" _F_ _IF_ARGS_ 1 1 C 2 _/\_ u0 -> \ (u1 :: ({{Num u0}}, {{Enum u0}}, u0 -> Ratio Integer)) -> case u1 of { _ALG_ _TUP_3 (u2 :: {{Num u0}}) (u3 :: {{Enum u0}}) (u4 :: u0 -> Ratio Integer) -> u2; _NO_DEFLT_ } _N_, _A_ 1 _U_ 1 _N_ _S_ "S" _F_ _IF_ARGS_ 1 1 C 2 _/\_ u0 -> \ (u1 :: ({{Num u0}}, {{Enum u0}}, u0 -> Ratio Integer)) -> case u1 of { _ALG_ _TUP_3 (u2 :: {{Num u0}}) (u3 :: {{Enum u0}}) (u4 :: u0 -> Ratio Integer) -> u3; _NO_DEFLT_ } _N_ #-} where
toRational :: a -> Ratio Integer
{-# GHC_PRAGMA {-meth-} _A_ 1 _U_ 12 _N_ _S_ "S" _F_ _IF_ARGS_ 1 1 C 2 _/\_ u0 -> \ (u1 :: ({{Num u0}}, {{Enum u0}}, u0 -> Ratio Integer)) -> case u1 of { _ALG_ _TUP_3 (u2 :: {{Num u0}}) (u3 :: {{Enum u0}}) (u4 :: u0 -> Ratio Integer) -> u4; _NO_DEFLT_ } _N_
- {-defm-} _A_ 2 _U_ 02 _N_ _S_ _!_ _F_ _IF_ARGS_ 1 2 XX 3 _/\_ u0 -> \ (u1 :: {{Real u0}}) (u2 :: u0) -> _APP_ _TYAPP_ patError# { (u0 -> Ratio Integer) } [ _NOREP_S_ "%DPreludeCore.Real.toRational\"", u2 ] _N_ #-}
+ {-defm-} _A_ 2 _U_ 02 _N_ _S_ _!_ _N_ _N_ #-}
class (RealFrac a, Floating a) => RealFloat a {-# GHC_PRAGMA {-superdicts-} _A_ 1 _U_ 1 _N_ _S_ "S" _F_ _IF_ARGS_ 1 1 C 2 _/\_ u0 -> \ (u1 :: ({{RealFrac u0}}, {{Floating u0}}, u0 -> Integer, u0 -> Int, u0 -> (Int, Int), u0 -> (Integer, Int), Integer -> Int -> u0, u0 -> Int, u0 -> u0, Int -> u0 -> u0)) -> case u1 of { _ALG_ _TUP_10 (u2 :: {{RealFrac u0}}) (u3 :: {{Floating u0}}) (u4 :: u0 -> Integer) (u5 :: u0 -> Int) (u6 :: u0 -> (Int, Int)) (u7 :: u0 -> (Integer, Int)) (u8 :: Integer -> Int -> u0) (u9 :: u0 -> Int) (ua :: u0 -> u0) (ub :: Int -> u0 -> u0) -> u2; _NO_DEFLT_ } _N_, _A_ 1 _U_ 1 _N_ _S_ "S" _F_ _IF_ARGS_ 1 1 C 2 _/\_ u0 -> \ (u1 :: ({{RealFrac u0}}, {{Floating u0}}, u0 -> Integer, u0 -> Int, u0 -> (Int, Int), u0 -> (Integer, Int), Integer -> Int -> u0, u0 -> Int, u0 -> u0, Int -> u0 -> u0)) -> case u1 of { _ALG_ _TUP_10 (u2 :: {{RealFrac u0}}) (u3 :: {{Floating u0}}) (u4 :: u0 -> Integer) (u5 :: u0 -> Int) (u6 :: u0 -> (Int, Int)) (u7 :: u0 -> (Integer, Int)) (u8 :: Integer -> Int -> u0) (u9 :: u0 -> Int) (ua :: u0 -> u0) (ub :: Int -> u0 -> u0) -> u3; _NO_DEFLT_ } _N_ #-} where
floatRadix :: a -> Integer
{-# GHC_PRAGMA {-meth-} _A_ 1 _U_ 12 _N_ _S_ "S" _F_ _IF_ARGS_ 1 1 C 2 _/\_ u0 -> \ (u1 :: ({{RealFrac u0}}, {{Floating u0}}, u0 -> Integer, u0 -> Int, u0 -> (Int, Int), u0 -> (Integer, Int), Integer -> Int -> u0, u0 -> Int, u0 -> u0, Int -> u0 -> u0)) -> case u1 of { _ALG_ _TUP_10 (u2 :: {{RealFrac u0}}) (u3 :: {{Floating u0}}) (u4 :: u0 -> Integer) (u5 :: u0 -> Int) (u6 :: u0 -> (Int, Int)) (u7 :: u0 -> (Integer, Int)) (u8 :: Integer -> Int -> u0) (u9 :: u0 -> Int) (ua :: u0 -> u0) (ub :: Int -> u0 -> u0) -> u4; _NO_DEFLT_ } _N_
- {-defm-} _A_ 2 _U_ 02 _N_ _S_ _!_ _F_ _IF_ARGS_ 1 2 XX 3 _/\_ u0 -> \ (u1 :: {{RealFloat u0}}) (u2 :: u0) -> _APP_ _TYAPP_ patError# { (u0 -> Integer) } [ _NOREP_S_ "%DPreludeCore.RealFloat.floatRadix\"", u2 ] _N_ #-}
+ {-defm-} _A_ 2 _U_ 02 _N_ _S_ _!_ _N_ _N_ #-}
floatDigits :: a -> Int
{-# GHC_PRAGMA {-meth-} _A_ 1 _U_ 12 _N_ _S_ "S" _F_ _IF_ARGS_ 1 1 C 2 _/\_ u0 -> \ (u1 :: ({{RealFrac u0}}, {{Floating u0}}, u0 -> Integer, u0 -> Int, u0 -> (Int, Int), u0 -> (Integer, Int), Integer -> Int -> u0, u0 -> Int, u0 -> u0, Int -> u0 -> u0)) -> case u1 of { _ALG_ _TUP_10 (u2 :: {{RealFrac u0}}) (u3 :: {{Floating u0}}) (u4 :: u0 -> Integer) (u5 :: u0 -> Int) (u6 :: u0 -> (Int, Int)) (u7 :: u0 -> (Integer, Int)) (u8 :: Integer -> Int -> u0) (u9 :: u0 -> Int) (ua :: u0 -> u0) (ub :: Int -> u0 -> u0) -> u5; _NO_DEFLT_ } _N_
- {-defm-} _A_ 2 _U_ 02 _N_ _S_ _!_ _F_ _IF_ARGS_ 1 2 XX 3 _/\_ u0 -> \ (u1 :: {{RealFloat u0}}) (u2 :: u0) -> _APP_ _TYAPP_ patError# { (u0 -> Int) } [ _NOREP_S_ "%DPreludeCore.RealFloat.floatDigits\"", u2 ] _N_ #-}
+ {-defm-} _A_ 2 _U_ 02 _N_ _S_ _!_ _N_ _N_ #-}
floatRange :: a -> (Int, Int)
{-# GHC_PRAGMA {-meth-} _A_ 1 _U_ 12 _N_ _S_ "S" _F_ _IF_ARGS_ 1 1 C 2 _/\_ u0 -> \ (u1 :: ({{RealFrac u0}}, {{Floating u0}}, u0 -> Integer, u0 -> Int, u0 -> (Int, Int), u0 -> (Integer, Int), Integer -> Int -> u0, u0 -> Int, u0 -> u0, Int -> u0 -> u0)) -> case u1 of { _ALG_ _TUP_10 (u2 :: {{RealFrac u0}}) (u3 :: {{Floating u0}}) (u4 :: u0 -> Integer) (u5 :: u0 -> Int) (u6 :: u0 -> (Int, Int)) (u7 :: u0 -> (Integer, Int)) (u8 :: Integer -> Int -> u0) (u9 :: u0 -> Int) (ua :: u0 -> u0) (ub :: Int -> u0 -> u0) -> u6; _NO_DEFLT_ } _N_
- {-defm-} _A_ 2 _U_ 02 _N_ _S_ _!_ _F_ _IF_ARGS_ 1 2 XX 3 _/\_ u0 -> \ (u1 :: {{RealFloat u0}}) (u2 :: u0) -> _APP_ _TYAPP_ patError# { (u0 -> (Int, Int)) } [ _NOREP_S_ "%DPreludeCore.RealFloat.floatRange\"", u2 ] _N_ #-}
+ {-defm-} _A_ 2 _U_ 02 _N_ _S_ _!_ _N_ _N_ #-}
decodeFloat :: a -> (Integer, Int)
{-# GHC_PRAGMA {-meth-} _A_ 1 _U_ 12 _N_ _S_ "S" _F_ _IF_ARGS_ 1 1 C 2 _/\_ u0 -> \ (u1 :: ({{RealFrac u0}}, {{Floating u0}}, u0 -> Integer, u0 -> Int, u0 -> (Int, Int), u0 -> (Integer, Int), Integer -> Int -> u0, u0 -> Int, u0 -> u0, Int -> u0 -> u0)) -> case u1 of { _ALG_ _TUP_10 (u2 :: {{RealFrac u0}}) (u3 :: {{Floating u0}}) (u4 :: u0 -> Integer) (u5 :: u0 -> Int) (u6 :: u0 -> (Int, Int)) (u7 :: u0 -> (Integer, Int)) (u8 :: Integer -> Int -> u0) (u9 :: u0 -> Int) (ua :: u0 -> u0) (ub :: Int -> u0 -> u0) -> u7; _NO_DEFLT_ } _N_
- {-defm-} _A_ 2 _U_ 02 _N_ _S_ _!_ _F_ _IF_ARGS_ 1 2 XX 3 _/\_ u0 -> \ (u1 :: {{RealFloat u0}}) (u2 :: u0) -> _APP_ _TYAPP_ patError# { (u0 -> (Integer, Int)) } [ _NOREP_S_ "%DPreludeCore.RealFloat.decodeFloat\"", u2 ] _N_ #-}
+ {-defm-} _A_ 2 _U_ 02 _N_ _S_ _!_ _N_ _N_ #-}
encodeFloat :: Integer -> Int -> a
{-# GHC_PRAGMA {-meth-} _A_ 1 _U_ 122 _N_ _S_ "S" _F_ _IF_ARGS_ 1 1 C 2 _/\_ u0 -> \ (u1 :: ({{RealFrac u0}}, {{Floating u0}}, u0 -> Integer, u0 -> Int, u0 -> (Int, Int), u0 -> (Integer, Int), Integer -> Int -> u0, u0 -> Int, u0 -> u0, Int -> u0 -> u0)) -> case u1 of { _ALG_ _TUP_10 (u2 :: {{RealFrac u0}}) (u3 :: {{Floating u0}}) (u4 :: u0 -> Integer) (u5 :: u0 -> Int) (u6 :: u0 -> (Int, Int)) (u7 :: u0 -> (Integer, Int)) (u8 :: Integer -> Int -> u0) (u9 :: u0 -> Int) (ua :: u0 -> u0) (ub :: Int -> u0 -> u0) -> u8; _NO_DEFLT_ } _N_
- {-defm-} _A_ 3 _U_ 022 _N_ _S_ _!_ _F_ _IF_ARGS_ 1 3 XXX 4 _/\_ u0 -> \ (u1 :: {{RealFloat u0}}) (u2 :: Integer) (u3 :: Int) -> _APP_ _TYAPP_ patError# { (Integer -> Int -> u0) } [ _NOREP_S_ "%DPreludeCore.RealFloat.encodeFloat\"", u2, u3 ] _N_ #-}
+ {-defm-} _A_ 3 _U_ 022 _N_ _S_ _!_ _N_ _N_ #-}
exponent :: a -> Int
{-# GHC_PRAGMA {-meth-} _A_ 1 _U_ 12 _N_ _S_ "S" _F_ _IF_ARGS_ 1 1 C 2 _/\_ u0 -> \ (u1 :: ({{RealFrac u0}}, {{Floating u0}}, u0 -> Integer, u0 -> Int, u0 -> (Int, Int), u0 -> (Integer, Int), Integer -> Int -> u0, u0 -> Int, u0 -> u0, Int -> u0 -> u0)) -> case u1 of { _ALG_ _TUP_10 (u2 :: {{RealFrac u0}}) (u3 :: {{Floating u0}}) (u4 :: u0 -> Integer) (u5 :: u0 -> Int) (u6 :: u0 -> (Int, Int)) (u7 :: u0 -> (Integer, Int)) (u8 :: Integer -> Int -> u0) (u9 :: u0 -> Int) (ua :: u0 -> u0) (ub :: Int -> u0 -> u0) -> u9; _NO_DEFLT_ } _N_
{-defm-} _A_ 2 _U_ 12 _N_ _S_ "SL" _N_ _N_ #-}
class (Real a, Fractional a) => RealFrac a {-# GHC_PRAGMA {-superdicts-} _A_ 1 _U_ 1 _N_ _S_ "S" _F_ _IF_ARGS_ 1 1 C 2 _/\_ u0 -> \ (u1 :: ({{Real u0}}, {{Fractional u0}}, (_forall_ z$z1 =>{{Integral z$z1}} -> u0 -> (z$z1, u0)), (_forall_ z$z1 =>{{Integral z$z1}} -> u0 -> z$z1), (_forall_ z$z1 =>{{Integral z$z1}} -> u0 -> z$z1), (_forall_ z$z1 =>{{Integral z$z1}} -> u0 -> z$z1), (_forall_ z$z1 =>{{Integral z$z1}} -> u0 -> z$z1))) -> case u1 of { _ALG_ _TUP_7 (u2 :: {{Real u0}}) (u3 :: {{Fractional u0}}) (u4 :: _forall_ a$z1 =>{{Integral a$z1}} -> u0 -> (a$z1, u0)) (u5 :: _forall_ a$z1 =>{{Integral a$z1}} -> u0 -> a$z1) (u6 :: _forall_ a$z1 =>{{Integral a$z1}} -> u0 -> a$z1) (u7 :: _forall_ a$z1 =>{{Integral a$z1}} -> u0 -> a$z1) (u8 :: _forall_ a$z1 =>{{Integral a$z1}} -> u0 -> a$z1) -> u2; _NO_DEFLT_ } _N_, _A_ 1 _U_ 1 _N_ _S_ "S" _F_ _IF_ARGS_ 1 1 C 2 _/\_ u0 -> \ (u1 :: ({{Real u0}}, {{Fractional u0}}, (_forall_ z$z1 =>{{Integral z$z1}} -> u0 -> (z$z1, u0)), (_forall_ z$z1 =>{{Integral z$z1}} -> u0 -> z$z1), (_forall_ z$z1 =>{{Integral z$z1}} -> u0 -> z$z1), (_forall_ z$z1 =>{{Integral z$z1}} -> u0 -> z$z1), (_forall_ z$z1 =>{{Integral z$z1}} -> u0 -> z$z1))) -> case u1 of { _ALG_ _TUP_7 (u2 :: {{Real u0}}) (u3 :: {{Fractional u0}}) (u4 :: _forall_ a$z1 =>{{Integral a$z1}} -> u0 -> (a$z1, u0)) (u5 :: _forall_ a$z1 =>{{Integral a$z1}} -> u0 -> a$z1) (u6 :: _forall_ a$z1 =>{{Integral a$z1}} -> u0 -> a$z1) (u7 :: _forall_ a$z1 =>{{Integral a$z1}} -> u0 -> a$z1) (u8 :: _forall_ a$z1 =>{{Integral a$z1}} -> u0 -> a$z1) -> u3; _NO_DEFLT_ } _N_ #-} where
properFraction :: Integral b => a -> (b, a)
{-# GHC_PRAGMA {-meth-} _A_ 2 _U_ 122 _N_ _S_ "SL" _F_ _IF_ARGS_ 2 2 CX 3 _/\_ u0 u1 -> \ (u2 :: ({{Real u0}}, {{Fractional u0}}, (_forall_ z$z1 =>{{Integral z$z1}} -> u0 -> (z$z1, u0)), (_forall_ z$z1 =>{{Integral z$z1}} -> u0 -> z$z1), (_forall_ z$z1 =>{{Integral z$z1}} -> u0 -> z$z1), (_forall_ z$z1 =>{{Integral z$z1}} -> u0 -> z$z1), (_forall_ z$z1 =>{{Integral z$z1}} -> u0 -> z$z1))) (u3 :: {{Integral u1}}) -> case u2 of { _ALG_ _TUP_7 (u4 :: {{Real u0}}) (u5 :: {{Fractional u0}}) (u6 :: _forall_ a$z1 =>{{Integral a$z1}} -> u0 -> (a$z1, u0)) (u7 :: _forall_ a$z1 =>{{Integral a$z1}} -> u0 -> a$z1) (u8 :: _forall_ a$z1 =>{{Integral a$z1}} -> u0 -> a$z1) (u9 :: _forall_ a$z1 =>{{Integral a$z1}} -> u0 -> a$z1) (ua :: _forall_ a$z1 =>{{Integral a$z1}} -> u0 -> a$z1) -> _APP_ _TYAPP_ u6 { u1 } [ u3 ]; _NO_DEFLT_ } _N_
- {-defm-} _A_ 3 _U_ 002 _N_ _S_ _!_ _F_ _IF_ARGS_ 2 3 XXX 3 _/\_ u0 u1 -> \ (u2 :: {{RealFrac u0}}) (u3 :: {{Integral u1}}) (u4 :: u0) -> _APP_ _TYAPP_ patError# { (u0 -> (u1, u0)) } [ _NOREP_S_ "%DPreludeCore.RealFrac.properFraction\"", u4 ] _N_ #-}
+ {-defm-} _A_ 3 _U_ 002 _N_ _S_ _!_ _N_ _N_ #-}
truncate :: Integral b => a -> b
{-# GHC_PRAGMA {-meth-} _A_ 2 _U_ 122 _N_ _S_ "SL" _F_ _IF_ARGS_ 2 2 CX 3 _/\_ u0 u1 -> \ (u2 :: ({{Real u0}}, {{Fractional u0}}, (_forall_ z$z1 =>{{Integral z$z1}} -> u0 -> (z$z1, u0)), (_forall_ z$z1 =>{{Integral z$z1}} -> u0 -> z$z1), (_forall_ z$z1 =>{{Integral z$z1}} -> u0 -> z$z1), (_forall_ z$z1 =>{{Integral z$z1}} -> u0 -> z$z1), (_forall_ z$z1 =>{{Integral z$z1}} -> u0 -> z$z1))) (u3 :: {{Integral u1}}) -> case u2 of { _ALG_ _TUP_7 (u4 :: {{Real u0}}) (u5 :: {{Fractional u0}}) (u6 :: _forall_ a$z1 =>{{Integral a$z1}} -> u0 -> (a$z1, u0)) (u7 :: _forall_ a$z1 =>{{Integral a$z1}} -> u0 -> a$z1) (u8 :: _forall_ a$z1 =>{{Integral a$z1}} -> u0 -> a$z1) (u9 :: _forall_ a$z1 =>{{Integral a$z1}} -> u0 -> a$z1) (ua :: _forall_ a$z1 =>{{Integral a$z1}} -> u0 -> a$z1) -> _APP_ _TYAPP_ u7 { u1 } [ u3 ]; _NO_DEFLT_ } _N_
{-defm-} _A_ 2 _U_ 122 _N_ _S_ "SL" _N_ _N_ #-}
class Text a where
readsPrec :: Int -> [Char] -> [(a, [Char])]
{-# GHC_PRAGMA {-meth-} _A_ 1 _U_ 122 _N_ _S_ "S" _F_ _IF_ARGS_ 1 1 C 2 _/\_ u0 -> \ (u1 :: (Int -> [Char] -> [(u0, [Char])], Int -> u0 -> [Char] -> [Char], [Char] -> [([u0], [Char])], [u0] -> [Char] -> [Char])) -> case u1 of { _ALG_ _TUP_4 (u2 :: Int -> [Char] -> [(u0, [Char])]) (u3 :: Int -> u0 -> [Char] -> [Char]) (u4 :: [Char] -> [([u0], [Char])]) (u5 :: [u0] -> [Char] -> [Char]) -> u2; _NO_DEFLT_ } _N_
- {-defm-} _A_ 3 _U_ 022 _N_ _S_ _!_ _F_ _IF_ARGS_ 1 3 XXX 4 _/\_ u0 -> \ (u1 :: {{Text u0}}) (u2 :: Int) (u3 :: [Char]) -> _APP_ _TYAPP_ patError# { (Int -> [Char] -> [(u0, [Char])]) } [ _NOREP_S_ "%DPreludeCore.Text.readsPrec\"", u2, u3 ] _N_ #-}
+ {-defm-} _A_ 3 _U_ 022 _N_ _S_ _!_ _N_ _N_ #-}
showsPrec :: Int -> a -> [Char] -> [Char]
{-# GHC_PRAGMA {-meth-} _A_ 1 _U_ 1222 _N_ _S_ "S" _F_ _IF_ARGS_ 1 1 C 2 _/\_ u0 -> \ (u1 :: (Int -> [Char] -> [(u0, [Char])], Int -> u0 -> [Char] -> [Char], [Char] -> [([u0], [Char])], [u0] -> [Char] -> [Char])) -> case u1 of { _ALG_ _TUP_4 (u2 :: Int -> [Char] -> [(u0, [Char])]) (u3 :: Int -> u0 -> [Char] -> [Char]) (u4 :: [Char] -> [([u0], [Char])]) (u5 :: [u0] -> [Char] -> [Char]) -> u3; _NO_DEFLT_ } _N_
- {-defm-} _A_ 4 _U_ 0222 _N_ _S_ _!_ _F_ _IF_ARGS_ 1 4 XXXX 5 _/\_ u0 -> \ (u1 :: {{Text u0}}) (u2 :: Int) (u3 :: u0) (u4 :: [Char]) -> _APP_ _TYAPP_ patError# { (Int -> u0 -> [Char] -> [Char]) } [ _NOREP_S_ "%DPreludeCore.Text.showsPrec\"", u2, u3, u4 ] _N_ #-}
+ {-defm-} _A_ 4 _U_ 0222 _N_ _S_ _!_ _N_ _N_ #-}
readList :: [Char] -> [([a], [Char])]
{-# GHC_PRAGMA {-meth-} _A_ 1 _U_ 12 _N_ _S_ "S" _F_ _IF_ARGS_ 1 1 C 2 _/\_ u0 -> \ (u1 :: (Int -> [Char] -> [(u0, [Char])], Int -> u0 -> [Char] -> [Char], [Char] -> [([u0], [Char])], [u0] -> [Char] -> [Char])) -> case u1 of { _ALG_ _TUP_4 (u2 :: Int -> [Char] -> [(u0, [Char])]) (u3 :: Int -> u0 -> [Char] -> [Char]) (u4 :: [Char] -> [([u0], [Char])]) (u5 :: [u0] -> [Char] -> [Char]) -> u4; _NO_DEFLT_ } _N_
- {-defm-} _A_ 1 _U_ 22 _N_ _N_ _F_ _IF_ARGS_ 0 0 X 1 _ORIG_ PreludeCore _readList _N_ #-}
+ {-defm-} _A_ 1 _U_ 12 _N_ _N_ _N_ _N_ #-}
showList :: [a] -> [Char] -> [Char]
{-# GHC_PRAGMA {-meth-} _A_ 1 _U_ 122 _N_ _S_ "S" _F_ _IF_ARGS_ 1 1 C 2 _/\_ u0 -> \ (u1 :: (Int -> [Char] -> [(u0, [Char])], Int -> u0 -> [Char] -> [Char], [Char] -> [([u0], [Char])], [u0] -> [Char] -> [Char])) -> case u1 of { _ALG_ _TUP_4 (u2 :: Int -> [Char] -> [(u0, [Char])]) (u3 :: Int -> u0 -> [Char] -> [Char]) (u4 :: [Char] -> [([u0], [Char])]) (u5 :: [u0] -> [Char] -> [Char]) -> u5; _NO_DEFLT_ } _N_
- {-defm-} _A_ 1 _U_ 212 _N_ _N_ _F_ _IF_ARGS_ 0 0 X 1 _ORIG_ PreludeCore _showList _N_ #-}
+ {-defm-} _A_ 1 _U_ 112 _N_ _N_ _N_ _N_ #-}
class _CCallable a
class _CReturnable a
data Array a b {-# GHC_PRAGMA _Array (a, a) (Array# b) #-}
data Assoc a b = (:=) a b
data _ByteArray a {-# GHC_PRAGMA _ByteArray (a, a) ByteArray# #-}
data Bin
-data Complex a = (:+) a a
+data Complex a = (:+) a a {-# GHC_PRAGMA _SPECIALISE_ [ Double# ] #-}
data _MutableArray a b c {-# GHC_PRAGMA _MutableArray (b, b) (MutableArray# a c) #-}
data _MutableByteArray a b {-# GHC_PRAGMA _MutableByteArray (b, b) (MutableByteArray# a) #-}
type BinCont = Bin -> [Response] -> [Request]
type ReadS a = [Char] -> [(a, [Char])]
type ShowS = [Char] -> [Char]
data _FILE {-# GHC_PRAGMA _FILE Addr# #-}
+__i0 :: Num a => a
+ {-# GHC_PRAGMA _A_ 1 _U_ 1 _N_ _S_ "U(AAAAAAAAAS)" {_A_ 1 _U_ 1 _N_ _N_ _N_ _N_} _N_ _SPECIALISE_ [ Double ] 1 { _A_ 0 _N_ _N_ _N_ _F_ _IF_ARGS_ 0 0 X 2 _!_ D# [] [0.0000000000000000##] _N_ }, [ Int ] 1 { _A_ 0 _N_ _N_ _N_ _F_ _IF_ARGS_ 0 0 X 2 _!_ I# [] [0#] _N_ }, [ Integer ] 1 { _A_ 0 _N_ _N_ _N_ _N_ _N_ }, [ (Ratio Integer) ] 1 { _A_ 0 _N_ _N_ _N_ _N_ _N_ }, [ (Complex Double) ] 1 { _A_ 0 _N_ _N_ _N_ _N_ _N_ } #-}
+__i1 :: Num a => a
+ {-# GHC_PRAGMA _A_ 1 _U_ 1 _N_ _S_ "U(AAAAAAAAAS)" {_A_ 1 _U_ 1 _N_ _N_ _N_ _N_} _N_ _SPECIALISE_ [ Double ] 1 { _A_ 0 _N_ _N_ _N_ _F_ _IF_ARGS_ 0 0 X 2 _!_ D# [] [1.0000000000000000##] _N_ }, [ Int ] 1 { _A_ 0 _N_ _N_ _N_ _F_ _IF_ARGS_ 0 0 X 2 _!_ I# [] [1#] _N_ }, [ Integer ] 1 { _A_ 0 _N_ _N_ _N_ _N_ _N_ }, [ (Ratio Integer) ] 1 { _A_ 0 _N_ _N_ _N_ _N_ _N_ }, [ (Complex Double) ] 1 { _A_ 0 _N_ _N_ _N_ _N_ _N_ } #-}
+__i10 :: Num a => a
+ {-# GHC_PRAGMA _A_ 1 _U_ 1 _N_ _S_ "U(AAAAAAAAAS)" {_A_ 1 _U_ 1 _N_ _N_ _N_ _N_} _N_ _SPECIALISE_ [ Double ] 1 { _A_ 0 _N_ _N_ _N_ _F_ _IF_ARGS_ 0 0 X 2 _!_ D# [] [10.000000000000000##] _N_ }, [ Int ] 1 { _A_ 0 _N_ _N_ _N_ _F_ _IF_ARGS_ 0 0 X 2 _!_ I# [] [10#] _N_ }, [ Integer ] 1 { _A_ 0 _N_ _N_ _N_ _N_ _N_ }, [ (Ratio Integer) ] 1 { _A_ 0 _N_ _N_ _N_ _N_ _N_ }, [ (Complex Double) ] 1 { _A_ 0 _N_ _N_ _N_ _N_ _N_ } #-}
+__i16 :: Num a => a
+ {-# GHC_PRAGMA _A_ 1 _U_ 1 _N_ _S_ "U(AAAAAAAAAS)" {_A_ 1 _U_ 1 _N_ _N_ _N_ _N_} _N_ _SPECIALISE_ [ Double ] 1 { _A_ 0 _N_ _N_ _N_ _F_ _IF_ARGS_ 0 0 X 2 _!_ D# [] [16.000000000000000##] _N_ }, [ Int ] 1 { _A_ 0 _N_ _N_ _N_ _F_ _IF_ARGS_ 0 0 X 2 _!_ I# [] [16#] _N_ }, [ Integer ] 1 { _A_ 0 _N_ _N_ _N_ _N_ _N_ }, [ (Ratio Integer) ] 1 { _A_ 0 _N_ _N_ _N_ _N_ _N_ }, [ (Complex Double) ] 1 { _A_ 0 _N_ _N_ _N_ _N_ _N_ } #-}
+__i2 :: Num a => a
+ {-# GHC_PRAGMA _A_ 1 _U_ 1 _N_ _S_ "U(AAAAAAAAAS)" {_A_ 1 _U_ 1 _N_ _N_ _N_ _N_} _N_ _SPECIALISE_ [ Double ] 1 { _A_ 0 _N_ _N_ _N_ _F_ _IF_ARGS_ 0 0 X 2 _!_ D# [] [2.0000000000000000##] _N_ }, [ Int ] 1 { _A_ 0 _N_ _N_ _N_ _F_ _IF_ARGS_ 0 0 X 2 _!_ I# [] [2#] _N_ }, [ Integer ] 1 { _A_ 0 _N_ _N_ _N_ _N_ _N_ }, [ (Ratio Integer) ] 1 { _A_ 0 _N_ _N_ _N_ _N_ _N_ }, [ (Complex Double) ] 1 { _A_ 0 _N_ _N_ _N_ _N_ _N_ } #-}
+__i8 :: Num a => a
+ {-# GHC_PRAGMA _A_ 1 _U_ 1 _N_ _S_ "U(AAAAAAAAAS)" {_A_ 1 _U_ 1 _N_ _N_ _N_ _N_} _N_ _SPECIALISE_ [ Double ] 1 { _A_ 0 _N_ _N_ _N_ _F_ _IF_ARGS_ 0 0 X 2 _!_ D# [] [8.0000000000000000##] _N_ }, [ Int ] 1 { _A_ 0 _N_ _N_ _N_ _F_ _IF_ARGS_ 0 0 X 2 _!_ I# [] [8#] _N_ }, [ Integer ] 1 { _A_ 0 _N_ _N_ _N_ _N_ _N_ }, [ (Ratio Integer) ] 1 { _A_ 0 _N_ _N_ _N_ _N_ _N_ }, [ (Complex Double) ] 1 { _A_ 0 _N_ _N_ _N_ _N_ _N_ } #-}
+__im1 :: Num a => a
+ {-# GHC_PRAGMA _A_ 1 _U_ 1 _N_ _S_ "U(AAAAAAAAAS)" {_A_ 1 _U_ 1 _N_ _N_ _N_ _N_} _N_ _SPECIALISE_ [ Double ] 1 { _A_ 0 _N_ _N_ _N_ _F_ _IF_ARGS_ 0 0 X 2 _!_ D# [] [-1.0000000000000000##] _N_ }, [ Int ] 1 { _A_ 0 _N_ _N_ _N_ _F_ _IF_ARGS_ 0 0 X 2 _!_ I# [] [-1#] _N_ }, [ Integer ] 1 { _A_ 0 _N_ _N_ _N_ _N_ _N_ }, [ (Ratio Integer) ] 1 { _A_ 0 _N_ _N_ _N_ _N_ _N_ }, [ (Complex Double) ] 1 { _A_ 0 _N_ _N_ _N_ _N_ _N_ } #-}
+__integer0 :: Integer
+ {-# GHC_PRAGMA _A_ 0 _N_ _N_ _N_ _N_ _N_ #-}
+__integer1 :: Integer
+ {-# GHC_PRAGMA _A_ 0 _N_ _N_ _N_ _N_ _N_ #-}
+__integer2 :: Integer
+ {-# GHC_PRAGMA _A_ 0 _N_ _N_ _N_ _N_ _N_ #-}
+__integerm1 :: Integer
+ {-# GHC_PRAGMA _A_ 0 _N_ _N_ _N_ _N_ _N_ #-}
+__rhalf :: Fractional a => a
+ {-# GHC_PRAGMA _A_ 1 _U_ 1 _N_ _S_ "U(AAAS)" {_A_ 1 _U_ 1 _N_ _N_ _N_ _N_} _N_ _SPECIALISE_ [ Double ] 1 { _A_ 0 _N_ _N_ _N_ _N_ _N_ }, [ (Ratio Integer) ] 1 { _A_ 0 _N_ _N_ _N_ _F_ _IF_ARGS_ 0 0 X 3 _!_ (:%) [Integer] [_SPEC_ _ORIG_ PreludeCore __i1 [ (Integer) ], _SPEC_ _ORIG_ PreludeCore __i2 [ (Integer) ]] _N_ }, [ (Complex Double) ] 1 { _A_ 0 _N_ _N_ _N_ _N_ _N_ } #-}
+_fromRational :: RealFloat a => Ratio Integer -> a
+ {-# GHC_PRAGMA _A_ 2 _U_ 22 _N_ _N_ _N_ _SPECIALISE_ [ Double ] 1 { _A_ 1 _U_ 1 _N_ _S_ "U(U(PPP)U(PPP))" {_A_ 4 _U_ 2221 _N_ _N_ _N_ _N_} _N_ _N_ } #-}
instance Enum ()
{-# GHC_PRAGMA _M_ PreludeBuiltin {-dfun-} _A_ 0 _N_ _N_ _N_ _F_ _IF_ARGS_ 0 0 X 6 _!_ _TUP_5 [{{Ord ()}}, (() -> [()]), (() -> () -> [()]), (() -> () -> [()]), (() -> () -> () -> [()])] [_DFUN_ Ord (()), _CONSTM_ Enum enumFrom (()), _CONSTM_ Enum enumFromThen (()), _CONSTM_ Enum enumFromTo (()), _CONSTM_ Enum enumFromThenTo (())] _N_
- enumFrom = _A_ 1 _U_ 2 _N_ _S_ "E" _N_ _N_,
- enumFromThen = _A_ 2 _U_ 21 _N_ _S_ "EE" _F_ _IF_ARGS_ 0 2 CC 7 \ (u0 :: ()) (u1 :: ()) -> case u0 of { _ALG_ _TUP_0 -> case u1 of { _ALG_ _TUP_0 -> let {(u2 :: [()]) = _!_ _NIL_ [()] []} in _!_ (:) [()] [u0, u2]; _NO_DEFLT_ }; _NO_DEFLT_ } _N_,
- enumFromTo = _A_ 2 _U_ 21 _N_ _S_ "EE" _F_ _IF_ARGS_ 0 2 CC 7 \ (u0 :: ()) (u1 :: ()) -> case u0 of { _ALG_ _TUP_0 -> case u1 of { _ALG_ _TUP_0 -> let {(u2 :: [()]) = _!_ _NIL_ [()] []} in _!_ (:) [()] [u0, u2]; _NO_DEFLT_ }; _NO_DEFLT_ } _N_,
- enumFromThenTo = _A_ 3 _U_ 211 _N_ _S_ "EEE" _F_ _IF_ARGS_ 0 3 CCC 8 \ (u0 :: ()) (u1 :: ()) (u2 :: ()) -> case u0 of { _ALG_ _TUP_0 -> case u1 of { _ALG_ _TUP_0 -> case u2 of { _ALG_ _TUP_0 -> let {(u3 :: [()]) = _!_ _NIL_ [()] []} in _!_ (:) [()] [u0, u3]; _NO_DEFLT_ }; _NO_DEFLT_ }; _NO_DEFLT_ } _N_ #-}
+ enumFrom = { _A_ 1 _U_ 2 _N_ _S_ "E" _N_ _N_ },
+ enumFromThen = { _A_ 2 _U_ 21 _N_ _S_ "EE" _F_ _IF_ARGS_ 0 2 CC 7 \ (u0 :: ()) (u1 :: ()) -> case u0 of { _ALG_ _TUP_0 -> case u1 of { _ALG_ _TUP_0 -> let {(u2 :: [()]) = _!_ _NIL_ [()] []} in _!_ (:) [()] [u0, u2]; _NO_DEFLT_ }; _NO_DEFLT_ } _N_ },
+ enumFromTo = { _A_ 2 _U_ 21 _N_ _S_ "EE" _F_ _IF_ARGS_ 0 2 CC 7 \ (u0 :: ()) (u1 :: ()) -> case u0 of { _ALG_ _TUP_0 -> case u1 of { _ALG_ _TUP_0 -> let {(u2 :: [()]) = _!_ _NIL_ [()] []} in _!_ (:) [()] [u0, u2]; _NO_DEFLT_ }; _NO_DEFLT_ } _N_ },
+ enumFromThenTo = { _A_ 3 _U_ 211 _N_ _S_ "EEE" _F_ _IF_ARGS_ 0 3 CCC 8 \ (u0 :: ()) (u1 :: ()) (u2 :: ()) -> case u0 of { _ALG_ _TUP_0 -> case u1 of { _ALG_ _TUP_0 -> case u2 of { _ALG_ _TUP_0 -> let {(u3 :: [()]) = _!_ _NIL_ [()] []} in _!_ (:) [()] [u0, u3]; _NO_DEFLT_ }; _NO_DEFLT_ }; _NO_DEFLT_ } _N_ } #-}
instance Enum Bool
{-# GHC_PRAGMA _M_ PreludeCore {-dfun-} _A_ 0 _N_ _N_ _N_ _F_ _IF_ARGS_ 0 0 X 6 _!_ _TUP_5 [{{Ord Bool}}, (Bool -> [Bool]), (Bool -> Bool -> [Bool]), (Bool -> Bool -> [Bool]), (Bool -> Bool -> Bool -> [Bool])] [_DFUN_ Ord (Bool), _CONSTM_ Enum enumFrom (Bool), _CONSTM_ Enum enumFromThen (Bool), _CONSTM_ Enum enumFromTo (Bool), _CONSTM_ Enum enumFromThenTo (Bool)] _N_
- enumFrom = _A_ 1 _U_ 2 _N_ _S_ "E" _N_ _N_,
- enumFromThen = _A_ 2 _U_ 22 _N_ _S_ "EE" _N_ _N_,
- enumFromTo = _A_ 2 _U_ 22 _N_ _N_ _N_ _N_,
- enumFromThenTo = _A_ 3 _U_ 222 _N_ _N_ _N_ _N_ #-}
+ enumFrom = { _A_ 1 _U_ 2 _N_ _S_ "E" _N_ _N_ },
+ enumFromThen = { _A_ 2 _U_ 22 _N_ _S_ "EE" _N_ _N_ },
+ enumFromTo = { _A_ 2 _U_ 22 _N_ _S_ "EL" _N_ _N_ },
+ enumFromThenTo = { _A_ 3 _U_ 222 _N_ _S_ "EEL" _N_ _N_ } #-}
instance Enum Char
{-# GHC_PRAGMA _M_ PreludeCore {-dfun-} _A_ 0 _N_ _N_ _N_ _F_ _IF_ARGS_ 0 0 X 6 _!_ _TUP_5 [{{Ord Char}}, (Char -> [Char]), (Char -> Char -> [Char]), (Char -> Char -> [Char]), (Char -> Char -> Char -> [Char])] [_DFUN_ Ord (Char), _CONSTM_ Enum enumFrom (Char), _CONSTM_ Enum enumFromThen (Char), _CONSTM_ Enum enumFromTo (Char), _CONSTM_ Enum enumFromThenTo (Char)] _N_
- enumFrom = _A_ 1 _U_ 1 _N_ _S_ "U(P)" {_A_ 1 _U_ 2 _N_ _N_ _N_ _N_} _N_ _N_,
- enumFromThen = _A_ 2 _U_ 22 _N_ _N_ _N_ _N_,
- enumFromTo = _A_ 2 _U_ 22 _N_ _N_ _N_ _N_,
- enumFromThenTo = _A_ 3 _U_ 222 _N_ _N_ _N_ _N_ #-}
+ enumFrom = { _A_ 1 _U_ 1 _N_ _S_ "U(P)" {_A_ 1 _U_ 2 _N_ _N_ _N_ _N_} _N_ _N_ },
+ enumFromThen = { _A_ 2 _U_ 22 _N_ _N_ _N_ _N_ },
+ enumFromTo = { _A_ 2 _U_ 12 _N_ _S_ "U(P)L" {_A_ 2 _U_ 22 _N_ _N_ _N_ _N_} _N_ _N_ },
+ enumFromThenTo = { _A_ 3 _U_ 222 _N_ _N_ _N_ _N_ } #-}
instance Enum Double
{-# GHC_PRAGMA _M_ PreludeCore {-dfun-} _A_ 0 _N_ _N_ _N_ _F_ _IF_ARGS_ 0 0 X 6 _!_ _TUP_5 [{{Ord Double}}, (Double -> [Double]), (Double -> Double -> [Double]), (Double -> Double -> [Double]), (Double -> Double -> Double -> [Double])] [_DFUN_ Ord (Double), _CONSTM_ Enum enumFrom (Double), _CONSTM_ Enum enumFromThen (Double), _CONSTM_ Enum enumFromTo (Double), _CONSTM_ Enum enumFromThenTo (Double)] _N_
- enumFrom = _A_ 1 _U_ 2 _N_ _N_ _N_ _N_,
- enumFromThen = _A_ 2 _U_ 21 _N_ _N_ _N_ _N_,
- enumFromTo = _A_ 2 _U_ 22 _N_ _N_ _N_ _N_,
- enumFromThenTo = _A_ 3 _U_ 222 _N_ _N_ _N_ _N_ #-}
+ enumFrom = { _A_ 1 _U_ 2 _N_ _N_ _N_ _N_ },
+ enumFromThen = { _A_ 2 _U_ 21 _N_ _N_ _N_ _N_ },
+ enumFromTo = { _A_ 2 _U_ 22 _N_ _N_ _N_ _N_ },
+ enumFromThenTo = { _A_ 3 _U_ 222 _N_ _N_ _N_ _N_ } #-}
instance Enum Float
{-# GHC_PRAGMA _M_ PreludeCore {-dfun-} _A_ 0 _N_ _N_ _N_ _F_ _IF_ARGS_ 0 0 X 6 _!_ _TUP_5 [{{Ord Float}}, (Float -> [Float]), (Float -> Float -> [Float]), (Float -> Float -> [Float]), (Float -> Float -> Float -> [Float])] [_DFUN_ Ord (Float), _CONSTM_ Enum enumFrom (Float), _CONSTM_ Enum enumFromThen (Float), _CONSTM_ Enum enumFromTo (Float), _CONSTM_ Enum enumFromThenTo (Float)] _N_
- enumFrom = _A_ 1 _U_ 2 _N_ _N_ _N_ _N_,
- enumFromThen = _A_ 2 _U_ 21 _N_ _N_ _N_ _N_,
- enumFromTo = _A_ 2 _U_ 22 _N_ _N_ _N_ _N_,
- enumFromThenTo = _A_ 3 _U_ 222 _N_ _N_ _N_ _N_ #-}
+ enumFrom = { _A_ 1 _U_ 2 _N_ _N_ _N_ _N_ },
+ enumFromThen = { _A_ 2 _U_ 21 _N_ _N_ _N_ _N_ },
+ enumFromTo = { _A_ 2 _U_ 22 _N_ _N_ _N_ _N_ },
+ enumFromThenTo = { _A_ 3 _U_ 222 _N_ _N_ _N_ _N_ } #-}
instance Enum Int
{-# GHC_PRAGMA _M_ PreludeCore {-dfun-} _A_ 0 _N_ _N_ _N_ _F_ _IF_ARGS_ 0 0 X 6 _!_ _TUP_5 [{{Ord Int}}, (Int -> [Int]), (Int -> Int -> [Int]), (Int -> Int -> [Int]), (Int -> Int -> Int -> [Int])] [_DFUN_ Ord (Int), _CONSTM_ Enum enumFrom (Int), _CONSTM_ Enum enumFromThen (Int), _CONSTM_ Enum enumFromTo (Int), _CONSTM_ Enum enumFromThenTo (Int)] _N_
- enumFrom = _A_ 1 _U_ 2 _N_ _N_ _F_ _ALWAYS_ \ (u0 :: Int) -> _LETREC_ {(u1 :: Int -> [Int]) = \ (u2 :: Int) -> let {(u6 :: [Int]) = let {(u5 :: Int) = case u2 of { _ALG_ I# (u3 :: Int#) -> case _#_ plusInt# [] [u3, 1#] of { _PRIM_ (u4 :: Int#) -> _!_ I# [] [u4] }; _NO_DEFLT_ }} in _APP_ u1 [ u5 ]} in _!_ (:) [Int] [u2, u6]} in _APP_ u1 [ u0 ] _N_,
- enumFromThen = _A_ 2 _U_ 21 _N_ _N_ _N_ _N_,
- enumFromTo = _A_ 2 _U_ 12 _N_ _S_ "SS" _F_ _ALWAYS_ \ (u0 :: Int) (u1 :: Int) -> case u0 of { _ALG_ I# (u2 :: Int#) -> _LETREC_ {(u3 :: Int# -> [Int]) = \ (u4 :: Int#) -> case u1 of { _ALG_ I# (u5 :: Int#) -> case _#_ leInt# [] [u4, u5] of { _ALG_ True -> let {(u7 :: [Int]) = case _#_ plusInt# [] [u4, 1#] of { _PRIM_ (u6 :: Int#) -> _APP_ u3 [ u6 ] }} in let {(u8 :: Int) = _!_ I# [] [u4]} in _!_ (:) [Int] [u8, u7]; False -> _!_ _NIL_ [Int] []; _NO_DEFLT_ }; _NO_DEFLT_ }} in _APP_ u3 [ u2 ]; _NO_DEFLT_ } _N_,
- enumFromThenTo = _A_ 3 _U_ 222 _N_ _N_ _N_ _N_ #-}
+ enumFrom = { _A_ 1 _U_ 2 _N_ _N_ _F_ _ALWAYS_ \ (u0 :: Int) -> _LETREC_ {(u1 :: Int -> [Int]) = \ (u2 :: Int) -> let {(u6 :: [Int]) = let {(u5 :: Int) = case u2 of { _ALG_ I# (u3 :: Int#) -> case _#_ plusInt# [] [u3, 1#] of { _PRIM_ (u4 :: Int#) -> _!_ I# [] [u4] }; _NO_DEFLT_ }} in _APP_ u1 [ u5 ]} in _!_ (:) [Int] [u2, u6]} in _APP_ u1 [ u0 ] _N_ },
+ enumFromThen = { _A_ 2 _U_ 21 _N_ _N_ _N_ _N_ },
+ enumFromTo = { _A_ 2 _U_ 12 _N_ _S_ "SS" _F_ _ALWAYS_ \ (u0 :: Int) (u1 :: Int) -> case u0 of { _ALG_ I# (u2 :: Int#) -> _LETREC_ {(u3 :: Int# -> [Int]) = \ (u4 :: Int#) -> case u1 of { _ALG_ I# (u5 :: Int#) -> case _#_ leInt# [] [u4, u5] of { _ALG_ True -> let {(u7 :: [Int]) = case _#_ plusInt# [] [u4, 1#] of { _PRIM_ (u6 :: Int#) -> _APP_ u3 [ u6 ] }} in let {(u8 :: Int) = _!_ I# [] [u4]} in _!_ (:) [Int] [u8, u7]; False -> _!_ _NIL_ [Int] []; _NO_DEFLT_ }; _NO_DEFLT_ }} in _APP_ u3 [ u2 ]; _NO_DEFLT_ } _N_ },
+ enumFromThenTo = { _A_ 3 _U_ 222 _N_ _N_ _N_ _N_ } #-}
instance Enum Integer
{-# GHC_PRAGMA _M_ PreludeCore {-dfun-} _A_ 0 _N_ _N_ _N_ _F_ _IF_ARGS_ 0 0 X 6 _!_ _TUP_5 [{{Ord Integer}}, (Integer -> [Integer]), (Integer -> Integer -> [Integer]), (Integer -> Integer -> [Integer]), (Integer -> Integer -> Integer -> [Integer])] [_DFUN_ Ord (Integer), _CONSTM_ Enum enumFrom (Integer), _CONSTM_ Enum enumFromThen (Integer), _CONSTM_ Enum enumFromTo (Integer), _CONSTM_ Enum enumFromThenTo (Integer)] _N_
- enumFrom = _A_ 1 _U_ 2 _N_ _N_ _N_ _N_,
- enumFromThen = _A_ 2 _U_ 21 _N_ _N_ _N_ _N_,
- enumFromTo = _A_ 2 _U_ 22 _N_ _N_ _N_ _N_,
- enumFromThenTo = _A_ 3 _U_ 222 _N_ _N_ _N_ _N_ #-}
+ enumFrom = { _A_ 1 _U_ 2 _N_ _N_ _N_ _N_ },
+ enumFromThen = { _A_ 2 _U_ 21 _N_ _N_ _N_ _N_ },
+ enumFromTo = { _A_ 2 _U_ 22 _N_ _N_ _N_ _N_ },
+ enumFromThenTo = { _A_ 3 _U_ 222 _N_ _N_ _N_ _N_ } #-}
instance Integral a => Enum (Ratio a)
{-# GHC_PRAGMA _M_ PreludeRatio {-dfun-} _A_ 2 _U_ 22 _N_ _N_ _N_ _N_ #-}
instance Enum (Ratio Integer)
{-# GHC_PRAGMA _M_ PreludeRatio {-dfun-} _A_ 0 _N_ _N_ _N_ _F_ _IF_ARGS_ 0 0 X 6 _!_ _TUP_5 [{{Ord (Ratio Integer)}}, (Ratio Integer -> [Ratio Integer]), (Ratio Integer -> Ratio Integer -> [Ratio Integer]), (Ratio Integer -> Ratio Integer -> [Ratio Integer]), (Ratio Integer -> Ratio Integer -> Ratio Integer -> [Ratio Integer])] [_DFUN_ Ord (Ratio Integer), _CONSTM_ Enum enumFrom (Ratio Integer), _CONSTM_ Enum enumFromThen (Ratio Integer), _CONSTM_ Enum enumFromTo (Ratio Integer), _CONSTM_ Enum enumFromThenTo (Ratio Integer)] _N_
- enumFrom = _A_ 1 _U_ 2 _N_ _N_ _N_ _N_,
- enumFromThen = _A_ 2 _U_ 21 _N_ _N_ _N_ _N_,
- enumFromTo = _A_ 2 _U_ 22 _N_ _N_ _N_ _N_,
- enumFromThenTo = _A_ 3 _U_ 222 _N_ _N_ _N_ _N_ #-}
+ enumFrom = { _A_ 1 _U_ 2 _N_ _N_ _N_ _N_ },
+ enumFromThen = { _A_ 2 _U_ 21 _N_ _N_ _N_ _N_ },
+ enumFromTo = { _A_ 2 _U_ 22 _N_ _N_ _N_ _N_ },
+ enumFromThenTo = { _A_ 3 _U_ 222 _N_ _N_ _N_ _N_ } #-}
instance Eq ()
{-# GHC_PRAGMA _M_ PreludeBuiltin {-dfun-} _A_ 0 _N_ _N_ _N_ _F_ _IF_ARGS_ 0 0 X 3 _!_ _TUP_2 [(() -> () -> Bool), (() -> () -> Bool)] [_CONSTM_ Eq (==) (()), _CONSTM_ Eq (/=) (())] _N_
- (==) = _A_ 2 _U_ 11 _N_ _S_ "EE" _F_ _IF_ARGS_ 0 2 CC 3 \ (u0 :: ()) (u1 :: ()) -> case u0 of { _ALG_ _TUP_0 -> case u1 of { _ALG_ _TUP_0 -> _!_ True [] []; _NO_DEFLT_ }; _NO_DEFLT_ } _N_,
- (/=) = _A_ 2 _U_ 11 _N_ _S_ "EE" _F_ _IF_ARGS_ 0 2 CC 3 \ (u0 :: ()) (u1 :: ()) -> case u0 of { _ALG_ _TUP_0 -> case u1 of { _ALG_ _TUP_0 -> _!_ False [] []; _NO_DEFLT_ }; _NO_DEFLT_ } _N_ #-}
+ (==) = { _A_ 2 _U_ 11 _N_ _S_ "EE" _F_ _IF_ARGS_ 0 2 CC 3 \ (u0 :: ()) (u1 :: ()) -> case u0 of { _ALG_ _TUP_0 -> case u1 of { _ALG_ _TUP_0 -> _!_ True [] []; _NO_DEFLT_ }; _NO_DEFLT_ } _N_ },
+ (/=) = { _A_ 2 _U_ 11 _N_ _S_ "EE" _F_ _IF_ARGS_ 0 2 CC 3 \ (u0 :: ()) (u1 :: ()) -> case u0 of { _ALG_ _TUP_0 -> case u1 of { _ALG_ _TUP_0 -> _!_ False [] []; _NO_DEFLT_ }; _NO_DEFLT_ } _N_ } #-}
instance (Eq a, Eq b) => Eq (a, b)
- {-# GHC_PRAGMA _M_ PreludeBuiltin {-dfun-} _A_ 2 _U_ 11 _N_ _N_ _N_ _N_ #-}
+ {-# GHC_PRAGMA _M_ PreludeBuiltin {-dfun-} _A_ 2 _U_ 22 _N_ _N_ _N_ _N_ #-}
instance (Eq a, Eq b, Eq c) => Eq (a, b, c)
{-# GHC_PRAGMA _M_ PreludeBuiltin {-dfun-} _A_ 3 _U_ 111 _N_ _N_ _N_ _N_ #-}
instance (Eq a, Eq b, Eq c, Eq d) => Eq (a, b, c, d)
{-# GHC_PRAGMA _M_ PreludeBuiltin {-dfun-} _A_ 5 _U_ 11111 _N_ _N_ _N_ _N_ #-}
instance Eq (Int, Int)
{-# GHC_PRAGMA _M_ PreludeBuiltin {-dfun-} _A_ 0 _N_ _N_ _N_ _F_ _IF_ARGS_ 0 0 X 3 _!_ _TUP_2 [((Int, Int) -> (Int, Int) -> Bool), ((Int, Int) -> (Int, Int) -> Bool)] [_CONSTM_ Eq (==) ((Int, Int)), _CONSTM_ Eq (/=) ((Int, Int))] _N_
- (==) = _A_ 2 _U_ 11 _N_ _S_ "U(U(P)L)U(U(P)L)" {_A_ 4 _U_ 2121 _N_ _N_ _F_ _IF_ARGS_ 0 4 XCXC 7 \ (u0 :: Int#) (u1 :: Int) (u2 :: Int#) (u3 :: Int) -> case _#_ eqInt# [] [u0, u2] of { _ALG_ True -> case u1 of { _ALG_ I# (u4 :: Int#) -> case u3 of { _ALG_ I# (u5 :: Int#) -> _#_ eqInt# [] [u4, u5]; _NO_DEFLT_ }; _NO_DEFLT_ }; False -> _!_ False [] []; _NO_DEFLT_ } _N_} _F_ _ALWAYS_ \ (u0 :: (Int, Int)) (u1 :: (Int, Int)) -> case u0 of { _ALG_ _TUP_2 (u2 :: Int) (u3 :: Int) -> case u2 of { _ALG_ I# (u4 :: Int#) -> case u1 of { _ALG_ _TUP_2 (u5 :: Int) (u6 :: Int) -> case u5 of { _ALG_ I# (u7 :: Int#) -> case _#_ eqInt# [] [u4, u7] of { _ALG_ True -> case u3 of { _ALG_ I# (u8 :: Int#) -> case u6 of { _ALG_ I# (u9 :: Int#) -> _#_ eqInt# [] [u8, u9]; _NO_DEFLT_ }; _NO_DEFLT_ }; False -> _!_ False [] []; _NO_DEFLT_ }; _NO_DEFLT_ }; _NO_DEFLT_ }; _NO_DEFLT_ }; _NO_DEFLT_ } _N_,
- (/=) = _A_ 2 _U_ 22 _N_ _N_ _N_ _N_ #-}
+ (==) = { _A_ 2 _U_ 11 _N_ _S_ "U(U(P)L)U(U(P)L)" {_A_ 4 _U_ 2121 _N_ _N_ _F_ _IF_ARGS_ 0 4 XCXC 7 \ (u0 :: Int#) (u1 :: Int) (u2 :: Int#) (u3 :: Int) -> case _#_ eqInt# [] [u0, u2] of { _ALG_ True -> case u1 of { _ALG_ I# (u4 :: Int#) -> case u3 of { _ALG_ I# (u5 :: Int#) -> _#_ eqInt# [] [u4, u5]; _NO_DEFLT_ }; _NO_DEFLT_ }; False -> _!_ False [] []; _NO_DEFLT_ } _N_} _F_ _ALWAYS_ \ (u0 :: (Int, Int)) (u1 :: (Int, Int)) -> case u0 of { _ALG_ _TUP_2 (u2 :: Int) (u3 :: Int) -> case u2 of { _ALG_ I# (u4 :: Int#) -> case u1 of { _ALG_ _TUP_2 (u5 :: Int) (u6 :: Int) -> case u5 of { _ALG_ I# (u7 :: Int#) -> case _#_ eqInt# [] [u4, u7] of { _ALG_ True -> case u3 of { _ALG_ I# (u8 :: Int#) -> case u6 of { _ALG_ I# (u9 :: Int#) -> _#_ eqInt# [] [u8, u9]; _NO_DEFLT_ }; _NO_DEFLT_ }; False -> _!_ False [] []; _NO_DEFLT_ }; _NO_DEFLT_ }; _NO_DEFLT_ }; _NO_DEFLT_ }; _NO_DEFLT_ } _N_ },
+ (/=) = { _A_ 2 _U_ 11 _N_ _S_ "U(U(P)L)U(U(P)L)" {_A_ 4 _U_ 2121 _N_ _N_ _F_ _IF_ARGS_ 0 4 XCXC 7 \ (u0 :: Int#) (u1 :: Int) (u2 :: Int#) (u3 :: Int) -> case _#_ neInt# [] [u0, u2] of { _ALG_ True -> _!_ True [] []; False -> case u1 of { _ALG_ I# (u4 :: Int#) -> case u3 of { _ALG_ I# (u5 :: Int#) -> _#_ neInt# [] [u4, u5]; _NO_DEFLT_ }; _NO_DEFLT_ }; _NO_DEFLT_ } _N_} _F_ _ALWAYS_ \ (u0 :: (Int, Int)) (u1 :: (Int, Int)) -> case u0 of { _ALG_ _TUP_2 (u2 :: Int) (u3 :: Int) -> case u2 of { _ALG_ I# (u4 :: Int#) -> case u1 of { _ALG_ _TUP_2 (u5 :: Int) (u6 :: Int) -> case u5 of { _ALG_ I# (u7 :: Int#) -> case _#_ neInt# [] [u4, u7] of { _ALG_ True -> _!_ True [] []; False -> case u3 of { _ALG_ I# (u8 :: Int#) -> case u6 of { _ALG_ I# (u9 :: Int#) -> _#_ neInt# [] [u8, u9]; _NO_DEFLT_ }; _NO_DEFLT_ }; _NO_DEFLT_ }; _NO_DEFLT_ }; _NO_DEFLT_ }; _NO_DEFLT_ }; _NO_DEFLT_ } _N_ } #-}
+instance Eq (Int, Int, Int)
+ {-# GHC_PRAGMA _M_ PreludeBuiltin {-dfun-} _A_ 0 _N_ _N_ _N_ _F_ _IF_ARGS_ 0 0 X 3 _!_ _TUP_2 [((Int, Int, Int) -> (Int, Int, Int) -> Bool), ((Int, Int, Int) -> (Int, Int, Int) -> Bool)] [_CONSTM_ Eq (==) ((Int, Int, Int)), _CONSTM_ Eq (/=) ((Int, Int, Int))] _N_
+ (==) = { _A_ 2 _U_ 11 _N_ _S_ "U(U(P)LL)U(U(P)LL)" {_A_ 4 _U_ 2111 _N_ _N_ _N_ _N_} _N_ _N_ },
+ (/=) = { _A_ 2 _U_ 11 _N_ _S_ "U(U(P)LL)U(U(P)LL)" {_A_ 4 _U_ 2111 _N_ _N_ _N_ _N_} _N_ _N_ } #-}
+instance Eq (Int, Int, Int, Int)
+ {-# GHC_PRAGMA _M_ PreludeBuiltin {-dfun-} _A_ 0 _N_ _N_ _N_ _F_ _IF_ARGS_ 0 0 X 3 _!_ _TUP_2 [((Int, Int, Int, Int) -> (Int, Int, Int, Int) -> Bool), ((Int, Int, Int, Int) -> (Int, Int, Int, Int) -> Bool)] [_CONSTM_ Eq (==) ((Int, Int, Int, Int)), _CONSTM_ Eq (/=) ((Int, Int, Int, Int))] _N_
+ (==) = { _A_ 2 _U_ 11 _N_ _S_ "U(U(P)LLL)U(U(P)LLL)" {_A_ 5 _U_ 21111 _N_ _N_ _N_ _N_} _N_ _N_ },
+ (/=) = { _A_ 2 _U_ 11 _N_ _S_ "U(U(P)LLL)U(U(P)LLL)" {_A_ 5 _U_ 21111 _N_ _N_ _N_ _N_} _N_ _N_ } #-}
+instance Eq (Int, Int, Int, Int, Int)
+ {-# GHC_PRAGMA _M_ PreludeBuiltin {-dfun-} _A_ 0 _N_ _N_ _N_ _F_ _IF_ARGS_ 0 0 X 3 _!_ _TUP_2 [((Int, Int, Int, Int, Int) -> (Int, Int, Int, Int, Int) -> Bool), ((Int, Int, Int, Int, Int) -> (Int, Int, Int, Int, Int) -> Bool)] [_CONSTM_ Eq (==) ((Int, Int, Int, Int, Int)), _CONSTM_ Eq (/=) ((Int, Int, Int, Int, Int))] _N_
+ (==) = { _A_ 2 _U_ 11 _N_ _S_ "U(U(P)LLLL)U(U(P)LLLL)" _N_ _N_ },
+ (/=) = { _A_ 2 _U_ 11 _N_ _S_ "U(U(P)LLLL)U(U(P)LLLL)" _N_ _N_ } #-}
+instance Eq ([Char], [Char])
+ {-# GHC_PRAGMA _M_ PreludeBuiltin {-dfun-} _A_ 0 _N_ _N_ _N_ _F_ _IF_ARGS_ 0 0 X 3 _!_ _TUP_2 [(([Char], [Char]) -> ([Char], [Char]) -> Bool), (([Char], [Char]) -> ([Char], [Char]) -> Bool)] [_CONSTM_ Eq (==) (([Char], [Char])), _CONSTM_ Eq (/=) (([Char], [Char]))] _N_
+ (==) = { _A_ 2 _U_ 11 _N_ _S_ "U(SL)U(SL)" {_A_ 4 _U_ 2222 _N_ _N_ _N_ _N_} _N_ _N_ },
+ (/=) = { _A_ 2 _U_ 11 _N_ _S_ "U(SL)U(SL)" {_A_ 4 _U_ 2222 _N_ _N_ _N_ _N_} _N_ _N_ } #-}
+instance Eq ([Int], [Int])
+ {-# GHC_PRAGMA _M_ PreludeBuiltin {-dfun-} _A_ 0 _N_ _N_ _N_ _F_ _IF_ARGS_ 0 0 X 3 _!_ _TUP_2 [(([Int], [Int]) -> ([Int], [Int]) -> Bool), (([Int], [Int]) -> ([Int], [Int]) -> Bool)] [_CONSTM_ Eq (==) (([Int], [Int])), _CONSTM_ Eq (/=) (([Int], [Int]))] _N_
+ (==) = { _A_ 2 _U_ 11 _N_ _S_ "U(SL)U(SL)" {_A_ 4 _U_ 2222 _N_ _N_ _N_ _N_} _N_ _N_ },
+ (/=) = { _A_ 2 _U_ 11 _N_ _S_ "U(SL)U(SL)" {_A_ 4 _U_ 2222 _N_ _N_ _N_ _N_} _N_ _N_ } #-}
instance Eq (_PackedString, _PackedString)
{-# GHC_PRAGMA _M_ PreludeBuiltin {-dfun-} _A_ 0 _N_ _N_ _N_ _F_ _IF_ARGS_ 0 0 X 3 _!_ _TUP_2 [((_PackedString, _PackedString) -> (_PackedString, _PackedString) -> Bool), ((_PackedString, _PackedString) -> (_PackedString, _PackedString) -> Bool)] [_CONSTM_ Eq (==) ((_PackedString, _PackedString)), _CONSTM_ Eq (/=) ((_PackedString, _PackedString))] _N_
- (==) = _A_ 2 _U_ 11 _N_ _S_ "U(SL)U(SL)" {_A_ 4 _U_ 2222 _N_ _N_ _N_ _N_} _N_ _N_,
- (/=) = _A_ 2 _U_ 22 _N_ _N_ _N_ _N_ #-}
+ (==) = { _A_ 2 _U_ 11 _N_ _S_ "U(SL)U(SL)" {_A_ 4 _U_ 2222 _N_ _N_ _N_ _N_} _N_ _N_ },
+ (/=) = { _A_ 2 _U_ 11 _N_ _S_ "U(SL)U(SL)" {_A_ 4 _U_ 2222 _N_ _N_ _N_ _N_} _N_ _N_ } #-}
instance (Ix a, Eq b) => Eq (Array a b)
{-# GHC_PRAGMA _M_ PreludeArray {-dfun-} _A_ 2 _U_ 21 _N_ _N_ _N_ _N_ #-}
instance (Eq a, Eq b) => Eq (Assoc a b)
{-# GHC_PRAGMA _M_ PreludeArray {-dfun-} _A_ 2 _U_ 11 _N_ _N_ _N_ _N_ #-}
instance Eq Bool
{-# GHC_PRAGMA _M_ PreludeCore {-dfun-} _A_ 0 _N_ _N_ _N_ _F_ _IF_ARGS_ 0 0 X 3 _!_ _TUP_2 [(Bool -> Bool -> Bool), (Bool -> Bool -> Bool)] [_CONSTM_ Eq (==) (Bool), _CONSTM_ Eq (/=) (Bool)] _N_
- (==) = _A_ 2 _U_ 11 _N_ _S_ "EE" _F_ _IF_ARGS_ 0 2 CC 7 \ (u0 :: Bool) (u1 :: Bool) -> case u0 of { _ALG_ True -> u1; False -> case u1 of { _ALG_ True -> _!_ False [] []; False -> _!_ True [] []; _NO_DEFLT_ }; _NO_DEFLT_ } _N_,
- (/=) = _A_ 2 _U_ 11 _N_ _S_ "EE" _F_ _IF_ARGS_ 0 2 CC 7 \ (u0 :: Bool) (u1 :: Bool) -> case u0 of { _ALG_ True -> case u1 of { _ALG_ True -> _!_ False [] []; False -> _!_ True [] []; _NO_DEFLT_ }; False -> u1; _NO_DEFLT_ } _N_ #-}
+ (==) = { _A_ 2 _U_ 11 _N_ _S_ "EE" _F_ _IF_ARGS_ 0 2 CC 7 \ (u0 :: Bool) (u1 :: Bool) -> case u0 of { _ALG_ True -> u1; False -> case u1 of { _ALG_ True -> _!_ False [] []; False -> _!_ True [] []; _NO_DEFLT_ }; _NO_DEFLT_ } _N_ },
+ (/=) = { _A_ 2 _U_ 11 _N_ _S_ "EE" _F_ _IF_ARGS_ 0 2 CC 7 \ (u0 :: Bool) (u1 :: Bool) -> case u0 of { _ALG_ True -> case u1 of { _ALG_ True -> _!_ False [] []; False -> _!_ True [] []; _NO_DEFLT_ }; False -> u1; _NO_DEFLT_ } _N_ } #-}
instance Eq Char
{-# GHC_PRAGMA _M_ PreludeCore {-dfun-} _A_ 0 _N_ _N_ _N_ _F_ _IF_ARGS_ 0 0 X 3 _!_ _TUP_2 [(Char -> Char -> Bool), (Char -> Char -> Bool)] [_CONSTM_ Eq (==) (Char), _CONSTM_ Eq (/=) (Char)] _N_
- (==) = _A_ 2 _U_ 11 _N_ _S_ "U(P)U(P)" {_A_ 2 _U_ 22 _N_ _N_ _F_ _IF_ARGS_ 0 2 XX 1 \ (u0 :: Char#) (u1 :: Char#) -> _#_ eqChar# [] [u0, u1] _N_} _F_ _IF_ARGS_ 0 2 CC 3 \ (u0 :: Char) (u1 :: Char) -> case u0 of { _ALG_ C# (u2 :: Char#) -> case u1 of { _ALG_ C# (u3 :: Char#) -> _#_ eqChar# [] [u2, u3]; _NO_DEFLT_ }; _NO_DEFLT_ } _N_,
- (/=) = _A_ 2 _U_ 11 _N_ _S_ "U(P)U(P)" {_A_ 2 _U_ 22 _N_ _N_ _F_ _IF_ARGS_ 0 2 XX 1 \ (u0 :: Char#) (u1 :: Char#) -> _#_ neChar# [] [u0, u1] _N_} _F_ _IF_ARGS_ 0 2 CC 3 \ (u0 :: Char) (u1 :: Char) -> case u0 of { _ALG_ C# (u2 :: Char#) -> case u1 of { _ALG_ C# (u3 :: Char#) -> _#_ neChar# [] [u2, u3]; _NO_DEFLT_ }; _NO_DEFLT_ } _N_ #-}
+ (==) = { _A_ 2 _U_ 11 _N_ _S_ "U(P)U(P)" {_A_ 2 _U_ 22 _N_ _N_ _F_ _IF_ARGS_ 0 2 XX 1 \ (u0 :: Char#) (u1 :: Char#) -> _#_ eqChar# [] [u0, u1] _N_} _F_ _IF_ARGS_ 0 2 CC 3 \ (u0 :: Char) (u1 :: Char) -> case u0 of { _ALG_ C# (u2 :: Char#) -> case u1 of { _ALG_ C# (u3 :: Char#) -> _#_ eqChar# [] [u2, u3]; _NO_DEFLT_ }; _NO_DEFLT_ } _N_ },
+ (/=) = { _A_ 2 _U_ 11 _N_ _S_ "U(P)U(P)" {_A_ 2 _U_ 22 _N_ _N_ _F_ _IF_ARGS_ 0 2 XX 1 \ (u0 :: Char#) (u1 :: Char#) -> _#_ neChar# [] [u0, u1] _N_} _F_ _IF_ARGS_ 0 2 CC 3 \ (u0 :: Char) (u1 :: Char) -> case u0 of { _ALG_ C# (u2 :: Char#) -> case u1 of { _ALG_ C# (u3 :: Char#) -> _#_ neChar# [] [u2, u3]; _NO_DEFLT_ }; _NO_DEFLT_ } _N_ } #-}
instance Eq a => Eq (Complex a)
{-# GHC_PRAGMA _M_ PreludeComplex {-dfun-} _A_ 1 _U_ 2 _N_ _N_ _N_ _N_ #-}
instance Eq (Complex Double)
{-# GHC_PRAGMA _M_ PreludeComplex {-dfun-} _A_ 0 _N_ _N_ _N_ _F_ _IF_ARGS_ 0 0 X 3 _!_ _TUP_2 [(Complex Double -> Complex Double -> Bool), (Complex Double -> Complex Double -> Bool)] [_CONSTM_ Eq (==) (Complex Double), _CONSTM_ Eq (/=) (Complex Double)] _N_
- (==) = _A_ 2 _U_ 11 _N_ _S_ "U(U(P)L)U(U(P)L)" {_A_ 4 _U_ 2121 _N_ _N_ _F_ _IF_ARGS_ 0 4 XCXC 7 \ (u0 :: Double#) (u1 :: Double) (u2 :: Double#) (u3 :: Double) -> case _#_ eqDouble# [] [u0, u2] of { _ALG_ True -> case u1 of { _ALG_ D# (u4 :: Double#) -> case u3 of { _ALG_ D# (u5 :: Double#) -> _#_ eqDouble# [] [u4, u5]; _NO_DEFLT_ }; _NO_DEFLT_ }; False -> _!_ False [] []; _NO_DEFLT_ } _N_} _F_ _ALWAYS_ \ (u0 :: Complex Double) (u1 :: Complex Double) -> case u0 of { _ALG_ (:+) (u2 :: Double) (u3 :: Double) -> case u2 of { _ALG_ D# (u4 :: Double#) -> case u1 of { _ALG_ (:+) (u5 :: Double) (u6 :: Double) -> case u5 of { _ALG_ D# (u7 :: Double#) -> case _#_ eqDouble# [] [u4, u7] of { _ALG_ True -> case u3 of { _ALG_ D# (u8 :: Double#) -> case u6 of { _ALG_ D# (u9 :: Double#) -> _#_ eqDouble# [] [u8, u9]; _NO_DEFLT_ }; _NO_DEFLT_ }; False -> _!_ False [] []; _NO_DEFLT_ }; _NO_DEFLT_ }; _NO_DEFLT_ }; _NO_DEFLT_ }; _NO_DEFLT_ } _N_,
- (/=) = _A_ 2 _U_ 11 _N_ _S_ "U(U(P)L)U(U(P)L)" {_A_ 4 _U_ 2121 _N_ _N_ _F_ _IF_ARGS_ 0 4 XCXC 7 \ (u0 :: Double#) (u1 :: Double) (u2 :: Double#) (u3 :: Double) -> case _#_ neDouble# [] [u0, u2] of { _ALG_ True -> _!_ True [] []; False -> case u1 of { _ALG_ D# (u4 :: Double#) -> case u3 of { _ALG_ D# (u5 :: Double#) -> _#_ neDouble# [] [u4, u5]; _NO_DEFLT_ }; _NO_DEFLT_ }; _NO_DEFLT_ } _N_} _F_ _ALWAYS_ \ (u0 :: Complex Double) (u1 :: Complex Double) -> case u0 of { _ALG_ (:+) (u2 :: Double) (u3 :: Double) -> case u2 of { _ALG_ D# (u4 :: Double#) -> case u1 of { _ALG_ (:+) (u5 :: Double) (u6 :: Double) -> case u5 of { _ALG_ D# (u7 :: Double#) -> case _#_ neDouble# [] [u4, u7] of { _ALG_ True -> _!_ True [] []; False -> case u3 of { _ALG_ D# (u8 :: Double#) -> case u6 of { _ALG_ D# (u9 :: Double#) -> _#_ neDouble# [] [u8, u9]; _NO_DEFLT_ }; _NO_DEFLT_ }; _NO_DEFLT_ }; _NO_DEFLT_ }; _NO_DEFLT_ }; _NO_DEFLT_ }; _NO_DEFLT_ } _N_ #-}
+ (==) = { _A_ 2 _U_ 11 _N_ _S_ "U(U(P)L)U(U(P)L)" {_A_ 4 _U_ 2121 _N_ _N_ _F_ _IF_ARGS_ 0 4 XCXC 7 \ (u0 :: Double#) (u1 :: Double) (u2 :: Double#) (u3 :: Double) -> case _#_ eqDouble# [] [u0, u2] of { _ALG_ True -> case u1 of { _ALG_ D# (u4 :: Double#) -> case u3 of { _ALG_ D# (u5 :: Double#) -> _#_ eqDouble# [] [u4, u5]; _NO_DEFLT_ }; _NO_DEFLT_ }; False -> _!_ False [] []; _NO_DEFLT_ } _N_} _F_ _ALWAYS_ \ (u0 :: Complex Double) (u1 :: Complex Double) -> case u0 of { _ALG_ (:+) (u2 :: Double) (u3 :: Double) -> case u2 of { _ALG_ D# (u4 :: Double#) -> case u1 of { _ALG_ (:+) (u5 :: Double) (u6 :: Double) -> case u5 of { _ALG_ D# (u7 :: Double#) -> case _#_ eqDouble# [] [u4, u7] of { _ALG_ True -> case u3 of { _ALG_ D# (u8 :: Double#) -> case u6 of { _ALG_ D# (u9 :: Double#) -> _#_ eqDouble# [] [u8, u9]; _NO_DEFLT_ }; _NO_DEFLT_ }; False -> _!_ False [] []; _NO_DEFLT_ }; _NO_DEFLT_ }; _NO_DEFLT_ }; _NO_DEFLT_ }; _NO_DEFLT_ } _N_ },
+ (/=) = { _A_ 2 _U_ 11 _N_ _S_ "U(U(P)L)U(U(P)L)" {_A_ 4 _U_ 2121 _N_ _N_ _F_ _IF_ARGS_ 0 4 XCXC 7 \ (u0 :: Double#) (u1 :: Double) (u2 :: Double#) (u3 :: Double) -> case _#_ neDouble# [] [u0, u2] of { _ALG_ True -> _!_ True [] []; False -> case u1 of { _ALG_ D# (u4 :: Double#) -> case u3 of { _ALG_ D# (u5 :: Double#) -> _#_ neDouble# [] [u4, u5]; _NO_DEFLT_ }; _NO_DEFLT_ }; _NO_DEFLT_ } _N_} _F_ _ALWAYS_ \ (u0 :: Complex Double) (u1 :: Complex Double) -> case u0 of { _ALG_ (:+) (u2 :: Double) (u3 :: Double) -> case u2 of { _ALG_ D# (u4 :: Double#) -> case u1 of { _ALG_ (:+) (u5 :: Double) (u6 :: Double) -> case u5 of { _ALG_ D# (u7 :: Double#) -> case _#_ neDouble# [] [u4, u7] of { _ALG_ True -> _!_ True [] []; False -> case u3 of { _ALG_ D# (u8 :: Double#) -> case u6 of { _ALG_ D# (u9 :: Double#) -> _#_ neDouble# [] [u8, u9]; _NO_DEFLT_ }; _NO_DEFLT_ }; _NO_DEFLT_ }; _NO_DEFLT_ }; _NO_DEFLT_ }; _NO_DEFLT_ }; _NO_DEFLT_ } _N_ } #-}
instance Eq Double
{-# GHC_PRAGMA _M_ PreludeCore {-dfun-} _A_ 0 _N_ _N_ _N_ _F_ _IF_ARGS_ 0 0 X 3 _!_ _TUP_2 [(Double -> Double -> Bool), (Double -> Double -> Bool)] [_CONSTM_ Eq (==) (Double), _CONSTM_ Eq (/=) (Double)] _N_
- (==) = _A_ 2 _U_ 11 _N_ _S_ "U(P)U(P)" {_A_ 2 _U_ 22 _N_ _N_ _F_ _IF_ARGS_ 0 2 XX 1 \ (u0 :: Double#) (u1 :: Double#) -> _#_ eqDouble# [] [u0, u1] _N_} _F_ _IF_ARGS_ 0 2 CC 3 \ (u0 :: Double) (u1 :: Double) -> case u0 of { _ALG_ D# (u2 :: Double#) -> case u1 of { _ALG_ D# (u3 :: Double#) -> _#_ eqDouble# [] [u2, u3]; _NO_DEFLT_ }; _NO_DEFLT_ } _N_,
- (/=) = _A_ 2 _U_ 11 _N_ _S_ "U(P)U(P)" {_A_ 2 _U_ 22 _N_ _N_ _F_ _IF_ARGS_ 0 2 XX 1 \ (u0 :: Double#) (u1 :: Double#) -> _#_ neDouble# [] [u0, u1] _N_} _F_ _IF_ARGS_ 0 2 CC 3 \ (u0 :: Double) (u1 :: Double) -> case u0 of { _ALG_ D# (u2 :: Double#) -> case u1 of { _ALG_ D# (u3 :: Double#) -> _#_ neDouble# [] [u2, u3]; _NO_DEFLT_ }; _NO_DEFLT_ } _N_ #-}
+ (==) = { _A_ 2 _U_ 11 _N_ _S_ "U(P)U(P)" {_A_ 2 _U_ 22 _N_ _N_ _F_ _IF_ARGS_ 0 2 XX 1 \ (u0 :: Double#) (u1 :: Double#) -> _#_ eqDouble# [] [u0, u1] _N_} _F_ _IF_ARGS_ 0 2 CC 3 \ (u0 :: Double) (u1 :: Double) -> case u0 of { _ALG_ D# (u2 :: Double#) -> case u1 of { _ALG_ D# (u3 :: Double#) -> _#_ eqDouble# [] [u2, u3]; _NO_DEFLT_ }; _NO_DEFLT_ } _N_ },
+ (/=) = { _A_ 2 _U_ 11 _N_ _S_ "U(P)U(P)" {_A_ 2 _U_ 22 _N_ _N_ _F_ _IF_ARGS_ 0 2 XX 1 \ (u0 :: Double#) (u1 :: Double#) -> _#_ neDouble# [] [u0, u1] _N_} _F_ _IF_ARGS_ 0 2 CC 3 \ (u0 :: Double) (u1 :: Double) -> case u0 of { _ALG_ D# (u2 :: Double#) -> case u1 of { _ALG_ D# (u3 :: Double#) -> _#_ neDouble# [] [u2, u3]; _NO_DEFLT_ }; _NO_DEFLT_ } _N_ } #-}
instance Eq Float
{-# GHC_PRAGMA _M_ PreludeCore {-dfun-} _A_ 0 _N_ _N_ _N_ _F_ _IF_ARGS_ 0 0 X 3 _!_ _TUP_2 [(Float -> Float -> Bool), (Float -> Float -> Bool)] [_CONSTM_ Eq (==) (Float), _CONSTM_ Eq (/=) (Float)] _N_
- (==) = _A_ 2 _U_ 11 _N_ _S_ "U(P)U(P)" {_A_ 2 _U_ 22 _N_ _N_ _F_ _IF_ARGS_ 0 2 XX 1 \ (u0 :: Float#) (u1 :: Float#) -> _#_ eqFloat# [] [u0, u1] _N_} _F_ _IF_ARGS_ 0 2 CC 3 \ (u0 :: Float) (u1 :: Float) -> case u0 of { _ALG_ F# (u2 :: Float#) -> case u1 of { _ALG_ F# (u3 :: Float#) -> _#_ eqFloat# [] [u2, u3]; _NO_DEFLT_ }; _NO_DEFLT_ } _N_,
- (/=) = _A_ 2 _U_ 11 _N_ _S_ "U(P)U(P)" {_A_ 2 _U_ 22 _N_ _N_ _F_ _IF_ARGS_ 0 2 XX 1 \ (u0 :: Float#) (u1 :: Float#) -> _#_ neFloat# [] [u0, u1] _N_} _F_ _IF_ARGS_ 0 2 CC 3 \ (u0 :: Float) (u1 :: Float) -> case u0 of { _ALG_ F# (u2 :: Float#) -> case u1 of { _ALG_ F# (u3 :: Float#) -> _#_ neFloat# [] [u2, u3]; _NO_DEFLT_ }; _NO_DEFLT_ } _N_ #-}
+ (==) = { _A_ 2 _U_ 11 _N_ _S_ "U(P)U(P)" {_A_ 2 _U_ 22 _N_ _N_ _F_ _IF_ARGS_ 0 2 XX 1 \ (u0 :: Float#) (u1 :: Float#) -> _#_ eqFloat# [] [u0, u1] _N_} _F_ _IF_ARGS_ 0 2 CC 3 \ (u0 :: Float) (u1 :: Float) -> case u0 of { _ALG_ F# (u2 :: Float#) -> case u1 of { _ALG_ F# (u3 :: Float#) -> _#_ eqFloat# [] [u2, u3]; _NO_DEFLT_ }; _NO_DEFLT_ } _N_ },
+ (/=) = { _A_ 2 _U_ 11 _N_ _S_ "U(P)U(P)" {_A_ 2 _U_ 22 _N_ _N_ _F_ _IF_ARGS_ 0 2 XX 1 \ (u0 :: Float#) (u1 :: Float#) -> _#_ neFloat# [] [u0, u1] _N_} _F_ _IF_ARGS_ 0 2 CC 3 \ (u0 :: Float) (u1 :: Float) -> case u0 of { _ALG_ F# (u2 :: Float#) -> case u1 of { _ALG_ F# (u3 :: Float#) -> _#_ neFloat# [] [u2, u3]; _NO_DEFLT_ }; _NO_DEFLT_ } _N_ } #-}
instance Eq Int
{-# GHC_PRAGMA _M_ PreludeCore {-dfun-} _A_ 0 _N_ _N_ _N_ _F_ _IF_ARGS_ 0 0 X 3 _!_ _TUP_2 [(Int -> Int -> Bool), (Int -> Int -> Bool)] [_CONSTM_ Eq (==) (Int), _CONSTM_ Eq (/=) (Int)] _N_
- (==) = _A_ 2 _U_ 11 _N_ _S_ "U(P)U(P)" {_A_ 2 _U_ 22 _N_ _N_ _F_ _IF_ARGS_ 0 2 XX 1 \ (u0 :: Int#) (u1 :: Int#) -> _#_ eqInt# [] [u0, u1] _N_} _F_ _IF_ARGS_ 0 2 CC 3 \ (u0 :: Int) (u1 :: Int) -> case u0 of { _ALG_ I# (u2 :: Int#) -> case u1 of { _ALG_ I# (u3 :: Int#) -> _#_ eqInt# [] [u2, u3]; _NO_DEFLT_ }; _NO_DEFLT_ } _N_,
- (/=) = _A_ 2 _U_ 11 _N_ _S_ "U(P)U(P)" {_A_ 2 _U_ 22 _N_ _N_ _F_ _IF_ARGS_ 0 2 XX 1 \ (u0 :: Int#) (u1 :: Int#) -> _#_ neInt# [] [u0, u1] _N_} _F_ _IF_ARGS_ 0 2 CC 3 \ (u0 :: Int) (u1 :: Int) -> case u0 of { _ALG_ I# (u2 :: Int#) -> case u1 of { _ALG_ I# (u3 :: Int#) -> _#_ neInt# [] [u2, u3]; _NO_DEFLT_ }; _NO_DEFLT_ } _N_ #-}
+ (==) = { _A_ 2 _U_ 11 _N_ _S_ "U(P)U(P)" {_A_ 2 _U_ 22 _N_ _N_ _F_ _IF_ARGS_ 0 2 XX 1 \ (u0 :: Int#) (u1 :: Int#) -> _#_ eqInt# [] [u0, u1] _N_} _F_ _IF_ARGS_ 0 2 CC 3 \ (u0 :: Int) (u1 :: Int) -> case u0 of { _ALG_ I# (u2 :: Int#) -> case u1 of { _ALG_ I# (u3 :: Int#) -> _#_ eqInt# [] [u2, u3]; _NO_DEFLT_ }; _NO_DEFLT_ } _N_ },
+ (/=) = { _A_ 2 _U_ 11 _N_ _S_ "U(P)U(P)" {_A_ 2 _U_ 22 _N_ _N_ _F_ _IF_ARGS_ 0 2 XX 1 \ (u0 :: Int#) (u1 :: Int#) -> _#_ neInt# [] [u0, u1] _N_} _F_ _IF_ARGS_ 0 2 CC 3 \ (u0 :: Int) (u1 :: Int) -> case u0 of { _ALG_ I# (u2 :: Int#) -> case u1 of { _ALG_ I# (u3 :: Int#) -> _#_ neInt# [] [u2, u3]; _NO_DEFLT_ }; _NO_DEFLT_ } _N_ } #-}
instance Eq Integer
{-# GHC_PRAGMA _M_ PreludeCore {-dfun-} _A_ 0 _N_ _N_ _N_ _F_ _IF_ARGS_ 0 0 X 3 _!_ _TUP_2 [(Integer -> Integer -> Bool), (Integer -> Integer -> Bool)] [_CONSTM_ Eq (==) (Integer), _CONSTM_ Eq (/=) (Integer)] _N_
- (==) = _A_ 2 _U_ 11 _N_ _S_ "U(PPP)U(PPP)" {_A_ 4 _U_ 2221 _N_ _N_ _F_ _IF_ARGS_ 0 4 XXXC 4 \ (u0 :: Int#) (u1 :: Int#) (u2 :: ByteArray#) (u3 :: Integer) -> case u3 of { _ALG_ J# (u4 :: Int#) (u5 :: Int#) (u6 :: ByteArray#) -> case _#_ cmpInteger# [] [u0, u1, u2, u4, u5, u6] of { _PRIM_ 0# -> _!_ True [] []; (u7 :: Int#) -> _!_ False [] [] }; _NO_DEFLT_ } _N_} _F_ _IF_ARGS_ 0 2 CC 5 \ (u0 :: Integer) (u1 :: Integer) -> case u0 of { _ALG_ J# (u2 :: Int#) (u3 :: Int#) (u4 :: ByteArray#) -> case u1 of { _ALG_ J# (u5 :: Int#) (u6 :: Int#) (u7 :: ByteArray#) -> case _#_ cmpInteger# [] [u2, u3, u4, u5, u6, u7] of { _PRIM_ 0# -> _!_ True [] []; (u8 :: Int#) -> _!_ False [] [] }; _NO_DEFLT_ }; _NO_DEFLT_ } _N_,
- (/=) = _A_ 2 _U_ 11 _N_ _S_ "U(PPP)U(PPP)" {_A_ 4 _U_ 2221 _N_ _N_ _F_ _IF_ARGS_ 0 4 XXXC 4 \ (u0 :: Int#) (u1 :: Int#) (u2 :: ByteArray#) (u3 :: Integer) -> case u3 of { _ALG_ J# (u4 :: Int#) (u5 :: Int#) (u6 :: ByteArray#) -> case _#_ cmpInteger# [] [u0, u1, u2, u4, u5, u6] of { _PRIM_ 0# -> _!_ False [] []; (u7 :: Int#) -> _!_ True [] [] }; _NO_DEFLT_ } _N_} _F_ _IF_ARGS_ 0 2 CC 5 \ (u0 :: Integer) (u1 :: Integer) -> case u0 of { _ALG_ J# (u2 :: Int#) (u3 :: Int#) (u4 :: ByteArray#) -> case u1 of { _ALG_ J# (u5 :: Int#) (u6 :: Int#) (u7 :: ByteArray#) -> case _#_ cmpInteger# [] [u2, u3, u4, u5, u6, u7] of { _PRIM_ 0# -> _!_ False [] []; (u8 :: Int#) -> _!_ True [] [] }; _NO_DEFLT_ }; _NO_DEFLT_ } _N_ #-}
+ (==) = { _A_ 2 _U_ 11 _N_ _S_ "U(PPP)U(PPP)" {_A_ 4 _U_ 2221 _N_ _N_ _F_ _IF_ARGS_ 0 4 XXXC 4 \ (u0 :: Int#) (u1 :: Int#) (u2 :: ByteArray#) (u3 :: Integer) -> case u3 of { _ALG_ J# (u4 :: Int#) (u5 :: Int#) (u6 :: ByteArray#) -> case _#_ cmpInteger# [] [u0, u1, u2, u4, u5, u6] of { _PRIM_ 0# -> _!_ True [] []; (u7 :: Int#) -> _!_ False [] [] }; _NO_DEFLT_ } _N_} _F_ _IF_ARGS_ 0 2 CC 5 \ (u0 :: Integer) (u1 :: Integer) -> case u0 of { _ALG_ J# (u2 :: Int#) (u3 :: Int#) (u4 :: ByteArray#) -> case u1 of { _ALG_ J# (u5 :: Int#) (u6 :: Int#) (u7 :: ByteArray#) -> case _#_ cmpInteger# [] [u2, u3, u4, u5, u6, u7] of { _PRIM_ 0# -> _!_ True [] []; (u8 :: Int#) -> _!_ False [] [] }; _NO_DEFLT_ }; _NO_DEFLT_ } _N_ },
+ (/=) = { _A_ 2 _U_ 11 _N_ _S_ "U(PPP)U(PPP)" {_A_ 4 _U_ 2221 _N_ _N_ _F_ _IF_ARGS_ 0 4 XXXC 4 \ (u0 :: Int#) (u1 :: Int#) (u2 :: ByteArray#) (u3 :: Integer) -> case u3 of { _ALG_ J# (u4 :: Int#) (u5 :: Int#) (u6 :: ByteArray#) -> case _#_ cmpInteger# [] [u0, u1, u2, u4, u5, u6] of { _PRIM_ 0# -> _!_ False [] []; (u7 :: Int#) -> _!_ True [] [] }; _NO_DEFLT_ } _N_} _F_ _IF_ARGS_ 0 2 CC 5 \ (u0 :: Integer) (u1 :: Integer) -> case u0 of { _ALG_ J# (u2 :: Int#) (u3 :: Int#) (u4 :: ByteArray#) -> case u1 of { _ALG_ J# (u5 :: Int#) (u6 :: Int#) (u7 :: ByteArray#) -> case _#_ cmpInteger# [] [u2, u3, u4, u5, u6, u7] of { _PRIM_ 0# -> _!_ False [] []; (u8 :: Int#) -> _!_ True [] [] }; _NO_DEFLT_ }; _NO_DEFLT_ } _N_ } #-}
instance Integral a => Eq (Ratio a)
{-# GHC_PRAGMA _M_ PreludeRatio {-dfun-} _A_ 1 _U_ 1 _N_ _N_ _N_ _N_ #-}
instance Eq (Ratio Integer)
{-# GHC_PRAGMA _M_ PreludeRatio {-dfun-} _A_ 0 _N_ _N_ _N_ _F_ _IF_ARGS_ 0 0 X 3 _!_ _TUP_2 [(Ratio Integer -> Ratio Integer -> Bool), (Ratio Integer -> Ratio Integer -> Bool)] [_CONSTM_ Eq (==) (Ratio Integer), _CONSTM_ Eq (/=) (Ratio Integer)] _N_
- (==) = _A_ 2 _U_ 11 _N_ _S_ "U(U(PPP)L)U(U(PPP)L)" {_A_ 5 _U_ 22211 _N_ _N_ _F_ _IF_ARGS_ 0 5 XXXCC 9 \ (u0 :: Int#) (u1 :: Int#) (u2 :: ByteArray#) (u3 :: Integer) (u4 :: Ratio Integer) -> case u4 of { _ALG_ (:%) (u5 :: Integer) (u6 :: Integer) -> case u5 of { _ALG_ J# (u7 :: Int#) (u8 :: Int#) (u9 :: ByteArray#) -> case _#_ cmpInteger# [] [u0, u1, u2, u7, u8, u9] of { _PRIM_ 0# -> case u3 of { _ALG_ J# (ua :: Int#) (ub :: Int#) (uc :: ByteArray#) -> case u6 of { _ALG_ J# (ud :: Int#) (ue :: Int#) (uf :: ByteArray#) -> case _#_ cmpInteger# [] [ua, ub, uc, ud, ue, uf] of { _PRIM_ 0# -> _!_ True [] []; (ug :: Int#) -> _!_ False [] [] }; _NO_DEFLT_ }; _NO_DEFLT_ }; (uh :: Int#) -> _!_ False [] [] }; _NO_DEFLT_ }; _NO_DEFLT_ } _N_} _N_ _N_,
- (/=) = _A_ 2 _U_ 11 _N_ _S_ "U(U(PPP)L)U(U(PPP)L)" {_A_ 5 _U_ 22211 _N_ _N_ _F_ _IF_ARGS_ 0 5 XXXCC 9 \ (u0 :: Int#) (u1 :: Int#) (u2 :: ByteArray#) (u3 :: Integer) (u4 :: Ratio Integer) -> case u4 of { _ALG_ (:%) (u5 :: Integer) (u6 :: Integer) -> case u5 of { _ALG_ J# (u7 :: Int#) (u8 :: Int#) (u9 :: ByteArray#) -> case _#_ cmpInteger# [] [u0, u1, u2, u7, u8, u9] of { _PRIM_ 0# -> case u3 of { _ALG_ J# (ua :: Int#) (ub :: Int#) (uc :: ByteArray#) -> case u6 of { _ALG_ J# (ud :: Int#) (ue :: Int#) (uf :: ByteArray#) -> case _#_ cmpInteger# [] [ua, ub, uc, ud, ue, uf] of { _PRIM_ 0# -> _!_ False [] []; (ug :: Int#) -> _!_ True [] [] }; _NO_DEFLT_ }; _NO_DEFLT_ }; (uh :: Int#) -> _!_ True [] [] }; _NO_DEFLT_ }; _NO_DEFLT_ } _N_} _N_ _N_ #-}
+ (==) = { _A_ 2 _U_ 11 _N_ _S_ "U(U(PPP)L)U(U(PPP)L)" {_A_ 5 _U_ 22211 _N_ _N_ _F_ _IF_ARGS_ 0 5 XXXCC 9 \ (u0 :: Int#) (u1 :: Int#) (u2 :: ByteArray#) (u3 :: Integer) (u4 :: Ratio Integer) -> case u4 of { _ALG_ (:%) (u5 :: Integer) (u6 :: Integer) -> case u5 of { _ALG_ J# (u7 :: Int#) (u8 :: Int#) (u9 :: ByteArray#) -> case _#_ cmpInteger# [] [u0, u1, u2, u7, u8, u9] of { _PRIM_ 0# -> case u3 of { _ALG_ J# (ua :: Int#) (ub :: Int#) (uc :: ByteArray#) -> case u6 of { _ALG_ J# (ud :: Int#) (ue :: Int#) (uf :: ByteArray#) -> case _#_ cmpInteger# [] [ua, ub, uc, ud, ue, uf] of { _PRIM_ 0# -> _!_ True [] []; (ug :: Int#) -> _!_ False [] [] }; _NO_DEFLT_ }; _NO_DEFLT_ }; (uh :: Int#) -> _!_ False [] [] }; _NO_DEFLT_ }; _NO_DEFLT_ } _N_} _N_ _N_ },
+ (/=) = { _A_ 2 _U_ 11 _N_ _S_ "U(U(PPP)L)U(U(PPP)L)" {_A_ 5 _U_ 22211 _N_ _N_ _F_ _IF_ARGS_ 0 5 XXXCC 9 \ (u0 :: Int#) (u1 :: Int#) (u2 :: ByteArray#) (u3 :: Integer) (u4 :: Ratio Integer) -> case u4 of { _ALG_ (:%) (u5 :: Integer) (u6 :: Integer) -> case u5 of { _ALG_ J# (u7 :: Int#) (u8 :: Int#) (u9 :: ByteArray#) -> case _#_ cmpInteger# [] [u0, u1, u2, u7, u8, u9] of { _PRIM_ 0# -> case u3 of { _ALG_ J# (ua :: Int#) (ub :: Int#) (uc :: ByteArray#) -> case u6 of { _ALG_ J# (ud :: Int#) (ue :: Int#) (uf :: ByteArray#) -> case _#_ cmpInteger# [] [ua, ub, uc, ud, ue, uf] of { _PRIM_ 0# -> _!_ False [] []; (ug :: Int#) -> _!_ True [] [] }; _NO_DEFLT_ }; _NO_DEFLT_ }; (uh :: Int#) -> _!_ True [] [] }; _NO_DEFLT_ }; _NO_DEFLT_ } _N_} _N_ _N_ } #-}
+instance Eq [(Int, Int)]
+ {-# GHC_PRAGMA _M_ PreludeBuiltin {-dfun-} _A_ 0 _N_ _N_ _N_ _F_ _IF_ARGS_ 0 0 X 3 _!_ _TUP_2 [([(Int, Int)] -> [(Int, Int)] -> Bool), ([(Int, Int)] -> [(Int, Int)] -> Bool)] [_CONSTM_ Eq (==) ([(Int, Int)]), _CONSTM_ Eq (/=) ([(Int, Int)])] _N_
+ (==) = { _A_ 2 _U_ 11 _N_ _S_ "SS" _N_ _N_ },
+ (/=) = { _A_ 2 _U_ 11 _N_ _S_ "SS" _N_ _N_ } #-}
instance Eq a => Eq [a]
{-# GHC_PRAGMA _M_ PreludeBuiltin {-dfun-} _A_ 1 _U_ 1 _N_ _N_ _N_ _N_ #-}
+instance Eq [Bool]
+ {-# GHC_PRAGMA _M_ PreludeBuiltin {-dfun-} _A_ 0 _N_ _N_ _N_ _F_ _IF_ARGS_ 0 0 X 3 _!_ _TUP_2 [([Bool] -> [Bool] -> Bool), ([Bool] -> [Bool] -> Bool)] [_CONSTM_ Eq (==) ([Bool]), _CONSTM_ Eq (/=) ([Bool])] _N_
+ (==) = { _A_ 2 _U_ 11 _N_ _S_ "SS" _N_ _N_ },
+ (/=) = { _A_ 2 _U_ 11 _N_ _S_ "SS" _N_ _N_ } #-}
instance Eq [Char]
{-# GHC_PRAGMA _M_ PreludeBuiltin {-dfun-} _A_ 0 _N_ _N_ _N_ _F_ _IF_ARGS_ 0 0 X 3 _!_ _TUP_2 [([Char] -> [Char] -> Bool), ([Char] -> [Char] -> Bool)] [_CONSTM_ Eq (==) ([Char]), _CONSTM_ Eq (/=) ([Char])] _N_
- (==) = _A_ 2 _U_ 11 _N_ _S_ "SS" _N_ _N_,
- (/=) = _A_ 2 _U_ 11 _N_ _S_ "SS" _N_ _N_ #-}
+ (==) = { _A_ 2 _U_ 11 _N_ _S_ "SS" _N_ _N_ },
+ (/=) = { _A_ 2 _U_ 11 _N_ _S_ "SS" _N_ _N_ } #-}
+instance Eq [Complex Double]
+ {-# GHC_PRAGMA _M_ PreludeBuiltin {-dfun-} _A_ 0 _N_ _N_ _N_ _F_ _IF_ARGS_ 0 0 X 3 _!_ _TUP_2 [([Complex Double] -> [Complex Double] -> Bool), ([Complex Double] -> [Complex Double] -> Bool)] [_CONSTM_ Eq (==) ([Complex Double]), _CONSTM_ Eq (/=) ([Complex Double])] _N_
+ (==) = { _A_ 2 _U_ 11 _N_ _S_ "SS" _N_ _N_ },
+ (/=) = { _A_ 2 _U_ 11 _N_ _S_ "SS" _N_ _N_ } #-}
+instance Eq [Double]
+ {-# GHC_PRAGMA _M_ PreludeBuiltin {-dfun-} _A_ 0 _N_ _N_ _N_ _F_ _IF_ARGS_ 0 0 X 3 _!_ _TUP_2 [([Double] -> [Double] -> Bool), ([Double] -> [Double] -> Bool)] [_CONSTM_ Eq (==) ([Double]), _CONSTM_ Eq (/=) ([Double])] _N_
+ (==) = { _A_ 2 _U_ 11 _N_ _S_ "SS" _N_ _N_ },
+ (/=) = { _A_ 2 _U_ 11 _N_ _S_ "SS" _N_ _N_ } #-}
instance Eq [Int]
{-# GHC_PRAGMA _M_ PreludeBuiltin {-dfun-} _A_ 0 _N_ _N_ _N_ _F_ _IF_ARGS_ 0 0 X 3 _!_ _TUP_2 [([Int] -> [Int] -> Bool), ([Int] -> [Int] -> Bool)] [_CONSTM_ Eq (==) ([Int]), _CONSTM_ Eq (/=) ([Int])] _N_
- (==) = _A_ 2 _U_ 11 _N_ _S_ "SS" _N_ _N_,
- (/=) = _A_ 2 _U_ 11 _N_ _S_ "SS" _N_ _N_ #-}
+ (==) = { _A_ 2 _U_ 11 _N_ _S_ "SS" _N_ _N_ },
+ (/=) = { _A_ 2 _U_ 11 _N_ _S_ "SS" _N_ _N_ } #-}
+instance Eq [Integer]
+ {-# GHC_PRAGMA _M_ PreludeBuiltin {-dfun-} _A_ 0 _N_ _N_ _N_ _F_ _IF_ARGS_ 0 0 X 3 _!_ _TUP_2 [([Integer] -> [Integer] -> Bool), ([Integer] -> [Integer] -> Bool)] [_CONSTM_ Eq (==) ([Integer]), _CONSTM_ Eq (/=) ([Integer])] _N_
+ (==) = { _A_ 2 _U_ 11 _N_ _S_ "SS" _N_ _N_ },
+ (/=) = { _A_ 2 _U_ 11 _N_ _S_ "SS" _N_ _N_ } #-}
+instance Eq [[Char]]
+ {-# GHC_PRAGMA _M_ PreludeBuiltin {-dfun-} _A_ 0 _N_ _N_ _N_ _F_ _IF_ARGS_ 0 0 X 3 _!_ _TUP_2 [([[Char]] -> [[Char]] -> Bool), ([[Char]] -> [[Char]] -> Bool)] [_CONSTM_ Eq (==) ([[Char]]), _CONSTM_ Eq (/=) ([[Char]])] _N_
+ (==) = { _A_ 2 _U_ 11 _N_ _S_ "SS" _N_ _N_ },
+ (/=) = { _A_ 2 _U_ 11 _N_ _S_ "SS" _N_ _N_ } #-}
+instance Eq [[Int]]
+ {-# GHC_PRAGMA _M_ PreludeBuiltin {-dfun-} _A_ 0 _N_ _N_ _N_ _F_ _IF_ARGS_ 0 0 X 3 _!_ _TUP_2 [([[Int]] -> [[Int]] -> Bool), ([[Int]] -> [[Int]] -> Bool)] [_CONSTM_ Eq (==) ([[Int]]), _CONSTM_ Eq (/=) ([[Int]])] _N_
+ (==) = { _A_ 2 _U_ 11 _N_ _S_ "SS" _N_ _N_ },
+ (/=) = { _A_ 2 _U_ 11 _N_ _S_ "SS" _N_ _N_ } #-}
instance Eq _Addr
{-# GHC_PRAGMA _M_ PreludeCore {-dfun-} _A_ 0 _N_ _N_ _N_ _F_ _IF_ARGS_ 0 0 X 3 _!_ _TUP_2 [(_Addr -> _Addr -> Bool), (_Addr -> _Addr -> Bool)] [_CONSTM_ Eq (==) (_Addr), _CONSTM_ Eq (/=) (_Addr)] _N_
- (==) = _A_ 2 _U_ 11 _N_ _S_ "U(P)U(P)" {_A_ 2 _U_ 22 _N_ _N_ _F_ _IF_ARGS_ 0 2 XX 1 \ (u0 :: Addr#) (u1 :: Addr#) -> _#_ eqAddr# [] [u0, u1] _N_} _F_ _IF_ARGS_ 0 2 CC 3 \ (u0 :: _Addr) (u1 :: _Addr) -> case u0 of { _ALG_ A# (u2 :: Addr#) -> case u1 of { _ALG_ A# (u3 :: Addr#) -> _#_ eqAddr# [] [u2, u3]; _NO_DEFLT_ }; _NO_DEFLT_ } _N_,
- (/=) = _A_ 2 _U_ 11 _N_ _S_ "U(P)U(P)" {_A_ 2 _U_ 22 _N_ _N_ _F_ _IF_ARGS_ 0 2 XX 1 \ (u0 :: Addr#) (u1 :: Addr#) -> _#_ neAddr# [] [u0, u1] _N_} _F_ _IF_ARGS_ 0 2 CC 3 \ (u0 :: _Addr) (u1 :: _Addr) -> case u0 of { _ALG_ A# (u2 :: Addr#) -> case u1 of { _ALG_ A# (u3 :: Addr#) -> _#_ neAddr# [] [u2, u3]; _NO_DEFLT_ }; _NO_DEFLT_ } _N_ #-}
+ (==) = { _A_ 2 _U_ 11 _N_ _S_ "U(P)U(P)" {_A_ 2 _U_ 22 _N_ _N_ _F_ _IF_ARGS_ 0 2 XX 1 \ (u0 :: Addr#) (u1 :: Addr#) -> _#_ eqAddr# [] [u0, u1] _N_} _F_ _IF_ARGS_ 0 2 CC 3 \ (u0 :: _Addr) (u1 :: _Addr) -> case u0 of { _ALG_ A# (u2 :: Addr#) -> case u1 of { _ALG_ A# (u3 :: Addr#) -> _#_ eqAddr# [] [u2, u3]; _NO_DEFLT_ }; _NO_DEFLT_ } _N_ },
+ (/=) = { _A_ 2 _U_ 11 _N_ _S_ "U(P)U(P)" {_A_ 2 _U_ 22 _N_ _N_ _F_ _IF_ARGS_ 0 2 XX 1 \ (u0 :: Addr#) (u1 :: Addr#) -> _#_ neAddr# [] [u0, u1] _N_} _F_ _IF_ARGS_ 0 2 CC 3 \ (u0 :: _Addr) (u1 :: _Addr) -> case u0 of { _ALG_ A# (u2 :: Addr#) -> case u1 of { _ALG_ A# (u3 :: Addr#) -> _#_ neAddr# [] [u2, u3]; _NO_DEFLT_ }; _NO_DEFLT_ } _N_ } #-}
instance Eq _PackedString
{-# GHC_PRAGMA _M_ PreludePS {-dfun-} _A_ 0 _N_ _N_ _N_ _F_ _IF_ARGS_ 0 0 X 3 _!_ _TUP_2 [(_PackedString -> _PackedString -> Bool), (_PackedString -> _PackedString -> Bool)] [_CONSTM_ Eq (==) (_PackedString), _CONSTM_ Eq (/=) (_PackedString)] _N_
- (==) = _A_ 2 _U_ 22 _N_ _S_ "SS" _N_ _N_,
- (/=) = _A_ 2 _U_ 22 _N_ _S_ "SS" _N_ _N_ #-}
+ (==) = { _A_ 2 _U_ 22 _N_ _S_ "SS" _N_ _N_ },
+ (/=) = { _A_ 2 _U_ 22 _N_ _S_ "SS" _N_ _N_ } #-}
instance Eq _Word
{-# GHC_PRAGMA _M_ PreludeCore {-dfun-} _A_ 0 _N_ _N_ _N_ _F_ _IF_ARGS_ 0 0 X 3 _!_ _TUP_2 [(_Word -> _Word -> Bool), (_Word -> _Word -> Bool)] [_CONSTM_ Eq (==) (_Word), _CONSTM_ Eq (/=) (_Word)] _N_
- (==) = _A_ 2 _U_ 11 _N_ _S_ "U(P)U(P)" {_A_ 2 _U_ 22 _N_ _N_ _F_ _IF_ARGS_ 0 2 XX 1 \ (u0 :: Word#) (u1 :: Word#) -> _#_ eqWord# [] [u0, u1] _N_} _F_ _IF_ARGS_ 0 2 CC 3 \ (u0 :: _Word) (u1 :: _Word) -> case u0 of { _ALG_ W# (u2 :: Word#) -> case u1 of { _ALG_ W# (u3 :: Word#) -> _#_ eqWord# [] [u2, u3]; _NO_DEFLT_ }; _NO_DEFLT_ } _N_,
- (/=) = _A_ 2 _U_ 11 _N_ _S_ "U(P)U(P)" {_A_ 2 _U_ 22 _N_ _N_ _F_ _IF_ARGS_ 0 2 XX 1 \ (u0 :: Word#) (u1 :: Word#) -> _#_ neWord# [] [u0, u1] _N_} _F_ _IF_ARGS_ 0 2 CC 3 \ (u0 :: _Word) (u1 :: _Word) -> case u0 of { _ALG_ W# (u2 :: Word#) -> case u1 of { _ALG_ W# (u3 :: Word#) -> _#_ neWord# [] [u2, u3]; _NO_DEFLT_ }; _NO_DEFLT_ } _N_ #-}
+ (==) = { _A_ 2 _U_ 11 _N_ _S_ "U(P)U(P)" {_A_ 2 _U_ 22 _N_ _N_ _F_ _IF_ARGS_ 0 2 XX 1 \ (u0 :: Word#) (u1 :: Word#) -> _#_ eqWord# [] [u0, u1] _N_} _F_ _IF_ARGS_ 0 2 CC 3 \ (u0 :: _Word) (u1 :: _Word) -> case u0 of { _ALG_ W# (u2 :: Word#) -> case u1 of { _ALG_ W# (u3 :: Word#) -> _#_ eqWord# [] [u2, u3]; _NO_DEFLT_ }; _NO_DEFLT_ } _N_ },
+ (/=) = { _A_ 2 _U_ 11 _N_ _S_ "U(P)U(P)" {_A_ 2 _U_ 22 _N_ _N_ _F_ _IF_ARGS_ 0 2 XX 1 \ (u0 :: Word#) (u1 :: Word#) -> _#_ neWord# [] [u0, u1] _N_} _F_ _IF_ARGS_ 0 2 CC 3 \ (u0 :: _Word) (u1 :: _Word) -> case u0 of { _ALG_ W# (u2 :: Word#) -> case u1 of { _ALG_ W# (u3 :: Word#) -> _#_ neWord# [] [u2, u3]; _NO_DEFLT_ }; _NO_DEFLT_ } _N_ } #-}
instance RealFloat a => Floating (Complex a)
{-# GHC_PRAGMA _M_ PreludeComplex {-dfun-} _A_ 2 _U_ 22 _N_ _N_ _N_ _N_ #-}
instance Floating (Complex Double)
{-# GHC_PRAGMA _M_ PreludeComplex {-dfun-} _A_ 0 _N_ _N_ _N_ _F_ _IF_ARGS_ 0 0 X 20 _!_ _TUP_19 [{{Fractional (Complex Double)}}, (Complex Double), (Complex Double -> Complex Double), (Complex Double -> Complex Double), (Complex Double -> Complex Double), (Complex Double -> Complex Double -> Complex Double), (Complex Double -> Complex Double -> Complex Double), (Complex Double -> Complex Double), (Complex Double -> Complex Double), (Complex Double -> Complex Double), (Complex Double -> Complex Double), (Complex Double -> Complex Double), (Complex Double -> Complex Double), (Complex Double -> Complex Double), (Complex Double -> Complex Double), (Complex Double -> Complex Double), (Complex Double -> Complex Double), (Complex Double -> Complex Double), (Complex Double -> Complex Double)] [_DFUN_ Fractional (Complex Double), _CONSTM_ Floating pi (Complex Double), _CONSTM_ Floating exp (Complex Double), _CONSTM_ Floating log (Complex Double), _CONSTM_ Floating sqrt (Complex Double), _CONSTM_ Floating (**) (Complex Double), _CONSTM_ Floating logBase (Complex Double), _CONSTM_ Floating sin (Complex Double), _CONSTM_ Floating cos (Complex Double), _CONSTM_ Floating tan (Complex Double), _CONSTM_ Floating asin (Complex Double), _CONSTM_ Floating acos (Complex Double), _CONSTM_ Floating atan (Complex Double), _CONSTM_ Floating sinh (Complex Double), _CONSTM_ Floating cosh (Complex Double), _CONSTM_ Floating tanh (Complex Double), _CONSTM_ Floating asinh (Complex Double), _CONSTM_ Floating acosh (Complex Double), _CONSTM_ Floating atanh (Complex Double)] _N_
- pi = _A_ 0 _N_ _N_ _N_ _N_ _N_,
- exp = _A_ 1 _U_ 1 _N_ _S_ "U(LL)" {_A_ 2 _U_ 12 _N_ _N_ _N_ _N_} _N_ _N_,
- log = _A_ 1 _U_ 2 _N_ _N_ _N_ _N_,
- sqrt = _A_ 1 _U_ 1 _N_ _S_ "U(U(P)L)" {_A_ 2 _U_ 22 _N_ _N_ _N_ _N_} _N_ _N_,
- (**) = _A_ 2 _U_ 21 _N_ _S_ "LU(LL)" {_A_ 3 _U_ 222 _N_ _N_ _N_ _N_} _N_ _N_,
- logBase = _A_ 2 _U_ 22 _N_ _N_ _N_ _N_,
- sin = _A_ 1 _U_ 1 _N_ _S_ "U(LL)" {_A_ 2 _U_ 22 _N_ _N_ _N_ _N_} _N_ _N_,
- cos = _A_ 1 _U_ 1 _N_ _S_ "U(LL)" {_A_ 2 _U_ 22 _N_ _N_ _N_ _N_} _N_ _N_,
- tan = _A_ 1 _U_ 1 _N_ _S_ "U(LL)" {_A_ 2 _U_ 22 _N_ _N_ _N_ _N_} _N_ _N_,
- asin = _A_ 1 _U_ 1 _N_ _S_ "U(LL)" {_A_ 2 _U_ 22 _N_ _N_ _N_ _N_} _N_ _N_,
- acos = _A_ 1 _U_ 1 _N_ _S_ "U(LL)" {_A_ 2 _U_ 22 _N_ _N_ _N_ _N_} _N_ _N_,
- atan = _A_ 1 _U_ 1 _N_ _S_ "U(LL)" {_A_ 2 _U_ 22 _N_ _N_ _N_ _N_} _N_ _N_,
- sinh = _A_ 1 _U_ 1 _N_ _S_ "U(LL)" {_A_ 2 _U_ 22 _N_ _N_ _N_ _N_} _N_ _N_,
- cosh = _A_ 1 _U_ 1 _N_ _S_ "U(LL)" {_A_ 2 _U_ 22 _N_ _N_ _N_ _N_} _N_ _N_,
- tanh = _A_ 1 _U_ 1 _N_ _S_ "U(LL)" {_A_ 2 _U_ 22 _N_ _N_ _N_ _N_} _N_ _N_,
- asinh = _A_ 1 _U_ 1 _N_ _N_ _N_ _N_,
- acosh = _A_ 1 _U_ 1 _N_ _N_ _N_ _N_,
- atanh = _A_ 1 _U_ 1 _N_ _N_ _N_ _N_ #-}
+ pi = { _A_ 0 _N_ _N_ _N_ _F_ _IF_ARGS_ 0 0 X 3 _!_ (:+) [Double] [_CONSTM_ Floating pi (Double), _SPEC_ _ORIG_ PreludeCore __i0 [ (Double) ]] _N_ },
+ exp = { _A_ 1 _U_ 1 _N_ _S_ "U(LL)" {_A_ 2 _U_ 12 _N_ _N_ _N_ _N_} _N_ _N_ },
+ log = { _A_ 1 _U_ 2 _N_ _N_ _N_ _N_ },
+ sqrt = { _A_ 1 _U_ 1 _N_ _S_ "U(U(P)L)" {_A_ 2 _U_ 22 _N_ _N_ _N_ _N_} _N_ _N_ },
+ (**) = { _A_ 2 _U_ 21 _N_ _S_ "LU(LL)" {_A_ 3 _U_ 222 _N_ _N_ _N_ _N_} _N_ _N_ },
+ logBase = { _A_ 2 _U_ 22 _N_ _N_ _N_ _N_ },
+ sin = { _A_ 1 _U_ 1 _N_ _S_ "U(LL)" {_A_ 2 _U_ 22 _N_ _N_ _N_ _N_} _N_ _N_ },
+ cos = { _A_ 1 _U_ 1 _N_ _S_ "U(LL)" {_A_ 2 _U_ 22 _N_ _N_ _N_ _N_} _N_ _N_ },
+ tan = { _A_ 1 _U_ 1 _N_ _S_ "U(LL)" {_A_ 2 _U_ 22 _N_ _N_ _N_ _N_} _N_ _N_ },
+ asin = { _A_ 1 _U_ 1 _N_ _S_ "U(LL)" {_A_ 2 _U_ 22 _N_ _N_ _N_ _N_} _N_ _N_ },
+ acos = { _A_ 1 _U_ 1 _N_ _S_ "U(LL)" {_A_ 2 _U_ 22 _N_ _N_ _N_ _N_} _N_ _N_ },
+ atan = { _A_ 1 _U_ 1 _N_ _S_ "U(LL)" {_A_ 2 _U_ 22 _N_ _N_ _N_ _N_} _N_ _N_ },
+ sinh = { _A_ 1 _U_ 1 _N_ _S_ "U(LL)" {_A_ 2 _U_ 22 _N_ _N_ _N_ _N_} _N_ _N_ },
+ cosh = { _A_ 1 _U_ 1 _N_ _S_ "U(LL)" {_A_ 2 _U_ 22 _N_ _N_ _N_ _N_} _N_ _N_ },
+ tanh = { _A_ 1 _U_ 1 _N_ _S_ "U(LL)" {_A_ 2 _U_ 22 _N_ _N_ _N_ _N_} _N_ _N_ },
+ asinh = { _A_ 1 _U_ 1 _N_ _N_ _N_ _N_ },
+ acosh = { _A_ 1 _U_ 1 _N_ _N_ _N_ _N_ },
+ atanh = { _A_ 1 _U_ 1 _N_ _N_ _N_ _N_ } #-}
instance Floating Double
{-# GHC_PRAGMA _M_ PreludeCore {-dfun-} _A_ 0 _N_ _N_ _N_ _F_ _IF_ARGS_ 0 0 X 20 _!_ _TUP_19 [{{Fractional Double}}, Double, (Double -> Double), (Double -> Double), (Double -> Double), (Double -> Double -> Double), (Double -> Double -> Double), (Double -> Double), (Double -> Double), (Double -> Double), (Double -> Double), (Double -> Double), (Double -> Double), (Double -> Double), (Double -> Double), (Double -> Double), (Double -> Double), (Double -> Double), (Double -> Double)] [_DFUN_ Fractional (Double), _CONSTM_ Floating pi (Double), _CONSTM_ Floating exp (Double), _CONSTM_ Floating log (Double), _CONSTM_ Floating sqrt (Double), _CONSTM_ Floating (**) (Double), _CONSTM_ Floating logBase (Double), _CONSTM_ Floating sin (Double), _CONSTM_ Floating cos (Double), _CONSTM_ Floating tan (Double), _CONSTM_ Floating asin (Double), _CONSTM_ Floating acos (Double), _CONSTM_ Floating atan (Double), _CONSTM_ Floating sinh (Double), _CONSTM_ Floating cosh (Double), _CONSTM_ Floating tanh (Double), _CONSTM_ Floating asinh (Double), _CONSTM_ Floating acosh (Double), _CONSTM_ Floating atanh (Double)] _N_
- pi = _A_ 0 _N_ _N_ _N_ _F_ _IF_ARGS_ 0 0 X 2 _!_ D# [] [3.1415926535897931##] _N_,
- exp = _A_ 1 _U_ 1 _N_ _S_ "U(P)" {_A_ 1 _U_ 2 _N_ _N_ _F_ _IF_ARGS_ 0 1 X 3 \ (u0 :: Double#) -> case _#_ expDouble# [] [u0] of { _PRIM_ (u1 :: Double#) -> _!_ D# [] [u1] } _N_} _F_ _IF_ARGS_ 0 1 C 4 \ (u0 :: Double) -> case u0 of { _ALG_ D# (u1 :: Double#) -> case _#_ expDouble# [] [u1] of { _PRIM_ (u2 :: Double#) -> _!_ D# [] [u2] }; _NO_DEFLT_ } _N_,
- log = _A_ 1 _U_ 1 _N_ _S_ "U(P)" {_A_ 1 _U_ 2 _N_ _N_ _F_ _IF_ARGS_ 0 1 X 3 \ (u0 :: Double#) -> case _#_ logDouble# [] [u0] of { _PRIM_ (u1 :: Double#) -> _!_ D# [] [u1] } _N_} _F_ _IF_ARGS_ 0 1 C 4 \ (u0 :: Double) -> case u0 of { _ALG_ D# (u1 :: Double#) -> case _#_ logDouble# [] [u1] of { _PRIM_ (u2 :: Double#) -> _!_ D# [] [u2] }; _NO_DEFLT_ } _N_,
- sqrt = _A_ 1 _U_ 1 _N_ _S_ "U(P)" {_A_ 1 _U_ 2 _N_ _N_ _F_ _IF_ARGS_ 0 1 X 3 \ (u0 :: Double#) -> case _#_ sqrtDouble# [] [u0] of { _PRIM_ (u1 :: Double#) -> _!_ D# [] [u1] } _N_} _F_ _IF_ARGS_ 0 1 C 4 \ (u0 :: Double) -> case u0 of { _ALG_ D# (u1 :: Double#) -> case _#_ sqrtDouble# [] [u1] of { _PRIM_ (u2 :: Double#) -> _!_ D# [] [u2] }; _NO_DEFLT_ } _N_,
- (**) = _A_ 2 _U_ 11 _N_ _S_ "U(P)U(P)" {_A_ 2 _U_ 22 _N_ _N_ _F_ _IF_ARGS_ 0 2 XX 3 \ (u0 :: Double#) (u1 :: Double#) -> case _#_ powerDouble# [] [u0, u1] of { _PRIM_ (u2 :: Double#) -> _!_ D# [] [u2] } _N_} _F_ _IF_ARGS_ 0 2 CC 5 \ (u0 :: Double) (u1 :: Double) -> case u0 of { _ALG_ D# (u2 :: Double#) -> case u1 of { _ALG_ D# (u3 :: Double#) -> case _#_ powerDouble# [] [u2, u3] of { _PRIM_ (u4 :: Double#) -> _!_ D# [] [u4] }; _NO_DEFLT_ }; _NO_DEFLT_ } _N_,
- logBase = _A_ 2 _U_ 11 _N_ _S_ "U(P)U(P)" {_A_ 2 _U_ 22 _N_ _N_ _F_ _IF_ARGS_ 0 2 XX 5 \ (u0 :: Double#) (u1 :: Double#) -> case _#_ logDouble# [] [u1] of { _PRIM_ (u2 :: Double#) -> case _#_ logDouble# [] [u0] of { _PRIM_ (u3 :: Double#) -> case _#_ divideDouble# [] [u2, u3] of { _PRIM_ (u4 :: Double#) -> _!_ D# [] [u4] } } } _N_} _F_ _IF_ARGS_ 0 2 CC 7 \ (u0 :: Double) (u1 :: Double) -> case u1 of { _ALG_ D# (u2 :: Double#) -> case _#_ logDouble# [] [u2] of { _PRIM_ (u3 :: Double#) -> case u0 of { _ALG_ D# (u4 :: Double#) -> case _#_ logDouble# [] [u4] of { _PRIM_ (u5 :: Double#) -> case _#_ divideDouble# [] [u3, u5] of { _PRIM_ (u6 :: Double#) -> _!_ D# [] [u6] } }; _NO_DEFLT_ } }; _NO_DEFLT_ } _N_,
- sin = _A_ 1 _U_ 1 _N_ _S_ "U(P)" {_A_ 1 _U_ 2 _N_ _N_ _F_ _IF_ARGS_ 0 1 X 3 \ (u0 :: Double#) -> case _#_ sinDouble# [] [u0] of { _PRIM_ (u1 :: Double#) -> _!_ D# [] [u1] } _N_} _F_ _IF_ARGS_ 0 1 C 4 \ (u0 :: Double) -> case u0 of { _ALG_ D# (u1 :: Double#) -> case _#_ sinDouble# [] [u1] of { _PRIM_ (u2 :: Double#) -> _!_ D# [] [u2] }; _NO_DEFLT_ } _N_,
- cos = _A_ 1 _U_ 1 _N_ _S_ "U(P)" {_A_ 1 _U_ 2 _N_ _N_ _F_ _IF_ARGS_ 0 1 X 3 \ (u0 :: Double#) -> case _#_ cosDouble# [] [u0] of { _PRIM_ (u1 :: Double#) -> _!_ D# [] [u1] } _N_} _F_ _IF_ARGS_ 0 1 C 4 \ (u0 :: Double) -> case u0 of { _ALG_ D# (u1 :: Double#) -> case _#_ cosDouble# [] [u1] of { _PRIM_ (u2 :: Double#) -> _!_ D# [] [u2] }; _NO_DEFLT_ } _N_,
- tan = _A_ 1 _U_ 1 _N_ _S_ "U(P)" {_A_ 1 _U_ 2 _N_ _N_ _F_ _IF_ARGS_ 0 1 X 3 \ (u0 :: Double#) -> case _#_ tanDouble# [] [u0] of { _PRIM_ (u1 :: Double#) -> _!_ D# [] [u1] } _N_} _F_ _IF_ARGS_ 0 1 C 4 \ (u0 :: Double) -> case u0 of { _ALG_ D# (u1 :: Double#) -> case _#_ tanDouble# [] [u1] of { _PRIM_ (u2 :: Double#) -> _!_ D# [] [u2] }; _NO_DEFLT_ } _N_,
- asin = _A_ 1 _U_ 1 _N_ _S_ "U(P)" {_A_ 1 _U_ 2 _N_ _N_ _F_ _IF_ARGS_ 0 1 X 3 \ (u0 :: Double#) -> case _#_ asinDouble# [] [u0] of { _PRIM_ (u1 :: Double#) -> _!_ D# [] [u1] } _N_} _F_ _IF_ARGS_ 0 1 C 4 \ (u0 :: Double) -> case u0 of { _ALG_ D# (u1 :: Double#) -> case _#_ asinDouble# [] [u1] of { _PRIM_ (u2 :: Double#) -> _!_ D# [] [u2] }; _NO_DEFLT_ } _N_,
- acos = _A_ 1 _U_ 1 _N_ _S_ "U(P)" {_A_ 1 _U_ 2 _N_ _N_ _F_ _IF_ARGS_ 0 1 X 3 \ (u0 :: Double#) -> case _#_ acosDouble# [] [u0] of { _PRIM_ (u1 :: Double#) -> _!_ D# [] [u1] } _N_} _F_ _IF_ARGS_ 0 1 C 4 \ (u0 :: Double) -> case u0 of { _ALG_ D# (u1 :: Double#) -> case _#_ acosDouble# [] [u1] of { _PRIM_ (u2 :: Double#) -> _!_ D# [] [u2] }; _NO_DEFLT_ } _N_,
- atan = _A_ 1 _U_ 1 _N_ _S_ "U(P)" {_A_ 1 _U_ 2 _N_ _N_ _F_ _IF_ARGS_ 0 1 X 3 \ (u0 :: Double#) -> case _#_ atanDouble# [] [u0] of { _PRIM_ (u1 :: Double#) -> _!_ D# [] [u1] } _N_} _F_ _IF_ARGS_ 0 1 C 4 \ (u0 :: Double) -> case u0 of { _ALG_ D# (u1 :: Double#) -> case _#_ atanDouble# [] [u1] of { _PRIM_ (u2 :: Double#) -> _!_ D# [] [u2] }; _NO_DEFLT_ } _N_,
- sinh = _A_ 1 _U_ 1 _N_ _S_ "U(P)" {_A_ 1 _U_ 2 _N_ _N_ _F_ _IF_ARGS_ 0 1 X 3 \ (u0 :: Double#) -> case _#_ sinhDouble# [] [u0] of { _PRIM_ (u1 :: Double#) -> _!_ D# [] [u1] } _N_} _F_ _IF_ARGS_ 0 1 C 4 \ (u0 :: Double) -> case u0 of { _ALG_ D# (u1 :: Double#) -> case _#_ sinhDouble# [] [u1] of { _PRIM_ (u2 :: Double#) -> _!_ D# [] [u2] }; _NO_DEFLT_ } _N_,
- cosh = _A_ 1 _U_ 1 _N_ _S_ "U(P)" {_A_ 1 _U_ 2 _N_ _N_ _F_ _IF_ARGS_ 0 1 X 3 \ (u0 :: Double#) -> case _#_ coshDouble# [] [u0] of { _PRIM_ (u1 :: Double#) -> _!_ D# [] [u1] } _N_} _F_ _IF_ARGS_ 0 1 C 4 \ (u0 :: Double) -> case u0 of { _ALG_ D# (u1 :: Double#) -> case _#_ coshDouble# [] [u1] of { _PRIM_ (u2 :: Double#) -> _!_ D# [] [u2] }; _NO_DEFLT_ } _N_,
- tanh = _A_ 1 _U_ 1 _N_ _S_ "U(P)" {_A_ 1 _U_ 2 _N_ _N_ _F_ _IF_ARGS_ 0 1 X 3 \ (u0 :: Double#) -> case _#_ tanhDouble# [] [u0] of { _PRIM_ (u1 :: Double#) -> _!_ D# [] [u1] } _N_} _F_ _IF_ARGS_ 0 1 C 4 \ (u0 :: Double) -> case u0 of { _ALG_ D# (u1 :: Double#) -> case _#_ tanhDouble# [] [u1] of { _PRIM_ (u2 :: Double#) -> _!_ D# [] [u2] }; _NO_DEFLT_ } _N_,
- asinh = _A_ 1 _U_ 1 _N_ _S_ "U(P)" {_A_ 1 _U_ 2 _N_ _N_ _N_ _N_} _N_ _N_,
- acosh = _A_ 1 _U_ 1 _N_ _S_ "U(P)" {_A_ 1 _U_ 2 _N_ _N_ _N_ _N_} _N_ _N_,
- atanh = _A_ 1 _U_ 1 _N_ _S_ "U(P)" {_A_ 1 _U_ 2 _N_ _N_ _N_ _N_} _N_ _N_ #-}
+ pi = { _A_ 0 _N_ _N_ _N_ _F_ _IF_ARGS_ 0 0 X 2 _!_ D# [] [3.1415926535897931##] _N_ },
+ exp = { _A_ 1 _U_ 1 _N_ _S_ "U(P)" {_A_ 1 _U_ 2 _N_ _N_ _F_ _IF_ARGS_ 0 1 X 3 \ (u0 :: Double#) -> case _#_ expDouble# [] [u0] of { _PRIM_ (u1 :: Double#) -> _!_ D# [] [u1] } _N_} _F_ _IF_ARGS_ 0 1 C 4 \ (u0 :: Double) -> case u0 of { _ALG_ D# (u1 :: Double#) -> case _#_ expDouble# [] [u1] of { _PRIM_ (u2 :: Double#) -> _!_ D# [] [u2] }; _NO_DEFLT_ } _N_ },
+ log = { _A_ 1 _U_ 1 _N_ _S_ "U(P)" {_A_ 1 _U_ 2 _N_ _N_ _F_ _IF_ARGS_ 0 1 X 3 \ (u0 :: Double#) -> case _#_ logDouble# [] [u0] of { _PRIM_ (u1 :: Double#) -> _!_ D# [] [u1] } _N_} _F_ _IF_ARGS_ 0 1 C 4 \ (u0 :: Double) -> case u0 of { _ALG_ D# (u1 :: Double#) -> case _#_ logDouble# [] [u1] of { _PRIM_ (u2 :: Double#) -> _!_ D# [] [u2] }; _NO_DEFLT_ } _N_ },
+ sqrt = { _A_ 1 _U_ 1 _N_ _S_ "U(P)" {_A_ 1 _U_ 2 _N_ _N_ _F_ _IF_ARGS_ 0 1 X 3 \ (u0 :: Double#) -> case _#_ sqrtDouble# [] [u0] of { _PRIM_ (u1 :: Double#) -> _!_ D# [] [u1] } _N_} _F_ _IF_ARGS_ 0 1 C 4 \ (u0 :: Double) -> case u0 of { _ALG_ D# (u1 :: Double#) -> case _#_ sqrtDouble# [] [u1] of { _PRIM_ (u2 :: Double#) -> _!_ D# [] [u2] }; _NO_DEFLT_ } _N_ },
+ (**) = { _A_ 2 _U_ 11 _N_ _S_ "U(P)U(P)" {_A_ 2 _U_ 22 _N_ _N_ _F_ _IF_ARGS_ 0 2 XX 3 \ (u0 :: Double#) (u1 :: Double#) -> case _#_ powerDouble# [] [u0, u1] of { _PRIM_ (u2 :: Double#) -> _!_ D# [] [u2] } _N_} _F_ _IF_ARGS_ 0 2 CC 5 \ (u0 :: Double) (u1 :: Double) -> case u0 of { _ALG_ D# (u2 :: Double#) -> case u1 of { _ALG_ D# (u3 :: Double#) -> case _#_ powerDouble# [] [u2, u3] of { _PRIM_ (u4 :: Double#) -> _!_ D# [] [u4] }; _NO_DEFLT_ }; _NO_DEFLT_ } _N_ },
+ logBase = { _A_ 2 _U_ 11 _N_ _S_ "U(P)U(P)" {_A_ 2 _U_ 22 _N_ _N_ _F_ _IF_ARGS_ 0 2 XX 5 \ (u0 :: Double#) (u1 :: Double#) -> case _#_ logDouble# [] [u1] of { _PRIM_ (u2 :: Double#) -> case _#_ logDouble# [] [u0] of { _PRIM_ (u3 :: Double#) -> case _#_ divideDouble# [] [u2, u3] of { _PRIM_ (u4 :: Double#) -> _!_ D# [] [u4] } } } _N_} _F_ _IF_ARGS_ 0 2 CC 7 \ (u0 :: Double) (u1 :: Double) -> case u1 of { _ALG_ D# (u2 :: Double#) -> case _#_ logDouble# [] [u2] of { _PRIM_ (u3 :: Double#) -> case u0 of { _ALG_ D# (u4 :: Double#) -> case _#_ logDouble# [] [u4] of { _PRIM_ (u5 :: Double#) -> case _#_ divideDouble# [] [u3, u5] of { _PRIM_ (u6 :: Double#) -> _!_ D# [] [u6] } }; _NO_DEFLT_ } }; _NO_DEFLT_ } _N_ },
+ sin = { _A_ 1 _U_ 1 _N_ _S_ "U(P)" {_A_ 1 _U_ 2 _N_ _N_ _F_ _IF_ARGS_ 0 1 X 3 \ (u0 :: Double#) -> case _#_ sinDouble# [] [u0] of { _PRIM_ (u1 :: Double#) -> _!_ D# [] [u1] } _N_} _F_ _IF_ARGS_ 0 1 C 4 \ (u0 :: Double) -> case u0 of { _ALG_ D# (u1 :: Double#) -> case _#_ sinDouble# [] [u1] of { _PRIM_ (u2 :: Double#) -> _!_ D# [] [u2] }; _NO_DEFLT_ } _N_ },
+ cos = { _A_ 1 _U_ 1 _N_ _S_ "U(P)" {_A_ 1 _U_ 2 _N_ _N_ _F_ _IF_ARGS_ 0 1 X 3 \ (u0 :: Double#) -> case _#_ cosDouble# [] [u0] of { _PRIM_ (u1 :: Double#) -> _!_ D# [] [u1] } _N_} _F_ _IF_ARGS_ 0 1 C 4 \ (u0 :: Double) -> case u0 of { _ALG_ D# (u1 :: Double#) -> case _#_ cosDouble# [] [u1] of { _PRIM_ (u2 :: Double#) -> _!_ D# [] [u2] }; _NO_DEFLT_ } _N_ },
+ tan = { _A_ 1 _U_ 1 _N_ _S_ "U(P)" {_A_ 1 _U_ 2 _N_ _N_ _F_ _IF_ARGS_ 0 1 X 3 \ (u0 :: Double#) -> case _#_ tanDouble# [] [u0] of { _PRIM_ (u1 :: Double#) -> _!_ D# [] [u1] } _N_} _F_ _IF_ARGS_ 0 1 C 4 \ (u0 :: Double) -> case u0 of { _ALG_ D# (u1 :: Double#) -> case _#_ tanDouble# [] [u1] of { _PRIM_ (u2 :: Double#) -> _!_ D# [] [u2] }; _NO_DEFLT_ } _N_ },
+ asin = { _A_ 1 _U_ 1 _N_ _S_ "U(P)" {_A_ 1 _U_ 2 _N_ _N_ _F_ _IF_ARGS_ 0 1 X 3 \ (u0 :: Double#) -> case _#_ asinDouble# [] [u0] of { _PRIM_ (u1 :: Double#) -> _!_ D# [] [u1] } _N_} _F_ _IF_ARGS_ 0 1 C 4 \ (u0 :: Double) -> case u0 of { _ALG_ D# (u1 :: Double#) -> case _#_ asinDouble# [] [u1] of { _PRIM_ (u2 :: Double#) -> _!_ D# [] [u2] }; _NO_DEFLT_ } _N_ },
+ acos = { _A_ 1 _U_ 1 _N_ _S_ "U(P)" {_A_ 1 _U_ 2 _N_ _N_ _F_ _IF_ARGS_ 0 1 X 3 \ (u0 :: Double#) -> case _#_ acosDouble# [] [u0] of { _PRIM_ (u1 :: Double#) -> _!_ D# [] [u1] } _N_} _F_ _IF_ARGS_ 0 1 C 4 \ (u0 :: Double) -> case u0 of { _ALG_ D# (u1 :: Double#) -> case _#_ acosDouble# [] [u1] of { _PRIM_ (u2 :: Double#) -> _!_ D# [] [u2] }; _NO_DEFLT_ } _N_ },
+ atan = { _A_ 1 _U_ 1 _N_ _S_ "U(P)" {_A_ 1 _U_ 2 _N_ _N_ _F_ _IF_ARGS_ 0 1 X 3 \ (u0 :: Double#) -> case _#_ atanDouble# [] [u0] of { _PRIM_ (u1 :: Double#) -> _!_ D# [] [u1] } _N_} _F_ _IF_ARGS_ 0 1 C 4 \ (u0 :: Double) -> case u0 of { _ALG_ D# (u1 :: Double#) -> case _#_ atanDouble# [] [u1] of { _PRIM_ (u2 :: Double#) -> _!_ D# [] [u2] }; _NO_DEFLT_ } _N_ },
+ sinh = { _A_ 1 _U_ 1 _N_ _S_ "U(P)" {_A_ 1 _U_ 2 _N_ _N_ _F_ _IF_ARGS_ 0 1 X 3 \ (u0 :: Double#) -> case _#_ sinhDouble# [] [u0] of { _PRIM_ (u1 :: Double#) -> _!_ D# [] [u1] } _N_} _F_ _IF_ARGS_ 0 1 C 4 \ (u0 :: Double) -> case u0 of { _ALG_ D# (u1 :: Double#) -> case _#_ sinhDouble# [] [u1] of { _PRIM_ (u2 :: Double#) -> _!_ D# [] [u2] }; _NO_DEFLT_ } _N_ },
+ cosh = { _A_ 1 _U_ 1 _N_ _S_ "U(P)" {_A_ 1 _U_ 2 _N_ _N_ _F_ _IF_ARGS_ 0 1 X 3 \ (u0 :: Double#) -> case _#_ coshDouble# [] [u0] of { _PRIM_ (u1 :: Double#) -> _!_ D# [] [u1] } _N_} _F_ _IF_ARGS_ 0 1 C 4 \ (u0 :: Double) -> case u0 of { _ALG_ D# (u1 :: Double#) -> case _#_ coshDouble# [] [u1] of { _PRIM_ (u2 :: Double#) -> _!_ D# [] [u2] }; _NO_DEFLT_ } _N_ },
+ tanh = { _A_ 1 _U_ 1 _N_ _S_ "U(P)" {_A_ 1 _U_ 2 _N_ _N_ _F_ _IF_ARGS_ 0 1 X 3 \ (u0 :: Double#) -> case _#_ tanhDouble# [] [u0] of { _PRIM_ (u1 :: Double#) -> _!_ D# [] [u1] } _N_} _F_ _IF_ARGS_ 0 1 C 4 \ (u0 :: Double) -> case u0 of { _ALG_ D# (u1 :: Double#) -> case _#_ tanhDouble# [] [u1] of { _PRIM_ (u2 :: Double#) -> _!_ D# [] [u2] }; _NO_DEFLT_ } _N_ },
+ asinh = { _A_ 1 _U_ 1 _N_ _S_ "U(P)" {_A_ 1 _U_ 2 _N_ _N_ _N_ _N_} _N_ _N_ },
+ acosh = { _A_ 1 _U_ 1 _N_ _S_ "U(P)" {_A_ 1 _U_ 2 _N_ _N_ _N_ _N_} _N_ _N_ },
+ atanh = { _A_ 1 _U_ 1 _N_ _S_ "U(P)" {_A_ 1 _U_ 2 _N_ _N_ _N_ _N_} _N_ _N_ } #-}
instance Floating Float
{-# GHC_PRAGMA _M_ PreludeCore {-dfun-} _A_ 0 _N_ _N_ _N_ _F_ _IF_ARGS_ 0 0 X 20 _!_ _TUP_19 [{{Fractional Float}}, Float, (Float -> Float), (Float -> Float), (Float -> Float), (Float -> Float -> Float), (Float -> Float -> Float), (Float -> Float), (Float -> Float), (Float -> Float), (Float -> Float), (Float -> Float), (Float -> Float), (Float -> Float), (Float -> Float), (Float -> Float), (Float -> Float), (Float -> Float), (Float -> Float)] [_DFUN_ Fractional (Float), _CONSTM_ Floating pi (Float), _CONSTM_ Floating exp (Float), _CONSTM_ Floating log (Float), _CONSTM_ Floating sqrt (Float), _CONSTM_ Floating (**) (Float), _CONSTM_ Floating logBase (Float), _CONSTM_ Floating sin (Float), _CONSTM_ Floating cos (Float), _CONSTM_ Floating tan (Float), _CONSTM_ Floating asin (Float), _CONSTM_ Floating acos (Float), _CONSTM_ Floating atan (Float), _CONSTM_ Floating sinh (Float), _CONSTM_ Floating cosh (Float), _CONSTM_ Floating tanh (Float), _CONSTM_ Floating asinh (Float), _CONSTM_ Floating acosh (Float), _CONSTM_ Floating atanh (Float)] _N_
- pi = _A_ 0 _N_ _N_ _N_ _F_ _IF_ARGS_ 0 0 X 2 _!_ F# [] [3.1415926535897931#] _N_,
- exp = _A_ 1 _U_ 1 _N_ _S_ "U(P)" {_A_ 1 _U_ 2 _N_ _N_ _F_ _IF_ARGS_ 0 1 X 3 \ (u0 :: Float#) -> case _#_ expFloat# [] [u0] of { _PRIM_ (u1 :: Float#) -> _!_ F# [] [u1] } _N_} _F_ _IF_ARGS_ 0 1 C 4 \ (u0 :: Float) -> case u0 of { _ALG_ F# (u1 :: Float#) -> case _#_ expFloat# [] [u1] of { _PRIM_ (u2 :: Float#) -> _!_ F# [] [u2] }; _NO_DEFLT_ } _N_,
- log = _A_ 1 _U_ 1 _N_ _S_ "U(P)" {_A_ 1 _U_ 2 _N_ _N_ _F_ _IF_ARGS_ 0 1 X 3 \ (u0 :: Float#) -> case _#_ logFloat# [] [u0] of { _PRIM_ (u1 :: Float#) -> _!_ F# [] [u1] } _N_} _F_ _IF_ARGS_ 0 1 C 4 \ (u0 :: Float) -> case u0 of { _ALG_ F# (u1 :: Float#) -> case _#_ logFloat# [] [u1] of { _PRIM_ (u2 :: Float#) -> _!_ F# [] [u2] }; _NO_DEFLT_ } _N_,
- sqrt = _A_ 1 _U_ 1 _N_ _S_ "U(P)" {_A_ 1 _U_ 2 _N_ _N_ _F_ _IF_ARGS_ 0 1 X 3 \ (u0 :: Float#) -> case _#_ sqrtFloat# [] [u0] of { _PRIM_ (u1 :: Float#) -> _!_ F# [] [u1] } _N_} _F_ _IF_ARGS_ 0 1 C 4 \ (u0 :: Float) -> case u0 of { _ALG_ F# (u1 :: Float#) -> case _#_ sqrtFloat# [] [u1] of { _PRIM_ (u2 :: Float#) -> _!_ F# [] [u2] }; _NO_DEFLT_ } _N_,
- (**) = _A_ 2 _U_ 11 _N_ _S_ "U(P)U(P)" {_A_ 2 _U_ 22 _N_ _N_ _F_ _IF_ARGS_ 0 2 XX 3 \ (u0 :: Float#) (u1 :: Float#) -> case _#_ powerFloat# [] [u0, u1] of { _PRIM_ (u2 :: Float#) -> _!_ F# [] [u2] } _N_} _F_ _IF_ARGS_ 0 2 CC 5 \ (u0 :: Float) (u1 :: Float) -> case u0 of { _ALG_ F# (u2 :: Float#) -> case u1 of { _ALG_ F# (u3 :: Float#) -> case _#_ powerFloat# [] [u2, u3] of { _PRIM_ (u4 :: Float#) -> _!_ F# [] [u4] }; _NO_DEFLT_ }; _NO_DEFLT_ } _N_,
- logBase = _A_ 2 _U_ 22 _N_ _N_ _N_ _N_,
- sin = _A_ 1 _U_ 1 _N_ _S_ "U(P)" {_A_ 1 _U_ 2 _N_ _N_ _F_ _IF_ARGS_ 0 1 X 3 \ (u0 :: Float#) -> case _#_ sinFloat# [] [u0] of { _PRIM_ (u1 :: Float#) -> _!_ F# [] [u1] } _N_} _F_ _IF_ARGS_ 0 1 C 4 \ (u0 :: Float) -> case u0 of { _ALG_ F# (u1 :: Float#) -> case _#_ sinFloat# [] [u1] of { _PRIM_ (u2 :: Float#) -> _!_ F# [] [u2] }; _NO_DEFLT_ } _N_,
- cos = _A_ 1 _U_ 1 _N_ _S_ "U(P)" {_A_ 1 _U_ 2 _N_ _N_ _F_ _IF_ARGS_ 0 1 X 3 \ (u0 :: Float#) -> case _#_ cosFloat# [] [u0] of { _PRIM_ (u1 :: Float#) -> _!_ F# [] [u1] } _N_} _F_ _IF_ARGS_ 0 1 C 4 \ (u0 :: Float) -> case u0 of { _ALG_ F# (u1 :: Float#) -> case _#_ cosFloat# [] [u1] of { _PRIM_ (u2 :: Float#) -> _!_ F# [] [u2] }; _NO_DEFLT_ } _N_,
- tan = _A_ 1 _U_ 1 _N_ _S_ "U(P)" {_A_ 1 _U_ 2 _N_ _N_ _F_ _IF_ARGS_ 0 1 X 3 \ (u0 :: Float#) -> case _#_ tanFloat# [] [u0] of { _PRIM_ (u1 :: Float#) -> _!_ F# [] [u1] } _N_} _F_ _IF_ARGS_ 0 1 C 4 \ (u0 :: Float) -> case u0 of { _ALG_ F# (u1 :: Float#) -> case _#_ tanFloat# [] [u1] of { _PRIM_ (u2 :: Float#) -> _!_ F# [] [u2] }; _NO_DEFLT_ } _N_,
- asin = _A_ 1 _U_ 1 _N_ _S_ "U(P)" {_A_ 1 _U_ 2 _N_ _N_ _F_ _IF_ARGS_ 0 1 X 3 \ (u0 :: Float#) -> case _#_ asinFloat# [] [u0] of { _PRIM_ (u1 :: Float#) -> _!_ F# [] [u1] } _N_} _F_ _IF_ARGS_ 0 1 C 4 \ (u0 :: Float) -> case u0 of { _ALG_ F# (u1 :: Float#) -> case _#_ asinFloat# [] [u1] of { _PRIM_ (u2 :: Float#) -> _!_ F# [] [u2] }; _NO_DEFLT_ } _N_,
- acos = _A_ 1 _U_ 1 _N_ _S_ "U(P)" {_A_ 1 _U_ 2 _N_ _N_ _F_ _IF_ARGS_ 0 1 X 3 \ (u0 :: Float#) -> case _#_ acosFloat# [] [u0] of { _PRIM_ (u1 :: Float#) -> _!_ F# [] [u1] } _N_} _F_ _IF_ARGS_ 0 1 C 4 \ (u0 :: Float) -> case u0 of { _ALG_ F# (u1 :: Float#) -> case _#_ acosFloat# [] [u1] of { _PRIM_ (u2 :: Float#) -> _!_ F# [] [u2] }; _NO_DEFLT_ } _N_,
- atan = _A_ 1 _U_ 1 _N_ _S_ "U(P)" {_A_ 1 _U_ 2 _N_ _N_ _F_ _IF_ARGS_ 0 1 X 3 \ (u0 :: Float#) -> case _#_ atanFloat# [] [u0] of { _PRIM_ (u1 :: Float#) -> _!_ F# [] [u1] } _N_} _F_ _IF_ARGS_ 0 1 C 4 \ (u0 :: Float) -> case u0 of { _ALG_ F# (u1 :: Float#) -> case _#_ atanFloat# [] [u1] of { _PRIM_ (u2 :: Float#) -> _!_ F# [] [u2] }; _NO_DEFLT_ } _N_,
- sinh = _A_ 1 _U_ 1 _N_ _S_ "U(P)" {_A_ 1 _U_ 2 _N_ _N_ _F_ _IF_ARGS_ 0 1 X 3 \ (u0 :: Float#) -> case _#_ sinhFloat# [] [u0] of { _PRIM_ (u1 :: Float#) -> _!_ F# [] [u1] } _N_} _F_ _IF_ARGS_ 0 1 C 4 \ (u0 :: Float) -> case u0 of { _ALG_ F# (u1 :: Float#) -> case _#_ sinhFloat# [] [u1] of { _PRIM_ (u2 :: Float#) -> _!_ F# [] [u2] }; _NO_DEFLT_ } _N_,
- cosh = _A_ 1 _U_ 1 _N_ _S_ "U(P)" {_A_ 1 _U_ 2 _N_ _N_ _F_ _IF_ARGS_ 0 1 X 3 \ (u0 :: Float#) -> case _#_ coshFloat# [] [u0] of { _PRIM_ (u1 :: Float#) -> _!_ F# [] [u1] } _N_} _F_ _IF_ARGS_ 0 1 C 4 \ (u0 :: Float) -> case u0 of { _ALG_ F# (u1 :: Float#) -> case _#_ coshFloat# [] [u1] of { _PRIM_ (u2 :: Float#) -> _!_ F# [] [u2] }; _NO_DEFLT_ } _N_,
- tanh = _A_ 1 _U_ 1 _N_ _S_ "U(P)" {_A_ 1 _U_ 2 _N_ _N_ _F_ _IF_ARGS_ 0 1 X 3 \ (u0 :: Float#) -> case _#_ tanhFloat# [] [u0] of { _PRIM_ (u1 :: Float#) -> _!_ F# [] [u1] } _N_} _F_ _IF_ARGS_ 0 1 C 4 \ (u0 :: Float) -> case u0 of { _ALG_ F# (u1 :: Float#) -> case _#_ tanhFloat# [] [u1] of { _PRIM_ (u2 :: Float#) -> _!_ F# [] [u2] }; _NO_DEFLT_ } _N_,
- asinh = _A_ 1 _U_ 1 _N_ _S_ "U(P)" {_A_ 1 _U_ 2 _N_ _N_ _N_ _N_} _N_ _N_,
- acosh = _A_ 1 _U_ 1 _N_ _S_ "U(P)" {_A_ 1 _U_ 2 _N_ _N_ _N_ _N_} _N_ _N_,
- atanh = _A_ 1 _U_ 1 _N_ _S_ "U(P)" {_A_ 1 _U_ 2 _N_ _N_ _N_ _N_} _N_ _N_ #-}
+ pi = { _A_ 0 _N_ _N_ _N_ _F_ _IF_ARGS_ 0 0 X 2 _!_ F# [] [3.1415926535897931#] _N_ },
+ exp = { _A_ 1 _U_ 1 _N_ _S_ "U(P)" {_A_ 1 _U_ 2 _N_ _N_ _F_ _IF_ARGS_ 0 1 X 3 \ (u0 :: Float#) -> case _#_ expFloat# [] [u0] of { _PRIM_ (u1 :: Float#) -> _!_ F# [] [u1] } _N_} _F_ _IF_ARGS_ 0 1 C 4 \ (u0 :: Float) -> case u0 of { _ALG_ F# (u1 :: Float#) -> case _#_ expFloat# [] [u1] of { _PRIM_ (u2 :: Float#) -> _!_ F# [] [u2] }; _NO_DEFLT_ } _N_ },
+ log = { _A_ 1 _U_ 1 _N_ _S_ "U(P)" {_A_ 1 _U_ 2 _N_ _N_ _F_ _IF_ARGS_ 0 1 X 3 \ (u0 :: Float#) -> case _#_ logFloat# [] [u0] of { _PRIM_ (u1 :: Float#) -> _!_ F# [] [u1] } _N_} _F_ _IF_ARGS_ 0 1 C 4 \ (u0 :: Float) -> case u0 of { _ALG_ F# (u1 :: Float#) -> case _#_ logFloat# [] [u1] of { _PRIM_ (u2 :: Float#) -> _!_ F# [] [u2] }; _NO_DEFLT_ } _N_ },
+ sqrt = { _A_ 1 _U_ 1 _N_ _S_ "U(P)" {_A_ 1 _U_ 2 _N_ _N_ _F_ _IF_ARGS_ 0 1 X 3 \ (u0 :: Float#) -> case _#_ sqrtFloat# [] [u0] of { _PRIM_ (u1 :: Float#) -> _!_ F# [] [u1] } _N_} _F_ _IF_ARGS_ 0 1 C 4 \ (u0 :: Float) -> case u0 of { _ALG_ F# (u1 :: Float#) -> case _#_ sqrtFloat# [] [u1] of { _PRIM_ (u2 :: Float#) -> _!_ F# [] [u2] }; _NO_DEFLT_ } _N_ },
+ (**) = { _A_ 2 _U_ 11 _N_ _S_ "U(P)U(P)" {_A_ 2 _U_ 22 _N_ _N_ _F_ _IF_ARGS_ 0 2 XX 3 \ (u0 :: Float#) (u1 :: Float#) -> case _#_ powerFloat# [] [u0, u1] of { _PRIM_ (u2 :: Float#) -> _!_ F# [] [u2] } _N_} _F_ _IF_ARGS_ 0 2 CC 5 \ (u0 :: Float) (u1 :: Float) -> case u0 of { _ALG_ F# (u2 :: Float#) -> case u1 of { _ALG_ F# (u3 :: Float#) -> case _#_ powerFloat# [] [u2, u3] of { _PRIM_ (u4 :: Float#) -> _!_ F# [] [u4] }; _NO_DEFLT_ }; _NO_DEFLT_ } _N_ },
+ logBase = { _A_ 2 _U_ 11 _N_ _S_ "U(P)U(P)" {_A_ 2 _U_ 22 _N_ _N_ _F_ _IF_ARGS_ 0 2 XX 5 \ (u0 :: Float#) (u1 :: Float#) -> case _#_ logFloat# [] [u1] of { _PRIM_ (u2 :: Float#) -> case _#_ logFloat# [] [u0] of { _PRIM_ (u3 :: Float#) -> case _#_ divideFloat# [] [u2, u3] of { _PRIM_ (u4 :: Float#) -> _!_ F# [] [u4] } } } _N_} _F_ _IF_ARGS_ 0 2 CC 7 \ (u0 :: Float) (u1 :: Float) -> case u1 of { _ALG_ F# (u2 :: Float#) -> case _#_ logFloat# [] [u2] of { _PRIM_ (u3 :: Float#) -> case u0 of { _ALG_ F# (u4 :: Float#) -> case _#_ logFloat# [] [u4] of { _PRIM_ (u5 :: Float#) -> case _#_ divideFloat# [] [u3, u5] of { _PRIM_ (u6 :: Float#) -> _!_ F# [] [u6] } }; _NO_DEFLT_ } }; _NO_DEFLT_ } _N_ },
+ sin = { _A_ 1 _U_ 1 _N_ _S_ "U(P)" {_A_ 1 _U_ 2 _N_ _N_ _F_ _IF_ARGS_ 0 1 X 3 \ (u0 :: Float#) -> case _#_ sinFloat# [] [u0] of { _PRIM_ (u1 :: Float#) -> _!_ F# [] [u1] } _N_} _F_ _IF_ARGS_ 0 1 C 4 \ (u0 :: Float) -> case u0 of { _ALG_ F# (u1 :: Float#) -> case _#_ sinFloat# [] [u1] of { _PRIM_ (u2 :: Float#) -> _!_ F# [] [u2] }; _NO_DEFLT_ } _N_ },
+ cos = { _A_ 1 _U_ 1 _N_ _S_ "U(P)" {_A_ 1 _U_ 2 _N_ _N_ _F_ _IF_ARGS_ 0 1 X 3 \ (u0 :: Float#) -> case _#_ cosFloat# [] [u0] of { _PRIM_ (u1 :: Float#) -> _!_ F# [] [u1] } _N_} _F_ _IF_ARGS_ 0 1 C 4 \ (u0 :: Float) -> case u0 of { _ALG_ F# (u1 :: Float#) -> case _#_ cosFloat# [] [u1] of { _PRIM_ (u2 :: Float#) -> _!_ F# [] [u2] }; _NO_DEFLT_ } _N_ },
+ tan = { _A_ 1 _U_ 1 _N_ _S_ "U(P)" {_A_ 1 _U_ 2 _N_ _N_ _F_ _IF_ARGS_ 0 1 X 3 \ (u0 :: Float#) -> case _#_ tanFloat# [] [u0] of { _PRIM_ (u1 :: Float#) -> _!_ F# [] [u1] } _N_} _F_ _IF_ARGS_ 0 1 C 4 \ (u0 :: Float) -> case u0 of { _ALG_ F# (u1 :: Float#) -> case _#_ tanFloat# [] [u1] of { _PRIM_ (u2 :: Float#) -> _!_ F# [] [u2] }; _NO_DEFLT_ } _N_ },
+ asin = { _A_ 1 _U_ 1 _N_ _S_ "U(P)" {_A_ 1 _U_ 2 _N_ _N_ _F_ _IF_ARGS_ 0 1 X 3 \ (u0 :: Float#) -> case _#_ asinFloat# [] [u0] of { _PRIM_ (u1 :: Float#) -> _!_ F# [] [u1] } _N_} _F_ _IF_ARGS_ 0 1 C 4 \ (u0 :: Float) -> case u0 of { _ALG_ F# (u1 :: Float#) -> case _#_ asinFloat# [] [u1] of { _PRIM_ (u2 :: Float#) -> _!_ F# [] [u2] }; _NO_DEFLT_ } _N_ },
+ acos = { _A_ 1 _U_ 1 _N_ _S_ "U(P)" {_A_ 1 _U_ 2 _N_ _N_ _F_ _IF_ARGS_ 0 1 X 3 \ (u0 :: Float#) -> case _#_ acosFloat# [] [u0] of { _PRIM_ (u1 :: Float#) -> _!_ F# [] [u1] } _N_} _F_ _IF_ARGS_ 0 1 C 4 \ (u0 :: Float) -> case u0 of { _ALG_ F# (u1 :: Float#) -> case _#_ acosFloat# [] [u1] of { _PRIM_ (u2 :: Float#) -> _!_ F# [] [u2] }; _NO_DEFLT_ } _N_ },
+ atan = { _A_ 1 _U_ 1 _N_ _S_ "U(P)" {_A_ 1 _U_ 2 _N_ _N_ _F_ _IF_ARGS_ 0 1 X 3 \ (u0 :: Float#) -> case _#_ atanFloat# [] [u0] of { _PRIM_ (u1 :: Float#) -> _!_ F# [] [u1] } _N_} _F_ _IF_ARGS_ 0 1 C 4 \ (u0 :: Float) -> case u0 of { _ALG_ F# (u1 :: Float#) -> case _#_ atanFloat# [] [u1] of { _PRIM_ (u2 :: Float#) -> _!_ F# [] [u2] }; _NO_DEFLT_ } _N_ },
+ sinh = { _A_ 1 _U_ 1 _N_ _S_ "U(P)" {_A_ 1 _U_ 2 _N_ _N_ _F_ _IF_ARGS_ 0 1 X 3 \ (u0 :: Float#) -> case _#_ sinhFloat# [] [u0] of { _PRIM_ (u1 :: Float#) -> _!_ F# [] [u1] } _N_} _F_ _IF_ARGS_ 0 1 C 4 \ (u0 :: Float) -> case u0 of { _ALG_ F# (u1 :: Float#) -> case _#_ sinhFloat# [] [u1] of { _PRIM_ (u2 :: Float#) -> _!_ F# [] [u2] }; _NO_DEFLT_ } _N_ },
+ cosh = { _A_ 1 _U_ 1 _N_ _S_ "U(P)" {_A_ 1 _U_ 2 _N_ _N_ _F_ _IF_ARGS_ 0 1 X 3 \ (u0 :: Float#) -> case _#_ coshFloat# [] [u0] of { _PRIM_ (u1 :: Float#) -> _!_ F# [] [u1] } _N_} _F_ _IF_ARGS_ 0 1 C 4 \ (u0 :: Float) -> case u0 of { _ALG_ F# (u1 :: Float#) -> case _#_ coshFloat# [] [u1] of { _PRIM_ (u2 :: Float#) -> _!_ F# [] [u2] }; _NO_DEFLT_ } _N_ },
+ tanh = { _A_ 1 _U_ 1 _N_ _S_ "U(P)" {_A_ 1 _U_ 2 _N_ _N_ _F_ _IF_ARGS_ 0 1 X 3 \ (u0 :: Float#) -> case _#_ tanhFloat# [] [u0] of { _PRIM_ (u1 :: Float#) -> _!_ F# [] [u1] } _N_} _F_ _IF_ARGS_ 0 1 C 4 \ (u0 :: Float) -> case u0 of { _ALG_ F# (u1 :: Float#) -> case _#_ tanhFloat# [] [u1] of { _PRIM_ (u2 :: Float#) -> _!_ F# [] [u2] }; _NO_DEFLT_ } _N_ },
+ asinh = { _A_ 1 _U_ 1 _N_ _S_ "U(P)" {_A_ 1 _U_ 2 _N_ _N_ _N_ _N_} _N_ _N_ },
+ acosh = { _A_ 1 _U_ 1 _N_ _S_ "U(P)" {_A_ 1 _U_ 2 _N_ _N_ _N_ _N_} _N_ _N_ },
+ atanh = { _A_ 1 _U_ 1 _N_ _S_ "U(P)" {_A_ 1 _U_ 2 _N_ _N_ _N_ _N_} _N_ _N_ } #-}
instance RealFloat a => Fractional (Complex a)
{-# GHC_PRAGMA _M_ PreludeComplex {-dfun-} _A_ 2 _U_ 22 _N_ _N_ _N_ _N_ #-}
instance Fractional (Complex Double)
{-# GHC_PRAGMA _M_ PreludeComplex {-dfun-} _A_ 0 _N_ _N_ _N_ _F_ _IF_ARGS_ 0 0 X 5 _!_ _TUP_4 [{{Num (Complex Double)}}, (Complex Double -> Complex Double -> Complex Double), (Complex Double -> Complex Double), (Ratio Integer -> Complex Double)] [_DFUN_ Num (Complex Double), _CONSTM_ Fractional (/) (Complex Double), _CONSTM_ Fractional recip (Complex Double), _CONSTM_ Fractional fromRational (Complex Double)] _N_
- (/) = _A_ 2 _U_ 11 _N_ _S_ "U(LL)U(LL)" {_A_ 4 _U_ 2222 _N_ _N_ _N_ _N_} _N_ _N_,
- recip = _A_ 1 _U_ 1 _N_ _S_ "U(LL)" {_A_ 2 _U_ 22 _N_ _N_ _N_ _N_} _N_ _N_,
- fromRational = _A_ 1 _U_ 2 _N_ _N_ _N_ _N_ #-}
+ (/) = { _A_ 2 _U_ 11 _N_ _S_ "U(LL)U(LL)" {_A_ 4 _U_ 2222 _N_ _N_ _N_ _N_} _N_ _N_ },
+ recip = { _A_ 1 _U_ 1 _N_ _S_ "U(LL)" {_A_ 2 _U_ 22 _N_ _N_ _N_ _N_} _F_ _IF_ARGS_ 0 1 X 3 \ (u0 :: Complex Double) -> _APP_ _CONSTM_ Fractional (/) (Complex Double) [ _SPEC_ _ORIG_ PreludeCore __i1 [ (Complex Double) ], u0 ] _N_ },
+ fromRational = { _A_ 1 _U_ 1 _N_ _N_ _N_ _N_ } #-}
instance Fractional Double
{-# GHC_PRAGMA _M_ PreludeCore {-dfun-} _A_ 0 _N_ _N_ _N_ _F_ _IF_ARGS_ 0 0 X 5 _!_ _TUP_4 [{{Num Double}}, (Double -> Double -> Double), (Double -> Double), (Ratio Integer -> Double)] [_DFUN_ Num (Double), _CONSTM_ Fractional (/) (Double), _CONSTM_ Fractional recip (Double), _CONSTM_ Fractional fromRational (Double)] _N_
- (/) = _A_ 2 _U_ 11 _N_ _S_ "U(P)U(P)" {_A_ 2 _U_ 22 _N_ _N_ _F_ _IF_ARGS_ 0 2 XX 3 \ (u0 :: Double#) (u1 :: Double#) -> case _#_ divideDouble# [] [u0, u1] of { _PRIM_ (u2 :: Double#) -> _!_ D# [] [u2] } _N_} _F_ _IF_ARGS_ 0 2 CC 5 \ (u0 :: Double) (u1 :: Double) -> case u0 of { _ALG_ D# (u2 :: Double#) -> case u1 of { _ALG_ D# (u3 :: Double#) -> case _#_ divideDouble# [] [u2, u3] of { _PRIM_ (u4 :: Double#) -> _!_ D# [] [u4] }; _NO_DEFLT_ }; _NO_DEFLT_ } _N_,
- recip = _A_ 1 _U_ 1 _N_ _S_ "U(P)" {_A_ 1 _U_ 2 _N_ _N_ _F_ _IF_ARGS_ 0 1 X 3 \ (u0 :: Double#) -> case _#_ divideDouble# [] [1.0000000000000000##, u0] of { _PRIM_ (u1 :: Double#) -> _!_ D# [] [u1] } _N_} _F_ _IF_ARGS_ 0 1 C 4 \ (u0 :: Double) -> case u0 of { _ALG_ D# (u1 :: Double#) -> case _#_ divideDouble# [] [1.0000000000000000##, u1] of { _PRIM_ (u2 :: Double#) -> _!_ D# [] [u2] }; _NO_DEFLT_ } _N_,
- fromRational = _A_ 0 _U_ 2 _N_ _N_ _N_ _N_ #-}
+ (/) = { _A_ 2 _U_ 11 _N_ _S_ "U(P)U(P)" {_A_ 2 _U_ 22 _N_ _N_ _F_ _IF_ARGS_ 0 2 XX 3 \ (u0 :: Double#) (u1 :: Double#) -> case _#_ divideDouble# [] [u0, u1] of { _PRIM_ (u2 :: Double#) -> _!_ D# [] [u2] } _N_} _F_ _IF_ARGS_ 0 2 CC 5 \ (u0 :: Double) (u1 :: Double) -> case u0 of { _ALG_ D# (u2 :: Double#) -> case u1 of { _ALG_ D# (u3 :: Double#) -> case _#_ divideDouble# [] [u2, u3] of { _PRIM_ (u4 :: Double#) -> _!_ D# [] [u4] }; _NO_DEFLT_ }; _NO_DEFLT_ } _N_ },
+ recip = { _A_ 1 _U_ 1 _N_ _S_ "U(P)" {_A_ 1 _U_ 2 _N_ _N_ _F_ _IF_ARGS_ 0 1 X 3 \ (u0 :: Double#) -> case _#_ divideDouble# [] [1.0000000000000000##, u0] of { _PRIM_ (u1 :: Double#) -> _!_ D# [] [u1] } _N_} _F_ _IF_ARGS_ 0 1 C 4 \ (u0 :: Double) -> case u0 of { _ALG_ D# (u1 :: Double#) -> case _#_ divideDouble# [] [1.0000000000000000##, u1] of { _PRIM_ (u2 :: Double#) -> _!_ D# [] [u2] }; _NO_DEFLT_ } _N_ },
+ fromRational = { _A_ 1 _U_ 1 _N_ _S_ "U(U(PPP)U(PPP))" {_A_ 4 _U_ 2222 _N_ _N_ _N_ _N_} _N_ _N_ } #-}
instance Fractional Float
{-# GHC_PRAGMA _M_ PreludeCore {-dfun-} _A_ 0 _N_ _N_ _N_ _F_ _IF_ARGS_ 0 0 X 5 _!_ _TUP_4 [{{Num Float}}, (Float -> Float -> Float), (Float -> Float), (Ratio Integer -> Float)] [_DFUN_ Num (Float), _CONSTM_ Fractional (/) (Float), _CONSTM_ Fractional recip (Float), _CONSTM_ Fractional fromRational (Float)] _N_
- (/) = _A_ 2 _U_ 11 _N_ _S_ "U(P)U(P)" {_A_ 2 _U_ 22 _N_ _N_ _F_ _IF_ARGS_ 0 2 XX 3 \ (u0 :: Float#) (u1 :: Float#) -> case _#_ divideFloat# [] [u0, u1] of { _PRIM_ (u2 :: Float#) -> _!_ F# [] [u2] } _N_} _F_ _IF_ARGS_ 0 2 CC 5 \ (u0 :: Float) (u1 :: Float) -> case u0 of { _ALG_ F# (u2 :: Float#) -> case u1 of { _ALG_ F# (u3 :: Float#) -> case _#_ divideFloat# [] [u2, u3] of { _PRIM_ (u4 :: Float#) -> _!_ F# [] [u4] }; _NO_DEFLT_ }; _NO_DEFLT_ } _N_,
- recip = _A_ 0 _U_ 2 _N_ _N_ _N_ _N_,
- fromRational = _A_ 0 _U_ 2 _N_ _N_ _N_ _N_ #-}
+ (/) = { _A_ 2 _U_ 11 _N_ _S_ "U(P)U(P)" {_A_ 2 _U_ 22 _N_ _N_ _F_ _IF_ARGS_ 0 2 XX 3 \ (u0 :: Float#) (u1 :: Float#) -> case _#_ divideFloat# [] [u0, u1] of { _PRIM_ (u2 :: Float#) -> _!_ F# [] [u2] } _N_} _F_ _IF_ARGS_ 0 2 CC 5 \ (u0 :: Float) (u1 :: Float) -> case u0 of { _ALG_ F# (u2 :: Float#) -> case u1 of { _ALG_ F# (u3 :: Float#) -> case _#_ divideFloat# [] [u2, u3] of { _PRIM_ (u4 :: Float#) -> _!_ F# [] [u4] }; _NO_DEFLT_ }; _NO_DEFLT_ } _N_ },
+ recip = { _A_ 1 _U_ 1 _N_ _S_ "U(P)" {_A_ 1 _U_ 2 _N_ _N_ _F_ _IF_ARGS_ 0 1 X 3 \ (u0 :: Float#) -> case _#_ divideFloat# [] [1.0000000000000000#, u0] of { _PRIM_ (u1 :: Float#) -> _!_ F# [] [u1] } _N_} _F_ _IF_ARGS_ 0 1 C 4 \ (u0 :: Float) -> case u0 of { _ALG_ F# (u1 :: Float#) -> case _#_ divideFloat# [] [1.0000000000000000#, u1] of { _PRIM_ (u2 :: Float#) -> _!_ F# [] [u2] }; _NO_DEFLT_ } _N_ },
+ fromRational = { _A_ 1 _U_ 2 _N_ _N_ _N_ _N_ } #-}
instance Integral a => Fractional (Ratio a)
{-# GHC_PRAGMA _M_ PreludeRatio {-dfun-} _A_ 2 _U_ 22 _N_ _N_ _N_ _N_ #-}
instance Fractional (Ratio Integer)
{-# GHC_PRAGMA _M_ PreludeRatio {-dfun-} _A_ 0 _N_ _N_ _N_ _F_ _IF_ARGS_ 0 0 X 5 _!_ _TUP_4 [{{Num (Ratio Integer)}}, (Ratio Integer -> Ratio Integer -> Ratio Integer), (Ratio Integer -> Ratio Integer), (Ratio Integer -> Ratio Integer)] [_DFUN_ Num (Ratio Integer), _CONSTM_ Fractional (/) (Ratio Integer), _CONSTM_ Fractional recip (Ratio Integer), _CONSTM_ Fractional fromRational (Ratio Integer)] _N_
- (/) = _A_ 2 _U_ 11 _N_ _S_ "U(LU(PPP))U(U(PPP)L)" {_A_ 5 _U_ 22221 _N_ _N_ _N_ _N_} _N_ _N_,
- recip = _A_ 1 _U_ 1 _N_ _S_ "U(U(PPP)L)" {_A_ 4 _U_ 2222 _N_ _N_ _N_ _N_} _N_ _N_,
- fromRational = _A_ 1 _U_ 1 _N_ _S_ "U(LL)" {_A_ 2 _U_ 22 _N_ _N_ _F_ _IF_ARGS_ 0 2 XX 3 \ (u0 :: Integer) (u1 :: Integer) -> _!_ (:%) [Integer] [u0, u1] _N_} _F_ _IF_ARGS_ 0 1 X 1 \ (u0 :: Ratio Integer) -> u0 _N_ #-}
+ (/) = { _A_ 2 _U_ 11 _N_ _S_ "U(LU(PPP))U(U(PPP)L)" {_A_ 5 _U_ 22221 _N_ _N_ _N_ _N_} _N_ _N_ },
+ recip = { _A_ 1 _U_ 1 _N_ _S_ "U(U(PPP)L)" {_A_ 4 _U_ 2222 _N_ _N_ _N_ _N_} _N_ _N_ },
+ fromRational = { _A_ 1 _U_ 1 _N_ _S_ "U(LL)" {_A_ 2 _U_ 22 _N_ _N_ _F_ _IF_ARGS_ 0 2 XX 3 \ (u0 :: Integer) (u1 :: Integer) -> _!_ (:%) [Integer] [u0, u1] _N_} _F_ _IF_ARGS_ 0 1 X 1 \ (u0 :: Ratio Integer) -> u0 _N_ } #-}
instance Integral Int
{-# GHC_PRAGMA _M_ PreludeCore {-dfun-} _A_ 0 _N_ _N_ _N_ _F_ _IF_ARGS_ 0 0 X 13 _!_ _TUP_12 [{{Real Int}}, {{Ix Int}}, (Int -> Int -> Int), (Int -> Int -> Int), (Int -> Int -> Int), (Int -> Int -> Int), (Int -> Int -> (Int, Int)), (Int -> Int -> (Int, Int)), (Int -> Bool), (Int -> Bool), (Int -> Integer), (Int -> Int)] [_DFUN_ Real (Int), _DFUN_ Ix (Int), _CONSTM_ Integral quot (Int), _CONSTM_ Integral rem (Int), _CONSTM_ Integral div (Int), _CONSTM_ Integral mod (Int), _CONSTM_ Integral quotRem (Int), _CONSTM_ Integral divMod (Int), _CONSTM_ Integral even (Int), _CONSTM_ Integral odd (Int), _CONSTM_ Integral toInteger (Int), _CONSTM_ Integral toInt (Int)] _N_
- quot = _A_ 2 _U_ 11 _N_ _S_ "U(P)U(P)" {_A_ 2 _U_ 22 _N_ _N_ _F_ _IF_ARGS_ 0 2 XC 5 \ (u0 :: Int#) (u1 :: Int#) -> case u1 of { _PRIM_ 0# -> _APP_ _TYAPP_ error { Int } [ _NOREP_S_ "Integral.Int.quot{PreludeCore}: divide by 0\n" ]; (u2 :: Int#) -> case _#_ quotInt# [] [u0, u1] of { _PRIM_ (u3 :: Int#) -> _!_ I# [] [u3] } } _N_} _F_ _IF_ARGS_ 0 2 CC 7 \ (u0 :: Int) (u1 :: Int) -> case u1 of { _ALG_ I# (u2 :: Int#) -> case u2 of { _PRIM_ 0# -> _APP_ _TYAPP_ error { Int } [ _NOREP_S_ "Integral.Int.quot{PreludeCore}: divide by 0\n" ]; (u3 :: Int#) -> case u0 of { _ALG_ I# (u4 :: Int#) -> case _#_ quotInt# [] [u4, u2] of { _PRIM_ (u5 :: Int#) -> _!_ I# [] [u5] }; _NO_DEFLT_ } }; _NO_DEFLT_ } _N_,
- rem = _A_ 2 _U_ 11 _N_ _S_ "U(P)U(P)" {_A_ 2 _U_ 22 _N_ _N_ _F_ _IF_ARGS_ 0 2 XC 5 \ (u0 :: Int#) (u1 :: Int#) -> case u1 of { _PRIM_ 0# -> _APP_ _TYAPP_ error { Int } [ _NOREP_S_ "Integral.Int.rem{PreludeCore}: divide by 0\n" ]; (u2 :: Int#) -> case _#_ remInt# [] [u0, u1] of { _PRIM_ (u3 :: Int#) -> _!_ I# [] [u3] } } _N_} _F_ _IF_ARGS_ 0 2 CC 7 \ (u0 :: Int) (u1 :: Int) -> case u1 of { _ALG_ I# (u2 :: Int#) -> case u2 of { _PRIM_ 0# -> _APP_ _TYAPP_ error { Int } [ _NOREP_S_ "Integral.Int.rem{PreludeCore}: divide by 0\n" ]; (u3 :: Int#) -> case u0 of { _ALG_ I# (u4 :: Int#) -> case _#_ remInt# [] [u4, u2] of { _PRIM_ (u5 :: Int#) -> _!_ I# [] [u5] }; _NO_DEFLT_ } }; _NO_DEFLT_ } _N_,
- div = _A_ 2 _U_ 11 _N_ _S_ "U(P)U(P)" {_A_ 2 _U_ 22 _N_ _N_ _N_ _N_} _N_ _N_,
- mod = _A_ 2 _U_ 11 _N_ _S_ "U(P)U(P)" {_A_ 2 _U_ 22 _N_ _N_ _N_ _N_} _N_ _N_,
- quotRem = _A_ 2 _U_ 11 _N_ _S_ "U(P)U(P)" {_A_ 2 _U_ 22 _N_ _N_ _N_ _N_} _N_ _N_,
- divMod = _A_ 2 _U_ 11 _N_ _S_ "U(P)U(P)" {_A_ 2 _U_ 22 _N_ _N_ _N_ _N_} _N_ _N_,
- even = _A_ 1 _U_ 1 _N_ _S_ "U(P)" {_A_ 1 _U_ 2 _N_ _N_ _N_ _N_} _N_ _N_,
- odd = _A_ 1 _U_ 1 _N_ _S_ "U(P)" {_A_ 1 _U_ 2 _N_ _N_ _N_ _N_} _N_ _N_,
- toInteger = _A_ 1 _U_ 1 _N_ _S_ "U(P)" {_A_ 1 _U_ 2 _N_ _N_ _F_ _IF_ARGS_ 0 1 X 1 \ (u0 :: Int#) -> _#_ int2Integer# [] [u0] _N_} _F_ _IF_ARGS_ 0 1 C 2 \ (u0 :: Int) -> case u0 of { _ALG_ I# (u1 :: Int#) -> _#_ int2Integer# [] [u1]; _NO_DEFLT_ } _N_,
- toInt = _A_ 1 _U_ 1 _N_ _S_ "U(P)" {_A_ 1 _U_ 2 _N_ _N_ _F_ _IF_ARGS_ 0 1 X 2 \ (u0 :: Int#) -> _!_ I# [] [u0] _N_} _F_ _IF_ARGS_ 0 1 X 1 \ (u0 :: Int) -> u0 _N_ #-}
+ quot = { _A_ 2 _U_ 11 _N_ _S_ "U(P)U(P)" {_A_ 2 _U_ 22 _N_ _N_ _F_ _IF_ARGS_ 0 2 XC 5 \ (u0 :: Int#) (u1 :: Int#) -> case u1 of { _PRIM_ 0# -> _APP_ _TYAPP_ error { Int } [ _NOREP_S_ "Integral.Int.quot{PreludeCore}: divide by 0\n" ]; (u2 :: Int#) -> case _#_ quotInt# [] [u0, u1] of { _PRIM_ (u3 :: Int#) -> _!_ I# [] [u3] } } _N_} _F_ _IF_ARGS_ 0 2 CC 7 \ (u0 :: Int) (u1 :: Int) -> case u1 of { _ALG_ I# (u2 :: Int#) -> case u2 of { _PRIM_ 0# -> _APP_ _TYAPP_ error { Int } [ _NOREP_S_ "Integral.Int.quot{PreludeCore}: divide by 0\n" ]; (u3 :: Int#) -> case u0 of { _ALG_ I# (u4 :: Int#) -> case _#_ quotInt# [] [u4, u2] of { _PRIM_ (u5 :: Int#) -> _!_ I# [] [u5] }; _NO_DEFLT_ } }; _NO_DEFLT_ } _N_ },
+ rem = { _A_ 2 _U_ 11 _N_ _S_ "U(P)U(P)" {_A_ 2 _U_ 22 _N_ _N_ _F_ _IF_ARGS_ 0 2 XC 5 \ (u0 :: Int#) (u1 :: Int#) -> case u1 of { _PRIM_ 0# -> _APP_ _TYAPP_ error { Int } [ _NOREP_S_ "Integral.Int.rem{PreludeCore}: divide by 0\n" ]; (u2 :: Int#) -> case _#_ remInt# [] [u0, u1] of { _PRIM_ (u3 :: Int#) -> _!_ I# [] [u3] } } _N_} _F_ _IF_ARGS_ 0 2 CC 7 \ (u0 :: Int) (u1 :: Int) -> case u1 of { _ALG_ I# (u2 :: Int#) -> case u2 of { _PRIM_ 0# -> _APP_ _TYAPP_ error { Int } [ _NOREP_S_ "Integral.Int.rem{PreludeCore}: divide by 0\n" ]; (u3 :: Int#) -> case u0 of { _ALG_ I# (u4 :: Int#) -> case _#_ remInt# [] [u4, u2] of { _PRIM_ (u5 :: Int#) -> _!_ I# [] [u5] }; _NO_DEFLT_ } }; _NO_DEFLT_ } _N_ },
+ div = { _A_ 2 _U_ 11 _N_ _S_ "U(P)U(P)" {_A_ 2 _U_ 22 _N_ _N_ _N_ _N_} _N_ _N_ },
+ mod = { _A_ 2 _U_ 11 _N_ _S_ "U(P)U(P)" {_A_ 2 _U_ 22 _N_ _N_ _N_ _N_} _N_ _N_ },
+ quotRem = { _A_ 2 _U_ 11 _N_ _S_ "U(P)U(P)" {_A_ 2 _U_ 22 _N_ _N_ _N_ _N_} _N_ _N_ },
+ divMod = { _A_ 2 _U_ 11 _N_ _S_ "U(P)U(P)" {_A_ 2 _U_ 22 _N_ _N_ _N_ _N_} _N_ _N_ },
+ even = { _A_ 1 _U_ 1 _N_ _S_ "U(P)" {_A_ 1 _U_ 2 _N_ _N_ _N_ _N_} _N_ _N_ },
+ odd = { _A_ 1 _U_ 1 _N_ _S_ "U(P)" {_A_ 1 _U_ 2 _N_ _N_ _N_ _N_} _N_ _N_ },
+ toInteger = { _A_ 1 _U_ 1 _N_ _S_ "U(P)" {_A_ 1 _U_ 2 _N_ _N_ _F_ _IF_ARGS_ 0 1 X 1 \ (u0 :: Int#) -> _#_ int2Integer# [] [u0] _N_} _F_ _IF_ARGS_ 0 1 C 2 \ (u0 :: Int) -> case u0 of { _ALG_ I# (u1 :: Int#) -> _#_ int2Integer# [] [u1]; _NO_DEFLT_ } _N_ },
+ toInt = { _A_ 1 _U_ 1 _N_ _S_ "U(P)" {_A_ 1 _U_ 2 _N_ _N_ _F_ _IF_ARGS_ 0 1 X 2 \ (u0 :: Int#) -> _!_ I# [] [u0] _N_} _F_ _IF_ARGS_ 0 1 X 1 \ (u0 :: Int) -> u0 _N_ } #-}
instance Integral Integer
{-# GHC_PRAGMA _M_ PreludeCore {-dfun-} _A_ 0 _N_ _N_ _N_ _F_ _IF_ARGS_ 0 0 X 13 _!_ _TUP_12 [{{Real Integer}}, {{Ix Integer}}, (Integer -> Integer -> Integer), (Integer -> Integer -> Integer), (Integer -> Integer -> Integer), (Integer -> Integer -> Integer), (Integer -> Integer -> (Integer, Integer)), (Integer -> Integer -> (Integer, Integer)), (Integer -> Bool), (Integer -> Bool), (Integer -> Integer), (Integer -> Int)] [_DFUN_ Real (Integer), _DFUN_ Ix (Integer), _CONSTM_ Integral quot (Integer), _CONSTM_ Integral rem (Integer), _CONSTM_ Integral div (Integer), _CONSTM_ Integral mod (Integer), _CONSTM_ Integral quotRem (Integer), _CONSTM_ Integral divMod (Integer), _CONSTM_ Integral even (Integer), _CONSTM_ Integral odd (Integer), _CONSTM_ Integral toInteger (Integer), _CONSTM_ Integral toInt (Integer)] _N_
- quot = _A_ 2 _U_ 11 _N_ _S_ "U(PPP)U(PPP)" {_A_ 4 _U_ 2221 _N_ _N_ _F_ _IF_ARGS_ 0 4 XXXX 7 \ (u0 :: Int#) (u1 :: Int#) (u2 :: ByteArray#) (u3 :: Integer) -> case _APP_ _WRKR_ _CONSTM_ Integral quotRem (Integer) [ u0, u1, u2, u3 ] of { _ALG_ _TUP_2 (u4 :: Integer) (u5 :: Integer) -> u4; _NO_DEFLT_ } _N_} _F_ _IF_ARGS_ 0 2 XX 5 \ (u0 :: Integer) (u1 :: Integer) -> case _APP_ _CONSTM_ Integral quotRem (Integer) [ u0, u1 ] of { _ALG_ _TUP_2 (u2 :: Integer) (u3 :: Integer) -> u2; _NO_DEFLT_ } _N_,
- rem = _A_ 2 _U_ 11 _N_ _S_ "U(PPP)U(PPP)" {_A_ 4 _U_ 2221 _N_ _N_ _F_ _IF_ARGS_ 0 4 XXXX 7 \ (u0 :: Int#) (u1 :: Int#) (u2 :: ByteArray#) (u3 :: Integer) -> case _APP_ _WRKR_ _CONSTM_ Integral quotRem (Integer) [ u0, u1, u2, u3 ] of { _ALG_ _TUP_2 (u4 :: Integer) (u5 :: Integer) -> u5; _NO_DEFLT_ } _N_} _F_ _IF_ARGS_ 0 2 XX 5 \ (u0 :: Integer) (u1 :: Integer) -> case _APP_ _CONSTM_ Integral quotRem (Integer) [ u0, u1 ] of { _ALG_ _TUP_2 (u2 :: Integer) (u3 :: Integer) -> u3; _NO_DEFLT_ } _N_,
- div = _A_ 2 _U_ 12 _N_ _S_ "U(PPP)U(PPP)" {_A_ 4 _U_ 2222 _N_ _N_ _F_ _IF_ARGS_ 0 4 XXXX 7 \ (u0 :: Int#) (u1 :: Int#) (u2 :: ByteArray#) (u3 :: Integer) -> case _APP_ _WRKR_ _CONSTM_ Integral divMod (Integer) [ u0, u1, u2, u3 ] of { _ALG_ _TUP_2 (u4 :: Integer) (u5 :: Integer) -> u4; _NO_DEFLT_ } _N_} _F_ _IF_ARGS_ 0 2 XX 5 \ (u0 :: Integer) (u1 :: Integer) -> case _APP_ _CONSTM_ Integral divMod (Integer) [ u0, u1 ] of { _ALG_ _TUP_2 (u2 :: Integer) (u3 :: Integer) -> u2; _NO_DEFLT_ } _N_,
- mod = _A_ 2 _U_ 12 _N_ _S_ "U(PPP)U(PPP)" {_A_ 4 _U_ 2222 _N_ _N_ _F_ _IF_ARGS_ 0 4 XXXX 7 \ (u0 :: Int#) (u1 :: Int#) (u2 :: ByteArray#) (u3 :: Integer) -> case _APP_ _WRKR_ _CONSTM_ Integral divMod (Integer) [ u0, u1, u2, u3 ] of { _ALG_ _TUP_2 (u4 :: Integer) (u5 :: Integer) -> u5; _NO_DEFLT_ } _N_} _F_ _IF_ARGS_ 0 2 XX 5 \ (u0 :: Integer) (u1 :: Integer) -> case _APP_ _CONSTM_ Integral divMod (Integer) [ u0, u1 ] of { _ALG_ _TUP_2 (u2 :: Integer) (u3 :: Integer) -> u3; _NO_DEFLT_ } _N_,
- quotRem = _A_ 2 _U_ 11 _N_ _S_ "U(PPP)U(PPP)" {_A_ 4 _U_ 2221 _N_ _N_ _N_ _N_} _N_ _N_,
- divMod = _A_ 2 _U_ 12 _N_ _S_ "U(PPP)U(PPP)" {_A_ 4 _U_ 2222 _N_ _N_ _N_ _N_} _N_ _N_,
- even = _A_ 1 _U_ 1 _N_ _S_ "U(PPP)" {_A_ 3 _U_ 222 _N_ _N_ _N_ _N_} _N_ _N_,
- odd = _A_ 1 _U_ 1 _N_ _S_ "U(PPP)" {_A_ 3 _U_ 222 _N_ _N_ _N_ _N_} _N_ _N_,
- toInteger = _A_ 1 _U_ 1 _N_ _S_ "U(PPP)" {_A_ 3 _U_ 222 _N_ _N_ _F_ _IF_ARGS_ 0 3 XXX 4 \ (u0 :: Int#) (u1 :: Int#) (u2 :: ByteArray#) -> _!_ J# [] [u0, u1, u2] _N_} _F_ _IF_ARGS_ 0 1 X 1 \ (u0 :: Integer) -> u0 _N_,
- toInt = _A_ 1 _U_ 1 _N_ _S_ "U(PPP)" {_A_ 3 _U_ 222 _N_ _N_ _F_ _IF_ARGS_ 0 3 XXX 3 \ (u0 :: Int#) (u1 :: Int#) (u2 :: ByteArray#) -> case _#_ integer2Int# [] [u0, u1, u2] of { _PRIM_ (u3 :: Int#) -> _!_ I# [] [u3] } _N_} _F_ _IF_ARGS_ 0 1 C 4 \ (u0 :: Integer) -> case u0 of { _ALG_ J# (u1 :: Int#) (u2 :: Int#) (u3 :: ByteArray#) -> case _#_ integer2Int# [] [u1, u2, u3] of { _PRIM_ (u4 :: Int#) -> _!_ I# [] [u4] }; _NO_DEFLT_ } _N_ #-}
+ quot = { _A_ 2 _U_ 11 _N_ _S_ "U(PPP)U(PPP)" {_A_ 4 _U_ 2221 _N_ _N_ _F_ _IF_ARGS_ 0 4 XXXX 7 \ (u0 :: Int#) (u1 :: Int#) (u2 :: ByteArray#) (u3 :: Integer) -> case _APP_ _WRKR_ _CONSTM_ Integral quotRem (Integer) [ u0, u1, u2, u3 ] of { _ALG_ _TUP_2 (u4 :: Integer) (u5 :: Integer) -> u4; _NO_DEFLT_ } _N_} _F_ _IF_ARGS_ 0 2 XX 5 \ (u0 :: Integer) (u1 :: Integer) -> case _APP_ _CONSTM_ Integral quotRem (Integer) [ u0, u1 ] of { _ALG_ _TUP_2 (u2 :: Integer) (u3 :: Integer) -> u2; _NO_DEFLT_ } _N_ },
+ rem = { _A_ 2 _U_ 11 _N_ _S_ "U(PPP)U(PPP)" {_A_ 4 _U_ 2221 _N_ _N_ _F_ _IF_ARGS_ 0 4 XXXX 7 \ (u0 :: Int#) (u1 :: Int#) (u2 :: ByteArray#) (u3 :: Integer) -> case _APP_ _WRKR_ _CONSTM_ Integral quotRem (Integer) [ u0, u1, u2, u3 ] of { _ALG_ _TUP_2 (u4 :: Integer) (u5 :: Integer) -> u5; _NO_DEFLT_ } _N_} _F_ _IF_ARGS_ 0 2 XX 5 \ (u0 :: Integer) (u1 :: Integer) -> case _APP_ _CONSTM_ Integral quotRem (Integer) [ u0, u1 ] of { _ALG_ _TUP_2 (u2 :: Integer) (u3 :: Integer) -> u3; _NO_DEFLT_ } _N_ },
+ div = { _A_ 2 _U_ 12 _N_ _S_ "U(PPP)U(PPP)" {_A_ 4 _U_ 2222 _N_ _N_ _F_ _IF_ARGS_ 0 4 XXXX 7 \ (u0 :: Int#) (u1 :: Int#) (u2 :: ByteArray#) (u3 :: Integer) -> case _APP_ _WRKR_ _CONSTM_ Integral divMod (Integer) [ u0, u1, u2, u3 ] of { _ALG_ _TUP_2 (u4 :: Integer) (u5 :: Integer) -> u4; _NO_DEFLT_ } _N_} _F_ _IF_ARGS_ 0 2 XX 5 \ (u0 :: Integer) (u1 :: Integer) -> case _APP_ _CONSTM_ Integral divMod (Integer) [ u0, u1 ] of { _ALG_ _TUP_2 (u2 :: Integer) (u3 :: Integer) -> u2; _NO_DEFLT_ } _N_ },
+ mod = { _A_ 2 _U_ 12 _N_ _S_ "U(PPP)U(PPP)" {_A_ 4 _U_ 2222 _N_ _N_ _F_ _IF_ARGS_ 0 4 XXXX 7 \ (u0 :: Int#) (u1 :: Int#) (u2 :: ByteArray#) (u3 :: Integer) -> case _APP_ _WRKR_ _CONSTM_ Integral divMod (Integer) [ u0, u1, u2, u3 ] of { _ALG_ _TUP_2 (u4 :: Integer) (u5 :: Integer) -> u5; _NO_DEFLT_ } _N_} _F_ _IF_ARGS_ 0 2 XX 5 \ (u0 :: Integer) (u1 :: Integer) -> case _APP_ _CONSTM_ Integral divMod (Integer) [ u0, u1 ] of { _ALG_ _TUP_2 (u2 :: Integer) (u3 :: Integer) -> u3; _NO_DEFLT_ } _N_ },
+ quotRem = { _A_ 2 _U_ 11 _N_ _S_ "U(PPP)U(PPP)" {_A_ 4 _U_ 2221 _N_ _N_ _N_ _N_} _N_ _N_ },
+ divMod = { _A_ 2 _U_ 12 _N_ _S_ "U(PPP)U(PPP)" {_A_ 4 _U_ 2222 _N_ _N_ _N_ _N_} _N_ _N_ },
+ even = { _A_ 1 _U_ 1 _N_ _S_ "U(PPP)" {_A_ 3 _U_ 222 _N_ _N_ _N_ _N_} _N_ _N_ },
+ odd = { _A_ 1 _U_ 1 _N_ _S_ "U(PPP)" {_A_ 3 _U_ 222 _N_ _N_ _N_ _N_} _N_ _N_ },
+ toInteger = { _A_ 1 _U_ 1 _N_ _S_ "U(PPP)" {_A_ 3 _U_ 222 _N_ _N_ _F_ _IF_ARGS_ 0 3 XXX 4 \ (u0 :: Int#) (u1 :: Int#) (u2 :: ByteArray#) -> _!_ J# [] [u0, u1, u2] _N_} _F_ _IF_ARGS_ 0 1 X 1 \ (u0 :: Integer) -> u0 _N_ },
+ toInt = { _A_ 1 _U_ 1 _N_ _S_ "U(PPP)" {_A_ 3 _U_ 222 _N_ _N_ _F_ _IF_ARGS_ 0 3 XXX 3 \ (u0 :: Int#) (u1 :: Int#) (u2 :: ByteArray#) -> case _#_ integer2Int# [] [u0, u1, u2] of { _PRIM_ (u3 :: Int#) -> _!_ I# [] [u3] } _N_} _F_ _IF_ARGS_ 0 1 C 4 \ (u0 :: Integer) -> case u0 of { _ALG_ J# (u1 :: Int#) (u2 :: Int#) (u3 :: ByteArray#) -> case _#_ integer2Int# [] [u1, u2, u3] of { _PRIM_ (u4 :: Int#) -> _!_ I# [] [u4] }; _NO_DEFLT_ } _N_ } #-}
instance Ix ()
{-# GHC_PRAGMA _M_ PreludeBuiltin {-dfun-} _A_ 0 _N_ _N_ _N_ _F_ _IF_ARGS_ 0 0 X 5 _!_ _TUP_4 [{{Ord ()}}, (((), ()) -> [()]), (((), ()) -> () -> Int), (((), ()) -> () -> Bool)] [_DFUN_ Ord (()), _CONSTM_ Ix range (()), _CONSTM_ Ix index (()), _CONSTM_ Ix inRange (())] _N_
- range = _A_ 1 _U_ 1 _N_ _S_ "U(EE)" {_A_ 2 _U_ 21 _N_ _N_ _N_ _N_} _N_ _N_,
- index = _A_ 2 _U_ 11 _N_ _S_ "U(EE)E" {_A_ 3 _U_ 111 _N_ _N_ _F_ _IF_ARGS_ 0 3 CCC 5 \ (u0 :: ()) (u1 :: ()) (u2 :: ()) -> case u0 of { _ALG_ _TUP_0 -> case u1 of { _ALG_ _TUP_0 -> case u2 of { _ALG_ _TUP_0 -> _!_ I# [] [0#]; _NO_DEFLT_ }; _NO_DEFLT_ }; _NO_DEFLT_ } _N_} _F_ _IF_ARGS_ 0 2 CC 6 \ (u0 :: ((), ())) (u1 :: ()) -> case u0 of { _ALG_ _TUP_2 (u2 :: ()) (u3 :: ()) -> case u2 of { _ALG_ _TUP_0 -> case u3 of { _ALG_ _TUP_0 -> case u1 of { _ALG_ _TUP_0 -> _!_ I# [] [0#]; _NO_DEFLT_ }; _NO_DEFLT_ }; _NO_DEFLT_ }; _NO_DEFLT_ } _N_,
- inRange = _A_ 2 _U_ 11 _N_ _S_ "U(EE)E" {_A_ 3 _U_ 111 _N_ _N_ _F_ _IF_ARGS_ 0 3 CCC 4 \ (u0 :: ()) (u1 :: ()) (u2 :: ()) -> case u0 of { _ALG_ _TUP_0 -> case u1 of { _ALG_ _TUP_0 -> case u2 of { _ALG_ _TUP_0 -> _!_ True [] []; _NO_DEFLT_ }; _NO_DEFLT_ }; _NO_DEFLT_ } _N_} _F_ _IF_ARGS_ 0 2 CC 5 \ (u0 :: ((), ())) (u1 :: ()) -> case u0 of { _ALG_ _TUP_2 (u2 :: ()) (u3 :: ()) -> case u2 of { _ALG_ _TUP_0 -> case u3 of { _ALG_ _TUP_0 -> case u1 of { _ALG_ _TUP_0 -> _!_ True [] []; _NO_DEFLT_ }; _NO_DEFLT_ }; _NO_DEFLT_ }; _NO_DEFLT_ } _N_ #-}
+ range = { _A_ 1 _U_ 1 _N_ _S_ "U(EE)" {_A_ 2 _U_ 21 _N_ _N_ _N_ _N_} _N_ _N_ },
+ index = { _A_ 2 _U_ 11 _N_ _S_ "U(EE)E" {_A_ 3 _U_ 111 _N_ _N_ _F_ _IF_ARGS_ 0 3 CCC 5 \ (u0 :: ()) (u1 :: ()) (u2 :: ()) -> case u0 of { _ALG_ _TUP_0 -> case u1 of { _ALG_ _TUP_0 -> case u2 of { _ALG_ _TUP_0 -> _!_ I# [] [0#]; _NO_DEFLT_ }; _NO_DEFLT_ }; _NO_DEFLT_ } _N_} _F_ _IF_ARGS_ 0 2 CC 6 \ (u0 :: ((), ())) (u1 :: ()) -> case u0 of { _ALG_ _TUP_2 (u2 :: ()) (u3 :: ()) -> case u2 of { _ALG_ _TUP_0 -> case u3 of { _ALG_ _TUP_0 -> case u1 of { _ALG_ _TUP_0 -> _!_ I# [] [0#]; _NO_DEFLT_ }; _NO_DEFLT_ }; _NO_DEFLT_ }; _NO_DEFLT_ } _N_ },
+ inRange = { _A_ 2 _U_ 11 _N_ _S_ "U(EE)E" {_A_ 3 _U_ 111 _N_ _N_ _F_ _IF_ARGS_ 0 3 CCC 4 \ (u0 :: ()) (u1 :: ()) (u2 :: ()) -> case u0 of { _ALG_ _TUP_0 -> case u1 of { _ALG_ _TUP_0 -> case u2 of { _ALG_ _TUP_0 -> _!_ True [] []; _NO_DEFLT_ }; _NO_DEFLT_ }; _NO_DEFLT_ } _N_} _F_ _IF_ARGS_ 0 2 CC 5 \ (u0 :: ((), ())) (u1 :: ()) -> case u0 of { _ALG_ _TUP_2 (u2 :: ()) (u3 :: ()) -> case u2 of { _ALG_ _TUP_0 -> case u3 of { _ALG_ _TUP_0 -> case u1 of { _ALG_ _TUP_0 -> _!_ True [] []; _NO_DEFLT_ }; _NO_DEFLT_ }; _NO_DEFLT_ }; _NO_DEFLT_ } _N_ } #-}
instance (Ix a, Ix b) => Ix (a, b)
{-# GHC_PRAGMA _M_ PreludeBuiltin {-dfun-} _A_ 3 _U_ 222 _N_ _N_ _N_ _N_ #-}
instance (Ix a, Ix b, Ix c) => Ix (a, b, c)
{-# GHC_PRAGMA _M_ PreludeBuiltin {-dfun-} _A_ 6 _U_ 222222 _N_ _N_ _N_ _N_ #-}
instance Ix (Int, Int)
{-# GHC_PRAGMA _M_ PreludeBuiltin {-dfun-} _A_ 0 _N_ _N_ _N_ _F_ _IF_ARGS_ 0 0 X 5 _!_ _TUP_4 [{{Ord (Int, Int)}}, (((Int, Int), (Int, Int)) -> [(Int, Int)]), (((Int, Int), (Int, Int)) -> (Int, Int) -> Int), (((Int, Int), (Int, Int)) -> (Int, Int) -> Bool)] [_DFUN_ Ord ((Int, Int)), _CONSTM_ Ix range ((Int, Int)), _CONSTM_ Ix index ((Int, Int)), _CONSTM_ Ix inRange ((Int, Int))] _N_
- range = _A_ 1 _U_ 1 _N_ _S_ "U(SS)" {_A_ 2 _U_ 11 _N_ _N_ _N_ _N_} _N_ _N_,
- index = _A_ 2 _U_ 11 _N_ _S_ "U(SS)U(U(P)U(P))" {_A_ 4 _U_ 1122 _N_ _N_ _N_ _N_} _N_ _N_,
- inRange = _A_ 2 _U_ 11 _N_ _S_ "U(SS)U(U(P)L)" {_A_ 4 _U_ 1121 _N_ _N_ _N_ _N_} _N_ _N_ #-}
+ range = { _A_ 1 _U_ 1 _N_ _S_ "U(SS)" {_A_ 2 _U_ 11 _N_ _N_ _N_ _N_} _N_ _N_ },
+ index = { _A_ 2 _U_ 11 _N_ _S_ "U(SS)U(U(P)U(P))" {_A_ 4 _U_ 1122 _N_ _N_ _N_ _N_} _N_ _N_ },
+ inRange = { _A_ 2 _U_ 11 _N_ _S_ "U(SS)U(U(P)L)" {_A_ 4 _U_ 1121 _N_ _N_ _N_ _N_} _N_ _N_ } #-}
instance (Ix a, Ix b) => Ix (Assoc a b)
{-# GHC_PRAGMA _M_ PreludeArray {-dfun-} _A_ 3 _U_ 222 _N_ _N_ _N_ _N_ #-}
instance Ix Bool
{-# GHC_PRAGMA _M_ PreludeCore {-dfun-} _A_ 0 _N_ _N_ _N_ _F_ _IF_ARGS_ 0 0 X 5 _!_ _TUP_4 [{{Ord Bool}}, ((Bool, Bool) -> [Bool]), ((Bool, Bool) -> Bool -> Int), ((Bool, Bool) -> Bool -> Bool)] [_DFUN_ Ord (Bool), _CONSTM_ Ix range (Bool), _CONSTM_ Ix index (Bool), _CONSTM_ Ix inRange (Bool)] _N_
- range = _A_ 1 _U_ 1 _N_ _S_ "U(EE)" {_A_ 2 _U_ 11 _N_ _N_ _N_ _N_} _N_ _N_,
- index = _A_ 2 _U_ 11 _N_ _S_ "U(EA)E" {_A_ 2 _U_ 11 _N_ _N_ _N_ _N_} _N_ _N_,
- inRange = _A_ 2 _U_ 12 _N_ _S_ "U(EL)E" {_A_ 3 _U_ 112 _N_ _N_ _N_ _N_} _N_ _N_ #-}
+ range = { _A_ 1 _U_ 1 _N_ _S_ "U(EE)" {_A_ 2 _U_ 11 _N_ _N_ _N_ _N_} _N_ _N_ },
+ index = { _A_ 2 _U_ 11 _N_ _S_ "U(EA)E" {_A_ 2 _U_ 11 _N_ _N_ _N_ _N_} _N_ _N_ },
+ inRange = { _A_ 2 _U_ 12 _N_ _S_ "U(EL)E" {_A_ 3 _U_ 112 _N_ _N_ _N_ _N_} _N_ _N_ } #-}
instance Ix Char
{-# GHC_PRAGMA _M_ PreludeCore {-dfun-} _A_ 0 _N_ _N_ _N_ _F_ _IF_ARGS_ 0 0 X 5 _!_ _TUP_4 [{{Ord Char}}, ((Char, Char) -> [Char]), ((Char, Char) -> Char -> Int), ((Char, Char) -> Char -> Bool)] [_DFUN_ Ord (Char), _CONSTM_ Ix range (Char), _CONSTM_ Ix index (Char), _CONSTM_ Ix inRange (Char)] _N_
- range = _A_ 1 _U_ 1 _N_ _S_ "U(LL)" {_A_ 2 _U_ 22 _N_ _N_ _F_ _IF_ARGS_ 0 0 X 1 _CONSTM_ Enum enumFromTo (Char) _N_} _F_ _IF_ARGS_ 0 1 C 4 \ (u0 :: (Char, Char)) -> case u0 of { _ALG_ _TUP_2 (u1 :: Char) (u2 :: Char) -> _APP_ _CONSTM_ Enum enumFromTo (Char) [ u1, u2 ]; _NO_DEFLT_ } _N_,
- index = _A_ 2 _U_ 11 _N_ _S_ "U(U(P)L)U(P)" {_A_ 3 _U_ 212 _N_ _N_ _N_ _N_} _N_ _N_,
- inRange = _A_ 2 _U_ 11 _N_ _S_ "U(U(P)L)U(P)" {_A_ 3 _U_ 212 _N_ _N_ _N_ _N_} _N_ _N_ #-}
+ range = { _A_ 1 _U_ 1 _N_ _S_ "U(U(P)L)" {_A_ 2 _U_ 22 _N_ _N_ _N_ _N_} _F_ _IF_ARGS_ 0 1 C 4 \ (u0 :: (Char, Char)) -> case u0 of { _ALG_ _TUP_2 (u1 :: Char) (u2 :: Char) -> _APP_ _CONSTM_ Enum enumFromTo (Char) [ u1, u2 ]; _NO_DEFLT_ } _N_ },
+ index = { _A_ 2 _U_ 11 _N_ _S_ "U(U(P)L)U(P)" {_A_ 3 _U_ 212 _N_ _N_ _N_ _N_} _N_ _N_ },
+ inRange = { _A_ 2 _U_ 11 _N_ _S_ "U(U(P)L)U(P)" {_A_ 3 _U_ 212 _N_ _N_ _N_ _N_} _N_ _N_ } #-}
instance Ix Int
{-# GHC_PRAGMA _M_ PreludeCore {-dfun-} _A_ 0 _N_ _N_ _N_ _F_ _IF_ARGS_ 0 0 X 5 _!_ _TUP_4 [{{Ord Int}}, ((Int, Int) -> [Int]), ((Int, Int) -> Int -> Int), ((Int, Int) -> Int -> Bool)] [_DFUN_ Ord (Int), _CONSTM_ Ix range (Int), _CONSTM_ Ix index (Int), _CONSTM_ Ix inRange (Int)] _N_
- range = _A_ 1 _U_ 1 _N_ _S_ "U(U(P)U(P))" {_A_ 2 _U_ 22 _N_ _N_ _N_ _N_} _N_ _N_,
- index = _A_ 2 _U_ 11 _N_ _S_ "U(U(P)U(P))U(P)" {_A_ 3 _U_ 222 _N_ _N_ _N_ _N_} _N_ _N_,
- inRange = _A_ 2 _U_ 11 _N_ _S_ "U(U(P)U(P))U(P)" {_A_ 3 _U_ 222 _N_ _N_ _F_ _IF_ARGS_ 0 3 XXX 5 \ (u0 :: Int#) (u1 :: Int#) (u2 :: Int#) -> case _#_ leInt# [] [u0, u2] of { _ALG_ True -> _#_ leInt# [] [u2, u1]; False -> _!_ False [] []; _NO_DEFLT_ } _N_} _F_ _ALWAYS_ \ (u0 :: (Int, Int)) (u1 :: Int) -> case u0 of { _ALG_ _TUP_2 (u2 :: Int) (u3 :: Int) -> case u2 of { _ALG_ I# (u4 :: Int#) -> case u3 of { _ALG_ I# (u5 :: Int#) -> case u1 of { _ALG_ I# (u6 :: Int#) -> case _#_ leInt# [] [u4, u6] of { _ALG_ True -> _#_ leInt# [] [u6, u5]; False -> _!_ False [] []; _NO_DEFLT_ }; _NO_DEFLT_ }; _NO_DEFLT_ }; _NO_DEFLT_ }; _NO_DEFLT_ } _N_ #-}
+ range = { _A_ 1 _U_ 1 _N_ _S_ "U(U(P)U(P))" {_A_ 2 _U_ 22 _N_ _N_ _N_ _N_} _N_ _N_ },
+ index = { _A_ 2 _U_ 11 _N_ _S_ "U(U(P)U(P))U(P)" {_A_ 3 _U_ 222 _N_ _N_ _N_ _N_} _N_ _N_ },
+ inRange = { _A_ 2 _U_ 11 _N_ _S_ "U(U(P)U(P))U(P)" {_A_ 3 _U_ 222 _N_ _N_ _F_ _IF_ARGS_ 0 3 XXX 5 \ (u0 :: Int#) (u1 :: Int#) (u2 :: Int#) -> case _#_ leInt# [] [u0, u2] of { _ALG_ True -> _#_ leInt# [] [u2, u1]; False -> _!_ False [] []; _NO_DEFLT_ } _N_} _F_ _ALWAYS_ \ (u0 :: (Int, Int)) (u1 :: Int) -> case u0 of { _ALG_ _TUP_2 (u2 :: Int) (u3 :: Int) -> case u2 of { _ALG_ I# (u4 :: Int#) -> case u3 of { _ALG_ I# (u5 :: Int#) -> case u1 of { _ALG_ I# (u6 :: Int#) -> case _#_ leInt# [] [u4, u6] of { _ALG_ True -> _#_ leInt# [] [u6, u5]; False -> _!_ False [] []; _NO_DEFLT_ }; _NO_DEFLT_ }; _NO_DEFLT_ }; _NO_DEFLT_ }; _NO_DEFLT_ } _N_ } #-}
instance Ix Integer
{-# GHC_PRAGMA _M_ PreludeCore {-dfun-} _A_ 0 _N_ _N_ _N_ _F_ _IF_ARGS_ 0 0 X 5 _!_ _TUP_4 [{{Ord Integer}}, ((Integer, Integer) -> [Integer]), ((Integer, Integer) -> Integer -> Int), ((Integer, Integer) -> Integer -> Bool)] [_DFUN_ Ord (Integer), _CONSTM_ Ix range (Integer), _CONSTM_ Ix index (Integer), _CONSTM_ Ix inRange (Integer)] _N_
- range = _A_ 1 _U_ 1 _N_ _S_ "U(LL)" {_A_ 2 _U_ 22 _N_ _N_ _F_ _IF_ARGS_ 0 0 X 1 _CONSTM_ Enum enumFromTo (Integer) _N_} _F_ _IF_ARGS_ 0 1 C 4 \ (u0 :: (Integer, Integer)) -> case u0 of { _ALG_ _TUP_2 (u1 :: Integer) (u2 :: Integer) -> _APP_ _CONSTM_ Enum enumFromTo (Integer) [ u1, u2 ]; _NO_DEFLT_ } _N_,
- index = _A_ 2 _U_ 12 _N_ _S_ "U(U(PPP)L)U(PPP)" {_A_ 5 _U_ 22222 _N_ _N_ _N_ _N_} _N_ _N_,
- inRange = _A_ 2 _U_ 11 _N_ _S_ "U(U(PPP)L)U(PPP)" {_A_ 5 _U_ 22211 _N_ _N_ _F_ _IF_ARGS_ 0 5 XXXCC 9 \ (u0 :: Int#) (u1 :: Int#) (u2 :: ByteArray#) (u3 :: Integer) (u4 :: Integer) -> case u4 of { _ALG_ J# (u5 :: Int#) (u6 :: Int#) (u7 :: ByteArray#) -> case _#_ cmpInteger# [] [u0, u1, u2, u5, u6, u7] of { _PRIM_ (u8 :: Int#) -> case _#_ leInt# [] [u8, 0#] of { _ALG_ True -> case u3 of { _ALG_ J# (u9 :: Int#) (ua :: Int#) (ub :: ByteArray#) -> case _#_ cmpInteger# [] [u5, u6, u7, u9, ua, ub] of { _PRIM_ (uc :: Int#) -> _#_ leInt# [] [uc, 0#] }; _NO_DEFLT_ }; False -> _!_ False [] []; _NO_DEFLT_ } }; _NO_DEFLT_ } _N_} _N_ _N_ #-}
+ range = { _A_ 1 _U_ 1 _N_ _S_ "U(LL)" {_A_ 2 _U_ 22 _N_ _N_ _F_ _IF_ARGS_ 0 0 X 1 _CONSTM_ Enum enumFromTo (Integer) _N_} _F_ _IF_ARGS_ 0 1 C 4 \ (u0 :: (Integer, Integer)) -> case u0 of { _ALG_ _TUP_2 (u1 :: Integer) (u2 :: Integer) -> _APP_ _CONSTM_ Enum enumFromTo (Integer) [ u1, u2 ]; _NO_DEFLT_ } _N_ },
+ index = { _A_ 2 _U_ 12 _N_ _S_ "U(U(PPP)L)U(PPP)" {_A_ 5 _U_ 22222 _N_ _N_ _N_ _N_} _N_ _N_ },
+ inRange = { _A_ 2 _U_ 11 _N_ _S_ "U(U(PPP)L)U(PPP)" {_A_ 5 _U_ 22211 _N_ _N_ _F_ _IF_ARGS_ 0 5 XXXCC 9 \ (u0 :: Int#) (u1 :: Int#) (u2 :: ByteArray#) (u3 :: Integer) (u4 :: Integer) -> case u4 of { _ALG_ J# (u5 :: Int#) (u6 :: Int#) (u7 :: ByteArray#) -> case _#_ cmpInteger# [] [u0, u1, u2, u5, u6, u7] of { _PRIM_ (u8 :: Int#) -> case _#_ leInt# [] [u8, 0#] of { _ALG_ True -> case u3 of { _ALG_ J# (u9 :: Int#) (ua :: Int#) (ub :: ByteArray#) -> case _#_ cmpInteger# [] [u5, u6, u7, u9, ua, ub] of { _PRIM_ (uc :: Int#) -> _#_ leInt# [] [uc, 0#] }; _NO_DEFLT_ }; False -> _!_ False [] []; _NO_DEFLT_ } }; _NO_DEFLT_ } _N_} _N_ _N_ } #-}
instance RealFloat a => Num (Complex a)
{-# GHC_PRAGMA _M_ PreludeComplex {-dfun-} _A_ 3 _U_ 222 _N_ _N_ _N_ _N_ #-}
instance Num (Complex Double)
- {-# GHC_PRAGMA _M_ PreludeComplex {-dfun-} _A_ 0 _N_ _N_ _N_ _N_ _N_
- (+) = _A_ 2 _U_ 11 _N_ _S_ "U(LL)U(LL)" {_A_ 4 _U_ 1111 _N_ _N_ _N_ _N_} _N_ _N_,
- (-) = _A_ 2 _U_ 11 _N_ _S_ "U(LL)U(LL)" {_A_ 4 _U_ 1111 _N_ _N_ _N_ _N_} _N_ _N_,
- (*) = _A_ 2 _U_ 11 _N_ _S_ "U(LL)U(LL)" {_A_ 4 _U_ 2222 _N_ _N_ _N_ _N_} _N_ _N_,
- negate = _A_ 1 _U_ 1 _N_ _S_ "U(LL)" {_A_ 2 _U_ 11 _N_ _N_ _N_ _N_} _N_ _N_,
- abs = _A_ 1 _U_ 1 _N_ _N_ _N_ _N_,
- signum = _A_ 1 _U_ 1 _N_ _S_ "U(U(P)L)" {_A_ 2 _U_ 22 _N_ _N_ _N_ _N_} _N_ _N_,
- fromInteger = _A_ 1 _U_ 1 _N_ _N_ _N_ _N_,
- fromInt = _A_ 1 _U_ 1 _N_ _N_ _N_ _N_ #-}
+ {-# GHC_PRAGMA _M_ PreludeComplex {-dfun-} _A_ 0 _N_ _N_ _N_ _F_ _IF_ARGS_ 0 0 X 11 _!_ _TUP_10 [{{Eq (Complex Double)}}, {{Text (Complex Double)}}, (Complex Double -> Complex Double -> Complex Double), (Complex Double -> Complex Double -> Complex Double), (Complex Double -> Complex Double -> Complex Double), (Complex Double -> Complex Double), (Complex Double -> Complex Double), (Complex Double -> Complex Double), (Integer -> Complex Double), (Int -> Complex Double)] [_DFUN_ Eq (Complex Double), _DFUN_ Text (Complex Double), _CONSTM_ Num (+) (Complex Double), _CONSTM_ Num (-) (Complex Double), _CONSTM_ Num (*) (Complex Double), _CONSTM_ Num negate (Complex Double), _CONSTM_ Num abs (Complex Double), _CONSTM_ Num signum (Complex Double), _CONSTM_ Num fromInteger (Complex Double), _CONSTM_ Num fromInt (Complex Double)] _N_
+ (+) = { _A_ 2 _U_ 11 _N_ _S_ "U(LL)U(LL)" {_A_ 4 _U_ 1111 _N_ _N_ _N_ _N_} _N_ _N_ },
+ (-) = { _A_ 2 _U_ 11 _N_ _S_ "U(LL)U(LL)" {_A_ 4 _U_ 1111 _N_ _N_ _N_ _N_} _N_ _N_ },
+ (*) = { _A_ 2 _U_ 11 _N_ _S_ "U(LL)U(LL)" {_A_ 4 _U_ 2222 _N_ _N_ _N_ _N_} _N_ _N_ },
+ negate = { _A_ 1 _U_ 1 _N_ _S_ "U(LL)" {_A_ 2 _U_ 11 _N_ _N_ _N_ _N_} _N_ _N_ },
+ abs = { _A_ 1 _U_ 1 _N_ _N_ _N_ _N_ },
+ signum = { _A_ 1 _U_ 1 _N_ _S_ "U(U(P)L)" {_A_ 2 _U_ 22 _N_ _N_ _N_ _N_} _N_ _N_ },
+ fromInteger = { _A_ 1 _U_ 1 _N_ _N_ _N_ _N_ },
+ fromInt = { _A_ 1 _U_ 1 _N_ _N_ _N_ _N_ } #-}
instance Num Double
{-# GHC_PRAGMA _M_ PreludeCore {-dfun-} _A_ 0 _N_ _N_ _N_ _F_ _IF_ARGS_ 0 0 X 11 _!_ _TUP_10 [{{Eq Double}}, {{Text Double}}, (Double -> Double -> Double), (Double -> Double -> Double), (Double -> Double -> Double), (Double -> Double), (Double -> Double), (Double -> Double), (Integer -> Double), (Int -> Double)] [_DFUN_ Eq (Double), _DFUN_ Text (Double), _CONSTM_ Num (+) (Double), _CONSTM_ Num (-) (Double), _CONSTM_ Num (*) (Double), _CONSTM_ Num negate (Double), _CONSTM_ Num abs (Double), _CONSTM_ Num signum (Double), _CONSTM_ Num fromInteger (Double), _CONSTM_ Num fromInt (Double)] _N_
- (+) = _A_ 2 _U_ 11 _N_ _S_ "U(P)U(P)" {_A_ 2 _U_ 22 _N_ _N_ _F_ _IF_ARGS_ 0 2 XX 3 \ (u0 :: Double#) (u1 :: Double#) -> case _#_ plusDouble# [] [u0, u1] of { _PRIM_ (u2 :: Double#) -> _!_ D# [] [u2] } _N_} _F_ _IF_ARGS_ 0 2 CC 5 \ (u0 :: Double) (u1 :: Double) -> case u0 of { _ALG_ D# (u2 :: Double#) -> case u1 of { _ALG_ D# (u3 :: Double#) -> case _#_ plusDouble# [] [u2, u3] of { _PRIM_ (u4 :: Double#) -> _!_ D# [] [u4] }; _NO_DEFLT_ }; _NO_DEFLT_ } _N_,
- (-) = _A_ 2 _U_ 11 _N_ _S_ "U(P)U(P)" {_A_ 2 _U_ 22 _N_ _N_ _F_ _IF_ARGS_ 0 2 XX 3 \ (u0 :: Double#) (u1 :: Double#) -> case _#_ minusDouble# [] [u0, u1] of { _PRIM_ (u2 :: Double#) -> _!_ D# [] [u2] } _N_} _F_ _IF_ARGS_ 0 2 CC 5 \ (u0 :: Double) (u1 :: Double) -> case u0 of { _ALG_ D# (u2 :: Double#) -> case u1 of { _ALG_ D# (u3 :: Double#) -> case _#_ minusDouble# [] [u2, u3] of { _PRIM_ (u4 :: Double#) -> _!_ D# [] [u4] }; _NO_DEFLT_ }; _NO_DEFLT_ } _N_,
- (*) = _A_ 2 _U_ 11 _N_ _S_ "U(P)U(P)" {_A_ 2 _U_ 22 _N_ _N_ _F_ _IF_ARGS_ 0 2 XX 3 \ (u0 :: Double#) (u1 :: Double#) -> case _#_ timesDouble# [] [u0, u1] of { _PRIM_ (u2 :: Double#) -> _!_ D# [] [u2] } _N_} _F_ _IF_ARGS_ 0 2 CC 5 \ (u0 :: Double) (u1 :: Double) -> case u0 of { _ALG_ D# (u2 :: Double#) -> case u1 of { _ALG_ D# (u3 :: Double#) -> case _#_ timesDouble# [] [u2, u3] of { _PRIM_ (u4 :: Double#) -> _!_ D# [] [u4] }; _NO_DEFLT_ }; _NO_DEFLT_ } _N_,
- negate = _A_ 1 _U_ 1 _N_ _S_ "U(P)" {_A_ 1 _U_ 2 _N_ _N_ _F_ _IF_ARGS_ 0 1 X 3 \ (u0 :: Double#) -> case _#_ negateDouble# [] [u0] of { _PRIM_ (u1 :: Double#) -> _!_ D# [] [u1] } _N_} _F_ _IF_ARGS_ 0 1 C 4 \ (u0 :: Double) -> case u0 of { _ALG_ D# (u1 :: Double#) -> case _#_ negateDouble# [] [u1] of { _PRIM_ (u2 :: Double#) -> _!_ D# [] [u2] }; _NO_DEFLT_ } _N_,
- abs = _A_ 1 _U_ 1 _N_ _S_ "U(P)" {_A_ 1 _U_ 2 _N_ _N_ _N_ _N_} _N_ _N_,
- signum = _A_ 1 _U_ 1 _N_ _S_ "U(P)" {_A_ 1 _U_ 2 _N_ _N_ _N_ _N_} _N_ _N_,
- fromInteger = _A_ 1 _U_ 1 _N_ _S_ "U(PPP)" {_A_ 3 _U_ 222 _N_ _N_ _F_ _IF_ARGS_ 0 3 XXX 3 \ (u0 :: Int#) (u1 :: Int#) (u2 :: ByteArray#) -> case _#_ encodeDouble# [] [u0, u1, u2, 0#] of { _PRIM_ (u3 :: Double#) -> _!_ D# [] [u3] } _N_} _F_ _IF_ARGS_ 0 1 C 4 \ (u0 :: Integer) -> case u0 of { _ALG_ J# (u1 :: Int#) (u2 :: Int#) (u3 :: ByteArray#) -> case _#_ encodeDouble# [] [u1, u2, u3, 0#] of { _PRIM_ (u4 :: Double#) -> _!_ D# [] [u4] }; _NO_DEFLT_ } _N_,
- fromInt = _A_ 1 _U_ 1 _N_ _S_ "U(P)" {_A_ 1 _U_ 2 _N_ _N_ _F_ _IF_ARGS_ 0 1 X 3 \ (u0 :: Int#) -> case _#_ int2Double# [] [u0] of { _PRIM_ (u1 :: Double#) -> _!_ D# [] [u1] } _N_} _F_ _IF_ARGS_ 0 1 C 4 \ (u0 :: Int) -> case u0 of { _ALG_ I# (u1 :: Int#) -> case _#_ int2Double# [] [u1] of { _PRIM_ (u2 :: Double#) -> _!_ D# [] [u2] }; _NO_DEFLT_ } _N_ #-}
+ (+) = { _A_ 2 _U_ 11 _N_ _S_ "U(P)U(P)" {_A_ 2 _U_ 22 _N_ _N_ _F_ _IF_ARGS_ 0 2 XX 3 \ (u0 :: Double#) (u1 :: Double#) -> case _#_ plusDouble# [] [u0, u1] of { _PRIM_ (u2 :: Double#) -> _!_ D# [] [u2] } _N_} _F_ _IF_ARGS_ 0 2 CC 5 \ (u0 :: Double) (u1 :: Double) -> case u0 of { _ALG_ D# (u2 :: Double#) -> case u1 of { _ALG_ D# (u3 :: Double#) -> case _#_ plusDouble# [] [u2, u3] of { _PRIM_ (u4 :: Double#) -> _!_ D# [] [u4] }; _NO_DEFLT_ }; _NO_DEFLT_ } _N_ },
+ (-) = { _A_ 2 _U_ 11 _N_ _S_ "U(P)U(P)" {_A_ 2 _U_ 22 _N_ _N_ _F_ _IF_ARGS_ 0 2 XX 3 \ (u0 :: Double#) (u1 :: Double#) -> case _#_ minusDouble# [] [u0, u1] of { _PRIM_ (u2 :: Double#) -> _!_ D# [] [u2] } _N_} _F_ _IF_ARGS_ 0 2 CC 5 \ (u0 :: Double) (u1 :: Double) -> case u0 of { _ALG_ D# (u2 :: Double#) -> case u1 of { _ALG_ D# (u3 :: Double#) -> case _#_ minusDouble# [] [u2, u3] of { _PRIM_ (u4 :: Double#) -> _!_ D# [] [u4] }; _NO_DEFLT_ }; _NO_DEFLT_ } _N_ },
+ (*) = { _A_ 2 _U_ 11 _N_ _S_ "U(P)U(P)" {_A_ 2 _U_ 22 _N_ _N_ _F_ _IF_ARGS_ 0 2 XX 3 \ (u0 :: Double#) (u1 :: Double#) -> case _#_ timesDouble# [] [u0, u1] of { _PRIM_ (u2 :: Double#) -> _!_ D# [] [u2] } _N_} _F_ _IF_ARGS_ 0 2 CC 5 \ (u0 :: Double) (u1 :: Double) -> case u0 of { _ALG_ D# (u2 :: Double#) -> case u1 of { _ALG_ D# (u3 :: Double#) -> case _#_ timesDouble# [] [u2, u3] of { _PRIM_ (u4 :: Double#) -> _!_ D# [] [u4] }; _NO_DEFLT_ }; _NO_DEFLT_ } _N_ },
+ negate = { _A_ 1 _U_ 1 _N_ _S_ "U(P)" {_A_ 1 _U_ 2 _N_ _N_ _F_ _IF_ARGS_ 0 1 X 3 \ (u0 :: Double#) -> case _#_ negateDouble# [] [u0] of { _PRIM_ (u1 :: Double#) -> _!_ D# [] [u1] } _N_} _F_ _IF_ARGS_ 0 1 C 4 \ (u0 :: Double) -> case u0 of { _ALG_ D# (u1 :: Double#) -> case _#_ negateDouble# [] [u1] of { _PRIM_ (u2 :: Double#) -> _!_ D# [] [u2] }; _NO_DEFLT_ } _N_ },
+ abs = { _A_ 1 _U_ 1 _N_ _S_ "U(P)" {_A_ 1 _U_ 2 _N_ _N_ _N_ _N_} _N_ _N_ },
+ signum = { _A_ 1 _U_ 1 _N_ _S_ "U(P)" {_A_ 1 _U_ 2 _N_ _N_ _N_ _N_} _N_ _N_ },
+ fromInteger = { _A_ 1 _U_ 1 _N_ _S_ "U(PPP)" {_A_ 3 _U_ 222 _N_ _N_ _F_ _IF_ARGS_ 0 3 XXX 3 \ (u0 :: Int#) (u1 :: Int#) (u2 :: ByteArray#) -> case _#_ encodeDouble# [] [u0, u1, u2, 0#] of { _PRIM_ (u3 :: Double#) -> _!_ D# [] [u3] } _N_} _F_ _IF_ARGS_ 0 1 C 4 \ (u0 :: Integer) -> case u0 of { _ALG_ J# (u1 :: Int#) (u2 :: Int#) (u3 :: ByteArray#) -> case _#_ encodeDouble# [] [u1, u2, u3, 0#] of { _PRIM_ (u4 :: Double#) -> _!_ D# [] [u4] }; _NO_DEFLT_ } _N_ },
+ fromInt = { _A_ 1 _U_ 1 _N_ _S_ "U(P)" {_A_ 1 _U_ 2 _N_ _N_ _F_ _IF_ARGS_ 0 1 X 3 \ (u0 :: Int#) -> case _#_ int2Double# [] [u0] of { _PRIM_ (u1 :: Double#) -> _!_ D# [] [u1] } _N_} _F_ _IF_ARGS_ 0 1 C 4 \ (u0 :: Int) -> case u0 of { _ALG_ I# (u1 :: Int#) -> case _#_ int2Double# [] [u1] of { _PRIM_ (u2 :: Double#) -> _!_ D# [] [u2] }; _NO_DEFLT_ } _N_ } #-}
instance Num Float
{-# GHC_PRAGMA _M_ PreludeCore {-dfun-} _A_ 0 _N_ _N_ _N_ _F_ _IF_ARGS_ 0 0 X 11 _!_ _TUP_10 [{{Eq Float}}, {{Text Float}}, (Float -> Float -> Float), (Float -> Float -> Float), (Float -> Float -> Float), (Float -> Float), (Float -> Float), (Float -> Float), (Integer -> Float), (Int -> Float)] [_DFUN_ Eq (Float), _DFUN_ Text (Float), _CONSTM_ Num (+) (Float), _CONSTM_ Num (-) (Float), _CONSTM_ Num (*) (Float), _CONSTM_ Num negate (Float), _CONSTM_ Num abs (Float), _CONSTM_ Num signum (Float), _CONSTM_ Num fromInteger (Float), _CONSTM_ Num fromInt (Float)] _N_
- (+) = _A_ 2 _U_ 11 _N_ _S_ "U(P)U(P)" {_A_ 2 _U_ 22 _N_ _N_ _F_ _IF_ARGS_ 0 2 XX 3 \ (u0 :: Float#) (u1 :: Float#) -> case _#_ plusFloat# [] [u0, u1] of { _PRIM_ (u2 :: Float#) -> _!_ F# [] [u2] } _N_} _F_ _IF_ARGS_ 0 2 CC 5 \ (u0 :: Float) (u1 :: Float) -> case u0 of { _ALG_ F# (u2 :: Float#) -> case u1 of { _ALG_ F# (u3 :: Float#) -> case _#_ plusFloat# [] [u2, u3] of { _PRIM_ (u4 :: Float#) -> _!_ F# [] [u4] }; _NO_DEFLT_ }; _NO_DEFLT_ } _N_,
- (-) = _A_ 2 _U_ 11 _N_ _S_ "U(P)U(P)" {_A_ 2 _U_ 22 _N_ _N_ _F_ _IF_ARGS_ 0 2 XX 3 \ (u0 :: Float#) (u1 :: Float#) -> case _#_ minusFloat# [] [u0, u1] of { _PRIM_ (u2 :: Float#) -> _!_ F# [] [u2] } _N_} _F_ _IF_ARGS_ 0 2 CC 5 \ (u0 :: Float) (u1 :: Float) -> case u0 of { _ALG_ F# (u2 :: Float#) -> case u1 of { _ALG_ F# (u3 :: Float#) -> case _#_ minusFloat# [] [u2, u3] of { _PRIM_ (u4 :: Float#) -> _!_ F# [] [u4] }; _NO_DEFLT_ }; _NO_DEFLT_ } _N_,
- (*) = _A_ 2 _U_ 11 _N_ _S_ "U(P)U(P)" {_A_ 2 _U_ 22 _N_ _N_ _F_ _IF_ARGS_ 0 2 XX 3 \ (u0 :: Float#) (u1 :: Float#) -> case _#_ timesFloat# [] [u0, u1] of { _PRIM_ (u2 :: Float#) -> _!_ F# [] [u2] } _N_} _F_ _IF_ARGS_ 0 2 CC 5 \ (u0 :: Float) (u1 :: Float) -> case u0 of { _ALG_ F# (u2 :: Float#) -> case u1 of { _ALG_ F# (u3 :: Float#) -> case _#_ timesFloat# [] [u2, u3] of { _PRIM_ (u4 :: Float#) -> _!_ F# [] [u4] }; _NO_DEFLT_ }; _NO_DEFLT_ } _N_,
- negate = _A_ 1 _U_ 1 _N_ _S_ "U(P)" {_A_ 1 _U_ 2 _N_ _N_ _F_ _IF_ARGS_ 0 1 X 3 \ (u0 :: Float#) -> case _#_ negateFloat# [] [u0] of { _PRIM_ (u1 :: Float#) -> _!_ F# [] [u1] } _N_} _F_ _IF_ARGS_ 0 1 C 4 \ (u0 :: Float) -> case u0 of { _ALG_ F# (u1 :: Float#) -> case _#_ negateFloat# [] [u1] of { _PRIM_ (u2 :: Float#) -> _!_ F# [] [u2] }; _NO_DEFLT_ } _N_,
- abs = _A_ 1 _U_ 1 _N_ _S_ "U(P)" {_A_ 1 _U_ 2 _N_ _N_ _N_ _N_} _N_ _N_,
- signum = _A_ 1 _U_ 1 _N_ _S_ "U(P)" {_A_ 1 _U_ 2 _N_ _N_ _N_ _N_} _N_ _N_,
- fromInteger = _A_ 1 _U_ 1 _N_ _S_ "U(PPP)" {_A_ 3 _U_ 222 _N_ _N_ _F_ _IF_ARGS_ 0 3 XXX 3 \ (u0 :: Int#) (u1 :: Int#) (u2 :: ByteArray#) -> case _#_ encodeFloat# [] [u0, u1, u2, 0#] of { _PRIM_ (u3 :: Float#) -> _!_ F# [] [u3] } _N_} _F_ _IF_ARGS_ 0 1 C 4 \ (u0 :: Integer) -> case u0 of { _ALG_ J# (u1 :: Int#) (u2 :: Int#) (u3 :: ByteArray#) -> case _#_ encodeFloat# [] [u1, u2, u3, 0#] of { _PRIM_ (u4 :: Float#) -> _!_ F# [] [u4] }; _NO_DEFLT_ } _N_,
- fromInt = _A_ 1 _U_ 1 _N_ _S_ "U(P)" {_A_ 1 _U_ 2 _N_ _N_ _F_ _IF_ARGS_ 0 1 X 3 \ (u0 :: Int#) -> case _#_ int2Float# [] [u0] of { _PRIM_ (u1 :: Float#) -> _!_ F# [] [u1] } _N_} _F_ _IF_ARGS_ 0 1 C 4 \ (u0 :: Int) -> case u0 of { _ALG_ I# (u1 :: Int#) -> case _#_ int2Float# [] [u1] of { _PRIM_ (u2 :: Float#) -> _!_ F# [] [u2] }; _NO_DEFLT_ } _N_ #-}
+ (+) = { _A_ 2 _U_ 11 _N_ _S_ "U(P)U(P)" {_A_ 2 _U_ 22 _N_ _N_ _F_ _IF_ARGS_ 0 2 XX 3 \ (u0 :: Float#) (u1 :: Float#) -> case _#_ plusFloat# [] [u0, u1] of { _PRIM_ (u2 :: Float#) -> _!_ F# [] [u2] } _N_} _F_ _IF_ARGS_ 0 2 CC 5 \ (u0 :: Float) (u1 :: Float) -> case u0 of { _ALG_ F# (u2 :: Float#) -> case u1 of { _ALG_ F# (u3 :: Float#) -> case _#_ plusFloat# [] [u2, u3] of { _PRIM_ (u4 :: Float#) -> _!_ F# [] [u4] }; _NO_DEFLT_ }; _NO_DEFLT_ } _N_ },
+ (-) = { _A_ 2 _U_ 11 _N_ _S_ "U(P)U(P)" {_A_ 2 _U_ 22 _N_ _N_ _F_ _IF_ARGS_ 0 2 XX 3 \ (u0 :: Float#) (u1 :: Float#) -> case _#_ minusFloat# [] [u0, u1] of { _PRIM_ (u2 :: Float#) -> _!_ F# [] [u2] } _N_} _F_ _IF_ARGS_ 0 2 CC 5 \ (u0 :: Float) (u1 :: Float) -> case u0 of { _ALG_ F# (u2 :: Float#) -> case u1 of { _ALG_ F# (u3 :: Float#) -> case _#_ minusFloat# [] [u2, u3] of { _PRIM_ (u4 :: Float#) -> _!_ F# [] [u4] }; _NO_DEFLT_ }; _NO_DEFLT_ } _N_ },
+ (*) = { _A_ 2 _U_ 11 _N_ _S_ "U(P)U(P)" {_A_ 2 _U_ 22 _N_ _N_ _F_ _IF_ARGS_ 0 2 XX 3 \ (u0 :: Float#) (u1 :: Float#) -> case _#_ timesFloat# [] [u0, u1] of { _PRIM_ (u2 :: Float#) -> _!_ F# [] [u2] } _N_} _F_ _IF_ARGS_ 0 2 CC 5 \ (u0 :: Float) (u1 :: Float) -> case u0 of { _ALG_ F# (u2 :: Float#) -> case u1 of { _ALG_ F# (u3 :: Float#) -> case _#_ timesFloat# [] [u2, u3] of { _PRIM_ (u4 :: Float#) -> _!_ F# [] [u4] }; _NO_DEFLT_ }; _NO_DEFLT_ } _N_ },
+ negate = { _A_ 1 _U_ 1 _N_ _S_ "U(P)" {_A_ 1 _U_ 2 _N_ _N_ _F_ _IF_ARGS_ 0 1 X 3 \ (u0 :: Float#) -> case _#_ negateFloat# [] [u0] of { _PRIM_ (u1 :: Float#) -> _!_ F# [] [u1] } _N_} _F_ _IF_ARGS_ 0 1 C 4 \ (u0 :: Float) -> case u0 of { _ALG_ F# (u1 :: Float#) -> case _#_ negateFloat# [] [u1] of { _PRIM_ (u2 :: Float#) -> _!_ F# [] [u2] }; _NO_DEFLT_ } _N_ },
+ abs = { _A_ 1 _U_ 1 _N_ _S_ "U(P)" {_A_ 1 _U_ 2 _N_ _N_ _N_ _N_} _N_ _N_ },
+ signum = { _A_ 1 _U_ 1 _N_ _S_ "U(P)" {_A_ 1 _U_ 2 _N_ _N_ _N_ _N_} _N_ _N_ },
+ fromInteger = { _A_ 1 _U_ 1 _N_ _S_ "U(PPP)" {_A_ 3 _U_ 222 _N_ _N_ _F_ _IF_ARGS_ 0 3 XXX 3 \ (u0 :: Int#) (u1 :: Int#) (u2 :: ByteArray#) -> case _#_ encodeFloat# [] [u0, u1, u2, 0#] of { _PRIM_ (u3 :: Float#) -> _!_ F# [] [u3] } _N_} _F_ _IF_ARGS_ 0 1 C 4 \ (u0 :: Integer) -> case u0 of { _ALG_ J# (u1 :: Int#) (u2 :: Int#) (u3 :: ByteArray#) -> case _#_ encodeFloat# [] [u1, u2, u3, 0#] of { _PRIM_ (u4 :: Float#) -> _!_ F# [] [u4] }; _NO_DEFLT_ } _N_ },
+ fromInt = { _A_ 1 _U_ 1 _N_ _S_ "U(P)" {_A_ 1 _U_ 2 _N_ _N_ _F_ _IF_ARGS_ 0 1 X 3 \ (u0 :: Int#) -> case _#_ int2Float# [] [u0] of { _PRIM_ (u1 :: Float#) -> _!_ F# [] [u1] } _N_} _F_ _IF_ARGS_ 0 1 C 4 \ (u0 :: Int) -> case u0 of { _ALG_ I# (u1 :: Int#) -> case _#_ int2Float# [] [u1] of { _PRIM_ (u2 :: Float#) -> _!_ F# [] [u2] }; _NO_DEFLT_ } _N_ } #-}
instance Num Int
{-# GHC_PRAGMA _M_ PreludeCore {-dfun-} _A_ 0 _N_ _N_ _N_ _F_ _IF_ARGS_ 0 0 X 11 _!_ _TUP_10 [{{Eq Int}}, {{Text Int}}, (Int -> Int -> Int), (Int -> Int -> Int), (Int -> Int -> Int), (Int -> Int), (Int -> Int), (Int -> Int), (Integer -> Int), (Int -> Int)] [_DFUN_ Eq (Int), _DFUN_ Text (Int), _CONSTM_ Num (+) (Int), _CONSTM_ Num (-) (Int), _CONSTM_ Num (*) (Int), _CONSTM_ Num negate (Int), _CONSTM_ Num abs (Int), _CONSTM_ Num signum (Int), _CONSTM_ Num fromInteger (Int), _CONSTM_ Num fromInt (Int)] _N_
- (+) = _A_ 2 _U_ 11 _N_ _S_ "U(P)U(P)" {_A_ 2 _U_ 22 _N_ _N_ _F_ _IF_ARGS_ 0 2 XX 3 \ (u0 :: Int#) (u1 :: Int#) -> case _#_ plusInt# [] [u0, u1] of { _PRIM_ (u2 :: Int#) -> _!_ I# [] [u2] } _N_} _F_ _IF_ARGS_ 0 2 CC 5 \ (u0 :: Int) (u1 :: Int) -> case u0 of { _ALG_ I# (u2 :: Int#) -> case u1 of { _ALG_ I# (u3 :: Int#) -> case _#_ plusInt# [] [u2, u3] of { _PRIM_ (u4 :: Int#) -> _!_ I# [] [u4] }; _NO_DEFLT_ }; _NO_DEFLT_ } _N_,
- (-) = _A_ 2 _U_ 11 _N_ _S_ "U(P)U(P)" {_A_ 2 _U_ 22 _N_ _N_ _F_ _IF_ARGS_ 0 2 XX 3 \ (u0 :: Int#) (u1 :: Int#) -> case _#_ minusInt# [] [u0, u1] of { _PRIM_ (u2 :: Int#) -> _!_ I# [] [u2] } _N_} _F_ _IF_ARGS_ 0 2 CC 5 \ (u0 :: Int) (u1 :: Int) -> case u0 of { _ALG_ I# (u2 :: Int#) -> case u1 of { _ALG_ I# (u3 :: Int#) -> case _#_ minusInt# [] [u2, u3] of { _PRIM_ (u4 :: Int#) -> _!_ I# [] [u4] }; _NO_DEFLT_ }; _NO_DEFLT_ } _N_,
- (*) = _A_ 2 _U_ 11 _N_ _S_ "U(P)U(P)" {_A_ 2 _U_ 22 _N_ _N_ _F_ _IF_ARGS_ 0 2 XX 3 \ (u0 :: Int#) (u1 :: Int#) -> case _#_ timesInt# [] [u0, u1] of { _PRIM_ (u2 :: Int#) -> _!_ I# [] [u2] } _N_} _F_ _IF_ARGS_ 0 2 CC 5 \ (u0 :: Int) (u1 :: Int) -> case u0 of { _ALG_ I# (u2 :: Int#) -> case u1 of { _ALG_ I# (u3 :: Int#) -> case _#_ timesInt# [] [u2, u3] of { _PRIM_ (u4 :: Int#) -> _!_ I# [] [u4] }; _NO_DEFLT_ }; _NO_DEFLT_ } _N_,
- negate = _A_ 1 _U_ 1 _N_ _S_ "U(P)" {_A_ 1 _U_ 2 _N_ _N_ _F_ _IF_ARGS_ 0 1 X 3 \ (u0 :: Int#) -> case _#_ negateInt# [] [u0] of { _PRIM_ (u1 :: Int#) -> _!_ I# [] [u1] } _N_} _F_ _IF_ARGS_ 0 1 C 4 \ (u0 :: Int) -> case u0 of { _ALG_ I# (u1 :: Int#) -> case _#_ negateInt# [] [u1] of { _PRIM_ (u2 :: Int#) -> _!_ I# [] [u2] }; _NO_DEFLT_ } _N_,
- abs = _A_ 1 _U_ 1 _N_ _S_ "U(P)" {_A_ 1 _U_ 2 _N_ _N_ _N_ _N_} _N_ _N_,
- signum = _A_ 1 _U_ 1 _N_ _S_ "U(P)" {_A_ 1 _U_ 2 _N_ _N_ _N_ _N_} _N_ _N_,
- fromInteger = _A_ 1 _U_ 1 _N_ _S_ "U(PPP)" {_A_ 3 _U_ 222 _N_ _N_ _F_ _IF_ARGS_ 0 3 XXX 3 \ (u0 :: Int#) (u1 :: Int#) (u2 :: ByteArray#) -> case _#_ integer2Int# [] [u0, u1, u2] of { _PRIM_ (u3 :: Int#) -> _!_ I# [] [u3] } _N_} _F_ _IF_ARGS_ 0 1 C 4 \ (u0 :: Integer) -> case u0 of { _ALG_ J# (u1 :: Int#) (u2 :: Int#) (u3 :: ByteArray#) -> case _#_ integer2Int# [] [u1, u2, u3] of { _PRIM_ (u4 :: Int#) -> _!_ I# [] [u4] }; _NO_DEFLT_ } _N_,
- fromInt = _A_ 1 _U_ 1 _N_ _S_ "U(P)" {_A_ 1 _U_ 2 _N_ _N_ _F_ _IF_ARGS_ 0 1 X 2 \ (u0 :: Int#) -> _!_ I# [] [u0] _N_} _F_ _IF_ARGS_ 0 1 X 1 \ (u0 :: Int) -> u0 _N_ #-}
+ (+) = { _A_ 2 _U_ 11 _N_ _S_ "U(P)U(P)" {_A_ 2 _U_ 22 _N_ _N_ _F_ _IF_ARGS_ 0 2 XX 3 \ (u0 :: Int#) (u1 :: Int#) -> case _#_ plusInt# [] [u0, u1] of { _PRIM_ (u2 :: Int#) -> _!_ I# [] [u2] } _N_} _F_ _IF_ARGS_ 0 2 CC 5 \ (u0 :: Int) (u1 :: Int) -> case u0 of { _ALG_ I# (u2 :: Int#) -> case u1 of { _ALG_ I# (u3 :: Int#) -> case _#_ plusInt# [] [u2, u3] of { _PRIM_ (u4 :: Int#) -> _!_ I# [] [u4] }; _NO_DEFLT_ }; _NO_DEFLT_ } _N_ },
+ (-) = { _A_ 2 _U_ 11 _N_ _S_ "U(P)U(P)" {_A_ 2 _U_ 22 _N_ _N_ _F_ _IF_ARGS_ 0 2 XX 3 \ (u0 :: Int#) (u1 :: Int#) -> case _#_ minusInt# [] [u0, u1] of { _PRIM_ (u2 :: Int#) -> _!_ I# [] [u2] } _N_} _F_ _IF_ARGS_ 0 2 CC 5 \ (u0 :: Int) (u1 :: Int) -> case u0 of { _ALG_ I# (u2 :: Int#) -> case u1 of { _ALG_ I# (u3 :: Int#) -> case _#_ minusInt# [] [u2, u3] of { _PRIM_ (u4 :: Int#) -> _!_ I# [] [u4] }; _NO_DEFLT_ }; _NO_DEFLT_ } _N_ },
+ (*) = { _A_ 2 _U_ 11 _N_ _S_ "U(P)U(P)" {_A_ 2 _U_ 22 _N_ _N_ _F_ _IF_ARGS_ 0 2 XX 3 \ (u0 :: Int#) (u1 :: Int#) -> case _#_ timesInt# [] [u0, u1] of { _PRIM_ (u2 :: Int#) -> _!_ I# [] [u2] } _N_} _F_ _IF_ARGS_ 0 2 CC 5 \ (u0 :: Int) (u1 :: Int) -> case u0 of { _ALG_ I# (u2 :: Int#) -> case u1 of { _ALG_ I# (u3 :: Int#) -> case _#_ timesInt# [] [u2, u3] of { _PRIM_ (u4 :: Int#) -> _!_ I# [] [u4] }; _NO_DEFLT_ }; _NO_DEFLT_ } _N_ },
+ negate = { _A_ 1 _U_ 1 _N_ _S_ "U(P)" {_A_ 1 _U_ 2 _N_ _N_ _F_ _IF_ARGS_ 0 1 X 3 \ (u0 :: Int#) -> case _#_ negateInt# [] [u0] of { _PRIM_ (u1 :: Int#) -> _!_ I# [] [u1] } _N_} _F_ _IF_ARGS_ 0 1 C 4 \ (u0 :: Int) -> case u0 of { _ALG_ I# (u1 :: Int#) -> case _#_ negateInt# [] [u1] of { _PRIM_ (u2 :: Int#) -> _!_ I# [] [u2] }; _NO_DEFLT_ } _N_ },
+ abs = { _A_ 1 _U_ 1 _N_ _S_ "U(P)" {_A_ 1 _U_ 2 _N_ _N_ _N_ _N_} _N_ _N_ },
+ signum = { _A_ 1 _U_ 1 _N_ _S_ "U(P)" {_A_ 1 _U_ 2 _N_ _N_ _N_ _N_} _N_ _N_ },
+ fromInteger = { _A_ 1 _U_ 1 _N_ _S_ "U(PPP)" {_A_ 3 _U_ 222 _N_ _N_ _F_ _IF_ARGS_ 0 3 XXX 3 \ (u0 :: Int#) (u1 :: Int#) (u2 :: ByteArray#) -> case _#_ integer2Int# [] [u0, u1, u2] of { _PRIM_ (u3 :: Int#) -> _!_ I# [] [u3] } _N_} _F_ _IF_ARGS_ 0 1 C 4 \ (u0 :: Integer) -> case u0 of { _ALG_ J# (u1 :: Int#) (u2 :: Int#) (u3 :: ByteArray#) -> case _#_ integer2Int# [] [u1, u2, u3] of { _PRIM_ (u4 :: Int#) -> _!_ I# [] [u4] }; _NO_DEFLT_ } _N_ },
+ fromInt = { _A_ 1 _U_ 1 _N_ _S_ "U(P)" {_A_ 1 _U_ 2 _N_ _N_ _F_ _IF_ARGS_ 0 1 X 2 \ (u0 :: Int#) -> _!_ I# [] [u0] _N_} _F_ _IF_ARGS_ 0 1 X 1 \ (u0 :: Int) -> u0 _N_ } #-}
instance Num Integer
{-# GHC_PRAGMA _M_ PreludeCore {-dfun-} _A_ 0 _N_ _N_ _N_ _F_ _IF_ARGS_ 0 0 X 11 _!_ _TUP_10 [{{Eq Integer}}, {{Text Integer}}, (Integer -> Integer -> Integer), (Integer -> Integer -> Integer), (Integer -> Integer -> Integer), (Integer -> Integer), (Integer -> Integer), (Integer -> Integer), (Integer -> Integer), (Int -> Integer)] [_DFUN_ Eq (Integer), _DFUN_ Text (Integer), _CONSTM_ Num (+) (Integer), _CONSTM_ Num (-) (Integer), _CONSTM_ Num (*) (Integer), _CONSTM_ Num negate (Integer), _CONSTM_ Num abs (Integer), _CONSTM_ Num signum (Integer), _CONSTM_ Num fromInteger (Integer), _CONSTM_ Num fromInt (Integer)] _N_
- (+) = _A_ 2 _U_ 11 _N_ _S_ "U(PPP)U(PPP)" {_A_ 4 _U_ 2221 _N_ _N_ _F_ _IF_ARGS_ 0 4 XXXC 5 \ (u0 :: Int#) (u1 :: Int#) (u2 :: ByteArray#) (u3 :: Integer) -> case u3 of { _ALG_ J# (u4 :: Int#) (u5 :: Int#) (u6 :: ByteArray#) -> _#_ plusInteger# [] [u0, u1, u2, u4, u5, u6]; _NO_DEFLT_ } _N_} _F_ _IF_ARGS_ 0 2 CC 6 \ (u0 :: Integer) (u1 :: Integer) -> case u0 of { _ALG_ J# (u2 :: Int#) (u3 :: Int#) (u4 :: ByteArray#) -> case u1 of { _ALG_ J# (u5 :: Int#) (u6 :: Int#) (u7 :: ByteArray#) -> _#_ plusInteger# [] [u2, u3, u4, u5, u6, u7]; _NO_DEFLT_ }; _NO_DEFLT_ } _N_,
- (-) = _A_ 2 _U_ 11 _N_ _S_ "U(PPP)U(PPP)" {_A_ 4 _U_ 2221 _N_ _N_ _F_ _IF_ARGS_ 0 4 XXXC 5 \ (u0 :: Int#) (u1 :: Int#) (u2 :: ByteArray#) (u3 :: Integer) -> case u3 of { _ALG_ J# (u4 :: Int#) (u5 :: Int#) (u6 :: ByteArray#) -> _#_ minusInteger# [] [u0, u1, u2, u4, u5, u6]; _NO_DEFLT_ } _N_} _F_ _IF_ARGS_ 0 2 CC 6 \ (u0 :: Integer) (u1 :: Integer) -> case u0 of { _ALG_ J# (u2 :: Int#) (u3 :: Int#) (u4 :: ByteArray#) -> case u1 of { _ALG_ J# (u5 :: Int#) (u6 :: Int#) (u7 :: ByteArray#) -> _#_ minusInteger# [] [u2, u3, u4, u5, u6, u7]; _NO_DEFLT_ }; _NO_DEFLT_ } _N_,
- (*) = _A_ 2 _U_ 11 _N_ _S_ "U(PPP)U(PPP)" {_A_ 4 _U_ 2221 _N_ _N_ _F_ _IF_ARGS_ 0 4 XXXC 5 \ (u0 :: Int#) (u1 :: Int#) (u2 :: ByteArray#) (u3 :: Integer) -> case u3 of { _ALG_ J# (u4 :: Int#) (u5 :: Int#) (u6 :: ByteArray#) -> _#_ timesInteger# [] [u0, u1, u2, u4, u5, u6]; _NO_DEFLT_ } _N_} _F_ _IF_ARGS_ 0 2 CC 6 \ (u0 :: Integer) (u1 :: Integer) -> case u0 of { _ALG_ J# (u2 :: Int#) (u3 :: Int#) (u4 :: ByteArray#) -> case u1 of { _ALG_ J# (u5 :: Int#) (u6 :: Int#) (u7 :: ByteArray#) -> _#_ timesInteger# [] [u2, u3, u4, u5, u6, u7]; _NO_DEFLT_ }; _NO_DEFLT_ } _N_,
- negate = _A_ 1 _U_ 1 _N_ _S_ "U(PPP)" {_A_ 3 _U_ 222 _N_ _N_ _F_ _IF_ARGS_ 0 3 XXX 4 \ (u0 :: Int#) (u1 :: Int#) (u2 :: ByteArray#) -> _#_ negateInteger# [] [u0, u1, u2] _N_} _F_ _IF_ARGS_ 0 1 C 5 \ (u0 :: Integer) -> case u0 of { _ALG_ J# (u1 :: Int#) (u2 :: Int#) (u3 :: ByteArray#) -> _#_ negateInteger# [] [u1, u2, u3]; _NO_DEFLT_ } _N_,
- abs = _A_ 1 _U_ 1 _N_ _S_ "U(PPP)" {_A_ 3 _U_ 222 _N_ _N_ _N_ _N_} _N_ _N_,
- signum = _A_ 1 _U_ 1 _N_ _S_ "U(PPP)" {_A_ 3 _U_ 222 _N_ _N_ _N_ _N_} _N_ _N_,
- fromInteger = _A_ 1 _U_ 1 _N_ _S_ "U(PPP)" {_A_ 3 _U_ 222 _N_ _N_ _F_ _IF_ARGS_ 0 3 XXX 4 \ (u0 :: Int#) (u1 :: Int#) (u2 :: ByteArray#) -> _!_ J# [] [u0, u1, u2] _N_} _F_ _IF_ARGS_ 0 1 X 1 \ (u0 :: Integer) -> u0 _N_,
- fromInt = _A_ 1 _U_ 1 _N_ _S_ "U(P)" {_A_ 1 _U_ 2 _N_ _N_ _F_ _IF_ARGS_ 0 1 X 1 \ (u0 :: Int#) -> _#_ int2Integer# [] [u0] _N_} _F_ _IF_ARGS_ 0 1 C 2 \ (u0 :: Int) -> case u0 of { _ALG_ I# (u1 :: Int#) -> _#_ int2Integer# [] [u1]; _NO_DEFLT_ } _N_ #-}
+ (+) = { _A_ 2 _U_ 11 _N_ _S_ "U(PPP)U(PPP)" {_A_ 4 _U_ 2221 _N_ _N_ _F_ _IF_ARGS_ 0 4 XXXC 5 \ (u0 :: Int#) (u1 :: Int#) (u2 :: ByteArray#) (u3 :: Integer) -> case u3 of { _ALG_ J# (u4 :: Int#) (u5 :: Int#) (u6 :: ByteArray#) -> _#_ plusInteger# [] [u0, u1, u2, u4, u5, u6]; _NO_DEFLT_ } _N_} _F_ _IF_ARGS_ 0 2 CC 6 \ (u0 :: Integer) (u1 :: Integer) -> case u0 of { _ALG_ J# (u2 :: Int#) (u3 :: Int#) (u4 :: ByteArray#) -> case u1 of { _ALG_ J# (u5 :: Int#) (u6 :: Int#) (u7 :: ByteArray#) -> _#_ plusInteger# [] [u2, u3, u4, u5, u6, u7]; _NO_DEFLT_ }; _NO_DEFLT_ } _N_ },
+ (-) = { _A_ 2 _U_ 11 _N_ _S_ "U(PPP)U(PPP)" {_A_ 4 _U_ 2221 _N_ _N_ _F_ _IF_ARGS_ 0 4 XXXC 5 \ (u0 :: Int#) (u1 :: Int#) (u2 :: ByteArray#) (u3 :: Integer) -> case u3 of { _ALG_ J# (u4 :: Int#) (u5 :: Int#) (u6 :: ByteArray#) -> _#_ minusInteger# [] [u0, u1, u2, u4, u5, u6]; _NO_DEFLT_ } _N_} _F_ _IF_ARGS_ 0 2 CC 6 \ (u0 :: Integer) (u1 :: Integer) -> case u0 of { _ALG_ J# (u2 :: Int#) (u3 :: Int#) (u4 :: ByteArray#) -> case u1 of { _ALG_ J# (u5 :: Int#) (u6 :: Int#) (u7 :: ByteArray#) -> _#_ minusInteger# [] [u2, u3, u4, u5, u6, u7]; _NO_DEFLT_ }; _NO_DEFLT_ } _N_ },
+ (*) = { _A_ 2 _U_ 11 _N_ _S_ "U(PPP)U(PPP)" {_A_ 4 _U_ 2221 _N_ _N_ _F_ _IF_ARGS_ 0 4 XXXC 5 \ (u0 :: Int#) (u1 :: Int#) (u2 :: ByteArray#) (u3 :: Integer) -> case u3 of { _ALG_ J# (u4 :: Int#) (u5 :: Int#) (u6 :: ByteArray#) -> _#_ timesInteger# [] [u0, u1, u2, u4, u5, u6]; _NO_DEFLT_ } _N_} _F_ _IF_ARGS_ 0 2 CC 6 \ (u0 :: Integer) (u1 :: Integer) -> case u0 of { _ALG_ J# (u2 :: Int#) (u3 :: Int#) (u4 :: ByteArray#) -> case u1 of { _ALG_ J# (u5 :: Int#) (u6 :: Int#) (u7 :: ByteArray#) -> _#_ timesInteger# [] [u2, u3, u4, u5, u6, u7]; _NO_DEFLT_ }; _NO_DEFLT_ } _N_ },
+ negate = { _A_ 1 _U_ 1 _N_ _S_ "U(PPP)" {_A_ 3 _U_ 222 _N_ _N_ _F_ _IF_ARGS_ 0 3 XXX 4 \ (u0 :: Int#) (u1 :: Int#) (u2 :: ByteArray#) -> _#_ negateInteger# [] [u0, u1, u2] _N_} _F_ _IF_ARGS_ 0 1 C 5 \ (u0 :: Integer) -> case u0 of { _ALG_ J# (u1 :: Int#) (u2 :: Int#) (u3 :: ByteArray#) -> _#_ negateInteger# [] [u1, u2, u3]; _NO_DEFLT_ } _N_ },
+ abs = { _A_ 1 _U_ 1 _N_ _S_ "U(PPP)" {_A_ 3 _U_ 222 _N_ _N_ _N_ _N_} _N_ _N_ },
+ signum = { _A_ 1 _U_ 1 _N_ _S_ "U(PPP)" {_A_ 3 _U_ 222 _N_ _N_ _N_ _N_} _N_ _N_ },
+ fromInteger = { _A_ 1 _U_ 1 _N_ _S_ "U(PPP)" {_A_ 3 _U_ 222 _N_ _N_ _F_ _IF_ARGS_ 0 3 XXX 4 \ (u0 :: Int#) (u1 :: Int#) (u2 :: ByteArray#) -> _!_ J# [] [u0, u1, u2] _N_} _F_ _IF_ARGS_ 0 1 X 1 \ (u0 :: Integer) -> u0 _N_ },
+ fromInt = { _A_ 1 _U_ 1 _N_ _S_ "U(P)" {_A_ 1 _U_ 2 _N_ _N_ _F_ _IF_ARGS_ 0 1 X 1 \ (u0 :: Int#) -> _#_ int2Integer# [] [u0] _N_} _F_ _IF_ARGS_ 0 1 C 2 \ (u0 :: Int) -> case u0 of { _ALG_ I# (u1 :: Int#) -> _#_ int2Integer# [] [u1]; _NO_DEFLT_ } _N_ } #-}
instance Integral a => Num (Ratio a)
{-# GHC_PRAGMA _M_ PreludeRatio {-dfun-} _A_ 3 _U_ 222 _N_ _N_ _N_ _N_ #-}
instance Num (Ratio Integer)
{-# GHC_PRAGMA _M_ PreludeRatio {-dfun-} _A_ 0 _N_ _N_ _N_ _F_ _IF_ARGS_ 0 0 X 11 _!_ _TUP_10 [{{Eq (Ratio Integer)}}, {{Text (Ratio Integer)}}, (Ratio Integer -> Ratio Integer -> Ratio Integer), (Ratio Integer -> Ratio Integer -> Ratio Integer), (Ratio Integer -> Ratio Integer -> Ratio Integer), (Ratio Integer -> Ratio Integer), (Ratio Integer -> Ratio Integer), (Ratio Integer -> Ratio Integer), (Integer -> Ratio Integer), (Int -> Ratio Integer)] [_DFUN_ Eq (Ratio Integer), _DFUN_ Text (Ratio Integer), _CONSTM_ Num (+) (Ratio Integer), _CONSTM_ Num (-) (Ratio Integer), _CONSTM_ Num (*) (Ratio Integer), _CONSTM_ Num negate (Ratio Integer), _CONSTM_ Num abs (Ratio Integer), _CONSTM_ Num signum (Ratio Integer), _CONSTM_ Num fromInteger (Ratio Integer), _CONSTM_ Num fromInt (Ratio Integer)] _N_
- (+) = _A_ 2 _U_ 11 _N_ _S_ "U(LU(PPP))U(LU(PPP))" {_A_ 5 _U_ 12221 _N_ _N_ _N_ _N_} _N_ _N_,
- (-) = _A_ 2 _U_ 11 _N_ _S_ "U(LU(PPP))U(LU(PPP))" {_A_ 5 _U_ 12221 _N_ _N_ _N_ _N_} _N_ _N_,
- (*) = _A_ 2 _U_ 11 _N_ _S_ "U(LU(PPP))U(LU(PPP))" {_A_ 5 _U_ 22221 _N_ _N_ _N_ _N_} _N_ _N_,
- negate = _A_ 1 _U_ 1 _N_ _S_ "U(LL)" {_A_ 2 _U_ 22 _N_ _N_ _N_ _N_} _N_ _N_,
- abs = _A_ 1 _U_ 1 _N_ _S_ "U(LL)" {_A_ 2 _U_ 12 _N_ _N_ _N_ _N_} _N_ _N_,
- signum = _A_ 1 _U_ 1 _N_ _S_ "U(LA)" {_A_ 1 _U_ 1 _N_ _N_ _N_ _N_} _N_ _N_,
- fromInteger = _A_ 1 _U_ 2 _N_ _N_ _N_ _N_,
- fromInt = _A_ 1 _U_ 1 _N_ _N_ _N_ _N_ #-}
+ (+) = { _A_ 2 _U_ 11 _N_ _S_ "U(LU(PPP))U(LU(PPP))" {_A_ 5 _U_ 12221 _N_ _N_ _N_ _N_} _N_ _N_ },
+ (-) = { _A_ 2 _U_ 11 _N_ _S_ "U(LU(PPP))U(LU(PPP))" {_A_ 5 _U_ 12221 _N_ _N_ _N_ _N_} _N_ _N_ },
+ (*) = { _A_ 2 _U_ 11 _N_ _S_ "U(LU(PPP))U(LU(PPP))" {_A_ 5 _U_ 22221 _N_ _N_ _N_ _N_} _N_ _N_ },
+ negate = { _A_ 1 _U_ 1 _N_ _S_ "U(LL)" {_A_ 2 _U_ 22 _N_ _N_ _N_ _N_} _N_ _N_ },
+ abs = { _A_ 1 _U_ 1 _N_ _S_ "U(LL)" {_A_ 2 _U_ 12 _N_ _N_ _N_ _N_} _N_ _N_ },
+ signum = { _A_ 1 _U_ 1 _N_ _S_ "U(LA)" {_A_ 1 _U_ 1 _N_ _N_ _N_ _N_} _N_ _N_ },
+ fromInteger = { _A_ 1 _U_ 2 _N_ _N_ _F_ _IF_ARGS_ 0 1 X 3 \ (u0 :: Integer) -> _!_ (:%) [Integer] [u0, _SPEC_ _ORIG_ PreludeCore __i1 [ (Integer) ]] _N_ },
+ fromInt = { _A_ 1 _U_ 1 _N_ _N_ _N_ _N_ } #-}
instance Ord ()
{-# GHC_PRAGMA _M_ PreludeBuiltin {-dfun-} _A_ 0 _N_ _N_ _N_ _F_ _IF_ARGS_ 0 0 X 9 _!_ _TUP_8 [{{Eq ()}}, (() -> () -> Bool), (() -> () -> Bool), (() -> () -> Bool), (() -> () -> Bool), (() -> () -> ()), (() -> () -> ()), (() -> () -> _CMP_TAG)] [_DFUN_ Eq (()), _CONSTM_ Ord (<) (()), _CONSTM_ Ord (<=) (()), _CONSTM_ Ord (>=) (()), _CONSTM_ Ord (>) (()), _CONSTM_ Ord max (()), _CONSTM_ Ord min (()), _CONSTM_ Ord _tagCmp (())] _N_
- (<) = _A_ 2 _U_ 11 _N_ _S_ "EE" _F_ _IF_ARGS_ 0 2 CC 3 \ (u0 :: ()) (u1 :: ()) -> case u0 of { _ALG_ _TUP_0 -> case u1 of { _ALG_ _TUP_0 -> _!_ False [] []; _NO_DEFLT_ }; _NO_DEFLT_ } _N_,
- (<=) = _A_ 2 _U_ 11 _N_ _S_ "EE" _F_ _IF_ARGS_ 0 2 CC 3 \ (u0 :: ()) (u1 :: ()) -> case u0 of { _ALG_ _TUP_0 -> case u1 of { _ALG_ _TUP_0 -> _!_ True [] []; _NO_DEFLT_ }; _NO_DEFLT_ } _N_,
- (>=) = _A_ 2 _U_ 11 _N_ _S_ "EE" _F_ _IF_ARGS_ 0 2 CC 3 \ (u0 :: ()) (u1 :: ()) -> case u0 of { _ALG_ _TUP_0 -> case u1 of { _ALG_ _TUP_0 -> _!_ True [] []; _NO_DEFLT_ }; _NO_DEFLT_ } _N_,
- (>) = _A_ 2 _U_ 11 _N_ _S_ "EE" _F_ _IF_ARGS_ 0 2 CC 3 \ (u0 :: ()) (u1 :: ()) -> case u0 of { _ALG_ _TUP_0 -> case u1 of { _ALG_ _TUP_0 -> _!_ False [] []; _NO_DEFLT_ }; _NO_DEFLT_ } _N_,
- max = _A_ 2 _U_ 11 _N_ _S_ "EE" _F_ _IF_ARGS_ 0 2 CX 2 \ (u0 :: ()) (u1 :: ()) -> case u0 of { _ALG_ _TUP_0 -> u1; _NO_DEFLT_ } _N_,
- min = _A_ 2 _U_ 11 _N_ _S_ "EE" _F_ _IF_ARGS_ 0 2 CX 2 \ (u0 :: ()) (u1 :: ()) -> case u0 of { _ALG_ _TUP_0 -> u1; _NO_DEFLT_ } _N_,
- _tagCmp = _A_ 2 _U_ 11 _N_ _S_ "EE" _F_ _IF_ARGS_ 0 2 CC 3 \ (u0 :: ()) (u1 :: ()) -> case u0 of { _ALG_ _TUP_0 -> case u1 of { _ALG_ _TUP_0 -> _!_ _EQ [] []; _NO_DEFLT_ }; _NO_DEFLT_ } _N_ #-}
+ (<) = { _A_ 2 _U_ 11 _N_ _S_ "EE" _F_ _IF_ARGS_ 0 2 CC 3 \ (u0 :: ()) (u1 :: ()) -> case u0 of { _ALG_ _TUP_0 -> case u1 of { _ALG_ _TUP_0 -> _!_ False [] []; _NO_DEFLT_ }; _NO_DEFLT_ } _N_ },
+ (<=) = { _A_ 2 _U_ 11 _N_ _S_ "EE" _F_ _IF_ARGS_ 0 2 CC 3 \ (u0 :: ()) (u1 :: ()) -> case u0 of { _ALG_ _TUP_0 -> case u1 of { _ALG_ _TUP_0 -> _!_ True [] []; _NO_DEFLT_ }; _NO_DEFLT_ } _N_ },
+ (>=) = { _A_ 2 _U_ 11 _N_ _S_ "EE" _F_ _IF_ARGS_ 0 2 CC 3 \ (u0 :: ()) (u1 :: ()) -> case u0 of { _ALG_ _TUP_0 -> case u1 of { _ALG_ _TUP_0 -> _!_ True [] []; _NO_DEFLT_ }; _NO_DEFLT_ } _N_ },
+ (>) = { _A_ 2 _U_ 11 _N_ _S_ "EE" _F_ _IF_ARGS_ 0 2 CC 3 \ (u0 :: ()) (u1 :: ()) -> case u0 of { _ALG_ _TUP_0 -> case u1 of { _ALG_ _TUP_0 -> _!_ False [] []; _NO_DEFLT_ }; _NO_DEFLT_ } _N_ },
+ max = { _A_ 2 _U_ 11 _N_ _S_ "EE" _F_ _IF_ARGS_ 0 2 CX 2 \ (u0 :: ()) (u1 :: ()) -> case u0 of { _ALG_ _TUP_0 -> u1; _NO_DEFLT_ } _N_ },
+ min = { _A_ 2 _U_ 11 _N_ _S_ "EE" _F_ _IF_ARGS_ 0 2 CX 2 \ (u0 :: ()) (u1 :: ()) -> case u0 of { _ALG_ _TUP_0 -> u1; _NO_DEFLT_ } _N_ },
+ _tagCmp = { _A_ 2 _U_ 11 _N_ _S_ "EE" _F_ _IF_ARGS_ 0 2 CC 3 \ (u0 :: ()) (u1 :: ()) -> case u0 of { _ALG_ _TUP_0 -> case u1 of { _ALG_ _TUP_0 -> _!_ _EQ [] []; _NO_DEFLT_ }; _NO_DEFLT_ } _N_ } #-}
instance (Ord a, Ord b) => Ord (a, b)
{-# GHC_PRAGMA _M_ PreludeBuiltin {-dfun-} _A_ 3 _U_ 112 _N_ _N_ _N_ _N_ #-}
instance (Ord a, Ord b, Ord c) => Ord (a, b, c)
{-# GHC_PRAGMA _M_ PreludeBuiltin {-dfun-} _A_ 6 _U_ 111112 _N_ _N_ _N_ _N_ #-}
instance Ord (Int, Int)
{-# GHC_PRAGMA _M_ PreludeBuiltin {-dfun-} _A_ 0 _N_ _N_ _N_ _F_ _IF_ARGS_ 0 0 X 9 _!_ _TUP_8 [{{Eq (Int, Int)}}, ((Int, Int) -> (Int, Int) -> Bool), ((Int, Int) -> (Int, Int) -> Bool), ((Int, Int) -> (Int, Int) -> Bool), ((Int, Int) -> (Int, Int) -> Bool), ((Int, Int) -> (Int, Int) -> (Int, Int)), ((Int, Int) -> (Int, Int) -> (Int, Int)), ((Int, Int) -> (Int, Int) -> _CMP_TAG)] [_DFUN_ Eq ((Int, Int)), _CONSTM_ Ord (<) ((Int, Int)), _CONSTM_ Ord (<=) ((Int, Int)), _CONSTM_ Ord (>=) ((Int, Int)), _CONSTM_ Ord (>) ((Int, Int)), _CONSTM_ Ord max ((Int, Int)), _CONSTM_ Ord min ((Int, Int)), _CONSTM_ Ord _tagCmp ((Int, Int))] _N_
- (<) = _A_ 2 _U_ 11 _N_ _S_ "U(U(P)L)U(U(P)L)" {_A_ 4 _U_ 2121 _N_ _N_ _N_ _N_} _N_ _N_,
- (<=) = _A_ 2 _U_ 11 _N_ _S_ "U(U(P)L)U(U(P)L)" {_A_ 4 _U_ 2121 _N_ _N_ _N_ _N_} _N_ _N_,
- (>=) = _A_ 2 _U_ 11 _N_ _S_ "U(U(P)L)U(U(P)L)" {_A_ 4 _U_ 2121 _N_ _N_ _N_ _N_} _N_ _N_,
- (>) = _A_ 2 _U_ 11 _N_ _S_ "U(U(P)L)U(U(P)L)" {_A_ 4 _U_ 2121 _N_ _N_ _N_ _N_} _N_ _N_,
- max = _A_ 2 _U_ 11 _N_ _S_ "U(U(P)L)U(U(P)L)" {_A_ 4 _U_ 2222 _N_ _N_ _N_ _N_} _N_ _N_,
- min = _A_ 2 _U_ 11 _N_ _S_ "U(U(P)L)U(U(P)L)" {_A_ 4 _U_ 2222 _N_ _N_ _N_ _N_} _N_ _N_,
- _tagCmp = _A_ 2 _U_ 11 _N_ _S_ "U(U(P)L)U(U(P)L)" {_A_ 4 _U_ 2121 _N_ _N_ _N_ _N_} _N_ _N_ #-}
+ (<) = { _A_ 2 _U_ 11 _N_ _S_ "U(U(P)L)U(U(P)L)" {_A_ 4 _U_ 2121 _N_ _N_ _N_ _N_} _N_ _N_ },
+ (<=) = { _A_ 2 _U_ 11 _N_ _S_ "U(U(P)L)U(U(P)L)" {_A_ 4 _U_ 2121 _N_ _N_ _N_ _N_} _N_ _N_ },
+ (>=) = { _A_ 2 _U_ 11 _N_ _S_ "U(U(P)L)U(U(P)L)" {_A_ 4 _U_ 2121 _N_ _N_ _N_ _N_} _N_ _N_ },
+ (>) = { _A_ 2 _U_ 11 _N_ _S_ "U(U(P)L)U(U(P)L)" {_A_ 4 _U_ 2121 _N_ _N_ _N_ _N_} _N_ _N_ },
+ max = { _A_ 2 _U_ 11 _N_ _S_ "U(U(P)L)U(U(P)L)" {_A_ 4 _U_ 2222 _N_ _N_ _N_ _N_} _N_ _N_ },
+ min = { _A_ 2 _U_ 11 _N_ _S_ "U(U(P)L)U(U(P)L)" {_A_ 4 _U_ 2222 _N_ _N_ _N_ _N_} _N_ _N_ },
+ _tagCmp = { _A_ 2 _U_ 11 _N_ _S_ "U(U(P)L)U(U(P)L)" {_A_ 4 _U_ 2121 _N_ _N_ _N_ _N_} _N_ _N_ } #-}
+instance Ord (Int, Int, Int)
+ {-# GHC_PRAGMA _M_ PreludeBuiltin {-dfun-} _A_ 0 _N_ _N_ _N_ _F_ _IF_ARGS_ 0 0 X 9 _!_ _TUP_8 [{{Eq (Int, Int, Int)}}, ((Int, Int, Int) -> (Int, Int, Int) -> Bool), ((Int, Int, Int) -> (Int, Int, Int) -> Bool), ((Int, Int, Int) -> (Int, Int, Int) -> Bool), ((Int, Int, Int) -> (Int, Int, Int) -> Bool), ((Int, Int, Int) -> (Int, Int, Int) -> (Int, Int, Int)), ((Int, Int, Int) -> (Int, Int, Int) -> (Int, Int, Int)), ((Int, Int, Int) -> (Int, Int, Int) -> _CMP_TAG)] [_DFUN_ Eq ((Int, Int, Int)), _CONSTM_ Ord (<) ((Int, Int, Int)), _CONSTM_ Ord (<=) ((Int, Int, Int)), _CONSTM_ Ord (>=) ((Int, Int, Int)), _CONSTM_ Ord (>) ((Int, Int, Int)), _CONSTM_ Ord max ((Int, Int, Int)), _CONSTM_ Ord min ((Int, Int, Int)), _CONSTM_ Ord _tagCmp ((Int, Int, Int))] _N_
+ (<) = { _A_ 2 _U_ 11 _N_ _S_ "U(U(P)LL)U(U(P)LL)" {_A_ 4 _U_ 2111 _N_ _N_ _N_ _N_} _N_ _N_ },
+ (<=) = { _A_ 2 _U_ 11 _N_ _S_ "U(U(P)LL)U(U(P)LL)" {_A_ 4 _U_ 2111 _N_ _N_ _N_ _N_} _N_ _N_ },
+ (>=) = { _A_ 2 _U_ 11 _N_ _S_ "U(U(P)LL)U(U(P)LL)" {_A_ 4 _U_ 2111 _N_ _N_ _N_ _N_} _N_ _N_ },
+ (>) = { _A_ 2 _U_ 11 _N_ _S_ "U(U(P)LL)U(U(P)LL)" {_A_ 4 _U_ 2111 _N_ _N_ _N_ _N_} _N_ _N_ },
+ max = { _A_ 2 _U_ 12 _N_ _S_ "U(U(P)LL)U(U(P)LL)" {_A_ 4 _U_ 2222 _N_ _N_ _N_ _N_} _N_ _N_ },
+ min = { _A_ 2 _U_ 12 _N_ _S_ "U(U(P)LL)U(U(P)LL)" {_A_ 4 _U_ 2222 _N_ _N_ _N_ _N_} _N_ _N_ },
+ _tagCmp = { _A_ 2 _U_ 11 _N_ _S_ "U(U(P)LL)U(U(P)LL)" {_A_ 4 _U_ 2111 _N_ _N_ _N_ _N_} _N_ _N_ } #-}
+instance Ord (Int, Int, Int, Int)
+ {-# GHC_PRAGMA _M_ PreludeBuiltin {-dfun-} _A_ 0 _N_ _N_ _N_ _F_ _IF_ARGS_ 0 0 X 9 _!_ _TUP_8 [{{Eq (Int, Int, Int, Int)}}, ((Int, Int, Int, Int) -> (Int, Int, Int, Int) -> Bool), ((Int, Int, Int, Int) -> (Int, Int, Int, Int) -> Bool), ((Int, Int, Int, Int) -> (Int, Int, Int, Int) -> Bool), ((Int, Int, Int, Int) -> (Int, Int, Int, Int) -> Bool), ((Int, Int, Int, Int) -> (Int, Int, Int, Int) -> (Int, Int, Int, Int)), ((Int, Int, Int, Int) -> (Int, Int, Int, Int) -> (Int, Int, Int, Int)), ((Int, Int, Int, Int) -> (Int, Int, Int, Int) -> _CMP_TAG)] [_DFUN_ Eq ((Int, Int, Int, Int)), _CONSTM_ Ord (<) ((Int, Int, Int, Int)), _CONSTM_ Ord (<=) ((Int, Int, Int, Int)), _CONSTM_ Ord (>=) ((Int, Int, Int, Int)), _CONSTM_ Ord (>) ((Int, Int, Int, Int)), _CONSTM_ Ord max ((Int, Int, Int, Int)), _CONSTM_ Ord min ((Int, Int, Int, Int)), _CONSTM_ Ord _tagCmp ((Int, Int, Int, Int))] _N_
+ (<) = { _A_ 2 _U_ 11 _N_ _S_ "U(U(P)LLL)U(U(P)LLL)" {_A_ 5 _U_ 21111 _N_ _N_ _N_ _N_} _N_ _N_ },
+ (<=) = { _A_ 2 _U_ 11 _N_ _S_ "U(U(P)LLL)U(U(P)LLL)" {_A_ 5 _U_ 21111 _N_ _N_ _N_ _N_} _N_ _N_ },
+ (>=) = { _A_ 2 _U_ 11 _N_ _S_ "U(U(P)LLL)U(U(P)LLL)" {_A_ 5 _U_ 21111 _N_ _N_ _N_ _N_} _N_ _N_ },
+ (>) = { _A_ 2 _U_ 11 _N_ _S_ "U(U(P)LLL)U(U(P)LLL)" {_A_ 5 _U_ 21111 _N_ _N_ _N_ _N_} _N_ _N_ },
+ max = { _A_ 2 _U_ 12 _N_ _S_ "U(U(P)LLL)U(U(P)LLL)" {_A_ 5 _U_ 22222 _N_ _N_ _N_ _N_} _N_ _N_ },
+ min = { _A_ 2 _U_ 12 _N_ _S_ "U(U(P)LLL)U(U(P)LLL)" {_A_ 5 _U_ 22222 _N_ _N_ _N_ _N_} _N_ _N_ },
+ _tagCmp = { _A_ 2 _U_ 11 _N_ _S_ "U(U(P)LLL)U(U(P)LLL)" {_A_ 5 _U_ 21111 _N_ _N_ _N_ _N_} _N_ _N_ } #-}
+instance Ord (Int, Int, Int, Int, Int)
+ {-# GHC_PRAGMA _M_ PreludeBuiltin {-dfun-} _A_ 0 _N_ _N_ _N_ _F_ _IF_ARGS_ 0 0 X 9 _!_ _TUP_8 [{{Eq (Int, Int, Int, Int, Int)}}, ((Int, Int, Int, Int, Int) -> (Int, Int, Int, Int, Int) -> Bool), ((Int, Int, Int, Int, Int) -> (Int, Int, Int, Int, Int) -> Bool), ((Int, Int, Int, Int, Int) -> (Int, Int, Int, Int, Int) -> Bool), ((Int, Int, Int, Int, Int) -> (Int, Int, Int, Int, Int) -> Bool), ((Int, Int, Int, Int, Int) -> (Int, Int, Int, Int, Int) -> (Int, Int, Int, Int, Int)), ((Int, Int, Int, Int, Int) -> (Int, Int, Int, Int, Int) -> (Int, Int, Int, Int, Int)), ((Int, Int, Int, Int, Int) -> (Int, Int, Int, Int, Int) -> _CMP_TAG)] [_DFUN_ Eq ((Int, Int, Int, Int, Int)), _CONSTM_ Ord (<) ((Int, Int, Int, Int, Int)), _CONSTM_ Ord (<=) ((Int, Int, Int, Int, Int)), _CONSTM_ Ord (>=) ((Int, Int, Int, Int, Int)), _CONSTM_ Ord (>) ((Int, Int, Int, Int, Int)), _CONSTM_ Ord max ((Int, Int, Int, Int, Int)), _CONSTM_ Ord min ((Int, Int, Int, Int, Int)), _CONSTM_ Ord _tagCmp ((Int, Int, Int, Int, Int))] _N_
+ (<) = { _A_ 2 _U_ 11 _N_ _S_ "U(U(P)LLLL)U(U(P)LLLL)" _N_ _N_ },
+ (<=) = { _A_ 2 _U_ 11 _N_ _S_ "U(U(P)LLLL)U(U(P)LLLL)" _N_ _N_ },
+ (>=) = { _A_ 2 _U_ 11 _N_ _S_ "U(U(P)LLLL)U(U(P)LLLL)" _N_ _N_ },
+ (>) = { _A_ 2 _U_ 11 _N_ _S_ "U(U(P)LLLL)U(U(P)LLLL)" _N_ _N_ },
+ max = { _A_ 2 _U_ 22 _N_ _S_ "U(U(P)LLLL)U(U(P)LLLL)" _N_ _N_ },
+ min = { _A_ 2 _U_ 22 _N_ _S_ "U(U(P)LLLL)U(U(P)LLLL)" _N_ _N_ },
+ _tagCmp = { _A_ 2 _U_ 11 _N_ _S_ "U(U(P)LLLL)U(U(P)LLLL)" _N_ _N_ } #-}
+instance Ord ([Char], [Char])
+ {-# GHC_PRAGMA _M_ PreludeBuiltin {-dfun-} _A_ 0 _N_ _N_ _N_ _F_ _IF_ARGS_ 0 0 X 9 _!_ _TUP_8 [{{Eq ([Char], [Char])}}, (([Char], [Char]) -> ([Char], [Char]) -> Bool), (([Char], [Char]) -> ([Char], [Char]) -> Bool), (([Char], [Char]) -> ([Char], [Char]) -> Bool), (([Char], [Char]) -> ([Char], [Char]) -> Bool), (([Char], [Char]) -> ([Char], [Char]) -> ([Char], [Char])), (([Char], [Char]) -> ([Char], [Char]) -> ([Char], [Char])), (([Char], [Char]) -> ([Char], [Char]) -> _CMP_TAG)] [_DFUN_ Eq (([Char], [Char])), _CONSTM_ Ord (<) (([Char], [Char])), _CONSTM_ Ord (<=) (([Char], [Char])), _CONSTM_ Ord (>=) (([Char], [Char])), _CONSTM_ Ord (>) (([Char], [Char])), _CONSTM_ Ord max (([Char], [Char])), _CONSTM_ Ord min (([Char], [Char])), _CONSTM_ Ord _tagCmp (([Char], [Char]))] _N_
+ (<) = { _A_ 2 _U_ 11 _N_ _S_ "U(SL)U(SL)" {_A_ 4 _U_ 2222 _N_ _N_ _N_ _N_} _N_ _N_ },
+ (<=) = { _A_ 2 _U_ 11 _N_ _S_ "U(SL)U(SL)" {_A_ 4 _U_ 2222 _N_ _N_ _N_ _N_} _N_ _N_ },
+ (>=) = { _A_ 2 _U_ 11 _N_ _S_ "U(SL)U(SL)" {_A_ 4 _U_ 2222 _N_ _N_ _N_ _N_} _N_ _N_ },
+ (>) = { _A_ 2 _U_ 11 _N_ _S_ "U(SL)U(SL)" {_A_ 4 _U_ 2222 _N_ _N_ _N_ _N_} _N_ _N_ },
+ max = { _A_ 2 _U_ 11 _N_ _S_ "U(SL)U(SL)" {_A_ 4 _U_ 2222 _N_ _N_ _N_ _N_} _N_ _N_ },
+ min = { _A_ 2 _U_ 11 _N_ _S_ "U(SL)U(SL)" {_A_ 4 _U_ 2222 _N_ _N_ _N_ _N_} _N_ _N_ },
+ _tagCmp = { _A_ 2 _U_ 11 _N_ _S_ "U(SL)U(SL)" {_A_ 4 _U_ 2222 _N_ _N_ _N_ _N_} _N_ _N_ } #-}
+instance Ord ([Int], [Int])
+ {-# GHC_PRAGMA _M_ PreludeBuiltin {-dfun-} _A_ 0 _N_ _N_ _N_ _F_ _IF_ARGS_ 0 0 X 9 _!_ _TUP_8 [{{Eq ([Int], [Int])}}, (([Int], [Int]) -> ([Int], [Int]) -> Bool), (([Int], [Int]) -> ([Int], [Int]) -> Bool), (([Int], [Int]) -> ([Int], [Int]) -> Bool), (([Int], [Int]) -> ([Int], [Int]) -> Bool), (([Int], [Int]) -> ([Int], [Int]) -> ([Int], [Int])), (([Int], [Int]) -> ([Int], [Int]) -> ([Int], [Int])), (([Int], [Int]) -> ([Int], [Int]) -> _CMP_TAG)] [_DFUN_ Eq (([Int], [Int])), _CONSTM_ Ord (<) (([Int], [Int])), _CONSTM_ Ord (<=) (([Int], [Int])), _CONSTM_ Ord (>=) (([Int], [Int])), _CONSTM_ Ord (>) (([Int], [Int])), _CONSTM_ Ord max (([Int], [Int])), _CONSTM_ Ord min (([Int], [Int])), _CONSTM_ Ord _tagCmp (([Int], [Int]))] _N_
+ (<) = { _A_ 2 _U_ 11 _N_ _S_ "U(SL)U(SL)" {_A_ 4 _U_ 2222 _N_ _N_ _N_ _N_} _N_ _N_ },
+ (<=) = { _A_ 2 _U_ 11 _N_ _S_ "U(SL)U(SL)" {_A_ 4 _U_ 2222 _N_ _N_ _N_ _N_} _N_ _N_ },
+ (>=) = { _A_ 2 _U_ 11 _N_ _S_ "U(SL)U(SL)" {_A_ 4 _U_ 2222 _N_ _N_ _N_ _N_} _N_ _N_ },
+ (>) = { _A_ 2 _U_ 11 _N_ _S_ "U(SL)U(SL)" {_A_ 4 _U_ 2222 _N_ _N_ _N_ _N_} _N_ _N_ },
+ max = { _A_ 2 _U_ 11 _N_ _S_ "U(SL)U(SL)" {_A_ 4 _U_ 2222 _N_ _N_ _N_ _N_} _N_ _N_ },
+ min = { _A_ 2 _U_ 11 _N_ _S_ "U(SL)U(SL)" {_A_ 4 _U_ 2222 _N_ _N_ _N_ _N_} _N_ _N_ },
+ _tagCmp = { _A_ 2 _U_ 11 _N_ _S_ "U(SL)U(SL)" {_A_ 4 _U_ 2222 _N_ _N_ _N_ _N_} _N_ _N_ } #-}
instance Ord (_PackedString, _PackedString)
{-# GHC_PRAGMA _M_ PreludeBuiltin {-dfun-} _A_ 0 _N_ _N_ _N_ _F_ _IF_ARGS_ 0 0 X 9 _!_ _TUP_8 [{{Eq (_PackedString, _PackedString)}}, ((_PackedString, _PackedString) -> (_PackedString, _PackedString) -> Bool), ((_PackedString, _PackedString) -> (_PackedString, _PackedString) -> Bool), ((_PackedString, _PackedString) -> (_PackedString, _PackedString) -> Bool), ((_PackedString, _PackedString) -> (_PackedString, _PackedString) -> Bool), ((_PackedString, _PackedString) -> (_PackedString, _PackedString) -> (_PackedString, _PackedString)), ((_PackedString, _PackedString) -> (_PackedString, _PackedString) -> (_PackedString, _PackedString)), ((_PackedString, _PackedString) -> (_PackedString, _PackedString) -> _CMP_TAG)] [_DFUN_ Eq ((_PackedString, _PackedString)), _CONSTM_ Ord (<) ((_PackedString, _PackedString)), _CONSTM_ Ord (<=) ((_PackedString, _PackedString)), _CONSTM_ Ord (>=) ((_PackedString, _PackedString)), _CONSTM_ Ord (>) ((_PackedString, _PackedString)), _CONSTM_ Ord max ((_PackedString, _PackedString)), _CONSTM_ Ord min ((_PackedString, _PackedString)), _CONSTM_ Ord _tagCmp ((_PackedString, _PackedString))] _N_
- (<) = _A_ 2 _U_ 11 _N_ _S_ "U(SL)U(SL)" {_A_ 4 _U_ 2222 _N_ _N_ _N_ _N_} _N_ _N_,
- (<=) = _A_ 2 _U_ 11 _N_ _S_ "U(SL)U(SL)" {_A_ 4 _U_ 2222 _N_ _N_ _N_ _N_} _N_ _N_,
- (>=) = _A_ 2 _U_ 11 _N_ _S_ "U(SL)U(SL)" {_A_ 4 _U_ 2222 _N_ _N_ _N_ _N_} _N_ _N_,
- (>) = _A_ 2 _U_ 11 _N_ _S_ "U(SL)U(SL)" {_A_ 4 _U_ 2222 _N_ _N_ _N_ _N_} _N_ _N_,
- max = _A_ 2 _U_ 11 _N_ _S_ "U(SL)U(SL)" {_A_ 4 _U_ 2222 _N_ _N_ _N_ _N_} _N_ _N_,
- min = _A_ 2 _U_ 11 _N_ _S_ "U(SL)U(SL)" {_A_ 4 _U_ 2222 _N_ _N_ _N_ _N_} _N_ _N_,
- _tagCmp = _A_ 2 _U_ 11 _N_ _S_ "U(SL)U(SL)" {_A_ 4 _U_ 2222 _N_ _N_ _N_ _N_} _N_ _N_ #-}
+ (<) = { _A_ 2 _U_ 11 _N_ _S_ "U(SL)U(SL)" {_A_ 4 _U_ 2222 _N_ _N_ _N_ _N_} _N_ _N_ },
+ (<=) = { _A_ 2 _U_ 11 _N_ _S_ "U(SL)U(SL)" {_A_ 4 _U_ 2222 _N_ _N_ _N_ _N_} _N_ _N_ },
+ (>=) = { _A_ 2 _U_ 11 _N_ _S_ "U(SL)U(SL)" {_A_ 4 _U_ 2222 _N_ _N_ _N_ _N_} _N_ _N_ },
+ (>) = { _A_ 2 _U_ 11 _N_ _S_ "U(SL)U(SL)" {_A_ 4 _U_ 2222 _N_ _N_ _N_ _N_} _N_ _N_ },
+ max = { _A_ 2 _U_ 11 _N_ _S_ "U(SL)U(SL)" {_A_ 4 _U_ 2222 _N_ _N_ _N_ _N_} _N_ _N_ },
+ min = { _A_ 2 _U_ 11 _N_ _S_ "U(SL)U(SL)" {_A_ 4 _U_ 2222 _N_ _N_ _N_ _N_} _N_ _N_ },
+ _tagCmp = { _A_ 2 _U_ 11 _N_ _S_ "U(SL)U(SL)" {_A_ 4 _U_ 2222 _N_ _N_ _N_ _N_} _N_ _N_ } #-}
instance (Ix a, Ord b) => Ord (Array a b)
{-# GHC_PRAGMA _M_ PreludeArray {-dfun-} _A_ 3 _U_ 222 _N_ _N_ _N_ _N_ #-}
instance (Ord a, Ord b) => Ord (Assoc a b)
{-# GHC_PRAGMA _M_ PreludeArray {-dfun-} _A_ 3 _U_ 112 _N_ _N_ _N_ _N_ #-}
instance Ord Bool
{-# GHC_PRAGMA _M_ PreludeCore {-dfun-} _A_ 0 _N_ _N_ _N_ _F_ _IF_ARGS_ 0 0 X 9 _!_ _TUP_8 [{{Eq Bool}}, (Bool -> Bool -> Bool), (Bool -> Bool -> Bool), (Bool -> Bool -> Bool), (Bool -> Bool -> Bool), (Bool -> Bool -> Bool), (Bool -> Bool -> Bool), (Bool -> Bool -> _CMP_TAG)] [_DFUN_ Eq (Bool), _CONSTM_ Ord (<) (Bool), _CONSTM_ Ord (<=) (Bool), _CONSTM_ Ord (>=) (Bool), _CONSTM_ Ord (>) (Bool), _CONSTM_ Ord max (Bool), _CONSTM_ Ord min (Bool), _CONSTM_ Ord _tagCmp (Bool)] _N_
- (<) = _A_ 2 _U_ 11 _N_ _S_ "EE" _N_ _N_,
- (<=) = _A_ 2 _U_ 11 _N_ _S_ "EE" _N_ _N_,
- (>=) = _A_ 2 _U_ 11 _N_ _S_ "EE" _N_ _N_,
- (>) = _A_ 2 _U_ 11 _N_ _S_ "EE" _N_ _N_,
- max = _A_ 2 _U_ 22 _N_ _S_ "EE" _N_ _N_,
- min = _A_ 2 _U_ 22 _N_ _S_ "EE" _N_ _N_,
- _tagCmp = _A_ 2 _U_ 11 _N_ _S_ "EE" _N_ _N_ #-}
+ (<) = { _A_ 2 _U_ 11 _N_ _S_ "EE" _N_ _N_ },
+ (<=) = { _A_ 2 _U_ 11 _N_ _S_ "EE" _N_ _N_ },
+ (>=) = { _A_ 2 _U_ 11 _N_ _S_ "EE" _N_ _N_ },
+ (>) = { _A_ 2 _U_ 11 _N_ _S_ "EE" _N_ _N_ },
+ max = { _A_ 2 _U_ 22 _N_ _S_ "EE" _N_ _N_ },
+ min = { _A_ 2 _U_ 22 _N_ _S_ "EE" _N_ _N_ },
+ _tagCmp = { _A_ 2 _U_ 11 _N_ _S_ "EE" _N_ _N_ } #-}
instance Ord Char
{-# GHC_PRAGMA _M_ PreludeCore {-dfun-} _A_ 0 _N_ _N_ _N_ _F_ _IF_ARGS_ 0 0 X 9 _!_ _TUP_8 [{{Eq Char}}, (Char -> Char -> Bool), (Char -> Char -> Bool), (Char -> Char -> Bool), (Char -> Char -> Bool), (Char -> Char -> Char), (Char -> Char -> Char), (Char -> Char -> _CMP_TAG)] [_DFUN_ Eq (Char), _CONSTM_ Ord (<) (Char), _CONSTM_ Ord (<=) (Char), _CONSTM_ Ord (>=) (Char), _CONSTM_ Ord (>) (Char), _CONSTM_ Ord max (Char), _CONSTM_ Ord min (Char), _CONSTM_ Ord _tagCmp (Char)] _N_
- (<) = _A_ 2 _U_ 11 _N_ _S_ "U(P)U(P)" {_A_ 2 _U_ 22 _N_ _N_ _F_ _IF_ARGS_ 0 2 XX 1 \ (u0 :: Char#) (u1 :: Char#) -> _#_ ltChar# [] [u0, u1] _N_} _F_ _IF_ARGS_ 0 2 CC 3 \ (u0 :: Char) (u1 :: Char) -> case u0 of { _ALG_ C# (u2 :: Char#) -> case u1 of { _ALG_ C# (u3 :: Char#) -> _#_ ltChar# [] [u2, u3]; _NO_DEFLT_ }; _NO_DEFLT_ } _N_,
- (<=) = _A_ 2 _U_ 11 _N_ _S_ "U(P)U(P)" {_A_ 2 _U_ 22 _N_ _N_ _F_ _IF_ARGS_ 0 2 XX 1 \ (u0 :: Char#) (u1 :: Char#) -> _#_ leChar# [] [u0, u1] _N_} _F_ _IF_ARGS_ 0 2 CC 3 \ (u0 :: Char) (u1 :: Char) -> case u0 of { _ALG_ C# (u2 :: Char#) -> case u1 of { _ALG_ C# (u3 :: Char#) -> _#_ leChar# [] [u2, u3]; _NO_DEFLT_ }; _NO_DEFLT_ } _N_,
- (>=) = _A_ 2 _U_ 11 _N_ _S_ "U(P)U(P)" {_A_ 2 _U_ 22 _N_ _N_ _F_ _IF_ARGS_ 0 2 XX 1 \ (u0 :: Char#) (u1 :: Char#) -> _#_ geChar# [] [u0, u1] _N_} _F_ _IF_ARGS_ 0 2 CC 3 \ (u0 :: Char) (u1 :: Char) -> case u0 of { _ALG_ C# (u2 :: Char#) -> case u1 of { _ALG_ C# (u3 :: Char#) -> _#_ geChar# [] [u2, u3]; _NO_DEFLT_ }; _NO_DEFLT_ } _N_,
- (>) = _A_ 2 _U_ 11 _N_ _S_ "U(P)U(P)" {_A_ 2 _U_ 22 _N_ _N_ _F_ _IF_ARGS_ 0 2 XX 1 \ (u0 :: Char#) (u1 :: Char#) -> _#_ gtChar# [] [u0, u1] _N_} _F_ _IF_ARGS_ 0 2 CC 3 \ (u0 :: Char) (u1 :: Char) -> case u0 of { _ALG_ C# (u2 :: Char#) -> case u1 of { _ALG_ C# (u3 :: Char#) -> _#_ gtChar# [] [u2, u3]; _NO_DEFLT_ }; _NO_DEFLT_ } _N_,
- max = _A_ 2 _U_ 11 _N_ _S_ "U(P)U(P)" {_A_ 2 _U_ 22 _N_ _N_ _N_ _N_} _N_ _N_,
- min = _A_ 2 _U_ 11 _N_ _S_ "U(P)U(P)" {_A_ 2 _U_ 22 _N_ _N_ _N_ _N_} _N_ _N_,
- _tagCmp = _A_ 2 _U_ 11 _N_ _S_ "U(P)U(P)" {_A_ 2 _U_ 22 _N_ _N_ _N_ _N_} _N_ _N_ #-}
+ (<) = { _A_ 2 _U_ 11 _N_ _S_ "U(P)U(P)" {_A_ 2 _U_ 22 _N_ _N_ _F_ _IF_ARGS_ 0 2 XX 1 \ (u0 :: Char#) (u1 :: Char#) -> _#_ ltChar# [] [u0, u1] _N_} _F_ _IF_ARGS_ 0 2 CC 3 \ (u0 :: Char) (u1 :: Char) -> case u0 of { _ALG_ C# (u2 :: Char#) -> case u1 of { _ALG_ C# (u3 :: Char#) -> _#_ ltChar# [] [u2, u3]; _NO_DEFLT_ }; _NO_DEFLT_ } _N_ },
+ (<=) = { _A_ 2 _U_ 11 _N_ _S_ "U(P)U(P)" {_A_ 2 _U_ 22 _N_ _N_ _F_ _IF_ARGS_ 0 2 XX 1 \ (u0 :: Char#) (u1 :: Char#) -> _#_ leChar# [] [u0, u1] _N_} _F_ _IF_ARGS_ 0 2 CC 3 \ (u0 :: Char) (u1 :: Char) -> case u0 of { _ALG_ C# (u2 :: Char#) -> case u1 of { _ALG_ C# (u3 :: Char#) -> _#_ leChar# [] [u2, u3]; _NO_DEFLT_ }; _NO_DEFLT_ } _N_ },
+ (>=) = { _A_ 2 _U_ 11 _N_ _S_ "U(P)U(P)" {_A_ 2 _U_ 22 _N_ _N_ _F_ _IF_ARGS_ 0 2 XX 1 \ (u0 :: Char#) (u1 :: Char#) -> _#_ geChar# [] [u0, u1] _N_} _F_ _IF_ARGS_ 0 2 CC 3 \ (u0 :: Char) (u1 :: Char) -> case u0 of { _ALG_ C# (u2 :: Char#) -> case u1 of { _ALG_ C# (u3 :: Char#) -> _#_ geChar# [] [u2, u3]; _NO_DEFLT_ }; _NO_DEFLT_ } _N_ },
+ (>) = { _A_ 2 _U_ 11 _N_ _S_ "U(P)U(P)" {_A_ 2 _U_ 22 _N_ _N_ _F_ _IF_ARGS_ 0 2 XX 1 \ (u0 :: Char#) (u1 :: Char#) -> _#_ gtChar# [] [u0, u1] _N_} _F_ _IF_ARGS_ 0 2 CC 3 \ (u0 :: Char) (u1 :: Char) -> case u0 of { _ALG_ C# (u2 :: Char#) -> case u1 of { _ALG_ C# (u3 :: Char#) -> _#_ gtChar# [] [u2, u3]; _NO_DEFLT_ }; _NO_DEFLT_ } _N_ },
+ max = { _A_ 2 _U_ 11 _N_ _S_ "U(P)U(P)" {_A_ 2 _U_ 22 _N_ _N_ _N_ _N_} _N_ _N_ },
+ min = { _A_ 2 _U_ 11 _N_ _S_ "U(P)U(P)" {_A_ 2 _U_ 22 _N_ _N_ _N_ _N_} _N_ _N_ },
+ _tagCmp = { _A_ 2 _U_ 11 _N_ _S_ "U(P)U(P)" {_A_ 2 _U_ 22 _N_ _N_ _N_ _N_} _N_ _N_ } #-}
instance Ord Double
{-# GHC_PRAGMA _M_ PreludeCore {-dfun-} _A_ 0 _N_ _N_ _N_ _F_ _IF_ARGS_ 0 0 X 9 _!_ _TUP_8 [{{Eq Double}}, (Double -> Double -> Bool), (Double -> Double -> Bool), (Double -> Double -> Bool), (Double -> Double -> Bool), (Double -> Double -> Double), (Double -> Double -> Double), (Double -> Double -> _CMP_TAG)] [_DFUN_ Eq (Double), _CONSTM_ Ord (<) (Double), _CONSTM_ Ord (<=) (Double), _CONSTM_ Ord (>=) (Double), _CONSTM_ Ord (>) (Double), _CONSTM_ Ord max (Double), _CONSTM_ Ord min (Double), _CONSTM_ Ord _tagCmp (Double)] _N_
- (<) = _A_ 2 _U_ 11 _N_ _S_ "U(P)U(P)" {_A_ 2 _U_ 22 _N_ _N_ _F_ _IF_ARGS_ 0 2 XX 1 \ (u0 :: Double#) (u1 :: Double#) -> _#_ ltDouble# [] [u0, u1] _N_} _F_ _IF_ARGS_ 0 2 CC 3 \ (u0 :: Double) (u1 :: Double) -> case u0 of { _ALG_ D# (u2 :: Double#) -> case u1 of { _ALG_ D# (u3 :: Double#) -> _#_ ltDouble# [] [u2, u3]; _NO_DEFLT_ }; _NO_DEFLT_ } _N_,
- (<=) = _A_ 2 _U_ 11 _N_ _S_ "U(P)U(P)" {_A_ 2 _U_ 22 _N_ _N_ _F_ _IF_ARGS_ 0 2 XX 1 \ (u0 :: Double#) (u1 :: Double#) -> _#_ leDouble# [] [u0, u1] _N_} _F_ _IF_ARGS_ 0 2 CC 3 \ (u0 :: Double) (u1 :: Double) -> case u0 of { _ALG_ D# (u2 :: Double#) -> case u1 of { _ALG_ D# (u3 :: Double#) -> _#_ leDouble# [] [u2, u3]; _NO_DEFLT_ }; _NO_DEFLT_ } _N_,
- (>=) = _A_ 2 _U_ 11 _N_ _S_ "U(P)U(P)" {_A_ 2 _U_ 22 _N_ _N_ _F_ _IF_ARGS_ 0 2 XX 1 \ (u0 :: Double#) (u1 :: Double#) -> _#_ geDouble# [] [u0, u1] _N_} _F_ _IF_ARGS_ 0 2 CC 3 \ (u0 :: Double) (u1 :: Double) -> case u0 of { _ALG_ D# (u2 :: Double#) -> case u1 of { _ALG_ D# (u3 :: Double#) -> _#_ geDouble# [] [u2, u3]; _NO_DEFLT_ }; _NO_DEFLT_ } _N_,
- (>) = _A_ 2 _U_ 11 _N_ _S_ "U(P)U(P)" {_A_ 2 _U_ 22 _N_ _N_ _F_ _IF_ARGS_ 0 2 XX 1 \ (u0 :: Double#) (u1 :: Double#) -> _#_ gtDouble# [] [u0, u1] _N_} _F_ _IF_ARGS_ 0 2 CC 3 \ (u0 :: Double) (u1 :: Double) -> case u0 of { _ALG_ D# (u2 :: Double#) -> case u1 of { _ALG_ D# (u3 :: Double#) -> _#_ gtDouble# [] [u2, u3]; _NO_DEFLT_ }; _NO_DEFLT_ } _N_,
- max = _A_ 2 _U_ 11 _N_ _S_ "U(P)U(P)" {_A_ 2 _U_ 22 _N_ _N_ _N_ _N_} _N_ _N_,
- min = _A_ 2 _U_ 11 _N_ _S_ "U(P)U(P)" {_A_ 2 _U_ 22 _N_ _N_ _N_ _N_} _N_ _N_,
- _tagCmp = _A_ 2 _U_ 11 _N_ _S_ "U(P)U(P)" {_A_ 2 _U_ 22 _N_ _N_ _N_ _N_} _N_ _N_ #-}
+ (<) = { _A_ 2 _U_ 11 _N_ _S_ "U(P)U(P)" {_A_ 2 _U_ 22 _N_ _N_ _F_ _IF_ARGS_ 0 2 XX 1 \ (u0 :: Double#) (u1 :: Double#) -> _#_ ltDouble# [] [u0, u1] _N_} _F_ _IF_ARGS_ 0 2 CC 3 \ (u0 :: Double) (u1 :: Double) -> case u0 of { _ALG_ D# (u2 :: Double#) -> case u1 of { _ALG_ D# (u3 :: Double#) -> _#_ ltDouble# [] [u2, u3]; _NO_DEFLT_ }; _NO_DEFLT_ } _N_ },
+ (<=) = { _A_ 2 _U_ 11 _N_ _S_ "U(P)U(P)" {_A_ 2 _U_ 22 _N_ _N_ _F_ _IF_ARGS_ 0 2 XX 1 \ (u0 :: Double#) (u1 :: Double#) -> _#_ leDouble# [] [u0, u1] _N_} _F_ _IF_ARGS_ 0 2 CC 3 \ (u0 :: Double) (u1 :: Double) -> case u0 of { _ALG_ D# (u2 :: Double#) -> case u1 of { _ALG_ D# (u3 :: Double#) -> _#_ leDouble# [] [u2, u3]; _NO_DEFLT_ }; _NO_DEFLT_ } _N_ },
+ (>=) = { _A_ 2 _U_ 11 _N_ _S_ "U(P)U(P)" {_A_ 2 _U_ 22 _N_ _N_ _F_ _IF_ARGS_ 0 2 XX 1 \ (u0 :: Double#) (u1 :: Double#) -> _#_ geDouble# [] [u0, u1] _N_} _F_ _IF_ARGS_ 0 2 CC 3 \ (u0 :: Double) (u1 :: Double) -> case u0 of { _ALG_ D# (u2 :: Double#) -> case u1 of { _ALG_ D# (u3 :: Double#) -> _#_ geDouble# [] [u2, u3]; _NO_DEFLT_ }; _NO_DEFLT_ } _N_ },
+ (>) = { _A_ 2 _U_ 11 _N_ _S_ "U(P)U(P)" {_A_ 2 _U_ 22 _N_ _N_ _F_ _IF_ARGS_ 0 2 XX 1 \ (u0 :: Double#) (u1 :: Double#) -> _#_ gtDouble# [] [u0, u1] _N_} _F_ _IF_ARGS_ 0 2 CC 3 \ (u0 :: Double) (u1 :: Double) -> case u0 of { _ALG_ D# (u2 :: Double#) -> case u1 of { _ALG_ D# (u3 :: Double#) -> _#_ gtDouble# [] [u2, u3]; _NO_DEFLT_ }; _NO_DEFLT_ } _N_ },
+ max = { _A_ 2 _U_ 11 _N_ _S_ "U(P)U(P)" {_A_ 2 _U_ 22 _N_ _N_ _N_ _N_} _N_ _N_ },
+ min = { _A_ 2 _U_ 11 _N_ _S_ "U(P)U(P)" {_A_ 2 _U_ 22 _N_ _N_ _N_ _N_} _N_ _N_ },
+ _tagCmp = { _A_ 2 _U_ 11 _N_ _S_ "U(P)U(P)" {_A_ 2 _U_ 22 _N_ _N_ _N_ _N_} _N_ _N_ } #-}
instance Ord Float
{-# GHC_PRAGMA _M_ PreludeCore {-dfun-} _A_ 0 _N_ _N_ _N_ _F_ _IF_ARGS_ 0 0 X 9 _!_ _TUP_8 [{{Eq Float}}, (Float -> Float -> Bool), (Float -> Float -> Bool), (Float -> Float -> Bool), (Float -> Float -> Bool), (Float -> Float -> Float), (Float -> Float -> Float), (Float -> Float -> _CMP_TAG)] [_DFUN_ Eq (Float), _CONSTM_ Ord (<) (Float), _CONSTM_ Ord (<=) (Float), _CONSTM_ Ord (>=) (Float), _CONSTM_ Ord (>) (Float), _CONSTM_ Ord max (Float), _CONSTM_ Ord min (Float), _CONSTM_ Ord _tagCmp (Float)] _N_
- (<) = _A_ 2 _U_ 11 _N_ _S_ "U(P)U(P)" {_A_ 2 _U_ 22 _N_ _N_ _F_ _IF_ARGS_ 0 2 XX 1 \ (u0 :: Float#) (u1 :: Float#) -> _#_ ltFloat# [] [u0, u1] _N_} _F_ _IF_ARGS_ 0 2 CC 3 \ (u0 :: Float) (u1 :: Float) -> case u0 of { _ALG_ F# (u2 :: Float#) -> case u1 of { _ALG_ F# (u3 :: Float#) -> _#_ ltFloat# [] [u2, u3]; _NO_DEFLT_ }; _NO_DEFLT_ } _N_,
- (<=) = _A_ 2 _U_ 11 _N_ _S_ "U(P)U(P)" {_A_ 2 _U_ 22 _N_ _N_ _F_ _IF_ARGS_ 0 2 XX 1 \ (u0 :: Float#) (u1 :: Float#) -> _#_ leFloat# [] [u0, u1] _N_} _F_ _IF_ARGS_ 0 2 CC 3 \ (u0 :: Float) (u1 :: Float) -> case u0 of { _ALG_ F# (u2 :: Float#) -> case u1 of { _ALG_ F# (u3 :: Float#) -> _#_ leFloat# [] [u2, u3]; _NO_DEFLT_ }; _NO_DEFLT_ } _N_,
- (>=) = _A_ 2 _U_ 11 _N_ _S_ "U(P)U(P)" {_A_ 2 _U_ 22 _N_ _N_ _F_ _IF_ARGS_ 0 2 XX 1 \ (u0 :: Float#) (u1 :: Float#) -> _#_ geFloat# [] [u0, u1] _N_} _F_ _IF_ARGS_ 0 2 CC 3 \ (u0 :: Float) (u1 :: Float) -> case u0 of { _ALG_ F# (u2 :: Float#) -> case u1 of { _ALG_ F# (u3 :: Float#) -> _#_ geFloat# [] [u2, u3]; _NO_DEFLT_ }; _NO_DEFLT_ } _N_,
- (>) = _A_ 2 _U_ 11 _N_ _S_ "U(P)U(P)" {_A_ 2 _U_ 22 _N_ _N_ _F_ _IF_ARGS_ 0 2 XX 1 \ (u0 :: Float#) (u1 :: Float#) -> _#_ gtFloat# [] [u0, u1] _N_} _F_ _IF_ARGS_ 0 2 CC 3 \ (u0 :: Float) (u1 :: Float) -> case u0 of { _ALG_ F# (u2 :: Float#) -> case u1 of { _ALG_ F# (u3 :: Float#) -> _#_ gtFloat# [] [u2, u3]; _NO_DEFLT_ }; _NO_DEFLT_ } _N_,
- max = _A_ 2 _U_ 11 _N_ _S_ "U(P)U(P)" {_A_ 2 _U_ 22 _N_ _N_ _N_ _N_} _N_ _N_,
- min = _A_ 2 _U_ 11 _N_ _S_ "U(P)U(P)" {_A_ 2 _U_ 22 _N_ _N_ _N_ _N_} _N_ _N_,
- _tagCmp = _A_ 2 _U_ 11 _N_ _S_ "U(P)U(P)" {_A_ 2 _U_ 22 _N_ _N_ _N_ _N_} _N_ _N_ #-}
+ (<) = { _A_ 2 _U_ 11 _N_ _S_ "U(P)U(P)" {_A_ 2 _U_ 22 _N_ _N_ _F_ _IF_ARGS_ 0 2 XX 1 \ (u0 :: Float#) (u1 :: Float#) -> _#_ ltFloat# [] [u0, u1] _N_} _F_ _IF_ARGS_ 0 2 CC 3 \ (u0 :: Float) (u1 :: Float) -> case u0 of { _ALG_ F# (u2 :: Float#) -> case u1 of { _ALG_ F# (u3 :: Float#) -> _#_ ltFloat# [] [u2, u3]; _NO_DEFLT_ }; _NO_DEFLT_ } _N_ },
+ (<=) = { _A_ 2 _U_ 11 _N_ _S_ "U(P)U(P)" {_A_ 2 _U_ 22 _N_ _N_ _F_ _IF_ARGS_ 0 2 XX 1 \ (u0 :: Float#) (u1 :: Float#) -> _#_ leFloat# [] [u0, u1] _N_} _F_ _IF_ARGS_ 0 2 CC 3 \ (u0 :: Float) (u1 :: Float) -> case u0 of { _ALG_ F# (u2 :: Float#) -> case u1 of { _ALG_ F# (u3 :: Float#) -> _#_ leFloat# [] [u2, u3]; _NO_DEFLT_ }; _NO_DEFLT_ } _N_ },
+ (>=) = { _A_ 2 _U_ 11 _N_ _S_ "U(P)U(P)" {_A_ 2 _U_ 22 _N_ _N_ _F_ _IF_ARGS_ 0 2 XX 1 \ (u0 :: Float#) (u1 :: Float#) -> _#_ geFloat# [] [u0, u1] _N_} _F_ _IF_ARGS_ 0 2 CC 3 \ (u0 :: Float) (u1 :: Float) -> case u0 of { _ALG_ F# (u2 :: Float#) -> case u1 of { _ALG_ F# (u3 :: Float#) -> _#_ geFloat# [] [u2, u3]; _NO_DEFLT_ }; _NO_DEFLT_ } _N_ },
+ (>) = { _A_ 2 _U_ 11 _N_ _S_ "U(P)U(P)" {_A_ 2 _U_ 22 _N_ _N_ _F_ _IF_ARGS_ 0 2 XX 1 \ (u0 :: Float#) (u1 :: Float#) -> _#_ gtFloat# [] [u0, u1] _N_} _F_ _IF_ARGS_ 0 2 CC 3 \ (u0 :: Float) (u1 :: Float) -> case u0 of { _ALG_ F# (u2 :: Float#) -> case u1 of { _ALG_ F# (u3 :: Float#) -> _#_ gtFloat# [] [u2, u3]; _NO_DEFLT_ }; _NO_DEFLT_ } _N_ },
+ max = { _A_ 2 _U_ 11 _N_ _S_ "U(P)U(P)" {_A_ 2 _U_ 22 _N_ _N_ _N_ _N_} _N_ _N_ },
+ min = { _A_ 2 _U_ 11 _N_ _S_ "U(P)U(P)" {_A_ 2 _U_ 22 _N_ _N_ _N_ _N_} _N_ _N_ },
+ _tagCmp = { _A_ 2 _U_ 11 _N_ _S_ "U(P)U(P)" {_A_ 2 _U_ 22 _N_ _N_ _N_ _N_} _N_ _N_ } #-}
instance Ord Int
{-# GHC_PRAGMA _M_ PreludeCore {-dfun-} _A_ 0 _N_ _N_ _N_ _F_ _IF_ARGS_ 0 0 X 9 _!_ _TUP_8 [{{Eq Int}}, (Int -> Int -> Bool), (Int -> Int -> Bool), (Int -> Int -> Bool), (Int -> Int -> Bool), (Int -> Int -> Int), (Int -> Int -> Int), (Int -> Int -> _CMP_TAG)] [_DFUN_ Eq (Int), _CONSTM_ Ord (<) (Int), _CONSTM_ Ord (<=) (Int), _CONSTM_ Ord (>=) (Int), _CONSTM_ Ord (>) (Int), _CONSTM_ Ord max (Int), _CONSTM_ Ord min (Int), _CONSTM_ Ord _tagCmp (Int)] _N_
- (<) = _A_ 2 _U_ 11 _N_ _S_ "U(P)U(P)" {_A_ 2 _U_ 22 _N_ _N_ _F_ _IF_ARGS_ 0 2 XX 1 \ (u0 :: Int#) (u1 :: Int#) -> _#_ ltInt# [] [u0, u1] _N_} _F_ _IF_ARGS_ 0 2 CC 3 \ (u0 :: Int) (u1 :: Int) -> case u0 of { _ALG_ I# (u2 :: Int#) -> case u1 of { _ALG_ I# (u3 :: Int#) -> _#_ ltInt# [] [u2, u3]; _NO_DEFLT_ }; _NO_DEFLT_ } _N_,
- (<=) = _A_ 2 _U_ 11 _N_ _S_ "U(P)U(P)" {_A_ 2 _U_ 22 _N_ _N_ _F_ _IF_ARGS_ 0 2 XX 1 \ (u0 :: Int#) (u1 :: Int#) -> _#_ leInt# [] [u0, u1] _N_} _F_ _IF_ARGS_ 0 2 CC 3 \ (u0 :: Int) (u1 :: Int) -> case u0 of { _ALG_ I# (u2 :: Int#) -> case u1 of { _ALG_ I# (u3 :: Int#) -> _#_ leInt# [] [u2, u3]; _NO_DEFLT_ }; _NO_DEFLT_ } _N_,
- (>=) = _A_ 2 _U_ 11 _N_ _S_ "U(P)U(P)" {_A_ 2 _U_ 22 _N_ _N_ _F_ _IF_ARGS_ 0 2 XX 1 \ (u0 :: Int#) (u1 :: Int#) -> _#_ geInt# [] [u0, u1] _N_} _F_ _IF_ARGS_ 0 2 CC 3 \ (u0 :: Int) (u1 :: Int) -> case u0 of { _ALG_ I# (u2 :: Int#) -> case u1 of { _ALG_ I# (u3 :: Int#) -> _#_ geInt# [] [u2, u3]; _NO_DEFLT_ }; _NO_DEFLT_ } _N_,
- (>) = _A_ 2 _U_ 11 _N_ _S_ "U(P)U(P)" {_A_ 2 _U_ 22 _N_ _N_ _F_ _IF_ARGS_ 0 2 XX 1 \ (u0 :: Int#) (u1 :: Int#) -> _#_ gtInt# [] [u0, u1] _N_} _F_ _IF_ARGS_ 0 2 CC 3 \ (u0 :: Int) (u1 :: Int) -> case u0 of { _ALG_ I# (u2 :: Int#) -> case u1 of { _ALG_ I# (u3 :: Int#) -> _#_ gtInt# [] [u2, u3]; _NO_DEFLT_ }; _NO_DEFLT_ } _N_,
- max = _A_ 2 _U_ 11 _N_ _S_ "U(P)U(P)" {_A_ 2 _U_ 22 _N_ _N_ _N_ _N_} _N_ _N_,
- min = _A_ 2 _U_ 11 _N_ _S_ "U(P)U(P)" {_A_ 2 _U_ 22 _N_ _N_ _N_ _N_} _N_ _N_,
- _tagCmp = _A_ 2 _U_ 11 _N_ _S_ "U(P)U(P)" {_A_ 2 _U_ 22 _N_ _N_ _N_ _N_} _N_ _N_ #-}
+ (<) = { _A_ 2 _U_ 11 _N_ _S_ "U(P)U(P)" {_A_ 2 _U_ 22 _N_ _N_ _F_ _IF_ARGS_ 0 2 XX 1 \ (u0 :: Int#) (u1 :: Int#) -> _#_ ltInt# [] [u0, u1] _N_} _F_ _IF_ARGS_ 0 2 CC 3 \ (u0 :: Int) (u1 :: Int) -> case u0 of { _ALG_ I# (u2 :: Int#) -> case u1 of { _ALG_ I# (u3 :: Int#) -> _#_ ltInt# [] [u2, u3]; _NO_DEFLT_ }; _NO_DEFLT_ } _N_ },
+ (<=) = { _A_ 2 _U_ 11 _N_ _S_ "U(P)U(P)" {_A_ 2 _U_ 22 _N_ _N_ _F_ _IF_ARGS_ 0 2 XX 1 \ (u0 :: Int#) (u1 :: Int#) -> _#_ leInt# [] [u0, u1] _N_} _F_ _IF_ARGS_ 0 2 CC 3 \ (u0 :: Int) (u1 :: Int) -> case u0 of { _ALG_ I# (u2 :: Int#) -> case u1 of { _ALG_ I# (u3 :: Int#) -> _#_ leInt# [] [u2, u3]; _NO_DEFLT_ }; _NO_DEFLT_ } _N_ },
+ (>=) = { _A_ 2 _U_ 11 _N_ _S_ "U(P)U(P)" {_A_ 2 _U_ 22 _N_ _N_ _F_ _IF_ARGS_ 0 2 XX 1 \ (u0 :: Int#) (u1 :: Int#) -> _#_ geInt# [] [u0, u1] _N_} _F_ _IF_ARGS_ 0 2 CC 3 \ (u0 :: Int) (u1 :: Int) -> case u0 of { _ALG_ I# (u2 :: Int#) -> case u1 of { _ALG_ I# (u3 :: Int#) -> _#_ geInt# [] [u2, u3]; _NO_DEFLT_ }; _NO_DEFLT_ } _N_ },
+ (>) = { _A_ 2 _U_ 11 _N_ _S_ "U(P)U(P)" {_A_ 2 _U_ 22 _N_ _N_ _F_ _IF_ARGS_ 0 2 XX 1 \ (u0 :: Int#) (u1 :: Int#) -> _#_ gtInt# [] [u0, u1] _N_} _F_ _IF_ARGS_ 0 2 CC 3 \ (u0 :: Int) (u1 :: Int) -> case u0 of { _ALG_ I# (u2 :: Int#) -> case u1 of { _ALG_ I# (u3 :: Int#) -> _#_ gtInt# [] [u2, u3]; _NO_DEFLT_ }; _NO_DEFLT_ } _N_ },
+ max = { _A_ 2 _U_ 11 _N_ _S_ "U(P)U(P)" {_A_ 2 _U_ 22 _N_ _N_ _N_ _N_} _N_ _N_ },
+ min = { _A_ 2 _U_ 11 _N_ _S_ "U(P)U(P)" {_A_ 2 _U_ 22 _N_ _N_ _N_ _N_} _N_ _N_ },
+ _tagCmp = { _A_ 2 _U_ 11 _N_ _S_ "U(P)U(P)" {_A_ 2 _U_ 22 _N_ _N_ _N_ _N_} _N_ _N_ } #-}
instance Ord Integer
{-# GHC_PRAGMA _M_ PreludeCore {-dfun-} _A_ 0 _N_ _N_ _N_ _F_ _IF_ARGS_ 0 0 X 9 _!_ _TUP_8 [{{Eq Integer}}, (Integer -> Integer -> Bool), (Integer -> Integer -> Bool), (Integer -> Integer -> Bool), (Integer -> Integer -> Bool), (Integer -> Integer -> Integer), (Integer -> Integer -> Integer), (Integer -> Integer -> _CMP_TAG)] [_DFUN_ Eq (Integer), _CONSTM_ Ord (<) (Integer), _CONSTM_ Ord (<=) (Integer), _CONSTM_ Ord (>=) (Integer), _CONSTM_ Ord (>) (Integer), _CONSTM_ Ord max (Integer), _CONSTM_ Ord min (Integer), _CONSTM_ Ord _tagCmp (Integer)] _N_
- (<) = _A_ 2 _U_ 11 _N_ _S_ "U(PPP)U(PPP)" {_A_ 4 _U_ 2221 _N_ _N_ _F_ _IF_ARGS_ 0 4 XXXC 3 \ (u0 :: Int#) (u1 :: Int#) (u2 :: ByteArray#) (u3 :: Integer) -> case u3 of { _ALG_ J# (u4 :: Int#) (u5 :: Int#) (u6 :: ByteArray#) -> case _#_ cmpInteger# [] [u0, u1, u2, u4, u5, u6] of { _PRIM_ (u7 :: Int#) -> _#_ ltInt# [] [u7, 0#] }; _NO_DEFLT_ } _N_} _F_ _IF_ARGS_ 0 2 CC 4 \ (u0 :: Integer) (u1 :: Integer) -> case u0 of { _ALG_ J# (u2 :: Int#) (u3 :: Int#) (u4 :: ByteArray#) -> case u1 of { _ALG_ J# (u5 :: Int#) (u6 :: Int#) (u7 :: ByteArray#) -> case _#_ cmpInteger# [] [u2, u3, u4, u5, u6, u7] of { _PRIM_ (u8 :: Int#) -> _#_ ltInt# [] [u8, 0#] }; _NO_DEFLT_ }; _NO_DEFLT_ } _N_,
- (<=) = _A_ 2 _U_ 11 _N_ _S_ "U(PPP)U(PPP)" {_A_ 4 _U_ 2221 _N_ _N_ _F_ _IF_ARGS_ 0 4 XXXC 3 \ (u0 :: Int#) (u1 :: Int#) (u2 :: ByteArray#) (u3 :: Integer) -> case u3 of { _ALG_ J# (u4 :: Int#) (u5 :: Int#) (u6 :: ByteArray#) -> case _#_ cmpInteger# [] [u0, u1, u2, u4, u5, u6] of { _PRIM_ (u7 :: Int#) -> _#_ leInt# [] [u7, 0#] }; _NO_DEFLT_ } _N_} _F_ _IF_ARGS_ 0 2 CC 4 \ (u0 :: Integer) (u1 :: Integer) -> case u0 of { _ALG_ J# (u2 :: Int#) (u3 :: Int#) (u4 :: ByteArray#) -> case u1 of { _ALG_ J# (u5 :: Int#) (u6 :: Int#) (u7 :: ByteArray#) -> case _#_ cmpInteger# [] [u2, u3, u4, u5, u6, u7] of { _PRIM_ (u8 :: Int#) -> _#_ leInt# [] [u8, 0#] }; _NO_DEFLT_ }; _NO_DEFLT_ } _N_,
- (>=) = _A_ 2 _U_ 11 _N_ _S_ "U(PPP)U(PPP)" {_A_ 4 _U_ 2221 _N_ _N_ _F_ _IF_ARGS_ 0 4 XXXC 3 \ (u0 :: Int#) (u1 :: Int#) (u2 :: ByteArray#) (u3 :: Integer) -> case u3 of { _ALG_ J# (u4 :: Int#) (u5 :: Int#) (u6 :: ByteArray#) -> case _#_ cmpInteger# [] [u0, u1, u2, u4, u5, u6] of { _PRIM_ (u7 :: Int#) -> _#_ geInt# [] [u7, 0#] }; _NO_DEFLT_ } _N_} _F_ _IF_ARGS_ 0 2 CC 4 \ (u0 :: Integer) (u1 :: Integer) -> case u0 of { _ALG_ J# (u2 :: Int#) (u3 :: Int#) (u4 :: ByteArray#) -> case u1 of { _ALG_ J# (u5 :: Int#) (u6 :: Int#) (u7 :: ByteArray#) -> case _#_ cmpInteger# [] [u2, u3, u4, u5, u6, u7] of { _PRIM_ (u8 :: Int#) -> _#_ geInt# [] [u8, 0#] }; _NO_DEFLT_ }; _NO_DEFLT_ } _N_,
- (>) = _A_ 2 _U_ 11 _N_ _S_ "U(PPP)U(PPP)" {_A_ 4 _U_ 2221 _N_ _N_ _F_ _IF_ARGS_ 0 4 XXXC 3 \ (u0 :: Int#) (u1 :: Int#) (u2 :: ByteArray#) (u3 :: Integer) -> case u3 of { _ALG_ J# (u4 :: Int#) (u5 :: Int#) (u6 :: ByteArray#) -> case _#_ cmpInteger# [] [u0, u1, u2, u4, u5, u6] of { _PRIM_ (u7 :: Int#) -> _#_ gtInt# [] [u7, 0#] }; _NO_DEFLT_ } _N_} _F_ _IF_ARGS_ 0 2 CC 4 \ (u0 :: Integer) (u1 :: Integer) -> case u0 of { _ALG_ J# (u2 :: Int#) (u3 :: Int#) (u4 :: ByteArray#) -> case u1 of { _ALG_ J# (u5 :: Int#) (u6 :: Int#) (u7 :: ByteArray#) -> case _#_ cmpInteger# [] [u2, u3, u4, u5, u6, u7] of { _PRIM_ (u8 :: Int#) -> _#_ gtInt# [] [u8, 0#] }; _NO_DEFLT_ }; _NO_DEFLT_ } _N_,
- max = _A_ 2 _U_ 11 _N_ _S_ "U(PPP)U(PPP)" {_A_ 4 _U_ 2221 _N_ _N_ _N_ _N_} _N_ _N_,
- min = _A_ 2 _U_ 11 _N_ _S_ "U(PPP)U(PPP)" {_A_ 4 _U_ 2221 _N_ _N_ _N_ _N_} _N_ _N_,
- _tagCmp = _A_ 2 _U_ 11 _N_ _S_ "U(PPP)U(PPP)" {_A_ 4 _U_ 2221 _N_ _N_ _N_ _N_} _N_ _N_ #-}
+ (<) = { _A_ 2 _U_ 11 _N_ _S_ "U(PPP)U(PPP)" {_A_ 4 _U_ 2221 _N_ _N_ _F_ _IF_ARGS_ 0 4 XXXC 3 \ (u0 :: Int#) (u1 :: Int#) (u2 :: ByteArray#) (u3 :: Integer) -> case u3 of { _ALG_ J# (u4 :: Int#) (u5 :: Int#) (u6 :: ByteArray#) -> case _#_ cmpInteger# [] [u0, u1, u2, u4, u5, u6] of { _PRIM_ (u7 :: Int#) -> _#_ ltInt# [] [u7, 0#] }; _NO_DEFLT_ } _N_} _F_ _IF_ARGS_ 0 2 CC 4 \ (u0 :: Integer) (u1 :: Integer) -> case u0 of { _ALG_ J# (u2 :: Int#) (u3 :: Int#) (u4 :: ByteArray#) -> case u1 of { _ALG_ J# (u5 :: Int#) (u6 :: Int#) (u7 :: ByteArray#) -> case _#_ cmpInteger# [] [u2, u3, u4, u5, u6, u7] of { _PRIM_ (u8 :: Int#) -> _#_ ltInt# [] [u8, 0#] }; _NO_DEFLT_ }; _NO_DEFLT_ } _N_ },
+ (<=) = { _A_ 2 _U_ 11 _N_ _S_ "U(PPP)U(PPP)" {_A_ 4 _U_ 2221 _N_ _N_ _F_ _IF_ARGS_ 0 4 XXXC 3 \ (u0 :: Int#) (u1 :: Int#) (u2 :: ByteArray#) (u3 :: Integer) -> case u3 of { _ALG_ J# (u4 :: Int#) (u5 :: Int#) (u6 :: ByteArray#) -> case _#_ cmpInteger# [] [u0, u1, u2, u4, u5, u6] of { _PRIM_ (u7 :: Int#) -> _#_ leInt# [] [u7, 0#] }; _NO_DEFLT_ } _N_} _F_ _IF_ARGS_ 0 2 CC 4 \ (u0 :: Integer) (u1 :: Integer) -> case u0 of { _ALG_ J# (u2 :: Int#) (u3 :: Int#) (u4 :: ByteArray#) -> case u1 of { _ALG_ J# (u5 :: Int#) (u6 :: Int#) (u7 :: ByteArray#) -> case _#_ cmpInteger# [] [u2, u3, u4, u5, u6, u7] of { _PRIM_ (u8 :: Int#) -> _#_ leInt# [] [u8, 0#] }; _NO_DEFLT_ }; _NO_DEFLT_ } _N_ },
+ (>=) = { _A_ 2 _U_ 11 _N_ _S_ "U(PPP)U(PPP)" {_A_ 4 _U_ 2221 _N_ _N_ _F_ _IF_ARGS_ 0 4 XXXC 3 \ (u0 :: Int#) (u1 :: Int#) (u2 :: ByteArray#) (u3 :: Integer) -> case u3 of { _ALG_ J# (u4 :: Int#) (u5 :: Int#) (u6 :: ByteArray#) -> case _#_ cmpInteger# [] [u0, u1, u2, u4, u5, u6] of { _PRIM_ (u7 :: Int#) -> _#_ geInt# [] [u7, 0#] }; _NO_DEFLT_ } _N_} _F_ _IF_ARGS_ 0 2 CC 4 \ (u0 :: Integer) (u1 :: Integer) -> case u0 of { _ALG_ J# (u2 :: Int#) (u3 :: Int#) (u4 :: ByteArray#) -> case u1 of { _ALG_ J# (u5 :: Int#) (u6 :: Int#) (u7 :: ByteArray#) -> case _#_ cmpInteger# [] [u2, u3, u4, u5, u6, u7] of { _PRIM_ (u8 :: Int#) -> _#_ geInt# [] [u8, 0#] }; _NO_DEFLT_ }; _NO_DEFLT_ } _N_ },
+ (>) = { _A_ 2 _U_ 11 _N_ _S_ "U(PPP)U(PPP)" {_A_ 4 _U_ 2221 _N_ _N_ _F_ _IF_ARGS_ 0 4 XXXC 3 \ (u0 :: Int#) (u1 :: Int#) (u2 :: ByteArray#) (u3 :: Integer) -> case u3 of { _ALG_ J# (u4 :: Int#) (u5 :: Int#) (u6 :: ByteArray#) -> case _#_ cmpInteger# [] [u0, u1, u2, u4, u5, u6] of { _PRIM_ (u7 :: Int#) -> _#_ gtInt# [] [u7, 0#] }; _NO_DEFLT_ } _N_} _F_ _IF_ARGS_ 0 2 CC 4 \ (u0 :: Integer) (u1 :: Integer) -> case u0 of { _ALG_ J# (u2 :: Int#) (u3 :: Int#) (u4 :: ByteArray#) -> case u1 of { _ALG_ J# (u5 :: Int#) (u6 :: Int#) (u7 :: ByteArray#) -> case _#_ cmpInteger# [] [u2, u3, u4, u5, u6, u7] of { _PRIM_ (u8 :: Int#) -> _#_ gtInt# [] [u8, 0#] }; _NO_DEFLT_ }; _NO_DEFLT_ } _N_ },
+ max = { _A_ 2 _U_ 11 _N_ _S_ "U(PPP)U(PPP)" {_A_ 4 _U_ 2221 _N_ _N_ _N_ _N_} _N_ _N_ },
+ min = { _A_ 2 _U_ 11 _N_ _S_ "U(PPP)U(PPP)" {_A_ 4 _U_ 2221 _N_ _N_ _N_ _N_} _N_ _N_ },
+ _tagCmp = { _A_ 2 _U_ 11 _N_ _S_ "U(PPP)U(PPP)" {_A_ 4 _U_ 2221 _N_ _N_ _N_ _N_} _N_ _N_ } #-}
instance Integral a => Ord (Ratio a)
{-# GHC_PRAGMA _M_ PreludeRatio {-dfun-} _A_ 2 _U_ 22 _N_ _N_ _N_ _N_ #-}
instance Ord (Ratio Integer)
{-# GHC_PRAGMA _M_ PreludeRatio {-dfun-} _A_ 0 _N_ _N_ _N_ _F_ _IF_ARGS_ 0 0 X 9 _!_ _TUP_8 [{{Eq (Ratio Integer)}}, (Ratio Integer -> Ratio Integer -> Bool), (Ratio Integer -> Ratio Integer -> Bool), (Ratio Integer -> Ratio Integer -> Bool), (Ratio Integer -> Ratio Integer -> Bool), (Ratio Integer -> Ratio Integer -> Ratio Integer), (Ratio Integer -> Ratio Integer -> Ratio Integer), (Ratio Integer -> Ratio Integer -> _CMP_TAG)] [_DFUN_ Eq (Ratio Integer), _CONSTM_ Ord (<) (Ratio Integer), _CONSTM_ Ord (<=) (Ratio Integer), _CONSTM_ Ord (>=) (Ratio Integer), _CONSTM_ Ord (>) (Ratio Integer), _CONSTM_ Ord max (Ratio Integer), _CONSTM_ Ord min (Ratio Integer), _CONSTM_ Ord _tagCmp (Ratio Integer)] _N_
- (<) = _A_ 2 _U_ 11 _N_ _S_ "U(U(PPP)U(PPP))U(U(PPP)U(PPP))" {_A_ 5 _U_ 22221 _N_ _N_ _N_ _N_} _N_ _N_,
- (<=) = _A_ 2 _U_ 11 _N_ _S_ "U(U(PPP)U(PPP))U(U(PPP)U(PPP))" {_A_ 5 _U_ 22221 _N_ _N_ _N_ _N_} _N_ _N_,
- (>=) = _A_ 2 _U_ 11 _N_ _S_ "U(U(PPP)U(PPP))U(U(PPP)U(PPP))" {_A_ 5 _U_ 22221 _N_ _N_ _N_ _N_} _N_ _N_,
- (>) = _A_ 2 _U_ 11 _N_ _S_ "U(U(PPP)U(PPP))U(U(PPP)U(PPP))" {_A_ 5 _U_ 22221 _N_ _N_ _N_ _N_} _N_ _N_,
- max = _A_ 2 _U_ 12 _N_ _S_ "U(U(PPP)U(PPP))U(U(PPP)U(PPP))" {_A_ 5 _U_ 22222 _N_ _N_ _N_ _N_} _N_ _N_,
- min = _A_ 2 _U_ 12 _N_ _S_ "U(U(PPP)U(PPP))U(U(PPP)U(PPP))" {_A_ 5 _U_ 22222 _N_ _N_ _N_ _N_} _N_ _N_,
- _tagCmp = _A_ 2 _U_ 11 _N_ _S_ "U(U(PPP)U(PPP))U(U(PPP)U(PPP))" {_A_ 5 _U_ 22221 _N_ _N_ _N_ _N_} _N_ _N_ #-}
+ (<) = { _A_ 2 _U_ 11 _N_ _S_ "U(U(PPP)U(PPP))U(U(PPP)U(PPP))" {_A_ 5 _U_ 22221 _N_ _N_ _N_ _N_} _N_ _N_ },
+ (<=) = { _A_ 2 _U_ 11 _N_ _S_ "U(U(PPP)U(PPP))U(U(PPP)U(PPP))" {_A_ 5 _U_ 22221 _N_ _N_ _N_ _N_} _N_ _N_ },
+ (>=) = { _A_ 2 _U_ 11 _N_ _S_ "U(U(PPP)U(PPP))U(U(PPP)U(PPP))" {_A_ 5 _U_ 22221 _N_ _N_ _N_ _N_} _N_ _N_ },
+ (>) = { _A_ 2 _U_ 11 _N_ _S_ "U(U(PPP)U(PPP))U(U(PPP)U(PPP))" {_A_ 5 _U_ 22221 _N_ _N_ _N_ _N_} _N_ _N_ },
+ max = { _A_ 2 _U_ 12 _N_ _S_ "U(U(PPP)U(PPP))U(U(PPP)U(PPP))" {_A_ 5 _U_ 22222 _N_ _N_ _N_ _N_} _N_ _N_ },
+ min = { _A_ 2 _U_ 12 _N_ _S_ "U(U(PPP)U(PPP))U(U(PPP)U(PPP))" {_A_ 5 _U_ 22222 _N_ _N_ _N_ _N_} _N_ _N_ },
+ _tagCmp = { _A_ 2 _U_ 11 _N_ _S_ "U(U(PPP)U(PPP))U(U(PPP)U(PPP))" {_A_ 5 _U_ 22221 _N_ _N_ _N_ _N_} _N_ _N_ } #-}
instance Ord a => Ord [a]
{-# GHC_PRAGMA _M_ PreludeBuiltin {-dfun-} _A_ 2 _U_ 12 _N_ _N_ _N_ _N_ #-}
+instance Ord [Bool]
+ {-# GHC_PRAGMA _M_ PreludeBuiltin {-dfun-} _A_ 0 _N_ _N_ _N_ _F_ _IF_ARGS_ 0 0 X 9 _!_ _TUP_8 [{{Eq [Bool]}}, ([Bool] -> [Bool] -> Bool), ([Bool] -> [Bool] -> Bool), ([Bool] -> [Bool] -> Bool), ([Bool] -> [Bool] -> Bool), ([Bool] -> [Bool] -> [Bool]), ([Bool] -> [Bool] -> [Bool]), ([Bool] -> [Bool] -> _CMP_TAG)] [_DFUN_ Eq ([Bool]), _CONSTM_ Ord (<) ([Bool]), _CONSTM_ Ord (<=) ([Bool]), _CONSTM_ Ord (>=) ([Bool]), _CONSTM_ Ord (>) ([Bool]), _CONSTM_ Ord max ([Bool]), _CONSTM_ Ord min ([Bool]), _CONSTM_ Ord _tagCmp ([Bool])] _N_
+ (<) = { _A_ 2 _U_ 11 _N_ _S_ "SS" _N_ _N_ },
+ (<=) = { _A_ 2 _U_ 11 _N_ _S_ "SS" _N_ _N_ },
+ (>=) = { _A_ 2 _U_ 11 _N_ _S_ "SS" _N_ _N_ },
+ (>) = { _A_ 2 _U_ 11 _N_ _S_ "SS" _N_ _N_ },
+ max = { _A_ 2 _U_ 22 _N_ _S_ "SS" _N_ _N_ },
+ min = { _A_ 2 _U_ 22 _N_ _S_ "SS" _N_ _N_ },
+ _tagCmp = { _A_ 2 _U_ 11 _N_ _S_ "SS" _N_ _N_ } #-}
instance Ord [Char]
{-# GHC_PRAGMA _M_ PreludeBuiltin {-dfun-} _A_ 0 _N_ _N_ _N_ _F_ _IF_ARGS_ 0 0 X 9 _!_ _TUP_8 [{{Eq [Char]}}, ([Char] -> [Char] -> Bool), ([Char] -> [Char] -> Bool), ([Char] -> [Char] -> Bool), ([Char] -> [Char] -> Bool), ([Char] -> [Char] -> [Char]), ([Char] -> [Char] -> [Char]), ([Char] -> [Char] -> _CMP_TAG)] [_DFUN_ Eq ([Char]), _CONSTM_ Ord (<) ([Char]), _CONSTM_ Ord (<=) ([Char]), _CONSTM_ Ord (>=) ([Char]), _CONSTM_ Ord (>) ([Char]), _CONSTM_ Ord max ([Char]), _CONSTM_ Ord min ([Char]), _CONSTM_ Ord _tagCmp ([Char])] _N_
- (<) = _A_ 2 _U_ 11 _N_ _S_ "SS" _N_ _N_,
- (<=) = _A_ 2 _U_ 11 _N_ _S_ "SS" _N_ _N_,
- (>=) = _A_ 2 _U_ 11 _N_ _S_ "SS" _N_ _N_,
- (>) = _A_ 2 _U_ 11 _N_ _S_ "SS" _N_ _N_,
- max = _A_ 2 _U_ 22 _N_ _S_ "SS" _N_ _N_,
- min = _A_ 2 _U_ 22 _N_ _S_ "SS" _N_ _N_,
- _tagCmp = _A_ 2 _U_ 11 _N_ _S_ "SS" _N_ _N_ #-}
+ (<) = { _A_ 2 _U_ 11 _N_ _S_ "SS" _N_ _N_ },
+ (<=) = { _A_ 2 _U_ 11 _N_ _S_ "SS" _N_ _N_ },
+ (>=) = { _A_ 2 _U_ 11 _N_ _S_ "SS" _N_ _N_ },
+ (>) = { _A_ 2 _U_ 11 _N_ _S_ "SS" _N_ _N_ },
+ max = { _A_ 2 _U_ 22 _N_ _S_ "SS" _N_ _N_ },
+ min = { _A_ 2 _U_ 22 _N_ _S_ "SS" _N_ _N_ },
+ _tagCmp = { _A_ 2 _U_ 11 _N_ _S_ "SS" _N_ _N_ } #-}
+instance Ord [Double]
+ {-# GHC_PRAGMA _M_ PreludeBuiltin {-dfun-} _A_ 0 _N_ _N_ _N_ _F_ _IF_ARGS_ 0 0 X 9 _!_ _TUP_8 [{{Eq [Double]}}, ([Double] -> [Double] -> Bool), ([Double] -> [Double] -> Bool), ([Double] -> [Double] -> Bool), ([Double] -> [Double] -> Bool), ([Double] -> [Double] -> [Double]), ([Double] -> [Double] -> [Double]), ([Double] -> [Double] -> _CMP_TAG)] [_DFUN_ Eq ([Double]), _CONSTM_ Ord (<) ([Double]), _CONSTM_ Ord (<=) ([Double]), _CONSTM_ Ord (>=) ([Double]), _CONSTM_ Ord (>) ([Double]), _CONSTM_ Ord max ([Double]), _CONSTM_ Ord min ([Double]), _CONSTM_ Ord _tagCmp ([Double])] _N_
+ (<) = { _A_ 2 _U_ 11 _N_ _S_ "SS" _N_ _N_ },
+ (<=) = { _A_ 2 _U_ 11 _N_ _S_ "SS" _N_ _N_ },
+ (>=) = { _A_ 2 _U_ 11 _N_ _S_ "SS" _N_ _N_ },
+ (>) = { _A_ 2 _U_ 11 _N_ _S_ "SS" _N_ _N_ },
+ max = { _A_ 2 _U_ 22 _N_ _S_ "SS" _N_ _N_ },
+ min = { _A_ 2 _U_ 22 _N_ _S_ "SS" _N_ _N_ },
+ _tagCmp = { _A_ 2 _U_ 11 _N_ _S_ "SS" _N_ _N_ } #-}
instance Ord [Int]
{-# GHC_PRAGMA _M_ PreludeBuiltin {-dfun-} _A_ 0 _N_ _N_ _N_ _F_ _IF_ARGS_ 0 0 X 9 _!_ _TUP_8 [{{Eq [Int]}}, ([Int] -> [Int] -> Bool), ([Int] -> [Int] -> Bool), ([Int] -> [Int] -> Bool), ([Int] -> [Int] -> Bool), ([Int] -> [Int] -> [Int]), ([Int] -> [Int] -> [Int]), ([Int] -> [Int] -> _CMP_TAG)] [_DFUN_ Eq ([Int]), _CONSTM_ Ord (<) ([Int]), _CONSTM_ Ord (<=) ([Int]), _CONSTM_ Ord (>=) ([Int]), _CONSTM_ Ord (>) ([Int]), _CONSTM_ Ord max ([Int]), _CONSTM_ Ord min ([Int]), _CONSTM_ Ord _tagCmp ([Int])] _N_
- (<) = _A_ 2 _U_ 11 _N_ _S_ "SS" _N_ _N_,
- (<=) = _A_ 2 _U_ 11 _N_ _S_ "SS" _N_ _N_,
- (>=) = _A_ 2 _U_ 11 _N_ _S_ "SS" _N_ _N_,
- (>) = _A_ 2 _U_ 11 _N_ _S_ "SS" _N_ _N_,
- max = _A_ 2 _U_ 22 _N_ _S_ "SS" _N_ _N_,
- min = _A_ 2 _U_ 22 _N_ _S_ "SS" _N_ _N_,
- _tagCmp = _A_ 2 _U_ 11 _N_ _S_ "SS" _N_ _N_ #-}
+ (<) = { _A_ 2 _U_ 11 _N_ _S_ "SS" _N_ _N_ },
+ (<=) = { _A_ 2 _U_ 11 _N_ _S_ "SS" _N_ _N_ },
+ (>=) = { _A_ 2 _U_ 11 _N_ _S_ "SS" _N_ _N_ },
+ (>) = { _A_ 2 _U_ 11 _N_ _S_ "SS" _N_ _N_ },
+ max = { _A_ 2 _U_ 22 _N_ _S_ "SS" _N_ _N_ },
+ min = { _A_ 2 _U_ 22 _N_ _S_ "SS" _N_ _N_ },
+ _tagCmp = { _A_ 2 _U_ 11 _N_ _S_ "SS" _N_ _N_ } #-}
+instance Ord [Integer]
+ {-# GHC_PRAGMA _M_ PreludeBuiltin {-dfun-} _A_ 0 _N_ _N_ _N_ _F_ _IF_ARGS_ 0 0 X 9 _!_ _TUP_8 [{{Eq [Integer]}}, ([Integer] -> [Integer] -> Bool), ([Integer] -> [Integer] -> Bool), ([Integer] -> [Integer] -> Bool), ([Integer] -> [Integer] -> Bool), ([Integer] -> [Integer] -> [Integer]), ([Integer] -> [Integer] -> [Integer]), ([Integer] -> [Integer] -> _CMP_TAG)] [_DFUN_ Eq ([Integer]), _CONSTM_ Ord (<) ([Integer]), _CONSTM_ Ord (<=) ([Integer]), _CONSTM_ Ord (>=) ([Integer]), _CONSTM_ Ord (>) ([Integer]), _CONSTM_ Ord max ([Integer]), _CONSTM_ Ord min ([Integer]), _CONSTM_ Ord _tagCmp ([Integer])] _N_
+ (<) = { _A_ 2 _U_ 11 _N_ _S_ "SS" _N_ _N_ },
+ (<=) = { _A_ 2 _U_ 11 _N_ _S_ "SS" _N_ _N_ },
+ (>=) = { _A_ 2 _U_ 11 _N_ _S_ "SS" _N_ _N_ },
+ (>) = { _A_ 2 _U_ 11 _N_ _S_ "SS" _N_ _N_ },
+ max = { _A_ 2 _U_ 22 _N_ _S_ "SS" _N_ _N_ },
+ min = { _A_ 2 _U_ 22 _N_ _S_ "SS" _N_ _N_ },
+ _tagCmp = { _A_ 2 _U_ 11 _N_ _S_ "SS" _N_ _N_ } #-}
+instance Ord [[Char]]
+ {-# GHC_PRAGMA _M_ PreludeBuiltin {-dfun-} _A_ 0 _N_ _N_ _N_ _F_ _IF_ARGS_ 0 0 X 9 _!_ _TUP_8 [{{Eq [[Char]]}}, ([[Char]] -> [[Char]] -> Bool), ([[Char]] -> [[Char]] -> Bool), ([[Char]] -> [[Char]] -> Bool), ([[Char]] -> [[Char]] -> Bool), ([[Char]] -> [[Char]] -> [[Char]]), ([[Char]] -> [[Char]] -> [[Char]]), ([[Char]] -> [[Char]] -> _CMP_TAG)] [_DFUN_ Eq ([[Char]]), _CONSTM_ Ord (<) ([[Char]]), _CONSTM_ Ord (<=) ([[Char]]), _CONSTM_ Ord (>=) ([[Char]]), _CONSTM_ Ord (>) ([[Char]]), _CONSTM_ Ord max ([[Char]]), _CONSTM_ Ord min ([[Char]]), _CONSTM_ Ord _tagCmp ([[Char]])] _N_
+ (<) = { _A_ 2 _U_ 11 _N_ _S_ "SS" _N_ _N_ },
+ (<=) = { _A_ 2 _U_ 11 _N_ _S_ "SS" _N_ _N_ },
+ (>=) = { _A_ 2 _U_ 11 _N_ _S_ "SS" _N_ _N_ },
+ (>) = { _A_ 2 _U_ 11 _N_ _S_ "SS" _N_ _N_ },
+ max = { _A_ 2 _U_ 22 _N_ _S_ "SS" _N_ _N_ },
+ min = { _A_ 2 _U_ 22 _N_ _S_ "SS" _N_ _N_ },
+ _tagCmp = { _A_ 2 _U_ 11 _N_ _S_ "SS" _N_ _N_ } #-}
+instance Ord [[Int]]
+ {-# GHC_PRAGMA _M_ PreludeBuiltin {-dfun-} _A_ 0 _N_ _N_ _N_ _F_ _IF_ARGS_ 0 0 X 9 _!_ _TUP_8 [{{Eq [[Int]]}}, ([[Int]] -> [[Int]] -> Bool), ([[Int]] -> [[Int]] -> Bool), ([[Int]] -> [[Int]] -> Bool), ([[Int]] -> [[Int]] -> Bool), ([[Int]] -> [[Int]] -> [[Int]]), ([[Int]] -> [[Int]] -> [[Int]]), ([[Int]] -> [[Int]] -> _CMP_TAG)] [_DFUN_ Eq ([[Int]]), _CONSTM_ Ord (<) ([[Int]]), _CONSTM_ Ord (<=) ([[Int]]), _CONSTM_ Ord (>=) ([[Int]]), _CONSTM_ Ord (>) ([[Int]]), _CONSTM_ Ord max ([[Int]]), _CONSTM_ Ord min ([[Int]]), _CONSTM_ Ord _tagCmp ([[Int]])] _N_
+ (<) = { _A_ 2 _U_ 11 _N_ _S_ "SS" _N_ _N_ },
+ (<=) = { _A_ 2 _U_ 11 _N_ _S_ "SS" _N_ _N_ },
+ (>=) = { _A_ 2 _U_ 11 _N_ _S_ "SS" _N_ _N_ },
+ (>) = { _A_ 2 _U_ 11 _N_ _S_ "SS" _N_ _N_ },
+ max = { _A_ 2 _U_ 22 _N_ _S_ "SS" _N_ _N_ },
+ min = { _A_ 2 _U_ 22 _N_ _S_ "SS" _N_ _N_ },
+ _tagCmp = { _A_ 2 _U_ 11 _N_ _S_ "SS" _N_ _N_ } #-}
instance Ord _Addr
{-# GHC_PRAGMA _M_ PreludeCore {-dfun-} _A_ 0 _N_ _N_ _N_ _F_ _IF_ARGS_ 0 0 X 9 _!_ _TUP_8 [{{Eq _Addr}}, (_Addr -> _Addr -> Bool), (_Addr -> _Addr -> Bool), (_Addr -> _Addr -> Bool), (_Addr -> _Addr -> Bool), (_Addr -> _Addr -> _Addr), (_Addr -> _Addr -> _Addr), (_Addr -> _Addr -> _CMP_TAG)] [_DFUN_ Eq (_Addr), _CONSTM_ Ord (<) (_Addr), _CONSTM_ Ord (<=) (_Addr), _CONSTM_ Ord (>=) (_Addr), _CONSTM_ Ord (>) (_Addr), _CONSTM_ Ord max (_Addr), _CONSTM_ Ord min (_Addr), _CONSTM_ Ord _tagCmp (_Addr)] _N_
- (<) = _A_ 2 _U_ 11 _N_ _S_ "U(P)U(P)" {_A_ 2 _U_ 22 _N_ _N_ _F_ _IF_ARGS_ 0 2 XX 1 \ (u0 :: Addr#) (u1 :: Addr#) -> _#_ ltAddr# [] [u0, u1] _N_} _F_ _IF_ARGS_ 0 2 CC 3 \ (u0 :: _Addr) (u1 :: _Addr) -> case u0 of { _ALG_ A# (u2 :: Addr#) -> case u1 of { _ALG_ A# (u3 :: Addr#) -> _#_ ltAddr# [] [u2, u3]; _NO_DEFLT_ }; _NO_DEFLT_ } _N_,
- (<=) = _A_ 2 _U_ 11 _N_ _S_ "U(P)U(P)" {_A_ 2 _U_ 22 _N_ _N_ _F_ _IF_ARGS_ 0 2 XX 1 \ (u0 :: Addr#) (u1 :: Addr#) -> _#_ leAddr# [] [u0, u1] _N_} _F_ _IF_ARGS_ 0 2 CC 3 \ (u0 :: _Addr) (u1 :: _Addr) -> case u0 of { _ALG_ A# (u2 :: Addr#) -> case u1 of { _ALG_ A# (u3 :: Addr#) -> _#_ leAddr# [] [u2, u3]; _NO_DEFLT_ }; _NO_DEFLT_ } _N_,
- (>=) = _A_ 2 _U_ 11 _N_ _S_ "U(P)U(P)" {_A_ 2 _U_ 22 _N_ _N_ _F_ _IF_ARGS_ 0 2 XX 1 \ (u0 :: Addr#) (u1 :: Addr#) -> _#_ geAddr# [] [u0, u1] _N_} _F_ _IF_ARGS_ 0 2 CC 3 \ (u0 :: _Addr) (u1 :: _Addr) -> case u0 of { _ALG_ A# (u2 :: Addr#) -> case u1 of { _ALG_ A# (u3 :: Addr#) -> _#_ geAddr# [] [u2, u3]; _NO_DEFLT_ }; _NO_DEFLT_ } _N_,
- (>) = _A_ 2 _U_ 11 _N_ _S_ "U(P)U(P)" {_A_ 2 _U_ 22 _N_ _N_ _F_ _IF_ARGS_ 0 2 XX 1 \ (u0 :: Addr#) (u1 :: Addr#) -> _#_ gtAddr# [] [u0, u1] _N_} _F_ _IF_ARGS_ 0 2 CC 3 \ (u0 :: _Addr) (u1 :: _Addr) -> case u0 of { _ALG_ A# (u2 :: Addr#) -> case u1 of { _ALG_ A# (u3 :: Addr#) -> _#_ gtAddr# [] [u2, u3]; _NO_DEFLT_ }; _NO_DEFLT_ } _N_,
- max = _A_ 2 _U_ 11 _N_ _S_ "U(P)U(P)" {_A_ 2 _U_ 22 _N_ _N_ _N_ _N_} _N_ _N_,
- min = _A_ 2 _U_ 11 _N_ _S_ "U(P)U(P)" {_A_ 2 _U_ 22 _N_ _N_ _N_ _N_} _N_ _N_,
- _tagCmp = _A_ 2 _U_ 11 _N_ _S_ "U(P)U(P)" {_A_ 2 _U_ 22 _N_ _N_ _N_ _N_} _N_ _N_ #-}
+ (<) = { _A_ 2 _U_ 11 _N_ _S_ "U(P)U(P)" {_A_ 2 _U_ 22 _N_ _N_ _F_ _IF_ARGS_ 0 2 XX 1 \ (u0 :: Addr#) (u1 :: Addr#) -> _#_ ltAddr# [] [u0, u1] _N_} _F_ _IF_ARGS_ 0 2 CC 3 \ (u0 :: _Addr) (u1 :: _Addr) -> case u0 of { _ALG_ A# (u2 :: Addr#) -> case u1 of { _ALG_ A# (u3 :: Addr#) -> _#_ ltAddr# [] [u2, u3]; _NO_DEFLT_ }; _NO_DEFLT_ } _N_ },
+ (<=) = { _A_ 2 _U_ 11 _N_ _S_ "U(P)U(P)" {_A_ 2 _U_ 22 _N_ _N_ _F_ _IF_ARGS_ 0 2 XX 1 \ (u0 :: Addr#) (u1 :: Addr#) -> _#_ leAddr# [] [u0, u1] _N_} _F_ _IF_ARGS_ 0 2 CC 3 \ (u0 :: _Addr) (u1 :: _Addr) -> case u0 of { _ALG_ A# (u2 :: Addr#) -> case u1 of { _ALG_ A# (u3 :: Addr#) -> _#_ leAddr# [] [u2, u3]; _NO_DEFLT_ }; _NO_DEFLT_ } _N_ },
+ (>=) = { _A_ 2 _U_ 11 _N_ _S_ "U(P)U(P)" {_A_ 2 _U_ 22 _N_ _N_ _F_ _IF_ARGS_ 0 2 XX 1 \ (u0 :: Addr#) (u1 :: Addr#) -> _#_ geAddr# [] [u0, u1] _N_} _F_ _IF_ARGS_ 0 2 CC 3 \ (u0 :: _Addr) (u1 :: _Addr) -> case u0 of { _ALG_ A# (u2 :: Addr#) -> case u1 of { _ALG_ A# (u3 :: Addr#) -> _#_ geAddr# [] [u2, u3]; _NO_DEFLT_ }; _NO_DEFLT_ } _N_ },
+ (>) = { _A_ 2 _U_ 11 _N_ _S_ "U(P)U(P)" {_A_ 2 _U_ 22 _N_ _N_ _F_ _IF_ARGS_ 0 2 XX 1 \ (u0 :: Addr#) (u1 :: Addr#) -> _#_ gtAddr# [] [u0, u1] _N_} _F_ _IF_ARGS_ 0 2 CC 3 \ (u0 :: _Addr) (u1 :: _Addr) -> case u0 of { _ALG_ A# (u2 :: Addr#) -> case u1 of { _ALG_ A# (u3 :: Addr#) -> _#_ gtAddr# [] [u2, u3]; _NO_DEFLT_ }; _NO_DEFLT_ } _N_ },
+ max = { _A_ 2 _U_ 11 _N_ _S_ "U(P)U(P)" {_A_ 2 _U_ 22 _N_ _N_ _N_ _N_} _N_ _N_ },
+ min = { _A_ 2 _U_ 11 _N_ _S_ "U(P)U(P)" {_A_ 2 _U_ 22 _N_ _N_ _N_ _N_} _N_ _N_ },
+ _tagCmp = { _A_ 2 _U_ 11 _N_ _S_ "U(P)U(P)" {_A_ 2 _U_ 22 _N_ _N_ _N_ _N_} _N_ _N_ } #-}
instance Ord _PackedString
{-# GHC_PRAGMA _M_ PreludePS {-dfun-} _A_ 0 _N_ _N_ _N_ _F_ _IF_ARGS_ 0 0 X 9 _!_ _TUP_8 [{{Eq _PackedString}}, (_PackedString -> _PackedString -> Bool), (_PackedString -> _PackedString -> Bool), (_PackedString -> _PackedString -> Bool), (_PackedString -> _PackedString -> Bool), (_PackedString -> _PackedString -> _PackedString), (_PackedString -> _PackedString -> _PackedString), (_PackedString -> _PackedString -> _CMP_TAG)] [_DFUN_ Eq (_PackedString), _CONSTM_ Ord (<) (_PackedString), _CONSTM_ Ord (<=) (_PackedString), _CONSTM_ Ord (>=) (_PackedString), _CONSTM_ Ord (>) (_PackedString), _CONSTM_ Ord max (_PackedString), _CONSTM_ Ord min (_PackedString), _CONSTM_ Ord _tagCmp (_PackedString)] _N_
- (<) = _A_ 2 _U_ 22 _N_ _S_ "SS" _N_ _N_,
- (<=) = _A_ 2 _U_ 22 _N_ _S_ "SS" _N_ _N_,
- (>=) = _A_ 2 _U_ 22 _N_ _S_ "SS" _N_ _N_,
- (>) = _A_ 2 _U_ 22 _N_ _S_ "SS" _N_ _N_,
- max = _A_ 2 _U_ 22 _N_ _N_ _N_ _N_,
- min = _A_ 2 _U_ 22 _N_ _N_ _N_ _N_,
- _tagCmp = _A_ 2 _U_ 22 _N_ _S_ "SS" _N_ _N_ #-}
+ (<) = { _A_ 2 _U_ 22 _N_ _S_ "SS" _N_ _N_ },
+ (<=) = { _A_ 2 _U_ 22 _N_ _S_ "SS" _N_ _N_ },
+ (>=) = { _A_ 2 _U_ 22 _N_ _S_ "SS" _N_ _N_ },
+ (>) = { _A_ 2 _U_ 22 _N_ _S_ "SS" _N_ _N_ },
+ max = { _A_ 2 _U_ 22 _N_ _S_ "SS" _N_ _N_ },
+ min = { _A_ 2 _U_ 22 _N_ _S_ "SS" _N_ _N_ },
+ _tagCmp = { _A_ 2 _U_ 22 _N_ _S_ "SS" _N_ _N_ } #-}
instance Ord _Word
{-# GHC_PRAGMA _M_ PreludeCore {-dfun-} _A_ 0 _N_ _N_ _N_ _F_ _IF_ARGS_ 0 0 X 9 _!_ _TUP_8 [{{Eq _Word}}, (_Word -> _Word -> Bool), (_Word -> _Word -> Bool), (_Word -> _Word -> Bool), (_Word -> _Word -> Bool), (_Word -> _Word -> _Word), (_Word -> _Word -> _Word), (_Word -> _Word -> _CMP_TAG)] [_DFUN_ Eq (_Word), _CONSTM_ Ord (<) (_Word), _CONSTM_ Ord (<=) (_Word), _CONSTM_ Ord (>=) (_Word), _CONSTM_ Ord (>) (_Word), _CONSTM_ Ord max (_Word), _CONSTM_ Ord min (_Word), _CONSTM_ Ord _tagCmp (_Word)] _N_
- (<) = _A_ 2 _U_ 11 _N_ _S_ "U(P)U(P)" {_A_ 2 _U_ 22 _N_ _N_ _F_ _IF_ARGS_ 0 2 XX 1 \ (u0 :: Word#) (u1 :: Word#) -> _#_ ltWord# [] [u0, u1] _N_} _F_ _IF_ARGS_ 0 2 CC 3 \ (u0 :: _Word) (u1 :: _Word) -> case u0 of { _ALG_ W# (u2 :: Word#) -> case u1 of { _ALG_ W# (u3 :: Word#) -> _#_ ltWord# [] [u2, u3]; _NO_DEFLT_ }; _NO_DEFLT_ } _N_,
- (<=) = _A_ 2 _U_ 11 _N_ _S_ "U(P)U(P)" {_A_ 2 _U_ 22 _N_ _N_ _F_ _IF_ARGS_ 0 2 XX 1 \ (u0 :: Word#) (u1 :: Word#) -> _#_ leWord# [] [u0, u1] _N_} _F_ _IF_ARGS_ 0 2 CC 3 \ (u0 :: _Word) (u1 :: _Word) -> case u0 of { _ALG_ W# (u2 :: Word#) -> case u1 of { _ALG_ W# (u3 :: Word#) -> _#_ leWord# [] [u2, u3]; _NO_DEFLT_ }; _NO_DEFLT_ } _N_,
- (>=) = _A_ 2 _U_ 11 _N_ _S_ "U(P)U(P)" {_A_ 2 _U_ 22 _N_ _N_ _F_ _IF_ARGS_ 0 2 XX 1 \ (u0 :: Word#) (u1 :: Word#) -> _#_ geWord# [] [u0, u1] _N_} _F_ _IF_ARGS_ 0 2 CC 3 \ (u0 :: _Word) (u1 :: _Word) -> case u0 of { _ALG_ W# (u2 :: Word#) -> case u1 of { _ALG_ W# (u3 :: Word#) -> _#_ geWord# [] [u2, u3]; _NO_DEFLT_ }; _NO_DEFLT_ } _N_,
- (>) = _A_ 2 _U_ 11 _N_ _S_ "U(P)U(P)" {_A_ 2 _U_ 22 _N_ _N_ _F_ _IF_ARGS_ 0 2 XX 1 \ (u0 :: Word#) (u1 :: Word#) -> _#_ gtWord# [] [u0, u1] _N_} _F_ _IF_ARGS_ 0 2 CC 3 \ (u0 :: _Word) (u1 :: _Word) -> case u0 of { _ALG_ W# (u2 :: Word#) -> case u1 of { _ALG_ W# (u3 :: Word#) -> _#_ gtWord# [] [u2, u3]; _NO_DEFLT_ }; _NO_DEFLT_ } _N_,
- max = _A_ 2 _U_ 11 _N_ _S_ "U(P)U(P)" {_A_ 2 _U_ 22 _N_ _N_ _N_ _N_} _N_ _N_,
- min = _A_ 2 _U_ 11 _N_ _S_ "U(P)U(P)" {_A_ 2 _U_ 22 _N_ _N_ _N_ _N_} _N_ _N_,
- _tagCmp = _A_ 2 _U_ 11 _N_ _S_ "U(P)U(P)" {_A_ 2 _U_ 22 _N_ _N_ _N_ _N_} _N_ _N_ #-}
+ (<) = { _A_ 2 _U_ 11 _N_ _S_ "U(P)U(P)" {_A_ 2 _U_ 22 _N_ _N_ _F_ _IF_ARGS_ 0 2 XX 1 \ (u0 :: Word#) (u1 :: Word#) -> _#_ ltWord# [] [u0, u1] _N_} _F_ _IF_ARGS_ 0 2 CC 3 \ (u0 :: _Word) (u1 :: _Word) -> case u0 of { _ALG_ W# (u2 :: Word#) -> case u1 of { _ALG_ W# (u3 :: Word#) -> _#_ ltWord# [] [u2, u3]; _NO_DEFLT_ }; _NO_DEFLT_ } _N_ },
+ (<=) = { _A_ 2 _U_ 11 _N_ _S_ "U(P)U(P)" {_A_ 2 _U_ 22 _N_ _N_ _F_ _IF_ARGS_ 0 2 XX 1 \ (u0 :: Word#) (u1 :: Word#) -> _#_ leWord# [] [u0, u1] _N_} _F_ _IF_ARGS_ 0 2 CC 3 \ (u0 :: _Word) (u1 :: _Word) -> case u0 of { _ALG_ W# (u2 :: Word#) -> case u1 of { _ALG_ W# (u3 :: Word#) -> _#_ leWord# [] [u2, u3]; _NO_DEFLT_ }; _NO_DEFLT_ } _N_ },
+ (>=) = { _A_ 2 _U_ 11 _N_ _S_ "U(P)U(P)" {_A_ 2 _U_ 22 _N_ _N_ _F_ _IF_ARGS_ 0 2 XX 1 \ (u0 :: Word#) (u1 :: Word#) -> _#_ geWord# [] [u0, u1] _N_} _F_ _IF_ARGS_ 0 2 CC 3 \ (u0 :: _Word) (u1 :: _Word) -> case u0 of { _ALG_ W# (u2 :: Word#) -> case u1 of { _ALG_ W# (u3 :: Word#) -> _#_ geWord# [] [u2, u3]; _NO_DEFLT_ }; _NO_DEFLT_ } _N_ },
+ (>) = { _A_ 2 _U_ 11 _N_ _S_ "U(P)U(P)" {_A_ 2 _U_ 22 _N_ _N_ _F_ _IF_ARGS_ 0 2 XX 1 \ (u0 :: Word#) (u1 :: Word#) -> _#_ gtWord# [] [u0, u1] _N_} _F_ _IF_ARGS_ 0 2 CC 3 \ (u0 :: _Word) (u1 :: _Word) -> case u0 of { _ALG_ W# (u2 :: Word#) -> case u1 of { _ALG_ W# (u3 :: Word#) -> _#_ gtWord# [] [u2, u3]; _NO_DEFLT_ }; _NO_DEFLT_ } _N_ },
+ max = { _A_ 2 _U_ 11 _N_ _S_ "U(P)U(P)" {_A_ 2 _U_ 22 _N_ _N_ _N_ _N_} _N_ _N_ },
+ min = { _A_ 2 _U_ 11 _N_ _S_ "U(P)U(P)" {_A_ 2 _U_ 22 _N_ _N_ _N_ _N_} _N_ _N_ },
+ _tagCmp = { _A_ 2 _U_ 11 _N_ _S_ "U(P)U(P)" {_A_ 2 _U_ 22 _N_ _N_ _N_ _N_} _N_ _N_ } #-}
instance Real Double
{-# GHC_PRAGMA _M_ PreludeCore {-dfun-} _A_ 0 _N_ _N_ _N_ _F_ _IF_ARGS_ 0 0 X 4 _!_ _TUP_3 [{{Num Double}}, {{Enum Double}}, (Double -> Ratio Integer)] [_DFUN_ Num (Double), _DFUN_ Enum (Double), _CONSTM_ Real toRational (Double)] _N_
- toRational = _A_ 1 _U_ 1 _N_ _S_ "U(P)" {_A_ 1 _U_ 2 _N_ _N_ _N_ _N_} _N_ _N_ #-}
+ toRational = { _A_ 1 _U_ 1 _N_ _S_ "U(P)" {_A_ 1 _U_ 2 _N_ _N_ _N_ _N_} _N_ _N_ } #-}
instance Real Float
{-# GHC_PRAGMA _M_ PreludeCore {-dfun-} _A_ 0 _N_ _N_ _N_ _F_ _IF_ARGS_ 0 0 X 4 _!_ _TUP_3 [{{Num Float}}, {{Enum Float}}, (Float -> Ratio Integer)] [_DFUN_ Num (Float), _DFUN_ Enum (Float), _CONSTM_ Real toRational (Float)] _N_
- toRational = _A_ 1 _U_ 1 _N_ _S_ "U(P)" {_A_ 1 _U_ 2 _N_ _N_ _N_ _N_} _N_ _N_ #-}
+ toRational = { _A_ 1 _U_ 1 _N_ _S_ "U(P)" {_A_ 1 _U_ 2 _N_ _N_ _N_ _N_} _N_ _N_ } #-}
instance Real Int
{-# GHC_PRAGMA _M_ PreludeCore {-dfun-} _A_ 0 _N_ _N_ _N_ _F_ _IF_ARGS_ 0 0 X 4 _!_ _TUP_3 [{{Num Int}}, {{Enum Int}}, (Int -> Ratio Integer)] [_DFUN_ Num (Int), _DFUN_ Enum (Int), _CONSTM_ Real toRational (Int)] _N_
- toRational = _A_ 1 _U_ 1 _N_ _N_ _N_ _N_ #-}
+ toRational = { _A_ 1 _U_ 1 _N_ _N_ _N_ _N_ } #-}
instance Real Integer
{-# GHC_PRAGMA _M_ PreludeCore {-dfun-} _A_ 0 _N_ _N_ _N_ _F_ _IF_ARGS_ 0 0 X 4 _!_ _TUP_3 [{{Num Integer}}, {{Enum Integer}}, (Integer -> Ratio Integer)] [_DFUN_ Num (Integer), _DFUN_ Enum (Integer), _CONSTM_ Real toRational (Integer)] _N_
- toRational = _A_ 1 _U_ 2 _N_ _N_ _N_ _N_ #-}
+ toRational = { _A_ 1 _U_ 2 _N_ _N_ _F_ _IF_ARGS_ 0 1 X 3 \ (u0 :: Integer) -> _!_ (:%) [Integer] [u0, _ORIG_ PreludeCore __integer1] _N_ } #-}
instance Integral a => Real (Ratio a)
{-# GHC_PRAGMA _M_ PreludeRatio {-dfun-} _A_ 3 _U_ 122 _N_ _N_ _N_ _N_ #-}
instance Real (Ratio Integer)
{-# GHC_PRAGMA _M_ PreludeRatio {-dfun-} _A_ 0 _N_ _N_ _N_ _F_ _IF_ARGS_ 0 0 X 4 _!_ _TUP_3 [{{Num (Ratio Integer)}}, {{Enum (Ratio Integer)}}, (Ratio Integer -> Ratio Integer)] [_DFUN_ Num (Ratio Integer), _DFUN_ Enum (Ratio Integer), _CONSTM_ Real toRational (Ratio Integer)] _N_
- toRational = _A_ 1 _U_ 1 _N_ _S_ "U(LL)" {_A_ 2 _U_ 22 _N_ _N_ _F_ _IF_ARGS_ 0 2 XX 3 \ (u0 :: Integer) (u1 :: Integer) -> _!_ (:%) [Integer] [u0, u1] _N_} _F_ _IF_ARGS_ 0 1 X 1 \ (u0 :: Ratio Integer) -> u0 _N_ #-}
+ toRational = { _A_ 1 _U_ 1 _N_ _S_ "U(LL)" {_A_ 2 _U_ 22 _N_ _N_ _F_ _IF_ARGS_ 0 2 XX 3 \ (u0 :: Integer) (u1 :: Integer) -> _!_ (:%) [Integer] [u0, u1] _N_} _F_ _IF_ARGS_ 0 1 X 1 \ (u0 :: Ratio Integer) -> u0 _N_ } #-}
instance RealFloat Double
{-# GHC_PRAGMA _M_ PreludeCore {-dfun-} _A_ 0 _N_ _N_ _N_ _F_ _IF_ARGS_ 0 0 X 11 _!_ _TUP_10 [{{RealFrac Double}}, {{Floating Double}}, (Double -> Integer), (Double -> Int), (Double -> (Int, Int)), (Double -> (Integer, Int)), (Integer -> Int -> Double), (Double -> Int), (Double -> Double), (Int -> Double -> Double)] [_DFUN_ RealFrac (Double), _DFUN_ Floating (Double), _CONSTM_ RealFloat floatRadix (Double), _CONSTM_ RealFloat floatDigits (Double), _CONSTM_ RealFloat floatRange (Double), _CONSTM_ RealFloat decodeFloat (Double), _CONSTM_ RealFloat encodeFloat (Double), _CONSTM_ RealFloat exponent (Double), _CONSTM_ RealFloat significand (Double), _CONSTM_ RealFloat scaleFloat (Double)] _N_
- floatRadix = _A_ 1 _U_ 0 _N_ _S_ "A" {_A_ 0 _N_ _N_ _N_ _F_ _IF_ARGS_ 0 0 X 1 _#_ int2Integer# [] [2#] _N_} _N_ _N_,
- floatDigits = _A_ 1 _U_ 0 _N_ _S_ "A" {_A_ 0 _N_ _N_ _N_ _F_ _IF_ARGS_ 0 0 X 2 _!_ I# [] [53#] _N_} _F_ _IF_ARGS_ 0 1 X 2 \ (u0 :: Double) -> _!_ I# [] [53#] _N_,
- floatRange = _A_ 1 _U_ 0 _N_ _S_ "A" {_A_ 0 _N_ _N_ _N_ _N_ _N_} _N_ _N_,
- decodeFloat = _A_ 1 _U_ 1 _N_ _S_ "U(P)" {_A_ 1 _U_ 2 _N_ _N_ _N_ _N_} _N_ _N_,
- encodeFloat = _A_ 2 _U_ 11 _N_ _S_ "U(PPP)U(P)" {_A_ 4 _U_ 2222 _N_ _N_ _F_ _IF_ARGS_ 0 4 XXXX 3 \ (u0 :: Int#) (u1 :: Int#) (u2 :: ByteArray#) (u3 :: Int#) -> case _#_ encodeDouble# [] [u0, u1, u2, u3] of { _PRIM_ (u4 :: Double#) -> _!_ D# [] [u4] } _N_} _F_ _IF_ARGS_ 0 2 CC 5 \ (u0 :: Integer) (u1 :: Int) -> case u0 of { _ALG_ J# (u2 :: Int#) (u3 :: Int#) (u4 :: ByteArray#) -> case u1 of { _ALG_ I# (u5 :: Int#) -> case _#_ encodeDouble# [] [u2, u3, u4, u5] of { _PRIM_ (u6 :: Double#) -> _!_ D# [] [u6] }; _NO_DEFLT_ }; _NO_DEFLT_ } _N_,
- exponent = _A_ 1 _U_ 2 _N_ _N_ _N_ _N_,
- significand = _A_ 1 _U_ 2 _N_ _N_ _N_ _N_,
- scaleFloat = _A_ 2 _U_ 22 _N_ _N_ _N_ _N_ #-}
+ floatRadix = { _A_ 1 _U_ 0 _N_ _S_ "A" {_A_ 0 _N_ _N_ _N_ _N_ _N_} _N_ _N_ },
+ floatDigits = { _A_ 1 _U_ 0 _N_ _S_ "A" {_A_ 0 _N_ _N_ _N_ _F_ _IF_ARGS_ 0 0 X 2 _!_ I# [] [53#] _N_} _F_ _IF_ARGS_ 0 1 X 2 \ (u0 :: Double) -> _!_ I# [] [53#] _N_ },
+ floatRange = { _A_ 1 _U_ 0 _N_ _S_ "A" {_A_ 0 _N_ _N_ _N_ _N_ _N_} _N_ _N_ },
+ decodeFloat = { _A_ 1 _U_ 1 _N_ _S_ "U(P)" {_A_ 1 _U_ 2 _N_ _N_ _N_ _N_} _N_ _N_ },
+ encodeFloat = { _A_ 2 _U_ 11 _N_ _S_ "U(PPP)U(P)" {_A_ 4 _U_ 2222 _N_ _N_ _F_ _IF_ARGS_ 0 4 XXXX 3 \ (u0 :: Int#) (u1 :: Int#) (u2 :: ByteArray#) (u3 :: Int#) -> case _#_ encodeDouble# [] [u0, u1, u2, u3] of { _PRIM_ (u4 :: Double#) -> _!_ D# [] [u4] } _N_} _F_ _IF_ARGS_ 0 2 CC 5 \ (u0 :: Integer) (u1 :: Int) -> case u0 of { _ALG_ J# (u2 :: Int#) (u3 :: Int#) (u4 :: ByteArray#) -> case u1 of { _ALG_ I# (u5 :: Int#) -> case _#_ encodeDouble# [] [u2, u3, u4, u5] of { _PRIM_ (u6 :: Double#) -> _!_ D# [] [u6] }; _NO_DEFLT_ }; _NO_DEFLT_ } _N_ },
+ exponent = { _A_ 1 _U_ 1 _N_ _S_ "U(P)" {_A_ 1 _U_ 2 _N_ _N_ _N_ _N_} _N_ _N_ },
+ significand = { _A_ 1 _U_ 1 _N_ _S_ "U(P)" {_A_ 1 _U_ 2 _N_ _N_ _N_ _N_} _N_ _N_ },
+ scaleFloat = { _A_ 2 _U_ 11 _N_ _S_ "U(P)U(P)" {_A_ 2 _U_ 22 _N_ _N_ _N_ _N_} _N_ _N_ } #-}
instance RealFloat Float
{-# GHC_PRAGMA _M_ PreludeCore {-dfun-} _A_ 0 _N_ _N_ _N_ _F_ _IF_ARGS_ 0 0 X 11 _!_ _TUP_10 [{{RealFrac Float}}, {{Floating Float}}, (Float -> Integer), (Float -> Int), (Float -> (Int, Int)), (Float -> (Integer, Int)), (Integer -> Int -> Float), (Float -> Int), (Float -> Float), (Int -> Float -> Float)] [_DFUN_ RealFrac (Float), _DFUN_ Floating (Float), _CONSTM_ RealFloat floatRadix (Float), _CONSTM_ RealFloat floatDigits (Float), _CONSTM_ RealFloat floatRange (Float), _CONSTM_ RealFloat decodeFloat (Float), _CONSTM_ RealFloat encodeFloat (Float), _CONSTM_ RealFloat exponent (Float), _CONSTM_ RealFloat significand (Float), _CONSTM_ RealFloat scaleFloat (Float)] _N_
- floatRadix = _A_ 1 _U_ 0 _N_ _S_ "A" {_A_ 0 _N_ _N_ _N_ _F_ _IF_ARGS_ 0 0 X 1 _#_ int2Integer# [] [2#] _N_} _N_ _N_,
- floatDigits = _A_ 1 _U_ 0 _N_ _S_ "A" {_A_ 0 _N_ _N_ _N_ _F_ _IF_ARGS_ 0 0 X 2 _!_ I# [] [24#] _N_} _F_ _IF_ARGS_ 0 1 X 2 \ (u0 :: Float) -> _!_ I# [] [24#] _N_,
- floatRange = _A_ 1 _U_ 0 _N_ _S_ "A" {_A_ 0 _N_ _N_ _N_ _N_ _N_} _N_ _N_,
- decodeFloat = _A_ 1 _U_ 1 _N_ _S_ "U(P)" {_A_ 1 _U_ 2 _N_ _N_ _N_ _N_} _N_ _N_,
- encodeFloat = _A_ 2 _U_ 11 _N_ _S_ "U(PPP)U(P)" {_A_ 4 _U_ 2222 _N_ _N_ _F_ _IF_ARGS_ 0 4 XXXX 3 \ (u0 :: Int#) (u1 :: Int#) (u2 :: ByteArray#) (u3 :: Int#) -> case _#_ encodeFloat# [] [u0, u1, u2, u3] of { _PRIM_ (u4 :: Float#) -> _!_ F# [] [u4] } _N_} _F_ _IF_ARGS_ 0 2 CC 5 \ (u0 :: Integer) (u1 :: Int) -> case u0 of { _ALG_ J# (u2 :: Int#) (u3 :: Int#) (u4 :: ByteArray#) -> case u1 of { _ALG_ I# (u5 :: Int#) -> case _#_ encodeFloat# [] [u2, u3, u4, u5] of { _PRIM_ (u6 :: Float#) -> _!_ F# [] [u6] }; _NO_DEFLT_ }; _NO_DEFLT_ } _N_,
- exponent = _A_ 1 _U_ 2 _N_ _N_ _N_ _N_,
- significand = _A_ 1 _U_ 2 _N_ _N_ _N_ _N_,
- scaleFloat = _A_ 2 _U_ 22 _N_ _N_ _N_ _N_ #-}
+ floatRadix = { _A_ 1 _U_ 0 _N_ _S_ "A" {_A_ 0 _N_ _N_ _N_ _N_ _N_} _N_ _N_ },
+ floatDigits = { _A_ 1 _U_ 0 _N_ _S_ "A" {_A_ 0 _N_ _N_ _N_ _F_ _IF_ARGS_ 0 0 X 2 _!_ I# [] [24#] _N_} _F_ _IF_ARGS_ 0 1 X 2 \ (u0 :: Float) -> _!_ I# [] [24#] _N_ },
+ floatRange = { _A_ 1 _U_ 0 _N_ _S_ "A" {_A_ 0 _N_ _N_ _N_ _N_ _N_} _N_ _N_ },
+ decodeFloat = { _A_ 1 _U_ 1 _N_ _S_ "U(P)" {_A_ 1 _U_ 2 _N_ _N_ _N_ _N_} _N_ _N_ },
+ encodeFloat = { _A_ 2 _U_ 11 _N_ _S_ "U(PPP)U(P)" {_A_ 4 _U_ 2222 _N_ _N_ _F_ _IF_ARGS_ 0 4 XXXX 3 \ (u0 :: Int#) (u1 :: Int#) (u2 :: ByteArray#) (u3 :: Int#) -> case _#_ encodeFloat# [] [u0, u1, u2, u3] of { _PRIM_ (u4 :: Float#) -> _!_ F# [] [u4] } _N_} _F_ _IF_ARGS_ 0 2 CC 5 \ (u0 :: Integer) (u1 :: Int) -> case u0 of { _ALG_ J# (u2 :: Int#) (u3 :: Int#) (u4 :: ByteArray#) -> case u1 of { _ALG_ I# (u5 :: Int#) -> case _#_ encodeFloat# [] [u2, u3, u4, u5] of { _PRIM_ (u6 :: Float#) -> _!_ F# [] [u6] }; _NO_DEFLT_ }; _NO_DEFLT_ } _N_ },
+ exponent = { _A_ 1 _U_ 1 _N_ _S_ "U(P)" {_A_ 1 _U_ 2 _N_ _N_ _N_ _N_} _N_ _N_ },
+ significand = { _A_ 1 _U_ 1 _N_ _S_ "U(P)" {_A_ 1 _U_ 2 _N_ _N_ _N_ _N_} _N_ _N_ },
+ scaleFloat = { _A_ 2 _U_ 11 _N_ _S_ "U(P)U(P)" {_A_ 2 _U_ 22 _N_ _N_ _N_ _N_} _N_ _N_ } #-}
instance RealFrac Double
{-# GHC_PRAGMA _M_ PreludeCore {-dfun-} _A_ 0 _N_ _N_ _N_ _F_ _IF_ARGS_ 0 0 X 8 _!_ _TUP_7 [{{Real Double}}, {{Fractional Double}}, _forall_ a$z1 =>{{Integral a$z1}} -> (Double -> (a$z1, Double)), _forall_ a$z1 =>{{Integral a$z1}} -> (Double -> a$z1), _forall_ a$z1 =>{{Integral a$z1}} -> (Double -> a$z1), _forall_ a$z1 =>{{Integral a$z1}} -> (Double -> a$z1), _forall_ a$z1 =>{{Integral a$z1}} -> (Double -> a$z1)] [_DFUN_ Real (Double), _DFUN_ Fractional (Double), _CONSTM_ RealFrac properFraction (Double), _CONSTM_ RealFrac truncate (Double), _CONSTM_ RealFrac round (Double), _CONSTM_ RealFrac ceiling (Double), _CONSTM_ RealFrac floor (Double)] _N_
- properFraction = _A_ 1 _U_ 22 _N_ _N_ _N_ _N_,
- truncate = _A_ 1 _U_ 22 _N_ _N_ _N_ _N_,
- round = _A_ 1 _U_ 22 _N_ _N_ _N_ _N_,
- ceiling = _A_ 1 _U_ 22 _N_ _N_ _N_ _N_,
- floor = _A_ 1 _U_ 22 _N_ _N_ _N_ _N_ #-}
+ properFraction = { _A_ 1 _U_ 11 _N_ _N_ _N_ _SPECIALISE_ [ Int ] 1 { _A_ 1 _U_ 1 _N_ _S_ "U(P)" {_A_ 1 _U_ 2 _N_ _N_ _N_ _N_} _N_ _N_ }, [ Integer ] 1 { _A_ 1 _U_ 1 _N_ _S_ "U(P)" {_A_ 1 _U_ 2 _N_ _N_ _N_ _N_} _N_ _N_ } },
+ truncate = { _A_ 1 _U_ 11 _N_ _N_ _N_ _SPECIALISE_ [ Int ] 1 { _A_ 1 _U_ 1 _N_ _S_ "U(P)" {_A_ 1 _U_ 2 _N_ _N_ _F_ _IF_ARGS_ 0 1 X 4 \ (u0 :: Double#) -> case _APP_ _WRKR_ _SPEC_ _CONSTM_ RealFrac properFraction (Double) [ (Int) ] [ u0 ] of { _ALG_ _TUP_2 (u1 :: Int) (u2 :: Double) -> u1; _NO_DEFLT_ } _N_} _F_ _IF_ARGS_ 0 1 X 4 \ (u0 :: Double) -> case _APP_ _SPEC_ _CONSTM_ RealFrac properFraction (Double) [ (Int) ] [ u0 ] of { _ALG_ _TUP_2 (u1 :: Int) (u2 :: Double) -> u1; _NO_DEFLT_ } _N_ }, [ Integer ] 1 { _A_ 1 _U_ 1 _N_ _S_ "U(P)" {_A_ 1 _U_ 2 _N_ _N_ _F_ _IF_ARGS_ 0 1 X 4 \ (u0 :: Double#) -> case _APP_ _WRKR_ _SPEC_ _CONSTM_ RealFrac properFraction (Double) [ (Integer) ] [ u0 ] of { _ALG_ _TUP_2 (u1 :: Integer) (u2 :: Double) -> u1; _NO_DEFLT_ } _N_} _F_ _IF_ARGS_ 0 1 X 4 \ (u0 :: Double) -> case _APP_ _SPEC_ _CONSTM_ RealFrac properFraction (Double) [ (Integer) ] [ u0 ] of { _ALG_ _TUP_2 (u1 :: Integer) (u2 :: Double) -> u1; _NO_DEFLT_ } _N_ } },
+ round = { _A_ 1 _U_ 21 _N_ _N_ _N_ _SPECIALISE_ [ Int ] 1 { _A_ 1 _U_ 1 _N_ _S_ "U(P)" {_A_ 1 _U_ 2 _N_ _N_ _N_ _N_} _N_ _N_ }, [ Integer ] 1 { _A_ 1 _U_ 1 _N_ _S_ "U(P)" {_A_ 1 _U_ 2 _N_ _N_ _N_ _N_} _N_ _N_ } },
+ ceiling = { _A_ 1 _U_ 21 _N_ _N_ _N_ _SPECIALISE_ [ Int ] 1 { _A_ 1 _U_ 1 _N_ _S_ "U(P)" {_A_ 1 _U_ 2 _N_ _N_ _N_ _N_} _N_ _N_ }, [ Integer ] 1 { _A_ 1 _U_ 1 _N_ _S_ "U(P)" {_A_ 1 _U_ 2 _N_ _N_ _N_ _N_} _N_ _N_ } },
+ floor = { _A_ 1 _U_ 21 _N_ _N_ _N_ _SPECIALISE_ [ Int ] 1 { _A_ 1 _U_ 1 _N_ _S_ "U(P)" {_A_ 1 _U_ 2 _N_ _N_ _N_ _N_} _N_ _N_ }, [ Integer ] 1 { _A_ 1 _U_ 1 _N_ _S_ "U(P)" {_A_ 1 _U_ 2 _N_ _N_ _N_ _N_} _N_ _N_ } } #-}
instance RealFrac Float
{-# GHC_PRAGMA _M_ PreludeCore {-dfun-} _A_ 0 _N_ _N_ _N_ _F_ _IF_ARGS_ 0 0 X 8 _!_ _TUP_7 [{{Real Float}}, {{Fractional Float}}, _forall_ a$z1 =>{{Integral a$z1}} -> (Float -> (a$z1, Float)), _forall_ a$z1 =>{{Integral a$z1}} -> (Float -> a$z1), _forall_ a$z1 =>{{Integral a$z1}} -> (Float -> a$z1), _forall_ a$z1 =>{{Integral a$z1}} -> (Float -> a$z1), _forall_ a$z1 =>{{Integral a$z1}} -> (Float -> a$z1)] [_DFUN_ Real (Float), _DFUN_ Fractional (Float), _CONSTM_ RealFrac properFraction (Float), _CONSTM_ RealFrac truncate (Float), _CONSTM_ RealFrac round (Float), _CONSTM_ RealFrac ceiling (Float), _CONSTM_ RealFrac floor (Float)] _N_
- properFraction = _A_ 1 _U_ 22 _N_ _N_ _N_ _N_,
- truncate = _A_ 1 _U_ 22 _N_ _N_ _N_ _N_,
- round = _A_ 1 _U_ 22 _N_ _N_ _N_ _N_,
- ceiling = _A_ 1 _U_ 22 _N_ _N_ _N_ _N_,
- floor = _A_ 1 _U_ 22 _N_ _N_ _N_ _N_ #-}
-instance Integral a => RealFrac (Ratio a)
- {-# GHC_PRAGMA _M_ PreludeRatio {-dfun-} _A_ 3 _U_ 222 _N_ _N_ _N_ _N_ #-}
+ properFraction = { _A_ 1 _U_ 11 _N_ _N_ _N_ _SPECIALISE_ [ Int ] 1 { _A_ 1 _U_ 1 _N_ _S_ "U(P)" {_A_ 1 _U_ 2 _N_ _N_ _N_ _N_} _N_ _N_ }, [ Integer ] 1 { _A_ 1 _U_ 1 _N_ _S_ "U(P)" {_A_ 1 _U_ 2 _N_ _N_ _N_ _N_} _N_ _N_ } },
+ truncate = { _A_ 1 _U_ 11 _N_ _N_ _N_ _SPECIALISE_ [ Int ] 1 { _A_ 1 _U_ 1 _N_ _S_ "U(P)" {_A_ 1 _U_ 2 _N_ _N_ _F_ _IF_ARGS_ 0 1 X 4 \ (u0 :: Float#) -> case _APP_ _WRKR_ _SPEC_ _CONSTM_ RealFrac properFraction (Float) [ (Int) ] [ u0 ] of { _ALG_ _TUP_2 (u1 :: Int) (u2 :: Float) -> u1; _NO_DEFLT_ } _N_} _F_ _IF_ARGS_ 0 1 X 4 \ (u0 :: Float) -> case _APP_ _SPEC_ _CONSTM_ RealFrac properFraction (Float) [ (Int) ] [ u0 ] of { _ALG_ _TUP_2 (u1 :: Int) (u2 :: Float) -> u1; _NO_DEFLT_ } _N_ }, [ Integer ] 1 { _A_ 1 _U_ 1 _N_ _S_ "U(P)" {_A_ 1 _U_ 2 _N_ _N_ _F_ _IF_ARGS_ 0 1 X 4 \ (u0 :: Float#) -> case _APP_ _WRKR_ _SPEC_ _CONSTM_ RealFrac properFraction (Float) [ (Integer) ] [ u0 ] of { _ALG_ _TUP_2 (u1 :: Integer) (u2 :: Float) -> u1; _NO_DEFLT_ } _N_} _F_ _IF_ARGS_ 0 1 X 4 \ (u0 :: Float) -> case _APP_ _SPEC_ _CONSTM_ RealFrac properFraction (Float) [ (Integer) ] [ u0 ] of { _ALG_ _TUP_2 (u1 :: Integer) (u2 :: Float) -> u1; _NO_DEFLT_ } _N_ } },
+ round = { _A_ 1 _U_ 21 _N_ _N_ _N_ _SPECIALISE_ [ Int ] 1 { _A_ 1 _U_ 1 _N_ _S_ "U(P)" {_A_ 1 _U_ 2 _N_ _N_ _N_ _N_} _N_ _N_ }, [ Integer ] 1 { _A_ 1 _U_ 1 _N_ _S_ "U(P)" {_A_ 1 _U_ 2 _N_ _N_ _N_ _N_} _N_ _N_ } },
+ ceiling = { _A_ 1 _U_ 21 _N_ _N_ _N_ _SPECIALISE_ [ Int ] 1 { _A_ 1 _U_ 1 _N_ _S_ "U(P)" {_A_ 1 _U_ 2 _N_ _N_ _N_ _N_} _N_ _N_ }, [ Integer ] 1 { _A_ 1 _U_ 1 _N_ _S_ "U(P)" {_A_ 1 _U_ 2 _N_ _N_ _N_ _N_} _N_ _N_ } },
+ floor = { _A_ 1 _U_ 21 _N_ _N_ _N_ _SPECIALISE_ [ Int ] 1 { _A_ 1 _U_ 1 _N_ _S_ "U(P)" {_A_ 1 _U_ 2 _N_ _N_ _N_ _N_} _N_ _N_ }, [ Integer ] 1 { _A_ 1 _U_ 1 _N_ _S_ "U(P)" {_A_ 1 _U_ 2 _N_ _N_ _N_ _N_} _N_ _N_ } } #-}
instance RealFrac (Ratio Integer)
{-# GHC_PRAGMA _M_ PreludeRatio {-dfun-} _A_ 0 _N_ _N_ _N_ _F_ _IF_ARGS_ 0 0 X 8 _!_ _TUP_7 [{{Real (Ratio Integer)}}, {{Fractional (Ratio Integer)}}, _forall_ a$z1 =>{{Integral a$z1}} -> (Ratio Integer -> (a$z1, Ratio Integer)), _forall_ a$z1 =>{{Integral a$z1}} -> (Ratio Integer -> a$z1), _forall_ a$z1 =>{{Integral a$z1}} -> (Ratio Integer -> a$z1), _forall_ a$z1 =>{{Integral a$z1}} -> (Ratio Integer -> a$z1), _forall_ a$z1 =>{{Integral a$z1}} -> (Ratio Integer -> a$z1)] [_DFUN_ Real (Ratio Integer), _DFUN_ Fractional (Ratio Integer), _CONSTM_ RealFrac properFraction (Ratio Integer), _CONSTM_ RealFrac truncate (Ratio Integer), _CONSTM_ RealFrac round (Ratio Integer), _CONSTM_ RealFrac ceiling (Ratio Integer), _CONSTM_ RealFrac floor (Ratio Integer)] _N_
- properFraction = _A_ 2 _U_ 11 _N_ _S_ "LU(LL)" {_A_ 3 _U_ 112 _N_ _N_ _N_ _N_} _N_ _N_,
- truncate = _A_ 1 _U_ 22 _N_ _N_ _F_ _IF_ARGS_ 1 1 X 3 _/\_ u0 -> \ (u1 :: {{Integral u0}}) -> _APP_ _TYAPP_ _TYAPP_ _WRKR_ _ORIG_ PreludeCore _truncate { (Ratio Integer) } { u0 } [ _CONSTM_ RealFrac properFraction (Ratio Integer), u1 ] _N_,
- round = _A_ 1 _U_ 22 _N_ _N_ _N_ _N_,
- ceiling = _A_ 1 _U_ 22 _N_ _N_ _N_ _N_,
- floor = _A_ 1 _U_ 22 _N_ _N_ _N_ _N_ #-}
+ properFraction = { _A_ 2 _U_ 11 _N_ _S_ "LU(U(PPP)U(PPP))" {_A_ 5 _U_ 12222 _N_ _N_ _N_ _N_} _N_ _SPECIALISE_ [ Int ] 1 { _A_ 1 _U_ 1 _N_ _S_ "U(U(PPP)U(PPP))" {_A_ 4 _U_ 2222 _N_ _N_ _N_ _N_} _N_ _N_ }, [ Integer ] 1 { _A_ 1 _U_ 1 _N_ _S_ "U(U(PPP)U(PPP))" {_A_ 4 _U_ 2222 _N_ _N_ _N_ _N_} _N_ _N_ } },
+ truncate = { _A_ 2 _U_ 11 _N_ _N_ _N_ _SPECIALISE_ [ Int ] 1 { _A_ 1 _U_ 1 _N_ _S_ "U(U(PPP)U(PPP))" {_A_ 4 _U_ 2222 _N_ _N_ _F_ _IF_ARGS_ 0 4 XXXX 7 \ (u0 :: Int#) (u1 :: Int#) (u2 :: ByteArray#) (u3 :: Integer) -> case _APP_ _WRKR_ _SPEC_ _CONSTM_ RealFrac properFraction (Ratio Integer) [ (Int) ] [ u0, u1, u2, u3 ] of { _ALG_ _TUP_2 (u4 :: Int) (u5 :: Ratio Integer) -> u4; _NO_DEFLT_ } _N_} _F_ _IF_ARGS_ 0 1 X 4 \ (u0 :: Ratio Integer) -> case _APP_ _SPEC_ _CONSTM_ RealFrac properFraction (Ratio Integer) [ (Int) ] [ u0 ] of { _ALG_ _TUP_2 (u1 :: Int) (u2 :: Ratio Integer) -> u1; _NO_DEFLT_ } _N_ }, [ Integer ] 1 { _A_ 1 _U_ 1 _N_ _S_ "U(U(PPP)U(PPP))" {_A_ 4 _U_ 2222 _N_ _N_ _F_ _IF_ARGS_ 0 4 XXXX 7 \ (u0 :: Int#) (u1 :: Int#) (u2 :: ByteArray#) (u3 :: Integer) -> case _APP_ _WRKR_ _SPEC_ _CONSTM_ RealFrac properFraction (Ratio Integer) [ (Integer) ] [ u0, u1, u2, u3 ] of { _ALG_ _TUP_2 (u4 :: Integer) (u5 :: Ratio Integer) -> u4; _NO_DEFLT_ } _N_} _F_ _IF_ARGS_ 0 1 X 4 \ (u0 :: Ratio Integer) -> case _APP_ _SPEC_ _CONSTM_ RealFrac properFraction (Ratio Integer) [ (Integer) ] [ u0 ] of { _ALG_ _TUP_2 (u1 :: Integer) (u2 :: Ratio Integer) -> u1; _NO_DEFLT_ } _N_ } },
+ round = { _A_ 1 _U_ 21 _N_ _N_ _N_ _SPECIALISE_ [ Int ] 1 { _A_ 1 _U_ 1 _N_ _S_ "U(U(PPP)U(PPP))" {_A_ 4 _U_ 2222 _N_ _N_ _N_ _N_} _N_ _N_ }, [ Integer ] 1 { _A_ 1 _U_ 1 _N_ _S_ "U(U(PPP)U(PPP))" {_A_ 4 _U_ 2222 _N_ _N_ _N_ _N_} _N_ _N_ } },
+ ceiling = { _A_ 1 _U_ 21 _N_ _N_ _N_ _SPECIALISE_ [ Int ] 1 { _A_ 1 _U_ 1 _N_ _S_ "U(U(PPP)U(PPP))" {_A_ 4 _U_ 2222 _N_ _N_ _N_ _N_} _N_ _N_ }, [ Integer ] 1 { _A_ 1 _U_ 1 _N_ _S_ "U(U(PPP)U(PPP))" {_A_ 4 _U_ 2222 _N_ _N_ _N_ _N_} _N_ _N_ } },
+ floor = { _A_ 1 _U_ 21 _N_ _N_ _N_ _SPECIALISE_ [ Int ] 1 { _A_ 1 _U_ 1 _N_ _S_ "U(U(PPP)U(PPP))" {_A_ 4 _U_ 2222 _N_ _N_ _N_ _N_} _N_ _N_ }, [ Integer ] 1 { _A_ 1 _U_ 1 _N_ _S_ "U(U(PPP)U(PPP))" {_A_ 4 _U_ 2222 _N_ _N_ _N_ _N_} _N_ _N_ } } #-}
+instance Text ((Int, Int), (Int, Int))
+ {-# GHC_PRAGMA _M_ PreludeBuiltin {-dfun-} _A_ 0 _N_ _N_ _N_ _F_ _IF_ARGS_ 0 0 X 5 _!_ _TUP_4 [(Int -> [Char] -> [(((Int, Int), (Int, Int)), [Char])]), (Int -> ((Int, Int), (Int, Int)) -> [Char] -> [Char]), ([Char] -> [([((Int, Int), (Int, Int))], [Char])]), ([((Int, Int), (Int, Int))] -> [Char] -> [Char])] [_CONSTM_ Text readsPrec (((Int, Int), (Int, Int))), _CONSTM_ Text showsPrec (((Int, Int), (Int, Int))), _CONSTM_ Text readList (((Int, Int), (Int, Int))), _CONSTM_ Text showList (((Int, Int), (Int, Int)))] _N_
+ readsPrec = { _A_ 1 _U_ 02 _N_ _S_ "A" {_A_ 0 _U_ 2 _N_ _N_ _N_ _N_} _N_ _N_ },
+ showsPrec = { _A_ 3 _U_ 012 _N_ _S_ "AU(LL)L" {_A_ 3 _U_ 112 _N_ _N_ _N_ _N_} _N_ _N_ },
+ readList = { _A_ 0 _U_ 2 _N_ _N_ _N_ _N_ },
+ showList = { _A_ 1 _U_ 12 _N_ _N_ _N_ _N_ } #-}
instance Text ()
{-# GHC_PRAGMA _M_ PreludeBuiltin {-dfun-} _A_ 0 _N_ _N_ _N_ _F_ _IF_ARGS_ 0 0 X 5 _!_ _TUP_4 [(Int -> [Char] -> [((), [Char])]), (Int -> () -> [Char] -> [Char]), ([Char] -> [([()], [Char])]), ([()] -> [Char] -> [Char])] [_CONSTM_ Text readsPrec (()), _CONSTM_ Text showsPrec (()), _CONSTM_ Text readList (()), _CONSTM_ Text showList (())] _N_
- readsPrec = _A_ 1 _U_ 02 _N_ _S_ "A" {_A_ 0 _U_ 2 _N_ _N_ _N_ _N_} _N_ _N_,
- showsPrec = _A_ 3 _U_ 012 _N_ _S_ "AEL" {_A_ 2 _U_ 12 _N_ _N_ _F_ _IF_ARGS_ 0 2 CX 4 \ (u0 :: ()) (u1 :: [Char]) -> case u0 of { _ALG_ _TUP_0 -> _APP_ _TYAPP_ _ORIG_ PreludeList (++) { Char } [ _NOREP_S_ "()", u1 ]; _NO_DEFLT_ } _N_} _F_ _IF_ARGS_ 0 3 XCX 4 \ (u0 :: Int) (u1 :: ()) (u2 :: [Char]) -> case u1 of { _ALG_ _TUP_0 -> _APP_ _TYAPP_ _ORIG_ PreludeList (++) { Char } [ _NOREP_S_ "()", u2 ]; _NO_DEFLT_ } _N_,
- readList = _A_ 0 _U_ 2 _N_ _N_ _N_ _N_,
- showList = _A_ 0 _U_ 12 _N_ _N_ _N_ _N_ #-}
+ readsPrec = { _A_ 1 _U_ 02 _N_ _S_ "A" {_A_ 0 _U_ 2 _N_ _N_ _N_ _N_} _N_ _N_ },
+ showsPrec = { _A_ 3 _U_ 012 _N_ _S_ "AEL" {_A_ 2 _U_ 12 _N_ _N_ _F_ _IF_ARGS_ 0 2 CX 4 \ (u0 :: ()) (u1 :: [Char]) -> case u0 of { _ALG_ _TUP_0 -> _APP_ _TYAPP_ _ORIG_ PreludeList (++) { Char } [ _NOREP_S_ "()", u1 ]; _NO_DEFLT_ } _N_} _F_ _IF_ARGS_ 0 3 XCX 4 \ (u0 :: Int) (u1 :: ()) (u2 :: [Char]) -> case u1 of { _ALG_ _TUP_0 -> _APP_ _TYAPP_ _ORIG_ PreludeList (++) { Char } [ _NOREP_S_ "()", u2 ]; _NO_DEFLT_ } _N_ },
+ readList = { _A_ 0 _U_ 2 _N_ _N_ _N_ _N_ },
+ showList = { _A_ 1 _U_ 12 _N_ _N_ _N_ _N_ } #-}
instance (Text a, Text b) => Text (a, b)
{-# GHC_PRAGMA _M_ PreludeBuiltin {-dfun-} _A_ 2 _U_ 22 _N_ _N_ _N_ _N_ #-}
instance (Text a, Text b, Text c) => Text (a, b, c)
{-# GHC_PRAGMA _M_ PreludeBuiltin {-dfun-} _A_ 5 _U_ 22222 _N_ _N_ _N_ _N_ #-}
instance Text (Int, Int)
{-# GHC_PRAGMA _M_ PreludeBuiltin {-dfun-} _A_ 0 _N_ _N_ _N_ _F_ _IF_ARGS_ 0 0 X 5 _!_ _TUP_4 [(Int -> [Char] -> [((Int, Int), [Char])]), (Int -> (Int, Int) -> [Char] -> [Char]), ([Char] -> [([(Int, Int)], [Char])]), ([(Int, Int)] -> [Char] -> [Char])] [_CONSTM_ Text readsPrec ((Int, Int)), _CONSTM_ Text showsPrec ((Int, Int)), _CONSTM_ Text readList ((Int, Int)), _CONSTM_ Text showList ((Int, Int))] _N_
- readsPrec = _A_ 1 _U_ 02 _N_ _S_ "A" {_A_ 0 _U_ 2 _N_ _N_ _N_ _N_} _N_ _N_,
- showsPrec = _A_ 3 _U_ 012 _N_ _S_ "AU(LL)L" {_A_ 3 _U_ 112 _N_ _N_ _N_ _N_} _N_ _N_,
- readList = _A_ 0 _U_ 2 _N_ _N_ _N_ _N_,
- showList = _A_ 0 _U_ 12 _N_ _N_ _N_ _N_ #-}
+ readsPrec = { _A_ 1 _U_ 02 _N_ _S_ "A" {_A_ 0 _U_ 2 _N_ _N_ _N_ _N_} _N_ _N_ },
+ showsPrec = { _A_ 3 _U_ 012 _N_ _S_ "AU(LL)L" {_A_ 3 _U_ 112 _N_ _N_ _N_ _N_} _N_ _N_ },
+ readList = { _A_ 0 _U_ 2 _N_ _N_ _N_ _N_ },
+ showList = { _A_ 1 _U_ 12 _N_ _N_ _N_ _N_ } #-}
+instance Text (Int, Int, Int)
+ {-# GHC_PRAGMA _M_ PreludeBuiltin {-dfun-} _A_ 0 _N_ _N_ _N_ _F_ _IF_ARGS_ 0 0 X 5 _!_ _TUP_4 [(Int -> [Char] -> [((Int, Int, Int), [Char])]), (Int -> (Int, Int, Int) -> [Char] -> [Char]), ([Char] -> [([(Int, Int, Int)], [Char])]), ([(Int, Int, Int)] -> [Char] -> [Char])] [_CONSTM_ Text readsPrec ((Int, Int, Int)), _CONSTM_ Text showsPrec ((Int, Int, Int)), _CONSTM_ Text readList ((Int, Int, Int)), _CONSTM_ Text showList ((Int, Int, Int))] _N_
+ readsPrec = { _A_ 1 _U_ 02 _N_ _S_ "A" {_A_ 0 _U_ 2 _N_ _N_ _N_ _N_} _N_ _N_ },
+ showsPrec = { _A_ 3 _U_ 012 _N_ _S_ "AU(LLL)L" {_A_ 4 _U_ 1112 _N_ _N_ _N_ _N_} _N_ _N_ },
+ readList = { _A_ 0 _U_ 2 _N_ _N_ _N_ _N_ },
+ showList = { _A_ 1 _U_ 12 _N_ _N_ _N_ _N_ } #-}
instance Text (Integer, Integer)
{-# GHC_PRAGMA _M_ PreludeBuiltin {-dfun-} _A_ 0 _N_ _N_ _N_ _F_ _IF_ARGS_ 0 0 X 5 _!_ _TUP_4 [(Int -> [Char] -> [((Integer, Integer), [Char])]), (Int -> (Integer, Integer) -> [Char] -> [Char]), ([Char] -> [([(Integer, Integer)], [Char])]), ([(Integer, Integer)] -> [Char] -> [Char])] [_CONSTM_ Text readsPrec ((Integer, Integer)), _CONSTM_ Text showsPrec ((Integer, Integer)), _CONSTM_ Text readList ((Integer, Integer)), _CONSTM_ Text showList ((Integer, Integer))] _N_
- readsPrec = _A_ 1 _U_ 02 _N_ _S_ "A" {_A_ 0 _U_ 2 _N_ _N_ _N_ _N_} _N_ _N_,
- showsPrec = _A_ 3 _U_ 012 _N_ _S_ "AU(LL)L" {_A_ 3 _U_ 112 _N_ _N_ _N_ _N_} _N_ _N_,
- readList = _A_ 0 _U_ 2 _N_ _N_ _N_ _N_,
- showList = _A_ 0 _U_ 12 _N_ _N_ _N_ _N_ #-}
+ readsPrec = { _A_ 1 _U_ 02 _N_ _S_ "A" {_A_ 0 _U_ 2 _N_ _N_ _N_ _N_} _N_ _N_ },
+ showsPrec = { _A_ 3 _U_ 012 _N_ _S_ "AU(LL)L" {_A_ 3 _U_ 112 _N_ _N_ _N_ _N_} _N_ _N_ },
+ readList = { _A_ 0 _U_ 2 _N_ _N_ _N_ _N_ },
+ showList = { _A_ 1 _U_ 12 _N_ _N_ _N_ _N_ } #-}
instance Text (a -> b)
{-# GHC_PRAGMA _M_ PreludeCore {-dfun-} _A_ 0 _N_ _N_ _N_ _N_ _N_ #-}
+instance Text (Array (Int, Int) Double)
+ {-# GHC_PRAGMA _M_ PreludeArray {-dfun-} _A_ 0 _N_ _N_ _N_ _F_ _IF_ARGS_ 0 0 X 5 _!_ _TUP_4 [(Int -> [Char] -> [(Array (Int, Int) Double, [Char])]), (Int -> Array (Int, Int) Double -> [Char] -> [Char]), ([Char] -> [([Array (Int, Int) Double], [Char])]), ([Array (Int, Int) Double] -> [Char] -> [Char])] [_CONSTM_ Text readsPrec (Array (Int, Int) Double), _CONSTM_ Text showsPrec (Array (Int, Int) Double), _CONSTM_ Text readList (Array (Int, Int) Double), _CONSTM_ Text showList (Array (Int, Int) Double)] _N_
+ readsPrec = { _A_ 1 _U_ 12 _N_ _S_ "U(P)" {_A_ 1 _U_ 22 _N_ _N_ _N_ _N_} _N_ _N_ },
+ showsPrec = { _A_ 2 _U_ 122 _N_ _N_ _N_ _N_ },
+ readList = { _A_ 0 _U_ 2 _N_ _N_ _N_ _N_ },
+ showList = { _A_ 0 _U_ 12 _N_ _N_ _N_ _N_ } #-}
instance (Ix a, Text a, Text b) => Text (Array a b)
{-# GHC_PRAGMA _M_ PreludeArray {-dfun-} _A_ 3 _U_ 222 _N_ _N_ _N_ _N_ #-}
+instance Text (Array Int Double)
+ {-# GHC_PRAGMA _M_ PreludeArray {-dfun-} _A_ 0 _N_ _N_ _N_ _F_ _IF_ARGS_ 0 0 X 5 _!_ _TUP_4 [(Int -> [Char] -> [(Array Int Double, [Char])]), (Int -> Array Int Double -> [Char] -> [Char]), ([Char] -> [([Array Int Double], [Char])]), ([Array Int Double] -> [Char] -> [Char])] [_CONSTM_ Text readsPrec (Array Int Double), _CONSTM_ Text showsPrec (Array Int Double), _CONSTM_ Text readList (Array Int Double), _CONSTM_ Text showList (Array Int Double)] _N_
+ readsPrec = { _A_ 1 _U_ 12 _N_ _S_ "U(P)" {_A_ 1 _U_ 22 _N_ _N_ _N_ _N_} _N_ _N_ },
+ showsPrec = { _A_ 2 _U_ 122 _N_ _N_ _N_ _N_ },
+ readList = { _A_ 0 _U_ 2 _N_ _N_ _N_ _N_ },
+ showList = { _A_ 0 _U_ 12 _N_ _N_ _N_ _N_ } #-}
instance (Text a, Text b) => Text (Assoc a b)
{-# GHC_PRAGMA _M_ PreludeArray {-dfun-} _A_ 2 _U_ 22 _N_ _N_ _N_ _N_ #-}
instance Text Bool
{-# GHC_PRAGMA _M_ PreludeCore {-dfun-} _A_ 0 _N_ _N_ _N_ _F_ _IF_ARGS_ 0 0 X 5 _!_ _TUP_4 [(Int -> [Char] -> [(Bool, [Char])]), (Int -> Bool -> [Char] -> [Char]), ([Char] -> [([Bool], [Char])]), ([Bool] -> [Char] -> [Char])] [_CONSTM_ Text readsPrec (Bool), _CONSTM_ Text showsPrec (Bool), _CONSTM_ Text readList (Bool), _CONSTM_ Text showList (Bool)] _N_
- readsPrec = _A_ 2 _U_ 02 _N_ _S_ "AL" {_A_ 1 _U_ 2 _N_ _N_ _N_ _N_} _N_ _N_,
- showsPrec = _A_ 3 _U_ 012 _N_ _S_ "AEL" {_A_ 2 _U_ 12 _N_ _N_ _N_ _N_} _N_ _N_,
- readList = _A_ 0 _U_ 2 _N_ _N_ _N_ _N_,
- showList = _A_ 0 _U_ 12 _N_ _N_ _N_ _N_ #-}
+ readsPrec = { _A_ 2 _U_ 02 _N_ _S_ "AL" {_A_ 1 _U_ 2 _N_ _N_ _N_ _N_} _N_ _N_ },
+ showsPrec = { _A_ 3 _U_ 012 _N_ _S_ "AEL" {_A_ 2 _U_ 12 _N_ _N_ _N_ _N_} _N_ _N_ },
+ readList = { _A_ 0 _U_ 2 _N_ _N_ _N_ _N_ },
+ showList = { _A_ 1 _U_ 12 _N_ _N_ _F_ _IF_ARGS_ 0 1 X 3 \ (u0 :: [Bool]) -> _APP_ _TYAPP_ _ORIG_ PreludeCore _showList { Bool } [ _WRKR_ _CONSTM_ Text showsPrec (Bool), u0 ] _N_ } #-}
instance Text Char
{-# GHC_PRAGMA _M_ PreludeCore {-dfun-} _A_ 0 _N_ _N_ _N_ _F_ _IF_ARGS_ 0 0 X 5 _!_ _TUP_4 [(Int -> [Char] -> [(Char, [Char])]), (Int -> Char -> [Char] -> [Char]), ([Char] -> [([Char], [Char])]), ([Char] -> [Char] -> [Char])] [_CONSTM_ Text readsPrec (Char), _CONSTM_ Text showsPrec (Char), _CONSTM_ Text readList (Char), _CONSTM_ Text showList (Char)] _N_
- readsPrec = _A_ 1 _U_ 02 _N_ _S_ "A" {_A_ 0 _U_ 2 _N_ _N_ _N_ _N_} _N_ _N_,
- showsPrec = _A_ 3 _U_ 012 _N_ _S_ "AU(P)L" {_A_ 2 _U_ 22 _N_ _N_ _N_ _N_} _N_ _N_,
- readList = _A_ 0 _U_ 2 _N_ _N_ _N_ _N_,
- showList = _A_ 1 _U_ 22 _N_ _N_ _N_ _N_ #-}
+ readsPrec = { _A_ 1 _U_ 02 _N_ _S_ "A" {_A_ 0 _U_ 2 _N_ _N_ _N_ _N_} _N_ _N_ },
+ showsPrec = { _A_ 3 _U_ 012 _N_ _S_ "AU(P)L" {_A_ 2 _U_ 22 _N_ _N_ _N_ _N_} _N_ _N_ },
+ readList = { _A_ 0 _U_ 2 _N_ _N_ _N_ _N_ },
+ showList = { _A_ 1 _U_ 22 _N_ _N_ _N_ _N_ } #-}
instance Text a => Text (Complex a)
{-# GHC_PRAGMA _M_ PreludeComplex {-dfun-} _A_ 1 _U_ 2 _N_ _N_ _N_ _N_ #-}
+instance Text (Complex Double)
+ {-# GHC_PRAGMA _M_ PreludeComplex {-dfun-} _A_ 0 _N_ _N_ _N_ _F_ _IF_ARGS_ 0 0 X 5 _!_ _TUP_4 [(Int -> [Char] -> [(Complex Double, [Char])]), (Int -> Complex Double -> [Char] -> [Char]), ([Char] -> [([Complex Double], [Char])]), ([Complex Double] -> [Char] -> [Char])] [_CONSTM_ Text readsPrec (Complex Double), _CONSTM_ Text showsPrec (Complex Double), _CONSTM_ Text readList (Complex Double), _CONSTM_ Text showList (Complex Double)] _N_
+ readsPrec = { _A_ 1 _U_ 12 _N_ _S_ "U(P)" {_A_ 1 _U_ 22 _N_ _N_ _N_ _N_} _N_ _N_ },
+ showsPrec = { _A_ 2 _U_ 112 _N_ _S_ "LU(LL)" {_A_ 3 _U_ 1222 _N_ _N_ _N_ _N_} _N_ _N_ },
+ readList = { _A_ 0 _U_ 2 _N_ _N_ _N_ _N_ },
+ showList = { _A_ 1 _U_ 12 _N_ _N_ _N_ _N_ } #-}
instance Text Double
{-# GHC_PRAGMA _M_ PreludeCore {-dfun-} _A_ 0 _N_ _N_ _N_ _F_ _IF_ARGS_ 0 0 X 5 _!_ _TUP_4 [(Int -> [Char] -> [(Double, [Char])]), (Int -> Double -> [Char] -> [Char]), ([Char] -> [([Double], [Char])]), ([Double] -> [Char] -> [Char])] [_CONSTM_ Text readsPrec (Double), _CONSTM_ Text showsPrec (Double), _CONSTM_ Text readList (Double), _CONSTM_ Text showList (Double)] _N_
- readsPrec = _A_ 2 _U_ 02 _N_ _S_ "AL" {_A_ 1 _U_ 2 _N_ _N_ _F_ _IF_ARGS_ 0 1 X 3 \ (u0 :: [Char]) -> _APP_ _SPEC_ _ORIG_ PreludeText readSigned [ (Double) ] [ _SPEC_ _ORIG_ PreludeText readFloat [ (Double) ], u0 ] _N_} _F_ _IF_ARGS_ 0 2 XX 3 \ (u0 :: Int) (u1 :: [Char]) -> _APP_ _SPEC_ _ORIG_ PreludeText readSigned [ (Double) ] [ _SPEC_ _ORIG_ PreludeText readFloat [ (Double) ], u1 ] _N_,
- showsPrec = _A_ 2 _U_ 212 _N_ _S_ "LU(P)" {_A_ 2 _U_ 222 _N_ _N_ _F_ _IF_ARGS_ 0 2 XX 4 \ (u0 :: Int) (u1 :: Double#) -> _APP_ _WRKR_ _SPEC_ _ORIG_ PreludeText showSigned [ (Double) ] [ _SPEC_ _ORIG_ PreludeText showFloat [ (Double) ], u0, u1 ] _N_} _F_ _IF_ARGS_ 0 2 XC 5 \ (u0 :: Int) (u1 :: Double) -> case u1 of { _ALG_ D# (u2 :: Double#) -> _APP_ _WRKR_ _SPEC_ _ORIG_ PreludeText showSigned [ (Double) ] [ _SPEC_ _ORIG_ PreludeText showFloat [ (Double) ], u0, u2 ]; _NO_DEFLT_ } _N_,
- readList = _A_ 0 _U_ 2 _N_ _N_ _N_ _N_,
- showList = _A_ 0 _U_ 12 _N_ _N_ _N_ _N_ #-}
+ readsPrec = { _A_ 2 _U_ 02 _N_ _S_ "AL" {_A_ 1 _U_ 2 _N_ _N_ _F_ _IF_ARGS_ 0 1 X 3 \ (u0 :: [Char]) -> _APP_ _SPEC_ _ORIG_ PreludeText readSigned [ (Double) ] [ _SPEC_ _ORIG_ PreludeText readFloat [ (Double) ], u0 ] _N_} _F_ _IF_ARGS_ 0 2 XX 3 \ (u0 :: Int) (u1 :: [Char]) -> _APP_ _SPEC_ _ORIG_ PreludeText readSigned [ (Double) ] [ _SPEC_ _ORIG_ PreludeText readFloat [ (Double) ], u1 ] _N_ },
+ showsPrec = { _A_ 2 _U_ 212 _N_ _S_ "LU(P)" {_A_ 2 _U_ 222 _N_ _N_ _F_ _IF_ARGS_ 0 2 XX 4 \ (u0 :: Int) (u1 :: Double#) -> _APP_ _WRKR_ _SPEC_ _ORIG_ PreludeText showSigned [ (Double) ] [ _SPEC_ _ORIG_ PreludeText showFloat [ (Double) ], u0, u1 ] _N_} _F_ _IF_ARGS_ 0 2 XC 5 \ (u0 :: Int) (u1 :: Double) -> case u1 of { _ALG_ D# (u2 :: Double#) -> _APP_ _WRKR_ _SPEC_ _ORIG_ PreludeText showSigned [ (Double) ] [ _SPEC_ _ORIG_ PreludeText showFloat [ (Double) ], u0, u2 ]; _NO_DEFLT_ } _N_ },
+ readList = { _A_ 0 _U_ 2 _N_ _N_ _N_ _N_ },
+ showList = { _A_ 1 _U_ 12 _N_ _N_ _N_ _N_ } #-}
instance Text Float
{-# GHC_PRAGMA _M_ PreludeCore {-dfun-} _A_ 0 _N_ _N_ _N_ _F_ _IF_ARGS_ 0 0 X 5 _!_ _TUP_4 [(Int -> [Char] -> [(Float, [Char])]), (Int -> Float -> [Char] -> [Char]), ([Char] -> [([Float], [Char])]), ([Float] -> [Char] -> [Char])] [_CONSTM_ Text readsPrec (Float), _CONSTM_ Text showsPrec (Float), _CONSTM_ Text readList (Float), _CONSTM_ Text showList (Float)] _N_
- readsPrec = _A_ 2 _U_ 02 _N_ _S_ "AL" {_A_ 1 _U_ 2 _N_ _N_ _N_ _N_} _N_ _N_,
- showsPrec = _A_ 1 _U_ 222 _N_ _N_ _N_ _N_,
- readList = _A_ 0 _U_ 2 _N_ _N_ _N_ _N_,
- showList = _A_ 0 _U_ 12 _N_ _N_ _N_ _N_ #-}
+ readsPrec = { _A_ 2 _U_ 02 _N_ _S_ "AL" {_A_ 1 _U_ 2 _N_ _N_ _N_ _N_} _N_ _N_ },
+ showsPrec = { _A_ 1 _U_ 222 _N_ _N_ _N_ _N_ },
+ readList = { _A_ 0 _U_ 2 _N_ _N_ _N_ _N_ },
+ showList = { _A_ 0 _U_ 12 _N_ _N_ _N_ _N_ } #-}
instance Text Int
{-# GHC_PRAGMA _M_ PreludeCore {-dfun-} _A_ 0 _N_ _N_ _N_ _F_ _IF_ARGS_ 0 0 X 5 _!_ _TUP_4 [(Int -> [Char] -> [(Int, [Char])]), (Int -> Int -> [Char] -> [Char]), ([Char] -> [([Int], [Char])]), ([Int] -> [Char] -> [Char])] [_CONSTM_ Text readsPrec (Int), _CONSTM_ Text showsPrec (Int), _CONSTM_ Text readList (Int), _CONSTM_ Text showList (Int)] _N_
- readsPrec = _A_ 2 _U_ 02 _N_ _S_ "AL" {_A_ 1 _U_ 2 _N_ _N_ _F_ _IF_ARGS_ 0 1 X 3 \ (u0 :: [Char]) -> _APP_ _SPEC_ _ORIG_ PreludeText readSigned [ (Int) ] [ _SPEC_ _ORIG_ PreludeText readDec [ (Int) ], u0 ] _N_} _F_ _IF_ARGS_ 0 2 XX 3 \ (u0 :: Int) (u1 :: [Char]) -> _APP_ _SPEC_ _ORIG_ PreludeText readSigned [ (Int) ] [ _SPEC_ _ORIG_ PreludeText readDec [ (Int) ], u1 ] _N_,
- showsPrec = _A_ 3 _U_ 212 _N_ _S_ "LU(P)L" {_A_ 3 _U_ 222 _N_ _N_ _N_ _N_} _N_ _N_,
- readList = _A_ 0 _U_ 2 _N_ _N_ _N_ _N_,
- showList = _A_ 0 _U_ 12 _N_ _N_ _N_ _N_ #-}
+ readsPrec = { _A_ 2 _U_ 02 _N_ _S_ "AL" {_A_ 1 _U_ 2 _N_ _N_ _F_ _IF_ARGS_ 0 1 X 3 \ (u0 :: [Char]) -> _APP_ _SPEC_ _ORIG_ PreludeText readSigned [ (Int) ] [ _SPEC_ _ORIG_ PreludeText readDec [ (Int) ], u0 ] _N_} _F_ _IF_ARGS_ 0 2 XX 3 \ (u0 :: Int) (u1 :: [Char]) -> _APP_ _SPEC_ _ORIG_ PreludeText readSigned [ (Int) ] [ _SPEC_ _ORIG_ PreludeText readDec [ (Int) ], u1 ] _N_ },
+ showsPrec = { _A_ 3 _U_ 212 _N_ _S_ "LU(P)L" {_A_ 3 _U_ 222 _N_ _N_ _N_ _N_} _N_ _N_ },
+ readList = { _A_ 0 _U_ 2 _N_ _N_ _N_ _N_ },
+ showList = { _A_ 1 _U_ 12 _N_ _N_ _N_ _N_ } #-}
instance Text Integer
{-# GHC_PRAGMA _M_ PreludeCore {-dfun-} _A_ 0 _N_ _N_ _N_ _F_ _IF_ARGS_ 0 0 X 5 _!_ _TUP_4 [(Int -> [Char] -> [(Integer, [Char])]), (Int -> Integer -> [Char] -> [Char]), ([Char] -> [([Integer], [Char])]), ([Integer] -> [Char] -> [Char])] [_CONSTM_ Text readsPrec (Integer), _CONSTM_ Text showsPrec (Integer), _CONSTM_ Text readList (Integer), _CONSTM_ Text showList (Integer)] _N_
- readsPrec = _A_ 2 _U_ 02 _N_ _S_ "AL" {_A_ 1 _U_ 2 _N_ _N_ _F_ _IF_ARGS_ 0 1 X 3 \ (u0 :: [Char]) -> _APP_ _SPEC_ _ORIG_ PreludeText readSigned [ (Integer) ] [ _SPEC_ _ORIG_ PreludeText readDec [ (Integer) ], u0 ] _N_} _F_ _IF_ARGS_ 0 2 XX 3 \ (u0 :: Int) (u1 :: [Char]) -> _APP_ _SPEC_ _ORIG_ PreludeText readSigned [ (Integer) ] [ _SPEC_ _ORIG_ PreludeText readDec [ (Integer) ], u1 ] _N_,
- showsPrec = _A_ 3 _U_ 212 _N_ _S_ "LU(PPP)L" {_A_ 5 _U_ 22222 _N_ _N_ _N_ _N_} _N_ _N_,
- readList = _A_ 0 _U_ 2 _N_ _N_ _N_ _N_,
- showList = _A_ 0 _U_ 12 _N_ _N_ _N_ _N_ #-}
+ readsPrec = { _A_ 2 _U_ 02 _N_ _S_ "AL" {_A_ 1 _U_ 2 _N_ _N_ _F_ _IF_ARGS_ 0 1 X 3 \ (u0 :: [Char]) -> _APP_ _SPEC_ _ORIG_ PreludeText readSigned [ (Integer) ] [ _SPEC_ _ORIG_ PreludeText readDec [ (Integer) ], u0 ] _N_} _F_ _IF_ARGS_ 0 2 XX 3 \ (u0 :: Int) (u1 :: [Char]) -> _APP_ _SPEC_ _ORIG_ PreludeText readSigned [ (Integer) ] [ _SPEC_ _ORIG_ PreludeText readDec [ (Integer) ], u1 ] _N_ },
+ showsPrec = { _A_ 3 _U_ 212 _N_ _S_ "LU(PPP)L" {_A_ 5 _U_ 22222 _N_ _N_ _N_ _N_} _N_ _N_ },
+ readList = { _A_ 0 _U_ 2 _N_ _N_ _N_ _N_ },
+ showList = { _A_ 1 _U_ 12 _N_ _N_ _N_ _N_ } #-}
instance Integral a => Text (Ratio a)
{-# GHC_PRAGMA _M_ PreludeRatio {-dfun-} _A_ 1 _U_ 2 _N_ _N_ _N_ _N_ #-}
instance Text (Ratio Integer)
{-# GHC_PRAGMA _M_ PreludeRatio {-dfun-} _A_ 0 _N_ _N_ _N_ _F_ _IF_ARGS_ 0 0 X 5 _!_ _TUP_4 [(Int -> [Char] -> [(Ratio Integer, [Char])]), (Int -> Ratio Integer -> [Char] -> [Char]), ([Char] -> [([Ratio Integer], [Char])]), ([Ratio Integer] -> [Char] -> [Char])] [_CONSTM_ Text readsPrec (Ratio Integer), _CONSTM_ Text showsPrec (Ratio Integer), _CONSTM_ Text readList (Ratio Integer), _CONSTM_ Text showList (Ratio Integer)] _N_
- readsPrec = _A_ 1 _U_ 12 _N_ _S_ "U(P)" {_A_ 1 _U_ 22 _N_ _N_ _N_ _N_} _N_ _N_,
- showsPrec = _A_ 2 _U_ 112 _N_ _S_ "LU(LL)" {_A_ 3 _U_ 1222 _N_ _N_ _N_ _N_} _N_ _N_,
- readList = _A_ 0 _U_ 2 _N_ _N_ _N_ _N_,
- showList = _A_ 0 _U_ 12 _N_ _N_ _N_ _N_ #-}
+ readsPrec = { _A_ 1 _U_ 12 _N_ _S_ "U(P)" {_A_ 1 _U_ 22 _N_ _N_ _N_ _N_} _N_ _N_ },
+ showsPrec = { _A_ 2 _U_ 112 _N_ _S_ "LU(LL)" {_A_ 3 _U_ 1222 _N_ _N_ _N_ _N_} _N_ _N_ },
+ readList = { _A_ 0 _U_ 2 _N_ _N_ _N_ _N_ },
+ showList = { _A_ 1 _U_ 12 _N_ _N_ _N_ _N_ } #-}
instance Text a => Text [a]
{-# GHC_PRAGMA _M_ PreludeBuiltin {-dfun-} _A_ 1 _U_ 2 _N_ _N_ _N_ _N_ #-}
+instance Text [Bool]
+ {-# GHC_PRAGMA _M_ PreludeBuiltin {-dfun-} _A_ 0 _N_ _N_ _N_ _F_ _IF_ARGS_ 0 0 X 5 _!_ _TUP_4 [(Int -> [Char] -> [([Bool], [Char])]), (Int -> [Bool] -> [Char] -> [Char]), ([Char] -> [([[Bool]], [Char])]), ([[Bool]] -> [Char] -> [Char])] [_CONSTM_ Text readsPrec ([Bool]), _CONSTM_ Text showsPrec ([Bool]), _CONSTM_ Text readList ([Bool]), _CONSTM_ Text showList ([Bool])] _N_
+ readsPrec = { _A_ 1 _U_ 02 _N_ _S_ "A" {_A_ 0 _U_ 2 _N_ _N_ _F_ _IF_ARGS_ 0 0 X 1 _CONSTM_ Text readList (Bool) _N_} _F_ _IF_ARGS_ 0 1 X 1 \ (u0 :: Int) -> _CONSTM_ Text readList (Bool) _N_ },
+ showsPrec = { _A_ 2 _U_ 012 _N_ _S_ "AS" {_A_ 1 _U_ 12 _N_ _N_ _F_ _IF_ARGS_ 0 1 X 3 \ (u0 :: [Bool]) -> _APP_ _TYAPP_ _ORIG_ PreludeCore _showList { Bool } [ _WRKR_ _CONSTM_ Text showsPrec (Bool), u0 ] _N_} _F_ _IF_ARGS_ 0 2 XX 3 \ (u0 :: Int) (u1 :: [Bool]) -> _APP_ _TYAPP_ _ORIG_ PreludeCore _showList { Bool } [ _WRKR_ _CONSTM_ Text showsPrec (Bool), u1 ] _N_ },
+ readList = { _A_ 0 _U_ 2 _N_ _N_ _N_ _N_ },
+ showList = { _A_ 1 _U_ 12 _N_ _N_ _N_ _N_ } #-}
instance Text [Char]
{-# GHC_PRAGMA _M_ PreludeBuiltin {-dfun-} _A_ 0 _N_ _N_ _N_ _F_ _IF_ARGS_ 0 0 X 5 _!_ _TUP_4 [(Int -> [Char] -> [([Char], [Char])]), (Int -> [Char] -> [Char] -> [Char]), ([Char] -> [([[Char]], [Char])]), ([[Char]] -> [Char] -> [Char])] [_CONSTM_ Text readsPrec ([Char]), _CONSTM_ Text showsPrec ([Char]), _CONSTM_ Text readList ([Char]), _CONSTM_ Text showList ([Char])] _N_
- readsPrec = _A_ 1 _U_ 02 _N_ _S_ "A" {_A_ 0 _U_ 2 _N_ _N_ _F_ _IF_ARGS_ 0 0 X 1 _CONSTM_ Text readList (Char) _N_} _F_ _IF_ARGS_ 0 1 X 1 \ (u0 :: Int) -> _CONSTM_ Text readList (Char) _N_,
- showsPrec = _A_ 2 _U_ 022 _N_ _S_ "AL" {_A_ 1 _U_ 22 _N_ _N_ _F_ _IF_ARGS_ 0 0 X 1 _CONSTM_ Text showList (Char) _N_} _F_ _IF_ARGS_ 0 2 XX 2 \ (u0 :: Int) (u1 :: [Char]) -> _APP_ _CONSTM_ Text showList (Char) [ u1 ] _N_,
- readList = _A_ 0 _U_ 2 _N_ _N_ _N_ _N_,
- showList = _A_ 0 _U_ 12 _N_ _N_ _N_ _N_ #-}
+ readsPrec = { _A_ 1 _U_ 02 _N_ _S_ "A" {_A_ 0 _U_ 2 _N_ _N_ _F_ _IF_ARGS_ 0 0 X 1 _CONSTM_ Text readList (Char) _N_} _F_ _IF_ARGS_ 0 1 X 1 \ (u0 :: Int) -> _CONSTM_ Text readList (Char) _N_ },
+ showsPrec = { _A_ 2 _U_ 022 _N_ _S_ "AL" {_A_ 1 _U_ 22 _N_ _N_ _F_ _IF_ARGS_ 0 0 X 1 _CONSTM_ Text showList (Char) _N_} _F_ _IF_ARGS_ 0 2 XX 2 \ (u0 :: Int) (u1 :: [Char]) -> _APP_ _CONSTM_ Text showList (Char) [ u1 ] _N_ },
+ readList = { _A_ 0 _U_ 2 _N_ _N_ _N_ _N_ },
+ showList = { _A_ 1 _U_ 12 _N_ _N_ _F_ _IF_ARGS_ 0 1 X 3 \ (u0 :: [[Char]]) -> _APP_ _TYAPP_ _ORIG_ PreludeCore _showList { [Char] } [ _CONSTM_ Text showList (Char), u0 ] _N_ } #-}
+instance Text [Complex Double]
+ {-# GHC_PRAGMA _M_ PreludeBuiltin {-dfun-} _A_ 0 _N_ _N_ _N_ _F_ _IF_ARGS_ 0 0 X 5 _!_ _TUP_4 [(Int -> [Char] -> [([Complex Double], [Char])]), (Int -> [Complex Double] -> [Char] -> [Char]), ([Char] -> [([[Complex Double]], [Char])]), ([[Complex Double]] -> [Char] -> [Char])] [_CONSTM_ Text readsPrec ([Complex Double]), _CONSTM_ Text showsPrec ([Complex Double]), _CONSTM_ Text readList ([Complex Double]), _CONSTM_ Text showList ([Complex Double])] _N_
+ readsPrec = { _A_ 1 _U_ 02 _N_ _S_ "A" {_A_ 0 _U_ 2 _N_ _N_ _F_ _IF_ARGS_ 0 0 X 1 _CONSTM_ Text readList (Complex Double) _N_} _F_ _IF_ARGS_ 0 1 X 1 \ (u0 :: Int) -> _CONSTM_ Text readList (Complex Double) _N_ },
+ showsPrec = { _A_ 2 _U_ 022 _N_ _S_ "AL" {_A_ 1 _U_ 22 _N_ _N_ _F_ _IF_ARGS_ 0 0 X 1 _CONSTM_ Text showList (Complex Double) _N_} _F_ _IF_ARGS_ 0 2 XX 2 \ (u0 :: Int) (u1 :: [Complex Double]) -> _APP_ _CONSTM_ Text showList (Complex Double) [ u1 ] _N_ },
+ readList = { _A_ 0 _U_ 2 _N_ _N_ _N_ _N_ },
+ showList = { _A_ 1 _U_ 12 _N_ _N_ _F_ _IF_ARGS_ 0 1 X 3 \ (u0 :: [[Complex Double]]) -> _APP_ _TYAPP_ _ORIG_ PreludeCore _showList { [Complex Double] } [ _CONSTM_ Text showList (Complex Double), u0 ] _N_ } #-}
+instance Text [Double]
+ {-# GHC_PRAGMA _M_ PreludeBuiltin {-dfun-} _A_ 0 _N_ _N_ _N_ _F_ _IF_ARGS_ 0 0 X 5 _!_ _TUP_4 [(Int -> [Char] -> [([Double], [Char])]), (Int -> [Double] -> [Char] -> [Char]), ([Char] -> [([[Double]], [Char])]), ([[Double]] -> [Char] -> [Char])] [_CONSTM_ Text readsPrec ([Double]), _CONSTM_ Text showsPrec ([Double]), _CONSTM_ Text readList ([Double]), _CONSTM_ Text showList ([Double])] _N_
+ readsPrec = { _A_ 1 _U_ 02 _N_ _S_ "A" {_A_ 0 _U_ 2 _N_ _N_ _F_ _IF_ARGS_ 0 0 X 1 _CONSTM_ Text readList (Double) _N_} _F_ _IF_ARGS_ 0 1 X 1 \ (u0 :: Int) -> _CONSTM_ Text readList (Double) _N_ },
+ showsPrec = { _A_ 2 _U_ 022 _N_ _S_ "AL" {_A_ 1 _U_ 22 _N_ _N_ _F_ _IF_ARGS_ 0 0 X 1 _CONSTM_ Text showList (Double) _N_} _F_ _IF_ARGS_ 0 2 XX 2 \ (u0 :: Int) (u1 :: [Double]) -> _APP_ _CONSTM_ Text showList (Double) [ u1 ] _N_ },
+ readList = { _A_ 0 _U_ 2 _N_ _N_ _N_ _N_ },
+ showList = { _A_ 1 _U_ 12 _N_ _N_ _F_ _IF_ARGS_ 0 1 X 3 \ (u0 :: [[Double]]) -> _APP_ _TYAPP_ _ORIG_ PreludeCore _showList { [Double] } [ _CONSTM_ Text showList (Double), u0 ] _N_ } #-}
instance Text [Int]
{-# GHC_PRAGMA _M_ PreludeBuiltin {-dfun-} _A_ 0 _N_ _N_ _N_ _F_ _IF_ARGS_ 0 0 X 5 _!_ _TUP_4 [(Int -> [Char] -> [([Int], [Char])]), (Int -> [Int] -> [Char] -> [Char]), ([Char] -> [([[Int]], [Char])]), ([[Int]] -> [Char] -> [Char])] [_CONSTM_ Text readsPrec ([Int]), _CONSTM_ Text showsPrec ([Int]), _CONSTM_ Text readList ([Int]), _CONSTM_ Text showList ([Int])] _N_
- readsPrec = _A_ 1 _U_ 02 _N_ _S_ "A" {_A_ 0 _U_ 2 _N_ _N_ _F_ _IF_ARGS_ 0 0 X 1 _CONSTM_ Text readList (Int) _N_} _F_ _IF_ARGS_ 0 1 X 1 \ (u0 :: Int) -> _CONSTM_ Text readList (Int) _N_,
- showsPrec = _A_ 1 _U_ 022 _N_ _S_ "A" {_A_ 0 _U_ 22 _N_ _N_ _F_ _IF_ARGS_ 0 0 X 1 _CONSTM_ Text showList (Int) _N_} _F_ _IF_ARGS_ 0 1 X 1 \ (u0 :: Int) -> _CONSTM_ Text showList (Int) _N_,
- readList = _A_ 0 _U_ 2 _N_ _N_ _N_ _N_,
- showList = _A_ 0 _U_ 12 _N_ _N_ _N_ _N_ #-}
+ readsPrec = { _A_ 1 _U_ 02 _N_ _S_ "A" {_A_ 0 _U_ 2 _N_ _N_ _F_ _IF_ARGS_ 0 0 X 1 _CONSTM_ Text readList (Int) _N_} _F_ _IF_ARGS_ 0 1 X 1 \ (u0 :: Int) -> _CONSTM_ Text readList (Int) _N_ },
+ showsPrec = { _A_ 2 _U_ 022 _N_ _S_ "AL" {_A_ 1 _U_ 22 _N_ _N_ _F_ _IF_ARGS_ 0 0 X 1 _CONSTM_ Text showList (Int) _N_} _F_ _IF_ARGS_ 0 2 XX 2 \ (u0 :: Int) (u1 :: [Int]) -> _APP_ _CONSTM_ Text showList (Int) [ u1 ] _N_ },
+ readList = { _A_ 0 _U_ 2 _N_ _N_ _N_ _N_ },
+ showList = { _A_ 1 _U_ 12 _N_ _N_ _F_ _IF_ARGS_ 0 1 X 3 \ (u0 :: [[Int]]) -> _APP_ _TYAPP_ _ORIG_ PreludeCore _showList { [Int] } [ _CONSTM_ Text showList (Int), u0 ] _N_ } #-}
+instance Text [Integer]
+ {-# GHC_PRAGMA _M_ PreludeBuiltin {-dfun-} _A_ 0 _N_ _N_ _N_ _F_ _IF_ARGS_ 0 0 X 5 _!_ _TUP_4 [(Int -> [Char] -> [([Integer], [Char])]), (Int -> [Integer] -> [Char] -> [Char]), ([Char] -> [([[Integer]], [Char])]), ([[Integer]] -> [Char] -> [Char])] [_CONSTM_ Text readsPrec ([Integer]), _CONSTM_ Text showsPrec ([Integer]), _CONSTM_ Text readList ([Integer]), _CONSTM_ Text showList ([Integer])] _N_
+ readsPrec = { _A_ 1 _U_ 02 _N_ _S_ "A" {_A_ 0 _U_ 2 _N_ _N_ _F_ _IF_ARGS_ 0 0 X 1 _CONSTM_ Text readList (Integer) _N_} _F_ _IF_ARGS_ 0 1 X 1 \ (u0 :: Int) -> _CONSTM_ Text readList (Integer) _N_ },
+ showsPrec = { _A_ 2 _U_ 022 _N_ _S_ "AL" {_A_ 1 _U_ 22 _N_ _N_ _F_ _IF_ARGS_ 0 0 X 1 _CONSTM_ Text showList (Integer) _N_} _F_ _IF_ARGS_ 0 2 XX 2 \ (u0 :: Int) (u1 :: [Integer]) -> _APP_ _CONSTM_ Text showList (Integer) [ u1 ] _N_ },
+ readList = { _A_ 0 _U_ 2 _N_ _N_ _N_ _N_ },
+ showList = { _A_ 1 _U_ 12 _N_ _N_ _F_ _IF_ARGS_ 0 1 X 3 \ (u0 :: [[Integer]]) -> _APP_ _TYAPP_ _ORIG_ PreludeCore _showList { [Integer] } [ _CONSTM_ Text showList (Integer), u0 ] _N_ } #-}
+instance Text [[Char]]
+ {-# GHC_PRAGMA _M_ PreludeBuiltin {-dfun-} _A_ 0 _N_ _N_ _N_ _F_ _IF_ARGS_ 0 0 X 5 _!_ _TUP_4 [(Int -> [Char] -> [([[Char]], [Char])]), (Int -> [[Char]] -> [Char] -> [Char]), ([Char] -> [([[[Char]]], [Char])]), ([[[Char]]] -> [Char] -> [Char])] [_CONSTM_ Text readsPrec ([[Char]]), _CONSTM_ Text showsPrec ([[Char]]), _CONSTM_ Text readList ([[Char]]), _CONSTM_ Text showList ([[Char]])] _N_
+ readsPrec = { _A_ 1 _U_ 02 _N_ _S_ "A" {_A_ 0 _U_ 2 _N_ _N_ _F_ _IF_ARGS_ 0 0 X 1 _CONSTM_ Text readList ([Char]) _N_} _F_ _IF_ARGS_ 0 1 X 1 \ (u0 :: Int) -> _CONSTM_ Text readList ([Char]) _N_ },
+ showsPrec = { _A_ 2 _U_ 012 _N_ _S_ "AS" {_A_ 1 _U_ 12 _N_ _N_ _F_ _IF_ARGS_ 0 1 X 3 \ (u0 :: [[Char]]) -> _APP_ _TYAPP_ _ORIG_ PreludeCore _showList { [Char] } [ _CONSTM_ Text showList (Char), u0 ] _N_} _F_ _IF_ARGS_ 0 2 XX 2 \ (u0 :: Int) (u1 :: [[Char]]) -> _APP_ _CONSTM_ Text showList ([Char]) [ u1 ] _N_ },
+ readList = { _A_ 0 _U_ 2 _N_ _N_ _N_ _N_ },
+ showList = { _A_ 1 _U_ 12 _N_ _N_ _N_ _N_ } #-}
+instance Text [[Int]]
+ {-# GHC_PRAGMA _M_ PreludeBuiltin {-dfun-} _A_ 0 _N_ _N_ _N_ _F_ _IF_ARGS_ 0 0 X 5 _!_ _TUP_4 [(Int -> [Char] -> [([[Int]], [Char])]), (Int -> [[Int]] -> [Char] -> [Char]), ([Char] -> [([[[Int]]], [Char])]), ([[[Int]]] -> [Char] -> [Char])] [_CONSTM_ Text readsPrec ([[Int]]), _CONSTM_ Text showsPrec ([[Int]]), _CONSTM_ Text readList ([[Int]]), _CONSTM_ Text showList ([[Int]])] _N_
+ readsPrec = { _A_ 1 _U_ 02 _N_ _S_ "A" {_A_ 0 _U_ 2 _N_ _N_ _F_ _IF_ARGS_ 0 0 X 1 _CONSTM_ Text readList ([Int]) _N_} _F_ _IF_ARGS_ 0 1 X 1 \ (u0 :: Int) -> _CONSTM_ Text readList ([Int]) _N_ },
+ showsPrec = { _A_ 2 _U_ 012 _N_ _S_ "AS" {_A_ 1 _U_ 12 _N_ _N_ _F_ _IF_ARGS_ 0 1 X 3 \ (u0 :: [[Int]]) -> _APP_ _TYAPP_ _ORIG_ PreludeCore _showList { [Int] } [ _CONSTM_ Text showList (Int), u0 ] _N_} _F_ _IF_ARGS_ 0 2 XX 2 \ (u0 :: Int) (u1 :: [[Int]]) -> _APP_ _CONSTM_ Text showList ([Int]) [ u1 ] _N_ },
+ readList = { _A_ 0 _U_ 2 _N_ _N_ _N_ _N_ },
+ showList = { _A_ 1 _U_ 12 _N_ _N_ _N_ _N_ } #-}
instance Text _PackedString
{-# GHC_PRAGMA _M_ PreludePS {-dfun-} _A_ 0 _N_ _N_ _N_ _F_ _IF_ARGS_ 0 0 X 5 _!_ _TUP_4 [(Int -> [Char] -> [(_PackedString, [Char])]), (Int -> _PackedString -> [Char] -> [Char]), ([Char] -> [([_PackedString], [Char])]), ([_PackedString] -> [Char] -> [Char])] [_CONSTM_ Text readsPrec (_PackedString), _CONSTM_ Text showsPrec (_PackedString), _CONSTM_ Text readList (_PackedString), _CONSTM_ Text showList (_PackedString)] _N_
- readsPrec = _A_ 2 _U_ 02 _N_ _S_ _!_ _F_ _IF_ARGS_ 0 2 XX 3 \ (u0 :: Int) (u1 :: [Char]) -> _APP_ _TYAPP_ error { ([Char] -> [(_PackedString, [Char])]) } [ _NOREP_S_ "readsPrec: _PackedString: ToDo", u1 ] _N_,
- showsPrec = _A_ 3 _U_ 012 _N_ _S_ "ALL" {_A_ 2 _U_ 12 _N_ _N_ _N_ _N_} _F_ _IF_ARGS_ 0 3 XXX 6 \ (u0 :: Int) (u1 :: _PackedString) (u2 :: [Char]) -> let {(u3 :: [Char]) = _APP_ _ORIG_ PreludePS _unpackPS [ u1 ]} in _APP_ _CONSTM_ Text showList (Char) [ u3, u2 ] _N_,
- readList = _A_ 0 _U_ 2 _N_ _N_ _N_ _N_,
- showList = _A_ 0 _U_ 12 _N_ _N_ _N_ _N_ #-}
+ readsPrec = { _A_ 2 _U_ 02 _N_ _S_ _!_ _N_ _N_ },
+ showsPrec = { _A_ 3 _U_ 012 _N_ _S_ "ALL" {_A_ 2 _U_ 12 _N_ _N_ _N_ _N_} _F_ _IF_ARGS_ 0 3 XXX 6 \ (u0 :: Int) (u1 :: _PackedString) (u2 :: [Char]) -> let {(u3 :: [Char]) = _APP_ _ORIG_ PreludePS _unpackPS [ u1 ]} in _APP_ _CONSTM_ Text showList (Char) [ u3, u2 ] _N_ },
+ readList = { _A_ 0 _U_ 2 _N_ _N_ _N_ _N_ },
+ showList = { _A_ 1 _U_ 12 _N_ _N_ _F_ _IF_ARGS_ 0 1 X 3 \ (u0 :: [_PackedString]) -> _APP_ _TYAPP_ _ORIG_ PreludeCore _showList { _PackedString } [ _WRKR_ _CONSTM_ Text showsPrec (_PackedString), u0 ] _N_ } #-}
instance _CCallable Char
{-# GHC_PRAGMA _M_ PreludeCore {-dfun-} _A_ 0 _N_ _N_ _N_ _F_ _IF_ARGS_ 0 0 X 1 _!_ _TUP_0 [] [] _N_ #-}
instance _CCallable Double
-{-# GHC_PRAGMA INTERFACE VERSION 5 #-}
+{-# GHC_PRAGMA INTERFACE VERSION 6 #-}
interface PreludeCore where
import PreludeArray(Array, Assoc(..), _ByteArray)
import PreludeBuiltin(Bin, Char(..), Double(..), Float(..), Int(..), Integer(..), List(..), Tuple0, Tuple2, Tuple3, Tuple4, Tuple5, _Addr(..), _CMP_TAG(..), _Word(..))
class Binary a where
readBin :: Bin -> (a, Bin)
{-# GHC_PRAGMA {-meth-} _A_ 1 _U_ 12 _N_ _S_ "S" _F_ _IF_ARGS_ 1 1 C 2 _/\_ u0 -> \ (u1 :: (Bin -> (u0, Bin), u0 -> Bin -> Bin)) -> case u1 of { _ALG_ _TUP_2 (u2 :: Bin -> (u0, Bin)) (u3 :: u0 -> Bin -> Bin) -> u2; _NO_DEFLT_ } _N_
- {-defm-} _A_ 2 _U_ 02 _N_ _S_ _!_ _F_ _IF_ARGS_ 1 2 XX 3 _/\_ u0 -> \ (u1 :: {{Binary u0}}) (u2 :: Bin) -> _APP_ _TYAPP_ patError# { (Bin -> (u0, Bin)) } [ _NOREP_S_ "%DPreludeCore.Binary.readBin\"", u2 ] _N_ #-}
+ {-defm-} _A_ 2 _U_ 02 _N_ _S_ _!_ _N_ _N_ #-}
showBin :: a -> Bin -> Bin
{-# GHC_PRAGMA {-meth-} _A_ 1 _U_ 122 _N_ _S_ "S" _F_ _IF_ARGS_ 1 1 C 2 _/\_ u0 -> \ (u1 :: (Bin -> (u0, Bin), u0 -> Bin -> Bin)) -> case u1 of { _ALG_ _TUP_2 (u2 :: Bin -> (u0, Bin)) (u3 :: u0 -> Bin -> Bin) -> u3; _NO_DEFLT_ } _N_
- {-defm-} _A_ 3 _U_ 022 _N_ _S_ _!_ _F_ _IF_ARGS_ 1 3 XXX 4 _/\_ u0 -> \ (u1 :: {{Binary u0}}) (u2 :: u0) (u3 :: Bin) -> _APP_ _TYAPP_ patError# { (u0 -> Bin -> Bin) } [ _NOREP_S_ "%DPreludeCore.Binary.showBin\"", u2, u3 ] _N_ #-}
+ {-defm-} _A_ 3 _U_ 022 _N_ _S_ _!_ _N_ _N_ #-}
class (Ord a) => Enum a {-# GHC_PRAGMA {-superdicts-} _A_ 1 _U_ 1 _N_ _S_ "S" _F_ _IF_ARGS_ 1 1 C 2 _/\_ u0 -> \ (u1 :: ({{Ord u0}}, u0 -> [u0], u0 -> u0 -> [u0], u0 -> u0 -> [u0], u0 -> u0 -> u0 -> [u0])) -> case u1 of { _ALG_ _TUP_5 (u2 :: {{Ord u0}}) (u3 :: u0 -> [u0]) (u4 :: u0 -> u0 -> [u0]) (u5 :: u0 -> u0 -> [u0]) (u6 :: u0 -> u0 -> u0 -> [u0]) -> u2; _NO_DEFLT_ } _N_ #-} where
enumFrom :: a -> [a]
{-# GHC_PRAGMA {-meth-} _A_ 1 _U_ 12 _N_ _S_ "S" _F_ _IF_ARGS_ 1 1 C 2 _/\_ u0 -> \ (u1 :: ({{Ord u0}}, u0 -> [u0], u0 -> u0 -> [u0], u0 -> u0 -> [u0], u0 -> u0 -> u0 -> [u0])) -> case u1 of { _ALG_ _TUP_5 (u2 :: {{Ord u0}}) (u3 :: u0 -> [u0]) (u4 :: u0 -> u0 -> [u0]) (u5 :: u0 -> u0 -> [u0]) (u6 :: u0 -> u0 -> u0 -> [u0]) -> u3; _NO_DEFLT_ } _N_
- {-defm-} _A_ 2 _U_ 02 _N_ _S_ _!_ _F_ _IF_ARGS_ 1 2 XX 3 _/\_ u0 -> \ (u1 :: {{Enum u0}}) (u2 :: u0) -> _APP_ _TYAPP_ patError# { (u0 -> [u0]) } [ _NOREP_S_ "%DPreludeCore.Enum.enumFrom\"", u2 ] _N_ #-}
+ {-defm-} _A_ 2 _U_ 02 _N_ _S_ _!_ _N_ _N_ #-}
enumFromThen :: a -> a -> [a]
{-# GHC_PRAGMA {-meth-} _A_ 1 _U_ 122 _N_ _S_ "S" _F_ _IF_ARGS_ 1 1 C 2 _/\_ u0 -> \ (u1 :: ({{Ord u0}}, u0 -> [u0], u0 -> u0 -> [u0], u0 -> u0 -> [u0], u0 -> u0 -> u0 -> [u0])) -> case u1 of { _ALG_ _TUP_5 (u2 :: {{Ord u0}}) (u3 :: u0 -> [u0]) (u4 :: u0 -> u0 -> [u0]) (u5 :: u0 -> u0 -> [u0]) (u6 :: u0 -> u0 -> u0 -> [u0]) -> u4; _NO_DEFLT_ } _N_
- {-defm-} _A_ 3 _U_ 022 _N_ _S_ _!_ _F_ _IF_ARGS_ 1 3 XXX 4 _/\_ u0 -> \ (u1 :: {{Enum u0}}) (u2 :: u0) (u3 :: u0) -> _APP_ _TYAPP_ patError# { (u0 -> u0 -> [u0]) } [ _NOREP_S_ "%DPreludeCore.Enum.enumFromThen\"", u2, u3 ] _N_ #-}
+ {-defm-} _A_ 3 _U_ 022 _N_ _S_ _!_ _N_ _N_ #-}
enumFromTo :: a -> a -> [a]
{-# GHC_PRAGMA {-meth-} _A_ 1 _U_ 122 _N_ _S_ "S" _F_ _IF_ARGS_ 1 1 C 2 _/\_ u0 -> \ (u1 :: ({{Ord u0}}, u0 -> [u0], u0 -> u0 -> [u0], u0 -> u0 -> [u0], u0 -> u0 -> u0 -> [u0])) -> case u1 of { _ALG_ _TUP_5 (u2 :: {{Ord u0}}) (u3 :: u0 -> [u0]) (u4 :: u0 -> u0 -> [u0]) (u5 :: u0 -> u0 -> [u0]) (u6 :: u0 -> u0 -> u0 -> [u0]) -> u5; _NO_DEFLT_ } _N_
{-defm-} _A_ 3 _U_ 122 _N_ _S_ "SLL" _N_ _N_ #-}
class Eq a where
(==) :: a -> a -> Bool
{-# GHC_PRAGMA {-meth-} _A_ 1 _U_ 122 _N_ _S_ "S" _F_ _IF_ARGS_ 1 1 C 2 _/\_ u0 -> \ (u1 :: (u0 -> u0 -> Bool, u0 -> u0 -> Bool)) -> case u1 of { _ALG_ _TUP_2 (u2 :: u0 -> u0 -> Bool) (u3 :: u0 -> u0 -> Bool) -> u2; _NO_DEFLT_ } _N_
- {-defm-} _A_ 3 _U_ 022 _N_ _S_ _!_ _F_ _IF_ARGS_ 1 3 XXX 4 _/\_ u0 -> \ (u1 :: {{Eq u0}}) (u2 :: u0) (u3 :: u0) -> _APP_ _TYAPP_ patError# { (u0 -> u0 -> Bool) } [ _NOREP_S_ "%DPreludeCore.Eq.(==)\"", u2, u3 ] _N_ #-}
+ {-defm-} _A_ 3 _U_ 022 _N_ _S_ _!_ _N_ _N_ #-}
(/=) :: a -> a -> Bool
{-# GHC_PRAGMA {-meth-} _A_ 1 _U_ 122 _N_ _S_ "S" _F_ _IF_ARGS_ 1 1 C 2 _/\_ u0 -> \ (u1 :: (u0 -> u0 -> Bool, u0 -> u0 -> Bool)) -> case u1 of { _ALG_ _TUP_2 (u2 :: u0 -> u0 -> Bool) (u3 :: u0 -> u0 -> Bool) -> u3; _NO_DEFLT_ } _N_
{-defm-} _A_ 3 _U_ 122 _N_ _S_ "SLL" _N_ _N_ #-}
class (Fractional a) => Floating a {-# GHC_PRAGMA {-superdicts-} _A_ 1 _U_ 1 _N_ _S_ "S" _F_ _IF_ARGS_ 1 1 C 2 _/\_ u0 -> \ (u1 :: ({{Fractional u0}}, u0, u0 -> u0, u0 -> u0, u0 -> u0, u0 -> u0 -> u0, u0 -> u0 -> u0, u0 -> u0, u0 -> u0, u0 -> u0, u0 -> u0, u0 -> u0, u0 -> u0, u0 -> u0, u0 -> u0, u0 -> u0, u0 -> u0, u0 -> u0, u0 -> u0)) -> case u1 of { _ALG_ _TUP_19 (u2 :: {{Fractional u0}}) (u3 :: u0) (u4 :: u0 -> u0) (u5 :: u0 -> u0) (u6 :: u0 -> u0) (u7 :: u0 -> u0 -> u0) (u8 :: u0 -> u0 -> u0) (u9 :: u0 -> u0) (ua :: u0 -> u0) (ub :: u0 -> u0) (uc :: u0 -> u0) (ud :: u0 -> u0) (ue :: u0 -> u0) (uf :: u0 -> u0) (ug :: u0 -> u0) (uh :: u0 -> u0) (ui :: u0 -> u0) (uj :: u0 -> u0) (uk :: u0 -> u0) -> u2; _NO_DEFLT_ } _N_ #-} where
pi :: a
{-# GHC_PRAGMA {-meth-} _A_ 1 _U_ 1 _N_ _S_ "S" _F_ _IF_ARGS_ 1 1 C 2 _/\_ u0 -> \ (u1 :: ({{Fractional u0}}, u0, u0 -> u0, u0 -> u0, u0 -> u0, u0 -> u0 -> u0, u0 -> u0 -> u0, u0 -> u0, u0 -> u0, u0 -> u0, u0 -> u0, u0 -> u0, u0 -> u0, u0 -> u0, u0 -> u0, u0 -> u0, u0 -> u0, u0 -> u0, u0 -> u0)) -> case u1 of { _ALG_ _TUP_19 (u2 :: {{Fractional u0}}) (u3 :: u0) (u4 :: u0 -> u0) (u5 :: u0 -> u0) (u6 :: u0 -> u0) (u7 :: u0 -> u0 -> u0) (u8 :: u0 -> u0 -> u0) (u9 :: u0 -> u0) (ua :: u0 -> u0) (ub :: u0 -> u0) (uc :: u0 -> u0) (ud :: u0 -> u0) (ue :: u0 -> u0) (uf :: u0 -> u0) (ug :: u0 -> u0) (uh :: u0 -> u0) (ui :: u0 -> u0) (uj :: u0 -> u0) (uk :: u0 -> u0) -> u3; _NO_DEFLT_ } _N_
- {-defm-} _A_ 1 _U_ 0 _N_ _S_ _!_ _F_ _IF_ARGS_ 1 1 X 2 _/\_ u0 -> \ (u1 :: {{Floating u0}}) -> _APP_ _TYAPP_ patError# { u0 } [ _NOREP_S_ "%DPreludeCore.Floating.pi\"" ] _N_ #-}
+ {-defm-} _A_ 1 _U_ 0 _N_ _S_ _!_ _N_ _N_ #-}
exp :: a -> a
{-# GHC_PRAGMA {-meth-} _A_ 1 _U_ 12 _N_ _S_ "S" _F_ _IF_ARGS_ 1 1 C 2 _/\_ u0 -> \ (u1 :: ({{Fractional u0}}, u0, u0 -> u0, u0 -> u0, u0 -> u0, u0 -> u0 -> u0, u0 -> u0 -> u0, u0 -> u0, u0 -> u0, u0 -> u0, u0 -> u0, u0 -> u0, u0 -> u0, u0 -> u0, u0 -> u0, u0 -> u0, u0 -> u0, u0 -> u0, u0 -> u0)) -> case u1 of { _ALG_ _TUP_19 (u2 :: {{Fractional u0}}) (u3 :: u0) (u4 :: u0 -> u0) (u5 :: u0 -> u0) (u6 :: u0 -> u0) (u7 :: u0 -> u0 -> u0) (u8 :: u0 -> u0 -> u0) (u9 :: u0 -> u0) (ua :: u0 -> u0) (ub :: u0 -> u0) (uc :: u0 -> u0) (ud :: u0 -> u0) (ue :: u0 -> u0) (uf :: u0 -> u0) (ug :: u0 -> u0) (uh :: u0 -> u0) (ui :: u0 -> u0) (uj :: u0 -> u0) (uk :: u0 -> u0) -> u4; _NO_DEFLT_ } _N_
- {-defm-} _A_ 2 _U_ 02 _N_ _S_ _!_ _F_ _IF_ARGS_ 1 2 XX 3 _/\_ u0 -> \ (u1 :: {{Floating u0}}) (u2 :: u0) -> _APP_ _TYAPP_ patError# { (u0 -> u0) } [ _NOREP_S_ "%DPreludeCore.Floating.exp\"", u2 ] _N_ #-}
+ {-defm-} _A_ 2 _U_ 02 _N_ _S_ _!_ _N_ _N_ #-}
log :: a -> a
{-# GHC_PRAGMA {-meth-} _A_ 1 _U_ 12 _N_ _S_ "S" _F_ _IF_ARGS_ 1 1 C 2 _/\_ u0 -> \ (u1 :: ({{Fractional u0}}, u0, u0 -> u0, u0 -> u0, u0 -> u0, u0 -> u0 -> u0, u0 -> u0 -> u0, u0 -> u0, u0 -> u0, u0 -> u0, u0 -> u0, u0 -> u0, u0 -> u0, u0 -> u0, u0 -> u0, u0 -> u0, u0 -> u0, u0 -> u0, u0 -> u0)) -> case u1 of { _ALG_ _TUP_19 (u2 :: {{Fractional u0}}) (u3 :: u0) (u4 :: u0 -> u0) (u5 :: u0 -> u0) (u6 :: u0 -> u0) (u7 :: u0 -> u0 -> u0) (u8 :: u0 -> u0 -> u0) (u9 :: u0 -> u0) (ua :: u0 -> u0) (ub :: u0 -> u0) (uc :: u0 -> u0) (ud :: u0 -> u0) (ue :: u0 -> u0) (uf :: u0 -> u0) (ug :: u0 -> u0) (uh :: u0 -> u0) (ui :: u0 -> u0) (uj :: u0 -> u0) (uk :: u0 -> u0) -> u5; _NO_DEFLT_ } _N_
- {-defm-} _A_ 2 _U_ 02 _N_ _S_ _!_ _F_ _IF_ARGS_ 1 2 XX 3 _/\_ u0 -> \ (u1 :: {{Floating u0}}) (u2 :: u0) -> _APP_ _TYAPP_ patError# { (u0 -> u0) } [ _NOREP_S_ "%DPreludeCore.Floating.log\"", u2 ] _N_ #-}
+ {-defm-} _A_ 2 _U_ 02 _N_ _S_ _!_ _N_ _N_ #-}
sqrt :: a -> a
{-# GHC_PRAGMA {-meth-} _A_ 1 _U_ 12 _N_ _S_ "S" _F_ _IF_ARGS_ 1 1 C 2 _/\_ u0 -> \ (u1 :: ({{Fractional u0}}, u0, u0 -> u0, u0 -> u0, u0 -> u0, u0 -> u0 -> u0, u0 -> u0 -> u0, u0 -> u0, u0 -> u0, u0 -> u0, u0 -> u0, u0 -> u0, u0 -> u0, u0 -> u0, u0 -> u0, u0 -> u0, u0 -> u0, u0 -> u0, u0 -> u0)) -> case u1 of { _ALG_ _TUP_19 (u2 :: {{Fractional u0}}) (u3 :: u0) (u4 :: u0 -> u0) (u5 :: u0 -> u0) (u6 :: u0 -> u0) (u7 :: u0 -> u0 -> u0) (u8 :: u0 -> u0 -> u0) (u9 :: u0 -> u0) (ua :: u0 -> u0) (ub :: u0 -> u0) (uc :: u0 -> u0) (ud :: u0 -> u0) (ue :: u0 -> u0) (uf :: u0 -> u0) (ug :: u0 -> u0) (uh :: u0 -> u0) (ui :: u0 -> u0) (uj :: u0 -> u0) (uk :: u0 -> u0) -> u6; _NO_DEFLT_ } _N_
{-defm-} _A_ 1 _U_ 12 _N_ _S_ "S" _N_ _N_ #-}
{-defm-} _A_ 3 _U_ 122 _N_ _S_ "SLL" _N_ _N_ #-}
sin :: a -> a
{-# GHC_PRAGMA {-meth-} _A_ 1 _U_ 12 _N_ _S_ "S" _F_ _IF_ARGS_ 1 1 C 2 _/\_ u0 -> \ (u1 :: ({{Fractional u0}}, u0, u0 -> u0, u0 -> u0, u0 -> u0, u0 -> u0 -> u0, u0 -> u0 -> u0, u0 -> u0, u0 -> u0, u0 -> u0, u0 -> u0, u0 -> u0, u0 -> u0, u0 -> u0, u0 -> u0, u0 -> u0, u0 -> u0, u0 -> u0, u0 -> u0)) -> case u1 of { _ALG_ _TUP_19 (u2 :: {{Fractional u0}}) (u3 :: u0) (u4 :: u0 -> u0) (u5 :: u0 -> u0) (u6 :: u0 -> u0) (u7 :: u0 -> u0 -> u0) (u8 :: u0 -> u0 -> u0) (u9 :: u0 -> u0) (ua :: u0 -> u0) (ub :: u0 -> u0) (uc :: u0 -> u0) (ud :: u0 -> u0) (ue :: u0 -> u0) (uf :: u0 -> u0) (ug :: u0 -> u0) (uh :: u0 -> u0) (ui :: u0 -> u0) (uj :: u0 -> u0) (uk :: u0 -> u0) -> u9; _NO_DEFLT_ } _N_
- {-defm-} _A_ 2 _U_ 02 _N_ _S_ _!_ _F_ _IF_ARGS_ 1 2 XX 3 _/\_ u0 -> \ (u1 :: {{Floating u0}}) (u2 :: u0) -> _APP_ _TYAPP_ patError# { (u0 -> u0) } [ _NOREP_S_ "%DPreludeCore.Floating.sin\"", u2 ] _N_ #-}
+ {-defm-} _A_ 2 _U_ 02 _N_ _S_ _!_ _N_ _N_ #-}
cos :: a -> a
{-# GHC_PRAGMA {-meth-} _A_ 1 _U_ 12 _N_ _S_ "S" _F_ _IF_ARGS_ 1 1 C 2 _/\_ u0 -> \ (u1 :: ({{Fractional u0}}, u0, u0 -> u0, u0 -> u0, u0 -> u0, u0 -> u0 -> u0, u0 -> u0 -> u0, u0 -> u0, u0 -> u0, u0 -> u0, u0 -> u0, u0 -> u0, u0 -> u0, u0 -> u0, u0 -> u0, u0 -> u0, u0 -> u0, u0 -> u0, u0 -> u0)) -> case u1 of { _ALG_ _TUP_19 (u2 :: {{Fractional u0}}) (u3 :: u0) (u4 :: u0 -> u0) (u5 :: u0 -> u0) (u6 :: u0 -> u0) (u7 :: u0 -> u0 -> u0) (u8 :: u0 -> u0 -> u0) (u9 :: u0 -> u0) (ua :: u0 -> u0) (ub :: u0 -> u0) (uc :: u0 -> u0) (ud :: u0 -> u0) (ue :: u0 -> u0) (uf :: u0 -> u0) (ug :: u0 -> u0) (uh :: u0 -> u0) (ui :: u0 -> u0) (uj :: u0 -> u0) (uk :: u0 -> u0) -> ua; _NO_DEFLT_ } _N_
- {-defm-} _A_ 2 _U_ 02 _N_ _S_ _!_ _F_ _IF_ARGS_ 1 2 XX 3 _/\_ u0 -> \ (u1 :: {{Floating u0}}) (u2 :: u0) -> _APP_ _TYAPP_ patError# { (u0 -> u0) } [ _NOREP_S_ "%DPreludeCore.Floating.cos\"", u2 ] _N_ #-}
+ {-defm-} _A_ 2 _U_ 02 _N_ _S_ _!_ _N_ _N_ #-}
tan :: a -> a
{-# GHC_PRAGMA {-meth-} _A_ 1 _U_ 12 _N_ _S_ "S" _F_ _IF_ARGS_ 1 1 C 2 _/\_ u0 -> \ (u1 :: ({{Fractional u0}}, u0, u0 -> u0, u0 -> u0, u0 -> u0, u0 -> u0 -> u0, u0 -> u0 -> u0, u0 -> u0, u0 -> u0, u0 -> u0, u0 -> u0, u0 -> u0, u0 -> u0, u0 -> u0, u0 -> u0, u0 -> u0, u0 -> u0, u0 -> u0, u0 -> u0)) -> case u1 of { _ALG_ _TUP_19 (u2 :: {{Fractional u0}}) (u3 :: u0) (u4 :: u0 -> u0) (u5 :: u0 -> u0) (u6 :: u0 -> u0) (u7 :: u0 -> u0 -> u0) (u8 :: u0 -> u0 -> u0) (u9 :: u0 -> u0) (ua :: u0 -> u0) (ub :: u0 -> u0) (uc :: u0 -> u0) (ud :: u0 -> u0) (ue :: u0 -> u0) (uf :: u0 -> u0) (ug :: u0 -> u0) (uh :: u0 -> u0) (ui :: u0 -> u0) (uj :: u0 -> u0) (uk :: u0 -> u0) -> ub; _NO_DEFLT_ } _N_
{-defm-} _A_ 2 _U_ 12 _N_ _S_ "SL" _N_ _N_ #-}
asin :: a -> a
{-# GHC_PRAGMA {-meth-} _A_ 1 _U_ 12 _N_ _S_ "S" _F_ _IF_ARGS_ 1 1 C 2 _/\_ u0 -> \ (u1 :: ({{Fractional u0}}, u0, u0 -> u0, u0 -> u0, u0 -> u0, u0 -> u0 -> u0, u0 -> u0 -> u0, u0 -> u0, u0 -> u0, u0 -> u0, u0 -> u0, u0 -> u0, u0 -> u0, u0 -> u0, u0 -> u0, u0 -> u0, u0 -> u0, u0 -> u0, u0 -> u0)) -> case u1 of { _ALG_ _TUP_19 (u2 :: {{Fractional u0}}) (u3 :: u0) (u4 :: u0 -> u0) (u5 :: u0 -> u0) (u6 :: u0 -> u0) (u7 :: u0 -> u0 -> u0) (u8 :: u0 -> u0 -> u0) (u9 :: u0 -> u0) (ua :: u0 -> u0) (ub :: u0 -> u0) (uc :: u0 -> u0) (ud :: u0 -> u0) (ue :: u0 -> u0) (uf :: u0 -> u0) (ug :: u0 -> u0) (uh :: u0 -> u0) (ui :: u0 -> u0) (uj :: u0 -> u0) (uk :: u0 -> u0) -> uc; _NO_DEFLT_ } _N_
- {-defm-} _A_ 2 _U_ 02 _N_ _S_ _!_ _F_ _IF_ARGS_ 1 2 XX 3 _/\_ u0 -> \ (u1 :: {{Floating u0}}) (u2 :: u0) -> _APP_ _TYAPP_ patError# { (u0 -> u0) } [ _NOREP_S_ "%DPreludeCore.Floating.asin\"", u2 ] _N_ #-}
+ {-defm-} _A_ 2 _U_ 02 _N_ _S_ _!_ _N_ _N_ #-}
acos :: a -> a
{-# GHC_PRAGMA {-meth-} _A_ 1 _U_ 12 _N_ _S_ "S" _F_ _IF_ARGS_ 1 1 C 2 _/\_ u0 -> \ (u1 :: ({{Fractional u0}}, u0, u0 -> u0, u0 -> u0, u0 -> u0, u0 -> u0 -> u0, u0 -> u0 -> u0, u0 -> u0, u0 -> u0, u0 -> u0, u0 -> u0, u0 -> u0, u0 -> u0, u0 -> u0, u0 -> u0, u0 -> u0, u0 -> u0, u0 -> u0, u0 -> u0)) -> case u1 of { _ALG_ _TUP_19 (u2 :: {{Fractional u0}}) (u3 :: u0) (u4 :: u0 -> u0) (u5 :: u0 -> u0) (u6 :: u0 -> u0) (u7 :: u0 -> u0 -> u0) (u8 :: u0 -> u0 -> u0) (u9 :: u0 -> u0) (ua :: u0 -> u0) (ub :: u0 -> u0) (uc :: u0 -> u0) (ud :: u0 -> u0) (ue :: u0 -> u0) (uf :: u0 -> u0) (ug :: u0 -> u0) (uh :: u0 -> u0) (ui :: u0 -> u0) (uj :: u0 -> u0) (uk :: u0 -> u0) -> ud; _NO_DEFLT_ } _N_
- {-defm-} _A_ 2 _U_ 02 _N_ _S_ _!_ _F_ _IF_ARGS_ 1 2 XX 3 _/\_ u0 -> \ (u1 :: {{Floating u0}}) (u2 :: u0) -> _APP_ _TYAPP_ patError# { (u0 -> u0) } [ _NOREP_S_ "%DPreludeCore.Floating.acos\"", u2 ] _N_ #-}
+ {-defm-} _A_ 2 _U_ 02 _N_ _S_ _!_ _N_ _N_ #-}
atan :: a -> a
{-# GHC_PRAGMA {-meth-} _A_ 1 _U_ 12 _N_ _S_ "S" _F_ _IF_ARGS_ 1 1 C 2 _/\_ u0 -> \ (u1 :: ({{Fractional u0}}, u0, u0 -> u0, u0 -> u0, u0 -> u0, u0 -> u0 -> u0, u0 -> u0 -> u0, u0 -> u0, u0 -> u0, u0 -> u0, u0 -> u0, u0 -> u0, u0 -> u0, u0 -> u0, u0 -> u0, u0 -> u0, u0 -> u0, u0 -> u0, u0 -> u0)) -> case u1 of { _ALG_ _TUP_19 (u2 :: {{Fractional u0}}) (u3 :: u0) (u4 :: u0 -> u0) (u5 :: u0 -> u0) (u6 :: u0 -> u0) (u7 :: u0 -> u0 -> u0) (u8 :: u0 -> u0 -> u0) (u9 :: u0 -> u0) (ua :: u0 -> u0) (ub :: u0 -> u0) (uc :: u0 -> u0) (ud :: u0 -> u0) (ue :: u0 -> u0) (uf :: u0 -> u0) (ug :: u0 -> u0) (uh :: u0 -> u0) (ui :: u0 -> u0) (uj :: u0 -> u0) (uk :: u0 -> u0) -> ue; _NO_DEFLT_ } _N_
- {-defm-} _A_ 2 _U_ 02 _N_ _S_ _!_ _F_ _IF_ARGS_ 1 2 XX 3 _/\_ u0 -> \ (u1 :: {{Floating u0}}) (u2 :: u0) -> _APP_ _TYAPP_ patError# { (u0 -> u0) } [ _NOREP_S_ "%DPreludeCore.Floating.atan\"", u2 ] _N_ #-}
+ {-defm-} _A_ 2 _U_ 02 _N_ _S_ _!_ _N_ _N_ #-}
sinh :: a -> a
{-# GHC_PRAGMA {-meth-} _A_ 1 _U_ 12 _N_ _S_ "S" _F_ _IF_ARGS_ 1 1 C 2 _/\_ u0 -> \ (u1 :: ({{Fractional u0}}, u0, u0 -> u0, u0 -> u0, u0 -> u0, u0 -> u0 -> u0, u0 -> u0 -> u0, u0 -> u0, u0 -> u0, u0 -> u0, u0 -> u0, u0 -> u0, u0 -> u0, u0 -> u0, u0 -> u0, u0 -> u0, u0 -> u0, u0 -> u0, u0 -> u0)) -> case u1 of { _ALG_ _TUP_19 (u2 :: {{Fractional u0}}) (u3 :: u0) (u4 :: u0 -> u0) (u5 :: u0 -> u0) (u6 :: u0 -> u0) (u7 :: u0 -> u0 -> u0) (u8 :: u0 -> u0 -> u0) (u9 :: u0 -> u0) (ua :: u0 -> u0) (ub :: u0 -> u0) (uc :: u0 -> u0) (ud :: u0 -> u0) (ue :: u0 -> u0) (uf :: u0 -> u0) (ug :: u0 -> u0) (uh :: u0 -> u0) (ui :: u0 -> u0) (uj :: u0 -> u0) (uk :: u0 -> u0) -> uf; _NO_DEFLT_ } _N_
- {-defm-} _A_ 2 _U_ 02 _N_ _S_ _!_ _F_ _IF_ARGS_ 1 2 XX 3 _/\_ u0 -> \ (u1 :: {{Floating u0}}) (u2 :: u0) -> _APP_ _TYAPP_ patError# { (u0 -> u0) } [ _NOREP_S_ "%DPreludeCore.Floating.sinh\"", u2 ] _N_ #-}
+ {-defm-} _A_ 2 _U_ 02 _N_ _S_ _!_ _N_ _N_ #-}
cosh :: a -> a
{-# GHC_PRAGMA {-meth-} _A_ 1 _U_ 12 _N_ _S_ "S" _F_ _IF_ARGS_ 1 1 C 2 _/\_ u0 -> \ (u1 :: ({{Fractional u0}}, u0, u0 -> u0, u0 -> u0, u0 -> u0, u0 -> u0 -> u0, u0 -> u0 -> u0, u0 -> u0, u0 -> u0, u0 -> u0, u0 -> u0, u0 -> u0, u0 -> u0, u0 -> u0, u0 -> u0, u0 -> u0, u0 -> u0, u0 -> u0, u0 -> u0)) -> case u1 of { _ALG_ _TUP_19 (u2 :: {{Fractional u0}}) (u3 :: u0) (u4 :: u0 -> u0) (u5 :: u0 -> u0) (u6 :: u0 -> u0) (u7 :: u0 -> u0 -> u0) (u8 :: u0 -> u0 -> u0) (u9 :: u0 -> u0) (ua :: u0 -> u0) (ub :: u0 -> u0) (uc :: u0 -> u0) (ud :: u0 -> u0) (ue :: u0 -> u0) (uf :: u0 -> u0) (ug :: u0 -> u0) (uh :: u0 -> u0) (ui :: u0 -> u0) (uj :: u0 -> u0) (uk :: u0 -> u0) -> ug; _NO_DEFLT_ } _N_
- {-defm-} _A_ 2 _U_ 02 _N_ _S_ _!_ _F_ _IF_ARGS_ 1 2 XX 3 _/\_ u0 -> \ (u1 :: {{Floating u0}}) (u2 :: u0) -> _APP_ _TYAPP_ patError# { (u0 -> u0) } [ _NOREP_S_ "%DPreludeCore.Floating.cosh\"", u2 ] _N_ #-}
+ {-defm-} _A_ 2 _U_ 02 _N_ _S_ _!_ _N_ _N_ #-}
tanh :: a -> a
{-# GHC_PRAGMA {-meth-} _A_ 1 _U_ 12 _N_ _S_ "S" _F_ _IF_ARGS_ 1 1 C 2 _/\_ u0 -> \ (u1 :: ({{Fractional u0}}, u0, u0 -> u0, u0 -> u0, u0 -> u0, u0 -> u0 -> u0, u0 -> u0 -> u0, u0 -> u0, u0 -> u0, u0 -> u0, u0 -> u0, u0 -> u0, u0 -> u0, u0 -> u0, u0 -> u0, u0 -> u0, u0 -> u0, u0 -> u0, u0 -> u0)) -> case u1 of { _ALG_ _TUP_19 (u2 :: {{Fractional u0}}) (u3 :: u0) (u4 :: u0 -> u0) (u5 :: u0 -> u0) (u6 :: u0 -> u0) (u7 :: u0 -> u0 -> u0) (u8 :: u0 -> u0 -> u0) (u9 :: u0 -> u0) (ua :: u0 -> u0) (ub :: u0 -> u0) (uc :: u0 -> u0) (ud :: u0 -> u0) (ue :: u0 -> u0) (uf :: u0 -> u0) (ug :: u0 -> u0) (uh :: u0 -> u0) (ui :: u0 -> u0) (uj :: u0 -> u0) (uk :: u0 -> u0) -> uh; _NO_DEFLT_ } _N_
{-defm-} _A_ 2 _U_ 12 _N_ _S_ "SL" _N_ _N_ #-}
asinh :: a -> a
{-# GHC_PRAGMA {-meth-} _A_ 1 _U_ 12 _N_ _S_ "S" _F_ _IF_ARGS_ 1 1 C 2 _/\_ u0 -> \ (u1 :: ({{Fractional u0}}, u0, u0 -> u0, u0 -> u0, u0 -> u0, u0 -> u0 -> u0, u0 -> u0 -> u0, u0 -> u0, u0 -> u0, u0 -> u0, u0 -> u0, u0 -> u0, u0 -> u0, u0 -> u0, u0 -> u0, u0 -> u0, u0 -> u0, u0 -> u0, u0 -> u0)) -> case u1 of { _ALG_ _TUP_19 (u2 :: {{Fractional u0}}) (u3 :: u0) (u4 :: u0 -> u0) (u5 :: u0 -> u0) (u6 :: u0 -> u0) (u7 :: u0 -> u0 -> u0) (u8 :: u0 -> u0 -> u0) (u9 :: u0 -> u0) (ua :: u0 -> u0) (ub :: u0 -> u0) (uc :: u0 -> u0) (ud :: u0 -> u0) (ue :: u0 -> u0) (uf :: u0 -> u0) (ug :: u0 -> u0) (uh :: u0 -> u0) (ui :: u0 -> u0) (uj :: u0 -> u0) (uk :: u0 -> u0) -> ui; _NO_DEFLT_ } _N_
- {-defm-} _A_ 2 _U_ 02 _N_ _S_ _!_ _F_ _IF_ARGS_ 1 2 XX 3 _/\_ u0 -> \ (u1 :: {{Floating u0}}) (u2 :: u0) -> _APP_ _TYAPP_ patError# { (u0 -> u0) } [ _NOREP_S_ "%DPreludeCore.Floating.asinh\"", u2 ] _N_ #-}
+ {-defm-} _A_ 2 _U_ 02 _N_ _S_ _!_ _N_ _N_ #-}
acosh :: a -> a
{-# GHC_PRAGMA {-meth-} _A_ 1 _U_ 12 _N_ _S_ "S" _F_ _IF_ARGS_ 1 1 C 2 _/\_ u0 -> \ (u1 :: ({{Fractional u0}}, u0, u0 -> u0, u0 -> u0, u0 -> u0, u0 -> u0 -> u0, u0 -> u0 -> u0, u0 -> u0, u0 -> u0, u0 -> u0, u0 -> u0, u0 -> u0, u0 -> u0, u0 -> u0, u0 -> u0, u0 -> u0, u0 -> u0, u0 -> u0, u0 -> u0)) -> case u1 of { _ALG_ _TUP_19 (u2 :: {{Fractional u0}}) (u3 :: u0) (u4 :: u0 -> u0) (u5 :: u0 -> u0) (u6 :: u0 -> u0) (u7 :: u0 -> u0 -> u0) (u8 :: u0 -> u0 -> u0) (u9 :: u0 -> u0) (ua :: u0 -> u0) (ub :: u0 -> u0) (uc :: u0 -> u0) (ud :: u0 -> u0) (ue :: u0 -> u0) (uf :: u0 -> u0) (ug :: u0 -> u0) (uh :: u0 -> u0) (ui :: u0 -> u0) (uj :: u0 -> u0) (uk :: u0 -> u0) -> uj; _NO_DEFLT_ } _N_
- {-defm-} _A_ 2 _U_ 02 _N_ _S_ _!_ _F_ _IF_ARGS_ 1 2 XX 3 _/\_ u0 -> \ (u1 :: {{Floating u0}}) (u2 :: u0) -> _APP_ _TYAPP_ patError# { (u0 -> u0) } [ _NOREP_S_ "%DPreludeCore.Floating.acosh\"", u2 ] _N_ #-}
+ {-defm-} _A_ 2 _U_ 02 _N_ _S_ _!_ _N_ _N_ #-}
atanh :: a -> a
{-# GHC_PRAGMA {-meth-} _A_ 1 _U_ 12 _N_ _S_ "S" _F_ _IF_ARGS_ 1 1 C 2 _/\_ u0 -> \ (u1 :: ({{Fractional u0}}, u0, u0 -> u0, u0 -> u0, u0 -> u0, u0 -> u0 -> u0, u0 -> u0 -> u0, u0 -> u0, u0 -> u0, u0 -> u0, u0 -> u0, u0 -> u0, u0 -> u0, u0 -> u0, u0 -> u0, u0 -> u0, u0 -> u0, u0 -> u0, u0 -> u0)) -> case u1 of { _ALG_ _TUP_19 (u2 :: {{Fractional u0}}) (u3 :: u0) (u4 :: u0 -> u0) (u5 :: u0 -> u0) (u6 :: u0 -> u0) (u7 :: u0 -> u0 -> u0) (u8 :: u0 -> u0 -> u0) (u9 :: u0 -> u0) (ua :: u0 -> u0) (ub :: u0 -> u0) (uc :: u0 -> u0) (ud :: u0 -> u0) (ue :: u0 -> u0) (uf :: u0 -> u0) (ug :: u0 -> u0) (uh :: u0 -> u0) (ui :: u0 -> u0) (uj :: u0 -> u0) (uk :: u0 -> u0) -> uk; _NO_DEFLT_ } _N_
- {-defm-} _A_ 2 _U_ 02 _N_ _S_ _!_ _F_ _IF_ARGS_ 1 2 XX 3 _/\_ u0 -> \ (u1 :: {{Floating u0}}) (u2 :: u0) -> _APP_ _TYAPP_ patError# { (u0 -> u0) } [ _NOREP_S_ "%DPreludeCore.Floating.atanh\"", u2 ] _N_ #-}
+ {-defm-} _A_ 2 _U_ 02 _N_ _S_ _!_ _N_ _N_ #-}
class (Num a) => Fractional a {-# GHC_PRAGMA {-superdicts-} _A_ 1 _U_ 1 _N_ _S_ "S" _F_ _IF_ARGS_ 1 1 C 2 _/\_ u0 -> \ (u1 :: ({{Num u0}}, u0 -> u0 -> u0, u0 -> u0, Ratio Integer -> u0)) -> case u1 of { _ALG_ _TUP_4 (u2 :: {{Num u0}}) (u3 :: u0 -> u0 -> u0) (u4 :: u0 -> u0) (u5 :: Ratio Integer -> u0) -> u2; _NO_DEFLT_ } _N_ #-} where
(/) :: a -> a -> a
{-# GHC_PRAGMA {-meth-} _A_ 1 _U_ 122 _N_ _S_ "S" _F_ _IF_ARGS_ 1 1 C 2 _/\_ u0 -> \ (u1 :: ({{Num u0}}, u0 -> u0 -> u0, u0 -> u0, Ratio Integer -> u0)) -> case u1 of { _ALG_ _TUP_4 (u2 :: {{Num u0}}) (u3 :: u0 -> u0 -> u0) (u4 :: u0 -> u0) (u5 :: Ratio Integer -> u0) -> u3; _NO_DEFLT_ } _N_
- {-defm-} _A_ 3 _U_ 022 _N_ _S_ _!_ _F_ _IF_ARGS_ 1 3 XXX 4 _/\_ u0 -> \ (u1 :: {{Fractional u0}}) (u2 :: u0) (u3 :: u0) -> _APP_ _TYAPP_ patError# { (u0 -> u0 -> u0) } [ _NOREP_S_ "%DPreludeCore.Fractional.(/)\"", u2, u3 ] _N_ #-}
+ {-defm-} _A_ 3 _U_ 022 _N_ _S_ _!_ _N_ _N_ #-}
recip :: a -> a
{-# GHC_PRAGMA {-meth-} _A_ 1 _U_ 12 _N_ _S_ "S" _F_ _IF_ARGS_ 1 1 C 2 _/\_ u0 -> \ (u1 :: ({{Num u0}}, u0 -> u0 -> u0, u0 -> u0, Ratio Integer -> u0)) -> case u1 of { _ALG_ _TUP_4 (u2 :: {{Num u0}}) (u3 :: u0 -> u0 -> u0) (u4 :: u0 -> u0) (u5 :: Ratio Integer -> u0) -> u4; _NO_DEFLT_ } _N_
{-defm-} _A_ 1 _U_ 12 _N_ _S_ "S" _N_ _N_ #-}
fromRational :: Ratio Integer -> a
{-# GHC_PRAGMA {-meth-} _A_ 1 _U_ 12 _N_ _S_ "S" _F_ _IF_ARGS_ 1 1 C 2 _/\_ u0 -> \ (u1 :: ({{Num u0}}, u0 -> u0 -> u0, u0 -> u0, Ratio Integer -> u0)) -> case u1 of { _ALG_ _TUP_4 (u2 :: {{Num u0}}) (u3 :: u0 -> u0 -> u0) (u4 :: u0 -> u0) (u5 :: Ratio Integer -> u0) -> u5; _NO_DEFLT_ } _N_
- {-defm-} _A_ 2 _U_ 02 _N_ _S_ _!_ _F_ _IF_ARGS_ 1 2 XX 3 _/\_ u0 -> \ (u1 :: {{Fractional u0}}) (u2 :: Ratio Integer) -> _APP_ _TYAPP_ patError# { (Ratio Integer -> u0) } [ _NOREP_S_ "%DPreludeCore.Fractional.fromRational\"", u2 ] _N_ #-}
+ {-defm-} _A_ 2 _U_ 02 _N_ _S_ _!_ _N_ _N_ #-}
class (Real a, Ix a) => Integral a {-# GHC_PRAGMA {-superdicts-} _A_ 1 _U_ 1 _N_ _S_ "S" _F_ _IF_ARGS_ 1 1 C 2 _/\_ u0 -> \ (u1 :: ({{Real u0}}, {{Ix u0}}, u0 -> u0 -> u0, u0 -> u0 -> u0, u0 -> u0 -> u0, u0 -> u0 -> u0, u0 -> u0 -> (u0, u0), u0 -> u0 -> (u0, u0), u0 -> Bool, u0 -> Bool, u0 -> Integer, u0 -> Int)) -> case u1 of { _ALG_ _TUP_12 (u2 :: {{Real u0}}) (u3 :: {{Ix u0}}) (u4 :: u0 -> u0 -> u0) (u5 :: u0 -> u0 -> u0) (u6 :: u0 -> u0 -> u0) (u7 :: u0 -> u0 -> u0) (u8 :: u0 -> u0 -> (u0, u0)) (u9 :: u0 -> u0 -> (u0, u0)) (ua :: u0 -> Bool) (ub :: u0 -> Bool) (uc :: u0 -> Integer) (ud :: u0 -> Int) -> u2; _NO_DEFLT_ } _N_, _A_ 1 _U_ 1 _N_ _S_ "S" _F_ _IF_ARGS_ 1 1 C 2 _/\_ u0 -> \ (u1 :: ({{Real u0}}, {{Ix u0}}, u0 -> u0 -> u0, u0 -> u0 -> u0, u0 -> u0 -> u0, u0 -> u0 -> u0, u0 -> u0 -> (u0, u0), u0 -> u0 -> (u0, u0), u0 -> Bool, u0 -> Bool, u0 -> Integer, u0 -> Int)) -> case u1 of { _ALG_ _TUP_12 (u2 :: {{Real u0}}) (u3 :: {{Ix u0}}) (u4 :: u0 -> u0 -> u0) (u5 :: u0 -> u0 -> u0) (u6 :: u0 -> u0 -> u0) (u7 :: u0 -> u0 -> u0) (u8 :: u0 -> u0 -> (u0, u0)) (u9 :: u0 -> u0 -> (u0, u0)) (ua :: u0 -> Bool) (ub :: u0 -> Bool) (uc :: u0 -> Integer) (ud :: u0 -> Int) -> u3; _NO_DEFLT_ } _N_ #-} where
quot :: a -> a -> a
{-# GHC_PRAGMA {-meth-} _A_ 1 _U_ 122 _N_ _S_ "S" _F_ _IF_ARGS_ 1 1 C 2 _/\_ u0 -> \ (u1 :: ({{Real u0}}, {{Ix u0}}, u0 -> u0 -> u0, u0 -> u0 -> u0, u0 -> u0 -> u0, u0 -> u0 -> u0, u0 -> u0 -> (u0, u0), u0 -> u0 -> (u0, u0), u0 -> Bool, u0 -> Bool, u0 -> Integer, u0 -> Int)) -> case u1 of { _ALG_ _TUP_12 (u2 :: {{Real u0}}) (u3 :: {{Ix u0}}) (u4 :: u0 -> u0 -> u0) (u5 :: u0 -> u0 -> u0) (u6 :: u0 -> u0 -> u0) (u7 :: u0 -> u0 -> u0) (u8 :: u0 -> u0 -> (u0, u0)) (u9 :: u0 -> u0 -> (u0, u0)) (ua :: u0 -> Bool) (ub :: u0 -> Bool) (uc :: u0 -> Integer) (ud :: u0 -> Int) -> u4; _NO_DEFLT_ } _N_
{-defm-} _A_ 3 _U_ 122 _N_ _S_ "SLL" _F_ _IF_ARGS_ 1 3 CXX 6 _/\_ u0 -> \ (u1 :: {{Integral u0}}) (u2 :: u0) (u3 :: u0) -> case case u1 of { _ALG_ _TUP_12 (u4 :: {{Real u0}}) (u5 :: {{Ix u0}}) (u6 :: u0 -> u0 -> u0) (u7 :: u0 -> u0 -> u0) (u8 :: u0 -> u0 -> u0) (u9 :: u0 -> u0 -> u0) (ua :: u0 -> u0 -> (u0, u0)) (ub :: u0 -> u0 -> (u0, u0)) (uc :: u0 -> Bool) (ud :: u0 -> Bool) (ue :: u0 -> Integer) (uf :: u0 -> Int) -> _APP_ ub [ u2, u3 ]; _NO_DEFLT_ } of { _ALG_ _TUP_2 (ug :: u0) (uh :: u0) -> uh; _NO_DEFLT_ } _N_ #-}
quotRem :: a -> a -> (a, a)
{-# GHC_PRAGMA {-meth-} _A_ 1 _U_ 122 _N_ _S_ "S" _F_ _IF_ARGS_ 1 1 C 2 _/\_ u0 -> \ (u1 :: ({{Real u0}}, {{Ix u0}}, u0 -> u0 -> u0, u0 -> u0 -> u0, u0 -> u0 -> u0, u0 -> u0 -> u0, u0 -> u0 -> (u0, u0), u0 -> u0 -> (u0, u0), u0 -> Bool, u0 -> Bool, u0 -> Integer, u0 -> Int)) -> case u1 of { _ALG_ _TUP_12 (u2 :: {{Real u0}}) (u3 :: {{Ix u0}}) (u4 :: u0 -> u0 -> u0) (u5 :: u0 -> u0 -> u0) (u6 :: u0 -> u0 -> u0) (u7 :: u0 -> u0 -> u0) (u8 :: u0 -> u0 -> (u0, u0)) (u9 :: u0 -> u0 -> (u0, u0)) (ua :: u0 -> Bool) (ub :: u0 -> Bool) (uc :: u0 -> Integer) (ud :: u0 -> Int) -> u8; _NO_DEFLT_ } _N_
- {-defm-} _A_ 3 _U_ 022 _N_ _S_ _!_ _F_ _IF_ARGS_ 1 3 XXX 4 _/\_ u0 -> \ (u1 :: {{Integral u0}}) (u2 :: u0) (u3 :: u0) -> _APP_ _TYAPP_ patError# { (u0 -> u0 -> (u0, u0)) } [ _NOREP_S_ "%DPreludeCore.Integral.quotRem\"", u2, u3 ] _N_ #-}
+ {-defm-} _A_ 3 _U_ 022 _N_ _S_ _!_ _N_ _N_ #-}
divMod :: a -> a -> (a, a)
{-# GHC_PRAGMA {-meth-} _A_ 1 _U_ 122 _N_ _S_ "S" _F_ _IF_ARGS_ 1 1 C 2 _/\_ u0 -> \ (u1 :: ({{Real u0}}, {{Ix u0}}, u0 -> u0 -> u0, u0 -> u0 -> u0, u0 -> u0 -> u0, u0 -> u0 -> u0, u0 -> u0 -> (u0, u0), u0 -> u0 -> (u0, u0), u0 -> Bool, u0 -> Bool, u0 -> Integer, u0 -> Int)) -> case u1 of { _ALG_ _TUP_12 (u2 :: {{Real u0}}) (u3 :: {{Ix u0}}) (u4 :: u0 -> u0 -> u0) (u5 :: u0 -> u0 -> u0) (u6 :: u0 -> u0 -> u0) (u7 :: u0 -> u0 -> u0) (u8 :: u0 -> u0 -> (u0, u0)) (u9 :: u0 -> u0 -> (u0, u0)) (ua :: u0 -> Bool) (ub :: u0 -> Bool) (uc :: u0 -> Integer) (ud :: u0 -> Int) -> u9; _NO_DEFLT_ } _N_
{-defm-} _A_ 1 _U_ 122 _N_ _S_ "S" _N_ _N_ #-}
{-defm-} _A_ 1 _U_ 12 _N_ _S_ "S" _N_ _N_ #-}
toInteger :: a -> Integer
{-# GHC_PRAGMA {-meth-} _A_ 1 _U_ 12 _N_ _S_ "S" _F_ _IF_ARGS_ 1 1 C 2 _/\_ u0 -> \ (u1 :: ({{Real u0}}, {{Ix u0}}, u0 -> u0 -> u0, u0 -> u0 -> u0, u0 -> u0 -> u0, u0 -> u0 -> u0, u0 -> u0 -> (u0, u0), u0 -> u0 -> (u0, u0), u0 -> Bool, u0 -> Bool, u0 -> Integer, u0 -> Int)) -> case u1 of { _ALG_ _TUP_12 (u2 :: {{Real u0}}) (u3 :: {{Ix u0}}) (u4 :: u0 -> u0 -> u0) (u5 :: u0 -> u0 -> u0) (u6 :: u0 -> u0 -> u0) (u7 :: u0 -> u0 -> u0) (u8 :: u0 -> u0 -> (u0, u0)) (u9 :: u0 -> u0 -> (u0, u0)) (ua :: u0 -> Bool) (ub :: u0 -> Bool) (uc :: u0 -> Integer) (ud :: u0 -> Int) -> uc; _NO_DEFLT_ } _N_
- {-defm-} _A_ 2 _U_ 02 _N_ _S_ _!_ _F_ _IF_ARGS_ 1 2 XX 3 _/\_ u0 -> \ (u1 :: {{Integral u0}}) (u2 :: u0) -> _APP_ _TYAPP_ patError# { (u0 -> Integer) } [ _NOREP_S_ "%DPreludeCore.Integral.toInteger\"", u2 ] _N_ #-}
+ {-defm-} _A_ 2 _U_ 02 _N_ _S_ _!_ _N_ _N_ #-}
toInt :: a -> Int
{-# GHC_PRAGMA {-meth-} _A_ 1 _U_ 12 _N_ _S_ "S" _F_ _IF_ARGS_ 1 1 C 2 _/\_ u0 -> \ (u1 :: ({{Real u0}}, {{Ix u0}}, u0 -> u0 -> u0, u0 -> u0 -> u0, u0 -> u0 -> u0, u0 -> u0 -> u0, u0 -> u0 -> (u0, u0), u0 -> u0 -> (u0, u0), u0 -> Bool, u0 -> Bool, u0 -> Integer, u0 -> Int)) -> case u1 of { _ALG_ _TUP_12 (u2 :: {{Real u0}}) (u3 :: {{Ix u0}}) (u4 :: u0 -> u0 -> u0) (u5 :: u0 -> u0 -> u0) (u6 :: u0 -> u0 -> u0) (u7 :: u0 -> u0 -> u0) (u8 :: u0 -> u0 -> (u0, u0)) (u9 :: u0 -> u0 -> (u0, u0)) (ua :: u0 -> Bool) (ub :: u0 -> Bool) (uc :: u0 -> Integer) (ud :: u0 -> Int) -> ud; _NO_DEFLT_ } _N_
- {-defm-} _A_ 2 _U_ 02 _N_ _S_ _!_ _F_ _IF_ARGS_ 1 2 XX 3 _/\_ u0 -> \ (u1 :: {{Integral u0}}) (u2 :: u0) -> _APP_ _TYAPP_ patError# { (u0 -> Int) } [ _NOREP_S_ "%DPreludeCore.Integral.toInt\"", u2 ] _N_ #-}
+ {-defm-} _A_ 2 _U_ 02 _N_ _S_ _!_ _N_ _N_ #-}
class (Ord a) => Ix a {-# GHC_PRAGMA {-superdicts-} _A_ 1 _U_ 1 _N_ _S_ "S" _F_ _IF_ARGS_ 1 1 C 2 _/\_ u0 -> \ (u1 :: ({{Ord u0}}, (u0, u0) -> [u0], (u0, u0) -> u0 -> Int, (u0, u0) -> u0 -> Bool)) -> case u1 of { _ALG_ _TUP_4 (u2 :: {{Ord u0}}) (u3 :: (u0, u0) -> [u0]) (u4 :: (u0, u0) -> u0 -> Int) (u5 :: (u0, u0) -> u0 -> Bool) -> u2; _NO_DEFLT_ } _N_ #-} where
range :: (a, a) -> [a]
{-# GHC_PRAGMA {-meth-} _A_ 1 _U_ 12 _N_ _S_ "S" _F_ _IF_ARGS_ 1 1 C 2 _/\_ u0 -> \ (u1 :: ({{Ord u0}}, (u0, u0) -> [u0], (u0, u0) -> u0 -> Int, (u0, u0) -> u0 -> Bool)) -> case u1 of { _ALG_ _TUP_4 (u2 :: {{Ord u0}}) (u3 :: (u0, u0) -> [u0]) (u4 :: (u0, u0) -> u0 -> Int) (u5 :: (u0, u0) -> u0 -> Bool) -> u3; _NO_DEFLT_ } _N_
- {-defm-} _A_ 2 _U_ 02 _N_ _S_ _!_ _F_ _IF_ARGS_ 1 2 XX 3 _/\_ u0 -> \ (u1 :: {{Ix u0}}) (u2 :: (u0, u0)) -> _APP_ _TYAPP_ patError# { ((u0, u0) -> [u0]) } [ _NOREP_S_ "%DPreludeCore.Ix.range\"", u2 ] _N_ #-}
+ {-defm-} _A_ 2 _U_ 02 _N_ _S_ _!_ _N_ _N_ #-}
index :: (a, a) -> a -> Int
{-# GHC_PRAGMA {-meth-} _A_ 1 _U_ 122 _N_ _S_ "S" _F_ _IF_ARGS_ 1 1 C 2 _/\_ u0 -> \ (u1 :: ({{Ord u0}}, (u0, u0) -> [u0], (u0, u0) -> u0 -> Int, (u0, u0) -> u0 -> Bool)) -> case u1 of { _ALG_ _TUP_4 (u2 :: {{Ord u0}}) (u3 :: (u0, u0) -> [u0]) (u4 :: (u0, u0) -> u0 -> Int) (u5 :: (u0, u0) -> u0 -> Bool) -> u4; _NO_DEFLT_ } _N_
- {-defm-} _A_ 3 _U_ 022 _N_ _S_ _!_ _F_ _IF_ARGS_ 1 3 XXX 4 _/\_ u0 -> \ (u1 :: {{Ix u0}}) (u2 :: (u0, u0)) (u3 :: u0) -> _APP_ _TYAPP_ patError# { ((u0, u0) -> u0 -> Int) } [ _NOREP_S_ "%DPreludeCore.Ix.index\"", u2, u3 ] _N_ #-}
+ {-defm-} _A_ 3 _U_ 022 _N_ _S_ _!_ _N_ _N_ #-}
inRange :: (a, a) -> a -> Bool
{-# GHC_PRAGMA {-meth-} _A_ 1 _U_ 122 _N_ _S_ "S" _F_ _IF_ARGS_ 1 1 C 2 _/\_ u0 -> \ (u1 :: ({{Ord u0}}, (u0, u0) -> [u0], (u0, u0) -> u0 -> Int, (u0, u0) -> u0 -> Bool)) -> case u1 of { _ALG_ _TUP_4 (u2 :: {{Ord u0}}) (u3 :: (u0, u0) -> [u0]) (u4 :: (u0, u0) -> u0 -> Int) (u5 :: (u0, u0) -> u0 -> Bool) -> u5; _NO_DEFLT_ } _N_
- {-defm-} _A_ 3 _U_ 022 _N_ _S_ _!_ _F_ _IF_ARGS_ 1 3 XXX 4 _/\_ u0 -> \ (u1 :: {{Ix u0}}) (u2 :: (u0, u0)) (u3 :: u0) -> _APP_ _TYAPP_ patError# { ((u0, u0) -> u0 -> Bool) } [ _NOREP_S_ "%DPreludeCore.Ix.inRange\"", u2, u3 ] _N_ #-}
+ {-defm-} _A_ 3 _U_ 022 _N_ _S_ _!_ _N_ _N_ #-}
class (Eq a, Text a) => Num a {-# GHC_PRAGMA {-superdicts-} _A_ 1 _U_ 1 _N_ _S_ "S" _F_ _IF_ARGS_ 1 1 C 2 _/\_ u0 -> \ (u1 :: ({{Eq u0}}, {{Text u0}}, u0 -> u0 -> u0, u0 -> u0 -> u0, u0 -> u0 -> u0, u0 -> u0, u0 -> u0, u0 -> u0, Integer -> u0, Int -> u0)) -> case u1 of { _ALG_ _TUP_10 (u2 :: {{Eq u0}}) (u3 :: {{Text u0}}) (u4 :: u0 -> u0 -> u0) (u5 :: u0 -> u0 -> u0) (u6 :: u0 -> u0 -> u0) (u7 :: u0 -> u0) (u8 :: u0 -> u0) (u9 :: u0 -> u0) (ua :: Integer -> u0) (ub :: Int -> u0) -> u2; _NO_DEFLT_ } _N_, _A_ 1 _U_ 1 _N_ _S_ "S" _F_ _IF_ARGS_ 1 1 C 2 _/\_ u0 -> \ (u1 :: ({{Eq u0}}, {{Text u0}}, u0 -> u0 -> u0, u0 -> u0 -> u0, u0 -> u0 -> u0, u0 -> u0, u0 -> u0, u0 -> u0, Integer -> u0, Int -> u0)) -> case u1 of { _ALG_ _TUP_10 (u2 :: {{Eq u0}}) (u3 :: {{Text u0}}) (u4 :: u0 -> u0 -> u0) (u5 :: u0 -> u0 -> u0) (u6 :: u0 -> u0 -> u0) (u7 :: u0 -> u0) (u8 :: u0 -> u0) (u9 :: u0 -> u0) (ua :: Integer -> u0) (ub :: Int -> u0) -> u3; _NO_DEFLT_ } _N_ #-} where
(+) :: a -> a -> a
{-# GHC_PRAGMA {-meth-} _A_ 1 _U_ 122 _N_ _S_ "S" _F_ _IF_ARGS_ 1 1 C 2 _/\_ u0 -> \ (u1 :: ({{Eq u0}}, {{Text u0}}, u0 -> u0 -> u0, u0 -> u0 -> u0, u0 -> u0 -> u0, u0 -> u0, u0 -> u0, u0 -> u0, Integer -> u0, Int -> u0)) -> case u1 of { _ALG_ _TUP_10 (u2 :: {{Eq u0}}) (u3 :: {{Text u0}}) (u4 :: u0 -> u0 -> u0) (u5 :: u0 -> u0 -> u0) (u6 :: u0 -> u0 -> u0) (u7 :: u0 -> u0) (u8 :: u0 -> u0) (u9 :: u0 -> u0) (ua :: Integer -> u0) (ub :: Int -> u0) -> u4; _NO_DEFLT_ } _N_
- {-defm-} _A_ 3 _U_ 022 _N_ _S_ _!_ _F_ _IF_ARGS_ 1 3 XXX 4 _/\_ u0 -> \ (u1 :: {{Num u0}}) (u2 :: u0) (u3 :: u0) -> _APP_ _TYAPP_ patError# { (u0 -> u0 -> u0) } [ _NOREP_S_ "%DPreludeCore.Num.(+)\"", u2, u3 ] _N_ #-}
+ {-defm-} _A_ 3 _U_ 022 _N_ _S_ _!_ _N_ _N_ #-}
(-) :: a -> a -> a
{-# GHC_PRAGMA {-meth-} _A_ 1 _U_ 122 _N_ _S_ "S" _F_ _IF_ARGS_ 1 1 C 2 _/\_ u0 -> \ (u1 :: ({{Eq u0}}, {{Text u0}}, u0 -> u0 -> u0, u0 -> u0 -> u0, u0 -> u0 -> u0, u0 -> u0, u0 -> u0, u0 -> u0, Integer -> u0, Int -> u0)) -> case u1 of { _ALG_ _TUP_10 (u2 :: {{Eq u0}}) (u3 :: {{Text u0}}) (u4 :: u0 -> u0 -> u0) (u5 :: u0 -> u0 -> u0) (u6 :: u0 -> u0 -> u0) (u7 :: u0 -> u0) (u8 :: u0 -> u0) (u9 :: u0 -> u0) (ua :: Integer -> u0) (ub :: Int -> u0) -> u5; _NO_DEFLT_ } _N_
{-defm-} _A_ 3 _U_ 122 _N_ _S_ "SLL" _F_ _ALWAYS_ _/\_ u0 -> \ (u1 :: {{Num u0}}) (u2 :: u0) (u3 :: u0) -> case u1 of { _ALG_ _TUP_10 (u4 :: {{Eq u0}}) (u5 :: {{Text u0}}) (u6 :: u0 -> u0 -> u0) (u7 :: u0 -> u0 -> u0) (u8 :: u0 -> u0 -> u0) (u9 :: u0 -> u0) (ua :: u0 -> u0) (ub :: u0 -> u0) (uc :: Integer -> u0) (ud :: Int -> u0) -> let {(ue :: u0) = _APP_ u9 [ u3 ]} in _APP_ u6 [ u2, ue ]; _NO_DEFLT_ } _N_ #-}
(*) :: a -> a -> a
{-# GHC_PRAGMA {-meth-} _A_ 1 _U_ 122 _N_ _S_ "S" _F_ _IF_ARGS_ 1 1 C 2 _/\_ u0 -> \ (u1 :: ({{Eq u0}}, {{Text u0}}, u0 -> u0 -> u0, u0 -> u0 -> u0, u0 -> u0 -> u0, u0 -> u0, u0 -> u0, u0 -> u0, Integer -> u0, Int -> u0)) -> case u1 of { _ALG_ _TUP_10 (u2 :: {{Eq u0}}) (u3 :: {{Text u0}}) (u4 :: u0 -> u0 -> u0) (u5 :: u0 -> u0 -> u0) (u6 :: u0 -> u0 -> u0) (u7 :: u0 -> u0) (u8 :: u0 -> u0) (u9 :: u0 -> u0) (ua :: Integer -> u0) (ub :: Int -> u0) -> u6; _NO_DEFLT_ } _N_
- {-defm-} _A_ 3 _U_ 022 _N_ _S_ _!_ _F_ _IF_ARGS_ 1 3 XXX 4 _/\_ u0 -> \ (u1 :: {{Num u0}}) (u2 :: u0) (u3 :: u0) -> _APP_ _TYAPP_ patError# { (u0 -> u0 -> u0) } [ _NOREP_S_ "%DPreludeCore.Num.(*)\"", u2, u3 ] _N_ #-}
+ {-defm-} _A_ 3 _U_ 022 _N_ _S_ _!_ _N_ _N_ #-}
negate :: a -> a
{-# GHC_PRAGMA {-meth-} _A_ 1 _U_ 12 _N_ _S_ "S" _F_ _IF_ARGS_ 1 1 C 2 _/\_ u0 -> \ (u1 :: ({{Eq u0}}, {{Text u0}}, u0 -> u0 -> u0, u0 -> u0 -> u0, u0 -> u0 -> u0, u0 -> u0, u0 -> u0, u0 -> u0, Integer -> u0, Int -> u0)) -> case u1 of { _ALG_ _TUP_10 (u2 :: {{Eq u0}}) (u3 :: {{Text u0}}) (u4 :: u0 -> u0 -> u0) (u5 :: u0 -> u0 -> u0) (u6 :: u0 -> u0 -> u0) (u7 :: u0 -> u0) (u8 :: u0 -> u0) (u9 :: u0 -> u0) (ua :: Integer -> u0) (ub :: Int -> u0) -> u7; _NO_DEFLT_ } _N_
- {-defm-} _A_ 2 _U_ 02 _N_ _S_ _!_ _F_ _IF_ARGS_ 1 2 XX 3 _/\_ u0 -> \ (u1 :: {{Num u0}}) (u2 :: u0) -> _APP_ _TYAPP_ patError# { (u0 -> u0) } [ _NOREP_S_ "%DPreludeCore.Num.negate\"", u2 ] _N_ #-}
+ {-defm-} _A_ 2 _U_ 02 _N_ _S_ _!_ _N_ _N_ #-}
abs :: a -> a
{-# GHC_PRAGMA {-meth-} _A_ 1 _U_ 12 _N_ _S_ "S" _F_ _IF_ARGS_ 1 1 C 2 _/\_ u0 -> \ (u1 :: ({{Eq u0}}, {{Text u0}}, u0 -> u0 -> u0, u0 -> u0 -> u0, u0 -> u0 -> u0, u0 -> u0, u0 -> u0, u0 -> u0, Integer -> u0, Int -> u0)) -> case u1 of { _ALG_ _TUP_10 (u2 :: {{Eq u0}}) (u3 :: {{Text u0}}) (u4 :: u0 -> u0 -> u0) (u5 :: u0 -> u0 -> u0) (u6 :: u0 -> u0 -> u0) (u7 :: u0 -> u0) (u8 :: u0 -> u0) (u9 :: u0 -> u0) (ua :: Integer -> u0) (ub :: Int -> u0) -> u8; _NO_DEFLT_ } _N_
- {-defm-} _A_ 2 _U_ 02 _N_ _S_ _!_ _F_ _IF_ARGS_ 1 2 XX 3 _/\_ u0 -> \ (u1 :: {{Num u0}}) (u2 :: u0) -> _APP_ _TYAPP_ patError# { (u0 -> u0) } [ _NOREP_S_ "%DPreludeCore.Num.abs\"", u2 ] _N_ #-}
+ {-defm-} _A_ 2 _U_ 02 _N_ _S_ _!_ _N_ _N_ #-}
signum :: a -> a
{-# GHC_PRAGMA {-meth-} _A_ 1 _U_ 12 _N_ _S_ "S" _F_ _IF_ARGS_ 1 1 C 2 _/\_ u0 -> \ (u1 :: ({{Eq u0}}, {{Text u0}}, u0 -> u0 -> u0, u0 -> u0 -> u0, u0 -> u0 -> u0, u0 -> u0, u0 -> u0, u0 -> u0, Integer -> u0, Int -> u0)) -> case u1 of { _ALG_ _TUP_10 (u2 :: {{Eq u0}}) (u3 :: {{Text u0}}) (u4 :: u0 -> u0 -> u0) (u5 :: u0 -> u0 -> u0) (u6 :: u0 -> u0 -> u0) (u7 :: u0 -> u0) (u8 :: u0 -> u0) (u9 :: u0 -> u0) (ua :: Integer -> u0) (ub :: Int -> u0) -> u9; _NO_DEFLT_ } _N_
- {-defm-} _A_ 2 _U_ 02 _N_ _S_ _!_ _F_ _IF_ARGS_ 1 2 XX 3 _/\_ u0 -> \ (u1 :: {{Num u0}}) (u2 :: u0) -> _APP_ _TYAPP_ patError# { (u0 -> u0) } [ _NOREP_S_ "%DPreludeCore.Num.signum\"", u2 ] _N_ #-}
+ {-defm-} _A_ 2 _U_ 02 _N_ _S_ _!_ _N_ _N_ #-}
fromInteger :: Integer -> a
{-# GHC_PRAGMA {-meth-} _A_ 1 _U_ 12 _N_ _S_ "S" _F_ _IF_ARGS_ 1 1 C 2 _/\_ u0 -> \ (u1 :: ({{Eq u0}}, {{Text u0}}, u0 -> u0 -> u0, u0 -> u0 -> u0, u0 -> u0 -> u0, u0 -> u0, u0 -> u0, u0 -> u0, Integer -> u0, Int -> u0)) -> case u1 of { _ALG_ _TUP_10 (u2 :: {{Eq u0}}) (u3 :: {{Text u0}}) (u4 :: u0 -> u0 -> u0) (u5 :: u0 -> u0 -> u0) (u6 :: u0 -> u0 -> u0) (u7 :: u0 -> u0) (u8 :: u0 -> u0) (u9 :: u0 -> u0) (ua :: Integer -> u0) (ub :: Int -> u0) -> ua; _NO_DEFLT_ } _N_
- {-defm-} _A_ 2 _U_ 02 _N_ _S_ _!_ _F_ _IF_ARGS_ 1 2 XX 3 _/\_ u0 -> \ (u1 :: {{Num u0}}) (u2 :: Integer) -> _APP_ _TYAPP_ patError# { (Integer -> u0) } [ _NOREP_S_ "%DPreludeCore.Num.fromInteger\"", u2 ] _N_ #-}
+ {-defm-} _A_ 2 _U_ 02 _N_ _S_ _!_ _N_ _N_ #-}
fromInt :: Int -> a
{-# GHC_PRAGMA {-meth-} _A_ 1 _U_ 12 _N_ _S_ "S" _F_ _IF_ARGS_ 1 1 C 2 _/\_ u0 -> \ (u1 :: ({{Eq u0}}, {{Text u0}}, u0 -> u0 -> u0, u0 -> u0 -> u0, u0 -> u0 -> u0, u0 -> u0, u0 -> u0, u0 -> u0, Integer -> u0, Int -> u0)) -> case u1 of { _ALG_ _TUP_10 (u2 :: {{Eq u0}}) (u3 :: {{Text u0}}) (u4 :: u0 -> u0 -> u0) (u5 :: u0 -> u0 -> u0) (u6 :: u0 -> u0 -> u0) (u7 :: u0 -> u0) (u8 :: u0 -> u0) (u9 :: u0 -> u0) (ua :: Integer -> u0) (ub :: Int -> u0) -> ub; _NO_DEFLT_ } _N_
{-defm-} _A_ 2 _U_ 11 _N_ _S_ "SL" _F_ _IF_ARGS_ 1 2 CC 6 _/\_ u0 -> \ (u1 :: {{Num u0}}) (u2 :: Int) -> let {(u4 :: Integer) = case u2 of { _ALG_ I# (u3 :: Int#) -> _#_ int2Integer# [] [u3]; _NO_DEFLT_ }} in case u1 of { _ALG_ _TUP_10 (u5 :: {{Eq u0}}) (u6 :: {{Text u0}}) (u7 :: u0 -> u0 -> u0) (u8 :: u0 -> u0 -> u0) (u9 :: u0 -> u0 -> u0) (ua :: u0 -> u0) (ub :: u0 -> u0) (uc :: u0 -> u0) (ud :: Integer -> u0) (ue :: Int -> u0) -> _APP_ ud [ u4 ]; _NO_DEFLT_ } _N_ #-}
{-defm-} _A_ 3 _U_ 122 _N_ _S_ "SLL" _N_ _N_ #-}
(<=) :: a -> a -> Bool
{-# GHC_PRAGMA {-meth-} _A_ 1 _U_ 122 _N_ _S_ "S" _F_ _IF_ARGS_ 1 1 C 2 _/\_ u0 -> \ (u1 :: ({{Eq u0}}, u0 -> u0 -> Bool, u0 -> u0 -> Bool, u0 -> u0 -> Bool, u0 -> u0 -> Bool, u0 -> u0 -> u0, u0 -> u0 -> u0, u0 -> u0 -> _CMP_TAG)) -> case u1 of { _ALG_ _TUP_8 (u2 :: {{Eq u0}}) (u3 :: u0 -> u0 -> Bool) (u4 :: u0 -> u0 -> Bool) (u5 :: u0 -> u0 -> Bool) (u6 :: u0 -> u0 -> Bool) (u7 :: u0 -> u0 -> u0) (u8 :: u0 -> u0 -> u0) (u9 :: u0 -> u0 -> _CMP_TAG) -> u4; _NO_DEFLT_ } _N_
- {-defm-} _A_ 3 _U_ 022 _N_ _S_ _!_ _F_ _IF_ARGS_ 1 3 XXX 4 _/\_ u0 -> \ (u1 :: {{Ord u0}}) (u2 :: u0) (u3 :: u0) -> _APP_ _TYAPP_ patError# { (u0 -> u0 -> Bool) } [ _NOREP_S_ "%DPreludeCore.Ord.(<=)\"", u2, u3 ] _N_ #-}
+ {-defm-} _A_ 3 _U_ 022 _N_ _S_ _!_ _N_ _N_ #-}
(>=) :: a -> a -> Bool
{-# GHC_PRAGMA {-meth-} _A_ 1 _U_ 122 _N_ _S_ "S" _F_ _IF_ARGS_ 1 1 C 2 _/\_ u0 -> \ (u1 :: ({{Eq u0}}, u0 -> u0 -> Bool, u0 -> u0 -> Bool, u0 -> u0 -> Bool, u0 -> u0 -> Bool, u0 -> u0 -> u0, u0 -> u0 -> u0, u0 -> u0 -> _CMP_TAG)) -> case u1 of { _ALG_ _TUP_8 (u2 :: {{Eq u0}}) (u3 :: u0 -> u0 -> Bool) (u4 :: u0 -> u0 -> Bool) (u5 :: u0 -> u0 -> Bool) (u6 :: u0 -> u0 -> Bool) (u7 :: u0 -> u0 -> u0) (u8 :: u0 -> u0 -> u0) (u9 :: u0 -> u0 -> _CMP_TAG) -> u5; _NO_DEFLT_ } _N_
{-defm-} _A_ 3 _U_ 122 _N_ _S_ "SLL" _F_ _IF_ARGS_ 1 3 CXX 4 _/\_ u0 -> \ (u1 :: {{Ord u0}}) (u2 :: u0) (u3 :: u0) -> case u1 of { _ALG_ _TUP_8 (u4 :: {{Eq u0}}) (u5 :: u0 -> u0 -> Bool) (u6 :: u0 -> u0 -> Bool) (u7 :: u0 -> u0 -> Bool) (u8 :: u0 -> u0 -> Bool) (u9 :: u0 -> u0 -> u0) (ua :: u0 -> u0 -> u0) (ub :: u0 -> u0 -> _CMP_TAG) -> _APP_ u6 [ u3, u2 ]; _NO_DEFLT_ } _N_ #-}
class (Num a, Enum a) => Real a {-# GHC_PRAGMA {-superdicts-} _A_ 1 _U_ 1 _N_ _S_ "S" _F_ _IF_ARGS_ 1 1 C 2 _/\_ u0 -> \ (u1 :: ({{Num u0}}, {{Enum u0}}, u0 -> Ratio Integer)) -> case u1 of { _ALG_ _TUP_3 (u2 :: {{Num u0}}) (u3 :: {{Enum u0}}) (u4 :: u0 -> Ratio Integer) -> u2; _NO_DEFLT_ } _N_, _A_ 1 _U_ 1 _N_ _S_ "S" _F_ _IF_ARGS_ 1 1 C 2 _/\_ u0 -> \ (u1 :: ({{Num u0}}, {{Enum u0}}, u0 -> Ratio Integer)) -> case u1 of { _ALG_ _TUP_3 (u2 :: {{Num u0}}) (u3 :: {{Enum u0}}) (u4 :: u0 -> Ratio Integer) -> u3; _NO_DEFLT_ } _N_ #-} where
toRational :: a -> Ratio Integer
{-# GHC_PRAGMA {-meth-} _A_ 1 _U_ 12 _N_ _S_ "S" _F_ _IF_ARGS_ 1 1 C 2 _/\_ u0 -> \ (u1 :: ({{Num u0}}, {{Enum u0}}, u0 -> Ratio Integer)) -> case u1 of { _ALG_ _TUP_3 (u2 :: {{Num u0}}) (u3 :: {{Enum u0}}) (u4 :: u0 -> Ratio Integer) -> u4; _NO_DEFLT_ } _N_
- {-defm-} _A_ 2 _U_ 02 _N_ _S_ _!_ _F_ _IF_ARGS_ 1 2 XX 3 _/\_ u0 -> \ (u1 :: {{Real u0}}) (u2 :: u0) -> _APP_ _TYAPP_ patError# { (u0 -> Ratio Integer) } [ _NOREP_S_ "%DPreludeCore.Real.toRational\"", u2 ] _N_ #-}
+ {-defm-} _A_ 2 _U_ 02 _N_ _S_ _!_ _N_ _N_ #-}
class (RealFrac a, Floating a) => RealFloat a {-# GHC_PRAGMA {-superdicts-} _A_ 1 _U_ 1 _N_ _S_ "S" _F_ _IF_ARGS_ 1 1 C 2 _/\_ u0 -> \ (u1 :: ({{RealFrac u0}}, {{Floating u0}}, u0 -> Integer, u0 -> Int, u0 -> (Int, Int), u0 -> (Integer, Int), Integer -> Int -> u0, u0 -> Int, u0 -> u0, Int -> u0 -> u0)) -> case u1 of { _ALG_ _TUP_10 (u2 :: {{RealFrac u0}}) (u3 :: {{Floating u0}}) (u4 :: u0 -> Integer) (u5 :: u0 -> Int) (u6 :: u0 -> (Int, Int)) (u7 :: u0 -> (Integer, Int)) (u8 :: Integer -> Int -> u0) (u9 :: u0 -> Int) (ua :: u0 -> u0) (ub :: Int -> u0 -> u0) -> u2; _NO_DEFLT_ } _N_, _A_ 1 _U_ 1 _N_ _S_ "S" _F_ _IF_ARGS_ 1 1 C 2 _/\_ u0 -> \ (u1 :: ({{RealFrac u0}}, {{Floating u0}}, u0 -> Integer, u0 -> Int, u0 -> (Int, Int), u0 -> (Integer, Int), Integer -> Int -> u0, u0 -> Int, u0 -> u0, Int -> u0 -> u0)) -> case u1 of { _ALG_ _TUP_10 (u2 :: {{RealFrac u0}}) (u3 :: {{Floating u0}}) (u4 :: u0 -> Integer) (u5 :: u0 -> Int) (u6 :: u0 -> (Int, Int)) (u7 :: u0 -> (Integer, Int)) (u8 :: Integer -> Int -> u0) (u9 :: u0 -> Int) (ua :: u0 -> u0) (ub :: Int -> u0 -> u0) -> u3; _NO_DEFLT_ } _N_ #-} where
floatRadix :: a -> Integer
{-# GHC_PRAGMA {-meth-} _A_ 1 _U_ 12 _N_ _S_ "S" _F_ _IF_ARGS_ 1 1 C 2 _/\_ u0 -> \ (u1 :: ({{RealFrac u0}}, {{Floating u0}}, u0 -> Integer, u0 -> Int, u0 -> (Int, Int), u0 -> (Integer, Int), Integer -> Int -> u0, u0 -> Int, u0 -> u0, Int -> u0 -> u0)) -> case u1 of { _ALG_ _TUP_10 (u2 :: {{RealFrac u0}}) (u3 :: {{Floating u0}}) (u4 :: u0 -> Integer) (u5 :: u0 -> Int) (u6 :: u0 -> (Int, Int)) (u7 :: u0 -> (Integer, Int)) (u8 :: Integer -> Int -> u0) (u9 :: u0 -> Int) (ua :: u0 -> u0) (ub :: Int -> u0 -> u0) -> u4; _NO_DEFLT_ } _N_
- {-defm-} _A_ 2 _U_ 02 _N_ _S_ _!_ _F_ _IF_ARGS_ 1 2 XX 3 _/\_ u0 -> \ (u1 :: {{RealFloat u0}}) (u2 :: u0) -> _APP_ _TYAPP_ patError# { (u0 -> Integer) } [ _NOREP_S_ "%DPreludeCore.RealFloat.floatRadix\"", u2 ] _N_ #-}
+ {-defm-} _A_ 2 _U_ 02 _N_ _S_ _!_ _N_ _N_ #-}
floatDigits :: a -> Int
{-# GHC_PRAGMA {-meth-} _A_ 1 _U_ 12 _N_ _S_ "S" _F_ _IF_ARGS_ 1 1 C 2 _/\_ u0 -> \ (u1 :: ({{RealFrac u0}}, {{Floating u0}}, u0 -> Integer, u0 -> Int, u0 -> (Int, Int), u0 -> (Integer, Int), Integer -> Int -> u0, u0 -> Int, u0 -> u0, Int -> u0 -> u0)) -> case u1 of { _ALG_ _TUP_10 (u2 :: {{RealFrac u0}}) (u3 :: {{Floating u0}}) (u4 :: u0 -> Integer) (u5 :: u0 -> Int) (u6 :: u0 -> (Int, Int)) (u7 :: u0 -> (Integer, Int)) (u8 :: Integer -> Int -> u0) (u9 :: u0 -> Int) (ua :: u0 -> u0) (ub :: Int -> u0 -> u0) -> u5; _NO_DEFLT_ } _N_
- {-defm-} _A_ 2 _U_ 02 _N_ _S_ _!_ _F_ _IF_ARGS_ 1 2 XX 3 _/\_ u0 -> \ (u1 :: {{RealFloat u0}}) (u2 :: u0) -> _APP_ _TYAPP_ patError# { (u0 -> Int) } [ _NOREP_S_ "%DPreludeCore.RealFloat.floatDigits\"", u2 ] _N_ #-}
+ {-defm-} _A_ 2 _U_ 02 _N_ _S_ _!_ _N_ _N_ #-}
floatRange :: a -> (Int, Int)
{-# GHC_PRAGMA {-meth-} _A_ 1 _U_ 12 _N_ _S_ "S" _F_ _IF_ARGS_ 1 1 C 2 _/\_ u0 -> \ (u1 :: ({{RealFrac u0}}, {{Floating u0}}, u0 -> Integer, u0 -> Int, u0 -> (Int, Int), u0 -> (Integer, Int), Integer -> Int -> u0, u0 -> Int, u0 -> u0, Int -> u0 -> u0)) -> case u1 of { _ALG_ _TUP_10 (u2 :: {{RealFrac u0}}) (u3 :: {{Floating u0}}) (u4 :: u0 -> Integer) (u5 :: u0 -> Int) (u6 :: u0 -> (Int, Int)) (u7 :: u0 -> (Integer, Int)) (u8 :: Integer -> Int -> u0) (u9 :: u0 -> Int) (ua :: u0 -> u0) (ub :: Int -> u0 -> u0) -> u6; _NO_DEFLT_ } _N_
- {-defm-} _A_ 2 _U_ 02 _N_ _S_ _!_ _F_ _IF_ARGS_ 1 2 XX 3 _/\_ u0 -> \ (u1 :: {{RealFloat u0}}) (u2 :: u0) -> _APP_ _TYAPP_ patError# { (u0 -> (Int, Int)) } [ _NOREP_S_ "%DPreludeCore.RealFloat.floatRange\"", u2 ] _N_ #-}
+ {-defm-} _A_ 2 _U_ 02 _N_ _S_ _!_ _N_ _N_ #-}
decodeFloat :: a -> (Integer, Int)
{-# GHC_PRAGMA {-meth-} _A_ 1 _U_ 12 _N_ _S_ "S" _F_ _IF_ARGS_ 1 1 C 2 _/\_ u0 -> \ (u1 :: ({{RealFrac u0}}, {{Floating u0}}, u0 -> Integer, u0 -> Int, u0 -> (Int, Int), u0 -> (Integer, Int), Integer -> Int -> u0, u0 -> Int, u0 -> u0, Int -> u0 -> u0)) -> case u1 of { _ALG_ _TUP_10 (u2 :: {{RealFrac u0}}) (u3 :: {{Floating u0}}) (u4 :: u0 -> Integer) (u5 :: u0 -> Int) (u6 :: u0 -> (Int, Int)) (u7 :: u0 -> (Integer, Int)) (u8 :: Integer -> Int -> u0) (u9 :: u0 -> Int) (ua :: u0 -> u0) (ub :: Int -> u0 -> u0) -> u7; _NO_DEFLT_ } _N_
- {-defm-} _A_ 2 _U_ 02 _N_ _S_ _!_ _F_ _IF_ARGS_ 1 2 XX 3 _/\_ u0 -> \ (u1 :: {{RealFloat u0}}) (u2 :: u0) -> _APP_ _TYAPP_ patError# { (u0 -> (Integer, Int)) } [ _NOREP_S_ "%DPreludeCore.RealFloat.decodeFloat\"", u2 ] _N_ #-}
+ {-defm-} _A_ 2 _U_ 02 _N_ _S_ _!_ _N_ _N_ #-}
encodeFloat :: Integer -> Int -> a
{-# GHC_PRAGMA {-meth-} _A_ 1 _U_ 122 _N_ _S_ "S" _F_ _IF_ARGS_ 1 1 C 2 _/\_ u0 -> \ (u1 :: ({{RealFrac u0}}, {{Floating u0}}, u0 -> Integer, u0 -> Int, u0 -> (Int, Int), u0 -> (Integer, Int), Integer -> Int -> u0, u0 -> Int, u0 -> u0, Int -> u0 -> u0)) -> case u1 of { _ALG_ _TUP_10 (u2 :: {{RealFrac u0}}) (u3 :: {{Floating u0}}) (u4 :: u0 -> Integer) (u5 :: u0 -> Int) (u6 :: u0 -> (Int, Int)) (u7 :: u0 -> (Integer, Int)) (u8 :: Integer -> Int -> u0) (u9 :: u0 -> Int) (ua :: u0 -> u0) (ub :: Int -> u0 -> u0) -> u8; _NO_DEFLT_ } _N_
- {-defm-} _A_ 3 _U_ 022 _N_ _S_ _!_ _F_ _IF_ARGS_ 1 3 XXX 4 _/\_ u0 -> \ (u1 :: {{RealFloat u0}}) (u2 :: Integer) (u3 :: Int) -> _APP_ _TYAPP_ patError# { (Integer -> Int -> u0) } [ _NOREP_S_ "%DPreludeCore.RealFloat.encodeFloat\"", u2, u3 ] _N_ #-}
+ {-defm-} _A_ 3 _U_ 022 _N_ _S_ _!_ _N_ _N_ #-}
exponent :: a -> Int
{-# GHC_PRAGMA {-meth-} _A_ 1 _U_ 12 _N_ _S_ "S" _F_ _IF_ARGS_ 1 1 C 2 _/\_ u0 -> \ (u1 :: ({{RealFrac u0}}, {{Floating u0}}, u0 -> Integer, u0 -> Int, u0 -> (Int, Int), u0 -> (Integer, Int), Integer -> Int -> u0, u0 -> Int, u0 -> u0, Int -> u0 -> u0)) -> case u1 of { _ALG_ _TUP_10 (u2 :: {{RealFrac u0}}) (u3 :: {{Floating u0}}) (u4 :: u0 -> Integer) (u5 :: u0 -> Int) (u6 :: u0 -> (Int, Int)) (u7 :: u0 -> (Integer, Int)) (u8 :: Integer -> Int -> u0) (u9 :: u0 -> Int) (ua :: u0 -> u0) (ub :: Int -> u0 -> u0) -> u9; _NO_DEFLT_ } _N_
{-defm-} _A_ 2 _U_ 12 _N_ _S_ "SL" _N_ _N_ #-}
class (Real a, Fractional a) => RealFrac a {-# GHC_PRAGMA {-superdicts-} _A_ 1 _U_ 1 _N_ _S_ "S" _F_ _IF_ARGS_ 1 1 C 2 _/\_ u0 -> \ (u1 :: ({{Real u0}}, {{Fractional u0}}, (_forall_ z$z1 =>{{Integral z$z1}} -> u0 -> (z$z1, u0)), (_forall_ z$z1 =>{{Integral z$z1}} -> u0 -> z$z1), (_forall_ z$z1 =>{{Integral z$z1}} -> u0 -> z$z1), (_forall_ z$z1 =>{{Integral z$z1}} -> u0 -> z$z1), (_forall_ z$z1 =>{{Integral z$z1}} -> u0 -> z$z1))) -> case u1 of { _ALG_ _TUP_7 (u2 :: {{Real u0}}) (u3 :: {{Fractional u0}}) (u4 :: _forall_ a$z1 =>{{Integral a$z1}} -> u0 -> (a$z1, u0)) (u5 :: _forall_ a$z1 =>{{Integral a$z1}} -> u0 -> a$z1) (u6 :: _forall_ a$z1 =>{{Integral a$z1}} -> u0 -> a$z1) (u7 :: _forall_ a$z1 =>{{Integral a$z1}} -> u0 -> a$z1) (u8 :: _forall_ a$z1 =>{{Integral a$z1}} -> u0 -> a$z1) -> u2; _NO_DEFLT_ } _N_, _A_ 1 _U_ 1 _N_ _S_ "S" _F_ _IF_ARGS_ 1 1 C 2 _/\_ u0 -> \ (u1 :: ({{Real u0}}, {{Fractional u0}}, (_forall_ z$z1 =>{{Integral z$z1}} -> u0 -> (z$z1, u0)), (_forall_ z$z1 =>{{Integral z$z1}} -> u0 -> z$z1), (_forall_ z$z1 =>{{Integral z$z1}} -> u0 -> z$z1), (_forall_ z$z1 =>{{Integral z$z1}} -> u0 -> z$z1), (_forall_ z$z1 =>{{Integral z$z1}} -> u0 -> z$z1))) -> case u1 of { _ALG_ _TUP_7 (u2 :: {{Real u0}}) (u3 :: {{Fractional u0}}) (u4 :: _forall_ a$z1 =>{{Integral a$z1}} -> u0 -> (a$z1, u0)) (u5 :: _forall_ a$z1 =>{{Integral a$z1}} -> u0 -> a$z1) (u6 :: _forall_ a$z1 =>{{Integral a$z1}} -> u0 -> a$z1) (u7 :: _forall_ a$z1 =>{{Integral a$z1}} -> u0 -> a$z1) (u8 :: _forall_ a$z1 =>{{Integral a$z1}} -> u0 -> a$z1) -> u3; _NO_DEFLT_ } _N_ #-} where
properFraction :: Integral b => a -> (b, a)
{-# GHC_PRAGMA {-meth-} _A_ 2 _U_ 122 _N_ _S_ "SL" _F_ _IF_ARGS_ 2 2 CX 3 _/\_ u0 u1 -> \ (u2 :: ({{Real u0}}, {{Fractional u0}}, (_forall_ z$z1 =>{{Integral z$z1}} -> u0 -> (z$z1, u0)), (_forall_ z$z1 =>{{Integral z$z1}} -> u0 -> z$z1), (_forall_ z$z1 =>{{Integral z$z1}} -> u0 -> z$z1), (_forall_ z$z1 =>{{Integral z$z1}} -> u0 -> z$z1), (_forall_ z$z1 =>{{Integral z$z1}} -> u0 -> z$z1))) (u3 :: {{Integral u1}}) -> case u2 of { _ALG_ _TUP_7 (u4 :: {{Real u0}}) (u5 :: {{Fractional u0}}) (u6 :: _forall_ a$z1 =>{{Integral a$z1}} -> u0 -> (a$z1, u0)) (u7 :: _forall_ a$z1 =>{{Integral a$z1}} -> u0 -> a$z1) (u8 :: _forall_ a$z1 =>{{Integral a$z1}} -> u0 -> a$z1) (u9 :: _forall_ a$z1 =>{{Integral a$z1}} -> u0 -> a$z1) (ua :: _forall_ a$z1 =>{{Integral a$z1}} -> u0 -> a$z1) -> _APP_ _TYAPP_ u6 { u1 } [ u3 ]; _NO_DEFLT_ } _N_
- {-defm-} _A_ 3 _U_ 002 _N_ _S_ _!_ _F_ _IF_ARGS_ 2 3 XXX 3 _/\_ u0 u1 -> \ (u2 :: {{RealFrac u0}}) (u3 :: {{Integral u1}}) (u4 :: u0) -> _APP_ _TYAPP_ patError# { (u0 -> (u1, u0)) } [ _NOREP_S_ "%DPreludeCore.RealFrac.properFraction\"", u4 ] _N_ #-}
+ {-defm-} _A_ 3 _U_ 002 _N_ _S_ _!_ _N_ _N_ #-}
truncate :: Integral b => a -> b
{-# GHC_PRAGMA {-meth-} _A_ 2 _U_ 122 _N_ _S_ "SL" _F_ _IF_ARGS_ 2 2 CX 3 _/\_ u0 u1 -> \ (u2 :: ({{Real u0}}, {{Fractional u0}}, (_forall_ z$z1 =>{{Integral z$z1}} -> u0 -> (z$z1, u0)), (_forall_ z$z1 =>{{Integral z$z1}} -> u0 -> z$z1), (_forall_ z$z1 =>{{Integral z$z1}} -> u0 -> z$z1), (_forall_ z$z1 =>{{Integral z$z1}} -> u0 -> z$z1), (_forall_ z$z1 =>{{Integral z$z1}} -> u0 -> z$z1))) (u3 :: {{Integral u1}}) -> case u2 of { _ALG_ _TUP_7 (u4 :: {{Real u0}}) (u5 :: {{Fractional u0}}) (u6 :: _forall_ a$z1 =>{{Integral a$z1}} -> u0 -> (a$z1, u0)) (u7 :: _forall_ a$z1 =>{{Integral a$z1}} -> u0 -> a$z1) (u8 :: _forall_ a$z1 =>{{Integral a$z1}} -> u0 -> a$z1) (u9 :: _forall_ a$z1 =>{{Integral a$z1}} -> u0 -> a$z1) (ua :: _forall_ a$z1 =>{{Integral a$z1}} -> u0 -> a$z1) -> _APP_ _TYAPP_ u7 { u1 } [ u3 ]; _NO_DEFLT_ } _N_
{-defm-} _A_ 2 _U_ 122 _N_ _S_ "SL" _N_ _N_ #-}
class Text a where
readsPrec :: Int -> [Char] -> [(a, [Char])]
{-# GHC_PRAGMA {-meth-} _A_ 1 _U_ 122 _N_ _S_ "S" _F_ _IF_ARGS_ 1 1 C 2 _/\_ u0 -> \ (u1 :: (Int -> [Char] -> [(u0, [Char])], Int -> u0 -> [Char] -> [Char], [Char] -> [([u0], [Char])], [u0] -> [Char] -> [Char])) -> case u1 of { _ALG_ _TUP_4 (u2 :: Int -> [Char] -> [(u0, [Char])]) (u3 :: Int -> u0 -> [Char] -> [Char]) (u4 :: [Char] -> [([u0], [Char])]) (u5 :: [u0] -> [Char] -> [Char]) -> u2; _NO_DEFLT_ } _N_
- {-defm-} _A_ 3 _U_ 022 _N_ _S_ _!_ _F_ _IF_ARGS_ 1 3 XXX 4 _/\_ u0 -> \ (u1 :: {{Text u0}}) (u2 :: Int) (u3 :: [Char]) -> _APP_ _TYAPP_ patError# { (Int -> [Char] -> [(u0, [Char])]) } [ _NOREP_S_ "%DPreludeCore.Text.readsPrec\"", u2, u3 ] _N_ #-}
+ {-defm-} _A_ 3 _U_ 022 _N_ _S_ _!_ _N_ _N_ #-}
showsPrec :: Int -> a -> [Char] -> [Char]
{-# GHC_PRAGMA {-meth-} _A_ 1 _U_ 1222 _N_ _S_ "S" _F_ _IF_ARGS_ 1 1 C 2 _/\_ u0 -> \ (u1 :: (Int -> [Char] -> [(u0, [Char])], Int -> u0 -> [Char] -> [Char], [Char] -> [([u0], [Char])], [u0] -> [Char] -> [Char])) -> case u1 of { _ALG_ _TUP_4 (u2 :: Int -> [Char] -> [(u0, [Char])]) (u3 :: Int -> u0 -> [Char] -> [Char]) (u4 :: [Char] -> [([u0], [Char])]) (u5 :: [u0] -> [Char] -> [Char]) -> u3; _NO_DEFLT_ } _N_
- {-defm-} _A_ 4 _U_ 0222 _N_ _S_ _!_ _F_ _IF_ARGS_ 1 4 XXXX 5 _/\_ u0 -> \ (u1 :: {{Text u0}}) (u2 :: Int) (u3 :: u0) (u4 :: [Char]) -> _APP_ _TYAPP_ patError# { (Int -> u0 -> [Char] -> [Char]) } [ _NOREP_S_ "%DPreludeCore.Text.showsPrec\"", u2, u3, u4 ] _N_ #-}
+ {-defm-} _A_ 4 _U_ 0222 _N_ _S_ _!_ _N_ _N_ #-}
readList :: [Char] -> [([a], [Char])]
{-# GHC_PRAGMA {-meth-} _A_ 1 _U_ 12 _N_ _S_ "S" _F_ _IF_ARGS_ 1 1 C 2 _/\_ u0 -> \ (u1 :: (Int -> [Char] -> [(u0, [Char])], Int -> u0 -> [Char] -> [Char], [Char] -> [([u0], [Char])], [u0] -> [Char] -> [Char])) -> case u1 of { _ALG_ _TUP_4 (u2 :: Int -> [Char] -> [(u0, [Char])]) (u3 :: Int -> u0 -> [Char] -> [Char]) (u4 :: [Char] -> [([u0], [Char])]) (u5 :: [u0] -> [Char] -> [Char]) -> u4; _NO_DEFLT_ } _N_
- {-defm-} _A_ 1 _U_ 22 _N_ _N_ _F_ _IF_ARGS_ 0 0 X 1 _ORIG_ PreludeCore _readList _N_ #-}
+ {-defm-} _A_ 1 _U_ 12 _N_ _N_ _N_ _N_ #-}
showList :: [a] -> [Char] -> [Char]
{-# GHC_PRAGMA {-meth-} _A_ 1 _U_ 122 _N_ _S_ "S" _F_ _IF_ARGS_ 1 1 C 2 _/\_ u0 -> \ (u1 :: (Int -> [Char] -> [(u0, [Char])], Int -> u0 -> [Char] -> [Char], [Char] -> [([u0], [Char])], [u0] -> [Char] -> [Char])) -> case u1 of { _ALG_ _TUP_4 (u2 :: Int -> [Char] -> [(u0, [Char])]) (u3 :: Int -> u0 -> [Char] -> [Char]) (u4 :: [Char] -> [([u0], [Char])]) (u5 :: [u0] -> [Char] -> [Char]) -> u5; _NO_DEFLT_ } _N_
- {-defm-} _A_ 1 _U_ 212 _N_ _N_ _F_ _IF_ARGS_ 0 0 X 1 _ORIG_ PreludeCore _showList _N_ #-}
+ {-defm-} _A_ 1 _U_ 112 _N_ _N_ _N_ _N_ #-}
class _CCallable a
class _CReturnable a
data Array a b {-# GHC_PRAGMA _Array (a, a) (Array# b) #-}
data Assoc a b = (:=) a b
data _ByteArray a {-# GHC_PRAGMA _ByteArray (a, a) ByteArray# #-}
data Bin
-data Complex a = (:+) a a
+data Complex a = (:+) a a {-# GHC_PRAGMA _SPECIALISE_ [ Double# ] #-}
data _MutableArray a b c {-# GHC_PRAGMA _MutableArray (b, b) (MutableArray# a c) #-}
data _MutableByteArray a b {-# GHC_PRAGMA _MutableByteArray (b, b) (MutableByteArray# a) #-}
type BinCont = Bin -> [Response] -> [Request]
type ReadS a = [Char] -> [(a, [Char])]
type ShowS = [Char] -> [Char]
data _FILE {-# GHC_PRAGMA _FILE Addr# #-}
+__i0 :: Num a => a
+ {-# GHC_PRAGMA _A_ 1 _U_ 1 _N_ _S_ "U(AAAAAAAAAS)" {_A_ 1 _U_ 1 _N_ _N_ _N_ _N_} _N_ _SPECIALISE_ [ Double ] 1 { _A_ 0 _N_ _N_ _N_ _F_ _IF_ARGS_ 0 0 X 2 _!_ D# [] [0.0000000000000000##] _N_ }, [ Int ] 1 { _A_ 0 _N_ _N_ _N_ _F_ _IF_ARGS_ 0 0 X 2 _!_ I# [] [0#] _N_ }, [ Integer ] 1 { _A_ 0 _N_ _N_ _N_ _N_ _N_ }, [ (Ratio Integer) ] 1 { _A_ 0 _N_ _N_ _N_ _N_ _N_ }, [ (Complex Double) ] 1 { _A_ 0 _N_ _N_ _N_ _N_ _N_ } #-}
+__i1 :: Num a => a
+ {-# GHC_PRAGMA _A_ 1 _U_ 1 _N_ _S_ "U(AAAAAAAAAS)" {_A_ 1 _U_ 1 _N_ _N_ _N_ _N_} _N_ _SPECIALISE_ [ Double ] 1 { _A_ 0 _N_ _N_ _N_ _F_ _IF_ARGS_ 0 0 X 2 _!_ D# [] [1.0000000000000000##] _N_ }, [ Int ] 1 { _A_ 0 _N_ _N_ _N_ _F_ _IF_ARGS_ 0 0 X 2 _!_ I# [] [1#] _N_ }, [ Integer ] 1 { _A_ 0 _N_ _N_ _N_ _N_ _N_ }, [ (Ratio Integer) ] 1 { _A_ 0 _N_ _N_ _N_ _N_ _N_ }, [ (Complex Double) ] 1 { _A_ 0 _N_ _N_ _N_ _N_ _N_ } #-}
+__i10 :: Num a => a
+ {-# GHC_PRAGMA _A_ 1 _U_ 1 _N_ _S_ "U(AAAAAAAAAS)" {_A_ 1 _U_ 1 _N_ _N_ _N_ _N_} _N_ _SPECIALISE_ [ Double ] 1 { _A_ 0 _N_ _N_ _N_ _F_ _IF_ARGS_ 0 0 X 2 _!_ D# [] [10.000000000000000##] _N_ }, [ Int ] 1 { _A_ 0 _N_ _N_ _N_ _F_ _IF_ARGS_ 0 0 X 2 _!_ I# [] [10#] _N_ }, [ Integer ] 1 { _A_ 0 _N_ _N_ _N_ _N_ _N_ }, [ (Ratio Integer) ] 1 { _A_ 0 _N_ _N_ _N_ _N_ _N_ }, [ (Complex Double) ] 1 { _A_ 0 _N_ _N_ _N_ _N_ _N_ } #-}
+__i16 :: Num a => a
+ {-# GHC_PRAGMA _A_ 1 _U_ 1 _N_ _S_ "U(AAAAAAAAAS)" {_A_ 1 _U_ 1 _N_ _N_ _N_ _N_} _N_ _SPECIALISE_ [ Double ] 1 { _A_ 0 _N_ _N_ _N_ _F_ _IF_ARGS_ 0 0 X 2 _!_ D# [] [16.000000000000000##] _N_ }, [ Int ] 1 { _A_ 0 _N_ _N_ _N_ _F_ _IF_ARGS_ 0 0 X 2 _!_ I# [] [16#] _N_ }, [ Integer ] 1 { _A_ 0 _N_ _N_ _N_ _N_ _N_ }, [ (Ratio Integer) ] 1 { _A_ 0 _N_ _N_ _N_ _N_ _N_ }, [ (Complex Double) ] 1 { _A_ 0 _N_ _N_ _N_ _N_ _N_ } #-}
+__i2 :: Num a => a
+ {-# GHC_PRAGMA _A_ 1 _U_ 1 _N_ _S_ "U(AAAAAAAAAS)" {_A_ 1 _U_ 1 _N_ _N_ _N_ _N_} _N_ _SPECIALISE_ [ Double ] 1 { _A_ 0 _N_ _N_ _N_ _F_ _IF_ARGS_ 0 0 X 2 _!_ D# [] [2.0000000000000000##] _N_ }, [ Int ] 1 { _A_ 0 _N_ _N_ _N_ _F_ _IF_ARGS_ 0 0 X 2 _!_ I# [] [2#] _N_ }, [ Integer ] 1 { _A_ 0 _N_ _N_ _N_ _N_ _N_ }, [ (Ratio Integer) ] 1 { _A_ 0 _N_ _N_ _N_ _N_ _N_ }, [ (Complex Double) ] 1 { _A_ 0 _N_ _N_ _N_ _N_ _N_ } #-}
+__i8 :: Num a => a
+ {-# GHC_PRAGMA _A_ 1 _U_ 1 _N_ _S_ "U(AAAAAAAAAS)" {_A_ 1 _U_ 1 _N_ _N_ _N_ _N_} _N_ _SPECIALISE_ [ Double ] 1 { _A_ 0 _N_ _N_ _N_ _F_ _IF_ARGS_ 0 0 X 2 _!_ D# [] [8.0000000000000000##] _N_ }, [ Int ] 1 { _A_ 0 _N_ _N_ _N_ _F_ _IF_ARGS_ 0 0 X 2 _!_ I# [] [8#] _N_ }, [ Integer ] 1 { _A_ 0 _N_ _N_ _N_ _N_ _N_ }, [ (Ratio Integer) ] 1 { _A_ 0 _N_ _N_ _N_ _N_ _N_ }, [ (Complex Double) ] 1 { _A_ 0 _N_ _N_ _N_ _N_ _N_ } #-}
+__im1 :: Num a => a
+ {-# GHC_PRAGMA _A_ 1 _U_ 1 _N_ _S_ "U(AAAAAAAAAS)" {_A_ 1 _U_ 1 _N_ _N_ _N_ _N_} _N_ _SPECIALISE_ [ Double ] 1 { _A_ 0 _N_ _N_ _N_ _F_ _IF_ARGS_ 0 0 X 2 _!_ D# [] [-1.0000000000000000##] _N_ }, [ Int ] 1 { _A_ 0 _N_ _N_ _N_ _F_ _IF_ARGS_ 0 0 X 2 _!_ I# [] [-1#] _N_ }, [ Integer ] 1 { _A_ 0 _N_ _N_ _N_ _N_ _N_ }, [ (Ratio Integer) ] 1 { _A_ 0 _N_ _N_ _N_ _N_ _N_ }, [ (Complex Double) ] 1 { _A_ 0 _N_ _N_ _N_ _N_ _N_ } #-}
+__integer0 :: Integer
+ {-# GHC_PRAGMA _A_ 0 _N_ _N_ _N_ _N_ _N_ #-}
+__integer1 :: Integer
+ {-# GHC_PRAGMA _A_ 0 _N_ _N_ _N_ _N_ _N_ #-}
+__integer2 :: Integer
+ {-# GHC_PRAGMA _A_ 0 _N_ _N_ _N_ _N_ _N_ #-}
+__integerm1 :: Integer
+ {-# GHC_PRAGMA _A_ 0 _N_ _N_ _N_ _N_ _N_ #-}
+__rhalf :: Fractional a => a
+ {-# GHC_PRAGMA _A_ 1 _U_ 1 _N_ _S_ "U(AAAS)" {_A_ 1 _U_ 1 _N_ _N_ _N_ _N_} _N_ _SPECIALISE_ [ Double ] 1 { _A_ 0 _N_ _N_ _N_ _N_ _N_ }, [ (Ratio Integer) ] 1 { _A_ 0 _N_ _N_ _N_ _F_ _IF_ARGS_ 0 0 X 3 _!_ (:%) [Integer] [_SPEC_ _ORIG_ PreludeCore __i1 [ (Integer) ], _SPEC_ _ORIG_ PreludeCore __i2 [ (Integer) ]] _N_ }, [ (Complex Double) ] 1 { _A_ 0 _N_ _N_ _N_ _N_ _N_ } #-}
+_fromRational :: RealFloat a => Ratio Integer -> a
+ {-# GHC_PRAGMA _A_ 2 _U_ 22 _N_ _N_ _N_ _SPECIALISE_ [ Double ] 1 { _A_ 1 _U_ 1 _N_ _S_ "U(U(PPP)U(PPP))" {_A_ 4 _U_ 2221 _N_ _N_ _N_ _N_} _N_ _N_ } #-}
instance Enum ()
{-# GHC_PRAGMA _M_ PreludeBuiltin {-dfun-} _A_ 0 _N_ _N_ _N_ _F_ _IF_ARGS_ 0 0 X 6 _!_ _TUP_5 [{{Ord ()}}, (() -> [()]), (() -> () -> [()]), (() -> () -> [()]), (() -> () -> () -> [()])] [_DFUN_ Ord (()), _CONSTM_ Enum enumFrom (()), _CONSTM_ Enum enumFromThen (()), _CONSTM_ Enum enumFromTo (()), _CONSTM_ Enum enumFromThenTo (())] _N_
- enumFrom = _A_ 1 _U_ 2 _N_ _S_ "E" _N_ _N_,
- enumFromThen = _A_ 2 _U_ 21 _N_ _S_ "EE" _F_ _IF_ARGS_ 0 2 CC 7 \ (u0 :: ()) (u1 :: ()) -> case u0 of { _ALG_ _TUP_0 -> case u1 of { _ALG_ _TUP_0 -> let {(u2 :: [()]) = _!_ _NIL_ [()] []} in _!_ (:) [()] [u0, u2]; _NO_DEFLT_ }; _NO_DEFLT_ } _N_,
- enumFromTo = _A_ 2 _U_ 21 _N_ _S_ "EE" _F_ _IF_ARGS_ 0 2 CC 7 \ (u0 :: ()) (u1 :: ()) -> case u0 of { _ALG_ _TUP_0 -> case u1 of { _ALG_ _TUP_0 -> let {(u2 :: [()]) = _!_ _NIL_ [()] []} in _!_ (:) [()] [u0, u2]; _NO_DEFLT_ }; _NO_DEFLT_ } _N_,
- enumFromThenTo = _A_ 3 _U_ 211 _N_ _S_ "EEE" _F_ _IF_ARGS_ 0 3 CCC 8 \ (u0 :: ()) (u1 :: ()) (u2 :: ()) -> case u0 of { _ALG_ _TUP_0 -> case u1 of { _ALG_ _TUP_0 -> case u2 of { _ALG_ _TUP_0 -> let {(u3 :: [()]) = _!_ _NIL_ [()] []} in _!_ (:) [()] [u0, u3]; _NO_DEFLT_ }; _NO_DEFLT_ }; _NO_DEFLT_ } _N_ #-}
+ enumFrom = { _A_ 1 _U_ 2 _N_ _S_ "E" _N_ _N_ },
+ enumFromThen = { _A_ 2 _U_ 21 _N_ _S_ "EE" _F_ _IF_ARGS_ 0 2 CC 7 \ (u0 :: ()) (u1 :: ()) -> case u0 of { _ALG_ _TUP_0 -> case u1 of { _ALG_ _TUP_0 -> let {(u2 :: [()]) = _!_ _NIL_ [()] []} in _!_ (:) [()] [u0, u2]; _NO_DEFLT_ }; _NO_DEFLT_ } _N_ },
+ enumFromTo = { _A_ 2 _U_ 21 _N_ _S_ "EE" _F_ _IF_ARGS_ 0 2 CC 7 \ (u0 :: ()) (u1 :: ()) -> case u0 of { _ALG_ _TUP_0 -> case u1 of { _ALG_ _TUP_0 -> let {(u2 :: [()]) = _!_ _NIL_ [()] []} in _!_ (:) [()] [u0, u2]; _NO_DEFLT_ }; _NO_DEFLT_ } _N_ },
+ enumFromThenTo = { _A_ 3 _U_ 211 _N_ _S_ "EEE" _F_ _IF_ARGS_ 0 3 CCC 8 \ (u0 :: ()) (u1 :: ()) (u2 :: ()) -> case u0 of { _ALG_ _TUP_0 -> case u1 of { _ALG_ _TUP_0 -> case u2 of { _ALG_ _TUP_0 -> let {(u3 :: [()]) = _!_ _NIL_ [()] []} in _!_ (:) [()] [u0, u3]; _NO_DEFLT_ }; _NO_DEFLT_ }; _NO_DEFLT_ } _N_ } #-}
instance Enum Bool
{-# GHC_PRAGMA _M_ PreludeCore {-dfun-} _A_ 0 _N_ _N_ _N_ _F_ _IF_ARGS_ 0 0 X 6 _!_ _TUP_5 [{{Ord Bool}}, (Bool -> [Bool]), (Bool -> Bool -> [Bool]), (Bool -> Bool -> [Bool]), (Bool -> Bool -> Bool -> [Bool])] [_DFUN_ Ord (Bool), _CONSTM_ Enum enumFrom (Bool), _CONSTM_ Enum enumFromThen (Bool), _CONSTM_ Enum enumFromTo (Bool), _CONSTM_ Enum enumFromThenTo (Bool)] _N_
- enumFrom = _A_ 1 _U_ 2 _N_ _S_ "E" _N_ _N_,
- enumFromThen = _A_ 2 _U_ 22 _N_ _S_ "EE" _N_ _N_,
- enumFromTo = _A_ 2 _U_ 22 _N_ _N_ _N_ _N_,
- enumFromThenTo = _A_ 3 _U_ 222 _N_ _N_ _N_ _N_ #-}
+ enumFrom = { _A_ 1 _U_ 2 _N_ _S_ "E" _N_ _N_ },
+ enumFromThen = { _A_ 2 _U_ 22 _N_ _S_ "EE" _N_ _N_ },
+ enumFromTo = { _A_ 2 _U_ 22 _N_ _S_ "EL" _N_ _N_ },
+ enumFromThenTo = { _A_ 3 _U_ 222 _N_ _S_ "EEL" _N_ _N_ } #-}
instance Enum Char
{-# GHC_PRAGMA _M_ PreludeCore {-dfun-} _A_ 0 _N_ _N_ _N_ _F_ _IF_ARGS_ 0 0 X 6 _!_ _TUP_5 [{{Ord Char}}, (Char -> [Char]), (Char -> Char -> [Char]), (Char -> Char -> [Char]), (Char -> Char -> Char -> [Char])] [_DFUN_ Ord (Char), _CONSTM_ Enum enumFrom (Char), _CONSTM_ Enum enumFromThen (Char), _CONSTM_ Enum enumFromTo (Char), _CONSTM_ Enum enumFromThenTo (Char)] _N_
- enumFrom = _A_ 1 _U_ 1 _N_ _S_ "U(P)" {_A_ 1 _U_ 2 _N_ _N_ _N_ _N_} _N_ _N_,
- enumFromThen = _A_ 2 _U_ 22 _N_ _N_ _N_ _N_,
- enumFromTo = _A_ 2 _U_ 22 _N_ _N_ _N_ _N_,
- enumFromThenTo = _A_ 3 _U_ 222 _N_ _N_ _N_ _N_ #-}
+ enumFrom = { _A_ 1 _U_ 1 _N_ _S_ "U(P)" {_A_ 1 _U_ 2 _N_ _N_ _N_ _N_} _N_ _N_ },
+ enumFromThen = { _A_ 2 _U_ 22 _N_ _N_ _N_ _N_ },
+ enumFromTo = { _A_ 2 _U_ 12 _N_ _S_ "U(P)L" {_A_ 2 _U_ 22 _N_ _N_ _N_ _N_} _N_ _N_ },
+ enumFromThenTo = { _A_ 3 _U_ 222 _N_ _N_ _N_ _N_ } #-}
instance Enum Double
{-# GHC_PRAGMA _M_ PreludeCore {-dfun-} _A_ 0 _N_ _N_ _N_ _F_ _IF_ARGS_ 0 0 X 6 _!_ _TUP_5 [{{Ord Double}}, (Double -> [Double]), (Double -> Double -> [Double]), (Double -> Double -> [Double]), (Double -> Double -> Double -> [Double])] [_DFUN_ Ord (Double), _CONSTM_ Enum enumFrom (Double), _CONSTM_ Enum enumFromThen (Double), _CONSTM_ Enum enumFromTo (Double), _CONSTM_ Enum enumFromThenTo (Double)] _N_
- enumFrom = _A_ 1 _U_ 2 _N_ _N_ _N_ _N_,
- enumFromThen = _A_ 2 _U_ 21 _N_ _N_ _N_ _N_,
- enumFromTo = _A_ 2 _U_ 22 _N_ _N_ _N_ _N_,
- enumFromThenTo = _A_ 3 _U_ 222 _N_ _N_ _N_ _N_ #-}
+ enumFrom = { _A_ 1 _U_ 2 _N_ _N_ _N_ _N_ },
+ enumFromThen = { _A_ 2 _U_ 21 _N_ _N_ _N_ _N_ },
+ enumFromTo = { _A_ 2 _U_ 22 _N_ _N_ _N_ _N_ },
+ enumFromThenTo = { _A_ 3 _U_ 222 _N_ _N_ _N_ _N_ } #-}
instance Enum Float
{-# GHC_PRAGMA _M_ PreludeCore {-dfun-} _A_ 0 _N_ _N_ _N_ _F_ _IF_ARGS_ 0 0 X 6 _!_ _TUP_5 [{{Ord Float}}, (Float -> [Float]), (Float -> Float -> [Float]), (Float -> Float -> [Float]), (Float -> Float -> Float -> [Float])] [_DFUN_ Ord (Float), _CONSTM_ Enum enumFrom (Float), _CONSTM_ Enum enumFromThen (Float), _CONSTM_ Enum enumFromTo (Float), _CONSTM_ Enum enumFromThenTo (Float)] _N_
- enumFrom = _A_ 1 _U_ 2 _N_ _N_ _N_ _N_,
- enumFromThen = _A_ 2 _U_ 21 _N_ _N_ _N_ _N_,
- enumFromTo = _A_ 2 _U_ 22 _N_ _N_ _N_ _N_,
- enumFromThenTo = _A_ 3 _U_ 222 _N_ _N_ _N_ _N_ #-}
+ enumFrom = { _A_ 1 _U_ 2 _N_ _N_ _N_ _N_ },
+ enumFromThen = { _A_ 2 _U_ 21 _N_ _N_ _N_ _N_ },
+ enumFromTo = { _A_ 2 _U_ 22 _N_ _N_ _N_ _N_ },
+ enumFromThenTo = { _A_ 3 _U_ 222 _N_ _N_ _N_ _N_ } #-}
instance Enum Int
{-# GHC_PRAGMA _M_ PreludeCore {-dfun-} _A_ 0 _N_ _N_ _N_ _F_ _IF_ARGS_ 0 0 X 6 _!_ _TUP_5 [{{Ord Int}}, (Int -> [Int]), (Int -> Int -> [Int]), (Int -> Int -> [Int]), (Int -> Int -> Int -> [Int])] [_DFUN_ Ord (Int), _CONSTM_ Enum enumFrom (Int), _CONSTM_ Enum enumFromThen (Int), _CONSTM_ Enum enumFromTo (Int), _CONSTM_ Enum enumFromThenTo (Int)] _N_
- enumFrom = _A_ 1 _U_ 2 _N_ _N_ _F_ _ALWAYS_ \ (u0 :: Int) -> _LETREC_ {(u1 :: Int -> [Int]) = \ (u2 :: Int) -> let {(u6 :: [Int]) = let {(u5 :: Int) = case u2 of { _ALG_ I# (u3 :: Int#) -> case _#_ plusInt# [] [u3, 1#] of { _PRIM_ (u4 :: Int#) -> _!_ I# [] [u4] }; _NO_DEFLT_ }} in _APP_ u1 [ u5 ]} in _!_ (:) [Int] [u2, u6]} in _APP_ u1 [ u0 ] _N_,
- enumFromThen = _A_ 2 _U_ 21 _N_ _N_ _N_ _N_,
- enumFromTo = _A_ 2 _U_ 12 _N_ _S_ "SS" _F_ _ALWAYS_ \ (u0 :: Int) (u1 :: Int) -> case u0 of { _ALG_ I# (u2 :: Int#) -> _LETREC_ {(u3 :: Int# -> [Int]) = \ (u4 :: Int#) -> case u1 of { _ALG_ I# (u5 :: Int#) -> case _#_ leInt# [] [u4, u5] of { _ALG_ True -> let {(u7 :: [Int]) = case _#_ plusInt# [] [u4, 1#] of { _PRIM_ (u6 :: Int#) -> _APP_ u3 [ u6 ] }} in let {(u8 :: Int) = _!_ I# [] [u4]} in _!_ (:) [Int] [u8, u7]; False -> _!_ _NIL_ [Int] []; _NO_DEFLT_ }; _NO_DEFLT_ }} in _APP_ u3 [ u2 ]; _NO_DEFLT_ } _N_,
- enumFromThenTo = _A_ 3 _U_ 222 _N_ _N_ _N_ _N_ #-}
+ enumFrom = { _A_ 1 _U_ 2 _N_ _N_ _F_ _ALWAYS_ \ (u0 :: Int) -> _LETREC_ {(u1 :: Int -> [Int]) = \ (u2 :: Int) -> let {(u6 :: [Int]) = let {(u5 :: Int) = case u2 of { _ALG_ I# (u3 :: Int#) -> case _#_ plusInt# [] [u3, 1#] of { _PRIM_ (u4 :: Int#) -> _!_ I# [] [u4] }; _NO_DEFLT_ }} in _APP_ u1 [ u5 ]} in _!_ (:) [Int] [u2, u6]} in _APP_ u1 [ u0 ] _N_ },
+ enumFromThen = { _A_ 2 _U_ 21 _N_ _N_ _N_ _N_ },
+ enumFromTo = { _A_ 2 _U_ 12 _N_ _S_ "SS" _F_ _ALWAYS_ \ (u0 :: Int) (u1 :: Int) -> case u0 of { _ALG_ I# (u2 :: Int#) -> _LETREC_ {(u3 :: Int# -> [Int]) = \ (u4 :: Int#) -> case u1 of { _ALG_ I# (u5 :: Int#) -> case _#_ leInt# [] [u4, u5] of { _ALG_ True -> let {(u7 :: [Int]) = case _#_ plusInt# [] [u4, 1#] of { _PRIM_ (u6 :: Int#) -> _APP_ u3 [ u6 ] }} in let {(u8 :: Int) = _!_ I# [] [u4]} in _!_ (:) [Int] [u8, u7]; False -> _!_ _NIL_ [Int] []; _NO_DEFLT_ }; _NO_DEFLT_ }} in _APP_ u3 [ u2 ]; _NO_DEFLT_ } _N_ },
+ enumFromThenTo = { _A_ 3 _U_ 222 _N_ _N_ _N_ _N_ } #-}
instance Enum Integer
{-# GHC_PRAGMA _M_ PreludeCore {-dfun-} _A_ 0 _N_ _N_ _N_ _F_ _IF_ARGS_ 0 0 X 6 _!_ _TUP_5 [{{Ord Integer}}, (Integer -> [Integer]), (Integer -> Integer -> [Integer]), (Integer -> Integer -> [Integer]), (Integer -> Integer -> Integer -> [Integer])] [_DFUN_ Ord (Integer), _CONSTM_ Enum enumFrom (Integer), _CONSTM_ Enum enumFromThen (Integer), _CONSTM_ Enum enumFromTo (Integer), _CONSTM_ Enum enumFromThenTo (Integer)] _N_
- enumFrom = _A_ 1 _U_ 2 _N_ _N_ _N_ _N_,
- enumFromThen = _A_ 2 _U_ 21 _N_ _N_ _N_ _N_,
- enumFromTo = _A_ 2 _U_ 22 _N_ _N_ _N_ _N_,
- enumFromThenTo = _A_ 3 _U_ 222 _N_ _N_ _N_ _N_ #-}
+ enumFrom = { _A_ 1 _U_ 2 _N_ _N_ _N_ _N_ },
+ enumFromThen = { _A_ 2 _U_ 21 _N_ _N_ _N_ _N_ },
+ enumFromTo = { _A_ 2 _U_ 22 _N_ _N_ _N_ _N_ },
+ enumFromThenTo = { _A_ 3 _U_ 222 _N_ _N_ _N_ _N_ } #-}
instance Integral a => Enum (Ratio a)
{-# GHC_PRAGMA _M_ PreludeRatio {-dfun-} _A_ 2 _U_ 22 _N_ _N_ _N_ _N_ #-}
instance Enum (Ratio Integer)
{-# GHC_PRAGMA _M_ PreludeRatio {-dfun-} _A_ 0 _N_ _N_ _N_ _F_ _IF_ARGS_ 0 0 X 6 _!_ _TUP_5 [{{Ord (Ratio Integer)}}, (Ratio Integer -> [Ratio Integer]), (Ratio Integer -> Ratio Integer -> [Ratio Integer]), (Ratio Integer -> Ratio Integer -> [Ratio Integer]), (Ratio Integer -> Ratio Integer -> Ratio Integer -> [Ratio Integer])] [_DFUN_ Ord (Ratio Integer), _CONSTM_ Enum enumFrom (Ratio Integer), _CONSTM_ Enum enumFromThen (Ratio Integer), _CONSTM_ Enum enumFromTo (Ratio Integer), _CONSTM_ Enum enumFromThenTo (Ratio Integer)] _N_
- enumFrom = _A_ 1 _U_ 2 _N_ _N_ _N_ _N_,
- enumFromThen = _A_ 2 _U_ 21 _N_ _N_ _N_ _N_,
- enumFromTo = _A_ 2 _U_ 22 _N_ _N_ _N_ _N_,
- enumFromThenTo = _A_ 3 _U_ 222 _N_ _N_ _N_ _N_ #-}
+ enumFrom = { _A_ 1 _U_ 2 _N_ _N_ _N_ _N_ },
+ enumFromThen = { _A_ 2 _U_ 21 _N_ _N_ _N_ _N_ },
+ enumFromTo = { _A_ 2 _U_ 22 _N_ _N_ _N_ _N_ },
+ enumFromThenTo = { _A_ 3 _U_ 222 _N_ _N_ _N_ _N_ } #-}
instance Eq ()
{-# GHC_PRAGMA _M_ PreludeBuiltin {-dfun-} _A_ 0 _N_ _N_ _N_ _F_ _IF_ARGS_ 0 0 X 3 _!_ _TUP_2 [(() -> () -> Bool), (() -> () -> Bool)] [_CONSTM_ Eq (==) (()), _CONSTM_ Eq (/=) (())] _N_
- (==) = _A_ 2 _U_ 11 _N_ _S_ "EE" _F_ _IF_ARGS_ 0 2 CC 3 \ (u0 :: ()) (u1 :: ()) -> case u0 of { _ALG_ _TUP_0 -> case u1 of { _ALG_ _TUP_0 -> _!_ True [] []; _NO_DEFLT_ }; _NO_DEFLT_ } _N_,
- (/=) = _A_ 2 _U_ 11 _N_ _S_ "EE" _F_ _IF_ARGS_ 0 2 CC 3 \ (u0 :: ()) (u1 :: ()) -> case u0 of { _ALG_ _TUP_0 -> case u1 of { _ALG_ _TUP_0 -> _!_ False [] []; _NO_DEFLT_ }; _NO_DEFLT_ } _N_ #-}
+ (==) = { _A_ 2 _U_ 11 _N_ _S_ "EE" _F_ _IF_ARGS_ 0 2 CC 3 \ (u0 :: ()) (u1 :: ()) -> case u0 of { _ALG_ _TUP_0 -> case u1 of { _ALG_ _TUP_0 -> _!_ True [] []; _NO_DEFLT_ }; _NO_DEFLT_ } _N_ },
+ (/=) = { _A_ 2 _U_ 11 _N_ _S_ "EE" _F_ _IF_ARGS_ 0 2 CC 3 \ (u0 :: ()) (u1 :: ()) -> case u0 of { _ALG_ _TUP_0 -> case u1 of { _ALG_ _TUP_0 -> _!_ False [] []; _NO_DEFLT_ }; _NO_DEFLT_ } _N_ } #-}
instance (Eq a, Eq b) => Eq (a, b)
- {-# GHC_PRAGMA _M_ PreludeBuiltin {-dfun-} _A_ 2 _U_ 11 _N_ _N_ _N_ _N_ #-}
+ {-# GHC_PRAGMA _M_ PreludeBuiltin {-dfun-} _A_ 2 _U_ 22 _N_ _N_ _N_ _N_ #-}
instance (Eq a, Eq b, Eq c) => Eq (a, b, c)
{-# GHC_PRAGMA _M_ PreludeBuiltin {-dfun-} _A_ 3 _U_ 111 _N_ _N_ _N_ _N_ #-}
instance (Eq a, Eq b, Eq c, Eq d) => Eq (a, b, c, d)
{-# GHC_PRAGMA _M_ PreludeBuiltin {-dfun-} _A_ 5 _U_ 11111 _N_ _N_ _N_ _N_ #-}
instance Eq (Int, Int)
{-# GHC_PRAGMA _M_ PreludeBuiltin {-dfun-} _A_ 0 _N_ _N_ _N_ _F_ _IF_ARGS_ 0 0 X 3 _!_ _TUP_2 [((Int, Int) -> (Int, Int) -> Bool), ((Int, Int) -> (Int, Int) -> Bool)] [_CONSTM_ Eq (==) ((Int, Int)), _CONSTM_ Eq (/=) ((Int, Int))] _N_
- (==) = _A_ 2 _U_ 11 _N_ _S_ "U(U(P)L)U(U(P)L)" {_A_ 4 _U_ 2121 _N_ _N_ _F_ _IF_ARGS_ 0 4 XCXC 7 \ (u0 :: Int#) (u1 :: Int) (u2 :: Int#) (u3 :: Int) -> case _#_ eqInt# [] [u0, u2] of { _ALG_ True -> case u1 of { _ALG_ I# (u4 :: Int#) -> case u3 of { _ALG_ I# (u5 :: Int#) -> _#_ eqInt# [] [u4, u5]; _NO_DEFLT_ }; _NO_DEFLT_ }; False -> _!_ False [] []; _NO_DEFLT_ } _N_} _F_ _ALWAYS_ \ (u0 :: (Int, Int)) (u1 :: (Int, Int)) -> case u0 of { _ALG_ _TUP_2 (u2 :: Int) (u3 :: Int) -> case u2 of { _ALG_ I# (u4 :: Int#) -> case u1 of { _ALG_ _TUP_2 (u5 :: Int) (u6 :: Int) -> case u5 of { _ALG_ I# (u7 :: Int#) -> case _#_ eqInt# [] [u4, u7] of { _ALG_ True -> case u3 of { _ALG_ I# (u8 :: Int#) -> case u6 of { _ALG_ I# (u9 :: Int#) -> _#_ eqInt# [] [u8, u9]; _NO_DEFLT_ }; _NO_DEFLT_ }; False -> _!_ False [] []; _NO_DEFLT_ }; _NO_DEFLT_ }; _NO_DEFLT_ }; _NO_DEFLT_ }; _NO_DEFLT_ } _N_,
- (/=) = _A_ 2 _U_ 22 _N_ _N_ _N_ _N_ #-}
+ (==) = { _A_ 2 _U_ 11 _N_ _S_ "U(U(P)L)U(U(P)L)" {_A_ 4 _U_ 2121 _N_ _N_ _F_ _IF_ARGS_ 0 4 XCXC 7 \ (u0 :: Int#) (u1 :: Int) (u2 :: Int#) (u3 :: Int) -> case _#_ eqInt# [] [u0, u2] of { _ALG_ True -> case u1 of { _ALG_ I# (u4 :: Int#) -> case u3 of { _ALG_ I# (u5 :: Int#) -> _#_ eqInt# [] [u4, u5]; _NO_DEFLT_ }; _NO_DEFLT_ }; False -> _!_ False [] []; _NO_DEFLT_ } _N_} _F_ _ALWAYS_ \ (u0 :: (Int, Int)) (u1 :: (Int, Int)) -> case u0 of { _ALG_ _TUP_2 (u2 :: Int) (u3 :: Int) -> case u2 of { _ALG_ I# (u4 :: Int#) -> case u1 of { _ALG_ _TUP_2 (u5 :: Int) (u6 :: Int) -> case u5 of { _ALG_ I# (u7 :: Int#) -> case _#_ eqInt# [] [u4, u7] of { _ALG_ True -> case u3 of { _ALG_ I# (u8 :: Int#) -> case u6 of { _ALG_ I# (u9 :: Int#) -> _#_ eqInt# [] [u8, u9]; _NO_DEFLT_ }; _NO_DEFLT_ }; False -> _!_ False [] []; _NO_DEFLT_ }; _NO_DEFLT_ }; _NO_DEFLT_ }; _NO_DEFLT_ }; _NO_DEFLT_ } _N_ },
+ (/=) = { _A_ 2 _U_ 11 _N_ _S_ "U(U(P)L)U(U(P)L)" {_A_ 4 _U_ 2121 _N_ _N_ _F_ _IF_ARGS_ 0 4 XCXC 7 \ (u0 :: Int#) (u1 :: Int) (u2 :: Int#) (u3 :: Int) -> case _#_ neInt# [] [u0, u2] of { _ALG_ True -> _!_ True [] []; False -> case u1 of { _ALG_ I# (u4 :: Int#) -> case u3 of { _ALG_ I# (u5 :: Int#) -> _#_ neInt# [] [u4, u5]; _NO_DEFLT_ }; _NO_DEFLT_ }; _NO_DEFLT_ } _N_} _F_ _ALWAYS_ \ (u0 :: (Int, Int)) (u1 :: (Int, Int)) -> case u0 of { _ALG_ _TUP_2 (u2 :: Int) (u3 :: Int) -> case u2 of { _ALG_ I# (u4 :: Int#) -> case u1 of { _ALG_ _TUP_2 (u5 :: Int) (u6 :: Int) -> case u5 of { _ALG_ I# (u7 :: Int#) -> case _#_ neInt# [] [u4, u7] of { _ALG_ True -> _!_ True [] []; False -> case u3 of { _ALG_ I# (u8 :: Int#) -> case u6 of { _ALG_ I# (u9 :: Int#) -> _#_ neInt# [] [u8, u9]; _NO_DEFLT_ }; _NO_DEFLT_ }; _NO_DEFLT_ }; _NO_DEFLT_ }; _NO_DEFLT_ }; _NO_DEFLT_ }; _NO_DEFLT_ } _N_ } #-}
+instance Eq (Int, Int, Int)
+ {-# GHC_PRAGMA _M_ PreludeBuiltin {-dfun-} _A_ 0 _N_ _N_ _N_ _F_ _IF_ARGS_ 0 0 X 3 _!_ _TUP_2 [((Int, Int, Int) -> (Int, Int, Int) -> Bool), ((Int, Int, Int) -> (Int, Int, Int) -> Bool)] [_CONSTM_ Eq (==) ((Int, Int, Int)), _CONSTM_ Eq (/=) ((Int, Int, Int))] _N_
+ (==) = { _A_ 2 _U_ 11 _N_ _S_ "U(U(P)LL)U(U(P)LL)" {_A_ 4 _U_ 2111 _N_ _N_ _N_ _N_} _N_ _N_ },
+ (/=) = { _A_ 2 _U_ 11 _N_ _S_ "U(U(P)LL)U(U(P)LL)" {_A_ 4 _U_ 2111 _N_ _N_ _N_ _N_} _N_ _N_ } #-}
+instance Eq (Int, Int, Int, Int)
+ {-# GHC_PRAGMA _M_ PreludeBuiltin {-dfun-} _A_ 0 _N_ _N_ _N_ _F_ _IF_ARGS_ 0 0 X 3 _!_ _TUP_2 [((Int, Int, Int, Int) -> (Int, Int, Int, Int) -> Bool), ((Int, Int, Int, Int) -> (Int, Int, Int, Int) -> Bool)] [_CONSTM_ Eq (==) ((Int, Int, Int, Int)), _CONSTM_ Eq (/=) ((Int, Int, Int, Int))] _N_
+ (==) = { _A_ 2 _U_ 11 _N_ _S_ "U(U(P)LLL)U(U(P)LLL)" {_A_ 5 _U_ 21111 _N_ _N_ _N_ _N_} _N_ _N_ },
+ (/=) = { _A_ 2 _U_ 11 _N_ _S_ "U(U(P)LLL)U(U(P)LLL)" {_A_ 5 _U_ 21111 _N_ _N_ _N_ _N_} _N_ _N_ } #-}
+instance Eq (Int, Int, Int, Int, Int)
+ {-# GHC_PRAGMA _M_ PreludeBuiltin {-dfun-} _A_ 0 _N_ _N_ _N_ _F_ _IF_ARGS_ 0 0 X 3 _!_ _TUP_2 [((Int, Int, Int, Int, Int) -> (Int, Int, Int, Int, Int) -> Bool), ((Int, Int, Int, Int, Int) -> (Int, Int, Int, Int, Int) -> Bool)] [_CONSTM_ Eq (==) ((Int, Int, Int, Int, Int)), _CONSTM_ Eq (/=) ((Int, Int, Int, Int, Int))] _N_
+ (==) = { _A_ 2 _U_ 11 _N_ _S_ "U(U(P)LLLL)U(U(P)LLLL)" _N_ _N_ },
+ (/=) = { _A_ 2 _U_ 11 _N_ _S_ "U(U(P)LLLL)U(U(P)LLLL)" _N_ _N_ } #-}
+instance Eq ([Char], [Char])
+ {-# GHC_PRAGMA _M_ PreludeBuiltin {-dfun-} _A_ 0 _N_ _N_ _N_ _F_ _IF_ARGS_ 0 0 X 3 _!_ _TUP_2 [(([Char], [Char]) -> ([Char], [Char]) -> Bool), (([Char], [Char]) -> ([Char], [Char]) -> Bool)] [_CONSTM_ Eq (==) (([Char], [Char])), _CONSTM_ Eq (/=) (([Char], [Char]))] _N_
+ (==) = { _A_ 2 _U_ 11 _N_ _S_ "U(SL)U(SL)" {_A_ 4 _U_ 2222 _N_ _N_ _N_ _N_} _N_ _N_ },
+ (/=) = { _A_ 2 _U_ 11 _N_ _S_ "U(SL)U(SL)" {_A_ 4 _U_ 2222 _N_ _N_ _N_ _N_} _N_ _N_ } #-}
+instance Eq ([Int], [Int])
+ {-# GHC_PRAGMA _M_ PreludeBuiltin {-dfun-} _A_ 0 _N_ _N_ _N_ _F_ _IF_ARGS_ 0 0 X 3 _!_ _TUP_2 [(([Int], [Int]) -> ([Int], [Int]) -> Bool), (([Int], [Int]) -> ([Int], [Int]) -> Bool)] [_CONSTM_ Eq (==) (([Int], [Int])), _CONSTM_ Eq (/=) (([Int], [Int]))] _N_
+ (==) = { _A_ 2 _U_ 11 _N_ _S_ "U(SL)U(SL)" {_A_ 4 _U_ 2222 _N_ _N_ _N_ _N_} _N_ _N_ },
+ (/=) = { _A_ 2 _U_ 11 _N_ _S_ "U(SL)U(SL)" {_A_ 4 _U_ 2222 _N_ _N_ _N_ _N_} _N_ _N_ } #-}
instance Eq (_PackedString, _PackedString)
{-# GHC_PRAGMA _M_ PreludeBuiltin {-dfun-} _A_ 0 _N_ _N_ _N_ _F_ _IF_ARGS_ 0 0 X 3 _!_ _TUP_2 [((_PackedString, _PackedString) -> (_PackedString, _PackedString) -> Bool), ((_PackedString, _PackedString) -> (_PackedString, _PackedString) -> Bool)] [_CONSTM_ Eq (==) ((_PackedString, _PackedString)), _CONSTM_ Eq (/=) ((_PackedString, _PackedString))] _N_
- (==) = _A_ 2 _U_ 11 _N_ _S_ "U(SL)U(SL)" {_A_ 4 _U_ 2222 _N_ _N_ _N_ _N_} _N_ _N_,
- (/=) = _A_ 2 _U_ 22 _N_ _N_ _N_ _N_ #-}
+ (==) = { _A_ 2 _U_ 11 _N_ _S_ "U(SL)U(SL)" {_A_ 4 _U_ 2222 _N_ _N_ _N_ _N_} _N_ _N_ },
+ (/=) = { _A_ 2 _U_ 11 _N_ _S_ "U(SL)U(SL)" {_A_ 4 _U_ 2222 _N_ _N_ _N_ _N_} _N_ _N_ } #-}
instance (Ix a, Eq b) => Eq (Array a b)
{-# GHC_PRAGMA _M_ PreludeArray {-dfun-} _A_ 2 _U_ 21 _N_ _N_ _N_ _N_ #-}
instance (Eq a, Eq b) => Eq (Assoc a b)
{-# GHC_PRAGMA _M_ PreludeArray {-dfun-} _A_ 2 _U_ 11 _N_ _N_ _N_ _N_ #-}
instance Eq Bool
{-# GHC_PRAGMA _M_ PreludeCore {-dfun-} _A_ 0 _N_ _N_ _N_ _F_ _IF_ARGS_ 0 0 X 3 _!_ _TUP_2 [(Bool -> Bool -> Bool), (Bool -> Bool -> Bool)] [_CONSTM_ Eq (==) (Bool), _CONSTM_ Eq (/=) (Bool)] _N_
- (==) = _A_ 2 _U_ 11 _N_ _S_ "EE" _F_ _IF_ARGS_ 0 2 CC 7 \ (u0 :: Bool) (u1 :: Bool) -> case u0 of { _ALG_ True -> u1; False -> case u1 of { _ALG_ True -> _!_ False [] []; False -> _!_ True [] []; _NO_DEFLT_ }; _NO_DEFLT_ } _N_,
- (/=) = _A_ 2 _U_ 11 _N_ _S_ "EE" _F_ _IF_ARGS_ 0 2 CC 7 \ (u0 :: Bool) (u1 :: Bool) -> case u0 of { _ALG_ True -> case u1 of { _ALG_ True -> _!_ False [] []; False -> _!_ True [] []; _NO_DEFLT_ }; False -> u1; _NO_DEFLT_ } _N_ #-}
+ (==) = { _A_ 2 _U_ 11 _N_ _S_ "EE" _F_ _IF_ARGS_ 0 2 CC 7 \ (u0 :: Bool) (u1 :: Bool) -> case u0 of { _ALG_ True -> u1; False -> case u1 of { _ALG_ True -> _!_ False [] []; False -> _!_ True [] []; _NO_DEFLT_ }; _NO_DEFLT_ } _N_ },
+ (/=) = { _A_ 2 _U_ 11 _N_ _S_ "EE" _F_ _IF_ARGS_ 0 2 CC 7 \ (u0 :: Bool) (u1 :: Bool) -> case u0 of { _ALG_ True -> case u1 of { _ALG_ True -> _!_ False [] []; False -> _!_ True [] []; _NO_DEFLT_ }; False -> u1; _NO_DEFLT_ } _N_ } #-}
instance Eq Char
{-# GHC_PRAGMA _M_ PreludeCore {-dfun-} _A_ 0 _N_ _N_ _N_ _F_ _IF_ARGS_ 0 0 X 3 _!_ _TUP_2 [(Char -> Char -> Bool), (Char -> Char -> Bool)] [_CONSTM_ Eq (==) (Char), _CONSTM_ Eq (/=) (Char)] _N_
- (==) = _A_ 2 _U_ 11 _N_ _S_ "U(P)U(P)" {_A_ 2 _U_ 22 _N_ _N_ _F_ _IF_ARGS_ 0 2 XX 1 \ (u0 :: Char#) (u1 :: Char#) -> _#_ eqChar# [] [u0, u1] _N_} _F_ _IF_ARGS_ 0 2 CC 3 \ (u0 :: Char) (u1 :: Char) -> case u0 of { _ALG_ C# (u2 :: Char#) -> case u1 of { _ALG_ C# (u3 :: Char#) -> _#_ eqChar# [] [u2, u3]; _NO_DEFLT_ }; _NO_DEFLT_ } _N_,
- (/=) = _A_ 2 _U_ 11 _N_ _S_ "U(P)U(P)" {_A_ 2 _U_ 22 _N_ _N_ _F_ _IF_ARGS_ 0 2 XX 1 \ (u0 :: Char#) (u1 :: Char#) -> _#_ neChar# [] [u0, u1] _N_} _F_ _IF_ARGS_ 0 2 CC 3 \ (u0 :: Char) (u1 :: Char) -> case u0 of { _ALG_ C# (u2 :: Char#) -> case u1 of { _ALG_ C# (u3 :: Char#) -> _#_ neChar# [] [u2, u3]; _NO_DEFLT_ }; _NO_DEFLT_ } _N_ #-}
+ (==) = { _A_ 2 _U_ 11 _N_ _S_ "U(P)U(P)" {_A_ 2 _U_ 22 _N_ _N_ _F_ _IF_ARGS_ 0 2 XX 1 \ (u0 :: Char#) (u1 :: Char#) -> _#_ eqChar# [] [u0, u1] _N_} _F_ _IF_ARGS_ 0 2 CC 3 \ (u0 :: Char) (u1 :: Char) -> case u0 of { _ALG_ C# (u2 :: Char#) -> case u1 of { _ALG_ C# (u3 :: Char#) -> _#_ eqChar# [] [u2, u3]; _NO_DEFLT_ }; _NO_DEFLT_ } _N_ },
+ (/=) = { _A_ 2 _U_ 11 _N_ _S_ "U(P)U(P)" {_A_ 2 _U_ 22 _N_ _N_ _F_ _IF_ARGS_ 0 2 XX 1 \ (u0 :: Char#) (u1 :: Char#) -> _#_ neChar# [] [u0, u1] _N_} _F_ _IF_ARGS_ 0 2 CC 3 \ (u0 :: Char) (u1 :: Char) -> case u0 of { _ALG_ C# (u2 :: Char#) -> case u1 of { _ALG_ C# (u3 :: Char#) -> _#_ neChar# [] [u2, u3]; _NO_DEFLT_ }; _NO_DEFLT_ } _N_ } #-}
instance Eq a => Eq (Complex a)
{-# GHC_PRAGMA _M_ PreludeComplex {-dfun-} _A_ 1 _U_ 2 _N_ _N_ _N_ _N_ #-}
instance Eq (Complex Double)
{-# GHC_PRAGMA _M_ PreludeComplex {-dfun-} _A_ 0 _N_ _N_ _N_ _F_ _IF_ARGS_ 0 0 X 3 _!_ _TUP_2 [(Complex Double -> Complex Double -> Bool), (Complex Double -> Complex Double -> Bool)] [_CONSTM_ Eq (==) (Complex Double), _CONSTM_ Eq (/=) (Complex Double)] _N_
- (==) = _A_ 2 _U_ 11 _N_ _S_ "U(U(P)L)U(U(P)L)" {_A_ 4 _U_ 2121 _N_ _N_ _F_ _IF_ARGS_ 0 4 XCXC 7 \ (u0 :: Double#) (u1 :: Double) (u2 :: Double#) (u3 :: Double) -> case _#_ eqDouble# [] [u0, u2] of { _ALG_ True -> case u1 of { _ALG_ D# (u4 :: Double#) -> case u3 of { _ALG_ D# (u5 :: Double#) -> _#_ eqDouble# [] [u4, u5]; _NO_DEFLT_ }; _NO_DEFLT_ }; False -> _!_ False [] []; _NO_DEFLT_ } _N_} _F_ _ALWAYS_ \ (u0 :: Complex Double) (u1 :: Complex Double) -> case u0 of { _ALG_ (:+) (u2 :: Double) (u3 :: Double) -> case u2 of { _ALG_ D# (u4 :: Double#) -> case u1 of { _ALG_ (:+) (u5 :: Double) (u6 :: Double) -> case u5 of { _ALG_ D# (u7 :: Double#) -> case _#_ eqDouble# [] [u4, u7] of { _ALG_ True -> case u3 of { _ALG_ D# (u8 :: Double#) -> case u6 of { _ALG_ D# (u9 :: Double#) -> _#_ eqDouble# [] [u8, u9]; _NO_DEFLT_ }; _NO_DEFLT_ }; False -> _!_ False [] []; _NO_DEFLT_ }; _NO_DEFLT_ }; _NO_DEFLT_ }; _NO_DEFLT_ }; _NO_DEFLT_ } _N_,
- (/=) = _A_ 2 _U_ 11 _N_ _S_ "U(U(P)L)U(U(P)L)" {_A_ 4 _U_ 2121 _N_ _N_ _F_ _IF_ARGS_ 0 4 XCXC 7 \ (u0 :: Double#) (u1 :: Double) (u2 :: Double#) (u3 :: Double) -> case _#_ neDouble# [] [u0, u2] of { _ALG_ True -> _!_ True [] []; False -> case u1 of { _ALG_ D# (u4 :: Double#) -> case u3 of { _ALG_ D# (u5 :: Double#) -> _#_ neDouble# [] [u4, u5]; _NO_DEFLT_ }; _NO_DEFLT_ }; _NO_DEFLT_ } _N_} _F_ _ALWAYS_ \ (u0 :: Complex Double) (u1 :: Complex Double) -> case u0 of { _ALG_ (:+) (u2 :: Double) (u3 :: Double) -> case u2 of { _ALG_ D# (u4 :: Double#) -> case u1 of { _ALG_ (:+) (u5 :: Double) (u6 :: Double) -> case u5 of { _ALG_ D# (u7 :: Double#) -> case _#_ neDouble# [] [u4, u7] of { _ALG_ True -> _!_ True [] []; False -> case u3 of { _ALG_ D# (u8 :: Double#) -> case u6 of { _ALG_ D# (u9 :: Double#) -> _#_ neDouble# [] [u8, u9]; _NO_DEFLT_ }; _NO_DEFLT_ }; _NO_DEFLT_ }; _NO_DEFLT_ }; _NO_DEFLT_ }; _NO_DEFLT_ }; _NO_DEFLT_ } _N_ #-}
+ (==) = { _A_ 2 _U_ 11 _N_ _S_ "U(U(P)L)U(U(P)L)" {_A_ 4 _U_ 2121 _N_ _N_ _F_ _IF_ARGS_ 0 4 XCXC 7 \ (u0 :: Double#) (u1 :: Double) (u2 :: Double#) (u3 :: Double) -> case _#_ eqDouble# [] [u0, u2] of { _ALG_ True -> case u1 of { _ALG_ D# (u4 :: Double#) -> case u3 of { _ALG_ D# (u5 :: Double#) -> _#_ eqDouble# [] [u4, u5]; _NO_DEFLT_ }; _NO_DEFLT_ }; False -> _!_ False [] []; _NO_DEFLT_ } _N_} _F_ _ALWAYS_ \ (u0 :: Complex Double) (u1 :: Complex Double) -> case u0 of { _ALG_ (:+) (u2 :: Double) (u3 :: Double) -> case u2 of { _ALG_ D# (u4 :: Double#) -> case u1 of { _ALG_ (:+) (u5 :: Double) (u6 :: Double) -> case u5 of { _ALG_ D# (u7 :: Double#) -> case _#_ eqDouble# [] [u4, u7] of { _ALG_ True -> case u3 of { _ALG_ D# (u8 :: Double#) -> case u6 of { _ALG_ D# (u9 :: Double#) -> _#_ eqDouble# [] [u8, u9]; _NO_DEFLT_ }; _NO_DEFLT_ }; False -> _!_ False [] []; _NO_DEFLT_ }; _NO_DEFLT_ }; _NO_DEFLT_ }; _NO_DEFLT_ }; _NO_DEFLT_ } _N_ },
+ (/=) = { _A_ 2 _U_ 11 _N_ _S_ "U(U(P)L)U(U(P)L)" {_A_ 4 _U_ 2121 _N_ _N_ _F_ _IF_ARGS_ 0 4 XCXC 7 \ (u0 :: Double#) (u1 :: Double) (u2 :: Double#) (u3 :: Double) -> case _#_ neDouble# [] [u0, u2] of { _ALG_ True -> _!_ True [] []; False -> case u1 of { _ALG_ D# (u4 :: Double#) -> case u3 of { _ALG_ D# (u5 :: Double#) -> _#_ neDouble# [] [u4, u5]; _NO_DEFLT_ }; _NO_DEFLT_ }; _NO_DEFLT_ } _N_} _F_ _ALWAYS_ \ (u0 :: Complex Double) (u1 :: Complex Double) -> case u0 of { _ALG_ (:+) (u2 :: Double) (u3 :: Double) -> case u2 of { _ALG_ D# (u4 :: Double#) -> case u1 of { _ALG_ (:+) (u5 :: Double) (u6 :: Double) -> case u5 of { _ALG_ D# (u7 :: Double#) -> case _#_ neDouble# [] [u4, u7] of { _ALG_ True -> _!_ True [] []; False -> case u3 of { _ALG_ D# (u8 :: Double#) -> case u6 of { _ALG_ D# (u9 :: Double#) -> _#_ neDouble# [] [u8, u9]; _NO_DEFLT_ }; _NO_DEFLT_ }; _NO_DEFLT_ }; _NO_DEFLT_ }; _NO_DEFLT_ }; _NO_DEFLT_ }; _NO_DEFLT_ } _N_ } #-}
instance Eq Double
{-# GHC_PRAGMA _M_ PreludeCore {-dfun-} _A_ 0 _N_ _N_ _N_ _F_ _IF_ARGS_ 0 0 X 3 _!_ _TUP_2 [(Double -> Double -> Bool), (Double -> Double -> Bool)] [_CONSTM_ Eq (==) (Double), _CONSTM_ Eq (/=) (Double)] _N_
- (==) = _A_ 2 _U_ 11 _N_ _S_ "U(P)U(P)" {_A_ 2 _U_ 22 _N_ _N_ _F_ _IF_ARGS_ 0 2 XX 1 \ (u0 :: Double#) (u1 :: Double#) -> _#_ eqDouble# [] [u0, u1] _N_} _F_ _IF_ARGS_ 0 2 CC 3 \ (u0 :: Double) (u1 :: Double) -> case u0 of { _ALG_ D# (u2 :: Double#) -> case u1 of { _ALG_ D# (u3 :: Double#) -> _#_ eqDouble# [] [u2, u3]; _NO_DEFLT_ }; _NO_DEFLT_ } _N_,
- (/=) = _A_ 2 _U_ 11 _N_ _S_ "U(P)U(P)" {_A_ 2 _U_ 22 _N_ _N_ _F_ _IF_ARGS_ 0 2 XX 1 \ (u0 :: Double#) (u1 :: Double#) -> _#_ neDouble# [] [u0, u1] _N_} _F_ _IF_ARGS_ 0 2 CC 3 \ (u0 :: Double) (u1 :: Double) -> case u0 of { _ALG_ D# (u2 :: Double#) -> case u1 of { _ALG_ D# (u3 :: Double#) -> _#_ neDouble# [] [u2, u3]; _NO_DEFLT_ }; _NO_DEFLT_ } _N_ #-}
+ (==) = { _A_ 2 _U_ 11 _N_ _S_ "U(P)U(P)" {_A_ 2 _U_ 22 _N_ _N_ _F_ _IF_ARGS_ 0 2 XX 1 \ (u0 :: Double#) (u1 :: Double#) -> _#_ eqDouble# [] [u0, u1] _N_} _F_ _IF_ARGS_ 0 2 CC 3 \ (u0 :: Double) (u1 :: Double) -> case u0 of { _ALG_ D# (u2 :: Double#) -> case u1 of { _ALG_ D# (u3 :: Double#) -> _#_ eqDouble# [] [u2, u3]; _NO_DEFLT_ }; _NO_DEFLT_ } _N_ },
+ (/=) = { _A_ 2 _U_ 11 _N_ _S_ "U(P)U(P)" {_A_ 2 _U_ 22 _N_ _N_ _F_ _IF_ARGS_ 0 2 XX 1 \ (u0 :: Double#) (u1 :: Double#) -> _#_ neDouble# [] [u0, u1] _N_} _F_ _IF_ARGS_ 0 2 CC 3 \ (u0 :: Double) (u1 :: Double) -> case u0 of { _ALG_ D# (u2 :: Double#) -> case u1 of { _ALG_ D# (u3 :: Double#) -> _#_ neDouble# [] [u2, u3]; _NO_DEFLT_ }; _NO_DEFLT_ } _N_ } #-}
instance Eq Float
{-# GHC_PRAGMA _M_ PreludeCore {-dfun-} _A_ 0 _N_ _N_ _N_ _F_ _IF_ARGS_ 0 0 X 3 _!_ _TUP_2 [(Float -> Float -> Bool), (Float -> Float -> Bool)] [_CONSTM_ Eq (==) (Float), _CONSTM_ Eq (/=) (Float)] _N_
- (==) = _A_ 2 _U_ 11 _N_ _S_ "U(P)U(P)" {_A_ 2 _U_ 22 _N_ _N_ _F_ _IF_ARGS_ 0 2 XX 1 \ (u0 :: Float#) (u1 :: Float#) -> _#_ eqFloat# [] [u0, u1] _N_} _F_ _IF_ARGS_ 0 2 CC 3 \ (u0 :: Float) (u1 :: Float) -> case u0 of { _ALG_ F# (u2 :: Float#) -> case u1 of { _ALG_ F# (u3 :: Float#) -> _#_ eqFloat# [] [u2, u3]; _NO_DEFLT_ }; _NO_DEFLT_ } _N_,
- (/=) = _A_ 2 _U_ 11 _N_ _S_ "U(P)U(P)" {_A_ 2 _U_ 22 _N_ _N_ _F_ _IF_ARGS_ 0 2 XX 1 \ (u0 :: Float#) (u1 :: Float#) -> _#_ neFloat# [] [u0, u1] _N_} _F_ _IF_ARGS_ 0 2 CC 3 \ (u0 :: Float) (u1 :: Float) -> case u0 of { _ALG_ F# (u2 :: Float#) -> case u1 of { _ALG_ F# (u3 :: Float#) -> _#_ neFloat# [] [u2, u3]; _NO_DEFLT_ }; _NO_DEFLT_ } _N_ #-}
+ (==) = { _A_ 2 _U_ 11 _N_ _S_ "U(P)U(P)" {_A_ 2 _U_ 22 _N_ _N_ _F_ _IF_ARGS_ 0 2 XX 1 \ (u0 :: Float#) (u1 :: Float#) -> _#_ eqFloat# [] [u0, u1] _N_} _F_ _IF_ARGS_ 0 2 CC 3 \ (u0 :: Float) (u1 :: Float) -> case u0 of { _ALG_ F# (u2 :: Float#) -> case u1 of { _ALG_ F# (u3 :: Float#) -> _#_ eqFloat# [] [u2, u3]; _NO_DEFLT_ }; _NO_DEFLT_ } _N_ },
+ (/=) = { _A_ 2 _U_ 11 _N_ _S_ "U(P)U(P)" {_A_ 2 _U_ 22 _N_ _N_ _F_ _IF_ARGS_ 0 2 XX 1 \ (u0 :: Float#) (u1 :: Float#) -> _#_ neFloat# [] [u0, u1] _N_} _F_ _IF_ARGS_ 0 2 CC 3 \ (u0 :: Float) (u1 :: Float) -> case u0 of { _ALG_ F# (u2 :: Float#) -> case u1 of { _ALG_ F# (u3 :: Float#) -> _#_ neFloat# [] [u2, u3]; _NO_DEFLT_ }; _NO_DEFLT_ } _N_ } #-}
instance Eq Int
{-# GHC_PRAGMA _M_ PreludeCore {-dfun-} _A_ 0 _N_ _N_ _N_ _F_ _IF_ARGS_ 0 0 X 3 _!_ _TUP_2 [(Int -> Int -> Bool), (Int -> Int -> Bool)] [_CONSTM_ Eq (==) (Int), _CONSTM_ Eq (/=) (Int)] _N_
- (==) = _A_ 2 _U_ 11 _N_ _S_ "U(P)U(P)" {_A_ 2 _U_ 22 _N_ _N_ _F_ _IF_ARGS_ 0 2 XX 1 \ (u0 :: Int#) (u1 :: Int#) -> _#_ eqInt# [] [u0, u1] _N_} _F_ _IF_ARGS_ 0 2 CC 3 \ (u0 :: Int) (u1 :: Int) -> case u0 of { _ALG_ I# (u2 :: Int#) -> case u1 of { _ALG_ I# (u3 :: Int#) -> _#_ eqInt# [] [u2, u3]; _NO_DEFLT_ }; _NO_DEFLT_ } _N_,
- (/=) = _A_ 2 _U_ 11 _N_ _S_ "U(P)U(P)" {_A_ 2 _U_ 22 _N_ _N_ _F_ _IF_ARGS_ 0 2 XX 1 \ (u0 :: Int#) (u1 :: Int#) -> _#_ neInt# [] [u0, u1] _N_} _F_ _IF_ARGS_ 0 2 CC 3 \ (u0 :: Int) (u1 :: Int) -> case u0 of { _ALG_ I# (u2 :: Int#) -> case u1 of { _ALG_ I# (u3 :: Int#) -> _#_ neInt# [] [u2, u3]; _NO_DEFLT_ }; _NO_DEFLT_ } _N_ #-}
+ (==) = { _A_ 2 _U_ 11 _N_ _S_ "U(P)U(P)" {_A_ 2 _U_ 22 _N_ _N_ _F_ _IF_ARGS_ 0 2 XX 1 \ (u0 :: Int#) (u1 :: Int#) -> _#_ eqInt# [] [u0, u1] _N_} _F_ _IF_ARGS_ 0 2 CC 3 \ (u0 :: Int) (u1 :: Int) -> case u0 of { _ALG_ I# (u2 :: Int#) -> case u1 of { _ALG_ I# (u3 :: Int#) -> _#_ eqInt# [] [u2, u3]; _NO_DEFLT_ }; _NO_DEFLT_ } _N_ },
+ (/=) = { _A_ 2 _U_ 11 _N_ _S_ "U(P)U(P)" {_A_ 2 _U_ 22 _N_ _N_ _F_ _IF_ARGS_ 0 2 XX 1 \ (u0 :: Int#) (u1 :: Int#) -> _#_ neInt# [] [u0, u1] _N_} _F_ _IF_ARGS_ 0 2 CC 3 \ (u0 :: Int) (u1 :: Int) -> case u0 of { _ALG_ I# (u2 :: Int#) -> case u1 of { _ALG_ I# (u3 :: Int#) -> _#_ neInt# [] [u2, u3]; _NO_DEFLT_ }; _NO_DEFLT_ } _N_ } #-}
instance Eq Integer
{-# GHC_PRAGMA _M_ PreludeCore {-dfun-} _A_ 0 _N_ _N_ _N_ _F_ _IF_ARGS_ 0 0 X 3 _!_ _TUP_2 [(Integer -> Integer -> Bool), (Integer -> Integer -> Bool)] [_CONSTM_ Eq (==) (Integer), _CONSTM_ Eq (/=) (Integer)] _N_
- (==) = _A_ 2 _U_ 11 _N_ _S_ "U(PPP)U(PPP)" {_A_ 4 _U_ 2221 _N_ _N_ _F_ _IF_ARGS_ 0 4 XXXC 4 \ (u0 :: Int#) (u1 :: Int#) (u2 :: ByteArray#) (u3 :: Integer) -> case u3 of { _ALG_ J# (u4 :: Int#) (u5 :: Int#) (u6 :: ByteArray#) -> case _#_ cmpInteger# [] [u0, u1, u2, u4, u5, u6] of { _PRIM_ 0# -> _!_ True [] []; (u7 :: Int#) -> _!_ False [] [] }; _NO_DEFLT_ } _N_} _F_ _IF_ARGS_ 0 2 CC 5 \ (u0 :: Integer) (u1 :: Integer) -> case u0 of { _ALG_ J# (u2 :: Int#) (u3 :: Int#) (u4 :: ByteArray#) -> case u1 of { _ALG_ J# (u5 :: Int#) (u6 :: Int#) (u7 :: ByteArray#) -> case _#_ cmpInteger# [] [u2, u3, u4, u5, u6, u7] of { _PRIM_ 0# -> _!_ True [] []; (u8 :: Int#) -> _!_ False [] [] }; _NO_DEFLT_ }; _NO_DEFLT_ } _N_,
- (/=) = _A_ 2 _U_ 11 _N_ _S_ "U(PPP)U(PPP)" {_A_ 4 _U_ 2221 _N_ _N_ _F_ _IF_ARGS_ 0 4 XXXC 4 \ (u0 :: Int#) (u1 :: Int#) (u2 :: ByteArray#) (u3 :: Integer) -> case u3 of { _ALG_ J# (u4 :: Int#) (u5 :: Int#) (u6 :: ByteArray#) -> case _#_ cmpInteger# [] [u0, u1, u2, u4, u5, u6] of { _PRIM_ 0# -> _!_ False [] []; (u7 :: Int#) -> _!_ True [] [] }; _NO_DEFLT_ } _N_} _F_ _IF_ARGS_ 0 2 CC 5 \ (u0 :: Integer) (u1 :: Integer) -> case u0 of { _ALG_ J# (u2 :: Int#) (u3 :: Int#) (u4 :: ByteArray#) -> case u1 of { _ALG_ J# (u5 :: Int#) (u6 :: Int#) (u7 :: ByteArray#) -> case _#_ cmpInteger# [] [u2, u3, u4, u5, u6, u7] of { _PRIM_ 0# -> _!_ False [] []; (u8 :: Int#) -> _!_ True [] [] }; _NO_DEFLT_ }; _NO_DEFLT_ } _N_ #-}
+ (==) = { _A_ 2 _U_ 11 _N_ _S_ "U(PPP)U(PPP)" {_A_ 4 _U_ 2221 _N_ _N_ _F_ _IF_ARGS_ 0 4 XXXC 4 \ (u0 :: Int#) (u1 :: Int#) (u2 :: ByteArray#) (u3 :: Integer) -> case u3 of { _ALG_ J# (u4 :: Int#) (u5 :: Int#) (u6 :: ByteArray#) -> case _#_ cmpInteger# [] [u0, u1, u2, u4, u5, u6] of { _PRIM_ 0# -> _!_ True [] []; (u7 :: Int#) -> _!_ False [] [] }; _NO_DEFLT_ } _N_} _F_ _IF_ARGS_ 0 2 CC 5 \ (u0 :: Integer) (u1 :: Integer) -> case u0 of { _ALG_ J# (u2 :: Int#) (u3 :: Int#) (u4 :: ByteArray#) -> case u1 of { _ALG_ J# (u5 :: Int#) (u6 :: Int#) (u7 :: ByteArray#) -> case _#_ cmpInteger# [] [u2, u3, u4, u5, u6, u7] of { _PRIM_ 0# -> _!_ True [] []; (u8 :: Int#) -> _!_ False [] [] }; _NO_DEFLT_ }; _NO_DEFLT_ } _N_ },
+ (/=) = { _A_ 2 _U_ 11 _N_ _S_ "U(PPP)U(PPP)" {_A_ 4 _U_ 2221 _N_ _N_ _F_ _IF_ARGS_ 0 4 XXXC 4 \ (u0 :: Int#) (u1 :: Int#) (u2 :: ByteArray#) (u3 :: Integer) -> case u3 of { _ALG_ J# (u4 :: Int#) (u5 :: Int#) (u6 :: ByteArray#) -> case _#_ cmpInteger# [] [u0, u1, u2, u4, u5, u6] of { _PRIM_ 0# -> _!_ False [] []; (u7 :: Int#) -> _!_ True [] [] }; _NO_DEFLT_ } _N_} _F_ _IF_ARGS_ 0 2 CC 5 \ (u0 :: Integer) (u1 :: Integer) -> case u0 of { _ALG_ J# (u2 :: Int#) (u3 :: Int#) (u4 :: ByteArray#) -> case u1 of { _ALG_ J# (u5 :: Int#) (u6 :: Int#) (u7 :: ByteArray#) -> case _#_ cmpInteger# [] [u2, u3, u4, u5, u6, u7] of { _PRIM_ 0# -> _!_ False [] []; (u8 :: Int#) -> _!_ True [] [] }; _NO_DEFLT_ }; _NO_DEFLT_ } _N_ } #-}
instance Integral a => Eq (Ratio a)
{-# GHC_PRAGMA _M_ PreludeRatio {-dfun-} _A_ 1 _U_ 1 _N_ _N_ _N_ _N_ #-}
instance Eq (Ratio Integer)
{-# GHC_PRAGMA _M_ PreludeRatio {-dfun-} _A_ 0 _N_ _N_ _N_ _F_ _IF_ARGS_ 0 0 X 3 _!_ _TUP_2 [(Ratio Integer -> Ratio Integer -> Bool), (Ratio Integer -> Ratio Integer -> Bool)] [_CONSTM_ Eq (==) (Ratio Integer), _CONSTM_ Eq (/=) (Ratio Integer)] _N_
- (==) = _A_ 2 _U_ 11 _N_ _S_ "U(U(PPP)L)U(U(PPP)L)" {_A_ 5 _U_ 22211 _N_ _N_ _F_ _IF_ARGS_ 0 5 XXXCC 9 \ (u0 :: Int#) (u1 :: Int#) (u2 :: ByteArray#) (u3 :: Integer) (u4 :: Ratio Integer) -> case u4 of { _ALG_ (:%) (u5 :: Integer) (u6 :: Integer) -> case u5 of { _ALG_ J# (u7 :: Int#) (u8 :: Int#) (u9 :: ByteArray#) -> case _#_ cmpInteger# [] [u0, u1, u2, u7, u8, u9] of { _PRIM_ 0# -> case u3 of { _ALG_ J# (ua :: Int#) (ub :: Int#) (uc :: ByteArray#) -> case u6 of { _ALG_ J# (ud :: Int#) (ue :: Int#) (uf :: ByteArray#) -> case _#_ cmpInteger# [] [ua, ub, uc, ud, ue, uf] of { _PRIM_ 0# -> _!_ True [] []; (ug :: Int#) -> _!_ False [] [] }; _NO_DEFLT_ }; _NO_DEFLT_ }; (uh :: Int#) -> _!_ False [] [] }; _NO_DEFLT_ }; _NO_DEFLT_ } _N_} _N_ _N_,
- (/=) = _A_ 2 _U_ 11 _N_ _S_ "U(U(PPP)L)U(U(PPP)L)" {_A_ 5 _U_ 22211 _N_ _N_ _F_ _IF_ARGS_ 0 5 XXXCC 9 \ (u0 :: Int#) (u1 :: Int#) (u2 :: ByteArray#) (u3 :: Integer) (u4 :: Ratio Integer) -> case u4 of { _ALG_ (:%) (u5 :: Integer) (u6 :: Integer) -> case u5 of { _ALG_ J# (u7 :: Int#) (u8 :: Int#) (u9 :: ByteArray#) -> case _#_ cmpInteger# [] [u0, u1, u2, u7, u8, u9] of { _PRIM_ 0# -> case u3 of { _ALG_ J# (ua :: Int#) (ub :: Int#) (uc :: ByteArray#) -> case u6 of { _ALG_ J# (ud :: Int#) (ue :: Int#) (uf :: ByteArray#) -> case _#_ cmpInteger# [] [ua, ub, uc, ud, ue, uf] of { _PRIM_ 0# -> _!_ False [] []; (ug :: Int#) -> _!_ True [] [] }; _NO_DEFLT_ }; _NO_DEFLT_ }; (uh :: Int#) -> _!_ True [] [] }; _NO_DEFLT_ }; _NO_DEFLT_ } _N_} _N_ _N_ #-}
+ (==) = { _A_ 2 _U_ 11 _N_ _S_ "U(U(PPP)L)U(U(PPP)L)" {_A_ 5 _U_ 22211 _N_ _N_ _F_ _IF_ARGS_ 0 5 XXXCC 9 \ (u0 :: Int#) (u1 :: Int#) (u2 :: ByteArray#) (u3 :: Integer) (u4 :: Ratio Integer) -> case u4 of { _ALG_ (:%) (u5 :: Integer) (u6 :: Integer) -> case u5 of { _ALG_ J# (u7 :: Int#) (u8 :: Int#) (u9 :: ByteArray#) -> case _#_ cmpInteger# [] [u0, u1, u2, u7, u8, u9] of { _PRIM_ 0# -> case u3 of { _ALG_ J# (ua :: Int#) (ub :: Int#) (uc :: ByteArray#) -> case u6 of { _ALG_ J# (ud :: Int#) (ue :: Int#) (uf :: ByteArray#) -> case _#_ cmpInteger# [] [ua, ub, uc, ud, ue, uf] of { _PRIM_ 0# -> _!_ True [] []; (ug :: Int#) -> _!_ False [] [] }; _NO_DEFLT_ }; _NO_DEFLT_ }; (uh :: Int#) -> _!_ False [] [] }; _NO_DEFLT_ }; _NO_DEFLT_ } _N_} _N_ _N_ },
+ (/=) = { _A_ 2 _U_ 11 _N_ _S_ "U(U(PPP)L)U(U(PPP)L)" {_A_ 5 _U_ 22211 _N_ _N_ _F_ _IF_ARGS_ 0 5 XXXCC 9 \ (u0 :: Int#) (u1 :: Int#) (u2 :: ByteArray#) (u3 :: Integer) (u4 :: Ratio Integer) -> case u4 of { _ALG_ (:%) (u5 :: Integer) (u6 :: Integer) -> case u5 of { _ALG_ J# (u7 :: Int#) (u8 :: Int#) (u9 :: ByteArray#) -> case _#_ cmpInteger# [] [u0, u1, u2, u7, u8, u9] of { _PRIM_ 0# -> case u3 of { _ALG_ J# (ua :: Int#) (ub :: Int#) (uc :: ByteArray#) -> case u6 of { _ALG_ J# (ud :: Int#) (ue :: Int#) (uf :: ByteArray#) -> case _#_ cmpInteger# [] [ua, ub, uc, ud, ue, uf] of { _PRIM_ 0# -> _!_ False [] []; (ug :: Int#) -> _!_ True [] [] }; _NO_DEFLT_ }; _NO_DEFLT_ }; (uh :: Int#) -> _!_ True [] [] }; _NO_DEFLT_ }; _NO_DEFLT_ } _N_} _N_ _N_ } #-}
+instance Eq [(Int, Int)]
+ {-# GHC_PRAGMA _M_ PreludeBuiltin {-dfun-} _A_ 0 _N_ _N_ _N_ _F_ _IF_ARGS_ 0 0 X 3 _!_ _TUP_2 [([(Int, Int)] -> [(Int, Int)] -> Bool), ([(Int, Int)] -> [(Int, Int)] -> Bool)] [_CONSTM_ Eq (==) ([(Int, Int)]), _CONSTM_ Eq (/=) ([(Int, Int)])] _N_
+ (==) = { _A_ 2 _U_ 11 _N_ _S_ "SS" _N_ _N_ },
+ (/=) = { _A_ 2 _U_ 11 _N_ _S_ "SS" _N_ _N_ } #-}
instance Eq a => Eq [a]
{-# GHC_PRAGMA _M_ PreludeBuiltin {-dfun-} _A_ 1 _U_ 1 _N_ _N_ _N_ _N_ #-}
+instance Eq [Bool]
+ {-# GHC_PRAGMA _M_ PreludeBuiltin {-dfun-} _A_ 0 _N_ _N_ _N_ _F_ _IF_ARGS_ 0 0 X 3 _!_ _TUP_2 [([Bool] -> [Bool] -> Bool), ([Bool] -> [Bool] -> Bool)] [_CONSTM_ Eq (==) ([Bool]), _CONSTM_ Eq (/=) ([Bool])] _N_
+ (==) = { _A_ 2 _U_ 11 _N_ _S_ "SS" _N_ _N_ },
+ (/=) = { _A_ 2 _U_ 11 _N_ _S_ "SS" _N_ _N_ } #-}
instance Eq [Char]
{-# GHC_PRAGMA _M_ PreludeBuiltin {-dfun-} _A_ 0 _N_ _N_ _N_ _F_ _IF_ARGS_ 0 0 X 3 _!_ _TUP_2 [([Char] -> [Char] -> Bool), ([Char] -> [Char] -> Bool)] [_CONSTM_ Eq (==) ([Char]), _CONSTM_ Eq (/=) ([Char])] _N_
- (==) = _A_ 2 _U_ 11 _N_ _S_ "SS" _N_ _N_,
- (/=) = _A_ 2 _U_ 11 _N_ _S_ "SS" _N_ _N_ #-}
+ (==) = { _A_ 2 _U_ 11 _N_ _S_ "SS" _N_ _N_ },
+ (/=) = { _A_ 2 _U_ 11 _N_ _S_ "SS" _N_ _N_ } #-}
+instance Eq [Complex Double]
+ {-# GHC_PRAGMA _M_ PreludeBuiltin {-dfun-} _A_ 0 _N_ _N_ _N_ _F_ _IF_ARGS_ 0 0 X 3 _!_ _TUP_2 [([Complex Double] -> [Complex Double] -> Bool), ([Complex Double] -> [Complex Double] -> Bool)] [_CONSTM_ Eq (==) ([Complex Double]), _CONSTM_ Eq (/=) ([Complex Double])] _N_
+ (==) = { _A_ 2 _U_ 11 _N_ _S_ "SS" _N_ _N_ },
+ (/=) = { _A_ 2 _U_ 11 _N_ _S_ "SS" _N_ _N_ } #-}
+instance Eq [Double]
+ {-# GHC_PRAGMA _M_ PreludeBuiltin {-dfun-} _A_ 0 _N_ _N_ _N_ _F_ _IF_ARGS_ 0 0 X 3 _!_ _TUP_2 [([Double] -> [Double] -> Bool), ([Double] -> [Double] -> Bool)] [_CONSTM_ Eq (==) ([Double]), _CONSTM_ Eq (/=) ([Double])] _N_
+ (==) = { _A_ 2 _U_ 11 _N_ _S_ "SS" _N_ _N_ },
+ (/=) = { _A_ 2 _U_ 11 _N_ _S_ "SS" _N_ _N_ } #-}
instance Eq [Int]
{-# GHC_PRAGMA _M_ PreludeBuiltin {-dfun-} _A_ 0 _N_ _N_ _N_ _F_ _IF_ARGS_ 0 0 X 3 _!_ _TUP_2 [([Int] -> [Int] -> Bool), ([Int] -> [Int] -> Bool)] [_CONSTM_ Eq (==) ([Int]), _CONSTM_ Eq (/=) ([Int])] _N_
- (==) = _A_ 2 _U_ 11 _N_ _S_ "SS" _N_ _N_,
- (/=) = _A_ 2 _U_ 11 _N_ _S_ "SS" _N_ _N_ #-}
+ (==) = { _A_ 2 _U_ 11 _N_ _S_ "SS" _N_ _N_ },
+ (/=) = { _A_ 2 _U_ 11 _N_ _S_ "SS" _N_ _N_ } #-}
+instance Eq [Integer]
+ {-# GHC_PRAGMA _M_ PreludeBuiltin {-dfun-} _A_ 0 _N_ _N_ _N_ _F_ _IF_ARGS_ 0 0 X 3 _!_ _TUP_2 [([Integer] -> [Integer] -> Bool), ([Integer] -> [Integer] -> Bool)] [_CONSTM_ Eq (==) ([Integer]), _CONSTM_ Eq (/=) ([Integer])] _N_
+ (==) = { _A_ 2 _U_ 11 _N_ _S_ "SS" _N_ _N_ },
+ (/=) = { _A_ 2 _U_ 11 _N_ _S_ "SS" _N_ _N_ } #-}
+instance Eq [[Char]]
+ {-# GHC_PRAGMA _M_ PreludeBuiltin {-dfun-} _A_ 0 _N_ _N_ _N_ _F_ _IF_ARGS_ 0 0 X 3 _!_ _TUP_2 [([[Char]] -> [[Char]] -> Bool), ([[Char]] -> [[Char]] -> Bool)] [_CONSTM_ Eq (==) ([[Char]]), _CONSTM_ Eq (/=) ([[Char]])] _N_
+ (==) = { _A_ 2 _U_ 11 _N_ _S_ "SS" _N_ _N_ },
+ (/=) = { _A_ 2 _U_ 11 _N_ _S_ "SS" _N_ _N_ } #-}
+instance Eq [[Int]]
+ {-# GHC_PRAGMA _M_ PreludeBuiltin {-dfun-} _A_ 0 _N_ _N_ _N_ _F_ _IF_ARGS_ 0 0 X 3 _!_ _TUP_2 [([[Int]] -> [[Int]] -> Bool), ([[Int]] -> [[Int]] -> Bool)] [_CONSTM_ Eq (==) ([[Int]]), _CONSTM_ Eq (/=) ([[Int]])] _N_
+ (==) = { _A_ 2 _U_ 11 _N_ _S_ "SS" _N_ _N_ },
+ (/=) = { _A_ 2 _U_ 11 _N_ _S_ "SS" _N_ _N_ } #-}
instance Eq _Addr
{-# GHC_PRAGMA _M_ PreludeCore {-dfun-} _A_ 0 _N_ _N_ _N_ _F_ _IF_ARGS_ 0 0 X 3 _!_ _TUP_2 [(_Addr -> _Addr -> Bool), (_Addr -> _Addr -> Bool)] [_CONSTM_ Eq (==) (_Addr), _CONSTM_ Eq (/=) (_Addr)] _N_
- (==) = _A_ 2 _U_ 11 _N_ _S_ "U(P)U(P)" {_A_ 2 _U_ 22 _N_ _N_ _F_ _IF_ARGS_ 0 2 XX 1 \ (u0 :: Addr#) (u1 :: Addr#) -> _#_ eqAddr# [] [u0, u1] _N_} _F_ _IF_ARGS_ 0 2 CC 3 \ (u0 :: _Addr) (u1 :: _Addr) -> case u0 of { _ALG_ A# (u2 :: Addr#) -> case u1 of { _ALG_ A# (u3 :: Addr#) -> _#_ eqAddr# [] [u2, u3]; _NO_DEFLT_ }; _NO_DEFLT_ } _N_,
- (/=) = _A_ 2 _U_ 11 _N_ _S_ "U(P)U(P)" {_A_ 2 _U_ 22 _N_ _N_ _F_ _IF_ARGS_ 0 2 XX 1 \ (u0 :: Addr#) (u1 :: Addr#) -> _#_ neAddr# [] [u0, u1] _N_} _F_ _IF_ARGS_ 0 2 CC 3 \ (u0 :: _Addr) (u1 :: _Addr) -> case u0 of { _ALG_ A# (u2 :: Addr#) -> case u1 of { _ALG_ A# (u3 :: Addr#) -> _#_ neAddr# [] [u2, u3]; _NO_DEFLT_ }; _NO_DEFLT_ } _N_ #-}
+ (==) = { _A_ 2 _U_ 11 _N_ _S_ "U(P)U(P)" {_A_ 2 _U_ 22 _N_ _N_ _F_ _IF_ARGS_ 0 2 XX 1 \ (u0 :: Addr#) (u1 :: Addr#) -> _#_ eqAddr# [] [u0, u1] _N_} _F_ _IF_ARGS_ 0 2 CC 3 \ (u0 :: _Addr) (u1 :: _Addr) -> case u0 of { _ALG_ A# (u2 :: Addr#) -> case u1 of { _ALG_ A# (u3 :: Addr#) -> _#_ eqAddr# [] [u2, u3]; _NO_DEFLT_ }; _NO_DEFLT_ } _N_ },
+ (/=) = { _A_ 2 _U_ 11 _N_ _S_ "U(P)U(P)" {_A_ 2 _U_ 22 _N_ _N_ _F_ _IF_ARGS_ 0 2 XX 1 \ (u0 :: Addr#) (u1 :: Addr#) -> _#_ neAddr# [] [u0, u1] _N_} _F_ _IF_ARGS_ 0 2 CC 3 \ (u0 :: _Addr) (u1 :: _Addr) -> case u0 of { _ALG_ A# (u2 :: Addr#) -> case u1 of { _ALG_ A# (u3 :: Addr#) -> _#_ neAddr# [] [u2, u3]; _NO_DEFLT_ }; _NO_DEFLT_ } _N_ } #-}
instance Eq _PackedString
{-# GHC_PRAGMA _M_ PreludePS {-dfun-} _A_ 0 _N_ _N_ _N_ _F_ _IF_ARGS_ 0 0 X 3 _!_ _TUP_2 [(_PackedString -> _PackedString -> Bool), (_PackedString -> _PackedString -> Bool)] [_CONSTM_ Eq (==) (_PackedString), _CONSTM_ Eq (/=) (_PackedString)] _N_
- (==) = _A_ 2 _U_ 22 _N_ _S_ "SS" _N_ _N_,
- (/=) = _A_ 2 _U_ 22 _N_ _S_ "SS" _N_ _N_ #-}
+ (==) = { _A_ 2 _U_ 22 _N_ _S_ "SS" _N_ _N_ },
+ (/=) = { _A_ 2 _U_ 22 _N_ _S_ "SS" _N_ _N_ } #-}
instance Eq _Word
{-# GHC_PRAGMA _M_ PreludeCore {-dfun-} _A_ 0 _N_ _N_ _N_ _F_ _IF_ARGS_ 0 0 X 3 _!_ _TUP_2 [(_Word -> _Word -> Bool), (_Word -> _Word -> Bool)] [_CONSTM_ Eq (==) (_Word), _CONSTM_ Eq (/=) (_Word)] _N_
- (==) = _A_ 2 _U_ 11 _N_ _S_ "U(P)U(P)" {_A_ 2 _U_ 22 _N_ _N_ _F_ _IF_ARGS_ 0 2 XX 1 \ (u0 :: Word#) (u1 :: Word#) -> _#_ eqWord# [] [u0, u1] _N_} _F_ _IF_ARGS_ 0 2 CC 3 \ (u0 :: _Word) (u1 :: _Word) -> case u0 of { _ALG_ W# (u2 :: Word#) -> case u1 of { _ALG_ W# (u3 :: Word#) -> _#_ eqWord# [] [u2, u3]; _NO_DEFLT_ }; _NO_DEFLT_ } _N_,
- (/=) = _A_ 2 _U_ 11 _N_ _S_ "U(P)U(P)" {_A_ 2 _U_ 22 _N_ _N_ _F_ _IF_ARGS_ 0 2 XX 1 \ (u0 :: Word#) (u1 :: Word#) -> _#_ neWord# [] [u0, u1] _N_} _F_ _IF_ARGS_ 0 2 CC 3 \ (u0 :: _Word) (u1 :: _Word) -> case u0 of { _ALG_ W# (u2 :: Word#) -> case u1 of { _ALG_ W# (u3 :: Word#) -> _#_ neWord# [] [u2, u3]; _NO_DEFLT_ }; _NO_DEFLT_ } _N_ #-}
+ (==) = { _A_ 2 _U_ 11 _N_ _S_ "U(P)U(P)" {_A_ 2 _U_ 22 _N_ _N_ _F_ _IF_ARGS_ 0 2 XX 1 \ (u0 :: Word#) (u1 :: Word#) -> _#_ eqWord# [] [u0, u1] _N_} _F_ _IF_ARGS_ 0 2 CC 3 \ (u0 :: _Word) (u1 :: _Word) -> case u0 of { _ALG_ W# (u2 :: Word#) -> case u1 of { _ALG_ W# (u3 :: Word#) -> _#_ eqWord# [] [u2, u3]; _NO_DEFLT_ }; _NO_DEFLT_ } _N_ },
+ (/=) = { _A_ 2 _U_ 11 _N_ _S_ "U(P)U(P)" {_A_ 2 _U_ 22 _N_ _N_ _F_ _IF_ARGS_ 0 2 XX 1 \ (u0 :: Word#) (u1 :: Word#) -> _#_ neWord# [] [u0, u1] _N_} _F_ _IF_ARGS_ 0 2 CC 3 \ (u0 :: _Word) (u1 :: _Word) -> case u0 of { _ALG_ W# (u2 :: Word#) -> case u1 of { _ALG_ W# (u3 :: Word#) -> _#_ neWord# [] [u2, u3]; _NO_DEFLT_ }; _NO_DEFLT_ } _N_ } #-}
instance RealFloat a => Floating (Complex a)
{-# GHC_PRAGMA _M_ PreludeComplex {-dfun-} _A_ 2 _U_ 22 _N_ _N_ _N_ _N_ #-}
instance Floating (Complex Double)
{-# GHC_PRAGMA _M_ PreludeComplex {-dfun-} _A_ 0 _N_ _N_ _N_ _F_ _IF_ARGS_ 0 0 X 20 _!_ _TUP_19 [{{Fractional (Complex Double)}}, (Complex Double), (Complex Double -> Complex Double), (Complex Double -> Complex Double), (Complex Double -> Complex Double), (Complex Double -> Complex Double -> Complex Double), (Complex Double -> Complex Double -> Complex Double), (Complex Double -> Complex Double), (Complex Double -> Complex Double), (Complex Double -> Complex Double), (Complex Double -> Complex Double), (Complex Double -> Complex Double), (Complex Double -> Complex Double), (Complex Double -> Complex Double), (Complex Double -> Complex Double), (Complex Double -> Complex Double), (Complex Double -> Complex Double), (Complex Double -> Complex Double), (Complex Double -> Complex Double)] [_DFUN_ Fractional (Complex Double), _CONSTM_ Floating pi (Complex Double), _CONSTM_ Floating exp (Complex Double), _CONSTM_ Floating log (Complex Double), _CONSTM_ Floating sqrt (Complex Double), _CONSTM_ Floating (**) (Complex Double), _CONSTM_ Floating logBase (Complex Double), _CONSTM_ Floating sin (Complex Double), _CONSTM_ Floating cos (Complex Double), _CONSTM_ Floating tan (Complex Double), _CONSTM_ Floating asin (Complex Double), _CONSTM_ Floating acos (Complex Double), _CONSTM_ Floating atan (Complex Double), _CONSTM_ Floating sinh (Complex Double), _CONSTM_ Floating cosh (Complex Double), _CONSTM_ Floating tanh (Complex Double), _CONSTM_ Floating asinh (Complex Double), _CONSTM_ Floating acosh (Complex Double), _CONSTM_ Floating atanh (Complex Double)] _N_
- pi = _A_ 0 _N_ _N_ _N_ _N_ _N_,
- exp = _A_ 1 _U_ 1 _N_ _S_ "U(LL)" {_A_ 2 _U_ 12 _N_ _N_ _N_ _N_} _N_ _N_,
- log = _A_ 1 _U_ 2 _N_ _N_ _N_ _N_,
- sqrt = _A_ 1 _U_ 1 _N_ _S_ "U(U(P)L)" {_A_ 2 _U_ 22 _N_ _N_ _N_ _N_} _N_ _N_,
- (**) = _A_ 2 _U_ 21 _N_ _S_ "LU(LL)" {_A_ 3 _U_ 222 _N_ _N_ _N_ _N_} _N_ _N_,
- logBase = _A_ 2 _U_ 22 _N_ _N_ _N_ _N_,
- sin = _A_ 1 _U_ 1 _N_ _S_ "U(LL)" {_A_ 2 _U_ 22 _N_ _N_ _N_ _N_} _N_ _N_,
- cos = _A_ 1 _U_ 1 _N_ _S_ "U(LL)" {_A_ 2 _U_ 22 _N_ _N_ _N_ _N_} _N_ _N_,
- tan = _A_ 1 _U_ 1 _N_ _S_ "U(LL)" {_A_ 2 _U_ 22 _N_ _N_ _N_ _N_} _N_ _N_,
- asin = _A_ 1 _U_ 1 _N_ _S_ "U(LL)" {_A_ 2 _U_ 22 _N_ _N_ _N_ _N_} _N_ _N_,
- acos = _A_ 1 _U_ 1 _N_ _S_ "U(LL)" {_A_ 2 _U_ 22 _N_ _N_ _N_ _N_} _N_ _N_,
- atan = _A_ 1 _U_ 1 _N_ _S_ "U(LL)" {_A_ 2 _U_ 22 _N_ _N_ _N_ _N_} _N_ _N_,
- sinh = _A_ 1 _U_ 1 _N_ _S_ "U(LL)" {_A_ 2 _U_ 22 _N_ _N_ _N_ _N_} _N_ _N_,
- cosh = _A_ 1 _U_ 1 _N_ _S_ "U(LL)" {_A_ 2 _U_ 22 _N_ _N_ _N_ _N_} _N_ _N_,
- tanh = _A_ 1 _U_ 1 _N_ _S_ "U(LL)" {_A_ 2 _U_ 22 _N_ _N_ _N_ _N_} _N_ _N_,
- asinh = _A_ 1 _U_ 1 _N_ _N_ _N_ _N_,
- acosh = _A_ 1 _U_ 1 _N_ _N_ _N_ _N_,
- atanh = _A_ 1 _U_ 1 _N_ _N_ _N_ _N_ #-}
+ pi = { _A_ 0 _N_ _N_ _N_ _F_ _IF_ARGS_ 0 0 X 3 _!_ (:+) [Double] [_CONSTM_ Floating pi (Double), _SPEC_ _ORIG_ PreludeCore __i0 [ (Double) ]] _N_ },
+ exp = { _A_ 1 _U_ 1 _N_ _S_ "U(LL)" {_A_ 2 _U_ 12 _N_ _N_ _N_ _N_} _N_ _N_ },
+ log = { _A_ 1 _U_ 2 _N_ _N_ _N_ _N_ },
+ sqrt = { _A_ 1 _U_ 1 _N_ _S_ "U(U(P)L)" {_A_ 2 _U_ 22 _N_ _N_ _N_ _N_} _N_ _N_ },
+ (**) = { _A_ 2 _U_ 21 _N_ _S_ "LU(LL)" {_A_ 3 _U_ 222 _N_ _N_ _N_ _N_} _N_ _N_ },
+ logBase = { _A_ 2 _U_ 22 _N_ _N_ _N_ _N_ },
+ sin = { _A_ 1 _U_ 1 _N_ _S_ "U(LL)" {_A_ 2 _U_ 22 _N_ _N_ _N_ _N_} _N_ _N_ },
+ cos = { _A_ 1 _U_ 1 _N_ _S_ "U(LL)" {_A_ 2 _U_ 22 _N_ _N_ _N_ _N_} _N_ _N_ },
+ tan = { _A_ 1 _U_ 1 _N_ _S_ "U(LL)" {_A_ 2 _U_ 22 _N_ _N_ _N_ _N_} _N_ _N_ },
+ asin = { _A_ 1 _U_ 1 _N_ _S_ "U(LL)" {_A_ 2 _U_ 22 _N_ _N_ _N_ _N_} _N_ _N_ },
+ acos = { _A_ 1 _U_ 1 _N_ _S_ "U(LL)" {_A_ 2 _U_ 22 _N_ _N_ _N_ _N_} _N_ _N_ },
+ atan = { _A_ 1 _U_ 1 _N_ _S_ "U(LL)" {_A_ 2 _U_ 22 _N_ _N_ _N_ _N_} _N_ _N_ },
+ sinh = { _A_ 1 _U_ 1 _N_ _S_ "U(LL)" {_A_ 2 _U_ 22 _N_ _N_ _N_ _N_} _N_ _N_ },
+ cosh = { _A_ 1 _U_ 1 _N_ _S_ "U(LL)" {_A_ 2 _U_ 22 _N_ _N_ _N_ _N_} _N_ _N_ },
+ tanh = { _A_ 1 _U_ 1 _N_ _S_ "U(LL)" {_A_ 2 _U_ 22 _N_ _N_ _N_ _N_} _N_ _N_ },
+ asinh = { _A_ 1 _U_ 1 _N_ _N_ _N_ _N_ },
+ acosh = { _A_ 1 _U_ 1 _N_ _N_ _N_ _N_ },
+ atanh = { _A_ 1 _U_ 1 _N_ _N_ _N_ _N_ } #-}
instance Floating Double
{-# GHC_PRAGMA _M_ PreludeCore {-dfun-} _A_ 0 _N_ _N_ _N_ _F_ _IF_ARGS_ 0 0 X 20 _!_ _TUP_19 [{{Fractional Double}}, Double, (Double -> Double), (Double -> Double), (Double -> Double), (Double -> Double -> Double), (Double -> Double -> Double), (Double -> Double), (Double -> Double), (Double -> Double), (Double -> Double), (Double -> Double), (Double -> Double), (Double -> Double), (Double -> Double), (Double -> Double), (Double -> Double), (Double -> Double), (Double -> Double)] [_DFUN_ Fractional (Double), _CONSTM_ Floating pi (Double), _CONSTM_ Floating exp (Double), _CONSTM_ Floating log (Double), _CONSTM_ Floating sqrt (Double), _CONSTM_ Floating (**) (Double), _CONSTM_ Floating logBase (Double), _CONSTM_ Floating sin (Double), _CONSTM_ Floating cos (Double), _CONSTM_ Floating tan (Double), _CONSTM_ Floating asin (Double), _CONSTM_ Floating acos (Double), _CONSTM_ Floating atan (Double), _CONSTM_ Floating sinh (Double), _CONSTM_ Floating cosh (Double), _CONSTM_ Floating tanh (Double), _CONSTM_ Floating asinh (Double), _CONSTM_ Floating acosh (Double), _CONSTM_ Floating atanh (Double)] _N_
- pi = _A_ 0 _N_ _N_ _N_ _F_ _IF_ARGS_ 0 0 X 2 _!_ D# [] [3.1415926535897931##] _N_,
- exp = _A_ 1 _U_ 1 _N_ _S_ "U(P)" {_A_ 1 _U_ 2 _N_ _N_ _F_ _IF_ARGS_ 0 1 X 3 \ (u0 :: Double#) -> case _#_ expDouble# [] [u0] of { _PRIM_ (u1 :: Double#) -> _!_ D# [] [u1] } _N_} _F_ _IF_ARGS_ 0 1 C 4 \ (u0 :: Double) -> case u0 of { _ALG_ D# (u1 :: Double#) -> case _#_ expDouble# [] [u1] of { _PRIM_ (u2 :: Double#) -> _!_ D# [] [u2] }; _NO_DEFLT_ } _N_,
- log = _A_ 1 _U_ 1 _N_ _S_ "U(P)" {_A_ 1 _U_ 2 _N_ _N_ _F_ _IF_ARGS_ 0 1 X 3 \ (u0 :: Double#) -> case _#_ logDouble# [] [u0] of { _PRIM_ (u1 :: Double#) -> _!_ D# [] [u1] } _N_} _F_ _IF_ARGS_ 0 1 C 4 \ (u0 :: Double) -> case u0 of { _ALG_ D# (u1 :: Double#) -> case _#_ logDouble# [] [u1] of { _PRIM_ (u2 :: Double#) -> _!_ D# [] [u2] }; _NO_DEFLT_ } _N_,
- sqrt = _A_ 1 _U_ 1 _N_ _S_ "U(P)" {_A_ 1 _U_ 2 _N_ _N_ _F_ _IF_ARGS_ 0 1 X 3 \ (u0 :: Double#) -> case _#_ sqrtDouble# [] [u0] of { _PRIM_ (u1 :: Double#) -> _!_ D# [] [u1] } _N_} _F_ _IF_ARGS_ 0 1 C 4 \ (u0 :: Double) -> case u0 of { _ALG_ D# (u1 :: Double#) -> case _#_ sqrtDouble# [] [u1] of { _PRIM_ (u2 :: Double#) -> _!_ D# [] [u2] }; _NO_DEFLT_ } _N_,
- (**) = _A_ 2 _U_ 11 _N_ _S_ "U(P)U(P)" {_A_ 2 _U_ 22 _N_ _N_ _F_ _IF_ARGS_ 0 2 XX 3 \ (u0 :: Double#) (u1 :: Double#) -> case _#_ powerDouble# [] [u0, u1] of { _PRIM_ (u2 :: Double#) -> _!_ D# [] [u2] } _N_} _F_ _IF_ARGS_ 0 2 CC 5 \ (u0 :: Double) (u1 :: Double) -> case u0 of { _ALG_ D# (u2 :: Double#) -> case u1 of { _ALG_ D# (u3 :: Double#) -> case _#_ powerDouble# [] [u2, u3] of { _PRIM_ (u4 :: Double#) -> _!_ D# [] [u4] }; _NO_DEFLT_ }; _NO_DEFLT_ } _N_,
- logBase = _A_ 2 _U_ 11 _N_ _S_ "U(P)U(P)" {_A_ 2 _U_ 22 _N_ _N_ _F_ _IF_ARGS_ 0 2 XX 5 \ (u0 :: Double#) (u1 :: Double#) -> case _#_ logDouble# [] [u1] of { _PRIM_ (u2 :: Double#) -> case _#_ logDouble# [] [u0] of { _PRIM_ (u3 :: Double#) -> case _#_ divideDouble# [] [u2, u3] of { _PRIM_ (u4 :: Double#) -> _!_ D# [] [u4] } } } _N_} _F_ _IF_ARGS_ 0 2 CC 7 \ (u0 :: Double) (u1 :: Double) -> case u1 of { _ALG_ D# (u2 :: Double#) -> case _#_ logDouble# [] [u2] of { _PRIM_ (u3 :: Double#) -> case u0 of { _ALG_ D# (u4 :: Double#) -> case _#_ logDouble# [] [u4] of { _PRIM_ (u5 :: Double#) -> case _#_ divideDouble# [] [u3, u5] of { _PRIM_ (u6 :: Double#) -> _!_ D# [] [u6] } }; _NO_DEFLT_ } }; _NO_DEFLT_ } _N_,
- sin = _A_ 1 _U_ 1 _N_ _S_ "U(P)" {_A_ 1 _U_ 2 _N_ _N_ _F_ _IF_ARGS_ 0 1 X 3 \ (u0 :: Double#) -> case _#_ sinDouble# [] [u0] of { _PRIM_ (u1 :: Double#) -> _!_ D# [] [u1] } _N_} _F_ _IF_ARGS_ 0 1 C 4 \ (u0 :: Double) -> case u0 of { _ALG_ D# (u1 :: Double#) -> case _#_ sinDouble# [] [u1] of { _PRIM_ (u2 :: Double#) -> _!_ D# [] [u2] }; _NO_DEFLT_ } _N_,
- cos = _A_ 1 _U_ 1 _N_ _S_ "U(P)" {_A_ 1 _U_ 2 _N_ _N_ _F_ _IF_ARGS_ 0 1 X 3 \ (u0 :: Double#) -> case _#_ cosDouble# [] [u0] of { _PRIM_ (u1 :: Double#) -> _!_ D# [] [u1] } _N_} _F_ _IF_ARGS_ 0 1 C 4 \ (u0 :: Double) -> case u0 of { _ALG_ D# (u1 :: Double#) -> case _#_ cosDouble# [] [u1] of { _PRIM_ (u2 :: Double#) -> _!_ D# [] [u2] }; _NO_DEFLT_ } _N_,
- tan = _A_ 1 _U_ 1 _N_ _S_ "U(P)" {_A_ 1 _U_ 2 _N_ _N_ _F_ _IF_ARGS_ 0 1 X 3 \ (u0 :: Double#) -> case _#_ tanDouble# [] [u0] of { _PRIM_ (u1 :: Double#) -> _!_ D# [] [u1] } _N_} _F_ _IF_ARGS_ 0 1 C 4 \ (u0 :: Double) -> case u0 of { _ALG_ D# (u1 :: Double#) -> case _#_ tanDouble# [] [u1] of { _PRIM_ (u2 :: Double#) -> _!_ D# [] [u2] }; _NO_DEFLT_ } _N_,
- asin = _A_ 1 _U_ 1 _N_ _S_ "U(P)" {_A_ 1 _U_ 2 _N_ _N_ _F_ _IF_ARGS_ 0 1 X 3 \ (u0 :: Double#) -> case _#_ asinDouble# [] [u0] of { _PRIM_ (u1 :: Double#) -> _!_ D# [] [u1] } _N_} _F_ _IF_ARGS_ 0 1 C 4 \ (u0 :: Double) -> case u0 of { _ALG_ D# (u1 :: Double#) -> case _#_ asinDouble# [] [u1] of { _PRIM_ (u2 :: Double#) -> _!_ D# [] [u2] }; _NO_DEFLT_ } _N_,
- acos = _A_ 1 _U_ 1 _N_ _S_ "U(P)" {_A_ 1 _U_ 2 _N_ _N_ _F_ _IF_ARGS_ 0 1 X 3 \ (u0 :: Double#) -> case _#_ acosDouble# [] [u0] of { _PRIM_ (u1 :: Double#) -> _!_ D# [] [u1] } _N_} _F_ _IF_ARGS_ 0 1 C 4 \ (u0 :: Double) -> case u0 of { _ALG_ D# (u1 :: Double#) -> case _#_ acosDouble# [] [u1] of { _PRIM_ (u2 :: Double#) -> _!_ D# [] [u2] }; _NO_DEFLT_ } _N_,
- atan = _A_ 1 _U_ 1 _N_ _S_ "U(P)" {_A_ 1 _U_ 2 _N_ _N_ _F_ _IF_ARGS_ 0 1 X 3 \ (u0 :: Double#) -> case _#_ atanDouble# [] [u0] of { _PRIM_ (u1 :: Double#) -> _!_ D# [] [u1] } _N_} _F_ _IF_ARGS_ 0 1 C 4 \ (u0 :: Double) -> case u0 of { _ALG_ D# (u1 :: Double#) -> case _#_ atanDouble# [] [u1] of { _PRIM_ (u2 :: Double#) -> _!_ D# [] [u2] }; _NO_DEFLT_ } _N_,
- sinh = _A_ 1 _U_ 1 _N_ _S_ "U(P)" {_A_ 1 _U_ 2 _N_ _N_ _F_ _IF_ARGS_ 0 1 X 3 \ (u0 :: Double#) -> case _#_ sinhDouble# [] [u0] of { _PRIM_ (u1 :: Double#) -> _!_ D# [] [u1] } _N_} _F_ _IF_ARGS_ 0 1 C 4 \ (u0 :: Double) -> case u0 of { _ALG_ D# (u1 :: Double#) -> case _#_ sinhDouble# [] [u1] of { _PRIM_ (u2 :: Double#) -> _!_ D# [] [u2] }; _NO_DEFLT_ } _N_,
- cosh = _A_ 1 _U_ 1 _N_ _S_ "U(P)" {_A_ 1 _U_ 2 _N_ _N_ _F_ _IF_ARGS_ 0 1 X 3 \ (u0 :: Double#) -> case _#_ coshDouble# [] [u0] of { _PRIM_ (u1 :: Double#) -> _!_ D# [] [u1] } _N_} _F_ _IF_ARGS_ 0 1 C 4 \ (u0 :: Double) -> case u0 of { _ALG_ D# (u1 :: Double#) -> case _#_ coshDouble# [] [u1] of { _PRIM_ (u2 :: Double#) -> _!_ D# [] [u2] }; _NO_DEFLT_ } _N_,
- tanh = _A_ 1 _U_ 1 _N_ _S_ "U(P)" {_A_ 1 _U_ 2 _N_ _N_ _F_ _IF_ARGS_ 0 1 X 3 \ (u0 :: Double#) -> case _#_ tanhDouble# [] [u0] of { _PRIM_ (u1 :: Double#) -> _!_ D# [] [u1] } _N_} _F_ _IF_ARGS_ 0 1 C 4 \ (u0 :: Double) -> case u0 of { _ALG_ D# (u1 :: Double#) -> case _#_ tanhDouble# [] [u1] of { _PRIM_ (u2 :: Double#) -> _!_ D# [] [u2] }; _NO_DEFLT_ } _N_,
- asinh = _A_ 1 _U_ 1 _N_ _S_ "U(P)" {_A_ 1 _U_ 2 _N_ _N_ _N_ _N_} _N_ _N_,
- acosh = _A_ 1 _U_ 1 _N_ _S_ "U(P)" {_A_ 1 _U_ 2 _N_ _N_ _N_ _N_} _N_ _N_,
- atanh = _A_ 1 _U_ 1 _N_ _S_ "U(P)" {_A_ 1 _U_ 2 _N_ _N_ _N_ _N_} _N_ _N_ #-}
+ pi = { _A_ 0 _N_ _N_ _N_ _F_ _IF_ARGS_ 0 0 X 2 _!_ D# [] [3.1415926535897931##] _N_ },
+ exp = { _A_ 1 _U_ 1 _N_ _S_ "U(P)" {_A_ 1 _U_ 2 _N_ _N_ _F_ _IF_ARGS_ 0 1 X 3 \ (u0 :: Double#) -> case _#_ expDouble# [] [u0] of { _PRIM_ (u1 :: Double#) -> _!_ D# [] [u1] } _N_} _F_ _IF_ARGS_ 0 1 C 4 \ (u0 :: Double) -> case u0 of { _ALG_ D# (u1 :: Double#) -> case _#_ expDouble# [] [u1] of { _PRIM_ (u2 :: Double#) -> _!_ D# [] [u2] }; _NO_DEFLT_ } _N_ },
+ log = { _A_ 1 _U_ 1 _N_ _S_ "U(P)" {_A_ 1 _U_ 2 _N_ _N_ _F_ _IF_ARGS_ 0 1 X 3 \ (u0 :: Double#) -> case _#_ logDouble# [] [u0] of { _PRIM_ (u1 :: Double#) -> _!_ D# [] [u1] } _N_} _F_ _IF_ARGS_ 0 1 C 4 \ (u0 :: Double) -> case u0 of { _ALG_ D# (u1 :: Double#) -> case _#_ logDouble# [] [u1] of { _PRIM_ (u2 :: Double#) -> _!_ D# [] [u2] }; _NO_DEFLT_ } _N_ },
+ sqrt = { _A_ 1 _U_ 1 _N_ _S_ "U(P)" {_A_ 1 _U_ 2 _N_ _N_ _F_ _IF_ARGS_ 0 1 X 3 \ (u0 :: Double#) -> case _#_ sqrtDouble# [] [u0] of { _PRIM_ (u1 :: Double#) -> _!_ D# [] [u1] } _N_} _F_ _IF_ARGS_ 0 1 C 4 \ (u0 :: Double) -> case u0 of { _ALG_ D# (u1 :: Double#) -> case _#_ sqrtDouble# [] [u1] of { _PRIM_ (u2 :: Double#) -> _!_ D# [] [u2] }; _NO_DEFLT_ } _N_ },
+ (**) = { _A_ 2 _U_ 11 _N_ _S_ "U(P)U(P)" {_A_ 2 _U_ 22 _N_ _N_ _F_ _IF_ARGS_ 0 2 XX 3 \ (u0 :: Double#) (u1 :: Double#) -> case _#_ powerDouble# [] [u0, u1] of { _PRIM_ (u2 :: Double#) -> _!_ D# [] [u2] } _N_} _F_ _IF_ARGS_ 0 2 CC 5 \ (u0 :: Double) (u1 :: Double) -> case u0 of { _ALG_ D# (u2 :: Double#) -> case u1 of { _ALG_ D# (u3 :: Double#) -> case _#_ powerDouble# [] [u2, u3] of { _PRIM_ (u4 :: Double#) -> _!_ D# [] [u4] }; _NO_DEFLT_ }; _NO_DEFLT_ } _N_ },
+ logBase = { _A_ 2 _U_ 11 _N_ _S_ "U(P)U(P)" {_A_ 2 _U_ 22 _N_ _N_ _F_ _IF_ARGS_ 0 2 XX 5 \ (u0 :: Double#) (u1 :: Double#) -> case _#_ logDouble# [] [u1] of { _PRIM_ (u2 :: Double#) -> case _#_ logDouble# [] [u0] of { _PRIM_ (u3 :: Double#) -> case _#_ divideDouble# [] [u2, u3] of { _PRIM_ (u4 :: Double#) -> _!_ D# [] [u4] } } } _N_} _F_ _IF_ARGS_ 0 2 CC 7 \ (u0 :: Double) (u1 :: Double) -> case u1 of { _ALG_ D# (u2 :: Double#) -> case _#_ logDouble# [] [u2] of { _PRIM_ (u3 :: Double#) -> case u0 of { _ALG_ D# (u4 :: Double#) -> case _#_ logDouble# [] [u4] of { _PRIM_ (u5 :: Double#) -> case _#_ divideDouble# [] [u3, u5] of { _PRIM_ (u6 :: Double#) -> _!_ D# [] [u6] } }; _NO_DEFLT_ } }; _NO_DEFLT_ } _N_ },
+ sin = { _A_ 1 _U_ 1 _N_ _S_ "U(P)" {_A_ 1 _U_ 2 _N_ _N_ _F_ _IF_ARGS_ 0 1 X 3 \ (u0 :: Double#) -> case _#_ sinDouble# [] [u0] of { _PRIM_ (u1 :: Double#) -> _!_ D# [] [u1] } _N_} _F_ _IF_ARGS_ 0 1 C 4 \ (u0 :: Double) -> case u0 of { _ALG_ D# (u1 :: Double#) -> case _#_ sinDouble# [] [u1] of { _PRIM_ (u2 :: Double#) -> _!_ D# [] [u2] }; _NO_DEFLT_ } _N_ },
+ cos = { _A_ 1 _U_ 1 _N_ _S_ "U(P)" {_A_ 1 _U_ 2 _N_ _N_ _F_ _IF_ARGS_ 0 1 X 3 \ (u0 :: Double#) -> case _#_ cosDouble# [] [u0] of { _PRIM_ (u1 :: Double#) -> _!_ D# [] [u1] } _N_} _F_ _IF_ARGS_ 0 1 C 4 \ (u0 :: Double) -> case u0 of { _ALG_ D# (u1 :: Double#) -> case _#_ cosDouble# [] [u1] of { _PRIM_ (u2 :: Double#) -> _!_ D# [] [u2] }; _NO_DEFLT_ } _N_ },
+ tan = { _A_ 1 _U_ 1 _N_ _S_ "U(P)" {_A_ 1 _U_ 2 _N_ _N_ _F_ _IF_ARGS_ 0 1 X 3 \ (u0 :: Double#) -> case _#_ tanDouble# [] [u0] of { _PRIM_ (u1 :: Double#) -> _!_ D# [] [u1] } _N_} _F_ _IF_ARGS_ 0 1 C 4 \ (u0 :: Double) -> case u0 of { _ALG_ D# (u1 :: Double#) -> case _#_ tanDouble# [] [u1] of { _PRIM_ (u2 :: Double#) -> _!_ D# [] [u2] }; _NO_DEFLT_ } _N_ },
+ asin = { _A_ 1 _U_ 1 _N_ _S_ "U(P)" {_A_ 1 _U_ 2 _N_ _N_ _F_ _IF_ARGS_ 0 1 X 3 \ (u0 :: Double#) -> case _#_ asinDouble# [] [u0] of { _PRIM_ (u1 :: Double#) -> _!_ D# [] [u1] } _N_} _F_ _IF_ARGS_ 0 1 C 4 \ (u0 :: Double) -> case u0 of { _ALG_ D# (u1 :: Double#) -> case _#_ asinDouble# [] [u1] of { _PRIM_ (u2 :: Double#) -> _!_ D# [] [u2] }; _NO_DEFLT_ } _N_ },
+ acos = { _A_ 1 _U_ 1 _N_ _S_ "U(P)" {_A_ 1 _U_ 2 _N_ _N_ _F_ _IF_ARGS_ 0 1 X 3 \ (u0 :: Double#) -> case _#_ acosDouble# [] [u0] of { _PRIM_ (u1 :: Double#) -> _!_ D# [] [u1] } _N_} _F_ _IF_ARGS_ 0 1 C 4 \ (u0 :: Double) -> case u0 of { _ALG_ D# (u1 :: Double#) -> case _#_ acosDouble# [] [u1] of { _PRIM_ (u2 :: Double#) -> _!_ D# [] [u2] }; _NO_DEFLT_ } _N_ },
+ atan = { _A_ 1 _U_ 1 _N_ _S_ "U(P)" {_A_ 1 _U_ 2 _N_ _N_ _F_ _IF_ARGS_ 0 1 X 3 \ (u0 :: Double#) -> case _#_ atanDouble# [] [u0] of { _PRIM_ (u1 :: Double#) -> _!_ D# [] [u1] } _N_} _F_ _IF_ARGS_ 0 1 C 4 \ (u0 :: Double) -> case u0 of { _ALG_ D# (u1 :: Double#) -> case _#_ atanDouble# [] [u1] of { _PRIM_ (u2 :: Double#) -> _!_ D# [] [u2] }; _NO_DEFLT_ } _N_ },
+ sinh = { _A_ 1 _U_ 1 _N_ _S_ "U(P)" {_A_ 1 _U_ 2 _N_ _N_ _F_ _IF_ARGS_ 0 1 X 3 \ (u0 :: Double#) -> case _#_ sinhDouble# [] [u0] of { _PRIM_ (u1 :: Double#) -> _!_ D# [] [u1] } _N_} _F_ _IF_ARGS_ 0 1 C 4 \ (u0 :: Double) -> case u0 of { _ALG_ D# (u1 :: Double#) -> case _#_ sinhDouble# [] [u1] of { _PRIM_ (u2 :: Double#) -> _!_ D# [] [u2] }; _NO_DEFLT_ } _N_ },
+ cosh = { _A_ 1 _U_ 1 _N_ _S_ "U(P)" {_A_ 1 _U_ 2 _N_ _N_ _F_ _IF_ARGS_ 0 1 X 3 \ (u0 :: Double#) -> case _#_ coshDouble# [] [u0] of { _PRIM_ (u1 :: Double#) -> _!_ D# [] [u1] } _N_} _F_ _IF_ARGS_ 0 1 C 4 \ (u0 :: Double) -> case u0 of { _ALG_ D# (u1 :: Double#) -> case _#_ coshDouble# [] [u1] of { _PRIM_ (u2 :: Double#) -> _!_ D# [] [u2] }; _NO_DEFLT_ } _N_ },
+ tanh = { _A_ 1 _U_ 1 _N_ _S_ "U(P)" {_A_ 1 _U_ 2 _N_ _N_ _F_ _IF_ARGS_ 0 1 X 3 \ (u0 :: Double#) -> case _#_ tanhDouble# [] [u0] of { _PRIM_ (u1 :: Double#) -> _!_ D# [] [u1] } _N_} _F_ _IF_ARGS_ 0 1 C 4 \ (u0 :: Double) -> case u0 of { _ALG_ D# (u1 :: Double#) -> case _#_ tanhDouble# [] [u1] of { _PRIM_ (u2 :: Double#) -> _!_ D# [] [u2] }; _NO_DEFLT_ } _N_ },
+ asinh = { _A_ 1 _U_ 1 _N_ _S_ "U(P)" {_A_ 1 _U_ 2 _N_ _N_ _N_ _N_} _N_ _N_ },
+ acosh = { _A_ 1 _U_ 1 _N_ _S_ "U(P)" {_A_ 1 _U_ 2 _N_ _N_ _N_ _N_} _N_ _N_ },
+ atanh = { _A_ 1 _U_ 1 _N_ _S_ "U(P)" {_A_ 1 _U_ 2 _N_ _N_ _N_ _N_} _N_ _N_ } #-}
instance Floating Float
{-# GHC_PRAGMA _M_ PreludeCore {-dfun-} _A_ 0 _N_ _N_ _N_ _F_ _IF_ARGS_ 0 0 X 20 _!_ _TUP_19 [{{Fractional Float}}, Float, (Float -> Float), (Float -> Float), (Float -> Float), (Float -> Float -> Float), (Float -> Float -> Float), (Float -> Float), (Float -> Float), (Float -> Float), (Float -> Float), (Float -> Float), (Float -> Float), (Float -> Float), (Float -> Float), (Float -> Float), (Float -> Float), (Float -> Float), (Float -> Float)] [_DFUN_ Fractional (Float), _CONSTM_ Floating pi (Float), _CONSTM_ Floating exp (Float), _CONSTM_ Floating log (Float), _CONSTM_ Floating sqrt (Float), _CONSTM_ Floating (**) (Float), _CONSTM_ Floating logBase (Float), _CONSTM_ Floating sin (Float), _CONSTM_ Floating cos (Float), _CONSTM_ Floating tan (Float), _CONSTM_ Floating asin (Float), _CONSTM_ Floating acos (Float), _CONSTM_ Floating atan (Float), _CONSTM_ Floating sinh (Float), _CONSTM_ Floating cosh (Float), _CONSTM_ Floating tanh (Float), _CONSTM_ Floating asinh (Float), _CONSTM_ Floating acosh (Float), _CONSTM_ Floating atanh (Float)] _N_
- pi = _A_ 0 _N_ _N_ _N_ _F_ _IF_ARGS_ 0 0 X 2 _!_ F# [] [3.1415926535897931#] _N_,
- exp = _A_ 1 _U_ 1 _N_ _S_ "U(P)" {_A_ 1 _U_ 2 _N_ _N_ _F_ _IF_ARGS_ 0 1 X 3 \ (u0 :: Float#) -> case _#_ expFloat# [] [u0] of { _PRIM_ (u1 :: Float#) -> _!_ F# [] [u1] } _N_} _F_ _IF_ARGS_ 0 1 C 4 \ (u0 :: Float) -> case u0 of { _ALG_ F# (u1 :: Float#) -> case _#_ expFloat# [] [u1] of { _PRIM_ (u2 :: Float#) -> _!_ F# [] [u2] }; _NO_DEFLT_ } _N_,
- log = _A_ 1 _U_ 1 _N_ _S_ "U(P)" {_A_ 1 _U_ 2 _N_ _N_ _F_ _IF_ARGS_ 0 1 X 3 \ (u0 :: Float#) -> case _#_ logFloat# [] [u0] of { _PRIM_ (u1 :: Float#) -> _!_ F# [] [u1] } _N_} _F_ _IF_ARGS_ 0 1 C 4 \ (u0 :: Float) -> case u0 of { _ALG_ F# (u1 :: Float#) -> case _#_ logFloat# [] [u1] of { _PRIM_ (u2 :: Float#) -> _!_ F# [] [u2] }; _NO_DEFLT_ } _N_,
- sqrt = _A_ 1 _U_ 1 _N_ _S_ "U(P)" {_A_ 1 _U_ 2 _N_ _N_ _F_ _IF_ARGS_ 0 1 X 3 \ (u0 :: Float#) -> case _#_ sqrtFloat# [] [u0] of { _PRIM_ (u1 :: Float#) -> _!_ F# [] [u1] } _N_} _F_ _IF_ARGS_ 0 1 C 4 \ (u0 :: Float) -> case u0 of { _ALG_ F# (u1 :: Float#) -> case _#_ sqrtFloat# [] [u1] of { _PRIM_ (u2 :: Float#) -> _!_ F# [] [u2] }; _NO_DEFLT_ } _N_,
- (**) = _A_ 2 _U_ 11 _N_ _S_ "U(P)U(P)" {_A_ 2 _U_ 22 _N_ _N_ _F_ _IF_ARGS_ 0 2 XX 3 \ (u0 :: Float#) (u1 :: Float#) -> case _#_ powerFloat# [] [u0, u1] of { _PRIM_ (u2 :: Float#) -> _!_ F# [] [u2] } _N_} _F_ _IF_ARGS_ 0 2 CC 5 \ (u0 :: Float) (u1 :: Float) -> case u0 of { _ALG_ F# (u2 :: Float#) -> case u1 of { _ALG_ F# (u3 :: Float#) -> case _#_ powerFloat# [] [u2, u3] of { _PRIM_ (u4 :: Float#) -> _!_ F# [] [u4] }; _NO_DEFLT_ }; _NO_DEFLT_ } _N_,
- logBase = _A_ 2 _U_ 22 _N_ _N_ _N_ _N_,
- sin = _A_ 1 _U_ 1 _N_ _S_ "U(P)" {_A_ 1 _U_ 2 _N_ _N_ _F_ _IF_ARGS_ 0 1 X 3 \ (u0 :: Float#) -> case _#_ sinFloat# [] [u0] of { _PRIM_ (u1 :: Float#) -> _!_ F# [] [u1] } _N_} _F_ _IF_ARGS_ 0 1 C 4 \ (u0 :: Float) -> case u0 of { _ALG_ F# (u1 :: Float#) -> case _#_ sinFloat# [] [u1] of { _PRIM_ (u2 :: Float#) -> _!_ F# [] [u2] }; _NO_DEFLT_ } _N_,
- cos = _A_ 1 _U_ 1 _N_ _S_ "U(P)" {_A_ 1 _U_ 2 _N_ _N_ _F_ _IF_ARGS_ 0 1 X 3 \ (u0 :: Float#) -> case _#_ cosFloat# [] [u0] of { _PRIM_ (u1 :: Float#) -> _!_ F# [] [u1] } _N_} _F_ _IF_ARGS_ 0 1 C 4 \ (u0 :: Float) -> case u0 of { _ALG_ F# (u1 :: Float#) -> case _#_ cosFloat# [] [u1] of { _PRIM_ (u2 :: Float#) -> _!_ F# [] [u2] }; _NO_DEFLT_ } _N_,
- tan = _A_ 1 _U_ 1 _N_ _S_ "U(P)" {_A_ 1 _U_ 2 _N_ _N_ _F_ _IF_ARGS_ 0 1 X 3 \ (u0 :: Float#) -> case _#_ tanFloat# [] [u0] of { _PRIM_ (u1 :: Float#) -> _!_ F# [] [u1] } _N_} _F_ _IF_ARGS_ 0 1 C 4 \ (u0 :: Float) -> case u0 of { _ALG_ F# (u1 :: Float#) -> case _#_ tanFloat# [] [u1] of { _PRIM_ (u2 :: Float#) -> _!_ F# [] [u2] }; _NO_DEFLT_ } _N_,
- asin = _A_ 1 _U_ 1 _N_ _S_ "U(P)" {_A_ 1 _U_ 2 _N_ _N_ _F_ _IF_ARGS_ 0 1 X 3 \ (u0 :: Float#) -> case _#_ asinFloat# [] [u0] of { _PRIM_ (u1 :: Float#) -> _!_ F# [] [u1] } _N_} _F_ _IF_ARGS_ 0 1 C 4 \ (u0 :: Float) -> case u0 of { _ALG_ F# (u1 :: Float#) -> case _#_ asinFloat# [] [u1] of { _PRIM_ (u2 :: Float#) -> _!_ F# [] [u2] }; _NO_DEFLT_ } _N_,
- acos = _A_ 1 _U_ 1 _N_ _S_ "U(P)" {_A_ 1 _U_ 2 _N_ _N_ _F_ _IF_ARGS_ 0 1 X 3 \ (u0 :: Float#) -> case _#_ acosFloat# [] [u0] of { _PRIM_ (u1 :: Float#) -> _!_ F# [] [u1] } _N_} _F_ _IF_ARGS_ 0 1 C 4 \ (u0 :: Float) -> case u0 of { _ALG_ F# (u1 :: Float#) -> case _#_ acosFloat# [] [u1] of { _PRIM_ (u2 :: Float#) -> _!_ F# [] [u2] }; _NO_DEFLT_ } _N_,
- atan = _A_ 1 _U_ 1 _N_ _S_ "U(P)" {_A_ 1 _U_ 2 _N_ _N_ _F_ _IF_ARGS_ 0 1 X 3 \ (u0 :: Float#) -> case _#_ atanFloat# [] [u0] of { _PRIM_ (u1 :: Float#) -> _!_ F# [] [u1] } _N_} _F_ _IF_ARGS_ 0 1 C 4 \ (u0 :: Float) -> case u0 of { _ALG_ F# (u1 :: Float#) -> case _#_ atanFloat# [] [u1] of { _PRIM_ (u2 :: Float#) -> _!_ F# [] [u2] }; _NO_DEFLT_ } _N_,
- sinh = _A_ 1 _U_ 1 _N_ _S_ "U(P)" {_A_ 1 _U_ 2 _N_ _N_ _F_ _IF_ARGS_ 0 1 X 3 \ (u0 :: Float#) -> case _#_ sinhFloat# [] [u0] of { _PRIM_ (u1 :: Float#) -> _!_ F# [] [u1] } _N_} _F_ _IF_ARGS_ 0 1 C 4 \ (u0 :: Float) -> case u0 of { _ALG_ F# (u1 :: Float#) -> case _#_ sinhFloat# [] [u1] of { _PRIM_ (u2 :: Float#) -> _!_ F# [] [u2] }; _NO_DEFLT_ } _N_,
- cosh = _A_ 1 _U_ 1 _N_ _S_ "U(P)" {_A_ 1 _U_ 2 _N_ _N_ _F_ _IF_ARGS_ 0 1 X 3 \ (u0 :: Float#) -> case _#_ coshFloat# [] [u0] of { _PRIM_ (u1 :: Float#) -> _!_ F# [] [u1] } _N_} _F_ _IF_ARGS_ 0 1 C 4 \ (u0 :: Float) -> case u0 of { _ALG_ F# (u1 :: Float#) -> case _#_ coshFloat# [] [u1] of { _PRIM_ (u2 :: Float#) -> _!_ F# [] [u2] }; _NO_DEFLT_ } _N_,
- tanh = _A_ 1 _U_ 1 _N_ _S_ "U(P)" {_A_ 1 _U_ 2 _N_ _N_ _F_ _IF_ARGS_ 0 1 X 3 \ (u0 :: Float#) -> case _#_ tanhFloat# [] [u0] of { _PRIM_ (u1 :: Float#) -> _!_ F# [] [u1] } _N_} _F_ _IF_ARGS_ 0 1 C 4 \ (u0 :: Float) -> case u0 of { _ALG_ F# (u1 :: Float#) -> case _#_ tanhFloat# [] [u1] of { _PRIM_ (u2 :: Float#) -> _!_ F# [] [u2] }; _NO_DEFLT_ } _N_,
- asinh = _A_ 1 _U_ 1 _N_ _S_ "U(P)" {_A_ 1 _U_ 2 _N_ _N_ _N_ _N_} _N_ _N_,
- acosh = _A_ 1 _U_ 1 _N_ _S_ "U(P)" {_A_ 1 _U_ 2 _N_ _N_ _N_ _N_} _N_ _N_,
- atanh = _A_ 1 _U_ 1 _N_ _S_ "U(P)" {_A_ 1 _U_ 2 _N_ _N_ _N_ _N_} _N_ _N_ #-}
+ pi = { _A_ 0 _N_ _N_ _N_ _F_ _IF_ARGS_ 0 0 X 2 _!_ F# [] [3.1415926535897931#] _N_ },
+ exp = { _A_ 1 _U_ 1 _N_ _S_ "U(P)" {_A_ 1 _U_ 2 _N_ _N_ _F_ _IF_ARGS_ 0 1 X 3 \ (u0 :: Float#) -> case _#_ expFloat# [] [u0] of { _PRIM_ (u1 :: Float#) -> _!_ F# [] [u1] } _N_} _F_ _IF_ARGS_ 0 1 C 4 \ (u0 :: Float) -> case u0 of { _ALG_ F# (u1 :: Float#) -> case _#_ expFloat# [] [u1] of { _PRIM_ (u2 :: Float#) -> _!_ F# [] [u2] }; _NO_DEFLT_ } _N_ },
+ log = { _A_ 1 _U_ 1 _N_ _S_ "U(P)" {_A_ 1 _U_ 2 _N_ _N_ _F_ _IF_ARGS_ 0 1 X 3 \ (u0 :: Float#) -> case _#_ logFloat# [] [u0] of { _PRIM_ (u1 :: Float#) -> _!_ F# [] [u1] } _N_} _F_ _IF_ARGS_ 0 1 C 4 \ (u0 :: Float) -> case u0 of { _ALG_ F# (u1 :: Float#) -> case _#_ logFloat# [] [u1] of { _PRIM_ (u2 :: Float#) -> _!_ F# [] [u2] }; _NO_DEFLT_ } _N_ },
+ sqrt = { _A_ 1 _U_ 1 _N_ _S_ "U(P)" {_A_ 1 _U_ 2 _N_ _N_ _F_ _IF_ARGS_ 0 1 X 3 \ (u0 :: Float#) -> case _#_ sqrtFloat# [] [u0] of { _PRIM_ (u1 :: Float#) -> _!_ F# [] [u1] } _N_} _F_ _IF_ARGS_ 0 1 C 4 \ (u0 :: Float) -> case u0 of { _ALG_ F# (u1 :: Float#) -> case _#_ sqrtFloat# [] [u1] of { _PRIM_ (u2 :: Float#) -> _!_ F# [] [u2] }; _NO_DEFLT_ } _N_ },
+ (**) = { _A_ 2 _U_ 11 _N_ _S_ "U(P)U(P)" {_A_ 2 _U_ 22 _N_ _N_ _F_ _IF_ARGS_ 0 2 XX 3 \ (u0 :: Float#) (u1 :: Float#) -> case _#_ powerFloat# [] [u0, u1] of { _PRIM_ (u2 :: Float#) -> _!_ F# [] [u2] } _N_} _F_ _IF_ARGS_ 0 2 CC 5 \ (u0 :: Float) (u1 :: Float) -> case u0 of { _ALG_ F# (u2 :: Float#) -> case u1 of { _ALG_ F# (u3 :: Float#) -> case _#_ powerFloat# [] [u2, u3] of { _PRIM_ (u4 :: Float#) -> _!_ F# [] [u4] }; _NO_DEFLT_ }; _NO_DEFLT_ } _N_ },
+ logBase = { _A_ 2 _U_ 11 _N_ _S_ "U(P)U(P)" {_A_ 2 _U_ 22 _N_ _N_ _F_ _IF_ARGS_ 0 2 XX 5 \ (u0 :: Float#) (u1 :: Float#) -> case _#_ logFloat# [] [u1] of { _PRIM_ (u2 :: Float#) -> case _#_ logFloat# [] [u0] of { _PRIM_ (u3 :: Float#) -> case _#_ divideFloat# [] [u2, u3] of { _PRIM_ (u4 :: Float#) -> _!_ F# [] [u4] } } } _N_} _F_ _IF_ARGS_ 0 2 CC 7 \ (u0 :: Float) (u1 :: Float) -> case u1 of { _ALG_ F# (u2 :: Float#) -> case _#_ logFloat# [] [u2] of { _PRIM_ (u3 :: Float#) -> case u0 of { _ALG_ F# (u4 :: Float#) -> case _#_ logFloat# [] [u4] of { _PRIM_ (u5 :: Float#) -> case _#_ divideFloat# [] [u3, u5] of { _PRIM_ (u6 :: Float#) -> _!_ F# [] [u6] } }; _NO_DEFLT_ } }; _NO_DEFLT_ } _N_ },
+ sin = { _A_ 1 _U_ 1 _N_ _S_ "U(P)" {_A_ 1 _U_ 2 _N_ _N_ _F_ _IF_ARGS_ 0 1 X 3 \ (u0 :: Float#) -> case _#_ sinFloat# [] [u0] of { _PRIM_ (u1 :: Float#) -> _!_ F# [] [u1] } _N_} _F_ _IF_ARGS_ 0 1 C 4 \ (u0 :: Float) -> case u0 of { _ALG_ F# (u1 :: Float#) -> case _#_ sinFloat# [] [u1] of { _PRIM_ (u2 :: Float#) -> _!_ F# [] [u2] }; _NO_DEFLT_ } _N_ },
+ cos = { _A_ 1 _U_ 1 _N_ _S_ "U(P)" {_A_ 1 _U_ 2 _N_ _N_ _F_ _IF_ARGS_ 0 1 X 3 \ (u0 :: Float#) -> case _#_ cosFloat# [] [u0] of { _PRIM_ (u1 :: Float#) -> _!_ F# [] [u1] } _N_} _F_ _IF_ARGS_ 0 1 C 4 \ (u0 :: Float) -> case u0 of { _ALG_ F# (u1 :: Float#) -> case _#_ cosFloat# [] [u1] of { _PRIM_ (u2 :: Float#) -> _!_ F# [] [u2] }; _NO_DEFLT_ } _N_ },
+ tan = { _A_ 1 _U_ 1 _N_ _S_ "U(P)" {_A_ 1 _U_ 2 _N_ _N_ _F_ _IF_ARGS_ 0 1 X 3 \ (u0 :: Float#) -> case _#_ tanFloat# [] [u0] of { _PRIM_ (u1 :: Float#) -> _!_ F# [] [u1] } _N_} _F_ _IF_ARGS_ 0 1 C 4 \ (u0 :: Float) -> case u0 of { _ALG_ F# (u1 :: Float#) -> case _#_ tanFloat# [] [u1] of { _PRIM_ (u2 :: Float#) -> _!_ F# [] [u2] }; _NO_DEFLT_ } _N_ },
+ asin = { _A_ 1 _U_ 1 _N_ _S_ "U(P)" {_A_ 1 _U_ 2 _N_ _N_ _F_ _IF_ARGS_ 0 1 X 3 \ (u0 :: Float#) -> case _#_ asinFloat# [] [u0] of { _PRIM_ (u1 :: Float#) -> _!_ F# [] [u1] } _N_} _F_ _IF_ARGS_ 0 1 C 4 \ (u0 :: Float) -> case u0 of { _ALG_ F# (u1 :: Float#) -> case _#_ asinFloat# [] [u1] of { _PRIM_ (u2 :: Float#) -> _!_ F# [] [u2] }; _NO_DEFLT_ } _N_ },
+ acos = { _A_ 1 _U_ 1 _N_ _S_ "U(P)" {_A_ 1 _U_ 2 _N_ _N_ _F_ _IF_ARGS_ 0 1 X 3 \ (u0 :: Float#) -> case _#_ acosFloat# [] [u0] of { _PRIM_ (u1 :: Float#) -> _!_ F# [] [u1] } _N_} _F_ _IF_ARGS_ 0 1 C 4 \ (u0 :: Float) -> case u0 of { _ALG_ F# (u1 :: Float#) -> case _#_ acosFloat# [] [u1] of { _PRIM_ (u2 :: Float#) -> _!_ F# [] [u2] }; _NO_DEFLT_ } _N_ },
+ atan = { _A_ 1 _U_ 1 _N_ _S_ "U(P)" {_A_ 1 _U_ 2 _N_ _N_ _F_ _IF_ARGS_ 0 1 X 3 \ (u0 :: Float#) -> case _#_ atanFloat# [] [u0] of { _PRIM_ (u1 :: Float#) -> _!_ F# [] [u1] } _N_} _F_ _IF_ARGS_ 0 1 C 4 \ (u0 :: Float) -> case u0 of { _ALG_ F# (u1 :: Float#) -> case _#_ atanFloat# [] [u1] of { _PRIM_ (u2 :: Float#) -> _!_ F# [] [u2] }; _NO_DEFLT_ } _N_ },
+ sinh = { _A_ 1 _U_ 1 _N_ _S_ "U(P)" {_A_ 1 _U_ 2 _N_ _N_ _F_ _IF_ARGS_ 0 1 X 3 \ (u0 :: Float#) -> case _#_ sinhFloat# [] [u0] of { _PRIM_ (u1 :: Float#) -> _!_ F# [] [u1] } _N_} _F_ _IF_ARGS_ 0 1 C 4 \ (u0 :: Float) -> case u0 of { _ALG_ F# (u1 :: Float#) -> case _#_ sinhFloat# [] [u1] of { _PRIM_ (u2 :: Float#) -> _!_ F# [] [u2] }; _NO_DEFLT_ } _N_ },
+ cosh = { _A_ 1 _U_ 1 _N_ _S_ "U(P)" {_A_ 1 _U_ 2 _N_ _N_ _F_ _IF_ARGS_ 0 1 X 3 \ (u0 :: Float#) -> case _#_ coshFloat# [] [u0] of { _PRIM_ (u1 :: Float#) -> _!_ F# [] [u1] } _N_} _F_ _IF_ARGS_ 0 1 C 4 \ (u0 :: Float) -> case u0 of { _ALG_ F# (u1 :: Float#) -> case _#_ coshFloat# [] [u1] of { _PRIM_ (u2 :: Float#) -> _!_ F# [] [u2] }; _NO_DEFLT_ } _N_ },
+ tanh = { _A_ 1 _U_ 1 _N_ _S_ "U(P)" {_A_ 1 _U_ 2 _N_ _N_ _F_ _IF_ARGS_ 0 1 X 3 \ (u0 :: Float#) -> case _#_ tanhFloat# [] [u0] of { _PRIM_ (u1 :: Float#) -> _!_ F# [] [u1] } _N_} _F_ _IF_ARGS_ 0 1 C 4 \ (u0 :: Float) -> case u0 of { _ALG_ F# (u1 :: Float#) -> case _#_ tanhFloat# [] [u1] of { _PRIM_ (u2 :: Float#) -> _!_ F# [] [u2] }; _NO_DEFLT_ } _N_ },
+ asinh = { _A_ 1 _U_ 1 _N_ _S_ "U(P)" {_A_ 1 _U_ 2 _N_ _N_ _N_ _N_} _N_ _N_ },
+ acosh = { _A_ 1 _U_ 1 _N_ _S_ "U(P)" {_A_ 1 _U_ 2 _N_ _N_ _N_ _N_} _N_ _N_ },
+ atanh = { _A_ 1 _U_ 1 _N_ _S_ "U(P)" {_A_ 1 _U_ 2 _N_ _N_ _N_ _N_} _N_ _N_ } #-}
instance RealFloat a => Fractional (Complex a)
{-# GHC_PRAGMA _M_ PreludeComplex {-dfun-} _A_ 2 _U_ 22 _N_ _N_ _N_ _N_ #-}
instance Fractional (Complex Double)
{-# GHC_PRAGMA _M_ PreludeComplex {-dfun-} _A_ 0 _N_ _N_ _N_ _F_ _IF_ARGS_ 0 0 X 5 _!_ _TUP_4 [{{Num (Complex Double)}}, (Complex Double -> Complex Double -> Complex Double), (Complex Double -> Complex Double), (Ratio Integer -> Complex Double)] [_DFUN_ Num (Complex Double), _CONSTM_ Fractional (/) (Complex Double), _CONSTM_ Fractional recip (Complex Double), _CONSTM_ Fractional fromRational (Complex Double)] _N_
- (/) = _A_ 2 _U_ 11 _N_ _S_ "U(LL)U(LL)" {_A_ 4 _U_ 2222 _N_ _N_ _N_ _N_} _N_ _N_,
- recip = _A_ 1 _U_ 1 _N_ _S_ "U(LL)" {_A_ 2 _U_ 22 _N_ _N_ _N_ _N_} _N_ _N_,
- fromRational = _A_ 1 _U_ 2 _N_ _N_ _N_ _N_ #-}
+ (/) = { _A_ 2 _U_ 11 _N_ _S_ "U(LL)U(LL)" {_A_ 4 _U_ 2222 _N_ _N_ _N_ _N_} _N_ _N_ },
+ recip = { _A_ 1 _U_ 1 _N_ _S_ "U(LL)" {_A_ 2 _U_ 22 _N_ _N_ _N_ _N_} _F_ _IF_ARGS_ 0 1 X 3 \ (u0 :: Complex Double) -> _APP_ _CONSTM_ Fractional (/) (Complex Double) [ _SPEC_ _ORIG_ PreludeCore __i1 [ (Complex Double) ], u0 ] _N_ },
+ fromRational = { _A_ 1 _U_ 1 _N_ _N_ _N_ _N_ } #-}
instance Fractional Double
{-# GHC_PRAGMA _M_ PreludeCore {-dfun-} _A_ 0 _N_ _N_ _N_ _F_ _IF_ARGS_ 0 0 X 5 _!_ _TUP_4 [{{Num Double}}, (Double -> Double -> Double), (Double -> Double), (Ratio Integer -> Double)] [_DFUN_ Num (Double), _CONSTM_ Fractional (/) (Double), _CONSTM_ Fractional recip (Double), _CONSTM_ Fractional fromRational (Double)] _N_
- (/) = _A_ 2 _U_ 11 _N_ _S_ "U(P)U(P)" {_A_ 2 _U_ 22 _N_ _N_ _F_ _IF_ARGS_ 0 2 XX 3 \ (u0 :: Double#) (u1 :: Double#) -> case _#_ divideDouble# [] [u0, u1] of { _PRIM_ (u2 :: Double#) -> _!_ D# [] [u2] } _N_} _F_ _IF_ARGS_ 0 2 CC 5 \ (u0 :: Double) (u1 :: Double) -> case u0 of { _ALG_ D# (u2 :: Double#) -> case u1 of { _ALG_ D# (u3 :: Double#) -> case _#_ divideDouble# [] [u2, u3] of { _PRIM_ (u4 :: Double#) -> _!_ D# [] [u4] }; _NO_DEFLT_ }; _NO_DEFLT_ } _N_,
- recip = _A_ 1 _U_ 1 _N_ _S_ "U(P)" {_A_ 1 _U_ 2 _N_ _N_ _F_ _IF_ARGS_ 0 1 X 3 \ (u0 :: Double#) -> case _#_ divideDouble# [] [1.0000000000000000##, u0] of { _PRIM_ (u1 :: Double#) -> _!_ D# [] [u1] } _N_} _F_ _IF_ARGS_ 0 1 C 4 \ (u0 :: Double) -> case u0 of { _ALG_ D# (u1 :: Double#) -> case _#_ divideDouble# [] [1.0000000000000000##, u1] of { _PRIM_ (u2 :: Double#) -> _!_ D# [] [u2] }; _NO_DEFLT_ } _N_,
- fromRational = _A_ 0 _U_ 2 _N_ _N_ _N_ _N_ #-}
+ (/) = { _A_ 2 _U_ 11 _N_ _S_ "U(P)U(P)" {_A_ 2 _U_ 22 _N_ _N_ _F_ _IF_ARGS_ 0 2 XX 3 \ (u0 :: Double#) (u1 :: Double#) -> case _#_ divideDouble# [] [u0, u1] of { _PRIM_ (u2 :: Double#) -> _!_ D# [] [u2] } _N_} _F_ _IF_ARGS_ 0 2 CC 5 \ (u0 :: Double) (u1 :: Double) -> case u0 of { _ALG_ D# (u2 :: Double#) -> case u1 of { _ALG_ D# (u3 :: Double#) -> case _#_ divideDouble# [] [u2, u3] of { _PRIM_ (u4 :: Double#) -> _!_ D# [] [u4] }; _NO_DEFLT_ }; _NO_DEFLT_ } _N_ },
+ recip = { _A_ 1 _U_ 1 _N_ _S_ "U(P)" {_A_ 1 _U_ 2 _N_ _N_ _F_ _IF_ARGS_ 0 1 X 3 \ (u0 :: Double#) -> case _#_ divideDouble# [] [1.0000000000000000##, u0] of { _PRIM_ (u1 :: Double#) -> _!_ D# [] [u1] } _N_} _F_ _IF_ARGS_ 0 1 C 4 \ (u0 :: Double) -> case u0 of { _ALG_ D# (u1 :: Double#) -> case _#_ divideDouble# [] [1.0000000000000000##, u1] of { _PRIM_ (u2 :: Double#) -> _!_ D# [] [u2] }; _NO_DEFLT_ } _N_ },
+ fromRational = { _A_ 1 _U_ 1 _N_ _S_ "U(U(PPP)U(PPP))" {_A_ 4 _U_ 2222 _N_ _N_ _N_ _N_} _N_ _N_ } #-}
instance Fractional Float
{-# GHC_PRAGMA _M_ PreludeCore {-dfun-} _A_ 0 _N_ _N_ _N_ _F_ _IF_ARGS_ 0 0 X 5 _!_ _TUP_4 [{{Num Float}}, (Float -> Float -> Float), (Float -> Float), (Ratio Integer -> Float)] [_DFUN_ Num (Float), _CONSTM_ Fractional (/) (Float), _CONSTM_ Fractional recip (Float), _CONSTM_ Fractional fromRational (Float)] _N_
- (/) = _A_ 2 _U_ 11 _N_ _S_ "U(P)U(P)" {_A_ 2 _U_ 22 _N_ _N_ _F_ _IF_ARGS_ 0 2 XX 3 \ (u0 :: Float#) (u1 :: Float#) -> case _#_ divideFloat# [] [u0, u1] of { _PRIM_ (u2 :: Float#) -> _!_ F# [] [u2] } _N_} _F_ _IF_ARGS_ 0 2 CC 5 \ (u0 :: Float) (u1 :: Float) -> case u0 of { _ALG_ F# (u2 :: Float#) -> case u1 of { _ALG_ F# (u3 :: Float#) -> case _#_ divideFloat# [] [u2, u3] of { _PRIM_ (u4 :: Float#) -> _!_ F# [] [u4] }; _NO_DEFLT_ }; _NO_DEFLT_ } _N_,
- recip = _A_ 0 _U_ 2 _N_ _N_ _N_ _N_,
- fromRational = _A_ 0 _U_ 2 _N_ _N_ _N_ _N_ #-}
+ (/) = { _A_ 2 _U_ 11 _N_ _S_ "U(P)U(P)" {_A_ 2 _U_ 22 _N_ _N_ _F_ _IF_ARGS_ 0 2 XX 3 \ (u0 :: Float#) (u1 :: Float#) -> case _#_ divideFloat# [] [u0, u1] of { _PRIM_ (u2 :: Float#) -> _!_ F# [] [u2] } _N_} _F_ _IF_ARGS_ 0 2 CC 5 \ (u0 :: Float) (u1 :: Float) -> case u0 of { _ALG_ F# (u2 :: Float#) -> case u1 of { _ALG_ F# (u3 :: Float#) -> case _#_ divideFloat# [] [u2, u3] of { _PRIM_ (u4 :: Float#) -> _!_ F# [] [u4] }; _NO_DEFLT_ }; _NO_DEFLT_ } _N_ },
+ recip = { _A_ 1 _U_ 1 _N_ _S_ "U(P)" {_A_ 1 _U_ 2 _N_ _N_ _F_ _IF_ARGS_ 0 1 X 3 \ (u0 :: Float#) -> case _#_ divideFloat# [] [1.0000000000000000#, u0] of { _PRIM_ (u1 :: Float#) -> _!_ F# [] [u1] } _N_} _F_ _IF_ARGS_ 0 1 C 4 \ (u0 :: Float) -> case u0 of { _ALG_ F# (u1 :: Float#) -> case _#_ divideFloat# [] [1.0000000000000000#, u1] of { _PRIM_ (u2 :: Float#) -> _!_ F# [] [u2] }; _NO_DEFLT_ } _N_ },
+ fromRational = { _A_ 1 _U_ 2 _N_ _N_ _N_ _N_ } #-}
instance Integral a => Fractional (Ratio a)
{-# GHC_PRAGMA _M_ PreludeRatio {-dfun-} _A_ 2 _U_ 22 _N_ _N_ _N_ _N_ #-}
instance Fractional (Ratio Integer)
{-# GHC_PRAGMA _M_ PreludeRatio {-dfun-} _A_ 0 _N_ _N_ _N_ _F_ _IF_ARGS_ 0 0 X 5 _!_ _TUP_4 [{{Num (Ratio Integer)}}, (Ratio Integer -> Ratio Integer -> Ratio Integer), (Ratio Integer -> Ratio Integer), (Ratio Integer -> Ratio Integer)] [_DFUN_ Num (Ratio Integer), _CONSTM_ Fractional (/) (Ratio Integer), _CONSTM_ Fractional recip (Ratio Integer), _CONSTM_ Fractional fromRational (Ratio Integer)] _N_
- (/) = _A_ 2 _U_ 11 _N_ _S_ "U(LU(PPP))U(U(PPP)L)" {_A_ 5 _U_ 22221 _N_ _N_ _N_ _N_} _N_ _N_,
- recip = _A_ 1 _U_ 1 _N_ _S_ "U(U(PPP)L)" {_A_ 4 _U_ 2222 _N_ _N_ _N_ _N_} _N_ _N_,
- fromRational = _A_ 1 _U_ 1 _N_ _S_ "U(LL)" {_A_ 2 _U_ 22 _N_ _N_ _F_ _IF_ARGS_ 0 2 XX 3 \ (u0 :: Integer) (u1 :: Integer) -> _!_ (:%) [Integer] [u0, u1] _N_} _F_ _IF_ARGS_ 0 1 X 1 \ (u0 :: Ratio Integer) -> u0 _N_ #-}
+ (/) = { _A_ 2 _U_ 11 _N_ _S_ "U(LU(PPP))U(U(PPP)L)" {_A_ 5 _U_ 22221 _N_ _N_ _N_ _N_} _N_ _N_ },
+ recip = { _A_ 1 _U_ 1 _N_ _S_ "U(U(PPP)L)" {_A_ 4 _U_ 2222 _N_ _N_ _N_ _N_} _N_ _N_ },
+ fromRational = { _A_ 1 _U_ 1 _N_ _S_ "U(LL)" {_A_ 2 _U_ 22 _N_ _N_ _F_ _IF_ARGS_ 0 2 XX 3 \ (u0 :: Integer) (u1 :: Integer) -> _!_ (:%) [Integer] [u0, u1] _N_} _F_ _IF_ARGS_ 0 1 X 1 \ (u0 :: Ratio Integer) -> u0 _N_ } #-}
instance Integral Int
{-# GHC_PRAGMA _M_ PreludeCore {-dfun-} _A_ 0 _N_ _N_ _N_ _F_ _IF_ARGS_ 0 0 X 13 _!_ _TUP_12 [{{Real Int}}, {{Ix Int}}, (Int -> Int -> Int), (Int -> Int -> Int), (Int -> Int -> Int), (Int -> Int -> Int), (Int -> Int -> (Int, Int)), (Int -> Int -> (Int, Int)), (Int -> Bool), (Int -> Bool), (Int -> Integer), (Int -> Int)] [_DFUN_ Real (Int), _DFUN_ Ix (Int), _CONSTM_ Integral quot (Int), _CONSTM_ Integral rem (Int), _CONSTM_ Integral div (Int), _CONSTM_ Integral mod (Int), _CONSTM_ Integral quotRem (Int), _CONSTM_ Integral divMod (Int), _CONSTM_ Integral even (Int), _CONSTM_ Integral odd (Int), _CONSTM_ Integral toInteger (Int), _CONSTM_ Integral toInt (Int)] _N_
- quot = _A_ 2 _U_ 11 _N_ _S_ "U(P)U(P)" {_A_ 2 _U_ 22 _N_ _N_ _F_ _IF_ARGS_ 0 2 XC 5 \ (u0 :: Int#) (u1 :: Int#) -> case u1 of { _PRIM_ 0# -> _APP_ _TYAPP_ error { Int } [ _NOREP_S_ "Integral.Int.quot{PreludeCore}: divide by 0\n" ]; (u2 :: Int#) -> case _#_ quotInt# [] [u0, u1] of { _PRIM_ (u3 :: Int#) -> _!_ I# [] [u3] } } _N_} _F_ _IF_ARGS_ 0 2 CC 7 \ (u0 :: Int) (u1 :: Int) -> case u1 of { _ALG_ I# (u2 :: Int#) -> case u2 of { _PRIM_ 0# -> _APP_ _TYAPP_ error { Int } [ _NOREP_S_ "Integral.Int.quot{PreludeCore}: divide by 0\n" ]; (u3 :: Int#) -> case u0 of { _ALG_ I# (u4 :: Int#) -> case _#_ quotInt# [] [u4, u2] of { _PRIM_ (u5 :: Int#) -> _!_ I# [] [u5] }; _NO_DEFLT_ } }; _NO_DEFLT_ } _N_,
- rem = _A_ 2 _U_ 11 _N_ _S_ "U(P)U(P)" {_A_ 2 _U_ 22 _N_ _N_ _F_ _IF_ARGS_ 0 2 XC 5 \ (u0 :: Int#) (u1 :: Int#) -> case u1 of { _PRIM_ 0# -> _APP_ _TYAPP_ error { Int } [ _NOREP_S_ "Integral.Int.rem{PreludeCore}: divide by 0\n" ]; (u2 :: Int#) -> case _#_ remInt# [] [u0, u1] of { _PRIM_ (u3 :: Int#) -> _!_ I# [] [u3] } } _N_} _F_ _IF_ARGS_ 0 2 CC 7 \ (u0 :: Int) (u1 :: Int) -> case u1 of { _ALG_ I# (u2 :: Int#) -> case u2 of { _PRIM_ 0# -> _APP_ _TYAPP_ error { Int } [ _NOREP_S_ "Integral.Int.rem{PreludeCore}: divide by 0\n" ]; (u3 :: Int#) -> case u0 of { _ALG_ I# (u4 :: Int#) -> case _#_ remInt# [] [u4, u2] of { _PRIM_ (u5 :: Int#) -> _!_ I# [] [u5] }; _NO_DEFLT_ } }; _NO_DEFLT_ } _N_,
- div = _A_ 2 _U_ 11 _N_ _S_ "U(P)U(P)" {_A_ 2 _U_ 22 _N_ _N_ _N_ _N_} _N_ _N_,
- mod = _A_ 2 _U_ 11 _N_ _S_ "U(P)U(P)" {_A_ 2 _U_ 22 _N_ _N_ _N_ _N_} _N_ _N_,
- quotRem = _A_ 2 _U_ 11 _N_ _S_ "U(P)U(P)" {_A_ 2 _U_ 22 _N_ _N_ _N_ _N_} _N_ _N_,
- divMod = _A_ 2 _U_ 11 _N_ _S_ "U(P)U(P)" {_A_ 2 _U_ 22 _N_ _N_ _N_ _N_} _N_ _N_,
- even = _A_ 1 _U_ 1 _N_ _S_ "U(P)" {_A_ 1 _U_ 2 _N_ _N_ _N_ _N_} _N_ _N_,
- odd = _A_ 1 _U_ 1 _N_ _S_ "U(P)" {_A_ 1 _U_ 2 _N_ _N_ _N_ _N_} _N_ _N_,
- toInteger = _A_ 1 _U_ 1 _N_ _S_ "U(P)" {_A_ 1 _U_ 2 _N_ _N_ _F_ _IF_ARGS_ 0 1 X 1 \ (u0 :: Int#) -> _#_ int2Integer# [] [u0] _N_} _F_ _IF_ARGS_ 0 1 C 2 \ (u0 :: Int) -> case u0 of { _ALG_ I# (u1 :: Int#) -> _#_ int2Integer# [] [u1]; _NO_DEFLT_ } _N_,
- toInt = _A_ 1 _U_ 1 _N_ _S_ "U(P)" {_A_ 1 _U_ 2 _N_ _N_ _F_ _IF_ARGS_ 0 1 X 2 \ (u0 :: Int#) -> _!_ I# [] [u0] _N_} _F_ _IF_ARGS_ 0 1 X 1 \ (u0 :: Int) -> u0 _N_ #-}
+ quot = { _A_ 2 _U_ 11 _N_ _S_ "U(P)U(P)" {_A_ 2 _U_ 22 _N_ _N_ _F_ _IF_ARGS_ 0 2 XC 5 \ (u0 :: Int#) (u1 :: Int#) -> case u1 of { _PRIM_ 0# -> _APP_ _TYAPP_ error { Int } [ _NOREP_S_ "Integral.Int.quot{PreludeCore}: divide by 0\n" ]; (u2 :: Int#) -> case _#_ quotInt# [] [u0, u1] of { _PRIM_ (u3 :: Int#) -> _!_ I# [] [u3] } } _N_} _F_ _IF_ARGS_ 0 2 CC 7 \ (u0 :: Int) (u1 :: Int) -> case u1 of { _ALG_ I# (u2 :: Int#) -> case u2 of { _PRIM_ 0# -> _APP_ _TYAPP_ error { Int } [ _NOREP_S_ "Integral.Int.quot{PreludeCore}: divide by 0\n" ]; (u3 :: Int#) -> case u0 of { _ALG_ I# (u4 :: Int#) -> case _#_ quotInt# [] [u4, u2] of { _PRIM_ (u5 :: Int#) -> _!_ I# [] [u5] }; _NO_DEFLT_ } }; _NO_DEFLT_ } _N_ },
+ rem = { _A_ 2 _U_ 11 _N_ _S_ "U(P)U(P)" {_A_ 2 _U_ 22 _N_ _N_ _F_ _IF_ARGS_ 0 2 XC 5 \ (u0 :: Int#) (u1 :: Int#) -> case u1 of { _PRIM_ 0# -> _APP_ _TYAPP_ error { Int } [ _NOREP_S_ "Integral.Int.rem{PreludeCore}: divide by 0\n" ]; (u2 :: Int#) -> case _#_ remInt# [] [u0, u1] of { _PRIM_ (u3 :: Int#) -> _!_ I# [] [u3] } } _N_} _F_ _IF_ARGS_ 0 2 CC 7 \ (u0 :: Int) (u1 :: Int) -> case u1 of { _ALG_ I# (u2 :: Int#) -> case u2 of { _PRIM_ 0# -> _APP_ _TYAPP_ error { Int } [ _NOREP_S_ "Integral.Int.rem{PreludeCore}: divide by 0\n" ]; (u3 :: Int#) -> case u0 of { _ALG_ I# (u4 :: Int#) -> case _#_ remInt# [] [u4, u2] of { _PRIM_ (u5 :: Int#) -> _!_ I# [] [u5] }; _NO_DEFLT_ } }; _NO_DEFLT_ } _N_ },
+ div = { _A_ 2 _U_ 11 _N_ _S_ "U(P)U(P)" {_A_ 2 _U_ 22 _N_ _N_ _N_ _N_} _N_ _N_ },
+ mod = { _A_ 2 _U_ 11 _N_ _S_ "U(P)U(P)" {_A_ 2 _U_ 22 _N_ _N_ _N_ _N_} _N_ _N_ },
+ quotRem = { _A_ 2 _U_ 11 _N_ _S_ "U(P)U(P)" {_A_ 2 _U_ 22 _N_ _N_ _N_ _N_} _N_ _N_ },
+ divMod = { _A_ 2 _U_ 11 _N_ _S_ "U(P)U(P)" {_A_ 2 _U_ 22 _N_ _N_ _N_ _N_} _N_ _N_ },
+ even = { _A_ 1 _U_ 1 _N_ _S_ "U(P)" {_A_ 1 _U_ 2 _N_ _N_ _N_ _N_} _N_ _N_ },
+ odd = { _A_ 1 _U_ 1 _N_ _S_ "U(P)" {_A_ 1 _U_ 2 _N_ _N_ _N_ _N_} _N_ _N_ },
+ toInteger = { _A_ 1 _U_ 1 _N_ _S_ "U(P)" {_A_ 1 _U_ 2 _N_ _N_ _F_ _IF_ARGS_ 0 1 X 1 \ (u0 :: Int#) -> _#_ int2Integer# [] [u0] _N_} _F_ _IF_ARGS_ 0 1 C 2 \ (u0 :: Int) -> case u0 of { _ALG_ I# (u1 :: Int#) -> _#_ int2Integer# [] [u1]; _NO_DEFLT_ } _N_ },
+ toInt = { _A_ 1 _U_ 1 _N_ _S_ "U(P)" {_A_ 1 _U_ 2 _N_ _N_ _F_ _IF_ARGS_ 0 1 X 2 \ (u0 :: Int#) -> _!_ I# [] [u0] _N_} _F_ _IF_ARGS_ 0 1 X 1 \ (u0 :: Int) -> u0 _N_ } #-}
instance Integral Integer
{-# GHC_PRAGMA _M_ PreludeCore {-dfun-} _A_ 0 _N_ _N_ _N_ _F_ _IF_ARGS_ 0 0 X 13 _!_ _TUP_12 [{{Real Integer}}, {{Ix Integer}}, (Integer -> Integer -> Integer), (Integer -> Integer -> Integer), (Integer -> Integer -> Integer), (Integer -> Integer -> Integer), (Integer -> Integer -> (Integer, Integer)), (Integer -> Integer -> (Integer, Integer)), (Integer -> Bool), (Integer -> Bool), (Integer -> Integer), (Integer -> Int)] [_DFUN_ Real (Integer), _DFUN_ Ix (Integer), _CONSTM_ Integral quot (Integer), _CONSTM_ Integral rem (Integer), _CONSTM_ Integral div (Integer), _CONSTM_ Integral mod (Integer), _CONSTM_ Integral quotRem (Integer), _CONSTM_ Integral divMod (Integer), _CONSTM_ Integral even (Integer), _CONSTM_ Integral odd (Integer), _CONSTM_ Integral toInteger (Integer), _CONSTM_ Integral toInt (Integer)] _N_
- quot = _A_ 2 _U_ 11 _N_ _S_ "U(PPP)U(PPP)" {_A_ 4 _U_ 2221 _N_ _N_ _F_ _IF_ARGS_ 0 4 XXXX 7 \ (u0 :: Int#) (u1 :: Int#) (u2 :: ByteArray#) (u3 :: Integer) -> case _APP_ _WRKR_ _CONSTM_ Integral quotRem (Integer) [ u0, u1, u2, u3 ] of { _ALG_ _TUP_2 (u4 :: Integer) (u5 :: Integer) -> u4; _NO_DEFLT_ } _N_} _F_ _IF_ARGS_ 0 2 XX 5 \ (u0 :: Integer) (u1 :: Integer) -> case _APP_ _CONSTM_ Integral quotRem (Integer) [ u0, u1 ] of { _ALG_ _TUP_2 (u2 :: Integer) (u3 :: Integer) -> u2; _NO_DEFLT_ } _N_,
- rem = _A_ 2 _U_ 11 _N_ _S_ "U(PPP)U(PPP)" {_A_ 4 _U_ 2221 _N_ _N_ _F_ _IF_ARGS_ 0 4 XXXX 7 \ (u0 :: Int#) (u1 :: Int#) (u2 :: ByteArray#) (u3 :: Integer) -> case _APP_ _WRKR_ _CONSTM_ Integral quotRem (Integer) [ u0, u1, u2, u3 ] of { _ALG_ _TUP_2 (u4 :: Integer) (u5 :: Integer) -> u5; _NO_DEFLT_ } _N_} _F_ _IF_ARGS_ 0 2 XX 5 \ (u0 :: Integer) (u1 :: Integer) -> case _APP_ _CONSTM_ Integral quotRem (Integer) [ u0, u1 ] of { _ALG_ _TUP_2 (u2 :: Integer) (u3 :: Integer) -> u3; _NO_DEFLT_ } _N_,
- div = _A_ 2 _U_ 12 _N_ _S_ "U(PPP)U(PPP)" {_A_ 4 _U_ 2222 _N_ _N_ _F_ _IF_ARGS_ 0 4 XXXX 7 \ (u0 :: Int#) (u1 :: Int#) (u2 :: ByteArray#) (u3 :: Integer) -> case _APP_ _WRKR_ _CONSTM_ Integral divMod (Integer) [ u0, u1, u2, u3 ] of { _ALG_ _TUP_2 (u4 :: Integer) (u5 :: Integer) -> u4; _NO_DEFLT_ } _N_} _F_ _IF_ARGS_ 0 2 XX 5 \ (u0 :: Integer) (u1 :: Integer) -> case _APP_ _CONSTM_ Integral divMod (Integer) [ u0, u1 ] of { _ALG_ _TUP_2 (u2 :: Integer) (u3 :: Integer) -> u2; _NO_DEFLT_ } _N_,
- mod = _A_ 2 _U_ 12 _N_ _S_ "U(PPP)U(PPP)" {_A_ 4 _U_ 2222 _N_ _N_ _F_ _IF_ARGS_ 0 4 XXXX 7 \ (u0 :: Int#) (u1 :: Int#) (u2 :: ByteArray#) (u3 :: Integer) -> case _APP_ _WRKR_ _CONSTM_ Integral divMod (Integer) [ u0, u1, u2, u3 ] of { _ALG_ _TUP_2 (u4 :: Integer) (u5 :: Integer) -> u5; _NO_DEFLT_ } _N_} _F_ _IF_ARGS_ 0 2 XX 5 \ (u0 :: Integer) (u1 :: Integer) -> case _APP_ _CONSTM_ Integral divMod (Integer) [ u0, u1 ] of { _ALG_ _TUP_2 (u2 :: Integer) (u3 :: Integer) -> u3; _NO_DEFLT_ } _N_,
- quotRem = _A_ 2 _U_ 11 _N_ _S_ "U(PPP)U(PPP)" {_A_ 4 _U_ 2221 _N_ _N_ _N_ _N_} _N_ _N_,
- divMod = _A_ 2 _U_ 12 _N_ _S_ "U(PPP)U(PPP)" {_A_ 4 _U_ 2222 _N_ _N_ _N_ _N_} _N_ _N_,
- even = _A_ 1 _U_ 1 _N_ _S_ "U(PPP)" {_A_ 3 _U_ 222 _N_ _N_ _N_ _N_} _N_ _N_,
- odd = _A_ 1 _U_ 1 _N_ _S_ "U(PPP)" {_A_ 3 _U_ 222 _N_ _N_ _N_ _N_} _N_ _N_,
- toInteger = _A_ 1 _U_ 1 _N_ _S_ "U(PPP)" {_A_ 3 _U_ 222 _N_ _N_ _F_ _IF_ARGS_ 0 3 XXX 4 \ (u0 :: Int#) (u1 :: Int#) (u2 :: ByteArray#) -> _!_ J# [] [u0, u1, u2] _N_} _F_ _IF_ARGS_ 0 1 X 1 \ (u0 :: Integer) -> u0 _N_,
- toInt = _A_ 1 _U_ 1 _N_ _S_ "U(PPP)" {_A_ 3 _U_ 222 _N_ _N_ _F_ _IF_ARGS_ 0 3 XXX 3 \ (u0 :: Int#) (u1 :: Int#) (u2 :: ByteArray#) -> case _#_ integer2Int# [] [u0, u1, u2] of { _PRIM_ (u3 :: Int#) -> _!_ I# [] [u3] } _N_} _F_ _IF_ARGS_ 0 1 C 4 \ (u0 :: Integer) -> case u0 of { _ALG_ J# (u1 :: Int#) (u2 :: Int#) (u3 :: ByteArray#) -> case _#_ integer2Int# [] [u1, u2, u3] of { _PRIM_ (u4 :: Int#) -> _!_ I# [] [u4] }; _NO_DEFLT_ } _N_ #-}
+ quot = { _A_ 2 _U_ 11 _N_ _S_ "U(PPP)U(PPP)" {_A_ 4 _U_ 2221 _N_ _N_ _F_ _IF_ARGS_ 0 4 XXXX 7 \ (u0 :: Int#) (u1 :: Int#) (u2 :: ByteArray#) (u3 :: Integer) -> case _APP_ _WRKR_ _CONSTM_ Integral quotRem (Integer) [ u0, u1, u2, u3 ] of { _ALG_ _TUP_2 (u4 :: Integer) (u5 :: Integer) -> u4; _NO_DEFLT_ } _N_} _F_ _IF_ARGS_ 0 2 XX 5 \ (u0 :: Integer) (u1 :: Integer) -> case _APP_ _CONSTM_ Integral quotRem (Integer) [ u0, u1 ] of { _ALG_ _TUP_2 (u2 :: Integer) (u3 :: Integer) -> u2; _NO_DEFLT_ } _N_ },
+ rem = { _A_ 2 _U_ 11 _N_ _S_ "U(PPP)U(PPP)" {_A_ 4 _U_ 2221 _N_ _N_ _F_ _IF_ARGS_ 0 4 XXXX 7 \ (u0 :: Int#) (u1 :: Int#) (u2 :: ByteArray#) (u3 :: Integer) -> case _APP_ _WRKR_ _CONSTM_ Integral quotRem (Integer) [ u0, u1, u2, u3 ] of { _ALG_ _TUP_2 (u4 :: Integer) (u5 :: Integer) -> u5; _NO_DEFLT_ } _N_} _F_ _IF_ARGS_ 0 2 XX 5 \ (u0 :: Integer) (u1 :: Integer) -> case _APP_ _CONSTM_ Integral quotRem (Integer) [ u0, u1 ] of { _ALG_ _TUP_2 (u2 :: Integer) (u3 :: Integer) -> u3; _NO_DEFLT_ } _N_ },
+ div = { _A_ 2 _U_ 12 _N_ _S_ "U(PPP)U(PPP)" {_A_ 4 _U_ 2222 _N_ _N_ _F_ _IF_ARGS_ 0 4 XXXX 7 \ (u0 :: Int#) (u1 :: Int#) (u2 :: ByteArray#) (u3 :: Integer) -> case _APP_ _WRKR_ _CONSTM_ Integral divMod (Integer) [ u0, u1, u2, u3 ] of { _ALG_ _TUP_2 (u4 :: Integer) (u5 :: Integer) -> u4; _NO_DEFLT_ } _N_} _F_ _IF_ARGS_ 0 2 XX 5 \ (u0 :: Integer) (u1 :: Integer) -> case _APP_ _CONSTM_ Integral divMod (Integer) [ u0, u1 ] of { _ALG_ _TUP_2 (u2 :: Integer) (u3 :: Integer) -> u2; _NO_DEFLT_ } _N_ },
+ mod = { _A_ 2 _U_ 12 _N_ _S_ "U(PPP)U(PPP)" {_A_ 4 _U_ 2222 _N_ _N_ _F_ _IF_ARGS_ 0 4 XXXX 7 \ (u0 :: Int#) (u1 :: Int#) (u2 :: ByteArray#) (u3 :: Integer) -> case _APP_ _WRKR_ _CONSTM_ Integral divMod (Integer) [ u0, u1, u2, u3 ] of { _ALG_ _TUP_2 (u4 :: Integer) (u5 :: Integer) -> u5; _NO_DEFLT_ } _N_} _F_ _IF_ARGS_ 0 2 XX 5 \ (u0 :: Integer) (u1 :: Integer) -> case _APP_ _CONSTM_ Integral divMod (Integer) [ u0, u1 ] of { _ALG_ _TUP_2 (u2 :: Integer) (u3 :: Integer) -> u3; _NO_DEFLT_ } _N_ },
+ quotRem = { _A_ 2 _U_ 11 _N_ _S_ "U(PPP)U(PPP)" {_A_ 4 _U_ 2221 _N_ _N_ _N_ _N_} _N_ _N_ },
+ divMod = { _A_ 2 _U_ 12 _N_ _S_ "U(PPP)U(PPP)" {_A_ 4 _U_ 2222 _N_ _N_ _N_ _N_} _N_ _N_ },
+ even = { _A_ 1 _U_ 1 _N_ _S_ "U(PPP)" {_A_ 3 _U_ 222 _N_ _N_ _N_ _N_} _N_ _N_ },
+ odd = { _A_ 1 _U_ 1 _N_ _S_ "U(PPP)" {_A_ 3 _U_ 222 _N_ _N_ _N_ _N_} _N_ _N_ },
+ toInteger = { _A_ 1 _U_ 1 _N_ _S_ "U(PPP)" {_A_ 3 _U_ 222 _N_ _N_ _F_ _IF_ARGS_ 0 3 XXX 4 \ (u0 :: Int#) (u1 :: Int#) (u2 :: ByteArray#) -> _!_ J# [] [u0, u1, u2] _N_} _F_ _IF_ARGS_ 0 1 X 1 \ (u0 :: Integer) -> u0 _N_ },
+ toInt = { _A_ 1 _U_ 1 _N_ _S_ "U(PPP)" {_A_ 3 _U_ 222 _N_ _N_ _F_ _IF_ARGS_ 0 3 XXX 3 \ (u0 :: Int#) (u1 :: Int#) (u2 :: ByteArray#) -> case _#_ integer2Int# [] [u0, u1, u2] of { _PRIM_ (u3 :: Int#) -> _!_ I# [] [u3] } _N_} _F_ _IF_ARGS_ 0 1 C 4 \ (u0 :: Integer) -> case u0 of { _ALG_ J# (u1 :: Int#) (u2 :: Int#) (u3 :: ByteArray#) -> case _#_ integer2Int# [] [u1, u2, u3] of { _PRIM_ (u4 :: Int#) -> _!_ I# [] [u4] }; _NO_DEFLT_ } _N_ } #-}
instance Ix ()
{-# GHC_PRAGMA _M_ PreludeBuiltin {-dfun-} _A_ 0 _N_ _N_ _N_ _F_ _IF_ARGS_ 0 0 X 5 _!_ _TUP_4 [{{Ord ()}}, (((), ()) -> [()]), (((), ()) -> () -> Int), (((), ()) -> () -> Bool)] [_DFUN_ Ord (()), _CONSTM_ Ix range (()), _CONSTM_ Ix index (()), _CONSTM_ Ix inRange (())] _N_
- range = _A_ 1 _U_ 1 _N_ _S_ "U(EE)" {_A_ 2 _U_ 21 _N_ _N_ _N_ _N_} _N_ _N_,
- index = _A_ 2 _U_ 11 _N_ _S_ "U(EE)E" {_A_ 3 _U_ 111 _N_ _N_ _F_ _IF_ARGS_ 0 3 CCC 5 \ (u0 :: ()) (u1 :: ()) (u2 :: ()) -> case u0 of { _ALG_ _TUP_0 -> case u1 of { _ALG_ _TUP_0 -> case u2 of { _ALG_ _TUP_0 -> _!_ I# [] [0#]; _NO_DEFLT_ }; _NO_DEFLT_ }; _NO_DEFLT_ } _N_} _F_ _IF_ARGS_ 0 2 CC 6 \ (u0 :: ((), ())) (u1 :: ()) -> case u0 of { _ALG_ _TUP_2 (u2 :: ()) (u3 :: ()) -> case u2 of { _ALG_ _TUP_0 -> case u3 of { _ALG_ _TUP_0 -> case u1 of { _ALG_ _TUP_0 -> _!_ I# [] [0#]; _NO_DEFLT_ }; _NO_DEFLT_ }; _NO_DEFLT_ }; _NO_DEFLT_ } _N_,
- inRange = _A_ 2 _U_ 11 _N_ _S_ "U(EE)E" {_A_ 3 _U_ 111 _N_ _N_ _F_ _IF_ARGS_ 0 3 CCC 4 \ (u0 :: ()) (u1 :: ()) (u2 :: ()) -> case u0 of { _ALG_ _TUP_0 -> case u1 of { _ALG_ _TUP_0 -> case u2 of { _ALG_ _TUP_0 -> _!_ True [] []; _NO_DEFLT_ }; _NO_DEFLT_ }; _NO_DEFLT_ } _N_} _F_ _IF_ARGS_ 0 2 CC 5 \ (u0 :: ((), ())) (u1 :: ()) -> case u0 of { _ALG_ _TUP_2 (u2 :: ()) (u3 :: ()) -> case u2 of { _ALG_ _TUP_0 -> case u3 of { _ALG_ _TUP_0 -> case u1 of { _ALG_ _TUP_0 -> _!_ True [] []; _NO_DEFLT_ }; _NO_DEFLT_ }; _NO_DEFLT_ }; _NO_DEFLT_ } _N_ #-}
+ range = { _A_ 1 _U_ 1 _N_ _S_ "U(EE)" {_A_ 2 _U_ 21 _N_ _N_ _N_ _N_} _N_ _N_ },
+ index = { _A_ 2 _U_ 11 _N_ _S_ "U(EE)E" {_A_ 3 _U_ 111 _N_ _N_ _F_ _IF_ARGS_ 0 3 CCC 5 \ (u0 :: ()) (u1 :: ()) (u2 :: ()) -> case u0 of { _ALG_ _TUP_0 -> case u1 of { _ALG_ _TUP_0 -> case u2 of { _ALG_ _TUP_0 -> _!_ I# [] [0#]; _NO_DEFLT_ }; _NO_DEFLT_ }; _NO_DEFLT_ } _N_} _F_ _IF_ARGS_ 0 2 CC 6 \ (u0 :: ((), ())) (u1 :: ()) -> case u0 of { _ALG_ _TUP_2 (u2 :: ()) (u3 :: ()) -> case u2 of { _ALG_ _TUP_0 -> case u3 of { _ALG_ _TUP_0 -> case u1 of { _ALG_ _TUP_0 -> _!_ I# [] [0#]; _NO_DEFLT_ }; _NO_DEFLT_ }; _NO_DEFLT_ }; _NO_DEFLT_ } _N_ },
+ inRange = { _A_ 2 _U_ 11 _N_ _S_ "U(EE)E" {_A_ 3 _U_ 111 _N_ _N_ _F_ _IF_ARGS_ 0 3 CCC 4 \ (u0 :: ()) (u1 :: ()) (u2 :: ()) -> case u0 of { _ALG_ _TUP_0 -> case u1 of { _ALG_ _TUP_0 -> case u2 of { _ALG_ _TUP_0 -> _!_ True [] []; _NO_DEFLT_ }; _NO_DEFLT_ }; _NO_DEFLT_ } _N_} _F_ _IF_ARGS_ 0 2 CC 5 \ (u0 :: ((), ())) (u1 :: ()) -> case u0 of { _ALG_ _TUP_2 (u2 :: ()) (u3 :: ()) -> case u2 of { _ALG_ _TUP_0 -> case u3 of { _ALG_ _TUP_0 -> case u1 of { _ALG_ _TUP_0 -> _!_ True [] []; _NO_DEFLT_ }; _NO_DEFLT_ }; _NO_DEFLT_ }; _NO_DEFLT_ } _N_ } #-}
instance (Ix a, Ix b) => Ix (a, b)
{-# GHC_PRAGMA _M_ PreludeBuiltin {-dfun-} _A_ 3 _U_ 222 _N_ _N_ _N_ _N_ #-}
instance (Ix a, Ix b, Ix c) => Ix (a, b, c)
{-# GHC_PRAGMA _M_ PreludeBuiltin {-dfun-} _A_ 6 _U_ 222222 _N_ _N_ _N_ _N_ #-}
instance Ix (Int, Int)
{-# GHC_PRAGMA _M_ PreludeBuiltin {-dfun-} _A_ 0 _N_ _N_ _N_ _F_ _IF_ARGS_ 0 0 X 5 _!_ _TUP_4 [{{Ord (Int, Int)}}, (((Int, Int), (Int, Int)) -> [(Int, Int)]), (((Int, Int), (Int, Int)) -> (Int, Int) -> Int), (((Int, Int), (Int, Int)) -> (Int, Int) -> Bool)] [_DFUN_ Ord ((Int, Int)), _CONSTM_ Ix range ((Int, Int)), _CONSTM_ Ix index ((Int, Int)), _CONSTM_ Ix inRange ((Int, Int))] _N_
- range = _A_ 1 _U_ 1 _N_ _S_ "U(SS)" {_A_ 2 _U_ 11 _N_ _N_ _N_ _N_} _N_ _N_,
- index = _A_ 2 _U_ 11 _N_ _S_ "U(SS)U(U(P)U(P))" {_A_ 4 _U_ 1122 _N_ _N_ _N_ _N_} _N_ _N_,
- inRange = _A_ 2 _U_ 11 _N_ _S_ "U(SS)U(U(P)L)" {_A_ 4 _U_ 1121 _N_ _N_ _N_ _N_} _N_ _N_ #-}
+ range = { _A_ 1 _U_ 1 _N_ _S_ "U(SS)" {_A_ 2 _U_ 11 _N_ _N_ _N_ _N_} _N_ _N_ },
+ index = { _A_ 2 _U_ 11 _N_ _S_ "U(SS)U(U(P)U(P))" {_A_ 4 _U_ 1122 _N_ _N_ _N_ _N_} _N_ _N_ },
+ inRange = { _A_ 2 _U_ 11 _N_ _S_ "U(SS)U(U(P)L)" {_A_ 4 _U_ 1121 _N_ _N_ _N_ _N_} _N_ _N_ } #-}
instance (Ix a, Ix b) => Ix (Assoc a b)
{-# GHC_PRAGMA _M_ PreludeArray {-dfun-} _A_ 3 _U_ 222 _N_ _N_ _N_ _N_ #-}
instance Ix Bool
{-# GHC_PRAGMA _M_ PreludeCore {-dfun-} _A_ 0 _N_ _N_ _N_ _F_ _IF_ARGS_ 0 0 X 5 _!_ _TUP_4 [{{Ord Bool}}, ((Bool, Bool) -> [Bool]), ((Bool, Bool) -> Bool -> Int), ((Bool, Bool) -> Bool -> Bool)] [_DFUN_ Ord (Bool), _CONSTM_ Ix range (Bool), _CONSTM_ Ix index (Bool), _CONSTM_ Ix inRange (Bool)] _N_
- range = _A_ 1 _U_ 1 _N_ _S_ "U(EE)" {_A_ 2 _U_ 11 _N_ _N_ _N_ _N_} _N_ _N_,
- index = _A_ 2 _U_ 11 _N_ _S_ "U(EA)E" {_A_ 2 _U_ 11 _N_ _N_ _N_ _N_} _N_ _N_,
- inRange = _A_ 2 _U_ 12 _N_ _S_ "U(EL)E" {_A_ 3 _U_ 112 _N_ _N_ _N_ _N_} _N_ _N_ #-}
+ range = { _A_ 1 _U_ 1 _N_ _S_ "U(EE)" {_A_ 2 _U_ 11 _N_ _N_ _N_ _N_} _N_ _N_ },
+ index = { _A_ 2 _U_ 11 _N_ _S_ "U(EA)E" {_A_ 2 _U_ 11 _N_ _N_ _N_ _N_} _N_ _N_ },
+ inRange = { _A_ 2 _U_ 12 _N_ _S_ "U(EL)E" {_A_ 3 _U_ 112 _N_ _N_ _N_ _N_} _N_ _N_ } #-}
instance Ix Char
{-# GHC_PRAGMA _M_ PreludeCore {-dfun-} _A_ 0 _N_ _N_ _N_ _F_ _IF_ARGS_ 0 0 X 5 _!_ _TUP_4 [{{Ord Char}}, ((Char, Char) -> [Char]), ((Char, Char) -> Char -> Int), ((Char, Char) -> Char -> Bool)] [_DFUN_ Ord (Char), _CONSTM_ Ix range (Char), _CONSTM_ Ix index (Char), _CONSTM_ Ix inRange (Char)] _N_
- range = _A_ 1 _U_ 1 _N_ _S_ "U(LL)" {_A_ 2 _U_ 22 _N_ _N_ _F_ _IF_ARGS_ 0 0 X 1 _CONSTM_ Enum enumFromTo (Char) _N_} _F_ _IF_ARGS_ 0 1 C 4 \ (u0 :: (Char, Char)) -> case u0 of { _ALG_ _TUP_2 (u1 :: Char) (u2 :: Char) -> _APP_ _CONSTM_ Enum enumFromTo (Char) [ u1, u2 ]; _NO_DEFLT_ } _N_,
- index = _A_ 2 _U_ 11 _N_ _S_ "U(U(P)L)U(P)" {_A_ 3 _U_ 212 _N_ _N_ _N_ _N_} _N_ _N_,
- inRange = _A_ 2 _U_ 11 _N_ _S_ "U(U(P)L)U(P)" {_A_ 3 _U_ 212 _N_ _N_ _N_ _N_} _N_ _N_ #-}
+ range = { _A_ 1 _U_ 1 _N_ _S_ "U(U(P)L)" {_A_ 2 _U_ 22 _N_ _N_ _N_ _N_} _F_ _IF_ARGS_ 0 1 C 4 \ (u0 :: (Char, Char)) -> case u0 of { _ALG_ _TUP_2 (u1 :: Char) (u2 :: Char) -> _APP_ _CONSTM_ Enum enumFromTo (Char) [ u1, u2 ]; _NO_DEFLT_ } _N_ },
+ index = { _A_ 2 _U_ 11 _N_ _S_ "U(U(P)L)U(P)" {_A_ 3 _U_ 212 _N_ _N_ _N_ _N_} _N_ _N_ },
+ inRange = { _A_ 2 _U_ 11 _N_ _S_ "U(U(P)L)U(P)" {_A_ 3 _U_ 212 _N_ _N_ _N_ _N_} _N_ _N_ } #-}
instance Ix Int
{-# GHC_PRAGMA _M_ PreludeCore {-dfun-} _A_ 0 _N_ _N_ _N_ _F_ _IF_ARGS_ 0 0 X 5 _!_ _TUP_4 [{{Ord Int}}, ((Int, Int) -> [Int]), ((Int, Int) -> Int -> Int), ((Int, Int) -> Int -> Bool)] [_DFUN_ Ord (Int), _CONSTM_ Ix range (Int), _CONSTM_ Ix index (Int), _CONSTM_ Ix inRange (Int)] _N_
- range = _A_ 1 _U_ 1 _N_ _S_ "U(U(P)U(P))" {_A_ 2 _U_ 22 _N_ _N_ _N_ _N_} _N_ _N_,
- index = _A_ 2 _U_ 11 _N_ _S_ "U(U(P)U(P))U(P)" {_A_ 3 _U_ 222 _N_ _N_ _N_ _N_} _N_ _N_,
- inRange = _A_ 2 _U_ 11 _N_ _S_ "U(U(P)U(P))U(P)" {_A_ 3 _U_ 222 _N_ _N_ _F_ _IF_ARGS_ 0 3 XXX 5 \ (u0 :: Int#) (u1 :: Int#) (u2 :: Int#) -> case _#_ leInt# [] [u0, u2] of { _ALG_ True -> _#_ leInt# [] [u2, u1]; False -> _!_ False [] []; _NO_DEFLT_ } _N_} _F_ _ALWAYS_ \ (u0 :: (Int, Int)) (u1 :: Int) -> case u0 of { _ALG_ _TUP_2 (u2 :: Int) (u3 :: Int) -> case u2 of { _ALG_ I# (u4 :: Int#) -> case u3 of { _ALG_ I# (u5 :: Int#) -> case u1 of { _ALG_ I# (u6 :: Int#) -> case _#_ leInt# [] [u4, u6] of { _ALG_ True -> _#_ leInt# [] [u6, u5]; False -> _!_ False [] []; _NO_DEFLT_ }; _NO_DEFLT_ }; _NO_DEFLT_ }; _NO_DEFLT_ }; _NO_DEFLT_ } _N_ #-}
+ range = { _A_ 1 _U_ 1 _N_ _S_ "U(U(P)U(P))" {_A_ 2 _U_ 22 _N_ _N_ _N_ _N_} _N_ _N_ },
+ index = { _A_ 2 _U_ 11 _N_ _S_ "U(U(P)U(P))U(P)" {_A_ 3 _U_ 222 _N_ _N_ _N_ _N_} _N_ _N_ },
+ inRange = { _A_ 2 _U_ 11 _N_ _S_ "U(U(P)U(P))U(P)" {_A_ 3 _U_ 222 _N_ _N_ _F_ _IF_ARGS_ 0 3 XXX 5 \ (u0 :: Int#) (u1 :: Int#) (u2 :: Int#) -> case _#_ leInt# [] [u0, u2] of { _ALG_ True -> _#_ leInt# [] [u2, u1]; False -> _!_ False [] []; _NO_DEFLT_ } _N_} _F_ _ALWAYS_ \ (u0 :: (Int, Int)) (u1 :: Int) -> case u0 of { _ALG_ _TUP_2 (u2 :: Int) (u3 :: Int) -> case u2 of { _ALG_ I# (u4 :: Int#) -> case u3 of { _ALG_ I# (u5 :: Int#) -> case u1 of { _ALG_ I# (u6 :: Int#) -> case _#_ leInt# [] [u4, u6] of { _ALG_ True -> _#_ leInt# [] [u6, u5]; False -> _!_ False [] []; _NO_DEFLT_ }; _NO_DEFLT_ }; _NO_DEFLT_ }; _NO_DEFLT_ }; _NO_DEFLT_ } _N_ } #-}
instance Ix Integer
{-# GHC_PRAGMA _M_ PreludeCore {-dfun-} _A_ 0 _N_ _N_ _N_ _F_ _IF_ARGS_ 0 0 X 5 _!_ _TUP_4 [{{Ord Integer}}, ((Integer, Integer) -> [Integer]), ((Integer, Integer) -> Integer -> Int), ((Integer, Integer) -> Integer -> Bool)] [_DFUN_ Ord (Integer), _CONSTM_ Ix range (Integer), _CONSTM_ Ix index (Integer), _CONSTM_ Ix inRange (Integer)] _N_
- range = _A_ 1 _U_ 1 _N_ _S_ "U(LL)" {_A_ 2 _U_ 22 _N_ _N_ _F_ _IF_ARGS_ 0 0 X 1 _CONSTM_ Enum enumFromTo (Integer) _N_} _F_ _IF_ARGS_ 0 1 C 4 \ (u0 :: (Integer, Integer)) -> case u0 of { _ALG_ _TUP_2 (u1 :: Integer) (u2 :: Integer) -> _APP_ _CONSTM_ Enum enumFromTo (Integer) [ u1, u2 ]; _NO_DEFLT_ } _N_,
- index = _A_ 2 _U_ 12 _N_ _S_ "U(U(PPP)L)U(PPP)" {_A_ 5 _U_ 22222 _N_ _N_ _N_ _N_} _N_ _N_,
- inRange = _A_ 2 _U_ 11 _N_ _S_ "U(U(PPP)L)U(PPP)" {_A_ 5 _U_ 22211 _N_ _N_ _F_ _IF_ARGS_ 0 5 XXXCC 9 \ (u0 :: Int#) (u1 :: Int#) (u2 :: ByteArray#) (u3 :: Integer) (u4 :: Integer) -> case u4 of { _ALG_ J# (u5 :: Int#) (u6 :: Int#) (u7 :: ByteArray#) -> case _#_ cmpInteger# [] [u0, u1, u2, u5, u6, u7] of { _PRIM_ (u8 :: Int#) -> case _#_ leInt# [] [u8, 0#] of { _ALG_ True -> case u3 of { _ALG_ J# (u9 :: Int#) (ua :: Int#) (ub :: ByteArray#) -> case _#_ cmpInteger# [] [u5, u6, u7, u9, ua, ub] of { _PRIM_ (uc :: Int#) -> _#_ leInt# [] [uc, 0#] }; _NO_DEFLT_ }; False -> _!_ False [] []; _NO_DEFLT_ } }; _NO_DEFLT_ } _N_} _N_ _N_ #-}
+ range = { _A_ 1 _U_ 1 _N_ _S_ "U(LL)" {_A_ 2 _U_ 22 _N_ _N_ _F_ _IF_ARGS_ 0 0 X 1 _CONSTM_ Enum enumFromTo (Integer) _N_} _F_ _IF_ARGS_ 0 1 C 4 \ (u0 :: (Integer, Integer)) -> case u0 of { _ALG_ _TUP_2 (u1 :: Integer) (u2 :: Integer) -> _APP_ _CONSTM_ Enum enumFromTo (Integer) [ u1, u2 ]; _NO_DEFLT_ } _N_ },
+ index = { _A_ 2 _U_ 12 _N_ _S_ "U(U(PPP)L)U(PPP)" {_A_ 5 _U_ 22222 _N_ _N_ _N_ _N_} _N_ _N_ },
+ inRange = { _A_ 2 _U_ 11 _N_ _S_ "U(U(PPP)L)U(PPP)" {_A_ 5 _U_ 22211 _N_ _N_ _F_ _IF_ARGS_ 0 5 XXXCC 9 \ (u0 :: Int#) (u1 :: Int#) (u2 :: ByteArray#) (u3 :: Integer) (u4 :: Integer) -> case u4 of { _ALG_ J# (u5 :: Int#) (u6 :: Int#) (u7 :: ByteArray#) -> case _#_ cmpInteger# [] [u0, u1, u2, u5, u6, u7] of { _PRIM_ (u8 :: Int#) -> case _#_ leInt# [] [u8, 0#] of { _ALG_ True -> case u3 of { _ALG_ J# (u9 :: Int#) (ua :: Int#) (ub :: ByteArray#) -> case _#_ cmpInteger# [] [u5, u6, u7, u9, ua, ub] of { _PRIM_ (uc :: Int#) -> _#_ leInt# [] [uc, 0#] }; _NO_DEFLT_ }; False -> _!_ False [] []; _NO_DEFLT_ } }; _NO_DEFLT_ } _N_} _N_ _N_ } #-}
instance RealFloat a => Num (Complex a)
{-# GHC_PRAGMA _M_ PreludeComplex {-dfun-} _A_ 3 _U_ 222 _N_ _N_ _N_ _N_ #-}
instance Num (Complex Double)
- {-# GHC_PRAGMA _M_ PreludeComplex {-dfun-} _A_ 0 _N_ _N_ _N_ _N_ _N_
- (+) = _A_ 2 _U_ 11 _N_ _S_ "U(LL)U(LL)" {_A_ 4 _U_ 1111 _N_ _N_ _N_ _N_} _N_ _N_,
- (-) = _A_ 2 _U_ 11 _N_ _S_ "U(LL)U(LL)" {_A_ 4 _U_ 1111 _N_ _N_ _N_ _N_} _N_ _N_,
- (*) = _A_ 2 _U_ 11 _N_ _S_ "U(LL)U(LL)" {_A_ 4 _U_ 2222 _N_ _N_ _N_ _N_} _N_ _N_,
- negate = _A_ 1 _U_ 1 _N_ _S_ "U(LL)" {_A_ 2 _U_ 11 _N_ _N_ _N_ _N_} _N_ _N_,
- abs = _A_ 1 _U_ 1 _N_ _N_ _N_ _N_,
- signum = _A_ 1 _U_ 1 _N_ _S_ "U(U(P)L)" {_A_ 2 _U_ 22 _N_ _N_ _N_ _N_} _N_ _N_,
- fromInteger = _A_ 1 _U_ 1 _N_ _N_ _N_ _N_,
- fromInt = _A_ 1 _U_ 1 _N_ _N_ _N_ _N_ #-}
+ {-# GHC_PRAGMA _M_ PreludeComplex {-dfun-} _A_ 0 _N_ _N_ _N_ _F_ _IF_ARGS_ 0 0 X 11 _!_ _TUP_10 [{{Eq (Complex Double)}}, {{Text (Complex Double)}}, (Complex Double -> Complex Double -> Complex Double), (Complex Double -> Complex Double -> Complex Double), (Complex Double -> Complex Double -> Complex Double), (Complex Double -> Complex Double), (Complex Double -> Complex Double), (Complex Double -> Complex Double), (Integer -> Complex Double), (Int -> Complex Double)] [_DFUN_ Eq (Complex Double), _DFUN_ Text (Complex Double), _CONSTM_ Num (+) (Complex Double), _CONSTM_ Num (-) (Complex Double), _CONSTM_ Num (*) (Complex Double), _CONSTM_ Num negate (Complex Double), _CONSTM_ Num abs (Complex Double), _CONSTM_ Num signum (Complex Double), _CONSTM_ Num fromInteger (Complex Double), _CONSTM_ Num fromInt (Complex Double)] _N_
+ (+) = { _A_ 2 _U_ 11 _N_ _S_ "U(LL)U(LL)" {_A_ 4 _U_ 1111 _N_ _N_ _N_ _N_} _N_ _N_ },
+ (-) = { _A_ 2 _U_ 11 _N_ _S_ "U(LL)U(LL)" {_A_ 4 _U_ 1111 _N_ _N_ _N_ _N_} _N_ _N_ },
+ (*) = { _A_ 2 _U_ 11 _N_ _S_ "U(LL)U(LL)" {_A_ 4 _U_ 2222 _N_ _N_ _N_ _N_} _N_ _N_ },
+ negate = { _A_ 1 _U_ 1 _N_ _S_ "U(LL)" {_A_ 2 _U_ 11 _N_ _N_ _N_ _N_} _N_ _N_ },
+ abs = { _A_ 1 _U_ 1 _N_ _N_ _N_ _N_ },
+ signum = { _A_ 1 _U_ 1 _N_ _S_ "U(U(P)L)" {_A_ 2 _U_ 22 _N_ _N_ _N_ _N_} _N_ _N_ },
+ fromInteger = { _A_ 1 _U_ 1 _N_ _N_ _N_ _N_ },
+ fromInt = { _A_ 1 _U_ 1 _N_ _N_ _N_ _N_ } #-}
instance Num Double
{-# GHC_PRAGMA _M_ PreludeCore {-dfun-} _A_ 0 _N_ _N_ _N_ _F_ _IF_ARGS_ 0 0 X 11 _!_ _TUP_10 [{{Eq Double}}, {{Text Double}}, (Double -> Double -> Double), (Double -> Double -> Double), (Double -> Double -> Double), (Double -> Double), (Double -> Double), (Double -> Double), (Integer -> Double), (Int -> Double)] [_DFUN_ Eq (Double), _DFUN_ Text (Double), _CONSTM_ Num (+) (Double), _CONSTM_ Num (-) (Double), _CONSTM_ Num (*) (Double), _CONSTM_ Num negate (Double), _CONSTM_ Num abs (Double), _CONSTM_ Num signum (Double), _CONSTM_ Num fromInteger (Double), _CONSTM_ Num fromInt (Double)] _N_
- (+) = _A_ 2 _U_ 11 _N_ _S_ "U(P)U(P)" {_A_ 2 _U_ 22 _N_ _N_ _F_ _IF_ARGS_ 0 2 XX 3 \ (u0 :: Double#) (u1 :: Double#) -> case _#_ plusDouble# [] [u0, u1] of { _PRIM_ (u2 :: Double#) -> _!_ D# [] [u2] } _N_} _F_ _IF_ARGS_ 0 2 CC 5 \ (u0 :: Double) (u1 :: Double) -> case u0 of { _ALG_ D# (u2 :: Double#) -> case u1 of { _ALG_ D# (u3 :: Double#) -> case _#_ plusDouble# [] [u2, u3] of { _PRIM_ (u4 :: Double#) -> _!_ D# [] [u4] }; _NO_DEFLT_ }; _NO_DEFLT_ } _N_,
- (-) = _A_ 2 _U_ 11 _N_ _S_ "U(P)U(P)" {_A_ 2 _U_ 22 _N_ _N_ _F_ _IF_ARGS_ 0 2 XX 3 \ (u0 :: Double#) (u1 :: Double#) -> case _#_ minusDouble# [] [u0, u1] of { _PRIM_ (u2 :: Double#) -> _!_ D# [] [u2] } _N_} _F_ _IF_ARGS_ 0 2 CC 5 \ (u0 :: Double) (u1 :: Double) -> case u0 of { _ALG_ D# (u2 :: Double#) -> case u1 of { _ALG_ D# (u3 :: Double#) -> case _#_ minusDouble# [] [u2, u3] of { _PRIM_ (u4 :: Double#) -> _!_ D# [] [u4] }; _NO_DEFLT_ }; _NO_DEFLT_ } _N_,
- (*) = _A_ 2 _U_ 11 _N_ _S_ "U(P)U(P)" {_A_ 2 _U_ 22 _N_ _N_ _F_ _IF_ARGS_ 0 2 XX 3 \ (u0 :: Double#) (u1 :: Double#) -> case _#_ timesDouble# [] [u0, u1] of { _PRIM_ (u2 :: Double#) -> _!_ D# [] [u2] } _N_} _F_ _IF_ARGS_ 0 2 CC 5 \ (u0 :: Double) (u1 :: Double) -> case u0 of { _ALG_ D# (u2 :: Double#) -> case u1 of { _ALG_ D# (u3 :: Double#) -> case _#_ timesDouble# [] [u2, u3] of { _PRIM_ (u4 :: Double#) -> _!_ D# [] [u4] }; _NO_DEFLT_ }; _NO_DEFLT_ } _N_,
- negate = _A_ 1 _U_ 1 _N_ _S_ "U(P)" {_A_ 1 _U_ 2 _N_ _N_ _F_ _IF_ARGS_ 0 1 X 3 \ (u0 :: Double#) -> case _#_ negateDouble# [] [u0] of { _PRIM_ (u1 :: Double#) -> _!_ D# [] [u1] } _N_} _F_ _IF_ARGS_ 0 1 C 4 \ (u0 :: Double) -> case u0 of { _ALG_ D# (u1 :: Double#) -> case _#_ negateDouble# [] [u1] of { _PRIM_ (u2 :: Double#) -> _!_ D# [] [u2] }; _NO_DEFLT_ } _N_,
- abs = _A_ 1 _U_ 1 _N_ _S_ "U(P)" {_A_ 1 _U_ 2 _N_ _N_ _N_ _N_} _N_ _N_,
- signum = _A_ 1 _U_ 1 _N_ _S_ "U(P)" {_A_ 1 _U_ 2 _N_ _N_ _N_ _N_} _N_ _N_,
- fromInteger = _A_ 1 _U_ 1 _N_ _S_ "U(PPP)" {_A_ 3 _U_ 222 _N_ _N_ _F_ _IF_ARGS_ 0 3 XXX 3 \ (u0 :: Int#) (u1 :: Int#) (u2 :: ByteArray#) -> case _#_ encodeDouble# [] [u0, u1, u2, 0#] of { _PRIM_ (u3 :: Double#) -> _!_ D# [] [u3] } _N_} _F_ _IF_ARGS_ 0 1 C 4 \ (u0 :: Integer) -> case u0 of { _ALG_ J# (u1 :: Int#) (u2 :: Int#) (u3 :: ByteArray#) -> case _#_ encodeDouble# [] [u1, u2, u3, 0#] of { _PRIM_ (u4 :: Double#) -> _!_ D# [] [u4] }; _NO_DEFLT_ } _N_,
- fromInt = _A_ 1 _U_ 1 _N_ _S_ "U(P)" {_A_ 1 _U_ 2 _N_ _N_ _F_ _IF_ARGS_ 0 1 X 3 \ (u0 :: Int#) -> case _#_ int2Double# [] [u0] of { _PRIM_ (u1 :: Double#) -> _!_ D# [] [u1] } _N_} _F_ _IF_ARGS_ 0 1 C 4 \ (u0 :: Int) -> case u0 of { _ALG_ I# (u1 :: Int#) -> case _#_ int2Double# [] [u1] of { _PRIM_ (u2 :: Double#) -> _!_ D# [] [u2] }; _NO_DEFLT_ } _N_ #-}
+ (+) = { _A_ 2 _U_ 11 _N_ _S_ "U(P)U(P)" {_A_ 2 _U_ 22 _N_ _N_ _F_ _IF_ARGS_ 0 2 XX 3 \ (u0 :: Double#) (u1 :: Double#) -> case _#_ plusDouble# [] [u0, u1] of { _PRIM_ (u2 :: Double#) -> _!_ D# [] [u2] } _N_} _F_ _IF_ARGS_ 0 2 CC 5 \ (u0 :: Double) (u1 :: Double) -> case u0 of { _ALG_ D# (u2 :: Double#) -> case u1 of { _ALG_ D# (u3 :: Double#) -> case _#_ plusDouble# [] [u2, u3] of { _PRIM_ (u4 :: Double#) -> _!_ D# [] [u4] }; _NO_DEFLT_ }; _NO_DEFLT_ } _N_ },
+ (-) = { _A_ 2 _U_ 11 _N_ _S_ "U(P)U(P)" {_A_ 2 _U_ 22 _N_ _N_ _F_ _IF_ARGS_ 0 2 XX 3 \ (u0 :: Double#) (u1 :: Double#) -> case _#_ minusDouble# [] [u0, u1] of { _PRIM_ (u2 :: Double#) -> _!_ D# [] [u2] } _N_} _F_ _IF_ARGS_ 0 2 CC 5 \ (u0 :: Double) (u1 :: Double) -> case u0 of { _ALG_ D# (u2 :: Double#) -> case u1 of { _ALG_ D# (u3 :: Double#) -> case _#_ minusDouble# [] [u2, u3] of { _PRIM_ (u4 :: Double#) -> _!_ D# [] [u4] }; _NO_DEFLT_ }; _NO_DEFLT_ } _N_ },
+ (*) = { _A_ 2 _U_ 11 _N_ _S_ "U(P)U(P)" {_A_ 2 _U_ 22 _N_ _N_ _F_ _IF_ARGS_ 0 2 XX 3 \ (u0 :: Double#) (u1 :: Double#) -> case _#_ timesDouble# [] [u0, u1] of { _PRIM_ (u2 :: Double#) -> _!_ D# [] [u2] } _N_} _F_ _IF_ARGS_ 0 2 CC 5 \ (u0 :: Double) (u1 :: Double) -> case u0 of { _ALG_ D# (u2 :: Double#) -> case u1 of { _ALG_ D# (u3 :: Double#) -> case _#_ timesDouble# [] [u2, u3] of { _PRIM_ (u4 :: Double#) -> _!_ D# [] [u4] }; _NO_DEFLT_ }; _NO_DEFLT_ } _N_ },
+ negate = { _A_ 1 _U_ 1 _N_ _S_ "U(P)" {_A_ 1 _U_ 2 _N_ _N_ _F_ _IF_ARGS_ 0 1 X 3 \ (u0 :: Double#) -> case _#_ negateDouble# [] [u0] of { _PRIM_ (u1 :: Double#) -> _!_ D# [] [u1] } _N_} _F_ _IF_ARGS_ 0 1 C 4 \ (u0 :: Double) -> case u0 of { _ALG_ D# (u1 :: Double#) -> case _#_ negateDouble# [] [u1] of { _PRIM_ (u2 :: Double#) -> _!_ D# [] [u2] }; _NO_DEFLT_ } _N_ },
+ abs = { _A_ 1 _U_ 1 _N_ _S_ "U(P)" {_A_ 1 _U_ 2 _N_ _N_ _N_ _N_} _N_ _N_ },
+ signum = { _A_ 1 _U_ 1 _N_ _S_ "U(P)" {_A_ 1 _U_ 2 _N_ _N_ _N_ _N_} _N_ _N_ },
+ fromInteger = { _A_ 1 _U_ 1 _N_ _S_ "U(PPP)" {_A_ 3 _U_ 222 _N_ _N_ _F_ _IF_ARGS_ 0 3 XXX 3 \ (u0 :: Int#) (u1 :: Int#) (u2 :: ByteArray#) -> case _#_ encodeDouble# [] [u0, u1, u2, 0#] of { _PRIM_ (u3 :: Double#) -> _!_ D# [] [u3] } _N_} _F_ _IF_ARGS_ 0 1 C 4 \ (u0 :: Integer) -> case u0 of { _ALG_ J# (u1 :: Int#) (u2 :: Int#) (u3 :: ByteArray#) -> case _#_ encodeDouble# [] [u1, u2, u3, 0#] of { _PRIM_ (u4 :: Double#) -> _!_ D# [] [u4] }; _NO_DEFLT_ } _N_ },
+ fromInt = { _A_ 1 _U_ 1 _N_ _S_ "U(P)" {_A_ 1 _U_ 2 _N_ _N_ _F_ _IF_ARGS_ 0 1 X 3 \ (u0 :: Int#) -> case _#_ int2Double# [] [u0] of { _PRIM_ (u1 :: Double#) -> _!_ D# [] [u1] } _N_} _F_ _IF_ARGS_ 0 1 C 4 \ (u0 :: Int) -> case u0 of { _ALG_ I# (u1 :: Int#) -> case _#_ int2Double# [] [u1] of { _PRIM_ (u2 :: Double#) -> _!_ D# [] [u2] }; _NO_DEFLT_ } _N_ } #-}
instance Num Float
{-# GHC_PRAGMA _M_ PreludeCore {-dfun-} _A_ 0 _N_ _N_ _N_ _F_ _IF_ARGS_ 0 0 X 11 _!_ _TUP_10 [{{Eq Float}}, {{Text Float}}, (Float -> Float -> Float), (Float -> Float -> Float), (Float -> Float -> Float), (Float -> Float), (Float -> Float), (Float -> Float), (Integer -> Float), (Int -> Float)] [_DFUN_ Eq (Float), _DFUN_ Text (Float), _CONSTM_ Num (+) (Float), _CONSTM_ Num (-) (Float), _CONSTM_ Num (*) (Float), _CONSTM_ Num negate (Float), _CONSTM_ Num abs (Float), _CONSTM_ Num signum (Float), _CONSTM_ Num fromInteger (Float), _CONSTM_ Num fromInt (Float)] _N_
- (+) = _A_ 2 _U_ 11 _N_ _S_ "U(P)U(P)" {_A_ 2 _U_ 22 _N_ _N_ _F_ _IF_ARGS_ 0 2 XX 3 \ (u0 :: Float#) (u1 :: Float#) -> case _#_ plusFloat# [] [u0, u1] of { _PRIM_ (u2 :: Float#) -> _!_ F# [] [u2] } _N_} _F_ _IF_ARGS_ 0 2 CC 5 \ (u0 :: Float) (u1 :: Float) -> case u0 of { _ALG_ F# (u2 :: Float#) -> case u1 of { _ALG_ F# (u3 :: Float#) -> case _#_ plusFloat# [] [u2, u3] of { _PRIM_ (u4 :: Float#) -> _!_ F# [] [u4] }; _NO_DEFLT_ }; _NO_DEFLT_ } _N_,
- (-) = _A_ 2 _U_ 11 _N_ _S_ "U(P)U(P)" {_A_ 2 _U_ 22 _N_ _N_ _F_ _IF_ARGS_ 0 2 XX 3 \ (u0 :: Float#) (u1 :: Float#) -> case _#_ minusFloat# [] [u0, u1] of { _PRIM_ (u2 :: Float#) -> _!_ F# [] [u2] } _N_} _F_ _IF_ARGS_ 0 2 CC 5 \ (u0 :: Float) (u1 :: Float) -> case u0 of { _ALG_ F# (u2 :: Float#) -> case u1 of { _ALG_ F# (u3 :: Float#) -> case _#_ minusFloat# [] [u2, u3] of { _PRIM_ (u4 :: Float#) -> _!_ F# [] [u4] }; _NO_DEFLT_ }; _NO_DEFLT_ } _N_,
- (*) = _A_ 2 _U_ 11 _N_ _S_ "U(P)U(P)" {_A_ 2 _U_ 22 _N_ _N_ _F_ _IF_ARGS_ 0 2 XX 3 \ (u0 :: Float#) (u1 :: Float#) -> case _#_ timesFloat# [] [u0, u1] of { _PRIM_ (u2 :: Float#) -> _!_ F# [] [u2] } _N_} _F_ _IF_ARGS_ 0 2 CC 5 \ (u0 :: Float) (u1 :: Float) -> case u0 of { _ALG_ F# (u2 :: Float#) -> case u1 of { _ALG_ F# (u3 :: Float#) -> case _#_ timesFloat# [] [u2, u3] of { _PRIM_ (u4 :: Float#) -> _!_ F# [] [u4] }; _NO_DEFLT_ }; _NO_DEFLT_ } _N_,
- negate = _A_ 1 _U_ 1 _N_ _S_ "U(P)" {_A_ 1 _U_ 2 _N_ _N_ _F_ _IF_ARGS_ 0 1 X 3 \ (u0 :: Float#) -> case _#_ negateFloat# [] [u0] of { _PRIM_ (u1 :: Float#) -> _!_ F# [] [u1] } _N_} _F_ _IF_ARGS_ 0 1 C 4 \ (u0 :: Float) -> case u0 of { _ALG_ F# (u1 :: Float#) -> case _#_ negateFloat# [] [u1] of { _PRIM_ (u2 :: Float#) -> _!_ F# [] [u2] }; _NO_DEFLT_ } _N_,
- abs = _A_ 1 _U_ 1 _N_ _S_ "U(P)" {_A_ 1 _U_ 2 _N_ _N_ _N_ _N_} _N_ _N_,
- signum = _A_ 1 _U_ 1 _N_ _S_ "U(P)" {_A_ 1 _U_ 2 _N_ _N_ _N_ _N_} _N_ _N_,
- fromInteger = _A_ 1 _U_ 1 _N_ _S_ "U(PPP)" {_A_ 3 _U_ 222 _N_ _N_ _F_ _IF_ARGS_ 0 3 XXX 3 \ (u0 :: Int#) (u1 :: Int#) (u2 :: ByteArray#) -> case _#_ encodeFloat# [] [u0, u1, u2, 0#] of { _PRIM_ (u3 :: Float#) -> _!_ F# [] [u3] } _N_} _F_ _IF_ARGS_ 0 1 C 4 \ (u0 :: Integer) -> case u0 of { _ALG_ J# (u1 :: Int#) (u2 :: Int#) (u3 :: ByteArray#) -> case _#_ encodeFloat# [] [u1, u2, u3, 0#] of { _PRIM_ (u4 :: Float#) -> _!_ F# [] [u4] }; _NO_DEFLT_ } _N_,
- fromInt = _A_ 1 _U_ 1 _N_ _S_ "U(P)" {_A_ 1 _U_ 2 _N_ _N_ _F_ _IF_ARGS_ 0 1 X 3 \ (u0 :: Int#) -> case _#_ int2Float# [] [u0] of { _PRIM_ (u1 :: Float#) -> _!_ F# [] [u1] } _N_} _F_ _IF_ARGS_ 0 1 C 4 \ (u0 :: Int) -> case u0 of { _ALG_ I# (u1 :: Int#) -> case _#_ int2Float# [] [u1] of { _PRIM_ (u2 :: Float#) -> _!_ F# [] [u2] }; _NO_DEFLT_ } _N_ #-}
+ (+) = { _A_ 2 _U_ 11 _N_ _S_ "U(P)U(P)" {_A_ 2 _U_ 22 _N_ _N_ _F_ _IF_ARGS_ 0 2 XX 3 \ (u0 :: Float#) (u1 :: Float#) -> case _#_ plusFloat# [] [u0, u1] of { _PRIM_ (u2 :: Float#) -> _!_ F# [] [u2] } _N_} _F_ _IF_ARGS_ 0 2 CC 5 \ (u0 :: Float) (u1 :: Float) -> case u0 of { _ALG_ F# (u2 :: Float#) -> case u1 of { _ALG_ F# (u3 :: Float#) -> case _#_ plusFloat# [] [u2, u3] of { _PRIM_ (u4 :: Float#) -> _!_ F# [] [u4] }; _NO_DEFLT_ }; _NO_DEFLT_ } _N_ },
+ (-) = { _A_ 2 _U_ 11 _N_ _S_ "U(P)U(P)" {_A_ 2 _U_ 22 _N_ _N_ _F_ _IF_ARGS_ 0 2 XX 3 \ (u0 :: Float#) (u1 :: Float#) -> case _#_ minusFloat# [] [u0, u1] of { _PRIM_ (u2 :: Float#) -> _!_ F# [] [u2] } _N_} _F_ _IF_ARGS_ 0 2 CC 5 \ (u0 :: Float) (u1 :: Float) -> case u0 of { _ALG_ F# (u2 :: Float#) -> case u1 of { _ALG_ F# (u3 :: Float#) -> case _#_ minusFloat# [] [u2, u3] of { _PRIM_ (u4 :: Float#) -> _!_ F# [] [u4] }; _NO_DEFLT_ }; _NO_DEFLT_ } _N_ },
+ (*) = { _A_ 2 _U_ 11 _N_ _S_ "U(P)U(P)" {_A_ 2 _U_ 22 _N_ _N_ _F_ _IF_ARGS_ 0 2 XX 3 \ (u0 :: Float#) (u1 :: Float#) -> case _#_ timesFloat# [] [u0, u1] of { _PRIM_ (u2 :: Float#) -> _!_ F# [] [u2] } _N_} _F_ _IF_ARGS_ 0 2 CC 5 \ (u0 :: Float) (u1 :: Float) -> case u0 of { _ALG_ F# (u2 :: Float#) -> case u1 of { _ALG_ F# (u3 :: Float#) -> case _#_ timesFloat# [] [u2, u3] of { _PRIM_ (u4 :: Float#) -> _!_ F# [] [u4] }; _NO_DEFLT_ }; _NO_DEFLT_ } _N_ },
+ negate = { _A_ 1 _U_ 1 _N_ _S_ "U(P)" {_A_ 1 _U_ 2 _N_ _N_ _F_ _IF_ARGS_ 0 1 X 3 \ (u0 :: Float#) -> case _#_ negateFloat# [] [u0] of { _PRIM_ (u1 :: Float#) -> _!_ F# [] [u1] } _N_} _F_ _IF_ARGS_ 0 1 C 4 \ (u0 :: Float) -> case u0 of { _ALG_ F# (u1 :: Float#) -> case _#_ negateFloat# [] [u1] of { _PRIM_ (u2 :: Float#) -> _!_ F# [] [u2] }; _NO_DEFLT_ } _N_ },
+ abs = { _A_ 1 _U_ 1 _N_ _S_ "U(P)" {_A_ 1 _U_ 2 _N_ _N_ _N_ _N_} _N_ _N_ },
+ signum = { _A_ 1 _U_ 1 _N_ _S_ "U(P)" {_A_ 1 _U_ 2 _N_ _N_ _N_ _N_} _N_ _N_ },
+ fromInteger = { _A_ 1 _U_ 1 _N_ _S_ "U(PPP)" {_A_ 3 _U_ 222 _N_ _N_ _F_ _IF_ARGS_ 0 3 XXX 3 \ (u0 :: Int#) (u1 :: Int#) (u2 :: ByteArray#) -> case _#_ encodeFloat# [] [u0, u1, u2, 0#] of { _PRIM_ (u3 :: Float#) -> _!_ F# [] [u3] } _N_} _F_ _IF_ARGS_ 0 1 C 4 \ (u0 :: Integer) -> case u0 of { _ALG_ J# (u1 :: Int#) (u2 :: Int#) (u3 :: ByteArray#) -> case _#_ encodeFloat# [] [u1, u2, u3, 0#] of { _PRIM_ (u4 :: Float#) -> _!_ F# [] [u4] }; _NO_DEFLT_ } _N_ },
+ fromInt = { _A_ 1 _U_ 1 _N_ _S_ "U(P)" {_A_ 1 _U_ 2 _N_ _N_ _F_ _IF_ARGS_ 0 1 X 3 \ (u0 :: Int#) -> case _#_ int2Float# [] [u0] of { _PRIM_ (u1 :: Float#) -> _!_ F# [] [u1] } _N_} _F_ _IF_ARGS_ 0 1 C 4 \ (u0 :: Int) -> case u0 of { _ALG_ I# (u1 :: Int#) -> case _#_ int2Float# [] [u1] of { _PRIM_ (u2 :: Float#) -> _!_ F# [] [u2] }; _NO_DEFLT_ } _N_ } #-}
instance Num Int
{-# GHC_PRAGMA _M_ PreludeCore {-dfun-} _A_ 0 _N_ _N_ _N_ _F_ _IF_ARGS_ 0 0 X 11 _!_ _TUP_10 [{{Eq Int}}, {{Text Int}}, (Int -> Int -> Int), (Int -> Int -> Int), (Int -> Int -> Int), (Int -> Int), (Int -> Int), (Int -> Int), (Integer -> Int), (Int -> Int)] [_DFUN_ Eq (Int), _DFUN_ Text (Int), _CONSTM_ Num (+) (Int), _CONSTM_ Num (-) (Int), _CONSTM_ Num (*) (Int), _CONSTM_ Num negate (Int), _CONSTM_ Num abs (Int), _CONSTM_ Num signum (Int), _CONSTM_ Num fromInteger (Int), _CONSTM_ Num fromInt (Int)] _N_
- (+) = _A_ 2 _U_ 11 _N_ _S_ "U(P)U(P)" {_A_ 2 _U_ 22 _N_ _N_ _F_ _IF_ARGS_ 0 2 XX 3 \ (u0 :: Int#) (u1 :: Int#) -> case _#_ plusInt# [] [u0, u1] of { _PRIM_ (u2 :: Int#) -> _!_ I# [] [u2] } _N_} _F_ _IF_ARGS_ 0 2 CC 5 \ (u0 :: Int) (u1 :: Int) -> case u0 of { _ALG_ I# (u2 :: Int#) -> case u1 of { _ALG_ I# (u3 :: Int#) -> case _#_ plusInt# [] [u2, u3] of { _PRIM_ (u4 :: Int#) -> _!_ I# [] [u4] }; _NO_DEFLT_ }; _NO_DEFLT_ } _N_,
- (-) = _A_ 2 _U_ 11 _N_ _S_ "U(P)U(P)" {_A_ 2 _U_ 22 _N_ _N_ _F_ _IF_ARGS_ 0 2 XX 3 \ (u0 :: Int#) (u1 :: Int#) -> case _#_ minusInt# [] [u0, u1] of { _PRIM_ (u2 :: Int#) -> _!_ I# [] [u2] } _N_} _F_ _IF_ARGS_ 0 2 CC 5 \ (u0 :: Int) (u1 :: Int) -> case u0 of { _ALG_ I# (u2 :: Int#) -> case u1 of { _ALG_ I# (u3 :: Int#) -> case _#_ minusInt# [] [u2, u3] of { _PRIM_ (u4 :: Int#) -> _!_ I# [] [u4] }; _NO_DEFLT_ }; _NO_DEFLT_ } _N_,
- (*) = _A_ 2 _U_ 11 _N_ _S_ "U(P)U(P)" {_A_ 2 _U_ 22 _N_ _N_ _F_ _IF_ARGS_ 0 2 XX 3 \ (u0 :: Int#) (u1 :: Int#) -> case _#_ timesInt# [] [u0, u1] of { _PRIM_ (u2 :: Int#) -> _!_ I# [] [u2] } _N_} _F_ _IF_ARGS_ 0 2 CC 5 \ (u0 :: Int) (u1 :: Int) -> case u0 of { _ALG_ I# (u2 :: Int#) -> case u1 of { _ALG_ I# (u3 :: Int#) -> case _#_ timesInt# [] [u2, u3] of { _PRIM_ (u4 :: Int#) -> _!_ I# [] [u4] }; _NO_DEFLT_ }; _NO_DEFLT_ } _N_,
- negate = _A_ 1 _U_ 1 _N_ _S_ "U(P)" {_A_ 1 _U_ 2 _N_ _N_ _F_ _IF_ARGS_ 0 1 X 3 \ (u0 :: Int#) -> case _#_ negateInt# [] [u0] of { _PRIM_ (u1 :: Int#) -> _!_ I# [] [u1] } _N_} _F_ _IF_ARGS_ 0 1 C 4 \ (u0 :: Int) -> case u0 of { _ALG_ I# (u1 :: Int#) -> case _#_ negateInt# [] [u1] of { _PRIM_ (u2 :: Int#) -> _!_ I# [] [u2] }; _NO_DEFLT_ } _N_,
- abs = _A_ 1 _U_ 1 _N_ _S_ "U(P)" {_A_ 1 _U_ 2 _N_ _N_ _N_ _N_} _N_ _N_,
- signum = _A_ 1 _U_ 1 _N_ _S_ "U(P)" {_A_ 1 _U_ 2 _N_ _N_ _N_ _N_} _N_ _N_,
- fromInteger = _A_ 1 _U_ 1 _N_ _S_ "U(PPP)" {_A_ 3 _U_ 222 _N_ _N_ _F_ _IF_ARGS_ 0 3 XXX 3 \ (u0 :: Int#) (u1 :: Int#) (u2 :: ByteArray#) -> case _#_ integer2Int# [] [u0, u1, u2] of { _PRIM_ (u3 :: Int#) -> _!_ I# [] [u3] } _N_} _F_ _IF_ARGS_ 0 1 C 4 \ (u0 :: Integer) -> case u0 of { _ALG_ J# (u1 :: Int#) (u2 :: Int#) (u3 :: ByteArray#) -> case _#_ integer2Int# [] [u1, u2, u3] of { _PRIM_ (u4 :: Int#) -> _!_ I# [] [u4] }; _NO_DEFLT_ } _N_,
- fromInt = _A_ 1 _U_ 1 _N_ _S_ "U(P)" {_A_ 1 _U_ 2 _N_ _N_ _F_ _IF_ARGS_ 0 1 X 2 \ (u0 :: Int#) -> _!_ I# [] [u0] _N_} _F_ _IF_ARGS_ 0 1 X 1 \ (u0 :: Int) -> u0 _N_ #-}
+ (+) = { _A_ 2 _U_ 11 _N_ _S_ "U(P)U(P)" {_A_ 2 _U_ 22 _N_ _N_ _F_ _IF_ARGS_ 0 2 XX 3 \ (u0 :: Int#) (u1 :: Int#) -> case _#_ plusInt# [] [u0, u1] of { _PRIM_ (u2 :: Int#) -> _!_ I# [] [u2] } _N_} _F_ _IF_ARGS_ 0 2 CC 5 \ (u0 :: Int) (u1 :: Int) -> case u0 of { _ALG_ I# (u2 :: Int#) -> case u1 of { _ALG_ I# (u3 :: Int#) -> case _#_ plusInt# [] [u2, u3] of { _PRIM_ (u4 :: Int#) -> _!_ I# [] [u4] }; _NO_DEFLT_ }; _NO_DEFLT_ } _N_ },
+ (-) = { _A_ 2 _U_ 11 _N_ _S_ "U(P)U(P)" {_A_ 2 _U_ 22 _N_ _N_ _F_ _IF_ARGS_ 0 2 XX 3 \ (u0 :: Int#) (u1 :: Int#) -> case _#_ minusInt# [] [u0, u1] of { _PRIM_ (u2 :: Int#) -> _!_ I# [] [u2] } _N_} _F_ _IF_ARGS_ 0 2 CC 5 \ (u0 :: Int) (u1 :: Int) -> case u0 of { _ALG_ I# (u2 :: Int#) -> case u1 of { _ALG_ I# (u3 :: Int#) -> case _#_ minusInt# [] [u2, u3] of { _PRIM_ (u4 :: Int#) -> _!_ I# [] [u4] }; _NO_DEFLT_ }; _NO_DEFLT_ } _N_ },
+ (*) = { _A_ 2 _U_ 11 _N_ _S_ "U(P)U(P)" {_A_ 2 _U_ 22 _N_ _N_ _F_ _IF_ARGS_ 0 2 XX 3 \ (u0 :: Int#) (u1 :: Int#) -> case _#_ timesInt# [] [u0, u1] of { _PRIM_ (u2 :: Int#) -> _!_ I# [] [u2] } _N_} _F_ _IF_ARGS_ 0 2 CC 5 \ (u0 :: Int) (u1 :: Int) -> case u0 of { _ALG_ I# (u2 :: Int#) -> case u1 of { _ALG_ I# (u3 :: Int#) -> case _#_ timesInt# [] [u2, u3] of { _PRIM_ (u4 :: Int#) -> _!_ I# [] [u4] }; _NO_DEFLT_ }; _NO_DEFLT_ } _N_ },
+ negate = { _A_ 1 _U_ 1 _N_ _S_ "U(P)" {_A_ 1 _U_ 2 _N_ _N_ _F_ _IF_ARGS_ 0 1 X 3 \ (u0 :: Int#) -> case _#_ negateInt# [] [u0] of { _PRIM_ (u1 :: Int#) -> _!_ I# [] [u1] } _N_} _F_ _IF_ARGS_ 0 1 C 4 \ (u0 :: Int) -> case u0 of { _ALG_ I# (u1 :: Int#) -> case _#_ negateInt# [] [u1] of { _PRIM_ (u2 :: Int#) -> _!_ I# [] [u2] }; _NO_DEFLT_ } _N_ },
+ abs = { _A_ 1 _U_ 1 _N_ _S_ "U(P)" {_A_ 1 _U_ 2 _N_ _N_ _N_ _N_} _N_ _N_ },
+ signum = { _A_ 1 _U_ 1 _N_ _S_ "U(P)" {_A_ 1 _U_ 2 _N_ _N_ _N_ _N_} _N_ _N_ },
+ fromInteger = { _A_ 1 _U_ 1 _N_ _S_ "U(PPP)" {_A_ 3 _U_ 222 _N_ _N_ _F_ _IF_ARGS_ 0 3 XXX 3 \ (u0 :: Int#) (u1 :: Int#) (u2 :: ByteArray#) -> case _#_ integer2Int# [] [u0, u1, u2] of { _PRIM_ (u3 :: Int#) -> _!_ I# [] [u3] } _N_} _F_ _IF_ARGS_ 0 1 C 4 \ (u0 :: Integer) -> case u0 of { _ALG_ J# (u1 :: Int#) (u2 :: Int#) (u3 :: ByteArray#) -> case _#_ integer2Int# [] [u1, u2, u3] of { _PRIM_ (u4 :: Int#) -> _!_ I# [] [u4] }; _NO_DEFLT_ } _N_ },
+ fromInt = { _A_ 1 _U_ 1 _N_ _S_ "U(P)" {_A_ 1 _U_ 2 _N_ _N_ _F_ _IF_ARGS_ 0 1 X 2 \ (u0 :: Int#) -> _!_ I# [] [u0] _N_} _F_ _IF_ARGS_ 0 1 X 1 \ (u0 :: Int) -> u0 _N_ } #-}
instance Num Integer
{-# GHC_PRAGMA _M_ PreludeCore {-dfun-} _A_ 0 _N_ _N_ _N_ _F_ _IF_ARGS_ 0 0 X 11 _!_ _TUP_10 [{{Eq Integer}}, {{Text Integer}}, (Integer -> Integer -> Integer), (Integer -> Integer -> Integer), (Integer -> Integer -> Integer), (Integer -> Integer), (Integer -> Integer), (Integer -> Integer), (Integer -> Integer), (Int -> Integer)] [_DFUN_ Eq (Integer), _DFUN_ Text (Integer), _CONSTM_ Num (+) (Integer), _CONSTM_ Num (-) (Integer), _CONSTM_ Num (*) (Integer), _CONSTM_ Num negate (Integer), _CONSTM_ Num abs (Integer), _CONSTM_ Num signum (Integer), _CONSTM_ Num fromInteger (Integer), _CONSTM_ Num fromInt (Integer)] _N_
- (+) = _A_ 2 _U_ 11 _N_ _S_ "U(PPP)U(PPP)" {_A_ 4 _U_ 2221 _N_ _N_ _F_ _IF_ARGS_ 0 4 XXXC 5 \ (u0 :: Int#) (u1 :: Int#) (u2 :: ByteArray#) (u3 :: Integer) -> case u3 of { _ALG_ J# (u4 :: Int#) (u5 :: Int#) (u6 :: ByteArray#) -> _#_ plusInteger# [] [u0, u1, u2, u4, u5, u6]; _NO_DEFLT_ } _N_} _F_ _IF_ARGS_ 0 2 CC 6 \ (u0 :: Integer) (u1 :: Integer) -> case u0 of { _ALG_ J# (u2 :: Int#) (u3 :: Int#) (u4 :: ByteArray#) -> case u1 of { _ALG_ J# (u5 :: Int#) (u6 :: Int#) (u7 :: ByteArray#) -> _#_ plusInteger# [] [u2, u3, u4, u5, u6, u7]; _NO_DEFLT_ }; _NO_DEFLT_ } _N_,
- (-) = _A_ 2 _U_ 11 _N_ _S_ "U(PPP)U(PPP)" {_A_ 4 _U_ 2221 _N_ _N_ _F_ _IF_ARGS_ 0 4 XXXC 5 \ (u0 :: Int#) (u1 :: Int#) (u2 :: ByteArray#) (u3 :: Integer) -> case u3 of { _ALG_ J# (u4 :: Int#) (u5 :: Int#) (u6 :: ByteArray#) -> _#_ minusInteger# [] [u0, u1, u2, u4, u5, u6]; _NO_DEFLT_ } _N_} _F_ _IF_ARGS_ 0 2 CC 6 \ (u0 :: Integer) (u1 :: Integer) -> case u0 of { _ALG_ J# (u2 :: Int#) (u3 :: Int#) (u4 :: ByteArray#) -> case u1 of { _ALG_ J# (u5 :: Int#) (u6 :: Int#) (u7 :: ByteArray#) -> _#_ minusInteger# [] [u2, u3, u4, u5, u6, u7]; _NO_DEFLT_ }; _NO_DEFLT_ } _N_,
- (*) = _A_ 2 _U_ 11 _N_ _S_ "U(PPP)U(PPP)" {_A_ 4 _U_ 2221 _N_ _N_ _F_ _IF_ARGS_ 0 4 XXXC 5 \ (u0 :: Int#) (u1 :: Int#) (u2 :: ByteArray#) (u3 :: Integer) -> case u3 of { _ALG_ J# (u4 :: Int#) (u5 :: Int#) (u6 :: ByteArray#) -> _#_ timesInteger# [] [u0, u1, u2, u4, u5, u6]; _NO_DEFLT_ } _N_} _F_ _IF_ARGS_ 0 2 CC 6 \ (u0 :: Integer) (u1 :: Integer) -> case u0 of { _ALG_ J# (u2 :: Int#) (u3 :: Int#) (u4 :: ByteArray#) -> case u1 of { _ALG_ J# (u5 :: Int#) (u6 :: Int#) (u7 :: ByteArray#) -> _#_ timesInteger# [] [u2, u3, u4, u5, u6, u7]; _NO_DEFLT_ }; _NO_DEFLT_ } _N_,
- negate = _A_ 1 _U_ 1 _N_ _S_ "U(PPP)" {_A_ 3 _U_ 222 _N_ _N_ _F_ _IF_ARGS_ 0 3 XXX 4 \ (u0 :: Int#) (u1 :: Int#) (u2 :: ByteArray#) -> _#_ negateInteger# [] [u0, u1, u2] _N_} _F_ _IF_ARGS_ 0 1 C 5 \ (u0 :: Integer) -> case u0 of { _ALG_ J# (u1 :: Int#) (u2 :: Int#) (u3 :: ByteArray#) -> _#_ negateInteger# [] [u1, u2, u3]; _NO_DEFLT_ } _N_,
- abs = _A_ 1 _U_ 1 _N_ _S_ "U(PPP)" {_A_ 3 _U_ 222 _N_ _N_ _N_ _N_} _N_ _N_,
- signum = _A_ 1 _U_ 1 _N_ _S_ "U(PPP)" {_A_ 3 _U_ 222 _N_ _N_ _N_ _N_} _N_ _N_,
- fromInteger = _A_ 1 _U_ 1 _N_ _S_ "U(PPP)" {_A_ 3 _U_ 222 _N_ _N_ _F_ _IF_ARGS_ 0 3 XXX 4 \ (u0 :: Int#) (u1 :: Int#) (u2 :: ByteArray#) -> _!_ J# [] [u0, u1, u2] _N_} _F_ _IF_ARGS_ 0 1 X 1 \ (u0 :: Integer) -> u0 _N_,
- fromInt = _A_ 1 _U_ 1 _N_ _S_ "U(P)" {_A_ 1 _U_ 2 _N_ _N_ _F_ _IF_ARGS_ 0 1 X 1 \ (u0 :: Int#) -> _#_ int2Integer# [] [u0] _N_} _F_ _IF_ARGS_ 0 1 C 2 \ (u0 :: Int) -> case u0 of { _ALG_ I# (u1 :: Int#) -> _#_ int2Integer# [] [u1]; _NO_DEFLT_ } _N_ #-}
+ (+) = { _A_ 2 _U_ 11 _N_ _S_ "U(PPP)U(PPP)" {_A_ 4 _U_ 2221 _N_ _N_ _F_ _IF_ARGS_ 0 4 XXXC 5 \ (u0 :: Int#) (u1 :: Int#) (u2 :: ByteArray#) (u3 :: Integer) -> case u3 of { _ALG_ J# (u4 :: Int#) (u5 :: Int#) (u6 :: ByteArray#) -> _#_ plusInteger# [] [u0, u1, u2, u4, u5, u6]; _NO_DEFLT_ } _N_} _F_ _IF_ARGS_ 0 2 CC 6 \ (u0 :: Integer) (u1 :: Integer) -> case u0 of { _ALG_ J# (u2 :: Int#) (u3 :: Int#) (u4 :: ByteArray#) -> case u1 of { _ALG_ J# (u5 :: Int#) (u6 :: Int#) (u7 :: ByteArray#) -> _#_ plusInteger# [] [u2, u3, u4, u5, u6, u7]; _NO_DEFLT_ }; _NO_DEFLT_ } _N_ },
+ (-) = { _A_ 2 _U_ 11 _N_ _S_ "U(PPP)U(PPP)" {_A_ 4 _U_ 2221 _N_ _N_ _F_ _IF_ARGS_ 0 4 XXXC 5 \ (u0 :: Int#) (u1 :: Int#) (u2 :: ByteArray#) (u3 :: Integer) -> case u3 of { _ALG_ J# (u4 :: Int#) (u5 :: Int#) (u6 :: ByteArray#) -> _#_ minusInteger# [] [u0, u1, u2, u4, u5, u6]; _NO_DEFLT_ } _N_} _F_ _IF_ARGS_ 0 2 CC 6 \ (u0 :: Integer) (u1 :: Integer) -> case u0 of { _ALG_ J# (u2 :: Int#) (u3 :: Int#) (u4 :: ByteArray#) -> case u1 of { _ALG_ J# (u5 :: Int#) (u6 :: Int#) (u7 :: ByteArray#) -> _#_ minusInteger# [] [u2, u3, u4, u5, u6, u7]; _NO_DEFLT_ }; _NO_DEFLT_ } _N_ },
+ (*) = { _A_ 2 _U_ 11 _N_ _S_ "U(PPP)U(PPP)" {_A_ 4 _U_ 2221 _N_ _N_ _F_ _IF_ARGS_ 0 4 XXXC 5 \ (u0 :: Int#) (u1 :: Int#) (u2 :: ByteArray#) (u3 :: Integer) -> case u3 of { _ALG_ J# (u4 :: Int#) (u5 :: Int#) (u6 :: ByteArray#) -> _#_ timesInteger# [] [u0, u1, u2, u4, u5, u6]; _NO_DEFLT_ } _N_} _F_ _IF_ARGS_ 0 2 CC 6 \ (u0 :: Integer) (u1 :: Integer) -> case u0 of { _ALG_ J# (u2 :: Int#) (u3 :: Int#) (u4 :: ByteArray#) -> case u1 of { _ALG_ J# (u5 :: Int#) (u6 :: Int#) (u7 :: ByteArray#) -> _#_ timesInteger# [] [u2, u3, u4, u5, u6, u7]; _NO_DEFLT_ }; _NO_DEFLT_ } _N_ },
+ negate = { _A_ 1 _U_ 1 _N_ _S_ "U(PPP)" {_A_ 3 _U_ 222 _N_ _N_ _F_ _IF_ARGS_ 0 3 XXX 4 \ (u0 :: Int#) (u1 :: Int#) (u2 :: ByteArray#) -> _#_ negateInteger# [] [u0, u1, u2] _N_} _F_ _IF_ARGS_ 0 1 C 5 \ (u0 :: Integer) -> case u0 of { _ALG_ J# (u1 :: Int#) (u2 :: Int#) (u3 :: ByteArray#) -> _#_ negateInteger# [] [u1, u2, u3]; _NO_DEFLT_ } _N_ },
+ abs = { _A_ 1 _U_ 1 _N_ _S_ "U(PPP)" {_A_ 3 _U_ 222 _N_ _N_ _N_ _N_} _N_ _N_ },
+ signum = { _A_ 1 _U_ 1 _N_ _S_ "U(PPP)" {_A_ 3 _U_ 222 _N_ _N_ _N_ _N_} _N_ _N_ },
+ fromInteger = { _A_ 1 _U_ 1 _N_ _S_ "U(PPP)" {_A_ 3 _U_ 222 _N_ _N_ _F_ _IF_ARGS_ 0 3 XXX 4 \ (u0 :: Int#) (u1 :: Int#) (u2 :: ByteArray#) -> _!_ J# [] [u0, u1, u2] _N_} _F_ _IF_ARGS_ 0 1 X 1 \ (u0 :: Integer) -> u0 _N_ },
+ fromInt = { _A_ 1 _U_ 1 _N_ _S_ "U(P)" {_A_ 1 _U_ 2 _N_ _N_ _F_ _IF_ARGS_ 0 1 X 1 \ (u0 :: Int#) -> _#_ int2Integer# [] [u0] _N_} _F_ _IF_ARGS_ 0 1 C 2 \ (u0 :: Int) -> case u0 of { _ALG_ I# (u1 :: Int#) -> _#_ int2Integer# [] [u1]; _NO_DEFLT_ } _N_ } #-}
instance Integral a => Num (Ratio a)
{-# GHC_PRAGMA _M_ PreludeRatio {-dfun-} _A_ 3 _U_ 222 _N_ _N_ _N_ _N_ #-}
instance Num (Ratio Integer)
{-# GHC_PRAGMA _M_ PreludeRatio {-dfun-} _A_ 0 _N_ _N_ _N_ _F_ _IF_ARGS_ 0 0 X 11 _!_ _TUP_10 [{{Eq (Ratio Integer)}}, {{Text (Ratio Integer)}}, (Ratio Integer -> Ratio Integer -> Ratio Integer), (Ratio Integer -> Ratio Integer -> Ratio Integer), (Ratio Integer -> Ratio Integer -> Ratio Integer), (Ratio Integer -> Ratio Integer), (Ratio Integer -> Ratio Integer), (Ratio Integer -> Ratio Integer), (Integer -> Ratio Integer), (Int -> Ratio Integer)] [_DFUN_ Eq (Ratio Integer), _DFUN_ Text (Ratio Integer), _CONSTM_ Num (+) (Ratio Integer), _CONSTM_ Num (-) (Ratio Integer), _CONSTM_ Num (*) (Ratio Integer), _CONSTM_ Num negate (Ratio Integer), _CONSTM_ Num abs (Ratio Integer), _CONSTM_ Num signum (Ratio Integer), _CONSTM_ Num fromInteger (Ratio Integer), _CONSTM_ Num fromInt (Ratio Integer)] _N_
- (+) = _A_ 2 _U_ 11 _N_ _S_ "U(LU(PPP))U(LU(PPP))" {_A_ 5 _U_ 12221 _N_ _N_ _N_ _N_} _N_ _N_,
- (-) = _A_ 2 _U_ 11 _N_ _S_ "U(LU(PPP))U(LU(PPP))" {_A_ 5 _U_ 12221 _N_ _N_ _N_ _N_} _N_ _N_,
- (*) = _A_ 2 _U_ 11 _N_ _S_ "U(LU(PPP))U(LU(PPP))" {_A_ 5 _U_ 22221 _N_ _N_ _N_ _N_} _N_ _N_,
- negate = _A_ 1 _U_ 1 _N_ _S_ "U(LL)" {_A_ 2 _U_ 22 _N_ _N_ _N_ _N_} _N_ _N_,
- abs = _A_ 1 _U_ 1 _N_ _S_ "U(LL)" {_A_ 2 _U_ 12 _N_ _N_ _N_ _N_} _N_ _N_,
- signum = _A_ 1 _U_ 1 _N_ _S_ "U(LA)" {_A_ 1 _U_ 1 _N_ _N_ _N_ _N_} _N_ _N_,
- fromInteger = _A_ 1 _U_ 2 _N_ _N_ _N_ _N_,
- fromInt = _A_ 1 _U_ 1 _N_ _N_ _N_ _N_ #-}
+ (+) = { _A_ 2 _U_ 11 _N_ _S_ "U(LU(PPP))U(LU(PPP))" {_A_ 5 _U_ 12221 _N_ _N_ _N_ _N_} _N_ _N_ },
+ (-) = { _A_ 2 _U_ 11 _N_ _S_ "U(LU(PPP))U(LU(PPP))" {_A_ 5 _U_ 12221 _N_ _N_ _N_ _N_} _N_ _N_ },
+ (*) = { _A_ 2 _U_ 11 _N_ _S_ "U(LU(PPP))U(LU(PPP))" {_A_ 5 _U_ 22221 _N_ _N_ _N_ _N_} _N_ _N_ },
+ negate = { _A_ 1 _U_ 1 _N_ _S_ "U(LL)" {_A_ 2 _U_ 22 _N_ _N_ _N_ _N_} _N_ _N_ },
+ abs = { _A_ 1 _U_ 1 _N_ _S_ "U(LL)" {_A_ 2 _U_ 12 _N_ _N_ _N_ _N_} _N_ _N_ },
+ signum = { _A_ 1 _U_ 1 _N_ _S_ "U(LA)" {_A_ 1 _U_ 1 _N_ _N_ _N_ _N_} _N_ _N_ },
+ fromInteger = { _A_ 1 _U_ 2 _N_ _N_ _F_ _IF_ARGS_ 0 1 X 3 \ (u0 :: Integer) -> _!_ (:%) [Integer] [u0, _SPEC_ _ORIG_ PreludeCore __i1 [ (Integer) ]] _N_ },
+ fromInt = { _A_ 1 _U_ 1 _N_ _N_ _N_ _N_ } #-}
instance Ord ()
{-# GHC_PRAGMA _M_ PreludeBuiltin {-dfun-} _A_ 0 _N_ _N_ _N_ _F_ _IF_ARGS_ 0 0 X 9 _!_ _TUP_8 [{{Eq ()}}, (() -> () -> Bool), (() -> () -> Bool), (() -> () -> Bool), (() -> () -> Bool), (() -> () -> ()), (() -> () -> ()), (() -> () -> _CMP_TAG)] [_DFUN_ Eq (()), _CONSTM_ Ord (<) (()), _CONSTM_ Ord (<=) (()), _CONSTM_ Ord (>=) (()), _CONSTM_ Ord (>) (()), _CONSTM_ Ord max (()), _CONSTM_ Ord min (()), _CONSTM_ Ord _tagCmp (())] _N_
- (<) = _A_ 2 _U_ 11 _N_ _S_ "EE" _F_ _IF_ARGS_ 0 2 CC 3 \ (u0 :: ()) (u1 :: ()) -> case u0 of { _ALG_ _TUP_0 -> case u1 of { _ALG_ _TUP_0 -> _!_ False [] []; _NO_DEFLT_ }; _NO_DEFLT_ } _N_,
- (<=) = _A_ 2 _U_ 11 _N_ _S_ "EE" _F_ _IF_ARGS_ 0 2 CC 3 \ (u0 :: ()) (u1 :: ()) -> case u0 of { _ALG_ _TUP_0 -> case u1 of { _ALG_ _TUP_0 -> _!_ True [] []; _NO_DEFLT_ }; _NO_DEFLT_ } _N_,
- (>=) = _A_ 2 _U_ 11 _N_ _S_ "EE" _F_ _IF_ARGS_ 0 2 CC 3 \ (u0 :: ()) (u1 :: ()) -> case u0 of { _ALG_ _TUP_0 -> case u1 of { _ALG_ _TUP_0 -> _!_ True [] []; _NO_DEFLT_ }; _NO_DEFLT_ } _N_,
- (>) = _A_ 2 _U_ 11 _N_ _S_ "EE" _F_ _IF_ARGS_ 0 2 CC 3 \ (u0 :: ()) (u1 :: ()) -> case u0 of { _ALG_ _TUP_0 -> case u1 of { _ALG_ _TUP_0 -> _!_ False [] []; _NO_DEFLT_ }; _NO_DEFLT_ } _N_,
- max = _A_ 2 _U_ 11 _N_ _S_ "EE" _F_ _IF_ARGS_ 0 2 CX 2 \ (u0 :: ()) (u1 :: ()) -> case u0 of { _ALG_ _TUP_0 -> u1; _NO_DEFLT_ } _N_,
- min = _A_ 2 _U_ 11 _N_ _S_ "EE" _F_ _IF_ARGS_ 0 2 CX 2 \ (u0 :: ()) (u1 :: ()) -> case u0 of { _ALG_ _TUP_0 -> u1; _NO_DEFLT_ } _N_,
- _tagCmp = _A_ 2 _U_ 11 _N_ _S_ "EE" _F_ _IF_ARGS_ 0 2 CC 3 \ (u0 :: ()) (u1 :: ()) -> case u0 of { _ALG_ _TUP_0 -> case u1 of { _ALG_ _TUP_0 -> _!_ _EQ [] []; _NO_DEFLT_ }; _NO_DEFLT_ } _N_ #-}
+ (<) = { _A_ 2 _U_ 11 _N_ _S_ "EE" _F_ _IF_ARGS_ 0 2 CC 3 \ (u0 :: ()) (u1 :: ()) -> case u0 of { _ALG_ _TUP_0 -> case u1 of { _ALG_ _TUP_0 -> _!_ False [] []; _NO_DEFLT_ }; _NO_DEFLT_ } _N_ },
+ (<=) = { _A_ 2 _U_ 11 _N_ _S_ "EE" _F_ _IF_ARGS_ 0 2 CC 3 \ (u0 :: ()) (u1 :: ()) -> case u0 of { _ALG_ _TUP_0 -> case u1 of { _ALG_ _TUP_0 -> _!_ True [] []; _NO_DEFLT_ }; _NO_DEFLT_ } _N_ },
+ (>=) = { _A_ 2 _U_ 11 _N_ _S_ "EE" _F_ _IF_ARGS_ 0 2 CC 3 \ (u0 :: ()) (u1 :: ()) -> case u0 of { _ALG_ _TUP_0 -> case u1 of { _ALG_ _TUP_0 -> _!_ True [] []; _NO_DEFLT_ }; _NO_DEFLT_ } _N_ },
+ (>) = { _A_ 2 _U_ 11 _N_ _S_ "EE" _F_ _IF_ARGS_ 0 2 CC 3 \ (u0 :: ()) (u1 :: ()) -> case u0 of { _ALG_ _TUP_0 -> case u1 of { _ALG_ _TUP_0 -> _!_ False [] []; _NO_DEFLT_ }; _NO_DEFLT_ } _N_ },
+ max = { _A_ 2 _U_ 11 _N_ _S_ "EE" _F_ _IF_ARGS_ 0 2 CX 2 \ (u0 :: ()) (u1 :: ()) -> case u0 of { _ALG_ _TUP_0 -> u1; _NO_DEFLT_ } _N_ },
+ min = { _A_ 2 _U_ 11 _N_ _S_ "EE" _F_ _IF_ARGS_ 0 2 CX 2 \ (u0 :: ()) (u1 :: ()) -> case u0 of { _ALG_ _TUP_0 -> u1; _NO_DEFLT_ } _N_ },
+ _tagCmp = { _A_ 2 _U_ 11 _N_ _S_ "EE" _F_ _IF_ARGS_ 0 2 CC 3 \ (u0 :: ()) (u1 :: ()) -> case u0 of { _ALG_ _TUP_0 -> case u1 of { _ALG_ _TUP_0 -> _!_ _EQ [] []; _NO_DEFLT_ }; _NO_DEFLT_ } _N_ } #-}
instance (Ord a, Ord b) => Ord (a, b)
{-# GHC_PRAGMA _M_ PreludeBuiltin {-dfun-} _A_ 3 _U_ 112 _N_ _N_ _N_ _N_ #-}
instance (Ord a, Ord b, Ord c) => Ord (a, b, c)
{-# GHC_PRAGMA _M_ PreludeBuiltin {-dfun-} _A_ 6 _U_ 111112 _N_ _N_ _N_ _N_ #-}
instance Ord (Int, Int)
{-# GHC_PRAGMA _M_ PreludeBuiltin {-dfun-} _A_ 0 _N_ _N_ _N_ _F_ _IF_ARGS_ 0 0 X 9 _!_ _TUP_8 [{{Eq (Int, Int)}}, ((Int, Int) -> (Int, Int) -> Bool), ((Int, Int) -> (Int, Int) -> Bool), ((Int, Int) -> (Int, Int) -> Bool), ((Int, Int) -> (Int, Int) -> Bool), ((Int, Int) -> (Int, Int) -> (Int, Int)), ((Int, Int) -> (Int, Int) -> (Int, Int)), ((Int, Int) -> (Int, Int) -> _CMP_TAG)] [_DFUN_ Eq ((Int, Int)), _CONSTM_ Ord (<) ((Int, Int)), _CONSTM_ Ord (<=) ((Int, Int)), _CONSTM_ Ord (>=) ((Int, Int)), _CONSTM_ Ord (>) ((Int, Int)), _CONSTM_ Ord max ((Int, Int)), _CONSTM_ Ord min ((Int, Int)), _CONSTM_ Ord _tagCmp ((Int, Int))] _N_
- (<) = _A_ 2 _U_ 11 _N_ _S_ "U(U(P)L)U(U(P)L)" {_A_ 4 _U_ 2121 _N_ _N_ _N_ _N_} _N_ _N_,
- (<=) = _A_ 2 _U_ 11 _N_ _S_ "U(U(P)L)U(U(P)L)" {_A_ 4 _U_ 2121 _N_ _N_ _N_ _N_} _N_ _N_,
- (>=) = _A_ 2 _U_ 11 _N_ _S_ "U(U(P)L)U(U(P)L)" {_A_ 4 _U_ 2121 _N_ _N_ _N_ _N_} _N_ _N_,
- (>) = _A_ 2 _U_ 11 _N_ _S_ "U(U(P)L)U(U(P)L)" {_A_ 4 _U_ 2121 _N_ _N_ _N_ _N_} _N_ _N_,
- max = _A_ 2 _U_ 11 _N_ _S_ "U(U(P)L)U(U(P)L)" {_A_ 4 _U_ 2222 _N_ _N_ _N_ _N_} _N_ _N_,
- min = _A_ 2 _U_ 11 _N_ _S_ "U(U(P)L)U(U(P)L)" {_A_ 4 _U_ 2222 _N_ _N_ _N_ _N_} _N_ _N_,
- _tagCmp = _A_ 2 _U_ 11 _N_ _S_ "U(U(P)L)U(U(P)L)" {_A_ 4 _U_ 2121 _N_ _N_ _N_ _N_} _N_ _N_ #-}
+ (<) = { _A_ 2 _U_ 11 _N_ _S_ "U(U(P)L)U(U(P)L)" {_A_ 4 _U_ 2121 _N_ _N_ _N_ _N_} _N_ _N_ },
+ (<=) = { _A_ 2 _U_ 11 _N_ _S_ "U(U(P)L)U(U(P)L)" {_A_ 4 _U_ 2121 _N_ _N_ _N_ _N_} _N_ _N_ },
+ (>=) = { _A_ 2 _U_ 11 _N_ _S_ "U(U(P)L)U(U(P)L)" {_A_ 4 _U_ 2121 _N_ _N_ _N_ _N_} _N_ _N_ },
+ (>) = { _A_ 2 _U_ 11 _N_ _S_ "U(U(P)L)U(U(P)L)" {_A_ 4 _U_ 2121 _N_ _N_ _N_ _N_} _N_ _N_ },
+ max = { _A_ 2 _U_ 11 _N_ _S_ "U(U(P)L)U(U(P)L)" {_A_ 4 _U_ 2222 _N_ _N_ _N_ _N_} _N_ _N_ },
+ min = { _A_ 2 _U_ 11 _N_ _S_ "U(U(P)L)U(U(P)L)" {_A_ 4 _U_ 2222 _N_ _N_ _N_ _N_} _N_ _N_ },
+ _tagCmp = { _A_ 2 _U_ 11 _N_ _S_ "U(U(P)L)U(U(P)L)" {_A_ 4 _U_ 2121 _N_ _N_ _N_ _N_} _N_ _N_ } #-}
+instance Ord (Int, Int, Int)
+ {-# GHC_PRAGMA _M_ PreludeBuiltin {-dfun-} _A_ 0 _N_ _N_ _N_ _F_ _IF_ARGS_ 0 0 X 9 _!_ _TUP_8 [{{Eq (Int, Int, Int)}}, ((Int, Int, Int) -> (Int, Int, Int) -> Bool), ((Int, Int, Int) -> (Int, Int, Int) -> Bool), ((Int, Int, Int) -> (Int, Int, Int) -> Bool), ((Int, Int, Int) -> (Int, Int, Int) -> Bool), ((Int, Int, Int) -> (Int, Int, Int) -> (Int, Int, Int)), ((Int, Int, Int) -> (Int, Int, Int) -> (Int, Int, Int)), ((Int, Int, Int) -> (Int, Int, Int) -> _CMP_TAG)] [_DFUN_ Eq ((Int, Int, Int)), _CONSTM_ Ord (<) ((Int, Int, Int)), _CONSTM_ Ord (<=) ((Int, Int, Int)), _CONSTM_ Ord (>=) ((Int, Int, Int)), _CONSTM_ Ord (>) ((Int, Int, Int)), _CONSTM_ Ord max ((Int, Int, Int)), _CONSTM_ Ord min ((Int, Int, Int)), _CONSTM_ Ord _tagCmp ((Int, Int, Int))] _N_
+ (<) = { _A_ 2 _U_ 11 _N_ _S_ "U(U(P)LL)U(U(P)LL)" {_A_ 4 _U_ 2111 _N_ _N_ _N_ _N_} _N_ _N_ },
+ (<=) = { _A_ 2 _U_ 11 _N_ _S_ "U(U(P)LL)U(U(P)LL)" {_A_ 4 _U_ 2111 _N_ _N_ _N_ _N_} _N_ _N_ },
+ (>=) = { _A_ 2 _U_ 11 _N_ _S_ "U(U(P)LL)U(U(P)LL)" {_A_ 4 _U_ 2111 _N_ _N_ _N_ _N_} _N_ _N_ },
+ (>) = { _A_ 2 _U_ 11 _N_ _S_ "U(U(P)LL)U(U(P)LL)" {_A_ 4 _U_ 2111 _N_ _N_ _N_ _N_} _N_ _N_ },
+ max = { _A_ 2 _U_ 12 _N_ _S_ "U(U(P)LL)U(U(P)LL)" {_A_ 4 _U_ 2222 _N_ _N_ _N_ _N_} _N_ _N_ },
+ min = { _A_ 2 _U_ 12 _N_ _S_ "U(U(P)LL)U(U(P)LL)" {_A_ 4 _U_ 2222 _N_ _N_ _N_ _N_} _N_ _N_ },
+ _tagCmp = { _A_ 2 _U_ 11 _N_ _S_ "U(U(P)LL)U(U(P)LL)" {_A_ 4 _U_ 2111 _N_ _N_ _N_ _N_} _N_ _N_ } #-}
+instance Ord (Int, Int, Int, Int)
+ {-# GHC_PRAGMA _M_ PreludeBuiltin {-dfun-} _A_ 0 _N_ _N_ _N_ _F_ _IF_ARGS_ 0 0 X 9 _!_ _TUP_8 [{{Eq (Int, Int, Int, Int)}}, ((Int, Int, Int, Int) -> (Int, Int, Int, Int) -> Bool), ((Int, Int, Int, Int) -> (Int, Int, Int, Int) -> Bool), ((Int, Int, Int, Int) -> (Int, Int, Int, Int) -> Bool), ((Int, Int, Int, Int) -> (Int, Int, Int, Int) -> Bool), ((Int, Int, Int, Int) -> (Int, Int, Int, Int) -> (Int, Int, Int, Int)), ((Int, Int, Int, Int) -> (Int, Int, Int, Int) -> (Int, Int, Int, Int)), ((Int, Int, Int, Int) -> (Int, Int, Int, Int) -> _CMP_TAG)] [_DFUN_ Eq ((Int, Int, Int, Int)), _CONSTM_ Ord (<) ((Int, Int, Int, Int)), _CONSTM_ Ord (<=) ((Int, Int, Int, Int)), _CONSTM_ Ord (>=) ((Int, Int, Int, Int)), _CONSTM_ Ord (>) ((Int, Int, Int, Int)), _CONSTM_ Ord max ((Int, Int, Int, Int)), _CONSTM_ Ord min ((Int, Int, Int, Int)), _CONSTM_ Ord _tagCmp ((Int, Int, Int, Int))] _N_
+ (<) = { _A_ 2 _U_ 11 _N_ _S_ "U(U(P)LLL)U(U(P)LLL)" {_A_ 5 _U_ 21111 _N_ _N_ _N_ _N_} _N_ _N_ },
+ (<=) = { _A_ 2 _U_ 11 _N_ _S_ "U(U(P)LLL)U(U(P)LLL)" {_A_ 5 _U_ 21111 _N_ _N_ _N_ _N_} _N_ _N_ },
+ (>=) = { _A_ 2 _U_ 11 _N_ _S_ "U(U(P)LLL)U(U(P)LLL)" {_A_ 5 _U_ 21111 _N_ _N_ _N_ _N_} _N_ _N_ },
+ (>) = { _A_ 2 _U_ 11 _N_ _S_ "U(U(P)LLL)U(U(P)LLL)" {_A_ 5 _U_ 21111 _N_ _N_ _N_ _N_} _N_ _N_ },
+ max = { _A_ 2 _U_ 12 _N_ _S_ "U(U(P)LLL)U(U(P)LLL)" {_A_ 5 _U_ 22222 _N_ _N_ _N_ _N_} _N_ _N_ },
+ min = { _A_ 2 _U_ 12 _N_ _S_ "U(U(P)LLL)U(U(P)LLL)" {_A_ 5 _U_ 22222 _N_ _N_ _N_ _N_} _N_ _N_ },
+ _tagCmp = { _A_ 2 _U_ 11 _N_ _S_ "U(U(P)LLL)U(U(P)LLL)" {_A_ 5 _U_ 21111 _N_ _N_ _N_ _N_} _N_ _N_ } #-}
+instance Ord (Int, Int, Int, Int, Int)
+ {-# GHC_PRAGMA _M_ PreludeBuiltin {-dfun-} _A_ 0 _N_ _N_ _N_ _F_ _IF_ARGS_ 0 0 X 9 _!_ _TUP_8 [{{Eq (Int, Int, Int, Int, Int)}}, ((Int, Int, Int, Int, Int) -> (Int, Int, Int, Int, Int) -> Bool), ((Int, Int, Int, Int, Int) -> (Int, Int, Int, Int, Int) -> Bool), ((Int, Int, Int, Int, Int) -> (Int, Int, Int, Int, Int) -> Bool), ((Int, Int, Int, Int, Int) -> (Int, Int, Int, Int, Int) -> Bool), ((Int, Int, Int, Int, Int) -> (Int, Int, Int, Int, Int) -> (Int, Int, Int, Int, Int)), ((Int, Int, Int, Int, Int) -> (Int, Int, Int, Int, Int) -> (Int, Int, Int, Int, Int)), ((Int, Int, Int, Int, Int) -> (Int, Int, Int, Int, Int) -> _CMP_TAG)] [_DFUN_ Eq ((Int, Int, Int, Int, Int)), _CONSTM_ Ord (<) ((Int, Int, Int, Int, Int)), _CONSTM_ Ord (<=) ((Int, Int, Int, Int, Int)), _CONSTM_ Ord (>=) ((Int, Int, Int, Int, Int)), _CONSTM_ Ord (>) ((Int, Int, Int, Int, Int)), _CONSTM_ Ord max ((Int, Int, Int, Int, Int)), _CONSTM_ Ord min ((Int, Int, Int, Int, Int)), _CONSTM_ Ord _tagCmp ((Int, Int, Int, Int, Int))] _N_
+ (<) = { _A_ 2 _U_ 11 _N_ _S_ "U(U(P)LLLL)U(U(P)LLLL)" _N_ _N_ },
+ (<=) = { _A_ 2 _U_ 11 _N_ _S_ "U(U(P)LLLL)U(U(P)LLLL)" _N_ _N_ },
+ (>=) = { _A_ 2 _U_ 11 _N_ _S_ "U(U(P)LLLL)U(U(P)LLLL)" _N_ _N_ },
+ (>) = { _A_ 2 _U_ 11 _N_ _S_ "U(U(P)LLLL)U(U(P)LLLL)" _N_ _N_ },
+ max = { _A_ 2 _U_ 22 _N_ _S_ "U(U(P)LLLL)U(U(P)LLLL)" _N_ _N_ },
+ min = { _A_ 2 _U_ 22 _N_ _S_ "U(U(P)LLLL)U(U(P)LLLL)" _N_ _N_ },
+ _tagCmp = { _A_ 2 _U_ 11 _N_ _S_ "U(U(P)LLLL)U(U(P)LLLL)" _N_ _N_ } #-}
+instance Ord ([Char], [Char])
+ {-# GHC_PRAGMA _M_ PreludeBuiltin {-dfun-} _A_ 0 _N_ _N_ _N_ _F_ _IF_ARGS_ 0 0 X 9 _!_ _TUP_8 [{{Eq ([Char], [Char])}}, (([Char], [Char]) -> ([Char], [Char]) -> Bool), (([Char], [Char]) -> ([Char], [Char]) -> Bool), (([Char], [Char]) -> ([Char], [Char]) -> Bool), (([Char], [Char]) -> ([Char], [Char]) -> Bool), (([Char], [Char]) -> ([Char], [Char]) -> ([Char], [Char])), (([Char], [Char]) -> ([Char], [Char]) -> ([Char], [Char])), (([Char], [Char]) -> ([Char], [Char]) -> _CMP_TAG)] [_DFUN_ Eq (([Char], [Char])), _CONSTM_ Ord (<) (([Char], [Char])), _CONSTM_ Ord (<=) (([Char], [Char])), _CONSTM_ Ord (>=) (([Char], [Char])), _CONSTM_ Ord (>) (([Char], [Char])), _CONSTM_ Ord max (([Char], [Char])), _CONSTM_ Ord min (([Char], [Char])), _CONSTM_ Ord _tagCmp (([Char], [Char]))] _N_
+ (<) = { _A_ 2 _U_ 11 _N_ _S_ "U(SL)U(SL)" {_A_ 4 _U_ 2222 _N_ _N_ _N_ _N_} _N_ _N_ },
+ (<=) = { _A_ 2 _U_ 11 _N_ _S_ "U(SL)U(SL)" {_A_ 4 _U_ 2222 _N_ _N_ _N_ _N_} _N_ _N_ },
+ (>=) = { _A_ 2 _U_ 11 _N_ _S_ "U(SL)U(SL)" {_A_ 4 _U_ 2222 _N_ _N_ _N_ _N_} _N_ _N_ },
+ (>) = { _A_ 2 _U_ 11 _N_ _S_ "U(SL)U(SL)" {_A_ 4 _U_ 2222 _N_ _N_ _N_ _N_} _N_ _N_ },
+ max = { _A_ 2 _U_ 11 _N_ _S_ "U(SL)U(SL)" {_A_ 4 _U_ 2222 _N_ _N_ _N_ _N_} _N_ _N_ },
+ min = { _A_ 2 _U_ 11 _N_ _S_ "U(SL)U(SL)" {_A_ 4 _U_ 2222 _N_ _N_ _N_ _N_} _N_ _N_ },
+ _tagCmp = { _A_ 2 _U_ 11 _N_ _S_ "U(SL)U(SL)" {_A_ 4 _U_ 2222 _N_ _N_ _N_ _N_} _N_ _N_ } #-}
+instance Ord ([Int], [Int])
+ {-# GHC_PRAGMA _M_ PreludeBuiltin {-dfun-} _A_ 0 _N_ _N_ _N_ _F_ _IF_ARGS_ 0 0 X 9 _!_ _TUP_8 [{{Eq ([Int], [Int])}}, (([Int], [Int]) -> ([Int], [Int]) -> Bool), (([Int], [Int]) -> ([Int], [Int]) -> Bool), (([Int], [Int]) -> ([Int], [Int]) -> Bool), (([Int], [Int]) -> ([Int], [Int]) -> Bool), (([Int], [Int]) -> ([Int], [Int]) -> ([Int], [Int])), (([Int], [Int]) -> ([Int], [Int]) -> ([Int], [Int])), (([Int], [Int]) -> ([Int], [Int]) -> _CMP_TAG)] [_DFUN_ Eq (([Int], [Int])), _CONSTM_ Ord (<) (([Int], [Int])), _CONSTM_ Ord (<=) (([Int], [Int])), _CONSTM_ Ord (>=) (([Int], [Int])), _CONSTM_ Ord (>) (([Int], [Int])), _CONSTM_ Ord max (([Int], [Int])), _CONSTM_ Ord min (([Int], [Int])), _CONSTM_ Ord _tagCmp (([Int], [Int]))] _N_
+ (<) = { _A_ 2 _U_ 11 _N_ _S_ "U(SL)U(SL)" {_A_ 4 _U_ 2222 _N_ _N_ _N_ _N_} _N_ _N_ },
+ (<=) = { _A_ 2 _U_ 11 _N_ _S_ "U(SL)U(SL)" {_A_ 4 _U_ 2222 _N_ _N_ _N_ _N_} _N_ _N_ },
+ (>=) = { _A_ 2 _U_ 11 _N_ _S_ "U(SL)U(SL)" {_A_ 4 _U_ 2222 _N_ _N_ _N_ _N_} _N_ _N_ },
+ (>) = { _A_ 2 _U_ 11 _N_ _S_ "U(SL)U(SL)" {_A_ 4 _U_ 2222 _N_ _N_ _N_ _N_} _N_ _N_ },
+ max = { _A_ 2 _U_ 11 _N_ _S_ "U(SL)U(SL)" {_A_ 4 _U_ 2222 _N_ _N_ _N_ _N_} _N_ _N_ },
+ min = { _A_ 2 _U_ 11 _N_ _S_ "U(SL)U(SL)" {_A_ 4 _U_ 2222 _N_ _N_ _N_ _N_} _N_ _N_ },
+ _tagCmp = { _A_ 2 _U_ 11 _N_ _S_ "U(SL)U(SL)" {_A_ 4 _U_ 2222 _N_ _N_ _N_ _N_} _N_ _N_ } #-}
instance Ord (_PackedString, _PackedString)
{-# GHC_PRAGMA _M_ PreludeBuiltin {-dfun-} _A_ 0 _N_ _N_ _N_ _F_ _IF_ARGS_ 0 0 X 9 _!_ _TUP_8 [{{Eq (_PackedString, _PackedString)}}, ((_PackedString, _PackedString) -> (_PackedString, _PackedString) -> Bool), ((_PackedString, _PackedString) -> (_PackedString, _PackedString) -> Bool), ((_PackedString, _PackedString) -> (_PackedString, _PackedString) -> Bool), ((_PackedString, _PackedString) -> (_PackedString, _PackedString) -> Bool), ((_PackedString, _PackedString) -> (_PackedString, _PackedString) -> (_PackedString, _PackedString)), ((_PackedString, _PackedString) -> (_PackedString, _PackedString) -> (_PackedString, _PackedString)), ((_PackedString, _PackedString) -> (_PackedString, _PackedString) -> _CMP_TAG)] [_DFUN_ Eq ((_PackedString, _PackedString)), _CONSTM_ Ord (<) ((_PackedString, _PackedString)), _CONSTM_ Ord (<=) ((_PackedString, _PackedString)), _CONSTM_ Ord (>=) ((_PackedString, _PackedString)), _CONSTM_ Ord (>) ((_PackedString, _PackedString)), _CONSTM_ Ord max ((_PackedString, _PackedString)), _CONSTM_ Ord min ((_PackedString, _PackedString)), _CONSTM_ Ord _tagCmp ((_PackedString, _PackedString))] _N_
- (<) = _A_ 2 _U_ 11 _N_ _S_ "U(SL)U(SL)" {_A_ 4 _U_ 2222 _N_ _N_ _N_ _N_} _N_ _N_,
- (<=) = _A_ 2 _U_ 11 _N_ _S_ "U(SL)U(SL)" {_A_ 4 _U_ 2222 _N_ _N_ _N_ _N_} _N_ _N_,
- (>=) = _A_ 2 _U_ 11 _N_ _S_ "U(SL)U(SL)" {_A_ 4 _U_ 2222 _N_ _N_ _N_ _N_} _N_ _N_,
- (>) = _A_ 2 _U_ 11 _N_ _S_ "U(SL)U(SL)" {_A_ 4 _U_ 2222 _N_ _N_ _N_ _N_} _N_ _N_,
- max = _A_ 2 _U_ 11 _N_ _S_ "U(SL)U(SL)" {_A_ 4 _U_ 2222 _N_ _N_ _N_ _N_} _N_ _N_,
- min = _A_ 2 _U_ 11 _N_ _S_ "U(SL)U(SL)" {_A_ 4 _U_ 2222 _N_ _N_ _N_ _N_} _N_ _N_,
- _tagCmp = _A_ 2 _U_ 11 _N_ _S_ "U(SL)U(SL)" {_A_ 4 _U_ 2222 _N_ _N_ _N_ _N_} _N_ _N_ #-}
+ (<) = { _A_ 2 _U_ 11 _N_ _S_ "U(SL)U(SL)" {_A_ 4 _U_ 2222 _N_ _N_ _N_ _N_} _N_ _N_ },
+ (<=) = { _A_ 2 _U_ 11 _N_ _S_ "U(SL)U(SL)" {_A_ 4 _U_ 2222 _N_ _N_ _N_ _N_} _N_ _N_ },
+ (>=) = { _A_ 2 _U_ 11 _N_ _S_ "U(SL)U(SL)" {_A_ 4 _U_ 2222 _N_ _N_ _N_ _N_} _N_ _N_ },
+ (>) = { _A_ 2 _U_ 11 _N_ _S_ "U(SL)U(SL)" {_A_ 4 _U_ 2222 _N_ _N_ _N_ _N_} _N_ _N_ },
+ max = { _A_ 2 _U_ 11 _N_ _S_ "U(SL)U(SL)" {_A_ 4 _U_ 2222 _N_ _N_ _N_ _N_} _N_ _N_ },
+ min = { _A_ 2 _U_ 11 _N_ _S_ "U(SL)U(SL)" {_A_ 4 _U_ 2222 _N_ _N_ _N_ _N_} _N_ _N_ },
+ _tagCmp = { _A_ 2 _U_ 11 _N_ _S_ "U(SL)U(SL)" {_A_ 4 _U_ 2222 _N_ _N_ _N_ _N_} _N_ _N_ } #-}
instance (Ix a, Ord b) => Ord (Array a b)
{-# GHC_PRAGMA _M_ PreludeArray {-dfun-} _A_ 3 _U_ 222 _N_ _N_ _N_ _N_ #-}
instance (Ord a, Ord b) => Ord (Assoc a b)
{-# GHC_PRAGMA _M_ PreludeArray {-dfun-} _A_ 3 _U_ 112 _N_ _N_ _N_ _N_ #-}
instance Ord Bool
{-# GHC_PRAGMA _M_ PreludeCore {-dfun-} _A_ 0 _N_ _N_ _N_ _F_ _IF_ARGS_ 0 0 X 9 _!_ _TUP_8 [{{Eq Bool}}, (Bool -> Bool -> Bool), (Bool -> Bool -> Bool), (Bool -> Bool -> Bool), (Bool -> Bool -> Bool), (Bool -> Bool -> Bool), (Bool -> Bool -> Bool), (Bool -> Bool -> _CMP_TAG)] [_DFUN_ Eq (Bool), _CONSTM_ Ord (<) (Bool), _CONSTM_ Ord (<=) (Bool), _CONSTM_ Ord (>=) (Bool), _CONSTM_ Ord (>) (Bool), _CONSTM_ Ord max (Bool), _CONSTM_ Ord min (Bool), _CONSTM_ Ord _tagCmp (Bool)] _N_
- (<) = _A_ 2 _U_ 11 _N_ _S_ "EE" _N_ _N_,
- (<=) = _A_ 2 _U_ 11 _N_ _S_ "EE" _N_ _N_,
- (>=) = _A_ 2 _U_ 11 _N_ _S_ "EE" _N_ _N_,
- (>) = _A_ 2 _U_ 11 _N_ _S_ "EE" _N_ _N_,
- max = _A_ 2 _U_ 22 _N_ _S_ "EE" _N_ _N_,
- min = _A_ 2 _U_ 22 _N_ _S_ "EE" _N_ _N_,
- _tagCmp = _A_ 2 _U_ 11 _N_ _S_ "EE" _N_ _N_ #-}
+ (<) = { _A_ 2 _U_ 11 _N_ _S_ "EE" _N_ _N_ },
+ (<=) = { _A_ 2 _U_ 11 _N_ _S_ "EE" _N_ _N_ },
+ (>=) = { _A_ 2 _U_ 11 _N_ _S_ "EE" _N_ _N_ },
+ (>) = { _A_ 2 _U_ 11 _N_ _S_ "EE" _N_ _N_ },
+ max = { _A_ 2 _U_ 22 _N_ _S_ "EE" _N_ _N_ },
+ min = { _A_ 2 _U_ 22 _N_ _S_ "EE" _N_ _N_ },
+ _tagCmp = { _A_ 2 _U_ 11 _N_ _S_ "EE" _N_ _N_ } #-}
instance Ord Char
{-# GHC_PRAGMA _M_ PreludeCore {-dfun-} _A_ 0 _N_ _N_ _N_ _F_ _IF_ARGS_ 0 0 X 9 _!_ _TUP_8 [{{Eq Char}}, (Char -> Char -> Bool), (Char -> Char -> Bool), (Char -> Char -> Bool), (Char -> Char -> Bool), (Char -> Char -> Char), (Char -> Char -> Char), (Char -> Char -> _CMP_TAG)] [_DFUN_ Eq (Char), _CONSTM_ Ord (<) (Char), _CONSTM_ Ord (<=) (Char), _CONSTM_ Ord (>=) (Char), _CONSTM_ Ord (>) (Char), _CONSTM_ Ord max (Char), _CONSTM_ Ord min (Char), _CONSTM_ Ord _tagCmp (Char)] _N_
- (<) = _A_ 2 _U_ 11 _N_ _S_ "U(P)U(P)" {_A_ 2 _U_ 22 _N_ _N_ _F_ _IF_ARGS_ 0 2 XX 1 \ (u0 :: Char#) (u1 :: Char#) -> _#_ ltChar# [] [u0, u1] _N_} _F_ _IF_ARGS_ 0 2 CC 3 \ (u0 :: Char) (u1 :: Char) -> case u0 of { _ALG_ C# (u2 :: Char#) -> case u1 of { _ALG_ C# (u3 :: Char#) -> _#_ ltChar# [] [u2, u3]; _NO_DEFLT_ }; _NO_DEFLT_ } _N_,
- (<=) = _A_ 2 _U_ 11 _N_ _S_ "U(P)U(P)" {_A_ 2 _U_ 22 _N_ _N_ _F_ _IF_ARGS_ 0 2 XX 1 \ (u0 :: Char#) (u1 :: Char#) -> _#_ leChar# [] [u0, u1] _N_} _F_ _IF_ARGS_ 0 2 CC 3 \ (u0 :: Char) (u1 :: Char) -> case u0 of { _ALG_ C# (u2 :: Char#) -> case u1 of { _ALG_ C# (u3 :: Char#) -> _#_ leChar# [] [u2, u3]; _NO_DEFLT_ }; _NO_DEFLT_ } _N_,
- (>=) = _A_ 2 _U_ 11 _N_ _S_ "U(P)U(P)" {_A_ 2 _U_ 22 _N_ _N_ _F_ _IF_ARGS_ 0 2 XX 1 \ (u0 :: Char#) (u1 :: Char#) -> _#_ geChar# [] [u0, u1] _N_} _F_ _IF_ARGS_ 0 2 CC 3 \ (u0 :: Char) (u1 :: Char) -> case u0 of { _ALG_ C# (u2 :: Char#) -> case u1 of { _ALG_ C# (u3 :: Char#) -> _#_ geChar# [] [u2, u3]; _NO_DEFLT_ }; _NO_DEFLT_ } _N_,
- (>) = _A_ 2 _U_ 11 _N_ _S_ "U(P)U(P)" {_A_ 2 _U_ 22 _N_ _N_ _F_ _IF_ARGS_ 0 2 XX 1 \ (u0 :: Char#) (u1 :: Char#) -> _#_ gtChar# [] [u0, u1] _N_} _F_ _IF_ARGS_ 0 2 CC 3 \ (u0 :: Char) (u1 :: Char) -> case u0 of { _ALG_ C# (u2 :: Char#) -> case u1 of { _ALG_ C# (u3 :: Char#) -> _#_ gtChar# [] [u2, u3]; _NO_DEFLT_ }; _NO_DEFLT_ } _N_,
- max = _A_ 2 _U_ 11 _N_ _S_ "U(P)U(P)" {_A_ 2 _U_ 22 _N_ _N_ _N_ _N_} _N_ _N_,
- min = _A_ 2 _U_ 11 _N_ _S_ "U(P)U(P)" {_A_ 2 _U_ 22 _N_ _N_ _N_ _N_} _N_ _N_,
- _tagCmp = _A_ 2 _U_ 11 _N_ _S_ "U(P)U(P)" {_A_ 2 _U_ 22 _N_ _N_ _N_ _N_} _N_ _N_ #-}
+ (<) = { _A_ 2 _U_ 11 _N_ _S_ "U(P)U(P)" {_A_ 2 _U_ 22 _N_ _N_ _F_ _IF_ARGS_ 0 2 XX 1 \ (u0 :: Char#) (u1 :: Char#) -> _#_ ltChar# [] [u0, u1] _N_} _F_ _IF_ARGS_ 0 2 CC 3 \ (u0 :: Char) (u1 :: Char) -> case u0 of { _ALG_ C# (u2 :: Char#) -> case u1 of { _ALG_ C# (u3 :: Char#) -> _#_ ltChar# [] [u2, u3]; _NO_DEFLT_ }; _NO_DEFLT_ } _N_ },
+ (<=) = { _A_ 2 _U_ 11 _N_ _S_ "U(P)U(P)" {_A_ 2 _U_ 22 _N_ _N_ _F_ _IF_ARGS_ 0 2 XX 1 \ (u0 :: Char#) (u1 :: Char#) -> _#_ leChar# [] [u0, u1] _N_} _F_ _IF_ARGS_ 0 2 CC 3 \ (u0 :: Char) (u1 :: Char) -> case u0 of { _ALG_ C# (u2 :: Char#) -> case u1 of { _ALG_ C# (u3 :: Char#) -> _#_ leChar# [] [u2, u3]; _NO_DEFLT_ }; _NO_DEFLT_ } _N_ },
+ (>=) = { _A_ 2 _U_ 11 _N_ _S_ "U(P)U(P)" {_A_ 2 _U_ 22 _N_ _N_ _F_ _IF_ARGS_ 0 2 XX 1 \ (u0 :: Char#) (u1 :: Char#) -> _#_ geChar# [] [u0, u1] _N_} _F_ _IF_ARGS_ 0 2 CC 3 \ (u0 :: Char) (u1 :: Char) -> case u0 of { _ALG_ C# (u2 :: Char#) -> case u1 of { _ALG_ C# (u3 :: Char#) -> _#_ geChar# [] [u2, u3]; _NO_DEFLT_ }; _NO_DEFLT_ } _N_ },
+ (>) = { _A_ 2 _U_ 11 _N_ _S_ "U(P)U(P)" {_A_ 2 _U_ 22 _N_ _N_ _F_ _IF_ARGS_ 0 2 XX 1 \ (u0 :: Char#) (u1 :: Char#) -> _#_ gtChar# [] [u0, u1] _N_} _F_ _IF_ARGS_ 0 2 CC 3 \ (u0 :: Char) (u1 :: Char) -> case u0 of { _ALG_ C# (u2 :: Char#) -> case u1 of { _ALG_ C# (u3 :: Char#) -> _#_ gtChar# [] [u2, u3]; _NO_DEFLT_ }; _NO_DEFLT_ } _N_ },
+ max = { _A_ 2 _U_ 11 _N_ _S_ "U(P)U(P)" {_A_ 2 _U_ 22 _N_ _N_ _N_ _N_} _N_ _N_ },
+ min = { _A_ 2 _U_ 11 _N_ _S_ "U(P)U(P)" {_A_ 2 _U_ 22 _N_ _N_ _N_ _N_} _N_ _N_ },
+ _tagCmp = { _A_ 2 _U_ 11 _N_ _S_ "U(P)U(P)" {_A_ 2 _U_ 22 _N_ _N_ _N_ _N_} _N_ _N_ } #-}
instance Ord Double
{-# GHC_PRAGMA _M_ PreludeCore {-dfun-} _A_ 0 _N_ _N_ _N_ _F_ _IF_ARGS_ 0 0 X 9 _!_ _TUP_8 [{{Eq Double}}, (Double -> Double -> Bool), (Double -> Double -> Bool), (Double -> Double -> Bool), (Double -> Double -> Bool), (Double -> Double -> Double), (Double -> Double -> Double), (Double -> Double -> _CMP_TAG)] [_DFUN_ Eq (Double), _CONSTM_ Ord (<) (Double), _CONSTM_ Ord (<=) (Double), _CONSTM_ Ord (>=) (Double), _CONSTM_ Ord (>) (Double), _CONSTM_ Ord max (Double), _CONSTM_ Ord min (Double), _CONSTM_ Ord _tagCmp (Double)] _N_
- (<) = _A_ 2 _U_ 11 _N_ _S_ "U(P)U(P)" {_A_ 2 _U_ 22 _N_ _N_ _F_ _IF_ARGS_ 0 2 XX 1 \ (u0 :: Double#) (u1 :: Double#) -> _#_ ltDouble# [] [u0, u1] _N_} _F_ _IF_ARGS_ 0 2 CC 3 \ (u0 :: Double) (u1 :: Double) -> case u0 of { _ALG_ D# (u2 :: Double#) -> case u1 of { _ALG_ D# (u3 :: Double#) -> _#_ ltDouble# [] [u2, u3]; _NO_DEFLT_ }; _NO_DEFLT_ } _N_,
- (<=) = _A_ 2 _U_ 11 _N_ _S_ "U(P)U(P)" {_A_ 2 _U_ 22 _N_ _N_ _F_ _IF_ARGS_ 0 2 XX 1 \ (u0 :: Double#) (u1 :: Double#) -> _#_ leDouble# [] [u0, u1] _N_} _F_ _IF_ARGS_ 0 2 CC 3 \ (u0 :: Double) (u1 :: Double) -> case u0 of { _ALG_ D# (u2 :: Double#) -> case u1 of { _ALG_ D# (u3 :: Double#) -> _#_ leDouble# [] [u2, u3]; _NO_DEFLT_ }; _NO_DEFLT_ } _N_,
- (>=) = _A_ 2 _U_ 11 _N_ _S_ "U(P)U(P)" {_A_ 2 _U_ 22 _N_ _N_ _F_ _IF_ARGS_ 0 2 XX 1 \ (u0 :: Double#) (u1 :: Double#) -> _#_ geDouble# [] [u0, u1] _N_} _F_ _IF_ARGS_ 0 2 CC 3 \ (u0 :: Double) (u1 :: Double) -> case u0 of { _ALG_ D# (u2 :: Double#) -> case u1 of { _ALG_ D# (u3 :: Double#) -> _#_ geDouble# [] [u2, u3]; _NO_DEFLT_ }; _NO_DEFLT_ } _N_,
- (>) = _A_ 2 _U_ 11 _N_ _S_ "U(P)U(P)" {_A_ 2 _U_ 22 _N_ _N_ _F_ _IF_ARGS_ 0 2 XX 1 \ (u0 :: Double#) (u1 :: Double#) -> _#_ gtDouble# [] [u0, u1] _N_} _F_ _IF_ARGS_ 0 2 CC 3 \ (u0 :: Double) (u1 :: Double) -> case u0 of { _ALG_ D# (u2 :: Double#) -> case u1 of { _ALG_ D# (u3 :: Double#) -> _#_ gtDouble# [] [u2, u3]; _NO_DEFLT_ }; _NO_DEFLT_ } _N_,
- max = _A_ 2 _U_ 11 _N_ _S_ "U(P)U(P)" {_A_ 2 _U_ 22 _N_ _N_ _N_ _N_} _N_ _N_,
- min = _A_ 2 _U_ 11 _N_ _S_ "U(P)U(P)" {_A_ 2 _U_ 22 _N_ _N_ _N_ _N_} _N_ _N_,
- _tagCmp = _A_ 2 _U_ 11 _N_ _S_ "U(P)U(P)" {_A_ 2 _U_ 22 _N_ _N_ _N_ _N_} _N_ _N_ #-}
+ (<) = { _A_ 2 _U_ 11 _N_ _S_ "U(P)U(P)" {_A_ 2 _U_ 22 _N_ _N_ _F_ _IF_ARGS_ 0 2 XX 1 \ (u0 :: Double#) (u1 :: Double#) -> _#_ ltDouble# [] [u0, u1] _N_} _F_ _IF_ARGS_ 0 2 CC 3 \ (u0 :: Double) (u1 :: Double) -> case u0 of { _ALG_ D# (u2 :: Double#) -> case u1 of { _ALG_ D# (u3 :: Double#) -> _#_ ltDouble# [] [u2, u3]; _NO_DEFLT_ }; _NO_DEFLT_ } _N_ },
+ (<=) = { _A_ 2 _U_ 11 _N_ _S_ "U(P)U(P)" {_A_ 2 _U_ 22 _N_ _N_ _F_ _IF_ARGS_ 0 2 XX 1 \ (u0 :: Double#) (u1 :: Double#) -> _#_ leDouble# [] [u0, u1] _N_} _F_ _IF_ARGS_ 0 2 CC 3 \ (u0 :: Double) (u1 :: Double) -> case u0 of { _ALG_ D# (u2 :: Double#) -> case u1 of { _ALG_ D# (u3 :: Double#) -> _#_ leDouble# [] [u2, u3]; _NO_DEFLT_ }; _NO_DEFLT_ } _N_ },
+ (>=) = { _A_ 2 _U_ 11 _N_ _S_ "U(P)U(P)" {_A_ 2 _U_ 22 _N_ _N_ _F_ _IF_ARGS_ 0 2 XX 1 \ (u0 :: Double#) (u1 :: Double#) -> _#_ geDouble# [] [u0, u1] _N_} _F_ _IF_ARGS_ 0 2 CC 3 \ (u0 :: Double) (u1 :: Double) -> case u0 of { _ALG_ D# (u2 :: Double#) -> case u1 of { _ALG_ D# (u3 :: Double#) -> _#_ geDouble# [] [u2, u3]; _NO_DEFLT_ }; _NO_DEFLT_ } _N_ },
+ (>) = { _A_ 2 _U_ 11 _N_ _S_ "U(P)U(P)" {_A_ 2 _U_ 22 _N_ _N_ _F_ _IF_ARGS_ 0 2 XX 1 \ (u0 :: Double#) (u1 :: Double#) -> _#_ gtDouble# [] [u0, u1] _N_} _F_ _IF_ARGS_ 0 2 CC 3 \ (u0 :: Double) (u1 :: Double) -> case u0 of { _ALG_ D# (u2 :: Double#) -> case u1 of { _ALG_ D# (u3 :: Double#) -> _#_ gtDouble# [] [u2, u3]; _NO_DEFLT_ }; _NO_DEFLT_ } _N_ },
+ max = { _A_ 2 _U_ 11 _N_ _S_ "U(P)U(P)" {_A_ 2 _U_ 22 _N_ _N_ _N_ _N_} _N_ _N_ },
+ min = { _A_ 2 _U_ 11 _N_ _S_ "U(P)U(P)" {_A_ 2 _U_ 22 _N_ _N_ _N_ _N_} _N_ _N_ },
+ _tagCmp = { _A_ 2 _U_ 11 _N_ _S_ "U(P)U(P)" {_A_ 2 _U_ 22 _N_ _N_ _N_ _N_} _N_ _N_ } #-}
instance Ord Float
{-# GHC_PRAGMA _M_ PreludeCore {-dfun-} _A_ 0 _N_ _N_ _N_ _F_ _IF_ARGS_ 0 0 X 9 _!_ _TUP_8 [{{Eq Float}}, (Float -> Float -> Bool), (Float -> Float -> Bool), (Float -> Float -> Bool), (Float -> Float -> Bool), (Float -> Float -> Float), (Float -> Float -> Float), (Float -> Float -> _CMP_TAG)] [_DFUN_ Eq (Float), _CONSTM_ Ord (<) (Float), _CONSTM_ Ord (<=) (Float), _CONSTM_ Ord (>=) (Float), _CONSTM_ Ord (>) (Float), _CONSTM_ Ord max (Float), _CONSTM_ Ord min (Float), _CONSTM_ Ord _tagCmp (Float)] _N_
- (<) = _A_ 2 _U_ 11 _N_ _S_ "U(P)U(P)" {_A_ 2 _U_ 22 _N_ _N_ _F_ _IF_ARGS_ 0 2 XX 1 \ (u0 :: Float#) (u1 :: Float#) -> _#_ ltFloat# [] [u0, u1] _N_} _F_ _IF_ARGS_ 0 2 CC 3 \ (u0 :: Float) (u1 :: Float) -> case u0 of { _ALG_ F# (u2 :: Float#) -> case u1 of { _ALG_ F# (u3 :: Float#) -> _#_ ltFloat# [] [u2, u3]; _NO_DEFLT_ }; _NO_DEFLT_ } _N_,
- (<=) = _A_ 2 _U_ 11 _N_ _S_ "U(P)U(P)" {_A_ 2 _U_ 22 _N_ _N_ _F_ _IF_ARGS_ 0 2 XX 1 \ (u0 :: Float#) (u1 :: Float#) -> _#_ leFloat# [] [u0, u1] _N_} _F_ _IF_ARGS_ 0 2 CC 3 \ (u0 :: Float) (u1 :: Float) -> case u0 of { _ALG_ F# (u2 :: Float#) -> case u1 of { _ALG_ F# (u3 :: Float#) -> _#_ leFloat# [] [u2, u3]; _NO_DEFLT_ }; _NO_DEFLT_ } _N_,
- (>=) = _A_ 2 _U_ 11 _N_ _S_ "U(P)U(P)" {_A_ 2 _U_ 22 _N_ _N_ _F_ _IF_ARGS_ 0 2 XX 1 \ (u0 :: Float#) (u1 :: Float#) -> _#_ geFloat# [] [u0, u1] _N_} _F_ _IF_ARGS_ 0 2 CC 3 \ (u0 :: Float) (u1 :: Float) -> case u0 of { _ALG_ F# (u2 :: Float#) -> case u1 of { _ALG_ F# (u3 :: Float#) -> _#_ geFloat# [] [u2, u3]; _NO_DEFLT_ }; _NO_DEFLT_ } _N_,
- (>) = _A_ 2 _U_ 11 _N_ _S_ "U(P)U(P)" {_A_ 2 _U_ 22 _N_ _N_ _F_ _IF_ARGS_ 0 2 XX 1 \ (u0 :: Float#) (u1 :: Float#) -> _#_ gtFloat# [] [u0, u1] _N_} _F_ _IF_ARGS_ 0 2 CC 3 \ (u0 :: Float) (u1 :: Float) -> case u0 of { _ALG_ F# (u2 :: Float#) -> case u1 of { _ALG_ F# (u3 :: Float#) -> _#_ gtFloat# [] [u2, u3]; _NO_DEFLT_ }; _NO_DEFLT_ } _N_,
- max = _A_ 2 _U_ 11 _N_ _S_ "U(P)U(P)" {_A_ 2 _U_ 22 _N_ _N_ _N_ _N_} _N_ _N_,
- min = _A_ 2 _U_ 11 _N_ _S_ "U(P)U(P)" {_A_ 2 _U_ 22 _N_ _N_ _N_ _N_} _N_ _N_,
- _tagCmp = _A_ 2 _U_ 11 _N_ _S_ "U(P)U(P)" {_A_ 2 _U_ 22 _N_ _N_ _N_ _N_} _N_ _N_ #-}
+ (<) = { _A_ 2 _U_ 11 _N_ _S_ "U(P)U(P)" {_A_ 2 _U_ 22 _N_ _N_ _F_ _IF_ARGS_ 0 2 XX 1 \ (u0 :: Float#) (u1 :: Float#) -> _#_ ltFloat# [] [u0, u1] _N_} _F_ _IF_ARGS_ 0 2 CC 3 \ (u0 :: Float) (u1 :: Float) -> case u0 of { _ALG_ F# (u2 :: Float#) -> case u1 of { _ALG_ F# (u3 :: Float#) -> _#_ ltFloat# [] [u2, u3]; _NO_DEFLT_ }; _NO_DEFLT_ } _N_ },
+ (<=) = { _A_ 2 _U_ 11 _N_ _S_ "U(P)U(P)" {_A_ 2 _U_ 22 _N_ _N_ _F_ _IF_ARGS_ 0 2 XX 1 \ (u0 :: Float#) (u1 :: Float#) -> _#_ leFloat# [] [u0, u1] _N_} _F_ _IF_ARGS_ 0 2 CC 3 \ (u0 :: Float) (u1 :: Float) -> case u0 of { _ALG_ F# (u2 :: Float#) -> case u1 of { _ALG_ F# (u3 :: Float#) -> _#_ leFloat# [] [u2, u3]; _NO_DEFLT_ }; _NO_DEFLT_ } _N_ },
+ (>=) = { _A_ 2 _U_ 11 _N_ _S_ "U(P)U(P)" {_A_ 2 _U_ 22 _N_ _N_ _F_ _IF_ARGS_ 0 2 XX 1 \ (u0 :: Float#) (u1 :: Float#) -> _#_ geFloat# [] [u0, u1] _N_} _F_ _IF_ARGS_ 0 2 CC 3 \ (u0 :: Float) (u1 :: Float) -> case u0 of { _ALG_ F# (u2 :: Float#) -> case u1 of { _ALG_ F# (u3 :: Float#) -> _#_ geFloat# [] [u2, u3]; _NO_DEFLT_ }; _NO_DEFLT_ } _N_ },
+ (>) = { _A_ 2 _U_ 11 _N_ _S_ "U(P)U(P)" {_A_ 2 _U_ 22 _N_ _N_ _F_ _IF_ARGS_ 0 2 XX 1 \ (u0 :: Float#) (u1 :: Float#) -> _#_ gtFloat# [] [u0, u1] _N_} _F_ _IF_ARGS_ 0 2 CC 3 \ (u0 :: Float) (u1 :: Float) -> case u0 of { _ALG_ F# (u2 :: Float#) -> case u1 of { _ALG_ F# (u3 :: Float#) -> _#_ gtFloat# [] [u2, u3]; _NO_DEFLT_ }; _NO_DEFLT_ } _N_ },
+ max = { _A_ 2 _U_ 11 _N_ _S_ "U(P)U(P)" {_A_ 2 _U_ 22 _N_ _N_ _N_ _N_} _N_ _N_ },
+ min = { _A_ 2 _U_ 11 _N_ _S_ "U(P)U(P)" {_A_ 2 _U_ 22 _N_ _N_ _N_ _N_} _N_ _N_ },
+ _tagCmp = { _A_ 2 _U_ 11 _N_ _S_ "U(P)U(P)" {_A_ 2 _U_ 22 _N_ _N_ _N_ _N_} _N_ _N_ } #-}
instance Ord Int
{-# GHC_PRAGMA _M_ PreludeCore {-dfun-} _A_ 0 _N_ _N_ _N_ _F_ _IF_ARGS_ 0 0 X 9 _!_ _TUP_8 [{{Eq Int}}, (Int -> Int -> Bool), (Int -> Int -> Bool), (Int -> Int -> Bool), (Int -> Int -> Bool), (Int -> Int -> Int), (Int -> Int -> Int), (Int -> Int -> _CMP_TAG)] [_DFUN_ Eq (Int), _CONSTM_ Ord (<) (Int), _CONSTM_ Ord (<=) (Int), _CONSTM_ Ord (>=) (Int), _CONSTM_ Ord (>) (Int), _CONSTM_ Ord max (Int), _CONSTM_ Ord min (Int), _CONSTM_ Ord _tagCmp (Int)] _N_
- (<) = _A_ 2 _U_ 11 _N_ _S_ "U(P)U(P)" {_A_ 2 _U_ 22 _N_ _N_ _F_ _IF_ARGS_ 0 2 XX 1 \ (u0 :: Int#) (u1 :: Int#) -> _#_ ltInt# [] [u0, u1] _N_} _F_ _IF_ARGS_ 0 2 CC 3 \ (u0 :: Int) (u1 :: Int) -> case u0 of { _ALG_ I# (u2 :: Int#) -> case u1 of { _ALG_ I# (u3 :: Int#) -> _#_ ltInt# [] [u2, u3]; _NO_DEFLT_ }; _NO_DEFLT_ } _N_,
- (<=) = _A_ 2 _U_ 11 _N_ _S_ "U(P)U(P)" {_A_ 2 _U_ 22 _N_ _N_ _F_ _IF_ARGS_ 0 2 XX 1 \ (u0 :: Int#) (u1 :: Int#) -> _#_ leInt# [] [u0, u1] _N_} _F_ _IF_ARGS_ 0 2 CC 3 \ (u0 :: Int) (u1 :: Int) -> case u0 of { _ALG_ I# (u2 :: Int#) -> case u1 of { _ALG_ I# (u3 :: Int#) -> _#_ leInt# [] [u2, u3]; _NO_DEFLT_ }; _NO_DEFLT_ } _N_,
- (>=) = _A_ 2 _U_ 11 _N_ _S_ "U(P)U(P)" {_A_ 2 _U_ 22 _N_ _N_ _F_ _IF_ARGS_ 0 2 XX 1 \ (u0 :: Int#) (u1 :: Int#) -> _#_ geInt# [] [u0, u1] _N_} _F_ _IF_ARGS_ 0 2 CC 3 \ (u0 :: Int) (u1 :: Int) -> case u0 of { _ALG_ I# (u2 :: Int#) -> case u1 of { _ALG_ I# (u3 :: Int#) -> _#_ geInt# [] [u2, u3]; _NO_DEFLT_ }; _NO_DEFLT_ } _N_,
- (>) = _A_ 2 _U_ 11 _N_ _S_ "U(P)U(P)" {_A_ 2 _U_ 22 _N_ _N_ _F_ _IF_ARGS_ 0 2 XX 1 \ (u0 :: Int#) (u1 :: Int#) -> _#_ gtInt# [] [u0, u1] _N_} _F_ _IF_ARGS_ 0 2 CC 3 \ (u0 :: Int) (u1 :: Int) -> case u0 of { _ALG_ I# (u2 :: Int#) -> case u1 of { _ALG_ I# (u3 :: Int#) -> _#_ gtInt# [] [u2, u3]; _NO_DEFLT_ }; _NO_DEFLT_ } _N_,
- max = _A_ 2 _U_ 11 _N_ _S_ "U(P)U(P)" {_A_ 2 _U_ 22 _N_ _N_ _N_ _N_} _N_ _N_,
- min = _A_ 2 _U_ 11 _N_ _S_ "U(P)U(P)" {_A_ 2 _U_ 22 _N_ _N_ _N_ _N_} _N_ _N_,
- _tagCmp = _A_ 2 _U_ 11 _N_ _S_ "U(P)U(P)" {_A_ 2 _U_ 22 _N_ _N_ _N_ _N_} _N_ _N_ #-}
+ (<) = { _A_ 2 _U_ 11 _N_ _S_ "U(P)U(P)" {_A_ 2 _U_ 22 _N_ _N_ _F_ _IF_ARGS_ 0 2 XX 1 \ (u0 :: Int#) (u1 :: Int#) -> _#_ ltInt# [] [u0, u1] _N_} _F_ _IF_ARGS_ 0 2 CC 3 \ (u0 :: Int) (u1 :: Int) -> case u0 of { _ALG_ I# (u2 :: Int#) -> case u1 of { _ALG_ I# (u3 :: Int#) -> _#_ ltInt# [] [u2, u3]; _NO_DEFLT_ }; _NO_DEFLT_ } _N_ },
+ (<=) = { _A_ 2 _U_ 11 _N_ _S_ "U(P)U(P)" {_A_ 2 _U_ 22 _N_ _N_ _F_ _IF_ARGS_ 0 2 XX 1 \ (u0 :: Int#) (u1 :: Int#) -> _#_ leInt# [] [u0, u1] _N_} _F_ _IF_ARGS_ 0 2 CC 3 \ (u0 :: Int) (u1 :: Int) -> case u0 of { _ALG_ I# (u2 :: Int#) -> case u1 of { _ALG_ I# (u3 :: Int#) -> _#_ leInt# [] [u2, u3]; _NO_DEFLT_ }; _NO_DEFLT_ } _N_ },
+ (>=) = { _A_ 2 _U_ 11 _N_ _S_ "U(P)U(P)" {_A_ 2 _U_ 22 _N_ _N_ _F_ _IF_ARGS_ 0 2 XX 1 \ (u0 :: Int#) (u1 :: Int#) -> _#_ geInt# [] [u0, u1] _N_} _F_ _IF_ARGS_ 0 2 CC 3 \ (u0 :: Int) (u1 :: Int) -> case u0 of { _ALG_ I# (u2 :: Int#) -> case u1 of { _ALG_ I# (u3 :: Int#) -> _#_ geInt# [] [u2, u3]; _NO_DEFLT_ }; _NO_DEFLT_ } _N_ },
+ (>) = { _A_ 2 _U_ 11 _N_ _S_ "U(P)U(P)" {_A_ 2 _U_ 22 _N_ _N_ _F_ _IF_ARGS_ 0 2 XX 1 \ (u0 :: Int#) (u1 :: Int#) -> _#_ gtInt# [] [u0, u1] _N_} _F_ _IF_ARGS_ 0 2 CC 3 \ (u0 :: Int) (u1 :: Int) -> case u0 of { _ALG_ I# (u2 :: Int#) -> case u1 of { _ALG_ I# (u3 :: Int#) -> _#_ gtInt# [] [u2, u3]; _NO_DEFLT_ }; _NO_DEFLT_ } _N_ },
+ max = { _A_ 2 _U_ 11 _N_ _S_ "U(P)U(P)" {_A_ 2 _U_ 22 _N_ _N_ _N_ _N_} _N_ _N_ },
+ min = { _A_ 2 _U_ 11 _N_ _S_ "U(P)U(P)" {_A_ 2 _U_ 22 _N_ _N_ _N_ _N_} _N_ _N_ },
+ _tagCmp = { _A_ 2 _U_ 11 _N_ _S_ "U(P)U(P)" {_A_ 2 _U_ 22 _N_ _N_ _N_ _N_} _N_ _N_ } #-}
instance Ord Integer
{-# GHC_PRAGMA _M_ PreludeCore {-dfun-} _A_ 0 _N_ _N_ _N_ _F_ _IF_ARGS_ 0 0 X 9 _!_ _TUP_8 [{{Eq Integer}}, (Integer -> Integer -> Bool), (Integer -> Integer -> Bool), (Integer -> Integer -> Bool), (Integer -> Integer -> Bool), (Integer -> Integer -> Integer), (Integer -> Integer -> Integer), (Integer -> Integer -> _CMP_TAG)] [_DFUN_ Eq (Integer), _CONSTM_ Ord (<) (Integer), _CONSTM_ Ord (<=) (Integer), _CONSTM_ Ord (>=) (Integer), _CONSTM_ Ord (>) (Integer), _CONSTM_ Ord max (Integer), _CONSTM_ Ord min (Integer), _CONSTM_ Ord _tagCmp (Integer)] _N_
- (<) = _A_ 2 _U_ 11 _N_ _S_ "U(PPP)U(PPP)" {_A_ 4 _U_ 2221 _N_ _N_ _F_ _IF_ARGS_ 0 4 XXXC 3 \ (u0 :: Int#) (u1 :: Int#) (u2 :: ByteArray#) (u3 :: Integer) -> case u3 of { _ALG_ J# (u4 :: Int#) (u5 :: Int#) (u6 :: ByteArray#) -> case _#_ cmpInteger# [] [u0, u1, u2, u4, u5, u6] of { _PRIM_ (u7 :: Int#) -> _#_ ltInt# [] [u7, 0#] }; _NO_DEFLT_ } _N_} _F_ _IF_ARGS_ 0 2 CC 4 \ (u0 :: Integer) (u1 :: Integer) -> case u0 of { _ALG_ J# (u2 :: Int#) (u3 :: Int#) (u4 :: ByteArray#) -> case u1 of { _ALG_ J# (u5 :: Int#) (u6 :: Int#) (u7 :: ByteArray#) -> case _#_ cmpInteger# [] [u2, u3, u4, u5, u6, u7] of { _PRIM_ (u8 :: Int#) -> _#_ ltInt# [] [u8, 0#] }; _NO_DEFLT_ }; _NO_DEFLT_ } _N_,
- (<=) = _A_ 2 _U_ 11 _N_ _S_ "U(PPP)U(PPP)" {_A_ 4 _U_ 2221 _N_ _N_ _F_ _IF_ARGS_ 0 4 XXXC 3 \ (u0 :: Int#) (u1 :: Int#) (u2 :: ByteArray#) (u3 :: Integer) -> case u3 of { _ALG_ J# (u4 :: Int#) (u5 :: Int#) (u6 :: ByteArray#) -> case _#_ cmpInteger# [] [u0, u1, u2, u4, u5, u6] of { _PRIM_ (u7 :: Int#) -> _#_ leInt# [] [u7, 0#] }; _NO_DEFLT_ } _N_} _F_ _IF_ARGS_ 0 2 CC 4 \ (u0 :: Integer) (u1 :: Integer) -> case u0 of { _ALG_ J# (u2 :: Int#) (u3 :: Int#) (u4 :: ByteArray#) -> case u1 of { _ALG_ J# (u5 :: Int#) (u6 :: Int#) (u7 :: ByteArray#) -> case _#_ cmpInteger# [] [u2, u3, u4, u5, u6, u7] of { _PRIM_ (u8 :: Int#) -> _#_ leInt# [] [u8, 0#] }; _NO_DEFLT_ }; _NO_DEFLT_ } _N_,
- (>=) = _A_ 2 _U_ 11 _N_ _S_ "U(PPP)U(PPP)" {_A_ 4 _U_ 2221 _N_ _N_ _F_ _IF_ARGS_ 0 4 XXXC 3 \ (u0 :: Int#) (u1 :: Int#) (u2 :: ByteArray#) (u3 :: Integer) -> case u3 of { _ALG_ J# (u4 :: Int#) (u5 :: Int#) (u6 :: ByteArray#) -> case _#_ cmpInteger# [] [u0, u1, u2, u4, u5, u6] of { _PRIM_ (u7 :: Int#) -> _#_ geInt# [] [u7, 0#] }; _NO_DEFLT_ } _N_} _F_ _IF_ARGS_ 0 2 CC 4 \ (u0 :: Integer) (u1 :: Integer) -> case u0 of { _ALG_ J# (u2 :: Int#) (u3 :: Int#) (u4 :: ByteArray#) -> case u1 of { _ALG_ J# (u5 :: Int#) (u6 :: Int#) (u7 :: ByteArray#) -> case _#_ cmpInteger# [] [u2, u3, u4, u5, u6, u7] of { _PRIM_ (u8 :: Int#) -> _#_ geInt# [] [u8, 0#] }; _NO_DEFLT_ }; _NO_DEFLT_ } _N_,
- (>) = _A_ 2 _U_ 11 _N_ _S_ "U(PPP)U(PPP)" {_A_ 4 _U_ 2221 _N_ _N_ _F_ _IF_ARGS_ 0 4 XXXC 3 \ (u0 :: Int#) (u1 :: Int#) (u2 :: ByteArray#) (u3 :: Integer) -> case u3 of { _ALG_ J# (u4 :: Int#) (u5 :: Int#) (u6 :: ByteArray#) -> case _#_ cmpInteger# [] [u0, u1, u2, u4, u5, u6] of { _PRIM_ (u7 :: Int#) -> _#_ gtInt# [] [u7, 0#] }; _NO_DEFLT_ } _N_} _F_ _IF_ARGS_ 0 2 CC 4 \ (u0 :: Integer) (u1 :: Integer) -> case u0 of { _ALG_ J# (u2 :: Int#) (u3 :: Int#) (u4 :: ByteArray#) -> case u1 of { _ALG_ J# (u5 :: Int#) (u6 :: Int#) (u7 :: ByteArray#) -> case _#_ cmpInteger# [] [u2, u3, u4, u5, u6, u7] of { _PRIM_ (u8 :: Int#) -> _#_ gtInt# [] [u8, 0#] }; _NO_DEFLT_ }; _NO_DEFLT_ } _N_,
- max = _A_ 2 _U_ 11 _N_ _S_ "U(PPP)U(PPP)" {_A_ 4 _U_ 2221 _N_ _N_ _N_ _N_} _N_ _N_,
- min = _A_ 2 _U_ 11 _N_ _S_ "U(PPP)U(PPP)" {_A_ 4 _U_ 2221 _N_ _N_ _N_ _N_} _N_ _N_,
- _tagCmp = _A_ 2 _U_ 11 _N_ _S_ "U(PPP)U(PPP)" {_A_ 4 _U_ 2221 _N_ _N_ _N_ _N_} _N_ _N_ #-}
+ (<) = { _A_ 2 _U_ 11 _N_ _S_ "U(PPP)U(PPP)" {_A_ 4 _U_ 2221 _N_ _N_ _F_ _IF_ARGS_ 0 4 XXXC 3 \ (u0 :: Int#) (u1 :: Int#) (u2 :: ByteArray#) (u3 :: Integer) -> case u3 of { _ALG_ J# (u4 :: Int#) (u5 :: Int#) (u6 :: ByteArray#) -> case _#_ cmpInteger# [] [u0, u1, u2, u4, u5, u6] of { _PRIM_ (u7 :: Int#) -> _#_ ltInt# [] [u7, 0#] }; _NO_DEFLT_ } _N_} _F_ _IF_ARGS_ 0 2 CC 4 \ (u0 :: Integer) (u1 :: Integer) -> case u0 of { _ALG_ J# (u2 :: Int#) (u3 :: Int#) (u4 :: ByteArray#) -> case u1 of { _ALG_ J# (u5 :: Int#) (u6 :: Int#) (u7 :: ByteArray#) -> case _#_ cmpInteger# [] [u2, u3, u4, u5, u6, u7] of { _PRIM_ (u8 :: Int#) -> _#_ ltInt# [] [u8, 0#] }; _NO_DEFLT_ }; _NO_DEFLT_ } _N_ },
+ (<=) = { _A_ 2 _U_ 11 _N_ _S_ "U(PPP)U(PPP)" {_A_ 4 _U_ 2221 _N_ _N_ _F_ _IF_ARGS_ 0 4 XXXC 3 \ (u0 :: Int#) (u1 :: Int#) (u2 :: ByteArray#) (u3 :: Integer) -> case u3 of { _ALG_ J# (u4 :: Int#) (u5 :: Int#) (u6 :: ByteArray#) -> case _#_ cmpInteger# [] [u0, u1, u2, u4, u5, u6] of { _PRIM_ (u7 :: Int#) -> _#_ leInt# [] [u7, 0#] }; _NO_DEFLT_ } _N_} _F_ _IF_ARGS_ 0 2 CC 4 \ (u0 :: Integer) (u1 :: Integer) -> case u0 of { _ALG_ J# (u2 :: Int#) (u3 :: Int#) (u4 :: ByteArray#) -> case u1 of { _ALG_ J# (u5 :: Int#) (u6 :: Int#) (u7 :: ByteArray#) -> case _#_ cmpInteger# [] [u2, u3, u4, u5, u6, u7] of { _PRIM_ (u8 :: Int#) -> _#_ leInt# [] [u8, 0#] }; _NO_DEFLT_ }; _NO_DEFLT_ } _N_ },
+ (>=) = { _A_ 2 _U_ 11 _N_ _S_ "U(PPP)U(PPP)" {_A_ 4 _U_ 2221 _N_ _N_ _F_ _IF_ARGS_ 0 4 XXXC 3 \ (u0 :: Int#) (u1 :: Int#) (u2 :: ByteArray#) (u3 :: Integer) -> case u3 of { _ALG_ J# (u4 :: Int#) (u5 :: Int#) (u6 :: ByteArray#) -> case _#_ cmpInteger# [] [u0, u1, u2, u4, u5, u6] of { _PRIM_ (u7 :: Int#) -> _#_ geInt# [] [u7, 0#] }; _NO_DEFLT_ } _N_} _F_ _IF_ARGS_ 0 2 CC 4 \ (u0 :: Integer) (u1 :: Integer) -> case u0 of { _ALG_ J# (u2 :: Int#) (u3 :: Int#) (u4 :: ByteArray#) -> case u1 of { _ALG_ J# (u5 :: Int#) (u6 :: Int#) (u7 :: ByteArray#) -> case _#_ cmpInteger# [] [u2, u3, u4, u5, u6, u7] of { _PRIM_ (u8 :: Int#) -> _#_ geInt# [] [u8, 0#] }; _NO_DEFLT_ }; _NO_DEFLT_ } _N_ },
+ (>) = { _A_ 2 _U_ 11 _N_ _S_ "U(PPP)U(PPP)" {_A_ 4 _U_ 2221 _N_ _N_ _F_ _IF_ARGS_ 0 4 XXXC 3 \ (u0 :: Int#) (u1 :: Int#) (u2 :: ByteArray#) (u3 :: Integer) -> case u3 of { _ALG_ J# (u4 :: Int#) (u5 :: Int#) (u6 :: ByteArray#) -> case _#_ cmpInteger# [] [u0, u1, u2, u4, u5, u6] of { _PRIM_ (u7 :: Int#) -> _#_ gtInt# [] [u7, 0#] }; _NO_DEFLT_ } _N_} _F_ _IF_ARGS_ 0 2 CC 4 \ (u0 :: Integer) (u1 :: Integer) -> case u0 of { _ALG_ J# (u2 :: Int#) (u3 :: Int#) (u4 :: ByteArray#) -> case u1 of { _ALG_ J# (u5 :: Int#) (u6 :: Int#) (u7 :: ByteArray#) -> case _#_ cmpInteger# [] [u2, u3, u4, u5, u6, u7] of { _PRIM_ (u8 :: Int#) -> _#_ gtInt# [] [u8, 0#] }; _NO_DEFLT_ }; _NO_DEFLT_ } _N_ },
+ max = { _A_ 2 _U_ 11 _N_ _S_ "U(PPP)U(PPP)" {_A_ 4 _U_ 2221 _N_ _N_ _N_ _N_} _N_ _N_ },
+ min = { _A_ 2 _U_ 11 _N_ _S_ "U(PPP)U(PPP)" {_A_ 4 _U_ 2221 _N_ _N_ _N_ _N_} _N_ _N_ },
+ _tagCmp = { _A_ 2 _U_ 11 _N_ _S_ "U(PPP)U(PPP)" {_A_ 4 _U_ 2221 _N_ _N_ _N_ _N_} _N_ _N_ } #-}
instance Integral a => Ord (Ratio a)
{-# GHC_PRAGMA _M_ PreludeRatio {-dfun-} _A_ 2 _U_ 22 _N_ _N_ _N_ _N_ #-}
instance Ord (Ratio Integer)
{-# GHC_PRAGMA _M_ PreludeRatio {-dfun-} _A_ 0 _N_ _N_ _N_ _F_ _IF_ARGS_ 0 0 X 9 _!_ _TUP_8 [{{Eq (Ratio Integer)}}, (Ratio Integer -> Ratio Integer -> Bool), (Ratio Integer -> Ratio Integer -> Bool), (Ratio Integer -> Ratio Integer -> Bool), (Ratio Integer -> Ratio Integer -> Bool), (Ratio Integer -> Ratio Integer -> Ratio Integer), (Ratio Integer -> Ratio Integer -> Ratio Integer), (Ratio Integer -> Ratio Integer -> _CMP_TAG)] [_DFUN_ Eq (Ratio Integer), _CONSTM_ Ord (<) (Ratio Integer), _CONSTM_ Ord (<=) (Ratio Integer), _CONSTM_ Ord (>=) (Ratio Integer), _CONSTM_ Ord (>) (Ratio Integer), _CONSTM_ Ord max (Ratio Integer), _CONSTM_ Ord min (Ratio Integer), _CONSTM_ Ord _tagCmp (Ratio Integer)] _N_
- (<) = _A_ 2 _U_ 11 _N_ _S_ "U(U(PPP)U(PPP))U(U(PPP)U(PPP))" {_A_ 5 _U_ 22221 _N_ _N_ _N_ _N_} _N_ _N_,
- (<=) = _A_ 2 _U_ 11 _N_ _S_ "U(U(PPP)U(PPP))U(U(PPP)U(PPP))" {_A_ 5 _U_ 22221 _N_ _N_ _N_ _N_} _N_ _N_,
- (>=) = _A_ 2 _U_ 11 _N_ _S_ "U(U(PPP)U(PPP))U(U(PPP)U(PPP))" {_A_ 5 _U_ 22221 _N_ _N_ _N_ _N_} _N_ _N_,
- (>) = _A_ 2 _U_ 11 _N_ _S_ "U(U(PPP)U(PPP))U(U(PPP)U(PPP))" {_A_ 5 _U_ 22221 _N_ _N_ _N_ _N_} _N_ _N_,
- max = _A_ 2 _U_ 12 _N_ _S_ "U(U(PPP)U(PPP))U(U(PPP)U(PPP))" {_A_ 5 _U_ 22222 _N_ _N_ _N_ _N_} _N_ _N_,
- min = _A_ 2 _U_ 12 _N_ _S_ "U(U(PPP)U(PPP))U(U(PPP)U(PPP))" {_A_ 5 _U_ 22222 _N_ _N_ _N_ _N_} _N_ _N_,
- _tagCmp = _A_ 2 _U_ 11 _N_ _S_ "U(U(PPP)U(PPP))U(U(PPP)U(PPP))" {_A_ 5 _U_ 22221 _N_ _N_ _N_ _N_} _N_ _N_ #-}
+ (<) = { _A_ 2 _U_ 11 _N_ _S_ "U(U(PPP)U(PPP))U(U(PPP)U(PPP))" {_A_ 5 _U_ 22221 _N_ _N_ _N_ _N_} _N_ _N_ },
+ (<=) = { _A_ 2 _U_ 11 _N_ _S_ "U(U(PPP)U(PPP))U(U(PPP)U(PPP))" {_A_ 5 _U_ 22221 _N_ _N_ _N_ _N_} _N_ _N_ },
+ (>=) = { _A_ 2 _U_ 11 _N_ _S_ "U(U(PPP)U(PPP))U(U(PPP)U(PPP))" {_A_ 5 _U_ 22221 _N_ _N_ _N_ _N_} _N_ _N_ },
+ (>) = { _A_ 2 _U_ 11 _N_ _S_ "U(U(PPP)U(PPP))U(U(PPP)U(PPP))" {_A_ 5 _U_ 22221 _N_ _N_ _N_ _N_} _N_ _N_ },
+ max = { _A_ 2 _U_ 12 _N_ _S_ "U(U(PPP)U(PPP))U(U(PPP)U(PPP))" {_A_ 5 _U_ 22222 _N_ _N_ _N_ _N_} _N_ _N_ },
+ min = { _A_ 2 _U_ 12 _N_ _S_ "U(U(PPP)U(PPP))U(U(PPP)U(PPP))" {_A_ 5 _U_ 22222 _N_ _N_ _N_ _N_} _N_ _N_ },
+ _tagCmp = { _A_ 2 _U_ 11 _N_ _S_ "U(U(PPP)U(PPP))U(U(PPP)U(PPP))" {_A_ 5 _U_ 22221 _N_ _N_ _N_ _N_} _N_ _N_ } #-}
instance Ord a => Ord [a]
{-# GHC_PRAGMA _M_ PreludeBuiltin {-dfun-} _A_ 2 _U_ 12 _N_ _N_ _N_ _N_ #-}
+instance Ord [Bool]
+ {-# GHC_PRAGMA _M_ PreludeBuiltin {-dfun-} _A_ 0 _N_ _N_ _N_ _F_ _IF_ARGS_ 0 0 X 9 _!_ _TUP_8 [{{Eq [Bool]}}, ([Bool] -> [Bool] -> Bool), ([Bool] -> [Bool] -> Bool), ([Bool] -> [Bool] -> Bool), ([Bool] -> [Bool] -> Bool), ([Bool] -> [Bool] -> [Bool]), ([Bool] -> [Bool] -> [Bool]), ([Bool] -> [Bool] -> _CMP_TAG)] [_DFUN_ Eq ([Bool]), _CONSTM_ Ord (<) ([Bool]), _CONSTM_ Ord (<=) ([Bool]), _CONSTM_ Ord (>=) ([Bool]), _CONSTM_ Ord (>) ([Bool]), _CONSTM_ Ord max ([Bool]), _CONSTM_ Ord min ([Bool]), _CONSTM_ Ord _tagCmp ([Bool])] _N_
+ (<) = { _A_ 2 _U_ 11 _N_ _S_ "SS" _N_ _N_ },
+ (<=) = { _A_ 2 _U_ 11 _N_ _S_ "SS" _N_ _N_ },
+ (>=) = { _A_ 2 _U_ 11 _N_ _S_ "SS" _N_ _N_ },
+ (>) = { _A_ 2 _U_ 11 _N_ _S_ "SS" _N_ _N_ },
+ max = { _A_ 2 _U_ 22 _N_ _S_ "SS" _N_ _N_ },
+ min = { _A_ 2 _U_ 22 _N_ _S_ "SS" _N_ _N_ },
+ _tagCmp = { _A_ 2 _U_ 11 _N_ _S_ "SS" _N_ _N_ } #-}
instance Ord [Char]
{-# GHC_PRAGMA _M_ PreludeBuiltin {-dfun-} _A_ 0 _N_ _N_ _N_ _F_ _IF_ARGS_ 0 0 X 9 _!_ _TUP_8 [{{Eq [Char]}}, ([Char] -> [Char] -> Bool), ([Char] -> [Char] -> Bool), ([Char] -> [Char] -> Bool), ([Char] -> [Char] -> Bool), ([Char] -> [Char] -> [Char]), ([Char] -> [Char] -> [Char]), ([Char] -> [Char] -> _CMP_TAG)] [_DFUN_ Eq ([Char]), _CONSTM_ Ord (<) ([Char]), _CONSTM_ Ord (<=) ([Char]), _CONSTM_ Ord (>=) ([Char]), _CONSTM_ Ord (>) ([Char]), _CONSTM_ Ord max ([Char]), _CONSTM_ Ord min ([Char]), _CONSTM_ Ord _tagCmp ([Char])] _N_
- (<) = _A_ 2 _U_ 11 _N_ _S_ "SS" _N_ _N_,
- (<=) = _A_ 2 _U_ 11 _N_ _S_ "SS" _N_ _N_,
- (>=) = _A_ 2 _U_ 11 _N_ _S_ "SS" _N_ _N_,
- (>) = _A_ 2 _U_ 11 _N_ _S_ "SS" _N_ _N_,
- max = _A_ 2 _U_ 22 _N_ _S_ "SS" _N_ _N_,
- min = _A_ 2 _U_ 22 _N_ _S_ "SS" _N_ _N_,
- _tagCmp = _A_ 2 _U_ 11 _N_ _S_ "SS" _N_ _N_ #-}
+ (<) = { _A_ 2 _U_ 11 _N_ _S_ "SS" _N_ _N_ },
+ (<=) = { _A_ 2 _U_ 11 _N_ _S_ "SS" _N_ _N_ },
+ (>=) = { _A_ 2 _U_ 11 _N_ _S_ "SS" _N_ _N_ },
+ (>) = { _A_ 2 _U_ 11 _N_ _S_ "SS" _N_ _N_ },
+ max = { _A_ 2 _U_ 22 _N_ _S_ "SS" _N_ _N_ },
+ min = { _A_ 2 _U_ 22 _N_ _S_ "SS" _N_ _N_ },
+ _tagCmp = { _A_ 2 _U_ 11 _N_ _S_ "SS" _N_ _N_ } #-}
+instance Ord [Double]
+ {-# GHC_PRAGMA _M_ PreludeBuiltin {-dfun-} _A_ 0 _N_ _N_ _N_ _F_ _IF_ARGS_ 0 0 X 9 _!_ _TUP_8 [{{Eq [Double]}}, ([Double] -> [Double] -> Bool), ([Double] -> [Double] -> Bool), ([Double] -> [Double] -> Bool), ([Double] -> [Double] -> Bool), ([Double] -> [Double] -> [Double]), ([Double] -> [Double] -> [Double]), ([Double] -> [Double] -> _CMP_TAG)] [_DFUN_ Eq ([Double]), _CONSTM_ Ord (<) ([Double]), _CONSTM_ Ord (<=) ([Double]), _CONSTM_ Ord (>=) ([Double]), _CONSTM_ Ord (>) ([Double]), _CONSTM_ Ord max ([Double]), _CONSTM_ Ord min ([Double]), _CONSTM_ Ord _tagCmp ([Double])] _N_
+ (<) = { _A_ 2 _U_ 11 _N_ _S_ "SS" _N_ _N_ },
+ (<=) = { _A_ 2 _U_ 11 _N_ _S_ "SS" _N_ _N_ },
+ (>=) = { _A_ 2 _U_ 11 _N_ _S_ "SS" _N_ _N_ },
+ (>) = { _A_ 2 _U_ 11 _N_ _S_ "SS" _N_ _N_ },
+ max = { _A_ 2 _U_ 22 _N_ _S_ "SS" _N_ _N_ },
+ min = { _A_ 2 _U_ 22 _N_ _S_ "SS" _N_ _N_ },
+ _tagCmp = { _A_ 2 _U_ 11 _N_ _S_ "SS" _N_ _N_ } #-}
instance Ord [Int]
{-# GHC_PRAGMA _M_ PreludeBuiltin {-dfun-} _A_ 0 _N_ _N_ _N_ _F_ _IF_ARGS_ 0 0 X 9 _!_ _TUP_8 [{{Eq [Int]}}, ([Int] -> [Int] -> Bool), ([Int] -> [Int] -> Bool), ([Int] -> [Int] -> Bool), ([Int] -> [Int] -> Bool), ([Int] -> [Int] -> [Int]), ([Int] -> [Int] -> [Int]), ([Int] -> [Int] -> _CMP_TAG)] [_DFUN_ Eq ([Int]), _CONSTM_ Ord (<) ([Int]), _CONSTM_ Ord (<=) ([Int]), _CONSTM_ Ord (>=) ([Int]), _CONSTM_ Ord (>) ([Int]), _CONSTM_ Ord max ([Int]), _CONSTM_ Ord min ([Int]), _CONSTM_ Ord _tagCmp ([Int])] _N_
- (<) = _A_ 2 _U_ 11 _N_ _S_ "SS" _N_ _N_,
- (<=) = _A_ 2 _U_ 11 _N_ _S_ "SS" _N_ _N_,
- (>=) = _A_ 2 _U_ 11 _N_ _S_ "SS" _N_ _N_,
- (>) = _A_ 2 _U_ 11 _N_ _S_ "SS" _N_ _N_,
- max = _A_ 2 _U_ 22 _N_ _S_ "SS" _N_ _N_,
- min = _A_ 2 _U_ 22 _N_ _S_ "SS" _N_ _N_,
- _tagCmp = _A_ 2 _U_ 11 _N_ _S_ "SS" _N_ _N_ #-}
+ (<) = { _A_ 2 _U_ 11 _N_ _S_ "SS" _N_ _N_ },
+ (<=) = { _A_ 2 _U_ 11 _N_ _S_ "SS" _N_ _N_ },
+ (>=) = { _A_ 2 _U_ 11 _N_ _S_ "SS" _N_ _N_ },
+ (>) = { _A_ 2 _U_ 11 _N_ _S_ "SS" _N_ _N_ },
+ max = { _A_ 2 _U_ 22 _N_ _S_ "SS" _N_ _N_ },
+ min = { _A_ 2 _U_ 22 _N_ _S_ "SS" _N_ _N_ },
+ _tagCmp = { _A_ 2 _U_ 11 _N_ _S_ "SS" _N_ _N_ } #-}
+instance Ord [Integer]
+ {-# GHC_PRAGMA _M_ PreludeBuiltin {-dfun-} _A_ 0 _N_ _N_ _N_ _F_ _IF_ARGS_ 0 0 X 9 _!_ _TUP_8 [{{Eq [Integer]}}, ([Integer] -> [Integer] -> Bool), ([Integer] -> [Integer] -> Bool), ([Integer] -> [Integer] -> Bool), ([Integer] -> [Integer] -> Bool), ([Integer] -> [Integer] -> [Integer]), ([Integer] -> [Integer] -> [Integer]), ([Integer] -> [Integer] -> _CMP_TAG)] [_DFUN_ Eq ([Integer]), _CONSTM_ Ord (<) ([Integer]), _CONSTM_ Ord (<=) ([Integer]), _CONSTM_ Ord (>=) ([Integer]), _CONSTM_ Ord (>) ([Integer]), _CONSTM_ Ord max ([Integer]), _CONSTM_ Ord min ([Integer]), _CONSTM_ Ord _tagCmp ([Integer])] _N_
+ (<) = { _A_ 2 _U_ 11 _N_ _S_ "SS" _N_ _N_ },
+ (<=) = { _A_ 2 _U_ 11 _N_ _S_ "SS" _N_ _N_ },
+ (>=) = { _A_ 2 _U_ 11 _N_ _S_ "SS" _N_ _N_ },
+ (>) = { _A_ 2 _U_ 11 _N_ _S_ "SS" _N_ _N_ },
+ max = { _A_ 2 _U_ 22 _N_ _S_ "SS" _N_ _N_ },
+ min = { _A_ 2 _U_ 22 _N_ _S_ "SS" _N_ _N_ },
+ _tagCmp = { _A_ 2 _U_ 11 _N_ _S_ "SS" _N_ _N_ } #-}
+instance Ord [[Char]]
+ {-# GHC_PRAGMA _M_ PreludeBuiltin {-dfun-} _A_ 0 _N_ _N_ _N_ _F_ _IF_ARGS_ 0 0 X 9 _!_ _TUP_8 [{{Eq [[Char]]}}, ([[Char]] -> [[Char]] -> Bool), ([[Char]] -> [[Char]] -> Bool), ([[Char]] -> [[Char]] -> Bool), ([[Char]] -> [[Char]] -> Bool), ([[Char]] -> [[Char]] -> [[Char]]), ([[Char]] -> [[Char]] -> [[Char]]), ([[Char]] -> [[Char]] -> _CMP_TAG)] [_DFUN_ Eq ([[Char]]), _CONSTM_ Ord (<) ([[Char]]), _CONSTM_ Ord (<=) ([[Char]]), _CONSTM_ Ord (>=) ([[Char]]), _CONSTM_ Ord (>) ([[Char]]), _CONSTM_ Ord max ([[Char]]), _CONSTM_ Ord min ([[Char]]), _CONSTM_ Ord _tagCmp ([[Char]])] _N_
+ (<) = { _A_ 2 _U_ 11 _N_ _S_ "SS" _N_ _N_ },
+ (<=) = { _A_ 2 _U_ 11 _N_ _S_ "SS" _N_ _N_ },
+ (>=) = { _A_ 2 _U_ 11 _N_ _S_ "SS" _N_ _N_ },
+ (>) = { _A_ 2 _U_ 11 _N_ _S_ "SS" _N_ _N_ },
+ max = { _A_ 2 _U_ 22 _N_ _S_ "SS" _N_ _N_ },
+ min = { _A_ 2 _U_ 22 _N_ _S_ "SS" _N_ _N_ },
+ _tagCmp = { _A_ 2 _U_ 11 _N_ _S_ "SS" _N_ _N_ } #-}
+instance Ord [[Int]]
+ {-# GHC_PRAGMA _M_ PreludeBuiltin {-dfun-} _A_ 0 _N_ _N_ _N_ _F_ _IF_ARGS_ 0 0 X 9 _!_ _TUP_8 [{{Eq [[Int]]}}, ([[Int]] -> [[Int]] -> Bool), ([[Int]] -> [[Int]] -> Bool), ([[Int]] -> [[Int]] -> Bool), ([[Int]] -> [[Int]] -> Bool), ([[Int]] -> [[Int]] -> [[Int]]), ([[Int]] -> [[Int]] -> [[Int]]), ([[Int]] -> [[Int]] -> _CMP_TAG)] [_DFUN_ Eq ([[Int]]), _CONSTM_ Ord (<) ([[Int]]), _CONSTM_ Ord (<=) ([[Int]]), _CONSTM_ Ord (>=) ([[Int]]), _CONSTM_ Ord (>) ([[Int]]), _CONSTM_ Ord max ([[Int]]), _CONSTM_ Ord min ([[Int]]), _CONSTM_ Ord _tagCmp ([[Int]])] _N_
+ (<) = { _A_ 2 _U_ 11 _N_ _S_ "SS" _N_ _N_ },
+ (<=) = { _A_ 2 _U_ 11 _N_ _S_ "SS" _N_ _N_ },
+ (>=) = { _A_ 2 _U_ 11 _N_ _S_ "SS" _N_ _N_ },
+ (>) = { _A_ 2 _U_ 11 _N_ _S_ "SS" _N_ _N_ },
+ max = { _A_ 2 _U_ 22 _N_ _S_ "SS" _N_ _N_ },
+ min = { _A_ 2 _U_ 22 _N_ _S_ "SS" _N_ _N_ },
+ _tagCmp = { _A_ 2 _U_ 11 _N_ _S_ "SS" _N_ _N_ } #-}
instance Ord _Addr
{-# GHC_PRAGMA _M_ PreludeCore {-dfun-} _A_ 0 _N_ _N_ _N_ _F_ _IF_ARGS_ 0 0 X 9 _!_ _TUP_8 [{{Eq _Addr}}, (_Addr -> _Addr -> Bool), (_Addr -> _Addr -> Bool), (_Addr -> _Addr -> Bool), (_Addr -> _Addr -> Bool), (_Addr -> _Addr -> _Addr), (_Addr -> _Addr -> _Addr), (_Addr -> _Addr -> _CMP_TAG)] [_DFUN_ Eq (_Addr), _CONSTM_ Ord (<) (_Addr), _CONSTM_ Ord (<=) (_Addr), _CONSTM_ Ord (>=) (_Addr), _CONSTM_ Ord (>) (_Addr), _CONSTM_ Ord max (_Addr), _CONSTM_ Ord min (_Addr), _CONSTM_ Ord _tagCmp (_Addr)] _N_
- (<) = _A_ 2 _U_ 11 _N_ _S_ "U(P)U(P)" {_A_ 2 _U_ 22 _N_ _N_ _F_ _IF_ARGS_ 0 2 XX 1 \ (u0 :: Addr#) (u1 :: Addr#) -> _#_ ltAddr# [] [u0, u1] _N_} _F_ _IF_ARGS_ 0 2 CC 3 \ (u0 :: _Addr) (u1 :: _Addr) -> case u0 of { _ALG_ A# (u2 :: Addr#) -> case u1 of { _ALG_ A# (u3 :: Addr#) -> _#_ ltAddr# [] [u2, u3]; _NO_DEFLT_ }; _NO_DEFLT_ } _N_,
- (<=) = _A_ 2 _U_ 11 _N_ _S_ "U(P)U(P)" {_A_ 2 _U_ 22 _N_ _N_ _F_ _IF_ARGS_ 0 2 XX 1 \ (u0 :: Addr#) (u1 :: Addr#) -> _#_ leAddr# [] [u0, u1] _N_} _F_ _IF_ARGS_ 0 2 CC 3 \ (u0 :: _Addr) (u1 :: _Addr) -> case u0 of { _ALG_ A# (u2 :: Addr#) -> case u1 of { _ALG_ A# (u3 :: Addr#) -> _#_ leAddr# [] [u2, u3]; _NO_DEFLT_ }; _NO_DEFLT_ } _N_,
- (>=) = _A_ 2 _U_ 11 _N_ _S_ "U(P)U(P)" {_A_ 2 _U_ 22 _N_ _N_ _F_ _IF_ARGS_ 0 2 XX 1 \ (u0 :: Addr#) (u1 :: Addr#) -> _#_ geAddr# [] [u0, u1] _N_} _F_ _IF_ARGS_ 0 2 CC 3 \ (u0 :: _Addr) (u1 :: _Addr) -> case u0 of { _ALG_ A# (u2 :: Addr#) -> case u1 of { _ALG_ A# (u3 :: Addr#) -> _#_ geAddr# [] [u2, u3]; _NO_DEFLT_ }; _NO_DEFLT_ } _N_,
- (>) = _A_ 2 _U_ 11 _N_ _S_ "U(P)U(P)" {_A_ 2 _U_ 22 _N_ _N_ _F_ _IF_ARGS_ 0 2 XX 1 \ (u0 :: Addr#) (u1 :: Addr#) -> _#_ gtAddr# [] [u0, u1] _N_} _F_ _IF_ARGS_ 0 2 CC 3 \ (u0 :: _Addr) (u1 :: _Addr) -> case u0 of { _ALG_ A# (u2 :: Addr#) -> case u1 of { _ALG_ A# (u3 :: Addr#) -> _#_ gtAddr# [] [u2, u3]; _NO_DEFLT_ }; _NO_DEFLT_ } _N_,
- max = _A_ 2 _U_ 11 _N_ _S_ "U(P)U(P)" {_A_ 2 _U_ 22 _N_ _N_ _N_ _N_} _N_ _N_,
- min = _A_ 2 _U_ 11 _N_ _S_ "U(P)U(P)" {_A_ 2 _U_ 22 _N_ _N_ _N_ _N_} _N_ _N_,
- _tagCmp = _A_ 2 _U_ 11 _N_ _S_ "U(P)U(P)" {_A_ 2 _U_ 22 _N_ _N_ _N_ _N_} _N_ _N_ #-}
+ (<) = { _A_ 2 _U_ 11 _N_ _S_ "U(P)U(P)" {_A_ 2 _U_ 22 _N_ _N_ _F_ _IF_ARGS_ 0 2 XX 1 \ (u0 :: Addr#) (u1 :: Addr#) -> _#_ ltAddr# [] [u0, u1] _N_} _F_ _IF_ARGS_ 0 2 CC 3 \ (u0 :: _Addr) (u1 :: _Addr) -> case u0 of { _ALG_ A# (u2 :: Addr#) -> case u1 of { _ALG_ A# (u3 :: Addr#) -> _#_ ltAddr# [] [u2, u3]; _NO_DEFLT_ }; _NO_DEFLT_ } _N_ },
+ (<=) = { _A_ 2 _U_ 11 _N_ _S_ "U(P)U(P)" {_A_ 2 _U_ 22 _N_ _N_ _F_ _IF_ARGS_ 0 2 XX 1 \ (u0 :: Addr#) (u1 :: Addr#) -> _#_ leAddr# [] [u0, u1] _N_} _F_ _IF_ARGS_ 0 2 CC 3 \ (u0 :: _Addr) (u1 :: _Addr) -> case u0 of { _ALG_ A# (u2 :: Addr#) -> case u1 of { _ALG_ A# (u3 :: Addr#) -> _#_ leAddr# [] [u2, u3]; _NO_DEFLT_ }; _NO_DEFLT_ } _N_ },
+ (>=) = { _A_ 2 _U_ 11 _N_ _S_ "U(P)U(P)" {_A_ 2 _U_ 22 _N_ _N_ _F_ _IF_ARGS_ 0 2 XX 1 \ (u0 :: Addr#) (u1 :: Addr#) -> _#_ geAddr# [] [u0, u1] _N_} _F_ _IF_ARGS_ 0 2 CC 3 \ (u0 :: _Addr) (u1 :: _Addr) -> case u0 of { _ALG_ A# (u2 :: Addr#) -> case u1 of { _ALG_ A# (u3 :: Addr#) -> _#_ geAddr# [] [u2, u3]; _NO_DEFLT_ }; _NO_DEFLT_ } _N_ },
+ (>) = { _A_ 2 _U_ 11 _N_ _S_ "U(P)U(P)" {_A_ 2 _U_ 22 _N_ _N_ _F_ _IF_ARGS_ 0 2 XX 1 \ (u0 :: Addr#) (u1 :: Addr#) -> _#_ gtAddr# [] [u0, u1] _N_} _F_ _IF_ARGS_ 0 2 CC 3 \ (u0 :: _Addr) (u1 :: _Addr) -> case u0 of { _ALG_ A# (u2 :: Addr#) -> case u1 of { _ALG_ A# (u3 :: Addr#) -> _#_ gtAddr# [] [u2, u3]; _NO_DEFLT_ }; _NO_DEFLT_ } _N_ },
+ max = { _A_ 2 _U_ 11 _N_ _S_ "U(P)U(P)" {_A_ 2 _U_ 22 _N_ _N_ _N_ _N_} _N_ _N_ },
+ min = { _A_ 2 _U_ 11 _N_ _S_ "U(P)U(P)" {_A_ 2 _U_ 22 _N_ _N_ _N_ _N_} _N_ _N_ },
+ _tagCmp = { _A_ 2 _U_ 11 _N_ _S_ "U(P)U(P)" {_A_ 2 _U_ 22 _N_ _N_ _N_ _N_} _N_ _N_ } #-}
instance Ord _PackedString
{-# GHC_PRAGMA _M_ PreludePS {-dfun-} _A_ 0 _N_ _N_ _N_ _F_ _IF_ARGS_ 0 0 X 9 _!_ _TUP_8 [{{Eq _PackedString}}, (_PackedString -> _PackedString -> Bool), (_PackedString -> _PackedString -> Bool), (_PackedString -> _PackedString -> Bool), (_PackedString -> _PackedString -> Bool), (_PackedString -> _PackedString -> _PackedString), (_PackedString -> _PackedString -> _PackedString), (_PackedString -> _PackedString -> _CMP_TAG)] [_DFUN_ Eq (_PackedString), _CONSTM_ Ord (<) (_PackedString), _CONSTM_ Ord (<=) (_PackedString), _CONSTM_ Ord (>=) (_PackedString), _CONSTM_ Ord (>) (_PackedString), _CONSTM_ Ord max (_PackedString), _CONSTM_ Ord min (_PackedString), _CONSTM_ Ord _tagCmp (_PackedString)] _N_
- (<) = _A_ 2 _U_ 22 _N_ _S_ "SS" _N_ _N_,
- (<=) = _A_ 2 _U_ 22 _N_ _S_ "SS" _N_ _N_,
- (>=) = _A_ 2 _U_ 22 _N_ _S_ "SS" _N_ _N_,
- (>) = _A_ 2 _U_ 22 _N_ _S_ "SS" _N_ _N_,
- max = _A_ 2 _U_ 22 _N_ _N_ _N_ _N_,
- min = _A_ 2 _U_ 22 _N_ _N_ _N_ _N_,
- _tagCmp = _A_ 2 _U_ 22 _N_ _S_ "SS" _N_ _N_ #-}
+ (<) = { _A_ 2 _U_ 22 _N_ _S_ "SS" _N_ _N_ },
+ (<=) = { _A_ 2 _U_ 22 _N_ _S_ "SS" _N_ _N_ },
+ (>=) = { _A_ 2 _U_ 22 _N_ _S_ "SS" _N_ _N_ },
+ (>) = { _A_ 2 _U_ 22 _N_ _S_ "SS" _N_ _N_ },
+ max = { _A_ 2 _U_ 22 _N_ _S_ "SS" _N_ _N_ },
+ min = { _A_ 2 _U_ 22 _N_ _S_ "SS" _N_ _N_ },
+ _tagCmp = { _A_ 2 _U_ 22 _N_ _S_ "SS" _N_ _N_ } #-}
instance Ord _Word
{-# GHC_PRAGMA _M_ PreludeCore {-dfun-} _A_ 0 _N_ _N_ _N_ _F_ _IF_ARGS_ 0 0 X 9 _!_ _TUP_8 [{{Eq _Word}}, (_Word -> _Word -> Bool), (_Word -> _Word -> Bool), (_Word -> _Word -> Bool), (_Word -> _Word -> Bool), (_Word -> _Word -> _Word), (_Word -> _Word -> _Word), (_Word -> _Word -> _CMP_TAG)] [_DFUN_ Eq (_Word), _CONSTM_ Ord (<) (_Word), _CONSTM_ Ord (<=) (_Word), _CONSTM_ Ord (>=) (_Word), _CONSTM_ Ord (>) (_Word), _CONSTM_ Ord max (_Word), _CONSTM_ Ord min (_Word), _CONSTM_ Ord _tagCmp (_Word)] _N_
- (<) = _A_ 2 _U_ 11 _N_ _S_ "U(P)U(P)" {_A_ 2 _U_ 22 _N_ _N_ _F_ _IF_ARGS_ 0 2 XX 1 \ (u0 :: Word#) (u1 :: Word#) -> _#_ ltWord# [] [u0, u1] _N_} _F_ _IF_ARGS_ 0 2 CC 3 \ (u0 :: _Word) (u1 :: _Word) -> case u0 of { _ALG_ W# (u2 :: Word#) -> case u1 of { _ALG_ W# (u3 :: Word#) -> _#_ ltWord# [] [u2, u3]; _NO_DEFLT_ }; _NO_DEFLT_ } _N_,
- (<=) = _A_ 2 _U_ 11 _N_ _S_ "U(P)U(P)" {_A_ 2 _U_ 22 _N_ _N_ _F_ _IF_ARGS_ 0 2 XX 1 \ (u0 :: Word#) (u1 :: Word#) -> _#_ leWord# [] [u0, u1] _N_} _F_ _IF_ARGS_ 0 2 CC 3 \ (u0 :: _Word) (u1 :: _Word) -> case u0 of { _ALG_ W# (u2 :: Word#) -> case u1 of { _ALG_ W# (u3 :: Word#) -> _#_ leWord# [] [u2, u3]; _NO_DEFLT_ }; _NO_DEFLT_ } _N_,
- (>=) = _A_ 2 _U_ 11 _N_ _S_ "U(P)U(P)" {_A_ 2 _U_ 22 _N_ _N_ _F_ _IF_ARGS_ 0 2 XX 1 \ (u0 :: Word#) (u1 :: Word#) -> _#_ geWord# [] [u0, u1] _N_} _F_ _IF_ARGS_ 0 2 CC 3 \ (u0 :: _Word) (u1 :: _Word) -> case u0 of { _ALG_ W# (u2 :: Word#) -> case u1 of { _ALG_ W# (u3 :: Word#) -> _#_ geWord# [] [u2, u3]; _NO_DEFLT_ }; _NO_DEFLT_ } _N_,
- (>) = _A_ 2 _U_ 11 _N_ _S_ "U(P)U(P)" {_A_ 2 _U_ 22 _N_ _N_ _F_ _IF_ARGS_ 0 2 XX 1 \ (u0 :: Word#) (u1 :: Word#) -> _#_ gtWord# [] [u0, u1] _N_} _F_ _IF_ARGS_ 0 2 CC 3 \ (u0 :: _Word) (u1 :: _Word) -> case u0 of { _ALG_ W# (u2 :: Word#) -> case u1 of { _ALG_ W# (u3 :: Word#) -> _#_ gtWord# [] [u2, u3]; _NO_DEFLT_ }; _NO_DEFLT_ } _N_,
- max = _A_ 2 _U_ 11 _N_ _S_ "U(P)U(P)" {_A_ 2 _U_ 22 _N_ _N_ _N_ _N_} _N_ _N_,
- min = _A_ 2 _U_ 11 _N_ _S_ "U(P)U(P)" {_A_ 2 _U_ 22 _N_ _N_ _N_ _N_} _N_ _N_,
- _tagCmp = _A_ 2 _U_ 11 _N_ _S_ "U(P)U(P)" {_A_ 2 _U_ 22 _N_ _N_ _N_ _N_} _N_ _N_ #-}
+ (<) = { _A_ 2 _U_ 11 _N_ _S_ "U(P)U(P)" {_A_ 2 _U_ 22 _N_ _N_ _F_ _IF_ARGS_ 0 2 XX 1 \ (u0 :: Word#) (u1 :: Word#) -> _#_ ltWord# [] [u0, u1] _N_} _F_ _IF_ARGS_ 0 2 CC 3 \ (u0 :: _Word) (u1 :: _Word) -> case u0 of { _ALG_ W# (u2 :: Word#) -> case u1 of { _ALG_ W# (u3 :: Word#) -> _#_ ltWord# [] [u2, u3]; _NO_DEFLT_ }; _NO_DEFLT_ } _N_ },
+ (<=) = { _A_ 2 _U_ 11 _N_ _S_ "U(P)U(P)" {_A_ 2 _U_ 22 _N_ _N_ _F_ _IF_ARGS_ 0 2 XX 1 \ (u0 :: Word#) (u1 :: Word#) -> _#_ leWord# [] [u0, u1] _N_} _F_ _IF_ARGS_ 0 2 CC 3 \ (u0 :: _Word) (u1 :: _Word) -> case u0 of { _ALG_ W# (u2 :: Word#) -> case u1 of { _ALG_ W# (u3 :: Word#) -> _#_ leWord# [] [u2, u3]; _NO_DEFLT_ }; _NO_DEFLT_ } _N_ },
+ (>=) = { _A_ 2 _U_ 11 _N_ _S_ "U(P)U(P)" {_A_ 2 _U_ 22 _N_ _N_ _F_ _IF_ARGS_ 0 2 XX 1 \ (u0 :: Word#) (u1 :: Word#) -> _#_ geWord# [] [u0, u1] _N_} _F_ _IF_ARGS_ 0 2 CC 3 \ (u0 :: _Word) (u1 :: _Word) -> case u0 of { _ALG_ W# (u2 :: Word#) -> case u1 of { _ALG_ W# (u3 :: Word#) -> _#_ geWord# [] [u2, u3]; _NO_DEFLT_ }; _NO_DEFLT_ } _N_ },
+ (>) = { _A_ 2 _U_ 11 _N_ _S_ "U(P)U(P)" {_A_ 2 _U_ 22 _N_ _N_ _F_ _IF_ARGS_ 0 2 XX 1 \ (u0 :: Word#) (u1 :: Word#) -> _#_ gtWord# [] [u0, u1] _N_} _F_ _IF_ARGS_ 0 2 CC 3 \ (u0 :: _Word) (u1 :: _Word) -> case u0 of { _ALG_ W# (u2 :: Word#) -> case u1 of { _ALG_ W# (u3 :: Word#) -> _#_ gtWord# [] [u2, u3]; _NO_DEFLT_ }; _NO_DEFLT_ } _N_ },
+ max = { _A_ 2 _U_ 11 _N_ _S_ "U(P)U(P)" {_A_ 2 _U_ 22 _N_ _N_ _N_ _N_} _N_ _N_ },
+ min = { _A_ 2 _U_ 11 _N_ _S_ "U(P)U(P)" {_A_ 2 _U_ 22 _N_ _N_ _N_ _N_} _N_ _N_ },
+ _tagCmp = { _A_ 2 _U_ 11 _N_ _S_ "U(P)U(P)" {_A_ 2 _U_ 22 _N_ _N_ _N_ _N_} _N_ _N_ } #-}
instance Real Double
{-# GHC_PRAGMA _M_ PreludeCore {-dfun-} _A_ 0 _N_ _N_ _N_ _F_ _IF_ARGS_ 0 0 X 4 _!_ _TUP_3 [{{Num Double}}, {{Enum Double}}, (Double -> Ratio Integer)] [_DFUN_ Num (Double), _DFUN_ Enum (Double), _CONSTM_ Real toRational (Double)] _N_
- toRational = _A_ 1 _U_ 1 _N_ _S_ "U(P)" {_A_ 1 _U_ 2 _N_ _N_ _N_ _N_} _N_ _N_ #-}
+ toRational = { _A_ 1 _U_ 1 _N_ _S_ "U(P)" {_A_ 1 _U_ 2 _N_ _N_ _N_ _N_} _N_ _N_ } #-}
instance Real Float
{-# GHC_PRAGMA _M_ PreludeCore {-dfun-} _A_ 0 _N_ _N_ _N_ _F_ _IF_ARGS_ 0 0 X 4 _!_ _TUP_3 [{{Num Float}}, {{Enum Float}}, (Float -> Ratio Integer)] [_DFUN_ Num (Float), _DFUN_ Enum (Float), _CONSTM_ Real toRational (Float)] _N_
- toRational = _A_ 1 _U_ 1 _N_ _S_ "U(P)" {_A_ 1 _U_ 2 _N_ _N_ _N_ _N_} _N_ _N_ #-}
+ toRational = { _A_ 1 _U_ 1 _N_ _S_ "U(P)" {_A_ 1 _U_ 2 _N_ _N_ _N_ _N_} _N_ _N_ } #-}
instance Real Int
{-# GHC_PRAGMA _M_ PreludeCore {-dfun-} _A_ 0 _N_ _N_ _N_ _F_ _IF_ARGS_ 0 0 X 4 _!_ _TUP_3 [{{Num Int}}, {{Enum Int}}, (Int -> Ratio Integer)] [_DFUN_ Num (Int), _DFUN_ Enum (Int), _CONSTM_ Real toRational (Int)] _N_
- toRational = _A_ 1 _U_ 1 _N_ _N_ _N_ _N_ #-}
+ toRational = { _A_ 1 _U_ 1 _N_ _N_ _N_ _N_ } #-}
instance Real Integer
{-# GHC_PRAGMA _M_ PreludeCore {-dfun-} _A_ 0 _N_ _N_ _N_ _F_ _IF_ARGS_ 0 0 X 4 _!_ _TUP_3 [{{Num Integer}}, {{Enum Integer}}, (Integer -> Ratio Integer)] [_DFUN_ Num (Integer), _DFUN_ Enum (Integer), _CONSTM_ Real toRational (Integer)] _N_
- toRational = _A_ 1 _U_ 2 _N_ _N_ _N_ _N_ #-}
+ toRational = { _A_ 1 _U_ 2 _N_ _N_ _F_ _IF_ARGS_ 0 1 X 3 \ (u0 :: Integer) -> _!_ (:%) [Integer] [u0, _ORIG_ PreludeCore __integer1] _N_ } #-}
instance Integral a => Real (Ratio a)
{-# GHC_PRAGMA _M_ PreludeRatio {-dfun-} _A_ 3 _U_ 122 _N_ _N_ _N_ _N_ #-}
instance Real (Ratio Integer)
{-# GHC_PRAGMA _M_ PreludeRatio {-dfun-} _A_ 0 _N_ _N_ _N_ _F_ _IF_ARGS_ 0 0 X 4 _!_ _TUP_3 [{{Num (Ratio Integer)}}, {{Enum (Ratio Integer)}}, (Ratio Integer -> Ratio Integer)] [_DFUN_ Num (Ratio Integer), _DFUN_ Enum (Ratio Integer), _CONSTM_ Real toRational (Ratio Integer)] _N_
- toRational = _A_ 1 _U_ 1 _N_ _S_ "U(LL)" {_A_ 2 _U_ 22 _N_ _N_ _F_ _IF_ARGS_ 0 2 XX 3 \ (u0 :: Integer) (u1 :: Integer) -> _!_ (:%) [Integer] [u0, u1] _N_} _F_ _IF_ARGS_ 0 1 X 1 \ (u0 :: Ratio Integer) -> u0 _N_ #-}
+ toRational = { _A_ 1 _U_ 1 _N_ _S_ "U(LL)" {_A_ 2 _U_ 22 _N_ _N_ _F_ _IF_ARGS_ 0 2 XX 3 \ (u0 :: Integer) (u1 :: Integer) -> _!_ (:%) [Integer] [u0, u1] _N_} _F_ _IF_ARGS_ 0 1 X 1 \ (u0 :: Ratio Integer) -> u0 _N_ } #-}
instance RealFloat Double
{-# GHC_PRAGMA _M_ PreludeCore {-dfun-} _A_ 0 _N_ _N_ _N_ _F_ _IF_ARGS_ 0 0 X 11 _!_ _TUP_10 [{{RealFrac Double}}, {{Floating Double}}, (Double -> Integer), (Double -> Int), (Double -> (Int, Int)), (Double -> (Integer, Int)), (Integer -> Int -> Double), (Double -> Int), (Double -> Double), (Int -> Double -> Double)] [_DFUN_ RealFrac (Double), _DFUN_ Floating (Double), _CONSTM_ RealFloat floatRadix (Double), _CONSTM_ RealFloat floatDigits (Double), _CONSTM_ RealFloat floatRange (Double), _CONSTM_ RealFloat decodeFloat (Double), _CONSTM_ RealFloat encodeFloat (Double), _CONSTM_ RealFloat exponent (Double), _CONSTM_ RealFloat significand (Double), _CONSTM_ RealFloat scaleFloat (Double)] _N_
- floatRadix = _A_ 1 _U_ 0 _N_ _S_ "A" {_A_ 0 _N_ _N_ _N_ _F_ _IF_ARGS_ 0 0 X 1 _#_ int2Integer# [] [2#] _N_} _N_ _N_,
- floatDigits = _A_ 1 _U_ 0 _N_ _S_ "A" {_A_ 0 _N_ _N_ _N_ _F_ _IF_ARGS_ 0 0 X 2 _!_ I# [] [53#] _N_} _F_ _IF_ARGS_ 0 1 X 2 \ (u0 :: Double) -> _!_ I# [] [53#] _N_,
- floatRange = _A_ 1 _U_ 0 _N_ _S_ "A" {_A_ 0 _N_ _N_ _N_ _N_ _N_} _N_ _N_,
- decodeFloat = _A_ 1 _U_ 1 _N_ _S_ "U(P)" {_A_ 1 _U_ 2 _N_ _N_ _N_ _N_} _N_ _N_,
- encodeFloat = _A_ 2 _U_ 11 _N_ _S_ "U(PPP)U(P)" {_A_ 4 _U_ 2222 _N_ _N_ _F_ _IF_ARGS_ 0 4 XXXX 3 \ (u0 :: Int#) (u1 :: Int#) (u2 :: ByteArray#) (u3 :: Int#) -> case _#_ encodeDouble# [] [u0, u1, u2, u3] of { _PRIM_ (u4 :: Double#) -> _!_ D# [] [u4] } _N_} _F_ _IF_ARGS_ 0 2 CC 5 \ (u0 :: Integer) (u1 :: Int) -> case u0 of { _ALG_ J# (u2 :: Int#) (u3 :: Int#) (u4 :: ByteArray#) -> case u1 of { _ALG_ I# (u5 :: Int#) -> case _#_ encodeDouble# [] [u2, u3, u4, u5] of { _PRIM_ (u6 :: Double#) -> _!_ D# [] [u6] }; _NO_DEFLT_ }; _NO_DEFLT_ } _N_,
- exponent = _A_ 1 _U_ 2 _N_ _N_ _N_ _N_,
- significand = _A_ 1 _U_ 2 _N_ _N_ _N_ _N_,
- scaleFloat = _A_ 2 _U_ 22 _N_ _N_ _N_ _N_ #-}
+ floatRadix = { _A_ 1 _U_ 0 _N_ _S_ "A" {_A_ 0 _N_ _N_ _N_ _N_ _N_} _N_ _N_ },
+ floatDigits = { _A_ 1 _U_ 0 _N_ _S_ "A" {_A_ 0 _N_ _N_ _N_ _F_ _IF_ARGS_ 0 0 X 2 _!_ I# [] [53#] _N_} _F_ _IF_ARGS_ 0 1 X 2 \ (u0 :: Double) -> _!_ I# [] [53#] _N_ },
+ floatRange = { _A_ 1 _U_ 0 _N_ _S_ "A" {_A_ 0 _N_ _N_ _N_ _N_ _N_} _N_ _N_ },
+ decodeFloat = { _A_ 1 _U_ 1 _N_ _S_ "U(P)" {_A_ 1 _U_ 2 _N_ _N_ _N_ _N_} _N_ _N_ },
+ encodeFloat = { _A_ 2 _U_ 11 _N_ _S_ "U(PPP)U(P)" {_A_ 4 _U_ 2222 _N_ _N_ _F_ _IF_ARGS_ 0 4 XXXX 3 \ (u0 :: Int#) (u1 :: Int#) (u2 :: ByteArray#) (u3 :: Int#) -> case _#_ encodeDouble# [] [u0, u1, u2, u3] of { _PRIM_ (u4 :: Double#) -> _!_ D# [] [u4] } _N_} _F_ _IF_ARGS_ 0 2 CC 5 \ (u0 :: Integer) (u1 :: Int) -> case u0 of { _ALG_ J# (u2 :: Int#) (u3 :: Int#) (u4 :: ByteArray#) -> case u1 of { _ALG_ I# (u5 :: Int#) -> case _#_ encodeDouble# [] [u2, u3, u4, u5] of { _PRIM_ (u6 :: Double#) -> _!_ D# [] [u6] }; _NO_DEFLT_ }; _NO_DEFLT_ } _N_ },
+ exponent = { _A_ 1 _U_ 1 _N_ _S_ "U(P)" {_A_ 1 _U_ 2 _N_ _N_ _N_ _N_} _N_ _N_ },
+ significand = { _A_ 1 _U_ 1 _N_ _S_ "U(P)" {_A_ 1 _U_ 2 _N_ _N_ _N_ _N_} _N_ _N_ },
+ scaleFloat = { _A_ 2 _U_ 11 _N_ _S_ "U(P)U(P)" {_A_ 2 _U_ 22 _N_ _N_ _N_ _N_} _N_ _N_ } #-}
instance RealFloat Float
{-# GHC_PRAGMA _M_ PreludeCore {-dfun-} _A_ 0 _N_ _N_ _N_ _F_ _IF_ARGS_ 0 0 X 11 _!_ _TUP_10 [{{RealFrac Float}}, {{Floating Float}}, (Float -> Integer), (Float -> Int), (Float -> (Int, Int)), (Float -> (Integer, Int)), (Integer -> Int -> Float), (Float -> Int), (Float -> Float), (Int -> Float -> Float)] [_DFUN_ RealFrac (Float), _DFUN_ Floating (Float), _CONSTM_ RealFloat floatRadix (Float), _CONSTM_ RealFloat floatDigits (Float), _CONSTM_ RealFloat floatRange (Float), _CONSTM_ RealFloat decodeFloat (Float), _CONSTM_ RealFloat encodeFloat (Float), _CONSTM_ RealFloat exponent (Float), _CONSTM_ RealFloat significand (Float), _CONSTM_ RealFloat scaleFloat (Float)] _N_
- floatRadix = _A_ 1 _U_ 0 _N_ _S_ "A" {_A_ 0 _N_ _N_ _N_ _F_ _IF_ARGS_ 0 0 X 1 _#_ int2Integer# [] [2#] _N_} _N_ _N_,
- floatDigits = _A_ 1 _U_ 0 _N_ _S_ "A" {_A_ 0 _N_ _N_ _N_ _F_ _IF_ARGS_ 0 0 X 2 _!_ I# [] [24#] _N_} _F_ _IF_ARGS_ 0 1 X 2 \ (u0 :: Float) -> _!_ I# [] [24#] _N_,
- floatRange = _A_ 1 _U_ 0 _N_ _S_ "A" {_A_ 0 _N_ _N_ _N_ _N_ _N_} _N_ _N_,
- decodeFloat = _A_ 1 _U_ 1 _N_ _S_ "U(P)" {_A_ 1 _U_ 2 _N_ _N_ _N_ _N_} _N_ _N_,
- encodeFloat = _A_ 2 _U_ 11 _N_ _S_ "U(PPP)U(P)" {_A_ 4 _U_ 2222 _N_ _N_ _F_ _IF_ARGS_ 0 4 XXXX 3 \ (u0 :: Int#) (u1 :: Int#) (u2 :: ByteArray#) (u3 :: Int#) -> case _#_ encodeFloat# [] [u0, u1, u2, u3] of { _PRIM_ (u4 :: Float#) -> _!_ F# [] [u4] } _N_} _F_ _IF_ARGS_ 0 2 CC 5 \ (u0 :: Integer) (u1 :: Int) -> case u0 of { _ALG_ J# (u2 :: Int#) (u3 :: Int#) (u4 :: ByteArray#) -> case u1 of { _ALG_ I# (u5 :: Int#) -> case _#_ encodeFloat# [] [u2, u3, u4, u5] of { _PRIM_ (u6 :: Float#) -> _!_ F# [] [u6] }; _NO_DEFLT_ }; _NO_DEFLT_ } _N_,
- exponent = _A_ 1 _U_ 2 _N_ _N_ _N_ _N_,
- significand = _A_ 1 _U_ 2 _N_ _N_ _N_ _N_,
- scaleFloat = _A_ 2 _U_ 22 _N_ _N_ _N_ _N_ #-}
+ floatRadix = { _A_ 1 _U_ 0 _N_ _S_ "A" {_A_ 0 _N_ _N_ _N_ _N_ _N_} _N_ _N_ },
+ floatDigits = { _A_ 1 _U_ 0 _N_ _S_ "A" {_A_ 0 _N_ _N_ _N_ _F_ _IF_ARGS_ 0 0 X 2 _!_ I# [] [24#] _N_} _F_ _IF_ARGS_ 0 1 X 2 \ (u0 :: Float) -> _!_ I# [] [24#] _N_ },
+ floatRange = { _A_ 1 _U_ 0 _N_ _S_ "A" {_A_ 0 _N_ _N_ _N_ _N_ _N_} _N_ _N_ },
+ decodeFloat = { _A_ 1 _U_ 1 _N_ _S_ "U(P)" {_A_ 1 _U_ 2 _N_ _N_ _N_ _N_} _N_ _N_ },
+ encodeFloat = { _A_ 2 _U_ 11 _N_ _S_ "U(PPP)U(P)" {_A_ 4 _U_ 2222 _N_ _N_ _F_ _IF_ARGS_ 0 4 XXXX 3 \ (u0 :: Int#) (u1 :: Int#) (u2 :: ByteArray#) (u3 :: Int#) -> case _#_ encodeFloat# [] [u0, u1, u2, u3] of { _PRIM_ (u4 :: Float#) -> _!_ F# [] [u4] } _N_} _F_ _IF_ARGS_ 0 2 CC 5 \ (u0 :: Integer) (u1 :: Int) -> case u0 of { _ALG_ J# (u2 :: Int#) (u3 :: Int#) (u4 :: ByteArray#) -> case u1 of { _ALG_ I# (u5 :: Int#) -> case _#_ encodeFloat# [] [u2, u3, u4, u5] of { _PRIM_ (u6 :: Float#) -> _!_ F# [] [u6] }; _NO_DEFLT_ }; _NO_DEFLT_ } _N_ },
+ exponent = { _A_ 1 _U_ 1 _N_ _S_ "U(P)" {_A_ 1 _U_ 2 _N_ _N_ _N_ _N_} _N_ _N_ },
+ significand = { _A_ 1 _U_ 1 _N_ _S_ "U(P)" {_A_ 1 _U_ 2 _N_ _N_ _N_ _N_} _N_ _N_ },
+ scaleFloat = { _A_ 2 _U_ 11 _N_ _S_ "U(P)U(P)" {_A_ 2 _U_ 22 _N_ _N_ _N_ _N_} _N_ _N_ } #-}
instance RealFrac Double
{-# GHC_PRAGMA _M_ PreludeCore {-dfun-} _A_ 0 _N_ _N_ _N_ _F_ _IF_ARGS_ 0 0 X 8 _!_ _TUP_7 [{{Real Double}}, {{Fractional Double}}, _forall_ a$z1 =>{{Integral a$z1}} -> (Double -> (a$z1, Double)), _forall_ a$z1 =>{{Integral a$z1}} -> (Double -> a$z1), _forall_ a$z1 =>{{Integral a$z1}} -> (Double -> a$z1), _forall_ a$z1 =>{{Integral a$z1}} -> (Double -> a$z1), _forall_ a$z1 =>{{Integral a$z1}} -> (Double -> a$z1)] [_DFUN_ Real (Double), _DFUN_ Fractional (Double), _CONSTM_ RealFrac properFraction (Double), _CONSTM_ RealFrac truncate (Double), _CONSTM_ RealFrac round (Double), _CONSTM_ RealFrac ceiling (Double), _CONSTM_ RealFrac floor (Double)] _N_
- properFraction = _A_ 1 _U_ 22 _N_ _N_ _N_ _N_,
- truncate = _A_ 1 _U_ 22 _N_ _N_ _N_ _N_,
- round = _A_ 1 _U_ 22 _N_ _N_ _N_ _N_,
- ceiling = _A_ 1 _U_ 22 _N_ _N_ _N_ _N_,
- floor = _A_ 1 _U_ 22 _N_ _N_ _N_ _N_ #-}
+ properFraction = { _A_ 1 _U_ 11 _N_ _N_ _N_ _SPECIALISE_ [ Int ] 1 { _A_ 1 _U_ 1 _N_ _S_ "U(P)" {_A_ 1 _U_ 2 _N_ _N_ _N_ _N_} _N_ _N_ }, [ Integer ] 1 { _A_ 1 _U_ 1 _N_ _S_ "U(P)" {_A_ 1 _U_ 2 _N_ _N_ _N_ _N_} _N_ _N_ } },
+ truncate = { _A_ 1 _U_ 11 _N_ _N_ _N_ _SPECIALISE_ [ Int ] 1 { _A_ 1 _U_ 1 _N_ _S_ "U(P)" {_A_ 1 _U_ 2 _N_ _N_ _F_ _IF_ARGS_ 0 1 X 4 \ (u0 :: Double#) -> case _APP_ _WRKR_ _SPEC_ _CONSTM_ RealFrac properFraction (Double) [ (Int) ] [ u0 ] of { _ALG_ _TUP_2 (u1 :: Int) (u2 :: Double) -> u1; _NO_DEFLT_ } _N_} _F_ _IF_ARGS_ 0 1 X 4 \ (u0 :: Double) -> case _APP_ _SPEC_ _CONSTM_ RealFrac properFraction (Double) [ (Int) ] [ u0 ] of { _ALG_ _TUP_2 (u1 :: Int) (u2 :: Double) -> u1; _NO_DEFLT_ } _N_ }, [ Integer ] 1 { _A_ 1 _U_ 1 _N_ _S_ "U(P)" {_A_ 1 _U_ 2 _N_ _N_ _F_ _IF_ARGS_ 0 1 X 4 \ (u0 :: Double#) -> case _APP_ _WRKR_ _SPEC_ _CONSTM_ RealFrac properFraction (Double) [ (Integer) ] [ u0 ] of { _ALG_ _TUP_2 (u1 :: Integer) (u2 :: Double) -> u1; _NO_DEFLT_ } _N_} _F_ _IF_ARGS_ 0 1 X 4 \ (u0 :: Double) -> case _APP_ _SPEC_ _CONSTM_ RealFrac properFraction (Double) [ (Integer) ] [ u0 ] of { _ALG_ _TUP_2 (u1 :: Integer) (u2 :: Double) -> u1; _NO_DEFLT_ } _N_ } },
+ round = { _A_ 1 _U_ 21 _N_ _N_ _N_ _SPECIALISE_ [ Int ] 1 { _A_ 1 _U_ 1 _N_ _S_ "U(P)" {_A_ 1 _U_ 2 _N_ _N_ _N_ _N_} _N_ _N_ }, [ Integer ] 1 { _A_ 1 _U_ 1 _N_ _S_ "U(P)" {_A_ 1 _U_ 2 _N_ _N_ _N_ _N_} _N_ _N_ } },
+ ceiling = { _A_ 1 _U_ 21 _N_ _N_ _N_ _SPECIALISE_ [ Int ] 1 { _A_ 1 _U_ 1 _N_ _S_ "U(P)" {_A_ 1 _U_ 2 _N_ _N_ _N_ _N_} _N_ _N_ }, [ Integer ] 1 { _A_ 1 _U_ 1 _N_ _S_ "U(P)" {_A_ 1 _U_ 2 _N_ _N_ _N_ _N_} _N_ _N_ } },
+ floor = { _A_ 1 _U_ 21 _N_ _N_ _N_ _SPECIALISE_ [ Int ] 1 { _A_ 1 _U_ 1 _N_ _S_ "U(P)" {_A_ 1 _U_ 2 _N_ _N_ _N_ _N_} _N_ _N_ }, [ Integer ] 1 { _A_ 1 _U_ 1 _N_ _S_ "U(P)" {_A_ 1 _U_ 2 _N_ _N_ _N_ _N_} _N_ _N_ } } #-}
instance RealFrac Float
{-# GHC_PRAGMA _M_ PreludeCore {-dfun-} _A_ 0 _N_ _N_ _N_ _F_ _IF_ARGS_ 0 0 X 8 _!_ _TUP_7 [{{Real Float}}, {{Fractional Float}}, _forall_ a$z1 =>{{Integral a$z1}} -> (Float -> (a$z1, Float)), _forall_ a$z1 =>{{Integral a$z1}} -> (Float -> a$z1), _forall_ a$z1 =>{{Integral a$z1}} -> (Float -> a$z1), _forall_ a$z1 =>{{Integral a$z1}} -> (Float -> a$z1), _forall_ a$z1 =>{{Integral a$z1}} -> (Float -> a$z1)] [_DFUN_ Real (Float), _DFUN_ Fractional (Float), _CONSTM_ RealFrac properFraction (Float), _CONSTM_ RealFrac truncate (Float), _CONSTM_ RealFrac round (Float), _CONSTM_ RealFrac ceiling (Float), _CONSTM_ RealFrac floor (Float)] _N_
- properFraction = _A_ 1 _U_ 22 _N_ _N_ _N_ _N_,
- truncate = _A_ 1 _U_ 22 _N_ _N_ _N_ _N_,
- round = _A_ 1 _U_ 22 _N_ _N_ _N_ _N_,
- ceiling = _A_ 1 _U_ 22 _N_ _N_ _N_ _N_,
- floor = _A_ 1 _U_ 22 _N_ _N_ _N_ _N_ #-}
-instance Integral a => RealFrac (Ratio a)
- {-# GHC_PRAGMA _M_ PreludeRatio {-dfun-} _A_ 3 _U_ 222 _N_ _N_ _N_ _N_ #-}
+ properFraction = { _A_ 1 _U_ 11 _N_ _N_ _N_ _SPECIALISE_ [ Int ] 1 { _A_ 1 _U_ 1 _N_ _S_ "U(P)" {_A_ 1 _U_ 2 _N_ _N_ _N_ _N_} _N_ _N_ }, [ Integer ] 1 { _A_ 1 _U_ 1 _N_ _S_ "U(P)" {_A_ 1 _U_ 2 _N_ _N_ _N_ _N_} _N_ _N_ } },
+ truncate = { _A_ 1 _U_ 11 _N_ _N_ _N_ _SPECIALISE_ [ Int ] 1 { _A_ 1 _U_ 1 _N_ _S_ "U(P)" {_A_ 1 _U_ 2 _N_ _N_ _F_ _IF_ARGS_ 0 1 X 4 \ (u0 :: Float#) -> case _APP_ _WRKR_ _SPEC_ _CONSTM_ RealFrac properFraction (Float) [ (Int) ] [ u0 ] of { _ALG_ _TUP_2 (u1 :: Int) (u2 :: Float) -> u1; _NO_DEFLT_ } _N_} _F_ _IF_ARGS_ 0 1 X 4 \ (u0 :: Float) -> case _APP_ _SPEC_ _CONSTM_ RealFrac properFraction (Float) [ (Int) ] [ u0 ] of { _ALG_ _TUP_2 (u1 :: Int) (u2 :: Float) -> u1; _NO_DEFLT_ } _N_ }, [ Integer ] 1 { _A_ 1 _U_ 1 _N_ _S_ "U(P)" {_A_ 1 _U_ 2 _N_ _N_ _F_ _IF_ARGS_ 0 1 X 4 \ (u0 :: Float#) -> case _APP_ _WRKR_ _SPEC_ _CONSTM_ RealFrac properFraction (Float) [ (Integer) ] [ u0 ] of { _ALG_ _TUP_2 (u1 :: Integer) (u2 :: Float) -> u1; _NO_DEFLT_ } _N_} _F_ _IF_ARGS_ 0 1 X 4 \ (u0 :: Float) -> case _APP_ _SPEC_ _CONSTM_ RealFrac properFraction (Float) [ (Integer) ] [ u0 ] of { _ALG_ _TUP_2 (u1 :: Integer) (u2 :: Float) -> u1; _NO_DEFLT_ } _N_ } },
+ round = { _A_ 1 _U_ 21 _N_ _N_ _N_ _SPECIALISE_ [ Int ] 1 { _A_ 1 _U_ 1 _N_ _S_ "U(P)" {_A_ 1 _U_ 2 _N_ _N_ _N_ _N_} _N_ _N_ }, [ Integer ] 1 { _A_ 1 _U_ 1 _N_ _S_ "U(P)" {_A_ 1 _U_ 2 _N_ _N_ _N_ _N_} _N_ _N_ } },
+ ceiling = { _A_ 1 _U_ 21 _N_ _N_ _N_ _SPECIALISE_ [ Int ] 1 { _A_ 1 _U_ 1 _N_ _S_ "U(P)" {_A_ 1 _U_ 2 _N_ _N_ _N_ _N_} _N_ _N_ }, [ Integer ] 1 { _A_ 1 _U_ 1 _N_ _S_ "U(P)" {_A_ 1 _U_ 2 _N_ _N_ _N_ _N_} _N_ _N_ } },
+ floor = { _A_ 1 _U_ 21 _N_ _N_ _N_ _SPECIALISE_ [ Int ] 1 { _A_ 1 _U_ 1 _N_ _S_ "U(P)" {_A_ 1 _U_ 2 _N_ _N_ _N_ _N_} _N_ _N_ }, [ Integer ] 1 { _A_ 1 _U_ 1 _N_ _S_ "U(P)" {_A_ 1 _U_ 2 _N_ _N_ _N_ _N_} _N_ _N_ } } #-}
instance RealFrac (Ratio Integer)
{-# GHC_PRAGMA _M_ PreludeRatio {-dfun-} _A_ 0 _N_ _N_ _N_ _F_ _IF_ARGS_ 0 0 X 8 _!_ _TUP_7 [{{Real (Ratio Integer)}}, {{Fractional (Ratio Integer)}}, _forall_ a$z1 =>{{Integral a$z1}} -> (Ratio Integer -> (a$z1, Ratio Integer)), _forall_ a$z1 =>{{Integral a$z1}} -> (Ratio Integer -> a$z1), _forall_ a$z1 =>{{Integral a$z1}} -> (Ratio Integer -> a$z1), _forall_ a$z1 =>{{Integral a$z1}} -> (Ratio Integer -> a$z1), _forall_ a$z1 =>{{Integral a$z1}} -> (Ratio Integer -> a$z1)] [_DFUN_ Real (Ratio Integer), _DFUN_ Fractional (Ratio Integer), _CONSTM_ RealFrac properFraction (Ratio Integer), _CONSTM_ RealFrac truncate (Ratio Integer), _CONSTM_ RealFrac round (Ratio Integer), _CONSTM_ RealFrac ceiling (Ratio Integer), _CONSTM_ RealFrac floor (Ratio Integer)] _N_
- properFraction = _A_ 2 _U_ 11 _N_ _S_ "LU(LL)" {_A_ 3 _U_ 112 _N_ _N_ _N_ _N_} _N_ _N_,
- truncate = _A_ 1 _U_ 22 _N_ _N_ _F_ _IF_ARGS_ 1 1 X 3 _/\_ u0 -> \ (u1 :: {{Integral u0}}) -> _APP_ _TYAPP_ _TYAPP_ _WRKR_ _ORIG_ PreludeCore _truncate { (Ratio Integer) } { u0 } [ _CONSTM_ RealFrac properFraction (Ratio Integer), u1 ] _N_,
- round = _A_ 1 _U_ 22 _N_ _N_ _N_ _N_,
- ceiling = _A_ 1 _U_ 22 _N_ _N_ _N_ _N_,
- floor = _A_ 1 _U_ 22 _N_ _N_ _N_ _N_ #-}
+ properFraction = { _A_ 2 _U_ 11 _N_ _S_ "LU(U(PPP)U(PPP))" {_A_ 5 _U_ 12222 _N_ _N_ _N_ _N_} _N_ _SPECIALISE_ [ Int ] 1 { _A_ 1 _U_ 1 _N_ _S_ "U(U(PPP)U(PPP))" {_A_ 4 _U_ 2222 _N_ _N_ _N_ _N_} _N_ _N_ }, [ Integer ] 1 { _A_ 1 _U_ 1 _N_ _S_ "U(U(PPP)U(PPP))" {_A_ 4 _U_ 2222 _N_ _N_ _N_ _N_} _N_ _N_ } },
+ truncate = { _A_ 2 _U_ 11 _N_ _N_ _N_ _SPECIALISE_ [ Int ] 1 { _A_ 1 _U_ 1 _N_ _S_ "U(U(PPP)U(PPP))" {_A_ 4 _U_ 2222 _N_ _N_ _F_ _IF_ARGS_ 0 4 XXXX 7 \ (u0 :: Int#) (u1 :: Int#) (u2 :: ByteArray#) (u3 :: Integer) -> case _APP_ _WRKR_ _SPEC_ _CONSTM_ RealFrac properFraction (Ratio Integer) [ (Int) ] [ u0, u1, u2, u3 ] of { _ALG_ _TUP_2 (u4 :: Int) (u5 :: Ratio Integer) -> u4; _NO_DEFLT_ } _N_} _F_ _IF_ARGS_ 0 1 X 4 \ (u0 :: Ratio Integer) -> case _APP_ _SPEC_ _CONSTM_ RealFrac properFraction (Ratio Integer) [ (Int) ] [ u0 ] of { _ALG_ _TUP_2 (u1 :: Int) (u2 :: Ratio Integer) -> u1; _NO_DEFLT_ } _N_ }, [ Integer ] 1 { _A_ 1 _U_ 1 _N_ _S_ "U(U(PPP)U(PPP))" {_A_ 4 _U_ 2222 _N_ _N_ _F_ _IF_ARGS_ 0 4 XXXX 7 \ (u0 :: Int#) (u1 :: Int#) (u2 :: ByteArray#) (u3 :: Integer) -> case _APP_ _WRKR_ _SPEC_ _CONSTM_ RealFrac properFraction (Ratio Integer) [ (Integer) ] [ u0, u1, u2, u3 ] of { _ALG_ _TUP_2 (u4 :: Integer) (u5 :: Ratio Integer) -> u4; _NO_DEFLT_ } _N_} _F_ _IF_ARGS_ 0 1 X 4 \ (u0 :: Ratio Integer) -> case _APP_ _SPEC_ _CONSTM_ RealFrac properFraction (Ratio Integer) [ (Integer) ] [ u0 ] of { _ALG_ _TUP_2 (u1 :: Integer) (u2 :: Ratio Integer) -> u1; _NO_DEFLT_ } _N_ } },
+ round = { _A_ 1 _U_ 21 _N_ _N_ _N_ _SPECIALISE_ [ Int ] 1 { _A_ 1 _U_ 1 _N_ _S_ "U(U(PPP)U(PPP))" {_A_ 4 _U_ 2222 _N_ _N_ _N_ _N_} _N_ _N_ }, [ Integer ] 1 { _A_ 1 _U_ 1 _N_ _S_ "U(U(PPP)U(PPP))" {_A_ 4 _U_ 2222 _N_ _N_ _N_ _N_} _N_ _N_ } },
+ ceiling = { _A_ 1 _U_ 21 _N_ _N_ _N_ _SPECIALISE_ [ Int ] 1 { _A_ 1 _U_ 1 _N_ _S_ "U(U(PPP)U(PPP))" {_A_ 4 _U_ 2222 _N_ _N_ _N_ _N_} _N_ _N_ }, [ Integer ] 1 { _A_ 1 _U_ 1 _N_ _S_ "U(U(PPP)U(PPP))" {_A_ 4 _U_ 2222 _N_ _N_ _N_ _N_} _N_ _N_ } },
+ floor = { _A_ 1 _U_ 21 _N_ _N_ _N_ _SPECIALISE_ [ Int ] 1 { _A_ 1 _U_ 1 _N_ _S_ "U(U(PPP)U(PPP))" {_A_ 4 _U_ 2222 _N_ _N_ _N_ _N_} _N_ _N_ }, [ Integer ] 1 { _A_ 1 _U_ 1 _N_ _S_ "U(U(PPP)U(PPP))" {_A_ 4 _U_ 2222 _N_ _N_ _N_ _N_} _N_ _N_ } } #-}
+instance Text ((Int, Int), (Int, Int))
+ {-# GHC_PRAGMA _M_ PreludeBuiltin {-dfun-} _A_ 0 _N_ _N_ _N_ _F_ _IF_ARGS_ 0 0 X 5 _!_ _TUP_4 [(Int -> [Char] -> [(((Int, Int), (Int, Int)), [Char])]), (Int -> ((Int, Int), (Int, Int)) -> [Char] -> [Char]), ([Char] -> [([((Int, Int), (Int, Int))], [Char])]), ([((Int, Int), (Int, Int))] -> [Char] -> [Char])] [_CONSTM_ Text readsPrec (((Int, Int), (Int, Int))), _CONSTM_ Text showsPrec (((Int, Int), (Int, Int))), _CONSTM_ Text readList (((Int, Int), (Int, Int))), _CONSTM_ Text showList (((Int, Int), (Int, Int)))] _N_
+ readsPrec = { _A_ 1 _U_ 02 _N_ _S_ "A" {_A_ 0 _U_ 2 _N_ _N_ _N_ _N_} _N_ _N_ },
+ showsPrec = { _A_ 3 _U_ 012 _N_ _S_ "AU(LL)L" {_A_ 3 _U_ 112 _N_ _N_ _N_ _N_} _N_ _N_ },
+ readList = { _A_ 0 _U_ 2 _N_ _N_ _N_ _N_ },
+ showList = { _A_ 1 _U_ 12 _N_ _N_ _N_ _N_ } #-}
instance Text ()
{-# GHC_PRAGMA _M_ PreludeBuiltin {-dfun-} _A_ 0 _N_ _N_ _N_ _F_ _IF_ARGS_ 0 0 X 5 _!_ _TUP_4 [(Int -> [Char] -> [((), [Char])]), (Int -> () -> [Char] -> [Char]), ([Char] -> [([()], [Char])]), ([()] -> [Char] -> [Char])] [_CONSTM_ Text readsPrec (()), _CONSTM_ Text showsPrec (()), _CONSTM_ Text readList (()), _CONSTM_ Text showList (())] _N_
- readsPrec = _A_ 1 _U_ 02 _N_ _S_ "A" {_A_ 0 _U_ 2 _N_ _N_ _N_ _N_} _N_ _N_,
- showsPrec = _A_ 3 _U_ 012 _N_ _S_ "AEL" {_A_ 2 _U_ 12 _N_ _N_ _F_ _IF_ARGS_ 0 2 CX 4 \ (u0 :: ()) (u1 :: [Char]) -> case u0 of { _ALG_ _TUP_0 -> _APP_ _TYAPP_ _ORIG_ PreludeList (++) { Char } [ _NOREP_S_ "()", u1 ]; _NO_DEFLT_ } _N_} _F_ _IF_ARGS_ 0 3 XCX 4 \ (u0 :: Int) (u1 :: ()) (u2 :: [Char]) -> case u1 of { _ALG_ _TUP_0 -> _APP_ _TYAPP_ _ORIG_ PreludeList (++) { Char } [ _NOREP_S_ "()", u2 ]; _NO_DEFLT_ } _N_,
- readList = _A_ 0 _U_ 2 _N_ _N_ _N_ _N_,
- showList = _A_ 0 _U_ 12 _N_ _N_ _N_ _N_ #-}
+ readsPrec = { _A_ 1 _U_ 02 _N_ _S_ "A" {_A_ 0 _U_ 2 _N_ _N_ _N_ _N_} _N_ _N_ },
+ showsPrec = { _A_ 3 _U_ 012 _N_ _S_ "AEL" {_A_ 2 _U_ 12 _N_ _N_ _F_ _IF_ARGS_ 0 2 CX 4 \ (u0 :: ()) (u1 :: [Char]) -> case u0 of { _ALG_ _TUP_0 -> _APP_ _TYAPP_ _ORIG_ PreludeList (++) { Char } [ _NOREP_S_ "()", u1 ]; _NO_DEFLT_ } _N_} _F_ _IF_ARGS_ 0 3 XCX 4 \ (u0 :: Int) (u1 :: ()) (u2 :: [Char]) -> case u1 of { _ALG_ _TUP_0 -> _APP_ _TYAPP_ _ORIG_ PreludeList (++) { Char } [ _NOREP_S_ "()", u2 ]; _NO_DEFLT_ } _N_ },
+ readList = { _A_ 0 _U_ 2 _N_ _N_ _N_ _N_ },
+ showList = { _A_ 1 _U_ 12 _N_ _N_ _N_ _N_ } #-}
instance (Text a, Text b) => Text (a, b)
{-# GHC_PRAGMA _M_ PreludeBuiltin {-dfun-} _A_ 2 _U_ 22 _N_ _N_ _N_ _N_ #-}
instance (Text a, Text b, Text c) => Text (a, b, c)
{-# GHC_PRAGMA _M_ PreludeBuiltin {-dfun-} _A_ 5 _U_ 22222 _N_ _N_ _N_ _N_ #-}
instance Text (Int, Int)
{-# GHC_PRAGMA _M_ PreludeBuiltin {-dfun-} _A_ 0 _N_ _N_ _N_ _F_ _IF_ARGS_ 0 0 X 5 _!_ _TUP_4 [(Int -> [Char] -> [((Int, Int), [Char])]), (Int -> (Int, Int) -> [Char] -> [Char]), ([Char] -> [([(Int, Int)], [Char])]), ([(Int, Int)] -> [Char] -> [Char])] [_CONSTM_ Text readsPrec ((Int, Int)), _CONSTM_ Text showsPrec ((Int, Int)), _CONSTM_ Text readList ((Int, Int)), _CONSTM_ Text showList ((Int, Int))] _N_
- readsPrec = _A_ 1 _U_ 02 _N_ _S_ "A" {_A_ 0 _U_ 2 _N_ _N_ _N_ _N_} _N_ _N_,
- showsPrec = _A_ 3 _U_ 012 _N_ _S_ "AU(LL)L" {_A_ 3 _U_ 112 _N_ _N_ _N_ _N_} _N_ _N_,
- readList = _A_ 0 _U_ 2 _N_ _N_ _N_ _N_,
- showList = _A_ 0 _U_ 12 _N_ _N_ _N_ _N_ #-}
+ readsPrec = { _A_ 1 _U_ 02 _N_ _S_ "A" {_A_ 0 _U_ 2 _N_ _N_ _N_ _N_} _N_ _N_ },
+ showsPrec = { _A_ 3 _U_ 012 _N_ _S_ "AU(LL)L" {_A_ 3 _U_ 112 _N_ _N_ _N_ _N_} _N_ _N_ },
+ readList = { _A_ 0 _U_ 2 _N_ _N_ _N_ _N_ },
+ showList = { _A_ 1 _U_ 12 _N_ _N_ _N_ _N_ } #-}
+instance Text (Int, Int, Int)
+ {-# GHC_PRAGMA _M_ PreludeBuiltin {-dfun-} _A_ 0 _N_ _N_ _N_ _F_ _IF_ARGS_ 0 0 X 5 _!_ _TUP_4 [(Int -> [Char] -> [((Int, Int, Int), [Char])]), (Int -> (Int, Int, Int) -> [Char] -> [Char]), ([Char] -> [([(Int, Int, Int)], [Char])]), ([(Int, Int, Int)] -> [Char] -> [Char])] [_CONSTM_ Text readsPrec ((Int, Int, Int)), _CONSTM_ Text showsPrec ((Int, Int, Int)), _CONSTM_ Text readList ((Int, Int, Int)), _CONSTM_ Text showList ((Int, Int, Int))] _N_
+ readsPrec = { _A_ 1 _U_ 02 _N_ _S_ "A" {_A_ 0 _U_ 2 _N_ _N_ _N_ _N_} _N_ _N_ },
+ showsPrec = { _A_ 3 _U_ 012 _N_ _S_ "AU(LLL)L" {_A_ 4 _U_ 1112 _N_ _N_ _N_ _N_} _N_ _N_ },
+ readList = { _A_ 0 _U_ 2 _N_ _N_ _N_ _N_ },
+ showList = { _A_ 1 _U_ 12 _N_ _N_ _N_ _N_ } #-}
instance Text (Integer, Integer)
{-# GHC_PRAGMA _M_ PreludeBuiltin {-dfun-} _A_ 0 _N_ _N_ _N_ _F_ _IF_ARGS_ 0 0 X 5 _!_ _TUP_4 [(Int -> [Char] -> [((Integer, Integer), [Char])]), (Int -> (Integer, Integer) -> [Char] -> [Char]), ([Char] -> [([(Integer, Integer)], [Char])]), ([(Integer, Integer)] -> [Char] -> [Char])] [_CONSTM_ Text readsPrec ((Integer, Integer)), _CONSTM_ Text showsPrec ((Integer, Integer)), _CONSTM_ Text readList ((Integer, Integer)), _CONSTM_ Text showList ((Integer, Integer))] _N_
- readsPrec = _A_ 1 _U_ 02 _N_ _S_ "A" {_A_ 0 _U_ 2 _N_ _N_ _N_ _N_} _N_ _N_,
- showsPrec = _A_ 3 _U_ 012 _N_ _S_ "AU(LL)L" {_A_ 3 _U_ 112 _N_ _N_ _N_ _N_} _N_ _N_,
- readList = _A_ 0 _U_ 2 _N_ _N_ _N_ _N_,
- showList = _A_ 0 _U_ 12 _N_ _N_ _N_ _N_ #-}
+ readsPrec = { _A_ 1 _U_ 02 _N_ _S_ "A" {_A_ 0 _U_ 2 _N_ _N_ _N_ _N_} _N_ _N_ },
+ showsPrec = { _A_ 3 _U_ 012 _N_ _S_ "AU(LL)L" {_A_ 3 _U_ 112 _N_ _N_ _N_ _N_} _N_ _N_ },
+ readList = { _A_ 0 _U_ 2 _N_ _N_ _N_ _N_ },
+ showList = { _A_ 1 _U_ 12 _N_ _N_ _N_ _N_ } #-}
instance Text (a -> b)
{-# GHC_PRAGMA _M_ PreludeCore {-dfun-} _A_ 0 _N_ _N_ _N_ _N_ _N_ #-}
+instance Text (Array (Int, Int) Double)
+ {-# GHC_PRAGMA _M_ PreludeArray {-dfun-} _A_ 0 _N_ _N_ _N_ _F_ _IF_ARGS_ 0 0 X 5 _!_ _TUP_4 [(Int -> [Char] -> [(Array (Int, Int) Double, [Char])]), (Int -> Array (Int, Int) Double -> [Char] -> [Char]), ([Char] -> [([Array (Int, Int) Double], [Char])]), ([Array (Int, Int) Double] -> [Char] -> [Char])] [_CONSTM_ Text readsPrec (Array (Int, Int) Double), _CONSTM_ Text showsPrec (Array (Int, Int) Double), _CONSTM_ Text readList (Array (Int, Int) Double), _CONSTM_ Text showList (Array (Int, Int) Double)] _N_
+ readsPrec = { _A_ 1 _U_ 12 _N_ _S_ "U(P)" {_A_ 1 _U_ 22 _N_ _N_ _N_ _N_} _N_ _N_ },
+ showsPrec = { _A_ 2 _U_ 122 _N_ _N_ _N_ _N_ },
+ readList = { _A_ 0 _U_ 2 _N_ _N_ _N_ _N_ },
+ showList = { _A_ 0 _U_ 12 _N_ _N_ _N_ _N_ } #-}
instance (Ix a, Text a, Text b) => Text (Array a b)
{-# GHC_PRAGMA _M_ PreludeArray {-dfun-} _A_ 3 _U_ 222 _N_ _N_ _N_ _N_ #-}
+instance Text (Array Int Double)
+ {-# GHC_PRAGMA _M_ PreludeArray {-dfun-} _A_ 0 _N_ _N_ _N_ _F_ _IF_ARGS_ 0 0 X 5 _!_ _TUP_4 [(Int -> [Char] -> [(Array Int Double, [Char])]), (Int -> Array Int Double -> [Char] -> [Char]), ([Char] -> [([Array Int Double], [Char])]), ([Array Int Double] -> [Char] -> [Char])] [_CONSTM_ Text readsPrec (Array Int Double), _CONSTM_ Text showsPrec (Array Int Double), _CONSTM_ Text readList (Array Int Double), _CONSTM_ Text showList (Array Int Double)] _N_
+ readsPrec = { _A_ 1 _U_ 12 _N_ _S_ "U(P)" {_A_ 1 _U_ 22 _N_ _N_ _N_ _N_} _N_ _N_ },
+ showsPrec = { _A_ 2 _U_ 122 _N_ _N_ _N_ _N_ },
+ readList = { _A_ 0 _U_ 2 _N_ _N_ _N_ _N_ },
+ showList = { _A_ 0 _U_ 12 _N_ _N_ _N_ _N_ } #-}
instance (Text a, Text b) => Text (Assoc a b)
{-# GHC_PRAGMA _M_ PreludeArray {-dfun-} _A_ 2 _U_ 22 _N_ _N_ _N_ _N_ #-}
instance Text Bool
{-# GHC_PRAGMA _M_ PreludeCore {-dfun-} _A_ 0 _N_ _N_ _N_ _F_ _IF_ARGS_ 0 0 X 5 _!_ _TUP_4 [(Int -> [Char] -> [(Bool, [Char])]), (Int -> Bool -> [Char] -> [Char]), ([Char] -> [([Bool], [Char])]), ([Bool] -> [Char] -> [Char])] [_CONSTM_ Text readsPrec (Bool), _CONSTM_ Text showsPrec (Bool), _CONSTM_ Text readList (Bool), _CONSTM_ Text showList (Bool)] _N_
- readsPrec = _A_ 2 _U_ 02 _N_ _S_ "AL" {_A_ 1 _U_ 2 _N_ _N_ _N_ _N_} _N_ _N_,
- showsPrec = _A_ 3 _U_ 012 _N_ _S_ "AEL" {_A_ 2 _U_ 12 _N_ _N_ _N_ _N_} _N_ _N_,
- readList = _A_ 0 _U_ 2 _N_ _N_ _N_ _N_,
- showList = _A_ 0 _U_ 12 _N_ _N_ _N_ _N_ #-}
+ readsPrec = { _A_ 2 _U_ 02 _N_ _S_ "AL" {_A_ 1 _U_ 2 _N_ _N_ _N_ _N_} _N_ _N_ },
+ showsPrec = { _A_ 3 _U_ 012 _N_ _S_ "AEL" {_A_ 2 _U_ 12 _N_ _N_ _N_ _N_} _N_ _N_ },
+ readList = { _A_ 0 _U_ 2 _N_ _N_ _N_ _N_ },
+ showList = { _A_ 1 _U_ 12 _N_ _N_ _F_ _IF_ARGS_ 0 1 X 3 \ (u0 :: [Bool]) -> _APP_ _TYAPP_ _ORIG_ PreludeCore _showList { Bool } [ _WRKR_ _CONSTM_ Text showsPrec (Bool), u0 ] _N_ } #-}
instance Text Char
{-# GHC_PRAGMA _M_ PreludeCore {-dfun-} _A_ 0 _N_ _N_ _N_ _F_ _IF_ARGS_ 0 0 X 5 _!_ _TUP_4 [(Int -> [Char] -> [(Char, [Char])]), (Int -> Char -> [Char] -> [Char]), ([Char] -> [([Char], [Char])]), ([Char] -> [Char] -> [Char])] [_CONSTM_ Text readsPrec (Char), _CONSTM_ Text showsPrec (Char), _CONSTM_ Text readList (Char), _CONSTM_ Text showList (Char)] _N_
- readsPrec = _A_ 1 _U_ 02 _N_ _S_ "A" {_A_ 0 _U_ 2 _N_ _N_ _N_ _N_} _N_ _N_,
- showsPrec = _A_ 3 _U_ 012 _N_ _S_ "AU(P)L" {_A_ 2 _U_ 22 _N_ _N_ _N_ _N_} _N_ _N_,
- readList = _A_ 0 _U_ 2 _N_ _N_ _N_ _N_,
- showList = _A_ 1 _U_ 22 _N_ _N_ _N_ _N_ #-}
+ readsPrec = { _A_ 1 _U_ 02 _N_ _S_ "A" {_A_ 0 _U_ 2 _N_ _N_ _N_ _N_} _N_ _N_ },
+ showsPrec = { _A_ 3 _U_ 012 _N_ _S_ "AU(P)L" {_A_ 2 _U_ 22 _N_ _N_ _N_ _N_} _N_ _N_ },
+ readList = { _A_ 0 _U_ 2 _N_ _N_ _N_ _N_ },
+ showList = { _A_ 1 _U_ 22 _N_ _N_ _N_ _N_ } #-}
instance Text a => Text (Complex a)
{-# GHC_PRAGMA _M_ PreludeComplex {-dfun-} _A_ 1 _U_ 2 _N_ _N_ _N_ _N_ #-}
+instance Text (Complex Double)
+ {-# GHC_PRAGMA _M_ PreludeComplex {-dfun-} _A_ 0 _N_ _N_ _N_ _F_ _IF_ARGS_ 0 0 X 5 _!_ _TUP_4 [(Int -> [Char] -> [(Complex Double, [Char])]), (Int -> Complex Double -> [Char] -> [Char]), ([Char] -> [([Complex Double], [Char])]), ([Complex Double] -> [Char] -> [Char])] [_CONSTM_ Text readsPrec (Complex Double), _CONSTM_ Text showsPrec (Complex Double), _CONSTM_ Text readList (Complex Double), _CONSTM_ Text showList (Complex Double)] _N_
+ readsPrec = { _A_ 1 _U_ 12 _N_ _S_ "U(P)" {_A_ 1 _U_ 22 _N_ _N_ _N_ _N_} _N_ _N_ },
+ showsPrec = { _A_ 2 _U_ 112 _N_ _S_ "LU(LL)" {_A_ 3 _U_ 1222 _N_ _N_ _N_ _N_} _N_ _N_ },
+ readList = { _A_ 0 _U_ 2 _N_ _N_ _N_ _N_ },
+ showList = { _A_ 1 _U_ 12 _N_ _N_ _N_ _N_ } #-}
instance Text Double
{-# GHC_PRAGMA _M_ PreludeCore {-dfun-} _A_ 0 _N_ _N_ _N_ _F_ _IF_ARGS_ 0 0 X 5 _!_ _TUP_4 [(Int -> [Char] -> [(Double, [Char])]), (Int -> Double -> [Char] -> [Char]), ([Char] -> [([Double], [Char])]), ([Double] -> [Char] -> [Char])] [_CONSTM_ Text readsPrec (Double), _CONSTM_ Text showsPrec (Double), _CONSTM_ Text readList (Double), _CONSTM_ Text showList (Double)] _N_
- readsPrec = _A_ 2 _U_ 02 _N_ _S_ "AL" {_A_ 1 _U_ 2 _N_ _N_ _F_ _IF_ARGS_ 0 1 X 3 \ (u0 :: [Char]) -> _APP_ _SPEC_ _ORIG_ PreludeText readSigned [ (Double) ] [ _SPEC_ _ORIG_ PreludeText readFloat [ (Double) ], u0 ] _N_} _F_ _IF_ARGS_ 0 2 XX 3 \ (u0 :: Int) (u1 :: [Char]) -> _APP_ _SPEC_ _ORIG_ PreludeText readSigned [ (Double) ] [ _SPEC_ _ORIG_ PreludeText readFloat [ (Double) ], u1 ] _N_,
- showsPrec = _A_ 2 _U_ 212 _N_ _S_ "LU(P)" {_A_ 2 _U_ 222 _N_ _N_ _F_ _IF_ARGS_ 0 2 XX 4 \ (u0 :: Int) (u1 :: Double#) -> _APP_ _WRKR_ _SPEC_ _ORIG_ PreludeText showSigned [ (Double) ] [ _SPEC_ _ORIG_ PreludeText showFloat [ (Double) ], u0, u1 ] _N_} _F_ _IF_ARGS_ 0 2 XC 5 \ (u0 :: Int) (u1 :: Double) -> case u1 of { _ALG_ D# (u2 :: Double#) -> _APP_ _WRKR_ _SPEC_ _ORIG_ PreludeText showSigned [ (Double) ] [ _SPEC_ _ORIG_ PreludeText showFloat [ (Double) ], u0, u2 ]; _NO_DEFLT_ } _N_,
- readList = _A_ 0 _U_ 2 _N_ _N_ _N_ _N_,
- showList = _A_ 0 _U_ 12 _N_ _N_ _N_ _N_ #-}
+ readsPrec = { _A_ 2 _U_ 02 _N_ _S_ "AL" {_A_ 1 _U_ 2 _N_ _N_ _F_ _IF_ARGS_ 0 1 X 3 \ (u0 :: [Char]) -> _APP_ _SPEC_ _ORIG_ PreludeText readSigned [ (Double) ] [ _SPEC_ _ORIG_ PreludeText readFloat [ (Double) ], u0 ] _N_} _F_ _IF_ARGS_ 0 2 XX 3 \ (u0 :: Int) (u1 :: [Char]) -> _APP_ _SPEC_ _ORIG_ PreludeText readSigned [ (Double) ] [ _SPEC_ _ORIG_ PreludeText readFloat [ (Double) ], u1 ] _N_ },
+ showsPrec = { _A_ 2 _U_ 212 _N_ _S_ "LU(P)" {_A_ 2 _U_ 222 _N_ _N_ _F_ _IF_ARGS_ 0 2 XX 4 \ (u0 :: Int) (u1 :: Double#) -> _APP_ _WRKR_ _SPEC_ _ORIG_ PreludeText showSigned [ (Double) ] [ _SPEC_ _ORIG_ PreludeText showFloat [ (Double) ], u0, u1 ] _N_} _F_ _IF_ARGS_ 0 2 XC 5 \ (u0 :: Int) (u1 :: Double) -> case u1 of { _ALG_ D# (u2 :: Double#) -> _APP_ _WRKR_ _SPEC_ _ORIG_ PreludeText showSigned [ (Double) ] [ _SPEC_ _ORIG_ PreludeText showFloat [ (Double) ], u0, u2 ]; _NO_DEFLT_ } _N_ },
+ readList = { _A_ 0 _U_ 2 _N_ _N_ _N_ _N_ },
+ showList = { _A_ 1 _U_ 12 _N_ _N_ _N_ _N_ } #-}
instance Text Float
{-# GHC_PRAGMA _M_ PreludeCore {-dfun-} _A_ 0 _N_ _N_ _N_ _F_ _IF_ARGS_ 0 0 X 5 _!_ _TUP_4 [(Int -> [Char] -> [(Float, [Char])]), (Int -> Float -> [Char] -> [Char]), ([Char] -> [([Float], [Char])]), ([Float] -> [Char] -> [Char])] [_CONSTM_ Text readsPrec (Float), _CONSTM_ Text showsPrec (Float), _CONSTM_ Text readList (Float), _CONSTM_ Text showList (Float)] _N_
- readsPrec = _A_ 2 _U_ 02 _N_ _S_ "AL" {_A_ 1 _U_ 2 _N_ _N_ _N_ _N_} _N_ _N_,
- showsPrec = _A_ 1 _U_ 222 _N_ _N_ _N_ _N_,
- readList = _A_ 0 _U_ 2 _N_ _N_ _N_ _N_,
- showList = _A_ 0 _U_ 12 _N_ _N_ _N_ _N_ #-}
+ readsPrec = { _A_ 2 _U_ 02 _N_ _S_ "AL" {_A_ 1 _U_ 2 _N_ _N_ _N_ _N_} _N_ _N_ },
+ showsPrec = { _A_ 1 _U_ 222 _N_ _N_ _N_ _N_ },
+ readList = { _A_ 0 _U_ 2 _N_ _N_ _N_ _N_ },
+ showList = { _A_ 0 _U_ 12 _N_ _N_ _N_ _N_ } #-}
instance Text Int
{-# GHC_PRAGMA _M_ PreludeCore {-dfun-} _A_ 0 _N_ _N_ _N_ _F_ _IF_ARGS_ 0 0 X 5 _!_ _TUP_4 [(Int -> [Char] -> [(Int, [Char])]), (Int -> Int -> [Char] -> [Char]), ([Char] -> [([Int], [Char])]), ([Int] -> [Char] -> [Char])] [_CONSTM_ Text readsPrec (Int), _CONSTM_ Text showsPrec (Int), _CONSTM_ Text readList (Int), _CONSTM_ Text showList (Int)] _N_
- readsPrec = _A_ 2 _U_ 02 _N_ _S_ "AL" {_A_ 1 _U_ 2 _N_ _N_ _F_ _IF_ARGS_ 0 1 X 3 \ (u0 :: [Char]) -> _APP_ _SPEC_ _ORIG_ PreludeText readSigned [ (Int) ] [ _SPEC_ _ORIG_ PreludeText readDec [ (Int) ], u0 ] _N_} _F_ _IF_ARGS_ 0 2 XX 3 \ (u0 :: Int) (u1 :: [Char]) -> _APP_ _SPEC_ _ORIG_ PreludeText readSigned [ (Int) ] [ _SPEC_ _ORIG_ PreludeText readDec [ (Int) ], u1 ] _N_,
- showsPrec = _A_ 3 _U_ 212 _N_ _S_ "LU(P)L" {_A_ 3 _U_ 222 _N_ _N_ _N_ _N_} _N_ _N_,
- readList = _A_ 0 _U_ 2 _N_ _N_ _N_ _N_,
- showList = _A_ 0 _U_ 12 _N_ _N_ _N_ _N_ #-}
+ readsPrec = { _A_ 2 _U_ 02 _N_ _S_ "AL" {_A_ 1 _U_ 2 _N_ _N_ _F_ _IF_ARGS_ 0 1 X 3 \ (u0 :: [Char]) -> _APP_ _SPEC_ _ORIG_ PreludeText readSigned [ (Int) ] [ _SPEC_ _ORIG_ PreludeText readDec [ (Int) ], u0 ] _N_} _F_ _IF_ARGS_ 0 2 XX 3 \ (u0 :: Int) (u1 :: [Char]) -> _APP_ _SPEC_ _ORIG_ PreludeText readSigned [ (Int) ] [ _SPEC_ _ORIG_ PreludeText readDec [ (Int) ], u1 ] _N_ },
+ showsPrec = { _A_ 3 _U_ 212 _N_ _S_ "LU(P)L" {_A_ 3 _U_ 222 _N_ _N_ _N_ _N_} _N_ _N_ },
+ readList = { _A_ 0 _U_ 2 _N_ _N_ _N_ _N_ },
+ showList = { _A_ 1 _U_ 12 _N_ _N_ _N_ _N_ } #-}
instance Text Integer
{-# GHC_PRAGMA _M_ PreludeCore {-dfun-} _A_ 0 _N_ _N_ _N_ _F_ _IF_ARGS_ 0 0 X 5 _!_ _TUP_4 [(Int -> [Char] -> [(Integer, [Char])]), (Int -> Integer -> [Char] -> [Char]), ([Char] -> [([Integer], [Char])]), ([Integer] -> [Char] -> [Char])] [_CONSTM_ Text readsPrec (Integer), _CONSTM_ Text showsPrec (Integer), _CONSTM_ Text readList (Integer), _CONSTM_ Text showList (Integer)] _N_
- readsPrec = _A_ 2 _U_ 02 _N_ _S_ "AL" {_A_ 1 _U_ 2 _N_ _N_ _F_ _IF_ARGS_ 0 1 X 3 \ (u0 :: [Char]) -> _APP_ _SPEC_ _ORIG_ PreludeText readSigned [ (Integer) ] [ _SPEC_ _ORIG_ PreludeText readDec [ (Integer) ], u0 ] _N_} _F_ _IF_ARGS_ 0 2 XX 3 \ (u0 :: Int) (u1 :: [Char]) -> _APP_ _SPEC_ _ORIG_ PreludeText readSigned [ (Integer) ] [ _SPEC_ _ORIG_ PreludeText readDec [ (Integer) ], u1 ] _N_,
- showsPrec = _A_ 3 _U_ 212 _N_ _S_ "LU(PPP)L" {_A_ 5 _U_ 22222 _N_ _N_ _N_ _N_} _N_ _N_,
- readList = _A_ 0 _U_ 2 _N_ _N_ _N_ _N_,
- showList = _A_ 0 _U_ 12 _N_ _N_ _N_ _N_ #-}
+ readsPrec = { _A_ 2 _U_ 02 _N_ _S_ "AL" {_A_ 1 _U_ 2 _N_ _N_ _F_ _IF_ARGS_ 0 1 X 3 \ (u0 :: [Char]) -> _APP_ _SPEC_ _ORIG_ PreludeText readSigned [ (Integer) ] [ _SPEC_ _ORIG_ PreludeText readDec [ (Integer) ], u0 ] _N_} _F_ _IF_ARGS_ 0 2 XX 3 \ (u0 :: Int) (u1 :: [Char]) -> _APP_ _SPEC_ _ORIG_ PreludeText readSigned [ (Integer) ] [ _SPEC_ _ORIG_ PreludeText readDec [ (Integer) ], u1 ] _N_ },
+ showsPrec = { _A_ 3 _U_ 212 _N_ _S_ "LU(PPP)L" {_A_ 5 _U_ 22222 _N_ _N_ _N_ _N_} _N_ _N_ },
+ readList = { _A_ 0 _U_ 2 _N_ _N_ _N_ _N_ },
+ showList = { _A_ 1 _U_ 12 _N_ _N_ _N_ _N_ } #-}
instance Integral a => Text (Ratio a)
{-# GHC_PRAGMA _M_ PreludeRatio {-dfun-} _A_ 1 _U_ 2 _N_ _N_ _N_ _N_ #-}
instance Text (Ratio Integer)
{-# GHC_PRAGMA _M_ PreludeRatio {-dfun-} _A_ 0 _N_ _N_ _N_ _F_ _IF_ARGS_ 0 0 X 5 _!_ _TUP_4 [(Int -> [Char] -> [(Ratio Integer, [Char])]), (Int -> Ratio Integer -> [Char] -> [Char]), ([Char] -> [([Ratio Integer], [Char])]), ([Ratio Integer] -> [Char] -> [Char])] [_CONSTM_ Text readsPrec (Ratio Integer), _CONSTM_ Text showsPrec (Ratio Integer), _CONSTM_ Text readList (Ratio Integer), _CONSTM_ Text showList (Ratio Integer)] _N_
- readsPrec = _A_ 1 _U_ 12 _N_ _S_ "U(P)" {_A_ 1 _U_ 22 _N_ _N_ _N_ _N_} _N_ _N_,
- showsPrec = _A_ 2 _U_ 112 _N_ _S_ "LU(LL)" {_A_ 3 _U_ 1222 _N_ _N_ _N_ _N_} _N_ _N_,
- readList = _A_ 0 _U_ 2 _N_ _N_ _N_ _N_,
- showList = _A_ 0 _U_ 12 _N_ _N_ _N_ _N_ #-}
+ readsPrec = { _A_ 1 _U_ 12 _N_ _S_ "U(P)" {_A_ 1 _U_ 22 _N_ _N_ _N_ _N_} _N_ _N_ },
+ showsPrec = { _A_ 2 _U_ 112 _N_ _S_ "LU(LL)" {_A_ 3 _U_ 1222 _N_ _N_ _N_ _N_} _N_ _N_ },
+ readList = { _A_ 0 _U_ 2 _N_ _N_ _N_ _N_ },
+ showList = { _A_ 1 _U_ 12 _N_ _N_ _N_ _N_ } #-}
instance Text a => Text [a]
{-# GHC_PRAGMA _M_ PreludeBuiltin {-dfun-} _A_ 1 _U_ 2 _N_ _N_ _N_ _N_ #-}
+instance Text [Bool]
+ {-# GHC_PRAGMA _M_ PreludeBuiltin {-dfun-} _A_ 0 _N_ _N_ _N_ _F_ _IF_ARGS_ 0 0 X 5 _!_ _TUP_4 [(Int -> [Char] -> [([Bool], [Char])]), (Int -> [Bool] -> [Char] -> [Char]), ([Char] -> [([[Bool]], [Char])]), ([[Bool]] -> [Char] -> [Char])] [_CONSTM_ Text readsPrec ([Bool]), _CONSTM_ Text showsPrec ([Bool]), _CONSTM_ Text readList ([Bool]), _CONSTM_ Text showList ([Bool])] _N_
+ readsPrec = { _A_ 1 _U_ 02 _N_ _S_ "A" {_A_ 0 _U_ 2 _N_ _N_ _F_ _IF_ARGS_ 0 0 X 1 _CONSTM_ Text readList (Bool) _N_} _F_ _IF_ARGS_ 0 1 X 1 \ (u0 :: Int) -> _CONSTM_ Text readList (Bool) _N_ },
+ showsPrec = { _A_ 2 _U_ 012 _N_ _S_ "AS" {_A_ 1 _U_ 12 _N_ _N_ _F_ _IF_ARGS_ 0 1 X 3 \ (u0 :: [Bool]) -> _APP_ _TYAPP_ _ORIG_ PreludeCore _showList { Bool } [ _WRKR_ _CONSTM_ Text showsPrec (Bool), u0 ] _N_} _F_ _IF_ARGS_ 0 2 XX 3 \ (u0 :: Int) (u1 :: [Bool]) -> _APP_ _TYAPP_ _ORIG_ PreludeCore _showList { Bool } [ _WRKR_ _CONSTM_ Text showsPrec (Bool), u1 ] _N_ },
+ readList = { _A_ 0 _U_ 2 _N_ _N_ _N_ _N_ },
+ showList = { _A_ 1 _U_ 12 _N_ _N_ _N_ _N_ } #-}
instance Text [Char]
{-# GHC_PRAGMA _M_ PreludeBuiltin {-dfun-} _A_ 0 _N_ _N_ _N_ _F_ _IF_ARGS_ 0 0 X 5 _!_ _TUP_4 [(Int -> [Char] -> [([Char], [Char])]), (Int -> [Char] -> [Char] -> [Char]), ([Char] -> [([[Char]], [Char])]), ([[Char]] -> [Char] -> [Char])] [_CONSTM_ Text readsPrec ([Char]), _CONSTM_ Text showsPrec ([Char]), _CONSTM_ Text readList ([Char]), _CONSTM_ Text showList ([Char])] _N_
- readsPrec = _A_ 1 _U_ 02 _N_ _S_ "A" {_A_ 0 _U_ 2 _N_ _N_ _F_ _IF_ARGS_ 0 0 X 1 _CONSTM_ Text readList (Char) _N_} _F_ _IF_ARGS_ 0 1 X 1 \ (u0 :: Int) -> _CONSTM_ Text readList (Char) _N_,
- showsPrec = _A_ 2 _U_ 022 _N_ _S_ "AL" {_A_ 1 _U_ 22 _N_ _N_ _F_ _IF_ARGS_ 0 0 X 1 _CONSTM_ Text showList (Char) _N_} _F_ _IF_ARGS_ 0 2 XX 2 \ (u0 :: Int) (u1 :: [Char]) -> _APP_ _CONSTM_ Text showList (Char) [ u1 ] _N_,
- readList = _A_ 0 _U_ 2 _N_ _N_ _N_ _N_,
- showList = _A_ 0 _U_ 12 _N_ _N_ _N_ _N_ #-}
+ readsPrec = { _A_ 1 _U_ 02 _N_ _S_ "A" {_A_ 0 _U_ 2 _N_ _N_ _F_ _IF_ARGS_ 0 0 X 1 _CONSTM_ Text readList (Char) _N_} _F_ _IF_ARGS_ 0 1 X 1 \ (u0 :: Int) -> _CONSTM_ Text readList (Char) _N_ },
+ showsPrec = { _A_ 2 _U_ 022 _N_ _S_ "AL" {_A_ 1 _U_ 22 _N_ _N_ _F_ _IF_ARGS_ 0 0 X 1 _CONSTM_ Text showList (Char) _N_} _F_ _IF_ARGS_ 0 2 XX 2 \ (u0 :: Int) (u1 :: [Char]) -> _APP_ _CONSTM_ Text showList (Char) [ u1 ] _N_ },
+ readList = { _A_ 0 _U_ 2 _N_ _N_ _N_ _N_ },
+ showList = { _A_ 1 _U_ 12 _N_ _N_ _F_ _IF_ARGS_ 0 1 X 3 \ (u0 :: [[Char]]) -> _APP_ _TYAPP_ _ORIG_ PreludeCore _showList { [Char] } [ _CONSTM_ Text showList (Char), u0 ] _N_ } #-}
+instance Text [Complex Double]
+ {-# GHC_PRAGMA _M_ PreludeBuiltin {-dfun-} _A_ 0 _N_ _N_ _N_ _F_ _IF_ARGS_ 0 0 X 5 _!_ _TUP_4 [(Int -> [Char] -> [([Complex Double], [Char])]), (Int -> [Complex Double] -> [Char] -> [Char]), ([Char] -> [([[Complex Double]], [Char])]), ([[Complex Double]] -> [Char] -> [Char])] [_CONSTM_ Text readsPrec ([Complex Double]), _CONSTM_ Text showsPrec ([Complex Double]), _CONSTM_ Text readList ([Complex Double]), _CONSTM_ Text showList ([Complex Double])] _N_
+ readsPrec = { _A_ 1 _U_ 02 _N_ _S_ "A" {_A_ 0 _U_ 2 _N_ _N_ _F_ _IF_ARGS_ 0 0 X 1 _CONSTM_ Text readList (Complex Double) _N_} _F_ _IF_ARGS_ 0 1 X 1 \ (u0 :: Int) -> _CONSTM_ Text readList (Complex Double) _N_ },
+ showsPrec = { _A_ 2 _U_ 022 _N_ _S_ "AL" {_A_ 1 _U_ 22 _N_ _N_ _F_ _IF_ARGS_ 0 0 X 1 _CONSTM_ Text showList (Complex Double) _N_} _F_ _IF_ARGS_ 0 2 XX 2 \ (u0 :: Int) (u1 :: [Complex Double]) -> _APP_ _CONSTM_ Text showList (Complex Double) [ u1 ] _N_ },
+ readList = { _A_ 0 _U_ 2 _N_ _N_ _N_ _N_ },
+ showList = { _A_ 1 _U_ 12 _N_ _N_ _F_ _IF_ARGS_ 0 1 X 3 \ (u0 :: [[Complex Double]]) -> _APP_ _TYAPP_ _ORIG_ PreludeCore _showList { [Complex Double] } [ _CONSTM_ Text showList (Complex Double), u0 ] _N_ } #-}
+instance Text [Double]
+ {-# GHC_PRAGMA _M_ PreludeBuiltin {-dfun-} _A_ 0 _N_ _N_ _N_ _F_ _IF_ARGS_ 0 0 X 5 _!_ _TUP_4 [(Int -> [Char] -> [([Double], [Char])]), (Int -> [Double] -> [Char] -> [Char]), ([Char] -> [([[Double]], [Char])]), ([[Double]] -> [Char] -> [Char])] [_CONSTM_ Text readsPrec ([Double]), _CONSTM_ Text showsPrec ([Double]), _CONSTM_ Text readList ([Double]), _CONSTM_ Text showList ([Double])] _N_
+ readsPrec = { _A_ 1 _U_ 02 _N_ _S_ "A" {_A_ 0 _U_ 2 _N_ _N_ _F_ _IF_ARGS_ 0 0 X 1 _CONSTM_ Text readList (Double) _N_} _F_ _IF_ARGS_ 0 1 X 1 \ (u0 :: Int) -> _CONSTM_ Text readList (Double) _N_ },
+ showsPrec = { _A_ 2 _U_ 022 _N_ _S_ "AL" {_A_ 1 _U_ 22 _N_ _N_ _F_ _IF_ARGS_ 0 0 X 1 _CONSTM_ Text showList (Double) _N_} _F_ _IF_ARGS_ 0 2 XX 2 \ (u0 :: Int) (u1 :: [Double]) -> _APP_ _CONSTM_ Text showList (Double) [ u1 ] _N_ },
+ readList = { _A_ 0 _U_ 2 _N_ _N_ _N_ _N_ },
+ showList = { _A_ 1 _U_ 12 _N_ _N_ _F_ _IF_ARGS_ 0 1 X 3 \ (u0 :: [[Double]]) -> _APP_ _TYAPP_ _ORIG_ PreludeCore _showList { [Double] } [ _CONSTM_ Text showList (Double), u0 ] _N_ } #-}
instance Text [Int]
{-# GHC_PRAGMA _M_ PreludeBuiltin {-dfun-} _A_ 0 _N_ _N_ _N_ _F_ _IF_ARGS_ 0 0 X 5 _!_ _TUP_4 [(Int -> [Char] -> [([Int], [Char])]), (Int -> [Int] -> [Char] -> [Char]), ([Char] -> [([[Int]], [Char])]), ([[Int]] -> [Char] -> [Char])] [_CONSTM_ Text readsPrec ([Int]), _CONSTM_ Text showsPrec ([Int]), _CONSTM_ Text readList ([Int]), _CONSTM_ Text showList ([Int])] _N_
- readsPrec = _A_ 1 _U_ 02 _N_ _S_ "A" {_A_ 0 _U_ 2 _N_ _N_ _F_ _IF_ARGS_ 0 0 X 1 _CONSTM_ Text readList (Int) _N_} _F_ _IF_ARGS_ 0 1 X 1 \ (u0 :: Int) -> _CONSTM_ Text readList (Int) _N_,
- showsPrec = _A_ 1 _U_ 022 _N_ _S_ "A" {_A_ 0 _U_ 22 _N_ _N_ _F_ _IF_ARGS_ 0 0 X 1 _CONSTM_ Text showList (Int) _N_} _F_ _IF_ARGS_ 0 1 X 1 \ (u0 :: Int) -> _CONSTM_ Text showList (Int) _N_,
- readList = _A_ 0 _U_ 2 _N_ _N_ _N_ _N_,
- showList = _A_ 0 _U_ 12 _N_ _N_ _N_ _N_ #-}
+ readsPrec = { _A_ 1 _U_ 02 _N_ _S_ "A" {_A_ 0 _U_ 2 _N_ _N_ _F_ _IF_ARGS_ 0 0 X 1 _CONSTM_ Text readList (Int) _N_} _F_ _IF_ARGS_ 0 1 X 1 \ (u0 :: Int) -> _CONSTM_ Text readList (Int) _N_ },
+ showsPrec = { _A_ 2 _U_ 022 _N_ _S_ "AL" {_A_ 1 _U_ 22 _N_ _N_ _F_ _IF_ARGS_ 0 0 X 1 _CONSTM_ Text showList (Int) _N_} _F_ _IF_ARGS_ 0 2 XX 2 \ (u0 :: Int) (u1 :: [Int]) -> _APP_ _CONSTM_ Text showList (Int) [ u1 ] _N_ },
+ readList = { _A_ 0 _U_ 2 _N_ _N_ _N_ _N_ },
+ showList = { _A_ 1 _U_ 12 _N_ _N_ _F_ _IF_ARGS_ 0 1 X 3 \ (u0 :: [[Int]]) -> _APP_ _TYAPP_ _ORIG_ PreludeCore _showList { [Int] } [ _CONSTM_ Text showList (Int), u0 ] _N_ } #-}
+instance Text [Integer]
+ {-# GHC_PRAGMA _M_ PreludeBuiltin {-dfun-} _A_ 0 _N_ _N_ _N_ _F_ _IF_ARGS_ 0 0 X 5 _!_ _TUP_4 [(Int -> [Char] -> [([Integer], [Char])]), (Int -> [Integer] -> [Char] -> [Char]), ([Char] -> [([[Integer]], [Char])]), ([[Integer]] -> [Char] -> [Char])] [_CONSTM_ Text readsPrec ([Integer]), _CONSTM_ Text showsPrec ([Integer]), _CONSTM_ Text readList ([Integer]), _CONSTM_ Text showList ([Integer])] _N_
+ readsPrec = { _A_ 1 _U_ 02 _N_ _S_ "A" {_A_ 0 _U_ 2 _N_ _N_ _F_ _IF_ARGS_ 0 0 X 1 _CONSTM_ Text readList (Integer) _N_} _F_ _IF_ARGS_ 0 1 X 1 \ (u0 :: Int) -> _CONSTM_ Text readList (Integer) _N_ },
+ showsPrec = { _A_ 2 _U_ 022 _N_ _S_ "AL" {_A_ 1 _U_ 22 _N_ _N_ _F_ _IF_ARGS_ 0 0 X 1 _CONSTM_ Text showList (Integer) _N_} _F_ _IF_ARGS_ 0 2 XX 2 \ (u0 :: Int) (u1 :: [Integer]) -> _APP_ _CONSTM_ Text showList (Integer) [ u1 ] _N_ },
+ readList = { _A_ 0 _U_ 2 _N_ _N_ _N_ _N_ },
+ showList = { _A_ 1 _U_ 12 _N_ _N_ _F_ _IF_ARGS_ 0 1 X 3 \ (u0 :: [[Integer]]) -> _APP_ _TYAPP_ _ORIG_ PreludeCore _showList { [Integer] } [ _CONSTM_ Text showList (Integer), u0 ] _N_ } #-}
+instance Text [[Char]]
+ {-# GHC_PRAGMA _M_ PreludeBuiltin {-dfun-} _A_ 0 _N_ _N_ _N_ _F_ _IF_ARGS_ 0 0 X 5 _!_ _TUP_4 [(Int -> [Char] -> [([[Char]], [Char])]), (Int -> [[Char]] -> [Char] -> [Char]), ([Char] -> [([[[Char]]], [Char])]), ([[[Char]]] -> [Char] -> [Char])] [_CONSTM_ Text readsPrec ([[Char]]), _CONSTM_ Text showsPrec ([[Char]]), _CONSTM_ Text readList ([[Char]]), _CONSTM_ Text showList ([[Char]])] _N_
+ readsPrec = { _A_ 1 _U_ 02 _N_ _S_ "A" {_A_ 0 _U_ 2 _N_ _N_ _F_ _IF_ARGS_ 0 0 X 1 _CONSTM_ Text readList ([Char]) _N_} _F_ _IF_ARGS_ 0 1 X 1 \ (u0 :: Int) -> _CONSTM_ Text readList ([Char]) _N_ },
+ showsPrec = { _A_ 2 _U_ 012 _N_ _S_ "AS" {_A_ 1 _U_ 12 _N_ _N_ _F_ _IF_ARGS_ 0 1 X 3 \ (u0 :: [[Char]]) -> _APP_ _TYAPP_ _ORIG_ PreludeCore _showList { [Char] } [ _CONSTM_ Text showList (Char), u0 ] _N_} _F_ _IF_ARGS_ 0 2 XX 2 \ (u0 :: Int) (u1 :: [[Char]]) -> _APP_ _CONSTM_ Text showList ([Char]) [ u1 ] _N_ },
+ readList = { _A_ 0 _U_ 2 _N_ _N_ _N_ _N_ },
+ showList = { _A_ 1 _U_ 12 _N_ _N_ _N_ _N_ } #-}
+instance Text [[Int]]
+ {-# GHC_PRAGMA _M_ PreludeBuiltin {-dfun-} _A_ 0 _N_ _N_ _N_ _F_ _IF_ARGS_ 0 0 X 5 _!_ _TUP_4 [(Int -> [Char] -> [([[Int]], [Char])]), (Int -> [[Int]] -> [Char] -> [Char]), ([Char] -> [([[[Int]]], [Char])]), ([[[Int]]] -> [Char] -> [Char])] [_CONSTM_ Text readsPrec ([[Int]]), _CONSTM_ Text showsPrec ([[Int]]), _CONSTM_ Text readList ([[Int]]), _CONSTM_ Text showList ([[Int]])] _N_
+ readsPrec = { _A_ 1 _U_ 02 _N_ _S_ "A" {_A_ 0 _U_ 2 _N_ _N_ _F_ _IF_ARGS_ 0 0 X 1 _CONSTM_ Text readList ([Int]) _N_} _F_ _IF_ARGS_ 0 1 X 1 \ (u0 :: Int) -> _CONSTM_ Text readList ([Int]) _N_ },
+ showsPrec = { _A_ 2 _U_ 012 _N_ _S_ "AS" {_A_ 1 _U_ 12 _N_ _N_ _F_ _IF_ARGS_ 0 1 X 3 \ (u0 :: [[Int]]) -> _APP_ _TYAPP_ _ORIG_ PreludeCore _showList { [Int] } [ _CONSTM_ Text showList (Int), u0 ] _N_} _F_ _IF_ARGS_ 0 2 XX 2 \ (u0 :: Int) (u1 :: [[Int]]) -> _APP_ _CONSTM_ Text showList ([Int]) [ u1 ] _N_ },
+ readList = { _A_ 0 _U_ 2 _N_ _N_ _N_ _N_ },
+ showList = { _A_ 1 _U_ 12 _N_ _N_ _N_ _N_ } #-}
instance Text _PackedString
{-# GHC_PRAGMA _M_ PreludePS {-dfun-} _A_ 0 _N_ _N_ _N_ _F_ _IF_ARGS_ 0 0 X 5 _!_ _TUP_4 [(Int -> [Char] -> [(_PackedString, [Char])]), (Int -> _PackedString -> [Char] -> [Char]), ([Char] -> [([_PackedString], [Char])]), ([_PackedString] -> [Char] -> [Char])] [_CONSTM_ Text readsPrec (_PackedString), _CONSTM_ Text showsPrec (_PackedString), _CONSTM_ Text readList (_PackedString), _CONSTM_ Text showList (_PackedString)] _N_
- readsPrec = _A_ 2 _U_ 02 _N_ _S_ _!_ _F_ _IF_ARGS_ 0 2 XX 3 \ (u0 :: Int) (u1 :: [Char]) -> _APP_ _TYAPP_ error { ([Char] -> [(_PackedString, [Char])]) } [ _NOREP_S_ "readsPrec: _PackedString: ToDo", u1 ] _N_,
- showsPrec = _A_ 3 _U_ 012 _N_ _S_ "ALL" {_A_ 2 _U_ 12 _N_ _N_ _N_ _N_} _F_ _IF_ARGS_ 0 3 XXX 6 \ (u0 :: Int) (u1 :: _PackedString) (u2 :: [Char]) -> let {(u3 :: [Char]) = _APP_ _ORIG_ PreludePS _unpackPS [ u1 ]} in _APP_ _CONSTM_ Text showList (Char) [ u3, u2 ] _N_,
- readList = _A_ 0 _U_ 2 _N_ _N_ _N_ _N_,
- showList = _A_ 0 _U_ 12 _N_ _N_ _N_ _N_ #-}
+ readsPrec = { _A_ 2 _U_ 02 _N_ _S_ _!_ _N_ _N_ },
+ showsPrec = { _A_ 3 _U_ 012 _N_ _S_ "ALL" {_A_ 2 _U_ 12 _N_ _N_ _N_ _N_} _F_ _IF_ARGS_ 0 3 XXX 6 \ (u0 :: Int) (u1 :: _PackedString) (u2 :: [Char]) -> let {(u3 :: [Char]) = _APP_ _ORIG_ PreludePS _unpackPS [ u1 ]} in _APP_ _CONSTM_ Text showList (Char) [ u3, u2 ] _N_ },
+ readList = { _A_ 0 _U_ 2 _N_ _N_ _N_ _N_ },
+ showList = { _A_ 1 _U_ 12 _N_ _N_ _F_ _IF_ARGS_ 0 1 X 3 \ (u0 :: [_PackedString]) -> _APP_ _TYAPP_ _ORIG_ PreludeCore _showList { _PackedString } [ _WRKR_ _CONSTM_ Text showsPrec (_PackedString), u0 ] _N_ } #-}
instance _CCallable Char
{-# GHC_PRAGMA _M_ PreludeCore {-dfun-} _A_ 0 _N_ _N_ _N_ _F_ _IF_ARGS_ 0 0 X 1 _!_ _TUP_0 [] [] _N_ #-}
instance _CCallable Double
-{-# GHC_PRAGMA INTERFACE VERSION 5 #-}
+{-# GHC_PRAGMA INTERFACE VERSION 6 #-}
interface PreludeCore where
import PreludeArray(Array, Assoc(..), _ByteArray)
import PreludeBuiltin(Bin, Char(..), Double(..), Float(..), Int(..), Integer(..), List(..), Tuple0, Tuple2, Tuple3, Tuple4, Tuple5, _Addr(..), _CMP_TAG(..), _Word(..))
import PreludeComplex(Complex(..))
-import PreludeGlaMisc(_MallocPtr(..))
+import PreludeGlaMisc(_MallocPtr(..), _StablePtr(..))
import PreludeGlaST(_MutableArray, _MutableByteArray)
import PreludeIO(BinCont(..), Dialogue(..), FailCont(..), IOError(..), Request(..), Response(..), SigAct(..), StrCont(..), StrListCont(..), SuccCont(..))
import PreludePS(_PackedString)
class Binary a where
readBin :: Bin -> (a, Bin)
{-# GHC_PRAGMA {-meth-} _A_ 1 _U_ 12 _N_ _S_ "S" _F_ _IF_ARGS_ 1 1 C 2 _/\_ u0 -> \ (u1 :: (Bin -> (u0, Bin), u0 -> Bin -> Bin)) -> case u1 of { _ALG_ _TUP_2 (u2 :: Bin -> (u0, Bin)) (u3 :: u0 -> Bin -> Bin) -> u2; _NO_DEFLT_ } _N_
- {-defm-} _A_ 2 _U_ 02 _N_ _S_ _!_ _F_ _IF_ARGS_ 1 2 XX 3 _/\_ u0 -> \ (u1 :: {{Binary u0}}) (u2 :: Bin) -> _APP_ _TYAPP_ patError# { (Bin -> (u0, Bin)) } [ _NOREP_S_ "%DPreludeCore.Binary.readBin\"", u2 ] _N_ #-}
+ {-defm-} _A_ 2 _U_ 02 _N_ _S_ _!_ _N_ _N_ #-}
showBin :: a -> Bin -> Bin
{-# GHC_PRAGMA {-meth-} _A_ 1 _U_ 122 _N_ _S_ "S" _F_ _IF_ARGS_ 1 1 C 2 _/\_ u0 -> \ (u1 :: (Bin -> (u0, Bin), u0 -> Bin -> Bin)) -> case u1 of { _ALG_ _TUP_2 (u2 :: Bin -> (u0, Bin)) (u3 :: u0 -> Bin -> Bin) -> u3; _NO_DEFLT_ } _N_
- {-defm-} _A_ 3 _U_ 022 _N_ _S_ _!_ _F_ _IF_ARGS_ 1 3 XXX 4 _/\_ u0 -> \ (u1 :: {{Binary u0}}) (u2 :: u0) (u3 :: Bin) -> _APP_ _TYAPP_ patError# { (u0 -> Bin -> Bin) } [ _NOREP_S_ "%DPreludeCore.Binary.showBin\"", u2, u3 ] _N_ #-}
+ {-defm-} _A_ 3 _U_ 022 _N_ _S_ _!_ _N_ _N_ #-}
class (Ord a) => Enum a {-# GHC_PRAGMA {-superdicts-} _A_ 1 _U_ 1 _N_ _S_ "S" _F_ _IF_ARGS_ 1 1 C 2 _/\_ u0 -> \ (u1 :: ({{Ord u0}}, u0 -> [u0], u0 -> u0 -> [u0], u0 -> u0 -> [u0], u0 -> u0 -> u0 -> [u0])) -> case u1 of { _ALG_ _TUP_5 (u2 :: {{Ord u0}}) (u3 :: u0 -> [u0]) (u4 :: u0 -> u0 -> [u0]) (u5 :: u0 -> u0 -> [u0]) (u6 :: u0 -> u0 -> u0 -> [u0]) -> u2; _NO_DEFLT_ } _N_ #-} where
enumFrom :: a -> [a]
{-# GHC_PRAGMA {-meth-} _A_ 1 _U_ 12 _N_ _S_ "S" _F_ _IF_ARGS_ 1 1 C 2 _/\_ u0 -> \ (u1 :: ({{Ord u0}}, u0 -> [u0], u0 -> u0 -> [u0], u0 -> u0 -> [u0], u0 -> u0 -> u0 -> [u0])) -> case u1 of { _ALG_ _TUP_5 (u2 :: {{Ord u0}}) (u3 :: u0 -> [u0]) (u4 :: u0 -> u0 -> [u0]) (u5 :: u0 -> u0 -> [u0]) (u6 :: u0 -> u0 -> u0 -> [u0]) -> u3; _NO_DEFLT_ } _N_
- {-defm-} _A_ 2 _U_ 02 _N_ _S_ _!_ _F_ _IF_ARGS_ 1 2 XX 3 _/\_ u0 -> \ (u1 :: {{Enum u0}}) (u2 :: u0) -> _APP_ _TYAPP_ patError# { (u0 -> [u0]) } [ _NOREP_S_ "%DPreludeCore.Enum.enumFrom\"", u2 ] _N_ #-}
+ {-defm-} _A_ 2 _U_ 02 _N_ _S_ _!_ _N_ _N_ #-}
enumFromThen :: a -> a -> [a]
{-# GHC_PRAGMA {-meth-} _A_ 1 _U_ 122 _N_ _S_ "S" _F_ _IF_ARGS_ 1 1 C 2 _/\_ u0 -> \ (u1 :: ({{Ord u0}}, u0 -> [u0], u0 -> u0 -> [u0], u0 -> u0 -> [u0], u0 -> u0 -> u0 -> [u0])) -> case u1 of { _ALG_ _TUP_5 (u2 :: {{Ord u0}}) (u3 :: u0 -> [u0]) (u4 :: u0 -> u0 -> [u0]) (u5 :: u0 -> u0 -> [u0]) (u6 :: u0 -> u0 -> u0 -> [u0]) -> u4; _NO_DEFLT_ } _N_
- {-defm-} _A_ 3 _U_ 022 _N_ _S_ _!_ _F_ _IF_ARGS_ 1 3 XXX 4 _/\_ u0 -> \ (u1 :: {{Enum u0}}) (u2 :: u0) (u3 :: u0) -> _APP_ _TYAPP_ patError# { (u0 -> u0 -> [u0]) } [ _NOREP_S_ "%DPreludeCore.Enum.enumFromThen\"", u2, u3 ] _N_ #-}
+ {-defm-} _A_ 3 _U_ 022 _N_ _S_ _!_ _N_ _N_ #-}
enumFromTo :: a -> a -> [a]
{-# GHC_PRAGMA {-meth-} _A_ 1 _U_ 122 _N_ _S_ "S" _F_ _IF_ARGS_ 1 1 C 2 _/\_ u0 -> \ (u1 :: ({{Ord u0}}, u0 -> [u0], u0 -> u0 -> [u0], u0 -> u0 -> [u0], u0 -> u0 -> u0 -> [u0])) -> case u1 of { _ALG_ _TUP_5 (u2 :: {{Ord u0}}) (u3 :: u0 -> [u0]) (u4 :: u0 -> u0 -> [u0]) (u5 :: u0 -> u0 -> [u0]) (u6 :: u0 -> u0 -> u0 -> [u0]) -> u5; _NO_DEFLT_ } _N_
{-defm-} _A_ 3 _U_ 122 _N_ _S_ "SLL" _N_ _N_ #-}
class Eq a where
(==) :: a -> a -> Bool
{-# GHC_PRAGMA {-meth-} _A_ 1 _U_ 122 _N_ _S_ "S" _F_ _IF_ARGS_ 1 1 C 2 _/\_ u0 -> \ (u1 :: (u0 -> u0 -> Bool, u0 -> u0 -> Bool)) -> case u1 of { _ALG_ _TUP_2 (u2 :: u0 -> u0 -> Bool) (u3 :: u0 -> u0 -> Bool) -> u2; _NO_DEFLT_ } _N_
- {-defm-} _A_ 3 _U_ 022 _N_ _S_ _!_ _F_ _IF_ARGS_ 1 3 XXX 4 _/\_ u0 -> \ (u1 :: {{Eq u0}}) (u2 :: u0) (u3 :: u0) -> _APP_ _TYAPP_ patError# { (u0 -> u0 -> Bool) } [ _NOREP_S_ "%DPreludeCore.Eq.(==)\"", u2, u3 ] _N_ #-}
+ {-defm-} _A_ 3 _U_ 022 _N_ _S_ _!_ _N_ _N_ #-}
(/=) :: a -> a -> Bool
{-# GHC_PRAGMA {-meth-} _A_ 1 _U_ 122 _N_ _S_ "S" _F_ _IF_ARGS_ 1 1 C 2 _/\_ u0 -> \ (u1 :: (u0 -> u0 -> Bool, u0 -> u0 -> Bool)) -> case u1 of { _ALG_ _TUP_2 (u2 :: u0 -> u0 -> Bool) (u3 :: u0 -> u0 -> Bool) -> u3; _NO_DEFLT_ } _N_
{-defm-} _A_ 3 _U_ 122 _N_ _S_ "SLL" _N_ _N_ #-}
class (Fractional a) => Floating a {-# GHC_PRAGMA {-superdicts-} _A_ 1 _U_ 1 _N_ _S_ "S" _F_ _IF_ARGS_ 1 1 C 2 _/\_ u0 -> \ (u1 :: ({{Fractional u0}}, u0, u0 -> u0, u0 -> u0, u0 -> u0, u0 -> u0 -> u0, u0 -> u0 -> u0, u0 -> u0, u0 -> u0, u0 -> u0, u0 -> u0, u0 -> u0, u0 -> u0, u0 -> u0, u0 -> u0, u0 -> u0, u0 -> u0, u0 -> u0, u0 -> u0)) -> case u1 of { _ALG_ _TUP_19 (u2 :: {{Fractional u0}}) (u3 :: u0) (u4 :: u0 -> u0) (u5 :: u0 -> u0) (u6 :: u0 -> u0) (u7 :: u0 -> u0 -> u0) (u8 :: u0 -> u0 -> u0) (u9 :: u0 -> u0) (ua :: u0 -> u0) (ub :: u0 -> u0) (uc :: u0 -> u0) (ud :: u0 -> u0) (ue :: u0 -> u0) (uf :: u0 -> u0) (ug :: u0 -> u0) (uh :: u0 -> u0) (ui :: u0 -> u0) (uj :: u0 -> u0) (uk :: u0 -> u0) -> u2; _NO_DEFLT_ } _N_ #-} where
pi :: a
{-# GHC_PRAGMA {-meth-} _A_ 1 _U_ 1 _N_ _S_ "S" _F_ _IF_ARGS_ 1 1 C 2 _/\_ u0 -> \ (u1 :: ({{Fractional u0}}, u0, u0 -> u0, u0 -> u0, u0 -> u0, u0 -> u0 -> u0, u0 -> u0 -> u0, u0 -> u0, u0 -> u0, u0 -> u0, u0 -> u0, u0 -> u0, u0 -> u0, u0 -> u0, u0 -> u0, u0 -> u0, u0 -> u0, u0 -> u0, u0 -> u0)) -> case u1 of { _ALG_ _TUP_19 (u2 :: {{Fractional u0}}) (u3 :: u0) (u4 :: u0 -> u0) (u5 :: u0 -> u0) (u6 :: u0 -> u0) (u7 :: u0 -> u0 -> u0) (u8 :: u0 -> u0 -> u0) (u9 :: u0 -> u0) (ua :: u0 -> u0) (ub :: u0 -> u0) (uc :: u0 -> u0) (ud :: u0 -> u0) (ue :: u0 -> u0) (uf :: u0 -> u0) (ug :: u0 -> u0) (uh :: u0 -> u0) (ui :: u0 -> u0) (uj :: u0 -> u0) (uk :: u0 -> u0) -> u3; _NO_DEFLT_ } _N_
- {-defm-} _A_ 1 _U_ 0 _N_ _S_ _!_ _F_ _IF_ARGS_ 1 1 X 2 _/\_ u0 -> \ (u1 :: {{Floating u0}}) -> _APP_ _TYAPP_ patError# { u0 } [ _NOREP_S_ "%DPreludeCore.Floating.pi\"" ] _N_ #-}
+ {-defm-} _A_ 1 _U_ 0 _N_ _S_ _!_ _N_ _N_ #-}
exp :: a -> a
{-# GHC_PRAGMA {-meth-} _A_ 1 _U_ 12 _N_ _S_ "S" _F_ _IF_ARGS_ 1 1 C 2 _/\_ u0 -> \ (u1 :: ({{Fractional u0}}, u0, u0 -> u0, u0 -> u0, u0 -> u0, u0 -> u0 -> u0, u0 -> u0 -> u0, u0 -> u0, u0 -> u0, u0 -> u0, u0 -> u0, u0 -> u0, u0 -> u0, u0 -> u0, u0 -> u0, u0 -> u0, u0 -> u0, u0 -> u0, u0 -> u0)) -> case u1 of { _ALG_ _TUP_19 (u2 :: {{Fractional u0}}) (u3 :: u0) (u4 :: u0 -> u0) (u5 :: u0 -> u0) (u6 :: u0 -> u0) (u7 :: u0 -> u0 -> u0) (u8 :: u0 -> u0 -> u0) (u9 :: u0 -> u0) (ua :: u0 -> u0) (ub :: u0 -> u0) (uc :: u0 -> u0) (ud :: u0 -> u0) (ue :: u0 -> u0) (uf :: u0 -> u0) (ug :: u0 -> u0) (uh :: u0 -> u0) (ui :: u0 -> u0) (uj :: u0 -> u0) (uk :: u0 -> u0) -> u4; _NO_DEFLT_ } _N_
- {-defm-} _A_ 2 _U_ 02 _N_ _S_ _!_ _F_ _IF_ARGS_ 1 2 XX 3 _/\_ u0 -> \ (u1 :: {{Floating u0}}) (u2 :: u0) -> _APP_ _TYAPP_ patError# { (u0 -> u0) } [ _NOREP_S_ "%DPreludeCore.Floating.exp\"", u2 ] _N_ #-}
+ {-defm-} _A_ 2 _U_ 02 _N_ _S_ _!_ _N_ _N_ #-}
log :: a -> a
{-# GHC_PRAGMA {-meth-} _A_ 1 _U_ 12 _N_ _S_ "S" _F_ _IF_ARGS_ 1 1 C 2 _/\_ u0 -> \ (u1 :: ({{Fractional u0}}, u0, u0 -> u0, u0 -> u0, u0 -> u0, u0 -> u0 -> u0, u0 -> u0 -> u0, u0 -> u0, u0 -> u0, u0 -> u0, u0 -> u0, u0 -> u0, u0 -> u0, u0 -> u0, u0 -> u0, u0 -> u0, u0 -> u0, u0 -> u0, u0 -> u0)) -> case u1 of { _ALG_ _TUP_19 (u2 :: {{Fractional u0}}) (u3 :: u0) (u4 :: u0 -> u0) (u5 :: u0 -> u0) (u6 :: u0 -> u0) (u7 :: u0 -> u0 -> u0) (u8 :: u0 -> u0 -> u0) (u9 :: u0 -> u0) (ua :: u0 -> u0) (ub :: u0 -> u0) (uc :: u0 -> u0) (ud :: u0 -> u0) (ue :: u0 -> u0) (uf :: u0 -> u0) (ug :: u0 -> u0) (uh :: u0 -> u0) (ui :: u0 -> u0) (uj :: u0 -> u0) (uk :: u0 -> u0) -> u5; _NO_DEFLT_ } _N_
- {-defm-} _A_ 2 _U_ 02 _N_ _S_ _!_ _F_ _IF_ARGS_ 1 2 XX 3 _/\_ u0 -> \ (u1 :: {{Floating u0}}) (u2 :: u0) -> _APP_ _TYAPP_ patError# { (u0 -> u0) } [ _NOREP_S_ "%DPreludeCore.Floating.log\"", u2 ] _N_ #-}
+ {-defm-} _A_ 2 _U_ 02 _N_ _S_ _!_ _N_ _N_ #-}
sqrt :: a -> a
{-# GHC_PRAGMA {-meth-} _A_ 1 _U_ 12 _N_ _S_ "S" _F_ _IF_ARGS_ 1 1 C 2 _/\_ u0 -> \ (u1 :: ({{Fractional u0}}, u0, u0 -> u0, u0 -> u0, u0 -> u0, u0 -> u0 -> u0, u0 -> u0 -> u0, u0 -> u0, u0 -> u0, u0 -> u0, u0 -> u0, u0 -> u0, u0 -> u0, u0 -> u0, u0 -> u0, u0 -> u0, u0 -> u0, u0 -> u0, u0 -> u0)) -> case u1 of { _ALG_ _TUP_19 (u2 :: {{Fractional u0}}) (u3 :: u0) (u4 :: u0 -> u0) (u5 :: u0 -> u0) (u6 :: u0 -> u0) (u7 :: u0 -> u0 -> u0) (u8 :: u0 -> u0 -> u0) (u9 :: u0 -> u0) (ua :: u0 -> u0) (ub :: u0 -> u0) (uc :: u0 -> u0) (ud :: u0 -> u0) (ue :: u0 -> u0) (uf :: u0 -> u0) (ug :: u0 -> u0) (uh :: u0 -> u0) (ui :: u0 -> u0) (uj :: u0 -> u0) (uk :: u0 -> u0) -> u6; _NO_DEFLT_ } _N_
{-defm-} _A_ 1 _U_ 12 _N_ _S_ "S" _N_ _N_ #-}
{-defm-} _A_ 3 _U_ 122 _N_ _S_ "SLL" _N_ _N_ #-}
sin :: a -> a
{-# GHC_PRAGMA {-meth-} _A_ 1 _U_ 12 _N_ _S_ "S" _F_ _IF_ARGS_ 1 1 C 2 _/\_ u0 -> \ (u1 :: ({{Fractional u0}}, u0, u0 -> u0, u0 -> u0, u0 -> u0, u0 -> u0 -> u0, u0 -> u0 -> u0, u0 -> u0, u0 -> u0, u0 -> u0, u0 -> u0, u0 -> u0, u0 -> u0, u0 -> u0, u0 -> u0, u0 -> u0, u0 -> u0, u0 -> u0, u0 -> u0)) -> case u1 of { _ALG_ _TUP_19 (u2 :: {{Fractional u0}}) (u3 :: u0) (u4 :: u0 -> u0) (u5 :: u0 -> u0) (u6 :: u0 -> u0) (u7 :: u0 -> u0 -> u0) (u8 :: u0 -> u0 -> u0) (u9 :: u0 -> u0) (ua :: u0 -> u0) (ub :: u0 -> u0) (uc :: u0 -> u0) (ud :: u0 -> u0) (ue :: u0 -> u0) (uf :: u0 -> u0) (ug :: u0 -> u0) (uh :: u0 -> u0) (ui :: u0 -> u0) (uj :: u0 -> u0) (uk :: u0 -> u0) -> u9; _NO_DEFLT_ } _N_
- {-defm-} _A_ 2 _U_ 02 _N_ _S_ _!_ _F_ _IF_ARGS_ 1 2 XX 3 _/\_ u0 -> \ (u1 :: {{Floating u0}}) (u2 :: u0) -> _APP_ _TYAPP_ patError# { (u0 -> u0) } [ _NOREP_S_ "%DPreludeCore.Floating.sin\"", u2 ] _N_ #-}
+ {-defm-} _A_ 2 _U_ 02 _N_ _S_ _!_ _N_ _N_ #-}
cos :: a -> a
{-# GHC_PRAGMA {-meth-} _A_ 1 _U_ 12 _N_ _S_ "S" _F_ _IF_ARGS_ 1 1 C 2 _/\_ u0 -> \ (u1 :: ({{Fractional u0}}, u0, u0 -> u0, u0 -> u0, u0 -> u0, u0 -> u0 -> u0, u0 -> u0 -> u0, u0 -> u0, u0 -> u0, u0 -> u0, u0 -> u0, u0 -> u0, u0 -> u0, u0 -> u0, u0 -> u0, u0 -> u0, u0 -> u0, u0 -> u0, u0 -> u0)) -> case u1 of { _ALG_ _TUP_19 (u2 :: {{Fractional u0}}) (u3 :: u0) (u4 :: u0 -> u0) (u5 :: u0 -> u0) (u6 :: u0 -> u0) (u7 :: u0 -> u0 -> u0) (u8 :: u0 -> u0 -> u0) (u9 :: u0 -> u0) (ua :: u0 -> u0) (ub :: u0 -> u0) (uc :: u0 -> u0) (ud :: u0 -> u0) (ue :: u0 -> u0) (uf :: u0 -> u0) (ug :: u0 -> u0) (uh :: u0 -> u0) (ui :: u0 -> u0) (uj :: u0 -> u0) (uk :: u0 -> u0) -> ua; _NO_DEFLT_ } _N_
- {-defm-} _A_ 2 _U_ 02 _N_ _S_ _!_ _F_ _IF_ARGS_ 1 2 XX 3 _/\_ u0 -> \ (u1 :: {{Floating u0}}) (u2 :: u0) -> _APP_ _TYAPP_ patError# { (u0 -> u0) } [ _NOREP_S_ "%DPreludeCore.Floating.cos\"", u2 ] _N_ #-}
+ {-defm-} _A_ 2 _U_ 02 _N_ _S_ _!_ _N_ _N_ #-}
tan :: a -> a
{-# GHC_PRAGMA {-meth-} _A_ 1 _U_ 12 _N_ _S_ "S" _F_ _IF_ARGS_ 1 1 C 2 _/\_ u0 -> \ (u1 :: ({{Fractional u0}}, u0, u0 -> u0, u0 -> u0, u0 -> u0, u0 -> u0 -> u0, u0 -> u0 -> u0, u0 -> u0, u0 -> u0, u0 -> u0, u0 -> u0, u0 -> u0, u0 -> u0, u0 -> u0, u0 -> u0, u0 -> u0, u0 -> u0, u0 -> u0, u0 -> u0)) -> case u1 of { _ALG_ _TUP_19 (u2 :: {{Fractional u0}}) (u3 :: u0) (u4 :: u0 -> u0) (u5 :: u0 -> u0) (u6 :: u0 -> u0) (u7 :: u0 -> u0 -> u0) (u8 :: u0 -> u0 -> u0) (u9 :: u0 -> u0) (ua :: u0 -> u0) (ub :: u0 -> u0) (uc :: u0 -> u0) (ud :: u0 -> u0) (ue :: u0 -> u0) (uf :: u0 -> u0) (ug :: u0 -> u0) (uh :: u0 -> u0) (ui :: u0 -> u0) (uj :: u0 -> u0) (uk :: u0 -> u0) -> ub; _NO_DEFLT_ } _N_
{-defm-} _A_ 2 _U_ 12 _N_ _S_ "SL" _N_ _N_ #-}
asin :: a -> a
{-# GHC_PRAGMA {-meth-} _A_ 1 _U_ 12 _N_ _S_ "S" _F_ _IF_ARGS_ 1 1 C 2 _/\_ u0 -> \ (u1 :: ({{Fractional u0}}, u0, u0 -> u0, u0 -> u0, u0 -> u0, u0 -> u0 -> u0, u0 -> u0 -> u0, u0 -> u0, u0 -> u0, u0 -> u0, u0 -> u0, u0 -> u0, u0 -> u0, u0 -> u0, u0 -> u0, u0 -> u0, u0 -> u0, u0 -> u0, u0 -> u0)) -> case u1 of { _ALG_ _TUP_19 (u2 :: {{Fractional u0}}) (u3 :: u0) (u4 :: u0 -> u0) (u5 :: u0 -> u0) (u6 :: u0 -> u0) (u7 :: u0 -> u0 -> u0) (u8 :: u0 -> u0 -> u0) (u9 :: u0 -> u0) (ua :: u0 -> u0) (ub :: u0 -> u0) (uc :: u0 -> u0) (ud :: u0 -> u0) (ue :: u0 -> u0) (uf :: u0 -> u0) (ug :: u0 -> u0) (uh :: u0 -> u0) (ui :: u0 -> u0) (uj :: u0 -> u0) (uk :: u0 -> u0) -> uc; _NO_DEFLT_ } _N_
- {-defm-} _A_ 2 _U_ 02 _N_ _S_ _!_ _F_ _IF_ARGS_ 1 2 XX 3 _/\_ u0 -> \ (u1 :: {{Floating u0}}) (u2 :: u0) -> _APP_ _TYAPP_ patError# { (u0 -> u0) } [ _NOREP_S_ "%DPreludeCore.Floating.asin\"", u2 ] _N_ #-}
+ {-defm-} _A_ 2 _U_ 02 _N_ _S_ _!_ _N_ _N_ #-}
acos :: a -> a
{-# GHC_PRAGMA {-meth-} _A_ 1 _U_ 12 _N_ _S_ "S" _F_ _IF_ARGS_ 1 1 C 2 _/\_ u0 -> \ (u1 :: ({{Fractional u0}}, u0, u0 -> u0, u0 -> u0, u0 -> u0, u0 -> u0 -> u0, u0 -> u0 -> u0, u0 -> u0, u0 -> u0, u0 -> u0, u0 -> u0, u0 -> u0, u0 -> u0, u0 -> u0, u0 -> u0, u0 -> u0, u0 -> u0, u0 -> u0, u0 -> u0)) -> case u1 of { _ALG_ _TUP_19 (u2 :: {{Fractional u0}}) (u3 :: u0) (u4 :: u0 -> u0) (u5 :: u0 -> u0) (u6 :: u0 -> u0) (u7 :: u0 -> u0 -> u0) (u8 :: u0 -> u0 -> u0) (u9 :: u0 -> u0) (ua :: u0 -> u0) (ub :: u0 -> u0) (uc :: u0 -> u0) (ud :: u0 -> u0) (ue :: u0 -> u0) (uf :: u0 -> u0) (ug :: u0 -> u0) (uh :: u0 -> u0) (ui :: u0 -> u0) (uj :: u0 -> u0) (uk :: u0 -> u0) -> ud; _NO_DEFLT_ } _N_
- {-defm-} _A_ 2 _U_ 02 _N_ _S_ _!_ _F_ _IF_ARGS_ 1 2 XX 3 _/\_ u0 -> \ (u1 :: {{Floating u0}}) (u2 :: u0) -> _APP_ _TYAPP_ patError# { (u0 -> u0) } [ _NOREP_S_ "%DPreludeCore.Floating.acos\"", u2 ] _N_ #-}
+ {-defm-} _A_ 2 _U_ 02 _N_ _S_ _!_ _N_ _N_ #-}
atan :: a -> a
{-# GHC_PRAGMA {-meth-} _A_ 1 _U_ 12 _N_ _S_ "S" _F_ _IF_ARGS_ 1 1 C 2 _/\_ u0 -> \ (u1 :: ({{Fractional u0}}, u0, u0 -> u0, u0 -> u0, u0 -> u0, u0 -> u0 -> u0, u0 -> u0 -> u0, u0 -> u0, u0 -> u0, u0 -> u0, u0 -> u0, u0 -> u0, u0 -> u0, u0 -> u0, u0 -> u0, u0 -> u0, u0 -> u0, u0 -> u0, u0 -> u0)) -> case u1 of { _ALG_ _TUP_19 (u2 :: {{Fractional u0}}) (u3 :: u0) (u4 :: u0 -> u0) (u5 :: u0 -> u0) (u6 :: u0 -> u0) (u7 :: u0 -> u0 -> u0) (u8 :: u0 -> u0 -> u0) (u9 :: u0 -> u0) (ua :: u0 -> u0) (ub :: u0 -> u0) (uc :: u0 -> u0) (ud :: u0 -> u0) (ue :: u0 -> u0) (uf :: u0 -> u0) (ug :: u0 -> u0) (uh :: u0 -> u0) (ui :: u0 -> u0) (uj :: u0 -> u0) (uk :: u0 -> u0) -> ue; _NO_DEFLT_ } _N_
- {-defm-} _A_ 2 _U_ 02 _N_ _S_ _!_ _F_ _IF_ARGS_ 1 2 XX 3 _/\_ u0 -> \ (u1 :: {{Floating u0}}) (u2 :: u0) -> _APP_ _TYAPP_ patError# { (u0 -> u0) } [ _NOREP_S_ "%DPreludeCore.Floating.atan\"", u2 ] _N_ #-}
+ {-defm-} _A_ 2 _U_ 02 _N_ _S_ _!_ _N_ _N_ #-}
sinh :: a -> a
{-# GHC_PRAGMA {-meth-} _A_ 1 _U_ 12 _N_ _S_ "S" _F_ _IF_ARGS_ 1 1 C 2 _/\_ u0 -> \ (u1 :: ({{Fractional u0}}, u0, u0 -> u0, u0 -> u0, u0 -> u0, u0 -> u0 -> u0, u0 -> u0 -> u0, u0 -> u0, u0 -> u0, u0 -> u0, u0 -> u0, u0 -> u0, u0 -> u0, u0 -> u0, u0 -> u0, u0 -> u0, u0 -> u0, u0 -> u0, u0 -> u0)) -> case u1 of { _ALG_ _TUP_19 (u2 :: {{Fractional u0}}) (u3 :: u0) (u4 :: u0 -> u0) (u5 :: u0 -> u0) (u6 :: u0 -> u0) (u7 :: u0 -> u0 -> u0) (u8 :: u0 -> u0 -> u0) (u9 :: u0 -> u0) (ua :: u0 -> u0) (ub :: u0 -> u0) (uc :: u0 -> u0) (ud :: u0 -> u0) (ue :: u0 -> u0) (uf :: u0 -> u0) (ug :: u0 -> u0) (uh :: u0 -> u0) (ui :: u0 -> u0) (uj :: u0 -> u0) (uk :: u0 -> u0) -> uf; _NO_DEFLT_ } _N_
- {-defm-} _A_ 2 _U_ 02 _N_ _S_ _!_ _F_ _IF_ARGS_ 1 2 XX 3 _/\_ u0 -> \ (u1 :: {{Floating u0}}) (u2 :: u0) -> _APP_ _TYAPP_ patError# { (u0 -> u0) } [ _NOREP_S_ "%DPreludeCore.Floating.sinh\"", u2 ] _N_ #-}
+ {-defm-} _A_ 2 _U_ 02 _N_ _S_ _!_ _N_ _N_ #-}
cosh :: a -> a
{-# GHC_PRAGMA {-meth-} _A_ 1 _U_ 12 _N_ _S_ "S" _F_ _IF_ARGS_ 1 1 C 2 _/\_ u0 -> \ (u1 :: ({{Fractional u0}}, u0, u0 -> u0, u0 -> u0, u0 -> u0, u0 -> u0 -> u0, u0 -> u0 -> u0, u0 -> u0, u0 -> u0, u0 -> u0, u0 -> u0, u0 -> u0, u0 -> u0, u0 -> u0, u0 -> u0, u0 -> u0, u0 -> u0, u0 -> u0, u0 -> u0)) -> case u1 of { _ALG_ _TUP_19 (u2 :: {{Fractional u0}}) (u3 :: u0) (u4 :: u0 -> u0) (u5 :: u0 -> u0) (u6 :: u0 -> u0) (u7 :: u0 -> u0 -> u0) (u8 :: u0 -> u0 -> u0) (u9 :: u0 -> u0) (ua :: u0 -> u0) (ub :: u0 -> u0) (uc :: u0 -> u0) (ud :: u0 -> u0) (ue :: u0 -> u0) (uf :: u0 -> u0) (ug :: u0 -> u0) (uh :: u0 -> u0) (ui :: u0 -> u0) (uj :: u0 -> u0) (uk :: u0 -> u0) -> ug; _NO_DEFLT_ } _N_
- {-defm-} _A_ 2 _U_ 02 _N_ _S_ _!_ _F_ _IF_ARGS_ 1 2 XX 3 _/\_ u0 -> \ (u1 :: {{Floating u0}}) (u2 :: u0) -> _APP_ _TYAPP_ patError# { (u0 -> u0) } [ _NOREP_S_ "%DPreludeCore.Floating.cosh\"", u2 ] _N_ #-}
+ {-defm-} _A_ 2 _U_ 02 _N_ _S_ _!_ _N_ _N_ #-}
tanh :: a -> a
{-# GHC_PRAGMA {-meth-} _A_ 1 _U_ 12 _N_ _S_ "S" _F_ _IF_ARGS_ 1 1 C 2 _/\_ u0 -> \ (u1 :: ({{Fractional u0}}, u0, u0 -> u0, u0 -> u0, u0 -> u0, u0 -> u0 -> u0, u0 -> u0 -> u0, u0 -> u0, u0 -> u0, u0 -> u0, u0 -> u0, u0 -> u0, u0 -> u0, u0 -> u0, u0 -> u0, u0 -> u0, u0 -> u0, u0 -> u0, u0 -> u0)) -> case u1 of { _ALG_ _TUP_19 (u2 :: {{Fractional u0}}) (u3 :: u0) (u4 :: u0 -> u0) (u5 :: u0 -> u0) (u6 :: u0 -> u0) (u7 :: u0 -> u0 -> u0) (u8 :: u0 -> u0 -> u0) (u9 :: u0 -> u0) (ua :: u0 -> u0) (ub :: u0 -> u0) (uc :: u0 -> u0) (ud :: u0 -> u0) (ue :: u0 -> u0) (uf :: u0 -> u0) (ug :: u0 -> u0) (uh :: u0 -> u0) (ui :: u0 -> u0) (uj :: u0 -> u0) (uk :: u0 -> u0) -> uh; _NO_DEFLT_ } _N_
{-defm-} _A_ 2 _U_ 12 _N_ _S_ "SL" _N_ _N_ #-}
asinh :: a -> a
{-# GHC_PRAGMA {-meth-} _A_ 1 _U_ 12 _N_ _S_ "S" _F_ _IF_ARGS_ 1 1 C 2 _/\_ u0 -> \ (u1 :: ({{Fractional u0}}, u0, u0 -> u0, u0 -> u0, u0 -> u0, u0 -> u0 -> u0, u0 -> u0 -> u0, u0 -> u0, u0 -> u0, u0 -> u0, u0 -> u0, u0 -> u0, u0 -> u0, u0 -> u0, u0 -> u0, u0 -> u0, u0 -> u0, u0 -> u0, u0 -> u0)) -> case u1 of { _ALG_ _TUP_19 (u2 :: {{Fractional u0}}) (u3 :: u0) (u4 :: u0 -> u0) (u5 :: u0 -> u0) (u6 :: u0 -> u0) (u7 :: u0 -> u0 -> u0) (u8 :: u0 -> u0 -> u0) (u9 :: u0 -> u0) (ua :: u0 -> u0) (ub :: u0 -> u0) (uc :: u0 -> u0) (ud :: u0 -> u0) (ue :: u0 -> u0) (uf :: u0 -> u0) (ug :: u0 -> u0) (uh :: u0 -> u0) (ui :: u0 -> u0) (uj :: u0 -> u0) (uk :: u0 -> u0) -> ui; _NO_DEFLT_ } _N_
- {-defm-} _A_ 2 _U_ 02 _N_ _S_ _!_ _F_ _IF_ARGS_ 1 2 XX 3 _/\_ u0 -> \ (u1 :: {{Floating u0}}) (u2 :: u0) -> _APP_ _TYAPP_ patError# { (u0 -> u0) } [ _NOREP_S_ "%DPreludeCore.Floating.asinh\"", u2 ] _N_ #-}
+ {-defm-} _A_ 2 _U_ 02 _N_ _S_ _!_ _N_ _N_ #-}
acosh :: a -> a
{-# GHC_PRAGMA {-meth-} _A_ 1 _U_ 12 _N_ _S_ "S" _F_ _IF_ARGS_ 1 1 C 2 _/\_ u0 -> \ (u1 :: ({{Fractional u0}}, u0, u0 -> u0, u0 -> u0, u0 -> u0, u0 -> u0 -> u0, u0 -> u0 -> u0, u0 -> u0, u0 -> u0, u0 -> u0, u0 -> u0, u0 -> u0, u0 -> u0, u0 -> u0, u0 -> u0, u0 -> u0, u0 -> u0, u0 -> u0, u0 -> u0)) -> case u1 of { _ALG_ _TUP_19 (u2 :: {{Fractional u0}}) (u3 :: u0) (u4 :: u0 -> u0) (u5 :: u0 -> u0) (u6 :: u0 -> u0) (u7 :: u0 -> u0 -> u0) (u8 :: u0 -> u0 -> u0) (u9 :: u0 -> u0) (ua :: u0 -> u0) (ub :: u0 -> u0) (uc :: u0 -> u0) (ud :: u0 -> u0) (ue :: u0 -> u0) (uf :: u0 -> u0) (ug :: u0 -> u0) (uh :: u0 -> u0) (ui :: u0 -> u0) (uj :: u0 -> u0) (uk :: u0 -> u0) -> uj; _NO_DEFLT_ } _N_
- {-defm-} _A_ 2 _U_ 02 _N_ _S_ _!_ _F_ _IF_ARGS_ 1 2 XX 3 _/\_ u0 -> \ (u1 :: {{Floating u0}}) (u2 :: u0) -> _APP_ _TYAPP_ patError# { (u0 -> u0) } [ _NOREP_S_ "%DPreludeCore.Floating.acosh\"", u2 ] _N_ #-}
+ {-defm-} _A_ 2 _U_ 02 _N_ _S_ _!_ _N_ _N_ #-}
atanh :: a -> a
{-# GHC_PRAGMA {-meth-} _A_ 1 _U_ 12 _N_ _S_ "S" _F_ _IF_ARGS_ 1 1 C 2 _/\_ u0 -> \ (u1 :: ({{Fractional u0}}, u0, u0 -> u0, u0 -> u0, u0 -> u0, u0 -> u0 -> u0, u0 -> u0 -> u0, u0 -> u0, u0 -> u0, u0 -> u0, u0 -> u0, u0 -> u0, u0 -> u0, u0 -> u0, u0 -> u0, u0 -> u0, u0 -> u0, u0 -> u0, u0 -> u0)) -> case u1 of { _ALG_ _TUP_19 (u2 :: {{Fractional u0}}) (u3 :: u0) (u4 :: u0 -> u0) (u5 :: u0 -> u0) (u6 :: u0 -> u0) (u7 :: u0 -> u0 -> u0) (u8 :: u0 -> u0 -> u0) (u9 :: u0 -> u0) (ua :: u0 -> u0) (ub :: u0 -> u0) (uc :: u0 -> u0) (ud :: u0 -> u0) (ue :: u0 -> u0) (uf :: u0 -> u0) (ug :: u0 -> u0) (uh :: u0 -> u0) (ui :: u0 -> u0) (uj :: u0 -> u0) (uk :: u0 -> u0) -> uk; _NO_DEFLT_ } _N_
- {-defm-} _A_ 2 _U_ 02 _N_ _S_ _!_ _F_ _IF_ARGS_ 1 2 XX 3 _/\_ u0 -> \ (u1 :: {{Floating u0}}) (u2 :: u0) -> _APP_ _TYAPP_ patError# { (u0 -> u0) } [ _NOREP_S_ "%DPreludeCore.Floating.atanh\"", u2 ] _N_ #-}
+ {-defm-} _A_ 2 _U_ 02 _N_ _S_ _!_ _N_ _N_ #-}
class (Num a) => Fractional a {-# GHC_PRAGMA {-superdicts-} _A_ 1 _U_ 1 _N_ _S_ "S" _F_ _IF_ARGS_ 1 1 C 2 _/\_ u0 -> \ (u1 :: ({{Num u0}}, u0 -> u0 -> u0, u0 -> u0, Ratio Integer -> u0)) -> case u1 of { _ALG_ _TUP_4 (u2 :: {{Num u0}}) (u3 :: u0 -> u0 -> u0) (u4 :: u0 -> u0) (u5 :: Ratio Integer -> u0) -> u2; _NO_DEFLT_ } _N_ #-} where
(/) :: a -> a -> a
{-# GHC_PRAGMA {-meth-} _A_ 1 _U_ 122 _N_ _S_ "S" _F_ _IF_ARGS_ 1 1 C 2 _/\_ u0 -> \ (u1 :: ({{Num u0}}, u0 -> u0 -> u0, u0 -> u0, Ratio Integer -> u0)) -> case u1 of { _ALG_ _TUP_4 (u2 :: {{Num u0}}) (u3 :: u0 -> u0 -> u0) (u4 :: u0 -> u0) (u5 :: Ratio Integer -> u0) -> u3; _NO_DEFLT_ } _N_
- {-defm-} _A_ 3 _U_ 022 _N_ _S_ _!_ _F_ _IF_ARGS_ 1 3 XXX 4 _/\_ u0 -> \ (u1 :: {{Fractional u0}}) (u2 :: u0) (u3 :: u0) -> _APP_ _TYAPP_ patError# { (u0 -> u0 -> u0) } [ _NOREP_S_ "%DPreludeCore.Fractional.(/)\"", u2, u3 ] _N_ #-}
+ {-defm-} _A_ 3 _U_ 022 _N_ _S_ _!_ _N_ _N_ #-}
recip :: a -> a
{-# GHC_PRAGMA {-meth-} _A_ 1 _U_ 12 _N_ _S_ "S" _F_ _IF_ARGS_ 1 1 C 2 _/\_ u0 -> \ (u1 :: ({{Num u0}}, u0 -> u0 -> u0, u0 -> u0, Ratio Integer -> u0)) -> case u1 of { _ALG_ _TUP_4 (u2 :: {{Num u0}}) (u3 :: u0 -> u0 -> u0) (u4 :: u0 -> u0) (u5 :: Ratio Integer -> u0) -> u4; _NO_DEFLT_ } _N_
{-defm-} _A_ 1 _U_ 12 _N_ _S_ "S" _N_ _N_ #-}
fromRational :: Ratio Integer -> a
{-# GHC_PRAGMA {-meth-} _A_ 1 _U_ 12 _N_ _S_ "S" _F_ _IF_ARGS_ 1 1 C 2 _/\_ u0 -> \ (u1 :: ({{Num u0}}, u0 -> u0 -> u0, u0 -> u0, Ratio Integer -> u0)) -> case u1 of { _ALG_ _TUP_4 (u2 :: {{Num u0}}) (u3 :: u0 -> u0 -> u0) (u4 :: u0 -> u0) (u5 :: Ratio Integer -> u0) -> u5; _NO_DEFLT_ } _N_
- {-defm-} _A_ 2 _U_ 02 _N_ _S_ _!_ _F_ _IF_ARGS_ 1 2 XX 3 _/\_ u0 -> \ (u1 :: {{Fractional u0}}) (u2 :: Ratio Integer) -> _APP_ _TYAPP_ patError# { (Ratio Integer -> u0) } [ _NOREP_S_ "%DPreludeCore.Fractional.fromRational\"", u2 ] _N_ #-}
+ {-defm-} _A_ 2 _U_ 02 _N_ _S_ _!_ _N_ _N_ #-}
class (Real a, Ix a) => Integral a {-# GHC_PRAGMA {-superdicts-} _A_ 1 _U_ 1 _N_ _S_ "S" _F_ _IF_ARGS_ 1 1 C 2 _/\_ u0 -> \ (u1 :: ({{Real u0}}, {{Ix u0}}, u0 -> u0 -> u0, u0 -> u0 -> u0, u0 -> u0 -> u0, u0 -> u0 -> u0, u0 -> u0 -> (u0, u0), u0 -> u0 -> (u0, u0), u0 -> Bool, u0 -> Bool, u0 -> Integer, u0 -> Int)) -> case u1 of { _ALG_ _TUP_12 (u2 :: {{Real u0}}) (u3 :: {{Ix u0}}) (u4 :: u0 -> u0 -> u0) (u5 :: u0 -> u0 -> u0) (u6 :: u0 -> u0 -> u0) (u7 :: u0 -> u0 -> u0) (u8 :: u0 -> u0 -> (u0, u0)) (u9 :: u0 -> u0 -> (u0, u0)) (ua :: u0 -> Bool) (ub :: u0 -> Bool) (uc :: u0 -> Integer) (ud :: u0 -> Int) -> u2; _NO_DEFLT_ } _N_, _A_ 1 _U_ 1 _N_ _S_ "S" _F_ _IF_ARGS_ 1 1 C 2 _/\_ u0 -> \ (u1 :: ({{Real u0}}, {{Ix u0}}, u0 -> u0 -> u0, u0 -> u0 -> u0, u0 -> u0 -> u0, u0 -> u0 -> u0, u0 -> u0 -> (u0, u0), u0 -> u0 -> (u0, u0), u0 -> Bool, u0 -> Bool, u0 -> Integer, u0 -> Int)) -> case u1 of { _ALG_ _TUP_12 (u2 :: {{Real u0}}) (u3 :: {{Ix u0}}) (u4 :: u0 -> u0 -> u0) (u5 :: u0 -> u0 -> u0) (u6 :: u0 -> u0 -> u0) (u7 :: u0 -> u0 -> u0) (u8 :: u0 -> u0 -> (u0, u0)) (u9 :: u0 -> u0 -> (u0, u0)) (ua :: u0 -> Bool) (ub :: u0 -> Bool) (uc :: u0 -> Integer) (ud :: u0 -> Int) -> u3; _NO_DEFLT_ } _N_ #-} where
quot :: a -> a -> a
{-# GHC_PRAGMA {-meth-} _A_ 1 _U_ 122 _N_ _S_ "S" _F_ _IF_ARGS_ 1 1 C 2 _/\_ u0 -> \ (u1 :: ({{Real u0}}, {{Ix u0}}, u0 -> u0 -> u0, u0 -> u0 -> u0, u0 -> u0 -> u0, u0 -> u0 -> u0, u0 -> u0 -> (u0, u0), u0 -> u0 -> (u0, u0), u0 -> Bool, u0 -> Bool, u0 -> Integer, u0 -> Int)) -> case u1 of { _ALG_ _TUP_12 (u2 :: {{Real u0}}) (u3 :: {{Ix u0}}) (u4 :: u0 -> u0 -> u0) (u5 :: u0 -> u0 -> u0) (u6 :: u0 -> u0 -> u0) (u7 :: u0 -> u0 -> u0) (u8 :: u0 -> u0 -> (u0, u0)) (u9 :: u0 -> u0 -> (u0, u0)) (ua :: u0 -> Bool) (ub :: u0 -> Bool) (uc :: u0 -> Integer) (ud :: u0 -> Int) -> u4; _NO_DEFLT_ } _N_
{-defm-} _A_ 3 _U_ 122 _N_ _S_ "SLL" _F_ _IF_ARGS_ 1 3 CXX 6 _/\_ u0 -> \ (u1 :: {{Integral u0}}) (u2 :: u0) (u3 :: u0) -> case case u1 of { _ALG_ _TUP_12 (u4 :: {{Real u0}}) (u5 :: {{Ix u0}}) (u6 :: u0 -> u0 -> u0) (u7 :: u0 -> u0 -> u0) (u8 :: u0 -> u0 -> u0) (u9 :: u0 -> u0 -> u0) (ua :: u0 -> u0 -> (u0, u0)) (ub :: u0 -> u0 -> (u0, u0)) (uc :: u0 -> Bool) (ud :: u0 -> Bool) (ue :: u0 -> Integer) (uf :: u0 -> Int) -> _APP_ ub [ u2, u3 ]; _NO_DEFLT_ } of { _ALG_ _TUP_2 (ug :: u0) (uh :: u0) -> uh; _NO_DEFLT_ } _N_ #-}
quotRem :: a -> a -> (a, a)
{-# GHC_PRAGMA {-meth-} _A_ 1 _U_ 122 _N_ _S_ "S" _F_ _IF_ARGS_ 1 1 C 2 _/\_ u0 -> \ (u1 :: ({{Real u0}}, {{Ix u0}}, u0 -> u0 -> u0, u0 -> u0 -> u0, u0 -> u0 -> u0, u0 -> u0 -> u0, u0 -> u0 -> (u0, u0), u0 -> u0 -> (u0, u0), u0 -> Bool, u0 -> Bool, u0 -> Integer, u0 -> Int)) -> case u1 of { _ALG_ _TUP_12 (u2 :: {{Real u0}}) (u3 :: {{Ix u0}}) (u4 :: u0 -> u0 -> u0) (u5 :: u0 -> u0 -> u0) (u6 :: u0 -> u0 -> u0) (u7 :: u0 -> u0 -> u0) (u8 :: u0 -> u0 -> (u0, u0)) (u9 :: u0 -> u0 -> (u0, u0)) (ua :: u0 -> Bool) (ub :: u0 -> Bool) (uc :: u0 -> Integer) (ud :: u0 -> Int) -> u8; _NO_DEFLT_ } _N_
- {-defm-} _A_ 3 _U_ 022 _N_ _S_ _!_ _F_ _IF_ARGS_ 1 3 XXX 4 _/\_ u0 -> \ (u1 :: {{Integral u0}}) (u2 :: u0) (u3 :: u0) -> _APP_ _TYAPP_ patError# { (u0 -> u0 -> (u0, u0)) } [ _NOREP_S_ "%DPreludeCore.Integral.quotRem\"", u2, u3 ] _N_ #-}
+ {-defm-} _A_ 3 _U_ 022 _N_ _S_ _!_ _N_ _N_ #-}
divMod :: a -> a -> (a, a)
{-# GHC_PRAGMA {-meth-} _A_ 1 _U_ 122 _N_ _S_ "S" _F_ _IF_ARGS_ 1 1 C 2 _/\_ u0 -> \ (u1 :: ({{Real u0}}, {{Ix u0}}, u0 -> u0 -> u0, u0 -> u0 -> u0, u0 -> u0 -> u0, u0 -> u0 -> u0, u0 -> u0 -> (u0, u0), u0 -> u0 -> (u0, u0), u0 -> Bool, u0 -> Bool, u0 -> Integer, u0 -> Int)) -> case u1 of { _ALG_ _TUP_12 (u2 :: {{Real u0}}) (u3 :: {{Ix u0}}) (u4 :: u0 -> u0 -> u0) (u5 :: u0 -> u0 -> u0) (u6 :: u0 -> u0 -> u0) (u7 :: u0 -> u0 -> u0) (u8 :: u0 -> u0 -> (u0, u0)) (u9 :: u0 -> u0 -> (u0, u0)) (ua :: u0 -> Bool) (ub :: u0 -> Bool) (uc :: u0 -> Integer) (ud :: u0 -> Int) -> u9; _NO_DEFLT_ } _N_
{-defm-} _A_ 1 _U_ 122 _N_ _S_ "S" _N_ _N_ #-}
{-defm-} _A_ 1 _U_ 12 _N_ _S_ "S" _N_ _N_ #-}
toInteger :: a -> Integer
{-# GHC_PRAGMA {-meth-} _A_ 1 _U_ 12 _N_ _S_ "S" _F_ _IF_ARGS_ 1 1 C 2 _/\_ u0 -> \ (u1 :: ({{Real u0}}, {{Ix u0}}, u0 -> u0 -> u0, u0 -> u0 -> u0, u0 -> u0 -> u0, u0 -> u0 -> u0, u0 -> u0 -> (u0, u0), u0 -> u0 -> (u0, u0), u0 -> Bool, u0 -> Bool, u0 -> Integer, u0 -> Int)) -> case u1 of { _ALG_ _TUP_12 (u2 :: {{Real u0}}) (u3 :: {{Ix u0}}) (u4 :: u0 -> u0 -> u0) (u5 :: u0 -> u0 -> u0) (u6 :: u0 -> u0 -> u0) (u7 :: u0 -> u0 -> u0) (u8 :: u0 -> u0 -> (u0, u0)) (u9 :: u0 -> u0 -> (u0, u0)) (ua :: u0 -> Bool) (ub :: u0 -> Bool) (uc :: u0 -> Integer) (ud :: u0 -> Int) -> uc; _NO_DEFLT_ } _N_
- {-defm-} _A_ 2 _U_ 02 _N_ _S_ _!_ _F_ _IF_ARGS_ 1 2 XX 3 _/\_ u0 -> \ (u1 :: {{Integral u0}}) (u2 :: u0) -> _APP_ _TYAPP_ patError# { (u0 -> Integer) } [ _NOREP_S_ "%DPreludeCore.Integral.toInteger\"", u2 ] _N_ #-}
+ {-defm-} _A_ 2 _U_ 02 _N_ _S_ _!_ _N_ _N_ #-}
toInt :: a -> Int
{-# GHC_PRAGMA {-meth-} _A_ 1 _U_ 12 _N_ _S_ "S" _F_ _IF_ARGS_ 1 1 C 2 _/\_ u0 -> \ (u1 :: ({{Real u0}}, {{Ix u0}}, u0 -> u0 -> u0, u0 -> u0 -> u0, u0 -> u0 -> u0, u0 -> u0 -> u0, u0 -> u0 -> (u0, u0), u0 -> u0 -> (u0, u0), u0 -> Bool, u0 -> Bool, u0 -> Integer, u0 -> Int)) -> case u1 of { _ALG_ _TUP_12 (u2 :: {{Real u0}}) (u3 :: {{Ix u0}}) (u4 :: u0 -> u0 -> u0) (u5 :: u0 -> u0 -> u0) (u6 :: u0 -> u0 -> u0) (u7 :: u0 -> u0 -> u0) (u8 :: u0 -> u0 -> (u0, u0)) (u9 :: u0 -> u0 -> (u0, u0)) (ua :: u0 -> Bool) (ub :: u0 -> Bool) (uc :: u0 -> Integer) (ud :: u0 -> Int) -> ud; _NO_DEFLT_ } _N_
- {-defm-} _A_ 2 _U_ 02 _N_ _S_ _!_ _F_ _IF_ARGS_ 1 2 XX 3 _/\_ u0 -> \ (u1 :: {{Integral u0}}) (u2 :: u0) -> _APP_ _TYAPP_ patError# { (u0 -> Int) } [ _NOREP_S_ "%DPreludeCore.Integral.toInt\"", u2 ] _N_ #-}
+ {-defm-} _A_ 2 _U_ 02 _N_ _S_ _!_ _N_ _N_ #-}
class (Ord a) => Ix a {-# GHC_PRAGMA {-superdicts-} _A_ 1 _U_ 1 _N_ _S_ "S" _F_ _IF_ARGS_ 1 1 C 2 _/\_ u0 -> \ (u1 :: ({{Ord u0}}, (u0, u0) -> [u0], (u0, u0) -> u0 -> Int, (u0, u0) -> u0 -> Bool)) -> case u1 of { _ALG_ _TUP_4 (u2 :: {{Ord u0}}) (u3 :: (u0, u0) -> [u0]) (u4 :: (u0, u0) -> u0 -> Int) (u5 :: (u0, u0) -> u0 -> Bool) -> u2; _NO_DEFLT_ } _N_ #-} where
range :: (a, a) -> [a]
{-# GHC_PRAGMA {-meth-} _A_ 1 _U_ 12 _N_ _S_ "S" _F_ _IF_ARGS_ 1 1 C 2 _/\_ u0 -> \ (u1 :: ({{Ord u0}}, (u0, u0) -> [u0], (u0, u0) -> u0 -> Int, (u0, u0) -> u0 -> Bool)) -> case u1 of { _ALG_ _TUP_4 (u2 :: {{Ord u0}}) (u3 :: (u0, u0) -> [u0]) (u4 :: (u0, u0) -> u0 -> Int) (u5 :: (u0, u0) -> u0 -> Bool) -> u3; _NO_DEFLT_ } _N_
- {-defm-} _A_ 2 _U_ 02 _N_ _S_ _!_ _F_ _IF_ARGS_ 1 2 XX 3 _/\_ u0 -> \ (u1 :: {{Ix u0}}) (u2 :: (u0, u0)) -> _APP_ _TYAPP_ patError# { ((u0, u0) -> [u0]) } [ _NOREP_S_ "%DPreludeCore.Ix.range\"", u2 ] _N_ #-}
+ {-defm-} _A_ 2 _U_ 02 _N_ _S_ _!_ _N_ _N_ #-}
index :: (a, a) -> a -> Int
{-# GHC_PRAGMA {-meth-} _A_ 1 _U_ 122 _N_ _S_ "S" _F_ _IF_ARGS_ 1 1 C 2 _/\_ u0 -> \ (u1 :: ({{Ord u0}}, (u0, u0) -> [u0], (u0, u0) -> u0 -> Int, (u0, u0) -> u0 -> Bool)) -> case u1 of { _ALG_ _TUP_4 (u2 :: {{Ord u0}}) (u3 :: (u0, u0) -> [u0]) (u4 :: (u0, u0) -> u0 -> Int) (u5 :: (u0, u0) -> u0 -> Bool) -> u4; _NO_DEFLT_ } _N_
- {-defm-} _A_ 3 _U_ 022 _N_ _S_ _!_ _F_ _IF_ARGS_ 1 3 XXX 4 _/\_ u0 -> \ (u1 :: {{Ix u0}}) (u2 :: (u0, u0)) (u3 :: u0) -> _APP_ _TYAPP_ patError# { ((u0, u0) -> u0 -> Int) } [ _NOREP_S_ "%DPreludeCore.Ix.index\"", u2, u3 ] _N_ #-}
+ {-defm-} _A_ 3 _U_ 022 _N_ _S_ _!_ _N_ _N_ #-}
inRange :: (a, a) -> a -> Bool
{-# GHC_PRAGMA {-meth-} _A_ 1 _U_ 122 _N_ _S_ "S" _F_ _IF_ARGS_ 1 1 C 2 _/\_ u0 -> \ (u1 :: ({{Ord u0}}, (u0, u0) -> [u0], (u0, u0) -> u0 -> Int, (u0, u0) -> u0 -> Bool)) -> case u1 of { _ALG_ _TUP_4 (u2 :: {{Ord u0}}) (u3 :: (u0, u0) -> [u0]) (u4 :: (u0, u0) -> u0 -> Int) (u5 :: (u0, u0) -> u0 -> Bool) -> u5; _NO_DEFLT_ } _N_
- {-defm-} _A_ 3 _U_ 022 _N_ _S_ _!_ _F_ _IF_ARGS_ 1 3 XXX 4 _/\_ u0 -> \ (u1 :: {{Ix u0}}) (u2 :: (u0, u0)) (u3 :: u0) -> _APP_ _TYAPP_ patError# { ((u0, u0) -> u0 -> Bool) } [ _NOREP_S_ "%DPreludeCore.Ix.inRange\"", u2, u3 ] _N_ #-}
+ {-defm-} _A_ 3 _U_ 022 _N_ _S_ _!_ _N_ _N_ #-}
class (Eq a, Text a) => Num a {-# GHC_PRAGMA {-superdicts-} _A_ 1 _U_ 1 _N_ _S_ "S" _F_ _IF_ARGS_ 1 1 C 2 _/\_ u0 -> \ (u1 :: ({{Eq u0}}, {{Text u0}}, u0 -> u0 -> u0, u0 -> u0 -> u0, u0 -> u0 -> u0, u0 -> u0, u0 -> u0, u0 -> u0, Integer -> u0, Int -> u0)) -> case u1 of { _ALG_ _TUP_10 (u2 :: {{Eq u0}}) (u3 :: {{Text u0}}) (u4 :: u0 -> u0 -> u0) (u5 :: u0 -> u0 -> u0) (u6 :: u0 -> u0 -> u0) (u7 :: u0 -> u0) (u8 :: u0 -> u0) (u9 :: u0 -> u0) (ua :: Integer -> u0) (ub :: Int -> u0) -> u2; _NO_DEFLT_ } _N_, _A_ 1 _U_ 1 _N_ _S_ "S" _F_ _IF_ARGS_ 1 1 C 2 _/\_ u0 -> \ (u1 :: ({{Eq u0}}, {{Text u0}}, u0 -> u0 -> u0, u0 -> u0 -> u0, u0 -> u0 -> u0, u0 -> u0, u0 -> u0, u0 -> u0, Integer -> u0, Int -> u0)) -> case u1 of { _ALG_ _TUP_10 (u2 :: {{Eq u0}}) (u3 :: {{Text u0}}) (u4 :: u0 -> u0 -> u0) (u5 :: u0 -> u0 -> u0) (u6 :: u0 -> u0 -> u0) (u7 :: u0 -> u0) (u8 :: u0 -> u0) (u9 :: u0 -> u0) (ua :: Integer -> u0) (ub :: Int -> u0) -> u3; _NO_DEFLT_ } _N_ #-} where
(+) :: a -> a -> a
{-# GHC_PRAGMA {-meth-} _A_ 1 _U_ 122 _N_ _S_ "S" _F_ _IF_ARGS_ 1 1 C 2 _/\_ u0 -> \ (u1 :: ({{Eq u0}}, {{Text u0}}, u0 -> u0 -> u0, u0 -> u0 -> u0, u0 -> u0 -> u0, u0 -> u0, u0 -> u0, u0 -> u0, Integer -> u0, Int -> u0)) -> case u1 of { _ALG_ _TUP_10 (u2 :: {{Eq u0}}) (u3 :: {{Text u0}}) (u4 :: u0 -> u0 -> u0) (u5 :: u0 -> u0 -> u0) (u6 :: u0 -> u0 -> u0) (u7 :: u0 -> u0) (u8 :: u0 -> u0) (u9 :: u0 -> u0) (ua :: Integer -> u0) (ub :: Int -> u0) -> u4; _NO_DEFLT_ } _N_
- {-defm-} _A_ 3 _U_ 022 _N_ _S_ _!_ _F_ _IF_ARGS_ 1 3 XXX 4 _/\_ u0 -> \ (u1 :: {{Num u0}}) (u2 :: u0) (u3 :: u0) -> _APP_ _TYAPP_ patError# { (u0 -> u0 -> u0) } [ _NOREP_S_ "%DPreludeCore.Num.(+)\"", u2, u3 ] _N_ #-}
+ {-defm-} _A_ 3 _U_ 022 _N_ _S_ _!_ _N_ _N_ #-}
(-) :: a -> a -> a
{-# GHC_PRAGMA {-meth-} _A_ 1 _U_ 122 _N_ _S_ "S" _F_ _IF_ARGS_ 1 1 C 2 _/\_ u0 -> \ (u1 :: ({{Eq u0}}, {{Text u0}}, u0 -> u0 -> u0, u0 -> u0 -> u0, u0 -> u0 -> u0, u0 -> u0, u0 -> u0, u0 -> u0, Integer -> u0, Int -> u0)) -> case u1 of { _ALG_ _TUP_10 (u2 :: {{Eq u0}}) (u3 :: {{Text u0}}) (u4 :: u0 -> u0 -> u0) (u5 :: u0 -> u0 -> u0) (u6 :: u0 -> u0 -> u0) (u7 :: u0 -> u0) (u8 :: u0 -> u0) (u9 :: u0 -> u0) (ua :: Integer -> u0) (ub :: Int -> u0) -> u5; _NO_DEFLT_ } _N_
{-defm-} _A_ 3 _U_ 122 _N_ _S_ "SLL" _F_ _ALWAYS_ _/\_ u0 -> \ (u1 :: {{Num u0}}) (u2 :: u0) (u3 :: u0) -> case u1 of { _ALG_ _TUP_10 (u4 :: {{Eq u0}}) (u5 :: {{Text u0}}) (u6 :: u0 -> u0 -> u0) (u7 :: u0 -> u0 -> u0) (u8 :: u0 -> u0 -> u0) (u9 :: u0 -> u0) (ua :: u0 -> u0) (ub :: u0 -> u0) (uc :: Integer -> u0) (ud :: Int -> u0) -> let {(ue :: u0) = _APP_ u9 [ u3 ]} in _APP_ u6 [ u2, ue ]; _NO_DEFLT_ } _N_ #-}
(*) :: a -> a -> a
{-# GHC_PRAGMA {-meth-} _A_ 1 _U_ 122 _N_ _S_ "S" _F_ _IF_ARGS_ 1 1 C 2 _/\_ u0 -> \ (u1 :: ({{Eq u0}}, {{Text u0}}, u0 -> u0 -> u0, u0 -> u0 -> u0, u0 -> u0 -> u0, u0 -> u0, u0 -> u0, u0 -> u0, Integer -> u0, Int -> u0)) -> case u1 of { _ALG_ _TUP_10 (u2 :: {{Eq u0}}) (u3 :: {{Text u0}}) (u4 :: u0 -> u0 -> u0) (u5 :: u0 -> u0 -> u0) (u6 :: u0 -> u0 -> u0) (u7 :: u0 -> u0) (u8 :: u0 -> u0) (u9 :: u0 -> u0) (ua :: Integer -> u0) (ub :: Int -> u0) -> u6; _NO_DEFLT_ } _N_
- {-defm-} _A_ 3 _U_ 022 _N_ _S_ _!_ _F_ _IF_ARGS_ 1 3 XXX 4 _/\_ u0 -> \ (u1 :: {{Num u0}}) (u2 :: u0) (u3 :: u0) -> _APP_ _TYAPP_ patError# { (u0 -> u0 -> u0) } [ _NOREP_S_ "%DPreludeCore.Num.(*)\"", u2, u3 ] _N_ #-}
+ {-defm-} _A_ 3 _U_ 022 _N_ _S_ _!_ _N_ _N_ #-}
negate :: a -> a
{-# GHC_PRAGMA {-meth-} _A_ 1 _U_ 12 _N_ _S_ "S" _F_ _IF_ARGS_ 1 1 C 2 _/\_ u0 -> \ (u1 :: ({{Eq u0}}, {{Text u0}}, u0 -> u0 -> u0, u0 -> u0 -> u0, u0 -> u0 -> u0, u0 -> u0, u0 -> u0, u0 -> u0, Integer -> u0, Int -> u0)) -> case u1 of { _ALG_ _TUP_10 (u2 :: {{Eq u0}}) (u3 :: {{Text u0}}) (u4 :: u0 -> u0 -> u0) (u5 :: u0 -> u0 -> u0) (u6 :: u0 -> u0 -> u0) (u7 :: u0 -> u0) (u8 :: u0 -> u0) (u9 :: u0 -> u0) (ua :: Integer -> u0) (ub :: Int -> u0) -> u7; _NO_DEFLT_ } _N_
- {-defm-} _A_ 2 _U_ 02 _N_ _S_ _!_ _F_ _IF_ARGS_ 1 2 XX 3 _/\_ u0 -> \ (u1 :: {{Num u0}}) (u2 :: u0) -> _APP_ _TYAPP_ patError# { (u0 -> u0) } [ _NOREP_S_ "%DPreludeCore.Num.negate\"", u2 ] _N_ #-}
+ {-defm-} _A_ 2 _U_ 02 _N_ _S_ _!_ _N_ _N_ #-}
abs :: a -> a
{-# GHC_PRAGMA {-meth-} _A_ 1 _U_ 12 _N_ _S_ "S" _F_ _IF_ARGS_ 1 1 C 2 _/\_ u0 -> \ (u1 :: ({{Eq u0}}, {{Text u0}}, u0 -> u0 -> u0, u0 -> u0 -> u0, u0 -> u0 -> u0, u0 -> u0, u0 -> u0, u0 -> u0, Integer -> u0, Int -> u0)) -> case u1 of { _ALG_ _TUP_10 (u2 :: {{Eq u0}}) (u3 :: {{Text u0}}) (u4 :: u0 -> u0 -> u0) (u5 :: u0 -> u0 -> u0) (u6 :: u0 -> u0 -> u0) (u7 :: u0 -> u0) (u8 :: u0 -> u0) (u9 :: u0 -> u0) (ua :: Integer -> u0) (ub :: Int -> u0) -> u8; _NO_DEFLT_ } _N_
- {-defm-} _A_ 2 _U_ 02 _N_ _S_ _!_ _F_ _IF_ARGS_ 1 2 XX 3 _/\_ u0 -> \ (u1 :: {{Num u0}}) (u2 :: u0) -> _APP_ _TYAPP_ patError# { (u0 -> u0) } [ _NOREP_S_ "%DPreludeCore.Num.abs\"", u2 ] _N_ #-}
+ {-defm-} _A_ 2 _U_ 02 _N_ _S_ _!_ _N_ _N_ #-}
signum :: a -> a
{-# GHC_PRAGMA {-meth-} _A_ 1 _U_ 12 _N_ _S_ "S" _F_ _IF_ARGS_ 1 1 C 2 _/\_ u0 -> \ (u1 :: ({{Eq u0}}, {{Text u0}}, u0 -> u0 -> u0, u0 -> u0 -> u0, u0 -> u0 -> u0, u0 -> u0, u0 -> u0, u0 -> u0, Integer -> u0, Int -> u0)) -> case u1 of { _ALG_ _TUP_10 (u2 :: {{Eq u0}}) (u3 :: {{Text u0}}) (u4 :: u0 -> u0 -> u0) (u5 :: u0 -> u0 -> u0) (u6 :: u0 -> u0 -> u0) (u7 :: u0 -> u0) (u8 :: u0 -> u0) (u9 :: u0 -> u0) (ua :: Integer -> u0) (ub :: Int -> u0) -> u9; _NO_DEFLT_ } _N_
- {-defm-} _A_ 2 _U_ 02 _N_ _S_ _!_ _F_ _IF_ARGS_ 1 2 XX 3 _/\_ u0 -> \ (u1 :: {{Num u0}}) (u2 :: u0) -> _APP_ _TYAPP_ patError# { (u0 -> u0) } [ _NOREP_S_ "%DPreludeCore.Num.signum\"", u2 ] _N_ #-}
+ {-defm-} _A_ 2 _U_ 02 _N_ _S_ _!_ _N_ _N_ #-}
fromInteger :: Integer -> a
{-# GHC_PRAGMA {-meth-} _A_ 1 _U_ 12 _N_ _S_ "S" _F_ _IF_ARGS_ 1 1 C 2 _/\_ u0 -> \ (u1 :: ({{Eq u0}}, {{Text u0}}, u0 -> u0 -> u0, u0 -> u0 -> u0, u0 -> u0 -> u0, u0 -> u0, u0 -> u0, u0 -> u0, Integer -> u0, Int -> u0)) -> case u1 of { _ALG_ _TUP_10 (u2 :: {{Eq u0}}) (u3 :: {{Text u0}}) (u4 :: u0 -> u0 -> u0) (u5 :: u0 -> u0 -> u0) (u6 :: u0 -> u0 -> u0) (u7 :: u0 -> u0) (u8 :: u0 -> u0) (u9 :: u0 -> u0) (ua :: Integer -> u0) (ub :: Int -> u0) -> ua; _NO_DEFLT_ } _N_
- {-defm-} _A_ 2 _U_ 02 _N_ _S_ _!_ _F_ _IF_ARGS_ 1 2 XX 3 _/\_ u0 -> \ (u1 :: {{Num u0}}) (u2 :: Integer) -> _APP_ _TYAPP_ patError# { (Integer -> u0) } [ _NOREP_S_ "%DPreludeCore.Num.fromInteger\"", u2 ] _N_ #-}
+ {-defm-} _A_ 2 _U_ 02 _N_ _S_ _!_ _N_ _N_ #-}
fromInt :: Int -> a
{-# GHC_PRAGMA {-meth-} _A_ 1 _U_ 12 _N_ _S_ "S" _F_ _IF_ARGS_ 1 1 C 2 _/\_ u0 -> \ (u1 :: ({{Eq u0}}, {{Text u0}}, u0 -> u0 -> u0, u0 -> u0 -> u0, u0 -> u0 -> u0, u0 -> u0, u0 -> u0, u0 -> u0, Integer -> u0, Int -> u0)) -> case u1 of { _ALG_ _TUP_10 (u2 :: {{Eq u0}}) (u3 :: {{Text u0}}) (u4 :: u0 -> u0 -> u0) (u5 :: u0 -> u0 -> u0) (u6 :: u0 -> u0 -> u0) (u7 :: u0 -> u0) (u8 :: u0 -> u0) (u9 :: u0 -> u0) (ua :: Integer -> u0) (ub :: Int -> u0) -> ub; _NO_DEFLT_ } _N_
{-defm-} _A_ 2 _U_ 11 _N_ _S_ "SL" _F_ _IF_ARGS_ 1 2 CC 6 _/\_ u0 -> \ (u1 :: {{Num u0}}) (u2 :: Int) -> let {(u4 :: Integer) = case u2 of { _ALG_ I# (u3 :: Int#) -> _#_ int2Integer# [] [u3]; _NO_DEFLT_ }} in case u1 of { _ALG_ _TUP_10 (u5 :: {{Eq u0}}) (u6 :: {{Text u0}}) (u7 :: u0 -> u0 -> u0) (u8 :: u0 -> u0 -> u0) (u9 :: u0 -> u0 -> u0) (ua :: u0 -> u0) (ub :: u0 -> u0) (uc :: u0 -> u0) (ud :: Integer -> u0) (ue :: Int -> u0) -> _APP_ ud [ u4 ]; _NO_DEFLT_ } _N_ #-}
{-defm-} _A_ 3 _U_ 122 _N_ _S_ "SLL" _N_ _N_ #-}
(<=) :: a -> a -> Bool
{-# GHC_PRAGMA {-meth-} _A_ 1 _U_ 122 _N_ _S_ "S" _F_ _IF_ARGS_ 1 1 C 2 _/\_ u0 -> \ (u1 :: ({{Eq u0}}, u0 -> u0 -> Bool, u0 -> u0 -> Bool, u0 -> u0 -> Bool, u0 -> u0 -> Bool, u0 -> u0 -> u0, u0 -> u0 -> u0, u0 -> u0 -> _CMP_TAG)) -> case u1 of { _ALG_ _TUP_8 (u2 :: {{Eq u0}}) (u3 :: u0 -> u0 -> Bool) (u4 :: u0 -> u0 -> Bool) (u5 :: u0 -> u0 -> Bool) (u6 :: u0 -> u0 -> Bool) (u7 :: u0 -> u0 -> u0) (u8 :: u0 -> u0 -> u0) (u9 :: u0 -> u0 -> _CMP_TAG) -> u4; _NO_DEFLT_ } _N_
- {-defm-} _A_ 3 _U_ 022 _N_ _S_ _!_ _F_ _IF_ARGS_ 1 3 XXX 4 _/\_ u0 -> \ (u1 :: {{Ord u0}}) (u2 :: u0) (u3 :: u0) -> _APP_ _TYAPP_ patError# { (u0 -> u0 -> Bool) } [ _NOREP_S_ "%DPreludeCore.Ord.(<=)\"", u2, u3 ] _N_ #-}
+ {-defm-} _A_ 3 _U_ 022 _N_ _S_ _!_ _N_ _N_ #-}
(>=) :: a -> a -> Bool
{-# GHC_PRAGMA {-meth-} _A_ 1 _U_ 122 _N_ _S_ "S" _F_ _IF_ARGS_ 1 1 C 2 _/\_ u0 -> \ (u1 :: ({{Eq u0}}, u0 -> u0 -> Bool, u0 -> u0 -> Bool, u0 -> u0 -> Bool, u0 -> u0 -> Bool, u0 -> u0 -> u0, u0 -> u0 -> u0, u0 -> u0 -> _CMP_TAG)) -> case u1 of { _ALG_ _TUP_8 (u2 :: {{Eq u0}}) (u3 :: u0 -> u0 -> Bool) (u4 :: u0 -> u0 -> Bool) (u5 :: u0 -> u0 -> Bool) (u6 :: u0 -> u0 -> Bool) (u7 :: u0 -> u0 -> u0) (u8 :: u0 -> u0 -> u0) (u9 :: u0 -> u0 -> _CMP_TAG) -> u5; _NO_DEFLT_ } _N_
{-defm-} _A_ 3 _U_ 122 _N_ _S_ "SLL" _F_ _IF_ARGS_ 1 3 CXX 4 _/\_ u0 -> \ (u1 :: {{Ord u0}}) (u2 :: u0) (u3 :: u0) -> case u1 of { _ALG_ _TUP_8 (u4 :: {{Eq u0}}) (u5 :: u0 -> u0 -> Bool) (u6 :: u0 -> u0 -> Bool) (u7 :: u0 -> u0 -> Bool) (u8 :: u0 -> u0 -> Bool) (u9 :: u0 -> u0 -> u0) (ua :: u0 -> u0 -> u0) (ub :: u0 -> u0 -> _CMP_TAG) -> _APP_ u6 [ u3, u2 ]; _NO_DEFLT_ } _N_ #-}
class (Num a, Enum a) => Real a {-# GHC_PRAGMA {-superdicts-} _A_ 1 _U_ 1 _N_ _S_ "S" _F_ _IF_ARGS_ 1 1 C 2 _/\_ u0 -> \ (u1 :: ({{Num u0}}, {{Enum u0}}, u0 -> Ratio Integer)) -> case u1 of { _ALG_ _TUP_3 (u2 :: {{Num u0}}) (u3 :: {{Enum u0}}) (u4 :: u0 -> Ratio Integer) -> u2; _NO_DEFLT_ } _N_, _A_ 1 _U_ 1 _N_ _S_ "S" _F_ _IF_ARGS_ 1 1 C 2 _/\_ u0 -> \ (u1 :: ({{Num u0}}, {{Enum u0}}, u0 -> Ratio Integer)) -> case u1 of { _ALG_ _TUP_3 (u2 :: {{Num u0}}) (u3 :: {{Enum u0}}) (u4 :: u0 -> Ratio Integer) -> u3; _NO_DEFLT_ } _N_ #-} where
toRational :: a -> Ratio Integer
{-# GHC_PRAGMA {-meth-} _A_ 1 _U_ 12 _N_ _S_ "S" _F_ _IF_ARGS_ 1 1 C 2 _/\_ u0 -> \ (u1 :: ({{Num u0}}, {{Enum u0}}, u0 -> Ratio Integer)) -> case u1 of { _ALG_ _TUP_3 (u2 :: {{Num u0}}) (u3 :: {{Enum u0}}) (u4 :: u0 -> Ratio Integer) -> u4; _NO_DEFLT_ } _N_
- {-defm-} _A_ 2 _U_ 02 _N_ _S_ _!_ _F_ _IF_ARGS_ 1 2 XX 3 _/\_ u0 -> \ (u1 :: {{Real u0}}) (u2 :: u0) -> _APP_ _TYAPP_ patError# { (u0 -> Ratio Integer) } [ _NOREP_S_ "%DPreludeCore.Real.toRational\"", u2 ] _N_ #-}
+ {-defm-} _A_ 2 _U_ 02 _N_ _S_ _!_ _N_ _N_ #-}
class (RealFrac a, Floating a) => RealFloat a {-# GHC_PRAGMA {-superdicts-} _A_ 1 _U_ 1 _N_ _S_ "S" _F_ _IF_ARGS_ 1 1 C 2 _/\_ u0 -> \ (u1 :: ({{RealFrac u0}}, {{Floating u0}}, u0 -> Integer, u0 -> Int, u0 -> (Int, Int), u0 -> (Integer, Int), Integer -> Int -> u0, u0 -> Int, u0 -> u0, Int -> u0 -> u0)) -> case u1 of { _ALG_ _TUP_10 (u2 :: {{RealFrac u0}}) (u3 :: {{Floating u0}}) (u4 :: u0 -> Integer) (u5 :: u0 -> Int) (u6 :: u0 -> (Int, Int)) (u7 :: u0 -> (Integer, Int)) (u8 :: Integer -> Int -> u0) (u9 :: u0 -> Int) (ua :: u0 -> u0) (ub :: Int -> u0 -> u0) -> u2; _NO_DEFLT_ } _N_, _A_ 1 _U_ 1 _N_ _S_ "S" _F_ _IF_ARGS_ 1 1 C 2 _/\_ u0 -> \ (u1 :: ({{RealFrac u0}}, {{Floating u0}}, u0 -> Integer, u0 -> Int, u0 -> (Int, Int), u0 -> (Integer, Int), Integer -> Int -> u0, u0 -> Int, u0 -> u0, Int -> u0 -> u0)) -> case u1 of { _ALG_ _TUP_10 (u2 :: {{RealFrac u0}}) (u3 :: {{Floating u0}}) (u4 :: u0 -> Integer) (u5 :: u0 -> Int) (u6 :: u0 -> (Int, Int)) (u7 :: u0 -> (Integer, Int)) (u8 :: Integer -> Int -> u0) (u9 :: u0 -> Int) (ua :: u0 -> u0) (ub :: Int -> u0 -> u0) -> u3; _NO_DEFLT_ } _N_ #-} where
floatRadix :: a -> Integer
{-# GHC_PRAGMA {-meth-} _A_ 1 _U_ 12 _N_ _S_ "S" _F_ _IF_ARGS_ 1 1 C 2 _/\_ u0 -> \ (u1 :: ({{RealFrac u0}}, {{Floating u0}}, u0 -> Integer, u0 -> Int, u0 -> (Int, Int), u0 -> (Integer, Int), Integer -> Int -> u0, u0 -> Int, u0 -> u0, Int -> u0 -> u0)) -> case u1 of { _ALG_ _TUP_10 (u2 :: {{RealFrac u0}}) (u3 :: {{Floating u0}}) (u4 :: u0 -> Integer) (u5 :: u0 -> Int) (u6 :: u0 -> (Int, Int)) (u7 :: u0 -> (Integer, Int)) (u8 :: Integer -> Int -> u0) (u9 :: u0 -> Int) (ua :: u0 -> u0) (ub :: Int -> u0 -> u0) -> u4; _NO_DEFLT_ } _N_
- {-defm-} _A_ 2 _U_ 02 _N_ _S_ _!_ _F_ _IF_ARGS_ 1 2 XX 3 _/\_ u0 -> \ (u1 :: {{RealFloat u0}}) (u2 :: u0) -> _APP_ _TYAPP_ patError# { (u0 -> Integer) } [ _NOREP_S_ "%DPreludeCore.RealFloat.floatRadix\"", u2 ] _N_ #-}
+ {-defm-} _A_ 2 _U_ 02 _N_ _S_ _!_ _N_ _N_ #-}
floatDigits :: a -> Int
{-# GHC_PRAGMA {-meth-} _A_ 1 _U_ 12 _N_ _S_ "S" _F_ _IF_ARGS_ 1 1 C 2 _/\_ u0 -> \ (u1 :: ({{RealFrac u0}}, {{Floating u0}}, u0 -> Integer, u0 -> Int, u0 -> (Int, Int), u0 -> (Integer, Int), Integer -> Int -> u0, u0 -> Int, u0 -> u0, Int -> u0 -> u0)) -> case u1 of { _ALG_ _TUP_10 (u2 :: {{RealFrac u0}}) (u3 :: {{Floating u0}}) (u4 :: u0 -> Integer) (u5 :: u0 -> Int) (u6 :: u0 -> (Int, Int)) (u7 :: u0 -> (Integer, Int)) (u8 :: Integer -> Int -> u0) (u9 :: u0 -> Int) (ua :: u0 -> u0) (ub :: Int -> u0 -> u0) -> u5; _NO_DEFLT_ } _N_
- {-defm-} _A_ 2 _U_ 02 _N_ _S_ _!_ _F_ _IF_ARGS_ 1 2 XX 3 _/\_ u0 -> \ (u1 :: {{RealFloat u0}}) (u2 :: u0) -> _APP_ _TYAPP_ patError# { (u0 -> Int) } [ _NOREP_S_ "%DPreludeCore.RealFloat.floatDigits\"", u2 ] _N_ #-}
+ {-defm-} _A_ 2 _U_ 02 _N_ _S_ _!_ _N_ _N_ #-}
floatRange :: a -> (Int, Int)
{-# GHC_PRAGMA {-meth-} _A_ 1 _U_ 12 _N_ _S_ "S" _F_ _IF_ARGS_ 1 1 C 2 _/\_ u0 -> \ (u1 :: ({{RealFrac u0}}, {{Floating u0}}, u0 -> Integer, u0 -> Int, u0 -> (Int, Int), u0 -> (Integer, Int), Integer -> Int -> u0, u0 -> Int, u0 -> u0, Int -> u0 -> u0)) -> case u1 of { _ALG_ _TUP_10 (u2 :: {{RealFrac u0}}) (u3 :: {{Floating u0}}) (u4 :: u0 -> Integer) (u5 :: u0 -> Int) (u6 :: u0 -> (Int, Int)) (u7 :: u0 -> (Integer, Int)) (u8 :: Integer -> Int -> u0) (u9 :: u0 -> Int) (ua :: u0 -> u0) (ub :: Int -> u0 -> u0) -> u6; _NO_DEFLT_ } _N_
- {-defm-} _A_ 2 _U_ 02 _N_ _S_ _!_ _F_ _IF_ARGS_ 1 2 XX 3 _/\_ u0 -> \ (u1 :: {{RealFloat u0}}) (u2 :: u0) -> _APP_ _TYAPP_ patError# { (u0 -> (Int, Int)) } [ _NOREP_S_ "%DPreludeCore.RealFloat.floatRange\"", u2 ] _N_ #-}
+ {-defm-} _A_ 2 _U_ 02 _N_ _S_ _!_ _N_ _N_ #-}
decodeFloat :: a -> (Integer, Int)
{-# GHC_PRAGMA {-meth-} _A_ 1 _U_ 12 _N_ _S_ "S" _F_ _IF_ARGS_ 1 1 C 2 _/\_ u0 -> \ (u1 :: ({{RealFrac u0}}, {{Floating u0}}, u0 -> Integer, u0 -> Int, u0 -> (Int, Int), u0 -> (Integer, Int), Integer -> Int -> u0, u0 -> Int, u0 -> u0, Int -> u0 -> u0)) -> case u1 of { _ALG_ _TUP_10 (u2 :: {{RealFrac u0}}) (u3 :: {{Floating u0}}) (u4 :: u0 -> Integer) (u5 :: u0 -> Int) (u6 :: u0 -> (Int, Int)) (u7 :: u0 -> (Integer, Int)) (u8 :: Integer -> Int -> u0) (u9 :: u0 -> Int) (ua :: u0 -> u0) (ub :: Int -> u0 -> u0) -> u7; _NO_DEFLT_ } _N_
- {-defm-} _A_ 2 _U_ 02 _N_ _S_ _!_ _F_ _IF_ARGS_ 1 2 XX 3 _/\_ u0 -> \ (u1 :: {{RealFloat u0}}) (u2 :: u0) -> _APP_ _TYAPP_ patError# { (u0 -> (Integer, Int)) } [ _NOREP_S_ "%DPreludeCore.RealFloat.decodeFloat\"", u2 ] _N_ #-}
+ {-defm-} _A_ 2 _U_ 02 _N_ _S_ _!_ _N_ _N_ #-}
encodeFloat :: Integer -> Int -> a
{-# GHC_PRAGMA {-meth-} _A_ 1 _U_ 122 _N_ _S_ "S" _F_ _IF_ARGS_ 1 1 C 2 _/\_ u0 -> \ (u1 :: ({{RealFrac u0}}, {{Floating u0}}, u0 -> Integer, u0 -> Int, u0 -> (Int, Int), u0 -> (Integer, Int), Integer -> Int -> u0, u0 -> Int, u0 -> u0, Int -> u0 -> u0)) -> case u1 of { _ALG_ _TUP_10 (u2 :: {{RealFrac u0}}) (u3 :: {{Floating u0}}) (u4 :: u0 -> Integer) (u5 :: u0 -> Int) (u6 :: u0 -> (Int, Int)) (u7 :: u0 -> (Integer, Int)) (u8 :: Integer -> Int -> u0) (u9 :: u0 -> Int) (ua :: u0 -> u0) (ub :: Int -> u0 -> u0) -> u8; _NO_DEFLT_ } _N_
- {-defm-} _A_ 3 _U_ 022 _N_ _S_ _!_ _F_ _IF_ARGS_ 1 3 XXX 4 _/\_ u0 -> \ (u1 :: {{RealFloat u0}}) (u2 :: Integer) (u3 :: Int) -> _APP_ _TYAPP_ patError# { (Integer -> Int -> u0) } [ _NOREP_S_ "%DPreludeCore.RealFloat.encodeFloat\"", u2, u3 ] _N_ #-}
+ {-defm-} _A_ 3 _U_ 022 _N_ _S_ _!_ _N_ _N_ #-}
exponent :: a -> Int
{-# GHC_PRAGMA {-meth-} _A_ 1 _U_ 12 _N_ _S_ "S" _F_ _IF_ARGS_ 1 1 C 2 _/\_ u0 -> \ (u1 :: ({{RealFrac u0}}, {{Floating u0}}, u0 -> Integer, u0 -> Int, u0 -> (Int, Int), u0 -> (Integer, Int), Integer -> Int -> u0, u0 -> Int, u0 -> u0, Int -> u0 -> u0)) -> case u1 of { _ALG_ _TUP_10 (u2 :: {{RealFrac u0}}) (u3 :: {{Floating u0}}) (u4 :: u0 -> Integer) (u5 :: u0 -> Int) (u6 :: u0 -> (Int, Int)) (u7 :: u0 -> (Integer, Int)) (u8 :: Integer -> Int -> u0) (u9 :: u0 -> Int) (ua :: u0 -> u0) (ub :: Int -> u0 -> u0) -> u9; _NO_DEFLT_ } _N_
{-defm-} _A_ 2 _U_ 12 _N_ _S_ "SL" _N_ _N_ #-}
class (Real a, Fractional a) => RealFrac a {-# GHC_PRAGMA {-superdicts-} _A_ 1 _U_ 1 _N_ _S_ "S" _F_ _IF_ARGS_ 1 1 C 2 _/\_ u0 -> \ (u1 :: ({{Real u0}}, {{Fractional u0}}, (_forall_ z$z1 =>{{Integral z$z1}} -> u0 -> (z$z1, u0)), (_forall_ z$z1 =>{{Integral z$z1}} -> u0 -> z$z1), (_forall_ z$z1 =>{{Integral z$z1}} -> u0 -> z$z1), (_forall_ z$z1 =>{{Integral z$z1}} -> u0 -> z$z1), (_forall_ z$z1 =>{{Integral z$z1}} -> u0 -> z$z1))) -> case u1 of { _ALG_ _TUP_7 (u2 :: {{Real u0}}) (u3 :: {{Fractional u0}}) (u4 :: _forall_ a$z1 =>{{Integral a$z1}} -> u0 -> (a$z1, u0)) (u5 :: _forall_ a$z1 =>{{Integral a$z1}} -> u0 -> a$z1) (u6 :: _forall_ a$z1 =>{{Integral a$z1}} -> u0 -> a$z1) (u7 :: _forall_ a$z1 =>{{Integral a$z1}} -> u0 -> a$z1) (u8 :: _forall_ a$z1 =>{{Integral a$z1}} -> u0 -> a$z1) -> u2; _NO_DEFLT_ } _N_, _A_ 1 _U_ 1 _N_ _S_ "S" _F_ _IF_ARGS_ 1 1 C 2 _/\_ u0 -> \ (u1 :: ({{Real u0}}, {{Fractional u0}}, (_forall_ z$z1 =>{{Integral z$z1}} -> u0 -> (z$z1, u0)), (_forall_ z$z1 =>{{Integral z$z1}} -> u0 -> z$z1), (_forall_ z$z1 =>{{Integral z$z1}} -> u0 -> z$z1), (_forall_ z$z1 =>{{Integral z$z1}} -> u0 -> z$z1), (_forall_ z$z1 =>{{Integral z$z1}} -> u0 -> z$z1))) -> case u1 of { _ALG_ _TUP_7 (u2 :: {{Real u0}}) (u3 :: {{Fractional u0}}) (u4 :: _forall_ a$z1 =>{{Integral a$z1}} -> u0 -> (a$z1, u0)) (u5 :: _forall_ a$z1 =>{{Integral a$z1}} -> u0 -> a$z1) (u6 :: _forall_ a$z1 =>{{Integral a$z1}} -> u0 -> a$z1) (u7 :: _forall_ a$z1 =>{{Integral a$z1}} -> u0 -> a$z1) (u8 :: _forall_ a$z1 =>{{Integral a$z1}} -> u0 -> a$z1) -> u3; _NO_DEFLT_ } _N_ #-} where
properFraction :: Integral b => a -> (b, a)
{-# GHC_PRAGMA {-meth-} _A_ 2 _U_ 122 _N_ _S_ "SL" _F_ _IF_ARGS_ 2 2 CX 3 _/\_ u0 u1 -> \ (u2 :: ({{Real u0}}, {{Fractional u0}}, (_forall_ z$z1 =>{{Integral z$z1}} -> u0 -> (z$z1, u0)), (_forall_ z$z1 =>{{Integral z$z1}} -> u0 -> z$z1), (_forall_ z$z1 =>{{Integral z$z1}} -> u0 -> z$z1), (_forall_ z$z1 =>{{Integral z$z1}} -> u0 -> z$z1), (_forall_ z$z1 =>{{Integral z$z1}} -> u0 -> z$z1))) (u3 :: {{Integral u1}}) -> case u2 of { _ALG_ _TUP_7 (u4 :: {{Real u0}}) (u5 :: {{Fractional u0}}) (u6 :: _forall_ a$z1 =>{{Integral a$z1}} -> u0 -> (a$z1, u0)) (u7 :: _forall_ a$z1 =>{{Integral a$z1}} -> u0 -> a$z1) (u8 :: _forall_ a$z1 =>{{Integral a$z1}} -> u0 -> a$z1) (u9 :: _forall_ a$z1 =>{{Integral a$z1}} -> u0 -> a$z1) (ua :: _forall_ a$z1 =>{{Integral a$z1}} -> u0 -> a$z1) -> _APP_ _TYAPP_ u6 { u1 } [ u3 ]; _NO_DEFLT_ } _N_
- {-defm-} _A_ 3 _U_ 002 _N_ _S_ _!_ _F_ _IF_ARGS_ 2 3 XXX 3 _/\_ u0 u1 -> \ (u2 :: {{RealFrac u0}}) (u3 :: {{Integral u1}}) (u4 :: u0) -> _APP_ _TYAPP_ patError# { (u0 -> (u1, u0)) } [ _NOREP_S_ "%DPreludeCore.RealFrac.properFraction\"", u4 ] _N_ #-}
+ {-defm-} _A_ 3 _U_ 002 _N_ _S_ _!_ _N_ _N_ #-}
truncate :: Integral b => a -> b
{-# GHC_PRAGMA {-meth-} _A_ 2 _U_ 122 _N_ _S_ "SL" _F_ _IF_ARGS_ 2 2 CX 3 _/\_ u0 u1 -> \ (u2 :: ({{Real u0}}, {{Fractional u0}}, (_forall_ z$z1 =>{{Integral z$z1}} -> u0 -> (z$z1, u0)), (_forall_ z$z1 =>{{Integral z$z1}} -> u0 -> z$z1), (_forall_ z$z1 =>{{Integral z$z1}} -> u0 -> z$z1), (_forall_ z$z1 =>{{Integral z$z1}} -> u0 -> z$z1), (_forall_ z$z1 =>{{Integral z$z1}} -> u0 -> z$z1))) (u3 :: {{Integral u1}}) -> case u2 of { _ALG_ _TUP_7 (u4 :: {{Real u0}}) (u5 :: {{Fractional u0}}) (u6 :: _forall_ a$z1 =>{{Integral a$z1}} -> u0 -> (a$z1, u0)) (u7 :: _forall_ a$z1 =>{{Integral a$z1}} -> u0 -> a$z1) (u8 :: _forall_ a$z1 =>{{Integral a$z1}} -> u0 -> a$z1) (u9 :: _forall_ a$z1 =>{{Integral a$z1}} -> u0 -> a$z1) (ua :: _forall_ a$z1 =>{{Integral a$z1}} -> u0 -> a$z1) -> _APP_ _TYAPP_ u7 { u1 } [ u3 ]; _NO_DEFLT_ } _N_
{-defm-} _A_ 2 _U_ 122 _N_ _S_ "SL" _N_ _N_ #-}
class Text a where
readsPrec :: Int -> [Char] -> [(a, [Char])]
{-# GHC_PRAGMA {-meth-} _A_ 1 _U_ 122 _N_ _S_ "S" _F_ _IF_ARGS_ 1 1 C 2 _/\_ u0 -> \ (u1 :: (Int -> [Char] -> [(u0, [Char])], Int -> u0 -> [Char] -> [Char], [Char] -> [([u0], [Char])], [u0] -> [Char] -> [Char])) -> case u1 of { _ALG_ _TUP_4 (u2 :: Int -> [Char] -> [(u0, [Char])]) (u3 :: Int -> u0 -> [Char] -> [Char]) (u4 :: [Char] -> [([u0], [Char])]) (u5 :: [u0] -> [Char] -> [Char]) -> u2; _NO_DEFLT_ } _N_
- {-defm-} _A_ 3 _U_ 022 _N_ _S_ _!_ _F_ _IF_ARGS_ 1 3 XXX 4 _/\_ u0 -> \ (u1 :: {{Text u0}}) (u2 :: Int) (u3 :: [Char]) -> _APP_ _TYAPP_ patError# { (Int -> [Char] -> [(u0, [Char])]) } [ _NOREP_S_ "%DPreludeCore.Text.readsPrec\"", u2, u3 ] _N_ #-}
+ {-defm-} _A_ 3 _U_ 022 _N_ _S_ _!_ _N_ _N_ #-}
showsPrec :: Int -> a -> [Char] -> [Char]
{-# GHC_PRAGMA {-meth-} _A_ 1 _U_ 1222 _N_ _S_ "S" _F_ _IF_ARGS_ 1 1 C 2 _/\_ u0 -> \ (u1 :: (Int -> [Char] -> [(u0, [Char])], Int -> u0 -> [Char] -> [Char], [Char] -> [([u0], [Char])], [u0] -> [Char] -> [Char])) -> case u1 of { _ALG_ _TUP_4 (u2 :: Int -> [Char] -> [(u0, [Char])]) (u3 :: Int -> u0 -> [Char] -> [Char]) (u4 :: [Char] -> [([u0], [Char])]) (u5 :: [u0] -> [Char] -> [Char]) -> u3; _NO_DEFLT_ } _N_
- {-defm-} _A_ 4 _U_ 0222 _N_ _S_ _!_ _F_ _IF_ARGS_ 1 4 XXXX 5 _/\_ u0 -> \ (u1 :: {{Text u0}}) (u2 :: Int) (u3 :: u0) (u4 :: [Char]) -> _APP_ _TYAPP_ patError# { (Int -> u0 -> [Char] -> [Char]) } [ _NOREP_S_ "%DPreludeCore.Text.showsPrec\"", u2, u3, u4 ] _N_ #-}
+ {-defm-} _A_ 4 _U_ 0222 _N_ _S_ _!_ _N_ _N_ #-}
readList :: [Char] -> [([a], [Char])]
{-# GHC_PRAGMA {-meth-} _A_ 1 _U_ 12 _N_ _S_ "S" _F_ _IF_ARGS_ 1 1 C 2 _/\_ u0 -> \ (u1 :: (Int -> [Char] -> [(u0, [Char])], Int -> u0 -> [Char] -> [Char], [Char] -> [([u0], [Char])], [u0] -> [Char] -> [Char])) -> case u1 of { _ALG_ _TUP_4 (u2 :: Int -> [Char] -> [(u0, [Char])]) (u3 :: Int -> u0 -> [Char] -> [Char]) (u4 :: [Char] -> [([u0], [Char])]) (u5 :: [u0] -> [Char] -> [Char]) -> u4; _NO_DEFLT_ } _N_
- {-defm-} _A_ 1 _U_ 22 _N_ _N_ _F_ _IF_ARGS_ 0 0 X 1 _ORIG_ PreludeCore _readList _N_ #-}
+ {-defm-} _A_ 1 _U_ 12 _N_ _N_ _N_ _N_ #-}
showList :: [a] -> [Char] -> [Char]
{-# GHC_PRAGMA {-meth-} _A_ 1 _U_ 122 _N_ _S_ "S" _F_ _IF_ARGS_ 1 1 C 2 _/\_ u0 -> \ (u1 :: (Int -> [Char] -> [(u0, [Char])], Int -> u0 -> [Char] -> [Char], [Char] -> [([u0], [Char])], [u0] -> [Char] -> [Char])) -> case u1 of { _ALG_ _TUP_4 (u2 :: Int -> [Char] -> [(u0, [Char])]) (u3 :: Int -> u0 -> [Char] -> [Char]) (u4 :: [Char] -> [([u0], [Char])]) (u5 :: [u0] -> [Char] -> [Char]) -> u5; _NO_DEFLT_ } _N_
- {-defm-} _A_ 1 _U_ 212 _N_ _N_ _F_ _IF_ARGS_ 0 0 X 1 _ORIG_ PreludeCore _showList _N_ #-}
+ {-defm-} _A_ 1 _U_ 112 _N_ _N_ _N_ _N_ #-}
class _CCallable a
class _CReturnable a
data Array a b {-# GHC_PRAGMA _Array (a, a) (Array# b) #-}
data Assoc a b = (:=) a b
data _ByteArray a {-# GHC_PRAGMA _ByteArray (a, a) ByteArray# #-}
data Bin
-data Complex a = (:+) a a
+data Complex a = (:+) a a {-# GHC_PRAGMA _SPECIALISE_ [ Double# ] #-}
data _MutableArray a b c {-# GHC_PRAGMA _MutableArray (b, b) (MutableArray# a c) #-}
data _MutableByteArray a b {-# GHC_PRAGMA _MutableByteArray (b, b) (MutableByteArray# a) #-}
type BinCont = Bin -> [Response] -> [Request]
type ReadS a = [Char] -> [(a, [Char])]
type ShowS = [Char] -> [Char]
data _FILE {-# GHC_PRAGMA _FILE Addr# #-}
+__i0 :: Num a => a
+ {-# GHC_PRAGMA _A_ 1 _U_ 1 _N_ _S_ "U(AAAAAAAAAS)" {_A_ 1 _U_ 1 _N_ _N_ _N_ _N_} _N_ _SPECIALISE_ [ Double ] 1 { _A_ 0 _N_ _N_ _N_ _F_ _IF_ARGS_ 0 0 X 2 _!_ D# [] [0.0000000000000000##] _N_ }, [ Int ] 1 { _A_ 0 _N_ _N_ _N_ _F_ _IF_ARGS_ 0 0 X 2 _!_ I# [] [0#] _N_ }, [ Integer ] 1 { _A_ 0 _N_ _N_ _N_ _N_ _N_ }, [ (Ratio Integer) ] 1 { _A_ 0 _N_ _N_ _N_ _N_ _N_ }, [ (Complex Double) ] 1 { _A_ 0 _N_ _N_ _N_ _N_ _N_ } #-}
+__i1 :: Num a => a
+ {-# GHC_PRAGMA _A_ 1 _U_ 1 _N_ _S_ "U(AAAAAAAAAS)" {_A_ 1 _U_ 1 _N_ _N_ _N_ _N_} _N_ _SPECIALISE_ [ Double ] 1 { _A_ 0 _N_ _N_ _N_ _F_ _IF_ARGS_ 0 0 X 2 _!_ D# [] [1.0000000000000000##] _N_ }, [ Int ] 1 { _A_ 0 _N_ _N_ _N_ _F_ _IF_ARGS_ 0 0 X 2 _!_ I# [] [1#] _N_ }, [ Integer ] 1 { _A_ 0 _N_ _N_ _N_ _N_ _N_ }, [ (Ratio Integer) ] 1 { _A_ 0 _N_ _N_ _N_ _N_ _N_ }, [ (Complex Double) ] 1 { _A_ 0 _N_ _N_ _N_ _N_ _N_ } #-}
+__i10 :: Num a => a
+ {-# GHC_PRAGMA _A_ 1 _U_ 1 _N_ _S_ "U(AAAAAAAAAS)" {_A_ 1 _U_ 1 _N_ _N_ _N_ _N_} _N_ _SPECIALISE_ [ Double ] 1 { _A_ 0 _N_ _N_ _N_ _F_ _IF_ARGS_ 0 0 X 2 _!_ D# [] [10.000000000000000##] _N_ }, [ Int ] 1 { _A_ 0 _N_ _N_ _N_ _F_ _IF_ARGS_ 0 0 X 2 _!_ I# [] [10#] _N_ }, [ Integer ] 1 { _A_ 0 _N_ _N_ _N_ _N_ _N_ }, [ (Ratio Integer) ] 1 { _A_ 0 _N_ _N_ _N_ _N_ _N_ }, [ (Complex Double) ] 1 { _A_ 0 _N_ _N_ _N_ _N_ _N_ } #-}
+__i16 :: Num a => a
+ {-# GHC_PRAGMA _A_ 1 _U_ 1 _N_ _S_ "U(AAAAAAAAAS)" {_A_ 1 _U_ 1 _N_ _N_ _N_ _N_} _N_ _SPECIALISE_ [ Double ] 1 { _A_ 0 _N_ _N_ _N_ _F_ _IF_ARGS_ 0 0 X 2 _!_ D# [] [16.000000000000000##] _N_ }, [ Int ] 1 { _A_ 0 _N_ _N_ _N_ _F_ _IF_ARGS_ 0 0 X 2 _!_ I# [] [16#] _N_ }, [ Integer ] 1 { _A_ 0 _N_ _N_ _N_ _N_ _N_ }, [ (Ratio Integer) ] 1 { _A_ 0 _N_ _N_ _N_ _N_ _N_ }, [ (Complex Double) ] 1 { _A_ 0 _N_ _N_ _N_ _N_ _N_ } #-}
+__i2 :: Num a => a
+ {-# GHC_PRAGMA _A_ 1 _U_ 1 _N_ _S_ "U(AAAAAAAAAS)" {_A_ 1 _U_ 1 _N_ _N_ _N_ _N_} _N_ _SPECIALISE_ [ Double ] 1 { _A_ 0 _N_ _N_ _N_ _F_ _IF_ARGS_ 0 0 X 2 _!_ D# [] [2.0000000000000000##] _N_ }, [ Int ] 1 { _A_ 0 _N_ _N_ _N_ _F_ _IF_ARGS_ 0 0 X 2 _!_ I# [] [2#] _N_ }, [ Integer ] 1 { _A_ 0 _N_ _N_ _N_ _N_ _N_ }, [ (Ratio Integer) ] 1 { _A_ 0 _N_ _N_ _N_ _N_ _N_ }, [ (Complex Double) ] 1 { _A_ 0 _N_ _N_ _N_ _N_ _N_ } #-}
+__i8 :: Num a => a
+ {-# GHC_PRAGMA _A_ 1 _U_ 1 _N_ _S_ "U(AAAAAAAAAS)" {_A_ 1 _U_ 1 _N_ _N_ _N_ _N_} _N_ _SPECIALISE_ [ Double ] 1 { _A_ 0 _N_ _N_ _N_ _F_ _IF_ARGS_ 0 0 X 2 _!_ D# [] [8.0000000000000000##] _N_ }, [ Int ] 1 { _A_ 0 _N_ _N_ _N_ _F_ _IF_ARGS_ 0 0 X 2 _!_ I# [] [8#] _N_ }, [ Integer ] 1 { _A_ 0 _N_ _N_ _N_ _N_ _N_ }, [ (Ratio Integer) ] 1 { _A_ 0 _N_ _N_ _N_ _N_ _N_ }, [ (Complex Double) ] 1 { _A_ 0 _N_ _N_ _N_ _N_ _N_ } #-}
+__im1 :: Num a => a
+ {-# GHC_PRAGMA _A_ 1 _U_ 1 _N_ _S_ "U(AAAAAAAAAS)" {_A_ 1 _U_ 1 _N_ _N_ _N_ _N_} _N_ _SPECIALISE_ [ Double ] 1 { _A_ 0 _N_ _N_ _N_ _F_ _IF_ARGS_ 0 0 X 2 _!_ D# [] [-1.0000000000000000##] _N_ }, [ Int ] 1 { _A_ 0 _N_ _N_ _N_ _F_ _IF_ARGS_ 0 0 X 2 _!_ I# [] [-1#] _N_ }, [ Integer ] 1 { _A_ 0 _N_ _N_ _N_ _N_ _N_ }, [ (Ratio Integer) ] 1 { _A_ 0 _N_ _N_ _N_ _N_ _N_ }, [ (Complex Double) ] 1 { _A_ 0 _N_ _N_ _N_ _N_ _N_ } #-}
+__integer0 :: Integer
+ {-# GHC_PRAGMA _A_ 0 _N_ _N_ _N_ _N_ _N_ #-}
+__integer1 :: Integer
+ {-# GHC_PRAGMA _A_ 0 _N_ _N_ _N_ _N_ _N_ #-}
+__integer2 :: Integer
+ {-# GHC_PRAGMA _A_ 0 _N_ _N_ _N_ _N_ _N_ #-}
+__integerm1 :: Integer
+ {-# GHC_PRAGMA _A_ 0 _N_ _N_ _N_ _N_ _N_ #-}
+__rhalf :: Fractional a => a
+ {-# GHC_PRAGMA _A_ 1 _U_ 1 _N_ _S_ "U(AAAS)" {_A_ 1 _U_ 1 _N_ _N_ _N_ _N_} _N_ _SPECIALISE_ [ Double ] 1 { _A_ 0 _N_ _N_ _N_ _N_ _N_ }, [ (Ratio Integer) ] 1 { _A_ 0 _N_ _N_ _N_ _F_ _IF_ARGS_ 0 0 X 3 _!_ (:%) [Integer] [_SPEC_ _ORIG_ PreludeCore __i1 [ (Integer) ], _SPEC_ _ORIG_ PreludeCore __i2 [ (Integer) ]] _N_ }, [ (Complex Double) ] 1 { _A_ 0 _N_ _N_ _N_ _N_ _N_ } #-}
+_fromRational :: RealFloat a => Ratio Integer -> a
+ {-# GHC_PRAGMA _A_ 2 _U_ 22 _N_ _N_ _N_ _SPECIALISE_ [ Double ] 1 { _A_ 1 _U_ 1 _N_ _S_ "U(U(PPP)U(PPP))" {_A_ 4 _U_ 2221 _N_ _N_ _N_ _N_} _N_ _N_ } #-}
instance Enum ()
{-# GHC_PRAGMA _M_ PreludeBuiltin {-dfun-} _A_ 0 _N_ _N_ _N_ _F_ _IF_ARGS_ 0 0 X 6 _!_ _TUP_5 [{{Ord ()}}, (() -> [()]), (() -> () -> [()]), (() -> () -> [()]), (() -> () -> () -> [()])] [_DFUN_ Ord (()), _CONSTM_ Enum enumFrom (()), _CONSTM_ Enum enumFromThen (()), _CONSTM_ Enum enumFromTo (()), _CONSTM_ Enum enumFromThenTo (())] _N_
- enumFrom = _A_ 1 _U_ 2 _N_ _S_ "E" _N_ _N_,
- enumFromThen = _A_ 2 _U_ 21 _N_ _S_ "EE" _F_ _IF_ARGS_ 0 2 CC 7 \ (u0 :: ()) (u1 :: ()) -> case u0 of { _ALG_ _TUP_0 -> case u1 of { _ALG_ _TUP_0 -> let {(u2 :: [()]) = _!_ _NIL_ [()] []} in _!_ (:) [()] [u0, u2]; _NO_DEFLT_ }; _NO_DEFLT_ } _N_,
- enumFromTo = _A_ 2 _U_ 21 _N_ _S_ "EE" _F_ _IF_ARGS_ 0 2 CC 7 \ (u0 :: ()) (u1 :: ()) -> case u0 of { _ALG_ _TUP_0 -> case u1 of { _ALG_ _TUP_0 -> let {(u2 :: [()]) = _!_ _NIL_ [()] []} in _!_ (:) [()] [u0, u2]; _NO_DEFLT_ }; _NO_DEFLT_ } _N_,
- enumFromThenTo = _A_ 3 _U_ 211 _N_ _S_ "EEE" _F_ _IF_ARGS_ 0 3 CCC 8 \ (u0 :: ()) (u1 :: ()) (u2 :: ()) -> case u0 of { _ALG_ _TUP_0 -> case u1 of { _ALG_ _TUP_0 -> case u2 of { _ALG_ _TUP_0 -> let {(u3 :: [()]) = _!_ _NIL_ [()] []} in _!_ (:) [()] [u0, u3]; _NO_DEFLT_ }; _NO_DEFLT_ }; _NO_DEFLT_ } _N_ #-}
+ enumFrom = { _A_ 1 _U_ 2 _N_ _S_ "E" _N_ _N_ },
+ enumFromThen = { _A_ 2 _U_ 21 _N_ _S_ "EE" _F_ _IF_ARGS_ 0 2 CC 7 \ (u0 :: ()) (u1 :: ()) -> case u0 of { _ALG_ _TUP_0 -> case u1 of { _ALG_ _TUP_0 -> let {(u2 :: [()]) = _!_ _NIL_ [()] []} in _!_ (:) [()] [u0, u2]; _NO_DEFLT_ }; _NO_DEFLT_ } _N_ },
+ enumFromTo = { _A_ 2 _U_ 21 _N_ _S_ "EE" _F_ _IF_ARGS_ 0 2 CC 7 \ (u0 :: ()) (u1 :: ()) -> case u0 of { _ALG_ _TUP_0 -> case u1 of { _ALG_ _TUP_0 -> let {(u2 :: [()]) = _!_ _NIL_ [()] []} in _!_ (:) [()] [u0, u2]; _NO_DEFLT_ }; _NO_DEFLT_ } _N_ },
+ enumFromThenTo = { _A_ 3 _U_ 211 _N_ _S_ "EEE" _F_ _IF_ARGS_ 0 3 CCC 8 \ (u0 :: ()) (u1 :: ()) (u2 :: ()) -> case u0 of { _ALG_ _TUP_0 -> case u1 of { _ALG_ _TUP_0 -> case u2 of { _ALG_ _TUP_0 -> let {(u3 :: [()]) = _!_ _NIL_ [()] []} in _!_ (:) [()] [u0, u3]; _NO_DEFLT_ }; _NO_DEFLT_ }; _NO_DEFLT_ } _N_ } #-}
instance Enum Bool
{-# GHC_PRAGMA _M_ PreludeCore {-dfun-} _A_ 0 _N_ _N_ _N_ _F_ _IF_ARGS_ 0 0 X 6 _!_ _TUP_5 [{{Ord Bool}}, (Bool -> [Bool]), (Bool -> Bool -> [Bool]), (Bool -> Bool -> [Bool]), (Bool -> Bool -> Bool -> [Bool])] [_DFUN_ Ord (Bool), _CONSTM_ Enum enumFrom (Bool), _CONSTM_ Enum enumFromThen (Bool), _CONSTM_ Enum enumFromTo (Bool), _CONSTM_ Enum enumFromThenTo (Bool)] _N_
- enumFrom = _A_ 1 _U_ 2 _N_ _S_ "E" _N_ _N_,
- enumFromThen = _A_ 2 _U_ 22 _N_ _S_ "EE" _N_ _N_,
- enumFromTo = _A_ 2 _U_ 22 _N_ _N_ _N_ _N_,
- enumFromThenTo = _A_ 3 _U_ 222 _N_ _N_ _N_ _N_ #-}
+ enumFrom = { _A_ 1 _U_ 2 _N_ _S_ "E" _N_ _N_ },
+ enumFromThen = { _A_ 2 _U_ 22 _N_ _S_ "EE" _N_ _N_ },
+ enumFromTo = { _A_ 2 _U_ 22 _N_ _S_ "EL" _N_ _N_ },
+ enumFromThenTo = { _A_ 3 _U_ 222 _N_ _S_ "EEL" _N_ _N_ } #-}
instance Enum Char
{-# GHC_PRAGMA _M_ PreludeCore {-dfun-} _A_ 0 _N_ _N_ _N_ _F_ _IF_ARGS_ 0 0 X 6 _!_ _TUP_5 [{{Ord Char}}, (Char -> [Char]), (Char -> Char -> [Char]), (Char -> Char -> [Char]), (Char -> Char -> Char -> [Char])] [_DFUN_ Ord (Char), _CONSTM_ Enum enumFrom (Char), _CONSTM_ Enum enumFromThen (Char), _CONSTM_ Enum enumFromTo (Char), _CONSTM_ Enum enumFromThenTo (Char)] _N_
- enumFrom = _A_ 1 _U_ 1 _N_ _S_ "U(P)" {_A_ 1 _U_ 2 _N_ _N_ _N_ _N_} _N_ _N_,
- enumFromThen = _A_ 2 _U_ 22 _N_ _N_ _N_ _N_,
- enumFromTo = _A_ 2 _U_ 22 _N_ _N_ _N_ _N_,
- enumFromThenTo = _A_ 3 _U_ 222 _N_ _N_ _N_ _N_ #-}
+ enumFrom = { _A_ 1 _U_ 1 _N_ _S_ "U(P)" {_A_ 1 _U_ 2 _N_ _N_ _N_ _N_} _N_ _N_ },
+ enumFromThen = { _A_ 2 _U_ 22 _N_ _N_ _N_ _N_ },
+ enumFromTo = { _A_ 2 _U_ 12 _N_ _S_ "U(P)L" {_A_ 2 _U_ 22 _N_ _N_ _N_ _N_} _N_ _N_ },
+ enumFromThenTo = { _A_ 3 _U_ 222 _N_ _N_ _N_ _N_ } #-}
instance Enum Double
{-# GHC_PRAGMA _M_ PreludeCore {-dfun-} _A_ 0 _N_ _N_ _N_ _F_ _IF_ARGS_ 0 0 X 6 _!_ _TUP_5 [{{Ord Double}}, (Double -> [Double]), (Double -> Double -> [Double]), (Double -> Double -> [Double]), (Double -> Double -> Double -> [Double])] [_DFUN_ Ord (Double), _CONSTM_ Enum enumFrom (Double), _CONSTM_ Enum enumFromThen (Double), _CONSTM_ Enum enumFromTo (Double), _CONSTM_ Enum enumFromThenTo (Double)] _N_
- enumFrom = _A_ 1 _U_ 2 _N_ _N_ _N_ _N_,
- enumFromThen = _A_ 2 _U_ 21 _N_ _N_ _N_ _N_,
- enumFromTo = _A_ 2 _U_ 22 _N_ _N_ _N_ _N_,
- enumFromThenTo = _A_ 3 _U_ 222 _N_ _N_ _N_ _N_ #-}
+ enumFrom = { _A_ 1 _U_ 2 _N_ _N_ _N_ _N_ },
+ enumFromThen = { _A_ 2 _U_ 21 _N_ _N_ _N_ _N_ },
+ enumFromTo = { _A_ 2 _U_ 22 _N_ _N_ _N_ _N_ },
+ enumFromThenTo = { _A_ 3 _U_ 222 _N_ _N_ _N_ _N_ } #-}
instance Enum Float
{-# GHC_PRAGMA _M_ PreludeCore {-dfun-} _A_ 0 _N_ _N_ _N_ _F_ _IF_ARGS_ 0 0 X 6 _!_ _TUP_5 [{{Ord Float}}, (Float -> [Float]), (Float -> Float -> [Float]), (Float -> Float -> [Float]), (Float -> Float -> Float -> [Float])] [_DFUN_ Ord (Float), _CONSTM_ Enum enumFrom (Float), _CONSTM_ Enum enumFromThen (Float), _CONSTM_ Enum enumFromTo (Float), _CONSTM_ Enum enumFromThenTo (Float)] _N_
- enumFrom = _A_ 1 _U_ 2 _N_ _N_ _N_ _N_,
- enumFromThen = _A_ 2 _U_ 21 _N_ _N_ _N_ _N_,
- enumFromTo = _A_ 2 _U_ 22 _N_ _N_ _N_ _N_,
- enumFromThenTo = _A_ 3 _U_ 222 _N_ _N_ _N_ _N_ #-}
+ enumFrom = { _A_ 1 _U_ 2 _N_ _N_ _N_ _N_ },
+ enumFromThen = { _A_ 2 _U_ 21 _N_ _N_ _N_ _N_ },
+ enumFromTo = { _A_ 2 _U_ 22 _N_ _N_ _N_ _N_ },
+ enumFromThenTo = { _A_ 3 _U_ 222 _N_ _N_ _N_ _N_ } #-}
instance Enum Int
{-# GHC_PRAGMA _M_ PreludeCore {-dfun-} _A_ 0 _N_ _N_ _N_ _F_ _IF_ARGS_ 0 0 X 6 _!_ _TUP_5 [{{Ord Int}}, (Int -> [Int]), (Int -> Int -> [Int]), (Int -> Int -> [Int]), (Int -> Int -> Int -> [Int])] [_DFUN_ Ord (Int), _CONSTM_ Enum enumFrom (Int), _CONSTM_ Enum enumFromThen (Int), _CONSTM_ Enum enumFromTo (Int), _CONSTM_ Enum enumFromThenTo (Int)] _N_
- enumFrom = _A_ 1 _U_ 2 _N_ _N_ _F_ _ALWAYS_ \ (u0 :: Int) -> _LETREC_ {(u1 :: Int -> [Int]) = \ (u2 :: Int) -> let {(u6 :: [Int]) = let {(u5 :: Int) = case u2 of { _ALG_ I# (u3 :: Int#) -> case _#_ plusInt# [] [u3, 1#] of { _PRIM_ (u4 :: Int#) -> _!_ I# [] [u4] }; _NO_DEFLT_ }} in _APP_ u1 [ u5 ]} in _!_ (:) [Int] [u2, u6]} in _APP_ u1 [ u0 ] _N_,
- enumFromThen = _A_ 2 _U_ 21 _N_ _N_ _N_ _N_,
- enumFromTo = _A_ 2 _U_ 12 _N_ _S_ "SS" _F_ _ALWAYS_ \ (u0 :: Int) (u1 :: Int) -> case u0 of { _ALG_ I# (u2 :: Int#) -> _LETREC_ {(u3 :: Int# -> [Int]) = \ (u4 :: Int#) -> case u1 of { _ALG_ I# (u5 :: Int#) -> case _#_ leInt# [] [u4, u5] of { _ALG_ True -> let {(u7 :: [Int]) = case _#_ plusInt# [] [u4, 1#] of { _PRIM_ (u6 :: Int#) -> _APP_ u3 [ u6 ] }} in let {(u8 :: Int) = _!_ I# [] [u4]} in _!_ (:) [Int] [u8, u7]; False -> _!_ _NIL_ [Int] []; _NO_DEFLT_ }; _NO_DEFLT_ }} in _APP_ u3 [ u2 ]; _NO_DEFLT_ } _N_,
- enumFromThenTo = _A_ 3 _U_ 222 _N_ _N_ _N_ _N_ #-}
+ enumFrom = { _A_ 1 _U_ 2 _N_ _N_ _F_ _ALWAYS_ \ (u0 :: Int) -> _LETREC_ {(u1 :: Int -> [Int]) = \ (u2 :: Int) -> let {(u6 :: [Int]) = let {(u5 :: Int) = case u2 of { _ALG_ I# (u3 :: Int#) -> case _#_ plusInt# [] [u3, 1#] of { _PRIM_ (u4 :: Int#) -> _!_ I# [] [u4] }; _NO_DEFLT_ }} in _APP_ u1 [ u5 ]} in _!_ (:) [Int] [u2, u6]} in _APP_ u1 [ u0 ] _N_ },
+ enumFromThen = { _A_ 2 _U_ 21 _N_ _N_ _N_ _N_ },
+ enumFromTo = { _A_ 2 _U_ 12 _N_ _S_ "SS" _F_ _ALWAYS_ \ (u0 :: Int) (u1 :: Int) -> case u0 of { _ALG_ I# (u2 :: Int#) -> _LETREC_ {(u3 :: Int# -> [Int]) = \ (u4 :: Int#) -> case u1 of { _ALG_ I# (u5 :: Int#) -> case _#_ leInt# [] [u4, u5] of { _ALG_ True -> let {(u7 :: [Int]) = case _#_ plusInt# [] [u4, 1#] of { _PRIM_ (u6 :: Int#) -> _APP_ u3 [ u6 ] }} in let {(u8 :: Int) = _!_ I# [] [u4]} in _!_ (:) [Int] [u8, u7]; False -> _!_ _NIL_ [Int] []; _NO_DEFLT_ }; _NO_DEFLT_ }} in _APP_ u3 [ u2 ]; _NO_DEFLT_ } _N_ },
+ enumFromThenTo = { _A_ 3 _U_ 222 _N_ _N_ _N_ _N_ } #-}
instance Enum Integer
{-# GHC_PRAGMA _M_ PreludeCore {-dfun-} _A_ 0 _N_ _N_ _N_ _F_ _IF_ARGS_ 0 0 X 6 _!_ _TUP_5 [{{Ord Integer}}, (Integer -> [Integer]), (Integer -> Integer -> [Integer]), (Integer -> Integer -> [Integer]), (Integer -> Integer -> Integer -> [Integer])] [_DFUN_ Ord (Integer), _CONSTM_ Enum enumFrom (Integer), _CONSTM_ Enum enumFromThen (Integer), _CONSTM_ Enum enumFromTo (Integer), _CONSTM_ Enum enumFromThenTo (Integer)] _N_
- enumFrom = _A_ 1 _U_ 2 _N_ _N_ _N_ _N_,
- enumFromThen = _A_ 2 _U_ 21 _N_ _N_ _N_ _N_,
- enumFromTo = _A_ 2 _U_ 22 _N_ _N_ _N_ _N_,
- enumFromThenTo = _A_ 3 _U_ 222 _N_ _N_ _N_ _N_ #-}
+ enumFrom = { _A_ 1 _U_ 2 _N_ _N_ _N_ _N_ },
+ enumFromThen = { _A_ 2 _U_ 21 _N_ _N_ _N_ _N_ },
+ enumFromTo = { _A_ 2 _U_ 22 _N_ _N_ _N_ _N_ },
+ enumFromThenTo = { _A_ 3 _U_ 222 _N_ _N_ _N_ _N_ } #-}
instance Integral a => Enum (Ratio a)
{-# GHC_PRAGMA _M_ PreludeRatio {-dfun-} _A_ 2 _U_ 22 _N_ _N_ _N_ _N_ #-}
instance Enum (Ratio Integer)
{-# GHC_PRAGMA _M_ PreludeRatio {-dfun-} _A_ 0 _N_ _N_ _N_ _F_ _IF_ARGS_ 0 0 X 6 _!_ _TUP_5 [{{Ord (Ratio Integer)}}, (Ratio Integer -> [Ratio Integer]), (Ratio Integer -> Ratio Integer -> [Ratio Integer]), (Ratio Integer -> Ratio Integer -> [Ratio Integer]), (Ratio Integer -> Ratio Integer -> Ratio Integer -> [Ratio Integer])] [_DFUN_ Ord (Ratio Integer), _CONSTM_ Enum enumFrom (Ratio Integer), _CONSTM_ Enum enumFromThen (Ratio Integer), _CONSTM_ Enum enumFromTo (Ratio Integer), _CONSTM_ Enum enumFromThenTo (Ratio Integer)] _N_
- enumFrom = _A_ 1 _U_ 2 _N_ _N_ _N_ _N_,
- enumFromThen = _A_ 2 _U_ 21 _N_ _N_ _N_ _N_,
- enumFromTo = _A_ 2 _U_ 22 _N_ _N_ _N_ _N_,
- enumFromThenTo = _A_ 3 _U_ 222 _N_ _N_ _N_ _N_ #-}
+ enumFrom = { _A_ 1 _U_ 2 _N_ _N_ _N_ _N_ },
+ enumFromThen = { _A_ 2 _U_ 21 _N_ _N_ _N_ _N_ },
+ enumFromTo = { _A_ 2 _U_ 22 _N_ _N_ _N_ _N_ },
+ enumFromThenTo = { _A_ 3 _U_ 222 _N_ _N_ _N_ _N_ } #-}
instance Eq ()
{-# GHC_PRAGMA _M_ PreludeBuiltin {-dfun-} _A_ 0 _N_ _N_ _N_ _F_ _IF_ARGS_ 0 0 X 3 _!_ _TUP_2 [(() -> () -> Bool), (() -> () -> Bool)] [_CONSTM_ Eq (==) (()), _CONSTM_ Eq (/=) (())] _N_
- (==) = _A_ 2 _U_ 11 _N_ _S_ "EE" _F_ _IF_ARGS_ 0 2 CC 3 \ (u0 :: ()) (u1 :: ()) -> case u0 of { _ALG_ _TUP_0 -> case u1 of { _ALG_ _TUP_0 -> _!_ True [] []; _NO_DEFLT_ }; _NO_DEFLT_ } _N_,
- (/=) = _A_ 2 _U_ 11 _N_ _S_ "EE" _F_ _IF_ARGS_ 0 2 CC 3 \ (u0 :: ()) (u1 :: ()) -> case u0 of { _ALG_ _TUP_0 -> case u1 of { _ALG_ _TUP_0 -> _!_ False [] []; _NO_DEFLT_ }; _NO_DEFLT_ } _N_ #-}
+ (==) = { _A_ 2 _U_ 11 _N_ _S_ "EE" _F_ _IF_ARGS_ 0 2 CC 3 \ (u0 :: ()) (u1 :: ()) -> case u0 of { _ALG_ _TUP_0 -> case u1 of { _ALG_ _TUP_0 -> _!_ True [] []; _NO_DEFLT_ }; _NO_DEFLT_ } _N_ },
+ (/=) = { _A_ 2 _U_ 11 _N_ _S_ "EE" _F_ _IF_ARGS_ 0 2 CC 3 \ (u0 :: ()) (u1 :: ()) -> case u0 of { _ALG_ _TUP_0 -> case u1 of { _ALG_ _TUP_0 -> _!_ False [] []; _NO_DEFLT_ }; _NO_DEFLT_ } _N_ } #-}
instance (Eq a, Eq b) => Eq (a, b)
- {-# GHC_PRAGMA _M_ PreludeBuiltin {-dfun-} _A_ 2 _U_ 11 _N_ _N_ _N_ _N_ #-}
+ {-# GHC_PRAGMA _M_ PreludeBuiltin {-dfun-} _A_ 2 _U_ 22 _N_ _N_ _N_ _N_ #-}
instance (Eq a, Eq b, Eq c) => Eq (a, b, c)
{-# GHC_PRAGMA _M_ PreludeBuiltin {-dfun-} _A_ 3 _U_ 111 _N_ _N_ _N_ _N_ #-}
instance (Eq a, Eq b, Eq c, Eq d) => Eq (a, b, c, d)
{-# GHC_PRAGMA _M_ PreludeBuiltin {-dfun-} _A_ 5 _U_ 11111 _N_ _N_ _N_ _N_ #-}
instance Eq (Int, Int)
{-# GHC_PRAGMA _M_ PreludeBuiltin {-dfun-} _A_ 0 _N_ _N_ _N_ _F_ _IF_ARGS_ 0 0 X 3 _!_ _TUP_2 [((Int, Int) -> (Int, Int) -> Bool), ((Int, Int) -> (Int, Int) -> Bool)] [_CONSTM_ Eq (==) ((Int, Int)), _CONSTM_ Eq (/=) ((Int, Int))] _N_
- (==) = _A_ 2 _U_ 11 _N_ _S_ "U(U(P)L)U(U(P)L)" {_A_ 4 _U_ 2121 _N_ _N_ _F_ _IF_ARGS_ 0 4 XCXC 7 \ (u0 :: Int#) (u1 :: Int) (u2 :: Int#) (u3 :: Int) -> case _#_ eqInt# [] [u0, u2] of { _ALG_ True -> case u1 of { _ALG_ I# (u4 :: Int#) -> case u3 of { _ALG_ I# (u5 :: Int#) -> _#_ eqInt# [] [u4, u5]; _NO_DEFLT_ }; _NO_DEFLT_ }; False -> _!_ False [] []; _NO_DEFLT_ } _N_} _F_ _ALWAYS_ \ (u0 :: (Int, Int)) (u1 :: (Int, Int)) -> case u0 of { _ALG_ _TUP_2 (u2 :: Int) (u3 :: Int) -> case u2 of { _ALG_ I# (u4 :: Int#) -> case u1 of { _ALG_ _TUP_2 (u5 :: Int) (u6 :: Int) -> case u5 of { _ALG_ I# (u7 :: Int#) -> case _#_ eqInt# [] [u4, u7] of { _ALG_ True -> case u3 of { _ALG_ I# (u8 :: Int#) -> case u6 of { _ALG_ I# (u9 :: Int#) -> _#_ eqInt# [] [u8, u9]; _NO_DEFLT_ }; _NO_DEFLT_ }; False -> _!_ False [] []; _NO_DEFLT_ }; _NO_DEFLT_ }; _NO_DEFLT_ }; _NO_DEFLT_ }; _NO_DEFLT_ } _N_,
- (/=) = _A_ 2 _U_ 22 _N_ _N_ _N_ _N_ #-}
+ (==) = { _A_ 2 _U_ 11 _N_ _S_ "U(U(P)L)U(U(P)L)" {_A_ 4 _U_ 2121 _N_ _N_ _F_ _IF_ARGS_ 0 4 XCXC 7 \ (u0 :: Int#) (u1 :: Int) (u2 :: Int#) (u3 :: Int) -> case _#_ eqInt# [] [u0, u2] of { _ALG_ True -> case u1 of { _ALG_ I# (u4 :: Int#) -> case u3 of { _ALG_ I# (u5 :: Int#) -> _#_ eqInt# [] [u4, u5]; _NO_DEFLT_ }; _NO_DEFLT_ }; False -> _!_ False [] []; _NO_DEFLT_ } _N_} _F_ _ALWAYS_ \ (u0 :: (Int, Int)) (u1 :: (Int, Int)) -> case u0 of { _ALG_ _TUP_2 (u2 :: Int) (u3 :: Int) -> case u2 of { _ALG_ I# (u4 :: Int#) -> case u1 of { _ALG_ _TUP_2 (u5 :: Int) (u6 :: Int) -> case u5 of { _ALG_ I# (u7 :: Int#) -> case _#_ eqInt# [] [u4, u7] of { _ALG_ True -> case u3 of { _ALG_ I# (u8 :: Int#) -> case u6 of { _ALG_ I# (u9 :: Int#) -> _#_ eqInt# [] [u8, u9]; _NO_DEFLT_ }; _NO_DEFLT_ }; False -> _!_ False [] []; _NO_DEFLT_ }; _NO_DEFLT_ }; _NO_DEFLT_ }; _NO_DEFLT_ }; _NO_DEFLT_ } _N_ },
+ (/=) = { _A_ 2 _U_ 11 _N_ _S_ "U(U(P)L)U(U(P)L)" {_A_ 4 _U_ 2121 _N_ _N_ _F_ _IF_ARGS_ 0 4 XCXC 7 \ (u0 :: Int#) (u1 :: Int) (u2 :: Int#) (u3 :: Int) -> case _#_ neInt# [] [u0, u2] of { _ALG_ True -> _!_ True [] []; False -> case u1 of { _ALG_ I# (u4 :: Int#) -> case u3 of { _ALG_ I# (u5 :: Int#) -> _#_ neInt# [] [u4, u5]; _NO_DEFLT_ }; _NO_DEFLT_ }; _NO_DEFLT_ } _N_} _F_ _ALWAYS_ \ (u0 :: (Int, Int)) (u1 :: (Int, Int)) -> case u0 of { _ALG_ _TUP_2 (u2 :: Int) (u3 :: Int) -> case u2 of { _ALG_ I# (u4 :: Int#) -> case u1 of { _ALG_ _TUP_2 (u5 :: Int) (u6 :: Int) -> case u5 of { _ALG_ I# (u7 :: Int#) -> case _#_ neInt# [] [u4, u7] of { _ALG_ True -> _!_ True [] []; False -> case u3 of { _ALG_ I# (u8 :: Int#) -> case u6 of { _ALG_ I# (u9 :: Int#) -> _#_ neInt# [] [u8, u9]; _NO_DEFLT_ }; _NO_DEFLT_ }; _NO_DEFLT_ }; _NO_DEFLT_ }; _NO_DEFLT_ }; _NO_DEFLT_ }; _NO_DEFLT_ } _N_ } #-}
+instance Eq (Int, Int, Int)
+ {-# GHC_PRAGMA _M_ PreludeBuiltin {-dfun-} _A_ 0 _N_ _N_ _N_ _F_ _IF_ARGS_ 0 0 X 3 _!_ _TUP_2 [((Int, Int, Int) -> (Int, Int, Int) -> Bool), ((Int, Int, Int) -> (Int, Int, Int) -> Bool)] [_CONSTM_ Eq (==) ((Int, Int, Int)), _CONSTM_ Eq (/=) ((Int, Int, Int))] _N_
+ (==) = { _A_ 2 _U_ 11 _N_ _S_ "U(U(P)LL)U(U(P)LL)" {_A_ 4 _U_ 2111 _N_ _N_ _N_ _N_} _N_ _N_ },
+ (/=) = { _A_ 2 _U_ 11 _N_ _S_ "U(U(P)LL)U(U(P)LL)" {_A_ 4 _U_ 2111 _N_ _N_ _N_ _N_} _N_ _N_ } #-}
+instance Eq (Int, Int, Int, Int)
+ {-# GHC_PRAGMA _M_ PreludeBuiltin {-dfun-} _A_ 0 _N_ _N_ _N_ _F_ _IF_ARGS_ 0 0 X 3 _!_ _TUP_2 [((Int, Int, Int, Int) -> (Int, Int, Int, Int) -> Bool), ((Int, Int, Int, Int) -> (Int, Int, Int, Int) -> Bool)] [_CONSTM_ Eq (==) ((Int, Int, Int, Int)), _CONSTM_ Eq (/=) ((Int, Int, Int, Int))] _N_
+ (==) = { _A_ 2 _U_ 11 _N_ _S_ "U(U(P)LLL)U(U(P)LLL)" {_A_ 5 _U_ 21111 _N_ _N_ _N_ _N_} _N_ _N_ },
+ (/=) = { _A_ 2 _U_ 11 _N_ _S_ "U(U(P)LLL)U(U(P)LLL)" {_A_ 5 _U_ 21111 _N_ _N_ _N_ _N_} _N_ _N_ } #-}
+instance Eq (Int, Int, Int, Int, Int)
+ {-# GHC_PRAGMA _M_ PreludeBuiltin {-dfun-} _A_ 0 _N_ _N_ _N_ _F_ _IF_ARGS_ 0 0 X 3 _!_ _TUP_2 [((Int, Int, Int, Int, Int) -> (Int, Int, Int, Int, Int) -> Bool), ((Int, Int, Int, Int, Int) -> (Int, Int, Int, Int, Int) -> Bool)] [_CONSTM_ Eq (==) ((Int, Int, Int, Int, Int)), _CONSTM_ Eq (/=) ((Int, Int, Int, Int, Int))] _N_
+ (==) = { _A_ 2 _U_ 11 _N_ _S_ "U(U(P)LLLL)U(U(P)LLLL)" _N_ _N_ },
+ (/=) = { _A_ 2 _U_ 11 _N_ _S_ "U(U(P)LLLL)U(U(P)LLLL)" _N_ _N_ } #-}
+instance Eq ([Char], [Char])
+ {-# GHC_PRAGMA _M_ PreludeBuiltin {-dfun-} _A_ 0 _N_ _N_ _N_ _F_ _IF_ARGS_ 0 0 X 3 _!_ _TUP_2 [(([Char], [Char]) -> ([Char], [Char]) -> Bool), (([Char], [Char]) -> ([Char], [Char]) -> Bool)] [_CONSTM_ Eq (==) (([Char], [Char])), _CONSTM_ Eq (/=) (([Char], [Char]))] _N_
+ (==) = { _A_ 2 _U_ 11 _N_ _S_ "U(SL)U(SL)" {_A_ 4 _U_ 2222 _N_ _N_ _N_ _N_} _N_ _N_ },
+ (/=) = { _A_ 2 _U_ 11 _N_ _S_ "U(SL)U(SL)" {_A_ 4 _U_ 2222 _N_ _N_ _N_ _N_} _N_ _N_ } #-}
+instance Eq ([Int], [Int])
+ {-# GHC_PRAGMA _M_ PreludeBuiltin {-dfun-} _A_ 0 _N_ _N_ _N_ _F_ _IF_ARGS_ 0 0 X 3 _!_ _TUP_2 [(([Int], [Int]) -> ([Int], [Int]) -> Bool), (([Int], [Int]) -> ([Int], [Int]) -> Bool)] [_CONSTM_ Eq (==) (([Int], [Int])), _CONSTM_ Eq (/=) (([Int], [Int]))] _N_
+ (==) = { _A_ 2 _U_ 11 _N_ _S_ "U(SL)U(SL)" {_A_ 4 _U_ 2222 _N_ _N_ _N_ _N_} _N_ _N_ },
+ (/=) = { _A_ 2 _U_ 11 _N_ _S_ "U(SL)U(SL)" {_A_ 4 _U_ 2222 _N_ _N_ _N_ _N_} _N_ _N_ } #-}
instance Eq (_PackedString, _PackedString)
{-# GHC_PRAGMA _M_ PreludeBuiltin {-dfun-} _A_ 0 _N_ _N_ _N_ _F_ _IF_ARGS_ 0 0 X 3 _!_ _TUP_2 [((_PackedString, _PackedString) -> (_PackedString, _PackedString) -> Bool), ((_PackedString, _PackedString) -> (_PackedString, _PackedString) -> Bool)] [_CONSTM_ Eq (==) ((_PackedString, _PackedString)), _CONSTM_ Eq (/=) ((_PackedString, _PackedString))] _N_
- (==) = _A_ 2 _U_ 11 _N_ _S_ "U(SL)U(SL)" {_A_ 4 _U_ 2222 _N_ _N_ _N_ _N_} _N_ _N_,
- (/=) = _A_ 2 _U_ 22 _N_ _N_ _N_ _N_ #-}
+ (==) = { _A_ 2 _U_ 11 _N_ _S_ "U(SL)U(SL)" {_A_ 4 _U_ 2222 _N_ _N_ _N_ _N_} _N_ _N_ },
+ (/=) = { _A_ 2 _U_ 11 _N_ _S_ "U(SL)U(SL)" {_A_ 4 _U_ 2222 _N_ _N_ _N_ _N_} _N_ _N_ } #-}
instance (Ix a, Eq b) => Eq (Array a b)
{-# GHC_PRAGMA _M_ PreludeArray {-dfun-} _A_ 2 _U_ 21 _N_ _N_ _N_ _N_ #-}
instance (Eq a, Eq b) => Eq (Assoc a b)
{-# GHC_PRAGMA _M_ PreludeArray {-dfun-} _A_ 2 _U_ 11 _N_ _N_ _N_ _N_ #-}
instance Eq Bool
{-# GHC_PRAGMA _M_ PreludeCore {-dfun-} _A_ 0 _N_ _N_ _N_ _F_ _IF_ARGS_ 0 0 X 3 _!_ _TUP_2 [(Bool -> Bool -> Bool), (Bool -> Bool -> Bool)] [_CONSTM_ Eq (==) (Bool), _CONSTM_ Eq (/=) (Bool)] _N_
- (==) = _A_ 2 _U_ 11 _N_ _S_ "EE" _F_ _IF_ARGS_ 0 2 CC 7 \ (u0 :: Bool) (u1 :: Bool) -> case u0 of { _ALG_ True -> u1; False -> case u1 of { _ALG_ True -> _!_ False [] []; False -> _!_ True [] []; _NO_DEFLT_ }; _NO_DEFLT_ } _N_,
- (/=) = _A_ 2 _U_ 11 _N_ _S_ "EE" _F_ _IF_ARGS_ 0 2 CC 7 \ (u0 :: Bool) (u1 :: Bool) -> case u0 of { _ALG_ True -> case u1 of { _ALG_ True -> _!_ False [] []; False -> _!_ True [] []; _NO_DEFLT_ }; False -> u1; _NO_DEFLT_ } _N_ #-}
+ (==) = { _A_ 2 _U_ 11 _N_ _S_ "EE" _F_ _IF_ARGS_ 0 2 CC 7 \ (u0 :: Bool) (u1 :: Bool) -> case u0 of { _ALG_ True -> u1; False -> case u1 of { _ALG_ True -> _!_ False [] []; False -> _!_ True [] []; _NO_DEFLT_ }; _NO_DEFLT_ } _N_ },
+ (/=) = { _A_ 2 _U_ 11 _N_ _S_ "EE" _F_ _IF_ARGS_ 0 2 CC 7 \ (u0 :: Bool) (u1 :: Bool) -> case u0 of { _ALG_ True -> case u1 of { _ALG_ True -> _!_ False [] []; False -> _!_ True [] []; _NO_DEFLT_ }; False -> u1; _NO_DEFLT_ } _N_ } #-}
instance Eq Char
{-# GHC_PRAGMA _M_ PreludeCore {-dfun-} _A_ 0 _N_ _N_ _N_ _F_ _IF_ARGS_ 0 0 X 3 _!_ _TUP_2 [(Char -> Char -> Bool), (Char -> Char -> Bool)] [_CONSTM_ Eq (==) (Char), _CONSTM_ Eq (/=) (Char)] _N_
- (==) = _A_ 2 _U_ 11 _N_ _S_ "U(P)U(P)" {_A_ 2 _U_ 22 _N_ _N_ _F_ _IF_ARGS_ 0 2 XX 1 \ (u0 :: Char#) (u1 :: Char#) -> _#_ eqChar# [] [u0, u1] _N_} _F_ _IF_ARGS_ 0 2 CC 3 \ (u0 :: Char) (u1 :: Char) -> case u0 of { _ALG_ C# (u2 :: Char#) -> case u1 of { _ALG_ C# (u3 :: Char#) -> _#_ eqChar# [] [u2, u3]; _NO_DEFLT_ }; _NO_DEFLT_ } _N_,
- (/=) = _A_ 2 _U_ 11 _N_ _S_ "U(P)U(P)" {_A_ 2 _U_ 22 _N_ _N_ _F_ _IF_ARGS_ 0 2 XX 1 \ (u0 :: Char#) (u1 :: Char#) -> _#_ neChar# [] [u0, u1] _N_} _F_ _IF_ARGS_ 0 2 CC 3 \ (u0 :: Char) (u1 :: Char) -> case u0 of { _ALG_ C# (u2 :: Char#) -> case u1 of { _ALG_ C# (u3 :: Char#) -> _#_ neChar# [] [u2, u3]; _NO_DEFLT_ }; _NO_DEFLT_ } _N_ #-}
+ (==) = { _A_ 2 _U_ 11 _N_ _S_ "U(P)U(P)" {_A_ 2 _U_ 22 _N_ _N_ _F_ _IF_ARGS_ 0 2 XX 1 \ (u0 :: Char#) (u1 :: Char#) -> _#_ eqChar# [] [u0, u1] _N_} _F_ _IF_ARGS_ 0 2 CC 3 \ (u0 :: Char) (u1 :: Char) -> case u0 of { _ALG_ C# (u2 :: Char#) -> case u1 of { _ALG_ C# (u3 :: Char#) -> _#_ eqChar# [] [u2, u3]; _NO_DEFLT_ }; _NO_DEFLT_ } _N_ },
+ (/=) = { _A_ 2 _U_ 11 _N_ _S_ "U(P)U(P)" {_A_ 2 _U_ 22 _N_ _N_ _F_ _IF_ARGS_ 0 2 XX 1 \ (u0 :: Char#) (u1 :: Char#) -> _#_ neChar# [] [u0, u1] _N_} _F_ _IF_ARGS_ 0 2 CC 3 \ (u0 :: Char) (u1 :: Char) -> case u0 of { _ALG_ C# (u2 :: Char#) -> case u1 of { _ALG_ C# (u3 :: Char#) -> _#_ neChar# [] [u2, u3]; _NO_DEFLT_ }; _NO_DEFLT_ } _N_ } #-}
instance Eq a => Eq (Complex a)
{-# GHC_PRAGMA _M_ PreludeComplex {-dfun-} _A_ 1 _U_ 2 _N_ _N_ _N_ _N_ #-}
instance Eq (Complex Double)
{-# GHC_PRAGMA _M_ PreludeComplex {-dfun-} _A_ 0 _N_ _N_ _N_ _F_ _IF_ARGS_ 0 0 X 3 _!_ _TUP_2 [(Complex Double -> Complex Double -> Bool), (Complex Double -> Complex Double -> Bool)] [_CONSTM_ Eq (==) (Complex Double), _CONSTM_ Eq (/=) (Complex Double)] _N_
- (==) = _A_ 2 _U_ 11 _N_ _S_ "U(U(P)L)U(U(P)L)" {_A_ 4 _U_ 2121 _N_ _N_ _F_ _IF_ARGS_ 0 4 XCXC 7 \ (u0 :: Double#) (u1 :: Double) (u2 :: Double#) (u3 :: Double) -> case _#_ eqDouble# [] [u0, u2] of { _ALG_ True -> case u1 of { _ALG_ D# (u4 :: Double#) -> case u3 of { _ALG_ D# (u5 :: Double#) -> _#_ eqDouble# [] [u4, u5]; _NO_DEFLT_ }; _NO_DEFLT_ }; False -> _!_ False [] []; _NO_DEFLT_ } _N_} _F_ _ALWAYS_ \ (u0 :: Complex Double) (u1 :: Complex Double) -> case u0 of { _ALG_ (:+) (u2 :: Double) (u3 :: Double) -> case u2 of { _ALG_ D# (u4 :: Double#) -> case u1 of { _ALG_ (:+) (u5 :: Double) (u6 :: Double) -> case u5 of { _ALG_ D# (u7 :: Double#) -> case _#_ eqDouble# [] [u4, u7] of { _ALG_ True -> case u3 of { _ALG_ D# (u8 :: Double#) -> case u6 of { _ALG_ D# (u9 :: Double#) -> _#_ eqDouble# [] [u8, u9]; _NO_DEFLT_ }; _NO_DEFLT_ }; False -> _!_ False [] []; _NO_DEFLT_ }; _NO_DEFLT_ }; _NO_DEFLT_ }; _NO_DEFLT_ }; _NO_DEFLT_ } _N_,
- (/=) = _A_ 2 _U_ 11 _N_ _S_ "U(U(P)L)U(U(P)L)" {_A_ 4 _U_ 2121 _N_ _N_ _F_ _IF_ARGS_ 0 4 XCXC 7 \ (u0 :: Double#) (u1 :: Double) (u2 :: Double#) (u3 :: Double) -> case _#_ neDouble# [] [u0, u2] of { _ALG_ True -> _!_ True [] []; False -> case u1 of { _ALG_ D# (u4 :: Double#) -> case u3 of { _ALG_ D# (u5 :: Double#) -> _#_ neDouble# [] [u4, u5]; _NO_DEFLT_ }; _NO_DEFLT_ }; _NO_DEFLT_ } _N_} _F_ _ALWAYS_ \ (u0 :: Complex Double) (u1 :: Complex Double) -> case u0 of { _ALG_ (:+) (u2 :: Double) (u3 :: Double) -> case u2 of { _ALG_ D# (u4 :: Double#) -> case u1 of { _ALG_ (:+) (u5 :: Double) (u6 :: Double) -> case u5 of { _ALG_ D# (u7 :: Double#) -> case _#_ neDouble# [] [u4, u7] of { _ALG_ True -> _!_ True [] []; False -> case u3 of { _ALG_ D# (u8 :: Double#) -> case u6 of { _ALG_ D# (u9 :: Double#) -> _#_ neDouble# [] [u8, u9]; _NO_DEFLT_ }; _NO_DEFLT_ }; _NO_DEFLT_ }; _NO_DEFLT_ }; _NO_DEFLT_ }; _NO_DEFLT_ }; _NO_DEFLT_ } _N_ #-}
+ (==) = { _A_ 2 _U_ 11 _N_ _S_ "U(U(P)L)U(U(P)L)" {_A_ 4 _U_ 2121 _N_ _N_ _F_ _IF_ARGS_ 0 4 XCXC 7 \ (u0 :: Double#) (u1 :: Double) (u2 :: Double#) (u3 :: Double) -> case _#_ eqDouble# [] [u0, u2] of { _ALG_ True -> case u1 of { _ALG_ D# (u4 :: Double#) -> case u3 of { _ALG_ D# (u5 :: Double#) -> _#_ eqDouble# [] [u4, u5]; _NO_DEFLT_ }; _NO_DEFLT_ }; False -> _!_ False [] []; _NO_DEFLT_ } _N_} _F_ _ALWAYS_ \ (u0 :: Complex Double) (u1 :: Complex Double) -> case u0 of { _ALG_ (:+) (u2 :: Double) (u3 :: Double) -> case u2 of { _ALG_ D# (u4 :: Double#) -> case u1 of { _ALG_ (:+) (u5 :: Double) (u6 :: Double) -> case u5 of { _ALG_ D# (u7 :: Double#) -> case _#_ eqDouble# [] [u4, u7] of { _ALG_ True -> case u3 of { _ALG_ D# (u8 :: Double#) -> case u6 of { _ALG_ D# (u9 :: Double#) -> _#_ eqDouble# [] [u8, u9]; _NO_DEFLT_ }; _NO_DEFLT_ }; False -> _!_ False [] []; _NO_DEFLT_ }; _NO_DEFLT_ }; _NO_DEFLT_ }; _NO_DEFLT_ }; _NO_DEFLT_ } _N_ },
+ (/=) = { _A_ 2 _U_ 11 _N_ _S_ "U(U(P)L)U(U(P)L)" {_A_ 4 _U_ 2121 _N_ _N_ _F_ _IF_ARGS_ 0 4 XCXC 7 \ (u0 :: Double#) (u1 :: Double) (u2 :: Double#) (u3 :: Double) -> case _#_ neDouble# [] [u0, u2] of { _ALG_ True -> _!_ True [] []; False -> case u1 of { _ALG_ D# (u4 :: Double#) -> case u3 of { _ALG_ D# (u5 :: Double#) -> _#_ neDouble# [] [u4, u5]; _NO_DEFLT_ }; _NO_DEFLT_ }; _NO_DEFLT_ } _N_} _F_ _ALWAYS_ \ (u0 :: Complex Double) (u1 :: Complex Double) -> case u0 of { _ALG_ (:+) (u2 :: Double) (u3 :: Double) -> case u2 of { _ALG_ D# (u4 :: Double#) -> case u1 of { _ALG_ (:+) (u5 :: Double) (u6 :: Double) -> case u5 of { _ALG_ D# (u7 :: Double#) -> case _#_ neDouble# [] [u4, u7] of { _ALG_ True -> _!_ True [] []; False -> case u3 of { _ALG_ D# (u8 :: Double#) -> case u6 of { _ALG_ D# (u9 :: Double#) -> _#_ neDouble# [] [u8, u9]; _NO_DEFLT_ }; _NO_DEFLT_ }; _NO_DEFLT_ }; _NO_DEFLT_ }; _NO_DEFLT_ }; _NO_DEFLT_ }; _NO_DEFLT_ } _N_ } #-}
instance Eq Double
{-# GHC_PRAGMA _M_ PreludeCore {-dfun-} _A_ 0 _N_ _N_ _N_ _F_ _IF_ARGS_ 0 0 X 3 _!_ _TUP_2 [(Double -> Double -> Bool), (Double -> Double -> Bool)] [_CONSTM_ Eq (==) (Double), _CONSTM_ Eq (/=) (Double)] _N_
- (==) = _A_ 2 _U_ 11 _N_ _S_ "U(P)U(P)" {_A_ 2 _U_ 22 _N_ _N_ _F_ _IF_ARGS_ 0 2 XX 1 \ (u0 :: Double#) (u1 :: Double#) -> _#_ eqDouble# [] [u0, u1] _N_} _F_ _IF_ARGS_ 0 2 CC 3 \ (u0 :: Double) (u1 :: Double) -> case u0 of { _ALG_ D# (u2 :: Double#) -> case u1 of { _ALG_ D# (u3 :: Double#) -> _#_ eqDouble# [] [u2, u3]; _NO_DEFLT_ }; _NO_DEFLT_ } _N_,
- (/=) = _A_ 2 _U_ 11 _N_ _S_ "U(P)U(P)" {_A_ 2 _U_ 22 _N_ _N_ _F_ _IF_ARGS_ 0 2 XX 1 \ (u0 :: Double#) (u1 :: Double#) -> _#_ neDouble# [] [u0, u1] _N_} _F_ _IF_ARGS_ 0 2 CC 3 \ (u0 :: Double) (u1 :: Double) -> case u0 of { _ALG_ D# (u2 :: Double#) -> case u1 of { _ALG_ D# (u3 :: Double#) -> _#_ neDouble# [] [u2, u3]; _NO_DEFLT_ }; _NO_DEFLT_ } _N_ #-}
+ (==) = { _A_ 2 _U_ 11 _N_ _S_ "U(P)U(P)" {_A_ 2 _U_ 22 _N_ _N_ _F_ _IF_ARGS_ 0 2 XX 1 \ (u0 :: Double#) (u1 :: Double#) -> _#_ eqDouble# [] [u0, u1] _N_} _F_ _IF_ARGS_ 0 2 CC 3 \ (u0 :: Double) (u1 :: Double) -> case u0 of { _ALG_ D# (u2 :: Double#) -> case u1 of { _ALG_ D# (u3 :: Double#) -> _#_ eqDouble# [] [u2, u3]; _NO_DEFLT_ }; _NO_DEFLT_ } _N_ },
+ (/=) = { _A_ 2 _U_ 11 _N_ _S_ "U(P)U(P)" {_A_ 2 _U_ 22 _N_ _N_ _F_ _IF_ARGS_ 0 2 XX 1 \ (u0 :: Double#) (u1 :: Double#) -> _#_ neDouble# [] [u0, u1] _N_} _F_ _IF_ARGS_ 0 2 CC 3 \ (u0 :: Double) (u1 :: Double) -> case u0 of { _ALG_ D# (u2 :: Double#) -> case u1 of { _ALG_ D# (u3 :: Double#) -> _#_ neDouble# [] [u2, u3]; _NO_DEFLT_ }; _NO_DEFLT_ } _N_ } #-}
instance Eq Float
{-# GHC_PRAGMA _M_ PreludeCore {-dfun-} _A_ 0 _N_ _N_ _N_ _F_ _IF_ARGS_ 0 0 X 3 _!_ _TUP_2 [(Float -> Float -> Bool), (Float -> Float -> Bool)] [_CONSTM_ Eq (==) (Float), _CONSTM_ Eq (/=) (Float)] _N_
- (==) = _A_ 2 _U_ 11 _N_ _S_ "U(P)U(P)" {_A_ 2 _U_ 22 _N_ _N_ _F_ _IF_ARGS_ 0 2 XX 1 \ (u0 :: Float#) (u1 :: Float#) -> _#_ eqFloat# [] [u0, u1] _N_} _F_ _IF_ARGS_ 0 2 CC 3 \ (u0 :: Float) (u1 :: Float) -> case u0 of { _ALG_ F# (u2 :: Float#) -> case u1 of { _ALG_ F# (u3 :: Float#) -> _#_ eqFloat# [] [u2, u3]; _NO_DEFLT_ }; _NO_DEFLT_ } _N_,
- (/=) = _A_ 2 _U_ 11 _N_ _S_ "U(P)U(P)" {_A_ 2 _U_ 22 _N_ _N_ _F_ _IF_ARGS_ 0 2 XX 1 \ (u0 :: Float#) (u1 :: Float#) -> _#_ neFloat# [] [u0, u1] _N_} _F_ _IF_ARGS_ 0 2 CC 3 \ (u0 :: Float) (u1 :: Float) -> case u0 of { _ALG_ F# (u2 :: Float#) -> case u1 of { _ALG_ F# (u3 :: Float#) -> _#_ neFloat# [] [u2, u3]; _NO_DEFLT_ }; _NO_DEFLT_ } _N_ #-}
+ (==) = { _A_ 2 _U_ 11 _N_ _S_ "U(P)U(P)" {_A_ 2 _U_ 22 _N_ _N_ _F_ _IF_ARGS_ 0 2 XX 1 \ (u0 :: Float#) (u1 :: Float#) -> _#_ eqFloat# [] [u0, u1] _N_} _F_ _IF_ARGS_ 0 2 CC 3 \ (u0 :: Float) (u1 :: Float) -> case u0 of { _ALG_ F# (u2 :: Float#) -> case u1 of { _ALG_ F# (u3 :: Float#) -> _#_ eqFloat# [] [u2, u3]; _NO_DEFLT_ }; _NO_DEFLT_ } _N_ },
+ (/=) = { _A_ 2 _U_ 11 _N_ _S_ "U(P)U(P)" {_A_ 2 _U_ 22 _N_ _N_ _F_ _IF_ARGS_ 0 2 XX 1 \ (u0 :: Float#) (u1 :: Float#) -> _#_ neFloat# [] [u0, u1] _N_} _F_ _IF_ARGS_ 0 2 CC 3 \ (u0 :: Float) (u1 :: Float) -> case u0 of { _ALG_ F# (u2 :: Float#) -> case u1 of { _ALG_ F# (u3 :: Float#) -> _#_ neFloat# [] [u2, u3]; _NO_DEFLT_ }; _NO_DEFLT_ } _N_ } #-}
instance Eq Int
{-# GHC_PRAGMA _M_ PreludeCore {-dfun-} _A_ 0 _N_ _N_ _N_ _F_ _IF_ARGS_ 0 0 X 3 _!_ _TUP_2 [(Int -> Int -> Bool), (Int -> Int -> Bool)] [_CONSTM_ Eq (==) (Int), _CONSTM_ Eq (/=) (Int)] _N_
- (==) = _A_ 2 _U_ 11 _N_ _S_ "U(P)U(P)" {_A_ 2 _U_ 22 _N_ _N_ _F_ _IF_ARGS_ 0 2 XX 1 \ (u0 :: Int#) (u1 :: Int#) -> _#_ eqInt# [] [u0, u1] _N_} _F_ _IF_ARGS_ 0 2 CC 3 \ (u0 :: Int) (u1 :: Int) -> case u0 of { _ALG_ I# (u2 :: Int#) -> case u1 of { _ALG_ I# (u3 :: Int#) -> _#_ eqInt# [] [u2, u3]; _NO_DEFLT_ }; _NO_DEFLT_ } _N_,
- (/=) = _A_ 2 _U_ 11 _N_ _S_ "U(P)U(P)" {_A_ 2 _U_ 22 _N_ _N_ _F_ _IF_ARGS_ 0 2 XX 1 \ (u0 :: Int#) (u1 :: Int#) -> _#_ neInt# [] [u0, u1] _N_} _F_ _IF_ARGS_ 0 2 CC 3 \ (u0 :: Int) (u1 :: Int) -> case u0 of { _ALG_ I# (u2 :: Int#) -> case u1 of { _ALG_ I# (u3 :: Int#) -> _#_ neInt# [] [u2, u3]; _NO_DEFLT_ }; _NO_DEFLT_ } _N_ #-}
+ (==) = { _A_ 2 _U_ 11 _N_ _S_ "U(P)U(P)" {_A_ 2 _U_ 22 _N_ _N_ _F_ _IF_ARGS_ 0 2 XX 1 \ (u0 :: Int#) (u1 :: Int#) -> _#_ eqInt# [] [u0, u1] _N_} _F_ _IF_ARGS_ 0 2 CC 3 \ (u0 :: Int) (u1 :: Int) -> case u0 of { _ALG_ I# (u2 :: Int#) -> case u1 of { _ALG_ I# (u3 :: Int#) -> _#_ eqInt# [] [u2, u3]; _NO_DEFLT_ }; _NO_DEFLT_ } _N_ },
+ (/=) = { _A_ 2 _U_ 11 _N_ _S_ "U(P)U(P)" {_A_ 2 _U_ 22 _N_ _N_ _F_ _IF_ARGS_ 0 2 XX 1 \ (u0 :: Int#) (u1 :: Int#) -> _#_ neInt# [] [u0, u1] _N_} _F_ _IF_ARGS_ 0 2 CC 3 \ (u0 :: Int) (u1 :: Int) -> case u0 of { _ALG_ I# (u2 :: Int#) -> case u1 of { _ALG_ I# (u3 :: Int#) -> _#_ neInt# [] [u2, u3]; _NO_DEFLT_ }; _NO_DEFLT_ } _N_ } #-}
instance Eq Integer
{-# GHC_PRAGMA _M_ PreludeCore {-dfun-} _A_ 0 _N_ _N_ _N_ _F_ _IF_ARGS_ 0 0 X 3 _!_ _TUP_2 [(Integer -> Integer -> Bool), (Integer -> Integer -> Bool)] [_CONSTM_ Eq (==) (Integer), _CONSTM_ Eq (/=) (Integer)] _N_
- (==) = _A_ 2 _U_ 11 _N_ _S_ "U(PPP)U(PPP)" {_A_ 4 _U_ 2221 _N_ _N_ _F_ _IF_ARGS_ 0 4 XXXC 4 \ (u0 :: Int#) (u1 :: Int#) (u2 :: ByteArray#) (u3 :: Integer) -> case u3 of { _ALG_ J# (u4 :: Int#) (u5 :: Int#) (u6 :: ByteArray#) -> case _#_ cmpInteger# [] [u0, u1, u2, u4, u5, u6] of { _PRIM_ 0# -> _!_ True [] []; (u7 :: Int#) -> _!_ False [] [] }; _NO_DEFLT_ } _N_} _F_ _IF_ARGS_ 0 2 CC 5 \ (u0 :: Integer) (u1 :: Integer) -> case u0 of { _ALG_ J# (u2 :: Int#) (u3 :: Int#) (u4 :: ByteArray#) -> case u1 of { _ALG_ J# (u5 :: Int#) (u6 :: Int#) (u7 :: ByteArray#) -> case _#_ cmpInteger# [] [u2, u3, u4, u5, u6, u7] of { _PRIM_ 0# -> _!_ True [] []; (u8 :: Int#) -> _!_ False [] [] }; _NO_DEFLT_ }; _NO_DEFLT_ } _N_,
- (/=) = _A_ 2 _U_ 11 _N_ _S_ "U(PPP)U(PPP)" {_A_ 4 _U_ 2221 _N_ _N_ _F_ _IF_ARGS_ 0 4 XXXC 4 \ (u0 :: Int#) (u1 :: Int#) (u2 :: ByteArray#) (u3 :: Integer) -> case u3 of { _ALG_ J# (u4 :: Int#) (u5 :: Int#) (u6 :: ByteArray#) -> case _#_ cmpInteger# [] [u0, u1, u2, u4, u5, u6] of { _PRIM_ 0# -> _!_ False [] []; (u7 :: Int#) -> _!_ True [] [] }; _NO_DEFLT_ } _N_} _F_ _IF_ARGS_ 0 2 CC 5 \ (u0 :: Integer) (u1 :: Integer) -> case u0 of { _ALG_ J# (u2 :: Int#) (u3 :: Int#) (u4 :: ByteArray#) -> case u1 of { _ALG_ J# (u5 :: Int#) (u6 :: Int#) (u7 :: ByteArray#) -> case _#_ cmpInteger# [] [u2, u3, u4, u5, u6, u7] of { _PRIM_ 0# -> _!_ False [] []; (u8 :: Int#) -> _!_ True [] [] }; _NO_DEFLT_ }; _NO_DEFLT_ } _N_ #-}
+ (==) = { _A_ 2 _U_ 11 _N_ _S_ "U(PPP)U(PPP)" {_A_ 4 _U_ 2221 _N_ _N_ _F_ _IF_ARGS_ 0 4 XXXC 4 \ (u0 :: Int#) (u1 :: Int#) (u2 :: ByteArray#) (u3 :: Integer) -> case u3 of { _ALG_ J# (u4 :: Int#) (u5 :: Int#) (u6 :: ByteArray#) -> case _#_ cmpInteger# [] [u0, u1, u2, u4, u5, u6] of { _PRIM_ 0# -> _!_ True [] []; (u7 :: Int#) -> _!_ False [] [] }; _NO_DEFLT_ } _N_} _F_ _IF_ARGS_ 0 2 CC 5 \ (u0 :: Integer) (u1 :: Integer) -> case u0 of { _ALG_ J# (u2 :: Int#) (u3 :: Int#) (u4 :: ByteArray#) -> case u1 of { _ALG_ J# (u5 :: Int#) (u6 :: Int#) (u7 :: ByteArray#) -> case _#_ cmpInteger# [] [u2, u3, u4, u5, u6, u7] of { _PRIM_ 0# -> _!_ True [] []; (u8 :: Int#) -> _!_ False [] [] }; _NO_DEFLT_ }; _NO_DEFLT_ } _N_ },
+ (/=) = { _A_ 2 _U_ 11 _N_ _S_ "U(PPP)U(PPP)" {_A_ 4 _U_ 2221 _N_ _N_ _F_ _IF_ARGS_ 0 4 XXXC 4 \ (u0 :: Int#) (u1 :: Int#) (u2 :: ByteArray#) (u3 :: Integer) -> case u3 of { _ALG_ J# (u4 :: Int#) (u5 :: Int#) (u6 :: ByteArray#) -> case _#_ cmpInteger# [] [u0, u1, u2, u4, u5, u6] of { _PRIM_ 0# -> _!_ False [] []; (u7 :: Int#) -> _!_ True [] [] }; _NO_DEFLT_ } _N_} _F_ _IF_ARGS_ 0 2 CC 5 \ (u0 :: Integer) (u1 :: Integer) -> case u0 of { _ALG_ J# (u2 :: Int#) (u3 :: Int#) (u4 :: ByteArray#) -> case u1 of { _ALG_ J# (u5 :: Int#) (u6 :: Int#) (u7 :: ByteArray#) -> case _#_ cmpInteger# [] [u2, u3, u4, u5, u6, u7] of { _PRIM_ 0# -> _!_ False [] []; (u8 :: Int#) -> _!_ True [] [] }; _NO_DEFLT_ }; _NO_DEFLT_ } _N_ } #-}
instance Integral a => Eq (Ratio a)
{-# GHC_PRAGMA _M_ PreludeRatio {-dfun-} _A_ 1 _U_ 1 _N_ _N_ _N_ _N_ #-}
instance Eq (Ratio Integer)
{-# GHC_PRAGMA _M_ PreludeRatio {-dfun-} _A_ 0 _N_ _N_ _N_ _F_ _IF_ARGS_ 0 0 X 3 _!_ _TUP_2 [(Ratio Integer -> Ratio Integer -> Bool), (Ratio Integer -> Ratio Integer -> Bool)] [_CONSTM_ Eq (==) (Ratio Integer), _CONSTM_ Eq (/=) (Ratio Integer)] _N_
- (==) = _A_ 2 _U_ 11 _N_ _S_ "U(U(PPP)L)U(U(PPP)L)" {_A_ 5 _U_ 22211 _N_ _N_ _F_ _IF_ARGS_ 0 5 XXXCC 9 \ (u0 :: Int#) (u1 :: Int#) (u2 :: ByteArray#) (u3 :: Integer) (u4 :: Ratio Integer) -> case u4 of { _ALG_ (:%) (u5 :: Integer) (u6 :: Integer) -> case u5 of { _ALG_ J# (u7 :: Int#) (u8 :: Int#) (u9 :: ByteArray#) -> case _#_ cmpInteger# [] [u0, u1, u2, u7, u8, u9] of { _PRIM_ 0# -> case u3 of { _ALG_ J# (ua :: Int#) (ub :: Int#) (uc :: ByteArray#) -> case u6 of { _ALG_ J# (ud :: Int#) (ue :: Int#) (uf :: ByteArray#) -> case _#_ cmpInteger# [] [ua, ub, uc, ud, ue, uf] of { _PRIM_ 0# -> _!_ True [] []; (ug :: Int#) -> _!_ False [] [] }; _NO_DEFLT_ }; _NO_DEFLT_ }; (uh :: Int#) -> _!_ False [] [] }; _NO_DEFLT_ }; _NO_DEFLT_ } _N_} _N_ _N_,
- (/=) = _A_ 2 _U_ 11 _N_ _S_ "U(U(PPP)L)U(U(PPP)L)" {_A_ 5 _U_ 22211 _N_ _N_ _F_ _IF_ARGS_ 0 5 XXXCC 9 \ (u0 :: Int#) (u1 :: Int#) (u2 :: ByteArray#) (u3 :: Integer) (u4 :: Ratio Integer) -> case u4 of { _ALG_ (:%) (u5 :: Integer) (u6 :: Integer) -> case u5 of { _ALG_ J# (u7 :: Int#) (u8 :: Int#) (u9 :: ByteArray#) -> case _#_ cmpInteger# [] [u0, u1, u2, u7, u8, u9] of { _PRIM_ 0# -> case u3 of { _ALG_ J# (ua :: Int#) (ub :: Int#) (uc :: ByteArray#) -> case u6 of { _ALG_ J# (ud :: Int#) (ue :: Int#) (uf :: ByteArray#) -> case _#_ cmpInteger# [] [ua, ub, uc, ud, ue, uf] of { _PRIM_ 0# -> _!_ False [] []; (ug :: Int#) -> _!_ True [] [] }; _NO_DEFLT_ }; _NO_DEFLT_ }; (uh :: Int#) -> _!_ True [] [] }; _NO_DEFLT_ }; _NO_DEFLT_ } _N_} _N_ _N_ #-}
+ (==) = { _A_ 2 _U_ 11 _N_ _S_ "U(U(PPP)L)U(U(PPP)L)" {_A_ 5 _U_ 22211 _N_ _N_ _F_ _IF_ARGS_ 0 5 XXXCC 9 \ (u0 :: Int#) (u1 :: Int#) (u2 :: ByteArray#) (u3 :: Integer) (u4 :: Ratio Integer) -> case u4 of { _ALG_ (:%) (u5 :: Integer) (u6 :: Integer) -> case u5 of { _ALG_ J# (u7 :: Int#) (u8 :: Int#) (u9 :: ByteArray#) -> case _#_ cmpInteger# [] [u0, u1, u2, u7, u8, u9] of { _PRIM_ 0# -> case u3 of { _ALG_ J# (ua :: Int#) (ub :: Int#) (uc :: ByteArray#) -> case u6 of { _ALG_ J# (ud :: Int#) (ue :: Int#) (uf :: ByteArray#) -> case _#_ cmpInteger# [] [ua, ub, uc, ud, ue, uf] of { _PRIM_ 0# -> _!_ True [] []; (ug :: Int#) -> _!_ False [] [] }; _NO_DEFLT_ }; _NO_DEFLT_ }; (uh :: Int#) -> _!_ False [] [] }; _NO_DEFLT_ }; _NO_DEFLT_ } _N_} _N_ _N_ },
+ (/=) = { _A_ 2 _U_ 11 _N_ _S_ "U(U(PPP)L)U(U(PPP)L)" {_A_ 5 _U_ 22211 _N_ _N_ _F_ _IF_ARGS_ 0 5 XXXCC 9 \ (u0 :: Int#) (u1 :: Int#) (u2 :: ByteArray#) (u3 :: Integer) (u4 :: Ratio Integer) -> case u4 of { _ALG_ (:%) (u5 :: Integer) (u6 :: Integer) -> case u5 of { _ALG_ J# (u7 :: Int#) (u8 :: Int#) (u9 :: ByteArray#) -> case _#_ cmpInteger# [] [u0, u1, u2, u7, u8, u9] of { _PRIM_ 0# -> case u3 of { _ALG_ J# (ua :: Int#) (ub :: Int#) (uc :: ByteArray#) -> case u6 of { _ALG_ J# (ud :: Int#) (ue :: Int#) (uf :: ByteArray#) -> case _#_ cmpInteger# [] [ua, ub, uc, ud, ue, uf] of { _PRIM_ 0# -> _!_ False [] []; (ug :: Int#) -> _!_ True [] [] }; _NO_DEFLT_ }; _NO_DEFLT_ }; (uh :: Int#) -> _!_ True [] [] }; _NO_DEFLT_ }; _NO_DEFLT_ } _N_} _N_ _N_ } #-}
+instance Eq [(Int, Int)]
+ {-# GHC_PRAGMA _M_ PreludeBuiltin {-dfun-} _A_ 0 _N_ _N_ _N_ _F_ _IF_ARGS_ 0 0 X 3 _!_ _TUP_2 [([(Int, Int)] -> [(Int, Int)] -> Bool), ([(Int, Int)] -> [(Int, Int)] -> Bool)] [_CONSTM_ Eq (==) ([(Int, Int)]), _CONSTM_ Eq (/=) ([(Int, Int)])] _N_
+ (==) = { _A_ 2 _U_ 11 _N_ _S_ "SS" _N_ _N_ },
+ (/=) = { _A_ 2 _U_ 11 _N_ _S_ "SS" _N_ _N_ } #-}
instance Eq a => Eq [a]
{-# GHC_PRAGMA _M_ PreludeBuiltin {-dfun-} _A_ 1 _U_ 1 _N_ _N_ _N_ _N_ #-}
+instance Eq [Bool]
+ {-# GHC_PRAGMA _M_ PreludeBuiltin {-dfun-} _A_ 0 _N_ _N_ _N_ _F_ _IF_ARGS_ 0 0 X 3 _!_ _TUP_2 [([Bool] -> [Bool] -> Bool), ([Bool] -> [Bool] -> Bool)] [_CONSTM_ Eq (==) ([Bool]), _CONSTM_ Eq (/=) ([Bool])] _N_
+ (==) = { _A_ 2 _U_ 11 _N_ _S_ "SS" _N_ _N_ },
+ (/=) = { _A_ 2 _U_ 11 _N_ _S_ "SS" _N_ _N_ } #-}
instance Eq [Char]
{-# GHC_PRAGMA _M_ PreludeBuiltin {-dfun-} _A_ 0 _N_ _N_ _N_ _F_ _IF_ARGS_ 0 0 X 3 _!_ _TUP_2 [([Char] -> [Char] -> Bool), ([Char] -> [Char] -> Bool)] [_CONSTM_ Eq (==) ([Char]), _CONSTM_ Eq (/=) ([Char])] _N_
- (==) = _A_ 2 _U_ 11 _N_ _S_ "SS" _N_ _N_,
- (/=) = _A_ 2 _U_ 11 _N_ _S_ "SS" _N_ _N_ #-}
+ (==) = { _A_ 2 _U_ 11 _N_ _S_ "SS" _N_ _N_ },
+ (/=) = { _A_ 2 _U_ 11 _N_ _S_ "SS" _N_ _N_ } #-}
+instance Eq [Complex Double]
+ {-# GHC_PRAGMA _M_ PreludeBuiltin {-dfun-} _A_ 0 _N_ _N_ _N_ _F_ _IF_ARGS_ 0 0 X 3 _!_ _TUP_2 [([Complex Double] -> [Complex Double] -> Bool), ([Complex Double] -> [Complex Double] -> Bool)] [_CONSTM_ Eq (==) ([Complex Double]), _CONSTM_ Eq (/=) ([Complex Double])] _N_
+ (==) = { _A_ 2 _U_ 11 _N_ _S_ "SS" _N_ _N_ },
+ (/=) = { _A_ 2 _U_ 11 _N_ _S_ "SS" _N_ _N_ } #-}
+instance Eq [Double]
+ {-# GHC_PRAGMA _M_ PreludeBuiltin {-dfun-} _A_ 0 _N_ _N_ _N_ _F_ _IF_ARGS_ 0 0 X 3 _!_ _TUP_2 [([Double] -> [Double] -> Bool), ([Double] -> [Double] -> Bool)] [_CONSTM_ Eq (==) ([Double]), _CONSTM_ Eq (/=) ([Double])] _N_
+ (==) = { _A_ 2 _U_ 11 _N_ _S_ "SS" _N_ _N_ },
+ (/=) = { _A_ 2 _U_ 11 _N_ _S_ "SS" _N_ _N_ } #-}
instance Eq [Int]
{-# GHC_PRAGMA _M_ PreludeBuiltin {-dfun-} _A_ 0 _N_ _N_ _N_ _F_ _IF_ARGS_ 0 0 X 3 _!_ _TUP_2 [([Int] -> [Int] -> Bool), ([Int] -> [Int] -> Bool)] [_CONSTM_ Eq (==) ([Int]), _CONSTM_ Eq (/=) ([Int])] _N_
- (==) = _A_ 2 _U_ 11 _N_ _S_ "SS" _N_ _N_,
- (/=) = _A_ 2 _U_ 11 _N_ _S_ "SS" _N_ _N_ #-}
+ (==) = { _A_ 2 _U_ 11 _N_ _S_ "SS" _N_ _N_ },
+ (/=) = { _A_ 2 _U_ 11 _N_ _S_ "SS" _N_ _N_ } #-}
+instance Eq [Integer]
+ {-# GHC_PRAGMA _M_ PreludeBuiltin {-dfun-} _A_ 0 _N_ _N_ _N_ _F_ _IF_ARGS_ 0 0 X 3 _!_ _TUP_2 [([Integer] -> [Integer] -> Bool), ([Integer] -> [Integer] -> Bool)] [_CONSTM_ Eq (==) ([Integer]), _CONSTM_ Eq (/=) ([Integer])] _N_
+ (==) = { _A_ 2 _U_ 11 _N_ _S_ "SS" _N_ _N_ },
+ (/=) = { _A_ 2 _U_ 11 _N_ _S_ "SS" _N_ _N_ } #-}
+instance Eq [[Char]]
+ {-# GHC_PRAGMA _M_ PreludeBuiltin {-dfun-} _A_ 0 _N_ _N_ _N_ _F_ _IF_ARGS_ 0 0 X 3 _!_ _TUP_2 [([[Char]] -> [[Char]] -> Bool), ([[Char]] -> [[Char]] -> Bool)] [_CONSTM_ Eq (==) ([[Char]]), _CONSTM_ Eq (/=) ([[Char]])] _N_
+ (==) = { _A_ 2 _U_ 11 _N_ _S_ "SS" _N_ _N_ },
+ (/=) = { _A_ 2 _U_ 11 _N_ _S_ "SS" _N_ _N_ } #-}
+instance Eq [[Int]]
+ {-# GHC_PRAGMA _M_ PreludeBuiltin {-dfun-} _A_ 0 _N_ _N_ _N_ _F_ _IF_ARGS_ 0 0 X 3 _!_ _TUP_2 [([[Int]] -> [[Int]] -> Bool), ([[Int]] -> [[Int]] -> Bool)] [_CONSTM_ Eq (==) ([[Int]]), _CONSTM_ Eq (/=) ([[Int]])] _N_
+ (==) = { _A_ 2 _U_ 11 _N_ _S_ "SS" _N_ _N_ },
+ (/=) = { _A_ 2 _U_ 11 _N_ _S_ "SS" _N_ _N_ } #-}
instance Eq _Addr
{-# GHC_PRAGMA _M_ PreludeCore {-dfun-} _A_ 0 _N_ _N_ _N_ _F_ _IF_ARGS_ 0 0 X 3 _!_ _TUP_2 [(_Addr -> _Addr -> Bool), (_Addr -> _Addr -> Bool)] [_CONSTM_ Eq (==) (_Addr), _CONSTM_ Eq (/=) (_Addr)] _N_
- (==) = _A_ 2 _U_ 11 _N_ _S_ "U(P)U(P)" {_A_ 2 _U_ 22 _N_ _N_ _F_ _IF_ARGS_ 0 2 XX 1 \ (u0 :: Addr#) (u1 :: Addr#) -> _#_ eqAddr# [] [u0, u1] _N_} _F_ _IF_ARGS_ 0 2 CC 3 \ (u0 :: _Addr) (u1 :: _Addr) -> case u0 of { _ALG_ A# (u2 :: Addr#) -> case u1 of { _ALG_ A# (u3 :: Addr#) -> _#_ eqAddr# [] [u2, u3]; _NO_DEFLT_ }; _NO_DEFLT_ } _N_,
- (/=) = _A_ 2 _U_ 11 _N_ _S_ "U(P)U(P)" {_A_ 2 _U_ 22 _N_ _N_ _F_ _IF_ARGS_ 0 2 XX 1 \ (u0 :: Addr#) (u1 :: Addr#) -> _#_ neAddr# [] [u0, u1] _N_} _F_ _IF_ARGS_ 0 2 CC 3 \ (u0 :: _Addr) (u1 :: _Addr) -> case u0 of { _ALG_ A# (u2 :: Addr#) -> case u1 of { _ALG_ A# (u3 :: Addr#) -> _#_ neAddr# [] [u2, u3]; _NO_DEFLT_ }; _NO_DEFLT_ } _N_ #-}
+ (==) = { _A_ 2 _U_ 11 _N_ _S_ "U(P)U(P)" {_A_ 2 _U_ 22 _N_ _N_ _F_ _IF_ARGS_ 0 2 XX 1 \ (u0 :: Addr#) (u1 :: Addr#) -> _#_ eqAddr# [] [u0, u1] _N_} _F_ _IF_ARGS_ 0 2 CC 3 \ (u0 :: _Addr) (u1 :: _Addr) -> case u0 of { _ALG_ A# (u2 :: Addr#) -> case u1 of { _ALG_ A# (u3 :: Addr#) -> _#_ eqAddr# [] [u2, u3]; _NO_DEFLT_ }; _NO_DEFLT_ } _N_ },
+ (/=) = { _A_ 2 _U_ 11 _N_ _S_ "U(P)U(P)" {_A_ 2 _U_ 22 _N_ _N_ _F_ _IF_ARGS_ 0 2 XX 1 \ (u0 :: Addr#) (u1 :: Addr#) -> _#_ neAddr# [] [u0, u1] _N_} _F_ _IF_ARGS_ 0 2 CC 3 \ (u0 :: _Addr) (u1 :: _Addr) -> case u0 of { _ALG_ A# (u2 :: Addr#) -> case u1 of { _ALG_ A# (u3 :: Addr#) -> _#_ neAddr# [] [u2, u3]; _NO_DEFLT_ }; _NO_DEFLT_ } _N_ } #-}
instance Eq _PackedString
{-# GHC_PRAGMA _M_ PreludePS {-dfun-} _A_ 0 _N_ _N_ _N_ _F_ _IF_ARGS_ 0 0 X 3 _!_ _TUP_2 [(_PackedString -> _PackedString -> Bool), (_PackedString -> _PackedString -> Bool)] [_CONSTM_ Eq (==) (_PackedString), _CONSTM_ Eq (/=) (_PackedString)] _N_
- (==) = _A_ 2 _U_ 22 _N_ _S_ "SS" _N_ _N_,
- (/=) = _A_ 2 _U_ 22 _N_ _S_ "SS" _N_ _N_ #-}
+ (==) = { _A_ 2 _U_ 22 _N_ _S_ "SS" _N_ _N_ },
+ (/=) = { _A_ 2 _U_ 22 _N_ _S_ "SS" _N_ _N_ } #-}
instance Eq _Word
{-# GHC_PRAGMA _M_ PreludeCore {-dfun-} _A_ 0 _N_ _N_ _N_ _F_ _IF_ARGS_ 0 0 X 3 _!_ _TUP_2 [(_Word -> _Word -> Bool), (_Word -> _Word -> Bool)] [_CONSTM_ Eq (==) (_Word), _CONSTM_ Eq (/=) (_Word)] _N_
- (==) = _A_ 2 _U_ 11 _N_ _S_ "U(P)U(P)" {_A_ 2 _U_ 22 _N_ _N_ _F_ _IF_ARGS_ 0 2 XX 1 \ (u0 :: Word#) (u1 :: Word#) -> _#_ eqWord# [] [u0, u1] _N_} _F_ _IF_ARGS_ 0 2 CC 3 \ (u0 :: _Word) (u1 :: _Word) -> case u0 of { _ALG_ W# (u2 :: Word#) -> case u1 of { _ALG_ W# (u3 :: Word#) -> _#_ eqWord# [] [u2, u3]; _NO_DEFLT_ }; _NO_DEFLT_ } _N_,
- (/=) = _A_ 2 _U_ 11 _N_ _S_ "U(P)U(P)" {_A_ 2 _U_ 22 _N_ _N_ _F_ _IF_ARGS_ 0 2 XX 1 \ (u0 :: Word#) (u1 :: Word#) -> _#_ neWord# [] [u0, u1] _N_} _F_ _IF_ARGS_ 0 2 CC 3 \ (u0 :: _Word) (u1 :: _Word) -> case u0 of { _ALG_ W# (u2 :: Word#) -> case u1 of { _ALG_ W# (u3 :: Word#) -> _#_ neWord# [] [u2, u3]; _NO_DEFLT_ }; _NO_DEFLT_ } _N_ #-}
+ (==) = { _A_ 2 _U_ 11 _N_ _S_ "U(P)U(P)" {_A_ 2 _U_ 22 _N_ _N_ _F_ _IF_ARGS_ 0 2 XX 1 \ (u0 :: Word#) (u1 :: Word#) -> _#_ eqWord# [] [u0, u1] _N_} _F_ _IF_ARGS_ 0 2 CC 3 \ (u0 :: _Word) (u1 :: _Word) -> case u0 of { _ALG_ W# (u2 :: Word#) -> case u1 of { _ALG_ W# (u3 :: Word#) -> _#_ eqWord# [] [u2, u3]; _NO_DEFLT_ }; _NO_DEFLT_ } _N_ },
+ (/=) = { _A_ 2 _U_ 11 _N_ _S_ "U(P)U(P)" {_A_ 2 _U_ 22 _N_ _N_ _F_ _IF_ARGS_ 0 2 XX 1 \ (u0 :: Word#) (u1 :: Word#) -> _#_ neWord# [] [u0, u1] _N_} _F_ _IF_ARGS_ 0 2 CC 3 \ (u0 :: _Word) (u1 :: _Word) -> case u0 of { _ALG_ W# (u2 :: Word#) -> case u1 of { _ALG_ W# (u3 :: Word#) -> _#_ neWord# [] [u2, u3]; _NO_DEFLT_ }; _NO_DEFLT_ } _N_ } #-}
instance RealFloat a => Floating (Complex a)
{-# GHC_PRAGMA _M_ PreludeComplex {-dfun-} _A_ 2 _U_ 22 _N_ _N_ _N_ _N_ #-}
instance Floating (Complex Double)
{-# GHC_PRAGMA _M_ PreludeComplex {-dfun-} _A_ 0 _N_ _N_ _N_ _F_ _IF_ARGS_ 0 0 X 20 _!_ _TUP_19 [{{Fractional (Complex Double)}}, (Complex Double), (Complex Double -> Complex Double), (Complex Double -> Complex Double), (Complex Double -> Complex Double), (Complex Double -> Complex Double -> Complex Double), (Complex Double -> Complex Double -> Complex Double), (Complex Double -> Complex Double), (Complex Double -> Complex Double), (Complex Double -> Complex Double), (Complex Double -> Complex Double), (Complex Double -> Complex Double), (Complex Double -> Complex Double), (Complex Double -> Complex Double), (Complex Double -> Complex Double), (Complex Double -> Complex Double), (Complex Double -> Complex Double), (Complex Double -> Complex Double), (Complex Double -> Complex Double)] [_DFUN_ Fractional (Complex Double), _CONSTM_ Floating pi (Complex Double), _CONSTM_ Floating exp (Complex Double), _CONSTM_ Floating log (Complex Double), _CONSTM_ Floating sqrt (Complex Double), _CONSTM_ Floating (**) (Complex Double), _CONSTM_ Floating logBase (Complex Double), _CONSTM_ Floating sin (Complex Double), _CONSTM_ Floating cos (Complex Double), _CONSTM_ Floating tan (Complex Double), _CONSTM_ Floating asin (Complex Double), _CONSTM_ Floating acos (Complex Double), _CONSTM_ Floating atan (Complex Double), _CONSTM_ Floating sinh (Complex Double), _CONSTM_ Floating cosh (Complex Double), _CONSTM_ Floating tanh (Complex Double), _CONSTM_ Floating asinh (Complex Double), _CONSTM_ Floating acosh (Complex Double), _CONSTM_ Floating atanh (Complex Double)] _N_
- pi = _A_ 0 _N_ _N_ _N_ _N_ _N_,
- exp = _A_ 1 _U_ 1 _N_ _S_ "U(LL)" {_A_ 2 _U_ 12 _N_ _N_ _N_ _N_} _N_ _N_,
- log = _A_ 1 _U_ 2 _N_ _N_ _N_ _N_,
- sqrt = _A_ 1 _U_ 1 _N_ _S_ "U(U(P)L)" {_A_ 2 _U_ 22 _N_ _N_ _N_ _N_} _N_ _N_,
- (**) = _A_ 2 _U_ 21 _N_ _S_ "LU(LL)" {_A_ 3 _U_ 222 _N_ _N_ _N_ _N_} _N_ _N_,
- logBase = _A_ 2 _U_ 22 _N_ _N_ _N_ _N_,
- sin = _A_ 1 _U_ 1 _N_ _S_ "U(LL)" {_A_ 2 _U_ 22 _N_ _N_ _N_ _N_} _N_ _N_,
- cos = _A_ 1 _U_ 1 _N_ _S_ "U(LL)" {_A_ 2 _U_ 22 _N_ _N_ _N_ _N_} _N_ _N_,
- tan = _A_ 1 _U_ 1 _N_ _S_ "U(LL)" {_A_ 2 _U_ 22 _N_ _N_ _N_ _N_} _N_ _N_,
- asin = _A_ 1 _U_ 1 _N_ _S_ "U(LL)" {_A_ 2 _U_ 22 _N_ _N_ _N_ _N_} _N_ _N_,
- acos = _A_ 1 _U_ 1 _N_ _S_ "U(LL)" {_A_ 2 _U_ 22 _N_ _N_ _N_ _N_} _N_ _N_,
- atan = _A_ 1 _U_ 1 _N_ _S_ "U(LL)" {_A_ 2 _U_ 22 _N_ _N_ _N_ _N_} _N_ _N_,
- sinh = _A_ 1 _U_ 1 _N_ _S_ "U(LL)" {_A_ 2 _U_ 22 _N_ _N_ _N_ _N_} _N_ _N_,
- cosh = _A_ 1 _U_ 1 _N_ _S_ "U(LL)" {_A_ 2 _U_ 22 _N_ _N_ _N_ _N_} _N_ _N_,
- tanh = _A_ 1 _U_ 1 _N_ _S_ "U(LL)" {_A_ 2 _U_ 22 _N_ _N_ _N_ _N_} _N_ _N_,
- asinh = _A_ 1 _U_ 1 _N_ _N_ _N_ _N_,
- acosh = _A_ 1 _U_ 1 _N_ _N_ _N_ _N_,
- atanh = _A_ 1 _U_ 1 _N_ _N_ _N_ _N_ #-}
+ pi = { _A_ 0 _N_ _N_ _N_ _F_ _IF_ARGS_ 0 0 X 3 _!_ (:+) [Double] [_CONSTM_ Floating pi (Double), _SPEC_ _ORIG_ PreludeCore __i0 [ (Double) ]] _N_ },
+ exp = { _A_ 1 _U_ 1 _N_ _S_ "U(LL)" {_A_ 2 _U_ 12 _N_ _N_ _N_ _N_} _N_ _N_ },
+ log = { _A_ 1 _U_ 2 _N_ _N_ _N_ _N_ },
+ sqrt = { _A_ 1 _U_ 1 _N_ _S_ "U(U(P)L)" {_A_ 2 _U_ 22 _N_ _N_ _N_ _N_} _N_ _N_ },
+ (**) = { _A_ 2 _U_ 21 _N_ _S_ "LU(LL)" {_A_ 3 _U_ 222 _N_ _N_ _N_ _N_} _N_ _N_ },
+ logBase = { _A_ 2 _U_ 22 _N_ _N_ _N_ _N_ },
+ sin = { _A_ 1 _U_ 1 _N_ _S_ "U(LL)" {_A_ 2 _U_ 22 _N_ _N_ _N_ _N_} _N_ _N_ },
+ cos = { _A_ 1 _U_ 1 _N_ _S_ "U(LL)" {_A_ 2 _U_ 22 _N_ _N_ _N_ _N_} _N_ _N_ },
+ tan = { _A_ 1 _U_ 1 _N_ _S_ "U(LL)" {_A_ 2 _U_ 22 _N_ _N_ _N_ _N_} _N_ _N_ },
+ asin = { _A_ 1 _U_ 1 _N_ _S_ "U(LL)" {_A_ 2 _U_ 22 _N_ _N_ _N_ _N_} _N_ _N_ },
+ acos = { _A_ 1 _U_ 1 _N_ _S_ "U(LL)" {_A_ 2 _U_ 22 _N_ _N_ _N_ _N_} _N_ _N_ },
+ atan = { _A_ 1 _U_ 1 _N_ _S_ "U(LL)" {_A_ 2 _U_ 22 _N_ _N_ _N_ _N_} _N_ _N_ },
+ sinh = { _A_ 1 _U_ 1 _N_ _S_ "U(LL)" {_A_ 2 _U_ 22 _N_ _N_ _N_ _N_} _N_ _N_ },
+ cosh = { _A_ 1 _U_ 1 _N_ _S_ "U(LL)" {_A_ 2 _U_ 22 _N_ _N_ _N_ _N_} _N_ _N_ },
+ tanh = { _A_ 1 _U_ 1 _N_ _S_ "U(LL)" {_A_ 2 _U_ 22 _N_ _N_ _N_ _N_} _N_ _N_ },
+ asinh = { _A_ 1 _U_ 1 _N_ _N_ _N_ _N_ },
+ acosh = { _A_ 1 _U_ 1 _N_ _N_ _N_ _N_ },
+ atanh = { _A_ 1 _U_ 1 _N_ _N_ _N_ _N_ } #-}
instance Floating Double
{-# GHC_PRAGMA _M_ PreludeCore {-dfun-} _A_ 0 _N_ _N_ _N_ _F_ _IF_ARGS_ 0 0 X 20 _!_ _TUP_19 [{{Fractional Double}}, Double, (Double -> Double), (Double -> Double), (Double -> Double), (Double -> Double -> Double), (Double -> Double -> Double), (Double -> Double), (Double -> Double), (Double -> Double), (Double -> Double), (Double -> Double), (Double -> Double), (Double -> Double), (Double -> Double), (Double -> Double), (Double -> Double), (Double -> Double), (Double -> Double)] [_DFUN_ Fractional (Double), _CONSTM_ Floating pi (Double), _CONSTM_ Floating exp (Double), _CONSTM_ Floating log (Double), _CONSTM_ Floating sqrt (Double), _CONSTM_ Floating (**) (Double), _CONSTM_ Floating logBase (Double), _CONSTM_ Floating sin (Double), _CONSTM_ Floating cos (Double), _CONSTM_ Floating tan (Double), _CONSTM_ Floating asin (Double), _CONSTM_ Floating acos (Double), _CONSTM_ Floating atan (Double), _CONSTM_ Floating sinh (Double), _CONSTM_ Floating cosh (Double), _CONSTM_ Floating tanh (Double), _CONSTM_ Floating asinh (Double), _CONSTM_ Floating acosh (Double), _CONSTM_ Floating atanh (Double)] _N_
- pi = _A_ 0 _N_ _N_ _N_ _F_ _IF_ARGS_ 0 0 X 2 _!_ D# [] [3.1415926535897931##] _N_,
- exp = _A_ 1 _U_ 1 _N_ _S_ "U(P)" {_A_ 1 _U_ 2 _N_ _N_ _F_ _IF_ARGS_ 0 1 X 3 \ (u0 :: Double#) -> case _#_ expDouble# [] [u0] of { _PRIM_ (u1 :: Double#) -> _!_ D# [] [u1] } _N_} _F_ _IF_ARGS_ 0 1 C 4 \ (u0 :: Double) -> case u0 of { _ALG_ D# (u1 :: Double#) -> case _#_ expDouble# [] [u1] of { _PRIM_ (u2 :: Double#) -> _!_ D# [] [u2] }; _NO_DEFLT_ } _N_,
- log = _A_ 1 _U_ 1 _N_ _S_ "U(P)" {_A_ 1 _U_ 2 _N_ _N_ _F_ _IF_ARGS_ 0 1 X 3 \ (u0 :: Double#) -> case _#_ logDouble# [] [u0] of { _PRIM_ (u1 :: Double#) -> _!_ D# [] [u1] } _N_} _F_ _IF_ARGS_ 0 1 C 4 \ (u0 :: Double) -> case u0 of { _ALG_ D# (u1 :: Double#) -> case _#_ logDouble# [] [u1] of { _PRIM_ (u2 :: Double#) -> _!_ D# [] [u2] }; _NO_DEFLT_ } _N_,
- sqrt = _A_ 1 _U_ 1 _N_ _S_ "U(P)" {_A_ 1 _U_ 2 _N_ _N_ _F_ _IF_ARGS_ 0 1 X 3 \ (u0 :: Double#) -> case _#_ sqrtDouble# [] [u0] of { _PRIM_ (u1 :: Double#) -> _!_ D# [] [u1] } _N_} _F_ _IF_ARGS_ 0 1 C 4 \ (u0 :: Double) -> case u0 of { _ALG_ D# (u1 :: Double#) -> case _#_ sqrtDouble# [] [u1] of { _PRIM_ (u2 :: Double#) -> _!_ D# [] [u2] }; _NO_DEFLT_ } _N_,
- (**) = _A_ 2 _U_ 11 _N_ _S_ "U(P)U(P)" {_A_ 2 _U_ 22 _N_ _N_ _F_ _IF_ARGS_ 0 2 XX 3 \ (u0 :: Double#) (u1 :: Double#) -> case _#_ powerDouble# [] [u0, u1] of { _PRIM_ (u2 :: Double#) -> _!_ D# [] [u2] } _N_} _F_ _IF_ARGS_ 0 2 CC 5 \ (u0 :: Double) (u1 :: Double) -> case u0 of { _ALG_ D# (u2 :: Double#) -> case u1 of { _ALG_ D# (u3 :: Double#) -> case _#_ powerDouble# [] [u2, u3] of { _PRIM_ (u4 :: Double#) -> _!_ D# [] [u4] }; _NO_DEFLT_ }; _NO_DEFLT_ } _N_,
- logBase = _A_ 2 _U_ 11 _N_ _S_ "U(P)U(P)" {_A_ 2 _U_ 22 _N_ _N_ _F_ _IF_ARGS_ 0 2 XX 5 \ (u0 :: Double#) (u1 :: Double#) -> case _#_ logDouble# [] [u1] of { _PRIM_ (u2 :: Double#) -> case _#_ logDouble# [] [u0] of { _PRIM_ (u3 :: Double#) -> case _#_ divideDouble# [] [u2, u3] of { _PRIM_ (u4 :: Double#) -> _!_ D# [] [u4] } } } _N_} _F_ _IF_ARGS_ 0 2 CC 7 \ (u0 :: Double) (u1 :: Double) -> case u1 of { _ALG_ D# (u2 :: Double#) -> case _#_ logDouble# [] [u2] of { _PRIM_ (u3 :: Double#) -> case u0 of { _ALG_ D# (u4 :: Double#) -> case _#_ logDouble# [] [u4] of { _PRIM_ (u5 :: Double#) -> case _#_ divideDouble# [] [u3, u5] of { _PRIM_ (u6 :: Double#) -> _!_ D# [] [u6] } }; _NO_DEFLT_ } }; _NO_DEFLT_ } _N_,
- sin = _A_ 1 _U_ 1 _N_ _S_ "U(P)" {_A_ 1 _U_ 2 _N_ _N_ _F_ _IF_ARGS_ 0 1 X 3 \ (u0 :: Double#) -> case _#_ sinDouble# [] [u0] of { _PRIM_ (u1 :: Double#) -> _!_ D# [] [u1] } _N_} _F_ _IF_ARGS_ 0 1 C 4 \ (u0 :: Double) -> case u0 of { _ALG_ D# (u1 :: Double#) -> case _#_ sinDouble# [] [u1] of { _PRIM_ (u2 :: Double#) -> _!_ D# [] [u2] }; _NO_DEFLT_ } _N_,
- cos = _A_ 1 _U_ 1 _N_ _S_ "U(P)" {_A_ 1 _U_ 2 _N_ _N_ _F_ _IF_ARGS_ 0 1 X 3 \ (u0 :: Double#) -> case _#_ cosDouble# [] [u0] of { _PRIM_ (u1 :: Double#) -> _!_ D# [] [u1] } _N_} _F_ _IF_ARGS_ 0 1 C 4 \ (u0 :: Double) -> case u0 of { _ALG_ D# (u1 :: Double#) -> case _#_ cosDouble# [] [u1] of { _PRIM_ (u2 :: Double#) -> _!_ D# [] [u2] }; _NO_DEFLT_ } _N_,
- tan = _A_ 1 _U_ 1 _N_ _S_ "U(P)" {_A_ 1 _U_ 2 _N_ _N_ _F_ _IF_ARGS_ 0 1 X 3 \ (u0 :: Double#) -> case _#_ tanDouble# [] [u0] of { _PRIM_ (u1 :: Double#) -> _!_ D# [] [u1] } _N_} _F_ _IF_ARGS_ 0 1 C 4 \ (u0 :: Double) -> case u0 of { _ALG_ D# (u1 :: Double#) -> case _#_ tanDouble# [] [u1] of { _PRIM_ (u2 :: Double#) -> _!_ D# [] [u2] }; _NO_DEFLT_ } _N_,
- asin = _A_ 1 _U_ 1 _N_ _S_ "U(P)" {_A_ 1 _U_ 2 _N_ _N_ _F_ _IF_ARGS_ 0 1 X 3 \ (u0 :: Double#) -> case _#_ asinDouble# [] [u0] of { _PRIM_ (u1 :: Double#) -> _!_ D# [] [u1] } _N_} _F_ _IF_ARGS_ 0 1 C 4 \ (u0 :: Double) -> case u0 of { _ALG_ D# (u1 :: Double#) -> case _#_ asinDouble# [] [u1] of { _PRIM_ (u2 :: Double#) -> _!_ D# [] [u2] }; _NO_DEFLT_ } _N_,
- acos = _A_ 1 _U_ 1 _N_ _S_ "U(P)" {_A_ 1 _U_ 2 _N_ _N_ _F_ _IF_ARGS_ 0 1 X 3 \ (u0 :: Double#) -> case _#_ acosDouble# [] [u0] of { _PRIM_ (u1 :: Double#) -> _!_ D# [] [u1] } _N_} _F_ _IF_ARGS_ 0 1 C 4 \ (u0 :: Double) -> case u0 of { _ALG_ D# (u1 :: Double#) -> case _#_ acosDouble# [] [u1] of { _PRIM_ (u2 :: Double#) -> _!_ D# [] [u2] }; _NO_DEFLT_ } _N_,
- atan = _A_ 1 _U_ 1 _N_ _S_ "U(P)" {_A_ 1 _U_ 2 _N_ _N_ _F_ _IF_ARGS_ 0 1 X 3 \ (u0 :: Double#) -> case _#_ atanDouble# [] [u0] of { _PRIM_ (u1 :: Double#) -> _!_ D# [] [u1] } _N_} _F_ _IF_ARGS_ 0 1 C 4 \ (u0 :: Double) -> case u0 of { _ALG_ D# (u1 :: Double#) -> case _#_ atanDouble# [] [u1] of { _PRIM_ (u2 :: Double#) -> _!_ D# [] [u2] }; _NO_DEFLT_ } _N_,
- sinh = _A_ 1 _U_ 1 _N_ _S_ "U(P)" {_A_ 1 _U_ 2 _N_ _N_ _F_ _IF_ARGS_ 0 1 X 3 \ (u0 :: Double#) -> case _#_ sinhDouble# [] [u0] of { _PRIM_ (u1 :: Double#) -> _!_ D# [] [u1] } _N_} _F_ _IF_ARGS_ 0 1 C 4 \ (u0 :: Double) -> case u0 of { _ALG_ D# (u1 :: Double#) -> case _#_ sinhDouble# [] [u1] of { _PRIM_ (u2 :: Double#) -> _!_ D# [] [u2] }; _NO_DEFLT_ } _N_,
- cosh = _A_ 1 _U_ 1 _N_ _S_ "U(P)" {_A_ 1 _U_ 2 _N_ _N_ _F_ _IF_ARGS_ 0 1 X 3 \ (u0 :: Double#) -> case _#_ coshDouble# [] [u0] of { _PRIM_ (u1 :: Double#) -> _!_ D# [] [u1] } _N_} _F_ _IF_ARGS_ 0 1 C 4 \ (u0 :: Double) -> case u0 of { _ALG_ D# (u1 :: Double#) -> case _#_ coshDouble# [] [u1] of { _PRIM_ (u2 :: Double#) -> _!_ D# [] [u2] }; _NO_DEFLT_ } _N_,
- tanh = _A_ 1 _U_ 1 _N_ _S_ "U(P)" {_A_ 1 _U_ 2 _N_ _N_ _F_ _IF_ARGS_ 0 1 X 3 \ (u0 :: Double#) -> case _#_ tanhDouble# [] [u0] of { _PRIM_ (u1 :: Double#) -> _!_ D# [] [u1] } _N_} _F_ _IF_ARGS_ 0 1 C 4 \ (u0 :: Double) -> case u0 of { _ALG_ D# (u1 :: Double#) -> case _#_ tanhDouble# [] [u1] of { _PRIM_ (u2 :: Double#) -> _!_ D# [] [u2] }; _NO_DEFLT_ } _N_,
- asinh = _A_ 1 _U_ 1 _N_ _S_ "U(P)" {_A_ 1 _U_ 2 _N_ _N_ _N_ _N_} _N_ _N_,
- acosh = _A_ 1 _U_ 1 _N_ _S_ "U(P)" {_A_ 1 _U_ 2 _N_ _N_ _N_ _N_} _N_ _N_,
- atanh = _A_ 1 _U_ 1 _N_ _S_ "U(P)" {_A_ 1 _U_ 2 _N_ _N_ _N_ _N_} _N_ _N_ #-}
+ pi = { _A_ 0 _N_ _N_ _N_ _F_ _IF_ARGS_ 0 0 X 2 _!_ D# [] [3.1415926535897931##] _N_ },
+ exp = { _A_ 1 _U_ 1 _N_ _S_ "U(P)" {_A_ 1 _U_ 2 _N_ _N_ _F_ _IF_ARGS_ 0 1 X 3 \ (u0 :: Double#) -> case _#_ expDouble# [] [u0] of { _PRIM_ (u1 :: Double#) -> _!_ D# [] [u1] } _N_} _F_ _IF_ARGS_ 0 1 C 4 \ (u0 :: Double) -> case u0 of { _ALG_ D# (u1 :: Double#) -> case _#_ expDouble# [] [u1] of { _PRIM_ (u2 :: Double#) -> _!_ D# [] [u2] }; _NO_DEFLT_ } _N_ },
+ log = { _A_ 1 _U_ 1 _N_ _S_ "U(P)" {_A_ 1 _U_ 2 _N_ _N_ _F_ _IF_ARGS_ 0 1 X 3 \ (u0 :: Double#) -> case _#_ logDouble# [] [u0] of { _PRIM_ (u1 :: Double#) -> _!_ D# [] [u1] } _N_} _F_ _IF_ARGS_ 0 1 C 4 \ (u0 :: Double) -> case u0 of { _ALG_ D# (u1 :: Double#) -> case _#_ logDouble# [] [u1] of { _PRIM_ (u2 :: Double#) -> _!_ D# [] [u2] }; _NO_DEFLT_ } _N_ },
+ sqrt = { _A_ 1 _U_ 1 _N_ _S_ "U(P)" {_A_ 1 _U_ 2 _N_ _N_ _F_ _IF_ARGS_ 0 1 X 3 \ (u0 :: Double#) -> case _#_ sqrtDouble# [] [u0] of { _PRIM_ (u1 :: Double#) -> _!_ D# [] [u1] } _N_} _F_ _IF_ARGS_ 0 1 C 4 \ (u0 :: Double) -> case u0 of { _ALG_ D# (u1 :: Double#) -> case _#_ sqrtDouble# [] [u1] of { _PRIM_ (u2 :: Double#) -> _!_ D# [] [u2] }; _NO_DEFLT_ } _N_ },
+ (**) = { _A_ 2 _U_ 11 _N_ _S_ "U(P)U(P)" {_A_ 2 _U_ 22 _N_ _N_ _F_ _IF_ARGS_ 0 2 XX 3 \ (u0 :: Double#) (u1 :: Double#) -> case _#_ powerDouble# [] [u0, u1] of { _PRIM_ (u2 :: Double#) -> _!_ D# [] [u2] } _N_} _F_ _IF_ARGS_ 0 2 CC 5 \ (u0 :: Double) (u1 :: Double) -> case u0 of { _ALG_ D# (u2 :: Double#) -> case u1 of { _ALG_ D# (u3 :: Double#) -> case _#_ powerDouble# [] [u2, u3] of { _PRIM_ (u4 :: Double#) -> _!_ D# [] [u4] }; _NO_DEFLT_ }; _NO_DEFLT_ } _N_ },
+ logBase = { _A_ 2 _U_ 11 _N_ _S_ "U(P)U(P)" {_A_ 2 _U_ 22 _N_ _N_ _F_ _IF_ARGS_ 0 2 XX 5 \ (u0 :: Double#) (u1 :: Double#) -> case _#_ logDouble# [] [u1] of { _PRIM_ (u2 :: Double#) -> case _#_ logDouble# [] [u0] of { _PRIM_ (u3 :: Double#) -> case _#_ divideDouble# [] [u2, u3] of { _PRIM_ (u4 :: Double#) -> _!_ D# [] [u4] } } } _N_} _F_ _IF_ARGS_ 0 2 CC 7 \ (u0 :: Double) (u1 :: Double) -> case u1 of { _ALG_ D# (u2 :: Double#) -> case _#_ logDouble# [] [u2] of { _PRIM_ (u3 :: Double#) -> case u0 of { _ALG_ D# (u4 :: Double#) -> case _#_ logDouble# [] [u4] of { _PRIM_ (u5 :: Double#) -> case _#_ divideDouble# [] [u3, u5] of { _PRIM_ (u6 :: Double#) -> _!_ D# [] [u6] } }; _NO_DEFLT_ } }; _NO_DEFLT_ } _N_ },
+ sin = { _A_ 1 _U_ 1 _N_ _S_ "U(P)" {_A_ 1 _U_ 2 _N_ _N_ _F_ _IF_ARGS_ 0 1 X 3 \ (u0 :: Double#) -> case _#_ sinDouble# [] [u0] of { _PRIM_ (u1 :: Double#) -> _!_ D# [] [u1] } _N_} _F_ _IF_ARGS_ 0 1 C 4 \ (u0 :: Double) -> case u0 of { _ALG_ D# (u1 :: Double#) -> case _#_ sinDouble# [] [u1] of { _PRIM_ (u2 :: Double#) -> _!_ D# [] [u2] }; _NO_DEFLT_ } _N_ },
+ cos = { _A_ 1 _U_ 1 _N_ _S_ "U(P)" {_A_ 1 _U_ 2 _N_ _N_ _F_ _IF_ARGS_ 0 1 X 3 \ (u0 :: Double#) -> case _#_ cosDouble# [] [u0] of { _PRIM_ (u1 :: Double#) -> _!_ D# [] [u1] } _N_} _F_ _IF_ARGS_ 0 1 C 4 \ (u0 :: Double) -> case u0 of { _ALG_ D# (u1 :: Double#) -> case _#_ cosDouble# [] [u1] of { _PRIM_ (u2 :: Double#) -> _!_ D# [] [u2] }; _NO_DEFLT_ } _N_ },
+ tan = { _A_ 1 _U_ 1 _N_ _S_ "U(P)" {_A_ 1 _U_ 2 _N_ _N_ _F_ _IF_ARGS_ 0 1 X 3 \ (u0 :: Double#) -> case _#_ tanDouble# [] [u0] of { _PRIM_ (u1 :: Double#) -> _!_ D# [] [u1] } _N_} _F_ _IF_ARGS_ 0 1 C 4 \ (u0 :: Double) -> case u0 of { _ALG_ D# (u1 :: Double#) -> case _#_ tanDouble# [] [u1] of { _PRIM_ (u2 :: Double#) -> _!_ D# [] [u2] }; _NO_DEFLT_ } _N_ },
+ asin = { _A_ 1 _U_ 1 _N_ _S_ "U(P)" {_A_ 1 _U_ 2 _N_ _N_ _F_ _IF_ARGS_ 0 1 X 3 \ (u0 :: Double#) -> case _#_ asinDouble# [] [u0] of { _PRIM_ (u1 :: Double#) -> _!_ D# [] [u1] } _N_} _F_ _IF_ARGS_ 0 1 C 4 \ (u0 :: Double) -> case u0 of { _ALG_ D# (u1 :: Double#) -> case _#_ asinDouble# [] [u1] of { _PRIM_ (u2 :: Double#) -> _!_ D# [] [u2] }; _NO_DEFLT_ } _N_ },
+ acos = { _A_ 1 _U_ 1 _N_ _S_ "U(P)" {_A_ 1 _U_ 2 _N_ _N_ _F_ _IF_ARGS_ 0 1 X 3 \ (u0 :: Double#) -> case _#_ acosDouble# [] [u0] of { _PRIM_ (u1 :: Double#) -> _!_ D# [] [u1] } _N_} _F_ _IF_ARGS_ 0 1 C 4 \ (u0 :: Double) -> case u0 of { _ALG_ D# (u1 :: Double#) -> case _#_ acosDouble# [] [u1] of { _PRIM_ (u2 :: Double#) -> _!_ D# [] [u2] }; _NO_DEFLT_ } _N_ },
+ atan = { _A_ 1 _U_ 1 _N_ _S_ "U(P)" {_A_ 1 _U_ 2 _N_ _N_ _F_ _IF_ARGS_ 0 1 X 3 \ (u0 :: Double#) -> case _#_ atanDouble# [] [u0] of { _PRIM_ (u1 :: Double#) -> _!_ D# [] [u1] } _N_} _F_ _IF_ARGS_ 0 1 C 4 \ (u0 :: Double) -> case u0 of { _ALG_ D# (u1 :: Double#) -> case _#_ atanDouble# [] [u1] of { _PRIM_ (u2 :: Double#) -> _!_ D# [] [u2] }; _NO_DEFLT_ } _N_ },
+ sinh = { _A_ 1 _U_ 1 _N_ _S_ "U(P)" {_A_ 1 _U_ 2 _N_ _N_ _F_ _IF_ARGS_ 0 1 X 3 \ (u0 :: Double#) -> case _#_ sinhDouble# [] [u0] of { _PRIM_ (u1 :: Double#) -> _!_ D# [] [u1] } _N_} _F_ _IF_ARGS_ 0 1 C 4 \ (u0 :: Double) -> case u0 of { _ALG_ D# (u1 :: Double#) -> case _#_ sinhDouble# [] [u1] of { _PRIM_ (u2 :: Double#) -> _!_ D# [] [u2] }; _NO_DEFLT_ } _N_ },
+ cosh = { _A_ 1 _U_ 1 _N_ _S_ "U(P)" {_A_ 1 _U_ 2 _N_ _N_ _F_ _IF_ARGS_ 0 1 X 3 \ (u0 :: Double#) -> case _#_ coshDouble# [] [u0] of { _PRIM_ (u1 :: Double#) -> _!_ D# [] [u1] } _N_} _F_ _IF_ARGS_ 0 1 C 4 \ (u0 :: Double) -> case u0 of { _ALG_ D# (u1 :: Double#) -> case _#_ coshDouble# [] [u1] of { _PRIM_ (u2 :: Double#) -> _!_ D# [] [u2] }; _NO_DEFLT_ } _N_ },
+ tanh = { _A_ 1 _U_ 1 _N_ _S_ "U(P)" {_A_ 1 _U_ 2 _N_ _N_ _F_ _IF_ARGS_ 0 1 X 3 \ (u0 :: Double#) -> case _#_ tanhDouble# [] [u0] of { _PRIM_ (u1 :: Double#) -> _!_ D# [] [u1] } _N_} _F_ _IF_ARGS_ 0 1 C 4 \ (u0 :: Double) -> case u0 of { _ALG_ D# (u1 :: Double#) -> case _#_ tanhDouble# [] [u1] of { _PRIM_ (u2 :: Double#) -> _!_ D# [] [u2] }; _NO_DEFLT_ } _N_ },
+ asinh = { _A_ 1 _U_ 1 _N_ _S_ "U(P)" {_A_ 1 _U_ 2 _N_ _N_ _N_ _N_} _N_ _N_ },
+ acosh = { _A_ 1 _U_ 1 _N_ _S_ "U(P)" {_A_ 1 _U_ 2 _N_ _N_ _N_ _N_} _N_ _N_ },
+ atanh = { _A_ 1 _U_ 1 _N_ _S_ "U(P)" {_A_ 1 _U_ 2 _N_ _N_ _N_ _N_} _N_ _N_ } #-}
instance Floating Float
{-# GHC_PRAGMA _M_ PreludeCore {-dfun-} _A_ 0 _N_ _N_ _N_ _F_ _IF_ARGS_ 0 0 X 20 _!_ _TUP_19 [{{Fractional Float}}, Float, (Float -> Float), (Float -> Float), (Float -> Float), (Float -> Float -> Float), (Float -> Float -> Float), (Float -> Float), (Float -> Float), (Float -> Float), (Float -> Float), (Float -> Float), (Float -> Float), (Float -> Float), (Float -> Float), (Float -> Float), (Float -> Float), (Float -> Float), (Float -> Float)] [_DFUN_ Fractional (Float), _CONSTM_ Floating pi (Float), _CONSTM_ Floating exp (Float), _CONSTM_ Floating log (Float), _CONSTM_ Floating sqrt (Float), _CONSTM_ Floating (**) (Float), _CONSTM_ Floating logBase (Float), _CONSTM_ Floating sin (Float), _CONSTM_ Floating cos (Float), _CONSTM_ Floating tan (Float), _CONSTM_ Floating asin (Float), _CONSTM_ Floating acos (Float), _CONSTM_ Floating atan (Float), _CONSTM_ Floating sinh (Float), _CONSTM_ Floating cosh (Float), _CONSTM_ Floating tanh (Float), _CONSTM_ Floating asinh (Float), _CONSTM_ Floating acosh (Float), _CONSTM_ Floating atanh (Float)] _N_
- pi = _A_ 0 _N_ _N_ _N_ _F_ _IF_ARGS_ 0 0 X 2 _!_ F# [] [3.1415926535897931#] _N_,
- exp = _A_ 1 _U_ 1 _N_ _S_ "U(P)" {_A_ 1 _U_ 2 _N_ _N_ _F_ _IF_ARGS_ 0 1 X 3 \ (u0 :: Float#) -> case _#_ expFloat# [] [u0] of { _PRIM_ (u1 :: Float#) -> _!_ F# [] [u1] } _N_} _F_ _IF_ARGS_ 0 1 C 4 \ (u0 :: Float) -> case u0 of { _ALG_ F# (u1 :: Float#) -> case _#_ expFloat# [] [u1] of { _PRIM_ (u2 :: Float#) -> _!_ F# [] [u2] }; _NO_DEFLT_ } _N_,
- log = _A_ 1 _U_ 1 _N_ _S_ "U(P)" {_A_ 1 _U_ 2 _N_ _N_ _F_ _IF_ARGS_ 0 1 X 3 \ (u0 :: Float#) -> case _#_ logFloat# [] [u0] of { _PRIM_ (u1 :: Float#) -> _!_ F# [] [u1] } _N_} _F_ _IF_ARGS_ 0 1 C 4 \ (u0 :: Float) -> case u0 of { _ALG_ F# (u1 :: Float#) -> case _#_ logFloat# [] [u1] of { _PRIM_ (u2 :: Float#) -> _!_ F# [] [u2] }; _NO_DEFLT_ } _N_,
- sqrt = _A_ 1 _U_ 1 _N_ _S_ "U(P)" {_A_ 1 _U_ 2 _N_ _N_ _F_ _IF_ARGS_ 0 1 X 3 \ (u0 :: Float#) -> case _#_ sqrtFloat# [] [u0] of { _PRIM_ (u1 :: Float#) -> _!_ F# [] [u1] } _N_} _F_ _IF_ARGS_ 0 1 C 4 \ (u0 :: Float) -> case u0 of { _ALG_ F# (u1 :: Float#) -> case _#_ sqrtFloat# [] [u1] of { _PRIM_ (u2 :: Float#) -> _!_ F# [] [u2] }; _NO_DEFLT_ } _N_,
- (**) = _A_ 2 _U_ 11 _N_ _S_ "U(P)U(P)" {_A_ 2 _U_ 22 _N_ _N_ _F_ _IF_ARGS_ 0 2 XX 3 \ (u0 :: Float#) (u1 :: Float#) -> case _#_ powerFloat# [] [u0, u1] of { _PRIM_ (u2 :: Float#) -> _!_ F# [] [u2] } _N_} _F_ _IF_ARGS_ 0 2 CC 5 \ (u0 :: Float) (u1 :: Float) -> case u0 of { _ALG_ F# (u2 :: Float#) -> case u1 of { _ALG_ F# (u3 :: Float#) -> case _#_ powerFloat# [] [u2, u3] of { _PRIM_ (u4 :: Float#) -> _!_ F# [] [u4] }; _NO_DEFLT_ }; _NO_DEFLT_ } _N_,
- logBase = _A_ 2 _U_ 22 _N_ _N_ _N_ _N_,
- sin = _A_ 1 _U_ 1 _N_ _S_ "U(P)" {_A_ 1 _U_ 2 _N_ _N_ _F_ _IF_ARGS_ 0 1 X 3 \ (u0 :: Float#) -> case _#_ sinFloat# [] [u0] of { _PRIM_ (u1 :: Float#) -> _!_ F# [] [u1] } _N_} _F_ _IF_ARGS_ 0 1 C 4 \ (u0 :: Float) -> case u0 of { _ALG_ F# (u1 :: Float#) -> case _#_ sinFloat# [] [u1] of { _PRIM_ (u2 :: Float#) -> _!_ F# [] [u2] }; _NO_DEFLT_ } _N_,
- cos = _A_ 1 _U_ 1 _N_ _S_ "U(P)" {_A_ 1 _U_ 2 _N_ _N_ _F_ _IF_ARGS_ 0 1 X 3 \ (u0 :: Float#) -> case _#_ cosFloat# [] [u0] of { _PRIM_ (u1 :: Float#) -> _!_ F# [] [u1] } _N_} _F_ _IF_ARGS_ 0 1 C 4 \ (u0 :: Float) -> case u0 of { _ALG_ F# (u1 :: Float#) -> case _#_ cosFloat# [] [u1] of { _PRIM_ (u2 :: Float#) -> _!_ F# [] [u2] }; _NO_DEFLT_ } _N_,
- tan = _A_ 1 _U_ 1 _N_ _S_ "U(P)" {_A_ 1 _U_ 2 _N_ _N_ _F_ _IF_ARGS_ 0 1 X 3 \ (u0 :: Float#) -> case _#_ tanFloat# [] [u0] of { _PRIM_ (u1 :: Float#) -> _!_ F# [] [u1] } _N_} _F_ _IF_ARGS_ 0 1 C 4 \ (u0 :: Float) -> case u0 of { _ALG_ F# (u1 :: Float#) -> case _#_ tanFloat# [] [u1] of { _PRIM_ (u2 :: Float#) -> _!_ F# [] [u2] }; _NO_DEFLT_ } _N_,
- asin = _A_ 1 _U_ 1 _N_ _S_ "U(P)" {_A_ 1 _U_ 2 _N_ _N_ _F_ _IF_ARGS_ 0 1 X 3 \ (u0 :: Float#) -> case _#_ asinFloat# [] [u0] of { _PRIM_ (u1 :: Float#) -> _!_ F# [] [u1] } _N_} _F_ _IF_ARGS_ 0 1 C 4 \ (u0 :: Float) -> case u0 of { _ALG_ F# (u1 :: Float#) -> case _#_ asinFloat# [] [u1] of { _PRIM_ (u2 :: Float#) -> _!_ F# [] [u2] }; _NO_DEFLT_ } _N_,
- acos = _A_ 1 _U_ 1 _N_ _S_ "U(P)" {_A_ 1 _U_ 2 _N_ _N_ _F_ _IF_ARGS_ 0 1 X 3 \ (u0 :: Float#) -> case _#_ acosFloat# [] [u0] of { _PRIM_ (u1 :: Float#) -> _!_ F# [] [u1] } _N_} _F_ _IF_ARGS_ 0 1 C 4 \ (u0 :: Float) -> case u0 of { _ALG_ F# (u1 :: Float#) -> case _#_ acosFloat# [] [u1] of { _PRIM_ (u2 :: Float#) -> _!_ F# [] [u2] }; _NO_DEFLT_ } _N_,
- atan = _A_ 1 _U_ 1 _N_ _S_ "U(P)" {_A_ 1 _U_ 2 _N_ _N_ _F_ _IF_ARGS_ 0 1 X 3 \ (u0 :: Float#) -> case _#_ atanFloat# [] [u0] of { _PRIM_ (u1 :: Float#) -> _!_ F# [] [u1] } _N_} _F_ _IF_ARGS_ 0 1 C 4 \ (u0 :: Float) -> case u0 of { _ALG_ F# (u1 :: Float#) -> case _#_ atanFloat# [] [u1] of { _PRIM_ (u2 :: Float#) -> _!_ F# [] [u2] }; _NO_DEFLT_ } _N_,
- sinh = _A_ 1 _U_ 1 _N_ _S_ "U(P)" {_A_ 1 _U_ 2 _N_ _N_ _F_ _IF_ARGS_ 0 1 X 3 \ (u0 :: Float#) -> case _#_ sinhFloat# [] [u0] of { _PRIM_ (u1 :: Float#) -> _!_ F# [] [u1] } _N_} _F_ _IF_ARGS_ 0 1 C 4 \ (u0 :: Float) -> case u0 of { _ALG_ F# (u1 :: Float#) -> case _#_ sinhFloat# [] [u1] of { _PRIM_ (u2 :: Float#) -> _!_ F# [] [u2] }; _NO_DEFLT_ } _N_,
- cosh = _A_ 1 _U_ 1 _N_ _S_ "U(P)" {_A_ 1 _U_ 2 _N_ _N_ _F_ _IF_ARGS_ 0 1 X 3 \ (u0 :: Float#) -> case _#_ coshFloat# [] [u0] of { _PRIM_ (u1 :: Float#) -> _!_ F# [] [u1] } _N_} _F_ _IF_ARGS_ 0 1 C 4 \ (u0 :: Float) -> case u0 of { _ALG_ F# (u1 :: Float#) -> case _#_ coshFloat# [] [u1] of { _PRIM_ (u2 :: Float#) -> _!_ F# [] [u2] }; _NO_DEFLT_ } _N_,
- tanh = _A_ 1 _U_ 1 _N_ _S_ "U(P)" {_A_ 1 _U_ 2 _N_ _N_ _F_ _IF_ARGS_ 0 1 X 3 \ (u0 :: Float#) -> case _#_ tanhFloat# [] [u0] of { _PRIM_ (u1 :: Float#) -> _!_ F# [] [u1] } _N_} _F_ _IF_ARGS_ 0 1 C 4 \ (u0 :: Float) -> case u0 of { _ALG_ F# (u1 :: Float#) -> case _#_ tanhFloat# [] [u1] of { _PRIM_ (u2 :: Float#) -> _!_ F# [] [u2] }; _NO_DEFLT_ } _N_,
- asinh = _A_ 1 _U_ 1 _N_ _S_ "U(P)" {_A_ 1 _U_ 2 _N_ _N_ _N_ _N_} _N_ _N_,
- acosh = _A_ 1 _U_ 1 _N_ _S_ "U(P)" {_A_ 1 _U_ 2 _N_ _N_ _N_ _N_} _N_ _N_,
- atanh = _A_ 1 _U_ 1 _N_ _S_ "U(P)" {_A_ 1 _U_ 2 _N_ _N_ _N_ _N_} _N_ _N_ #-}
+ pi = { _A_ 0 _N_ _N_ _N_ _F_ _IF_ARGS_ 0 0 X 2 _!_ F# [] [3.1415926535897931#] _N_ },
+ exp = { _A_ 1 _U_ 1 _N_ _S_ "U(P)" {_A_ 1 _U_ 2 _N_ _N_ _F_ _IF_ARGS_ 0 1 X 3 \ (u0 :: Float#) -> case _#_ expFloat# [] [u0] of { _PRIM_ (u1 :: Float#) -> _!_ F# [] [u1] } _N_} _F_ _IF_ARGS_ 0 1 C 4 \ (u0 :: Float) -> case u0 of { _ALG_ F# (u1 :: Float#) -> case _#_ expFloat# [] [u1] of { _PRIM_ (u2 :: Float#) -> _!_ F# [] [u2] }; _NO_DEFLT_ } _N_ },
+ log = { _A_ 1 _U_ 1 _N_ _S_ "U(P)" {_A_ 1 _U_ 2 _N_ _N_ _F_ _IF_ARGS_ 0 1 X 3 \ (u0 :: Float#) -> case _#_ logFloat# [] [u0] of { _PRIM_ (u1 :: Float#) -> _!_ F# [] [u1] } _N_} _F_ _IF_ARGS_ 0 1 C 4 \ (u0 :: Float) -> case u0 of { _ALG_ F# (u1 :: Float#) -> case _#_ logFloat# [] [u1] of { _PRIM_ (u2 :: Float#) -> _!_ F# [] [u2] }; _NO_DEFLT_ } _N_ },
+ sqrt = { _A_ 1 _U_ 1 _N_ _S_ "U(P)" {_A_ 1 _U_ 2 _N_ _N_ _F_ _IF_ARGS_ 0 1 X 3 \ (u0 :: Float#) -> case _#_ sqrtFloat# [] [u0] of { _PRIM_ (u1 :: Float#) -> _!_ F# [] [u1] } _N_} _F_ _IF_ARGS_ 0 1 C 4 \ (u0 :: Float) -> case u0 of { _ALG_ F# (u1 :: Float#) -> case _#_ sqrtFloat# [] [u1] of { _PRIM_ (u2 :: Float#) -> _!_ F# [] [u2] }; _NO_DEFLT_ } _N_ },
+ (**) = { _A_ 2 _U_ 11 _N_ _S_ "U(P)U(P)" {_A_ 2 _U_ 22 _N_ _N_ _F_ _IF_ARGS_ 0 2 XX 3 \ (u0 :: Float#) (u1 :: Float#) -> case _#_ powerFloat# [] [u0, u1] of { _PRIM_ (u2 :: Float#) -> _!_ F# [] [u2] } _N_} _F_ _IF_ARGS_ 0 2 CC 5 \ (u0 :: Float) (u1 :: Float) -> case u0 of { _ALG_ F# (u2 :: Float#) -> case u1 of { _ALG_ F# (u3 :: Float#) -> case _#_ powerFloat# [] [u2, u3] of { _PRIM_ (u4 :: Float#) -> _!_ F# [] [u4] }; _NO_DEFLT_ }; _NO_DEFLT_ } _N_ },
+ logBase = { _A_ 2 _U_ 11 _N_ _S_ "U(P)U(P)" {_A_ 2 _U_ 22 _N_ _N_ _F_ _IF_ARGS_ 0 2 XX 5 \ (u0 :: Float#) (u1 :: Float#) -> case _#_ logFloat# [] [u1] of { _PRIM_ (u2 :: Float#) -> case _#_ logFloat# [] [u0] of { _PRIM_ (u3 :: Float#) -> case _#_ divideFloat# [] [u2, u3] of { _PRIM_ (u4 :: Float#) -> _!_ F# [] [u4] } } } _N_} _F_ _IF_ARGS_ 0 2 CC 7 \ (u0 :: Float) (u1 :: Float) -> case u1 of { _ALG_ F# (u2 :: Float#) -> case _#_ logFloat# [] [u2] of { _PRIM_ (u3 :: Float#) -> case u0 of { _ALG_ F# (u4 :: Float#) -> case _#_ logFloat# [] [u4] of { _PRIM_ (u5 :: Float#) -> case _#_ divideFloat# [] [u3, u5] of { _PRIM_ (u6 :: Float#) -> _!_ F# [] [u6] } }; _NO_DEFLT_ } }; _NO_DEFLT_ } _N_ },
+ sin = { _A_ 1 _U_ 1 _N_ _S_ "U(P)" {_A_ 1 _U_ 2 _N_ _N_ _F_ _IF_ARGS_ 0 1 X 3 \ (u0 :: Float#) -> case _#_ sinFloat# [] [u0] of { _PRIM_ (u1 :: Float#) -> _!_ F# [] [u1] } _N_} _F_ _IF_ARGS_ 0 1 C 4 \ (u0 :: Float) -> case u0 of { _ALG_ F# (u1 :: Float#) -> case _#_ sinFloat# [] [u1] of { _PRIM_ (u2 :: Float#) -> _!_ F# [] [u2] }; _NO_DEFLT_ } _N_ },
+ cos = { _A_ 1 _U_ 1 _N_ _S_ "U(P)" {_A_ 1 _U_ 2 _N_ _N_ _F_ _IF_ARGS_ 0 1 X 3 \ (u0 :: Float#) -> case _#_ cosFloat# [] [u0] of { _PRIM_ (u1 :: Float#) -> _!_ F# [] [u1] } _N_} _F_ _IF_ARGS_ 0 1 C 4 \ (u0 :: Float) -> case u0 of { _ALG_ F# (u1 :: Float#) -> case _#_ cosFloat# [] [u1] of { _PRIM_ (u2 :: Float#) -> _!_ F# [] [u2] }; _NO_DEFLT_ } _N_ },
+ tan = { _A_ 1 _U_ 1 _N_ _S_ "U(P)" {_A_ 1 _U_ 2 _N_ _N_ _F_ _IF_ARGS_ 0 1 X 3 \ (u0 :: Float#) -> case _#_ tanFloat# [] [u0] of { _PRIM_ (u1 :: Float#) -> _!_ F# [] [u1] } _N_} _F_ _IF_ARGS_ 0 1 C 4 \ (u0 :: Float) -> case u0 of { _ALG_ F# (u1 :: Float#) -> case _#_ tanFloat# [] [u1] of { _PRIM_ (u2 :: Float#) -> _!_ F# [] [u2] }; _NO_DEFLT_ } _N_ },
+ asin = { _A_ 1 _U_ 1 _N_ _S_ "U(P)" {_A_ 1 _U_ 2 _N_ _N_ _F_ _IF_ARGS_ 0 1 X 3 \ (u0 :: Float#) -> case _#_ asinFloat# [] [u0] of { _PRIM_ (u1 :: Float#) -> _!_ F# [] [u1] } _N_} _F_ _IF_ARGS_ 0 1 C 4 \ (u0 :: Float) -> case u0 of { _ALG_ F# (u1 :: Float#) -> case _#_ asinFloat# [] [u1] of { _PRIM_ (u2 :: Float#) -> _!_ F# [] [u2] }; _NO_DEFLT_ } _N_ },
+ acos = { _A_ 1 _U_ 1 _N_ _S_ "U(P)" {_A_ 1 _U_ 2 _N_ _N_ _F_ _IF_ARGS_ 0 1 X 3 \ (u0 :: Float#) -> case _#_ acosFloat# [] [u0] of { _PRIM_ (u1 :: Float#) -> _!_ F# [] [u1] } _N_} _F_ _IF_ARGS_ 0 1 C 4 \ (u0 :: Float) -> case u0 of { _ALG_ F# (u1 :: Float#) -> case _#_ acosFloat# [] [u1] of { _PRIM_ (u2 :: Float#) -> _!_ F# [] [u2] }; _NO_DEFLT_ } _N_ },
+ atan = { _A_ 1 _U_ 1 _N_ _S_ "U(P)" {_A_ 1 _U_ 2 _N_ _N_ _F_ _IF_ARGS_ 0 1 X 3 \ (u0 :: Float#) -> case _#_ atanFloat# [] [u0] of { _PRIM_ (u1 :: Float#) -> _!_ F# [] [u1] } _N_} _F_ _IF_ARGS_ 0 1 C 4 \ (u0 :: Float) -> case u0 of { _ALG_ F# (u1 :: Float#) -> case _#_ atanFloat# [] [u1] of { _PRIM_ (u2 :: Float#) -> _!_ F# [] [u2] }; _NO_DEFLT_ } _N_ },
+ sinh = { _A_ 1 _U_ 1 _N_ _S_ "U(P)" {_A_ 1 _U_ 2 _N_ _N_ _F_ _IF_ARGS_ 0 1 X 3 \ (u0 :: Float#) -> case _#_ sinhFloat# [] [u0] of { _PRIM_ (u1 :: Float#) -> _!_ F# [] [u1] } _N_} _F_ _IF_ARGS_ 0 1 C 4 \ (u0 :: Float) -> case u0 of { _ALG_ F# (u1 :: Float#) -> case _#_ sinhFloat# [] [u1] of { _PRIM_ (u2 :: Float#) -> _!_ F# [] [u2] }; _NO_DEFLT_ } _N_ },
+ cosh = { _A_ 1 _U_ 1 _N_ _S_ "U(P)" {_A_ 1 _U_ 2 _N_ _N_ _F_ _IF_ARGS_ 0 1 X 3 \ (u0 :: Float#) -> case _#_ coshFloat# [] [u0] of { _PRIM_ (u1 :: Float#) -> _!_ F# [] [u1] } _N_} _F_ _IF_ARGS_ 0 1 C 4 \ (u0 :: Float) -> case u0 of { _ALG_ F# (u1 :: Float#) -> case _#_ coshFloat# [] [u1] of { _PRIM_ (u2 :: Float#) -> _!_ F# [] [u2] }; _NO_DEFLT_ } _N_ },
+ tanh = { _A_ 1 _U_ 1 _N_ _S_ "U(P)" {_A_ 1 _U_ 2 _N_ _N_ _F_ _IF_ARGS_ 0 1 X 3 \ (u0 :: Float#) -> case _#_ tanhFloat# [] [u0] of { _PRIM_ (u1 :: Float#) -> _!_ F# [] [u1] } _N_} _F_ _IF_ARGS_ 0 1 C 4 \ (u0 :: Float) -> case u0 of { _ALG_ F# (u1 :: Float#) -> case _#_ tanhFloat# [] [u1] of { _PRIM_ (u2 :: Float#) -> _!_ F# [] [u2] }; _NO_DEFLT_ } _N_ },
+ asinh = { _A_ 1 _U_ 1 _N_ _S_ "U(P)" {_A_ 1 _U_ 2 _N_ _N_ _N_ _N_} _N_ _N_ },
+ acosh = { _A_ 1 _U_ 1 _N_ _S_ "U(P)" {_A_ 1 _U_ 2 _N_ _N_ _N_ _N_} _N_ _N_ },
+ atanh = { _A_ 1 _U_ 1 _N_ _S_ "U(P)" {_A_ 1 _U_ 2 _N_ _N_ _N_ _N_} _N_ _N_ } #-}
instance RealFloat a => Fractional (Complex a)
{-# GHC_PRAGMA _M_ PreludeComplex {-dfun-} _A_ 2 _U_ 22 _N_ _N_ _N_ _N_ #-}
instance Fractional (Complex Double)
{-# GHC_PRAGMA _M_ PreludeComplex {-dfun-} _A_ 0 _N_ _N_ _N_ _F_ _IF_ARGS_ 0 0 X 5 _!_ _TUP_4 [{{Num (Complex Double)}}, (Complex Double -> Complex Double -> Complex Double), (Complex Double -> Complex Double), (Ratio Integer -> Complex Double)] [_DFUN_ Num (Complex Double), _CONSTM_ Fractional (/) (Complex Double), _CONSTM_ Fractional recip (Complex Double), _CONSTM_ Fractional fromRational (Complex Double)] _N_
- (/) = _A_ 2 _U_ 11 _N_ _S_ "U(LL)U(LL)" {_A_ 4 _U_ 2222 _N_ _N_ _N_ _N_} _N_ _N_,
- recip = _A_ 1 _U_ 1 _N_ _S_ "U(LL)" {_A_ 2 _U_ 22 _N_ _N_ _N_ _N_} _N_ _N_,
- fromRational = _A_ 1 _U_ 2 _N_ _N_ _N_ _N_ #-}
+ (/) = { _A_ 2 _U_ 11 _N_ _S_ "U(LL)U(LL)" {_A_ 4 _U_ 2222 _N_ _N_ _N_ _N_} _N_ _N_ },
+ recip = { _A_ 1 _U_ 1 _N_ _S_ "U(LL)" {_A_ 2 _U_ 22 _N_ _N_ _N_ _N_} _F_ _IF_ARGS_ 0 1 X 3 \ (u0 :: Complex Double) -> _APP_ _CONSTM_ Fractional (/) (Complex Double) [ _SPEC_ _ORIG_ PreludeCore __i1 [ (Complex Double) ], u0 ] _N_ },
+ fromRational = { _A_ 1 _U_ 1 _N_ _N_ _N_ _N_ } #-}
instance Fractional Double
{-# GHC_PRAGMA _M_ PreludeCore {-dfun-} _A_ 0 _N_ _N_ _N_ _F_ _IF_ARGS_ 0 0 X 5 _!_ _TUP_4 [{{Num Double}}, (Double -> Double -> Double), (Double -> Double), (Ratio Integer -> Double)] [_DFUN_ Num (Double), _CONSTM_ Fractional (/) (Double), _CONSTM_ Fractional recip (Double), _CONSTM_ Fractional fromRational (Double)] _N_
- (/) = _A_ 2 _U_ 11 _N_ _S_ "U(P)U(P)" {_A_ 2 _U_ 22 _N_ _N_ _F_ _IF_ARGS_ 0 2 XX 3 \ (u0 :: Double#) (u1 :: Double#) -> case _#_ divideDouble# [] [u0, u1] of { _PRIM_ (u2 :: Double#) -> _!_ D# [] [u2] } _N_} _F_ _IF_ARGS_ 0 2 CC 5 \ (u0 :: Double) (u1 :: Double) -> case u0 of { _ALG_ D# (u2 :: Double#) -> case u1 of { _ALG_ D# (u3 :: Double#) -> case _#_ divideDouble# [] [u2, u3] of { _PRIM_ (u4 :: Double#) -> _!_ D# [] [u4] }; _NO_DEFLT_ }; _NO_DEFLT_ } _N_,
- recip = _A_ 1 _U_ 1 _N_ _S_ "U(P)" {_A_ 1 _U_ 2 _N_ _N_ _F_ _IF_ARGS_ 0 1 X 3 \ (u0 :: Double#) -> case _#_ divideDouble# [] [1.0000000000000000##, u0] of { _PRIM_ (u1 :: Double#) -> _!_ D# [] [u1] } _N_} _F_ _IF_ARGS_ 0 1 C 4 \ (u0 :: Double) -> case u0 of { _ALG_ D# (u1 :: Double#) -> case _#_ divideDouble# [] [1.0000000000000000##, u1] of { _PRIM_ (u2 :: Double#) -> _!_ D# [] [u2] }; _NO_DEFLT_ } _N_,
- fromRational = _A_ 0 _U_ 2 _N_ _N_ _N_ _N_ #-}
+ (/) = { _A_ 2 _U_ 11 _N_ _S_ "U(P)U(P)" {_A_ 2 _U_ 22 _N_ _N_ _F_ _IF_ARGS_ 0 2 XX 3 \ (u0 :: Double#) (u1 :: Double#) -> case _#_ divideDouble# [] [u0, u1] of { _PRIM_ (u2 :: Double#) -> _!_ D# [] [u2] } _N_} _F_ _IF_ARGS_ 0 2 CC 5 \ (u0 :: Double) (u1 :: Double) -> case u0 of { _ALG_ D# (u2 :: Double#) -> case u1 of { _ALG_ D# (u3 :: Double#) -> case _#_ divideDouble# [] [u2, u3] of { _PRIM_ (u4 :: Double#) -> _!_ D# [] [u4] }; _NO_DEFLT_ }; _NO_DEFLT_ } _N_ },
+ recip = { _A_ 1 _U_ 1 _N_ _S_ "U(P)" {_A_ 1 _U_ 2 _N_ _N_ _F_ _IF_ARGS_ 0 1 X 3 \ (u0 :: Double#) -> case _#_ divideDouble# [] [1.0000000000000000##, u0] of { _PRIM_ (u1 :: Double#) -> _!_ D# [] [u1] } _N_} _F_ _IF_ARGS_ 0 1 C 4 \ (u0 :: Double) -> case u0 of { _ALG_ D# (u1 :: Double#) -> case _#_ divideDouble# [] [1.0000000000000000##, u1] of { _PRIM_ (u2 :: Double#) -> _!_ D# [] [u2] }; _NO_DEFLT_ } _N_ },
+ fromRational = { _A_ 1 _U_ 1 _N_ _S_ "U(U(PPP)U(PPP))" {_A_ 4 _U_ 2222 _N_ _N_ _N_ _N_} _N_ _N_ } #-}
instance Fractional Float
{-# GHC_PRAGMA _M_ PreludeCore {-dfun-} _A_ 0 _N_ _N_ _N_ _F_ _IF_ARGS_ 0 0 X 5 _!_ _TUP_4 [{{Num Float}}, (Float -> Float -> Float), (Float -> Float), (Ratio Integer -> Float)] [_DFUN_ Num (Float), _CONSTM_ Fractional (/) (Float), _CONSTM_ Fractional recip (Float), _CONSTM_ Fractional fromRational (Float)] _N_
- (/) = _A_ 2 _U_ 11 _N_ _S_ "U(P)U(P)" {_A_ 2 _U_ 22 _N_ _N_ _F_ _IF_ARGS_ 0 2 XX 3 \ (u0 :: Float#) (u1 :: Float#) -> case _#_ divideFloat# [] [u0, u1] of { _PRIM_ (u2 :: Float#) -> _!_ F# [] [u2] } _N_} _F_ _IF_ARGS_ 0 2 CC 5 \ (u0 :: Float) (u1 :: Float) -> case u0 of { _ALG_ F# (u2 :: Float#) -> case u1 of { _ALG_ F# (u3 :: Float#) -> case _#_ divideFloat# [] [u2, u3] of { _PRIM_ (u4 :: Float#) -> _!_ F# [] [u4] }; _NO_DEFLT_ }; _NO_DEFLT_ } _N_,
- recip = _A_ 0 _U_ 2 _N_ _N_ _N_ _N_,
- fromRational = _A_ 0 _U_ 2 _N_ _N_ _N_ _N_ #-}
+ (/) = { _A_ 2 _U_ 11 _N_ _S_ "U(P)U(P)" {_A_ 2 _U_ 22 _N_ _N_ _F_ _IF_ARGS_ 0 2 XX 3 \ (u0 :: Float#) (u1 :: Float#) -> case _#_ divideFloat# [] [u0, u1] of { _PRIM_ (u2 :: Float#) -> _!_ F# [] [u2] } _N_} _F_ _IF_ARGS_ 0 2 CC 5 \ (u0 :: Float) (u1 :: Float) -> case u0 of { _ALG_ F# (u2 :: Float#) -> case u1 of { _ALG_ F# (u3 :: Float#) -> case _#_ divideFloat# [] [u2, u3] of { _PRIM_ (u4 :: Float#) -> _!_ F# [] [u4] }; _NO_DEFLT_ }; _NO_DEFLT_ } _N_ },
+ recip = { _A_ 1 _U_ 1 _N_ _S_ "U(P)" {_A_ 1 _U_ 2 _N_ _N_ _F_ _IF_ARGS_ 0 1 X 3 \ (u0 :: Float#) -> case _#_ divideFloat# [] [1.0000000000000000#, u0] of { _PRIM_ (u1 :: Float#) -> _!_ F# [] [u1] } _N_} _F_ _IF_ARGS_ 0 1 C 4 \ (u0 :: Float) -> case u0 of { _ALG_ F# (u1 :: Float#) -> case _#_ divideFloat# [] [1.0000000000000000#, u1] of { _PRIM_ (u2 :: Float#) -> _!_ F# [] [u2] }; _NO_DEFLT_ } _N_ },
+ fromRational = { _A_ 1 _U_ 2 _N_ _N_ _N_ _N_ } #-}
instance Integral a => Fractional (Ratio a)
{-# GHC_PRAGMA _M_ PreludeRatio {-dfun-} _A_ 2 _U_ 22 _N_ _N_ _N_ _N_ #-}
instance Fractional (Ratio Integer)
{-# GHC_PRAGMA _M_ PreludeRatio {-dfun-} _A_ 0 _N_ _N_ _N_ _F_ _IF_ARGS_ 0 0 X 5 _!_ _TUP_4 [{{Num (Ratio Integer)}}, (Ratio Integer -> Ratio Integer -> Ratio Integer), (Ratio Integer -> Ratio Integer), (Ratio Integer -> Ratio Integer)] [_DFUN_ Num (Ratio Integer), _CONSTM_ Fractional (/) (Ratio Integer), _CONSTM_ Fractional recip (Ratio Integer), _CONSTM_ Fractional fromRational (Ratio Integer)] _N_
- (/) = _A_ 2 _U_ 11 _N_ _S_ "U(LU(PPP))U(U(PPP)L)" {_A_ 5 _U_ 22221 _N_ _N_ _N_ _N_} _N_ _N_,
- recip = _A_ 1 _U_ 1 _N_ _S_ "U(U(PPP)L)" {_A_ 4 _U_ 2222 _N_ _N_ _N_ _N_} _N_ _N_,
- fromRational = _A_ 1 _U_ 1 _N_ _S_ "U(LL)" {_A_ 2 _U_ 22 _N_ _N_ _F_ _IF_ARGS_ 0 2 XX 3 \ (u0 :: Integer) (u1 :: Integer) -> _!_ (:%) [Integer] [u0, u1] _N_} _F_ _IF_ARGS_ 0 1 X 1 \ (u0 :: Ratio Integer) -> u0 _N_ #-}
+ (/) = { _A_ 2 _U_ 11 _N_ _S_ "U(LU(PPP))U(U(PPP)L)" {_A_ 5 _U_ 22221 _N_ _N_ _N_ _N_} _N_ _N_ },
+ recip = { _A_ 1 _U_ 1 _N_ _S_ "U(U(PPP)L)" {_A_ 4 _U_ 2222 _N_ _N_ _N_ _N_} _N_ _N_ },
+ fromRational = { _A_ 1 _U_ 1 _N_ _S_ "U(LL)" {_A_ 2 _U_ 22 _N_ _N_ _F_ _IF_ARGS_ 0 2 XX 3 \ (u0 :: Integer) (u1 :: Integer) -> _!_ (:%) [Integer] [u0, u1] _N_} _F_ _IF_ARGS_ 0 1 X 1 \ (u0 :: Ratio Integer) -> u0 _N_ } #-}
instance Integral Int
{-# GHC_PRAGMA _M_ PreludeCore {-dfun-} _A_ 0 _N_ _N_ _N_ _F_ _IF_ARGS_ 0 0 X 13 _!_ _TUP_12 [{{Real Int}}, {{Ix Int}}, (Int -> Int -> Int), (Int -> Int -> Int), (Int -> Int -> Int), (Int -> Int -> Int), (Int -> Int -> (Int, Int)), (Int -> Int -> (Int, Int)), (Int -> Bool), (Int -> Bool), (Int -> Integer), (Int -> Int)] [_DFUN_ Real (Int), _DFUN_ Ix (Int), _CONSTM_ Integral quot (Int), _CONSTM_ Integral rem (Int), _CONSTM_ Integral div (Int), _CONSTM_ Integral mod (Int), _CONSTM_ Integral quotRem (Int), _CONSTM_ Integral divMod (Int), _CONSTM_ Integral even (Int), _CONSTM_ Integral odd (Int), _CONSTM_ Integral toInteger (Int), _CONSTM_ Integral toInt (Int)] _N_
- quot = _A_ 2 _U_ 11 _N_ _S_ "U(P)U(P)" {_A_ 2 _U_ 22 _N_ _N_ _F_ _IF_ARGS_ 0 2 XC 5 \ (u0 :: Int#) (u1 :: Int#) -> case u1 of { _PRIM_ 0# -> _APP_ _TYAPP_ error { Int } [ _NOREP_S_ "Integral.Int.quot{PreludeCore}: divide by 0\n" ]; (u2 :: Int#) -> case _#_ quotInt# [] [u0, u1] of { _PRIM_ (u3 :: Int#) -> _!_ I# [] [u3] } } _N_} _F_ _IF_ARGS_ 0 2 CC 7 \ (u0 :: Int) (u1 :: Int) -> case u1 of { _ALG_ I# (u2 :: Int#) -> case u2 of { _PRIM_ 0# -> _APP_ _TYAPP_ error { Int } [ _NOREP_S_ "Integral.Int.quot{PreludeCore}: divide by 0\n" ]; (u3 :: Int#) -> case u0 of { _ALG_ I# (u4 :: Int#) -> case _#_ quotInt# [] [u4, u2] of { _PRIM_ (u5 :: Int#) -> _!_ I# [] [u5] }; _NO_DEFLT_ } }; _NO_DEFLT_ } _N_,
- rem = _A_ 2 _U_ 11 _N_ _S_ "U(P)U(P)" {_A_ 2 _U_ 22 _N_ _N_ _F_ _IF_ARGS_ 0 2 XC 5 \ (u0 :: Int#) (u1 :: Int#) -> case u1 of { _PRIM_ 0# -> _APP_ _TYAPP_ error { Int } [ _NOREP_S_ "Integral.Int.rem{PreludeCore}: divide by 0\n" ]; (u2 :: Int#) -> case _#_ remInt# [] [u0, u1] of { _PRIM_ (u3 :: Int#) -> _!_ I# [] [u3] } } _N_} _F_ _IF_ARGS_ 0 2 CC 7 \ (u0 :: Int) (u1 :: Int) -> case u1 of { _ALG_ I# (u2 :: Int#) -> case u2 of { _PRIM_ 0# -> _APP_ _TYAPP_ error { Int } [ _NOREP_S_ "Integral.Int.rem{PreludeCore}: divide by 0\n" ]; (u3 :: Int#) -> case u0 of { _ALG_ I# (u4 :: Int#) -> case _#_ remInt# [] [u4, u2] of { _PRIM_ (u5 :: Int#) -> _!_ I# [] [u5] }; _NO_DEFLT_ } }; _NO_DEFLT_ } _N_,
- div = _A_ 2 _U_ 11 _N_ _S_ "U(P)U(P)" {_A_ 2 _U_ 22 _N_ _N_ _N_ _N_} _N_ _N_,
- mod = _A_ 2 _U_ 11 _N_ _S_ "U(P)U(P)" {_A_ 2 _U_ 22 _N_ _N_ _N_ _N_} _N_ _N_,
- quotRem = _A_ 2 _U_ 11 _N_ _S_ "U(P)U(P)" {_A_ 2 _U_ 22 _N_ _N_ _N_ _N_} _N_ _N_,
- divMod = _A_ 2 _U_ 11 _N_ _S_ "U(P)U(P)" {_A_ 2 _U_ 22 _N_ _N_ _N_ _N_} _N_ _N_,
- even = _A_ 1 _U_ 1 _N_ _S_ "U(P)" {_A_ 1 _U_ 2 _N_ _N_ _N_ _N_} _N_ _N_,
- odd = _A_ 1 _U_ 1 _N_ _S_ "U(P)" {_A_ 1 _U_ 2 _N_ _N_ _N_ _N_} _N_ _N_,
- toInteger = _A_ 1 _U_ 1 _N_ _S_ "U(P)" {_A_ 1 _U_ 2 _N_ _N_ _F_ _IF_ARGS_ 0 1 X 1 \ (u0 :: Int#) -> _#_ int2Integer# [] [u0] _N_} _F_ _IF_ARGS_ 0 1 C 2 \ (u0 :: Int) -> case u0 of { _ALG_ I# (u1 :: Int#) -> _#_ int2Integer# [] [u1]; _NO_DEFLT_ } _N_,
- toInt = _A_ 1 _U_ 1 _N_ _S_ "U(P)" {_A_ 1 _U_ 2 _N_ _N_ _F_ _IF_ARGS_ 0 1 X 2 \ (u0 :: Int#) -> _!_ I# [] [u0] _N_} _F_ _IF_ARGS_ 0 1 X 1 \ (u0 :: Int) -> u0 _N_ #-}
+ quot = { _A_ 2 _U_ 11 _N_ _S_ "U(P)U(P)" {_A_ 2 _U_ 22 _N_ _N_ _F_ _IF_ARGS_ 0 2 XC 5 \ (u0 :: Int#) (u1 :: Int#) -> case u1 of { _PRIM_ 0# -> _APP_ _TYAPP_ error { Int } [ _NOREP_S_ "Integral.Int.quot{PreludeCore}: divide by 0\n" ]; (u2 :: Int#) -> case _#_ quotInt# [] [u0, u1] of { _PRIM_ (u3 :: Int#) -> _!_ I# [] [u3] } } _N_} _F_ _IF_ARGS_ 0 2 CC 7 \ (u0 :: Int) (u1 :: Int) -> case u1 of { _ALG_ I# (u2 :: Int#) -> case u2 of { _PRIM_ 0# -> _APP_ _TYAPP_ error { Int } [ _NOREP_S_ "Integral.Int.quot{PreludeCore}: divide by 0\n" ]; (u3 :: Int#) -> case u0 of { _ALG_ I# (u4 :: Int#) -> case _#_ quotInt# [] [u4, u2] of { _PRIM_ (u5 :: Int#) -> _!_ I# [] [u5] }; _NO_DEFLT_ } }; _NO_DEFLT_ } _N_ },
+ rem = { _A_ 2 _U_ 11 _N_ _S_ "U(P)U(P)" {_A_ 2 _U_ 22 _N_ _N_ _F_ _IF_ARGS_ 0 2 XC 5 \ (u0 :: Int#) (u1 :: Int#) -> case u1 of { _PRIM_ 0# -> _APP_ _TYAPP_ error { Int } [ _NOREP_S_ "Integral.Int.rem{PreludeCore}: divide by 0\n" ]; (u2 :: Int#) -> case _#_ remInt# [] [u0, u1] of { _PRIM_ (u3 :: Int#) -> _!_ I# [] [u3] } } _N_} _F_ _IF_ARGS_ 0 2 CC 7 \ (u0 :: Int) (u1 :: Int) -> case u1 of { _ALG_ I# (u2 :: Int#) -> case u2 of { _PRIM_ 0# -> _APP_ _TYAPP_ error { Int } [ _NOREP_S_ "Integral.Int.rem{PreludeCore}: divide by 0\n" ]; (u3 :: Int#) -> case u0 of { _ALG_ I# (u4 :: Int#) -> case _#_ remInt# [] [u4, u2] of { _PRIM_ (u5 :: Int#) -> _!_ I# [] [u5] }; _NO_DEFLT_ } }; _NO_DEFLT_ } _N_ },
+ div = { _A_ 2 _U_ 11 _N_ _S_ "U(P)U(P)" {_A_ 2 _U_ 22 _N_ _N_ _N_ _N_} _N_ _N_ },
+ mod = { _A_ 2 _U_ 11 _N_ _S_ "U(P)U(P)" {_A_ 2 _U_ 22 _N_ _N_ _N_ _N_} _N_ _N_ },
+ quotRem = { _A_ 2 _U_ 11 _N_ _S_ "U(P)U(P)" {_A_ 2 _U_ 22 _N_ _N_ _N_ _N_} _N_ _N_ },
+ divMod = { _A_ 2 _U_ 11 _N_ _S_ "U(P)U(P)" {_A_ 2 _U_ 22 _N_ _N_ _N_ _N_} _N_ _N_ },
+ even = { _A_ 1 _U_ 1 _N_ _S_ "U(P)" {_A_ 1 _U_ 2 _N_ _N_ _N_ _N_} _N_ _N_ },
+ odd = { _A_ 1 _U_ 1 _N_ _S_ "U(P)" {_A_ 1 _U_ 2 _N_ _N_ _N_ _N_} _N_ _N_ },
+ toInteger = { _A_ 1 _U_ 1 _N_ _S_ "U(P)" {_A_ 1 _U_ 2 _N_ _N_ _F_ _IF_ARGS_ 0 1 X 1 \ (u0 :: Int#) -> _#_ int2Integer# [] [u0] _N_} _F_ _IF_ARGS_ 0 1 C 2 \ (u0 :: Int) -> case u0 of { _ALG_ I# (u1 :: Int#) -> _#_ int2Integer# [] [u1]; _NO_DEFLT_ } _N_ },
+ toInt = { _A_ 1 _U_ 1 _N_ _S_ "U(P)" {_A_ 1 _U_ 2 _N_ _N_ _F_ _IF_ARGS_ 0 1 X 2 \ (u0 :: Int#) -> _!_ I# [] [u0] _N_} _F_ _IF_ARGS_ 0 1 X 1 \ (u0 :: Int) -> u0 _N_ } #-}
instance Integral Integer
{-# GHC_PRAGMA _M_ PreludeCore {-dfun-} _A_ 0 _N_ _N_ _N_ _F_ _IF_ARGS_ 0 0 X 13 _!_ _TUP_12 [{{Real Integer}}, {{Ix Integer}}, (Integer -> Integer -> Integer), (Integer -> Integer -> Integer), (Integer -> Integer -> Integer), (Integer -> Integer -> Integer), (Integer -> Integer -> (Integer, Integer)), (Integer -> Integer -> (Integer, Integer)), (Integer -> Bool), (Integer -> Bool), (Integer -> Integer), (Integer -> Int)] [_DFUN_ Real (Integer), _DFUN_ Ix (Integer), _CONSTM_ Integral quot (Integer), _CONSTM_ Integral rem (Integer), _CONSTM_ Integral div (Integer), _CONSTM_ Integral mod (Integer), _CONSTM_ Integral quotRem (Integer), _CONSTM_ Integral divMod (Integer), _CONSTM_ Integral even (Integer), _CONSTM_ Integral odd (Integer), _CONSTM_ Integral toInteger (Integer), _CONSTM_ Integral toInt (Integer)] _N_
- quot = _A_ 2 _U_ 11 _N_ _S_ "U(PPP)U(PPP)" {_A_ 4 _U_ 2221 _N_ _N_ _F_ _IF_ARGS_ 0 4 XXXX 7 \ (u0 :: Int#) (u1 :: Int#) (u2 :: ByteArray#) (u3 :: Integer) -> case _APP_ _WRKR_ _CONSTM_ Integral quotRem (Integer) [ u0, u1, u2, u3 ] of { _ALG_ _TUP_2 (u4 :: Integer) (u5 :: Integer) -> u4; _NO_DEFLT_ } _N_} _F_ _IF_ARGS_ 0 2 XX 5 \ (u0 :: Integer) (u1 :: Integer) -> case _APP_ _CONSTM_ Integral quotRem (Integer) [ u0, u1 ] of { _ALG_ _TUP_2 (u2 :: Integer) (u3 :: Integer) -> u2; _NO_DEFLT_ } _N_,
- rem = _A_ 2 _U_ 11 _N_ _S_ "U(PPP)U(PPP)" {_A_ 4 _U_ 2221 _N_ _N_ _F_ _IF_ARGS_ 0 4 XXXX 7 \ (u0 :: Int#) (u1 :: Int#) (u2 :: ByteArray#) (u3 :: Integer) -> case _APP_ _WRKR_ _CONSTM_ Integral quotRem (Integer) [ u0, u1, u2, u3 ] of { _ALG_ _TUP_2 (u4 :: Integer) (u5 :: Integer) -> u5; _NO_DEFLT_ } _N_} _F_ _IF_ARGS_ 0 2 XX 5 \ (u0 :: Integer) (u1 :: Integer) -> case _APP_ _CONSTM_ Integral quotRem (Integer) [ u0, u1 ] of { _ALG_ _TUP_2 (u2 :: Integer) (u3 :: Integer) -> u3; _NO_DEFLT_ } _N_,
- div = _A_ 2 _U_ 12 _N_ _S_ "U(PPP)U(PPP)" {_A_ 4 _U_ 2222 _N_ _N_ _F_ _IF_ARGS_ 0 4 XXXX 7 \ (u0 :: Int#) (u1 :: Int#) (u2 :: ByteArray#) (u3 :: Integer) -> case _APP_ _WRKR_ _CONSTM_ Integral divMod (Integer) [ u0, u1, u2, u3 ] of { _ALG_ _TUP_2 (u4 :: Integer) (u5 :: Integer) -> u4; _NO_DEFLT_ } _N_} _F_ _IF_ARGS_ 0 2 XX 5 \ (u0 :: Integer) (u1 :: Integer) -> case _APP_ _CONSTM_ Integral divMod (Integer) [ u0, u1 ] of { _ALG_ _TUP_2 (u2 :: Integer) (u3 :: Integer) -> u2; _NO_DEFLT_ } _N_,
- mod = _A_ 2 _U_ 12 _N_ _S_ "U(PPP)U(PPP)" {_A_ 4 _U_ 2222 _N_ _N_ _F_ _IF_ARGS_ 0 4 XXXX 7 \ (u0 :: Int#) (u1 :: Int#) (u2 :: ByteArray#) (u3 :: Integer) -> case _APP_ _WRKR_ _CONSTM_ Integral divMod (Integer) [ u0, u1, u2, u3 ] of { _ALG_ _TUP_2 (u4 :: Integer) (u5 :: Integer) -> u5; _NO_DEFLT_ } _N_} _F_ _IF_ARGS_ 0 2 XX 5 \ (u0 :: Integer) (u1 :: Integer) -> case _APP_ _CONSTM_ Integral divMod (Integer) [ u0, u1 ] of { _ALG_ _TUP_2 (u2 :: Integer) (u3 :: Integer) -> u3; _NO_DEFLT_ } _N_,
- quotRem = _A_ 2 _U_ 11 _N_ _S_ "U(PPP)U(PPP)" {_A_ 4 _U_ 2221 _N_ _N_ _N_ _N_} _N_ _N_,
- divMod = _A_ 2 _U_ 12 _N_ _S_ "U(PPP)U(PPP)" {_A_ 4 _U_ 2222 _N_ _N_ _N_ _N_} _N_ _N_,
- even = _A_ 1 _U_ 1 _N_ _S_ "U(PPP)" {_A_ 3 _U_ 222 _N_ _N_ _N_ _N_} _N_ _N_,
- odd = _A_ 1 _U_ 1 _N_ _S_ "U(PPP)" {_A_ 3 _U_ 222 _N_ _N_ _N_ _N_} _N_ _N_,
- toInteger = _A_ 1 _U_ 1 _N_ _S_ "U(PPP)" {_A_ 3 _U_ 222 _N_ _N_ _F_ _IF_ARGS_ 0 3 XXX 4 \ (u0 :: Int#) (u1 :: Int#) (u2 :: ByteArray#) -> _!_ J# [] [u0, u1, u2] _N_} _F_ _IF_ARGS_ 0 1 X 1 \ (u0 :: Integer) -> u0 _N_,
- toInt = _A_ 1 _U_ 1 _N_ _S_ "U(PPP)" {_A_ 3 _U_ 222 _N_ _N_ _F_ _IF_ARGS_ 0 3 XXX 3 \ (u0 :: Int#) (u1 :: Int#) (u2 :: ByteArray#) -> case _#_ integer2Int# [] [u0, u1, u2] of { _PRIM_ (u3 :: Int#) -> _!_ I# [] [u3] } _N_} _F_ _IF_ARGS_ 0 1 C 4 \ (u0 :: Integer) -> case u0 of { _ALG_ J# (u1 :: Int#) (u2 :: Int#) (u3 :: ByteArray#) -> case _#_ integer2Int# [] [u1, u2, u3] of { _PRIM_ (u4 :: Int#) -> _!_ I# [] [u4] }; _NO_DEFLT_ } _N_ #-}
+ quot = { _A_ 2 _U_ 11 _N_ _S_ "U(PPP)U(PPP)" {_A_ 4 _U_ 2221 _N_ _N_ _F_ _IF_ARGS_ 0 4 XXXX 7 \ (u0 :: Int#) (u1 :: Int#) (u2 :: ByteArray#) (u3 :: Integer) -> case _APP_ _WRKR_ _CONSTM_ Integral quotRem (Integer) [ u0, u1, u2, u3 ] of { _ALG_ _TUP_2 (u4 :: Integer) (u5 :: Integer) -> u4; _NO_DEFLT_ } _N_} _F_ _IF_ARGS_ 0 2 XX 5 \ (u0 :: Integer) (u1 :: Integer) -> case _APP_ _CONSTM_ Integral quotRem (Integer) [ u0, u1 ] of { _ALG_ _TUP_2 (u2 :: Integer) (u3 :: Integer) -> u2; _NO_DEFLT_ } _N_ },
+ rem = { _A_ 2 _U_ 11 _N_ _S_ "U(PPP)U(PPP)" {_A_ 4 _U_ 2221 _N_ _N_ _F_ _IF_ARGS_ 0 4 XXXX 7 \ (u0 :: Int#) (u1 :: Int#) (u2 :: ByteArray#) (u3 :: Integer) -> case _APP_ _WRKR_ _CONSTM_ Integral quotRem (Integer) [ u0, u1, u2, u3 ] of { _ALG_ _TUP_2 (u4 :: Integer) (u5 :: Integer) -> u5; _NO_DEFLT_ } _N_} _F_ _IF_ARGS_ 0 2 XX 5 \ (u0 :: Integer) (u1 :: Integer) -> case _APP_ _CONSTM_ Integral quotRem (Integer) [ u0, u1 ] of { _ALG_ _TUP_2 (u2 :: Integer) (u3 :: Integer) -> u3; _NO_DEFLT_ } _N_ },
+ div = { _A_ 2 _U_ 12 _N_ _S_ "U(PPP)U(PPP)" {_A_ 4 _U_ 2222 _N_ _N_ _F_ _IF_ARGS_ 0 4 XXXX 7 \ (u0 :: Int#) (u1 :: Int#) (u2 :: ByteArray#) (u3 :: Integer) -> case _APP_ _WRKR_ _CONSTM_ Integral divMod (Integer) [ u0, u1, u2, u3 ] of { _ALG_ _TUP_2 (u4 :: Integer) (u5 :: Integer) -> u4; _NO_DEFLT_ } _N_} _F_ _IF_ARGS_ 0 2 XX 5 \ (u0 :: Integer) (u1 :: Integer) -> case _APP_ _CONSTM_ Integral divMod (Integer) [ u0, u1 ] of { _ALG_ _TUP_2 (u2 :: Integer) (u3 :: Integer) -> u2; _NO_DEFLT_ } _N_ },
+ mod = { _A_ 2 _U_ 12 _N_ _S_ "U(PPP)U(PPP)" {_A_ 4 _U_ 2222 _N_ _N_ _F_ _IF_ARGS_ 0 4 XXXX 7 \ (u0 :: Int#) (u1 :: Int#) (u2 :: ByteArray#) (u3 :: Integer) -> case _APP_ _WRKR_ _CONSTM_ Integral divMod (Integer) [ u0, u1, u2, u3 ] of { _ALG_ _TUP_2 (u4 :: Integer) (u5 :: Integer) -> u5; _NO_DEFLT_ } _N_} _F_ _IF_ARGS_ 0 2 XX 5 \ (u0 :: Integer) (u1 :: Integer) -> case _APP_ _CONSTM_ Integral divMod (Integer) [ u0, u1 ] of { _ALG_ _TUP_2 (u2 :: Integer) (u3 :: Integer) -> u3; _NO_DEFLT_ } _N_ },
+ quotRem = { _A_ 2 _U_ 11 _N_ _S_ "U(PPP)U(PPP)" {_A_ 4 _U_ 2221 _N_ _N_ _N_ _N_} _N_ _N_ },
+ divMod = { _A_ 2 _U_ 12 _N_ _S_ "U(PPP)U(PPP)" {_A_ 4 _U_ 2222 _N_ _N_ _N_ _N_} _N_ _N_ },
+ even = { _A_ 1 _U_ 1 _N_ _S_ "U(PPP)" {_A_ 3 _U_ 222 _N_ _N_ _N_ _N_} _N_ _N_ },
+ odd = { _A_ 1 _U_ 1 _N_ _S_ "U(PPP)" {_A_ 3 _U_ 222 _N_ _N_ _N_ _N_} _N_ _N_ },
+ toInteger = { _A_ 1 _U_ 1 _N_ _S_ "U(PPP)" {_A_ 3 _U_ 222 _N_ _N_ _F_ _IF_ARGS_ 0 3 XXX 4 \ (u0 :: Int#) (u1 :: Int#) (u2 :: ByteArray#) -> _!_ J# [] [u0, u1, u2] _N_} _F_ _IF_ARGS_ 0 1 X 1 \ (u0 :: Integer) -> u0 _N_ },
+ toInt = { _A_ 1 _U_ 1 _N_ _S_ "U(PPP)" {_A_ 3 _U_ 222 _N_ _N_ _F_ _IF_ARGS_ 0 3 XXX 3 \ (u0 :: Int#) (u1 :: Int#) (u2 :: ByteArray#) -> case _#_ integer2Int# [] [u0, u1, u2] of { _PRIM_ (u3 :: Int#) -> _!_ I# [] [u3] } _N_} _F_ _IF_ARGS_ 0 1 C 4 \ (u0 :: Integer) -> case u0 of { _ALG_ J# (u1 :: Int#) (u2 :: Int#) (u3 :: ByteArray#) -> case _#_ integer2Int# [] [u1, u2, u3] of { _PRIM_ (u4 :: Int#) -> _!_ I# [] [u4] }; _NO_DEFLT_ } _N_ } #-}
instance Ix ()
{-# GHC_PRAGMA _M_ PreludeBuiltin {-dfun-} _A_ 0 _N_ _N_ _N_ _F_ _IF_ARGS_ 0 0 X 5 _!_ _TUP_4 [{{Ord ()}}, (((), ()) -> [()]), (((), ()) -> () -> Int), (((), ()) -> () -> Bool)] [_DFUN_ Ord (()), _CONSTM_ Ix range (()), _CONSTM_ Ix index (()), _CONSTM_ Ix inRange (())] _N_
- range = _A_ 1 _U_ 1 _N_ _S_ "U(EE)" {_A_ 2 _U_ 21 _N_ _N_ _N_ _N_} _N_ _N_,
- index = _A_ 2 _U_ 11 _N_ _S_ "U(EE)E" {_A_ 3 _U_ 111 _N_ _N_ _F_ _IF_ARGS_ 0 3 CCC 5 \ (u0 :: ()) (u1 :: ()) (u2 :: ()) -> case u0 of { _ALG_ _TUP_0 -> case u1 of { _ALG_ _TUP_0 -> case u2 of { _ALG_ _TUP_0 -> _!_ I# [] [0#]; _NO_DEFLT_ }; _NO_DEFLT_ }; _NO_DEFLT_ } _N_} _F_ _IF_ARGS_ 0 2 CC 6 \ (u0 :: ((), ())) (u1 :: ()) -> case u0 of { _ALG_ _TUP_2 (u2 :: ()) (u3 :: ()) -> case u2 of { _ALG_ _TUP_0 -> case u3 of { _ALG_ _TUP_0 -> case u1 of { _ALG_ _TUP_0 -> _!_ I# [] [0#]; _NO_DEFLT_ }; _NO_DEFLT_ }; _NO_DEFLT_ }; _NO_DEFLT_ } _N_,
- inRange = _A_ 2 _U_ 11 _N_ _S_ "U(EE)E" {_A_ 3 _U_ 111 _N_ _N_ _F_ _IF_ARGS_ 0 3 CCC 4 \ (u0 :: ()) (u1 :: ()) (u2 :: ()) -> case u0 of { _ALG_ _TUP_0 -> case u1 of { _ALG_ _TUP_0 -> case u2 of { _ALG_ _TUP_0 -> _!_ True [] []; _NO_DEFLT_ }; _NO_DEFLT_ }; _NO_DEFLT_ } _N_} _F_ _IF_ARGS_ 0 2 CC 5 \ (u0 :: ((), ())) (u1 :: ()) -> case u0 of { _ALG_ _TUP_2 (u2 :: ()) (u3 :: ()) -> case u2 of { _ALG_ _TUP_0 -> case u3 of { _ALG_ _TUP_0 -> case u1 of { _ALG_ _TUP_0 -> _!_ True [] []; _NO_DEFLT_ }; _NO_DEFLT_ }; _NO_DEFLT_ }; _NO_DEFLT_ } _N_ #-}
+ range = { _A_ 1 _U_ 1 _N_ _S_ "U(EE)" {_A_ 2 _U_ 21 _N_ _N_ _N_ _N_} _N_ _N_ },
+ index = { _A_ 2 _U_ 11 _N_ _S_ "U(EE)E" {_A_ 3 _U_ 111 _N_ _N_ _F_ _IF_ARGS_ 0 3 CCC 5 \ (u0 :: ()) (u1 :: ()) (u2 :: ()) -> case u0 of { _ALG_ _TUP_0 -> case u1 of { _ALG_ _TUP_0 -> case u2 of { _ALG_ _TUP_0 -> _!_ I# [] [0#]; _NO_DEFLT_ }; _NO_DEFLT_ }; _NO_DEFLT_ } _N_} _F_ _IF_ARGS_ 0 2 CC 6 \ (u0 :: ((), ())) (u1 :: ()) -> case u0 of { _ALG_ _TUP_2 (u2 :: ()) (u3 :: ()) -> case u2 of { _ALG_ _TUP_0 -> case u3 of { _ALG_ _TUP_0 -> case u1 of { _ALG_ _TUP_0 -> _!_ I# [] [0#]; _NO_DEFLT_ }; _NO_DEFLT_ }; _NO_DEFLT_ }; _NO_DEFLT_ } _N_ },
+ inRange = { _A_ 2 _U_ 11 _N_ _S_ "U(EE)E" {_A_ 3 _U_ 111 _N_ _N_ _F_ _IF_ARGS_ 0 3 CCC 4 \ (u0 :: ()) (u1 :: ()) (u2 :: ()) -> case u0 of { _ALG_ _TUP_0 -> case u1 of { _ALG_ _TUP_0 -> case u2 of { _ALG_ _TUP_0 -> _!_ True [] []; _NO_DEFLT_ }; _NO_DEFLT_ }; _NO_DEFLT_ } _N_} _F_ _IF_ARGS_ 0 2 CC 5 \ (u0 :: ((), ())) (u1 :: ()) -> case u0 of { _ALG_ _TUP_2 (u2 :: ()) (u3 :: ()) -> case u2 of { _ALG_ _TUP_0 -> case u3 of { _ALG_ _TUP_0 -> case u1 of { _ALG_ _TUP_0 -> _!_ True [] []; _NO_DEFLT_ }; _NO_DEFLT_ }; _NO_DEFLT_ }; _NO_DEFLT_ } _N_ } #-}
instance (Ix a, Ix b) => Ix (a, b)
{-# GHC_PRAGMA _M_ PreludeBuiltin {-dfun-} _A_ 3 _U_ 222 _N_ _N_ _N_ _N_ #-}
instance (Ix a, Ix b, Ix c) => Ix (a, b, c)
{-# GHC_PRAGMA _M_ PreludeBuiltin {-dfun-} _A_ 6 _U_ 222222 _N_ _N_ _N_ _N_ #-}
instance Ix (Int, Int)
{-# GHC_PRAGMA _M_ PreludeBuiltin {-dfun-} _A_ 0 _N_ _N_ _N_ _F_ _IF_ARGS_ 0 0 X 5 _!_ _TUP_4 [{{Ord (Int, Int)}}, (((Int, Int), (Int, Int)) -> [(Int, Int)]), (((Int, Int), (Int, Int)) -> (Int, Int) -> Int), (((Int, Int), (Int, Int)) -> (Int, Int) -> Bool)] [_DFUN_ Ord ((Int, Int)), _CONSTM_ Ix range ((Int, Int)), _CONSTM_ Ix index ((Int, Int)), _CONSTM_ Ix inRange ((Int, Int))] _N_
- range = _A_ 1 _U_ 1 _N_ _S_ "U(SS)" {_A_ 2 _U_ 11 _N_ _N_ _N_ _N_} _N_ _N_,
- index = _A_ 2 _U_ 11 _N_ _S_ "U(SS)U(U(P)U(P))" {_A_ 4 _U_ 1122 _N_ _N_ _N_ _N_} _N_ _N_,
- inRange = _A_ 2 _U_ 11 _N_ _S_ "U(SS)U(U(P)L)" {_A_ 4 _U_ 1121 _N_ _N_ _N_ _N_} _N_ _N_ #-}
+ range = { _A_ 1 _U_ 1 _N_ _S_ "U(SS)" {_A_ 2 _U_ 11 _N_ _N_ _N_ _N_} _N_ _N_ },
+ index = { _A_ 2 _U_ 11 _N_ _S_ "U(SS)U(U(P)U(P))" {_A_ 4 _U_ 1122 _N_ _N_ _N_ _N_} _N_ _N_ },
+ inRange = { _A_ 2 _U_ 11 _N_ _S_ "U(SS)U(U(P)L)" {_A_ 4 _U_ 1121 _N_ _N_ _N_ _N_} _N_ _N_ } #-}
instance (Ix a, Ix b) => Ix (Assoc a b)
{-# GHC_PRAGMA _M_ PreludeArray {-dfun-} _A_ 3 _U_ 222 _N_ _N_ _N_ _N_ #-}
instance Ix Bool
{-# GHC_PRAGMA _M_ PreludeCore {-dfun-} _A_ 0 _N_ _N_ _N_ _F_ _IF_ARGS_ 0 0 X 5 _!_ _TUP_4 [{{Ord Bool}}, ((Bool, Bool) -> [Bool]), ((Bool, Bool) -> Bool -> Int), ((Bool, Bool) -> Bool -> Bool)] [_DFUN_ Ord (Bool), _CONSTM_ Ix range (Bool), _CONSTM_ Ix index (Bool), _CONSTM_ Ix inRange (Bool)] _N_
- range = _A_ 1 _U_ 1 _N_ _S_ "U(EE)" {_A_ 2 _U_ 11 _N_ _N_ _N_ _N_} _N_ _N_,
- index = _A_ 2 _U_ 11 _N_ _S_ "U(EA)E" {_A_ 2 _U_ 11 _N_ _N_ _N_ _N_} _N_ _N_,
- inRange = _A_ 2 _U_ 12 _N_ _S_ "U(EL)E" {_A_ 3 _U_ 112 _N_ _N_ _N_ _N_} _N_ _N_ #-}
+ range = { _A_ 1 _U_ 1 _N_ _S_ "U(EE)" {_A_ 2 _U_ 11 _N_ _N_ _N_ _N_} _N_ _N_ },
+ index = { _A_ 2 _U_ 11 _N_ _S_ "U(EA)E" {_A_ 2 _U_ 11 _N_ _N_ _N_ _N_} _N_ _N_ },
+ inRange = { _A_ 2 _U_ 12 _N_ _S_ "U(EL)E" {_A_ 3 _U_ 112 _N_ _N_ _N_ _N_} _N_ _N_ } #-}
instance Ix Char
{-# GHC_PRAGMA _M_ PreludeCore {-dfun-} _A_ 0 _N_ _N_ _N_ _F_ _IF_ARGS_ 0 0 X 5 _!_ _TUP_4 [{{Ord Char}}, ((Char, Char) -> [Char]), ((Char, Char) -> Char -> Int), ((Char, Char) -> Char -> Bool)] [_DFUN_ Ord (Char), _CONSTM_ Ix range (Char), _CONSTM_ Ix index (Char), _CONSTM_ Ix inRange (Char)] _N_
- range = _A_ 1 _U_ 1 _N_ _S_ "U(LL)" {_A_ 2 _U_ 22 _N_ _N_ _F_ _IF_ARGS_ 0 0 X 1 _CONSTM_ Enum enumFromTo (Char) _N_} _F_ _IF_ARGS_ 0 1 C 4 \ (u0 :: (Char, Char)) -> case u0 of { _ALG_ _TUP_2 (u1 :: Char) (u2 :: Char) -> _APP_ _CONSTM_ Enum enumFromTo (Char) [ u1, u2 ]; _NO_DEFLT_ } _N_,
- index = _A_ 2 _U_ 11 _N_ _S_ "U(U(P)L)U(P)" {_A_ 3 _U_ 212 _N_ _N_ _N_ _N_} _N_ _N_,
- inRange = _A_ 2 _U_ 11 _N_ _S_ "U(U(P)L)U(P)" {_A_ 3 _U_ 212 _N_ _N_ _N_ _N_} _N_ _N_ #-}
+ range = { _A_ 1 _U_ 1 _N_ _S_ "U(U(P)L)" {_A_ 2 _U_ 22 _N_ _N_ _N_ _N_} _F_ _IF_ARGS_ 0 1 C 4 \ (u0 :: (Char, Char)) -> case u0 of { _ALG_ _TUP_2 (u1 :: Char) (u2 :: Char) -> _APP_ _CONSTM_ Enum enumFromTo (Char) [ u1, u2 ]; _NO_DEFLT_ } _N_ },
+ index = { _A_ 2 _U_ 11 _N_ _S_ "U(U(P)L)U(P)" {_A_ 3 _U_ 212 _N_ _N_ _N_ _N_} _N_ _N_ },
+ inRange = { _A_ 2 _U_ 11 _N_ _S_ "U(U(P)L)U(P)" {_A_ 3 _U_ 212 _N_ _N_ _N_ _N_} _N_ _N_ } #-}
instance Ix Int
{-# GHC_PRAGMA _M_ PreludeCore {-dfun-} _A_ 0 _N_ _N_ _N_ _F_ _IF_ARGS_ 0 0 X 5 _!_ _TUP_4 [{{Ord Int}}, ((Int, Int) -> [Int]), ((Int, Int) -> Int -> Int), ((Int, Int) -> Int -> Bool)] [_DFUN_ Ord (Int), _CONSTM_ Ix range (Int), _CONSTM_ Ix index (Int), _CONSTM_ Ix inRange (Int)] _N_
- range = _A_ 1 _U_ 1 _N_ _S_ "U(U(P)U(P))" {_A_ 2 _U_ 22 _N_ _N_ _N_ _N_} _N_ _N_,
- index = _A_ 2 _U_ 11 _N_ _S_ "U(U(P)U(P))U(P)" {_A_ 3 _U_ 222 _N_ _N_ _N_ _N_} _N_ _N_,
- inRange = _A_ 2 _U_ 11 _N_ _S_ "U(U(P)U(P))U(P)" {_A_ 3 _U_ 222 _N_ _N_ _F_ _IF_ARGS_ 0 3 XXX 5 \ (u0 :: Int#) (u1 :: Int#) (u2 :: Int#) -> case _#_ leInt# [] [u0, u2] of { _ALG_ True -> _#_ leInt# [] [u2, u1]; False -> _!_ False [] []; _NO_DEFLT_ } _N_} _F_ _ALWAYS_ \ (u0 :: (Int, Int)) (u1 :: Int) -> case u0 of { _ALG_ _TUP_2 (u2 :: Int) (u3 :: Int) -> case u2 of { _ALG_ I# (u4 :: Int#) -> case u3 of { _ALG_ I# (u5 :: Int#) -> case u1 of { _ALG_ I# (u6 :: Int#) -> case _#_ leInt# [] [u4, u6] of { _ALG_ True -> _#_ leInt# [] [u6, u5]; False -> _!_ False [] []; _NO_DEFLT_ }; _NO_DEFLT_ }; _NO_DEFLT_ }; _NO_DEFLT_ }; _NO_DEFLT_ } _N_ #-}
+ range = { _A_ 1 _U_ 1 _N_ _S_ "U(U(P)U(P))" {_A_ 2 _U_ 22 _N_ _N_ _N_ _N_} _N_ _N_ },
+ index = { _A_ 2 _U_ 11 _N_ _S_ "U(U(P)U(P))U(P)" {_A_ 3 _U_ 222 _N_ _N_ _N_ _N_} _N_ _N_ },
+ inRange = { _A_ 2 _U_ 11 _N_ _S_ "U(U(P)U(P))U(P)" {_A_ 3 _U_ 222 _N_ _N_ _F_ _IF_ARGS_ 0 3 XXX 5 \ (u0 :: Int#) (u1 :: Int#) (u2 :: Int#) -> case _#_ leInt# [] [u0, u2] of { _ALG_ True -> _#_ leInt# [] [u2, u1]; False -> _!_ False [] []; _NO_DEFLT_ } _N_} _F_ _ALWAYS_ \ (u0 :: (Int, Int)) (u1 :: Int) -> case u0 of { _ALG_ _TUP_2 (u2 :: Int) (u3 :: Int) -> case u2 of { _ALG_ I# (u4 :: Int#) -> case u3 of { _ALG_ I# (u5 :: Int#) -> case u1 of { _ALG_ I# (u6 :: Int#) -> case _#_ leInt# [] [u4, u6] of { _ALG_ True -> _#_ leInt# [] [u6, u5]; False -> _!_ False [] []; _NO_DEFLT_ }; _NO_DEFLT_ }; _NO_DEFLT_ }; _NO_DEFLT_ }; _NO_DEFLT_ } _N_ } #-}
instance Ix Integer
{-# GHC_PRAGMA _M_ PreludeCore {-dfun-} _A_ 0 _N_ _N_ _N_ _F_ _IF_ARGS_ 0 0 X 5 _!_ _TUP_4 [{{Ord Integer}}, ((Integer, Integer) -> [Integer]), ((Integer, Integer) -> Integer -> Int), ((Integer, Integer) -> Integer -> Bool)] [_DFUN_ Ord (Integer), _CONSTM_ Ix range (Integer), _CONSTM_ Ix index (Integer), _CONSTM_ Ix inRange (Integer)] _N_
- range = _A_ 1 _U_ 1 _N_ _S_ "U(LL)" {_A_ 2 _U_ 22 _N_ _N_ _F_ _IF_ARGS_ 0 0 X 1 _CONSTM_ Enum enumFromTo (Integer) _N_} _F_ _IF_ARGS_ 0 1 C 4 \ (u0 :: (Integer, Integer)) -> case u0 of { _ALG_ _TUP_2 (u1 :: Integer) (u2 :: Integer) -> _APP_ _CONSTM_ Enum enumFromTo (Integer) [ u1, u2 ]; _NO_DEFLT_ } _N_,
- index = _A_ 2 _U_ 12 _N_ _S_ "U(U(PPP)L)U(PPP)" {_A_ 5 _U_ 22222 _N_ _N_ _N_ _N_} _N_ _N_,
- inRange = _A_ 2 _U_ 11 _N_ _S_ "U(U(PPP)L)U(PPP)" {_A_ 5 _U_ 22211 _N_ _N_ _F_ _IF_ARGS_ 0 5 XXXCC 9 \ (u0 :: Int#) (u1 :: Int#) (u2 :: ByteArray#) (u3 :: Integer) (u4 :: Integer) -> case u4 of { _ALG_ J# (u5 :: Int#) (u6 :: Int#) (u7 :: ByteArray#) -> case _#_ cmpInteger# [] [u0, u1, u2, u5, u6, u7] of { _PRIM_ (u8 :: Int#) -> case _#_ leInt# [] [u8, 0#] of { _ALG_ True -> case u3 of { _ALG_ J# (u9 :: Int#) (ua :: Int#) (ub :: ByteArray#) -> case _#_ cmpInteger# [] [u5, u6, u7, u9, ua, ub] of { _PRIM_ (uc :: Int#) -> _#_ leInt# [] [uc, 0#] }; _NO_DEFLT_ }; False -> _!_ False [] []; _NO_DEFLT_ } }; _NO_DEFLT_ } _N_} _N_ _N_ #-}
+ range = { _A_ 1 _U_ 1 _N_ _S_ "U(LL)" {_A_ 2 _U_ 22 _N_ _N_ _F_ _IF_ARGS_ 0 0 X 1 _CONSTM_ Enum enumFromTo (Integer) _N_} _F_ _IF_ARGS_ 0 1 C 4 \ (u0 :: (Integer, Integer)) -> case u0 of { _ALG_ _TUP_2 (u1 :: Integer) (u2 :: Integer) -> _APP_ _CONSTM_ Enum enumFromTo (Integer) [ u1, u2 ]; _NO_DEFLT_ } _N_ },
+ index = { _A_ 2 _U_ 12 _N_ _S_ "U(U(PPP)L)U(PPP)" {_A_ 5 _U_ 22222 _N_ _N_ _N_ _N_} _N_ _N_ },
+ inRange = { _A_ 2 _U_ 11 _N_ _S_ "U(U(PPP)L)U(PPP)" {_A_ 5 _U_ 22211 _N_ _N_ _F_ _IF_ARGS_ 0 5 XXXCC 9 \ (u0 :: Int#) (u1 :: Int#) (u2 :: ByteArray#) (u3 :: Integer) (u4 :: Integer) -> case u4 of { _ALG_ J# (u5 :: Int#) (u6 :: Int#) (u7 :: ByteArray#) -> case _#_ cmpInteger# [] [u0, u1, u2, u5, u6, u7] of { _PRIM_ (u8 :: Int#) -> case _#_ leInt# [] [u8, 0#] of { _ALG_ True -> case u3 of { _ALG_ J# (u9 :: Int#) (ua :: Int#) (ub :: ByteArray#) -> case _#_ cmpInteger# [] [u5, u6, u7, u9, ua, ub] of { _PRIM_ (uc :: Int#) -> _#_ leInt# [] [uc, 0#] }; _NO_DEFLT_ }; False -> _!_ False [] []; _NO_DEFLT_ } }; _NO_DEFLT_ } _N_} _N_ _N_ } #-}
instance RealFloat a => Num (Complex a)
{-# GHC_PRAGMA _M_ PreludeComplex {-dfun-} _A_ 3 _U_ 222 _N_ _N_ _N_ _N_ #-}
instance Num (Complex Double)
- {-# GHC_PRAGMA _M_ PreludeComplex {-dfun-} _A_ 0 _N_ _N_ _N_ _N_ _N_
- (+) = _A_ 2 _U_ 11 _N_ _S_ "U(LL)U(LL)" {_A_ 4 _U_ 1111 _N_ _N_ _N_ _N_} _N_ _N_,
- (-) = _A_ 2 _U_ 11 _N_ _S_ "U(LL)U(LL)" {_A_ 4 _U_ 1111 _N_ _N_ _N_ _N_} _N_ _N_,
- (*) = _A_ 2 _U_ 11 _N_ _S_ "U(LL)U(LL)" {_A_ 4 _U_ 2222 _N_ _N_ _N_ _N_} _N_ _N_,
- negate = _A_ 1 _U_ 1 _N_ _S_ "U(LL)" {_A_ 2 _U_ 11 _N_ _N_ _N_ _N_} _N_ _N_,
- abs = _A_ 1 _U_ 1 _N_ _N_ _N_ _N_,
- signum = _A_ 1 _U_ 1 _N_ _S_ "U(U(P)L)" {_A_ 2 _U_ 22 _N_ _N_ _N_ _N_} _N_ _N_,
- fromInteger = _A_ 1 _U_ 1 _N_ _N_ _N_ _N_,
- fromInt = _A_ 1 _U_ 1 _N_ _N_ _N_ _N_ #-}
+ {-# GHC_PRAGMA _M_ PreludeComplex {-dfun-} _A_ 0 _N_ _N_ _N_ _F_ _IF_ARGS_ 0 0 X 11 _!_ _TUP_10 [{{Eq (Complex Double)}}, {{Text (Complex Double)}}, (Complex Double -> Complex Double -> Complex Double), (Complex Double -> Complex Double -> Complex Double), (Complex Double -> Complex Double -> Complex Double), (Complex Double -> Complex Double), (Complex Double -> Complex Double), (Complex Double -> Complex Double), (Integer -> Complex Double), (Int -> Complex Double)] [_DFUN_ Eq (Complex Double), _DFUN_ Text (Complex Double), _CONSTM_ Num (+) (Complex Double), _CONSTM_ Num (-) (Complex Double), _CONSTM_ Num (*) (Complex Double), _CONSTM_ Num negate (Complex Double), _CONSTM_ Num abs (Complex Double), _CONSTM_ Num signum (Complex Double), _CONSTM_ Num fromInteger (Complex Double), _CONSTM_ Num fromInt (Complex Double)] _N_
+ (+) = { _A_ 2 _U_ 11 _N_ _S_ "U(LL)U(LL)" {_A_ 4 _U_ 1111 _N_ _N_ _N_ _N_} _N_ _N_ },
+ (-) = { _A_ 2 _U_ 11 _N_ _S_ "U(LL)U(LL)" {_A_ 4 _U_ 1111 _N_ _N_ _N_ _N_} _N_ _N_ },
+ (*) = { _A_ 2 _U_ 11 _N_ _S_ "U(LL)U(LL)" {_A_ 4 _U_ 2222 _N_ _N_ _N_ _N_} _N_ _N_ },
+ negate = { _A_ 1 _U_ 1 _N_ _S_ "U(LL)" {_A_ 2 _U_ 11 _N_ _N_ _N_ _N_} _N_ _N_ },
+ abs = { _A_ 1 _U_ 1 _N_ _N_ _N_ _N_ },
+ signum = { _A_ 1 _U_ 1 _N_ _S_ "U(U(P)L)" {_A_ 2 _U_ 22 _N_ _N_ _N_ _N_} _N_ _N_ },
+ fromInteger = { _A_ 1 _U_ 1 _N_ _N_ _N_ _N_ },
+ fromInt = { _A_ 1 _U_ 1 _N_ _N_ _N_ _N_ } #-}
instance Num Double
{-# GHC_PRAGMA _M_ PreludeCore {-dfun-} _A_ 0 _N_ _N_ _N_ _F_ _IF_ARGS_ 0 0 X 11 _!_ _TUP_10 [{{Eq Double}}, {{Text Double}}, (Double -> Double -> Double), (Double -> Double -> Double), (Double -> Double -> Double), (Double -> Double), (Double -> Double), (Double -> Double), (Integer -> Double), (Int -> Double)] [_DFUN_ Eq (Double), _DFUN_ Text (Double), _CONSTM_ Num (+) (Double), _CONSTM_ Num (-) (Double), _CONSTM_ Num (*) (Double), _CONSTM_ Num negate (Double), _CONSTM_ Num abs (Double), _CONSTM_ Num signum (Double), _CONSTM_ Num fromInteger (Double), _CONSTM_ Num fromInt (Double)] _N_
- (+) = _A_ 2 _U_ 11 _N_ _S_ "U(P)U(P)" {_A_ 2 _U_ 22 _N_ _N_ _F_ _IF_ARGS_ 0 2 XX 3 \ (u0 :: Double#) (u1 :: Double#) -> case _#_ plusDouble# [] [u0, u1] of { _PRIM_ (u2 :: Double#) -> _!_ D# [] [u2] } _N_} _F_ _IF_ARGS_ 0 2 CC 5 \ (u0 :: Double) (u1 :: Double) -> case u0 of { _ALG_ D# (u2 :: Double#) -> case u1 of { _ALG_ D# (u3 :: Double#) -> case _#_ plusDouble# [] [u2, u3] of { _PRIM_ (u4 :: Double#) -> _!_ D# [] [u4] }; _NO_DEFLT_ }; _NO_DEFLT_ } _N_,
- (-) = _A_ 2 _U_ 11 _N_ _S_ "U(P)U(P)" {_A_ 2 _U_ 22 _N_ _N_ _F_ _IF_ARGS_ 0 2 XX 3 \ (u0 :: Double#) (u1 :: Double#) -> case _#_ minusDouble# [] [u0, u1] of { _PRIM_ (u2 :: Double#) -> _!_ D# [] [u2] } _N_} _F_ _IF_ARGS_ 0 2 CC 5 \ (u0 :: Double) (u1 :: Double) -> case u0 of { _ALG_ D# (u2 :: Double#) -> case u1 of { _ALG_ D# (u3 :: Double#) -> case _#_ minusDouble# [] [u2, u3] of { _PRIM_ (u4 :: Double#) -> _!_ D# [] [u4] }; _NO_DEFLT_ }; _NO_DEFLT_ } _N_,
- (*) = _A_ 2 _U_ 11 _N_ _S_ "U(P)U(P)" {_A_ 2 _U_ 22 _N_ _N_ _F_ _IF_ARGS_ 0 2 XX 3 \ (u0 :: Double#) (u1 :: Double#) -> case _#_ timesDouble# [] [u0, u1] of { _PRIM_ (u2 :: Double#) -> _!_ D# [] [u2] } _N_} _F_ _IF_ARGS_ 0 2 CC 5 \ (u0 :: Double) (u1 :: Double) -> case u0 of { _ALG_ D# (u2 :: Double#) -> case u1 of { _ALG_ D# (u3 :: Double#) -> case _#_ timesDouble# [] [u2, u3] of { _PRIM_ (u4 :: Double#) -> _!_ D# [] [u4] }; _NO_DEFLT_ }; _NO_DEFLT_ } _N_,
- negate = _A_ 1 _U_ 1 _N_ _S_ "U(P)" {_A_ 1 _U_ 2 _N_ _N_ _F_ _IF_ARGS_ 0 1 X 3 \ (u0 :: Double#) -> case _#_ negateDouble# [] [u0] of { _PRIM_ (u1 :: Double#) -> _!_ D# [] [u1] } _N_} _F_ _IF_ARGS_ 0 1 C 4 \ (u0 :: Double) -> case u0 of { _ALG_ D# (u1 :: Double#) -> case _#_ negateDouble# [] [u1] of { _PRIM_ (u2 :: Double#) -> _!_ D# [] [u2] }; _NO_DEFLT_ } _N_,
- abs = _A_ 1 _U_ 1 _N_ _S_ "U(P)" {_A_ 1 _U_ 2 _N_ _N_ _N_ _N_} _N_ _N_,
- signum = _A_ 1 _U_ 1 _N_ _S_ "U(P)" {_A_ 1 _U_ 2 _N_ _N_ _N_ _N_} _N_ _N_,
- fromInteger = _A_ 1 _U_ 1 _N_ _S_ "U(PPP)" {_A_ 3 _U_ 222 _N_ _N_ _F_ _IF_ARGS_ 0 3 XXX 3 \ (u0 :: Int#) (u1 :: Int#) (u2 :: ByteArray#) -> case _#_ encodeDouble# [] [u0, u1, u2, 0#] of { _PRIM_ (u3 :: Double#) -> _!_ D# [] [u3] } _N_} _F_ _IF_ARGS_ 0 1 C 4 \ (u0 :: Integer) -> case u0 of { _ALG_ J# (u1 :: Int#) (u2 :: Int#) (u3 :: ByteArray#) -> case _#_ encodeDouble# [] [u1, u2, u3, 0#] of { _PRIM_ (u4 :: Double#) -> _!_ D# [] [u4] }; _NO_DEFLT_ } _N_,
- fromInt = _A_ 1 _U_ 1 _N_ _S_ "U(P)" {_A_ 1 _U_ 2 _N_ _N_ _F_ _IF_ARGS_ 0 1 X 3 \ (u0 :: Int#) -> case _#_ int2Double# [] [u0] of { _PRIM_ (u1 :: Double#) -> _!_ D# [] [u1] } _N_} _F_ _IF_ARGS_ 0 1 C 4 \ (u0 :: Int) -> case u0 of { _ALG_ I# (u1 :: Int#) -> case _#_ int2Double# [] [u1] of { _PRIM_ (u2 :: Double#) -> _!_ D# [] [u2] }; _NO_DEFLT_ } _N_ #-}
+ (+) = { _A_ 2 _U_ 11 _N_ _S_ "U(P)U(P)" {_A_ 2 _U_ 22 _N_ _N_ _F_ _IF_ARGS_ 0 2 XX 3 \ (u0 :: Double#) (u1 :: Double#) -> case _#_ plusDouble# [] [u0, u1] of { _PRIM_ (u2 :: Double#) -> _!_ D# [] [u2] } _N_} _F_ _IF_ARGS_ 0 2 CC 5 \ (u0 :: Double) (u1 :: Double) -> case u0 of { _ALG_ D# (u2 :: Double#) -> case u1 of { _ALG_ D# (u3 :: Double#) -> case _#_ plusDouble# [] [u2, u3] of { _PRIM_ (u4 :: Double#) -> _!_ D# [] [u4] }; _NO_DEFLT_ }; _NO_DEFLT_ } _N_ },
+ (-) = { _A_ 2 _U_ 11 _N_ _S_ "U(P)U(P)" {_A_ 2 _U_ 22 _N_ _N_ _F_ _IF_ARGS_ 0 2 XX 3 \ (u0 :: Double#) (u1 :: Double#) -> case _#_ minusDouble# [] [u0, u1] of { _PRIM_ (u2 :: Double#) -> _!_ D# [] [u2] } _N_} _F_ _IF_ARGS_ 0 2 CC 5 \ (u0 :: Double) (u1 :: Double) -> case u0 of { _ALG_ D# (u2 :: Double#) -> case u1 of { _ALG_ D# (u3 :: Double#) -> case _#_ minusDouble# [] [u2, u3] of { _PRIM_ (u4 :: Double#) -> _!_ D# [] [u4] }; _NO_DEFLT_ }; _NO_DEFLT_ } _N_ },
+ (*) = { _A_ 2 _U_ 11 _N_ _S_ "U(P)U(P)" {_A_ 2 _U_ 22 _N_ _N_ _F_ _IF_ARGS_ 0 2 XX 3 \ (u0 :: Double#) (u1 :: Double#) -> case _#_ timesDouble# [] [u0, u1] of { _PRIM_ (u2 :: Double#) -> _!_ D# [] [u2] } _N_} _F_ _IF_ARGS_ 0 2 CC 5 \ (u0 :: Double) (u1 :: Double) -> case u0 of { _ALG_ D# (u2 :: Double#) -> case u1 of { _ALG_ D# (u3 :: Double#) -> case _#_ timesDouble# [] [u2, u3] of { _PRIM_ (u4 :: Double#) -> _!_ D# [] [u4] }; _NO_DEFLT_ }; _NO_DEFLT_ } _N_ },
+ negate = { _A_ 1 _U_ 1 _N_ _S_ "U(P)" {_A_ 1 _U_ 2 _N_ _N_ _F_ _IF_ARGS_ 0 1 X 3 \ (u0 :: Double#) -> case _#_ negateDouble# [] [u0] of { _PRIM_ (u1 :: Double#) -> _!_ D# [] [u1] } _N_} _F_ _IF_ARGS_ 0 1 C 4 \ (u0 :: Double) -> case u0 of { _ALG_ D# (u1 :: Double#) -> case _#_ negateDouble# [] [u1] of { _PRIM_ (u2 :: Double#) -> _!_ D# [] [u2] }; _NO_DEFLT_ } _N_ },
+ abs = { _A_ 1 _U_ 1 _N_ _S_ "U(P)" {_A_ 1 _U_ 2 _N_ _N_ _N_ _N_} _N_ _N_ },
+ signum = { _A_ 1 _U_ 1 _N_ _S_ "U(P)" {_A_ 1 _U_ 2 _N_ _N_ _N_ _N_} _N_ _N_ },
+ fromInteger = { _A_ 1 _U_ 1 _N_ _S_ "U(PPP)" {_A_ 3 _U_ 222 _N_ _N_ _F_ _IF_ARGS_ 0 3 XXX 3 \ (u0 :: Int#) (u1 :: Int#) (u2 :: ByteArray#) -> case _#_ encodeDouble# [] [u0, u1, u2, 0#] of { _PRIM_ (u3 :: Double#) -> _!_ D# [] [u3] } _N_} _F_ _IF_ARGS_ 0 1 C 4 \ (u0 :: Integer) -> case u0 of { _ALG_ J# (u1 :: Int#) (u2 :: Int#) (u3 :: ByteArray#) -> case _#_ encodeDouble# [] [u1, u2, u3, 0#] of { _PRIM_ (u4 :: Double#) -> _!_ D# [] [u4] }; _NO_DEFLT_ } _N_ },
+ fromInt = { _A_ 1 _U_ 1 _N_ _S_ "U(P)" {_A_ 1 _U_ 2 _N_ _N_ _F_ _IF_ARGS_ 0 1 X 3 \ (u0 :: Int#) -> case _#_ int2Double# [] [u0] of { _PRIM_ (u1 :: Double#) -> _!_ D# [] [u1] } _N_} _F_ _IF_ARGS_ 0 1 C 4 \ (u0 :: Int) -> case u0 of { _ALG_ I# (u1 :: Int#) -> case _#_ int2Double# [] [u1] of { _PRIM_ (u2 :: Double#) -> _!_ D# [] [u2] }; _NO_DEFLT_ } _N_ } #-}
instance Num Float
{-# GHC_PRAGMA _M_ PreludeCore {-dfun-} _A_ 0 _N_ _N_ _N_ _F_ _IF_ARGS_ 0 0 X 11 _!_ _TUP_10 [{{Eq Float}}, {{Text Float}}, (Float -> Float -> Float), (Float -> Float -> Float), (Float -> Float -> Float), (Float -> Float), (Float -> Float), (Float -> Float), (Integer -> Float), (Int -> Float)] [_DFUN_ Eq (Float), _DFUN_ Text (Float), _CONSTM_ Num (+) (Float), _CONSTM_ Num (-) (Float), _CONSTM_ Num (*) (Float), _CONSTM_ Num negate (Float), _CONSTM_ Num abs (Float), _CONSTM_ Num signum (Float), _CONSTM_ Num fromInteger (Float), _CONSTM_ Num fromInt (Float)] _N_
- (+) = _A_ 2 _U_ 11 _N_ _S_ "U(P)U(P)" {_A_ 2 _U_ 22 _N_ _N_ _F_ _IF_ARGS_ 0 2 XX 3 \ (u0 :: Float#) (u1 :: Float#) -> case _#_ plusFloat# [] [u0, u1] of { _PRIM_ (u2 :: Float#) -> _!_ F# [] [u2] } _N_} _F_ _IF_ARGS_ 0 2 CC 5 \ (u0 :: Float) (u1 :: Float) -> case u0 of { _ALG_ F# (u2 :: Float#) -> case u1 of { _ALG_ F# (u3 :: Float#) -> case _#_ plusFloat# [] [u2, u3] of { _PRIM_ (u4 :: Float#) -> _!_ F# [] [u4] }; _NO_DEFLT_ }; _NO_DEFLT_ } _N_,
- (-) = _A_ 2 _U_ 11 _N_ _S_ "U(P)U(P)" {_A_ 2 _U_ 22 _N_ _N_ _F_ _IF_ARGS_ 0 2 XX 3 \ (u0 :: Float#) (u1 :: Float#) -> case _#_ minusFloat# [] [u0, u1] of { _PRIM_ (u2 :: Float#) -> _!_ F# [] [u2] } _N_} _F_ _IF_ARGS_ 0 2 CC 5 \ (u0 :: Float) (u1 :: Float) -> case u0 of { _ALG_ F# (u2 :: Float#) -> case u1 of { _ALG_ F# (u3 :: Float#) -> case _#_ minusFloat# [] [u2, u3] of { _PRIM_ (u4 :: Float#) -> _!_ F# [] [u4] }; _NO_DEFLT_ }; _NO_DEFLT_ } _N_,
- (*) = _A_ 2 _U_ 11 _N_ _S_ "U(P)U(P)" {_A_ 2 _U_ 22 _N_ _N_ _F_ _IF_ARGS_ 0 2 XX 3 \ (u0 :: Float#) (u1 :: Float#) -> case _#_ timesFloat# [] [u0, u1] of { _PRIM_ (u2 :: Float#) -> _!_ F# [] [u2] } _N_} _F_ _IF_ARGS_ 0 2 CC 5 \ (u0 :: Float) (u1 :: Float) -> case u0 of { _ALG_ F# (u2 :: Float#) -> case u1 of { _ALG_ F# (u3 :: Float#) -> case _#_ timesFloat# [] [u2, u3] of { _PRIM_ (u4 :: Float#) -> _!_ F# [] [u4] }; _NO_DEFLT_ }; _NO_DEFLT_ } _N_,
- negate = _A_ 1 _U_ 1 _N_ _S_ "U(P)" {_A_ 1 _U_ 2 _N_ _N_ _F_ _IF_ARGS_ 0 1 X 3 \ (u0 :: Float#) -> case _#_ negateFloat# [] [u0] of { _PRIM_ (u1 :: Float#) -> _!_ F# [] [u1] } _N_} _F_ _IF_ARGS_ 0 1 C 4 \ (u0 :: Float) -> case u0 of { _ALG_ F# (u1 :: Float#) -> case _#_ negateFloat# [] [u1] of { _PRIM_ (u2 :: Float#) -> _!_ F# [] [u2] }; _NO_DEFLT_ } _N_,
- abs = _A_ 1 _U_ 1 _N_ _S_ "U(P)" {_A_ 1 _U_ 2 _N_ _N_ _N_ _N_} _N_ _N_,
- signum = _A_ 1 _U_ 1 _N_ _S_ "U(P)" {_A_ 1 _U_ 2 _N_ _N_ _N_ _N_} _N_ _N_,
- fromInteger = _A_ 1 _U_ 1 _N_ _S_ "U(PPP)" {_A_ 3 _U_ 222 _N_ _N_ _F_ _IF_ARGS_ 0 3 XXX 3 \ (u0 :: Int#) (u1 :: Int#) (u2 :: ByteArray#) -> case _#_ encodeFloat# [] [u0, u1, u2, 0#] of { _PRIM_ (u3 :: Float#) -> _!_ F# [] [u3] } _N_} _F_ _IF_ARGS_ 0 1 C 4 \ (u0 :: Integer) -> case u0 of { _ALG_ J# (u1 :: Int#) (u2 :: Int#) (u3 :: ByteArray#) -> case _#_ encodeFloat# [] [u1, u2, u3, 0#] of { _PRIM_ (u4 :: Float#) -> _!_ F# [] [u4] }; _NO_DEFLT_ } _N_,
- fromInt = _A_ 1 _U_ 1 _N_ _S_ "U(P)" {_A_ 1 _U_ 2 _N_ _N_ _F_ _IF_ARGS_ 0 1 X 3 \ (u0 :: Int#) -> case _#_ int2Float# [] [u0] of { _PRIM_ (u1 :: Float#) -> _!_ F# [] [u1] } _N_} _F_ _IF_ARGS_ 0 1 C 4 \ (u0 :: Int) -> case u0 of { _ALG_ I# (u1 :: Int#) -> case _#_ int2Float# [] [u1] of { _PRIM_ (u2 :: Float#) -> _!_ F# [] [u2] }; _NO_DEFLT_ } _N_ #-}
+ (+) = { _A_ 2 _U_ 11 _N_ _S_ "U(P)U(P)" {_A_ 2 _U_ 22 _N_ _N_ _F_ _IF_ARGS_ 0 2 XX 3 \ (u0 :: Float#) (u1 :: Float#) -> case _#_ plusFloat# [] [u0, u1] of { _PRIM_ (u2 :: Float#) -> _!_ F# [] [u2] } _N_} _F_ _IF_ARGS_ 0 2 CC 5 \ (u0 :: Float) (u1 :: Float) -> case u0 of { _ALG_ F# (u2 :: Float#) -> case u1 of { _ALG_ F# (u3 :: Float#) -> case _#_ plusFloat# [] [u2, u3] of { _PRIM_ (u4 :: Float#) -> _!_ F# [] [u4] }; _NO_DEFLT_ }; _NO_DEFLT_ } _N_ },
+ (-) = { _A_ 2 _U_ 11 _N_ _S_ "U(P)U(P)" {_A_ 2 _U_ 22 _N_ _N_ _F_ _IF_ARGS_ 0 2 XX 3 \ (u0 :: Float#) (u1 :: Float#) -> case _#_ minusFloat# [] [u0, u1] of { _PRIM_ (u2 :: Float#) -> _!_ F# [] [u2] } _N_} _F_ _IF_ARGS_ 0 2 CC 5 \ (u0 :: Float) (u1 :: Float) -> case u0 of { _ALG_ F# (u2 :: Float#) -> case u1 of { _ALG_ F# (u3 :: Float#) -> case _#_ minusFloat# [] [u2, u3] of { _PRIM_ (u4 :: Float#) -> _!_ F# [] [u4] }; _NO_DEFLT_ }; _NO_DEFLT_ } _N_ },
+ (*) = { _A_ 2 _U_ 11 _N_ _S_ "U(P)U(P)" {_A_ 2 _U_ 22 _N_ _N_ _F_ _IF_ARGS_ 0 2 XX 3 \ (u0 :: Float#) (u1 :: Float#) -> case _#_ timesFloat# [] [u0, u1] of { _PRIM_ (u2 :: Float#) -> _!_ F# [] [u2] } _N_} _F_ _IF_ARGS_ 0 2 CC 5 \ (u0 :: Float) (u1 :: Float) -> case u0 of { _ALG_ F# (u2 :: Float#) -> case u1 of { _ALG_ F# (u3 :: Float#) -> case _#_ timesFloat# [] [u2, u3] of { _PRIM_ (u4 :: Float#) -> _!_ F# [] [u4] }; _NO_DEFLT_ }; _NO_DEFLT_ } _N_ },
+ negate = { _A_ 1 _U_ 1 _N_ _S_ "U(P)" {_A_ 1 _U_ 2 _N_ _N_ _F_ _IF_ARGS_ 0 1 X 3 \ (u0 :: Float#) -> case _#_ negateFloat# [] [u0] of { _PRIM_ (u1 :: Float#) -> _!_ F# [] [u1] } _N_} _F_ _IF_ARGS_ 0 1 C 4 \ (u0 :: Float) -> case u0 of { _ALG_ F# (u1 :: Float#) -> case _#_ negateFloat# [] [u1] of { _PRIM_ (u2 :: Float#) -> _!_ F# [] [u2] }; _NO_DEFLT_ } _N_ },
+ abs = { _A_ 1 _U_ 1 _N_ _S_ "U(P)" {_A_ 1 _U_ 2 _N_ _N_ _N_ _N_} _N_ _N_ },
+ signum = { _A_ 1 _U_ 1 _N_ _S_ "U(P)" {_A_ 1 _U_ 2 _N_ _N_ _N_ _N_} _N_ _N_ },
+ fromInteger = { _A_ 1 _U_ 1 _N_ _S_ "U(PPP)" {_A_ 3 _U_ 222 _N_ _N_ _F_ _IF_ARGS_ 0 3 XXX 3 \ (u0 :: Int#) (u1 :: Int#) (u2 :: ByteArray#) -> case _#_ encodeFloat# [] [u0, u1, u2, 0#] of { _PRIM_ (u3 :: Float#) -> _!_ F# [] [u3] } _N_} _F_ _IF_ARGS_ 0 1 C 4 \ (u0 :: Integer) -> case u0 of { _ALG_ J# (u1 :: Int#) (u2 :: Int#) (u3 :: ByteArray#) -> case _#_ encodeFloat# [] [u1, u2, u3, 0#] of { _PRIM_ (u4 :: Float#) -> _!_ F# [] [u4] }; _NO_DEFLT_ } _N_ },
+ fromInt = { _A_ 1 _U_ 1 _N_ _S_ "U(P)" {_A_ 1 _U_ 2 _N_ _N_ _F_ _IF_ARGS_ 0 1 X 3 \ (u0 :: Int#) -> case _#_ int2Float# [] [u0] of { _PRIM_ (u1 :: Float#) -> _!_ F# [] [u1] } _N_} _F_ _IF_ARGS_ 0 1 C 4 \ (u0 :: Int) -> case u0 of { _ALG_ I# (u1 :: Int#) -> case _#_ int2Float# [] [u1] of { _PRIM_ (u2 :: Float#) -> _!_ F# [] [u2] }; _NO_DEFLT_ } _N_ } #-}
instance Num Int
{-# GHC_PRAGMA _M_ PreludeCore {-dfun-} _A_ 0 _N_ _N_ _N_ _F_ _IF_ARGS_ 0 0 X 11 _!_ _TUP_10 [{{Eq Int}}, {{Text Int}}, (Int -> Int -> Int), (Int -> Int -> Int), (Int -> Int -> Int), (Int -> Int), (Int -> Int), (Int -> Int), (Integer -> Int), (Int -> Int)] [_DFUN_ Eq (Int), _DFUN_ Text (Int), _CONSTM_ Num (+) (Int), _CONSTM_ Num (-) (Int), _CONSTM_ Num (*) (Int), _CONSTM_ Num negate (Int), _CONSTM_ Num abs (Int), _CONSTM_ Num signum (Int), _CONSTM_ Num fromInteger (Int), _CONSTM_ Num fromInt (Int)] _N_
- (+) = _A_ 2 _U_ 11 _N_ _S_ "U(P)U(P)" {_A_ 2 _U_ 22 _N_ _N_ _F_ _IF_ARGS_ 0 2 XX 3 \ (u0 :: Int#) (u1 :: Int#) -> case _#_ plusInt# [] [u0, u1] of { _PRIM_ (u2 :: Int#) -> _!_ I# [] [u2] } _N_} _F_ _IF_ARGS_ 0 2 CC 5 \ (u0 :: Int) (u1 :: Int) -> case u0 of { _ALG_ I# (u2 :: Int#) -> case u1 of { _ALG_ I# (u3 :: Int#) -> case _#_ plusInt# [] [u2, u3] of { _PRIM_ (u4 :: Int#) -> _!_ I# [] [u4] }; _NO_DEFLT_ }; _NO_DEFLT_ } _N_,
- (-) = _A_ 2 _U_ 11 _N_ _S_ "U(P)U(P)" {_A_ 2 _U_ 22 _N_ _N_ _F_ _IF_ARGS_ 0 2 XX 3 \ (u0 :: Int#) (u1 :: Int#) -> case _#_ minusInt# [] [u0, u1] of { _PRIM_ (u2 :: Int#) -> _!_ I# [] [u2] } _N_} _F_ _IF_ARGS_ 0 2 CC 5 \ (u0 :: Int) (u1 :: Int) -> case u0 of { _ALG_ I# (u2 :: Int#) -> case u1 of { _ALG_ I# (u3 :: Int#) -> case _#_ minusInt# [] [u2, u3] of { _PRIM_ (u4 :: Int#) -> _!_ I# [] [u4] }; _NO_DEFLT_ }; _NO_DEFLT_ } _N_,
- (*) = _A_ 2 _U_ 11 _N_ _S_ "U(P)U(P)" {_A_ 2 _U_ 22 _N_ _N_ _F_ _IF_ARGS_ 0 2 XX 3 \ (u0 :: Int#) (u1 :: Int#) -> case _#_ timesInt# [] [u0, u1] of { _PRIM_ (u2 :: Int#) -> _!_ I# [] [u2] } _N_} _F_ _IF_ARGS_ 0 2 CC 5 \ (u0 :: Int) (u1 :: Int) -> case u0 of { _ALG_ I# (u2 :: Int#) -> case u1 of { _ALG_ I# (u3 :: Int#) -> case _#_ timesInt# [] [u2, u3] of { _PRIM_ (u4 :: Int#) -> _!_ I# [] [u4] }; _NO_DEFLT_ }; _NO_DEFLT_ } _N_,
- negate = _A_ 1 _U_ 1 _N_ _S_ "U(P)" {_A_ 1 _U_ 2 _N_ _N_ _F_ _IF_ARGS_ 0 1 X 3 \ (u0 :: Int#) -> case _#_ negateInt# [] [u0] of { _PRIM_ (u1 :: Int#) -> _!_ I# [] [u1] } _N_} _F_ _IF_ARGS_ 0 1 C 4 \ (u0 :: Int) -> case u0 of { _ALG_ I# (u1 :: Int#) -> case _#_ negateInt# [] [u1] of { _PRIM_ (u2 :: Int#) -> _!_ I# [] [u2] }; _NO_DEFLT_ } _N_,
- abs = _A_ 1 _U_ 1 _N_ _S_ "U(P)" {_A_ 1 _U_ 2 _N_ _N_ _N_ _N_} _N_ _N_,
- signum = _A_ 1 _U_ 1 _N_ _S_ "U(P)" {_A_ 1 _U_ 2 _N_ _N_ _N_ _N_} _N_ _N_,
- fromInteger = _A_ 1 _U_ 1 _N_ _S_ "U(PPP)" {_A_ 3 _U_ 222 _N_ _N_ _F_ _IF_ARGS_ 0 3 XXX 3 \ (u0 :: Int#) (u1 :: Int#) (u2 :: ByteArray#) -> case _#_ integer2Int# [] [u0, u1, u2] of { _PRIM_ (u3 :: Int#) -> _!_ I# [] [u3] } _N_} _F_ _IF_ARGS_ 0 1 C 4 \ (u0 :: Integer) -> case u0 of { _ALG_ J# (u1 :: Int#) (u2 :: Int#) (u3 :: ByteArray#) -> case _#_ integer2Int# [] [u1, u2, u3] of { _PRIM_ (u4 :: Int#) -> _!_ I# [] [u4] }; _NO_DEFLT_ } _N_,
- fromInt = _A_ 1 _U_ 1 _N_ _S_ "U(P)" {_A_ 1 _U_ 2 _N_ _N_ _F_ _IF_ARGS_ 0 1 X 2 \ (u0 :: Int#) -> _!_ I# [] [u0] _N_} _F_ _IF_ARGS_ 0 1 X 1 \ (u0 :: Int) -> u0 _N_ #-}
+ (+) = { _A_ 2 _U_ 11 _N_ _S_ "U(P)U(P)" {_A_ 2 _U_ 22 _N_ _N_ _F_ _IF_ARGS_ 0 2 XX 3 \ (u0 :: Int#) (u1 :: Int#) -> case _#_ plusInt# [] [u0, u1] of { _PRIM_ (u2 :: Int#) -> _!_ I# [] [u2] } _N_} _F_ _IF_ARGS_ 0 2 CC 5 \ (u0 :: Int) (u1 :: Int) -> case u0 of { _ALG_ I# (u2 :: Int#) -> case u1 of { _ALG_ I# (u3 :: Int#) -> case _#_ plusInt# [] [u2, u3] of { _PRIM_ (u4 :: Int#) -> _!_ I# [] [u4] }; _NO_DEFLT_ }; _NO_DEFLT_ } _N_ },
+ (-) = { _A_ 2 _U_ 11 _N_ _S_ "U(P)U(P)" {_A_ 2 _U_ 22 _N_ _N_ _F_ _IF_ARGS_ 0 2 XX 3 \ (u0 :: Int#) (u1 :: Int#) -> case _#_ minusInt# [] [u0, u1] of { _PRIM_ (u2 :: Int#) -> _!_ I# [] [u2] } _N_} _F_ _IF_ARGS_ 0 2 CC 5 \ (u0 :: Int) (u1 :: Int) -> case u0 of { _ALG_ I# (u2 :: Int#) -> case u1 of { _ALG_ I# (u3 :: Int#) -> case _#_ minusInt# [] [u2, u3] of { _PRIM_ (u4 :: Int#) -> _!_ I# [] [u4] }; _NO_DEFLT_ }; _NO_DEFLT_ } _N_ },
+ (*) = { _A_ 2 _U_ 11 _N_ _S_ "U(P)U(P)" {_A_ 2 _U_ 22 _N_ _N_ _F_ _IF_ARGS_ 0 2 XX 3 \ (u0 :: Int#) (u1 :: Int#) -> case _#_ timesInt# [] [u0, u1] of { _PRIM_ (u2 :: Int#) -> _!_ I# [] [u2] } _N_} _F_ _IF_ARGS_ 0 2 CC 5 \ (u0 :: Int) (u1 :: Int) -> case u0 of { _ALG_ I# (u2 :: Int#) -> case u1 of { _ALG_ I# (u3 :: Int#) -> case _#_ timesInt# [] [u2, u3] of { _PRIM_ (u4 :: Int#) -> _!_ I# [] [u4] }; _NO_DEFLT_ }; _NO_DEFLT_ } _N_ },
+ negate = { _A_ 1 _U_ 1 _N_ _S_ "U(P)" {_A_ 1 _U_ 2 _N_ _N_ _F_ _IF_ARGS_ 0 1 X 3 \ (u0 :: Int#) -> case _#_ negateInt# [] [u0] of { _PRIM_ (u1 :: Int#) -> _!_ I# [] [u1] } _N_} _F_ _IF_ARGS_ 0 1 C 4 \ (u0 :: Int) -> case u0 of { _ALG_ I# (u1 :: Int#) -> case _#_ negateInt# [] [u1] of { _PRIM_ (u2 :: Int#) -> _!_ I# [] [u2] }; _NO_DEFLT_ } _N_ },
+ abs = { _A_ 1 _U_ 1 _N_ _S_ "U(P)" {_A_ 1 _U_ 2 _N_ _N_ _N_ _N_} _N_ _N_ },
+ signum = { _A_ 1 _U_ 1 _N_ _S_ "U(P)" {_A_ 1 _U_ 2 _N_ _N_ _N_ _N_} _N_ _N_ },
+ fromInteger = { _A_ 1 _U_ 1 _N_ _S_ "U(PPP)" {_A_ 3 _U_ 222 _N_ _N_ _F_ _IF_ARGS_ 0 3 XXX 3 \ (u0 :: Int#) (u1 :: Int#) (u2 :: ByteArray#) -> case _#_ integer2Int# [] [u0, u1, u2] of { _PRIM_ (u3 :: Int#) -> _!_ I# [] [u3] } _N_} _F_ _IF_ARGS_ 0 1 C 4 \ (u0 :: Integer) -> case u0 of { _ALG_ J# (u1 :: Int#) (u2 :: Int#) (u3 :: ByteArray#) -> case _#_ integer2Int# [] [u1, u2, u3] of { _PRIM_ (u4 :: Int#) -> _!_ I# [] [u4] }; _NO_DEFLT_ } _N_ },
+ fromInt = { _A_ 1 _U_ 1 _N_ _S_ "U(P)" {_A_ 1 _U_ 2 _N_ _N_ _F_ _IF_ARGS_ 0 1 X 2 \ (u0 :: Int#) -> _!_ I# [] [u0] _N_} _F_ _IF_ARGS_ 0 1 X 1 \ (u0 :: Int) -> u0 _N_ } #-}
instance Num Integer
{-# GHC_PRAGMA _M_ PreludeCore {-dfun-} _A_ 0 _N_ _N_ _N_ _F_ _IF_ARGS_ 0 0 X 11 _!_ _TUP_10 [{{Eq Integer}}, {{Text Integer}}, (Integer -> Integer -> Integer), (Integer -> Integer -> Integer), (Integer -> Integer -> Integer), (Integer -> Integer), (Integer -> Integer), (Integer -> Integer), (Integer -> Integer), (Int -> Integer)] [_DFUN_ Eq (Integer), _DFUN_ Text (Integer), _CONSTM_ Num (+) (Integer), _CONSTM_ Num (-) (Integer), _CONSTM_ Num (*) (Integer), _CONSTM_ Num negate (Integer), _CONSTM_ Num abs (Integer), _CONSTM_ Num signum (Integer), _CONSTM_ Num fromInteger (Integer), _CONSTM_ Num fromInt (Integer)] _N_
- (+) = _A_ 2 _U_ 11 _N_ _S_ "U(PPP)U(PPP)" {_A_ 4 _U_ 2221 _N_ _N_ _F_ _IF_ARGS_ 0 4 XXXC 5 \ (u0 :: Int#) (u1 :: Int#) (u2 :: ByteArray#) (u3 :: Integer) -> case u3 of { _ALG_ J# (u4 :: Int#) (u5 :: Int#) (u6 :: ByteArray#) -> _#_ plusInteger# [] [u0, u1, u2, u4, u5, u6]; _NO_DEFLT_ } _N_} _F_ _IF_ARGS_ 0 2 CC 6 \ (u0 :: Integer) (u1 :: Integer) -> case u0 of { _ALG_ J# (u2 :: Int#) (u3 :: Int#) (u4 :: ByteArray#) -> case u1 of { _ALG_ J# (u5 :: Int#) (u6 :: Int#) (u7 :: ByteArray#) -> _#_ plusInteger# [] [u2, u3, u4, u5, u6, u7]; _NO_DEFLT_ }; _NO_DEFLT_ } _N_,
- (-) = _A_ 2 _U_ 11 _N_ _S_ "U(PPP)U(PPP)" {_A_ 4 _U_ 2221 _N_ _N_ _F_ _IF_ARGS_ 0 4 XXXC 5 \ (u0 :: Int#) (u1 :: Int#) (u2 :: ByteArray#) (u3 :: Integer) -> case u3 of { _ALG_ J# (u4 :: Int#) (u5 :: Int#) (u6 :: ByteArray#) -> _#_ minusInteger# [] [u0, u1, u2, u4, u5, u6]; _NO_DEFLT_ } _N_} _F_ _IF_ARGS_ 0 2 CC 6 \ (u0 :: Integer) (u1 :: Integer) -> case u0 of { _ALG_ J# (u2 :: Int#) (u3 :: Int#) (u4 :: ByteArray#) -> case u1 of { _ALG_ J# (u5 :: Int#) (u6 :: Int#) (u7 :: ByteArray#) -> _#_ minusInteger# [] [u2, u3, u4, u5, u6, u7]; _NO_DEFLT_ }; _NO_DEFLT_ } _N_,
- (*) = _A_ 2 _U_ 11 _N_ _S_ "U(PPP)U(PPP)" {_A_ 4 _U_ 2221 _N_ _N_ _F_ _IF_ARGS_ 0 4 XXXC 5 \ (u0 :: Int#) (u1 :: Int#) (u2 :: ByteArray#) (u3 :: Integer) -> case u3 of { _ALG_ J# (u4 :: Int#) (u5 :: Int#) (u6 :: ByteArray#) -> _#_ timesInteger# [] [u0, u1, u2, u4, u5, u6]; _NO_DEFLT_ } _N_} _F_ _IF_ARGS_ 0 2 CC 6 \ (u0 :: Integer) (u1 :: Integer) -> case u0 of { _ALG_ J# (u2 :: Int#) (u3 :: Int#) (u4 :: ByteArray#) -> case u1 of { _ALG_ J# (u5 :: Int#) (u6 :: Int#) (u7 :: ByteArray#) -> _#_ timesInteger# [] [u2, u3, u4, u5, u6, u7]; _NO_DEFLT_ }; _NO_DEFLT_ } _N_,
- negate = _A_ 1 _U_ 1 _N_ _S_ "U(PPP)" {_A_ 3 _U_ 222 _N_ _N_ _F_ _IF_ARGS_ 0 3 XXX 4 \ (u0 :: Int#) (u1 :: Int#) (u2 :: ByteArray#) -> _#_ negateInteger# [] [u0, u1, u2] _N_} _F_ _IF_ARGS_ 0 1 C 5 \ (u0 :: Integer) -> case u0 of { _ALG_ J# (u1 :: Int#) (u2 :: Int#) (u3 :: ByteArray#) -> _#_ negateInteger# [] [u1, u2, u3]; _NO_DEFLT_ } _N_,
- abs = _A_ 1 _U_ 1 _N_ _S_ "U(PPP)" {_A_ 3 _U_ 222 _N_ _N_ _N_ _N_} _N_ _N_,
- signum = _A_ 1 _U_ 1 _N_ _S_ "U(PPP)" {_A_ 3 _U_ 222 _N_ _N_ _N_ _N_} _N_ _N_,
- fromInteger = _A_ 1 _U_ 1 _N_ _S_ "U(PPP)" {_A_ 3 _U_ 222 _N_ _N_ _F_ _IF_ARGS_ 0 3 XXX 4 \ (u0 :: Int#) (u1 :: Int#) (u2 :: ByteArray#) -> _!_ J# [] [u0, u1, u2] _N_} _F_ _IF_ARGS_ 0 1 X 1 \ (u0 :: Integer) -> u0 _N_,
- fromInt = _A_ 1 _U_ 1 _N_ _S_ "U(P)" {_A_ 1 _U_ 2 _N_ _N_ _F_ _IF_ARGS_ 0 1 X 1 \ (u0 :: Int#) -> _#_ int2Integer# [] [u0] _N_} _F_ _IF_ARGS_ 0 1 C 2 \ (u0 :: Int) -> case u0 of { _ALG_ I# (u1 :: Int#) -> _#_ int2Integer# [] [u1]; _NO_DEFLT_ } _N_ #-}
+ (+) = { _A_ 2 _U_ 11 _N_ _S_ "U(PPP)U(PPP)" {_A_ 4 _U_ 2221 _N_ _N_ _F_ _IF_ARGS_ 0 4 XXXC 5 \ (u0 :: Int#) (u1 :: Int#) (u2 :: ByteArray#) (u3 :: Integer) -> case u3 of { _ALG_ J# (u4 :: Int#) (u5 :: Int#) (u6 :: ByteArray#) -> _#_ plusInteger# [] [u0, u1, u2, u4, u5, u6]; _NO_DEFLT_ } _N_} _F_ _IF_ARGS_ 0 2 CC 6 \ (u0 :: Integer) (u1 :: Integer) -> case u0 of { _ALG_ J# (u2 :: Int#) (u3 :: Int#) (u4 :: ByteArray#) -> case u1 of { _ALG_ J# (u5 :: Int#) (u6 :: Int#) (u7 :: ByteArray#) -> _#_ plusInteger# [] [u2, u3, u4, u5, u6, u7]; _NO_DEFLT_ }; _NO_DEFLT_ } _N_ },
+ (-) = { _A_ 2 _U_ 11 _N_ _S_ "U(PPP)U(PPP)" {_A_ 4 _U_ 2221 _N_ _N_ _F_ _IF_ARGS_ 0 4 XXXC 5 \ (u0 :: Int#) (u1 :: Int#) (u2 :: ByteArray#) (u3 :: Integer) -> case u3 of { _ALG_ J# (u4 :: Int#) (u5 :: Int#) (u6 :: ByteArray#) -> _#_ minusInteger# [] [u0, u1, u2, u4, u5, u6]; _NO_DEFLT_ } _N_} _F_ _IF_ARGS_ 0 2 CC 6 \ (u0 :: Integer) (u1 :: Integer) -> case u0 of { _ALG_ J# (u2 :: Int#) (u3 :: Int#) (u4 :: ByteArray#) -> case u1 of { _ALG_ J# (u5 :: Int#) (u6 :: Int#) (u7 :: ByteArray#) -> _#_ minusInteger# [] [u2, u3, u4, u5, u6, u7]; _NO_DEFLT_ }; _NO_DEFLT_ } _N_ },
+ (*) = { _A_ 2 _U_ 11 _N_ _S_ "U(PPP)U(PPP)" {_A_ 4 _U_ 2221 _N_ _N_ _F_ _IF_ARGS_ 0 4 XXXC 5 \ (u0 :: Int#) (u1 :: Int#) (u2 :: ByteArray#) (u3 :: Integer) -> case u3 of { _ALG_ J# (u4 :: Int#) (u5 :: Int#) (u6 :: ByteArray#) -> _#_ timesInteger# [] [u0, u1, u2, u4, u5, u6]; _NO_DEFLT_ } _N_} _F_ _IF_ARGS_ 0 2 CC 6 \ (u0 :: Integer) (u1 :: Integer) -> case u0 of { _ALG_ J# (u2 :: Int#) (u3 :: Int#) (u4 :: ByteArray#) -> case u1 of { _ALG_ J# (u5 :: Int#) (u6 :: Int#) (u7 :: ByteArray#) -> _#_ timesInteger# [] [u2, u3, u4, u5, u6, u7]; _NO_DEFLT_ }; _NO_DEFLT_ } _N_ },
+ negate = { _A_ 1 _U_ 1 _N_ _S_ "U(PPP)" {_A_ 3 _U_ 222 _N_ _N_ _F_ _IF_ARGS_ 0 3 XXX 4 \ (u0 :: Int#) (u1 :: Int#) (u2 :: ByteArray#) -> _#_ negateInteger# [] [u0, u1, u2] _N_} _F_ _IF_ARGS_ 0 1 C 5 \ (u0 :: Integer) -> case u0 of { _ALG_ J# (u1 :: Int#) (u2 :: Int#) (u3 :: ByteArray#) -> _#_ negateInteger# [] [u1, u2, u3]; _NO_DEFLT_ } _N_ },
+ abs = { _A_ 1 _U_ 1 _N_ _S_ "U(PPP)" {_A_ 3 _U_ 222 _N_ _N_ _N_ _N_} _N_ _N_ },
+ signum = { _A_ 1 _U_ 1 _N_ _S_ "U(PPP)" {_A_ 3 _U_ 222 _N_ _N_ _N_ _N_} _N_ _N_ },
+ fromInteger = { _A_ 1 _U_ 1 _N_ _S_ "U(PPP)" {_A_ 3 _U_ 222 _N_ _N_ _F_ _IF_ARGS_ 0 3 XXX 4 \ (u0 :: Int#) (u1 :: Int#) (u2 :: ByteArray#) -> _!_ J# [] [u0, u1, u2] _N_} _F_ _IF_ARGS_ 0 1 X 1 \ (u0 :: Integer) -> u0 _N_ },
+ fromInt = { _A_ 1 _U_ 1 _N_ _S_ "U(P)" {_A_ 1 _U_ 2 _N_ _N_ _F_ _IF_ARGS_ 0 1 X 1 \ (u0 :: Int#) -> _#_ int2Integer# [] [u0] _N_} _F_ _IF_ARGS_ 0 1 C 2 \ (u0 :: Int) -> case u0 of { _ALG_ I# (u1 :: Int#) -> _#_ int2Integer# [] [u1]; _NO_DEFLT_ } _N_ } #-}
instance Integral a => Num (Ratio a)
{-# GHC_PRAGMA _M_ PreludeRatio {-dfun-} _A_ 3 _U_ 222 _N_ _N_ _N_ _N_ #-}
instance Num (Ratio Integer)
{-# GHC_PRAGMA _M_ PreludeRatio {-dfun-} _A_ 0 _N_ _N_ _N_ _F_ _IF_ARGS_ 0 0 X 11 _!_ _TUP_10 [{{Eq (Ratio Integer)}}, {{Text (Ratio Integer)}}, (Ratio Integer -> Ratio Integer -> Ratio Integer), (Ratio Integer -> Ratio Integer -> Ratio Integer), (Ratio Integer -> Ratio Integer -> Ratio Integer), (Ratio Integer -> Ratio Integer), (Ratio Integer -> Ratio Integer), (Ratio Integer -> Ratio Integer), (Integer -> Ratio Integer), (Int -> Ratio Integer)] [_DFUN_ Eq (Ratio Integer), _DFUN_ Text (Ratio Integer), _CONSTM_ Num (+) (Ratio Integer), _CONSTM_ Num (-) (Ratio Integer), _CONSTM_ Num (*) (Ratio Integer), _CONSTM_ Num negate (Ratio Integer), _CONSTM_ Num abs (Ratio Integer), _CONSTM_ Num signum (Ratio Integer), _CONSTM_ Num fromInteger (Ratio Integer), _CONSTM_ Num fromInt (Ratio Integer)] _N_
- (+) = _A_ 2 _U_ 11 _N_ _S_ "U(LU(PPP))U(LU(PPP))" {_A_ 5 _U_ 12221 _N_ _N_ _N_ _N_} _N_ _N_,
- (-) = _A_ 2 _U_ 11 _N_ _S_ "U(LU(PPP))U(LU(PPP))" {_A_ 5 _U_ 12221 _N_ _N_ _N_ _N_} _N_ _N_,
- (*) = _A_ 2 _U_ 11 _N_ _S_ "U(LU(PPP))U(LU(PPP))" {_A_ 5 _U_ 22221 _N_ _N_ _N_ _N_} _N_ _N_,
- negate = _A_ 1 _U_ 1 _N_ _S_ "U(LL)" {_A_ 2 _U_ 22 _N_ _N_ _N_ _N_} _N_ _N_,
- abs = _A_ 1 _U_ 1 _N_ _S_ "U(LL)" {_A_ 2 _U_ 12 _N_ _N_ _N_ _N_} _N_ _N_,
- signum = _A_ 1 _U_ 1 _N_ _S_ "U(LA)" {_A_ 1 _U_ 1 _N_ _N_ _N_ _N_} _N_ _N_,
- fromInteger = _A_ 1 _U_ 2 _N_ _N_ _N_ _N_,
- fromInt = _A_ 1 _U_ 1 _N_ _N_ _N_ _N_ #-}
+ (+) = { _A_ 2 _U_ 11 _N_ _S_ "U(LU(PPP))U(LU(PPP))" {_A_ 5 _U_ 12221 _N_ _N_ _N_ _N_} _N_ _N_ },
+ (-) = { _A_ 2 _U_ 11 _N_ _S_ "U(LU(PPP))U(LU(PPP))" {_A_ 5 _U_ 12221 _N_ _N_ _N_ _N_} _N_ _N_ },
+ (*) = { _A_ 2 _U_ 11 _N_ _S_ "U(LU(PPP))U(LU(PPP))" {_A_ 5 _U_ 22221 _N_ _N_ _N_ _N_} _N_ _N_ },
+ negate = { _A_ 1 _U_ 1 _N_ _S_ "U(LL)" {_A_ 2 _U_ 22 _N_ _N_ _N_ _N_} _N_ _N_ },
+ abs = { _A_ 1 _U_ 1 _N_ _S_ "U(LL)" {_A_ 2 _U_ 12 _N_ _N_ _N_ _N_} _N_ _N_ },
+ signum = { _A_ 1 _U_ 1 _N_ _S_ "U(LA)" {_A_ 1 _U_ 1 _N_ _N_ _N_ _N_} _N_ _N_ },
+ fromInteger = { _A_ 1 _U_ 2 _N_ _N_ _F_ _IF_ARGS_ 0 1 X 3 \ (u0 :: Integer) -> _!_ (:%) [Integer] [u0, _SPEC_ _ORIG_ PreludeCore __i1 [ (Integer) ]] _N_ },
+ fromInt = { _A_ 1 _U_ 1 _N_ _N_ _N_ _N_ } #-}
instance Ord ()
{-# GHC_PRAGMA _M_ PreludeBuiltin {-dfun-} _A_ 0 _N_ _N_ _N_ _F_ _IF_ARGS_ 0 0 X 9 _!_ _TUP_8 [{{Eq ()}}, (() -> () -> Bool), (() -> () -> Bool), (() -> () -> Bool), (() -> () -> Bool), (() -> () -> ()), (() -> () -> ()), (() -> () -> _CMP_TAG)] [_DFUN_ Eq (()), _CONSTM_ Ord (<) (()), _CONSTM_ Ord (<=) (()), _CONSTM_ Ord (>=) (()), _CONSTM_ Ord (>) (()), _CONSTM_ Ord max (()), _CONSTM_ Ord min (()), _CONSTM_ Ord _tagCmp (())] _N_
- (<) = _A_ 2 _U_ 11 _N_ _S_ "EE" _F_ _IF_ARGS_ 0 2 CC 3 \ (u0 :: ()) (u1 :: ()) -> case u0 of { _ALG_ _TUP_0 -> case u1 of { _ALG_ _TUP_0 -> _!_ False [] []; _NO_DEFLT_ }; _NO_DEFLT_ } _N_,
- (<=) = _A_ 2 _U_ 11 _N_ _S_ "EE" _F_ _IF_ARGS_ 0 2 CC 3 \ (u0 :: ()) (u1 :: ()) -> case u0 of { _ALG_ _TUP_0 -> case u1 of { _ALG_ _TUP_0 -> _!_ True [] []; _NO_DEFLT_ }; _NO_DEFLT_ } _N_,
- (>=) = _A_ 2 _U_ 11 _N_ _S_ "EE" _F_ _IF_ARGS_ 0 2 CC 3 \ (u0 :: ()) (u1 :: ()) -> case u0 of { _ALG_ _TUP_0 -> case u1 of { _ALG_ _TUP_0 -> _!_ True [] []; _NO_DEFLT_ }; _NO_DEFLT_ } _N_,
- (>) = _A_ 2 _U_ 11 _N_ _S_ "EE" _F_ _IF_ARGS_ 0 2 CC 3 \ (u0 :: ()) (u1 :: ()) -> case u0 of { _ALG_ _TUP_0 -> case u1 of { _ALG_ _TUP_0 -> _!_ False [] []; _NO_DEFLT_ }; _NO_DEFLT_ } _N_,
- max = _A_ 2 _U_ 11 _N_ _S_ "EE" _F_ _IF_ARGS_ 0 2 CX 2 \ (u0 :: ()) (u1 :: ()) -> case u0 of { _ALG_ _TUP_0 -> u1; _NO_DEFLT_ } _N_,
- min = _A_ 2 _U_ 11 _N_ _S_ "EE" _F_ _IF_ARGS_ 0 2 CX 2 \ (u0 :: ()) (u1 :: ()) -> case u0 of { _ALG_ _TUP_0 -> u1; _NO_DEFLT_ } _N_,
- _tagCmp = _A_ 2 _U_ 11 _N_ _S_ "EE" _F_ _IF_ARGS_ 0 2 CC 3 \ (u0 :: ()) (u1 :: ()) -> case u0 of { _ALG_ _TUP_0 -> case u1 of { _ALG_ _TUP_0 -> _!_ _EQ [] []; _NO_DEFLT_ }; _NO_DEFLT_ } _N_ #-}
+ (<) = { _A_ 2 _U_ 11 _N_ _S_ "EE" _F_ _IF_ARGS_ 0 2 CC 3 \ (u0 :: ()) (u1 :: ()) -> case u0 of { _ALG_ _TUP_0 -> case u1 of { _ALG_ _TUP_0 -> _!_ False [] []; _NO_DEFLT_ }; _NO_DEFLT_ } _N_ },
+ (<=) = { _A_ 2 _U_ 11 _N_ _S_ "EE" _F_ _IF_ARGS_ 0 2 CC 3 \ (u0 :: ()) (u1 :: ()) -> case u0 of { _ALG_ _TUP_0 -> case u1 of { _ALG_ _TUP_0 -> _!_ True [] []; _NO_DEFLT_ }; _NO_DEFLT_ } _N_ },
+ (>=) = { _A_ 2 _U_ 11 _N_ _S_ "EE" _F_ _IF_ARGS_ 0 2 CC 3 \ (u0 :: ()) (u1 :: ()) -> case u0 of { _ALG_ _TUP_0 -> case u1 of { _ALG_ _TUP_0 -> _!_ True [] []; _NO_DEFLT_ }; _NO_DEFLT_ } _N_ },
+ (>) = { _A_ 2 _U_ 11 _N_ _S_ "EE" _F_ _IF_ARGS_ 0 2 CC 3 \ (u0 :: ()) (u1 :: ()) -> case u0 of { _ALG_ _TUP_0 -> case u1 of { _ALG_ _TUP_0 -> _!_ False [] []; _NO_DEFLT_ }; _NO_DEFLT_ } _N_ },
+ max = { _A_ 2 _U_ 11 _N_ _S_ "EE" _F_ _IF_ARGS_ 0 2 CX 2 \ (u0 :: ()) (u1 :: ()) -> case u0 of { _ALG_ _TUP_0 -> u1; _NO_DEFLT_ } _N_ },
+ min = { _A_ 2 _U_ 11 _N_ _S_ "EE" _F_ _IF_ARGS_ 0 2 CX 2 \ (u0 :: ()) (u1 :: ()) -> case u0 of { _ALG_ _TUP_0 -> u1; _NO_DEFLT_ } _N_ },
+ _tagCmp = { _A_ 2 _U_ 11 _N_ _S_ "EE" _F_ _IF_ARGS_ 0 2 CC 3 \ (u0 :: ()) (u1 :: ()) -> case u0 of { _ALG_ _TUP_0 -> case u1 of { _ALG_ _TUP_0 -> _!_ _EQ [] []; _NO_DEFLT_ }; _NO_DEFLT_ } _N_ } #-}
instance (Ord a, Ord b) => Ord (a, b)
{-# GHC_PRAGMA _M_ PreludeBuiltin {-dfun-} _A_ 3 _U_ 112 _N_ _N_ _N_ _N_ #-}
instance (Ord a, Ord b, Ord c) => Ord (a, b, c)
{-# GHC_PRAGMA _M_ PreludeBuiltin {-dfun-} _A_ 6 _U_ 111112 _N_ _N_ _N_ _N_ #-}
instance Ord (Int, Int)
{-# GHC_PRAGMA _M_ PreludeBuiltin {-dfun-} _A_ 0 _N_ _N_ _N_ _F_ _IF_ARGS_ 0 0 X 9 _!_ _TUP_8 [{{Eq (Int, Int)}}, ((Int, Int) -> (Int, Int) -> Bool), ((Int, Int) -> (Int, Int) -> Bool), ((Int, Int) -> (Int, Int) -> Bool), ((Int, Int) -> (Int, Int) -> Bool), ((Int, Int) -> (Int, Int) -> (Int, Int)), ((Int, Int) -> (Int, Int) -> (Int, Int)), ((Int, Int) -> (Int, Int) -> _CMP_TAG)] [_DFUN_ Eq ((Int, Int)), _CONSTM_ Ord (<) ((Int, Int)), _CONSTM_ Ord (<=) ((Int, Int)), _CONSTM_ Ord (>=) ((Int, Int)), _CONSTM_ Ord (>) ((Int, Int)), _CONSTM_ Ord max ((Int, Int)), _CONSTM_ Ord min ((Int, Int)), _CONSTM_ Ord _tagCmp ((Int, Int))] _N_
- (<) = _A_ 2 _U_ 11 _N_ _S_ "U(U(P)L)U(U(P)L)" {_A_ 4 _U_ 2121 _N_ _N_ _N_ _N_} _N_ _N_,
- (<=) = _A_ 2 _U_ 11 _N_ _S_ "U(U(P)L)U(U(P)L)" {_A_ 4 _U_ 2121 _N_ _N_ _N_ _N_} _N_ _N_,
- (>=) = _A_ 2 _U_ 11 _N_ _S_ "U(U(P)L)U(U(P)L)" {_A_ 4 _U_ 2121 _N_ _N_ _N_ _N_} _N_ _N_,
- (>) = _A_ 2 _U_ 11 _N_ _S_ "U(U(P)L)U(U(P)L)" {_A_ 4 _U_ 2121 _N_ _N_ _N_ _N_} _N_ _N_,
- max = _A_ 2 _U_ 11 _N_ _S_ "U(U(P)L)U(U(P)L)" {_A_ 4 _U_ 2222 _N_ _N_ _N_ _N_} _N_ _N_,
- min = _A_ 2 _U_ 11 _N_ _S_ "U(U(P)L)U(U(P)L)" {_A_ 4 _U_ 2222 _N_ _N_ _N_ _N_} _N_ _N_,
- _tagCmp = _A_ 2 _U_ 11 _N_ _S_ "U(U(P)L)U(U(P)L)" {_A_ 4 _U_ 2121 _N_ _N_ _N_ _N_} _N_ _N_ #-}
+ (<) = { _A_ 2 _U_ 11 _N_ _S_ "U(U(P)L)U(U(P)L)" {_A_ 4 _U_ 2121 _N_ _N_ _N_ _N_} _N_ _N_ },
+ (<=) = { _A_ 2 _U_ 11 _N_ _S_ "U(U(P)L)U(U(P)L)" {_A_ 4 _U_ 2121 _N_ _N_ _N_ _N_} _N_ _N_ },
+ (>=) = { _A_ 2 _U_ 11 _N_ _S_ "U(U(P)L)U(U(P)L)" {_A_ 4 _U_ 2121 _N_ _N_ _N_ _N_} _N_ _N_ },
+ (>) = { _A_ 2 _U_ 11 _N_ _S_ "U(U(P)L)U(U(P)L)" {_A_ 4 _U_ 2121 _N_ _N_ _N_ _N_} _N_ _N_ },
+ max = { _A_ 2 _U_ 11 _N_ _S_ "U(U(P)L)U(U(P)L)" {_A_ 4 _U_ 2222 _N_ _N_ _N_ _N_} _N_ _N_ },
+ min = { _A_ 2 _U_ 11 _N_ _S_ "U(U(P)L)U(U(P)L)" {_A_ 4 _U_ 2222 _N_ _N_ _N_ _N_} _N_ _N_ },
+ _tagCmp = { _A_ 2 _U_ 11 _N_ _S_ "U(U(P)L)U(U(P)L)" {_A_ 4 _U_ 2121 _N_ _N_ _N_ _N_} _N_ _N_ } #-}
+instance Ord (Int, Int, Int)
+ {-# GHC_PRAGMA _M_ PreludeBuiltin {-dfun-} _A_ 0 _N_ _N_ _N_ _F_ _IF_ARGS_ 0 0 X 9 _!_ _TUP_8 [{{Eq (Int, Int, Int)}}, ((Int, Int, Int) -> (Int, Int, Int) -> Bool), ((Int, Int, Int) -> (Int, Int, Int) -> Bool), ((Int, Int, Int) -> (Int, Int, Int) -> Bool), ((Int, Int, Int) -> (Int, Int, Int) -> Bool), ((Int, Int, Int) -> (Int, Int, Int) -> (Int, Int, Int)), ((Int, Int, Int) -> (Int, Int, Int) -> (Int, Int, Int)), ((Int, Int, Int) -> (Int, Int, Int) -> _CMP_TAG)] [_DFUN_ Eq ((Int, Int, Int)), _CONSTM_ Ord (<) ((Int, Int, Int)), _CONSTM_ Ord (<=) ((Int, Int, Int)), _CONSTM_ Ord (>=) ((Int, Int, Int)), _CONSTM_ Ord (>) ((Int, Int, Int)), _CONSTM_ Ord max ((Int, Int, Int)), _CONSTM_ Ord min ((Int, Int, Int)), _CONSTM_ Ord _tagCmp ((Int, Int, Int))] _N_
+ (<) = { _A_ 2 _U_ 11 _N_ _S_ "U(U(P)LL)U(U(P)LL)" {_A_ 4 _U_ 2111 _N_ _N_ _N_ _N_} _N_ _N_ },
+ (<=) = { _A_ 2 _U_ 11 _N_ _S_ "U(U(P)LL)U(U(P)LL)" {_A_ 4 _U_ 2111 _N_ _N_ _N_ _N_} _N_ _N_ },
+ (>=) = { _A_ 2 _U_ 11 _N_ _S_ "U(U(P)LL)U(U(P)LL)" {_A_ 4 _U_ 2111 _N_ _N_ _N_ _N_} _N_ _N_ },
+ (>) = { _A_ 2 _U_ 11 _N_ _S_ "U(U(P)LL)U(U(P)LL)" {_A_ 4 _U_ 2111 _N_ _N_ _N_ _N_} _N_ _N_ },
+ max = { _A_ 2 _U_ 12 _N_ _S_ "U(U(P)LL)U(U(P)LL)" {_A_ 4 _U_ 2222 _N_ _N_ _N_ _N_} _N_ _N_ },
+ min = { _A_ 2 _U_ 12 _N_ _S_ "U(U(P)LL)U(U(P)LL)" {_A_ 4 _U_ 2222 _N_ _N_ _N_ _N_} _N_ _N_ },
+ _tagCmp = { _A_ 2 _U_ 11 _N_ _S_ "U(U(P)LL)U(U(P)LL)" {_A_ 4 _U_ 2111 _N_ _N_ _N_ _N_} _N_ _N_ } #-}
+instance Ord (Int, Int, Int, Int)
+ {-# GHC_PRAGMA _M_ PreludeBuiltin {-dfun-} _A_ 0 _N_ _N_ _N_ _F_ _IF_ARGS_ 0 0 X 9 _!_ _TUP_8 [{{Eq (Int, Int, Int, Int)}}, ((Int, Int, Int, Int) -> (Int, Int, Int, Int) -> Bool), ((Int, Int, Int, Int) -> (Int, Int, Int, Int) -> Bool), ((Int, Int, Int, Int) -> (Int, Int, Int, Int) -> Bool), ((Int, Int, Int, Int) -> (Int, Int, Int, Int) -> Bool), ((Int, Int, Int, Int) -> (Int, Int, Int, Int) -> (Int, Int, Int, Int)), ((Int, Int, Int, Int) -> (Int, Int, Int, Int) -> (Int, Int, Int, Int)), ((Int, Int, Int, Int) -> (Int, Int, Int, Int) -> _CMP_TAG)] [_DFUN_ Eq ((Int, Int, Int, Int)), _CONSTM_ Ord (<) ((Int, Int, Int, Int)), _CONSTM_ Ord (<=) ((Int, Int, Int, Int)), _CONSTM_ Ord (>=) ((Int, Int, Int, Int)), _CONSTM_ Ord (>) ((Int, Int, Int, Int)), _CONSTM_ Ord max ((Int, Int, Int, Int)), _CONSTM_ Ord min ((Int, Int, Int, Int)), _CONSTM_ Ord _tagCmp ((Int, Int, Int, Int))] _N_
+ (<) = { _A_ 2 _U_ 11 _N_ _S_ "U(U(P)LLL)U(U(P)LLL)" {_A_ 5 _U_ 21111 _N_ _N_ _N_ _N_} _N_ _N_ },
+ (<=) = { _A_ 2 _U_ 11 _N_ _S_ "U(U(P)LLL)U(U(P)LLL)" {_A_ 5 _U_ 21111 _N_ _N_ _N_ _N_} _N_ _N_ },
+ (>=) = { _A_ 2 _U_ 11 _N_ _S_ "U(U(P)LLL)U(U(P)LLL)" {_A_ 5 _U_ 21111 _N_ _N_ _N_ _N_} _N_ _N_ },
+ (>) = { _A_ 2 _U_ 11 _N_ _S_ "U(U(P)LLL)U(U(P)LLL)" {_A_ 5 _U_ 21111 _N_ _N_ _N_ _N_} _N_ _N_ },
+ max = { _A_ 2 _U_ 12 _N_ _S_ "U(U(P)LLL)U(U(P)LLL)" {_A_ 5 _U_ 22222 _N_ _N_ _N_ _N_} _N_ _N_ },
+ min = { _A_ 2 _U_ 12 _N_ _S_ "U(U(P)LLL)U(U(P)LLL)" {_A_ 5 _U_ 22222 _N_ _N_ _N_ _N_} _N_ _N_ },
+ _tagCmp = { _A_ 2 _U_ 11 _N_ _S_ "U(U(P)LLL)U(U(P)LLL)" {_A_ 5 _U_ 21111 _N_ _N_ _N_ _N_} _N_ _N_ } #-}
+instance Ord (Int, Int, Int, Int, Int)
+ {-# GHC_PRAGMA _M_ PreludeBuiltin {-dfun-} _A_ 0 _N_ _N_ _N_ _F_ _IF_ARGS_ 0 0 X 9 _!_ _TUP_8 [{{Eq (Int, Int, Int, Int, Int)}}, ((Int, Int, Int, Int, Int) -> (Int, Int, Int, Int, Int) -> Bool), ((Int, Int, Int, Int, Int) -> (Int, Int, Int, Int, Int) -> Bool), ((Int, Int, Int, Int, Int) -> (Int, Int, Int, Int, Int) -> Bool), ((Int, Int, Int, Int, Int) -> (Int, Int, Int, Int, Int) -> Bool), ((Int, Int, Int, Int, Int) -> (Int, Int, Int, Int, Int) -> (Int, Int, Int, Int, Int)), ((Int, Int, Int, Int, Int) -> (Int, Int, Int, Int, Int) -> (Int, Int, Int, Int, Int)), ((Int, Int, Int, Int, Int) -> (Int, Int, Int, Int, Int) -> _CMP_TAG)] [_DFUN_ Eq ((Int, Int, Int, Int, Int)), _CONSTM_ Ord (<) ((Int, Int, Int, Int, Int)), _CONSTM_ Ord (<=) ((Int, Int, Int, Int, Int)), _CONSTM_ Ord (>=) ((Int, Int, Int, Int, Int)), _CONSTM_ Ord (>) ((Int, Int, Int, Int, Int)), _CONSTM_ Ord max ((Int, Int, Int, Int, Int)), _CONSTM_ Ord min ((Int, Int, Int, Int, Int)), _CONSTM_ Ord _tagCmp ((Int, Int, Int, Int, Int))] _N_
+ (<) = { _A_ 2 _U_ 11 _N_ _S_ "U(U(P)LLLL)U(U(P)LLLL)" _N_ _N_ },
+ (<=) = { _A_ 2 _U_ 11 _N_ _S_ "U(U(P)LLLL)U(U(P)LLLL)" _N_ _N_ },
+ (>=) = { _A_ 2 _U_ 11 _N_ _S_ "U(U(P)LLLL)U(U(P)LLLL)" _N_ _N_ },
+ (>) = { _A_ 2 _U_ 11 _N_ _S_ "U(U(P)LLLL)U(U(P)LLLL)" _N_ _N_ },
+ max = { _A_ 2 _U_ 22 _N_ _S_ "U(U(P)LLLL)U(U(P)LLLL)" _N_ _N_ },
+ min = { _A_ 2 _U_ 22 _N_ _S_ "U(U(P)LLLL)U(U(P)LLLL)" _N_ _N_ },
+ _tagCmp = { _A_ 2 _U_ 11 _N_ _S_ "U(U(P)LLLL)U(U(P)LLLL)" _N_ _N_ } #-}
+instance Ord ([Char], [Char])
+ {-# GHC_PRAGMA _M_ PreludeBuiltin {-dfun-} _A_ 0 _N_ _N_ _N_ _F_ _IF_ARGS_ 0 0 X 9 _!_ _TUP_8 [{{Eq ([Char], [Char])}}, (([Char], [Char]) -> ([Char], [Char]) -> Bool), (([Char], [Char]) -> ([Char], [Char]) -> Bool), (([Char], [Char]) -> ([Char], [Char]) -> Bool), (([Char], [Char]) -> ([Char], [Char]) -> Bool), (([Char], [Char]) -> ([Char], [Char]) -> ([Char], [Char])), (([Char], [Char]) -> ([Char], [Char]) -> ([Char], [Char])), (([Char], [Char]) -> ([Char], [Char]) -> _CMP_TAG)] [_DFUN_ Eq (([Char], [Char])), _CONSTM_ Ord (<) (([Char], [Char])), _CONSTM_ Ord (<=) (([Char], [Char])), _CONSTM_ Ord (>=) (([Char], [Char])), _CONSTM_ Ord (>) (([Char], [Char])), _CONSTM_ Ord max (([Char], [Char])), _CONSTM_ Ord min (([Char], [Char])), _CONSTM_ Ord _tagCmp (([Char], [Char]))] _N_
+ (<) = { _A_ 2 _U_ 11 _N_ _S_ "U(SL)U(SL)" {_A_ 4 _U_ 2222 _N_ _N_ _N_ _N_} _N_ _N_ },
+ (<=) = { _A_ 2 _U_ 11 _N_ _S_ "U(SL)U(SL)" {_A_ 4 _U_ 2222 _N_ _N_ _N_ _N_} _N_ _N_ },
+ (>=) = { _A_ 2 _U_ 11 _N_ _S_ "U(SL)U(SL)" {_A_ 4 _U_ 2222 _N_ _N_ _N_ _N_} _N_ _N_ },
+ (>) = { _A_ 2 _U_ 11 _N_ _S_ "U(SL)U(SL)" {_A_ 4 _U_ 2222 _N_ _N_ _N_ _N_} _N_ _N_ },
+ max = { _A_ 2 _U_ 11 _N_ _S_ "U(SL)U(SL)" {_A_ 4 _U_ 2222 _N_ _N_ _N_ _N_} _N_ _N_ },
+ min = { _A_ 2 _U_ 11 _N_ _S_ "U(SL)U(SL)" {_A_ 4 _U_ 2222 _N_ _N_ _N_ _N_} _N_ _N_ },
+ _tagCmp = { _A_ 2 _U_ 11 _N_ _S_ "U(SL)U(SL)" {_A_ 4 _U_ 2222 _N_ _N_ _N_ _N_} _N_ _N_ } #-}
+instance Ord ([Int], [Int])
+ {-# GHC_PRAGMA _M_ PreludeBuiltin {-dfun-} _A_ 0 _N_ _N_ _N_ _F_ _IF_ARGS_ 0 0 X 9 _!_ _TUP_8 [{{Eq ([Int], [Int])}}, (([Int], [Int]) -> ([Int], [Int]) -> Bool), (([Int], [Int]) -> ([Int], [Int]) -> Bool), (([Int], [Int]) -> ([Int], [Int]) -> Bool), (([Int], [Int]) -> ([Int], [Int]) -> Bool), (([Int], [Int]) -> ([Int], [Int]) -> ([Int], [Int])), (([Int], [Int]) -> ([Int], [Int]) -> ([Int], [Int])), (([Int], [Int]) -> ([Int], [Int]) -> _CMP_TAG)] [_DFUN_ Eq (([Int], [Int])), _CONSTM_ Ord (<) (([Int], [Int])), _CONSTM_ Ord (<=) (([Int], [Int])), _CONSTM_ Ord (>=) (([Int], [Int])), _CONSTM_ Ord (>) (([Int], [Int])), _CONSTM_ Ord max (([Int], [Int])), _CONSTM_ Ord min (([Int], [Int])), _CONSTM_ Ord _tagCmp (([Int], [Int]))] _N_
+ (<) = { _A_ 2 _U_ 11 _N_ _S_ "U(SL)U(SL)" {_A_ 4 _U_ 2222 _N_ _N_ _N_ _N_} _N_ _N_ },
+ (<=) = { _A_ 2 _U_ 11 _N_ _S_ "U(SL)U(SL)" {_A_ 4 _U_ 2222 _N_ _N_ _N_ _N_} _N_ _N_ },
+ (>=) = { _A_ 2 _U_ 11 _N_ _S_ "U(SL)U(SL)" {_A_ 4 _U_ 2222 _N_ _N_ _N_ _N_} _N_ _N_ },
+ (>) = { _A_ 2 _U_ 11 _N_ _S_ "U(SL)U(SL)" {_A_ 4 _U_ 2222 _N_ _N_ _N_ _N_} _N_ _N_ },
+ max = { _A_ 2 _U_ 11 _N_ _S_ "U(SL)U(SL)" {_A_ 4 _U_ 2222 _N_ _N_ _N_ _N_} _N_ _N_ },
+ min = { _A_ 2 _U_ 11 _N_ _S_ "U(SL)U(SL)" {_A_ 4 _U_ 2222 _N_ _N_ _N_ _N_} _N_ _N_ },
+ _tagCmp = { _A_ 2 _U_ 11 _N_ _S_ "U(SL)U(SL)" {_A_ 4 _U_ 2222 _N_ _N_ _N_ _N_} _N_ _N_ } #-}
instance Ord (_PackedString, _PackedString)
{-# GHC_PRAGMA _M_ PreludeBuiltin {-dfun-} _A_ 0 _N_ _N_ _N_ _F_ _IF_ARGS_ 0 0 X 9 _!_ _TUP_8 [{{Eq (_PackedString, _PackedString)}}, ((_PackedString, _PackedString) -> (_PackedString, _PackedString) -> Bool), ((_PackedString, _PackedString) -> (_PackedString, _PackedString) -> Bool), ((_PackedString, _PackedString) -> (_PackedString, _PackedString) -> Bool), ((_PackedString, _PackedString) -> (_PackedString, _PackedString) -> Bool), ((_PackedString, _PackedString) -> (_PackedString, _PackedString) -> (_PackedString, _PackedString)), ((_PackedString, _PackedString) -> (_PackedString, _PackedString) -> (_PackedString, _PackedString)), ((_PackedString, _PackedString) -> (_PackedString, _PackedString) -> _CMP_TAG)] [_DFUN_ Eq ((_PackedString, _PackedString)), _CONSTM_ Ord (<) ((_PackedString, _PackedString)), _CONSTM_ Ord (<=) ((_PackedString, _PackedString)), _CONSTM_ Ord (>=) ((_PackedString, _PackedString)), _CONSTM_ Ord (>) ((_PackedString, _PackedString)), _CONSTM_ Ord max ((_PackedString, _PackedString)), _CONSTM_ Ord min ((_PackedString, _PackedString)), _CONSTM_ Ord _tagCmp ((_PackedString, _PackedString))] _N_
- (<) = _A_ 2 _U_ 11 _N_ _S_ "U(SL)U(SL)" {_A_ 4 _U_ 2222 _N_ _N_ _N_ _N_} _N_ _N_,
- (<=) = _A_ 2 _U_ 11 _N_ _S_ "U(SL)U(SL)" {_A_ 4 _U_ 2222 _N_ _N_ _N_ _N_} _N_ _N_,
- (>=) = _A_ 2 _U_ 11 _N_ _S_ "U(SL)U(SL)" {_A_ 4 _U_ 2222 _N_ _N_ _N_ _N_} _N_ _N_,
- (>) = _A_ 2 _U_ 11 _N_ _S_ "U(SL)U(SL)" {_A_ 4 _U_ 2222 _N_ _N_ _N_ _N_} _N_ _N_,
- max = _A_ 2 _U_ 11 _N_ _S_ "U(SL)U(SL)" {_A_ 4 _U_ 2222 _N_ _N_ _N_ _N_} _N_ _N_,
- min = _A_ 2 _U_ 11 _N_ _S_ "U(SL)U(SL)" {_A_ 4 _U_ 2222 _N_ _N_ _N_ _N_} _N_ _N_,
- _tagCmp = _A_ 2 _U_ 11 _N_ _S_ "U(SL)U(SL)" {_A_ 4 _U_ 2222 _N_ _N_ _N_ _N_} _N_ _N_ #-}
+ (<) = { _A_ 2 _U_ 11 _N_ _S_ "U(SL)U(SL)" {_A_ 4 _U_ 2222 _N_ _N_ _N_ _N_} _N_ _N_ },
+ (<=) = { _A_ 2 _U_ 11 _N_ _S_ "U(SL)U(SL)" {_A_ 4 _U_ 2222 _N_ _N_ _N_ _N_} _N_ _N_ },
+ (>=) = { _A_ 2 _U_ 11 _N_ _S_ "U(SL)U(SL)" {_A_ 4 _U_ 2222 _N_ _N_ _N_ _N_} _N_ _N_ },
+ (>) = { _A_ 2 _U_ 11 _N_ _S_ "U(SL)U(SL)" {_A_ 4 _U_ 2222 _N_ _N_ _N_ _N_} _N_ _N_ },
+ max = { _A_ 2 _U_ 11 _N_ _S_ "U(SL)U(SL)" {_A_ 4 _U_ 2222 _N_ _N_ _N_ _N_} _N_ _N_ },
+ min = { _A_ 2 _U_ 11 _N_ _S_ "U(SL)U(SL)" {_A_ 4 _U_ 2222 _N_ _N_ _N_ _N_} _N_ _N_ },
+ _tagCmp = { _A_ 2 _U_ 11 _N_ _S_ "U(SL)U(SL)" {_A_ 4 _U_ 2222 _N_ _N_ _N_ _N_} _N_ _N_ } #-}
instance (Ix a, Ord b) => Ord (Array a b)
{-# GHC_PRAGMA _M_ PreludeArray {-dfun-} _A_ 3 _U_ 222 _N_ _N_ _N_ _N_ #-}
instance (Ord a, Ord b) => Ord (Assoc a b)
{-# GHC_PRAGMA _M_ PreludeArray {-dfun-} _A_ 3 _U_ 112 _N_ _N_ _N_ _N_ #-}
instance Ord Bool
{-# GHC_PRAGMA _M_ PreludeCore {-dfun-} _A_ 0 _N_ _N_ _N_ _F_ _IF_ARGS_ 0 0 X 9 _!_ _TUP_8 [{{Eq Bool}}, (Bool -> Bool -> Bool), (Bool -> Bool -> Bool), (Bool -> Bool -> Bool), (Bool -> Bool -> Bool), (Bool -> Bool -> Bool), (Bool -> Bool -> Bool), (Bool -> Bool -> _CMP_TAG)] [_DFUN_ Eq (Bool), _CONSTM_ Ord (<) (Bool), _CONSTM_ Ord (<=) (Bool), _CONSTM_ Ord (>=) (Bool), _CONSTM_ Ord (>) (Bool), _CONSTM_ Ord max (Bool), _CONSTM_ Ord min (Bool), _CONSTM_ Ord _tagCmp (Bool)] _N_
- (<) = _A_ 2 _U_ 11 _N_ _S_ "EE" _N_ _N_,
- (<=) = _A_ 2 _U_ 11 _N_ _S_ "EE" _N_ _N_,
- (>=) = _A_ 2 _U_ 11 _N_ _S_ "EE" _N_ _N_,
- (>) = _A_ 2 _U_ 11 _N_ _S_ "EE" _N_ _N_,
- max = _A_ 2 _U_ 22 _N_ _S_ "EE" _N_ _N_,
- min = _A_ 2 _U_ 22 _N_ _S_ "EE" _N_ _N_,
- _tagCmp = _A_ 2 _U_ 11 _N_ _S_ "EE" _N_ _N_ #-}
+ (<) = { _A_ 2 _U_ 11 _N_ _S_ "EE" _N_ _N_ },
+ (<=) = { _A_ 2 _U_ 11 _N_ _S_ "EE" _N_ _N_ },
+ (>=) = { _A_ 2 _U_ 11 _N_ _S_ "EE" _N_ _N_ },
+ (>) = { _A_ 2 _U_ 11 _N_ _S_ "EE" _N_ _N_ },
+ max = { _A_ 2 _U_ 22 _N_ _S_ "EE" _N_ _N_ },
+ min = { _A_ 2 _U_ 22 _N_ _S_ "EE" _N_ _N_ },
+ _tagCmp = { _A_ 2 _U_ 11 _N_ _S_ "EE" _N_ _N_ } #-}
instance Ord Char
{-# GHC_PRAGMA _M_ PreludeCore {-dfun-} _A_ 0 _N_ _N_ _N_ _F_ _IF_ARGS_ 0 0 X 9 _!_ _TUP_8 [{{Eq Char}}, (Char -> Char -> Bool), (Char -> Char -> Bool), (Char -> Char -> Bool), (Char -> Char -> Bool), (Char -> Char -> Char), (Char -> Char -> Char), (Char -> Char -> _CMP_TAG)] [_DFUN_ Eq (Char), _CONSTM_ Ord (<) (Char), _CONSTM_ Ord (<=) (Char), _CONSTM_ Ord (>=) (Char), _CONSTM_ Ord (>) (Char), _CONSTM_ Ord max (Char), _CONSTM_ Ord min (Char), _CONSTM_ Ord _tagCmp (Char)] _N_
- (<) = _A_ 2 _U_ 11 _N_ _S_ "U(P)U(P)" {_A_ 2 _U_ 22 _N_ _N_ _F_ _IF_ARGS_ 0 2 XX 1 \ (u0 :: Char#) (u1 :: Char#) -> _#_ ltChar# [] [u0, u1] _N_} _F_ _IF_ARGS_ 0 2 CC 3 \ (u0 :: Char) (u1 :: Char) -> case u0 of { _ALG_ C# (u2 :: Char#) -> case u1 of { _ALG_ C# (u3 :: Char#) -> _#_ ltChar# [] [u2, u3]; _NO_DEFLT_ }; _NO_DEFLT_ } _N_,
- (<=) = _A_ 2 _U_ 11 _N_ _S_ "U(P)U(P)" {_A_ 2 _U_ 22 _N_ _N_ _F_ _IF_ARGS_ 0 2 XX 1 \ (u0 :: Char#) (u1 :: Char#) -> _#_ leChar# [] [u0, u1] _N_} _F_ _IF_ARGS_ 0 2 CC 3 \ (u0 :: Char) (u1 :: Char) -> case u0 of { _ALG_ C# (u2 :: Char#) -> case u1 of { _ALG_ C# (u3 :: Char#) -> _#_ leChar# [] [u2, u3]; _NO_DEFLT_ }; _NO_DEFLT_ } _N_,
- (>=) = _A_ 2 _U_ 11 _N_ _S_ "U(P)U(P)" {_A_ 2 _U_ 22 _N_ _N_ _F_ _IF_ARGS_ 0 2 XX 1 \ (u0 :: Char#) (u1 :: Char#) -> _#_ geChar# [] [u0, u1] _N_} _F_ _IF_ARGS_ 0 2 CC 3 \ (u0 :: Char) (u1 :: Char) -> case u0 of { _ALG_ C# (u2 :: Char#) -> case u1 of { _ALG_ C# (u3 :: Char#) -> _#_ geChar# [] [u2, u3]; _NO_DEFLT_ }; _NO_DEFLT_ } _N_,
- (>) = _A_ 2 _U_ 11 _N_ _S_ "U(P)U(P)" {_A_ 2 _U_ 22 _N_ _N_ _F_ _IF_ARGS_ 0 2 XX 1 \ (u0 :: Char#) (u1 :: Char#) -> _#_ gtChar# [] [u0, u1] _N_} _F_ _IF_ARGS_ 0 2 CC 3 \ (u0 :: Char) (u1 :: Char) -> case u0 of { _ALG_ C# (u2 :: Char#) -> case u1 of { _ALG_ C# (u3 :: Char#) -> _#_ gtChar# [] [u2, u3]; _NO_DEFLT_ }; _NO_DEFLT_ } _N_,
- max = _A_ 2 _U_ 11 _N_ _S_ "U(P)U(P)" {_A_ 2 _U_ 22 _N_ _N_ _N_ _N_} _N_ _N_,
- min = _A_ 2 _U_ 11 _N_ _S_ "U(P)U(P)" {_A_ 2 _U_ 22 _N_ _N_ _N_ _N_} _N_ _N_,
- _tagCmp = _A_ 2 _U_ 11 _N_ _S_ "U(P)U(P)" {_A_ 2 _U_ 22 _N_ _N_ _N_ _N_} _N_ _N_ #-}
+ (<) = { _A_ 2 _U_ 11 _N_ _S_ "U(P)U(P)" {_A_ 2 _U_ 22 _N_ _N_ _F_ _IF_ARGS_ 0 2 XX 1 \ (u0 :: Char#) (u1 :: Char#) -> _#_ ltChar# [] [u0, u1] _N_} _F_ _IF_ARGS_ 0 2 CC 3 \ (u0 :: Char) (u1 :: Char) -> case u0 of { _ALG_ C# (u2 :: Char#) -> case u1 of { _ALG_ C# (u3 :: Char#) -> _#_ ltChar# [] [u2, u3]; _NO_DEFLT_ }; _NO_DEFLT_ } _N_ },
+ (<=) = { _A_ 2 _U_ 11 _N_ _S_ "U(P)U(P)" {_A_ 2 _U_ 22 _N_ _N_ _F_ _IF_ARGS_ 0 2 XX 1 \ (u0 :: Char#) (u1 :: Char#) -> _#_ leChar# [] [u0, u1] _N_} _F_ _IF_ARGS_ 0 2 CC 3 \ (u0 :: Char) (u1 :: Char) -> case u0 of { _ALG_ C# (u2 :: Char#) -> case u1 of { _ALG_ C# (u3 :: Char#) -> _#_ leChar# [] [u2, u3]; _NO_DEFLT_ }; _NO_DEFLT_ } _N_ },
+ (>=) = { _A_ 2 _U_ 11 _N_ _S_ "U(P)U(P)" {_A_ 2 _U_ 22 _N_ _N_ _F_ _IF_ARGS_ 0 2 XX 1 \ (u0 :: Char#) (u1 :: Char#) -> _#_ geChar# [] [u0, u1] _N_} _F_ _IF_ARGS_ 0 2 CC 3 \ (u0 :: Char) (u1 :: Char) -> case u0 of { _ALG_ C# (u2 :: Char#) -> case u1 of { _ALG_ C# (u3 :: Char#) -> _#_ geChar# [] [u2, u3]; _NO_DEFLT_ }; _NO_DEFLT_ } _N_ },
+ (>) = { _A_ 2 _U_ 11 _N_ _S_ "U(P)U(P)" {_A_ 2 _U_ 22 _N_ _N_ _F_ _IF_ARGS_ 0 2 XX 1 \ (u0 :: Char#) (u1 :: Char#) -> _#_ gtChar# [] [u0, u1] _N_} _F_ _IF_ARGS_ 0 2 CC 3 \ (u0 :: Char) (u1 :: Char) -> case u0 of { _ALG_ C# (u2 :: Char#) -> case u1 of { _ALG_ C# (u3 :: Char#) -> _#_ gtChar# [] [u2, u3]; _NO_DEFLT_ }; _NO_DEFLT_ } _N_ },
+ max = { _A_ 2 _U_ 11 _N_ _S_ "U(P)U(P)" {_A_ 2 _U_ 22 _N_ _N_ _N_ _N_} _N_ _N_ },
+ min = { _A_ 2 _U_ 11 _N_ _S_ "U(P)U(P)" {_A_ 2 _U_ 22 _N_ _N_ _N_ _N_} _N_ _N_ },
+ _tagCmp = { _A_ 2 _U_ 11 _N_ _S_ "U(P)U(P)" {_A_ 2 _U_ 22 _N_ _N_ _N_ _N_} _N_ _N_ } #-}
instance Ord Double
{-# GHC_PRAGMA _M_ PreludeCore {-dfun-} _A_ 0 _N_ _N_ _N_ _F_ _IF_ARGS_ 0 0 X 9 _!_ _TUP_8 [{{Eq Double}}, (Double -> Double -> Bool), (Double -> Double -> Bool), (Double -> Double -> Bool), (Double -> Double -> Bool), (Double -> Double -> Double), (Double -> Double -> Double), (Double -> Double -> _CMP_TAG)] [_DFUN_ Eq (Double), _CONSTM_ Ord (<) (Double), _CONSTM_ Ord (<=) (Double), _CONSTM_ Ord (>=) (Double), _CONSTM_ Ord (>) (Double), _CONSTM_ Ord max (Double), _CONSTM_ Ord min (Double), _CONSTM_ Ord _tagCmp (Double)] _N_
- (<) = _A_ 2 _U_ 11 _N_ _S_ "U(P)U(P)" {_A_ 2 _U_ 22 _N_ _N_ _F_ _IF_ARGS_ 0 2 XX 1 \ (u0 :: Double#) (u1 :: Double#) -> _#_ ltDouble# [] [u0, u1] _N_} _F_ _IF_ARGS_ 0 2 CC 3 \ (u0 :: Double) (u1 :: Double) -> case u0 of { _ALG_ D# (u2 :: Double#) -> case u1 of { _ALG_ D# (u3 :: Double#) -> _#_ ltDouble# [] [u2, u3]; _NO_DEFLT_ }; _NO_DEFLT_ } _N_,
- (<=) = _A_ 2 _U_ 11 _N_ _S_ "U(P)U(P)" {_A_ 2 _U_ 22 _N_ _N_ _F_ _IF_ARGS_ 0 2 XX 1 \ (u0 :: Double#) (u1 :: Double#) -> _#_ leDouble# [] [u0, u1] _N_} _F_ _IF_ARGS_ 0 2 CC 3 \ (u0 :: Double) (u1 :: Double) -> case u0 of { _ALG_ D# (u2 :: Double#) -> case u1 of { _ALG_ D# (u3 :: Double#) -> _#_ leDouble# [] [u2, u3]; _NO_DEFLT_ }; _NO_DEFLT_ } _N_,
- (>=) = _A_ 2 _U_ 11 _N_ _S_ "U(P)U(P)" {_A_ 2 _U_ 22 _N_ _N_ _F_ _IF_ARGS_ 0 2 XX 1 \ (u0 :: Double#) (u1 :: Double#) -> _#_ geDouble# [] [u0, u1] _N_} _F_ _IF_ARGS_ 0 2 CC 3 \ (u0 :: Double) (u1 :: Double) -> case u0 of { _ALG_ D# (u2 :: Double#) -> case u1 of { _ALG_ D# (u3 :: Double#) -> _#_ geDouble# [] [u2, u3]; _NO_DEFLT_ }; _NO_DEFLT_ } _N_,
- (>) = _A_ 2 _U_ 11 _N_ _S_ "U(P)U(P)" {_A_ 2 _U_ 22 _N_ _N_ _F_ _IF_ARGS_ 0 2 XX 1 \ (u0 :: Double#) (u1 :: Double#) -> _#_ gtDouble# [] [u0, u1] _N_} _F_ _IF_ARGS_ 0 2 CC 3 \ (u0 :: Double) (u1 :: Double) -> case u0 of { _ALG_ D# (u2 :: Double#) -> case u1 of { _ALG_ D# (u3 :: Double#) -> _#_ gtDouble# [] [u2, u3]; _NO_DEFLT_ }; _NO_DEFLT_ } _N_,
- max = _A_ 2 _U_ 11 _N_ _S_ "U(P)U(P)" {_A_ 2 _U_ 22 _N_ _N_ _N_ _N_} _N_ _N_,
- min = _A_ 2 _U_ 11 _N_ _S_ "U(P)U(P)" {_A_ 2 _U_ 22 _N_ _N_ _N_ _N_} _N_ _N_,
- _tagCmp = _A_ 2 _U_ 11 _N_ _S_ "U(P)U(P)" {_A_ 2 _U_ 22 _N_ _N_ _N_ _N_} _N_ _N_ #-}
+ (<) = { _A_ 2 _U_ 11 _N_ _S_ "U(P)U(P)" {_A_ 2 _U_ 22 _N_ _N_ _F_ _IF_ARGS_ 0 2 XX 1 \ (u0 :: Double#) (u1 :: Double#) -> _#_ ltDouble# [] [u0, u1] _N_} _F_ _IF_ARGS_ 0 2 CC 3 \ (u0 :: Double) (u1 :: Double) -> case u0 of { _ALG_ D# (u2 :: Double#) -> case u1 of { _ALG_ D# (u3 :: Double#) -> _#_ ltDouble# [] [u2, u3]; _NO_DEFLT_ }; _NO_DEFLT_ } _N_ },
+ (<=) = { _A_ 2 _U_ 11 _N_ _S_ "U(P)U(P)" {_A_ 2 _U_ 22 _N_ _N_ _F_ _IF_ARGS_ 0 2 XX 1 \ (u0 :: Double#) (u1 :: Double#) -> _#_ leDouble# [] [u0, u1] _N_} _F_ _IF_ARGS_ 0 2 CC 3 \ (u0 :: Double) (u1 :: Double) -> case u0 of { _ALG_ D# (u2 :: Double#) -> case u1 of { _ALG_ D# (u3 :: Double#) -> _#_ leDouble# [] [u2, u3]; _NO_DEFLT_ }; _NO_DEFLT_ } _N_ },
+ (>=) = { _A_ 2 _U_ 11 _N_ _S_ "U(P)U(P)" {_A_ 2 _U_ 22 _N_ _N_ _F_ _IF_ARGS_ 0 2 XX 1 \ (u0 :: Double#) (u1 :: Double#) -> _#_ geDouble# [] [u0, u1] _N_} _F_ _IF_ARGS_ 0 2 CC 3 \ (u0 :: Double) (u1 :: Double) -> case u0 of { _ALG_ D# (u2 :: Double#) -> case u1 of { _ALG_ D# (u3 :: Double#) -> _#_ geDouble# [] [u2, u3]; _NO_DEFLT_ }; _NO_DEFLT_ } _N_ },
+ (>) = { _A_ 2 _U_ 11 _N_ _S_ "U(P)U(P)" {_A_ 2 _U_ 22 _N_ _N_ _F_ _IF_ARGS_ 0 2 XX 1 \ (u0 :: Double#) (u1 :: Double#) -> _#_ gtDouble# [] [u0, u1] _N_} _F_ _IF_ARGS_ 0 2 CC 3 \ (u0 :: Double) (u1 :: Double) -> case u0 of { _ALG_ D# (u2 :: Double#) -> case u1 of { _ALG_ D# (u3 :: Double#) -> _#_ gtDouble# [] [u2, u3]; _NO_DEFLT_ }; _NO_DEFLT_ } _N_ },
+ max = { _A_ 2 _U_ 11 _N_ _S_ "U(P)U(P)" {_A_ 2 _U_ 22 _N_ _N_ _N_ _N_} _N_ _N_ },
+ min = { _A_ 2 _U_ 11 _N_ _S_ "U(P)U(P)" {_A_ 2 _U_ 22 _N_ _N_ _N_ _N_} _N_ _N_ },
+ _tagCmp = { _A_ 2 _U_ 11 _N_ _S_ "U(P)U(P)" {_A_ 2 _U_ 22 _N_ _N_ _N_ _N_} _N_ _N_ } #-}
instance Ord Float
{-# GHC_PRAGMA _M_ PreludeCore {-dfun-} _A_ 0 _N_ _N_ _N_ _F_ _IF_ARGS_ 0 0 X 9 _!_ _TUP_8 [{{Eq Float}}, (Float -> Float -> Bool), (Float -> Float -> Bool), (Float -> Float -> Bool), (Float -> Float -> Bool), (Float -> Float -> Float), (Float -> Float -> Float), (Float -> Float -> _CMP_TAG)] [_DFUN_ Eq (Float), _CONSTM_ Ord (<) (Float), _CONSTM_ Ord (<=) (Float), _CONSTM_ Ord (>=) (Float), _CONSTM_ Ord (>) (Float), _CONSTM_ Ord max (Float), _CONSTM_ Ord min (Float), _CONSTM_ Ord _tagCmp (Float)] _N_
- (<) = _A_ 2 _U_ 11 _N_ _S_ "U(P)U(P)" {_A_ 2 _U_ 22 _N_ _N_ _F_ _IF_ARGS_ 0 2 XX 1 \ (u0 :: Float#) (u1 :: Float#) -> _#_ ltFloat# [] [u0, u1] _N_} _F_ _IF_ARGS_ 0 2 CC 3 \ (u0 :: Float) (u1 :: Float) -> case u0 of { _ALG_ F# (u2 :: Float#) -> case u1 of { _ALG_ F# (u3 :: Float#) -> _#_ ltFloat# [] [u2, u3]; _NO_DEFLT_ }; _NO_DEFLT_ } _N_,
- (<=) = _A_ 2 _U_ 11 _N_ _S_ "U(P)U(P)" {_A_ 2 _U_ 22 _N_ _N_ _F_ _IF_ARGS_ 0 2 XX 1 \ (u0 :: Float#) (u1 :: Float#) -> _#_ leFloat# [] [u0, u1] _N_} _F_ _IF_ARGS_ 0 2 CC 3 \ (u0 :: Float) (u1 :: Float) -> case u0 of { _ALG_ F# (u2 :: Float#) -> case u1 of { _ALG_ F# (u3 :: Float#) -> _#_ leFloat# [] [u2, u3]; _NO_DEFLT_ }; _NO_DEFLT_ } _N_,
- (>=) = _A_ 2 _U_ 11 _N_ _S_ "U(P)U(P)" {_A_ 2 _U_ 22 _N_ _N_ _F_ _IF_ARGS_ 0 2 XX 1 \ (u0 :: Float#) (u1 :: Float#) -> _#_ geFloat# [] [u0, u1] _N_} _F_ _IF_ARGS_ 0 2 CC 3 \ (u0 :: Float) (u1 :: Float) -> case u0 of { _ALG_ F# (u2 :: Float#) -> case u1 of { _ALG_ F# (u3 :: Float#) -> _#_ geFloat# [] [u2, u3]; _NO_DEFLT_ }; _NO_DEFLT_ } _N_,
- (>) = _A_ 2 _U_ 11 _N_ _S_ "U(P)U(P)" {_A_ 2 _U_ 22 _N_ _N_ _F_ _IF_ARGS_ 0 2 XX 1 \ (u0 :: Float#) (u1 :: Float#) -> _#_ gtFloat# [] [u0, u1] _N_} _F_ _IF_ARGS_ 0 2 CC 3 \ (u0 :: Float) (u1 :: Float) -> case u0 of { _ALG_ F# (u2 :: Float#) -> case u1 of { _ALG_ F# (u3 :: Float#) -> _#_ gtFloat# [] [u2, u3]; _NO_DEFLT_ }; _NO_DEFLT_ } _N_,
- max = _A_ 2 _U_ 11 _N_ _S_ "U(P)U(P)" {_A_ 2 _U_ 22 _N_ _N_ _N_ _N_} _N_ _N_,
- min = _A_ 2 _U_ 11 _N_ _S_ "U(P)U(P)" {_A_ 2 _U_ 22 _N_ _N_ _N_ _N_} _N_ _N_,
- _tagCmp = _A_ 2 _U_ 11 _N_ _S_ "U(P)U(P)" {_A_ 2 _U_ 22 _N_ _N_ _N_ _N_} _N_ _N_ #-}
+ (<) = { _A_ 2 _U_ 11 _N_ _S_ "U(P)U(P)" {_A_ 2 _U_ 22 _N_ _N_ _F_ _IF_ARGS_ 0 2 XX 1 \ (u0 :: Float#) (u1 :: Float#) -> _#_ ltFloat# [] [u0, u1] _N_} _F_ _IF_ARGS_ 0 2 CC 3 \ (u0 :: Float) (u1 :: Float) -> case u0 of { _ALG_ F# (u2 :: Float#) -> case u1 of { _ALG_ F# (u3 :: Float#) -> _#_ ltFloat# [] [u2, u3]; _NO_DEFLT_ }; _NO_DEFLT_ } _N_ },
+ (<=) = { _A_ 2 _U_ 11 _N_ _S_ "U(P)U(P)" {_A_ 2 _U_ 22 _N_ _N_ _F_ _IF_ARGS_ 0 2 XX 1 \ (u0 :: Float#) (u1 :: Float#) -> _#_ leFloat# [] [u0, u1] _N_} _F_ _IF_ARGS_ 0 2 CC 3 \ (u0 :: Float) (u1 :: Float) -> case u0 of { _ALG_ F# (u2 :: Float#) -> case u1 of { _ALG_ F# (u3 :: Float#) -> _#_ leFloat# [] [u2, u3]; _NO_DEFLT_ }; _NO_DEFLT_ } _N_ },
+ (>=) = { _A_ 2 _U_ 11 _N_ _S_ "U(P)U(P)" {_A_ 2 _U_ 22 _N_ _N_ _F_ _IF_ARGS_ 0 2 XX 1 \ (u0 :: Float#) (u1 :: Float#) -> _#_ geFloat# [] [u0, u1] _N_} _F_ _IF_ARGS_ 0 2 CC 3 \ (u0 :: Float) (u1 :: Float) -> case u0 of { _ALG_ F# (u2 :: Float#) -> case u1 of { _ALG_ F# (u3 :: Float#) -> _#_ geFloat# [] [u2, u3]; _NO_DEFLT_ }; _NO_DEFLT_ } _N_ },
+ (>) = { _A_ 2 _U_ 11 _N_ _S_ "U(P)U(P)" {_A_ 2 _U_ 22 _N_ _N_ _F_ _IF_ARGS_ 0 2 XX 1 \ (u0 :: Float#) (u1 :: Float#) -> _#_ gtFloat# [] [u0, u1] _N_} _F_ _IF_ARGS_ 0 2 CC 3 \ (u0 :: Float) (u1 :: Float) -> case u0 of { _ALG_ F# (u2 :: Float#) -> case u1 of { _ALG_ F# (u3 :: Float#) -> _#_ gtFloat# [] [u2, u3]; _NO_DEFLT_ }; _NO_DEFLT_ } _N_ },
+ max = { _A_ 2 _U_ 11 _N_ _S_ "U(P)U(P)" {_A_ 2 _U_ 22 _N_ _N_ _N_ _N_} _N_ _N_ },
+ min = { _A_ 2 _U_ 11 _N_ _S_ "U(P)U(P)" {_A_ 2 _U_ 22 _N_ _N_ _N_ _N_} _N_ _N_ },
+ _tagCmp = { _A_ 2 _U_ 11 _N_ _S_ "U(P)U(P)" {_A_ 2 _U_ 22 _N_ _N_ _N_ _N_} _N_ _N_ } #-}
instance Ord Int
{-# GHC_PRAGMA _M_ PreludeCore {-dfun-} _A_ 0 _N_ _N_ _N_ _F_ _IF_ARGS_ 0 0 X 9 _!_ _TUP_8 [{{Eq Int}}, (Int -> Int -> Bool), (Int -> Int -> Bool), (Int -> Int -> Bool), (Int -> Int -> Bool), (Int -> Int -> Int), (Int -> Int -> Int), (Int -> Int -> _CMP_TAG)] [_DFUN_ Eq (Int), _CONSTM_ Ord (<) (Int), _CONSTM_ Ord (<=) (Int), _CONSTM_ Ord (>=) (Int), _CONSTM_ Ord (>) (Int), _CONSTM_ Ord max (Int), _CONSTM_ Ord min (Int), _CONSTM_ Ord _tagCmp (Int)] _N_
- (<) = _A_ 2 _U_ 11 _N_ _S_ "U(P)U(P)" {_A_ 2 _U_ 22 _N_ _N_ _F_ _IF_ARGS_ 0 2 XX 1 \ (u0 :: Int#) (u1 :: Int#) -> _#_ ltInt# [] [u0, u1] _N_} _F_ _IF_ARGS_ 0 2 CC 3 \ (u0 :: Int) (u1 :: Int) -> case u0 of { _ALG_ I# (u2 :: Int#) -> case u1 of { _ALG_ I# (u3 :: Int#) -> _#_ ltInt# [] [u2, u3]; _NO_DEFLT_ }; _NO_DEFLT_ } _N_,
- (<=) = _A_ 2 _U_ 11 _N_ _S_ "U(P)U(P)" {_A_ 2 _U_ 22 _N_ _N_ _F_ _IF_ARGS_ 0 2 XX 1 \ (u0 :: Int#) (u1 :: Int#) -> _#_ leInt# [] [u0, u1] _N_} _F_ _IF_ARGS_ 0 2 CC 3 \ (u0 :: Int) (u1 :: Int) -> case u0 of { _ALG_ I# (u2 :: Int#) -> case u1 of { _ALG_ I# (u3 :: Int#) -> _#_ leInt# [] [u2, u3]; _NO_DEFLT_ }; _NO_DEFLT_ } _N_,
- (>=) = _A_ 2 _U_ 11 _N_ _S_ "U(P)U(P)" {_A_ 2 _U_ 22 _N_ _N_ _F_ _IF_ARGS_ 0 2 XX 1 \ (u0 :: Int#) (u1 :: Int#) -> _#_ geInt# [] [u0, u1] _N_} _F_ _IF_ARGS_ 0 2 CC 3 \ (u0 :: Int) (u1 :: Int) -> case u0 of { _ALG_ I# (u2 :: Int#) -> case u1 of { _ALG_ I# (u3 :: Int#) -> _#_ geInt# [] [u2, u3]; _NO_DEFLT_ }; _NO_DEFLT_ } _N_,
- (>) = _A_ 2 _U_ 11 _N_ _S_ "U(P)U(P)" {_A_ 2 _U_ 22 _N_ _N_ _F_ _IF_ARGS_ 0 2 XX 1 \ (u0 :: Int#) (u1 :: Int#) -> _#_ gtInt# [] [u0, u1] _N_} _F_ _IF_ARGS_ 0 2 CC 3 \ (u0 :: Int) (u1 :: Int) -> case u0 of { _ALG_ I# (u2 :: Int#) -> case u1 of { _ALG_ I# (u3 :: Int#) -> _#_ gtInt# [] [u2, u3]; _NO_DEFLT_ }; _NO_DEFLT_ } _N_,
- max = _A_ 2 _U_ 11 _N_ _S_ "U(P)U(P)" {_A_ 2 _U_ 22 _N_ _N_ _N_ _N_} _N_ _N_,
- min = _A_ 2 _U_ 11 _N_ _S_ "U(P)U(P)" {_A_ 2 _U_ 22 _N_ _N_ _N_ _N_} _N_ _N_,
- _tagCmp = _A_ 2 _U_ 11 _N_ _S_ "U(P)U(P)" {_A_ 2 _U_ 22 _N_ _N_ _N_ _N_} _N_ _N_ #-}
+ (<) = { _A_ 2 _U_ 11 _N_ _S_ "U(P)U(P)" {_A_ 2 _U_ 22 _N_ _N_ _F_ _IF_ARGS_ 0 2 XX 1 \ (u0 :: Int#) (u1 :: Int#) -> _#_ ltInt# [] [u0, u1] _N_} _F_ _IF_ARGS_ 0 2 CC 3 \ (u0 :: Int) (u1 :: Int) -> case u0 of { _ALG_ I# (u2 :: Int#) -> case u1 of { _ALG_ I# (u3 :: Int#) -> _#_ ltInt# [] [u2, u3]; _NO_DEFLT_ }; _NO_DEFLT_ } _N_ },
+ (<=) = { _A_ 2 _U_ 11 _N_ _S_ "U(P)U(P)" {_A_ 2 _U_ 22 _N_ _N_ _F_ _IF_ARGS_ 0 2 XX 1 \ (u0 :: Int#) (u1 :: Int#) -> _#_ leInt# [] [u0, u1] _N_} _F_ _IF_ARGS_ 0 2 CC 3 \ (u0 :: Int) (u1 :: Int) -> case u0 of { _ALG_ I# (u2 :: Int#) -> case u1 of { _ALG_ I# (u3 :: Int#) -> _#_ leInt# [] [u2, u3]; _NO_DEFLT_ }; _NO_DEFLT_ } _N_ },
+ (>=) = { _A_ 2 _U_ 11 _N_ _S_ "U(P)U(P)" {_A_ 2 _U_ 22 _N_ _N_ _F_ _IF_ARGS_ 0 2 XX 1 \ (u0 :: Int#) (u1 :: Int#) -> _#_ geInt# [] [u0, u1] _N_} _F_ _IF_ARGS_ 0 2 CC 3 \ (u0 :: Int) (u1 :: Int) -> case u0 of { _ALG_ I# (u2 :: Int#) -> case u1 of { _ALG_ I# (u3 :: Int#) -> _#_ geInt# [] [u2, u3]; _NO_DEFLT_ }; _NO_DEFLT_ } _N_ },
+ (>) = { _A_ 2 _U_ 11 _N_ _S_ "U(P)U(P)" {_A_ 2 _U_ 22 _N_ _N_ _F_ _IF_ARGS_ 0 2 XX 1 \ (u0 :: Int#) (u1 :: Int#) -> _#_ gtInt# [] [u0, u1] _N_} _F_ _IF_ARGS_ 0 2 CC 3 \ (u0 :: Int) (u1 :: Int) -> case u0 of { _ALG_ I# (u2 :: Int#) -> case u1 of { _ALG_ I# (u3 :: Int#) -> _#_ gtInt# [] [u2, u3]; _NO_DEFLT_ }; _NO_DEFLT_ } _N_ },
+ max = { _A_ 2 _U_ 11 _N_ _S_ "U(P)U(P)" {_A_ 2 _U_ 22 _N_ _N_ _N_ _N_} _N_ _N_ },
+ min = { _A_ 2 _U_ 11 _N_ _S_ "U(P)U(P)" {_A_ 2 _U_ 22 _N_ _N_ _N_ _N_} _N_ _N_ },
+ _tagCmp = { _A_ 2 _U_ 11 _N_ _S_ "U(P)U(P)" {_A_ 2 _U_ 22 _N_ _N_ _N_ _N_} _N_ _N_ } #-}
instance Ord Integer
{-# GHC_PRAGMA _M_ PreludeCore {-dfun-} _A_ 0 _N_ _N_ _N_ _F_ _IF_ARGS_ 0 0 X 9 _!_ _TUP_8 [{{Eq Integer}}, (Integer -> Integer -> Bool), (Integer -> Integer -> Bool), (Integer -> Integer -> Bool), (Integer -> Integer -> Bool), (Integer -> Integer -> Integer), (Integer -> Integer -> Integer), (Integer -> Integer -> _CMP_TAG)] [_DFUN_ Eq (Integer), _CONSTM_ Ord (<) (Integer), _CONSTM_ Ord (<=) (Integer), _CONSTM_ Ord (>=) (Integer), _CONSTM_ Ord (>) (Integer), _CONSTM_ Ord max (Integer), _CONSTM_ Ord min (Integer), _CONSTM_ Ord _tagCmp (Integer)] _N_
- (<) = _A_ 2 _U_ 11 _N_ _S_ "U(PPP)U(PPP)" {_A_ 4 _U_ 2221 _N_ _N_ _F_ _IF_ARGS_ 0 4 XXXC 3 \ (u0 :: Int#) (u1 :: Int#) (u2 :: ByteArray#) (u3 :: Integer) -> case u3 of { _ALG_ J# (u4 :: Int#) (u5 :: Int#) (u6 :: ByteArray#) -> case _#_ cmpInteger# [] [u0, u1, u2, u4, u5, u6] of { _PRIM_ (u7 :: Int#) -> _#_ ltInt# [] [u7, 0#] }; _NO_DEFLT_ } _N_} _F_ _IF_ARGS_ 0 2 CC 4 \ (u0 :: Integer) (u1 :: Integer) -> case u0 of { _ALG_ J# (u2 :: Int#) (u3 :: Int#) (u4 :: ByteArray#) -> case u1 of { _ALG_ J# (u5 :: Int#) (u6 :: Int#) (u7 :: ByteArray#) -> case _#_ cmpInteger# [] [u2, u3, u4, u5, u6, u7] of { _PRIM_ (u8 :: Int#) -> _#_ ltInt# [] [u8, 0#] }; _NO_DEFLT_ }; _NO_DEFLT_ } _N_,
- (<=) = _A_ 2 _U_ 11 _N_ _S_ "U(PPP)U(PPP)" {_A_ 4 _U_ 2221 _N_ _N_ _F_ _IF_ARGS_ 0 4 XXXC 3 \ (u0 :: Int#) (u1 :: Int#) (u2 :: ByteArray#) (u3 :: Integer) -> case u3 of { _ALG_ J# (u4 :: Int#) (u5 :: Int#) (u6 :: ByteArray#) -> case _#_ cmpInteger# [] [u0, u1, u2, u4, u5, u6] of { _PRIM_ (u7 :: Int#) -> _#_ leInt# [] [u7, 0#] }; _NO_DEFLT_ } _N_} _F_ _IF_ARGS_ 0 2 CC 4 \ (u0 :: Integer) (u1 :: Integer) -> case u0 of { _ALG_ J# (u2 :: Int#) (u3 :: Int#) (u4 :: ByteArray#) -> case u1 of { _ALG_ J# (u5 :: Int#) (u6 :: Int#) (u7 :: ByteArray#) -> case _#_ cmpInteger# [] [u2, u3, u4, u5, u6, u7] of { _PRIM_ (u8 :: Int#) -> _#_ leInt# [] [u8, 0#] }; _NO_DEFLT_ }; _NO_DEFLT_ } _N_,
- (>=) = _A_ 2 _U_ 11 _N_ _S_ "U(PPP)U(PPP)" {_A_ 4 _U_ 2221 _N_ _N_ _F_ _IF_ARGS_ 0 4 XXXC 3 \ (u0 :: Int#) (u1 :: Int#) (u2 :: ByteArray#) (u3 :: Integer) -> case u3 of { _ALG_ J# (u4 :: Int#) (u5 :: Int#) (u6 :: ByteArray#) -> case _#_ cmpInteger# [] [u0, u1, u2, u4, u5, u6] of { _PRIM_ (u7 :: Int#) -> _#_ geInt# [] [u7, 0#] }; _NO_DEFLT_ } _N_} _F_ _IF_ARGS_ 0 2 CC 4 \ (u0 :: Integer) (u1 :: Integer) -> case u0 of { _ALG_ J# (u2 :: Int#) (u3 :: Int#) (u4 :: ByteArray#) -> case u1 of { _ALG_ J# (u5 :: Int#) (u6 :: Int#) (u7 :: ByteArray#) -> case _#_ cmpInteger# [] [u2, u3, u4, u5, u6, u7] of { _PRIM_ (u8 :: Int#) -> _#_ geInt# [] [u8, 0#] }; _NO_DEFLT_ }; _NO_DEFLT_ } _N_,
- (>) = _A_ 2 _U_ 11 _N_ _S_ "U(PPP)U(PPP)" {_A_ 4 _U_ 2221 _N_ _N_ _F_ _IF_ARGS_ 0 4 XXXC 3 \ (u0 :: Int#) (u1 :: Int#) (u2 :: ByteArray#) (u3 :: Integer) -> case u3 of { _ALG_ J# (u4 :: Int#) (u5 :: Int#) (u6 :: ByteArray#) -> case _#_ cmpInteger# [] [u0, u1, u2, u4, u5, u6] of { _PRIM_ (u7 :: Int#) -> _#_ gtInt# [] [u7, 0#] }; _NO_DEFLT_ } _N_} _F_ _IF_ARGS_ 0 2 CC 4 \ (u0 :: Integer) (u1 :: Integer) -> case u0 of { _ALG_ J# (u2 :: Int#) (u3 :: Int#) (u4 :: ByteArray#) -> case u1 of { _ALG_ J# (u5 :: Int#) (u6 :: Int#) (u7 :: ByteArray#) -> case _#_ cmpInteger# [] [u2, u3, u4, u5, u6, u7] of { _PRIM_ (u8 :: Int#) -> _#_ gtInt# [] [u8, 0#] }; _NO_DEFLT_ }; _NO_DEFLT_ } _N_,
- max = _A_ 2 _U_ 11 _N_ _S_ "U(PPP)U(PPP)" {_A_ 4 _U_ 2221 _N_ _N_ _N_ _N_} _N_ _N_,
- min = _A_ 2 _U_ 11 _N_ _S_ "U(PPP)U(PPP)" {_A_ 4 _U_ 2221 _N_ _N_ _N_ _N_} _N_ _N_,
- _tagCmp = _A_ 2 _U_ 11 _N_ _S_ "U(PPP)U(PPP)" {_A_ 4 _U_ 2221 _N_ _N_ _N_ _N_} _N_ _N_ #-}
+ (<) = { _A_ 2 _U_ 11 _N_ _S_ "U(PPP)U(PPP)" {_A_ 4 _U_ 2221 _N_ _N_ _F_ _IF_ARGS_ 0 4 XXXC 3 \ (u0 :: Int#) (u1 :: Int#) (u2 :: ByteArray#) (u3 :: Integer) -> case u3 of { _ALG_ J# (u4 :: Int#) (u5 :: Int#) (u6 :: ByteArray#) -> case _#_ cmpInteger# [] [u0, u1, u2, u4, u5, u6] of { _PRIM_ (u7 :: Int#) -> _#_ ltInt# [] [u7, 0#] }; _NO_DEFLT_ } _N_} _F_ _IF_ARGS_ 0 2 CC 4 \ (u0 :: Integer) (u1 :: Integer) -> case u0 of { _ALG_ J# (u2 :: Int#) (u3 :: Int#) (u4 :: ByteArray#) -> case u1 of { _ALG_ J# (u5 :: Int#) (u6 :: Int#) (u7 :: ByteArray#) -> case _#_ cmpInteger# [] [u2, u3, u4, u5, u6, u7] of { _PRIM_ (u8 :: Int#) -> _#_ ltInt# [] [u8, 0#] }; _NO_DEFLT_ }; _NO_DEFLT_ } _N_ },
+ (<=) = { _A_ 2 _U_ 11 _N_ _S_ "U(PPP)U(PPP)" {_A_ 4 _U_ 2221 _N_ _N_ _F_ _IF_ARGS_ 0 4 XXXC 3 \ (u0 :: Int#) (u1 :: Int#) (u2 :: ByteArray#) (u3 :: Integer) -> case u3 of { _ALG_ J# (u4 :: Int#) (u5 :: Int#) (u6 :: ByteArray#) -> case _#_ cmpInteger# [] [u0, u1, u2, u4, u5, u6] of { _PRIM_ (u7 :: Int#) -> _#_ leInt# [] [u7, 0#] }; _NO_DEFLT_ } _N_} _F_ _IF_ARGS_ 0 2 CC 4 \ (u0 :: Integer) (u1 :: Integer) -> case u0 of { _ALG_ J# (u2 :: Int#) (u3 :: Int#) (u4 :: ByteArray#) -> case u1 of { _ALG_ J# (u5 :: Int#) (u6 :: Int#) (u7 :: ByteArray#) -> case _#_ cmpInteger# [] [u2, u3, u4, u5, u6, u7] of { _PRIM_ (u8 :: Int#) -> _#_ leInt# [] [u8, 0#] }; _NO_DEFLT_ }; _NO_DEFLT_ } _N_ },
+ (>=) = { _A_ 2 _U_ 11 _N_ _S_ "U(PPP)U(PPP)" {_A_ 4 _U_ 2221 _N_ _N_ _F_ _IF_ARGS_ 0 4 XXXC 3 \ (u0 :: Int#) (u1 :: Int#) (u2 :: ByteArray#) (u3 :: Integer) -> case u3 of { _ALG_ J# (u4 :: Int#) (u5 :: Int#) (u6 :: ByteArray#) -> case _#_ cmpInteger# [] [u0, u1, u2, u4, u5, u6] of { _PRIM_ (u7 :: Int#) -> _#_ geInt# [] [u7, 0#] }; _NO_DEFLT_ } _N_} _F_ _IF_ARGS_ 0 2 CC 4 \ (u0 :: Integer) (u1 :: Integer) -> case u0 of { _ALG_ J# (u2 :: Int#) (u3 :: Int#) (u4 :: ByteArray#) -> case u1 of { _ALG_ J# (u5 :: Int#) (u6 :: Int#) (u7 :: ByteArray#) -> case _#_ cmpInteger# [] [u2, u3, u4, u5, u6, u7] of { _PRIM_ (u8 :: Int#) -> _#_ geInt# [] [u8, 0#] }; _NO_DEFLT_ }; _NO_DEFLT_ } _N_ },
+ (>) = { _A_ 2 _U_ 11 _N_ _S_ "U(PPP)U(PPP)" {_A_ 4 _U_ 2221 _N_ _N_ _F_ _IF_ARGS_ 0 4 XXXC 3 \ (u0 :: Int#) (u1 :: Int#) (u2 :: ByteArray#) (u3 :: Integer) -> case u3 of { _ALG_ J# (u4 :: Int#) (u5 :: Int#) (u6 :: ByteArray#) -> case _#_ cmpInteger# [] [u0, u1, u2, u4, u5, u6] of { _PRIM_ (u7 :: Int#) -> _#_ gtInt# [] [u7, 0#] }; _NO_DEFLT_ } _N_} _F_ _IF_ARGS_ 0 2 CC 4 \ (u0 :: Integer) (u1 :: Integer) -> case u0 of { _ALG_ J# (u2 :: Int#) (u3 :: Int#) (u4 :: ByteArray#) -> case u1 of { _ALG_ J# (u5 :: Int#) (u6 :: Int#) (u7 :: ByteArray#) -> case _#_ cmpInteger# [] [u2, u3, u4, u5, u6, u7] of { _PRIM_ (u8 :: Int#) -> _#_ gtInt# [] [u8, 0#] }; _NO_DEFLT_ }; _NO_DEFLT_ } _N_ },
+ max = { _A_ 2 _U_ 11 _N_ _S_ "U(PPP)U(PPP)" {_A_ 4 _U_ 2221 _N_ _N_ _N_ _N_} _N_ _N_ },
+ min = { _A_ 2 _U_ 11 _N_ _S_ "U(PPP)U(PPP)" {_A_ 4 _U_ 2221 _N_ _N_ _N_ _N_} _N_ _N_ },
+ _tagCmp = { _A_ 2 _U_ 11 _N_ _S_ "U(PPP)U(PPP)" {_A_ 4 _U_ 2221 _N_ _N_ _N_ _N_} _N_ _N_ } #-}
instance Integral a => Ord (Ratio a)
{-# GHC_PRAGMA _M_ PreludeRatio {-dfun-} _A_ 2 _U_ 22 _N_ _N_ _N_ _N_ #-}
instance Ord (Ratio Integer)
{-# GHC_PRAGMA _M_ PreludeRatio {-dfun-} _A_ 0 _N_ _N_ _N_ _F_ _IF_ARGS_ 0 0 X 9 _!_ _TUP_8 [{{Eq (Ratio Integer)}}, (Ratio Integer -> Ratio Integer -> Bool), (Ratio Integer -> Ratio Integer -> Bool), (Ratio Integer -> Ratio Integer -> Bool), (Ratio Integer -> Ratio Integer -> Bool), (Ratio Integer -> Ratio Integer -> Ratio Integer), (Ratio Integer -> Ratio Integer -> Ratio Integer), (Ratio Integer -> Ratio Integer -> _CMP_TAG)] [_DFUN_ Eq (Ratio Integer), _CONSTM_ Ord (<) (Ratio Integer), _CONSTM_ Ord (<=) (Ratio Integer), _CONSTM_ Ord (>=) (Ratio Integer), _CONSTM_ Ord (>) (Ratio Integer), _CONSTM_ Ord max (Ratio Integer), _CONSTM_ Ord min (Ratio Integer), _CONSTM_ Ord _tagCmp (Ratio Integer)] _N_
- (<) = _A_ 2 _U_ 11 _N_ _S_ "U(U(PPP)U(PPP))U(U(PPP)U(PPP))" {_A_ 5 _U_ 22221 _N_ _N_ _N_ _N_} _N_ _N_,
- (<=) = _A_ 2 _U_ 11 _N_ _S_ "U(U(PPP)U(PPP))U(U(PPP)U(PPP))" {_A_ 5 _U_ 22221 _N_ _N_ _N_ _N_} _N_ _N_,
- (>=) = _A_ 2 _U_ 11 _N_ _S_ "U(U(PPP)U(PPP))U(U(PPP)U(PPP))" {_A_ 5 _U_ 22221 _N_ _N_ _N_ _N_} _N_ _N_,
- (>) = _A_ 2 _U_ 11 _N_ _S_ "U(U(PPP)U(PPP))U(U(PPP)U(PPP))" {_A_ 5 _U_ 22221 _N_ _N_ _N_ _N_} _N_ _N_,
- max = _A_ 2 _U_ 12 _N_ _S_ "U(U(PPP)U(PPP))U(U(PPP)U(PPP))" {_A_ 5 _U_ 22222 _N_ _N_ _N_ _N_} _N_ _N_,
- min = _A_ 2 _U_ 12 _N_ _S_ "U(U(PPP)U(PPP))U(U(PPP)U(PPP))" {_A_ 5 _U_ 22222 _N_ _N_ _N_ _N_} _N_ _N_,
- _tagCmp = _A_ 2 _U_ 11 _N_ _S_ "U(U(PPP)U(PPP))U(U(PPP)U(PPP))" {_A_ 5 _U_ 22221 _N_ _N_ _N_ _N_} _N_ _N_ #-}
+ (<) = { _A_ 2 _U_ 11 _N_ _S_ "U(U(PPP)U(PPP))U(U(PPP)U(PPP))" {_A_ 5 _U_ 22221 _N_ _N_ _N_ _N_} _N_ _N_ },
+ (<=) = { _A_ 2 _U_ 11 _N_ _S_ "U(U(PPP)U(PPP))U(U(PPP)U(PPP))" {_A_ 5 _U_ 22221 _N_ _N_ _N_ _N_} _N_ _N_ },
+ (>=) = { _A_ 2 _U_ 11 _N_ _S_ "U(U(PPP)U(PPP))U(U(PPP)U(PPP))" {_A_ 5 _U_ 22221 _N_ _N_ _N_ _N_} _N_ _N_ },
+ (>) = { _A_ 2 _U_ 11 _N_ _S_ "U(U(PPP)U(PPP))U(U(PPP)U(PPP))" {_A_ 5 _U_ 22221 _N_ _N_ _N_ _N_} _N_ _N_ },
+ max = { _A_ 2 _U_ 12 _N_ _S_ "U(U(PPP)U(PPP))U(U(PPP)U(PPP))" {_A_ 5 _U_ 22222 _N_ _N_ _N_ _N_} _N_ _N_ },
+ min = { _A_ 2 _U_ 12 _N_ _S_ "U(U(PPP)U(PPP))U(U(PPP)U(PPP))" {_A_ 5 _U_ 22222 _N_ _N_ _N_ _N_} _N_ _N_ },
+ _tagCmp = { _A_ 2 _U_ 11 _N_ _S_ "U(U(PPP)U(PPP))U(U(PPP)U(PPP))" {_A_ 5 _U_ 22221 _N_ _N_ _N_ _N_} _N_ _N_ } #-}
instance Ord a => Ord [a]
{-# GHC_PRAGMA _M_ PreludeBuiltin {-dfun-} _A_ 2 _U_ 12 _N_ _N_ _N_ _N_ #-}
+instance Ord [Bool]
+ {-# GHC_PRAGMA _M_ PreludeBuiltin {-dfun-} _A_ 0 _N_ _N_ _N_ _F_ _IF_ARGS_ 0 0 X 9 _!_ _TUP_8 [{{Eq [Bool]}}, ([Bool] -> [Bool] -> Bool), ([Bool] -> [Bool] -> Bool), ([Bool] -> [Bool] -> Bool), ([Bool] -> [Bool] -> Bool), ([Bool] -> [Bool] -> [Bool]), ([Bool] -> [Bool] -> [Bool]), ([Bool] -> [Bool] -> _CMP_TAG)] [_DFUN_ Eq ([Bool]), _CONSTM_ Ord (<) ([Bool]), _CONSTM_ Ord (<=) ([Bool]), _CONSTM_ Ord (>=) ([Bool]), _CONSTM_ Ord (>) ([Bool]), _CONSTM_ Ord max ([Bool]), _CONSTM_ Ord min ([Bool]), _CONSTM_ Ord _tagCmp ([Bool])] _N_
+ (<) = { _A_ 2 _U_ 11 _N_ _S_ "SS" _N_ _N_ },
+ (<=) = { _A_ 2 _U_ 11 _N_ _S_ "SS" _N_ _N_ },
+ (>=) = { _A_ 2 _U_ 11 _N_ _S_ "SS" _N_ _N_ },
+ (>) = { _A_ 2 _U_ 11 _N_ _S_ "SS" _N_ _N_ },
+ max = { _A_ 2 _U_ 22 _N_ _S_ "SS" _N_ _N_ },
+ min = { _A_ 2 _U_ 22 _N_ _S_ "SS" _N_ _N_ },
+ _tagCmp = { _A_ 2 _U_ 11 _N_ _S_ "SS" _N_ _N_ } #-}
instance Ord [Char]
{-# GHC_PRAGMA _M_ PreludeBuiltin {-dfun-} _A_ 0 _N_ _N_ _N_ _F_ _IF_ARGS_ 0 0 X 9 _!_ _TUP_8 [{{Eq [Char]}}, ([Char] -> [Char] -> Bool), ([Char] -> [Char] -> Bool), ([Char] -> [Char] -> Bool), ([Char] -> [Char] -> Bool), ([Char] -> [Char] -> [Char]), ([Char] -> [Char] -> [Char]), ([Char] -> [Char] -> _CMP_TAG)] [_DFUN_ Eq ([Char]), _CONSTM_ Ord (<) ([Char]), _CONSTM_ Ord (<=) ([Char]), _CONSTM_ Ord (>=) ([Char]), _CONSTM_ Ord (>) ([Char]), _CONSTM_ Ord max ([Char]), _CONSTM_ Ord min ([Char]), _CONSTM_ Ord _tagCmp ([Char])] _N_
- (<) = _A_ 2 _U_ 11 _N_ _S_ "SS" _N_ _N_,
- (<=) = _A_ 2 _U_ 11 _N_ _S_ "SS" _N_ _N_,
- (>=) = _A_ 2 _U_ 11 _N_ _S_ "SS" _N_ _N_,
- (>) = _A_ 2 _U_ 11 _N_ _S_ "SS" _N_ _N_,
- max = _A_ 2 _U_ 22 _N_ _S_ "SS" _N_ _N_,
- min = _A_ 2 _U_ 22 _N_ _S_ "SS" _N_ _N_,
- _tagCmp = _A_ 2 _U_ 11 _N_ _S_ "SS" _N_ _N_ #-}
+ (<) = { _A_ 2 _U_ 11 _N_ _S_ "SS" _N_ _N_ },
+ (<=) = { _A_ 2 _U_ 11 _N_ _S_ "SS" _N_ _N_ },
+ (>=) = { _A_ 2 _U_ 11 _N_ _S_ "SS" _N_ _N_ },
+ (>) = { _A_ 2 _U_ 11 _N_ _S_ "SS" _N_ _N_ },
+ max = { _A_ 2 _U_ 22 _N_ _S_ "SS" _N_ _N_ },
+ min = { _A_ 2 _U_ 22 _N_ _S_ "SS" _N_ _N_ },
+ _tagCmp = { _A_ 2 _U_ 11 _N_ _S_ "SS" _N_ _N_ } #-}
+instance Ord [Double]
+ {-# GHC_PRAGMA _M_ PreludeBuiltin {-dfun-} _A_ 0 _N_ _N_ _N_ _F_ _IF_ARGS_ 0 0 X 9 _!_ _TUP_8 [{{Eq [Double]}}, ([Double] -> [Double] -> Bool), ([Double] -> [Double] -> Bool), ([Double] -> [Double] -> Bool), ([Double] -> [Double] -> Bool), ([Double] -> [Double] -> [Double]), ([Double] -> [Double] -> [Double]), ([Double] -> [Double] -> _CMP_TAG)] [_DFUN_ Eq ([Double]), _CONSTM_ Ord (<) ([Double]), _CONSTM_ Ord (<=) ([Double]), _CONSTM_ Ord (>=) ([Double]), _CONSTM_ Ord (>) ([Double]), _CONSTM_ Ord max ([Double]), _CONSTM_ Ord min ([Double]), _CONSTM_ Ord _tagCmp ([Double])] _N_
+ (<) = { _A_ 2 _U_ 11 _N_ _S_ "SS" _N_ _N_ },
+ (<=) = { _A_ 2 _U_ 11 _N_ _S_ "SS" _N_ _N_ },
+ (>=) = { _A_ 2 _U_ 11 _N_ _S_ "SS" _N_ _N_ },
+ (>) = { _A_ 2 _U_ 11 _N_ _S_ "SS" _N_ _N_ },
+ max = { _A_ 2 _U_ 22 _N_ _S_ "SS" _N_ _N_ },
+ min = { _A_ 2 _U_ 22 _N_ _S_ "SS" _N_ _N_ },
+ _tagCmp = { _A_ 2 _U_ 11 _N_ _S_ "SS" _N_ _N_ } #-}
instance Ord [Int]
{-# GHC_PRAGMA _M_ PreludeBuiltin {-dfun-} _A_ 0 _N_ _N_ _N_ _F_ _IF_ARGS_ 0 0 X 9 _!_ _TUP_8 [{{Eq [Int]}}, ([Int] -> [Int] -> Bool), ([Int] -> [Int] -> Bool), ([Int] -> [Int] -> Bool), ([Int] -> [Int] -> Bool), ([Int] -> [Int] -> [Int]), ([Int] -> [Int] -> [Int]), ([Int] -> [Int] -> _CMP_TAG)] [_DFUN_ Eq ([Int]), _CONSTM_ Ord (<) ([Int]), _CONSTM_ Ord (<=) ([Int]), _CONSTM_ Ord (>=) ([Int]), _CONSTM_ Ord (>) ([Int]), _CONSTM_ Ord max ([Int]), _CONSTM_ Ord min ([Int]), _CONSTM_ Ord _tagCmp ([Int])] _N_
- (<) = _A_ 2 _U_ 11 _N_ _S_ "SS" _N_ _N_,
- (<=) = _A_ 2 _U_ 11 _N_ _S_ "SS" _N_ _N_,
- (>=) = _A_ 2 _U_ 11 _N_ _S_ "SS" _N_ _N_,
- (>) = _A_ 2 _U_ 11 _N_ _S_ "SS" _N_ _N_,
- max = _A_ 2 _U_ 22 _N_ _S_ "SS" _N_ _N_,
- min = _A_ 2 _U_ 22 _N_ _S_ "SS" _N_ _N_,
- _tagCmp = _A_ 2 _U_ 11 _N_ _S_ "SS" _N_ _N_ #-}
+ (<) = { _A_ 2 _U_ 11 _N_ _S_ "SS" _N_ _N_ },
+ (<=) = { _A_ 2 _U_ 11 _N_ _S_ "SS" _N_ _N_ },
+ (>=) = { _A_ 2 _U_ 11 _N_ _S_ "SS" _N_ _N_ },
+ (>) = { _A_ 2 _U_ 11 _N_ _S_ "SS" _N_ _N_ },
+ max = { _A_ 2 _U_ 22 _N_ _S_ "SS" _N_ _N_ },
+ min = { _A_ 2 _U_ 22 _N_ _S_ "SS" _N_ _N_ },
+ _tagCmp = { _A_ 2 _U_ 11 _N_ _S_ "SS" _N_ _N_ } #-}
+instance Ord [Integer]
+ {-# GHC_PRAGMA _M_ PreludeBuiltin {-dfun-} _A_ 0 _N_ _N_ _N_ _F_ _IF_ARGS_ 0 0 X 9 _!_ _TUP_8 [{{Eq [Integer]}}, ([Integer] -> [Integer] -> Bool), ([Integer] -> [Integer] -> Bool), ([Integer] -> [Integer] -> Bool), ([Integer] -> [Integer] -> Bool), ([Integer] -> [Integer] -> [Integer]), ([Integer] -> [Integer] -> [Integer]), ([Integer] -> [Integer] -> _CMP_TAG)] [_DFUN_ Eq ([Integer]), _CONSTM_ Ord (<) ([Integer]), _CONSTM_ Ord (<=) ([Integer]), _CONSTM_ Ord (>=) ([Integer]), _CONSTM_ Ord (>) ([Integer]), _CONSTM_ Ord max ([Integer]), _CONSTM_ Ord min ([Integer]), _CONSTM_ Ord _tagCmp ([Integer])] _N_
+ (<) = { _A_ 2 _U_ 11 _N_ _S_ "SS" _N_ _N_ },
+ (<=) = { _A_ 2 _U_ 11 _N_ _S_ "SS" _N_ _N_ },
+ (>=) = { _A_ 2 _U_ 11 _N_ _S_ "SS" _N_ _N_ },
+ (>) = { _A_ 2 _U_ 11 _N_ _S_ "SS" _N_ _N_ },
+ max = { _A_ 2 _U_ 22 _N_ _S_ "SS" _N_ _N_ },
+ min = { _A_ 2 _U_ 22 _N_ _S_ "SS" _N_ _N_ },
+ _tagCmp = { _A_ 2 _U_ 11 _N_ _S_ "SS" _N_ _N_ } #-}
+instance Ord [[Char]]
+ {-# GHC_PRAGMA _M_ PreludeBuiltin {-dfun-} _A_ 0 _N_ _N_ _N_ _F_ _IF_ARGS_ 0 0 X 9 _!_ _TUP_8 [{{Eq [[Char]]}}, ([[Char]] -> [[Char]] -> Bool), ([[Char]] -> [[Char]] -> Bool), ([[Char]] -> [[Char]] -> Bool), ([[Char]] -> [[Char]] -> Bool), ([[Char]] -> [[Char]] -> [[Char]]), ([[Char]] -> [[Char]] -> [[Char]]), ([[Char]] -> [[Char]] -> _CMP_TAG)] [_DFUN_ Eq ([[Char]]), _CONSTM_ Ord (<) ([[Char]]), _CONSTM_ Ord (<=) ([[Char]]), _CONSTM_ Ord (>=) ([[Char]]), _CONSTM_ Ord (>) ([[Char]]), _CONSTM_ Ord max ([[Char]]), _CONSTM_ Ord min ([[Char]]), _CONSTM_ Ord _tagCmp ([[Char]])] _N_
+ (<) = { _A_ 2 _U_ 11 _N_ _S_ "SS" _N_ _N_ },
+ (<=) = { _A_ 2 _U_ 11 _N_ _S_ "SS" _N_ _N_ },
+ (>=) = { _A_ 2 _U_ 11 _N_ _S_ "SS" _N_ _N_ },
+ (>) = { _A_ 2 _U_ 11 _N_ _S_ "SS" _N_ _N_ },
+ max = { _A_ 2 _U_ 22 _N_ _S_ "SS" _N_ _N_ },
+ min = { _A_ 2 _U_ 22 _N_ _S_ "SS" _N_ _N_ },
+ _tagCmp = { _A_ 2 _U_ 11 _N_ _S_ "SS" _N_ _N_ } #-}
+instance Ord [[Int]]
+ {-# GHC_PRAGMA _M_ PreludeBuiltin {-dfun-} _A_ 0 _N_ _N_ _N_ _F_ _IF_ARGS_ 0 0 X 9 _!_ _TUP_8 [{{Eq [[Int]]}}, ([[Int]] -> [[Int]] -> Bool), ([[Int]] -> [[Int]] -> Bool), ([[Int]] -> [[Int]] -> Bool), ([[Int]] -> [[Int]] -> Bool), ([[Int]] -> [[Int]] -> [[Int]]), ([[Int]] -> [[Int]] -> [[Int]]), ([[Int]] -> [[Int]] -> _CMP_TAG)] [_DFUN_ Eq ([[Int]]), _CONSTM_ Ord (<) ([[Int]]), _CONSTM_ Ord (<=) ([[Int]]), _CONSTM_ Ord (>=) ([[Int]]), _CONSTM_ Ord (>) ([[Int]]), _CONSTM_ Ord max ([[Int]]), _CONSTM_ Ord min ([[Int]]), _CONSTM_ Ord _tagCmp ([[Int]])] _N_
+ (<) = { _A_ 2 _U_ 11 _N_ _S_ "SS" _N_ _N_ },
+ (<=) = { _A_ 2 _U_ 11 _N_ _S_ "SS" _N_ _N_ },
+ (>=) = { _A_ 2 _U_ 11 _N_ _S_ "SS" _N_ _N_ },
+ (>) = { _A_ 2 _U_ 11 _N_ _S_ "SS" _N_ _N_ },
+ max = { _A_ 2 _U_ 22 _N_ _S_ "SS" _N_ _N_ },
+ min = { _A_ 2 _U_ 22 _N_ _S_ "SS" _N_ _N_ },
+ _tagCmp = { _A_ 2 _U_ 11 _N_ _S_ "SS" _N_ _N_ } #-}
instance Ord _Addr
{-# GHC_PRAGMA _M_ PreludeCore {-dfun-} _A_ 0 _N_ _N_ _N_ _F_ _IF_ARGS_ 0 0 X 9 _!_ _TUP_8 [{{Eq _Addr}}, (_Addr -> _Addr -> Bool), (_Addr -> _Addr -> Bool), (_Addr -> _Addr -> Bool), (_Addr -> _Addr -> Bool), (_Addr -> _Addr -> _Addr), (_Addr -> _Addr -> _Addr), (_Addr -> _Addr -> _CMP_TAG)] [_DFUN_ Eq (_Addr), _CONSTM_ Ord (<) (_Addr), _CONSTM_ Ord (<=) (_Addr), _CONSTM_ Ord (>=) (_Addr), _CONSTM_ Ord (>) (_Addr), _CONSTM_ Ord max (_Addr), _CONSTM_ Ord min (_Addr), _CONSTM_ Ord _tagCmp (_Addr)] _N_
- (<) = _A_ 2 _U_ 11 _N_ _S_ "U(P)U(P)" {_A_ 2 _U_ 22 _N_ _N_ _F_ _IF_ARGS_ 0 2 XX 1 \ (u0 :: Addr#) (u1 :: Addr#) -> _#_ ltAddr# [] [u0, u1] _N_} _F_ _IF_ARGS_ 0 2 CC 3 \ (u0 :: _Addr) (u1 :: _Addr) -> case u0 of { _ALG_ A# (u2 :: Addr#) -> case u1 of { _ALG_ A# (u3 :: Addr#) -> _#_ ltAddr# [] [u2, u3]; _NO_DEFLT_ }; _NO_DEFLT_ } _N_,
- (<=) = _A_ 2 _U_ 11 _N_ _S_ "U(P)U(P)" {_A_ 2 _U_ 22 _N_ _N_ _F_ _IF_ARGS_ 0 2 XX 1 \ (u0 :: Addr#) (u1 :: Addr#) -> _#_ leAddr# [] [u0, u1] _N_} _F_ _IF_ARGS_ 0 2 CC 3 \ (u0 :: _Addr) (u1 :: _Addr) -> case u0 of { _ALG_ A# (u2 :: Addr#) -> case u1 of { _ALG_ A# (u3 :: Addr#) -> _#_ leAddr# [] [u2, u3]; _NO_DEFLT_ }; _NO_DEFLT_ } _N_,
- (>=) = _A_ 2 _U_ 11 _N_ _S_ "U(P)U(P)" {_A_ 2 _U_ 22 _N_ _N_ _F_ _IF_ARGS_ 0 2 XX 1 \ (u0 :: Addr#) (u1 :: Addr#) -> _#_ geAddr# [] [u0, u1] _N_} _F_ _IF_ARGS_ 0 2 CC 3 \ (u0 :: _Addr) (u1 :: _Addr) -> case u0 of { _ALG_ A# (u2 :: Addr#) -> case u1 of { _ALG_ A# (u3 :: Addr#) -> _#_ geAddr# [] [u2, u3]; _NO_DEFLT_ }; _NO_DEFLT_ } _N_,
- (>) = _A_ 2 _U_ 11 _N_ _S_ "U(P)U(P)" {_A_ 2 _U_ 22 _N_ _N_ _F_ _IF_ARGS_ 0 2 XX 1 \ (u0 :: Addr#) (u1 :: Addr#) -> _#_ gtAddr# [] [u0, u1] _N_} _F_ _IF_ARGS_ 0 2 CC 3 \ (u0 :: _Addr) (u1 :: _Addr) -> case u0 of { _ALG_ A# (u2 :: Addr#) -> case u1 of { _ALG_ A# (u3 :: Addr#) -> _#_ gtAddr# [] [u2, u3]; _NO_DEFLT_ }; _NO_DEFLT_ } _N_,
- max = _A_ 2 _U_ 11 _N_ _S_ "U(P)U(P)" {_A_ 2 _U_ 22 _N_ _N_ _N_ _N_} _N_ _N_,
- min = _A_ 2 _U_ 11 _N_ _S_ "U(P)U(P)" {_A_ 2 _U_ 22 _N_ _N_ _N_ _N_} _N_ _N_,
- _tagCmp = _A_ 2 _U_ 11 _N_ _S_ "U(P)U(P)" {_A_ 2 _U_ 22 _N_ _N_ _N_ _N_} _N_ _N_ #-}
+ (<) = { _A_ 2 _U_ 11 _N_ _S_ "U(P)U(P)" {_A_ 2 _U_ 22 _N_ _N_ _F_ _IF_ARGS_ 0 2 XX 1 \ (u0 :: Addr#) (u1 :: Addr#) -> _#_ ltAddr# [] [u0, u1] _N_} _F_ _IF_ARGS_ 0 2 CC 3 \ (u0 :: _Addr) (u1 :: _Addr) -> case u0 of { _ALG_ A# (u2 :: Addr#) -> case u1 of { _ALG_ A# (u3 :: Addr#) -> _#_ ltAddr# [] [u2, u3]; _NO_DEFLT_ }; _NO_DEFLT_ } _N_ },
+ (<=) = { _A_ 2 _U_ 11 _N_ _S_ "U(P)U(P)" {_A_ 2 _U_ 22 _N_ _N_ _F_ _IF_ARGS_ 0 2 XX 1 \ (u0 :: Addr#) (u1 :: Addr#) -> _#_ leAddr# [] [u0, u1] _N_} _F_ _IF_ARGS_ 0 2 CC 3 \ (u0 :: _Addr) (u1 :: _Addr) -> case u0 of { _ALG_ A# (u2 :: Addr#) -> case u1 of { _ALG_ A# (u3 :: Addr#) -> _#_ leAddr# [] [u2, u3]; _NO_DEFLT_ }; _NO_DEFLT_ } _N_ },
+ (>=) = { _A_ 2 _U_ 11 _N_ _S_ "U(P)U(P)" {_A_ 2 _U_ 22 _N_ _N_ _F_ _IF_ARGS_ 0 2 XX 1 \ (u0 :: Addr#) (u1 :: Addr#) -> _#_ geAddr# [] [u0, u1] _N_} _F_ _IF_ARGS_ 0 2 CC 3 \ (u0 :: _Addr) (u1 :: _Addr) -> case u0 of { _ALG_ A# (u2 :: Addr#) -> case u1 of { _ALG_ A# (u3 :: Addr#) -> _#_ geAddr# [] [u2, u3]; _NO_DEFLT_ }; _NO_DEFLT_ } _N_ },
+ (>) = { _A_ 2 _U_ 11 _N_ _S_ "U(P)U(P)" {_A_ 2 _U_ 22 _N_ _N_ _F_ _IF_ARGS_ 0 2 XX 1 \ (u0 :: Addr#) (u1 :: Addr#) -> _#_ gtAddr# [] [u0, u1] _N_} _F_ _IF_ARGS_ 0 2 CC 3 \ (u0 :: _Addr) (u1 :: _Addr) -> case u0 of { _ALG_ A# (u2 :: Addr#) -> case u1 of { _ALG_ A# (u3 :: Addr#) -> _#_ gtAddr# [] [u2, u3]; _NO_DEFLT_ }; _NO_DEFLT_ } _N_ },
+ max = { _A_ 2 _U_ 11 _N_ _S_ "U(P)U(P)" {_A_ 2 _U_ 22 _N_ _N_ _N_ _N_} _N_ _N_ },
+ min = { _A_ 2 _U_ 11 _N_ _S_ "U(P)U(P)" {_A_ 2 _U_ 22 _N_ _N_ _N_ _N_} _N_ _N_ },
+ _tagCmp = { _A_ 2 _U_ 11 _N_ _S_ "U(P)U(P)" {_A_ 2 _U_ 22 _N_ _N_ _N_ _N_} _N_ _N_ } #-}
instance Ord _PackedString
{-# GHC_PRAGMA _M_ PreludePS {-dfun-} _A_ 0 _N_ _N_ _N_ _F_ _IF_ARGS_ 0 0 X 9 _!_ _TUP_8 [{{Eq _PackedString}}, (_PackedString -> _PackedString -> Bool), (_PackedString -> _PackedString -> Bool), (_PackedString -> _PackedString -> Bool), (_PackedString -> _PackedString -> Bool), (_PackedString -> _PackedString -> _PackedString), (_PackedString -> _PackedString -> _PackedString), (_PackedString -> _PackedString -> _CMP_TAG)] [_DFUN_ Eq (_PackedString), _CONSTM_ Ord (<) (_PackedString), _CONSTM_ Ord (<=) (_PackedString), _CONSTM_ Ord (>=) (_PackedString), _CONSTM_ Ord (>) (_PackedString), _CONSTM_ Ord max (_PackedString), _CONSTM_ Ord min (_PackedString), _CONSTM_ Ord _tagCmp (_PackedString)] _N_
- (<) = _A_ 2 _U_ 22 _N_ _S_ "SS" _N_ _N_,
- (<=) = _A_ 2 _U_ 22 _N_ _S_ "SS" _N_ _N_,
- (>=) = _A_ 2 _U_ 22 _N_ _S_ "SS" _N_ _N_,
- (>) = _A_ 2 _U_ 22 _N_ _S_ "SS" _N_ _N_,
- max = _A_ 2 _U_ 22 _N_ _N_ _N_ _N_,
- min = _A_ 2 _U_ 22 _N_ _N_ _N_ _N_,
- _tagCmp = _A_ 2 _U_ 22 _N_ _S_ "SS" _N_ _N_ #-}
+ (<) = { _A_ 2 _U_ 22 _N_ _S_ "SS" _N_ _N_ },
+ (<=) = { _A_ 2 _U_ 22 _N_ _S_ "SS" _N_ _N_ },
+ (>=) = { _A_ 2 _U_ 22 _N_ _S_ "SS" _N_ _N_ },
+ (>) = { _A_ 2 _U_ 22 _N_ _S_ "SS" _N_ _N_ },
+ max = { _A_ 2 _U_ 22 _N_ _S_ "SS" _N_ _N_ },
+ min = { _A_ 2 _U_ 22 _N_ _S_ "SS" _N_ _N_ },
+ _tagCmp = { _A_ 2 _U_ 22 _N_ _S_ "SS" _N_ _N_ } #-}
instance Ord _Word
{-# GHC_PRAGMA _M_ PreludeCore {-dfun-} _A_ 0 _N_ _N_ _N_ _F_ _IF_ARGS_ 0 0 X 9 _!_ _TUP_8 [{{Eq _Word}}, (_Word -> _Word -> Bool), (_Word -> _Word -> Bool), (_Word -> _Word -> Bool), (_Word -> _Word -> Bool), (_Word -> _Word -> _Word), (_Word -> _Word -> _Word), (_Word -> _Word -> _CMP_TAG)] [_DFUN_ Eq (_Word), _CONSTM_ Ord (<) (_Word), _CONSTM_ Ord (<=) (_Word), _CONSTM_ Ord (>=) (_Word), _CONSTM_ Ord (>) (_Word), _CONSTM_ Ord max (_Word), _CONSTM_ Ord min (_Word), _CONSTM_ Ord _tagCmp (_Word)] _N_
- (<) = _A_ 2 _U_ 11 _N_ _S_ "U(P)U(P)" {_A_ 2 _U_ 22 _N_ _N_ _F_ _IF_ARGS_ 0 2 XX 1 \ (u0 :: Word#) (u1 :: Word#) -> _#_ ltWord# [] [u0, u1] _N_} _F_ _IF_ARGS_ 0 2 CC 3 \ (u0 :: _Word) (u1 :: _Word) -> case u0 of { _ALG_ W# (u2 :: Word#) -> case u1 of { _ALG_ W# (u3 :: Word#) -> _#_ ltWord# [] [u2, u3]; _NO_DEFLT_ }; _NO_DEFLT_ } _N_,
- (<=) = _A_ 2 _U_ 11 _N_ _S_ "U(P)U(P)" {_A_ 2 _U_ 22 _N_ _N_ _F_ _IF_ARGS_ 0 2 XX 1 \ (u0 :: Word#) (u1 :: Word#) -> _#_ leWord# [] [u0, u1] _N_} _F_ _IF_ARGS_ 0 2 CC 3 \ (u0 :: _Word) (u1 :: _Word) -> case u0 of { _ALG_ W# (u2 :: Word#) -> case u1 of { _ALG_ W# (u3 :: Word#) -> _#_ leWord# [] [u2, u3]; _NO_DEFLT_ }; _NO_DEFLT_ } _N_,
- (>=) = _A_ 2 _U_ 11 _N_ _S_ "U(P)U(P)" {_A_ 2 _U_ 22 _N_ _N_ _F_ _IF_ARGS_ 0 2 XX 1 \ (u0 :: Word#) (u1 :: Word#) -> _#_ geWord# [] [u0, u1] _N_} _F_ _IF_ARGS_ 0 2 CC 3 \ (u0 :: _Word) (u1 :: _Word) -> case u0 of { _ALG_ W# (u2 :: Word#) -> case u1 of { _ALG_ W# (u3 :: Word#) -> _#_ geWord# [] [u2, u3]; _NO_DEFLT_ }; _NO_DEFLT_ } _N_,
- (>) = _A_ 2 _U_ 11 _N_ _S_ "U(P)U(P)" {_A_ 2 _U_ 22 _N_ _N_ _F_ _IF_ARGS_ 0 2 XX 1 \ (u0 :: Word#) (u1 :: Word#) -> _#_ gtWord# [] [u0, u1] _N_} _F_ _IF_ARGS_ 0 2 CC 3 \ (u0 :: _Word) (u1 :: _Word) -> case u0 of { _ALG_ W# (u2 :: Word#) -> case u1 of { _ALG_ W# (u3 :: Word#) -> _#_ gtWord# [] [u2, u3]; _NO_DEFLT_ }; _NO_DEFLT_ } _N_,
- max = _A_ 2 _U_ 11 _N_ _S_ "U(P)U(P)" {_A_ 2 _U_ 22 _N_ _N_ _N_ _N_} _N_ _N_,
- min = _A_ 2 _U_ 11 _N_ _S_ "U(P)U(P)" {_A_ 2 _U_ 22 _N_ _N_ _N_ _N_} _N_ _N_,
- _tagCmp = _A_ 2 _U_ 11 _N_ _S_ "U(P)U(P)" {_A_ 2 _U_ 22 _N_ _N_ _N_ _N_} _N_ _N_ #-}
+ (<) = { _A_ 2 _U_ 11 _N_ _S_ "U(P)U(P)" {_A_ 2 _U_ 22 _N_ _N_ _F_ _IF_ARGS_ 0 2 XX 1 \ (u0 :: Word#) (u1 :: Word#) -> _#_ ltWord# [] [u0, u1] _N_} _F_ _IF_ARGS_ 0 2 CC 3 \ (u0 :: _Word) (u1 :: _Word) -> case u0 of { _ALG_ W# (u2 :: Word#) -> case u1 of { _ALG_ W# (u3 :: Word#) -> _#_ ltWord# [] [u2, u3]; _NO_DEFLT_ }; _NO_DEFLT_ } _N_ },
+ (<=) = { _A_ 2 _U_ 11 _N_ _S_ "U(P)U(P)" {_A_ 2 _U_ 22 _N_ _N_ _F_ _IF_ARGS_ 0 2 XX 1 \ (u0 :: Word#) (u1 :: Word#) -> _#_ leWord# [] [u0, u1] _N_} _F_ _IF_ARGS_ 0 2 CC 3 \ (u0 :: _Word) (u1 :: _Word) -> case u0 of { _ALG_ W# (u2 :: Word#) -> case u1 of { _ALG_ W# (u3 :: Word#) -> _#_ leWord# [] [u2, u3]; _NO_DEFLT_ }; _NO_DEFLT_ } _N_ },
+ (>=) = { _A_ 2 _U_ 11 _N_ _S_ "U(P)U(P)" {_A_ 2 _U_ 22 _N_ _N_ _F_ _IF_ARGS_ 0 2 XX 1 \ (u0 :: Word#) (u1 :: Word#) -> _#_ geWord# [] [u0, u1] _N_} _F_ _IF_ARGS_ 0 2 CC 3 \ (u0 :: _Word) (u1 :: _Word) -> case u0 of { _ALG_ W# (u2 :: Word#) -> case u1 of { _ALG_ W# (u3 :: Word#) -> _#_ geWord# [] [u2, u3]; _NO_DEFLT_ }; _NO_DEFLT_ } _N_ },
+ (>) = { _A_ 2 _U_ 11 _N_ _S_ "U(P)U(P)" {_A_ 2 _U_ 22 _N_ _N_ _F_ _IF_ARGS_ 0 2 XX 1 \ (u0 :: Word#) (u1 :: Word#) -> _#_ gtWord# [] [u0, u1] _N_} _F_ _IF_ARGS_ 0 2 CC 3 \ (u0 :: _Word) (u1 :: _Word) -> case u0 of { _ALG_ W# (u2 :: Word#) -> case u1 of { _ALG_ W# (u3 :: Word#) -> _#_ gtWord# [] [u2, u3]; _NO_DEFLT_ }; _NO_DEFLT_ } _N_ },
+ max = { _A_ 2 _U_ 11 _N_ _S_ "U(P)U(P)" {_A_ 2 _U_ 22 _N_ _N_ _N_ _N_} _N_ _N_ },
+ min = { _A_ 2 _U_ 11 _N_ _S_ "U(P)U(P)" {_A_ 2 _U_ 22 _N_ _N_ _N_ _N_} _N_ _N_ },
+ _tagCmp = { _A_ 2 _U_ 11 _N_ _S_ "U(P)U(P)" {_A_ 2 _U_ 22 _N_ _N_ _N_ _N_} _N_ _N_ } #-}
instance Real Double
{-# GHC_PRAGMA _M_ PreludeCore {-dfun-} _A_ 0 _N_ _N_ _N_ _F_ _IF_ARGS_ 0 0 X 4 _!_ _TUP_3 [{{Num Double}}, {{Enum Double}}, (Double -> Ratio Integer)] [_DFUN_ Num (Double), _DFUN_ Enum (Double), _CONSTM_ Real toRational (Double)] _N_
- toRational = _A_ 1 _U_ 1 _N_ _S_ "U(P)" {_A_ 1 _U_ 2 _N_ _N_ _N_ _N_} _N_ _N_ #-}
+ toRational = { _A_ 1 _U_ 1 _N_ _S_ "U(P)" {_A_ 1 _U_ 2 _N_ _N_ _N_ _N_} _N_ _N_ } #-}
instance Real Float
{-# GHC_PRAGMA _M_ PreludeCore {-dfun-} _A_ 0 _N_ _N_ _N_ _F_ _IF_ARGS_ 0 0 X 4 _!_ _TUP_3 [{{Num Float}}, {{Enum Float}}, (Float -> Ratio Integer)] [_DFUN_ Num (Float), _DFUN_ Enum (Float), _CONSTM_ Real toRational (Float)] _N_
- toRational = _A_ 1 _U_ 1 _N_ _S_ "U(P)" {_A_ 1 _U_ 2 _N_ _N_ _N_ _N_} _N_ _N_ #-}
+ toRational = { _A_ 1 _U_ 1 _N_ _S_ "U(P)" {_A_ 1 _U_ 2 _N_ _N_ _N_ _N_} _N_ _N_ } #-}
instance Real Int
{-# GHC_PRAGMA _M_ PreludeCore {-dfun-} _A_ 0 _N_ _N_ _N_ _F_ _IF_ARGS_ 0 0 X 4 _!_ _TUP_3 [{{Num Int}}, {{Enum Int}}, (Int -> Ratio Integer)] [_DFUN_ Num (Int), _DFUN_ Enum (Int), _CONSTM_ Real toRational (Int)] _N_
- toRational = _A_ 1 _U_ 1 _N_ _N_ _N_ _N_ #-}
+ toRational = { _A_ 1 _U_ 1 _N_ _N_ _N_ _N_ } #-}
instance Real Integer
{-# GHC_PRAGMA _M_ PreludeCore {-dfun-} _A_ 0 _N_ _N_ _N_ _F_ _IF_ARGS_ 0 0 X 4 _!_ _TUP_3 [{{Num Integer}}, {{Enum Integer}}, (Integer -> Ratio Integer)] [_DFUN_ Num (Integer), _DFUN_ Enum (Integer), _CONSTM_ Real toRational (Integer)] _N_
- toRational = _A_ 1 _U_ 2 _N_ _N_ _N_ _N_ #-}
+ toRational = { _A_ 1 _U_ 2 _N_ _N_ _F_ _IF_ARGS_ 0 1 X 3 \ (u0 :: Integer) -> _!_ (:%) [Integer] [u0, _ORIG_ PreludeCore __integer1] _N_ } #-}
instance Integral a => Real (Ratio a)
{-# GHC_PRAGMA _M_ PreludeRatio {-dfun-} _A_ 3 _U_ 122 _N_ _N_ _N_ _N_ #-}
instance Real (Ratio Integer)
{-# GHC_PRAGMA _M_ PreludeRatio {-dfun-} _A_ 0 _N_ _N_ _N_ _F_ _IF_ARGS_ 0 0 X 4 _!_ _TUP_3 [{{Num (Ratio Integer)}}, {{Enum (Ratio Integer)}}, (Ratio Integer -> Ratio Integer)] [_DFUN_ Num (Ratio Integer), _DFUN_ Enum (Ratio Integer), _CONSTM_ Real toRational (Ratio Integer)] _N_
- toRational = _A_ 1 _U_ 1 _N_ _S_ "U(LL)" {_A_ 2 _U_ 22 _N_ _N_ _F_ _IF_ARGS_ 0 2 XX 3 \ (u0 :: Integer) (u1 :: Integer) -> _!_ (:%) [Integer] [u0, u1] _N_} _F_ _IF_ARGS_ 0 1 X 1 \ (u0 :: Ratio Integer) -> u0 _N_ #-}
+ toRational = { _A_ 1 _U_ 1 _N_ _S_ "U(LL)" {_A_ 2 _U_ 22 _N_ _N_ _F_ _IF_ARGS_ 0 2 XX 3 \ (u0 :: Integer) (u1 :: Integer) -> _!_ (:%) [Integer] [u0, u1] _N_} _F_ _IF_ARGS_ 0 1 X 1 \ (u0 :: Ratio Integer) -> u0 _N_ } #-}
instance RealFloat Double
{-# GHC_PRAGMA _M_ PreludeCore {-dfun-} _A_ 0 _N_ _N_ _N_ _F_ _IF_ARGS_ 0 0 X 11 _!_ _TUP_10 [{{RealFrac Double}}, {{Floating Double}}, (Double -> Integer), (Double -> Int), (Double -> (Int, Int)), (Double -> (Integer, Int)), (Integer -> Int -> Double), (Double -> Int), (Double -> Double), (Int -> Double -> Double)] [_DFUN_ RealFrac (Double), _DFUN_ Floating (Double), _CONSTM_ RealFloat floatRadix (Double), _CONSTM_ RealFloat floatDigits (Double), _CONSTM_ RealFloat floatRange (Double), _CONSTM_ RealFloat decodeFloat (Double), _CONSTM_ RealFloat encodeFloat (Double), _CONSTM_ RealFloat exponent (Double), _CONSTM_ RealFloat significand (Double), _CONSTM_ RealFloat scaleFloat (Double)] _N_
- floatRadix = _A_ 1 _U_ 0 _N_ _S_ "A" {_A_ 0 _N_ _N_ _N_ _F_ _IF_ARGS_ 0 0 X 1 _#_ int2Integer# [] [2#] _N_} _N_ _N_,
- floatDigits = _A_ 1 _U_ 0 _N_ _S_ "A" {_A_ 0 _N_ _N_ _N_ _F_ _IF_ARGS_ 0 0 X 2 _!_ I# [] [53#] _N_} _F_ _IF_ARGS_ 0 1 X 2 \ (u0 :: Double) -> _!_ I# [] [53#] _N_,
- floatRange = _A_ 1 _U_ 0 _N_ _S_ "A" {_A_ 0 _N_ _N_ _N_ _N_ _N_} _N_ _N_,
- decodeFloat = _A_ 1 _U_ 1 _N_ _S_ "U(P)" {_A_ 1 _U_ 2 _N_ _N_ _N_ _N_} _N_ _N_,
- encodeFloat = _A_ 2 _U_ 11 _N_ _S_ "U(PPP)U(P)" {_A_ 4 _U_ 2222 _N_ _N_ _F_ _IF_ARGS_ 0 4 XXXX 3 \ (u0 :: Int#) (u1 :: Int#) (u2 :: ByteArray#) (u3 :: Int#) -> case _#_ encodeDouble# [] [u0, u1, u2, u3] of { _PRIM_ (u4 :: Double#) -> _!_ D# [] [u4] } _N_} _F_ _IF_ARGS_ 0 2 CC 5 \ (u0 :: Integer) (u1 :: Int) -> case u0 of { _ALG_ J# (u2 :: Int#) (u3 :: Int#) (u4 :: ByteArray#) -> case u1 of { _ALG_ I# (u5 :: Int#) -> case _#_ encodeDouble# [] [u2, u3, u4, u5] of { _PRIM_ (u6 :: Double#) -> _!_ D# [] [u6] }; _NO_DEFLT_ }; _NO_DEFLT_ } _N_,
- exponent = _A_ 1 _U_ 2 _N_ _N_ _N_ _N_,
- significand = _A_ 1 _U_ 2 _N_ _N_ _N_ _N_,
- scaleFloat = _A_ 2 _U_ 22 _N_ _N_ _N_ _N_ #-}
+ floatRadix = { _A_ 1 _U_ 0 _N_ _S_ "A" {_A_ 0 _N_ _N_ _N_ _N_ _N_} _N_ _N_ },
+ floatDigits = { _A_ 1 _U_ 0 _N_ _S_ "A" {_A_ 0 _N_ _N_ _N_ _F_ _IF_ARGS_ 0 0 X 2 _!_ I# [] [53#] _N_} _F_ _IF_ARGS_ 0 1 X 2 \ (u0 :: Double) -> _!_ I# [] [53#] _N_ },
+ floatRange = { _A_ 1 _U_ 0 _N_ _S_ "A" {_A_ 0 _N_ _N_ _N_ _N_ _N_} _N_ _N_ },
+ decodeFloat = { _A_ 1 _U_ 1 _N_ _S_ "U(P)" {_A_ 1 _U_ 2 _N_ _N_ _N_ _N_} _N_ _N_ },
+ encodeFloat = { _A_ 2 _U_ 11 _N_ _S_ "U(PPP)U(P)" {_A_ 4 _U_ 2222 _N_ _N_ _F_ _IF_ARGS_ 0 4 XXXX 3 \ (u0 :: Int#) (u1 :: Int#) (u2 :: ByteArray#) (u3 :: Int#) -> case _#_ encodeDouble# [] [u0, u1, u2, u3] of { _PRIM_ (u4 :: Double#) -> _!_ D# [] [u4] } _N_} _F_ _IF_ARGS_ 0 2 CC 5 \ (u0 :: Integer) (u1 :: Int) -> case u0 of { _ALG_ J# (u2 :: Int#) (u3 :: Int#) (u4 :: ByteArray#) -> case u1 of { _ALG_ I# (u5 :: Int#) -> case _#_ encodeDouble# [] [u2, u3, u4, u5] of { _PRIM_ (u6 :: Double#) -> _!_ D# [] [u6] }; _NO_DEFLT_ }; _NO_DEFLT_ } _N_ },
+ exponent = { _A_ 1 _U_ 1 _N_ _S_ "U(P)" {_A_ 1 _U_ 2 _N_ _N_ _N_ _N_} _N_ _N_ },
+ significand = { _A_ 1 _U_ 1 _N_ _S_ "U(P)" {_A_ 1 _U_ 2 _N_ _N_ _N_ _N_} _N_ _N_ },
+ scaleFloat = { _A_ 2 _U_ 11 _N_ _S_ "U(P)U(P)" {_A_ 2 _U_ 22 _N_ _N_ _N_ _N_} _N_ _N_ } #-}
instance RealFloat Float
{-# GHC_PRAGMA _M_ PreludeCore {-dfun-} _A_ 0 _N_ _N_ _N_ _F_ _IF_ARGS_ 0 0 X 11 _!_ _TUP_10 [{{RealFrac Float}}, {{Floating Float}}, (Float -> Integer), (Float -> Int), (Float -> (Int, Int)), (Float -> (Integer, Int)), (Integer -> Int -> Float), (Float -> Int), (Float -> Float), (Int -> Float -> Float)] [_DFUN_ RealFrac (Float), _DFUN_ Floating (Float), _CONSTM_ RealFloat floatRadix (Float), _CONSTM_ RealFloat floatDigits (Float), _CONSTM_ RealFloat floatRange (Float), _CONSTM_ RealFloat decodeFloat (Float), _CONSTM_ RealFloat encodeFloat (Float), _CONSTM_ RealFloat exponent (Float), _CONSTM_ RealFloat significand (Float), _CONSTM_ RealFloat scaleFloat (Float)] _N_
- floatRadix = _A_ 1 _U_ 0 _N_ _S_ "A" {_A_ 0 _N_ _N_ _N_ _F_ _IF_ARGS_ 0 0 X 1 _#_ int2Integer# [] [2#] _N_} _N_ _N_,
- floatDigits = _A_ 1 _U_ 0 _N_ _S_ "A" {_A_ 0 _N_ _N_ _N_ _F_ _IF_ARGS_ 0 0 X 2 _!_ I# [] [24#] _N_} _F_ _IF_ARGS_ 0 1 X 2 \ (u0 :: Float) -> _!_ I# [] [24#] _N_,
- floatRange = _A_ 1 _U_ 0 _N_ _S_ "A" {_A_ 0 _N_ _N_ _N_ _N_ _N_} _N_ _N_,
- decodeFloat = _A_ 1 _U_ 1 _N_ _S_ "U(P)" {_A_ 1 _U_ 2 _N_ _N_ _N_ _N_} _N_ _N_,
- encodeFloat = _A_ 2 _U_ 11 _N_ _S_ "U(PPP)U(P)" {_A_ 4 _U_ 2222 _N_ _N_ _F_ _IF_ARGS_ 0 4 XXXX 3 \ (u0 :: Int#) (u1 :: Int#) (u2 :: ByteArray#) (u3 :: Int#) -> case _#_ encodeFloat# [] [u0, u1, u2, u3] of { _PRIM_ (u4 :: Float#) -> _!_ F# [] [u4] } _N_} _F_ _IF_ARGS_ 0 2 CC 5 \ (u0 :: Integer) (u1 :: Int) -> case u0 of { _ALG_ J# (u2 :: Int#) (u3 :: Int#) (u4 :: ByteArray#) -> case u1 of { _ALG_ I# (u5 :: Int#) -> case _#_ encodeFloat# [] [u2, u3, u4, u5] of { _PRIM_ (u6 :: Float#) -> _!_ F# [] [u6] }; _NO_DEFLT_ }; _NO_DEFLT_ } _N_,
- exponent = _A_ 1 _U_ 2 _N_ _N_ _N_ _N_,
- significand = _A_ 1 _U_ 2 _N_ _N_ _N_ _N_,
- scaleFloat = _A_ 2 _U_ 22 _N_ _N_ _N_ _N_ #-}
+ floatRadix = { _A_ 1 _U_ 0 _N_ _S_ "A" {_A_ 0 _N_ _N_ _N_ _N_ _N_} _N_ _N_ },
+ floatDigits = { _A_ 1 _U_ 0 _N_ _S_ "A" {_A_ 0 _N_ _N_ _N_ _F_ _IF_ARGS_ 0 0 X 2 _!_ I# [] [24#] _N_} _F_ _IF_ARGS_ 0 1 X 2 \ (u0 :: Float) -> _!_ I# [] [24#] _N_ },
+ floatRange = { _A_ 1 _U_ 0 _N_ _S_ "A" {_A_ 0 _N_ _N_ _N_ _N_ _N_} _N_ _N_ },
+ decodeFloat = { _A_ 1 _U_ 1 _N_ _S_ "U(P)" {_A_ 1 _U_ 2 _N_ _N_ _N_ _N_} _N_ _N_ },
+ encodeFloat = { _A_ 2 _U_ 11 _N_ _S_ "U(PPP)U(P)" {_A_ 4 _U_ 2222 _N_ _N_ _F_ _IF_ARGS_ 0 4 XXXX 3 \ (u0 :: Int#) (u1 :: Int#) (u2 :: ByteArray#) (u3 :: Int#) -> case _#_ encodeFloat# [] [u0, u1, u2, u3] of { _PRIM_ (u4 :: Float#) -> _!_ F# [] [u4] } _N_} _F_ _IF_ARGS_ 0 2 CC 5 \ (u0 :: Integer) (u1 :: Int) -> case u0 of { _ALG_ J# (u2 :: Int#) (u3 :: Int#) (u4 :: ByteArray#) -> case u1 of { _ALG_ I# (u5 :: Int#) -> case _#_ encodeFloat# [] [u2, u3, u4, u5] of { _PRIM_ (u6 :: Float#) -> _!_ F# [] [u6] }; _NO_DEFLT_ }; _NO_DEFLT_ } _N_ },
+ exponent = { _A_ 1 _U_ 1 _N_ _S_ "U(P)" {_A_ 1 _U_ 2 _N_ _N_ _N_ _N_} _N_ _N_ },
+ significand = { _A_ 1 _U_ 1 _N_ _S_ "U(P)" {_A_ 1 _U_ 2 _N_ _N_ _N_ _N_} _N_ _N_ },
+ scaleFloat = { _A_ 2 _U_ 11 _N_ _S_ "U(P)U(P)" {_A_ 2 _U_ 22 _N_ _N_ _N_ _N_} _N_ _N_ } #-}
instance RealFrac Double
{-# GHC_PRAGMA _M_ PreludeCore {-dfun-} _A_ 0 _N_ _N_ _N_ _F_ _IF_ARGS_ 0 0 X 8 _!_ _TUP_7 [{{Real Double}}, {{Fractional Double}}, _forall_ a$z1 =>{{Integral a$z1}} -> (Double -> (a$z1, Double)), _forall_ a$z1 =>{{Integral a$z1}} -> (Double -> a$z1), _forall_ a$z1 =>{{Integral a$z1}} -> (Double -> a$z1), _forall_ a$z1 =>{{Integral a$z1}} -> (Double -> a$z1), _forall_ a$z1 =>{{Integral a$z1}} -> (Double -> a$z1)] [_DFUN_ Real (Double), _DFUN_ Fractional (Double), _CONSTM_ RealFrac properFraction (Double), _CONSTM_ RealFrac truncate (Double), _CONSTM_ RealFrac round (Double), _CONSTM_ RealFrac ceiling (Double), _CONSTM_ RealFrac floor (Double)] _N_
- properFraction = _A_ 1 _U_ 22 _N_ _N_ _N_ _N_,
- truncate = _A_ 1 _U_ 22 _N_ _N_ _N_ _N_,
- round = _A_ 1 _U_ 22 _N_ _N_ _N_ _N_,
- ceiling = _A_ 1 _U_ 22 _N_ _N_ _N_ _N_,
- floor = _A_ 1 _U_ 22 _N_ _N_ _N_ _N_ #-}
+ properFraction = { _A_ 1 _U_ 11 _N_ _N_ _N_ _SPECIALISE_ [ Int ] 1 { _A_ 1 _U_ 1 _N_ _S_ "U(P)" {_A_ 1 _U_ 2 _N_ _N_ _N_ _N_} _N_ _N_ }, [ Integer ] 1 { _A_ 1 _U_ 1 _N_ _S_ "U(P)" {_A_ 1 _U_ 2 _N_ _N_ _N_ _N_} _N_ _N_ } },
+ truncate = { _A_ 1 _U_ 11 _N_ _N_ _N_ _SPECIALISE_ [ Int ] 1 { _A_ 1 _U_ 1 _N_ _S_ "U(P)" {_A_ 1 _U_ 2 _N_ _N_ _F_ _IF_ARGS_ 0 1 X 4 \ (u0 :: Double#) -> case _APP_ _WRKR_ _SPEC_ _CONSTM_ RealFrac properFraction (Double) [ (Int) ] [ u0 ] of { _ALG_ _TUP_2 (u1 :: Int) (u2 :: Double) -> u1; _NO_DEFLT_ } _N_} _F_ _IF_ARGS_ 0 1 X 4 \ (u0 :: Double) -> case _APP_ _SPEC_ _CONSTM_ RealFrac properFraction (Double) [ (Int) ] [ u0 ] of { _ALG_ _TUP_2 (u1 :: Int) (u2 :: Double) -> u1; _NO_DEFLT_ } _N_ }, [ Integer ] 1 { _A_ 1 _U_ 1 _N_ _S_ "U(P)" {_A_ 1 _U_ 2 _N_ _N_ _F_ _IF_ARGS_ 0 1 X 4 \ (u0 :: Double#) -> case _APP_ _WRKR_ _SPEC_ _CONSTM_ RealFrac properFraction (Double) [ (Integer) ] [ u0 ] of { _ALG_ _TUP_2 (u1 :: Integer) (u2 :: Double) -> u1; _NO_DEFLT_ } _N_} _F_ _IF_ARGS_ 0 1 X 4 \ (u0 :: Double) -> case _APP_ _SPEC_ _CONSTM_ RealFrac properFraction (Double) [ (Integer) ] [ u0 ] of { _ALG_ _TUP_2 (u1 :: Integer) (u2 :: Double) -> u1; _NO_DEFLT_ } _N_ } },
+ round = { _A_ 1 _U_ 21 _N_ _N_ _N_ _SPECIALISE_ [ Int ] 1 { _A_ 1 _U_ 1 _N_ _S_ "U(P)" {_A_ 1 _U_ 2 _N_ _N_ _N_ _N_} _N_ _N_ }, [ Integer ] 1 { _A_ 1 _U_ 1 _N_ _S_ "U(P)" {_A_ 1 _U_ 2 _N_ _N_ _N_ _N_} _N_ _N_ } },
+ ceiling = { _A_ 1 _U_ 21 _N_ _N_ _N_ _SPECIALISE_ [ Int ] 1 { _A_ 1 _U_ 1 _N_ _S_ "U(P)" {_A_ 1 _U_ 2 _N_ _N_ _N_ _N_} _N_ _N_ }, [ Integer ] 1 { _A_ 1 _U_ 1 _N_ _S_ "U(P)" {_A_ 1 _U_ 2 _N_ _N_ _N_ _N_} _N_ _N_ } },
+ floor = { _A_ 1 _U_ 21 _N_ _N_ _N_ _SPECIALISE_ [ Int ] 1 { _A_ 1 _U_ 1 _N_ _S_ "U(P)" {_A_ 1 _U_ 2 _N_ _N_ _N_ _N_} _N_ _N_ }, [ Integer ] 1 { _A_ 1 _U_ 1 _N_ _S_ "U(P)" {_A_ 1 _U_ 2 _N_ _N_ _N_ _N_} _N_ _N_ } } #-}
instance RealFrac Float
{-# GHC_PRAGMA _M_ PreludeCore {-dfun-} _A_ 0 _N_ _N_ _N_ _F_ _IF_ARGS_ 0 0 X 8 _!_ _TUP_7 [{{Real Float}}, {{Fractional Float}}, _forall_ a$z1 =>{{Integral a$z1}} -> (Float -> (a$z1, Float)), _forall_ a$z1 =>{{Integral a$z1}} -> (Float -> a$z1), _forall_ a$z1 =>{{Integral a$z1}} -> (Float -> a$z1), _forall_ a$z1 =>{{Integral a$z1}} -> (Float -> a$z1), _forall_ a$z1 =>{{Integral a$z1}} -> (Float -> a$z1)] [_DFUN_ Real (Float), _DFUN_ Fractional (Float), _CONSTM_ RealFrac properFraction (Float), _CONSTM_ RealFrac truncate (Float), _CONSTM_ RealFrac round (Float), _CONSTM_ RealFrac ceiling (Float), _CONSTM_ RealFrac floor (Float)] _N_
- properFraction = _A_ 1 _U_ 22 _N_ _N_ _N_ _N_,
- truncate = _A_ 1 _U_ 22 _N_ _N_ _N_ _N_,
- round = _A_ 1 _U_ 22 _N_ _N_ _N_ _N_,
- ceiling = _A_ 1 _U_ 22 _N_ _N_ _N_ _N_,
- floor = _A_ 1 _U_ 22 _N_ _N_ _N_ _N_ #-}
-instance Integral a => RealFrac (Ratio a)
- {-# GHC_PRAGMA _M_ PreludeRatio {-dfun-} _A_ 3 _U_ 222 _N_ _N_ _N_ _N_ #-}
+ properFraction = { _A_ 1 _U_ 11 _N_ _N_ _N_ _SPECIALISE_ [ Int ] 1 { _A_ 1 _U_ 1 _N_ _S_ "U(P)" {_A_ 1 _U_ 2 _N_ _N_ _N_ _N_} _N_ _N_ }, [ Integer ] 1 { _A_ 1 _U_ 1 _N_ _S_ "U(P)" {_A_ 1 _U_ 2 _N_ _N_ _N_ _N_} _N_ _N_ } },
+ truncate = { _A_ 1 _U_ 11 _N_ _N_ _N_ _SPECIALISE_ [ Int ] 1 { _A_ 1 _U_ 1 _N_ _S_ "U(P)" {_A_ 1 _U_ 2 _N_ _N_ _F_ _IF_ARGS_ 0 1 X 4 \ (u0 :: Float#) -> case _APP_ _WRKR_ _SPEC_ _CONSTM_ RealFrac properFraction (Float) [ (Int) ] [ u0 ] of { _ALG_ _TUP_2 (u1 :: Int) (u2 :: Float) -> u1; _NO_DEFLT_ } _N_} _F_ _IF_ARGS_ 0 1 X 4 \ (u0 :: Float) -> case _APP_ _SPEC_ _CONSTM_ RealFrac properFraction (Float) [ (Int) ] [ u0 ] of { _ALG_ _TUP_2 (u1 :: Int) (u2 :: Float) -> u1; _NO_DEFLT_ } _N_ }, [ Integer ] 1 { _A_ 1 _U_ 1 _N_ _S_ "U(P)" {_A_ 1 _U_ 2 _N_ _N_ _F_ _IF_ARGS_ 0 1 X 4 \ (u0 :: Float#) -> case _APP_ _WRKR_ _SPEC_ _CONSTM_ RealFrac properFraction (Float) [ (Integer) ] [ u0 ] of { _ALG_ _TUP_2 (u1 :: Integer) (u2 :: Float) -> u1; _NO_DEFLT_ } _N_} _F_ _IF_ARGS_ 0 1 X 4 \ (u0 :: Float) -> case _APP_ _SPEC_ _CONSTM_ RealFrac properFraction (Float) [ (Integer) ] [ u0 ] of { _ALG_ _TUP_2 (u1 :: Integer) (u2 :: Float) -> u1; _NO_DEFLT_ } _N_ } },
+ round = { _A_ 1 _U_ 21 _N_ _N_ _N_ _SPECIALISE_ [ Int ] 1 { _A_ 1 _U_ 1 _N_ _S_ "U(P)" {_A_ 1 _U_ 2 _N_ _N_ _N_ _N_} _N_ _N_ }, [ Integer ] 1 { _A_ 1 _U_ 1 _N_ _S_ "U(P)" {_A_ 1 _U_ 2 _N_ _N_ _N_ _N_} _N_ _N_ } },
+ ceiling = { _A_ 1 _U_ 21 _N_ _N_ _N_ _SPECIALISE_ [ Int ] 1 { _A_ 1 _U_ 1 _N_ _S_ "U(P)" {_A_ 1 _U_ 2 _N_ _N_ _N_ _N_} _N_ _N_ }, [ Integer ] 1 { _A_ 1 _U_ 1 _N_ _S_ "U(P)" {_A_ 1 _U_ 2 _N_ _N_ _N_ _N_} _N_ _N_ } },
+ floor = { _A_ 1 _U_ 21 _N_ _N_ _N_ _SPECIALISE_ [ Int ] 1 { _A_ 1 _U_ 1 _N_ _S_ "U(P)" {_A_ 1 _U_ 2 _N_ _N_ _N_ _N_} _N_ _N_ }, [ Integer ] 1 { _A_ 1 _U_ 1 _N_ _S_ "U(P)" {_A_ 1 _U_ 2 _N_ _N_ _N_ _N_} _N_ _N_ } } #-}
instance RealFrac (Ratio Integer)
{-# GHC_PRAGMA _M_ PreludeRatio {-dfun-} _A_ 0 _N_ _N_ _N_ _F_ _IF_ARGS_ 0 0 X 8 _!_ _TUP_7 [{{Real (Ratio Integer)}}, {{Fractional (Ratio Integer)}}, _forall_ a$z1 =>{{Integral a$z1}} -> (Ratio Integer -> (a$z1, Ratio Integer)), _forall_ a$z1 =>{{Integral a$z1}} -> (Ratio Integer -> a$z1), _forall_ a$z1 =>{{Integral a$z1}} -> (Ratio Integer -> a$z1), _forall_ a$z1 =>{{Integral a$z1}} -> (Ratio Integer -> a$z1), _forall_ a$z1 =>{{Integral a$z1}} -> (Ratio Integer -> a$z1)] [_DFUN_ Real (Ratio Integer), _DFUN_ Fractional (Ratio Integer), _CONSTM_ RealFrac properFraction (Ratio Integer), _CONSTM_ RealFrac truncate (Ratio Integer), _CONSTM_ RealFrac round (Ratio Integer), _CONSTM_ RealFrac ceiling (Ratio Integer), _CONSTM_ RealFrac floor (Ratio Integer)] _N_
- properFraction = _A_ 2 _U_ 11 _N_ _S_ "LU(LL)" {_A_ 3 _U_ 112 _N_ _N_ _N_ _N_} _N_ _N_,
- truncate = _A_ 1 _U_ 22 _N_ _N_ _F_ _IF_ARGS_ 1 1 X 3 _/\_ u0 -> \ (u1 :: {{Integral u0}}) -> _APP_ _TYAPP_ _TYAPP_ _WRKR_ _ORIG_ PreludeCore _truncate { (Ratio Integer) } { u0 } [ _CONSTM_ RealFrac properFraction (Ratio Integer), u1 ] _N_,
- round = _A_ 1 _U_ 22 _N_ _N_ _N_ _N_,
- ceiling = _A_ 1 _U_ 22 _N_ _N_ _N_ _N_,
- floor = _A_ 1 _U_ 22 _N_ _N_ _N_ _N_ #-}
+ properFraction = { _A_ 2 _U_ 11 _N_ _S_ "LU(U(PPP)U(PPP))" {_A_ 5 _U_ 12222 _N_ _N_ _N_ _N_} _N_ _SPECIALISE_ [ Int ] 1 { _A_ 1 _U_ 1 _N_ _S_ "U(U(PPP)U(PPP))" {_A_ 4 _U_ 2222 _N_ _N_ _N_ _N_} _N_ _N_ }, [ Integer ] 1 { _A_ 1 _U_ 1 _N_ _S_ "U(U(PPP)U(PPP))" {_A_ 4 _U_ 2222 _N_ _N_ _N_ _N_} _N_ _N_ } },
+ truncate = { _A_ 2 _U_ 11 _N_ _N_ _N_ _SPECIALISE_ [ Int ] 1 { _A_ 1 _U_ 1 _N_ _S_ "U(U(PPP)U(PPP))" {_A_ 4 _U_ 2222 _N_ _N_ _F_ _IF_ARGS_ 0 4 XXXX 7 \ (u0 :: Int#) (u1 :: Int#) (u2 :: ByteArray#) (u3 :: Integer) -> case _APP_ _WRKR_ _SPEC_ _CONSTM_ RealFrac properFraction (Ratio Integer) [ (Int) ] [ u0, u1, u2, u3 ] of { _ALG_ _TUP_2 (u4 :: Int) (u5 :: Ratio Integer) -> u4; _NO_DEFLT_ } _N_} _F_ _IF_ARGS_ 0 1 X 4 \ (u0 :: Ratio Integer) -> case _APP_ _SPEC_ _CONSTM_ RealFrac properFraction (Ratio Integer) [ (Int) ] [ u0 ] of { _ALG_ _TUP_2 (u1 :: Int) (u2 :: Ratio Integer) -> u1; _NO_DEFLT_ } _N_ }, [ Integer ] 1 { _A_ 1 _U_ 1 _N_ _S_ "U(U(PPP)U(PPP))" {_A_ 4 _U_ 2222 _N_ _N_ _F_ _IF_ARGS_ 0 4 XXXX 7 \ (u0 :: Int#) (u1 :: Int#) (u2 :: ByteArray#) (u3 :: Integer) -> case _APP_ _WRKR_ _SPEC_ _CONSTM_ RealFrac properFraction (Ratio Integer) [ (Integer) ] [ u0, u1, u2, u3 ] of { _ALG_ _TUP_2 (u4 :: Integer) (u5 :: Ratio Integer) -> u4; _NO_DEFLT_ } _N_} _F_ _IF_ARGS_ 0 1 X 4 \ (u0 :: Ratio Integer) -> case _APP_ _SPEC_ _CONSTM_ RealFrac properFraction (Ratio Integer) [ (Integer) ] [ u0 ] of { _ALG_ _TUP_2 (u1 :: Integer) (u2 :: Ratio Integer) -> u1; _NO_DEFLT_ } _N_ } },
+ round = { _A_ 1 _U_ 21 _N_ _N_ _N_ _SPECIALISE_ [ Int ] 1 { _A_ 1 _U_ 1 _N_ _S_ "U(U(PPP)U(PPP))" {_A_ 4 _U_ 2222 _N_ _N_ _N_ _N_} _N_ _N_ }, [ Integer ] 1 { _A_ 1 _U_ 1 _N_ _S_ "U(U(PPP)U(PPP))" {_A_ 4 _U_ 2222 _N_ _N_ _N_ _N_} _N_ _N_ } },
+ ceiling = { _A_ 1 _U_ 21 _N_ _N_ _N_ _SPECIALISE_ [ Int ] 1 { _A_ 1 _U_ 1 _N_ _S_ "U(U(PPP)U(PPP))" {_A_ 4 _U_ 2222 _N_ _N_ _N_ _N_} _N_ _N_ }, [ Integer ] 1 { _A_ 1 _U_ 1 _N_ _S_ "U(U(PPP)U(PPP))" {_A_ 4 _U_ 2222 _N_ _N_ _N_ _N_} _N_ _N_ } },
+ floor = { _A_ 1 _U_ 21 _N_ _N_ _N_ _SPECIALISE_ [ Int ] 1 { _A_ 1 _U_ 1 _N_ _S_ "U(U(PPP)U(PPP))" {_A_ 4 _U_ 2222 _N_ _N_ _N_ _N_} _N_ _N_ }, [ Integer ] 1 { _A_ 1 _U_ 1 _N_ _S_ "U(U(PPP)U(PPP))" {_A_ 4 _U_ 2222 _N_ _N_ _N_ _N_} _N_ _N_ } } #-}
+instance Text ((Int, Int), (Int, Int))
+ {-# GHC_PRAGMA _M_ PreludeBuiltin {-dfun-} _A_ 0 _N_ _N_ _N_ _F_ _IF_ARGS_ 0 0 X 5 _!_ _TUP_4 [(Int -> [Char] -> [(((Int, Int), (Int, Int)), [Char])]), (Int -> ((Int, Int), (Int, Int)) -> [Char] -> [Char]), ([Char] -> [([((Int, Int), (Int, Int))], [Char])]), ([((Int, Int), (Int, Int))] -> [Char] -> [Char])] [_CONSTM_ Text readsPrec (((Int, Int), (Int, Int))), _CONSTM_ Text showsPrec (((Int, Int), (Int, Int))), _CONSTM_ Text readList (((Int, Int), (Int, Int))), _CONSTM_ Text showList (((Int, Int), (Int, Int)))] _N_
+ readsPrec = { _A_ 1 _U_ 02 _N_ _S_ "A" {_A_ 0 _U_ 2 _N_ _N_ _N_ _N_} _N_ _N_ },
+ showsPrec = { _A_ 3 _U_ 012 _N_ _S_ "AU(LL)L" {_A_ 3 _U_ 112 _N_ _N_ _N_ _N_} _N_ _N_ },
+ readList = { _A_ 0 _U_ 2 _N_ _N_ _N_ _N_ },
+ showList = { _A_ 1 _U_ 12 _N_ _N_ _N_ _N_ } #-}
instance Text ()
{-# GHC_PRAGMA _M_ PreludeBuiltin {-dfun-} _A_ 0 _N_ _N_ _N_ _F_ _IF_ARGS_ 0 0 X 5 _!_ _TUP_4 [(Int -> [Char] -> [((), [Char])]), (Int -> () -> [Char] -> [Char]), ([Char] -> [([()], [Char])]), ([()] -> [Char] -> [Char])] [_CONSTM_ Text readsPrec (()), _CONSTM_ Text showsPrec (()), _CONSTM_ Text readList (()), _CONSTM_ Text showList (())] _N_
- readsPrec = _A_ 1 _U_ 02 _N_ _S_ "A" {_A_ 0 _U_ 2 _N_ _N_ _N_ _N_} _N_ _N_,
- showsPrec = _A_ 3 _U_ 012 _N_ _S_ "AEL" {_A_ 2 _U_ 12 _N_ _N_ _F_ _IF_ARGS_ 0 2 CX 4 \ (u0 :: ()) (u1 :: [Char]) -> case u0 of { _ALG_ _TUP_0 -> _APP_ _TYAPP_ _ORIG_ PreludeList (++) { Char } [ _NOREP_S_ "()", u1 ]; _NO_DEFLT_ } _N_} _F_ _IF_ARGS_ 0 3 XCX 4 \ (u0 :: Int) (u1 :: ()) (u2 :: [Char]) -> case u1 of { _ALG_ _TUP_0 -> _APP_ _TYAPP_ _ORIG_ PreludeList (++) { Char } [ _NOREP_S_ "()", u2 ]; _NO_DEFLT_ } _N_,
- readList = _A_ 0 _U_ 2 _N_ _N_ _N_ _N_,
- showList = _A_ 0 _U_ 12 _N_ _N_ _N_ _N_ #-}
+ readsPrec = { _A_ 1 _U_ 02 _N_ _S_ "A" {_A_ 0 _U_ 2 _N_ _N_ _N_ _N_} _N_ _N_ },
+ showsPrec = { _A_ 3 _U_ 012 _N_ _S_ "AEL" {_A_ 2 _U_ 12 _N_ _N_ _F_ _IF_ARGS_ 0 2 CX 4 \ (u0 :: ()) (u1 :: [Char]) -> case u0 of { _ALG_ _TUP_0 -> _APP_ _TYAPP_ _ORIG_ PreludeList (++) { Char } [ _NOREP_S_ "()", u1 ]; _NO_DEFLT_ } _N_} _F_ _IF_ARGS_ 0 3 XCX 4 \ (u0 :: Int) (u1 :: ()) (u2 :: [Char]) -> case u1 of { _ALG_ _TUP_0 -> _APP_ _TYAPP_ _ORIG_ PreludeList (++) { Char } [ _NOREP_S_ "()", u2 ]; _NO_DEFLT_ } _N_ },
+ readList = { _A_ 0 _U_ 2 _N_ _N_ _N_ _N_ },
+ showList = { _A_ 1 _U_ 12 _N_ _N_ _N_ _N_ } #-}
instance (Text a, Text b) => Text (a, b)
{-# GHC_PRAGMA _M_ PreludeBuiltin {-dfun-} _A_ 2 _U_ 22 _N_ _N_ _N_ _N_ #-}
instance (Text a, Text b, Text c) => Text (a, b, c)
{-# GHC_PRAGMA _M_ PreludeBuiltin {-dfun-} _A_ 5 _U_ 22222 _N_ _N_ _N_ _N_ #-}
instance Text (Int, Int)
{-# GHC_PRAGMA _M_ PreludeBuiltin {-dfun-} _A_ 0 _N_ _N_ _N_ _F_ _IF_ARGS_ 0 0 X 5 _!_ _TUP_4 [(Int -> [Char] -> [((Int, Int), [Char])]), (Int -> (Int, Int) -> [Char] -> [Char]), ([Char] -> [([(Int, Int)], [Char])]), ([(Int, Int)] -> [Char] -> [Char])] [_CONSTM_ Text readsPrec ((Int, Int)), _CONSTM_ Text showsPrec ((Int, Int)), _CONSTM_ Text readList ((Int, Int)), _CONSTM_ Text showList ((Int, Int))] _N_
- readsPrec = _A_ 1 _U_ 02 _N_ _S_ "A" {_A_ 0 _U_ 2 _N_ _N_ _N_ _N_} _N_ _N_,
- showsPrec = _A_ 3 _U_ 012 _N_ _S_ "AU(LL)L" {_A_ 3 _U_ 112 _N_ _N_ _N_ _N_} _N_ _N_,
- readList = _A_ 0 _U_ 2 _N_ _N_ _N_ _N_,
- showList = _A_ 0 _U_ 12 _N_ _N_ _N_ _N_ #-}
+ readsPrec = { _A_ 1 _U_ 02 _N_ _S_ "A" {_A_ 0 _U_ 2 _N_ _N_ _N_ _N_} _N_ _N_ },
+ showsPrec = { _A_ 3 _U_ 012 _N_ _S_ "AU(LL)L" {_A_ 3 _U_ 112 _N_ _N_ _N_ _N_} _N_ _N_ },
+ readList = { _A_ 0 _U_ 2 _N_ _N_ _N_ _N_ },
+ showList = { _A_ 1 _U_ 12 _N_ _N_ _N_ _N_ } #-}
+instance Text (Int, Int, Int)
+ {-# GHC_PRAGMA _M_ PreludeBuiltin {-dfun-} _A_ 0 _N_ _N_ _N_ _F_ _IF_ARGS_ 0 0 X 5 _!_ _TUP_4 [(Int -> [Char] -> [((Int, Int, Int), [Char])]), (Int -> (Int, Int, Int) -> [Char] -> [Char]), ([Char] -> [([(Int, Int, Int)], [Char])]), ([(Int, Int, Int)] -> [Char] -> [Char])] [_CONSTM_ Text readsPrec ((Int, Int, Int)), _CONSTM_ Text showsPrec ((Int, Int, Int)), _CONSTM_ Text readList ((Int, Int, Int)), _CONSTM_ Text showList ((Int, Int, Int))] _N_
+ readsPrec = { _A_ 1 _U_ 02 _N_ _S_ "A" {_A_ 0 _U_ 2 _N_ _N_ _N_ _N_} _N_ _N_ },
+ showsPrec = { _A_ 3 _U_ 012 _N_ _S_ "AU(LLL)L" {_A_ 4 _U_ 1112 _N_ _N_ _N_ _N_} _N_ _N_ },
+ readList = { _A_ 0 _U_ 2 _N_ _N_ _N_ _N_ },
+ showList = { _A_ 1 _U_ 12 _N_ _N_ _N_ _N_ } #-}
instance Text (Integer, Integer)
{-# GHC_PRAGMA _M_ PreludeBuiltin {-dfun-} _A_ 0 _N_ _N_ _N_ _F_ _IF_ARGS_ 0 0 X 5 _!_ _TUP_4 [(Int -> [Char] -> [((Integer, Integer), [Char])]), (Int -> (Integer, Integer) -> [Char] -> [Char]), ([Char] -> [([(Integer, Integer)], [Char])]), ([(Integer, Integer)] -> [Char] -> [Char])] [_CONSTM_ Text readsPrec ((Integer, Integer)), _CONSTM_ Text showsPrec ((Integer, Integer)), _CONSTM_ Text readList ((Integer, Integer)), _CONSTM_ Text showList ((Integer, Integer))] _N_
- readsPrec = _A_ 1 _U_ 02 _N_ _S_ "A" {_A_ 0 _U_ 2 _N_ _N_ _N_ _N_} _N_ _N_,
- showsPrec = _A_ 3 _U_ 012 _N_ _S_ "AU(LL)L" {_A_ 3 _U_ 112 _N_ _N_ _N_ _N_} _N_ _N_,
- readList = _A_ 0 _U_ 2 _N_ _N_ _N_ _N_,
- showList = _A_ 0 _U_ 12 _N_ _N_ _N_ _N_ #-}
+ readsPrec = { _A_ 1 _U_ 02 _N_ _S_ "A" {_A_ 0 _U_ 2 _N_ _N_ _N_ _N_} _N_ _N_ },
+ showsPrec = { _A_ 3 _U_ 012 _N_ _S_ "AU(LL)L" {_A_ 3 _U_ 112 _N_ _N_ _N_ _N_} _N_ _N_ },
+ readList = { _A_ 0 _U_ 2 _N_ _N_ _N_ _N_ },
+ showList = { _A_ 1 _U_ 12 _N_ _N_ _N_ _N_ } #-}
instance Text (a -> b)
{-# GHC_PRAGMA _M_ PreludeCore {-dfun-} _A_ 0 _N_ _N_ _N_ _N_ _N_ #-}
+instance Text (Array (Int, Int) Double)
+ {-# GHC_PRAGMA _M_ PreludeArray {-dfun-} _A_ 0 _N_ _N_ _N_ _F_ _IF_ARGS_ 0 0 X 5 _!_ _TUP_4 [(Int -> [Char] -> [(Array (Int, Int) Double, [Char])]), (Int -> Array (Int, Int) Double -> [Char] -> [Char]), ([Char] -> [([Array (Int, Int) Double], [Char])]), ([Array (Int, Int) Double] -> [Char] -> [Char])] [_CONSTM_ Text readsPrec (Array (Int, Int) Double), _CONSTM_ Text showsPrec (Array (Int, Int) Double), _CONSTM_ Text readList (Array (Int, Int) Double), _CONSTM_ Text showList (Array (Int, Int) Double)] _N_
+ readsPrec = { _A_ 1 _U_ 12 _N_ _S_ "U(P)" {_A_ 1 _U_ 22 _N_ _N_ _N_ _N_} _N_ _N_ },
+ showsPrec = { _A_ 2 _U_ 122 _N_ _N_ _N_ _N_ },
+ readList = { _A_ 0 _U_ 2 _N_ _N_ _N_ _N_ },
+ showList = { _A_ 0 _U_ 12 _N_ _N_ _N_ _N_ } #-}
instance (Ix a, Text a, Text b) => Text (Array a b)
{-# GHC_PRAGMA _M_ PreludeArray {-dfun-} _A_ 3 _U_ 222 _N_ _N_ _N_ _N_ #-}
+instance Text (Array Int Double)
+ {-# GHC_PRAGMA _M_ PreludeArray {-dfun-} _A_ 0 _N_ _N_ _N_ _F_ _IF_ARGS_ 0 0 X 5 _!_ _TUP_4 [(Int -> [Char] -> [(Array Int Double, [Char])]), (Int -> Array Int Double -> [Char] -> [Char]), ([Char] -> [([Array Int Double], [Char])]), ([Array Int Double] -> [Char] -> [Char])] [_CONSTM_ Text readsPrec (Array Int Double), _CONSTM_ Text showsPrec (Array Int Double), _CONSTM_ Text readList (Array Int Double), _CONSTM_ Text showList (Array Int Double)] _N_
+ readsPrec = { _A_ 1 _U_ 12 _N_ _S_ "U(P)" {_A_ 1 _U_ 22 _N_ _N_ _N_ _N_} _N_ _N_ },
+ showsPrec = { _A_ 2 _U_ 122 _N_ _N_ _N_ _N_ },
+ readList = { _A_ 0 _U_ 2 _N_ _N_ _N_ _N_ },
+ showList = { _A_ 0 _U_ 12 _N_ _N_ _N_ _N_ } #-}
instance (Text a, Text b) => Text (Assoc a b)
{-# GHC_PRAGMA _M_ PreludeArray {-dfun-} _A_ 2 _U_ 22 _N_ _N_ _N_ _N_ #-}
instance Text Bool
{-# GHC_PRAGMA _M_ PreludeCore {-dfun-} _A_ 0 _N_ _N_ _N_ _F_ _IF_ARGS_ 0 0 X 5 _!_ _TUP_4 [(Int -> [Char] -> [(Bool, [Char])]), (Int -> Bool -> [Char] -> [Char]), ([Char] -> [([Bool], [Char])]), ([Bool] -> [Char] -> [Char])] [_CONSTM_ Text readsPrec (Bool), _CONSTM_ Text showsPrec (Bool), _CONSTM_ Text readList (Bool), _CONSTM_ Text showList (Bool)] _N_
- readsPrec = _A_ 2 _U_ 02 _N_ _S_ "AL" {_A_ 1 _U_ 2 _N_ _N_ _N_ _N_} _N_ _N_,
- showsPrec = _A_ 3 _U_ 012 _N_ _S_ "AEL" {_A_ 2 _U_ 12 _N_ _N_ _N_ _N_} _N_ _N_,
- readList = _A_ 0 _U_ 2 _N_ _N_ _N_ _N_,
- showList = _A_ 0 _U_ 12 _N_ _N_ _N_ _N_ #-}
+ readsPrec = { _A_ 2 _U_ 02 _N_ _S_ "AL" {_A_ 1 _U_ 2 _N_ _N_ _N_ _N_} _N_ _N_ },
+ showsPrec = { _A_ 3 _U_ 012 _N_ _S_ "AEL" {_A_ 2 _U_ 12 _N_ _N_ _N_ _N_} _N_ _N_ },
+ readList = { _A_ 0 _U_ 2 _N_ _N_ _N_ _N_ },
+ showList = { _A_ 1 _U_ 12 _N_ _N_ _F_ _IF_ARGS_ 0 1 X 3 \ (u0 :: [Bool]) -> _APP_ _TYAPP_ _ORIG_ PreludeCore _showList { Bool } [ _WRKR_ _CONSTM_ Text showsPrec (Bool), u0 ] _N_ } #-}
instance Text Char
{-# GHC_PRAGMA _M_ PreludeCore {-dfun-} _A_ 0 _N_ _N_ _N_ _F_ _IF_ARGS_ 0 0 X 5 _!_ _TUP_4 [(Int -> [Char] -> [(Char, [Char])]), (Int -> Char -> [Char] -> [Char]), ([Char] -> [([Char], [Char])]), ([Char] -> [Char] -> [Char])] [_CONSTM_ Text readsPrec (Char), _CONSTM_ Text showsPrec (Char), _CONSTM_ Text readList (Char), _CONSTM_ Text showList (Char)] _N_
- readsPrec = _A_ 1 _U_ 02 _N_ _S_ "A" {_A_ 0 _U_ 2 _N_ _N_ _N_ _N_} _N_ _N_,
- showsPrec = _A_ 3 _U_ 012 _N_ _S_ "AU(P)L" {_A_ 2 _U_ 22 _N_ _N_ _N_ _N_} _N_ _N_,
- readList = _A_ 0 _U_ 2 _N_ _N_ _N_ _N_,
- showList = _A_ 1 _U_ 22 _N_ _N_ _N_ _N_ #-}
+ readsPrec = { _A_ 1 _U_ 02 _N_ _S_ "A" {_A_ 0 _U_ 2 _N_ _N_ _N_ _N_} _N_ _N_ },
+ showsPrec = { _A_ 3 _U_ 012 _N_ _S_ "AU(P)L" {_A_ 2 _U_ 22 _N_ _N_ _N_ _N_} _N_ _N_ },
+ readList = { _A_ 0 _U_ 2 _N_ _N_ _N_ _N_ },
+ showList = { _A_ 1 _U_ 22 _N_ _N_ _N_ _N_ } #-}
instance Text a => Text (Complex a)
{-# GHC_PRAGMA _M_ PreludeComplex {-dfun-} _A_ 1 _U_ 2 _N_ _N_ _N_ _N_ #-}
+instance Text (Complex Double)
+ {-# GHC_PRAGMA _M_ PreludeComplex {-dfun-} _A_ 0 _N_ _N_ _N_ _F_ _IF_ARGS_ 0 0 X 5 _!_ _TUP_4 [(Int -> [Char] -> [(Complex Double, [Char])]), (Int -> Complex Double -> [Char] -> [Char]), ([Char] -> [([Complex Double], [Char])]), ([Complex Double] -> [Char] -> [Char])] [_CONSTM_ Text readsPrec (Complex Double), _CONSTM_ Text showsPrec (Complex Double), _CONSTM_ Text readList (Complex Double), _CONSTM_ Text showList (Complex Double)] _N_
+ readsPrec = { _A_ 1 _U_ 12 _N_ _S_ "U(P)" {_A_ 1 _U_ 22 _N_ _N_ _N_ _N_} _N_ _N_ },
+ showsPrec = { _A_ 2 _U_ 112 _N_ _S_ "LU(LL)" {_A_ 3 _U_ 1222 _N_ _N_ _N_ _N_} _N_ _N_ },
+ readList = { _A_ 0 _U_ 2 _N_ _N_ _N_ _N_ },
+ showList = { _A_ 1 _U_ 12 _N_ _N_ _N_ _N_ } #-}
instance Text Double
{-# GHC_PRAGMA _M_ PreludeCore {-dfun-} _A_ 0 _N_ _N_ _N_ _F_ _IF_ARGS_ 0 0 X 5 _!_ _TUP_4 [(Int -> [Char] -> [(Double, [Char])]), (Int -> Double -> [Char] -> [Char]), ([Char] -> [([Double], [Char])]), ([Double] -> [Char] -> [Char])] [_CONSTM_ Text readsPrec (Double), _CONSTM_ Text showsPrec (Double), _CONSTM_ Text readList (Double), _CONSTM_ Text showList (Double)] _N_
- readsPrec = _A_ 2 _U_ 02 _N_ _S_ "AL" {_A_ 1 _U_ 2 _N_ _N_ _F_ _IF_ARGS_ 0 1 X 3 \ (u0 :: [Char]) -> _APP_ _SPEC_ _ORIG_ PreludeText readSigned [ (Double) ] [ _SPEC_ _ORIG_ PreludeText readFloat [ (Double) ], u0 ] _N_} _F_ _IF_ARGS_ 0 2 XX 3 \ (u0 :: Int) (u1 :: [Char]) -> _APP_ _SPEC_ _ORIG_ PreludeText readSigned [ (Double) ] [ _SPEC_ _ORIG_ PreludeText readFloat [ (Double) ], u1 ] _N_,
- showsPrec = _A_ 2 _U_ 212 _N_ _S_ "LU(P)" {_A_ 2 _U_ 222 _N_ _N_ _F_ _IF_ARGS_ 0 2 XX 4 \ (u0 :: Int) (u1 :: Double#) -> _APP_ _WRKR_ _SPEC_ _ORIG_ PreludeText showSigned [ (Double) ] [ _SPEC_ _ORIG_ PreludeText showFloat [ (Double) ], u0, u1 ] _N_} _F_ _IF_ARGS_ 0 2 XC 5 \ (u0 :: Int) (u1 :: Double) -> case u1 of { _ALG_ D# (u2 :: Double#) -> _APP_ _WRKR_ _SPEC_ _ORIG_ PreludeText showSigned [ (Double) ] [ _SPEC_ _ORIG_ PreludeText showFloat [ (Double) ], u0, u2 ]; _NO_DEFLT_ } _N_,
- readList = _A_ 0 _U_ 2 _N_ _N_ _N_ _N_,
- showList = _A_ 0 _U_ 12 _N_ _N_ _N_ _N_ #-}
+ readsPrec = { _A_ 2 _U_ 02 _N_ _S_ "AL" {_A_ 1 _U_ 2 _N_ _N_ _F_ _IF_ARGS_ 0 1 X 3 \ (u0 :: [Char]) -> _APP_ _SPEC_ _ORIG_ PreludeText readSigned [ (Double) ] [ _SPEC_ _ORIG_ PreludeText readFloat [ (Double) ], u0 ] _N_} _F_ _IF_ARGS_ 0 2 XX 3 \ (u0 :: Int) (u1 :: [Char]) -> _APP_ _SPEC_ _ORIG_ PreludeText readSigned [ (Double) ] [ _SPEC_ _ORIG_ PreludeText readFloat [ (Double) ], u1 ] _N_ },
+ showsPrec = { _A_ 2 _U_ 212 _N_ _S_ "LU(P)" {_A_ 2 _U_ 222 _N_ _N_ _F_ _IF_ARGS_ 0 2 XX 4 \ (u0 :: Int) (u1 :: Double#) -> _APP_ _WRKR_ _SPEC_ _ORIG_ PreludeText showSigned [ (Double) ] [ _SPEC_ _ORIG_ PreludeText showFloat [ (Double) ], u0, u1 ] _N_} _F_ _IF_ARGS_ 0 2 XC 5 \ (u0 :: Int) (u1 :: Double) -> case u1 of { _ALG_ D# (u2 :: Double#) -> _APP_ _WRKR_ _SPEC_ _ORIG_ PreludeText showSigned [ (Double) ] [ _SPEC_ _ORIG_ PreludeText showFloat [ (Double) ], u0, u2 ]; _NO_DEFLT_ } _N_ },
+ readList = { _A_ 0 _U_ 2 _N_ _N_ _N_ _N_ },
+ showList = { _A_ 1 _U_ 12 _N_ _N_ _N_ _N_ } #-}
instance Text Float
{-# GHC_PRAGMA _M_ PreludeCore {-dfun-} _A_ 0 _N_ _N_ _N_ _F_ _IF_ARGS_ 0 0 X 5 _!_ _TUP_4 [(Int -> [Char] -> [(Float, [Char])]), (Int -> Float -> [Char] -> [Char]), ([Char] -> [([Float], [Char])]), ([Float] -> [Char] -> [Char])] [_CONSTM_ Text readsPrec (Float), _CONSTM_ Text showsPrec (Float), _CONSTM_ Text readList (Float), _CONSTM_ Text showList (Float)] _N_
- readsPrec = _A_ 2 _U_ 02 _N_ _S_ "AL" {_A_ 1 _U_ 2 _N_ _N_ _N_ _N_} _N_ _N_,
- showsPrec = _A_ 1 _U_ 222 _N_ _N_ _N_ _N_,
- readList = _A_ 0 _U_ 2 _N_ _N_ _N_ _N_,
- showList = _A_ 0 _U_ 12 _N_ _N_ _N_ _N_ #-}
+ readsPrec = { _A_ 2 _U_ 02 _N_ _S_ "AL" {_A_ 1 _U_ 2 _N_ _N_ _N_ _N_} _N_ _N_ },
+ showsPrec = { _A_ 1 _U_ 222 _N_ _N_ _N_ _N_ },
+ readList = { _A_ 0 _U_ 2 _N_ _N_ _N_ _N_ },
+ showList = { _A_ 0 _U_ 12 _N_ _N_ _N_ _N_ } #-}
instance Text Int
{-# GHC_PRAGMA _M_ PreludeCore {-dfun-} _A_ 0 _N_ _N_ _N_ _F_ _IF_ARGS_ 0 0 X 5 _!_ _TUP_4 [(Int -> [Char] -> [(Int, [Char])]), (Int -> Int -> [Char] -> [Char]), ([Char] -> [([Int], [Char])]), ([Int] -> [Char] -> [Char])] [_CONSTM_ Text readsPrec (Int), _CONSTM_ Text showsPrec (Int), _CONSTM_ Text readList (Int), _CONSTM_ Text showList (Int)] _N_
- readsPrec = _A_ 2 _U_ 02 _N_ _S_ "AL" {_A_ 1 _U_ 2 _N_ _N_ _F_ _IF_ARGS_ 0 1 X 3 \ (u0 :: [Char]) -> _APP_ _SPEC_ _ORIG_ PreludeText readSigned [ (Int) ] [ _SPEC_ _ORIG_ PreludeText readDec [ (Int) ], u0 ] _N_} _F_ _IF_ARGS_ 0 2 XX 3 \ (u0 :: Int) (u1 :: [Char]) -> _APP_ _SPEC_ _ORIG_ PreludeText readSigned [ (Int) ] [ _SPEC_ _ORIG_ PreludeText readDec [ (Int) ], u1 ] _N_,
- showsPrec = _A_ 3 _U_ 212 _N_ _S_ "LU(P)L" {_A_ 3 _U_ 222 _N_ _N_ _N_ _N_} _N_ _N_,
- readList = _A_ 0 _U_ 2 _N_ _N_ _N_ _N_,
- showList = _A_ 0 _U_ 12 _N_ _N_ _N_ _N_ #-}
+ readsPrec = { _A_ 2 _U_ 02 _N_ _S_ "AL" {_A_ 1 _U_ 2 _N_ _N_ _F_ _IF_ARGS_ 0 1 X 3 \ (u0 :: [Char]) -> _APP_ _SPEC_ _ORIG_ PreludeText readSigned [ (Int) ] [ _SPEC_ _ORIG_ PreludeText readDec [ (Int) ], u0 ] _N_} _F_ _IF_ARGS_ 0 2 XX 3 \ (u0 :: Int) (u1 :: [Char]) -> _APP_ _SPEC_ _ORIG_ PreludeText readSigned [ (Int) ] [ _SPEC_ _ORIG_ PreludeText readDec [ (Int) ], u1 ] _N_ },
+ showsPrec = { _A_ 3 _U_ 212 _N_ _S_ "LU(P)L" {_A_ 3 _U_ 222 _N_ _N_ _N_ _N_} _N_ _N_ },
+ readList = { _A_ 0 _U_ 2 _N_ _N_ _N_ _N_ },
+ showList = { _A_ 1 _U_ 12 _N_ _N_ _N_ _N_ } #-}
instance Text Integer
{-# GHC_PRAGMA _M_ PreludeCore {-dfun-} _A_ 0 _N_ _N_ _N_ _F_ _IF_ARGS_ 0 0 X 5 _!_ _TUP_4 [(Int -> [Char] -> [(Integer, [Char])]), (Int -> Integer -> [Char] -> [Char]), ([Char] -> [([Integer], [Char])]), ([Integer] -> [Char] -> [Char])] [_CONSTM_ Text readsPrec (Integer), _CONSTM_ Text showsPrec (Integer), _CONSTM_ Text readList (Integer), _CONSTM_ Text showList (Integer)] _N_
- readsPrec = _A_ 2 _U_ 02 _N_ _S_ "AL" {_A_ 1 _U_ 2 _N_ _N_ _F_ _IF_ARGS_ 0 1 X 3 \ (u0 :: [Char]) -> _APP_ _SPEC_ _ORIG_ PreludeText readSigned [ (Integer) ] [ _SPEC_ _ORIG_ PreludeText readDec [ (Integer) ], u0 ] _N_} _F_ _IF_ARGS_ 0 2 XX 3 \ (u0 :: Int) (u1 :: [Char]) -> _APP_ _SPEC_ _ORIG_ PreludeText readSigned [ (Integer) ] [ _SPEC_ _ORIG_ PreludeText readDec [ (Integer) ], u1 ] _N_,
- showsPrec = _A_ 3 _U_ 212 _N_ _S_ "LU(PPP)L" {_A_ 5 _U_ 22222 _N_ _N_ _N_ _N_} _N_ _N_,
- readList = _A_ 0 _U_ 2 _N_ _N_ _N_ _N_,
- showList = _A_ 0 _U_ 12 _N_ _N_ _N_ _N_ #-}
+ readsPrec = { _A_ 2 _U_ 02 _N_ _S_ "AL" {_A_ 1 _U_ 2 _N_ _N_ _F_ _IF_ARGS_ 0 1 X 3 \ (u0 :: [Char]) -> _APP_ _SPEC_ _ORIG_ PreludeText readSigned [ (Integer) ] [ _SPEC_ _ORIG_ PreludeText readDec [ (Integer) ], u0 ] _N_} _F_ _IF_ARGS_ 0 2 XX 3 \ (u0 :: Int) (u1 :: [Char]) -> _APP_ _SPEC_ _ORIG_ PreludeText readSigned [ (Integer) ] [ _SPEC_ _ORIG_ PreludeText readDec [ (Integer) ], u1 ] _N_ },
+ showsPrec = { _A_ 3 _U_ 212 _N_ _S_ "LU(PPP)L" {_A_ 5 _U_ 22222 _N_ _N_ _N_ _N_} _N_ _N_ },
+ readList = { _A_ 0 _U_ 2 _N_ _N_ _N_ _N_ },
+ showList = { _A_ 1 _U_ 12 _N_ _N_ _N_ _N_ } #-}
instance Integral a => Text (Ratio a)
{-# GHC_PRAGMA _M_ PreludeRatio {-dfun-} _A_ 1 _U_ 2 _N_ _N_ _N_ _N_ #-}
instance Text (Ratio Integer)
{-# GHC_PRAGMA _M_ PreludeRatio {-dfun-} _A_ 0 _N_ _N_ _N_ _F_ _IF_ARGS_ 0 0 X 5 _!_ _TUP_4 [(Int -> [Char] -> [(Ratio Integer, [Char])]), (Int -> Ratio Integer -> [Char] -> [Char]), ([Char] -> [([Ratio Integer], [Char])]), ([Ratio Integer] -> [Char] -> [Char])] [_CONSTM_ Text readsPrec (Ratio Integer), _CONSTM_ Text showsPrec (Ratio Integer), _CONSTM_ Text readList (Ratio Integer), _CONSTM_ Text showList (Ratio Integer)] _N_
- readsPrec = _A_ 1 _U_ 12 _N_ _S_ "U(P)" {_A_ 1 _U_ 22 _N_ _N_ _N_ _N_} _N_ _N_,
- showsPrec = _A_ 2 _U_ 112 _N_ _S_ "LU(LL)" {_A_ 3 _U_ 1222 _N_ _N_ _N_ _N_} _N_ _N_,
- readList = _A_ 0 _U_ 2 _N_ _N_ _N_ _N_,
- showList = _A_ 0 _U_ 12 _N_ _N_ _N_ _N_ #-}
+ readsPrec = { _A_ 1 _U_ 12 _N_ _S_ "U(P)" {_A_ 1 _U_ 22 _N_ _N_ _N_ _N_} _N_ _N_ },
+ showsPrec = { _A_ 2 _U_ 112 _N_ _S_ "LU(LL)" {_A_ 3 _U_ 1222 _N_ _N_ _N_ _N_} _N_ _N_ },
+ readList = { _A_ 0 _U_ 2 _N_ _N_ _N_ _N_ },
+ showList = { _A_ 1 _U_ 12 _N_ _N_ _N_ _N_ } #-}
instance Text a => Text [a]
{-# GHC_PRAGMA _M_ PreludeBuiltin {-dfun-} _A_ 1 _U_ 2 _N_ _N_ _N_ _N_ #-}
+instance Text [Bool]
+ {-# GHC_PRAGMA _M_ PreludeBuiltin {-dfun-} _A_ 0 _N_ _N_ _N_ _F_ _IF_ARGS_ 0 0 X 5 _!_ _TUP_4 [(Int -> [Char] -> [([Bool], [Char])]), (Int -> [Bool] -> [Char] -> [Char]), ([Char] -> [([[Bool]], [Char])]), ([[Bool]] -> [Char] -> [Char])] [_CONSTM_ Text readsPrec ([Bool]), _CONSTM_ Text showsPrec ([Bool]), _CONSTM_ Text readList ([Bool]), _CONSTM_ Text showList ([Bool])] _N_
+ readsPrec = { _A_ 1 _U_ 02 _N_ _S_ "A" {_A_ 0 _U_ 2 _N_ _N_ _F_ _IF_ARGS_ 0 0 X 1 _CONSTM_ Text readList (Bool) _N_} _F_ _IF_ARGS_ 0 1 X 1 \ (u0 :: Int) -> _CONSTM_ Text readList (Bool) _N_ },
+ showsPrec = { _A_ 2 _U_ 012 _N_ _S_ "AS" {_A_ 1 _U_ 12 _N_ _N_ _F_ _IF_ARGS_ 0 1 X 3 \ (u0 :: [Bool]) -> _APP_ _TYAPP_ _ORIG_ PreludeCore _showList { Bool } [ _WRKR_ _CONSTM_ Text showsPrec (Bool), u0 ] _N_} _F_ _IF_ARGS_ 0 2 XX 3 \ (u0 :: Int) (u1 :: [Bool]) -> _APP_ _TYAPP_ _ORIG_ PreludeCore _showList { Bool } [ _WRKR_ _CONSTM_ Text showsPrec (Bool), u1 ] _N_ },
+ readList = { _A_ 0 _U_ 2 _N_ _N_ _N_ _N_ },
+ showList = { _A_ 1 _U_ 12 _N_ _N_ _N_ _N_ } #-}
instance Text [Char]
{-# GHC_PRAGMA _M_ PreludeBuiltin {-dfun-} _A_ 0 _N_ _N_ _N_ _F_ _IF_ARGS_ 0 0 X 5 _!_ _TUP_4 [(Int -> [Char] -> [([Char], [Char])]), (Int -> [Char] -> [Char] -> [Char]), ([Char] -> [([[Char]], [Char])]), ([[Char]] -> [Char] -> [Char])] [_CONSTM_ Text readsPrec ([Char]), _CONSTM_ Text showsPrec ([Char]), _CONSTM_ Text readList ([Char]), _CONSTM_ Text showList ([Char])] _N_
- readsPrec = _A_ 1 _U_ 02 _N_ _S_ "A" {_A_ 0 _U_ 2 _N_ _N_ _F_ _IF_ARGS_ 0 0 X 1 _CONSTM_ Text readList (Char) _N_} _F_ _IF_ARGS_ 0 1 X 1 \ (u0 :: Int) -> _CONSTM_ Text readList (Char) _N_,
- showsPrec = _A_ 2 _U_ 022 _N_ _S_ "AL" {_A_ 1 _U_ 22 _N_ _N_ _F_ _IF_ARGS_ 0 0 X 1 _CONSTM_ Text showList (Char) _N_} _F_ _IF_ARGS_ 0 2 XX 2 \ (u0 :: Int) (u1 :: [Char]) -> _APP_ _CONSTM_ Text showList (Char) [ u1 ] _N_,
- readList = _A_ 0 _U_ 2 _N_ _N_ _N_ _N_,
- showList = _A_ 0 _U_ 12 _N_ _N_ _N_ _N_ #-}
+ readsPrec = { _A_ 1 _U_ 02 _N_ _S_ "A" {_A_ 0 _U_ 2 _N_ _N_ _F_ _IF_ARGS_ 0 0 X 1 _CONSTM_ Text readList (Char) _N_} _F_ _IF_ARGS_ 0 1 X 1 \ (u0 :: Int) -> _CONSTM_ Text readList (Char) _N_ },
+ showsPrec = { _A_ 2 _U_ 022 _N_ _S_ "AL" {_A_ 1 _U_ 22 _N_ _N_ _F_ _IF_ARGS_ 0 0 X 1 _CONSTM_ Text showList (Char) _N_} _F_ _IF_ARGS_ 0 2 XX 2 \ (u0 :: Int) (u1 :: [Char]) -> _APP_ _CONSTM_ Text showList (Char) [ u1 ] _N_ },
+ readList = { _A_ 0 _U_ 2 _N_ _N_ _N_ _N_ },
+ showList = { _A_ 1 _U_ 12 _N_ _N_ _F_ _IF_ARGS_ 0 1 X 3 \ (u0 :: [[Char]]) -> _APP_ _TYAPP_ _ORIG_ PreludeCore _showList { [Char] } [ _CONSTM_ Text showList (Char), u0 ] _N_ } #-}
+instance Text [Complex Double]
+ {-# GHC_PRAGMA _M_ PreludeBuiltin {-dfun-} _A_ 0 _N_ _N_ _N_ _F_ _IF_ARGS_ 0 0 X 5 _!_ _TUP_4 [(Int -> [Char] -> [([Complex Double], [Char])]), (Int -> [Complex Double] -> [Char] -> [Char]), ([Char] -> [([[Complex Double]], [Char])]), ([[Complex Double]] -> [Char] -> [Char])] [_CONSTM_ Text readsPrec ([Complex Double]), _CONSTM_ Text showsPrec ([Complex Double]), _CONSTM_ Text readList ([Complex Double]), _CONSTM_ Text showList ([Complex Double])] _N_
+ readsPrec = { _A_ 1 _U_ 02 _N_ _S_ "A" {_A_ 0 _U_ 2 _N_ _N_ _F_ _IF_ARGS_ 0 0 X 1 _CONSTM_ Text readList (Complex Double) _N_} _F_ _IF_ARGS_ 0 1 X 1 \ (u0 :: Int) -> _CONSTM_ Text readList (Complex Double) _N_ },
+ showsPrec = { _A_ 2 _U_ 022 _N_ _S_ "AL" {_A_ 1 _U_ 22 _N_ _N_ _F_ _IF_ARGS_ 0 0 X 1 _CONSTM_ Text showList (Complex Double) _N_} _F_ _IF_ARGS_ 0 2 XX 2 \ (u0 :: Int) (u1 :: [Complex Double]) -> _APP_ _CONSTM_ Text showList (Complex Double) [ u1 ] _N_ },
+ readList = { _A_ 0 _U_ 2 _N_ _N_ _N_ _N_ },
+ showList = { _A_ 1 _U_ 12 _N_ _N_ _F_ _IF_ARGS_ 0 1 X 3 \ (u0 :: [[Complex Double]]) -> _APP_ _TYAPP_ _ORIG_ PreludeCore _showList { [Complex Double] } [ _CONSTM_ Text showList (Complex Double), u0 ] _N_ } #-}
+instance Text [Double]
+ {-# GHC_PRAGMA _M_ PreludeBuiltin {-dfun-} _A_ 0 _N_ _N_ _N_ _F_ _IF_ARGS_ 0 0 X 5 _!_ _TUP_4 [(Int -> [Char] -> [([Double], [Char])]), (Int -> [Double] -> [Char] -> [Char]), ([Char] -> [([[Double]], [Char])]), ([[Double]] -> [Char] -> [Char])] [_CONSTM_ Text readsPrec ([Double]), _CONSTM_ Text showsPrec ([Double]), _CONSTM_ Text readList ([Double]), _CONSTM_ Text showList ([Double])] _N_
+ readsPrec = { _A_ 1 _U_ 02 _N_ _S_ "A" {_A_ 0 _U_ 2 _N_ _N_ _F_ _IF_ARGS_ 0 0 X 1 _CONSTM_ Text readList (Double) _N_} _F_ _IF_ARGS_ 0 1 X 1 \ (u0 :: Int) -> _CONSTM_ Text readList (Double) _N_ },
+ showsPrec = { _A_ 2 _U_ 022 _N_ _S_ "AL" {_A_ 1 _U_ 22 _N_ _N_ _F_ _IF_ARGS_ 0 0 X 1 _CONSTM_ Text showList (Double) _N_} _F_ _IF_ARGS_ 0 2 XX 2 \ (u0 :: Int) (u1 :: [Double]) -> _APP_ _CONSTM_ Text showList (Double) [ u1 ] _N_ },
+ readList = { _A_ 0 _U_ 2 _N_ _N_ _N_ _N_ },
+ showList = { _A_ 1 _U_ 12 _N_ _N_ _F_ _IF_ARGS_ 0 1 X 3 \ (u0 :: [[Double]]) -> _APP_ _TYAPP_ _ORIG_ PreludeCore _showList { [Double] } [ _CONSTM_ Text showList (Double), u0 ] _N_ } #-}
instance Text [Int]
{-# GHC_PRAGMA _M_ PreludeBuiltin {-dfun-} _A_ 0 _N_ _N_ _N_ _F_ _IF_ARGS_ 0 0 X 5 _!_ _TUP_4 [(Int -> [Char] -> [([Int], [Char])]), (Int -> [Int] -> [Char] -> [Char]), ([Char] -> [([[Int]], [Char])]), ([[Int]] -> [Char] -> [Char])] [_CONSTM_ Text readsPrec ([Int]), _CONSTM_ Text showsPrec ([Int]), _CONSTM_ Text readList ([Int]), _CONSTM_ Text showList ([Int])] _N_
- readsPrec = _A_ 1 _U_ 02 _N_ _S_ "A" {_A_ 0 _U_ 2 _N_ _N_ _F_ _IF_ARGS_ 0 0 X 1 _CONSTM_ Text readList (Int) _N_} _F_ _IF_ARGS_ 0 1 X 1 \ (u0 :: Int) -> _CONSTM_ Text readList (Int) _N_,
- showsPrec = _A_ 1 _U_ 022 _N_ _S_ "A" {_A_ 0 _U_ 22 _N_ _N_ _F_ _IF_ARGS_ 0 0 X 1 _CONSTM_ Text showList (Int) _N_} _F_ _IF_ARGS_ 0 1 X 1 \ (u0 :: Int) -> _CONSTM_ Text showList (Int) _N_,
- readList = _A_ 0 _U_ 2 _N_ _N_ _N_ _N_,
- showList = _A_ 0 _U_ 12 _N_ _N_ _N_ _N_ #-}
+ readsPrec = { _A_ 1 _U_ 02 _N_ _S_ "A" {_A_ 0 _U_ 2 _N_ _N_ _F_ _IF_ARGS_ 0 0 X 1 _CONSTM_ Text readList (Int) _N_} _F_ _IF_ARGS_ 0 1 X 1 \ (u0 :: Int) -> _CONSTM_ Text readList (Int) _N_ },
+ showsPrec = { _A_ 2 _U_ 022 _N_ _S_ "AL" {_A_ 1 _U_ 22 _N_ _N_ _F_ _IF_ARGS_ 0 0 X 1 _CONSTM_ Text showList (Int) _N_} _F_ _IF_ARGS_ 0 2 XX 2 \ (u0 :: Int) (u1 :: [Int]) -> _APP_ _CONSTM_ Text showList (Int) [ u1 ] _N_ },
+ readList = { _A_ 0 _U_ 2 _N_ _N_ _N_ _N_ },
+ showList = { _A_ 1 _U_ 12 _N_ _N_ _F_ _IF_ARGS_ 0 1 X 3 \ (u0 :: [[Int]]) -> _APP_ _TYAPP_ _ORIG_ PreludeCore _showList { [Int] } [ _CONSTM_ Text showList (Int), u0 ] _N_ } #-}
+instance Text [Integer]
+ {-# GHC_PRAGMA _M_ PreludeBuiltin {-dfun-} _A_ 0 _N_ _N_ _N_ _F_ _IF_ARGS_ 0 0 X 5 _!_ _TUP_4 [(Int -> [Char] -> [([Integer], [Char])]), (Int -> [Integer] -> [Char] -> [Char]), ([Char] -> [([[Integer]], [Char])]), ([[Integer]] -> [Char] -> [Char])] [_CONSTM_ Text readsPrec ([Integer]), _CONSTM_ Text showsPrec ([Integer]), _CONSTM_ Text readList ([Integer]), _CONSTM_ Text showList ([Integer])] _N_
+ readsPrec = { _A_ 1 _U_ 02 _N_ _S_ "A" {_A_ 0 _U_ 2 _N_ _N_ _F_ _IF_ARGS_ 0 0 X 1 _CONSTM_ Text readList (Integer) _N_} _F_ _IF_ARGS_ 0 1 X 1 \ (u0 :: Int) -> _CONSTM_ Text readList (Integer) _N_ },
+ showsPrec = { _A_ 2 _U_ 022 _N_ _S_ "AL" {_A_ 1 _U_ 22 _N_ _N_ _F_ _IF_ARGS_ 0 0 X 1 _CONSTM_ Text showList (Integer) _N_} _F_ _IF_ARGS_ 0 2 XX 2 \ (u0 :: Int) (u1 :: [Integer]) -> _APP_ _CONSTM_ Text showList (Integer) [ u1 ] _N_ },
+ readList = { _A_ 0 _U_ 2 _N_ _N_ _N_ _N_ },
+ showList = { _A_ 1 _U_ 12 _N_ _N_ _F_ _IF_ARGS_ 0 1 X 3 \ (u0 :: [[Integer]]) -> _APP_ _TYAPP_ _ORIG_ PreludeCore _showList { [Integer] } [ _CONSTM_ Text showList (Integer), u0 ] _N_ } #-}
+instance Text [[Char]]
+ {-# GHC_PRAGMA _M_ PreludeBuiltin {-dfun-} _A_ 0 _N_ _N_ _N_ _F_ _IF_ARGS_ 0 0 X 5 _!_ _TUP_4 [(Int -> [Char] -> [([[Char]], [Char])]), (Int -> [[Char]] -> [Char] -> [Char]), ([Char] -> [([[[Char]]], [Char])]), ([[[Char]]] -> [Char] -> [Char])] [_CONSTM_ Text readsPrec ([[Char]]), _CONSTM_ Text showsPrec ([[Char]]), _CONSTM_ Text readList ([[Char]]), _CONSTM_ Text showList ([[Char]])] _N_
+ readsPrec = { _A_ 1 _U_ 02 _N_ _S_ "A" {_A_ 0 _U_ 2 _N_ _N_ _F_ _IF_ARGS_ 0 0 X 1 _CONSTM_ Text readList ([Char]) _N_} _F_ _IF_ARGS_ 0 1 X 1 \ (u0 :: Int) -> _CONSTM_ Text readList ([Char]) _N_ },
+ showsPrec = { _A_ 2 _U_ 012 _N_ _S_ "AS" {_A_ 1 _U_ 12 _N_ _N_ _F_ _IF_ARGS_ 0 1 X 3 \ (u0 :: [[Char]]) -> _APP_ _TYAPP_ _ORIG_ PreludeCore _showList { [Char] } [ _CONSTM_ Text showList (Char), u0 ] _N_} _F_ _IF_ARGS_ 0 2 XX 2 \ (u0 :: Int) (u1 :: [[Char]]) -> _APP_ _CONSTM_ Text showList ([Char]) [ u1 ] _N_ },
+ readList = { _A_ 0 _U_ 2 _N_ _N_ _N_ _N_ },
+ showList = { _A_ 1 _U_ 12 _N_ _N_ _N_ _N_ } #-}
+instance Text [[Int]]
+ {-# GHC_PRAGMA _M_ PreludeBuiltin {-dfun-} _A_ 0 _N_ _N_ _N_ _F_ _IF_ARGS_ 0 0 X 5 _!_ _TUP_4 [(Int -> [Char] -> [([[Int]], [Char])]), (Int -> [[Int]] -> [Char] -> [Char]), ([Char] -> [([[[Int]]], [Char])]), ([[[Int]]] -> [Char] -> [Char])] [_CONSTM_ Text readsPrec ([[Int]]), _CONSTM_ Text showsPrec ([[Int]]), _CONSTM_ Text readList ([[Int]]), _CONSTM_ Text showList ([[Int]])] _N_
+ readsPrec = { _A_ 1 _U_ 02 _N_ _S_ "A" {_A_ 0 _U_ 2 _N_ _N_ _F_ _IF_ARGS_ 0 0 X 1 _CONSTM_ Text readList ([Int]) _N_} _F_ _IF_ARGS_ 0 1 X 1 \ (u0 :: Int) -> _CONSTM_ Text readList ([Int]) _N_ },
+ showsPrec = { _A_ 2 _U_ 012 _N_ _S_ "AS" {_A_ 1 _U_ 12 _N_ _N_ _F_ _IF_ARGS_ 0 1 X 3 \ (u0 :: [[Int]]) -> _APP_ _TYAPP_ _ORIG_ PreludeCore _showList { [Int] } [ _CONSTM_ Text showList (Int), u0 ] _N_} _F_ _IF_ARGS_ 0 2 XX 2 \ (u0 :: Int) (u1 :: [[Int]]) -> _APP_ _CONSTM_ Text showList ([Int]) [ u1 ] _N_ },
+ readList = { _A_ 0 _U_ 2 _N_ _N_ _N_ _N_ },
+ showList = { _A_ 1 _U_ 12 _N_ _N_ _N_ _N_ } #-}
instance Text _PackedString
{-# GHC_PRAGMA _M_ PreludePS {-dfun-} _A_ 0 _N_ _N_ _N_ _F_ _IF_ARGS_ 0 0 X 5 _!_ _TUP_4 [(Int -> [Char] -> [(_PackedString, [Char])]), (Int -> _PackedString -> [Char] -> [Char]), ([Char] -> [([_PackedString], [Char])]), ([_PackedString] -> [Char] -> [Char])] [_CONSTM_ Text readsPrec (_PackedString), _CONSTM_ Text showsPrec (_PackedString), _CONSTM_ Text readList (_PackedString), _CONSTM_ Text showList (_PackedString)] _N_
- readsPrec = _A_ 2 _U_ 02 _N_ _S_ _!_ _F_ _IF_ARGS_ 0 2 XX 3 \ (u0 :: Int) (u1 :: [Char]) -> _APP_ _TYAPP_ error { ([Char] -> [(_PackedString, [Char])]) } [ _NOREP_S_ "readsPrec: _PackedString: ToDo", u1 ] _N_,
- showsPrec = _A_ 3 _U_ 012 _N_ _S_ "ALL" {_A_ 2 _U_ 12 _N_ _N_ _N_ _N_} _F_ _IF_ARGS_ 0 3 XXX 6 \ (u0 :: Int) (u1 :: _PackedString) (u2 :: [Char]) -> let {(u3 :: [Char]) = _APP_ _ORIG_ PreludePS _unpackPS [ u1 ]} in _APP_ _CONSTM_ Text showList (Char) [ u3, u2 ] _N_,
- readList = _A_ 0 _U_ 2 _N_ _N_ _N_ _N_,
- showList = _A_ 0 _U_ 12 _N_ _N_ _N_ _N_ #-}
+ readsPrec = { _A_ 2 _U_ 02 _N_ _S_ _!_ _N_ _N_ },
+ showsPrec = { _A_ 3 _U_ 012 _N_ _S_ "ALL" {_A_ 2 _U_ 12 _N_ _N_ _N_ _N_} _F_ _IF_ARGS_ 0 3 XXX 6 \ (u0 :: Int) (u1 :: _PackedString) (u2 :: [Char]) -> let {(u3 :: [Char]) = _APP_ _ORIG_ PreludePS _unpackPS [ u1 ]} in _APP_ _CONSTM_ Text showList (Char) [ u3, u2 ] _N_ },
+ readList = { _A_ 0 _U_ 2 _N_ _N_ _N_ _N_ },
+ showList = { _A_ 1 _U_ 12 _N_ _N_ _F_ _IF_ARGS_ 0 1 X 3 \ (u0 :: [_PackedString]) -> _APP_ _TYAPP_ _ORIG_ PreludeCore _showList { _PackedString } [ _WRKR_ _CONSTM_ Text showsPrec (_PackedString), u0 ] _N_ } #-}
instance _CCallable Char
{-# GHC_PRAGMA _M_ PreludeCore {-dfun-} _A_ 0 _N_ _N_ _N_ _F_ _IF_ARGS_ 0 0 X 1 _!_ _TUP_0 [] [] _N_ #-}
instance _CCallable Double
{-# GHC_PRAGMA _M_ PreludeCore {-dfun-} _A_ 0 _N_ _N_ _N_ _F_ _IF_ARGS_ 0 0 X 1 _!_ _TUP_0 [] [] _N_ #-}
instance _CCallable (_MutableByteArray a b)
{-# GHC_PRAGMA _M_ PreludeGlaST {-dfun-} _A_ 0 _N_ _N_ _N_ _F_ _IF_ARGS_ 2 0 X 1 _/\_ u0 u1 -> _!_ _TUP_0 [] [] _N_ #-}
+instance _CCallable (_StablePtr a)
+ {-# GHC_PRAGMA _M_ PreludeCore {-dfun-} _A_ 0 _N_ _N_ _N_ _F_ _IF_ARGS_ 1 0 X 1 _/\_ u0 -> _!_ _TUP_0 [] [] _N_ #-}
instance _CCallable _Word
{-# GHC_PRAGMA _M_ PreludeCore {-dfun-} _A_ 0 _N_ _N_ _N_ _F_ _IF_ARGS_ 0 0 X 1 _!_ _TUP_0 [] [] _N_ #-}
instance _CReturnable ()
{-# GHC_PRAGMA _M_ PreludeCore {-dfun-} _A_ 0 _N_ _N_ _N_ _F_ _IF_ARGS_ 0 0 X 1 _!_ _TUP_0 [] [] _N_ #-}
instance _CReturnable _MallocPtr
{-# GHC_PRAGMA _M_ PreludeCore {-dfun-} _A_ 0 _N_ _N_ _N_ _F_ _IF_ARGS_ 0 0 X 1 _!_ _TUP_0 [] [] _N_ #-}
+instance _CReturnable (_StablePtr a)
+ {-# GHC_PRAGMA _M_ PreludeCore {-dfun-} _A_ 0 _N_ _N_ _N_ _F_ _IF_ARGS_ 1 0 X 1 _/\_ u0 -> _!_ _TUP_0 [] [] _N_ #-}
instance _CReturnable _Word
{-# GHC_PRAGMA _M_ PreludeCore {-dfun-} _A_ 0 _N_ _N_ _N_ _F_ _IF_ARGS_ 0 0 X 1 _!_ _TUP_0 [] [] _N_ #-}
-{-# GHC_PRAGMA INTERFACE VERSION 5 #-}
+{-# GHC_PRAGMA INTERFACE VERSION 6 #-}
interface PreludeCore where
import PreludeArray(Array, Assoc(..), _ByteArray)
import PreludeBuiltin(Bin, Char(..), Double(..), Float(..), Int(..), Integer(..), List(..), Tuple0, Tuple2, Tuple3, Tuple4, Tuple5, _Addr(..), _CMP_TAG(..), _Word(..))
class Binary a where
readBin :: Bin -> (a, Bin)
{-# GHC_PRAGMA {-meth-} _A_ 1 _U_ 12 _N_ _S_ "S" _F_ _IF_ARGS_ 1 1 C 2 _/\_ u0 -> \ (u1 :: (Bin -> (u0, Bin), u0 -> Bin -> Bin)) -> case u1 of { _ALG_ _TUP_2 (u2 :: Bin -> (u0, Bin)) (u3 :: u0 -> Bin -> Bin) -> u2; _NO_DEFLT_ } _N_
- {-defm-} _A_ 2 _U_ 02 _N_ _S_ _!_ _F_ _IF_ARGS_ 1 2 XX 3 _/\_ u0 -> \ (u1 :: {{Binary u0}}) (u2 :: Bin) -> _APP_ _TYAPP_ patError# { (Bin -> (u0, Bin)) } [ _NOREP_S_ "%DPreludeCore.Binary.readBin\"", u2 ] _N_ #-}
+ {-defm-} _A_ 2 _U_ 02 _N_ _S_ _!_ _N_ _N_ #-}
showBin :: a -> Bin -> Bin
{-# GHC_PRAGMA {-meth-} _A_ 1 _U_ 122 _N_ _S_ "S" _F_ _IF_ARGS_ 1 1 C 2 _/\_ u0 -> \ (u1 :: (Bin -> (u0, Bin), u0 -> Bin -> Bin)) -> case u1 of { _ALG_ _TUP_2 (u2 :: Bin -> (u0, Bin)) (u3 :: u0 -> Bin -> Bin) -> u3; _NO_DEFLT_ } _N_
- {-defm-} _A_ 3 _U_ 022 _N_ _S_ _!_ _F_ _IF_ARGS_ 1 3 XXX 4 _/\_ u0 -> \ (u1 :: {{Binary u0}}) (u2 :: u0) (u3 :: Bin) -> _APP_ _TYAPP_ patError# { (u0 -> Bin -> Bin) } [ _NOREP_S_ "%DPreludeCore.Binary.showBin\"", u2, u3 ] _N_ #-}
+ {-defm-} _A_ 3 _U_ 022 _N_ _S_ _!_ _N_ _N_ #-}
class (Ord a) => Enum a {-# GHC_PRAGMA {-superdicts-} _A_ 1 _U_ 1 _N_ _S_ "S" _F_ _IF_ARGS_ 1 1 C 2 _/\_ u0 -> \ (u1 :: ({{Ord u0}}, u0 -> [u0], u0 -> u0 -> [u0], u0 -> u0 -> [u0], u0 -> u0 -> u0 -> [u0])) -> case u1 of { _ALG_ _TUP_5 (u2 :: {{Ord u0}}) (u3 :: u0 -> [u0]) (u4 :: u0 -> u0 -> [u0]) (u5 :: u0 -> u0 -> [u0]) (u6 :: u0 -> u0 -> u0 -> [u0]) -> u2; _NO_DEFLT_ } _N_ #-} where
enumFrom :: a -> [a]
{-# GHC_PRAGMA {-meth-} _A_ 1 _U_ 12 _N_ _S_ "S" _F_ _IF_ARGS_ 1 1 C 2 _/\_ u0 -> \ (u1 :: ({{Ord u0}}, u0 -> [u0], u0 -> u0 -> [u0], u0 -> u0 -> [u0], u0 -> u0 -> u0 -> [u0])) -> case u1 of { _ALG_ _TUP_5 (u2 :: {{Ord u0}}) (u3 :: u0 -> [u0]) (u4 :: u0 -> u0 -> [u0]) (u5 :: u0 -> u0 -> [u0]) (u6 :: u0 -> u0 -> u0 -> [u0]) -> u3; _NO_DEFLT_ } _N_
- {-defm-} _A_ 2 _U_ 02 _N_ _S_ _!_ _F_ _IF_ARGS_ 1 2 XX 3 _/\_ u0 -> \ (u1 :: {{Enum u0}}) (u2 :: u0) -> _APP_ _TYAPP_ patError# { (u0 -> [u0]) } [ _NOREP_S_ "%DPreludeCore.Enum.enumFrom\"", u2 ] _N_ #-}
+ {-defm-} _A_ 2 _U_ 02 _N_ _S_ _!_ _N_ _N_ #-}
enumFromThen :: a -> a -> [a]
{-# GHC_PRAGMA {-meth-} _A_ 1 _U_ 122 _N_ _S_ "S" _F_ _IF_ARGS_ 1 1 C 2 _/\_ u0 -> \ (u1 :: ({{Ord u0}}, u0 -> [u0], u0 -> u0 -> [u0], u0 -> u0 -> [u0], u0 -> u0 -> u0 -> [u0])) -> case u1 of { _ALG_ _TUP_5 (u2 :: {{Ord u0}}) (u3 :: u0 -> [u0]) (u4 :: u0 -> u0 -> [u0]) (u5 :: u0 -> u0 -> [u0]) (u6 :: u0 -> u0 -> u0 -> [u0]) -> u4; _NO_DEFLT_ } _N_
- {-defm-} _A_ 3 _U_ 022 _N_ _S_ _!_ _F_ _IF_ARGS_ 1 3 XXX 4 _/\_ u0 -> \ (u1 :: {{Enum u0}}) (u2 :: u0) (u3 :: u0) -> _APP_ _TYAPP_ patError# { (u0 -> u0 -> [u0]) } [ _NOREP_S_ "%DPreludeCore.Enum.enumFromThen\"", u2, u3 ] _N_ #-}
+ {-defm-} _A_ 3 _U_ 022 _N_ _S_ _!_ _N_ _N_ #-}
enumFromTo :: a -> a -> [a]
{-# GHC_PRAGMA {-meth-} _A_ 1 _U_ 122 _N_ _S_ "S" _F_ _IF_ARGS_ 1 1 C 2 _/\_ u0 -> \ (u1 :: ({{Ord u0}}, u0 -> [u0], u0 -> u0 -> [u0], u0 -> u0 -> [u0], u0 -> u0 -> u0 -> [u0])) -> case u1 of { _ALG_ _TUP_5 (u2 :: {{Ord u0}}) (u3 :: u0 -> [u0]) (u4 :: u0 -> u0 -> [u0]) (u5 :: u0 -> u0 -> [u0]) (u6 :: u0 -> u0 -> u0 -> [u0]) -> u5; _NO_DEFLT_ } _N_
{-defm-} _A_ 3 _U_ 122 _N_ _S_ "SLL" _N_ _N_ #-}
class Eq a where
(==) :: a -> a -> Bool
{-# GHC_PRAGMA {-meth-} _A_ 1 _U_ 122 _N_ _S_ "S" _F_ _IF_ARGS_ 1 1 C 2 _/\_ u0 -> \ (u1 :: (u0 -> u0 -> Bool, u0 -> u0 -> Bool)) -> case u1 of { _ALG_ _TUP_2 (u2 :: u0 -> u0 -> Bool) (u3 :: u0 -> u0 -> Bool) -> u2; _NO_DEFLT_ } _N_
- {-defm-} _A_ 3 _U_ 022 _N_ _S_ _!_ _F_ _IF_ARGS_ 1 3 XXX 4 _/\_ u0 -> \ (u1 :: {{Eq u0}}) (u2 :: u0) (u3 :: u0) -> _APP_ _TYAPP_ patError# { (u0 -> u0 -> Bool) } [ _NOREP_S_ "%DPreludeCore.Eq.(==)\"", u2, u3 ] _N_ #-}
+ {-defm-} _A_ 3 _U_ 022 _N_ _S_ _!_ _N_ _N_ #-}
(/=) :: a -> a -> Bool
{-# GHC_PRAGMA {-meth-} _A_ 1 _U_ 122 _N_ _S_ "S" _F_ _IF_ARGS_ 1 1 C 2 _/\_ u0 -> \ (u1 :: (u0 -> u0 -> Bool, u0 -> u0 -> Bool)) -> case u1 of { _ALG_ _TUP_2 (u2 :: u0 -> u0 -> Bool) (u3 :: u0 -> u0 -> Bool) -> u3; _NO_DEFLT_ } _N_
{-defm-} _A_ 3 _U_ 122 _N_ _S_ "SLL" _N_ _N_ #-}
class (Fractional a) => Floating a {-# GHC_PRAGMA {-superdicts-} _A_ 1 _U_ 1 _N_ _S_ "S" _F_ _IF_ARGS_ 1 1 C 2 _/\_ u0 -> \ (u1 :: ({{Fractional u0}}, u0, u0 -> u0, u0 -> u0, u0 -> u0, u0 -> u0 -> u0, u0 -> u0 -> u0, u0 -> u0, u0 -> u0, u0 -> u0, u0 -> u0, u0 -> u0, u0 -> u0, u0 -> u0, u0 -> u0, u0 -> u0, u0 -> u0, u0 -> u0, u0 -> u0)) -> case u1 of { _ALG_ _TUP_19 (u2 :: {{Fractional u0}}) (u3 :: u0) (u4 :: u0 -> u0) (u5 :: u0 -> u0) (u6 :: u0 -> u0) (u7 :: u0 -> u0 -> u0) (u8 :: u0 -> u0 -> u0) (u9 :: u0 -> u0) (ua :: u0 -> u0) (ub :: u0 -> u0) (uc :: u0 -> u0) (ud :: u0 -> u0) (ue :: u0 -> u0) (uf :: u0 -> u0) (ug :: u0 -> u0) (uh :: u0 -> u0) (ui :: u0 -> u0) (uj :: u0 -> u0) (uk :: u0 -> u0) -> u2; _NO_DEFLT_ } _N_ #-} where
pi :: a
{-# GHC_PRAGMA {-meth-} _A_ 1 _U_ 1 _N_ _S_ "S" _F_ _IF_ARGS_ 1 1 C 2 _/\_ u0 -> \ (u1 :: ({{Fractional u0}}, u0, u0 -> u0, u0 -> u0, u0 -> u0, u0 -> u0 -> u0, u0 -> u0 -> u0, u0 -> u0, u0 -> u0, u0 -> u0, u0 -> u0, u0 -> u0, u0 -> u0, u0 -> u0, u0 -> u0, u0 -> u0, u0 -> u0, u0 -> u0, u0 -> u0)) -> case u1 of { _ALG_ _TUP_19 (u2 :: {{Fractional u0}}) (u3 :: u0) (u4 :: u0 -> u0) (u5 :: u0 -> u0) (u6 :: u0 -> u0) (u7 :: u0 -> u0 -> u0) (u8 :: u0 -> u0 -> u0) (u9 :: u0 -> u0) (ua :: u0 -> u0) (ub :: u0 -> u0) (uc :: u0 -> u0) (ud :: u0 -> u0) (ue :: u0 -> u0) (uf :: u0 -> u0) (ug :: u0 -> u0) (uh :: u0 -> u0) (ui :: u0 -> u0) (uj :: u0 -> u0) (uk :: u0 -> u0) -> u3; _NO_DEFLT_ } _N_
- {-defm-} _A_ 1 _U_ 0 _N_ _S_ _!_ _F_ _IF_ARGS_ 1 1 X 2 _/\_ u0 -> \ (u1 :: {{Floating u0}}) -> _APP_ _TYAPP_ patError# { u0 } [ _NOREP_S_ "%DPreludeCore.Floating.pi\"" ] _N_ #-}
+ {-defm-} _A_ 1 _U_ 0 _N_ _S_ _!_ _N_ _N_ #-}
exp :: a -> a
{-# GHC_PRAGMA {-meth-} _A_ 1 _U_ 12 _N_ _S_ "S" _F_ _IF_ARGS_ 1 1 C 2 _/\_ u0 -> \ (u1 :: ({{Fractional u0}}, u0, u0 -> u0, u0 -> u0, u0 -> u0, u0 -> u0 -> u0, u0 -> u0 -> u0, u0 -> u0, u0 -> u0, u0 -> u0, u0 -> u0, u0 -> u0, u0 -> u0, u0 -> u0, u0 -> u0, u0 -> u0, u0 -> u0, u0 -> u0, u0 -> u0)) -> case u1 of { _ALG_ _TUP_19 (u2 :: {{Fractional u0}}) (u3 :: u0) (u4 :: u0 -> u0) (u5 :: u0 -> u0) (u6 :: u0 -> u0) (u7 :: u0 -> u0 -> u0) (u8 :: u0 -> u0 -> u0) (u9 :: u0 -> u0) (ua :: u0 -> u0) (ub :: u0 -> u0) (uc :: u0 -> u0) (ud :: u0 -> u0) (ue :: u0 -> u0) (uf :: u0 -> u0) (ug :: u0 -> u0) (uh :: u0 -> u0) (ui :: u0 -> u0) (uj :: u0 -> u0) (uk :: u0 -> u0) -> u4; _NO_DEFLT_ } _N_
- {-defm-} _A_ 2 _U_ 02 _N_ _S_ _!_ _F_ _IF_ARGS_ 1 2 XX 3 _/\_ u0 -> \ (u1 :: {{Floating u0}}) (u2 :: u0) -> _APP_ _TYAPP_ patError# { (u0 -> u0) } [ _NOREP_S_ "%DPreludeCore.Floating.exp\"", u2 ] _N_ #-}
+ {-defm-} _A_ 2 _U_ 02 _N_ _S_ _!_ _N_ _N_ #-}
log :: a -> a
{-# GHC_PRAGMA {-meth-} _A_ 1 _U_ 12 _N_ _S_ "S" _F_ _IF_ARGS_ 1 1 C 2 _/\_ u0 -> \ (u1 :: ({{Fractional u0}}, u0, u0 -> u0, u0 -> u0, u0 -> u0, u0 -> u0 -> u0, u0 -> u0 -> u0, u0 -> u0, u0 -> u0, u0 -> u0, u0 -> u0, u0 -> u0, u0 -> u0, u0 -> u0, u0 -> u0, u0 -> u0, u0 -> u0, u0 -> u0, u0 -> u0)) -> case u1 of { _ALG_ _TUP_19 (u2 :: {{Fractional u0}}) (u3 :: u0) (u4 :: u0 -> u0) (u5 :: u0 -> u0) (u6 :: u0 -> u0) (u7 :: u0 -> u0 -> u0) (u8 :: u0 -> u0 -> u0) (u9 :: u0 -> u0) (ua :: u0 -> u0) (ub :: u0 -> u0) (uc :: u0 -> u0) (ud :: u0 -> u0) (ue :: u0 -> u0) (uf :: u0 -> u0) (ug :: u0 -> u0) (uh :: u0 -> u0) (ui :: u0 -> u0) (uj :: u0 -> u0) (uk :: u0 -> u0) -> u5; _NO_DEFLT_ } _N_
- {-defm-} _A_ 2 _U_ 02 _N_ _S_ _!_ _F_ _IF_ARGS_ 1 2 XX 3 _/\_ u0 -> \ (u1 :: {{Floating u0}}) (u2 :: u0) -> _APP_ _TYAPP_ patError# { (u0 -> u0) } [ _NOREP_S_ "%DPreludeCore.Floating.log\"", u2 ] _N_ #-}
+ {-defm-} _A_ 2 _U_ 02 _N_ _S_ _!_ _N_ _N_ #-}
sqrt :: a -> a
{-# GHC_PRAGMA {-meth-} _A_ 1 _U_ 12 _N_ _S_ "S" _F_ _IF_ARGS_ 1 1 C 2 _/\_ u0 -> \ (u1 :: ({{Fractional u0}}, u0, u0 -> u0, u0 -> u0, u0 -> u0, u0 -> u0 -> u0, u0 -> u0 -> u0, u0 -> u0, u0 -> u0, u0 -> u0, u0 -> u0, u0 -> u0, u0 -> u0, u0 -> u0, u0 -> u0, u0 -> u0, u0 -> u0, u0 -> u0, u0 -> u0)) -> case u1 of { _ALG_ _TUP_19 (u2 :: {{Fractional u0}}) (u3 :: u0) (u4 :: u0 -> u0) (u5 :: u0 -> u0) (u6 :: u0 -> u0) (u7 :: u0 -> u0 -> u0) (u8 :: u0 -> u0 -> u0) (u9 :: u0 -> u0) (ua :: u0 -> u0) (ub :: u0 -> u0) (uc :: u0 -> u0) (ud :: u0 -> u0) (ue :: u0 -> u0) (uf :: u0 -> u0) (ug :: u0 -> u0) (uh :: u0 -> u0) (ui :: u0 -> u0) (uj :: u0 -> u0) (uk :: u0 -> u0) -> u6; _NO_DEFLT_ } _N_
{-defm-} _A_ 1 _U_ 12 _N_ _S_ "S" _N_ _N_ #-}
{-defm-} _A_ 3 _U_ 122 _N_ _S_ "SLL" _N_ _N_ #-}
sin :: a -> a
{-# GHC_PRAGMA {-meth-} _A_ 1 _U_ 12 _N_ _S_ "S" _F_ _IF_ARGS_ 1 1 C 2 _/\_ u0 -> \ (u1 :: ({{Fractional u0}}, u0, u0 -> u0, u0 -> u0, u0 -> u0, u0 -> u0 -> u0, u0 -> u0 -> u0, u0 -> u0, u0 -> u0, u0 -> u0, u0 -> u0, u0 -> u0, u0 -> u0, u0 -> u0, u0 -> u0, u0 -> u0, u0 -> u0, u0 -> u0, u0 -> u0)) -> case u1 of { _ALG_ _TUP_19 (u2 :: {{Fractional u0}}) (u3 :: u0) (u4 :: u0 -> u0) (u5 :: u0 -> u0) (u6 :: u0 -> u0) (u7 :: u0 -> u0 -> u0) (u8 :: u0 -> u0 -> u0) (u9 :: u0 -> u0) (ua :: u0 -> u0) (ub :: u0 -> u0) (uc :: u0 -> u0) (ud :: u0 -> u0) (ue :: u0 -> u0) (uf :: u0 -> u0) (ug :: u0 -> u0) (uh :: u0 -> u0) (ui :: u0 -> u0) (uj :: u0 -> u0) (uk :: u0 -> u0) -> u9; _NO_DEFLT_ } _N_
- {-defm-} _A_ 2 _U_ 02 _N_ _S_ _!_ _F_ _IF_ARGS_ 1 2 XX 3 _/\_ u0 -> \ (u1 :: {{Floating u0}}) (u2 :: u0) -> _APP_ _TYAPP_ patError# { (u0 -> u0) } [ _NOREP_S_ "%DPreludeCore.Floating.sin\"", u2 ] _N_ #-}
+ {-defm-} _A_ 2 _U_ 02 _N_ _S_ _!_ _N_ _N_ #-}
cos :: a -> a
{-# GHC_PRAGMA {-meth-} _A_ 1 _U_ 12 _N_ _S_ "S" _F_ _IF_ARGS_ 1 1 C 2 _/\_ u0 -> \ (u1 :: ({{Fractional u0}}, u0, u0 -> u0, u0 -> u0, u0 -> u0, u0 -> u0 -> u0, u0 -> u0 -> u0, u0 -> u0, u0 -> u0, u0 -> u0, u0 -> u0, u0 -> u0, u0 -> u0, u0 -> u0, u0 -> u0, u0 -> u0, u0 -> u0, u0 -> u0, u0 -> u0)) -> case u1 of { _ALG_ _TUP_19 (u2 :: {{Fractional u0}}) (u3 :: u0) (u4 :: u0 -> u0) (u5 :: u0 -> u0) (u6 :: u0 -> u0) (u7 :: u0 -> u0 -> u0) (u8 :: u0 -> u0 -> u0) (u9 :: u0 -> u0) (ua :: u0 -> u0) (ub :: u0 -> u0) (uc :: u0 -> u0) (ud :: u0 -> u0) (ue :: u0 -> u0) (uf :: u0 -> u0) (ug :: u0 -> u0) (uh :: u0 -> u0) (ui :: u0 -> u0) (uj :: u0 -> u0) (uk :: u0 -> u0) -> ua; _NO_DEFLT_ } _N_
- {-defm-} _A_ 2 _U_ 02 _N_ _S_ _!_ _F_ _IF_ARGS_ 1 2 XX 3 _/\_ u0 -> \ (u1 :: {{Floating u0}}) (u2 :: u0) -> _APP_ _TYAPP_ patError# { (u0 -> u0) } [ _NOREP_S_ "%DPreludeCore.Floating.cos\"", u2 ] _N_ #-}
+ {-defm-} _A_ 2 _U_ 02 _N_ _S_ _!_ _N_ _N_ #-}
tan :: a -> a
{-# GHC_PRAGMA {-meth-} _A_ 1 _U_ 12 _N_ _S_ "S" _F_ _IF_ARGS_ 1 1 C 2 _/\_ u0 -> \ (u1 :: ({{Fractional u0}}, u0, u0 -> u0, u0 -> u0, u0 -> u0, u0 -> u0 -> u0, u0 -> u0 -> u0, u0 -> u0, u0 -> u0, u0 -> u0, u0 -> u0, u0 -> u0, u0 -> u0, u0 -> u0, u0 -> u0, u0 -> u0, u0 -> u0, u0 -> u0, u0 -> u0)) -> case u1 of { _ALG_ _TUP_19 (u2 :: {{Fractional u0}}) (u3 :: u0) (u4 :: u0 -> u0) (u5 :: u0 -> u0) (u6 :: u0 -> u0) (u7 :: u0 -> u0 -> u0) (u8 :: u0 -> u0 -> u0) (u9 :: u0 -> u0) (ua :: u0 -> u0) (ub :: u0 -> u0) (uc :: u0 -> u0) (ud :: u0 -> u0) (ue :: u0 -> u0) (uf :: u0 -> u0) (ug :: u0 -> u0) (uh :: u0 -> u0) (ui :: u0 -> u0) (uj :: u0 -> u0) (uk :: u0 -> u0) -> ub; _NO_DEFLT_ } _N_
{-defm-} _A_ 2 _U_ 12 _N_ _S_ "SL" _N_ _N_ #-}
asin :: a -> a
{-# GHC_PRAGMA {-meth-} _A_ 1 _U_ 12 _N_ _S_ "S" _F_ _IF_ARGS_ 1 1 C 2 _/\_ u0 -> \ (u1 :: ({{Fractional u0}}, u0, u0 -> u0, u0 -> u0, u0 -> u0, u0 -> u0 -> u0, u0 -> u0 -> u0, u0 -> u0, u0 -> u0, u0 -> u0, u0 -> u0, u0 -> u0, u0 -> u0, u0 -> u0, u0 -> u0, u0 -> u0, u0 -> u0, u0 -> u0, u0 -> u0)) -> case u1 of { _ALG_ _TUP_19 (u2 :: {{Fractional u0}}) (u3 :: u0) (u4 :: u0 -> u0) (u5 :: u0 -> u0) (u6 :: u0 -> u0) (u7 :: u0 -> u0 -> u0) (u8 :: u0 -> u0 -> u0) (u9 :: u0 -> u0) (ua :: u0 -> u0) (ub :: u0 -> u0) (uc :: u0 -> u0) (ud :: u0 -> u0) (ue :: u0 -> u0) (uf :: u0 -> u0) (ug :: u0 -> u0) (uh :: u0 -> u0) (ui :: u0 -> u0) (uj :: u0 -> u0) (uk :: u0 -> u0) -> uc; _NO_DEFLT_ } _N_
- {-defm-} _A_ 2 _U_ 02 _N_ _S_ _!_ _F_ _IF_ARGS_ 1 2 XX 3 _/\_ u0 -> \ (u1 :: {{Floating u0}}) (u2 :: u0) -> _APP_ _TYAPP_ patError# { (u0 -> u0) } [ _NOREP_S_ "%DPreludeCore.Floating.asin\"", u2 ] _N_ #-}
+ {-defm-} _A_ 2 _U_ 02 _N_ _S_ _!_ _N_ _N_ #-}
acos :: a -> a
{-# GHC_PRAGMA {-meth-} _A_ 1 _U_ 12 _N_ _S_ "S" _F_ _IF_ARGS_ 1 1 C 2 _/\_ u0 -> \ (u1 :: ({{Fractional u0}}, u0, u0 -> u0, u0 -> u0, u0 -> u0, u0 -> u0 -> u0, u0 -> u0 -> u0, u0 -> u0, u0 -> u0, u0 -> u0, u0 -> u0, u0 -> u0, u0 -> u0, u0 -> u0, u0 -> u0, u0 -> u0, u0 -> u0, u0 -> u0, u0 -> u0)) -> case u1 of { _ALG_ _TUP_19 (u2 :: {{Fractional u0}}) (u3 :: u0) (u4 :: u0 -> u0) (u5 :: u0 -> u0) (u6 :: u0 -> u0) (u7 :: u0 -> u0 -> u0) (u8 :: u0 -> u0 -> u0) (u9 :: u0 -> u0) (ua :: u0 -> u0) (ub :: u0 -> u0) (uc :: u0 -> u0) (ud :: u0 -> u0) (ue :: u0 -> u0) (uf :: u0 -> u0) (ug :: u0 -> u0) (uh :: u0 -> u0) (ui :: u0 -> u0) (uj :: u0 -> u0) (uk :: u0 -> u0) -> ud; _NO_DEFLT_ } _N_
- {-defm-} _A_ 2 _U_ 02 _N_ _S_ _!_ _F_ _IF_ARGS_ 1 2 XX 3 _/\_ u0 -> \ (u1 :: {{Floating u0}}) (u2 :: u0) -> _APP_ _TYAPP_ patError# { (u0 -> u0) } [ _NOREP_S_ "%DPreludeCore.Floating.acos\"", u2 ] _N_ #-}
+ {-defm-} _A_ 2 _U_ 02 _N_ _S_ _!_ _N_ _N_ #-}
atan :: a -> a
{-# GHC_PRAGMA {-meth-} _A_ 1 _U_ 12 _N_ _S_ "S" _F_ _IF_ARGS_ 1 1 C 2 _/\_ u0 -> \ (u1 :: ({{Fractional u0}}, u0, u0 -> u0, u0 -> u0, u0 -> u0, u0 -> u0 -> u0, u0 -> u0 -> u0, u0 -> u0, u0 -> u0, u0 -> u0, u0 -> u0, u0 -> u0, u0 -> u0, u0 -> u0, u0 -> u0, u0 -> u0, u0 -> u0, u0 -> u0, u0 -> u0)) -> case u1 of { _ALG_ _TUP_19 (u2 :: {{Fractional u0}}) (u3 :: u0) (u4 :: u0 -> u0) (u5 :: u0 -> u0) (u6 :: u0 -> u0) (u7 :: u0 -> u0 -> u0) (u8 :: u0 -> u0 -> u0) (u9 :: u0 -> u0) (ua :: u0 -> u0) (ub :: u0 -> u0) (uc :: u0 -> u0) (ud :: u0 -> u0) (ue :: u0 -> u0) (uf :: u0 -> u0) (ug :: u0 -> u0) (uh :: u0 -> u0) (ui :: u0 -> u0) (uj :: u0 -> u0) (uk :: u0 -> u0) -> ue; _NO_DEFLT_ } _N_
- {-defm-} _A_ 2 _U_ 02 _N_ _S_ _!_ _F_ _IF_ARGS_ 1 2 XX 3 _/\_ u0 -> \ (u1 :: {{Floating u0}}) (u2 :: u0) -> _APP_ _TYAPP_ patError# { (u0 -> u0) } [ _NOREP_S_ "%DPreludeCore.Floating.atan\"", u2 ] _N_ #-}
+ {-defm-} _A_ 2 _U_ 02 _N_ _S_ _!_ _N_ _N_ #-}
sinh :: a -> a
{-# GHC_PRAGMA {-meth-} _A_ 1 _U_ 12 _N_ _S_ "S" _F_ _IF_ARGS_ 1 1 C 2 _/\_ u0 -> \ (u1 :: ({{Fractional u0}}, u0, u0 -> u0, u0 -> u0, u0 -> u0, u0 -> u0 -> u0, u0 -> u0 -> u0, u0 -> u0, u0 -> u0, u0 -> u0, u0 -> u0, u0 -> u0, u0 -> u0, u0 -> u0, u0 -> u0, u0 -> u0, u0 -> u0, u0 -> u0, u0 -> u0)) -> case u1 of { _ALG_ _TUP_19 (u2 :: {{Fractional u0}}) (u3 :: u0) (u4 :: u0 -> u0) (u5 :: u0 -> u0) (u6 :: u0 -> u0) (u7 :: u0 -> u0 -> u0) (u8 :: u0 -> u0 -> u0) (u9 :: u0 -> u0) (ua :: u0 -> u0) (ub :: u0 -> u0) (uc :: u0 -> u0) (ud :: u0 -> u0) (ue :: u0 -> u0) (uf :: u0 -> u0) (ug :: u0 -> u0) (uh :: u0 -> u0) (ui :: u0 -> u0) (uj :: u0 -> u0) (uk :: u0 -> u0) -> uf; _NO_DEFLT_ } _N_
- {-defm-} _A_ 2 _U_ 02 _N_ _S_ _!_ _F_ _IF_ARGS_ 1 2 XX 3 _/\_ u0 -> \ (u1 :: {{Floating u0}}) (u2 :: u0) -> _APP_ _TYAPP_ patError# { (u0 -> u0) } [ _NOREP_S_ "%DPreludeCore.Floating.sinh\"", u2 ] _N_ #-}
+ {-defm-} _A_ 2 _U_ 02 _N_ _S_ _!_ _N_ _N_ #-}
cosh :: a -> a
{-# GHC_PRAGMA {-meth-} _A_ 1 _U_ 12 _N_ _S_ "S" _F_ _IF_ARGS_ 1 1 C 2 _/\_ u0 -> \ (u1 :: ({{Fractional u0}}, u0, u0 -> u0, u0 -> u0, u0 -> u0, u0 -> u0 -> u0, u0 -> u0 -> u0, u0 -> u0, u0 -> u0, u0 -> u0, u0 -> u0, u0 -> u0, u0 -> u0, u0 -> u0, u0 -> u0, u0 -> u0, u0 -> u0, u0 -> u0, u0 -> u0)) -> case u1 of { _ALG_ _TUP_19 (u2 :: {{Fractional u0}}) (u3 :: u0) (u4 :: u0 -> u0) (u5 :: u0 -> u0) (u6 :: u0 -> u0) (u7 :: u0 -> u0 -> u0) (u8 :: u0 -> u0 -> u0) (u9 :: u0 -> u0) (ua :: u0 -> u0) (ub :: u0 -> u0) (uc :: u0 -> u0) (ud :: u0 -> u0) (ue :: u0 -> u0) (uf :: u0 -> u0) (ug :: u0 -> u0) (uh :: u0 -> u0) (ui :: u0 -> u0) (uj :: u0 -> u0) (uk :: u0 -> u0) -> ug; _NO_DEFLT_ } _N_
- {-defm-} _A_ 2 _U_ 02 _N_ _S_ _!_ _F_ _IF_ARGS_ 1 2 XX 3 _/\_ u0 -> \ (u1 :: {{Floating u0}}) (u2 :: u0) -> _APP_ _TYAPP_ patError# { (u0 -> u0) } [ _NOREP_S_ "%DPreludeCore.Floating.cosh\"", u2 ] _N_ #-}
+ {-defm-} _A_ 2 _U_ 02 _N_ _S_ _!_ _N_ _N_ #-}
tanh :: a -> a
{-# GHC_PRAGMA {-meth-} _A_ 1 _U_ 12 _N_ _S_ "S" _F_ _IF_ARGS_ 1 1 C 2 _/\_ u0 -> \ (u1 :: ({{Fractional u0}}, u0, u0 -> u0, u0 -> u0, u0 -> u0, u0 -> u0 -> u0, u0 -> u0 -> u0, u0 -> u0, u0 -> u0, u0 -> u0, u0 -> u0, u0 -> u0, u0 -> u0, u0 -> u0, u0 -> u0, u0 -> u0, u0 -> u0, u0 -> u0, u0 -> u0)) -> case u1 of { _ALG_ _TUP_19 (u2 :: {{Fractional u0}}) (u3 :: u0) (u4 :: u0 -> u0) (u5 :: u0 -> u0) (u6 :: u0 -> u0) (u7 :: u0 -> u0 -> u0) (u8 :: u0 -> u0 -> u0) (u9 :: u0 -> u0) (ua :: u0 -> u0) (ub :: u0 -> u0) (uc :: u0 -> u0) (ud :: u0 -> u0) (ue :: u0 -> u0) (uf :: u0 -> u0) (ug :: u0 -> u0) (uh :: u0 -> u0) (ui :: u0 -> u0) (uj :: u0 -> u0) (uk :: u0 -> u0) -> uh; _NO_DEFLT_ } _N_
{-defm-} _A_ 2 _U_ 12 _N_ _S_ "SL" _N_ _N_ #-}
asinh :: a -> a
{-# GHC_PRAGMA {-meth-} _A_ 1 _U_ 12 _N_ _S_ "S" _F_ _IF_ARGS_ 1 1 C 2 _/\_ u0 -> \ (u1 :: ({{Fractional u0}}, u0, u0 -> u0, u0 -> u0, u0 -> u0, u0 -> u0 -> u0, u0 -> u0 -> u0, u0 -> u0, u0 -> u0, u0 -> u0, u0 -> u0, u0 -> u0, u0 -> u0, u0 -> u0, u0 -> u0, u0 -> u0, u0 -> u0, u0 -> u0, u0 -> u0)) -> case u1 of { _ALG_ _TUP_19 (u2 :: {{Fractional u0}}) (u3 :: u0) (u4 :: u0 -> u0) (u5 :: u0 -> u0) (u6 :: u0 -> u0) (u7 :: u0 -> u0 -> u0) (u8 :: u0 -> u0 -> u0) (u9 :: u0 -> u0) (ua :: u0 -> u0) (ub :: u0 -> u0) (uc :: u0 -> u0) (ud :: u0 -> u0) (ue :: u0 -> u0) (uf :: u0 -> u0) (ug :: u0 -> u0) (uh :: u0 -> u0) (ui :: u0 -> u0) (uj :: u0 -> u0) (uk :: u0 -> u0) -> ui; _NO_DEFLT_ } _N_
- {-defm-} _A_ 2 _U_ 02 _N_ _S_ _!_ _F_ _IF_ARGS_ 1 2 XX 3 _/\_ u0 -> \ (u1 :: {{Floating u0}}) (u2 :: u0) -> _APP_ _TYAPP_ patError# { (u0 -> u0) } [ _NOREP_S_ "%DPreludeCore.Floating.asinh\"", u2 ] _N_ #-}
+ {-defm-} _A_ 2 _U_ 02 _N_ _S_ _!_ _N_ _N_ #-}
acosh :: a -> a
{-# GHC_PRAGMA {-meth-} _A_ 1 _U_ 12 _N_ _S_ "S" _F_ _IF_ARGS_ 1 1 C 2 _/\_ u0 -> \ (u1 :: ({{Fractional u0}}, u0, u0 -> u0, u0 -> u0, u0 -> u0, u0 -> u0 -> u0, u0 -> u0 -> u0, u0 -> u0, u0 -> u0, u0 -> u0, u0 -> u0, u0 -> u0, u0 -> u0, u0 -> u0, u0 -> u0, u0 -> u0, u0 -> u0, u0 -> u0, u0 -> u0)) -> case u1 of { _ALG_ _TUP_19 (u2 :: {{Fractional u0}}) (u3 :: u0) (u4 :: u0 -> u0) (u5 :: u0 -> u0) (u6 :: u0 -> u0) (u7 :: u0 -> u0 -> u0) (u8 :: u0 -> u0 -> u0) (u9 :: u0 -> u0) (ua :: u0 -> u0) (ub :: u0 -> u0) (uc :: u0 -> u0) (ud :: u0 -> u0) (ue :: u0 -> u0) (uf :: u0 -> u0) (ug :: u0 -> u0) (uh :: u0 -> u0) (ui :: u0 -> u0) (uj :: u0 -> u0) (uk :: u0 -> u0) -> uj; _NO_DEFLT_ } _N_
- {-defm-} _A_ 2 _U_ 02 _N_ _S_ _!_ _F_ _IF_ARGS_ 1 2 XX 3 _/\_ u0 -> \ (u1 :: {{Floating u0}}) (u2 :: u0) -> _APP_ _TYAPP_ patError# { (u0 -> u0) } [ _NOREP_S_ "%DPreludeCore.Floating.acosh\"", u2 ] _N_ #-}
+ {-defm-} _A_ 2 _U_ 02 _N_ _S_ _!_ _N_ _N_ #-}
atanh :: a -> a
{-# GHC_PRAGMA {-meth-} _A_ 1 _U_ 12 _N_ _S_ "S" _F_ _IF_ARGS_ 1 1 C 2 _/\_ u0 -> \ (u1 :: ({{Fractional u0}}, u0, u0 -> u0, u0 -> u0, u0 -> u0, u0 -> u0 -> u0, u0 -> u0 -> u0, u0 -> u0, u0 -> u0, u0 -> u0, u0 -> u0, u0 -> u0, u0 -> u0, u0 -> u0, u0 -> u0, u0 -> u0, u0 -> u0, u0 -> u0, u0 -> u0)) -> case u1 of { _ALG_ _TUP_19 (u2 :: {{Fractional u0}}) (u3 :: u0) (u4 :: u0 -> u0) (u5 :: u0 -> u0) (u6 :: u0 -> u0) (u7 :: u0 -> u0 -> u0) (u8 :: u0 -> u0 -> u0) (u9 :: u0 -> u0) (ua :: u0 -> u0) (ub :: u0 -> u0) (uc :: u0 -> u0) (ud :: u0 -> u0) (ue :: u0 -> u0) (uf :: u0 -> u0) (ug :: u0 -> u0) (uh :: u0 -> u0) (ui :: u0 -> u0) (uj :: u0 -> u0) (uk :: u0 -> u0) -> uk; _NO_DEFLT_ } _N_
- {-defm-} _A_ 2 _U_ 02 _N_ _S_ _!_ _F_ _IF_ARGS_ 1 2 XX 3 _/\_ u0 -> \ (u1 :: {{Floating u0}}) (u2 :: u0) -> _APP_ _TYAPP_ patError# { (u0 -> u0) } [ _NOREP_S_ "%DPreludeCore.Floating.atanh\"", u2 ] _N_ #-}
+ {-defm-} _A_ 2 _U_ 02 _N_ _S_ _!_ _N_ _N_ #-}
class (Num a) => Fractional a {-# GHC_PRAGMA {-superdicts-} _A_ 1 _U_ 1 _N_ _S_ "S" _F_ _IF_ARGS_ 1 1 C 2 _/\_ u0 -> \ (u1 :: ({{Num u0}}, u0 -> u0 -> u0, u0 -> u0, Ratio Integer -> u0)) -> case u1 of { _ALG_ _TUP_4 (u2 :: {{Num u0}}) (u3 :: u0 -> u0 -> u0) (u4 :: u0 -> u0) (u5 :: Ratio Integer -> u0) -> u2; _NO_DEFLT_ } _N_ #-} where
(/) :: a -> a -> a
{-# GHC_PRAGMA {-meth-} _A_ 1 _U_ 122 _N_ _S_ "S" _F_ _IF_ARGS_ 1 1 C 2 _/\_ u0 -> \ (u1 :: ({{Num u0}}, u0 -> u0 -> u0, u0 -> u0, Ratio Integer -> u0)) -> case u1 of { _ALG_ _TUP_4 (u2 :: {{Num u0}}) (u3 :: u0 -> u0 -> u0) (u4 :: u0 -> u0) (u5 :: Ratio Integer -> u0) -> u3; _NO_DEFLT_ } _N_
- {-defm-} _A_ 3 _U_ 022 _N_ _S_ _!_ _F_ _IF_ARGS_ 1 3 XXX 4 _/\_ u0 -> \ (u1 :: {{Fractional u0}}) (u2 :: u0) (u3 :: u0) -> _APP_ _TYAPP_ patError# { (u0 -> u0 -> u0) } [ _NOREP_S_ "%DPreludeCore.Fractional.(/)\"", u2, u3 ] _N_ #-}
+ {-defm-} _A_ 3 _U_ 022 _N_ _S_ _!_ _N_ _N_ #-}
recip :: a -> a
{-# GHC_PRAGMA {-meth-} _A_ 1 _U_ 12 _N_ _S_ "S" _F_ _IF_ARGS_ 1 1 C 2 _/\_ u0 -> \ (u1 :: ({{Num u0}}, u0 -> u0 -> u0, u0 -> u0, Ratio Integer -> u0)) -> case u1 of { _ALG_ _TUP_4 (u2 :: {{Num u0}}) (u3 :: u0 -> u0 -> u0) (u4 :: u0 -> u0) (u5 :: Ratio Integer -> u0) -> u4; _NO_DEFLT_ } _N_
{-defm-} _A_ 1 _U_ 12 _N_ _S_ "S" _N_ _N_ #-}
fromRational :: Ratio Integer -> a
{-# GHC_PRAGMA {-meth-} _A_ 1 _U_ 12 _N_ _S_ "S" _F_ _IF_ARGS_ 1 1 C 2 _/\_ u0 -> \ (u1 :: ({{Num u0}}, u0 -> u0 -> u0, u0 -> u0, Ratio Integer -> u0)) -> case u1 of { _ALG_ _TUP_4 (u2 :: {{Num u0}}) (u3 :: u0 -> u0 -> u0) (u4 :: u0 -> u0) (u5 :: Ratio Integer -> u0) -> u5; _NO_DEFLT_ } _N_
- {-defm-} _A_ 2 _U_ 02 _N_ _S_ _!_ _F_ _IF_ARGS_ 1 2 XX 3 _/\_ u0 -> \ (u1 :: {{Fractional u0}}) (u2 :: Ratio Integer) -> _APP_ _TYAPP_ patError# { (Ratio Integer -> u0) } [ _NOREP_S_ "%DPreludeCore.Fractional.fromRational\"", u2 ] _N_ #-}
+ {-defm-} _A_ 2 _U_ 02 _N_ _S_ _!_ _N_ _N_ #-}
class (Real a, Ix a) => Integral a {-# GHC_PRAGMA {-superdicts-} _A_ 1 _U_ 1 _N_ _S_ "S" _F_ _IF_ARGS_ 1 1 C 2 _/\_ u0 -> \ (u1 :: ({{Real u0}}, {{Ix u0}}, u0 -> u0 -> u0, u0 -> u0 -> u0, u0 -> u0 -> u0, u0 -> u0 -> u0, u0 -> u0 -> (u0, u0), u0 -> u0 -> (u0, u0), u0 -> Bool, u0 -> Bool, u0 -> Integer, u0 -> Int)) -> case u1 of { _ALG_ _TUP_12 (u2 :: {{Real u0}}) (u3 :: {{Ix u0}}) (u4 :: u0 -> u0 -> u0) (u5 :: u0 -> u0 -> u0) (u6 :: u0 -> u0 -> u0) (u7 :: u0 -> u0 -> u0) (u8 :: u0 -> u0 -> (u0, u0)) (u9 :: u0 -> u0 -> (u0, u0)) (ua :: u0 -> Bool) (ub :: u0 -> Bool) (uc :: u0 -> Integer) (ud :: u0 -> Int) -> u2; _NO_DEFLT_ } _N_, _A_ 1 _U_ 1 _N_ _S_ "S" _F_ _IF_ARGS_ 1 1 C 2 _/\_ u0 -> \ (u1 :: ({{Real u0}}, {{Ix u0}}, u0 -> u0 -> u0, u0 -> u0 -> u0, u0 -> u0 -> u0, u0 -> u0 -> u0, u0 -> u0 -> (u0, u0), u0 -> u0 -> (u0, u0), u0 -> Bool, u0 -> Bool, u0 -> Integer, u0 -> Int)) -> case u1 of { _ALG_ _TUP_12 (u2 :: {{Real u0}}) (u3 :: {{Ix u0}}) (u4 :: u0 -> u0 -> u0) (u5 :: u0 -> u0 -> u0) (u6 :: u0 -> u0 -> u0) (u7 :: u0 -> u0 -> u0) (u8 :: u0 -> u0 -> (u0, u0)) (u9 :: u0 -> u0 -> (u0, u0)) (ua :: u0 -> Bool) (ub :: u0 -> Bool) (uc :: u0 -> Integer) (ud :: u0 -> Int) -> u3; _NO_DEFLT_ } _N_ #-} where
quot :: a -> a -> a
{-# GHC_PRAGMA {-meth-} _A_ 1 _U_ 122 _N_ _S_ "S" _F_ _IF_ARGS_ 1 1 C 2 _/\_ u0 -> \ (u1 :: ({{Real u0}}, {{Ix u0}}, u0 -> u0 -> u0, u0 -> u0 -> u0, u0 -> u0 -> u0, u0 -> u0 -> u0, u0 -> u0 -> (u0, u0), u0 -> u0 -> (u0, u0), u0 -> Bool, u0 -> Bool, u0 -> Integer, u0 -> Int)) -> case u1 of { _ALG_ _TUP_12 (u2 :: {{Real u0}}) (u3 :: {{Ix u0}}) (u4 :: u0 -> u0 -> u0) (u5 :: u0 -> u0 -> u0) (u6 :: u0 -> u0 -> u0) (u7 :: u0 -> u0 -> u0) (u8 :: u0 -> u0 -> (u0, u0)) (u9 :: u0 -> u0 -> (u0, u0)) (ua :: u0 -> Bool) (ub :: u0 -> Bool) (uc :: u0 -> Integer) (ud :: u0 -> Int) -> u4; _NO_DEFLT_ } _N_
{-defm-} _A_ 3 _U_ 122 _N_ _S_ "SLL" _F_ _IF_ARGS_ 1 3 CXX 6 _/\_ u0 -> \ (u1 :: {{Integral u0}}) (u2 :: u0) (u3 :: u0) -> case case u1 of { _ALG_ _TUP_12 (u4 :: {{Real u0}}) (u5 :: {{Ix u0}}) (u6 :: u0 -> u0 -> u0) (u7 :: u0 -> u0 -> u0) (u8 :: u0 -> u0 -> u0) (u9 :: u0 -> u0 -> u0) (ua :: u0 -> u0 -> (u0, u0)) (ub :: u0 -> u0 -> (u0, u0)) (uc :: u0 -> Bool) (ud :: u0 -> Bool) (ue :: u0 -> Integer) (uf :: u0 -> Int) -> _APP_ ub [ u2, u3 ]; _NO_DEFLT_ } of { _ALG_ _TUP_2 (ug :: u0) (uh :: u0) -> uh; _NO_DEFLT_ } _N_ #-}
quotRem :: a -> a -> (a, a)
{-# GHC_PRAGMA {-meth-} _A_ 1 _U_ 122 _N_ _S_ "S" _F_ _IF_ARGS_ 1 1 C 2 _/\_ u0 -> \ (u1 :: ({{Real u0}}, {{Ix u0}}, u0 -> u0 -> u0, u0 -> u0 -> u0, u0 -> u0 -> u0, u0 -> u0 -> u0, u0 -> u0 -> (u0, u0), u0 -> u0 -> (u0, u0), u0 -> Bool, u0 -> Bool, u0 -> Integer, u0 -> Int)) -> case u1 of { _ALG_ _TUP_12 (u2 :: {{Real u0}}) (u3 :: {{Ix u0}}) (u4 :: u0 -> u0 -> u0) (u5 :: u0 -> u0 -> u0) (u6 :: u0 -> u0 -> u0) (u7 :: u0 -> u0 -> u0) (u8 :: u0 -> u0 -> (u0, u0)) (u9 :: u0 -> u0 -> (u0, u0)) (ua :: u0 -> Bool) (ub :: u0 -> Bool) (uc :: u0 -> Integer) (ud :: u0 -> Int) -> u8; _NO_DEFLT_ } _N_
- {-defm-} _A_ 3 _U_ 022 _N_ _S_ _!_ _F_ _IF_ARGS_ 1 3 XXX 4 _/\_ u0 -> \ (u1 :: {{Integral u0}}) (u2 :: u0) (u3 :: u0) -> _APP_ _TYAPP_ patError# { (u0 -> u0 -> (u0, u0)) } [ _NOREP_S_ "%DPreludeCore.Integral.quotRem\"", u2, u3 ] _N_ #-}
+ {-defm-} _A_ 3 _U_ 022 _N_ _S_ _!_ _N_ _N_ #-}
divMod :: a -> a -> (a, a)
{-# GHC_PRAGMA {-meth-} _A_ 1 _U_ 122 _N_ _S_ "S" _F_ _IF_ARGS_ 1 1 C 2 _/\_ u0 -> \ (u1 :: ({{Real u0}}, {{Ix u0}}, u0 -> u0 -> u0, u0 -> u0 -> u0, u0 -> u0 -> u0, u0 -> u0 -> u0, u0 -> u0 -> (u0, u0), u0 -> u0 -> (u0, u0), u0 -> Bool, u0 -> Bool, u0 -> Integer, u0 -> Int)) -> case u1 of { _ALG_ _TUP_12 (u2 :: {{Real u0}}) (u3 :: {{Ix u0}}) (u4 :: u0 -> u0 -> u0) (u5 :: u0 -> u0 -> u0) (u6 :: u0 -> u0 -> u0) (u7 :: u0 -> u0 -> u0) (u8 :: u0 -> u0 -> (u0, u0)) (u9 :: u0 -> u0 -> (u0, u0)) (ua :: u0 -> Bool) (ub :: u0 -> Bool) (uc :: u0 -> Integer) (ud :: u0 -> Int) -> u9; _NO_DEFLT_ } _N_
{-defm-} _A_ 1 _U_ 122 _N_ _S_ "S" _N_ _N_ #-}
{-defm-} _A_ 1 _U_ 12 _N_ _S_ "S" _N_ _N_ #-}
toInteger :: a -> Integer
{-# GHC_PRAGMA {-meth-} _A_ 1 _U_ 12 _N_ _S_ "S" _F_ _IF_ARGS_ 1 1 C 2 _/\_ u0 -> \ (u1 :: ({{Real u0}}, {{Ix u0}}, u0 -> u0 -> u0, u0 -> u0 -> u0, u0 -> u0 -> u0, u0 -> u0 -> u0, u0 -> u0 -> (u0, u0), u0 -> u0 -> (u0, u0), u0 -> Bool, u0 -> Bool, u0 -> Integer, u0 -> Int)) -> case u1 of { _ALG_ _TUP_12 (u2 :: {{Real u0}}) (u3 :: {{Ix u0}}) (u4 :: u0 -> u0 -> u0) (u5 :: u0 -> u0 -> u0) (u6 :: u0 -> u0 -> u0) (u7 :: u0 -> u0 -> u0) (u8 :: u0 -> u0 -> (u0, u0)) (u9 :: u0 -> u0 -> (u0, u0)) (ua :: u0 -> Bool) (ub :: u0 -> Bool) (uc :: u0 -> Integer) (ud :: u0 -> Int) -> uc; _NO_DEFLT_ } _N_
- {-defm-} _A_ 2 _U_ 02 _N_ _S_ _!_ _F_ _IF_ARGS_ 1 2 XX 3 _/\_ u0 -> \ (u1 :: {{Integral u0}}) (u2 :: u0) -> _APP_ _TYAPP_ patError# { (u0 -> Integer) } [ _NOREP_S_ "%DPreludeCore.Integral.toInteger\"", u2 ] _N_ #-}
+ {-defm-} _A_ 2 _U_ 02 _N_ _S_ _!_ _N_ _N_ #-}
toInt :: a -> Int
{-# GHC_PRAGMA {-meth-} _A_ 1 _U_ 12 _N_ _S_ "S" _F_ _IF_ARGS_ 1 1 C 2 _/\_ u0 -> \ (u1 :: ({{Real u0}}, {{Ix u0}}, u0 -> u0 -> u0, u0 -> u0 -> u0, u0 -> u0 -> u0, u0 -> u0 -> u0, u0 -> u0 -> (u0, u0), u0 -> u0 -> (u0, u0), u0 -> Bool, u0 -> Bool, u0 -> Integer, u0 -> Int)) -> case u1 of { _ALG_ _TUP_12 (u2 :: {{Real u0}}) (u3 :: {{Ix u0}}) (u4 :: u0 -> u0 -> u0) (u5 :: u0 -> u0 -> u0) (u6 :: u0 -> u0 -> u0) (u7 :: u0 -> u0 -> u0) (u8 :: u0 -> u0 -> (u0, u0)) (u9 :: u0 -> u0 -> (u0, u0)) (ua :: u0 -> Bool) (ub :: u0 -> Bool) (uc :: u0 -> Integer) (ud :: u0 -> Int) -> ud; _NO_DEFLT_ } _N_
- {-defm-} _A_ 2 _U_ 02 _N_ _S_ _!_ _F_ _IF_ARGS_ 1 2 XX 3 _/\_ u0 -> \ (u1 :: {{Integral u0}}) (u2 :: u0) -> _APP_ _TYAPP_ patError# { (u0 -> Int) } [ _NOREP_S_ "%DPreludeCore.Integral.toInt\"", u2 ] _N_ #-}
+ {-defm-} _A_ 2 _U_ 02 _N_ _S_ _!_ _N_ _N_ #-}
class (Ord a) => Ix a {-# GHC_PRAGMA {-superdicts-} _A_ 1 _U_ 1 _N_ _S_ "S" _F_ _IF_ARGS_ 1 1 C 2 _/\_ u0 -> \ (u1 :: ({{Ord u0}}, (u0, u0) -> [u0], (u0, u0) -> u0 -> Int, (u0, u0) -> u0 -> Bool)) -> case u1 of { _ALG_ _TUP_4 (u2 :: {{Ord u0}}) (u3 :: (u0, u0) -> [u0]) (u4 :: (u0, u0) -> u0 -> Int) (u5 :: (u0, u0) -> u0 -> Bool) -> u2; _NO_DEFLT_ } _N_ #-} where
range :: (a, a) -> [a]
{-# GHC_PRAGMA {-meth-} _A_ 1 _U_ 12 _N_ _S_ "S" _F_ _IF_ARGS_ 1 1 C 2 _/\_ u0 -> \ (u1 :: ({{Ord u0}}, (u0, u0) -> [u0], (u0, u0) -> u0 -> Int, (u0, u0) -> u0 -> Bool)) -> case u1 of { _ALG_ _TUP_4 (u2 :: {{Ord u0}}) (u3 :: (u0, u0) -> [u0]) (u4 :: (u0, u0) -> u0 -> Int) (u5 :: (u0, u0) -> u0 -> Bool) -> u3; _NO_DEFLT_ } _N_
- {-defm-} _A_ 2 _U_ 02 _N_ _S_ _!_ _F_ _IF_ARGS_ 1 2 XX 3 _/\_ u0 -> \ (u1 :: {{Ix u0}}) (u2 :: (u0, u0)) -> _APP_ _TYAPP_ patError# { ((u0, u0) -> [u0]) } [ _NOREP_S_ "%DPreludeCore.Ix.range\"", u2 ] _N_ #-}
+ {-defm-} _A_ 2 _U_ 02 _N_ _S_ _!_ _N_ _N_ #-}
index :: (a, a) -> a -> Int
{-# GHC_PRAGMA {-meth-} _A_ 1 _U_ 122 _N_ _S_ "S" _F_ _IF_ARGS_ 1 1 C 2 _/\_ u0 -> \ (u1 :: ({{Ord u0}}, (u0, u0) -> [u0], (u0, u0) -> u0 -> Int, (u0, u0) -> u0 -> Bool)) -> case u1 of { _ALG_ _TUP_4 (u2 :: {{Ord u0}}) (u3 :: (u0, u0) -> [u0]) (u4 :: (u0, u0) -> u0 -> Int) (u5 :: (u0, u0) -> u0 -> Bool) -> u4; _NO_DEFLT_ } _N_
- {-defm-} _A_ 3 _U_ 022 _N_ _S_ _!_ _F_ _IF_ARGS_ 1 3 XXX 4 _/\_ u0 -> \ (u1 :: {{Ix u0}}) (u2 :: (u0, u0)) (u3 :: u0) -> _APP_ _TYAPP_ patError# { ((u0, u0) -> u0 -> Int) } [ _NOREP_S_ "%DPreludeCore.Ix.index\"", u2, u3 ] _N_ #-}
+ {-defm-} _A_ 3 _U_ 022 _N_ _S_ _!_ _N_ _N_ #-}
inRange :: (a, a) -> a -> Bool
{-# GHC_PRAGMA {-meth-} _A_ 1 _U_ 122 _N_ _S_ "S" _F_ _IF_ARGS_ 1 1 C 2 _/\_ u0 -> \ (u1 :: ({{Ord u0}}, (u0, u0) -> [u0], (u0, u0) -> u0 -> Int, (u0, u0) -> u0 -> Bool)) -> case u1 of { _ALG_ _TUP_4 (u2 :: {{Ord u0}}) (u3 :: (u0, u0) -> [u0]) (u4 :: (u0, u0) -> u0 -> Int) (u5 :: (u0, u0) -> u0 -> Bool) -> u5; _NO_DEFLT_ } _N_
- {-defm-} _A_ 3 _U_ 022 _N_ _S_ _!_ _F_ _IF_ARGS_ 1 3 XXX 4 _/\_ u0 -> \ (u1 :: {{Ix u0}}) (u2 :: (u0, u0)) (u3 :: u0) -> _APP_ _TYAPP_ patError# { ((u0, u0) -> u0 -> Bool) } [ _NOREP_S_ "%DPreludeCore.Ix.inRange\"", u2, u3 ] _N_ #-}
+ {-defm-} _A_ 3 _U_ 022 _N_ _S_ _!_ _N_ _N_ #-}
class (Eq a, Text a) => Num a {-# GHC_PRAGMA {-superdicts-} _A_ 1 _U_ 1 _N_ _S_ "S" _F_ _IF_ARGS_ 1 1 C 2 _/\_ u0 -> \ (u1 :: ({{Eq u0}}, {{Text u0}}, u0 -> u0 -> u0, u0 -> u0 -> u0, u0 -> u0 -> u0, u0 -> u0, u0 -> u0, u0 -> u0, Integer -> u0, Int -> u0)) -> case u1 of { _ALG_ _TUP_10 (u2 :: {{Eq u0}}) (u3 :: {{Text u0}}) (u4 :: u0 -> u0 -> u0) (u5 :: u0 -> u0 -> u0) (u6 :: u0 -> u0 -> u0) (u7 :: u0 -> u0) (u8 :: u0 -> u0) (u9 :: u0 -> u0) (ua :: Integer -> u0) (ub :: Int -> u0) -> u2; _NO_DEFLT_ } _N_, _A_ 1 _U_ 1 _N_ _S_ "S" _F_ _IF_ARGS_ 1 1 C 2 _/\_ u0 -> \ (u1 :: ({{Eq u0}}, {{Text u0}}, u0 -> u0 -> u0, u0 -> u0 -> u0, u0 -> u0 -> u0, u0 -> u0, u0 -> u0, u0 -> u0, Integer -> u0, Int -> u0)) -> case u1 of { _ALG_ _TUP_10 (u2 :: {{Eq u0}}) (u3 :: {{Text u0}}) (u4 :: u0 -> u0 -> u0) (u5 :: u0 -> u0 -> u0) (u6 :: u0 -> u0 -> u0) (u7 :: u0 -> u0) (u8 :: u0 -> u0) (u9 :: u0 -> u0) (ua :: Integer -> u0) (ub :: Int -> u0) -> u3; _NO_DEFLT_ } _N_ #-} where
(+) :: a -> a -> a
{-# GHC_PRAGMA {-meth-} _A_ 1 _U_ 122 _N_ _S_ "S" _F_ _IF_ARGS_ 1 1 C 2 _/\_ u0 -> \ (u1 :: ({{Eq u0}}, {{Text u0}}, u0 -> u0 -> u0, u0 -> u0 -> u0, u0 -> u0 -> u0, u0 -> u0, u0 -> u0, u0 -> u0, Integer -> u0, Int -> u0)) -> case u1 of { _ALG_ _TUP_10 (u2 :: {{Eq u0}}) (u3 :: {{Text u0}}) (u4 :: u0 -> u0 -> u0) (u5 :: u0 -> u0 -> u0) (u6 :: u0 -> u0 -> u0) (u7 :: u0 -> u0) (u8 :: u0 -> u0) (u9 :: u0 -> u0) (ua :: Integer -> u0) (ub :: Int -> u0) -> u4; _NO_DEFLT_ } _N_
- {-defm-} _A_ 3 _U_ 022 _N_ _S_ _!_ _F_ _IF_ARGS_ 1 3 XXX 4 _/\_ u0 -> \ (u1 :: {{Num u0}}) (u2 :: u0) (u3 :: u0) -> _APP_ _TYAPP_ patError# { (u0 -> u0 -> u0) } [ _NOREP_S_ "%DPreludeCore.Num.(+)\"", u2, u3 ] _N_ #-}
+ {-defm-} _A_ 3 _U_ 022 _N_ _S_ _!_ _N_ _N_ #-}
(-) :: a -> a -> a
{-# GHC_PRAGMA {-meth-} _A_ 1 _U_ 122 _N_ _S_ "S" _F_ _IF_ARGS_ 1 1 C 2 _/\_ u0 -> \ (u1 :: ({{Eq u0}}, {{Text u0}}, u0 -> u0 -> u0, u0 -> u0 -> u0, u0 -> u0 -> u0, u0 -> u0, u0 -> u0, u0 -> u0, Integer -> u0, Int -> u0)) -> case u1 of { _ALG_ _TUP_10 (u2 :: {{Eq u0}}) (u3 :: {{Text u0}}) (u4 :: u0 -> u0 -> u0) (u5 :: u0 -> u0 -> u0) (u6 :: u0 -> u0 -> u0) (u7 :: u0 -> u0) (u8 :: u0 -> u0) (u9 :: u0 -> u0) (ua :: Integer -> u0) (ub :: Int -> u0) -> u5; _NO_DEFLT_ } _N_
{-defm-} _A_ 3 _U_ 122 _N_ _S_ "SLL" _F_ _ALWAYS_ _/\_ u0 -> \ (u1 :: {{Num u0}}) (u2 :: u0) (u3 :: u0) -> case u1 of { _ALG_ _TUP_10 (u4 :: {{Eq u0}}) (u5 :: {{Text u0}}) (u6 :: u0 -> u0 -> u0) (u7 :: u0 -> u0 -> u0) (u8 :: u0 -> u0 -> u0) (u9 :: u0 -> u0) (ua :: u0 -> u0) (ub :: u0 -> u0) (uc :: Integer -> u0) (ud :: Int -> u0) -> let {(ue :: u0) = _APP_ u9 [ u3 ]} in _APP_ u6 [ u2, ue ]; _NO_DEFLT_ } _N_ #-}
(*) :: a -> a -> a
{-# GHC_PRAGMA {-meth-} _A_ 1 _U_ 122 _N_ _S_ "S" _F_ _IF_ARGS_ 1 1 C 2 _/\_ u0 -> \ (u1 :: ({{Eq u0}}, {{Text u0}}, u0 -> u0 -> u0, u0 -> u0 -> u0, u0 -> u0 -> u0, u0 -> u0, u0 -> u0, u0 -> u0, Integer -> u0, Int -> u0)) -> case u1 of { _ALG_ _TUP_10 (u2 :: {{Eq u0}}) (u3 :: {{Text u0}}) (u4 :: u0 -> u0 -> u0) (u5 :: u0 -> u0 -> u0) (u6 :: u0 -> u0 -> u0) (u7 :: u0 -> u0) (u8 :: u0 -> u0) (u9 :: u0 -> u0) (ua :: Integer -> u0) (ub :: Int -> u0) -> u6; _NO_DEFLT_ } _N_
- {-defm-} _A_ 3 _U_ 022 _N_ _S_ _!_ _F_ _IF_ARGS_ 1 3 XXX 4 _/\_ u0 -> \ (u1 :: {{Num u0}}) (u2 :: u0) (u3 :: u0) -> _APP_ _TYAPP_ patError# { (u0 -> u0 -> u0) } [ _NOREP_S_ "%DPreludeCore.Num.(*)\"", u2, u3 ] _N_ #-}
+ {-defm-} _A_ 3 _U_ 022 _N_ _S_ _!_ _N_ _N_ #-}
negate :: a -> a
{-# GHC_PRAGMA {-meth-} _A_ 1 _U_ 12 _N_ _S_ "S" _F_ _IF_ARGS_ 1 1 C 2 _/\_ u0 -> \ (u1 :: ({{Eq u0}}, {{Text u0}}, u0 -> u0 -> u0, u0 -> u0 -> u0, u0 -> u0 -> u0, u0 -> u0, u0 -> u0, u0 -> u0, Integer -> u0, Int -> u0)) -> case u1 of { _ALG_ _TUP_10 (u2 :: {{Eq u0}}) (u3 :: {{Text u0}}) (u4 :: u0 -> u0 -> u0) (u5 :: u0 -> u0 -> u0) (u6 :: u0 -> u0 -> u0) (u7 :: u0 -> u0) (u8 :: u0 -> u0) (u9 :: u0 -> u0) (ua :: Integer -> u0) (ub :: Int -> u0) -> u7; _NO_DEFLT_ } _N_
- {-defm-} _A_ 2 _U_ 02 _N_ _S_ _!_ _F_ _IF_ARGS_ 1 2 XX 3 _/\_ u0 -> \ (u1 :: {{Num u0}}) (u2 :: u0) -> _APP_ _TYAPP_ patError# { (u0 -> u0) } [ _NOREP_S_ "%DPreludeCore.Num.negate\"", u2 ] _N_ #-}
+ {-defm-} _A_ 2 _U_ 02 _N_ _S_ _!_ _N_ _N_ #-}
abs :: a -> a
{-# GHC_PRAGMA {-meth-} _A_ 1 _U_ 12 _N_ _S_ "S" _F_ _IF_ARGS_ 1 1 C 2 _/\_ u0 -> \ (u1 :: ({{Eq u0}}, {{Text u0}}, u0 -> u0 -> u0, u0 -> u0 -> u0, u0 -> u0 -> u0, u0 -> u0, u0 -> u0, u0 -> u0, Integer -> u0, Int -> u0)) -> case u1 of { _ALG_ _TUP_10 (u2 :: {{Eq u0}}) (u3 :: {{Text u0}}) (u4 :: u0 -> u0 -> u0) (u5 :: u0 -> u0 -> u0) (u6 :: u0 -> u0 -> u0) (u7 :: u0 -> u0) (u8 :: u0 -> u0) (u9 :: u0 -> u0) (ua :: Integer -> u0) (ub :: Int -> u0) -> u8; _NO_DEFLT_ } _N_
- {-defm-} _A_ 2 _U_ 02 _N_ _S_ _!_ _F_ _IF_ARGS_ 1 2 XX 3 _/\_ u0 -> \ (u1 :: {{Num u0}}) (u2 :: u0) -> _APP_ _TYAPP_ patError# { (u0 -> u0) } [ _NOREP_S_ "%DPreludeCore.Num.abs\"", u2 ] _N_ #-}
+ {-defm-} _A_ 2 _U_ 02 _N_ _S_ _!_ _N_ _N_ #-}
signum :: a -> a
{-# GHC_PRAGMA {-meth-} _A_ 1 _U_ 12 _N_ _S_ "S" _F_ _IF_ARGS_ 1 1 C 2 _/\_ u0 -> \ (u1 :: ({{Eq u0}}, {{Text u0}}, u0 -> u0 -> u0, u0 -> u0 -> u0, u0 -> u0 -> u0, u0 -> u0, u0 -> u0, u0 -> u0, Integer -> u0, Int -> u0)) -> case u1 of { _ALG_ _TUP_10 (u2 :: {{Eq u0}}) (u3 :: {{Text u0}}) (u4 :: u0 -> u0 -> u0) (u5 :: u0 -> u0 -> u0) (u6 :: u0 -> u0 -> u0) (u7 :: u0 -> u0) (u8 :: u0 -> u0) (u9 :: u0 -> u0) (ua :: Integer -> u0) (ub :: Int -> u0) -> u9; _NO_DEFLT_ } _N_
- {-defm-} _A_ 2 _U_ 02 _N_ _S_ _!_ _F_ _IF_ARGS_ 1 2 XX 3 _/\_ u0 -> \ (u1 :: {{Num u0}}) (u2 :: u0) -> _APP_ _TYAPP_ patError# { (u0 -> u0) } [ _NOREP_S_ "%DPreludeCore.Num.signum\"", u2 ] _N_ #-}
+ {-defm-} _A_ 2 _U_ 02 _N_ _S_ _!_ _N_ _N_ #-}
fromInteger :: Integer -> a
{-# GHC_PRAGMA {-meth-} _A_ 1 _U_ 12 _N_ _S_ "S" _F_ _IF_ARGS_ 1 1 C 2 _/\_ u0 -> \ (u1 :: ({{Eq u0}}, {{Text u0}}, u0 -> u0 -> u0, u0 -> u0 -> u0, u0 -> u0 -> u0, u0 -> u0, u0 -> u0, u0 -> u0, Integer -> u0, Int -> u0)) -> case u1 of { _ALG_ _TUP_10 (u2 :: {{Eq u0}}) (u3 :: {{Text u0}}) (u4 :: u0 -> u0 -> u0) (u5 :: u0 -> u0 -> u0) (u6 :: u0 -> u0 -> u0) (u7 :: u0 -> u0) (u8 :: u0 -> u0) (u9 :: u0 -> u0) (ua :: Integer -> u0) (ub :: Int -> u0) -> ua; _NO_DEFLT_ } _N_
- {-defm-} _A_ 2 _U_ 02 _N_ _S_ _!_ _F_ _IF_ARGS_ 1 2 XX 3 _/\_ u0 -> \ (u1 :: {{Num u0}}) (u2 :: Integer) -> _APP_ _TYAPP_ patError# { (Integer -> u0) } [ _NOREP_S_ "%DPreludeCore.Num.fromInteger\"", u2 ] _N_ #-}
+ {-defm-} _A_ 2 _U_ 02 _N_ _S_ _!_ _N_ _N_ #-}
fromInt :: Int -> a
{-# GHC_PRAGMA {-meth-} _A_ 1 _U_ 12 _N_ _S_ "S" _F_ _IF_ARGS_ 1 1 C 2 _/\_ u0 -> \ (u1 :: ({{Eq u0}}, {{Text u0}}, u0 -> u0 -> u0, u0 -> u0 -> u0, u0 -> u0 -> u0, u0 -> u0, u0 -> u0, u0 -> u0, Integer -> u0, Int -> u0)) -> case u1 of { _ALG_ _TUP_10 (u2 :: {{Eq u0}}) (u3 :: {{Text u0}}) (u4 :: u0 -> u0 -> u0) (u5 :: u0 -> u0 -> u0) (u6 :: u0 -> u0 -> u0) (u7 :: u0 -> u0) (u8 :: u0 -> u0) (u9 :: u0 -> u0) (ua :: Integer -> u0) (ub :: Int -> u0) -> ub; _NO_DEFLT_ } _N_
{-defm-} _A_ 2 _U_ 11 _N_ _S_ "SL" _F_ _IF_ARGS_ 1 2 CC 6 _/\_ u0 -> \ (u1 :: {{Num u0}}) (u2 :: Int) -> let {(u4 :: Integer) = case u2 of { _ALG_ I# (u3 :: Int#) -> _#_ int2Integer# [] [u3]; _NO_DEFLT_ }} in case u1 of { _ALG_ _TUP_10 (u5 :: {{Eq u0}}) (u6 :: {{Text u0}}) (u7 :: u0 -> u0 -> u0) (u8 :: u0 -> u0 -> u0) (u9 :: u0 -> u0 -> u0) (ua :: u0 -> u0) (ub :: u0 -> u0) (uc :: u0 -> u0) (ud :: Integer -> u0) (ue :: Int -> u0) -> _APP_ ud [ u4 ]; _NO_DEFLT_ } _N_ #-}
{-defm-} _A_ 3 _U_ 122 _N_ _S_ "SLL" _N_ _N_ #-}
(<=) :: a -> a -> Bool
{-# GHC_PRAGMA {-meth-} _A_ 1 _U_ 122 _N_ _S_ "S" _F_ _IF_ARGS_ 1 1 C 2 _/\_ u0 -> \ (u1 :: ({{Eq u0}}, u0 -> u0 -> Bool, u0 -> u0 -> Bool, u0 -> u0 -> Bool, u0 -> u0 -> Bool, u0 -> u0 -> u0, u0 -> u0 -> u0, u0 -> u0 -> _CMP_TAG)) -> case u1 of { _ALG_ _TUP_8 (u2 :: {{Eq u0}}) (u3 :: u0 -> u0 -> Bool) (u4 :: u0 -> u0 -> Bool) (u5 :: u0 -> u0 -> Bool) (u6 :: u0 -> u0 -> Bool) (u7 :: u0 -> u0 -> u0) (u8 :: u0 -> u0 -> u0) (u9 :: u0 -> u0 -> _CMP_TAG) -> u4; _NO_DEFLT_ } _N_
- {-defm-} _A_ 3 _U_ 022 _N_ _S_ _!_ _F_ _IF_ARGS_ 1 3 XXX 4 _/\_ u0 -> \ (u1 :: {{Ord u0}}) (u2 :: u0) (u3 :: u0) -> _APP_ _TYAPP_ patError# { (u0 -> u0 -> Bool) } [ _NOREP_S_ "%DPreludeCore.Ord.(<=)\"", u2, u3 ] _N_ #-}
+ {-defm-} _A_ 3 _U_ 022 _N_ _S_ _!_ _N_ _N_ #-}
(>=) :: a -> a -> Bool
{-# GHC_PRAGMA {-meth-} _A_ 1 _U_ 122 _N_ _S_ "S" _F_ _IF_ARGS_ 1 1 C 2 _/\_ u0 -> \ (u1 :: ({{Eq u0}}, u0 -> u0 -> Bool, u0 -> u0 -> Bool, u0 -> u0 -> Bool, u0 -> u0 -> Bool, u0 -> u0 -> u0, u0 -> u0 -> u0, u0 -> u0 -> _CMP_TAG)) -> case u1 of { _ALG_ _TUP_8 (u2 :: {{Eq u0}}) (u3 :: u0 -> u0 -> Bool) (u4 :: u0 -> u0 -> Bool) (u5 :: u0 -> u0 -> Bool) (u6 :: u0 -> u0 -> Bool) (u7 :: u0 -> u0 -> u0) (u8 :: u0 -> u0 -> u0) (u9 :: u0 -> u0 -> _CMP_TAG) -> u5; _NO_DEFLT_ } _N_
{-defm-} _A_ 3 _U_ 122 _N_ _S_ "SLL" _F_ _IF_ARGS_ 1 3 CXX 4 _/\_ u0 -> \ (u1 :: {{Ord u0}}) (u2 :: u0) (u3 :: u0) -> case u1 of { _ALG_ _TUP_8 (u4 :: {{Eq u0}}) (u5 :: u0 -> u0 -> Bool) (u6 :: u0 -> u0 -> Bool) (u7 :: u0 -> u0 -> Bool) (u8 :: u0 -> u0 -> Bool) (u9 :: u0 -> u0 -> u0) (ua :: u0 -> u0 -> u0) (ub :: u0 -> u0 -> _CMP_TAG) -> _APP_ u6 [ u3, u2 ]; _NO_DEFLT_ } _N_ #-}
class (Num a, Enum a) => Real a {-# GHC_PRAGMA {-superdicts-} _A_ 1 _U_ 1 _N_ _S_ "S" _F_ _IF_ARGS_ 1 1 C 2 _/\_ u0 -> \ (u1 :: ({{Num u0}}, {{Enum u0}}, u0 -> Ratio Integer)) -> case u1 of { _ALG_ _TUP_3 (u2 :: {{Num u0}}) (u3 :: {{Enum u0}}) (u4 :: u0 -> Ratio Integer) -> u2; _NO_DEFLT_ } _N_, _A_ 1 _U_ 1 _N_ _S_ "S" _F_ _IF_ARGS_ 1 1 C 2 _/\_ u0 -> \ (u1 :: ({{Num u0}}, {{Enum u0}}, u0 -> Ratio Integer)) -> case u1 of { _ALG_ _TUP_3 (u2 :: {{Num u0}}) (u3 :: {{Enum u0}}) (u4 :: u0 -> Ratio Integer) -> u3; _NO_DEFLT_ } _N_ #-} where
toRational :: a -> Ratio Integer
{-# GHC_PRAGMA {-meth-} _A_ 1 _U_ 12 _N_ _S_ "S" _F_ _IF_ARGS_ 1 1 C 2 _/\_ u0 -> \ (u1 :: ({{Num u0}}, {{Enum u0}}, u0 -> Ratio Integer)) -> case u1 of { _ALG_ _TUP_3 (u2 :: {{Num u0}}) (u3 :: {{Enum u0}}) (u4 :: u0 -> Ratio Integer) -> u4; _NO_DEFLT_ } _N_
- {-defm-} _A_ 2 _U_ 02 _N_ _S_ _!_ _F_ _IF_ARGS_ 1 2 XX 3 _/\_ u0 -> \ (u1 :: {{Real u0}}) (u2 :: u0) -> _APP_ _TYAPP_ patError# { (u0 -> Ratio Integer) } [ _NOREP_S_ "%DPreludeCore.Real.toRational\"", u2 ] _N_ #-}
+ {-defm-} _A_ 2 _U_ 02 _N_ _S_ _!_ _N_ _N_ #-}
class (RealFrac a, Floating a) => RealFloat a {-# GHC_PRAGMA {-superdicts-} _A_ 1 _U_ 1 _N_ _S_ "S" _F_ _IF_ARGS_ 1 1 C 2 _/\_ u0 -> \ (u1 :: ({{RealFrac u0}}, {{Floating u0}}, u0 -> Integer, u0 -> Int, u0 -> (Int, Int), u0 -> (Integer, Int), Integer -> Int -> u0, u0 -> Int, u0 -> u0, Int -> u0 -> u0)) -> case u1 of { _ALG_ _TUP_10 (u2 :: {{RealFrac u0}}) (u3 :: {{Floating u0}}) (u4 :: u0 -> Integer) (u5 :: u0 -> Int) (u6 :: u0 -> (Int, Int)) (u7 :: u0 -> (Integer, Int)) (u8 :: Integer -> Int -> u0) (u9 :: u0 -> Int) (ua :: u0 -> u0) (ub :: Int -> u0 -> u0) -> u2; _NO_DEFLT_ } _N_, _A_ 1 _U_ 1 _N_ _S_ "S" _F_ _IF_ARGS_ 1 1 C 2 _/\_ u0 -> \ (u1 :: ({{RealFrac u0}}, {{Floating u0}}, u0 -> Integer, u0 -> Int, u0 -> (Int, Int), u0 -> (Integer, Int), Integer -> Int -> u0, u0 -> Int, u0 -> u0, Int -> u0 -> u0)) -> case u1 of { _ALG_ _TUP_10 (u2 :: {{RealFrac u0}}) (u3 :: {{Floating u0}}) (u4 :: u0 -> Integer) (u5 :: u0 -> Int) (u6 :: u0 -> (Int, Int)) (u7 :: u0 -> (Integer, Int)) (u8 :: Integer -> Int -> u0) (u9 :: u0 -> Int) (ua :: u0 -> u0) (ub :: Int -> u0 -> u0) -> u3; _NO_DEFLT_ } _N_ #-} where
floatRadix :: a -> Integer
{-# GHC_PRAGMA {-meth-} _A_ 1 _U_ 12 _N_ _S_ "S" _F_ _IF_ARGS_ 1 1 C 2 _/\_ u0 -> \ (u1 :: ({{RealFrac u0}}, {{Floating u0}}, u0 -> Integer, u0 -> Int, u0 -> (Int, Int), u0 -> (Integer, Int), Integer -> Int -> u0, u0 -> Int, u0 -> u0, Int -> u0 -> u0)) -> case u1 of { _ALG_ _TUP_10 (u2 :: {{RealFrac u0}}) (u3 :: {{Floating u0}}) (u4 :: u0 -> Integer) (u5 :: u0 -> Int) (u6 :: u0 -> (Int, Int)) (u7 :: u0 -> (Integer, Int)) (u8 :: Integer -> Int -> u0) (u9 :: u0 -> Int) (ua :: u0 -> u0) (ub :: Int -> u0 -> u0) -> u4; _NO_DEFLT_ } _N_
- {-defm-} _A_ 2 _U_ 02 _N_ _S_ _!_ _F_ _IF_ARGS_ 1 2 XX 3 _/\_ u0 -> \ (u1 :: {{RealFloat u0}}) (u2 :: u0) -> _APP_ _TYAPP_ patError# { (u0 -> Integer) } [ _NOREP_S_ "%DPreludeCore.RealFloat.floatRadix\"", u2 ] _N_ #-}
+ {-defm-} _A_ 2 _U_ 02 _N_ _S_ _!_ _N_ _N_ #-}
floatDigits :: a -> Int
{-# GHC_PRAGMA {-meth-} _A_ 1 _U_ 12 _N_ _S_ "S" _F_ _IF_ARGS_ 1 1 C 2 _/\_ u0 -> \ (u1 :: ({{RealFrac u0}}, {{Floating u0}}, u0 -> Integer, u0 -> Int, u0 -> (Int, Int), u0 -> (Integer, Int), Integer -> Int -> u0, u0 -> Int, u0 -> u0, Int -> u0 -> u0)) -> case u1 of { _ALG_ _TUP_10 (u2 :: {{RealFrac u0}}) (u3 :: {{Floating u0}}) (u4 :: u0 -> Integer) (u5 :: u0 -> Int) (u6 :: u0 -> (Int, Int)) (u7 :: u0 -> (Integer, Int)) (u8 :: Integer -> Int -> u0) (u9 :: u0 -> Int) (ua :: u0 -> u0) (ub :: Int -> u0 -> u0) -> u5; _NO_DEFLT_ } _N_
- {-defm-} _A_ 2 _U_ 02 _N_ _S_ _!_ _F_ _IF_ARGS_ 1 2 XX 3 _/\_ u0 -> \ (u1 :: {{RealFloat u0}}) (u2 :: u0) -> _APP_ _TYAPP_ patError# { (u0 -> Int) } [ _NOREP_S_ "%DPreludeCore.RealFloat.floatDigits\"", u2 ] _N_ #-}
+ {-defm-} _A_ 2 _U_ 02 _N_ _S_ _!_ _N_ _N_ #-}
floatRange :: a -> (Int, Int)
{-# GHC_PRAGMA {-meth-} _A_ 1 _U_ 12 _N_ _S_ "S" _F_ _IF_ARGS_ 1 1 C 2 _/\_ u0 -> \ (u1 :: ({{RealFrac u0}}, {{Floating u0}}, u0 -> Integer, u0 -> Int, u0 -> (Int, Int), u0 -> (Integer, Int), Integer -> Int -> u0, u0 -> Int, u0 -> u0, Int -> u0 -> u0)) -> case u1 of { _ALG_ _TUP_10 (u2 :: {{RealFrac u0}}) (u3 :: {{Floating u0}}) (u4 :: u0 -> Integer) (u5 :: u0 -> Int) (u6 :: u0 -> (Int, Int)) (u7 :: u0 -> (Integer, Int)) (u8 :: Integer -> Int -> u0) (u9 :: u0 -> Int) (ua :: u0 -> u0) (ub :: Int -> u0 -> u0) -> u6; _NO_DEFLT_ } _N_
- {-defm-} _A_ 2 _U_ 02 _N_ _S_ _!_ _F_ _IF_ARGS_ 1 2 XX 3 _/\_ u0 -> \ (u1 :: {{RealFloat u0}}) (u2 :: u0) -> _APP_ _TYAPP_ patError# { (u0 -> (Int, Int)) } [ _NOREP_S_ "%DPreludeCore.RealFloat.floatRange\"", u2 ] _N_ #-}
+ {-defm-} _A_ 2 _U_ 02 _N_ _S_ _!_ _N_ _N_ #-}
decodeFloat :: a -> (Integer, Int)
{-# GHC_PRAGMA {-meth-} _A_ 1 _U_ 12 _N_ _S_ "S" _F_ _IF_ARGS_ 1 1 C 2 _/\_ u0 -> \ (u1 :: ({{RealFrac u0}}, {{Floating u0}}, u0 -> Integer, u0 -> Int, u0 -> (Int, Int), u0 -> (Integer, Int), Integer -> Int -> u0, u0 -> Int, u0 -> u0, Int -> u0 -> u0)) -> case u1 of { _ALG_ _TUP_10 (u2 :: {{RealFrac u0}}) (u3 :: {{Floating u0}}) (u4 :: u0 -> Integer) (u5 :: u0 -> Int) (u6 :: u0 -> (Int, Int)) (u7 :: u0 -> (Integer, Int)) (u8 :: Integer -> Int -> u0) (u9 :: u0 -> Int) (ua :: u0 -> u0) (ub :: Int -> u0 -> u0) -> u7; _NO_DEFLT_ } _N_
- {-defm-} _A_ 2 _U_ 02 _N_ _S_ _!_ _F_ _IF_ARGS_ 1 2 XX 3 _/\_ u0 -> \ (u1 :: {{RealFloat u0}}) (u2 :: u0) -> _APP_ _TYAPP_ patError# { (u0 -> (Integer, Int)) } [ _NOREP_S_ "%DPreludeCore.RealFloat.decodeFloat\"", u2 ] _N_ #-}
+ {-defm-} _A_ 2 _U_ 02 _N_ _S_ _!_ _N_ _N_ #-}
encodeFloat :: Integer -> Int -> a
{-# GHC_PRAGMA {-meth-} _A_ 1 _U_ 122 _N_ _S_ "S" _F_ _IF_ARGS_ 1 1 C 2 _/\_ u0 -> \ (u1 :: ({{RealFrac u0}}, {{Floating u0}}, u0 -> Integer, u0 -> Int, u0 -> (Int, Int), u0 -> (Integer, Int), Integer -> Int -> u0, u0 -> Int, u0 -> u0, Int -> u0 -> u0)) -> case u1 of { _ALG_ _TUP_10 (u2 :: {{RealFrac u0}}) (u3 :: {{Floating u0}}) (u4 :: u0 -> Integer) (u5 :: u0 -> Int) (u6 :: u0 -> (Int, Int)) (u7 :: u0 -> (Integer, Int)) (u8 :: Integer -> Int -> u0) (u9 :: u0 -> Int) (ua :: u0 -> u0) (ub :: Int -> u0 -> u0) -> u8; _NO_DEFLT_ } _N_
- {-defm-} _A_ 3 _U_ 022 _N_ _S_ _!_ _F_ _IF_ARGS_ 1 3 XXX 4 _/\_ u0 -> \ (u1 :: {{RealFloat u0}}) (u2 :: Integer) (u3 :: Int) -> _APP_ _TYAPP_ patError# { (Integer -> Int -> u0) } [ _NOREP_S_ "%DPreludeCore.RealFloat.encodeFloat\"", u2, u3 ] _N_ #-}
+ {-defm-} _A_ 3 _U_ 022 _N_ _S_ _!_ _N_ _N_ #-}
exponent :: a -> Int
{-# GHC_PRAGMA {-meth-} _A_ 1 _U_ 12 _N_ _S_ "S" _F_ _IF_ARGS_ 1 1 C 2 _/\_ u0 -> \ (u1 :: ({{RealFrac u0}}, {{Floating u0}}, u0 -> Integer, u0 -> Int, u0 -> (Int, Int), u0 -> (Integer, Int), Integer -> Int -> u0, u0 -> Int, u0 -> u0, Int -> u0 -> u0)) -> case u1 of { _ALG_ _TUP_10 (u2 :: {{RealFrac u0}}) (u3 :: {{Floating u0}}) (u4 :: u0 -> Integer) (u5 :: u0 -> Int) (u6 :: u0 -> (Int, Int)) (u7 :: u0 -> (Integer, Int)) (u8 :: Integer -> Int -> u0) (u9 :: u0 -> Int) (ua :: u0 -> u0) (ub :: Int -> u0 -> u0) -> u9; _NO_DEFLT_ } _N_
{-defm-} _A_ 2 _U_ 12 _N_ _S_ "SL" _N_ _N_ #-}
class (Real a, Fractional a) => RealFrac a {-# GHC_PRAGMA {-superdicts-} _A_ 1 _U_ 1 _N_ _S_ "S" _F_ _IF_ARGS_ 1 1 C 2 _/\_ u0 -> \ (u1 :: ({{Real u0}}, {{Fractional u0}}, (_forall_ z$z1 =>{{Integral z$z1}} -> u0 -> (z$z1, u0)), (_forall_ z$z1 =>{{Integral z$z1}} -> u0 -> z$z1), (_forall_ z$z1 =>{{Integral z$z1}} -> u0 -> z$z1), (_forall_ z$z1 =>{{Integral z$z1}} -> u0 -> z$z1), (_forall_ z$z1 =>{{Integral z$z1}} -> u0 -> z$z1))) -> case u1 of { _ALG_ _TUP_7 (u2 :: {{Real u0}}) (u3 :: {{Fractional u0}}) (u4 :: _forall_ a$z1 =>{{Integral a$z1}} -> u0 -> (a$z1, u0)) (u5 :: _forall_ a$z1 =>{{Integral a$z1}} -> u0 -> a$z1) (u6 :: _forall_ a$z1 =>{{Integral a$z1}} -> u0 -> a$z1) (u7 :: _forall_ a$z1 =>{{Integral a$z1}} -> u0 -> a$z1) (u8 :: _forall_ a$z1 =>{{Integral a$z1}} -> u0 -> a$z1) -> u2; _NO_DEFLT_ } _N_, _A_ 1 _U_ 1 _N_ _S_ "S" _F_ _IF_ARGS_ 1 1 C 2 _/\_ u0 -> \ (u1 :: ({{Real u0}}, {{Fractional u0}}, (_forall_ z$z1 =>{{Integral z$z1}} -> u0 -> (z$z1, u0)), (_forall_ z$z1 =>{{Integral z$z1}} -> u0 -> z$z1), (_forall_ z$z1 =>{{Integral z$z1}} -> u0 -> z$z1), (_forall_ z$z1 =>{{Integral z$z1}} -> u0 -> z$z1), (_forall_ z$z1 =>{{Integral z$z1}} -> u0 -> z$z1))) -> case u1 of { _ALG_ _TUP_7 (u2 :: {{Real u0}}) (u3 :: {{Fractional u0}}) (u4 :: _forall_ a$z1 =>{{Integral a$z1}} -> u0 -> (a$z1, u0)) (u5 :: _forall_ a$z1 =>{{Integral a$z1}} -> u0 -> a$z1) (u6 :: _forall_ a$z1 =>{{Integral a$z1}} -> u0 -> a$z1) (u7 :: _forall_ a$z1 =>{{Integral a$z1}} -> u0 -> a$z1) (u8 :: _forall_ a$z1 =>{{Integral a$z1}} -> u0 -> a$z1) -> u3; _NO_DEFLT_ } _N_ #-} where
properFraction :: Integral b => a -> (b, a)
{-# GHC_PRAGMA {-meth-} _A_ 2 _U_ 122 _N_ _S_ "SL" _F_ _IF_ARGS_ 2 2 CX 3 _/\_ u0 u1 -> \ (u2 :: ({{Real u0}}, {{Fractional u0}}, (_forall_ z$z1 =>{{Integral z$z1}} -> u0 -> (z$z1, u0)), (_forall_ z$z1 =>{{Integral z$z1}} -> u0 -> z$z1), (_forall_ z$z1 =>{{Integral z$z1}} -> u0 -> z$z1), (_forall_ z$z1 =>{{Integral z$z1}} -> u0 -> z$z1), (_forall_ z$z1 =>{{Integral z$z1}} -> u0 -> z$z1))) (u3 :: {{Integral u1}}) -> case u2 of { _ALG_ _TUP_7 (u4 :: {{Real u0}}) (u5 :: {{Fractional u0}}) (u6 :: _forall_ a$z1 =>{{Integral a$z1}} -> u0 -> (a$z1, u0)) (u7 :: _forall_ a$z1 =>{{Integral a$z1}} -> u0 -> a$z1) (u8 :: _forall_ a$z1 =>{{Integral a$z1}} -> u0 -> a$z1) (u9 :: _forall_ a$z1 =>{{Integral a$z1}} -> u0 -> a$z1) (ua :: _forall_ a$z1 =>{{Integral a$z1}} -> u0 -> a$z1) -> _APP_ _TYAPP_ u6 { u1 } [ u3 ]; _NO_DEFLT_ } _N_
- {-defm-} _A_ 3 _U_ 002 _N_ _S_ _!_ _F_ _IF_ARGS_ 2 3 XXX 3 _/\_ u0 u1 -> \ (u2 :: {{RealFrac u0}}) (u3 :: {{Integral u1}}) (u4 :: u0) -> _APP_ _TYAPP_ patError# { (u0 -> (u1, u0)) } [ _NOREP_S_ "%DPreludeCore.RealFrac.properFraction\"", u4 ] _N_ #-}
+ {-defm-} _A_ 3 _U_ 002 _N_ _S_ _!_ _N_ _N_ #-}
truncate :: Integral b => a -> b
{-# GHC_PRAGMA {-meth-} _A_ 2 _U_ 122 _N_ _S_ "SL" _F_ _IF_ARGS_ 2 2 CX 3 _/\_ u0 u1 -> \ (u2 :: ({{Real u0}}, {{Fractional u0}}, (_forall_ z$z1 =>{{Integral z$z1}} -> u0 -> (z$z1, u0)), (_forall_ z$z1 =>{{Integral z$z1}} -> u0 -> z$z1), (_forall_ z$z1 =>{{Integral z$z1}} -> u0 -> z$z1), (_forall_ z$z1 =>{{Integral z$z1}} -> u0 -> z$z1), (_forall_ z$z1 =>{{Integral z$z1}} -> u0 -> z$z1))) (u3 :: {{Integral u1}}) -> case u2 of { _ALG_ _TUP_7 (u4 :: {{Real u0}}) (u5 :: {{Fractional u0}}) (u6 :: _forall_ a$z1 =>{{Integral a$z1}} -> u0 -> (a$z1, u0)) (u7 :: _forall_ a$z1 =>{{Integral a$z1}} -> u0 -> a$z1) (u8 :: _forall_ a$z1 =>{{Integral a$z1}} -> u0 -> a$z1) (u9 :: _forall_ a$z1 =>{{Integral a$z1}} -> u0 -> a$z1) (ua :: _forall_ a$z1 =>{{Integral a$z1}} -> u0 -> a$z1) -> _APP_ _TYAPP_ u7 { u1 } [ u3 ]; _NO_DEFLT_ } _N_
{-defm-} _A_ 2 _U_ 122 _N_ _S_ "SL" _N_ _N_ #-}
class Text a where
readsPrec :: Int -> [Char] -> [(a, [Char])]
{-# GHC_PRAGMA {-meth-} _A_ 1 _U_ 122 _N_ _S_ "S" _F_ _IF_ARGS_ 1 1 C 2 _/\_ u0 -> \ (u1 :: (Int -> [Char] -> [(u0, [Char])], Int -> u0 -> [Char] -> [Char], [Char] -> [([u0], [Char])], [u0] -> [Char] -> [Char])) -> case u1 of { _ALG_ _TUP_4 (u2 :: Int -> [Char] -> [(u0, [Char])]) (u3 :: Int -> u0 -> [Char] -> [Char]) (u4 :: [Char] -> [([u0], [Char])]) (u5 :: [u0] -> [Char] -> [Char]) -> u2; _NO_DEFLT_ } _N_
- {-defm-} _A_ 3 _U_ 022 _N_ _S_ _!_ _F_ _IF_ARGS_ 1 3 XXX 4 _/\_ u0 -> \ (u1 :: {{Text u0}}) (u2 :: Int) (u3 :: [Char]) -> _APP_ _TYAPP_ patError# { (Int -> [Char] -> [(u0, [Char])]) } [ _NOREP_S_ "%DPreludeCore.Text.readsPrec\"", u2, u3 ] _N_ #-}
+ {-defm-} _A_ 3 _U_ 022 _N_ _S_ _!_ _N_ _N_ #-}
showsPrec :: Int -> a -> [Char] -> [Char]
{-# GHC_PRAGMA {-meth-} _A_ 1 _U_ 1222 _N_ _S_ "S" _F_ _IF_ARGS_ 1 1 C 2 _/\_ u0 -> \ (u1 :: (Int -> [Char] -> [(u0, [Char])], Int -> u0 -> [Char] -> [Char], [Char] -> [([u0], [Char])], [u0] -> [Char] -> [Char])) -> case u1 of { _ALG_ _TUP_4 (u2 :: Int -> [Char] -> [(u0, [Char])]) (u3 :: Int -> u0 -> [Char] -> [Char]) (u4 :: [Char] -> [([u0], [Char])]) (u5 :: [u0] -> [Char] -> [Char]) -> u3; _NO_DEFLT_ } _N_
- {-defm-} _A_ 4 _U_ 0222 _N_ _S_ _!_ _F_ _IF_ARGS_ 1 4 XXXX 5 _/\_ u0 -> \ (u1 :: {{Text u0}}) (u2 :: Int) (u3 :: u0) (u4 :: [Char]) -> _APP_ _TYAPP_ patError# { (Int -> u0 -> [Char] -> [Char]) } [ _NOREP_S_ "%DPreludeCore.Text.showsPrec\"", u2, u3, u4 ] _N_ #-}
+ {-defm-} _A_ 4 _U_ 0222 _N_ _S_ _!_ _N_ _N_ #-}
readList :: [Char] -> [([a], [Char])]
{-# GHC_PRAGMA {-meth-} _A_ 1 _U_ 12 _N_ _S_ "S" _F_ _IF_ARGS_ 1 1 C 2 _/\_ u0 -> \ (u1 :: (Int -> [Char] -> [(u0, [Char])], Int -> u0 -> [Char] -> [Char], [Char] -> [([u0], [Char])], [u0] -> [Char] -> [Char])) -> case u1 of { _ALG_ _TUP_4 (u2 :: Int -> [Char] -> [(u0, [Char])]) (u3 :: Int -> u0 -> [Char] -> [Char]) (u4 :: [Char] -> [([u0], [Char])]) (u5 :: [u0] -> [Char] -> [Char]) -> u4; _NO_DEFLT_ } _N_
- {-defm-} _A_ 1 _U_ 22 _N_ _N_ _F_ _IF_ARGS_ 0 0 X 1 _ORIG_ PreludeCore _readList _N_ #-}
+ {-defm-} _A_ 1 _U_ 12 _N_ _N_ _N_ _N_ #-}
showList :: [a] -> [Char] -> [Char]
{-# GHC_PRAGMA {-meth-} _A_ 1 _U_ 122 _N_ _S_ "S" _F_ _IF_ARGS_ 1 1 C 2 _/\_ u0 -> \ (u1 :: (Int -> [Char] -> [(u0, [Char])], Int -> u0 -> [Char] -> [Char], [Char] -> [([u0], [Char])], [u0] -> [Char] -> [Char])) -> case u1 of { _ALG_ _TUP_4 (u2 :: Int -> [Char] -> [(u0, [Char])]) (u3 :: Int -> u0 -> [Char] -> [Char]) (u4 :: [Char] -> [([u0], [Char])]) (u5 :: [u0] -> [Char] -> [Char]) -> u5; _NO_DEFLT_ } _N_
- {-defm-} _A_ 1 _U_ 212 _N_ _N_ _F_ _IF_ARGS_ 0 0 X 1 _ORIG_ PreludeCore _showList _N_ #-}
+ {-defm-} _A_ 1 _U_ 112 _N_ _N_ _N_ _N_ #-}
class _CCallable a
class _CReturnable a
data Array a b {-# GHC_PRAGMA _Array (a, a) (Array# b) #-}
data Assoc a b = (:=) a b
data _ByteArray a {-# GHC_PRAGMA _ByteArray (a, a) ByteArray# #-}
data Bin
-data Complex a = (:+) a a
+data Complex a = (:+) a a {-# GHC_PRAGMA _SPECIALISE_ [ Double# ] #-}
data _MutableArray a b c {-# GHC_PRAGMA _MutableArray (b, b) (MutableArray# a c) #-}
data _MutableByteArray a b {-# GHC_PRAGMA _MutableByteArray (b, b) (MutableByteArray# a) #-}
type BinCont = Bin -> [Response] -> [Request]
type ReadS a = [Char] -> [(a, [Char])]
type ShowS = [Char] -> [Char]
data _FILE {-# GHC_PRAGMA _FILE Addr# #-}
+__i0 :: Num a => a
+ {-# GHC_PRAGMA _A_ 1 _U_ 1 _N_ _S_ "U(AAAAAAAAAS)" {_A_ 1 _U_ 1 _N_ _N_ _N_ _N_} _N_ _SPECIALISE_ [ Double ] 1 { _A_ 0 _N_ _N_ _N_ _F_ _IF_ARGS_ 0 0 X 2 _!_ D# [] [0.0000000000000000##] _N_ }, [ Int ] 1 { _A_ 0 _N_ _N_ _N_ _F_ _IF_ARGS_ 0 0 X 2 _!_ I# [] [0#] _N_ }, [ Integer ] 1 { _A_ 0 _N_ _N_ _N_ _N_ _N_ }, [ (Ratio Integer) ] 1 { _A_ 0 _N_ _N_ _N_ _N_ _N_ }, [ (Complex Double) ] 1 { _A_ 0 _N_ _N_ _N_ _N_ _N_ } #-}
+__i1 :: Num a => a
+ {-# GHC_PRAGMA _A_ 1 _U_ 1 _N_ _S_ "U(AAAAAAAAAS)" {_A_ 1 _U_ 1 _N_ _N_ _N_ _N_} _N_ _SPECIALISE_ [ Double ] 1 { _A_ 0 _N_ _N_ _N_ _F_ _IF_ARGS_ 0 0 X 2 _!_ D# [] [1.0000000000000000##] _N_ }, [ Int ] 1 { _A_ 0 _N_ _N_ _N_ _F_ _IF_ARGS_ 0 0 X 2 _!_ I# [] [1#] _N_ }, [ Integer ] 1 { _A_ 0 _N_ _N_ _N_ _N_ _N_ }, [ (Ratio Integer) ] 1 { _A_ 0 _N_ _N_ _N_ _N_ _N_ }, [ (Complex Double) ] 1 { _A_ 0 _N_ _N_ _N_ _N_ _N_ } #-}
+__i10 :: Num a => a
+ {-# GHC_PRAGMA _A_ 1 _U_ 1 _N_ _S_ "U(AAAAAAAAAS)" {_A_ 1 _U_ 1 _N_ _N_ _N_ _N_} _N_ _SPECIALISE_ [ Double ] 1 { _A_ 0 _N_ _N_ _N_ _F_ _IF_ARGS_ 0 0 X 2 _!_ D# [] [10.000000000000000##] _N_ }, [ Int ] 1 { _A_ 0 _N_ _N_ _N_ _F_ _IF_ARGS_ 0 0 X 2 _!_ I# [] [10#] _N_ }, [ Integer ] 1 { _A_ 0 _N_ _N_ _N_ _N_ _N_ }, [ (Ratio Integer) ] 1 { _A_ 0 _N_ _N_ _N_ _N_ _N_ }, [ (Complex Double) ] 1 { _A_ 0 _N_ _N_ _N_ _N_ _N_ } #-}
+__i16 :: Num a => a
+ {-# GHC_PRAGMA _A_ 1 _U_ 1 _N_ _S_ "U(AAAAAAAAAS)" {_A_ 1 _U_ 1 _N_ _N_ _N_ _N_} _N_ _SPECIALISE_ [ Double ] 1 { _A_ 0 _N_ _N_ _N_ _F_ _IF_ARGS_ 0 0 X 2 _!_ D# [] [16.000000000000000##] _N_ }, [ Int ] 1 { _A_ 0 _N_ _N_ _N_ _F_ _IF_ARGS_ 0 0 X 2 _!_ I# [] [16#] _N_ }, [ Integer ] 1 { _A_ 0 _N_ _N_ _N_ _N_ _N_ }, [ (Ratio Integer) ] 1 { _A_ 0 _N_ _N_ _N_ _N_ _N_ }, [ (Complex Double) ] 1 { _A_ 0 _N_ _N_ _N_ _N_ _N_ } #-}
+__i2 :: Num a => a
+ {-# GHC_PRAGMA _A_ 1 _U_ 1 _N_ _S_ "U(AAAAAAAAAS)" {_A_ 1 _U_ 1 _N_ _N_ _N_ _N_} _N_ _SPECIALISE_ [ Double ] 1 { _A_ 0 _N_ _N_ _N_ _F_ _IF_ARGS_ 0 0 X 2 _!_ D# [] [2.0000000000000000##] _N_ }, [ Int ] 1 { _A_ 0 _N_ _N_ _N_ _F_ _IF_ARGS_ 0 0 X 2 _!_ I# [] [2#] _N_ }, [ Integer ] 1 { _A_ 0 _N_ _N_ _N_ _N_ _N_ }, [ (Ratio Integer) ] 1 { _A_ 0 _N_ _N_ _N_ _N_ _N_ }, [ (Complex Double) ] 1 { _A_ 0 _N_ _N_ _N_ _N_ _N_ } #-}
+__i8 :: Num a => a
+ {-# GHC_PRAGMA _A_ 1 _U_ 1 _N_ _S_ "U(AAAAAAAAAS)" {_A_ 1 _U_ 1 _N_ _N_ _N_ _N_} _N_ _SPECIALISE_ [ Double ] 1 { _A_ 0 _N_ _N_ _N_ _F_ _IF_ARGS_ 0 0 X 2 _!_ D# [] [8.0000000000000000##] _N_ }, [ Int ] 1 { _A_ 0 _N_ _N_ _N_ _F_ _IF_ARGS_ 0 0 X 2 _!_ I# [] [8#] _N_ }, [ Integer ] 1 { _A_ 0 _N_ _N_ _N_ _N_ _N_ }, [ (Ratio Integer) ] 1 { _A_ 0 _N_ _N_ _N_ _N_ _N_ }, [ (Complex Double) ] 1 { _A_ 0 _N_ _N_ _N_ _N_ _N_ } #-}
+__im1 :: Num a => a
+ {-# GHC_PRAGMA _A_ 1 _U_ 1 _N_ _S_ "U(AAAAAAAAAS)" {_A_ 1 _U_ 1 _N_ _N_ _N_ _N_} _N_ _SPECIALISE_ [ Double ] 1 { _A_ 0 _N_ _N_ _N_ _F_ _IF_ARGS_ 0 0 X 2 _!_ D# [] [-1.0000000000000000##] _N_ }, [ Int ] 1 { _A_ 0 _N_ _N_ _N_ _F_ _IF_ARGS_ 0 0 X 2 _!_ I# [] [-1#] _N_ }, [ Integer ] 1 { _A_ 0 _N_ _N_ _N_ _N_ _N_ }, [ (Ratio Integer) ] 1 { _A_ 0 _N_ _N_ _N_ _N_ _N_ }, [ (Complex Double) ] 1 { _A_ 0 _N_ _N_ _N_ _N_ _N_ } #-}
+__integer0 :: Integer
+ {-# GHC_PRAGMA _A_ 0 _N_ _N_ _N_ _N_ _N_ #-}
+__integer1 :: Integer
+ {-# GHC_PRAGMA _A_ 0 _N_ _N_ _N_ _N_ _N_ #-}
+__integer2 :: Integer
+ {-# GHC_PRAGMA _A_ 0 _N_ _N_ _N_ _N_ _N_ #-}
+__integerm1 :: Integer
+ {-# GHC_PRAGMA _A_ 0 _N_ _N_ _N_ _N_ _N_ #-}
+__rhalf :: Fractional a => a
+ {-# GHC_PRAGMA _A_ 1 _U_ 1 _N_ _S_ "U(AAAS)" {_A_ 1 _U_ 1 _N_ _N_ _N_ _N_} _N_ _SPECIALISE_ [ Double ] 1 { _A_ 0 _N_ _N_ _N_ _N_ _N_ }, [ (Ratio Integer) ] 1 { _A_ 0 _N_ _N_ _N_ _F_ _IF_ARGS_ 0 0 X 3 _!_ (:%) [Integer] [_SPEC_ _ORIG_ PreludeCore __i1 [ (Integer) ], _SPEC_ _ORIG_ PreludeCore __i2 [ (Integer) ]] _N_ }, [ (Complex Double) ] 1 { _A_ 0 _N_ _N_ _N_ _N_ _N_ } #-}
+_fromRational :: RealFloat a => Ratio Integer -> a
+ {-# GHC_PRAGMA _A_ 2 _U_ 22 _N_ _N_ _N_ _SPECIALISE_ [ Double ] 1 { _A_ 1 _U_ 1 _N_ _S_ "U(U(PPP)U(PPP))" {_A_ 4 _U_ 2221 _N_ _N_ _N_ _N_} _N_ _N_ } #-}
instance Enum ()
{-# GHC_PRAGMA _M_ PreludeBuiltin {-dfun-} _A_ 0 _N_ _N_ _N_ _F_ _IF_ARGS_ 0 0 X 6 _!_ _TUP_5 [{{Ord ()}}, (() -> [()]), (() -> () -> [()]), (() -> () -> [()]), (() -> () -> () -> [()])] [_DFUN_ Ord (()), _CONSTM_ Enum enumFrom (()), _CONSTM_ Enum enumFromThen (()), _CONSTM_ Enum enumFromTo (()), _CONSTM_ Enum enumFromThenTo (())] _N_
- enumFrom = _A_ 1 _U_ 2 _N_ _S_ "E" _N_ _N_,
- enumFromThen = _A_ 2 _U_ 21 _N_ _S_ "EE" _F_ _IF_ARGS_ 0 2 CC 7 \ (u0 :: ()) (u1 :: ()) -> case u0 of { _ALG_ _TUP_0 -> case u1 of { _ALG_ _TUP_0 -> let {(u2 :: [()]) = _!_ _NIL_ [()] []} in _!_ (:) [()] [u0, u2]; _NO_DEFLT_ }; _NO_DEFLT_ } _N_,
- enumFromTo = _A_ 2 _U_ 21 _N_ _S_ "EE" _F_ _IF_ARGS_ 0 2 CC 7 \ (u0 :: ()) (u1 :: ()) -> case u0 of { _ALG_ _TUP_0 -> case u1 of { _ALG_ _TUP_0 -> let {(u2 :: [()]) = _!_ _NIL_ [()] []} in _!_ (:) [()] [u0, u2]; _NO_DEFLT_ }; _NO_DEFLT_ } _N_,
- enumFromThenTo = _A_ 3 _U_ 211 _N_ _S_ "EEE" _F_ _IF_ARGS_ 0 3 CCC 8 \ (u0 :: ()) (u1 :: ()) (u2 :: ()) -> case u0 of { _ALG_ _TUP_0 -> case u1 of { _ALG_ _TUP_0 -> case u2 of { _ALG_ _TUP_0 -> let {(u3 :: [()]) = _!_ _NIL_ [()] []} in _!_ (:) [()] [u0, u3]; _NO_DEFLT_ }; _NO_DEFLT_ }; _NO_DEFLT_ } _N_ #-}
+ enumFrom = { _A_ 1 _U_ 2 _N_ _S_ "E" _N_ _N_ },
+ enumFromThen = { _A_ 2 _U_ 21 _N_ _S_ "EE" _F_ _IF_ARGS_ 0 2 CC 7 \ (u0 :: ()) (u1 :: ()) -> case u0 of { _ALG_ _TUP_0 -> case u1 of { _ALG_ _TUP_0 -> let {(u2 :: [()]) = _!_ _NIL_ [()] []} in _!_ (:) [()] [u0, u2]; _NO_DEFLT_ }; _NO_DEFLT_ } _N_ },
+ enumFromTo = { _A_ 2 _U_ 21 _N_ _S_ "EE" _F_ _IF_ARGS_ 0 2 CC 7 \ (u0 :: ()) (u1 :: ()) -> case u0 of { _ALG_ _TUP_0 -> case u1 of { _ALG_ _TUP_0 -> let {(u2 :: [()]) = _!_ _NIL_ [()] []} in _!_ (:) [()] [u0, u2]; _NO_DEFLT_ }; _NO_DEFLT_ } _N_ },
+ enumFromThenTo = { _A_ 3 _U_ 211 _N_ _S_ "EEE" _F_ _IF_ARGS_ 0 3 CCC 8 \ (u0 :: ()) (u1 :: ()) (u2 :: ()) -> case u0 of { _ALG_ _TUP_0 -> case u1 of { _ALG_ _TUP_0 -> case u2 of { _ALG_ _TUP_0 -> let {(u3 :: [()]) = _!_ _NIL_ [()] []} in _!_ (:) [()] [u0, u3]; _NO_DEFLT_ }; _NO_DEFLT_ }; _NO_DEFLT_ } _N_ } #-}
instance Enum Bool
{-# GHC_PRAGMA _M_ PreludeCore {-dfun-} _A_ 0 _N_ _N_ _N_ _F_ _IF_ARGS_ 0 0 X 6 _!_ _TUP_5 [{{Ord Bool}}, (Bool -> [Bool]), (Bool -> Bool -> [Bool]), (Bool -> Bool -> [Bool]), (Bool -> Bool -> Bool -> [Bool])] [_DFUN_ Ord (Bool), _CONSTM_ Enum enumFrom (Bool), _CONSTM_ Enum enumFromThen (Bool), _CONSTM_ Enum enumFromTo (Bool), _CONSTM_ Enum enumFromThenTo (Bool)] _N_
- enumFrom = _A_ 1 _U_ 2 _N_ _S_ "E" _N_ _N_,
- enumFromThen = _A_ 2 _U_ 22 _N_ _S_ "EE" _N_ _N_,
- enumFromTo = _A_ 2 _U_ 22 _N_ _N_ _N_ _N_,
- enumFromThenTo = _A_ 3 _U_ 222 _N_ _N_ _N_ _N_ #-}
+ enumFrom = { _A_ 1 _U_ 2 _N_ _S_ "E" _N_ _N_ },
+ enumFromThen = { _A_ 2 _U_ 22 _N_ _S_ "EE" _N_ _N_ },
+ enumFromTo = { _A_ 2 _U_ 22 _N_ _S_ "EL" _N_ _N_ },
+ enumFromThenTo = { _A_ 3 _U_ 222 _N_ _S_ "EEL" _N_ _N_ } #-}
instance Enum Char
{-# GHC_PRAGMA _M_ PreludeCore {-dfun-} _A_ 0 _N_ _N_ _N_ _F_ _IF_ARGS_ 0 0 X 6 _!_ _TUP_5 [{{Ord Char}}, (Char -> [Char]), (Char -> Char -> [Char]), (Char -> Char -> [Char]), (Char -> Char -> Char -> [Char])] [_DFUN_ Ord (Char), _CONSTM_ Enum enumFrom (Char), _CONSTM_ Enum enumFromThen (Char), _CONSTM_ Enum enumFromTo (Char), _CONSTM_ Enum enumFromThenTo (Char)] _N_
- enumFrom = _A_ 1 _U_ 1 _N_ _S_ "U(P)" {_A_ 1 _U_ 2 _N_ _N_ _N_ _N_} _N_ _N_,
- enumFromThen = _A_ 2 _U_ 22 _N_ _N_ _N_ _N_,
- enumFromTo = _A_ 2 _U_ 22 _N_ _N_ _N_ _N_,
- enumFromThenTo = _A_ 3 _U_ 222 _N_ _N_ _N_ _N_ #-}
+ enumFrom = { _A_ 1 _U_ 1 _N_ _S_ "U(P)" {_A_ 1 _U_ 2 _N_ _N_ _N_ _N_} _N_ _N_ },
+ enumFromThen = { _A_ 2 _U_ 22 _N_ _N_ _N_ _N_ },
+ enumFromTo = { _A_ 2 _U_ 12 _N_ _S_ "U(P)L" {_A_ 2 _U_ 22 _N_ _N_ _N_ _N_} _N_ _N_ },
+ enumFromThenTo = { _A_ 3 _U_ 222 _N_ _N_ _N_ _N_ } #-}
instance Enum Double
{-# GHC_PRAGMA _M_ PreludeCore {-dfun-} _A_ 0 _N_ _N_ _N_ _F_ _IF_ARGS_ 0 0 X 6 _!_ _TUP_5 [{{Ord Double}}, (Double -> [Double]), (Double -> Double -> [Double]), (Double -> Double -> [Double]), (Double -> Double -> Double -> [Double])] [_DFUN_ Ord (Double), _CONSTM_ Enum enumFrom (Double), _CONSTM_ Enum enumFromThen (Double), _CONSTM_ Enum enumFromTo (Double), _CONSTM_ Enum enumFromThenTo (Double)] _N_
- enumFrom = _A_ 1 _U_ 2 _N_ _N_ _N_ _N_,
- enumFromThen = _A_ 2 _U_ 21 _N_ _N_ _N_ _N_,
- enumFromTo = _A_ 2 _U_ 22 _N_ _N_ _N_ _N_,
- enumFromThenTo = _A_ 3 _U_ 222 _N_ _N_ _N_ _N_ #-}
+ enumFrom = { _A_ 1 _U_ 2 _N_ _N_ _N_ _N_ },
+ enumFromThen = { _A_ 2 _U_ 21 _N_ _N_ _N_ _N_ },
+ enumFromTo = { _A_ 2 _U_ 22 _N_ _N_ _N_ _N_ },
+ enumFromThenTo = { _A_ 3 _U_ 222 _N_ _N_ _N_ _N_ } #-}
instance Enum Float
{-# GHC_PRAGMA _M_ PreludeCore {-dfun-} _A_ 0 _N_ _N_ _N_ _F_ _IF_ARGS_ 0 0 X 6 _!_ _TUP_5 [{{Ord Float}}, (Float -> [Float]), (Float -> Float -> [Float]), (Float -> Float -> [Float]), (Float -> Float -> Float -> [Float])] [_DFUN_ Ord (Float), _CONSTM_ Enum enumFrom (Float), _CONSTM_ Enum enumFromThen (Float), _CONSTM_ Enum enumFromTo (Float), _CONSTM_ Enum enumFromThenTo (Float)] _N_
- enumFrom = _A_ 1 _U_ 2 _N_ _N_ _N_ _N_,
- enumFromThen = _A_ 2 _U_ 21 _N_ _N_ _N_ _N_,
- enumFromTo = _A_ 2 _U_ 22 _N_ _N_ _N_ _N_,
- enumFromThenTo = _A_ 3 _U_ 222 _N_ _N_ _N_ _N_ #-}
+ enumFrom = { _A_ 1 _U_ 2 _N_ _N_ _N_ _N_ },
+ enumFromThen = { _A_ 2 _U_ 21 _N_ _N_ _N_ _N_ },
+ enumFromTo = { _A_ 2 _U_ 22 _N_ _N_ _N_ _N_ },
+ enumFromThenTo = { _A_ 3 _U_ 222 _N_ _N_ _N_ _N_ } #-}
instance Enum Int
{-# GHC_PRAGMA _M_ PreludeCore {-dfun-} _A_ 0 _N_ _N_ _N_ _F_ _IF_ARGS_ 0 0 X 6 _!_ _TUP_5 [{{Ord Int}}, (Int -> [Int]), (Int -> Int -> [Int]), (Int -> Int -> [Int]), (Int -> Int -> Int -> [Int])] [_DFUN_ Ord (Int), _CONSTM_ Enum enumFrom (Int), _CONSTM_ Enum enumFromThen (Int), _CONSTM_ Enum enumFromTo (Int), _CONSTM_ Enum enumFromThenTo (Int)] _N_
- enumFrom = _A_ 1 _U_ 2 _N_ _N_ _F_ _ALWAYS_ \ (u0 :: Int) -> _LETREC_ {(u1 :: Int -> [Int]) = \ (u2 :: Int) -> let {(u6 :: [Int]) = let {(u5 :: Int) = case u2 of { _ALG_ I# (u3 :: Int#) -> case _#_ plusInt# [] [u3, 1#] of { _PRIM_ (u4 :: Int#) -> _!_ I# [] [u4] }; _NO_DEFLT_ }} in _APP_ u1 [ u5 ]} in _!_ (:) [Int] [u2, u6]} in _APP_ u1 [ u0 ] _N_,
- enumFromThen = _A_ 2 _U_ 21 _N_ _N_ _N_ _N_,
- enumFromTo = _A_ 2 _U_ 12 _N_ _S_ "SS" _F_ _ALWAYS_ \ (u0 :: Int) (u1 :: Int) -> case u0 of { _ALG_ I# (u2 :: Int#) -> _LETREC_ {(u3 :: Int# -> [Int]) = \ (u4 :: Int#) -> case u1 of { _ALG_ I# (u5 :: Int#) -> case _#_ leInt# [] [u4, u5] of { _ALG_ True -> let {(u7 :: [Int]) = case _#_ plusInt# [] [u4, 1#] of { _PRIM_ (u6 :: Int#) -> _APP_ u3 [ u6 ] }} in let {(u8 :: Int) = _!_ I# [] [u4]} in _!_ (:) [Int] [u8, u7]; False -> _!_ _NIL_ [Int] []; _NO_DEFLT_ }; _NO_DEFLT_ }} in _APP_ u3 [ u2 ]; _NO_DEFLT_ } _N_,
- enumFromThenTo = _A_ 3 _U_ 222 _N_ _N_ _N_ _N_ #-}
+ enumFrom = { _A_ 1 _U_ 2 _N_ _N_ _F_ _ALWAYS_ \ (u0 :: Int) -> _LETREC_ {(u1 :: Int -> [Int]) = \ (u2 :: Int) -> let {(u6 :: [Int]) = let {(u5 :: Int) = case u2 of { _ALG_ I# (u3 :: Int#) -> case _#_ plusInt# [] [u3, 1#] of { _PRIM_ (u4 :: Int#) -> _!_ I# [] [u4] }; _NO_DEFLT_ }} in _APP_ u1 [ u5 ]} in _!_ (:) [Int] [u2, u6]} in _APP_ u1 [ u0 ] _N_ },
+ enumFromThen = { _A_ 2 _U_ 21 _N_ _N_ _N_ _N_ },
+ enumFromTo = { _A_ 2 _U_ 12 _N_ _S_ "SS" _F_ _ALWAYS_ \ (u0 :: Int) (u1 :: Int) -> case u0 of { _ALG_ I# (u2 :: Int#) -> _LETREC_ {(u3 :: Int# -> [Int]) = \ (u4 :: Int#) -> case u1 of { _ALG_ I# (u5 :: Int#) -> case _#_ leInt# [] [u4, u5] of { _ALG_ True -> let {(u7 :: [Int]) = case _#_ plusInt# [] [u4, 1#] of { _PRIM_ (u6 :: Int#) -> _APP_ u3 [ u6 ] }} in let {(u8 :: Int) = _!_ I# [] [u4]} in _!_ (:) [Int] [u8, u7]; False -> _!_ _NIL_ [Int] []; _NO_DEFLT_ }; _NO_DEFLT_ }} in _APP_ u3 [ u2 ]; _NO_DEFLT_ } _N_ },
+ enumFromThenTo = { _A_ 3 _U_ 222 _N_ _N_ _N_ _N_ } #-}
instance Enum Integer
{-# GHC_PRAGMA _M_ PreludeCore {-dfun-} _A_ 0 _N_ _N_ _N_ _F_ _IF_ARGS_ 0 0 X 6 _!_ _TUP_5 [{{Ord Integer}}, (Integer -> [Integer]), (Integer -> Integer -> [Integer]), (Integer -> Integer -> [Integer]), (Integer -> Integer -> Integer -> [Integer])] [_DFUN_ Ord (Integer), _CONSTM_ Enum enumFrom (Integer), _CONSTM_ Enum enumFromThen (Integer), _CONSTM_ Enum enumFromTo (Integer), _CONSTM_ Enum enumFromThenTo (Integer)] _N_
- enumFrom = _A_ 1 _U_ 2 _N_ _N_ _N_ _N_,
- enumFromThen = _A_ 2 _U_ 21 _N_ _N_ _N_ _N_,
- enumFromTo = _A_ 2 _U_ 22 _N_ _N_ _N_ _N_,
- enumFromThenTo = _A_ 3 _U_ 222 _N_ _N_ _N_ _N_ #-}
+ enumFrom = { _A_ 1 _U_ 2 _N_ _N_ _N_ _N_ },
+ enumFromThen = { _A_ 2 _U_ 21 _N_ _N_ _N_ _N_ },
+ enumFromTo = { _A_ 2 _U_ 22 _N_ _N_ _N_ _N_ },
+ enumFromThenTo = { _A_ 3 _U_ 222 _N_ _N_ _N_ _N_ } #-}
instance Integral a => Enum (Ratio a)
{-# GHC_PRAGMA _M_ PreludeRatio {-dfun-} _A_ 2 _U_ 22 _N_ _N_ _N_ _N_ #-}
instance Enum (Ratio Integer)
{-# GHC_PRAGMA _M_ PreludeRatio {-dfun-} _A_ 0 _N_ _N_ _N_ _F_ _IF_ARGS_ 0 0 X 6 _!_ _TUP_5 [{{Ord (Ratio Integer)}}, (Ratio Integer -> [Ratio Integer]), (Ratio Integer -> Ratio Integer -> [Ratio Integer]), (Ratio Integer -> Ratio Integer -> [Ratio Integer]), (Ratio Integer -> Ratio Integer -> Ratio Integer -> [Ratio Integer])] [_DFUN_ Ord (Ratio Integer), _CONSTM_ Enum enumFrom (Ratio Integer), _CONSTM_ Enum enumFromThen (Ratio Integer), _CONSTM_ Enum enumFromTo (Ratio Integer), _CONSTM_ Enum enumFromThenTo (Ratio Integer)] _N_
- enumFrom = _A_ 1 _U_ 2 _N_ _N_ _N_ _N_,
- enumFromThen = _A_ 2 _U_ 21 _N_ _N_ _N_ _N_,
- enumFromTo = _A_ 2 _U_ 22 _N_ _N_ _N_ _N_,
- enumFromThenTo = _A_ 3 _U_ 222 _N_ _N_ _N_ _N_ #-}
+ enumFrom = { _A_ 1 _U_ 2 _N_ _N_ _N_ _N_ },
+ enumFromThen = { _A_ 2 _U_ 21 _N_ _N_ _N_ _N_ },
+ enumFromTo = { _A_ 2 _U_ 22 _N_ _N_ _N_ _N_ },
+ enumFromThenTo = { _A_ 3 _U_ 222 _N_ _N_ _N_ _N_ } #-}
instance Eq ()
{-# GHC_PRAGMA _M_ PreludeBuiltin {-dfun-} _A_ 0 _N_ _N_ _N_ _F_ _IF_ARGS_ 0 0 X 3 _!_ _TUP_2 [(() -> () -> Bool), (() -> () -> Bool)] [_CONSTM_ Eq (==) (()), _CONSTM_ Eq (/=) (())] _N_
- (==) = _A_ 2 _U_ 11 _N_ _S_ "EE" _F_ _IF_ARGS_ 0 2 CC 3 \ (u0 :: ()) (u1 :: ()) -> case u0 of { _ALG_ _TUP_0 -> case u1 of { _ALG_ _TUP_0 -> _!_ True [] []; _NO_DEFLT_ }; _NO_DEFLT_ } _N_,
- (/=) = _A_ 2 _U_ 11 _N_ _S_ "EE" _F_ _IF_ARGS_ 0 2 CC 3 \ (u0 :: ()) (u1 :: ()) -> case u0 of { _ALG_ _TUP_0 -> case u1 of { _ALG_ _TUP_0 -> _!_ False [] []; _NO_DEFLT_ }; _NO_DEFLT_ } _N_ #-}
+ (==) = { _A_ 2 _U_ 11 _N_ _S_ "EE" _F_ _IF_ARGS_ 0 2 CC 3 \ (u0 :: ()) (u1 :: ()) -> case u0 of { _ALG_ _TUP_0 -> case u1 of { _ALG_ _TUP_0 -> _!_ True [] []; _NO_DEFLT_ }; _NO_DEFLT_ } _N_ },
+ (/=) = { _A_ 2 _U_ 11 _N_ _S_ "EE" _F_ _IF_ARGS_ 0 2 CC 3 \ (u0 :: ()) (u1 :: ()) -> case u0 of { _ALG_ _TUP_0 -> case u1 of { _ALG_ _TUP_0 -> _!_ False [] []; _NO_DEFLT_ }; _NO_DEFLT_ } _N_ } #-}
instance (Eq a, Eq b) => Eq (a, b)
- {-# GHC_PRAGMA _M_ PreludeBuiltin {-dfun-} _A_ 2 _U_ 11 _N_ _N_ _N_ _N_ #-}
+ {-# GHC_PRAGMA _M_ PreludeBuiltin {-dfun-} _A_ 2 _U_ 22 _N_ _N_ _N_ _N_ #-}
instance (Eq a, Eq b, Eq c) => Eq (a, b, c)
{-# GHC_PRAGMA _M_ PreludeBuiltin {-dfun-} _A_ 3 _U_ 111 _N_ _N_ _N_ _N_ #-}
instance (Eq a, Eq b, Eq c, Eq d) => Eq (a, b, c, d)
{-# GHC_PRAGMA _M_ PreludeBuiltin {-dfun-} _A_ 5 _U_ 11111 _N_ _N_ _N_ _N_ #-}
instance Eq (Int, Int)
{-# GHC_PRAGMA _M_ PreludeBuiltin {-dfun-} _A_ 0 _N_ _N_ _N_ _F_ _IF_ARGS_ 0 0 X 3 _!_ _TUP_2 [((Int, Int) -> (Int, Int) -> Bool), ((Int, Int) -> (Int, Int) -> Bool)] [_CONSTM_ Eq (==) ((Int, Int)), _CONSTM_ Eq (/=) ((Int, Int))] _N_
- (==) = _A_ 2 _U_ 11 _N_ _S_ "U(U(P)L)U(U(P)L)" {_A_ 4 _U_ 2121 _N_ _N_ _F_ _IF_ARGS_ 0 4 XCXC 7 \ (u0 :: Int#) (u1 :: Int) (u2 :: Int#) (u3 :: Int) -> case _#_ eqInt# [] [u0, u2] of { _ALG_ True -> case u1 of { _ALG_ I# (u4 :: Int#) -> case u3 of { _ALG_ I# (u5 :: Int#) -> _#_ eqInt# [] [u4, u5]; _NO_DEFLT_ }; _NO_DEFLT_ }; False -> _!_ False [] []; _NO_DEFLT_ } _N_} _F_ _ALWAYS_ \ (u0 :: (Int, Int)) (u1 :: (Int, Int)) -> case u0 of { _ALG_ _TUP_2 (u2 :: Int) (u3 :: Int) -> case u2 of { _ALG_ I# (u4 :: Int#) -> case u1 of { _ALG_ _TUP_2 (u5 :: Int) (u6 :: Int) -> case u5 of { _ALG_ I# (u7 :: Int#) -> case _#_ eqInt# [] [u4, u7] of { _ALG_ True -> case u3 of { _ALG_ I# (u8 :: Int#) -> case u6 of { _ALG_ I# (u9 :: Int#) -> _#_ eqInt# [] [u8, u9]; _NO_DEFLT_ }; _NO_DEFLT_ }; False -> _!_ False [] []; _NO_DEFLT_ }; _NO_DEFLT_ }; _NO_DEFLT_ }; _NO_DEFLT_ }; _NO_DEFLT_ } _N_,
- (/=) = _A_ 2 _U_ 22 _N_ _N_ _N_ _N_ #-}
+ (==) = { _A_ 2 _U_ 11 _N_ _S_ "U(U(P)L)U(U(P)L)" {_A_ 4 _U_ 2121 _N_ _N_ _F_ _IF_ARGS_ 0 4 XCXC 7 \ (u0 :: Int#) (u1 :: Int) (u2 :: Int#) (u3 :: Int) -> case _#_ eqInt# [] [u0, u2] of { _ALG_ True -> case u1 of { _ALG_ I# (u4 :: Int#) -> case u3 of { _ALG_ I# (u5 :: Int#) -> _#_ eqInt# [] [u4, u5]; _NO_DEFLT_ }; _NO_DEFLT_ }; False -> _!_ False [] []; _NO_DEFLT_ } _N_} _F_ _ALWAYS_ \ (u0 :: (Int, Int)) (u1 :: (Int, Int)) -> case u0 of { _ALG_ _TUP_2 (u2 :: Int) (u3 :: Int) -> case u2 of { _ALG_ I# (u4 :: Int#) -> case u1 of { _ALG_ _TUP_2 (u5 :: Int) (u6 :: Int) -> case u5 of { _ALG_ I# (u7 :: Int#) -> case _#_ eqInt# [] [u4, u7] of { _ALG_ True -> case u3 of { _ALG_ I# (u8 :: Int#) -> case u6 of { _ALG_ I# (u9 :: Int#) -> _#_ eqInt# [] [u8, u9]; _NO_DEFLT_ }; _NO_DEFLT_ }; False -> _!_ False [] []; _NO_DEFLT_ }; _NO_DEFLT_ }; _NO_DEFLT_ }; _NO_DEFLT_ }; _NO_DEFLT_ } _N_ },
+ (/=) = { _A_ 2 _U_ 11 _N_ _S_ "U(U(P)L)U(U(P)L)" {_A_ 4 _U_ 2121 _N_ _N_ _F_ _IF_ARGS_ 0 4 XCXC 7 \ (u0 :: Int#) (u1 :: Int) (u2 :: Int#) (u3 :: Int) -> case _#_ neInt# [] [u0, u2] of { _ALG_ True -> _!_ True [] []; False -> case u1 of { _ALG_ I# (u4 :: Int#) -> case u3 of { _ALG_ I# (u5 :: Int#) -> _#_ neInt# [] [u4, u5]; _NO_DEFLT_ }; _NO_DEFLT_ }; _NO_DEFLT_ } _N_} _F_ _ALWAYS_ \ (u0 :: (Int, Int)) (u1 :: (Int, Int)) -> case u0 of { _ALG_ _TUP_2 (u2 :: Int) (u3 :: Int) -> case u2 of { _ALG_ I# (u4 :: Int#) -> case u1 of { _ALG_ _TUP_2 (u5 :: Int) (u6 :: Int) -> case u5 of { _ALG_ I# (u7 :: Int#) -> case _#_ neInt# [] [u4, u7] of { _ALG_ True -> _!_ True [] []; False -> case u3 of { _ALG_ I# (u8 :: Int#) -> case u6 of { _ALG_ I# (u9 :: Int#) -> _#_ neInt# [] [u8, u9]; _NO_DEFLT_ }; _NO_DEFLT_ }; _NO_DEFLT_ }; _NO_DEFLT_ }; _NO_DEFLT_ }; _NO_DEFLT_ }; _NO_DEFLT_ } _N_ } #-}
+instance Eq (Int, Int, Int)
+ {-# GHC_PRAGMA _M_ PreludeBuiltin {-dfun-} _A_ 0 _N_ _N_ _N_ _F_ _IF_ARGS_ 0 0 X 3 _!_ _TUP_2 [((Int, Int, Int) -> (Int, Int, Int) -> Bool), ((Int, Int, Int) -> (Int, Int, Int) -> Bool)] [_CONSTM_ Eq (==) ((Int, Int, Int)), _CONSTM_ Eq (/=) ((Int, Int, Int))] _N_
+ (==) = { _A_ 2 _U_ 11 _N_ _S_ "U(U(P)LL)U(U(P)LL)" {_A_ 4 _U_ 2111 _N_ _N_ _N_ _N_} _N_ _N_ },
+ (/=) = { _A_ 2 _U_ 11 _N_ _S_ "U(U(P)LL)U(U(P)LL)" {_A_ 4 _U_ 2111 _N_ _N_ _N_ _N_} _N_ _N_ } #-}
+instance Eq (Int, Int, Int, Int)
+ {-# GHC_PRAGMA _M_ PreludeBuiltin {-dfun-} _A_ 0 _N_ _N_ _N_ _F_ _IF_ARGS_ 0 0 X 3 _!_ _TUP_2 [((Int, Int, Int, Int) -> (Int, Int, Int, Int) -> Bool), ((Int, Int, Int, Int) -> (Int, Int, Int, Int) -> Bool)] [_CONSTM_ Eq (==) ((Int, Int, Int, Int)), _CONSTM_ Eq (/=) ((Int, Int, Int, Int))] _N_
+ (==) = { _A_ 2 _U_ 11 _N_ _S_ "U(U(P)LLL)U(U(P)LLL)" {_A_ 5 _U_ 21111 _N_ _N_ _N_ _N_} _N_ _N_ },
+ (/=) = { _A_ 2 _U_ 11 _N_ _S_ "U(U(P)LLL)U(U(P)LLL)" {_A_ 5 _U_ 21111 _N_ _N_ _N_ _N_} _N_ _N_ } #-}
+instance Eq (Int, Int, Int, Int, Int)
+ {-# GHC_PRAGMA _M_ PreludeBuiltin {-dfun-} _A_ 0 _N_ _N_ _N_ _F_ _IF_ARGS_ 0 0 X 3 _!_ _TUP_2 [((Int, Int, Int, Int, Int) -> (Int, Int, Int, Int, Int) -> Bool), ((Int, Int, Int, Int, Int) -> (Int, Int, Int, Int, Int) -> Bool)] [_CONSTM_ Eq (==) ((Int, Int, Int, Int, Int)), _CONSTM_ Eq (/=) ((Int, Int, Int, Int, Int))] _N_
+ (==) = { _A_ 2 _U_ 11 _N_ _S_ "U(U(P)LLLL)U(U(P)LLLL)" _N_ _N_ },
+ (/=) = { _A_ 2 _U_ 11 _N_ _S_ "U(U(P)LLLL)U(U(P)LLLL)" _N_ _N_ } #-}
+instance Eq ([Char], [Char])
+ {-# GHC_PRAGMA _M_ PreludeBuiltin {-dfun-} _A_ 0 _N_ _N_ _N_ _F_ _IF_ARGS_ 0 0 X 3 _!_ _TUP_2 [(([Char], [Char]) -> ([Char], [Char]) -> Bool), (([Char], [Char]) -> ([Char], [Char]) -> Bool)] [_CONSTM_ Eq (==) (([Char], [Char])), _CONSTM_ Eq (/=) (([Char], [Char]))] _N_
+ (==) = { _A_ 2 _U_ 11 _N_ _S_ "U(SL)U(SL)" {_A_ 4 _U_ 2222 _N_ _N_ _N_ _N_} _N_ _N_ },
+ (/=) = { _A_ 2 _U_ 11 _N_ _S_ "U(SL)U(SL)" {_A_ 4 _U_ 2222 _N_ _N_ _N_ _N_} _N_ _N_ } #-}
+instance Eq ([Int], [Int])
+ {-# GHC_PRAGMA _M_ PreludeBuiltin {-dfun-} _A_ 0 _N_ _N_ _N_ _F_ _IF_ARGS_ 0 0 X 3 _!_ _TUP_2 [(([Int], [Int]) -> ([Int], [Int]) -> Bool), (([Int], [Int]) -> ([Int], [Int]) -> Bool)] [_CONSTM_ Eq (==) (([Int], [Int])), _CONSTM_ Eq (/=) (([Int], [Int]))] _N_
+ (==) = { _A_ 2 _U_ 11 _N_ _S_ "U(SL)U(SL)" {_A_ 4 _U_ 2222 _N_ _N_ _N_ _N_} _N_ _N_ },
+ (/=) = { _A_ 2 _U_ 11 _N_ _S_ "U(SL)U(SL)" {_A_ 4 _U_ 2222 _N_ _N_ _N_ _N_} _N_ _N_ } #-}
instance Eq (_PackedString, _PackedString)
{-# GHC_PRAGMA _M_ PreludeBuiltin {-dfun-} _A_ 0 _N_ _N_ _N_ _F_ _IF_ARGS_ 0 0 X 3 _!_ _TUP_2 [((_PackedString, _PackedString) -> (_PackedString, _PackedString) -> Bool), ((_PackedString, _PackedString) -> (_PackedString, _PackedString) -> Bool)] [_CONSTM_ Eq (==) ((_PackedString, _PackedString)), _CONSTM_ Eq (/=) ((_PackedString, _PackedString))] _N_
- (==) = _A_ 2 _U_ 11 _N_ _S_ "U(SL)U(SL)" {_A_ 4 _U_ 2222 _N_ _N_ _N_ _N_} _N_ _N_,
- (/=) = _A_ 2 _U_ 22 _N_ _N_ _N_ _N_ #-}
+ (==) = { _A_ 2 _U_ 11 _N_ _S_ "U(SL)U(SL)" {_A_ 4 _U_ 2222 _N_ _N_ _N_ _N_} _N_ _N_ },
+ (/=) = { _A_ 2 _U_ 11 _N_ _S_ "U(SL)U(SL)" {_A_ 4 _U_ 2222 _N_ _N_ _N_ _N_} _N_ _N_ } #-}
instance (Ix a, Eq b) => Eq (Array a b)
{-# GHC_PRAGMA _M_ PreludeArray {-dfun-} _A_ 2 _U_ 21 _N_ _N_ _N_ _N_ #-}
instance (Eq a, Eq b) => Eq (Assoc a b)
{-# GHC_PRAGMA _M_ PreludeArray {-dfun-} _A_ 2 _U_ 11 _N_ _N_ _N_ _N_ #-}
instance Eq Bool
{-# GHC_PRAGMA _M_ PreludeCore {-dfun-} _A_ 0 _N_ _N_ _N_ _F_ _IF_ARGS_ 0 0 X 3 _!_ _TUP_2 [(Bool -> Bool -> Bool), (Bool -> Bool -> Bool)] [_CONSTM_ Eq (==) (Bool), _CONSTM_ Eq (/=) (Bool)] _N_
- (==) = _A_ 2 _U_ 11 _N_ _S_ "EE" _F_ _IF_ARGS_ 0 2 CC 7 \ (u0 :: Bool) (u1 :: Bool) -> case u0 of { _ALG_ True -> u1; False -> case u1 of { _ALG_ True -> _!_ False [] []; False -> _!_ True [] []; _NO_DEFLT_ }; _NO_DEFLT_ } _N_,
- (/=) = _A_ 2 _U_ 11 _N_ _S_ "EE" _F_ _IF_ARGS_ 0 2 CC 7 \ (u0 :: Bool) (u1 :: Bool) -> case u0 of { _ALG_ True -> case u1 of { _ALG_ True -> _!_ False [] []; False -> _!_ True [] []; _NO_DEFLT_ }; False -> u1; _NO_DEFLT_ } _N_ #-}
+ (==) = { _A_ 2 _U_ 11 _N_ _S_ "EE" _F_ _IF_ARGS_ 0 2 CC 7 \ (u0 :: Bool) (u1 :: Bool) -> case u0 of { _ALG_ True -> u1; False -> case u1 of { _ALG_ True -> _!_ False [] []; False -> _!_ True [] []; _NO_DEFLT_ }; _NO_DEFLT_ } _N_ },
+ (/=) = { _A_ 2 _U_ 11 _N_ _S_ "EE" _F_ _IF_ARGS_ 0 2 CC 7 \ (u0 :: Bool) (u1 :: Bool) -> case u0 of { _ALG_ True -> case u1 of { _ALG_ True -> _!_ False [] []; False -> _!_ True [] []; _NO_DEFLT_ }; False -> u1; _NO_DEFLT_ } _N_ } #-}
instance Eq Char
{-# GHC_PRAGMA _M_ PreludeCore {-dfun-} _A_ 0 _N_ _N_ _N_ _F_ _IF_ARGS_ 0 0 X 3 _!_ _TUP_2 [(Char -> Char -> Bool), (Char -> Char -> Bool)] [_CONSTM_ Eq (==) (Char), _CONSTM_ Eq (/=) (Char)] _N_
- (==) = _A_ 2 _U_ 11 _N_ _S_ "U(P)U(P)" {_A_ 2 _U_ 22 _N_ _N_ _F_ _IF_ARGS_ 0 2 XX 1 \ (u0 :: Char#) (u1 :: Char#) -> _#_ eqChar# [] [u0, u1] _N_} _F_ _IF_ARGS_ 0 2 CC 3 \ (u0 :: Char) (u1 :: Char) -> case u0 of { _ALG_ C# (u2 :: Char#) -> case u1 of { _ALG_ C# (u3 :: Char#) -> _#_ eqChar# [] [u2, u3]; _NO_DEFLT_ }; _NO_DEFLT_ } _N_,
- (/=) = _A_ 2 _U_ 11 _N_ _S_ "U(P)U(P)" {_A_ 2 _U_ 22 _N_ _N_ _F_ _IF_ARGS_ 0 2 XX 1 \ (u0 :: Char#) (u1 :: Char#) -> _#_ neChar# [] [u0, u1] _N_} _F_ _IF_ARGS_ 0 2 CC 3 \ (u0 :: Char) (u1 :: Char) -> case u0 of { _ALG_ C# (u2 :: Char#) -> case u1 of { _ALG_ C# (u3 :: Char#) -> _#_ neChar# [] [u2, u3]; _NO_DEFLT_ }; _NO_DEFLT_ } _N_ #-}
+ (==) = { _A_ 2 _U_ 11 _N_ _S_ "U(P)U(P)" {_A_ 2 _U_ 22 _N_ _N_ _F_ _IF_ARGS_ 0 2 XX 1 \ (u0 :: Char#) (u1 :: Char#) -> _#_ eqChar# [] [u0, u1] _N_} _F_ _IF_ARGS_ 0 2 CC 3 \ (u0 :: Char) (u1 :: Char) -> case u0 of { _ALG_ C# (u2 :: Char#) -> case u1 of { _ALG_ C# (u3 :: Char#) -> _#_ eqChar# [] [u2, u3]; _NO_DEFLT_ }; _NO_DEFLT_ } _N_ },
+ (/=) = { _A_ 2 _U_ 11 _N_ _S_ "U(P)U(P)" {_A_ 2 _U_ 22 _N_ _N_ _F_ _IF_ARGS_ 0 2 XX 1 \ (u0 :: Char#) (u1 :: Char#) -> _#_ neChar# [] [u0, u1] _N_} _F_ _IF_ARGS_ 0 2 CC 3 \ (u0 :: Char) (u1 :: Char) -> case u0 of { _ALG_ C# (u2 :: Char#) -> case u1 of { _ALG_ C# (u3 :: Char#) -> _#_ neChar# [] [u2, u3]; _NO_DEFLT_ }; _NO_DEFLT_ } _N_ } #-}
instance Eq a => Eq (Complex a)
{-# GHC_PRAGMA _M_ PreludeComplex {-dfun-} _A_ 1 _U_ 2 _N_ _N_ _N_ _N_ #-}
instance Eq (Complex Double)
{-# GHC_PRAGMA _M_ PreludeComplex {-dfun-} _A_ 0 _N_ _N_ _N_ _F_ _IF_ARGS_ 0 0 X 3 _!_ _TUP_2 [(Complex Double -> Complex Double -> Bool), (Complex Double -> Complex Double -> Bool)] [_CONSTM_ Eq (==) (Complex Double), _CONSTM_ Eq (/=) (Complex Double)] _N_
- (==) = _A_ 2 _U_ 11 _N_ _S_ "U(U(P)L)U(U(P)L)" {_A_ 4 _U_ 2121 _N_ _N_ _F_ _IF_ARGS_ 0 4 XCXC 7 \ (u0 :: Double#) (u1 :: Double) (u2 :: Double#) (u3 :: Double) -> case _#_ eqDouble# [] [u0, u2] of { _ALG_ True -> case u1 of { _ALG_ D# (u4 :: Double#) -> case u3 of { _ALG_ D# (u5 :: Double#) -> _#_ eqDouble# [] [u4, u5]; _NO_DEFLT_ }; _NO_DEFLT_ }; False -> _!_ False [] []; _NO_DEFLT_ } _N_} _F_ _ALWAYS_ \ (u0 :: Complex Double) (u1 :: Complex Double) -> case u0 of { _ALG_ (:+) (u2 :: Double) (u3 :: Double) -> case u2 of { _ALG_ D# (u4 :: Double#) -> case u1 of { _ALG_ (:+) (u5 :: Double) (u6 :: Double) -> case u5 of { _ALG_ D# (u7 :: Double#) -> case _#_ eqDouble# [] [u4, u7] of { _ALG_ True -> case u3 of { _ALG_ D# (u8 :: Double#) -> case u6 of { _ALG_ D# (u9 :: Double#) -> _#_ eqDouble# [] [u8, u9]; _NO_DEFLT_ }; _NO_DEFLT_ }; False -> _!_ False [] []; _NO_DEFLT_ }; _NO_DEFLT_ }; _NO_DEFLT_ }; _NO_DEFLT_ }; _NO_DEFLT_ } _N_,
- (/=) = _A_ 2 _U_ 11 _N_ _S_ "U(U(P)L)U(U(P)L)" {_A_ 4 _U_ 2121 _N_ _N_ _F_ _IF_ARGS_ 0 4 XCXC 7 \ (u0 :: Double#) (u1 :: Double) (u2 :: Double#) (u3 :: Double) -> case _#_ neDouble# [] [u0, u2] of { _ALG_ True -> _!_ True [] []; False -> case u1 of { _ALG_ D# (u4 :: Double#) -> case u3 of { _ALG_ D# (u5 :: Double#) -> _#_ neDouble# [] [u4, u5]; _NO_DEFLT_ }; _NO_DEFLT_ }; _NO_DEFLT_ } _N_} _F_ _ALWAYS_ \ (u0 :: Complex Double) (u1 :: Complex Double) -> case u0 of { _ALG_ (:+) (u2 :: Double) (u3 :: Double) -> case u2 of { _ALG_ D# (u4 :: Double#) -> case u1 of { _ALG_ (:+) (u5 :: Double) (u6 :: Double) -> case u5 of { _ALG_ D# (u7 :: Double#) -> case _#_ neDouble# [] [u4, u7] of { _ALG_ True -> _!_ True [] []; False -> case u3 of { _ALG_ D# (u8 :: Double#) -> case u6 of { _ALG_ D# (u9 :: Double#) -> _#_ neDouble# [] [u8, u9]; _NO_DEFLT_ }; _NO_DEFLT_ }; _NO_DEFLT_ }; _NO_DEFLT_ }; _NO_DEFLT_ }; _NO_DEFLT_ }; _NO_DEFLT_ } _N_ #-}
+ (==) = { _A_ 2 _U_ 11 _N_ _S_ "U(U(P)L)U(U(P)L)" {_A_ 4 _U_ 2121 _N_ _N_ _F_ _IF_ARGS_ 0 4 XCXC 7 \ (u0 :: Double#) (u1 :: Double) (u2 :: Double#) (u3 :: Double) -> case _#_ eqDouble# [] [u0, u2] of { _ALG_ True -> case u1 of { _ALG_ D# (u4 :: Double#) -> case u3 of { _ALG_ D# (u5 :: Double#) -> _#_ eqDouble# [] [u4, u5]; _NO_DEFLT_ }; _NO_DEFLT_ }; False -> _!_ False [] []; _NO_DEFLT_ } _N_} _F_ _ALWAYS_ \ (u0 :: Complex Double) (u1 :: Complex Double) -> case u0 of { _ALG_ (:+) (u2 :: Double) (u3 :: Double) -> case u2 of { _ALG_ D# (u4 :: Double#) -> case u1 of { _ALG_ (:+) (u5 :: Double) (u6 :: Double) -> case u5 of { _ALG_ D# (u7 :: Double#) -> case _#_ eqDouble# [] [u4, u7] of { _ALG_ True -> case u3 of { _ALG_ D# (u8 :: Double#) -> case u6 of { _ALG_ D# (u9 :: Double#) -> _#_ eqDouble# [] [u8, u9]; _NO_DEFLT_ }; _NO_DEFLT_ }; False -> _!_ False [] []; _NO_DEFLT_ }; _NO_DEFLT_ }; _NO_DEFLT_ }; _NO_DEFLT_ }; _NO_DEFLT_ } _N_ },
+ (/=) = { _A_ 2 _U_ 11 _N_ _S_ "U(U(P)L)U(U(P)L)" {_A_ 4 _U_ 2121 _N_ _N_ _F_ _IF_ARGS_ 0 4 XCXC 7 \ (u0 :: Double#) (u1 :: Double) (u2 :: Double#) (u3 :: Double) -> case _#_ neDouble# [] [u0, u2] of { _ALG_ True -> _!_ True [] []; False -> case u1 of { _ALG_ D# (u4 :: Double#) -> case u3 of { _ALG_ D# (u5 :: Double#) -> _#_ neDouble# [] [u4, u5]; _NO_DEFLT_ }; _NO_DEFLT_ }; _NO_DEFLT_ } _N_} _F_ _ALWAYS_ \ (u0 :: Complex Double) (u1 :: Complex Double) -> case u0 of { _ALG_ (:+) (u2 :: Double) (u3 :: Double) -> case u2 of { _ALG_ D# (u4 :: Double#) -> case u1 of { _ALG_ (:+) (u5 :: Double) (u6 :: Double) -> case u5 of { _ALG_ D# (u7 :: Double#) -> case _#_ neDouble# [] [u4, u7] of { _ALG_ True -> _!_ True [] []; False -> case u3 of { _ALG_ D# (u8 :: Double#) -> case u6 of { _ALG_ D# (u9 :: Double#) -> _#_ neDouble# [] [u8, u9]; _NO_DEFLT_ }; _NO_DEFLT_ }; _NO_DEFLT_ }; _NO_DEFLT_ }; _NO_DEFLT_ }; _NO_DEFLT_ }; _NO_DEFLT_ } _N_ } #-}
instance Eq Double
{-# GHC_PRAGMA _M_ PreludeCore {-dfun-} _A_ 0 _N_ _N_ _N_ _F_ _IF_ARGS_ 0 0 X 3 _!_ _TUP_2 [(Double -> Double -> Bool), (Double -> Double -> Bool)] [_CONSTM_ Eq (==) (Double), _CONSTM_ Eq (/=) (Double)] _N_
- (==) = _A_ 2 _U_ 11 _N_ _S_ "U(P)U(P)" {_A_ 2 _U_ 22 _N_ _N_ _F_ _IF_ARGS_ 0 2 XX 1 \ (u0 :: Double#) (u1 :: Double#) -> _#_ eqDouble# [] [u0, u1] _N_} _F_ _IF_ARGS_ 0 2 CC 3 \ (u0 :: Double) (u1 :: Double) -> case u0 of { _ALG_ D# (u2 :: Double#) -> case u1 of { _ALG_ D# (u3 :: Double#) -> _#_ eqDouble# [] [u2, u3]; _NO_DEFLT_ }; _NO_DEFLT_ } _N_,
- (/=) = _A_ 2 _U_ 11 _N_ _S_ "U(P)U(P)" {_A_ 2 _U_ 22 _N_ _N_ _F_ _IF_ARGS_ 0 2 XX 1 \ (u0 :: Double#) (u1 :: Double#) -> _#_ neDouble# [] [u0, u1] _N_} _F_ _IF_ARGS_ 0 2 CC 3 \ (u0 :: Double) (u1 :: Double) -> case u0 of { _ALG_ D# (u2 :: Double#) -> case u1 of { _ALG_ D# (u3 :: Double#) -> _#_ neDouble# [] [u2, u3]; _NO_DEFLT_ }; _NO_DEFLT_ } _N_ #-}
+ (==) = { _A_ 2 _U_ 11 _N_ _S_ "U(P)U(P)" {_A_ 2 _U_ 22 _N_ _N_ _F_ _IF_ARGS_ 0 2 XX 1 \ (u0 :: Double#) (u1 :: Double#) -> _#_ eqDouble# [] [u0, u1] _N_} _F_ _IF_ARGS_ 0 2 CC 3 \ (u0 :: Double) (u1 :: Double) -> case u0 of { _ALG_ D# (u2 :: Double#) -> case u1 of { _ALG_ D# (u3 :: Double#) -> _#_ eqDouble# [] [u2, u3]; _NO_DEFLT_ }; _NO_DEFLT_ } _N_ },
+ (/=) = { _A_ 2 _U_ 11 _N_ _S_ "U(P)U(P)" {_A_ 2 _U_ 22 _N_ _N_ _F_ _IF_ARGS_ 0 2 XX 1 \ (u0 :: Double#) (u1 :: Double#) -> _#_ neDouble# [] [u0, u1] _N_} _F_ _IF_ARGS_ 0 2 CC 3 \ (u0 :: Double) (u1 :: Double) -> case u0 of { _ALG_ D# (u2 :: Double#) -> case u1 of { _ALG_ D# (u3 :: Double#) -> _#_ neDouble# [] [u2, u3]; _NO_DEFLT_ }; _NO_DEFLT_ } _N_ } #-}
instance Eq Float
{-# GHC_PRAGMA _M_ PreludeCore {-dfun-} _A_ 0 _N_ _N_ _N_ _F_ _IF_ARGS_ 0 0 X 3 _!_ _TUP_2 [(Float -> Float -> Bool), (Float -> Float -> Bool)] [_CONSTM_ Eq (==) (Float), _CONSTM_ Eq (/=) (Float)] _N_
- (==) = _A_ 2 _U_ 11 _N_ _S_ "U(P)U(P)" {_A_ 2 _U_ 22 _N_ _N_ _F_ _IF_ARGS_ 0 2 XX 1 \ (u0 :: Float#) (u1 :: Float#) -> _#_ eqFloat# [] [u0, u1] _N_} _F_ _IF_ARGS_ 0 2 CC 3 \ (u0 :: Float) (u1 :: Float) -> case u0 of { _ALG_ F# (u2 :: Float#) -> case u1 of { _ALG_ F# (u3 :: Float#) -> _#_ eqFloat# [] [u2, u3]; _NO_DEFLT_ }; _NO_DEFLT_ } _N_,
- (/=) = _A_ 2 _U_ 11 _N_ _S_ "U(P)U(P)" {_A_ 2 _U_ 22 _N_ _N_ _F_ _IF_ARGS_ 0 2 XX 1 \ (u0 :: Float#) (u1 :: Float#) -> _#_ neFloat# [] [u0, u1] _N_} _F_ _IF_ARGS_ 0 2 CC 3 \ (u0 :: Float) (u1 :: Float) -> case u0 of { _ALG_ F# (u2 :: Float#) -> case u1 of { _ALG_ F# (u3 :: Float#) -> _#_ neFloat# [] [u2, u3]; _NO_DEFLT_ }; _NO_DEFLT_ } _N_ #-}
+ (==) = { _A_ 2 _U_ 11 _N_ _S_ "U(P)U(P)" {_A_ 2 _U_ 22 _N_ _N_ _F_ _IF_ARGS_ 0 2 XX 1 \ (u0 :: Float#) (u1 :: Float#) -> _#_ eqFloat# [] [u0, u1] _N_} _F_ _IF_ARGS_ 0 2 CC 3 \ (u0 :: Float) (u1 :: Float) -> case u0 of { _ALG_ F# (u2 :: Float#) -> case u1 of { _ALG_ F# (u3 :: Float#) -> _#_ eqFloat# [] [u2, u3]; _NO_DEFLT_ }; _NO_DEFLT_ } _N_ },
+ (/=) = { _A_ 2 _U_ 11 _N_ _S_ "U(P)U(P)" {_A_ 2 _U_ 22 _N_ _N_ _F_ _IF_ARGS_ 0 2 XX 1 \ (u0 :: Float#) (u1 :: Float#) -> _#_ neFloat# [] [u0, u1] _N_} _F_ _IF_ARGS_ 0 2 CC 3 \ (u0 :: Float) (u1 :: Float) -> case u0 of { _ALG_ F# (u2 :: Float#) -> case u1 of { _ALG_ F# (u3 :: Float#) -> _#_ neFloat# [] [u2, u3]; _NO_DEFLT_ }; _NO_DEFLT_ } _N_ } #-}
instance Eq Int
{-# GHC_PRAGMA _M_ PreludeCore {-dfun-} _A_ 0 _N_ _N_ _N_ _F_ _IF_ARGS_ 0 0 X 3 _!_ _TUP_2 [(Int -> Int -> Bool), (Int -> Int -> Bool)] [_CONSTM_ Eq (==) (Int), _CONSTM_ Eq (/=) (Int)] _N_
- (==) = _A_ 2 _U_ 11 _N_ _S_ "U(P)U(P)" {_A_ 2 _U_ 22 _N_ _N_ _F_ _IF_ARGS_ 0 2 XX 1 \ (u0 :: Int#) (u1 :: Int#) -> _#_ eqInt# [] [u0, u1] _N_} _F_ _IF_ARGS_ 0 2 CC 3 \ (u0 :: Int) (u1 :: Int) -> case u0 of { _ALG_ I# (u2 :: Int#) -> case u1 of { _ALG_ I# (u3 :: Int#) -> _#_ eqInt# [] [u2, u3]; _NO_DEFLT_ }; _NO_DEFLT_ } _N_,
- (/=) = _A_ 2 _U_ 11 _N_ _S_ "U(P)U(P)" {_A_ 2 _U_ 22 _N_ _N_ _F_ _IF_ARGS_ 0 2 XX 1 \ (u0 :: Int#) (u1 :: Int#) -> _#_ neInt# [] [u0, u1] _N_} _F_ _IF_ARGS_ 0 2 CC 3 \ (u0 :: Int) (u1 :: Int) -> case u0 of { _ALG_ I# (u2 :: Int#) -> case u1 of { _ALG_ I# (u3 :: Int#) -> _#_ neInt# [] [u2, u3]; _NO_DEFLT_ }; _NO_DEFLT_ } _N_ #-}
+ (==) = { _A_ 2 _U_ 11 _N_ _S_ "U(P)U(P)" {_A_ 2 _U_ 22 _N_ _N_ _F_ _IF_ARGS_ 0 2 XX 1 \ (u0 :: Int#) (u1 :: Int#) -> _#_ eqInt# [] [u0, u1] _N_} _F_ _IF_ARGS_ 0 2 CC 3 \ (u0 :: Int) (u1 :: Int) -> case u0 of { _ALG_ I# (u2 :: Int#) -> case u1 of { _ALG_ I# (u3 :: Int#) -> _#_ eqInt# [] [u2, u3]; _NO_DEFLT_ }; _NO_DEFLT_ } _N_ },
+ (/=) = { _A_ 2 _U_ 11 _N_ _S_ "U(P)U(P)" {_A_ 2 _U_ 22 _N_ _N_ _F_ _IF_ARGS_ 0 2 XX 1 \ (u0 :: Int#) (u1 :: Int#) -> _#_ neInt# [] [u0, u1] _N_} _F_ _IF_ARGS_ 0 2 CC 3 \ (u0 :: Int) (u1 :: Int) -> case u0 of { _ALG_ I# (u2 :: Int#) -> case u1 of { _ALG_ I# (u3 :: Int#) -> _#_ neInt# [] [u2, u3]; _NO_DEFLT_ }; _NO_DEFLT_ } _N_ } #-}
instance Eq Integer
{-# GHC_PRAGMA _M_ PreludeCore {-dfun-} _A_ 0 _N_ _N_ _N_ _F_ _IF_ARGS_ 0 0 X 3 _!_ _TUP_2 [(Integer -> Integer -> Bool), (Integer -> Integer -> Bool)] [_CONSTM_ Eq (==) (Integer), _CONSTM_ Eq (/=) (Integer)] _N_
- (==) = _A_ 2 _U_ 11 _N_ _S_ "U(PPP)U(PPP)" {_A_ 4 _U_ 2221 _N_ _N_ _F_ _IF_ARGS_ 0 4 XXXC 4 \ (u0 :: Int#) (u1 :: Int#) (u2 :: ByteArray#) (u3 :: Integer) -> case u3 of { _ALG_ J# (u4 :: Int#) (u5 :: Int#) (u6 :: ByteArray#) -> case _#_ cmpInteger# [] [u0, u1, u2, u4, u5, u6] of { _PRIM_ 0# -> _!_ True [] []; (u7 :: Int#) -> _!_ False [] [] }; _NO_DEFLT_ } _N_} _F_ _IF_ARGS_ 0 2 CC 5 \ (u0 :: Integer) (u1 :: Integer) -> case u0 of { _ALG_ J# (u2 :: Int#) (u3 :: Int#) (u4 :: ByteArray#) -> case u1 of { _ALG_ J# (u5 :: Int#) (u6 :: Int#) (u7 :: ByteArray#) -> case _#_ cmpInteger# [] [u2, u3, u4, u5, u6, u7] of { _PRIM_ 0# -> _!_ True [] []; (u8 :: Int#) -> _!_ False [] [] }; _NO_DEFLT_ }; _NO_DEFLT_ } _N_,
- (/=) = _A_ 2 _U_ 11 _N_ _S_ "U(PPP)U(PPP)" {_A_ 4 _U_ 2221 _N_ _N_ _F_ _IF_ARGS_ 0 4 XXXC 4 \ (u0 :: Int#) (u1 :: Int#) (u2 :: ByteArray#) (u3 :: Integer) -> case u3 of { _ALG_ J# (u4 :: Int#) (u5 :: Int#) (u6 :: ByteArray#) -> case _#_ cmpInteger# [] [u0, u1, u2, u4, u5, u6] of { _PRIM_ 0# -> _!_ False [] []; (u7 :: Int#) -> _!_ True [] [] }; _NO_DEFLT_ } _N_} _F_ _IF_ARGS_ 0 2 CC 5 \ (u0 :: Integer) (u1 :: Integer) -> case u0 of { _ALG_ J# (u2 :: Int#) (u3 :: Int#) (u4 :: ByteArray#) -> case u1 of { _ALG_ J# (u5 :: Int#) (u6 :: Int#) (u7 :: ByteArray#) -> case _#_ cmpInteger# [] [u2, u3, u4, u5, u6, u7] of { _PRIM_ 0# -> _!_ False [] []; (u8 :: Int#) -> _!_ True [] [] }; _NO_DEFLT_ }; _NO_DEFLT_ } _N_ #-}
+ (==) = { _A_ 2 _U_ 11 _N_ _S_ "U(PPP)U(PPP)" {_A_ 4 _U_ 2221 _N_ _N_ _F_ _IF_ARGS_ 0 4 XXXC 4 \ (u0 :: Int#) (u1 :: Int#) (u2 :: ByteArray#) (u3 :: Integer) -> case u3 of { _ALG_ J# (u4 :: Int#) (u5 :: Int#) (u6 :: ByteArray#) -> case _#_ cmpInteger# [] [u0, u1, u2, u4, u5, u6] of { _PRIM_ 0# -> _!_ True [] []; (u7 :: Int#) -> _!_ False [] [] }; _NO_DEFLT_ } _N_} _F_ _IF_ARGS_ 0 2 CC 5 \ (u0 :: Integer) (u1 :: Integer) -> case u0 of { _ALG_ J# (u2 :: Int#) (u3 :: Int#) (u4 :: ByteArray#) -> case u1 of { _ALG_ J# (u5 :: Int#) (u6 :: Int#) (u7 :: ByteArray#) -> case _#_ cmpInteger# [] [u2, u3, u4, u5, u6, u7] of { _PRIM_ 0# -> _!_ True [] []; (u8 :: Int#) -> _!_ False [] [] }; _NO_DEFLT_ }; _NO_DEFLT_ } _N_ },
+ (/=) = { _A_ 2 _U_ 11 _N_ _S_ "U(PPP)U(PPP)" {_A_ 4 _U_ 2221 _N_ _N_ _F_ _IF_ARGS_ 0 4 XXXC 4 \ (u0 :: Int#) (u1 :: Int#) (u2 :: ByteArray#) (u3 :: Integer) -> case u3 of { _ALG_ J# (u4 :: Int#) (u5 :: Int#) (u6 :: ByteArray#) -> case _#_ cmpInteger# [] [u0, u1, u2, u4, u5, u6] of { _PRIM_ 0# -> _!_ False [] []; (u7 :: Int#) -> _!_ True [] [] }; _NO_DEFLT_ } _N_} _F_ _IF_ARGS_ 0 2 CC 5 \ (u0 :: Integer) (u1 :: Integer) -> case u0 of { _ALG_ J# (u2 :: Int#) (u3 :: Int#) (u4 :: ByteArray#) -> case u1 of { _ALG_ J# (u5 :: Int#) (u6 :: Int#) (u7 :: ByteArray#) -> case _#_ cmpInteger# [] [u2, u3, u4, u5, u6, u7] of { _PRIM_ 0# -> _!_ False [] []; (u8 :: Int#) -> _!_ True [] [] }; _NO_DEFLT_ }; _NO_DEFLT_ } _N_ } #-}
instance Integral a => Eq (Ratio a)
{-# GHC_PRAGMA _M_ PreludeRatio {-dfun-} _A_ 1 _U_ 1 _N_ _N_ _N_ _N_ #-}
instance Eq (Ratio Integer)
{-# GHC_PRAGMA _M_ PreludeRatio {-dfun-} _A_ 0 _N_ _N_ _N_ _F_ _IF_ARGS_ 0 0 X 3 _!_ _TUP_2 [(Ratio Integer -> Ratio Integer -> Bool), (Ratio Integer -> Ratio Integer -> Bool)] [_CONSTM_ Eq (==) (Ratio Integer), _CONSTM_ Eq (/=) (Ratio Integer)] _N_
- (==) = _A_ 2 _U_ 11 _N_ _S_ "U(U(PPP)L)U(U(PPP)L)" {_A_ 5 _U_ 22211 _N_ _N_ _F_ _IF_ARGS_ 0 5 XXXCC 9 \ (u0 :: Int#) (u1 :: Int#) (u2 :: ByteArray#) (u3 :: Integer) (u4 :: Ratio Integer) -> case u4 of { _ALG_ (:%) (u5 :: Integer) (u6 :: Integer) -> case u5 of { _ALG_ J# (u7 :: Int#) (u8 :: Int#) (u9 :: ByteArray#) -> case _#_ cmpInteger# [] [u0, u1, u2, u7, u8, u9] of { _PRIM_ 0# -> case u3 of { _ALG_ J# (ua :: Int#) (ub :: Int#) (uc :: ByteArray#) -> case u6 of { _ALG_ J# (ud :: Int#) (ue :: Int#) (uf :: ByteArray#) -> case _#_ cmpInteger# [] [ua, ub, uc, ud, ue, uf] of { _PRIM_ 0# -> _!_ True [] []; (ug :: Int#) -> _!_ False [] [] }; _NO_DEFLT_ }; _NO_DEFLT_ }; (uh :: Int#) -> _!_ False [] [] }; _NO_DEFLT_ }; _NO_DEFLT_ } _N_} _N_ _N_,
- (/=) = _A_ 2 _U_ 11 _N_ _S_ "U(U(PPP)L)U(U(PPP)L)" {_A_ 5 _U_ 22211 _N_ _N_ _F_ _IF_ARGS_ 0 5 XXXCC 9 \ (u0 :: Int#) (u1 :: Int#) (u2 :: ByteArray#) (u3 :: Integer) (u4 :: Ratio Integer) -> case u4 of { _ALG_ (:%) (u5 :: Integer) (u6 :: Integer) -> case u5 of { _ALG_ J# (u7 :: Int#) (u8 :: Int#) (u9 :: ByteArray#) -> case _#_ cmpInteger# [] [u0, u1, u2, u7, u8, u9] of { _PRIM_ 0# -> case u3 of { _ALG_ J# (ua :: Int#) (ub :: Int#) (uc :: ByteArray#) -> case u6 of { _ALG_ J# (ud :: Int#) (ue :: Int#) (uf :: ByteArray#) -> case _#_ cmpInteger# [] [ua, ub, uc, ud, ue, uf] of { _PRIM_ 0# -> _!_ False [] []; (ug :: Int#) -> _!_ True [] [] }; _NO_DEFLT_ }; _NO_DEFLT_ }; (uh :: Int#) -> _!_ True [] [] }; _NO_DEFLT_ }; _NO_DEFLT_ } _N_} _N_ _N_ #-}
+ (==) = { _A_ 2 _U_ 11 _N_ _S_ "U(U(PPP)L)U(U(PPP)L)" {_A_ 5 _U_ 22211 _N_ _N_ _F_ _IF_ARGS_ 0 5 XXXCC 9 \ (u0 :: Int#) (u1 :: Int#) (u2 :: ByteArray#) (u3 :: Integer) (u4 :: Ratio Integer) -> case u4 of { _ALG_ (:%) (u5 :: Integer) (u6 :: Integer) -> case u5 of { _ALG_ J# (u7 :: Int#) (u8 :: Int#) (u9 :: ByteArray#) -> case _#_ cmpInteger# [] [u0, u1, u2, u7, u8, u9] of { _PRIM_ 0# -> case u3 of { _ALG_ J# (ua :: Int#) (ub :: Int#) (uc :: ByteArray#) -> case u6 of { _ALG_ J# (ud :: Int#) (ue :: Int#) (uf :: ByteArray#) -> case _#_ cmpInteger# [] [ua, ub, uc, ud, ue, uf] of { _PRIM_ 0# -> _!_ True [] []; (ug :: Int#) -> _!_ False [] [] }; _NO_DEFLT_ }; _NO_DEFLT_ }; (uh :: Int#) -> _!_ False [] [] }; _NO_DEFLT_ }; _NO_DEFLT_ } _N_} _N_ _N_ },
+ (/=) = { _A_ 2 _U_ 11 _N_ _S_ "U(U(PPP)L)U(U(PPP)L)" {_A_ 5 _U_ 22211 _N_ _N_ _F_ _IF_ARGS_ 0 5 XXXCC 9 \ (u0 :: Int#) (u1 :: Int#) (u2 :: ByteArray#) (u3 :: Integer) (u4 :: Ratio Integer) -> case u4 of { _ALG_ (:%) (u5 :: Integer) (u6 :: Integer) -> case u5 of { _ALG_ J# (u7 :: Int#) (u8 :: Int#) (u9 :: ByteArray#) -> case _#_ cmpInteger# [] [u0, u1, u2, u7, u8, u9] of { _PRIM_ 0# -> case u3 of { _ALG_ J# (ua :: Int#) (ub :: Int#) (uc :: ByteArray#) -> case u6 of { _ALG_ J# (ud :: Int#) (ue :: Int#) (uf :: ByteArray#) -> case _#_ cmpInteger# [] [ua, ub, uc, ud, ue, uf] of { _PRIM_ 0# -> _!_ False [] []; (ug :: Int#) -> _!_ True [] [] }; _NO_DEFLT_ }; _NO_DEFLT_ }; (uh :: Int#) -> _!_ True [] [] }; _NO_DEFLT_ }; _NO_DEFLT_ } _N_} _N_ _N_ } #-}
+instance Eq [(Int, Int)]
+ {-# GHC_PRAGMA _M_ PreludeBuiltin {-dfun-} _A_ 0 _N_ _N_ _N_ _F_ _IF_ARGS_ 0 0 X 3 _!_ _TUP_2 [([(Int, Int)] -> [(Int, Int)] -> Bool), ([(Int, Int)] -> [(Int, Int)] -> Bool)] [_CONSTM_ Eq (==) ([(Int, Int)]), _CONSTM_ Eq (/=) ([(Int, Int)])] _N_
+ (==) = { _A_ 2 _U_ 11 _N_ _S_ "SS" _N_ _N_ },
+ (/=) = { _A_ 2 _U_ 11 _N_ _S_ "SS" _N_ _N_ } #-}
instance Eq a => Eq [a]
{-# GHC_PRAGMA _M_ PreludeBuiltin {-dfun-} _A_ 1 _U_ 1 _N_ _N_ _N_ _N_ #-}
+instance Eq [Bool]
+ {-# GHC_PRAGMA _M_ PreludeBuiltin {-dfun-} _A_ 0 _N_ _N_ _N_ _F_ _IF_ARGS_ 0 0 X 3 _!_ _TUP_2 [([Bool] -> [Bool] -> Bool), ([Bool] -> [Bool] -> Bool)] [_CONSTM_ Eq (==) ([Bool]), _CONSTM_ Eq (/=) ([Bool])] _N_
+ (==) = { _A_ 2 _U_ 11 _N_ _S_ "SS" _N_ _N_ },
+ (/=) = { _A_ 2 _U_ 11 _N_ _S_ "SS" _N_ _N_ } #-}
instance Eq [Char]
{-# GHC_PRAGMA _M_ PreludeBuiltin {-dfun-} _A_ 0 _N_ _N_ _N_ _F_ _IF_ARGS_ 0 0 X 3 _!_ _TUP_2 [([Char] -> [Char] -> Bool), ([Char] -> [Char] -> Bool)] [_CONSTM_ Eq (==) ([Char]), _CONSTM_ Eq (/=) ([Char])] _N_
- (==) = _A_ 2 _U_ 11 _N_ _S_ "SS" _N_ _N_,
- (/=) = _A_ 2 _U_ 11 _N_ _S_ "SS" _N_ _N_ #-}
+ (==) = { _A_ 2 _U_ 11 _N_ _S_ "SS" _N_ _N_ },
+ (/=) = { _A_ 2 _U_ 11 _N_ _S_ "SS" _N_ _N_ } #-}
+instance Eq [Complex Double]
+ {-# GHC_PRAGMA _M_ PreludeBuiltin {-dfun-} _A_ 0 _N_ _N_ _N_ _F_ _IF_ARGS_ 0 0 X 3 _!_ _TUP_2 [([Complex Double] -> [Complex Double] -> Bool), ([Complex Double] -> [Complex Double] -> Bool)] [_CONSTM_ Eq (==) ([Complex Double]), _CONSTM_ Eq (/=) ([Complex Double])] _N_
+ (==) = { _A_ 2 _U_ 11 _N_ _S_ "SS" _N_ _N_ },
+ (/=) = { _A_ 2 _U_ 11 _N_ _S_ "SS" _N_ _N_ } #-}
+instance Eq [Double]
+ {-# GHC_PRAGMA _M_ PreludeBuiltin {-dfun-} _A_ 0 _N_ _N_ _N_ _F_ _IF_ARGS_ 0 0 X 3 _!_ _TUP_2 [([Double] -> [Double] -> Bool), ([Double] -> [Double] -> Bool)] [_CONSTM_ Eq (==) ([Double]), _CONSTM_ Eq (/=) ([Double])] _N_
+ (==) = { _A_ 2 _U_ 11 _N_ _S_ "SS" _N_ _N_ },
+ (/=) = { _A_ 2 _U_ 11 _N_ _S_ "SS" _N_ _N_ } #-}
instance Eq [Int]
{-# GHC_PRAGMA _M_ PreludeBuiltin {-dfun-} _A_ 0 _N_ _N_ _N_ _F_ _IF_ARGS_ 0 0 X 3 _!_ _TUP_2 [([Int] -> [Int] -> Bool), ([Int] -> [Int] -> Bool)] [_CONSTM_ Eq (==) ([Int]), _CONSTM_ Eq (/=) ([Int])] _N_
- (==) = _A_ 2 _U_ 11 _N_ _S_ "SS" _N_ _N_,
- (/=) = _A_ 2 _U_ 11 _N_ _S_ "SS" _N_ _N_ #-}
+ (==) = { _A_ 2 _U_ 11 _N_ _S_ "SS" _N_ _N_ },
+ (/=) = { _A_ 2 _U_ 11 _N_ _S_ "SS" _N_ _N_ } #-}
+instance Eq [Integer]
+ {-# GHC_PRAGMA _M_ PreludeBuiltin {-dfun-} _A_ 0 _N_ _N_ _N_ _F_ _IF_ARGS_ 0 0 X 3 _!_ _TUP_2 [([Integer] -> [Integer] -> Bool), ([Integer] -> [Integer] -> Bool)] [_CONSTM_ Eq (==) ([Integer]), _CONSTM_ Eq (/=) ([Integer])] _N_
+ (==) = { _A_ 2 _U_ 11 _N_ _S_ "SS" _N_ _N_ },
+ (/=) = { _A_ 2 _U_ 11 _N_ _S_ "SS" _N_ _N_ } #-}
+instance Eq [[Char]]
+ {-# GHC_PRAGMA _M_ PreludeBuiltin {-dfun-} _A_ 0 _N_ _N_ _N_ _F_ _IF_ARGS_ 0 0 X 3 _!_ _TUP_2 [([[Char]] -> [[Char]] -> Bool), ([[Char]] -> [[Char]] -> Bool)] [_CONSTM_ Eq (==) ([[Char]]), _CONSTM_ Eq (/=) ([[Char]])] _N_
+ (==) = { _A_ 2 _U_ 11 _N_ _S_ "SS" _N_ _N_ },
+ (/=) = { _A_ 2 _U_ 11 _N_ _S_ "SS" _N_ _N_ } #-}
+instance Eq [[Int]]
+ {-# GHC_PRAGMA _M_ PreludeBuiltin {-dfun-} _A_ 0 _N_ _N_ _N_ _F_ _IF_ARGS_ 0 0 X 3 _!_ _TUP_2 [([[Int]] -> [[Int]] -> Bool), ([[Int]] -> [[Int]] -> Bool)] [_CONSTM_ Eq (==) ([[Int]]), _CONSTM_ Eq (/=) ([[Int]])] _N_
+ (==) = { _A_ 2 _U_ 11 _N_ _S_ "SS" _N_ _N_ },
+ (/=) = { _A_ 2 _U_ 11 _N_ _S_ "SS" _N_ _N_ } #-}
instance Eq _Addr
{-# GHC_PRAGMA _M_ PreludeCore {-dfun-} _A_ 0 _N_ _N_ _N_ _F_ _IF_ARGS_ 0 0 X 3 _!_ _TUP_2 [(_Addr -> _Addr -> Bool), (_Addr -> _Addr -> Bool)] [_CONSTM_ Eq (==) (_Addr), _CONSTM_ Eq (/=) (_Addr)] _N_
- (==) = _A_ 2 _U_ 11 _N_ _S_ "U(P)U(P)" {_A_ 2 _U_ 22 _N_ _N_ _F_ _IF_ARGS_ 0 2 XX 1 \ (u0 :: Addr#) (u1 :: Addr#) -> _#_ eqAddr# [] [u0, u1] _N_} _F_ _IF_ARGS_ 0 2 CC 3 \ (u0 :: _Addr) (u1 :: _Addr) -> case u0 of { _ALG_ A# (u2 :: Addr#) -> case u1 of { _ALG_ A# (u3 :: Addr#) -> _#_ eqAddr# [] [u2, u3]; _NO_DEFLT_ }; _NO_DEFLT_ } _N_,
- (/=) = _A_ 2 _U_ 11 _N_ _S_ "U(P)U(P)" {_A_ 2 _U_ 22 _N_ _N_ _F_ _IF_ARGS_ 0 2 XX 1 \ (u0 :: Addr#) (u1 :: Addr#) -> _#_ neAddr# [] [u0, u1] _N_} _F_ _IF_ARGS_ 0 2 CC 3 \ (u0 :: _Addr) (u1 :: _Addr) -> case u0 of { _ALG_ A# (u2 :: Addr#) -> case u1 of { _ALG_ A# (u3 :: Addr#) -> _#_ neAddr# [] [u2, u3]; _NO_DEFLT_ }; _NO_DEFLT_ } _N_ #-}
+ (==) = { _A_ 2 _U_ 11 _N_ _S_ "U(P)U(P)" {_A_ 2 _U_ 22 _N_ _N_ _F_ _IF_ARGS_ 0 2 XX 1 \ (u0 :: Addr#) (u1 :: Addr#) -> _#_ eqAddr# [] [u0, u1] _N_} _F_ _IF_ARGS_ 0 2 CC 3 \ (u0 :: _Addr) (u1 :: _Addr) -> case u0 of { _ALG_ A# (u2 :: Addr#) -> case u1 of { _ALG_ A# (u3 :: Addr#) -> _#_ eqAddr# [] [u2, u3]; _NO_DEFLT_ }; _NO_DEFLT_ } _N_ },
+ (/=) = { _A_ 2 _U_ 11 _N_ _S_ "U(P)U(P)" {_A_ 2 _U_ 22 _N_ _N_ _F_ _IF_ARGS_ 0 2 XX 1 \ (u0 :: Addr#) (u1 :: Addr#) -> _#_ neAddr# [] [u0, u1] _N_} _F_ _IF_ARGS_ 0 2 CC 3 \ (u0 :: _Addr) (u1 :: _Addr) -> case u0 of { _ALG_ A# (u2 :: Addr#) -> case u1 of { _ALG_ A# (u3 :: Addr#) -> _#_ neAddr# [] [u2, u3]; _NO_DEFLT_ }; _NO_DEFLT_ } _N_ } #-}
instance Eq _PackedString
{-# GHC_PRAGMA _M_ PreludePS {-dfun-} _A_ 0 _N_ _N_ _N_ _F_ _IF_ARGS_ 0 0 X 3 _!_ _TUP_2 [(_PackedString -> _PackedString -> Bool), (_PackedString -> _PackedString -> Bool)] [_CONSTM_ Eq (==) (_PackedString), _CONSTM_ Eq (/=) (_PackedString)] _N_
- (==) = _A_ 2 _U_ 22 _N_ _S_ "SS" _N_ _N_,
- (/=) = _A_ 2 _U_ 22 _N_ _S_ "SS" _N_ _N_ #-}
+ (==) = { _A_ 2 _U_ 22 _N_ _S_ "SS" _N_ _N_ },
+ (/=) = { _A_ 2 _U_ 22 _N_ _S_ "SS" _N_ _N_ } #-}
instance Eq _Word
{-# GHC_PRAGMA _M_ PreludeCore {-dfun-} _A_ 0 _N_ _N_ _N_ _F_ _IF_ARGS_ 0 0 X 3 _!_ _TUP_2 [(_Word -> _Word -> Bool), (_Word -> _Word -> Bool)] [_CONSTM_ Eq (==) (_Word), _CONSTM_ Eq (/=) (_Word)] _N_
- (==) = _A_ 2 _U_ 11 _N_ _S_ "U(P)U(P)" {_A_ 2 _U_ 22 _N_ _N_ _F_ _IF_ARGS_ 0 2 XX 1 \ (u0 :: Word#) (u1 :: Word#) -> _#_ eqWord# [] [u0, u1] _N_} _F_ _IF_ARGS_ 0 2 CC 3 \ (u0 :: _Word) (u1 :: _Word) -> case u0 of { _ALG_ W# (u2 :: Word#) -> case u1 of { _ALG_ W# (u3 :: Word#) -> _#_ eqWord# [] [u2, u3]; _NO_DEFLT_ }; _NO_DEFLT_ } _N_,
- (/=) = _A_ 2 _U_ 11 _N_ _S_ "U(P)U(P)" {_A_ 2 _U_ 22 _N_ _N_ _F_ _IF_ARGS_ 0 2 XX 1 \ (u0 :: Word#) (u1 :: Word#) -> _#_ neWord# [] [u0, u1] _N_} _F_ _IF_ARGS_ 0 2 CC 3 \ (u0 :: _Word) (u1 :: _Word) -> case u0 of { _ALG_ W# (u2 :: Word#) -> case u1 of { _ALG_ W# (u3 :: Word#) -> _#_ neWord# [] [u2, u3]; _NO_DEFLT_ }; _NO_DEFLT_ } _N_ #-}
+ (==) = { _A_ 2 _U_ 11 _N_ _S_ "U(P)U(P)" {_A_ 2 _U_ 22 _N_ _N_ _F_ _IF_ARGS_ 0 2 XX 1 \ (u0 :: Word#) (u1 :: Word#) -> _#_ eqWord# [] [u0, u1] _N_} _F_ _IF_ARGS_ 0 2 CC 3 \ (u0 :: _Word) (u1 :: _Word) -> case u0 of { _ALG_ W# (u2 :: Word#) -> case u1 of { _ALG_ W# (u3 :: Word#) -> _#_ eqWord# [] [u2, u3]; _NO_DEFLT_ }; _NO_DEFLT_ } _N_ },
+ (/=) = { _A_ 2 _U_ 11 _N_ _S_ "U(P)U(P)" {_A_ 2 _U_ 22 _N_ _N_ _F_ _IF_ARGS_ 0 2 XX 1 \ (u0 :: Word#) (u1 :: Word#) -> _#_ neWord# [] [u0, u1] _N_} _F_ _IF_ARGS_ 0 2 CC 3 \ (u0 :: _Word) (u1 :: _Word) -> case u0 of { _ALG_ W# (u2 :: Word#) -> case u1 of { _ALG_ W# (u3 :: Word#) -> _#_ neWord# [] [u2, u3]; _NO_DEFLT_ }; _NO_DEFLT_ } _N_ } #-}
instance RealFloat a => Floating (Complex a)
{-# GHC_PRAGMA _M_ PreludeComplex {-dfun-} _A_ 2 _U_ 22 _N_ _N_ _N_ _N_ #-}
instance Floating (Complex Double)
{-# GHC_PRAGMA _M_ PreludeComplex {-dfun-} _A_ 0 _N_ _N_ _N_ _F_ _IF_ARGS_ 0 0 X 20 _!_ _TUP_19 [{{Fractional (Complex Double)}}, (Complex Double), (Complex Double -> Complex Double), (Complex Double -> Complex Double), (Complex Double -> Complex Double), (Complex Double -> Complex Double -> Complex Double), (Complex Double -> Complex Double -> Complex Double), (Complex Double -> Complex Double), (Complex Double -> Complex Double), (Complex Double -> Complex Double), (Complex Double -> Complex Double), (Complex Double -> Complex Double), (Complex Double -> Complex Double), (Complex Double -> Complex Double), (Complex Double -> Complex Double), (Complex Double -> Complex Double), (Complex Double -> Complex Double), (Complex Double -> Complex Double), (Complex Double -> Complex Double)] [_DFUN_ Fractional (Complex Double), _CONSTM_ Floating pi (Complex Double), _CONSTM_ Floating exp (Complex Double), _CONSTM_ Floating log (Complex Double), _CONSTM_ Floating sqrt (Complex Double), _CONSTM_ Floating (**) (Complex Double), _CONSTM_ Floating logBase (Complex Double), _CONSTM_ Floating sin (Complex Double), _CONSTM_ Floating cos (Complex Double), _CONSTM_ Floating tan (Complex Double), _CONSTM_ Floating asin (Complex Double), _CONSTM_ Floating acos (Complex Double), _CONSTM_ Floating atan (Complex Double), _CONSTM_ Floating sinh (Complex Double), _CONSTM_ Floating cosh (Complex Double), _CONSTM_ Floating tanh (Complex Double), _CONSTM_ Floating asinh (Complex Double), _CONSTM_ Floating acosh (Complex Double), _CONSTM_ Floating atanh (Complex Double)] _N_
- pi = _A_ 0 _N_ _N_ _N_ _N_ _N_,
- exp = _A_ 1 _U_ 1 _N_ _S_ "U(LL)" {_A_ 2 _U_ 12 _N_ _N_ _N_ _N_} _N_ _N_,
- log = _A_ 1 _U_ 2 _N_ _N_ _N_ _N_,
- sqrt = _A_ 1 _U_ 1 _N_ _S_ "U(U(P)L)" {_A_ 2 _U_ 22 _N_ _N_ _N_ _N_} _N_ _N_,
- (**) = _A_ 2 _U_ 21 _N_ _S_ "LU(LL)" {_A_ 3 _U_ 222 _N_ _N_ _N_ _N_} _N_ _N_,
- logBase = _A_ 2 _U_ 22 _N_ _N_ _N_ _N_,
- sin = _A_ 1 _U_ 1 _N_ _S_ "U(LL)" {_A_ 2 _U_ 22 _N_ _N_ _N_ _N_} _N_ _N_,
- cos = _A_ 1 _U_ 1 _N_ _S_ "U(LL)" {_A_ 2 _U_ 22 _N_ _N_ _N_ _N_} _N_ _N_,
- tan = _A_ 1 _U_ 1 _N_ _S_ "U(LL)" {_A_ 2 _U_ 22 _N_ _N_ _N_ _N_} _N_ _N_,
- asin = _A_ 1 _U_ 1 _N_ _S_ "U(LL)" {_A_ 2 _U_ 22 _N_ _N_ _N_ _N_} _N_ _N_,
- acos = _A_ 1 _U_ 1 _N_ _S_ "U(LL)" {_A_ 2 _U_ 22 _N_ _N_ _N_ _N_} _N_ _N_,
- atan = _A_ 1 _U_ 1 _N_ _S_ "U(LL)" {_A_ 2 _U_ 22 _N_ _N_ _N_ _N_} _N_ _N_,
- sinh = _A_ 1 _U_ 1 _N_ _S_ "U(LL)" {_A_ 2 _U_ 22 _N_ _N_ _N_ _N_} _N_ _N_,
- cosh = _A_ 1 _U_ 1 _N_ _S_ "U(LL)" {_A_ 2 _U_ 22 _N_ _N_ _N_ _N_} _N_ _N_,
- tanh = _A_ 1 _U_ 1 _N_ _S_ "U(LL)" {_A_ 2 _U_ 22 _N_ _N_ _N_ _N_} _N_ _N_,
- asinh = _A_ 1 _U_ 1 _N_ _N_ _N_ _N_,
- acosh = _A_ 1 _U_ 1 _N_ _N_ _N_ _N_,
- atanh = _A_ 1 _U_ 1 _N_ _N_ _N_ _N_ #-}
+ pi = { _A_ 0 _N_ _N_ _N_ _F_ _IF_ARGS_ 0 0 X 3 _!_ (:+) [Double] [_CONSTM_ Floating pi (Double), _SPEC_ _ORIG_ PreludeCore __i0 [ (Double) ]] _N_ },
+ exp = { _A_ 1 _U_ 1 _N_ _S_ "U(LL)" {_A_ 2 _U_ 12 _N_ _N_ _N_ _N_} _N_ _N_ },
+ log = { _A_ 1 _U_ 2 _N_ _N_ _N_ _N_ },
+ sqrt = { _A_ 1 _U_ 1 _N_ _S_ "U(U(P)L)" {_A_ 2 _U_ 22 _N_ _N_ _N_ _N_} _N_ _N_ },
+ (**) = { _A_ 2 _U_ 21 _N_ _S_ "LU(LL)" {_A_ 3 _U_ 222 _N_ _N_ _N_ _N_} _N_ _N_ },
+ logBase = { _A_ 2 _U_ 22 _N_ _N_ _N_ _N_ },
+ sin = { _A_ 1 _U_ 1 _N_ _S_ "U(LL)" {_A_ 2 _U_ 22 _N_ _N_ _N_ _N_} _N_ _N_ },
+ cos = { _A_ 1 _U_ 1 _N_ _S_ "U(LL)" {_A_ 2 _U_ 22 _N_ _N_ _N_ _N_} _N_ _N_ },
+ tan = { _A_ 1 _U_ 1 _N_ _S_ "U(LL)" {_A_ 2 _U_ 22 _N_ _N_ _N_ _N_} _N_ _N_ },
+ asin = { _A_ 1 _U_ 1 _N_ _S_ "U(LL)" {_A_ 2 _U_ 22 _N_ _N_ _N_ _N_} _N_ _N_ },
+ acos = { _A_ 1 _U_ 1 _N_ _S_ "U(LL)" {_A_ 2 _U_ 22 _N_ _N_ _N_ _N_} _N_ _N_ },
+ atan = { _A_ 1 _U_ 1 _N_ _S_ "U(LL)" {_A_ 2 _U_ 22 _N_ _N_ _N_ _N_} _N_ _N_ },
+ sinh = { _A_ 1 _U_ 1 _N_ _S_ "U(LL)" {_A_ 2 _U_ 22 _N_ _N_ _N_ _N_} _N_ _N_ },
+ cosh = { _A_ 1 _U_ 1 _N_ _S_ "U(LL)" {_A_ 2 _U_ 22 _N_ _N_ _N_ _N_} _N_ _N_ },
+ tanh = { _A_ 1 _U_ 1 _N_ _S_ "U(LL)" {_A_ 2 _U_ 22 _N_ _N_ _N_ _N_} _N_ _N_ },
+ asinh = { _A_ 1 _U_ 1 _N_ _N_ _N_ _N_ },
+ acosh = { _A_ 1 _U_ 1 _N_ _N_ _N_ _N_ },
+ atanh = { _A_ 1 _U_ 1 _N_ _N_ _N_ _N_ } #-}
instance Floating Double
{-# GHC_PRAGMA _M_ PreludeCore {-dfun-} _A_ 0 _N_ _N_ _N_ _F_ _IF_ARGS_ 0 0 X 20 _!_ _TUP_19 [{{Fractional Double}}, Double, (Double -> Double), (Double -> Double), (Double -> Double), (Double -> Double -> Double), (Double -> Double -> Double), (Double -> Double), (Double -> Double), (Double -> Double), (Double -> Double), (Double -> Double), (Double -> Double), (Double -> Double), (Double -> Double), (Double -> Double), (Double -> Double), (Double -> Double), (Double -> Double)] [_DFUN_ Fractional (Double), _CONSTM_ Floating pi (Double), _CONSTM_ Floating exp (Double), _CONSTM_ Floating log (Double), _CONSTM_ Floating sqrt (Double), _CONSTM_ Floating (**) (Double), _CONSTM_ Floating logBase (Double), _CONSTM_ Floating sin (Double), _CONSTM_ Floating cos (Double), _CONSTM_ Floating tan (Double), _CONSTM_ Floating asin (Double), _CONSTM_ Floating acos (Double), _CONSTM_ Floating atan (Double), _CONSTM_ Floating sinh (Double), _CONSTM_ Floating cosh (Double), _CONSTM_ Floating tanh (Double), _CONSTM_ Floating asinh (Double), _CONSTM_ Floating acosh (Double), _CONSTM_ Floating atanh (Double)] _N_
- pi = _A_ 0 _N_ _N_ _N_ _F_ _IF_ARGS_ 0 0 X 2 _!_ D# [] [3.1415926535897931##] _N_,
- exp = _A_ 1 _U_ 1 _N_ _S_ "U(P)" {_A_ 1 _U_ 2 _N_ _N_ _F_ _IF_ARGS_ 0 1 X 3 \ (u0 :: Double#) -> case _#_ expDouble# [] [u0] of { _PRIM_ (u1 :: Double#) -> _!_ D# [] [u1] } _N_} _F_ _IF_ARGS_ 0 1 C 4 \ (u0 :: Double) -> case u0 of { _ALG_ D# (u1 :: Double#) -> case _#_ expDouble# [] [u1] of { _PRIM_ (u2 :: Double#) -> _!_ D# [] [u2] }; _NO_DEFLT_ } _N_,
- log = _A_ 1 _U_ 1 _N_ _S_ "U(P)" {_A_ 1 _U_ 2 _N_ _N_ _F_ _IF_ARGS_ 0 1 X 3 \ (u0 :: Double#) -> case _#_ logDouble# [] [u0] of { _PRIM_ (u1 :: Double#) -> _!_ D# [] [u1] } _N_} _F_ _IF_ARGS_ 0 1 C 4 \ (u0 :: Double) -> case u0 of { _ALG_ D# (u1 :: Double#) -> case _#_ logDouble# [] [u1] of { _PRIM_ (u2 :: Double#) -> _!_ D# [] [u2] }; _NO_DEFLT_ } _N_,
- sqrt = _A_ 1 _U_ 1 _N_ _S_ "U(P)" {_A_ 1 _U_ 2 _N_ _N_ _F_ _IF_ARGS_ 0 1 X 3 \ (u0 :: Double#) -> case _#_ sqrtDouble# [] [u0] of { _PRIM_ (u1 :: Double#) -> _!_ D# [] [u1] } _N_} _F_ _IF_ARGS_ 0 1 C 4 \ (u0 :: Double) -> case u0 of { _ALG_ D# (u1 :: Double#) -> case _#_ sqrtDouble# [] [u1] of { _PRIM_ (u2 :: Double#) -> _!_ D# [] [u2] }; _NO_DEFLT_ } _N_,
- (**) = _A_ 2 _U_ 11 _N_ _S_ "U(P)U(P)" {_A_ 2 _U_ 22 _N_ _N_ _F_ _IF_ARGS_ 0 2 XX 3 \ (u0 :: Double#) (u1 :: Double#) -> case _#_ powerDouble# [] [u0, u1] of { _PRIM_ (u2 :: Double#) -> _!_ D# [] [u2] } _N_} _F_ _IF_ARGS_ 0 2 CC 5 \ (u0 :: Double) (u1 :: Double) -> case u0 of { _ALG_ D# (u2 :: Double#) -> case u1 of { _ALG_ D# (u3 :: Double#) -> case _#_ powerDouble# [] [u2, u3] of { _PRIM_ (u4 :: Double#) -> _!_ D# [] [u4] }; _NO_DEFLT_ }; _NO_DEFLT_ } _N_,
- logBase = _A_ 2 _U_ 11 _N_ _S_ "U(P)U(P)" {_A_ 2 _U_ 22 _N_ _N_ _F_ _IF_ARGS_ 0 2 XX 5 \ (u0 :: Double#) (u1 :: Double#) -> case _#_ logDouble# [] [u1] of { _PRIM_ (u2 :: Double#) -> case _#_ logDouble# [] [u0] of { _PRIM_ (u3 :: Double#) -> case _#_ divideDouble# [] [u2, u3] of { _PRIM_ (u4 :: Double#) -> _!_ D# [] [u4] } } } _N_} _F_ _IF_ARGS_ 0 2 CC 7 \ (u0 :: Double) (u1 :: Double) -> case u1 of { _ALG_ D# (u2 :: Double#) -> case _#_ logDouble# [] [u2] of { _PRIM_ (u3 :: Double#) -> case u0 of { _ALG_ D# (u4 :: Double#) -> case _#_ logDouble# [] [u4] of { _PRIM_ (u5 :: Double#) -> case _#_ divideDouble# [] [u3, u5] of { _PRIM_ (u6 :: Double#) -> _!_ D# [] [u6] } }; _NO_DEFLT_ } }; _NO_DEFLT_ } _N_,
- sin = _A_ 1 _U_ 1 _N_ _S_ "U(P)" {_A_ 1 _U_ 2 _N_ _N_ _F_ _IF_ARGS_ 0 1 X 3 \ (u0 :: Double#) -> case _#_ sinDouble# [] [u0] of { _PRIM_ (u1 :: Double#) -> _!_ D# [] [u1] } _N_} _F_ _IF_ARGS_ 0 1 C 4 \ (u0 :: Double) -> case u0 of { _ALG_ D# (u1 :: Double#) -> case _#_ sinDouble# [] [u1] of { _PRIM_ (u2 :: Double#) -> _!_ D# [] [u2] }; _NO_DEFLT_ } _N_,
- cos = _A_ 1 _U_ 1 _N_ _S_ "U(P)" {_A_ 1 _U_ 2 _N_ _N_ _F_ _IF_ARGS_ 0 1 X 3 \ (u0 :: Double#) -> case _#_ cosDouble# [] [u0] of { _PRIM_ (u1 :: Double#) -> _!_ D# [] [u1] } _N_} _F_ _IF_ARGS_ 0 1 C 4 \ (u0 :: Double) -> case u0 of { _ALG_ D# (u1 :: Double#) -> case _#_ cosDouble# [] [u1] of { _PRIM_ (u2 :: Double#) -> _!_ D# [] [u2] }; _NO_DEFLT_ } _N_,
- tan = _A_ 1 _U_ 1 _N_ _S_ "U(P)" {_A_ 1 _U_ 2 _N_ _N_ _F_ _IF_ARGS_ 0 1 X 3 \ (u0 :: Double#) -> case _#_ tanDouble# [] [u0] of { _PRIM_ (u1 :: Double#) -> _!_ D# [] [u1] } _N_} _F_ _IF_ARGS_ 0 1 C 4 \ (u0 :: Double) -> case u0 of { _ALG_ D# (u1 :: Double#) -> case _#_ tanDouble# [] [u1] of { _PRIM_ (u2 :: Double#) -> _!_ D# [] [u2] }; _NO_DEFLT_ } _N_,
- asin = _A_ 1 _U_ 1 _N_ _S_ "U(P)" {_A_ 1 _U_ 2 _N_ _N_ _F_ _IF_ARGS_ 0 1 X 3 \ (u0 :: Double#) -> case _#_ asinDouble# [] [u0] of { _PRIM_ (u1 :: Double#) -> _!_ D# [] [u1] } _N_} _F_ _IF_ARGS_ 0 1 C 4 \ (u0 :: Double) -> case u0 of { _ALG_ D# (u1 :: Double#) -> case _#_ asinDouble# [] [u1] of { _PRIM_ (u2 :: Double#) -> _!_ D# [] [u2] }; _NO_DEFLT_ } _N_,
- acos = _A_ 1 _U_ 1 _N_ _S_ "U(P)" {_A_ 1 _U_ 2 _N_ _N_ _F_ _IF_ARGS_ 0 1 X 3 \ (u0 :: Double#) -> case _#_ acosDouble# [] [u0] of { _PRIM_ (u1 :: Double#) -> _!_ D# [] [u1] } _N_} _F_ _IF_ARGS_ 0 1 C 4 \ (u0 :: Double) -> case u0 of { _ALG_ D# (u1 :: Double#) -> case _#_ acosDouble# [] [u1] of { _PRIM_ (u2 :: Double#) -> _!_ D# [] [u2] }; _NO_DEFLT_ } _N_,
- atan = _A_ 1 _U_ 1 _N_ _S_ "U(P)" {_A_ 1 _U_ 2 _N_ _N_ _F_ _IF_ARGS_ 0 1 X 3 \ (u0 :: Double#) -> case _#_ atanDouble# [] [u0] of { _PRIM_ (u1 :: Double#) -> _!_ D# [] [u1] } _N_} _F_ _IF_ARGS_ 0 1 C 4 \ (u0 :: Double) -> case u0 of { _ALG_ D# (u1 :: Double#) -> case _#_ atanDouble# [] [u1] of { _PRIM_ (u2 :: Double#) -> _!_ D# [] [u2] }; _NO_DEFLT_ } _N_,
- sinh = _A_ 1 _U_ 1 _N_ _S_ "U(P)" {_A_ 1 _U_ 2 _N_ _N_ _F_ _IF_ARGS_ 0 1 X 3 \ (u0 :: Double#) -> case _#_ sinhDouble# [] [u0] of { _PRIM_ (u1 :: Double#) -> _!_ D# [] [u1] } _N_} _F_ _IF_ARGS_ 0 1 C 4 \ (u0 :: Double) -> case u0 of { _ALG_ D# (u1 :: Double#) -> case _#_ sinhDouble# [] [u1] of { _PRIM_ (u2 :: Double#) -> _!_ D# [] [u2] }; _NO_DEFLT_ } _N_,
- cosh = _A_ 1 _U_ 1 _N_ _S_ "U(P)" {_A_ 1 _U_ 2 _N_ _N_ _F_ _IF_ARGS_ 0 1 X 3 \ (u0 :: Double#) -> case _#_ coshDouble# [] [u0] of { _PRIM_ (u1 :: Double#) -> _!_ D# [] [u1] } _N_} _F_ _IF_ARGS_ 0 1 C 4 \ (u0 :: Double) -> case u0 of { _ALG_ D# (u1 :: Double#) -> case _#_ coshDouble# [] [u1] of { _PRIM_ (u2 :: Double#) -> _!_ D# [] [u2] }; _NO_DEFLT_ } _N_,
- tanh = _A_ 1 _U_ 1 _N_ _S_ "U(P)" {_A_ 1 _U_ 2 _N_ _N_ _F_ _IF_ARGS_ 0 1 X 3 \ (u0 :: Double#) -> case _#_ tanhDouble# [] [u0] of { _PRIM_ (u1 :: Double#) -> _!_ D# [] [u1] } _N_} _F_ _IF_ARGS_ 0 1 C 4 \ (u0 :: Double) -> case u0 of { _ALG_ D# (u1 :: Double#) -> case _#_ tanhDouble# [] [u1] of { _PRIM_ (u2 :: Double#) -> _!_ D# [] [u2] }; _NO_DEFLT_ } _N_,
- asinh = _A_ 1 _U_ 1 _N_ _S_ "U(P)" {_A_ 1 _U_ 2 _N_ _N_ _N_ _N_} _N_ _N_,
- acosh = _A_ 1 _U_ 1 _N_ _S_ "U(P)" {_A_ 1 _U_ 2 _N_ _N_ _N_ _N_} _N_ _N_,
- atanh = _A_ 1 _U_ 1 _N_ _S_ "U(P)" {_A_ 1 _U_ 2 _N_ _N_ _N_ _N_} _N_ _N_ #-}
+ pi = { _A_ 0 _N_ _N_ _N_ _F_ _IF_ARGS_ 0 0 X 2 _!_ D# [] [3.1415926535897931##] _N_ },
+ exp = { _A_ 1 _U_ 1 _N_ _S_ "U(P)" {_A_ 1 _U_ 2 _N_ _N_ _F_ _IF_ARGS_ 0 1 X 3 \ (u0 :: Double#) -> case _#_ expDouble# [] [u0] of { _PRIM_ (u1 :: Double#) -> _!_ D# [] [u1] } _N_} _F_ _IF_ARGS_ 0 1 C 4 \ (u0 :: Double) -> case u0 of { _ALG_ D# (u1 :: Double#) -> case _#_ expDouble# [] [u1] of { _PRIM_ (u2 :: Double#) -> _!_ D# [] [u2] }; _NO_DEFLT_ } _N_ },
+ log = { _A_ 1 _U_ 1 _N_ _S_ "U(P)" {_A_ 1 _U_ 2 _N_ _N_ _F_ _IF_ARGS_ 0 1 X 3 \ (u0 :: Double#) -> case _#_ logDouble# [] [u0] of { _PRIM_ (u1 :: Double#) -> _!_ D# [] [u1] } _N_} _F_ _IF_ARGS_ 0 1 C 4 \ (u0 :: Double) -> case u0 of { _ALG_ D# (u1 :: Double#) -> case _#_ logDouble# [] [u1] of { _PRIM_ (u2 :: Double#) -> _!_ D# [] [u2] }; _NO_DEFLT_ } _N_ },
+ sqrt = { _A_ 1 _U_ 1 _N_ _S_ "U(P)" {_A_ 1 _U_ 2 _N_ _N_ _F_ _IF_ARGS_ 0 1 X 3 \ (u0 :: Double#) -> case _#_ sqrtDouble# [] [u0] of { _PRIM_ (u1 :: Double#) -> _!_ D# [] [u1] } _N_} _F_ _IF_ARGS_ 0 1 C 4 \ (u0 :: Double) -> case u0 of { _ALG_ D# (u1 :: Double#) -> case _#_ sqrtDouble# [] [u1] of { _PRIM_ (u2 :: Double#) -> _!_ D# [] [u2] }; _NO_DEFLT_ } _N_ },
+ (**) = { _A_ 2 _U_ 11 _N_ _S_ "U(P)U(P)" {_A_ 2 _U_ 22 _N_ _N_ _F_ _IF_ARGS_ 0 2 XX 3 \ (u0 :: Double#) (u1 :: Double#) -> case _#_ powerDouble# [] [u0, u1] of { _PRIM_ (u2 :: Double#) -> _!_ D# [] [u2] } _N_} _F_ _IF_ARGS_ 0 2 CC 5 \ (u0 :: Double) (u1 :: Double) -> case u0 of { _ALG_ D# (u2 :: Double#) -> case u1 of { _ALG_ D# (u3 :: Double#) -> case _#_ powerDouble# [] [u2, u3] of { _PRIM_ (u4 :: Double#) -> _!_ D# [] [u4] }; _NO_DEFLT_ }; _NO_DEFLT_ } _N_ },
+ logBase = { _A_ 2 _U_ 11 _N_ _S_ "U(P)U(P)" {_A_ 2 _U_ 22 _N_ _N_ _F_ _IF_ARGS_ 0 2 XX 5 \ (u0 :: Double#) (u1 :: Double#) -> case _#_ logDouble# [] [u1] of { _PRIM_ (u2 :: Double#) -> case _#_ logDouble# [] [u0] of { _PRIM_ (u3 :: Double#) -> case _#_ divideDouble# [] [u2, u3] of { _PRIM_ (u4 :: Double#) -> _!_ D# [] [u4] } } } _N_} _F_ _IF_ARGS_ 0 2 CC 7 \ (u0 :: Double) (u1 :: Double) -> case u1 of { _ALG_ D# (u2 :: Double#) -> case _#_ logDouble# [] [u2] of { _PRIM_ (u3 :: Double#) -> case u0 of { _ALG_ D# (u4 :: Double#) -> case _#_ logDouble# [] [u4] of { _PRIM_ (u5 :: Double#) -> case _#_ divideDouble# [] [u3, u5] of { _PRIM_ (u6 :: Double#) -> _!_ D# [] [u6] } }; _NO_DEFLT_ } }; _NO_DEFLT_ } _N_ },
+ sin = { _A_ 1 _U_ 1 _N_ _S_ "U(P)" {_A_ 1 _U_ 2 _N_ _N_ _F_ _IF_ARGS_ 0 1 X 3 \ (u0 :: Double#) -> case _#_ sinDouble# [] [u0] of { _PRIM_ (u1 :: Double#) -> _!_ D# [] [u1] } _N_} _F_ _IF_ARGS_ 0 1 C 4 \ (u0 :: Double) -> case u0 of { _ALG_ D# (u1 :: Double#) -> case _#_ sinDouble# [] [u1] of { _PRIM_ (u2 :: Double#) -> _!_ D# [] [u2] }; _NO_DEFLT_ } _N_ },
+ cos = { _A_ 1 _U_ 1 _N_ _S_ "U(P)" {_A_ 1 _U_ 2 _N_ _N_ _F_ _IF_ARGS_ 0 1 X 3 \ (u0 :: Double#) -> case _#_ cosDouble# [] [u0] of { _PRIM_ (u1 :: Double#) -> _!_ D# [] [u1] } _N_} _F_ _IF_ARGS_ 0 1 C 4 \ (u0 :: Double) -> case u0 of { _ALG_ D# (u1 :: Double#) -> case _#_ cosDouble# [] [u1] of { _PRIM_ (u2 :: Double#) -> _!_ D# [] [u2] }; _NO_DEFLT_ } _N_ },
+ tan = { _A_ 1 _U_ 1 _N_ _S_ "U(P)" {_A_ 1 _U_ 2 _N_ _N_ _F_ _IF_ARGS_ 0 1 X 3 \ (u0 :: Double#) -> case _#_ tanDouble# [] [u0] of { _PRIM_ (u1 :: Double#) -> _!_ D# [] [u1] } _N_} _F_ _IF_ARGS_ 0 1 C 4 \ (u0 :: Double) -> case u0 of { _ALG_ D# (u1 :: Double#) -> case _#_ tanDouble# [] [u1] of { _PRIM_ (u2 :: Double#) -> _!_ D# [] [u2] }; _NO_DEFLT_ } _N_ },
+ asin = { _A_ 1 _U_ 1 _N_ _S_ "U(P)" {_A_ 1 _U_ 2 _N_ _N_ _F_ _IF_ARGS_ 0 1 X 3 \ (u0 :: Double#) -> case _#_ asinDouble# [] [u0] of { _PRIM_ (u1 :: Double#) -> _!_ D# [] [u1] } _N_} _F_ _IF_ARGS_ 0 1 C 4 \ (u0 :: Double) -> case u0 of { _ALG_ D# (u1 :: Double#) -> case _#_ asinDouble# [] [u1] of { _PRIM_ (u2 :: Double#) -> _!_ D# [] [u2] }; _NO_DEFLT_ } _N_ },
+ acos = { _A_ 1 _U_ 1 _N_ _S_ "U(P)" {_A_ 1 _U_ 2 _N_ _N_ _F_ _IF_ARGS_ 0 1 X 3 \ (u0 :: Double#) -> case _#_ acosDouble# [] [u0] of { _PRIM_ (u1 :: Double#) -> _!_ D# [] [u1] } _N_} _F_ _IF_ARGS_ 0 1 C 4 \ (u0 :: Double) -> case u0 of { _ALG_ D# (u1 :: Double#) -> case _#_ acosDouble# [] [u1] of { _PRIM_ (u2 :: Double#) -> _!_ D# [] [u2] }; _NO_DEFLT_ } _N_ },
+ atan = { _A_ 1 _U_ 1 _N_ _S_ "U(P)" {_A_ 1 _U_ 2 _N_ _N_ _F_ _IF_ARGS_ 0 1 X 3 \ (u0 :: Double#) -> case _#_ atanDouble# [] [u0] of { _PRIM_ (u1 :: Double#) -> _!_ D# [] [u1] } _N_} _F_ _IF_ARGS_ 0 1 C 4 \ (u0 :: Double) -> case u0 of { _ALG_ D# (u1 :: Double#) -> case _#_ atanDouble# [] [u1] of { _PRIM_ (u2 :: Double#) -> _!_ D# [] [u2] }; _NO_DEFLT_ } _N_ },
+ sinh = { _A_ 1 _U_ 1 _N_ _S_ "U(P)" {_A_ 1 _U_ 2 _N_ _N_ _F_ _IF_ARGS_ 0 1 X 3 \ (u0 :: Double#) -> case _#_ sinhDouble# [] [u0] of { _PRIM_ (u1 :: Double#) -> _!_ D# [] [u1] } _N_} _F_ _IF_ARGS_ 0 1 C 4 \ (u0 :: Double) -> case u0 of { _ALG_ D# (u1 :: Double#) -> case _#_ sinhDouble# [] [u1] of { _PRIM_ (u2 :: Double#) -> _!_ D# [] [u2] }; _NO_DEFLT_ } _N_ },
+ cosh = { _A_ 1 _U_ 1 _N_ _S_ "U(P)" {_A_ 1 _U_ 2 _N_ _N_ _F_ _IF_ARGS_ 0 1 X 3 \ (u0 :: Double#) -> case _#_ coshDouble# [] [u0] of { _PRIM_ (u1 :: Double#) -> _!_ D# [] [u1] } _N_} _F_ _IF_ARGS_ 0 1 C 4 \ (u0 :: Double) -> case u0 of { _ALG_ D# (u1 :: Double#) -> case _#_ coshDouble# [] [u1] of { _PRIM_ (u2 :: Double#) -> _!_ D# [] [u2] }; _NO_DEFLT_ } _N_ },
+ tanh = { _A_ 1 _U_ 1 _N_ _S_ "U(P)" {_A_ 1 _U_ 2 _N_ _N_ _F_ _IF_ARGS_ 0 1 X 3 \ (u0 :: Double#) -> case _#_ tanhDouble# [] [u0] of { _PRIM_ (u1 :: Double#) -> _!_ D# [] [u1] } _N_} _F_ _IF_ARGS_ 0 1 C 4 \ (u0 :: Double) -> case u0 of { _ALG_ D# (u1 :: Double#) -> case _#_ tanhDouble# [] [u1] of { _PRIM_ (u2 :: Double#) -> _!_ D# [] [u2] }; _NO_DEFLT_ } _N_ },
+ asinh = { _A_ 1 _U_ 1 _N_ _S_ "U(P)" {_A_ 1 _U_ 2 _N_ _N_ _N_ _N_} _N_ _N_ },
+ acosh = { _A_ 1 _U_ 1 _N_ _S_ "U(P)" {_A_ 1 _U_ 2 _N_ _N_ _N_ _N_} _N_ _N_ },
+ atanh = { _A_ 1 _U_ 1 _N_ _S_ "U(P)" {_A_ 1 _U_ 2 _N_ _N_ _N_ _N_} _N_ _N_ } #-}
instance Floating Float
{-# GHC_PRAGMA _M_ PreludeCore {-dfun-} _A_ 0 _N_ _N_ _N_ _F_ _IF_ARGS_ 0 0 X 20 _!_ _TUP_19 [{{Fractional Float}}, Float, (Float -> Float), (Float -> Float), (Float -> Float), (Float -> Float -> Float), (Float -> Float -> Float), (Float -> Float), (Float -> Float), (Float -> Float), (Float -> Float), (Float -> Float), (Float -> Float), (Float -> Float), (Float -> Float), (Float -> Float), (Float -> Float), (Float -> Float), (Float -> Float)] [_DFUN_ Fractional (Float), _CONSTM_ Floating pi (Float), _CONSTM_ Floating exp (Float), _CONSTM_ Floating log (Float), _CONSTM_ Floating sqrt (Float), _CONSTM_ Floating (**) (Float), _CONSTM_ Floating logBase (Float), _CONSTM_ Floating sin (Float), _CONSTM_ Floating cos (Float), _CONSTM_ Floating tan (Float), _CONSTM_ Floating asin (Float), _CONSTM_ Floating acos (Float), _CONSTM_ Floating atan (Float), _CONSTM_ Floating sinh (Float), _CONSTM_ Floating cosh (Float), _CONSTM_ Floating tanh (Float), _CONSTM_ Floating asinh (Float), _CONSTM_ Floating acosh (Float), _CONSTM_ Floating atanh (Float)] _N_
- pi = _A_ 0 _N_ _N_ _N_ _F_ _IF_ARGS_ 0 0 X 2 _!_ F# [] [3.1415926535897931#] _N_,
- exp = _A_ 1 _U_ 1 _N_ _S_ "U(P)" {_A_ 1 _U_ 2 _N_ _N_ _F_ _IF_ARGS_ 0 1 X 3 \ (u0 :: Float#) -> case _#_ expFloat# [] [u0] of { _PRIM_ (u1 :: Float#) -> _!_ F# [] [u1] } _N_} _F_ _IF_ARGS_ 0 1 C 4 \ (u0 :: Float) -> case u0 of { _ALG_ F# (u1 :: Float#) -> case _#_ expFloat# [] [u1] of { _PRIM_ (u2 :: Float#) -> _!_ F# [] [u2] }; _NO_DEFLT_ } _N_,
- log = _A_ 1 _U_ 1 _N_ _S_ "U(P)" {_A_ 1 _U_ 2 _N_ _N_ _F_ _IF_ARGS_ 0 1 X 3 \ (u0 :: Float#) -> case _#_ logFloat# [] [u0] of { _PRIM_ (u1 :: Float#) -> _!_ F# [] [u1] } _N_} _F_ _IF_ARGS_ 0 1 C 4 \ (u0 :: Float) -> case u0 of { _ALG_ F# (u1 :: Float#) -> case _#_ logFloat# [] [u1] of { _PRIM_ (u2 :: Float#) -> _!_ F# [] [u2] }; _NO_DEFLT_ } _N_,
- sqrt = _A_ 1 _U_ 1 _N_ _S_ "U(P)" {_A_ 1 _U_ 2 _N_ _N_ _F_ _IF_ARGS_ 0 1 X 3 \ (u0 :: Float#) -> case _#_ sqrtFloat# [] [u0] of { _PRIM_ (u1 :: Float#) -> _!_ F# [] [u1] } _N_} _F_ _IF_ARGS_ 0 1 C 4 \ (u0 :: Float) -> case u0 of { _ALG_ F# (u1 :: Float#) -> case _#_ sqrtFloat# [] [u1] of { _PRIM_ (u2 :: Float#) -> _!_ F# [] [u2] }; _NO_DEFLT_ } _N_,
- (**) = _A_ 2 _U_ 11 _N_ _S_ "U(P)U(P)" {_A_ 2 _U_ 22 _N_ _N_ _F_ _IF_ARGS_ 0 2 XX 3 \ (u0 :: Float#) (u1 :: Float#) -> case _#_ powerFloat# [] [u0, u1] of { _PRIM_ (u2 :: Float#) -> _!_ F# [] [u2] } _N_} _F_ _IF_ARGS_ 0 2 CC 5 \ (u0 :: Float) (u1 :: Float) -> case u0 of { _ALG_ F# (u2 :: Float#) -> case u1 of { _ALG_ F# (u3 :: Float#) -> case _#_ powerFloat# [] [u2, u3] of { _PRIM_ (u4 :: Float#) -> _!_ F# [] [u4] }; _NO_DEFLT_ }; _NO_DEFLT_ } _N_,
- logBase = _A_ 2 _U_ 22 _N_ _N_ _N_ _N_,
- sin = _A_ 1 _U_ 1 _N_ _S_ "U(P)" {_A_ 1 _U_ 2 _N_ _N_ _F_ _IF_ARGS_ 0 1 X 3 \ (u0 :: Float#) -> case _#_ sinFloat# [] [u0] of { _PRIM_ (u1 :: Float#) -> _!_ F# [] [u1] } _N_} _F_ _IF_ARGS_ 0 1 C 4 \ (u0 :: Float) -> case u0 of { _ALG_ F# (u1 :: Float#) -> case _#_ sinFloat# [] [u1] of { _PRIM_ (u2 :: Float#) -> _!_ F# [] [u2] }; _NO_DEFLT_ } _N_,
- cos = _A_ 1 _U_ 1 _N_ _S_ "U(P)" {_A_ 1 _U_ 2 _N_ _N_ _F_ _IF_ARGS_ 0 1 X 3 \ (u0 :: Float#) -> case _#_ cosFloat# [] [u0] of { _PRIM_ (u1 :: Float#) -> _!_ F# [] [u1] } _N_} _F_ _IF_ARGS_ 0 1 C 4 \ (u0 :: Float) -> case u0 of { _ALG_ F# (u1 :: Float#) -> case _#_ cosFloat# [] [u1] of { _PRIM_ (u2 :: Float#) -> _!_ F# [] [u2] }; _NO_DEFLT_ } _N_,
- tan = _A_ 1 _U_ 1 _N_ _S_ "U(P)" {_A_ 1 _U_ 2 _N_ _N_ _F_ _IF_ARGS_ 0 1 X 3 \ (u0 :: Float#) -> case _#_ tanFloat# [] [u0] of { _PRIM_ (u1 :: Float#) -> _!_ F# [] [u1] } _N_} _F_ _IF_ARGS_ 0 1 C 4 \ (u0 :: Float) -> case u0 of { _ALG_ F# (u1 :: Float#) -> case _#_ tanFloat# [] [u1] of { _PRIM_ (u2 :: Float#) -> _!_ F# [] [u2] }; _NO_DEFLT_ } _N_,
- asin = _A_ 1 _U_ 1 _N_ _S_ "U(P)" {_A_ 1 _U_ 2 _N_ _N_ _F_ _IF_ARGS_ 0 1 X 3 \ (u0 :: Float#) -> case _#_ asinFloat# [] [u0] of { _PRIM_ (u1 :: Float#) -> _!_ F# [] [u1] } _N_} _F_ _IF_ARGS_ 0 1 C 4 \ (u0 :: Float) -> case u0 of { _ALG_ F# (u1 :: Float#) -> case _#_ asinFloat# [] [u1] of { _PRIM_ (u2 :: Float#) -> _!_ F# [] [u2] }; _NO_DEFLT_ } _N_,
- acos = _A_ 1 _U_ 1 _N_ _S_ "U(P)" {_A_ 1 _U_ 2 _N_ _N_ _F_ _IF_ARGS_ 0 1 X 3 \ (u0 :: Float#) -> case _#_ acosFloat# [] [u0] of { _PRIM_ (u1 :: Float#) -> _!_ F# [] [u1] } _N_} _F_ _IF_ARGS_ 0 1 C 4 \ (u0 :: Float) -> case u0 of { _ALG_ F# (u1 :: Float#) -> case _#_ acosFloat# [] [u1] of { _PRIM_ (u2 :: Float#) -> _!_ F# [] [u2] }; _NO_DEFLT_ } _N_,
- atan = _A_ 1 _U_ 1 _N_ _S_ "U(P)" {_A_ 1 _U_ 2 _N_ _N_ _F_ _IF_ARGS_ 0 1 X 3 \ (u0 :: Float#) -> case _#_ atanFloat# [] [u0] of { _PRIM_ (u1 :: Float#) -> _!_ F# [] [u1] } _N_} _F_ _IF_ARGS_ 0 1 C 4 \ (u0 :: Float) -> case u0 of { _ALG_ F# (u1 :: Float#) -> case _#_ atanFloat# [] [u1] of { _PRIM_ (u2 :: Float#) -> _!_ F# [] [u2] }; _NO_DEFLT_ } _N_,
- sinh = _A_ 1 _U_ 1 _N_ _S_ "U(P)" {_A_ 1 _U_ 2 _N_ _N_ _F_ _IF_ARGS_ 0 1 X 3 \ (u0 :: Float#) -> case _#_ sinhFloat# [] [u0] of { _PRIM_ (u1 :: Float#) -> _!_ F# [] [u1] } _N_} _F_ _IF_ARGS_ 0 1 C 4 \ (u0 :: Float) -> case u0 of { _ALG_ F# (u1 :: Float#) -> case _#_ sinhFloat# [] [u1] of { _PRIM_ (u2 :: Float#) -> _!_ F# [] [u2] }; _NO_DEFLT_ } _N_,
- cosh = _A_ 1 _U_ 1 _N_ _S_ "U(P)" {_A_ 1 _U_ 2 _N_ _N_ _F_ _IF_ARGS_ 0 1 X 3 \ (u0 :: Float#) -> case _#_ coshFloat# [] [u0] of { _PRIM_ (u1 :: Float#) -> _!_ F# [] [u1] } _N_} _F_ _IF_ARGS_ 0 1 C 4 \ (u0 :: Float) -> case u0 of { _ALG_ F# (u1 :: Float#) -> case _#_ coshFloat# [] [u1] of { _PRIM_ (u2 :: Float#) -> _!_ F# [] [u2] }; _NO_DEFLT_ } _N_,
- tanh = _A_ 1 _U_ 1 _N_ _S_ "U(P)" {_A_ 1 _U_ 2 _N_ _N_ _F_ _IF_ARGS_ 0 1 X 3 \ (u0 :: Float#) -> case _#_ tanhFloat# [] [u0] of { _PRIM_ (u1 :: Float#) -> _!_ F# [] [u1] } _N_} _F_ _IF_ARGS_ 0 1 C 4 \ (u0 :: Float) -> case u0 of { _ALG_ F# (u1 :: Float#) -> case _#_ tanhFloat# [] [u1] of { _PRIM_ (u2 :: Float#) -> _!_ F# [] [u2] }; _NO_DEFLT_ } _N_,
- asinh = _A_ 1 _U_ 1 _N_ _S_ "U(P)" {_A_ 1 _U_ 2 _N_ _N_ _N_ _N_} _N_ _N_,
- acosh = _A_ 1 _U_ 1 _N_ _S_ "U(P)" {_A_ 1 _U_ 2 _N_ _N_ _N_ _N_} _N_ _N_,
- atanh = _A_ 1 _U_ 1 _N_ _S_ "U(P)" {_A_ 1 _U_ 2 _N_ _N_ _N_ _N_} _N_ _N_ #-}
+ pi = { _A_ 0 _N_ _N_ _N_ _F_ _IF_ARGS_ 0 0 X 2 _!_ F# [] [3.1415926535897931#] _N_ },
+ exp = { _A_ 1 _U_ 1 _N_ _S_ "U(P)" {_A_ 1 _U_ 2 _N_ _N_ _F_ _IF_ARGS_ 0 1 X 3 \ (u0 :: Float#) -> case _#_ expFloat# [] [u0] of { _PRIM_ (u1 :: Float#) -> _!_ F# [] [u1] } _N_} _F_ _IF_ARGS_ 0 1 C 4 \ (u0 :: Float) -> case u0 of { _ALG_ F# (u1 :: Float#) -> case _#_ expFloat# [] [u1] of { _PRIM_ (u2 :: Float#) -> _!_ F# [] [u2] }; _NO_DEFLT_ } _N_ },
+ log = { _A_ 1 _U_ 1 _N_ _S_ "U(P)" {_A_ 1 _U_ 2 _N_ _N_ _F_ _IF_ARGS_ 0 1 X 3 \ (u0 :: Float#) -> case _#_ logFloat# [] [u0] of { _PRIM_ (u1 :: Float#) -> _!_ F# [] [u1] } _N_} _F_ _IF_ARGS_ 0 1 C 4 \ (u0 :: Float) -> case u0 of { _ALG_ F# (u1 :: Float#) -> case _#_ logFloat# [] [u1] of { _PRIM_ (u2 :: Float#) -> _!_ F# [] [u2] }; _NO_DEFLT_ } _N_ },
+ sqrt = { _A_ 1 _U_ 1 _N_ _S_ "U(P)" {_A_ 1 _U_ 2 _N_ _N_ _F_ _IF_ARGS_ 0 1 X 3 \ (u0 :: Float#) -> case _#_ sqrtFloat# [] [u0] of { _PRIM_ (u1 :: Float#) -> _!_ F# [] [u1] } _N_} _F_ _IF_ARGS_ 0 1 C 4 \ (u0 :: Float) -> case u0 of { _ALG_ F# (u1 :: Float#) -> case _#_ sqrtFloat# [] [u1] of { _PRIM_ (u2 :: Float#) -> _!_ F# [] [u2] }; _NO_DEFLT_ } _N_ },
+ (**) = { _A_ 2 _U_ 11 _N_ _S_ "U(P)U(P)" {_A_ 2 _U_ 22 _N_ _N_ _F_ _IF_ARGS_ 0 2 XX 3 \ (u0 :: Float#) (u1 :: Float#) -> case _#_ powerFloat# [] [u0, u1] of { _PRIM_ (u2 :: Float#) -> _!_ F# [] [u2] } _N_} _F_ _IF_ARGS_ 0 2 CC 5 \ (u0 :: Float) (u1 :: Float) -> case u0 of { _ALG_ F# (u2 :: Float#) -> case u1 of { _ALG_ F# (u3 :: Float#) -> case _#_ powerFloat# [] [u2, u3] of { _PRIM_ (u4 :: Float#) -> _!_ F# [] [u4] }; _NO_DEFLT_ }; _NO_DEFLT_ } _N_ },
+ logBase = { _A_ 2 _U_ 11 _N_ _S_ "U(P)U(P)" {_A_ 2 _U_ 22 _N_ _N_ _F_ _IF_ARGS_ 0 2 XX 5 \ (u0 :: Float#) (u1 :: Float#) -> case _#_ logFloat# [] [u1] of { _PRIM_ (u2 :: Float#) -> case _#_ logFloat# [] [u0] of { _PRIM_ (u3 :: Float#) -> case _#_ divideFloat# [] [u2, u3] of { _PRIM_ (u4 :: Float#) -> _!_ F# [] [u4] } } } _N_} _F_ _IF_ARGS_ 0 2 CC 7 \ (u0 :: Float) (u1 :: Float) -> case u1 of { _ALG_ F# (u2 :: Float#) -> case _#_ logFloat# [] [u2] of { _PRIM_ (u3 :: Float#) -> case u0 of { _ALG_ F# (u4 :: Float#) -> case _#_ logFloat# [] [u4] of { _PRIM_ (u5 :: Float#) -> case _#_ divideFloat# [] [u3, u5] of { _PRIM_ (u6 :: Float#) -> _!_ F# [] [u6] } }; _NO_DEFLT_ } }; _NO_DEFLT_ } _N_ },
+ sin = { _A_ 1 _U_ 1 _N_ _S_ "U(P)" {_A_ 1 _U_ 2 _N_ _N_ _F_ _IF_ARGS_ 0 1 X 3 \ (u0 :: Float#) -> case _#_ sinFloat# [] [u0] of { _PRIM_ (u1 :: Float#) -> _!_ F# [] [u1] } _N_} _F_ _IF_ARGS_ 0 1 C 4 \ (u0 :: Float) -> case u0 of { _ALG_ F# (u1 :: Float#) -> case _#_ sinFloat# [] [u1] of { _PRIM_ (u2 :: Float#) -> _!_ F# [] [u2] }; _NO_DEFLT_ } _N_ },
+ cos = { _A_ 1 _U_ 1 _N_ _S_ "U(P)" {_A_ 1 _U_ 2 _N_ _N_ _F_ _IF_ARGS_ 0 1 X 3 \ (u0 :: Float#) -> case _#_ cosFloat# [] [u0] of { _PRIM_ (u1 :: Float#) -> _!_ F# [] [u1] } _N_} _F_ _IF_ARGS_ 0 1 C 4 \ (u0 :: Float) -> case u0 of { _ALG_ F# (u1 :: Float#) -> case _#_ cosFloat# [] [u1] of { _PRIM_ (u2 :: Float#) -> _!_ F# [] [u2] }; _NO_DEFLT_ } _N_ },
+ tan = { _A_ 1 _U_ 1 _N_ _S_ "U(P)" {_A_ 1 _U_ 2 _N_ _N_ _F_ _IF_ARGS_ 0 1 X 3 \ (u0 :: Float#) -> case _#_ tanFloat# [] [u0] of { _PRIM_ (u1 :: Float#) -> _!_ F# [] [u1] } _N_} _F_ _IF_ARGS_ 0 1 C 4 \ (u0 :: Float) -> case u0 of { _ALG_ F# (u1 :: Float#) -> case _#_ tanFloat# [] [u1] of { _PRIM_ (u2 :: Float#) -> _!_ F# [] [u2] }; _NO_DEFLT_ } _N_ },
+ asin = { _A_ 1 _U_ 1 _N_ _S_ "U(P)" {_A_ 1 _U_ 2 _N_ _N_ _F_ _IF_ARGS_ 0 1 X 3 \ (u0 :: Float#) -> case _#_ asinFloat# [] [u0] of { _PRIM_ (u1 :: Float#) -> _!_ F# [] [u1] } _N_} _F_ _IF_ARGS_ 0 1 C 4 \ (u0 :: Float) -> case u0 of { _ALG_ F# (u1 :: Float#) -> case _#_ asinFloat# [] [u1] of { _PRIM_ (u2 :: Float#) -> _!_ F# [] [u2] }; _NO_DEFLT_ } _N_ },
+ acos = { _A_ 1 _U_ 1 _N_ _S_ "U(P)" {_A_ 1 _U_ 2 _N_ _N_ _F_ _IF_ARGS_ 0 1 X 3 \ (u0 :: Float#) -> case _#_ acosFloat# [] [u0] of { _PRIM_ (u1 :: Float#) -> _!_ F# [] [u1] } _N_} _F_ _IF_ARGS_ 0 1 C 4 \ (u0 :: Float) -> case u0 of { _ALG_ F# (u1 :: Float#) -> case _#_ acosFloat# [] [u1] of { _PRIM_ (u2 :: Float#) -> _!_ F# [] [u2] }; _NO_DEFLT_ } _N_ },
+ atan = { _A_ 1 _U_ 1 _N_ _S_ "U(P)" {_A_ 1 _U_ 2 _N_ _N_ _F_ _IF_ARGS_ 0 1 X 3 \ (u0 :: Float#) -> case _#_ atanFloat# [] [u0] of { _PRIM_ (u1 :: Float#) -> _!_ F# [] [u1] } _N_} _F_ _IF_ARGS_ 0 1 C 4 \ (u0 :: Float) -> case u0 of { _ALG_ F# (u1 :: Float#) -> case _#_ atanFloat# [] [u1] of { _PRIM_ (u2 :: Float#) -> _!_ F# [] [u2] }; _NO_DEFLT_ } _N_ },
+ sinh = { _A_ 1 _U_ 1 _N_ _S_ "U(P)" {_A_ 1 _U_ 2 _N_ _N_ _F_ _IF_ARGS_ 0 1 X 3 \ (u0 :: Float#) -> case _#_ sinhFloat# [] [u0] of { _PRIM_ (u1 :: Float#) -> _!_ F# [] [u1] } _N_} _F_ _IF_ARGS_ 0 1 C 4 \ (u0 :: Float) -> case u0 of { _ALG_ F# (u1 :: Float#) -> case _#_ sinhFloat# [] [u1] of { _PRIM_ (u2 :: Float#) -> _!_ F# [] [u2] }; _NO_DEFLT_ } _N_ },
+ cosh = { _A_ 1 _U_ 1 _N_ _S_ "U(P)" {_A_ 1 _U_ 2 _N_ _N_ _F_ _IF_ARGS_ 0 1 X 3 \ (u0 :: Float#) -> case _#_ coshFloat# [] [u0] of { _PRIM_ (u1 :: Float#) -> _!_ F# [] [u1] } _N_} _F_ _IF_ARGS_ 0 1 C 4 \ (u0 :: Float) -> case u0 of { _ALG_ F# (u1 :: Float#) -> case _#_ coshFloat# [] [u1] of { _PRIM_ (u2 :: Float#) -> _!_ F# [] [u2] }; _NO_DEFLT_ } _N_ },
+ tanh = { _A_ 1 _U_ 1 _N_ _S_ "U(P)" {_A_ 1 _U_ 2 _N_ _N_ _F_ _IF_ARGS_ 0 1 X 3 \ (u0 :: Float#) -> case _#_ tanhFloat# [] [u0] of { _PRIM_ (u1 :: Float#) -> _!_ F# [] [u1] } _N_} _F_ _IF_ARGS_ 0 1 C 4 \ (u0 :: Float) -> case u0 of { _ALG_ F# (u1 :: Float#) -> case _#_ tanhFloat# [] [u1] of { _PRIM_ (u2 :: Float#) -> _!_ F# [] [u2] }; _NO_DEFLT_ } _N_ },
+ asinh = { _A_ 1 _U_ 1 _N_ _S_ "U(P)" {_A_ 1 _U_ 2 _N_ _N_ _N_ _N_} _N_ _N_ },
+ acosh = { _A_ 1 _U_ 1 _N_ _S_ "U(P)" {_A_ 1 _U_ 2 _N_ _N_ _N_ _N_} _N_ _N_ },
+ atanh = { _A_ 1 _U_ 1 _N_ _S_ "U(P)" {_A_ 1 _U_ 2 _N_ _N_ _N_ _N_} _N_ _N_ } #-}
instance RealFloat a => Fractional (Complex a)
{-# GHC_PRAGMA _M_ PreludeComplex {-dfun-} _A_ 2 _U_ 22 _N_ _N_ _N_ _N_ #-}
instance Fractional (Complex Double)
{-# GHC_PRAGMA _M_ PreludeComplex {-dfun-} _A_ 0 _N_ _N_ _N_ _F_ _IF_ARGS_ 0 0 X 5 _!_ _TUP_4 [{{Num (Complex Double)}}, (Complex Double -> Complex Double -> Complex Double), (Complex Double -> Complex Double), (Ratio Integer -> Complex Double)] [_DFUN_ Num (Complex Double), _CONSTM_ Fractional (/) (Complex Double), _CONSTM_ Fractional recip (Complex Double), _CONSTM_ Fractional fromRational (Complex Double)] _N_
- (/) = _A_ 2 _U_ 11 _N_ _S_ "U(LL)U(LL)" {_A_ 4 _U_ 2222 _N_ _N_ _N_ _N_} _N_ _N_,
- recip = _A_ 1 _U_ 1 _N_ _S_ "U(LL)" {_A_ 2 _U_ 22 _N_ _N_ _N_ _N_} _N_ _N_,
- fromRational = _A_ 1 _U_ 2 _N_ _N_ _N_ _N_ #-}
+ (/) = { _A_ 2 _U_ 11 _N_ _S_ "U(LL)U(LL)" {_A_ 4 _U_ 2222 _N_ _N_ _N_ _N_} _N_ _N_ },
+ recip = { _A_ 1 _U_ 1 _N_ _S_ "U(LL)" {_A_ 2 _U_ 22 _N_ _N_ _N_ _N_} _F_ _IF_ARGS_ 0 1 X 3 \ (u0 :: Complex Double) -> _APP_ _CONSTM_ Fractional (/) (Complex Double) [ _SPEC_ _ORIG_ PreludeCore __i1 [ (Complex Double) ], u0 ] _N_ },
+ fromRational = { _A_ 1 _U_ 1 _N_ _N_ _N_ _N_ } #-}
instance Fractional Double
{-# GHC_PRAGMA _M_ PreludeCore {-dfun-} _A_ 0 _N_ _N_ _N_ _F_ _IF_ARGS_ 0 0 X 5 _!_ _TUP_4 [{{Num Double}}, (Double -> Double -> Double), (Double -> Double), (Ratio Integer -> Double)] [_DFUN_ Num (Double), _CONSTM_ Fractional (/) (Double), _CONSTM_ Fractional recip (Double), _CONSTM_ Fractional fromRational (Double)] _N_
- (/) = _A_ 2 _U_ 11 _N_ _S_ "U(P)U(P)" {_A_ 2 _U_ 22 _N_ _N_ _F_ _IF_ARGS_ 0 2 XX 3 \ (u0 :: Double#) (u1 :: Double#) -> case _#_ divideDouble# [] [u0, u1] of { _PRIM_ (u2 :: Double#) -> _!_ D# [] [u2] } _N_} _F_ _IF_ARGS_ 0 2 CC 5 \ (u0 :: Double) (u1 :: Double) -> case u0 of { _ALG_ D# (u2 :: Double#) -> case u1 of { _ALG_ D# (u3 :: Double#) -> case _#_ divideDouble# [] [u2, u3] of { _PRIM_ (u4 :: Double#) -> _!_ D# [] [u4] }; _NO_DEFLT_ }; _NO_DEFLT_ } _N_,
- recip = _A_ 1 _U_ 1 _N_ _S_ "U(P)" {_A_ 1 _U_ 2 _N_ _N_ _F_ _IF_ARGS_ 0 1 X 3 \ (u0 :: Double#) -> case _#_ divideDouble# [] [1.0000000000000000##, u0] of { _PRIM_ (u1 :: Double#) -> _!_ D# [] [u1] } _N_} _F_ _IF_ARGS_ 0 1 C 4 \ (u0 :: Double) -> case u0 of { _ALG_ D# (u1 :: Double#) -> case _#_ divideDouble# [] [1.0000000000000000##, u1] of { _PRIM_ (u2 :: Double#) -> _!_ D# [] [u2] }; _NO_DEFLT_ } _N_,
- fromRational = _A_ 0 _U_ 2 _N_ _N_ _N_ _N_ #-}
+ (/) = { _A_ 2 _U_ 11 _N_ _S_ "U(P)U(P)" {_A_ 2 _U_ 22 _N_ _N_ _F_ _IF_ARGS_ 0 2 XX 3 \ (u0 :: Double#) (u1 :: Double#) -> case _#_ divideDouble# [] [u0, u1] of { _PRIM_ (u2 :: Double#) -> _!_ D# [] [u2] } _N_} _F_ _IF_ARGS_ 0 2 CC 5 \ (u0 :: Double) (u1 :: Double) -> case u0 of { _ALG_ D# (u2 :: Double#) -> case u1 of { _ALG_ D# (u3 :: Double#) -> case _#_ divideDouble# [] [u2, u3] of { _PRIM_ (u4 :: Double#) -> _!_ D# [] [u4] }; _NO_DEFLT_ }; _NO_DEFLT_ } _N_ },
+ recip = { _A_ 1 _U_ 1 _N_ _S_ "U(P)" {_A_ 1 _U_ 2 _N_ _N_ _F_ _IF_ARGS_ 0 1 X 3 \ (u0 :: Double#) -> case _#_ divideDouble# [] [1.0000000000000000##, u0] of { _PRIM_ (u1 :: Double#) -> _!_ D# [] [u1] } _N_} _F_ _IF_ARGS_ 0 1 C 4 \ (u0 :: Double) -> case u0 of { _ALG_ D# (u1 :: Double#) -> case _#_ divideDouble# [] [1.0000000000000000##, u1] of { _PRIM_ (u2 :: Double#) -> _!_ D# [] [u2] }; _NO_DEFLT_ } _N_ },
+ fromRational = { _A_ 1 _U_ 1 _N_ _S_ "U(U(PPP)U(PPP))" {_A_ 4 _U_ 2222 _N_ _N_ _N_ _N_} _N_ _N_ } #-}
instance Fractional Float
{-# GHC_PRAGMA _M_ PreludeCore {-dfun-} _A_ 0 _N_ _N_ _N_ _F_ _IF_ARGS_ 0 0 X 5 _!_ _TUP_4 [{{Num Float}}, (Float -> Float -> Float), (Float -> Float), (Ratio Integer -> Float)] [_DFUN_ Num (Float), _CONSTM_ Fractional (/) (Float), _CONSTM_ Fractional recip (Float), _CONSTM_ Fractional fromRational (Float)] _N_
- (/) = _A_ 2 _U_ 11 _N_ _S_ "U(P)U(P)" {_A_ 2 _U_ 22 _N_ _N_ _F_ _IF_ARGS_ 0 2 XX 3 \ (u0 :: Float#) (u1 :: Float#) -> case _#_ divideFloat# [] [u0, u1] of { _PRIM_ (u2 :: Float#) -> _!_ F# [] [u2] } _N_} _F_ _IF_ARGS_ 0 2 CC 5 \ (u0 :: Float) (u1 :: Float) -> case u0 of { _ALG_ F# (u2 :: Float#) -> case u1 of { _ALG_ F# (u3 :: Float#) -> case _#_ divideFloat# [] [u2, u3] of { _PRIM_ (u4 :: Float#) -> _!_ F# [] [u4] }; _NO_DEFLT_ }; _NO_DEFLT_ } _N_,
- recip = _A_ 0 _U_ 2 _N_ _N_ _N_ _N_,
- fromRational = _A_ 0 _U_ 2 _N_ _N_ _N_ _N_ #-}
+ (/) = { _A_ 2 _U_ 11 _N_ _S_ "U(P)U(P)" {_A_ 2 _U_ 22 _N_ _N_ _F_ _IF_ARGS_ 0 2 XX 3 \ (u0 :: Float#) (u1 :: Float#) -> case _#_ divideFloat# [] [u0, u1] of { _PRIM_ (u2 :: Float#) -> _!_ F# [] [u2] } _N_} _F_ _IF_ARGS_ 0 2 CC 5 \ (u0 :: Float) (u1 :: Float) -> case u0 of { _ALG_ F# (u2 :: Float#) -> case u1 of { _ALG_ F# (u3 :: Float#) -> case _#_ divideFloat# [] [u2, u3] of { _PRIM_ (u4 :: Float#) -> _!_ F# [] [u4] }; _NO_DEFLT_ }; _NO_DEFLT_ } _N_ },
+ recip = { _A_ 1 _U_ 1 _N_ _S_ "U(P)" {_A_ 1 _U_ 2 _N_ _N_ _F_ _IF_ARGS_ 0 1 X 3 \ (u0 :: Float#) -> case _#_ divideFloat# [] [1.0000000000000000#, u0] of { _PRIM_ (u1 :: Float#) -> _!_ F# [] [u1] } _N_} _F_ _IF_ARGS_ 0 1 C 4 \ (u0 :: Float) -> case u0 of { _ALG_ F# (u1 :: Float#) -> case _#_ divideFloat# [] [1.0000000000000000#, u1] of { _PRIM_ (u2 :: Float#) -> _!_ F# [] [u2] }; _NO_DEFLT_ } _N_ },
+ fromRational = { _A_ 1 _U_ 2 _N_ _N_ _N_ _N_ } #-}
instance Integral a => Fractional (Ratio a)
{-# GHC_PRAGMA _M_ PreludeRatio {-dfun-} _A_ 2 _U_ 22 _N_ _N_ _N_ _N_ #-}
instance Fractional (Ratio Integer)
{-# GHC_PRAGMA _M_ PreludeRatio {-dfun-} _A_ 0 _N_ _N_ _N_ _F_ _IF_ARGS_ 0 0 X 5 _!_ _TUP_4 [{{Num (Ratio Integer)}}, (Ratio Integer -> Ratio Integer -> Ratio Integer), (Ratio Integer -> Ratio Integer), (Ratio Integer -> Ratio Integer)] [_DFUN_ Num (Ratio Integer), _CONSTM_ Fractional (/) (Ratio Integer), _CONSTM_ Fractional recip (Ratio Integer), _CONSTM_ Fractional fromRational (Ratio Integer)] _N_
- (/) = _A_ 2 _U_ 11 _N_ _S_ "U(LU(PPP))U(U(PPP)L)" {_A_ 5 _U_ 22221 _N_ _N_ _N_ _N_} _N_ _N_,
- recip = _A_ 1 _U_ 1 _N_ _S_ "U(U(PPP)L)" {_A_ 4 _U_ 2222 _N_ _N_ _N_ _N_} _N_ _N_,
- fromRational = _A_ 1 _U_ 1 _N_ _S_ "U(LL)" {_A_ 2 _U_ 22 _N_ _N_ _F_ _IF_ARGS_ 0 2 XX 3 \ (u0 :: Integer) (u1 :: Integer) -> _!_ (:%) [Integer] [u0, u1] _N_} _F_ _IF_ARGS_ 0 1 X 1 \ (u0 :: Ratio Integer) -> u0 _N_ #-}
+ (/) = { _A_ 2 _U_ 11 _N_ _S_ "U(LU(PPP))U(U(PPP)L)" {_A_ 5 _U_ 22221 _N_ _N_ _N_ _N_} _N_ _N_ },
+ recip = { _A_ 1 _U_ 1 _N_ _S_ "U(U(PPP)L)" {_A_ 4 _U_ 2222 _N_ _N_ _N_ _N_} _N_ _N_ },
+ fromRational = { _A_ 1 _U_ 1 _N_ _S_ "U(LL)" {_A_ 2 _U_ 22 _N_ _N_ _F_ _IF_ARGS_ 0 2 XX 3 \ (u0 :: Integer) (u1 :: Integer) -> _!_ (:%) [Integer] [u0, u1] _N_} _F_ _IF_ARGS_ 0 1 X 1 \ (u0 :: Ratio Integer) -> u0 _N_ } #-}
instance Integral Int
{-# GHC_PRAGMA _M_ PreludeCore {-dfun-} _A_ 0 _N_ _N_ _N_ _F_ _IF_ARGS_ 0 0 X 13 _!_ _TUP_12 [{{Real Int}}, {{Ix Int}}, (Int -> Int -> Int), (Int -> Int -> Int), (Int -> Int -> Int), (Int -> Int -> Int), (Int -> Int -> (Int, Int)), (Int -> Int -> (Int, Int)), (Int -> Bool), (Int -> Bool), (Int -> Integer), (Int -> Int)] [_DFUN_ Real (Int), _DFUN_ Ix (Int), _CONSTM_ Integral quot (Int), _CONSTM_ Integral rem (Int), _CONSTM_ Integral div (Int), _CONSTM_ Integral mod (Int), _CONSTM_ Integral quotRem (Int), _CONSTM_ Integral divMod (Int), _CONSTM_ Integral even (Int), _CONSTM_ Integral odd (Int), _CONSTM_ Integral toInteger (Int), _CONSTM_ Integral toInt (Int)] _N_
- quot = _A_ 2 _U_ 11 _N_ _S_ "U(P)U(P)" {_A_ 2 _U_ 22 _N_ _N_ _F_ _IF_ARGS_ 0 2 XC 5 \ (u0 :: Int#) (u1 :: Int#) -> case u1 of { _PRIM_ 0# -> _APP_ _TYAPP_ error { Int } [ _NOREP_S_ "Integral.Int.quot{PreludeCore}: divide by 0\n" ]; (u2 :: Int#) -> case _#_ quotInt# [] [u0, u1] of { _PRIM_ (u3 :: Int#) -> _!_ I# [] [u3] } } _N_} _F_ _IF_ARGS_ 0 2 CC 7 \ (u0 :: Int) (u1 :: Int) -> case u1 of { _ALG_ I# (u2 :: Int#) -> case u2 of { _PRIM_ 0# -> _APP_ _TYAPP_ error { Int } [ _NOREP_S_ "Integral.Int.quot{PreludeCore}: divide by 0\n" ]; (u3 :: Int#) -> case u0 of { _ALG_ I# (u4 :: Int#) -> case _#_ quotInt# [] [u4, u2] of { _PRIM_ (u5 :: Int#) -> _!_ I# [] [u5] }; _NO_DEFLT_ } }; _NO_DEFLT_ } _N_,
- rem = _A_ 2 _U_ 11 _N_ _S_ "U(P)U(P)" {_A_ 2 _U_ 22 _N_ _N_ _F_ _IF_ARGS_ 0 2 XC 5 \ (u0 :: Int#) (u1 :: Int#) -> case u1 of { _PRIM_ 0# -> _APP_ _TYAPP_ error { Int } [ _NOREP_S_ "Integral.Int.rem{PreludeCore}: divide by 0\n" ]; (u2 :: Int#) -> case _#_ remInt# [] [u0, u1] of { _PRIM_ (u3 :: Int#) -> _!_ I# [] [u3] } } _N_} _F_ _IF_ARGS_ 0 2 CC 7 \ (u0 :: Int) (u1 :: Int) -> case u1 of { _ALG_ I# (u2 :: Int#) -> case u2 of { _PRIM_ 0# -> _APP_ _TYAPP_ error { Int } [ _NOREP_S_ "Integral.Int.rem{PreludeCore}: divide by 0\n" ]; (u3 :: Int#) -> case u0 of { _ALG_ I# (u4 :: Int#) -> case _#_ remInt# [] [u4, u2] of { _PRIM_ (u5 :: Int#) -> _!_ I# [] [u5] }; _NO_DEFLT_ } }; _NO_DEFLT_ } _N_,
- div = _A_ 2 _U_ 11 _N_ _S_ "U(P)U(P)" {_A_ 2 _U_ 22 _N_ _N_ _N_ _N_} _N_ _N_,
- mod = _A_ 2 _U_ 11 _N_ _S_ "U(P)U(P)" {_A_ 2 _U_ 22 _N_ _N_ _N_ _N_} _N_ _N_,
- quotRem = _A_ 2 _U_ 11 _N_ _S_ "U(P)U(P)" {_A_ 2 _U_ 22 _N_ _N_ _N_ _N_} _N_ _N_,
- divMod = _A_ 2 _U_ 11 _N_ _S_ "U(P)U(P)" {_A_ 2 _U_ 22 _N_ _N_ _N_ _N_} _N_ _N_,
- even = _A_ 1 _U_ 1 _N_ _S_ "U(P)" {_A_ 1 _U_ 2 _N_ _N_ _N_ _N_} _N_ _N_,
- odd = _A_ 1 _U_ 1 _N_ _S_ "U(P)" {_A_ 1 _U_ 2 _N_ _N_ _N_ _N_} _N_ _N_,
- toInteger = _A_ 1 _U_ 1 _N_ _S_ "U(P)" {_A_ 1 _U_ 2 _N_ _N_ _F_ _IF_ARGS_ 0 1 X 1 \ (u0 :: Int#) -> _#_ int2Integer# [] [u0] _N_} _F_ _IF_ARGS_ 0 1 C 2 \ (u0 :: Int) -> case u0 of { _ALG_ I# (u1 :: Int#) -> _#_ int2Integer# [] [u1]; _NO_DEFLT_ } _N_,
- toInt = _A_ 1 _U_ 1 _N_ _S_ "U(P)" {_A_ 1 _U_ 2 _N_ _N_ _F_ _IF_ARGS_ 0 1 X 2 \ (u0 :: Int#) -> _!_ I# [] [u0] _N_} _F_ _IF_ARGS_ 0 1 X 1 \ (u0 :: Int) -> u0 _N_ #-}
+ quot = { _A_ 2 _U_ 11 _N_ _S_ "U(P)U(P)" {_A_ 2 _U_ 22 _N_ _N_ _F_ _IF_ARGS_ 0 2 XC 5 \ (u0 :: Int#) (u1 :: Int#) -> case u1 of { _PRIM_ 0# -> _APP_ _TYAPP_ error { Int } [ _NOREP_S_ "Integral.Int.quot{PreludeCore}: divide by 0\n" ]; (u2 :: Int#) -> case _#_ quotInt# [] [u0, u1] of { _PRIM_ (u3 :: Int#) -> _!_ I# [] [u3] } } _N_} _F_ _IF_ARGS_ 0 2 CC 7 \ (u0 :: Int) (u1 :: Int) -> case u1 of { _ALG_ I# (u2 :: Int#) -> case u2 of { _PRIM_ 0# -> _APP_ _TYAPP_ error { Int } [ _NOREP_S_ "Integral.Int.quot{PreludeCore}: divide by 0\n" ]; (u3 :: Int#) -> case u0 of { _ALG_ I# (u4 :: Int#) -> case _#_ quotInt# [] [u4, u2] of { _PRIM_ (u5 :: Int#) -> _!_ I# [] [u5] }; _NO_DEFLT_ } }; _NO_DEFLT_ } _N_ },
+ rem = { _A_ 2 _U_ 11 _N_ _S_ "U(P)U(P)" {_A_ 2 _U_ 22 _N_ _N_ _F_ _IF_ARGS_ 0 2 XC 5 \ (u0 :: Int#) (u1 :: Int#) -> case u1 of { _PRIM_ 0# -> _APP_ _TYAPP_ error { Int } [ _NOREP_S_ "Integral.Int.rem{PreludeCore}: divide by 0\n" ]; (u2 :: Int#) -> case _#_ remInt# [] [u0, u1] of { _PRIM_ (u3 :: Int#) -> _!_ I# [] [u3] } } _N_} _F_ _IF_ARGS_ 0 2 CC 7 \ (u0 :: Int) (u1 :: Int) -> case u1 of { _ALG_ I# (u2 :: Int#) -> case u2 of { _PRIM_ 0# -> _APP_ _TYAPP_ error { Int } [ _NOREP_S_ "Integral.Int.rem{PreludeCore}: divide by 0\n" ]; (u3 :: Int#) -> case u0 of { _ALG_ I# (u4 :: Int#) -> case _#_ remInt# [] [u4, u2] of { _PRIM_ (u5 :: Int#) -> _!_ I# [] [u5] }; _NO_DEFLT_ } }; _NO_DEFLT_ } _N_ },
+ div = { _A_ 2 _U_ 11 _N_ _S_ "U(P)U(P)" {_A_ 2 _U_ 22 _N_ _N_ _N_ _N_} _N_ _N_ },
+ mod = { _A_ 2 _U_ 11 _N_ _S_ "U(P)U(P)" {_A_ 2 _U_ 22 _N_ _N_ _N_ _N_} _N_ _N_ },
+ quotRem = { _A_ 2 _U_ 11 _N_ _S_ "U(P)U(P)" {_A_ 2 _U_ 22 _N_ _N_ _N_ _N_} _N_ _N_ },
+ divMod = { _A_ 2 _U_ 11 _N_ _S_ "U(P)U(P)" {_A_ 2 _U_ 22 _N_ _N_ _N_ _N_} _N_ _N_ },
+ even = { _A_ 1 _U_ 1 _N_ _S_ "U(P)" {_A_ 1 _U_ 2 _N_ _N_ _N_ _N_} _N_ _N_ },
+ odd = { _A_ 1 _U_ 1 _N_ _S_ "U(P)" {_A_ 1 _U_ 2 _N_ _N_ _N_ _N_} _N_ _N_ },
+ toInteger = { _A_ 1 _U_ 1 _N_ _S_ "U(P)" {_A_ 1 _U_ 2 _N_ _N_ _F_ _IF_ARGS_ 0 1 X 1 \ (u0 :: Int#) -> _#_ int2Integer# [] [u0] _N_} _F_ _IF_ARGS_ 0 1 C 2 \ (u0 :: Int) -> case u0 of { _ALG_ I# (u1 :: Int#) -> _#_ int2Integer# [] [u1]; _NO_DEFLT_ } _N_ },
+ toInt = { _A_ 1 _U_ 1 _N_ _S_ "U(P)" {_A_ 1 _U_ 2 _N_ _N_ _F_ _IF_ARGS_ 0 1 X 2 \ (u0 :: Int#) -> _!_ I# [] [u0] _N_} _F_ _IF_ARGS_ 0 1 X 1 \ (u0 :: Int) -> u0 _N_ } #-}
instance Integral Integer
{-# GHC_PRAGMA _M_ PreludeCore {-dfun-} _A_ 0 _N_ _N_ _N_ _F_ _IF_ARGS_ 0 0 X 13 _!_ _TUP_12 [{{Real Integer}}, {{Ix Integer}}, (Integer -> Integer -> Integer), (Integer -> Integer -> Integer), (Integer -> Integer -> Integer), (Integer -> Integer -> Integer), (Integer -> Integer -> (Integer, Integer)), (Integer -> Integer -> (Integer, Integer)), (Integer -> Bool), (Integer -> Bool), (Integer -> Integer), (Integer -> Int)] [_DFUN_ Real (Integer), _DFUN_ Ix (Integer), _CONSTM_ Integral quot (Integer), _CONSTM_ Integral rem (Integer), _CONSTM_ Integral div (Integer), _CONSTM_ Integral mod (Integer), _CONSTM_ Integral quotRem (Integer), _CONSTM_ Integral divMod (Integer), _CONSTM_ Integral even (Integer), _CONSTM_ Integral odd (Integer), _CONSTM_ Integral toInteger (Integer), _CONSTM_ Integral toInt (Integer)] _N_
- quot = _A_ 2 _U_ 11 _N_ _S_ "U(PPP)U(PPP)" {_A_ 4 _U_ 2221 _N_ _N_ _F_ _IF_ARGS_ 0 4 XXXX 7 \ (u0 :: Int#) (u1 :: Int#) (u2 :: ByteArray#) (u3 :: Integer) -> case _APP_ _WRKR_ _CONSTM_ Integral quotRem (Integer) [ u0, u1, u2, u3 ] of { _ALG_ _TUP_2 (u4 :: Integer) (u5 :: Integer) -> u4; _NO_DEFLT_ } _N_} _F_ _IF_ARGS_ 0 2 XX 5 \ (u0 :: Integer) (u1 :: Integer) -> case _APP_ _CONSTM_ Integral quotRem (Integer) [ u0, u1 ] of { _ALG_ _TUP_2 (u2 :: Integer) (u3 :: Integer) -> u2; _NO_DEFLT_ } _N_,
- rem = _A_ 2 _U_ 11 _N_ _S_ "U(PPP)U(PPP)" {_A_ 4 _U_ 2221 _N_ _N_ _F_ _IF_ARGS_ 0 4 XXXX 7 \ (u0 :: Int#) (u1 :: Int#) (u2 :: ByteArray#) (u3 :: Integer) -> case _APP_ _WRKR_ _CONSTM_ Integral quotRem (Integer) [ u0, u1, u2, u3 ] of { _ALG_ _TUP_2 (u4 :: Integer) (u5 :: Integer) -> u5; _NO_DEFLT_ } _N_} _F_ _IF_ARGS_ 0 2 XX 5 \ (u0 :: Integer) (u1 :: Integer) -> case _APP_ _CONSTM_ Integral quotRem (Integer) [ u0, u1 ] of { _ALG_ _TUP_2 (u2 :: Integer) (u3 :: Integer) -> u3; _NO_DEFLT_ } _N_,
- div = _A_ 2 _U_ 12 _N_ _S_ "U(PPP)U(PPP)" {_A_ 4 _U_ 2222 _N_ _N_ _F_ _IF_ARGS_ 0 4 XXXX 7 \ (u0 :: Int#) (u1 :: Int#) (u2 :: ByteArray#) (u3 :: Integer) -> case _APP_ _WRKR_ _CONSTM_ Integral divMod (Integer) [ u0, u1, u2, u3 ] of { _ALG_ _TUP_2 (u4 :: Integer) (u5 :: Integer) -> u4; _NO_DEFLT_ } _N_} _F_ _IF_ARGS_ 0 2 XX 5 \ (u0 :: Integer) (u1 :: Integer) -> case _APP_ _CONSTM_ Integral divMod (Integer) [ u0, u1 ] of { _ALG_ _TUP_2 (u2 :: Integer) (u3 :: Integer) -> u2; _NO_DEFLT_ } _N_,
- mod = _A_ 2 _U_ 12 _N_ _S_ "U(PPP)U(PPP)" {_A_ 4 _U_ 2222 _N_ _N_ _F_ _IF_ARGS_ 0 4 XXXX 7 \ (u0 :: Int#) (u1 :: Int#) (u2 :: ByteArray#) (u3 :: Integer) -> case _APP_ _WRKR_ _CONSTM_ Integral divMod (Integer) [ u0, u1, u2, u3 ] of { _ALG_ _TUP_2 (u4 :: Integer) (u5 :: Integer) -> u5; _NO_DEFLT_ } _N_} _F_ _IF_ARGS_ 0 2 XX 5 \ (u0 :: Integer) (u1 :: Integer) -> case _APP_ _CONSTM_ Integral divMod (Integer) [ u0, u1 ] of { _ALG_ _TUP_2 (u2 :: Integer) (u3 :: Integer) -> u3; _NO_DEFLT_ } _N_,
- quotRem = _A_ 2 _U_ 11 _N_ _S_ "U(PPP)U(PPP)" {_A_ 4 _U_ 2221 _N_ _N_ _N_ _N_} _N_ _N_,
- divMod = _A_ 2 _U_ 12 _N_ _S_ "U(PPP)U(PPP)" {_A_ 4 _U_ 2222 _N_ _N_ _N_ _N_} _N_ _N_,
- even = _A_ 1 _U_ 1 _N_ _S_ "U(PPP)" {_A_ 3 _U_ 222 _N_ _N_ _N_ _N_} _N_ _N_,
- odd = _A_ 1 _U_ 1 _N_ _S_ "U(PPP)" {_A_ 3 _U_ 222 _N_ _N_ _N_ _N_} _N_ _N_,
- toInteger = _A_ 1 _U_ 1 _N_ _S_ "U(PPP)" {_A_ 3 _U_ 222 _N_ _N_ _F_ _IF_ARGS_ 0 3 XXX 4 \ (u0 :: Int#) (u1 :: Int#) (u2 :: ByteArray#) -> _!_ J# [] [u0, u1, u2] _N_} _F_ _IF_ARGS_ 0 1 X 1 \ (u0 :: Integer) -> u0 _N_,
- toInt = _A_ 1 _U_ 1 _N_ _S_ "U(PPP)" {_A_ 3 _U_ 222 _N_ _N_ _F_ _IF_ARGS_ 0 3 XXX 3 \ (u0 :: Int#) (u1 :: Int#) (u2 :: ByteArray#) -> case _#_ integer2Int# [] [u0, u1, u2] of { _PRIM_ (u3 :: Int#) -> _!_ I# [] [u3] } _N_} _F_ _IF_ARGS_ 0 1 C 4 \ (u0 :: Integer) -> case u0 of { _ALG_ J# (u1 :: Int#) (u2 :: Int#) (u3 :: ByteArray#) -> case _#_ integer2Int# [] [u1, u2, u3] of { _PRIM_ (u4 :: Int#) -> _!_ I# [] [u4] }; _NO_DEFLT_ } _N_ #-}
+ quot = { _A_ 2 _U_ 11 _N_ _S_ "U(PPP)U(PPP)" {_A_ 4 _U_ 2221 _N_ _N_ _F_ _IF_ARGS_ 0 4 XXXX 7 \ (u0 :: Int#) (u1 :: Int#) (u2 :: ByteArray#) (u3 :: Integer) -> case _APP_ _WRKR_ _CONSTM_ Integral quotRem (Integer) [ u0, u1, u2, u3 ] of { _ALG_ _TUP_2 (u4 :: Integer) (u5 :: Integer) -> u4; _NO_DEFLT_ } _N_} _F_ _IF_ARGS_ 0 2 XX 5 \ (u0 :: Integer) (u1 :: Integer) -> case _APP_ _CONSTM_ Integral quotRem (Integer) [ u0, u1 ] of { _ALG_ _TUP_2 (u2 :: Integer) (u3 :: Integer) -> u2; _NO_DEFLT_ } _N_ },
+ rem = { _A_ 2 _U_ 11 _N_ _S_ "U(PPP)U(PPP)" {_A_ 4 _U_ 2221 _N_ _N_ _F_ _IF_ARGS_ 0 4 XXXX 7 \ (u0 :: Int#) (u1 :: Int#) (u2 :: ByteArray#) (u3 :: Integer) -> case _APP_ _WRKR_ _CONSTM_ Integral quotRem (Integer) [ u0, u1, u2, u3 ] of { _ALG_ _TUP_2 (u4 :: Integer) (u5 :: Integer) -> u5; _NO_DEFLT_ } _N_} _F_ _IF_ARGS_ 0 2 XX 5 \ (u0 :: Integer) (u1 :: Integer) -> case _APP_ _CONSTM_ Integral quotRem (Integer) [ u0, u1 ] of { _ALG_ _TUP_2 (u2 :: Integer) (u3 :: Integer) -> u3; _NO_DEFLT_ } _N_ },
+ div = { _A_ 2 _U_ 12 _N_ _S_ "U(PPP)U(PPP)" {_A_ 4 _U_ 2222 _N_ _N_ _F_ _IF_ARGS_ 0 4 XXXX 7 \ (u0 :: Int#) (u1 :: Int#) (u2 :: ByteArray#) (u3 :: Integer) -> case _APP_ _WRKR_ _CONSTM_ Integral divMod (Integer) [ u0, u1, u2, u3 ] of { _ALG_ _TUP_2 (u4 :: Integer) (u5 :: Integer) -> u4; _NO_DEFLT_ } _N_} _F_ _IF_ARGS_ 0 2 XX 5 \ (u0 :: Integer) (u1 :: Integer) -> case _APP_ _CONSTM_ Integral divMod (Integer) [ u0, u1 ] of { _ALG_ _TUP_2 (u2 :: Integer) (u3 :: Integer) -> u2; _NO_DEFLT_ } _N_ },
+ mod = { _A_ 2 _U_ 12 _N_ _S_ "U(PPP)U(PPP)" {_A_ 4 _U_ 2222 _N_ _N_ _F_ _IF_ARGS_ 0 4 XXXX 7 \ (u0 :: Int#) (u1 :: Int#) (u2 :: ByteArray#) (u3 :: Integer) -> case _APP_ _WRKR_ _CONSTM_ Integral divMod (Integer) [ u0, u1, u2, u3 ] of { _ALG_ _TUP_2 (u4 :: Integer) (u5 :: Integer) -> u5; _NO_DEFLT_ } _N_} _F_ _IF_ARGS_ 0 2 XX 5 \ (u0 :: Integer) (u1 :: Integer) -> case _APP_ _CONSTM_ Integral divMod (Integer) [ u0, u1 ] of { _ALG_ _TUP_2 (u2 :: Integer) (u3 :: Integer) -> u3; _NO_DEFLT_ } _N_ },
+ quotRem = { _A_ 2 _U_ 11 _N_ _S_ "U(PPP)U(PPP)" {_A_ 4 _U_ 2221 _N_ _N_ _N_ _N_} _N_ _N_ },
+ divMod = { _A_ 2 _U_ 12 _N_ _S_ "U(PPP)U(PPP)" {_A_ 4 _U_ 2222 _N_ _N_ _N_ _N_} _N_ _N_ },
+ even = { _A_ 1 _U_ 1 _N_ _S_ "U(PPP)" {_A_ 3 _U_ 222 _N_ _N_ _N_ _N_} _N_ _N_ },
+ odd = { _A_ 1 _U_ 1 _N_ _S_ "U(PPP)" {_A_ 3 _U_ 222 _N_ _N_ _N_ _N_} _N_ _N_ },
+ toInteger = { _A_ 1 _U_ 1 _N_ _S_ "U(PPP)" {_A_ 3 _U_ 222 _N_ _N_ _F_ _IF_ARGS_ 0 3 XXX 4 \ (u0 :: Int#) (u1 :: Int#) (u2 :: ByteArray#) -> _!_ J# [] [u0, u1, u2] _N_} _F_ _IF_ARGS_ 0 1 X 1 \ (u0 :: Integer) -> u0 _N_ },
+ toInt = { _A_ 1 _U_ 1 _N_ _S_ "U(PPP)" {_A_ 3 _U_ 222 _N_ _N_ _F_ _IF_ARGS_ 0 3 XXX 3 \ (u0 :: Int#) (u1 :: Int#) (u2 :: ByteArray#) -> case _#_ integer2Int# [] [u0, u1, u2] of { _PRIM_ (u3 :: Int#) -> _!_ I# [] [u3] } _N_} _F_ _IF_ARGS_ 0 1 C 4 \ (u0 :: Integer) -> case u0 of { _ALG_ J# (u1 :: Int#) (u2 :: Int#) (u3 :: ByteArray#) -> case _#_ integer2Int# [] [u1, u2, u3] of { _PRIM_ (u4 :: Int#) -> _!_ I# [] [u4] }; _NO_DEFLT_ } _N_ } #-}
instance Ix ()
{-# GHC_PRAGMA _M_ PreludeBuiltin {-dfun-} _A_ 0 _N_ _N_ _N_ _F_ _IF_ARGS_ 0 0 X 5 _!_ _TUP_4 [{{Ord ()}}, (((), ()) -> [()]), (((), ()) -> () -> Int), (((), ()) -> () -> Bool)] [_DFUN_ Ord (()), _CONSTM_ Ix range (()), _CONSTM_ Ix index (()), _CONSTM_ Ix inRange (())] _N_
- range = _A_ 1 _U_ 1 _N_ _S_ "U(EE)" {_A_ 2 _U_ 21 _N_ _N_ _N_ _N_} _N_ _N_,
- index = _A_ 2 _U_ 11 _N_ _S_ "U(EE)E" {_A_ 3 _U_ 111 _N_ _N_ _F_ _IF_ARGS_ 0 3 CCC 5 \ (u0 :: ()) (u1 :: ()) (u2 :: ()) -> case u0 of { _ALG_ _TUP_0 -> case u1 of { _ALG_ _TUP_0 -> case u2 of { _ALG_ _TUP_0 -> _!_ I# [] [0#]; _NO_DEFLT_ }; _NO_DEFLT_ }; _NO_DEFLT_ } _N_} _F_ _IF_ARGS_ 0 2 CC 6 \ (u0 :: ((), ())) (u1 :: ()) -> case u0 of { _ALG_ _TUP_2 (u2 :: ()) (u3 :: ()) -> case u2 of { _ALG_ _TUP_0 -> case u3 of { _ALG_ _TUP_0 -> case u1 of { _ALG_ _TUP_0 -> _!_ I# [] [0#]; _NO_DEFLT_ }; _NO_DEFLT_ }; _NO_DEFLT_ }; _NO_DEFLT_ } _N_,
- inRange = _A_ 2 _U_ 11 _N_ _S_ "U(EE)E" {_A_ 3 _U_ 111 _N_ _N_ _F_ _IF_ARGS_ 0 3 CCC 4 \ (u0 :: ()) (u1 :: ()) (u2 :: ()) -> case u0 of { _ALG_ _TUP_0 -> case u1 of { _ALG_ _TUP_0 -> case u2 of { _ALG_ _TUP_0 -> _!_ True [] []; _NO_DEFLT_ }; _NO_DEFLT_ }; _NO_DEFLT_ } _N_} _F_ _IF_ARGS_ 0 2 CC 5 \ (u0 :: ((), ())) (u1 :: ()) -> case u0 of { _ALG_ _TUP_2 (u2 :: ()) (u3 :: ()) -> case u2 of { _ALG_ _TUP_0 -> case u3 of { _ALG_ _TUP_0 -> case u1 of { _ALG_ _TUP_0 -> _!_ True [] []; _NO_DEFLT_ }; _NO_DEFLT_ }; _NO_DEFLT_ }; _NO_DEFLT_ } _N_ #-}
+ range = { _A_ 1 _U_ 1 _N_ _S_ "U(EE)" {_A_ 2 _U_ 21 _N_ _N_ _N_ _N_} _N_ _N_ },
+ index = { _A_ 2 _U_ 11 _N_ _S_ "U(EE)E" {_A_ 3 _U_ 111 _N_ _N_ _F_ _IF_ARGS_ 0 3 CCC 5 \ (u0 :: ()) (u1 :: ()) (u2 :: ()) -> case u0 of { _ALG_ _TUP_0 -> case u1 of { _ALG_ _TUP_0 -> case u2 of { _ALG_ _TUP_0 -> _!_ I# [] [0#]; _NO_DEFLT_ }; _NO_DEFLT_ }; _NO_DEFLT_ } _N_} _F_ _IF_ARGS_ 0 2 CC 6 \ (u0 :: ((), ())) (u1 :: ()) -> case u0 of { _ALG_ _TUP_2 (u2 :: ()) (u3 :: ()) -> case u2 of { _ALG_ _TUP_0 -> case u3 of { _ALG_ _TUP_0 -> case u1 of { _ALG_ _TUP_0 -> _!_ I# [] [0#]; _NO_DEFLT_ }; _NO_DEFLT_ }; _NO_DEFLT_ }; _NO_DEFLT_ } _N_ },
+ inRange = { _A_ 2 _U_ 11 _N_ _S_ "U(EE)E" {_A_ 3 _U_ 111 _N_ _N_ _F_ _IF_ARGS_ 0 3 CCC 4 \ (u0 :: ()) (u1 :: ()) (u2 :: ()) -> case u0 of { _ALG_ _TUP_0 -> case u1 of { _ALG_ _TUP_0 -> case u2 of { _ALG_ _TUP_0 -> _!_ True [] []; _NO_DEFLT_ }; _NO_DEFLT_ }; _NO_DEFLT_ } _N_} _F_ _IF_ARGS_ 0 2 CC 5 \ (u0 :: ((), ())) (u1 :: ()) -> case u0 of { _ALG_ _TUP_2 (u2 :: ()) (u3 :: ()) -> case u2 of { _ALG_ _TUP_0 -> case u3 of { _ALG_ _TUP_0 -> case u1 of { _ALG_ _TUP_0 -> _!_ True [] []; _NO_DEFLT_ }; _NO_DEFLT_ }; _NO_DEFLT_ }; _NO_DEFLT_ } _N_ } #-}
instance (Ix a, Ix b) => Ix (a, b)
{-# GHC_PRAGMA _M_ PreludeBuiltin {-dfun-} _A_ 3 _U_ 222 _N_ _N_ _N_ _N_ #-}
instance (Ix a, Ix b, Ix c) => Ix (a, b, c)
{-# GHC_PRAGMA _M_ PreludeBuiltin {-dfun-} _A_ 6 _U_ 222222 _N_ _N_ _N_ _N_ #-}
instance Ix (Int, Int)
{-# GHC_PRAGMA _M_ PreludeBuiltin {-dfun-} _A_ 0 _N_ _N_ _N_ _F_ _IF_ARGS_ 0 0 X 5 _!_ _TUP_4 [{{Ord (Int, Int)}}, (((Int, Int), (Int, Int)) -> [(Int, Int)]), (((Int, Int), (Int, Int)) -> (Int, Int) -> Int), (((Int, Int), (Int, Int)) -> (Int, Int) -> Bool)] [_DFUN_ Ord ((Int, Int)), _CONSTM_ Ix range ((Int, Int)), _CONSTM_ Ix index ((Int, Int)), _CONSTM_ Ix inRange ((Int, Int))] _N_
- range = _A_ 1 _U_ 1 _N_ _S_ "U(SS)" {_A_ 2 _U_ 11 _N_ _N_ _N_ _N_} _N_ _N_,
- index = _A_ 2 _U_ 11 _N_ _S_ "U(SS)U(U(P)U(P))" {_A_ 4 _U_ 1122 _N_ _N_ _N_ _N_} _N_ _N_,
- inRange = _A_ 2 _U_ 11 _N_ _S_ "U(SS)U(U(P)L)" {_A_ 4 _U_ 1121 _N_ _N_ _N_ _N_} _N_ _N_ #-}
+ range = { _A_ 1 _U_ 1 _N_ _S_ "U(SS)" {_A_ 2 _U_ 11 _N_ _N_ _N_ _N_} _N_ _N_ },
+ index = { _A_ 2 _U_ 11 _N_ _S_ "U(SS)U(U(P)U(P))" {_A_ 4 _U_ 1122 _N_ _N_ _N_ _N_} _N_ _N_ },
+ inRange = { _A_ 2 _U_ 11 _N_ _S_ "U(SS)U(U(P)L)" {_A_ 4 _U_ 1121 _N_ _N_ _N_ _N_} _N_ _N_ } #-}
instance (Ix a, Ix b) => Ix (Assoc a b)
{-# GHC_PRAGMA _M_ PreludeArray {-dfun-} _A_ 3 _U_ 222 _N_ _N_ _N_ _N_ #-}
instance Ix Bool
{-# GHC_PRAGMA _M_ PreludeCore {-dfun-} _A_ 0 _N_ _N_ _N_ _F_ _IF_ARGS_ 0 0 X 5 _!_ _TUP_4 [{{Ord Bool}}, ((Bool, Bool) -> [Bool]), ((Bool, Bool) -> Bool -> Int), ((Bool, Bool) -> Bool -> Bool)] [_DFUN_ Ord (Bool), _CONSTM_ Ix range (Bool), _CONSTM_ Ix index (Bool), _CONSTM_ Ix inRange (Bool)] _N_
- range = _A_ 1 _U_ 1 _N_ _S_ "U(EE)" {_A_ 2 _U_ 11 _N_ _N_ _N_ _N_} _N_ _N_,
- index = _A_ 2 _U_ 11 _N_ _S_ "U(EA)E" {_A_ 2 _U_ 11 _N_ _N_ _N_ _N_} _N_ _N_,
- inRange = _A_ 2 _U_ 12 _N_ _S_ "U(EL)E" {_A_ 3 _U_ 112 _N_ _N_ _N_ _N_} _N_ _N_ #-}
+ range = { _A_ 1 _U_ 1 _N_ _S_ "U(EE)" {_A_ 2 _U_ 11 _N_ _N_ _N_ _N_} _N_ _N_ },
+ index = { _A_ 2 _U_ 11 _N_ _S_ "U(EA)E" {_A_ 2 _U_ 11 _N_ _N_ _N_ _N_} _N_ _N_ },
+ inRange = { _A_ 2 _U_ 12 _N_ _S_ "U(EL)E" {_A_ 3 _U_ 112 _N_ _N_ _N_ _N_} _N_ _N_ } #-}
instance Ix Char
{-# GHC_PRAGMA _M_ PreludeCore {-dfun-} _A_ 0 _N_ _N_ _N_ _F_ _IF_ARGS_ 0 0 X 5 _!_ _TUP_4 [{{Ord Char}}, ((Char, Char) -> [Char]), ((Char, Char) -> Char -> Int), ((Char, Char) -> Char -> Bool)] [_DFUN_ Ord (Char), _CONSTM_ Ix range (Char), _CONSTM_ Ix index (Char), _CONSTM_ Ix inRange (Char)] _N_
- range = _A_ 1 _U_ 1 _N_ _S_ "U(LL)" {_A_ 2 _U_ 22 _N_ _N_ _F_ _IF_ARGS_ 0 0 X 1 _CONSTM_ Enum enumFromTo (Char) _N_} _F_ _IF_ARGS_ 0 1 C 4 \ (u0 :: (Char, Char)) -> case u0 of { _ALG_ _TUP_2 (u1 :: Char) (u2 :: Char) -> _APP_ _CONSTM_ Enum enumFromTo (Char) [ u1, u2 ]; _NO_DEFLT_ } _N_,
- index = _A_ 2 _U_ 11 _N_ _S_ "U(U(P)L)U(P)" {_A_ 3 _U_ 212 _N_ _N_ _N_ _N_} _N_ _N_,
- inRange = _A_ 2 _U_ 11 _N_ _S_ "U(U(P)L)U(P)" {_A_ 3 _U_ 212 _N_ _N_ _N_ _N_} _N_ _N_ #-}
+ range = { _A_ 1 _U_ 1 _N_ _S_ "U(U(P)L)" {_A_ 2 _U_ 22 _N_ _N_ _N_ _N_} _F_ _IF_ARGS_ 0 1 C 4 \ (u0 :: (Char, Char)) -> case u0 of { _ALG_ _TUP_2 (u1 :: Char) (u2 :: Char) -> _APP_ _CONSTM_ Enum enumFromTo (Char) [ u1, u2 ]; _NO_DEFLT_ } _N_ },
+ index = { _A_ 2 _U_ 11 _N_ _S_ "U(U(P)L)U(P)" {_A_ 3 _U_ 212 _N_ _N_ _N_ _N_} _N_ _N_ },
+ inRange = { _A_ 2 _U_ 11 _N_ _S_ "U(U(P)L)U(P)" {_A_ 3 _U_ 212 _N_ _N_ _N_ _N_} _N_ _N_ } #-}
instance Ix Int
{-# GHC_PRAGMA _M_ PreludeCore {-dfun-} _A_ 0 _N_ _N_ _N_ _F_ _IF_ARGS_ 0 0 X 5 _!_ _TUP_4 [{{Ord Int}}, ((Int, Int) -> [Int]), ((Int, Int) -> Int -> Int), ((Int, Int) -> Int -> Bool)] [_DFUN_ Ord (Int), _CONSTM_ Ix range (Int), _CONSTM_ Ix index (Int), _CONSTM_ Ix inRange (Int)] _N_
- range = _A_ 1 _U_ 1 _N_ _S_ "U(U(P)U(P))" {_A_ 2 _U_ 22 _N_ _N_ _N_ _N_} _N_ _N_,
- index = _A_ 2 _U_ 11 _N_ _S_ "U(U(P)U(P))U(P)" {_A_ 3 _U_ 222 _N_ _N_ _N_ _N_} _N_ _N_,
- inRange = _A_ 2 _U_ 11 _N_ _S_ "U(U(P)U(P))U(P)" {_A_ 3 _U_ 222 _N_ _N_ _F_ _IF_ARGS_ 0 3 XXX 5 \ (u0 :: Int#) (u1 :: Int#) (u2 :: Int#) -> case _#_ leInt# [] [u0, u2] of { _ALG_ True -> _#_ leInt# [] [u2, u1]; False -> _!_ False [] []; _NO_DEFLT_ } _N_} _F_ _ALWAYS_ \ (u0 :: (Int, Int)) (u1 :: Int) -> case u0 of { _ALG_ _TUP_2 (u2 :: Int) (u3 :: Int) -> case u2 of { _ALG_ I# (u4 :: Int#) -> case u3 of { _ALG_ I# (u5 :: Int#) -> case u1 of { _ALG_ I# (u6 :: Int#) -> case _#_ leInt# [] [u4, u6] of { _ALG_ True -> _#_ leInt# [] [u6, u5]; False -> _!_ False [] []; _NO_DEFLT_ }; _NO_DEFLT_ }; _NO_DEFLT_ }; _NO_DEFLT_ }; _NO_DEFLT_ } _N_ #-}
+ range = { _A_ 1 _U_ 1 _N_ _S_ "U(U(P)U(P))" {_A_ 2 _U_ 22 _N_ _N_ _N_ _N_} _N_ _N_ },
+ index = { _A_ 2 _U_ 11 _N_ _S_ "U(U(P)U(P))U(P)" {_A_ 3 _U_ 222 _N_ _N_ _N_ _N_} _N_ _N_ },
+ inRange = { _A_ 2 _U_ 11 _N_ _S_ "U(U(P)U(P))U(P)" {_A_ 3 _U_ 222 _N_ _N_ _F_ _IF_ARGS_ 0 3 XXX 5 \ (u0 :: Int#) (u1 :: Int#) (u2 :: Int#) -> case _#_ leInt# [] [u0, u2] of { _ALG_ True -> _#_ leInt# [] [u2, u1]; False -> _!_ False [] []; _NO_DEFLT_ } _N_} _F_ _ALWAYS_ \ (u0 :: (Int, Int)) (u1 :: Int) -> case u0 of { _ALG_ _TUP_2 (u2 :: Int) (u3 :: Int) -> case u2 of { _ALG_ I# (u4 :: Int#) -> case u3 of { _ALG_ I# (u5 :: Int#) -> case u1 of { _ALG_ I# (u6 :: Int#) -> case _#_ leInt# [] [u4, u6] of { _ALG_ True -> _#_ leInt# [] [u6, u5]; False -> _!_ False [] []; _NO_DEFLT_ }; _NO_DEFLT_ }; _NO_DEFLT_ }; _NO_DEFLT_ }; _NO_DEFLT_ } _N_ } #-}
instance Ix Integer
{-# GHC_PRAGMA _M_ PreludeCore {-dfun-} _A_ 0 _N_ _N_ _N_ _F_ _IF_ARGS_ 0 0 X 5 _!_ _TUP_4 [{{Ord Integer}}, ((Integer, Integer) -> [Integer]), ((Integer, Integer) -> Integer -> Int), ((Integer, Integer) -> Integer -> Bool)] [_DFUN_ Ord (Integer), _CONSTM_ Ix range (Integer), _CONSTM_ Ix index (Integer), _CONSTM_ Ix inRange (Integer)] _N_
- range = _A_ 1 _U_ 1 _N_ _S_ "U(LL)" {_A_ 2 _U_ 22 _N_ _N_ _F_ _IF_ARGS_ 0 0 X 1 _CONSTM_ Enum enumFromTo (Integer) _N_} _F_ _IF_ARGS_ 0 1 C 4 \ (u0 :: (Integer, Integer)) -> case u0 of { _ALG_ _TUP_2 (u1 :: Integer) (u2 :: Integer) -> _APP_ _CONSTM_ Enum enumFromTo (Integer) [ u1, u2 ]; _NO_DEFLT_ } _N_,
- index = _A_ 2 _U_ 12 _N_ _S_ "U(U(PPP)L)U(PPP)" {_A_ 5 _U_ 22222 _N_ _N_ _N_ _N_} _N_ _N_,
- inRange = _A_ 2 _U_ 11 _N_ _S_ "U(U(PPP)L)U(PPP)" {_A_ 5 _U_ 22211 _N_ _N_ _F_ _IF_ARGS_ 0 5 XXXCC 9 \ (u0 :: Int#) (u1 :: Int#) (u2 :: ByteArray#) (u3 :: Integer) (u4 :: Integer) -> case u4 of { _ALG_ J# (u5 :: Int#) (u6 :: Int#) (u7 :: ByteArray#) -> case _#_ cmpInteger# [] [u0, u1, u2, u5, u6, u7] of { _PRIM_ (u8 :: Int#) -> case _#_ leInt# [] [u8, 0#] of { _ALG_ True -> case u3 of { _ALG_ J# (u9 :: Int#) (ua :: Int#) (ub :: ByteArray#) -> case _#_ cmpInteger# [] [u5, u6, u7, u9, ua, ub] of { _PRIM_ (uc :: Int#) -> _#_ leInt# [] [uc, 0#] }; _NO_DEFLT_ }; False -> _!_ False [] []; _NO_DEFLT_ } }; _NO_DEFLT_ } _N_} _N_ _N_ #-}
+ range = { _A_ 1 _U_ 1 _N_ _S_ "U(LL)" {_A_ 2 _U_ 22 _N_ _N_ _F_ _IF_ARGS_ 0 0 X 1 _CONSTM_ Enum enumFromTo (Integer) _N_} _F_ _IF_ARGS_ 0 1 C 4 \ (u0 :: (Integer, Integer)) -> case u0 of { _ALG_ _TUP_2 (u1 :: Integer) (u2 :: Integer) -> _APP_ _CONSTM_ Enum enumFromTo (Integer) [ u1, u2 ]; _NO_DEFLT_ } _N_ },
+ index = { _A_ 2 _U_ 12 _N_ _S_ "U(U(PPP)L)U(PPP)" {_A_ 5 _U_ 22222 _N_ _N_ _N_ _N_} _N_ _N_ },
+ inRange = { _A_ 2 _U_ 11 _N_ _S_ "U(U(PPP)L)U(PPP)" {_A_ 5 _U_ 22211 _N_ _N_ _F_ _IF_ARGS_ 0 5 XXXCC 9 \ (u0 :: Int#) (u1 :: Int#) (u2 :: ByteArray#) (u3 :: Integer) (u4 :: Integer) -> case u4 of { _ALG_ J# (u5 :: Int#) (u6 :: Int#) (u7 :: ByteArray#) -> case _#_ cmpInteger# [] [u0, u1, u2, u5, u6, u7] of { _PRIM_ (u8 :: Int#) -> case _#_ leInt# [] [u8, 0#] of { _ALG_ True -> case u3 of { _ALG_ J# (u9 :: Int#) (ua :: Int#) (ub :: ByteArray#) -> case _#_ cmpInteger# [] [u5, u6, u7, u9, ua, ub] of { _PRIM_ (uc :: Int#) -> _#_ leInt# [] [uc, 0#] }; _NO_DEFLT_ }; False -> _!_ False [] []; _NO_DEFLT_ } }; _NO_DEFLT_ } _N_} _N_ _N_ } #-}
instance RealFloat a => Num (Complex a)
{-# GHC_PRAGMA _M_ PreludeComplex {-dfun-} _A_ 3 _U_ 222 _N_ _N_ _N_ _N_ #-}
instance Num (Complex Double)
- {-# GHC_PRAGMA _M_ PreludeComplex {-dfun-} _A_ 0 _N_ _N_ _N_ _N_ _N_
- (+) = _A_ 2 _U_ 11 _N_ _S_ "U(LL)U(LL)" {_A_ 4 _U_ 1111 _N_ _N_ _N_ _N_} _N_ _N_,
- (-) = _A_ 2 _U_ 11 _N_ _S_ "U(LL)U(LL)" {_A_ 4 _U_ 1111 _N_ _N_ _N_ _N_} _N_ _N_,
- (*) = _A_ 2 _U_ 11 _N_ _S_ "U(LL)U(LL)" {_A_ 4 _U_ 2222 _N_ _N_ _N_ _N_} _N_ _N_,
- negate = _A_ 1 _U_ 1 _N_ _S_ "U(LL)" {_A_ 2 _U_ 11 _N_ _N_ _N_ _N_} _N_ _N_,
- abs = _A_ 1 _U_ 1 _N_ _N_ _N_ _N_,
- signum = _A_ 1 _U_ 1 _N_ _S_ "U(U(P)L)" {_A_ 2 _U_ 22 _N_ _N_ _N_ _N_} _N_ _N_,
- fromInteger = _A_ 1 _U_ 1 _N_ _N_ _N_ _N_,
- fromInt = _A_ 1 _U_ 1 _N_ _N_ _N_ _N_ #-}
+ {-# GHC_PRAGMA _M_ PreludeComplex {-dfun-} _A_ 0 _N_ _N_ _N_ _F_ _IF_ARGS_ 0 0 X 11 _!_ _TUP_10 [{{Eq (Complex Double)}}, {{Text (Complex Double)}}, (Complex Double -> Complex Double -> Complex Double), (Complex Double -> Complex Double -> Complex Double), (Complex Double -> Complex Double -> Complex Double), (Complex Double -> Complex Double), (Complex Double -> Complex Double), (Complex Double -> Complex Double), (Integer -> Complex Double), (Int -> Complex Double)] [_DFUN_ Eq (Complex Double), _DFUN_ Text (Complex Double), _CONSTM_ Num (+) (Complex Double), _CONSTM_ Num (-) (Complex Double), _CONSTM_ Num (*) (Complex Double), _CONSTM_ Num negate (Complex Double), _CONSTM_ Num abs (Complex Double), _CONSTM_ Num signum (Complex Double), _CONSTM_ Num fromInteger (Complex Double), _CONSTM_ Num fromInt (Complex Double)] _N_
+ (+) = { _A_ 2 _U_ 11 _N_ _S_ "U(LL)U(LL)" {_A_ 4 _U_ 1111 _N_ _N_ _N_ _N_} _N_ _N_ },
+ (-) = { _A_ 2 _U_ 11 _N_ _S_ "U(LL)U(LL)" {_A_ 4 _U_ 1111 _N_ _N_ _N_ _N_} _N_ _N_ },
+ (*) = { _A_ 2 _U_ 11 _N_ _S_ "U(LL)U(LL)" {_A_ 4 _U_ 2222 _N_ _N_ _N_ _N_} _N_ _N_ },
+ negate = { _A_ 1 _U_ 1 _N_ _S_ "U(LL)" {_A_ 2 _U_ 11 _N_ _N_ _N_ _N_} _N_ _N_ },
+ abs = { _A_ 1 _U_ 1 _N_ _N_ _N_ _N_ },
+ signum = { _A_ 1 _U_ 1 _N_ _S_ "U(U(P)L)" {_A_ 2 _U_ 22 _N_ _N_ _N_ _N_} _N_ _N_ },
+ fromInteger = { _A_ 1 _U_ 1 _N_ _N_ _N_ _N_ },
+ fromInt = { _A_ 1 _U_ 1 _N_ _N_ _N_ _N_ } #-}
instance Num Double
{-# GHC_PRAGMA _M_ PreludeCore {-dfun-} _A_ 0 _N_ _N_ _N_ _F_ _IF_ARGS_ 0 0 X 11 _!_ _TUP_10 [{{Eq Double}}, {{Text Double}}, (Double -> Double -> Double), (Double -> Double -> Double), (Double -> Double -> Double), (Double -> Double), (Double -> Double), (Double -> Double), (Integer -> Double), (Int -> Double)] [_DFUN_ Eq (Double), _DFUN_ Text (Double), _CONSTM_ Num (+) (Double), _CONSTM_ Num (-) (Double), _CONSTM_ Num (*) (Double), _CONSTM_ Num negate (Double), _CONSTM_ Num abs (Double), _CONSTM_ Num signum (Double), _CONSTM_ Num fromInteger (Double), _CONSTM_ Num fromInt (Double)] _N_
- (+) = _A_ 2 _U_ 11 _N_ _S_ "U(P)U(P)" {_A_ 2 _U_ 22 _N_ _N_ _F_ _IF_ARGS_ 0 2 XX 3 \ (u0 :: Double#) (u1 :: Double#) -> case _#_ plusDouble# [] [u0, u1] of { _PRIM_ (u2 :: Double#) -> _!_ D# [] [u2] } _N_} _F_ _IF_ARGS_ 0 2 CC 5 \ (u0 :: Double) (u1 :: Double) -> case u0 of { _ALG_ D# (u2 :: Double#) -> case u1 of { _ALG_ D# (u3 :: Double#) -> case _#_ plusDouble# [] [u2, u3] of { _PRIM_ (u4 :: Double#) -> _!_ D# [] [u4] }; _NO_DEFLT_ }; _NO_DEFLT_ } _N_,
- (-) = _A_ 2 _U_ 11 _N_ _S_ "U(P)U(P)" {_A_ 2 _U_ 22 _N_ _N_ _F_ _IF_ARGS_ 0 2 XX 3 \ (u0 :: Double#) (u1 :: Double#) -> case _#_ minusDouble# [] [u0, u1] of { _PRIM_ (u2 :: Double#) -> _!_ D# [] [u2] } _N_} _F_ _IF_ARGS_ 0 2 CC 5 \ (u0 :: Double) (u1 :: Double) -> case u0 of { _ALG_ D# (u2 :: Double#) -> case u1 of { _ALG_ D# (u3 :: Double#) -> case _#_ minusDouble# [] [u2, u3] of { _PRIM_ (u4 :: Double#) -> _!_ D# [] [u4] }; _NO_DEFLT_ }; _NO_DEFLT_ } _N_,
- (*) = _A_ 2 _U_ 11 _N_ _S_ "U(P)U(P)" {_A_ 2 _U_ 22 _N_ _N_ _F_ _IF_ARGS_ 0 2 XX 3 \ (u0 :: Double#) (u1 :: Double#) -> case _#_ timesDouble# [] [u0, u1] of { _PRIM_ (u2 :: Double#) -> _!_ D# [] [u2] } _N_} _F_ _IF_ARGS_ 0 2 CC 5 \ (u0 :: Double) (u1 :: Double) -> case u0 of { _ALG_ D# (u2 :: Double#) -> case u1 of { _ALG_ D# (u3 :: Double#) -> case _#_ timesDouble# [] [u2, u3] of { _PRIM_ (u4 :: Double#) -> _!_ D# [] [u4] }; _NO_DEFLT_ }; _NO_DEFLT_ } _N_,
- negate = _A_ 1 _U_ 1 _N_ _S_ "U(P)" {_A_ 1 _U_ 2 _N_ _N_ _F_ _IF_ARGS_ 0 1 X 3 \ (u0 :: Double#) -> case _#_ negateDouble# [] [u0] of { _PRIM_ (u1 :: Double#) -> _!_ D# [] [u1] } _N_} _F_ _IF_ARGS_ 0 1 C 4 \ (u0 :: Double) -> case u0 of { _ALG_ D# (u1 :: Double#) -> case _#_ negateDouble# [] [u1] of { _PRIM_ (u2 :: Double#) -> _!_ D# [] [u2] }; _NO_DEFLT_ } _N_,
- abs = _A_ 1 _U_ 1 _N_ _S_ "U(P)" {_A_ 1 _U_ 2 _N_ _N_ _N_ _N_} _N_ _N_,
- signum = _A_ 1 _U_ 1 _N_ _S_ "U(P)" {_A_ 1 _U_ 2 _N_ _N_ _N_ _N_} _N_ _N_,
- fromInteger = _A_ 1 _U_ 1 _N_ _S_ "U(PPP)" {_A_ 3 _U_ 222 _N_ _N_ _F_ _IF_ARGS_ 0 3 XXX 3 \ (u0 :: Int#) (u1 :: Int#) (u2 :: ByteArray#) -> case _#_ encodeDouble# [] [u0, u1, u2, 0#] of { _PRIM_ (u3 :: Double#) -> _!_ D# [] [u3] } _N_} _F_ _IF_ARGS_ 0 1 C 4 \ (u0 :: Integer) -> case u0 of { _ALG_ J# (u1 :: Int#) (u2 :: Int#) (u3 :: ByteArray#) -> case _#_ encodeDouble# [] [u1, u2, u3, 0#] of { _PRIM_ (u4 :: Double#) -> _!_ D# [] [u4] }; _NO_DEFLT_ } _N_,
- fromInt = _A_ 1 _U_ 1 _N_ _S_ "U(P)" {_A_ 1 _U_ 2 _N_ _N_ _F_ _IF_ARGS_ 0 1 X 3 \ (u0 :: Int#) -> case _#_ int2Double# [] [u0] of { _PRIM_ (u1 :: Double#) -> _!_ D# [] [u1] } _N_} _F_ _IF_ARGS_ 0 1 C 4 \ (u0 :: Int) -> case u0 of { _ALG_ I# (u1 :: Int#) -> case _#_ int2Double# [] [u1] of { _PRIM_ (u2 :: Double#) -> _!_ D# [] [u2] }; _NO_DEFLT_ } _N_ #-}
+ (+) = { _A_ 2 _U_ 11 _N_ _S_ "U(P)U(P)" {_A_ 2 _U_ 22 _N_ _N_ _F_ _IF_ARGS_ 0 2 XX 3 \ (u0 :: Double#) (u1 :: Double#) -> case _#_ plusDouble# [] [u0, u1] of { _PRIM_ (u2 :: Double#) -> _!_ D# [] [u2] } _N_} _F_ _IF_ARGS_ 0 2 CC 5 \ (u0 :: Double) (u1 :: Double) -> case u0 of { _ALG_ D# (u2 :: Double#) -> case u1 of { _ALG_ D# (u3 :: Double#) -> case _#_ plusDouble# [] [u2, u3] of { _PRIM_ (u4 :: Double#) -> _!_ D# [] [u4] }; _NO_DEFLT_ }; _NO_DEFLT_ } _N_ },
+ (-) = { _A_ 2 _U_ 11 _N_ _S_ "U(P)U(P)" {_A_ 2 _U_ 22 _N_ _N_ _F_ _IF_ARGS_ 0 2 XX 3 \ (u0 :: Double#) (u1 :: Double#) -> case _#_ minusDouble# [] [u0, u1] of { _PRIM_ (u2 :: Double#) -> _!_ D# [] [u2] } _N_} _F_ _IF_ARGS_ 0 2 CC 5 \ (u0 :: Double) (u1 :: Double) -> case u0 of { _ALG_ D# (u2 :: Double#) -> case u1 of { _ALG_ D# (u3 :: Double#) -> case _#_ minusDouble# [] [u2, u3] of { _PRIM_ (u4 :: Double#) -> _!_ D# [] [u4] }; _NO_DEFLT_ }; _NO_DEFLT_ } _N_ },
+ (*) = { _A_ 2 _U_ 11 _N_ _S_ "U(P)U(P)" {_A_ 2 _U_ 22 _N_ _N_ _F_ _IF_ARGS_ 0 2 XX 3 \ (u0 :: Double#) (u1 :: Double#) -> case _#_ timesDouble# [] [u0, u1] of { _PRIM_ (u2 :: Double#) -> _!_ D# [] [u2] } _N_} _F_ _IF_ARGS_ 0 2 CC 5 \ (u0 :: Double) (u1 :: Double) -> case u0 of { _ALG_ D# (u2 :: Double#) -> case u1 of { _ALG_ D# (u3 :: Double#) -> case _#_ timesDouble# [] [u2, u3] of { _PRIM_ (u4 :: Double#) -> _!_ D# [] [u4] }; _NO_DEFLT_ }; _NO_DEFLT_ } _N_ },
+ negate = { _A_ 1 _U_ 1 _N_ _S_ "U(P)" {_A_ 1 _U_ 2 _N_ _N_ _F_ _IF_ARGS_ 0 1 X 3 \ (u0 :: Double#) -> case _#_ negateDouble# [] [u0] of { _PRIM_ (u1 :: Double#) -> _!_ D# [] [u1] } _N_} _F_ _IF_ARGS_ 0 1 C 4 \ (u0 :: Double) -> case u0 of { _ALG_ D# (u1 :: Double#) -> case _#_ negateDouble# [] [u1] of { _PRIM_ (u2 :: Double#) -> _!_ D# [] [u2] }; _NO_DEFLT_ } _N_ },
+ abs = { _A_ 1 _U_ 1 _N_ _S_ "U(P)" {_A_ 1 _U_ 2 _N_ _N_ _N_ _N_} _N_ _N_ },
+ signum = { _A_ 1 _U_ 1 _N_ _S_ "U(P)" {_A_ 1 _U_ 2 _N_ _N_ _N_ _N_} _N_ _N_ },
+ fromInteger = { _A_ 1 _U_ 1 _N_ _S_ "U(PPP)" {_A_ 3 _U_ 222 _N_ _N_ _F_ _IF_ARGS_ 0 3 XXX 3 \ (u0 :: Int#) (u1 :: Int#) (u2 :: ByteArray#) -> case _#_ encodeDouble# [] [u0, u1, u2, 0#] of { _PRIM_ (u3 :: Double#) -> _!_ D# [] [u3] } _N_} _F_ _IF_ARGS_ 0 1 C 4 \ (u0 :: Integer) -> case u0 of { _ALG_ J# (u1 :: Int#) (u2 :: Int#) (u3 :: ByteArray#) -> case _#_ encodeDouble# [] [u1, u2, u3, 0#] of { _PRIM_ (u4 :: Double#) -> _!_ D# [] [u4] }; _NO_DEFLT_ } _N_ },
+ fromInt = { _A_ 1 _U_ 1 _N_ _S_ "U(P)" {_A_ 1 _U_ 2 _N_ _N_ _F_ _IF_ARGS_ 0 1 X 3 \ (u0 :: Int#) -> case _#_ int2Double# [] [u0] of { _PRIM_ (u1 :: Double#) -> _!_ D# [] [u1] } _N_} _F_ _IF_ARGS_ 0 1 C 4 \ (u0 :: Int) -> case u0 of { _ALG_ I# (u1 :: Int#) -> case _#_ int2Double# [] [u1] of { _PRIM_ (u2 :: Double#) -> _!_ D# [] [u2] }; _NO_DEFLT_ } _N_ } #-}
instance Num Float
{-# GHC_PRAGMA _M_ PreludeCore {-dfun-} _A_ 0 _N_ _N_ _N_ _F_ _IF_ARGS_ 0 0 X 11 _!_ _TUP_10 [{{Eq Float}}, {{Text Float}}, (Float -> Float -> Float), (Float -> Float -> Float), (Float -> Float -> Float), (Float -> Float), (Float -> Float), (Float -> Float), (Integer -> Float), (Int -> Float)] [_DFUN_ Eq (Float), _DFUN_ Text (Float), _CONSTM_ Num (+) (Float), _CONSTM_ Num (-) (Float), _CONSTM_ Num (*) (Float), _CONSTM_ Num negate (Float), _CONSTM_ Num abs (Float), _CONSTM_ Num signum (Float), _CONSTM_ Num fromInteger (Float), _CONSTM_ Num fromInt (Float)] _N_
- (+) = _A_ 2 _U_ 11 _N_ _S_ "U(P)U(P)" {_A_ 2 _U_ 22 _N_ _N_ _F_ _IF_ARGS_ 0 2 XX 3 \ (u0 :: Float#) (u1 :: Float#) -> case _#_ plusFloat# [] [u0, u1] of { _PRIM_ (u2 :: Float#) -> _!_ F# [] [u2] } _N_} _F_ _IF_ARGS_ 0 2 CC 5 \ (u0 :: Float) (u1 :: Float) -> case u0 of { _ALG_ F# (u2 :: Float#) -> case u1 of { _ALG_ F# (u3 :: Float#) -> case _#_ plusFloat# [] [u2, u3] of { _PRIM_ (u4 :: Float#) -> _!_ F# [] [u4] }; _NO_DEFLT_ }; _NO_DEFLT_ } _N_,
- (-) = _A_ 2 _U_ 11 _N_ _S_ "U(P)U(P)" {_A_ 2 _U_ 22 _N_ _N_ _F_ _IF_ARGS_ 0 2 XX 3 \ (u0 :: Float#) (u1 :: Float#) -> case _#_ minusFloat# [] [u0, u1] of { _PRIM_ (u2 :: Float#) -> _!_ F# [] [u2] } _N_} _F_ _IF_ARGS_ 0 2 CC 5 \ (u0 :: Float) (u1 :: Float) -> case u0 of { _ALG_ F# (u2 :: Float#) -> case u1 of { _ALG_ F# (u3 :: Float#) -> case _#_ minusFloat# [] [u2, u3] of { _PRIM_ (u4 :: Float#) -> _!_ F# [] [u4] }; _NO_DEFLT_ }; _NO_DEFLT_ } _N_,
- (*) = _A_ 2 _U_ 11 _N_ _S_ "U(P)U(P)" {_A_ 2 _U_ 22 _N_ _N_ _F_ _IF_ARGS_ 0 2 XX 3 \ (u0 :: Float#) (u1 :: Float#) -> case _#_ timesFloat# [] [u0, u1] of { _PRIM_ (u2 :: Float#) -> _!_ F# [] [u2] } _N_} _F_ _IF_ARGS_ 0 2 CC 5 \ (u0 :: Float) (u1 :: Float) -> case u0 of { _ALG_ F# (u2 :: Float#) -> case u1 of { _ALG_ F# (u3 :: Float#) -> case _#_ timesFloat# [] [u2, u3] of { _PRIM_ (u4 :: Float#) -> _!_ F# [] [u4] }; _NO_DEFLT_ }; _NO_DEFLT_ } _N_,
- negate = _A_ 1 _U_ 1 _N_ _S_ "U(P)" {_A_ 1 _U_ 2 _N_ _N_ _F_ _IF_ARGS_ 0 1 X 3 \ (u0 :: Float#) -> case _#_ negateFloat# [] [u0] of { _PRIM_ (u1 :: Float#) -> _!_ F# [] [u1] } _N_} _F_ _IF_ARGS_ 0 1 C 4 \ (u0 :: Float) -> case u0 of { _ALG_ F# (u1 :: Float#) -> case _#_ negateFloat# [] [u1] of { _PRIM_ (u2 :: Float#) -> _!_ F# [] [u2] }; _NO_DEFLT_ } _N_,
- abs = _A_ 1 _U_ 1 _N_ _S_ "U(P)" {_A_ 1 _U_ 2 _N_ _N_ _N_ _N_} _N_ _N_,
- signum = _A_ 1 _U_ 1 _N_ _S_ "U(P)" {_A_ 1 _U_ 2 _N_ _N_ _N_ _N_} _N_ _N_,
- fromInteger = _A_ 1 _U_ 1 _N_ _S_ "U(PPP)" {_A_ 3 _U_ 222 _N_ _N_ _F_ _IF_ARGS_ 0 3 XXX 3 \ (u0 :: Int#) (u1 :: Int#) (u2 :: ByteArray#) -> case _#_ encodeFloat# [] [u0, u1, u2, 0#] of { _PRIM_ (u3 :: Float#) -> _!_ F# [] [u3] } _N_} _F_ _IF_ARGS_ 0 1 C 4 \ (u0 :: Integer) -> case u0 of { _ALG_ J# (u1 :: Int#) (u2 :: Int#) (u3 :: ByteArray#) -> case _#_ encodeFloat# [] [u1, u2, u3, 0#] of { _PRIM_ (u4 :: Float#) -> _!_ F# [] [u4] }; _NO_DEFLT_ } _N_,
- fromInt = _A_ 1 _U_ 1 _N_ _S_ "U(P)" {_A_ 1 _U_ 2 _N_ _N_ _F_ _IF_ARGS_ 0 1 X 3 \ (u0 :: Int#) -> case _#_ int2Float# [] [u0] of { _PRIM_ (u1 :: Float#) -> _!_ F# [] [u1] } _N_} _F_ _IF_ARGS_ 0 1 C 4 \ (u0 :: Int) -> case u0 of { _ALG_ I# (u1 :: Int#) -> case _#_ int2Float# [] [u1] of { _PRIM_ (u2 :: Float#) -> _!_ F# [] [u2] }; _NO_DEFLT_ } _N_ #-}
+ (+) = { _A_ 2 _U_ 11 _N_ _S_ "U(P)U(P)" {_A_ 2 _U_ 22 _N_ _N_ _F_ _IF_ARGS_ 0 2 XX 3 \ (u0 :: Float#) (u1 :: Float#) -> case _#_ plusFloat# [] [u0, u1] of { _PRIM_ (u2 :: Float#) -> _!_ F# [] [u2] } _N_} _F_ _IF_ARGS_ 0 2 CC 5 \ (u0 :: Float) (u1 :: Float) -> case u0 of { _ALG_ F# (u2 :: Float#) -> case u1 of { _ALG_ F# (u3 :: Float#) -> case _#_ plusFloat# [] [u2, u3] of { _PRIM_ (u4 :: Float#) -> _!_ F# [] [u4] }; _NO_DEFLT_ }; _NO_DEFLT_ } _N_ },
+ (-) = { _A_ 2 _U_ 11 _N_ _S_ "U(P)U(P)" {_A_ 2 _U_ 22 _N_ _N_ _F_ _IF_ARGS_ 0 2 XX 3 \ (u0 :: Float#) (u1 :: Float#) -> case _#_ minusFloat# [] [u0, u1] of { _PRIM_ (u2 :: Float#) -> _!_ F# [] [u2] } _N_} _F_ _IF_ARGS_ 0 2 CC 5 \ (u0 :: Float) (u1 :: Float) -> case u0 of { _ALG_ F# (u2 :: Float#) -> case u1 of { _ALG_ F# (u3 :: Float#) -> case _#_ minusFloat# [] [u2, u3] of { _PRIM_ (u4 :: Float#) -> _!_ F# [] [u4] }; _NO_DEFLT_ }; _NO_DEFLT_ } _N_ },
+ (*) = { _A_ 2 _U_ 11 _N_ _S_ "U(P)U(P)" {_A_ 2 _U_ 22 _N_ _N_ _F_ _IF_ARGS_ 0 2 XX 3 \ (u0 :: Float#) (u1 :: Float#) -> case _#_ timesFloat# [] [u0, u1] of { _PRIM_ (u2 :: Float#) -> _!_ F# [] [u2] } _N_} _F_ _IF_ARGS_ 0 2 CC 5 \ (u0 :: Float) (u1 :: Float) -> case u0 of { _ALG_ F# (u2 :: Float#) -> case u1 of { _ALG_ F# (u3 :: Float#) -> case _#_ timesFloat# [] [u2, u3] of { _PRIM_ (u4 :: Float#) -> _!_ F# [] [u4] }; _NO_DEFLT_ }; _NO_DEFLT_ } _N_ },
+ negate = { _A_ 1 _U_ 1 _N_ _S_ "U(P)" {_A_ 1 _U_ 2 _N_ _N_ _F_ _IF_ARGS_ 0 1 X 3 \ (u0 :: Float#) -> case _#_ negateFloat# [] [u0] of { _PRIM_ (u1 :: Float#) -> _!_ F# [] [u1] } _N_} _F_ _IF_ARGS_ 0 1 C 4 \ (u0 :: Float) -> case u0 of { _ALG_ F# (u1 :: Float#) -> case _#_ negateFloat# [] [u1] of { _PRIM_ (u2 :: Float#) -> _!_ F# [] [u2] }; _NO_DEFLT_ } _N_ },
+ abs = { _A_ 1 _U_ 1 _N_ _S_ "U(P)" {_A_ 1 _U_ 2 _N_ _N_ _N_ _N_} _N_ _N_ },
+ signum = { _A_ 1 _U_ 1 _N_ _S_ "U(P)" {_A_ 1 _U_ 2 _N_ _N_ _N_ _N_} _N_ _N_ },
+ fromInteger = { _A_ 1 _U_ 1 _N_ _S_ "U(PPP)" {_A_ 3 _U_ 222 _N_ _N_ _F_ _IF_ARGS_ 0 3 XXX 3 \ (u0 :: Int#) (u1 :: Int#) (u2 :: ByteArray#) -> case _#_ encodeFloat# [] [u0, u1, u2, 0#] of { _PRIM_ (u3 :: Float#) -> _!_ F# [] [u3] } _N_} _F_ _IF_ARGS_ 0 1 C 4 \ (u0 :: Integer) -> case u0 of { _ALG_ J# (u1 :: Int#) (u2 :: Int#) (u3 :: ByteArray#) -> case _#_ encodeFloat# [] [u1, u2, u3, 0#] of { _PRIM_ (u4 :: Float#) -> _!_ F# [] [u4] }; _NO_DEFLT_ } _N_ },
+ fromInt = { _A_ 1 _U_ 1 _N_ _S_ "U(P)" {_A_ 1 _U_ 2 _N_ _N_ _F_ _IF_ARGS_ 0 1 X 3 \ (u0 :: Int#) -> case _#_ int2Float# [] [u0] of { _PRIM_ (u1 :: Float#) -> _!_ F# [] [u1] } _N_} _F_ _IF_ARGS_ 0 1 C 4 \ (u0 :: Int) -> case u0 of { _ALG_ I# (u1 :: Int#) -> case _#_ int2Float# [] [u1] of { _PRIM_ (u2 :: Float#) -> _!_ F# [] [u2] }; _NO_DEFLT_ } _N_ } #-}
instance Num Int
{-# GHC_PRAGMA _M_ PreludeCore {-dfun-} _A_ 0 _N_ _N_ _N_ _F_ _IF_ARGS_ 0 0 X 11 _!_ _TUP_10 [{{Eq Int}}, {{Text Int}}, (Int -> Int -> Int), (Int -> Int -> Int), (Int -> Int -> Int), (Int -> Int), (Int -> Int), (Int -> Int), (Integer -> Int), (Int -> Int)] [_DFUN_ Eq (Int), _DFUN_ Text (Int), _CONSTM_ Num (+) (Int), _CONSTM_ Num (-) (Int), _CONSTM_ Num (*) (Int), _CONSTM_ Num negate (Int), _CONSTM_ Num abs (Int), _CONSTM_ Num signum (Int), _CONSTM_ Num fromInteger (Int), _CONSTM_ Num fromInt (Int)] _N_
- (+) = _A_ 2 _U_ 11 _N_ _S_ "U(P)U(P)" {_A_ 2 _U_ 22 _N_ _N_ _F_ _IF_ARGS_ 0 2 XX 3 \ (u0 :: Int#) (u1 :: Int#) -> case _#_ plusInt# [] [u0, u1] of { _PRIM_ (u2 :: Int#) -> _!_ I# [] [u2] } _N_} _F_ _IF_ARGS_ 0 2 CC 5 \ (u0 :: Int) (u1 :: Int) -> case u0 of { _ALG_ I# (u2 :: Int#) -> case u1 of { _ALG_ I# (u3 :: Int#) -> case _#_ plusInt# [] [u2, u3] of { _PRIM_ (u4 :: Int#) -> _!_ I# [] [u4] }; _NO_DEFLT_ }; _NO_DEFLT_ } _N_,
- (-) = _A_ 2 _U_ 11 _N_ _S_ "U(P)U(P)" {_A_ 2 _U_ 22 _N_ _N_ _F_ _IF_ARGS_ 0 2 XX 3 \ (u0 :: Int#) (u1 :: Int#) -> case _#_ minusInt# [] [u0, u1] of { _PRIM_ (u2 :: Int#) -> _!_ I# [] [u2] } _N_} _F_ _IF_ARGS_ 0 2 CC 5 \ (u0 :: Int) (u1 :: Int) -> case u0 of { _ALG_ I# (u2 :: Int#) -> case u1 of { _ALG_ I# (u3 :: Int#) -> case _#_ minusInt# [] [u2, u3] of { _PRIM_ (u4 :: Int#) -> _!_ I# [] [u4] }; _NO_DEFLT_ }; _NO_DEFLT_ } _N_,
- (*) = _A_ 2 _U_ 11 _N_ _S_ "U(P)U(P)" {_A_ 2 _U_ 22 _N_ _N_ _F_ _IF_ARGS_ 0 2 XX 3 \ (u0 :: Int#) (u1 :: Int#) -> case _#_ timesInt# [] [u0, u1] of { _PRIM_ (u2 :: Int#) -> _!_ I# [] [u2] } _N_} _F_ _IF_ARGS_ 0 2 CC 5 \ (u0 :: Int) (u1 :: Int) -> case u0 of { _ALG_ I# (u2 :: Int#) -> case u1 of { _ALG_ I# (u3 :: Int#) -> case _#_ timesInt# [] [u2, u3] of { _PRIM_ (u4 :: Int#) -> _!_ I# [] [u4] }; _NO_DEFLT_ }; _NO_DEFLT_ } _N_,
- negate = _A_ 1 _U_ 1 _N_ _S_ "U(P)" {_A_ 1 _U_ 2 _N_ _N_ _F_ _IF_ARGS_ 0 1 X 3 \ (u0 :: Int#) -> case _#_ negateInt# [] [u0] of { _PRIM_ (u1 :: Int#) -> _!_ I# [] [u1] } _N_} _F_ _IF_ARGS_ 0 1 C 4 \ (u0 :: Int) -> case u0 of { _ALG_ I# (u1 :: Int#) -> case _#_ negateInt# [] [u1] of { _PRIM_ (u2 :: Int#) -> _!_ I# [] [u2] }; _NO_DEFLT_ } _N_,
- abs = _A_ 1 _U_ 1 _N_ _S_ "U(P)" {_A_ 1 _U_ 2 _N_ _N_ _N_ _N_} _N_ _N_,
- signum = _A_ 1 _U_ 1 _N_ _S_ "U(P)" {_A_ 1 _U_ 2 _N_ _N_ _N_ _N_} _N_ _N_,
- fromInteger = _A_ 1 _U_ 1 _N_ _S_ "U(PPP)" {_A_ 3 _U_ 222 _N_ _N_ _F_ _IF_ARGS_ 0 3 XXX 3 \ (u0 :: Int#) (u1 :: Int#) (u2 :: ByteArray#) -> case _#_ integer2Int# [] [u0, u1, u2] of { _PRIM_ (u3 :: Int#) -> _!_ I# [] [u3] } _N_} _F_ _IF_ARGS_ 0 1 C 4 \ (u0 :: Integer) -> case u0 of { _ALG_ J# (u1 :: Int#) (u2 :: Int#) (u3 :: ByteArray#) -> case _#_ integer2Int# [] [u1, u2, u3] of { _PRIM_ (u4 :: Int#) -> _!_ I# [] [u4] }; _NO_DEFLT_ } _N_,
- fromInt = _A_ 1 _U_ 1 _N_ _S_ "U(P)" {_A_ 1 _U_ 2 _N_ _N_ _F_ _IF_ARGS_ 0 1 X 2 \ (u0 :: Int#) -> _!_ I# [] [u0] _N_} _F_ _IF_ARGS_ 0 1 X 1 \ (u0 :: Int) -> u0 _N_ #-}
+ (+) = { _A_ 2 _U_ 11 _N_ _S_ "U(P)U(P)" {_A_ 2 _U_ 22 _N_ _N_ _F_ _IF_ARGS_ 0 2 XX 3 \ (u0 :: Int#) (u1 :: Int#) -> case _#_ plusInt# [] [u0, u1] of { _PRIM_ (u2 :: Int#) -> _!_ I# [] [u2] } _N_} _F_ _IF_ARGS_ 0 2 CC 5 \ (u0 :: Int) (u1 :: Int) -> case u0 of { _ALG_ I# (u2 :: Int#) -> case u1 of { _ALG_ I# (u3 :: Int#) -> case _#_ plusInt# [] [u2, u3] of { _PRIM_ (u4 :: Int#) -> _!_ I# [] [u4] }; _NO_DEFLT_ }; _NO_DEFLT_ } _N_ },
+ (-) = { _A_ 2 _U_ 11 _N_ _S_ "U(P)U(P)" {_A_ 2 _U_ 22 _N_ _N_ _F_ _IF_ARGS_ 0 2 XX 3 \ (u0 :: Int#) (u1 :: Int#) -> case _#_ minusInt# [] [u0, u1] of { _PRIM_ (u2 :: Int#) -> _!_ I# [] [u2] } _N_} _F_ _IF_ARGS_ 0 2 CC 5 \ (u0 :: Int) (u1 :: Int) -> case u0 of { _ALG_ I# (u2 :: Int#) -> case u1 of { _ALG_ I# (u3 :: Int#) -> case _#_ minusInt# [] [u2, u3] of { _PRIM_ (u4 :: Int#) -> _!_ I# [] [u4] }; _NO_DEFLT_ }; _NO_DEFLT_ } _N_ },
+ (*) = { _A_ 2 _U_ 11 _N_ _S_ "U(P)U(P)" {_A_ 2 _U_ 22 _N_ _N_ _F_ _IF_ARGS_ 0 2 XX 3 \ (u0 :: Int#) (u1 :: Int#) -> case _#_ timesInt# [] [u0, u1] of { _PRIM_ (u2 :: Int#) -> _!_ I# [] [u2] } _N_} _F_ _IF_ARGS_ 0 2 CC 5 \ (u0 :: Int) (u1 :: Int) -> case u0 of { _ALG_ I# (u2 :: Int#) -> case u1 of { _ALG_ I# (u3 :: Int#) -> case _#_ timesInt# [] [u2, u3] of { _PRIM_ (u4 :: Int#) -> _!_ I# [] [u4] }; _NO_DEFLT_ }; _NO_DEFLT_ } _N_ },
+ negate = { _A_ 1 _U_ 1 _N_ _S_ "U(P)" {_A_ 1 _U_ 2 _N_ _N_ _F_ _IF_ARGS_ 0 1 X 3 \ (u0 :: Int#) -> case _#_ negateInt# [] [u0] of { _PRIM_ (u1 :: Int#) -> _!_ I# [] [u1] } _N_} _F_ _IF_ARGS_ 0 1 C 4 \ (u0 :: Int) -> case u0 of { _ALG_ I# (u1 :: Int#) -> case _#_ negateInt# [] [u1] of { _PRIM_ (u2 :: Int#) -> _!_ I# [] [u2] }; _NO_DEFLT_ } _N_ },
+ abs = { _A_ 1 _U_ 1 _N_ _S_ "U(P)" {_A_ 1 _U_ 2 _N_ _N_ _N_ _N_} _N_ _N_ },
+ signum = { _A_ 1 _U_ 1 _N_ _S_ "U(P)" {_A_ 1 _U_ 2 _N_ _N_ _N_ _N_} _N_ _N_ },
+ fromInteger = { _A_ 1 _U_ 1 _N_ _S_ "U(PPP)" {_A_ 3 _U_ 222 _N_ _N_ _F_ _IF_ARGS_ 0 3 XXX 3 \ (u0 :: Int#) (u1 :: Int#) (u2 :: ByteArray#) -> case _#_ integer2Int# [] [u0, u1, u2] of { _PRIM_ (u3 :: Int#) -> _!_ I# [] [u3] } _N_} _F_ _IF_ARGS_ 0 1 C 4 \ (u0 :: Integer) -> case u0 of { _ALG_ J# (u1 :: Int#) (u2 :: Int#) (u3 :: ByteArray#) -> case _#_ integer2Int# [] [u1, u2, u3] of { _PRIM_ (u4 :: Int#) -> _!_ I# [] [u4] }; _NO_DEFLT_ } _N_ },
+ fromInt = { _A_ 1 _U_ 1 _N_ _S_ "U(P)" {_A_ 1 _U_ 2 _N_ _N_ _F_ _IF_ARGS_ 0 1 X 2 \ (u0 :: Int#) -> _!_ I# [] [u0] _N_} _F_ _IF_ARGS_ 0 1 X 1 \ (u0 :: Int) -> u0 _N_ } #-}
instance Num Integer
{-# GHC_PRAGMA _M_ PreludeCore {-dfun-} _A_ 0 _N_ _N_ _N_ _F_ _IF_ARGS_ 0 0 X 11 _!_ _TUP_10 [{{Eq Integer}}, {{Text Integer}}, (Integer -> Integer -> Integer), (Integer -> Integer -> Integer), (Integer -> Integer -> Integer), (Integer -> Integer), (Integer -> Integer), (Integer -> Integer), (Integer -> Integer), (Int -> Integer)] [_DFUN_ Eq (Integer), _DFUN_ Text (Integer), _CONSTM_ Num (+) (Integer), _CONSTM_ Num (-) (Integer), _CONSTM_ Num (*) (Integer), _CONSTM_ Num negate (Integer), _CONSTM_ Num abs (Integer), _CONSTM_ Num signum (Integer), _CONSTM_ Num fromInteger (Integer), _CONSTM_ Num fromInt (Integer)] _N_
- (+) = _A_ 2 _U_ 11 _N_ _S_ "U(PPP)U(PPP)" {_A_ 4 _U_ 2221 _N_ _N_ _F_ _IF_ARGS_ 0 4 XXXC 5 \ (u0 :: Int#) (u1 :: Int#) (u2 :: ByteArray#) (u3 :: Integer) -> case u3 of { _ALG_ J# (u4 :: Int#) (u5 :: Int#) (u6 :: ByteArray#) -> _#_ plusInteger# [] [u0, u1, u2, u4, u5, u6]; _NO_DEFLT_ } _N_} _F_ _IF_ARGS_ 0 2 CC 6 \ (u0 :: Integer) (u1 :: Integer) -> case u0 of { _ALG_ J# (u2 :: Int#) (u3 :: Int#) (u4 :: ByteArray#) -> case u1 of { _ALG_ J# (u5 :: Int#) (u6 :: Int#) (u7 :: ByteArray#) -> _#_ plusInteger# [] [u2, u3, u4, u5, u6, u7]; _NO_DEFLT_ }; _NO_DEFLT_ } _N_,
- (-) = _A_ 2 _U_ 11 _N_ _S_ "U(PPP)U(PPP)" {_A_ 4 _U_ 2221 _N_ _N_ _F_ _IF_ARGS_ 0 4 XXXC 5 \ (u0 :: Int#) (u1 :: Int#) (u2 :: ByteArray#) (u3 :: Integer) -> case u3 of { _ALG_ J# (u4 :: Int#) (u5 :: Int#) (u6 :: ByteArray#) -> _#_ minusInteger# [] [u0, u1, u2, u4, u5, u6]; _NO_DEFLT_ } _N_} _F_ _IF_ARGS_ 0 2 CC 6 \ (u0 :: Integer) (u1 :: Integer) -> case u0 of { _ALG_ J# (u2 :: Int#) (u3 :: Int#) (u4 :: ByteArray#) -> case u1 of { _ALG_ J# (u5 :: Int#) (u6 :: Int#) (u7 :: ByteArray#) -> _#_ minusInteger# [] [u2, u3, u4, u5, u6, u7]; _NO_DEFLT_ }; _NO_DEFLT_ } _N_,
- (*) = _A_ 2 _U_ 11 _N_ _S_ "U(PPP)U(PPP)" {_A_ 4 _U_ 2221 _N_ _N_ _F_ _IF_ARGS_ 0 4 XXXC 5 \ (u0 :: Int#) (u1 :: Int#) (u2 :: ByteArray#) (u3 :: Integer) -> case u3 of { _ALG_ J# (u4 :: Int#) (u5 :: Int#) (u6 :: ByteArray#) -> _#_ timesInteger# [] [u0, u1, u2, u4, u5, u6]; _NO_DEFLT_ } _N_} _F_ _IF_ARGS_ 0 2 CC 6 \ (u0 :: Integer) (u1 :: Integer) -> case u0 of { _ALG_ J# (u2 :: Int#) (u3 :: Int#) (u4 :: ByteArray#) -> case u1 of { _ALG_ J# (u5 :: Int#) (u6 :: Int#) (u7 :: ByteArray#) -> _#_ timesInteger# [] [u2, u3, u4, u5, u6, u7]; _NO_DEFLT_ }; _NO_DEFLT_ } _N_,
- negate = _A_ 1 _U_ 1 _N_ _S_ "U(PPP)" {_A_ 3 _U_ 222 _N_ _N_ _F_ _IF_ARGS_ 0 3 XXX 4 \ (u0 :: Int#) (u1 :: Int#) (u2 :: ByteArray#) -> _#_ negateInteger# [] [u0, u1, u2] _N_} _F_ _IF_ARGS_ 0 1 C 5 \ (u0 :: Integer) -> case u0 of { _ALG_ J# (u1 :: Int#) (u2 :: Int#) (u3 :: ByteArray#) -> _#_ negateInteger# [] [u1, u2, u3]; _NO_DEFLT_ } _N_,
- abs = _A_ 1 _U_ 1 _N_ _S_ "U(PPP)" {_A_ 3 _U_ 222 _N_ _N_ _N_ _N_} _N_ _N_,
- signum = _A_ 1 _U_ 1 _N_ _S_ "U(PPP)" {_A_ 3 _U_ 222 _N_ _N_ _N_ _N_} _N_ _N_,
- fromInteger = _A_ 1 _U_ 1 _N_ _S_ "U(PPP)" {_A_ 3 _U_ 222 _N_ _N_ _F_ _IF_ARGS_ 0 3 XXX 4 \ (u0 :: Int#) (u1 :: Int#) (u2 :: ByteArray#) -> _!_ J# [] [u0, u1, u2] _N_} _F_ _IF_ARGS_ 0 1 X 1 \ (u0 :: Integer) -> u0 _N_,
- fromInt = _A_ 1 _U_ 1 _N_ _S_ "U(P)" {_A_ 1 _U_ 2 _N_ _N_ _F_ _IF_ARGS_ 0 1 X 1 \ (u0 :: Int#) -> _#_ int2Integer# [] [u0] _N_} _F_ _IF_ARGS_ 0 1 C 2 \ (u0 :: Int) -> case u0 of { _ALG_ I# (u1 :: Int#) -> _#_ int2Integer# [] [u1]; _NO_DEFLT_ } _N_ #-}
+ (+) = { _A_ 2 _U_ 11 _N_ _S_ "U(PPP)U(PPP)" {_A_ 4 _U_ 2221 _N_ _N_ _F_ _IF_ARGS_ 0 4 XXXC 5 \ (u0 :: Int#) (u1 :: Int#) (u2 :: ByteArray#) (u3 :: Integer) -> case u3 of { _ALG_ J# (u4 :: Int#) (u5 :: Int#) (u6 :: ByteArray#) -> _#_ plusInteger# [] [u0, u1, u2, u4, u5, u6]; _NO_DEFLT_ } _N_} _F_ _IF_ARGS_ 0 2 CC 6 \ (u0 :: Integer) (u1 :: Integer) -> case u0 of { _ALG_ J# (u2 :: Int#) (u3 :: Int#) (u4 :: ByteArray#) -> case u1 of { _ALG_ J# (u5 :: Int#) (u6 :: Int#) (u7 :: ByteArray#) -> _#_ plusInteger# [] [u2, u3, u4, u5, u6, u7]; _NO_DEFLT_ }; _NO_DEFLT_ } _N_ },
+ (-) = { _A_ 2 _U_ 11 _N_ _S_ "U(PPP)U(PPP)" {_A_ 4 _U_ 2221 _N_ _N_ _F_ _IF_ARGS_ 0 4 XXXC 5 \ (u0 :: Int#) (u1 :: Int#) (u2 :: ByteArray#) (u3 :: Integer) -> case u3 of { _ALG_ J# (u4 :: Int#) (u5 :: Int#) (u6 :: ByteArray#) -> _#_ minusInteger# [] [u0, u1, u2, u4, u5, u6]; _NO_DEFLT_ } _N_} _F_ _IF_ARGS_ 0 2 CC 6 \ (u0 :: Integer) (u1 :: Integer) -> case u0 of { _ALG_ J# (u2 :: Int#) (u3 :: Int#) (u4 :: ByteArray#) -> case u1 of { _ALG_ J# (u5 :: Int#) (u6 :: Int#) (u7 :: ByteArray#) -> _#_ minusInteger# [] [u2, u3, u4, u5, u6, u7]; _NO_DEFLT_ }; _NO_DEFLT_ } _N_ },
+ (*) = { _A_ 2 _U_ 11 _N_ _S_ "U(PPP)U(PPP)" {_A_ 4 _U_ 2221 _N_ _N_ _F_ _IF_ARGS_ 0 4 XXXC 5 \ (u0 :: Int#) (u1 :: Int#) (u2 :: ByteArray#) (u3 :: Integer) -> case u3 of { _ALG_ J# (u4 :: Int#) (u5 :: Int#) (u6 :: ByteArray#) -> _#_ timesInteger# [] [u0, u1, u2, u4, u5, u6]; _NO_DEFLT_ } _N_} _F_ _IF_ARGS_ 0 2 CC 6 \ (u0 :: Integer) (u1 :: Integer) -> case u0 of { _ALG_ J# (u2 :: Int#) (u3 :: Int#) (u4 :: ByteArray#) -> case u1 of { _ALG_ J# (u5 :: Int#) (u6 :: Int#) (u7 :: ByteArray#) -> _#_ timesInteger# [] [u2, u3, u4, u5, u6, u7]; _NO_DEFLT_ }; _NO_DEFLT_ } _N_ },
+ negate = { _A_ 1 _U_ 1 _N_ _S_ "U(PPP)" {_A_ 3 _U_ 222 _N_ _N_ _F_ _IF_ARGS_ 0 3 XXX 4 \ (u0 :: Int#) (u1 :: Int#) (u2 :: ByteArray#) -> _#_ negateInteger# [] [u0, u1, u2] _N_} _F_ _IF_ARGS_ 0 1 C 5 \ (u0 :: Integer) -> case u0 of { _ALG_ J# (u1 :: Int#) (u2 :: Int#) (u3 :: ByteArray#) -> _#_ negateInteger# [] [u1, u2, u3]; _NO_DEFLT_ } _N_ },
+ abs = { _A_ 1 _U_ 1 _N_ _S_ "U(PPP)" {_A_ 3 _U_ 222 _N_ _N_ _N_ _N_} _N_ _N_ },
+ signum = { _A_ 1 _U_ 1 _N_ _S_ "U(PPP)" {_A_ 3 _U_ 222 _N_ _N_ _N_ _N_} _N_ _N_ },
+ fromInteger = { _A_ 1 _U_ 1 _N_ _S_ "U(PPP)" {_A_ 3 _U_ 222 _N_ _N_ _F_ _IF_ARGS_ 0 3 XXX 4 \ (u0 :: Int#) (u1 :: Int#) (u2 :: ByteArray#) -> _!_ J# [] [u0, u1, u2] _N_} _F_ _IF_ARGS_ 0 1 X 1 \ (u0 :: Integer) -> u0 _N_ },
+ fromInt = { _A_ 1 _U_ 1 _N_ _S_ "U(P)" {_A_ 1 _U_ 2 _N_ _N_ _F_ _IF_ARGS_ 0 1 X 1 \ (u0 :: Int#) -> _#_ int2Integer# [] [u0] _N_} _F_ _IF_ARGS_ 0 1 C 2 \ (u0 :: Int) -> case u0 of { _ALG_ I# (u1 :: Int#) -> _#_ int2Integer# [] [u1]; _NO_DEFLT_ } _N_ } #-}
instance Integral a => Num (Ratio a)
{-# GHC_PRAGMA _M_ PreludeRatio {-dfun-} _A_ 3 _U_ 222 _N_ _N_ _N_ _N_ #-}
instance Num (Ratio Integer)
{-# GHC_PRAGMA _M_ PreludeRatio {-dfun-} _A_ 0 _N_ _N_ _N_ _F_ _IF_ARGS_ 0 0 X 11 _!_ _TUP_10 [{{Eq (Ratio Integer)}}, {{Text (Ratio Integer)}}, (Ratio Integer -> Ratio Integer -> Ratio Integer), (Ratio Integer -> Ratio Integer -> Ratio Integer), (Ratio Integer -> Ratio Integer -> Ratio Integer), (Ratio Integer -> Ratio Integer), (Ratio Integer -> Ratio Integer), (Ratio Integer -> Ratio Integer), (Integer -> Ratio Integer), (Int -> Ratio Integer)] [_DFUN_ Eq (Ratio Integer), _DFUN_ Text (Ratio Integer), _CONSTM_ Num (+) (Ratio Integer), _CONSTM_ Num (-) (Ratio Integer), _CONSTM_ Num (*) (Ratio Integer), _CONSTM_ Num negate (Ratio Integer), _CONSTM_ Num abs (Ratio Integer), _CONSTM_ Num signum (Ratio Integer), _CONSTM_ Num fromInteger (Ratio Integer), _CONSTM_ Num fromInt (Ratio Integer)] _N_
- (+) = _A_ 2 _U_ 11 _N_ _S_ "U(LU(PPP))U(LU(PPP))" {_A_ 5 _U_ 12221 _N_ _N_ _N_ _N_} _N_ _N_,
- (-) = _A_ 2 _U_ 11 _N_ _S_ "U(LU(PPP))U(LU(PPP))" {_A_ 5 _U_ 12221 _N_ _N_ _N_ _N_} _N_ _N_,
- (*) = _A_ 2 _U_ 11 _N_ _S_ "U(LU(PPP))U(LU(PPP))" {_A_ 5 _U_ 22221 _N_ _N_ _N_ _N_} _N_ _N_,
- negate = _A_ 1 _U_ 1 _N_ _S_ "U(LL)" {_A_ 2 _U_ 22 _N_ _N_ _N_ _N_} _N_ _N_,
- abs = _A_ 1 _U_ 1 _N_ _S_ "U(LL)" {_A_ 2 _U_ 12 _N_ _N_ _N_ _N_} _N_ _N_,
- signum = _A_ 1 _U_ 1 _N_ _S_ "U(LA)" {_A_ 1 _U_ 1 _N_ _N_ _N_ _N_} _N_ _N_,
- fromInteger = _A_ 1 _U_ 2 _N_ _N_ _N_ _N_,
- fromInt = _A_ 1 _U_ 1 _N_ _N_ _N_ _N_ #-}
+ (+) = { _A_ 2 _U_ 11 _N_ _S_ "U(LU(PPP))U(LU(PPP))" {_A_ 5 _U_ 12221 _N_ _N_ _N_ _N_} _N_ _N_ },
+ (-) = { _A_ 2 _U_ 11 _N_ _S_ "U(LU(PPP))U(LU(PPP))" {_A_ 5 _U_ 12221 _N_ _N_ _N_ _N_} _N_ _N_ },
+ (*) = { _A_ 2 _U_ 11 _N_ _S_ "U(LU(PPP))U(LU(PPP))" {_A_ 5 _U_ 22221 _N_ _N_ _N_ _N_} _N_ _N_ },
+ negate = { _A_ 1 _U_ 1 _N_ _S_ "U(LL)" {_A_ 2 _U_ 22 _N_ _N_ _N_ _N_} _N_ _N_ },
+ abs = { _A_ 1 _U_ 1 _N_ _S_ "U(LL)" {_A_ 2 _U_ 12 _N_ _N_ _N_ _N_} _N_ _N_ },
+ signum = { _A_ 1 _U_ 1 _N_ _S_ "U(LA)" {_A_ 1 _U_ 1 _N_ _N_ _N_ _N_} _N_ _N_ },
+ fromInteger = { _A_ 1 _U_ 2 _N_ _N_ _F_ _IF_ARGS_ 0 1 X 3 \ (u0 :: Integer) -> _!_ (:%) [Integer] [u0, _SPEC_ _ORIG_ PreludeCore __i1 [ (Integer) ]] _N_ },
+ fromInt = { _A_ 1 _U_ 1 _N_ _N_ _N_ _N_ } #-}
instance Ord ()
{-# GHC_PRAGMA _M_ PreludeBuiltin {-dfun-} _A_ 0 _N_ _N_ _N_ _F_ _IF_ARGS_ 0 0 X 9 _!_ _TUP_8 [{{Eq ()}}, (() -> () -> Bool), (() -> () -> Bool), (() -> () -> Bool), (() -> () -> Bool), (() -> () -> ()), (() -> () -> ()), (() -> () -> _CMP_TAG)] [_DFUN_ Eq (()), _CONSTM_ Ord (<) (()), _CONSTM_ Ord (<=) (()), _CONSTM_ Ord (>=) (()), _CONSTM_ Ord (>) (()), _CONSTM_ Ord max (()), _CONSTM_ Ord min (()), _CONSTM_ Ord _tagCmp (())] _N_
- (<) = _A_ 2 _U_ 11 _N_ _S_ "EE" _F_ _IF_ARGS_ 0 2 CC 3 \ (u0 :: ()) (u1 :: ()) -> case u0 of { _ALG_ _TUP_0 -> case u1 of { _ALG_ _TUP_0 -> _!_ False [] []; _NO_DEFLT_ }; _NO_DEFLT_ } _N_,
- (<=) = _A_ 2 _U_ 11 _N_ _S_ "EE" _F_ _IF_ARGS_ 0 2 CC 3 \ (u0 :: ()) (u1 :: ()) -> case u0 of { _ALG_ _TUP_0 -> case u1 of { _ALG_ _TUP_0 -> _!_ True [] []; _NO_DEFLT_ }; _NO_DEFLT_ } _N_,
- (>=) = _A_ 2 _U_ 11 _N_ _S_ "EE" _F_ _IF_ARGS_ 0 2 CC 3 \ (u0 :: ()) (u1 :: ()) -> case u0 of { _ALG_ _TUP_0 -> case u1 of { _ALG_ _TUP_0 -> _!_ True [] []; _NO_DEFLT_ }; _NO_DEFLT_ } _N_,
- (>) = _A_ 2 _U_ 11 _N_ _S_ "EE" _F_ _IF_ARGS_ 0 2 CC 3 \ (u0 :: ()) (u1 :: ()) -> case u0 of { _ALG_ _TUP_0 -> case u1 of { _ALG_ _TUP_0 -> _!_ False [] []; _NO_DEFLT_ }; _NO_DEFLT_ } _N_,
- max = _A_ 2 _U_ 11 _N_ _S_ "EE" _F_ _IF_ARGS_ 0 2 CX 2 \ (u0 :: ()) (u1 :: ()) -> case u0 of { _ALG_ _TUP_0 -> u1; _NO_DEFLT_ } _N_,
- min = _A_ 2 _U_ 11 _N_ _S_ "EE" _F_ _IF_ARGS_ 0 2 CX 2 \ (u0 :: ()) (u1 :: ()) -> case u0 of { _ALG_ _TUP_0 -> u1; _NO_DEFLT_ } _N_,
- _tagCmp = _A_ 2 _U_ 11 _N_ _S_ "EE" _F_ _IF_ARGS_ 0 2 CC 3 \ (u0 :: ()) (u1 :: ()) -> case u0 of { _ALG_ _TUP_0 -> case u1 of { _ALG_ _TUP_0 -> _!_ _EQ [] []; _NO_DEFLT_ }; _NO_DEFLT_ } _N_ #-}
+ (<) = { _A_ 2 _U_ 11 _N_ _S_ "EE" _F_ _IF_ARGS_ 0 2 CC 3 \ (u0 :: ()) (u1 :: ()) -> case u0 of { _ALG_ _TUP_0 -> case u1 of { _ALG_ _TUP_0 -> _!_ False [] []; _NO_DEFLT_ }; _NO_DEFLT_ } _N_ },
+ (<=) = { _A_ 2 _U_ 11 _N_ _S_ "EE" _F_ _IF_ARGS_ 0 2 CC 3 \ (u0 :: ()) (u1 :: ()) -> case u0 of { _ALG_ _TUP_0 -> case u1 of { _ALG_ _TUP_0 -> _!_ True [] []; _NO_DEFLT_ }; _NO_DEFLT_ } _N_ },
+ (>=) = { _A_ 2 _U_ 11 _N_ _S_ "EE" _F_ _IF_ARGS_ 0 2 CC 3 \ (u0 :: ()) (u1 :: ()) -> case u0 of { _ALG_ _TUP_0 -> case u1 of { _ALG_ _TUP_0 -> _!_ True [] []; _NO_DEFLT_ }; _NO_DEFLT_ } _N_ },
+ (>) = { _A_ 2 _U_ 11 _N_ _S_ "EE" _F_ _IF_ARGS_ 0 2 CC 3 \ (u0 :: ()) (u1 :: ()) -> case u0 of { _ALG_ _TUP_0 -> case u1 of { _ALG_ _TUP_0 -> _!_ False [] []; _NO_DEFLT_ }; _NO_DEFLT_ } _N_ },
+ max = { _A_ 2 _U_ 11 _N_ _S_ "EE" _F_ _IF_ARGS_ 0 2 CX 2 \ (u0 :: ()) (u1 :: ()) -> case u0 of { _ALG_ _TUP_0 -> u1; _NO_DEFLT_ } _N_ },
+ min = { _A_ 2 _U_ 11 _N_ _S_ "EE" _F_ _IF_ARGS_ 0 2 CX 2 \ (u0 :: ()) (u1 :: ()) -> case u0 of { _ALG_ _TUP_0 -> u1; _NO_DEFLT_ } _N_ },
+ _tagCmp = { _A_ 2 _U_ 11 _N_ _S_ "EE" _F_ _IF_ARGS_ 0 2 CC 3 \ (u0 :: ()) (u1 :: ()) -> case u0 of { _ALG_ _TUP_0 -> case u1 of { _ALG_ _TUP_0 -> _!_ _EQ [] []; _NO_DEFLT_ }; _NO_DEFLT_ } _N_ } #-}
instance (Ord a, Ord b) => Ord (a, b)
{-# GHC_PRAGMA _M_ PreludeBuiltin {-dfun-} _A_ 3 _U_ 112 _N_ _N_ _N_ _N_ #-}
instance (Ord a, Ord b, Ord c) => Ord (a, b, c)
{-# GHC_PRAGMA _M_ PreludeBuiltin {-dfun-} _A_ 6 _U_ 111112 _N_ _N_ _N_ _N_ #-}
instance Ord (Int, Int)
{-# GHC_PRAGMA _M_ PreludeBuiltin {-dfun-} _A_ 0 _N_ _N_ _N_ _F_ _IF_ARGS_ 0 0 X 9 _!_ _TUP_8 [{{Eq (Int, Int)}}, ((Int, Int) -> (Int, Int) -> Bool), ((Int, Int) -> (Int, Int) -> Bool), ((Int, Int) -> (Int, Int) -> Bool), ((Int, Int) -> (Int, Int) -> Bool), ((Int, Int) -> (Int, Int) -> (Int, Int)), ((Int, Int) -> (Int, Int) -> (Int, Int)), ((Int, Int) -> (Int, Int) -> _CMP_TAG)] [_DFUN_ Eq ((Int, Int)), _CONSTM_ Ord (<) ((Int, Int)), _CONSTM_ Ord (<=) ((Int, Int)), _CONSTM_ Ord (>=) ((Int, Int)), _CONSTM_ Ord (>) ((Int, Int)), _CONSTM_ Ord max ((Int, Int)), _CONSTM_ Ord min ((Int, Int)), _CONSTM_ Ord _tagCmp ((Int, Int))] _N_
- (<) = _A_ 2 _U_ 11 _N_ _S_ "U(U(P)L)U(U(P)L)" {_A_ 4 _U_ 2121 _N_ _N_ _N_ _N_} _N_ _N_,
- (<=) = _A_ 2 _U_ 11 _N_ _S_ "U(U(P)L)U(U(P)L)" {_A_ 4 _U_ 2121 _N_ _N_ _N_ _N_} _N_ _N_,
- (>=) = _A_ 2 _U_ 11 _N_ _S_ "U(U(P)L)U(U(P)L)" {_A_ 4 _U_ 2121 _N_ _N_ _N_ _N_} _N_ _N_,
- (>) = _A_ 2 _U_ 11 _N_ _S_ "U(U(P)L)U(U(P)L)" {_A_ 4 _U_ 2121 _N_ _N_ _N_ _N_} _N_ _N_,
- max = _A_ 2 _U_ 11 _N_ _S_ "U(U(P)L)U(U(P)L)" {_A_ 4 _U_ 2222 _N_ _N_ _N_ _N_} _N_ _N_,
- min = _A_ 2 _U_ 11 _N_ _S_ "U(U(P)L)U(U(P)L)" {_A_ 4 _U_ 2222 _N_ _N_ _N_ _N_} _N_ _N_,
- _tagCmp = _A_ 2 _U_ 11 _N_ _S_ "U(U(P)L)U(U(P)L)" {_A_ 4 _U_ 2121 _N_ _N_ _N_ _N_} _N_ _N_ #-}
+ (<) = { _A_ 2 _U_ 11 _N_ _S_ "U(U(P)L)U(U(P)L)" {_A_ 4 _U_ 2121 _N_ _N_ _N_ _N_} _N_ _N_ },
+ (<=) = { _A_ 2 _U_ 11 _N_ _S_ "U(U(P)L)U(U(P)L)" {_A_ 4 _U_ 2121 _N_ _N_ _N_ _N_} _N_ _N_ },
+ (>=) = { _A_ 2 _U_ 11 _N_ _S_ "U(U(P)L)U(U(P)L)" {_A_ 4 _U_ 2121 _N_ _N_ _N_ _N_} _N_ _N_ },
+ (>) = { _A_ 2 _U_ 11 _N_ _S_ "U(U(P)L)U(U(P)L)" {_A_ 4 _U_ 2121 _N_ _N_ _N_ _N_} _N_ _N_ },
+ max = { _A_ 2 _U_ 11 _N_ _S_ "U(U(P)L)U(U(P)L)" {_A_ 4 _U_ 2222 _N_ _N_ _N_ _N_} _N_ _N_ },
+ min = { _A_ 2 _U_ 11 _N_ _S_ "U(U(P)L)U(U(P)L)" {_A_ 4 _U_ 2222 _N_ _N_ _N_ _N_} _N_ _N_ },
+ _tagCmp = { _A_ 2 _U_ 11 _N_ _S_ "U(U(P)L)U(U(P)L)" {_A_ 4 _U_ 2121 _N_ _N_ _N_ _N_} _N_ _N_ } #-}
+instance Ord (Int, Int, Int)
+ {-# GHC_PRAGMA _M_ PreludeBuiltin {-dfun-} _A_ 0 _N_ _N_ _N_ _F_ _IF_ARGS_ 0 0 X 9 _!_ _TUP_8 [{{Eq (Int, Int, Int)}}, ((Int, Int, Int) -> (Int, Int, Int) -> Bool), ((Int, Int, Int) -> (Int, Int, Int) -> Bool), ((Int, Int, Int) -> (Int, Int, Int) -> Bool), ((Int, Int, Int) -> (Int, Int, Int) -> Bool), ((Int, Int, Int) -> (Int, Int, Int) -> (Int, Int, Int)), ((Int, Int, Int) -> (Int, Int, Int) -> (Int, Int, Int)), ((Int, Int, Int) -> (Int, Int, Int) -> _CMP_TAG)] [_DFUN_ Eq ((Int, Int, Int)), _CONSTM_ Ord (<) ((Int, Int, Int)), _CONSTM_ Ord (<=) ((Int, Int, Int)), _CONSTM_ Ord (>=) ((Int, Int, Int)), _CONSTM_ Ord (>) ((Int, Int, Int)), _CONSTM_ Ord max ((Int, Int, Int)), _CONSTM_ Ord min ((Int, Int, Int)), _CONSTM_ Ord _tagCmp ((Int, Int, Int))] _N_
+ (<) = { _A_ 2 _U_ 11 _N_ _S_ "U(U(P)LL)U(U(P)LL)" {_A_ 4 _U_ 2111 _N_ _N_ _N_ _N_} _N_ _N_ },
+ (<=) = { _A_ 2 _U_ 11 _N_ _S_ "U(U(P)LL)U(U(P)LL)" {_A_ 4 _U_ 2111 _N_ _N_ _N_ _N_} _N_ _N_ },
+ (>=) = { _A_ 2 _U_ 11 _N_ _S_ "U(U(P)LL)U(U(P)LL)" {_A_ 4 _U_ 2111 _N_ _N_ _N_ _N_} _N_ _N_ },
+ (>) = { _A_ 2 _U_ 11 _N_ _S_ "U(U(P)LL)U(U(P)LL)" {_A_ 4 _U_ 2111 _N_ _N_ _N_ _N_} _N_ _N_ },
+ max = { _A_ 2 _U_ 12 _N_ _S_ "U(U(P)LL)U(U(P)LL)" {_A_ 4 _U_ 2222 _N_ _N_ _N_ _N_} _N_ _N_ },
+ min = { _A_ 2 _U_ 12 _N_ _S_ "U(U(P)LL)U(U(P)LL)" {_A_ 4 _U_ 2222 _N_ _N_ _N_ _N_} _N_ _N_ },
+ _tagCmp = { _A_ 2 _U_ 11 _N_ _S_ "U(U(P)LL)U(U(P)LL)" {_A_ 4 _U_ 2111 _N_ _N_ _N_ _N_} _N_ _N_ } #-}
+instance Ord (Int, Int, Int, Int)
+ {-# GHC_PRAGMA _M_ PreludeBuiltin {-dfun-} _A_ 0 _N_ _N_ _N_ _F_ _IF_ARGS_ 0 0 X 9 _!_ _TUP_8 [{{Eq (Int, Int, Int, Int)}}, ((Int, Int, Int, Int) -> (Int, Int, Int, Int) -> Bool), ((Int, Int, Int, Int) -> (Int, Int, Int, Int) -> Bool), ((Int, Int, Int, Int) -> (Int, Int, Int, Int) -> Bool), ((Int, Int, Int, Int) -> (Int, Int, Int, Int) -> Bool), ((Int, Int, Int, Int) -> (Int, Int, Int, Int) -> (Int, Int, Int, Int)), ((Int, Int, Int, Int) -> (Int, Int, Int, Int) -> (Int, Int, Int, Int)), ((Int, Int, Int, Int) -> (Int, Int, Int, Int) -> _CMP_TAG)] [_DFUN_ Eq ((Int, Int, Int, Int)), _CONSTM_ Ord (<) ((Int, Int, Int, Int)), _CONSTM_ Ord (<=) ((Int, Int, Int, Int)), _CONSTM_ Ord (>=) ((Int, Int, Int, Int)), _CONSTM_ Ord (>) ((Int, Int, Int, Int)), _CONSTM_ Ord max ((Int, Int, Int, Int)), _CONSTM_ Ord min ((Int, Int, Int, Int)), _CONSTM_ Ord _tagCmp ((Int, Int, Int, Int))] _N_
+ (<) = { _A_ 2 _U_ 11 _N_ _S_ "U(U(P)LLL)U(U(P)LLL)" {_A_ 5 _U_ 21111 _N_ _N_ _N_ _N_} _N_ _N_ },
+ (<=) = { _A_ 2 _U_ 11 _N_ _S_ "U(U(P)LLL)U(U(P)LLL)" {_A_ 5 _U_ 21111 _N_ _N_ _N_ _N_} _N_ _N_ },
+ (>=) = { _A_ 2 _U_ 11 _N_ _S_ "U(U(P)LLL)U(U(P)LLL)" {_A_ 5 _U_ 21111 _N_ _N_ _N_ _N_} _N_ _N_ },
+ (>) = { _A_ 2 _U_ 11 _N_ _S_ "U(U(P)LLL)U(U(P)LLL)" {_A_ 5 _U_ 21111 _N_ _N_ _N_ _N_} _N_ _N_ },
+ max = { _A_ 2 _U_ 12 _N_ _S_ "U(U(P)LLL)U(U(P)LLL)" {_A_ 5 _U_ 22222 _N_ _N_ _N_ _N_} _N_ _N_ },
+ min = { _A_ 2 _U_ 12 _N_ _S_ "U(U(P)LLL)U(U(P)LLL)" {_A_ 5 _U_ 22222 _N_ _N_ _N_ _N_} _N_ _N_ },
+ _tagCmp = { _A_ 2 _U_ 11 _N_ _S_ "U(U(P)LLL)U(U(P)LLL)" {_A_ 5 _U_ 21111 _N_ _N_ _N_ _N_} _N_ _N_ } #-}
+instance Ord (Int, Int, Int, Int, Int)
+ {-# GHC_PRAGMA _M_ PreludeBuiltin {-dfun-} _A_ 0 _N_ _N_ _N_ _F_ _IF_ARGS_ 0 0 X 9 _!_ _TUP_8 [{{Eq (Int, Int, Int, Int, Int)}}, ((Int, Int, Int, Int, Int) -> (Int, Int, Int, Int, Int) -> Bool), ((Int, Int, Int, Int, Int) -> (Int, Int, Int, Int, Int) -> Bool), ((Int, Int, Int, Int, Int) -> (Int, Int, Int, Int, Int) -> Bool), ((Int, Int, Int, Int, Int) -> (Int, Int, Int, Int, Int) -> Bool), ((Int, Int, Int, Int, Int) -> (Int, Int, Int, Int, Int) -> (Int, Int, Int, Int, Int)), ((Int, Int, Int, Int, Int) -> (Int, Int, Int, Int, Int) -> (Int, Int, Int, Int, Int)), ((Int, Int, Int, Int, Int) -> (Int, Int, Int, Int, Int) -> _CMP_TAG)] [_DFUN_ Eq ((Int, Int, Int, Int, Int)), _CONSTM_ Ord (<) ((Int, Int, Int, Int, Int)), _CONSTM_ Ord (<=) ((Int, Int, Int, Int, Int)), _CONSTM_ Ord (>=) ((Int, Int, Int, Int, Int)), _CONSTM_ Ord (>) ((Int, Int, Int, Int, Int)), _CONSTM_ Ord max ((Int, Int, Int, Int, Int)), _CONSTM_ Ord min ((Int, Int, Int, Int, Int)), _CONSTM_ Ord _tagCmp ((Int, Int, Int, Int, Int))] _N_
+ (<) = { _A_ 2 _U_ 11 _N_ _S_ "U(U(P)LLLL)U(U(P)LLLL)" _N_ _N_ },
+ (<=) = { _A_ 2 _U_ 11 _N_ _S_ "U(U(P)LLLL)U(U(P)LLLL)" _N_ _N_ },
+ (>=) = { _A_ 2 _U_ 11 _N_ _S_ "U(U(P)LLLL)U(U(P)LLLL)" _N_ _N_ },
+ (>) = { _A_ 2 _U_ 11 _N_ _S_ "U(U(P)LLLL)U(U(P)LLLL)" _N_ _N_ },
+ max = { _A_ 2 _U_ 22 _N_ _S_ "U(U(P)LLLL)U(U(P)LLLL)" _N_ _N_ },
+ min = { _A_ 2 _U_ 22 _N_ _S_ "U(U(P)LLLL)U(U(P)LLLL)" _N_ _N_ },
+ _tagCmp = { _A_ 2 _U_ 11 _N_ _S_ "U(U(P)LLLL)U(U(P)LLLL)" _N_ _N_ } #-}
+instance Ord ([Char], [Char])
+ {-# GHC_PRAGMA _M_ PreludeBuiltin {-dfun-} _A_ 0 _N_ _N_ _N_ _F_ _IF_ARGS_ 0 0 X 9 _!_ _TUP_8 [{{Eq ([Char], [Char])}}, (([Char], [Char]) -> ([Char], [Char]) -> Bool), (([Char], [Char]) -> ([Char], [Char]) -> Bool), (([Char], [Char]) -> ([Char], [Char]) -> Bool), (([Char], [Char]) -> ([Char], [Char]) -> Bool), (([Char], [Char]) -> ([Char], [Char]) -> ([Char], [Char])), (([Char], [Char]) -> ([Char], [Char]) -> ([Char], [Char])), (([Char], [Char]) -> ([Char], [Char]) -> _CMP_TAG)] [_DFUN_ Eq (([Char], [Char])), _CONSTM_ Ord (<) (([Char], [Char])), _CONSTM_ Ord (<=) (([Char], [Char])), _CONSTM_ Ord (>=) (([Char], [Char])), _CONSTM_ Ord (>) (([Char], [Char])), _CONSTM_ Ord max (([Char], [Char])), _CONSTM_ Ord min (([Char], [Char])), _CONSTM_ Ord _tagCmp (([Char], [Char]))] _N_
+ (<) = { _A_ 2 _U_ 11 _N_ _S_ "U(SL)U(SL)" {_A_ 4 _U_ 2222 _N_ _N_ _N_ _N_} _N_ _N_ },
+ (<=) = { _A_ 2 _U_ 11 _N_ _S_ "U(SL)U(SL)" {_A_ 4 _U_ 2222 _N_ _N_ _N_ _N_} _N_ _N_ },
+ (>=) = { _A_ 2 _U_ 11 _N_ _S_ "U(SL)U(SL)" {_A_ 4 _U_ 2222 _N_ _N_ _N_ _N_} _N_ _N_ },
+ (>) = { _A_ 2 _U_ 11 _N_ _S_ "U(SL)U(SL)" {_A_ 4 _U_ 2222 _N_ _N_ _N_ _N_} _N_ _N_ },
+ max = { _A_ 2 _U_ 11 _N_ _S_ "U(SL)U(SL)" {_A_ 4 _U_ 2222 _N_ _N_ _N_ _N_} _N_ _N_ },
+ min = { _A_ 2 _U_ 11 _N_ _S_ "U(SL)U(SL)" {_A_ 4 _U_ 2222 _N_ _N_ _N_ _N_} _N_ _N_ },
+ _tagCmp = { _A_ 2 _U_ 11 _N_ _S_ "U(SL)U(SL)" {_A_ 4 _U_ 2222 _N_ _N_ _N_ _N_} _N_ _N_ } #-}
+instance Ord ([Int], [Int])
+ {-# GHC_PRAGMA _M_ PreludeBuiltin {-dfun-} _A_ 0 _N_ _N_ _N_ _F_ _IF_ARGS_ 0 0 X 9 _!_ _TUP_8 [{{Eq ([Int], [Int])}}, (([Int], [Int]) -> ([Int], [Int]) -> Bool), (([Int], [Int]) -> ([Int], [Int]) -> Bool), (([Int], [Int]) -> ([Int], [Int]) -> Bool), (([Int], [Int]) -> ([Int], [Int]) -> Bool), (([Int], [Int]) -> ([Int], [Int]) -> ([Int], [Int])), (([Int], [Int]) -> ([Int], [Int]) -> ([Int], [Int])), (([Int], [Int]) -> ([Int], [Int]) -> _CMP_TAG)] [_DFUN_ Eq (([Int], [Int])), _CONSTM_ Ord (<) (([Int], [Int])), _CONSTM_ Ord (<=) (([Int], [Int])), _CONSTM_ Ord (>=) (([Int], [Int])), _CONSTM_ Ord (>) (([Int], [Int])), _CONSTM_ Ord max (([Int], [Int])), _CONSTM_ Ord min (([Int], [Int])), _CONSTM_ Ord _tagCmp (([Int], [Int]))] _N_
+ (<) = { _A_ 2 _U_ 11 _N_ _S_ "U(SL)U(SL)" {_A_ 4 _U_ 2222 _N_ _N_ _N_ _N_} _N_ _N_ },
+ (<=) = { _A_ 2 _U_ 11 _N_ _S_ "U(SL)U(SL)" {_A_ 4 _U_ 2222 _N_ _N_ _N_ _N_} _N_ _N_ },
+ (>=) = { _A_ 2 _U_ 11 _N_ _S_ "U(SL)U(SL)" {_A_ 4 _U_ 2222 _N_ _N_ _N_ _N_} _N_ _N_ },
+ (>) = { _A_ 2 _U_ 11 _N_ _S_ "U(SL)U(SL)" {_A_ 4 _U_ 2222 _N_ _N_ _N_ _N_} _N_ _N_ },
+ max = { _A_ 2 _U_ 11 _N_ _S_ "U(SL)U(SL)" {_A_ 4 _U_ 2222 _N_ _N_ _N_ _N_} _N_ _N_ },
+ min = { _A_ 2 _U_ 11 _N_ _S_ "U(SL)U(SL)" {_A_ 4 _U_ 2222 _N_ _N_ _N_ _N_} _N_ _N_ },
+ _tagCmp = { _A_ 2 _U_ 11 _N_ _S_ "U(SL)U(SL)" {_A_ 4 _U_ 2222 _N_ _N_ _N_ _N_} _N_ _N_ } #-}
instance Ord (_PackedString, _PackedString)
{-# GHC_PRAGMA _M_ PreludeBuiltin {-dfun-} _A_ 0 _N_ _N_ _N_ _F_ _IF_ARGS_ 0 0 X 9 _!_ _TUP_8 [{{Eq (_PackedString, _PackedString)}}, ((_PackedString, _PackedString) -> (_PackedString, _PackedString) -> Bool), ((_PackedString, _PackedString) -> (_PackedString, _PackedString) -> Bool), ((_PackedString, _PackedString) -> (_PackedString, _PackedString) -> Bool), ((_PackedString, _PackedString) -> (_PackedString, _PackedString) -> Bool), ((_PackedString, _PackedString) -> (_PackedString, _PackedString) -> (_PackedString, _PackedString)), ((_PackedString, _PackedString) -> (_PackedString, _PackedString) -> (_PackedString, _PackedString)), ((_PackedString, _PackedString) -> (_PackedString, _PackedString) -> _CMP_TAG)] [_DFUN_ Eq ((_PackedString, _PackedString)), _CONSTM_ Ord (<) ((_PackedString, _PackedString)), _CONSTM_ Ord (<=) ((_PackedString, _PackedString)), _CONSTM_ Ord (>=) ((_PackedString, _PackedString)), _CONSTM_ Ord (>) ((_PackedString, _PackedString)), _CONSTM_ Ord max ((_PackedString, _PackedString)), _CONSTM_ Ord min ((_PackedString, _PackedString)), _CONSTM_ Ord _tagCmp ((_PackedString, _PackedString))] _N_
- (<) = _A_ 2 _U_ 11 _N_ _S_ "U(SL)U(SL)" {_A_ 4 _U_ 2222 _N_ _N_ _N_ _N_} _N_ _N_,
- (<=) = _A_ 2 _U_ 11 _N_ _S_ "U(SL)U(SL)" {_A_ 4 _U_ 2222 _N_ _N_ _N_ _N_} _N_ _N_,
- (>=) = _A_ 2 _U_ 11 _N_ _S_ "U(SL)U(SL)" {_A_ 4 _U_ 2222 _N_ _N_ _N_ _N_} _N_ _N_,
- (>) = _A_ 2 _U_ 11 _N_ _S_ "U(SL)U(SL)" {_A_ 4 _U_ 2222 _N_ _N_ _N_ _N_} _N_ _N_,
- max = _A_ 2 _U_ 11 _N_ _S_ "U(SL)U(SL)" {_A_ 4 _U_ 2222 _N_ _N_ _N_ _N_} _N_ _N_,
- min = _A_ 2 _U_ 11 _N_ _S_ "U(SL)U(SL)" {_A_ 4 _U_ 2222 _N_ _N_ _N_ _N_} _N_ _N_,
- _tagCmp = _A_ 2 _U_ 11 _N_ _S_ "U(SL)U(SL)" {_A_ 4 _U_ 2222 _N_ _N_ _N_ _N_} _N_ _N_ #-}
+ (<) = { _A_ 2 _U_ 11 _N_ _S_ "U(SL)U(SL)" {_A_ 4 _U_ 2222 _N_ _N_ _N_ _N_} _N_ _N_ },
+ (<=) = { _A_ 2 _U_ 11 _N_ _S_ "U(SL)U(SL)" {_A_ 4 _U_ 2222 _N_ _N_ _N_ _N_} _N_ _N_ },
+ (>=) = { _A_ 2 _U_ 11 _N_ _S_ "U(SL)U(SL)" {_A_ 4 _U_ 2222 _N_ _N_ _N_ _N_} _N_ _N_ },
+ (>) = { _A_ 2 _U_ 11 _N_ _S_ "U(SL)U(SL)" {_A_ 4 _U_ 2222 _N_ _N_ _N_ _N_} _N_ _N_ },
+ max = { _A_ 2 _U_ 11 _N_ _S_ "U(SL)U(SL)" {_A_ 4 _U_ 2222 _N_ _N_ _N_ _N_} _N_ _N_ },
+ min = { _A_ 2 _U_ 11 _N_ _S_ "U(SL)U(SL)" {_A_ 4 _U_ 2222 _N_ _N_ _N_ _N_} _N_ _N_ },
+ _tagCmp = { _A_ 2 _U_ 11 _N_ _S_ "U(SL)U(SL)" {_A_ 4 _U_ 2222 _N_ _N_ _N_ _N_} _N_ _N_ } #-}
instance (Ix a, Ord b) => Ord (Array a b)
{-# GHC_PRAGMA _M_ PreludeArray {-dfun-} _A_ 3 _U_ 222 _N_ _N_ _N_ _N_ #-}
instance (Ord a, Ord b) => Ord (Assoc a b)
{-# GHC_PRAGMA _M_ PreludeArray {-dfun-} _A_ 3 _U_ 112 _N_ _N_ _N_ _N_ #-}
instance Ord Bool
{-# GHC_PRAGMA _M_ PreludeCore {-dfun-} _A_ 0 _N_ _N_ _N_ _F_ _IF_ARGS_ 0 0 X 9 _!_ _TUP_8 [{{Eq Bool}}, (Bool -> Bool -> Bool), (Bool -> Bool -> Bool), (Bool -> Bool -> Bool), (Bool -> Bool -> Bool), (Bool -> Bool -> Bool), (Bool -> Bool -> Bool), (Bool -> Bool -> _CMP_TAG)] [_DFUN_ Eq (Bool), _CONSTM_ Ord (<) (Bool), _CONSTM_ Ord (<=) (Bool), _CONSTM_ Ord (>=) (Bool), _CONSTM_ Ord (>) (Bool), _CONSTM_ Ord max (Bool), _CONSTM_ Ord min (Bool), _CONSTM_ Ord _tagCmp (Bool)] _N_
- (<) = _A_ 2 _U_ 11 _N_ _S_ "EE" _N_ _N_,
- (<=) = _A_ 2 _U_ 11 _N_ _S_ "EE" _N_ _N_,
- (>=) = _A_ 2 _U_ 11 _N_ _S_ "EE" _N_ _N_,
- (>) = _A_ 2 _U_ 11 _N_ _S_ "EE" _N_ _N_,
- max = _A_ 2 _U_ 22 _N_ _S_ "EE" _N_ _N_,
- min = _A_ 2 _U_ 22 _N_ _S_ "EE" _N_ _N_,
- _tagCmp = _A_ 2 _U_ 11 _N_ _S_ "EE" _N_ _N_ #-}
+ (<) = { _A_ 2 _U_ 11 _N_ _S_ "EE" _N_ _N_ },
+ (<=) = { _A_ 2 _U_ 11 _N_ _S_ "EE" _N_ _N_ },
+ (>=) = { _A_ 2 _U_ 11 _N_ _S_ "EE" _N_ _N_ },
+ (>) = { _A_ 2 _U_ 11 _N_ _S_ "EE" _N_ _N_ },
+ max = { _A_ 2 _U_ 22 _N_ _S_ "EE" _N_ _N_ },
+ min = { _A_ 2 _U_ 22 _N_ _S_ "EE" _N_ _N_ },
+ _tagCmp = { _A_ 2 _U_ 11 _N_ _S_ "EE" _N_ _N_ } #-}
instance Ord Char
{-# GHC_PRAGMA _M_ PreludeCore {-dfun-} _A_ 0 _N_ _N_ _N_ _F_ _IF_ARGS_ 0 0 X 9 _!_ _TUP_8 [{{Eq Char}}, (Char -> Char -> Bool), (Char -> Char -> Bool), (Char -> Char -> Bool), (Char -> Char -> Bool), (Char -> Char -> Char), (Char -> Char -> Char), (Char -> Char -> _CMP_TAG)] [_DFUN_ Eq (Char), _CONSTM_ Ord (<) (Char), _CONSTM_ Ord (<=) (Char), _CONSTM_ Ord (>=) (Char), _CONSTM_ Ord (>) (Char), _CONSTM_ Ord max (Char), _CONSTM_ Ord min (Char), _CONSTM_ Ord _tagCmp (Char)] _N_
- (<) = _A_ 2 _U_ 11 _N_ _S_ "U(P)U(P)" {_A_ 2 _U_ 22 _N_ _N_ _F_ _IF_ARGS_ 0 2 XX 1 \ (u0 :: Char#) (u1 :: Char#) -> _#_ ltChar# [] [u0, u1] _N_} _F_ _IF_ARGS_ 0 2 CC 3 \ (u0 :: Char) (u1 :: Char) -> case u0 of { _ALG_ C# (u2 :: Char#) -> case u1 of { _ALG_ C# (u3 :: Char#) -> _#_ ltChar# [] [u2, u3]; _NO_DEFLT_ }; _NO_DEFLT_ } _N_,
- (<=) = _A_ 2 _U_ 11 _N_ _S_ "U(P)U(P)" {_A_ 2 _U_ 22 _N_ _N_ _F_ _IF_ARGS_ 0 2 XX 1 \ (u0 :: Char#) (u1 :: Char#) -> _#_ leChar# [] [u0, u1] _N_} _F_ _IF_ARGS_ 0 2 CC 3 \ (u0 :: Char) (u1 :: Char) -> case u0 of { _ALG_ C# (u2 :: Char#) -> case u1 of { _ALG_ C# (u3 :: Char#) -> _#_ leChar# [] [u2, u3]; _NO_DEFLT_ }; _NO_DEFLT_ } _N_,
- (>=) = _A_ 2 _U_ 11 _N_ _S_ "U(P)U(P)" {_A_ 2 _U_ 22 _N_ _N_ _F_ _IF_ARGS_ 0 2 XX 1 \ (u0 :: Char#) (u1 :: Char#) -> _#_ geChar# [] [u0, u1] _N_} _F_ _IF_ARGS_ 0 2 CC 3 \ (u0 :: Char) (u1 :: Char) -> case u0 of { _ALG_ C# (u2 :: Char#) -> case u1 of { _ALG_ C# (u3 :: Char#) -> _#_ geChar# [] [u2, u3]; _NO_DEFLT_ }; _NO_DEFLT_ } _N_,
- (>) = _A_ 2 _U_ 11 _N_ _S_ "U(P)U(P)" {_A_ 2 _U_ 22 _N_ _N_ _F_ _IF_ARGS_ 0 2 XX 1 \ (u0 :: Char#) (u1 :: Char#) -> _#_ gtChar# [] [u0, u1] _N_} _F_ _IF_ARGS_ 0 2 CC 3 \ (u0 :: Char) (u1 :: Char) -> case u0 of { _ALG_ C# (u2 :: Char#) -> case u1 of { _ALG_ C# (u3 :: Char#) -> _#_ gtChar# [] [u2, u3]; _NO_DEFLT_ }; _NO_DEFLT_ } _N_,
- max = _A_ 2 _U_ 11 _N_ _S_ "U(P)U(P)" {_A_ 2 _U_ 22 _N_ _N_ _N_ _N_} _N_ _N_,
- min = _A_ 2 _U_ 11 _N_ _S_ "U(P)U(P)" {_A_ 2 _U_ 22 _N_ _N_ _N_ _N_} _N_ _N_,
- _tagCmp = _A_ 2 _U_ 11 _N_ _S_ "U(P)U(P)" {_A_ 2 _U_ 22 _N_ _N_ _N_ _N_} _N_ _N_ #-}
+ (<) = { _A_ 2 _U_ 11 _N_ _S_ "U(P)U(P)" {_A_ 2 _U_ 22 _N_ _N_ _F_ _IF_ARGS_ 0 2 XX 1 \ (u0 :: Char#) (u1 :: Char#) -> _#_ ltChar# [] [u0, u1] _N_} _F_ _IF_ARGS_ 0 2 CC 3 \ (u0 :: Char) (u1 :: Char) -> case u0 of { _ALG_ C# (u2 :: Char#) -> case u1 of { _ALG_ C# (u3 :: Char#) -> _#_ ltChar# [] [u2, u3]; _NO_DEFLT_ }; _NO_DEFLT_ } _N_ },
+ (<=) = { _A_ 2 _U_ 11 _N_ _S_ "U(P)U(P)" {_A_ 2 _U_ 22 _N_ _N_ _F_ _IF_ARGS_ 0 2 XX 1 \ (u0 :: Char#) (u1 :: Char#) -> _#_ leChar# [] [u0, u1] _N_} _F_ _IF_ARGS_ 0 2 CC 3 \ (u0 :: Char) (u1 :: Char) -> case u0 of { _ALG_ C# (u2 :: Char#) -> case u1 of { _ALG_ C# (u3 :: Char#) -> _#_ leChar# [] [u2, u3]; _NO_DEFLT_ }; _NO_DEFLT_ } _N_ },
+ (>=) = { _A_ 2 _U_ 11 _N_ _S_ "U(P)U(P)" {_A_ 2 _U_ 22 _N_ _N_ _F_ _IF_ARGS_ 0 2 XX 1 \ (u0 :: Char#) (u1 :: Char#) -> _#_ geChar# [] [u0, u1] _N_} _F_ _IF_ARGS_ 0 2 CC 3 \ (u0 :: Char) (u1 :: Char) -> case u0 of { _ALG_ C# (u2 :: Char#) -> case u1 of { _ALG_ C# (u3 :: Char#) -> _#_ geChar# [] [u2, u3]; _NO_DEFLT_ }; _NO_DEFLT_ } _N_ },
+ (>) = { _A_ 2 _U_ 11 _N_ _S_ "U(P)U(P)" {_A_ 2 _U_ 22 _N_ _N_ _F_ _IF_ARGS_ 0 2 XX 1 \ (u0 :: Char#) (u1 :: Char#) -> _#_ gtChar# [] [u0, u1] _N_} _F_ _IF_ARGS_ 0 2 CC 3 \ (u0 :: Char) (u1 :: Char) -> case u0 of { _ALG_ C# (u2 :: Char#) -> case u1 of { _ALG_ C# (u3 :: Char#) -> _#_ gtChar# [] [u2, u3]; _NO_DEFLT_ }; _NO_DEFLT_ } _N_ },
+ max = { _A_ 2 _U_ 11 _N_ _S_ "U(P)U(P)" {_A_ 2 _U_ 22 _N_ _N_ _N_ _N_} _N_ _N_ },
+ min = { _A_ 2 _U_ 11 _N_ _S_ "U(P)U(P)" {_A_ 2 _U_ 22 _N_ _N_ _N_ _N_} _N_ _N_ },
+ _tagCmp = { _A_ 2 _U_ 11 _N_ _S_ "U(P)U(P)" {_A_ 2 _U_ 22 _N_ _N_ _N_ _N_} _N_ _N_ } #-}
instance Ord Double
{-# GHC_PRAGMA _M_ PreludeCore {-dfun-} _A_ 0 _N_ _N_ _N_ _F_ _IF_ARGS_ 0 0 X 9 _!_ _TUP_8 [{{Eq Double}}, (Double -> Double -> Bool), (Double -> Double -> Bool), (Double -> Double -> Bool), (Double -> Double -> Bool), (Double -> Double -> Double), (Double -> Double -> Double), (Double -> Double -> _CMP_TAG)] [_DFUN_ Eq (Double), _CONSTM_ Ord (<) (Double), _CONSTM_ Ord (<=) (Double), _CONSTM_ Ord (>=) (Double), _CONSTM_ Ord (>) (Double), _CONSTM_ Ord max (Double), _CONSTM_ Ord min (Double), _CONSTM_ Ord _tagCmp (Double)] _N_
- (<) = _A_ 2 _U_ 11 _N_ _S_ "U(P)U(P)" {_A_ 2 _U_ 22 _N_ _N_ _F_ _IF_ARGS_ 0 2 XX 1 \ (u0 :: Double#) (u1 :: Double#) -> _#_ ltDouble# [] [u0, u1] _N_} _F_ _IF_ARGS_ 0 2 CC 3 \ (u0 :: Double) (u1 :: Double) -> case u0 of { _ALG_ D# (u2 :: Double#) -> case u1 of { _ALG_ D# (u3 :: Double#) -> _#_ ltDouble# [] [u2, u3]; _NO_DEFLT_ }; _NO_DEFLT_ } _N_,
- (<=) = _A_ 2 _U_ 11 _N_ _S_ "U(P)U(P)" {_A_ 2 _U_ 22 _N_ _N_ _F_ _IF_ARGS_ 0 2 XX 1 \ (u0 :: Double#) (u1 :: Double#) -> _#_ leDouble# [] [u0, u1] _N_} _F_ _IF_ARGS_ 0 2 CC 3 \ (u0 :: Double) (u1 :: Double) -> case u0 of { _ALG_ D# (u2 :: Double#) -> case u1 of { _ALG_ D# (u3 :: Double#) -> _#_ leDouble# [] [u2, u3]; _NO_DEFLT_ }; _NO_DEFLT_ } _N_,
- (>=) = _A_ 2 _U_ 11 _N_ _S_ "U(P)U(P)" {_A_ 2 _U_ 22 _N_ _N_ _F_ _IF_ARGS_ 0 2 XX 1 \ (u0 :: Double#) (u1 :: Double#) -> _#_ geDouble# [] [u0, u1] _N_} _F_ _IF_ARGS_ 0 2 CC 3 \ (u0 :: Double) (u1 :: Double) -> case u0 of { _ALG_ D# (u2 :: Double#) -> case u1 of { _ALG_ D# (u3 :: Double#) -> _#_ geDouble# [] [u2, u3]; _NO_DEFLT_ }; _NO_DEFLT_ } _N_,
- (>) = _A_ 2 _U_ 11 _N_ _S_ "U(P)U(P)" {_A_ 2 _U_ 22 _N_ _N_ _F_ _IF_ARGS_ 0 2 XX 1 \ (u0 :: Double#) (u1 :: Double#) -> _#_ gtDouble# [] [u0, u1] _N_} _F_ _IF_ARGS_ 0 2 CC 3 \ (u0 :: Double) (u1 :: Double) -> case u0 of { _ALG_ D# (u2 :: Double#) -> case u1 of { _ALG_ D# (u3 :: Double#) -> _#_ gtDouble# [] [u2, u3]; _NO_DEFLT_ }; _NO_DEFLT_ } _N_,
- max = _A_ 2 _U_ 11 _N_ _S_ "U(P)U(P)" {_A_ 2 _U_ 22 _N_ _N_ _N_ _N_} _N_ _N_,
- min = _A_ 2 _U_ 11 _N_ _S_ "U(P)U(P)" {_A_ 2 _U_ 22 _N_ _N_ _N_ _N_} _N_ _N_,
- _tagCmp = _A_ 2 _U_ 11 _N_ _S_ "U(P)U(P)" {_A_ 2 _U_ 22 _N_ _N_ _N_ _N_} _N_ _N_ #-}
+ (<) = { _A_ 2 _U_ 11 _N_ _S_ "U(P)U(P)" {_A_ 2 _U_ 22 _N_ _N_ _F_ _IF_ARGS_ 0 2 XX 1 \ (u0 :: Double#) (u1 :: Double#) -> _#_ ltDouble# [] [u0, u1] _N_} _F_ _IF_ARGS_ 0 2 CC 3 \ (u0 :: Double) (u1 :: Double) -> case u0 of { _ALG_ D# (u2 :: Double#) -> case u1 of { _ALG_ D# (u3 :: Double#) -> _#_ ltDouble# [] [u2, u3]; _NO_DEFLT_ }; _NO_DEFLT_ } _N_ },
+ (<=) = { _A_ 2 _U_ 11 _N_ _S_ "U(P)U(P)" {_A_ 2 _U_ 22 _N_ _N_ _F_ _IF_ARGS_ 0 2 XX 1 \ (u0 :: Double#) (u1 :: Double#) -> _#_ leDouble# [] [u0, u1] _N_} _F_ _IF_ARGS_ 0 2 CC 3 \ (u0 :: Double) (u1 :: Double) -> case u0 of { _ALG_ D# (u2 :: Double#) -> case u1 of { _ALG_ D# (u3 :: Double#) -> _#_ leDouble# [] [u2, u3]; _NO_DEFLT_ }; _NO_DEFLT_ } _N_ },
+ (>=) = { _A_ 2 _U_ 11 _N_ _S_ "U(P)U(P)" {_A_ 2 _U_ 22 _N_ _N_ _F_ _IF_ARGS_ 0 2 XX 1 \ (u0 :: Double#) (u1 :: Double#) -> _#_ geDouble# [] [u0, u1] _N_} _F_ _IF_ARGS_ 0 2 CC 3 \ (u0 :: Double) (u1 :: Double) -> case u0 of { _ALG_ D# (u2 :: Double#) -> case u1 of { _ALG_ D# (u3 :: Double#) -> _#_ geDouble# [] [u2, u3]; _NO_DEFLT_ }; _NO_DEFLT_ } _N_ },
+ (>) = { _A_ 2 _U_ 11 _N_ _S_ "U(P)U(P)" {_A_ 2 _U_ 22 _N_ _N_ _F_ _IF_ARGS_ 0 2 XX 1 \ (u0 :: Double#) (u1 :: Double#) -> _#_ gtDouble# [] [u0, u1] _N_} _F_ _IF_ARGS_ 0 2 CC 3 \ (u0 :: Double) (u1 :: Double) -> case u0 of { _ALG_ D# (u2 :: Double#) -> case u1 of { _ALG_ D# (u3 :: Double#) -> _#_ gtDouble# [] [u2, u3]; _NO_DEFLT_ }; _NO_DEFLT_ } _N_ },
+ max = { _A_ 2 _U_ 11 _N_ _S_ "U(P)U(P)" {_A_ 2 _U_ 22 _N_ _N_ _N_ _N_} _N_ _N_ },
+ min = { _A_ 2 _U_ 11 _N_ _S_ "U(P)U(P)" {_A_ 2 _U_ 22 _N_ _N_ _N_ _N_} _N_ _N_ },
+ _tagCmp = { _A_ 2 _U_ 11 _N_ _S_ "U(P)U(P)" {_A_ 2 _U_ 22 _N_ _N_ _N_ _N_} _N_ _N_ } #-}
instance Ord Float
{-# GHC_PRAGMA _M_ PreludeCore {-dfun-} _A_ 0 _N_ _N_ _N_ _F_ _IF_ARGS_ 0 0 X 9 _!_ _TUP_8 [{{Eq Float}}, (Float -> Float -> Bool), (Float -> Float -> Bool), (Float -> Float -> Bool), (Float -> Float -> Bool), (Float -> Float -> Float), (Float -> Float -> Float), (Float -> Float -> _CMP_TAG)] [_DFUN_ Eq (Float), _CONSTM_ Ord (<) (Float), _CONSTM_ Ord (<=) (Float), _CONSTM_ Ord (>=) (Float), _CONSTM_ Ord (>) (Float), _CONSTM_ Ord max (Float), _CONSTM_ Ord min (Float), _CONSTM_ Ord _tagCmp (Float)] _N_
- (<) = _A_ 2 _U_ 11 _N_ _S_ "U(P)U(P)" {_A_ 2 _U_ 22 _N_ _N_ _F_ _IF_ARGS_ 0 2 XX 1 \ (u0 :: Float#) (u1 :: Float#) -> _#_ ltFloat# [] [u0, u1] _N_} _F_ _IF_ARGS_ 0 2 CC 3 \ (u0 :: Float) (u1 :: Float) -> case u0 of { _ALG_ F# (u2 :: Float#) -> case u1 of { _ALG_ F# (u3 :: Float#) -> _#_ ltFloat# [] [u2, u3]; _NO_DEFLT_ }; _NO_DEFLT_ } _N_,
- (<=) = _A_ 2 _U_ 11 _N_ _S_ "U(P)U(P)" {_A_ 2 _U_ 22 _N_ _N_ _F_ _IF_ARGS_ 0 2 XX 1 \ (u0 :: Float#) (u1 :: Float#) -> _#_ leFloat# [] [u0, u1] _N_} _F_ _IF_ARGS_ 0 2 CC 3 \ (u0 :: Float) (u1 :: Float) -> case u0 of { _ALG_ F# (u2 :: Float#) -> case u1 of { _ALG_ F# (u3 :: Float#) -> _#_ leFloat# [] [u2, u3]; _NO_DEFLT_ }; _NO_DEFLT_ } _N_,
- (>=) = _A_ 2 _U_ 11 _N_ _S_ "U(P)U(P)" {_A_ 2 _U_ 22 _N_ _N_ _F_ _IF_ARGS_ 0 2 XX 1 \ (u0 :: Float#) (u1 :: Float#) -> _#_ geFloat# [] [u0, u1] _N_} _F_ _IF_ARGS_ 0 2 CC 3 \ (u0 :: Float) (u1 :: Float) -> case u0 of { _ALG_ F# (u2 :: Float#) -> case u1 of { _ALG_ F# (u3 :: Float#) -> _#_ geFloat# [] [u2, u3]; _NO_DEFLT_ }; _NO_DEFLT_ } _N_,
- (>) = _A_ 2 _U_ 11 _N_ _S_ "U(P)U(P)" {_A_ 2 _U_ 22 _N_ _N_ _F_ _IF_ARGS_ 0 2 XX 1 \ (u0 :: Float#) (u1 :: Float#) -> _#_ gtFloat# [] [u0, u1] _N_} _F_ _IF_ARGS_ 0 2 CC 3 \ (u0 :: Float) (u1 :: Float) -> case u0 of { _ALG_ F# (u2 :: Float#) -> case u1 of { _ALG_ F# (u3 :: Float#) -> _#_ gtFloat# [] [u2, u3]; _NO_DEFLT_ }; _NO_DEFLT_ } _N_,
- max = _A_ 2 _U_ 11 _N_ _S_ "U(P)U(P)" {_A_ 2 _U_ 22 _N_ _N_ _N_ _N_} _N_ _N_,
- min = _A_ 2 _U_ 11 _N_ _S_ "U(P)U(P)" {_A_ 2 _U_ 22 _N_ _N_ _N_ _N_} _N_ _N_,
- _tagCmp = _A_ 2 _U_ 11 _N_ _S_ "U(P)U(P)" {_A_ 2 _U_ 22 _N_ _N_ _N_ _N_} _N_ _N_ #-}
+ (<) = { _A_ 2 _U_ 11 _N_ _S_ "U(P)U(P)" {_A_ 2 _U_ 22 _N_ _N_ _F_ _IF_ARGS_ 0 2 XX 1 \ (u0 :: Float#) (u1 :: Float#) -> _#_ ltFloat# [] [u0, u1] _N_} _F_ _IF_ARGS_ 0 2 CC 3 \ (u0 :: Float) (u1 :: Float) -> case u0 of { _ALG_ F# (u2 :: Float#) -> case u1 of { _ALG_ F# (u3 :: Float#) -> _#_ ltFloat# [] [u2, u3]; _NO_DEFLT_ }; _NO_DEFLT_ } _N_ },
+ (<=) = { _A_ 2 _U_ 11 _N_ _S_ "U(P)U(P)" {_A_ 2 _U_ 22 _N_ _N_ _F_ _IF_ARGS_ 0 2 XX 1 \ (u0 :: Float#) (u1 :: Float#) -> _#_ leFloat# [] [u0, u1] _N_} _F_ _IF_ARGS_ 0 2 CC 3 \ (u0 :: Float) (u1 :: Float) -> case u0 of { _ALG_ F# (u2 :: Float#) -> case u1 of { _ALG_ F# (u3 :: Float#) -> _#_ leFloat# [] [u2, u3]; _NO_DEFLT_ }; _NO_DEFLT_ } _N_ },
+ (>=) = { _A_ 2 _U_ 11 _N_ _S_ "U(P)U(P)" {_A_ 2 _U_ 22 _N_ _N_ _F_ _IF_ARGS_ 0 2 XX 1 \ (u0 :: Float#) (u1 :: Float#) -> _#_ geFloat# [] [u0, u1] _N_} _F_ _IF_ARGS_ 0 2 CC 3 \ (u0 :: Float) (u1 :: Float) -> case u0 of { _ALG_ F# (u2 :: Float#) -> case u1 of { _ALG_ F# (u3 :: Float#) -> _#_ geFloat# [] [u2, u3]; _NO_DEFLT_ }; _NO_DEFLT_ } _N_ },
+ (>) = { _A_ 2 _U_ 11 _N_ _S_ "U(P)U(P)" {_A_ 2 _U_ 22 _N_ _N_ _F_ _IF_ARGS_ 0 2 XX 1 \ (u0 :: Float#) (u1 :: Float#) -> _#_ gtFloat# [] [u0, u1] _N_} _F_ _IF_ARGS_ 0 2 CC 3 \ (u0 :: Float) (u1 :: Float) -> case u0 of { _ALG_ F# (u2 :: Float#) -> case u1 of { _ALG_ F# (u3 :: Float#) -> _#_ gtFloat# [] [u2, u3]; _NO_DEFLT_ }; _NO_DEFLT_ } _N_ },
+ max = { _A_ 2 _U_ 11 _N_ _S_ "U(P)U(P)" {_A_ 2 _U_ 22 _N_ _N_ _N_ _N_} _N_ _N_ },
+ min = { _A_ 2 _U_ 11 _N_ _S_ "U(P)U(P)" {_A_ 2 _U_ 22 _N_ _N_ _N_ _N_} _N_ _N_ },
+ _tagCmp = { _A_ 2 _U_ 11 _N_ _S_ "U(P)U(P)" {_A_ 2 _U_ 22 _N_ _N_ _N_ _N_} _N_ _N_ } #-}
instance Ord Int
{-# GHC_PRAGMA _M_ PreludeCore {-dfun-} _A_ 0 _N_ _N_ _N_ _F_ _IF_ARGS_ 0 0 X 9 _!_ _TUP_8 [{{Eq Int}}, (Int -> Int -> Bool), (Int -> Int -> Bool), (Int -> Int -> Bool), (Int -> Int -> Bool), (Int -> Int -> Int), (Int -> Int -> Int), (Int -> Int -> _CMP_TAG)] [_DFUN_ Eq (Int), _CONSTM_ Ord (<) (Int), _CONSTM_ Ord (<=) (Int), _CONSTM_ Ord (>=) (Int), _CONSTM_ Ord (>) (Int), _CONSTM_ Ord max (Int), _CONSTM_ Ord min (Int), _CONSTM_ Ord _tagCmp (Int)] _N_
- (<) = _A_ 2 _U_ 11 _N_ _S_ "U(P)U(P)" {_A_ 2 _U_ 22 _N_ _N_ _F_ _IF_ARGS_ 0 2 XX 1 \ (u0 :: Int#) (u1 :: Int#) -> _#_ ltInt# [] [u0, u1] _N_} _F_ _IF_ARGS_ 0 2 CC 3 \ (u0 :: Int) (u1 :: Int) -> case u0 of { _ALG_ I# (u2 :: Int#) -> case u1 of { _ALG_ I# (u3 :: Int#) -> _#_ ltInt# [] [u2, u3]; _NO_DEFLT_ }; _NO_DEFLT_ } _N_,
- (<=) = _A_ 2 _U_ 11 _N_ _S_ "U(P)U(P)" {_A_ 2 _U_ 22 _N_ _N_ _F_ _IF_ARGS_ 0 2 XX 1 \ (u0 :: Int#) (u1 :: Int#) -> _#_ leInt# [] [u0, u1] _N_} _F_ _IF_ARGS_ 0 2 CC 3 \ (u0 :: Int) (u1 :: Int) -> case u0 of { _ALG_ I# (u2 :: Int#) -> case u1 of { _ALG_ I# (u3 :: Int#) -> _#_ leInt# [] [u2, u3]; _NO_DEFLT_ }; _NO_DEFLT_ } _N_,
- (>=) = _A_ 2 _U_ 11 _N_ _S_ "U(P)U(P)" {_A_ 2 _U_ 22 _N_ _N_ _F_ _IF_ARGS_ 0 2 XX 1 \ (u0 :: Int#) (u1 :: Int#) -> _#_ geInt# [] [u0, u1] _N_} _F_ _IF_ARGS_ 0 2 CC 3 \ (u0 :: Int) (u1 :: Int) -> case u0 of { _ALG_ I# (u2 :: Int#) -> case u1 of { _ALG_ I# (u3 :: Int#) -> _#_ geInt# [] [u2, u3]; _NO_DEFLT_ }; _NO_DEFLT_ } _N_,
- (>) = _A_ 2 _U_ 11 _N_ _S_ "U(P)U(P)" {_A_ 2 _U_ 22 _N_ _N_ _F_ _IF_ARGS_ 0 2 XX 1 \ (u0 :: Int#) (u1 :: Int#) -> _#_ gtInt# [] [u0, u1] _N_} _F_ _IF_ARGS_ 0 2 CC 3 \ (u0 :: Int) (u1 :: Int) -> case u0 of { _ALG_ I# (u2 :: Int#) -> case u1 of { _ALG_ I# (u3 :: Int#) -> _#_ gtInt# [] [u2, u3]; _NO_DEFLT_ }; _NO_DEFLT_ } _N_,
- max = _A_ 2 _U_ 11 _N_ _S_ "U(P)U(P)" {_A_ 2 _U_ 22 _N_ _N_ _N_ _N_} _N_ _N_,
- min = _A_ 2 _U_ 11 _N_ _S_ "U(P)U(P)" {_A_ 2 _U_ 22 _N_ _N_ _N_ _N_} _N_ _N_,
- _tagCmp = _A_ 2 _U_ 11 _N_ _S_ "U(P)U(P)" {_A_ 2 _U_ 22 _N_ _N_ _N_ _N_} _N_ _N_ #-}
+ (<) = { _A_ 2 _U_ 11 _N_ _S_ "U(P)U(P)" {_A_ 2 _U_ 22 _N_ _N_ _F_ _IF_ARGS_ 0 2 XX 1 \ (u0 :: Int#) (u1 :: Int#) -> _#_ ltInt# [] [u0, u1] _N_} _F_ _IF_ARGS_ 0 2 CC 3 \ (u0 :: Int) (u1 :: Int) -> case u0 of { _ALG_ I# (u2 :: Int#) -> case u1 of { _ALG_ I# (u3 :: Int#) -> _#_ ltInt# [] [u2, u3]; _NO_DEFLT_ }; _NO_DEFLT_ } _N_ },
+ (<=) = { _A_ 2 _U_ 11 _N_ _S_ "U(P)U(P)" {_A_ 2 _U_ 22 _N_ _N_ _F_ _IF_ARGS_ 0 2 XX 1 \ (u0 :: Int#) (u1 :: Int#) -> _#_ leInt# [] [u0, u1] _N_} _F_ _IF_ARGS_ 0 2 CC 3 \ (u0 :: Int) (u1 :: Int) -> case u0 of { _ALG_ I# (u2 :: Int#) -> case u1 of { _ALG_ I# (u3 :: Int#) -> _#_ leInt# [] [u2, u3]; _NO_DEFLT_ }; _NO_DEFLT_ } _N_ },
+ (>=) = { _A_ 2 _U_ 11 _N_ _S_ "U(P)U(P)" {_A_ 2 _U_ 22 _N_ _N_ _F_ _IF_ARGS_ 0 2 XX 1 \ (u0 :: Int#) (u1 :: Int#) -> _#_ geInt# [] [u0, u1] _N_} _F_ _IF_ARGS_ 0 2 CC 3 \ (u0 :: Int) (u1 :: Int) -> case u0 of { _ALG_ I# (u2 :: Int#) -> case u1 of { _ALG_ I# (u3 :: Int#) -> _#_ geInt# [] [u2, u3]; _NO_DEFLT_ }; _NO_DEFLT_ } _N_ },
+ (>) = { _A_ 2 _U_ 11 _N_ _S_ "U(P)U(P)" {_A_ 2 _U_ 22 _N_ _N_ _F_ _IF_ARGS_ 0 2 XX 1 \ (u0 :: Int#) (u1 :: Int#) -> _#_ gtInt# [] [u0, u1] _N_} _F_ _IF_ARGS_ 0 2 CC 3 \ (u0 :: Int) (u1 :: Int) -> case u0 of { _ALG_ I# (u2 :: Int#) -> case u1 of { _ALG_ I# (u3 :: Int#) -> _#_ gtInt# [] [u2, u3]; _NO_DEFLT_ }; _NO_DEFLT_ } _N_ },
+ max = { _A_ 2 _U_ 11 _N_ _S_ "U(P)U(P)" {_A_ 2 _U_ 22 _N_ _N_ _N_ _N_} _N_ _N_ },
+ min = { _A_ 2 _U_ 11 _N_ _S_ "U(P)U(P)" {_A_ 2 _U_ 22 _N_ _N_ _N_ _N_} _N_ _N_ },
+ _tagCmp = { _A_ 2 _U_ 11 _N_ _S_ "U(P)U(P)" {_A_ 2 _U_ 22 _N_ _N_ _N_ _N_} _N_ _N_ } #-}
instance Ord Integer
{-# GHC_PRAGMA _M_ PreludeCore {-dfun-} _A_ 0 _N_ _N_ _N_ _F_ _IF_ARGS_ 0 0 X 9 _!_ _TUP_8 [{{Eq Integer}}, (Integer -> Integer -> Bool), (Integer -> Integer -> Bool), (Integer -> Integer -> Bool), (Integer -> Integer -> Bool), (Integer -> Integer -> Integer), (Integer -> Integer -> Integer), (Integer -> Integer -> _CMP_TAG)] [_DFUN_ Eq (Integer), _CONSTM_ Ord (<) (Integer), _CONSTM_ Ord (<=) (Integer), _CONSTM_ Ord (>=) (Integer), _CONSTM_ Ord (>) (Integer), _CONSTM_ Ord max (Integer), _CONSTM_ Ord min (Integer), _CONSTM_ Ord _tagCmp (Integer)] _N_
- (<) = _A_ 2 _U_ 11 _N_ _S_ "U(PPP)U(PPP)" {_A_ 4 _U_ 2221 _N_ _N_ _F_ _IF_ARGS_ 0 4 XXXC 3 \ (u0 :: Int#) (u1 :: Int#) (u2 :: ByteArray#) (u3 :: Integer) -> case u3 of { _ALG_ J# (u4 :: Int#) (u5 :: Int#) (u6 :: ByteArray#) -> case _#_ cmpInteger# [] [u0, u1, u2, u4, u5, u6] of { _PRIM_ (u7 :: Int#) -> _#_ ltInt# [] [u7, 0#] }; _NO_DEFLT_ } _N_} _F_ _IF_ARGS_ 0 2 CC 4 \ (u0 :: Integer) (u1 :: Integer) -> case u0 of { _ALG_ J# (u2 :: Int#) (u3 :: Int#) (u4 :: ByteArray#) -> case u1 of { _ALG_ J# (u5 :: Int#) (u6 :: Int#) (u7 :: ByteArray#) -> case _#_ cmpInteger# [] [u2, u3, u4, u5, u6, u7] of { _PRIM_ (u8 :: Int#) -> _#_ ltInt# [] [u8, 0#] }; _NO_DEFLT_ }; _NO_DEFLT_ } _N_,
- (<=) = _A_ 2 _U_ 11 _N_ _S_ "U(PPP)U(PPP)" {_A_ 4 _U_ 2221 _N_ _N_ _F_ _IF_ARGS_ 0 4 XXXC 3 \ (u0 :: Int#) (u1 :: Int#) (u2 :: ByteArray#) (u3 :: Integer) -> case u3 of { _ALG_ J# (u4 :: Int#) (u5 :: Int#) (u6 :: ByteArray#) -> case _#_ cmpInteger# [] [u0, u1, u2, u4, u5, u6] of { _PRIM_ (u7 :: Int#) -> _#_ leInt# [] [u7, 0#] }; _NO_DEFLT_ } _N_} _F_ _IF_ARGS_ 0 2 CC 4 \ (u0 :: Integer) (u1 :: Integer) -> case u0 of { _ALG_ J# (u2 :: Int#) (u3 :: Int#) (u4 :: ByteArray#) -> case u1 of { _ALG_ J# (u5 :: Int#) (u6 :: Int#) (u7 :: ByteArray#) -> case _#_ cmpInteger# [] [u2, u3, u4, u5, u6, u7] of { _PRIM_ (u8 :: Int#) -> _#_ leInt# [] [u8, 0#] }; _NO_DEFLT_ }; _NO_DEFLT_ } _N_,
- (>=) = _A_ 2 _U_ 11 _N_ _S_ "U(PPP)U(PPP)" {_A_ 4 _U_ 2221 _N_ _N_ _F_ _IF_ARGS_ 0 4 XXXC 3 \ (u0 :: Int#) (u1 :: Int#) (u2 :: ByteArray#) (u3 :: Integer) -> case u3 of { _ALG_ J# (u4 :: Int#) (u5 :: Int#) (u6 :: ByteArray#) -> case _#_ cmpInteger# [] [u0, u1, u2, u4, u5, u6] of { _PRIM_ (u7 :: Int#) -> _#_ geInt# [] [u7, 0#] }; _NO_DEFLT_ } _N_} _F_ _IF_ARGS_ 0 2 CC 4 \ (u0 :: Integer) (u1 :: Integer) -> case u0 of { _ALG_ J# (u2 :: Int#) (u3 :: Int#) (u4 :: ByteArray#) -> case u1 of { _ALG_ J# (u5 :: Int#) (u6 :: Int#) (u7 :: ByteArray#) -> case _#_ cmpInteger# [] [u2, u3, u4, u5, u6, u7] of { _PRIM_ (u8 :: Int#) -> _#_ geInt# [] [u8, 0#] }; _NO_DEFLT_ }; _NO_DEFLT_ } _N_,
- (>) = _A_ 2 _U_ 11 _N_ _S_ "U(PPP)U(PPP)" {_A_ 4 _U_ 2221 _N_ _N_ _F_ _IF_ARGS_ 0 4 XXXC 3 \ (u0 :: Int#) (u1 :: Int#) (u2 :: ByteArray#) (u3 :: Integer) -> case u3 of { _ALG_ J# (u4 :: Int#) (u5 :: Int#) (u6 :: ByteArray#) -> case _#_ cmpInteger# [] [u0, u1, u2, u4, u5, u6] of { _PRIM_ (u7 :: Int#) -> _#_ gtInt# [] [u7, 0#] }; _NO_DEFLT_ } _N_} _F_ _IF_ARGS_ 0 2 CC 4 \ (u0 :: Integer) (u1 :: Integer) -> case u0 of { _ALG_ J# (u2 :: Int#) (u3 :: Int#) (u4 :: ByteArray#) -> case u1 of { _ALG_ J# (u5 :: Int#) (u6 :: Int#) (u7 :: ByteArray#) -> case _#_ cmpInteger# [] [u2, u3, u4, u5, u6, u7] of { _PRIM_ (u8 :: Int#) -> _#_ gtInt# [] [u8, 0#] }; _NO_DEFLT_ }; _NO_DEFLT_ } _N_,
- max = _A_ 2 _U_ 11 _N_ _S_ "U(PPP)U(PPP)" {_A_ 4 _U_ 2221 _N_ _N_ _N_ _N_} _N_ _N_,
- min = _A_ 2 _U_ 11 _N_ _S_ "U(PPP)U(PPP)" {_A_ 4 _U_ 2221 _N_ _N_ _N_ _N_} _N_ _N_,
- _tagCmp = _A_ 2 _U_ 11 _N_ _S_ "U(PPP)U(PPP)" {_A_ 4 _U_ 2221 _N_ _N_ _N_ _N_} _N_ _N_ #-}
+ (<) = { _A_ 2 _U_ 11 _N_ _S_ "U(PPP)U(PPP)" {_A_ 4 _U_ 2221 _N_ _N_ _F_ _IF_ARGS_ 0 4 XXXC 3 \ (u0 :: Int#) (u1 :: Int#) (u2 :: ByteArray#) (u3 :: Integer) -> case u3 of { _ALG_ J# (u4 :: Int#) (u5 :: Int#) (u6 :: ByteArray#) -> case _#_ cmpInteger# [] [u0, u1, u2, u4, u5, u6] of { _PRIM_ (u7 :: Int#) -> _#_ ltInt# [] [u7, 0#] }; _NO_DEFLT_ } _N_} _F_ _IF_ARGS_ 0 2 CC 4 \ (u0 :: Integer) (u1 :: Integer) -> case u0 of { _ALG_ J# (u2 :: Int#) (u3 :: Int#) (u4 :: ByteArray#) -> case u1 of { _ALG_ J# (u5 :: Int#) (u6 :: Int#) (u7 :: ByteArray#) -> case _#_ cmpInteger# [] [u2, u3, u4, u5, u6, u7] of { _PRIM_ (u8 :: Int#) -> _#_ ltInt# [] [u8, 0#] }; _NO_DEFLT_ }; _NO_DEFLT_ } _N_ },
+ (<=) = { _A_ 2 _U_ 11 _N_ _S_ "U(PPP)U(PPP)" {_A_ 4 _U_ 2221 _N_ _N_ _F_ _IF_ARGS_ 0 4 XXXC 3 \ (u0 :: Int#) (u1 :: Int#) (u2 :: ByteArray#) (u3 :: Integer) -> case u3 of { _ALG_ J# (u4 :: Int#) (u5 :: Int#) (u6 :: ByteArray#) -> case _#_ cmpInteger# [] [u0, u1, u2, u4, u5, u6] of { _PRIM_ (u7 :: Int#) -> _#_ leInt# [] [u7, 0#] }; _NO_DEFLT_ } _N_} _F_ _IF_ARGS_ 0 2 CC 4 \ (u0 :: Integer) (u1 :: Integer) -> case u0 of { _ALG_ J# (u2 :: Int#) (u3 :: Int#) (u4 :: ByteArray#) -> case u1 of { _ALG_ J# (u5 :: Int#) (u6 :: Int#) (u7 :: ByteArray#) -> case _#_ cmpInteger# [] [u2, u3, u4, u5, u6, u7] of { _PRIM_ (u8 :: Int#) -> _#_ leInt# [] [u8, 0#] }; _NO_DEFLT_ }; _NO_DEFLT_ } _N_ },
+ (>=) = { _A_ 2 _U_ 11 _N_ _S_ "U(PPP)U(PPP)" {_A_ 4 _U_ 2221 _N_ _N_ _F_ _IF_ARGS_ 0 4 XXXC 3 \ (u0 :: Int#) (u1 :: Int#) (u2 :: ByteArray#) (u3 :: Integer) -> case u3 of { _ALG_ J# (u4 :: Int#) (u5 :: Int#) (u6 :: ByteArray#) -> case _#_ cmpInteger# [] [u0, u1, u2, u4, u5, u6] of { _PRIM_ (u7 :: Int#) -> _#_ geInt# [] [u7, 0#] }; _NO_DEFLT_ } _N_} _F_ _IF_ARGS_ 0 2 CC 4 \ (u0 :: Integer) (u1 :: Integer) -> case u0 of { _ALG_ J# (u2 :: Int#) (u3 :: Int#) (u4 :: ByteArray#) -> case u1 of { _ALG_ J# (u5 :: Int#) (u6 :: Int#) (u7 :: ByteArray#) -> case _#_ cmpInteger# [] [u2, u3, u4, u5, u6, u7] of { _PRIM_ (u8 :: Int#) -> _#_ geInt# [] [u8, 0#] }; _NO_DEFLT_ }; _NO_DEFLT_ } _N_ },
+ (>) = { _A_ 2 _U_ 11 _N_ _S_ "U(PPP)U(PPP)" {_A_ 4 _U_ 2221 _N_ _N_ _F_ _IF_ARGS_ 0 4 XXXC 3 \ (u0 :: Int#) (u1 :: Int#) (u2 :: ByteArray#) (u3 :: Integer) -> case u3 of { _ALG_ J# (u4 :: Int#) (u5 :: Int#) (u6 :: ByteArray#) -> case _#_ cmpInteger# [] [u0, u1, u2, u4, u5, u6] of { _PRIM_ (u7 :: Int#) -> _#_ gtInt# [] [u7, 0#] }; _NO_DEFLT_ } _N_} _F_ _IF_ARGS_ 0 2 CC 4 \ (u0 :: Integer) (u1 :: Integer) -> case u0 of { _ALG_ J# (u2 :: Int#) (u3 :: Int#) (u4 :: ByteArray#) -> case u1 of { _ALG_ J# (u5 :: Int#) (u6 :: Int#) (u7 :: ByteArray#) -> case _#_ cmpInteger# [] [u2, u3, u4, u5, u6, u7] of { _PRIM_ (u8 :: Int#) -> _#_ gtInt# [] [u8, 0#] }; _NO_DEFLT_ }; _NO_DEFLT_ } _N_ },
+ max = { _A_ 2 _U_ 11 _N_ _S_ "U(PPP)U(PPP)" {_A_ 4 _U_ 2221 _N_ _N_ _N_ _N_} _N_ _N_ },
+ min = { _A_ 2 _U_ 11 _N_ _S_ "U(PPP)U(PPP)" {_A_ 4 _U_ 2221 _N_ _N_ _N_ _N_} _N_ _N_ },
+ _tagCmp = { _A_ 2 _U_ 11 _N_ _S_ "U(PPP)U(PPP)" {_A_ 4 _U_ 2221 _N_ _N_ _N_ _N_} _N_ _N_ } #-}
instance Integral a => Ord (Ratio a)
{-# GHC_PRAGMA _M_ PreludeRatio {-dfun-} _A_ 2 _U_ 22 _N_ _N_ _N_ _N_ #-}
instance Ord (Ratio Integer)
{-# GHC_PRAGMA _M_ PreludeRatio {-dfun-} _A_ 0 _N_ _N_ _N_ _F_ _IF_ARGS_ 0 0 X 9 _!_ _TUP_8 [{{Eq (Ratio Integer)}}, (Ratio Integer -> Ratio Integer -> Bool), (Ratio Integer -> Ratio Integer -> Bool), (Ratio Integer -> Ratio Integer -> Bool), (Ratio Integer -> Ratio Integer -> Bool), (Ratio Integer -> Ratio Integer -> Ratio Integer), (Ratio Integer -> Ratio Integer -> Ratio Integer), (Ratio Integer -> Ratio Integer -> _CMP_TAG)] [_DFUN_ Eq (Ratio Integer), _CONSTM_ Ord (<) (Ratio Integer), _CONSTM_ Ord (<=) (Ratio Integer), _CONSTM_ Ord (>=) (Ratio Integer), _CONSTM_ Ord (>) (Ratio Integer), _CONSTM_ Ord max (Ratio Integer), _CONSTM_ Ord min (Ratio Integer), _CONSTM_ Ord _tagCmp (Ratio Integer)] _N_
- (<) = _A_ 2 _U_ 11 _N_ _S_ "U(U(PPP)U(PPP))U(U(PPP)U(PPP))" {_A_ 5 _U_ 22221 _N_ _N_ _N_ _N_} _N_ _N_,
- (<=) = _A_ 2 _U_ 11 _N_ _S_ "U(U(PPP)U(PPP))U(U(PPP)U(PPP))" {_A_ 5 _U_ 22221 _N_ _N_ _N_ _N_} _N_ _N_,
- (>=) = _A_ 2 _U_ 11 _N_ _S_ "U(U(PPP)U(PPP))U(U(PPP)U(PPP))" {_A_ 5 _U_ 22221 _N_ _N_ _N_ _N_} _N_ _N_,
- (>) = _A_ 2 _U_ 11 _N_ _S_ "U(U(PPP)U(PPP))U(U(PPP)U(PPP))" {_A_ 5 _U_ 22221 _N_ _N_ _N_ _N_} _N_ _N_,
- max = _A_ 2 _U_ 12 _N_ _S_ "U(U(PPP)U(PPP))U(U(PPP)U(PPP))" {_A_ 5 _U_ 22222 _N_ _N_ _N_ _N_} _N_ _N_,
- min = _A_ 2 _U_ 12 _N_ _S_ "U(U(PPP)U(PPP))U(U(PPP)U(PPP))" {_A_ 5 _U_ 22222 _N_ _N_ _N_ _N_} _N_ _N_,
- _tagCmp = _A_ 2 _U_ 11 _N_ _S_ "U(U(PPP)U(PPP))U(U(PPP)U(PPP))" {_A_ 5 _U_ 22221 _N_ _N_ _N_ _N_} _N_ _N_ #-}
+ (<) = { _A_ 2 _U_ 11 _N_ _S_ "U(U(PPP)U(PPP))U(U(PPP)U(PPP))" {_A_ 5 _U_ 22221 _N_ _N_ _N_ _N_} _N_ _N_ },
+ (<=) = { _A_ 2 _U_ 11 _N_ _S_ "U(U(PPP)U(PPP))U(U(PPP)U(PPP))" {_A_ 5 _U_ 22221 _N_ _N_ _N_ _N_} _N_ _N_ },
+ (>=) = { _A_ 2 _U_ 11 _N_ _S_ "U(U(PPP)U(PPP))U(U(PPP)U(PPP))" {_A_ 5 _U_ 22221 _N_ _N_ _N_ _N_} _N_ _N_ },
+ (>) = { _A_ 2 _U_ 11 _N_ _S_ "U(U(PPP)U(PPP))U(U(PPP)U(PPP))" {_A_ 5 _U_ 22221 _N_ _N_ _N_ _N_} _N_ _N_ },
+ max = { _A_ 2 _U_ 12 _N_ _S_ "U(U(PPP)U(PPP))U(U(PPP)U(PPP))" {_A_ 5 _U_ 22222 _N_ _N_ _N_ _N_} _N_ _N_ },
+ min = { _A_ 2 _U_ 12 _N_ _S_ "U(U(PPP)U(PPP))U(U(PPP)U(PPP))" {_A_ 5 _U_ 22222 _N_ _N_ _N_ _N_} _N_ _N_ },
+ _tagCmp = { _A_ 2 _U_ 11 _N_ _S_ "U(U(PPP)U(PPP))U(U(PPP)U(PPP))" {_A_ 5 _U_ 22221 _N_ _N_ _N_ _N_} _N_ _N_ } #-}
instance Ord a => Ord [a]
{-# GHC_PRAGMA _M_ PreludeBuiltin {-dfun-} _A_ 2 _U_ 12 _N_ _N_ _N_ _N_ #-}
+instance Ord [Bool]
+ {-# GHC_PRAGMA _M_ PreludeBuiltin {-dfun-} _A_ 0 _N_ _N_ _N_ _F_ _IF_ARGS_ 0 0 X 9 _!_ _TUP_8 [{{Eq [Bool]}}, ([Bool] -> [Bool] -> Bool), ([Bool] -> [Bool] -> Bool), ([Bool] -> [Bool] -> Bool), ([Bool] -> [Bool] -> Bool), ([Bool] -> [Bool] -> [Bool]), ([Bool] -> [Bool] -> [Bool]), ([Bool] -> [Bool] -> _CMP_TAG)] [_DFUN_ Eq ([Bool]), _CONSTM_ Ord (<) ([Bool]), _CONSTM_ Ord (<=) ([Bool]), _CONSTM_ Ord (>=) ([Bool]), _CONSTM_ Ord (>) ([Bool]), _CONSTM_ Ord max ([Bool]), _CONSTM_ Ord min ([Bool]), _CONSTM_ Ord _tagCmp ([Bool])] _N_
+ (<) = { _A_ 2 _U_ 11 _N_ _S_ "SS" _N_ _N_ },
+ (<=) = { _A_ 2 _U_ 11 _N_ _S_ "SS" _N_ _N_ },
+ (>=) = { _A_ 2 _U_ 11 _N_ _S_ "SS" _N_ _N_ },
+ (>) = { _A_ 2 _U_ 11 _N_ _S_ "SS" _N_ _N_ },
+ max = { _A_ 2 _U_ 22 _N_ _S_ "SS" _N_ _N_ },
+ min = { _A_ 2 _U_ 22 _N_ _S_ "SS" _N_ _N_ },
+ _tagCmp = { _A_ 2 _U_ 11 _N_ _S_ "SS" _N_ _N_ } #-}
instance Ord [Char]
{-# GHC_PRAGMA _M_ PreludeBuiltin {-dfun-} _A_ 0 _N_ _N_ _N_ _F_ _IF_ARGS_ 0 0 X 9 _!_ _TUP_8 [{{Eq [Char]}}, ([Char] -> [Char] -> Bool), ([Char] -> [Char] -> Bool), ([Char] -> [Char] -> Bool), ([Char] -> [Char] -> Bool), ([Char] -> [Char] -> [Char]), ([Char] -> [Char] -> [Char]), ([Char] -> [Char] -> _CMP_TAG)] [_DFUN_ Eq ([Char]), _CONSTM_ Ord (<) ([Char]), _CONSTM_ Ord (<=) ([Char]), _CONSTM_ Ord (>=) ([Char]), _CONSTM_ Ord (>) ([Char]), _CONSTM_ Ord max ([Char]), _CONSTM_ Ord min ([Char]), _CONSTM_ Ord _tagCmp ([Char])] _N_
- (<) = _A_ 2 _U_ 11 _N_ _S_ "SS" _N_ _N_,
- (<=) = _A_ 2 _U_ 11 _N_ _S_ "SS" _N_ _N_,
- (>=) = _A_ 2 _U_ 11 _N_ _S_ "SS" _N_ _N_,
- (>) = _A_ 2 _U_ 11 _N_ _S_ "SS" _N_ _N_,
- max = _A_ 2 _U_ 22 _N_ _S_ "SS" _N_ _N_,
- min = _A_ 2 _U_ 22 _N_ _S_ "SS" _N_ _N_,
- _tagCmp = _A_ 2 _U_ 11 _N_ _S_ "SS" _N_ _N_ #-}
+ (<) = { _A_ 2 _U_ 11 _N_ _S_ "SS" _N_ _N_ },
+ (<=) = { _A_ 2 _U_ 11 _N_ _S_ "SS" _N_ _N_ },
+ (>=) = { _A_ 2 _U_ 11 _N_ _S_ "SS" _N_ _N_ },
+ (>) = { _A_ 2 _U_ 11 _N_ _S_ "SS" _N_ _N_ },
+ max = { _A_ 2 _U_ 22 _N_ _S_ "SS" _N_ _N_ },
+ min = { _A_ 2 _U_ 22 _N_ _S_ "SS" _N_ _N_ },
+ _tagCmp = { _A_ 2 _U_ 11 _N_ _S_ "SS" _N_ _N_ } #-}
+instance Ord [Double]
+ {-# GHC_PRAGMA _M_ PreludeBuiltin {-dfun-} _A_ 0 _N_ _N_ _N_ _F_ _IF_ARGS_ 0 0 X 9 _!_ _TUP_8 [{{Eq [Double]}}, ([Double] -> [Double] -> Bool), ([Double] -> [Double] -> Bool), ([Double] -> [Double] -> Bool), ([Double] -> [Double] -> Bool), ([Double] -> [Double] -> [Double]), ([Double] -> [Double] -> [Double]), ([Double] -> [Double] -> _CMP_TAG)] [_DFUN_ Eq ([Double]), _CONSTM_ Ord (<) ([Double]), _CONSTM_ Ord (<=) ([Double]), _CONSTM_ Ord (>=) ([Double]), _CONSTM_ Ord (>) ([Double]), _CONSTM_ Ord max ([Double]), _CONSTM_ Ord min ([Double]), _CONSTM_ Ord _tagCmp ([Double])] _N_
+ (<) = { _A_ 2 _U_ 11 _N_ _S_ "SS" _N_ _N_ },
+ (<=) = { _A_ 2 _U_ 11 _N_ _S_ "SS" _N_ _N_ },
+ (>=) = { _A_ 2 _U_ 11 _N_ _S_ "SS" _N_ _N_ },
+ (>) = { _A_ 2 _U_ 11 _N_ _S_ "SS" _N_ _N_ },
+ max = { _A_ 2 _U_ 22 _N_ _S_ "SS" _N_ _N_ },
+ min = { _A_ 2 _U_ 22 _N_ _S_ "SS" _N_ _N_ },
+ _tagCmp = { _A_ 2 _U_ 11 _N_ _S_ "SS" _N_ _N_ } #-}
instance Ord [Int]
{-# GHC_PRAGMA _M_ PreludeBuiltin {-dfun-} _A_ 0 _N_ _N_ _N_ _F_ _IF_ARGS_ 0 0 X 9 _!_ _TUP_8 [{{Eq [Int]}}, ([Int] -> [Int] -> Bool), ([Int] -> [Int] -> Bool), ([Int] -> [Int] -> Bool), ([Int] -> [Int] -> Bool), ([Int] -> [Int] -> [Int]), ([Int] -> [Int] -> [Int]), ([Int] -> [Int] -> _CMP_TAG)] [_DFUN_ Eq ([Int]), _CONSTM_ Ord (<) ([Int]), _CONSTM_ Ord (<=) ([Int]), _CONSTM_ Ord (>=) ([Int]), _CONSTM_ Ord (>) ([Int]), _CONSTM_ Ord max ([Int]), _CONSTM_ Ord min ([Int]), _CONSTM_ Ord _tagCmp ([Int])] _N_
- (<) = _A_ 2 _U_ 11 _N_ _S_ "SS" _N_ _N_,
- (<=) = _A_ 2 _U_ 11 _N_ _S_ "SS" _N_ _N_,
- (>=) = _A_ 2 _U_ 11 _N_ _S_ "SS" _N_ _N_,
- (>) = _A_ 2 _U_ 11 _N_ _S_ "SS" _N_ _N_,
- max = _A_ 2 _U_ 22 _N_ _S_ "SS" _N_ _N_,
- min = _A_ 2 _U_ 22 _N_ _S_ "SS" _N_ _N_,
- _tagCmp = _A_ 2 _U_ 11 _N_ _S_ "SS" _N_ _N_ #-}
+ (<) = { _A_ 2 _U_ 11 _N_ _S_ "SS" _N_ _N_ },
+ (<=) = { _A_ 2 _U_ 11 _N_ _S_ "SS" _N_ _N_ },
+ (>=) = { _A_ 2 _U_ 11 _N_ _S_ "SS" _N_ _N_ },
+ (>) = { _A_ 2 _U_ 11 _N_ _S_ "SS" _N_ _N_ },
+ max = { _A_ 2 _U_ 22 _N_ _S_ "SS" _N_ _N_ },
+ min = { _A_ 2 _U_ 22 _N_ _S_ "SS" _N_ _N_ },
+ _tagCmp = { _A_ 2 _U_ 11 _N_ _S_ "SS" _N_ _N_ } #-}
+instance Ord [Integer]
+ {-# GHC_PRAGMA _M_ PreludeBuiltin {-dfun-} _A_ 0 _N_ _N_ _N_ _F_ _IF_ARGS_ 0 0 X 9 _!_ _TUP_8 [{{Eq [Integer]}}, ([Integer] -> [Integer] -> Bool), ([Integer] -> [Integer] -> Bool), ([Integer] -> [Integer] -> Bool), ([Integer] -> [Integer] -> Bool), ([Integer] -> [Integer] -> [Integer]), ([Integer] -> [Integer] -> [Integer]), ([Integer] -> [Integer] -> _CMP_TAG)] [_DFUN_ Eq ([Integer]), _CONSTM_ Ord (<) ([Integer]), _CONSTM_ Ord (<=) ([Integer]), _CONSTM_ Ord (>=) ([Integer]), _CONSTM_ Ord (>) ([Integer]), _CONSTM_ Ord max ([Integer]), _CONSTM_ Ord min ([Integer]), _CONSTM_ Ord _tagCmp ([Integer])] _N_
+ (<) = { _A_ 2 _U_ 11 _N_ _S_ "SS" _N_ _N_ },
+ (<=) = { _A_ 2 _U_ 11 _N_ _S_ "SS" _N_ _N_ },
+ (>=) = { _A_ 2 _U_ 11 _N_ _S_ "SS" _N_ _N_ },
+ (>) = { _A_ 2 _U_ 11 _N_ _S_ "SS" _N_ _N_ },
+ max = { _A_ 2 _U_ 22 _N_ _S_ "SS" _N_ _N_ },
+ min = { _A_ 2 _U_ 22 _N_ _S_ "SS" _N_ _N_ },
+ _tagCmp = { _A_ 2 _U_ 11 _N_ _S_ "SS" _N_ _N_ } #-}
+instance Ord [[Char]]
+ {-# GHC_PRAGMA _M_ PreludeBuiltin {-dfun-} _A_ 0 _N_ _N_ _N_ _F_ _IF_ARGS_ 0 0 X 9 _!_ _TUP_8 [{{Eq [[Char]]}}, ([[Char]] -> [[Char]] -> Bool), ([[Char]] -> [[Char]] -> Bool), ([[Char]] -> [[Char]] -> Bool), ([[Char]] -> [[Char]] -> Bool), ([[Char]] -> [[Char]] -> [[Char]]), ([[Char]] -> [[Char]] -> [[Char]]), ([[Char]] -> [[Char]] -> _CMP_TAG)] [_DFUN_ Eq ([[Char]]), _CONSTM_ Ord (<) ([[Char]]), _CONSTM_ Ord (<=) ([[Char]]), _CONSTM_ Ord (>=) ([[Char]]), _CONSTM_ Ord (>) ([[Char]]), _CONSTM_ Ord max ([[Char]]), _CONSTM_ Ord min ([[Char]]), _CONSTM_ Ord _tagCmp ([[Char]])] _N_
+ (<) = { _A_ 2 _U_ 11 _N_ _S_ "SS" _N_ _N_ },
+ (<=) = { _A_ 2 _U_ 11 _N_ _S_ "SS" _N_ _N_ },
+ (>=) = { _A_ 2 _U_ 11 _N_ _S_ "SS" _N_ _N_ },
+ (>) = { _A_ 2 _U_ 11 _N_ _S_ "SS" _N_ _N_ },
+ max = { _A_ 2 _U_ 22 _N_ _S_ "SS" _N_ _N_ },
+ min = { _A_ 2 _U_ 22 _N_ _S_ "SS" _N_ _N_ },
+ _tagCmp = { _A_ 2 _U_ 11 _N_ _S_ "SS" _N_ _N_ } #-}
+instance Ord [[Int]]
+ {-# GHC_PRAGMA _M_ PreludeBuiltin {-dfun-} _A_ 0 _N_ _N_ _N_ _F_ _IF_ARGS_ 0 0 X 9 _!_ _TUP_8 [{{Eq [[Int]]}}, ([[Int]] -> [[Int]] -> Bool), ([[Int]] -> [[Int]] -> Bool), ([[Int]] -> [[Int]] -> Bool), ([[Int]] -> [[Int]] -> Bool), ([[Int]] -> [[Int]] -> [[Int]]), ([[Int]] -> [[Int]] -> [[Int]]), ([[Int]] -> [[Int]] -> _CMP_TAG)] [_DFUN_ Eq ([[Int]]), _CONSTM_ Ord (<) ([[Int]]), _CONSTM_ Ord (<=) ([[Int]]), _CONSTM_ Ord (>=) ([[Int]]), _CONSTM_ Ord (>) ([[Int]]), _CONSTM_ Ord max ([[Int]]), _CONSTM_ Ord min ([[Int]]), _CONSTM_ Ord _tagCmp ([[Int]])] _N_
+ (<) = { _A_ 2 _U_ 11 _N_ _S_ "SS" _N_ _N_ },
+ (<=) = { _A_ 2 _U_ 11 _N_ _S_ "SS" _N_ _N_ },
+ (>=) = { _A_ 2 _U_ 11 _N_ _S_ "SS" _N_ _N_ },
+ (>) = { _A_ 2 _U_ 11 _N_ _S_ "SS" _N_ _N_ },
+ max = { _A_ 2 _U_ 22 _N_ _S_ "SS" _N_ _N_ },
+ min = { _A_ 2 _U_ 22 _N_ _S_ "SS" _N_ _N_ },
+ _tagCmp = { _A_ 2 _U_ 11 _N_ _S_ "SS" _N_ _N_ } #-}
instance Ord _Addr
{-# GHC_PRAGMA _M_ PreludeCore {-dfun-} _A_ 0 _N_ _N_ _N_ _F_ _IF_ARGS_ 0 0 X 9 _!_ _TUP_8 [{{Eq _Addr}}, (_Addr -> _Addr -> Bool), (_Addr -> _Addr -> Bool), (_Addr -> _Addr -> Bool), (_Addr -> _Addr -> Bool), (_Addr -> _Addr -> _Addr), (_Addr -> _Addr -> _Addr), (_Addr -> _Addr -> _CMP_TAG)] [_DFUN_ Eq (_Addr), _CONSTM_ Ord (<) (_Addr), _CONSTM_ Ord (<=) (_Addr), _CONSTM_ Ord (>=) (_Addr), _CONSTM_ Ord (>) (_Addr), _CONSTM_ Ord max (_Addr), _CONSTM_ Ord min (_Addr), _CONSTM_ Ord _tagCmp (_Addr)] _N_
- (<) = _A_ 2 _U_ 11 _N_ _S_ "U(P)U(P)" {_A_ 2 _U_ 22 _N_ _N_ _F_ _IF_ARGS_ 0 2 XX 1 \ (u0 :: Addr#) (u1 :: Addr#) -> _#_ ltAddr# [] [u0, u1] _N_} _F_ _IF_ARGS_ 0 2 CC 3 \ (u0 :: _Addr) (u1 :: _Addr) -> case u0 of { _ALG_ A# (u2 :: Addr#) -> case u1 of { _ALG_ A# (u3 :: Addr#) -> _#_ ltAddr# [] [u2, u3]; _NO_DEFLT_ }; _NO_DEFLT_ } _N_,
- (<=) = _A_ 2 _U_ 11 _N_ _S_ "U(P)U(P)" {_A_ 2 _U_ 22 _N_ _N_ _F_ _IF_ARGS_ 0 2 XX 1 \ (u0 :: Addr#) (u1 :: Addr#) -> _#_ leAddr# [] [u0, u1] _N_} _F_ _IF_ARGS_ 0 2 CC 3 \ (u0 :: _Addr) (u1 :: _Addr) -> case u0 of { _ALG_ A# (u2 :: Addr#) -> case u1 of { _ALG_ A# (u3 :: Addr#) -> _#_ leAddr# [] [u2, u3]; _NO_DEFLT_ }; _NO_DEFLT_ } _N_,
- (>=) = _A_ 2 _U_ 11 _N_ _S_ "U(P)U(P)" {_A_ 2 _U_ 22 _N_ _N_ _F_ _IF_ARGS_ 0 2 XX 1 \ (u0 :: Addr#) (u1 :: Addr#) -> _#_ geAddr# [] [u0, u1] _N_} _F_ _IF_ARGS_ 0 2 CC 3 \ (u0 :: _Addr) (u1 :: _Addr) -> case u0 of { _ALG_ A# (u2 :: Addr#) -> case u1 of { _ALG_ A# (u3 :: Addr#) -> _#_ geAddr# [] [u2, u3]; _NO_DEFLT_ }; _NO_DEFLT_ } _N_,
- (>) = _A_ 2 _U_ 11 _N_ _S_ "U(P)U(P)" {_A_ 2 _U_ 22 _N_ _N_ _F_ _IF_ARGS_ 0 2 XX 1 \ (u0 :: Addr#) (u1 :: Addr#) -> _#_ gtAddr# [] [u0, u1] _N_} _F_ _IF_ARGS_ 0 2 CC 3 \ (u0 :: _Addr) (u1 :: _Addr) -> case u0 of { _ALG_ A# (u2 :: Addr#) -> case u1 of { _ALG_ A# (u3 :: Addr#) -> _#_ gtAddr# [] [u2, u3]; _NO_DEFLT_ }; _NO_DEFLT_ } _N_,
- max = _A_ 2 _U_ 11 _N_ _S_ "U(P)U(P)" {_A_ 2 _U_ 22 _N_ _N_ _N_ _N_} _N_ _N_,
- min = _A_ 2 _U_ 11 _N_ _S_ "U(P)U(P)" {_A_ 2 _U_ 22 _N_ _N_ _N_ _N_} _N_ _N_,
- _tagCmp = _A_ 2 _U_ 11 _N_ _S_ "U(P)U(P)" {_A_ 2 _U_ 22 _N_ _N_ _N_ _N_} _N_ _N_ #-}
+ (<) = { _A_ 2 _U_ 11 _N_ _S_ "U(P)U(P)" {_A_ 2 _U_ 22 _N_ _N_ _F_ _IF_ARGS_ 0 2 XX 1 \ (u0 :: Addr#) (u1 :: Addr#) -> _#_ ltAddr# [] [u0, u1] _N_} _F_ _IF_ARGS_ 0 2 CC 3 \ (u0 :: _Addr) (u1 :: _Addr) -> case u0 of { _ALG_ A# (u2 :: Addr#) -> case u1 of { _ALG_ A# (u3 :: Addr#) -> _#_ ltAddr# [] [u2, u3]; _NO_DEFLT_ }; _NO_DEFLT_ } _N_ },
+ (<=) = { _A_ 2 _U_ 11 _N_ _S_ "U(P)U(P)" {_A_ 2 _U_ 22 _N_ _N_ _F_ _IF_ARGS_ 0 2 XX 1 \ (u0 :: Addr#) (u1 :: Addr#) -> _#_ leAddr# [] [u0, u1] _N_} _F_ _IF_ARGS_ 0 2 CC 3 \ (u0 :: _Addr) (u1 :: _Addr) -> case u0 of { _ALG_ A# (u2 :: Addr#) -> case u1 of { _ALG_ A# (u3 :: Addr#) -> _#_ leAddr# [] [u2, u3]; _NO_DEFLT_ }; _NO_DEFLT_ } _N_ },
+ (>=) = { _A_ 2 _U_ 11 _N_ _S_ "U(P)U(P)" {_A_ 2 _U_ 22 _N_ _N_ _F_ _IF_ARGS_ 0 2 XX 1 \ (u0 :: Addr#) (u1 :: Addr#) -> _#_ geAddr# [] [u0, u1] _N_} _F_ _IF_ARGS_ 0 2 CC 3 \ (u0 :: _Addr) (u1 :: _Addr) -> case u0 of { _ALG_ A# (u2 :: Addr#) -> case u1 of { _ALG_ A# (u3 :: Addr#) -> _#_ geAddr# [] [u2, u3]; _NO_DEFLT_ }; _NO_DEFLT_ } _N_ },
+ (>) = { _A_ 2 _U_ 11 _N_ _S_ "U(P)U(P)" {_A_ 2 _U_ 22 _N_ _N_ _F_ _IF_ARGS_ 0 2 XX 1 \ (u0 :: Addr#) (u1 :: Addr#) -> _#_ gtAddr# [] [u0, u1] _N_} _F_ _IF_ARGS_ 0 2 CC 3 \ (u0 :: _Addr) (u1 :: _Addr) -> case u0 of { _ALG_ A# (u2 :: Addr#) -> case u1 of { _ALG_ A# (u3 :: Addr#) -> _#_ gtAddr# [] [u2, u3]; _NO_DEFLT_ }; _NO_DEFLT_ } _N_ },
+ max = { _A_ 2 _U_ 11 _N_ _S_ "U(P)U(P)" {_A_ 2 _U_ 22 _N_ _N_ _N_ _N_} _N_ _N_ },
+ min = { _A_ 2 _U_ 11 _N_ _S_ "U(P)U(P)" {_A_ 2 _U_ 22 _N_ _N_ _N_ _N_} _N_ _N_ },
+ _tagCmp = { _A_ 2 _U_ 11 _N_ _S_ "U(P)U(P)" {_A_ 2 _U_ 22 _N_ _N_ _N_ _N_} _N_ _N_ } #-}
instance Ord _PackedString
{-# GHC_PRAGMA _M_ PreludePS {-dfun-} _A_ 0 _N_ _N_ _N_ _F_ _IF_ARGS_ 0 0 X 9 _!_ _TUP_8 [{{Eq _PackedString}}, (_PackedString -> _PackedString -> Bool), (_PackedString -> _PackedString -> Bool), (_PackedString -> _PackedString -> Bool), (_PackedString -> _PackedString -> Bool), (_PackedString -> _PackedString -> _PackedString), (_PackedString -> _PackedString -> _PackedString), (_PackedString -> _PackedString -> _CMP_TAG)] [_DFUN_ Eq (_PackedString), _CONSTM_ Ord (<) (_PackedString), _CONSTM_ Ord (<=) (_PackedString), _CONSTM_ Ord (>=) (_PackedString), _CONSTM_ Ord (>) (_PackedString), _CONSTM_ Ord max (_PackedString), _CONSTM_ Ord min (_PackedString), _CONSTM_ Ord _tagCmp (_PackedString)] _N_
- (<) = _A_ 2 _U_ 22 _N_ _S_ "SS" _N_ _N_,
- (<=) = _A_ 2 _U_ 22 _N_ _S_ "SS" _N_ _N_,
- (>=) = _A_ 2 _U_ 22 _N_ _S_ "SS" _N_ _N_,
- (>) = _A_ 2 _U_ 22 _N_ _S_ "SS" _N_ _N_,
- max = _A_ 2 _U_ 22 _N_ _N_ _N_ _N_,
- min = _A_ 2 _U_ 22 _N_ _N_ _N_ _N_,
- _tagCmp = _A_ 2 _U_ 22 _N_ _S_ "SS" _N_ _N_ #-}
+ (<) = { _A_ 2 _U_ 22 _N_ _S_ "SS" _N_ _N_ },
+ (<=) = { _A_ 2 _U_ 22 _N_ _S_ "SS" _N_ _N_ },
+ (>=) = { _A_ 2 _U_ 22 _N_ _S_ "SS" _N_ _N_ },
+ (>) = { _A_ 2 _U_ 22 _N_ _S_ "SS" _N_ _N_ },
+ max = { _A_ 2 _U_ 22 _N_ _S_ "SS" _N_ _N_ },
+ min = { _A_ 2 _U_ 22 _N_ _S_ "SS" _N_ _N_ },
+ _tagCmp = { _A_ 2 _U_ 22 _N_ _S_ "SS" _N_ _N_ } #-}
instance Ord _Word
{-# GHC_PRAGMA _M_ PreludeCore {-dfun-} _A_ 0 _N_ _N_ _N_ _F_ _IF_ARGS_ 0 0 X 9 _!_ _TUP_8 [{{Eq _Word}}, (_Word -> _Word -> Bool), (_Word -> _Word -> Bool), (_Word -> _Word -> Bool), (_Word -> _Word -> Bool), (_Word -> _Word -> _Word), (_Word -> _Word -> _Word), (_Word -> _Word -> _CMP_TAG)] [_DFUN_ Eq (_Word), _CONSTM_ Ord (<) (_Word), _CONSTM_ Ord (<=) (_Word), _CONSTM_ Ord (>=) (_Word), _CONSTM_ Ord (>) (_Word), _CONSTM_ Ord max (_Word), _CONSTM_ Ord min (_Word), _CONSTM_ Ord _tagCmp (_Word)] _N_
- (<) = _A_ 2 _U_ 11 _N_ _S_ "U(P)U(P)" {_A_ 2 _U_ 22 _N_ _N_ _F_ _IF_ARGS_ 0 2 XX 1 \ (u0 :: Word#) (u1 :: Word#) -> _#_ ltWord# [] [u0, u1] _N_} _F_ _IF_ARGS_ 0 2 CC 3 \ (u0 :: _Word) (u1 :: _Word) -> case u0 of { _ALG_ W# (u2 :: Word#) -> case u1 of { _ALG_ W# (u3 :: Word#) -> _#_ ltWord# [] [u2, u3]; _NO_DEFLT_ }; _NO_DEFLT_ } _N_,
- (<=) = _A_ 2 _U_ 11 _N_ _S_ "U(P)U(P)" {_A_ 2 _U_ 22 _N_ _N_ _F_ _IF_ARGS_ 0 2 XX 1 \ (u0 :: Word#) (u1 :: Word#) -> _#_ leWord# [] [u0, u1] _N_} _F_ _IF_ARGS_ 0 2 CC 3 \ (u0 :: _Word) (u1 :: _Word) -> case u0 of { _ALG_ W# (u2 :: Word#) -> case u1 of { _ALG_ W# (u3 :: Word#) -> _#_ leWord# [] [u2, u3]; _NO_DEFLT_ }; _NO_DEFLT_ } _N_,
- (>=) = _A_ 2 _U_ 11 _N_ _S_ "U(P)U(P)" {_A_ 2 _U_ 22 _N_ _N_ _F_ _IF_ARGS_ 0 2 XX 1 \ (u0 :: Word#) (u1 :: Word#) -> _#_ geWord# [] [u0, u1] _N_} _F_ _IF_ARGS_ 0 2 CC 3 \ (u0 :: _Word) (u1 :: _Word) -> case u0 of { _ALG_ W# (u2 :: Word#) -> case u1 of { _ALG_ W# (u3 :: Word#) -> _#_ geWord# [] [u2, u3]; _NO_DEFLT_ }; _NO_DEFLT_ } _N_,
- (>) = _A_ 2 _U_ 11 _N_ _S_ "U(P)U(P)" {_A_ 2 _U_ 22 _N_ _N_ _F_ _IF_ARGS_ 0 2 XX 1 \ (u0 :: Word#) (u1 :: Word#) -> _#_ gtWord# [] [u0, u1] _N_} _F_ _IF_ARGS_ 0 2 CC 3 \ (u0 :: _Word) (u1 :: _Word) -> case u0 of { _ALG_ W# (u2 :: Word#) -> case u1 of { _ALG_ W# (u3 :: Word#) -> _#_ gtWord# [] [u2, u3]; _NO_DEFLT_ }; _NO_DEFLT_ } _N_,
- max = _A_ 2 _U_ 11 _N_ _S_ "U(P)U(P)" {_A_ 2 _U_ 22 _N_ _N_ _N_ _N_} _N_ _N_,
- min = _A_ 2 _U_ 11 _N_ _S_ "U(P)U(P)" {_A_ 2 _U_ 22 _N_ _N_ _N_ _N_} _N_ _N_,
- _tagCmp = _A_ 2 _U_ 11 _N_ _S_ "U(P)U(P)" {_A_ 2 _U_ 22 _N_ _N_ _N_ _N_} _N_ _N_ #-}
+ (<) = { _A_ 2 _U_ 11 _N_ _S_ "U(P)U(P)" {_A_ 2 _U_ 22 _N_ _N_ _F_ _IF_ARGS_ 0 2 XX 1 \ (u0 :: Word#) (u1 :: Word#) -> _#_ ltWord# [] [u0, u1] _N_} _F_ _IF_ARGS_ 0 2 CC 3 \ (u0 :: _Word) (u1 :: _Word) -> case u0 of { _ALG_ W# (u2 :: Word#) -> case u1 of { _ALG_ W# (u3 :: Word#) -> _#_ ltWord# [] [u2, u3]; _NO_DEFLT_ }; _NO_DEFLT_ } _N_ },
+ (<=) = { _A_ 2 _U_ 11 _N_ _S_ "U(P)U(P)" {_A_ 2 _U_ 22 _N_ _N_ _F_ _IF_ARGS_ 0 2 XX 1 \ (u0 :: Word#) (u1 :: Word#) -> _#_ leWord# [] [u0, u1] _N_} _F_ _IF_ARGS_ 0 2 CC 3 \ (u0 :: _Word) (u1 :: _Word) -> case u0 of { _ALG_ W# (u2 :: Word#) -> case u1 of { _ALG_ W# (u3 :: Word#) -> _#_ leWord# [] [u2, u3]; _NO_DEFLT_ }; _NO_DEFLT_ } _N_ },
+ (>=) = { _A_ 2 _U_ 11 _N_ _S_ "U(P)U(P)" {_A_ 2 _U_ 22 _N_ _N_ _F_ _IF_ARGS_ 0 2 XX 1 \ (u0 :: Word#) (u1 :: Word#) -> _#_ geWord# [] [u0, u1] _N_} _F_ _IF_ARGS_ 0 2 CC 3 \ (u0 :: _Word) (u1 :: _Word) -> case u0 of { _ALG_ W# (u2 :: Word#) -> case u1 of { _ALG_ W# (u3 :: Word#) -> _#_ geWord# [] [u2, u3]; _NO_DEFLT_ }; _NO_DEFLT_ } _N_ },
+ (>) = { _A_ 2 _U_ 11 _N_ _S_ "U(P)U(P)" {_A_ 2 _U_ 22 _N_ _N_ _F_ _IF_ARGS_ 0 2 XX 1 \ (u0 :: Word#) (u1 :: Word#) -> _#_ gtWord# [] [u0, u1] _N_} _F_ _IF_ARGS_ 0 2 CC 3 \ (u0 :: _Word) (u1 :: _Word) -> case u0 of { _ALG_ W# (u2 :: Word#) -> case u1 of { _ALG_ W# (u3 :: Word#) -> _#_ gtWord# [] [u2, u3]; _NO_DEFLT_ }; _NO_DEFLT_ } _N_ },
+ max = { _A_ 2 _U_ 11 _N_ _S_ "U(P)U(P)" {_A_ 2 _U_ 22 _N_ _N_ _N_ _N_} _N_ _N_ },
+ min = { _A_ 2 _U_ 11 _N_ _S_ "U(P)U(P)" {_A_ 2 _U_ 22 _N_ _N_ _N_ _N_} _N_ _N_ },
+ _tagCmp = { _A_ 2 _U_ 11 _N_ _S_ "U(P)U(P)" {_A_ 2 _U_ 22 _N_ _N_ _N_ _N_} _N_ _N_ } #-}
instance Real Double
{-# GHC_PRAGMA _M_ PreludeCore {-dfun-} _A_ 0 _N_ _N_ _N_ _F_ _IF_ARGS_ 0 0 X 4 _!_ _TUP_3 [{{Num Double}}, {{Enum Double}}, (Double -> Ratio Integer)] [_DFUN_ Num (Double), _DFUN_ Enum (Double), _CONSTM_ Real toRational (Double)] _N_
- toRational = _A_ 1 _U_ 1 _N_ _S_ "U(P)" {_A_ 1 _U_ 2 _N_ _N_ _N_ _N_} _N_ _N_ #-}
+ toRational = { _A_ 1 _U_ 1 _N_ _S_ "U(P)" {_A_ 1 _U_ 2 _N_ _N_ _N_ _N_} _N_ _N_ } #-}
instance Real Float
{-# GHC_PRAGMA _M_ PreludeCore {-dfun-} _A_ 0 _N_ _N_ _N_ _F_ _IF_ARGS_ 0 0 X 4 _!_ _TUP_3 [{{Num Float}}, {{Enum Float}}, (Float -> Ratio Integer)] [_DFUN_ Num (Float), _DFUN_ Enum (Float), _CONSTM_ Real toRational (Float)] _N_
- toRational = _A_ 1 _U_ 1 _N_ _S_ "U(P)" {_A_ 1 _U_ 2 _N_ _N_ _N_ _N_} _N_ _N_ #-}
+ toRational = { _A_ 1 _U_ 1 _N_ _S_ "U(P)" {_A_ 1 _U_ 2 _N_ _N_ _N_ _N_} _N_ _N_ } #-}
instance Real Int
{-# GHC_PRAGMA _M_ PreludeCore {-dfun-} _A_ 0 _N_ _N_ _N_ _F_ _IF_ARGS_ 0 0 X 4 _!_ _TUP_3 [{{Num Int}}, {{Enum Int}}, (Int -> Ratio Integer)] [_DFUN_ Num (Int), _DFUN_ Enum (Int), _CONSTM_ Real toRational (Int)] _N_
- toRational = _A_ 1 _U_ 1 _N_ _N_ _N_ _N_ #-}
+ toRational = { _A_ 1 _U_ 1 _N_ _N_ _N_ _N_ } #-}
instance Real Integer
{-# GHC_PRAGMA _M_ PreludeCore {-dfun-} _A_ 0 _N_ _N_ _N_ _F_ _IF_ARGS_ 0 0 X 4 _!_ _TUP_3 [{{Num Integer}}, {{Enum Integer}}, (Integer -> Ratio Integer)] [_DFUN_ Num (Integer), _DFUN_ Enum (Integer), _CONSTM_ Real toRational (Integer)] _N_
- toRational = _A_ 1 _U_ 2 _N_ _N_ _N_ _N_ #-}
+ toRational = { _A_ 1 _U_ 2 _N_ _N_ _F_ _IF_ARGS_ 0 1 X 3 \ (u0 :: Integer) -> _!_ (:%) [Integer] [u0, _ORIG_ PreludeCore __integer1] _N_ } #-}
instance Integral a => Real (Ratio a)
{-# GHC_PRAGMA _M_ PreludeRatio {-dfun-} _A_ 3 _U_ 122 _N_ _N_ _N_ _N_ #-}
instance Real (Ratio Integer)
{-# GHC_PRAGMA _M_ PreludeRatio {-dfun-} _A_ 0 _N_ _N_ _N_ _F_ _IF_ARGS_ 0 0 X 4 _!_ _TUP_3 [{{Num (Ratio Integer)}}, {{Enum (Ratio Integer)}}, (Ratio Integer -> Ratio Integer)] [_DFUN_ Num (Ratio Integer), _DFUN_ Enum (Ratio Integer), _CONSTM_ Real toRational (Ratio Integer)] _N_
- toRational = _A_ 1 _U_ 1 _N_ _S_ "U(LL)" {_A_ 2 _U_ 22 _N_ _N_ _F_ _IF_ARGS_ 0 2 XX 3 \ (u0 :: Integer) (u1 :: Integer) -> _!_ (:%) [Integer] [u0, u1] _N_} _F_ _IF_ARGS_ 0 1 X 1 \ (u0 :: Ratio Integer) -> u0 _N_ #-}
+ toRational = { _A_ 1 _U_ 1 _N_ _S_ "U(LL)" {_A_ 2 _U_ 22 _N_ _N_ _F_ _IF_ARGS_ 0 2 XX 3 \ (u0 :: Integer) (u1 :: Integer) -> _!_ (:%) [Integer] [u0, u1] _N_} _F_ _IF_ARGS_ 0 1 X 1 \ (u0 :: Ratio Integer) -> u0 _N_ } #-}
instance RealFloat Double
{-# GHC_PRAGMA _M_ PreludeCore {-dfun-} _A_ 0 _N_ _N_ _N_ _F_ _IF_ARGS_ 0 0 X 11 _!_ _TUP_10 [{{RealFrac Double}}, {{Floating Double}}, (Double -> Integer), (Double -> Int), (Double -> (Int, Int)), (Double -> (Integer, Int)), (Integer -> Int -> Double), (Double -> Int), (Double -> Double), (Int -> Double -> Double)] [_DFUN_ RealFrac (Double), _DFUN_ Floating (Double), _CONSTM_ RealFloat floatRadix (Double), _CONSTM_ RealFloat floatDigits (Double), _CONSTM_ RealFloat floatRange (Double), _CONSTM_ RealFloat decodeFloat (Double), _CONSTM_ RealFloat encodeFloat (Double), _CONSTM_ RealFloat exponent (Double), _CONSTM_ RealFloat significand (Double), _CONSTM_ RealFloat scaleFloat (Double)] _N_
- floatRadix = _A_ 1 _U_ 0 _N_ _S_ "A" {_A_ 0 _N_ _N_ _N_ _F_ _IF_ARGS_ 0 0 X 1 _#_ int2Integer# [] [2#] _N_} _N_ _N_,
- floatDigits = _A_ 1 _U_ 0 _N_ _S_ "A" {_A_ 0 _N_ _N_ _N_ _F_ _IF_ARGS_ 0 0 X 2 _!_ I# [] [53#] _N_} _F_ _IF_ARGS_ 0 1 X 2 \ (u0 :: Double) -> _!_ I# [] [53#] _N_,
- floatRange = _A_ 1 _U_ 0 _N_ _S_ "A" {_A_ 0 _N_ _N_ _N_ _N_ _N_} _N_ _N_,
- decodeFloat = _A_ 1 _U_ 1 _N_ _S_ "U(P)" {_A_ 1 _U_ 2 _N_ _N_ _N_ _N_} _N_ _N_,
- encodeFloat = _A_ 2 _U_ 11 _N_ _S_ "U(PPP)U(P)" {_A_ 4 _U_ 2222 _N_ _N_ _F_ _IF_ARGS_ 0 4 XXXX 3 \ (u0 :: Int#) (u1 :: Int#) (u2 :: ByteArray#) (u3 :: Int#) -> case _#_ encodeDouble# [] [u0, u1, u2, u3] of { _PRIM_ (u4 :: Double#) -> _!_ D# [] [u4] } _N_} _F_ _IF_ARGS_ 0 2 CC 5 \ (u0 :: Integer) (u1 :: Int) -> case u0 of { _ALG_ J# (u2 :: Int#) (u3 :: Int#) (u4 :: ByteArray#) -> case u1 of { _ALG_ I# (u5 :: Int#) -> case _#_ encodeDouble# [] [u2, u3, u4, u5] of { _PRIM_ (u6 :: Double#) -> _!_ D# [] [u6] }; _NO_DEFLT_ }; _NO_DEFLT_ } _N_,
- exponent = _A_ 1 _U_ 2 _N_ _N_ _N_ _N_,
- significand = _A_ 1 _U_ 2 _N_ _N_ _N_ _N_,
- scaleFloat = _A_ 2 _U_ 22 _N_ _N_ _N_ _N_ #-}
+ floatRadix = { _A_ 1 _U_ 0 _N_ _S_ "A" {_A_ 0 _N_ _N_ _N_ _N_ _N_} _N_ _N_ },
+ floatDigits = { _A_ 1 _U_ 0 _N_ _S_ "A" {_A_ 0 _N_ _N_ _N_ _F_ _IF_ARGS_ 0 0 X 2 _!_ I# [] [53#] _N_} _F_ _IF_ARGS_ 0 1 X 2 \ (u0 :: Double) -> _!_ I# [] [53#] _N_ },
+ floatRange = { _A_ 1 _U_ 0 _N_ _S_ "A" {_A_ 0 _N_ _N_ _N_ _N_ _N_} _N_ _N_ },
+ decodeFloat = { _A_ 1 _U_ 1 _N_ _S_ "U(P)" {_A_ 1 _U_ 2 _N_ _N_ _N_ _N_} _N_ _N_ },
+ encodeFloat = { _A_ 2 _U_ 11 _N_ _S_ "U(PPP)U(P)" {_A_ 4 _U_ 2222 _N_ _N_ _F_ _IF_ARGS_ 0 4 XXXX 3 \ (u0 :: Int#) (u1 :: Int#) (u2 :: ByteArray#) (u3 :: Int#) -> case _#_ encodeDouble# [] [u0, u1, u2, u3] of { _PRIM_ (u4 :: Double#) -> _!_ D# [] [u4] } _N_} _F_ _IF_ARGS_ 0 2 CC 5 \ (u0 :: Integer) (u1 :: Int) -> case u0 of { _ALG_ J# (u2 :: Int#) (u3 :: Int#) (u4 :: ByteArray#) -> case u1 of { _ALG_ I# (u5 :: Int#) -> case _#_ encodeDouble# [] [u2, u3, u4, u5] of { _PRIM_ (u6 :: Double#) -> _!_ D# [] [u6] }; _NO_DEFLT_ }; _NO_DEFLT_ } _N_ },
+ exponent = { _A_ 1 _U_ 1 _N_ _S_ "U(P)" {_A_ 1 _U_ 2 _N_ _N_ _N_ _N_} _N_ _N_ },
+ significand = { _A_ 1 _U_ 1 _N_ _S_ "U(P)" {_A_ 1 _U_ 2 _N_ _N_ _N_ _N_} _N_ _N_ },
+ scaleFloat = { _A_ 2 _U_ 11 _N_ _S_ "U(P)U(P)" {_A_ 2 _U_ 22 _N_ _N_ _N_ _N_} _N_ _N_ } #-}
instance RealFloat Float
{-# GHC_PRAGMA _M_ PreludeCore {-dfun-} _A_ 0 _N_ _N_ _N_ _F_ _IF_ARGS_ 0 0 X 11 _!_ _TUP_10 [{{RealFrac Float}}, {{Floating Float}}, (Float -> Integer), (Float -> Int), (Float -> (Int, Int)), (Float -> (Integer, Int)), (Integer -> Int -> Float), (Float -> Int), (Float -> Float), (Int -> Float -> Float)] [_DFUN_ RealFrac (Float), _DFUN_ Floating (Float), _CONSTM_ RealFloat floatRadix (Float), _CONSTM_ RealFloat floatDigits (Float), _CONSTM_ RealFloat floatRange (Float), _CONSTM_ RealFloat decodeFloat (Float), _CONSTM_ RealFloat encodeFloat (Float), _CONSTM_ RealFloat exponent (Float), _CONSTM_ RealFloat significand (Float), _CONSTM_ RealFloat scaleFloat (Float)] _N_
- floatRadix = _A_ 1 _U_ 0 _N_ _S_ "A" {_A_ 0 _N_ _N_ _N_ _F_ _IF_ARGS_ 0 0 X 1 _#_ int2Integer# [] [2#] _N_} _N_ _N_,
- floatDigits = _A_ 1 _U_ 0 _N_ _S_ "A" {_A_ 0 _N_ _N_ _N_ _F_ _IF_ARGS_ 0 0 X 2 _!_ I# [] [24#] _N_} _F_ _IF_ARGS_ 0 1 X 2 \ (u0 :: Float) -> _!_ I# [] [24#] _N_,
- floatRange = _A_ 1 _U_ 0 _N_ _S_ "A" {_A_ 0 _N_ _N_ _N_ _N_ _N_} _N_ _N_,
- decodeFloat = _A_ 1 _U_ 1 _N_ _S_ "U(P)" {_A_ 1 _U_ 2 _N_ _N_ _N_ _N_} _N_ _N_,
- encodeFloat = _A_ 2 _U_ 11 _N_ _S_ "U(PPP)U(P)" {_A_ 4 _U_ 2222 _N_ _N_ _F_ _IF_ARGS_ 0 4 XXXX 3 \ (u0 :: Int#) (u1 :: Int#) (u2 :: ByteArray#) (u3 :: Int#) -> case _#_ encodeFloat# [] [u0, u1, u2, u3] of { _PRIM_ (u4 :: Float#) -> _!_ F# [] [u4] } _N_} _F_ _IF_ARGS_ 0 2 CC 5 \ (u0 :: Integer) (u1 :: Int) -> case u0 of { _ALG_ J# (u2 :: Int#) (u3 :: Int#) (u4 :: ByteArray#) -> case u1 of { _ALG_ I# (u5 :: Int#) -> case _#_ encodeFloat# [] [u2, u3, u4, u5] of { _PRIM_ (u6 :: Float#) -> _!_ F# [] [u6] }; _NO_DEFLT_ }; _NO_DEFLT_ } _N_,
- exponent = _A_ 1 _U_ 2 _N_ _N_ _N_ _N_,
- significand = _A_ 1 _U_ 2 _N_ _N_ _N_ _N_,
- scaleFloat = _A_ 2 _U_ 22 _N_ _N_ _N_ _N_ #-}
+ floatRadix = { _A_ 1 _U_ 0 _N_ _S_ "A" {_A_ 0 _N_ _N_ _N_ _N_ _N_} _N_ _N_ },
+ floatDigits = { _A_ 1 _U_ 0 _N_ _S_ "A" {_A_ 0 _N_ _N_ _N_ _F_ _IF_ARGS_ 0 0 X 2 _!_ I# [] [24#] _N_} _F_ _IF_ARGS_ 0 1 X 2 \ (u0 :: Float) -> _!_ I# [] [24#] _N_ },
+ floatRange = { _A_ 1 _U_ 0 _N_ _S_ "A" {_A_ 0 _N_ _N_ _N_ _N_ _N_} _N_ _N_ },
+ decodeFloat = { _A_ 1 _U_ 1 _N_ _S_ "U(P)" {_A_ 1 _U_ 2 _N_ _N_ _N_ _N_} _N_ _N_ },
+ encodeFloat = { _A_ 2 _U_ 11 _N_ _S_ "U(PPP)U(P)" {_A_ 4 _U_ 2222 _N_ _N_ _F_ _IF_ARGS_ 0 4 XXXX 3 \ (u0 :: Int#) (u1 :: Int#) (u2 :: ByteArray#) (u3 :: Int#) -> case _#_ encodeFloat# [] [u0, u1, u2, u3] of { _PRIM_ (u4 :: Float#) -> _!_ F# [] [u4] } _N_} _F_ _IF_ARGS_ 0 2 CC 5 \ (u0 :: Integer) (u1 :: Int) -> case u0 of { _ALG_ J# (u2 :: Int#) (u3 :: Int#) (u4 :: ByteArray#) -> case u1 of { _ALG_ I# (u5 :: Int#) -> case _#_ encodeFloat# [] [u2, u3, u4, u5] of { _PRIM_ (u6 :: Float#) -> _!_ F# [] [u6] }; _NO_DEFLT_ }; _NO_DEFLT_ } _N_ },
+ exponent = { _A_ 1 _U_ 1 _N_ _S_ "U(P)" {_A_ 1 _U_ 2 _N_ _N_ _N_ _N_} _N_ _N_ },
+ significand = { _A_ 1 _U_ 1 _N_ _S_ "U(P)" {_A_ 1 _U_ 2 _N_ _N_ _N_ _N_} _N_ _N_ },
+ scaleFloat = { _A_ 2 _U_ 11 _N_ _S_ "U(P)U(P)" {_A_ 2 _U_ 22 _N_ _N_ _N_ _N_} _N_ _N_ } #-}
instance RealFrac Double
{-# GHC_PRAGMA _M_ PreludeCore {-dfun-} _A_ 0 _N_ _N_ _N_ _F_ _IF_ARGS_ 0 0 X 8 _!_ _TUP_7 [{{Real Double}}, {{Fractional Double}}, _forall_ a$z1 =>{{Integral a$z1}} -> (Double -> (a$z1, Double)), _forall_ a$z1 =>{{Integral a$z1}} -> (Double -> a$z1), _forall_ a$z1 =>{{Integral a$z1}} -> (Double -> a$z1), _forall_ a$z1 =>{{Integral a$z1}} -> (Double -> a$z1), _forall_ a$z1 =>{{Integral a$z1}} -> (Double -> a$z1)] [_DFUN_ Real (Double), _DFUN_ Fractional (Double), _CONSTM_ RealFrac properFraction (Double), _CONSTM_ RealFrac truncate (Double), _CONSTM_ RealFrac round (Double), _CONSTM_ RealFrac ceiling (Double), _CONSTM_ RealFrac floor (Double)] _N_
- properFraction = _A_ 1 _U_ 22 _N_ _N_ _N_ _N_,
- truncate = _A_ 1 _U_ 22 _N_ _N_ _N_ _N_,
- round = _A_ 1 _U_ 22 _N_ _N_ _N_ _N_,
- ceiling = _A_ 1 _U_ 22 _N_ _N_ _N_ _N_,
- floor = _A_ 1 _U_ 22 _N_ _N_ _N_ _N_ #-}
+ properFraction = { _A_ 1 _U_ 11 _N_ _N_ _N_ _SPECIALISE_ [ Int ] 1 { _A_ 1 _U_ 1 _N_ _S_ "U(P)" {_A_ 1 _U_ 2 _N_ _N_ _N_ _N_} _N_ _N_ }, [ Integer ] 1 { _A_ 1 _U_ 1 _N_ _S_ "U(P)" {_A_ 1 _U_ 2 _N_ _N_ _N_ _N_} _N_ _N_ } },
+ truncate = { _A_ 1 _U_ 11 _N_ _N_ _N_ _SPECIALISE_ [ Int ] 1 { _A_ 1 _U_ 1 _N_ _S_ "U(P)" {_A_ 1 _U_ 2 _N_ _N_ _F_ _IF_ARGS_ 0 1 X 4 \ (u0 :: Double#) -> case _APP_ _WRKR_ _SPEC_ _CONSTM_ RealFrac properFraction (Double) [ (Int) ] [ u0 ] of { _ALG_ _TUP_2 (u1 :: Int) (u2 :: Double) -> u1; _NO_DEFLT_ } _N_} _F_ _IF_ARGS_ 0 1 X 4 \ (u0 :: Double) -> case _APP_ _SPEC_ _CONSTM_ RealFrac properFraction (Double) [ (Int) ] [ u0 ] of { _ALG_ _TUP_2 (u1 :: Int) (u2 :: Double) -> u1; _NO_DEFLT_ } _N_ }, [ Integer ] 1 { _A_ 1 _U_ 1 _N_ _S_ "U(P)" {_A_ 1 _U_ 2 _N_ _N_ _F_ _IF_ARGS_ 0 1 X 4 \ (u0 :: Double#) -> case _APP_ _WRKR_ _SPEC_ _CONSTM_ RealFrac properFraction (Double) [ (Integer) ] [ u0 ] of { _ALG_ _TUP_2 (u1 :: Integer) (u2 :: Double) -> u1; _NO_DEFLT_ } _N_} _F_ _IF_ARGS_ 0 1 X 4 \ (u0 :: Double) -> case _APP_ _SPEC_ _CONSTM_ RealFrac properFraction (Double) [ (Integer) ] [ u0 ] of { _ALG_ _TUP_2 (u1 :: Integer) (u2 :: Double) -> u1; _NO_DEFLT_ } _N_ } },
+ round = { _A_ 1 _U_ 21 _N_ _N_ _N_ _SPECIALISE_ [ Int ] 1 { _A_ 1 _U_ 1 _N_ _S_ "U(P)" {_A_ 1 _U_ 2 _N_ _N_ _N_ _N_} _N_ _N_ }, [ Integer ] 1 { _A_ 1 _U_ 1 _N_ _S_ "U(P)" {_A_ 1 _U_ 2 _N_ _N_ _N_ _N_} _N_ _N_ } },
+ ceiling = { _A_ 1 _U_ 21 _N_ _N_ _N_ _SPECIALISE_ [ Int ] 1 { _A_ 1 _U_ 1 _N_ _S_ "U(P)" {_A_ 1 _U_ 2 _N_ _N_ _N_ _N_} _N_ _N_ }, [ Integer ] 1 { _A_ 1 _U_ 1 _N_ _S_ "U(P)" {_A_ 1 _U_ 2 _N_ _N_ _N_ _N_} _N_ _N_ } },
+ floor = { _A_ 1 _U_ 21 _N_ _N_ _N_ _SPECIALISE_ [ Int ] 1 { _A_ 1 _U_ 1 _N_ _S_ "U(P)" {_A_ 1 _U_ 2 _N_ _N_ _N_ _N_} _N_ _N_ }, [ Integer ] 1 { _A_ 1 _U_ 1 _N_ _S_ "U(P)" {_A_ 1 _U_ 2 _N_ _N_ _N_ _N_} _N_ _N_ } } #-}
instance RealFrac Float
{-# GHC_PRAGMA _M_ PreludeCore {-dfun-} _A_ 0 _N_ _N_ _N_ _F_ _IF_ARGS_ 0 0 X 8 _!_ _TUP_7 [{{Real Float}}, {{Fractional Float}}, _forall_ a$z1 =>{{Integral a$z1}} -> (Float -> (a$z1, Float)), _forall_ a$z1 =>{{Integral a$z1}} -> (Float -> a$z1), _forall_ a$z1 =>{{Integral a$z1}} -> (Float -> a$z1), _forall_ a$z1 =>{{Integral a$z1}} -> (Float -> a$z1), _forall_ a$z1 =>{{Integral a$z1}} -> (Float -> a$z1)] [_DFUN_ Real (Float), _DFUN_ Fractional (Float), _CONSTM_ RealFrac properFraction (Float), _CONSTM_ RealFrac truncate (Float), _CONSTM_ RealFrac round (Float), _CONSTM_ RealFrac ceiling (Float), _CONSTM_ RealFrac floor (Float)] _N_
- properFraction = _A_ 1 _U_ 22 _N_ _N_ _N_ _N_,
- truncate = _A_ 1 _U_ 22 _N_ _N_ _N_ _N_,
- round = _A_ 1 _U_ 22 _N_ _N_ _N_ _N_,
- ceiling = _A_ 1 _U_ 22 _N_ _N_ _N_ _N_,
- floor = _A_ 1 _U_ 22 _N_ _N_ _N_ _N_ #-}
-instance Integral a => RealFrac (Ratio a)
- {-# GHC_PRAGMA _M_ PreludeRatio {-dfun-} _A_ 3 _U_ 222 _N_ _N_ _N_ _N_ #-}
+ properFraction = { _A_ 1 _U_ 11 _N_ _N_ _N_ _SPECIALISE_ [ Int ] 1 { _A_ 1 _U_ 1 _N_ _S_ "U(P)" {_A_ 1 _U_ 2 _N_ _N_ _N_ _N_} _N_ _N_ }, [ Integer ] 1 { _A_ 1 _U_ 1 _N_ _S_ "U(P)" {_A_ 1 _U_ 2 _N_ _N_ _N_ _N_} _N_ _N_ } },
+ truncate = { _A_ 1 _U_ 11 _N_ _N_ _N_ _SPECIALISE_ [ Int ] 1 { _A_ 1 _U_ 1 _N_ _S_ "U(P)" {_A_ 1 _U_ 2 _N_ _N_ _F_ _IF_ARGS_ 0 1 X 4 \ (u0 :: Float#) -> case _APP_ _WRKR_ _SPEC_ _CONSTM_ RealFrac properFraction (Float) [ (Int) ] [ u0 ] of { _ALG_ _TUP_2 (u1 :: Int) (u2 :: Float) -> u1; _NO_DEFLT_ } _N_} _F_ _IF_ARGS_ 0 1 X 4 \ (u0 :: Float) -> case _APP_ _SPEC_ _CONSTM_ RealFrac properFraction (Float) [ (Int) ] [ u0 ] of { _ALG_ _TUP_2 (u1 :: Int) (u2 :: Float) -> u1; _NO_DEFLT_ } _N_ }, [ Integer ] 1 { _A_ 1 _U_ 1 _N_ _S_ "U(P)" {_A_ 1 _U_ 2 _N_ _N_ _F_ _IF_ARGS_ 0 1 X 4 \ (u0 :: Float#) -> case _APP_ _WRKR_ _SPEC_ _CONSTM_ RealFrac properFraction (Float) [ (Integer) ] [ u0 ] of { _ALG_ _TUP_2 (u1 :: Integer) (u2 :: Float) -> u1; _NO_DEFLT_ } _N_} _F_ _IF_ARGS_ 0 1 X 4 \ (u0 :: Float) -> case _APP_ _SPEC_ _CONSTM_ RealFrac properFraction (Float) [ (Integer) ] [ u0 ] of { _ALG_ _TUP_2 (u1 :: Integer) (u2 :: Float) -> u1; _NO_DEFLT_ } _N_ } },
+ round = { _A_ 1 _U_ 21 _N_ _N_ _N_ _SPECIALISE_ [ Int ] 1 { _A_ 1 _U_ 1 _N_ _S_ "U(P)" {_A_ 1 _U_ 2 _N_ _N_ _N_ _N_} _N_ _N_ }, [ Integer ] 1 { _A_ 1 _U_ 1 _N_ _S_ "U(P)" {_A_ 1 _U_ 2 _N_ _N_ _N_ _N_} _N_ _N_ } },
+ ceiling = { _A_ 1 _U_ 21 _N_ _N_ _N_ _SPECIALISE_ [ Int ] 1 { _A_ 1 _U_ 1 _N_ _S_ "U(P)" {_A_ 1 _U_ 2 _N_ _N_ _N_ _N_} _N_ _N_ }, [ Integer ] 1 { _A_ 1 _U_ 1 _N_ _S_ "U(P)" {_A_ 1 _U_ 2 _N_ _N_ _N_ _N_} _N_ _N_ } },
+ floor = { _A_ 1 _U_ 21 _N_ _N_ _N_ _SPECIALISE_ [ Int ] 1 { _A_ 1 _U_ 1 _N_ _S_ "U(P)" {_A_ 1 _U_ 2 _N_ _N_ _N_ _N_} _N_ _N_ }, [ Integer ] 1 { _A_ 1 _U_ 1 _N_ _S_ "U(P)" {_A_ 1 _U_ 2 _N_ _N_ _N_ _N_} _N_ _N_ } } #-}
instance RealFrac (Ratio Integer)
{-# GHC_PRAGMA _M_ PreludeRatio {-dfun-} _A_ 0 _N_ _N_ _N_ _F_ _IF_ARGS_ 0 0 X 8 _!_ _TUP_7 [{{Real (Ratio Integer)}}, {{Fractional (Ratio Integer)}}, _forall_ a$z1 =>{{Integral a$z1}} -> (Ratio Integer -> (a$z1, Ratio Integer)), _forall_ a$z1 =>{{Integral a$z1}} -> (Ratio Integer -> a$z1), _forall_ a$z1 =>{{Integral a$z1}} -> (Ratio Integer -> a$z1), _forall_ a$z1 =>{{Integral a$z1}} -> (Ratio Integer -> a$z1), _forall_ a$z1 =>{{Integral a$z1}} -> (Ratio Integer -> a$z1)] [_DFUN_ Real (Ratio Integer), _DFUN_ Fractional (Ratio Integer), _CONSTM_ RealFrac properFraction (Ratio Integer), _CONSTM_ RealFrac truncate (Ratio Integer), _CONSTM_ RealFrac round (Ratio Integer), _CONSTM_ RealFrac ceiling (Ratio Integer), _CONSTM_ RealFrac floor (Ratio Integer)] _N_
- properFraction = _A_ 2 _U_ 11 _N_ _S_ "LU(LL)" {_A_ 3 _U_ 112 _N_ _N_ _N_ _N_} _N_ _N_,
- truncate = _A_ 1 _U_ 22 _N_ _N_ _F_ _IF_ARGS_ 1 1 X 3 _/\_ u0 -> \ (u1 :: {{Integral u0}}) -> _APP_ _TYAPP_ _TYAPP_ _WRKR_ _ORIG_ PreludeCore _truncate { (Ratio Integer) } { u0 } [ _CONSTM_ RealFrac properFraction (Ratio Integer), u1 ] _N_,
- round = _A_ 1 _U_ 22 _N_ _N_ _N_ _N_,
- ceiling = _A_ 1 _U_ 22 _N_ _N_ _N_ _N_,
- floor = _A_ 1 _U_ 22 _N_ _N_ _N_ _N_ #-}
+ properFraction = { _A_ 2 _U_ 11 _N_ _S_ "LU(U(PPP)U(PPP))" {_A_ 5 _U_ 12222 _N_ _N_ _N_ _N_} _N_ _SPECIALISE_ [ Int ] 1 { _A_ 1 _U_ 1 _N_ _S_ "U(U(PPP)U(PPP))" {_A_ 4 _U_ 2222 _N_ _N_ _N_ _N_} _N_ _N_ }, [ Integer ] 1 { _A_ 1 _U_ 1 _N_ _S_ "U(U(PPP)U(PPP))" {_A_ 4 _U_ 2222 _N_ _N_ _N_ _N_} _N_ _N_ } },
+ truncate = { _A_ 2 _U_ 11 _N_ _N_ _N_ _SPECIALISE_ [ Int ] 1 { _A_ 1 _U_ 1 _N_ _S_ "U(U(PPP)U(PPP))" {_A_ 4 _U_ 2222 _N_ _N_ _F_ _IF_ARGS_ 0 4 XXXX 7 \ (u0 :: Int#) (u1 :: Int#) (u2 :: ByteArray#) (u3 :: Integer) -> case _APP_ _WRKR_ _SPEC_ _CONSTM_ RealFrac properFraction (Ratio Integer) [ (Int) ] [ u0, u1, u2, u3 ] of { _ALG_ _TUP_2 (u4 :: Int) (u5 :: Ratio Integer) -> u4; _NO_DEFLT_ } _N_} _F_ _IF_ARGS_ 0 1 X 4 \ (u0 :: Ratio Integer) -> case _APP_ _SPEC_ _CONSTM_ RealFrac properFraction (Ratio Integer) [ (Int) ] [ u0 ] of { _ALG_ _TUP_2 (u1 :: Int) (u2 :: Ratio Integer) -> u1; _NO_DEFLT_ } _N_ }, [ Integer ] 1 { _A_ 1 _U_ 1 _N_ _S_ "U(U(PPP)U(PPP))" {_A_ 4 _U_ 2222 _N_ _N_ _F_ _IF_ARGS_ 0 4 XXXX 7 \ (u0 :: Int#) (u1 :: Int#) (u2 :: ByteArray#) (u3 :: Integer) -> case _APP_ _WRKR_ _SPEC_ _CONSTM_ RealFrac properFraction (Ratio Integer) [ (Integer) ] [ u0, u1, u2, u3 ] of { _ALG_ _TUP_2 (u4 :: Integer) (u5 :: Ratio Integer) -> u4; _NO_DEFLT_ } _N_} _F_ _IF_ARGS_ 0 1 X 4 \ (u0 :: Ratio Integer) -> case _APP_ _SPEC_ _CONSTM_ RealFrac properFraction (Ratio Integer) [ (Integer) ] [ u0 ] of { _ALG_ _TUP_2 (u1 :: Integer) (u2 :: Ratio Integer) -> u1; _NO_DEFLT_ } _N_ } },
+ round = { _A_ 1 _U_ 21 _N_ _N_ _N_ _SPECIALISE_ [ Int ] 1 { _A_ 1 _U_ 1 _N_ _S_ "U(U(PPP)U(PPP))" {_A_ 4 _U_ 2222 _N_ _N_ _N_ _N_} _N_ _N_ }, [ Integer ] 1 { _A_ 1 _U_ 1 _N_ _S_ "U(U(PPP)U(PPP))" {_A_ 4 _U_ 2222 _N_ _N_ _N_ _N_} _N_ _N_ } },
+ ceiling = { _A_ 1 _U_ 21 _N_ _N_ _N_ _SPECIALISE_ [ Int ] 1 { _A_ 1 _U_ 1 _N_ _S_ "U(U(PPP)U(PPP))" {_A_ 4 _U_ 2222 _N_ _N_ _N_ _N_} _N_ _N_ }, [ Integer ] 1 { _A_ 1 _U_ 1 _N_ _S_ "U(U(PPP)U(PPP))" {_A_ 4 _U_ 2222 _N_ _N_ _N_ _N_} _N_ _N_ } },
+ floor = { _A_ 1 _U_ 21 _N_ _N_ _N_ _SPECIALISE_ [ Int ] 1 { _A_ 1 _U_ 1 _N_ _S_ "U(U(PPP)U(PPP))" {_A_ 4 _U_ 2222 _N_ _N_ _N_ _N_} _N_ _N_ }, [ Integer ] 1 { _A_ 1 _U_ 1 _N_ _S_ "U(U(PPP)U(PPP))" {_A_ 4 _U_ 2222 _N_ _N_ _N_ _N_} _N_ _N_ } } #-}
+instance Text ((Int, Int), (Int, Int))
+ {-# GHC_PRAGMA _M_ PreludeBuiltin {-dfun-} _A_ 0 _N_ _N_ _N_ _F_ _IF_ARGS_ 0 0 X 5 _!_ _TUP_4 [(Int -> [Char] -> [(((Int, Int), (Int, Int)), [Char])]), (Int -> ((Int, Int), (Int, Int)) -> [Char] -> [Char]), ([Char] -> [([((Int, Int), (Int, Int))], [Char])]), ([((Int, Int), (Int, Int))] -> [Char] -> [Char])] [_CONSTM_ Text readsPrec (((Int, Int), (Int, Int))), _CONSTM_ Text showsPrec (((Int, Int), (Int, Int))), _CONSTM_ Text readList (((Int, Int), (Int, Int))), _CONSTM_ Text showList (((Int, Int), (Int, Int)))] _N_
+ readsPrec = { _A_ 1 _U_ 02 _N_ _S_ "A" {_A_ 0 _U_ 2 _N_ _N_ _N_ _N_} _N_ _N_ },
+ showsPrec = { _A_ 3 _U_ 012 _N_ _S_ "AU(LL)L" {_A_ 3 _U_ 112 _N_ _N_ _N_ _N_} _N_ _N_ },
+ readList = { _A_ 0 _U_ 2 _N_ _N_ _N_ _N_ },
+ showList = { _A_ 1 _U_ 12 _N_ _N_ _N_ _N_ } #-}
instance Text ()
{-# GHC_PRAGMA _M_ PreludeBuiltin {-dfun-} _A_ 0 _N_ _N_ _N_ _F_ _IF_ARGS_ 0 0 X 5 _!_ _TUP_4 [(Int -> [Char] -> [((), [Char])]), (Int -> () -> [Char] -> [Char]), ([Char] -> [([()], [Char])]), ([()] -> [Char] -> [Char])] [_CONSTM_ Text readsPrec (()), _CONSTM_ Text showsPrec (()), _CONSTM_ Text readList (()), _CONSTM_ Text showList (())] _N_
- readsPrec = _A_ 1 _U_ 02 _N_ _S_ "A" {_A_ 0 _U_ 2 _N_ _N_ _N_ _N_} _N_ _N_,
- showsPrec = _A_ 3 _U_ 012 _N_ _S_ "AEL" {_A_ 2 _U_ 12 _N_ _N_ _F_ _IF_ARGS_ 0 2 CX 4 \ (u0 :: ()) (u1 :: [Char]) -> case u0 of { _ALG_ _TUP_0 -> _APP_ _TYAPP_ _ORIG_ PreludeList (++) { Char } [ _NOREP_S_ "()", u1 ]; _NO_DEFLT_ } _N_} _F_ _IF_ARGS_ 0 3 XCX 4 \ (u0 :: Int) (u1 :: ()) (u2 :: [Char]) -> case u1 of { _ALG_ _TUP_0 -> _APP_ _TYAPP_ _ORIG_ PreludeList (++) { Char } [ _NOREP_S_ "()", u2 ]; _NO_DEFLT_ } _N_,
- readList = _A_ 0 _U_ 2 _N_ _N_ _N_ _N_,
- showList = _A_ 0 _U_ 12 _N_ _N_ _N_ _N_ #-}
+ readsPrec = { _A_ 1 _U_ 02 _N_ _S_ "A" {_A_ 0 _U_ 2 _N_ _N_ _N_ _N_} _N_ _N_ },
+ showsPrec = { _A_ 3 _U_ 012 _N_ _S_ "AEL" {_A_ 2 _U_ 12 _N_ _N_ _F_ _IF_ARGS_ 0 2 CX 4 \ (u0 :: ()) (u1 :: [Char]) -> case u0 of { _ALG_ _TUP_0 -> _APP_ _TYAPP_ _ORIG_ PreludeList (++) { Char } [ _NOREP_S_ "()", u1 ]; _NO_DEFLT_ } _N_} _F_ _IF_ARGS_ 0 3 XCX 4 \ (u0 :: Int) (u1 :: ()) (u2 :: [Char]) -> case u1 of { _ALG_ _TUP_0 -> _APP_ _TYAPP_ _ORIG_ PreludeList (++) { Char } [ _NOREP_S_ "()", u2 ]; _NO_DEFLT_ } _N_ },
+ readList = { _A_ 0 _U_ 2 _N_ _N_ _N_ _N_ },
+ showList = { _A_ 1 _U_ 12 _N_ _N_ _N_ _N_ } #-}
instance (Text a, Text b) => Text (a, b)
{-# GHC_PRAGMA _M_ PreludeBuiltin {-dfun-} _A_ 2 _U_ 22 _N_ _N_ _N_ _N_ #-}
instance (Text a, Text b, Text c) => Text (a, b, c)
{-# GHC_PRAGMA _M_ PreludeBuiltin {-dfun-} _A_ 5 _U_ 22222 _N_ _N_ _N_ _N_ #-}
instance Text (Int, Int)
{-# GHC_PRAGMA _M_ PreludeBuiltin {-dfun-} _A_ 0 _N_ _N_ _N_ _F_ _IF_ARGS_ 0 0 X 5 _!_ _TUP_4 [(Int -> [Char] -> [((Int, Int), [Char])]), (Int -> (Int, Int) -> [Char] -> [Char]), ([Char] -> [([(Int, Int)], [Char])]), ([(Int, Int)] -> [Char] -> [Char])] [_CONSTM_ Text readsPrec ((Int, Int)), _CONSTM_ Text showsPrec ((Int, Int)), _CONSTM_ Text readList ((Int, Int)), _CONSTM_ Text showList ((Int, Int))] _N_
- readsPrec = _A_ 1 _U_ 02 _N_ _S_ "A" {_A_ 0 _U_ 2 _N_ _N_ _N_ _N_} _N_ _N_,
- showsPrec = _A_ 3 _U_ 012 _N_ _S_ "AU(LL)L" {_A_ 3 _U_ 112 _N_ _N_ _N_ _N_} _N_ _N_,
- readList = _A_ 0 _U_ 2 _N_ _N_ _N_ _N_,
- showList = _A_ 0 _U_ 12 _N_ _N_ _N_ _N_ #-}
+ readsPrec = { _A_ 1 _U_ 02 _N_ _S_ "A" {_A_ 0 _U_ 2 _N_ _N_ _N_ _N_} _N_ _N_ },
+ showsPrec = { _A_ 3 _U_ 012 _N_ _S_ "AU(LL)L" {_A_ 3 _U_ 112 _N_ _N_ _N_ _N_} _N_ _N_ },
+ readList = { _A_ 0 _U_ 2 _N_ _N_ _N_ _N_ },
+ showList = { _A_ 1 _U_ 12 _N_ _N_ _N_ _N_ } #-}
+instance Text (Int, Int, Int)
+ {-# GHC_PRAGMA _M_ PreludeBuiltin {-dfun-} _A_ 0 _N_ _N_ _N_ _F_ _IF_ARGS_ 0 0 X 5 _!_ _TUP_4 [(Int -> [Char] -> [((Int, Int, Int), [Char])]), (Int -> (Int, Int, Int) -> [Char] -> [Char]), ([Char] -> [([(Int, Int, Int)], [Char])]), ([(Int, Int, Int)] -> [Char] -> [Char])] [_CONSTM_ Text readsPrec ((Int, Int, Int)), _CONSTM_ Text showsPrec ((Int, Int, Int)), _CONSTM_ Text readList ((Int, Int, Int)), _CONSTM_ Text showList ((Int, Int, Int))] _N_
+ readsPrec = { _A_ 1 _U_ 02 _N_ _S_ "A" {_A_ 0 _U_ 2 _N_ _N_ _N_ _N_} _N_ _N_ },
+ showsPrec = { _A_ 3 _U_ 012 _N_ _S_ "AU(LLL)L" {_A_ 4 _U_ 1112 _N_ _N_ _N_ _N_} _N_ _N_ },
+ readList = { _A_ 0 _U_ 2 _N_ _N_ _N_ _N_ },
+ showList = { _A_ 1 _U_ 12 _N_ _N_ _N_ _N_ } #-}
instance Text (Integer, Integer)
{-# GHC_PRAGMA _M_ PreludeBuiltin {-dfun-} _A_ 0 _N_ _N_ _N_ _F_ _IF_ARGS_ 0 0 X 5 _!_ _TUP_4 [(Int -> [Char] -> [((Integer, Integer), [Char])]), (Int -> (Integer, Integer) -> [Char] -> [Char]), ([Char] -> [([(Integer, Integer)], [Char])]), ([(Integer, Integer)] -> [Char] -> [Char])] [_CONSTM_ Text readsPrec ((Integer, Integer)), _CONSTM_ Text showsPrec ((Integer, Integer)), _CONSTM_ Text readList ((Integer, Integer)), _CONSTM_ Text showList ((Integer, Integer))] _N_
- readsPrec = _A_ 1 _U_ 02 _N_ _S_ "A" {_A_ 0 _U_ 2 _N_ _N_ _N_ _N_} _N_ _N_,
- showsPrec = _A_ 3 _U_ 012 _N_ _S_ "AU(LL)L" {_A_ 3 _U_ 112 _N_ _N_ _N_ _N_} _N_ _N_,
- readList = _A_ 0 _U_ 2 _N_ _N_ _N_ _N_,
- showList = _A_ 0 _U_ 12 _N_ _N_ _N_ _N_ #-}
+ readsPrec = { _A_ 1 _U_ 02 _N_ _S_ "A" {_A_ 0 _U_ 2 _N_ _N_ _N_ _N_} _N_ _N_ },
+ showsPrec = { _A_ 3 _U_ 012 _N_ _S_ "AU(LL)L" {_A_ 3 _U_ 112 _N_ _N_ _N_ _N_} _N_ _N_ },
+ readList = { _A_ 0 _U_ 2 _N_ _N_ _N_ _N_ },
+ showList = { _A_ 1 _U_ 12 _N_ _N_ _N_ _N_ } #-}
instance Text (a -> b)
{-# GHC_PRAGMA _M_ PreludeCore {-dfun-} _A_ 0 _N_ _N_ _N_ _N_ _N_ #-}
+instance Text (Array (Int, Int) Double)
+ {-# GHC_PRAGMA _M_ PreludeArray {-dfun-} _A_ 0 _N_ _N_ _N_ _F_ _IF_ARGS_ 0 0 X 5 _!_ _TUP_4 [(Int -> [Char] -> [(Array (Int, Int) Double, [Char])]), (Int -> Array (Int, Int) Double -> [Char] -> [Char]), ([Char] -> [([Array (Int, Int) Double], [Char])]), ([Array (Int, Int) Double] -> [Char] -> [Char])] [_CONSTM_ Text readsPrec (Array (Int, Int) Double), _CONSTM_ Text showsPrec (Array (Int, Int) Double), _CONSTM_ Text readList (Array (Int, Int) Double), _CONSTM_ Text showList (Array (Int, Int) Double)] _N_
+ readsPrec = { _A_ 1 _U_ 12 _N_ _S_ "U(P)" {_A_ 1 _U_ 22 _N_ _N_ _N_ _N_} _N_ _N_ },
+ showsPrec = { _A_ 2 _U_ 122 _N_ _N_ _N_ _N_ },
+ readList = { _A_ 0 _U_ 2 _N_ _N_ _N_ _N_ },
+ showList = { _A_ 0 _U_ 12 _N_ _N_ _N_ _N_ } #-}
instance (Ix a, Text a, Text b) => Text (Array a b)
{-# GHC_PRAGMA _M_ PreludeArray {-dfun-} _A_ 3 _U_ 222 _N_ _N_ _N_ _N_ #-}
+instance Text (Array Int Double)
+ {-# GHC_PRAGMA _M_ PreludeArray {-dfun-} _A_ 0 _N_ _N_ _N_ _F_ _IF_ARGS_ 0 0 X 5 _!_ _TUP_4 [(Int -> [Char] -> [(Array Int Double, [Char])]), (Int -> Array Int Double -> [Char] -> [Char]), ([Char] -> [([Array Int Double], [Char])]), ([Array Int Double] -> [Char] -> [Char])] [_CONSTM_ Text readsPrec (Array Int Double), _CONSTM_ Text showsPrec (Array Int Double), _CONSTM_ Text readList (Array Int Double), _CONSTM_ Text showList (Array Int Double)] _N_
+ readsPrec = { _A_ 1 _U_ 12 _N_ _S_ "U(P)" {_A_ 1 _U_ 22 _N_ _N_ _N_ _N_} _N_ _N_ },
+ showsPrec = { _A_ 2 _U_ 122 _N_ _N_ _N_ _N_ },
+ readList = { _A_ 0 _U_ 2 _N_ _N_ _N_ _N_ },
+ showList = { _A_ 0 _U_ 12 _N_ _N_ _N_ _N_ } #-}
instance (Text a, Text b) => Text (Assoc a b)
{-# GHC_PRAGMA _M_ PreludeArray {-dfun-} _A_ 2 _U_ 22 _N_ _N_ _N_ _N_ #-}
instance Text Bool
{-# GHC_PRAGMA _M_ PreludeCore {-dfun-} _A_ 0 _N_ _N_ _N_ _F_ _IF_ARGS_ 0 0 X 5 _!_ _TUP_4 [(Int -> [Char] -> [(Bool, [Char])]), (Int -> Bool -> [Char] -> [Char]), ([Char] -> [([Bool], [Char])]), ([Bool] -> [Char] -> [Char])] [_CONSTM_ Text readsPrec (Bool), _CONSTM_ Text showsPrec (Bool), _CONSTM_ Text readList (Bool), _CONSTM_ Text showList (Bool)] _N_
- readsPrec = _A_ 2 _U_ 02 _N_ _S_ "AL" {_A_ 1 _U_ 2 _N_ _N_ _N_ _N_} _N_ _N_,
- showsPrec = _A_ 3 _U_ 012 _N_ _S_ "AEL" {_A_ 2 _U_ 12 _N_ _N_ _N_ _N_} _N_ _N_,
- readList = _A_ 0 _U_ 2 _N_ _N_ _N_ _N_,
- showList = _A_ 0 _U_ 12 _N_ _N_ _N_ _N_ #-}
+ readsPrec = { _A_ 2 _U_ 02 _N_ _S_ "AL" {_A_ 1 _U_ 2 _N_ _N_ _N_ _N_} _N_ _N_ },
+ showsPrec = { _A_ 3 _U_ 012 _N_ _S_ "AEL" {_A_ 2 _U_ 12 _N_ _N_ _N_ _N_} _N_ _N_ },
+ readList = { _A_ 0 _U_ 2 _N_ _N_ _N_ _N_ },
+ showList = { _A_ 1 _U_ 12 _N_ _N_ _F_ _IF_ARGS_ 0 1 X 3 \ (u0 :: [Bool]) -> _APP_ _TYAPP_ _ORIG_ PreludeCore _showList { Bool } [ _WRKR_ _CONSTM_ Text showsPrec (Bool), u0 ] _N_ } #-}
instance Text Char
{-# GHC_PRAGMA _M_ PreludeCore {-dfun-} _A_ 0 _N_ _N_ _N_ _F_ _IF_ARGS_ 0 0 X 5 _!_ _TUP_4 [(Int -> [Char] -> [(Char, [Char])]), (Int -> Char -> [Char] -> [Char]), ([Char] -> [([Char], [Char])]), ([Char] -> [Char] -> [Char])] [_CONSTM_ Text readsPrec (Char), _CONSTM_ Text showsPrec (Char), _CONSTM_ Text readList (Char), _CONSTM_ Text showList (Char)] _N_
- readsPrec = _A_ 1 _U_ 02 _N_ _S_ "A" {_A_ 0 _U_ 2 _N_ _N_ _N_ _N_} _N_ _N_,
- showsPrec = _A_ 3 _U_ 012 _N_ _S_ "AU(P)L" {_A_ 2 _U_ 22 _N_ _N_ _N_ _N_} _N_ _N_,
- readList = _A_ 0 _U_ 2 _N_ _N_ _N_ _N_,
- showList = _A_ 1 _U_ 22 _N_ _N_ _N_ _N_ #-}
+ readsPrec = { _A_ 1 _U_ 02 _N_ _S_ "A" {_A_ 0 _U_ 2 _N_ _N_ _N_ _N_} _N_ _N_ },
+ showsPrec = { _A_ 3 _U_ 012 _N_ _S_ "AU(P)L" {_A_ 2 _U_ 22 _N_ _N_ _N_ _N_} _N_ _N_ },
+ readList = { _A_ 0 _U_ 2 _N_ _N_ _N_ _N_ },
+ showList = { _A_ 1 _U_ 22 _N_ _N_ _N_ _N_ } #-}
instance Text a => Text (Complex a)
{-# GHC_PRAGMA _M_ PreludeComplex {-dfun-} _A_ 1 _U_ 2 _N_ _N_ _N_ _N_ #-}
+instance Text (Complex Double)
+ {-# GHC_PRAGMA _M_ PreludeComplex {-dfun-} _A_ 0 _N_ _N_ _N_ _F_ _IF_ARGS_ 0 0 X 5 _!_ _TUP_4 [(Int -> [Char] -> [(Complex Double, [Char])]), (Int -> Complex Double -> [Char] -> [Char]), ([Char] -> [([Complex Double], [Char])]), ([Complex Double] -> [Char] -> [Char])] [_CONSTM_ Text readsPrec (Complex Double), _CONSTM_ Text showsPrec (Complex Double), _CONSTM_ Text readList (Complex Double), _CONSTM_ Text showList (Complex Double)] _N_
+ readsPrec = { _A_ 1 _U_ 12 _N_ _S_ "U(P)" {_A_ 1 _U_ 22 _N_ _N_ _N_ _N_} _N_ _N_ },
+ showsPrec = { _A_ 2 _U_ 112 _N_ _S_ "LU(LL)" {_A_ 3 _U_ 1222 _N_ _N_ _N_ _N_} _N_ _N_ },
+ readList = { _A_ 0 _U_ 2 _N_ _N_ _N_ _N_ },
+ showList = { _A_ 1 _U_ 12 _N_ _N_ _N_ _N_ } #-}
instance Text Double
{-# GHC_PRAGMA _M_ PreludeCore {-dfun-} _A_ 0 _N_ _N_ _N_ _F_ _IF_ARGS_ 0 0 X 5 _!_ _TUP_4 [(Int -> [Char] -> [(Double, [Char])]), (Int -> Double -> [Char] -> [Char]), ([Char] -> [([Double], [Char])]), ([Double] -> [Char] -> [Char])] [_CONSTM_ Text readsPrec (Double), _CONSTM_ Text showsPrec (Double), _CONSTM_ Text readList (Double), _CONSTM_ Text showList (Double)] _N_
- readsPrec = _A_ 2 _U_ 02 _N_ _S_ "AL" {_A_ 1 _U_ 2 _N_ _N_ _F_ _IF_ARGS_ 0 1 X 3 \ (u0 :: [Char]) -> _APP_ _SPEC_ _ORIG_ PreludeText readSigned [ (Double) ] [ _SPEC_ _ORIG_ PreludeText readFloat [ (Double) ], u0 ] _N_} _F_ _IF_ARGS_ 0 2 XX 3 \ (u0 :: Int) (u1 :: [Char]) -> _APP_ _SPEC_ _ORIG_ PreludeText readSigned [ (Double) ] [ _SPEC_ _ORIG_ PreludeText readFloat [ (Double) ], u1 ] _N_,
- showsPrec = _A_ 2 _U_ 212 _N_ _S_ "LU(P)" {_A_ 2 _U_ 222 _N_ _N_ _F_ _IF_ARGS_ 0 2 XX 4 \ (u0 :: Int) (u1 :: Double#) -> _APP_ _WRKR_ _SPEC_ _ORIG_ PreludeText showSigned [ (Double) ] [ _SPEC_ _ORIG_ PreludeText showFloat [ (Double) ], u0, u1 ] _N_} _F_ _IF_ARGS_ 0 2 XC 5 \ (u0 :: Int) (u1 :: Double) -> case u1 of { _ALG_ D# (u2 :: Double#) -> _APP_ _WRKR_ _SPEC_ _ORIG_ PreludeText showSigned [ (Double) ] [ _SPEC_ _ORIG_ PreludeText showFloat [ (Double) ], u0, u2 ]; _NO_DEFLT_ } _N_,
- readList = _A_ 0 _U_ 2 _N_ _N_ _N_ _N_,
- showList = _A_ 0 _U_ 12 _N_ _N_ _N_ _N_ #-}
+ readsPrec = { _A_ 2 _U_ 02 _N_ _S_ "AL" {_A_ 1 _U_ 2 _N_ _N_ _F_ _IF_ARGS_ 0 1 X 3 \ (u0 :: [Char]) -> _APP_ _SPEC_ _ORIG_ PreludeText readSigned [ (Double) ] [ _SPEC_ _ORIG_ PreludeText readFloat [ (Double) ], u0 ] _N_} _F_ _IF_ARGS_ 0 2 XX 3 \ (u0 :: Int) (u1 :: [Char]) -> _APP_ _SPEC_ _ORIG_ PreludeText readSigned [ (Double) ] [ _SPEC_ _ORIG_ PreludeText readFloat [ (Double) ], u1 ] _N_ },
+ showsPrec = { _A_ 2 _U_ 212 _N_ _S_ "LU(P)" {_A_ 2 _U_ 222 _N_ _N_ _F_ _IF_ARGS_ 0 2 XX 4 \ (u0 :: Int) (u1 :: Double#) -> _APP_ _WRKR_ _SPEC_ _ORIG_ PreludeText showSigned [ (Double) ] [ _SPEC_ _ORIG_ PreludeText showFloat [ (Double) ], u0, u1 ] _N_} _F_ _IF_ARGS_ 0 2 XC 5 \ (u0 :: Int) (u1 :: Double) -> case u1 of { _ALG_ D# (u2 :: Double#) -> _APP_ _WRKR_ _SPEC_ _ORIG_ PreludeText showSigned [ (Double) ] [ _SPEC_ _ORIG_ PreludeText showFloat [ (Double) ], u0, u2 ]; _NO_DEFLT_ } _N_ },
+ readList = { _A_ 0 _U_ 2 _N_ _N_ _N_ _N_ },
+ showList = { _A_ 1 _U_ 12 _N_ _N_ _N_ _N_ } #-}
instance Text Float
{-# GHC_PRAGMA _M_ PreludeCore {-dfun-} _A_ 0 _N_ _N_ _N_ _F_ _IF_ARGS_ 0 0 X 5 _!_ _TUP_4 [(Int -> [Char] -> [(Float, [Char])]), (Int -> Float -> [Char] -> [Char]), ([Char] -> [([Float], [Char])]), ([Float] -> [Char] -> [Char])] [_CONSTM_ Text readsPrec (Float), _CONSTM_ Text showsPrec (Float), _CONSTM_ Text readList (Float), _CONSTM_ Text showList (Float)] _N_
- readsPrec = _A_ 2 _U_ 02 _N_ _S_ "AL" {_A_ 1 _U_ 2 _N_ _N_ _N_ _N_} _N_ _N_,
- showsPrec = _A_ 1 _U_ 222 _N_ _N_ _N_ _N_,
- readList = _A_ 0 _U_ 2 _N_ _N_ _N_ _N_,
- showList = _A_ 0 _U_ 12 _N_ _N_ _N_ _N_ #-}
+ readsPrec = { _A_ 2 _U_ 02 _N_ _S_ "AL" {_A_ 1 _U_ 2 _N_ _N_ _N_ _N_} _N_ _N_ },
+ showsPrec = { _A_ 1 _U_ 222 _N_ _N_ _N_ _N_ },
+ readList = { _A_ 0 _U_ 2 _N_ _N_ _N_ _N_ },
+ showList = { _A_ 0 _U_ 12 _N_ _N_ _N_ _N_ } #-}
instance Text Int
{-# GHC_PRAGMA _M_ PreludeCore {-dfun-} _A_ 0 _N_ _N_ _N_ _F_ _IF_ARGS_ 0 0 X 5 _!_ _TUP_4 [(Int -> [Char] -> [(Int, [Char])]), (Int -> Int -> [Char] -> [Char]), ([Char] -> [([Int], [Char])]), ([Int] -> [Char] -> [Char])] [_CONSTM_ Text readsPrec (Int), _CONSTM_ Text showsPrec (Int), _CONSTM_ Text readList (Int), _CONSTM_ Text showList (Int)] _N_
- readsPrec = _A_ 2 _U_ 02 _N_ _S_ "AL" {_A_ 1 _U_ 2 _N_ _N_ _F_ _IF_ARGS_ 0 1 X 3 \ (u0 :: [Char]) -> _APP_ _SPEC_ _ORIG_ PreludeText readSigned [ (Int) ] [ _SPEC_ _ORIG_ PreludeText readDec [ (Int) ], u0 ] _N_} _F_ _IF_ARGS_ 0 2 XX 3 \ (u0 :: Int) (u1 :: [Char]) -> _APP_ _SPEC_ _ORIG_ PreludeText readSigned [ (Int) ] [ _SPEC_ _ORIG_ PreludeText readDec [ (Int) ], u1 ] _N_,
- showsPrec = _A_ 3 _U_ 212 _N_ _S_ "LU(P)L" {_A_ 3 _U_ 222 _N_ _N_ _N_ _N_} _N_ _N_,
- readList = _A_ 0 _U_ 2 _N_ _N_ _N_ _N_,
- showList = _A_ 0 _U_ 12 _N_ _N_ _N_ _N_ #-}
+ readsPrec = { _A_ 2 _U_ 02 _N_ _S_ "AL" {_A_ 1 _U_ 2 _N_ _N_ _F_ _IF_ARGS_ 0 1 X 3 \ (u0 :: [Char]) -> _APP_ _SPEC_ _ORIG_ PreludeText readSigned [ (Int) ] [ _SPEC_ _ORIG_ PreludeText readDec [ (Int) ], u0 ] _N_} _F_ _IF_ARGS_ 0 2 XX 3 \ (u0 :: Int) (u1 :: [Char]) -> _APP_ _SPEC_ _ORIG_ PreludeText readSigned [ (Int) ] [ _SPEC_ _ORIG_ PreludeText readDec [ (Int) ], u1 ] _N_ },
+ showsPrec = { _A_ 3 _U_ 212 _N_ _S_ "LU(P)L" {_A_ 3 _U_ 222 _N_ _N_ _N_ _N_} _N_ _N_ },
+ readList = { _A_ 0 _U_ 2 _N_ _N_ _N_ _N_ },
+ showList = { _A_ 1 _U_ 12 _N_ _N_ _N_ _N_ } #-}
instance Text Integer
{-# GHC_PRAGMA _M_ PreludeCore {-dfun-} _A_ 0 _N_ _N_ _N_ _F_ _IF_ARGS_ 0 0 X 5 _!_ _TUP_4 [(Int -> [Char] -> [(Integer, [Char])]), (Int -> Integer -> [Char] -> [Char]), ([Char] -> [([Integer], [Char])]), ([Integer] -> [Char] -> [Char])] [_CONSTM_ Text readsPrec (Integer), _CONSTM_ Text showsPrec (Integer), _CONSTM_ Text readList (Integer), _CONSTM_ Text showList (Integer)] _N_
- readsPrec = _A_ 2 _U_ 02 _N_ _S_ "AL" {_A_ 1 _U_ 2 _N_ _N_ _F_ _IF_ARGS_ 0 1 X 3 \ (u0 :: [Char]) -> _APP_ _SPEC_ _ORIG_ PreludeText readSigned [ (Integer) ] [ _SPEC_ _ORIG_ PreludeText readDec [ (Integer) ], u0 ] _N_} _F_ _IF_ARGS_ 0 2 XX 3 \ (u0 :: Int) (u1 :: [Char]) -> _APP_ _SPEC_ _ORIG_ PreludeText readSigned [ (Integer) ] [ _SPEC_ _ORIG_ PreludeText readDec [ (Integer) ], u1 ] _N_,
- showsPrec = _A_ 3 _U_ 212 _N_ _S_ "LU(PPP)L" {_A_ 5 _U_ 22222 _N_ _N_ _N_ _N_} _N_ _N_,
- readList = _A_ 0 _U_ 2 _N_ _N_ _N_ _N_,
- showList = _A_ 0 _U_ 12 _N_ _N_ _N_ _N_ #-}
+ readsPrec = { _A_ 2 _U_ 02 _N_ _S_ "AL" {_A_ 1 _U_ 2 _N_ _N_ _F_ _IF_ARGS_ 0 1 X 3 \ (u0 :: [Char]) -> _APP_ _SPEC_ _ORIG_ PreludeText readSigned [ (Integer) ] [ _SPEC_ _ORIG_ PreludeText readDec [ (Integer) ], u0 ] _N_} _F_ _IF_ARGS_ 0 2 XX 3 \ (u0 :: Int) (u1 :: [Char]) -> _APP_ _SPEC_ _ORIG_ PreludeText readSigned [ (Integer) ] [ _SPEC_ _ORIG_ PreludeText readDec [ (Integer) ], u1 ] _N_ },
+ showsPrec = { _A_ 3 _U_ 212 _N_ _S_ "LU(PPP)L" {_A_ 5 _U_ 22222 _N_ _N_ _N_ _N_} _N_ _N_ },
+ readList = { _A_ 0 _U_ 2 _N_ _N_ _N_ _N_ },
+ showList = { _A_ 1 _U_ 12 _N_ _N_ _N_ _N_ } #-}
instance Integral a => Text (Ratio a)
{-# GHC_PRAGMA _M_ PreludeRatio {-dfun-} _A_ 1 _U_ 2 _N_ _N_ _N_ _N_ #-}
instance Text (Ratio Integer)
{-# GHC_PRAGMA _M_ PreludeRatio {-dfun-} _A_ 0 _N_ _N_ _N_ _F_ _IF_ARGS_ 0 0 X 5 _!_ _TUP_4 [(Int -> [Char] -> [(Ratio Integer, [Char])]), (Int -> Ratio Integer -> [Char] -> [Char]), ([Char] -> [([Ratio Integer], [Char])]), ([Ratio Integer] -> [Char] -> [Char])] [_CONSTM_ Text readsPrec (Ratio Integer), _CONSTM_ Text showsPrec (Ratio Integer), _CONSTM_ Text readList (Ratio Integer), _CONSTM_ Text showList (Ratio Integer)] _N_
- readsPrec = _A_ 1 _U_ 12 _N_ _S_ "U(P)" {_A_ 1 _U_ 22 _N_ _N_ _N_ _N_} _N_ _N_,
- showsPrec = _A_ 2 _U_ 112 _N_ _S_ "LU(LL)" {_A_ 3 _U_ 1222 _N_ _N_ _N_ _N_} _N_ _N_,
- readList = _A_ 0 _U_ 2 _N_ _N_ _N_ _N_,
- showList = _A_ 0 _U_ 12 _N_ _N_ _N_ _N_ #-}
+ readsPrec = { _A_ 1 _U_ 12 _N_ _S_ "U(P)" {_A_ 1 _U_ 22 _N_ _N_ _N_ _N_} _N_ _N_ },
+ showsPrec = { _A_ 2 _U_ 112 _N_ _S_ "LU(LL)" {_A_ 3 _U_ 1222 _N_ _N_ _N_ _N_} _N_ _N_ },
+ readList = { _A_ 0 _U_ 2 _N_ _N_ _N_ _N_ },
+ showList = { _A_ 1 _U_ 12 _N_ _N_ _N_ _N_ } #-}
instance Text a => Text [a]
{-# GHC_PRAGMA _M_ PreludeBuiltin {-dfun-} _A_ 1 _U_ 2 _N_ _N_ _N_ _N_ #-}
+instance Text [Bool]
+ {-# GHC_PRAGMA _M_ PreludeBuiltin {-dfun-} _A_ 0 _N_ _N_ _N_ _F_ _IF_ARGS_ 0 0 X 5 _!_ _TUP_4 [(Int -> [Char] -> [([Bool], [Char])]), (Int -> [Bool] -> [Char] -> [Char]), ([Char] -> [([[Bool]], [Char])]), ([[Bool]] -> [Char] -> [Char])] [_CONSTM_ Text readsPrec ([Bool]), _CONSTM_ Text showsPrec ([Bool]), _CONSTM_ Text readList ([Bool]), _CONSTM_ Text showList ([Bool])] _N_
+ readsPrec = { _A_ 1 _U_ 02 _N_ _S_ "A" {_A_ 0 _U_ 2 _N_ _N_ _F_ _IF_ARGS_ 0 0 X 1 _CONSTM_ Text readList (Bool) _N_} _F_ _IF_ARGS_ 0 1 X 1 \ (u0 :: Int) -> _CONSTM_ Text readList (Bool) _N_ },
+ showsPrec = { _A_ 2 _U_ 012 _N_ _S_ "AS" {_A_ 1 _U_ 12 _N_ _N_ _F_ _IF_ARGS_ 0 1 X 3 \ (u0 :: [Bool]) -> _APP_ _TYAPP_ _ORIG_ PreludeCore _showList { Bool } [ _WRKR_ _CONSTM_ Text showsPrec (Bool), u0 ] _N_} _F_ _IF_ARGS_ 0 2 XX 3 \ (u0 :: Int) (u1 :: [Bool]) -> _APP_ _TYAPP_ _ORIG_ PreludeCore _showList { Bool } [ _WRKR_ _CONSTM_ Text showsPrec (Bool), u1 ] _N_ },
+ readList = { _A_ 0 _U_ 2 _N_ _N_ _N_ _N_ },
+ showList = { _A_ 1 _U_ 12 _N_ _N_ _N_ _N_ } #-}
instance Text [Char]
{-# GHC_PRAGMA _M_ PreludeBuiltin {-dfun-} _A_ 0 _N_ _N_ _N_ _F_ _IF_ARGS_ 0 0 X 5 _!_ _TUP_4 [(Int -> [Char] -> [([Char], [Char])]), (Int -> [Char] -> [Char] -> [Char]), ([Char] -> [([[Char]], [Char])]), ([[Char]] -> [Char] -> [Char])] [_CONSTM_ Text readsPrec ([Char]), _CONSTM_ Text showsPrec ([Char]), _CONSTM_ Text readList ([Char]), _CONSTM_ Text showList ([Char])] _N_
- readsPrec = _A_ 1 _U_ 02 _N_ _S_ "A" {_A_ 0 _U_ 2 _N_ _N_ _F_ _IF_ARGS_ 0 0 X 1 _CONSTM_ Text readList (Char) _N_} _F_ _IF_ARGS_ 0 1 X 1 \ (u0 :: Int) -> _CONSTM_ Text readList (Char) _N_,
- showsPrec = _A_ 2 _U_ 022 _N_ _S_ "AL" {_A_ 1 _U_ 22 _N_ _N_ _F_ _IF_ARGS_ 0 0 X 1 _CONSTM_ Text showList (Char) _N_} _F_ _IF_ARGS_ 0 2 XX 2 \ (u0 :: Int) (u1 :: [Char]) -> _APP_ _CONSTM_ Text showList (Char) [ u1 ] _N_,
- readList = _A_ 0 _U_ 2 _N_ _N_ _N_ _N_,
- showList = _A_ 0 _U_ 12 _N_ _N_ _N_ _N_ #-}
+ readsPrec = { _A_ 1 _U_ 02 _N_ _S_ "A" {_A_ 0 _U_ 2 _N_ _N_ _F_ _IF_ARGS_ 0 0 X 1 _CONSTM_ Text readList (Char) _N_} _F_ _IF_ARGS_ 0 1 X 1 \ (u0 :: Int) -> _CONSTM_ Text readList (Char) _N_ },
+ showsPrec = { _A_ 2 _U_ 022 _N_ _S_ "AL" {_A_ 1 _U_ 22 _N_ _N_ _F_ _IF_ARGS_ 0 0 X 1 _CONSTM_ Text showList (Char) _N_} _F_ _IF_ARGS_ 0 2 XX 2 \ (u0 :: Int) (u1 :: [Char]) -> _APP_ _CONSTM_ Text showList (Char) [ u1 ] _N_ },
+ readList = { _A_ 0 _U_ 2 _N_ _N_ _N_ _N_ },
+ showList = { _A_ 1 _U_ 12 _N_ _N_ _F_ _IF_ARGS_ 0 1 X 3 \ (u0 :: [[Char]]) -> _APP_ _TYAPP_ _ORIG_ PreludeCore _showList { [Char] } [ _CONSTM_ Text showList (Char), u0 ] _N_ } #-}
+instance Text [Complex Double]
+ {-# GHC_PRAGMA _M_ PreludeBuiltin {-dfun-} _A_ 0 _N_ _N_ _N_ _F_ _IF_ARGS_ 0 0 X 5 _!_ _TUP_4 [(Int -> [Char] -> [([Complex Double], [Char])]), (Int -> [Complex Double] -> [Char] -> [Char]), ([Char] -> [([[Complex Double]], [Char])]), ([[Complex Double]] -> [Char] -> [Char])] [_CONSTM_ Text readsPrec ([Complex Double]), _CONSTM_ Text showsPrec ([Complex Double]), _CONSTM_ Text readList ([Complex Double]), _CONSTM_ Text showList ([Complex Double])] _N_
+ readsPrec = { _A_ 1 _U_ 02 _N_ _S_ "A" {_A_ 0 _U_ 2 _N_ _N_ _F_ _IF_ARGS_ 0 0 X 1 _CONSTM_ Text readList (Complex Double) _N_} _F_ _IF_ARGS_ 0 1 X 1 \ (u0 :: Int) -> _CONSTM_ Text readList (Complex Double) _N_ },
+ showsPrec = { _A_ 2 _U_ 022 _N_ _S_ "AL" {_A_ 1 _U_ 22 _N_ _N_ _F_ _IF_ARGS_ 0 0 X 1 _CONSTM_ Text showList (Complex Double) _N_} _F_ _IF_ARGS_ 0 2 XX 2 \ (u0 :: Int) (u1 :: [Complex Double]) -> _APP_ _CONSTM_ Text showList (Complex Double) [ u1 ] _N_ },
+ readList = { _A_ 0 _U_ 2 _N_ _N_ _N_ _N_ },
+ showList = { _A_ 1 _U_ 12 _N_ _N_ _F_ _IF_ARGS_ 0 1 X 3 \ (u0 :: [[Complex Double]]) -> _APP_ _TYAPP_ _ORIG_ PreludeCore _showList { [Complex Double] } [ _CONSTM_ Text showList (Complex Double), u0 ] _N_ } #-}
+instance Text [Double]
+ {-# GHC_PRAGMA _M_ PreludeBuiltin {-dfun-} _A_ 0 _N_ _N_ _N_ _F_ _IF_ARGS_ 0 0 X 5 _!_ _TUP_4 [(Int -> [Char] -> [([Double], [Char])]), (Int -> [Double] -> [Char] -> [Char]), ([Char] -> [([[Double]], [Char])]), ([[Double]] -> [Char] -> [Char])] [_CONSTM_ Text readsPrec ([Double]), _CONSTM_ Text showsPrec ([Double]), _CONSTM_ Text readList ([Double]), _CONSTM_ Text showList ([Double])] _N_
+ readsPrec = { _A_ 1 _U_ 02 _N_ _S_ "A" {_A_ 0 _U_ 2 _N_ _N_ _F_ _IF_ARGS_ 0 0 X 1 _CONSTM_ Text readList (Double) _N_} _F_ _IF_ARGS_ 0 1 X 1 \ (u0 :: Int) -> _CONSTM_ Text readList (Double) _N_ },
+ showsPrec = { _A_ 2 _U_ 022 _N_ _S_ "AL" {_A_ 1 _U_ 22 _N_ _N_ _F_ _IF_ARGS_ 0 0 X 1 _CONSTM_ Text showList (Double) _N_} _F_ _IF_ARGS_ 0 2 XX 2 \ (u0 :: Int) (u1 :: [Double]) -> _APP_ _CONSTM_ Text showList (Double) [ u1 ] _N_ },
+ readList = { _A_ 0 _U_ 2 _N_ _N_ _N_ _N_ },
+ showList = { _A_ 1 _U_ 12 _N_ _N_ _F_ _IF_ARGS_ 0 1 X 3 \ (u0 :: [[Double]]) -> _APP_ _TYAPP_ _ORIG_ PreludeCore _showList { [Double] } [ _CONSTM_ Text showList (Double), u0 ] _N_ } #-}
instance Text [Int]
{-# GHC_PRAGMA _M_ PreludeBuiltin {-dfun-} _A_ 0 _N_ _N_ _N_ _F_ _IF_ARGS_ 0 0 X 5 _!_ _TUP_4 [(Int -> [Char] -> [([Int], [Char])]), (Int -> [Int] -> [Char] -> [Char]), ([Char] -> [([[Int]], [Char])]), ([[Int]] -> [Char] -> [Char])] [_CONSTM_ Text readsPrec ([Int]), _CONSTM_ Text showsPrec ([Int]), _CONSTM_ Text readList ([Int]), _CONSTM_ Text showList ([Int])] _N_
- readsPrec = _A_ 1 _U_ 02 _N_ _S_ "A" {_A_ 0 _U_ 2 _N_ _N_ _F_ _IF_ARGS_ 0 0 X 1 _CONSTM_ Text readList (Int) _N_} _F_ _IF_ARGS_ 0 1 X 1 \ (u0 :: Int) -> _CONSTM_ Text readList (Int) _N_,
- showsPrec = _A_ 1 _U_ 022 _N_ _S_ "A" {_A_ 0 _U_ 22 _N_ _N_ _F_ _IF_ARGS_ 0 0 X 1 _CONSTM_ Text showList (Int) _N_} _F_ _IF_ARGS_ 0 1 X 1 \ (u0 :: Int) -> _CONSTM_ Text showList (Int) _N_,
- readList = _A_ 0 _U_ 2 _N_ _N_ _N_ _N_,
- showList = _A_ 0 _U_ 12 _N_ _N_ _N_ _N_ #-}
+ readsPrec = { _A_ 1 _U_ 02 _N_ _S_ "A" {_A_ 0 _U_ 2 _N_ _N_ _F_ _IF_ARGS_ 0 0 X 1 _CONSTM_ Text readList (Int) _N_} _F_ _IF_ARGS_ 0 1 X 1 \ (u0 :: Int) -> _CONSTM_ Text readList (Int) _N_ },
+ showsPrec = { _A_ 2 _U_ 022 _N_ _S_ "AL" {_A_ 1 _U_ 22 _N_ _N_ _F_ _IF_ARGS_ 0 0 X 1 _CONSTM_ Text showList (Int) _N_} _F_ _IF_ARGS_ 0 2 XX 2 \ (u0 :: Int) (u1 :: [Int]) -> _APP_ _CONSTM_ Text showList (Int) [ u1 ] _N_ },
+ readList = { _A_ 0 _U_ 2 _N_ _N_ _N_ _N_ },
+ showList = { _A_ 1 _U_ 12 _N_ _N_ _F_ _IF_ARGS_ 0 1 X 3 \ (u0 :: [[Int]]) -> _APP_ _TYAPP_ _ORIG_ PreludeCore _showList { [Int] } [ _CONSTM_ Text showList (Int), u0 ] _N_ } #-}
+instance Text [Integer]
+ {-# GHC_PRAGMA _M_ PreludeBuiltin {-dfun-} _A_ 0 _N_ _N_ _N_ _F_ _IF_ARGS_ 0 0 X 5 _!_ _TUP_4 [(Int -> [Char] -> [([Integer], [Char])]), (Int -> [Integer] -> [Char] -> [Char]), ([Char] -> [([[Integer]], [Char])]), ([[Integer]] -> [Char] -> [Char])] [_CONSTM_ Text readsPrec ([Integer]), _CONSTM_ Text showsPrec ([Integer]), _CONSTM_ Text readList ([Integer]), _CONSTM_ Text showList ([Integer])] _N_
+ readsPrec = { _A_ 1 _U_ 02 _N_ _S_ "A" {_A_ 0 _U_ 2 _N_ _N_ _F_ _IF_ARGS_ 0 0 X 1 _CONSTM_ Text readList (Integer) _N_} _F_ _IF_ARGS_ 0 1 X 1 \ (u0 :: Int) -> _CONSTM_ Text readList (Integer) _N_ },
+ showsPrec = { _A_ 2 _U_ 022 _N_ _S_ "AL" {_A_ 1 _U_ 22 _N_ _N_ _F_ _IF_ARGS_ 0 0 X 1 _CONSTM_ Text showList (Integer) _N_} _F_ _IF_ARGS_ 0 2 XX 2 \ (u0 :: Int) (u1 :: [Integer]) -> _APP_ _CONSTM_ Text showList (Integer) [ u1 ] _N_ },
+ readList = { _A_ 0 _U_ 2 _N_ _N_ _N_ _N_ },
+ showList = { _A_ 1 _U_ 12 _N_ _N_ _F_ _IF_ARGS_ 0 1 X 3 \ (u0 :: [[Integer]]) -> _APP_ _TYAPP_ _ORIG_ PreludeCore _showList { [Integer] } [ _CONSTM_ Text showList (Integer), u0 ] _N_ } #-}
+instance Text [[Char]]
+ {-# GHC_PRAGMA _M_ PreludeBuiltin {-dfun-} _A_ 0 _N_ _N_ _N_ _F_ _IF_ARGS_ 0 0 X 5 _!_ _TUP_4 [(Int -> [Char] -> [([[Char]], [Char])]), (Int -> [[Char]] -> [Char] -> [Char]), ([Char] -> [([[[Char]]], [Char])]), ([[[Char]]] -> [Char] -> [Char])] [_CONSTM_ Text readsPrec ([[Char]]), _CONSTM_ Text showsPrec ([[Char]]), _CONSTM_ Text readList ([[Char]]), _CONSTM_ Text showList ([[Char]])] _N_
+ readsPrec = { _A_ 1 _U_ 02 _N_ _S_ "A" {_A_ 0 _U_ 2 _N_ _N_ _F_ _IF_ARGS_ 0 0 X 1 _CONSTM_ Text readList ([Char]) _N_} _F_ _IF_ARGS_ 0 1 X 1 \ (u0 :: Int) -> _CONSTM_ Text readList ([Char]) _N_ },
+ showsPrec = { _A_ 2 _U_ 012 _N_ _S_ "AS" {_A_ 1 _U_ 12 _N_ _N_ _F_ _IF_ARGS_ 0 1 X 3 \ (u0 :: [[Char]]) -> _APP_ _TYAPP_ _ORIG_ PreludeCore _showList { [Char] } [ _CONSTM_ Text showList (Char), u0 ] _N_} _F_ _IF_ARGS_ 0 2 XX 2 \ (u0 :: Int) (u1 :: [[Char]]) -> _APP_ _CONSTM_ Text showList ([Char]) [ u1 ] _N_ },
+ readList = { _A_ 0 _U_ 2 _N_ _N_ _N_ _N_ },
+ showList = { _A_ 1 _U_ 12 _N_ _N_ _N_ _N_ } #-}
+instance Text [[Int]]
+ {-# GHC_PRAGMA _M_ PreludeBuiltin {-dfun-} _A_ 0 _N_ _N_ _N_ _F_ _IF_ARGS_ 0 0 X 5 _!_ _TUP_4 [(Int -> [Char] -> [([[Int]], [Char])]), (Int -> [[Int]] -> [Char] -> [Char]), ([Char] -> [([[[Int]]], [Char])]), ([[[Int]]] -> [Char] -> [Char])] [_CONSTM_ Text readsPrec ([[Int]]), _CONSTM_ Text showsPrec ([[Int]]), _CONSTM_ Text readList ([[Int]]), _CONSTM_ Text showList ([[Int]])] _N_
+ readsPrec = { _A_ 1 _U_ 02 _N_ _S_ "A" {_A_ 0 _U_ 2 _N_ _N_ _F_ _IF_ARGS_ 0 0 X 1 _CONSTM_ Text readList ([Int]) _N_} _F_ _IF_ARGS_ 0 1 X 1 \ (u0 :: Int) -> _CONSTM_ Text readList ([Int]) _N_ },
+ showsPrec = { _A_ 2 _U_ 012 _N_ _S_ "AS" {_A_ 1 _U_ 12 _N_ _N_ _F_ _IF_ARGS_ 0 1 X 3 \ (u0 :: [[Int]]) -> _APP_ _TYAPP_ _ORIG_ PreludeCore _showList { [Int] } [ _CONSTM_ Text showList (Int), u0 ] _N_} _F_ _IF_ARGS_ 0 2 XX 2 \ (u0 :: Int) (u1 :: [[Int]]) -> _APP_ _CONSTM_ Text showList ([Int]) [ u1 ] _N_ },
+ readList = { _A_ 0 _U_ 2 _N_ _N_ _N_ _N_ },
+ showList = { _A_ 1 _U_ 12 _N_ _N_ _N_ _N_ } #-}
instance Text _PackedString
{-# GHC_PRAGMA _M_ PreludePS {-dfun-} _A_ 0 _N_ _N_ _N_ _F_ _IF_ARGS_ 0 0 X 5 _!_ _TUP_4 [(Int -> [Char] -> [(_PackedString, [Char])]), (Int -> _PackedString -> [Char] -> [Char]), ([Char] -> [([_PackedString], [Char])]), ([_PackedString] -> [Char] -> [Char])] [_CONSTM_ Text readsPrec (_PackedString), _CONSTM_ Text showsPrec (_PackedString), _CONSTM_ Text readList (_PackedString), _CONSTM_ Text showList (_PackedString)] _N_
- readsPrec = _A_ 2 _U_ 02 _N_ _S_ _!_ _F_ _IF_ARGS_ 0 2 XX 3 \ (u0 :: Int) (u1 :: [Char]) -> _APP_ _TYAPP_ error { ([Char] -> [(_PackedString, [Char])]) } [ _NOREP_S_ "readsPrec: _PackedString: ToDo", u1 ] _N_,
- showsPrec = _A_ 3 _U_ 012 _N_ _S_ "ALL" {_A_ 2 _U_ 12 _N_ _N_ _N_ _N_} _F_ _IF_ARGS_ 0 3 XXX 6 \ (u0 :: Int) (u1 :: _PackedString) (u2 :: [Char]) -> let {(u3 :: [Char]) = _APP_ _ORIG_ PreludePS _unpackPS [ u1 ]} in _APP_ _CONSTM_ Text showList (Char) [ u3, u2 ] _N_,
- readList = _A_ 0 _U_ 2 _N_ _N_ _N_ _N_,
- showList = _A_ 0 _U_ 12 _N_ _N_ _N_ _N_ #-}
+ readsPrec = { _A_ 2 _U_ 02 _N_ _S_ _!_ _N_ _N_ },
+ showsPrec = { _A_ 3 _U_ 012 _N_ _S_ "ALL" {_A_ 2 _U_ 12 _N_ _N_ _N_ _N_} _F_ _IF_ARGS_ 0 3 XXX 6 \ (u0 :: Int) (u1 :: _PackedString) (u2 :: [Char]) -> let {(u3 :: [Char]) = _APP_ _ORIG_ PreludePS _unpackPS [ u1 ]} in _APP_ _CONSTM_ Text showList (Char) [ u3, u2 ] _N_ },
+ readList = { _A_ 0 _U_ 2 _N_ _N_ _N_ _N_ },
+ showList = { _A_ 1 _U_ 12 _N_ _N_ _F_ _IF_ARGS_ 0 1 X 3 \ (u0 :: [_PackedString]) -> _APP_ _TYAPP_ _ORIG_ PreludeCore _showList { _PackedString } [ _WRKR_ _CONSTM_ Text showsPrec (_PackedString), u0 ] _N_ } #-}
instance _CCallable Char
{-# GHC_PRAGMA _M_ PreludeCore {-dfun-} _A_ 0 _N_ _N_ _N_ _F_ _IF_ARGS_ 0 0 X 1 _!_ _TUP_0 [] [] _N_ #-}
instance _CCallable Double
-{-# GHC_PRAGMA INTERFACE VERSION 5 #-}
+{-# GHC_PRAGMA INTERFACE VERSION 6 #-}
interface PreludeCore where
import PreludeArray(Array, Assoc(..), _ByteArray)
import PreludeBuiltin(Bin, Char(..), Double(..), Float(..), Int(..), Integer(..), List(..), Tuple0, Tuple2, Tuple3, Tuple4, Tuple5, _Addr(..), _CMP_TAG(..), _Word(..))
class Binary a where
readBin :: Bin -> (a, Bin)
{-# GHC_PRAGMA {-meth-} _A_ 1 _U_ 12 _N_ _S_ "S" _F_ _IF_ARGS_ 1 1 C 2 _/\_ u0 -> \ (u1 :: (Bin -> (u0, Bin), u0 -> Bin -> Bin)) -> case u1 of { _ALG_ _TUP_2 (u2 :: Bin -> (u0, Bin)) (u3 :: u0 -> Bin -> Bin) -> u2; _NO_DEFLT_ } _N_
- {-defm-} _A_ 2 _U_ 02 _N_ _S_ _!_ _F_ _IF_ARGS_ 1 2 XX 3 _/\_ u0 -> \ (u1 :: {{Binary u0}}) (u2 :: Bin) -> _APP_ _TYAPP_ patError# { (Bin -> (u0, Bin)) } [ _NOREP_S_ "%DPreludeCore.Binary.readBin\"", u2 ] _N_ #-}
+ {-defm-} _A_ 2 _U_ 02 _N_ _S_ _!_ _N_ _N_ #-}
showBin :: a -> Bin -> Bin
{-# GHC_PRAGMA {-meth-} _A_ 1 _U_ 122 _N_ _S_ "S" _F_ _IF_ARGS_ 1 1 C 2 _/\_ u0 -> \ (u1 :: (Bin -> (u0, Bin), u0 -> Bin -> Bin)) -> case u1 of { _ALG_ _TUP_2 (u2 :: Bin -> (u0, Bin)) (u3 :: u0 -> Bin -> Bin) -> u3; _NO_DEFLT_ } _N_
- {-defm-} _A_ 3 _U_ 022 _N_ _S_ _!_ _F_ _IF_ARGS_ 1 3 XXX 4 _/\_ u0 -> \ (u1 :: {{Binary u0}}) (u2 :: u0) (u3 :: Bin) -> _APP_ _TYAPP_ patError# { (u0 -> Bin -> Bin) } [ _NOREP_S_ "%DPreludeCore.Binary.showBin\"", u2, u3 ] _N_ #-}
+ {-defm-} _A_ 3 _U_ 022 _N_ _S_ _!_ _N_ _N_ #-}
class (Ord a) => Enum a {-# GHC_PRAGMA {-superdicts-} _A_ 1 _U_ 1 _N_ _S_ "S" _F_ _IF_ARGS_ 1 1 C 2 _/\_ u0 -> \ (u1 :: ({{Ord u0}}, u0 -> [u0], u0 -> u0 -> [u0], u0 -> u0 -> [u0], u0 -> u0 -> u0 -> [u0])) -> case u1 of { _ALG_ _TUP_5 (u2 :: {{Ord u0}}) (u3 :: u0 -> [u0]) (u4 :: u0 -> u0 -> [u0]) (u5 :: u0 -> u0 -> [u0]) (u6 :: u0 -> u0 -> u0 -> [u0]) -> u2; _NO_DEFLT_ } _N_ #-} where
enumFrom :: a -> [a]
{-# GHC_PRAGMA {-meth-} _A_ 1 _U_ 12 _N_ _S_ "S" _F_ _IF_ARGS_ 1 1 C 2 _/\_ u0 -> \ (u1 :: ({{Ord u0}}, u0 -> [u0], u0 -> u0 -> [u0], u0 -> u0 -> [u0], u0 -> u0 -> u0 -> [u0])) -> case u1 of { _ALG_ _TUP_5 (u2 :: {{Ord u0}}) (u3 :: u0 -> [u0]) (u4 :: u0 -> u0 -> [u0]) (u5 :: u0 -> u0 -> [u0]) (u6 :: u0 -> u0 -> u0 -> [u0]) -> u3; _NO_DEFLT_ } _N_
- {-defm-} _A_ 2 _U_ 02 _N_ _S_ _!_ _F_ _IF_ARGS_ 1 2 XX 3 _/\_ u0 -> \ (u1 :: {{Enum u0}}) (u2 :: u0) -> _APP_ _TYAPP_ patError# { (u0 -> [u0]) } [ _NOREP_S_ "%DPreludeCore.Enum.enumFrom\"", u2 ] _N_ #-}
+ {-defm-} _A_ 2 _U_ 02 _N_ _S_ _!_ _N_ _N_ #-}
enumFromThen :: a -> a -> [a]
{-# GHC_PRAGMA {-meth-} _A_ 1 _U_ 122 _N_ _S_ "S" _F_ _IF_ARGS_ 1 1 C 2 _/\_ u0 -> \ (u1 :: ({{Ord u0}}, u0 -> [u0], u0 -> u0 -> [u0], u0 -> u0 -> [u0], u0 -> u0 -> u0 -> [u0])) -> case u1 of { _ALG_ _TUP_5 (u2 :: {{Ord u0}}) (u3 :: u0 -> [u0]) (u4 :: u0 -> u0 -> [u0]) (u5 :: u0 -> u0 -> [u0]) (u6 :: u0 -> u0 -> u0 -> [u0]) -> u4; _NO_DEFLT_ } _N_
- {-defm-} _A_ 3 _U_ 022 _N_ _S_ _!_ _F_ _IF_ARGS_ 1 3 XXX 4 _/\_ u0 -> \ (u1 :: {{Enum u0}}) (u2 :: u0) (u3 :: u0) -> _APP_ _TYAPP_ patError# { (u0 -> u0 -> [u0]) } [ _NOREP_S_ "%DPreludeCore.Enum.enumFromThen\"", u2, u3 ] _N_ #-}
+ {-defm-} _A_ 3 _U_ 022 _N_ _S_ _!_ _N_ _N_ #-}
enumFromTo :: a -> a -> [a]
{-# GHC_PRAGMA {-meth-} _A_ 1 _U_ 122 _N_ _S_ "S" _F_ _IF_ARGS_ 1 1 C 2 _/\_ u0 -> \ (u1 :: ({{Ord u0}}, u0 -> [u0], u0 -> u0 -> [u0], u0 -> u0 -> [u0], u0 -> u0 -> u0 -> [u0])) -> case u1 of { _ALG_ _TUP_5 (u2 :: {{Ord u0}}) (u3 :: u0 -> [u0]) (u4 :: u0 -> u0 -> [u0]) (u5 :: u0 -> u0 -> [u0]) (u6 :: u0 -> u0 -> u0 -> [u0]) -> u5; _NO_DEFLT_ } _N_
{-defm-} _A_ 3 _U_ 122 _N_ _S_ "SLL" _N_ _N_ #-}
class Eq a where
(==) :: a -> a -> Bool
{-# GHC_PRAGMA {-meth-} _A_ 1 _U_ 122 _N_ _S_ "S" _F_ _IF_ARGS_ 1 1 C 2 _/\_ u0 -> \ (u1 :: (u0 -> u0 -> Bool, u0 -> u0 -> Bool)) -> case u1 of { _ALG_ _TUP_2 (u2 :: u0 -> u0 -> Bool) (u3 :: u0 -> u0 -> Bool) -> u2; _NO_DEFLT_ } _N_
- {-defm-} _A_ 3 _U_ 022 _N_ _S_ _!_ _F_ _IF_ARGS_ 1 3 XXX 4 _/\_ u0 -> \ (u1 :: {{Eq u0}}) (u2 :: u0) (u3 :: u0) -> _APP_ _TYAPP_ patError# { (u0 -> u0 -> Bool) } [ _NOREP_S_ "%DPreludeCore.Eq.(==)\"", u2, u3 ] _N_ #-}
+ {-defm-} _A_ 3 _U_ 022 _N_ _S_ _!_ _N_ _N_ #-}
(/=) :: a -> a -> Bool
{-# GHC_PRAGMA {-meth-} _A_ 1 _U_ 122 _N_ _S_ "S" _F_ _IF_ARGS_ 1 1 C 2 _/\_ u0 -> \ (u1 :: (u0 -> u0 -> Bool, u0 -> u0 -> Bool)) -> case u1 of { _ALG_ _TUP_2 (u2 :: u0 -> u0 -> Bool) (u3 :: u0 -> u0 -> Bool) -> u3; _NO_DEFLT_ } _N_
{-defm-} _A_ 3 _U_ 122 _N_ _S_ "SLL" _N_ _N_ #-}
class (Fractional a) => Floating a {-# GHC_PRAGMA {-superdicts-} _A_ 1 _U_ 1 _N_ _S_ "S" _F_ _IF_ARGS_ 1 1 C 2 _/\_ u0 -> \ (u1 :: ({{Fractional u0}}, u0, u0 -> u0, u0 -> u0, u0 -> u0, u0 -> u0 -> u0, u0 -> u0 -> u0, u0 -> u0, u0 -> u0, u0 -> u0, u0 -> u0, u0 -> u0, u0 -> u0, u0 -> u0, u0 -> u0, u0 -> u0, u0 -> u0, u0 -> u0, u0 -> u0)) -> case u1 of { _ALG_ _TUP_19 (u2 :: {{Fractional u0}}) (u3 :: u0) (u4 :: u0 -> u0) (u5 :: u0 -> u0) (u6 :: u0 -> u0) (u7 :: u0 -> u0 -> u0) (u8 :: u0 -> u0 -> u0) (u9 :: u0 -> u0) (ua :: u0 -> u0) (ub :: u0 -> u0) (uc :: u0 -> u0) (ud :: u0 -> u0) (ue :: u0 -> u0) (uf :: u0 -> u0) (ug :: u0 -> u0) (uh :: u0 -> u0) (ui :: u0 -> u0) (uj :: u0 -> u0) (uk :: u0 -> u0) -> u2; _NO_DEFLT_ } _N_ #-} where
pi :: a
{-# GHC_PRAGMA {-meth-} _A_ 1 _U_ 1 _N_ _S_ "S" _F_ _IF_ARGS_ 1 1 C 2 _/\_ u0 -> \ (u1 :: ({{Fractional u0}}, u0, u0 -> u0, u0 -> u0, u0 -> u0, u0 -> u0 -> u0, u0 -> u0 -> u0, u0 -> u0, u0 -> u0, u0 -> u0, u0 -> u0, u0 -> u0, u0 -> u0, u0 -> u0, u0 -> u0, u0 -> u0, u0 -> u0, u0 -> u0, u0 -> u0)) -> case u1 of { _ALG_ _TUP_19 (u2 :: {{Fractional u0}}) (u3 :: u0) (u4 :: u0 -> u0) (u5 :: u0 -> u0) (u6 :: u0 -> u0) (u7 :: u0 -> u0 -> u0) (u8 :: u0 -> u0 -> u0) (u9 :: u0 -> u0) (ua :: u0 -> u0) (ub :: u0 -> u0) (uc :: u0 -> u0) (ud :: u0 -> u0) (ue :: u0 -> u0) (uf :: u0 -> u0) (ug :: u0 -> u0) (uh :: u0 -> u0) (ui :: u0 -> u0) (uj :: u0 -> u0) (uk :: u0 -> u0) -> u3; _NO_DEFLT_ } _N_
- {-defm-} _A_ 1 _U_ 0 _N_ _S_ _!_ _F_ _IF_ARGS_ 1 1 X 2 _/\_ u0 -> \ (u1 :: {{Floating u0}}) -> _APP_ _TYAPP_ patError# { u0 } [ _NOREP_S_ "%DPreludeCore.Floating.pi\"" ] _N_ #-}
+ {-defm-} _A_ 1 _U_ 0 _N_ _S_ _!_ _N_ _N_ #-}
exp :: a -> a
{-# GHC_PRAGMA {-meth-} _A_ 1 _U_ 12 _N_ _S_ "S" _F_ _IF_ARGS_ 1 1 C 2 _/\_ u0 -> \ (u1 :: ({{Fractional u0}}, u0, u0 -> u0, u0 -> u0, u0 -> u0, u0 -> u0 -> u0, u0 -> u0 -> u0, u0 -> u0, u0 -> u0, u0 -> u0, u0 -> u0, u0 -> u0, u0 -> u0, u0 -> u0, u0 -> u0, u0 -> u0, u0 -> u0, u0 -> u0, u0 -> u0)) -> case u1 of { _ALG_ _TUP_19 (u2 :: {{Fractional u0}}) (u3 :: u0) (u4 :: u0 -> u0) (u5 :: u0 -> u0) (u6 :: u0 -> u0) (u7 :: u0 -> u0 -> u0) (u8 :: u0 -> u0 -> u0) (u9 :: u0 -> u0) (ua :: u0 -> u0) (ub :: u0 -> u0) (uc :: u0 -> u0) (ud :: u0 -> u0) (ue :: u0 -> u0) (uf :: u0 -> u0) (ug :: u0 -> u0) (uh :: u0 -> u0) (ui :: u0 -> u0) (uj :: u0 -> u0) (uk :: u0 -> u0) -> u4; _NO_DEFLT_ } _N_
- {-defm-} _A_ 2 _U_ 02 _N_ _S_ _!_ _F_ _IF_ARGS_ 1 2 XX 3 _/\_ u0 -> \ (u1 :: {{Floating u0}}) (u2 :: u0) -> _APP_ _TYAPP_ patError# { (u0 -> u0) } [ _NOREP_S_ "%DPreludeCore.Floating.exp\"", u2 ] _N_ #-}
+ {-defm-} _A_ 2 _U_ 02 _N_ _S_ _!_ _N_ _N_ #-}
log :: a -> a
{-# GHC_PRAGMA {-meth-} _A_ 1 _U_ 12 _N_ _S_ "S" _F_ _IF_ARGS_ 1 1 C 2 _/\_ u0 -> \ (u1 :: ({{Fractional u0}}, u0, u0 -> u0, u0 -> u0, u0 -> u0, u0 -> u0 -> u0, u0 -> u0 -> u0, u0 -> u0, u0 -> u0, u0 -> u0, u0 -> u0, u0 -> u0, u0 -> u0, u0 -> u0, u0 -> u0, u0 -> u0, u0 -> u0, u0 -> u0, u0 -> u0)) -> case u1 of { _ALG_ _TUP_19 (u2 :: {{Fractional u0}}) (u3 :: u0) (u4 :: u0 -> u0) (u5 :: u0 -> u0) (u6 :: u0 -> u0) (u7 :: u0 -> u0 -> u0) (u8 :: u0 -> u0 -> u0) (u9 :: u0 -> u0) (ua :: u0 -> u0) (ub :: u0 -> u0) (uc :: u0 -> u0) (ud :: u0 -> u0) (ue :: u0 -> u0) (uf :: u0 -> u0) (ug :: u0 -> u0) (uh :: u0 -> u0) (ui :: u0 -> u0) (uj :: u0 -> u0) (uk :: u0 -> u0) -> u5; _NO_DEFLT_ } _N_
- {-defm-} _A_ 2 _U_ 02 _N_ _S_ _!_ _F_ _IF_ARGS_ 1 2 XX 3 _/\_ u0 -> \ (u1 :: {{Floating u0}}) (u2 :: u0) -> _APP_ _TYAPP_ patError# { (u0 -> u0) } [ _NOREP_S_ "%DPreludeCore.Floating.log\"", u2 ] _N_ #-}
+ {-defm-} _A_ 2 _U_ 02 _N_ _S_ _!_ _N_ _N_ #-}
sqrt :: a -> a
{-# GHC_PRAGMA {-meth-} _A_ 1 _U_ 12 _N_ _S_ "S" _F_ _IF_ARGS_ 1 1 C 2 _/\_ u0 -> \ (u1 :: ({{Fractional u0}}, u0, u0 -> u0, u0 -> u0, u0 -> u0, u0 -> u0 -> u0, u0 -> u0 -> u0, u0 -> u0, u0 -> u0, u0 -> u0, u0 -> u0, u0 -> u0, u0 -> u0, u0 -> u0, u0 -> u0, u0 -> u0, u0 -> u0, u0 -> u0, u0 -> u0)) -> case u1 of { _ALG_ _TUP_19 (u2 :: {{Fractional u0}}) (u3 :: u0) (u4 :: u0 -> u0) (u5 :: u0 -> u0) (u6 :: u0 -> u0) (u7 :: u0 -> u0 -> u0) (u8 :: u0 -> u0 -> u0) (u9 :: u0 -> u0) (ua :: u0 -> u0) (ub :: u0 -> u0) (uc :: u0 -> u0) (ud :: u0 -> u0) (ue :: u0 -> u0) (uf :: u0 -> u0) (ug :: u0 -> u0) (uh :: u0 -> u0) (ui :: u0 -> u0) (uj :: u0 -> u0) (uk :: u0 -> u0) -> u6; _NO_DEFLT_ } _N_
{-defm-} _A_ 1 _U_ 12 _N_ _S_ "S" _N_ _N_ #-}
{-defm-} _A_ 3 _U_ 122 _N_ _S_ "SLL" _N_ _N_ #-}
sin :: a -> a
{-# GHC_PRAGMA {-meth-} _A_ 1 _U_ 12 _N_ _S_ "S" _F_ _IF_ARGS_ 1 1 C 2 _/\_ u0 -> \ (u1 :: ({{Fractional u0}}, u0, u0 -> u0, u0 -> u0, u0 -> u0, u0 -> u0 -> u0, u0 -> u0 -> u0, u0 -> u0, u0 -> u0, u0 -> u0, u0 -> u0, u0 -> u0, u0 -> u0, u0 -> u0, u0 -> u0, u0 -> u0, u0 -> u0, u0 -> u0, u0 -> u0)) -> case u1 of { _ALG_ _TUP_19 (u2 :: {{Fractional u0}}) (u3 :: u0) (u4 :: u0 -> u0) (u5 :: u0 -> u0) (u6 :: u0 -> u0) (u7 :: u0 -> u0 -> u0) (u8 :: u0 -> u0 -> u0) (u9 :: u0 -> u0) (ua :: u0 -> u0) (ub :: u0 -> u0) (uc :: u0 -> u0) (ud :: u0 -> u0) (ue :: u0 -> u0) (uf :: u0 -> u0) (ug :: u0 -> u0) (uh :: u0 -> u0) (ui :: u0 -> u0) (uj :: u0 -> u0) (uk :: u0 -> u0) -> u9; _NO_DEFLT_ } _N_
- {-defm-} _A_ 2 _U_ 02 _N_ _S_ _!_ _F_ _IF_ARGS_ 1 2 XX 3 _/\_ u0 -> \ (u1 :: {{Floating u0}}) (u2 :: u0) -> _APP_ _TYAPP_ patError# { (u0 -> u0) } [ _NOREP_S_ "%DPreludeCore.Floating.sin\"", u2 ] _N_ #-}
+ {-defm-} _A_ 2 _U_ 02 _N_ _S_ _!_ _N_ _N_ #-}
cos :: a -> a
{-# GHC_PRAGMA {-meth-} _A_ 1 _U_ 12 _N_ _S_ "S" _F_ _IF_ARGS_ 1 1 C 2 _/\_ u0 -> \ (u1 :: ({{Fractional u0}}, u0, u0 -> u0, u0 -> u0, u0 -> u0, u0 -> u0 -> u0, u0 -> u0 -> u0, u0 -> u0, u0 -> u0, u0 -> u0, u0 -> u0, u0 -> u0, u0 -> u0, u0 -> u0, u0 -> u0, u0 -> u0, u0 -> u0, u0 -> u0, u0 -> u0)) -> case u1 of { _ALG_ _TUP_19 (u2 :: {{Fractional u0}}) (u3 :: u0) (u4 :: u0 -> u0) (u5 :: u0 -> u0) (u6 :: u0 -> u0) (u7 :: u0 -> u0 -> u0) (u8 :: u0 -> u0 -> u0) (u9 :: u0 -> u0) (ua :: u0 -> u0) (ub :: u0 -> u0) (uc :: u0 -> u0) (ud :: u0 -> u0) (ue :: u0 -> u0) (uf :: u0 -> u0) (ug :: u0 -> u0) (uh :: u0 -> u0) (ui :: u0 -> u0) (uj :: u0 -> u0) (uk :: u0 -> u0) -> ua; _NO_DEFLT_ } _N_
- {-defm-} _A_ 2 _U_ 02 _N_ _S_ _!_ _F_ _IF_ARGS_ 1 2 XX 3 _/\_ u0 -> \ (u1 :: {{Floating u0}}) (u2 :: u0) -> _APP_ _TYAPP_ patError# { (u0 -> u0) } [ _NOREP_S_ "%DPreludeCore.Floating.cos\"", u2 ] _N_ #-}
+ {-defm-} _A_ 2 _U_ 02 _N_ _S_ _!_ _N_ _N_ #-}
tan :: a -> a
{-# GHC_PRAGMA {-meth-} _A_ 1 _U_ 12 _N_ _S_ "S" _F_ _IF_ARGS_ 1 1 C 2 _/\_ u0 -> \ (u1 :: ({{Fractional u0}}, u0, u0 -> u0, u0 -> u0, u0 -> u0, u0 -> u0 -> u0, u0 -> u0 -> u0, u0 -> u0, u0 -> u0, u0 -> u0, u0 -> u0, u0 -> u0, u0 -> u0, u0 -> u0, u0 -> u0, u0 -> u0, u0 -> u0, u0 -> u0, u0 -> u0)) -> case u1 of { _ALG_ _TUP_19 (u2 :: {{Fractional u0}}) (u3 :: u0) (u4 :: u0 -> u0) (u5 :: u0 -> u0) (u6 :: u0 -> u0) (u7 :: u0 -> u0 -> u0) (u8 :: u0 -> u0 -> u0) (u9 :: u0 -> u0) (ua :: u0 -> u0) (ub :: u0 -> u0) (uc :: u0 -> u0) (ud :: u0 -> u0) (ue :: u0 -> u0) (uf :: u0 -> u0) (ug :: u0 -> u0) (uh :: u0 -> u0) (ui :: u0 -> u0) (uj :: u0 -> u0) (uk :: u0 -> u0) -> ub; _NO_DEFLT_ } _N_
{-defm-} _A_ 2 _U_ 12 _N_ _S_ "SL" _N_ _N_ #-}
asin :: a -> a
{-# GHC_PRAGMA {-meth-} _A_ 1 _U_ 12 _N_ _S_ "S" _F_ _IF_ARGS_ 1 1 C 2 _/\_ u0 -> \ (u1 :: ({{Fractional u0}}, u0, u0 -> u0, u0 -> u0, u0 -> u0, u0 -> u0 -> u0, u0 -> u0 -> u0, u0 -> u0, u0 -> u0, u0 -> u0, u0 -> u0, u0 -> u0, u0 -> u0, u0 -> u0, u0 -> u0, u0 -> u0, u0 -> u0, u0 -> u0, u0 -> u0)) -> case u1 of { _ALG_ _TUP_19 (u2 :: {{Fractional u0}}) (u3 :: u0) (u4 :: u0 -> u0) (u5 :: u0 -> u0) (u6 :: u0 -> u0) (u7 :: u0 -> u0 -> u0) (u8 :: u0 -> u0 -> u0) (u9 :: u0 -> u0) (ua :: u0 -> u0) (ub :: u0 -> u0) (uc :: u0 -> u0) (ud :: u0 -> u0) (ue :: u0 -> u0) (uf :: u0 -> u0) (ug :: u0 -> u0) (uh :: u0 -> u0) (ui :: u0 -> u0) (uj :: u0 -> u0) (uk :: u0 -> u0) -> uc; _NO_DEFLT_ } _N_
- {-defm-} _A_ 2 _U_ 02 _N_ _S_ _!_ _F_ _IF_ARGS_ 1 2 XX 3 _/\_ u0 -> \ (u1 :: {{Floating u0}}) (u2 :: u0) -> _APP_ _TYAPP_ patError# { (u0 -> u0) } [ _NOREP_S_ "%DPreludeCore.Floating.asin\"", u2 ] _N_ #-}
+ {-defm-} _A_ 2 _U_ 02 _N_ _S_ _!_ _N_ _N_ #-}
acos :: a -> a
{-# GHC_PRAGMA {-meth-} _A_ 1 _U_ 12 _N_ _S_ "S" _F_ _IF_ARGS_ 1 1 C 2 _/\_ u0 -> \ (u1 :: ({{Fractional u0}}, u0, u0 -> u0, u0 -> u0, u0 -> u0, u0 -> u0 -> u0, u0 -> u0 -> u0, u0 -> u0, u0 -> u0, u0 -> u0, u0 -> u0, u0 -> u0, u0 -> u0, u0 -> u0, u0 -> u0, u0 -> u0, u0 -> u0, u0 -> u0, u0 -> u0)) -> case u1 of { _ALG_ _TUP_19 (u2 :: {{Fractional u0}}) (u3 :: u0) (u4 :: u0 -> u0) (u5 :: u0 -> u0) (u6 :: u0 -> u0) (u7 :: u0 -> u0 -> u0) (u8 :: u0 -> u0 -> u0) (u9 :: u0 -> u0) (ua :: u0 -> u0) (ub :: u0 -> u0) (uc :: u0 -> u0) (ud :: u0 -> u0) (ue :: u0 -> u0) (uf :: u0 -> u0) (ug :: u0 -> u0) (uh :: u0 -> u0) (ui :: u0 -> u0) (uj :: u0 -> u0) (uk :: u0 -> u0) -> ud; _NO_DEFLT_ } _N_
- {-defm-} _A_ 2 _U_ 02 _N_ _S_ _!_ _F_ _IF_ARGS_ 1 2 XX 3 _/\_ u0 -> \ (u1 :: {{Floating u0}}) (u2 :: u0) -> _APP_ _TYAPP_ patError# { (u0 -> u0) } [ _NOREP_S_ "%DPreludeCore.Floating.acos\"", u2 ] _N_ #-}
+ {-defm-} _A_ 2 _U_ 02 _N_ _S_ _!_ _N_ _N_ #-}
atan :: a -> a
{-# GHC_PRAGMA {-meth-} _A_ 1 _U_ 12 _N_ _S_ "S" _F_ _IF_ARGS_ 1 1 C 2 _/\_ u0 -> \ (u1 :: ({{Fractional u0}}, u0, u0 -> u0, u0 -> u0, u0 -> u0, u0 -> u0 -> u0, u0 -> u0 -> u0, u0 -> u0, u0 -> u0, u0 -> u0, u0 -> u0, u0 -> u0, u0 -> u0, u0 -> u0, u0 -> u0, u0 -> u0, u0 -> u0, u0 -> u0, u0 -> u0)) -> case u1 of { _ALG_ _TUP_19 (u2 :: {{Fractional u0}}) (u3 :: u0) (u4 :: u0 -> u0) (u5 :: u0 -> u0) (u6 :: u0 -> u0) (u7 :: u0 -> u0 -> u0) (u8 :: u0 -> u0 -> u0) (u9 :: u0 -> u0) (ua :: u0 -> u0) (ub :: u0 -> u0) (uc :: u0 -> u0) (ud :: u0 -> u0) (ue :: u0 -> u0) (uf :: u0 -> u0) (ug :: u0 -> u0) (uh :: u0 -> u0) (ui :: u0 -> u0) (uj :: u0 -> u0) (uk :: u0 -> u0) -> ue; _NO_DEFLT_ } _N_
- {-defm-} _A_ 2 _U_ 02 _N_ _S_ _!_ _F_ _IF_ARGS_ 1 2 XX 3 _/\_ u0 -> \ (u1 :: {{Floating u0}}) (u2 :: u0) -> _APP_ _TYAPP_ patError# { (u0 -> u0) } [ _NOREP_S_ "%DPreludeCore.Floating.atan\"", u2 ] _N_ #-}
+ {-defm-} _A_ 2 _U_ 02 _N_ _S_ _!_ _N_ _N_ #-}
sinh :: a -> a
{-# GHC_PRAGMA {-meth-} _A_ 1 _U_ 12 _N_ _S_ "S" _F_ _IF_ARGS_ 1 1 C 2 _/\_ u0 -> \ (u1 :: ({{Fractional u0}}, u0, u0 -> u0, u0 -> u0, u0 -> u0, u0 -> u0 -> u0, u0 -> u0 -> u0, u0 -> u0, u0 -> u0, u0 -> u0, u0 -> u0, u0 -> u0, u0 -> u0, u0 -> u0, u0 -> u0, u0 -> u0, u0 -> u0, u0 -> u0, u0 -> u0)) -> case u1 of { _ALG_ _TUP_19 (u2 :: {{Fractional u0}}) (u3 :: u0) (u4 :: u0 -> u0) (u5 :: u0 -> u0) (u6 :: u0 -> u0) (u7 :: u0 -> u0 -> u0) (u8 :: u0 -> u0 -> u0) (u9 :: u0 -> u0) (ua :: u0 -> u0) (ub :: u0 -> u0) (uc :: u0 -> u0) (ud :: u0 -> u0) (ue :: u0 -> u0) (uf :: u0 -> u0) (ug :: u0 -> u0) (uh :: u0 -> u0) (ui :: u0 -> u0) (uj :: u0 -> u0) (uk :: u0 -> u0) -> uf; _NO_DEFLT_ } _N_
- {-defm-} _A_ 2 _U_ 02 _N_ _S_ _!_ _F_ _IF_ARGS_ 1 2 XX 3 _/\_ u0 -> \ (u1 :: {{Floating u0}}) (u2 :: u0) -> _APP_ _TYAPP_ patError# { (u0 -> u0) } [ _NOREP_S_ "%DPreludeCore.Floating.sinh\"", u2 ] _N_ #-}
+ {-defm-} _A_ 2 _U_ 02 _N_ _S_ _!_ _N_ _N_ #-}
cosh :: a -> a
{-# GHC_PRAGMA {-meth-} _A_ 1 _U_ 12 _N_ _S_ "S" _F_ _IF_ARGS_ 1 1 C 2 _/\_ u0 -> \ (u1 :: ({{Fractional u0}}, u0, u0 -> u0, u0 -> u0, u0 -> u0, u0 -> u0 -> u0, u0 -> u0 -> u0, u0 -> u0, u0 -> u0, u0 -> u0, u0 -> u0, u0 -> u0, u0 -> u0, u0 -> u0, u0 -> u0, u0 -> u0, u0 -> u0, u0 -> u0, u0 -> u0)) -> case u1 of { _ALG_ _TUP_19 (u2 :: {{Fractional u0}}) (u3 :: u0) (u4 :: u0 -> u0) (u5 :: u0 -> u0) (u6 :: u0 -> u0) (u7 :: u0 -> u0 -> u0) (u8 :: u0 -> u0 -> u0) (u9 :: u0 -> u0) (ua :: u0 -> u0) (ub :: u0 -> u0) (uc :: u0 -> u0) (ud :: u0 -> u0) (ue :: u0 -> u0) (uf :: u0 -> u0) (ug :: u0 -> u0) (uh :: u0 -> u0) (ui :: u0 -> u0) (uj :: u0 -> u0) (uk :: u0 -> u0) -> ug; _NO_DEFLT_ } _N_
- {-defm-} _A_ 2 _U_ 02 _N_ _S_ _!_ _F_ _IF_ARGS_ 1 2 XX 3 _/\_ u0 -> \ (u1 :: {{Floating u0}}) (u2 :: u0) -> _APP_ _TYAPP_ patError# { (u0 -> u0) } [ _NOREP_S_ "%DPreludeCore.Floating.cosh\"", u2 ] _N_ #-}
+ {-defm-} _A_ 2 _U_ 02 _N_ _S_ _!_ _N_ _N_ #-}
tanh :: a -> a
{-# GHC_PRAGMA {-meth-} _A_ 1 _U_ 12 _N_ _S_ "S" _F_ _IF_ARGS_ 1 1 C 2 _/\_ u0 -> \ (u1 :: ({{Fractional u0}}, u0, u0 -> u0, u0 -> u0, u0 -> u0, u0 -> u0 -> u0, u0 -> u0 -> u0, u0 -> u0, u0 -> u0, u0 -> u0, u0 -> u0, u0 -> u0, u0 -> u0, u0 -> u0, u0 -> u0, u0 -> u0, u0 -> u0, u0 -> u0, u0 -> u0)) -> case u1 of { _ALG_ _TUP_19 (u2 :: {{Fractional u0}}) (u3 :: u0) (u4 :: u0 -> u0) (u5 :: u0 -> u0) (u6 :: u0 -> u0) (u7 :: u0 -> u0 -> u0) (u8 :: u0 -> u0 -> u0) (u9 :: u0 -> u0) (ua :: u0 -> u0) (ub :: u0 -> u0) (uc :: u0 -> u0) (ud :: u0 -> u0) (ue :: u0 -> u0) (uf :: u0 -> u0) (ug :: u0 -> u0) (uh :: u0 -> u0) (ui :: u0 -> u0) (uj :: u0 -> u0) (uk :: u0 -> u0) -> uh; _NO_DEFLT_ } _N_
{-defm-} _A_ 2 _U_ 12 _N_ _S_ "SL" _N_ _N_ #-}
asinh :: a -> a
{-# GHC_PRAGMA {-meth-} _A_ 1 _U_ 12 _N_ _S_ "S" _F_ _IF_ARGS_ 1 1 C 2 _/\_ u0 -> \ (u1 :: ({{Fractional u0}}, u0, u0 -> u0, u0 -> u0, u0 -> u0, u0 -> u0 -> u0, u0 -> u0 -> u0, u0 -> u0, u0 -> u0, u0 -> u0, u0 -> u0, u0 -> u0, u0 -> u0, u0 -> u0, u0 -> u0, u0 -> u0, u0 -> u0, u0 -> u0, u0 -> u0)) -> case u1 of { _ALG_ _TUP_19 (u2 :: {{Fractional u0}}) (u3 :: u0) (u4 :: u0 -> u0) (u5 :: u0 -> u0) (u6 :: u0 -> u0) (u7 :: u0 -> u0 -> u0) (u8 :: u0 -> u0 -> u0) (u9 :: u0 -> u0) (ua :: u0 -> u0) (ub :: u0 -> u0) (uc :: u0 -> u0) (ud :: u0 -> u0) (ue :: u0 -> u0) (uf :: u0 -> u0) (ug :: u0 -> u0) (uh :: u0 -> u0) (ui :: u0 -> u0) (uj :: u0 -> u0) (uk :: u0 -> u0) -> ui; _NO_DEFLT_ } _N_
- {-defm-} _A_ 2 _U_ 02 _N_ _S_ _!_ _F_ _IF_ARGS_ 1 2 XX 3 _/\_ u0 -> \ (u1 :: {{Floating u0}}) (u2 :: u0) -> _APP_ _TYAPP_ patError# { (u0 -> u0) } [ _NOREP_S_ "%DPreludeCore.Floating.asinh\"", u2 ] _N_ #-}
+ {-defm-} _A_ 2 _U_ 02 _N_ _S_ _!_ _N_ _N_ #-}
acosh :: a -> a
{-# GHC_PRAGMA {-meth-} _A_ 1 _U_ 12 _N_ _S_ "S" _F_ _IF_ARGS_ 1 1 C 2 _/\_ u0 -> \ (u1 :: ({{Fractional u0}}, u0, u0 -> u0, u0 -> u0, u0 -> u0, u0 -> u0 -> u0, u0 -> u0 -> u0, u0 -> u0, u0 -> u0, u0 -> u0, u0 -> u0, u0 -> u0, u0 -> u0, u0 -> u0, u0 -> u0, u0 -> u0, u0 -> u0, u0 -> u0, u0 -> u0)) -> case u1 of { _ALG_ _TUP_19 (u2 :: {{Fractional u0}}) (u3 :: u0) (u4 :: u0 -> u0) (u5 :: u0 -> u0) (u6 :: u0 -> u0) (u7 :: u0 -> u0 -> u0) (u8 :: u0 -> u0 -> u0) (u9 :: u0 -> u0) (ua :: u0 -> u0) (ub :: u0 -> u0) (uc :: u0 -> u0) (ud :: u0 -> u0) (ue :: u0 -> u0) (uf :: u0 -> u0) (ug :: u0 -> u0) (uh :: u0 -> u0) (ui :: u0 -> u0) (uj :: u0 -> u0) (uk :: u0 -> u0) -> uj; _NO_DEFLT_ } _N_
- {-defm-} _A_ 2 _U_ 02 _N_ _S_ _!_ _F_ _IF_ARGS_ 1 2 XX 3 _/\_ u0 -> \ (u1 :: {{Floating u0}}) (u2 :: u0) -> _APP_ _TYAPP_ patError# { (u0 -> u0) } [ _NOREP_S_ "%DPreludeCore.Floating.acosh\"", u2 ] _N_ #-}
+ {-defm-} _A_ 2 _U_ 02 _N_ _S_ _!_ _N_ _N_ #-}
atanh :: a -> a
{-# GHC_PRAGMA {-meth-} _A_ 1 _U_ 12 _N_ _S_ "S" _F_ _IF_ARGS_ 1 1 C 2 _/\_ u0 -> \ (u1 :: ({{Fractional u0}}, u0, u0 -> u0, u0 -> u0, u0 -> u0, u0 -> u0 -> u0, u0 -> u0 -> u0, u0 -> u0, u0 -> u0, u0 -> u0, u0 -> u0, u0 -> u0, u0 -> u0, u0 -> u0, u0 -> u0, u0 -> u0, u0 -> u0, u0 -> u0, u0 -> u0)) -> case u1 of { _ALG_ _TUP_19 (u2 :: {{Fractional u0}}) (u3 :: u0) (u4 :: u0 -> u0) (u5 :: u0 -> u0) (u6 :: u0 -> u0) (u7 :: u0 -> u0 -> u0) (u8 :: u0 -> u0 -> u0) (u9 :: u0 -> u0) (ua :: u0 -> u0) (ub :: u0 -> u0) (uc :: u0 -> u0) (ud :: u0 -> u0) (ue :: u0 -> u0) (uf :: u0 -> u0) (ug :: u0 -> u0) (uh :: u0 -> u0) (ui :: u0 -> u0) (uj :: u0 -> u0) (uk :: u0 -> u0) -> uk; _NO_DEFLT_ } _N_
- {-defm-} _A_ 2 _U_ 02 _N_ _S_ _!_ _F_ _IF_ARGS_ 1 2 XX 3 _/\_ u0 -> \ (u1 :: {{Floating u0}}) (u2 :: u0) -> _APP_ _TYAPP_ patError# { (u0 -> u0) } [ _NOREP_S_ "%DPreludeCore.Floating.atanh\"", u2 ] _N_ #-}
+ {-defm-} _A_ 2 _U_ 02 _N_ _S_ _!_ _N_ _N_ #-}
class (Num a) => Fractional a {-# GHC_PRAGMA {-superdicts-} _A_ 1 _U_ 1 _N_ _S_ "S" _F_ _IF_ARGS_ 1 1 C 2 _/\_ u0 -> \ (u1 :: ({{Num u0}}, u0 -> u0 -> u0, u0 -> u0, Ratio Integer -> u0)) -> case u1 of { _ALG_ _TUP_4 (u2 :: {{Num u0}}) (u3 :: u0 -> u0 -> u0) (u4 :: u0 -> u0) (u5 :: Ratio Integer -> u0) -> u2; _NO_DEFLT_ } _N_ #-} where
(/) :: a -> a -> a
{-# GHC_PRAGMA {-meth-} _A_ 1 _U_ 122 _N_ _S_ "S" _F_ _IF_ARGS_ 1 1 C 2 _/\_ u0 -> \ (u1 :: ({{Num u0}}, u0 -> u0 -> u0, u0 -> u0, Ratio Integer -> u0)) -> case u1 of { _ALG_ _TUP_4 (u2 :: {{Num u0}}) (u3 :: u0 -> u0 -> u0) (u4 :: u0 -> u0) (u5 :: Ratio Integer -> u0) -> u3; _NO_DEFLT_ } _N_
- {-defm-} _A_ 3 _U_ 022 _N_ _S_ _!_ _F_ _IF_ARGS_ 1 3 XXX 4 _/\_ u0 -> \ (u1 :: {{Fractional u0}}) (u2 :: u0) (u3 :: u0) -> _APP_ _TYAPP_ patError# { (u0 -> u0 -> u0) } [ _NOREP_S_ "%DPreludeCore.Fractional.(/)\"", u2, u3 ] _N_ #-}
+ {-defm-} _A_ 3 _U_ 022 _N_ _S_ _!_ _N_ _N_ #-}
recip :: a -> a
{-# GHC_PRAGMA {-meth-} _A_ 1 _U_ 12 _N_ _S_ "S" _F_ _IF_ARGS_ 1 1 C 2 _/\_ u0 -> \ (u1 :: ({{Num u0}}, u0 -> u0 -> u0, u0 -> u0, Ratio Integer -> u0)) -> case u1 of { _ALG_ _TUP_4 (u2 :: {{Num u0}}) (u3 :: u0 -> u0 -> u0) (u4 :: u0 -> u0) (u5 :: Ratio Integer -> u0) -> u4; _NO_DEFLT_ } _N_
{-defm-} _A_ 1 _U_ 12 _N_ _S_ "S" _N_ _N_ #-}
fromRational :: Ratio Integer -> a
{-# GHC_PRAGMA {-meth-} _A_ 1 _U_ 12 _N_ _S_ "S" _F_ _IF_ARGS_ 1 1 C 2 _/\_ u0 -> \ (u1 :: ({{Num u0}}, u0 -> u0 -> u0, u0 -> u0, Ratio Integer -> u0)) -> case u1 of { _ALG_ _TUP_4 (u2 :: {{Num u0}}) (u3 :: u0 -> u0 -> u0) (u4 :: u0 -> u0) (u5 :: Ratio Integer -> u0) -> u5; _NO_DEFLT_ } _N_
- {-defm-} _A_ 2 _U_ 02 _N_ _S_ _!_ _F_ _IF_ARGS_ 1 2 XX 3 _/\_ u0 -> \ (u1 :: {{Fractional u0}}) (u2 :: Ratio Integer) -> _APP_ _TYAPP_ patError# { (Ratio Integer -> u0) } [ _NOREP_S_ "%DPreludeCore.Fractional.fromRational\"", u2 ] _N_ #-}
+ {-defm-} _A_ 2 _U_ 02 _N_ _S_ _!_ _N_ _N_ #-}
class (Real a, Ix a) => Integral a {-# GHC_PRAGMA {-superdicts-} _A_ 1 _U_ 1 _N_ _S_ "S" _F_ _IF_ARGS_ 1 1 C 2 _/\_ u0 -> \ (u1 :: ({{Real u0}}, {{Ix u0}}, u0 -> u0 -> u0, u0 -> u0 -> u0, u0 -> u0 -> u0, u0 -> u0 -> u0, u0 -> u0 -> (u0, u0), u0 -> u0 -> (u0, u0), u0 -> Bool, u0 -> Bool, u0 -> Integer, u0 -> Int)) -> case u1 of { _ALG_ _TUP_12 (u2 :: {{Real u0}}) (u3 :: {{Ix u0}}) (u4 :: u0 -> u0 -> u0) (u5 :: u0 -> u0 -> u0) (u6 :: u0 -> u0 -> u0) (u7 :: u0 -> u0 -> u0) (u8 :: u0 -> u0 -> (u0, u0)) (u9 :: u0 -> u0 -> (u0, u0)) (ua :: u0 -> Bool) (ub :: u0 -> Bool) (uc :: u0 -> Integer) (ud :: u0 -> Int) -> u2; _NO_DEFLT_ } _N_, _A_ 1 _U_ 1 _N_ _S_ "S" _F_ _IF_ARGS_ 1 1 C 2 _/\_ u0 -> \ (u1 :: ({{Real u0}}, {{Ix u0}}, u0 -> u0 -> u0, u0 -> u0 -> u0, u0 -> u0 -> u0, u0 -> u0 -> u0, u0 -> u0 -> (u0, u0), u0 -> u0 -> (u0, u0), u0 -> Bool, u0 -> Bool, u0 -> Integer, u0 -> Int)) -> case u1 of { _ALG_ _TUP_12 (u2 :: {{Real u0}}) (u3 :: {{Ix u0}}) (u4 :: u0 -> u0 -> u0) (u5 :: u0 -> u0 -> u0) (u6 :: u0 -> u0 -> u0) (u7 :: u0 -> u0 -> u0) (u8 :: u0 -> u0 -> (u0, u0)) (u9 :: u0 -> u0 -> (u0, u0)) (ua :: u0 -> Bool) (ub :: u0 -> Bool) (uc :: u0 -> Integer) (ud :: u0 -> Int) -> u3; _NO_DEFLT_ } _N_ #-} where
quot :: a -> a -> a
{-# GHC_PRAGMA {-meth-} _A_ 1 _U_ 122 _N_ _S_ "S" _F_ _IF_ARGS_ 1 1 C 2 _/\_ u0 -> \ (u1 :: ({{Real u0}}, {{Ix u0}}, u0 -> u0 -> u0, u0 -> u0 -> u0, u0 -> u0 -> u0, u0 -> u0 -> u0, u0 -> u0 -> (u0, u0), u0 -> u0 -> (u0, u0), u0 -> Bool, u0 -> Bool, u0 -> Integer, u0 -> Int)) -> case u1 of { _ALG_ _TUP_12 (u2 :: {{Real u0}}) (u3 :: {{Ix u0}}) (u4 :: u0 -> u0 -> u0) (u5 :: u0 -> u0 -> u0) (u6 :: u0 -> u0 -> u0) (u7 :: u0 -> u0 -> u0) (u8 :: u0 -> u0 -> (u0, u0)) (u9 :: u0 -> u0 -> (u0, u0)) (ua :: u0 -> Bool) (ub :: u0 -> Bool) (uc :: u0 -> Integer) (ud :: u0 -> Int) -> u4; _NO_DEFLT_ } _N_
{-defm-} _A_ 3 _U_ 122 _N_ _S_ "SLL" _F_ _IF_ARGS_ 1 3 CXX 6 _/\_ u0 -> \ (u1 :: {{Integral u0}}) (u2 :: u0) (u3 :: u0) -> case case u1 of { _ALG_ _TUP_12 (u4 :: {{Real u0}}) (u5 :: {{Ix u0}}) (u6 :: u0 -> u0 -> u0) (u7 :: u0 -> u0 -> u0) (u8 :: u0 -> u0 -> u0) (u9 :: u0 -> u0 -> u0) (ua :: u0 -> u0 -> (u0, u0)) (ub :: u0 -> u0 -> (u0, u0)) (uc :: u0 -> Bool) (ud :: u0 -> Bool) (ue :: u0 -> Integer) (uf :: u0 -> Int) -> _APP_ ub [ u2, u3 ]; _NO_DEFLT_ } of { _ALG_ _TUP_2 (ug :: u0) (uh :: u0) -> uh; _NO_DEFLT_ } _N_ #-}
quotRem :: a -> a -> (a, a)
{-# GHC_PRAGMA {-meth-} _A_ 1 _U_ 122 _N_ _S_ "S" _F_ _IF_ARGS_ 1 1 C 2 _/\_ u0 -> \ (u1 :: ({{Real u0}}, {{Ix u0}}, u0 -> u0 -> u0, u0 -> u0 -> u0, u0 -> u0 -> u0, u0 -> u0 -> u0, u0 -> u0 -> (u0, u0), u0 -> u0 -> (u0, u0), u0 -> Bool, u0 -> Bool, u0 -> Integer, u0 -> Int)) -> case u1 of { _ALG_ _TUP_12 (u2 :: {{Real u0}}) (u3 :: {{Ix u0}}) (u4 :: u0 -> u0 -> u0) (u5 :: u0 -> u0 -> u0) (u6 :: u0 -> u0 -> u0) (u7 :: u0 -> u0 -> u0) (u8 :: u0 -> u0 -> (u0, u0)) (u9 :: u0 -> u0 -> (u0, u0)) (ua :: u0 -> Bool) (ub :: u0 -> Bool) (uc :: u0 -> Integer) (ud :: u0 -> Int) -> u8; _NO_DEFLT_ } _N_
- {-defm-} _A_ 3 _U_ 022 _N_ _S_ _!_ _F_ _IF_ARGS_ 1 3 XXX 4 _/\_ u0 -> \ (u1 :: {{Integral u0}}) (u2 :: u0) (u3 :: u0) -> _APP_ _TYAPP_ patError# { (u0 -> u0 -> (u0, u0)) } [ _NOREP_S_ "%DPreludeCore.Integral.quotRem\"", u2, u3 ] _N_ #-}
+ {-defm-} _A_ 3 _U_ 022 _N_ _S_ _!_ _N_ _N_ #-}
divMod :: a -> a -> (a, a)
{-# GHC_PRAGMA {-meth-} _A_ 1 _U_ 122 _N_ _S_ "S" _F_ _IF_ARGS_ 1 1 C 2 _/\_ u0 -> \ (u1 :: ({{Real u0}}, {{Ix u0}}, u0 -> u0 -> u0, u0 -> u0 -> u0, u0 -> u0 -> u0, u0 -> u0 -> u0, u0 -> u0 -> (u0, u0), u0 -> u0 -> (u0, u0), u0 -> Bool, u0 -> Bool, u0 -> Integer, u0 -> Int)) -> case u1 of { _ALG_ _TUP_12 (u2 :: {{Real u0}}) (u3 :: {{Ix u0}}) (u4 :: u0 -> u0 -> u0) (u5 :: u0 -> u0 -> u0) (u6 :: u0 -> u0 -> u0) (u7 :: u0 -> u0 -> u0) (u8 :: u0 -> u0 -> (u0, u0)) (u9 :: u0 -> u0 -> (u0, u0)) (ua :: u0 -> Bool) (ub :: u0 -> Bool) (uc :: u0 -> Integer) (ud :: u0 -> Int) -> u9; _NO_DEFLT_ } _N_
{-defm-} _A_ 1 _U_ 122 _N_ _S_ "S" _N_ _N_ #-}
{-defm-} _A_ 1 _U_ 12 _N_ _S_ "S" _N_ _N_ #-}
toInteger :: a -> Integer
{-# GHC_PRAGMA {-meth-} _A_ 1 _U_ 12 _N_ _S_ "S" _F_ _IF_ARGS_ 1 1 C 2 _/\_ u0 -> \ (u1 :: ({{Real u0}}, {{Ix u0}}, u0 -> u0 -> u0, u0 -> u0 -> u0, u0 -> u0 -> u0, u0 -> u0 -> u0, u0 -> u0 -> (u0, u0), u0 -> u0 -> (u0, u0), u0 -> Bool, u0 -> Bool, u0 -> Integer, u0 -> Int)) -> case u1 of { _ALG_ _TUP_12 (u2 :: {{Real u0}}) (u3 :: {{Ix u0}}) (u4 :: u0 -> u0 -> u0) (u5 :: u0 -> u0 -> u0) (u6 :: u0 -> u0 -> u0) (u7 :: u0 -> u0 -> u0) (u8 :: u0 -> u0 -> (u0, u0)) (u9 :: u0 -> u0 -> (u0, u0)) (ua :: u0 -> Bool) (ub :: u0 -> Bool) (uc :: u0 -> Integer) (ud :: u0 -> Int) -> uc; _NO_DEFLT_ } _N_
- {-defm-} _A_ 2 _U_ 02 _N_ _S_ _!_ _F_ _IF_ARGS_ 1 2 XX 3 _/\_ u0 -> \ (u1 :: {{Integral u0}}) (u2 :: u0) -> _APP_ _TYAPP_ patError# { (u0 -> Integer) } [ _NOREP_S_ "%DPreludeCore.Integral.toInteger\"", u2 ] _N_ #-}
+ {-defm-} _A_ 2 _U_ 02 _N_ _S_ _!_ _N_ _N_ #-}
toInt :: a -> Int
{-# GHC_PRAGMA {-meth-} _A_ 1 _U_ 12 _N_ _S_ "S" _F_ _IF_ARGS_ 1 1 C 2 _/\_ u0 -> \ (u1 :: ({{Real u0}}, {{Ix u0}}, u0 -> u0 -> u0, u0 -> u0 -> u0, u0 -> u0 -> u0, u0 -> u0 -> u0, u0 -> u0 -> (u0, u0), u0 -> u0 -> (u0, u0), u0 -> Bool, u0 -> Bool, u0 -> Integer, u0 -> Int)) -> case u1 of { _ALG_ _TUP_12 (u2 :: {{Real u0}}) (u3 :: {{Ix u0}}) (u4 :: u0 -> u0 -> u0) (u5 :: u0 -> u0 -> u0) (u6 :: u0 -> u0 -> u0) (u7 :: u0 -> u0 -> u0) (u8 :: u0 -> u0 -> (u0, u0)) (u9 :: u0 -> u0 -> (u0, u0)) (ua :: u0 -> Bool) (ub :: u0 -> Bool) (uc :: u0 -> Integer) (ud :: u0 -> Int) -> ud; _NO_DEFLT_ } _N_
- {-defm-} _A_ 2 _U_ 02 _N_ _S_ _!_ _F_ _IF_ARGS_ 1 2 XX 3 _/\_ u0 -> \ (u1 :: {{Integral u0}}) (u2 :: u0) -> _APP_ _TYAPP_ patError# { (u0 -> Int) } [ _NOREP_S_ "%DPreludeCore.Integral.toInt\"", u2 ] _N_ #-}
+ {-defm-} _A_ 2 _U_ 02 _N_ _S_ _!_ _N_ _N_ #-}
class (Ord a) => Ix a {-# GHC_PRAGMA {-superdicts-} _A_ 1 _U_ 1 _N_ _S_ "S" _F_ _IF_ARGS_ 1 1 C 2 _/\_ u0 -> \ (u1 :: ({{Ord u0}}, (u0, u0) -> [u0], (u0, u0) -> u0 -> Int, (u0, u0) -> u0 -> Bool)) -> case u1 of { _ALG_ _TUP_4 (u2 :: {{Ord u0}}) (u3 :: (u0, u0) -> [u0]) (u4 :: (u0, u0) -> u0 -> Int) (u5 :: (u0, u0) -> u0 -> Bool) -> u2; _NO_DEFLT_ } _N_ #-} where
range :: (a, a) -> [a]
{-# GHC_PRAGMA {-meth-} _A_ 1 _U_ 12 _N_ _S_ "S" _F_ _IF_ARGS_ 1 1 C 2 _/\_ u0 -> \ (u1 :: ({{Ord u0}}, (u0, u0) -> [u0], (u0, u0) -> u0 -> Int, (u0, u0) -> u0 -> Bool)) -> case u1 of { _ALG_ _TUP_4 (u2 :: {{Ord u0}}) (u3 :: (u0, u0) -> [u0]) (u4 :: (u0, u0) -> u0 -> Int) (u5 :: (u0, u0) -> u0 -> Bool) -> u3; _NO_DEFLT_ } _N_
- {-defm-} _A_ 2 _U_ 02 _N_ _S_ _!_ _F_ _IF_ARGS_ 1 2 XX 3 _/\_ u0 -> \ (u1 :: {{Ix u0}}) (u2 :: (u0, u0)) -> _APP_ _TYAPP_ patError# { ((u0, u0) -> [u0]) } [ _NOREP_S_ "%DPreludeCore.Ix.range\"", u2 ] _N_ #-}
+ {-defm-} _A_ 2 _U_ 02 _N_ _S_ _!_ _N_ _N_ #-}
index :: (a, a) -> a -> Int
{-# GHC_PRAGMA {-meth-} _A_ 1 _U_ 122 _N_ _S_ "S" _F_ _IF_ARGS_ 1 1 C 2 _/\_ u0 -> \ (u1 :: ({{Ord u0}}, (u0, u0) -> [u0], (u0, u0) -> u0 -> Int, (u0, u0) -> u0 -> Bool)) -> case u1 of { _ALG_ _TUP_4 (u2 :: {{Ord u0}}) (u3 :: (u0, u0) -> [u0]) (u4 :: (u0, u0) -> u0 -> Int) (u5 :: (u0, u0) -> u0 -> Bool) -> u4; _NO_DEFLT_ } _N_
- {-defm-} _A_ 3 _U_ 022 _N_ _S_ _!_ _F_ _IF_ARGS_ 1 3 XXX 4 _/\_ u0 -> \ (u1 :: {{Ix u0}}) (u2 :: (u0, u0)) (u3 :: u0) -> _APP_ _TYAPP_ patError# { ((u0, u0) -> u0 -> Int) } [ _NOREP_S_ "%DPreludeCore.Ix.index\"", u2, u3 ] _N_ #-}
+ {-defm-} _A_ 3 _U_ 022 _N_ _S_ _!_ _N_ _N_ #-}
inRange :: (a, a) -> a -> Bool
{-# GHC_PRAGMA {-meth-} _A_ 1 _U_ 122 _N_ _S_ "S" _F_ _IF_ARGS_ 1 1 C 2 _/\_ u0 -> \ (u1 :: ({{Ord u0}}, (u0, u0) -> [u0], (u0, u0) -> u0 -> Int, (u0, u0) -> u0 -> Bool)) -> case u1 of { _ALG_ _TUP_4 (u2 :: {{Ord u0}}) (u3 :: (u0, u0) -> [u0]) (u4 :: (u0, u0) -> u0 -> Int) (u5 :: (u0, u0) -> u0 -> Bool) -> u5; _NO_DEFLT_ } _N_
- {-defm-} _A_ 3 _U_ 022 _N_ _S_ _!_ _F_ _IF_ARGS_ 1 3 XXX 4 _/\_ u0 -> \ (u1 :: {{Ix u0}}) (u2 :: (u0, u0)) (u3 :: u0) -> _APP_ _TYAPP_ patError# { ((u0, u0) -> u0 -> Bool) } [ _NOREP_S_ "%DPreludeCore.Ix.inRange\"", u2, u3 ] _N_ #-}
+ {-defm-} _A_ 3 _U_ 022 _N_ _S_ _!_ _N_ _N_ #-}
class (Eq a, Text a) => Num a {-# GHC_PRAGMA {-superdicts-} _A_ 1 _U_ 1 _N_ _S_ "S" _F_ _IF_ARGS_ 1 1 C 2 _/\_ u0 -> \ (u1 :: ({{Eq u0}}, {{Text u0}}, u0 -> u0 -> u0, u0 -> u0 -> u0, u0 -> u0 -> u0, u0 -> u0, u0 -> u0, u0 -> u0, Integer -> u0, Int -> u0)) -> case u1 of { _ALG_ _TUP_10 (u2 :: {{Eq u0}}) (u3 :: {{Text u0}}) (u4 :: u0 -> u0 -> u0) (u5 :: u0 -> u0 -> u0) (u6 :: u0 -> u0 -> u0) (u7 :: u0 -> u0) (u8 :: u0 -> u0) (u9 :: u0 -> u0) (ua :: Integer -> u0) (ub :: Int -> u0) -> u2; _NO_DEFLT_ } _N_, _A_ 1 _U_ 1 _N_ _S_ "S" _F_ _IF_ARGS_ 1 1 C 2 _/\_ u0 -> \ (u1 :: ({{Eq u0}}, {{Text u0}}, u0 -> u0 -> u0, u0 -> u0 -> u0, u0 -> u0 -> u0, u0 -> u0, u0 -> u0, u0 -> u0, Integer -> u0, Int -> u0)) -> case u1 of { _ALG_ _TUP_10 (u2 :: {{Eq u0}}) (u3 :: {{Text u0}}) (u4 :: u0 -> u0 -> u0) (u5 :: u0 -> u0 -> u0) (u6 :: u0 -> u0 -> u0) (u7 :: u0 -> u0) (u8 :: u0 -> u0) (u9 :: u0 -> u0) (ua :: Integer -> u0) (ub :: Int -> u0) -> u3; _NO_DEFLT_ } _N_ #-} where
(+) :: a -> a -> a
{-# GHC_PRAGMA {-meth-} _A_ 1 _U_ 122 _N_ _S_ "S" _F_ _IF_ARGS_ 1 1 C 2 _/\_ u0 -> \ (u1 :: ({{Eq u0}}, {{Text u0}}, u0 -> u0 -> u0, u0 -> u0 -> u0, u0 -> u0 -> u0, u0 -> u0, u0 -> u0, u0 -> u0, Integer -> u0, Int -> u0)) -> case u1 of { _ALG_ _TUP_10 (u2 :: {{Eq u0}}) (u3 :: {{Text u0}}) (u4 :: u0 -> u0 -> u0) (u5 :: u0 -> u0 -> u0) (u6 :: u0 -> u0 -> u0) (u7 :: u0 -> u0) (u8 :: u0 -> u0) (u9 :: u0 -> u0) (ua :: Integer -> u0) (ub :: Int -> u0) -> u4; _NO_DEFLT_ } _N_
- {-defm-} _A_ 3 _U_ 022 _N_ _S_ _!_ _F_ _IF_ARGS_ 1 3 XXX 4 _/\_ u0 -> \ (u1 :: {{Num u0}}) (u2 :: u0) (u3 :: u0) -> _APP_ _TYAPP_ patError# { (u0 -> u0 -> u0) } [ _NOREP_S_ "%DPreludeCore.Num.(+)\"", u2, u3 ] _N_ #-}
+ {-defm-} _A_ 3 _U_ 022 _N_ _S_ _!_ _N_ _N_ #-}
(-) :: a -> a -> a
{-# GHC_PRAGMA {-meth-} _A_ 1 _U_ 122 _N_ _S_ "S" _F_ _IF_ARGS_ 1 1 C 2 _/\_ u0 -> \ (u1 :: ({{Eq u0}}, {{Text u0}}, u0 -> u0 -> u0, u0 -> u0 -> u0, u0 -> u0 -> u0, u0 -> u0, u0 -> u0, u0 -> u0, Integer -> u0, Int -> u0)) -> case u1 of { _ALG_ _TUP_10 (u2 :: {{Eq u0}}) (u3 :: {{Text u0}}) (u4 :: u0 -> u0 -> u0) (u5 :: u0 -> u0 -> u0) (u6 :: u0 -> u0 -> u0) (u7 :: u0 -> u0) (u8 :: u0 -> u0) (u9 :: u0 -> u0) (ua :: Integer -> u0) (ub :: Int -> u0) -> u5; _NO_DEFLT_ } _N_
{-defm-} _A_ 3 _U_ 122 _N_ _S_ "SLL" _F_ _ALWAYS_ _/\_ u0 -> \ (u1 :: {{Num u0}}) (u2 :: u0) (u3 :: u0) -> case u1 of { _ALG_ _TUP_10 (u4 :: {{Eq u0}}) (u5 :: {{Text u0}}) (u6 :: u0 -> u0 -> u0) (u7 :: u0 -> u0 -> u0) (u8 :: u0 -> u0 -> u0) (u9 :: u0 -> u0) (ua :: u0 -> u0) (ub :: u0 -> u0) (uc :: Integer -> u0) (ud :: Int -> u0) -> let {(ue :: u0) = _APP_ u9 [ u3 ]} in _APP_ u6 [ u2, ue ]; _NO_DEFLT_ } _N_ #-}
(*) :: a -> a -> a
{-# GHC_PRAGMA {-meth-} _A_ 1 _U_ 122 _N_ _S_ "S" _F_ _IF_ARGS_ 1 1 C 2 _/\_ u0 -> \ (u1 :: ({{Eq u0}}, {{Text u0}}, u0 -> u0 -> u0, u0 -> u0 -> u0, u0 -> u0 -> u0, u0 -> u0, u0 -> u0, u0 -> u0, Integer -> u0, Int -> u0)) -> case u1 of { _ALG_ _TUP_10 (u2 :: {{Eq u0}}) (u3 :: {{Text u0}}) (u4 :: u0 -> u0 -> u0) (u5 :: u0 -> u0 -> u0) (u6 :: u0 -> u0 -> u0) (u7 :: u0 -> u0) (u8 :: u0 -> u0) (u9 :: u0 -> u0) (ua :: Integer -> u0) (ub :: Int -> u0) -> u6; _NO_DEFLT_ } _N_
- {-defm-} _A_ 3 _U_ 022 _N_ _S_ _!_ _F_ _IF_ARGS_ 1 3 XXX 4 _/\_ u0 -> \ (u1 :: {{Num u0}}) (u2 :: u0) (u3 :: u0) -> _APP_ _TYAPP_ patError# { (u0 -> u0 -> u0) } [ _NOREP_S_ "%DPreludeCore.Num.(*)\"", u2, u3 ] _N_ #-}
+ {-defm-} _A_ 3 _U_ 022 _N_ _S_ _!_ _N_ _N_ #-}
negate :: a -> a
{-# GHC_PRAGMA {-meth-} _A_ 1 _U_ 12 _N_ _S_ "S" _F_ _IF_ARGS_ 1 1 C 2 _/\_ u0 -> \ (u1 :: ({{Eq u0}}, {{Text u0}}, u0 -> u0 -> u0, u0 -> u0 -> u0, u0 -> u0 -> u0, u0 -> u0, u0 -> u0, u0 -> u0, Integer -> u0, Int -> u0)) -> case u1 of { _ALG_ _TUP_10 (u2 :: {{Eq u0}}) (u3 :: {{Text u0}}) (u4 :: u0 -> u0 -> u0) (u5 :: u0 -> u0 -> u0) (u6 :: u0 -> u0 -> u0) (u7 :: u0 -> u0) (u8 :: u0 -> u0) (u9 :: u0 -> u0) (ua :: Integer -> u0) (ub :: Int -> u0) -> u7; _NO_DEFLT_ } _N_
- {-defm-} _A_ 2 _U_ 02 _N_ _S_ _!_ _F_ _IF_ARGS_ 1 2 XX 3 _/\_ u0 -> \ (u1 :: {{Num u0}}) (u2 :: u0) -> _APP_ _TYAPP_ patError# { (u0 -> u0) } [ _NOREP_S_ "%DPreludeCore.Num.negate\"", u2 ] _N_ #-}
+ {-defm-} _A_ 2 _U_ 02 _N_ _S_ _!_ _N_ _N_ #-}
abs :: a -> a
{-# GHC_PRAGMA {-meth-} _A_ 1 _U_ 12 _N_ _S_ "S" _F_ _IF_ARGS_ 1 1 C 2 _/\_ u0 -> \ (u1 :: ({{Eq u0}}, {{Text u0}}, u0 -> u0 -> u0, u0 -> u0 -> u0, u0 -> u0 -> u0, u0 -> u0, u0 -> u0, u0 -> u0, Integer -> u0, Int -> u0)) -> case u1 of { _ALG_ _TUP_10 (u2 :: {{Eq u0}}) (u3 :: {{Text u0}}) (u4 :: u0 -> u0 -> u0) (u5 :: u0 -> u0 -> u0) (u6 :: u0 -> u0 -> u0) (u7 :: u0 -> u0) (u8 :: u0 -> u0) (u9 :: u0 -> u0) (ua :: Integer -> u0) (ub :: Int -> u0) -> u8; _NO_DEFLT_ } _N_
- {-defm-} _A_ 2 _U_ 02 _N_ _S_ _!_ _F_ _IF_ARGS_ 1 2 XX 3 _/\_ u0 -> \ (u1 :: {{Num u0}}) (u2 :: u0) -> _APP_ _TYAPP_ patError# { (u0 -> u0) } [ _NOREP_S_ "%DPreludeCore.Num.abs\"", u2 ] _N_ #-}
+ {-defm-} _A_ 2 _U_ 02 _N_ _S_ _!_ _N_ _N_ #-}
signum :: a -> a
{-# GHC_PRAGMA {-meth-} _A_ 1 _U_ 12 _N_ _S_ "S" _F_ _IF_ARGS_ 1 1 C 2 _/\_ u0 -> \ (u1 :: ({{Eq u0}}, {{Text u0}}, u0 -> u0 -> u0, u0 -> u0 -> u0, u0 -> u0 -> u0, u0 -> u0, u0 -> u0, u0 -> u0, Integer -> u0, Int -> u0)) -> case u1 of { _ALG_ _TUP_10 (u2 :: {{Eq u0}}) (u3 :: {{Text u0}}) (u4 :: u0 -> u0 -> u0) (u5 :: u0 -> u0 -> u0) (u6 :: u0 -> u0 -> u0) (u7 :: u0 -> u0) (u8 :: u0 -> u0) (u9 :: u0 -> u0) (ua :: Integer -> u0) (ub :: Int -> u0) -> u9; _NO_DEFLT_ } _N_
- {-defm-} _A_ 2 _U_ 02 _N_ _S_ _!_ _F_ _IF_ARGS_ 1 2 XX 3 _/\_ u0 -> \ (u1 :: {{Num u0}}) (u2 :: u0) -> _APP_ _TYAPP_ patError# { (u0 -> u0) } [ _NOREP_S_ "%DPreludeCore.Num.signum\"", u2 ] _N_ #-}
+ {-defm-} _A_ 2 _U_ 02 _N_ _S_ _!_ _N_ _N_ #-}
fromInteger :: Integer -> a
{-# GHC_PRAGMA {-meth-} _A_ 1 _U_ 12 _N_ _S_ "S" _F_ _IF_ARGS_ 1 1 C 2 _/\_ u0 -> \ (u1 :: ({{Eq u0}}, {{Text u0}}, u0 -> u0 -> u0, u0 -> u0 -> u0, u0 -> u0 -> u0, u0 -> u0, u0 -> u0, u0 -> u0, Integer -> u0, Int -> u0)) -> case u1 of { _ALG_ _TUP_10 (u2 :: {{Eq u0}}) (u3 :: {{Text u0}}) (u4 :: u0 -> u0 -> u0) (u5 :: u0 -> u0 -> u0) (u6 :: u0 -> u0 -> u0) (u7 :: u0 -> u0) (u8 :: u0 -> u0) (u9 :: u0 -> u0) (ua :: Integer -> u0) (ub :: Int -> u0) -> ua; _NO_DEFLT_ } _N_
- {-defm-} _A_ 2 _U_ 02 _N_ _S_ _!_ _F_ _IF_ARGS_ 1 2 XX 3 _/\_ u0 -> \ (u1 :: {{Num u0}}) (u2 :: Integer) -> _APP_ _TYAPP_ patError# { (Integer -> u0) } [ _NOREP_S_ "%DPreludeCore.Num.fromInteger\"", u2 ] _N_ #-}
+ {-defm-} _A_ 2 _U_ 02 _N_ _S_ _!_ _N_ _N_ #-}
fromInt :: Int -> a
{-# GHC_PRAGMA {-meth-} _A_ 1 _U_ 12 _N_ _S_ "S" _F_ _IF_ARGS_ 1 1 C 2 _/\_ u0 -> \ (u1 :: ({{Eq u0}}, {{Text u0}}, u0 -> u0 -> u0, u0 -> u0 -> u0, u0 -> u0 -> u0, u0 -> u0, u0 -> u0, u0 -> u0, Integer -> u0, Int -> u0)) -> case u1 of { _ALG_ _TUP_10 (u2 :: {{Eq u0}}) (u3 :: {{Text u0}}) (u4 :: u0 -> u0 -> u0) (u5 :: u0 -> u0 -> u0) (u6 :: u0 -> u0 -> u0) (u7 :: u0 -> u0) (u8 :: u0 -> u0) (u9 :: u0 -> u0) (ua :: Integer -> u0) (ub :: Int -> u0) -> ub; _NO_DEFLT_ } _N_
{-defm-} _A_ 2 _U_ 11 _N_ _S_ "SL" _F_ _IF_ARGS_ 1 2 CC 6 _/\_ u0 -> \ (u1 :: {{Num u0}}) (u2 :: Int) -> let {(u4 :: Integer) = case u2 of { _ALG_ I# (u3 :: Int#) -> _#_ int2Integer# [] [u3]; _NO_DEFLT_ }} in case u1 of { _ALG_ _TUP_10 (u5 :: {{Eq u0}}) (u6 :: {{Text u0}}) (u7 :: u0 -> u0 -> u0) (u8 :: u0 -> u0 -> u0) (u9 :: u0 -> u0 -> u0) (ua :: u0 -> u0) (ub :: u0 -> u0) (uc :: u0 -> u0) (ud :: Integer -> u0) (ue :: Int -> u0) -> _APP_ ud [ u4 ]; _NO_DEFLT_ } _N_ #-}
{-defm-} _A_ 3 _U_ 122 _N_ _S_ "SLL" _N_ _N_ #-}
(<=) :: a -> a -> Bool
{-# GHC_PRAGMA {-meth-} _A_ 1 _U_ 122 _N_ _S_ "S" _F_ _IF_ARGS_ 1 1 C 2 _/\_ u0 -> \ (u1 :: ({{Eq u0}}, u0 -> u0 -> Bool, u0 -> u0 -> Bool, u0 -> u0 -> Bool, u0 -> u0 -> Bool, u0 -> u0 -> u0, u0 -> u0 -> u0, u0 -> u0 -> _CMP_TAG)) -> case u1 of { _ALG_ _TUP_8 (u2 :: {{Eq u0}}) (u3 :: u0 -> u0 -> Bool) (u4 :: u0 -> u0 -> Bool) (u5 :: u0 -> u0 -> Bool) (u6 :: u0 -> u0 -> Bool) (u7 :: u0 -> u0 -> u0) (u8 :: u0 -> u0 -> u0) (u9 :: u0 -> u0 -> _CMP_TAG) -> u4; _NO_DEFLT_ } _N_
- {-defm-} _A_ 3 _U_ 022 _N_ _S_ _!_ _F_ _IF_ARGS_ 1 3 XXX 4 _/\_ u0 -> \ (u1 :: {{Ord u0}}) (u2 :: u0) (u3 :: u0) -> _APP_ _TYAPP_ patError# { (u0 -> u0 -> Bool) } [ _NOREP_S_ "%DPreludeCore.Ord.(<=)\"", u2, u3 ] _N_ #-}
+ {-defm-} _A_ 3 _U_ 022 _N_ _S_ _!_ _N_ _N_ #-}
(>=) :: a -> a -> Bool
{-# GHC_PRAGMA {-meth-} _A_ 1 _U_ 122 _N_ _S_ "S" _F_ _IF_ARGS_ 1 1 C 2 _/\_ u0 -> \ (u1 :: ({{Eq u0}}, u0 -> u0 -> Bool, u0 -> u0 -> Bool, u0 -> u0 -> Bool, u0 -> u0 -> Bool, u0 -> u0 -> u0, u0 -> u0 -> u0, u0 -> u0 -> _CMP_TAG)) -> case u1 of { _ALG_ _TUP_8 (u2 :: {{Eq u0}}) (u3 :: u0 -> u0 -> Bool) (u4 :: u0 -> u0 -> Bool) (u5 :: u0 -> u0 -> Bool) (u6 :: u0 -> u0 -> Bool) (u7 :: u0 -> u0 -> u0) (u8 :: u0 -> u0 -> u0) (u9 :: u0 -> u0 -> _CMP_TAG) -> u5; _NO_DEFLT_ } _N_
{-defm-} _A_ 3 _U_ 122 _N_ _S_ "SLL" _F_ _IF_ARGS_ 1 3 CXX 4 _/\_ u0 -> \ (u1 :: {{Ord u0}}) (u2 :: u0) (u3 :: u0) -> case u1 of { _ALG_ _TUP_8 (u4 :: {{Eq u0}}) (u5 :: u0 -> u0 -> Bool) (u6 :: u0 -> u0 -> Bool) (u7 :: u0 -> u0 -> Bool) (u8 :: u0 -> u0 -> Bool) (u9 :: u0 -> u0 -> u0) (ua :: u0 -> u0 -> u0) (ub :: u0 -> u0 -> _CMP_TAG) -> _APP_ u6 [ u3, u2 ]; _NO_DEFLT_ } _N_ #-}
class (Num a, Enum a) => Real a {-# GHC_PRAGMA {-superdicts-} _A_ 1 _U_ 1 _N_ _S_ "S" _F_ _IF_ARGS_ 1 1 C 2 _/\_ u0 -> \ (u1 :: ({{Num u0}}, {{Enum u0}}, u0 -> Ratio Integer)) -> case u1 of { _ALG_ _TUP_3 (u2 :: {{Num u0}}) (u3 :: {{Enum u0}}) (u4 :: u0 -> Ratio Integer) -> u2; _NO_DEFLT_ } _N_, _A_ 1 _U_ 1 _N_ _S_ "S" _F_ _IF_ARGS_ 1 1 C 2 _/\_ u0 -> \ (u1 :: ({{Num u0}}, {{Enum u0}}, u0 -> Ratio Integer)) -> case u1 of { _ALG_ _TUP_3 (u2 :: {{Num u0}}) (u3 :: {{Enum u0}}) (u4 :: u0 -> Ratio Integer) -> u3; _NO_DEFLT_ } _N_ #-} where
toRational :: a -> Ratio Integer
{-# GHC_PRAGMA {-meth-} _A_ 1 _U_ 12 _N_ _S_ "S" _F_ _IF_ARGS_ 1 1 C 2 _/\_ u0 -> \ (u1 :: ({{Num u0}}, {{Enum u0}}, u0 -> Ratio Integer)) -> case u1 of { _ALG_ _TUP_3 (u2 :: {{Num u0}}) (u3 :: {{Enum u0}}) (u4 :: u0 -> Ratio Integer) -> u4; _NO_DEFLT_ } _N_
- {-defm-} _A_ 2 _U_ 02 _N_ _S_ _!_ _F_ _IF_ARGS_ 1 2 XX 3 _/\_ u0 -> \ (u1 :: {{Real u0}}) (u2 :: u0) -> _APP_ _TYAPP_ patError# { (u0 -> Ratio Integer) } [ _NOREP_S_ "%DPreludeCore.Real.toRational\"", u2 ] _N_ #-}
+ {-defm-} _A_ 2 _U_ 02 _N_ _S_ _!_ _N_ _N_ #-}
class (RealFrac a, Floating a) => RealFloat a {-# GHC_PRAGMA {-superdicts-} _A_ 1 _U_ 1 _N_ _S_ "S" _F_ _IF_ARGS_ 1 1 C 2 _/\_ u0 -> \ (u1 :: ({{RealFrac u0}}, {{Floating u0}}, u0 -> Integer, u0 -> Int, u0 -> (Int, Int), u0 -> (Integer, Int), Integer -> Int -> u0, u0 -> Int, u0 -> u0, Int -> u0 -> u0)) -> case u1 of { _ALG_ _TUP_10 (u2 :: {{RealFrac u0}}) (u3 :: {{Floating u0}}) (u4 :: u0 -> Integer) (u5 :: u0 -> Int) (u6 :: u0 -> (Int, Int)) (u7 :: u0 -> (Integer, Int)) (u8 :: Integer -> Int -> u0) (u9 :: u0 -> Int) (ua :: u0 -> u0) (ub :: Int -> u0 -> u0) -> u2; _NO_DEFLT_ } _N_, _A_ 1 _U_ 1 _N_ _S_ "S" _F_ _IF_ARGS_ 1 1 C 2 _/\_ u0 -> \ (u1 :: ({{RealFrac u0}}, {{Floating u0}}, u0 -> Integer, u0 -> Int, u0 -> (Int, Int), u0 -> (Integer, Int), Integer -> Int -> u0, u0 -> Int, u0 -> u0, Int -> u0 -> u0)) -> case u1 of { _ALG_ _TUP_10 (u2 :: {{RealFrac u0}}) (u3 :: {{Floating u0}}) (u4 :: u0 -> Integer) (u5 :: u0 -> Int) (u6 :: u0 -> (Int, Int)) (u7 :: u0 -> (Integer, Int)) (u8 :: Integer -> Int -> u0) (u9 :: u0 -> Int) (ua :: u0 -> u0) (ub :: Int -> u0 -> u0) -> u3; _NO_DEFLT_ } _N_ #-} where
floatRadix :: a -> Integer
{-# GHC_PRAGMA {-meth-} _A_ 1 _U_ 12 _N_ _S_ "S" _F_ _IF_ARGS_ 1 1 C 2 _/\_ u0 -> \ (u1 :: ({{RealFrac u0}}, {{Floating u0}}, u0 -> Integer, u0 -> Int, u0 -> (Int, Int), u0 -> (Integer, Int), Integer -> Int -> u0, u0 -> Int, u0 -> u0, Int -> u0 -> u0)) -> case u1 of { _ALG_ _TUP_10 (u2 :: {{RealFrac u0}}) (u3 :: {{Floating u0}}) (u4 :: u0 -> Integer) (u5 :: u0 -> Int) (u6 :: u0 -> (Int, Int)) (u7 :: u0 -> (Integer, Int)) (u8 :: Integer -> Int -> u0) (u9 :: u0 -> Int) (ua :: u0 -> u0) (ub :: Int -> u0 -> u0) -> u4; _NO_DEFLT_ } _N_
- {-defm-} _A_ 2 _U_ 02 _N_ _S_ _!_ _F_ _IF_ARGS_ 1 2 XX 3 _/\_ u0 -> \ (u1 :: {{RealFloat u0}}) (u2 :: u0) -> _APP_ _TYAPP_ patError# { (u0 -> Integer) } [ _NOREP_S_ "%DPreludeCore.RealFloat.floatRadix\"", u2 ] _N_ #-}
+ {-defm-} _A_ 2 _U_ 02 _N_ _S_ _!_ _N_ _N_ #-}
floatDigits :: a -> Int
{-# GHC_PRAGMA {-meth-} _A_ 1 _U_ 12 _N_ _S_ "S" _F_ _IF_ARGS_ 1 1 C 2 _/\_ u0 -> \ (u1 :: ({{RealFrac u0}}, {{Floating u0}}, u0 -> Integer, u0 -> Int, u0 -> (Int, Int), u0 -> (Integer, Int), Integer -> Int -> u0, u0 -> Int, u0 -> u0, Int -> u0 -> u0)) -> case u1 of { _ALG_ _TUP_10 (u2 :: {{RealFrac u0}}) (u3 :: {{Floating u0}}) (u4 :: u0 -> Integer) (u5 :: u0 -> Int) (u6 :: u0 -> (Int, Int)) (u7 :: u0 -> (Integer, Int)) (u8 :: Integer -> Int -> u0) (u9 :: u0 -> Int) (ua :: u0 -> u0) (ub :: Int -> u0 -> u0) -> u5; _NO_DEFLT_ } _N_
- {-defm-} _A_ 2 _U_ 02 _N_ _S_ _!_ _F_ _IF_ARGS_ 1 2 XX 3 _/\_ u0 -> \ (u1 :: {{RealFloat u0}}) (u2 :: u0) -> _APP_ _TYAPP_ patError# { (u0 -> Int) } [ _NOREP_S_ "%DPreludeCore.RealFloat.floatDigits\"", u2 ] _N_ #-}
+ {-defm-} _A_ 2 _U_ 02 _N_ _S_ _!_ _N_ _N_ #-}
floatRange :: a -> (Int, Int)
{-# GHC_PRAGMA {-meth-} _A_ 1 _U_ 12 _N_ _S_ "S" _F_ _IF_ARGS_ 1 1 C 2 _/\_ u0 -> \ (u1 :: ({{RealFrac u0}}, {{Floating u0}}, u0 -> Integer, u0 -> Int, u0 -> (Int, Int), u0 -> (Integer, Int), Integer -> Int -> u0, u0 -> Int, u0 -> u0, Int -> u0 -> u0)) -> case u1 of { _ALG_ _TUP_10 (u2 :: {{RealFrac u0}}) (u3 :: {{Floating u0}}) (u4 :: u0 -> Integer) (u5 :: u0 -> Int) (u6 :: u0 -> (Int, Int)) (u7 :: u0 -> (Integer, Int)) (u8 :: Integer -> Int -> u0) (u9 :: u0 -> Int) (ua :: u0 -> u0) (ub :: Int -> u0 -> u0) -> u6; _NO_DEFLT_ } _N_
- {-defm-} _A_ 2 _U_ 02 _N_ _S_ _!_ _F_ _IF_ARGS_ 1 2 XX 3 _/\_ u0 -> \ (u1 :: {{RealFloat u0}}) (u2 :: u0) -> _APP_ _TYAPP_ patError# { (u0 -> (Int, Int)) } [ _NOREP_S_ "%DPreludeCore.RealFloat.floatRange\"", u2 ] _N_ #-}
+ {-defm-} _A_ 2 _U_ 02 _N_ _S_ _!_ _N_ _N_ #-}
decodeFloat :: a -> (Integer, Int)
{-# GHC_PRAGMA {-meth-} _A_ 1 _U_ 12 _N_ _S_ "S" _F_ _IF_ARGS_ 1 1 C 2 _/\_ u0 -> \ (u1 :: ({{RealFrac u0}}, {{Floating u0}}, u0 -> Integer, u0 -> Int, u0 -> (Int, Int), u0 -> (Integer, Int), Integer -> Int -> u0, u0 -> Int, u0 -> u0, Int -> u0 -> u0)) -> case u1 of { _ALG_ _TUP_10 (u2 :: {{RealFrac u0}}) (u3 :: {{Floating u0}}) (u4 :: u0 -> Integer) (u5 :: u0 -> Int) (u6 :: u0 -> (Int, Int)) (u7 :: u0 -> (Integer, Int)) (u8 :: Integer -> Int -> u0) (u9 :: u0 -> Int) (ua :: u0 -> u0) (ub :: Int -> u0 -> u0) -> u7; _NO_DEFLT_ } _N_
- {-defm-} _A_ 2 _U_ 02 _N_ _S_ _!_ _F_ _IF_ARGS_ 1 2 XX 3 _/\_ u0 -> \ (u1 :: {{RealFloat u0}}) (u2 :: u0) -> _APP_ _TYAPP_ patError# { (u0 -> (Integer, Int)) } [ _NOREP_S_ "%DPreludeCore.RealFloat.decodeFloat\"", u2 ] _N_ #-}
+ {-defm-} _A_ 2 _U_ 02 _N_ _S_ _!_ _N_ _N_ #-}
encodeFloat :: Integer -> Int -> a
{-# GHC_PRAGMA {-meth-} _A_ 1 _U_ 122 _N_ _S_ "S" _F_ _IF_ARGS_ 1 1 C 2 _/\_ u0 -> \ (u1 :: ({{RealFrac u0}}, {{Floating u0}}, u0 -> Integer, u0 -> Int, u0 -> (Int, Int), u0 -> (Integer, Int), Integer -> Int -> u0, u0 -> Int, u0 -> u0, Int -> u0 -> u0)) -> case u1 of { _ALG_ _TUP_10 (u2 :: {{RealFrac u0}}) (u3 :: {{Floating u0}}) (u4 :: u0 -> Integer) (u5 :: u0 -> Int) (u6 :: u0 -> (Int, Int)) (u7 :: u0 -> (Integer, Int)) (u8 :: Integer -> Int -> u0) (u9 :: u0 -> Int) (ua :: u0 -> u0) (ub :: Int -> u0 -> u0) -> u8; _NO_DEFLT_ } _N_
- {-defm-} _A_ 3 _U_ 022 _N_ _S_ _!_ _F_ _IF_ARGS_ 1 3 XXX 4 _/\_ u0 -> \ (u1 :: {{RealFloat u0}}) (u2 :: Integer) (u3 :: Int) -> _APP_ _TYAPP_ patError# { (Integer -> Int -> u0) } [ _NOREP_S_ "%DPreludeCore.RealFloat.encodeFloat\"", u2, u3 ] _N_ #-}
+ {-defm-} _A_ 3 _U_ 022 _N_ _S_ _!_ _N_ _N_ #-}
exponent :: a -> Int
{-# GHC_PRAGMA {-meth-} _A_ 1 _U_ 12 _N_ _S_ "S" _F_ _IF_ARGS_ 1 1 C 2 _/\_ u0 -> \ (u1 :: ({{RealFrac u0}}, {{Floating u0}}, u0 -> Integer, u0 -> Int, u0 -> (Int, Int), u0 -> (Integer, Int), Integer -> Int -> u0, u0 -> Int, u0 -> u0, Int -> u0 -> u0)) -> case u1 of { _ALG_ _TUP_10 (u2 :: {{RealFrac u0}}) (u3 :: {{Floating u0}}) (u4 :: u0 -> Integer) (u5 :: u0 -> Int) (u6 :: u0 -> (Int, Int)) (u7 :: u0 -> (Integer, Int)) (u8 :: Integer -> Int -> u0) (u9 :: u0 -> Int) (ua :: u0 -> u0) (ub :: Int -> u0 -> u0) -> u9; _NO_DEFLT_ } _N_
{-defm-} _A_ 2 _U_ 12 _N_ _S_ "SL" _N_ _N_ #-}
class (Real a, Fractional a) => RealFrac a {-# GHC_PRAGMA {-superdicts-} _A_ 1 _U_ 1 _N_ _S_ "S" _F_ _IF_ARGS_ 1 1 C 2 _/\_ u0 -> \ (u1 :: ({{Real u0}}, {{Fractional u0}}, (_forall_ z$z1 =>{{Integral z$z1}} -> u0 -> (z$z1, u0)), (_forall_ z$z1 =>{{Integral z$z1}} -> u0 -> z$z1), (_forall_ z$z1 =>{{Integral z$z1}} -> u0 -> z$z1), (_forall_ z$z1 =>{{Integral z$z1}} -> u0 -> z$z1), (_forall_ z$z1 =>{{Integral z$z1}} -> u0 -> z$z1))) -> case u1 of { _ALG_ _TUP_7 (u2 :: {{Real u0}}) (u3 :: {{Fractional u0}}) (u4 :: _forall_ a$z1 =>{{Integral a$z1}} -> u0 -> (a$z1, u0)) (u5 :: _forall_ a$z1 =>{{Integral a$z1}} -> u0 -> a$z1) (u6 :: _forall_ a$z1 =>{{Integral a$z1}} -> u0 -> a$z1) (u7 :: _forall_ a$z1 =>{{Integral a$z1}} -> u0 -> a$z1) (u8 :: _forall_ a$z1 =>{{Integral a$z1}} -> u0 -> a$z1) -> u2; _NO_DEFLT_ } _N_, _A_ 1 _U_ 1 _N_ _S_ "S" _F_ _IF_ARGS_ 1 1 C 2 _/\_ u0 -> \ (u1 :: ({{Real u0}}, {{Fractional u0}}, (_forall_ z$z1 =>{{Integral z$z1}} -> u0 -> (z$z1, u0)), (_forall_ z$z1 =>{{Integral z$z1}} -> u0 -> z$z1), (_forall_ z$z1 =>{{Integral z$z1}} -> u0 -> z$z1), (_forall_ z$z1 =>{{Integral z$z1}} -> u0 -> z$z1), (_forall_ z$z1 =>{{Integral z$z1}} -> u0 -> z$z1))) -> case u1 of { _ALG_ _TUP_7 (u2 :: {{Real u0}}) (u3 :: {{Fractional u0}}) (u4 :: _forall_ a$z1 =>{{Integral a$z1}} -> u0 -> (a$z1, u0)) (u5 :: _forall_ a$z1 =>{{Integral a$z1}} -> u0 -> a$z1) (u6 :: _forall_ a$z1 =>{{Integral a$z1}} -> u0 -> a$z1) (u7 :: _forall_ a$z1 =>{{Integral a$z1}} -> u0 -> a$z1) (u8 :: _forall_ a$z1 =>{{Integral a$z1}} -> u0 -> a$z1) -> u3; _NO_DEFLT_ } _N_ #-} where
properFraction :: Integral b => a -> (b, a)
{-# GHC_PRAGMA {-meth-} _A_ 2 _U_ 122 _N_ _S_ "SL" _F_ _IF_ARGS_ 2 2 CX 3 _/\_ u0 u1 -> \ (u2 :: ({{Real u0}}, {{Fractional u0}}, (_forall_ z$z1 =>{{Integral z$z1}} -> u0 -> (z$z1, u0)), (_forall_ z$z1 =>{{Integral z$z1}} -> u0 -> z$z1), (_forall_ z$z1 =>{{Integral z$z1}} -> u0 -> z$z1), (_forall_ z$z1 =>{{Integral z$z1}} -> u0 -> z$z1), (_forall_ z$z1 =>{{Integral z$z1}} -> u0 -> z$z1))) (u3 :: {{Integral u1}}) -> case u2 of { _ALG_ _TUP_7 (u4 :: {{Real u0}}) (u5 :: {{Fractional u0}}) (u6 :: _forall_ a$z1 =>{{Integral a$z1}} -> u0 -> (a$z1, u0)) (u7 :: _forall_ a$z1 =>{{Integral a$z1}} -> u0 -> a$z1) (u8 :: _forall_ a$z1 =>{{Integral a$z1}} -> u0 -> a$z1) (u9 :: _forall_ a$z1 =>{{Integral a$z1}} -> u0 -> a$z1) (ua :: _forall_ a$z1 =>{{Integral a$z1}} -> u0 -> a$z1) -> _APP_ _TYAPP_ u6 { u1 } [ u3 ]; _NO_DEFLT_ } _N_
- {-defm-} _A_ 3 _U_ 002 _N_ _S_ _!_ _F_ _IF_ARGS_ 2 3 XXX 3 _/\_ u0 u1 -> \ (u2 :: {{RealFrac u0}}) (u3 :: {{Integral u1}}) (u4 :: u0) -> _APP_ _TYAPP_ patError# { (u0 -> (u1, u0)) } [ _NOREP_S_ "%DPreludeCore.RealFrac.properFraction\"", u4 ] _N_ #-}
+ {-defm-} _A_ 3 _U_ 002 _N_ _S_ _!_ _N_ _N_ #-}
truncate :: Integral b => a -> b
{-# GHC_PRAGMA {-meth-} _A_ 2 _U_ 122 _N_ _S_ "SL" _F_ _IF_ARGS_ 2 2 CX 3 _/\_ u0 u1 -> \ (u2 :: ({{Real u0}}, {{Fractional u0}}, (_forall_ z$z1 =>{{Integral z$z1}} -> u0 -> (z$z1, u0)), (_forall_ z$z1 =>{{Integral z$z1}} -> u0 -> z$z1), (_forall_ z$z1 =>{{Integral z$z1}} -> u0 -> z$z1), (_forall_ z$z1 =>{{Integral z$z1}} -> u0 -> z$z1), (_forall_ z$z1 =>{{Integral z$z1}} -> u0 -> z$z1))) (u3 :: {{Integral u1}}) -> case u2 of { _ALG_ _TUP_7 (u4 :: {{Real u0}}) (u5 :: {{Fractional u0}}) (u6 :: _forall_ a$z1 =>{{Integral a$z1}} -> u0 -> (a$z1, u0)) (u7 :: _forall_ a$z1 =>{{Integral a$z1}} -> u0 -> a$z1) (u8 :: _forall_ a$z1 =>{{Integral a$z1}} -> u0 -> a$z1) (u9 :: _forall_ a$z1 =>{{Integral a$z1}} -> u0 -> a$z1) (ua :: _forall_ a$z1 =>{{Integral a$z1}} -> u0 -> a$z1) -> _APP_ _TYAPP_ u7 { u1 } [ u3 ]; _NO_DEFLT_ } _N_
{-defm-} _A_ 2 _U_ 122 _N_ _S_ "SL" _N_ _N_ #-}
class Text a where
readsPrec :: Int -> [Char] -> [(a, [Char])]
{-# GHC_PRAGMA {-meth-} _A_ 1 _U_ 122 _N_ _S_ "S" _F_ _IF_ARGS_ 1 1 C 2 _/\_ u0 -> \ (u1 :: (Int -> [Char] -> [(u0, [Char])], Int -> u0 -> [Char] -> [Char], [Char] -> [([u0], [Char])], [u0] -> [Char] -> [Char])) -> case u1 of { _ALG_ _TUP_4 (u2 :: Int -> [Char] -> [(u0, [Char])]) (u3 :: Int -> u0 -> [Char] -> [Char]) (u4 :: [Char] -> [([u0], [Char])]) (u5 :: [u0] -> [Char] -> [Char]) -> u2; _NO_DEFLT_ } _N_
- {-defm-} _A_ 3 _U_ 022 _N_ _S_ _!_ _F_ _IF_ARGS_ 1 3 XXX 4 _/\_ u0 -> \ (u1 :: {{Text u0}}) (u2 :: Int) (u3 :: [Char]) -> _APP_ _TYAPP_ patError# { (Int -> [Char] -> [(u0, [Char])]) } [ _NOREP_S_ "%DPreludeCore.Text.readsPrec\"", u2, u3 ] _N_ #-}
+ {-defm-} _A_ 3 _U_ 022 _N_ _S_ _!_ _N_ _N_ #-}
showsPrec :: Int -> a -> [Char] -> [Char]
{-# GHC_PRAGMA {-meth-} _A_ 1 _U_ 1222 _N_ _S_ "S" _F_ _IF_ARGS_ 1 1 C 2 _/\_ u0 -> \ (u1 :: (Int -> [Char] -> [(u0, [Char])], Int -> u0 -> [Char] -> [Char], [Char] -> [([u0], [Char])], [u0] -> [Char] -> [Char])) -> case u1 of { _ALG_ _TUP_4 (u2 :: Int -> [Char] -> [(u0, [Char])]) (u3 :: Int -> u0 -> [Char] -> [Char]) (u4 :: [Char] -> [([u0], [Char])]) (u5 :: [u0] -> [Char] -> [Char]) -> u3; _NO_DEFLT_ } _N_
- {-defm-} _A_ 4 _U_ 0222 _N_ _S_ _!_ _F_ _IF_ARGS_ 1 4 XXXX 5 _/\_ u0 -> \ (u1 :: {{Text u0}}) (u2 :: Int) (u3 :: u0) (u4 :: [Char]) -> _APP_ _TYAPP_ patError# { (Int -> u0 -> [Char] -> [Char]) } [ _NOREP_S_ "%DPreludeCore.Text.showsPrec\"", u2, u3, u4 ] _N_ #-}
+ {-defm-} _A_ 4 _U_ 0222 _N_ _S_ _!_ _N_ _N_ #-}
readList :: [Char] -> [([a], [Char])]
{-# GHC_PRAGMA {-meth-} _A_ 1 _U_ 12 _N_ _S_ "S" _F_ _IF_ARGS_ 1 1 C 2 _/\_ u0 -> \ (u1 :: (Int -> [Char] -> [(u0, [Char])], Int -> u0 -> [Char] -> [Char], [Char] -> [([u0], [Char])], [u0] -> [Char] -> [Char])) -> case u1 of { _ALG_ _TUP_4 (u2 :: Int -> [Char] -> [(u0, [Char])]) (u3 :: Int -> u0 -> [Char] -> [Char]) (u4 :: [Char] -> [([u0], [Char])]) (u5 :: [u0] -> [Char] -> [Char]) -> u4; _NO_DEFLT_ } _N_
- {-defm-} _A_ 1 _U_ 22 _N_ _N_ _F_ _IF_ARGS_ 0 0 X 1 _ORIG_ PreludeCore _readList _N_ #-}
+ {-defm-} _A_ 1 _U_ 12 _N_ _N_ _N_ _N_ #-}
showList :: [a] -> [Char] -> [Char]
{-# GHC_PRAGMA {-meth-} _A_ 1 _U_ 122 _N_ _S_ "S" _F_ _IF_ARGS_ 1 1 C 2 _/\_ u0 -> \ (u1 :: (Int -> [Char] -> [(u0, [Char])], Int -> u0 -> [Char] -> [Char], [Char] -> [([u0], [Char])], [u0] -> [Char] -> [Char])) -> case u1 of { _ALG_ _TUP_4 (u2 :: Int -> [Char] -> [(u0, [Char])]) (u3 :: Int -> u0 -> [Char] -> [Char]) (u4 :: [Char] -> [([u0], [Char])]) (u5 :: [u0] -> [Char] -> [Char]) -> u5; _NO_DEFLT_ } _N_
- {-defm-} _A_ 1 _U_ 212 _N_ _N_ _F_ _IF_ARGS_ 0 0 X 1 _ORIG_ PreludeCore _showList _N_ #-}
+ {-defm-} _A_ 1 _U_ 112 _N_ _N_ _N_ _N_ #-}
class _CCallable a
class _CReturnable a
data Array a b {-# GHC_PRAGMA _Array (a, a) (Array# b) #-}
data Assoc a b = (:=) a b
data _ByteArray a {-# GHC_PRAGMA _ByteArray (a, a) ByteArray# #-}
data Bin
-data Complex a = (:+) a a
+data Complex a = (:+) a a {-# GHC_PRAGMA _SPECIALISE_ [ Double# ] #-}
data _MutableArray a b c {-# GHC_PRAGMA _MutableArray (b, b) (MutableArray# a c) #-}
data _MutableByteArray a b {-# GHC_PRAGMA _MutableByteArray (b, b) (MutableByteArray# a) #-}
type BinCont = Bin -> [Response] -> [Request]
type ReadS a = [Char] -> [(a, [Char])]
type ShowS = [Char] -> [Char]
data _FILE {-# GHC_PRAGMA _FILE Addr# #-}
+__i0 :: Num a => a
+ {-# GHC_PRAGMA _A_ 1 _U_ 1 _N_ _S_ "U(AAAAAAAAAS)" {_A_ 1 _U_ 1 _N_ _N_ _N_ _N_} _N_ _SPECIALISE_ [ Double ] 1 { _A_ 0 _N_ _N_ _N_ _F_ _IF_ARGS_ 0 0 X 2 _!_ D# [] [0.0000000000000000##] _N_ }, [ Int ] 1 { _A_ 0 _N_ _N_ _N_ _F_ _IF_ARGS_ 0 0 X 2 _!_ I# [] [0#] _N_ }, [ Integer ] 1 { _A_ 0 _N_ _N_ _N_ _N_ _N_ }, [ (Ratio Integer) ] 1 { _A_ 0 _N_ _N_ _N_ _N_ _N_ }, [ (Complex Double) ] 1 { _A_ 0 _N_ _N_ _N_ _N_ _N_ } #-}
+__i1 :: Num a => a
+ {-# GHC_PRAGMA _A_ 1 _U_ 1 _N_ _S_ "U(AAAAAAAAAS)" {_A_ 1 _U_ 1 _N_ _N_ _N_ _N_} _N_ _SPECIALISE_ [ Double ] 1 { _A_ 0 _N_ _N_ _N_ _F_ _IF_ARGS_ 0 0 X 2 _!_ D# [] [1.0000000000000000##] _N_ }, [ Int ] 1 { _A_ 0 _N_ _N_ _N_ _F_ _IF_ARGS_ 0 0 X 2 _!_ I# [] [1#] _N_ }, [ Integer ] 1 { _A_ 0 _N_ _N_ _N_ _N_ _N_ }, [ (Ratio Integer) ] 1 { _A_ 0 _N_ _N_ _N_ _N_ _N_ }, [ (Complex Double) ] 1 { _A_ 0 _N_ _N_ _N_ _N_ _N_ } #-}
+__i10 :: Num a => a
+ {-# GHC_PRAGMA _A_ 1 _U_ 1 _N_ _S_ "U(AAAAAAAAAS)" {_A_ 1 _U_ 1 _N_ _N_ _N_ _N_} _N_ _SPECIALISE_ [ Double ] 1 { _A_ 0 _N_ _N_ _N_ _F_ _IF_ARGS_ 0 0 X 2 _!_ D# [] [10.000000000000000##] _N_ }, [ Int ] 1 { _A_ 0 _N_ _N_ _N_ _F_ _IF_ARGS_ 0 0 X 2 _!_ I# [] [10#] _N_ }, [ Integer ] 1 { _A_ 0 _N_ _N_ _N_ _N_ _N_ }, [ (Ratio Integer) ] 1 { _A_ 0 _N_ _N_ _N_ _N_ _N_ }, [ (Complex Double) ] 1 { _A_ 0 _N_ _N_ _N_ _N_ _N_ } #-}
+__i16 :: Num a => a
+ {-# GHC_PRAGMA _A_ 1 _U_ 1 _N_ _S_ "U(AAAAAAAAAS)" {_A_ 1 _U_ 1 _N_ _N_ _N_ _N_} _N_ _SPECIALISE_ [ Double ] 1 { _A_ 0 _N_ _N_ _N_ _F_ _IF_ARGS_ 0 0 X 2 _!_ D# [] [16.000000000000000##] _N_ }, [ Int ] 1 { _A_ 0 _N_ _N_ _N_ _F_ _IF_ARGS_ 0 0 X 2 _!_ I# [] [16#] _N_ }, [ Integer ] 1 { _A_ 0 _N_ _N_ _N_ _N_ _N_ }, [ (Ratio Integer) ] 1 { _A_ 0 _N_ _N_ _N_ _N_ _N_ }, [ (Complex Double) ] 1 { _A_ 0 _N_ _N_ _N_ _N_ _N_ } #-}
+__i2 :: Num a => a
+ {-# GHC_PRAGMA _A_ 1 _U_ 1 _N_ _S_ "U(AAAAAAAAAS)" {_A_ 1 _U_ 1 _N_ _N_ _N_ _N_} _N_ _SPECIALISE_ [ Double ] 1 { _A_ 0 _N_ _N_ _N_ _F_ _IF_ARGS_ 0 0 X 2 _!_ D# [] [2.0000000000000000##] _N_ }, [ Int ] 1 { _A_ 0 _N_ _N_ _N_ _F_ _IF_ARGS_ 0 0 X 2 _!_ I# [] [2#] _N_ }, [ Integer ] 1 { _A_ 0 _N_ _N_ _N_ _N_ _N_ }, [ (Ratio Integer) ] 1 { _A_ 0 _N_ _N_ _N_ _N_ _N_ }, [ (Complex Double) ] 1 { _A_ 0 _N_ _N_ _N_ _N_ _N_ } #-}
+__i8 :: Num a => a
+ {-# GHC_PRAGMA _A_ 1 _U_ 1 _N_ _S_ "U(AAAAAAAAAS)" {_A_ 1 _U_ 1 _N_ _N_ _N_ _N_} _N_ _SPECIALISE_ [ Double ] 1 { _A_ 0 _N_ _N_ _N_ _F_ _IF_ARGS_ 0 0 X 2 _!_ D# [] [8.0000000000000000##] _N_ }, [ Int ] 1 { _A_ 0 _N_ _N_ _N_ _F_ _IF_ARGS_ 0 0 X 2 _!_ I# [] [8#] _N_ }, [ Integer ] 1 { _A_ 0 _N_ _N_ _N_ _N_ _N_ }, [ (Ratio Integer) ] 1 { _A_ 0 _N_ _N_ _N_ _N_ _N_ }, [ (Complex Double) ] 1 { _A_ 0 _N_ _N_ _N_ _N_ _N_ } #-}
+__im1 :: Num a => a
+ {-# GHC_PRAGMA _A_ 1 _U_ 1 _N_ _S_ "U(AAAAAAAAAS)" {_A_ 1 _U_ 1 _N_ _N_ _N_ _N_} _N_ _SPECIALISE_ [ Double ] 1 { _A_ 0 _N_ _N_ _N_ _F_ _IF_ARGS_ 0 0 X 2 _!_ D# [] [-1.0000000000000000##] _N_ }, [ Int ] 1 { _A_ 0 _N_ _N_ _N_ _F_ _IF_ARGS_ 0 0 X 2 _!_ I# [] [-1#] _N_ }, [ Integer ] 1 { _A_ 0 _N_ _N_ _N_ _N_ _N_ }, [ (Ratio Integer) ] 1 { _A_ 0 _N_ _N_ _N_ _N_ _N_ }, [ (Complex Double) ] 1 { _A_ 0 _N_ _N_ _N_ _N_ _N_ } #-}
+__integer0 :: Integer
+ {-# GHC_PRAGMA _A_ 0 _N_ _N_ _N_ _N_ _N_ #-}
+__integer1 :: Integer
+ {-# GHC_PRAGMA _A_ 0 _N_ _N_ _N_ _N_ _N_ #-}
+__integer2 :: Integer
+ {-# GHC_PRAGMA _A_ 0 _N_ _N_ _N_ _N_ _N_ #-}
+__integerm1 :: Integer
+ {-# GHC_PRAGMA _A_ 0 _N_ _N_ _N_ _N_ _N_ #-}
+__rhalf :: Fractional a => a
+ {-# GHC_PRAGMA _A_ 1 _U_ 1 _N_ _S_ "U(AAAS)" {_A_ 1 _U_ 1 _N_ _N_ _N_ _N_} _N_ _SPECIALISE_ [ Double ] 1 { _A_ 0 _N_ _N_ _N_ _N_ _N_ }, [ (Ratio Integer) ] 1 { _A_ 0 _N_ _N_ _N_ _F_ _IF_ARGS_ 0 0 X 3 _!_ (:%) [Integer] [_SPEC_ _ORIG_ PreludeCore __i1 [ (Integer) ], _SPEC_ _ORIG_ PreludeCore __i2 [ (Integer) ]] _N_ }, [ (Complex Double) ] 1 { _A_ 0 _N_ _N_ _N_ _N_ _N_ } #-}
+_fromRational :: RealFloat a => Ratio Integer -> a
+ {-# GHC_PRAGMA _A_ 2 _U_ 22 _N_ _N_ _N_ _SPECIALISE_ [ Double ] 1 { _A_ 1 _U_ 1 _N_ _S_ "U(U(PPP)U(PPP))" {_A_ 4 _U_ 2221 _N_ _N_ _N_ _N_} _N_ _N_ } #-}
instance Enum ()
{-# GHC_PRAGMA _M_ PreludeBuiltin {-dfun-} _A_ 0 _N_ _N_ _N_ _F_ _IF_ARGS_ 0 0 X 6 _!_ _TUP_5 [{{Ord ()}}, (() -> [()]), (() -> () -> [()]), (() -> () -> [()]), (() -> () -> () -> [()])] [_DFUN_ Ord (()), _CONSTM_ Enum enumFrom (()), _CONSTM_ Enum enumFromThen (()), _CONSTM_ Enum enumFromTo (()), _CONSTM_ Enum enumFromThenTo (())] _N_
- enumFrom = _A_ 1 _U_ 2 _N_ _S_ "E" _N_ _N_,
- enumFromThen = _A_ 2 _U_ 21 _N_ _S_ "EE" _F_ _IF_ARGS_ 0 2 CC 7 \ (u0 :: ()) (u1 :: ()) -> case u0 of { _ALG_ _TUP_0 -> case u1 of { _ALG_ _TUP_0 -> let {(u2 :: [()]) = _!_ _NIL_ [()] []} in _!_ (:) [()] [u0, u2]; _NO_DEFLT_ }; _NO_DEFLT_ } _N_,
- enumFromTo = _A_ 2 _U_ 21 _N_ _S_ "EE" _F_ _IF_ARGS_ 0 2 CC 7 \ (u0 :: ()) (u1 :: ()) -> case u0 of { _ALG_ _TUP_0 -> case u1 of { _ALG_ _TUP_0 -> let {(u2 :: [()]) = _!_ _NIL_ [()] []} in _!_ (:) [()] [u0, u2]; _NO_DEFLT_ }; _NO_DEFLT_ } _N_,
- enumFromThenTo = _A_ 3 _U_ 211 _N_ _S_ "EEE" _F_ _IF_ARGS_ 0 3 CCC 8 \ (u0 :: ()) (u1 :: ()) (u2 :: ()) -> case u0 of { _ALG_ _TUP_0 -> case u1 of { _ALG_ _TUP_0 -> case u2 of { _ALG_ _TUP_0 -> let {(u3 :: [()]) = _!_ _NIL_ [()] []} in _!_ (:) [()] [u0, u3]; _NO_DEFLT_ }; _NO_DEFLT_ }; _NO_DEFLT_ } _N_ #-}
+ enumFrom = { _A_ 1 _U_ 2 _N_ _S_ "E" _N_ _N_ },
+ enumFromThen = { _A_ 2 _U_ 21 _N_ _S_ "EE" _F_ _IF_ARGS_ 0 2 CC 7 \ (u0 :: ()) (u1 :: ()) -> case u0 of { _ALG_ _TUP_0 -> case u1 of { _ALG_ _TUP_0 -> let {(u2 :: [()]) = _!_ _NIL_ [()] []} in _!_ (:) [()] [u0, u2]; _NO_DEFLT_ }; _NO_DEFLT_ } _N_ },
+ enumFromTo = { _A_ 2 _U_ 21 _N_ _S_ "EE" _F_ _IF_ARGS_ 0 2 CC 7 \ (u0 :: ()) (u1 :: ()) -> case u0 of { _ALG_ _TUP_0 -> case u1 of { _ALG_ _TUP_0 -> let {(u2 :: [()]) = _!_ _NIL_ [()] []} in _!_ (:) [()] [u0, u2]; _NO_DEFLT_ }; _NO_DEFLT_ } _N_ },
+ enumFromThenTo = { _A_ 3 _U_ 211 _N_ _S_ "EEE" _F_ _IF_ARGS_ 0 3 CCC 8 \ (u0 :: ()) (u1 :: ()) (u2 :: ()) -> case u0 of { _ALG_ _TUP_0 -> case u1 of { _ALG_ _TUP_0 -> case u2 of { _ALG_ _TUP_0 -> let {(u3 :: [()]) = _!_ _NIL_ [()] []} in _!_ (:) [()] [u0, u3]; _NO_DEFLT_ }; _NO_DEFLT_ }; _NO_DEFLT_ } _N_ } #-}
instance Enum Bool
{-# GHC_PRAGMA _M_ PreludeCore {-dfun-} _A_ 0 _N_ _N_ _N_ _F_ _IF_ARGS_ 0 0 X 6 _!_ _TUP_5 [{{Ord Bool}}, (Bool -> [Bool]), (Bool -> Bool -> [Bool]), (Bool -> Bool -> [Bool]), (Bool -> Bool -> Bool -> [Bool])] [_DFUN_ Ord (Bool), _CONSTM_ Enum enumFrom (Bool), _CONSTM_ Enum enumFromThen (Bool), _CONSTM_ Enum enumFromTo (Bool), _CONSTM_ Enum enumFromThenTo (Bool)] _N_
- enumFrom = _A_ 1 _U_ 2 _N_ _S_ "E" _N_ _N_,
- enumFromThen = _A_ 2 _U_ 22 _N_ _S_ "EE" _N_ _N_,
- enumFromTo = _A_ 2 _U_ 22 _N_ _N_ _N_ _N_,
- enumFromThenTo = _A_ 3 _U_ 222 _N_ _N_ _N_ _N_ #-}
+ enumFrom = { _A_ 1 _U_ 2 _N_ _S_ "E" _N_ _N_ },
+ enumFromThen = { _A_ 2 _U_ 22 _N_ _S_ "EE" _N_ _N_ },
+ enumFromTo = { _A_ 2 _U_ 22 _N_ _S_ "EL" _N_ _N_ },
+ enumFromThenTo = { _A_ 3 _U_ 222 _N_ _S_ "EEL" _N_ _N_ } #-}
instance Enum Char
{-# GHC_PRAGMA _M_ PreludeCore {-dfun-} _A_ 0 _N_ _N_ _N_ _F_ _IF_ARGS_ 0 0 X 6 _!_ _TUP_5 [{{Ord Char}}, (Char -> [Char]), (Char -> Char -> [Char]), (Char -> Char -> [Char]), (Char -> Char -> Char -> [Char])] [_DFUN_ Ord (Char), _CONSTM_ Enum enumFrom (Char), _CONSTM_ Enum enumFromThen (Char), _CONSTM_ Enum enumFromTo (Char), _CONSTM_ Enum enumFromThenTo (Char)] _N_
- enumFrom = _A_ 1 _U_ 1 _N_ _S_ "U(P)" {_A_ 1 _U_ 2 _N_ _N_ _N_ _N_} _N_ _N_,
- enumFromThen = _A_ 2 _U_ 22 _N_ _N_ _N_ _N_,
- enumFromTo = _A_ 2 _U_ 22 _N_ _N_ _N_ _N_,
- enumFromThenTo = _A_ 3 _U_ 222 _N_ _N_ _N_ _N_ #-}
+ enumFrom = { _A_ 1 _U_ 1 _N_ _S_ "U(P)" {_A_ 1 _U_ 2 _N_ _N_ _N_ _N_} _N_ _N_ },
+ enumFromThen = { _A_ 2 _U_ 22 _N_ _N_ _N_ _N_ },
+ enumFromTo = { _A_ 2 _U_ 12 _N_ _S_ "U(P)L" {_A_ 2 _U_ 22 _N_ _N_ _N_ _N_} _N_ _N_ },
+ enumFromThenTo = { _A_ 3 _U_ 222 _N_ _N_ _N_ _N_ } #-}
instance Enum Double
{-# GHC_PRAGMA _M_ PreludeCore {-dfun-} _A_ 0 _N_ _N_ _N_ _F_ _IF_ARGS_ 0 0 X 6 _!_ _TUP_5 [{{Ord Double}}, (Double -> [Double]), (Double -> Double -> [Double]), (Double -> Double -> [Double]), (Double -> Double -> Double -> [Double])] [_DFUN_ Ord (Double), _CONSTM_ Enum enumFrom (Double), _CONSTM_ Enum enumFromThen (Double), _CONSTM_ Enum enumFromTo (Double), _CONSTM_ Enum enumFromThenTo (Double)] _N_
- enumFrom = _A_ 1 _U_ 2 _N_ _N_ _N_ _N_,
- enumFromThen = _A_ 2 _U_ 21 _N_ _N_ _N_ _N_,
- enumFromTo = _A_ 2 _U_ 22 _N_ _N_ _N_ _N_,
- enumFromThenTo = _A_ 3 _U_ 222 _N_ _N_ _N_ _N_ #-}
+ enumFrom = { _A_ 1 _U_ 2 _N_ _N_ _N_ _N_ },
+ enumFromThen = { _A_ 2 _U_ 21 _N_ _N_ _N_ _N_ },
+ enumFromTo = { _A_ 2 _U_ 22 _N_ _N_ _N_ _N_ },
+ enumFromThenTo = { _A_ 3 _U_ 222 _N_ _N_ _N_ _N_ } #-}
instance Enum Float
{-# GHC_PRAGMA _M_ PreludeCore {-dfun-} _A_ 0 _N_ _N_ _N_ _F_ _IF_ARGS_ 0 0 X 6 _!_ _TUP_5 [{{Ord Float}}, (Float -> [Float]), (Float -> Float -> [Float]), (Float -> Float -> [Float]), (Float -> Float -> Float -> [Float])] [_DFUN_ Ord (Float), _CONSTM_ Enum enumFrom (Float), _CONSTM_ Enum enumFromThen (Float), _CONSTM_ Enum enumFromTo (Float), _CONSTM_ Enum enumFromThenTo (Float)] _N_
- enumFrom = _A_ 1 _U_ 2 _N_ _N_ _N_ _N_,
- enumFromThen = _A_ 2 _U_ 21 _N_ _N_ _N_ _N_,
- enumFromTo = _A_ 2 _U_ 22 _N_ _N_ _N_ _N_,
- enumFromThenTo = _A_ 3 _U_ 222 _N_ _N_ _N_ _N_ #-}
+ enumFrom = { _A_ 1 _U_ 2 _N_ _N_ _N_ _N_ },
+ enumFromThen = { _A_ 2 _U_ 21 _N_ _N_ _N_ _N_ },
+ enumFromTo = { _A_ 2 _U_ 22 _N_ _N_ _N_ _N_ },
+ enumFromThenTo = { _A_ 3 _U_ 222 _N_ _N_ _N_ _N_ } #-}
instance Enum Int
{-# GHC_PRAGMA _M_ PreludeCore {-dfun-} _A_ 0 _N_ _N_ _N_ _F_ _IF_ARGS_ 0 0 X 6 _!_ _TUP_5 [{{Ord Int}}, (Int -> [Int]), (Int -> Int -> [Int]), (Int -> Int -> [Int]), (Int -> Int -> Int -> [Int])] [_DFUN_ Ord (Int), _CONSTM_ Enum enumFrom (Int), _CONSTM_ Enum enumFromThen (Int), _CONSTM_ Enum enumFromTo (Int), _CONSTM_ Enum enumFromThenTo (Int)] _N_
- enumFrom = _A_ 1 _U_ 2 _N_ _N_ _F_ _ALWAYS_ \ (u0 :: Int) -> _LETREC_ {(u1 :: Int -> [Int]) = \ (u2 :: Int) -> let {(u6 :: [Int]) = let {(u5 :: Int) = case u2 of { _ALG_ I# (u3 :: Int#) -> case _#_ plusInt# [] [u3, 1#] of { _PRIM_ (u4 :: Int#) -> _!_ I# [] [u4] }; _NO_DEFLT_ }} in _APP_ u1 [ u5 ]} in _!_ (:) [Int] [u2, u6]} in _APP_ u1 [ u0 ] _N_,
- enumFromThen = _A_ 2 _U_ 21 _N_ _N_ _N_ _N_,
- enumFromTo = _A_ 2 _U_ 12 _N_ _S_ "SS" _F_ _ALWAYS_ \ (u0 :: Int) (u1 :: Int) -> case u0 of { _ALG_ I# (u2 :: Int#) -> _LETREC_ {(u3 :: Int# -> [Int]) = \ (u4 :: Int#) -> case u1 of { _ALG_ I# (u5 :: Int#) -> case _#_ leInt# [] [u4, u5] of { _ALG_ True -> let {(u7 :: [Int]) = case _#_ plusInt# [] [u4, 1#] of { _PRIM_ (u6 :: Int#) -> _APP_ u3 [ u6 ] }} in let {(u8 :: Int) = _!_ I# [] [u4]} in _!_ (:) [Int] [u8, u7]; False -> _!_ _NIL_ [Int] []; _NO_DEFLT_ }; _NO_DEFLT_ }} in _APP_ u3 [ u2 ]; _NO_DEFLT_ } _N_,
- enumFromThenTo = _A_ 3 _U_ 222 _N_ _N_ _N_ _N_ #-}
+ enumFrom = { _A_ 1 _U_ 2 _N_ _N_ _F_ _ALWAYS_ \ (u0 :: Int) -> _LETREC_ {(u1 :: Int -> [Int]) = \ (u2 :: Int) -> let {(u6 :: [Int]) = let {(u5 :: Int) = case u2 of { _ALG_ I# (u3 :: Int#) -> case _#_ plusInt# [] [u3, 1#] of { _PRIM_ (u4 :: Int#) -> _!_ I# [] [u4] }; _NO_DEFLT_ }} in _APP_ u1 [ u5 ]} in _!_ (:) [Int] [u2, u6]} in _APP_ u1 [ u0 ] _N_ },
+ enumFromThen = { _A_ 2 _U_ 21 _N_ _N_ _N_ _N_ },
+ enumFromTo = { _A_ 2 _U_ 12 _N_ _S_ "SS" _F_ _ALWAYS_ \ (u0 :: Int) (u1 :: Int) -> case u0 of { _ALG_ I# (u2 :: Int#) -> _LETREC_ {(u3 :: Int# -> [Int]) = \ (u4 :: Int#) -> case u1 of { _ALG_ I# (u5 :: Int#) -> case _#_ leInt# [] [u4, u5] of { _ALG_ True -> let {(u7 :: [Int]) = case _#_ plusInt# [] [u4, 1#] of { _PRIM_ (u6 :: Int#) -> _APP_ u3 [ u6 ] }} in let {(u8 :: Int) = _!_ I# [] [u4]} in _!_ (:) [Int] [u8, u7]; False -> _!_ _NIL_ [Int] []; _NO_DEFLT_ }; _NO_DEFLT_ }} in _APP_ u3 [ u2 ]; _NO_DEFLT_ } _N_ },
+ enumFromThenTo = { _A_ 3 _U_ 222 _N_ _N_ _N_ _N_ } #-}
instance Enum Integer
{-# GHC_PRAGMA _M_ PreludeCore {-dfun-} _A_ 0 _N_ _N_ _N_ _F_ _IF_ARGS_ 0 0 X 6 _!_ _TUP_5 [{{Ord Integer}}, (Integer -> [Integer]), (Integer -> Integer -> [Integer]), (Integer -> Integer -> [Integer]), (Integer -> Integer -> Integer -> [Integer])] [_DFUN_ Ord (Integer), _CONSTM_ Enum enumFrom (Integer), _CONSTM_ Enum enumFromThen (Integer), _CONSTM_ Enum enumFromTo (Integer), _CONSTM_ Enum enumFromThenTo (Integer)] _N_
- enumFrom = _A_ 1 _U_ 2 _N_ _N_ _N_ _N_,
- enumFromThen = _A_ 2 _U_ 21 _N_ _N_ _N_ _N_,
- enumFromTo = _A_ 2 _U_ 22 _N_ _N_ _N_ _N_,
- enumFromThenTo = _A_ 3 _U_ 222 _N_ _N_ _N_ _N_ #-}
+ enumFrom = { _A_ 1 _U_ 2 _N_ _N_ _N_ _N_ },
+ enumFromThen = { _A_ 2 _U_ 21 _N_ _N_ _N_ _N_ },
+ enumFromTo = { _A_ 2 _U_ 22 _N_ _N_ _N_ _N_ },
+ enumFromThenTo = { _A_ 3 _U_ 222 _N_ _N_ _N_ _N_ } #-}
instance Integral a => Enum (Ratio a)
{-# GHC_PRAGMA _M_ PreludeRatio {-dfun-} _A_ 2 _U_ 22 _N_ _N_ _N_ _N_ #-}
instance Enum (Ratio Integer)
{-# GHC_PRAGMA _M_ PreludeRatio {-dfun-} _A_ 0 _N_ _N_ _N_ _F_ _IF_ARGS_ 0 0 X 6 _!_ _TUP_5 [{{Ord (Ratio Integer)}}, (Ratio Integer -> [Ratio Integer]), (Ratio Integer -> Ratio Integer -> [Ratio Integer]), (Ratio Integer -> Ratio Integer -> [Ratio Integer]), (Ratio Integer -> Ratio Integer -> Ratio Integer -> [Ratio Integer])] [_DFUN_ Ord (Ratio Integer), _CONSTM_ Enum enumFrom (Ratio Integer), _CONSTM_ Enum enumFromThen (Ratio Integer), _CONSTM_ Enum enumFromTo (Ratio Integer), _CONSTM_ Enum enumFromThenTo (Ratio Integer)] _N_
- enumFrom = _A_ 1 _U_ 2 _N_ _N_ _N_ _N_,
- enumFromThen = _A_ 2 _U_ 21 _N_ _N_ _N_ _N_,
- enumFromTo = _A_ 2 _U_ 22 _N_ _N_ _N_ _N_,
- enumFromThenTo = _A_ 3 _U_ 222 _N_ _N_ _N_ _N_ #-}
+ enumFrom = { _A_ 1 _U_ 2 _N_ _N_ _N_ _N_ },
+ enumFromThen = { _A_ 2 _U_ 21 _N_ _N_ _N_ _N_ },
+ enumFromTo = { _A_ 2 _U_ 22 _N_ _N_ _N_ _N_ },
+ enumFromThenTo = { _A_ 3 _U_ 222 _N_ _N_ _N_ _N_ } #-}
instance Eq ()
{-# GHC_PRAGMA _M_ PreludeBuiltin {-dfun-} _A_ 0 _N_ _N_ _N_ _F_ _IF_ARGS_ 0 0 X 3 _!_ _TUP_2 [(() -> () -> Bool), (() -> () -> Bool)] [_CONSTM_ Eq (==) (()), _CONSTM_ Eq (/=) (())] _N_
- (==) = _A_ 2 _U_ 11 _N_ _S_ "EE" _F_ _IF_ARGS_ 0 2 CC 3 \ (u0 :: ()) (u1 :: ()) -> case u0 of { _ALG_ _TUP_0 -> case u1 of { _ALG_ _TUP_0 -> _!_ True [] []; _NO_DEFLT_ }; _NO_DEFLT_ } _N_,
- (/=) = _A_ 2 _U_ 11 _N_ _S_ "EE" _F_ _IF_ARGS_ 0 2 CC 3 \ (u0 :: ()) (u1 :: ()) -> case u0 of { _ALG_ _TUP_0 -> case u1 of { _ALG_ _TUP_0 -> _!_ False [] []; _NO_DEFLT_ }; _NO_DEFLT_ } _N_ #-}
+ (==) = { _A_ 2 _U_ 11 _N_ _S_ "EE" _F_ _IF_ARGS_ 0 2 CC 3 \ (u0 :: ()) (u1 :: ()) -> case u0 of { _ALG_ _TUP_0 -> case u1 of { _ALG_ _TUP_0 -> _!_ True [] []; _NO_DEFLT_ }; _NO_DEFLT_ } _N_ },
+ (/=) = { _A_ 2 _U_ 11 _N_ _S_ "EE" _F_ _IF_ARGS_ 0 2 CC 3 \ (u0 :: ()) (u1 :: ()) -> case u0 of { _ALG_ _TUP_0 -> case u1 of { _ALG_ _TUP_0 -> _!_ False [] []; _NO_DEFLT_ }; _NO_DEFLT_ } _N_ } #-}
instance (Eq a, Eq b) => Eq (a, b)
- {-# GHC_PRAGMA _M_ PreludeBuiltin {-dfun-} _A_ 2 _U_ 11 _N_ _N_ _N_ _N_ #-}
+ {-# GHC_PRAGMA _M_ PreludeBuiltin {-dfun-} _A_ 2 _U_ 22 _N_ _N_ _N_ _N_ #-}
instance (Eq a, Eq b, Eq c) => Eq (a, b, c)
{-# GHC_PRAGMA _M_ PreludeBuiltin {-dfun-} _A_ 3 _U_ 111 _N_ _N_ _N_ _N_ #-}
instance (Eq a, Eq b, Eq c, Eq d) => Eq (a, b, c, d)
{-# GHC_PRAGMA _M_ PreludeBuiltin {-dfun-} _A_ 5 _U_ 11111 _N_ _N_ _N_ _N_ #-}
instance Eq (Int, Int)
{-# GHC_PRAGMA _M_ PreludeBuiltin {-dfun-} _A_ 0 _N_ _N_ _N_ _F_ _IF_ARGS_ 0 0 X 3 _!_ _TUP_2 [((Int, Int) -> (Int, Int) -> Bool), ((Int, Int) -> (Int, Int) -> Bool)] [_CONSTM_ Eq (==) ((Int, Int)), _CONSTM_ Eq (/=) ((Int, Int))] _N_
- (==) = _A_ 2 _U_ 11 _N_ _S_ "U(U(P)L)U(U(P)L)" {_A_ 4 _U_ 2121 _N_ _N_ _F_ _IF_ARGS_ 0 4 XCXC 7 \ (u0 :: Int#) (u1 :: Int) (u2 :: Int#) (u3 :: Int) -> case _#_ eqInt# [] [u0, u2] of { _ALG_ True -> case u1 of { _ALG_ I# (u4 :: Int#) -> case u3 of { _ALG_ I# (u5 :: Int#) -> _#_ eqInt# [] [u4, u5]; _NO_DEFLT_ }; _NO_DEFLT_ }; False -> _!_ False [] []; _NO_DEFLT_ } _N_} _F_ _ALWAYS_ \ (u0 :: (Int, Int)) (u1 :: (Int, Int)) -> case u0 of { _ALG_ _TUP_2 (u2 :: Int) (u3 :: Int) -> case u2 of { _ALG_ I# (u4 :: Int#) -> case u1 of { _ALG_ _TUP_2 (u5 :: Int) (u6 :: Int) -> case u5 of { _ALG_ I# (u7 :: Int#) -> case _#_ eqInt# [] [u4, u7] of { _ALG_ True -> case u3 of { _ALG_ I# (u8 :: Int#) -> case u6 of { _ALG_ I# (u9 :: Int#) -> _#_ eqInt# [] [u8, u9]; _NO_DEFLT_ }; _NO_DEFLT_ }; False -> _!_ False [] []; _NO_DEFLT_ }; _NO_DEFLT_ }; _NO_DEFLT_ }; _NO_DEFLT_ }; _NO_DEFLT_ } _N_,
- (/=) = _A_ 2 _U_ 22 _N_ _N_ _N_ _N_ #-}
+ (==) = { _A_ 2 _U_ 11 _N_ _S_ "U(U(P)L)U(U(P)L)" {_A_ 4 _U_ 2121 _N_ _N_ _F_ _IF_ARGS_ 0 4 XCXC 7 \ (u0 :: Int#) (u1 :: Int) (u2 :: Int#) (u3 :: Int) -> case _#_ eqInt# [] [u0, u2] of { _ALG_ True -> case u1 of { _ALG_ I# (u4 :: Int#) -> case u3 of { _ALG_ I# (u5 :: Int#) -> _#_ eqInt# [] [u4, u5]; _NO_DEFLT_ }; _NO_DEFLT_ }; False -> _!_ False [] []; _NO_DEFLT_ } _N_} _F_ _ALWAYS_ \ (u0 :: (Int, Int)) (u1 :: (Int, Int)) -> case u0 of { _ALG_ _TUP_2 (u2 :: Int) (u3 :: Int) -> case u2 of { _ALG_ I# (u4 :: Int#) -> case u1 of { _ALG_ _TUP_2 (u5 :: Int) (u6 :: Int) -> case u5 of { _ALG_ I# (u7 :: Int#) -> case _#_ eqInt# [] [u4, u7] of { _ALG_ True -> case u3 of { _ALG_ I# (u8 :: Int#) -> case u6 of { _ALG_ I# (u9 :: Int#) -> _#_ eqInt# [] [u8, u9]; _NO_DEFLT_ }; _NO_DEFLT_ }; False -> _!_ False [] []; _NO_DEFLT_ }; _NO_DEFLT_ }; _NO_DEFLT_ }; _NO_DEFLT_ }; _NO_DEFLT_ } _N_ },
+ (/=) = { _A_ 2 _U_ 11 _N_ _S_ "U(U(P)L)U(U(P)L)" {_A_ 4 _U_ 2121 _N_ _N_ _F_ _IF_ARGS_ 0 4 XCXC 7 \ (u0 :: Int#) (u1 :: Int) (u2 :: Int#) (u3 :: Int) -> case _#_ neInt# [] [u0, u2] of { _ALG_ True -> _!_ True [] []; False -> case u1 of { _ALG_ I# (u4 :: Int#) -> case u3 of { _ALG_ I# (u5 :: Int#) -> _#_ neInt# [] [u4, u5]; _NO_DEFLT_ }; _NO_DEFLT_ }; _NO_DEFLT_ } _N_} _F_ _ALWAYS_ \ (u0 :: (Int, Int)) (u1 :: (Int, Int)) -> case u0 of { _ALG_ _TUP_2 (u2 :: Int) (u3 :: Int) -> case u2 of { _ALG_ I# (u4 :: Int#) -> case u1 of { _ALG_ _TUP_2 (u5 :: Int) (u6 :: Int) -> case u5 of { _ALG_ I# (u7 :: Int#) -> case _#_ neInt# [] [u4, u7] of { _ALG_ True -> _!_ True [] []; False -> case u3 of { _ALG_ I# (u8 :: Int#) -> case u6 of { _ALG_ I# (u9 :: Int#) -> _#_ neInt# [] [u8, u9]; _NO_DEFLT_ }; _NO_DEFLT_ }; _NO_DEFLT_ }; _NO_DEFLT_ }; _NO_DEFLT_ }; _NO_DEFLT_ }; _NO_DEFLT_ } _N_ } #-}
+instance Eq (Int, Int, Int)
+ {-# GHC_PRAGMA _M_ PreludeBuiltin {-dfun-} _A_ 0 _N_ _N_ _N_ _F_ _IF_ARGS_ 0 0 X 3 _!_ _TUP_2 [((Int, Int, Int) -> (Int, Int, Int) -> Bool), ((Int, Int, Int) -> (Int, Int, Int) -> Bool)] [_CONSTM_ Eq (==) ((Int, Int, Int)), _CONSTM_ Eq (/=) ((Int, Int, Int))] _N_
+ (==) = { _A_ 2 _U_ 11 _N_ _S_ "U(U(P)LL)U(U(P)LL)" {_A_ 4 _U_ 2111 _N_ _N_ _N_ _N_} _N_ _N_ },
+ (/=) = { _A_ 2 _U_ 11 _N_ _S_ "U(U(P)LL)U(U(P)LL)" {_A_ 4 _U_ 2111 _N_ _N_ _N_ _N_} _N_ _N_ } #-}
+instance Eq (Int, Int, Int, Int)
+ {-# GHC_PRAGMA _M_ PreludeBuiltin {-dfun-} _A_ 0 _N_ _N_ _N_ _F_ _IF_ARGS_ 0 0 X 3 _!_ _TUP_2 [((Int, Int, Int, Int) -> (Int, Int, Int, Int) -> Bool), ((Int, Int, Int, Int) -> (Int, Int, Int, Int) -> Bool)] [_CONSTM_ Eq (==) ((Int, Int, Int, Int)), _CONSTM_ Eq (/=) ((Int, Int, Int, Int))] _N_
+ (==) = { _A_ 2 _U_ 11 _N_ _S_ "U(U(P)LLL)U(U(P)LLL)" {_A_ 5 _U_ 21111 _N_ _N_ _N_ _N_} _N_ _N_ },
+ (/=) = { _A_ 2 _U_ 11 _N_ _S_ "U(U(P)LLL)U(U(P)LLL)" {_A_ 5 _U_ 21111 _N_ _N_ _N_ _N_} _N_ _N_ } #-}
+instance Eq (Int, Int, Int, Int, Int)
+ {-# GHC_PRAGMA _M_ PreludeBuiltin {-dfun-} _A_ 0 _N_ _N_ _N_ _F_ _IF_ARGS_ 0 0 X 3 _!_ _TUP_2 [((Int, Int, Int, Int, Int) -> (Int, Int, Int, Int, Int) -> Bool), ((Int, Int, Int, Int, Int) -> (Int, Int, Int, Int, Int) -> Bool)] [_CONSTM_ Eq (==) ((Int, Int, Int, Int, Int)), _CONSTM_ Eq (/=) ((Int, Int, Int, Int, Int))] _N_
+ (==) = { _A_ 2 _U_ 11 _N_ _S_ "U(U(P)LLLL)U(U(P)LLLL)" _N_ _N_ },
+ (/=) = { _A_ 2 _U_ 11 _N_ _S_ "U(U(P)LLLL)U(U(P)LLLL)" _N_ _N_ } #-}
+instance Eq ([Char], [Char])
+ {-# GHC_PRAGMA _M_ PreludeBuiltin {-dfun-} _A_ 0 _N_ _N_ _N_ _F_ _IF_ARGS_ 0 0 X 3 _!_ _TUP_2 [(([Char], [Char]) -> ([Char], [Char]) -> Bool), (([Char], [Char]) -> ([Char], [Char]) -> Bool)] [_CONSTM_ Eq (==) (([Char], [Char])), _CONSTM_ Eq (/=) (([Char], [Char]))] _N_
+ (==) = { _A_ 2 _U_ 11 _N_ _S_ "U(SL)U(SL)" {_A_ 4 _U_ 2222 _N_ _N_ _N_ _N_} _N_ _N_ },
+ (/=) = { _A_ 2 _U_ 11 _N_ _S_ "U(SL)U(SL)" {_A_ 4 _U_ 2222 _N_ _N_ _N_ _N_} _N_ _N_ } #-}
+instance Eq ([Int], [Int])
+ {-# GHC_PRAGMA _M_ PreludeBuiltin {-dfun-} _A_ 0 _N_ _N_ _N_ _F_ _IF_ARGS_ 0 0 X 3 _!_ _TUP_2 [(([Int], [Int]) -> ([Int], [Int]) -> Bool), (([Int], [Int]) -> ([Int], [Int]) -> Bool)] [_CONSTM_ Eq (==) (([Int], [Int])), _CONSTM_ Eq (/=) (([Int], [Int]))] _N_
+ (==) = { _A_ 2 _U_ 11 _N_ _S_ "U(SL)U(SL)" {_A_ 4 _U_ 2222 _N_ _N_ _N_ _N_} _N_ _N_ },
+ (/=) = { _A_ 2 _U_ 11 _N_ _S_ "U(SL)U(SL)" {_A_ 4 _U_ 2222 _N_ _N_ _N_ _N_} _N_ _N_ } #-}
instance Eq (_PackedString, _PackedString)
{-# GHC_PRAGMA _M_ PreludeBuiltin {-dfun-} _A_ 0 _N_ _N_ _N_ _F_ _IF_ARGS_ 0 0 X 3 _!_ _TUP_2 [((_PackedString, _PackedString) -> (_PackedString, _PackedString) -> Bool), ((_PackedString, _PackedString) -> (_PackedString, _PackedString) -> Bool)] [_CONSTM_ Eq (==) ((_PackedString, _PackedString)), _CONSTM_ Eq (/=) ((_PackedString, _PackedString))] _N_
- (==) = _A_ 2 _U_ 11 _N_ _S_ "U(SL)U(SL)" {_A_ 4 _U_ 2222 _N_ _N_ _N_ _N_} _N_ _N_,
- (/=) = _A_ 2 _U_ 22 _N_ _N_ _N_ _N_ #-}
+ (==) = { _A_ 2 _U_ 11 _N_ _S_ "U(SL)U(SL)" {_A_ 4 _U_ 2222 _N_ _N_ _N_ _N_} _N_ _N_ },
+ (/=) = { _A_ 2 _U_ 11 _N_ _S_ "U(SL)U(SL)" {_A_ 4 _U_ 2222 _N_ _N_ _N_ _N_} _N_ _N_ } #-}
instance (Ix a, Eq b) => Eq (Array a b)
{-# GHC_PRAGMA _M_ PreludeArray {-dfun-} _A_ 2 _U_ 21 _N_ _N_ _N_ _N_ #-}
instance (Eq a, Eq b) => Eq (Assoc a b)
{-# GHC_PRAGMA _M_ PreludeArray {-dfun-} _A_ 2 _U_ 11 _N_ _N_ _N_ _N_ #-}
instance Eq Bool
{-# GHC_PRAGMA _M_ PreludeCore {-dfun-} _A_ 0 _N_ _N_ _N_ _F_ _IF_ARGS_ 0 0 X 3 _!_ _TUP_2 [(Bool -> Bool -> Bool), (Bool -> Bool -> Bool)] [_CONSTM_ Eq (==) (Bool), _CONSTM_ Eq (/=) (Bool)] _N_
- (==) = _A_ 2 _U_ 11 _N_ _S_ "EE" _F_ _IF_ARGS_ 0 2 CC 7 \ (u0 :: Bool) (u1 :: Bool) -> case u0 of { _ALG_ True -> u1; False -> case u1 of { _ALG_ True -> _!_ False [] []; False -> _!_ True [] []; _NO_DEFLT_ }; _NO_DEFLT_ } _N_,
- (/=) = _A_ 2 _U_ 11 _N_ _S_ "EE" _F_ _IF_ARGS_ 0 2 CC 7 \ (u0 :: Bool) (u1 :: Bool) -> case u0 of { _ALG_ True -> case u1 of { _ALG_ True -> _!_ False [] []; False -> _!_ True [] []; _NO_DEFLT_ }; False -> u1; _NO_DEFLT_ } _N_ #-}
+ (==) = { _A_ 2 _U_ 11 _N_ _S_ "EE" _F_ _IF_ARGS_ 0 2 CC 7 \ (u0 :: Bool) (u1 :: Bool) -> case u0 of { _ALG_ True -> u1; False -> case u1 of { _ALG_ True -> _!_ False [] []; False -> _!_ True [] []; _NO_DEFLT_ }; _NO_DEFLT_ } _N_ },
+ (/=) = { _A_ 2 _U_ 11 _N_ _S_ "EE" _F_ _IF_ARGS_ 0 2 CC 7 \ (u0 :: Bool) (u1 :: Bool) -> case u0 of { _ALG_ True -> case u1 of { _ALG_ True -> _!_ False [] []; False -> _!_ True [] []; _NO_DEFLT_ }; False -> u1; _NO_DEFLT_ } _N_ } #-}
instance Eq Char
{-# GHC_PRAGMA _M_ PreludeCore {-dfun-} _A_ 0 _N_ _N_ _N_ _F_ _IF_ARGS_ 0 0 X 3 _!_ _TUP_2 [(Char -> Char -> Bool), (Char -> Char -> Bool)] [_CONSTM_ Eq (==) (Char), _CONSTM_ Eq (/=) (Char)] _N_
- (==) = _A_ 2 _U_ 11 _N_ _S_ "U(P)U(P)" {_A_ 2 _U_ 22 _N_ _N_ _F_ _IF_ARGS_ 0 2 XX 1 \ (u0 :: Char#) (u1 :: Char#) -> _#_ eqChar# [] [u0, u1] _N_} _F_ _IF_ARGS_ 0 2 CC 3 \ (u0 :: Char) (u1 :: Char) -> case u0 of { _ALG_ C# (u2 :: Char#) -> case u1 of { _ALG_ C# (u3 :: Char#) -> _#_ eqChar# [] [u2, u3]; _NO_DEFLT_ }; _NO_DEFLT_ } _N_,
- (/=) = _A_ 2 _U_ 11 _N_ _S_ "U(P)U(P)" {_A_ 2 _U_ 22 _N_ _N_ _F_ _IF_ARGS_ 0 2 XX 1 \ (u0 :: Char#) (u1 :: Char#) -> _#_ neChar# [] [u0, u1] _N_} _F_ _IF_ARGS_ 0 2 CC 3 \ (u0 :: Char) (u1 :: Char) -> case u0 of { _ALG_ C# (u2 :: Char#) -> case u1 of { _ALG_ C# (u3 :: Char#) -> _#_ neChar# [] [u2, u3]; _NO_DEFLT_ }; _NO_DEFLT_ } _N_ #-}
+ (==) = { _A_ 2 _U_ 11 _N_ _S_ "U(P)U(P)" {_A_ 2 _U_ 22 _N_ _N_ _F_ _IF_ARGS_ 0 2 XX 1 \ (u0 :: Char#) (u1 :: Char#) -> _#_ eqChar# [] [u0, u1] _N_} _F_ _IF_ARGS_ 0 2 CC 3 \ (u0 :: Char) (u1 :: Char) -> case u0 of { _ALG_ C# (u2 :: Char#) -> case u1 of { _ALG_ C# (u3 :: Char#) -> _#_ eqChar# [] [u2, u3]; _NO_DEFLT_ }; _NO_DEFLT_ } _N_ },
+ (/=) = { _A_ 2 _U_ 11 _N_ _S_ "U(P)U(P)" {_A_ 2 _U_ 22 _N_ _N_ _F_ _IF_ARGS_ 0 2 XX 1 \ (u0 :: Char#) (u1 :: Char#) -> _#_ neChar# [] [u0, u1] _N_} _F_ _IF_ARGS_ 0 2 CC 3 \ (u0 :: Char) (u1 :: Char) -> case u0 of { _ALG_ C# (u2 :: Char#) -> case u1 of { _ALG_ C# (u3 :: Char#) -> _#_ neChar# [] [u2, u3]; _NO_DEFLT_ }; _NO_DEFLT_ } _N_ } #-}
instance Eq a => Eq (Complex a)
{-# GHC_PRAGMA _M_ PreludeComplex {-dfun-} _A_ 1 _U_ 2 _N_ _N_ _N_ _N_ #-}
instance Eq (Complex Double)
{-# GHC_PRAGMA _M_ PreludeComplex {-dfun-} _A_ 0 _N_ _N_ _N_ _F_ _IF_ARGS_ 0 0 X 3 _!_ _TUP_2 [(Complex Double -> Complex Double -> Bool), (Complex Double -> Complex Double -> Bool)] [_CONSTM_ Eq (==) (Complex Double), _CONSTM_ Eq (/=) (Complex Double)] _N_
- (==) = _A_ 2 _U_ 11 _N_ _S_ "U(U(P)L)U(U(P)L)" {_A_ 4 _U_ 2121 _N_ _N_ _F_ _IF_ARGS_ 0 4 XCXC 7 \ (u0 :: Double#) (u1 :: Double) (u2 :: Double#) (u3 :: Double) -> case _#_ eqDouble# [] [u0, u2] of { _ALG_ True -> case u1 of { _ALG_ D# (u4 :: Double#) -> case u3 of { _ALG_ D# (u5 :: Double#) -> _#_ eqDouble# [] [u4, u5]; _NO_DEFLT_ }; _NO_DEFLT_ }; False -> _!_ False [] []; _NO_DEFLT_ } _N_} _F_ _ALWAYS_ \ (u0 :: Complex Double) (u1 :: Complex Double) -> case u0 of { _ALG_ (:+) (u2 :: Double) (u3 :: Double) -> case u2 of { _ALG_ D# (u4 :: Double#) -> case u1 of { _ALG_ (:+) (u5 :: Double) (u6 :: Double) -> case u5 of { _ALG_ D# (u7 :: Double#) -> case _#_ eqDouble# [] [u4, u7] of { _ALG_ True -> case u3 of { _ALG_ D# (u8 :: Double#) -> case u6 of { _ALG_ D# (u9 :: Double#) -> _#_ eqDouble# [] [u8, u9]; _NO_DEFLT_ }; _NO_DEFLT_ }; False -> _!_ False [] []; _NO_DEFLT_ }; _NO_DEFLT_ }; _NO_DEFLT_ }; _NO_DEFLT_ }; _NO_DEFLT_ } _N_,
- (/=) = _A_ 2 _U_ 11 _N_ _S_ "U(U(P)L)U(U(P)L)" {_A_ 4 _U_ 2121 _N_ _N_ _F_ _IF_ARGS_ 0 4 XCXC 7 \ (u0 :: Double#) (u1 :: Double) (u2 :: Double#) (u3 :: Double) -> case _#_ neDouble# [] [u0, u2] of { _ALG_ True -> _!_ True [] []; False -> case u1 of { _ALG_ D# (u4 :: Double#) -> case u3 of { _ALG_ D# (u5 :: Double#) -> _#_ neDouble# [] [u4, u5]; _NO_DEFLT_ }; _NO_DEFLT_ }; _NO_DEFLT_ } _N_} _F_ _ALWAYS_ \ (u0 :: Complex Double) (u1 :: Complex Double) -> case u0 of { _ALG_ (:+) (u2 :: Double) (u3 :: Double) -> case u2 of { _ALG_ D# (u4 :: Double#) -> case u1 of { _ALG_ (:+) (u5 :: Double) (u6 :: Double) -> case u5 of { _ALG_ D# (u7 :: Double#) -> case _#_ neDouble# [] [u4, u7] of { _ALG_ True -> _!_ True [] []; False -> case u3 of { _ALG_ D# (u8 :: Double#) -> case u6 of { _ALG_ D# (u9 :: Double#) -> _#_ neDouble# [] [u8, u9]; _NO_DEFLT_ }; _NO_DEFLT_ }; _NO_DEFLT_ }; _NO_DEFLT_ }; _NO_DEFLT_ }; _NO_DEFLT_ }; _NO_DEFLT_ } _N_ #-}
+ (==) = { _A_ 2 _U_ 11 _N_ _S_ "U(U(P)L)U(U(P)L)" {_A_ 4 _U_ 2121 _N_ _N_ _F_ _IF_ARGS_ 0 4 XCXC 7 \ (u0 :: Double#) (u1 :: Double) (u2 :: Double#) (u3 :: Double) -> case _#_ eqDouble# [] [u0, u2] of { _ALG_ True -> case u1 of { _ALG_ D# (u4 :: Double#) -> case u3 of { _ALG_ D# (u5 :: Double#) -> _#_ eqDouble# [] [u4, u5]; _NO_DEFLT_ }; _NO_DEFLT_ }; False -> _!_ False [] []; _NO_DEFLT_ } _N_} _F_ _ALWAYS_ \ (u0 :: Complex Double) (u1 :: Complex Double) -> case u0 of { _ALG_ (:+) (u2 :: Double) (u3 :: Double) -> case u2 of { _ALG_ D# (u4 :: Double#) -> case u1 of { _ALG_ (:+) (u5 :: Double) (u6 :: Double) -> case u5 of { _ALG_ D# (u7 :: Double#) -> case _#_ eqDouble# [] [u4, u7] of { _ALG_ True -> case u3 of { _ALG_ D# (u8 :: Double#) -> case u6 of { _ALG_ D# (u9 :: Double#) -> _#_ eqDouble# [] [u8, u9]; _NO_DEFLT_ }; _NO_DEFLT_ }; False -> _!_ False [] []; _NO_DEFLT_ }; _NO_DEFLT_ }; _NO_DEFLT_ }; _NO_DEFLT_ }; _NO_DEFLT_ } _N_ },
+ (/=) = { _A_ 2 _U_ 11 _N_ _S_ "U(U(P)L)U(U(P)L)" {_A_ 4 _U_ 2121 _N_ _N_ _F_ _IF_ARGS_ 0 4 XCXC 7 \ (u0 :: Double#) (u1 :: Double) (u2 :: Double#) (u3 :: Double) -> case _#_ neDouble# [] [u0, u2] of { _ALG_ True -> _!_ True [] []; False -> case u1 of { _ALG_ D# (u4 :: Double#) -> case u3 of { _ALG_ D# (u5 :: Double#) -> _#_ neDouble# [] [u4, u5]; _NO_DEFLT_ }; _NO_DEFLT_ }; _NO_DEFLT_ } _N_} _F_ _ALWAYS_ \ (u0 :: Complex Double) (u1 :: Complex Double) -> case u0 of { _ALG_ (:+) (u2 :: Double) (u3 :: Double) -> case u2 of { _ALG_ D# (u4 :: Double#) -> case u1 of { _ALG_ (:+) (u5 :: Double) (u6 :: Double) -> case u5 of { _ALG_ D# (u7 :: Double#) -> case _#_ neDouble# [] [u4, u7] of { _ALG_ True -> _!_ True [] []; False -> case u3 of { _ALG_ D# (u8 :: Double#) -> case u6 of { _ALG_ D# (u9 :: Double#) -> _#_ neDouble# [] [u8, u9]; _NO_DEFLT_ }; _NO_DEFLT_ }; _NO_DEFLT_ }; _NO_DEFLT_ }; _NO_DEFLT_ }; _NO_DEFLT_ }; _NO_DEFLT_ } _N_ } #-}
instance Eq Double
{-# GHC_PRAGMA _M_ PreludeCore {-dfun-} _A_ 0 _N_ _N_ _N_ _F_ _IF_ARGS_ 0 0 X 3 _!_ _TUP_2 [(Double -> Double -> Bool), (Double -> Double -> Bool)] [_CONSTM_ Eq (==) (Double), _CONSTM_ Eq (/=) (Double)] _N_
- (==) = _A_ 2 _U_ 11 _N_ _S_ "U(P)U(P)" {_A_ 2 _U_ 22 _N_ _N_ _F_ _IF_ARGS_ 0 2 XX 1 \ (u0 :: Double#) (u1 :: Double#) -> _#_ eqDouble# [] [u0, u1] _N_} _F_ _IF_ARGS_ 0 2 CC 3 \ (u0 :: Double) (u1 :: Double) -> case u0 of { _ALG_ D# (u2 :: Double#) -> case u1 of { _ALG_ D# (u3 :: Double#) -> _#_ eqDouble# [] [u2, u3]; _NO_DEFLT_ }; _NO_DEFLT_ } _N_,
- (/=) = _A_ 2 _U_ 11 _N_ _S_ "U(P)U(P)" {_A_ 2 _U_ 22 _N_ _N_ _F_ _IF_ARGS_ 0 2 XX 1 \ (u0 :: Double#) (u1 :: Double#) -> _#_ neDouble# [] [u0, u1] _N_} _F_ _IF_ARGS_ 0 2 CC 3 \ (u0 :: Double) (u1 :: Double) -> case u0 of { _ALG_ D# (u2 :: Double#) -> case u1 of { _ALG_ D# (u3 :: Double#) -> _#_ neDouble# [] [u2, u3]; _NO_DEFLT_ }; _NO_DEFLT_ } _N_ #-}
+ (==) = { _A_ 2 _U_ 11 _N_ _S_ "U(P)U(P)" {_A_ 2 _U_ 22 _N_ _N_ _F_ _IF_ARGS_ 0 2 XX 1 \ (u0 :: Double#) (u1 :: Double#) -> _#_ eqDouble# [] [u0, u1] _N_} _F_ _IF_ARGS_ 0 2 CC 3 \ (u0 :: Double) (u1 :: Double) -> case u0 of { _ALG_ D# (u2 :: Double#) -> case u1 of { _ALG_ D# (u3 :: Double#) -> _#_ eqDouble# [] [u2, u3]; _NO_DEFLT_ }; _NO_DEFLT_ } _N_ },
+ (/=) = { _A_ 2 _U_ 11 _N_ _S_ "U(P)U(P)" {_A_ 2 _U_ 22 _N_ _N_ _F_ _IF_ARGS_ 0 2 XX 1 \ (u0 :: Double#) (u1 :: Double#) -> _#_ neDouble# [] [u0, u1] _N_} _F_ _IF_ARGS_ 0 2 CC 3 \ (u0 :: Double) (u1 :: Double) -> case u0 of { _ALG_ D# (u2 :: Double#) -> case u1 of { _ALG_ D# (u3 :: Double#) -> _#_ neDouble# [] [u2, u3]; _NO_DEFLT_ }; _NO_DEFLT_ } _N_ } #-}
instance Eq Float
{-# GHC_PRAGMA _M_ PreludeCore {-dfun-} _A_ 0 _N_ _N_ _N_ _F_ _IF_ARGS_ 0 0 X 3 _!_ _TUP_2 [(Float -> Float -> Bool), (Float -> Float -> Bool)] [_CONSTM_ Eq (==) (Float), _CONSTM_ Eq (/=) (Float)] _N_
- (==) = _A_ 2 _U_ 11 _N_ _S_ "U(P)U(P)" {_A_ 2 _U_ 22 _N_ _N_ _F_ _IF_ARGS_ 0 2 XX 1 \ (u0 :: Float#) (u1 :: Float#) -> _#_ eqFloat# [] [u0, u1] _N_} _F_ _IF_ARGS_ 0 2 CC 3 \ (u0 :: Float) (u1 :: Float) -> case u0 of { _ALG_ F# (u2 :: Float#) -> case u1 of { _ALG_ F# (u3 :: Float#) -> _#_ eqFloat# [] [u2, u3]; _NO_DEFLT_ }; _NO_DEFLT_ } _N_,
- (/=) = _A_ 2 _U_ 11 _N_ _S_ "U(P)U(P)" {_A_ 2 _U_ 22 _N_ _N_ _F_ _IF_ARGS_ 0 2 XX 1 \ (u0 :: Float#) (u1 :: Float#) -> _#_ neFloat# [] [u0, u1] _N_} _F_ _IF_ARGS_ 0 2 CC 3 \ (u0 :: Float) (u1 :: Float) -> case u0 of { _ALG_ F# (u2 :: Float#) -> case u1 of { _ALG_ F# (u3 :: Float#) -> _#_ neFloat# [] [u2, u3]; _NO_DEFLT_ }; _NO_DEFLT_ } _N_ #-}
+ (==) = { _A_ 2 _U_ 11 _N_ _S_ "U(P)U(P)" {_A_ 2 _U_ 22 _N_ _N_ _F_ _IF_ARGS_ 0 2 XX 1 \ (u0 :: Float#) (u1 :: Float#) -> _#_ eqFloat# [] [u0, u1] _N_} _F_ _IF_ARGS_ 0 2 CC 3 \ (u0 :: Float) (u1 :: Float) -> case u0 of { _ALG_ F# (u2 :: Float#) -> case u1 of { _ALG_ F# (u3 :: Float#) -> _#_ eqFloat# [] [u2, u3]; _NO_DEFLT_ }; _NO_DEFLT_ } _N_ },
+ (/=) = { _A_ 2 _U_ 11 _N_ _S_ "U(P)U(P)" {_A_ 2 _U_ 22 _N_ _N_ _F_ _IF_ARGS_ 0 2 XX 1 \ (u0 :: Float#) (u1 :: Float#) -> _#_ neFloat# [] [u0, u1] _N_} _F_ _IF_ARGS_ 0 2 CC 3 \ (u0 :: Float) (u1 :: Float) -> case u0 of { _ALG_ F# (u2 :: Float#) -> case u1 of { _ALG_ F# (u3 :: Float#) -> _#_ neFloat# [] [u2, u3]; _NO_DEFLT_ }; _NO_DEFLT_ } _N_ } #-}
instance Eq Int
{-# GHC_PRAGMA _M_ PreludeCore {-dfun-} _A_ 0 _N_ _N_ _N_ _F_ _IF_ARGS_ 0 0 X 3 _!_ _TUP_2 [(Int -> Int -> Bool), (Int -> Int -> Bool)] [_CONSTM_ Eq (==) (Int), _CONSTM_ Eq (/=) (Int)] _N_
- (==) = _A_ 2 _U_ 11 _N_ _S_ "U(P)U(P)" {_A_ 2 _U_ 22 _N_ _N_ _F_ _IF_ARGS_ 0 2 XX 1 \ (u0 :: Int#) (u1 :: Int#) -> _#_ eqInt# [] [u0, u1] _N_} _F_ _IF_ARGS_ 0 2 CC 3 \ (u0 :: Int) (u1 :: Int) -> case u0 of { _ALG_ I# (u2 :: Int#) -> case u1 of { _ALG_ I# (u3 :: Int#) -> _#_ eqInt# [] [u2, u3]; _NO_DEFLT_ }; _NO_DEFLT_ } _N_,
- (/=) = _A_ 2 _U_ 11 _N_ _S_ "U(P)U(P)" {_A_ 2 _U_ 22 _N_ _N_ _F_ _IF_ARGS_ 0 2 XX 1 \ (u0 :: Int#) (u1 :: Int#) -> _#_ neInt# [] [u0, u1] _N_} _F_ _IF_ARGS_ 0 2 CC 3 \ (u0 :: Int) (u1 :: Int) -> case u0 of { _ALG_ I# (u2 :: Int#) -> case u1 of { _ALG_ I# (u3 :: Int#) -> _#_ neInt# [] [u2, u3]; _NO_DEFLT_ }; _NO_DEFLT_ } _N_ #-}
+ (==) = { _A_ 2 _U_ 11 _N_ _S_ "U(P)U(P)" {_A_ 2 _U_ 22 _N_ _N_ _F_ _IF_ARGS_ 0 2 XX 1 \ (u0 :: Int#) (u1 :: Int#) -> _#_ eqInt# [] [u0, u1] _N_} _F_ _IF_ARGS_ 0 2 CC 3 \ (u0 :: Int) (u1 :: Int) -> case u0 of { _ALG_ I# (u2 :: Int#) -> case u1 of { _ALG_ I# (u3 :: Int#) -> _#_ eqInt# [] [u2, u3]; _NO_DEFLT_ }; _NO_DEFLT_ } _N_ },
+ (/=) = { _A_ 2 _U_ 11 _N_ _S_ "U(P)U(P)" {_A_ 2 _U_ 22 _N_ _N_ _F_ _IF_ARGS_ 0 2 XX 1 \ (u0 :: Int#) (u1 :: Int#) -> _#_ neInt# [] [u0, u1] _N_} _F_ _IF_ARGS_ 0 2 CC 3 \ (u0 :: Int) (u1 :: Int) -> case u0 of { _ALG_ I# (u2 :: Int#) -> case u1 of { _ALG_ I# (u3 :: Int#) -> _#_ neInt# [] [u2, u3]; _NO_DEFLT_ }; _NO_DEFLT_ } _N_ } #-}
instance Eq Integer
{-# GHC_PRAGMA _M_ PreludeCore {-dfun-} _A_ 0 _N_ _N_ _N_ _F_ _IF_ARGS_ 0 0 X 3 _!_ _TUP_2 [(Integer -> Integer -> Bool), (Integer -> Integer -> Bool)] [_CONSTM_ Eq (==) (Integer), _CONSTM_ Eq (/=) (Integer)] _N_
- (==) = _A_ 2 _U_ 11 _N_ _S_ "U(PPP)U(PPP)" {_A_ 4 _U_ 2221 _N_ _N_ _F_ _IF_ARGS_ 0 4 XXXC 4 \ (u0 :: Int#) (u1 :: Int#) (u2 :: ByteArray#) (u3 :: Integer) -> case u3 of { _ALG_ J# (u4 :: Int#) (u5 :: Int#) (u6 :: ByteArray#) -> case _#_ cmpInteger# [] [u0, u1, u2, u4, u5, u6] of { _PRIM_ 0# -> _!_ True [] []; (u7 :: Int#) -> _!_ False [] [] }; _NO_DEFLT_ } _N_} _F_ _IF_ARGS_ 0 2 CC 5 \ (u0 :: Integer) (u1 :: Integer) -> case u0 of { _ALG_ J# (u2 :: Int#) (u3 :: Int#) (u4 :: ByteArray#) -> case u1 of { _ALG_ J# (u5 :: Int#) (u6 :: Int#) (u7 :: ByteArray#) -> case _#_ cmpInteger# [] [u2, u3, u4, u5, u6, u7] of { _PRIM_ 0# -> _!_ True [] []; (u8 :: Int#) -> _!_ False [] [] }; _NO_DEFLT_ }; _NO_DEFLT_ } _N_,
- (/=) = _A_ 2 _U_ 11 _N_ _S_ "U(PPP)U(PPP)" {_A_ 4 _U_ 2221 _N_ _N_ _F_ _IF_ARGS_ 0 4 XXXC 4 \ (u0 :: Int#) (u1 :: Int#) (u2 :: ByteArray#) (u3 :: Integer) -> case u3 of { _ALG_ J# (u4 :: Int#) (u5 :: Int#) (u6 :: ByteArray#) -> case _#_ cmpInteger# [] [u0, u1, u2, u4, u5, u6] of { _PRIM_ 0# -> _!_ False [] []; (u7 :: Int#) -> _!_ True [] [] }; _NO_DEFLT_ } _N_} _F_ _IF_ARGS_ 0 2 CC 5 \ (u0 :: Integer) (u1 :: Integer) -> case u0 of { _ALG_ J# (u2 :: Int#) (u3 :: Int#) (u4 :: ByteArray#) -> case u1 of { _ALG_ J# (u5 :: Int#) (u6 :: Int#) (u7 :: ByteArray#) -> case _#_ cmpInteger# [] [u2, u3, u4, u5, u6, u7] of { _PRIM_ 0# -> _!_ False [] []; (u8 :: Int#) -> _!_ True [] [] }; _NO_DEFLT_ }; _NO_DEFLT_ } _N_ #-}
+ (==) = { _A_ 2 _U_ 11 _N_ _S_ "U(PPP)U(PPP)" {_A_ 4 _U_ 2221 _N_ _N_ _F_ _IF_ARGS_ 0 4 XXXC 4 \ (u0 :: Int#) (u1 :: Int#) (u2 :: ByteArray#) (u3 :: Integer) -> case u3 of { _ALG_ J# (u4 :: Int#) (u5 :: Int#) (u6 :: ByteArray#) -> case _#_ cmpInteger# [] [u0, u1, u2, u4, u5, u6] of { _PRIM_ 0# -> _!_ True [] []; (u7 :: Int#) -> _!_ False [] [] }; _NO_DEFLT_ } _N_} _F_ _IF_ARGS_ 0 2 CC 5 \ (u0 :: Integer) (u1 :: Integer) -> case u0 of { _ALG_ J# (u2 :: Int#) (u3 :: Int#) (u4 :: ByteArray#) -> case u1 of { _ALG_ J# (u5 :: Int#) (u6 :: Int#) (u7 :: ByteArray#) -> case _#_ cmpInteger# [] [u2, u3, u4, u5, u6, u7] of { _PRIM_ 0# -> _!_ True [] []; (u8 :: Int#) -> _!_ False [] [] }; _NO_DEFLT_ }; _NO_DEFLT_ } _N_ },
+ (/=) = { _A_ 2 _U_ 11 _N_ _S_ "U(PPP)U(PPP)" {_A_ 4 _U_ 2221 _N_ _N_ _F_ _IF_ARGS_ 0 4 XXXC 4 \ (u0 :: Int#) (u1 :: Int#) (u2 :: ByteArray#) (u3 :: Integer) -> case u3 of { _ALG_ J# (u4 :: Int#) (u5 :: Int#) (u6 :: ByteArray#) -> case _#_ cmpInteger# [] [u0, u1, u2, u4, u5, u6] of { _PRIM_ 0# -> _!_ False [] []; (u7 :: Int#) -> _!_ True [] [] }; _NO_DEFLT_ } _N_} _F_ _IF_ARGS_ 0 2 CC 5 \ (u0 :: Integer) (u1 :: Integer) -> case u0 of { _ALG_ J# (u2 :: Int#) (u3 :: Int#) (u4 :: ByteArray#) -> case u1 of { _ALG_ J# (u5 :: Int#) (u6 :: Int#) (u7 :: ByteArray#) -> case _#_ cmpInteger# [] [u2, u3, u4, u5, u6, u7] of { _PRIM_ 0# -> _!_ False [] []; (u8 :: Int#) -> _!_ True [] [] }; _NO_DEFLT_ }; _NO_DEFLT_ } _N_ } #-}
instance Integral a => Eq (Ratio a)
{-# GHC_PRAGMA _M_ PreludeRatio {-dfun-} _A_ 1 _U_ 1 _N_ _N_ _N_ _N_ #-}
instance Eq (Ratio Integer)
{-# GHC_PRAGMA _M_ PreludeRatio {-dfun-} _A_ 0 _N_ _N_ _N_ _F_ _IF_ARGS_ 0 0 X 3 _!_ _TUP_2 [(Ratio Integer -> Ratio Integer -> Bool), (Ratio Integer -> Ratio Integer -> Bool)] [_CONSTM_ Eq (==) (Ratio Integer), _CONSTM_ Eq (/=) (Ratio Integer)] _N_
- (==) = _A_ 2 _U_ 11 _N_ _S_ "U(U(PPP)L)U(U(PPP)L)" {_A_ 5 _U_ 22211 _N_ _N_ _F_ _IF_ARGS_ 0 5 XXXCC 9 \ (u0 :: Int#) (u1 :: Int#) (u2 :: ByteArray#) (u3 :: Integer) (u4 :: Ratio Integer) -> case u4 of { _ALG_ (:%) (u5 :: Integer) (u6 :: Integer) -> case u5 of { _ALG_ J# (u7 :: Int#) (u8 :: Int#) (u9 :: ByteArray#) -> case _#_ cmpInteger# [] [u0, u1, u2, u7, u8, u9] of { _PRIM_ 0# -> case u3 of { _ALG_ J# (ua :: Int#) (ub :: Int#) (uc :: ByteArray#) -> case u6 of { _ALG_ J# (ud :: Int#) (ue :: Int#) (uf :: ByteArray#) -> case _#_ cmpInteger# [] [ua, ub, uc, ud, ue, uf] of { _PRIM_ 0# -> _!_ True [] []; (ug :: Int#) -> _!_ False [] [] }; _NO_DEFLT_ }; _NO_DEFLT_ }; (uh :: Int#) -> _!_ False [] [] }; _NO_DEFLT_ }; _NO_DEFLT_ } _N_} _N_ _N_,
- (/=) = _A_ 2 _U_ 11 _N_ _S_ "U(U(PPP)L)U(U(PPP)L)" {_A_ 5 _U_ 22211 _N_ _N_ _F_ _IF_ARGS_ 0 5 XXXCC 9 \ (u0 :: Int#) (u1 :: Int#) (u2 :: ByteArray#) (u3 :: Integer) (u4 :: Ratio Integer) -> case u4 of { _ALG_ (:%) (u5 :: Integer) (u6 :: Integer) -> case u5 of { _ALG_ J# (u7 :: Int#) (u8 :: Int#) (u9 :: ByteArray#) -> case _#_ cmpInteger# [] [u0, u1, u2, u7, u8, u9] of { _PRIM_ 0# -> case u3 of { _ALG_ J# (ua :: Int#) (ub :: Int#) (uc :: ByteArray#) -> case u6 of { _ALG_ J# (ud :: Int#) (ue :: Int#) (uf :: ByteArray#) -> case _#_ cmpInteger# [] [ua, ub, uc, ud, ue, uf] of { _PRIM_ 0# -> _!_ False [] []; (ug :: Int#) -> _!_ True [] [] }; _NO_DEFLT_ }; _NO_DEFLT_ }; (uh :: Int#) -> _!_ True [] [] }; _NO_DEFLT_ }; _NO_DEFLT_ } _N_} _N_ _N_ #-}
+ (==) = { _A_ 2 _U_ 11 _N_ _S_ "U(U(PPP)L)U(U(PPP)L)" {_A_ 5 _U_ 22211 _N_ _N_ _F_ _IF_ARGS_ 0 5 XXXCC 9 \ (u0 :: Int#) (u1 :: Int#) (u2 :: ByteArray#) (u3 :: Integer) (u4 :: Ratio Integer) -> case u4 of { _ALG_ (:%) (u5 :: Integer) (u6 :: Integer) -> case u5 of { _ALG_ J# (u7 :: Int#) (u8 :: Int#) (u9 :: ByteArray#) -> case _#_ cmpInteger# [] [u0, u1, u2, u7, u8, u9] of { _PRIM_ 0# -> case u3 of { _ALG_ J# (ua :: Int#) (ub :: Int#) (uc :: ByteArray#) -> case u6 of { _ALG_ J# (ud :: Int#) (ue :: Int#) (uf :: ByteArray#) -> case _#_ cmpInteger# [] [ua, ub, uc, ud, ue, uf] of { _PRIM_ 0# -> _!_ True [] []; (ug :: Int#) -> _!_ False [] [] }; _NO_DEFLT_ }; _NO_DEFLT_ }; (uh :: Int#) -> _!_ False [] [] }; _NO_DEFLT_ }; _NO_DEFLT_ } _N_} _N_ _N_ },
+ (/=) = { _A_ 2 _U_ 11 _N_ _S_ "U(U(PPP)L)U(U(PPP)L)" {_A_ 5 _U_ 22211 _N_ _N_ _F_ _IF_ARGS_ 0 5 XXXCC 9 \ (u0 :: Int#) (u1 :: Int#) (u2 :: ByteArray#) (u3 :: Integer) (u4 :: Ratio Integer) -> case u4 of { _ALG_ (:%) (u5 :: Integer) (u6 :: Integer) -> case u5 of { _ALG_ J# (u7 :: Int#) (u8 :: Int#) (u9 :: ByteArray#) -> case _#_ cmpInteger# [] [u0, u1, u2, u7, u8, u9] of { _PRIM_ 0# -> case u3 of { _ALG_ J# (ua :: Int#) (ub :: Int#) (uc :: ByteArray#) -> case u6 of { _ALG_ J# (ud :: Int#) (ue :: Int#) (uf :: ByteArray#) -> case _#_ cmpInteger# [] [ua, ub, uc, ud, ue, uf] of { _PRIM_ 0# -> _!_ False [] []; (ug :: Int#) -> _!_ True [] [] }; _NO_DEFLT_ }; _NO_DEFLT_ }; (uh :: Int#) -> _!_ True [] [] }; _NO_DEFLT_ }; _NO_DEFLT_ } _N_} _N_ _N_ } #-}
+instance Eq [(Int, Int)]
+ {-# GHC_PRAGMA _M_ PreludeBuiltin {-dfun-} _A_ 0 _N_ _N_ _N_ _F_ _IF_ARGS_ 0 0 X 3 _!_ _TUP_2 [([(Int, Int)] -> [(Int, Int)] -> Bool), ([(Int, Int)] -> [(Int, Int)] -> Bool)] [_CONSTM_ Eq (==) ([(Int, Int)]), _CONSTM_ Eq (/=) ([(Int, Int)])] _N_
+ (==) = { _A_ 2 _U_ 11 _N_ _S_ "SS" _N_ _N_ },
+ (/=) = { _A_ 2 _U_ 11 _N_ _S_ "SS" _N_ _N_ } #-}
instance Eq a => Eq [a]
{-# GHC_PRAGMA _M_ PreludeBuiltin {-dfun-} _A_ 1 _U_ 1 _N_ _N_ _N_ _N_ #-}
+instance Eq [Bool]
+ {-# GHC_PRAGMA _M_ PreludeBuiltin {-dfun-} _A_ 0 _N_ _N_ _N_ _F_ _IF_ARGS_ 0 0 X 3 _!_ _TUP_2 [([Bool] -> [Bool] -> Bool), ([Bool] -> [Bool] -> Bool)] [_CONSTM_ Eq (==) ([Bool]), _CONSTM_ Eq (/=) ([Bool])] _N_
+ (==) = { _A_ 2 _U_ 11 _N_ _S_ "SS" _N_ _N_ },
+ (/=) = { _A_ 2 _U_ 11 _N_ _S_ "SS" _N_ _N_ } #-}
instance Eq [Char]
{-# GHC_PRAGMA _M_ PreludeBuiltin {-dfun-} _A_ 0 _N_ _N_ _N_ _F_ _IF_ARGS_ 0 0 X 3 _!_ _TUP_2 [([Char] -> [Char] -> Bool), ([Char] -> [Char] -> Bool)] [_CONSTM_ Eq (==) ([Char]), _CONSTM_ Eq (/=) ([Char])] _N_
- (==) = _A_ 2 _U_ 11 _N_ _S_ "SS" _N_ _N_,
- (/=) = _A_ 2 _U_ 11 _N_ _S_ "SS" _N_ _N_ #-}
+ (==) = { _A_ 2 _U_ 11 _N_ _S_ "SS" _N_ _N_ },
+ (/=) = { _A_ 2 _U_ 11 _N_ _S_ "SS" _N_ _N_ } #-}
+instance Eq [Complex Double]
+ {-# GHC_PRAGMA _M_ PreludeBuiltin {-dfun-} _A_ 0 _N_ _N_ _N_ _F_ _IF_ARGS_ 0 0 X 3 _!_ _TUP_2 [([Complex Double] -> [Complex Double] -> Bool), ([Complex Double] -> [Complex Double] -> Bool)] [_CONSTM_ Eq (==) ([Complex Double]), _CONSTM_ Eq (/=) ([Complex Double])] _N_
+ (==) = { _A_ 2 _U_ 11 _N_ _S_ "SS" _N_ _N_ },
+ (/=) = { _A_ 2 _U_ 11 _N_ _S_ "SS" _N_ _N_ } #-}
+instance Eq [Double]
+ {-# GHC_PRAGMA _M_ PreludeBuiltin {-dfun-} _A_ 0 _N_ _N_ _N_ _F_ _IF_ARGS_ 0 0 X 3 _!_ _TUP_2 [([Double] -> [Double] -> Bool), ([Double] -> [Double] -> Bool)] [_CONSTM_ Eq (==) ([Double]), _CONSTM_ Eq (/=) ([Double])] _N_
+ (==) = { _A_ 2 _U_ 11 _N_ _S_ "SS" _N_ _N_ },
+ (/=) = { _A_ 2 _U_ 11 _N_ _S_ "SS" _N_ _N_ } #-}
instance Eq [Int]
{-# GHC_PRAGMA _M_ PreludeBuiltin {-dfun-} _A_ 0 _N_ _N_ _N_ _F_ _IF_ARGS_ 0 0 X 3 _!_ _TUP_2 [([Int] -> [Int] -> Bool), ([Int] -> [Int] -> Bool)] [_CONSTM_ Eq (==) ([Int]), _CONSTM_ Eq (/=) ([Int])] _N_
- (==) = _A_ 2 _U_ 11 _N_ _S_ "SS" _N_ _N_,
- (/=) = _A_ 2 _U_ 11 _N_ _S_ "SS" _N_ _N_ #-}
+ (==) = { _A_ 2 _U_ 11 _N_ _S_ "SS" _N_ _N_ },
+ (/=) = { _A_ 2 _U_ 11 _N_ _S_ "SS" _N_ _N_ } #-}
+instance Eq [Integer]
+ {-# GHC_PRAGMA _M_ PreludeBuiltin {-dfun-} _A_ 0 _N_ _N_ _N_ _F_ _IF_ARGS_ 0 0 X 3 _!_ _TUP_2 [([Integer] -> [Integer] -> Bool), ([Integer] -> [Integer] -> Bool)] [_CONSTM_ Eq (==) ([Integer]), _CONSTM_ Eq (/=) ([Integer])] _N_
+ (==) = { _A_ 2 _U_ 11 _N_ _S_ "SS" _N_ _N_ },
+ (/=) = { _A_ 2 _U_ 11 _N_ _S_ "SS" _N_ _N_ } #-}
+instance Eq [[Char]]
+ {-# GHC_PRAGMA _M_ PreludeBuiltin {-dfun-} _A_ 0 _N_ _N_ _N_ _F_ _IF_ARGS_ 0 0 X 3 _!_ _TUP_2 [([[Char]] -> [[Char]] -> Bool), ([[Char]] -> [[Char]] -> Bool)] [_CONSTM_ Eq (==) ([[Char]]), _CONSTM_ Eq (/=) ([[Char]])] _N_
+ (==) = { _A_ 2 _U_ 11 _N_ _S_ "SS" _N_ _N_ },
+ (/=) = { _A_ 2 _U_ 11 _N_ _S_ "SS" _N_ _N_ } #-}
+instance Eq [[Int]]
+ {-# GHC_PRAGMA _M_ PreludeBuiltin {-dfun-} _A_ 0 _N_ _N_ _N_ _F_ _IF_ARGS_ 0 0 X 3 _!_ _TUP_2 [([[Int]] -> [[Int]] -> Bool), ([[Int]] -> [[Int]] -> Bool)] [_CONSTM_ Eq (==) ([[Int]]), _CONSTM_ Eq (/=) ([[Int]])] _N_
+ (==) = { _A_ 2 _U_ 11 _N_ _S_ "SS" _N_ _N_ },
+ (/=) = { _A_ 2 _U_ 11 _N_ _S_ "SS" _N_ _N_ } #-}
instance Eq _Addr
{-# GHC_PRAGMA _M_ PreludeCore {-dfun-} _A_ 0 _N_ _N_ _N_ _F_ _IF_ARGS_ 0 0 X 3 _!_ _TUP_2 [(_Addr -> _Addr -> Bool), (_Addr -> _Addr -> Bool)] [_CONSTM_ Eq (==) (_Addr), _CONSTM_ Eq (/=) (_Addr)] _N_
- (==) = _A_ 2 _U_ 11 _N_ _S_ "U(P)U(P)" {_A_ 2 _U_ 22 _N_ _N_ _F_ _IF_ARGS_ 0 2 XX 1 \ (u0 :: Addr#) (u1 :: Addr#) -> _#_ eqAddr# [] [u0, u1] _N_} _F_ _IF_ARGS_ 0 2 CC 3 \ (u0 :: _Addr) (u1 :: _Addr) -> case u0 of { _ALG_ A# (u2 :: Addr#) -> case u1 of { _ALG_ A# (u3 :: Addr#) -> _#_ eqAddr# [] [u2, u3]; _NO_DEFLT_ }; _NO_DEFLT_ } _N_,
- (/=) = _A_ 2 _U_ 11 _N_ _S_ "U(P)U(P)" {_A_ 2 _U_ 22 _N_ _N_ _F_ _IF_ARGS_ 0 2 XX 1 \ (u0 :: Addr#) (u1 :: Addr#) -> _#_ neAddr# [] [u0, u1] _N_} _F_ _IF_ARGS_ 0 2 CC 3 \ (u0 :: _Addr) (u1 :: _Addr) -> case u0 of { _ALG_ A# (u2 :: Addr#) -> case u1 of { _ALG_ A# (u3 :: Addr#) -> _#_ neAddr# [] [u2, u3]; _NO_DEFLT_ }; _NO_DEFLT_ } _N_ #-}
+ (==) = { _A_ 2 _U_ 11 _N_ _S_ "U(P)U(P)" {_A_ 2 _U_ 22 _N_ _N_ _F_ _IF_ARGS_ 0 2 XX 1 \ (u0 :: Addr#) (u1 :: Addr#) -> _#_ eqAddr# [] [u0, u1] _N_} _F_ _IF_ARGS_ 0 2 CC 3 \ (u0 :: _Addr) (u1 :: _Addr) -> case u0 of { _ALG_ A# (u2 :: Addr#) -> case u1 of { _ALG_ A# (u3 :: Addr#) -> _#_ eqAddr# [] [u2, u3]; _NO_DEFLT_ }; _NO_DEFLT_ } _N_ },
+ (/=) = { _A_ 2 _U_ 11 _N_ _S_ "U(P)U(P)" {_A_ 2 _U_ 22 _N_ _N_ _F_ _IF_ARGS_ 0 2 XX 1 \ (u0 :: Addr#) (u1 :: Addr#) -> _#_ neAddr# [] [u0, u1] _N_} _F_ _IF_ARGS_ 0 2 CC 3 \ (u0 :: _Addr) (u1 :: _Addr) -> case u0 of { _ALG_ A# (u2 :: Addr#) -> case u1 of { _ALG_ A# (u3 :: Addr#) -> _#_ neAddr# [] [u2, u3]; _NO_DEFLT_ }; _NO_DEFLT_ } _N_ } #-}
instance Eq _PackedString
{-# GHC_PRAGMA _M_ PreludePS {-dfun-} _A_ 0 _N_ _N_ _N_ _F_ _IF_ARGS_ 0 0 X 3 _!_ _TUP_2 [(_PackedString -> _PackedString -> Bool), (_PackedString -> _PackedString -> Bool)] [_CONSTM_ Eq (==) (_PackedString), _CONSTM_ Eq (/=) (_PackedString)] _N_
- (==) = _A_ 2 _U_ 22 _N_ _S_ "SS" _N_ _N_,
- (/=) = _A_ 2 _U_ 22 _N_ _S_ "SS" _N_ _N_ #-}
+ (==) = { _A_ 2 _U_ 22 _N_ _S_ "SS" _N_ _N_ },
+ (/=) = { _A_ 2 _U_ 22 _N_ _S_ "SS" _N_ _N_ } #-}
instance Eq _Word
{-# GHC_PRAGMA _M_ PreludeCore {-dfun-} _A_ 0 _N_ _N_ _N_ _F_ _IF_ARGS_ 0 0 X 3 _!_ _TUP_2 [(_Word -> _Word -> Bool), (_Word -> _Word -> Bool)] [_CONSTM_ Eq (==) (_Word), _CONSTM_ Eq (/=) (_Word)] _N_
- (==) = _A_ 2 _U_ 11 _N_ _S_ "U(P)U(P)" {_A_ 2 _U_ 22 _N_ _N_ _F_ _IF_ARGS_ 0 2 XX 1 \ (u0 :: Word#) (u1 :: Word#) -> _#_ eqWord# [] [u0, u1] _N_} _F_ _IF_ARGS_ 0 2 CC 3 \ (u0 :: _Word) (u1 :: _Word) -> case u0 of { _ALG_ W# (u2 :: Word#) -> case u1 of { _ALG_ W# (u3 :: Word#) -> _#_ eqWord# [] [u2, u3]; _NO_DEFLT_ }; _NO_DEFLT_ } _N_,
- (/=) = _A_ 2 _U_ 11 _N_ _S_ "U(P)U(P)" {_A_ 2 _U_ 22 _N_ _N_ _F_ _IF_ARGS_ 0 2 XX 1 \ (u0 :: Word#) (u1 :: Word#) -> _#_ neWord# [] [u0, u1] _N_} _F_ _IF_ARGS_ 0 2 CC 3 \ (u0 :: _Word) (u1 :: _Word) -> case u0 of { _ALG_ W# (u2 :: Word#) -> case u1 of { _ALG_ W# (u3 :: Word#) -> _#_ neWord# [] [u2, u3]; _NO_DEFLT_ }; _NO_DEFLT_ } _N_ #-}
+ (==) = { _A_ 2 _U_ 11 _N_ _S_ "U(P)U(P)" {_A_ 2 _U_ 22 _N_ _N_ _F_ _IF_ARGS_ 0 2 XX 1 \ (u0 :: Word#) (u1 :: Word#) -> _#_ eqWord# [] [u0, u1] _N_} _F_ _IF_ARGS_ 0 2 CC 3 \ (u0 :: _Word) (u1 :: _Word) -> case u0 of { _ALG_ W# (u2 :: Word#) -> case u1 of { _ALG_ W# (u3 :: Word#) -> _#_ eqWord# [] [u2, u3]; _NO_DEFLT_ }; _NO_DEFLT_ } _N_ },
+ (/=) = { _A_ 2 _U_ 11 _N_ _S_ "U(P)U(P)" {_A_ 2 _U_ 22 _N_ _N_ _F_ _IF_ARGS_ 0 2 XX 1 \ (u0 :: Word#) (u1 :: Word#) -> _#_ neWord# [] [u0, u1] _N_} _F_ _IF_ARGS_ 0 2 CC 3 \ (u0 :: _Word) (u1 :: _Word) -> case u0 of { _ALG_ W# (u2 :: Word#) -> case u1 of { _ALG_ W# (u3 :: Word#) -> _#_ neWord# [] [u2, u3]; _NO_DEFLT_ }; _NO_DEFLT_ } _N_ } #-}
instance RealFloat a => Floating (Complex a)
{-# GHC_PRAGMA _M_ PreludeComplex {-dfun-} _A_ 2 _U_ 22 _N_ _N_ _N_ _N_ #-}
instance Floating (Complex Double)
{-# GHC_PRAGMA _M_ PreludeComplex {-dfun-} _A_ 0 _N_ _N_ _N_ _F_ _IF_ARGS_ 0 0 X 20 _!_ _TUP_19 [{{Fractional (Complex Double)}}, (Complex Double), (Complex Double -> Complex Double), (Complex Double -> Complex Double), (Complex Double -> Complex Double), (Complex Double -> Complex Double -> Complex Double), (Complex Double -> Complex Double -> Complex Double), (Complex Double -> Complex Double), (Complex Double -> Complex Double), (Complex Double -> Complex Double), (Complex Double -> Complex Double), (Complex Double -> Complex Double), (Complex Double -> Complex Double), (Complex Double -> Complex Double), (Complex Double -> Complex Double), (Complex Double -> Complex Double), (Complex Double -> Complex Double), (Complex Double -> Complex Double), (Complex Double -> Complex Double)] [_DFUN_ Fractional (Complex Double), _CONSTM_ Floating pi (Complex Double), _CONSTM_ Floating exp (Complex Double), _CONSTM_ Floating log (Complex Double), _CONSTM_ Floating sqrt (Complex Double), _CONSTM_ Floating (**) (Complex Double), _CONSTM_ Floating logBase (Complex Double), _CONSTM_ Floating sin (Complex Double), _CONSTM_ Floating cos (Complex Double), _CONSTM_ Floating tan (Complex Double), _CONSTM_ Floating asin (Complex Double), _CONSTM_ Floating acos (Complex Double), _CONSTM_ Floating atan (Complex Double), _CONSTM_ Floating sinh (Complex Double), _CONSTM_ Floating cosh (Complex Double), _CONSTM_ Floating tanh (Complex Double), _CONSTM_ Floating asinh (Complex Double), _CONSTM_ Floating acosh (Complex Double), _CONSTM_ Floating atanh (Complex Double)] _N_
- pi = _A_ 0 _N_ _N_ _N_ _N_ _N_,
- exp = _A_ 1 _U_ 1 _N_ _S_ "U(LL)" {_A_ 2 _U_ 12 _N_ _N_ _N_ _N_} _N_ _N_,
- log = _A_ 1 _U_ 2 _N_ _N_ _N_ _N_,
- sqrt = _A_ 1 _U_ 1 _N_ _S_ "U(U(P)L)" {_A_ 2 _U_ 22 _N_ _N_ _N_ _N_} _N_ _N_,
- (**) = _A_ 2 _U_ 21 _N_ _S_ "LU(LL)" {_A_ 3 _U_ 222 _N_ _N_ _N_ _N_} _N_ _N_,
- logBase = _A_ 2 _U_ 22 _N_ _N_ _N_ _N_,
- sin = _A_ 1 _U_ 1 _N_ _S_ "U(LL)" {_A_ 2 _U_ 22 _N_ _N_ _N_ _N_} _N_ _N_,
- cos = _A_ 1 _U_ 1 _N_ _S_ "U(LL)" {_A_ 2 _U_ 22 _N_ _N_ _N_ _N_} _N_ _N_,
- tan = _A_ 1 _U_ 1 _N_ _S_ "U(LL)" {_A_ 2 _U_ 22 _N_ _N_ _N_ _N_} _N_ _N_,
- asin = _A_ 1 _U_ 1 _N_ _S_ "U(LL)" {_A_ 2 _U_ 22 _N_ _N_ _N_ _N_} _N_ _N_,
- acos = _A_ 1 _U_ 1 _N_ _S_ "U(LL)" {_A_ 2 _U_ 22 _N_ _N_ _N_ _N_} _N_ _N_,
- atan = _A_ 1 _U_ 1 _N_ _S_ "U(LL)" {_A_ 2 _U_ 22 _N_ _N_ _N_ _N_} _N_ _N_,
- sinh = _A_ 1 _U_ 1 _N_ _S_ "U(LL)" {_A_ 2 _U_ 22 _N_ _N_ _N_ _N_} _N_ _N_,
- cosh = _A_ 1 _U_ 1 _N_ _S_ "U(LL)" {_A_ 2 _U_ 22 _N_ _N_ _N_ _N_} _N_ _N_,
- tanh = _A_ 1 _U_ 1 _N_ _S_ "U(LL)" {_A_ 2 _U_ 22 _N_ _N_ _N_ _N_} _N_ _N_,
- asinh = _A_ 1 _U_ 1 _N_ _N_ _N_ _N_,
- acosh = _A_ 1 _U_ 1 _N_ _N_ _N_ _N_,
- atanh = _A_ 1 _U_ 1 _N_ _N_ _N_ _N_ #-}
+ pi = { _A_ 0 _N_ _N_ _N_ _F_ _IF_ARGS_ 0 0 X 3 _!_ (:+) [Double] [_CONSTM_ Floating pi (Double), _SPEC_ _ORIG_ PreludeCore __i0 [ (Double) ]] _N_ },
+ exp = { _A_ 1 _U_ 1 _N_ _S_ "U(LL)" {_A_ 2 _U_ 12 _N_ _N_ _N_ _N_} _N_ _N_ },
+ log = { _A_ 1 _U_ 2 _N_ _N_ _N_ _N_ },
+ sqrt = { _A_ 1 _U_ 1 _N_ _S_ "U(U(P)L)" {_A_ 2 _U_ 22 _N_ _N_ _N_ _N_} _N_ _N_ },
+ (**) = { _A_ 2 _U_ 21 _N_ _S_ "LU(LL)" {_A_ 3 _U_ 222 _N_ _N_ _N_ _N_} _N_ _N_ },
+ logBase = { _A_ 2 _U_ 22 _N_ _N_ _N_ _N_ },
+ sin = { _A_ 1 _U_ 1 _N_ _S_ "U(LL)" {_A_ 2 _U_ 22 _N_ _N_ _N_ _N_} _N_ _N_ },
+ cos = { _A_ 1 _U_ 1 _N_ _S_ "U(LL)" {_A_ 2 _U_ 22 _N_ _N_ _N_ _N_} _N_ _N_ },
+ tan = { _A_ 1 _U_ 1 _N_ _S_ "U(LL)" {_A_ 2 _U_ 22 _N_ _N_ _N_ _N_} _N_ _N_ },
+ asin = { _A_ 1 _U_ 1 _N_ _S_ "U(LL)" {_A_ 2 _U_ 22 _N_ _N_ _N_ _N_} _N_ _N_ },
+ acos = { _A_ 1 _U_ 1 _N_ _S_ "U(LL)" {_A_ 2 _U_ 22 _N_ _N_ _N_ _N_} _N_ _N_ },
+ atan = { _A_ 1 _U_ 1 _N_ _S_ "U(LL)" {_A_ 2 _U_ 22 _N_ _N_ _N_ _N_} _N_ _N_ },
+ sinh = { _A_ 1 _U_ 1 _N_ _S_ "U(LL)" {_A_ 2 _U_ 22 _N_ _N_ _N_ _N_} _N_ _N_ },
+ cosh = { _A_ 1 _U_ 1 _N_ _S_ "U(LL)" {_A_ 2 _U_ 22 _N_ _N_ _N_ _N_} _N_ _N_ },
+ tanh = { _A_ 1 _U_ 1 _N_ _S_ "U(LL)" {_A_ 2 _U_ 22 _N_ _N_ _N_ _N_} _N_ _N_ },
+ asinh = { _A_ 1 _U_ 1 _N_ _N_ _N_ _N_ },
+ acosh = { _A_ 1 _U_ 1 _N_ _N_ _N_ _N_ },
+ atanh = { _A_ 1 _U_ 1 _N_ _N_ _N_ _N_ } #-}
instance Floating Double
{-# GHC_PRAGMA _M_ PreludeCore {-dfun-} _A_ 0 _N_ _N_ _N_ _F_ _IF_ARGS_ 0 0 X 20 _!_ _TUP_19 [{{Fractional Double}}, Double, (Double -> Double), (Double -> Double), (Double -> Double), (Double -> Double -> Double), (Double -> Double -> Double), (Double -> Double), (Double -> Double), (Double -> Double), (Double -> Double), (Double -> Double), (Double -> Double), (Double -> Double), (Double -> Double), (Double -> Double), (Double -> Double), (Double -> Double), (Double -> Double)] [_DFUN_ Fractional (Double), _CONSTM_ Floating pi (Double), _CONSTM_ Floating exp (Double), _CONSTM_ Floating log (Double), _CONSTM_ Floating sqrt (Double), _CONSTM_ Floating (**) (Double), _CONSTM_ Floating logBase (Double), _CONSTM_ Floating sin (Double), _CONSTM_ Floating cos (Double), _CONSTM_ Floating tan (Double), _CONSTM_ Floating asin (Double), _CONSTM_ Floating acos (Double), _CONSTM_ Floating atan (Double), _CONSTM_ Floating sinh (Double), _CONSTM_ Floating cosh (Double), _CONSTM_ Floating tanh (Double), _CONSTM_ Floating asinh (Double), _CONSTM_ Floating acosh (Double), _CONSTM_ Floating atanh (Double)] _N_
- pi = _A_ 0 _N_ _N_ _N_ _F_ _IF_ARGS_ 0 0 X 2 _!_ D# [] [3.1415926535897931##] _N_,
- exp = _A_ 1 _U_ 1 _N_ _S_ "U(P)" {_A_ 1 _U_ 2 _N_ _N_ _F_ _IF_ARGS_ 0 1 X 3 \ (u0 :: Double#) -> case _#_ expDouble# [] [u0] of { _PRIM_ (u1 :: Double#) -> _!_ D# [] [u1] } _N_} _F_ _IF_ARGS_ 0 1 C 4 \ (u0 :: Double) -> case u0 of { _ALG_ D# (u1 :: Double#) -> case _#_ expDouble# [] [u1] of { _PRIM_ (u2 :: Double#) -> _!_ D# [] [u2] }; _NO_DEFLT_ } _N_,
- log = _A_ 1 _U_ 1 _N_ _S_ "U(P)" {_A_ 1 _U_ 2 _N_ _N_ _F_ _IF_ARGS_ 0 1 X 3 \ (u0 :: Double#) -> case _#_ logDouble# [] [u0] of { _PRIM_ (u1 :: Double#) -> _!_ D# [] [u1] } _N_} _F_ _IF_ARGS_ 0 1 C 4 \ (u0 :: Double) -> case u0 of { _ALG_ D# (u1 :: Double#) -> case _#_ logDouble# [] [u1] of { _PRIM_ (u2 :: Double#) -> _!_ D# [] [u2] }; _NO_DEFLT_ } _N_,
- sqrt = _A_ 1 _U_ 1 _N_ _S_ "U(P)" {_A_ 1 _U_ 2 _N_ _N_ _F_ _IF_ARGS_ 0 1 X 3 \ (u0 :: Double#) -> case _#_ sqrtDouble# [] [u0] of { _PRIM_ (u1 :: Double#) -> _!_ D# [] [u1] } _N_} _F_ _IF_ARGS_ 0 1 C 4 \ (u0 :: Double) -> case u0 of { _ALG_ D# (u1 :: Double#) -> case _#_ sqrtDouble# [] [u1] of { _PRIM_ (u2 :: Double#) -> _!_ D# [] [u2] }; _NO_DEFLT_ } _N_,
- (**) = _A_ 2 _U_ 11 _N_ _S_ "U(P)U(P)" {_A_ 2 _U_ 22 _N_ _N_ _F_ _IF_ARGS_ 0 2 XX 3 \ (u0 :: Double#) (u1 :: Double#) -> case _#_ powerDouble# [] [u0, u1] of { _PRIM_ (u2 :: Double#) -> _!_ D# [] [u2] } _N_} _F_ _IF_ARGS_ 0 2 CC 5 \ (u0 :: Double) (u1 :: Double) -> case u0 of { _ALG_ D# (u2 :: Double#) -> case u1 of { _ALG_ D# (u3 :: Double#) -> case _#_ powerDouble# [] [u2, u3] of { _PRIM_ (u4 :: Double#) -> _!_ D# [] [u4] }; _NO_DEFLT_ }; _NO_DEFLT_ } _N_,
- logBase = _A_ 2 _U_ 11 _N_ _S_ "U(P)U(P)" {_A_ 2 _U_ 22 _N_ _N_ _F_ _IF_ARGS_ 0 2 XX 5 \ (u0 :: Double#) (u1 :: Double#) -> case _#_ logDouble# [] [u1] of { _PRIM_ (u2 :: Double#) -> case _#_ logDouble# [] [u0] of { _PRIM_ (u3 :: Double#) -> case _#_ divideDouble# [] [u2, u3] of { _PRIM_ (u4 :: Double#) -> _!_ D# [] [u4] } } } _N_} _F_ _IF_ARGS_ 0 2 CC 7 \ (u0 :: Double) (u1 :: Double) -> case u1 of { _ALG_ D# (u2 :: Double#) -> case _#_ logDouble# [] [u2] of { _PRIM_ (u3 :: Double#) -> case u0 of { _ALG_ D# (u4 :: Double#) -> case _#_ logDouble# [] [u4] of { _PRIM_ (u5 :: Double#) -> case _#_ divideDouble# [] [u3, u5] of { _PRIM_ (u6 :: Double#) -> _!_ D# [] [u6] } }; _NO_DEFLT_ } }; _NO_DEFLT_ } _N_,
- sin = _A_ 1 _U_ 1 _N_ _S_ "U(P)" {_A_ 1 _U_ 2 _N_ _N_ _F_ _IF_ARGS_ 0 1 X 3 \ (u0 :: Double#) -> case _#_ sinDouble# [] [u0] of { _PRIM_ (u1 :: Double#) -> _!_ D# [] [u1] } _N_} _F_ _IF_ARGS_ 0 1 C 4 \ (u0 :: Double) -> case u0 of { _ALG_ D# (u1 :: Double#) -> case _#_ sinDouble# [] [u1] of { _PRIM_ (u2 :: Double#) -> _!_ D# [] [u2] }; _NO_DEFLT_ } _N_,
- cos = _A_ 1 _U_ 1 _N_ _S_ "U(P)" {_A_ 1 _U_ 2 _N_ _N_ _F_ _IF_ARGS_ 0 1 X 3 \ (u0 :: Double#) -> case _#_ cosDouble# [] [u0] of { _PRIM_ (u1 :: Double#) -> _!_ D# [] [u1] } _N_} _F_ _IF_ARGS_ 0 1 C 4 \ (u0 :: Double) -> case u0 of { _ALG_ D# (u1 :: Double#) -> case _#_ cosDouble# [] [u1] of { _PRIM_ (u2 :: Double#) -> _!_ D# [] [u2] }; _NO_DEFLT_ } _N_,
- tan = _A_ 1 _U_ 1 _N_ _S_ "U(P)" {_A_ 1 _U_ 2 _N_ _N_ _F_ _IF_ARGS_ 0 1 X 3 \ (u0 :: Double#) -> case _#_ tanDouble# [] [u0] of { _PRIM_ (u1 :: Double#) -> _!_ D# [] [u1] } _N_} _F_ _IF_ARGS_ 0 1 C 4 \ (u0 :: Double) -> case u0 of { _ALG_ D# (u1 :: Double#) -> case _#_ tanDouble# [] [u1] of { _PRIM_ (u2 :: Double#) -> _!_ D# [] [u2] }; _NO_DEFLT_ } _N_,
- asin = _A_ 1 _U_ 1 _N_ _S_ "U(P)" {_A_ 1 _U_ 2 _N_ _N_ _F_ _IF_ARGS_ 0 1 X 3 \ (u0 :: Double#) -> case _#_ asinDouble# [] [u0] of { _PRIM_ (u1 :: Double#) -> _!_ D# [] [u1] } _N_} _F_ _IF_ARGS_ 0 1 C 4 \ (u0 :: Double) -> case u0 of { _ALG_ D# (u1 :: Double#) -> case _#_ asinDouble# [] [u1] of { _PRIM_ (u2 :: Double#) -> _!_ D# [] [u2] }; _NO_DEFLT_ } _N_,
- acos = _A_ 1 _U_ 1 _N_ _S_ "U(P)" {_A_ 1 _U_ 2 _N_ _N_ _F_ _IF_ARGS_ 0 1 X 3 \ (u0 :: Double#) -> case _#_ acosDouble# [] [u0] of { _PRIM_ (u1 :: Double#) -> _!_ D# [] [u1] } _N_} _F_ _IF_ARGS_ 0 1 C 4 \ (u0 :: Double) -> case u0 of { _ALG_ D# (u1 :: Double#) -> case _#_ acosDouble# [] [u1] of { _PRIM_ (u2 :: Double#) -> _!_ D# [] [u2] }; _NO_DEFLT_ } _N_,
- atan = _A_ 1 _U_ 1 _N_ _S_ "U(P)" {_A_ 1 _U_ 2 _N_ _N_ _F_ _IF_ARGS_ 0 1 X 3 \ (u0 :: Double#) -> case _#_ atanDouble# [] [u0] of { _PRIM_ (u1 :: Double#) -> _!_ D# [] [u1] } _N_} _F_ _IF_ARGS_ 0 1 C 4 \ (u0 :: Double) -> case u0 of { _ALG_ D# (u1 :: Double#) -> case _#_ atanDouble# [] [u1] of { _PRIM_ (u2 :: Double#) -> _!_ D# [] [u2] }; _NO_DEFLT_ } _N_,
- sinh = _A_ 1 _U_ 1 _N_ _S_ "U(P)" {_A_ 1 _U_ 2 _N_ _N_ _F_ _IF_ARGS_ 0 1 X 3 \ (u0 :: Double#) -> case _#_ sinhDouble# [] [u0] of { _PRIM_ (u1 :: Double#) -> _!_ D# [] [u1] } _N_} _F_ _IF_ARGS_ 0 1 C 4 \ (u0 :: Double) -> case u0 of { _ALG_ D# (u1 :: Double#) -> case _#_ sinhDouble# [] [u1] of { _PRIM_ (u2 :: Double#) -> _!_ D# [] [u2] }; _NO_DEFLT_ } _N_,
- cosh = _A_ 1 _U_ 1 _N_ _S_ "U(P)" {_A_ 1 _U_ 2 _N_ _N_ _F_ _IF_ARGS_ 0 1 X 3 \ (u0 :: Double#) -> case _#_ coshDouble# [] [u0] of { _PRIM_ (u1 :: Double#) -> _!_ D# [] [u1] } _N_} _F_ _IF_ARGS_ 0 1 C 4 \ (u0 :: Double) -> case u0 of { _ALG_ D# (u1 :: Double#) -> case _#_ coshDouble# [] [u1] of { _PRIM_ (u2 :: Double#) -> _!_ D# [] [u2] }; _NO_DEFLT_ } _N_,
- tanh = _A_ 1 _U_ 1 _N_ _S_ "U(P)" {_A_ 1 _U_ 2 _N_ _N_ _F_ _IF_ARGS_ 0 1 X 3 \ (u0 :: Double#) -> case _#_ tanhDouble# [] [u0] of { _PRIM_ (u1 :: Double#) -> _!_ D# [] [u1] } _N_} _F_ _IF_ARGS_ 0 1 C 4 \ (u0 :: Double) -> case u0 of { _ALG_ D# (u1 :: Double#) -> case _#_ tanhDouble# [] [u1] of { _PRIM_ (u2 :: Double#) -> _!_ D# [] [u2] }; _NO_DEFLT_ } _N_,
- asinh = _A_ 1 _U_ 1 _N_ _S_ "U(P)" {_A_ 1 _U_ 2 _N_ _N_ _N_ _N_} _N_ _N_,
- acosh = _A_ 1 _U_ 1 _N_ _S_ "U(P)" {_A_ 1 _U_ 2 _N_ _N_ _N_ _N_} _N_ _N_,
- atanh = _A_ 1 _U_ 1 _N_ _S_ "U(P)" {_A_ 1 _U_ 2 _N_ _N_ _N_ _N_} _N_ _N_ #-}
+ pi = { _A_ 0 _N_ _N_ _N_ _F_ _IF_ARGS_ 0 0 X 2 _!_ D# [] [3.1415926535897931##] _N_ },
+ exp = { _A_ 1 _U_ 1 _N_ _S_ "U(P)" {_A_ 1 _U_ 2 _N_ _N_ _F_ _IF_ARGS_ 0 1 X 3 \ (u0 :: Double#) -> case _#_ expDouble# [] [u0] of { _PRIM_ (u1 :: Double#) -> _!_ D# [] [u1] } _N_} _F_ _IF_ARGS_ 0 1 C 4 \ (u0 :: Double) -> case u0 of { _ALG_ D# (u1 :: Double#) -> case _#_ expDouble# [] [u1] of { _PRIM_ (u2 :: Double#) -> _!_ D# [] [u2] }; _NO_DEFLT_ } _N_ },
+ log = { _A_ 1 _U_ 1 _N_ _S_ "U(P)" {_A_ 1 _U_ 2 _N_ _N_ _F_ _IF_ARGS_ 0 1 X 3 \ (u0 :: Double#) -> case _#_ logDouble# [] [u0] of { _PRIM_ (u1 :: Double#) -> _!_ D# [] [u1] } _N_} _F_ _IF_ARGS_ 0 1 C 4 \ (u0 :: Double) -> case u0 of { _ALG_ D# (u1 :: Double#) -> case _#_ logDouble# [] [u1] of { _PRIM_ (u2 :: Double#) -> _!_ D# [] [u2] }; _NO_DEFLT_ } _N_ },
+ sqrt = { _A_ 1 _U_ 1 _N_ _S_ "U(P)" {_A_ 1 _U_ 2 _N_ _N_ _F_ _IF_ARGS_ 0 1 X 3 \ (u0 :: Double#) -> case _#_ sqrtDouble# [] [u0] of { _PRIM_ (u1 :: Double#) -> _!_ D# [] [u1] } _N_} _F_ _IF_ARGS_ 0 1 C 4 \ (u0 :: Double) -> case u0 of { _ALG_ D# (u1 :: Double#) -> case _#_ sqrtDouble# [] [u1] of { _PRIM_ (u2 :: Double#) -> _!_ D# [] [u2] }; _NO_DEFLT_ } _N_ },
+ (**) = { _A_ 2 _U_ 11 _N_ _S_ "U(P)U(P)" {_A_ 2 _U_ 22 _N_ _N_ _F_ _IF_ARGS_ 0 2 XX 3 \ (u0 :: Double#) (u1 :: Double#) -> case _#_ powerDouble# [] [u0, u1] of { _PRIM_ (u2 :: Double#) -> _!_ D# [] [u2] } _N_} _F_ _IF_ARGS_ 0 2 CC 5 \ (u0 :: Double) (u1 :: Double) -> case u0 of { _ALG_ D# (u2 :: Double#) -> case u1 of { _ALG_ D# (u3 :: Double#) -> case _#_ powerDouble# [] [u2, u3] of { _PRIM_ (u4 :: Double#) -> _!_ D# [] [u4] }; _NO_DEFLT_ }; _NO_DEFLT_ } _N_ },
+ logBase = { _A_ 2 _U_ 11 _N_ _S_ "U(P)U(P)" {_A_ 2 _U_ 22 _N_ _N_ _F_ _IF_ARGS_ 0 2 XX 5 \ (u0 :: Double#) (u1 :: Double#) -> case _#_ logDouble# [] [u1] of { _PRIM_ (u2 :: Double#) -> case _#_ logDouble# [] [u0] of { _PRIM_ (u3 :: Double#) -> case _#_ divideDouble# [] [u2, u3] of { _PRIM_ (u4 :: Double#) -> _!_ D# [] [u4] } } } _N_} _F_ _IF_ARGS_ 0 2 CC 7 \ (u0 :: Double) (u1 :: Double) -> case u1 of { _ALG_ D# (u2 :: Double#) -> case _#_ logDouble# [] [u2] of { _PRIM_ (u3 :: Double#) -> case u0 of { _ALG_ D# (u4 :: Double#) -> case _#_ logDouble# [] [u4] of { _PRIM_ (u5 :: Double#) -> case _#_ divideDouble# [] [u3, u5] of { _PRIM_ (u6 :: Double#) -> _!_ D# [] [u6] } }; _NO_DEFLT_ } }; _NO_DEFLT_ } _N_ },
+ sin = { _A_ 1 _U_ 1 _N_ _S_ "U(P)" {_A_ 1 _U_ 2 _N_ _N_ _F_ _IF_ARGS_ 0 1 X 3 \ (u0 :: Double#) -> case _#_ sinDouble# [] [u0] of { _PRIM_ (u1 :: Double#) -> _!_ D# [] [u1] } _N_} _F_ _IF_ARGS_ 0 1 C 4 \ (u0 :: Double) -> case u0 of { _ALG_ D# (u1 :: Double#) -> case _#_ sinDouble# [] [u1] of { _PRIM_ (u2 :: Double#) -> _!_ D# [] [u2] }; _NO_DEFLT_ } _N_ },
+ cos = { _A_ 1 _U_ 1 _N_ _S_ "U(P)" {_A_ 1 _U_ 2 _N_ _N_ _F_ _IF_ARGS_ 0 1 X 3 \ (u0 :: Double#) -> case _#_ cosDouble# [] [u0] of { _PRIM_ (u1 :: Double#) -> _!_ D# [] [u1] } _N_} _F_ _IF_ARGS_ 0 1 C 4 \ (u0 :: Double) -> case u0 of { _ALG_ D# (u1 :: Double#) -> case _#_ cosDouble# [] [u1] of { _PRIM_ (u2 :: Double#) -> _!_ D# [] [u2] }; _NO_DEFLT_ } _N_ },
+ tan = { _A_ 1 _U_ 1 _N_ _S_ "U(P)" {_A_ 1 _U_ 2 _N_ _N_ _F_ _IF_ARGS_ 0 1 X 3 \ (u0 :: Double#) -> case _#_ tanDouble# [] [u0] of { _PRIM_ (u1 :: Double#) -> _!_ D# [] [u1] } _N_} _F_ _IF_ARGS_ 0 1 C 4 \ (u0 :: Double) -> case u0 of { _ALG_ D# (u1 :: Double#) -> case _#_ tanDouble# [] [u1] of { _PRIM_ (u2 :: Double#) -> _!_ D# [] [u2] }; _NO_DEFLT_ } _N_ },
+ asin = { _A_ 1 _U_ 1 _N_ _S_ "U(P)" {_A_ 1 _U_ 2 _N_ _N_ _F_ _IF_ARGS_ 0 1 X 3 \ (u0 :: Double#) -> case _#_ asinDouble# [] [u0] of { _PRIM_ (u1 :: Double#) -> _!_ D# [] [u1] } _N_} _F_ _IF_ARGS_ 0 1 C 4 \ (u0 :: Double) -> case u0 of { _ALG_ D# (u1 :: Double#) -> case _#_ asinDouble# [] [u1] of { _PRIM_ (u2 :: Double#) -> _!_ D# [] [u2] }; _NO_DEFLT_ } _N_ },
+ acos = { _A_ 1 _U_ 1 _N_ _S_ "U(P)" {_A_ 1 _U_ 2 _N_ _N_ _F_ _IF_ARGS_ 0 1 X 3 \ (u0 :: Double#) -> case _#_ acosDouble# [] [u0] of { _PRIM_ (u1 :: Double#) -> _!_ D# [] [u1] } _N_} _F_ _IF_ARGS_ 0 1 C 4 \ (u0 :: Double) -> case u0 of { _ALG_ D# (u1 :: Double#) -> case _#_ acosDouble# [] [u1] of { _PRIM_ (u2 :: Double#) -> _!_ D# [] [u2] }; _NO_DEFLT_ } _N_ },
+ atan = { _A_ 1 _U_ 1 _N_ _S_ "U(P)" {_A_ 1 _U_ 2 _N_ _N_ _F_ _IF_ARGS_ 0 1 X 3 \ (u0 :: Double#) -> case _#_ atanDouble# [] [u0] of { _PRIM_ (u1 :: Double#) -> _!_ D# [] [u1] } _N_} _F_ _IF_ARGS_ 0 1 C 4 \ (u0 :: Double) -> case u0 of { _ALG_ D# (u1 :: Double#) -> case _#_ atanDouble# [] [u1] of { _PRIM_ (u2 :: Double#) -> _!_ D# [] [u2] }; _NO_DEFLT_ } _N_ },
+ sinh = { _A_ 1 _U_ 1 _N_ _S_ "U(P)" {_A_ 1 _U_ 2 _N_ _N_ _F_ _IF_ARGS_ 0 1 X 3 \ (u0 :: Double#) -> case _#_ sinhDouble# [] [u0] of { _PRIM_ (u1 :: Double#) -> _!_ D# [] [u1] } _N_} _F_ _IF_ARGS_ 0 1 C 4 \ (u0 :: Double) -> case u0 of { _ALG_ D# (u1 :: Double#) -> case _#_ sinhDouble# [] [u1] of { _PRIM_ (u2 :: Double#) -> _!_ D# [] [u2] }; _NO_DEFLT_ } _N_ },
+ cosh = { _A_ 1 _U_ 1 _N_ _S_ "U(P)" {_A_ 1 _U_ 2 _N_ _N_ _F_ _IF_ARGS_ 0 1 X 3 \ (u0 :: Double#) -> case _#_ coshDouble# [] [u0] of { _PRIM_ (u1 :: Double#) -> _!_ D# [] [u1] } _N_} _F_ _IF_ARGS_ 0 1 C 4 \ (u0 :: Double) -> case u0 of { _ALG_ D# (u1 :: Double#) -> case _#_ coshDouble# [] [u1] of { _PRIM_ (u2 :: Double#) -> _!_ D# [] [u2] }; _NO_DEFLT_ } _N_ },
+ tanh = { _A_ 1 _U_ 1 _N_ _S_ "U(P)" {_A_ 1 _U_ 2 _N_ _N_ _F_ _IF_ARGS_ 0 1 X 3 \ (u0 :: Double#) -> case _#_ tanhDouble# [] [u0] of { _PRIM_ (u1 :: Double#) -> _!_ D# [] [u1] } _N_} _F_ _IF_ARGS_ 0 1 C 4 \ (u0 :: Double) -> case u0 of { _ALG_ D# (u1 :: Double#) -> case _#_ tanhDouble# [] [u1] of { _PRIM_ (u2 :: Double#) -> _!_ D# [] [u2] }; _NO_DEFLT_ } _N_ },
+ asinh = { _A_ 1 _U_ 1 _N_ _S_ "U(P)" {_A_ 1 _U_ 2 _N_ _N_ _N_ _N_} _N_ _N_ },
+ acosh = { _A_ 1 _U_ 1 _N_ _S_ "U(P)" {_A_ 1 _U_ 2 _N_ _N_ _N_ _N_} _N_ _N_ },
+ atanh = { _A_ 1 _U_ 1 _N_ _S_ "U(P)" {_A_ 1 _U_ 2 _N_ _N_ _N_ _N_} _N_ _N_ } #-}
instance Floating Float
{-# GHC_PRAGMA _M_ PreludeCore {-dfun-} _A_ 0 _N_ _N_ _N_ _F_ _IF_ARGS_ 0 0 X 20 _!_ _TUP_19 [{{Fractional Float}}, Float, (Float -> Float), (Float -> Float), (Float -> Float), (Float -> Float -> Float), (Float -> Float -> Float), (Float -> Float), (Float -> Float), (Float -> Float), (Float -> Float), (Float -> Float), (Float -> Float), (Float -> Float), (Float -> Float), (Float -> Float), (Float -> Float), (Float -> Float), (Float -> Float)] [_DFUN_ Fractional (Float), _CONSTM_ Floating pi (Float), _CONSTM_ Floating exp (Float), _CONSTM_ Floating log (Float), _CONSTM_ Floating sqrt (Float), _CONSTM_ Floating (**) (Float), _CONSTM_ Floating logBase (Float), _CONSTM_ Floating sin (Float), _CONSTM_ Floating cos (Float), _CONSTM_ Floating tan (Float), _CONSTM_ Floating asin (Float), _CONSTM_ Floating acos (Float), _CONSTM_ Floating atan (Float), _CONSTM_ Floating sinh (Float), _CONSTM_ Floating cosh (Float), _CONSTM_ Floating tanh (Float), _CONSTM_ Floating asinh (Float), _CONSTM_ Floating acosh (Float), _CONSTM_ Floating atanh (Float)] _N_
- pi = _A_ 0 _N_ _N_ _N_ _F_ _IF_ARGS_ 0 0 X 2 _!_ F# [] [3.1415926535897931#] _N_,
- exp = _A_ 1 _U_ 1 _N_ _S_ "U(P)" {_A_ 1 _U_ 2 _N_ _N_ _F_ _IF_ARGS_ 0 1 X 3 \ (u0 :: Float#) -> case _#_ expFloat# [] [u0] of { _PRIM_ (u1 :: Float#) -> _!_ F# [] [u1] } _N_} _F_ _IF_ARGS_ 0 1 C 4 \ (u0 :: Float) -> case u0 of { _ALG_ F# (u1 :: Float#) -> case _#_ expFloat# [] [u1] of { _PRIM_ (u2 :: Float#) -> _!_ F# [] [u2] }; _NO_DEFLT_ } _N_,
- log = _A_ 1 _U_ 1 _N_ _S_ "U(P)" {_A_ 1 _U_ 2 _N_ _N_ _F_ _IF_ARGS_ 0 1 X 3 \ (u0 :: Float#) -> case _#_ logFloat# [] [u0] of { _PRIM_ (u1 :: Float#) -> _!_ F# [] [u1] } _N_} _F_ _IF_ARGS_ 0 1 C 4 \ (u0 :: Float) -> case u0 of { _ALG_ F# (u1 :: Float#) -> case _#_ logFloat# [] [u1] of { _PRIM_ (u2 :: Float#) -> _!_ F# [] [u2] }; _NO_DEFLT_ } _N_,
- sqrt = _A_ 1 _U_ 1 _N_ _S_ "U(P)" {_A_ 1 _U_ 2 _N_ _N_ _F_ _IF_ARGS_ 0 1 X 3 \ (u0 :: Float#) -> case _#_ sqrtFloat# [] [u0] of { _PRIM_ (u1 :: Float#) -> _!_ F# [] [u1] } _N_} _F_ _IF_ARGS_ 0 1 C 4 \ (u0 :: Float) -> case u0 of { _ALG_ F# (u1 :: Float#) -> case _#_ sqrtFloat# [] [u1] of { _PRIM_ (u2 :: Float#) -> _!_ F# [] [u2] }; _NO_DEFLT_ } _N_,
- (**) = _A_ 2 _U_ 11 _N_ _S_ "U(P)U(P)" {_A_ 2 _U_ 22 _N_ _N_ _F_ _IF_ARGS_ 0 2 XX 3 \ (u0 :: Float#) (u1 :: Float#) -> case _#_ powerFloat# [] [u0, u1] of { _PRIM_ (u2 :: Float#) -> _!_ F# [] [u2] } _N_} _F_ _IF_ARGS_ 0 2 CC 5 \ (u0 :: Float) (u1 :: Float) -> case u0 of { _ALG_ F# (u2 :: Float#) -> case u1 of { _ALG_ F# (u3 :: Float#) -> case _#_ powerFloat# [] [u2, u3] of { _PRIM_ (u4 :: Float#) -> _!_ F# [] [u4] }; _NO_DEFLT_ }; _NO_DEFLT_ } _N_,
- logBase = _A_ 2 _U_ 22 _N_ _N_ _N_ _N_,
- sin = _A_ 1 _U_ 1 _N_ _S_ "U(P)" {_A_ 1 _U_ 2 _N_ _N_ _F_ _IF_ARGS_ 0 1 X 3 \ (u0 :: Float#) -> case _#_ sinFloat# [] [u0] of { _PRIM_ (u1 :: Float#) -> _!_ F# [] [u1] } _N_} _F_ _IF_ARGS_ 0 1 C 4 \ (u0 :: Float) -> case u0 of { _ALG_ F# (u1 :: Float#) -> case _#_ sinFloat# [] [u1] of { _PRIM_ (u2 :: Float#) -> _!_ F# [] [u2] }; _NO_DEFLT_ } _N_,
- cos = _A_ 1 _U_ 1 _N_ _S_ "U(P)" {_A_ 1 _U_ 2 _N_ _N_ _F_ _IF_ARGS_ 0 1 X 3 \ (u0 :: Float#) -> case _#_ cosFloat# [] [u0] of { _PRIM_ (u1 :: Float#) -> _!_ F# [] [u1] } _N_} _F_ _IF_ARGS_ 0 1 C 4 \ (u0 :: Float) -> case u0 of { _ALG_ F# (u1 :: Float#) -> case _#_ cosFloat# [] [u1] of { _PRIM_ (u2 :: Float#) -> _!_ F# [] [u2] }; _NO_DEFLT_ } _N_,
- tan = _A_ 1 _U_ 1 _N_ _S_ "U(P)" {_A_ 1 _U_ 2 _N_ _N_ _F_ _IF_ARGS_ 0 1 X 3 \ (u0 :: Float#) -> case _#_ tanFloat# [] [u0] of { _PRIM_ (u1 :: Float#) -> _!_ F# [] [u1] } _N_} _F_ _IF_ARGS_ 0 1 C 4 \ (u0 :: Float) -> case u0 of { _ALG_ F# (u1 :: Float#) -> case _#_ tanFloat# [] [u1] of { _PRIM_ (u2 :: Float#) -> _!_ F# [] [u2] }; _NO_DEFLT_ } _N_,
- asin = _A_ 1 _U_ 1 _N_ _S_ "U(P)" {_A_ 1 _U_ 2 _N_ _N_ _F_ _IF_ARGS_ 0 1 X 3 \ (u0 :: Float#) -> case _#_ asinFloat# [] [u0] of { _PRIM_ (u1 :: Float#) -> _!_ F# [] [u1] } _N_} _F_ _IF_ARGS_ 0 1 C 4 \ (u0 :: Float) -> case u0 of { _ALG_ F# (u1 :: Float#) -> case _#_ asinFloat# [] [u1] of { _PRIM_ (u2 :: Float#) -> _!_ F# [] [u2] }; _NO_DEFLT_ } _N_,
- acos = _A_ 1 _U_ 1 _N_ _S_ "U(P)" {_A_ 1 _U_ 2 _N_ _N_ _F_ _IF_ARGS_ 0 1 X 3 \ (u0 :: Float#) -> case _#_ acosFloat# [] [u0] of { _PRIM_ (u1 :: Float#) -> _!_ F# [] [u1] } _N_} _F_ _IF_ARGS_ 0 1 C 4 \ (u0 :: Float) -> case u0 of { _ALG_ F# (u1 :: Float#) -> case _#_ acosFloat# [] [u1] of { _PRIM_ (u2 :: Float#) -> _!_ F# [] [u2] }; _NO_DEFLT_ } _N_,
- atan = _A_ 1 _U_ 1 _N_ _S_ "U(P)" {_A_ 1 _U_ 2 _N_ _N_ _F_ _IF_ARGS_ 0 1 X 3 \ (u0 :: Float#) -> case _#_ atanFloat# [] [u0] of { _PRIM_ (u1 :: Float#) -> _!_ F# [] [u1] } _N_} _F_ _IF_ARGS_ 0 1 C 4 \ (u0 :: Float) -> case u0 of { _ALG_ F# (u1 :: Float#) -> case _#_ atanFloat# [] [u1] of { _PRIM_ (u2 :: Float#) -> _!_ F# [] [u2] }; _NO_DEFLT_ } _N_,
- sinh = _A_ 1 _U_ 1 _N_ _S_ "U(P)" {_A_ 1 _U_ 2 _N_ _N_ _F_ _IF_ARGS_ 0 1 X 3 \ (u0 :: Float#) -> case _#_ sinhFloat# [] [u0] of { _PRIM_ (u1 :: Float#) -> _!_ F# [] [u1] } _N_} _F_ _IF_ARGS_ 0 1 C 4 \ (u0 :: Float) -> case u0 of { _ALG_ F# (u1 :: Float#) -> case _#_ sinhFloat# [] [u1] of { _PRIM_ (u2 :: Float#) -> _!_ F# [] [u2] }; _NO_DEFLT_ } _N_,
- cosh = _A_ 1 _U_ 1 _N_ _S_ "U(P)" {_A_ 1 _U_ 2 _N_ _N_ _F_ _IF_ARGS_ 0 1 X 3 \ (u0 :: Float#) -> case _#_ coshFloat# [] [u0] of { _PRIM_ (u1 :: Float#) -> _!_ F# [] [u1] } _N_} _F_ _IF_ARGS_ 0 1 C 4 \ (u0 :: Float) -> case u0 of { _ALG_ F# (u1 :: Float#) -> case _#_ coshFloat# [] [u1] of { _PRIM_ (u2 :: Float#) -> _!_ F# [] [u2] }; _NO_DEFLT_ } _N_,
- tanh = _A_ 1 _U_ 1 _N_ _S_ "U(P)" {_A_ 1 _U_ 2 _N_ _N_ _F_ _IF_ARGS_ 0 1 X 3 \ (u0 :: Float#) -> case _#_ tanhFloat# [] [u0] of { _PRIM_ (u1 :: Float#) -> _!_ F# [] [u1] } _N_} _F_ _IF_ARGS_ 0 1 C 4 \ (u0 :: Float) -> case u0 of { _ALG_ F# (u1 :: Float#) -> case _#_ tanhFloat# [] [u1] of { _PRIM_ (u2 :: Float#) -> _!_ F# [] [u2] }; _NO_DEFLT_ } _N_,
- asinh = _A_ 1 _U_ 1 _N_ _S_ "U(P)" {_A_ 1 _U_ 2 _N_ _N_ _N_ _N_} _N_ _N_,
- acosh = _A_ 1 _U_ 1 _N_ _S_ "U(P)" {_A_ 1 _U_ 2 _N_ _N_ _N_ _N_} _N_ _N_,
- atanh = _A_ 1 _U_ 1 _N_ _S_ "U(P)" {_A_ 1 _U_ 2 _N_ _N_ _N_ _N_} _N_ _N_ #-}
+ pi = { _A_ 0 _N_ _N_ _N_ _F_ _IF_ARGS_ 0 0 X 2 _!_ F# [] [3.1415926535897931#] _N_ },
+ exp = { _A_ 1 _U_ 1 _N_ _S_ "U(P)" {_A_ 1 _U_ 2 _N_ _N_ _F_ _IF_ARGS_ 0 1 X 3 \ (u0 :: Float#) -> case _#_ expFloat# [] [u0] of { _PRIM_ (u1 :: Float#) -> _!_ F# [] [u1] } _N_} _F_ _IF_ARGS_ 0 1 C 4 \ (u0 :: Float) -> case u0 of { _ALG_ F# (u1 :: Float#) -> case _#_ expFloat# [] [u1] of { _PRIM_ (u2 :: Float#) -> _!_ F# [] [u2] }; _NO_DEFLT_ } _N_ },
+ log = { _A_ 1 _U_ 1 _N_ _S_ "U(P)" {_A_ 1 _U_ 2 _N_ _N_ _F_ _IF_ARGS_ 0 1 X 3 \ (u0 :: Float#) -> case _#_ logFloat# [] [u0] of { _PRIM_ (u1 :: Float#) -> _!_ F# [] [u1] } _N_} _F_ _IF_ARGS_ 0 1 C 4 \ (u0 :: Float) -> case u0 of { _ALG_ F# (u1 :: Float#) -> case _#_ logFloat# [] [u1] of { _PRIM_ (u2 :: Float#) -> _!_ F# [] [u2] }; _NO_DEFLT_ } _N_ },
+ sqrt = { _A_ 1 _U_ 1 _N_ _S_ "U(P)" {_A_ 1 _U_ 2 _N_ _N_ _F_ _IF_ARGS_ 0 1 X 3 \ (u0 :: Float#) -> case _#_ sqrtFloat# [] [u0] of { _PRIM_ (u1 :: Float#) -> _!_ F# [] [u1] } _N_} _F_ _IF_ARGS_ 0 1 C 4 \ (u0 :: Float) -> case u0 of { _ALG_ F# (u1 :: Float#) -> case _#_ sqrtFloat# [] [u1] of { _PRIM_ (u2 :: Float#) -> _!_ F# [] [u2] }; _NO_DEFLT_ } _N_ },
+ (**) = { _A_ 2 _U_ 11 _N_ _S_ "U(P)U(P)" {_A_ 2 _U_ 22 _N_ _N_ _F_ _IF_ARGS_ 0 2 XX 3 \ (u0 :: Float#) (u1 :: Float#) -> case _#_ powerFloat# [] [u0, u1] of { _PRIM_ (u2 :: Float#) -> _!_ F# [] [u2] } _N_} _F_ _IF_ARGS_ 0 2 CC 5 \ (u0 :: Float) (u1 :: Float) -> case u0 of { _ALG_ F# (u2 :: Float#) -> case u1 of { _ALG_ F# (u3 :: Float#) -> case _#_ powerFloat# [] [u2, u3] of { _PRIM_ (u4 :: Float#) -> _!_ F# [] [u4] }; _NO_DEFLT_ }; _NO_DEFLT_ } _N_ },
+ logBase = { _A_ 2 _U_ 11 _N_ _S_ "U(P)U(P)" {_A_ 2 _U_ 22 _N_ _N_ _F_ _IF_ARGS_ 0 2 XX 5 \ (u0 :: Float#) (u1 :: Float#) -> case _#_ logFloat# [] [u1] of { _PRIM_ (u2 :: Float#) -> case _#_ logFloat# [] [u0] of { _PRIM_ (u3 :: Float#) -> case _#_ divideFloat# [] [u2, u3] of { _PRIM_ (u4 :: Float#) -> _!_ F# [] [u4] } } } _N_} _F_ _IF_ARGS_ 0 2 CC 7 \ (u0 :: Float) (u1 :: Float) -> case u1 of { _ALG_ F# (u2 :: Float#) -> case _#_ logFloat# [] [u2] of { _PRIM_ (u3 :: Float#) -> case u0 of { _ALG_ F# (u4 :: Float#) -> case _#_ logFloat# [] [u4] of { _PRIM_ (u5 :: Float#) -> case _#_ divideFloat# [] [u3, u5] of { _PRIM_ (u6 :: Float#) -> _!_ F# [] [u6] } }; _NO_DEFLT_ } }; _NO_DEFLT_ } _N_ },
+ sin = { _A_ 1 _U_ 1 _N_ _S_ "U(P)" {_A_ 1 _U_ 2 _N_ _N_ _F_ _IF_ARGS_ 0 1 X 3 \ (u0 :: Float#) -> case _#_ sinFloat# [] [u0] of { _PRIM_ (u1 :: Float#) -> _!_ F# [] [u1] } _N_} _F_ _IF_ARGS_ 0 1 C 4 \ (u0 :: Float) -> case u0 of { _ALG_ F# (u1 :: Float#) -> case _#_ sinFloat# [] [u1] of { _PRIM_ (u2 :: Float#) -> _!_ F# [] [u2] }; _NO_DEFLT_ } _N_ },
+ cos = { _A_ 1 _U_ 1 _N_ _S_ "U(P)" {_A_ 1 _U_ 2 _N_ _N_ _F_ _IF_ARGS_ 0 1 X 3 \ (u0 :: Float#) -> case _#_ cosFloat# [] [u0] of { _PRIM_ (u1 :: Float#) -> _!_ F# [] [u1] } _N_} _F_ _IF_ARGS_ 0 1 C 4 \ (u0 :: Float) -> case u0 of { _ALG_ F# (u1 :: Float#) -> case _#_ cosFloat# [] [u1] of { _PRIM_ (u2 :: Float#) -> _!_ F# [] [u2] }; _NO_DEFLT_ } _N_ },
+ tan = { _A_ 1 _U_ 1 _N_ _S_ "U(P)" {_A_ 1 _U_ 2 _N_ _N_ _F_ _IF_ARGS_ 0 1 X 3 \ (u0 :: Float#) -> case _#_ tanFloat# [] [u0] of { _PRIM_ (u1 :: Float#) -> _!_ F# [] [u1] } _N_} _F_ _IF_ARGS_ 0 1 C 4 \ (u0 :: Float) -> case u0 of { _ALG_ F# (u1 :: Float#) -> case _#_ tanFloat# [] [u1] of { _PRIM_ (u2 :: Float#) -> _!_ F# [] [u2] }; _NO_DEFLT_ } _N_ },
+ asin = { _A_ 1 _U_ 1 _N_ _S_ "U(P)" {_A_ 1 _U_ 2 _N_ _N_ _F_ _IF_ARGS_ 0 1 X 3 \ (u0 :: Float#) -> case _#_ asinFloat# [] [u0] of { _PRIM_ (u1 :: Float#) -> _!_ F# [] [u1] } _N_} _F_ _IF_ARGS_ 0 1 C 4 \ (u0 :: Float) -> case u0 of { _ALG_ F# (u1 :: Float#) -> case _#_ asinFloat# [] [u1] of { _PRIM_ (u2 :: Float#) -> _!_ F# [] [u2] }; _NO_DEFLT_ } _N_ },
+ acos = { _A_ 1 _U_ 1 _N_ _S_ "U(P)" {_A_ 1 _U_ 2 _N_ _N_ _F_ _IF_ARGS_ 0 1 X 3 \ (u0 :: Float#) -> case _#_ acosFloat# [] [u0] of { _PRIM_ (u1 :: Float#) -> _!_ F# [] [u1] } _N_} _F_ _IF_ARGS_ 0 1 C 4 \ (u0 :: Float) -> case u0 of { _ALG_ F# (u1 :: Float#) -> case _#_ acosFloat# [] [u1] of { _PRIM_ (u2 :: Float#) -> _!_ F# [] [u2] }; _NO_DEFLT_ } _N_ },
+ atan = { _A_ 1 _U_ 1 _N_ _S_ "U(P)" {_A_ 1 _U_ 2 _N_ _N_ _F_ _IF_ARGS_ 0 1 X 3 \ (u0 :: Float#) -> case _#_ atanFloat# [] [u0] of { _PRIM_ (u1 :: Float#) -> _!_ F# [] [u1] } _N_} _F_ _IF_ARGS_ 0 1 C 4 \ (u0 :: Float) -> case u0 of { _ALG_ F# (u1 :: Float#) -> case _#_ atanFloat# [] [u1] of { _PRIM_ (u2 :: Float#) -> _!_ F# [] [u2] }; _NO_DEFLT_ } _N_ },
+ sinh = { _A_ 1 _U_ 1 _N_ _S_ "U(P)" {_A_ 1 _U_ 2 _N_ _N_ _F_ _IF_ARGS_ 0 1 X 3 \ (u0 :: Float#) -> case _#_ sinhFloat# [] [u0] of { _PRIM_ (u1 :: Float#) -> _!_ F# [] [u1] } _N_} _F_ _IF_ARGS_ 0 1 C 4 \ (u0 :: Float) -> case u0 of { _ALG_ F# (u1 :: Float#) -> case _#_ sinhFloat# [] [u1] of { _PRIM_ (u2 :: Float#) -> _!_ F# [] [u2] }; _NO_DEFLT_ } _N_ },
+ cosh = { _A_ 1 _U_ 1 _N_ _S_ "U(P)" {_A_ 1 _U_ 2 _N_ _N_ _F_ _IF_ARGS_ 0 1 X 3 \ (u0 :: Float#) -> case _#_ coshFloat# [] [u0] of { _PRIM_ (u1 :: Float#) -> _!_ F# [] [u1] } _N_} _F_ _IF_ARGS_ 0 1 C 4 \ (u0 :: Float) -> case u0 of { _ALG_ F# (u1 :: Float#) -> case _#_ coshFloat# [] [u1] of { _PRIM_ (u2 :: Float#) -> _!_ F# [] [u2] }; _NO_DEFLT_ } _N_ },
+ tanh = { _A_ 1 _U_ 1 _N_ _S_ "U(P)" {_A_ 1 _U_ 2 _N_ _N_ _F_ _IF_ARGS_ 0 1 X 3 \ (u0 :: Float#) -> case _#_ tanhFloat# [] [u0] of { _PRIM_ (u1 :: Float#) -> _!_ F# [] [u1] } _N_} _F_ _IF_ARGS_ 0 1 C 4 \ (u0 :: Float) -> case u0 of { _ALG_ F# (u1 :: Float#) -> case _#_ tanhFloat# [] [u1] of { _PRIM_ (u2 :: Float#) -> _!_ F# [] [u2] }; _NO_DEFLT_ } _N_ },
+ asinh = { _A_ 1 _U_ 1 _N_ _S_ "U(P)" {_A_ 1 _U_ 2 _N_ _N_ _N_ _N_} _N_ _N_ },
+ acosh = { _A_ 1 _U_ 1 _N_ _S_ "U(P)" {_A_ 1 _U_ 2 _N_ _N_ _N_ _N_} _N_ _N_ },
+ atanh = { _A_ 1 _U_ 1 _N_ _S_ "U(P)" {_A_ 1 _U_ 2 _N_ _N_ _N_ _N_} _N_ _N_ } #-}
instance RealFloat a => Fractional (Complex a)
{-# GHC_PRAGMA _M_ PreludeComplex {-dfun-} _A_ 2 _U_ 22 _N_ _N_ _N_ _N_ #-}
instance Fractional (Complex Double)
{-# GHC_PRAGMA _M_ PreludeComplex {-dfun-} _A_ 0 _N_ _N_ _N_ _F_ _IF_ARGS_ 0 0 X 5 _!_ _TUP_4 [{{Num (Complex Double)}}, (Complex Double -> Complex Double -> Complex Double), (Complex Double -> Complex Double), (Ratio Integer -> Complex Double)] [_DFUN_ Num (Complex Double), _CONSTM_ Fractional (/) (Complex Double), _CONSTM_ Fractional recip (Complex Double), _CONSTM_ Fractional fromRational (Complex Double)] _N_
- (/) = _A_ 2 _U_ 11 _N_ _S_ "U(LL)U(LL)" {_A_ 4 _U_ 2222 _N_ _N_ _N_ _N_} _N_ _N_,
- recip = _A_ 1 _U_ 1 _N_ _S_ "U(LL)" {_A_ 2 _U_ 22 _N_ _N_ _N_ _N_} _N_ _N_,
- fromRational = _A_ 1 _U_ 2 _N_ _N_ _N_ _N_ #-}
+ (/) = { _A_ 2 _U_ 11 _N_ _S_ "U(LL)U(LL)" {_A_ 4 _U_ 2222 _N_ _N_ _N_ _N_} _N_ _N_ },
+ recip = { _A_ 1 _U_ 1 _N_ _S_ "U(LL)" {_A_ 2 _U_ 22 _N_ _N_ _N_ _N_} _F_ _IF_ARGS_ 0 1 X 3 \ (u0 :: Complex Double) -> _APP_ _CONSTM_ Fractional (/) (Complex Double) [ _SPEC_ _ORIG_ PreludeCore __i1 [ (Complex Double) ], u0 ] _N_ },
+ fromRational = { _A_ 1 _U_ 1 _N_ _N_ _N_ _N_ } #-}
instance Fractional Double
{-# GHC_PRAGMA _M_ PreludeCore {-dfun-} _A_ 0 _N_ _N_ _N_ _F_ _IF_ARGS_ 0 0 X 5 _!_ _TUP_4 [{{Num Double}}, (Double -> Double -> Double), (Double -> Double), (Ratio Integer -> Double)] [_DFUN_ Num (Double), _CONSTM_ Fractional (/) (Double), _CONSTM_ Fractional recip (Double), _CONSTM_ Fractional fromRational (Double)] _N_
- (/) = _A_ 2 _U_ 11 _N_ _S_ "U(P)U(P)" {_A_ 2 _U_ 22 _N_ _N_ _F_ _IF_ARGS_ 0 2 XX 3 \ (u0 :: Double#) (u1 :: Double#) -> case _#_ divideDouble# [] [u0, u1] of { _PRIM_ (u2 :: Double#) -> _!_ D# [] [u2] } _N_} _F_ _IF_ARGS_ 0 2 CC 5 \ (u0 :: Double) (u1 :: Double) -> case u0 of { _ALG_ D# (u2 :: Double#) -> case u1 of { _ALG_ D# (u3 :: Double#) -> case _#_ divideDouble# [] [u2, u3] of { _PRIM_ (u4 :: Double#) -> _!_ D# [] [u4] }; _NO_DEFLT_ }; _NO_DEFLT_ } _N_,
- recip = _A_ 1 _U_ 1 _N_ _S_ "U(P)" {_A_ 1 _U_ 2 _N_ _N_ _F_ _IF_ARGS_ 0 1 X 3 \ (u0 :: Double#) -> case _#_ divideDouble# [] [1.0000000000000000##, u0] of { _PRIM_ (u1 :: Double#) -> _!_ D# [] [u1] } _N_} _F_ _IF_ARGS_ 0 1 C 4 \ (u0 :: Double) -> case u0 of { _ALG_ D# (u1 :: Double#) -> case _#_ divideDouble# [] [1.0000000000000000##, u1] of { _PRIM_ (u2 :: Double#) -> _!_ D# [] [u2] }; _NO_DEFLT_ } _N_,
- fromRational = _A_ 0 _U_ 2 _N_ _N_ _N_ _N_ #-}
+ (/) = { _A_ 2 _U_ 11 _N_ _S_ "U(P)U(P)" {_A_ 2 _U_ 22 _N_ _N_ _F_ _IF_ARGS_ 0 2 XX 3 \ (u0 :: Double#) (u1 :: Double#) -> case _#_ divideDouble# [] [u0, u1] of { _PRIM_ (u2 :: Double#) -> _!_ D# [] [u2] } _N_} _F_ _IF_ARGS_ 0 2 CC 5 \ (u0 :: Double) (u1 :: Double) -> case u0 of { _ALG_ D# (u2 :: Double#) -> case u1 of { _ALG_ D# (u3 :: Double#) -> case _#_ divideDouble# [] [u2, u3] of { _PRIM_ (u4 :: Double#) -> _!_ D# [] [u4] }; _NO_DEFLT_ }; _NO_DEFLT_ } _N_ },
+ recip = { _A_ 1 _U_ 1 _N_ _S_ "U(P)" {_A_ 1 _U_ 2 _N_ _N_ _F_ _IF_ARGS_ 0 1 X 3 \ (u0 :: Double#) -> case _#_ divideDouble# [] [1.0000000000000000##, u0] of { _PRIM_ (u1 :: Double#) -> _!_ D# [] [u1] } _N_} _F_ _IF_ARGS_ 0 1 C 4 \ (u0 :: Double) -> case u0 of { _ALG_ D# (u1 :: Double#) -> case _#_ divideDouble# [] [1.0000000000000000##, u1] of { _PRIM_ (u2 :: Double#) -> _!_ D# [] [u2] }; _NO_DEFLT_ } _N_ },
+ fromRational = { _A_ 1 _U_ 1 _N_ _S_ "U(U(PPP)U(PPP))" {_A_ 4 _U_ 2222 _N_ _N_ _N_ _N_} _N_ _N_ } #-}
instance Fractional Float
{-# GHC_PRAGMA _M_ PreludeCore {-dfun-} _A_ 0 _N_ _N_ _N_ _F_ _IF_ARGS_ 0 0 X 5 _!_ _TUP_4 [{{Num Float}}, (Float -> Float -> Float), (Float -> Float), (Ratio Integer -> Float)] [_DFUN_ Num (Float), _CONSTM_ Fractional (/) (Float), _CONSTM_ Fractional recip (Float), _CONSTM_ Fractional fromRational (Float)] _N_
- (/) = _A_ 2 _U_ 11 _N_ _S_ "U(P)U(P)" {_A_ 2 _U_ 22 _N_ _N_ _F_ _IF_ARGS_ 0 2 XX 3 \ (u0 :: Float#) (u1 :: Float#) -> case _#_ divideFloat# [] [u0, u1] of { _PRIM_ (u2 :: Float#) -> _!_ F# [] [u2] } _N_} _F_ _IF_ARGS_ 0 2 CC 5 \ (u0 :: Float) (u1 :: Float) -> case u0 of { _ALG_ F# (u2 :: Float#) -> case u1 of { _ALG_ F# (u3 :: Float#) -> case _#_ divideFloat# [] [u2, u3] of { _PRIM_ (u4 :: Float#) -> _!_ F# [] [u4] }; _NO_DEFLT_ }; _NO_DEFLT_ } _N_,
- recip = _A_ 0 _U_ 2 _N_ _N_ _N_ _N_,
- fromRational = _A_ 0 _U_ 2 _N_ _N_ _N_ _N_ #-}
+ (/) = { _A_ 2 _U_ 11 _N_ _S_ "U(P)U(P)" {_A_ 2 _U_ 22 _N_ _N_ _F_ _IF_ARGS_ 0 2 XX 3 \ (u0 :: Float#) (u1 :: Float#) -> case _#_ divideFloat# [] [u0, u1] of { _PRIM_ (u2 :: Float#) -> _!_ F# [] [u2] } _N_} _F_ _IF_ARGS_ 0 2 CC 5 \ (u0 :: Float) (u1 :: Float) -> case u0 of { _ALG_ F# (u2 :: Float#) -> case u1 of { _ALG_ F# (u3 :: Float#) -> case _#_ divideFloat# [] [u2, u3] of { _PRIM_ (u4 :: Float#) -> _!_ F# [] [u4] }; _NO_DEFLT_ }; _NO_DEFLT_ } _N_ },
+ recip = { _A_ 1 _U_ 1 _N_ _S_ "U(P)" {_A_ 1 _U_ 2 _N_ _N_ _F_ _IF_ARGS_ 0 1 X 3 \ (u0 :: Float#) -> case _#_ divideFloat# [] [1.0000000000000000#, u0] of { _PRIM_ (u1 :: Float#) -> _!_ F# [] [u1] } _N_} _F_ _IF_ARGS_ 0 1 C 4 \ (u0 :: Float) -> case u0 of { _ALG_ F# (u1 :: Float#) -> case _#_ divideFloat# [] [1.0000000000000000#, u1] of { _PRIM_ (u2 :: Float#) -> _!_ F# [] [u2] }; _NO_DEFLT_ } _N_ },
+ fromRational = { _A_ 1 _U_ 2 _N_ _N_ _N_ _N_ } #-}
instance Integral a => Fractional (Ratio a)
{-# GHC_PRAGMA _M_ PreludeRatio {-dfun-} _A_ 2 _U_ 22 _N_ _N_ _N_ _N_ #-}
instance Fractional (Ratio Integer)
{-# GHC_PRAGMA _M_ PreludeRatio {-dfun-} _A_ 0 _N_ _N_ _N_ _F_ _IF_ARGS_ 0 0 X 5 _!_ _TUP_4 [{{Num (Ratio Integer)}}, (Ratio Integer -> Ratio Integer -> Ratio Integer), (Ratio Integer -> Ratio Integer), (Ratio Integer -> Ratio Integer)] [_DFUN_ Num (Ratio Integer), _CONSTM_ Fractional (/) (Ratio Integer), _CONSTM_ Fractional recip (Ratio Integer), _CONSTM_ Fractional fromRational (Ratio Integer)] _N_
- (/) = _A_ 2 _U_ 11 _N_ _S_ "U(LU(PPP))U(U(PPP)L)" {_A_ 5 _U_ 22221 _N_ _N_ _N_ _N_} _N_ _N_,
- recip = _A_ 1 _U_ 1 _N_ _S_ "U(U(PPP)L)" {_A_ 4 _U_ 2222 _N_ _N_ _N_ _N_} _N_ _N_,
- fromRational = _A_ 1 _U_ 1 _N_ _S_ "U(LL)" {_A_ 2 _U_ 22 _N_ _N_ _F_ _IF_ARGS_ 0 2 XX 3 \ (u0 :: Integer) (u1 :: Integer) -> _!_ (:%) [Integer] [u0, u1] _N_} _F_ _IF_ARGS_ 0 1 X 1 \ (u0 :: Ratio Integer) -> u0 _N_ #-}
+ (/) = { _A_ 2 _U_ 11 _N_ _S_ "U(LU(PPP))U(U(PPP)L)" {_A_ 5 _U_ 22221 _N_ _N_ _N_ _N_} _N_ _N_ },
+ recip = { _A_ 1 _U_ 1 _N_ _S_ "U(U(PPP)L)" {_A_ 4 _U_ 2222 _N_ _N_ _N_ _N_} _N_ _N_ },
+ fromRational = { _A_ 1 _U_ 1 _N_ _S_ "U(LL)" {_A_ 2 _U_ 22 _N_ _N_ _F_ _IF_ARGS_ 0 2 XX 3 \ (u0 :: Integer) (u1 :: Integer) -> _!_ (:%) [Integer] [u0, u1] _N_} _F_ _IF_ARGS_ 0 1 X 1 \ (u0 :: Ratio Integer) -> u0 _N_ } #-}
instance Integral Int
{-# GHC_PRAGMA _M_ PreludeCore {-dfun-} _A_ 0 _N_ _N_ _N_ _F_ _IF_ARGS_ 0 0 X 13 _!_ _TUP_12 [{{Real Int}}, {{Ix Int}}, (Int -> Int -> Int), (Int -> Int -> Int), (Int -> Int -> Int), (Int -> Int -> Int), (Int -> Int -> (Int, Int)), (Int -> Int -> (Int, Int)), (Int -> Bool), (Int -> Bool), (Int -> Integer), (Int -> Int)] [_DFUN_ Real (Int), _DFUN_ Ix (Int), _CONSTM_ Integral quot (Int), _CONSTM_ Integral rem (Int), _CONSTM_ Integral div (Int), _CONSTM_ Integral mod (Int), _CONSTM_ Integral quotRem (Int), _CONSTM_ Integral divMod (Int), _CONSTM_ Integral even (Int), _CONSTM_ Integral odd (Int), _CONSTM_ Integral toInteger (Int), _CONSTM_ Integral toInt (Int)] _N_
- quot = _A_ 2 _U_ 11 _N_ _S_ "U(P)U(P)" {_A_ 2 _U_ 22 _N_ _N_ _F_ _IF_ARGS_ 0 2 XC 5 \ (u0 :: Int#) (u1 :: Int#) -> case u1 of { _PRIM_ 0# -> _APP_ _TYAPP_ error { Int } [ _NOREP_S_ "Integral.Int.quot{PreludeCore}: divide by 0\n" ]; (u2 :: Int#) -> case _#_ quotInt# [] [u0, u1] of { _PRIM_ (u3 :: Int#) -> _!_ I# [] [u3] } } _N_} _F_ _IF_ARGS_ 0 2 CC 7 \ (u0 :: Int) (u1 :: Int) -> case u1 of { _ALG_ I# (u2 :: Int#) -> case u2 of { _PRIM_ 0# -> _APP_ _TYAPP_ error { Int } [ _NOREP_S_ "Integral.Int.quot{PreludeCore}: divide by 0\n" ]; (u3 :: Int#) -> case u0 of { _ALG_ I# (u4 :: Int#) -> case _#_ quotInt# [] [u4, u2] of { _PRIM_ (u5 :: Int#) -> _!_ I# [] [u5] }; _NO_DEFLT_ } }; _NO_DEFLT_ } _N_,
- rem = _A_ 2 _U_ 11 _N_ _S_ "U(P)U(P)" {_A_ 2 _U_ 22 _N_ _N_ _F_ _IF_ARGS_ 0 2 XC 5 \ (u0 :: Int#) (u1 :: Int#) -> case u1 of { _PRIM_ 0# -> _APP_ _TYAPP_ error { Int } [ _NOREP_S_ "Integral.Int.rem{PreludeCore}: divide by 0\n" ]; (u2 :: Int#) -> case _#_ remInt# [] [u0, u1] of { _PRIM_ (u3 :: Int#) -> _!_ I# [] [u3] } } _N_} _F_ _IF_ARGS_ 0 2 CC 7 \ (u0 :: Int) (u1 :: Int) -> case u1 of { _ALG_ I# (u2 :: Int#) -> case u2 of { _PRIM_ 0# -> _APP_ _TYAPP_ error { Int } [ _NOREP_S_ "Integral.Int.rem{PreludeCore}: divide by 0\n" ]; (u3 :: Int#) -> case u0 of { _ALG_ I# (u4 :: Int#) -> case _#_ remInt# [] [u4, u2] of { _PRIM_ (u5 :: Int#) -> _!_ I# [] [u5] }; _NO_DEFLT_ } }; _NO_DEFLT_ } _N_,
- div = _A_ 2 _U_ 11 _N_ _S_ "U(P)U(P)" {_A_ 2 _U_ 22 _N_ _N_ _N_ _N_} _N_ _N_,
- mod = _A_ 2 _U_ 11 _N_ _S_ "U(P)U(P)" {_A_ 2 _U_ 22 _N_ _N_ _N_ _N_} _N_ _N_,
- quotRem = _A_ 2 _U_ 11 _N_ _S_ "U(P)U(P)" {_A_ 2 _U_ 22 _N_ _N_ _N_ _N_} _N_ _N_,
- divMod = _A_ 2 _U_ 11 _N_ _S_ "U(P)U(P)" {_A_ 2 _U_ 22 _N_ _N_ _N_ _N_} _N_ _N_,
- even = _A_ 1 _U_ 1 _N_ _S_ "U(P)" {_A_ 1 _U_ 2 _N_ _N_ _N_ _N_} _N_ _N_,
- odd = _A_ 1 _U_ 1 _N_ _S_ "U(P)" {_A_ 1 _U_ 2 _N_ _N_ _N_ _N_} _N_ _N_,
- toInteger = _A_ 1 _U_ 1 _N_ _S_ "U(P)" {_A_ 1 _U_ 2 _N_ _N_ _F_ _IF_ARGS_ 0 1 X 1 \ (u0 :: Int#) -> _#_ int2Integer# [] [u0] _N_} _F_ _IF_ARGS_ 0 1 C 2 \ (u0 :: Int) -> case u0 of { _ALG_ I# (u1 :: Int#) -> _#_ int2Integer# [] [u1]; _NO_DEFLT_ } _N_,
- toInt = _A_ 1 _U_ 1 _N_ _S_ "U(P)" {_A_ 1 _U_ 2 _N_ _N_ _F_ _IF_ARGS_ 0 1 X 2 \ (u0 :: Int#) -> _!_ I# [] [u0] _N_} _F_ _IF_ARGS_ 0 1 X 1 \ (u0 :: Int) -> u0 _N_ #-}
+ quot = { _A_ 2 _U_ 11 _N_ _S_ "U(P)U(P)" {_A_ 2 _U_ 22 _N_ _N_ _F_ _IF_ARGS_ 0 2 XC 5 \ (u0 :: Int#) (u1 :: Int#) -> case u1 of { _PRIM_ 0# -> _APP_ _TYAPP_ error { Int } [ _NOREP_S_ "Integral.Int.quot{PreludeCore}: divide by 0\n" ]; (u2 :: Int#) -> case _#_ quotInt# [] [u0, u1] of { _PRIM_ (u3 :: Int#) -> _!_ I# [] [u3] } } _N_} _F_ _IF_ARGS_ 0 2 CC 7 \ (u0 :: Int) (u1 :: Int) -> case u1 of { _ALG_ I# (u2 :: Int#) -> case u2 of { _PRIM_ 0# -> _APP_ _TYAPP_ error { Int } [ _NOREP_S_ "Integral.Int.quot{PreludeCore}: divide by 0\n" ]; (u3 :: Int#) -> case u0 of { _ALG_ I# (u4 :: Int#) -> case _#_ quotInt# [] [u4, u2] of { _PRIM_ (u5 :: Int#) -> _!_ I# [] [u5] }; _NO_DEFLT_ } }; _NO_DEFLT_ } _N_ },
+ rem = { _A_ 2 _U_ 11 _N_ _S_ "U(P)U(P)" {_A_ 2 _U_ 22 _N_ _N_ _F_ _IF_ARGS_ 0 2 XC 5 \ (u0 :: Int#) (u1 :: Int#) -> case u1 of { _PRIM_ 0# -> _APP_ _TYAPP_ error { Int } [ _NOREP_S_ "Integral.Int.rem{PreludeCore}: divide by 0\n" ]; (u2 :: Int#) -> case _#_ remInt# [] [u0, u1] of { _PRIM_ (u3 :: Int#) -> _!_ I# [] [u3] } } _N_} _F_ _IF_ARGS_ 0 2 CC 7 \ (u0 :: Int) (u1 :: Int) -> case u1 of { _ALG_ I# (u2 :: Int#) -> case u2 of { _PRIM_ 0# -> _APP_ _TYAPP_ error { Int } [ _NOREP_S_ "Integral.Int.rem{PreludeCore}: divide by 0\n" ]; (u3 :: Int#) -> case u0 of { _ALG_ I# (u4 :: Int#) -> case _#_ remInt# [] [u4, u2] of { _PRIM_ (u5 :: Int#) -> _!_ I# [] [u5] }; _NO_DEFLT_ } }; _NO_DEFLT_ } _N_ },
+ div = { _A_ 2 _U_ 11 _N_ _S_ "U(P)U(P)" {_A_ 2 _U_ 22 _N_ _N_ _N_ _N_} _N_ _N_ },
+ mod = { _A_ 2 _U_ 11 _N_ _S_ "U(P)U(P)" {_A_ 2 _U_ 22 _N_ _N_ _N_ _N_} _N_ _N_ },
+ quotRem = { _A_ 2 _U_ 11 _N_ _S_ "U(P)U(P)" {_A_ 2 _U_ 22 _N_ _N_ _N_ _N_} _N_ _N_ },
+ divMod = { _A_ 2 _U_ 11 _N_ _S_ "U(P)U(P)" {_A_ 2 _U_ 22 _N_ _N_ _N_ _N_} _N_ _N_ },
+ even = { _A_ 1 _U_ 1 _N_ _S_ "U(P)" {_A_ 1 _U_ 2 _N_ _N_ _N_ _N_} _N_ _N_ },
+ odd = { _A_ 1 _U_ 1 _N_ _S_ "U(P)" {_A_ 1 _U_ 2 _N_ _N_ _N_ _N_} _N_ _N_ },
+ toInteger = { _A_ 1 _U_ 1 _N_ _S_ "U(P)" {_A_ 1 _U_ 2 _N_ _N_ _F_ _IF_ARGS_ 0 1 X 1 \ (u0 :: Int#) -> _#_ int2Integer# [] [u0] _N_} _F_ _IF_ARGS_ 0 1 C 2 \ (u0 :: Int) -> case u0 of { _ALG_ I# (u1 :: Int#) -> _#_ int2Integer# [] [u1]; _NO_DEFLT_ } _N_ },
+ toInt = { _A_ 1 _U_ 1 _N_ _S_ "U(P)" {_A_ 1 _U_ 2 _N_ _N_ _F_ _IF_ARGS_ 0 1 X 2 \ (u0 :: Int#) -> _!_ I# [] [u0] _N_} _F_ _IF_ARGS_ 0 1 X 1 \ (u0 :: Int) -> u0 _N_ } #-}
instance Integral Integer
{-# GHC_PRAGMA _M_ PreludeCore {-dfun-} _A_ 0 _N_ _N_ _N_ _F_ _IF_ARGS_ 0 0 X 13 _!_ _TUP_12 [{{Real Integer}}, {{Ix Integer}}, (Integer -> Integer -> Integer), (Integer -> Integer -> Integer), (Integer -> Integer -> Integer), (Integer -> Integer -> Integer), (Integer -> Integer -> (Integer, Integer)), (Integer -> Integer -> (Integer, Integer)), (Integer -> Bool), (Integer -> Bool), (Integer -> Integer), (Integer -> Int)] [_DFUN_ Real (Integer), _DFUN_ Ix (Integer), _CONSTM_ Integral quot (Integer), _CONSTM_ Integral rem (Integer), _CONSTM_ Integral div (Integer), _CONSTM_ Integral mod (Integer), _CONSTM_ Integral quotRem (Integer), _CONSTM_ Integral divMod (Integer), _CONSTM_ Integral even (Integer), _CONSTM_ Integral odd (Integer), _CONSTM_ Integral toInteger (Integer), _CONSTM_ Integral toInt (Integer)] _N_
- quot = _A_ 2 _U_ 11 _N_ _S_ "U(PPP)U(PPP)" {_A_ 4 _U_ 2221 _N_ _N_ _F_ _IF_ARGS_ 0 4 XXXX 7 \ (u0 :: Int#) (u1 :: Int#) (u2 :: ByteArray#) (u3 :: Integer) -> case _APP_ _WRKR_ _CONSTM_ Integral quotRem (Integer) [ u0, u1, u2, u3 ] of { _ALG_ _TUP_2 (u4 :: Integer) (u5 :: Integer) -> u4; _NO_DEFLT_ } _N_} _F_ _IF_ARGS_ 0 2 XX 5 \ (u0 :: Integer) (u1 :: Integer) -> case _APP_ _CONSTM_ Integral quotRem (Integer) [ u0, u1 ] of { _ALG_ _TUP_2 (u2 :: Integer) (u3 :: Integer) -> u2; _NO_DEFLT_ } _N_,
- rem = _A_ 2 _U_ 11 _N_ _S_ "U(PPP)U(PPP)" {_A_ 4 _U_ 2221 _N_ _N_ _F_ _IF_ARGS_ 0 4 XXXX 7 \ (u0 :: Int#) (u1 :: Int#) (u2 :: ByteArray#) (u3 :: Integer) -> case _APP_ _WRKR_ _CONSTM_ Integral quotRem (Integer) [ u0, u1, u2, u3 ] of { _ALG_ _TUP_2 (u4 :: Integer) (u5 :: Integer) -> u5; _NO_DEFLT_ } _N_} _F_ _IF_ARGS_ 0 2 XX 5 \ (u0 :: Integer) (u1 :: Integer) -> case _APP_ _CONSTM_ Integral quotRem (Integer) [ u0, u1 ] of { _ALG_ _TUP_2 (u2 :: Integer) (u3 :: Integer) -> u3; _NO_DEFLT_ } _N_,
- div = _A_ 2 _U_ 12 _N_ _S_ "U(PPP)U(PPP)" {_A_ 4 _U_ 2222 _N_ _N_ _F_ _IF_ARGS_ 0 4 XXXX 7 \ (u0 :: Int#) (u1 :: Int#) (u2 :: ByteArray#) (u3 :: Integer) -> case _APP_ _WRKR_ _CONSTM_ Integral divMod (Integer) [ u0, u1, u2, u3 ] of { _ALG_ _TUP_2 (u4 :: Integer) (u5 :: Integer) -> u4; _NO_DEFLT_ } _N_} _F_ _IF_ARGS_ 0 2 XX 5 \ (u0 :: Integer) (u1 :: Integer) -> case _APP_ _CONSTM_ Integral divMod (Integer) [ u0, u1 ] of { _ALG_ _TUP_2 (u2 :: Integer) (u3 :: Integer) -> u2; _NO_DEFLT_ } _N_,
- mod = _A_ 2 _U_ 12 _N_ _S_ "U(PPP)U(PPP)" {_A_ 4 _U_ 2222 _N_ _N_ _F_ _IF_ARGS_ 0 4 XXXX 7 \ (u0 :: Int#) (u1 :: Int#) (u2 :: ByteArray#) (u3 :: Integer) -> case _APP_ _WRKR_ _CONSTM_ Integral divMod (Integer) [ u0, u1, u2, u3 ] of { _ALG_ _TUP_2 (u4 :: Integer) (u5 :: Integer) -> u5; _NO_DEFLT_ } _N_} _F_ _IF_ARGS_ 0 2 XX 5 \ (u0 :: Integer) (u1 :: Integer) -> case _APP_ _CONSTM_ Integral divMod (Integer) [ u0, u1 ] of { _ALG_ _TUP_2 (u2 :: Integer) (u3 :: Integer) -> u3; _NO_DEFLT_ } _N_,
- quotRem = _A_ 2 _U_ 11 _N_ _S_ "U(PPP)U(PPP)" {_A_ 4 _U_ 2221 _N_ _N_ _N_ _N_} _N_ _N_,
- divMod = _A_ 2 _U_ 12 _N_ _S_ "U(PPP)U(PPP)" {_A_ 4 _U_ 2222 _N_ _N_ _N_ _N_} _N_ _N_,
- even = _A_ 1 _U_ 1 _N_ _S_ "U(PPP)" {_A_ 3 _U_ 222 _N_ _N_ _N_ _N_} _N_ _N_,
- odd = _A_ 1 _U_ 1 _N_ _S_ "U(PPP)" {_A_ 3 _U_ 222 _N_ _N_ _N_ _N_} _N_ _N_,
- toInteger = _A_ 1 _U_ 1 _N_ _S_ "U(PPP)" {_A_ 3 _U_ 222 _N_ _N_ _F_ _IF_ARGS_ 0 3 XXX 4 \ (u0 :: Int#) (u1 :: Int#) (u2 :: ByteArray#) -> _!_ J# [] [u0, u1, u2] _N_} _F_ _IF_ARGS_ 0 1 X 1 \ (u0 :: Integer) -> u0 _N_,
- toInt = _A_ 1 _U_ 1 _N_ _S_ "U(PPP)" {_A_ 3 _U_ 222 _N_ _N_ _F_ _IF_ARGS_ 0 3 XXX 3 \ (u0 :: Int#) (u1 :: Int#) (u2 :: ByteArray#) -> case _#_ integer2Int# [] [u0, u1, u2] of { _PRIM_ (u3 :: Int#) -> _!_ I# [] [u3] } _N_} _F_ _IF_ARGS_ 0 1 C 4 \ (u0 :: Integer) -> case u0 of { _ALG_ J# (u1 :: Int#) (u2 :: Int#) (u3 :: ByteArray#) -> case _#_ integer2Int# [] [u1, u2, u3] of { _PRIM_ (u4 :: Int#) -> _!_ I# [] [u4] }; _NO_DEFLT_ } _N_ #-}
+ quot = { _A_ 2 _U_ 11 _N_ _S_ "U(PPP)U(PPP)" {_A_ 4 _U_ 2221 _N_ _N_ _F_ _IF_ARGS_ 0 4 XXXX 7 \ (u0 :: Int#) (u1 :: Int#) (u2 :: ByteArray#) (u3 :: Integer) -> case _APP_ _WRKR_ _CONSTM_ Integral quotRem (Integer) [ u0, u1, u2, u3 ] of { _ALG_ _TUP_2 (u4 :: Integer) (u5 :: Integer) -> u4; _NO_DEFLT_ } _N_} _F_ _IF_ARGS_ 0 2 XX 5 \ (u0 :: Integer) (u1 :: Integer) -> case _APP_ _CONSTM_ Integral quotRem (Integer) [ u0, u1 ] of { _ALG_ _TUP_2 (u2 :: Integer) (u3 :: Integer) -> u2; _NO_DEFLT_ } _N_ },
+ rem = { _A_ 2 _U_ 11 _N_ _S_ "U(PPP)U(PPP)" {_A_ 4 _U_ 2221 _N_ _N_ _F_ _IF_ARGS_ 0 4 XXXX 7 \ (u0 :: Int#) (u1 :: Int#) (u2 :: ByteArray#) (u3 :: Integer) -> case _APP_ _WRKR_ _CONSTM_ Integral quotRem (Integer) [ u0, u1, u2, u3 ] of { _ALG_ _TUP_2 (u4 :: Integer) (u5 :: Integer) -> u5; _NO_DEFLT_ } _N_} _F_ _IF_ARGS_ 0 2 XX 5 \ (u0 :: Integer) (u1 :: Integer) -> case _APP_ _CONSTM_ Integral quotRem (Integer) [ u0, u1 ] of { _ALG_ _TUP_2 (u2 :: Integer) (u3 :: Integer) -> u3; _NO_DEFLT_ } _N_ },
+ div = { _A_ 2 _U_ 12 _N_ _S_ "U(PPP)U(PPP)" {_A_ 4 _U_ 2222 _N_ _N_ _F_ _IF_ARGS_ 0 4 XXXX 7 \ (u0 :: Int#) (u1 :: Int#) (u2 :: ByteArray#) (u3 :: Integer) -> case _APP_ _WRKR_ _CONSTM_ Integral divMod (Integer) [ u0, u1, u2, u3 ] of { _ALG_ _TUP_2 (u4 :: Integer) (u5 :: Integer) -> u4; _NO_DEFLT_ } _N_} _F_ _IF_ARGS_ 0 2 XX 5 \ (u0 :: Integer) (u1 :: Integer) -> case _APP_ _CONSTM_ Integral divMod (Integer) [ u0, u1 ] of { _ALG_ _TUP_2 (u2 :: Integer) (u3 :: Integer) -> u2; _NO_DEFLT_ } _N_ },
+ mod = { _A_ 2 _U_ 12 _N_ _S_ "U(PPP)U(PPP)" {_A_ 4 _U_ 2222 _N_ _N_ _F_ _IF_ARGS_ 0 4 XXXX 7 \ (u0 :: Int#) (u1 :: Int#) (u2 :: ByteArray#) (u3 :: Integer) -> case _APP_ _WRKR_ _CONSTM_ Integral divMod (Integer) [ u0, u1, u2, u3 ] of { _ALG_ _TUP_2 (u4 :: Integer) (u5 :: Integer) -> u5; _NO_DEFLT_ } _N_} _F_ _IF_ARGS_ 0 2 XX 5 \ (u0 :: Integer) (u1 :: Integer) -> case _APP_ _CONSTM_ Integral divMod (Integer) [ u0, u1 ] of { _ALG_ _TUP_2 (u2 :: Integer) (u3 :: Integer) -> u3; _NO_DEFLT_ } _N_ },
+ quotRem = { _A_ 2 _U_ 11 _N_ _S_ "U(PPP)U(PPP)" {_A_ 4 _U_ 2221 _N_ _N_ _N_ _N_} _N_ _N_ },
+ divMod = { _A_ 2 _U_ 12 _N_ _S_ "U(PPP)U(PPP)" {_A_ 4 _U_ 2222 _N_ _N_ _N_ _N_} _N_ _N_ },
+ even = { _A_ 1 _U_ 1 _N_ _S_ "U(PPP)" {_A_ 3 _U_ 222 _N_ _N_ _N_ _N_} _N_ _N_ },
+ odd = { _A_ 1 _U_ 1 _N_ _S_ "U(PPP)" {_A_ 3 _U_ 222 _N_ _N_ _N_ _N_} _N_ _N_ },
+ toInteger = { _A_ 1 _U_ 1 _N_ _S_ "U(PPP)" {_A_ 3 _U_ 222 _N_ _N_ _F_ _IF_ARGS_ 0 3 XXX 4 \ (u0 :: Int#) (u1 :: Int#) (u2 :: ByteArray#) -> _!_ J# [] [u0, u1, u2] _N_} _F_ _IF_ARGS_ 0 1 X 1 \ (u0 :: Integer) -> u0 _N_ },
+ toInt = { _A_ 1 _U_ 1 _N_ _S_ "U(PPP)" {_A_ 3 _U_ 222 _N_ _N_ _F_ _IF_ARGS_ 0 3 XXX 3 \ (u0 :: Int#) (u1 :: Int#) (u2 :: ByteArray#) -> case _#_ integer2Int# [] [u0, u1, u2] of { _PRIM_ (u3 :: Int#) -> _!_ I# [] [u3] } _N_} _F_ _IF_ARGS_ 0 1 C 4 \ (u0 :: Integer) -> case u0 of { _ALG_ J# (u1 :: Int#) (u2 :: Int#) (u3 :: ByteArray#) -> case _#_ integer2Int# [] [u1, u2, u3] of { _PRIM_ (u4 :: Int#) -> _!_ I# [] [u4] }; _NO_DEFLT_ } _N_ } #-}
instance Ix ()
{-# GHC_PRAGMA _M_ PreludeBuiltin {-dfun-} _A_ 0 _N_ _N_ _N_ _F_ _IF_ARGS_ 0 0 X 5 _!_ _TUP_4 [{{Ord ()}}, (((), ()) -> [()]), (((), ()) -> () -> Int), (((), ()) -> () -> Bool)] [_DFUN_ Ord (()), _CONSTM_ Ix range (()), _CONSTM_ Ix index (()), _CONSTM_ Ix inRange (())] _N_
- range = _A_ 1 _U_ 1 _N_ _S_ "U(EE)" {_A_ 2 _U_ 21 _N_ _N_ _N_ _N_} _N_ _N_,
- index = _A_ 2 _U_ 11 _N_ _S_ "U(EE)E" {_A_ 3 _U_ 111 _N_ _N_ _F_ _IF_ARGS_ 0 3 CCC 5 \ (u0 :: ()) (u1 :: ()) (u2 :: ()) -> case u0 of { _ALG_ _TUP_0 -> case u1 of { _ALG_ _TUP_0 -> case u2 of { _ALG_ _TUP_0 -> _!_ I# [] [0#]; _NO_DEFLT_ }; _NO_DEFLT_ }; _NO_DEFLT_ } _N_} _F_ _IF_ARGS_ 0 2 CC 6 \ (u0 :: ((), ())) (u1 :: ()) -> case u0 of { _ALG_ _TUP_2 (u2 :: ()) (u3 :: ()) -> case u2 of { _ALG_ _TUP_0 -> case u3 of { _ALG_ _TUP_0 -> case u1 of { _ALG_ _TUP_0 -> _!_ I# [] [0#]; _NO_DEFLT_ }; _NO_DEFLT_ }; _NO_DEFLT_ }; _NO_DEFLT_ } _N_,
- inRange = _A_ 2 _U_ 11 _N_ _S_ "U(EE)E" {_A_ 3 _U_ 111 _N_ _N_ _F_ _IF_ARGS_ 0 3 CCC 4 \ (u0 :: ()) (u1 :: ()) (u2 :: ()) -> case u0 of { _ALG_ _TUP_0 -> case u1 of { _ALG_ _TUP_0 -> case u2 of { _ALG_ _TUP_0 -> _!_ True [] []; _NO_DEFLT_ }; _NO_DEFLT_ }; _NO_DEFLT_ } _N_} _F_ _IF_ARGS_ 0 2 CC 5 \ (u0 :: ((), ())) (u1 :: ()) -> case u0 of { _ALG_ _TUP_2 (u2 :: ()) (u3 :: ()) -> case u2 of { _ALG_ _TUP_0 -> case u3 of { _ALG_ _TUP_0 -> case u1 of { _ALG_ _TUP_0 -> _!_ True [] []; _NO_DEFLT_ }; _NO_DEFLT_ }; _NO_DEFLT_ }; _NO_DEFLT_ } _N_ #-}
+ range = { _A_ 1 _U_ 1 _N_ _S_ "U(EE)" {_A_ 2 _U_ 21 _N_ _N_ _N_ _N_} _N_ _N_ },
+ index = { _A_ 2 _U_ 11 _N_ _S_ "U(EE)E" {_A_ 3 _U_ 111 _N_ _N_ _F_ _IF_ARGS_ 0 3 CCC 5 \ (u0 :: ()) (u1 :: ()) (u2 :: ()) -> case u0 of { _ALG_ _TUP_0 -> case u1 of { _ALG_ _TUP_0 -> case u2 of { _ALG_ _TUP_0 -> _!_ I# [] [0#]; _NO_DEFLT_ }; _NO_DEFLT_ }; _NO_DEFLT_ } _N_} _F_ _IF_ARGS_ 0 2 CC 6 \ (u0 :: ((), ())) (u1 :: ()) -> case u0 of { _ALG_ _TUP_2 (u2 :: ()) (u3 :: ()) -> case u2 of { _ALG_ _TUP_0 -> case u3 of { _ALG_ _TUP_0 -> case u1 of { _ALG_ _TUP_0 -> _!_ I# [] [0#]; _NO_DEFLT_ }; _NO_DEFLT_ }; _NO_DEFLT_ }; _NO_DEFLT_ } _N_ },
+ inRange = { _A_ 2 _U_ 11 _N_ _S_ "U(EE)E" {_A_ 3 _U_ 111 _N_ _N_ _F_ _IF_ARGS_ 0 3 CCC 4 \ (u0 :: ()) (u1 :: ()) (u2 :: ()) -> case u0 of { _ALG_ _TUP_0 -> case u1 of { _ALG_ _TUP_0 -> case u2 of { _ALG_ _TUP_0 -> _!_ True [] []; _NO_DEFLT_ }; _NO_DEFLT_ }; _NO_DEFLT_ } _N_} _F_ _IF_ARGS_ 0 2 CC 5 \ (u0 :: ((), ())) (u1 :: ()) -> case u0 of { _ALG_ _TUP_2 (u2 :: ()) (u3 :: ()) -> case u2 of { _ALG_ _TUP_0 -> case u3 of { _ALG_ _TUP_0 -> case u1 of { _ALG_ _TUP_0 -> _!_ True [] []; _NO_DEFLT_ }; _NO_DEFLT_ }; _NO_DEFLT_ }; _NO_DEFLT_ } _N_ } #-}
instance (Ix a, Ix b) => Ix (a, b)
{-# GHC_PRAGMA _M_ PreludeBuiltin {-dfun-} _A_ 3 _U_ 222 _N_ _N_ _N_ _N_ #-}
instance (Ix a, Ix b, Ix c) => Ix (a, b, c)
{-# GHC_PRAGMA _M_ PreludeBuiltin {-dfun-} _A_ 6 _U_ 222222 _N_ _N_ _N_ _N_ #-}
instance Ix (Int, Int)
{-# GHC_PRAGMA _M_ PreludeBuiltin {-dfun-} _A_ 0 _N_ _N_ _N_ _F_ _IF_ARGS_ 0 0 X 5 _!_ _TUP_4 [{{Ord (Int, Int)}}, (((Int, Int), (Int, Int)) -> [(Int, Int)]), (((Int, Int), (Int, Int)) -> (Int, Int) -> Int), (((Int, Int), (Int, Int)) -> (Int, Int) -> Bool)] [_DFUN_ Ord ((Int, Int)), _CONSTM_ Ix range ((Int, Int)), _CONSTM_ Ix index ((Int, Int)), _CONSTM_ Ix inRange ((Int, Int))] _N_
- range = _A_ 1 _U_ 1 _N_ _S_ "U(SS)" {_A_ 2 _U_ 11 _N_ _N_ _N_ _N_} _N_ _N_,
- index = _A_ 2 _U_ 11 _N_ _S_ "U(SS)U(U(P)U(P))" {_A_ 4 _U_ 1122 _N_ _N_ _N_ _N_} _N_ _N_,
- inRange = _A_ 2 _U_ 11 _N_ _S_ "U(SS)U(U(P)L)" {_A_ 4 _U_ 1121 _N_ _N_ _N_ _N_} _N_ _N_ #-}
+ range = { _A_ 1 _U_ 1 _N_ _S_ "U(SS)" {_A_ 2 _U_ 11 _N_ _N_ _N_ _N_} _N_ _N_ },
+ index = { _A_ 2 _U_ 11 _N_ _S_ "U(SS)U(U(P)U(P))" {_A_ 4 _U_ 1122 _N_ _N_ _N_ _N_} _N_ _N_ },
+ inRange = { _A_ 2 _U_ 11 _N_ _S_ "U(SS)U(U(P)L)" {_A_ 4 _U_ 1121 _N_ _N_ _N_ _N_} _N_ _N_ } #-}
instance (Ix a, Ix b) => Ix (Assoc a b)
{-# GHC_PRAGMA _M_ PreludeArray {-dfun-} _A_ 3 _U_ 222 _N_ _N_ _N_ _N_ #-}
instance Ix Bool
{-# GHC_PRAGMA _M_ PreludeCore {-dfun-} _A_ 0 _N_ _N_ _N_ _F_ _IF_ARGS_ 0 0 X 5 _!_ _TUP_4 [{{Ord Bool}}, ((Bool, Bool) -> [Bool]), ((Bool, Bool) -> Bool -> Int), ((Bool, Bool) -> Bool -> Bool)] [_DFUN_ Ord (Bool), _CONSTM_ Ix range (Bool), _CONSTM_ Ix index (Bool), _CONSTM_ Ix inRange (Bool)] _N_
- range = _A_ 1 _U_ 1 _N_ _S_ "U(EE)" {_A_ 2 _U_ 11 _N_ _N_ _N_ _N_} _N_ _N_,
- index = _A_ 2 _U_ 11 _N_ _S_ "U(EA)E" {_A_ 2 _U_ 11 _N_ _N_ _N_ _N_} _N_ _N_,
- inRange = _A_ 2 _U_ 12 _N_ _S_ "U(EL)E" {_A_ 3 _U_ 112 _N_ _N_ _N_ _N_} _N_ _N_ #-}
+ range = { _A_ 1 _U_ 1 _N_ _S_ "U(EE)" {_A_ 2 _U_ 11 _N_ _N_ _N_ _N_} _N_ _N_ },
+ index = { _A_ 2 _U_ 11 _N_ _S_ "U(EA)E" {_A_ 2 _U_ 11 _N_ _N_ _N_ _N_} _N_ _N_ },
+ inRange = { _A_ 2 _U_ 12 _N_ _S_ "U(EL)E" {_A_ 3 _U_ 112 _N_ _N_ _N_ _N_} _N_ _N_ } #-}
instance Ix Char
{-# GHC_PRAGMA _M_ PreludeCore {-dfun-} _A_ 0 _N_ _N_ _N_ _F_ _IF_ARGS_ 0 0 X 5 _!_ _TUP_4 [{{Ord Char}}, ((Char, Char) -> [Char]), ((Char, Char) -> Char -> Int), ((Char, Char) -> Char -> Bool)] [_DFUN_ Ord (Char), _CONSTM_ Ix range (Char), _CONSTM_ Ix index (Char), _CONSTM_ Ix inRange (Char)] _N_
- range = _A_ 1 _U_ 1 _N_ _S_ "U(LL)" {_A_ 2 _U_ 22 _N_ _N_ _F_ _IF_ARGS_ 0 0 X 1 _CONSTM_ Enum enumFromTo (Char) _N_} _F_ _IF_ARGS_ 0 1 C 4 \ (u0 :: (Char, Char)) -> case u0 of { _ALG_ _TUP_2 (u1 :: Char) (u2 :: Char) -> _APP_ _CONSTM_ Enum enumFromTo (Char) [ u1, u2 ]; _NO_DEFLT_ } _N_,
- index = _A_ 2 _U_ 11 _N_ _S_ "U(U(P)L)U(P)" {_A_ 3 _U_ 212 _N_ _N_ _N_ _N_} _N_ _N_,
- inRange = _A_ 2 _U_ 11 _N_ _S_ "U(U(P)L)U(P)" {_A_ 3 _U_ 212 _N_ _N_ _N_ _N_} _N_ _N_ #-}
+ range = { _A_ 1 _U_ 1 _N_ _S_ "U(U(P)L)" {_A_ 2 _U_ 22 _N_ _N_ _N_ _N_} _F_ _IF_ARGS_ 0 1 C 4 \ (u0 :: (Char, Char)) -> case u0 of { _ALG_ _TUP_2 (u1 :: Char) (u2 :: Char) -> _APP_ _CONSTM_ Enum enumFromTo (Char) [ u1, u2 ]; _NO_DEFLT_ } _N_ },
+ index = { _A_ 2 _U_ 11 _N_ _S_ "U(U(P)L)U(P)" {_A_ 3 _U_ 212 _N_ _N_ _N_ _N_} _N_ _N_ },
+ inRange = { _A_ 2 _U_ 11 _N_ _S_ "U(U(P)L)U(P)" {_A_ 3 _U_ 212 _N_ _N_ _N_ _N_} _N_ _N_ } #-}
instance Ix Int
{-# GHC_PRAGMA _M_ PreludeCore {-dfun-} _A_ 0 _N_ _N_ _N_ _F_ _IF_ARGS_ 0 0 X 5 _!_ _TUP_4 [{{Ord Int}}, ((Int, Int) -> [Int]), ((Int, Int) -> Int -> Int), ((Int, Int) -> Int -> Bool)] [_DFUN_ Ord (Int), _CONSTM_ Ix range (Int), _CONSTM_ Ix index (Int), _CONSTM_ Ix inRange (Int)] _N_
- range = _A_ 1 _U_ 1 _N_ _S_ "U(U(P)U(P))" {_A_ 2 _U_ 22 _N_ _N_ _N_ _N_} _N_ _N_,
- index = _A_ 2 _U_ 11 _N_ _S_ "U(U(P)U(P))U(P)" {_A_ 3 _U_ 222 _N_ _N_ _N_ _N_} _N_ _N_,
- inRange = _A_ 2 _U_ 11 _N_ _S_ "U(U(P)U(P))U(P)" {_A_ 3 _U_ 222 _N_ _N_ _F_ _IF_ARGS_ 0 3 XXX 5 \ (u0 :: Int#) (u1 :: Int#) (u2 :: Int#) -> case _#_ leInt# [] [u0, u2] of { _ALG_ True -> _#_ leInt# [] [u2, u1]; False -> _!_ False [] []; _NO_DEFLT_ } _N_} _F_ _ALWAYS_ \ (u0 :: (Int, Int)) (u1 :: Int) -> case u0 of { _ALG_ _TUP_2 (u2 :: Int) (u3 :: Int) -> case u2 of { _ALG_ I# (u4 :: Int#) -> case u3 of { _ALG_ I# (u5 :: Int#) -> case u1 of { _ALG_ I# (u6 :: Int#) -> case _#_ leInt# [] [u4, u6] of { _ALG_ True -> _#_ leInt# [] [u6, u5]; False -> _!_ False [] []; _NO_DEFLT_ }; _NO_DEFLT_ }; _NO_DEFLT_ }; _NO_DEFLT_ }; _NO_DEFLT_ } _N_ #-}
+ range = { _A_ 1 _U_ 1 _N_ _S_ "U(U(P)U(P))" {_A_ 2 _U_ 22 _N_ _N_ _N_ _N_} _N_ _N_ },
+ index = { _A_ 2 _U_ 11 _N_ _S_ "U(U(P)U(P))U(P)" {_A_ 3 _U_ 222 _N_ _N_ _N_ _N_} _N_ _N_ },
+ inRange = { _A_ 2 _U_ 11 _N_ _S_ "U(U(P)U(P))U(P)" {_A_ 3 _U_ 222 _N_ _N_ _F_ _IF_ARGS_ 0 3 XXX 5 \ (u0 :: Int#) (u1 :: Int#) (u2 :: Int#) -> case _#_ leInt# [] [u0, u2] of { _ALG_ True -> _#_ leInt# [] [u2, u1]; False -> _!_ False [] []; _NO_DEFLT_ } _N_} _F_ _ALWAYS_ \ (u0 :: (Int, Int)) (u1 :: Int) -> case u0 of { _ALG_ _TUP_2 (u2 :: Int) (u3 :: Int) -> case u2 of { _ALG_ I# (u4 :: Int#) -> case u3 of { _ALG_ I# (u5 :: Int#) -> case u1 of { _ALG_ I# (u6 :: Int#) -> case _#_ leInt# [] [u4, u6] of { _ALG_ True -> _#_ leInt# [] [u6, u5]; False -> _!_ False [] []; _NO_DEFLT_ }; _NO_DEFLT_ }; _NO_DEFLT_ }; _NO_DEFLT_ }; _NO_DEFLT_ } _N_ } #-}
instance Ix Integer
{-# GHC_PRAGMA _M_ PreludeCore {-dfun-} _A_ 0 _N_ _N_ _N_ _F_ _IF_ARGS_ 0 0 X 5 _!_ _TUP_4 [{{Ord Integer}}, ((Integer, Integer) -> [Integer]), ((Integer, Integer) -> Integer -> Int), ((Integer, Integer) -> Integer -> Bool)] [_DFUN_ Ord (Integer), _CONSTM_ Ix range (Integer), _CONSTM_ Ix index (Integer), _CONSTM_ Ix inRange (Integer)] _N_
- range = _A_ 1 _U_ 1 _N_ _S_ "U(LL)" {_A_ 2 _U_ 22 _N_ _N_ _F_ _IF_ARGS_ 0 0 X 1 _CONSTM_ Enum enumFromTo (Integer) _N_} _F_ _IF_ARGS_ 0 1 C 4 \ (u0 :: (Integer, Integer)) -> case u0 of { _ALG_ _TUP_2 (u1 :: Integer) (u2 :: Integer) -> _APP_ _CONSTM_ Enum enumFromTo (Integer) [ u1, u2 ]; _NO_DEFLT_ } _N_,
- index = _A_ 2 _U_ 12 _N_ _S_ "U(U(PPP)L)U(PPP)" {_A_ 5 _U_ 22222 _N_ _N_ _N_ _N_} _N_ _N_,
- inRange = _A_ 2 _U_ 11 _N_ _S_ "U(U(PPP)L)U(PPP)" {_A_ 5 _U_ 22211 _N_ _N_ _F_ _IF_ARGS_ 0 5 XXXCC 9 \ (u0 :: Int#) (u1 :: Int#) (u2 :: ByteArray#) (u3 :: Integer) (u4 :: Integer) -> case u4 of { _ALG_ J# (u5 :: Int#) (u6 :: Int#) (u7 :: ByteArray#) -> case _#_ cmpInteger# [] [u0, u1, u2, u5, u6, u7] of { _PRIM_ (u8 :: Int#) -> case _#_ leInt# [] [u8, 0#] of { _ALG_ True -> case u3 of { _ALG_ J# (u9 :: Int#) (ua :: Int#) (ub :: ByteArray#) -> case _#_ cmpInteger# [] [u5, u6, u7, u9, ua, ub] of { _PRIM_ (uc :: Int#) -> _#_ leInt# [] [uc, 0#] }; _NO_DEFLT_ }; False -> _!_ False [] []; _NO_DEFLT_ } }; _NO_DEFLT_ } _N_} _N_ _N_ #-}
+ range = { _A_ 1 _U_ 1 _N_ _S_ "U(LL)" {_A_ 2 _U_ 22 _N_ _N_ _F_ _IF_ARGS_ 0 0 X 1 _CONSTM_ Enum enumFromTo (Integer) _N_} _F_ _IF_ARGS_ 0 1 C 4 \ (u0 :: (Integer, Integer)) -> case u0 of { _ALG_ _TUP_2 (u1 :: Integer) (u2 :: Integer) -> _APP_ _CONSTM_ Enum enumFromTo (Integer) [ u1, u2 ]; _NO_DEFLT_ } _N_ },
+ index = { _A_ 2 _U_ 12 _N_ _S_ "U(U(PPP)L)U(PPP)" {_A_ 5 _U_ 22222 _N_ _N_ _N_ _N_} _N_ _N_ },
+ inRange = { _A_ 2 _U_ 11 _N_ _S_ "U(U(PPP)L)U(PPP)" {_A_ 5 _U_ 22211 _N_ _N_ _F_ _IF_ARGS_ 0 5 XXXCC 9 \ (u0 :: Int#) (u1 :: Int#) (u2 :: ByteArray#) (u3 :: Integer) (u4 :: Integer) -> case u4 of { _ALG_ J# (u5 :: Int#) (u6 :: Int#) (u7 :: ByteArray#) -> case _#_ cmpInteger# [] [u0, u1, u2, u5, u6, u7] of { _PRIM_ (u8 :: Int#) -> case _#_ leInt# [] [u8, 0#] of { _ALG_ True -> case u3 of { _ALG_ J# (u9 :: Int#) (ua :: Int#) (ub :: ByteArray#) -> case _#_ cmpInteger# [] [u5, u6, u7, u9, ua, ub] of { _PRIM_ (uc :: Int#) -> _#_ leInt# [] [uc, 0#] }; _NO_DEFLT_ }; False -> _!_ False [] []; _NO_DEFLT_ } }; _NO_DEFLT_ } _N_} _N_ _N_ } #-}
instance RealFloat a => Num (Complex a)
{-# GHC_PRAGMA _M_ PreludeComplex {-dfun-} _A_ 3 _U_ 222 _N_ _N_ _N_ _N_ #-}
instance Num (Complex Double)
- {-# GHC_PRAGMA _M_ PreludeComplex {-dfun-} _A_ 0 _N_ _N_ _N_ _N_ _N_
- (+) = _A_ 2 _U_ 11 _N_ _S_ "U(LL)U(LL)" {_A_ 4 _U_ 1111 _N_ _N_ _N_ _N_} _N_ _N_,
- (-) = _A_ 2 _U_ 11 _N_ _S_ "U(LL)U(LL)" {_A_ 4 _U_ 1111 _N_ _N_ _N_ _N_} _N_ _N_,
- (*) = _A_ 2 _U_ 11 _N_ _S_ "U(LL)U(LL)" {_A_ 4 _U_ 2222 _N_ _N_ _N_ _N_} _N_ _N_,
- negate = _A_ 1 _U_ 1 _N_ _S_ "U(LL)" {_A_ 2 _U_ 11 _N_ _N_ _N_ _N_} _N_ _N_,
- abs = _A_ 1 _U_ 1 _N_ _N_ _N_ _N_,
- signum = _A_ 1 _U_ 1 _N_ _S_ "U(U(P)L)" {_A_ 2 _U_ 22 _N_ _N_ _N_ _N_} _N_ _N_,
- fromInteger = _A_ 1 _U_ 1 _N_ _N_ _N_ _N_,
- fromInt = _A_ 1 _U_ 1 _N_ _N_ _N_ _N_ #-}
+ {-# GHC_PRAGMA _M_ PreludeComplex {-dfun-} _A_ 0 _N_ _N_ _N_ _F_ _IF_ARGS_ 0 0 X 11 _!_ _TUP_10 [{{Eq (Complex Double)}}, {{Text (Complex Double)}}, (Complex Double -> Complex Double -> Complex Double), (Complex Double -> Complex Double -> Complex Double), (Complex Double -> Complex Double -> Complex Double), (Complex Double -> Complex Double), (Complex Double -> Complex Double), (Complex Double -> Complex Double), (Integer -> Complex Double), (Int -> Complex Double)] [_DFUN_ Eq (Complex Double), _DFUN_ Text (Complex Double), _CONSTM_ Num (+) (Complex Double), _CONSTM_ Num (-) (Complex Double), _CONSTM_ Num (*) (Complex Double), _CONSTM_ Num negate (Complex Double), _CONSTM_ Num abs (Complex Double), _CONSTM_ Num signum (Complex Double), _CONSTM_ Num fromInteger (Complex Double), _CONSTM_ Num fromInt (Complex Double)] _N_
+ (+) = { _A_ 2 _U_ 11 _N_ _S_ "U(LL)U(LL)" {_A_ 4 _U_ 1111 _N_ _N_ _N_ _N_} _N_ _N_ },
+ (-) = { _A_ 2 _U_ 11 _N_ _S_ "U(LL)U(LL)" {_A_ 4 _U_ 1111 _N_ _N_ _N_ _N_} _N_ _N_ },
+ (*) = { _A_ 2 _U_ 11 _N_ _S_ "U(LL)U(LL)" {_A_ 4 _U_ 2222 _N_ _N_ _N_ _N_} _N_ _N_ },
+ negate = { _A_ 1 _U_ 1 _N_ _S_ "U(LL)" {_A_ 2 _U_ 11 _N_ _N_ _N_ _N_} _N_ _N_ },
+ abs = { _A_ 1 _U_ 1 _N_ _N_ _N_ _N_ },
+ signum = { _A_ 1 _U_ 1 _N_ _S_ "U(U(P)L)" {_A_ 2 _U_ 22 _N_ _N_ _N_ _N_} _N_ _N_ },
+ fromInteger = { _A_ 1 _U_ 1 _N_ _N_ _N_ _N_ },
+ fromInt = { _A_ 1 _U_ 1 _N_ _N_ _N_ _N_ } #-}
instance Num Double
{-# GHC_PRAGMA _M_ PreludeCore {-dfun-} _A_ 0 _N_ _N_ _N_ _F_ _IF_ARGS_ 0 0 X 11 _!_ _TUP_10 [{{Eq Double}}, {{Text Double}}, (Double -> Double -> Double), (Double -> Double -> Double), (Double -> Double -> Double), (Double -> Double), (Double -> Double), (Double -> Double), (Integer -> Double), (Int -> Double)] [_DFUN_ Eq (Double), _DFUN_ Text (Double), _CONSTM_ Num (+) (Double), _CONSTM_ Num (-) (Double), _CONSTM_ Num (*) (Double), _CONSTM_ Num negate (Double), _CONSTM_ Num abs (Double), _CONSTM_ Num signum (Double), _CONSTM_ Num fromInteger (Double), _CONSTM_ Num fromInt (Double)] _N_
- (+) = _A_ 2 _U_ 11 _N_ _S_ "U(P)U(P)" {_A_ 2 _U_ 22 _N_ _N_ _F_ _IF_ARGS_ 0 2 XX 3 \ (u0 :: Double#) (u1 :: Double#) -> case _#_ plusDouble# [] [u0, u1] of { _PRIM_ (u2 :: Double#) -> _!_ D# [] [u2] } _N_} _F_ _IF_ARGS_ 0 2 CC 5 \ (u0 :: Double) (u1 :: Double) -> case u0 of { _ALG_ D# (u2 :: Double#) -> case u1 of { _ALG_ D# (u3 :: Double#) -> case _#_ plusDouble# [] [u2, u3] of { _PRIM_ (u4 :: Double#) -> _!_ D# [] [u4] }; _NO_DEFLT_ }; _NO_DEFLT_ } _N_,
- (-) = _A_ 2 _U_ 11 _N_ _S_ "U(P)U(P)" {_A_ 2 _U_ 22 _N_ _N_ _F_ _IF_ARGS_ 0 2 XX 3 \ (u0 :: Double#) (u1 :: Double#) -> case _#_ minusDouble# [] [u0, u1] of { _PRIM_ (u2 :: Double#) -> _!_ D# [] [u2] } _N_} _F_ _IF_ARGS_ 0 2 CC 5 \ (u0 :: Double) (u1 :: Double) -> case u0 of { _ALG_ D# (u2 :: Double#) -> case u1 of { _ALG_ D# (u3 :: Double#) -> case _#_ minusDouble# [] [u2, u3] of { _PRIM_ (u4 :: Double#) -> _!_ D# [] [u4] }; _NO_DEFLT_ }; _NO_DEFLT_ } _N_,
- (*) = _A_ 2 _U_ 11 _N_ _S_ "U(P)U(P)" {_A_ 2 _U_ 22 _N_ _N_ _F_ _IF_ARGS_ 0 2 XX 3 \ (u0 :: Double#) (u1 :: Double#) -> case _#_ timesDouble# [] [u0, u1] of { _PRIM_ (u2 :: Double#) -> _!_ D# [] [u2] } _N_} _F_ _IF_ARGS_ 0 2 CC 5 \ (u0 :: Double) (u1 :: Double) -> case u0 of { _ALG_ D# (u2 :: Double#) -> case u1 of { _ALG_ D# (u3 :: Double#) -> case _#_ timesDouble# [] [u2, u3] of { _PRIM_ (u4 :: Double#) -> _!_ D# [] [u4] }; _NO_DEFLT_ }; _NO_DEFLT_ } _N_,
- negate = _A_ 1 _U_ 1 _N_ _S_ "U(P)" {_A_ 1 _U_ 2 _N_ _N_ _F_ _IF_ARGS_ 0 1 X 3 \ (u0 :: Double#) -> case _#_ negateDouble# [] [u0] of { _PRIM_ (u1 :: Double#) -> _!_ D# [] [u1] } _N_} _F_ _IF_ARGS_ 0 1 C 4 \ (u0 :: Double) -> case u0 of { _ALG_ D# (u1 :: Double#) -> case _#_ negateDouble# [] [u1] of { _PRIM_ (u2 :: Double#) -> _!_ D# [] [u2] }; _NO_DEFLT_ } _N_,
- abs = _A_ 1 _U_ 1 _N_ _S_ "U(P)" {_A_ 1 _U_ 2 _N_ _N_ _N_ _N_} _N_ _N_,
- signum = _A_ 1 _U_ 1 _N_ _S_ "U(P)" {_A_ 1 _U_ 2 _N_ _N_ _N_ _N_} _N_ _N_,
- fromInteger = _A_ 1 _U_ 1 _N_ _S_ "U(PPP)" {_A_ 3 _U_ 222 _N_ _N_ _F_ _IF_ARGS_ 0 3 XXX 3 \ (u0 :: Int#) (u1 :: Int#) (u2 :: ByteArray#) -> case _#_ encodeDouble# [] [u0, u1, u2, 0#] of { _PRIM_ (u3 :: Double#) -> _!_ D# [] [u3] } _N_} _F_ _IF_ARGS_ 0 1 C 4 \ (u0 :: Integer) -> case u0 of { _ALG_ J# (u1 :: Int#) (u2 :: Int#) (u3 :: ByteArray#) -> case _#_ encodeDouble# [] [u1, u2, u3, 0#] of { _PRIM_ (u4 :: Double#) -> _!_ D# [] [u4] }; _NO_DEFLT_ } _N_,
- fromInt = _A_ 1 _U_ 1 _N_ _S_ "U(P)" {_A_ 1 _U_ 2 _N_ _N_ _F_ _IF_ARGS_ 0 1 X 3 \ (u0 :: Int#) -> case _#_ int2Double# [] [u0] of { _PRIM_ (u1 :: Double#) -> _!_ D# [] [u1] } _N_} _F_ _IF_ARGS_ 0 1 C 4 \ (u0 :: Int) -> case u0 of { _ALG_ I# (u1 :: Int#) -> case _#_ int2Double# [] [u1] of { _PRIM_ (u2 :: Double#) -> _!_ D# [] [u2] }; _NO_DEFLT_ } _N_ #-}
+ (+) = { _A_ 2 _U_ 11 _N_ _S_ "U(P)U(P)" {_A_ 2 _U_ 22 _N_ _N_ _F_ _IF_ARGS_ 0 2 XX 3 \ (u0 :: Double#) (u1 :: Double#) -> case _#_ plusDouble# [] [u0, u1] of { _PRIM_ (u2 :: Double#) -> _!_ D# [] [u2] } _N_} _F_ _IF_ARGS_ 0 2 CC 5 \ (u0 :: Double) (u1 :: Double) -> case u0 of { _ALG_ D# (u2 :: Double#) -> case u1 of { _ALG_ D# (u3 :: Double#) -> case _#_ plusDouble# [] [u2, u3] of { _PRIM_ (u4 :: Double#) -> _!_ D# [] [u4] }; _NO_DEFLT_ }; _NO_DEFLT_ } _N_ },
+ (-) = { _A_ 2 _U_ 11 _N_ _S_ "U(P)U(P)" {_A_ 2 _U_ 22 _N_ _N_ _F_ _IF_ARGS_ 0 2 XX 3 \ (u0 :: Double#) (u1 :: Double#) -> case _#_ minusDouble# [] [u0, u1] of { _PRIM_ (u2 :: Double#) -> _!_ D# [] [u2] } _N_} _F_ _IF_ARGS_ 0 2 CC 5 \ (u0 :: Double) (u1 :: Double) -> case u0 of { _ALG_ D# (u2 :: Double#) -> case u1 of { _ALG_ D# (u3 :: Double#) -> case _#_ minusDouble# [] [u2, u3] of { _PRIM_ (u4 :: Double#) -> _!_ D# [] [u4] }; _NO_DEFLT_ }; _NO_DEFLT_ } _N_ },
+ (*) = { _A_ 2 _U_ 11 _N_ _S_ "U(P)U(P)" {_A_ 2 _U_ 22 _N_ _N_ _F_ _IF_ARGS_ 0 2 XX 3 \ (u0 :: Double#) (u1 :: Double#) -> case _#_ timesDouble# [] [u0, u1] of { _PRIM_ (u2 :: Double#) -> _!_ D# [] [u2] } _N_} _F_ _IF_ARGS_ 0 2 CC 5 \ (u0 :: Double) (u1 :: Double) -> case u0 of { _ALG_ D# (u2 :: Double#) -> case u1 of { _ALG_ D# (u3 :: Double#) -> case _#_ timesDouble# [] [u2, u3] of { _PRIM_ (u4 :: Double#) -> _!_ D# [] [u4] }; _NO_DEFLT_ }; _NO_DEFLT_ } _N_ },
+ negate = { _A_ 1 _U_ 1 _N_ _S_ "U(P)" {_A_ 1 _U_ 2 _N_ _N_ _F_ _IF_ARGS_ 0 1 X 3 \ (u0 :: Double#) -> case _#_ negateDouble# [] [u0] of { _PRIM_ (u1 :: Double#) -> _!_ D# [] [u1] } _N_} _F_ _IF_ARGS_ 0 1 C 4 \ (u0 :: Double) -> case u0 of { _ALG_ D# (u1 :: Double#) -> case _#_ negateDouble# [] [u1] of { _PRIM_ (u2 :: Double#) -> _!_ D# [] [u2] }; _NO_DEFLT_ } _N_ },
+ abs = { _A_ 1 _U_ 1 _N_ _S_ "U(P)" {_A_ 1 _U_ 2 _N_ _N_ _N_ _N_} _N_ _N_ },
+ signum = { _A_ 1 _U_ 1 _N_ _S_ "U(P)" {_A_ 1 _U_ 2 _N_ _N_ _N_ _N_} _N_ _N_ },
+ fromInteger = { _A_ 1 _U_ 1 _N_ _S_ "U(PPP)" {_A_ 3 _U_ 222 _N_ _N_ _F_ _IF_ARGS_ 0 3 XXX 3 \ (u0 :: Int#) (u1 :: Int#) (u2 :: ByteArray#) -> case _#_ encodeDouble# [] [u0, u1, u2, 0#] of { _PRIM_ (u3 :: Double#) -> _!_ D# [] [u3] } _N_} _F_ _IF_ARGS_ 0 1 C 4 \ (u0 :: Integer) -> case u0 of { _ALG_ J# (u1 :: Int#) (u2 :: Int#) (u3 :: ByteArray#) -> case _#_ encodeDouble# [] [u1, u2, u3, 0#] of { _PRIM_ (u4 :: Double#) -> _!_ D# [] [u4] }; _NO_DEFLT_ } _N_ },
+ fromInt = { _A_ 1 _U_ 1 _N_ _S_ "U(P)" {_A_ 1 _U_ 2 _N_ _N_ _F_ _IF_ARGS_ 0 1 X 3 \ (u0 :: Int#) -> case _#_ int2Double# [] [u0] of { _PRIM_ (u1 :: Double#) -> _!_ D# [] [u1] } _N_} _F_ _IF_ARGS_ 0 1 C 4 \ (u0 :: Int) -> case u0 of { _ALG_ I# (u1 :: Int#) -> case _#_ int2Double# [] [u1] of { _PRIM_ (u2 :: Double#) -> _!_ D# [] [u2] }; _NO_DEFLT_ } _N_ } #-}
instance Num Float
{-# GHC_PRAGMA _M_ PreludeCore {-dfun-} _A_ 0 _N_ _N_ _N_ _F_ _IF_ARGS_ 0 0 X 11 _!_ _TUP_10 [{{Eq Float}}, {{Text Float}}, (Float -> Float -> Float), (Float -> Float -> Float), (Float -> Float -> Float), (Float -> Float), (Float -> Float), (Float -> Float), (Integer -> Float), (Int -> Float)] [_DFUN_ Eq (Float), _DFUN_ Text (Float), _CONSTM_ Num (+) (Float), _CONSTM_ Num (-) (Float), _CONSTM_ Num (*) (Float), _CONSTM_ Num negate (Float), _CONSTM_ Num abs (Float), _CONSTM_ Num signum (Float), _CONSTM_ Num fromInteger (Float), _CONSTM_ Num fromInt (Float)] _N_
- (+) = _A_ 2 _U_ 11 _N_ _S_ "U(P)U(P)" {_A_ 2 _U_ 22 _N_ _N_ _F_ _IF_ARGS_ 0 2 XX 3 \ (u0 :: Float#) (u1 :: Float#) -> case _#_ plusFloat# [] [u0, u1] of { _PRIM_ (u2 :: Float#) -> _!_ F# [] [u2] } _N_} _F_ _IF_ARGS_ 0 2 CC 5 \ (u0 :: Float) (u1 :: Float) -> case u0 of { _ALG_ F# (u2 :: Float#) -> case u1 of { _ALG_ F# (u3 :: Float#) -> case _#_ plusFloat# [] [u2, u3] of { _PRIM_ (u4 :: Float#) -> _!_ F# [] [u4] }; _NO_DEFLT_ }; _NO_DEFLT_ } _N_,
- (-) = _A_ 2 _U_ 11 _N_ _S_ "U(P)U(P)" {_A_ 2 _U_ 22 _N_ _N_ _F_ _IF_ARGS_ 0 2 XX 3 \ (u0 :: Float#) (u1 :: Float#) -> case _#_ minusFloat# [] [u0, u1] of { _PRIM_ (u2 :: Float#) -> _!_ F# [] [u2] } _N_} _F_ _IF_ARGS_ 0 2 CC 5 \ (u0 :: Float) (u1 :: Float) -> case u0 of { _ALG_ F# (u2 :: Float#) -> case u1 of { _ALG_ F# (u3 :: Float#) -> case _#_ minusFloat# [] [u2, u3] of { _PRIM_ (u4 :: Float#) -> _!_ F# [] [u4] }; _NO_DEFLT_ }; _NO_DEFLT_ } _N_,
- (*) = _A_ 2 _U_ 11 _N_ _S_ "U(P)U(P)" {_A_ 2 _U_ 22 _N_ _N_ _F_ _IF_ARGS_ 0 2 XX 3 \ (u0 :: Float#) (u1 :: Float#) -> case _#_ timesFloat# [] [u0, u1] of { _PRIM_ (u2 :: Float#) -> _!_ F# [] [u2] } _N_} _F_ _IF_ARGS_ 0 2 CC 5 \ (u0 :: Float) (u1 :: Float) -> case u0 of { _ALG_ F# (u2 :: Float#) -> case u1 of { _ALG_ F# (u3 :: Float#) -> case _#_ timesFloat# [] [u2, u3] of { _PRIM_ (u4 :: Float#) -> _!_ F# [] [u4] }; _NO_DEFLT_ }; _NO_DEFLT_ } _N_,
- negate = _A_ 1 _U_ 1 _N_ _S_ "U(P)" {_A_ 1 _U_ 2 _N_ _N_ _F_ _IF_ARGS_ 0 1 X 3 \ (u0 :: Float#) -> case _#_ negateFloat# [] [u0] of { _PRIM_ (u1 :: Float#) -> _!_ F# [] [u1] } _N_} _F_ _IF_ARGS_ 0 1 C 4 \ (u0 :: Float) -> case u0 of { _ALG_ F# (u1 :: Float#) -> case _#_ negateFloat# [] [u1] of { _PRIM_ (u2 :: Float#) -> _!_ F# [] [u2] }; _NO_DEFLT_ } _N_,
- abs = _A_ 1 _U_ 1 _N_ _S_ "U(P)" {_A_ 1 _U_ 2 _N_ _N_ _N_ _N_} _N_ _N_,
- signum = _A_ 1 _U_ 1 _N_ _S_ "U(P)" {_A_ 1 _U_ 2 _N_ _N_ _N_ _N_} _N_ _N_,
- fromInteger = _A_ 1 _U_ 1 _N_ _S_ "U(PPP)" {_A_ 3 _U_ 222 _N_ _N_ _F_ _IF_ARGS_ 0 3 XXX 3 \ (u0 :: Int#) (u1 :: Int#) (u2 :: ByteArray#) -> case _#_ encodeFloat# [] [u0, u1, u2, 0#] of { _PRIM_ (u3 :: Float#) -> _!_ F# [] [u3] } _N_} _F_ _IF_ARGS_ 0 1 C 4 \ (u0 :: Integer) -> case u0 of { _ALG_ J# (u1 :: Int#) (u2 :: Int#) (u3 :: ByteArray#) -> case _#_ encodeFloat# [] [u1, u2, u3, 0#] of { _PRIM_ (u4 :: Float#) -> _!_ F# [] [u4] }; _NO_DEFLT_ } _N_,
- fromInt = _A_ 1 _U_ 1 _N_ _S_ "U(P)" {_A_ 1 _U_ 2 _N_ _N_ _F_ _IF_ARGS_ 0 1 X 3 \ (u0 :: Int#) -> case _#_ int2Float# [] [u0] of { _PRIM_ (u1 :: Float#) -> _!_ F# [] [u1] } _N_} _F_ _IF_ARGS_ 0 1 C 4 \ (u0 :: Int) -> case u0 of { _ALG_ I# (u1 :: Int#) -> case _#_ int2Float# [] [u1] of { _PRIM_ (u2 :: Float#) -> _!_ F# [] [u2] }; _NO_DEFLT_ } _N_ #-}
+ (+) = { _A_ 2 _U_ 11 _N_ _S_ "U(P)U(P)" {_A_ 2 _U_ 22 _N_ _N_ _F_ _IF_ARGS_ 0 2 XX 3 \ (u0 :: Float#) (u1 :: Float#) -> case _#_ plusFloat# [] [u0, u1] of { _PRIM_ (u2 :: Float#) -> _!_ F# [] [u2] } _N_} _F_ _IF_ARGS_ 0 2 CC 5 \ (u0 :: Float) (u1 :: Float) -> case u0 of { _ALG_ F# (u2 :: Float#) -> case u1 of { _ALG_ F# (u3 :: Float#) -> case _#_ plusFloat# [] [u2, u3] of { _PRIM_ (u4 :: Float#) -> _!_ F# [] [u4] }; _NO_DEFLT_ }; _NO_DEFLT_ } _N_ },
+ (-) = { _A_ 2 _U_ 11 _N_ _S_ "U(P)U(P)" {_A_ 2 _U_ 22 _N_ _N_ _F_ _IF_ARGS_ 0 2 XX 3 \ (u0 :: Float#) (u1 :: Float#) -> case _#_ minusFloat# [] [u0, u1] of { _PRIM_ (u2 :: Float#) -> _!_ F# [] [u2] } _N_} _F_ _IF_ARGS_ 0 2 CC 5 \ (u0 :: Float) (u1 :: Float) -> case u0 of { _ALG_ F# (u2 :: Float#) -> case u1 of { _ALG_ F# (u3 :: Float#) -> case _#_ minusFloat# [] [u2, u3] of { _PRIM_ (u4 :: Float#) -> _!_ F# [] [u4] }; _NO_DEFLT_ }; _NO_DEFLT_ } _N_ },
+ (*) = { _A_ 2 _U_ 11 _N_ _S_ "U(P)U(P)" {_A_ 2 _U_ 22 _N_ _N_ _F_ _IF_ARGS_ 0 2 XX 3 \ (u0 :: Float#) (u1 :: Float#) -> case _#_ timesFloat# [] [u0, u1] of { _PRIM_ (u2 :: Float#) -> _!_ F# [] [u2] } _N_} _F_ _IF_ARGS_ 0 2 CC 5 \ (u0 :: Float) (u1 :: Float) -> case u0 of { _ALG_ F# (u2 :: Float#) -> case u1 of { _ALG_ F# (u3 :: Float#) -> case _#_ timesFloat# [] [u2, u3] of { _PRIM_ (u4 :: Float#) -> _!_ F# [] [u4] }; _NO_DEFLT_ }; _NO_DEFLT_ } _N_ },
+ negate = { _A_ 1 _U_ 1 _N_ _S_ "U(P)" {_A_ 1 _U_ 2 _N_ _N_ _F_ _IF_ARGS_ 0 1 X 3 \ (u0 :: Float#) -> case _#_ negateFloat# [] [u0] of { _PRIM_ (u1 :: Float#) -> _!_ F# [] [u1] } _N_} _F_ _IF_ARGS_ 0 1 C 4 \ (u0 :: Float) -> case u0 of { _ALG_ F# (u1 :: Float#) -> case _#_ negateFloat# [] [u1] of { _PRIM_ (u2 :: Float#) -> _!_ F# [] [u2] }; _NO_DEFLT_ } _N_ },
+ abs = { _A_ 1 _U_ 1 _N_ _S_ "U(P)" {_A_ 1 _U_ 2 _N_ _N_ _N_ _N_} _N_ _N_ },
+ signum = { _A_ 1 _U_ 1 _N_ _S_ "U(P)" {_A_ 1 _U_ 2 _N_ _N_ _N_ _N_} _N_ _N_ },
+ fromInteger = { _A_ 1 _U_ 1 _N_ _S_ "U(PPP)" {_A_ 3 _U_ 222 _N_ _N_ _F_ _IF_ARGS_ 0 3 XXX 3 \ (u0 :: Int#) (u1 :: Int#) (u2 :: ByteArray#) -> case _#_ encodeFloat# [] [u0, u1, u2, 0#] of { _PRIM_ (u3 :: Float#) -> _!_ F# [] [u3] } _N_} _F_ _IF_ARGS_ 0 1 C 4 \ (u0 :: Integer) -> case u0 of { _ALG_ J# (u1 :: Int#) (u2 :: Int#) (u3 :: ByteArray#) -> case _#_ encodeFloat# [] [u1, u2, u3, 0#] of { _PRIM_ (u4 :: Float#) -> _!_ F# [] [u4] }; _NO_DEFLT_ } _N_ },
+ fromInt = { _A_ 1 _U_ 1 _N_ _S_ "U(P)" {_A_ 1 _U_ 2 _N_ _N_ _F_ _IF_ARGS_ 0 1 X 3 \ (u0 :: Int#) -> case _#_ int2Float# [] [u0] of { _PRIM_ (u1 :: Float#) -> _!_ F# [] [u1] } _N_} _F_ _IF_ARGS_ 0 1 C 4 \ (u0 :: Int) -> case u0 of { _ALG_ I# (u1 :: Int#) -> case _#_ int2Float# [] [u1] of { _PRIM_ (u2 :: Float#) -> _!_ F# [] [u2] }; _NO_DEFLT_ } _N_ } #-}
instance Num Int
{-# GHC_PRAGMA _M_ PreludeCore {-dfun-} _A_ 0 _N_ _N_ _N_ _F_ _IF_ARGS_ 0 0 X 11 _!_ _TUP_10 [{{Eq Int}}, {{Text Int}}, (Int -> Int -> Int), (Int -> Int -> Int), (Int -> Int -> Int), (Int -> Int), (Int -> Int), (Int -> Int), (Integer -> Int), (Int -> Int)] [_DFUN_ Eq (Int), _DFUN_ Text (Int), _CONSTM_ Num (+) (Int), _CONSTM_ Num (-) (Int), _CONSTM_ Num (*) (Int), _CONSTM_ Num negate (Int), _CONSTM_ Num abs (Int), _CONSTM_ Num signum (Int), _CONSTM_ Num fromInteger (Int), _CONSTM_ Num fromInt (Int)] _N_
- (+) = _A_ 2 _U_ 11 _N_ _S_ "U(P)U(P)" {_A_ 2 _U_ 22 _N_ _N_ _F_ _IF_ARGS_ 0 2 XX 3 \ (u0 :: Int#) (u1 :: Int#) -> case _#_ plusInt# [] [u0, u1] of { _PRIM_ (u2 :: Int#) -> _!_ I# [] [u2] } _N_} _F_ _IF_ARGS_ 0 2 CC 5 \ (u0 :: Int) (u1 :: Int) -> case u0 of { _ALG_ I# (u2 :: Int#) -> case u1 of { _ALG_ I# (u3 :: Int#) -> case _#_ plusInt# [] [u2, u3] of { _PRIM_ (u4 :: Int#) -> _!_ I# [] [u4] }; _NO_DEFLT_ }; _NO_DEFLT_ } _N_,
- (-) = _A_ 2 _U_ 11 _N_ _S_ "U(P)U(P)" {_A_ 2 _U_ 22 _N_ _N_ _F_ _IF_ARGS_ 0 2 XX 3 \ (u0 :: Int#) (u1 :: Int#) -> case _#_ minusInt# [] [u0, u1] of { _PRIM_ (u2 :: Int#) -> _!_ I# [] [u2] } _N_} _F_ _IF_ARGS_ 0 2 CC 5 \ (u0 :: Int) (u1 :: Int) -> case u0 of { _ALG_ I# (u2 :: Int#) -> case u1 of { _ALG_ I# (u3 :: Int#) -> case _#_ minusInt# [] [u2, u3] of { _PRIM_ (u4 :: Int#) -> _!_ I# [] [u4] }; _NO_DEFLT_ }; _NO_DEFLT_ } _N_,
- (*) = _A_ 2 _U_ 11 _N_ _S_ "U(P)U(P)" {_A_ 2 _U_ 22 _N_ _N_ _F_ _IF_ARGS_ 0 2 XX 3 \ (u0 :: Int#) (u1 :: Int#) -> case _#_ timesInt# [] [u0, u1] of { _PRIM_ (u2 :: Int#) -> _!_ I# [] [u2] } _N_} _F_ _IF_ARGS_ 0 2 CC 5 \ (u0 :: Int) (u1 :: Int) -> case u0 of { _ALG_ I# (u2 :: Int#) -> case u1 of { _ALG_ I# (u3 :: Int#) -> case _#_ timesInt# [] [u2, u3] of { _PRIM_ (u4 :: Int#) -> _!_ I# [] [u4] }; _NO_DEFLT_ }; _NO_DEFLT_ } _N_,
- negate = _A_ 1 _U_ 1 _N_ _S_ "U(P)" {_A_ 1 _U_ 2 _N_ _N_ _F_ _IF_ARGS_ 0 1 X 3 \ (u0 :: Int#) -> case _#_ negateInt# [] [u0] of { _PRIM_ (u1 :: Int#) -> _!_ I# [] [u1] } _N_} _F_ _IF_ARGS_ 0 1 C 4 \ (u0 :: Int) -> case u0 of { _ALG_ I# (u1 :: Int#) -> case _#_ negateInt# [] [u1] of { _PRIM_ (u2 :: Int#) -> _!_ I# [] [u2] }; _NO_DEFLT_ } _N_,
- abs = _A_ 1 _U_ 1 _N_ _S_ "U(P)" {_A_ 1 _U_ 2 _N_ _N_ _N_ _N_} _N_ _N_,
- signum = _A_ 1 _U_ 1 _N_ _S_ "U(P)" {_A_ 1 _U_ 2 _N_ _N_ _N_ _N_} _N_ _N_,
- fromInteger = _A_ 1 _U_ 1 _N_ _S_ "U(PPP)" {_A_ 3 _U_ 222 _N_ _N_ _F_ _IF_ARGS_ 0 3 XXX 3 \ (u0 :: Int#) (u1 :: Int#) (u2 :: ByteArray#) -> case _#_ integer2Int# [] [u0, u1, u2] of { _PRIM_ (u3 :: Int#) -> _!_ I# [] [u3] } _N_} _F_ _IF_ARGS_ 0 1 C 4 \ (u0 :: Integer) -> case u0 of { _ALG_ J# (u1 :: Int#) (u2 :: Int#) (u3 :: ByteArray#) -> case _#_ integer2Int# [] [u1, u2, u3] of { _PRIM_ (u4 :: Int#) -> _!_ I# [] [u4] }; _NO_DEFLT_ } _N_,
- fromInt = _A_ 1 _U_ 1 _N_ _S_ "U(P)" {_A_ 1 _U_ 2 _N_ _N_ _F_ _IF_ARGS_ 0 1 X 2 \ (u0 :: Int#) -> _!_ I# [] [u0] _N_} _F_ _IF_ARGS_ 0 1 X 1 \ (u0 :: Int) -> u0 _N_ #-}
+ (+) = { _A_ 2 _U_ 11 _N_ _S_ "U(P)U(P)" {_A_ 2 _U_ 22 _N_ _N_ _F_ _IF_ARGS_ 0 2 XX 3 \ (u0 :: Int#) (u1 :: Int#) -> case _#_ plusInt# [] [u0, u1] of { _PRIM_ (u2 :: Int#) -> _!_ I# [] [u2] } _N_} _F_ _IF_ARGS_ 0 2 CC 5 \ (u0 :: Int) (u1 :: Int) -> case u0 of { _ALG_ I# (u2 :: Int#) -> case u1 of { _ALG_ I# (u3 :: Int#) -> case _#_ plusInt# [] [u2, u3] of { _PRIM_ (u4 :: Int#) -> _!_ I# [] [u4] }; _NO_DEFLT_ }; _NO_DEFLT_ } _N_ },
+ (-) = { _A_ 2 _U_ 11 _N_ _S_ "U(P)U(P)" {_A_ 2 _U_ 22 _N_ _N_ _F_ _IF_ARGS_ 0 2 XX 3 \ (u0 :: Int#) (u1 :: Int#) -> case _#_ minusInt# [] [u0, u1] of { _PRIM_ (u2 :: Int#) -> _!_ I# [] [u2] } _N_} _F_ _IF_ARGS_ 0 2 CC 5 \ (u0 :: Int) (u1 :: Int) -> case u0 of { _ALG_ I# (u2 :: Int#) -> case u1 of { _ALG_ I# (u3 :: Int#) -> case _#_ minusInt# [] [u2, u3] of { _PRIM_ (u4 :: Int#) -> _!_ I# [] [u4] }; _NO_DEFLT_ }; _NO_DEFLT_ } _N_ },
+ (*) = { _A_ 2 _U_ 11 _N_ _S_ "U(P)U(P)" {_A_ 2 _U_ 22 _N_ _N_ _F_ _IF_ARGS_ 0 2 XX 3 \ (u0 :: Int#) (u1 :: Int#) -> case _#_ timesInt# [] [u0, u1] of { _PRIM_ (u2 :: Int#) -> _!_ I# [] [u2] } _N_} _F_ _IF_ARGS_ 0 2 CC 5 \ (u0 :: Int) (u1 :: Int) -> case u0 of { _ALG_ I# (u2 :: Int#) -> case u1 of { _ALG_ I# (u3 :: Int#) -> case _#_ timesInt# [] [u2, u3] of { _PRIM_ (u4 :: Int#) -> _!_ I# [] [u4] }; _NO_DEFLT_ }; _NO_DEFLT_ } _N_ },
+ negate = { _A_ 1 _U_ 1 _N_ _S_ "U(P)" {_A_ 1 _U_ 2 _N_ _N_ _F_ _IF_ARGS_ 0 1 X 3 \ (u0 :: Int#) -> case _#_ negateInt# [] [u0] of { _PRIM_ (u1 :: Int#) -> _!_ I# [] [u1] } _N_} _F_ _IF_ARGS_ 0 1 C 4 \ (u0 :: Int) -> case u0 of { _ALG_ I# (u1 :: Int#) -> case _#_ negateInt# [] [u1] of { _PRIM_ (u2 :: Int#) -> _!_ I# [] [u2] }; _NO_DEFLT_ } _N_ },
+ abs = { _A_ 1 _U_ 1 _N_ _S_ "U(P)" {_A_ 1 _U_ 2 _N_ _N_ _N_ _N_} _N_ _N_ },
+ signum = { _A_ 1 _U_ 1 _N_ _S_ "U(P)" {_A_ 1 _U_ 2 _N_ _N_ _N_ _N_} _N_ _N_ },
+ fromInteger = { _A_ 1 _U_ 1 _N_ _S_ "U(PPP)" {_A_ 3 _U_ 222 _N_ _N_ _F_ _IF_ARGS_ 0 3 XXX 3 \ (u0 :: Int#) (u1 :: Int#) (u2 :: ByteArray#) -> case _#_ integer2Int# [] [u0, u1, u2] of { _PRIM_ (u3 :: Int#) -> _!_ I# [] [u3] } _N_} _F_ _IF_ARGS_ 0 1 C 4 \ (u0 :: Integer) -> case u0 of { _ALG_ J# (u1 :: Int#) (u2 :: Int#) (u3 :: ByteArray#) -> case _#_ integer2Int# [] [u1, u2, u3] of { _PRIM_ (u4 :: Int#) -> _!_ I# [] [u4] }; _NO_DEFLT_ } _N_ },
+ fromInt = { _A_ 1 _U_ 1 _N_ _S_ "U(P)" {_A_ 1 _U_ 2 _N_ _N_ _F_ _IF_ARGS_ 0 1 X 2 \ (u0 :: Int#) -> _!_ I# [] [u0] _N_} _F_ _IF_ARGS_ 0 1 X 1 \ (u0 :: Int) -> u0 _N_ } #-}
instance Num Integer
{-# GHC_PRAGMA _M_ PreludeCore {-dfun-} _A_ 0 _N_ _N_ _N_ _F_ _IF_ARGS_ 0 0 X 11 _!_ _TUP_10 [{{Eq Integer}}, {{Text Integer}}, (Integer -> Integer -> Integer), (Integer -> Integer -> Integer), (Integer -> Integer -> Integer), (Integer -> Integer), (Integer -> Integer), (Integer -> Integer), (Integer -> Integer), (Int -> Integer)] [_DFUN_ Eq (Integer), _DFUN_ Text (Integer), _CONSTM_ Num (+) (Integer), _CONSTM_ Num (-) (Integer), _CONSTM_ Num (*) (Integer), _CONSTM_ Num negate (Integer), _CONSTM_ Num abs (Integer), _CONSTM_ Num signum (Integer), _CONSTM_ Num fromInteger (Integer), _CONSTM_ Num fromInt (Integer)] _N_
- (+) = _A_ 2 _U_ 11 _N_ _S_ "U(PPP)U(PPP)" {_A_ 4 _U_ 2221 _N_ _N_ _F_ _IF_ARGS_ 0 4 XXXC 5 \ (u0 :: Int#) (u1 :: Int#) (u2 :: ByteArray#) (u3 :: Integer) -> case u3 of { _ALG_ J# (u4 :: Int#) (u5 :: Int#) (u6 :: ByteArray#) -> _#_ plusInteger# [] [u0, u1, u2, u4, u5, u6]; _NO_DEFLT_ } _N_} _F_ _IF_ARGS_ 0 2 CC 6 \ (u0 :: Integer) (u1 :: Integer) -> case u0 of { _ALG_ J# (u2 :: Int#) (u3 :: Int#) (u4 :: ByteArray#) -> case u1 of { _ALG_ J# (u5 :: Int#) (u6 :: Int#) (u7 :: ByteArray#) -> _#_ plusInteger# [] [u2, u3, u4, u5, u6, u7]; _NO_DEFLT_ }; _NO_DEFLT_ } _N_,
- (-) = _A_ 2 _U_ 11 _N_ _S_ "U(PPP)U(PPP)" {_A_ 4 _U_ 2221 _N_ _N_ _F_ _IF_ARGS_ 0 4 XXXC 5 \ (u0 :: Int#) (u1 :: Int#) (u2 :: ByteArray#) (u3 :: Integer) -> case u3 of { _ALG_ J# (u4 :: Int#) (u5 :: Int#) (u6 :: ByteArray#) -> _#_ minusInteger# [] [u0, u1, u2, u4, u5, u6]; _NO_DEFLT_ } _N_} _F_ _IF_ARGS_ 0 2 CC 6 \ (u0 :: Integer) (u1 :: Integer) -> case u0 of { _ALG_ J# (u2 :: Int#) (u3 :: Int#) (u4 :: ByteArray#) -> case u1 of { _ALG_ J# (u5 :: Int#) (u6 :: Int#) (u7 :: ByteArray#) -> _#_ minusInteger# [] [u2, u3, u4, u5, u6, u7]; _NO_DEFLT_ }; _NO_DEFLT_ } _N_,
- (*) = _A_ 2 _U_ 11 _N_ _S_ "U(PPP)U(PPP)" {_A_ 4 _U_ 2221 _N_ _N_ _F_ _IF_ARGS_ 0 4 XXXC 5 \ (u0 :: Int#) (u1 :: Int#) (u2 :: ByteArray#) (u3 :: Integer) -> case u3 of { _ALG_ J# (u4 :: Int#) (u5 :: Int#) (u6 :: ByteArray#) -> _#_ timesInteger# [] [u0, u1, u2, u4, u5, u6]; _NO_DEFLT_ } _N_} _F_ _IF_ARGS_ 0 2 CC 6 \ (u0 :: Integer) (u1 :: Integer) -> case u0 of { _ALG_ J# (u2 :: Int#) (u3 :: Int#) (u4 :: ByteArray#) -> case u1 of { _ALG_ J# (u5 :: Int#) (u6 :: Int#) (u7 :: ByteArray#) -> _#_ timesInteger# [] [u2, u3, u4, u5, u6, u7]; _NO_DEFLT_ }; _NO_DEFLT_ } _N_,
- negate = _A_ 1 _U_ 1 _N_ _S_ "U(PPP)" {_A_ 3 _U_ 222 _N_ _N_ _F_ _IF_ARGS_ 0 3 XXX 4 \ (u0 :: Int#) (u1 :: Int#) (u2 :: ByteArray#) -> _#_ negateInteger# [] [u0, u1, u2] _N_} _F_ _IF_ARGS_ 0 1 C 5 \ (u0 :: Integer) -> case u0 of { _ALG_ J# (u1 :: Int#) (u2 :: Int#) (u3 :: ByteArray#) -> _#_ negateInteger# [] [u1, u2, u3]; _NO_DEFLT_ } _N_,
- abs = _A_ 1 _U_ 1 _N_ _S_ "U(PPP)" {_A_ 3 _U_ 222 _N_ _N_ _N_ _N_} _N_ _N_,
- signum = _A_ 1 _U_ 1 _N_ _S_ "U(PPP)" {_A_ 3 _U_ 222 _N_ _N_ _N_ _N_} _N_ _N_,
- fromInteger = _A_ 1 _U_ 1 _N_ _S_ "U(PPP)" {_A_ 3 _U_ 222 _N_ _N_ _F_ _IF_ARGS_ 0 3 XXX 4 \ (u0 :: Int#) (u1 :: Int#) (u2 :: ByteArray#) -> _!_ J# [] [u0, u1, u2] _N_} _F_ _IF_ARGS_ 0 1 X 1 \ (u0 :: Integer) -> u0 _N_,
- fromInt = _A_ 1 _U_ 1 _N_ _S_ "U(P)" {_A_ 1 _U_ 2 _N_ _N_ _F_ _IF_ARGS_ 0 1 X 1 \ (u0 :: Int#) -> _#_ int2Integer# [] [u0] _N_} _F_ _IF_ARGS_ 0 1 C 2 \ (u0 :: Int) -> case u0 of { _ALG_ I# (u1 :: Int#) -> _#_ int2Integer# [] [u1]; _NO_DEFLT_ } _N_ #-}
+ (+) = { _A_ 2 _U_ 11 _N_ _S_ "U(PPP)U(PPP)" {_A_ 4 _U_ 2221 _N_ _N_ _F_ _IF_ARGS_ 0 4 XXXC 5 \ (u0 :: Int#) (u1 :: Int#) (u2 :: ByteArray#) (u3 :: Integer) -> case u3 of { _ALG_ J# (u4 :: Int#) (u5 :: Int#) (u6 :: ByteArray#) -> _#_ plusInteger# [] [u0, u1, u2, u4, u5, u6]; _NO_DEFLT_ } _N_} _F_ _IF_ARGS_ 0 2 CC 6 \ (u0 :: Integer) (u1 :: Integer) -> case u0 of { _ALG_ J# (u2 :: Int#) (u3 :: Int#) (u4 :: ByteArray#) -> case u1 of { _ALG_ J# (u5 :: Int#) (u6 :: Int#) (u7 :: ByteArray#) -> _#_ plusInteger# [] [u2, u3, u4, u5, u6, u7]; _NO_DEFLT_ }; _NO_DEFLT_ } _N_ },
+ (-) = { _A_ 2 _U_ 11 _N_ _S_ "U(PPP)U(PPP)" {_A_ 4 _U_ 2221 _N_ _N_ _F_ _IF_ARGS_ 0 4 XXXC 5 \ (u0 :: Int#) (u1 :: Int#) (u2 :: ByteArray#) (u3 :: Integer) -> case u3 of { _ALG_ J# (u4 :: Int#) (u5 :: Int#) (u6 :: ByteArray#) -> _#_ minusInteger# [] [u0, u1, u2, u4, u5, u6]; _NO_DEFLT_ } _N_} _F_ _IF_ARGS_ 0 2 CC 6 \ (u0 :: Integer) (u1 :: Integer) -> case u0 of { _ALG_ J# (u2 :: Int#) (u3 :: Int#) (u4 :: ByteArray#) -> case u1 of { _ALG_ J# (u5 :: Int#) (u6 :: Int#) (u7 :: ByteArray#) -> _#_ minusInteger# [] [u2, u3, u4, u5, u6, u7]; _NO_DEFLT_ }; _NO_DEFLT_ } _N_ },
+ (*) = { _A_ 2 _U_ 11 _N_ _S_ "U(PPP)U(PPP)" {_A_ 4 _U_ 2221 _N_ _N_ _F_ _IF_ARGS_ 0 4 XXXC 5 \ (u0 :: Int#) (u1 :: Int#) (u2 :: ByteArray#) (u3 :: Integer) -> case u3 of { _ALG_ J# (u4 :: Int#) (u5 :: Int#) (u6 :: ByteArray#) -> _#_ timesInteger# [] [u0, u1, u2, u4, u5, u6]; _NO_DEFLT_ } _N_} _F_ _IF_ARGS_ 0 2 CC 6 \ (u0 :: Integer) (u1 :: Integer) -> case u0 of { _ALG_ J# (u2 :: Int#) (u3 :: Int#) (u4 :: ByteArray#) -> case u1 of { _ALG_ J# (u5 :: Int#) (u6 :: Int#) (u7 :: ByteArray#) -> _#_ timesInteger# [] [u2, u3, u4, u5, u6, u7]; _NO_DEFLT_ }; _NO_DEFLT_ } _N_ },
+ negate = { _A_ 1 _U_ 1 _N_ _S_ "U(PPP)" {_A_ 3 _U_ 222 _N_ _N_ _F_ _IF_ARGS_ 0 3 XXX 4 \ (u0 :: Int#) (u1 :: Int#) (u2 :: ByteArray#) -> _#_ negateInteger# [] [u0, u1, u2] _N_} _F_ _IF_ARGS_ 0 1 C 5 \ (u0 :: Integer) -> case u0 of { _ALG_ J# (u1 :: Int#) (u2 :: Int#) (u3 :: ByteArray#) -> _#_ negateInteger# [] [u1, u2, u3]; _NO_DEFLT_ } _N_ },
+ abs = { _A_ 1 _U_ 1 _N_ _S_ "U(PPP)" {_A_ 3 _U_ 222 _N_ _N_ _N_ _N_} _N_ _N_ },
+ signum = { _A_ 1 _U_ 1 _N_ _S_ "U(PPP)" {_A_ 3 _U_ 222 _N_ _N_ _N_ _N_} _N_ _N_ },
+ fromInteger = { _A_ 1 _U_ 1 _N_ _S_ "U(PPP)" {_A_ 3 _U_ 222 _N_ _N_ _F_ _IF_ARGS_ 0 3 XXX 4 \ (u0 :: Int#) (u1 :: Int#) (u2 :: ByteArray#) -> _!_ J# [] [u0, u1, u2] _N_} _F_ _IF_ARGS_ 0 1 X 1 \ (u0 :: Integer) -> u0 _N_ },
+ fromInt = { _A_ 1 _U_ 1 _N_ _S_ "U(P)" {_A_ 1 _U_ 2 _N_ _N_ _F_ _IF_ARGS_ 0 1 X 1 \ (u0 :: Int#) -> _#_ int2Integer# [] [u0] _N_} _F_ _IF_ARGS_ 0 1 C 2 \ (u0 :: Int) -> case u0 of { _ALG_ I# (u1 :: Int#) -> _#_ int2Integer# [] [u1]; _NO_DEFLT_ } _N_ } #-}
instance Integral a => Num (Ratio a)
{-# GHC_PRAGMA _M_ PreludeRatio {-dfun-} _A_ 3 _U_ 222 _N_ _N_ _N_ _N_ #-}
instance Num (Ratio Integer)
{-# GHC_PRAGMA _M_ PreludeRatio {-dfun-} _A_ 0 _N_ _N_ _N_ _F_ _IF_ARGS_ 0 0 X 11 _!_ _TUP_10 [{{Eq (Ratio Integer)}}, {{Text (Ratio Integer)}}, (Ratio Integer -> Ratio Integer -> Ratio Integer), (Ratio Integer -> Ratio Integer -> Ratio Integer), (Ratio Integer -> Ratio Integer -> Ratio Integer), (Ratio Integer -> Ratio Integer), (Ratio Integer -> Ratio Integer), (Ratio Integer -> Ratio Integer), (Integer -> Ratio Integer), (Int -> Ratio Integer)] [_DFUN_ Eq (Ratio Integer), _DFUN_ Text (Ratio Integer), _CONSTM_ Num (+) (Ratio Integer), _CONSTM_ Num (-) (Ratio Integer), _CONSTM_ Num (*) (Ratio Integer), _CONSTM_ Num negate (Ratio Integer), _CONSTM_ Num abs (Ratio Integer), _CONSTM_ Num signum (Ratio Integer), _CONSTM_ Num fromInteger (Ratio Integer), _CONSTM_ Num fromInt (Ratio Integer)] _N_
- (+) = _A_ 2 _U_ 11 _N_ _S_ "U(LU(PPP))U(LU(PPP))" {_A_ 5 _U_ 12221 _N_ _N_ _N_ _N_} _N_ _N_,
- (-) = _A_ 2 _U_ 11 _N_ _S_ "U(LU(PPP))U(LU(PPP))" {_A_ 5 _U_ 12221 _N_ _N_ _N_ _N_} _N_ _N_,
- (*) = _A_ 2 _U_ 11 _N_ _S_ "U(LU(PPP))U(LU(PPP))" {_A_ 5 _U_ 22221 _N_ _N_ _N_ _N_} _N_ _N_,
- negate = _A_ 1 _U_ 1 _N_ _S_ "U(LL)" {_A_ 2 _U_ 22 _N_ _N_ _N_ _N_} _N_ _N_,
- abs = _A_ 1 _U_ 1 _N_ _S_ "U(LL)" {_A_ 2 _U_ 12 _N_ _N_ _N_ _N_} _N_ _N_,
- signum = _A_ 1 _U_ 1 _N_ _S_ "U(LA)" {_A_ 1 _U_ 1 _N_ _N_ _N_ _N_} _N_ _N_,
- fromInteger = _A_ 1 _U_ 2 _N_ _N_ _N_ _N_,
- fromInt = _A_ 1 _U_ 1 _N_ _N_ _N_ _N_ #-}
+ (+) = { _A_ 2 _U_ 11 _N_ _S_ "U(LU(PPP))U(LU(PPP))" {_A_ 5 _U_ 12221 _N_ _N_ _N_ _N_} _N_ _N_ },
+ (-) = { _A_ 2 _U_ 11 _N_ _S_ "U(LU(PPP))U(LU(PPP))" {_A_ 5 _U_ 12221 _N_ _N_ _N_ _N_} _N_ _N_ },
+ (*) = { _A_ 2 _U_ 11 _N_ _S_ "U(LU(PPP))U(LU(PPP))" {_A_ 5 _U_ 22221 _N_ _N_ _N_ _N_} _N_ _N_ },
+ negate = { _A_ 1 _U_ 1 _N_ _S_ "U(LL)" {_A_ 2 _U_ 22 _N_ _N_ _N_ _N_} _N_ _N_ },
+ abs = { _A_ 1 _U_ 1 _N_ _S_ "U(LL)" {_A_ 2 _U_ 12 _N_ _N_ _N_ _N_} _N_ _N_ },
+ signum = { _A_ 1 _U_ 1 _N_ _S_ "U(LA)" {_A_ 1 _U_ 1 _N_ _N_ _N_ _N_} _N_ _N_ },
+ fromInteger = { _A_ 1 _U_ 2 _N_ _N_ _F_ _IF_ARGS_ 0 1 X 3 \ (u0 :: Integer) -> _!_ (:%) [Integer] [u0, _SPEC_ _ORIG_ PreludeCore __i1 [ (Integer) ]] _N_ },
+ fromInt = { _A_ 1 _U_ 1 _N_ _N_ _N_ _N_ } #-}
instance Ord ()
{-# GHC_PRAGMA _M_ PreludeBuiltin {-dfun-} _A_ 0 _N_ _N_ _N_ _F_ _IF_ARGS_ 0 0 X 9 _!_ _TUP_8 [{{Eq ()}}, (() -> () -> Bool), (() -> () -> Bool), (() -> () -> Bool), (() -> () -> Bool), (() -> () -> ()), (() -> () -> ()), (() -> () -> _CMP_TAG)] [_DFUN_ Eq (()), _CONSTM_ Ord (<) (()), _CONSTM_ Ord (<=) (()), _CONSTM_ Ord (>=) (()), _CONSTM_ Ord (>) (()), _CONSTM_ Ord max (()), _CONSTM_ Ord min (()), _CONSTM_ Ord _tagCmp (())] _N_
- (<) = _A_ 2 _U_ 11 _N_ _S_ "EE" _F_ _IF_ARGS_ 0 2 CC 3 \ (u0 :: ()) (u1 :: ()) -> case u0 of { _ALG_ _TUP_0 -> case u1 of { _ALG_ _TUP_0 -> _!_ False [] []; _NO_DEFLT_ }; _NO_DEFLT_ } _N_,
- (<=) = _A_ 2 _U_ 11 _N_ _S_ "EE" _F_ _IF_ARGS_ 0 2 CC 3 \ (u0 :: ()) (u1 :: ()) -> case u0 of { _ALG_ _TUP_0 -> case u1 of { _ALG_ _TUP_0 -> _!_ True [] []; _NO_DEFLT_ }; _NO_DEFLT_ } _N_,
- (>=) = _A_ 2 _U_ 11 _N_ _S_ "EE" _F_ _IF_ARGS_ 0 2 CC 3 \ (u0 :: ()) (u1 :: ()) -> case u0 of { _ALG_ _TUP_0 -> case u1 of { _ALG_ _TUP_0 -> _!_ True [] []; _NO_DEFLT_ }; _NO_DEFLT_ } _N_,
- (>) = _A_ 2 _U_ 11 _N_ _S_ "EE" _F_ _IF_ARGS_ 0 2 CC 3 \ (u0 :: ()) (u1 :: ()) -> case u0 of { _ALG_ _TUP_0 -> case u1 of { _ALG_ _TUP_0 -> _!_ False [] []; _NO_DEFLT_ }; _NO_DEFLT_ } _N_,
- max = _A_ 2 _U_ 11 _N_ _S_ "EE" _F_ _IF_ARGS_ 0 2 CX 2 \ (u0 :: ()) (u1 :: ()) -> case u0 of { _ALG_ _TUP_0 -> u1; _NO_DEFLT_ } _N_,
- min = _A_ 2 _U_ 11 _N_ _S_ "EE" _F_ _IF_ARGS_ 0 2 CX 2 \ (u0 :: ()) (u1 :: ()) -> case u0 of { _ALG_ _TUP_0 -> u1; _NO_DEFLT_ } _N_,
- _tagCmp = _A_ 2 _U_ 11 _N_ _S_ "EE" _F_ _IF_ARGS_ 0 2 CC 3 \ (u0 :: ()) (u1 :: ()) -> case u0 of { _ALG_ _TUP_0 -> case u1 of { _ALG_ _TUP_0 -> _!_ _EQ [] []; _NO_DEFLT_ }; _NO_DEFLT_ } _N_ #-}
+ (<) = { _A_ 2 _U_ 11 _N_ _S_ "EE" _F_ _IF_ARGS_ 0 2 CC 3 \ (u0 :: ()) (u1 :: ()) -> case u0 of { _ALG_ _TUP_0 -> case u1 of { _ALG_ _TUP_0 -> _!_ False [] []; _NO_DEFLT_ }; _NO_DEFLT_ } _N_ },
+ (<=) = { _A_ 2 _U_ 11 _N_ _S_ "EE" _F_ _IF_ARGS_ 0 2 CC 3 \ (u0 :: ()) (u1 :: ()) -> case u0 of { _ALG_ _TUP_0 -> case u1 of { _ALG_ _TUP_0 -> _!_ True [] []; _NO_DEFLT_ }; _NO_DEFLT_ } _N_ },
+ (>=) = { _A_ 2 _U_ 11 _N_ _S_ "EE" _F_ _IF_ARGS_ 0 2 CC 3 \ (u0 :: ()) (u1 :: ()) -> case u0 of { _ALG_ _TUP_0 -> case u1 of { _ALG_ _TUP_0 -> _!_ True [] []; _NO_DEFLT_ }; _NO_DEFLT_ } _N_ },
+ (>) = { _A_ 2 _U_ 11 _N_ _S_ "EE" _F_ _IF_ARGS_ 0 2 CC 3 \ (u0 :: ()) (u1 :: ()) -> case u0 of { _ALG_ _TUP_0 -> case u1 of { _ALG_ _TUP_0 -> _!_ False [] []; _NO_DEFLT_ }; _NO_DEFLT_ } _N_ },
+ max = { _A_ 2 _U_ 11 _N_ _S_ "EE" _F_ _IF_ARGS_ 0 2 CX 2 \ (u0 :: ()) (u1 :: ()) -> case u0 of { _ALG_ _TUP_0 -> u1; _NO_DEFLT_ } _N_ },
+ min = { _A_ 2 _U_ 11 _N_ _S_ "EE" _F_ _IF_ARGS_ 0 2 CX 2 \ (u0 :: ()) (u1 :: ()) -> case u0 of { _ALG_ _TUP_0 -> u1; _NO_DEFLT_ } _N_ },
+ _tagCmp = { _A_ 2 _U_ 11 _N_ _S_ "EE" _F_ _IF_ARGS_ 0 2 CC 3 \ (u0 :: ()) (u1 :: ()) -> case u0 of { _ALG_ _TUP_0 -> case u1 of { _ALG_ _TUP_0 -> _!_ _EQ [] []; _NO_DEFLT_ }; _NO_DEFLT_ } _N_ } #-}
instance (Ord a, Ord b) => Ord (a, b)
{-# GHC_PRAGMA _M_ PreludeBuiltin {-dfun-} _A_ 3 _U_ 112 _N_ _N_ _N_ _N_ #-}
instance (Ord a, Ord b, Ord c) => Ord (a, b, c)
{-# GHC_PRAGMA _M_ PreludeBuiltin {-dfun-} _A_ 6 _U_ 111112 _N_ _N_ _N_ _N_ #-}
instance Ord (Int, Int)
{-# GHC_PRAGMA _M_ PreludeBuiltin {-dfun-} _A_ 0 _N_ _N_ _N_ _F_ _IF_ARGS_ 0 0 X 9 _!_ _TUP_8 [{{Eq (Int, Int)}}, ((Int, Int) -> (Int, Int) -> Bool), ((Int, Int) -> (Int, Int) -> Bool), ((Int, Int) -> (Int, Int) -> Bool), ((Int, Int) -> (Int, Int) -> Bool), ((Int, Int) -> (Int, Int) -> (Int, Int)), ((Int, Int) -> (Int, Int) -> (Int, Int)), ((Int, Int) -> (Int, Int) -> _CMP_TAG)] [_DFUN_ Eq ((Int, Int)), _CONSTM_ Ord (<) ((Int, Int)), _CONSTM_ Ord (<=) ((Int, Int)), _CONSTM_ Ord (>=) ((Int, Int)), _CONSTM_ Ord (>) ((Int, Int)), _CONSTM_ Ord max ((Int, Int)), _CONSTM_ Ord min ((Int, Int)), _CONSTM_ Ord _tagCmp ((Int, Int))] _N_
- (<) = _A_ 2 _U_ 11 _N_ _S_ "U(U(P)L)U(U(P)L)" {_A_ 4 _U_ 2121 _N_ _N_ _N_ _N_} _N_ _N_,
- (<=) = _A_ 2 _U_ 11 _N_ _S_ "U(U(P)L)U(U(P)L)" {_A_ 4 _U_ 2121 _N_ _N_ _N_ _N_} _N_ _N_,
- (>=) = _A_ 2 _U_ 11 _N_ _S_ "U(U(P)L)U(U(P)L)" {_A_ 4 _U_ 2121 _N_ _N_ _N_ _N_} _N_ _N_,
- (>) = _A_ 2 _U_ 11 _N_ _S_ "U(U(P)L)U(U(P)L)" {_A_ 4 _U_ 2121 _N_ _N_ _N_ _N_} _N_ _N_,
- max = _A_ 2 _U_ 11 _N_ _S_ "U(U(P)L)U(U(P)L)" {_A_ 4 _U_ 2222 _N_ _N_ _N_ _N_} _N_ _N_,
- min = _A_ 2 _U_ 11 _N_ _S_ "U(U(P)L)U(U(P)L)" {_A_ 4 _U_ 2222 _N_ _N_ _N_ _N_} _N_ _N_,
- _tagCmp = _A_ 2 _U_ 11 _N_ _S_ "U(U(P)L)U(U(P)L)" {_A_ 4 _U_ 2121 _N_ _N_ _N_ _N_} _N_ _N_ #-}
+ (<) = { _A_ 2 _U_ 11 _N_ _S_ "U(U(P)L)U(U(P)L)" {_A_ 4 _U_ 2121 _N_ _N_ _N_ _N_} _N_ _N_ },
+ (<=) = { _A_ 2 _U_ 11 _N_ _S_ "U(U(P)L)U(U(P)L)" {_A_ 4 _U_ 2121 _N_ _N_ _N_ _N_} _N_ _N_ },
+ (>=) = { _A_ 2 _U_ 11 _N_ _S_ "U(U(P)L)U(U(P)L)" {_A_ 4 _U_ 2121 _N_ _N_ _N_ _N_} _N_ _N_ },
+ (>) = { _A_ 2 _U_ 11 _N_ _S_ "U(U(P)L)U(U(P)L)" {_A_ 4 _U_ 2121 _N_ _N_ _N_ _N_} _N_ _N_ },
+ max = { _A_ 2 _U_ 11 _N_ _S_ "U(U(P)L)U(U(P)L)" {_A_ 4 _U_ 2222 _N_ _N_ _N_ _N_} _N_ _N_ },
+ min = { _A_ 2 _U_ 11 _N_ _S_ "U(U(P)L)U(U(P)L)" {_A_ 4 _U_ 2222 _N_ _N_ _N_ _N_} _N_ _N_ },
+ _tagCmp = { _A_ 2 _U_ 11 _N_ _S_ "U(U(P)L)U(U(P)L)" {_A_ 4 _U_ 2121 _N_ _N_ _N_ _N_} _N_ _N_ } #-}
+instance Ord (Int, Int, Int)
+ {-# GHC_PRAGMA _M_ PreludeBuiltin {-dfun-} _A_ 0 _N_ _N_ _N_ _F_ _IF_ARGS_ 0 0 X 9 _!_ _TUP_8 [{{Eq (Int, Int, Int)}}, ((Int, Int, Int) -> (Int, Int, Int) -> Bool), ((Int, Int, Int) -> (Int, Int, Int) -> Bool), ((Int, Int, Int) -> (Int, Int, Int) -> Bool), ((Int, Int, Int) -> (Int, Int, Int) -> Bool), ((Int, Int, Int) -> (Int, Int, Int) -> (Int, Int, Int)), ((Int, Int, Int) -> (Int, Int, Int) -> (Int, Int, Int)), ((Int, Int, Int) -> (Int, Int, Int) -> _CMP_TAG)] [_DFUN_ Eq ((Int, Int, Int)), _CONSTM_ Ord (<) ((Int, Int, Int)), _CONSTM_ Ord (<=) ((Int, Int, Int)), _CONSTM_ Ord (>=) ((Int, Int, Int)), _CONSTM_ Ord (>) ((Int, Int, Int)), _CONSTM_ Ord max ((Int, Int, Int)), _CONSTM_ Ord min ((Int, Int, Int)), _CONSTM_ Ord _tagCmp ((Int, Int, Int))] _N_
+ (<) = { _A_ 2 _U_ 11 _N_ _S_ "U(U(P)LL)U(U(P)LL)" {_A_ 4 _U_ 2111 _N_ _N_ _N_ _N_} _N_ _N_ },
+ (<=) = { _A_ 2 _U_ 11 _N_ _S_ "U(U(P)LL)U(U(P)LL)" {_A_ 4 _U_ 2111 _N_ _N_ _N_ _N_} _N_ _N_ },
+ (>=) = { _A_ 2 _U_ 11 _N_ _S_ "U(U(P)LL)U(U(P)LL)" {_A_ 4 _U_ 2111 _N_ _N_ _N_ _N_} _N_ _N_ },
+ (>) = { _A_ 2 _U_ 11 _N_ _S_ "U(U(P)LL)U(U(P)LL)" {_A_ 4 _U_ 2111 _N_ _N_ _N_ _N_} _N_ _N_ },
+ max = { _A_ 2 _U_ 12 _N_ _S_ "U(U(P)LL)U(U(P)LL)" {_A_ 4 _U_ 2222 _N_ _N_ _N_ _N_} _N_ _N_ },
+ min = { _A_ 2 _U_ 12 _N_ _S_ "U(U(P)LL)U(U(P)LL)" {_A_ 4 _U_ 2222 _N_ _N_ _N_ _N_} _N_ _N_ },
+ _tagCmp = { _A_ 2 _U_ 11 _N_ _S_ "U(U(P)LL)U(U(P)LL)" {_A_ 4 _U_ 2111 _N_ _N_ _N_ _N_} _N_ _N_ } #-}
+instance Ord (Int, Int, Int, Int)
+ {-# GHC_PRAGMA _M_ PreludeBuiltin {-dfun-} _A_ 0 _N_ _N_ _N_ _F_ _IF_ARGS_ 0 0 X 9 _!_ _TUP_8 [{{Eq (Int, Int, Int, Int)}}, ((Int, Int, Int, Int) -> (Int, Int, Int, Int) -> Bool), ((Int, Int, Int, Int) -> (Int, Int, Int, Int) -> Bool), ((Int, Int, Int, Int) -> (Int, Int, Int, Int) -> Bool), ((Int, Int, Int, Int) -> (Int, Int, Int, Int) -> Bool), ((Int, Int, Int, Int) -> (Int, Int, Int, Int) -> (Int, Int, Int, Int)), ((Int, Int, Int, Int) -> (Int, Int, Int, Int) -> (Int, Int, Int, Int)), ((Int, Int, Int, Int) -> (Int, Int, Int, Int) -> _CMP_TAG)] [_DFUN_ Eq ((Int, Int, Int, Int)), _CONSTM_ Ord (<) ((Int, Int, Int, Int)), _CONSTM_ Ord (<=) ((Int, Int, Int, Int)), _CONSTM_ Ord (>=) ((Int, Int, Int, Int)), _CONSTM_ Ord (>) ((Int, Int, Int, Int)), _CONSTM_ Ord max ((Int, Int, Int, Int)), _CONSTM_ Ord min ((Int, Int, Int, Int)), _CONSTM_ Ord _tagCmp ((Int, Int, Int, Int))] _N_
+ (<) = { _A_ 2 _U_ 11 _N_ _S_ "U(U(P)LLL)U(U(P)LLL)" {_A_ 5 _U_ 21111 _N_ _N_ _N_ _N_} _N_ _N_ },
+ (<=) = { _A_ 2 _U_ 11 _N_ _S_ "U(U(P)LLL)U(U(P)LLL)" {_A_ 5 _U_ 21111 _N_ _N_ _N_ _N_} _N_ _N_ },
+ (>=) = { _A_ 2 _U_ 11 _N_ _S_ "U(U(P)LLL)U(U(P)LLL)" {_A_ 5 _U_ 21111 _N_ _N_ _N_ _N_} _N_ _N_ },
+ (>) = { _A_ 2 _U_ 11 _N_ _S_ "U(U(P)LLL)U(U(P)LLL)" {_A_ 5 _U_ 21111 _N_ _N_ _N_ _N_} _N_ _N_ },
+ max = { _A_ 2 _U_ 12 _N_ _S_ "U(U(P)LLL)U(U(P)LLL)" {_A_ 5 _U_ 22222 _N_ _N_ _N_ _N_} _N_ _N_ },
+ min = { _A_ 2 _U_ 12 _N_ _S_ "U(U(P)LLL)U(U(P)LLL)" {_A_ 5 _U_ 22222 _N_ _N_ _N_ _N_} _N_ _N_ },
+ _tagCmp = { _A_ 2 _U_ 11 _N_ _S_ "U(U(P)LLL)U(U(P)LLL)" {_A_ 5 _U_ 21111 _N_ _N_ _N_ _N_} _N_ _N_ } #-}
+instance Ord (Int, Int, Int, Int, Int)
+ {-# GHC_PRAGMA _M_ PreludeBuiltin {-dfun-} _A_ 0 _N_ _N_ _N_ _F_ _IF_ARGS_ 0 0 X 9 _!_ _TUP_8 [{{Eq (Int, Int, Int, Int, Int)}}, ((Int, Int, Int, Int, Int) -> (Int, Int, Int, Int, Int) -> Bool), ((Int, Int, Int, Int, Int) -> (Int, Int, Int, Int, Int) -> Bool), ((Int, Int, Int, Int, Int) -> (Int, Int, Int, Int, Int) -> Bool), ((Int, Int, Int, Int, Int) -> (Int, Int, Int, Int, Int) -> Bool), ((Int, Int, Int, Int, Int) -> (Int, Int, Int, Int, Int) -> (Int, Int, Int, Int, Int)), ((Int, Int, Int, Int, Int) -> (Int, Int, Int, Int, Int) -> (Int, Int, Int, Int, Int)), ((Int, Int, Int, Int, Int) -> (Int, Int, Int, Int, Int) -> _CMP_TAG)] [_DFUN_ Eq ((Int, Int, Int, Int, Int)), _CONSTM_ Ord (<) ((Int, Int, Int, Int, Int)), _CONSTM_ Ord (<=) ((Int, Int, Int, Int, Int)), _CONSTM_ Ord (>=) ((Int, Int, Int, Int, Int)), _CONSTM_ Ord (>) ((Int, Int, Int, Int, Int)), _CONSTM_ Ord max ((Int, Int, Int, Int, Int)), _CONSTM_ Ord min ((Int, Int, Int, Int, Int)), _CONSTM_ Ord _tagCmp ((Int, Int, Int, Int, Int))] _N_
+ (<) = { _A_ 2 _U_ 11 _N_ _S_ "U(U(P)LLLL)U(U(P)LLLL)" _N_ _N_ },
+ (<=) = { _A_ 2 _U_ 11 _N_ _S_ "U(U(P)LLLL)U(U(P)LLLL)" _N_ _N_ },
+ (>=) = { _A_ 2 _U_ 11 _N_ _S_ "U(U(P)LLLL)U(U(P)LLLL)" _N_ _N_ },
+ (>) = { _A_ 2 _U_ 11 _N_ _S_ "U(U(P)LLLL)U(U(P)LLLL)" _N_ _N_ },
+ max = { _A_ 2 _U_ 22 _N_ _S_ "U(U(P)LLLL)U(U(P)LLLL)" _N_ _N_ },
+ min = { _A_ 2 _U_ 22 _N_ _S_ "U(U(P)LLLL)U(U(P)LLLL)" _N_ _N_ },
+ _tagCmp = { _A_ 2 _U_ 11 _N_ _S_ "U(U(P)LLLL)U(U(P)LLLL)" _N_ _N_ } #-}
+instance Ord ([Char], [Char])
+ {-# GHC_PRAGMA _M_ PreludeBuiltin {-dfun-} _A_ 0 _N_ _N_ _N_ _F_ _IF_ARGS_ 0 0 X 9 _!_ _TUP_8 [{{Eq ([Char], [Char])}}, (([Char], [Char]) -> ([Char], [Char]) -> Bool), (([Char], [Char]) -> ([Char], [Char]) -> Bool), (([Char], [Char]) -> ([Char], [Char]) -> Bool), (([Char], [Char]) -> ([Char], [Char]) -> Bool), (([Char], [Char]) -> ([Char], [Char]) -> ([Char], [Char])), (([Char], [Char]) -> ([Char], [Char]) -> ([Char], [Char])), (([Char], [Char]) -> ([Char], [Char]) -> _CMP_TAG)] [_DFUN_ Eq (([Char], [Char])), _CONSTM_ Ord (<) (([Char], [Char])), _CONSTM_ Ord (<=) (([Char], [Char])), _CONSTM_ Ord (>=) (([Char], [Char])), _CONSTM_ Ord (>) (([Char], [Char])), _CONSTM_ Ord max (([Char], [Char])), _CONSTM_ Ord min (([Char], [Char])), _CONSTM_ Ord _tagCmp (([Char], [Char]))] _N_
+ (<) = { _A_ 2 _U_ 11 _N_ _S_ "U(SL)U(SL)" {_A_ 4 _U_ 2222 _N_ _N_ _N_ _N_} _N_ _N_ },
+ (<=) = { _A_ 2 _U_ 11 _N_ _S_ "U(SL)U(SL)" {_A_ 4 _U_ 2222 _N_ _N_ _N_ _N_} _N_ _N_ },
+ (>=) = { _A_ 2 _U_ 11 _N_ _S_ "U(SL)U(SL)" {_A_ 4 _U_ 2222 _N_ _N_ _N_ _N_} _N_ _N_ },
+ (>) = { _A_ 2 _U_ 11 _N_ _S_ "U(SL)U(SL)" {_A_ 4 _U_ 2222 _N_ _N_ _N_ _N_} _N_ _N_ },
+ max = { _A_ 2 _U_ 11 _N_ _S_ "U(SL)U(SL)" {_A_ 4 _U_ 2222 _N_ _N_ _N_ _N_} _N_ _N_ },
+ min = { _A_ 2 _U_ 11 _N_ _S_ "U(SL)U(SL)" {_A_ 4 _U_ 2222 _N_ _N_ _N_ _N_} _N_ _N_ },
+ _tagCmp = { _A_ 2 _U_ 11 _N_ _S_ "U(SL)U(SL)" {_A_ 4 _U_ 2222 _N_ _N_ _N_ _N_} _N_ _N_ } #-}
+instance Ord ([Int], [Int])
+ {-# GHC_PRAGMA _M_ PreludeBuiltin {-dfun-} _A_ 0 _N_ _N_ _N_ _F_ _IF_ARGS_ 0 0 X 9 _!_ _TUP_8 [{{Eq ([Int], [Int])}}, (([Int], [Int]) -> ([Int], [Int]) -> Bool), (([Int], [Int]) -> ([Int], [Int]) -> Bool), (([Int], [Int]) -> ([Int], [Int]) -> Bool), (([Int], [Int]) -> ([Int], [Int]) -> Bool), (([Int], [Int]) -> ([Int], [Int]) -> ([Int], [Int])), (([Int], [Int]) -> ([Int], [Int]) -> ([Int], [Int])), (([Int], [Int]) -> ([Int], [Int]) -> _CMP_TAG)] [_DFUN_ Eq (([Int], [Int])), _CONSTM_ Ord (<) (([Int], [Int])), _CONSTM_ Ord (<=) (([Int], [Int])), _CONSTM_ Ord (>=) (([Int], [Int])), _CONSTM_ Ord (>) (([Int], [Int])), _CONSTM_ Ord max (([Int], [Int])), _CONSTM_ Ord min (([Int], [Int])), _CONSTM_ Ord _tagCmp (([Int], [Int]))] _N_
+ (<) = { _A_ 2 _U_ 11 _N_ _S_ "U(SL)U(SL)" {_A_ 4 _U_ 2222 _N_ _N_ _N_ _N_} _N_ _N_ },
+ (<=) = { _A_ 2 _U_ 11 _N_ _S_ "U(SL)U(SL)" {_A_ 4 _U_ 2222 _N_ _N_ _N_ _N_} _N_ _N_ },
+ (>=) = { _A_ 2 _U_ 11 _N_ _S_ "U(SL)U(SL)" {_A_ 4 _U_ 2222 _N_ _N_ _N_ _N_} _N_ _N_ },
+ (>) = { _A_ 2 _U_ 11 _N_ _S_ "U(SL)U(SL)" {_A_ 4 _U_ 2222 _N_ _N_ _N_ _N_} _N_ _N_ },
+ max = { _A_ 2 _U_ 11 _N_ _S_ "U(SL)U(SL)" {_A_ 4 _U_ 2222 _N_ _N_ _N_ _N_} _N_ _N_ },
+ min = { _A_ 2 _U_ 11 _N_ _S_ "U(SL)U(SL)" {_A_ 4 _U_ 2222 _N_ _N_ _N_ _N_} _N_ _N_ },
+ _tagCmp = { _A_ 2 _U_ 11 _N_ _S_ "U(SL)U(SL)" {_A_ 4 _U_ 2222 _N_ _N_ _N_ _N_} _N_ _N_ } #-}
instance Ord (_PackedString, _PackedString)
{-# GHC_PRAGMA _M_ PreludeBuiltin {-dfun-} _A_ 0 _N_ _N_ _N_ _F_ _IF_ARGS_ 0 0 X 9 _!_ _TUP_8 [{{Eq (_PackedString, _PackedString)}}, ((_PackedString, _PackedString) -> (_PackedString, _PackedString) -> Bool), ((_PackedString, _PackedString) -> (_PackedString, _PackedString) -> Bool), ((_PackedString, _PackedString) -> (_PackedString, _PackedString) -> Bool), ((_PackedString, _PackedString) -> (_PackedString, _PackedString) -> Bool), ((_PackedString, _PackedString) -> (_PackedString, _PackedString) -> (_PackedString, _PackedString)), ((_PackedString, _PackedString) -> (_PackedString, _PackedString) -> (_PackedString, _PackedString)), ((_PackedString, _PackedString) -> (_PackedString, _PackedString) -> _CMP_TAG)] [_DFUN_ Eq ((_PackedString, _PackedString)), _CONSTM_ Ord (<) ((_PackedString, _PackedString)), _CONSTM_ Ord (<=) ((_PackedString, _PackedString)), _CONSTM_ Ord (>=) ((_PackedString, _PackedString)), _CONSTM_ Ord (>) ((_PackedString, _PackedString)), _CONSTM_ Ord max ((_PackedString, _PackedString)), _CONSTM_ Ord min ((_PackedString, _PackedString)), _CONSTM_ Ord _tagCmp ((_PackedString, _PackedString))] _N_
- (<) = _A_ 2 _U_ 11 _N_ _S_ "U(SL)U(SL)" {_A_ 4 _U_ 2222 _N_ _N_ _N_ _N_} _N_ _N_,
- (<=) = _A_ 2 _U_ 11 _N_ _S_ "U(SL)U(SL)" {_A_ 4 _U_ 2222 _N_ _N_ _N_ _N_} _N_ _N_,
- (>=) = _A_ 2 _U_ 11 _N_ _S_ "U(SL)U(SL)" {_A_ 4 _U_ 2222 _N_ _N_ _N_ _N_} _N_ _N_,
- (>) = _A_ 2 _U_ 11 _N_ _S_ "U(SL)U(SL)" {_A_ 4 _U_ 2222 _N_ _N_ _N_ _N_} _N_ _N_,
- max = _A_ 2 _U_ 11 _N_ _S_ "U(SL)U(SL)" {_A_ 4 _U_ 2222 _N_ _N_ _N_ _N_} _N_ _N_,
- min = _A_ 2 _U_ 11 _N_ _S_ "U(SL)U(SL)" {_A_ 4 _U_ 2222 _N_ _N_ _N_ _N_} _N_ _N_,
- _tagCmp = _A_ 2 _U_ 11 _N_ _S_ "U(SL)U(SL)" {_A_ 4 _U_ 2222 _N_ _N_ _N_ _N_} _N_ _N_ #-}
+ (<) = { _A_ 2 _U_ 11 _N_ _S_ "U(SL)U(SL)" {_A_ 4 _U_ 2222 _N_ _N_ _N_ _N_} _N_ _N_ },
+ (<=) = { _A_ 2 _U_ 11 _N_ _S_ "U(SL)U(SL)" {_A_ 4 _U_ 2222 _N_ _N_ _N_ _N_} _N_ _N_ },
+ (>=) = { _A_ 2 _U_ 11 _N_ _S_ "U(SL)U(SL)" {_A_ 4 _U_ 2222 _N_ _N_ _N_ _N_} _N_ _N_ },
+ (>) = { _A_ 2 _U_ 11 _N_ _S_ "U(SL)U(SL)" {_A_ 4 _U_ 2222 _N_ _N_ _N_ _N_} _N_ _N_ },
+ max = { _A_ 2 _U_ 11 _N_ _S_ "U(SL)U(SL)" {_A_ 4 _U_ 2222 _N_ _N_ _N_ _N_} _N_ _N_ },
+ min = { _A_ 2 _U_ 11 _N_ _S_ "U(SL)U(SL)" {_A_ 4 _U_ 2222 _N_ _N_ _N_ _N_} _N_ _N_ },
+ _tagCmp = { _A_ 2 _U_ 11 _N_ _S_ "U(SL)U(SL)" {_A_ 4 _U_ 2222 _N_ _N_ _N_ _N_} _N_ _N_ } #-}
instance (Ix a, Ord b) => Ord (Array a b)
{-# GHC_PRAGMA _M_ PreludeArray {-dfun-} _A_ 3 _U_ 222 _N_ _N_ _N_ _N_ #-}
instance (Ord a, Ord b) => Ord (Assoc a b)
{-# GHC_PRAGMA _M_ PreludeArray {-dfun-} _A_ 3 _U_ 112 _N_ _N_ _N_ _N_ #-}
instance Ord Bool
{-# GHC_PRAGMA _M_ PreludeCore {-dfun-} _A_ 0 _N_ _N_ _N_ _F_ _IF_ARGS_ 0 0 X 9 _!_ _TUP_8 [{{Eq Bool}}, (Bool -> Bool -> Bool), (Bool -> Bool -> Bool), (Bool -> Bool -> Bool), (Bool -> Bool -> Bool), (Bool -> Bool -> Bool), (Bool -> Bool -> Bool), (Bool -> Bool -> _CMP_TAG)] [_DFUN_ Eq (Bool), _CONSTM_ Ord (<) (Bool), _CONSTM_ Ord (<=) (Bool), _CONSTM_ Ord (>=) (Bool), _CONSTM_ Ord (>) (Bool), _CONSTM_ Ord max (Bool), _CONSTM_ Ord min (Bool), _CONSTM_ Ord _tagCmp (Bool)] _N_
- (<) = _A_ 2 _U_ 11 _N_ _S_ "EE" _N_ _N_,
- (<=) = _A_ 2 _U_ 11 _N_ _S_ "EE" _N_ _N_,
- (>=) = _A_ 2 _U_ 11 _N_ _S_ "EE" _N_ _N_,
- (>) = _A_ 2 _U_ 11 _N_ _S_ "EE" _N_ _N_,
- max = _A_ 2 _U_ 22 _N_ _S_ "EE" _N_ _N_,
- min = _A_ 2 _U_ 22 _N_ _S_ "EE" _N_ _N_,
- _tagCmp = _A_ 2 _U_ 11 _N_ _S_ "EE" _N_ _N_ #-}
+ (<) = { _A_ 2 _U_ 11 _N_ _S_ "EE" _N_ _N_ },
+ (<=) = { _A_ 2 _U_ 11 _N_ _S_ "EE" _N_ _N_ },
+ (>=) = { _A_ 2 _U_ 11 _N_ _S_ "EE" _N_ _N_ },
+ (>) = { _A_ 2 _U_ 11 _N_ _S_ "EE" _N_ _N_ },
+ max = { _A_ 2 _U_ 22 _N_ _S_ "EE" _N_ _N_ },
+ min = { _A_ 2 _U_ 22 _N_ _S_ "EE" _N_ _N_ },
+ _tagCmp = { _A_ 2 _U_ 11 _N_ _S_ "EE" _N_ _N_ } #-}
instance Ord Char
{-# GHC_PRAGMA _M_ PreludeCore {-dfun-} _A_ 0 _N_ _N_ _N_ _F_ _IF_ARGS_ 0 0 X 9 _!_ _TUP_8 [{{Eq Char}}, (Char -> Char -> Bool), (Char -> Char -> Bool), (Char -> Char -> Bool), (Char -> Char -> Bool), (Char -> Char -> Char), (Char -> Char -> Char), (Char -> Char -> _CMP_TAG)] [_DFUN_ Eq (Char), _CONSTM_ Ord (<) (Char), _CONSTM_ Ord (<=) (Char), _CONSTM_ Ord (>=) (Char), _CONSTM_ Ord (>) (Char), _CONSTM_ Ord max (Char), _CONSTM_ Ord min (Char), _CONSTM_ Ord _tagCmp (Char)] _N_
- (<) = _A_ 2 _U_ 11 _N_ _S_ "U(P)U(P)" {_A_ 2 _U_ 22 _N_ _N_ _F_ _IF_ARGS_ 0 2 XX 1 \ (u0 :: Char#) (u1 :: Char#) -> _#_ ltChar# [] [u0, u1] _N_} _F_ _IF_ARGS_ 0 2 CC 3 \ (u0 :: Char) (u1 :: Char) -> case u0 of { _ALG_ C# (u2 :: Char#) -> case u1 of { _ALG_ C# (u3 :: Char#) -> _#_ ltChar# [] [u2, u3]; _NO_DEFLT_ }; _NO_DEFLT_ } _N_,
- (<=) = _A_ 2 _U_ 11 _N_ _S_ "U(P)U(P)" {_A_ 2 _U_ 22 _N_ _N_ _F_ _IF_ARGS_ 0 2 XX 1 \ (u0 :: Char#) (u1 :: Char#) -> _#_ leChar# [] [u0, u1] _N_} _F_ _IF_ARGS_ 0 2 CC 3 \ (u0 :: Char) (u1 :: Char) -> case u0 of { _ALG_ C# (u2 :: Char#) -> case u1 of { _ALG_ C# (u3 :: Char#) -> _#_ leChar# [] [u2, u3]; _NO_DEFLT_ }; _NO_DEFLT_ } _N_,
- (>=) = _A_ 2 _U_ 11 _N_ _S_ "U(P)U(P)" {_A_ 2 _U_ 22 _N_ _N_ _F_ _IF_ARGS_ 0 2 XX 1 \ (u0 :: Char#) (u1 :: Char#) -> _#_ geChar# [] [u0, u1] _N_} _F_ _IF_ARGS_ 0 2 CC 3 \ (u0 :: Char) (u1 :: Char) -> case u0 of { _ALG_ C# (u2 :: Char#) -> case u1 of { _ALG_ C# (u3 :: Char#) -> _#_ geChar# [] [u2, u3]; _NO_DEFLT_ }; _NO_DEFLT_ } _N_,
- (>) = _A_ 2 _U_ 11 _N_ _S_ "U(P)U(P)" {_A_ 2 _U_ 22 _N_ _N_ _F_ _IF_ARGS_ 0 2 XX 1 \ (u0 :: Char#) (u1 :: Char#) -> _#_ gtChar# [] [u0, u1] _N_} _F_ _IF_ARGS_ 0 2 CC 3 \ (u0 :: Char) (u1 :: Char) -> case u0 of { _ALG_ C# (u2 :: Char#) -> case u1 of { _ALG_ C# (u3 :: Char#) -> _#_ gtChar# [] [u2, u3]; _NO_DEFLT_ }; _NO_DEFLT_ } _N_,
- max = _A_ 2 _U_ 11 _N_ _S_ "U(P)U(P)" {_A_ 2 _U_ 22 _N_ _N_ _N_ _N_} _N_ _N_,
- min = _A_ 2 _U_ 11 _N_ _S_ "U(P)U(P)" {_A_ 2 _U_ 22 _N_ _N_ _N_ _N_} _N_ _N_,
- _tagCmp = _A_ 2 _U_ 11 _N_ _S_ "U(P)U(P)" {_A_ 2 _U_ 22 _N_ _N_ _N_ _N_} _N_ _N_ #-}
+ (<) = { _A_ 2 _U_ 11 _N_ _S_ "U(P)U(P)" {_A_ 2 _U_ 22 _N_ _N_ _F_ _IF_ARGS_ 0 2 XX 1 \ (u0 :: Char#) (u1 :: Char#) -> _#_ ltChar# [] [u0, u1] _N_} _F_ _IF_ARGS_ 0 2 CC 3 \ (u0 :: Char) (u1 :: Char) -> case u0 of { _ALG_ C# (u2 :: Char#) -> case u1 of { _ALG_ C# (u3 :: Char#) -> _#_ ltChar# [] [u2, u3]; _NO_DEFLT_ }; _NO_DEFLT_ } _N_ },
+ (<=) = { _A_ 2 _U_ 11 _N_ _S_ "U(P)U(P)" {_A_ 2 _U_ 22 _N_ _N_ _F_ _IF_ARGS_ 0 2 XX 1 \ (u0 :: Char#) (u1 :: Char#) -> _#_ leChar# [] [u0, u1] _N_} _F_ _IF_ARGS_ 0 2 CC 3 \ (u0 :: Char) (u1 :: Char) -> case u0 of { _ALG_ C# (u2 :: Char#) -> case u1 of { _ALG_ C# (u3 :: Char#) -> _#_ leChar# [] [u2, u3]; _NO_DEFLT_ }; _NO_DEFLT_ } _N_ },
+ (>=) = { _A_ 2 _U_ 11 _N_ _S_ "U(P)U(P)" {_A_ 2 _U_ 22 _N_ _N_ _F_ _IF_ARGS_ 0 2 XX 1 \ (u0 :: Char#) (u1 :: Char#) -> _#_ geChar# [] [u0, u1] _N_} _F_ _IF_ARGS_ 0 2 CC 3 \ (u0 :: Char) (u1 :: Char) -> case u0 of { _ALG_ C# (u2 :: Char#) -> case u1 of { _ALG_ C# (u3 :: Char#) -> _#_ geChar# [] [u2, u3]; _NO_DEFLT_ }; _NO_DEFLT_ } _N_ },
+ (>) = { _A_ 2 _U_ 11 _N_ _S_ "U(P)U(P)" {_A_ 2 _U_ 22 _N_ _N_ _F_ _IF_ARGS_ 0 2 XX 1 \ (u0 :: Char#) (u1 :: Char#) -> _#_ gtChar# [] [u0, u1] _N_} _F_ _IF_ARGS_ 0 2 CC 3 \ (u0 :: Char) (u1 :: Char) -> case u0 of { _ALG_ C# (u2 :: Char#) -> case u1 of { _ALG_ C# (u3 :: Char#) -> _#_ gtChar# [] [u2, u3]; _NO_DEFLT_ }; _NO_DEFLT_ } _N_ },
+ max = { _A_ 2 _U_ 11 _N_ _S_ "U(P)U(P)" {_A_ 2 _U_ 22 _N_ _N_ _N_ _N_} _N_ _N_ },
+ min = { _A_ 2 _U_ 11 _N_ _S_ "U(P)U(P)" {_A_ 2 _U_ 22 _N_ _N_ _N_ _N_} _N_ _N_ },
+ _tagCmp = { _A_ 2 _U_ 11 _N_ _S_ "U(P)U(P)" {_A_ 2 _U_ 22 _N_ _N_ _N_ _N_} _N_ _N_ } #-}
instance Ord Double
{-# GHC_PRAGMA _M_ PreludeCore {-dfun-} _A_ 0 _N_ _N_ _N_ _F_ _IF_ARGS_ 0 0 X 9 _!_ _TUP_8 [{{Eq Double}}, (Double -> Double -> Bool), (Double -> Double -> Bool), (Double -> Double -> Bool), (Double -> Double -> Bool), (Double -> Double -> Double), (Double -> Double -> Double), (Double -> Double -> _CMP_TAG)] [_DFUN_ Eq (Double), _CONSTM_ Ord (<) (Double), _CONSTM_ Ord (<=) (Double), _CONSTM_ Ord (>=) (Double), _CONSTM_ Ord (>) (Double), _CONSTM_ Ord max (Double), _CONSTM_ Ord min (Double), _CONSTM_ Ord _tagCmp (Double)] _N_
- (<) = _A_ 2 _U_ 11 _N_ _S_ "U(P)U(P)" {_A_ 2 _U_ 22 _N_ _N_ _F_ _IF_ARGS_ 0 2 XX 1 \ (u0 :: Double#) (u1 :: Double#) -> _#_ ltDouble# [] [u0, u1] _N_} _F_ _IF_ARGS_ 0 2 CC 3 \ (u0 :: Double) (u1 :: Double) -> case u0 of { _ALG_ D# (u2 :: Double#) -> case u1 of { _ALG_ D# (u3 :: Double#) -> _#_ ltDouble# [] [u2, u3]; _NO_DEFLT_ }; _NO_DEFLT_ } _N_,
- (<=) = _A_ 2 _U_ 11 _N_ _S_ "U(P)U(P)" {_A_ 2 _U_ 22 _N_ _N_ _F_ _IF_ARGS_ 0 2 XX 1 \ (u0 :: Double#) (u1 :: Double#) -> _#_ leDouble# [] [u0, u1] _N_} _F_ _IF_ARGS_ 0 2 CC 3 \ (u0 :: Double) (u1 :: Double) -> case u0 of { _ALG_ D# (u2 :: Double#) -> case u1 of { _ALG_ D# (u3 :: Double#) -> _#_ leDouble# [] [u2, u3]; _NO_DEFLT_ }; _NO_DEFLT_ } _N_,
- (>=) = _A_ 2 _U_ 11 _N_ _S_ "U(P)U(P)" {_A_ 2 _U_ 22 _N_ _N_ _F_ _IF_ARGS_ 0 2 XX 1 \ (u0 :: Double#) (u1 :: Double#) -> _#_ geDouble# [] [u0, u1] _N_} _F_ _IF_ARGS_ 0 2 CC 3 \ (u0 :: Double) (u1 :: Double) -> case u0 of { _ALG_ D# (u2 :: Double#) -> case u1 of { _ALG_ D# (u3 :: Double#) -> _#_ geDouble# [] [u2, u3]; _NO_DEFLT_ }; _NO_DEFLT_ } _N_,
- (>) = _A_ 2 _U_ 11 _N_ _S_ "U(P)U(P)" {_A_ 2 _U_ 22 _N_ _N_ _F_ _IF_ARGS_ 0 2 XX 1 \ (u0 :: Double#) (u1 :: Double#) -> _#_ gtDouble# [] [u0, u1] _N_} _F_ _IF_ARGS_ 0 2 CC 3 \ (u0 :: Double) (u1 :: Double) -> case u0 of { _ALG_ D# (u2 :: Double#) -> case u1 of { _ALG_ D# (u3 :: Double#) -> _#_ gtDouble# [] [u2, u3]; _NO_DEFLT_ }; _NO_DEFLT_ } _N_,
- max = _A_ 2 _U_ 11 _N_ _S_ "U(P)U(P)" {_A_ 2 _U_ 22 _N_ _N_ _N_ _N_} _N_ _N_,
- min = _A_ 2 _U_ 11 _N_ _S_ "U(P)U(P)" {_A_ 2 _U_ 22 _N_ _N_ _N_ _N_} _N_ _N_,
- _tagCmp = _A_ 2 _U_ 11 _N_ _S_ "U(P)U(P)" {_A_ 2 _U_ 22 _N_ _N_ _N_ _N_} _N_ _N_ #-}
+ (<) = { _A_ 2 _U_ 11 _N_ _S_ "U(P)U(P)" {_A_ 2 _U_ 22 _N_ _N_ _F_ _IF_ARGS_ 0 2 XX 1 \ (u0 :: Double#) (u1 :: Double#) -> _#_ ltDouble# [] [u0, u1] _N_} _F_ _IF_ARGS_ 0 2 CC 3 \ (u0 :: Double) (u1 :: Double) -> case u0 of { _ALG_ D# (u2 :: Double#) -> case u1 of { _ALG_ D# (u3 :: Double#) -> _#_ ltDouble# [] [u2, u3]; _NO_DEFLT_ }; _NO_DEFLT_ } _N_ },
+ (<=) = { _A_ 2 _U_ 11 _N_ _S_ "U(P)U(P)" {_A_ 2 _U_ 22 _N_ _N_ _F_ _IF_ARGS_ 0 2 XX 1 \ (u0 :: Double#) (u1 :: Double#) -> _#_ leDouble# [] [u0, u1] _N_} _F_ _IF_ARGS_ 0 2 CC 3 \ (u0 :: Double) (u1 :: Double) -> case u0 of { _ALG_ D# (u2 :: Double#) -> case u1 of { _ALG_ D# (u3 :: Double#) -> _#_ leDouble# [] [u2, u3]; _NO_DEFLT_ }; _NO_DEFLT_ } _N_ },
+ (>=) = { _A_ 2 _U_ 11 _N_ _S_ "U(P)U(P)" {_A_ 2 _U_ 22 _N_ _N_ _F_ _IF_ARGS_ 0 2 XX 1 \ (u0 :: Double#) (u1 :: Double#) -> _#_ geDouble# [] [u0, u1] _N_} _F_ _IF_ARGS_ 0 2 CC 3 \ (u0 :: Double) (u1 :: Double) -> case u0 of { _ALG_ D# (u2 :: Double#) -> case u1 of { _ALG_ D# (u3 :: Double#) -> _#_ geDouble# [] [u2, u3]; _NO_DEFLT_ }; _NO_DEFLT_ } _N_ },
+ (>) = { _A_ 2 _U_ 11 _N_ _S_ "U(P)U(P)" {_A_ 2 _U_ 22 _N_ _N_ _F_ _IF_ARGS_ 0 2 XX 1 \ (u0 :: Double#) (u1 :: Double#) -> _#_ gtDouble# [] [u0, u1] _N_} _F_ _IF_ARGS_ 0 2 CC 3 \ (u0 :: Double) (u1 :: Double) -> case u0 of { _ALG_ D# (u2 :: Double#) -> case u1 of { _ALG_ D# (u3 :: Double#) -> _#_ gtDouble# [] [u2, u3]; _NO_DEFLT_ }; _NO_DEFLT_ } _N_ },
+ max = { _A_ 2 _U_ 11 _N_ _S_ "U(P)U(P)" {_A_ 2 _U_ 22 _N_ _N_ _N_ _N_} _N_ _N_ },
+ min = { _A_ 2 _U_ 11 _N_ _S_ "U(P)U(P)" {_A_ 2 _U_ 22 _N_ _N_ _N_ _N_} _N_ _N_ },
+ _tagCmp = { _A_ 2 _U_ 11 _N_ _S_ "U(P)U(P)" {_A_ 2 _U_ 22 _N_ _N_ _N_ _N_} _N_ _N_ } #-}
instance Ord Float
{-# GHC_PRAGMA _M_ PreludeCore {-dfun-} _A_ 0 _N_ _N_ _N_ _F_ _IF_ARGS_ 0 0 X 9 _!_ _TUP_8 [{{Eq Float}}, (Float -> Float -> Bool), (Float -> Float -> Bool), (Float -> Float -> Bool), (Float -> Float -> Bool), (Float -> Float -> Float), (Float -> Float -> Float), (Float -> Float -> _CMP_TAG)] [_DFUN_ Eq (Float), _CONSTM_ Ord (<) (Float), _CONSTM_ Ord (<=) (Float), _CONSTM_ Ord (>=) (Float), _CONSTM_ Ord (>) (Float), _CONSTM_ Ord max (Float), _CONSTM_ Ord min (Float), _CONSTM_ Ord _tagCmp (Float)] _N_
- (<) = _A_ 2 _U_ 11 _N_ _S_ "U(P)U(P)" {_A_ 2 _U_ 22 _N_ _N_ _F_ _IF_ARGS_ 0 2 XX 1 \ (u0 :: Float#) (u1 :: Float#) -> _#_ ltFloat# [] [u0, u1] _N_} _F_ _IF_ARGS_ 0 2 CC 3 \ (u0 :: Float) (u1 :: Float) -> case u0 of { _ALG_ F# (u2 :: Float#) -> case u1 of { _ALG_ F# (u3 :: Float#) -> _#_ ltFloat# [] [u2, u3]; _NO_DEFLT_ }; _NO_DEFLT_ } _N_,
- (<=) = _A_ 2 _U_ 11 _N_ _S_ "U(P)U(P)" {_A_ 2 _U_ 22 _N_ _N_ _F_ _IF_ARGS_ 0 2 XX 1 \ (u0 :: Float#) (u1 :: Float#) -> _#_ leFloat# [] [u0, u1] _N_} _F_ _IF_ARGS_ 0 2 CC 3 \ (u0 :: Float) (u1 :: Float) -> case u0 of { _ALG_ F# (u2 :: Float#) -> case u1 of { _ALG_ F# (u3 :: Float#) -> _#_ leFloat# [] [u2, u3]; _NO_DEFLT_ }; _NO_DEFLT_ } _N_,
- (>=) = _A_ 2 _U_ 11 _N_ _S_ "U(P)U(P)" {_A_ 2 _U_ 22 _N_ _N_ _F_ _IF_ARGS_ 0 2 XX 1 \ (u0 :: Float#) (u1 :: Float#) -> _#_ geFloat# [] [u0, u1] _N_} _F_ _IF_ARGS_ 0 2 CC 3 \ (u0 :: Float) (u1 :: Float) -> case u0 of { _ALG_ F# (u2 :: Float#) -> case u1 of { _ALG_ F# (u3 :: Float#) -> _#_ geFloat# [] [u2, u3]; _NO_DEFLT_ }; _NO_DEFLT_ } _N_,
- (>) = _A_ 2 _U_ 11 _N_ _S_ "U(P)U(P)" {_A_ 2 _U_ 22 _N_ _N_ _F_ _IF_ARGS_ 0 2 XX 1 \ (u0 :: Float#) (u1 :: Float#) -> _#_ gtFloat# [] [u0, u1] _N_} _F_ _IF_ARGS_ 0 2 CC 3 \ (u0 :: Float) (u1 :: Float) -> case u0 of { _ALG_ F# (u2 :: Float#) -> case u1 of { _ALG_ F# (u3 :: Float#) -> _#_ gtFloat# [] [u2, u3]; _NO_DEFLT_ }; _NO_DEFLT_ } _N_,
- max = _A_ 2 _U_ 11 _N_ _S_ "U(P)U(P)" {_A_ 2 _U_ 22 _N_ _N_ _N_ _N_} _N_ _N_,
- min = _A_ 2 _U_ 11 _N_ _S_ "U(P)U(P)" {_A_ 2 _U_ 22 _N_ _N_ _N_ _N_} _N_ _N_,
- _tagCmp = _A_ 2 _U_ 11 _N_ _S_ "U(P)U(P)" {_A_ 2 _U_ 22 _N_ _N_ _N_ _N_} _N_ _N_ #-}
+ (<) = { _A_ 2 _U_ 11 _N_ _S_ "U(P)U(P)" {_A_ 2 _U_ 22 _N_ _N_ _F_ _IF_ARGS_ 0 2 XX 1 \ (u0 :: Float#) (u1 :: Float#) -> _#_ ltFloat# [] [u0, u1] _N_} _F_ _IF_ARGS_ 0 2 CC 3 \ (u0 :: Float) (u1 :: Float) -> case u0 of { _ALG_ F# (u2 :: Float#) -> case u1 of { _ALG_ F# (u3 :: Float#) -> _#_ ltFloat# [] [u2, u3]; _NO_DEFLT_ }; _NO_DEFLT_ } _N_ },
+ (<=) = { _A_ 2 _U_ 11 _N_ _S_ "U(P)U(P)" {_A_ 2 _U_ 22 _N_ _N_ _F_ _IF_ARGS_ 0 2 XX 1 \ (u0 :: Float#) (u1 :: Float#) -> _#_ leFloat# [] [u0, u1] _N_} _F_ _IF_ARGS_ 0 2 CC 3 \ (u0 :: Float) (u1 :: Float) -> case u0 of { _ALG_ F# (u2 :: Float#) -> case u1 of { _ALG_ F# (u3 :: Float#) -> _#_ leFloat# [] [u2, u3]; _NO_DEFLT_ }; _NO_DEFLT_ } _N_ },
+ (>=) = { _A_ 2 _U_ 11 _N_ _S_ "U(P)U(P)" {_A_ 2 _U_ 22 _N_ _N_ _F_ _IF_ARGS_ 0 2 XX 1 \ (u0 :: Float#) (u1 :: Float#) -> _#_ geFloat# [] [u0, u1] _N_} _F_ _IF_ARGS_ 0 2 CC 3 \ (u0 :: Float) (u1 :: Float) -> case u0 of { _ALG_ F# (u2 :: Float#) -> case u1 of { _ALG_ F# (u3 :: Float#) -> _#_ geFloat# [] [u2, u3]; _NO_DEFLT_ }; _NO_DEFLT_ } _N_ },
+ (>) = { _A_ 2 _U_ 11 _N_ _S_ "U(P)U(P)" {_A_ 2 _U_ 22 _N_ _N_ _F_ _IF_ARGS_ 0 2 XX 1 \ (u0 :: Float#) (u1 :: Float#) -> _#_ gtFloat# [] [u0, u1] _N_} _F_ _IF_ARGS_ 0 2 CC 3 \ (u0 :: Float) (u1 :: Float) -> case u0 of { _ALG_ F# (u2 :: Float#) -> case u1 of { _ALG_ F# (u3 :: Float#) -> _#_ gtFloat# [] [u2, u3]; _NO_DEFLT_ }; _NO_DEFLT_ } _N_ },
+ max = { _A_ 2 _U_ 11 _N_ _S_ "U(P)U(P)" {_A_ 2 _U_ 22 _N_ _N_ _N_ _N_} _N_ _N_ },
+ min = { _A_ 2 _U_ 11 _N_ _S_ "U(P)U(P)" {_A_ 2 _U_ 22 _N_ _N_ _N_ _N_} _N_ _N_ },
+ _tagCmp = { _A_ 2 _U_ 11 _N_ _S_ "U(P)U(P)" {_A_ 2 _U_ 22 _N_ _N_ _N_ _N_} _N_ _N_ } #-}
instance Ord Int
{-# GHC_PRAGMA _M_ PreludeCore {-dfun-} _A_ 0 _N_ _N_ _N_ _F_ _IF_ARGS_ 0 0 X 9 _!_ _TUP_8 [{{Eq Int}}, (Int -> Int -> Bool), (Int -> Int -> Bool), (Int -> Int -> Bool), (Int -> Int -> Bool), (Int -> Int -> Int), (Int -> Int -> Int), (Int -> Int -> _CMP_TAG)] [_DFUN_ Eq (Int), _CONSTM_ Ord (<) (Int), _CONSTM_ Ord (<=) (Int), _CONSTM_ Ord (>=) (Int), _CONSTM_ Ord (>) (Int), _CONSTM_ Ord max (Int), _CONSTM_ Ord min (Int), _CONSTM_ Ord _tagCmp (Int)] _N_
- (<) = _A_ 2 _U_ 11 _N_ _S_ "U(P)U(P)" {_A_ 2 _U_ 22 _N_ _N_ _F_ _IF_ARGS_ 0 2 XX 1 \ (u0 :: Int#) (u1 :: Int#) -> _#_ ltInt# [] [u0, u1] _N_} _F_ _IF_ARGS_ 0 2 CC 3 \ (u0 :: Int) (u1 :: Int) -> case u0 of { _ALG_ I# (u2 :: Int#) -> case u1 of { _ALG_ I# (u3 :: Int#) -> _#_ ltInt# [] [u2, u3]; _NO_DEFLT_ }; _NO_DEFLT_ } _N_,
- (<=) = _A_ 2 _U_ 11 _N_ _S_ "U(P)U(P)" {_A_ 2 _U_ 22 _N_ _N_ _F_ _IF_ARGS_ 0 2 XX 1 \ (u0 :: Int#) (u1 :: Int#) -> _#_ leInt# [] [u0, u1] _N_} _F_ _IF_ARGS_ 0 2 CC 3 \ (u0 :: Int) (u1 :: Int) -> case u0 of { _ALG_ I# (u2 :: Int#) -> case u1 of { _ALG_ I# (u3 :: Int#) -> _#_ leInt# [] [u2, u3]; _NO_DEFLT_ }; _NO_DEFLT_ } _N_,
- (>=) = _A_ 2 _U_ 11 _N_ _S_ "U(P)U(P)" {_A_ 2 _U_ 22 _N_ _N_ _F_ _IF_ARGS_ 0 2 XX 1 \ (u0 :: Int#) (u1 :: Int#) -> _#_ geInt# [] [u0, u1] _N_} _F_ _IF_ARGS_ 0 2 CC 3 \ (u0 :: Int) (u1 :: Int) -> case u0 of { _ALG_ I# (u2 :: Int#) -> case u1 of { _ALG_ I# (u3 :: Int#) -> _#_ geInt# [] [u2, u3]; _NO_DEFLT_ }; _NO_DEFLT_ } _N_,
- (>) = _A_ 2 _U_ 11 _N_ _S_ "U(P)U(P)" {_A_ 2 _U_ 22 _N_ _N_ _F_ _IF_ARGS_ 0 2 XX 1 \ (u0 :: Int#) (u1 :: Int#) -> _#_ gtInt# [] [u0, u1] _N_} _F_ _IF_ARGS_ 0 2 CC 3 \ (u0 :: Int) (u1 :: Int) -> case u0 of { _ALG_ I# (u2 :: Int#) -> case u1 of { _ALG_ I# (u3 :: Int#) -> _#_ gtInt# [] [u2, u3]; _NO_DEFLT_ }; _NO_DEFLT_ } _N_,
- max = _A_ 2 _U_ 11 _N_ _S_ "U(P)U(P)" {_A_ 2 _U_ 22 _N_ _N_ _N_ _N_} _N_ _N_,
- min = _A_ 2 _U_ 11 _N_ _S_ "U(P)U(P)" {_A_ 2 _U_ 22 _N_ _N_ _N_ _N_} _N_ _N_,
- _tagCmp = _A_ 2 _U_ 11 _N_ _S_ "U(P)U(P)" {_A_ 2 _U_ 22 _N_ _N_ _N_ _N_} _N_ _N_ #-}
+ (<) = { _A_ 2 _U_ 11 _N_ _S_ "U(P)U(P)" {_A_ 2 _U_ 22 _N_ _N_ _F_ _IF_ARGS_ 0 2 XX 1 \ (u0 :: Int#) (u1 :: Int#) -> _#_ ltInt# [] [u0, u1] _N_} _F_ _IF_ARGS_ 0 2 CC 3 \ (u0 :: Int) (u1 :: Int) -> case u0 of { _ALG_ I# (u2 :: Int#) -> case u1 of { _ALG_ I# (u3 :: Int#) -> _#_ ltInt# [] [u2, u3]; _NO_DEFLT_ }; _NO_DEFLT_ } _N_ },
+ (<=) = { _A_ 2 _U_ 11 _N_ _S_ "U(P)U(P)" {_A_ 2 _U_ 22 _N_ _N_ _F_ _IF_ARGS_ 0 2 XX 1 \ (u0 :: Int#) (u1 :: Int#) -> _#_ leInt# [] [u0, u1] _N_} _F_ _IF_ARGS_ 0 2 CC 3 \ (u0 :: Int) (u1 :: Int) -> case u0 of { _ALG_ I# (u2 :: Int#) -> case u1 of { _ALG_ I# (u3 :: Int#) -> _#_ leInt# [] [u2, u3]; _NO_DEFLT_ }; _NO_DEFLT_ } _N_ },
+ (>=) = { _A_ 2 _U_ 11 _N_ _S_ "U(P)U(P)" {_A_ 2 _U_ 22 _N_ _N_ _F_ _IF_ARGS_ 0 2 XX 1 \ (u0 :: Int#) (u1 :: Int#) -> _#_ geInt# [] [u0, u1] _N_} _F_ _IF_ARGS_ 0 2 CC 3 \ (u0 :: Int) (u1 :: Int) -> case u0 of { _ALG_ I# (u2 :: Int#) -> case u1 of { _ALG_ I# (u3 :: Int#) -> _#_ geInt# [] [u2, u3]; _NO_DEFLT_ }; _NO_DEFLT_ } _N_ },
+ (>) = { _A_ 2 _U_ 11 _N_ _S_ "U(P)U(P)" {_A_ 2 _U_ 22 _N_ _N_ _F_ _IF_ARGS_ 0 2 XX 1 \ (u0 :: Int#) (u1 :: Int#) -> _#_ gtInt# [] [u0, u1] _N_} _F_ _IF_ARGS_ 0 2 CC 3 \ (u0 :: Int) (u1 :: Int) -> case u0 of { _ALG_ I# (u2 :: Int#) -> case u1 of { _ALG_ I# (u3 :: Int#) -> _#_ gtInt# [] [u2, u3]; _NO_DEFLT_ }; _NO_DEFLT_ } _N_ },
+ max = { _A_ 2 _U_ 11 _N_ _S_ "U(P)U(P)" {_A_ 2 _U_ 22 _N_ _N_ _N_ _N_} _N_ _N_ },
+ min = { _A_ 2 _U_ 11 _N_ _S_ "U(P)U(P)" {_A_ 2 _U_ 22 _N_ _N_ _N_ _N_} _N_ _N_ },
+ _tagCmp = { _A_ 2 _U_ 11 _N_ _S_ "U(P)U(P)" {_A_ 2 _U_ 22 _N_ _N_ _N_ _N_} _N_ _N_ } #-}
instance Ord Integer
{-# GHC_PRAGMA _M_ PreludeCore {-dfun-} _A_ 0 _N_ _N_ _N_ _F_ _IF_ARGS_ 0 0 X 9 _!_ _TUP_8 [{{Eq Integer}}, (Integer -> Integer -> Bool), (Integer -> Integer -> Bool), (Integer -> Integer -> Bool), (Integer -> Integer -> Bool), (Integer -> Integer -> Integer), (Integer -> Integer -> Integer), (Integer -> Integer -> _CMP_TAG)] [_DFUN_ Eq (Integer), _CONSTM_ Ord (<) (Integer), _CONSTM_ Ord (<=) (Integer), _CONSTM_ Ord (>=) (Integer), _CONSTM_ Ord (>) (Integer), _CONSTM_ Ord max (Integer), _CONSTM_ Ord min (Integer), _CONSTM_ Ord _tagCmp (Integer)] _N_
- (<) = _A_ 2 _U_ 11 _N_ _S_ "U(PPP)U(PPP)" {_A_ 4 _U_ 2221 _N_ _N_ _F_ _IF_ARGS_ 0 4 XXXC 3 \ (u0 :: Int#) (u1 :: Int#) (u2 :: ByteArray#) (u3 :: Integer) -> case u3 of { _ALG_ J# (u4 :: Int#) (u5 :: Int#) (u6 :: ByteArray#) -> case _#_ cmpInteger# [] [u0, u1, u2, u4, u5, u6] of { _PRIM_ (u7 :: Int#) -> _#_ ltInt# [] [u7, 0#] }; _NO_DEFLT_ } _N_} _F_ _IF_ARGS_ 0 2 CC 4 \ (u0 :: Integer) (u1 :: Integer) -> case u0 of { _ALG_ J# (u2 :: Int#) (u3 :: Int#) (u4 :: ByteArray#) -> case u1 of { _ALG_ J# (u5 :: Int#) (u6 :: Int#) (u7 :: ByteArray#) -> case _#_ cmpInteger# [] [u2, u3, u4, u5, u6, u7] of { _PRIM_ (u8 :: Int#) -> _#_ ltInt# [] [u8, 0#] }; _NO_DEFLT_ }; _NO_DEFLT_ } _N_,
- (<=) = _A_ 2 _U_ 11 _N_ _S_ "U(PPP)U(PPP)" {_A_ 4 _U_ 2221 _N_ _N_ _F_ _IF_ARGS_ 0 4 XXXC 3 \ (u0 :: Int#) (u1 :: Int#) (u2 :: ByteArray#) (u3 :: Integer) -> case u3 of { _ALG_ J# (u4 :: Int#) (u5 :: Int#) (u6 :: ByteArray#) -> case _#_ cmpInteger# [] [u0, u1, u2, u4, u5, u6] of { _PRIM_ (u7 :: Int#) -> _#_ leInt# [] [u7, 0#] }; _NO_DEFLT_ } _N_} _F_ _IF_ARGS_ 0 2 CC 4 \ (u0 :: Integer) (u1 :: Integer) -> case u0 of { _ALG_ J# (u2 :: Int#) (u3 :: Int#) (u4 :: ByteArray#) -> case u1 of { _ALG_ J# (u5 :: Int#) (u6 :: Int#) (u7 :: ByteArray#) -> case _#_ cmpInteger# [] [u2, u3, u4, u5, u6, u7] of { _PRIM_ (u8 :: Int#) -> _#_ leInt# [] [u8, 0#] }; _NO_DEFLT_ }; _NO_DEFLT_ } _N_,
- (>=) = _A_ 2 _U_ 11 _N_ _S_ "U(PPP)U(PPP)" {_A_ 4 _U_ 2221 _N_ _N_ _F_ _IF_ARGS_ 0 4 XXXC 3 \ (u0 :: Int#) (u1 :: Int#) (u2 :: ByteArray#) (u3 :: Integer) -> case u3 of { _ALG_ J# (u4 :: Int#) (u5 :: Int#) (u6 :: ByteArray#) -> case _#_ cmpInteger# [] [u0, u1, u2, u4, u5, u6] of { _PRIM_ (u7 :: Int#) -> _#_ geInt# [] [u7, 0#] }; _NO_DEFLT_ } _N_} _F_ _IF_ARGS_ 0 2 CC 4 \ (u0 :: Integer) (u1 :: Integer) -> case u0 of { _ALG_ J# (u2 :: Int#) (u3 :: Int#) (u4 :: ByteArray#) -> case u1 of { _ALG_ J# (u5 :: Int#) (u6 :: Int#) (u7 :: ByteArray#) -> case _#_ cmpInteger# [] [u2, u3, u4, u5, u6, u7] of { _PRIM_ (u8 :: Int#) -> _#_ geInt# [] [u8, 0#] }; _NO_DEFLT_ }; _NO_DEFLT_ } _N_,
- (>) = _A_ 2 _U_ 11 _N_ _S_ "U(PPP)U(PPP)" {_A_ 4 _U_ 2221 _N_ _N_ _F_ _IF_ARGS_ 0 4 XXXC 3 \ (u0 :: Int#) (u1 :: Int#) (u2 :: ByteArray#) (u3 :: Integer) -> case u3 of { _ALG_ J# (u4 :: Int#) (u5 :: Int#) (u6 :: ByteArray#) -> case _#_ cmpInteger# [] [u0, u1, u2, u4, u5, u6] of { _PRIM_ (u7 :: Int#) -> _#_ gtInt# [] [u7, 0#] }; _NO_DEFLT_ } _N_} _F_ _IF_ARGS_ 0 2 CC 4 \ (u0 :: Integer) (u1 :: Integer) -> case u0 of { _ALG_ J# (u2 :: Int#) (u3 :: Int#) (u4 :: ByteArray#) -> case u1 of { _ALG_ J# (u5 :: Int#) (u6 :: Int#) (u7 :: ByteArray#) -> case _#_ cmpInteger# [] [u2, u3, u4, u5, u6, u7] of { _PRIM_ (u8 :: Int#) -> _#_ gtInt# [] [u8, 0#] }; _NO_DEFLT_ }; _NO_DEFLT_ } _N_,
- max = _A_ 2 _U_ 11 _N_ _S_ "U(PPP)U(PPP)" {_A_ 4 _U_ 2221 _N_ _N_ _N_ _N_} _N_ _N_,
- min = _A_ 2 _U_ 11 _N_ _S_ "U(PPP)U(PPP)" {_A_ 4 _U_ 2221 _N_ _N_ _N_ _N_} _N_ _N_,
- _tagCmp = _A_ 2 _U_ 11 _N_ _S_ "U(PPP)U(PPP)" {_A_ 4 _U_ 2221 _N_ _N_ _N_ _N_} _N_ _N_ #-}
+ (<) = { _A_ 2 _U_ 11 _N_ _S_ "U(PPP)U(PPP)" {_A_ 4 _U_ 2221 _N_ _N_ _F_ _IF_ARGS_ 0 4 XXXC 3 \ (u0 :: Int#) (u1 :: Int#) (u2 :: ByteArray#) (u3 :: Integer) -> case u3 of { _ALG_ J# (u4 :: Int#) (u5 :: Int#) (u6 :: ByteArray#) -> case _#_ cmpInteger# [] [u0, u1, u2, u4, u5, u6] of { _PRIM_ (u7 :: Int#) -> _#_ ltInt# [] [u7, 0#] }; _NO_DEFLT_ } _N_} _F_ _IF_ARGS_ 0 2 CC 4 \ (u0 :: Integer) (u1 :: Integer) -> case u0 of { _ALG_ J# (u2 :: Int#) (u3 :: Int#) (u4 :: ByteArray#) -> case u1 of { _ALG_ J# (u5 :: Int#) (u6 :: Int#) (u7 :: ByteArray#) -> case _#_ cmpInteger# [] [u2, u3, u4, u5, u6, u7] of { _PRIM_ (u8 :: Int#) -> _#_ ltInt# [] [u8, 0#] }; _NO_DEFLT_ }; _NO_DEFLT_ } _N_ },
+ (<=) = { _A_ 2 _U_ 11 _N_ _S_ "U(PPP)U(PPP)" {_A_ 4 _U_ 2221 _N_ _N_ _F_ _IF_ARGS_ 0 4 XXXC 3 \ (u0 :: Int#) (u1 :: Int#) (u2 :: ByteArray#) (u3 :: Integer) -> case u3 of { _ALG_ J# (u4 :: Int#) (u5 :: Int#) (u6 :: ByteArray#) -> case _#_ cmpInteger# [] [u0, u1, u2, u4, u5, u6] of { _PRIM_ (u7 :: Int#) -> _#_ leInt# [] [u7, 0#] }; _NO_DEFLT_ } _N_} _F_ _IF_ARGS_ 0 2 CC 4 \ (u0 :: Integer) (u1 :: Integer) -> case u0 of { _ALG_ J# (u2 :: Int#) (u3 :: Int#) (u4 :: ByteArray#) -> case u1 of { _ALG_ J# (u5 :: Int#) (u6 :: Int#) (u7 :: ByteArray#) -> case _#_ cmpInteger# [] [u2, u3, u4, u5, u6, u7] of { _PRIM_ (u8 :: Int#) -> _#_ leInt# [] [u8, 0#] }; _NO_DEFLT_ }; _NO_DEFLT_ } _N_ },
+ (>=) = { _A_ 2 _U_ 11 _N_ _S_ "U(PPP)U(PPP)" {_A_ 4 _U_ 2221 _N_ _N_ _F_ _IF_ARGS_ 0 4 XXXC 3 \ (u0 :: Int#) (u1 :: Int#) (u2 :: ByteArray#) (u3 :: Integer) -> case u3 of { _ALG_ J# (u4 :: Int#) (u5 :: Int#) (u6 :: ByteArray#) -> case _#_ cmpInteger# [] [u0, u1, u2, u4, u5, u6] of { _PRIM_ (u7 :: Int#) -> _#_ geInt# [] [u7, 0#] }; _NO_DEFLT_ } _N_} _F_ _IF_ARGS_ 0 2 CC 4 \ (u0 :: Integer) (u1 :: Integer) -> case u0 of { _ALG_ J# (u2 :: Int#) (u3 :: Int#) (u4 :: ByteArray#) -> case u1 of { _ALG_ J# (u5 :: Int#) (u6 :: Int#) (u7 :: ByteArray#) -> case _#_ cmpInteger# [] [u2, u3, u4, u5, u6, u7] of { _PRIM_ (u8 :: Int#) -> _#_ geInt# [] [u8, 0#] }; _NO_DEFLT_ }; _NO_DEFLT_ } _N_ },
+ (>) = { _A_ 2 _U_ 11 _N_ _S_ "U(PPP)U(PPP)" {_A_ 4 _U_ 2221 _N_ _N_ _F_ _IF_ARGS_ 0 4 XXXC 3 \ (u0 :: Int#) (u1 :: Int#) (u2 :: ByteArray#) (u3 :: Integer) -> case u3 of { _ALG_ J# (u4 :: Int#) (u5 :: Int#) (u6 :: ByteArray#) -> case _#_ cmpInteger# [] [u0, u1, u2, u4, u5, u6] of { _PRIM_ (u7 :: Int#) -> _#_ gtInt# [] [u7, 0#] }; _NO_DEFLT_ } _N_} _F_ _IF_ARGS_ 0 2 CC 4 \ (u0 :: Integer) (u1 :: Integer) -> case u0 of { _ALG_ J# (u2 :: Int#) (u3 :: Int#) (u4 :: ByteArray#) -> case u1 of { _ALG_ J# (u5 :: Int#) (u6 :: Int#) (u7 :: ByteArray#) -> case _#_ cmpInteger# [] [u2, u3, u4, u5, u6, u7] of { _PRIM_ (u8 :: Int#) -> _#_ gtInt# [] [u8, 0#] }; _NO_DEFLT_ }; _NO_DEFLT_ } _N_ },
+ max = { _A_ 2 _U_ 11 _N_ _S_ "U(PPP)U(PPP)" {_A_ 4 _U_ 2221 _N_ _N_ _N_ _N_} _N_ _N_ },
+ min = { _A_ 2 _U_ 11 _N_ _S_ "U(PPP)U(PPP)" {_A_ 4 _U_ 2221 _N_ _N_ _N_ _N_} _N_ _N_ },
+ _tagCmp = { _A_ 2 _U_ 11 _N_ _S_ "U(PPP)U(PPP)" {_A_ 4 _U_ 2221 _N_ _N_ _N_ _N_} _N_ _N_ } #-}
instance Integral a => Ord (Ratio a)
{-# GHC_PRAGMA _M_ PreludeRatio {-dfun-} _A_ 2 _U_ 22 _N_ _N_ _N_ _N_ #-}
instance Ord (Ratio Integer)
{-# GHC_PRAGMA _M_ PreludeRatio {-dfun-} _A_ 0 _N_ _N_ _N_ _F_ _IF_ARGS_ 0 0 X 9 _!_ _TUP_8 [{{Eq (Ratio Integer)}}, (Ratio Integer -> Ratio Integer -> Bool), (Ratio Integer -> Ratio Integer -> Bool), (Ratio Integer -> Ratio Integer -> Bool), (Ratio Integer -> Ratio Integer -> Bool), (Ratio Integer -> Ratio Integer -> Ratio Integer), (Ratio Integer -> Ratio Integer -> Ratio Integer), (Ratio Integer -> Ratio Integer -> _CMP_TAG)] [_DFUN_ Eq (Ratio Integer), _CONSTM_ Ord (<) (Ratio Integer), _CONSTM_ Ord (<=) (Ratio Integer), _CONSTM_ Ord (>=) (Ratio Integer), _CONSTM_ Ord (>) (Ratio Integer), _CONSTM_ Ord max (Ratio Integer), _CONSTM_ Ord min (Ratio Integer), _CONSTM_ Ord _tagCmp (Ratio Integer)] _N_
- (<) = _A_ 2 _U_ 11 _N_ _S_ "U(U(PPP)U(PPP))U(U(PPP)U(PPP))" {_A_ 5 _U_ 22221 _N_ _N_ _N_ _N_} _N_ _N_,
- (<=) = _A_ 2 _U_ 11 _N_ _S_ "U(U(PPP)U(PPP))U(U(PPP)U(PPP))" {_A_ 5 _U_ 22221 _N_ _N_ _N_ _N_} _N_ _N_,
- (>=) = _A_ 2 _U_ 11 _N_ _S_ "U(U(PPP)U(PPP))U(U(PPP)U(PPP))" {_A_ 5 _U_ 22221 _N_ _N_ _N_ _N_} _N_ _N_,
- (>) = _A_ 2 _U_ 11 _N_ _S_ "U(U(PPP)U(PPP))U(U(PPP)U(PPP))" {_A_ 5 _U_ 22221 _N_ _N_ _N_ _N_} _N_ _N_,
- max = _A_ 2 _U_ 12 _N_ _S_ "U(U(PPP)U(PPP))U(U(PPP)U(PPP))" {_A_ 5 _U_ 22222 _N_ _N_ _N_ _N_} _N_ _N_,
- min = _A_ 2 _U_ 12 _N_ _S_ "U(U(PPP)U(PPP))U(U(PPP)U(PPP))" {_A_ 5 _U_ 22222 _N_ _N_ _N_ _N_} _N_ _N_,
- _tagCmp = _A_ 2 _U_ 11 _N_ _S_ "U(U(PPP)U(PPP))U(U(PPP)U(PPP))" {_A_ 5 _U_ 22221 _N_ _N_ _N_ _N_} _N_ _N_ #-}
+ (<) = { _A_ 2 _U_ 11 _N_ _S_ "U(U(PPP)U(PPP))U(U(PPP)U(PPP))" {_A_ 5 _U_ 22221 _N_ _N_ _N_ _N_} _N_ _N_ },
+ (<=) = { _A_ 2 _U_ 11 _N_ _S_ "U(U(PPP)U(PPP))U(U(PPP)U(PPP))" {_A_ 5 _U_ 22221 _N_ _N_ _N_ _N_} _N_ _N_ },
+ (>=) = { _A_ 2 _U_ 11 _N_ _S_ "U(U(PPP)U(PPP))U(U(PPP)U(PPP))" {_A_ 5 _U_ 22221 _N_ _N_ _N_ _N_} _N_ _N_ },
+ (>) = { _A_ 2 _U_ 11 _N_ _S_ "U(U(PPP)U(PPP))U(U(PPP)U(PPP))" {_A_ 5 _U_ 22221 _N_ _N_ _N_ _N_} _N_ _N_ },
+ max = { _A_ 2 _U_ 12 _N_ _S_ "U(U(PPP)U(PPP))U(U(PPP)U(PPP))" {_A_ 5 _U_ 22222 _N_ _N_ _N_ _N_} _N_ _N_ },
+ min = { _A_ 2 _U_ 12 _N_ _S_ "U(U(PPP)U(PPP))U(U(PPP)U(PPP))" {_A_ 5 _U_ 22222 _N_ _N_ _N_ _N_} _N_ _N_ },
+ _tagCmp = { _A_ 2 _U_ 11 _N_ _S_ "U(U(PPP)U(PPP))U(U(PPP)U(PPP))" {_A_ 5 _U_ 22221 _N_ _N_ _N_ _N_} _N_ _N_ } #-}
instance Ord a => Ord [a]
{-# GHC_PRAGMA _M_ PreludeBuiltin {-dfun-} _A_ 2 _U_ 12 _N_ _N_ _N_ _N_ #-}
+instance Ord [Bool]
+ {-# GHC_PRAGMA _M_ PreludeBuiltin {-dfun-} _A_ 0 _N_ _N_ _N_ _F_ _IF_ARGS_ 0 0 X 9 _!_ _TUP_8 [{{Eq [Bool]}}, ([Bool] -> [Bool] -> Bool), ([Bool] -> [Bool] -> Bool), ([Bool] -> [Bool] -> Bool), ([Bool] -> [Bool] -> Bool), ([Bool] -> [Bool] -> [Bool]), ([Bool] -> [Bool] -> [Bool]), ([Bool] -> [Bool] -> _CMP_TAG)] [_DFUN_ Eq ([Bool]), _CONSTM_ Ord (<) ([Bool]), _CONSTM_ Ord (<=) ([Bool]), _CONSTM_ Ord (>=) ([Bool]), _CONSTM_ Ord (>) ([Bool]), _CONSTM_ Ord max ([Bool]), _CONSTM_ Ord min ([Bool]), _CONSTM_ Ord _tagCmp ([Bool])] _N_
+ (<) = { _A_ 2 _U_ 11 _N_ _S_ "SS" _N_ _N_ },
+ (<=) = { _A_ 2 _U_ 11 _N_ _S_ "SS" _N_ _N_ },
+ (>=) = { _A_ 2 _U_ 11 _N_ _S_ "SS" _N_ _N_ },
+ (>) = { _A_ 2 _U_ 11 _N_ _S_ "SS" _N_ _N_ },
+ max = { _A_ 2 _U_ 22 _N_ _S_ "SS" _N_ _N_ },
+ min = { _A_ 2 _U_ 22 _N_ _S_ "SS" _N_ _N_ },
+ _tagCmp = { _A_ 2 _U_ 11 _N_ _S_ "SS" _N_ _N_ } #-}
instance Ord [Char]
{-# GHC_PRAGMA _M_ PreludeBuiltin {-dfun-} _A_ 0 _N_ _N_ _N_ _F_ _IF_ARGS_ 0 0 X 9 _!_ _TUP_8 [{{Eq [Char]}}, ([Char] -> [Char] -> Bool), ([Char] -> [Char] -> Bool), ([Char] -> [Char] -> Bool), ([Char] -> [Char] -> Bool), ([Char] -> [Char] -> [Char]), ([Char] -> [Char] -> [Char]), ([Char] -> [Char] -> _CMP_TAG)] [_DFUN_ Eq ([Char]), _CONSTM_ Ord (<) ([Char]), _CONSTM_ Ord (<=) ([Char]), _CONSTM_ Ord (>=) ([Char]), _CONSTM_ Ord (>) ([Char]), _CONSTM_ Ord max ([Char]), _CONSTM_ Ord min ([Char]), _CONSTM_ Ord _tagCmp ([Char])] _N_
- (<) = _A_ 2 _U_ 11 _N_ _S_ "SS" _N_ _N_,
- (<=) = _A_ 2 _U_ 11 _N_ _S_ "SS" _N_ _N_,
- (>=) = _A_ 2 _U_ 11 _N_ _S_ "SS" _N_ _N_,
- (>) = _A_ 2 _U_ 11 _N_ _S_ "SS" _N_ _N_,
- max = _A_ 2 _U_ 22 _N_ _S_ "SS" _N_ _N_,
- min = _A_ 2 _U_ 22 _N_ _S_ "SS" _N_ _N_,
- _tagCmp = _A_ 2 _U_ 11 _N_ _S_ "SS" _N_ _N_ #-}
+ (<) = { _A_ 2 _U_ 11 _N_ _S_ "SS" _N_ _N_ },
+ (<=) = { _A_ 2 _U_ 11 _N_ _S_ "SS" _N_ _N_ },
+ (>=) = { _A_ 2 _U_ 11 _N_ _S_ "SS" _N_ _N_ },
+ (>) = { _A_ 2 _U_ 11 _N_ _S_ "SS" _N_ _N_ },
+ max = { _A_ 2 _U_ 22 _N_ _S_ "SS" _N_ _N_ },
+ min = { _A_ 2 _U_ 22 _N_ _S_ "SS" _N_ _N_ },
+ _tagCmp = { _A_ 2 _U_ 11 _N_ _S_ "SS" _N_ _N_ } #-}
+instance Ord [Double]
+ {-# GHC_PRAGMA _M_ PreludeBuiltin {-dfun-} _A_ 0 _N_ _N_ _N_ _F_ _IF_ARGS_ 0 0 X 9 _!_ _TUP_8 [{{Eq [Double]}}, ([Double] -> [Double] -> Bool), ([Double] -> [Double] -> Bool), ([Double] -> [Double] -> Bool), ([Double] -> [Double] -> Bool), ([Double] -> [Double] -> [Double]), ([Double] -> [Double] -> [Double]), ([Double] -> [Double] -> _CMP_TAG)] [_DFUN_ Eq ([Double]), _CONSTM_ Ord (<) ([Double]), _CONSTM_ Ord (<=) ([Double]), _CONSTM_ Ord (>=) ([Double]), _CONSTM_ Ord (>) ([Double]), _CONSTM_ Ord max ([Double]), _CONSTM_ Ord min ([Double]), _CONSTM_ Ord _tagCmp ([Double])] _N_
+ (<) = { _A_ 2 _U_ 11 _N_ _S_ "SS" _N_ _N_ },
+ (<=) = { _A_ 2 _U_ 11 _N_ _S_ "SS" _N_ _N_ },
+ (>=) = { _A_ 2 _U_ 11 _N_ _S_ "SS" _N_ _N_ },
+ (>) = { _A_ 2 _U_ 11 _N_ _S_ "SS" _N_ _N_ },
+ max = { _A_ 2 _U_ 22 _N_ _S_ "SS" _N_ _N_ },
+ min = { _A_ 2 _U_ 22 _N_ _S_ "SS" _N_ _N_ },
+ _tagCmp = { _A_ 2 _U_ 11 _N_ _S_ "SS" _N_ _N_ } #-}
instance Ord [Int]
{-# GHC_PRAGMA _M_ PreludeBuiltin {-dfun-} _A_ 0 _N_ _N_ _N_ _F_ _IF_ARGS_ 0 0 X 9 _!_ _TUP_8 [{{Eq [Int]}}, ([Int] -> [Int] -> Bool), ([Int] -> [Int] -> Bool), ([Int] -> [Int] -> Bool), ([Int] -> [Int] -> Bool), ([Int] -> [Int] -> [Int]), ([Int] -> [Int] -> [Int]), ([Int] -> [Int] -> _CMP_TAG)] [_DFUN_ Eq ([Int]), _CONSTM_ Ord (<) ([Int]), _CONSTM_ Ord (<=) ([Int]), _CONSTM_ Ord (>=) ([Int]), _CONSTM_ Ord (>) ([Int]), _CONSTM_ Ord max ([Int]), _CONSTM_ Ord min ([Int]), _CONSTM_ Ord _tagCmp ([Int])] _N_
- (<) = _A_ 2 _U_ 11 _N_ _S_ "SS" _N_ _N_,
- (<=) = _A_ 2 _U_ 11 _N_ _S_ "SS" _N_ _N_,
- (>=) = _A_ 2 _U_ 11 _N_ _S_ "SS" _N_ _N_,
- (>) = _A_ 2 _U_ 11 _N_ _S_ "SS" _N_ _N_,
- max = _A_ 2 _U_ 22 _N_ _S_ "SS" _N_ _N_,
- min = _A_ 2 _U_ 22 _N_ _S_ "SS" _N_ _N_,
- _tagCmp = _A_ 2 _U_ 11 _N_ _S_ "SS" _N_ _N_ #-}
+ (<) = { _A_ 2 _U_ 11 _N_ _S_ "SS" _N_ _N_ },
+ (<=) = { _A_ 2 _U_ 11 _N_ _S_ "SS" _N_ _N_ },
+ (>=) = { _A_ 2 _U_ 11 _N_ _S_ "SS" _N_ _N_ },
+ (>) = { _A_ 2 _U_ 11 _N_ _S_ "SS" _N_ _N_ },
+ max = { _A_ 2 _U_ 22 _N_ _S_ "SS" _N_ _N_ },
+ min = { _A_ 2 _U_ 22 _N_ _S_ "SS" _N_ _N_ },
+ _tagCmp = { _A_ 2 _U_ 11 _N_ _S_ "SS" _N_ _N_ } #-}
+instance Ord [Integer]
+ {-# GHC_PRAGMA _M_ PreludeBuiltin {-dfun-} _A_ 0 _N_ _N_ _N_ _F_ _IF_ARGS_ 0 0 X 9 _!_ _TUP_8 [{{Eq [Integer]}}, ([Integer] -> [Integer] -> Bool), ([Integer] -> [Integer] -> Bool), ([Integer] -> [Integer] -> Bool), ([Integer] -> [Integer] -> Bool), ([Integer] -> [Integer] -> [Integer]), ([Integer] -> [Integer] -> [Integer]), ([Integer] -> [Integer] -> _CMP_TAG)] [_DFUN_ Eq ([Integer]), _CONSTM_ Ord (<) ([Integer]), _CONSTM_ Ord (<=) ([Integer]), _CONSTM_ Ord (>=) ([Integer]), _CONSTM_ Ord (>) ([Integer]), _CONSTM_ Ord max ([Integer]), _CONSTM_ Ord min ([Integer]), _CONSTM_ Ord _tagCmp ([Integer])] _N_
+ (<) = { _A_ 2 _U_ 11 _N_ _S_ "SS" _N_ _N_ },
+ (<=) = { _A_ 2 _U_ 11 _N_ _S_ "SS" _N_ _N_ },
+ (>=) = { _A_ 2 _U_ 11 _N_ _S_ "SS" _N_ _N_ },
+ (>) = { _A_ 2 _U_ 11 _N_ _S_ "SS" _N_ _N_ },
+ max = { _A_ 2 _U_ 22 _N_ _S_ "SS" _N_ _N_ },
+ min = { _A_ 2 _U_ 22 _N_ _S_ "SS" _N_ _N_ },
+ _tagCmp = { _A_ 2 _U_ 11 _N_ _S_ "SS" _N_ _N_ } #-}
+instance Ord [[Char]]
+ {-# GHC_PRAGMA _M_ PreludeBuiltin {-dfun-} _A_ 0 _N_ _N_ _N_ _F_ _IF_ARGS_ 0 0 X 9 _!_ _TUP_8 [{{Eq [[Char]]}}, ([[Char]] -> [[Char]] -> Bool), ([[Char]] -> [[Char]] -> Bool), ([[Char]] -> [[Char]] -> Bool), ([[Char]] -> [[Char]] -> Bool), ([[Char]] -> [[Char]] -> [[Char]]), ([[Char]] -> [[Char]] -> [[Char]]), ([[Char]] -> [[Char]] -> _CMP_TAG)] [_DFUN_ Eq ([[Char]]), _CONSTM_ Ord (<) ([[Char]]), _CONSTM_ Ord (<=) ([[Char]]), _CONSTM_ Ord (>=) ([[Char]]), _CONSTM_ Ord (>) ([[Char]]), _CONSTM_ Ord max ([[Char]]), _CONSTM_ Ord min ([[Char]]), _CONSTM_ Ord _tagCmp ([[Char]])] _N_
+ (<) = { _A_ 2 _U_ 11 _N_ _S_ "SS" _N_ _N_ },
+ (<=) = { _A_ 2 _U_ 11 _N_ _S_ "SS" _N_ _N_ },
+ (>=) = { _A_ 2 _U_ 11 _N_ _S_ "SS" _N_ _N_ },
+ (>) = { _A_ 2 _U_ 11 _N_ _S_ "SS" _N_ _N_ },
+ max = { _A_ 2 _U_ 22 _N_ _S_ "SS" _N_ _N_ },
+ min = { _A_ 2 _U_ 22 _N_ _S_ "SS" _N_ _N_ },
+ _tagCmp = { _A_ 2 _U_ 11 _N_ _S_ "SS" _N_ _N_ } #-}
+instance Ord [[Int]]
+ {-# GHC_PRAGMA _M_ PreludeBuiltin {-dfun-} _A_ 0 _N_ _N_ _N_ _F_ _IF_ARGS_ 0 0 X 9 _!_ _TUP_8 [{{Eq [[Int]]}}, ([[Int]] -> [[Int]] -> Bool), ([[Int]] -> [[Int]] -> Bool), ([[Int]] -> [[Int]] -> Bool), ([[Int]] -> [[Int]] -> Bool), ([[Int]] -> [[Int]] -> [[Int]]), ([[Int]] -> [[Int]] -> [[Int]]), ([[Int]] -> [[Int]] -> _CMP_TAG)] [_DFUN_ Eq ([[Int]]), _CONSTM_ Ord (<) ([[Int]]), _CONSTM_ Ord (<=) ([[Int]]), _CONSTM_ Ord (>=) ([[Int]]), _CONSTM_ Ord (>) ([[Int]]), _CONSTM_ Ord max ([[Int]]), _CONSTM_ Ord min ([[Int]]), _CONSTM_ Ord _tagCmp ([[Int]])] _N_
+ (<) = { _A_ 2 _U_ 11 _N_ _S_ "SS" _N_ _N_ },
+ (<=) = { _A_ 2 _U_ 11 _N_ _S_ "SS" _N_ _N_ },
+ (>=) = { _A_ 2 _U_ 11 _N_ _S_ "SS" _N_ _N_ },
+ (>) = { _A_ 2 _U_ 11 _N_ _S_ "SS" _N_ _N_ },
+ max = { _A_ 2 _U_ 22 _N_ _S_ "SS" _N_ _N_ },
+ min = { _A_ 2 _U_ 22 _N_ _S_ "SS" _N_ _N_ },
+ _tagCmp = { _A_ 2 _U_ 11 _N_ _S_ "SS" _N_ _N_ } #-}
instance Ord _Addr
{-# GHC_PRAGMA _M_ PreludeCore {-dfun-} _A_ 0 _N_ _N_ _N_ _F_ _IF_ARGS_ 0 0 X 9 _!_ _TUP_8 [{{Eq _Addr}}, (_Addr -> _Addr -> Bool), (_Addr -> _Addr -> Bool), (_Addr -> _Addr -> Bool), (_Addr -> _Addr -> Bool), (_Addr -> _Addr -> _Addr), (_Addr -> _Addr -> _Addr), (_Addr -> _Addr -> _CMP_TAG)] [_DFUN_ Eq (_Addr), _CONSTM_ Ord (<) (_Addr), _CONSTM_ Ord (<=) (_Addr), _CONSTM_ Ord (>=) (_Addr), _CONSTM_ Ord (>) (_Addr), _CONSTM_ Ord max (_Addr), _CONSTM_ Ord min (_Addr), _CONSTM_ Ord _tagCmp (_Addr)] _N_
- (<) = _A_ 2 _U_ 11 _N_ _S_ "U(P)U(P)" {_A_ 2 _U_ 22 _N_ _N_ _F_ _IF_ARGS_ 0 2 XX 1 \ (u0 :: Addr#) (u1 :: Addr#) -> _#_ ltAddr# [] [u0, u1] _N_} _F_ _IF_ARGS_ 0 2 CC 3 \ (u0 :: _Addr) (u1 :: _Addr) -> case u0 of { _ALG_ A# (u2 :: Addr#) -> case u1 of { _ALG_ A# (u3 :: Addr#) -> _#_ ltAddr# [] [u2, u3]; _NO_DEFLT_ }; _NO_DEFLT_ } _N_,
- (<=) = _A_ 2 _U_ 11 _N_ _S_ "U(P)U(P)" {_A_ 2 _U_ 22 _N_ _N_ _F_ _IF_ARGS_ 0 2 XX 1 \ (u0 :: Addr#) (u1 :: Addr#) -> _#_ leAddr# [] [u0, u1] _N_} _F_ _IF_ARGS_ 0 2 CC 3 \ (u0 :: _Addr) (u1 :: _Addr) -> case u0 of { _ALG_ A# (u2 :: Addr#) -> case u1 of { _ALG_ A# (u3 :: Addr#) -> _#_ leAddr# [] [u2, u3]; _NO_DEFLT_ }; _NO_DEFLT_ } _N_,
- (>=) = _A_ 2 _U_ 11 _N_ _S_ "U(P)U(P)" {_A_ 2 _U_ 22 _N_ _N_ _F_ _IF_ARGS_ 0 2 XX 1 \ (u0 :: Addr#) (u1 :: Addr#) -> _#_ geAddr# [] [u0, u1] _N_} _F_ _IF_ARGS_ 0 2 CC 3 \ (u0 :: _Addr) (u1 :: _Addr) -> case u0 of { _ALG_ A# (u2 :: Addr#) -> case u1 of { _ALG_ A# (u3 :: Addr#) -> _#_ geAddr# [] [u2, u3]; _NO_DEFLT_ }; _NO_DEFLT_ } _N_,
- (>) = _A_ 2 _U_ 11 _N_ _S_ "U(P)U(P)" {_A_ 2 _U_ 22 _N_ _N_ _F_ _IF_ARGS_ 0 2 XX 1 \ (u0 :: Addr#) (u1 :: Addr#) -> _#_ gtAddr# [] [u0, u1] _N_} _F_ _IF_ARGS_ 0 2 CC 3 \ (u0 :: _Addr) (u1 :: _Addr) -> case u0 of { _ALG_ A# (u2 :: Addr#) -> case u1 of { _ALG_ A# (u3 :: Addr#) -> _#_ gtAddr# [] [u2, u3]; _NO_DEFLT_ }; _NO_DEFLT_ } _N_,
- max = _A_ 2 _U_ 11 _N_ _S_ "U(P)U(P)" {_A_ 2 _U_ 22 _N_ _N_ _N_ _N_} _N_ _N_,
- min = _A_ 2 _U_ 11 _N_ _S_ "U(P)U(P)" {_A_ 2 _U_ 22 _N_ _N_ _N_ _N_} _N_ _N_,
- _tagCmp = _A_ 2 _U_ 11 _N_ _S_ "U(P)U(P)" {_A_ 2 _U_ 22 _N_ _N_ _N_ _N_} _N_ _N_ #-}
+ (<) = { _A_ 2 _U_ 11 _N_ _S_ "U(P)U(P)" {_A_ 2 _U_ 22 _N_ _N_ _F_ _IF_ARGS_ 0 2 XX 1 \ (u0 :: Addr#) (u1 :: Addr#) -> _#_ ltAddr# [] [u0, u1] _N_} _F_ _IF_ARGS_ 0 2 CC 3 \ (u0 :: _Addr) (u1 :: _Addr) -> case u0 of { _ALG_ A# (u2 :: Addr#) -> case u1 of { _ALG_ A# (u3 :: Addr#) -> _#_ ltAddr# [] [u2, u3]; _NO_DEFLT_ }; _NO_DEFLT_ } _N_ },
+ (<=) = { _A_ 2 _U_ 11 _N_ _S_ "U(P)U(P)" {_A_ 2 _U_ 22 _N_ _N_ _F_ _IF_ARGS_ 0 2 XX 1 \ (u0 :: Addr#) (u1 :: Addr#) -> _#_ leAddr# [] [u0, u1] _N_} _F_ _IF_ARGS_ 0 2 CC 3 \ (u0 :: _Addr) (u1 :: _Addr) -> case u0 of { _ALG_ A# (u2 :: Addr#) -> case u1 of { _ALG_ A# (u3 :: Addr#) -> _#_ leAddr# [] [u2, u3]; _NO_DEFLT_ }; _NO_DEFLT_ } _N_ },
+ (>=) = { _A_ 2 _U_ 11 _N_ _S_ "U(P)U(P)" {_A_ 2 _U_ 22 _N_ _N_ _F_ _IF_ARGS_ 0 2 XX 1 \ (u0 :: Addr#) (u1 :: Addr#) -> _#_ geAddr# [] [u0, u1] _N_} _F_ _IF_ARGS_ 0 2 CC 3 \ (u0 :: _Addr) (u1 :: _Addr) -> case u0 of { _ALG_ A# (u2 :: Addr#) -> case u1 of { _ALG_ A# (u3 :: Addr#) -> _#_ geAddr# [] [u2, u3]; _NO_DEFLT_ }; _NO_DEFLT_ } _N_ },
+ (>) = { _A_ 2 _U_ 11 _N_ _S_ "U(P)U(P)" {_A_ 2 _U_ 22 _N_ _N_ _F_ _IF_ARGS_ 0 2 XX 1 \ (u0 :: Addr#) (u1 :: Addr#) -> _#_ gtAddr# [] [u0, u1] _N_} _F_ _IF_ARGS_ 0 2 CC 3 \ (u0 :: _Addr) (u1 :: _Addr) -> case u0 of { _ALG_ A# (u2 :: Addr#) -> case u1 of { _ALG_ A# (u3 :: Addr#) -> _#_ gtAddr# [] [u2, u3]; _NO_DEFLT_ }; _NO_DEFLT_ } _N_ },
+ max = { _A_ 2 _U_ 11 _N_ _S_ "U(P)U(P)" {_A_ 2 _U_ 22 _N_ _N_ _N_ _N_} _N_ _N_ },
+ min = { _A_ 2 _U_ 11 _N_ _S_ "U(P)U(P)" {_A_ 2 _U_ 22 _N_ _N_ _N_ _N_} _N_ _N_ },
+ _tagCmp = { _A_ 2 _U_ 11 _N_ _S_ "U(P)U(P)" {_A_ 2 _U_ 22 _N_ _N_ _N_ _N_} _N_ _N_ } #-}
instance Ord _PackedString
{-# GHC_PRAGMA _M_ PreludePS {-dfun-} _A_ 0 _N_ _N_ _N_ _F_ _IF_ARGS_ 0 0 X 9 _!_ _TUP_8 [{{Eq _PackedString}}, (_PackedString -> _PackedString -> Bool), (_PackedString -> _PackedString -> Bool), (_PackedString -> _PackedString -> Bool), (_PackedString -> _PackedString -> Bool), (_PackedString -> _PackedString -> _PackedString), (_PackedString -> _PackedString -> _PackedString), (_PackedString -> _PackedString -> _CMP_TAG)] [_DFUN_ Eq (_PackedString), _CONSTM_ Ord (<) (_PackedString), _CONSTM_ Ord (<=) (_PackedString), _CONSTM_ Ord (>=) (_PackedString), _CONSTM_ Ord (>) (_PackedString), _CONSTM_ Ord max (_PackedString), _CONSTM_ Ord min (_PackedString), _CONSTM_ Ord _tagCmp (_PackedString)] _N_
- (<) = _A_ 2 _U_ 22 _N_ _S_ "SS" _N_ _N_,
- (<=) = _A_ 2 _U_ 22 _N_ _S_ "SS" _N_ _N_,
- (>=) = _A_ 2 _U_ 22 _N_ _S_ "SS" _N_ _N_,
- (>) = _A_ 2 _U_ 22 _N_ _S_ "SS" _N_ _N_,
- max = _A_ 2 _U_ 22 _N_ _N_ _N_ _N_,
- min = _A_ 2 _U_ 22 _N_ _N_ _N_ _N_,
- _tagCmp = _A_ 2 _U_ 22 _N_ _S_ "SS" _N_ _N_ #-}
+ (<) = { _A_ 2 _U_ 22 _N_ _S_ "SS" _N_ _N_ },
+ (<=) = { _A_ 2 _U_ 22 _N_ _S_ "SS" _N_ _N_ },
+ (>=) = { _A_ 2 _U_ 22 _N_ _S_ "SS" _N_ _N_ },
+ (>) = { _A_ 2 _U_ 22 _N_ _S_ "SS" _N_ _N_ },
+ max = { _A_ 2 _U_ 22 _N_ _S_ "SS" _N_ _N_ },
+ min = { _A_ 2 _U_ 22 _N_ _S_ "SS" _N_ _N_ },
+ _tagCmp = { _A_ 2 _U_ 22 _N_ _S_ "SS" _N_ _N_ } #-}
instance Ord _Word
{-# GHC_PRAGMA _M_ PreludeCore {-dfun-} _A_ 0 _N_ _N_ _N_ _F_ _IF_ARGS_ 0 0 X 9 _!_ _TUP_8 [{{Eq _Word}}, (_Word -> _Word -> Bool), (_Word -> _Word -> Bool), (_Word -> _Word -> Bool), (_Word -> _Word -> Bool), (_Word -> _Word -> _Word), (_Word -> _Word -> _Word), (_Word -> _Word -> _CMP_TAG)] [_DFUN_ Eq (_Word), _CONSTM_ Ord (<) (_Word), _CONSTM_ Ord (<=) (_Word), _CONSTM_ Ord (>=) (_Word), _CONSTM_ Ord (>) (_Word), _CONSTM_ Ord max (_Word), _CONSTM_ Ord min (_Word), _CONSTM_ Ord _tagCmp (_Word)] _N_
- (<) = _A_ 2 _U_ 11 _N_ _S_ "U(P)U(P)" {_A_ 2 _U_ 22 _N_ _N_ _F_ _IF_ARGS_ 0 2 XX 1 \ (u0 :: Word#) (u1 :: Word#) -> _#_ ltWord# [] [u0, u1] _N_} _F_ _IF_ARGS_ 0 2 CC 3 \ (u0 :: _Word) (u1 :: _Word) -> case u0 of { _ALG_ W# (u2 :: Word#) -> case u1 of { _ALG_ W# (u3 :: Word#) -> _#_ ltWord# [] [u2, u3]; _NO_DEFLT_ }; _NO_DEFLT_ } _N_,
- (<=) = _A_ 2 _U_ 11 _N_ _S_ "U(P)U(P)" {_A_ 2 _U_ 22 _N_ _N_ _F_ _IF_ARGS_ 0 2 XX 1 \ (u0 :: Word#) (u1 :: Word#) -> _#_ leWord# [] [u0, u1] _N_} _F_ _IF_ARGS_ 0 2 CC 3 \ (u0 :: _Word) (u1 :: _Word) -> case u0 of { _ALG_ W# (u2 :: Word#) -> case u1 of { _ALG_ W# (u3 :: Word#) -> _#_ leWord# [] [u2, u3]; _NO_DEFLT_ }; _NO_DEFLT_ } _N_,
- (>=) = _A_ 2 _U_ 11 _N_ _S_ "U(P)U(P)" {_A_ 2 _U_ 22 _N_ _N_ _F_ _IF_ARGS_ 0 2 XX 1 \ (u0 :: Word#) (u1 :: Word#) -> _#_ geWord# [] [u0, u1] _N_} _F_ _IF_ARGS_ 0 2 CC 3 \ (u0 :: _Word) (u1 :: _Word) -> case u0 of { _ALG_ W# (u2 :: Word#) -> case u1 of { _ALG_ W# (u3 :: Word#) -> _#_ geWord# [] [u2, u3]; _NO_DEFLT_ }; _NO_DEFLT_ } _N_,
- (>) = _A_ 2 _U_ 11 _N_ _S_ "U(P)U(P)" {_A_ 2 _U_ 22 _N_ _N_ _F_ _IF_ARGS_ 0 2 XX 1 \ (u0 :: Word#) (u1 :: Word#) -> _#_ gtWord# [] [u0, u1] _N_} _F_ _IF_ARGS_ 0 2 CC 3 \ (u0 :: _Word) (u1 :: _Word) -> case u0 of { _ALG_ W# (u2 :: Word#) -> case u1 of { _ALG_ W# (u3 :: Word#) -> _#_ gtWord# [] [u2, u3]; _NO_DEFLT_ }; _NO_DEFLT_ } _N_,
- max = _A_ 2 _U_ 11 _N_ _S_ "U(P)U(P)" {_A_ 2 _U_ 22 _N_ _N_ _N_ _N_} _N_ _N_,
- min = _A_ 2 _U_ 11 _N_ _S_ "U(P)U(P)" {_A_ 2 _U_ 22 _N_ _N_ _N_ _N_} _N_ _N_,
- _tagCmp = _A_ 2 _U_ 11 _N_ _S_ "U(P)U(P)" {_A_ 2 _U_ 22 _N_ _N_ _N_ _N_} _N_ _N_ #-}
+ (<) = { _A_ 2 _U_ 11 _N_ _S_ "U(P)U(P)" {_A_ 2 _U_ 22 _N_ _N_ _F_ _IF_ARGS_ 0 2 XX 1 \ (u0 :: Word#) (u1 :: Word#) -> _#_ ltWord# [] [u0, u1] _N_} _F_ _IF_ARGS_ 0 2 CC 3 \ (u0 :: _Word) (u1 :: _Word) -> case u0 of { _ALG_ W# (u2 :: Word#) -> case u1 of { _ALG_ W# (u3 :: Word#) -> _#_ ltWord# [] [u2, u3]; _NO_DEFLT_ }; _NO_DEFLT_ } _N_ },
+ (<=) = { _A_ 2 _U_ 11 _N_ _S_ "U(P)U(P)" {_A_ 2 _U_ 22 _N_ _N_ _F_ _IF_ARGS_ 0 2 XX 1 \ (u0 :: Word#) (u1 :: Word#) -> _#_ leWord# [] [u0, u1] _N_} _F_ _IF_ARGS_ 0 2 CC 3 \ (u0 :: _Word) (u1 :: _Word) -> case u0 of { _ALG_ W# (u2 :: Word#) -> case u1 of { _ALG_ W# (u3 :: Word#) -> _#_ leWord# [] [u2, u3]; _NO_DEFLT_ }; _NO_DEFLT_ } _N_ },
+ (>=) = { _A_ 2 _U_ 11 _N_ _S_ "U(P)U(P)" {_A_ 2 _U_ 22 _N_ _N_ _F_ _IF_ARGS_ 0 2 XX 1 \ (u0 :: Word#) (u1 :: Word#) -> _#_ geWord# [] [u0, u1] _N_} _F_ _IF_ARGS_ 0 2 CC 3 \ (u0 :: _Word) (u1 :: _Word) -> case u0 of { _ALG_ W# (u2 :: Word#) -> case u1 of { _ALG_ W# (u3 :: Word#) -> _#_ geWord# [] [u2, u3]; _NO_DEFLT_ }; _NO_DEFLT_ } _N_ },
+ (>) = { _A_ 2 _U_ 11 _N_ _S_ "U(P)U(P)" {_A_ 2 _U_ 22 _N_ _N_ _F_ _IF_ARGS_ 0 2 XX 1 \ (u0 :: Word#) (u1 :: Word#) -> _#_ gtWord# [] [u0, u1] _N_} _F_ _IF_ARGS_ 0 2 CC 3 \ (u0 :: _Word) (u1 :: _Word) -> case u0 of { _ALG_ W# (u2 :: Word#) -> case u1 of { _ALG_ W# (u3 :: Word#) -> _#_ gtWord# [] [u2, u3]; _NO_DEFLT_ }; _NO_DEFLT_ } _N_ },
+ max = { _A_ 2 _U_ 11 _N_ _S_ "U(P)U(P)" {_A_ 2 _U_ 22 _N_ _N_ _N_ _N_} _N_ _N_ },
+ min = { _A_ 2 _U_ 11 _N_ _S_ "U(P)U(P)" {_A_ 2 _U_ 22 _N_ _N_ _N_ _N_} _N_ _N_ },
+ _tagCmp = { _A_ 2 _U_ 11 _N_ _S_ "U(P)U(P)" {_A_ 2 _U_ 22 _N_ _N_ _N_ _N_} _N_ _N_ } #-}
instance Real Double
{-# GHC_PRAGMA _M_ PreludeCore {-dfun-} _A_ 0 _N_ _N_ _N_ _F_ _IF_ARGS_ 0 0 X 4 _!_ _TUP_3 [{{Num Double}}, {{Enum Double}}, (Double -> Ratio Integer)] [_DFUN_ Num (Double), _DFUN_ Enum (Double), _CONSTM_ Real toRational (Double)] _N_
- toRational = _A_ 1 _U_ 1 _N_ _S_ "U(P)" {_A_ 1 _U_ 2 _N_ _N_ _N_ _N_} _N_ _N_ #-}
+ toRational = { _A_ 1 _U_ 1 _N_ _S_ "U(P)" {_A_ 1 _U_ 2 _N_ _N_ _N_ _N_} _N_ _N_ } #-}
instance Real Float
{-# GHC_PRAGMA _M_ PreludeCore {-dfun-} _A_ 0 _N_ _N_ _N_ _F_ _IF_ARGS_ 0 0 X 4 _!_ _TUP_3 [{{Num Float}}, {{Enum Float}}, (Float -> Ratio Integer)] [_DFUN_ Num (Float), _DFUN_ Enum (Float), _CONSTM_ Real toRational (Float)] _N_
- toRational = _A_ 1 _U_ 1 _N_ _S_ "U(P)" {_A_ 1 _U_ 2 _N_ _N_ _N_ _N_} _N_ _N_ #-}
+ toRational = { _A_ 1 _U_ 1 _N_ _S_ "U(P)" {_A_ 1 _U_ 2 _N_ _N_ _N_ _N_} _N_ _N_ } #-}
instance Real Int
{-# GHC_PRAGMA _M_ PreludeCore {-dfun-} _A_ 0 _N_ _N_ _N_ _F_ _IF_ARGS_ 0 0 X 4 _!_ _TUP_3 [{{Num Int}}, {{Enum Int}}, (Int -> Ratio Integer)] [_DFUN_ Num (Int), _DFUN_ Enum (Int), _CONSTM_ Real toRational (Int)] _N_
- toRational = _A_ 1 _U_ 1 _N_ _N_ _N_ _N_ #-}
+ toRational = { _A_ 1 _U_ 1 _N_ _N_ _N_ _N_ } #-}
instance Real Integer
{-# GHC_PRAGMA _M_ PreludeCore {-dfun-} _A_ 0 _N_ _N_ _N_ _F_ _IF_ARGS_ 0 0 X 4 _!_ _TUP_3 [{{Num Integer}}, {{Enum Integer}}, (Integer -> Ratio Integer)] [_DFUN_ Num (Integer), _DFUN_ Enum (Integer), _CONSTM_ Real toRational (Integer)] _N_
- toRational = _A_ 1 _U_ 2 _N_ _N_ _N_ _N_ #-}
+ toRational = { _A_ 1 _U_ 2 _N_ _N_ _F_ _IF_ARGS_ 0 1 X 3 \ (u0 :: Integer) -> _!_ (:%) [Integer] [u0, _ORIG_ PreludeCore __integer1] _N_ } #-}
instance Integral a => Real (Ratio a)
{-# GHC_PRAGMA _M_ PreludeRatio {-dfun-} _A_ 3 _U_ 122 _N_ _N_ _N_ _N_ #-}
instance Real (Ratio Integer)
{-# GHC_PRAGMA _M_ PreludeRatio {-dfun-} _A_ 0 _N_ _N_ _N_ _F_ _IF_ARGS_ 0 0 X 4 _!_ _TUP_3 [{{Num (Ratio Integer)}}, {{Enum (Ratio Integer)}}, (Ratio Integer -> Ratio Integer)] [_DFUN_ Num (Ratio Integer), _DFUN_ Enum (Ratio Integer), _CONSTM_ Real toRational (Ratio Integer)] _N_
- toRational = _A_ 1 _U_ 1 _N_ _S_ "U(LL)" {_A_ 2 _U_ 22 _N_ _N_ _F_ _IF_ARGS_ 0 2 XX 3 \ (u0 :: Integer) (u1 :: Integer) -> _!_ (:%) [Integer] [u0, u1] _N_} _F_ _IF_ARGS_ 0 1 X 1 \ (u0 :: Ratio Integer) -> u0 _N_ #-}
+ toRational = { _A_ 1 _U_ 1 _N_ _S_ "U(LL)" {_A_ 2 _U_ 22 _N_ _N_ _F_ _IF_ARGS_ 0 2 XX 3 \ (u0 :: Integer) (u1 :: Integer) -> _!_ (:%) [Integer] [u0, u1] _N_} _F_ _IF_ARGS_ 0 1 X 1 \ (u0 :: Ratio Integer) -> u0 _N_ } #-}
instance RealFloat Double
{-# GHC_PRAGMA _M_ PreludeCore {-dfun-} _A_ 0 _N_ _N_ _N_ _F_ _IF_ARGS_ 0 0 X 11 _!_ _TUP_10 [{{RealFrac Double}}, {{Floating Double}}, (Double -> Integer), (Double -> Int), (Double -> (Int, Int)), (Double -> (Integer, Int)), (Integer -> Int -> Double), (Double -> Int), (Double -> Double), (Int -> Double -> Double)] [_DFUN_ RealFrac (Double), _DFUN_ Floating (Double), _CONSTM_ RealFloat floatRadix (Double), _CONSTM_ RealFloat floatDigits (Double), _CONSTM_ RealFloat floatRange (Double), _CONSTM_ RealFloat decodeFloat (Double), _CONSTM_ RealFloat encodeFloat (Double), _CONSTM_ RealFloat exponent (Double), _CONSTM_ RealFloat significand (Double), _CONSTM_ RealFloat scaleFloat (Double)] _N_
- floatRadix = _A_ 1 _U_ 0 _N_ _S_ "A" {_A_ 0 _N_ _N_ _N_ _F_ _IF_ARGS_ 0 0 X 1 _#_ int2Integer# [] [2#] _N_} _N_ _N_,
- floatDigits = _A_ 1 _U_ 0 _N_ _S_ "A" {_A_ 0 _N_ _N_ _N_ _F_ _IF_ARGS_ 0 0 X 2 _!_ I# [] [53#] _N_} _F_ _IF_ARGS_ 0 1 X 2 \ (u0 :: Double) -> _!_ I# [] [53#] _N_,
- floatRange = _A_ 1 _U_ 0 _N_ _S_ "A" {_A_ 0 _N_ _N_ _N_ _N_ _N_} _N_ _N_,
- decodeFloat = _A_ 1 _U_ 1 _N_ _S_ "U(P)" {_A_ 1 _U_ 2 _N_ _N_ _N_ _N_} _N_ _N_,
- encodeFloat = _A_ 2 _U_ 11 _N_ _S_ "U(PPP)U(P)" {_A_ 4 _U_ 2222 _N_ _N_ _F_ _IF_ARGS_ 0 4 XXXX 3 \ (u0 :: Int#) (u1 :: Int#) (u2 :: ByteArray#) (u3 :: Int#) -> case _#_ encodeDouble# [] [u0, u1, u2, u3] of { _PRIM_ (u4 :: Double#) -> _!_ D# [] [u4] } _N_} _F_ _IF_ARGS_ 0 2 CC 5 \ (u0 :: Integer) (u1 :: Int) -> case u0 of { _ALG_ J# (u2 :: Int#) (u3 :: Int#) (u4 :: ByteArray#) -> case u1 of { _ALG_ I# (u5 :: Int#) -> case _#_ encodeDouble# [] [u2, u3, u4, u5] of { _PRIM_ (u6 :: Double#) -> _!_ D# [] [u6] }; _NO_DEFLT_ }; _NO_DEFLT_ } _N_,
- exponent = _A_ 1 _U_ 2 _N_ _N_ _N_ _N_,
- significand = _A_ 1 _U_ 2 _N_ _N_ _N_ _N_,
- scaleFloat = _A_ 2 _U_ 22 _N_ _N_ _N_ _N_ #-}
+ floatRadix = { _A_ 1 _U_ 0 _N_ _S_ "A" {_A_ 0 _N_ _N_ _N_ _N_ _N_} _N_ _N_ },
+ floatDigits = { _A_ 1 _U_ 0 _N_ _S_ "A" {_A_ 0 _N_ _N_ _N_ _F_ _IF_ARGS_ 0 0 X 2 _!_ I# [] [53#] _N_} _F_ _IF_ARGS_ 0 1 X 2 \ (u0 :: Double) -> _!_ I# [] [53#] _N_ },
+ floatRange = { _A_ 1 _U_ 0 _N_ _S_ "A" {_A_ 0 _N_ _N_ _N_ _N_ _N_} _N_ _N_ },
+ decodeFloat = { _A_ 1 _U_ 1 _N_ _S_ "U(P)" {_A_ 1 _U_ 2 _N_ _N_ _N_ _N_} _N_ _N_ },
+ encodeFloat = { _A_ 2 _U_ 11 _N_ _S_ "U(PPP)U(P)" {_A_ 4 _U_ 2222 _N_ _N_ _F_ _IF_ARGS_ 0 4 XXXX 3 \ (u0 :: Int#) (u1 :: Int#) (u2 :: ByteArray#) (u3 :: Int#) -> case _#_ encodeDouble# [] [u0, u1, u2, u3] of { _PRIM_ (u4 :: Double#) -> _!_ D# [] [u4] } _N_} _F_ _IF_ARGS_ 0 2 CC 5 \ (u0 :: Integer) (u1 :: Int) -> case u0 of { _ALG_ J# (u2 :: Int#) (u3 :: Int#) (u4 :: ByteArray#) -> case u1 of { _ALG_ I# (u5 :: Int#) -> case _#_ encodeDouble# [] [u2, u3, u4, u5] of { _PRIM_ (u6 :: Double#) -> _!_ D# [] [u6] }; _NO_DEFLT_ }; _NO_DEFLT_ } _N_ },
+ exponent = { _A_ 1 _U_ 1 _N_ _S_ "U(P)" {_A_ 1 _U_ 2 _N_ _N_ _N_ _N_} _N_ _N_ },
+ significand = { _A_ 1 _U_ 1 _N_ _S_ "U(P)" {_A_ 1 _U_ 2 _N_ _N_ _N_ _N_} _N_ _N_ },
+ scaleFloat = { _A_ 2 _U_ 11 _N_ _S_ "U(P)U(P)" {_A_ 2 _U_ 22 _N_ _N_ _N_ _N_} _N_ _N_ } #-}
instance RealFloat Float
{-# GHC_PRAGMA _M_ PreludeCore {-dfun-} _A_ 0 _N_ _N_ _N_ _F_ _IF_ARGS_ 0 0 X 11 _!_ _TUP_10 [{{RealFrac Float}}, {{Floating Float}}, (Float -> Integer), (Float -> Int), (Float -> (Int, Int)), (Float -> (Integer, Int)), (Integer -> Int -> Float), (Float -> Int), (Float -> Float), (Int -> Float -> Float)] [_DFUN_ RealFrac (Float), _DFUN_ Floating (Float), _CONSTM_ RealFloat floatRadix (Float), _CONSTM_ RealFloat floatDigits (Float), _CONSTM_ RealFloat floatRange (Float), _CONSTM_ RealFloat decodeFloat (Float), _CONSTM_ RealFloat encodeFloat (Float), _CONSTM_ RealFloat exponent (Float), _CONSTM_ RealFloat significand (Float), _CONSTM_ RealFloat scaleFloat (Float)] _N_
- floatRadix = _A_ 1 _U_ 0 _N_ _S_ "A" {_A_ 0 _N_ _N_ _N_ _F_ _IF_ARGS_ 0 0 X 1 _#_ int2Integer# [] [2#] _N_} _N_ _N_,
- floatDigits = _A_ 1 _U_ 0 _N_ _S_ "A" {_A_ 0 _N_ _N_ _N_ _F_ _IF_ARGS_ 0 0 X 2 _!_ I# [] [24#] _N_} _F_ _IF_ARGS_ 0 1 X 2 \ (u0 :: Float) -> _!_ I# [] [24#] _N_,
- floatRange = _A_ 1 _U_ 0 _N_ _S_ "A" {_A_ 0 _N_ _N_ _N_ _N_ _N_} _N_ _N_,
- decodeFloat = _A_ 1 _U_ 1 _N_ _S_ "U(P)" {_A_ 1 _U_ 2 _N_ _N_ _N_ _N_} _N_ _N_,
- encodeFloat = _A_ 2 _U_ 11 _N_ _S_ "U(PPP)U(P)" {_A_ 4 _U_ 2222 _N_ _N_ _F_ _IF_ARGS_ 0 4 XXXX 3 \ (u0 :: Int#) (u1 :: Int#) (u2 :: ByteArray#) (u3 :: Int#) -> case _#_ encodeFloat# [] [u0, u1, u2, u3] of { _PRIM_ (u4 :: Float#) -> _!_ F# [] [u4] } _N_} _F_ _IF_ARGS_ 0 2 CC 5 \ (u0 :: Integer) (u1 :: Int) -> case u0 of { _ALG_ J# (u2 :: Int#) (u3 :: Int#) (u4 :: ByteArray#) -> case u1 of { _ALG_ I# (u5 :: Int#) -> case _#_ encodeFloat# [] [u2, u3, u4, u5] of { _PRIM_ (u6 :: Float#) -> _!_ F# [] [u6] }; _NO_DEFLT_ }; _NO_DEFLT_ } _N_,
- exponent = _A_ 1 _U_ 2 _N_ _N_ _N_ _N_,
- significand = _A_ 1 _U_ 2 _N_ _N_ _N_ _N_,
- scaleFloat = _A_ 2 _U_ 22 _N_ _N_ _N_ _N_ #-}
+ floatRadix = { _A_ 1 _U_ 0 _N_ _S_ "A" {_A_ 0 _N_ _N_ _N_ _N_ _N_} _N_ _N_ },
+ floatDigits = { _A_ 1 _U_ 0 _N_ _S_ "A" {_A_ 0 _N_ _N_ _N_ _F_ _IF_ARGS_ 0 0 X 2 _!_ I# [] [24#] _N_} _F_ _IF_ARGS_ 0 1 X 2 \ (u0 :: Float) -> _!_ I# [] [24#] _N_ },
+ floatRange = { _A_ 1 _U_ 0 _N_ _S_ "A" {_A_ 0 _N_ _N_ _N_ _N_ _N_} _N_ _N_ },
+ decodeFloat = { _A_ 1 _U_ 1 _N_ _S_ "U(P)" {_A_ 1 _U_ 2 _N_ _N_ _N_ _N_} _N_ _N_ },
+ encodeFloat = { _A_ 2 _U_ 11 _N_ _S_ "U(PPP)U(P)" {_A_ 4 _U_ 2222 _N_ _N_ _F_ _IF_ARGS_ 0 4 XXXX 3 \ (u0 :: Int#) (u1 :: Int#) (u2 :: ByteArray#) (u3 :: Int#) -> case _#_ encodeFloat# [] [u0, u1, u2, u3] of { _PRIM_ (u4 :: Float#) -> _!_ F# [] [u4] } _N_} _F_ _IF_ARGS_ 0 2 CC 5 \ (u0 :: Integer) (u1 :: Int) -> case u0 of { _ALG_ J# (u2 :: Int#) (u3 :: Int#) (u4 :: ByteArray#) -> case u1 of { _ALG_ I# (u5 :: Int#) -> case _#_ encodeFloat# [] [u2, u3, u4, u5] of { _PRIM_ (u6 :: Float#) -> _!_ F# [] [u6] }; _NO_DEFLT_ }; _NO_DEFLT_ } _N_ },
+ exponent = { _A_ 1 _U_ 1 _N_ _S_ "U(P)" {_A_ 1 _U_ 2 _N_ _N_ _N_ _N_} _N_ _N_ },
+ significand = { _A_ 1 _U_ 1 _N_ _S_ "U(P)" {_A_ 1 _U_ 2 _N_ _N_ _N_ _N_} _N_ _N_ },
+ scaleFloat = { _A_ 2 _U_ 11 _N_ _S_ "U(P)U(P)" {_A_ 2 _U_ 22 _N_ _N_ _N_ _N_} _N_ _N_ } #-}
instance RealFrac Double
{-# GHC_PRAGMA _M_ PreludeCore {-dfun-} _A_ 0 _N_ _N_ _N_ _F_ _IF_ARGS_ 0 0 X 8 _!_ _TUP_7 [{{Real Double}}, {{Fractional Double}}, _forall_ a$z1 =>{{Integral a$z1}} -> (Double -> (a$z1, Double)), _forall_ a$z1 =>{{Integral a$z1}} -> (Double -> a$z1), _forall_ a$z1 =>{{Integral a$z1}} -> (Double -> a$z1), _forall_ a$z1 =>{{Integral a$z1}} -> (Double -> a$z1), _forall_ a$z1 =>{{Integral a$z1}} -> (Double -> a$z1)] [_DFUN_ Real (Double), _DFUN_ Fractional (Double), _CONSTM_ RealFrac properFraction (Double), _CONSTM_ RealFrac truncate (Double), _CONSTM_ RealFrac round (Double), _CONSTM_ RealFrac ceiling (Double), _CONSTM_ RealFrac floor (Double)] _N_
- properFraction = _A_ 1 _U_ 22 _N_ _N_ _N_ _N_,
- truncate = _A_ 1 _U_ 22 _N_ _N_ _N_ _N_,
- round = _A_ 1 _U_ 22 _N_ _N_ _N_ _N_,
- ceiling = _A_ 1 _U_ 22 _N_ _N_ _N_ _N_,
- floor = _A_ 1 _U_ 22 _N_ _N_ _N_ _N_ #-}
+ properFraction = { _A_ 1 _U_ 11 _N_ _N_ _N_ _SPECIALISE_ [ Int ] 1 { _A_ 1 _U_ 1 _N_ _S_ "U(P)" {_A_ 1 _U_ 2 _N_ _N_ _N_ _N_} _N_ _N_ }, [ Integer ] 1 { _A_ 1 _U_ 1 _N_ _S_ "U(P)" {_A_ 1 _U_ 2 _N_ _N_ _N_ _N_} _N_ _N_ } },
+ truncate = { _A_ 1 _U_ 11 _N_ _N_ _N_ _SPECIALISE_ [ Int ] 1 { _A_ 1 _U_ 1 _N_ _S_ "U(P)" {_A_ 1 _U_ 2 _N_ _N_ _F_ _IF_ARGS_ 0 1 X 4 \ (u0 :: Double#) -> case _APP_ _WRKR_ _SPEC_ _CONSTM_ RealFrac properFraction (Double) [ (Int) ] [ u0 ] of { _ALG_ _TUP_2 (u1 :: Int) (u2 :: Double) -> u1; _NO_DEFLT_ } _N_} _F_ _IF_ARGS_ 0 1 X 4 \ (u0 :: Double) -> case _APP_ _SPEC_ _CONSTM_ RealFrac properFraction (Double) [ (Int) ] [ u0 ] of { _ALG_ _TUP_2 (u1 :: Int) (u2 :: Double) -> u1; _NO_DEFLT_ } _N_ }, [ Integer ] 1 { _A_ 1 _U_ 1 _N_ _S_ "U(P)" {_A_ 1 _U_ 2 _N_ _N_ _F_ _IF_ARGS_ 0 1 X 4 \ (u0 :: Double#) -> case _APP_ _WRKR_ _SPEC_ _CONSTM_ RealFrac properFraction (Double) [ (Integer) ] [ u0 ] of { _ALG_ _TUP_2 (u1 :: Integer) (u2 :: Double) -> u1; _NO_DEFLT_ } _N_} _F_ _IF_ARGS_ 0 1 X 4 \ (u0 :: Double) -> case _APP_ _SPEC_ _CONSTM_ RealFrac properFraction (Double) [ (Integer) ] [ u0 ] of { _ALG_ _TUP_2 (u1 :: Integer) (u2 :: Double) -> u1; _NO_DEFLT_ } _N_ } },
+ round = { _A_ 1 _U_ 21 _N_ _N_ _N_ _SPECIALISE_ [ Int ] 1 { _A_ 1 _U_ 1 _N_ _S_ "U(P)" {_A_ 1 _U_ 2 _N_ _N_ _N_ _N_} _N_ _N_ }, [ Integer ] 1 { _A_ 1 _U_ 1 _N_ _S_ "U(P)" {_A_ 1 _U_ 2 _N_ _N_ _N_ _N_} _N_ _N_ } },
+ ceiling = { _A_ 1 _U_ 21 _N_ _N_ _N_ _SPECIALISE_ [ Int ] 1 { _A_ 1 _U_ 1 _N_ _S_ "U(P)" {_A_ 1 _U_ 2 _N_ _N_ _N_ _N_} _N_ _N_ }, [ Integer ] 1 { _A_ 1 _U_ 1 _N_ _S_ "U(P)" {_A_ 1 _U_ 2 _N_ _N_ _N_ _N_} _N_ _N_ } },
+ floor = { _A_ 1 _U_ 21 _N_ _N_ _N_ _SPECIALISE_ [ Int ] 1 { _A_ 1 _U_ 1 _N_ _S_ "U(P)" {_A_ 1 _U_ 2 _N_ _N_ _N_ _N_} _N_ _N_ }, [ Integer ] 1 { _A_ 1 _U_ 1 _N_ _S_ "U(P)" {_A_ 1 _U_ 2 _N_ _N_ _N_ _N_} _N_ _N_ } } #-}
instance RealFrac Float
{-# GHC_PRAGMA _M_ PreludeCore {-dfun-} _A_ 0 _N_ _N_ _N_ _F_ _IF_ARGS_ 0 0 X 8 _!_ _TUP_7 [{{Real Float}}, {{Fractional Float}}, _forall_ a$z1 =>{{Integral a$z1}} -> (Float -> (a$z1, Float)), _forall_ a$z1 =>{{Integral a$z1}} -> (Float -> a$z1), _forall_ a$z1 =>{{Integral a$z1}} -> (Float -> a$z1), _forall_ a$z1 =>{{Integral a$z1}} -> (Float -> a$z1), _forall_ a$z1 =>{{Integral a$z1}} -> (Float -> a$z1)] [_DFUN_ Real (Float), _DFUN_ Fractional (Float), _CONSTM_ RealFrac properFraction (Float), _CONSTM_ RealFrac truncate (Float), _CONSTM_ RealFrac round (Float), _CONSTM_ RealFrac ceiling (Float), _CONSTM_ RealFrac floor (Float)] _N_
- properFraction = _A_ 1 _U_ 22 _N_ _N_ _N_ _N_,
- truncate = _A_ 1 _U_ 22 _N_ _N_ _N_ _N_,
- round = _A_ 1 _U_ 22 _N_ _N_ _N_ _N_,
- ceiling = _A_ 1 _U_ 22 _N_ _N_ _N_ _N_,
- floor = _A_ 1 _U_ 22 _N_ _N_ _N_ _N_ #-}
-instance Integral a => RealFrac (Ratio a)
- {-# GHC_PRAGMA _M_ PreludeRatio {-dfun-} _A_ 3 _U_ 222 _N_ _N_ _N_ _N_ #-}
+ properFraction = { _A_ 1 _U_ 11 _N_ _N_ _N_ _SPECIALISE_ [ Int ] 1 { _A_ 1 _U_ 1 _N_ _S_ "U(P)" {_A_ 1 _U_ 2 _N_ _N_ _N_ _N_} _N_ _N_ }, [ Integer ] 1 { _A_ 1 _U_ 1 _N_ _S_ "U(P)" {_A_ 1 _U_ 2 _N_ _N_ _N_ _N_} _N_ _N_ } },
+ truncate = { _A_ 1 _U_ 11 _N_ _N_ _N_ _SPECIALISE_ [ Int ] 1 { _A_ 1 _U_ 1 _N_ _S_ "U(P)" {_A_ 1 _U_ 2 _N_ _N_ _F_ _IF_ARGS_ 0 1 X 4 \ (u0 :: Float#) -> case _APP_ _WRKR_ _SPEC_ _CONSTM_ RealFrac properFraction (Float) [ (Int) ] [ u0 ] of { _ALG_ _TUP_2 (u1 :: Int) (u2 :: Float) -> u1; _NO_DEFLT_ } _N_} _F_ _IF_ARGS_ 0 1 X 4 \ (u0 :: Float) -> case _APP_ _SPEC_ _CONSTM_ RealFrac properFraction (Float) [ (Int) ] [ u0 ] of { _ALG_ _TUP_2 (u1 :: Int) (u2 :: Float) -> u1; _NO_DEFLT_ } _N_ }, [ Integer ] 1 { _A_ 1 _U_ 1 _N_ _S_ "U(P)" {_A_ 1 _U_ 2 _N_ _N_ _F_ _IF_ARGS_ 0 1 X 4 \ (u0 :: Float#) -> case _APP_ _WRKR_ _SPEC_ _CONSTM_ RealFrac properFraction (Float) [ (Integer) ] [ u0 ] of { _ALG_ _TUP_2 (u1 :: Integer) (u2 :: Float) -> u1; _NO_DEFLT_ } _N_} _F_ _IF_ARGS_ 0 1 X 4 \ (u0 :: Float) -> case _APP_ _SPEC_ _CONSTM_ RealFrac properFraction (Float) [ (Integer) ] [ u0 ] of { _ALG_ _TUP_2 (u1 :: Integer) (u2 :: Float) -> u1; _NO_DEFLT_ } _N_ } },
+ round = { _A_ 1 _U_ 21 _N_ _N_ _N_ _SPECIALISE_ [ Int ] 1 { _A_ 1 _U_ 1 _N_ _S_ "U(P)" {_A_ 1 _U_ 2 _N_ _N_ _N_ _N_} _N_ _N_ }, [ Integer ] 1 { _A_ 1 _U_ 1 _N_ _S_ "U(P)" {_A_ 1 _U_ 2 _N_ _N_ _N_ _N_} _N_ _N_ } },
+ ceiling = { _A_ 1 _U_ 21 _N_ _N_ _N_ _SPECIALISE_ [ Int ] 1 { _A_ 1 _U_ 1 _N_ _S_ "U(P)" {_A_ 1 _U_ 2 _N_ _N_ _N_ _N_} _N_ _N_ }, [ Integer ] 1 { _A_ 1 _U_ 1 _N_ _S_ "U(P)" {_A_ 1 _U_ 2 _N_ _N_ _N_ _N_} _N_ _N_ } },
+ floor = { _A_ 1 _U_ 21 _N_ _N_ _N_ _SPECIALISE_ [ Int ] 1 { _A_ 1 _U_ 1 _N_ _S_ "U(P)" {_A_ 1 _U_ 2 _N_ _N_ _N_ _N_} _N_ _N_ }, [ Integer ] 1 { _A_ 1 _U_ 1 _N_ _S_ "U(P)" {_A_ 1 _U_ 2 _N_ _N_ _N_ _N_} _N_ _N_ } } #-}
instance RealFrac (Ratio Integer)
{-# GHC_PRAGMA _M_ PreludeRatio {-dfun-} _A_ 0 _N_ _N_ _N_ _F_ _IF_ARGS_ 0 0 X 8 _!_ _TUP_7 [{{Real (Ratio Integer)}}, {{Fractional (Ratio Integer)}}, _forall_ a$z1 =>{{Integral a$z1}} -> (Ratio Integer -> (a$z1, Ratio Integer)), _forall_ a$z1 =>{{Integral a$z1}} -> (Ratio Integer -> a$z1), _forall_ a$z1 =>{{Integral a$z1}} -> (Ratio Integer -> a$z1), _forall_ a$z1 =>{{Integral a$z1}} -> (Ratio Integer -> a$z1), _forall_ a$z1 =>{{Integral a$z1}} -> (Ratio Integer -> a$z1)] [_DFUN_ Real (Ratio Integer), _DFUN_ Fractional (Ratio Integer), _CONSTM_ RealFrac properFraction (Ratio Integer), _CONSTM_ RealFrac truncate (Ratio Integer), _CONSTM_ RealFrac round (Ratio Integer), _CONSTM_ RealFrac ceiling (Ratio Integer), _CONSTM_ RealFrac floor (Ratio Integer)] _N_
- properFraction = _A_ 2 _U_ 11 _N_ _S_ "LU(LL)" {_A_ 3 _U_ 112 _N_ _N_ _N_ _N_} _N_ _N_,
- truncate = _A_ 1 _U_ 22 _N_ _N_ _F_ _IF_ARGS_ 1 1 X 3 _/\_ u0 -> \ (u1 :: {{Integral u0}}) -> _APP_ _TYAPP_ _TYAPP_ _WRKR_ _ORIG_ PreludeCore _truncate { (Ratio Integer) } { u0 } [ _CONSTM_ RealFrac properFraction (Ratio Integer), u1 ] _N_,
- round = _A_ 1 _U_ 22 _N_ _N_ _N_ _N_,
- ceiling = _A_ 1 _U_ 22 _N_ _N_ _N_ _N_,
- floor = _A_ 1 _U_ 22 _N_ _N_ _N_ _N_ #-}
+ properFraction = { _A_ 2 _U_ 11 _N_ _S_ "LU(U(PPP)U(PPP))" {_A_ 5 _U_ 12222 _N_ _N_ _N_ _N_} _N_ _SPECIALISE_ [ Int ] 1 { _A_ 1 _U_ 1 _N_ _S_ "U(U(PPP)U(PPP))" {_A_ 4 _U_ 2222 _N_ _N_ _N_ _N_} _N_ _N_ }, [ Integer ] 1 { _A_ 1 _U_ 1 _N_ _S_ "U(U(PPP)U(PPP))" {_A_ 4 _U_ 2222 _N_ _N_ _N_ _N_} _N_ _N_ } },
+ truncate = { _A_ 2 _U_ 11 _N_ _N_ _N_ _SPECIALISE_ [ Int ] 1 { _A_ 1 _U_ 1 _N_ _S_ "U(U(PPP)U(PPP))" {_A_ 4 _U_ 2222 _N_ _N_ _F_ _IF_ARGS_ 0 4 XXXX 7 \ (u0 :: Int#) (u1 :: Int#) (u2 :: ByteArray#) (u3 :: Integer) -> case _APP_ _WRKR_ _SPEC_ _CONSTM_ RealFrac properFraction (Ratio Integer) [ (Int) ] [ u0, u1, u2, u3 ] of { _ALG_ _TUP_2 (u4 :: Int) (u5 :: Ratio Integer) -> u4; _NO_DEFLT_ } _N_} _F_ _IF_ARGS_ 0 1 X 4 \ (u0 :: Ratio Integer) -> case _APP_ _SPEC_ _CONSTM_ RealFrac properFraction (Ratio Integer) [ (Int) ] [ u0 ] of { _ALG_ _TUP_2 (u1 :: Int) (u2 :: Ratio Integer) -> u1; _NO_DEFLT_ } _N_ }, [ Integer ] 1 { _A_ 1 _U_ 1 _N_ _S_ "U(U(PPP)U(PPP))" {_A_ 4 _U_ 2222 _N_ _N_ _F_ _IF_ARGS_ 0 4 XXXX 7 \ (u0 :: Int#) (u1 :: Int#) (u2 :: ByteArray#) (u3 :: Integer) -> case _APP_ _WRKR_ _SPEC_ _CONSTM_ RealFrac properFraction (Ratio Integer) [ (Integer) ] [ u0, u1, u2, u3 ] of { _ALG_ _TUP_2 (u4 :: Integer) (u5 :: Ratio Integer) -> u4; _NO_DEFLT_ } _N_} _F_ _IF_ARGS_ 0 1 X 4 \ (u0 :: Ratio Integer) -> case _APP_ _SPEC_ _CONSTM_ RealFrac properFraction (Ratio Integer) [ (Integer) ] [ u0 ] of { _ALG_ _TUP_2 (u1 :: Integer) (u2 :: Ratio Integer) -> u1; _NO_DEFLT_ } _N_ } },
+ round = { _A_ 1 _U_ 21 _N_ _N_ _N_ _SPECIALISE_ [ Int ] 1 { _A_ 1 _U_ 1 _N_ _S_ "U(U(PPP)U(PPP))" {_A_ 4 _U_ 2222 _N_ _N_ _N_ _N_} _N_ _N_ }, [ Integer ] 1 { _A_ 1 _U_ 1 _N_ _S_ "U(U(PPP)U(PPP))" {_A_ 4 _U_ 2222 _N_ _N_ _N_ _N_} _N_ _N_ } },
+ ceiling = { _A_ 1 _U_ 21 _N_ _N_ _N_ _SPECIALISE_ [ Int ] 1 { _A_ 1 _U_ 1 _N_ _S_ "U(U(PPP)U(PPP))" {_A_ 4 _U_ 2222 _N_ _N_ _N_ _N_} _N_ _N_ }, [ Integer ] 1 { _A_ 1 _U_ 1 _N_ _S_ "U(U(PPP)U(PPP))" {_A_ 4 _U_ 2222 _N_ _N_ _N_ _N_} _N_ _N_ } },
+ floor = { _A_ 1 _U_ 21 _N_ _N_ _N_ _SPECIALISE_ [ Int ] 1 { _A_ 1 _U_ 1 _N_ _S_ "U(U(PPP)U(PPP))" {_A_ 4 _U_ 2222 _N_ _N_ _N_ _N_} _N_ _N_ }, [ Integer ] 1 { _A_ 1 _U_ 1 _N_ _S_ "U(U(PPP)U(PPP))" {_A_ 4 _U_ 2222 _N_ _N_ _N_ _N_} _N_ _N_ } } #-}
+instance Text ((Int, Int), (Int, Int))
+ {-# GHC_PRAGMA _M_ PreludeBuiltin {-dfun-} _A_ 0 _N_ _N_ _N_ _F_ _IF_ARGS_ 0 0 X 5 _!_ _TUP_4 [(Int -> [Char] -> [(((Int, Int), (Int, Int)), [Char])]), (Int -> ((Int, Int), (Int, Int)) -> [Char] -> [Char]), ([Char] -> [([((Int, Int), (Int, Int))], [Char])]), ([((Int, Int), (Int, Int))] -> [Char] -> [Char])] [_CONSTM_ Text readsPrec (((Int, Int), (Int, Int))), _CONSTM_ Text showsPrec (((Int, Int), (Int, Int))), _CONSTM_ Text readList (((Int, Int), (Int, Int))), _CONSTM_ Text showList (((Int, Int), (Int, Int)))] _N_
+ readsPrec = { _A_ 1 _U_ 02 _N_ _S_ "A" {_A_ 0 _U_ 2 _N_ _N_ _N_ _N_} _N_ _N_ },
+ showsPrec = { _A_ 3 _U_ 012 _N_ _S_ "AU(LL)L" {_A_ 3 _U_ 112 _N_ _N_ _N_ _N_} _N_ _N_ },
+ readList = { _A_ 0 _U_ 2 _N_ _N_ _N_ _N_ },
+ showList = { _A_ 1 _U_ 12 _N_ _N_ _N_ _N_ } #-}
instance Text ()
{-# GHC_PRAGMA _M_ PreludeBuiltin {-dfun-} _A_ 0 _N_ _N_ _N_ _F_ _IF_ARGS_ 0 0 X 5 _!_ _TUP_4 [(Int -> [Char] -> [((), [Char])]), (Int -> () -> [Char] -> [Char]), ([Char] -> [([()], [Char])]), ([()] -> [Char] -> [Char])] [_CONSTM_ Text readsPrec (()), _CONSTM_ Text showsPrec (()), _CONSTM_ Text readList (()), _CONSTM_ Text showList (())] _N_
- readsPrec = _A_ 1 _U_ 02 _N_ _S_ "A" {_A_ 0 _U_ 2 _N_ _N_ _N_ _N_} _N_ _N_,
- showsPrec = _A_ 3 _U_ 012 _N_ _S_ "AEL" {_A_ 2 _U_ 12 _N_ _N_ _F_ _IF_ARGS_ 0 2 CX 4 \ (u0 :: ()) (u1 :: [Char]) -> case u0 of { _ALG_ _TUP_0 -> _APP_ _TYAPP_ _ORIG_ PreludeList (++) { Char } [ _NOREP_S_ "()", u1 ]; _NO_DEFLT_ } _N_} _F_ _IF_ARGS_ 0 3 XCX 4 \ (u0 :: Int) (u1 :: ()) (u2 :: [Char]) -> case u1 of { _ALG_ _TUP_0 -> _APP_ _TYAPP_ _ORIG_ PreludeList (++) { Char } [ _NOREP_S_ "()", u2 ]; _NO_DEFLT_ } _N_,
- readList = _A_ 0 _U_ 2 _N_ _N_ _N_ _N_,
- showList = _A_ 0 _U_ 12 _N_ _N_ _N_ _N_ #-}
+ readsPrec = { _A_ 1 _U_ 02 _N_ _S_ "A" {_A_ 0 _U_ 2 _N_ _N_ _N_ _N_} _N_ _N_ },
+ showsPrec = { _A_ 3 _U_ 012 _N_ _S_ "AEL" {_A_ 2 _U_ 12 _N_ _N_ _F_ _IF_ARGS_ 0 2 CX 4 \ (u0 :: ()) (u1 :: [Char]) -> case u0 of { _ALG_ _TUP_0 -> _APP_ _TYAPP_ _ORIG_ PreludeList (++) { Char } [ _NOREP_S_ "()", u1 ]; _NO_DEFLT_ } _N_} _F_ _IF_ARGS_ 0 3 XCX 4 \ (u0 :: Int) (u1 :: ()) (u2 :: [Char]) -> case u1 of { _ALG_ _TUP_0 -> _APP_ _TYAPP_ _ORIG_ PreludeList (++) { Char } [ _NOREP_S_ "()", u2 ]; _NO_DEFLT_ } _N_ },
+ readList = { _A_ 0 _U_ 2 _N_ _N_ _N_ _N_ },
+ showList = { _A_ 1 _U_ 12 _N_ _N_ _N_ _N_ } #-}
instance (Text a, Text b) => Text (a, b)
{-# GHC_PRAGMA _M_ PreludeBuiltin {-dfun-} _A_ 2 _U_ 22 _N_ _N_ _N_ _N_ #-}
instance (Text a, Text b, Text c) => Text (a, b, c)
{-# GHC_PRAGMA _M_ PreludeBuiltin {-dfun-} _A_ 5 _U_ 22222 _N_ _N_ _N_ _N_ #-}
instance Text (Int, Int)
{-# GHC_PRAGMA _M_ PreludeBuiltin {-dfun-} _A_ 0 _N_ _N_ _N_ _F_ _IF_ARGS_ 0 0 X 5 _!_ _TUP_4 [(Int -> [Char] -> [((Int, Int), [Char])]), (Int -> (Int, Int) -> [Char] -> [Char]), ([Char] -> [([(Int, Int)], [Char])]), ([(Int, Int)] -> [Char] -> [Char])] [_CONSTM_ Text readsPrec ((Int, Int)), _CONSTM_ Text showsPrec ((Int, Int)), _CONSTM_ Text readList ((Int, Int)), _CONSTM_ Text showList ((Int, Int))] _N_
- readsPrec = _A_ 1 _U_ 02 _N_ _S_ "A" {_A_ 0 _U_ 2 _N_ _N_ _N_ _N_} _N_ _N_,
- showsPrec = _A_ 3 _U_ 012 _N_ _S_ "AU(LL)L" {_A_ 3 _U_ 112 _N_ _N_ _N_ _N_} _N_ _N_,
- readList = _A_ 0 _U_ 2 _N_ _N_ _N_ _N_,
- showList = _A_ 0 _U_ 12 _N_ _N_ _N_ _N_ #-}
+ readsPrec = { _A_ 1 _U_ 02 _N_ _S_ "A" {_A_ 0 _U_ 2 _N_ _N_ _N_ _N_} _N_ _N_ },
+ showsPrec = { _A_ 3 _U_ 012 _N_ _S_ "AU(LL)L" {_A_ 3 _U_ 112 _N_ _N_ _N_ _N_} _N_ _N_ },
+ readList = { _A_ 0 _U_ 2 _N_ _N_ _N_ _N_ },
+ showList = { _A_ 1 _U_ 12 _N_ _N_ _N_ _N_ } #-}
+instance Text (Int, Int, Int)
+ {-# GHC_PRAGMA _M_ PreludeBuiltin {-dfun-} _A_ 0 _N_ _N_ _N_ _F_ _IF_ARGS_ 0 0 X 5 _!_ _TUP_4 [(Int -> [Char] -> [((Int, Int, Int), [Char])]), (Int -> (Int, Int, Int) -> [Char] -> [Char]), ([Char] -> [([(Int, Int, Int)], [Char])]), ([(Int, Int, Int)] -> [Char] -> [Char])] [_CONSTM_ Text readsPrec ((Int, Int, Int)), _CONSTM_ Text showsPrec ((Int, Int, Int)), _CONSTM_ Text readList ((Int, Int, Int)), _CONSTM_ Text showList ((Int, Int, Int))] _N_
+ readsPrec = { _A_ 1 _U_ 02 _N_ _S_ "A" {_A_ 0 _U_ 2 _N_ _N_ _N_ _N_} _N_ _N_ },
+ showsPrec = { _A_ 3 _U_ 012 _N_ _S_ "AU(LLL)L" {_A_ 4 _U_ 1112 _N_ _N_ _N_ _N_} _N_ _N_ },
+ readList = { _A_ 0 _U_ 2 _N_ _N_ _N_ _N_ },
+ showList = { _A_ 1 _U_ 12 _N_ _N_ _N_ _N_ } #-}
instance Text (Integer, Integer)
{-# GHC_PRAGMA _M_ PreludeBuiltin {-dfun-} _A_ 0 _N_ _N_ _N_ _F_ _IF_ARGS_ 0 0 X 5 _!_ _TUP_4 [(Int -> [Char] -> [((Integer, Integer), [Char])]), (Int -> (Integer, Integer) -> [Char] -> [Char]), ([Char] -> [([(Integer, Integer)], [Char])]), ([(Integer, Integer)] -> [Char] -> [Char])] [_CONSTM_ Text readsPrec ((Integer, Integer)), _CONSTM_ Text showsPrec ((Integer, Integer)), _CONSTM_ Text readList ((Integer, Integer)), _CONSTM_ Text showList ((Integer, Integer))] _N_
- readsPrec = _A_ 1 _U_ 02 _N_ _S_ "A" {_A_ 0 _U_ 2 _N_ _N_ _N_ _N_} _N_ _N_,
- showsPrec = _A_ 3 _U_ 012 _N_ _S_ "AU(LL)L" {_A_ 3 _U_ 112 _N_ _N_ _N_ _N_} _N_ _N_,
- readList = _A_ 0 _U_ 2 _N_ _N_ _N_ _N_,
- showList = _A_ 0 _U_ 12 _N_ _N_ _N_ _N_ #-}
+ readsPrec = { _A_ 1 _U_ 02 _N_ _S_ "A" {_A_ 0 _U_ 2 _N_ _N_ _N_ _N_} _N_ _N_ },
+ showsPrec = { _A_ 3 _U_ 012 _N_ _S_ "AU(LL)L" {_A_ 3 _U_ 112 _N_ _N_ _N_ _N_} _N_ _N_ },
+ readList = { _A_ 0 _U_ 2 _N_ _N_ _N_ _N_ },
+ showList = { _A_ 1 _U_ 12 _N_ _N_ _N_ _N_ } #-}
instance Text (a -> b)
{-# GHC_PRAGMA _M_ PreludeCore {-dfun-} _A_ 0 _N_ _N_ _N_ _N_ _N_ #-}
+instance Text (Array (Int, Int) Double)
+ {-# GHC_PRAGMA _M_ PreludeArray {-dfun-} _A_ 0 _N_ _N_ _N_ _F_ _IF_ARGS_ 0 0 X 5 _!_ _TUP_4 [(Int -> [Char] -> [(Array (Int, Int) Double, [Char])]), (Int -> Array (Int, Int) Double -> [Char] -> [Char]), ([Char] -> [([Array (Int, Int) Double], [Char])]), ([Array (Int, Int) Double] -> [Char] -> [Char])] [_CONSTM_ Text readsPrec (Array (Int, Int) Double), _CONSTM_ Text showsPrec (Array (Int, Int) Double), _CONSTM_ Text readList (Array (Int, Int) Double), _CONSTM_ Text showList (Array (Int, Int) Double)] _N_
+ readsPrec = { _A_ 1 _U_ 12 _N_ _S_ "U(P)" {_A_ 1 _U_ 22 _N_ _N_ _N_ _N_} _N_ _N_ },
+ showsPrec = { _A_ 2 _U_ 122 _N_ _N_ _N_ _N_ },
+ readList = { _A_ 0 _U_ 2 _N_ _N_ _N_ _N_ },
+ showList = { _A_ 0 _U_ 12 _N_ _N_ _N_ _N_ } #-}
instance (Ix a, Text a, Text b) => Text (Array a b)
{-# GHC_PRAGMA _M_ PreludeArray {-dfun-} _A_ 3 _U_ 222 _N_ _N_ _N_ _N_ #-}
+instance Text (Array Int Double)
+ {-# GHC_PRAGMA _M_ PreludeArray {-dfun-} _A_ 0 _N_ _N_ _N_ _F_ _IF_ARGS_ 0 0 X 5 _!_ _TUP_4 [(Int -> [Char] -> [(Array Int Double, [Char])]), (Int -> Array Int Double -> [Char] -> [Char]), ([Char] -> [([Array Int Double], [Char])]), ([Array Int Double] -> [Char] -> [Char])] [_CONSTM_ Text readsPrec (Array Int Double), _CONSTM_ Text showsPrec (Array Int Double), _CONSTM_ Text readList (Array Int Double), _CONSTM_ Text showList (Array Int Double)] _N_
+ readsPrec = { _A_ 1 _U_ 12 _N_ _S_ "U(P)" {_A_ 1 _U_ 22 _N_ _N_ _N_ _N_} _N_ _N_ },
+ showsPrec = { _A_ 2 _U_ 122 _N_ _N_ _N_ _N_ },
+ readList = { _A_ 0 _U_ 2 _N_ _N_ _N_ _N_ },
+ showList = { _A_ 0 _U_ 12 _N_ _N_ _N_ _N_ } #-}
instance (Text a, Text b) => Text (Assoc a b)
{-# GHC_PRAGMA _M_ PreludeArray {-dfun-} _A_ 2 _U_ 22 _N_ _N_ _N_ _N_ #-}
instance Text Bool
{-# GHC_PRAGMA _M_ PreludeCore {-dfun-} _A_ 0 _N_ _N_ _N_ _F_ _IF_ARGS_ 0 0 X 5 _!_ _TUP_4 [(Int -> [Char] -> [(Bool, [Char])]), (Int -> Bool -> [Char] -> [Char]), ([Char] -> [([Bool], [Char])]), ([Bool] -> [Char] -> [Char])] [_CONSTM_ Text readsPrec (Bool), _CONSTM_ Text showsPrec (Bool), _CONSTM_ Text readList (Bool), _CONSTM_ Text showList (Bool)] _N_
- readsPrec = _A_ 2 _U_ 02 _N_ _S_ "AL" {_A_ 1 _U_ 2 _N_ _N_ _N_ _N_} _N_ _N_,
- showsPrec = _A_ 3 _U_ 012 _N_ _S_ "AEL" {_A_ 2 _U_ 12 _N_ _N_ _N_ _N_} _N_ _N_,
- readList = _A_ 0 _U_ 2 _N_ _N_ _N_ _N_,
- showList = _A_ 0 _U_ 12 _N_ _N_ _N_ _N_ #-}
+ readsPrec = { _A_ 2 _U_ 02 _N_ _S_ "AL" {_A_ 1 _U_ 2 _N_ _N_ _N_ _N_} _N_ _N_ },
+ showsPrec = { _A_ 3 _U_ 012 _N_ _S_ "AEL" {_A_ 2 _U_ 12 _N_ _N_ _N_ _N_} _N_ _N_ },
+ readList = { _A_ 0 _U_ 2 _N_ _N_ _N_ _N_ },
+ showList = { _A_ 1 _U_ 12 _N_ _N_ _F_ _IF_ARGS_ 0 1 X 3 \ (u0 :: [Bool]) -> _APP_ _TYAPP_ _ORIG_ PreludeCore _showList { Bool } [ _WRKR_ _CONSTM_ Text showsPrec (Bool), u0 ] _N_ } #-}
instance Text Char
{-# GHC_PRAGMA _M_ PreludeCore {-dfun-} _A_ 0 _N_ _N_ _N_ _F_ _IF_ARGS_ 0 0 X 5 _!_ _TUP_4 [(Int -> [Char] -> [(Char, [Char])]), (Int -> Char -> [Char] -> [Char]), ([Char] -> [([Char], [Char])]), ([Char] -> [Char] -> [Char])] [_CONSTM_ Text readsPrec (Char), _CONSTM_ Text showsPrec (Char), _CONSTM_ Text readList (Char), _CONSTM_ Text showList (Char)] _N_
- readsPrec = _A_ 1 _U_ 02 _N_ _S_ "A" {_A_ 0 _U_ 2 _N_ _N_ _N_ _N_} _N_ _N_,
- showsPrec = _A_ 3 _U_ 012 _N_ _S_ "AU(P)L" {_A_ 2 _U_ 22 _N_ _N_ _N_ _N_} _N_ _N_,
- readList = _A_ 0 _U_ 2 _N_ _N_ _N_ _N_,
- showList = _A_ 1 _U_ 22 _N_ _N_ _N_ _N_ #-}
+ readsPrec = { _A_ 1 _U_ 02 _N_ _S_ "A" {_A_ 0 _U_ 2 _N_ _N_ _N_ _N_} _N_ _N_ },
+ showsPrec = { _A_ 3 _U_ 012 _N_ _S_ "AU(P)L" {_A_ 2 _U_ 22 _N_ _N_ _N_ _N_} _N_ _N_ },
+ readList = { _A_ 0 _U_ 2 _N_ _N_ _N_ _N_ },
+ showList = { _A_ 1 _U_ 22 _N_ _N_ _N_ _N_ } #-}
instance Text a => Text (Complex a)
{-# GHC_PRAGMA _M_ PreludeComplex {-dfun-} _A_ 1 _U_ 2 _N_ _N_ _N_ _N_ #-}
+instance Text (Complex Double)
+ {-# GHC_PRAGMA _M_ PreludeComplex {-dfun-} _A_ 0 _N_ _N_ _N_ _F_ _IF_ARGS_ 0 0 X 5 _!_ _TUP_4 [(Int -> [Char] -> [(Complex Double, [Char])]), (Int -> Complex Double -> [Char] -> [Char]), ([Char] -> [([Complex Double], [Char])]), ([Complex Double] -> [Char] -> [Char])] [_CONSTM_ Text readsPrec (Complex Double), _CONSTM_ Text showsPrec (Complex Double), _CONSTM_ Text readList (Complex Double), _CONSTM_ Text showList (Complex Double)] _N_
+ readsPrec = { _A_ 1 _U_ 12 _N_ _S_ "U(P)" {_A_ 1 _U_ 22 _N_ _N_ _N_ _N_} _N_ _N_ },
+ showsPrec = { _A_ 2 _U_ 112 _N_ _S_ "LU(LL)" {_A_ 3 _U_ 1222 _N_ _N_ _N_ _N_} _N_ _N_ },
+ readList = { _A_ 0 _U_ 2 _N_ _N_ _N_ _N_ },
+ showList = { _A_ 1 _U_ 12 _N_ _N_ _N_ _N_ } #-}
instance Text Double
{-# GHC_PRAGMA _M_ PreludeCore {-dfun-} _A_ 0 _N_ _N_ _N_ _F_ _IF_ARGS_ 0 0 X 5 _!_ _TUP_4 [(Int -> [Char] -> [(Double, [Char])]), (Int -> Double -> [Char] -> [Char]), ([Char] -> [([Double], [Char])]), ([Double] -> [Char] -> [Char])] [_CONSTM_ Text readsPrec (Double), _CONSTM_ Text showsPrec (Double), _CONSTM_ Text readList (Double), _CONSTM_ Text showList (Double)] _N_
- readsPrec = _A_ 2 _U_ 02 _N_ _S_ "AL" {_A_ 1 _U_ 2 _N_ _N_ _F_ _IF_ARGS_ 0 1 X 3 \ (u0 :: [Char]) -> _APP_ _SPEC_ _ORIG_ PreludeText readSigned [ (Double) ] [ _SPEC_ _ORIG_ PreludeText readFloat [ (Double) ], u0 ] _N_} _F_ _IF_ARGS_ 0 2 XX 3 \ (u0 :: Int) (u1 :: [Char]) -> _APP_ _SPEC_ _ORIG_ PreludeText readSigned [ (Double) ] [ _SPEC_ _ORIG_ PreludeText readFloat [ (Double) ], u1 ] _N_,
- showsPrec = _A_ 2 _U_ 212 _N_ _S_ "LU(P)" {_A_ 2 _U_ 222 _N_ _N_ _F_ _IF_ARGS_ 0 2 XX 4 \ (u0 :: Int) (u1 :: Double#) -> _APP_ _WRKR_ _SPEC_ _ORIG_ PreludeText showSigned [ (Double) ] [ _SPEC_ _ORIG_ PreludeText showFloat [ (Double) ], u0, u1 ] _N_} _F_ _IF_ARGS_ 0 2 XC 5 \ (u0 :: Int) (u1 :: Double) -> case u1 of { _ALG_ D# (u2 :: Double#) -> _APP_ _WRKR_ _SPEC_ _ORIG_ PreludeText showSigned [ (Double) ] [ _SPEC_ _ORIG_ PreludeText showFloat [ (Double) ], u0, u2 ]; _NO_DEFLT_ } _N_,
- readList = _A_ 0 _U_ 2 _N_ _N_ _N_ _N_,
- showList = _A_ 0 _U_ 12 _N_ _N_ _N_ _N_ #-}
+ readsPrec = { _A_ 2 _U_ 02 _N_ _S_ "AL" {_A_ 1 _U_ 2 _N_ _N_ _F_ _IF_ARGS_ 0 1 X 3 \ (u0 :: [Char]) -> _APP_ _SPEC_ _ORIG_ PreludeText readSigned [ (Double) ] [ _SPEC_ _ORIG_ PreludeText readFloat [ (Double) ], u0 ] _N_} _F_ _IF_ARGS_ 0 2 XX 3 \ (u0 :: Int) (u1 :: [Char]) -> _APP_ _SPEC_ _ORIG_ PreludeText readSigned [ (Double) ] [ _SPEC_ _ORIG_ PreludeText readFloat [ (Double) ], u1 ] _N_ },
+ showsPrec = { _A_ 2 _U_ 212 _N_ _S_ "LU(P)" {_A_ 2 _U_ 222 _N_ _N_ _F_ _IF_ARGS_ 0 2 XX 4 \ (u0 :: Int) (u1 :: Double#) -> _APP_ _WRKR_ _SPEC_ _ORIG_ PreludeText showSigned [ (Double) ] [ _SPEC_ _ORIG_ PreludeText showFloat [ (Double) ], u0, u1 ] _N_} _F_ _IF_ARGS_ 0 2 XC 5 \ (u0 :: Int) (u1 :: Double) -> case u1 of { _ALG_ D# (u2 :: Double#) -> _APP_ _WRKR_ _SPEC_ _ORIG_ PreludeText showSigned [ (Double) ] [ _SPEC_ _ORIG_ PreludeText showFloat [ (Double) ], u0, u2 ]; _NO_DEFLT_ } _N_ },
+ readList = { _A_ 0 _U_ 2 _N_ _N_ _N_ _N_ },
+ showList = { _A_ 1 _U_ 12 _N_ _N_ _N_ _N_ } #-}
instance Text Float
{-# GHC_PRAGMA _M_ PreludeCore {-dfun-} _A_ 0 _N_ _N_ _N_ _F_ _IF_ARGS_ 0 0 X 5 _!_ _TUP_4 [(Int -> [Char] -> [(Float, [Char])]), (Int -> Float -> [Char] -> [Char]), ([Char] -> [([Float], [Char])]), ([Float] -> [Char] -> [Char])] [_CONSTM_ Text readsPrec (Float), _CONSTM_ Text showsPrec (Float), _CONSTM_ Text readList (Float), _CONSTM_ Text showList (Float)] _N_
- readsPrec = _A_ 2 _U_ 02 _N_ _S_ "AL" {_A_ 1 _U_ 2 _N_ _N_ _N_ _N_} _N_ _N_,
- showsPrec = _A_ 1 _U_ 222 _N_ _N_ _N_ _N_,
- readList = _A_ 0 _U_ 2 _N_ _N_ _N_ _N_,
- showList = _A_ 0 _U_ 12 _N_ _N_ _N_ _N_ #-}
+ readsPrec = { _A_ 2 _U_ 02 _N_ _S_ "AL" {_A_ 1 _U_ 2 _N_ _N_ _N_ _N_} _N_ _N_ },
+ showsPrec = { _A_ 1 _U_ 222 _N_ _N_ _N_ _N_ },
+ readList = { _A_ 0 _U_ 2 _N_ _N_ _N_ _N_ },
+ showList = { _A_ 0 _U_ 12 _N_ _N_ _N_ _N_ } #-}
instance Text Int
{-# GHC_PRAGMA _M_ PreludeCore {-dfun-} _A_ 0 _N_ _N_ _N_ _F_ _IF_ARGS_ 0 0 X 5 _!_ _TUP_4 [(Int -> [Char] -> [(Int, [Char])]), (Int -> Int -> [Char] -> [Char]), ([Char] -> [([Int], [Char])]), ([Int] -> [Char] -> [Char])] [_CONSTM_ Text readsPrec (Int), _CONSTM_ Text showsPrec (Int), _CONSTM_ Text readList (Int), _CONSTM_ Text showList (Int)] _N_
- readsPrec = _A_ 2 _U_ 02 _N_ _S_ "AL" {_A_ 1 _U_ 2 _N_ _N_ _F_ _IF_ARGS_ 0 1 X 3 \ (u0 :: [Char]) -> _APP_ _SPEC_ _ORIG_ PreludeText readSigned [ (Int) ] [ _SPEC_ _ORIG_ PreludeText readDec [ (Int) ], u0 ] _N_} _F_ _IF_ARGS_ 0 2 XX 3 \ (u0 :: Int) (u1 :: [Char]) -> _APP_ _SPEC_ _ORIG_ PreludeText readSigned [ (Int) ] [ _SPEC_ _ORIG_ PreludeText readDec [ (Int) ], u1 ] _N_,
- showsPrec = _A_ 3 _U_ 212 _N_ _S_ "LU(P)L" {_A_ 3 _U_ 222 _N_ _N_ _N_ _N_} _N_ _N_,
- readList = _A_ 0 _U_ 2 _N_ _N_ _N_ _N_,
- showList = _A_ 0 _U_ 12 _N_ _N_ _N_ _N_ #-}
+ readsPrec = { _A_ 2 _U_ 02 _N_ _S_ "AL" {_A_ 1 _U_ 2 _N_ _N_ _F_ _IF_ARGS_ 0 1 X 3 \ (u0 :: [Char]) -> _APP_ _SPEC_ _ORIG_ PreludeText readSigned [ (Int) ] [ _SPEC_ _ORIG_ PreludeText readDec [ (Int) ], u0 ] _N_} _F_ _IF_ARGS_ 0 2 XX 3 \ (u0 :: Int) (u1 :: [Char]) -> _APP_ _SPEC_ _ORIG_ PreludeText readSigned [ (Int) ] [ _SPEC_ _ORIG_ PreludeText readDec [ (Int) ], u1 ] _N_ },
+ showsPrec = { _A_ 3 _U_ 212 _N_ _S_ "LU(P)L" {_A_ 3 _U_ 222 _N_ _N_ _N_ _N_} _N_ _N_ },
+ readList = { _A_ 0 _U_ 2 _N_ _N_ _N_ _N_ },
+ showList = { _A_ 1 _U_ 12 _N_ _N_ _N_ _N_ } #-}
instance Text Integer
{-# GHC_PRAGMA _M_ PreludeCore {-dfun-} _A_ 0 _N_ _N_ _N_ _F_ _IF_ARGS_ 0 0 X 5 _!_ _TUP_4 [(Int -> [Char] -> [(Integer, [Char])]), (Int -> Integer -> [Char] -> [Char]), ([Char] -> [([Integer], [Char])]), ([Integer] -> [Char] -> [Char])] [_CONSTM_ Text readsPrec (Integer), _CONSTM_ Text showsPrec (Integer), _CONSTM_ Text readList (Integer), _CONSTM_ Text showList (Integer)] _N_
- readsPrec = _A_ 2 _U_ 02 _N_ _S_ "AL" {_A_ 1 _U_ 2 _N_ _N_ _F_ _IF_ARGS_ 0 1 X 3 \ (u0 :: [Char]) -> _APP_ _SPEC_ _ORIG_ PreludeText readSigned [ (Integer) ] [ _SPEC_ _ORIG_ PreludeText readDec [ (Integer) ], u0 ] _N_} _F_ _IF_ARGS_ 0 2 XX 3 \ (u0 :: Int) (u1 :: [Char]) -> _APP_ _SPEC_ _ORIG_ PreludeText readSigned [ (Integer) ] [ _SPEC_ _ORIG_ PreludeText readDec [ (Integer) ], u1 ] _N_,
- showsPrec = _A_ 3 _U_ 212 _N_ _S_ "LU(PPP)L" {_A_ 5 _U_ 22222 _N_ _N_ _N_ _N_} _N_ _N_,
- readList = _A_ 0 _U_ 2 _N_ _N_ _N_ _N_,
- showList = _A_ 0 _U_ 12 _N_ _N_ _N_ _N_ #-}
+ readsPrec = { _A_ 2 _U_ 02 _N_ _S_ "AL" {_A_ 1 _U_ 2 _N_ _N_ _F_ _IF_ARGS_ 0 1 X 3 \ (u0 :: [Char]) -> _APP_ _SPEC_ _ORIG_ PreludeText readSigned [ (Integer) ] [ _SPEC_ _ORIG_ PreludeText readDec [ (Integer) ], u0 ] _N_} _F_ _IF_ARGS_ 0 2 XX 3 \ (u0 :: Int) (u1 :: [Char]) -> _APP_ _SPEC_ _ORIG_ PreludeText readSigned [ (Integer) ] [ _SPEC_ _ORIG_ PreludeText readDec [ (Integer) ], u1 ] _N_ },
+ showsPrec = { _A_ 3 _U_ 212 _N_ _S_ "LU(PPP)L" {_A_ 5 _U_ 22222 _N_ _N_ _N_ _N_} _N_ _N_ },
+ readList = { _A_ 0 _U_ 2 _N_ _N_ _N_ _N_ },
+ showList = { _A_ 1 _U_ 12 _N_ _N_ _N_ _N_ } #-}
instance Integral a => Text (Ratio a)
{-# GHC_PRAGMA _M_ PreludeRatio {-dfun-} _A_ 1 _U_ 2 _N_ _N_ _N_ _N_ #-}
instance Text (Ratio Integer)
{-# GHC_PRAGMA _M_ PreludeRatio {-dfun-} _A_ 0 _N_ _N_ _N_ _F_ _IF_ARGS_ 0 0 X 5 _!_ _TUP_4 [(Int -> [Char] -> [(Ratio Integer, [Char])]), (Int -> Ratio Integer -> [Char] -> [Char]), ([Char] -> [([Ratio Integer], [Char])]), ([Ratio Integer] -> [Char] -> [Char])] [_CONSTM_ Text readsPrec (Ratio Integer), _CONSTM_ Text showsPrec (Ratio Integer), _CONSTM_ Text readList (Ratio Integer), _CONSTM_ Text showList (Ratio Integer)] _N_
- readsPrec = _A_ 1 _U_ 12 _N_ _S_ "U(P)" {_A_ 1 _U_ 22 _N_ _N_ _N_ _N_} _N_ _N_,
- showsPrec = _A_ 2 _U_ 112 _N_ _S_ "LU(LL)" {_A_ 3 _U_ 1222 _N_ _N_ _N_ _N_} _N_ _N_,
- readList = _A_ 0 _U_ 2 _N_ _N_ _N_ _N_,
- showList = _A_ 0 _U_ 12 _N_ _N_ _N_ _N_ #-}
+ readsPrec = { _A_ 1 _U_ 12 _N_ _S_ "U(P)" {_A_ 1 _U_ 22 _N_ _N_ _N_ _N_} _N_ _N_ },
+ showsPrec = { _A_ 2 _U_ 112 _N_ _S_ "LU(LL)" {_A_ 3 _U_ 1222 _N_ _N_ _N_ _N_} _N_ _N_ },
+ readList = { _A_ 0 _U_ 2 _N_ _N_ _N_ _N_ },
+ showList = { _A_ 1 _U_ 12 _N_ _N_ _N_ _N_ } #-}
instance Text a => Text [a]
{-# GHC_PRAGMA _M_ PreludeBuiltin {-dfun-} _A_ 1 _U_ 2 _N_ _N_ _N_ _N_ #-}
+instance Text [Bool]
+ {-# GHC_PRAGMA _M_ PreludeBuiltin {-dfun-} _A_ 0 _N_ _N_ _N_ _F_ _IF_ARGS_ 0 0 X 5 _!_ _TUP_4 [(Int -> [Char] -> [([Bool], [Char])]), (Int -> [Bool] -> [Char] -> [Char]), ([Char] -> [([[Bool]], [Char])]), ([[Bool]] -> [Char] -> [Char])] [_CONSTM_ Text readsPrec ([Bool]), _CONSTM_ Text showsPrec ([Bool]), _CONSTM_ Text readList ([Bool]), _CONSTM_ Text showList ([Bool])] _N_
+ readsPrec = { _A_ 1 _U_ 02 _N_ _S_ "A" {_A_ 0 _U_ 2 _N_ _N_ _F_ _IF_ARGS_ 0 0 X 1 _CONSTM_ Text readList (Bool) _N_} _F_ _IF_ARGS_ 0 1 X 1 \ (u0 :: Int) -> _CONSTM_ Text readList (Bool) _N_ },
+ showsPrec = { _A_ 2 _U_ 012 _N_ _S_ "AS" {_A_ 1 _U_ 12 _N_ _N_ _F_ _IF_ARGS_ 0 1 X 3 \ (u0 :: [Bool]) -> _APP_ _TYAPP_ _ORIG_ PreludeCore _showList { Bool } [ _WRKR_ _CONSTM_ Text showsPrec (Bool), u0 ] _N_} _F_ _IF_ARGS_ 0 2 XX 3 \ (u0 :: Int) (u1 :: [Bool]) -> _APP_ _TYAPP_ _ORIG_ PreludeCore _showList { Bool } [ _WRKR_ _CONSTM_ Text showsPrec (Bool), u1 ] _N_ },
+ readList = { _A_ 0 _U_ 2 _N_ _N_ _N_ _N_ },
+ showList = { _A_ 1 _U_ 12 _N_ _N_ _N_ _N_ } #-}
instance Text [Char]
{-# GHC_PRAGMA _M_ PreludeBuiltin {-dfun-} _A_ 0 _N_ _N_ _N_ _F_ _IF_ARGS_ 0 0 X 5 _!_ _TUP_4 [(Int -> [Char] -> [([Char], [Char])]), (Int -> [Char] -> [Char] -> [Char]), ([Char] -> [([[Char]], [Char])]), ([[Char]] -> [Char] -> [Char])] [_CONSTM_ Text readsPrec ([Char]), _CONSTM_ Text showsPrec ([Char]), _CONSTM_ Text readList ([Char]), _CONSTM_ Text showList ([Char])] _N_
- readsPrec = _A_ 1 _U_ 02 _N_ _S_ "A" {_A_ 0 _U_ 2 _N_ _N_ _F_ _IF_ARGS_ 0 0 X 1 _CONSTM_ Text readList (Char) _N_} _F_ _IF_ARGS_ 0 1 X 1 \ (u0 :: Int) -> _CONSTM_ Text readList (Char) _N_,
- showsPrec = _A_ 2 _U_ 022 _N_ _S_ "AL" {_A_ 1 _U_ 22 _N_ _N_ _F_ _IF_ARGS_ 0 0 X 1 _CONSTM_ Text showList (Char) _N_} _F_ _IF_ARGS_ 0 2 XX 2 \ (u0 :: Int) (u1 :: [Char]) -> _APP_ _CONSTM_ Text showList (Char) [ u1 ] _N_,
- readList = _A_ 0 _U_ 2 _N_ _N_ _N_ _N_,
- showList = _A_ 0 _U_ 12 _N_ _N_ _N_ _N_ #-}
+ readsPrec = { _A_ 1 _U_ 02 _N_ _S_ "A" {_A_ 0 _U_ 2 _N_ _N_ _F_ _IF_ARGS_ 0 0 X 1 _CONSTM_ Text readList (Char) _N_} _F_ _IF_ARGS_ 0 1 X 1 \ (u0 :: Int) -> _CONSTM_ Text readList (Char) _N_ },
+ showsPrec = { _A_ 2 _U_ 022 _N_ _S_ "AL" {_A_ 1 _U_ 22 _N_ _N_ _F_ _IF_ARGS_ 0 0 X 1 _CONSTM_ Text showList (Char) _N_} _F_ _IF_ARGS_ 0 2 XX 2 \ (u0 :: Int) (u1 :: [Char]) -> _APP_ _CONSTM_ Text showList (Char) [ u1 ] _N_ },
+ readList = { _A_ 0 _U_ 2 _N_ _N_ _N_ _N_ },
+ showList = { _A_ 1 _U_ 12 _N_ _N_ _F_ _IF_ARGS_ 0 1 X 3 \ (u0 :: [[Char]]) -> _APP_ _TYAPP_ _ORIG_ PreludeCore _showList { [Char] } [ _CONSTM_ Text showList (Char), u0 ] _N_ } #-}
+instance Text [Complex Double]
+ {-# GHC_PRAGMA _M_ PreludeBuiltin {-dfun-} _A_ 0 _N_ _N_ _N_ _F_ _IF_ARGS_ 0 0 X 5 _!_ _TUP_4 [(Int -> [Char] -> [([Complex Double], [Char])]), (Int -> [Complex Double] -> [Char] -> [Char]), ([Char] -> [([[Complex Double]], [Char])]), ([[Complex Double]] -> [Char] -> [Char])] [_CONSTM_ Text readsPrec ([Complex Double]), _CONSTM_ Text showsPrec ([Complex Double]), _CONSTM_ Text readList ([Complex Double]), _CONSTM_ Text showList ([Complex Double])] _N_
+ readsPrec = { _A_ 1 _U_ 02 _N_ _S_ "A" {_A_ 0 _U_ 2 _N_ _N_ _F_ _IF_ARGS_ 0 0 X 1 _CONSTM_ Text readList (Complex Double) _N_} _F_ _IF_ARGS_ 0 1 X 1 \ (u0 :: Int) -> _CONSTM_ Text readList (Complex Double) _N_ },
+ showsPrec = { _A_ 2 _U_ 022 _N_ _S_ "AL" {_A_ 1 _U_ 22 _N_ _N_ _F_ _IF_ARGS_ 0 0 X 1 _CONSTM_ Text showList (Complex Double) _N_} _F_ _IF_ARGS_ 0 2 XX 2 \ (u0 :: Int) (u1 :: [Complex Double]) -> _APP_ _CONSTM_ Text showList (Complex Double) [ u1 ] _N_ },
+ readList = { _A_ 0 _U_ 2 _N_ _N_ _N_ _N_ },
+ showList = { _A_ 1 _U_ 12 _N_ _N_ _F_ _IF_ARGS_ 0 1 X 3 \ (u0 :: [[Complex Double]]) -> _APP_ _TYAPP_ _ORIG_ PreludeCore _showList { [Complex Double] } [ _CONSTM_ Text showList (Complex Double), u0 ] _N_ } #-}
+instance Text [Double]
+ {-# GHC_PRAGMA _M_ PreludeBuiltin {-dfun-} _A_ 0 _N_ _N_ _N_ _F_ _IF_ARGS_ 0 0 X 5 _!_ _TUP_4 [(Int -> [Char] -> [([Double], [Char])]), (Int -> [Double] -> [Char] -> [Char]), ([Char] -> [([[Double]], [Char])]), ([[Double]] -> [Char] -> [Char])] [_CONSTM_ Text readsPrec ([Double]), _CONSTM_ Text showsPrec ([Double]), _CONSTM_ Text readList ([Double]), _CONSTM_ Text showList ([Double])] _N_
+ readsPrec = { _A_ 1 _U_ 02 _N_ _S_ "A" {_A_ 0 _U_ 2 _N_ _N_ _F_ _IF_ARGS_ 0 0 X 1 _CONSTM_ Text readList (Double) _N_} _F_ _IF_ARGS_ 0 1 X 1 \ (u0 :: Int) -> _CONSTM_ Text readList (Double) _N_ },
+ showsPrec = { _A_ 2 _U_ 022 _N_ _S_ "AL" {_A_ 1 _U_ 22 _N_ _N_ _F_ _IF_ARGS_ 0 0 X 1 _CONSTM_ Text showList (Double) _N_} _F_ _IF_ARGS_ 0 2 XX 2 \ (u0 :: Int) (u1 :: [Double]) -> _APP_ _CONSTM_ Text showList (Double) [ u1 ] _N_ },
+ readList = { _A_ 0 _U_ 2 _N_ _N_ _N_ _N_ },
+ showList = { _A_ 1 _U_ 12 _N_ _N_ _F_ _IF_ARGS_ 0 1 X 3 \ (u0 :: [[Double]]) -> _APP_ _TYAPP_ _ORIG_ PreludeCore _showList { [Double] } [ _CONSTM_ Text showList (Double), u0 ] _N_ } #-}
instance Text [Int]
{-# GHC_PRAGMA _M_ PreludeBuiltin {-dfun-} _A_ 0 _N_ _N_ _N_ _F_ _IF_ARGS_ 0 0 X 5 _!_ _TUP_4 [(Int -> [Char] -> [([Int], [Char])]), (Int -> [Int] -> [Char] -> [Char]), ([Char] -> [([[Int]], [Char])]), ([[Int]] -> [Char] -> [Char])] [_CONSTM_ Text readsPrec ([Int]), _CONSTM_ Text showsPrec ([Int]), _CONSTM_ Text readList ([Int]), _CONSTM_ Text showList ([Int])] _N_
- readsPrec = _A_ 1 _U_ 02 _N_ _S_ "A" {_A_ 0 _U_ 2 _N_ _N_ _F_ _IF_ARGS_ 0 0 X 1 _CONSTM_ Text readList (Int) _N_} _F_ _IF_ARGS_ 0 1 X 1 \ (u0 :: Int) -> _CONSTM_ Text readList (Int) _N_,
- showsPrec = _A_ 1 _U_ 022 _N_ _S_ "A" {_A_ 0 _U_ 22 _N_ _N_ _F_ _IF_ARGS_ 0 0 X 1 _CONSTM_ Text showList (Int) _N_} _F_ _IF_ARGS_ 0 1 X 1 \ (u0 :: Int) -> _CONSTM_ Text showList (Int) _N_,
- readList = _A_ 0 _U_ 2 _N_ _N_ _N_ _N_,
- showList = _A_ 0 _U_ 12 _N_ _N_ _N_ _N_ #-}
+ readsPrec = { _A_ 1 _U_ 02 _N_ _S_ "A" {_A_ 0 _U_ 2 _N_ _N_ _F_ _IF_ARGS_ 0 0 X 1 _CONSTM_ Text readList (Int) _N_} _F_ _IF_ARGS_ 0 1 X 1 \ (u0 :: Int) -> _CONSTM_ Text readList (Int) _N_ },
+ showsPrec = { _A_ 2 _U_ 022 _N_ _S_ "AL" {_A_ 1 _U_ 22 _N_ _N_ _F_ _IF_ARGS_ 0 0 X 1 _CONSTM_ Text showList (Int) _N_} _F_ _IF_ARGS_ 0 2 XX 2 \ (u0 :: Int) (u1 :: [Int]) -> _APP_ _CONSTM_ Text showList (Int) [ u1 ] _N_ },
+ readList = { _A_ 0 _U_ 2 _N_ _N_ _N_ _N_ },
+ showList = { _A_ 1 _U_ 12 _N_ _N_ _F_ _IF_ARGS_ 0 1 X 3 \ (u0 :: [[Int]]) -> _APP_ _TYAPP_ _ORIG_ PreludeCore _showList { [Int] } [ _CONSTM_ Text showList (Int), u0 ] _N_ } #-}
+instance Text [Integer]
+ {-# GHC_PRAGMA _M_ PreludeBuiltin {-dfun-} _A_ 0 _N_ _N_ _N_ _F_ _IF_ARGS_ 0 0 X 5 _!_ _TUP_4 [(Int -> [Char] -> [([Integer], [Char])]), (Int -> [Integer] -> [Char] -> [Char]), ([Char] -> [([[Integer]], [Char])]), ([[Integer]] -> [Char] -> [Char])] [_CONSTM_ Text readsPrec ([Integer]), _CONSTM_ Text showsPrec ([Integer]), _CONSTM_ Text readList ([Integer]), _CONSTM_ Text showList ([Integer])] _N_
+ readsPrec = { _A_ 1 _U_ 02 _N_ _S_ "A" {_A_ 0 _U_ 2 _N_ _N_ _F_ _IF_ARGS_ 0 0 X 1 _CONSTM_ Text readList (Integer) _N_} _F_ _IF_ARGS_ 0 1 X 1 \ (u0 :: Int) -> _CONSTM_ Text readList (Integer) _N_ },
+ showsPrec = { _A_ 2 _U_ 022 _N_ _S_ "AL" {_A_ 1 _U_ 22 _N_ _N_ _F_ _IF_ARGS_ 0 0 X 1 _CONSTM_ Text showList (Integer) _N_} _F_ _IF_ARGS_ 0 2 XX 2 \ (u0 :: Int) (u1 :: [Integer]) -> _APP_ _CONSTM_ Text showList (Integer) [ u1 ] _N_ },
+ readList = { _A_ 0 _U_ 2 _N_ _N_ _N_ _N_ },
+ showList = { _A_ 1 _U_ 12 _N_ _N_ _F_ _IF_ARGS_ 0 1 X 3 \ (u0 :: [[Integer]]) -> _APP_ _TYAPP_ _ORIG_ PreludeCore _showList { [Integer] } [ _CONSTM_ Text showList (Integer), u0 ] _N_ } #-}
+instance Text [[Char]]
+ {-# GHC_PRAGMA _M_ PreludeBuiltin {-dfun-} _A_ 0 _N_ _N_ _N_ _F_ _IF_ARGS_ 0 0 X 5 _!_ _TUP_4 [(Int -> [Char] -> [([[Char]], [Char])]), (Int -> [[Char]] -> [Char] -> [Char]), ([Char] -> [([[[Char]]], [Char])]), ([[[Char]]] -> [Char] -> [Char])] [_CONSTM_ Text readsPrec ([[Char]]), _CONSTM_ Text showsPrec ([[Char]]), _CONSTM_ Text readList ([[Char]]), _CONSTM_ Text showList ([[Char]])] _N_
+ readsPrec = { _A_ 1 _U_ 02 _N_ _S_ "A" {_A_ 0 _U_ 2 _N_ _N_ _F_ _IF_ARGS_ 0 0 X 1 _CONSTM_ Text readList ([Char]) _N_} _F_ _IF_ARGS_ 0 1 X 1 \ (u0 :: Int) -> _CONSTM_ Text readList ([Char]) _N_ },
+ showsPrec = { _A_ 2 _U_ 012 _N_ _S_ "AS" {_A_ 1 _U_ 12 _N_ _N_ _F_ _IF_ARGS_ 0 1 X 3 \ (u0 :: [[Char]]) -> _APP_ _TYAPP_ _ORIG_ PreludeCore _showList { [Char] } [ _CONSTM_ Text showList (Char), u0 ] _N_} _F_ _IF_ARGS_ 0 2 XX 2 \ (u0 :: Int) (u1 :: [[Char]]) -> _APP_ _CONSTM_ Text showList ([Char]) [ u1 ] _N_ },
+ readList = { _A_ 0 _U_ 2 _N_ _N_ _N_ _N_ },
+ showList = { _A_ 1 _U_ 12 _N_ _N_ _N_ _N_ } #-}
+instance Text [[Int]]
+ {-# GHC_PRAGMA _M_ PreludeBuiltin {-dfun-} _A_ 0 _N_ _N_ _N_ _F_ _IF_ARGS_ 0 0 X 5 _!_ _TUP_4 [(Int -> [Char] -> [([[Int]], [Char])]), (Int -> [[Int]] -> [Char] -> [Char]), ([Char] -> [([[[Int]]], [Char])]), ([[[Int]]] -> [Char] -> [Char])] [_CONSTM_ Text readsPrec ([[Int]]), _CONSTM_ Text showsPrec ([[Int]]), _CONSTM_ Text readList ([[Int]]), _CONSTM_ Text showList ([[Int]])] _N_
+ readsPrec = { _A_ 1 _U_ 02 _N_ _S_ "A" {_A_ 0 _U_ 2 _N_ _N_ _F_ _IF_ARGS_ 0 0 X 1 _CONSTM_ Text readList ([Int]) _N_} _F_ _IF_ARGS_ 0 1 X 1 \ (u0 :: Int) -> _CONSTM_ Text readList ([Int]) _N_ },
+ showsPrec = { _A_ 2 _U_ 012 _N_ _S_ "AS" {_A_ 1 _U_ 12 _N_ _N_ _F_ _IF_ARGS_ 0 1 X 3 \ (u0 :: [[Int]]) -> _APP_ _TYAPP_ _ORIG_ PreludeCore _showList { [Int] } [ _CONSTM_ Text showList (Int), u0 ] _N_} _F_ _IF_ARGS_ 0 2 XX 2 \ (u0 :: Int) (u1 :: [[Int]]) -> _APP_ _CONSTM_ Text showList ([Int]) [ u1 ] _N_ },
+ readList = { _A_ 0 _U_ 2 _N_ _N_ _N_ _N_ },
+ showList = { _A_ 1 _U_ 12 _N_ _N_ _N_ _N_ } #-}
instance Text _PackedString
{-# GHC_PRAGMA _M_ PreludePS {-dfun-} _A_ 0 _N_ _N_ _N_ _F_ _IF_ARGS_ 0 0 X 5 _!_ _TUP_4 [(Int -> [Char] -> [(_PackedString, [Char])]), (Int -> _PackedString -> [Char] -> [Char]), ([Char] -> [([_PackedString], [Char])]), ([_PackedString] -> [Char] -> [Char])] [_CONSTM_ Text readsPrec (_PackedString), _CONSTM_ Text showsPrec (_PackedString), _CONSTM_ Text readList (_PackedString), _CONSTM_ Text showList (_PackedString)] _N_
- readsPrec = _A_ 2 _U_ 02 _N_ _S_ _!_ _F_ _IF_ARGS_ 0 2 XX 3 \ (u0 :: Int) (u1 :: [Char]) -> _APP_ _TYAPP_ error { ([Char] -> [(_PackedString, [Char])]) } [ _NOREP_S_ "readsPrec: _PackedString: ToDo", u1 ] _N_,
- showsPrec = _A_ 3 _U_ 012 _N_ _S_ "ALL" {_A_ 2 _U_ 12 _N_ _N_ _N_ _N_} _F_ _IF_ARGS_ 0 3 XXX 6 \ (u0 :: Int) (u1 :: _PackedString) (u2 :: [Char]) -> let {(u3 :: [Char]) = _APP_ _ORIG_ PreludePS _unpackPS [ u1 ]} in _APP_ _CONSTM_ Text showList (Char) [ u3, u2 ] _N_,
- readList = _A_ 0 _U_ 2 _N_ _N_ _N_ _N_,
- showList = _A_ 0 _U_ 12 _N_ _N_ _N_ _N_ #-}
+ readsPrec = { _A_ 2 _U_ 02 _N_ _S_ _!_ _N_ _N_ },
+ showsPrec = { _A_ 3 _U_ 012 _N_ _S_ "ALL" {_A_ 2 _U_ 12 _N_ _N_ _N_ _N_} _F_ _IF_ARGS_ 0 3 XXX 6 \ (u0 :: Int) (u1 :: _PackedString) (u2 :: [Char]) -> let {(u3 :: [Char]) = _APP_ _ORIG_ PreludePS _unpackPS [ u1 ]} in _APP_ _CONSTM_ Text showList (Char) [ u3, u2 ] _N_ },
+ readList = { _A_ 0 _U_ 2 _N_ _N_ _N_ _N_ },
+ showList = { _A_ 1 _U_ 12 _N_ _N_ _F_ _IF_ARGS_ 0 1 X 3 \ (u0 :: [_PackedString]) -> _APP_ _TYAPP_ _ORIG_ PreludeCore _showList { _PackedString } [ _WRKR_ _CONSTM_ Text showsPrec (_PackedString), u0 ] _N_ } #-}
instance _CCallable Char
{-# GHC_PRAGMA _M_ PreludeCore {-dfun-} _A_ 0 _N_ _N_ _N_ _F_ _IF_ARGS_ 0 0 X 1 _!_ _TUP_0 [] [] _N_ #-}
instance _CCallable Double
#if defined(__UNBOXED_INSTANCES__)
minInt#, maxInt#,
+ toInt#, fromInt#,
minChar#, maxChar#,
toChar#, fromChar#,
isAscii#, isControl#, isPrint#, isSpace#,
readParen, showParen, readLitChar, showLitChar, readSigned,
showSigned, showSpace__, readDec, showInt, readFloat, showFloat,
_showHex, _showRadix, _showDigit, -- non-std
- _readList, _showList, _truncate, _round, _ceiling, _floor,
+ _readList, _showList,
_readRational, _showRational, -- extras!
-{-# GHC_PRAGMA INTERFACE VERSION 5 #-}
+{-# GHC_PRAGMA INTERFACE VERSION 6 #-}
interface PreludeIO where
import PreludeBuiltin(Char(..), Int(..), Integer(..), List(..), Tuple0, Tuple2, _Addr(..), _RealWorld(..), _State(..))
import PreludeCore(Bool(..), Eq(..), Ord(..), Text(..))
print13 :: Text a => a -> _State _RealWorld -> (Either IOError13 (), _State _RealWorld)
{-# GHC_PRAGMA _A_ 1 _U_ 121 _N_ _N_ _N_ _N_ #-}
putChar :: Char -> _State _RealWorld -> (Either IOError13 (), _State _RealWorld)
- {-# GHC_PRAGMA _A_ 2 _U_ 11 _N_ _N_ _F_ _IF_ARGS_ 0 0 X 2 _APP_ _ORIG_ PreludeWriteTextIO hPutChar [ _ORIG_ PreludeStdIO stdout13 ] _N_ #-}
+ {-# GHC_PRAGMA _A_ 2 _U_ 11 _N_ _N_ _F_ _IF_ARGS_ 0 2 XC 6 \ (u0 :: Char) (u1 :: _State _RealWorld) -> case _ORIG_ PreludeStdIO stdout13 of { _ALG_ _MVar (u2 :: SynchVar# _RealWorld _Handle) -> case u1 of { _ALG_ S# (u3 :: State# _RealWorld) -> _APP_ _WRKR_ _ORIG_ PreludeWriteTextIO hPutChar [ u2, u0, u3 ]; _NO_DEFLT_ }; _NO_DEFLT_ } _N_ #-}
putStr :: [Char] -> _State _RealWorld -> (Either IOError13 (), _State _RealWorld)
- {-# GHC_PRAGMA _A_ 2 _U_ 21 _N_ _N_ _F_ _IF_ARGS_ 0 0 X 2 _APP_ _ORIG_ PreludeWriteTextIO hPutStr [ _ORIG_ PreludeStdIO stdout13 ] _N_ #-}
+ {-# GHC_PRAGMA _A_ 2 _U_ 21 _N_ _N_ _F_ _IF_ARGS_ 0 2 XC 6 \ (u0 :: [Char]) (u1 :: _State _RealWorld) -> case _ORIG_ PreludeStdIO stdout13 of { _ALG_ _MVar (u2 :: SynchVar# _RealWorld _Handle) -> case u1 of { _ALG_ S# (u3 :: State# _RealWorld) -> _APP_ _WRKR_ _ORIG_ PreludeWriteTextIO hPutStr [ u2, u0, u3 ]; _NO_DEFLT_ }; _NO_DEFLT_ } _N_ #-}
putText :: Text a => a -> _State _RealWorld -> (Either IOError13 (), _State _RealWorld)
{-# GHC_PRAGMA _A_ 1 _U_ 121 _N_ _N_ _F_ _IF_ARGS_ 1 1 X 3 _/\_ u0 -> \ (u1 :: {{Text u0}}) -> _APP_ _TYAPP_ _ORIG_ PreludeWriteTextIO hPutText { u0 } [ u1, _ORIG_ PreludeStdIO stdout13 ] _N_ #-}
writeFile13 :: [Char] -> [Char] -> _State _RealWorld -> (Either IOError13 (), _State _RealWorld)
{-# GHC_PRAGMA _M_ PreludeMonadicIO {-dfun-} _A_ 2 _U_ 22 _N_ _N_ _N_ _N_ #-}
instance Text IOError13
{-# GHC_PRAGMA _M_ PreludeIOError {-dfun-} _A_ 0 _N_ _N_ _N_ _F_ _IF_ARGS_ 0 0 X 5 _!_ _TUP_4 [(Int -> [Char] -> [(IOError13, [Char])]), (Int -> IOError13 -> [Char] -> [Char]), ([Char] -> [([IOError13], [Char])]), ([IOError13] -> [Char] -> [Char])] [_CONSTM_ Text readsPrec (IOError13), _CONSTM_ Text showsPrec (IOError13), _CONSTM_ Text readList (IOError13), _CONSTM_ Text showList (IOError13)] _N_
- readsPrec = _A_ 2 _U_ 22 _N_ _S_ _!_ _F_ _IF_ARGS_ 0 2 XX 4 \ (u0 :: Int) (u1 :: [Char]) -> _APP_ _TYAPP_ patError# { (Int -> [Char] -> [(IOError13, [Char])]) } [ _NOREP_S_ "%DPreludeCore.Text.readsPrec\"", u0, u1 ] _N_,
- showsPrec = _A_ 2 _U_ 012 _N_ _S_ "AS" {_A_ 1 _U_ 12 _N_ _N_ _N_ _N_} _N_ _N_,
- readList = _A_ 0 _U_ 2 _N_ _N_ _N_ _N_,
- showList = _A_ 0 _U_ 12 _N_ _N_ _N_ _N_ #-}
+ readsPrec = { _A_ 2 _U_ 02 _N_ _S_ _!_ _N_ _N_ },
+ showsPrec = { _A_ 2 _U_ 012 _N_ _S_ "AS" {_A_ 1 _U_ 12 _N_ _N_ _N_ _N_} _N_ _N_ },
+ readList = { _A_ 0 _U_ 2 _N_ _N_ _N_ _N_ },
+ showList = { _A_ 1 _U_ 12 _N_ _N_ _F_ _IF_ARGS_ 0 1 X 3 \ (u0 :: [IOError13]) -> _APP_ _TYAPP_ _ORIG_ PreludeCore _showList { IOError13 } [ _WRKR_ _CONSTM_ Text showsPrec (IOError13), u0 ] _N_ } #-}
instance Text a => Text (Maybe a)
{-# GHC_PRAGMA _M_ PreludeStdIO {-dfun-} _A_ 1 _U_ 2 _N_ _N_ _N_ _N_ #-}
import PS
import Prel ( (.) )
import Text
+import TyArray
+import TyComplex
import PreludeGlaST
import PreludePrimIO ( _MVar )
-{-# GHC_PRAGMA INTERFACE VERSION 5 #-}
+{-# GHC_PRAGMA INTERFACE VERSION 6 #-}
interface PreludeIOError where
import PreludeBuiltin(Char(..), List(..), Tuple2, _RealWorld(..), _State(..))
import PreludeCore(Text(..))
{-# GHC_PRAGMA _A_ 1 _U_ 1 _N_ _S_ "U(P)" {_A_ 1 _U_ 2 _N_ _N_ _N_ _N_} _N_ _N_ #-}
instance Text IOError13
{-# GHC_PRAGMA _M_ PreludeIOError {-dfun-} _A_ 0 _N_ _N_ _N_ _F_ _IF_ARGS_ 0 0 X 5 _!_ _TUP_4 [(Int -> [Char] -> [(IOError13, [Char])]), (Int -> IOError13 -> [Char] -> [Char]), ([Char] -> [([IOError13], [Char])]), ([IOError13] -> [Char] -> [Char])] [_CONSTM_ Text readsPrec (IOError13), _CONSTM_ Text showsPrec (IOError13), _CONSTM_ Text readList (IOError13), _CONSTM_ Text showList (IOError13)] _N_
- readsPrec = _A_ 2 _U_ 22 _N_ _S_ _!_ _F_ _IF_ARGS_ 0 2 XX 4 \ (u0 :: Int) (u1 :: [Char]) -> _APP_ _TYAPP_ patError# { (Int -> [Char] -> [(IOError13, [Char])]) } [ _NOREP_S_ "%DPreludeCore.Text.readsPrec\"", u0, u1 ] _N_,
- showsPrec = _A_ 2 _U_ 012 _N_ _S_ "AS" {_A_ 1 _U_ 12 _N_ _N_ _N_ _N_} _N_ _N_,
- readList = _A_ 0 _U_ 2 _N_ _N_ _N_ _N_,
- showList = _A_ 0 _U_ 12 _N_ _N_ _N_ _N_ #-}
+ readsPrec = { _A_ 2 _U_ 02 _N_ _S_ _!_ _N_ _N_ },
+ showsPrec = { _A_ 2 _U_ 012 _N_ _S_ "AS" {_A_ 1 _U_ 12 _N_ _N_ _N_ _N_} _N_ _N_ },
+ readList = { _A_ 0 _U_ 2 _N_ _N_ _N_ _N_ },
+ showList = { _A_ 1 _U_ 12 _N_ _N_ _F_ _IF_ARGS_ 0 1 X 3 \ (u0 :: [IOError13]) -> _APP_ _TYAPP_ _ORIG_ PreludeCore _showList { IOError13 } [ _WRKR_ _CONSTM_ Text showsPrec (IOError13), u0 ] _N_ } #-}
import Prel ( (.), not )
import PreludeGlaST
import Text
+import TyArray
+import TyComplex
data IOError13 = AlreadyExists String
| HardwareFault String
-- not really OK: deriving (Text)
instance Text IOError13 where -- NB: not interested in reading
+ readsPrec p = error "readsPrec: IOError13"
+
showsPrec p (AlreadyExists s) = show2 "AlreadyExists: " s
showsPrec p (HardwareFault s) = show2 "HardwareFault: " s
showsPrec p (IllegalOperation s) = show2 "IllegalOperation: " s
showsPrec p (UserError s) = showString s
showsPrec p EOF = showString "EOF"
+ readList = _readList (readsPrec 0)
+ showList = _showList (showsPrec 0)
+
show2 x y = showString x . showString y
_constructError :: PrimIO IOError13
-{-# GHC_PRAGMA INTERFACE VERSION 5 #-}
+{-# GHC_PRAGMA INTERFACE VERSION 6 #-}
interface PreludeIOError where
import PreludeBuiltin(Char(..), List(..), Tuple2, _RealWorld(..), _State(..))
import PreludeCore(Text(..))
{-# GHC_PRAGMA _A_ 1 _U_ 1 _N_ _S_ "U(P)" {_A_ 1 _U_ 2 _N_ _N_ _N_ _N_} _N_ _N_ #-}
instance Text IOError13
{-# GHC_PRAGMA _M_ PreludeIOError {-dfun-} _A_ 0 _N_ _N_ _N_ _F_ _IF_ARGS_ 0 0 X 5 _!_ _TUP_4 [(Int -> [Char] -> [(IOError13, [Char])]), (Int -> IOError13 -> [Char] -> [Char]), ([Char] -> [([IOError13], [Char])]), ([IOError13] -> [Char] -> [Char])] [_CONSTM_ Text readsPrec (IOError13), _CONSTM_ Text showsPrec (IOError13), _CONSTM_ Text readList (IOError13), _CONSTM_ Text showList (IOError13)] _N_
- readsPrec = _A_ 2 _U_ 22 _N_ _S_ _!_ _F_ _IF_ARGS_ 0 2 XX 4 \ (u0 :: Int) (u1 :: [Char]) -> _APP_ _TYAPP_ patError# { (Int -> [Char] -> [(IOError13, [Char])]) } [ _NOREP_S_ "%DPreludeCore.Text.readsPrec\"", u0, u1 ] _N_,
- showsPrec = _A_ 2 _U_ 012 _N_ _S_ "AS" {_A_ 1 _U_ 12 _N_ _N_ _N_ _N_} _N_ _N_,
- readList = _A_ 0 _U_ 2 _N_ _N_ _N_ _N_,
- showList = _A_ 0 _U_ 12 _N_ _N_ _N_ _N_ #-}
+ readsPrec = { _A_ 2 _U_ 02 _N_ _S_ _!_ _N_ _N_ },
+ showsPrec = { _A_ 2 _U_ 012 _N_ _S_ "AS" {_A_ 1 _U_ 12 _N_ _N_ _N_ _N_} _N_ _N_ },
+ readList = { _A_ 0 _U_ 2 _N_ _N_ _N_ _N_ },
+ showList = { _A_ 1 _U_ 12 _N_ _N_ _F_ _IF_ARGS_ 0 1 X 3 \ (u0 :: [IOError13]) -> _APP_ _TYAPP_ _ORIG_ PreludeCore _showList { IOError13 } [ _WRKR_ _CONSTM_ Text showsPrec (IOError13), u0 ] _N_ } #-}
-{-# GHC_PRAGMA INTERFACE VERSION 5 #-}
+{-# GHC_PRAGMA INTERFACE VERSION 6 #-}
interface PreludeIOError where
import PreludeBuiltin(Char(..), List(..), Tuple2, _RealWorld(..), _State(..))
import PreludeCore(Text(..))
{-# GHC_PRAGMA _A_ 1 _U_ 1 _N_ _S_ "U(P)" {_A_ 1 _U_ 2 _N_ _N_ _N_ _N_} _N_ _N_ #-}
instance Text IOError13
{-# GHC_PRAGMA _M_ PreludeIOError {-dfun-} _A_ 0 _N_ _N_ _N_ _F_ _IF_ARGS_ 0 0 X 5 _!_ _TUP_4 [(Int -> [Char] -> [(IOError13, [Char])]), (Int -> IOError13 -> [Char] -> [Char]), ([Char] -> [([IOError13], [Char])]), ([IOError13] -> [Char] -> [Char])] [_CONSTM_ Text readsPrec (IOError13), _CONSTM_ Text showsPrec (IOError13), _CONSTM_ Text readList (IOError13), _CONSTM_ Text showList (IOError13)] _N_
- readsPrec = _A_ 2 _U_ 22 _N_ _S_ _!_ _F_ _IF_ARGS_ 0 2 XX 4 \ (u0 :: Int) (u1 :: [Char]) -> _APP_ _TYAPP_ patError# { (Int -> [Char] -> [(IOError13, [Char])]) } [ _NOREP_S_ "%DPreludeCore.Text.readsPrec\"", u0, u1 ] _N_,
- showsPrec = _A_ 2 _U_ 012 _N_ _S_ "AS" {_A_ 1 _U_ 12 _N_ _N_ _N_ _N_} _N_ _N_,
- readList = _A_ 0 _U_ 2 _N_ _N_ _N_ _N_,
- showList = _A_ 0 _U_ 12 _N_ _N_ _N_ _N_ #-}
+ readsPrec = { _A_ 2 _U_ 02 _N_ _S_ _!_ _N_ _N_ },
+ showsPrec = { _A_ 2 _U_ 012 _N_ _S_ "AS" {_A_ 1 _U_ 12 _N_ _N_ _N_ _N_} _N_ _N_ },
+ readList = { _A_ 0 _U_ 2 _N_ _N_ _N_ _N_ },
+ showList = { _A_ 1 _U_ 12 _N_ _N_ _F_ _IF_ARGS_ 0 1 X 3 \ (u0 :: [IOError13]) -> _APP_ _TYAPP_ _ORIG_ PreludeCore _showList { IOError13 } [ _WRKR_ _CONSTM_ Text showsPrec (IOError13), u0 ] _N_ } #-}
-{-# GHC_PRAGMA INTERFACE VERSION 5 #-}
+{-# GHC_PRAGMA INTERFACE VERSION 6 #-}
interface PreludeIOError where
import PreludeBuiltin(Char(..), List(..), Tuple2, _RealWorld(..), _State(..))
import PreludeCore(Text(..))
{-# GHC_PRAGMA _A_ 1 _U_ 1 _N_ _S_ "U(P)" {_A_ 1 _U_ 2 _N_ _N_ _N_ _N_} _N_ _N_ #-}
instance Text IOError13
{-# GHC_PRAGMA _M_ PreludeIOError {-dfun-} _A_ 0 _N_ _N_ _N_ _F_ _IF_ARGS_ 0 0 X 5 _!_ _TUP_4 [(Int -> [Char] -> [(IOError13, [Char])]), (Int -> IOError13 -> [Char] -> [Char]), ([Char] -> [([IOError13], [Char])]), ([IOError13] -> [Char] -> [Char])] [_CONSTM_ Text readsPrec (IOError13), _CONSTM_ Text showsPrec (IOError13), _CONSTM_ Text readList (IOError13), _CONSTM_ Text showList (IOError13)] _N_
- readsPrec = _A_ 2 _U_ 22 _N_ _S_ _!_ _F_ _IF_ARGS_ 0 2 XX 4 \ (u0 :: Int) (u1 :: [Char]) -> _APP_ _TYAPP_ patError# { (Int -> [Char] -> [(IOError13, [Char])]) } [ _NOREP_S_ "%DPreludeCore.Text.readsPrec\"", u0, u1 ] _N_,
- showsPrec = _A_ 2 _U_ 012 _N_ _S_ "AS" {_A_ 1 _U_ 12 _N_ _N_ _N_ _N_} _N_ _N_,
- readList = _A_ 0 _U_ 2 _N_ _N_ _N_ _N_,
- showList = _A_ 0 _U_ 12 _N_ _N_ _N_ _N_ #-}
+ readsPrec = { _A_ 2 _U_ 02 _N_ _S_ _!_ _N_ _N_ },
+ showsPrec = { _A_ 2 _U_ 012 _N_ _S_ "AS" {_A_ 1 _U_ 12 _N_ _N_ _N_ _N_} _N_ _N_ },
+ readList = { _A_ 0 _U_ 2 _N_ _N_ _N_ _N_ },
+ showList = { _A_ 1 _U_ 12 _N_ _N_ _F_ _IF_ARGS_ 0 1 X 3 \ (u0 :: [IOError13]) -> _APP_ _TYAPP_ _ORIG_ PreludeCore _showList { IOError13 } [ _WRKR_ _CONSTM_ Text showsPrec (IOError13), u0 ] _N_ } #-}
-{-# GHC_PRAGMA INTERFACE VERSION 5 #-}
+{-# GHC_PRAGMA INTERFACE VERSION 6 #-}
interface PreludeIOError where
import PreludeBuiltin(Char(..), List(..), Tuple2, _RealWorld(..), _State(..))
import PreludeCore(Text(..))
{-# GHC_PRAGMA _A_ 1 _U_ 1 _N_ _S_ "U(P)" {_A_ 1 _U_ 2 _N_ _N_ _N_ _N_} _N_ _N_ #-}
instance Text IOError13
{-# GHC_PRAGMA _M_ PreludeIOError {-dfun-} _A_ 0 _N_ _N_ _N_ _F_ _IF_ARGS_ 0 0 X 5 _!_ _TUP_4 [(Int -> [Char] -> [(IOError13, [Char])]), (Int -> IOError13 -> [Char] -> [Char]), ([Char] -> [([IOError13], [Char])]), ([IOError13] -> [Char] -> [Char])] [_CONSTM_ Text readsPrec (IOError13), _CONSTM_ Text showsPrec (IOError13), _CONSTM_ Text readList (IOError13), _CONSTM_ Text showList (IOError13)] _N_
- readsPrec = _A_ 2 _U_ 22 _N_ _S_ _!_ _F_ _IF_ARGS_ 0 2 XX 4 \ (u0 :: Int) (u1 :: [Char]) -> _APP_ _TYAPP_ patError# { (Int -> [Char] -> [(IOError13, [Char])]) } [ _NOREP_S_ "%DPreludeCore.Text.readsPrec\"", u0, u1 ] _N_,
- showsPrec = _A_ 2 _U_ 012 _N_ _S_ "AS" {_A_ 1 _U_ 12 _N_ _N_ _N_ _N_} _N_ _N_,
- readList = _A_ 0 _U_ 2 _N_ _N_ _N_ _N_,
- showList = _A_ 0 _U_ 12 _N_ _N_ _N_ _N_ #-}
+ readsPrec = { _A_ 2 _U_ 02 _N_ _S_ _!_ _N_ _N_ },
+ showsPrec = { _A_ 2 _U_ 012 _N_ _S_ "AS" {_A_ 1 _U_ 12 _N_ _N_ _N_ _N_} _N_ _N_ },
+ readList = { _A_ 0 _U_ 2 _N_ _N_ _N_ _N_ },
+ showList = { _A_ 1 _U_ 12 _N_ _N_ _F_ _IF_ARGS_ 0 1 X 3 \ (u0 :: [IOError13]) -> _APP_ _TYAPP_ _ORIG_ PreludeCore _showList { IOError13 } [ _WRKR_ _CONSTM_ Text showsPrec (IOError13), u0 ] _N_ } #-}
-{-# GHC_PRAGMA INTERFACE VERSION 5 #-}
+{-# GHC_PRAGMA INTERFACE VERSION 6 #-}
interface PreludeIO where
import PreludeBuiltin(Char(..), Int(..), Integer(..), List(..), Tuple0, Tuple2, _Addr(..), _RealWorld(..), _State(..))
import PreludeCore(Bool(..), Eq(..), Ord(..), Text(..))
print13 :: Text a => a -> _State _RealWorld -> (Either IOError13 (), _State _RealWorld)
{-# GHC_PRAGMA _A_ 1 _U_ 121 _N_ _N_ _N_ _N_ #-}
putChar :: Char -> _State _RealWorld -> (Either IOError13 (), _State _RealWorld)
- {-# GHC_PRAGMA _A_ 2 _U_ 11 _N_ _N_ _F_ _IF_ARGS_ 0 0 X 2 _APP_ _ORIG_ PreludeWriteTextIO hPutChar [ _ORIG_ PreludeStdIO stdout13 ] _N_ #-}
+ {-# GHC_PRAGMA _A_ 2 _U_ 11 _N_ _N_ _F_ _IF_ARGS_ 0 2 XC 6 \ (u0 :: Char) (u1 :: _State _RealWorld) -> case _ORIG_ PreludeStdIO stdout13 of { _ALG_ _MVar (u2 :: SynchVar# _RealWorld _Handle) -> case u1 of { _ALG_ S# (u3 :: State# _RealWorld) -> _APP_ _WRKR_ _ORIG_ PreludeWriteTextIO hPutChar [ u2, u0, u3 ]; _NO_DEFLT_ }; _NO_DEFLT_ } _N_ #-}
putStr :: [Char] -> _State _RealWorld -> (Either IOError13 (), _State _RealWorld)
- {-# GHC_PRAGMA _A_ 2 _U_ 21 _N_ _N_ _F_ _IF_ARGS_ 0 0 X 2 _APP_ _ORIG_ PreludeWriteTextIO hPutStr [ _ORIG_ PreludeStdIO stdout13 ] _N_ #-}
+ {-# GHC_PRAGMA _A_ 2 _U_ 21 _N_ _N_ _F_ _IF_ARGS_ 0 2 XC 6 \ (u0 :: [Char]) (u1 :: _State _RealWorld) -> case _ORIG_ PreludeStdIO stdout13 of { _ALG_ _MVar (u2 :: SynchVar# _RealWorld _Handle) -> case u1 of { _ALG_ S# (u3 :: State# _RealWorld) -> _APP_ _WRKR_ _ORIG_ PreludeWriteTextIO hPutStr [ u2, u0, u3 ]; _NO_DEFLT_ }; _NO_DEFLT_ } _N_ #-}
putText :: Text a => a -> _State _RealWorld -> (Either IOError13 (), _State _RealWorld)
{-# GHC_PRAGMA _A_ 1 _U_ 121 _N_ _N_ _F_ _IF_ARGS_ 1 1 X 3 _/\_ u0 -> \ (u1 :: {{Text u0}}) -> _APP_ _TYAPP_ _ORIG_ PreludeWriteTextIO hPutText { u0 } [ u1, _ORIG_ PreludeStdIO stdout13 ] _N_ #-}
writeFile13 :: [Char] -> [Char] -> _State _RealWorld -> (Either IOError13 (), _State _RealWorld)
{-# GHC_PRAGMA _M_ PreludeMonadicIO {-dfun-} _A_ 2 _U_ 22 _N_ _N_ _N_ _N_ #-}
instance Text IOError13
{-# GHC_PRAGMA _M_ PreludeIOError {-dfun-} _A_ 0 _N_ _N_ _N_ _F_ _IF_ARGS_ 0 0 X 5 _!_ _TUP_4 [(Int -> [Char] -> [(IOError13, [Char])]), (Int -> IOError13 -> [Char] -> [Char]), ([Char] -> [([IOError13], [Char])]), ([IOError13] -> [Char] -> [Char])] [_CONSTM_ Text readsPrec (IOError13), _CONSTM_ Text showsPrec (IOError13), _CONSTM_ Text readList (IOError13), _CONSTM_ Text showList (IOError13)] _N_
- readsPrec = _A_ 2 _U_ 22 _N_ _S_ _!_ _F_ _IF_ARGS_ 0 2 XX 4 \ (u0 :: Int) (u1 :: [Char]) -> _APP_ _TYAPP_ patError# { (Int -> [Char] -> [(IOError13, [Char])]) } [ _NOREP_S_ "%DPreludeCore.Text.readsPrec\"", u0, u1 ] _N_,
- showsPrec = _A_ 2 _U_ 012 _N_ _S_ "AS" {_A_ 1 _U_ 12 _N_ _N_ _N_ _N_} _N_ _N_,
- readList = _A_ 0 _U_ 2 _N_ _N_ _N_ _N_,
- showList = _A_ 0 _U_ 12 _N_ _N_ _N_ _N_ #-}
+ readsPrec = { _A_ 2 _U_ 02 _N_ _S_ _!_ _N_ _N_ },
+ showsPrec = { _A_ 2 _U_ 012 _N_ _S_ "AS" {_A_ 1 _U_ 12 _N_ _N_ _N_ _N_} _N_ _N_ },
+ readList = { _A_ 0 _U_ 2 _N_ _N_ _N_ _N_ },
+ showList = { _A_ 1 _U_ 12 _N_ _N_ _F_ _IF_ARGS_ 0 1 X 3 \ (u0 :: [IOError13]) -> _APP_ _TYAPP_ _ORIG_ PreludeCore _showList { IOError13 } [ _WRKR_ _CONSTM_ Text showsPrec (IOError13), u0 ] _N_ } #-}
instance Text a => Text (Maybe a)
{-# GHC_PRAGMA _M_ PreludeStdIO {-dfun-} _A_ 1 _U_ 2 _N_ _N_ _N_ _N_ #-}
-{-# GHC_PRAGMA INTERFACE VERSION 5 #-}
+{-# GHC_PRAGMA INTERFACE VERSION 6 #-}
interface PreludeIO where
import PreludeBuiltin(Char(..), Int(..), Integer(..), List(..), Tuple0, Tuple2, _Addr(..), _RealWorld(..), _State(..))
import PreludeCore(Bool(..), Eq(..), Ord(..), Text(..))
print13 :: Text a => a -> _State _RealWorld -> (Either IOError13 (), _State _RealWorld)
{-# GHC_PRAGMA _A_ 1 _U_ 121 _N_ _N_ _N_ _N_ #-}
putChar :: Char -> _State _RealWorld -> (Either IOError13 (), _State _RealWorld)
- {-# GHC_PRAGMA _A_ 2 _U_ 11 _N_ _N_ _F_ _IF_ARGS_ 0 0 X 2 _APP_ _ORIG_ PreludeWriteTextIO hPutChar [ _ORIG_ PreludeStdIO stdout13 ] _N_ #-}
+ {-# GHC_PRAGMA _A_ 2 _U_ 11 _N_ _N_ _F_ _IF_ARGS_ 0 2 XC 6 \ (u0 :: Char) (u1 :: _State _RealWorld) -> case _ORIG_ PreludeStdIO stdout13 of { _ALG_ _MVar (u2 :: SynchVar# _RealWorld _Handle) -> case u1 of { _ALG_ S# (u3 :: State# _RealWorld) -> _APP_ _WRKR_ _ORIG_ PreludeWriteTextIO hPutChar [ u2, u0, u3 ]; _NO_DEFLT_ }; _NO_DEFLT_ } _N_ #-}
putStr :: [Char] -> _State _RealWorld -> (Either IOError13 (), _State _RealWorld)
- {-# GHC_PRAGMA _A_ 2 _U_ 21 _N_ _N_ _F_ _IF_ARGS_ 0 0 X 2 _APP_ _ORIG_ PreludeWriteTextIO hPutStr [ _ORIG_ PreludeStdIO stdout13 ] _N_ #-}
+ {-# GHC_PRAGMA _A_ 2 _U_ 21 _N_ _N_ _F_ _IF_ARGS_ 0 2 XC 6 \ (u0 :: [Char]) (u1 :: _State _RealWorld) -> case _ORIG_ PreludeStdIO stdout13 of { _ALG_ _MVar (u2 :: SynchVar# _RealWorld _Handle) -> case u1 of { _ALG_ S# (u3 :: State# _RealWorld) -> _APP_ _WRKR_ _ORIG_ PreludeWriteTextIO hPutStr [ u2, u0, u3 ]; _NO_DEFLT_ }; _NO_DEFLT_ } _N_ #-}
putText :: Text a => a -> _State _RealWorld -> (Either IOError13 (), _State _RealWorld)
{-# GHC_PRAGMA _A_ 1 _U_ 121 _N_ _N_ _F_ _IF_ARGS_ 1 1 X 3 _/\_ u0 -> \ (u1 :: {{Text u0}}) -> _APP_ _TYAPP_ _ORIG_ PreludeWriteTextIO hPutText { u0 } [ u1, _ORIG_ PreludeStdIO stdout13 ] _N_ #-}
writeFile13 :: [Char] -> [Char] -> _State _RealWorld -> (Either IOError13 (), _State _RealWorld)
{-# GHC_PRAGMA _M_ PreludeMonadicIO {-dfun-} _A_ 2 _U_ 22 _N_ _N_ _N_ _N_ #-}
instance Text IOError13
{-# GHC_PRAGMA _M_ PreludeIOError {-dfun-} _A_ 0 _N_ _N_ _N_ _F_ _IF_ARGS_ 0 0 X 5 _!_ _TUP_4 [(Int -> [Char] -> [(IOError13, [Char])]), (Int -> IOError13 -> [Char] -> [Char]), ([Char] -> [([IOError13], [Char])]), ([IOError13] -> [Char] -> [Char])] [_CONSTM_ Text readsPrec (IOError13), _CONSTM_ Text showsPrec (IOError13), _CONSTM_ Text readList (IOError13), _CONSTM_ Text showList (IOError13)] _N_
- readsPrec = _A_ 2 _U_ 22 _N_ _S_ _!_ _F_ _IF_ARGS_ 0 2 XX 4 \ (u0 :: Int) (u1 :: [Char]) -> _APP_ _TYAPP_ patError# { (Int -> [Char] -> [(IOError13, [Char])]) } [ _NOREP_S_ "%DPreludeCore.Text.readsPrec\"", u0, u1 ] _N_,
- showsPrec = _A_ 2 _U_ 012 _N_ _S_ "AS" {_A_ 1 _U_ 12 _N_ _N_ _N_ _N_} _N_ _N_,
- readList = _A_ 0 _U_ 2 _N_ _N_ _N_ _N_,
- showList = _A_ 0 _U_ 12 _N_ _N_ _N_ _N_ #-}
+ readsPrec = { _A_ 2 _U_ 02 _N_ _S_ _!_ _N_ _N_ },
+ showsPrec = { _A_ 2 _U_ 012 _N_ _S_ "AS" {_A_ 1 _U_ 12 _N_ _N_ _N_ _N_} _N_ _N_ },
+ readList = { _A_ 0 _U_ 2 _N_ _N_ _N_ _N_ },
+ showList = { _A_ 1 _U_ 12 _N_ _N_ _F_ _IF_ARGS_ 0 1 X 3 \ (u0 :: [IOError13]) -> _APP_ _TYAPP_ _ORIG_ PreludeCore _showList { IOError13 } [ _WRKR_ _CONSTM_ Text showsPrec (IOError13), u0 ] _N_ } #-}
instance Text a => Text (Maybe a)
{-# GHC_PRAGMA _M_ PreludeStdIO {-dfun-} _A_ 1 _U_ 2 _N_ _N_ _N_ _N_ #-}
-{-# GHC_PRAGMA INTERFACE VERSION 5 #-}
+{-# GHC_PRAGMA INTERFACE VERSION 6 #-}
interface PreludeIO where
import PreludeBuiltin(Char(..), Int(..), Integer(..), List(..), Tuple0, Tuple2, _Addr(..), _RealWorld(..), _State(..))
import PreludeCore(Bool(..), Eq(..), Ord(..), Text(..))
print13 :: Text a => a -> _State _RealWorld -> (Either IOError13 (), _State _RealWorld)
{-# GHC_PRAGMA _A_ 1 _U_ 121 _N_ _N_ _N_ _N_ #-}
putChar :: Char -> _State _RealWorld -> (Either IOError13 (), _State _RealWorld)
- {-# GHC_PRAGMA _A_ 2 _U_ 11 _N_ _N_ _F_ _IF_ARGS_ 0 0 X 2 _APP_ _ORIG_ PreludeWriteTextIO hPutChar [ _ORIG_ PreludeStdIO stdout13 ] _N_ #-}
+ {-# GHC_PRAGMA _A_ 2 _U_ 11 _N_ _N_ _F_ _IF_ARGS_ 0 2 XC 6 \ (u0 :: Char) (u1 :: _State _RealWorld) -> case _ORIG_ PreludeStdIO stdout13 of { _ALG_ _MVar (u2 :: SynchVar# _RealWorld _Handle) -> case u1 of { _ALG_ S# (u3 :: State# _RealWorld) -> _APP_ _WRKR_ _ORIG_ PreludeWriteTextIO hPutChar [ u2, u0, u3 ]; _NO_DEFLT_ }; _NO_DEFLT_ } _N_ #-}
putStr :: [Char] -> _State _RealWorld -> (Either IOError13 (), _State _RealWorld)
- {-# GHC_PRAGMA _A_ 2 _U_ 21 _N_ _N_ _F_ _IF_ARGS_ 0 0 X 2 _APP_ _ORIG_ PreludeWriteTextIO hPutStr [ _ORIG_ PreludeStdIO stdout13 ] _N_ #-}
+ {-# GHC_PRAGMA _A_ 2 _U_ 21 _N_ _N_ _F_ _IF_ARGS_ 0 2 XC 6 \ (u0 :: [Char]) (u1 :: _State _RealWorld) -> case _ORIG_ PreludeStdIO stdout13 of { _ALG_ _MVar (u2 :: SynchVar# _RealWorld _Handle) -> case u1 of { _ALG_ S# (u3 :: State# _RealWorld) -> _APP_ _WRKR_ _ORIG_ PreludeWriteTextIO hPutStr [ u2, u0, u3 ]; _NO_DEFLT_ }; _NO_DEFLT_ } _N_ #-}
putText :: Text a => a -> _State _RealWorld -> (Either IOError13 (), _State _RealWorld)
{-# GHC_PRAGMA _A_ 1 _U_ 121 _N_ _N_ _F_ _IF_ARGS_ 1 1 X 3 _/\_ u0 -> \ (u1 :: {{Text u0}}) -> _APP_ _TYAPP_ _ORIG_ PreludeWriteTextIO hPutText { u0 } [ u1, _ORIG_ PreludeStdIO stdout13 ] _N_ #-}
writeFile13 :: [Char] -> [Char] -> _State _RealWorld -> (Either IOError13 (), _State _RealWorld)
{-# GHC_PRAGMA _M_ PreludeMonadicIO {-dfun-} _A_ 2 _U_ 22 _N_ _N_ _N_ _N_ #-}
instance Text IOError13
{-# GHC_PRAGMA _M_ PreludeIOError {-dfun-} _A_ 0 _N_ _N_ _N_ _F_ _IF_ARGS_ 0 0 X 5 _!_ _TUP_4 [(Int -> [Char] -> [(IOError13, [Char])]), (Int -> IOError13 -> [Char] -> [Char]), ([Char] -> [([IOError13], [Char])]), ([IOError13] -> [Char] -> [Char])] [_CONSTM_ Text readsPrec (IOError13), _CONSTM_ Text showsPrec (IOError13), _CONSTM_ Text readList (IOError13), _CONSTM_ Text showList (IOError13)] _N_
- readsPrec = _A_ 2 _U_ 22 _N_ _S_ _!_ _F_ _IF_ARGS_ 0 2 XX 4 \ (u0 :: Int) (u1 :: [Char]) -> _APP_ _TYAPP_ patError# { (Int -> [Char] -> [(IOError13, [Char])]) } [ _NOREP_S_ "%DPreludeCore.Text.readsPrec\"", u0, u1 ] _N_,
- showsPrec = _A_ 2 _U_ 012 _N_ _S_ "AS" {_A_ 1 _U_ 12 _N_ _N_ _N_ _N_} _N_ _N_,
- readList = _A_ 0 _U_ 2 _N_ _N_ _N_ _N_,
- showList = _A_ 0 _U_ 12 _N_ _N_ _N_ _N_ #-}
+ readsPrec = { _A_ 2 _U_ 02 _N_ _S_ _!_ _N_ _N_ },
+ showsPrec = { _A_ 2 _U_ 012 _N_ _S_ "AS" {_A_ 1 _U_ 12 _N_ _N_ _N_ _N_} _N_ _N_ },
+ readList = { _A_ 0 _U_ 2 _N_ _N_ _N_ _N_ },
+ showList = { _A_ 1 _U_ 12 _N_ _N_ _F_ _IF_ARGS_ 0 1 X 3 \ (u0 :: [IOError13]) -> _APP_ _TYAPP_ _ORIG_ PreludeCore _showList { IOError13 } [ _WRKR_ _CONSTM_ Text showsPrec (IOError13), u0 ] _N_ } #-}
instance Text a => Text (Maybe a)
{-# GHC_PRAGMA _M_ PreludeStdIO {-dfun-} _A_ 1 _U_ 2 _N_ _N_ _N_ _N_ #-}
-{-# GHC_PRAGMA INTERFACE VERSION 5 #-}
+{-# GHC_PRAGMA INTERFACE VERSION 6 #-}
interface PreludeIO where
import PreludeBuiltin(Char(..), Int(..), Integer(..), List(..), Tuple0, Tuple2, _Addr(..), _RealWorld(..), _State(..))
import PreludeCore(Bool(..), Eq(..), Ord(..), Text(..))
print13 :: Text a => a -> _State _RealWorld -> (Either IOError13 (), _State _RealWorld)
{-# GHC_PRAGMA _A_ 1 _U_ 121 _N_ _N_ _N_ _N_ #-}
putChar :: Char -> _State _RealWorld -> (Either IOError13 (), _State _RealWorld)
- {-# GHC_PRAGMA _A_ 2 _U_ 11 _N_ _N_ _F_ _IF_ARGS_ 0 0 X 2 _APP_ _ORIG_ PreludeWriteTextIO hPutChar [ _ORIG_ PreludeStdIO stdout13 ] _N_ #-}
+ {-# GHC_PRAGMA _A_ 2 _U_ 11 _N_ _N_ _F_ _IF_ARGS_ 0 2 XC 6 \ (u0 :: Char) (u1 :: _State _RealWorld) -> case _ORIG_ PreludeStdIO stdout13 of { _ALG_ _MVar (u2 :: SynchVar# _RealWorld _Handle) -> case u1 of { _ALG_ S# (u3 :: State# _RealWorld) -> _APP_ _WRKR_ _ORIG_ PreludeWriteTextIO hPutChar [ u2, u0, u3 ]; _NO_DEFLT_ }; _NO_DEFLT_ } _N_ #-}
putStr :: [Char] -> _State _RealWorld -> (Either IOError13 (), _State _RealWorld)
- {-# GHC_PRAGMA _A_ 2 _U_ 21 _N_ _N_ _F_ _IF_ARGS_ 0 0 X 2 _APP_ _ORIG_ PreludeWriteTextIO hPutStr [ _ORIG_ PreludeStdIO stdout13 ] _N_ #-}
+ {-# GHC_PRAGMA _A_ 2 _U_ 21 _N_ _N_ _F_ _IF_ARGS_ 0 2 XC 6 \ (u0 :: [Char]) (u1 :: _State _RealWorld) -> case _ORIG_ PreludeStdIO stdout13 of { _ALG_ _MVar (u2 :: SynchVar# _RealWorld _Handle) -> case u1 of { _ALG_ S# (u3 :: State# _RealWorld) -> _APP_ _WRKR_ _ORIG_ PreludeWriteTextIO hPutStr [ u2, u0, u3 ]; _NO_DEFLT_ }; _NO_DEFLT_ } _N_ #-}
putText :: Text a => a -> _State _RealWorld -> (Either IOError13 (), _State _RealWorld)
{-# GHC_PRAGMA _A_ 1 _U_ 121 _N_ _N_ _F_ _IF_ARGS_ 1 1 X 3 _/\_ u0 -> \ (u1 :: {{Text u0}}) -> _APP_ _TYAPP_ _ORIG_ PreludeWriteTextIO hPutText { u0 } [ u1, _ORIG_ PreludeStdIO stdout13 ] _N_ #-}
writeFile13 :: [Char] -> [Char] -> _State _RealWorld -> (Either IOError13 (), _State _RealWorld)
{-# GHC_PRAGMA _M_ PreludeMonadicIO {-dfun-} _A_ 2 _U_ 22 _N_ _N_ _N_ _N_ #-}
instance Text IOError13
{-# GHC_PRAGMA _M_ PreludeIOError {-dfun-} _A_ 0 _N_ _N_ _N_ _F_ _IF_ARGS_ 0 0 X 5 _!_ _TUP_4 [(Int -> [Char] -> [(IOError13, [Char])]), (Int -> IOError13 -> [Char] -> [Char]), ([Char] -> [([IOError13], [Char])]), ([IOError13] -> [Char] -> [Char])] [_CONSTM_ Text readsPrec (IOError13), _CONSTM_ Text showsPrec (IOError13), _CONSTM_ Text readList (IOError13), _CONSTM_ Text showList (IOError13)] _N_
- readsPrec = _A_ 2 _U_ 22 _N_ _S_ _!_ _F_ _IF_ARGS_ 0 2 XX 4 \ (u0 :: Int) (u1 :: [Char]) -> _APP_ _TYAPP_ patError# { (Int -> [Char] -> [(IOError13, [Char])]) } [ _NOREP_S_ "%DPreludeCore.Text.readsPrec\"", u0, u1 ] _N_,
- showsPrec = _A_ 2 _U_ 012 _N_ _S_ "AS" {_A_ 1 _U_ 12 _N_ _N_ _N_ _N_} _N_ _N_,
- readList = _A_ 0 _U_ 2 _N_ _N_ _N_ _N_,
- showList = _A_ 0 _U_ 12 _N_ _N_ _N_ _N_ #-}
+ readsPrec = { _A_ 2 _U_ 02 _N_ _S_ _!_ _N_ _N_ },
+ showsPrec = { _A_ 2 _U_ 012 _N_ _S_ "AS" {_A_ 1 _U_ 12 _N_ _N_ _N_ _N_} _N_ _N_ },
+ readList = { _A_ 0 _U_ 2 _N_ _N_ _N_ _N_ },
+ showList = { _A_ 1 _U_ 12 _N_ _N_ _F_ _IF_ARGS_ 0 1 X 3 \ (u0 :: [IOError13]) -> _APP_ _TYAPP_ _ORIG_ PreludeCore _showList { IOError13 } [ _WRKR_ _CONSTM_ Text showsPrec (IOError13), u0 ] _N_ } #-}
instance Text a => Text (Maybe a)
{-# GHC_PRAGMA _M_ PreludeStdIO {-dfun-} _A_ 1 _U_ 2 _N_ _N_ _N_ _N_ #-}
-{-# GHC_PRAGMA INTERFACE VERSION 5 #-}
+{-# GHC_PRAGMA INTERFACE VERSION 6 #-}
interface PreludeMonadicIO where
import PreludeBuiltin(Char(..), List(..), Tuple0, Tuple2, _RealWorld(..), _State(..))
import PreludeCore(Eq(..), Ord(..), Text(..))
import Prel ( (.), not )
import PS ( _PackedString, _unpackPS )
import Text
+import TyArray
+import TyComplex
import PreludeGlaST
import PreludeIOError
-{-# GHC_PRAGMA INTERFACE VERSION 5 #-}
+{-# GHC_PRAGMA INTERFACE VERSION 6 #-}
interface PreludeMonadicIO where
import PreludeBuiltin(Char(..), List(..), Tuple0, Tuple2, _RealWorld(..), _State(..))
import PreludeCore(Eq(..), Ord(..), Text(..))
-{-# GHC_PRAGMA INTERFACE VERSION 5 #-}
+{-# GHC_PRAGMA INTERFACE VERSION 6 #-}
interface PreludeMonadicIO where
import PreludeBuiltin(Char(..), List(..), Tuple0, Tuple2, _RealWorld(..), _State(..))
import PreludeCore(Eq(..), Ord(..), Text(..))
-{-# GHC_PRAGMA INTERFACE VERSION 5 #-}
+{-# GHC_PRAGMA INTERFACE VERSION 6 #-}
interface PreludeMonadicIO where
import PreludeBuiltin(Char(..), List(..), Tuple0, Tuple2, _RealWorld(..), _State(..))
import PreludeCore(Eq(..), Ord(..), Text(..))
-{-# GHC_PRAGMA INTERFACE VERSION 5 #-}
+{-# GHC_PRAGMA INTERFACE VERSION 6 #-}
interface PreludeMonadicIO where
import PreludeBuiltin(Char(..), List(..), Tuple0, Tuple2, _RealWorld(..), _State(..))
import PreludeCore(Eq(..), Ord(..), Text(..))
-{-# GHC_PRAGMA INTERFACE VERSION 5 #-}
+{-# GHC_PRAGMA INTERFACE VERSION 6 #-}
interface PreludeReadTextIO where
import PreludeBuiltin(Char(..), List(..), Tuple2, _RealWorld(..), _State(..))
import PreludeCore(Bool(..))
import List ( (++) )
import Prel ( chr )
import Text
+import TyArray
+import TyComplex
import PreludeIOError
import PreludeMonadicIO
-{-# GHC_PRAGMA INTERFACE VERSION 5 #-}
+{-# GHC_PRAGMA INTERFACE VERSION 6 #-}
interface PreludeReadTextIO where
import PreludeBuiltin(Char(..), List(..), Tuple2, _RealWorld(..), _State(..))
import PreludeCore(Bool(..))
-{-# GHC_PRAGMA INTERFACE VERSION 5 #-}
+{-# GHC_PRAGMA INTERFACE VERSION 6 #-}
interface PreludeReadTextIO where
import PreludeBuiltin(Char(..), List(..), Tuple2, _RealWorld(..), _State(..))
import PreludeCore(Bool(..))
-{-# GHC_PRAGMA INTERFACE VERSION 5 #-}
+{-# GHC_PRAGMA INTERFACE VERSION 6 #-}
interface PreludeReadTextIO where
import PreludeBuiltin(Char(..), List(..), Tuple2, _RealWorld(..), _State(..))
import PreludeCore(Bool(..))
-{-# GHC_PRAGMA INTERFACE VERSION 5 #-}
+{-# GHC_PRAGMA INTERFACE VERSION 6 #-}
interface PreludeReadTextIO where
import PreludeBuiltin(Char(..), List(..), Tuple2, _RealWorld(..), _State(..))
import PreludeCore(Bool(..))
-{-# GHC_PRAGMA INTERFACE VERSION 5 #-}
+{-# GHC_PRAGMA INTERFACE VERSION 6 #-}
interface PreludeStdIO where
import PreludeBuiltin(Char(..), Int(..), Integer(..), List(..), Tuple0, Tuple2, _Addr(..), _RealWorld(..), _State(..))
import PreludeCore(Bool(..), Eq(..), Ord(..), Text(..))
import Prel ( otherwise, not, (.) )
import Text
import TyArray -- instance _CCallable (_ByteArray a)
+import TyComplex
import PreludeIOError
import PreludeMonadicIO
-{-# GHC_PRAGMA INTERFACE VERSION 5 #-}
+{-# GHC_PRAGMA INTERFACE VERSION 6 #-}
interface PreludeStdIO where
import PreludeBuiltin(Char(..), Int(..), Integer(..), List(..), Tuple0, Tuple2, _Addr(..), _RealWorld(..), _State(..))
import PreludeCore(Bool(..), Eq(..), Ord(..), Text(..))
-{-# GHC_PRAGMA INTERFACE VERSION 5 #-}
+{-# GHC_PRAGMA INTERFACE VERSION 6 #-}
interface PreludeStdIO where
import PreludeBuiltin(Char(..), Int(..), Integer(..), List(..), Tuple0, Tuple2, _Addr(..), _RealWorld(..), _State(..))
import PreludeCore(Bool(..), Eq(..), Ord(..), Text(..))
-{-# GHC_PRAGMA INTERFACE VERSION 5 #-}
+{-# GHC_PRAGMA INTERFACE VERSION 6 #-}
interface PreludeStdIO where
import PreludeBuiltin(Char(..), Int(..), Integer(..), List(..), Tuple0, Tuple2, _Addr(..), _RealWorld(..), _State(..))
import PreludeCore(Bool(..), Eq(..), Ord(..), Text(..))
-{-# GHC_PRAGMA INTERFACE VERSION 5 #-}
+{-# GHC_PRAGMA INTERFACE VERSION 6 #-}
interface PreludeStdIO where
import PreludeBuiltin(Char(..), Int(..), Integer(..), List(..), Tuple0, Tuple2, _Addr(..), _RealWorld(..), _State(..))
import PreludeCore(Bool(..), Eq(..), Ord(..), Text(..))
-{-# GHC_PRAGMA INTERFACE VERSION 5 #-}
+{-# GHC_PRAGMA INTERFACE VERSION 6 #-}
interface PreludeWriteTextIO where
import PreludeBuiltin(Char(..), List(..), Tuple0, Tuple2, _RealWorld(..), _State(..))
import PreludeCore(Text(..))
print13 :: Text a => a -> _State _RealWorld -> (Either IOError13 (), _State _RealWorld)
{-# GHC_PRAGMA _A_ 1 _U_ 121 _N_ _N_ _N_ _N_ #-}
putChar :: Char -> _State _RealWorld -> (Either IOError13 (), _State _RealWorld)
- {-# GHC_PRAGMA _A_ 2 _U_ 11 _N_ _N_ _F_ _IF_ARGS_ 0 0 X 2 _APP_ _ORIG_ PreludeWriteTextIO hPutChar [ _ORIG_ PreludeStdIO stdout13 ] _N_ #-}
+ {-# GHC_PRAGMA _A_ 2 _U_ 11 _N_ _N_ _F_ _IF_ARGS_ 0 2 XC 6 \ (u0 :: Char) (u1 :: _State _RealWorld) -> case _ORIG_ PreludeStdIO stdout13 of { _ALG_ _MVar (u2 :: SynchVar# _RealWorld _Handle) -> case u1 of { _ALG_ S# (u3 :: State# _RealWorld) -> _APP_ _WRKR_ _ORIG_ PreludeWriteTextIO hPutChar [ u2, u0, u3 ]; _NO_DEFLT_ }; _NO_DEFLT_ } _N_ #-}
putStr :: [Char] -> _State _RealWorld -> (Either IOError13 (), _State _RealWorld)
- {-# GHC_PRAGMA _A_ 2 _U_ 21 _N_ _N_ _F_ _IF_ARGS_ 0 0 X 2 _APP_ _ORIG_ PreludeWriteTextIO hPutStr [ _ORIG_ PreludeStdIO stdout13 ] _N_ #-}
+ {-# GHC_PRAGMA _A_ 2 _U_ 21 _N_ _N_ _F_ _IF_ARGS_ 0 2 XC 6 \ (u0 :: [Char]) (u1 :: _State _RealWorld) -> case _ORIG_ PreludeStdIO stdout13 of { _ALG_ _MVar (u2 :: SynchVar# _RealWorld _Handle) -> case u1 of { _ALG_ S# (u3 :: State# _RealWorld) -> _APP_ _WRKR_ _ORIG_ PreludeWriteTextIO hPutStr [ u2, u0, u3 ]; _NO_DEFLT_ }; _NO_DEFLT_ } _N_ #-}
putText :: Text a => a -> _State _RealWorld -> (Either IOError13 (), _State _RealWorld)
{-# GHC_PRAGMA _A_ 1 _U_ 121 _N_ _N_ _F_ _IF_ARGS_ 1 1 X 3 _/\_ u0 -> \ (u1 :: {{Text u0}}) -> _APP_ _TYAPP_ _ORIG_ PreludeWriteTextIO hPutText { u0 } [ u1, _ORIG_ PreludeStdIO stdout13 ] _N_ #-}
writeFile13 :: [Char] -> [Char] -> _State _RealWorld -> (Either IOError13 (), _State _RealWorld)
import Prel ( ord, (.), otherwise )
import Text
import TyArray -- instance _CCallable (_ByteArray a)
+import TyComplex
import PreludeIOError
import PreludeMonadicIO
-{-# GHC_PRAGMA INTERFACE VERSION 5 #-}
+{-# GHC_PRAGMA INTERFACE VERSION 6 #-}
interface PreludeWriteTextIO where
import PreludeBuiltin(Char(..), List(..), Tuple0, Tuple2, _RealWorld(..), _State(..))
import PreludeCore(Text(..))
print13 :: Text a => a -> _State _RealWorld -> (Either IOError13 (), _State _RealWorld)
{-# GHC_PRAGMA _A_ 1 _U_ 121 _N_ _N_ _N_ _N_ #-}
putChar :: Char -> _State _RealWorld -> (Either IOError13 (), _State _RealWorld)
- {-# GHC_PRAGMA _A_ 2 _U_ 11 _N_ _N_ _F_ _IF_ARGS_ 0 0 X 2 _APP_ _ORIG_ PreludeWriteTextIO hPutChar [ _ORIG_ PreludeStdIO stdout13 ] _N_ #-}
+ {-# GHC_PRAGMA _A_ 2 _U_ 11 _N_ _N_ _F_ _IF_ARGS_ 0 2 XC 6 \ (u0 :: Char) (u1 :: _State _RealWorld) -> case _ORIG_ PreludeStdIO stdout13 of { _ALG_ _MVar (u2 :: SynchVar# _RealWorld _Handle) -> case u1 of { _ALG_ S# (u3 :: State# _RealWorld) -> _APP_ _WRKR_ _ORIG_ PreludeWriteTextIO hPutChar [ u2, u0, u3 ]; _NO_DEFLT_ }; _NO_DEFLT_ } _N_ #-}
putStr :: [Char] -> _State _RealWorld -> (Either IOError13 (), _State _RealWorld)
- {-# GHC_PRAGMA _A_ 2 _U_ 21 _N_ _N_ _F_ _IF_ARGS_ 0 0 X 2 _APP_ _ORIG_ PreludeWriteTextIO hPutStr [ _ORIG_ PreludeStdIO stdout13 ] _N_ #-}
+ {-# GHC_PRAGMA _A_ 2 _U_ 21 _N_ _N_ _F_ _IF_ARGS_ 0 2 XC 6 \ (u0 :: [Char]) (u1 :: _State _RealWorld) -> case _ORIG_ PreludeStdIO stdout13 of { _ALG_ _MVar (u2 :: SynchVar# _RealWorld _Handle) -> case u1 of { _ALG_ S# (u3 :: State# _RealWorld) -> _APP_ _WRKR_ _ORIG_ PreludeWriteTextIO hPutStr [ u2, u0, u3 ]; _NO_DEFLT_ }; _NO_DEFLT_ } _N_ #-}
putText :: Text a => a -> _State _RealWorld -> (Either IOError13 (), _State _RealWorld)
{-# GHC_PRAGMA _A_ 1 _U_ 121 _N_ _N_ _F_ _IF_ARGS_ 1 1 X 3 _/\_ u0 -> \ (u1 :: {{Text u0}}) -> _APP_ _TYAPP_ _ORIG_ PreludeWriteTextIO hPutText { u0 } [ u1, _ORIG_ PreludeStdIO stdout13 ] _N_ #-}
writeFile13 :: [Char] -> [Char] -> _State _RealWorld -> (Either IOError13 (), _State _RealWorld)
-{-# GHC_PRAGMA INTERFACE VERSION 5 #-}
+{-# GHC_PRAGMA INTERFACE VERSION 6 #-}
interface PreludeWriteTextIO where
import PreludeBuiltin(Char(..), List(..), Tuple0, Tuple2, _RealWorld(..), _State(..))
import PreludeCore(Text(..))
print13 :: Text a => a -> _State _RealWorld -> (Either IOError13 (), _State _RealWorld)
{-# GHC_PRAGMA _A_ 1 _U_ 121 _N_ _N_ _N_ _N_ #-}
putChar :: Char -> _State _RealWorld -> (Either IOError13 (), _State _RealWorld)
- {-# GHC_PRAGMA _A_ 2 _U_ 11 _N_ _N_ _F_ _IF_ARGS_ 0 0 X 2 _APP_ _ORIG_ PreludeWriteTextIO hPutChar [ _ORIG_ PreludeStdIO stdout13 ] _N_ #-}
+ {-# GHC_PRAGMA _A_ 2 _U_ 11 _N_ _N_ _F_ _IF_ARGS_ 0 2 XC 6 \ (u0 :: Char) (u1 :: _State _RealWorld) -> case _ORIG_ PreludeStdIO stdout13 of { _ALG_ _MVar (u2 :: SynchVar# _RealWorld _Handle) -> case u1 of { _ALG_ S# (u3 :: State# _RealWorld) -> _APP_ _WRKR_ _ORIG_ PreludeWriteTextIO hPutChar [ u2, u0, u3 ]; _NO_DEFLT_ }; _NO_DEFLT_ } _N_ #-}
putStr :: [Char] -> _State _RealWorld -> (Either IOError13 (), _State _RealWorld)
- {-# GHC_PRAGMA _A_ 2 _U_ 21 _N_ _N_ _F_ _IF_ARGS_ 0 0 X 2 _APP_ _ORIG_ PreludeWriteTextIO hPutStr [ _ORIG_ PreludeStdIO stdout13 ] _N_ #-}
+ {-# GHC_PRAGMA _A_ 2 _U_ 21 _N_ _N_ _F_ _IF_ARGS_ 0 2 XC 6 \ (u0 :: [Char]) (u1 :: _State _RealWorld) -> case _ORIG_ PreludeStdIO stdout13 of { _ALG_ _MVar (u2 :: SynchVar# _RealWorld _Handle) -> case u1 of { _ALG_ S# (u3 :: State# _RealWorld) -> _APP_ _WRKR_ _ORIG_ PreludeWriteTextIO hPutStr [ u2, u0, u3 ]; _NO_DEFLT_ }; _NO_DEFLT_ } _N_ #-}
putText :: Text a => a -> _State _RealWorld -> (Either IOError13 (), _State _RealWorld)
{-# GHC_PRAGMA _A_ 1 _U_ 121 _N_ _N_ _F_ _IF_ARGS_ 1 1 X 3 _/\_ u0 -> \ (u1 :: {{Text u0}}) -> _APP_ _TYAPP_ _ORIG_ PreludeWriteTextIO hPutText { u0 } [ u1, _ORIG_ PreludeStdIO stdout13 ] _N_ #-}
writeFile13 :: [Char] -> [Char] -> _State _RealWorld -> (Either IOError13 (), _State _RealWorld)
-{-# GHC_PRAGMA INTERFACE VERSION 5 #-}
+{-# GHC_PRAGMA INTERFACE VERSION 6 #-}
interface PreludeWriteTextIO where
import PreludeBuiltin(Char(..), List(..), Tuple0, Tuple2, _RealWorld(..), _State(..))
import PreludeCore(Text(..))
print13 :: Text a => a -> _State _RealWorld -> (Either IOError13 (), _State _RealWorld)
{-# GHC_PRAGMA _A_ 1 _U_ 121 _N_ _N_ _N_ _N_ #-}
putChar :: Char -> _State _RealWorld -> (Either IOError13 (), _State _RealWorld)
- {-# GHC_PRAGMA _A_ 2 _U_ 11 _N_ _N_ _F_ _IF_ARGS_ 0 0 X 2 _APP_ _ORIG_ PreludeWriteTextIO hPutChar [ _ORIG_ PreludeStdIO stdout13 ] _N_ #-}
+ {-# GHC_PRAGMA _A_ 2 _U_ 11 _N_ _N_ _F_ _IF_ARGS_ 0 2 XC 6 \ (u0 :: Char) (u1 :: _State _RealWorld) -> case _ORIG_ PreludeStdIO stdout13 of { _ALG_ _MVar (u2 :: SynchVar# _RealWorld _Handle) -> case u1 of { _ALG_ S# (u3 :: State# _RealWorld) -> _APP_ _WRKR_ _ORIG_ PreludeWriteTextIO hPutChar [ u2, u0, u3 ]; _NO_DEFLT_ }; _NO_DEFLT_ } _N_ #-}
putStr :: [Char] -> _State _RealWorld -> (Either IOError13 (), _State _RealWorld)
- {-# GHC_PRAGMA _A_ 2 _U_ 21 _N_ _N_ _F_ _IF_ARGS_ 0 0 X 2 _APP_ _ORIG_ PreludeWriteTextIO hPutStr [ _ORIG_ PreludeStdIO stdout13 ] _N_ #-}
+ {-# GHC_PRAGMA _A_ 2 _U_ 21 _N_ _N_ _F_ _IF_ARGS_ 0 2 XC 6 \ (u0 :: [Char]) (u1 :: _State _RealWorld) -> case _ORIG_ PreludeStdIO stdout13 of { _ALG_ _MVar (u2 :: SynchVar# _RealWorld _Handle) -> case u1 of { _ALG_ S# (u3 :: State# _RealWorld) -> _APP_ _WRKR_ _ORIG_ PreludeWriteTextIO hPutStr [ u2, u0, u3 ]; _NO_DEFLT_ }; _NO_DEFLT_ } _N_ #-}
putText :: Text a => a -> _State _RealWorld -> (Either IOError13 (), _State _RealWorld)
{-# GHC_PRAGMA _A_ 1 _U_ 121 _N_ _N_ _F_ _IF_ARGS_ 1 1 X 3 _/\_ u0 -> \ (u1 :: {{Text u0}}) -> _APP_ _TYAPP_ _ORIG_ PreludeWriteTextIO hPutText { u0 } [ u1, _ORIG_ PreludeStdIO stdout13 ] _N_ #-}
writeFile13 :: [Char] -> [Char] -> _State _RealWorld -> (Either IOError13 (), _State _RealWorld)
-{-# GHC_PRAGMA INTERFACE VERSION 5 #-}
+{-# GHC_PRAGMA INTERFACE VERSION 6 #-}
interface PreludeWriteTextIO where
import PreludeBuiltin(Char(..), List(..), Tuple0, Tuple2, _RealWorld(..), _State(..))
import PreludeCore(Text(..))
print13 :: Text a => a -> _State _RealWorld -> (Either IOError13 (), _State _RealWorld)
{-# GHC_PRAGMA _A_ 1 _U_ 121 _N_ _N_ _N_ _N_ #-}
putChar :: Char -> _State _RealWorld -> (Either IOError13 (), _State _RealWorld)
- {-# GHC_PRAGMA _A_ 2 _U_ 11 _N_ _N_ _F_ _IF_ARGS_ 0 0 X 2 _APP_ _ORIG_ PreludeWriteTextIO hPutChar [ _ORIG_ PreludeStdIO stdout13 ] _N_ #-}
+ {-# GHC_PRAGMA _A_ 2 _U_ 11 _N_ _N_ _F_ _IF_ARGS_ 0 2 XC 6 \ (u0 :: Char) (u1 :: _State _RealWorld) -> case _ORIG_ PreludeStdIO stdout13 of { _ALG_ _MVar (u2 :: SynchVar# _RealWorld _Handle) -> case u1 of { _ALG_ S# (u3 :: State# _RealWorld) -> _APP_ _WRKR_ _ORIG_ PreludeWriteTextIO hPutChar [ u2, u0, u3 ]; _NO_DEFLT_ }; _NO_DEFLT_ } _N_ #-}
putStr :: [Char] -> _State _RealWorld -> (Either IOError13 (), _State _RealWorld)
- {-# GHC_PRAGMA _A_ 2 _U_ 21 _N_ _N_ _F_ _IF_ARGS_ 0 0 X 2 _APP_ _ORIG_ PreludeWriteTextIO hPutStr [ _ORIG_ PreludeStdIO stdout13 ] _N_ #-}
+ {-# GHC_PRAGMA _A_ 2 _U_ 21 _N_ _N_ _F_ _IF_ARGS_ 0 2 XC 6 \ (u0 :: [Char]) (u1 :: _State _RealWorld) -> case _ORIG_ PreludeStdIO stdout13 of { _ALG_ _MVar (u2 :: SynchVar# _RealWorld _Handle) -> case u1 of { _ALG_ S# (u3 :: State# _RealWorld) -> _APP_ _WRKR_ _ORIG_ PreludeWriteTextIO hPutStr [ u2, u0, u3 ]; _NO_DEFLT_ }; _NO_DEFLT_ } _N_ #-}
putText :: Text a => a -> _State _RealWorld -> (Either IOError13 (), _State _RealWorld)
{-# GHC_PRAGMA _A_ 1 _U_ 121 _N_ _N_ _F_ _IF_ARGS_ 1 1 X 3 _/\_ u0 -> \ (u1 :: {{Text u0}}) -> _APP_ _TYAPP_ _ORIG_ PreludeWriteTextIO hPutText { u0 } [ u1, _ORIG_ PreludeStdIO stdout13 ] _N_ #-}
writeFile13 :: [Char] -> [Char] -> _State _RealWorld -> (Either IOError13 (), _State _RealWorld)
-{-# GHC_PRAGMA INTERFACE VERSION 5 #-}
+{-# GHC_PRAGMA INTERFACE VERSION 6 #-}
interface Prelude where
import PreludeArray((!), (//), Array, Assoc, _ByteArray, accum, accumArray, amap, array, assocs, bounds, elems, indices, ixmap, listArray)
import PreludeBuiltin(Bin, Char(..), Int(..), Integer(..), List(..), Tuple0, Tuple2, Tuple3, Tuple4, Tuple5, Tuple6, Tuple7, _Addr(..), _RealWorld(..), _State(..))
import PreludeComplex(Complex, cis, conjugate, imagPart, magnitude, mkPolar, phase, polar, realPart)
-import PreludeCore(Bool(..), Eq(..), Fractional(..), Integral(..), Ix(..), Num(..), Ord(..), Real(..), RealFloat(..), RealFrac(..), Text(..), _ceiling, _floor, _readList, _round, _showList, _showRational, _truncate)
+import PreludeCore(Bool(..), Eq(..), Fractional(..), Integral(..), Ix(..), Num(..), Ord(..), Real(..), RealFloat(..), RealFrac(..), Text(..), _readList, _showList, _showRational)
import PreludeIO(IOError, Request, Response, SigAct, abort, appendBinChan, appendBinFile, appendChan, appendFile, binDispatch, deleteFile, done, echo, exit, getArgs, getEnv, getProgName, interact, print, prints, readBinChan, readBinFile, readChan, readFile, setEnv, sigAction, statusChan, statusFile, stdecho, stderr, stdin, stdout, strDispatch, strListDispatch, succDispatch, writeBinFile, writeFile)
import PreludeList((!!), (++), (\\), all, and, any, break, concat, cycle, drop, dropWhile, elem, filter, foldl1, foldr1, genericLength, head, init, iterate, last, length, lines, map, maximum, minimum, notElem, nub, null, or, partition, product, products, repeat, reverse, scanl, scanl1, scanr, scanr1, span, splitAt, sum, sums, tail, take, takeWhile, transpose, unlines, unwords, unzip, unzip3, unzip4, unzip5, unzip6, unzip7, words, zip, zip3, zip4, zip5, zip6, zip7, zipWith, zipWith3, zipWith4, zipWith5, zipWith6, zipWith7)
import PreludePS(_PackedString, _appendPS, _breakPS, _byteArrayToPS, _concatPS, _consPS, _dropPS, _dropWhilePS, _filterPS, _foldlPS, _foldrPS, _headPS, _indexPS, _lengthPS, _linesPS, _mapPS, _nilPS, _nullPS, _packCBytes, _packCString, _packString, _psToByteArray, _putPS, _reversePS, _spanPS, _splitAtPS, _substrPS, _tailPS, _takePS, _takeWhilePS, _unpackPS, _wordsPS)
(.) :: (a -> c) -> (b -> a) -> b -> c
{-# GHC_PRAGMA _A_ 3 _U_ 112 _N_ _S_ "SLL" _F_ _ALWAYS_ _/\_ u0 u1 u2 -> \ (u3 :: u0 -> u2) (u4 :: u1 -> u0) (u5 :: u1) -> let {(u6 :: u0) = _APP_ u4 [ u5 ]} in _APP_ u3 [ u6 ] _N_ #-}
(^) :: (Num b, Integral a) => b -> a -> b
- {-# GHC_PRAGMA _A_ 2 _U_ 2122 _N_ _S_ "LU(U(LU(U(U(SA)AALAAAA)AAAA)A)AAALAAAALAA)" {_A_ 5 _U_ 2212222 _N_ _N_ _N_ _N_} _N_ _SPECIALISE_ [ Int, Double ] 2 { _A_ 2 _U_ 21 _N_ _S_ "LU(P)" {_A_ 2 _U_ 22 _N_ _N_ _N_ _N_} _N_ _N_ }, [ Int, Int ] 2 { _A_ 2 _U_ 21 _N_ _S_ "LU(P)" {_A_ 2 _U_ 22 _N_ _N_ _N_ _N_} _N_ _N_ }, [ Int, Integer ] 2 { _A_ 2 _U_ 21 _N_ _S_ "LU(P)" {_A_ 2 _U_ 22 _N_ _N_ _N_ _N_} _N_ _N_ }, [ Int, (Ratio Integer) ] 2 { _A_ 2 _U_ 21 _N_ _S_ "LU(P)" {_A_ 2 _U_ 22 _N_ _N_ _N_ _N_} _N_ _N_ }, [ Int, (Complex Double) ] 2 { _A_ 2 _U_ 21 _N_ _S_ "LU(P)" {_A_ 2 _U_ 22 _N_ _N_ _N_ _N_} _N_ _N_ } #-}
+ {-# GHC_PRAGMA _A_ 2 _U_ 2122 _N_ _S_ "LU(U(LU(U(U(SL)LLLLLLL)LLLL)L)LLLLLLLLLLL)" _N_ _SPECIALISE_ [ Int, Double ] 2 { _A_ 2 _U_ 21 _N_ _S_ "LU(P)" {_A_ 2 _U_ 22 _N_ _N_ _N_ _N_} _N_ _N_ }, [ Int, Int ] 2 { _A_ 2 _U_ 21 _N_ _S_ "LU(P)" {_A_ 2 _U_ 22 _N_ _N_ _N_ _N_} _N_ _N_ }, [ Int, Integer ] 2 { _A_ 2 _U_ 21 _N_ _S_ "LU(P)" {_A_ 2 _U_ 22 _N_ _N_ _N_ _N_} _N_ _N_ }, [ Int, (Ratio Integer) ] 2 { _A_ 2 _U_ 21 _N_ _S_ "LU(P)" {_A_ 2 _U_ 22 _N_ _N_ _N_ _N_} _N_ _N_ }, [ Int, (Complex Double) ] 2 { _A_ 2 _U_ 21 _N_ _S_ "LU(P)" {_A_ 2 _U_ 22 _N_ _N_ _N_ _N_} _N_ _N_ }, [ Integer, Integer ] 2 { _A_ 2 _U_ 21 _N_ _S_ "LU(PPP)" {_A_ 4 _U_ 2222 _N_ _N_ _N_ _N_} _N_ _N_ } #-}
(^^) :: (Fractional b, Integral a) => b -> a -> b
- {-# GHC_PRAGMA _A_ 2 _U_ 2122 _N_ _S_ "LU(LU(U(AAASAAAA)AAA)AALAAAALAA)" {_A_ 5 _U_ 2212222 _N_ _N_ _N_ _N_} _N_ _SPECIALISE_ [ Int, Double ] 2 { _A_ 2 _U_ 21 _N_ _S_ "LU(P)" {_A_ 2 _U_ 22 _N_ _N_ _N_ _N_} _N_ _N_ }, [ Int, (Ratio Integer) ] 2 { _A_ 2 _U_ 21 _N_ _S_ "LU(P)" {_A_ 2 _U_ 22 _N_ _N_ _N_ _N_} _N_ _N_ } #-}
+ {-# GHC_PRAGMA _A_ 2 _U_ 2222 _N_ _S_ "LU(LU(U(LLLSLLLL)LLL)LLLLLLLLLL)" _N_ _SPECIALISE_ [ Int, Double ] 2 { _A_ 2 _U_ 21 _N_ _S_ "LU(P)" {_A_ 2 _U_ 22 _N_ _N_ _N_ _N_} _N_ _N_ }, [ Int, (Ratio Integer) ] 2 { _A_ 2 _U_ 21 _N_ _S_ "LU(P)" {_A_ 2 _U_ 22 _N_ _N_ _N_ _N_} _N_ _N_ }, [ Int, (Complex Double) ] 2 { _A_ 2 _U_ 21 _N_ _S_ "LU(P)" {_A_ 2 _U_ 22 _N_ _N_ _N_ _N_} _N_ _N_ } #-}
appendBin :: Bin -> Bin -> Bin
- {-# GHC_PRAGMA _A_ 2 _U_ 22 _N_ _S_ _!_ _F_ _IF_ARGS_ 0 2 XX 4 \ (u0 :: Bin) (u1 :: Bin) -> _APP_ _TYAPP_ error { (Bin -> Bin -> Bin) } [ _NOREP_S_ "appendBin{Prelude}\n", u0, u1 ] _N_ #-}
+ {-# GHC_PRAGMA _A_ 2 _U_ 22 _N_ _S_ _!_ _N_ _N_ #-}
asTypeOf :: a -> a -> a
{-# GHC_PRAGMA _A_ 2 _U_ 10 _N_ _N_ _F_ _IF_ARGS_ 1 0 X 1 _/\_ u0 -> _TYAPP_ _TYAPP_ _ORIG_ Prelude const { u0 } { u0 } _N_ #-}
atan2 :: RealFloat a => a -> a -> a
flip :: (b -> a -> c) -> a -> b -> c
{-# GHC_PRAGMA _A_ 3 _U_ 122 _N_ _S_ "SLL" _F_ _IF_ARGS_ 3 3 XXX 3 _/\_ u0 u1 u2 -> \ (u3 :: u1 -> u0 -> u2) (u4 :: u0) (u5 :: u1) -> _APP_ u3 [ u5, u4 ] _N_ #-}
fromIntegral :: (Integral a, Num b) => a -> b
- {-# GHC_PRAGMA _A_ 3 _U_ 112 _N_ _S_ "LU(AAAAAAAASA)L" {_A_ 3 _U_ 112 _N_ _N_ _F_ _IF_ARGS_ 2 3 CXX 6 _/\_ u0 u1 -> \ (u2 :: {{Integral u0}}) (u3 :: Integer -> u1) (u4 :: u0) -> let {(uh :: Integer) = case u2 of { _ALG_ _TUP_12 (u5 :: {{Real u0}}) (u6 :: {{Ix u0}}) (u7 :: u0 -> u0 -> u0) (u8 :: u0 -> u0 -> u0) (u9 :: u0 -> u0 -> u0) (ua :: u0 -> u0 -> u0) (ub :: u0 -> u0 -> (u0, u0)) (uc :: u0 -> u0 -> (u0, u0)) (ud :: u0 -> Bool) (ue :: u0 -> Bool) (uf :: u0 -> Integer) (ug :: u0 -> Int) -> _APP_ uf [ u4 ]; _NO_DEFLT_ }} in _APP_ u3 [ uh ] _N_} _F_ _IF_ARGS_ 2 3 CCX 7 _/\_ u0 u1 -> \ (u2 :: {{Integral u0}}) (u3 :: {{Num u1}}) (u4 :: u0) -> let {(uh :: Integer) = case u2 of { _ALG_ _TUP_12 (u5 :: {{Real u0}}) (u6 :: {{Ix u0}}) (u7 :: u0 -> u0 -> u0) (u8 :: u0 -> u0 -> u0) (u9 :: u0 -> u0 -> u0) (ua :: u0 -> u0 -> u0) (ub :: u0 -> u0 -> (u0, u0)) (uc :: u0 -> u0 -> (u0, u0)) (ud :: u0 -> Bool) (ue :: u0 -> Bool) (uf :: u0 -> Integer) (ug :: u0 -> Int) -> _APP_ uf [ u4 ]; _NO_DEFLT_ }} in case u3 of { _ALG_ _TUP_10 (ui :: {{Eq u1}}) (uj :: {{Text u1}}) (uk :: u1 -> u1 -> u1) (ul :: u1 -> u1 -> u1) (um :: u1 -> u1 -> u1) (un :: u1 -> u1) (uo :: u1 -> u1) (up :: u1 -> u1) (uq :: Integer -> u1) (ur :: Int -> u1) -> _APP_ uq [ uh ]; _NO_DEFLT_ } _SPECIALISE_ [ Int, Double ] 2 { _A_ 1 _U_ 1 _N_ _S_ "U(P)" {_A_ 1 _U_ 2 _N_ _N_ _F_ _IF_ARGS_ 0 1 X 3 \ (u0 :: Int#) -> case _#_ int2Double# [] [u0] of { _PRIM_ (u1 :: Double#) -> _!_ D# [] [u1] } _N_} _F_ _IF_ARGS_ 0 1 C 4 \ (u0 :: Int) -> case u0 of { _ALG_ I# (u1 :: Int#) -> case _#_ int2Double# [] [u1] of { _PRIM_ (u2 :: Double#) -> _!_ D# [] [u2] }; _NO_DEFLT_ } _N_ }, [ Int, Int ] 2 { _A_ 1 _U_ 1 _N_ _N_ _F_ _IF_ARGS_ 0 0 X 1 _TYAPP_ _ORIG_ Prelude id { Int } _N_ }, [ Int, Integer ] 2 { _A_ 1 _U_ 1 _N_ _S_ "U(P)" {_A_ 1 _U_ 2 _N_ _N_ _F_ _IF_ARGS_ 0 1 X 1 \ (u0 :: Int#) -> _#_ int2Integer# [] [u0] _N_} _F_ _IF_ARGS_ 0 1 C 2 \ (u0 :: Int) -> case u0 of { _ALG_ I# (u1 :: Int#) -> _#_ int2Integer# [] [u1]; _NO_DEFLT_ } _N_ }, [ Integer, Double ] 2 { _A_ 1 _U_ 1 _N_ _S_ "U(PPP)" {_A_ 3 _U_ 222 _N_ _N_ _F_ _IF_ARGS_ 0 3 XXX 3 \ (u0 :: Int#) (u1 :: Int#) (u2 :: ByteArray#) -> case _#_ encodeDouble# [] [u0, u1, u2, 0#] of { _PRIM_ (u3 :: Double#) -> _!_ D# [] [u3] } _N_} _F_ _IF_ARGS_ 0 1 C 4 \ (u0 :: Integer) -> case u0 of { _ALG_ J# (u1 :: Int#) (u2 :: Int#) (u3 :: ByteArray#) -> case _#_ encodeDouble# [] [u1, u2, u3, 0#] of { _PRIM_ (u4 :: Double#) -> _!_ D# [] [u4] }; _NO_DEFLT_ } _N_ }, [ Integer, Int ] 2 { _A_ 1 _U_ 1 _N_ _S_ "U(PPP)" {_A_ 3 _U_ 222 _N_ _N_ _F_ _IF_ARGS_ 0 3 XXX 3 \ (u0 :: Int#) (u1 :: Int#) (u2 :: ByteArray#) -> case _#_ integer2Int# [] [u0, u1, u2] of { _PRIM_ (u3 :: Int#) -> _!_ I# [] [u3] } _N_} _F_ _IF_ARGS_ 0 1 C 4 \ (u0 :: Integer) -> case u0 of { _ALG_ J# (u1 :: Int#) (u2 :: Int#) (u3 :: ByteArray#) -> case _#_ integer2Int# [] [u1, u2, u3] of { _PRIM_ (u4 :: Int#) -> _!_ I# [] [u4] }; _NO_DEFLT_ } _N_ }, [ Integer, Integer ] 2 { _A_ 1 _U_ 1 _N_ _N_ _F_ _IF_ARGS_ 0 0 X 1 _TYAPP_ _ORIG_ Prelude id { Integer } _N_ } #-}
+ {-# GHC_PRAGMA _A_ 3 _U_ 112 _N_ _S_ "LU(AAAAAAAASA)L" {_A_ 3 _U_ 112 _N_ _N_ _F_ _IF_ARGS_ 2 3 CXX 6 _/\_ u0 u1 -> \ (u2 :: {{Integral u0}}) (u3 :: Integer -> u1) (u4 :: u0) -> let {(uh :: Integer) = case u2 of { _ALG_ _TUP_12 (u5 :: {{Real u0}}) (u6 :: {{Ix u0}}) (u7 :: u0 -> u0 -> u0) (u8 :: u0 -> u0 -> u0) (u9 :: u0 -> u0 -> u0) (ua :: u0 -> u0 -> u0) (ub :: u0 -> u0 -> (u0, u0)) (uc :: u0 -> u0 -> (u0, u0)) (ud :: u0 -> Bool) (ue :: u0 -> Bool) (uf :: u0 -> Integer) (ug :: u0 -> Int) -> _APP_ uf [ u4 ]; _NO_DEFLT_ }} in _APP_ u3 [ uh ] _N_} _F_ _IF_ARGS_ 2 3 CCX 7 _/\_ u0 u1 -> \ (u2 :: {{Integral u0}}) (u3 :: {{Num u1}}) (u4 :: u0) -> let {(uh :: Integer) = case u2 of { _ALG_ _TUP_12 (u5 :: {{Real u0}}) (u6 :: {{Ix u0}}) (u7 :: u0 -> u0 -> u0) (u8 :: u0 -> u0 -> u0) (u9 :: u0 -> u0 -> u0) (ua :: u0 -> u0 -> u0) (ub :: u0 -> u0 -> (u0, u0)) (uc :: u0 -> u0 -> (u0, u0)) (ud :: u0 -> Bool) (ue :: u0 -> Bool) (uf :: u0 -> Integer) (ug :: u0 -> Int) -> _APP_ uf [ u4 ]; _NO_DEFLT_ }} in case u3 of { _ALG_ _TUP_10 (ui :: {{Eq u1}}) (uj :: {{Text u1}}) (uk :: u1 -> u1 -> u1) (ul :: u1 -> u1 -> u1) (um :: u1 -> u1 -> u1) (un :: u1 -> u1) (uo :: u1 -> u1) (up :: u1 -> u1) (uq :: Integer -> u1) (ur :: Int -> u1) -> _APP_ uq [ uh ]; _NO_DEFLT_ } _SPECIALISE_ [ Int, Double ] 2 { _A_ 1 _U_ 1 _N_ _S_ "U(P)" {_A_ 1 _U_ 2 _N_ _N_ _F_ _IF_ARGS_ 0 1 X 3 \ (u0 :: Int#) -> case _#_ int2Double# [] [u0] of { _PRIM_ (u1 :: Double#) -> _!_ D# [] [u1] } _N_} _F_ _IF_ARGS_ 0 1 C 4 \ (u0 :: Int) -> case u0 of { _ALG_ I# (u1 :: Int#) -> case _#_ int2Double# [] [u1] of { _PRIM_ (u2 :: Double#) -> _!_ D# [] [u2] }; _NO_DEFLT_ } _N_ }, [ Int, Float ] 2 { _A_ 1 _U_ 1 _N_ _S_ "U(P)" {_A_ 1 _U_ 2 _N_ _N_ _F_ _IF_ARGS_ 0 1 X 3 \ (u0 :: Int#) -> case _#_ int2Float# [] [u0] of { _PRIM_ (u1 :: Float#) -> _!_ F# [] [u1] } _N_} _F_ _IF_ARGS_ 0 1 C 4 \ (u0 :: Int) -> case u0 of { _ALG_ I# (u1 :: Int#) -> case _#_ int2Float# [] [u1] of { _PRIM_ (u2 :: Float#) -> _!_ F# [] [u2] }; _NO_DEFLT_ } _N_ }, [ Int, Int ] 2 { _A_ 1 _U_ 1 _N_ _N_ _F_ _IF_ARGS_ 0 0 X 1 _TYAPP_ _ORIG_ Prelude id { Int } _N_ }, [ Int, Integer ] 2 { _A_ 1 _U_ 1 _N_ _S_ "U(P)" {_A_ 1 _U_ 2 _N_ _N_ _F_ _IF_ARGS_ 0 1 X 1 \ (u0 :: Int#) -> _#_ int2Integer# [] [u0] _N_} _F_ _IF_ARGS_ 0 1 C 2 \ (u0 :: Int) -> case u0 of { _ALG_ I# (u1 :: Int#) -> _#_ int2Integer# [] [u1]; _NO_DEFLT_ } _N_ }, [ Int, (Ratio Integer) ] 2 { _A_ 1 _U_ 1 _N_ _N_ _N_ _N_ }, [ Integer, Double ] 2 { _A_ 1 _U_ 1 _N_ _S_ "U(PPP)" {_A_ 3 _U_ 222 _N_ _N_ _F_ _IF_ARGS_ 0 3 XXX 3 \ (u0 :: Int#) (u1 :: Int#) (u2 :: ByteArray#) -> case _#_ encodeDouble# [] [u0, u1, u2, 0#] of { _PRIM_ (u3 :: Double#) -> _!_ D# [] [u3] } _N_} _F_ _IF_ARGS_ 0 1 C 4 \ (u0 :: Integer) -> case u0 of { _ALG_ J# (u1 :: Int#) (u2 :: Int#) (u3 :: ByteArray#) -> case _#_ encodeDouble# [] [u1, u2, u3, 0#] of { _PRIM_ (u4 :: Double#) -> _!_ D# [] [u4] }; _NO_DEFLT_ } _N_ }, [ Integer, Float ] 2 { _A_ 1 _U_ 1 _N_ _S_ "U(PPP)" {_A_ 3 _U_ 222 _N_ _N_ _F_ _IF_ARGS_ 0 3 XXX 3 \ (u0 :: Int#) (u1 :: Int#) (u2 :: ByteArray#) -> case _#_ encodeFloat# [] [u0, u1, u2, 0#] of { _PRIM_ (u3 :: Float#) -> _!_ F# [] [u3] } _N_} _F_ _IF_ARGS_ 0 1 C 4 \ (u0 :: Integer) -> case u0 of { _ALG_ J# (u1 :: Int#) (u2 :: Int#) (u3 :: ByteArray#) -> case _#_ encodeFloat# [] [u1, u2, u3, 0#] of { _PRIM_ (u4 :: Float#) -> _!_ F# [] [u4] }; _NO_DEFLT_ } _N_ }, [ Integer, Int ] 2 { _A_ 1 _U_ 1 _N_ _S_ "U(PPP)" {_A_ 3 _U_ 222 _N_ _N_ _F_ _IF_ARGS_ 0 3 XXX 3 \ (u0 :: Int#) (u1 :: Int#) (u2 :: ByteArray#) -> case _#_ integer2Int# [] [u0, u1, u2] of { _PRIM_ (u3 :: Int#) -> _!_ I# [] [u3] } _N_} _F_ _IF_ARGS_ 0 1 C 4 \ (u0 :: Integer) -> case u0 of { _ALG_ J# (u1 :: Int#) (u2 :: Int#) (u3 :: ByteArray#) -> case _#_ integer2Int# [] [u1, u2, u3] of { _PRIM_ (u4 :: Int#) -> _!_ I# [] [u4] }; _NO_DEFLT_ } _N_ }, [ Integer, Integer ] 2 { _A_ 1 _U_ 1 _N_ _N_ _F_ _IF_ARGS_ 0 0 X 1 _TYAPP_ _ORIG_ Prelude id { Integer } _N_ }, [ Integer, (Ratio Integer) ] 2 { _A_ 1 _U_ 2 _N_ _N_ _F_ _IF_ARGS_ 0 1 X 3 \ (u0 :: Integer) -> _!_ (:%) [Integer] [u0, _SPEC_ _ORIG_ PreludeCore __i1 [ (Integer) ]] _N_ } #-}
fromRealFrac :: (RealFrac a, Fractional b) => a -> b
- {-# GHC_PRAGMA _A_ 3 _U_ 112 _N_ _S_ "LU(AAAS)L" {_A_ 3 _U_ 112 _N_ _N_ _F_ _IF_ARGS_ 2 3 CXX 7 _/\_ u0 u1 -> \ (u2 :: {{RealFrac u0}}) (u3 :: Ratio Integer -> u1) (u4 :: u0) -> let {(uf :: Ratio Integer) = case u2 of { _ALG_ _TUP_7 (u5 :: {{Real u0}}) (u6 :: {{Fractional u0}}) (u7 :: _forall_ a$z1 =>{{Integral a$z1}} -> u0 -> (a$z1, u0)) (u8 :: _forall_ a$z1 =>{{Integral a$z1}} -> u0 -> a$z1) (u9 :: _forall_ a$z1 =>{{Integral a$z1}} -> u0 -> a$z1) (ua :: _forall_ a$z1 =>{{Integral a$z1}} -> u0 -> a$z1) (ub :: _forall_ a$z1 =>{{Integral a$z1}} -> u0 -> a$z1) -> case u5 of { _ALG_ _TUP_3 (uc :: {{Num u0}}) (ud :: {{Enum u0}}) (ue :: u0 -> Ratio Integer) -> _APP_ ue [ u4 ]; _NO_DEFLT_ }; _NO_DEFLT_ }} in _APP_ u3 [ uf ] _N_} _F_ _IF_ARGS_ 2 3 CCX 8 _/\_ u0 u1 -> \ (u2 :: {{RealFrac u0}}) (u3 :: {{Fractional u1}}) (u4 :: u0) -> let {(uf :: Ratio Integer) = case u2 of { _ALG_ _TUP_7 (u5 :: {{Real u0}}) (u6 :: {{Fractional u0}}) (u7 :: _forall_ a$z1 =>{{Integral a$z1}} -> u0 -> (a$z1, u0)) (u8 :: _forall_ a$z1 =>{{Integral a$z1}} -> u0 -> a$z1) (u9 :: _forall_ a$z1 =>{{Integral a$z1}} -> u0 -> a$z1) (ua :: _forall_ a$z1 =>{{Integral a$z1}} -> u0 -> a$z1) (ub :: _forall_ a$z1 =>{{Integral a$z1}} -> u0 -> a$z1) -> case u5 of { _ALG_ _TUP_3 (uc :: {{Num u0}}) (ud :: {{Enum u0}}) (ue :: u0 -> Ratio Integer) -> _APP_ ue [ u4 ]; _NO_DEFLT_ }; _NO_DEFLT_ }} in case u3 of { _ALG_ _TUP_4 (ug :: {{Num u1}}) (uh :: u1 -> u1 -> u1) (ui :: u1 -> u1) (uj :: Ratio Integer -> u1) -> _APP_ uj [ uf ]; _NO_DEFLT_ } _SPECIALISE_ [ Double, Double ] 2 { _A_ 1 _U_ 1 _N_ _N_ _F_ _IF_ARGS_ 0 0 X 1 _TYAPP_ _ORIG_ Prelude id { Double } _N_ }, [ Double, Float ] 2 { _A_ 1 _U_ 1 _N_ _S_ "U(P)" {_A_ 1 _U_ 2 _N_ _N_ _F_ _IF_ARGS_ 0 1 X 3 \ (u0 :: Double#) -> case _#_ double2Float# [] [u0] of { _PRIM_ (u1 :: Float#) -> _!_ F# [] [u1] } _N_} _F_ _IF_ARGS_ 0 1 C 4 \ (u0 :: Double) -> case u0 of { _ALG_ D# (u1 :: Double#) -> case _#_ double2Float# [] [u1] of { _PRIM_ (u2 :: Float#) -> _!_ F# [] [u2] }; _NO_DEFLT_ } _N_ }, [ Float, Double ] 2 { _A_ 1 _U_ 1 _N_ _S_ "U(P)" {_A_ 1 _U_ 2 _N_ _N_ _F_ _IF_ARGS_ 0 1 X 3 \ (u0 :: Float#) -> case _#_ float2Double# [] [u0] of { _PRIM_ (u1 :: Double#) -> _!_ D# [] [u1] } _N_} _F_ _IF_ARGS_ 0 1 C 4 \ (u0 :: Float) -> case u0 of { _ALG_ F# (u1 :: Float#) -> case _#_ float2Double# [] [u1] of { _PRIM_ (u2 :: Double#) -> _!_ D# [] [u2] }; _NO_DEFLT_ } _N_ }, [ Float, Float ] 2 { _A_ 1 _U_ 1 _N_ _N_ _F_ _IF_ARGS_ 0 0 X 1 _TYAPP_ _ORIG_ Prelude id { Float } _N_ } #-}
+ {-# GHC_PRAGMA _A_ 3 _U_ 112 _N_ _S_ "LU(AAAS)L" {_A_ 3 _U_ 112 _N_ _N_ _F_ _IF_ARGS_ 2 3 CXX 7 _/\_ u0 u1 -> \ (u2 :: {{RealFrac u0}}) (u3 :: Ratio Integer -> u1) (u4 :: u0) -> let {(uf :: Ratio Integer) = case u2 of { _ALG_ _TUP_7 (u5 :: {{Real u0}}) (u6 :: {{Fractional u0}}) (u7 :: _forall_ a$z1 =>{{Integral a$z1}} -> u0 -> (a$z1, u0)) (u8 :: _forall_ a$z1 =>{{Integral a$z1}} -> u0 -> a$z1) (u9 :: _forall_ a$z1 =>{{Integral a$z1}} -> u0 -> a$z1) (ua :: _forall_ a$z1 =>{{Integral a$z1}} -> u0 -> a$z1) (ub :: _forall_ a$z1 =>{{Integral a$z1}} -> u0 -> a$z1) -> case u5 of { _ALG_ _TUP_3 (uc :: {{Num u0}}) (ud :: {{Enum u0}}) (ue :: u0 -> Ratio Integer) -> _APP_ ue [ u4 ]; _NO_DEFLT_ }; _NO_DEFLT_ }} in _APP_ u3 [ uf ] _N_} _F_ _IF_ARGS_ 2 3 CCX 8 _/\_ u0 u1 -> \ (u2 :: {{RealFrac u0}}) (u3 :: {{Fractional u1}}) (u4 :: u0) -> let {(uf :: Ratio Integer) = case u2 of { _ALG_ _TUP_7 (u5 :: {{Real u0}}) (u6 :: {{Fractional u0}}) (u7 :: _forall_ a$z1 =>{{Integral a$z1}} -> u0 -> (a$z1, u0)) (u8 :: _forall_ a$z1 =>{{Integral a$z1}} -> u0 -> a$z1) (u9 :: _forall_ a$z1 =>{{Integral a$z1}} -> u0 -> a$z1) (ua :: _forall_ a$z1 =>{{Integral a$z1}} -> u0 -> a$z1) (ub :: _forall_ a$z1 =>{{Integral a$z1}} -> u0 -> a$z1) -> case u5 of { _ALG_ _TUP_3 (uc :: {{Num u0}}) (ud :: {{Enum u0}}) (ue :: u0 -> Ratio Integer) -> _APP_ ue [ u4 ]; _NO_DEFLT_ }; _NO_DEFLT_ }} in case u3 of { _ALG_ _TUP_4 (ug :: {{Num u1}}) (uh :: u1 -> u1 -> u1) (ui :: u1 -> u1) (uj :: Ratio Integer -> u1) -> _APP_ uj [ uf ]; _NO_DEFLT_ } _SPECIALISE_ [ Double, Double ] 2 { _A_ 1 _U_ 1 _N_ _N_ _F_ _IF_ARGS_ 0 0 X 1 _TYAPP_ _ORIG_ Prelude id { Double } _N_ }, [ Double, Float ] 2 { _A_ 1 _U_ 1 _N_ _S_ "U(P)" {_A_ 1 _U_ 2 _N_ _N_ _F_ _IF_ARGS_ 0 1 X 3 \ (u0 :: Double#) -> case _#_ double2Float# [] [u0] of { _PRIM_ (u1 :: Float#) -> _!_ F# [] [u1] } _N_} _F_ _IF_ARGS_ 0 1 C 4 \ (u0 :: Double) -> case u0 of { _ALG_ D# (u1 :: Double#) -> case _#_ double2Float# [] [u1] of { _PRIM_ (u2 :: Float#) -> _!_ F# [] [u2] }; _NO_DEFLT_ } _N_ }, [ Double, (Ratio Integer) ] 2 { _A_ 1 _U_ 1 _N_ _S_ "U(P)" {_A_ 1 _U_ 2 _N_ _N_ _N_ _N_} _N_ _N_ }, [ Float, Double ] 2 { _A_ 1 _U_ 1 _N_ _S_ "U(P)" {_A_ 1 _U_ 2 _N_ _N_ _F_ _IF_ARGS_ 0 1 X 3 \ (u0 :: Float#) -> case _#_ float2Double# [] [u0] of { _PRIM_ (u1 :: Double#) -> _!_ D# [] [u1] } _N_} _F_ _IF_ARGS_ 0 1 C 4 \ (u0 :: Float) -> case u0 of { _ALG_ F# (u1 :: Float#) -> case _#_ float2Double# [] [u1] of { _PRIM_ (u2 :: Double#) -> _!_ D# [] [u2] }; _NO_DEFLT_ } _N_ }, [ Float, Float ] 2 { _A_ 1 _U_ 1 _N_ _N_ _F_ _IF_ARGS_ 0 0 X 1 _TYAPP_ _ORIG_ Prelude id { Float } _N_ }, [ Float, (Ratio Integer) ] 2 { _A_ 1 _U_ 1 _N_ _S_ "U(P)" {_A_ 1 _U_ 2 _N_ _N_ _N_ _N_} _N_ _N_ }, [ (Ratio Integer), Double ] 2 { _A_ 1 _U_ 1 _N_ _S_ "U(U(PPP)U(PPP))" {_A_ 4 _U_ 2222 _N_ _N_ _N_ _N_} _N_ _N_ }, [ (Ratio Integer), Float ] 2 { _A_ 1 _U_ 2 _N_ _N_ _F_ _IF_ARGS_ 0 0 X 1 _CONSTM_ Fractional fromRational (Float) _N_ }, [ (Ratio Integer), (Ratio Integer) ] 2 { _A_ 1 _U_ 1 _N_ _N_ _F_ _IF_ARGS_ 0 0 X 1 _TYAPP_ _ORIG_ Prelude id { (Ratio Integer) } _N_ } #-}
fst :: (b, a) -> b
{-# GHC_PRAGMA _A_ 1 _U_ 1 _N_ _S_ "U(SA)" {_A_ 1 _U_ 1 _N_ _N_ _F_ _IF_ARGS_ 2 1 X 1 _/\_ u0 u1 -> \ (u2 :: u1) -> u2 _N_} _F_ _IF_ARGS_ 2 1 C 2 _/\_ u0 u1 -> \ (u2 :: (u1, u0)) -> case u2 of { _ALG_ _TUP_2 (u3 :: u1) (u4 :: u0) -> u3; _NO_DEFLT_ } _N_ #-}
gcd :: Integral a => a -> a -> a
isLower :: Char -> Bool
{-# GHC_PRAGMA _A_ 1 _U_ 1 _N_ _S_ "U(P)" {_A_ 1 _U_ 2 _N_ _N_ _N_ _N_} _N_ _N_ #-}
isNullBin :: Bin -> Bool
- {-# GHC_PRAGMA _A_ 1 _U_ 2 _N_ _S_ _!_ _F_ _IF_ARGS_ 0 1 X 3 \ (u0 :: Bin) -> _APP_ _TYAPP_ error { (Bin -> Bool) } [ _NOREP_S_ "isNullBin{Prelude}\n", u0 ] _N_ #-}
+ {-# GHC_PRAGMA _A_ 1 _U_ 2 _N_ _S_ _!_ _N_ _N_ #-}
isPrint :: Char -> Bool
{-# GHC_PRAGMA _A_ 1 _U_ 1 _N_ _S_ "U(P)" {_A_ 1 _U_ 2 _N_ _N_ _N_ _N_} _N_ _N_ #-}
isSpace :: Char -> Bool
not :: Bool -> Bool
{-# GHC_PRAGMA _A_ 1 _U_ 1 _N_ _S_ "E" _F_ _ALWAYS_ \ (u0 :: Bool) -> case u0 of { _ALG_ True -> _!_ False [] []; False -> _!_ True [] []; _NO_DEFLT_ } _N_ #-}
nullBin :: Bin
- {-# GHC_PRAGMA _A_ 0 _N_ _N_ _S_ _!_ _F_ _IF_ARGS_ 0 0 X 2 _APP_ _TYAPP_ error { Bin } [ _NOREP_S_ "nullBin{Prelude}\n" ] _N_ #-}
+ {-# GHC_PRAGMA _A_ 0 _N_ _N_ _S_ _!_ _N_ _N_ #-}
ord :: Char -> Int
{-# GHC_PRAGMA _A_ 1 _U_ 1 _N_ _S_ "U(P)" {_A_ 1 _U_ 2 _N_ _N_ _F_ _IF_ARGS_ 0 1 X 3 \ (u0 :: Char#) -> case _#_ ord# [] [u0] of { _PRIM_ (u1 :: Int#) -> _!_ I# [] [u1] } _N_} _F_ _IF_ARGS_ 0 1 C 4 \ (u0 :: Char) -> case u0 of { _ALG_ C# (u1 :: Char#) -> case _#_ ord# [] [u1] of { _PRIM_ (u2 :: Int#) -> _!_ I# [] [u2] }; _NO_DEFLT_ } _N_ #-}
otherwise :: Bool
snd :: (a, b) -> b
{-# GHC_PRAGMA _A_ 1 _U_ 1 _N_ _S_ "U(AS)" {_A_ 1 _U_ 1 _N_ _N_ _F_ _IF_ARGS_ 2 1 X 1 _/\_ u0 u1 -> \ (u2 :: u1) -> u2 _N_} _F_ _IF_ARGS_ 2 1 C 2 _/\_ u0 u1 -> \ (u2 :: (u0, u1)) -> case u2 of { _ALG_ _TUP_2 (u3 :: u0) (u4 :: u1) -> u4; _NO_DEFLT_ } _N_ #-}
subtract :: Num a => a -> a -> a
- {-# GHC_PRAGMA _A_ 3 _U_ 122 _N_ _S_ "U(AAASAAAAAA)LL" {_A_ 3 _U_ 122 _N_ _N_ _F_ _IF_ARGS_ 1 3 XXX 3 _/\_ u0 -> \ (u1 :: u0 -> u0 -> u0) (u2 :: u0) (u3 :: u0) -> _APP_ u1 [ u3, u2 ] _N_} _F_ _IF_ARGS_ 1 3 CXX 4 _/\_ u0 -> \ (u1 :: {{Num u0}}) (u2 :: u0) (u3 :: u0) -> case u1 of { _ALG_ _TUP_10 (u4 :: {{Eq u0}}) (u5 :: {{Text u0}}) (u6 :: u0 -> u0 -> u0) (u7 :: u0 -> u0 -> u0) (u8 :: u0 -> u0 -> u0) (u9 :: u0 -> u0) (ua :: u0 -> u0) (ub :: u0 -> u0) (uc :: Integer -> u0) (ud :: Int -> u0) -> _APP_ u7 [ u3, u2 ]; _NO_DEFLT_ } _SPECIALISE_ [ Double ] 1 { _A_ 2 _U_ 11 _N_ _S_ "U(P)U(P)" {_A_ 2 _U_ 22 _N_ _N_ _F_ _IF_ARGS_ 0 2 XX 3 \ (u0 :: Double#) (u1 :: Double#) -> case _#_ minusDouble# [] [u1, u0] of { _PRIM_ (u2 :: Double#) -> _!_ D# [] [u2] } _N_} _F_ _IF_ARGS_ 0 2 CC 5 \ (u0 :: Double) (u1 :: Double) -> case u1 of { _ALG_ D# (u2 :: Double#) -> case u0 of { _ALG_ D# (u3 :: Double#) -> case _#_ minusDouble# [] [u2, u3] of { _PRIM_ (u4 :: Double#) -> _!_ D# [] [u4] }; _NO_DEFLT_ }; _NO_DEFLT_ } _N_ }, [ Int ] 1 { _A_ 2 _U_ 11 _N_ _S_ "U(P)U(P)" {_A_ 2 _U_ 22 _N_ _N_ _F_ _IF_ARGS_ 0 2 XX 3 \ (u0 :: Int#) (u1 :: Int#) -> case _#_ minusInt# [] [u1, u0] of { _PRIM_ (u2 :: Int#) -> _!_ I# [] [u2] } _N_} _F_ _IF_ARGS_ 0 2 CC 5 \ (u0 :: Int) (u1 :: Int) -> case u1 of { _ALG_ I# (u2 :: Int#) -> case u0 of { _ALG_ I# (u3 :: Int#) -> case _#_ minusInt# [] [u2, u3] of { _PRIM_ (u4 :: Int#) -> _!_ I# [] [u4] }; _NO_DEFLT_ }; _NO_DEFLT_ } _N_ } #-}
+ {-# GHC_PRAGMA _A_ 3 _U_ 122 _N_ _S_ "U(AAASAAAAAA)LL" {_A_ 3 _U_ 122 _N_ _N_ _F_ _IF_ARGS_ 1 3 XXX 3 _/\_ u0 -> \ (u1 :: u0 -> u0 -> u0) (u2 :: u0) (u3 :: u0) -> _APP_ u1 [ u3, u2 ] _N_} _F_ _IF_ARGS_ 1 3 CXX 4 _/\_ u0 -> \ (u1 :: {{Num u0}}) (u2 :: u0) (u3 :: u0) -> case u1 of { _ALG_ _TUP_10 (u4 :: {{Eq u0}}) (u5 :: {{Text u0}}) (u6 :: u0 -> u0 -> u0) (u7 :: u0 -> u0 -> u0) (u8 :: u0 -> u0 -> u0) (u9 :: u0 -> u0) (ua :: u0 -> u0) (ub :: u0 -> u0) (uc :: Integer -> u0) (ud :: Int -> u0) -> _APP_ u7 [ u3, u2 ]; _NO_DEFLT_ } _SPECIALISE_ [ Double ] 1 { _A_ 2 _U_ 11 _N_ _S_ "U(P)U(P)" {_A_ 2 _U_ 22 _N_ _N_ _F_ _IF_ARGS_ 0 2 XX 3 \ (u0 :: Double#) (u1 :: Double#) -> case _#_ minusDouble# [] [u1, u0] of { _PRIM_ (u2 :: Double#) -> _!_ D# [] [u2] } _N_} _F_ _IF_ARGS_ 0 2 CC 5 \ (u0 :: Double) (u1 :: Double) -> case u1 of { _ALG_ D# (u2 :: Double#) -> case u0 of { _ALG_ D# (u3 :: Double#) -> case _#_ minusDouble# [] [u2, u3] of { _PRIM_ (u4 :: Double#) -> _!_ D# [] [u4] }; _NO_DEFLT_ }; _NO_DEFLT_ } _N_ }, [ Int ] 1 { _A_ 2 _U_ 11 _N_ _S_ "U(P)U(P)" {_A_ 2 _U_ 22 _N_ _N_ _F_ _IF_ARGS_ 0 2 XX 3 \ (u0 :: Int#) (u1 :: Int#) -> case _#_ minusInt# [] [u1, u0] of { _PRIM_ (u2 :: Int#) -> _!_ I# [] [u2] } _N_} _F_ _IF_ARGS_ 0 2 CC 5 \ (u0 :: Int) (u1 :: Int) -> case u1 of { _ALG_ I# (u2 :: Int#) -> case u0 of { _ALG_ I# (u3 :: Int#) -> case _#_ minusInt# [] [u2, u3] of { _PRIM_ (u4 :: Int#) -> _!_ I# [] [u4] }; _NO_DEFLT_ }; _NO_DEFLT_ } _N_ }, [ (Complex Double) ] 1 { _A_ 2 _U_ 11 _N_ _S_ "U(LL)U(LL)" {_A_ 4 _U_ 2222 _N_ _N_ _N_ _N_} _N_ _N_ } #-}
toLower :: Char -> Char
{-# GHC_PRAGMA _A_ 1 _U_ 1 _N_ _S_ "U(P)" {_A_ 1 _U_ 2 _N_ _N_ _N_ _N_} _N_ _N_ #-}
toUpper :: Char -> Char
imagPart :: Complex a -> a
{-# GHC_PRAGMA _A_ 1 _U_ 1 _N_ _S_ "U(AS)" {_A_ 1 _U_ 1 _N_ _N_ _F_ _IF_ARGS_ 1 1 X 1 _/\_ u0 -> \ (u1 :: u0) -> u1 _N_} _F_ _IF_ARGS_ 1 1 C 2 _/\_ u0 -> \ (u1 :: Complex u0) -> case u1 of { _ALG_ (:+) (u2 :: u0) (u3 :: u0) -> u3; _NO_DEFLT_ } _N_ #-}
magnitude :: RealFloat a => Complex a -> a
- {-# GHC_PRAGMA _A_ 1 _U_ 12 _N_ _S_ "U(ALAAAAALAS)" {_A_ 3 _U_ 2221 _N_ _N_ _N_ _N_} _N_ _SPECIALISE_ [ Double ] 1 { _A_ 1 _U_ 1 _N_ _S_ "U(LL)" {_A_ 2 _U_ 22 _N_ _N_ _N_ _N_} _N_ _N_ } #-}
+ {-# GHC_PRAGMA _A_ 1 _U_ 12 _N_ _S_ "U(ALAAAAALAS)" {_A_ 3 _U_ 2221 _N_ _N_ _N_ _N_} _N_ _SPECIALISE_ [ Double ] 1 { _A_ 1 _U_ 1 _N_ _S_ "U(U(P)U(P))" {_A_ 2 _U_ 22 _N_ _N_ _N_ _N_} _N_ _N_ } #-}
mkPolar :: RealFloat a => a -> a -> Complex a
{-# GHC_PRAGMA _A_ 3 _U_ 122 _N_ _N_ _N_ _SPECIALISE_ [ Double ] 1 { _A_ 2 _U_ 22 _N_ _N_ _N_ _N_ } #-}
phase :: RealFloat a => Complex a -> a
{-# GHC_PRAGMA _A_ 1 _U_ 22 _N_ _N_ _N_ _SPECIALISE_ [ Double ] 1 { _A_ 1 _U_ 2 _N_ _N_ _N_ _N_ } #-}
realPart :: Complex a -> a
{-# GHC_PRAGMA _A_ 1 _U_ 1 _N_ _S_ "U(SA)" {_A_ 1 _U_ 1 _N_ _N_ _F_ _IF_ARGS_ 1 1 X 1 _/\_ u0 -> \ (u1 :: u0) -> u1 _N_} _F_ _IF_ARGS_ 1 1 C 2 _/\_ u0 -> \ (u1 :: Complex u0) -> case u1 of { _ALG_ (:+) (u2 :: u0) (u3 :: u0) -> u2; _NO_DEFLT_ } _N_ #-}
-_ceiling :: (RealFrac a, Integral b) => a -> b
- {-# GHC_PRAGMA _A_ 2 _U_ 122 _N_ _S_ "U(U(AU(U(AAAASAAA)AAAA)A)LSAAAA)L" {_A_ 4 _U_ 11122 _N_ _N_ _N_ _N_} _N_ _SPECIALISE_ [ Double, Int ] 2 { _A_ 0 _U_ 2 _N_ _N_ _N_ _N_ } #-}
-_floor :: (RealFrac a, Integral b) => a -> b
- {-# GHC_PRAGMA _A_ 2 _U_ 122 _N_ _S_ "U(U(AU(U(ASAAAAAA)AAAA)A)LSAAAA)L" {_A_ 4 _U_ 11122 _N_ _N_ _N_ _N_} _N_ _SPECIALISE_ [ Double, Int ] 2 { _A_ 0 _U_ 2 _N_ _N_ _N_ _N_ } #-}
-_readList :: Text a => [Char] -> [([a], [Char])]
+_readList :: ([Char] -> [(a, [Char])]) -> [Char] -> [([a], [Char])]
{-# GHC_PRAGMA _A_ 1 _U_ 22 _N_ _N_ _N_ _N_ #-}
-_round :: (RealFrac a, Integral b) => a -> b
- {-# GHC_PRAGMA _A_ 2 _U_ 122 _N_ _S_ "U(U(AU(U(ALAAAAAS)AAAA)A)LSAAAA)L" {_A_ 5 _U_ 112122 _N_ _N_ _N_ _N_} _N_ _SPECIALISE_ [ Double, Int ] 2 { _A_ 0 _U_ 2 _N_ _N_ _N_ _N_ }, [ (Ratio Integer), Integer ] 2 { _A_ 1 _U_ 1 _N_ _S_ "U(LL)" {_A_ 2 _U_ 22 _N_ _N_ _N_ _N_} _N_ _N_ } #-}
-_showList :: Text a => [a] -> [Char] -> [Char]
- {-# GHC_PRAGMA _A_ 1 _U_ 212 _N_ _N_ _N_ _N_ #-}
+_showList :: (a -> [Char] -> [Char]) -> [a] -> [Char] -> [Char]
+ {-# GHC_PRAGMA _A_ 2 _U_ 212 _N_ _S_ "LS" _N_ _N_ #-}
_showRational :: Int -> Ratio Integer -> [Char]
{-# GHC_PRAGMA _A_ 2 _U_ 21 _N_ _S_ "LU(U(PPP)L)" {_A_ 5 _U_ 22222 _N_ _N_ _N_ _N_} _N_ _N_ #-}
-_truncate :: (RealFrac a, Integral b) => a -> b
- {-# GHC_PRAGMA _A_ 2 _U_ 122 _N_ _S_ "U(AASAAAA)L" {_A_ 2 _U_ 122 _N_ _N_ _N_ _N_} _N_ _SPECIALISE_ [ Double, Int ] 2 { _A_ 0 _U_ 2 _N_ _N_ _N_ _N_ } #-}
abort :: IOError -> [Response] -> [Request]
{-# GHC_PRAGMA _A_ 2 _U_ 00 _N_ _S_ "A" {_A_ 1 _U_ 0 _N_ _N_ _F_ _IF_ARGS_ 0 1 X 1 \ (u0 :: [Response]) -> _!_ _NIL_ [Request] [] _N_} _F_ _IF_ARGS_ 0 1 X 1 \ (u0 :: IOError) -> _ORIG_ PreludeIO done _N_ #-}
appendBinChan :: [Char] -> Bin -> (IOError -> [Response] -> [Request]) -> ([Response] -> [Request]) -> [Response] -> [Request]
interact :: ([Char] -> [Char]) -> [Response] -> [Request]
{-# GHC_PRAGMA _A_ 1 _U_ 11 _N_ _N_ _N_ _N_ #-}
print :: Text a => a -> [Response] -> [Request]
- {-# GHC_PRAGMA _A_ 1 _U_ 121 _N_ _N_ _N_ _N_ #-}
+ {-# GHC_PRAGMA _A_ 1 _U_ 121 _N_ _N_ _N_ _SPECIALISE_ [ Bool ] 1 { _A_ 1 _U_ 21 _N_ _N_ _N_ _N_ }, [ Char ] 1 { _A_ 1 _U_ 11 _N_ _N_ _N_ _N_ }, [ Double ] 1 { _A_ 1 _U_ 11 _N_ _N_ _N_ _N_ }, [ Int ] 1 { _A_ 1 _U_ 11 _N_ _N_ _N_ _N_ }, [ Integer ] 1 { _A_ 1 _U_ 11 _N_ _N_ _N_ _N_ }, [ [Char] ] 1 { _A_ 1 _U_ 21 _N_ _N_ _N_ _N_ }, [ [Int] ] 1 { _A_ 1 _U_ 21 _N_ _N_ _N_ _N_ }, [ [[Char]] ] 1 { _A_ 1 _U_ 21 _N_ _N_ _N_ _N_ }, [ [[Int]] ] 1 { _A_ 1 _U_ 21 _N_ _N_ _N_ _N_ }, [ _PackedString ] 1 { _A_ 1 _U_ 21 _N_ _N_ _N_ _N_ }, [ () ] 1 { _A_ 1 _U_ 21 _N_ _N_ _N_ _N_ } #-}
prints :: Text a => a -> [Char] -> [Response] -> [Request]
- {-# GHC_PRAGMA _A_ 1 _U_ 1221 _N_ _N_ _N_ _N_ #-}
+ {-# GHC_PRAGMA _A_ 1 _U_ 1221 _N_ _N_ _N_ _SPECIALISE_ [ Bool ] 1 { _A_ 2 _U_ 221 _N_ _N_ _N_ _N_ }, [ Char ] 1 { _A_ 2 _U_ 121 _N_ _N_ _N_ _N_ }, [ Double ] 1 { _A_ 2 _U_ 121 _N_ _N_ _N_ _N_ }, [ Int ] 1 { _A_ 2 _U_ 121 _N_ _N_ _N_ _N_ }, [ Integer ] 1 { _A_ 2 _U_ 121 _N_ _N_ _N_ _N_ }, [ [Char] ] 1 { _A_ 2 _U_ 221 _N_ _N_ _N_ _N_ }, [ [Int] ] 1 { _A_ 2 _U_ 221 _N_ _N_ _N_ _N_ }, [ [[Char]] ] 1 { _A_ 2 _U_ 121 _N_ _N_ _N_ _N_ }, [ [[Int]] ] 1 { _A_ 2 _U_ 121 _N_ _N_ _N_ _N_ }, [ _PackedString ] 1 { _A_ 2 _U_ 221 _N_ _N_ _N_ _N_ }, [ () ] 1 { _A_ 2 _U_ 121 _N_ _N_ _N_ _N_ } #-}
readBinChan :: [Char] -> (IOError -> [Response] -> [Request]) -> (Bin -> [Response] -> [Request]) -> [Response] -> [Request]
{-# GHC_PRAGMA _A_ 4 _U_ 2111 _N_ _N_ _N_ _N_ #-}
readBinFile :: [Char] -> (IOError -> [Response] -> [Request]) -> (Bin -> [Response] -> [Request]) -> [Response] -> [Request]
(++) :: [a] -> [a] -> [a]
{-# GHC_PRAGMA _A_ 2 _U_ 12 _N_ _S_ "SL" _N_ _N_ #-}
(\\) :: Eq a => [a] -> [a] -> [a]
- {-# GHC_PRAGMA _A_ 3 _U_ 122 _N_ _S_ "LLS" _N_ _N_ #-}
+ {-# GHC_PRAGMA _A_ 3 _U_ 122 _N_ _S_ "LLS" _N_ _SPECIALISE_ [ Int ] 1 { _A_ 2 _U_ 22 _N_ _S_ "LS" _N_ _N_ }, [ [Char] ] 1 { _A_ 2 _U_ 22 _N_ _S_ "LS" _N_ _N_ } #-}
all :: (a -> Bool) -> [a] -> Bool
{-# GHC_PRAGMA _A_ 2 _U_ 21 _N_ _S_ "LS" _F_ _ALWAYS_ _/\_ u0 -> \ (u1 :: u0 -> Bool) (u2 :: [u0]) -> let {(u3 :: Bool) = _!_ True [] []} in let {(u6 :: u0 -> Bool -> Bool) = \ (u4 :: u0) (u5 :: Bool) -> case _APP_ u1 [ u4 ] of { _ALG_ True -> u5; False -> _!_ False [] []; _NO_DEFLT_ }} in _APP_ _TYAPP_ _TYAPP_ foldr { u0 } { Bool } [ u6, u3, u2 ] _N_ #-}
and :: [Bool] -> Bool
dropWhile :: (a -> Bool) -> [a] -> [a]
{-# GHC_PRAGMA _A_ 2 _U_ 21 _N_ _S_ "LS" _N_ _N_ #-}
elem :: Eq a => a -> [a] -> Bool
- {-# GHC_PRAGMA _A_ 3 _U_ 121 _N_ _S_ "LLS" _F_ _ALWAYS_ _/\_ u0 -> \ (u1 :: {{Eq u0}}) (u2 :: u0) (u3 :: [u0]) -> let {(u6 :: u0 -> u0 -> Bool) = case u1 of { _ALG_ _TUP_2 (u4 :: u0 -> u0 -> Bool) (u5 :: u0 -> u0 -> Bool) -> u4; _NO_DEFLT_ }} in let {(u8 :: u0 -> Bool) = \ (u7 :: u0) -> _APP_ u6 [ u2, u7 ]} in _APP_ _TYAPP_ _ORIG_ PreludeList any { u0 } [ u8, u3 ] _SPECIALISE_ [ Char ] 1 { _A_ 2 _U_ 21 _N_ _S_ "LS" _F_ _ALWAYS_ \ (u0 :: Char) (u1 :: [Char]) -> let {(u5 :: Char -> Bool) = \ (u2 :: Char) -> case u0 of { _ALG_ C# (u3 :: Char#) -> case u2 of { _ALG_ C# (u4 :: Char#) -> _#_ eqChar# [] [u3, u4]; _NO_DEFLT_ }; _NO_DEFLT_ }} in _APP_ _TYAPP_ _ORIG_ PreludeList any { Char } [ u5, u1 ] _N_ }, [ Int ] 1 { _A_ 2 _U_ 21 _N_ _S_ "LS" _F_ _ALWAYS_ \ (u0 :: Int) (u1 :: [Int]) -> let {(u5 :: Int -> Bool) = \ (u2 :: Int) -> case u0 of { _ALG_ I# (u3 :: Int#) -> case u2 of { _ALG_ I# (u4 :: Int#) -> _#_ eqInt# [] [u3, u4]; _NO_DEFLT_ }; _NO_DEFLT_ }} in _APP_ _TYAPP_ _ORIG_ PreludeList any { Int } [ u5, u1 ] _N_ }, [ [Char] ] 1 { _A_ 2 _U_ 21 _N_ _S_ "LS" _F_ _ALWAYS_ \ (u0 :: [Char]) (u1 :: [[Char]]) -> let {(u3 :: [Char] -> Bool) = \ (u2 :: [Char]) -> _APP_ _CONSTM_ Eq (==) ([Char]) [ u0, u2 ]} in _APP_ _TYAPP_ _ORIG_ PreludeList any { [Char] } [ u3, u1 ] _N_ } #-}
+ {-# GHC_PRAGMA _A_ 3 _U_ 121 _N_ _S_ "LLS" _F_ _ALWAYS_ _/\_ u0 -> \ (u1 :: {{Eq u0}}) (u2 :: u0) (u3 :: [u0]) -> let {(u6 :: u0 -> u0 -> Bool) = case u1 of { _ALG_ _TUP_2 (u4 :: u0 -> u0 -> Bool) (u5 :: u0 -> u0 -> Bool) -> u4; _NO_DEFLT_ }} in let {(u8 :: u0 -> Bool) = \ (u7 :: u0) -> _APP_ u6 [ u2, u7 ]} in _APP_ _TYAPP_ _ORIG_ PreludeList any { u0 } [ u8, u3 ] _SPECIALISE_ [ Char ] 1 { _A_ 2 _U_ 21 _N_ _S_ "LS" _F_ _ALWAYS_ \ (u0 :: Char) (u1 :: [Char]) -> let {(u5 :: Char -> Bool) = \ (u2 :: Char) -> case u0 of { _ALG_ C# (u3 :: Char#) -> case u2 of { _ALG_ C# (u4 :: Char#) -> _#_ eqChar# [] [u3, u4]; _NO_DEFLT_ }; _NO_DEFLT_ }} in _APP_ _TYAPP_ _ORIG_ PreludeList any { Char } [ u5, u1 ] _N_ }, [ Int ] 1 { _A_ 2 _U_ 21 _N_ _S_ "LS" _F_ _ALWAYS_ \ (u0 :: Int) (u1 :: [Int]) -> let {(u5 :: Int -> Bool) = \ (u2 :: Int) -> case u0 of { _ALG_ I# (u3 :: Int#) -> case u2 of { _ALG_ I# (u4 :: Int#) -> _#_ eqInt# [] [u3, u4]; _NO_DEFLT_ }; _NO_DEFLT_ }} in _APP_ _TYAPP_ _ORIG_ PreludeList any { Int } [ u5, u1 ] _N_ }, [ Integer ] 1 { _A_ 2 _U_ 21 _N_ _S_ "LS" _F_ _ALWAYS_ \ (u0 :: Integer) (u1 :: [Integer]) -> let {(ua :: Integer -> Bool) = \ (u2 :: Integer) -> case u0 of { _ALG_ J# (u3 :: Int#) (u4 :: Int#) (u5 :: ByteArray#) -> case u2 of { _ALG_ J# (u6 :: Int#) (u7 :: Int#) (u8 :: ByteArray#) -> case _#_ cmpInteger# [] [u3, u4, u5, u6, u7, u8] of { _PRIM_ 0# -> _!_ True [] []; (u9 :: Int#) -> _!_ False [] [] }; _NO_DEFLT_ }; _NO_DEFLT_ }} in _APP_ _TYAPP_ _ORIG_ PreludeList any { Integer } [ ua, u1 ] _N_ }, [ [Char] ] 1 { _A_ 2 _U_ 21 _N_ _S_ "LS" _F_ _ALWAYS_ \ (u0 :: [Char]) (u1 :: [[Char]]) -> let {(u3 :: [Char] -> Bool) = \ (u2 :: [Char]) -> _APP_ _CONSTM_ Eq (==) ([Char]) [ u0, u2 ]} in _APP_ _TYAPP_ _ORIG_ PreludeList any { [Char] } [ u3, u1 ] _N_ }, [ [Int] ] 1 { _A_ 2 _U_ 21 _N_ _S_ "LS" _F_ _ALWAYS_ \ (u0 :: [Int]) (u1 :: [[Int]]) -> let {(u3 :: [Int] -> Bool) = \ (u2 :: [Int]) -> _APP_ _CONSTM_ Eq (==) ([Int]) [ u0, u2 ]} in _APP_ _TYAPP_ _ORIG_ PreludeList any { [Int] } [ u3, u1 ] _N_ }, [ (Int, Int) ] 1 { _A_ 2 _U_ 21 _N_ _S_ "LS" _F_ _ALWAYS_ \ (u0 :: (Int, Int)) (u1 :: [(Int, Int)]) -> let {(ub :: (Int, Int) -> Bool) = \ (u2 :: (Int, Int)) -> case u0 of { _ALG_ _TUP_2 (u3 :: Int) (u4 :: Int) -> case u3 of { _ALG_ I# (u5 :: Int#) -> case u2 of { _ALG_ _TUP_2 (u6 :: Int) (u7 :: Int) -> case u6 of { _ALG_ I# (u8 :: Int#) -> case _#_ eqInt# [] [u5, u8] of { _ALG_ True -> case u4 of { _ALG_ I# (u9 :: Int#) -> case u7 of { _ALG_ I# (ua :: Int#) -> _#_ eqInt# [] [u9, ua]; _NO_DEFLT_ }; _NO_DEFLT_ }; False -> _!_ False [] []; _NO_DEFLT_ }; _NO_DEFLT_ }; _NO_DEFLT_ }; _NO_DEFLT_ }; _NO_DEFLT_ }} in _APP_ _TYAPP_ _ORIG_ PreludeList any { (Int, Int) } [ ub, u1 ] _N_ } #-}
filter :: (a -> Bool) -> [a] -> [a]
{-# GHC_PRAGMA _A_ 2 _U_ 21 _N_ _S_ "LS" _F_ _ALWAYS_ _/\_ u0 -> \ (u1 :: u0 -> Bool) (u2 :: [u0]) -> let {(u9 :: _forall_ a$z1 =>(u0 -> a$z1 -> a$z1) -> a$z1 -> a$z1) = _/\_ u3 -> \ (u4 :: u0 -> u3 -> u3) (u5 :: u3) -> let {(u8 :: u0 -> u3 -> u3) = \ (u6 :: u0) (u7 :: u3) -> case _APP_ u1 [ u6 ] of { _ALG_ True -> _APP_ u4 [ u6, u7 ]; False -> u7; _NO_DEFLT_ }} in _APP_ _TYAPP_ _TYAPP_ foldr { u0 } { u3 } [ u8, u5, u2 ]} in _APP_ _TYAPP_ _build { u0 } [ u9 ] _N_ #-}
foldl1 :: (a -> a -> a) -> [a] -> a
foldr1 :: (a -> a -> a) -> [a] -> a
{-# GHC_PRAGMA _A_ 2 _U_ 21 _N_ _S_ "LS" _N_ _N_ #-}
genericLength :: Num b => [a] -> b
- {-# GHC_PRAGMA _A_ 1 _U_ 21 _N_ _N_ _N_ _N_ #-}
+ {-# GHC_PRAGMA _A_ 1 _U_ 21 _N_ _N_ _N_ _SPECIALISE_ [ _N_, Int ] 1 { _A_ 1 _U_ 1 _N_ _S_ "S" _N_ _N_ }, [ _N_, Integer ] 1 { _A_ 1 _U_ 1 _N_ _S_ "S" _N_ _N_ } #-}
head :: [a] -> a
{-# GHC_PRAGMA _A_ 1 _U_ 1 _N_ _S_ "S" _F_ _ALWAYS_ _/\_ u0 -> \ (u1 :: [u0]) -> let {(u2 :: u0) = _APP_ _TYAPP_ error { u0 } [ _NOREP_S_ "head{PreludeList}: head []\n" ]} in let {(u5 :: u0 -> u0 -> u0) = \ (u3 :: u0) (u4 :: u0) -> u3} in _APP_ _TYAPP_ _TYAPP_ foldr { u0 } { u0 } [ u5, u2, u1 ] _N_ #-}
init :: [a] -> [a]
map :: (a -> b) -> [a] -> [b]
{-# GHC_PRAGMA _A_ 2 _U_ 21 _N_ _S_ "LS" _F_ _ALWAYS_ _/\_ u0 u1 -> \ (u2 :: u0 -> u1) (u3 :: [u0]) -> let {(ua :: _forall_ a$z1 =>(u1 -> a$z1 -> a$z1) -> a$z1 -> a$z1) = _/\_ u4 -> \ (u5 :: u1 -> u4 -> u4) (u6 :: u4) -> let {(u9 :: u0 -> u4 -> u4) = \ (u7 :: u0) -> let {(u8 :: u1) = _APP_ u2 [ u7 ]} in _APP_ u5 [ u8 ]} in _APP_ _TYAPP_ _TYAPP_ foldr { u0 } { u4 } [ u9, u6, u3 ]} in _APP_ _TYAPP_ _build { u1 } [ ua ] _N_ #-}
maximum :: Ord a => [a] -> a
- {-# GHC_PRAGMA _A_ 1 _U_ 11 _N_ _N_ _N_ _N_ #-}
+ {-# GHC_PRAGMA _A_ 1 _U_ 11 _N_ _N_ _N_ _SPECIALISE_ [ Double ] 1 { _A_ 1 _U_ 1 _N_ _S_ "S" _N_ _N_ }, [ Int ] 1 { _A_ 1 _U_ 1 _N_ _S_ "S" _N_ _N_ }, [ Integer ] 1 { _A_ 1 _U_ 1 _N_ _S_ "S" _N_ _N_ } #-}
minimum :: Ord a => [a] -> a
- {-# GHC_PRAGMA _A_ 1 _U_ 11 _N_ _N_ _N_ _N_ #-}
+ {-# GHC_PRAGMA _A_ 1 _U_ 11 _N_ _N_ _N_ _SPECIALISE_ [ Double ] 1 { _A_ 1 _U_ 1 _N_ _S_ "S" _N_ _N_ }, [ Int ] 1 { _A_ 1 _U_ 1 _N_ _S_ "S" _N_ _N_ }, [ Integer ] 1 { _A_ 1 _U_ 1 _N_ _S_ "S" _N_ _N_ } #-}
notElem :: Eq a => a -> [a] -> Bool
- {-# GHC_PRAGMA _A_ 3 _U_ 121 _N_ _S_ "LLS" _F_ _ALWAYS_ _/\_ u0 -> \ (u1 :: {{Eq u0}}) (u2 :: u0) (u3 :: [u0]) -> let {(u6 :: u0 -> u0 -> Bool) = case u1 of { _ALG_ _TUP_2 (u4 :: u0 -> u0 -> Bool) (u5 :: u0 -> u0 -> Bool) -> u5; _NO_DEFLT_ }} in let {(u8 :: u0 -> Bool) = \ (u7 :: u0) -> _APP_ u6 [ u2, u7 ]} in _APP_ _TYAPP_ _ORIG_ PreludeList all { u0 } [ u8, u3 ] _SPECIALISE_ [ Char ] 1 { _A_ 2 _U_ 21 _N_ _S_ "LS" _F_ _ALWAYS_ \ (u0 :: Char) (u1 :: [Char]) -> let {(u5 :: Char -> Bool) = \ (u2 :: Char) -> case u0 of { _ALG_ C# (u3 :: Char#) -> case u2 of { _ALG_ C# (u4 :: Char#) -> _#_ neChar# [] [u3, u4]; _NO_DEFLT_ }; _NO_DEFLT_ }} in _APP_ _TYAPP_ _ORIG_ PreludeList all { Char } [ u5, u1 ] _N_ }, [ Int ] 1 { _A_ 2 _U_ 21 _N_ _S_ "LS" _F_ _ALWAYS_ \ (u0 :: Int) (u1 :: [Int]) -> let {(u5 :: Int -> Bool) = \ (u2 :: Int) -> case u0 of { _ALG_ I# (u3 :: Int#) -> case u2 of { _ALG_ I# (u4 :: Int#) -> _#_ neInt# [] [u3, u4]; _NO_DEFLT_ }; _NO_DEFLT_ }} in _APP_ _TYAPP_ _ORIG_ PreludeList all { Int } [ u5, u1 ] _N_ }, [ [Char] ] 1 { _A_ 2 _U_ 21 _N_ _S_ "LS" _F_ _ALWAYS_ \ (u0 :: [Char]) (u1 :: [[Char]]) -> let {(u3 :: [Char] -> Bool) = \ (u2 :: [Char]) -> _APP_ _CONSTM_ Eq (/=) ([Char]) [ u0, u2 ]} in _APP_ _TYAPP_ _ORIG_ PreludeList all { [Char] } [ u3, u1 ] _N_ } #-}
+ {-# GHC_PRAGMA _A_ 3 _U_ 121 _N_ _S_ "LLS" _F_ _ALWAYS_ _/\_ u0 -> \ (u1 :: {{Eq u0}}) (u2 :: u0) (u3 :: [u0]) -> let {(u6 :: u0 -> u0 -> Bool) = case u1 of { _ALG_ _TUP_2 (u4 :: u0 -> u0 -> Bool) (u5 :: u0 -> u0 -> Bool) -> u5; _NO_DEFLT_ }} in let {(u8 :: u0 -> Bool) = \ (u7 :: u0) -> _APP_ u6 [ u2, u7 ]} in _APP_ _TYAPP_ _ORIG_ PreludeList all { u0 } [ u8, u3 ] _SPECIALISE_ [ Char ] 1 { _A_ 2 _U_ 21 _N_ _S_ "LS" _F_ _ALWAYS_ \ (u0 :: Char) (u1 :: [Char]) -> let {(u5 :: Char -> Bool) = \ (u2 :: Char) -> case u0 of { _ALG_ C# (u3 :: Char#) -> case u2 of { _ALG_ C# (u4 :: Char#) -> _#_ neChar# [] [u3, u4]; _NO_DEFLT_ }; _NO_DEFLT_ }} in _APP_ _TYAPP_ _ORIG_ PreludeList all { Char } [ u5, u1 ] _N_ }, [ Int ] 1 { _A_ 2 _U_ 21 _N_ _S_ "LS" _F_ _ALWAYS_ \ (u0 :: Int) (u1 :: [Int]) -> let {(u5 :: Int -> Bool) = \ (u2 :: Int) -> case u0 of { _ALG_ I# (u3 :: Int#) -> case u2 of { _ALG_ I# (u4 :: Int#) -> _#_ neInt# [] [u3, u4]; _NO_DEFLT_ }; _NO_DEFLT_ }} in _APP_ _TYAPP_ _ORIG_ PreludeList all { Int } [ u5, u1 ] _N_ }, [ Integer ] 1 { _A_ 2 _U_ 21 _N_ _S_ "LS" _F_ _ALWAYS_ \ (u0 :: Integer) (u1 :: [Integer]) -> let {(ua :: Integer -> Bool) = \ (u2 :: Integer) -> case u0 of { _ALG_ J# (u3 :: Int#) (u4 :: Int#) (u5 :: ByteArray#) -> case u2 of { _ALG_ J# (u6 :: Int#) (u7 :: Int#) (u8 :: ByteArray#) -> case _#_ cmpInteger# [] [u3, u4, u5, u6, u7, u8] of { _PRIM_ 0# -> _!_ False [] []; (u9 :: Int#) -> _!_ True [] [] }; _NO_DEFLT_ }; _NO_DEFLT_ }} in _APP_ _TYAPP_ _ORIG_ PreludeList all { Integer } [ ua, u1 ] _N_ }, [ [Char] ] 1 { _A_ 2 _U_ 21 _N_ _S_ "LS" _F_ _ALWAYS_ \ (u0 :: [Char]) (u1 :: [[Char]]) -> let {(u3 :: [Char] -> Bool) = \ (u2 :: [Char]) -> _APP_ _CONSTM_ Eq (/=) ([Char]) [ u0, u2 ]} in _APP_ _TYAPP_ _ORIG_ PreludeList all { [Char] } [ u3, u1 ] _N_ }, [ (Int, Int) ] 1 { _A_ 2 _U_ 21 _N_ _S_ "LS" _F_ _ALWAYS_ \ (u0 :: (Int, Int)) (u1 :: [(Int, Int)]) -> let {(ub :: (Int, Int) -> Bool) = \ (u2 :: (Int, Int)) -> case u0 of { _ALG_ _TUP_2 (u3 :: Int) (u4 :: Int) -> case u3 of { _ALG_ I# (u5 :: Int#) -> case u2 of { _ALG_ _TUP_2 (u6 :: Int) (u7 :: Int) -> case u6 of { _ALG_ I# (u8 :: Int#) -> case _#_ neInt# [] [u5, u8] of { _ALG_ True -> _!_ True [] []; False -> case u4 of { _ALG_ I# (u9 :: Int#) -> case u7 of { _ALG_ I# (ua :: Int#) -> _#_ neInt# [] [u9, ua]; _NO_DEFLT_ }; _NO_DEFLT_ }; _NO_DEFLT_ }; _NO_DEFLT_ }; _NO_DEFLT_ }; _NO_DEFLT_ }; _NO_DEFLT_ }} in _APP_ _TYAPP_ _ORIG_ PreludeList all { (Int, Int) } [ ub, u1 ] _N_ } #-}
nub :: Eq a => [a] -> [a]
- {-# GHC_PRAGMA _A_ 2 _U_ 11 _N_ _S_ "LS" _N_ _N_ #-}
+ {-# GHC_PRAGMA _A_ 2 _U_ 11 _N_ _S_ "LS" _N_ _SPECIALISE_ [ Int ] 1 { _A_ 1 _U_ 1 _N_ _S_ "S" _N_ _N_ }, [ [Char] ] 1 { _A_ 1 _U_ 1 _N_ _S_ "S" _N_ _N_ }, [ [Int] ] 1 { _A_ 1 _U_ 1 _N_ _S_ "S" _N_ _N_ } #-}
null :: [a] -> Bool
{-# GHC_PRAGMA _A_ 1 _U_ 1 _N_ _S_ "S" _F_ _ALWAYS_ _/\_ u0 -> \ (u1 :: [u0]) -> let {(u2 :: Bool) = _!_ True [] []} in let {(u5 :: u0 -> Bool -> Bool) = \ (u3 :: u0) (u4 :: Bool) -> _!_ False [] []} in _APP_ _TYAPP_ _TYAPP_ foldr { u0 } { Bool } [ u5, u2, u1 ] _N_ #-}
or :: [Bool] -> Bool
partition :: (a -> Bool) -> [a] -> ([a], [a])
{-# GHC_PRAGMA _A_ 2 _U_ 21 _N_ _S_ "LS" _F_ _ALWAYS_ _/\_ u0 -> \ (u1 :: u0 -> Bool) (u2 :: [u0]) -> let {(u9 :: u0 -> ([u0], [u0]) -> ([u0], [u0])) = \ (u3 :: u0) (u4 :: ([u0], [u0])) -> case u4 of { _ALG_ _TUP_2 (u5 :: [u0]) (u6 :: [u0]) -> case _APP_ u1 [ u3 ] of { _ALG_ True -> let {(u7 :: [u0]) = _!_ (:) [u0] [u3, u5]} in _!_ _TUP_2 [[u0], [u0]] [u7, u6]; False -> let {(u8 :: [u0]) = _!_ (:) [u0] [u3, u6]} in _!_ _TUP_2 [[u0], [u0]] [u5, u8]; _NO_DEFLT_ }; _NO_DEFLT_ }} in let {(ua :: [u0]) = _!_ _NIL_ [u0] []} in let {(ub :: ([u0], [u0])) = _!_ _TUP_2 [[u0], [u0]] [ua, ua]} in _APP_ _TYAPP_ _TYAPP_ foldr { u0 } { ([u0], [u0]) } [ u9, ub, u2 ] _N_ #-}
product :: Num a => [a] -> a
- {-# GHC_PRAGMA _A_ 1 _U_ 22 _N_ _N_ _F_ _ALWAYS_ _/\_ u0 -> \ (u1 :: {{Num u0}}) -> let {(uc :: u0 -> u0 -> u0) = case u1 of { _ALG_ _TUP_10 (u2 :: {{Eq u0}}) (u3 :: {{Text u0}}) (u4 :: u0 -> u0 -> u0) (u5 :: u0 -> u0 -> u0) (u6 :: u0 -> u0 -> u0) (u7 :: u0 -> u0) (u8 :: u0 -> u0) (u9 :: u0 -> u0) (ua :: Integer -> u0) (ub :: Int -> u0) -> u6; _NO_DEFLT_ }} in let {(uo :: u0) = let {(ud :: Int) = _!_ I# [] [1#]} in case u1 of { _ALG_ _TUP_10 (ue :: {{Eq u0}}) (uf :: {{Text u0}}) (ug :: u0 -> u0 -> u0) (uh :: u0 -> u0 -> u0) (ui :: u0 -> u0 -> u0) (uj :: u0 -> u0) (uk :: u0 -> u0) (ul :: u0 -> u0) (um :: Integer -> u0) (un :: Int -> u0) -> _APP_ un [ ud ]; _NO_DEFLT_ }} in \ (up :: [u0]) -> _APP_ _TYAPP_ _TYAPP_ foldl { u0 } { u0 } [ uc, uo, up ] _SPECIALISE_ [ Double ] 1 { _A_ 1 _U_ 1 _N_ _S_ "S" _F_ _ALWAYS_ \ (u0 :: [Double]) -> let {(u1 :: Double) = _!_ D# [] [1.0000000000000000##]} in _APP_ _TYAPP_ _TYAPP_ foldl { Double } { Double } [ _CONSTM_ Num (*) (Double), u1, u0 ] _N_ }, [ Int ] 1 { _A_ 1 _U_ 1 _N_ _S_ "S" _F_ _ALWAYS_ \ (u0 :: [Int]) -> let {(u1 :: Int) = _!_ I# [] [1#]} in _APP_ _TYAPP_ _TYAPP_ foldl { Int } { Int } [ _CONSTM_ Num (*) (Int), u1, u0 ] _N_ }, [ Integer ] 1 { _A_ 1 _U_ 1 _N_ _S_ "S" _F_ _ALWAYS_ \ (u0 :: [Integer]) -> let {(u1 :: Integer) = _#_ int2Integer# [] [1#]} in _APP_ _TYAPP_ _TYAPP_ foldl { Integer } { Integer } [ _CONSTM_ Num (*) (Integer), u1, u0 ] _N_ } #-}
+ {-# GHC_PRAGMA _A_ 1 _U_ 22 _N_ _N_ _F_ _ALWAYS_ _/\_ u0 -> \ (u1 :: {{Num u0}}) -> let {(uc :: u0 -> u0 -> u0) = case u1 of { _ALG_ _TUP_10 (u2 :: {{Eq u0}}) (u3 :: {{Text u0}}) (u4 :: u0 -> u0 -> u0) (u5 :: u0 -> u0 -> u0) (u6 :: u0 -> u0 -> u0) (u7 :: u0 -> u0) (u8 :: u0 -> u0) (u9 :: u0 -> u0) (ua :: Integer -> u0) (ub :: Int -> u0) -> u6; _NO_DEFLT_ }} in let {(uo :: u0) = let {(ud :: Int) = _!_ I# [] [1#]} in case u1 of { _ALG_ _TUP_10 (ue :: {{Eq u0}}) (uf :: {{Text u0}}) (ug :: u0 -> u0 -> u0) (uh :: u0 -> u0 -> u0) (ui :: u0 -> u0 -> u0) (uj :: u0 -> u0) (uk :: u0 -> u0) (ul :: u0 -> u0) (um :: Integer -> u0) (un :: Int -> u0) -> _APP_ un [ ud ]; _NO_DEFLT_ }} in \ (up :: [u0]) -> _APP_ _TYAPP_ _TYAPP_ foldl { u0 } { u0 } [ uc, uo, up ] _SPECIALISE_ [ Double ] 1 { _A_ 1 _U_ 1 _N_ _S_ "S" _F_ _ALWAYS_ \ (u0 :: [Double]) -> let {(u1 :: Double) = _!_ D# [] [1.0000000000000000##]} in _APP_ _TYAPP_ _TYAPP_ foldl { Double } { Double } [ _CONSTM_ Num (*) (Double), u1, u0 ] _N_ }, [ Int ] 1 { _A_ 1 _U_ 1 _N_ _S_ "S" _F_ _ALWAYS_ \ (u0 :: [Int]) -> let {(u1 :: Int) = _!_ I# [] [1#]} in _APP_ _TYAPP_ _TYAPP_ foldl { Int } { Int } [ _CONSTM_ Num (*) (Int), u1, u0 ] _N_ }, [ Integer ] 1 { _A_ 1 _U_ 1 _N_ _S_ "S" _F_ _ALWAYS_ \ (u0 :: [Integer]) -> let {(u1 :: Integer) = _#_ int2Integer# [] [1#]} in _APP_ _TYAPP_ _TYAPP_ foldl { Integer } { Integer } [ _CONSTM_ Num (*) (Integer), u1, u0 ] _N_ }, [ (Complex Double) ] 1 { _A_ 1 _U_ 1 _N_ _S_ "S" _F_ _ALWAYS_ let {(u6 :: Complex Double -> Complex Double -> Complex Double) = \ (u0 :: Complex Double) (u1 :: Complex Double) -> case u0 of { _ALG_ (:+) (u2 :: Double) (u3 :: Double) -> case u1 of { _ALG_ (:+) (u4 :: Double) (u5 :: Double) -> _APP_ _WRKR_ _CONSTM_ Num (*) (Complex Double) [ u2, u3, u4, u5 ]; _NO_DEFLT_ }; _NO_DEFLT_ }} in let {(u8 :: Complex Double) = let {(u7 :: Int) = _!_ I# [] [1#]} in _APP_ _CONSTM_ Num fromInt (Complex Double) [ u7 ]} in \ (u9 :: [Complex Double]) -> _APP_ _TYAPP_ _TYAPP_ foldl { (Complex Double) } { (Complex Double) } [ u6, u8, u9 ] _N_ } #-}
products :: Num a => [a] -> [a]
- {-# GHC_PRAGMA _A_ 1 _U_ 21 _N_ _N_ _N_ _N_ #-}
+ {-# GHC_PRAGMA _A_ 1 _U_ 21 _N_ _N_ _N_ _SPECIALISE_ [ Double ] 1 { _A_ 1 _U_ 1 _N_ _N_ _N_ _N_ }, [ Int ] 1 { _A_ 1 _U_ 1 _N_ _N_ _N_ _N_ }, [ Integer ] 1 { _A_ 1 _U_ 1 _N_ _N_ _F_ _IF_ARGS_ 0 1 X 4 \ (u0 :: [Integer]) -> _APP_ _TYAPP_ _TYAPP_ _ORIG_ PreludeList scanl { Integer } { Integer } [ _CONSTM_ Num (*) (Integer), _SPEC_ _ORIG_ PreludeCore __i1 [ (Integer) ], u0 ] _N_ }, [ (Complex Double) ] 1 { _A_ 1 _U_ 1 _N_ _N_ _N_ _N_ } #-}
repeat :: a -> [a]
{-# GHC_PRAGMA _A_ 1 _U_ 2 _N_ _N_ _F_ _ALWAYS_ _/\_ u0 -> \ (u1 :: u0) -> let {(u6 :: _forall_ a$z1 =>(u0 -> a$z1 -> a$z1) -> a$z1 -> a$z1) = _/\_ u2 -> \ (u3 :: u0 -> u2 -> u2) (u4 :: u2) -> _LETREC_ {(u5 :: u2) = _APP_ u3 [ u1, u5 ]} in u5} in _APP_ _TYAPP_ _build { u0 } [ u6 ] _N_ #-}
reverse :: [a] -> [a]
sum :: Num a => [a] -> a
{-# GHC_PRAGMA _A_ 1 _U_ 22 _N_ _N_ _F_ _ALWAYS_ _/\_ u0 -> \ (u1 :: {{Num u0}}) -> let {(uc :: u0 -> u0 -> u0) = case u1 of { _ALG_ _TUP_10 (u2 :: {{Eq u0}}) (u3 :: {{Text u0}}) (u4 :: u0 -> u0 -> u0) (u5 :: u0 -> u0 -> u0) (u6 :: u0 -> u0 -> u0) (u7 :: u0 -> u0) (u8 :: u0 -> u0) (u9 :: u0 -> u0) (ua :: Integer -> u0) (ub :: Int -> u0) -> u4; _NO_DEFLT_ }} in let {(uo :: u0) = let {(ud :: Int) = _!_ I# [] [0#]} in case u1 of { _ALG_ _TUP_10 (ue :: {{Eq u0}}) (uf :: {{Text u0}}) (ug :: u0 -> u0 -> u0) (uh :: u0 -> u0 -> u0) (ui :: u0 -> u0 -> u0) (uj :: u0 -> u0) (uk :: u0 -> u0) (ul :: u0 -> u0) (um :: Integer -> u0) (un :: Int -> u0) -> _APP_ un [ ud ]; _NO_DEFLT_ }} in \ (up :: [u0]) -> _APP_ _TYAPP_ _TYAPP_ foldl { u0 } { u0 } [ uc, uo, up ] _SPECIALISE_ [ Double ] 1 { _A_ 1 _U_ 1 _N_ _S_ "S" _F_ _ALWAYS_ \ (u0 :: [Double]) -> let {(u1 :: Double) = _!_ D# [] [0.0000000000000000##]} in _APP_ _TYAPP_ _TYAPP_ foldl { Double } { Double } [ _CONSTM_ Num (+) (Double), u1, u0 ] _N_ }, [ Int ] 1 { _A_ 1 _U_ 1 _N_ _S_ "S" _F_ _ALWAYS_ \ (u0 :: [Int]) -> let {(u1 :: Int) = _!_ I# [] [0#]} in _APP_ _TYAPP_ _TYAPP_ foldl { Int } { Int } [ _CONSTM_ Num (+) (Int), u1, u0 ] _N_ }, [ Integer ] 1 { _A_ 1 _U_ 1 _N_ _S_ "S" _F_ _ALWAYS_ \ (u0 :: [Integer]) -> let {(u1 :: Integer) = _#_ int2Integer# [] [0#]} in _APP_ _TYAPP_ _TYAPP_ foldl { Integer } { Integer } [ _CONSTM_ Num (+) (Integer), u1, u0 ] _N_ }, [ (Complex Double) ] 1 { _A_ 1 _U_ 1 _N_ _S_ "S" _F_ _ALWAYS_ let {(u6 :: Complex Double -> Complex Double -> Complex Double) = \ (u0 :: Complex Double) (u1 :: Complex Double) -> case u0 of { _ALG_ (:+) (u2 :: Double) (u3 :: Double) -> case u1 of { _ALG_ (:+) (u4 :: Double) (u5 :: Double) -> _APP_ _WRKR_ _CONSTM_ Num (+) (Complex Double) [ u2, u3, u4, u5 ]; _NO_DEFLT_ }; _NO_DEFLT_ }} in let {(u8 :: Complex Double) = let {(u7 :: Int) = _!_ I# [] [0#]} in _APP_ _CONSTM_ Num fromInt (Complex Double) [ u7 ]} in \ (u9 :: [Complex Double]) -> _APP_ _TYAPP_ _TYAPP_ foldl { (Complex Double) } { (Complex Double) } [ u6, u8, u9 ] _N_ } #-}
sums :: Num a => [a] -> [a]
- {-# GHC_PRAGMA _A_ 1 _U_ 21 _N_ _N_ _N_ _N_ #-}
+ {-# GHC_PRAGMA _A_ 1 _U_ 21 _N_ _N_ _N_ _SPECIALISE_ [ Double ] 1 { _A_ 1 _U_ 1 _N_ _N_ _N_ _N_ }, [ Int ] 1 { _A_ 1 _U_ 1 _N_ _N_ _N_ _N_ }, [ Integer ] 1 { _A_ 1 _U_ 1 _N_ _N_ _F_ _IF_ARGS_ 0 1 X 4 \ (u0 :: [Integer]) -> _APP_ _TYAPP_ _TYAPP_ _ORIG_ PreludeList scanl { Integer } { Integer } [ _CONSTM_ Num (+) (Integer), _SPEC_ _ORIG_ PreludeCore __i0 [ (Integer) ], u0 ] _N_ }, [ (Complex Double) ] 1 { _A_ 1 _U_ 1 _N_ _N_ _N_ _N_ } #-}
tail :: [a] -> [a]
{-# GHC_PRAGMA _A_ 1 _U_ 1 _N_ _S_ "S" _F_ _IF_ARGS_ 1 1 C 5 _/\_ u0 -> \ (u1 :: [u0]) -> case u1 of { _ALG_ (:) (u2 :: u0) (u3 :: [u0]) -> u3; _NIL_ -> _APP_ _TYAPP_ error { [u0] } [ _NOREP_S_ "tail{PreludeList}: tail []\n" ]; _NO_DEFLT_ } _N_ #-}
take :: Integral a => a -> [b] -> [b]
- {-# GHC_PRAGMA _A_ 3 _U_ 121 _N_ _S_ "U(AAAAAAAAAAAS)LL" {_A_ 3 _U_ 121 _N_ _N_ _N_ _N_} _F_ _IF_ARGS_ 2 3 CXX 7 _/\_ u0 u1 -> \ (u2 :: {{Integral u0}}) (u3 :: u0) (u4 :: [u1]) -> let {(uh :: Int) = case u2 of { _ALG_ _TUP_12 (u5 :: {{Real u0}}) (u6 :: {{Ix u0}}) (u7 :: u0 -> u0 -> u0) (u8 :: u0 -> u0 -> u0) (u9 :: u0 -> u0 -> u0) (ua :: u0 -> u0 -> u0) (ub :: u0 -> u0 -> (u0, u0)) (uc :: u0 -> u0 -> (u0, u0)) (ud :: u0 -> Bool) (ue :: u0 -> Bool) (uf :: u0 -> Integer) (ug :: u0 -> Int) -> _APP_ ug [ u3 ]; _NO_DEFLT_ }} in _APP_ _TYAPP_ _SPEC_ _ORIG_ PreludeList take [ (Int), _N_ ] { u1 } [ uh, u4 ] _SPECIALISE_ [ Int, _N_ ] 1 { _A_ 2 _U_ 11 _N_ _S_ "U(P)L" {_A_ 2 _U_ 21 _N_ _N_ _N_ _N_} _N_ _N_ }, [ Integer, _N_ ] 1 { _A_ 2 _U_ 11 _N_ _S_ "U(PPP)L" {_A_ 4 _U_ 2221 _N_ _N_ _F_ _IF_ARGS_ 1 4 XXXX 4 _/\_ u0 -> \ (u1 :: Int#) (u2 :: Int#) (u3 :: ByteArray#) (u4 :: [u0]) -> case _#_ integer2Int# [] [u1, u2, u3] of { _PRIM_ (u5 :: Int#) -> _APP_ _TYAPP_ _WRKR_ _SPEC_ _ORIG_ PreludeList take [ (Int), _N_ ] { u0 } [ u5, u4 ] } _N_} _F_ _ALWAYS_ _/\_ u0 -> \ (u1 :: Integer) (u2 :: [u0]) -> case u1 of { _ALG_ J# (u3 :: Int#) (u4 :: Int#) (u5 :: ByteArray#) -> case _#_ integer2Int# [] [u3, u4, u5] of { _PRIM_ (u6 :: Int#) -> _APP_ _TYAPP_ _WRKR_ _SPEC_ _ORIG_ PreludeList take [ (Int), _N_ ] { u0 } [ u6, u2 ] }; _NO_DEFLT_ } _N_ } #-}
+ {-# GHC_PRAGMA _A_ 1 _U_ 122 _N_ _S_ "U(LU(U(ASSAAAAA)AAA)AAAALAAAAL)" {_A_ 5 _U_ 2121222 _N_ _N_ _N_ _N_} _N_ _SPECIALISE_ [ Int, _N_ ] 1 { _A_ 2 _U_ 11 _N_ _S_ "U(P)L" {_A_ 2 _U_ 21 _N_ _N_ _N_ _N_} _N_ _N_ }, [ Integer, _N_ ] 1 { _A_ 1 _U_ 12 _N_ _S_ "U(PPP)" {_A_ 3 _U_ 2222 _N_ _N_ _N_ _N_} _N_ _N_ } #-}
takeWhile :: (a -> Bool) -> [a] -> [a]
{-# GHC_PRAGMA _A_ 2 _U_ 21 _N_ _S_ "LS" _F_ _ALWAYS_ _/\_ u0 -> \ (u1 :: u0 -> Bool) (u2 :: [u0]) -> let {(u9 :: _forall_ a$z1 =>(u0 -> a$z1 -> a$z1) -> a$z1 -> a$z1) = _/\_ u3 -> \ (u4 :: u0 -> u3 -> u3) (u5 :: u3) -> let {(u8 :: u0 -> u3 -> u3) = \ (u6 :: u0) (u7 :: u3) -> case _APP_ u1 [ u6 ] of { _ALG_ True -> _APP_ u4 [ u6, u7 ]; False -> u5; _NO_DEFLT_ }} in _APP_ _TYAPP_ _TYAPP_ foldr { u0 } { u3 } [ u8, u5, u2 ]} in _APP_ _TYAPP_ _build { u0 } [ u9 ] _N_ #-}
transpose :: [[a]] -> [[a]]
lex :: [Char] -> [([Char], [Char])]
{-# GHC_PRAGMA _A_ 1 _U_ 2 _N_ _S_ "S" _N_ _N_ #-}
read :: Text a => [Char] -> a
- {-# GHC_PRAGMA _A_ 1 _U_ 12 _N_ _S_ "U(SAAA)" {_A_ 1 _U_ 12 _N_ _N_ _N_ _N_} _N_ _SPECIALISE_ [ Double ] 1 { _A_ 1 _U_ 2 _N_ _N_ _N_ _N_ }, [ Float ] 1 { _A_ 1 _U_ 2 _N_ _N_ _N_ _N_ }, [ Int ] 1 { _A_ 1 _U_ 2 _N_ _N_ _N_ _N_ }, [ Integer ] 1 { _A_ 1 _U_ 2 _N_ _N_ _N_ _N_ } #-}
+ {-# GHC_PRAGMA _A_ 1 _U_ 12 _N_ _S_ "U(SAAA)" {_A_ 1 _U_ 12 _N_ _N_ _N_ _N_} _N_ _SPECIALISE_ [ Bool ] 1 { _A_ 1 _U_ 2 _N_ _N_ _N_ _N_ }, [ Char ] 1 { _A_ 1 _U_ 2 _N_ _N_ _N_ _N_ }, [ Double ] 1 { _A_ 1 _U_ 2 _N_ _N_ _N_ _N_ }, [ Int ] 1 { _A_ 1 _U_ 2 _N_ _N_ _N_ _N_ }, [ Integer ] 1 { _A_ 1 _U_ 2 _N_ _N_ _N_ _N_ }, [ [Bool] ] 1 { _A_ 1 _U_ 2 _N_ _N_ _N_ _N_ }, [ [Char] ] 1 { _A_ 1 _U_ 2 _N_ _N_ _N_ _N_ }, [ [Double] ] 1 { _A_ 1 _U_ 2 _N_ _N_ _N_ _N_ }, [ [Float] ] 1 { _A_ 1 _U_ 2 _N_ _N_ _N_ _N_ }, [ [Int] ] 1 { _A_ 1 _U_ 2 _N_ _N_ _N_ _N_ }, [ [Integer] ] 1 { _A_ 1 _U_ 2 _N_ _N_ _N_ _N_ }, [ [[Char]] ] 1 { _A_ 1 _U_ 2 _N_ _N_ _N_ _N_ }, [ [[Int]] ] 1 { _A_ 1 _U_ 2 _N_ _N_ _N_ _N_ }, [ [Complex Double] ] 1 { _A_ 1 _U_ 2 _N_ _N_ _N_ _N_ }, [ (Ratio Integer) ] 1 { _A_ 1 _U_ 2 _N_ _N_ _N_ _N_ }, [ (Array Int Double) ] 1 { _A_ 1 _U_ 2 _N_ _N_ _N_ _N_ }, [ (Array (Int, Int) Double) ] 1 { _A_ 1 _U_ 2 _N_ _N_ _N_ _N_ }, [ _PackedString ] 1 { _A_ 1 _U_ 2 _N_ _S_ _!_ _N_ _N_ }, [ (Complex Double) ] 1 { _A_ 1 _U_ 2 _N_ _N_ _N_ _N_ }, [ () ] 1 { _A_ 1 _U_ 2 _N_ _N_ _N_ _N_ }, [ (Int, Int) ] 1 { _A_ 1 _U_ 2 _N_ _N_ _N_ _N_ }, [ (Integer, Integer) ] 1 { _A_ 1 _U_ 2 _N_ _N_ _N_ _N_ }, [ (Int, Int, Int) ] 1 { _A_ 1 _U_ 2 _N_ _N_ _N_ _N_ } #-}
readDec :: Integral a => [Char] -> [(a, [Char])]
- {-# GHC_PRAGMA _A_ 1 _U_ 22 _N_ _N_ _N_ _SPECIALISE_ [ Int ] 1 { _A_ 1 _U_ 2 _N_ _N_ _N_ _N_ }, [ Integer ] 1 { _A_ 1 _U_ 2 _N_ _S_ "S" _N_ _N_ } #-}
+ {-# GHC_PRAGMA _A_ 1 _U_ 22 _N_ _N_ _N_ _SPECIALISE_ [ Int ] 1 { _A_ 1 _U_ 2 _N_ _N_ _N_ _N_ }, [ Integer ] 1 { _A_ 1 _U_ 2 _N_ _N_ _N_ _N_ } #-}
readFloat :: RealFloat a => [Char] -> [(a, [Char])]
- {-# GHC_PRAGMA _A_ 2 _U_ 12 _N_ _S_ "LS" _N_ _SPECIALISE_ [ Double ] 1 { _A_ 1 _U_ 2 _N_ _S_ "S" _N_ _N_ }, [ Float ] 1 { _A_ 1 _U_ 2 _N_ _S_ "S" _N_ _N_ } #-}
+ {-# GHC_PRAGMA _A_ 2 _U_ 12 _N_ _S_ "LS" _N_ _SPECIALISE_ [ Double ] 1 { _A_ 1 _U_ 2 _N_ _S_ "S" _N_ _N_ } #-}
readLitChar :: [Char] -> [(Char, [Char])]
{-# GHC_PRAGMA _A_ 0 _U_ 1 _N_ _N_ _N_ _N_ #-}
readParen :: Bool -> ([Char] -> [(a, [Char])]) -> [Char] -> [(a, [Char])]
readSigned :: Real a => ([Char] -> [(a, [Char])]) -> [Char] -> [(a, [Char])]
{-# GHC_PRAGMA _A_ 2 _U_ 122 _N_ _N_ _N_ _SPECIALISE_ [ Double ] 1 { _A_ 1 _U_ 22 _N_ _N_ _N_ _N_ }, [ Int ] 1 { _A_ 1 _U_ 22 _N_ _N_ _N_ _N_ }, [ Integer ] 1 { _A_ 1 _U_ 22 _N_ _N_ _N_ _N_ } #-}
reads :: Text a => [Char] -> [(a, [Char])]
- {-# GHC_PRAGMA _A_ 1 _U_ 12 _N_ _S_ "U(SAAA)" {_A_ 1 _U_ 12 _N_ _N_ _N_ _N_} _N_ _SPECIALISE_ [ Double ] 1 { _A_ 1 _U_ 2 _N_ _N_ _N_ _N_ }, [ Float ] 1 { _A_ 1 _U_ 2 _N_ _N_ _N_ _N_ }, [ Int ] 1 { _A_ 1 _U_ 2 _N_ _N_ _N_ _N_ }, [ Integer ] 1 { _A_ 1 _U_ 2 _N_ _N_ _N_ _N_ } #-}
+ {-# GHC_PRAGMA _A_ 1 _U_ 12 _N_ _S_ "U(SAAA)" {_A_ 1 _U_ 12 _N_ _N_ _N_ _N_} _N_ _SPECIALISE_ [ Bool ] 1 { _A_ 1 _U_ 2 _N_ _N_ _N_ _N_ }, [ Char ] 1 { _A_ 0 _U_ 2 _N_ _N_ _N_ _N_ }, [ Double ] 1 { _A_ 1 _U_ 2 _N_ _N_ _N_ _N_ }, [ Int ] 1 { _A_ 1 _U_ 2 _N_ _N_ _N_ _N_ }, [ Integer ] 1 { _A_ 1 _U_ 2 _N_ _N_ _N_ _N_ }, [ [Bool] ] 1 { _A_ 0 _U_ 2 _N_ _N_ _F_ _IF_ARGS_ 0 0 X 1 _CONSTM_ Text readList (Bool) _N_ }, [ [Char] ] 1 { _A_ 0 _U_ 2 _N_ _N_ _F_ _IF_ARGS_ 0 0 X 1 _CONSTM_ Text readList (Char) _N_ }, [ [Double] ] 1 { _A_ 0 _U_ 2 _N_ _N_ _F_ _IF_ARGS_ 0 0 X 1 _CONSTM_ Text readList (Double) _N_ }, [ [Float] ] 1 { _A_ 0 _U_ 2 _N_ _N_ _N_ _N_ }, [ [Int] ] 1 { _A_ 0 _U_ 2 _N_ _N_ _F_ _IF_ARGS_ 0 0 X 1 _CONSTM_ Text readList (Int) _N_ }, [ [Integer] ] 1 { _A_ 0 _U_ 2 _N_ _N_ _F_ _IF_ARGS_ 0 0 X 1 _CONSTM_ Text readList (Integer) _N_ }, [ [[Char]] ] 1 { _A_ 0 _U_ 2 _N_ _N_ _F_ _IF_ARGS_ 0 0 X 1 _CONSTM_ Text readList ([Char]) _N_ }, [ [[Int]] ] 1 { _A_ 0 _U_ 2 _N_ _N_ _F_ _IF_ARGS_ 0 0 X 1 _CONSTM_ Text readList ([Int]) _N_ }, [ [Complex Double] ] 1 { _A_ 0 _U_ 2 _N_ _N_ _F_ _IF_ARGS_ 0 0 X 1 _CONSTM_ Text readList (Complex Double) _N_ }, [ (Ratio Integer) ] 1 { _A_ 0 _U_ 2 _N_ _N_ _N_ _N_ }, [ (Array Int Double) ] 1 { _A_ 0 _U_ 2 _N_ _N_ _N_ _N_ }, [ (Array (Int, Int) Double) ] 1 { _A_ 0 _U_ 2 _N_ _N_ _N_ _N_ }, [ _PackedString ] 1 { _A_ 1 _U_ 2 _N_ _S_ _!_ _N_ _N_ }, [ (Complex Double) ] 1 { _A_ 0 _U_ 2 _N_ _N_ _N_ _N_ }, [ () ] 1 { _A_ 0 _U_ 2 _N_ _N_ _N_ _N_ }, [ (Int, Int) ] 1 { _A_ 0 _U_ 2 _N_ _N_ _N_ _N_ }, [ (Integer, Integer) ] 1 { _A_ 0 _U_ 2 _N_ _N_ _N_ _N_ }, [ (Int, Int, Int) ] 1 { _A_ 0 _U_ 2 _N_ _N_ _N_ _N_ } #-}
show :: Text a => a -> [Char]
- {-# GHC_PRAGMA _A_ 1 _U_ 12 _N_ _S_ "U(ASAA)" {_A_ 1 _U_ 12 _N_ _N_ _N_ _N_} _N_ _SPECIALISE_ [ Char ] 1 { _A_ 1 _U_ 1 _N_ _S_ "U(P)" {_A_ 1 _U_ 2 _N_ _N_ _N_ _N_} _N_ _N_ }, [ Double ] 1 { _A_ 1 _U_ 1 _N_ _S_ "U(P)" {_A_ 1 _U_ 2 _N_ _N_ _N_ _N_} _N_ _N_ }, [ Float ] 1 { _A_ 1 _U_ 2 _N_ _N_ _N_ _N_ }, [ Int ] 1 { _A_ 1 _U_ 1 _N_ _S_ "U(P)" {_A_ 1 _U_ 2 _N_ _N_ _N_ _N_} _N_ _N_ }, [ Integer ] 1 { _A_ 1 _U_ 1 _N_ _S_ "U(PPP)" {_A_ 3 _U_ 222 _N_ _N_ _N_ _N_} _N_ _N_ }, [ [Char] ] 1 { _A_ 1 _U_ 2 _N_ _N_ _N_ _N_ }, [ _PackedString ] 1 { _A_ 1 _U_ 1 _N_ _N_ _N_ _N_ }, [ (Int, Int) ] 1 { _A_ 1 _U_ 1 _N_ _S_ "U(LL)" {_A_ 2 _U_ 22 _N_ _N_ _N_ _N_} _N_ _N_ }, [ (Integer, Integer) ] 1 { _A_ 1 _U_ 1 _N_ _S_ "U(LL)" {_A_ 2 _U_ 22 _N_ _N_ _N_ _N_} _N_ _N_ } #-}
+ {-# GHC_PRAGMA _A_ 1 _U_ 12 _N_ _S_ "U(ASAA)" {_A_ 1 _U_ 12 _N_ _N_ _N_ _N_} _N_ _SPECIALISE_ [ Bool ] 1 { _A_ 1 _U_ 2 _N_ _S_ "E" _N_ _N_ }, [ Char ] 1 { _A_ 1 _U_ 1 _N_ _S_ "U(P)" {_A_ 1 _U_ 2 _N_ _N_ _N_ _N_} _N_ _N_ }, [ Double ] 1 { _A_ 1 _U_ 1 _N_ _S_ "U(P)" {_A_ 1 _U_ 2 _N_ _N_ _N_ _N_} _N_ _N_ }, [ Int ] 1 { _A_ 1 _U_ 1 _N_ _S_ "U(P)" {_A_ 1 _U_ 2 _N_ _N_ _N_ _N_} _N_ _N_ }, [ Integer ] 1 { _A_ 1 _U_ 1 _N_ _S_ "U(PPP)" {_A_ 3 _U_ 222 _N_ _N_ _N_ _N_} _N_ _N_ }, [ [Bool] ] 1 { _A_ 1 _U_ 1 _N_ _S_ "S" _N_ _N_ }, [ [Char] ] 1 { _A_ 1 _U_ 2 _N_ _N_ _N_ _N_ }, [ [Double] ] 1 { _A_ 1 _U_ 2 _N_ _N_ _N_ _N_ }, [ [Int] ] 1 { _A_ 1 _U_ 2 _N_ _N_ _N_ _N_ }, [ [Integer] ] 1 { _A_ 1 _U_ 2 _N_ _N_ _N_ _N_ }, [ [[Char]] ] 1 { _A_ 1 _U_ 1 _N_ _S_ "S" _N_ _N_ }, [ [[Int]] ] 1 { _A_ 1 _U_ 1 _N_ _S_ "S" _N_ _N_ }, [ [Complex Double] ] 1 { _A_ 1 _U_ 2 _N_ _N_ _N_ _N_ }, [ (Ratio Integer) ] 1 { _A_ 1 _U_ 1 _N_ _S_ "U(LL)" {_A_ 2 _U_ 22 _N_ _N_ _N_ _N_} _N_ _N_ }, [ (Array Int Double) ] 1 { _A_ 1 _U_ 2 _N_ _N_ _N_ _N_ }, [ (Array (Int, Int) Double) ] 1 { _A_ 1 _U_ 2 _N_ _N_ _N_ _N_ }, [ _PackedString ] 1 { _A_ 1 _U_ 1 _N_ _N_ _N_ _N_ }, [ (Complex Double) ] 1 { _A_ 1 _U_ 1 _N_ _S_ "U(LL)" {_A_ 2 _U_ 22 _N_ _N_ _N_ _N_} _N_ _N_ }, [ () ] 1 { _A_ 1 _U_ 1 _N_ _S_ "E" _N_ _N_ }, [ (Int, Int) ] 1 { _A_ 1 _U_ 1 _N_ _S_ "U(LL)" {_A_ 2 _U_ 22 _N_ _N_ _N_ _N_} _N_ _N_ }, [ (Integer, Integer) ] 1 { _A_ 1 _U_ 1 _N_ _S_ "U(LL)" {_A_ 2 _U_ 22 _N_ _N_ _N_ _N_} _N_ _N_ }, [ (Int, Int, Int) ] 1 { _A_ 1 _U_ 1 _N_ _S_ "U(LLL)" {_A_ 3 _U_ 222 _N_ _N_ _N_ _N_} _N_ _N_ } #-}
showChar :: Char -> [Char] -> [Char]
{-# GHC_PRAGMA _A_ 2 _U_ 22 _N_ _N_ _F_ _IF_ARGS_ 0 2 XX 3 \ (u0 :: Char) (u1 :: [Char]) -> _!_ (:) [Char] [u0, u1] _N_ #-}
showFloat :: RealFloat a => a -> [Char] -> [Char]
- {-# GHC_PRAGMA _A_ 1 _U_ 122 _N_ _S_ "U(U(LU(SLLL)LAAAA)LLLALAAAA)" {_A_ 5 _U_ 1122222 _N_ _N_ _N_ _N_} _N_ _SPECIALISE_ [ Double ] 1 { _A_ 1 _U_ 12 _N_ _S_ "U(P)" {_A_ 1 _U_ 22 _N_ _N_ _N_ _N_} _N_ _N_ }, [ Float ] 1 { _A_ 0 _U_ 22 _N_ _N_ _N_ _N_ } #-}
+ {-# GHC_PRAGMA _A_ 1 _U_ 122 _N_ _S_ "U(U(AU(SAAA)AAAAL)LLLALAAAA)" {_A_ 5 _U_ 1122222 _N_ _N_ _N_ _N_} _N_ _SPECIALISE_ [ Double ] 1 { _A_ 1 _U_ 12 _N_ _S_ "U(P)" {_A_ 1 _U_ 22 _N_ _N_ _N_ _N_} _N_ _N_ } #-}
showInt :: Integral a => a -> [Char] -> [Char]
{-# GHC_PRAGMA _A_ 1 _U_ 122 _N_ _S_ "U(U(U(U(SL)LLLLLLLLL)LL)LLLLLSLLLLL)" _N_ _SPECIALISE_ [ Int ] 1 { _A_ 2 _U_ 12 _N_ _S_ "U(P)L" {_A_ 2 _U_ 22 _N_ _N_ _N_ _N_} _N_ _N_ }, [ Integer ] 1 { _A_ 2 _U_ 12 _N_ _S_ "U(PPP)L" {_A_ 4 _U_ 2222 _N_ _N_ _N_ _N_} _N_ _N_ } #-}
showLitChar :: Char -> [Char] -> [Char]
showString :: [Char] -> [Char] -> [Char]
{-# GHC_PRAGMA _A_ 2 _U_ 12 _N_ _N_ _F_ _IF_ARGS_ 0 0 X 1 _TYAPP_ _ORIG_ PreludeList (++) { Char } _N_ #-}
shows :: Text a => a -> [Char] -> [Char]
- {-# GHC_PRAGMA _A_ 1 _U_ 122 _N_ _S_ "U(ASAA)" {_A_ 1 _U_ 122 _N_ _N_ _N_ _N_} _N_ _SPECIALISE_ [ Char ] 1 { _A_ 2 _U_ 12 _N_ _S_ "U(P)L" {_A_ 2 _U_ 22 _N_ _N_ _N_ _N_} _N_ _N_ }, [ Double ] 1 { _A_ 1 _U_ 12 _N_ _S_ "U(P)" {_A_ 1 _U_ 22 _N_ _N_ _N_ _N_} _N_ _N_ }, [ Float ] 1 { _A_ 0 _U_ 22 _N_ _N_ _N_ _N_ }, [ Int ] 1 { _A_ 2 _U_ 12 _N_ _S_ "U(P)L" {_A_ 2 _U_ 22 _N_ _N_ _N_ _N_} _N_ _N_ }, [ Integer ] 1 { _A_ 2 _U_ 12 _N_ _S_ "U(PPP)L" {_A_ 4 _U_ 2222 _N_ _N_ _N_ _N_} _N_ _N_ }, [ [Char] ] 1 { _A_ 1 _U_ 22 _N_ _N_ _F_ _IF_ARGS_ 0 0 X 1 _CONSTM_ Text showList (Char) _N_ }, [ _PackedString ] 1 { _A_ 2 _U_ 12 _N_ _N_ _N_ _N_ }, [ (Int, Int) ] 1 { _A_ 2 _U_ 12 _N_ _S_ "U(LL)L" {_A_ 3 _U_ 222 _N_ _N_ _N_ _N_} _N_ _N_ }, [ (Integer, Integer) ] 1 { _A_ 2 _U_ 12 _N_ _S_ "U(LL)L" {_A_ 3 _U_ 222 _N_ _N_ _N_ _N_} _N_ _N_ } #-}
+ {-# GHC_PRAGMA _A_ 1 _U_ 122 _N_ _S_ "U(ASAA)" {_A_ 1 _U_ 122 _N_ _N_ _N_ _N_} _N_ _SPECIALISE_ [ Bool ] 1 { _A_ 2 _U_ 22 _N_ _N_ _N_ _N_ }, [ Char ] 1 { _A_ 2 _U_ 12 _N_ _S_ "U(P)L" {_A_ 2 _U_ 22 _N_ _N_ _N_ _N_} _N_ _N_ }, [ Double ] 1 { _A_ 1 _U_ 12 _N_ _S_ "U(P)" {_A_ 1 _U_ 22 _N_ _N_ _N_ _N_} _N_ _N_ }, [ Int ] 1 { _A_ 2 _U_ 12 _N_ _S_ "U(P)L" {_A_ 2 _U_ 22 _N_ _N_ _N_ _N_} _N_ _N_ }, [ Integer ] 1 { _A_ 2 _U_ 12 _N_ _S_ "U(PPP)L" {_A_ 4 _U_ 2222 _N_ _N_ _N_ _N_} _N_ _N_ }, [ [Bool] ] 1 { _A_ 1 _U_ 12 _N_ _S_ "S" _F_ _IF_ARGS_ 0 1 X 3 \ (u0 :: [Bool]) -> _APP_ _TYAPP_ _ORIG_ PreludeCore _showList { Bool } [ _WRKR_ _CONSTM_ Text showsPrec (Bool), u0 ] _N_ }, [ [Char] ] 1 { _A_ 1 _U_ 22 _N_ _N_ _F_ _IF_ARGS_ 0 0 X 1 _CONSTM_ Text showList (Char) _N_ }, [ [Double] ] 1 { _A_ 1 _U_ 22 _N_ _N_ _F_ _IF_ARGS_ 0 0 X 1 _CONSTM_ Text showList (Double) _N_ }, [ [Int] ] 1 { _A_ 1 _U_ 22 _N_ _N_ _F_ _IF_ARGS_ 0 0 X 1 _CONSTM_ Text showList (Int) _N_ }, [ [Integer] ] 1 { _A_ 1 _U_ 22 _N_ _N_ _F_ _IF_ARGS_ 0 0 X 1 _CONSTM_ Text showList (Integer) _N_ }, [ [[Char]] ] 1 { _A_ 1 _U_ 12 _N_ _S_ "S" _F_ _IF_ARGS_ 0 1 X 3 \ (u0 :: [[Char]]) -> _APP_ _TYAPP_ _ORIG_ PreludeCore _showList { [Char] } [ _CONSTM_ Text showList (Char), u0 ] _N_ }, [ [[Int]] ] 1 { _A_ 1 _U_ 12 _N_ _S_ "S" _F_ _IF_ARGS_ 0 1 X 3 \ (u0 :: [[Int]]) -> _APP_ _TYAPP_ _ORIG_ PreludeCore _showList { [Int] } [ _CONSTM_ Text showList (Int), u0 ] _N_ }, [ [Complex Double] ] 1 { _A_ 1 _U_ 22 _N_ _N_ _F_ _IF_ARGS_ 0 0 X 1 _CONSTM_ Text showList (Complex Double) _N_ }, [ (Ratio Integer) ] 1 { _A_ 1 _U_ 12 _N_ _S_ "U(LL)" {_A_ 2 _U_ 222 _N_ _N_ _N_ _N_} _N_ _N_ }, [ (Array Int Double) ] 1 { _A_ 1 _U_ 22 _N_ _N_ _N_ _N_ }, [ (Array (Int, Int) Double) ] 1 { _A_ 1 _U_ 22 _N_ _N_ _N_ _N_ }, [ _PackedString ] 1 { _A_ 2 _U_ 12 _N_ _N_ _N_ _N_ }, [ (Complex Double) ] 1 { _A_ 1 _U_ 12 _N_ _S_ "U(LL)" {_A_ 2 _U_ 222 _N_ _N_ _N_ _N_} _N_ _N_ }, [ () ] 1 { _A_ 2 _U_ 12 _N_ _S_ "EL" _F_ _IF_ARGS_ 0 2 CX 4 \ (u0 :: ()) (u1 :: [Char]) -> case u0 of { _ALG_ _TUP_0 -> _APP_ _TYAPP_ _ORIG_ PreludeList (++) { Char } [ _NOREP_S_ "()", u1 ]; _NO_DEFLT_ } _N_ }, [ (Int, Int) ] 1 { _A_ 2 _U_ 12 _N_ _S_ "U(LL)L" {_A_ 3 _U_ 222 _N_ _N_ _N_ _N_} _N_ _N_ }, [ (Integer, Integer) ] 1 { _A_ 2 _U_ 12 _N_ _S_ "U(LL)L" {_A_ 3 _U_ 222 _N_ _N_ _N_ _N_} _N_ _N_ }, [ (Int, Int, Int) ] 1 { _A_ 2 _U_ 12 _N_ _S_ "U(LLL)L" {_A_ 4 _U_ 2222 _N_ _N_ _N_ _N_} _N_ _N_ } #-}
-{-# GHC_PRAGMA INTERFACE VERSION 5 #-}
+{-# GHC_PRAGMA INTERFACE VERSION 6 #-}
interface Prelude where
import PreludeArray((!), (//), Array, Assoc, _ByteArray, accum, accumArray, amap, array, assocs, bounds, elems, indices, ixmap, listArray)
import PreludeBuiltin(Bin, Char(..), Int(..), Integer(..), List(..), Tuple0, Tuple2, Tuple3, Tuple4, Tuple5, Tuple6, Tuple7, _Addr(..), _RealWorld(..), _State(..))
import PreludeComplex(Complex, cis, conjugate, imagPart, magnitude, mkPolar, phase, polar, realPart)
-import PreludeCore(Bool(..), Eq(..), Fractional(..), Integral(..), Ix(..), Num(..), Ord(..), Real(..), RealFloat(..), RealFrac(..), Text(..), _ceiling, _floor, _readList, _round, _showList, _showRational, _truncate)
+import PreludeCore(Bool(..), Eq(..), Fractional(..), Integral(..), Ix(..), Num(..), Ord(..), Real(..), RealFloat(..), RealFrac(..), Text(..), _readList, _showList, _showRational)
import PreludeIO(IOError, Request, Response, SigAct, abort, appendBinChan, appendBinFile, appendChan, appendFile, binDispatch, deleteFile, done, echo, exit, getArgs, getEnv, getProgName, interact, print, prints, readBinChan, readBinFile, readChan, readFile, setEnv, sigAction, statusChan, statusFile, stdecho, stderr, stdin, stdout, strDispatch, strListDispatch, succDispatch, writeBinFile, writeFile)
import PreludeList((!!), (++), (\\), all, and, any, break, concat, cycle, drop, dropWhile, elem, filter, foldl1, foldr1, genericLength, head, init, iterate, last, length, lines, map, maximum, minimum, notElem, nub, null, or, partition, product, products, repeat, reverse, scanl, scanl1, scanr, scanr1, span, splitAt, sum, sums, tail, take, takeWhile, transpose, unlines, unwords, unzip, unzip3, unzip4, unzip5, unzip6, unzip7, words, zip, zip3, zip4, zip5, zip6, zip7, zipWith, zipWith3, zipWith4, zipWith5, zipWith6, zipWith7)
import PreludePS(_PackedString, _appendPS, _breakPS, _byteArrayToPS, _concatPS, _consPS, _dropPS, _dropWhilePS, _filterPS, _foldlPS, _foldrPS, _headPS, _indexPS, _lengthPS, _linesPS, _mapPS, _nilPS, _nullPS, _packCBytes, _packCString, _packString, _psToByteArray, _putPS, _reversePS, _spanPS, _splitAtPS, _substrPS, _tailPS, _takePS, _takeWhilePS, _unpackPS, _wordsPS)
(.) :: (a -> c) -> (b -> a) -> b -> c
{-# GHC_PRAGMA _A_ 3 _U_ 112 _N_ _S_ "SLL" _F_ _ALWAYS_ _/\_ u0 u1 u2 -> \ (u3 :: u0 -> u2) (u4 :: u1 -> u0) (u5 :: u1) -> let {(u6 :: u0) = _APP_ u4 [ u5 ]} in _APP_ u3 [ u6 ] _N_ #-}
(^) :: (Num b, Integral a) => b -> a -> b
- {-# GHC_PRAGMA _A_ 2 _U_ 2122 _N_ _S_ "LU(U(LU(U(U(SA)AALAAAA)AAAA)A)AAALAAAALAA)" {_A_ 5 _U_ 2212222 _N_ _N_ _N_ _N_} _N_ _SPECIALISE_ [ Int, Double ] 2 { _A_ 2 _U_ 21 _N_ _S_ "LU(P)" {_A_ 2 _U_ 22 _N_ _N_ _N_ _N_} _N_ _N_ }, [ Int, Int ] 2 { _A_ 2 _U_ 21 _N_ _S_ "LU(P)" {_A_ 2 _U_ 22 _N_ _N_ _N_ _N_} _N_ _N_ }, [ Int, Integer ] 2 { _A_ 2 _U_ 21 _N_ _S_ "LU(P)" {_A_ 2 _U_ 22 _N_ _N_ _N_ _N_} _N_ _N_ }, [ Int, (Ratio Integer) ] 2 { _A_ 2 _U_ 21 _N_ _S_ "LU(P)" {_A_ 2 _U_ 22 _N_ _N_ _N_ _N_} _N_ _N_ }, [ Int, (Complex Double) ] 2 { _A_ 2 _U_ 21 _N_ _S_ "LU(P)" {_A_ 2 _U_ 22 _N_ _N_ _N_ _N_} _N_ _N_ } #-}
+ {-# GHC_PRAGMA _A_ 2 _U_ 2122 _N_ _S_ "LU(U(LU(U(U(SL)LLLLLLL)LLLL)L)LLLLLLLLLLL)" _N_ _SPECIALISE_ [ Int, Double ] 2 { _A_ 2 _U_ 21 _N_ _S_ "LU(P)" {_A_ 2 _U_ 22 _N_ _N_ _N_ _N_} _N_ _N_ }, [ Int, Int ] 2 { _A_ 2 _U_ 21 _N_ _S_ "LU(P)" {_A_ 2 _U_ 22 _N_ _N_ _N_ _N_} _N_ _N_ }, [ Int, Integer ] 2 { _A_ 2 _U_ 21 _N_ _S_ "LU(P)" {_A_ 2 _U_ 22 _N_ _N_ _N_ _N_} _N_ _N_ }, [ Int, (Ratio Integer) ] 2 { _A_ 2 _U_ 21 _N_ _S_ "LU(P)" {_A_ 2 _U_ 22 _N_ _N_ _N_ _N_} _N_ _N_ }, [ Int, (Complex Double) ] 2 { _A_ 2 _U_ 21 _N_ _S_ "LU(P)" {_A_ 2 _U_ 22 _N_ _N_ _N_ _N_} _N_ _N_ }, [ Integer, Integer ] 2 { _A_ 2 _U_ 21 _N_ _S_ "LU(PPP)" {_A_ 4 _U_ 2222 _N_ _N_ _N_ _N_} _N_ _N_ } #-}
(^^) :: (Fractional b, Integral a) => b -> a -> b
- {-# GHC_PRAGMA _A_ 2 _U_ 2122 _N_ _S_ "LU(LU(U(AAASAAAA)AAA)AALAAAALAA)" {_A_ 5 _U_ 2212222 _N_ _N_ _N_ _N_} _N_ _SPECIALISE_ [ Int, Double ] 2 { _A_ 2 _U_ 21 _N_ _S_ "LU(P)" {_A_ 2 _U_ 22 _N_ _N_ _N_ _N_} _N_ _N_ }, [ Int, (Ratio Integer) ] 2 { _A_ 2 _U_ 21 _N_ _S_ "LU(P)" {_A_ 2 _U_ 22 _N_ _N_ _N_ _N_} _N_ _N_ } #-}
+ {-# GHC_PRAGMA _A_ 2 _U_ 2222 _N_ _S_ "LU(LU(U(LLLSLLLL)LLL)LLLLLLLLLL)" _N_ _SPECIALISE_ [ Int, Double ] 2 { _A_ 2 _U_ 21 _N_ _S_ "LU(P)" {_A_ 2 _U_ 22 _N_ _N_ _N_ _N_} _N_ _N_ }, [ Int, (Ratio Integer) ] 2 { _A_ 2 _U_ 21 _N_ _S_ "LU(P)" {_A_ 2 _U_ 22 _N_ _N_ _N_ _N_} _N_ _N_ }, [ Int, (Complex Double) ] 2 { _A_ 2 _U_ 21 _N_ _S_ "LU(P)" {_A_ 2 _U_ 22 _N_ _N_ _N_ _N_} _N_ _N_ } #-}
appendBin :: Bin -> Bin -> Bin
- {-# GHC_PRAGMA _A_ 2 _U_ 22 _N_ _S_ _!_ _F_ _IF_ARGS_ 0 2 XX 4 \ (u0 :: Bin) (u1 :: Bin) -> _APP_ _TYAPP_ error { (Bin -> Bin -> Bin) } [ _NOREP_S_ "appendBin{Prelude}\n", u0, u1 ] _N_ #-}
+ {-# GHC_PRAGMA _A_ 2 _U_ 22 _N_ _S_ _!_ _N_ _N_ #-}
asTypeOf :: a -> a -> a
{-# GHC_PRAGMA _A_ 2 _U_ 10 _N_ _N_ _F_ _IF_ARGS_ 1 0 X 1 _/\_ u0 -> _TYAPP_ _TYAPP_ _ORIG_ Prelude const { u0 } { u0 } _N_ #-}
atan2 :: RealFloat a => a -> a -> a
flip :: (b -> a -> c) -> a -> b -> c
{-# GHC_PRAGMA _A_ 3 _U_ 122 _N_ _S_ "SLL" _F_ _IF_ARGS_ 3 3 XXX 3 _/\_ u0 u1 u2 -> \ (u3 :: u1 -> u0 -> u2) (u4 :: u0) (u5 :: u1) -> _APP_ u3 [ u5, u4 ] _N_ #-}
fromIntegral :: (Integral a, Num b) => a -> b
- {-# GHC_PRAGMA _A_ 3 _U_ 112 _N_ _S_ "LU(AAAAAAAASA)L" {_A_ 3 _U_ 112 _N_ _N_ _F_ _IF_ARGS_ 2 3 CXX 6 _/\_ u0 u1 -> \ (u2 :: {{Integral u0}}) (u3 :: Integer -> u1) (u4 :: u0) -> let {(uh :: Integer) = case u2 of { _ALG_ _TUP_12 (u5 :: {{Real u0}}) (u6 :: {{Ix u0}}) (u7 :: u0 -> u0 -> u0) (u8 :: u0 -> u0 -> u0) (u9 :: u0 -> u0 -> u0) (ua :: u0 -> u0 -> u0) (ub :: u0 -> u0 -> (u0, u0)) (uc :: u0 -> u0 -> (u0, u0)) (ud :: u0 -> Bool) (ue :: u0 -> Bool) (uf :: u0 -> Integer) (ug :: u0 -> Int) -> _APP_ uf [ u4 ]; _NO_DEFLT_ }} in _APP_ u3 [ uh ] _N_} _F_ _IF_ARGS_ 2 3 CCX 7 _/\_ u0 u1 -> \ (u2 :: {{Integral u0}}) (u3 :: {{Num u1}}) (u4 :: u0) -> let {(uh :: Integer) = case u2 of { _ALG_ _TUP_12 (u5 :: {{Real u0}}) (u6 :: {{Ix u0}}) (u7 :: u0 -> u0 -> u0) (u8 :: u0 -> u0 -> u0) (u9 :: u0 -> u0 -> u0) (ua :: u0 -> u0 -> u0) (ub :: u0 -> u0 -> (u0, u0)) (uc :: u0 -> u0 -> (u0, u0)) (ud :: u0 -> Bool) (ue :: u0 -> Bool) (uf :: u0 -> Integer) (ug :: u0 -> Int) -> _APP_ uf [ u4 ]; _NO_DEFLT_ }} in case u3 of { _ALG_ _TUP_10 (ui :: {{Eq u1}}) (uj :: {{Text u1}}) (uk :: u1 -> u1 -> u1) (ul :: u1 -> u1 -> u1) (um :: u1 -> u1 -> u1) (un :: u1 -> u1) (uo :: u1 -> u1) (up :: u1 -> u1) (uq :: Integer -> u1) (ur :: Int -> u1) -> _APP_ uq [ uh ]; _NO_DEFLT_ } _SPECIALISE_ [ Int, Double ] 2 { _A_ 1 _U_ 1 _N_ _S_ "U(P)" {_A_ 1 _U_ 2 _N_ _N_ _F_ _IF_ARGS_ 0 1 X 3 \ (u0 :: Int#) -> case _#_ int2Double# [] [u0] of { _PRIM_ (u1 :: Double#) -> _!_ D# [] [u1] } _N_} _F_ _IF_ARGS_ 0 1 C 4 \ (u0 :: Int) -> case u0 of { _ALG_ I# (u1 :: Int#) -> case _#_ int2Double# [] [u1] of { _PRIM_ (u2 :: Double#) -> _!_ D# [] [u2] }; _NO_DEFLT_ } _N_ }, [ Int, Int ] 2 { _A_ 1 _U_ 1 _N_ _N_ _F_ _IF_ARGS_ 0 0 X 1 _TYAPP_ _ORIG_ Prelude id { Int } _N_ }, [ Int, Integer ] 2 { _A_ 1 _U_ 1 _N_ _S_ "U(P)" {_A_ 1 _U_ 2 _N_ _N_ _F_ _IF_ARGS_ 0 1 X 1 \ (u0 :: Int#) -> _#_ int2Integer# [] [u0] _N_} _F_ _IF_ARGS_ 0 1 C 2 \ (u0 :: Int) -> case u0 of { _ALG_ I# (u1 :: Int#) -> _#_ int2Integer# [] [u1]; _NO_DEFLT_ } _N_ }, [ Integer, Double ] 2 { _A_ 1 _U_ 1 _N_ _S_ "U(PPP)" {_A_ 3 _U_ 222 _N_ _N_ _F_ _IF_ARGS_ 0 3 XXX 3 \ (u0 :: Int#) (u1 :: Int#) (u2 :: ByteArray#) -> case _#_ encodeDouble# [] [u0, u1, u2, 0#] of { _PRIM_ (u3 :: Double#) -> _!_ D# [] [u3] } _N_} _F_ _IF_ARGS_ 0 1 C 4 \ (u0 :: Integer) -> case u0 of { _ALG_ J# (u1 :: Int#) (u2 :: Int#) (u3 :: ByteArray#) -> case _#_ encodeDouble# [] [u1, u2, u3, 0#] of { _PRIM_ (u4 :: Double#) -> _!_ D# [] [u4] }; _NO_DEFLT_ } _N_ }, [ Integer, Int ] 2 { _A_ 1 _U_ 1 _N_ _S_ "U(PPP)" {_A_ 3 _U_ 222 _N_ _N_ _F_ _IF_ARGS_ 0 3 XXX 3 \ (u0 :: Int#) (u1 :: Int#) (u2 :: ByteArray#) -> case _#_ integer2Int# [] [u0, u1, u2] of { _PRIM_ (u3 :: Int#) -> _!_ I# [] [u3] } _N_} _F_ _IF_ARGS_ 0 1 C 4 \ (u0 :: Integer) -> case u0 of { _ALG_ J# (u1 :: Int#) (u2 :: Int#) (u3 :: ByteArray#) -> case _#_ integer2Int# [] [u1, u2, u3] of { _PRIM_ (u4 :: Int#) -> _!_ I# [] [u4] }; _NO_DEFLT_ } _N_ }, [ Integer, Integer ] 2 { _A_ 1 _U_ 1 _N_ _N_ _F_ _IF_ARGS_ 0 0 X 1 _TYAPP_ _ORIG_ Prelude id { Integer } _N_ } #-}
+ {-# GHC_PRAGMA _A_ 3 _U_ 112 _N_ _S_ "LU(AAAAAAAASA)L" {_A_ 3 _U_ 112 _N_ _N_ _F_ _IF_ARGS_ 2 3 CXX 6 _/\_ u0 u1 -> \ (u2 :: {{Integral u0}}) (u3 :: Integer -> u1) (u4 :: u0) -> let {(uh :: Integer) = case u2 of { _ALG_ _TUP_12 (u5 :: {{Real u0}}) (u6 :: {{Ix u0}}) (u7 :: u0 -> u0 -> u0) (u8 :: u0 -> u0 -> u0) (u9 :: u0 -> u0 -> u0) (ua :: u0 -> u0 -> u0) (ub :: u0 -> u0 -> (u0, u0)) (uc :: u0 -> u0 -> (u0, u0)) (ud :: u0 -> Bool) (ue :: u0 -> Bool) (uf :: u0 -> Integer) (ug :: u0 -> Int) -> _APP_ uf [ u4 ]; _NO_DEFLT_ }} in _APP_ u3 [ uh ] _N_} _F_ _IF_ARGS_ 2 3 CCX 7 _/\_ u0 u1 -> \ (u2 :: {{Integral u0}}) (u3 :: {{Num u1}}) (u4 :: u0) -> let {(uh :: Integer) = case u2 of { _ALG_ _TUP_12 (u5 :: {{Real u0}}) (u6 :: {{Ix u0}}) (u7 :: u0 -> u0 -> u0) (u8 :: u0 -> u0 -> u0) (u9 :: u0 -> u0 -> u0) (ua :: u0 -> u0 -> u0) (ub :: u0 -> u0 -> (u0, u0)) (uc :: u0 -> u0 -> (u0, u0)) (ud :: u0 -> Bool) (ue :: u0 -> Bool) (uf :: u0 -> Integer) (ug :: u0 -> Int) -> _APP_ uf [ u4 ]; _NO_DEFLT_ }} in case u3 of { _ALG_ _TUP_10 (ui :: {{Eq u1}}) (uj :: {{Text u1}}) (uk :: u1 -> u1 -> u1) (ul :: u1 -> u1 -> u1) (um :: u1 -> u1 -> u1) (un :: u1 -> u1) (uo :: u1 -> u1) (up :: u1 -> u1) (uq :: Integer -> u1) (ur :: Int -> u1) -> _APP_ uq [ uh ]; _NO_DEFLT_ } _SPECIALISE_ [ Int, Double ] 2 { _A_ 1 _U_ 1 _N_ _S_ "U(P)" {_A_ 1 _U_ 2 _N_ _N_ _F_ _IF_ARGS_ 0 1 X 3 \ (u0 :: Int#) -> case _#_ int2Double# [] [u0] of { _PRIM_ (u1 :: Double#) -> _!_ D# [] [u1] } _N_} _F_ _IF_ARGS_ 0 1 C 4 \ (u0 :: Int) -> case u0 of { _ALG_ I# (u1 :: Int#) -> case _#_ int2Double# [] [u1] of { _PRIM_ (u2 :: Double#) -> _!_ D# [] [u2] }; _NO_DEFLT_ } _N_ }, [ Int, Float ] 2 { _A_ 1 _U_ 1 _N_ _S_ "U(P)" {_A_ 1 _U_ 2 _N_ _N_ _F_ _IF_ARGS_ 0 1 X 3 \ (u0 :: Int#) -> case _#_ int2Float# [] [u0] of { _PRIM_ (u1 :: Float#) -> _!_ F# [] [u1] } _N_} _F_ _IF_ARGS_ 0 1 C 4 \ (u0 :: Int) -> case u0 of { _ALG_ I# (u1 :: Int#) -> case _#_ int2Float# [] [u1] of { _PRIM_ (u2 :: Float#) -> _!_ F# [] [u2] }; _NO_DEFLT_ } _N_ }, [ Int, Int ] 2 { _A_ 1 _U_ 1 _N_ _N_ _F_ _IF_ARGS_ 0 0 X 1 _TYAPP_ _ORIG_ Prelude id { Int } _N_ }, [ Int, Integer ] 2 { _A_ 1 _U_ 1 _N_ _S_ "U(P)" {_A_ 1 _U_ 2 _N_ _N_ _F_ _IF_ARGS_ 0 1 X 1 \ (u0 :: Int#) -> _#_ int2Integer# [] [u0] _N_} _F_ _IF_ARGS_ 0 1 C 2 \ (u0 :: Int) -> case u0 of { _ALG_ I# (u1 :: Int#) -> _#_ int2Integer# [] [u1]; _NO_DEFLT_ } _N_ }, [ Int, (Ratio Integer) ] 2 { _A_ 1 _U_ 1 _N_ _N_ _N_ _N_ }, [ Integer, Double ] 2 { _A_ 1 _U_ 1 _N_ _S_ "U(PPP)" {_A_ 3 _U_ 222 _N_ _N_ _F_ _IF_ARGS_ 0 3 XXX 3 \ (u0 :: Int#) (u1 :: Int#) (u2 :: ByteArray#) -> case _#_ encodeDouble# [] [u0, u1, u2, 0#] of { _PRIM_ (u3 :: Double#) -> _!_ D# [] [u3] } _N_} _F_ _IF_ARGS_ 0 1 C 4 \ (u0 :: Integer) -> case u0 of { _ALG_ J# (u1 :: Int#) (u2 :: Int#) (u3 :: ByteArray#) -> case _#_ encodeDouble# [] [u1, u2, u3, 0#] of { _PRIM_ (u4 :: Double#) -> _!_ D# [] [u4] }; _NO_DEFLT_ } _N_ }, [ Integer, Float ] 2 { _A_ 1 _U_ 1 _N_ _S_ "U(PPP)" {_A_ 3 _U_ 222 _N_ _N_ _F_ _IF_ARGS_ 0 3 XXX 3 \ (u0 :: Int#) (u1 :: Int#) (u2 :: ByteArray#) -> case _#_ encodeFloat# [] [u0, u1, u2, 0#] of { _PRIM_ (u3 :: Float#) -> _!_ F# [] [u3] } _N_} _F_ _IF_ARGS_ 0 1 C 4 \ (u0 :: Integer) -> case u0 of { _ALG_ J# (u1 :: Int#) (u2 :: Int#) (u3 :: ByteArray#) -> case _#_ encodeFloat# [] [u1, u2, u3, 0#] of { _PRIM_ (u4 :: Float#) -> _!_ F# [] [u4] }; _NO_DEFLT_ } _N_ }, [ Integer, Int ] 2 { _A_ 1 _U_ 1 _N_ _S_ "U(PPP)" {_A_ 3 _U_ 222 _N_ _N_ _F_ _IF_ARGS_ 0 3 XXX 3 \ (u0 :: Int#) (u1 :: Int#) (u2 :: ByteArray#) -> case _#_ integer2Int# [] [u0, u1, u2] of { _PRIM_ (u3 :: Int#) -> _!_ I# [] [u3] } _N_} _F_ _IF_ARGS_ 0 1 C 4 \ (u0 :: Integer) -> case u0 of { _ALG_ J# (u1 :: Int#) (u2 :: Int#) (u3 :: ByteArray#) -> case _#_ integer2Int# [] [u1, u2, u3] of { _PRIM_ (u4 :: Int#) -> _!_ I# [] [u4] }; _NO_DEFLT_ } _N_ }, [ Integer, Integer ] 2 { _A_ 1 _U_ 1 _N_ _N_ _F_ _IF_ARGS_ 0 0 X 1 _TYAPP_ _ORIG_ Prelude id { Integer } _N_ }, [ Integer, (Ratio Integer) ] 2 { _A_ 1 _U_ 2 _N_ _N_ _F_ _IF_ARGS_ 0 1 X 3 \ (u0 :: Integer) -> _!_ (:%) [Integer] [u0, _SPEC_ _ORIG_ PreludeCore __i1 [ (Integer) ]] _N_ } #-}
fromRealFrac :: (RealFrac a, Fractional b) => a -> b
- {-# GHC_PRAGMA _A_ 3 _U_ 112 _N_ _S_ "LU(AAAS)L" {_A_ 3 _U_ 112 _N_ _N_ _F_ _IF_ARGS_ 2 3 CXX 7 _/\_ u0 u1 -> \ (u2 :: {{RealFrac u0}}) (u3 :: Ratio Integer -> u1) (u4 :: u0) -> let {(uf :: Ratio Integer) = case u2 of { _ALG_ _TUP_7 (u5 :: {{Real u0}}) (u6 :: {{Fractional u0}}) (u7 :: _forall_ a$z1 =>{{Integral a$z1}} -> u0 -> (a$z1, u0)) (u8 :: _forall_ a$z1 =>{{Integral a$z1}} -> u0 -> a$z1) (u9 :: _forall_ a$z1 =>{{Integral a$z1}} -> u0 -> a$z1) (ua :: _forall_ a$z1 =>{{Integral a$z1}} -> u0 -> a$z1) (ub :: _forall_ a$z1 =>{{Integral a$z1}} -> u0 -> a$z1) -> case u5 of { _ALG_ _TUP_3 (uc :: {{Num u0}}) (ud :: {{Enum u0}}) (ue :: u0 -> Ratio Integer) -> _APP_ ue [ u4 ]; _NO_DEFLT_ }; _NO_DEFLT_ }} in _APP_ u3 [ uf ] _N_} _F_ _IF_ARGS_ 2 3 CCX 8 _/\_ u0 u1 -> \ (u2 :: {{RealFrac u0}}) (u3 :: {{Fractional u1}}) (u4 :: u0) -> let {(uf :: Ratio Integer) = case u2 of { _ALG_ _TUP_7 (u5 :: {{Real u0}}) (u6 :: {{Fractional u0}}) (u7 :: _forall_ a$z1 =>{{Integral a$z1}} -> u0 -> (a$z1, u0)) (u8 :: _forall_ a$z1 =>{{Integral a$z1}} -> u0 -> a$z1) (u9 :: _forall_ a$z1 =>{{Integral a$z1}} -> u0 -> a$z1) (ua :: _forall_ a$z1 =>{{Integral a$z1}} -> u0 -> a$z1) (ub :: _forall_ a$z1 =>{{Integral a$z1}} -> u0 -> a$z1) -> case u5 of { _ALG_ _TUP_3 (uc :: {{Num u0}}) (ud :: {{Enum u0}}) (ue :: u0 -> Ratio Integer) -> _APP_ ue [ u4 ]; _NO_DEFLT_ }; _NO_DEFLT_ }} in case u3 of { _ALG_ _TUP_4 (ug :: {{Num u1}}) (uh :: u1 -> u1 -> u1) (ui :: u1 -> u1) (uj :: Ratio Integer -> u1) -> _APP_ uj [ uf ]; _NO_DEFLT_ } _SPECIALISE_ [ Double, Double ] 2 { _A_ 1 _U_ 1 _N_ _N_ _F_ _IF_ARGS_ 0 0 X 1 _TYAPP_ _ORIG_ Prelude id { Double } _N_ }, [ Double, Float ] 2 { _A_ 1 _U_ 1 _N_ _S_ "U(P)" {_A_ 1 _U_ 2 _N_ _N_ _F_ _IF_ARGS_ 0 1 X 3 \ (u0 :: Double#) -> case _#_ double2Float# [] [u0] of { _PRIM_ (u1 :: Float#) -> _!_ F# [] [u1] } _N_} _F_ _IF_ARGS_ 0 1 C 4 \ (u0 :: Double) -> case u0 of { _ALG_ D# (u1 :: Double#) -> case _#_ double2Float# [] [u1] of { _PRIM_ (u2 :: Float#) -> _!_ F# [] [u2] }; _NO_DEFLT_ } _N_ }, [ Float, Double ] 2 { _A_ 1 _U_ 1 _N_ _S_ "U(P)" {_A_ 1 _U_ 2 _N_ _N_ _F_ _IF_ARGS_ 0 1 X 3 \ (u0 :: Float#) -> case _#_ float2Double# [] [u0] of { _PRIM_ (u1 :: Double#) -> _!_ D# [] [u1] } _N_} _F_ _IF_ARGS_ 0 1 C 4 \ (u0 :: Float) -> case u0 of { _ALG_ F# (u1 :: Float#) -> case _#_ float2Double# [] [u1] of { _PRIM_ (u2 :: Double#) -> _!_ D# [] [u2] }; _NO_DEFLT_ } _N_ }, [ Float, Float ] 2 { _A_ 1 _U_ 1 _N_ _N_ _F_ _IF_ARGS_ 0 0 X 1 _TYAPP_ _ORIG_ Prelude id { Float } _N_ } #-}
+ {-# GHC_PRAGMA _A_ 3 _U_ 112 _N_ _S_ "LU(AAAS)L" {_A_ 3 _U_ 112 _N_ _N_ _F_ _IF_ARGS_ 2 3 CXX 7 _/\_ u0 u1 -> \ (u2 :: {{RealFrac u0}}) (u3 :: Ratio Integer -> u1) (u4 :: u0) -> let {(uf :: Ratio Integer) = case u2 of { _ALG_ _TUP_7 (u5 :: {{Real u0}}) (u6 :: {{Fractional u0}}) (u7 :: _forall_ a$z1 =>{{Integral a$z1}} -> u0 -> (a$z1, u0)) (u8 :: _forall_ a$z1 =>{{Integral a$z1}} -> u0 -> a$z1) (u9 :: _forall_ a$z1 =>{{Integral a$z1}} -> u0 -> a$z1) (ua :: _forall_ a$z1 =>{{Integral a$z1}} -> u0 -> a$z1) (ub :: _forall_ a$z1 =>{{Integral a$z1}} -> u0 -> a$z1) -> case u5 of { _ALG_ _TUP_3 (uc :: {{Num u0}}) (ud :: {{Enum u0}}) (ue :: u0 -> Ratio Integer) -> _APP_ ue [ u4 ]; _NO_DEFLT_ }; _NO_DEFLT_ }} in _APP_ u3 [ uf ] _N_} _F_ _IF_ARGS_ 2 3 CCX 8 _/\_ u0 u1 -> \ (u2 :: {{RealFrac u0}}) (u3 :: {{Fractional u1}}) (u4 :: u0) -> let {(uf :: Ratio Integer) = case u2 of { _ALG_ _TUP_7 (u5 :: {{Real u0}}) (u6 :: {{Fractional u0}}) (u7 :: _forall_ a$z1 =>{{Integral a$z1}} -> u0 -> (a$z1, u0)) (u8 :: _forall_ a$z1 =>{{Integral a$z1}} -> u0 -> a$z1) (u9 :: _forall_ a$z1 =>{{Integral a$z1}} -> u0 -> a$z1) (ua :: _forall_ a$z1 =>{{Integral a$z1}} -> u0 -> a$z1) (ub :: _forall_ a$z1 =>{{Integral a$z1}} -> u0 -> a$z1) -> case u5 of { _ALG_ _TUP_3 (uc :: {{Num u0}}) (ud :: {{Enum u0}}) (ue :: u0 -> Ratio Integer) -> _APP_ ue [ u4 ]; _NO_DEFLT_ }; _NO_DEFLT_ }} in case u3 of { _ALG_ _TUP_4 (ug :: {{Num u1}}) (uh :: u1 -> u1 -> u1) (ui :: u1 -> u1) (uj :: Ratio Integer -> u1) -> _APP_ uj [ uf ]; _NO_DEFLT_ } _SPECIALISE_ [ Double, Double ] 2 { _A_ 1 _U_ 1 _N_ _N_ _F_ _IF_ARGS_ 0 0 X 1 _TYAPP_ _ORIG_ Prelude id { Double } _N_ }, [ Double, Float ] 2 { _A_ 1 _U_ 1 _N_ _S_ "U(P)" {_A_ 1 _U_ 2 _N_ _N_ _F_ _IF_ARGS_ 0 1 X 3 \ (u0 :: Double#) -> case _#_ double2Float# [] [u0] of { _PRIM_ (u1 :: Float#) -> _!_ F# [] [u1] } _N_} _F_ _IF_ARGS_ 0 1 C 4 \ (u0 :: Double) -> case u0 of { _ALG_ D# (u1 :: Double#) -> case _#_ double2Float# [] [u1] of { _PRIM_ (u2 :: Float#) -> _!_ F# [] [u2] }; _NO_DEFLT_ } _N_ }, [ Double, (Ratio Integer) ] 2 { _A_ 1 _U_ 1 _N_ _S_ "U(P)" {_A_ 1 _U_ 2 _N_ _N_ _N_ _N_} _N_ _N_ }, [ Float, Double ] 2 { _A_ 1 _U_ 1 _N_ _S_ "U(P)" {_A_ 1 _U_ 2 _N_ _N_ _F_ _IF_ARGS_ 0 1 X 3 \ (u0 :: Float#) -> case _#_ float2Double# [] [u0] of { _PRIM_ (u1 :: Double#) -> _!_ D# [] [u1] } _N_} _F_ _IF_ARGS_ 0 1 C 4 \ (u0 :: Float) -> case u0 of { _ALG_ F# (u1 :: Float#) -> case _#_ float2Double# [] [u1] of { _PRIM_ (u2 :: Double#) -> _!_ D# [] [u2] }; _NO_DEFLT_ } _N_ }, [ Float, Float ] 2 { _A_ 1 _U_ 1 _N_ _N_ _F_ _IF_ARGS_ 0 0 X 1 _TYAPP_ _ORIG_ Prelude id { Float } _N_ }, [ Float, (Ratio Integer) ] 2 { _A_ 1 _U_ 1 _N_ _S_ "U(P)" {_A_ 1 _U_ 2 _N_ _N_ _N_ _N_} _N_ _N_ }, [ (Ratio Integer), Double ] 2 { _A_ 1 _U_ 1 _N_ _S_ "U(U(PPP)U(PPP))" {_A_ 4 _U_ 2222 _N_ _N_ _N_ _N_} _N_ _N_ }, [ (Ratio Integer), Float ] 2 { _A_ 1 _U_ 2 _N_ _N_ _F_ _IF_ARGS_ 0 0 X 1 _CONSTM_ Fractional fromRational (Float) _N_ }, [ (Ratio Integer), (Ratio Integer) ] 2 { _A_ 1 _U_ 1 _N_ _N_ _F_ _IF_ARGS_ 0 0 X 1 _TYAPP_ _ORIG_ Prelude id { (Ratio Integer) } _N_ } #-}
fst :: (b, a) -> b
{-# GHC_PRAGMA _A_ 1 _U_ 1 _N_ _S_ "U(SA)" {_A_ 1 _U_ 1 _N_ _N_ _F_ _IF_ARGS_ 2 1 X 1 _/\_ u0 u1 -> \ (u2 :: u1) -> u2 _N_} _F_ _IF_ARGS_ 2 1 C 2 _/\_ u0 u1 -> \ (u2 :: (u1, u0)) -> case u2 of { _ALG_ _TUP_2 (u3 :: u1) (u4 :: u0) -> u3; _NO_DEFLT_ } _N_ #-}
gcd :: Integral a => a -> a -> a
isLower :: Char -> Bool
{-# GHC_PRAGMA _A_ 1 _U_ 1 _N_ _S_ "U(P)" {_A_ 1 _U_ 2 _N_ _N_ _N_ _N_} _N_ _N_ #-}
isNullBin :: Bin -> Bool
- {-# GHC_PRAGMA _A_ 1 _U_ 2 _N_ _S_ _!_ _F_ _IF_ARGS_ 0 1 X 3 \ (u0 :: Bin) -> _APP_ _TYAPP_ error { (Bin -> Bool) } [ _NOREP_S_ "isNullBin{Prelude}\n", u0 ] _N_ #-}
+ {-# GHC_PRAGMA _A_ 1 _U_ 2 _N_ _S_ _!_ _N_ _N_ #-}
isPrint :: Char -> Bool
{-# GHC_PRAGMA _A_ 1 _U_ 1 _N_ _S_ "U(P)" {_A_ 1 _U_ 2 _N_ _N_ _N_ _N_} _N_ _N_ #-}
isSpace :: Char -> Bool
not :: Bool -> Bool
{-# GHC_PRAGMA _A_ 1 _U_ 1 _N_ _S_ "E" _F_ _ALWAYS_ \ (u0 :: Bool) -> case u0 of { _ALG_ True -> _!_ False [] []; False -> _!_ True [] []; _NO_DEFLT_ } _N_ #-}
nullBin :: Bin
- {-# GHC_PRAGMA _A_ 0 _N_ _N_ _S_ _!_ _F_ _IF_ARGS_ 0 0 X 2 _APP_ _TYAPP_ error { Bin } [ _NOREP_S_ "nullBin{Prelude}\n" ] _N_ #-}
+ {-# GHC_PRAGMA _A_ 0 _N_ _N_ _S_ _!_ _N_ _N_ #-}
ord :: Char -> Int
{-# GHC_PRAGMA _A_ 1 _U_ 1 _N_ _S_ "U(P)" {_A_ 1 _U_ 2 _N_ _N_ _F_ _IF_ARGS_ 0 1 X 3 \ (u0 :: Char#) -> case _#_ ord# [] [u0] of { _PRIM_ (u1 :: Int#) -> _!_ I# [] [u1] } _N_} _F_ _IF_ARGS_ 0 1 C 4 \ (u0 :: Char) -> case u0 of { _ALG_ C# (u1 :: Char#) -> case _#_ ord# [] [u1] of { _PRIM_ (u2 :: Int#) -> _!_ I# [] [u2] }; _NO_DEFLT_ } _N_ #-}
otherwise :: Bool
snd :: (a, b) -> b
{-# GHC_PRAGMA _A_ 1 _U_ 1 _N_ _S_ "U(AS)" {_A_ 1 _U_ 1 _N_ _N_ _F_ _IF_ARGS_ 2 1 X 1 _/\_ u0 u1 -> \ (u2 :: u1) -> u2 _N_} _F_ _IF_ARGS_ 2 1 C 2 _/\_ u0 u1 -> \ (u2 :: (u0, u1)) -> case u2 of { _ALG_ _TUP_2 (u3 :: u0) (u4 :: u1) -> u4; _NO_DEFLT_ } _N_ #-}
subtract :: Num a => a -> a -> a
- {-# GHC_PRAGMA _A_ 3 _U_ 122 _N_ _S_ "U(AAASAAAAAA)LL" {_A_ 3 _U_ 122 _N_ _N_ _F_ _IF_ARGS_ 1 3 XXX 3 _/\_ u0 -> \ (u1 :: u0 -> u0 -> u0) (u2 :: u0) (u3 :: u0) -> _APP_ u1 [ u3, u2 ] _N_} _F_ _IF_ARGS_ 1 3 CXX 4 _/\_ u0 -> \ (u1 :: {{Num u0}}) (u2 :: u0) (u3 :: u0) -> case u1 of { _ALG_ _TUP_10 (u4 :: {{Eq u0}}) (u5 :: {{Text u0}}) (u6 :: u0 -> u0 -> u0) (u7 :: u0 -> u0 -> u0) (u8 :: u0 -> u0 -> u0) (u9 :: u0 -> u0) (ua :: u0 -> u0) (ub :: u0 -> u0) (uc :: Integer -> u0) (ud :: Int -> u0) -> _APP_ u7 [ u3, u2 ]; _NO_DEFLT_ } _SPECIALISE_ [ Double ] 1 { _A_ 2 _U_ 11 _N_ _S_ "U(P)U(P)" {_A_ 2 _U_ 22 _N_ _N_ _F_ _IF_ARGS_ 0 2 XX 3 \ (u0 :: Double#) (u1 :: Double#) -> case _#_ minusDouble# [] [u1, u0] of { _PRIM_ (u2 :: Double#) -> _!_ D# [] [u2] } _N_} _F_ _IF_ARGS_ 0 2 CC 5 \ (u0 :: Double) (u1 :: Double) -> case u1 of { _ALG_ D# (u2 :: Double#) -> case u0 of { _ALG_ D# (u3 :: Double#) -> case _#_ minusDouble# [] [u2, u3] of { _PRIM_ (u4 :: Double#) -> _!_ D# [] [u4] }; _NO_DEFLT_ }; _NO_DEFLT_ } _N_ }, [ Int ] 1 { _A_ 2 _U_ 11 _N_ _S_ "U(P)U(P)" {_A_ 2 _U_ 22 _N_ _N_ _F_ _IF_ARGS_ 0 2 XX 3 \ (u0 :: Int#) (u1 :: Int#) -> case _#_ minusInt# [] [u1, u0] of { _PRIM_ (u2 :: Int#) -> _!_ I# [] [u2] } _N_} _F_ _IF_ARGS_ 0 2 CC 5 \ (u0 :: Int) (u1 :: Int) -> case u1 of { _ALG_ I# (u2 :: Int#) -> case u0 of { _ALG_ I# (u3 :: Int#) -> case _#_ minusInt# [] [u2, u3] of { _PRIM_ (u4 :: Int#) -> _!_ I# [] [u4] }; _NO_DEFLT_ }; _NO_DEFLT_ } _N_ } #-}
+ {-# GHC_PRAGMA _A_ 3 _U_ 122 _N_ _S_ "U(AAASAAAAAA)LL" {_A_ 3 _U_ 122 _N_ _N_ _F_ _IF_ARGS_ 1 3 XXX 3 _/\_ u0 -> \ (u1 :: u0 -> u0 -> u0) (u2 :: u0) (u3 :: u0) -> _APP_ u1 [ u3, u2 ] _N_} _F_ _IF_ARGS_ 1 3 CXX 4 _/\_ u0 -> \ (u1 :: {{Num u0}}) (u2 :: u0) (u3 :: u0) -> case u1 of { _ALG_ _TUP_10 (u4 :: {{Eq u0}}) (u5 :: {{Text u0}}) (u6 :: u0 -> u0 -> u0) (u7 :: u0 -> u0 -> u0) (u8 :: u0 -> u0 -> u0) (u9 :: u0 -> u0) (ua :: u0 -> u0) (ub :: u0 -> u0) (uc :: Integer -> u0) (ud :: Int -> u0) -> _APP_ u7 [ u3, u2 ]; _NO_DEFLT_ } _SPECIALISE_ [ Double ] 1 { _A_ 2 _U_ 11 _N_ _S_ "U(P)U(P)" {_A_ 2 _U_ 22 _N_ _N_ _F_ _IF_ARGS_ 0 2 XX 3 \ (u0 :: Double#) (u1 :: Double#) -> case _#_ minusDouble# [] [u1, u0] of { _PRIM_ (u2 :: Double#) -> _!_ D# [] [u2] } _N_} _F_ _IF_ARGS_ 0 2 CC 5 \ (u0 :: Double) (u1 :: Double) -> case u1 of { _ALG_ D# (u2 :: Double#) -> case u0 of { _ALG_ D# (u3 :: Double#) -> case _#_ minusDouble# [] [u2, u3] of { _PRIM_ (u4 :: Double#) -> _!_ D# [] [u4] }; _NO_DEFLT_ }; _NO_DEFLT_ } _N_ }, [ Int ] 1 { _A_ 2 _U_ 11 _N_ _S_ "U(P)U(P)" {_A_ 2 _U_ 22 _N_ _N_ _F_ _IF_ARGS_ 0 2 XX 3 \ (u0 :: Int#) (u1 :: Int#) -> case _#_ minusInt# [] [u1, u0] of { _PRIM_ (u2 :: Int#) -> _!_ I# [] [u2] } _N_} _F_ _IF_ARGS_ 0 2 CC 5 \ (u0 :: Int) (u1 :: Int) -> case u1 of { _ALG_ I# (u2 :: Int#) -> case u0 of { _ALG_ I# (u3 :: Int#) -> case _#_ minusInt# [] [u2, u3] of { _PRIM_ (u4 :: Int#) -> _!_ I# [] [u4] }; _NO_DEFLT_ }; _NO_DEFLT_ } _N_ }, [ (Complex Double) ] 1 { _A_ 2 _U_ 11 _N_ _S_ "U(LL)U(LL)" {_A_ 4 _U_ 2222 _N_ _N_ _N_ _N_} _N_ _N_ } #-}
toLower :: Char -> Char
{-# GHC_PRAGMA _A_ 1 _U_ 1 _N_ _S_ "U(P)" {_A_ 1 _U_ 2 _N_ _N_ _N_ _N_} _N_ _N_ #-}
toUpper :: Char -> Char
imagPart :: Complex a -> a
{-# GHC_PRAGMA _A_ 1 _U_ 1 _N_ _S_ "U(AS)" {_A_ 1 _U_ 1 _N_ _N_ _F_ _IF_ARGS_ 1 1 X 1 _/\_ u0 -> \ (u1 :: u0) -> u1 _N_} _F_ _IF_ARGS_ 1 1 C 2 _/\_ u0 -> \ (u1 :: Complex u0) -> case u1 of { _ALG_ (:+) (u2 :: u0) (u3 :: u0) -> u3; _NO_DEFLT_ } _N_ #-}
magnitude :: RealFloat a => Complex a -> a
- {-# GHC_PRAGMA _A_ 1 _U_ 12 _N_ _S_ "U(ALAAAAALAS)" {_A_ 3 _U_ 2221 _N_ _N_ _N_ _N_} _N_ _SPECIALISE_ [ Double ] 1 { _A_ 1 _U_ 1 _N_ _S_ "U(LL)" {_A_ 2 _U_ 22 _N_ _N_ _N_ _N_} _N_ _N_ } #-}
+ {-# GHC_PRAGMA _A_ 1 _U_ 12 _N_ _S_ "U(ALAAAAALAS)" {_A_ 3 _U_ 2221 _N_ _N_ _N_ _N_} _N_ _SPECIALISE_ [ Double ] 1 { _A_ 1 _U_ 1 _N_ _S_ "U(U(P)U(P))" {_A_ 2 _U_ 22 _N_ _N_ _N_ _N_} _N_ _N_ } #-}
mkPolar :: RealFloat a => a -> a -> Complex a
{-# GHC_PRAGMA _A_ 3 _U_ 122 _N_ _N_ _N_ _SPECIALISE_ [ Double ] 1 { _A_ 2 _U_ 22 _N_ _N_ _N_ _N_ } #-}
phase :: RealFloat a => Complex a -> a
{-# GHC_PRAGMA _A_ 1 _U_ 22 _N_ _N_ _N_ _SPECIALISE_ [ Double ] 1 { _A_ 1 _U_ 2 _N_ _N_ _N_ _N_ } #-}
realPart :: Complex a -> a
{-# GHC_PRAGMA _A_ 1 _U_ 1 _N_ _S_ "U(SA)" {_A_ 1 _U_ 1 _N_ _N_ _F_ _IF_ARGS_ 1 1 X 1 _/\_ u0 -> \ (u1 :: u0) -> u1 _N_} _F_ _IF_ARGS_ 1 1 C 2 _/\_ u0 -> \ (u1 :: Complex u0) -> case u1 of { _ALG_ (:+) (u2 :: u0) (u3 :: u0) -> u2; _NO_DEFLT_ } _N_ #-}
-_ceiling :: (RealFrac a, Integral b) => a -> b
- {-# GHC_PRAGMA _A_ 2 _U_ 122 _N_ _S_ "U(U(AU(U(AAAASAAA)AAAA)A)LSAAAA)L" {_A_ 4 _U_ 11122 _N_ _N_ _N_ _N_} _N_ _SPECIALISE_ [ Double, Int ] 2 { _A_ 0 _U_ 2 _N_ _N_ _N_ _N_ } #-}
-_floor :: (RealFrac a, Integral b) => a -> b
- {-# GHC_PRAGMA _A_ 2 _U_ 122 _N_ _S_ "U(U(AU(U(ASAAAAAA)AAAA)A)LSAAAA)L" {_A_ 4 _U_ 11122 _N_ _N_ _N_ _N_} _N_ _SPECIALISE_ [ Double, Int ] 2 { _A_ 0 _U_ 2 _N_ _N_ _N_ _N_ } #-}
-_readList :: Text a => [Char] -> [([a], [Char])]
+_readList :: ([Char] -> [(a, [Char])]) -> [Char] -> [([a], [Char])]
{-# GHC_PRAGMA _A_ 1 _U_ 22 _N_ _N_ _N_ _N_ #-}
-_round :: (RealFrac a, Integral b) => a -> b
- {-# GHC_PRAGMA _A_ 2 _U_ 122 _N_ _S_ "U(U(AU(U(ALAAAAAS)AAAA)A)LSAAAA)L" {_A_ 5 _U_ 112122 _N_ _N_ _N_ _N_} _N_ _SPECIALISE_ [ Double, Int ] 2 { _A_ 0 _U_ 2 _N_ _N_ _N_ _N_ }, [ (Ratio Integer), Integer ] 2 { _A_ 1 _U_ 1 _N_ _S_ "U(LL)" {_A_ 2 _U_ 22 _N_ _N_ _N_ _N_} _N_ _N_ } #-}
-_showList :: Text a => [a] -> [Char] -> [Char]
- {-# GHC_PRAGMA _A_ 1 _U_ 212 _N_ _N_ _N_ _N_ #-}
+_showList :: (a -> [Char] -> [Char]) -> [a] -> [Char] -> [Char]
+ {-# GHC_PRAGMA _A_ 2 _U_ 212 _N_ _S_ "LS" _N_ _N_ #-}
_showRational :: Int -> Ratio Integer -> [Char]
{-# GHC_PRAGMA _A_ 2 _U_ 21 _N_ _S_ "LU(U(PPP)L)" {_A_ 5 _U_ 22222 _N_ _N_ _N_ _N_} _N_ _N_ #-}
-_truncate :: (RealFrac a, Integral b) => a -> b
- {-# GHC_PRAGMA _A_ 2 _U_ 122 _N_ _S_ "U(AASAAAA)L" {_A_ 2 _U_ 122 _N_ _N_ _N_ _N_} _N_ _SPECIALISE_ [ Double, Int ] 2 { _A_ 0 _U_ 2 _N_ _N_ _N_ _N_ } #-}
abort :: IOError -> [Response] -> [Request]
{-# GHC_PRAGMA _A_ 2 _U_ 00 _N_ _S_ "A" {_A_ 1 _U_ 0 _N_ _N_ _F_ _IF_ARGS_ 0 1 X 1 \ (u0 :: [Response]) -> _!_ _NIL_ [Request] [] _N_} _F_ _IF_ARGS_ 0 1 X 1 \ (u0 :: IOError) -> _ORIG_ PreludeIO done _N_ #-}
appendBinChan :: [Char] -> Bin -> (IOError -> [Response] -> [Request]) -> ([Response] -> [Request]) -> [Response] -> [Request]
interact :: ([Char] -> [Char]) -> [Response] -> [Request]
{-# GHC_PRAGMA _A_ 1 _U_ 11 _N_ _N_ _N_ _N_ #-}
print :: Text a => a -> [Response] -> [Request]
- {-# GHC_PRAGMA _A_ 1 _U_ 121 _N_ _N_ _N_ _N_ #-}
+ {-# GHC_PRAGMA _A_ 1 _U_ 121 _N_ _N_ _N_ _SPECIALISE_ [ Bool ] 1 { _A_ 1 _U_ 21 _N_ _N_ _N_ _N_ }, [ Char ] 1 { _A_ 1 _U_ 11 _N_ _N_ _N_ _N_ }, [ Double ] 1 { _A_ 1 _U_ 11 _N_ _N_ _N_ _N_ }, [ Int ] 1 { _A_ 1 _U_ 11 _N_ _N_ _N_ _N_ }, [ Integer ] 1 { _A_ 1 _U_ 11 _N_ _N_ _N_ _N_ }, [ [Char] ] 1 { _A_ 1 _U_ 21 _N_ _N_ _N_ _N_ }, [ [Int] ] 1 { _A_ 1 _U_ 21 _N_ _N_ _N_ _N_ }, [ [[Char]] ] 1 { _A_ 1 _U_ 21 _N_ _N_ _N_ _N_ }, [ [[Int]] ] 1 { _A_ 1 _U_ 21 _N_ _N_ _N_ _N_ }, [ _PackedString ] 1 { _A_ 1 _U_ 21 _N_ _N_ _N_ _N_ }, [ () ] 1 { _A_ 1 _U_ 21 _N_ _N_ _N_ _N_ } #-}
prints :: Text a => a -> [Char] -> [Response] -> [Request]
- {-# GHC_PRAGMA _A_ 1 _U_ 1221 _N_ _N_ _N_ _N_ #-}
+ {-# GHC_PRAGMA _A_ 1 _U_ 1221 _N_ _N_ _N_ _SPECIALISE_ [ Bool ] 1 { _A_ 2 _U_ 221 _N_ _N_ _N_ _N_ }, [ Char ] 1 { _A_ 2 _U_ 121 _N_ _N_ _N_ _N_ }, [ Double ] 1 { _A_ 2 _U_ 121 _N_ _N_ _N_ _N_ }, [ Int ] 1 { _A_ 2 _U_ 121 _N_ _N_ _N_ _N_ }, [ Integer ] 1 { _A_ 2 _U_ 121 _N_ _N_ _N_ _N_ }, [ [Char] ] 1 { _A_ 2 _U_ 221 _N_ _N_ _N_ _N_ }, [ [Int] ] 1 { _A_ 2 _U_ 221 _N_ _N_ _N_ _N_ }, [ [[Char]] ] 1 { _A_ 2 _U_ 121 _N_ _N_ _N_ _N_ }, [ [[Int]] ] 1 { _A_ 2 _U_ 121 _N_ _N_ _N_ _N_ }, [ _PackedString ] 1 { _A_ 2 _U_ 221 _N_ _N_ _N_ _N_ }, [ () ] 1 { _A_ 2 _U_ 121 _N_ _N_ _N_ _N_ } #-}
readBinChan :: [Char] -> (IOError -> [Response] -> [Request]) -> (Bin -> [Response] -> [Request]) -> [Response] -> [Request]
{-# GHC_PRAGMA _A_ 4 _U_ 2111 _N_ _N_ _N_ _N_ #-}
readBinFile :: [Char] -> (IOError -> [Response] -> [Request]) -> (Bin -> [Response] -> [Request]) -> [Response] -> [Request]
(++) :: [a] -> [a] -> [a]
{-# GHC_PRAGMA _A_ 2 _U_ 12 _N_ _S_ "SL" _N_ _N_ #-}
(\\) :: Eq a => [a] -> [a] -> [a]
- {-# GHC_PRAGMA _A_ 3 _U_ 122 _N_ _S_ "LLS" _N_ _N_ #-}
+ {-# GHC_PRAGMA _A_ 3 _U_ 122 _N_ _S_ "LLS" _N_ _SPECIALISE_ [ Int ] 1 { _A_ 2 _U_ 22 _N_ _S_ "LS" _N_ _N_ }, [ [Char] ] 1 { _A_ 2 _U_ 22 _N_ _S_ "LS" _N_ _N_ } #-}
all :: (a -> Bool) -> [a] -> Bool
{-# GHC_PRAGMA _A_ 2 _U_ 21 _N_ _S_ "LS" _F_ _ALWAYS_ _/\_ u0 -> \ (u1 :: u0 -> Bool) (u2 :: [u0]) -> let {(u3 :: Bool) = _!_ True [] []} in let {(u6 :: u0 -> Bool -> Bool) = \ (u4 :: u0) (u5 :: Bool) -> case _APP_ u1 [ u4 ] of { _ALG_ True -> u5; False -> _!_ False [] []; _NO_DEFLT_ }} in _APP_ _TYAPP_ _TYAPP_ foldr { u0 } { Bool } [ u6, u3, u2 ] _N_ #-}
and :: [Bool] -> Bool
dropWhile :: (a -> Bool) -> [a] -> [a]
{-# GHC_PRAGMA _A_ 2 _U_ 21 _N_ _S_ "LS" _N_ _N_ #-}
elem :: Eq a => a -> [a] -> Bool
- {-# GHC_PRAGMA _A_ 3 _U_ 121 _N_ _S_ "LLS" _F_ _ALWAYS_ _/\_ u0 -> \ (u1 :: {{Eq u0}}) (u2 :: u0) (u3 :: [u0]) -> let {(u6 :: u0 -> u0 -> Bool) = case u1 of { _ALG_ _TUP_2 (u4 :: u0 -> u0 -> Bool) (u5 :: u0 -> u0 -> Bool) -> u4; _NO_DEFLT_ }} in let {(u8 :: u0 -> Bool) = \ (u7 :: u0) -> _APP_ u6 [ u2, u7 ]} in _APP_ _TYAPP_ _ORIG_ PreludeList any { u0 } [ u8, u3 ] _SPECIALISE_ [ Char ] 1 { _A_ 2 _U_ 21 _N_ _S_ "LS" _F_ _ALWAYS_ \ (u0 :: Char) (u1 :: [Char]) -> let {(u5 :: Char -> Bool) = \ (u2 :: Char) -> case u0 of { _ALG_ C# (u3 :: Char#) -> case u2 of { _ALG_ C# (u4 :: Char#) -> _#_ eqChar# [] [u3, u4]; _NO_DEFLT_ }; _NO_DEFLT_ }} in _APP_ _TYAPP_ _ORIG_ PreludeList any { Char } [ u5, u1 ] _N_ }, [ Int ] 1 { _A_ 2 _U_ 21 _N_ _S_ "LS" _F_ _ALWAYS_ \ (u0 :: Int) (u1 :: [Int]) -> let {(u5 :: Int -> Bool) = \ (u2 :: Int) -> case u0 of { _ALG_ I# (u3 :: Int#) -> case u2 of { _ALG_ I# (u4 :: Int#) -> _#_ eqInt# [] [u3, u4]; _NO_DEFLT_ }; _NO_DEFLT_ }} in _APP_ _TYAPP_ _ORIG_ PreludeList any { Int } [ u5, u1 ] _N_ }, [ [Char] ] 1 { _A_ 2 _U_ 21 _N_ _S_ "LS" _F_ _ALWAYS_ \ (u0 :: [Char]) (u1 :: [[Char]]) -> let {(u3 :: [Char] -> Bool) = \ (u2 :: [Char]) -> _APP_ _CONSTM_ Eq (==) ([Char]) [ u0, u2 ]} in _APP_ _TYAPP_ _ORIG_ PreludeList any { [Char] } [ u3, u1 ] _N_ } #-}
+ {-# GHC_PRAGMA _A_ 3 _U_ 121 _N_ _S_ "LLS" _F_ _ALWAYS_ _/\_ u0 -> \ (u1 :: {{Eq u0}}) (u2 :: u0) (u3 :: [u0]) -> let {(u6 :: u0 -> u0 -> Bool) = case u1 of { _ALG_ _TUP_2 (u4 :: u0 -> u0 -> Bool) (u5 :: u0 -> u0 -> Bool) -> u4; _NO_DEFLT_ }} in let {(u8 :: u0 -> Bool) = \ (u7 :: u0) -> _APP_ u6 [ u2, u7 ]} in _APP_ _TYAPP_ _ORIG_ PreludeList any { u0 } [ u8, u3 ] _SPECIALISE_ [ Char ] 1 { _A_ 2 _U_ 21 _N_ _S_ "LS" _F_ _ALWAYS_ \ (u0 :: Char) (u1 :: [Char]) -> let {(u5 :: Char -> Bool) = \ (u2 :: Char) -> case u0 of { _ALG_ C# (u3 :: Char#) -> case u2 of { _ALG_ C# (u4 :: Char#) -> _#_ eqChar# [] [u3, u4]; _NO_DEFLT_ }; _NO_DEFLT_ }} in _APP_ _TYAPP_ _ORIG_ PreludeList any { Char } [ u5, u1 ] _N_ }, [ Int ] 1 { _A_ 2 _U_ 21 _N_ _S_ "LS" _F_ _ALWAYS_ \ (u0 :: Int) (u1 :: [Int]) -> let {(u5 :: Int -> Bool) = \ (u2 :: Int) -> case u0 of { _ALG_ I# (u3 :: Int#) -> case u2 of { _ALG_ I# (u4 :: Int#) -> _#_ eqInt# [] [u3, u4]; _NO_DEFLT_ }; _NO_DEFLT_ }} in _APP_ _TYAPP_ _ORIG_ PreludeList any { Int } [ u5, u1 ] _N_ }, [ Integer ] 1 { _A_ 2 _U_ 21 _N_ _S_ "LS" _F_ _ALWAYS_ \ (u0 :: Integer) (u1 :: [Integer]) -> let {(ua :: Integer -> Bool) = \ (u2 :: Integer) -> case u0 of { _ALG_ J# (u3 :: Int#) (u4 :: Int#) (u5 :: ByteArray#) -> case u2 of { _ALG_ J# (u6 :: Int#) (u7 :: Int#) (u8 :: ByteArray#) -> case _#_ cmpInteger# [] [u3, u4, u5, u6, u7, u8] of { _PRIM_ 0# -> _!_ True [] []; (u9 :: Int#) -> _!_ False [] [] }; _NO_DEFLT_ }; _NO_DEFLT_ }} in _APP_ _TYAPP_ _ORIG_ PreludeList any { Integer } [ ua, u1 ] _N_ }, [ [Char] ] 1 { _A_ 2 _U_ 21 _N_ _S_ "LS" _F_ _ALWAYS_ \ (u0 :: [Char]) (u1 :: [[Char]]) -> let {(u3 :: [Char] -> Bool) = \ (u2 :: [Char]) -> _APP_ _CONSTM_ Eq (==) ([Char]) [ u0, u2 ]} in _APP_ _TYAPP_ _ORIG_ PreludeList any { [Char] } [ u3, u1 ] _N_ }, [ [Int] ] 1 { _A_ 2 _U_ 21 _N_ _S_ "LS" _F_ _ALWAYS_ \ (u0 :: [Int]) (u1 :: [[Int]]) -> let {(u3 :: [Int] -> Bool) = \ (u2 :: [Int]) -> _APP_ _CONSTM_ Eq (==) ([Int]) [ u0, u2 ]} in _APP_ _TYAPP_ _ORIG_ PreludeList any { [Int] } [ u3, u1 ] _N_ }, [ (Int, Int) ] 1 { _A_ 2 _U_ 21 _N_ _S_ "LS" _F_ _ALWAYS_ \ (u0 :: (Int, Int)) (u1 :: [(Int, Int)]) -> let {(ub :: (Int, Int) -> Bool) = \ (u2 :: (Int, Int)) -> case u0 of { _ALG_ _TUP_2 (u3 :: Int) (u4 :: Int) -> case u3 of { _ALG_ I# (u5 :: Int#) -> case u2 of { _ALG_ _TUP_2 (u6 :: Int) (u7 :: Int) -> case u6 of { _ALG_ I# (u8 :: Int#) -> case _#_ eqInt# [] [u5, u8] of { _ALG_ True -> case u4 of { _ALG_ I# (u9 :: Int#) -> case u7 of { _ALG_ I# (ua :: Int#) -> _#_ eqInt# [] [u9, ua]; _NO_DEFLT_ }; _NO_DEFLT_ }; False -> _!_ False [] []; _NO_DEFLT_ }; _NO_DEFLT_ }; _NO_DEFLT_ }; _NO_DEFLT_ }; _NO_DEFLT_ }} in _APP_ _TYAPP_ _ORIG_ PreludeList any { (Int, Int) } [ ub, u1 ] _N_ } #-}
filter :: (a -> Bool) -> [a] -> [a]
{-# GHC_PRAGMA _A_ 2 _U_ 21 _N_ _S_ "LS" _F_ _ALWAYS_ _/\_ u0 -> \ (u1 :: u0 -> Bool) (u2 :: [u0]) -> let {(u9 :: _forall_ a$z1 =>(u0 -> a$z1 -> a$z1) -> a$z1 -> a$z1) = _/\_ u3 -> \ (u4 :: u0 -> u3 -> u3) (u5 :: u3) -> let {(u8 :: u0 -> u3 -> u3) = \ (u6 :: u0) (u7 :: u3) -> case _APP_ u1 [ u6 ] of { _ALG_ True -> _APP_ u4 [ u6, u7 ]; False -> u7; _NO_DEFLT_ }} in _APP_ _TYAPP_ _TYAPP_ foldr { u0 } { u3 } [ u8, u5, u2 ]} in _APP_ _TYAPP_ _build { u0 } [ u9 ] _N_ #-}
foldl1 :: (a -> a -> a) -> [a] -> a
foldr1 :: (a -> a -> a) -> [a] -> a
{-# GHC_PRAGMA _A_ 2 _U_ 21 _N_ _S_ "LS" _N_ _N_ #-}
genericLength :: Num b => [a] -> b
- {-# GHC_PRAGMA _A_ 1 _U_ 21 _N_ _N_ _N_ _N_ #-}
+ {-# GHC_PRAGMA _A_ 1 _U_ 21 _N_ _N_ _N_ _SPECIALISE_ [ _N_, Int ] 1 { _A_ 1 _U_ 1 _N_ _S_ "S" _N_ _N_ }, [ _N_, Integer ] 1 { _A_ 1 _U_ 1 _N_ _S_ "S" _N_ _N_ } #-}
head :: [a] -> a
{-# GHC_PRAGMA _A_ 1 _U_ 1 _N_ _S_ "S" _F_ _ALWAYS_ _/\_ u0 -> \ (u1 :: [u0]) -> let {(u2 :: u0) = _APP_ _TYAPP_ error { u0 } [ _NOREP_S_ "head{PreludeList}: head []\n" ]} in let {(u5 :: u0 -> u0 -> u0) = \ (u3 :: u0) (u4 :: u0) -> u3} in _APP_ _TYAPP_ _TYAPP_ foldr { u0 } { u0 } [ u5, u2, u1 ] _N_ #-}
init :: [a] -> [a]
map :: (a -> b) -> [a] -> [b]
{-# GHC_PRAGMA _A_ 2 _U_ 21 _N_ _S_ "LS" _F_ _ALWAYS_ _/\_ u0 u1 -> \ (u2 :: u0 -> u1) (u3 :: [u0]) -> let {(ua :: _forall_ a$z1 =>(u1 -> a$z1 -> a$z1) -> a$z1 -> a$z1) = _/\_ u4 -> \ (u5 :: u1 -> u4 -> u4) (u6 :: u4) -> let {(u9 :: u0 -> u4 -> u4) = \ (u7 :: u0) -> let {(u8 :: u1) = _APP_ u2 [ u7 ]} in _APP_ u5 [ u8 ]} in _APP_ _TYAPP_ _TYAPP_ foldr { u0 } { u4 } [ u9, u6, u3 ]} in _APP_ _TYAPP_ _build { u1 } [ ua ] _N_ #-}
maximum :: Ord a => [a] -> a
- {-# GHC_PRAGMA _A_ 1 _U_ 11 _N_ _N_ _N_ _N_ #-}
+ {-# GHC_PRAGMA _A_ 1 _U_ 11 _N_ _N_ _N_ _SPECIALISE_ [ Double ] 1 { _A_ 1 _U_ 1 _N_ _S_ "S" _N_ _N_ }, [ Int ] 1 { _A_ 1 _U_ 1 _N_ _S_ "S" _N_ _N_ }, [ Integer ] 1 { _A_ 1 _U_ 1 _N_ _S_ "S" _N_ _N_ } #-}
minimum :: Ord a => [a] -> a
- {-# GHC_PRAGMA _A_ 1 _U_ 11 _N_ _N_ _N_ _N_ #-}
+ {-# GHC_PRAGMA _A_ 1 _U_ 11 _N_ _N_ _N_ _SPECIALISE_ [ Double ] 1 { _A_ 1 _U_ 1 _N_ _S_ "S" _N_ _N_ }, [ Int ] 1 { _A_ 1 _U_ 1 _N_ _S_ "S" _N_ _N_ }, [ Integer ] 1 { _A_ 1 _U_ 1 _N_ _S_ "S" _N_ _N_ } #-}
notElem :: Eq a => a -> [a] -> Bool
- {-# GHC_PRAGMA _A_ 3 _U_ 121 _N_ _S_ "LLS" _F_ _ALWAYS_ _/\_ u0 -> \ (u1 :: {{Eq u0}}) (u2 :: u0) (u3 :: [u0]) -> let {(u6 :: u0 -> u0 -> Bool) = case u1 of { _ALG_ _TUP_2 (u4 :: u0 -> u0 -> Bool) (u5 :: u0 -> u0 -> Bool) -> u5; _NO_DEFLT_ }} in let {(u8 :: u0 -> Bool) = \ (u7 :: u0) -> _APP_ u6 [ u2, u7 ]} in _APP_ _TYAPP_ _ORIG_ PreludeList all { u0 } [ u8, u3 ] _SPECIALISE_ [ Char ] 1 { _A_ 2 _U_ 21 _N_ _S_ "LS" _F_ _ALWAYS_ \ (u0 :: Char) (u1 :: [Char]) -> let {(u5 :: Char -> Bool) = \ (u2 :: Char) -> case u0 of { _ALG_ C# (u3 :: Char#) -> case u2 of { _ALG_ C# (u4 :: Char#) -> _#_ neChar# [] [u3, u4]; _NO_DEFLT_ }; _NO_DEFLT_ }} in _APP_ _TYAPP_ _ORIG_ PreludeList all { Char } [ u5, u1 ] _N_ }, [ Int ] 1 { _A_ 2 _U_ 21 _N_ _S_ "LS" _F_ _ALWAYS_ \ (u0 :: Int) (u1 :: [Int]) -> let {(u5 :: Int -> Bool) = \ (u2 :: Int) -> case u0 of { _ALG_ I# (u3 :: Int#) -> case u2 of { _ALG_ I# (u4 :: Int#) -> _#_ neInt# [] [u3, u4]; _NO_DEFLT_ }; _NO_DEFLT_ }} in _APP_ _TYAPP_ _ORIG_ PreludeList all { Int } [ u5, u1 ] _N_ }, [ [Char] ] 1 { _A_ 2 _U_ 21 _N_ _S_ "LS" _F_ _ALWAYS_ \ (u0 :: [Char]) (u1 :: [[Char]]) -> let {(u3 :: [Char] -> Bool) = \ (u2 :: [Char]) -> _APP_ _CONSTM_ Eq (/=) ([Char]) [ u0, u2 ]} in _APP_ _TYAPP_ _ORIG_ PreludeList all { [Char] } [ u3, u1 ] _N_ } #-}
+ {-# GHC_PRAGMA _A_ 3 _U_ 121 _N_ _S_ "LLS" _F_ _ALWAYS_ _/\_ u0 -> \ (u1 :: {{Eq u0}}) (u2 :: u0) (u3 :: [u0]) -> let {(u6 :: u0 -> u0 -> Bool) = case u1 of { _ALG_ _TUP_2 (u4 :: u0 -> u0 -> Bool) (u5 :: u0 -> u0 -> Bool) -> u5; _NO_DEFLT_ }} in let {(u8 :: u0 -> Bool) = \ (u7 :: u0) -> _APP_ u6 [ u2, u7 ]} in _APP_ _TYAPP_ _ORIG_ PreludeList all { u0 } [ u8, u3 ] _SPECIALISE_ [ Char ] 1 { _A_ 2 _U_ 21 _N_ _S_ "LS" _F_ _ALWAYS_ \ (u0 :: Char) (u1 :: [Char]) -> let {(u5 :: Char -> Bool) = \ (u2 :: Char) -> case u0 of { _ALG_ C# (u3 :: Char#) -> case u2 of { _ALG_ C# (u4 :: Char#) -> _#_ neChar# [] [u3, u4]; _NO_DEFLT_ }; _NO_DEFLT_ }} in _APP_ _TYAPP_ _ORIG_ PreludeList all { Char } [ u5, u1 ] _N_ }, [ Int ] 1 { _A_ 2 _U_ 21 _N_ _S_ "LS" _F_ _ALWAYS_ \ (u0 :: Int) (u1 :: [Int]) -> let {(u5 :: Int -> Bool) = \ (u2 :: Int) -> case u0 of { _ALG_ I# (u3 :: Int#) -> case u2 of { _ALG_ I# (u4 :: Int#) -> _#_ neInt# [] [u3, u4]; _NO_DEFLT_ }; _NO_DEFLT_ }} in _APP_ _TYAPP_ _ORIG_ PreludeList all { Int } [ u5, u1 ] _N_ }, [ Integer ] 1 { _A_ 2 _U_ 21 _N_ _S_ "LS" _F_ _ALWAYS_ \ (u0 :: Integer) (u1 :: [Integer]) -> let {(ua :: Integer -> Bool) = \ (u2 :: Integer) -> case u0 of { _ALG_ J# (u3 :: Int#) (u4 :: Int#) (u5 :: ByteArray#) -> case u2 of { _ALG_ J# (u6 :: Int#) (u7 :: Int#) (u8 :: ByteArray#) -> case _#_ cmpInteger# [] [u3, u4, u5, u6, u7, u8] of { _PRIM_ 0# -> _!_ False [] []; (u9 :: Int#) -> _!_ True [] [] }; _NO_DEFLT_ }; _NO_DEFLT_ }} in _APP_ _TYAPP_ _ORIG_ PreludeList all { Integer } [ ua, u1 ] _N_ }, [ [Char] ] 1 { _A_ 2 _U_ 21 _N_ _S_ "LS" _F_ _ALWAYS_ \ (u0 :: [Char]) (u1 :: [[Char]]) -> let {(u3 :: [Char] -> Bool) = \ (u2 :: [Char]) -> _APP_ _CONSTM_ Eq (/=) ([Char]) [ u0, u2 ]} in _APP_ _TYAPP_ _ORIG_ PreludeList all { [Char] } [ u3, u1 ] _N_ }, [ (Int, Int) ] 1 { _A_ 2 _U_ 21 _N_ _S_ "LS" _F_ _ALWAYS_ \ (u0 :: (Int, Int)) (u1 :: [(Int, Int)]) -> let {(ub :: (Int, Int) -> Bool) = \ (u2 :: (Int, Int)) -> case u0 of { _ALG_ _TUP_2 (u3 :: Int) (u4 :: Int) -> case u3 of { _ALG_ I# (u5 :: Int#) -> case u2 of { _ALG_ _TUP_2 (u6 :: Int) (u7 :: Int) -> case u6 of { _ALG_ I# (u8 :: Int#) -> case _#_ neInt# [] [u5, u8] of { _ALG_ True -> _!_ True [] []; False -> case u4 of { _ALG_ I# (u9 :: Int#) -> case u7 of { _ALG_ I# (ua :: Int#) -> _#_ neInt# [] [u9, ua]; _NO_DEFLT_ }; _NO_DEFLT_ }; _NO_DEFLT_ }; _NO_DEFLT_ }; _NO_DEFLT_ }; _NO_DEFLT_ }; _NO_DEFLT_ }} in _APP_ _TYAPP_ _ORIG_ PreludeList all { (Int, Int) } [ ub, u1 ] _N_ } #-}
nub :: Eq a => [a] -> [a]
- {-# GHC_PRAGMA _A_ 2 _U_ 11 _N_ _S_ "LS" _N_ _N_ #-}
+ {-# GHC_PRAGMA _A_ 2 _U_ 11 _N_ _S_ "LS" _N_ _SPECIALISE_ [ Int ] 1 { _A_ 1 _U_ 1 _N_ _S_ "S" _N_ _N_ }, [ [Char] ] 1 { _A_ 1 _U_ 1 _N_ _S_ "S" _N_ _N_ }, [ [Int] ] 1 { _A_ 1 _U_ 1 _N_ _S_ "S" _N_ _N_ } #-}
null :: [a] -> Bool
{-# GHC_PRAGMA _A_ 1 _U_ 1 _N_ _S_ "S" _F_ _ALWAYS_ _/\_ u0 -> \ (u1 :: [u0]) -> let {(u2 :: Bool) = _!_ True [] []} in let {(u5 :: u0 -> Bool -> Bool) = \ (u3 :: u0) (u4 :: Bool) -> _!_ False [] []} in _APP_ _TYAPP_ _TYAPP_ foldr { u0 } { Bool } [ u5, u2, u1 ] _N_ #-}
or :: [Bool] -> Bool
partition :: (a -> Bool) -> [a] -> ([a], [a])
{-# GHC_PRAGMA _A_ 2 _U_ 21 _N_ _S_ "LS" _F_ _ALWAYS_ _/\_ u0 -> \ (u1 :: u0 -> Bool) (u2 :: [u0]) -> let {(u9 :: u0 -> ([u0], [u0]) -> ([u0], [u0])) = \ (u3 :: u0) (u4 :: ([u0], [u0])) -> case u4 of { _ALG_ _TUP_2 (u5 :: [u0]) (u6 :: [u0]) -> case _APP_ u1 [ u3 ] of { _ALG_ True -> let {(u7 :: [u0]) = _!_ (:) [u0] [u3, u5]} in _!_ _TUP_2 [[u0], [u0]] [u7, u6]; False -> let {(u8 :: [u0]) = _!_ (:) [u0] [u3, u6]} in _!_ _TUP_2 [[u0], [u0]] [u5, u8]; _NO_DEFLT_ }; _NO_DEFLT_ }} in let {(ua :: [u0]) = _!_ _NIL_ [u0] []} in let {(ub :: ([u0], [u0])) = _!_ _TUP_2 [[u0], [u0]] [ua, ua]} in _APP_ _TYAPP_ _TYAPP_ foldr { u0 } { ([u0], [u0]) } [ u9, ub, u2 ] _N_ #-}
product :: Num a => [a] -> a
- {-# GHC_PRAGMA _A_ 1 _U_ 22 _N_ _N_ _F_ _ALWAYS_ _/\_ u0 -> \ (u1 :: {{Num u0}}) -> let {(uc :: u0 -> u0 -> u0) = case u1 of { _ALG_ _TUP_10 (u2 :: {{Eq u0}}) (u3 :: {{Text u0}}) (u4 :: u0 -> u0 -> u0) (u5 :: u0 -> u0 -> u0) (u6 :: u0 -> u0 -> u0) (u7 :: u0 -> u0) (u8 :: u0 -> u0) (u9 :: u0 -> u0) (ua :: Integer -> u0) (ub :: Int -> u0) -> u6; _NO_DEFLT_ }} in let {(uo :: u0) = let {(ud :: Int) = _!_ I# [] [1#]} in case u1 of { _ALG_ _TUP_10 (ue :: {{Eq u0}}) (uf :: {{Text u0}}) (ug :: u0 -> u0 -> u0) (uh :: u0 -> u0 -> u0) (ui :: u0 -> u0 -> u0) (uj :: u0 -> u0) (uk :: u0 -> u0) (ul :: u0 -> u0) (um :: Integer -> u0) (un :: Int -> u0) -> _APP_ un [ ud ]; _NO_DEFLT_ }} in \ (up :: [u0]) -> _APP_ _TYAPP_ _TYAPP_ foldl { u0 } { u0 } [ uc, uo, up ] _SPECIALISE_ [ Double ] 1 { _A_ 1 _U_ 1 _N_ _S_ "S" _F_ _ALWAYS_ \ (u0 :: [Double]) -> let {(u1 :: Double) = _!_ D# [] [1.0000000000000000##]} in _APP_ _TYAPP_ _TYAPP_ foldl { Double } { Double } [ _CONSTM_ Num (*) (Double), u1, u0 ] _N_ }, [ Int ] 1 { _A_ 1 _U_ 1 _N_ _S_ "S" _F_ _ALWAYS_ \ (u0 :: [Int]) -> let {(u1 :: Int) = _!_ I# [] [1#]} in _APP_ _TYAPP_ _TYAPP_ foldl { Int } { Int } [ _CONSTM_ Num (*) (Int), u1, u0 ] _N_ }, [ Integer ] 1 { _A_ 1 _U_ 1 _N_ _S_ "S" _F_ _ALWAYS_ \ (u0 :: [Integer]) -> let {(u1 :: Integer) = _#_ int2Integer# [] [1#]} in _APP_ _TYAPP_ _TYAPP_ foldl { Integer } { Integer } [ _CONSTM_ Num (*) (Integer), u1, u0 ] _N_ } #-}
+ {-# GHC_PRAGMA _A_ 1 _U_ 22 _N_ _N_ _F_ _ALWAYS_ _/\_ u0 -> \ (u1 :: {{Num u0}}) -> let {(uc :: u0 -> u0 -> u0) = case u1 of { _ALG_ _TUP_10 (u2 :: {{Eq u0}}) (u3 :: {{Text u0}}) (u4 :: u0 -> u0 -> u0) (u5 :: u0 -> u0 -> u0) (u6 :: u0 -> u0 -> u0) (u7 :: u0 -> u0) (u8 :: u0 -> u0) (u9 :: u0 -> u0) (ua :: Integer -> u0) (ub :: Int -> u0) -> u6; _NO_DEFLT_ }} in let {(uo :: u0) = let {(ud :: Int) = _!_ I# [] [1#]} in case u1 of { _ALG_ _TUP_10 (ue :: {{Eq u0}}) (uf :: {{Text u0}}) (ug :: u0 -> u0 -> u0) (uh :: u0 -> u0 -> u0) (ui :: u0 -> u0 -> u0) (uj :: u0 -> u0) (uk :: u0 -> u0) (ul :: u0 -> u0) (um :: Integer -> u0) (un :: Int -> u0) -> _APP_ un [ ud ]; _NO_DEFLT_ }} in \ (up :: [u0]) -> _APP_ _TYAPP_ _TYAPP_ foldl { u0 } { u0 } [ uc, uo, up ] _SPECIALISE_ [ Double ] 1 { _A_ 1 _U_ 1 _N_ _S_ "S" _F_ _ALWAYS_ \ (u0 :: [Double]) -> let {(u1 :: Double) = _!_ D# [] [1.0000000000000000##]} in _APP_ _TYAPP_ _TYAPP_ foldl { Double } { Double } [ _CONSTM_ Num (*) (Double), u1, u0 ] _N_ }, [ Int ] 1 { _A_ 1 _U_ 1 _N_ _S_ "S" _F_ _ALWAYS_ \ (u0 :: [Int]) -> let {(u1 :: Int) = _!_ I# [] [1#]} in _APP_ _TYAPP_ _TYAPP_ foldl { Int } { Int } [ _CONSTM_ Num (*) (Int), u1, u0 ] _N_ }, [ Integer ] 1 { _A_ 1 _U_ 1 _N_ _S_ "S" _F_ _ALWAYS_ \ (u0 :: [Integer]) -> let {(u1 :: Integer) = _#_ int2Integer# [] [1#]} in _APP_ _TYAPP_ _TYAPP_ foldl { Integer } { Integer } [ _CONSTM_ Num (*) (Integer), u1, u0 ] _N_ }, [ (Complex Double) ] 1 { _A_ 1 _U_ 1 _N_ _S_ "S" _F_ _ALWAYS_ let {(u6 :: Complex Double -> Complex Double -> Complex Double) = \ (u0 :: Complex Double) (u1 :: Complex Double) -> case u0 of { _ALG_ (:+) (u2 :: Double) (u3 :: Double) -> case u1 of { _ALG_ (:+) (u4 :: Double) (u5 :: Double) -> _APP_ _WRKR_ _CONSTM_ Num (*) (Complex Double) [ u2, u3, u4, u5 ]; _NO_DEFLT_ }; _NO_DEFLT_ }} in let {(u8 :: Complex Double) = let {(u7 :: Int) = _!_ I# [] [1#]} in _APP_ _CONSTM_ Num fromInt (Complex Double) [ u7 ]} in \ (u9 :: [Complex Double]) -> _APP_ _TYAPP_ _TYAPP_ foldl { (Complex Double) } { (Complex Double) } [ u6, u8, u9 ] _N_ } #-}
products :: Num a => [a] -> [a]
- {-# GHC_PRAGMA _A_ 1 _U_ 21 _N_ _N_ _N_ _N_ #-}
+ {-# GHC_PRAGMA _A_ 1 _U_ 21 _N_ _N_ _N_ _SPECIALISE_ [ Double ] 1 { _A_ 1 _U_ 1 _N_ _N_ _N_ _N_ }, [ Int ] 1 { _A_ 1 _U_ 1 _N_ _N_ _N_ _N_ }, [ Integer ] 1 { _A_ 1 _U_ 1 _N_ _N_ _F_ _IF_ARGS_ 0 1 X 4 \ (u0 :: [Integer]) -> _APP_ _TYAPP_ _TYAPP_ _ORIG_ PreludeList scanl { Integer } { Integer } [ _CONSTM_ Num (*) (Integer), _SPEC_ _ORIG_ PreludeCore __i1 [ (Integer) ], u0 ] _N_ }, [ (Complex Double) ] 1 { _A_ 1 _U_ 1 _N_ _N_ _N_ _N_ } #-}
repeat :: a -> [a]
{-# GHC_PRAGMA _A_ 1 _U_ 2 _N_ _N_ _F_ _ALWAYS_ _/\_ u0 -> \ (u1 :: u0) -> let {(u6 :: _forall_ a$z1 =>(u0 -> a$z1 -> a$z1) -> a$z1 -> a$z1) = _/\_ u2 -> \ (u3 :: u0 -> u2 -> u2) (u4 :: u2) -> _LETREC_ {(u5 :: u2) = _APP_ u3 [ u1, u5 ]} in u5} in _APP_ _TYAPP_ _build { u0 } [ u6 ] _N_ #-}
reverse :: [a] -> [a]
sum :: Num a => [a] -> a
{-# GHC_PRAGMA _A_ 1 _U_ 22 _N_ _N_ _F_ _ALWAYS_ _/\_ u0 -> \ (u1 :: {{Num u0}}) -> let {(uc :: u0 -> u0 -> u0) = case u1 of { _ALG_ _TUP_10 (u2 :: {{Eq u0}}) (u3 :: {{Text u0}}) (u4 :: u0 -> u0 -> u0) (u5 :: u0 -> u0 -> u0) (u6 :: u0 -> u0 -> u0) (u7 :: u0 -> u0) (u8 :: u0 -> u0) (u9 :: u0 -> u0) (ua :: Integer -> u0) (ub :: Int -> u0) -> u4; _NO_DEFLT_ }} in let {(uo :: u0) = let {(ud :: Int) = _!_ I# [] [0#]} in case u1 of { _ALG_ _TUP_10 (ue :: {{Eq u0}}) (uf :: {{Text u0}}) (ug :: u0 -> u0 -> u0) (uh :: u0 -> u0 -> u0) (ui :: u0 -> u0 -> u0) (uj :: u0 -> u0) (uk :: u0 -> u0) (ul :: u0 -> u0) (um :: Integer -> u0) (un :: Int -> u0) -> _APP_ un [ ud ]; _NO_DEFLT_ }} in \ (up :: [u0]) -> _APP_ _TYAPP_ _TYAPP_ foldl { u0 } { u0 } [ uc, uo, up ] _SPECIALISE_ [ Double ] 1 { _A_ 1 _U_ 1 _N_ _S_ "S" _F_ _ALWAYS_ \ (u0 :: [Double]) -> let {(u1 :: Double) = _!_ D# [] [0.0000000000000000##]} in _APP_ _TYAPP_ _TYAPP_ foldl { Double } { Double } [ _CONSTM_ Num (+) (Double), u1, u0 ] _N_ }, [ Int ] 1 { _A_ 1 _U_ 1 _N_ _S_ "S" _F_ _ALWAYS_ \ (u0 :: [Int]) -> let {(u1 :: Int) = _!_ I# [] [0#]} in _APP_ _TYAPP_ _TYAPP_ foldl { Int } { Int } [ _CONSTM_ Num (+) (Int), u1, u0 ] _N_ }, [ Integer ] 1 { _A_ 1 _U_ 1 _N_ _S_ "S" _F_ _ALWAYS_ \ (u0 :: [Integer]) -> let {(u1 :: Integer) = _#_ int2Integer# [] [0#]} in _APP_ _TYAPP_ _TYAPP_ foldl { Integer } { Integer } [ _CONSTM_ Num (+) (Integer), u1, u0 ] _N_ }, [ (Complex Double) ] 1 { _A_ 1 _U_ 1 _N_ _S_ "S" _F_ _ALWAYS_ let {(u6 :: Complex Double -> Complex Double -> Complex Double) = \ (u0 :: Complex Double) (u1 :: Complex Double) -> case u0 of { _ALG_ (:+) (u2 :: Double) (u3 :: Double) -> case u1 of { _ALG_ (:+) (u4 :: Double) (u5 :: Double) -> _APP_ _WRKR_ _CONSTM_ Num (+) (Complex Double) [ u2, u3, u4, u5 ]; _NO_DEFLT_ }; _NO_DEFLT_ }} in let {(u8 :: Complex Double) = let {(u7 :: Int) = _!_ I# [] [0#]} in _APP_ _CONSTM_ Num fromInt (Complex Double) [ u7 ]} in \ (u9 :: [Complex Double]) -> _APP_ _TYAPP_ _TYAPP_ foldl { (Complex Double) } { (Complex Double) } [ u6, u8, u9 ] _N_ } #-}
sums :: Num a => [a] -> [a]
- {-# GHC_PRAGMA _A_ 1 _U_ 21 _N_ _N_ _N_ _N_ #-}
+ {-# GHC_PRAGMA _A_ 1 _U_ 21 _N_ _N_ _N_ _SPECIALISE_ [ Double ] 1 { _A_ 1 _U_ 1 _N_ _N_ _N_ _N_ }, [ Int ] 1 { _A_ 1 _U_ 1 _N_ _N_ _N_ _N_ }, [ Integer ] 1 { _A_ 1 _U_ 1 _N_ _N_ _F_ _IF_ARGS_ 0 1 X 4 \ (u0 :: [Integer]) -> _APP_ _TYAPP_ _TYAPP_ _ORIG_ PreludeList scanl { Integer } { Integer } [ _CONSTM_ Num (+) (Integer), _SPEC_ _ORIG_ PreludeCore __i0 [ (Integer) ], u0 ] _N_ }, [ (Complex Double) ] 1 { _A_ 1 _U_ 1 _N_ _N_ _N_ _N_ } #-}
tail :: [a] -> [a]
{-# GHC_PRAGMA _A_ 1 _U_ 1 _N_ _S_ "S" _F_ _IF_ARGS_ 1 1 C 5 _/\_ u0 -> \ (u1 :: [u0]) -> case u1 of { _ALG_ (:) (u2 :: u0) (u3 :: [u0]) -> u3; _NIL_ -> _APP_ _TYAPP_ error { [u0] } [ _NOREP_S_ "tail{PreludeList}: tail []\n" ]; _NO_DEFLT_ } _N_ #-}
take :: Integral a => a -> [b] -> [b]
- {-# GHC_PRAGMA _A_ 3 _U_ 121 _N_ _S_ "U(AAAAAAAAAAAS)LL" {_A_ 3 _U_ 121 _N_ _N_ _N_ _N_} _F_ _IF_ARGS_ 2 3 CXX 7 _/\_ u0 u1 -> \ (u2 :: {{Integral u0}}) (u3 :: u0) (u4 :: [u1]) -> let {(uh :: Int) = case u2 of { _ALG_ _TUP_12 (u5 :: {{Real u0}}) (u6 :: {{Ix u0}}) (u7 :: u0 -> u0 -> u0) (u8 :: u0 -> u0 -> u0) (u9 :: u0 -> u0 -> u0) (ua :: u0 -> u0 -> u0) (ub :: u0 -> u0 -> (u0, u0)) (uc :: u0 -> u0 -> (u0, u0)) (ud :: u0 -> Bool) (ue :: u0 -> Bool) (uf :: u0 -> Integer) (ug :: u0 -> Int) -> _APP_ ug [ u3 ]; _NO_DEFLT_ }} in _APP_ _TYAPP_ _SPEC_ _ORIG_ PreludeList take [ (Int), _N_ ] { u1 } [ uh, u4 ] _SPECIALISE_ [ Int, _N_ ] 1 { _A_ 2 _U_ 11 _N_ _S_ "U(P)L" {_A_ 2 _U_ 21 _N_ _N_ _N_ _N_} _N_ _N_ }, [ Integer, _N_ ] 1 { _A_ 2 _U_ 11 _N_ _S_ "U(PPP)L" {_A_ 4 _U_ 2221 _N_ _N_ _F_ _IF_ARGS_ 1 4 XXXX 4 _/\_ u0 -> \ (u1 :: Int#) (u2 :: Int#) (u3 :: ByteArray#) (u4 :: [u0]) -> case _#_ integer2Int# [] [u1, u2, u3] of { _PRIM_ (u5 :: Int#) -> _APP_ _TYAPP_ _WRKR_ _SPEC_ _ORIG_ PreludeList take [ (Int), _N_ ] { u0 } [ u5, u4 ] } _N_} _F_ _ALWAYS_ _/\_ u0 -> \ (u1 :: Integer) (u2 :: [u0]) -> case u1 of { _ALG_ J# (u3 :: Int#) (u4 :: Int#) (u5 :: ByteArray#) -> case _#_ integer2Int# [] [u3, u4, u5] of { _PRIM_ (u6 :: Int#) -> _APP_ _TYAPP_ _WRKR_ _SPEC_ _ORIG_ PreludeList take [ (Int), _N_ ] { u0 } [ u6, u2 ] }; _NO_DEFLT_ } _N_ } #-}
+ {-# GHC_PRAGMA _A_ 1 _U_ 122 _N_ _S_ "U(LU(U(ASSAAAAA)AAA)AAAALAAAAL)" {_A_ 5 _U_ 2121222 _N_ _N_ _N_ _N_} _N_ _SPECIALISE_ [ Int, _N_ ] 1 { _A_ 2 _U_ 11 _N_ _S_ "U(P)L" {_A_ 2 _U_ 21 _N_ _N_ _N_ _N_} _N_ _N_ }, [ Integer, _N_ ] 1 { _A_ 1 _U_ 12 _N_ _S_ "U(PPP)" {_A_ 3 _U_ 2222 _N_ _N_ _N_ _N_} _N_ _N_ } #-}
takeWhile :: (a -> Bool) -> [a] -> [a]
{-# GHC_PRAGMA _A_ 2 _U_ 21 _N_ _S_ "LS" _F_ _ALWAYS_ _/\_ u0 -> \ (u1 :: u0 -> Bool) (u2 :: [u0]) -> let {(u9 :: _forall_ a$z1 =>(u0 -> a$z1 -> a$z1) -> a$z1 -> a$z1) = _/\_ u3 -> \ (u4 :: u0 -> u3 -> u3) (u5 :: u3) -> let {(u8 :: u0 -> u3 -> u3) = \ (u6 :: u0) (u7 :: u3) -> case _APP_ u1 [ u6 ] of { _ALG_ True -> _APP_ u4 [ u6, u7 ]; False -> u5; _NO_DEFLT_ }} in _APP_ _TYAPP_ _TYAPP_ foldr { u0 } { u3 } [ u8, u5, u2 ]} in _APP_ _TYAPP_ _build { u0 } [ u9 ] _N_ #-}
transpose :: [[a]] -> [[a]]
lex :: [Char] -> [([Char], [Char])]
{-# GHC_PRAGMA _A_ 1 _U_ 2 _N_ _S_ "S" _N_ _N_ #-}
read :: Text a => [Char] -> a
- {-# GHC_PRAGMA _A_ 1 _U_ 12 _N_ _S_ "U(SAAA)" {_A_ 1 _U_ 12 _N_ _N_ _N_ _N_} _N_ _SPECIALISE_ [ Double ] 1 { _A_ 1 _U_ 2 _N_ _N_ _N_ _N_ }, [ Float ] 1 { _A_ 1 _U_ 2 _N_ _N_ _N_ _N_ }, [ Int ] 1 { _A_ 1 _U_ 2 _N_ _N_ _N_ _N_ }, [ Integer ] 1 { _A_ 1 _U_ 2 _N_ _N_ _N_ _N_ } #-}
+ {-# GHC_PRAGMA _A_ 1 _U_ 12 _N_ _S_ "U(SAAA)" {_A_ 1 _U_ 12 _N_ _N_ _N_ _N_} _N_ _SPECIALISE_ [ Bool ] 1 { _A_ 1 _U_ 2 _N_ _N_ _N_ _N_ }, [ Char ] 1 { _A_ 1 _U_ 2 _N_ _N_ _N_ _N_ }, [ Double ] 1 { _A_ 1 _U_ 2 _N_ _N_ _N_ _N_ }, [ Int ] 1 { _A_ 1 _U_ 2 _N_ _N_ _N_ _N_ }, [ Integer ] 1 { _A_ 1 _U_ 2 _N_ _N_ _N_ _N_ }, [ [Bool] ] 1 { _A_ 1 _U_ 2 _N_ _N_ _N_ _N_ }, [ [Char] ] 1 { _A_ 1 _U_ 2 _N_ _N_ _N_ _N_ }, [ [Double] ] 1 { _A_ 1 _U_ 2 _N_ _N_ _N_ _N_ }, [ [Float] ] 1 { _A_ 1 _U_ 2 _N_ _N_ _N_ _N_ }, [ [Int] ] 1 { _A_ 1 _U_ 2 _N_ _N_ _N_ _N_ }, [ [Integer] ] 1 { _A_ 1 _U_ 2 _N_ _N_ _N_ _N_ }, [ [[Char]] ] 1 { _A_ 1 _U_ 2 _N_ _N_ _N_ _N_ }, [ [[Int]] ] 1 { _A_ 1 _U_ 2 _N_ _N_ _N_ _N_ }, [ [Complex Double] ] 1 { _A_ 1 _U_ 2 _N_ _N_ _N_ _N_ }, [ (Ratio Integer) ] 1 { _A_ 1 _U_ 2 _N_ _N_ _N_ _N_ }, [ (Array Int Double) ] 1 { _A_ 1 _U_ 2 _N_ _N_ _N_ _N_ }, [ (Array (Int, Int) Double) ] 1 { _A_ 1 _U_ 2 _N_ _N_ _N_ _N_ }, [ _PackedString ] 1 { _A_ 1 _U_ 2 _N_ _S_ _!_ _N_ _N_ }, [ (Complex Double) ] 1 { _A_ 1 _U_ 2 _N_ _N_ _N_ _N_ }, [ () ] 1 { _A_ 1 _U_ 2 _N_ _N_ _N_ _N_ }, [ (Int, Int) ] 1 { _A_ 1 _U_ 2 _N_ _N_ _N_ _N_ }, [ (Integer, Integer) ] 1 { _A_ 1 _U_ 2 _N_ _N_ _N_ _N_ }, [ (Int, Int, Int) ] 1 { _A_ 1 _U_ 2 _N_ _N_ _N_ _N_ } #-}
readDec :: Integral a => [Char] -> [(a, [Char])]
- {-# GHC_PRAGMA _A_ 1 _U_ 22 _N_ _N_ _N_ _SPECIALISE_ [ Int ] 1 { _A_ 1 _U_ 2 _N_ _N_ _N_ _N_ }, [ Integer ] 1 { _A_ 1 _U_ 2 _N_ _S_ "S" _N_ _N_ } #-}
+ {-# GHC_PRAGMA _A_ 1 _U_ 22 _N_ _N_ _N_ _SPECIALISE_ [ Int ] 1 { _A_ 1 _U_ 2 _N_ _N_ _N_ _N_ }, [ Integer ] 1 { _A_ 1 _U_ 2 _N_ _N_ _N_ _N_ } #-}
readFloat :: RealFloat a => [Char] -> [(a, [Char])]
- {-# GHC_PRAGMA _A_ 2 _U_ 12 _N_ _S_ "LS" _N_ _SPECIALISE_ [ Double ] 1 { _A_ 1 _U_ 2 _N_ _S_ "S" _N_ _N_ }, [ Float ] 1 { _A_ 1 _U_ 2 _N_ _S_ "S" _N_ _N_ } #-}
+ {-# GHC_PRAGMA _A_ 2 _U_ 12 _N_ _S_ "LS" _N_ _SPECIALISE_ [ Double ] 1 { _A_ 1 _U_ 2 _N_ _S_ "S" _N_ _N_ } #-}
readLitChar :: [Char] -> [(Char, [Char])]
{-# GHC_PRAGMA _A_ 0 _U_ 1 _N_ _N_ _N_ _N_ #-}
readParen :: Bool -> ([Char] -> [(a, [Char])]) -> [Char] -> [(a, [Char])]
readSigned :: Real a => ([Char] -> [(a, [Char])]) -> [Char] -> [(a, [Char])]
{-# GHC_PRAGMA _A_ 2 _U_ 122 _N_ _N_ _N_ _SPECIALISE_ [ Double ] 1 { _A_ 1 _U_ 22 _N_ _N_ _N_ _N_ }, [ Int ] 1 { _A_ 1 _U_ 22 _N_ _N_ _N_ _N_ }, [ Integer ] 1 { _A_ 1 _U_ 22 _N_ _N_ _N_ _N_ } #-}
reads :: Text a => [Char] -> [(a, [Char])]
- {-# GHC_PRAGMA _A_ 1 _U_ 12 _N_ _S_ "U(SAAA)" {_A_ 1 _U_ 12 _N_ _N_ _N_ _N_} _N_ _SPECIALISE_ [ Double ] 1 { _A_ 1 _U_ 2 _N_ _N_ _N_ _N_ }, [ Float ] 1 { _A_ 1 _U_ 2 _N_ _N_ _N_ _N_ }, [ Int ] 1 { _A_ 1 _U_ 2 _N_ _N_ _N_ _N_ }, [ Integer ] 1 { _A_ 1 _U_ 2 _N_ _N_ _N_ _N_ } #-}
+ {-# GHC_PRAGMA _A_ 1 _U_ 12 _N_ _S_ "U(SAAA)" {_A_ 1 _U_ 12 _N_ _N_ _N_ _N_} _N_ _SPECIALISE_ [ Bool ] 1 { _A_ 1 _U_ 2 _N_ _N_ _N_ _N_ }, [ Char ] 1 { _A_ 0 _U_ 2 _N_ _N_ _N_ _N_ }, [ Double ] 1 { _A_ 1 _U_ 2 _N_ _N_ _N_ _N_ }, [ Int ] 1 { _A_ 1 _U_ 2 _N_ _N_ _N_ _N_ }, [ Integer ] 1 { _A_ 1 _U_ 2 _N_ _N_ _N_ _N_ }, [ [Bool] ] 1 { _A_ 0 _U_ 2 _N_ _N_ _F_ _IF_ARGS_ 0 0 X 1 _CONSTM_ Text readList (Bool) _N_ }, [ [Char] ] 1 { _A_ 0 _U_ 2 _N_ _N_ _F_ _IF_ARGS_ 0 0 X 1 _CONSTM_ Text readList (Char) _N_ }, [ [Double] ] 1 { _A_ 0 _U_ 2 _N_ _N_ _F_ _IF_ARGS_ 0 0 X 1 _CONSTM_ Text readList (Double) _N_ }, [ [Float] ] 1 { _A_ 0 _U_ 2 _N_ _N_ _N_ _N_ }, [ [Int] ] 1 { _A_ 0 _U_ 2 _N_ _N_ _F_ _IF_ARGS_ 0 0 X 1 _CONSTM_ Text readList (Int) _N_ }, [ [Integer] ] 1 { _A_ 0 _U_ 2 _N_ _N_ _F_ _IF_ARGS_ 0 0 X 1 _CONSTM_ Text readList (Integer) _N_ }, [ [[Char]] ] 1 { _A_ 0 _U_ 2 _N_ _N_ _F_ _IF_ARGS_ 0 0 X 1 _CONSTM_ Text readList ([Char]) _N_ }, [ [[Int]] ] 1 { _A_ 0 _U_ 2 _N_ _N_ _F_ _IF_ARGS_ 0 0 X 1 _CONSTM_ Text readList ([Int]) _N_ }, [ [Complex Double] ] 1 { _A_ 0 _U_ 2 _N_ _N_ _F_ _IF_ARGS_ 0 0 X 1 _CONSTM_ Text readList (Complex Double) _N_ }, [ (Ratio Integer) ] 1 { _A_ 0 _U_ 2 _N_ _N_ _N_ _N_ }, [ (Array Int Double) ] 1 { _A_ 0 _U_ 2 _N_ _N_ _N_ _N_ }, [ (Array (Int, Int) Double) ] 1 { _A_ 0 _U_ 2 _N_ _N_ _N_ _N_ }, [ _PackedString ] 1 { _A_ 1 _U_ 2 _N_ _S_ _!_ _N_ _N_ }, [ (Complex Double) ] 1 { _A_ 0 _U_ 2 _N_ _N_ _N_ _N_ }, [ () ] 1 { _A_ 0 _U_ 2 _N_ _N_ _N_ _N_ }, [ (Int, Int) ] 1 { _A_ 0 _U_ 2 _N_ _N_ _N_ _N_ }, [ (Integer, Integer) ] 1 { _A_ 0 _U_ 2 _N_ _N_ _N_ _N_ }, [ (Int, Int, Int) ] 1 { _A_ 0 _U_ 2 _N_ _N_ _N_ _N_ } #-}
show :: Text a => a -> [Char]
- {-# GHC_PRAGMA _A_ 1 _U_ 12 _N_ _S_ "U(ASAA)" {_A_ 1 _U_ 12 _N_ _N_ _N_ _N_} _N_ _SPECIALISE_ [ Char ] 1 { _A_ 1 _U_ 1 _N_ _S_ "U(P)" {_A_ 1 _U_ 2 _N_ _N_ _N_ _N_} _N_ _N_ }, [ Double ] 1 { _A_ 1 _U_ 1 _N_ _S_ "U(P)" {_A_ 1 _U_ 2 _N_ _N_ _N_ _N_} _N_ _N_ }, [ Float ] 1 { _A_ 1 _U_ 2 _N_ _N_ _N_ _N_ }, [ Int ] 1 { _A_ 1 _U_ 1 _N_ _S_ "U(P)" {_A_ 1 _U_ 2 _N_ _N_ _N_ _N_} _N_ _N_ }, [ Integer ] 1 { _A_ 1 _U_ 1 _N_ _S_ "U(PPP)" {_A_ 3 _U_ 222 _N_ _N_ _N_ _N_} _N_ _N_ }, [ [Char] ] 1 { _A_ 1 _U_ 2 _N_ _N_ _N_ _N_ }, [ _PackedString ] 1 { _A_ 1 _U_ 1 _N_ _N_ _N_ _N_ }, [ (Int, Int) ] 1 { _A_ 1 _U_ 1 _N_ _S_ "U(LL)" {_A_ 2 _U_ 22 _N_ _N_ _N_ _N_} _N_ _N_ }, [ (Integer, Integer) ] 1 { _A_ 1 _U_ 1 _N_ _S_ "U(LL)" {_A_ 2 _U_ 22 _N_ _N_ _N_ _N_} _N_ _N_ } #-}
+ {-# GHC_PRAGMA _A_ 1 _U_ 12 _N_ _S_ "U(ASAA)" {_A_ 1 _U_ 12 _N_ _N_ _N_ _N_} _N_ _SPECIALISE_ [ Bool ] 1 { _A_ 1 _U_ 2 _N_ _S_ "E" _N_ _N_ }, [ Char ] 1 { _A_ 1 _U_ 1 _N_ _S_ "U(P)" {_A_ 1 _U_ 2 _N_ _N_ _N_ _N_} _N_ _N_ }, [ Double ] 1 { _A_ 1 _U_ 1 _N_ _S_ "U(P)" {_A_ 1 _U_ 2 _N_ _N_ _N_ _N_} _N_ _N_ }, [ Int ] 1 { _A_ 1 _U_ 1 _N_ _S_ "U(P)" {_A_ 1 _U_ 2 _N_ _N_ _N_ _N_} _N_ _N_ }, [ Integer ] 1 { _A_ 1 _U_ 1 _N_ _S_ "U(PPP)" {_A_ 3 _U_ 222 _N_ _N_ _N_ _N_} _N_ _N_ }, [ [Bool] ] 1 { _A_ 1 _U_ 1 _N_ _S_ "S" _N_ _N_ }, [ [Char] ] 1 { _A_ 1 _U_ 2 _N_ _N_ _N_ _N_ }, [ [Double] ] 1 { _A_ 1 _U_ 2 _N_ _N_ _N_ _N_ }, [ [Int] ] 1 { _A_ 1 _U_ 2 _N_ _N_ _N_ _N_ }, [ [Integer] ] 1 { _A_ 1 _U_ 2 _N_ _N_ _N_ _N_ }, [ [[Char]] ] 1 { _A_ 1 _U_ 1 _N_ _S_ "S" _N_ _N_ }, [ [[Int]] ] 1 { _A_ 1 _U_ 1 _N_ _S_ "S" _N_ _N_ }, [ [Complex Double] ] 1 { _A_ 1 _U_ 2 _N_ _N_ _N_ _N_ }, [ (Ratio Integer) ] 1 { _A_ 1 _U_ 1 _N_ _S_ "U(LL)" {_A_ 2 _U_ 22 _N_ _N_ _N_ _N_} _N_ _N_ }, [ (Array Int Double) ] 1 { _A_ 1 _U_ 2 _N_ _N_ _N_ _N_ }, [ (Array (Int, Int) Double) ] 1 { _A_ 1 _U_ 2 _N_ _N_ _N_ _N_ }, [ _PackedString ] 1 { _A_ 1 _U_ 1 _N_ _N_ _N_ _N_ }, [ (Complex Double) ] 1 { _A_ 1 _U_ 1 _N_ _S_ "U(LL)" {_A_ 2 _U_ 22 _N_ _N_ _N_ _N_} _N_ _N_ }, [ () ] 1 { _A_ 1 _U_ 1 _N_ _S_ "E" _N_ _N_ }, [ (Int, Int) ] 1 { _A_ 1 _U_ 1 _N_ _S_ "U(LL)" {_A_ 2 _U_ 22 _N_ _N_ _N_ _N_} _N_ _N_ }, [ (Integer, Integer) ] 1 { _A_ 1 _U_ 1 _N_ _S_ "U(LL)" {_A_ 2 _U_ 22 _N_ _N_ _N_ _N_} _N_ _N_ }, [ (Int, Int, Int) ] 1 { _A_ 1 _U_ 1 _N_ _S_ "U(LLL)" {_A_ 3 _U_ 222 _N_ _N_ _N_ _N_} _N_ _N_ } #-}
showChar :: Char -> [Char] -> [Char]
{-# GHC_PRAGMA _A_ 2 _U_ 22 _N_ _N_ _F_ _IF_ARGS_ 0 2 XX 3 \ (u0 :: Char) (u1 :: [Char]) -> _!_ (:) [Char] [u0, u1] _N_ #-}
showFloat :: RealFloat a => a -> [Char] -> [Char]
- {-# GHC_PRAGMA _A_ 1 _U_ 122 _N_ _S_ "U(U(LU(SLLL)LAAAA)LLLALAAAA)" {_A_ 5 _U_ 1122222 _N_ _N_ _N_ _N_} _N_ _SPECIALISE_ [ Double ] 1 { _A_ 1 _U_ 12 _N_ _S_ "U(P)" {_A_ 1 _U_ 22 _N_ _N_ _N_ _N_} _N_ _N_ }, [ Float ] 1 { _A_ 0 _U_ 22 _N_ _N_ _N_ _N_ } #-}
+ {-# GHC_PRAGMA _A_ 1 _U_ 122 _N_ _S_ "U(U(AU(SAAA)AAAAL)LLLALAAAA)" {_A_ 5 _U_ 1122222 _N_ _N_ _N_ _N_} _N_ _SPECIALISE_ [ Double ] 1 { _A_ 1 _U_ 12 _N_ _S_ "U(P)" {_A_ 1 _U_ 22 _N_ _N_ _N_ _N_} _N_ _N_ } #-}
showInt :: Integral a => a -> [Char] -> [Char]
{-# GHC_PRAGMA _A_ 1 _U_ 122 _N_ _S_ "U(U(U(U(SL)LLLLLLLLL)LL)LLLLLSLLLLL)" _N_ _SPECIALISE_ [ Int ] 1 { _A_ 2 _U_ 12 _N_ _S_ "U(P)L" {_A_ 2 _U_ 22 _N_ _N_ _N_ _N_} _N_ _N_ }, [ Integer ] 1 { _A_ 2 _U_ 12 _N_ _S_ "U(PPP)L" {_A_ 4 _U_ 2222 _N_ _N_ _N_ _N_} _N_ _N_ } #-}
showLitChar :: Char -> [Char] -> [Char]
showString :: [Char] -> [Char] -> [Char]
{-# GHC_PRAGMA _A_ 2 _U_ 12 _N_ _N_ _F_ _IF_ARGS_ 0 0 X 1 _TYAPP_ _ORIG_ PreludeList (++) { Char } _N_ #-}
shows :: Text a => a -> [Char] -> [Char]
- {-# GHC_PRAGMA _A_ 1 _U_ 122 _N_ _S_ "U(ASAA)" {_A_ 1 _U_ 122 _N_ _N_ _N_ _N_} _N_ _SPECIALISE_ [ Char ] 1 { _A_ 2 _U_ 12 _N_ _S_ "U(P)L" {_A_ 2 _U_ 22 _N_ _N_ _N_ _N_} _N_ _N_ }, [ Double ] 1 { _A_ 1 _U_ 12 _N_ _S_ "U(P)" {_A_ 1 _U_ 22 _N_ _N_ _N_ _N_} _N_ _N_ }, [ Float ] 1 { _A_ 0 _U_ 22 _N_ _N_ _N_ _N_ }, [ Int ] 1 { _A_ 2 _U_ 12 _N_ _S_ "U(P)L" {_A_ 2 _U_ 22 _N_ _N_ _N_ _N_} _N_ _N_ }, [ Integer ] 1 { _A_ 2 _U_ 12 _N_ _S_ "U(PPP)L" {_A_ 4 _U_ 2222 _N_ _N_ _N_ _N_} _N_ _N_ }, [ [Char] ] 1 { _A_ 1 _U_ 22 _N_ _N_ _F_ _IF_ARGS_ 0 0 X 1 _CONSTM_ Text showList (Char) _N_ }, [ _PackedString ] 1 { _A_ 2 _U_ 12 _N_ _N_ _N_ _N_ }, [ (Int, Int) ] 1 { _A_ 2 _U_ 12 _N_ _S_ "U(LL)L" {_A_ 3 _U_ 222 _N_ _N_ _N_ _N_} _N_ _N_ }, [ (Integer, Integer) ] 1 { _A_ 2 _U_ 12 _N_ _S_ "U(LL)L" {_A_ 3 _U_ 222 _N_ _N_ _N_ _N_} _N_ _N_ } #-}
+ {-# GHC_PRAGMA _A_ 1 _U_ 122 _N_ _S_ "U(ASAA)" {_A_ 1 _U_ 122 _N_ _N_ _N_ _N_} _N_ _SPECIALISE_ [ Bool ] 1 { _A_ 2 _U_ 22 _N_ _N_ _N_ _N_ }, [ Char ] 1 { _A_ 2 _U_ 12 _N_ _S_ "U(P)L" {_A_ 2 _U_ 22 _N_ _N_ _N_ _N_} _N_ _N_ }, [ Double ] 1 { _A_ 1 _U_ 12 _N_ _S_ "U(P)" {_A_ 1 _U_ 22 _N_ _N_ _N_ _N_} _N_ _N_ }, [ Int ] 1 { _A_ 2 _U_ 12 _N_ _S_ "U(P)L" {_A_ 2 _U_ 22 _N_ _N_ _N_ _N_} _N_ _N_ }, [ Integer ] 1 { _A_ 2 _U_ 12 _N_ _S_ "U(PPP)L" {_A_ 4 _U_ 2222 _N_ _N_ _N_ _N_} _N_ _N_ }, [ [Bool] ] 1 { _A_ 1 _U_ 12 _N_ _S_ "S" _F_ _IF_ARGS_ 0 1 X 3 \ (u0 :: [Bool]) -> _APP_ _TYAPP_ _ORIG_ PreludeCore _showList { Bool } [ _WRKR_ _CONSTM_ Text showsPrec (Bool), u0 ] _N_ }, [ [Char] ] 1 { _A_ 1 _U_ 22 _N_ _N_ _F_ _IF_ARGS_ 0 0 X 1 _CONSTM_ Text showList (Char) _N_ }, [ [Double] ] 1 { _A_ 1 _U_ 22 _N_ _N_ _F_ _IF_ARGS_ 0 0 X 1 _CONSTM_ Text showList (Double) _N_ }, [ [Int] ] 1 { _A_ 1 _U_ 22 _N_ _N_ _F_ _IF_ARGS_ 0 0 X 1 _CONSTM_ Text showList (Int) _N_ }, [ [Integer] ] 1 { _A_ 1 _U_ 22 _N_ _N_ _F_ _IF_ARGS_ 0 0 X 1 _CONSTM_ Text showList (Integer) _N_ }, [ [[Char]] ] 1 { _A_ 1 _U_ 12 _N_ _S_ "S" _F_ _IF_ARGS_ 0 1 X 3 \ (u0 :: [[Char]]) -> _APP_ _TYAPP_ _ORIG_ PreludeCore _showList { [Char] } [ _CONSTM_ Text showList (Char), u0 ] _N_ }, [ [[Int]] ] 1 { _A_ 1 _U_ 12 _N_ _S_ "S" _F_ _IF_ARGS_ 0 1 X 3 \ (u0 :: [[Int]]) -> _APP_ _TYAPP_ _ORIG_ PreludeCore _showList { [Int] } [ _CONSTM_ Text showList (Int), u0 ] _N_ }, [ [Complex Double] ] 1 { _A_ 1 _U_ 22 _N_ _N_ _F_ _IF_ARGS_ 0 0 X 1 _CONSTM_ Text showList (Complex Double) _N_ }, [ (Ratio Integer) ] 1 { _A_ 1 _U_ 12 _N_ _S_ "U(LL)" {_A_ 2 _U_ 222 _N_ _N_ _N_ _N_} _N_ _N_ }, [ (Array Int Double) ] 1 { _A_ 1 _U_ 22 _N_ _N_ _N_ _N_ }, [ (Array (Int, Int) Double) ] 1 { _A_ 1 _U_ 22 _N_ _N_ _N_ _N_ }, [ _PackedString ] 1 { _A_ 2 _U_ 12 _N_ _N_ _N_ _N_ }, [ (Complex Double) ] 1 { _A_ 1 _U_ 12 _N_ _S_ "U(LL)" {_A_ 2 _U_ 222 _N_ _N_ _N_ _N_} _N_ _N_ }, [ () ] 1 { _A_ 2 _U_ 12 _N_ _S_ "EL" _F_ _IF_ARGS_ 0 2 CX 4 \ (u0 :: ()) (u1 :: [Char]) -> case u0 of { _ALG_ _TUP_0 -> _APP_ _TYAPP_ _ORIG_ PreludeList (++) { Char } [ _NOREP_S_ "()", u1 ]; _NO_DEFLT_ } _N_ }, [ (Int, Int) ] 1 { _A_ 2 _U_ 12 _N_ _S_ "U(LL)L" {_A_ 3 _U_ 222 _N_ _N_ _N_ _N_} _N_ _N_ }, [ (Integer, Integer) ] 1 { _A_ 2 _U_ 12 _N_ _S_ "U(LL)L" {_A_ 3 _U_ 222 _N_ _N_ _N_ _N_} _N_ _N_ }, [ (Int, Int, Int) ] 1 { _A_ 2 _U_ 12 _N_ _S_ "U(LLL)L" {_A_ 4 _U_ 2222 _N_ _N_ _N_ _N_} _N_ _N_ } #-}
-{-# GHC_PRAGMA INTERFACE VERSION 5 #-}
+{-# GHC_PRAGMA INTERFACE VERSION 6 #-}
interface Prelude where
import PreludeArray((!), (//), Array, Assoc, _ByteArray, accum, accumArray, amap, array, assocs, bounds, elems, indices, ixmap, listArray)
import PreludeBuiltin(Bin, Char(..), Int(..), Integer(..), List(..), Tuple0, Tuple2, Tuple3, Tuple4, Tuple5, Tuple6, Tuple7, _Addr(..), _RealWorld(..), _State(..))
import PreludeComplex(Complex, cis, conjugate, imagPart, magnitude, mkPolar, phase, polar, realPart)
-import PreludeCore(Bool(..), Eq(..), Fractional(..), Integral(..), Ix(..), Num(..), Ord(..), Real(..), RealFloat(..), RealFrac(..), Text(..), _ceiling, _floor, _readList, _round, _showList, _showRational, _truncate)
+import PreludeCore(Bool(..), Eq(..), Fractional(..), Integral(..), Ix(..), Num(..), Ord(..), Real(..), RealFloat(..), RealFrac(..), Text(..), _readList, _showList, _showRational)
import PreludeIO(IOError, Request, Response, SigAct, abort, appendBinChan, appendBinFile, appendChan, appendFile, binDispatch, deleteFile, done, echo, exit, getArgs, getEnv, getProgName, interact, print, prints, readBinChan, readBinFile, readChan, readFile, setEnv, sigAction, statusChan, statusFile, stdecho, stderr, stdin, stdout, strDispatch, strListDispatch, succDispatch, writeBinFile, writeFile)
import PreludeList((!!), (++), (\\), all, and, any, break, concat, cycle, drop, dropWhile, elem, filter, foldl1, foldr1, genericLength, head, init, iterate, last, length, lines, map, maximum, minimum, notElem, nub, null, or, partition, product, products, repeat, reverse, scanl, scanl1, scanr, scanr1, span, splitAt, sum, sums, tail, take, takeWhile, transpose, unlines, unwords, unzip, unzip3, unzip4, unzip5, unzip6, unzip7, words, zip, zip3, zip4, zip5, zip6, zip7, zipWith, zipWith3, zipWith4, zipWith5, zipWith6, zipWith7)
import PreludePS(_PackedString, _appendPS, _breakPS, _byteArrayToPS, _concatPS, _consPS, _dropPS, _dropWhilePS, _filterPS, _foldlPS, _foldrPS, _headPS, _indexPS, _lengthPS, _linesPS, _mapPS, _nilPS, _nullPS, _packCBytes, _packCString, _packString, _psToByteArray, _putPS, _reversePS, _spanPS, _splitAtPS, _substrPS, _tailPS, _takePS, _takeWhilePS, _unpackPS, _wordsPS)
(.) :: (a -> c) -> (b -> a) -> b -> c
{-# GHC_PRAGMA _A_ 3 _U_ 112 _N_ _S_ "SLL" _F_ _ALWAYS_ _/\_ u0 u1 u2 -> \ (u3 :: u0 -> u2) (u4 :: u1 -> u0) (u5 :: u1) -> let {(u6 :: u0) = _APP_ u4 [ u5 ]} in _APP_ u3 [ u6 ] _N_ #-}
(^) :: (Num b, Integral a) => b -> a -> b
- {-# GHC_PRAGMA _A_ 2 _U_ 2122 _N_ _S_ "LU(U(LU(U(U(SA)AALAAAA)AAAA)A)AAALAAAALAA)" {_A_ 5 _U_ 2212222 _N_ _N_ _N_ _N_} _N_ _SPECIALISE_ [ Int, Double ] 2 { _A_ 2 _U_ 21 _N_ _S_ "LU(P)" {_A_ 2 _U_ 22 _N_ _N_ _N_ _N_} _N_ _N_ }, [ Int, Int ] 2 { _A_ 2 _U_ 21 _N_ _S_ "LU(P)" {_A_ 2 _U_ 22 _N_ _N_ _N_ _N_} _N_ _N_ }, [ Int, Integer ] 2 { _A_ 2 _U_ 21 _N_ _S_ "LU(P)" {_A_ 2 _U_ 22 _N_ _N_ _N_ _N_} _N_ _N_ }, [ Int, (Ratio Integer) ] 2 { _A_ 2 _U_ 21 _N_ _S_ "LU(P)" {_A_ 2 _U_ 22 _N_ _N_ _N_ _N_} _N_ _N_ }, [ Int, (Complex Double) ] 2 { _A_ 2 _U_ 21 _N_ _S_ "LU(P)" {_A_ 2 _U_ 22 _N_ _N_ _N_ _N_} _N_ _N_ } #-}
+ {-# GHC_PRAGMA _A_ 2 _U_ 2222 _N_ _S_ "LU(U(LU(U(U(SL)LLLLLLL)LLLL)L)LLLLLLLLLLL)" _N_ _SPECIALISE_ [ Int, Double ] 2 { _A_ 2 _U_ 21 _N_ _S_ "LU(P)" {_A_ 2 _U_ 22 _N_ _N_ _N_ _N_} _N_ _N_ }, [ Int, Int ] 2 { _A_ 2 _U_ 21 _N_ _S_ "LU(P)" {_A_ 2 _U_ 22 _N_ _N_ _N_ _N_} _N_ _N_ }, [ Int, Integer ] 2 { _A_ 2 _U_ 21 _N_ _S_ "LU(P)" {_A_ 2 _U_ 22 _N_ _N_ _N_ _N_} _N_ _N_ }, [ Int, (Ratio Integer) ] 2 { _A_ 2 _U_ 21 _N_ _S_ "LU(P)" {_A_ 2 _U_ 22 _N_ _N_ _N_ _N_} _N_ _N_ }, [ Int, (Complex Double) ] 2 { _A_ 2 _U_ 21 _N_ _S_ "LU(P)" {_A_ 2 _U_ 22 _N_ _N_ _N_ _N_} _N_ _N_ }, [ Integer, Integer ] 2 { _A_ 2 _U_ 21 _N_ _S_ "LU(PPP)" {_A_ 4 _U_ 2222 _N_ _N_ _N_ _N_} _N_ _N_ } #-}
(^^) :: (Fractional b, Integral a) => b -> a -> b
- {-# GHC_PRAGMA _A_ 2 _U_ 2122 _N_ _S_ "LU(LU(U(AAASAAAA)AAA)AALAAAALAA)" {_A_ 5 _U_ 2212222 _N_ _N_ _N_ _N_} _N_ _SPECIALISE_ [ Int, Double ] 2 { _A_ 2 _U_ 21 _N_ _S_ "LU(P)" {_A_ 2 _U_ 22 _N_ _N_ _N_ _N_} _N_ _N_ }, [ Int, (Ratio Integer) ] 2 { _A_ 2 _U_ 21 _N_ _S_ "LU(P)" {_A_ 2 _U_ 22 _N_ _N_ _N_ _N_} _N_ _N_ } #-}
+ {-# GHC_PRAGMA _A_ 2 _U_ 2222 _N_ _S_ "LU(LU(U(LLLSLLLL)LLL)LLLLLLLLLL)" _N_ _SPECIALISE_ [ Int, Double ] 2 { _A_ 2 _U_ 21 _N_ _S_ "LU(P)" {_A_ 2 _U_ 22 _N_ _N_ _N_ _N_} _N_ _N_ }, [ Int, (Ratio Integer) ] 2 { _A_ 2 _U_ 21 _N_ _S_ "LU(P)" {_A_ 2 _U_ 22 _N_ _N_ _N_ _N_} _N_ _N_ }, [ Int, (Complex Double) ] 2 { _A_ 2 _U_ 21 _N_ _S_ "LU(P)" {_A_ 2 _U_ 22 _N_ _N_ _N_ _N_} _N_ _N_ } #-}
appendBin :: Bin -> Bin -> Bin
- {-# GHC_PRAGMA _A_ 2 _U_ 22 _N_ _S_ _!_ _F_ _IF_ARGS_ 0 2 XX 4 \ (u0 :: Bin) (u1 :: Bin) -> _APP_ _TYAPP_ error { (Bin -> Bin -> Bin) } [ _NOREP_S_ "appendBin{Prelude}\n", u0, u1 ] _N_ #-}
+ {-# GHC_PRAGMA _A_ 2 _U_ 22 _N_ _S_ _!_ _N_ _N_ #-}
asTypeOf :: a -> a -> a
{-# GHC_PRAGMA _A_ 2 _U_ 10 _N_ _N_ _F_ _IF_ARGS_ 1 0 X 1 _/\_ u0 -> _TYAPP_ _TYAPP_ _ORIG_ Prelude const { u0 } { u0 } _N_ #-}
atan2 :: RealFloat a => a -> a -> a
flip :: (b -> a -> c) -> a -> b -> c
{-# GHC_PRAGMA _A_ 3 _U_ 122 _N_ _S_ "SLL" _F_ _IF_ARGS_ 3 3 XXX 3 _/\_ u0 u1 u2 -> \ (u3 :: u1 -> u0 -> u2) (u4 :: u0) (u5 :: u1) -> _APP_ u3 [ u5, u4 ] _N_ #-}
fromIntegral :: (Integral a, Num b) => a -> b
- {-# GHC_PRAGMA _A_ 3 _U_ 112 _N_ _S_ "LU(AAAAAAAASA)L" {_A_ 3 _U_ 112 _N_ _N_ _F_ _IF_ARGS_ 2 3 CXX 6 _/\_ u0 u1 -> \ (u2 :: {{Integral u0}}) (u3 :: Integer -> u1) (u4 :: u0) -> let {(uh :: Integer) = case u2 of { _ALG_ _TUP_12 (u5 :: {{Real u0}}) (u6 :: {{Ix u0}}) (u7 :: u0 -> u0 -> u0) (u8 :: u0 -> u0 -> u0) (u9 :: u0 -> u0 -> u0) (ua :: u0 -> u0 -> u0) (ub :: u0 -> u0 -> (u0, u0)) (uc :: u0 -> u0 -> (u0, u0)) (ud :: u0 -> Bool) (ue :: u0 -> Bool) (uf :: u0 -> Integer) (ug :: u0 -> Int) -> _APP_ uf [ u4 ]; _NO_DEFLT_ }} in _APP_ u3 [ uh ] _N_} _F_ _IF_ARGS_ 2 3 CCX 7 _/\_ u0 u1 -> \ (u2 :: {{Integral u0}}) (u3 :: {{Num u1}}) (u4 :: u0) -> let {(uh :: Integer) = case u2 of { _ALG_ _TUP_12 (u5 :: {{Real u0}}) (u6 :: {{Ix u0}}) (u7 :: u0 -> u0 -> u0) (u8 :: u0 -> u0 -> u0) (u9 :: u0 -> u0 -> u0) (ua :: u0 -> u0 -> u0) (ub :: u0 -> u0 -> (u0, u0)) (uc :: u0 -> u0 -> (u0, u0)) (ud :: u0 -> Bool) (ue :: u0 -> Bool) (uf :: u0 -> Integer) (ug :: u0 -> Int) -> _APP_ uf [ u4 ]; _NO_DEFLT_ }} in case u3 of { _ALG_ _TUP_10 (ui :: {{Eq u1}}) (uj :: {{Text u1}}) (uk :: u1 -> u1 -> u1) (ul :: u1 -> u1 -> u1) (um :: u1 -> u1 -> u1) (un :: u1 -> u1) (uo :: u1 -> u1) (up :: u1 -> u1) (uq :: Integer -> u1) (ur :: Int -> u1) -> _APP_ uq [ uh ]; _NO_DEFLT_ } _SPECIALISE_ [ Int, Double ] 2 { _A_ 1 _U_ 1 _N_ _S_ "U(P)" {_A_ 1 _U_ 2 _N_ _N_ _F_ _IF_ARGS_ 0 1 X 3 \ (u0 :: Int#) -> case _#_ int2Double# [] [u0] of { _PRIM_ (u1 :: Double#) -> _!_ D# [] [u1] } _N_} _F_ _IF_ARGS_ 0 1 C 4 \ (u0 :: Int) -> case u0 of { _ALG_ I# (u1 :: Int#) -> case _#_ int2Double# [] [u1] of { _PRIM_ (u2 :: Double#) -> _!_ D# [] [u2] }; _NO_DEFLT_ } _N_ }, [ Int, Int ] 2 { _A_ 1 _U_ 1 _N_ _N_ _F_ _IF_ARGS_ 0 0 X 1 _TYAPP_ _ORIG_ Prelude id { Int } _N_ }, [ Int, Integer ] 2 { _A_ 1 _U_ 1 _N_ _S_ "U(P)" {_A_ 1 _U_ 2 _N_ _N_ _F_ _IF_ARGS_ 0 1 X 1 \ (u0 :: Int#) -> _#_ int2Integer# [] [u0] _N_} _F_ _IF_ARGS_ 0 1 C 2 \ (u0 :: Int) -> case u0 of { _ALG_ I# (u1 :: Int#) -> _#_ int2Integer# [] [u1]; _NO_DEFLT_ } _N_ }, [ Integer, Double ] 2 { _A_ 1 _U_ 1 _N_ _S_ "U(PPP)" {_A_ 3 _U_ 222 _N_ _N_ _F_ _IF_ARGS_ 0 3 XXX 3 \ (u0 :: Int#) (u1 :: Int#) (u2 :: ByteArray#) -> case _#_ encodeDouble# [] [u0, u1, u2, 0#] of { _PRIM_ (u3 :: Double#) -> _!_ D# [] [u3] } _N_} _F_ _IF_ARGS_ 0 1 C 4 \ (u0 :: Integer) -> case u0 of { _ALG_ J# (u1 :: Int#) (u2 :: Int#) (u3 :: ByteArray#) -> case _#_ encodeDouble# [] [u1, u2, u3, 0#] of { _PRIM_ (u4 :: Double#) -> _!_ D# [] [u4] }; _NO_DEFLT_ } _N_ }, [ Integer, Int ] 2 { _A_ 1 _U_ 1 _N_ _S_ "U(PPP)" {_A_ 3 _U_ 222 _N_ _N_ _F_ _IF_ARGS_ 0 3 XXX 3 \ (u0 :: Int#) (u1 :: Int#) (u2 :: ByteArray#) -> case _#_ integer2Int# [] [u0, u1, u2] of { _PRIM_ (u3 :: Int#) -> _!_ I# [] [u3] } _N_} _F_ _IF_ARGS_ 0 1 C 4 \ (u0 :: Integer) -> case u0 of { _ALG_ J# (u1 :: Int#) (u2 :: Int#) (u3 :: ByteArray#) -> case _#_ integer2Int# [] [u1, u2, u3] of { _PRIM_ (u4 :: Int#) -> _!_ I# [] [u4] }; _NO_DEFLT_ } _N_ }, [ Integer, Integer ] 2 { _A_ 1 _U_ 1 _N_ _N_ _F_ _IF_ARGS_ 0 0 X 1 _TYAPP_ _ORIG_ Prelude id { Integer } _N_ } #-}
+ {-# GHC_PRAGMA _A_ 3 _U_ 112 _N_ _S_ "LU(AAAAAAAASA)L" {_A_ 3 _U_ 112 _N_ _N_ _F_ _IF_ARGS_ 2 3 CXX 6 _/\_ u0 u1 -> \ (u2 :: {{Integral u0}}) (u3 :: Integer -> u1) (u4 :: u0) -> let {(uh :: Integer) = case u2 of { _ALG_ _TUP_12 (u5 :: {{Real u0}}) (u6 :: {{Ix u0}}) (u7 :: u0 -> u0 -> u0) (u8 :: u0 -> u0 -> u0) (u9 :: u0 -> u0 -> u0) (ua :: u0 -> u0 -> u0) (ub :: u0 -> u0 -> (u0, u0)) (uc :: u0 -> u0 -> (u0, u0)) (ud :: u0 -> Bool) (ue :: u0 -> Bool) (uf :: u0 -> Integer) (ug :: u0 -> Int) -> _APP_ uf [ u4 ]; _NO_DEFLT_ }} in _APP_ u3 [ uh ] _N_} _F_ _IF_ARGS_ 2 3 CCX 7 _/\_ u0 u1 -> \ (u2 :: {{Integral u0}}) (u3 :: {{Num u1}}) (u4 :: u0) -> let {(uh :: Integer) = case u2 of { _ALG_ _TUP_12 (u5 :: {{Real u0}}) (u6 :: {{Ix u0}}) (u7 :: u0 -> u0 -> u0) (u8 :: u0 -> u0 -> u0) (u9 :: u0 -> u0 -> u0) (ua :: u0 -> u0 -> u0) (ub :: u0 -> u0 -> (u0, u0)) (uc :: u0 -> u0 -> (u0, u0)) (ud :: u0 -> Bool) (ue :: u0 -> Bool) (uf :: u0 -> Integer) (ug :: u0 -> Int) -> _APP_ uf [ u4 ]; _NO_DEFLT_ }} in case u3 of { _ALG_ _TUP_10 (ui :: {{Eq u1}}) (uj :: {{Text u1}}) (uk :: u1 -> u1 -> u1) (ul :: u1 -> u1 -> u1) (um :: u1 -> u1 -> u1) (un :: u1 -> u1) (uo :: u1 -> u1) (up :: u1 -> u1) (uq :: Integer -> u1) (ur :: Int -> u1) -> _APP_ uq [ uh ]; _NO_DEFLT_ } _SPECIALISE_ [ Int, Double ] 2 { _A_ 1 _U_ 1 _N_ _S_ "U(P)" {_A_ 1 _U_ 2 _N_ _N_ _F_ _IF_ARGS_ 0 1 X 3 \ (u0 :: Int#) -> case _#_ int2Double# [] [u0] of { _PRIM_ (u1 :: Double#) -> _!_ D# [] [u1] } _N_} _F_ _IF_ARGS_ 0 1 C 4 \ (u0 :: Int) -> case u0 of { _ALG_ I# (u1 :: Int#) -> case _#_ int2Double# [] [u1] of { _PRIM_ (u2 :: Double#) -> _!_ D# [] [u2] }; _NO_DEFLT_ } _N_ }, [ Int, Float ] 2 { _A_ 1 _U_ 1 _N_ _S_ "U(P)" {_A_ 1 _U_ 2 _N_ _N_ _F_ _IF_ARGS_ 0 1 X 3 \ (u0 :: Int#) -> case _#_ int2Float# [] [u0] of { _PRIM_ (u1 :: Float#) -> _!_ F# [] [u1] } _N_} _F_ _IF_ARGS_ 0 1 C 4 \ (u0 :: Int) -> case u0 of { _ALG_ I# (u1 :: Int#) -> case _#_ int2Float# [] [u1] of { _PRIM_ (u2 :: Float#) -> _!_ F# [] [u2] }; _NO_DEFLT_ } _N_ }, [ Int, Int ] 2 { _A_ 1 _U_ 1 _N_ _N_ _F_ _IF_ARGS_ 0 0 X 1 _TYAPP_ _ORIG_ Prelude id { Int } _N_ }, [ Int, Integer ] 2 { _A_ 1 _U_ 1 _N_ _S_ "U(P)" {_A_ 1 _U_ 2 _N_ _N_ _F_ _IF_ARGS_ 0 1 X 1 \ (u0 :: Int#) -> _#_ int2Integer# [] [u0] _N_} _F_ _IF_ARGS_ 0 1 C 2 \ (u0 :: Int) -> case u0 of { _ALG_ I# (u1 :: Int#) -> _#_ int2Integer# [] [u1]; _NO_DEFLT_ } _N_ }, [ Int, (Ratio Integer) ] 2 { _A_ 1 _U_ 1 _N_ _N_ _N_ _N_ }, [ Integer, Double ] 2 { _A_ 1 _U_ 1 _N_ _S_ "U(PPP)" {_A_ 3 _U_ 222 _N_ _N_ _F_ _IF_ARGS_ 0 3 XXX 3 \ (u0 :: Int#) (u1 :: Int#) (u2 :: ByteArray#) -> case _#_ encodeDouble# [] [u0, u1, u2, 0#] of { _PRIM_ (u3 :: Double#) -> _!_ D# [] [u3] } _N_} _F_ _IF_ARGS_ 0 1 C 4 \ (u0 :: Integer) -> case u0 of { _ALG_ J# (u1 :: Int#) (u2 :: Int#) (u3 :: ByteArray#) -> case _#_ encodeDouble# [] [u1, u2, u3, 0#] of { _PRIM_ (u4 :: Double#) -> _!_ D# [] [u4] }; _NO_DEFLT_ } _N_ }, [ Integer, Float ] 2 { _A_ 1 _U_ 1 _N_ _S_ "U(PPP)" {_A_ 3 _U_ 222 _N_ _N_ _F_ _IF_ARGS_ 0 3 XXX 3 \ (u0 :: Int#) (u1 :: Int#) (u2 :: ByteArray#) -> case _#_ encodeFloat# [] [u0, u1, u2, 0#] of { _PRIM_ (u3 :: Float#) -> _!_ F# [] [u3] } _N_} _F_ _IF_ARGS_ 0 1 C 4 \ (u0 :: Integer) -> case u0 of { _ALG_ J# (u1 :: Int#) (u2 :: Int#) (u3 :: ByteArray#) -> case _#_ encodeFloat# [] [u1, u2, u3, 0#] of { _PRIM_ (u4 :: Float#) -> _!_ F# [] [u4] }; _NO_DEFLT_ } _N_ }, [ Integer, Int ] 2 { _A_ 1 _U_ 1 _N_ _S_ "U(PPP)" {_A_ 3 _U_ 222 _N_ _N_ _F_ _IF_ARGS_ 0 3 XXX 3 \ (u0 :: Int#) (u1 :: Int#) (u2 :: ByteArray#) -> case _#_ integer2Int# [] [u0, u1, u2] of { _PRIM_ (u3 :: Int#) -> _!_ I# [] [u3] } _N_} _F_ _IF_ARGS_ 0 1 C 4 \ (u0 :: Integer) -> case u0 of { _ALG_ J# (u1 :: Int#) (u2 :: Int#) (u3 :: ByteArray#) -> case _#_ integer2Int# [] [u1, u2, u3] of { _PRIM_ (u4 :: Int#) -> _!_ I# [] [u4] }; _NO_DEFLT_ } _N_ }, [ Integer, Integer ] 2 { _A_ 1 _U_ 1 _N_ _N_ _F_ _IF_ARGS_ 0 0 X 1 _TYAPP_ _ORIG_ Prelude id { Integer } _N_ }, [ Integer, (Ratio Integer) ] 2 { _A_ 1 _U_ 2 _N_ _N_ _F_ _IF_ARGS_ 0 1 X 3 \ (u0 :: Integer) -> _!_ (:%) [Integer] [u0, _SPEC_ _ORIG_ PreludeCore __i1 [ (Integer) ]] _N_ } #-}
fromRealFrac :: (RealFrac a, Fractional b) => a -> b
- {-# GHC_PRAGMA _A_ 3 _U_ 112 _N_ _S_ "LU(AAAS)L" {_A_ 3 _U_ 112 _N_ _N_ _N_ _N_} _N_ _SPECIALISE_ [ Double, Double ] 2 { _A_ 1 _U_ 1 _N_ _N_ _F_ _IF_ARGS_ 0 0 X 1 _TYAPP_ _ORIG_ Prelude id { Double } _N_ }, [ Double, Float ] 2 { _A_ 1 _U_ 1 _N_ _S_ "U(P)" {_A_ 1 _U_ 2 _N_ _N_ _F_ _IF_ARGS_ 0 1 X 3 \ (u0 :: Double#) -> case _#_ double2Float# [] [u0] of { _PRIM_ (u1 :: Float#) -> _!_ F# [] [u1] } _N_} _F_ _IF_ARGS_ 0 1 C 4 \ (u0 :: Double) -> case u0 of { _ALG_ D# (u1 :: Double#) -> case _#_ double2Float# [] [u1] of { _PRIM_ (u2 :: Float#) -> _!_ F# [] [u2] }; _NO_DEFLT_ } _N_ }, [ Float, Double ] 2 { _A_ 1 _U_ 1 _N_ _S_ "U(P)" {_A_ 1 _U_ 2 _N_ _N_ _F_ _IF_ARGS_ 0 1 X 3 \ (u0 :: Float#) -> case _#_ float2Double# [] [u0] of { _PRIM_ (u1 :: Double#) -> _!_ D# [] [u1] } _N_} _F_ _IF_ARGS_ 0 1 C 4 \ (u0 :: Float) -> case u0 of { _ALG_ F# (u1 :: Float#) -> case _#_ float2Double# [] [u1] of { _PRIM_ (u2 :: Double#) -> _!_ D# [] [u2] }; _NO_DEFLT_ } _N_ }, [ Float, Float ] 2 { _A_ 1 _U_ 1 _N_ _N_ _F_ _IF_ARGS_ 0 0 X 1 _TYAPP_ _ORIG_ Prelude id { Float } _N_ } #-}
+ {-# GHC_PRAGMA _A_ 3 _U_ 112 _N_ _S_ "LU(AAAS)L" {_A_ 3 _U_ 112 _N_ _N_ _N_ _N_} _N_ _SPECIALISE_ [ Double, Double ] 2 { _A_ 1 _U_ 1 _N_ _N_ _F_ _IF_ARGS_ 0 0 X 1 _TYAPP_ _ORIG_ Prelude id { Double } _N_ }, [ Double, Float ] 2 { _A_ 1 _U_ 1 _N_ _S_ "U(P)" {_A_ 1 _U_ 2 _N_ _N_ _F_ _IF_ARGS_ 0 1 X 3 \ (u0 :: Double#) -> case _#_ double2Float# [] [u0] of { _PRIM_ (u1 :: Float#) -> _!_ F# [] [u1] } _N_} _F_ _IF_ARGS_ 0 1 C 4 \ (u0 :: Double) -> case u0 of { _ALG_ D# (u1 :: Double#) -> case _#_ double2Float# [] [u1] of { _PRIM_ (u2 :: Float#) -> _!_ F# [] [u2] }; _NO_DEFLT_ } _N_ }, [ Double, (Ratio Integer) ] 2 { _A_ 1 _U_ 1 _N_ _S_ "U(P)" {_A_ 1 _U_ 2 _N_ _N_ _N_ _N_} _N_ _N_ }, [ Float, Double ] 2 { _A_ 1 _U_ 1 _N_ _S_ "U(P)" {_A_ 1 _U_ 2 _N_ _N_ _F_ _IF_ARGS_ 0 1 X 3 \ (u0 :: Float#) -> case _#_ float2Double# [] [u0] of { _PRIM_ (u1 :: Double#) -> _!_ D# [] [u1] } _N_} _F_ _IF_ARGS_ 0 1 C 4 \ (u0 :: Float) -> case u0 of { _ALG_ F# (u1 :: Float#) -> case _#_ float2Double# [] [u1] of { _PRIM_ (u2 :: Double#) -> _!_ D# [] [u2] }; _NO_DEFLT_ } _N_ }, [ Float, Float ] 2 { _A_ 1 _U_ 1 _N_ _N_ _F_ _IF_ARGS_ 0 0 X 1 _TYAPP_ _ORIG_ Prelude id { Float } _N_ }, [ Float, (Ratio Integer) ] 2 { _A_ 1 _U_ 1 _N_ _S_ "U(P)" {_A_ 1 _U_ 2 _N_ _N_ _N_ _N_} _N_ _N_ }, [ (Ratio Integer), Double ] 2 { _A_ 1 _U_ 1 _N_ _S_ "U(U(PPP)U(PPP))" {_A_ 4 _U_ 2222 _N_ _N_ _N_ _N_} _N_ _N_ }, [ (Ratio Integer), Float ] 2 { _A_ 1 _U_ 2 _N_ _N_ _F_ _IF_ARGS_ 0 0 X 1 _CONSTM_ Fractional fromRational (Float) _N_ }, [ (Ratio Integer), (Ratio Integer) ] 2 { _A_ 1 _U_ 1 _N_ _N_ _F_ _IF_ARGS_ 0 0 X 1 _TYAPP_ _ORIG_ Prelude id { (Ratio Integer) } _N_ } #-}
fst :: (b, a) -> b
{-# GHC_PRAGMA _A_ 1 _U_ 1 _N_ _S_ "U(SA)" {_A_ 1 _U_ 1 _N_ _N_ _F_ _IF_ARGS_ 2 1 X 1 _/\_ u0 u1 -> \ (u2 :: u1) -> u2 _N_} _F_ _IF_ARGS_ 2 1 C 2 _/\_ u0 u1 -> \ (u2 :: (u1, u0)) -> case u2 of { _ALG_ _TUP_2 (u3 :: u1) (u4 :: u0) -> u3; _NO_DEFLT_ } _N_ #-}
gcd :: Integral a => a -> a -> a
isLower :: Char -> Bool
{-# GHC_PRAGMA _A_ 1 _U_ 1 _N_ _S_ "U(P)" {_A_ 1 _U_ 2 _N_ _N_ _N_ _N_} _N_ _N_ #-}
isNullBin :: Bin -> Bool
- {-# GHC_PRAGMA _A_ 1 _U_ 2 _N_ _S_ _!_ _F_ _IF_ARGS_ 0 1 X 3 \ (u0 :: Bin) -> _APP_ _TYAPP_ error { (Bin -> Bool) } [ _NOREP_S_ "isNullBin{Prelude}\n", u0 ] _N_ #-}
+ {-# GHC_PRAGMA _A_ 1 _U_ 2 _N_ _S_ _!_ _N_ _N_ #-}
isPrint :: Char -> Bool
{-# GHC_PRAGMA _A_ 1 _U_ 1 _N_ _S_ "U(P)" {_A_ 1 _U_ 2 _N_ _N_ _N_ _N_} _N_ _N_ #-}
isSpace :: Char -> Bool
not :: Bool -> Bool
{-# GHC_PRAGMA _A_ 1 _U_ 1 _N_ _S_ "E" _F_ _ALWAYS_ \ (u0 :: Bool) -> case u0 of { _ALG_ True -> _!_ False [] []; False -> _!_ True [] []; _NO_DEFLT_ } _N_ #-}
nullBin :: Bin
- {-# GHC_PRAGMA _A_ 0 _N_ _N_ _S_ _!_ _F_ _IF_ARGS_ 0 0 X 2 _APP_ _TYAPP_ error { Bin } [ _NOREP_S_ "nullBin{Prelude}\n" ] _N_ #-}
+ {-# GHC_PRAGMA _A_ 0 _N_ _N_ _S_ _!_ _N_ _N_ #-}
ord :: Char -> Int
{-# GHC_PRAGMA _A_ 1 _U_ 1 _N_ _S_ "U(P)" {_A_ 1 _U_ 2 _N_ _N_ _F_ _IF_ARGS_ 0 1 X 3 \ (u0 :: Char#) -> case _#_ ord# [] [u0] of { _PRIM_ (u1 :: Int#) -> _!_ I# [] [u1] } _N_} _F_ _IF_ARGS_ 0 1 C 4 \ (u0 :: Char) -> case u0 of { _ALG_ C# (u1 :: Char#) -> case _#_ ord# [] [u1] of { _PRIM_ (u2 :: Int#) -> _!_ I# [] [u2] }; _NO_DEFLT_ } _N_ #-}
otherwise :: Bool
snd :: (a, b) -> b
{-# GHC_PRAGMA _A_ 1 _U_ 1 _N_ _S_ "U(AS)" {_A_ 1 _U_ 1 _N_ _N_ _F_ _IF_ARGS_ 2 1 X 1 _/\_ u0 u1 -> \ (u2 :: u1) -> u2 _N_} _F_ _IF_ARGS_ 2 1 C 2 _/\_ u0 u1 -> \ (u2 :: (u0, u1)) -> case u2 of { _ALG_ _TUP_2 (u3 :: u0) (u4 :: u1) -> u4; _NO_DEFLT_ } _N_ #-}
subtract :: Num a => a -> a -> a
- {-# GHC_PRAGMA _A_ 3 _U_ 122 _N_ _S_ "U(AAASAAAAAA)LL" {_A_ 3 _U_ 122 _N_ _N_ _F_ _IF_ARGS_ 1 3 XXX 3 _/\_ u0 -> \ (u1 :: u0 -> u0 -> u0) (u2 :: u0) (u3 :: u0) -> _APP_ u1 [ u3, u2 ] _N_} _F_ _IF_ARGS_ 1 3 CXX 4 _/\_ u0 -> \ (u1 :: {{Num u0}}) (u2 :: u0) (u3 :: u0) -> case u1 of { _ALG_ _TUP_10 (u4 :: {{Eq u0}}) (u5 :: {{Text u0}}) (u6 :: u0 -> u0 -> u0) (u7 :: u0 -> u0 -> u0) (u8 :: u0 -> u0 -> u0) (u9 :: u0 -> u0) (ua :: u0 -> u0) (ub :: u0 -> u0) (uc :: Integer -> u0) (ud :: Int -> u0) -> _APP_ u7 [ u3, u2 ]; _NO_DEFLT_ } _SPECIALISE_ [ Double ] 1 { _A_ 2 _U_ 11 _N_ _S_ "U(P)U(P)" {_A_ 2 _U_ 22 _N_ _N_ _F_ _IF_ARGS_ 0 2 XX 3 \ (u0 :: Double#) (u1 :: Double#) -> case _#_ minusDouble# [] [u1, u0] of { _PRIM_ (u2 :: Double#) -> _!_ D# [] [u2] } _N_} _F_ _IF_ARGS_ 0 2 CC 5 \ (u0 :: Double) (u1 :: Double) -> case u1 of { _ALG_ D# (u2 :: Double#) -> case u0 of { _ALG_ D# (u3 :: Double#) -> case _#_ minusDouble# [] [u2, u3] of { _PRIM_ (u4 :: Double#) -> _!_ D# [] [u4] }; _NO_DEFLT_ }; _NO_DEFLT_ } _N_ }, [ Int ] 1 { _A_ 2 _U_ 11 _N_ _S_ "U(P)U(P)" {_A_ 2 _U_ 22 _N_ _N_ _F_ _IF_ARGS_ 0 2 XX 3 \ (u0 :: Int#) (u1 :: Int#) -> case _#_ minusInt# [] [u1, u0] of { _PRIM_ (u2 :: Int#) -> _!_ I# [] [u2] } _N_} _F_ _IF_ARGS_ 0 2 CC 5 \ (u0 :: Int) (u1 :: Int) -> case u1 of { _ALG_ I# (u2 :: Int#) -> case u0 of { _ALG_ I# (u3 :: Int#) -> case _#_ minusInt# [] [u2, u3] of { _PRIM_ (u4 :: Int#) -> _!_ I# [] [u4] }; _NO_DEFLT_ }; _NO_DEFLT_ } _N_ } #-}
+ {-# GHC_PRAGMA _A_ 3 _U_ 122 _N_ _S_ "U(AAASAAAAAA)LL" {_A_ 3 _U_ 122 _N_ _N_ _F_ _IF_ARGS_ 1 3 XXX 3 _/\_ u0 -> \ (u1 :: u0 -> u0 -> u0) (u2 :: u0) (u3 :: u0) -> _APP_ u1 [ u3, u2 ] _N_} _F_ _IF_ARGS_ 1 3 CXX 4 _/\_ u0 -> \ (u1 :: {{Num u0}}) (u2 :: u0) (u3 :: u0) -> case u1 of { _ALG_ _TUP_10 (u4 :: {{Eq u0}}) (u5 :: {{Text u0}}) (u6 :: u0 -> u0 -> u0) (u7 :: u0 -> u0 -> u0) (u8 :: u0 -> u0 -> u0) (u9 :: u0 -> u0) (ua :: u0 -> u0) (ub :: u0 -> u0) (uc :: Integer -> u0) (ud :: Int -> u0) -> _APP_ u7 [ u3, u2 ]; _NO_DEFLT_ } _SPECIALISE_ [ Double ] 1 { _A_ 2 _U_ 11 _N_ _S_ "U(P)U(P)" {_A_ 2 _U_ 22 _N_ _N_ _F_ _IF_ARGS_ 0 2 XX 3 \ (u0 :: Double#) (u1 :: Double#) -> case _#_ minusDouble# [] [u1, u0] of { _PRIM_ (u2 :: Double#) -> _!_ D# [] [u2] } _N_} _F_ _IF_ARGS_ 0 2 CC 5 \ (u0 :: Double) (u1 :: Double) -> case u1 of { _ALG_ D# (u2 :: Double#) -> case u0 of { _ALG_ D# (u3 :: Double#) -> case _#_ minusDouble# [] [u2, u3] of { _PRIM_ (u4 :: Double#) -> _!_ D# [] [u4] }; _NO_DEFLT_ }; _NO_DEFLT_ } _N_ }, [ Int ] 1 { _A_ 2 _U_ 11 _N_ _S_ "U(P)U(P)" {_A_ 2 _U_ 22 _N_ _N_ _F_ _IF_ARGS_ 0 2 XX 3 \ (u0 :: Int#) (u1 :: Int#) -> case _#_ minusInt# [] [u1, u0] of { _PRIM_ (u2 :: Int#) -> _!_ I# [] [u2] } _N_} _F_ _IF_ARGS_ 0 2 CC 5 \ (u0 :: Int) (u1 :: Int) -> case u1 of { _ALG_ I# (u2 :: Int#) -> case u0 of { _ALG_ I# (u3 :: Int#) -> case _#_ minusInt# [] [u2, u3] of { _PRIM_ (u4 :: Int#) -> _!_ I# [] [u4] }; _NO_DEFLT_ }; _NO_DEFLT_ } _N_ }, [ (Complex Double) ] 1 { _A_ 2 _U_ 11 _N_ _S_ "U(LL)U(LL)" {_A_ 4 _U_ 2222 _N_ _N_ _N_ _N_} _N_ _N_ } #-}
toLower :: Char -> Char
{-# GHC_PRAGMA _A_ 1 _U_ 1 _N_ _S_ "U(P)" {_A_ 1 _U_ 2 _N_ _N_ _N_ _N_} _N_ _N_ #-}
toUpper :: Char -> Char
imagPart :: Complex a -> a
{-# GHC_PRAGMA _A_ 1 _U_ 1 _N_ _S_ "U(AS)" {_A_ 1 _U_ 1 _N_ _N_ _F_ _IF_ARGS_ 1 1 X 1 _/\_ u0 -> \ (u1 :: u0) -> u1 _N_} _F_ _IF_ARGS_ 1 1 C 2 _/\_ u0 -> \ (u1 :: Complex u0) -> case u1 of { _ALG_ (:+) (u2 :: u0) (u3 :: u0) -> u3; _NO_DEFLT_ } _N_ #-}
magnitude :: RealFloat a => Complex a -> a
- {-# GHC_PRAGMA _A_ 1 _U_ 12 _N_ _S_ "U(ALAAAAALAS)" {_A_ 3 _U_ 2221 _N_ _N_ _N_ _N_} _N_ _SPECIALISE_ [ Double ] 1 { _A_ 1 _U_ 1 _N_ _S_ "U(LL)" {_A_ 2 _U_ 22 _N_ _N_ _N_ _N_} _N_ _N_ } #-}
+ {-# GHC_PRAGMA _A_ 1 _U_ 12 _N_ _S_ "U(ALAAAAALAS)" {_A_ 3 _U_ 2221 _N_ _N_ _N_ _N_} _N_ _SPECIALISE_ [ Double ] 1 { _A_ 1 _U_ 1 _N_ _S_ "U(U(P)U(P))" {_A_ 2 _U_ 22 _N_ _N_ _N_ _N_} _N_ _N_ } #-}
mkPolar :: RealFloat a => a -> a -> Complex a
{-# GHC_PRAGMA _A_ 3 _U_ 122 _N_ _N_ _N_ _SPECIALISE_ [ Double ] 1 { _A_ 2 _U_ 22 _N_ _N_ _N_ _N_ } #-}
phase :: RealFloat a => Complex a -> a
{-# GHC_PRAGMA _A_ 1 _U_ 22 _N_ _N_ _N_ _SPECIALISE_ [ Double ] 1 { _A_ 1 _U_ 2 _N_ _N_ _N_ _N_ } #-}
realPart :: Complex a -> a
{-# GHC_PRAGMA _A_ 1 _U_ 1 _N_ _S_ "U(SA)" {_A_ 1 _U_ 1 _N_ _N_ _F_ _IF_ARGS_ 1 1 X 1 _/\_ u0 -> \ (u1 :: u0) -> u1 _N_} _F_ _IF_ARGS_ 1 1 C 2 _/\_ u0 -> \ (u1 :: Complex u0) -> case u1 of { _ALG_ (:+) (u2 :: u0) (u3 :: u0) -> u2; _NO_DEFLT_ } _N_ #-}
-_ceiling :: (RealFrac a, Integral b) => a -> b
- {-# GHC_PRAGMA _A_ 2 _U_ 122 _N_ _S_ "U(U(AU(U(AAAASAAA)AAAA)A)LSAAAA)L" {_A_ 4 _U_ 11122 _N_ _N_ _N_ _N_} _N_ _SPECIALISE_ [ Double, Int ] 2 { _A_ 0 _U_ 2 _N_ _N_ _N_ _N_ } #-}
-_floor :: (RealFrac a, Integral b) => a -> b
- {-# GHC_PRAGMA _A_ 2 _U_ 122 _N_ _S_ "U(U(AU(U(ASAAAAAA)AAAA)A)LSAAAA)L" {_A_ 4 _U_ 11122 _N_ _N_ _N_ _N_} _N_ _SPECIALISE_ [ Double, Int ] 2 { _A_ 0 _U_ 2 _N_ _N_ _N_ _N_ } #-}
-_readList :: Text a => [Char] -> [([a], [Char])]
+_readList :: ([Char] -> [(a, [Char])]) -> [Char] -> [([a], [Char])]
{-# GHC_PRAGMA _A_ 1 _U_ 22 _N_ _N_ _N_ _N_ #-}
-_round :: (RealFrac a, Integral b) => a -> b
- {-# GHC_PRAGMA _A_ 2 _U_ 122 _N_ _S_ "U(U(AU(U(ALAAAAAS)AAAA)A)LSAAAA)L" {_A_ 5 _U_ 112122 _N_ _N_ _N_ _N_} _N_ _SPECIALISE_ [ Double, Int ] 2 { _A_ 0 _U_ 2 _N_ _N_ _N_ _N_ }, [ (Ratio Integer), Integer ] 2 { _A_ 1 _U_ 1 _N_ _S_ "U(LL)" {_A_ 2 _U_ 22 _N_ _N_ _N_ _N_} _N_ _N_ } #-}
-_showList :: Text a => [a] -> [Char] -> [Char]
- {-# GHC_PRAGMA _A_ 1 _U_ 212 _N_ _N_ _N_ _N_ #-}
+_showList :: (a -> [Char] -> [Char]) -> [a] -> [Char] -> [Char]
+ {-# GHC_PRAGMA _A_ 2 _U_ 212 _N_ _S_ "LS" _N_ _N_ #-}
_showRational :: Int -> Ratio Integer -> [Char]
{-# GHC_PRAGMA _A_ 2 _U_ 21 _N_ _S_ "LU(U(PPP)L)" {_A_ 5 _U_ 22222 _N_ _N_ _N_ _N_} _N_ _N_ #-}
-_truncate :: (RealFrac a, Integral b) => a -> b
- {-# GHC_PRAGMA _A_ 2 _U_ 122 _N_ _S_ "U(AASAAAA)L" {_A_ 2 _U_ 122 _N_ _N_ _N_ _N_} _N_ _SPECIALISE_ [ Double, Int ] 2 { _A_ 0 _U_ 2 _N_ _N_ _N_ _N_ } #-}
abort :: IOError -> [Response] -> [Request]
{-# GHC_PRAGMA _A_ 2 _U_ 00 _N_ _S_ "A" {_A_ 1 _U_ 0 _N_ _N_ _F_ _IF_ARGS_ 0 1 X 1 \ (u0 :: [Response]) -> _!_ _NIL_ [Request] [] _N_} _F_ _IF_ARGS_ 0 1 X 1 \ (u0 :: IOError) -> _ORIG_ PreludeIO done _N_ #-}
appendBinChan :: [Char] -> Bin -> (IOError -> [Response] -> [Request]) -> ([Response] -> [Request]) -> [Response] -> [Request]
interact :: ([Char] -> [Char]) -> [Response] -> [Request]
{-# GHC_PRAGMA _A_ 1 _U_ 11 _N_ _N_ _N_ _N_ #-}
print :: Text a => a -> [Response] -> [Request]
- {-# GHC_PRAGMA _A_ 1 _U_ 121 _N_ _N_ _N_ _N_ #-}
+ {-# GHC_PRAGMA _A_ 1 _U_ 121 _N_ _N_ _N_ _SPECIALISE_ [ Bool ] 1 { _A_ 1 _U_ 21 _N_ _N_ _N_ _N_ }, [ Char ] 1 { _A_ 1 _U_ 11 _N_ _N_ _N_ _N_ }, [ Double ] 1 { _A_ 1 _U_ 11 _N_ _N_ _N_ _N_ }, [ Int ] 1 { _A_ 1 _U_ 11 _N_ _N_ _N_ _N_ }, [ Integer ] 1 { _A_ 1 _U_ 11 _N_ _N_ _N_ _N_ }, [ [Char] ] 1 { _A_ 1 _U_ 21 _N_ _N_ _N_ _N_ }, [ [Int] ] 1 { _A_ 1 _U_ 21 _N_ _N_ _N_ _N_ }, [ [[Char]] ] 1 { _A_ 1 _U_ 21 _N_ _N_ _N_ _N_ }, [ [[Int]] ] 1 { _A_ 1 _U_ 21 _N_ _N_ _N_ _N_ }, [ _PackedString ] 1 { _A_ 1 _U_ 21 _N_ _N_ _N_ _N_ }, [ () ] 1 { _A_ 1 _U_ 21 _N_ _N_ _N_ _N_ } #-}
prints :: Text a => a -> [Char] -> [Response] -> [Request]
- {-# GHC_PRAGMA _A_ 1 _U_ 1221 _N_ _N_ _N_ _N_ #-}
+ {-# GHC_PRAGMA _A_ 1 _U_ 1221 _N_ _N_ _N_ _SPECIALISE_ [ Bool ] 1 { _A_ 2 _U_ 221 _N_ _N_ _N_ _N_ }, [ Char ] 1 { _A_ 2 _U_ 121 _N_ _N_ _N_ _N_ }, [ Double ] 1 { _A_ 2 _U_ 121 _N_ _N_ _N_ _N_ }, [ Int ] 1 { _A_ 2 _U_ 121 _N_ _N_ _N_ _N_ }, [ Integer ] 1 { _A_ 2 _U_ 121 _N_ _N_ _N_ _N_ }, [ [Char] ] 1 { _A_ 2 _U_ 221 _N_ _N_ _N_ _N_ }, [ [Int] ] 1 { _A_ 2 _U_ 221 _N_ _N_ _N_ _N_ }, [ [[Char]] ] 1 { _A_ 2 _U_ 121 _N_ _N_ _N_ _N_ }, [ [[Int]] ] 1 { _A_ 2 _U_ 121 _N_ _N_ _N_ _N_ }, [ _PackedString ] 1 { _A_ 2 _U_ 221 _N_ _N_ _N_ _N_ }, [ () ] 1 { _A_ 2 _U_ 121 _N_ _N_ _N_ _N_ } #-}
readBinChan :: [Char] -> (IOError -> [Response] -> [Request]) -> (Bin -> [Response] -> [Request]) -> [Response] -> [Request]
{-# GHC_PRAGMA _A_ 4 _U_ 2111 _N_ _N_ _N_ _N_ #-}
readBinFile :: [Char] -> (IOError -> [Response] -> [Request]) -> (Bin -> [Response] -> [Request]) -> [Response] -> [Request]
(++) :: [a] -> [a] -> [a]
{-# GHC_PRAGMA _A_ 2 _U_ 12 _N_ _S_ "SL" _N_ _N_ #-}
(\\) :: Eq a => [a] -> [a] -> [a]
- {-# GHC_PRAGMA _A_ 3 _U_ 122 _N_ _S_ "LLS" _N_ _N_ #-}
+ {-# GHC_PRAGMA _A_ 3 _U_ 122 _N_ _S_ "LLS" _N_ _SPECIALISE_ [ Int ] 1 { _A_ 2 _U_ 22 _N_ _S_ "LS" _N_ _N_ }, [ [Char] ] 1 { _A_ 2 _U_ 22 _N_ _S_ "LS" _N_ _N_ } #-}
all :: (a -> Bool) -> [a] -> Bool
{-# GHC_PRAGMA _A_ 2 _U_ 21 _N_ _S_ "LS" _F_ _ALWAYS_ _/\_ u0 -> \ (u1 :: u0 -> Bool) (u2 :: [u0]) -> let {(u3 :: Bool) = _!_ True [] []} in let {(u6 :: u0 -> Bool -> Bool) = \ (u4 :: u0) (u5 :: Bool) -> case _APP_ u1 [ u4 ] of { _ALG_ True -> u5; False -> _!_ False [] []; _NO_DEFLT_ }} in _APP_ _TYAPP_ _TYAPP_ foldr { u0 } { Bool } [ u6, u3, u2 ] _N_ #-}
and :: [Bool] -> Bool
dropWhile :: (a -> Bool) -> [a] -> [a]
{-# GHC_PRAGMA _A_ 2 _U_ 21 _N_ _S_ "LS" _N_ _N_ #-}
elem :: Eq a => a -> [a] -> Bool
- {-# GHC_PRAGMA _A_ 3 _U_ 121 _N_ _S_ "LLS" _F_ _ALWAYS_ _/\_ u0 -> \ (u1 :: {{Eq u0}}) (u2 :: u0) (u3 :: [u0]) -> let {(u6 :: u0 -> u0 -> Bool) = case u1 of { _ALG_ _TUP_2 (u4 :: u0 -> u0 -> Bool) (u5 :: u0 -> u0 -> Bool) -> u4; _NO_DEFLT_ }} in let {(u8 :: u0 -> Bool) = \ (u7 :: u0) -> _APP_ u6 [ u2, u7 ]} in _APP_ _TYAPP_ _ORIG_ PreludeList any { u0 } [ u8, u3 ] _SPECIALISE_ [ Char ] 1 { _A_ 2 _U_ 21 _N_ _S_ "LS" _F_ _ALWAYS_ \ (u0 :: Char) (u1 :: [Char]) -> let {(u5 :: Char -> Bool) = \ (u2 :: Char) -> case u0 of { _ALG_ C# (u3 :: Char#) -> case u2 of { _ALG_ C# (u4 :: Char#) -> _#_ eqChar# [] [u3, u4]; _NO_DEFLT_ }; _NO_DEFLT_ }} in _APP_ _TYAPP_ _ORIG_ PreludeList any { Char } [ u5, u1 ] _N_ }, [ Int ] 1 { _A_ 2 _U_ 21 _N_ _S_ "LS" _F_ _ALWAYS_ \ (u0 :: Int) (u1 :: [Int]) -> let {(u5 :: Int -> Bool) = \ (u2 :: Int) -> case u0 of { _ALG_ I# (u3 :: Int#) -> case u2 of { _ALG_ I# (u4 :: Int#) -> _#_ eqInt# [] [u3, u4]; _NO_DEFLT_ }; _NO_DEFLT_ }} in _APP_ _TYAPP_ _ORIG_ PreludeList any { Int } [ u5, u1 ] _N_ }, [ [Char] ] 1 { _A_ 2 _U_ 21 _N_ _S_ "LS" _F_ _ALWAYS_ \ (u0 :: [Char]) (u1 :: [[Char]]) -> let {(u3 :: [Char] -> Bool) = \ (u2 :: [Char]) -> _APP_ _CONSTM_ Eq (==) ([Char]) [ u0, u2 ]} in _APP_ _TYAPP_ _ORIG_ PreludeList any { [Char] } [ u3, u1 ] _N_ } #-}
+ {-# GHC_PRAGMA _A_ 3 _U_ 121 _N_ _S_ "LLS" _F_ _ALWAYS_ _/\_ u0 -> \ (u1 :: {{Eq u0}}) (u2 :: u0) (u3 :: [u0]) -> let {(u6 :: u0 -> u0 -> Bool) = case u1 of { _ALG_ _TUP_2 (u4 :: u0 -> u0 -> Bool) (u5 :: u0 -> u0 -> Bool) -> u4; _NO_DEFLT_ }} in let {(u8 :: u0 -> Bool) = \ (u7 :: u0) -> _APP_ u6 [ u2, u7 ]} in _APP_ _TYAPP_ _ORIG_ PreludeList any { u0 } [ u8, u3 ] _SPECIALISE_ [ Char ] 1 { _A_ 2 _U_ 21 _N_ _S_ "LS" _F_ _ALWAYS_ \ (u0 :: Char) (u1 :: [Char]) -> let {(u5 :: Char -> Bool) = \ (u2 :: Char) -> case u0 of { _ALG_ C# (u3 :: Char#) -> case u2 of { _ALG_ C# (u4 :: Char#) -> _#_ eqChar# [] [u3, u4]; _NO_DEFLT_ }; _NO_DEFLT_ }} in _APP_ _TYAPP_ _ORIG_ PreludeList any { Char } [ u5, u1 ] _N_ }, [ Int ] 1 { _A_ 2 _U_ 21 _N_ _S_ "LS" _F_ _ALWAYS_ \ (u0 :: Int) (u1 :: [Int]) -> let {(u5 :: Int -> Bool) = \ (u2 :: Int) -> case u0 of { _ALG_ I# (u3 :: Int#) -> case u2 of { _ALG_ I# (u4 :: Int#) -> _#_ eqInt# [] [u3, u4]; _NO_DEFLT_ }; _NO_DEFLT_ }} in _APP_ _TYAPP_ _ORIG_ PreludeList any { Int } [ u5, u1 ] _N_ }, [ Integer ] 1 { _A_ 2 _U_ 21 _N_ _S_ "LS" _F_ _ALWAYS_ \ (u0 :: Integer) (u1 :: [Integer]) -> let {(ua :: Integer -> Bool) = \ (u2 :: Integer) -> case u0 of { _ALG_ J# (u3 :: Int#) (u4 :: Int#) (u5 :: ByteArray#) -> case u2 of { _ALG_ J# (u6 :: Int#) (u7 :: Int#) (u8 :: ByteArray#) -> case _#_ cmpInteger# [] [u3, u4, u5, u6, u7, u8] of { _PRIM_ 0# -> _!_ True [] []; (u9 :: Int#) -> _!_ False [] [] }; _NO_DEFLT_ }; _NO_DEFLT_ }} in _APP_ _TYAPP_ _ORIG_ PreludeList any { Integer } [ ua, u1 ] _N_ }, [ [Char] ] 1 { _A_ 2 _U_ 21 _N_ _S_ "LS" _F_ _ALWAYS_ \ (u0 :: [Char]) (u1 :: [[Char]]) -> let {(u3 :: [Char] -> Bool) = \ (u2 :: [Char]) -> _APP_ _CONSTM_ Eq (==) ([Char]) [ u0, u2 ]} in _APP_ _TYAPP_ _ORIG_ PreludeList any { [Char] } [ u3, u1 ] _N_ }, [ [Int] ] 1 { _A_ 2 _U_ 21 _N_ _S_ "LS" _F_ _ALWAYS_ \ (u0 :: [Int]) (u1 :: [[Int]]) -> let {(u3 :: [Int] -> Bool) = \ (u2 :: [Int]) -> _APP_ _CONSTM_ Eq (==) ([Int]) [ u0, u2 ]} in _APP_ _TYAPP_ _ORIG_ PreludeList any { [Int] } [ u3, u1 ] _N_ }, [ (Int, Int) ] 1 { _A_ 2 _U_ 21 _N_ _S_ "LS" _F_ _ALWAYS_ \ (u0 :: (Int, Int)) (u1 :: [(Int, Int)]) -> let {(ub :: (Int, Int) -> Bool) = \ (u2 :: (Int, Int)) -> case u0 of { _ALG_ _TUP_2 (u3 :: Int) (u4 :: Int) -> case u3 of { _ALG_ I# (u5 :: Int#) -> case u2 of { _ALG_ _TUP_2 (u6 :: Int) (u7 :: Int) -> case u6 of { _ALG_ I# (u8 :: Int#) -> case _#_ eqInt# [] [u5, u8] of { _ALG_ True -> case u4 of { _ALG_ I# (u9 :: Int#) -> case u7 of { _ALG_ I# (ua :: Int#) -> _#_ eqInt# [] [u9, ua]; _NO_DEFLT_ }; _NO_DEFLT_ }; False -> _!_ False [] []; _NO_DEFLT_ }; _NO_DEFLT_ }; _NO_DEFLT_ }; _NO_DEFLT_ }; _NO_DEFLT_ }} in _APP_ _TYAPP_ _ORIG_ PreludeList any { (Int, Int) } [ ub, u1 ] _N_ } #-}
filter :: (a -> Bool) -> [a] -> [a]
{-# GHC_PRAGMA _A_ 2 _U_ 21 _N_ _S_ "LS" _F_ _ALWAYS_ _/\_ u0 -> \ (u1 :: u0 -> Bool) (u2 :: [u0]) -> let {(u9 :: _forall_ a$z1 =>(u0 -> a$z1 -> a$z1) -> a$z1 -> a$z1) = _/\_ u3 -> \ (u4 :: u0 -> u3 -> u3) (u5 :: u3) -> let {(u8 :: u0 -> u3 -> u3) = \ (u6 :: u0) (u7 :: u3) -> case _APP_ u1 [ u6 ] of { _ALG_ True -> _APP_ u4 [ u6, u7 ]; False -> u7; _NO_DEFLT_ }} in _APP_ _TYAPP_ _TYAPP_ foldr { u0 } { u3 } [ u8, u5, u2 ]} in _APP_ _TYAPP_ _build { u0 } [ u9 ] _N_ #-}
foldl1 :: (a -> a -> a) -> [a] -> a
foldr1 :: (a -> a -> a) -> [a] -> a
{-# GHC_PRAGMA _A_ 2 _U_ 21 _N_ _S_ "LS" _N_ _N_ #-}
genericLength :: Num b => [a] -> b
- {-# GHC_PRAGMA _A_ 1 _U_ 21 _N_ _N_ _N_ _N_ #-}
+ {-# GHC_PRAGMA _A_ 1 _U_ 21 _N_ _N_ _N_ _SPECIALISE_ [ _N_, Int ] 1 { _A_ 1 _U_ 1 _N_ _S_ "S" _N_ _N_ }, [ _N_, Integer ] 1 { _A_ 1 _U_ 1 _N_ _S_ "S" _N_ _N_ } #-}
head :: [a] -> a
{-# GHC_PRAGMA _A_ 1 _U_ 1 _N_ _S_ "S" _F_ _ALWAYS_ _/\_ u0 -> \ (u1 :: [u0]) -> let {(u2 :: u0) = _APP_ _TYAPP_ error { u0 } [ _NOREP_S_ "head{PreludeList}: head []\n" ]} in let {(u5 :: u0 -> u0 -> u0) = \ (u3 :: u0) (u4 :: u0) -> u3} in _APP_ _TYAPP_ _TYAPP_ foldr { u0 } { u0 } [ u5, u2, u1 ] _N_ #-}
init :: [a] -> [a]
map :: (a -> b) -> [a] -> [b]
{-# GHC_PRAGMA _A_ 2 _U_ 21 _N_ _S_ "LS" _F_ _ALWAYS_ _/\_ u0 u1 -> \ (u2 :: u0 -> u1) (u3 :: [u0]) -> let {(ua :: _forall_ a$z1 =>(u1 -> a$z1 -> a$z1) -> a$z1 -> a$z1) = _/\_ u4 -> \ (u5 :: u1 -> u4 -> u4) (u6 :: u4) -> let {(u9 :: u0 -> u4 -> u4) = \ (u7 :: u0) -> let {(u8 :: u1) = _APP_ u2 [ u7 ]} in _APP_ u5 [ u8 ]} in _APP_ _TYAPP_ _TYAPP_ foldr { u0 } { u4 } [ u9, u6, u3 ]} in _APP_ _TYAPP_ _build { u1 } [ ua ] _N_ #-}
maximum :: Ord a => [a] -> a
- {-# GHC_PRAGMA _A_ 1 _U_ 11 _N_ _N_ _N_ _N_ #-}
+ {-# GHC_PRAGMA _A_ 1 _U_ 11 _N_ _N_ _N_ _SPECIALISE_ [ Double ] 1 { _A_ 1 _U_ 1 _N_ _S_ "S" _N_ _N_ }, [ Int ] 1 { _A_ 1 _U_ 1 _N_ _S_ "S" _N_ _N_ }, [ Integer ] 1 { _A_ 1 _U_ 1 _N_ _S_ "S" _N_ _N_ } #-}
minimum :: Ord a => [a] -> a
- {-# GHC_PRAGMA _A_ 1 _U_ 11 _N_ _N_ _N_ _N_ #-}
+ {-# GHC_PRAGMA _A_ 1 _U_ 11 _N_ _N_ _N_ _SPECIALISE_ [ Double ] 1 { _A_ 1 _U_ 1 _N_ _S_ "S" _N_ _N_ }, [ Int ] 1 { _A_ 1 _U_ 1 _N_ _S_ "S" _N_ _N_ }, [ Integer ] 1 { _A_ 1 _U_ 1 _N_ _S_ "S" _N_ _N_ } #-}
notElem :: Eq a => a -> [a] -> Bool
- {-# GHC_PRAGMA _A_ 3 _U_ 121 _N_ _S_ "LLS" _F_ _ALWAYS_ _/\_ u0 -> \ (u1 :: {{Eq u0}}) (u2 :: u0) (u3 :: [u0]) -> let {(u6 :: u0 -> u0 -> Bool) = case u1 of { _ALG_ _TUP_2 (u4 :: u0 -> u0 -> Bool) (u5 :: u0 -> u0 -> Bool) -> u5; _NO_DEFLT_ }} in let {(u8 :: u0 -> Bool) = \ (u7 :: u0) -> _APP_ u6 [ u2, u7 ]} in _APP_ _TYAPP_ _ORIG_ PreludeList all { u0 } [ u8, u3 ] _SPECIALISE_ [ Char ] 1 { _A_ 2 _U_ 21 _N_ _S_ "LS" _F_ _ALWAYS_ \ (u0 :: Char) (u1 :: [Char]) -> let {(u5 :: Char -> Bool) = \ (u2 :: Char) -> case u0 of { _ALG_ C# (u3 :: Char#) -> case u2 of { _ALG_ C# (u4 :: Char#) -> _#_ neChar# [] [u3, u4]; _NO_DEFLT_ }; _NO_DEFLT_ }} in _APP_ _TYAPP_ _ORIG_ PreludeList all { Char } [ u5, u1 ] _N_ }, [ Int ] 1 { _A_ 2 _U_ 21 _N_ _S_ "LS" _F_ _ALWAYS_ \ (u0 :: Int) (u1 :: [Int]) -> let {(u5 :: Int -> Bool) = \ (u2 :: Int) -> case u0 of { _ALG_ I# (u3 :: Int#) -> case u2 of { _ALG_ I# (u4 :: Int#) -> _#_ neInt# [] [u3, u4]; _NO_DEFLT_ }; _NO_DEFLT_ }} in _APP_ _TYAPP_ _ORIG_ PreludeList all { Int } [ u5, u1 ] _N_ }, [ [Char] ] 1 { _A_ 2 _U_ 21 _N_ _S_ "LS" _F_ _ALWAYS_ \ (u0 :: [Char]) (u1 :: [[Char]]) -> let {(u3 :: [Char] -> Bool) = \ (u2 :: [Char]) -> _APP_ _CONSTM_ Eq (/=) ([Char]) [ u0, u2 ]} in _APP_ _TYAPP_ _ORIG_ PreludeList all { [Char] } [ u3, u1 ] _N_ } #-}
+ {-# GHC_PRAGMA _A_ 3 _U_ 121 _N_ _S_ "LLS" _F_ _ALWAYS_ _/\_ u0 -> \ (u1 :: {{Eq u0}}) (u2 :: u0) (u3 :: [u0]) -> let {(u6 :: u0 -> u0 -> Bool) = case u1 of { _ALG_ _TUP_2 (u4 :: u0 -> u0 -> Bool) (u5 :: u0 -> u0 -> Bool) -> u5; _NO_DEFLT_ }} in let {(u8 :: u0 -> Bool) = \ (u7 :: u0) -> _APP_ u6 [ u2, u7 ]} in _APP_ _TYAPP_ _ORIG_ PreludeList all { u0 } [ u8, u3 ] _SPECIALISE_ [ Char ] 1 { _A_ 2 _U_ 21 _N_ _S_ "LS" _F_ _ALWAYS_ \ (u0 :: Char) (u1 :: [Char]) -> let {(u5 :: Char -> Bool) = \ (u2 :: Char) -> case u0 of { _ALG_ C# (u3 :: Char#) -> case u2 of { _ALG_ C# (u4 :: Char#) -> _#_ neChar# [] [u3, u4]; _NO_DEFLT_ }; _NO_DEFLT_ }} in _APP_ _TYAPP_ _ORIG_ PreludeList all { Char } [ u5, u1 ] _N_ }, [ Int ] 1 { _A_ 2 _U_ 21 _N_ _S_ "LS" _F_ _ALWAYS_ \ (u0 :: Int) (u1 :: [Int]) -> let {(u5 :: Int -> Bool) = \ (u2 :: Int) -> case u0 of { _ALG_ I# (u3 :: Int#) -> case u2 of { _ALG_ I# (u4 :: Int#) -> _#_ neInt# [] [u3, u4]; _NO_DEFLT_ }; _NO_DEFLT_ }} in _APP_ _TYAPP_ _ORIG_ PreludeList all { Int } [ u5, u1 ] _N_ }, [ Integer ] 1 { _A_ 2 _U_ 21 _N_ _S_ "LS" _F_ _ALWAYS_ \ (u0 :: Integer) (u1 :: [Integer]) -> let {(ua :: Integer -> Bool) = \ (u2 :: Integer) -> case u0 of { _ALG_ J# (u3 :: Int#) (u4 :: Int#) (u5 :: ByteArray#) -> case u2 of { _ALG_ J# (u6 :: Int#) (u7 :: Int#) (u8 :: ByteArray#) -> case _#_ cmpInteger# [] [u3, u4, u5, u6, u7, u8] of { _PRIM_ 0# -> _!_ False [] []; (u9 :: Int#) -> _!_ True [] [] }; _NO_DEFLT_ }; _NO_DEFLT_ }} in _APP_ _TYAPP_ _ORIG_ PreludeList all { Integer } [ ua, u1 ] _N_ }, [ [Char] ] 1 { _A_ 2 _U_ 21 _N_ _S_ "LS" _F_ _ALWAYS_ \ (u0 :: [Char]) (u1 :: [[Char]]) -> let {(u3 :: [Char] -> Bool) = \ (u2 :: [Char]) -> _APP_ _CONSTM_ Eq (/=) ([Char]) [ u0, u2 ]} in _APP_ _TYAPP_ _ORIG_ PreludeList all { [Char] } [ u3, u1 ] _N_ }, [ (Int, Int) ] 1 { _A_ 2 _U_ 21 _N_ _S_ "LS" _F_ _ALWAYS_ \ (u0 :: (Int, Int)) (u1 :: [(Int, Int)]) -> let {(ub :: (Int, Int) -> Bool) = \ (u2 :: (Int, Int)) -> case u0 of { _ALG_ _TUP_2 (u3 :: Int) (u4 :: Int) -> case u3 of { _ALG_ I# (u5 :: Int#) -> case u2 of { _ALG_ _TUP_2 (u6 :: Int) (u7 :: Int) -> case u6 of { _ALG_ I# (u8 :: Int#) -> case _#_ neInt# [] [u5, u8] of { _ALG_ True -> _!_ True [] []; False -> case u4 of { _ALG_ I# (u9 :: Int#) -> case u7 of { _ALG_ I# (ua :: Int#) -> _#_ neInt# [] [u9, ua]; _NO_DEFLT_ }; _NO_DEFLT_ }; _NO_DEFLT_ }; _NO_DEFLT_ }; _NO_DEFLT_ }; _NO_DEFLT_ }; _NO_DEFLT_ }} in _APP_ _TYAPP_ _ORIG_ PreludeList all { (Int, Int) } [ ub, u1 ] _N_ } #-}
nub :: Eq a => [a] -> [a]
- {-# GHC_PRAGMA _A_ 2 _U_ 11 _N_ _S_ "LS" _N_ _N_ #-}
+ {-# GHC_PRAGMA _A_ 2 _U_ 11 _N_ _S_ "LS" _N_ _SPECIALISE_ [ Int ] 1 { _A_ 1 _U_ 1 _N_ _S_ "S" _N_ _N_ }, [ [Char] ] 1 { _A_ 1 _U_ 1 _N_ _S_ "S" _N_ _N_ }, [ [Int] ] 1 { _A_ 1 _U_ 1 _N_ _S_ "S" _N_ _N_ } #-}
null :: [a] -> Bool
{-# GHC_PRAGMA _A_ 1 _U_ 1 _N_ _S_ "S" _F_ _ALWAYS_ _/\_ u0 -> \ (u1 :: [u0]) -> let {(u2 :: Bool) = _!_ True [] []} in let {(u5 :: u0 -> Bool -> Bool) = \ (u3 :: u0) (u4 :: Bool) -> _!_ False [] []} in _APP_ _TYAPP_ _TYAPP_ foldr { u0 } { Bool } [ u5, u2, u1 ] _N_ #-}
or :: [Bool] -> Bool
partition :: (a -> Bool) -> [a] -> ([a], [a])
{-# GHC_PRAGMA _A_ 2 _U_ 21 _N_ _S_ "LS" _F_ _ALWAYS_ _/\_ u0 -> \ (u1 :: u0 -> Bool) (u2 :: [u0]) -> let {(u9 :: u0 -> ([u0], [u0]) -> ([u0], [u0])) = \ (u3 :: u0) (u4 :: ([u0], [u0])) -> case u4 of { _ALG_ _TUP_2 (u5 :: [u0]) (u6 :: [u0]) -> case _APP_ u1 [ u3 ] of { _ALG_ True -> let {(u7 :: [u0]) = _!_ (:) [u0] [u3, u5]} in _!_ _TUP_2 [[u0], [u0]] [u7, u6]; False -> let {(u8 :: [u0]) = _!_ (:) [u0] [u3, u6]} in _!_ _TUP_2 [[u0], [u0]] [u5, u8]; _NO_DEFLT_ }; _NO_DEFLT_ }} in let {(ua :: [u0]) = _!_ _NIL_ [u0] []} in let {(ub :: ([u0], [u0])) = _!_ _TUP_2 [[u0], [u0]] [ua, ua]} in _APP_ _TYAPP_ _TYAPP_ foldr { u0 } { ([u0], [u0]) } [ u9, ub, u2 ] _N_ #-}
product :: Num a => [a] -> a
- {-# GHC_PRAGMA _A_ 1 _U_ 22 _N_ _N_ _F_ _ALWAYS_ _/\_ u0 -> \ (u1 :: {{Num u0}}) -> let {(uc :: u0 -> u0 -> u0) = case u1 of { _ALG_ _TUP_10 (u2 :: {{Eq u0}}) (u3 :: {{Text u0}}) (u4 :: u0 -> u0 -> u0) (u5 :: u0 -> u0 -> u0) (u6 :: u0 -> u0 -> u0) (u7 :: u0 -> u0) (u8 :: u0 -> u0) (u9 :: u0 -> u0) (ua :: Integer -> u0) (ub :: Int -> u0) -> u6; _NO_DEFLT_ }} in let {(uo :: u0) = let {(ud :: Int) = _!_ I# [] [1#]} in case u1 of { _ALG_ _TUP_10 (ue :: {{Eq u0}}) (uf :: {{Text u0}}) (ug :: u0 -> u0 -> u0) (uh :: u0 -> u0 -> u0) (ui :: u0 -> u0 -> u0) (uj :: u0 -> u0) (uk :: u0 -> u0) (ul :: u0 -> u0) (um :: Integer -> u0) (un :: Int -> u0) -> _APP_ un [ ud ]; _NO_DEFLT_ }} in \ (up :: [u0]) -> _APP_ _TYAPP_ _TYAPP_ foldl { u0 } { u0 } [ uc, uo, up ] _SPECIALISE_ [ Double ] 1 { _A_ 1 _U_ 1 _N_ _S_ "S" _F_ _ALWAYS_ \ (u0 :: [Double]) -> let {(u1 :: Double) = _!_ D# [] [1.0000000000000000##]} in _APP_ _TYAPP_ _TYAPP_ foldl { Double } { Double } [ _CONSTM_ Num (*) (Double), u1, u0 ] _N_ }, [ Int ] 1 { _A_ 1 _U_ 1 _N_ _S_ "S" _F_ _ALWAYS_ \ (u0 :: [Int]) -> let {(u1 :: Int) = _!_ I# [] [1#]} in _APP_ _TYAPP_ _TYAPP_ foldl { Int } { Int } [ _CONSTM_ Num (*) (Int), u1, u0 ] _N_ }, [ Integer ] 1 { _A_ 1 _U_ 1 _N_ _S_ "S" _F_ _ALWAYS_ \ (u0 :: [Integer]) -> let {(u1 :: Integer) = _#_ int2Integer# [] [1#]} in _APP_ _TYAPP_ _TYAPP_ foldl { Integer } { Integer } [ _CONSTM_ Num (*) (Integer), u1, u0 ] _N_ } #-}
+ {-# GHC_PRAGMA _A_ 1 _U_ 22 _N_ _N_ _F_ _ALWAYS_ _/\_ u0 -> \ (u1 :: {{Num u0}}) -> let {(uc :: u0 -> u0 -> u0) = case u1 of { _ALG_ _TUP_10 (u2 :: {{Eq u0}}) (u3 :: {{Text u0}}) (u4 :: u0 -> u0 -> u0) (u5 :: u0 -> u0 -> u0) (u6 :: u0 -> u0 -> u0) (u7 :: u0 -> u0) (u8 :: u0 -> u0) (u9 :: u0 -> u0) (ua :: Integer -> u0) (ub :: Int -> u0) -> u6; _NO_DEFLT_ }} in let {(uo :: u0) = let {(ud :: Int) = _!_ I# [] [1#]} in case u1 of { _ALG_ _TUP_10 (ue :: {{Eq u0}}) (uf :: {{Text u0}}) (ug :: u0 -> u0 -> u0) (uh :: u0 -> u0 -> u0) (ui :: u0 -> u0 -> u0) (uj :: u0 -> u0) (uk :: u0 -> u0) (ul :: u0 -> u0) (um :: Integer -> u0) (un :: Int -> u0) -> _APP_ un [ ud ]; _NO_DEFLT_ }} in \ (up :: [u0]) -> _APP_ _TYAPP_ _TYAPP_ foldl { u0 } { u0 } [ uc, uo, up ] _SPECIALISE_ [ Double ] 1 { _A_ 1 _U_ 1 _N_ _S_ "S" _F_ _ALWAYS_ \ (u0 :: [Double]) -> let {(u1 :: Double) = _!_ D# [] [1.0000000000000000##]} in _APP_ _TYAPP_ _TYAPP_ foldl { Double } { Double } [ _CONSTM_ Num (*) (Double), u1, u0 ] _N_ }, [ Int ] 1 { _A_ 1 _U_ 1 _N_ _S_ "S" _F_ _ALWAYS_ \ (u0 :: [Int]) -> let {(u1 :: Int) = _!_ I# [] [1#]} in _APP_ _TYAPP_ _TYAPP_ foldl { Int } { Int } [ _CONSTM_ Num (*) (Int), u1, u0 ] _N_ }, [ Integer ] 1 { _A_ 1 _U_ 1 _N_ _S_ "S" _F_ _ALWAYS_ \ (u0 :: [Integer]) -> let {(u1 :: Integer) = _#_ int2Integer# [] [1#]} in _APP_ _TYAPP_ _TYAPP_ foldl { Integer } { Integer } [ _CONSTM_ Num (*) (Integer), u1, u0 ] _N_ }, [ (Complex Double) ] 1 { _A_ 1 _U_ 1 _N_ _S_ "S" _F_ _ALWAYS_ let {(u6 :: Complex Double -> Complex Double -> Complex Double) = \ (u0 :: Complex Double) (u1 :: Complex Double) -> case u0 of { _ALG_ (:+) (u2 :: Double) (u3 :: Double) -> case u1 of { _ALG_ (:+) (u4 :: Double) (u5 :: Double) -> _APP_ _WRKR_ _CONSTM_ Num (*) (Complex Double) [ u2, u3, u4, u5 ]; _NO_DEFLT_ }; _NO_DEFLT_ }} in let {(u8 :: Complex Double) = let {(u7 :: Int) = _!_ I# [] [1#]} in _APP_ _CONSTM_ Num fromInt (Complex Double) [ u7 ]} in \ (u9 :: [Complex Double]) -> _APP_ _TYAPP_ _TYAPP_ foldl { (Complex Double) } { (Complex Double) } [ u6, u8, u9 ] _N_ } #-}
products :: Num a => [a] -> [a]
- {-# GHC_PRAGMA _A_ 1 _U_ 21 _N_ _N_ _N_ _N_ #-}
+ {-# GHC_PRAGMA _A_ 1 _U_ 21 _N_ _N_ _N_ _SPECIALISE_ [ Double ] 1 { _A_ 1 _U_ 1 _N_ _N_ _N_ _N_ }, [ Int ] 1 { _A_ 1 _U_ 1 _N_ _N_ _N_ _N_ }, [ Integer ] 1 { _A_ 1 _U_ 1 _N_ _N_ _F_ _IF_ARGS_ 0 1 X 4 \ (u0 :: [Integer]) -> _APP_ _TYAPP_ _TYAPP_ _ORIG_ PreludeList scanl { Integer } { Integer } [ _CONSTM_ Num (*) (Integer), _SPEC_ _ORIG_ PreludeCore __i1 [ (Integer) ], u0 ] _N_ }, [ (Complex Double) ] 1 { _A_ 1 _U_ 1 _N_ _N_ _N_ _N_ } #-}
repeat :: a -> [a]
{-# GHC_PRAGMA _A_ 1 _U_ 2 _N_ _N_ _F_ _ALWAYS_ _/\_ u0 -> \ (u1 :: u0) -> let {(u6 :: _forall_ a$z1 =>(u0 -> a$z1 -> a$z1) -> a$z1 -> a$z1) = _/\_ u2 -> \ (u3 :: u0 -> u2 -> u2) (u4 :: u2) -> _LETREC_ {(u5 :: u2) = _APP_ u3 [ u1, u5 ]} in u5} in _APP_ _TYAPP_ _build { u0 } [ u6 ] _N_ #-}
reverse :: [a] -> [a]
sum :: Num a => [a] -> a
{-# GHC_PRAGMA _A_ 1 _U_ 22 _N_ _N_ _F_ _ALWAYS_ _/\_ u0 -> \ (u1 :: {{Num u0}}) -> let {(uc :: u0 -> u0 -> u0) = case u1 of { _ALG_ _TUP_10 (u2 :: {{Eq u0}}) (u3 :: {{Text u0}}) (u4 :: u0 -> u0 -> u0) (u5 :: u0 -> u0 -> u0) (u6 :: u0 -> u0 -> u0) (u7 :: u0 -> u0) (u8 :: u0 -> u0) (u9 :: u0 -> u0) (ua :: Integer -> u0) (ub :: Int -> u0) -> u4; _NO_DEFLT_ }} in let {(uo :: u0) = let {(ud :: Int) = _!_ I# [] [0#]} in case u1 of { _ALG_ _TUP_10 (ue :: {{Eq u0}}) (uf :: {{Text u0}}) (ug :: u0 -> u0 -> u0) (uh :: u0 -> u0 -> u0) (ui :: u0 -> u0 -> u0) (uj :: u0 -> u0) (uk :: u0 -> u0) (ul :: u0 -> u0) (um :: Integer -> u0) (un :: Int -> u0) -> _APP_ un [ ud ]; _NO_DEFLT_ }} in \ (up :: [u0]) -> _APP_ _TYAPP_ _TYAPP_ foldl { u0 } { u0 } [ uc, uo, up ] _SPECIALISE_ [ Double ] 1 { _A_ 1 _U_ 1 _N_ _S_ "S" _F_ _ALWAYS_ \ (u0 :: [Double]) -> let {(u1 :: Double) = _!_ D# [] [0.0000000000000000##]} in _APP_ _TYAPP_ _TYAPP_ foldl { Double } { Double } [ _CONSTM_ Num (+) (Double), u1, u0 ] _N_ }, [ Int ] 1 { _A_ 1 _U_ 1 _N_ _S_ "S" _F_ _ALWAYS_ \ (u0 :: [Int]) -> let {(u1 :: Int) = _!_ I# [] [0#]} in _APP_ _TYAPP_ _TYAPP_ foldl { Int } { Int } [ _CONSTM_ Num (+) (Int), u1, u0 ] _N_ }, [ Integer ] 1 { _A_ 1 _U_ 1 _N_ _S_ "S" _F_ _ALWAYS_ \ (u0 :: [Integer]) -> let {(u1 :: Integer) = _#_ int2Integer# [] [0#]} in _APP_ _TYAPP_ _TYAPP_ foldl { Integer } { Integer } [ _CONSTM_ Num (+) (Integer), u1, u0 ] _N_ }, [ (Complex Double) ] 1 { _A_ 1 _U_ 1 _N_ _S_ "S" _F_ _ALWAYS_ let {(u6 :: Complex Double -> Complex Double -> Complex Double) = \ (u0 :: Complex Double) (u1 :: Complex Double) -> case u0 of { _ALG_ (:+) (u2 :: Double) (u3 :: Double) -> case u1 of { _ALG_ (:+) (u4 :: Double) (u5 :: Double) -> _APP_ _WRKR_ _CONSTM_ Num (+) (Complex Double) [ u2, u3, u4, u5 ]; _NO_DEFLT_ }; _NO_DEFLT_ }} in let {(u8 :: Complex Double) = let {(u7 :: Int) = _!_ I# [] [0#]} in _APP_ _CONSTM_ Num fromInt (Complex Double) [ u7 ]} in \ (u9 :: [Complex Double]) -> _APP_ _TYAPP_ _TYAPP_ foldl { (Complex Double) } { (Complex Double) } [ u6, u8, u9 ] _N_ } #-}
sums :: Num a => [a] -> [a]
- {-# GHC_PRAGMA _A_ 1 _U_ 21 _N_ _N_ _N_ _N_ #-}
+ {-# GHC_PRAGMA _A_ 1 _U_ 21 _N_ _N_ _N_ _SPECIALISE_ [ Double ] 1 { _A_ 1 _U_ 1 _N_ _N_ _N_ _N_ }, [ Int ] 1 { _A_ 1 _U_ 1 _N_ _N_ _N_ _N_ }, [ Integer ] 1 { _A_ 1 _U_ 1 _N_ _N_ _F_ _IF_ARGS_ 0 1 X 4 \ (u0 :: [Integer]) -> _APP_ _TYAPP_ _TYAPP_ _ORIG_ PreludeList scanl { Integer } { Integer } [ _CONSTM_ Num (+) (Integer), _SPEC_ _ORIG_ PreludeCore __i0 [ (Integer) ], u0 ] _N_ }, [ (Complex Double) ] 1 { _A_ 1 _U_ 1 _N_ _N_ _N_ _N_ } #-}
tail :: [a] -> [a]
{-# GHC_PRAGMA _A_ 1 _U_ 1 _N_ _S_ "S" _F_ _IF_ARGS_ 1 1 C 5 _/\_ u0 -> \ (u1 :: [u0]) -> case u1 of { _ALG_ (:) (u2 :: u0) (u3 :: [u0]) -> u3; _NIL_ -> _APP_ _TYAPP_ error { [u0] } [ _NOREP_S_ "tail{PreludeList}: tail []\n" ]; _NO_DEFLT_ } _N_ #-}
take :: Integral a => a -> [b] -> [b]
- {-# GHC_PRAGMA _A_ 3 _U_ 121 _N_ _S_ "U(AAAAAAAAAAAS)LL" {_A_ 3 _U_ 121 _N_ _N_ _N_ _N_} _F_ _IF_ARGS_ 2 3 CXX 7 _/\_ u0 u1 -> \ (u2 :: {{Integral u0}}) (u3 :: u0) (u4 :: [u1]) -> let {(uh :: Int) = case u2 of { _ALG_ _TUP_12 (u5 :: {{Real u0}}) (u6 :: {{Ix u0}}) (u7 :: u0 -> u0 -> u0) (u8 :: u0 -> u0 -> u0) (u9 :: u0 -> u0 -> u0) (ua :: u0 -> u0 -> u0) (ub :: u0 -> u0 -> (u0, u0)) (uc :: u0 -> u0 -> (u0, u0)) (ud :: u0 -> Bool) (ue :: u0 -> Bool) (uf :: u0 -> Integer) (ug :: u0 -> Int) -> _APP_ ug [ u3 ]; _NO_DEFLT_ }} in _APP_ _TYAPP_ _SPEC_ _ORIG_ PreludeList take [ (Int), _N_ ] { u1 } [ uh, u4 ] _SPECIALISE_ [ Int, _N_ ] 1 { _A_ 2 _U_ 11 _N_ _S_ "U(P)L" {_A_ 2 _U_ 21 _N_ _N_ _N_ _N_} _N_ _N_ }, [ Integer, _N_ ] 1 { _A_ 2 _U_ 11 _N_ _S_ "U(PPP)L" {_A_ 4 _U_ 2221 _N_ _N_ _F_ _IF_ARGS_ 1 4 XXXX 4 _/\_ u0 -> \ (u1 :: Int#) (u2 :: Int#) (u3 :: ByteArray#) (u4 :: [u0]) -> case _#_ integer2Int# [] [u1, u2, u3] of { _PRIM_ (u5 :: Int#) -> _APP_ _TYAPP_ _WRKR_ _SPEC_ _ORIG_ PreludeList take [ (Int), _N_ ] { u0 } [ u5, u4 ] } _N_} _F_ _ALWAYS_ _/\_ u0 -> \ (u1 :: Integer) (u2 :: [u0]) -> case u1 of { _ALG_ J# (u3 :: Int#) (u4 :: Int#) (u5 :: ByteArray#) -> case _#_ integer2Int# [] [u3, u4, u5] of { _PRIM_ (u6 :: Int#) -> _APP_ _TYAPP_ _WRKR_ _SPEC_ _ORIG_ PreludeList take [ (Int), _N_ ] { u0 } [ u6, u2 ] }; _NO_DEFLT_ } _N_ } #-}
+ {-# GHC_PRAGMA _A_ 1 _U_ 122 _N_ _S_ "U(LU(U(ASSAAAAA)AAA)AAAALAAAAL)" {_A_ 5 _U_ 2121222 _N_ _N_ _N_ _N_} _N_ _SPECIALISE_ [ Int, _N_ ] 1 { _A_ 2 _U_ 11 _N_ _S_ "U(P)L" {_A_ 2 _U_ 21 _N_ _N_ _N_ _N_} _N_ _N_ }, [ Integer, _N_ ] 1 { _A_ 1 _U_ 12 _N_ _S_ "U(PPP)" {_A_ 3 _U_ 2222 _N_ _N_ _N_ _N_} _N_ _N_ } #-}
takeWhile :: (a -> Bool) -> [a] -> [a]
{-# GHC_PRAGMA _A_ 2 _U_ 21 _N_ _S_ "LS" _F_ _ALWAYS_ _/\_ u0 -> \ (u1 :: u0 -> Bool) (u2 :: [u0]) -> let {(u9 :: _forall_ a$z1 =>(u0 -> a$z1 -> a$z1) -> a$z1 -> a$z1) = _/\_ u3 -> \ (u4 :: u0 -> u3 -> u3) (u5 :: u3) -> let {(u8 :: u0 -> u3 -> u3) = \ (u6 :: u0) (u7 :: u3) -> case _APP_ u1 [ u6 ] of { _ALG_ True -> _APP_ u4 [ u6, u7 ]; False -> u5; _NO_DEFLT_ }} in _APP_ _TYAPP_ _TYAPP_ foldr { u0 } { u3 } [ u8, u5, u2 ]} in _APP_ _TYAPP_ _build { u0 } [ u9 ] _N_ #-}
transpose :: [[a]] -> [[a]]
lex :: [Char] -> [([Char], [Char])]
{-# GHC_PRAGMA _A_ 1 _U_ 2 _N_ _S_ "S" _N_ _N_ #-}
read :: Text a => [Char] -> a
- {-# GHC_PRAGMA _A_ 1 _U_ 12 _N_ _S_ "U(SAAA)" {_A_ 1 _U_ 12 _N_ _N_ _N_ _N_} _N_ _SPECIALISE_ [ Double ] 1 { _A_ 1 _U_ 2 _N_ _N_ _N_ _N_ }, [ Float ] 1 { _A_ 1 _U_ 2 _N_ _N_ _N_ _N_ }, [ Int ] 1 { _A_ 1 _U_ 2 _N_ _N_ _N_ _N_ }, [ Integer ] 1 { _A_ 1 _U_ 2 _N_ _N_ _N_ _N_ } #-}
+ {-# GHC_PRAGMA _A_ 1 _U_ 12 _N_ _S_ "U(SAAA)" {_A_ 1 _U_ 12 _N_ _N_ _N_ _N_} _N_ _SPECIALISE_ [ Bool ] 1 { _A_ 1 _U_ 2 _N_ _N_ _N_ _N_ }, [ Char ] 1 { _A_ 1 _U_ 2 _N_ _N_ _N_ _N_ }, [ Double ] 1 { _A_ 1 _U_ 2 _N_ _N_ _N_ _N_ }, [ Int ] 1 { _A_ 1 _U_ 2 _N_ _N_ _N_ _N_ }, [ Integer ] 1 { _A_ 1 _U_ 2 _N_ _N_ _N_ _N_ }, [ [Bool] ] 1 { _A_ 1 _U_ 2 _N_ _N_ _N_ _N_ }, [ [Char] ] 1 { _A_ 1 _U_ 2 _N_ _N_ _N_ _N_ }, [ [Double] ] 1 { _A_ 1 _U_ 2 _N_ _N_ _N_ _N_ }, [ [Float] ] 1 { _A_ 1 _U_ 2 _N_ _N_ _N_ _N_ }, [ [Int] ] 1 { _A_ 1 _U_ 2 _N_ _N_ _N_ _N_ }, [ [Integer] ] 1 { _A_ 1 _U_ 2 _N_ _N_ _N_ _N_ }, [ [[Char]] ] 1 { _A_ 1 _U_ 2 _N_ _N_ _N_ _N_ }, [ [[Int]] ] 1 { _A_ 1 _U_ 2 _N_ _N_ _N_ _N_ }, [ [Complex Double] ] 1 { _A_ 1 _U_ 2 _N_ _N_ _N_ _N_ }, [ (Ratio Integer) ] 1 { _A_ 1 _U_ 2 _N_ _N_ _N_ _N_ }, [ (Array Int Double) ] 1 { _A_ 1 _U_ 2 _N_ _N_ _N_ _N_ }, [ (Array (Int, Int) Double) ] 1 { _A_ 1 _U_ 2 _N_ _N_ _N_ _N_ }, [ _PackedString ] 1 { _A_ 1 _U_ 2 _N_ _S_ _!_ _N_ _N_ }, [ (Complex Double) ] 1 { _A_ 1 _U_ 2 _N_ _N_ _N_ _N_ }, [ () ] 1 { _A_ 1 _U_ 2 _N_ _N_ _N_ _N_ }, [ (Int, Int) ] 1 { _A_ 1 _U_ 2 _N_ _N_ _N_ _N_ }, [ (Integer, Integer) ] 1 { _A_ 1 _U_ 2 _N_ _N_ _N_ _N_ }, [ (Int, Int, Int) ] 1 { _A_ 1 _U_ 2 _N_ _N_ _N_ _N_ } #-}
readDec :: Integral a => [Char] -> [(a, [Char])]
- {-# GHC_PRAGMA _A_ 1 _U_ 22 _N_ _N_ _N_ _SPECIALISE_ [ Int ] 1 { _A_ 0 _U_ 2 _N_ _N_ _N_ _N_ }, [ Integer ] 1 { _A_ 1 _U_ 2 _N_ _S_ "S" _N_ _N_ } #-}
+ {-# GHC_PRAGMA _A_ 1 _U_ 22 _N_ _N_ _N_ _SPECIALISE_ [ Int ] 1 { _A_ 0 _U_ 2 _N_ _N_ _N_ _N_ }, [ Integer ] 1 { _A_ 0 _U_ 2 _N_ _N_ _N_ _N_ } #-}
readFloat :: RealFloat a => [Char] -> [(a, [Char])]
- {-# GHC_PRAGMA _A_ 2 _U_ 12 _N_ _S_ "LS" _N_ _SPECIALISE_ [ Double ] 1 { _A_ 1 _U_ 2 _N_ _S_ "S" _N_ _N_ }, [ Float ] 1 { _A_ 1 _U_ 2 _N_ _S_ "S" _N_ _N_ } #-}
+ {-# GHC_PRAGMA _A_ 2 _U_ 12 _N_ _S_ "LS" _N_ _SPECIALISE_ [ Double ] 1 { _A_ 1 _U_ 2 _N_ _S_ "S" _N_ _N_ } #-}
readLitChar :: [Char] -> [(Char, [Char])]
{-# GHC_PRAGMA _A_ 0 _U_ 1 _N_ _N_ _N_ _N_ #-}
readParen :: Bool -> ([Char] -> [(a, [Char])]) -> [Char] -> [(a, [Char])]
readSigned :: Real a => ([Char] -> [(a, [Char])]) -> [Char] -> [(a, [Char])]
{-# GHC_PRAGMA _A_ 2 _U_ 122 _N_ _N_ _N_ _SPECIALISE_ [ Double ] 1 { _A_ 1 _U_ 22 _N_ _N_ _N_ _N_ }, [ Int ] 1 { _A_ 1 _U_ 22 _N_ _N_ _N_ _N_ }, [ Integer ] 1 { _A_ 1 _U_ 22 _N_ _N_ _N_ _N_ } #-}
reads :: Text a => [Char] -> [(a, [Char])]
- {-# GHC_PRAGMA _A_ 1 _U_ 12 _N_ _S_ "U(SAAA)" {_A_ 1 _U_ 12 _N_ _N_ _N_ _N_} _N_ _SPECIALISE_ [ Double ] 1 { _A_ 1 _U_ 2 _N_ _N_ _N_ _N_ }, [ Float ] 1 { _A_ 1 _U_ 2 _N_ _N_ _N_ _N_ }, [ Int ] 1 { _A_ 1 _U_ 2 _N_ _N_ _N_ _N_ }, [ Integer ] 1 { _A_ 1 _U_ 2 _N_ _N_ _N_ _N_ } #-}
+ {-# GHC_PRAGMA _A_ 1 _U_ 12 _N_ _S_ "U(SAAA)" {_A_ 1 _U_ 12 _N_ _N_ _N_ _N_} _N_ _SPECIALISE_ [ Bool ] 1 { _A_ 1 _U_ 2 _N_ _N_ _N_ _N_ }, [ Char ] 1 { _A_ 0 _U_ 2 _N_ _N_ _N_ _N_ }, [ Double ] 1 { _A_ 1 _U_ 2 _N_ _N_ _N_ _N_ }, [ Int ] 1 { _A_ 1 _U_ 2 _N_ _N_ _N_ _N_ }, [ Integer ] 1 { _A_ 1 _U_ 2 _N_ _N_ _N_ _N_ }, [ [Bool] ] 1 { _A_ 0 _U_ 2 _N_ _N_ _F_ _IF_ARGS_ 0 0 X 1 _CONSTM_ Text readList (Bool) _N_ }, [ [Char] ] 1 { _A_ 0 _U_ 2 _N_ _N_ _F_ _IF_ARGS_ 0 0 X 1 _CONSTM_ Text readList (Char) _N_ }, [ [Double] ] 1 { _A_ 0 _U_ 2 _N_ _N_ _F_ _IF_ARGS_ 0 0 X 1 _CONSTM_ Text readList (Double) _N_ }, [ [Float] ] 1 { _A_ 0 _U_ 2 _N_ _N_ _N_ _N_ }, [ [Int] ] 1 { _A_ 0 _U_ 2 _N_ _N_ _F_ _IF_ARGS_ 0 0 X 1 _CONSTM_ Text readList (Int) _N_ }, [ [Integer] ] 1 { _A_ 0 _U_ 2 _N_ _N_ _F_ _IF_ARGS_ 0 0 X 1 _CONSTM_ Text readList (Integer) _N_ }, [ [[Char]] ] 1 { _A_ 0 _U_ 2 _N_ _N_ _F_ _IF_ARGS_ 0 0 X 1 _CONSTM_ Text readList ([Char]) _N_ }, [ [[Int]] ] 1 { _A_ 0 _U_ 2 _N_ _N_ _F_ _IF_ARGS_ 0 0 X 1 _CONSTM_ Text readList ([Int]) _N_ }, [ [Complex Double] ] 1 { _A_ 0 _U_ 2 _N_ _N_ _F_ _IF_ARGS_ 0 0 X 1 _CONSTM_ Text readList (Complex Double) _N_ }, [ (Ratio Integer) ] 1 { _A_ 0 _U_ 2 _N_ _N_ _N_ _N_ }, [ (Array Int Double) ] 1 { _A_ 0 _U_ 2 _N_ _N_ _N_ _N_ }, [ (Array (Int, Int) Double) ] 1 { _A_ 0 _U_ 2 _N_ _N_ _N_ _N_ }, [ _PackedString ] 1 { _A_ 1 _U_ 2 _N_ _S_ _!_ _N_ _N_ }, [ (Complex Double) ] 1 { _A_ 0 _U_ 2 _N_ _N_ _N_ _N_ }, [ () ] 1 { _A_ 0 _U_ 2 _N_ _N_ _N_ _N_ }, [ (Int, Int) ] 1 { _A_ 0 _U_ 2 _N_ _N_ _N_ _N_ }, [ (Integer, Integer) ] 1 { _A_ 0 _U_ 2 _N_ _N_ _N_ _N_ }, [ (Int, Int, Int) ] 1 { _A_ 0 _U_ 2 _N_ _N_ _N_ _N_ } #-}
show :: Text a => a -> [Char]
- {-# GHC_PRAGMA _A_ 1 _U_ 12 _N_ _S_ "U(ASAA)" {_A_ 1 _U_ 12 _N_ _N_ _N_ _N_} _N_ _SPECIALISE_ [ Char ] 1 { _A_ 1 _U_ 1 _N_ _S_ "U(P)" {_A_ 1 _U_ 2 _N_ _N_ _N_ _N_} _N_ _N_ }, [ Double ] 1 { _A_ 1 _U_ 1 _N_ _S_ "U(P)" {_A_ 1 _U_ 2 _N_ _N_ _N_ _N_} _N_ _N_ }, [ Float ] 1 { _A_ 1 _U_ 2 _N_ _N_ _N_ _N_ }, [ Int ] 1 { _A_ 1 _U_ 1 _N_ _S_ "U(P)" {_A_ 1 _U_ 2 _N_ _N_ _N_ _N_} _N_ _N_ }, [ Integer ] 1 { _A_ 1 _U_ 1 _N_ _S_ "U(PPP)" {_A_ 3 _U_ 222 _N_ _N_ _N_ _N_} _N_ _N_ }, [ [Char] ] 1 { _A_ 1 _U_ 2 _N_ _N_ _N_ _N_ }, [ _PackedString ] 1 { _A_ 1 _U_ 1 _N_ _N_ _N_ _N_ }, [ (Int, Int) ] 1 { _A_ 1 _U_ 1 _N_ _S_ "U(LL)" {_A_ 2 _U_ 22 _N_ _N_ _N_ _N_} _N_ _N_ }, [ (Integer, Integer) ] 1 { _A_ 1 _U_ 1 _N_ _S_ "U(LL)" {_A_ 2 _U_ 22 _N_ _N_ _N_ _N_} _N_ _N_ } #-}
+ {-# GHC_PRAGMA _A_ 1 _U_ 12 _N_ _S_ "U(ASAA)" {_A_ 1 _U_ 12 _N_ _N_ _N_ _N_} _N_ _SPECIALISE_ [ Bool ] 1 { _A_ 1 _U_ 2 _N_ _S_ "E" _N_ _N_ }, [ Char ] 1 { _A_ 1 _U_ 1 _N_ _S_ "U(P)" {_A_ 1 _U_ 2 _N_ _N_ _N_ _N_} _N_ _N_ }, [ Double ] 1 { _A_ 1 _U_ 1 _N_ _S_ "U(P)" {_A_ 1 _U_ 2 _N_ _N_ _N_ _N_} _N_ _N_ }, [ Int ] 1 { _A_ 1 _U_ 1 _N_ _S_ "U(P)" {_A_ 1 _U_ 2 _N_ _N_ _N_ _N_} _N_ _N_ }, [ Integer ] 1 { _A_ 1 _U_ 1 _N_ _S_ "U(PPP)" {_A_ 3 _U_ 222 _N_ _N_ _N_ _N_} _N_ _N_ }, [ [Bool] ] 1 { _A_ 1 _U_ 1 _N_ _S_ "S" _N_ _N_ }, [ [Char] ] 1 { _A_ 1 _U_ 2 _N_ _N_ _N_ _N_ }, [ [Double] ] 1 { _A_ 1 _U_ 2 _N_ _N_ _N_ _N_ }, [ [Int] ] 1 { _A_ 1 _U_ 2 _N_ _N_ _N_ _N_ }, [ [Integer] ] 1 { _A_ 1 _U_ 2 _N_ _N_ _N_ _N_ }, [ [[Char]] ] 1 { _A_ 1 _U_ 1 _N_ _S_ "S" _N_ _N_ }, [ [[Int]] ] 1 { _A_ 1 _U_ 1 _N_ _S_ "S" _N_ _N_ }, [ [Complex Double] ] 1 { _A_ 1 _U_ 2 _N_ _N_ _N_ _N_ }, [ (Ratio Integer) ] 1 { _A_ 1 _U_ 1 _N_ _S_ "U(LL)" {_A_ 2 _U_ 22 _N_ _N_ _N_ _N_} _N_ _N_ }, [ (Array Int Double) ] 1 { _A_ 1 _U_ 2 _N_ _N_ _N_ _N_ }, [ (Array (Int, Int) Double) ] 1 { _A_ 1 _U_ 2 _N_ _N_ _N_ _N_ }, [ _PackedString ] 1 { _A_ 1 _U_ 1 _N_ _N_ _N_ _N_ }, [ (Complex Double) ] 1 { _A_ 1 _U_ 1 _N_ _S_ "U(LL)" {_A_ 2 _U_ 22 _N_ _N_ _N_ _N_} _N_ _N_ }, [ () ] 1 { _A_ 1 _U_ 1 _N_ _S_ "E" _N_ _N_ }, [ (Int, Int) ] 1 { _A_ 1 _U_ 1 _N_ _S_ "U(LL)" {_A_ 2 _U_ 22 _N_ _N_ _N_ _N_} _N_ _N_ }, [ (Integer, Integer) ] 1 { _A_ 1 _U_ 1 _N_ _S_ "U(LL)" {_A_ 2 _U_ 22 _N_ _N_ _N_ _N_} _N_ _N_ }, [ (Int, Int, Int) ] 1 { _A_ 1 _U_ 1 _N_ _S_ "U(LLL)" {_A_ 3 _U_ 222 _N_ _N_ _N_ _N_} _N_ _N_ } #-}
showChar :: Char -> [Char] -> [Char]
{-# GHC_PRAGMA _A_ 2 _U_ 22 _N_ _N_ _F_ _IF_ARGS_ 0 2 XX 3 \ (u0 :: Char) (u1 :: [Char]) -> _!_ (:) [Char] [u0, u1] _N_ #-}
showFloat :: RealFloat a => a -> [Char] -> [Char]
- {-# GHC_PRAGMA _A_ 1 _U_ 122 _N_ _S_ "U(U(LU(SLLL)LAAAA)LLLALAAAA)" {_A_ 5 _U_ 1122222 _N_ _N_ _N_ _N_} _N_ _SPECIALISE_ [ Double ] 1 { _A_ 1 _U_ 12 _N_ _S_ "U(P)" {_A_ 1 _U_ 22 _N_ _N_ _N_ _N_} _N_ _N_ }, [ Float ] 1 { _A_ 0 _U_ 22 _N_ _N_ _N_ _N_ } #-}
+ {-# GHC_PRAGMA _A_ 1 _U_ 122 _N_ _S_ "U(U(AU(SAAA)AAAAL)LLLALAAAA)" {_A_ 5 _U_ 1122222 _N_ _N_ _N_ _N_} _N_ _SPECIALISE_ [ Double ] 1 { _A_ 1 _U_ 12 _N_ _S_ "U(P)" {_A_ 1 _U_ 22 _N_ _N_ _N_ _N_} _N_ _N_ } #-}
showInt :: Integral a => a -> [Char] -> [Char]
{-# GHC_PRAGMA _A_ 1 _U_ 222 _N_ _S_ "U(U(U(U(SL)LLLLLLLLL)LL)LLLLLSLLLLL)" _N_ _SPECIALISE_ [ Int ] 1 { _A_ 2 _U_ 12 _N_ _S_ "U(P)L" {_A_ 2 _U_ 22 _N_ _N_ _N_ _N_} _N_ _N_ }, [ Integer ] 1 { _A_ 2 _U_ 12 _N_ _S_ "U(PPP)L" {_A_ 4 _U_ 2222 _N_ _N_ _N_ _N_} _N_ _N_ } #-}
showLitChar :: Char -> [Char] -> [Char]
showString :: [Char] -> [Char] -> [Char]
{-# GHC_PRAGMA _A_ 2 _U_ 12 _N_ _N_ _F_ _IF_ARGS_ 0 0 X 1 _TYAPP_ _ORIG_ PreludeList (++) { Char } _N_ #-}
shows :: Text a => a -> [Char] -> [Char]
- {-# GHC_PRAGMA _A_ 1 _U_ 122 _N_ _S_ "U(ASAA)" {_A_ 1 _U_ 122 _N_ _N_ _N_ _N_} _N_ _SPECIALISE_ [ Char ] 1 { _A_ 2 _U_ 12 _N_ _S_ "U(P)L" {_A_ 2 _U_ 22 _N_ _N_ _N_ _N_} _N_ _N_ }, [ Double ] 1 { _A_ 1 _U_ 12 _N_ _S_ "U(P)" {_A_ 1 _U_ 22 _N_ _N_ _N_ _N_} _N_ _N_ }, [ Float ] 1 { _A_ 0 _U_ 22 _N_ _N_ _N_ _N_ }, [ Int ] 1 { _A_ 2 _U_ 12 _N_ _S_ "U(P)L" {_A_ 2 _U_ 22 _N_ _N_ _N_ _N_} _N_ _N_ }, [ Integer ] 1 { _A_ 2 _U_ 12 _N_ _S_ "U(PPP)L" {_A_ 4 _U_ 2222 _N_ _N_ _N_ _N_} _N_ _N_ }, [ [Char] ] 1 { _A_ 1 _U_ 22 _N_ _N_ _F_ _IF_ARGS_ 0 0 X 1 _CONSTM_ Text showList (Char) _N_ }, [ _PackedString ] 1 { _A_ 2 _U_ 12 _N_ _N_ _N_ _N_ }, [ (Int, Int) ] 1 { _A_ 2 _U_ 12 _N_ _S_ "U(LL)L" {_A_ 3 _U_ 222 _N_ _N_ _N_ _N_} _N_ _N_ }, [ (Integer, Integer) ] 1 { _A_ 2 _U_ 12 _N_ _S_ "U(LL)L" {_A_ 3 _U_ 222 _N_ _N_ _N_ _N_} _N_ _N_ } #-}
+ {-# GHC_PRAGMA _A_ 1 _U_ 122 _N_ _S_ "U(ASAA)" {_A_ 1 _U_ 122 _N_ _N_ _N_ _N_} _N_ _SPECIALISE_ [ Bool ] 1 { _A_ 2 _U_ 22 _N_ _N_ _N_ _N_ }, [ Char ] 1 { _A_ 2 _U_ 12 _N_ _S_ "U(P)L" {_A_ 2 _U_ 22 _N_ _N_ _N_ _N_} _N_ _N_ }, [ Double ] 1 { _A_ 1 _U_ 12 _N_ _S_ "U(P)" {_A_ 1 _U_ 22 _N_ _N_ _N_ _N_} _N_ _N_ }, [ Int ] 1 { _A_ 2 _U_ 12 _N_ _S_ "U(P)L" {_A_ 2 _U_ 22 _N_ _N_ _N_ _N_} _N_ _N_ }, [ Integer ] 1 { _A_ 2 _U_ 12 _N_ _S_ "U(PPP)L" {_A_ 4 _U_ 2222 _N_ _N_ _N_ _N_} _N_ _N_ }, [ [Bool] ] 1 { _A_ 1 _U_ 12 _N_ _S_ "S" _F_ _IF_ARGS_ 0 1 X 3 \ (u0 :: [Bool]) -> _APP_ _TYAPP_ _ORIG_ PreludeCore _showList { Bool } [ _WRKR_ _CONSTM_ Text showsPrec (Bool), u0 ] _N_ }, [ [Char] ] 1 { _A_ 1 _U_ 22 _N_ _N_ _F_ _IF_ARGS_ 0 0 X 1 _CONSTM_ Text showList (Char) _N_ }, [ [Double] ] 1 { _A_ 1 _U_ 22 _N_ _N_ _F_ _IF_ARGS_ 0 0 X 1 _CONSTM_ Text showList (Double) _N_ }, [ [Int] ] 1 { _A_ 1 _U_ 22 _N_ _N_ _F_ _IF_ARGS_ 0 0 X 1 _CONSTM_ Text showList (Int) _N_ }, [ [Integer] ] 1 { _A_ 1 _U_ 22 _N_ _N_ _F_ _IF_ARGS_ 0 0 X 1 _CONSTM_ Text showList (Integer) _N_ }, [ [[Char]] ] 1 { _A_ 1 _U_ 12 _N_ _S_ "S" _F_ _IF_ARGS_ 0 1 X 3 \ (u0 :: [[Char]]) -> _APP_ _TYAPP_ _ORIG_ PreludeCore _showList { [Char] } [ _CONSTM_ Text showList (Char), u0 ] _N_ }, [ [[Int]] ] 1 { _A_ 1 _U_ 12 _N_ _S_ "S" _F_ _IF_ARGS_ 0 1 X 3 \ (u0 :: [[Int]]) -> _APP_ _TYAPP_ _ORIG_ PreludeCore _showList { [Int] } [ _CONSTM_ Text showList (Int), u0 ] _N_ }, [ [Complex Double] ] 1 { _A_ 1 _U_ 22 _N_ _N_ _F_ _IF_ARGS_ 0 0 X 1 _CONSTM_ Text showList (Complex Double) _N_ }, [ (Ratio Integer) ] 1 { _A_ 1 _U_ 12 _N_ _S_ "U(LL)" {_A_ 2 _U_ 222 _N_ _N_ _N_ _N_} _N_ _N_ }, [ (Array Int Double) ] 1 { _A_ 1 _U_ 22 _N_ _N_ _N_ _N_ }, [ (Array (Int, Int) Double) ] 1 { _A_ 1 _U_ 22 _N_ _N_ _N_ _N_ }, [ _PackedString ] 1 { _A_ 2 _U_ 12 _N_ _N_ _N_ _N_ }, [ (Complex Double) ] 1 { _A_ 1 _U_ 12 _N_ _S_ "U(LL)" {_A_ 2 _U_ 222 _N_ _N_ _N_ _N_} _N_ _N_ }, [ () ] 1 { _A_ 2 _U_ 12 _N_ _S_ "EL" _F_ _IF_ARGS_ 0 2 CX 4 \ (u0 :: ()) (u1 :: [Char]) -> case u0 of { _ALG_ _TUP_0 -> _APP_ _TYAPP_ _ORIG_ PreludeList (++) { Char } [ _NOREP_S_ "()", u1 ]; _NO_DEFLT_ } _N_ }, [ (Int, Int) ] 1 { _A_ 2 _U_ 12 _N_ _S_ "U(LL)L" {_A_ 3 _U_ 222 _N_ _N_ _N_ _N_} _N_ _N_ }, [ (Integer, Integer) ] 1 { _A_ 2 _U_ 12 _N_ _S_ "U(LL)L" {_A_ 3 _U_ 222 _N_ _N_ _N_ _N_} _N_ _N_ }, [ (Int, Int, Int) ] 1 { _A_ 2 _U_ 12 _N_ _S_ "U(LLL)L" {_A_ 4 _U_ 2222 _N_ _N_ _N_ _N_} _N_ _N_ } #-}
-{-# GHC_PRAGMA INTERFACE VERSION 5 #-}
+{-# GHC_PRAGMA INTERFACE VERSION 6 #-}
interface Prelude where
import PreludeArray((!), (//), Array, Assoc, _ByteArray, accum, accumArray, amap, array, assocs, bounds, elems, indices, ixmap, listArray)
import PreludeBuiltin(Bin, Char(..), Int(..), Integer(..), List(..), Tuple0, Tuple2, Tuple3, Tuple4, Tuple5, Tuple6, Tuple7, _Addr(..), _RealWorld(..), _State(..))
import PreludeComplex(Complex, cis, conjugate, imagPart, magnitude, mkPolar, phase, polar, realPart)
-import PreludeCore(Bool(..), Eq(..), Fractional(..), Integral(..), Ix(..), Num(..), Ord(..), Real(..), RealFloat(..), RealFrac(..), Text(..), _ceiling, _floor, _readList, _round, _showList, _showRational, _truncate)
+import PreludeCore(Bool(..), Eq(..), Fractional(..), Integral(..), Ix(..), Num(..), Ord(..), Real(..), RealFloat(..), RealFrac(..), Text(..), _readList, _showList, _showRational)
import PreludeIO(IOError, Request, Response, SigAct, abort, appendBinChan, appendBinFile, appendChan, appendFile, binDispatch, deleteFile, done, echo, exit, getArgs, getEnv, getProgName, interact, print, prints, readBinChan, readBinFile, readChan, readFile, setEnv, sigAction, statusChan, statusFile, stdecho, stderr, stdin, stdout, strDispatch, strListDispatch, succDispatch, writeBinFile, writeFile)
import PreludeList((!!), (++), (\\), all, and, any, break, concat, cycle, drop, dropWhile, elem, filter, foldl1, foldr1, genericLength, head, init, iterate, last, length, lines, map, maximum, minimum, notElem, nub, null, or, partition, product, products, repeat, reverse, scanl, scanl1, scanr, scanr1, span, splitAt, sum, sums, tail, take, takeWhile, transpose, unlines, unwords, unzip, unzip3, unzip4, unzip5, unzip6, unzip7, words, zip, zip3, zip4, zip5, zip6, zip7, zipWith, zipWith3, zipWith4, zipWith5, zipWith6, zipWith7)
import PreludePS(_PackedString, _appendPS, _breakPS, _byteArrayToPS, _concatPS, _consPS, _dropPS, _dropWhilePS, _filterPS, _foldlPS, _foldrPS, _headPS, _indexPS, _lengthPS, _linesPS, _mapPS, _nilPS, _nullPS, _packCBytes, _packCString, _packString, _psToByteArray, _putPS, _reversePS, _spanPS, _splitAtPS, _substrPS, _tailPS, _takePS, _takeWhilePS, _unpackPS, _wordsPS)
(.) :: (a -> c) -> (b -> a) -> b -> c
{-# GHC_PRAGMA _A_ 3 _U_ 112 _N_ _S_ "SLL" _F_ _ALWAYS_ _/\_ u0 u1 u2 -> \ (u3 :: u0 -> u2) (u4 :: u1 -> u0) (u5 :: u1) -> let {(u6 :: u0) = _APP_ u4 [ u5 ]} in _APP_ u3 [ u6 ] _N_ #-}
(^) :: (Num b, Integral a) => b -> a -> b
- {-# GHC_PRAGMA _A_ 2 _U_ 2122 _N_ _S_ "LU(U(LU(U(U(SA)AALAAAA)AAAA)A)AAALAAAALAA)" {_A_ 5 _U_ 2212222 _N_ _N_ _N_ _N_} _N_ _SPECIALISE_ [ Int, Double ] 2 { _A_ 2 _U_ 21 _N_ _S_ "LU(P)" {_A_ 2 _U_ 22 _N_ _N_ _N_ _N_} _N_ _N_ }, [ Int, Int ] 2 { _A_ 2 _U_ 21 _N_ _S_ "LU(P)" {_A_ 2 _U_ 22 _N_ _N_ _N_ _N_} _N_ _N_ }, [ Int, Integer ] 2 { _A_ 2 _U_ 21 _N_ _S_ "LU(P)" {_A_ 2 _U_ 22 _N_ _N_ _N_ _N_} _N_ _N_ }, [ Int, (Ratio Integer) ] 2 { _A_ 2 _U_ 21 _N_ _S_ "LU(P)" {_A_ 2 _U_ 22 _N_ _N_ _N_ _N_} _N_ _N_ }, [ Int, (Complex Double) ] 2 { _A_ 2 _U_ 21 _N_ _S_ "LU(P)" {_A_ 2 _U_ 22 _N_ _N_ _N_ _N_} _N_ _N_ } #-}
+ {-# GHC_PRAGMA _A_ 2 _U_ 2122 _N_ _S_ "LU(U(LU(U(U(SL)LLLLLLL)LLLL)L)LLLLLLLLLLL)" _N_ _SPECIALISE_ [ Int, Double ] 2 { _A_ 2 _U_ 21 _N_ _S_ "LU(P)" {_A_ 2 _U_ 22 _N_ _N_ _N_ _N_} _N_ _N_ }, [ Int, Int ] 2 { _A_ 2 _U_ 21 _N_ _S_ "LU(P)" {_A_ 2 _U_ 22 _N_ _N_ _N_ _N_} _N_ _N_ }, [ Int, Integer ] 2 { _A_ 2 _U_ 21 _N_ _S_ "LU(P)" {_A_ 2 _U_ 22 _N_ _N_ _N_ _N_} _N_ _N_ }, [ Int, (Ratio Integer) ] 2 { _A_ 2 _U_ 21 _N_ _S_ "LU(P)" {_A_ 2 _U_ 22 _N_ _N_ _N_ _N_} _N_ _N_ }, [ Int, (Complex Double) ] 2 { _A_ 2 _U_ 21 _N_ _S_ "LU(P)" {_A_ 2 _U_ 22 _N_ _N_ _N_ _N_} _N_ _N_ }, [ Integer, Integer ] 2 { _A_ 2 _U_ 21 _N_ _S_ "LU(PPP)" {_A_ 4 _U_ 2222 _N_ _N_ _N_ _N_} _N_ _N_ } #-}
(^^) :: (Fractional b, Integral a) => b -> a -> b
- {-# GHC_PRAGMA _A_ 2 _U_ 2122 _N_ _S_ "LU(LU(U(AAASAAAA)AAA)AALAAAALAA)" {_A_ 5 _U_ 2212222 _N_ _N_ _N_ _N_} _N_ _SPECIALISE_ [ Int, Double ] 2 { _A_ 2 _U_ 21 _N_ _S_ "LU(P)" {_A_ 2 _U_ 22 _N_ _N_ _N_ _N_} _N_ _N_ }, [ Int, (Ratio Integer) ] 2 { _A_ 2 _U_ 21 _N_ _S_ "LU(P)" {_A_ 2 _U_ 22 _N_ _N_ _N_ _N_} _N_ _N_ } #-}
+ {-# GHC_PRAGMA _A_ 2 _U_ 2222 _N_ _S_ "LU(LU(U(LLLSLLLL)LLL)LLLLLLLLLL)" _N_ _SPECIALISE_ [ Int, Double ] 2 { _A_ 2 _U_ 21 _N_ _S_ "LU(P)" {_A_ 2 _U_ 22 _N_ _N_ _N_ _N_} _N_ _N_ }, [ Int, (Ratio Integer) ] 2 { _A_ 2 _U_ 21 _N_ _S_ "LU(P)" {_A_ 2 _U_ 22 _N_ _N_ _N_ _N_} _N_ _N_ }, [ Int, (Complex Double) ] 2 { _A_ 2 _U_ 21 _N_ _S_ "LU(P)" {_A_ 2 _U_ 22 _N_ _N_ _N_ _N_} _N_ _N_ } #-}
appendBin :: Bin -> Bin -> Bin
- {-# GHC_PRAGMA _A_ 2 _U_ 22 _N_ _S_ _!_ _F_ _IF_ARGS_ 0 2 XX 4 \ (u0 :: Bin) (u1 :: Bin) -> _APP_ _TYAPP_ error { (Bin -> Bin -> Bin) } [ _NOREP_S_ "appendBin{Prelude}\n", u0, u1 ] _N_ #-}
+ {-# GHC_PRAGMA _A_ 2 _U_ 22 _N_ _S_ _!_ _N_ _N_ #-}
asTypeOf :: a -> a -> a
{-# GHC_PRAGMA _A_ 2 _U_ 10 _N_ _N_ _F_ _IF_ARGS_ 1 0 X 1 _/\_ u0 -> _TYAPP_ _TYAPP_ _ORIG_ Prelude const { u0 } { u0 } _N_ #-}
atan2 :: RealFloat a => a -> a -> a
flip :: (b -> a -> c) -> a -> b -> c
{-# GHC_PRAGMA _A_ 3 _U_ 122 _N_ _S_ "SLL" _F_ _IF_ARGS_ 3 3 XXX 3 _/\_ u0 u1 u2 -> \ (u3 :: u1 -> u0 -> u2) (u4 :: u0) (u5 :: u1) -> _APP_ u3 [ u5, u4 ] _N_ #-}
fromIntegral :: (Integral a, Num b) => a -> b
- {-# GHC_PRAGMA _A_ 3 _U_ 112 _N_ _S_ "LU(AAAAAAAASA)L" {_A_ 3 _U_ 112 _N_ _N_ _F_ _IF_ARGS_ 2 3 CXX 6 _/\_ u0 u1 -> \ (u2 :: {{Integral u0}}) (u3 :: Integer -> u1) (u4 :: u0) -> let {(uh :: Integer) = case u2 of { _ALG_ _TUP_12 (u5 :: {{Real u0}}) (u6 :: {{Ix u0}}) (u7 :: u0 -> u0 -> u0) (u8 :: u0 -> u0 -> u0) (u9 :: u0 -> u0 -> u0) (ua :: u0 -> u0 -> u0) (ub :: u0 -> u0 -> (u0, u0)) (uc :: u0 -> u0 -> (u0, u0)) (ud :: u0 -> Bool) (ue :: u0 -> Bool) (uf :: u0 -> Integer) (ug :: u0 -> Int) -> _APP_ uf [ u4 ]; _NO_DEFLT_ }} in _APP_ u3 [ uh ] _N_} _F_ _IF_ARGS_ 2 3 CCX 7 _/\_ u0 u1 -> \ (u2 :: {{Integral u0}}) (u3 :: {{Num u1}}) (u4 :: u0) -> let {(uh :: Integer) = case u2 of { _ALG_ _TUP_12 (u5 :: {{Real u0}}) (u6 :: {{Ix u0}}) (u7 :: u0 -> u0 -> u0) (u8 :: u0 -> u0 -> u0) (u9 :: u0 -> u0 -> u0) (ua :: u0 -> u0 -> u0) (ub :: u0 -> u0 -> (u0, u0)) (uc :: u0 -> u0 -> (u0, u0)) (ud :: u0 -> Bool) (ue :: u0 -> Bool) (uf :: u0 -> Integer) (ug :: u0 -> Int) -> _APP_ uf [ u4 ]; _NO_DEFLT_ }} in case u3 of { _ALG_ _TUP_10 (ui :: {{Eq u1}}) (uj :: {{Text u1}}) (uk :: u1 -> u1 -> u1) (ul :: u1 -> u1 -> u1) (um :: u1 -> u1 -> u1) (un :: u1 -> u1) (uo :: u1 -> u1) (up :: u1 -> u1) (uq :: Integer -> u1) (ur :: Int -> u1) -> _APP_ uq [ uh ]; _NO_DEFLT_ } _SPECIALISE_ [ Int, Double ] 2 { _A_ 1 _U_ 1 _N_ _S_ "U(P)" {_A_ 1 _U_ 2 _N_ _N_ _F_ _IF_ARGS_ 0 1 X 3 \ (u0 :: Int#) -> case _#_ int2Double# [] [u0] of { _PRIM_ (u1 :: Double#) -> _!_ D# [] [u1] } _N_} _F_ _IF_ARGS_ 0 1 C 4 \ (u0 :: Int) -> case u0 of { _ALG_ I# (u1 :: Int#) -> case _#_ int2Double# [] [u1] of { _PRIM_ (u2 :: Double#) -> _!_ D# [] [u2] }; _NO_DEFLT_ } _N_ }, [ Int, Int ] 2 { _A_ 1 _U_ 1 _N_ _N_ _F_ _IF_ARGS_ 0 0 X 1 _TYAPP_ _ORIG_ Prelude id { Int } _N_ }, [ Int, Integer ] 2 { _A_ 1 _U_ 1 _N_ _S_ "U(P)" {_A_ 1 _U_ 2 _N_ _N_ _F_ _IF_ARGS_ 0 1 X 1 \ (u0 :: Int#) -> _#_ int2Integer# [] [u0] _N_} _F_ _IF_ARGS_ 0 1 C 2 \ (u0 :: Int) -> case u0 of { _ALG_ I# (u1 :: Int#) -> _#_ int2Integer# [] [u1]; _NO_DEFLT_ } _N_ }, [ Integer, Double ] 2 { _A_ 1 _U_ 1 _N_ _S_ "U(PPP)" {_A_ 3 _U_ 222 _N_ _N_ _F_ _IF_ARGS_ 0 3 XXX 3 \ (u0 :: Int#) (u1 :: Int#) (u2 :: ByteArray#) -> case _#_ encodeDouble# [] [u0, u1, u2, 0#] of { _PRIM_ (u3 :: Double#) -> _!_ D# [] [u3] } _N_} _F_ _IF_ARGS_ 0 1 C 4 \ (u0 :: Integer) -> case u0 of { _ALG_ J# (u1 :: Int#) (u2 :: Int#) (u3 :: ByteArray#) -> case _#_ encodeDouble# [] [u1, u2, u3, 0#] of { _PRIM_ (u4 :: Double#) -> _!_ D# [] [u4] }; _NO_DEFLT_ } _N_ }, [ Integer, Int ] 2 { _A_ 1 _U_ 1 _N_ _S_ "U(PPP)" {_A_ 3 _U_ 222 _N_ _N_ _F_ _IF_ARGS_ 0 3 XXX 3 \ (u0 :: Int#) (u1 :: Int#) (u2 :: ByteArray#) -> case _#_ integer2Int# [] [u0, u1, u2] of { _PRIM_ (u3 :: Int#) -> _!_ I# [] [u3] } _N_} _F_ _IF_ARGS_ 0 1 C 4 \ (u0 :: Integer) -> case u0 of { _ALG_ J# (u1 :: Int#) (u2 :: Int#) (u3 :: ByteArray#) -> case _#_ integer2Int# [] [u1, u2, u3] of { _PRIM_ (u4 :: Int#) -> _!_ I# [] [u4] }; _NO_DEFLT_ } _N_ }, [ Integer, Integer ] 2 { _A_ 1 _U_ 1 _N_ _N_ _F_ _IF_ARGS_ 0 0 X 1 _TYAPP_ _ORIG_ Prelude id { Integer } _N_ } #-}
+ {-# GHC_PRAGMA _A_ 3 _U_ 112 _N_ _S_ "LU(AAAAAAAASA)L" {_A_ 3 _U_ 112 _N_ _N_ _F_ _IF_ARGS_ 2 3 CXX 6 _/\_ u0 u1 -> \ (u2 :: {{Integral u0}}) (u3 :: Integer -> u1) (u4 :: u0) -> let {(uh :: Integer) = case u2 of { _ALG_ _TUP_12 (u5 :: {{Real u0}}) (u6 :: {{Ix u0}}) (u7 :: u0 -> u0 -> u0) (u8 :: u0 -> u0 -> u0) (u9 :: u0 -> u0 -> u0) (ua :: u0 -> u0 -> u0) (ub :: u0 -> u0 -> (u0, u0)) (uc :: u0 -> u0 -> (u0, u0)) (ud :: u0 -> Bool) (ue :: u0 -> Bool) (uf :: u0 -> Integer) (ug :: u0 -> Int) -> _APP_ uf [ u4 ]; _NO_DEFLT_ }} in _APP_ u3 [ uh ] _N_} _F_ _IF_ARGS_ 2 3 CCX 7 _/\_ u0 u1 -> \ (u2 :: {{Integral u0}}) (u3 :: {{Num u1}}) (u4 :: u0) -> let {(uh :: Integer) = case u2 of { _ALG_ _TUP_12 (u5 :: {{Real u0}}) (u6 :: {{Ix u0}}) (u7 :: u0 -> u0 -> u0) (u8 :: u0 -> u0 -> u0) (u9 :: u0 -> u0 -> u0) (ua :: u0 -> u0 -> u0) (ub :: u0 -> u0 -> (u0, u0)) (uc :: u0 -> u0 -> (u0, u0)) (ud :: u0 -> Bool) (ue :: u0 -> Bool) (uf :: u0 -> Integer) (ug :: u0 -> Int) -> _APP_ uf [ u4 ]; _NO_DEFLT_ }} in case u3 of { _ALG_ _TUP_10 (ui :: {{Eq u1}}) (uj :: {{Text u1}}) (uk :: u1 -> u1 -> u1) (ul :: u1 -> u1 -> u1) (um :: u1 -> u1 -> u1) (un :: u1 -> u1) (uo :: u1 -> u1) (up :: u1 -> u1) (uq :: Integer -> u1) (ur :: Int -> u1) -> _APP_ uq [ uh ]; _NO_DEFLT_ } _SPECIALISE_ [ Int, Double ] 2 { _A_ 1 _U_ 1 _N_ _S_ "U(P)" {_A_ 1 _U_ 2 _N_ _N_ _F_ _IF_ARGS_ 0 1 X 3 \ (u0 :: Int#) -> case _#_ int2Double# [] [u0] of { _PRIM_ (u1 :: Double#) -> _!_ D# [] [u1] } _N_} _F_ _IF_ARGS_ 0 1 C 4 \ (u0 :: Int) -> case u0 of { _ALG_ I# (u1 :: Int#) -> case _#_ int2Double# [] [u1] of { _PRIM_ (u2 :: Double#) -> _!_ D# [] [u2] }; _NO_DEFLT_ } _N_ }, [ Int, Float ] 2 { _A_ 1 _U_ 1 _N_ _S_ "U(P)" {_A_ 1 _U_ 2 _N_ _N_ _F_ _IF_ARGS_ 0 1 X 3 \ (u0 :: Int#) -> case _#_ int2Float# [] [u0] of { _PRIM_ (u1 :: Float#) -> _!_ F# [] [u1] } _N_} _F_ _IF_ARGS_ 0 1 C 4 \ (u0 :: Int) -> case u0 of { _ALG_ I# (u1 :: Int#) -> case _#_ int2Float# [] [u1] of { _PRIM_ (u2 :: Float#) -> _!_ F# [] [u2] }; _NO_DEFLT_ } _N_ }, [ Int, Int ] 2 { _A_ 1 _U_ 1 _N_ _N_ _F_ _IF_ARGS_ 0 0 X 1 _TYAPP_ _ORIG_ Prelude id { Int } _N_ }, [ Int, Integer ] 2 { _A_ 1 _U_ 1 _N_ _S_ "U(P)" {_A_ 1 _U_ 2 _N_ _N_ _F_ _IF_ARGS_ 0 1 X 1 \ (u0 :: Int#) -> _#_ int2Integer# [] [u0] _N_} _F_ _IF_ARGS_ 0 1 C 2 \ (u0 :: Int) -> case u0 of { _ALG_ I# (u1 :: Int#) -> _#_ int2Integer# [] [u1]; _NO_DEFLT_ } _N_ }, [ Int, (Ratio Integer) ] 2 { _A_ 1 _U_ 1 _N_ _N_ _N_ _N_ }, [ Integer, Double ] 2 { _A_ 1 _U_ 1 _N_ _S_ "U(PPP)" {_A_ 3 _U_ 222 _N_ _N_ _F_ _IF_ARGS_ 0 3 XXX 3 \ (u0 :: Int#) (u1 :: Int#) (u2 :: ByteArray#) -> case _#_ encodeDouble# [] [u0, u1, u2, 0#] of { _PRIM_ (u3 :: Double#) -> _!_ D# [] [u3] } _N_} _F_ _IF_ARGS_ 0 1 C 4 \ (u0 :: Integer) -> case u0 of { _ALG_ J# (u1 :: Int#) (u2 :: Int#) (u3 :: ByteArray#) -> case _#_ encodeDouble# [] [u1, u2, u3, 0#] of { _PRIM_ (u4 :: Double#) -> _!_ D# [] [u4] }; _NO_DEFLT_ } _N_ }, [ Integer, Float ] 2 { _A_ 1 _U_ 1 _N_ _S_ "U(PPP)" {_A_ 3 _U_ 222 _N_ _N_ _F_ _IF_ARGS_ 0 3 XXX 3 \ (u0 :: Int#) (u1 :: Int#) (u2 :: ByteArray#) -> case _#_ encodeFloat# [] [u0, u1, u2, 0#] of { _PRIM_ (u3 :: Float#) -> _!_ F# [] [u3] } _N_} _F_ _IF_ARGS_ 0 1 C 4 \ (u0 :: Integer) -> case u0 of { _ALG_ J# (u1 :: Int#) (u2 :: Int#) (u3 :: ByteArray#) -> case _#_ encodeFloat# [] [u1, u2, u3, 0#] of { _PRIM_ (u4 :: Float#) -> _!_ F# [] [u4] }; _NO_DEFLT_ } _N_ }, [ Integer, Int ] 2 { _A_ 1 _U_ 1 _N_ _S_ "U(PPP)" {_A_ 3 _U_ 222 _N_ _N_ _F_ _IF_ARGS_ 0 3 XXX 3 \ (u0 :: Int#) (u1 :: Int#) (u2 :: ByteArray#) -> case _#_ integer2Int# [] [u0, u1, u2] of { _PRIM_ (u3 :: Int#) -> _!_ I# [] [u3] } _N_} _F_ _IF_ARGS_ 0 1 C 4 \ (u0 :: Integer) -> case u0 of { _ALG_ J# (u1 :: Int#) (u2 :: Int#) (u3 :: ByteArray#) -> case _#_ integer2Int# [] [u1, u2, u3] of { _PRIM_ (u4 :: Int#) -> _!_ I# [] [u4] }; _NO_DEFLT_ } _N_ }, [ Integer, Integer ] 2 { _A_ 1 _U_ 1 _N_ _N_ _F_ _IF_ARGS_ 0 0 X 1 _TYAPP_ _ORIG_ Prelude id { Integer } _N_ }, [ Integer, (Ratio Integer) ] 2 { _A_ 1 _U_ 2 _N_ _N_ _F_ _IF_ARGS_ 0 1 X 3 \ (u0 :: Integer) -> _!_ (:%) [Integer] [u0, _SPEC_ _ORIG_ PreludeCore __i1 [ (Integer) ]] _N_ } #-}
fromRealFrac :: (RealFrac a, Fractional b) => a -> b
- {-# GHC_PRAGMA _A_ 3 _U_ 112 _N_ _S_ "LU(AAAS)L" {_A_ 3 _U_ 112 _N_ _N_ _F_ _IF_ARGS_ 2 3 CXX 7 _/\_ u0 u1 -> \ (u2 :: {{RealFrac u0}}) (u3 :: Ratio Integer -> u1) (u4 :: u0) -> let {(uf :: Ratio Integer) = case u2 of { _ALG_ _TUP_7 (u5 :: {{Real u0}}) (u6 :: {{Fractional u0}}) (u7 :: _forall_ a$z1 =>{{Integral a$z1}} -> u0 -> (a$z1, u0)) (u8 :: _forall_ a$z1 =>{{Integral a$z1}} -> u0 -> a$z1) (u9 :: _forall_ a$z1 =>{{Integral a$z1}} -> u0 -> a$z1) (ua :: _forall_ a$z1 =>{{Integral a$z1}} -> u0 -> a$z1) (ub :: _forall_ a$z1 =>{{Integral a$z1}} -> u0 -> a$z1) -> case u5 of { _ALG_ _TUP_3 (uc :: {{Num u0}}) (ud :: {{Enum u0}}) (ue :: u0 -> Ratio Integer) -> _APP_ ue [ u4 ]; _NO_DEFLT_ }; _NO_DEFLT_ }} in _APP_ u3 [ uf ] _N_} _F_ _IF_ARGS_ 2 3 CCX 8 _/\_ u0 u1 -> \ (u2 :: {{RealFrac u0}}) (u3 :: {{Fractional u1}}) (u4 :: u0) -> let {(uf :: Ratio Integer) = case u2 of { _ALG_ _TUP_7 (u5 :: {{Real u0}}) (u6 :: {{Fractional u0}}) (u7 :: _forall_ a$z1 =>{{Integral a$z1}} -> u0 -> (a$z1, u0)) (u8 :: _forall_ a$z1 =>{{Integral a$z1}} -> u0 -> a$z1) (u9 :: _forall_ a$z1 =>{{Integral a$z1}} -> u0 -> a$z1) (ua :: _forall_ a$z1 =>{{Integral a$z1}} -> u0 -> a$z1) (ub :: _forall_ a$z1 =>{{Integral a$z1}} -> u0 -> a$z1) -> case u5 of { _ALG_ _TUP_3 (uc :: {{Num u0}}) (ud :: {{Enum u0}}) (ue :: u0 -> Ratio Integer) -> _APP_ ue [ u4 ]; _NO_DEFLT_ }; _NO_DEFLT_ }} in case u3 of { _ALG_ _TUP_4 (ug :: {{Num u1}}) (uh :: u1 -> u1 -> u1) (ui :: u1 -> u1) (uj :: Ratio Integer -> u1) -> _APP_ uj [ uf ]; _NO_DEFLT_ } _SPECIALISE_ [ Double, Double ] 2 { _A_ 1 _U_ 1 _N_ _N_ _F_ _IF_ARGS_ 0 0 X 1 _TYAPP_ _ORIG_ Prelude id { Double } _N_ }, [ Double, Float ] 2 { _A_ 1 _U_ 1 _N_ _S_ "U(P)" {_A_ 1 _U_ 2 _N_ _N_ _F_ _IF_ARGS_ 0 1 X 3 \ (u0 :: Double#) -> case _#_ double2Float# [] [u0] of { _PRIM_ (u1 :: Float#) -> _!_ F# [] [u1] } _N_} _F_ _IF_ARGS_ 0 1 C 4 \ (u0 :: Double) -> case u0 of { _ALG_ D# (u1 :: Double#) -> case _#_ double2Float# [] [u1] of { _PRIM_ (u2 :: Float#) -> _!_ F# [] [u2] }; _NO_DEFLT_ } _N_ }, [ Float, Double ] 2 { _A_ 1 _U_ 1 _N_ _S_ "U(P)" {_A_ 1 _U_ 2 _N_ _N_ _F_ _IF_ARGS_ 0 1 X 3 \ (u0 :: Float#) -> case _#_ float2Double# [] [u0] of { _PRIM_ (u1 :: Double#) -> _!_ D# [] [u1] } _N_} _F_ _IF_ARGS_ 0 1 C 4 \ (u0 :: Float) -> case u0 of { _ALG_ F# (u1 :: Float#) -> case _#_ float2Double# [] [u1] of { _PRIM_ (u2 :: Double#) -> _!_ D# [] [u2] }; _NO_DEFLT_ } _N_ }, [ Float, Float ] 2 { _A_ 1 _U_ 1 _N_ _N_ _F_ _IF_ARGS_ 0 0 X 1 _TYAPP_ _ORIG_ Prelude id { Float } _N_ } #-}
+ {-# GHC_PRAGMA _A_ 3 _U_ 112 _N_ _S_ "LU(AAAS)L" {_A_ 3 _U_ 112 _N_ _N_ _F_ _IF_ARGS_ 2 3 CXX 7 _/\_ u0 u1 -> \ (u2 :: {{RealFrac u0}}) (u3 :: Ratio Integer -> u1) (u4 :: u0) -> let {(uf :: Ratio Integer) = case u2 of { _ALG_ _TUP_7 (u5 :: {{Real u0}}) (u6 :: {{Fractional u0}}) (u7 :: _forall_ a$z1 =>{{Integral a$z1}} -> u0 -> (a$z1, u0)) (u8 :: _forall_ a$z1 =>{{Integral a$z1}} -> u0 -> a$z1) (u9 :: _forall_ a$z1 =>{{Integral a$z1}} -> u0 -> a$z1) (ua :: _forall_ a$z1 =>{{Integral a$z1}} -> u0 -> a$z1) (ub :: _forall_ a$z1 =>{{Integral a$z1}} -> u0 -> a$z1) -> case u5 of { _ALG_ _TUP_3 (uc :: {{Num u0}}) (ud :: {{Enum u0}}) (ue :: u0 -> Ratio Integer) -> _APP_ ue [ u4 ]; _NO_DEFLT_ }; _NO_DEFLT_ }} in _APP_ u3 [ uf ] _N_} _F_ _IF_ARGS_ 2 3 CCX 8 _/\_ u0 u1 -> \ (u2 :: {{RealFrac u0}}) (u3 :: {{Fractional u1}}) (u4 :: u0) -> let {(uf :: Ratio Integer) = case u2 of { _ALG_ _TUP_7 (u5 :: {{Real u0}}) (u6 :: {{Fractional u0}}) (u7 :: _forall_ a$z1 =>{{Integral a$z1}} -> u0 -> (a$z1, u0)) (u8 :: _forall_ a$z1 =>{{Integral a$z1}} -> u0 -> a$z1) (u9 :: _forall_ a$z1 =>{{Integral a$z1}} -> u0 -> a$z1) (ua :: _forall_ a$z1 =>{{Integral a$z1}} -> u0 -> a$z1) (ub :: _forall_ a$z1 =>{{Integral a$z1}} -> u0 -> a$z1) -> case u5 of { _ALG_ _TUP_3 (uc :: {{Num u0}}) (ud :: {{Enum u0}}) (ue :: u0 -> Ratio Integer) -> _APP_ ue [ u4 ]; _NO_DEFLT_ }; _NO_DEFLT_ }} in case u3 of { _ALG_ _TUP_4 (ug :: {{Num u1}}) (uh :: u1 -> u1 -> u1) (ui :: u1 -> u1) (uj :: Ratio Integer -> u1) -> _APP_ uj [ uf ]; _NO_DEFLT_ } _SPECIALISE_ [ Double, Double ] 2 { _A_ 1 _U_ 1 _N_ _N_ _F_ _IF_ARGS_ 0 0 X 1 _TYAPP_ _ORIG_ Prelude id { Double } _N_ }, [ Double, Float ] 2 { _A_ 1 _U_ 1 _N_ _S_ "U(P)" {_A_ 1 _U_ 2 _N_ _N_ _F_ _IF_ARGS_ 0 1 X 3 \ (u0 :: Double#) -> case _#_ double2Float# [] [u0] of { _PRIM_ (u1 :: Float#) -> _!_ F# [] [u1] } _N_} _F_ _IF_ARGS_ 0 1 C 4 \ (u0 :: Double) -> case u0 of { _ALG_ D# (u1 :: Double#) -> case _#_ double2Float# [] [u1] of { _PRIM_ (u2 :: Float#) -> _!_ F# [] [u2] }; _NO_DEFLT_ } _N_ }, [ Double, (Ratio Integer) ] 2 { _A_ 1 _U_ 1 _N_ _S_ "U(P)" {_A_ 1 _U_ 2 _N_ _N_ _N_ _N_} _N_ _N_ }, [ Float, Double ] 2 { _A_ 1 _U_ 1 _N_ _S_ "U(P)" {_A_ 1 _U_ 2 _N_ _N_ _F_ _IF_ARGS_ 0 1 X 3 \ (u0 :: Float#) -> case _#_ float2Double# [] [u0] of { _PRIM_ (u1 :: Double#) -> _!_ D# [] [u1] } _N_} _F_ _IF_ARGS_ 0 1 C 4 \ (u0 :: Float) -> case u0 of { _ALG_ F# (u1 :: Float#) -> case _#_ float2Double# [] [u1] of { _PRIM_ (u2 :: Double#) -> _!_ D# [] [u2] }; _NO_DEFLT_ } _N_ }, [ Float, Float ] 2 { _A_ 1 _U_ 1 _N_ _N_ _F_ _IF_ARGS_ 0 0 X 1 _TYAPP_ _ORIG_ Prelude id { Float } _N_ }, [ Float, (Ratio Integer) ] 2 { _A_ 1 _U_ 1 _N_ _S_ "U(P)" {_A_ 1 _U_ 2 _N_ _N_ _N_ _N_} _N_ _N_ }, [ (Ratio Integer), Double ] 2 { _A_ 1 _U_ 1 _N_ _S_ "U(U(PPP)U(PPP))" {_A_ 4 _U_ 2222 _N_ _N_ _N_ _N_} _N_ _N_ }, [ (Ratio Integer), Float ] 2 { _A_ 1 _U_ 2 _N_ _N_ _F_ _IF_ARGS_ 0 0 X 1 _CONSTM_ Fractional fromRational (Float) _N_ }, [ (Ratio Integer), (Ratio Integer) ] 2 { _A_ 1 _U_ 1 _N_ _N_ _F_ _IF_ARGS_ 0 0 X 1 _TYAPP_ _ORIG_ Prelude id { (Ratio Integer) } _N_ } #-}
fst :: (b, a) -> b
{-# GHC_PRAGMA _A_ 1 _U_ 1 _N_ _S_ "U(SA)" {_A_ 1 _U_ 1 _N_ _N_ _F_ _IF_ARGS_ 2 1 X 1 _/\_ u0 u1 -> \ (u2 :: u1) -> u2 _N_} _F_ _IF_ARGS_ 2 1 C 2 _/\_ u0 u1 -> \ (u2 :: (u1, u0)) -> case u2 of { _ALG_ _TUP_2 (u3 :: u1) (u4 :: u0) -> u3; _NO_DEFLT_ } _N_ #-}
gcd :: Integral a => a -> a -> a
isLower :: Char -> Bool
{-# GHC_PRAGMA _A_ 1 _U_ 1 _N_ _S_ "U(P)" {_A_ 1 _U_ 2 _N_ _N_ _N_ _N_} _N_ _N_ #-}
isNullBin :: Bin -> Bool
- {-# GHC_PRAGMA _A_ 1 _U_ 2 _N_ _S_ _!_ _F_ _IF_ARGS_ 0 1 X 3 \ (u0 :: Bin) -> _APP_ _TYAPP_ error { (Bin -> Bool) } [ _NOREP_S_ "isNullBin{Prelude}\n", u0 ] _N_ #-}
+ {-# GHC_PRAGMA _A_ 1 _U_ 2 _N_ _S_ _!_ _N_ _N_ #-}
isPrint :: Char -> Bool
{-# GHC_PRAGMA _A_ 1 _U_ 1 _N_ _S_ "U(P)" {_A_ 1 _U_ 2 _N_ _N_ _N_ _N_} _N_ _N_ #-}
isSpace :: Char -> Bool
not :: Bool -> Bool
{-# GHC_PRAGMA _A_ 1 _U_ 1 _N_ _S_ "E" _F_ _ALWAYS_ \ (u0 :: Bool) -> case u0 of { _ALG_ True -> _!_ False [] []; False -> _!_ True [] []; _NO_DEFLT_ } _N_ #-}
nullBin :: Bin
- {-# GHC_PRAGMA _A_ 0 _N_ _N_ _S_ _!_ _F_ _IF_ARGS_ 0 0 X 2 _APP_ _TYAPP_ error { Bin } [ _NOREP_S_ "nullBin{Prelude}\n" ] _N_ #-}
+ {-# GHC_PRAGMA _A_ 0 _N_ _N_ _S_ _!_ _N_ _N_ #-}
ord :: Char -> Int
{-# GHC_PRAGMA _A_ 1 _U_ 1 _N_ _S_ "U(P)" {_A_ 1 _U_ 2 _N_ _N_ _F_ _IF_ARGS_ 0 1 X 3 \ (u0 :: Char#) -> case _#_ ord# [] [u0] of { _PRIM_ (u1 :: Int#) -> _!_ I# [] [u1] } _N_} _F_ _IF_ARGS_ 0 1 C 4 \ (u0 :: Char) -> case u0 of { _ALG_ C# (u1 :: Char#) -> case _#_ ord# [] [u1] of { _PRIM_ (u2 :: Int#) -> _!_ I# [] [u2] }; _NO_DEFLT_ } _N_ #-}
otherwise :: Bool
snd :: (a, b) -> b
{-# GHC_PRAGMA _A_ 1 _U_ 1 _N_ _S_ "U(AS)" {_A_ 1 _U_ 1 _N_ _N_ _F_ _IF_ARGS_ 2 1 X 1 _/\_ u0 u1 -> \ (u2 :: u1) -> u2 _N_} _F_ _IF_ARGS_ 2 1 C 2 _/\_ u0 u1 -> \ (u2 :: (u0, u1)) -> case u2 of { _ALG_ _TUP_2 (u3 :: u0) (u4 :: u1) -> u4; _NO_DEFLT_ } _N_ #-}
subtract :: Num a => a -> a -> a
- {-# GHC_PRAGMA _A_ 3 _U_ 122 _N_ _S_ "U(AAASAAAAAA)LL" {_A_ 3 _U_ 122 _N_ _N_ _F_ _IF_ARGS_ 1 3 XXX 3 _/\_ u0 -> \ (u1 :: u0 -> u0 -> u0) (u2 :: u0) (u3 :: u0) -> _APP_ u1 [ u3, u2 ] _N_} _F_ _IF_ARGS_ 1 3 CXX 4 _/\_ u0 -> \ (u1 :: {{Num u0}}) (u2 :: u0) (u3 :: u0) -> case u1 of { _ALG_ _TUP_10 (u4 :: {{Eq u0}}) (u5 :: {{Text u0}}) (u6 :: u0 -> u0 -> u0) (u7 :: u0 -> u0 -> u0) (u8 :: u0 -> u0 -> u0) (u9 :: u0 -> u0) (ua :: u0 -> u0) (ub :: u0 -> u0) (uc :: Integer -> u0) (ud :: Int -> u0) -> _APP_ u7 [ u3, u2 ]; _NO_DEFLT_ } _SPECIALISE_ [ Double ] 1 { _A_ 2 _U_ 11 _N_ _S_ "U(P)U(P)" {_A_ 2 _U_ 22 _N_ _N_ _F_ _IF_ARGS_ 0 2 XX 3 \ (u0 :: Double#) (u1 :: Double#) -> case _#_ minusDouble# [] [u1, u0] of { _PRIM_ (u2 :: Double#) -> _!_ D# [] [u2] } _N_} _F_ _IF_ARGS_ 0 2 CC 5 \ (u0 :: Double) (u1 :: Double) -> case u1 of { _ALG_ D# (u2 :: Double#) -> case u0 of { _ALG_ D# (u3 :: Double#) -> case _#_ minusDouble# [] [u2, u3] of { _PRIM_ (u4 :: Double#) -> _!_ D# [] [u4] }; _NO_DEFLT_ }; _NO_DEFLT_ } _N_ }, [ Int ] 1 { _A_ 2 _U_ 11 _N_ _S_ "U(P)U(P)" {_A_ 2 _U_ 22 _N_ _N_ _F_ _IF_ARGS_ 0 2 XX 3 \ (u0 :: Int#) (u1 :: Int#) -> case _#_ minusInt# [] [u1, u0] of { _PRIM_ (u2 :: Int#) -> _!_ I# [] [u2] } _N_} _F_ _IF_ARGS_ 0 2 CC 5 \ (u0 :: Int) (u1 :: Int) -> case u1 of { _ALG_ I# (u2 :: Int#) -> case u0 of { _ALG_ I# (u3 :: Int#) -> case _#_ minusInt# [] [u2, u3] of { _PRIM_ (u4 :: Int#) -> _!_ I# [] [u4] }; _NO_DEFLT_ }; _NO_DEFLT_ } _N_ } #-}
+ {-# GHC_PRAGMA _A_ 3 _U_ 122 _N_ _S_ "U(AAASAAAAAA)LL" {_A_ 3 _U_ 122 _N_ _N_ _F_ _IF_ARGS_ 1 3 XXX 3 _/\_ u0 -> \ (u1 :: u0 -> u0 -> u0) (u2 :: u0) (u3 :: u0) -> _APP_ u1 [ u3, u2 ] _N_} _F_ _IF_ARGS_ 1 3 CXX 4 _/\_ u0 -> \ (u1 :: {{Num u0}}) (u2 :: u0) (u3 :: u0) -> case u1 of { _ALG_ _TUP_10 (u4 :: {{Eq u0}}) (u5 :: {{Text u0}}) (u6 :: u0 -> u0 -> u0) (u7 :: u0 -> u0 -> u0) (u8 :: u0 -> u0 -> u0) (u9 :: u0 -> u0) (ua :: u0 -> u0) (ub :: u0 -> u0) (uc :: Integer -> u0) (ud :: Int -> u0) -> _APP_ u7 [ u3, u2 ]; _NO_DEFLT_ } _SPECIALISE_ [ Double ] 1 { _A_ 2 _U_ 11 _N_ _S_ "U(P)U(P)" {_A_ 2 _U_ 22 _N_ _N_ _F_ _IF_ARGS_ 0 2 XX 3 \ (u0 :: Double#) (u1 :: Double#) -> case _#_ minusDouble# [] [u1, u0] of { _PRIM_ (u2 :: Double#) -> _!_ D# [] [u2] } _N_} _F_ _IF_ARGS_ 0 2 CC 5 \ (u0 :: Double) (u1 :: Double) -> case u1 of { _ALG_ D# (u2 :: Double#) -> case u0 of { _ALG_ D# (u3 :: Double#) -> case _#_ minusDouble# [] [u2, u3] of { _PRIM_ (u4 :: Double#) -> _!_ D# [] [u4] }; _NO_DEFLT_ }; _NO_DEFLT_ } _N_ }, [ Int ] 1 { _A_ 2 _U_ 11 _N_ _S_ "U(P)U(P)" {_A_ 2 _U_ 22 _N_ _N_ _F_ _IF_ARGS_ 0 2 XX 3 \ (u0 :: Int#) (u1 :: Int#) -> case _#_ minusInt# [] [u1, u0] of { _PRIM_ (u2 :: Int#) -> _!_ I# [] [u2] } _N_} _F_ _IF_ARGS_ 0 2 CC 5 \ (u0 :: Int) (u1 :: Int) -> case u1 of { _ALG_ I# (u2 :: Int#) -> case u0 of { _ALG_ I# (u3 :: Int#) -> case _#_ minusInt# [] [u2, u3] of { _PRIM_ (u4 :: Int#) -> _!_ I# [] [u4] }; _NO_DEFLT_ }; _NO_DEFLT_ } _N_ }, [ (Complex Double) ] 1 { _A_ 2 _U_ 11 _N_ _S_ "U(LL)U(LL)" {_A_ 4 _U_ 2222 _N_ _N_ _N_ _N_} _N_ _N_ } #-}
toLower :: Char -> Char
{-# GHC_PRAGMA _A_ 1 _U_ 1 _N_ _S_ "U(P)" {_A_ 1 _U_ 2 _N_ _N_ _N_ _N_} _N_ _N_ #-}
toUpper :: Char -> Char
imagPart :: Complex a -> a
{-# GHC_PRAGMA _A_ 1 _U_ 1 _N_ _S_ "U(AS)" {_A_ 1 _U_ 1 _N_ _N_ _F_ _IF_ARGS_ 1 1 X 1 _/\_ u0 -> \ (u1 :: u0) -> u1 _N_} _F_ _IF_ARGS_ 1 1 C 2 _/\_ u0 -> \ (u1 :: Complex u0) -> case u1 of { _ALG_ (:+) (u2 :: u0) (u3 :: u0) -> u3; _NO_DEFLT_ } _N_ #-}
magnitude :: RealFloat a => Complex a -> a
- {-# GHC_PRAGMA _A_ 1 _U_ 12 _N_ _S_ "U(ALAAAAALAS)" {_A_ 3 _U_ 2221 _N_ _N_ _N_ _N_} _N_ _SPECIALISE_ [ Double ] 1 { _A_ 1 _U_ 1 _N_ _S_ "U(LL)" {_A_ 2 _U_ 22 _N_ _N_ _N_ _N_} _N_ _N_ } #-}
+ {-# GHC_PRAGMA _A_ 1 _U_ 12 _N_ _S_ "U(ALAAAAALAS)" {_A_ 3 _U_ 2221 _N_ _N_ _N_ _N_} _N_ _SPECIALISE_ [ Double ] 1 { _A_ 1 _U_ 1 _N_ _S_ "U(U(P)U(P))" {_A_ 2 _U_ 22 _N_ _N_ _N_ _N_} _N_ _N_ } #-}
mkPolar :: RealFloat a => a -> a -> Complex a
{-# GHC_PRAGMA _A_ 3 _U_ 122 _N_ _N_ _N_ _SPECIALISE_ [ Double ] 1 { _A_ 2 _U_ 22 _N_ _N_ _N_ _N_ } #-}
phase :: RealFloat a => Complex a -> a
{-# GHC_PRAGMA _A_ 1 _U_ 22 _N_ _N_ _N_ _SPECIALISE_ [ Double ] 1 { _A_ 1 _U_ 2 _N_ _N_ _N_ _N_ } #-}
realPart :: Complex a -> a
{-# GHC_PRAGMA _A_ 1 _U_ 1 _N_ _S_ "U(SA)" {_A_ 1 _U_ 1 _N_ _N_ _F_ _IF_ARGS_ 1 1 X 1 _/\_ u0 -> \ (u1 :: u0) -> u1 _N_} _F_ _IF_ARGS_ 1 1 C 2 _/\_ u0 -> \ (u1 :: Complex u0) -> case u1 of { _ALG_ (:+) (u2 :: u0) (u3 :: u0) -> u2; _NO_DEFLT_ } _N_ #-}
-_ceiling :: (RealFrac a, Integral b) => a -> b
- {-# GHC_PRAGMA _A_ 2 _U_ 122 _N_ _S_ "U(U(AU(U(AAAASAAA)AAAA)A)LSAAAA)L" {_A_ 4 _U_ 11122 _N_ _N_ _N_ _N_} _N_ _SPECIALISE_ [ Double, Int ] 2 { _A_ 0 _U_ 2 _N_ _N_ _N_ _N_ } #-}
-_floor :: (RealFrac a, Integral b) => a -> b
- {-# GHC_PRAGMA _A_ 2 _U_ 122 _N_ _S_ "U(U(AU(U(ASAAAAAA)AAAA)A)LSAAAA)L" {_A_ 4 _U_ 11122 _N_ _N_ _N_ _N_} _N_ _SPECIALISE_ [ Double, Int ] 2 { _A_ 0 _U_ 2 _N_ _N_ _N_ _N_ } #-}
-_readList :: Text a => [Char] -> [([a], [Char])]
+_readList :: ([Char] -> [(a, [Char])]) -> [Char] -> [([a], [Char])]
{-# GHC_PRAGMA _A_ 1 _U_ 22 _N_ _N_ _N_ _N_ #-}
-_round :: (RealFrac a, Integral b) => a -> b
- {-# GHC_PRAGMA _A_ 2 _U_ 122 _N_ _S_ "U(U(AU(U(ALAAAAAS)AAAA)A)LSAAAA)L" {_A_ 5 _U_ 112122 _N_ _N_ _N_ _N_} _N_ _SPECIALISE_ [ Double, Int ] 2 { _A_ 0 _U_ 2 _N_ _N_ _N_ _N_ }, [ (Ratio Integer), Integer ] 2 { _A_ 1 _U_ 1 _N_ _S_ "U(LL)" {_A_ 2 _U_ 22 _N_ _N_ _N_ _N_} _N_ _N_ } #-}
-_showList :: Text a => [a] -> [Char] -> [Char]
- {-# GHC_PRAGMA _A_ 1 _U_ 212 _N_ _N_ _N_ _N_ #-}
+_showList :: (a -> [Char] -> [Char]) -> [a] -> [Char] -> [Char]
+ {-# GHC_PRAGMA _A_ 2 _U_ 212 _N_ _S_ "LS" _N_ _N_ #-}
_showRational :: Int -> Ratio Integer -> [Char]
{-# GHC_PRAGMA _A_ 2 _U_ 21 _N_ _S_ "LU(U(PPP)L)" {_A_ 5 _U_ 22222 _N_ _N_ _N_ _N_} _N_ _N_ #-}
-_truncate :: (RealFrac a, Integral b) => a -> b
- {-# GHC_PRAGMA _A_ 2 _U_ 122 _N_ _S_ "U(AASAAAA)L" {_A_ 2 _U_ 122 _N_ _N_ _N_ _N_} _N_ _SPECIALISE_ [ Double, Int ] 2 { _A_ 0 _U_ 2 _N_ _N_ _N_ _N_ } #-}
abort :: IOError -> [Response] -> [Request]
{-# GHC_PRAGMA _A_ 2 _U_ 00 _N_ _S_ "A" {_A_ 1 _U_ 0 _N_ _N_ _F_ _IF_ARGS_ 0 1 X 1 \ (u0 :: [Response]) -> _!_ _NIL_ [Request] [] _N_} _F_ _IF_ARGS_ 0 1 X 1 \ (u0 :: IOError) -> _ORIG_ PreludeIO done _N_ #-}
appendBinChan :: [Char] -> Bin -> (IOError -> [Response] -> [Request]) -> ([Response] -> [Request]) -> [Response] -> [Request]
interact :: ([Char] -> [Char]) -> [Response] -> [Request]
{-# GHC_PRAGMA _A_ 1 _U_ 11 _N_ _N_ _N_ _N_ #-}
print :: Text a => a -> [Response] -> [Request]
- {-# GHC_PRAGMA _A_ 1 _U_ 121 _N_ _N_ _N_ _N_ #-}
+ {-# GHC_PRAGMA _A_ 1 _U_ 121 _N_ _N_ _N_ _SPECIALISE_ [ Bool ] 1 { _A_ 1 _U_ 21 _N_ _N_ _N_ _N_ }, [ Char ] 1 { _A_ 1 _U_ 11 _N_ _N_ _N_ _N_ }, [ Double ] 1 { _A_ 1 _U_ 11 _N_ _N_ _N_ _N_ }, [ Int ] 1 { _A_ 1 _U_ 11 _N_ _N_ _N_ _N_ }, [ Integer ] 1 { _A_ 1 _U_ 11 _N_ _N_ _N_ _N_ }, [ [Char] ] 1 { _A_ 1 _U_ 21 _N_ _N_ _N_ _N_ }, [ [Int] ] 1 { _A_ 1 _U_ 21 _N_ _N_ _N_ _N_ }, [ [[Char]] ] 1 { _A_ 1 _U_ 21 _N_ _N_ _N_ _N_ }, [ [[Int]] ] 1 { _A_ 1 _U_ 21 _N_ _N_ _N_ _N_ }, [ _PackedString ] 1 { _A_ 1 _U_ 21 _N_ _N_ _N_ _N_ }, [ () ] 1 { _A_ 1 _U_ 21 _N_ _N_ _N_ _N_ } #-}
prints :: Text a => a -> [Char] -> [Response] -> [Request]
- {-# GHC_PRAGMA _A_ 1 _U_ 1221 _N_ _N_ _N_ _N_ #-}
+ {-# GHC_PRAGMA _A_ 1 _U_ 1221 _N_ _N_ _N_ _SPECIALISE_ [ Bool ] 1 { _A_ 2 _U_ 221 _N_ _N_ _N_ _N_ }, [ Char ] 1 { _A_ 2 _U_ 121 _N_ _N_ _N_ _N_ }, [ Double ] 1 { _A_ 2 _U_ 121 _N_ _N_ _N_ _N_ }, [ Int ] 1 { _A_ 2 _U_ 121 _N_ _N_ _N_ _N_ }, [ Integer ] 1 { _A_ 2 _U_ 121 _N_ _N_ _N_ _N_ }, [ [Char] ] 1 { _A_ 2 _U_ 221 _N_ _N_ _N_ _N_ }, [ [Int] ] 1 { _A_ 2 _U_ 221 _N_ _N_ _N_ _N_ }, [ [[Char]] ] 1 { _A_ 2 _U_ 121 _N_ _N_ _N_ _N_ }, [ [[Int]] ] 1 { _A_ 2 _U_ 121 _N_ _N_ _N_ _N_ }, [ _PackedString ] 1 { _A_ 2 _U_ 221 _N_ _N_ _N_ _N_ }, [ () ] 1 { _A_ 2 _U_ 121 _N_ _N_ _N_ _N_ } #-}
readBinChan :: [Char] -> (IOError -> [Response] -> [Request]) -> (Bin -> [Response] -> [Request]) -> [Response] -> [Request]
{-# GHC_PRAGMA _A_ 4 _U_ 2111 _N_ _N_ _N_ _N_ #-}
readBinFile :: [Char] -> (IOError -> [Response] -> [Request]) -> (Bin -> [Response] -> [Request]) -> [Response] -> [Request]
(++) :: [a] -> [a] -> [a]
{-# GHC_PRAGMA _A_ 2 _U_ 12 _N_ _S_ "SL" _N_ _N_ #-}
(\\) :: Eq a => [a] -> [a] -> [a]
- {-# GHC_PRAGMA _A_ 3 _U_ 122 _N_ _S_ "LLS" _N_ _N_ #-}
+ {-# GHC_PRAGMA _A_ 3 _U_ 122 _N_ _S_ "LLS" _N_ _SPECIALISE_ [ Int ] 1 { _A_ 2 _U_ 22 _N_ _S_ "LS" _N_ _N_ }, [ [Char] ] 1 { _A_ 2 _U_ 22 _N_ _S_ "LS" _N_ _N_ } #-}
all :: (a -> Bool) -> [a] -> Bool
{-# GHC_PRAGMA _A_ 2 _U_ 21 _N_ _S_ "LS" _F_ _ALWAYS_ _/\_ u0 -> \ (u1 :: u0 -> Bool) (u2 :: [u0]) -> let {(u3 :: Bool) = _!_ True [] []} in let {(u6 :: u0 -> Bool -> Bool) = \ (u4 :: u0) (u5 :: Bool) -> case _APP_ u1 [ u4 ] of { _ALG_ True -> u5; False -> _!_ False [] []; _NO_DEFLT_ }} in _APP_ _TYAPP_ _TYAPP_ foldr { u0 } { Bool } [ u6, u3, u2 ] _N_ #-}
and :: [Bool] -> Bool
dropWhile :: (a -> Bool) -> [a] -> [a]
{-# GHC_PRAGMA _A_ 2 _U_ 21 _N_ _S_ "LS" _N_ _N_ #-}
elem :: Eq a => a -> [a] -> Bool
- {-# GHC_PRAGMA _A_ 3 _U_ 121 _N_ _S_ "LLS" _F_ _ALWAYS_ _/\_ u0 -> \ (u1 :: {{Eq u0}}) (u2 :: u0) (u3 :: [u0]) -> let {(u6 :: u0 -> u0 -> Bool) = case u1 of { _ALG_ _TUP_2 (u4 :: u0 -> u0 -> Bool) (u5 :: u0 -> u0 -> Bool) -> u4; _NO_DEFLT_ }} in let {(u8 :: u0 -> Bool) = \ (u7 :: u0) -> _APP_ u6 [ u2, u7 ]} in _APP_ _TYAPP_ _ORIG_ PreludeList any { u0 } [ u8, u3 ] _SPECIALISE_ [ Char ] 1 { _A_ 2 _U_ 21 _N_ _S_ "LS" _F_ _ALWAYS_ \ (u0 :: Char) (u1 :: [Char]) -> let {(u5 :: Char -> Bool) = \ (u2 :: Char) -> case u0 of { _ALG_ C# (u3 :: Char#) -> case u2 of { _ALG_ C# (u4 :: Char#) -> _#_ eqChar# [] [u3, u4]; _NO_DEFLT_ }; _NO_DEFLT_ }} in _APP_ _TYAPP_ _ORIG_ PreludeList any { Char } [ u5, u1 ] _N_ }, [ Int ] 1 { _A_ 2 _U_ 21 _N_ _S_ "LS" _F_ _ALWAYS_ \ (u0 :: Int) (u1 :: [Int]) -> let {(u5 :: Int -> Bool) = \ (u2 :: Int) -> case u0 of { _ALG_ I# (u3 :: Int#) -> case u2 of { _ALG_ I# (u4 :: Int#) -> _#_ eqInt# [] [u3, u4]; _NO_DEFLT_ }; _NO_DEFLT_ }} in _APP_ _TYAPP_ _ORIG_ PreludeList any { Int } [ u5, u1 ] _N_ }, [ [Char] ] 1 { _A_ 2 _U_ 21 _N_ _S_ "LS" _F_ _ALWAYS_ \ (u0 :: [Char]) (u1 :: [[Char]]) -> let {(u3 :: [Char] -> Bool) = \ (u2 :: [Char]) -> _APP_ _CONSTM_ Eq (==) ([Char]) [ u0, u2 ]} in _APP_ _TYAPP_ _ORIG_ PreludeList any { [Char] } [ u3, u1 ] _N_ } #-}
+ {-# GHC_PRAGMA _A_ 3 _U_ 121 _N_ _S_ "LLS" _F_ _ALWAYS_ _/\_ u0 -> \ (u1 :: {{Eq u0}}) (u2 :: u0) (u3 :: [u0]) -> let {(u6 :: u0 -> u0 -> Bool) = case u1 of { _ALG_ _TUP_2 (u4 :: u0 -> u0 -> Bool) (u5 :: u0 -> u0 -> Bool) -> u4; _NO_DEFLT_ }} in let {(u8 :: u0 -> Bool) = \ (u7 :: u0) -> _APP_ u6 [ u2, u7 ]} in _APP_ _TYAPP_ _ORIG_ PreludeList any { u0 } [ u8, u3 ] _SPECIALISE_ [ Char ] 1 { _A_ 2 _U_ 21 _N_ _S_ "LS" _F_ _ALWAYS_ \ (u0 :: Char) (u1 :: [Char]) -> let {(u5 :: Char -> Bool) = \ (u2 :: Char) -> case u0 of { _ALG_ C# (u3 :: Char#) -> case u2 of { _ALG_ C# (u4 :: Char#) -> _#_ eqChar# [] [u3, u4]; _NO_DEFLT_ }; _NO_DEFLT_ }} in _APP_ _TYAPP_ _ORIG_ PreludeList any { Char } [ u5, u1 ] _N_ }, [ Int ] 1 { _A_ 2 _U_ 21 _N_ _S_ "LS" _F_ _ALWAYS_ \ (u0 :: Int) (u1 :: [Int]) -> let {(u5 :: Int -> Bool) = \ (u2 :: Int) -> case u0 of { _ALG_ I# (u3 :: Int#) -> case u2 of { _ALG_ I# (u4 :: Int#) -> _#_ eqInt# [] [u3, u4]; _NO_DEFLT_ }; _NO_DEFLT_ }} in _APP_ _TYAPP_ _ORIG_ PreludeList any { Int } [ u5, u1 ] _N_ }, [ Integer ] 1 { _A_ 2 _U_ 21 _N_ _S_ "LS" _F_ _ALWAYS_ \ (u0 :: Integer) (u1 :: [Integer]) -> let {(ua :: Integer -> Bool) = \ (u2 :: Integer) -> case u0 of { _ALG_ J# (u3 :: Int#) (u4 :: Int#) (u5 :: ByteArray#) -> case u2 of { _ALG_ J# (u6 :: Int#) (u7 :: Int#) (u8 :: ByteArray#) -> case _#_ cmpInteger# [] [u3, u4, u5, u6, u7, u8] of { _PRIM_ 0# -> _!_ True [] []; (u9 :: Int#) -> _!_ False [] [] }; _NO_DEFLT_ }; _NO_DEFLT_ }} in _APP_ _TYAPP_ _ORIG_ PreludeList any { Integer } [ ua, u1 ] _N_ }, [ [Char] ] 1 { _A_ 2 _U_ 21 _N_ _S_ "LS" _F_ _ALWAYS_ \ (u0 :: [Char]) (u1 :: [[Char]]) -> let {(u3 :: [Char] -> Bool) = \ (u2 :: [Char]) -> _APP_ _CONSTM_ Eq (==) ([Char]) [ u0, u2 ]} in _APP_ _TYAPP_ _ORIG_ PreludeList any { [Char] } [ u3, u1 ] _N_ }, [ [Int] ] 1 { _A_ 2 _U_ 21 _N_ _S_ "LS" _F_ _ALWAYS_ \ (u0 :: [Int]) (u1 :: [[Int]]) -> let {(u3 :: [Int] -> Bool) = \ (u2 :: [Int]) -> _APP_ _CONSTM_ Eq (==) ([Int]) [ u0, u2 ]} in _APP_ _TYAPP_ _ORIG_ PreludeList any { [Int] } [ u3, u1 ] _N_ }, [ (Int, Int) ] 1 { _A_ 2 _U_ 21 _N_ _S_ "LS" _F_ _ALWAYS_ \ (u0 :: (Int, Int)) (u1 :: [(Int, Int)]) -> let {(ub :: (Int, Int) -> Bool) = \ (u2 :: (Int, Int)) -> case u0 of { _ALG_ _TUP_2 (u3 :: Int) (u4 :: Int) -> case u3 of { _ALG_ I# (u5 :: Int#) -> case u2 of { _ALG_ _TUP_2 (u6 :: Int) (u7 :: Int) -> case u6 of { _ALG_ I# (u8 :: Int#) -> case _#_ eqInt# [] [u5, u8] of { _ALG_ True -> case u4 of { _ALG_ I# (u9 :: Int#) -> case u7 of { _ALG_ I# (ua :: Int#) -> _#_ eqInt# [] [u9, ua]; _NO_DEFLT_ }; _NO_DEFLT_ }; False -> _!_ False [] []; _NO_DEFLT_ }; _NO_DEFLT_ }; _NO_DEFLT_ }; _NO_DEFLT_ }; _NO_DEFLT_ }} in _APP_ _TYAPP_ _ORIG_ PreludeList any { (Int, Int) } [ ub, u1 ] _N_ } #-}
filter :: (a -> Bool) -> [a] -> [a]
{-# GHC_PRAGMA _A_ 2 _U_ 21 _N_ _S_ "LS" _F_ _ALWAYS_ _/\_ u0 -> \ (u1 :: u0 -> Bool) (u2 :: [u0]) -> let {(u9 :: _forall_ a$z1 =>(u0 -> a$z1 -> a$z1) -> a$z1 -> a$z1) = _/\_ u3 -> \ (u4 :: u0 -> u3 -> u3) (u5 :: u3) -> let {(u8 :: u0 -> u3 -> u3) = \ (u6 :: u0) (u7 :: u3) -> case _APP_ u1 [ u6 ] of { _ALG_ True -> _APP_ u4 [ u6, u7 ]; False -> u7; _NO_DEFLT_ }} in _APP_ _TYAPP_ _TYAPP_ foldr { u0 } { u3 } [ u8, u5, u2 ]} in _APP_ _TYAPP_ _build { u0 } [ u9 ] _N_ #-}
foldl1 :: (a -> a -> a) -> [a] -> a
foldr1 :: (a -> a -> a) -> [a] -> a
{-# GHC_PRAGMA _A_ 2 _U_ 21 _N_ _S_ "LS" _N_ _N_ #-}
genericLength :: Num b => [a] -> b
- {-# GHC_PRAGMA _A_ 1 _U_ 21 _N_ _N_ _N_ _N_ #-}
+ {-# GHC_PRAGMA _A_ 1 _U_ 21 _N_ _N_ _N_ _SPECIALISE_ [ _N_, Int ] 1 { _A_ 1 _U_ 1 _N_ _S_ "S" _N_ _N_ }, [ _N_, Integer ] 1 { _A_ 1 _U_ 1 _N_ _S_ "S" _N_ _N_ } #-}
head :: [a] -> a
{-# GHC_PRAGMA _A_ 1 _U_ 1 _N_ _S_ "S" _F_ _ALWAYS_ _/\_ u0 -> \ (u1 :: [u0]) -> let {(u2 :: u0) = _APP_ _TYAPP_ error { u0 } [ _NOREP_S_ "head{PreludeList}: head []\n" ]} in let {(u5 :: u0 -> u0 -> u0) = \ (u3 :: u0) (u4 :: u0) -> u3} in _APP_ _TYAPP_ _TYAPP_ foldr { u0 } { u0 } [ u5, u2, u1 ] _N_ #-}
init :: [a] -> [a]
map :: (a -> b) -> [a] -> [b]
{-# GHC_PRAGMA _A_ 2 _U_ 21 _N_ _S_ "LS" _F_ _ALWAYS_ _/\_ u0 u1 -> \ (u2 :: u0 -> u1) (u3 :: [u0]) -> let {(ua :: _forall_ a$z1 =>(u1 -> a$z1 -> a$z1) -> a$z1 -> a$z1) = _/\_ u4 -> \ (u5 :: u1 -> u4 -> u4) (u6 :: u4) -> let {(u9 :: u0 -> u4 -> u4) = \ (u7 :: u0) -> let {(u8 :: u1) = _APP_ u2 [ u7 ]} in _APP_ u5 [ u8 ]} in _APP_ _TYAPP_ _TYAPP_ foldr { u0 } { u4 } [ u9, u6, u3 ]} in _APP_ _TYAPP_ _build { u1 } [ ua ] _N_ #-}
maximum :: Ord a => [a] -> a
- {-# GHC_PRAGMA _A_ 1 _U_ 11 _N_ _N_ _N_ _N_ #-}
+ {-# GHC_PRAGMA _A_ 1 _U_ 11 _N_ _N_ _N_ _SPECIALISE_ [ Double ] 1 { _A_ 1 _U_ 1 _N_ _S_ "S" _N_ _N_ }, [ Int ] 1 { _A_ 1 _U_ 1 _N_ _S_ "S" _N_ _N_ }, [ Integer ] 1 { _A_ 1 _U_ 1 _N_ _S_ "S" _N_ _N_ } #-}
minimum :: Ord a => [a] -> a
- {-# GHC_PRAGMA _A_ 1 _U_ 11 _N_ _N_ _N_ _N_ #-}
+ {-# GHC_PRAGMA _A_ 1 _U_ 11 _N_ _N_ _N_ _SPECIALISE_ [ Double ] 1 { _A_ 1 _U_ 1 _N_ _S_ "S" _N_ _N_ }, [ Int ] 1 { _A_ 1 _U_ 1 _N_ _S_ "S" _N_ _N_ }, [ Integer ] 1 { _A_ 1 _U_ 1 _N_ _S_ "S" _N_ _N_ } #-}
notElem :: Eq a => a -> [a] -> Bool
- {-# GHC_PRAGMA _A_ 3 _U_ 121 _N_ _S_ "LLS" _F_ _ALWAYS_ _/\_ u0 -> \ (u1 :: {{Eq u0}}) (u2 :: u0) (u3 :: [u0]) -> let {(u6 :: u0 -> u0 -> Bool) = case u1 of { _ALG_ _TUP_2 (u4 :: u0 -> u0 -> Bool) (u5 :: u0 -> u0 -> Bool) -> u5; _NO_DEFLT_ }} in let {(u8 :: u0 -> Bool) = \ (u7 :: u0) -> _APP_ u6 [ u2, u7 ]} in _APP_ _TYAPP_ _ORIG_ PreludeList all { u0 } [ u8, u3 ] _SPECIALISE_ [ Char ] 1 { _A_ 2 _U_ 21 _N_ _S_ "LS" _F_ _ALWAYS_ \ (u0 :: Char) (u1 :: [Char]) -> let {(u5 :: Char -> Bool) = \ (u2 :: Char) -> case u0 of { _ALG_ C# (u3 :: Char#) -> case u2 of { _ALG_ C# (u4 :: Char#) -> _#_ neChar# [] [u3, u4]; _NO_DEFLT_ }; _NO_DEFLT_ }} in _APP_ _TYAPP_ _ORIG_ PreludeList all { Char } [ u5, u1 ] _N_ }, [ Int ] 1 { _A_ 2 _U_ 21 _N_ _S_ "LS" _F_ _ALWAYS_ \ (u0 :: Int) (u1 :: [Int]) -> let {(u5 :: Int -> Bool) = \ (u2 :: Int) -> case u0 of { _ALG_ I# (u3 :: Int#) -> case u2 of { _ALG_ I# (u4 :: Int#) -> _#_ neInt# [] [u3, u4]; _NO_DEFLT_ }; _NO_DEFLT_ }} in _APP_ _TYAPP_ _ORIG_ PreludeList all { Int } [ u5, u1 ] _N_ }, [ [Char] ] 1 { _A_ 2 _U_ 21 _N_ _S_ "LS" _F_ _ALWAYS_ \ (u0 :: [Char]) (u1 :: [[Char]]) -> let {(u3 :: [Char] -> Bool) = \ (u2 :: [Char]) -> _APP_ _CONSTM_ Eq (/=) ([Char]) [ u0, u2 ]} in _APP_ _TYAPP_ _ORIG_ PreludeList all { [Char] } [ u3, u1 ] _N_ } #-}
+ {-# GHC_PRAGMA _A_ 3 _U_ 121 _N_ _S_ "LLS" _F_ _ALWAYS_ _/\_ u0 -> \ (u1 :: {{Eq u0}}) (u2 :: u0) (u3 :: [u0]) -> let {(u6 :: u0 -> u0 -> Bool) = case u1 of { _ALG_ _TUP_2 (u4 :: u0 -> u0 -> Bool) (u5 :: u0 -> u0 -> Bool) -> u5; _NO_DEFLT_ }} in let {(u8 :: u0 -> Bool) = \ (u7 :: u0) -> _APP_ u6 [ u2, u7 ]} in _APP_ _TYAPP_ _ORIG_ PreludeList all { u0 } [ u8, u3 ] _SPECIALISE_ [ Char ] 1 { _A_ 2 _U_ 21 _N_ _S_ "LS" _F_ _ALWAYS_ \ (u0 :: Char) (u1 :: [Char]) -> let {(u5 :: Char -> Bool) = \ (u2 :: Char) -> case u0 of { _ALG_ C# (u3 :: Char#) -> case u2 of { _ALG_ C# (u4 :: Char#) -> _#_ neChar# [] [u3, u4]; _NO_DEFLT_ }; _NO_DEFLT_ }} in _APP_ _TYAPP_ _ORIG_ PreludeList all { Char } [ u5, u1 ] _N_ }, [ Int ] 1 { _A_ 2 _U_ 21 _N_ _S_ "LS" _F_ _ALWAYS_ \ (u0 :: Int) (u1 :: [Int]) -> let {(u5 :: Int -> Bool) = \ (u2 :: Int) -> case u0 of { _ALG_ I# (u3 :: Int#) -> case u2 of { _ALG_ I# (u4 :: Int#) -> _#_ neInt# [] [u3, u4]; _NO_DEFLT_ }; _NO_DEFLT_ }} in _APP_ _TYAPP_ _ORIG_ PreludeList all { Int } [ u5, u1 ] _N_ }, [ Integer ] 1 { _A_ 2 _U_ 21 _N_ _S_ "LS" _F_ _ALWAYS_ \ (u0 :: Integer) (u1 :: [Integer]) -> let {(ua :: Integer -> Bool) = \ (u2 :: Integer) -> case u0 of { _ALG_ J# (u3 :: Int#) (u4 :: Int#) (u5 :: ByteArray#) -> case u2 of { _ALG_ J# (u6 :: Int#) (u7 :: Int#) (u8 :: ByteArray#) -> case _#_ cmpInteger# [] [u3, u4, u5, u6, u7, u8] of { _PRIM_ 0# -> _!_ False [] []; (u9 :: Int#) -> _!_ True [] [] }; _NO_DEFLT_ }; _NO_DEFLT_ }} in _APP_ _TYAPP_ _ORIG_ PreludeList all { Integer } [ ua, u1 ] _N_ }, [ [Char] ] 1 { _A_ 2 _U_ 21 _N_ _S_ "LS" _F_ _ALWAYS_ \ (u0 :: [Char]) (u1 :: [[Char]]) -> let {(u3 :: [Char] -> Bool) = \ (u2 :: [Char]) -> _APP_ _CONSTM_ Eq (/=) ([Char]) [ u0, u2 ]} in _APP_ _TYAPP_ _ORIG_ PreludeList all { [Char] } [ u3, u1 ] _N_ }, [ (Int, Int) ] 1 { _A_ 2 _U_ 21 _N_ _S_ "LS" _F_ _ALWAYS_ \ (u0 :: (Int, Int)) (u1 :: [(Int, Int)]) -> let {(ub :: (Int, Int) -> Bool) = \ (u2 :: (Int, Int)) -> case u0 of { _ALG_ _TUP_2 (u3 :: Int) (u4 :: Int) -> case u3 of { _ALG_ I# (u5 :: Int#) -> case u2 of { _ALG_ _TUP_2 (u6 :: Int) (u7 :: Int) -> case u6 of { _ALG_ I# (u8 :: Int#) -> case _#_ neInt# [] [u5, u8] of { _ALG_ True -> _!_ True [] []; False -> case u4 of { _ALG_ I# (u9 :: Int#) -> case u7 of { _ALG_ I# (ua :: Int#) -> _#_ neInt# [] [u9, ua]; _NO_DEFLT_ }; _NO_DEFLT_ }; _NO_DEFLT_ }; _NO_DEFLT_ }; _NO_DEFLT_ }; _NO_DEFLT_ }; _NO_DEFLT_ }} in _APP_ _TYAPP_ _ORIG_ PreludeList all { (Int, Int) } [ ub, u1 ] _N_ } #-}
nub :: Eq a => [a] -> [a]
- {-# GHC_PRAGMA _A_ 2 _U_ 11 _N_ _S_ "LS" _N_ _N_ #-}
+ {-# GHC_PRAGMA _A_ 2 _U_ 11 _N_ _S_ "LS" _N_ _SPECIALISE_ [ Int ] 1 { _A_ 1 _U_ 1 _N_ _S_ "S" _N_ _N_ }, [ [Char] ] 1 { _A_ 1 _U_ 1 _N_ _S_ "S" _N_ _N_ }, [ [Int] ] 1 { _A_ 1 _U_ 1 _N_ _S_ "S" _N_ _N_ } #-}
null :: [a] -> Bool
{-# GHC_PRAGMA _A_ 1 _U_ 1 _N_ _S_ "S" _F_ _ALWAYS_ _/\_ u0 -> \ (u1 :: [u0]) -> let {(u2 :: Bool) = _!_ True [] []} in let {(u5 :: u0 -> Bool -> Bool) = \ (u3 :: u0) (u4 :: Bool) -> _!_ False [] []} in _APP_ _TYAPP_ _TYAPP_ foldr { u0 } { Bool } [ u5, u2, u1 ] _N_ #-}
or :: [Bool] -> Bool
partition :: (a -> Bool) -> [a] -> ([a], [a])
{-# GHC_PRAGMA _A_ 2 _U_ 21 _N_ _S_ "LS" _F_ _ALWAYS_ _/\_ u0 -> \ (u1 :: u0 -> Bool) (u2 :: [u0]) -> let {(u9 :: u0 -> ([u0], [u0]) -> ([u0], [u0])) = \ (u3 :: u0) (u4 :: ([u0], [u0])) -> case u4 of { _ALG_ _TUP_2 (u5 :: [u0]) (u6 :: [u0]) -> case _APP_ u1 [ u3 ] of { _ALG_ True -> let {(u7 :: [u0]) = _!_ (:) [u0] [u3, u5]} in _!_ _TUP_2 [[u0], [u0]] [u7, u6]; False -> let {(u8 :: [u0]) = _!_ (:) [u0] [u3, u6]} in _!_ _TUP_2 [[u0], [u0]] [u5, u8]; _NO_DEFLT_ }; _NO_DEFLT_ }} in let {(ua :: [u0]) = _!_ _NIL_ [u0] []} in let {(ub :: ([u0], [u0])) = _!_ _TUP_2 [[u0], [u0]] [ua, ua]} in _APP_ _TYAPP_ _TYAPP_ foldr { u0 } { ([u0], [u0]) } [ u9, ub, u2 ] _N_ #-}
product :: Num a => [a] -> a
- {-# GHC_PRAGMA _A_ 1 _U_ 22 _N_ _N_ _F_ _ALWAYS_ _/\_ u0 -> \ (u1 :: {{Num u0}}) -> let {(uc :: u0 -> u0 -> u0) = case u1 of { _ALG_ _TUP_10 (u2 :: {{Eq u0}}) (u3 :: {{Text u0}}) (u4 :: u0 -> u0 -> u0) (u5 :: u0 -> u0 -> u0) (u6 :: u0 -> u0 -> u0) (u7 :: u0 -> u0) (u8 :: u0 -> u0) (u9 :: u0 -> u0) (ua :: Integer -> u0) (ub :: Int -> u0) -> u6; _NO_DEFLT_ }} in let {(uo :: u0) = let {(ud :: Int) = _!_ I# [] [1#]} in case u1 of { _ALG_ _TUP_10 (ue :: {{Eq u0}}) (uf :: {{Text u0}}) (ug :: u0 -> u0 -> u0) (uh :: u0 -> u0 -> u0) (ui :: u0 -> u0 -> u0) (uj :: u0 -> u0) (uk :: u0 -> u0) (ul :: u0 -> u0) (um :: Integer -> u0) (un :: Int -> u0) -> _APP_ un [ ud ]; _NO_DEFLT_ }} in \ (up :: [u0]) -> _APP_ _TYAPP_ _TYAPP_ foldl { u0 } { u0 } [ uc, uo, up ] _SPECIALISE_ [ Double ] 1 { _A_ 1 _U_ 1 _N_ _S_ "S" _F_ _ALWAYS_ \ (u0 :: [Double]) -> let {(u1 :: Double) = _!_ D# [] [1.0000000000000000##]} in _APP_ _TYAPP_ _TYAPP_ foldl { Double } { Double } [ _CONSTM_ Num (*) (Double), u1, u0 ] _N_ }, [ Int ] 1 { _A_ 1 _U_ 1 _N_ _S_ "S" _F_ _ALWAYS_ \ (u0 :: [Int]) -> let {(u1 :: Int) = _!_ I# [] [1#]} in _APP_ _TYAPP_ _TYAPP_ foldl { Int } { Int } [ _CONSTM_ Num (*) (Int), u1, u0 ] _N_ }, [ Integer ] 1 { _A_ 1 _U_ 1 _N_ _S_ "S" _F_ _ALWAYS_ \ (u0 :: [Integer]) -> let {(u1 :: Integer) = _#_ int2Integer# [] [1#]} in _APP_ _TYAPP_ _TYAPP_ foldl { Integer } { Integer } [ _CONSTM_ Num (*) (Integer), u1, u0 ] _N_ } #-}
+ {-# GHC_PRAGMA _A_ 1 _U_ 22 _N_ _N_ _F_ _ALWAYS_ _/\_ u0 -> \ (u1 :: {{Num u0}}) -> let {(uc :: u0 -> u0 -> u0) = case u1 of { _ALG_ _TUP_10 (u2 :: {{Eq u0}}) (u3 :: {{Text u0}}) (u4 :: u0 -> u0 -> u0) (u5 :: u0 -> u0 -> u0) (u6 :: u0 -> u0 -> u0) (u7 :: u0 -> u0) (u8 :: u0 -> u0) (u9 :: u0 -> u0) (ua :: Integer -> u0) (ub :: Int -> u0) -> u6; _NO_DEFLT_ }} in let {(uo :: u0) = let {(ud :: Int) = _!_ I# [] [1#]} in case u1 of { _ALG_ _TUP_10 (ue :: {{Eq u0}}) (uf :: {{Text u0}}) (ug :: u0 -> u0 -> u0) (uh :: u0 -> u0 -> u0) (ui :: u0 -> u0 -> u0) (uj :: u0 -> u0) (uk :: u0 -> u0) (ul :: u0 -> u0) (um :: Integer -> u0) (un :: Int -> u0) -> _APP_ un [ ud ]; _NO_DEFLT_ }} in \ (up :: [u0]) -> _APP_ _TYAPP_ _TYAPP_ foldl { u0 } { u0 } [ uc, uo, up ] _SPECIALISE_ [ Double ] 1 { _A_ 1 _U_ 1 _N_ _S_ "S" _F_ _ALWAYS_ \ (u0 :: [Double]) -> let {(u1 :: Double) = _!_ D# [] [1.0000000000000000##]} in _APP_ _TYAPP_ _TYAPP_ foldl { Double } { Double } [ _CONSTM_ Num (*) (Double), u1, u0 ] _N_ }, [ Int ] 1 { _A_ 1 _U_ 1 _N_ _S_ "S" _F_ _ALWAYS_ \ (u0 :: [Int]) -> let {(u1 :: Int) = _!_ I# [] [1#]} in _APP_ _TYAPP_ _TYAPP_ foldl { Int } { Int } [ _CONSTM_ Num (*) (Int), u1, u0 ] _N_ }, [ Integer ] 1 { _A_ 1 _U_ 1 _N_ _S_ "S" _F_ _ALWAYS_ \ (u0 :: [Integer]) -> let {(u1 :: Integer) = _#_ int2Integer# [] [1#]} in _APP_ _TYAPP_ _TYAPP_ foldl { Integer } { Integer } [ _CONSTM_ Num (*) (Integer), u1, u0 ] _N_ }, [ (Complex Double) ] 1 { _A_ 1 _U_ 1 _N_ _S_ "S" _F_ _ALWAYS_ let {(u6 :: Complex Double -> Complex Double -> Complex Double) = \ (u0 :: Complex Double) (u1 :: Complex Double) -> case u0 of { _ALG_ (:+) (u2 :: Double) (u3 :: Double) -> case u1 of { _ALG_ (:+) (u4 :: Double) (u5 :: Double) -> _APP_ _WRKR_ _CONSTM_ Num (*) (Complex Double) [ u2, u3, u4, u5 ]; _NO_DEFLT_ }; _NO_DEFLT_ }} in let {(u8 :: Complex Double) = let {(u7 :: Int) = _!_ I# [] [1#]} in _APP_ _CONSTM_ Num fromInt (Complex Double) [ u7 ]} in \ (u9 :: [Complex Double]) -> _APP_ _TYAPP_ _TYAPP_ foldl { (Complex Double) } { (Complex Double) } [ u6, u8, u9 ] _N_ } #-}
products :: Num a => [a] -> [a]
- {-# GHC_PRAGMA _A_ 1 _U_ 21 _N_ _N_ _N_ _N_ #-}
+ {-# GHC_PRAGMA _A_ 1 _U_ 21 _N_ _N_ _N_ _SPECIALISE_ [ Double ] 1 { _A_ 1 _U_ 1 _N_ _N_ _N_ _N_ }, [ Int ] 1 { _A_ 1 _U_ 1 _N_ _N_ _N_ _N_ }, [ Integer ] 1 { _A_ 1 _U_ 1 _N_ _N_ _F_ _IF_ARGS_ 0 1 X 4 \ (u0 :: [Integer]) -> _APP_ _TYAPP_ _TYAPP_ _ORIG_ PreludeList scanl { Integer } { Integer } [ _CONSTM_ Num (*) (Integer), _SPEC_ _ORIG_ PreludeCore __i1 [ (Integer) ], u0 ] _N_ }, [ (Complex Double) ] 1 { _A_ 1 _U_ 1 _N_ _N_ _N_ _N_ } #-}
repeat :: a -> [a]
{-# GHC_PRAGMA _A_ 1 _U_ 2 _N_ _N_ _F_ _ALWAYS_ _/\_ u0 -> \ (u1 :: u0) -> let {(u6 :: _forall_ a$z1 =>(u0 -> a$z1 -> a$z1) -> a$z1 -> a$z1) = _/\_ u2 -> \ (u3 :: u0 -> u2 -> u2) (u4 :: u2) -> _LETREC_ {(u5 :: u2) = _APP_ u3 [ u1, u5 ]} in u5} in _APP_ _TYAPP_ _build { u0 } [ u6 ] _N_ #-}
reverse :: [a] -> [a]
sum :: Num a => [a] -> a
{-# GHC_PRAGMA _A_ 1 _U_ 22 _N_ _N_ _F_ _ALWAYS_ _/\_ u0 -> \ (u1 :: {{Num u0}}) -> let {(uc :: u0 -> u0 -> u0) = case u1 of { _ALG_ _TUP_10 (u2 :: {{Eq u0}}) (u3 :: {{Text u0}}) (u4 :: u0 -> u0 -> u0) (u5 :: u0 -> u0 -> u0) (u6 :: u0 -> u0 -> u0) (u7 :: u0 -> u0) (u8 :: u0 -> u0) (u9 :: u0 -> u0) (ua :: Integer -> u0) (ub :: Int -> u0) -> u4; _NO_DEFLT_ }} in let {(uo :: u0) = let {(ud :: Int) = _!_ I# [] [0#]} in case u1 of { _ALG_ _TUP_10 (ue :: {{Eq u0}}) (uf :: {{Text u0}}) (ug :: u0 -> u0 -> u0) (uh :: u0 -> u0 -> u0) (ui :: u0 -> u0 -> u0) (uj :: u0 -> u0) (uk :: u0 -> u0) (ul :: u0 -> u0) (um :: Integer -> u0) (un :: Int -> u0) -> _APP_ un [ ud ]; _NO_DEFLT_ }} in \ (up :: [u0]) -> _APP_ _TYAPP_ _TYAPP_ foldl { u0 } { u0 } [ uc, uo, up ] _SPECIALISE_ [ Double ] 1 { _A_ 1 _U_ 1 _N_ _S_ "S" _F_ _ALWAYS_ \ (u0 :: [Double]) -> let {(u1 :: Double) = _!_ D# [] [0.0000000000000000##]} in _APP_ _TYAPP_ _TYAPP_ foldl { Double } { Double } [ _CONSTM_ Num (+) (Double), u1, u0 ] _N_ }, [ Int ] 1 { _A_ 1 _U_ 1 _N_ _S_ "S" _F_ _ALWAYS_ \ (u0 :: [Int]) -> let {(u1 :: Int) = _!_ I# [] [0#]} in _APP_ _TYAPP_ _TYAPP_ foldl { Int } { Int } [ _CONSTM_ Num (+) (Int), u1, u0 ] _N_ }, [ Integer ] 1 { _A_ 1 _U_ 1 _N_ _S_ "S" _F_ _ALWAYS_ \ (u0 :: [Integer]) -> let {(u1 :: Integer) = _#_ int2Integer# [] [0#]} in _APP_ _TYAPP_ _TYAPP_ foldl { Integer } { Integer } [ _CONSTM_ Num (+) (Integer), u1, u0 ] _N_ }, [ (Complex Double) ] 1 { _A_ 1 _U_ 1 _N_ _S_ "S" _F_ _ALWAYS_ let {(u6 :: Complex Double -> Complex Double -> Complex Double) = \ (u0 :: Complex Double) (u1 :: Complex Double) -> case u0 of { _ALG_ (:+) (u2 :: Double) (u3 :: Double) -> case u1 of { _ALG_ (:+) (u4 :: Double) (u5 :: Double) -> _APP_ _WRKR_ _CONSTM_ Num (+) (Complex Double) [ u2, u3, u4, u5 ]; _NO_DEFLT_ }; _NO_DEFLT_ }} in let {(u8 :: Complex Double) = let {(u7 :: Int) = _!_ I# [] [0#]} in _APP_ _CONSTM_ Num fromInt (Complex Double) [ u7 ]} in \ (u9 :: [Complex Double]) -> _APP_ _TYAPP_ _TYAPP_ foldl { (Complex Double) } { (Complex Double) } [ u6, u8, u9 ] _N_ } #-}
sums :: Num a => [a] -> [a]
- {-# GHC_PRAGMA _A_ 1 _U_ 21 _N_ _N_ _N_ _N_ #-}
+ {-# GHC_PRAGMA _A_ 1 _U_ 21 _N_ _N_ _N_ _SPECIALISE_ [ Double ] 1 { _A_ 1 _U_ 1 _N_ _N_ _N_ _N_ }, [ Int ] 1 { _A_ 1 _U_ 1 _N_ _N_ _N_ _N_ }, [ Integer ] 1 { _A_ 1 _U_ 1 _N_ _N_ _F_ _IF_ARGS_ 0 1 X 4 \ (u0 :: [Integer]) -> _APP_ _TYAPP_ _TYAPP_ _ORIG_ PreludeList scanl { Integer } { Integer } [ _CONSTM_ Num (+) (Integer), _SPEC_ _ORIG_ PreludeCore __i0 [ (Integer) ], u0 ] _N_ }, [ (Complex Double) ] 1 { _A_ 1 _U_ 1 _N_ _N_ _N_ _N_ } #-}
tail :: [a] -> [a]
{-# GHC_PRAGMA _A_ 1 _U_ 1 _N_ _S_ "S" _F_ _IF_ARGS_ 1 1 C 5 _/\_ u0 -> \ (u1 :: [u0]) -> case u1 of { _ALG_ (:) (u2 :: u0) (u3 :: [u0]) -> u3; _NIL_ -> _APP_ _TYAPP_ error { [u0] } [ _NOREP_S_ "tail{PreludeList}: tail []\n" ]; _NO_DEFLT_ } _N_ #-}
take :: Integral a => a -> [b] -> [b]
- {-# GHC_PRAGMA _A_ 3 _U_ 121 _N_ _S_ "U(AAAAAAAAAAAS)LL" {_A_ 3 _U_ 121 _N_ _N_ _N_ _N_} _F_ _IF_ARGS_ 2 3 CXX 7 _/\_ u0 u1 -> \ (u2 :: {{Integral u0}}) (u3 :: u0) (u4 :: [u1]) -> let {(uh :: Int) = case u2 of { _ALG_ _TUP_12 (u5 :: {{Real u0}}) (u6 :: {{Ix u0}}) (u7 :: u0 -> u0 -> u0) (u8 :: u0 -> u0 -> u0) (u9 :: u0 -> u0 -> u0) (ua :: u0 -> u0 -> u0) (ub :: u0 -> u0 -> (u0, u0)) (uc :: u0 -> u0 -> (u0, u0)) (ud :: u0 -> Bool) (ue :: u0 -> Bool) (uf :: u0 -> Integer) (ug :: u0 -> Int) -> _APP_ ug [ u3 ]; _NO_DEFLT_ }} in _APP_ _TYAPP_ _SPEC_ _ORIG_ PreludeList take [ (Int), _N_ ] { u1 } [ uh, u4 ] _SPECIALISE_ [ Int, _N_ ] 1 { _A_ 2 _U_ 11 _N_ _S_ "U(P)L" {_A_ 2 _U_ 21 _N_ _N_ _N_ _N_} _N_ _N_ }, [ Integer, _N_ ] 1 { _A_ 2 _U_ 11 _N_ _S_ "U(PPP)L" {_A_ 4 _U_ 2221 _N_ _N_ _F_ _IF_ARGS_ 1 4 XXXX 4 _/\_ u0 -> \ (u1 :: Int#) (u2 :: Int#) (u3 :: ByteArray#) (u4 :: [u0]) -> case _#_ integer2Int# [] [u1, u2, u3] of { _PRIM_ (u5 :: Int#) -> _APP_ _TYAPP_ _WRKR_ _SPEC_ _ORIG_ PreludeList take [ (Int), _N_ ] { u0 } [ u5, u4 ] } _N_} _F_ _ALWAYS_ _/\_ u0 -> \ (u1 :: Integer) (u2 :: [u0]) -> case u1 of { _ALG_ J# (u3 :: Int#) (u4 :: Int#) (u5 :: ByteArray#) -> case _#_ integer2Int# [] [u3, u4, u5] of { _PRIM_ (u6 :: Int#) -> _APP_ _TYAPP_ _WRKR_ _SPEC_ _ORIG_ PreludeList take [ (Int), _N_ ] { u0 } [ u6, u2 ] }; _NO_DEFLT_ } _N_ } #-}
+ {-# GHC_PRAGMA _A_ 1 _U_ 122 _N_ _S_ "U(LU(U(ASSAAAAA)AAA)AAAALAAAAL)" {_A_ 5 _U_ 2121222 _N_ _N_ _N_ _N_} _N_ _SPECIALISE_ [ Int, _N_ ] 1 { _A_ 2 _U_ 11 _N_ _S_ "U(P)L" {_A_ 2 _U_ 21 _N_ _N_ _N_ _N_} _N_ _N_ }, [ Integer, _N_ ] 1 { _A_ 1 _U_ 12 _N_ _S_ "U(PPP)" {_A_ 3 _U_ 2222 _N_ _N_ _N_ _N_} _N_ _N_ } #-}
takeWhile :: (a -> Bool) -> [a] -> [a]
{-# GHC_PRAGMA _A_ 2 _U_ 21 _N_ _S_ "LS" _F_ _ALWAYS_ _/\_ u0 -> \ (u1 :: u0 -> Bool) (u2 :: [u0]) -> let {(u9 :: _forall_ a$z1 =>(u0 -> a$z1 -> a$z1) -> a$z1 -> a$z1) = _/\_ u3 -> \ (u4 :: u0 -> u3 -> u3) (u5 :: u3) -> let {(u8 :: u0 -> u3 -> u3) = \ (u6 :: u0) (u7 :: u3) -> case _APP_ u1 [ u6 ] of { _ALG_ True -> _APP_ u4 [ u6, u7 ]; False -> u5; _NO_DEFLT_ }} in _APP_ _TYAPP_ _TYAPP_ foldr { u0 } { u3 } [ u8, u5, u2 ]} in _APP_ _TYAPP_ _build { u0 } [ u9 ] _N_ #-}
transpose :: [[a]] -> [[a]]
lex :: [Char] -> [([Char], [Char])]
{-# GHC_PRAGMA _A_ 1 _U_ 2 _N_ _S_ "S" _N_ _N_ #-}
read :: Text a => [Char] -> a
- {-# GHC_PRAGMA _A_ 1 _U_ 12 _N_ _S_ "U(SAAA)" {_A_ 1 _U_ 12 _N_ _N_ _N_ _N_} _N_ _SPECIALISE_ [ Double ] 1 { _A_ 1 _U_ 2 _N_ _N_ _N_ _N_ }, [ Float ] 1 { _A_ 1 _U_ 2 _N_ _N_ _N_ _N_ }, [ Int ] 1 { _A_ 1 _U_ 2 _N_ _N_ _N_ _N_ }, [ Integer ] 1 { _A_ 1 _U_ 2 _N_ _N_ _N_ _N_ } #-}
+ {-# GHC_PRAGMA _A_ 1 _U_ 12 _N_ _S_ "U(SAAA)" {_A_ 1 _U_ 12 _N_ _N_ _N_ _N_} _N_ _SPECIALISE_ [ Bool ] 1 { _A_ 1 _U_ 2 _N_ _N_ _N_ _N_ }, [ Char ] 1 { _A_ 1 _U_ 2 _N_ _N_ _N_ _N_ }, [ Double ] 1 { _A_ 1 _U_ 2 _N_ _N_ _N_ _N_ }, [ Int ] 1 { _A_ 1 _U_ 2 _N_ _N_ _N_ _N_ }, [ Integer ] 1 { _A_ 1 _U_ 2 _N_ _N_ _N_ _N_ }, [ [Bool] ] 1 { _A_ 1 _U_ 2 _N_ _N_ _N_ _N_ }, [ [Char] ] 1 { _A_ 1 _U_ 2 _N_ _N_ _N_ _N_ }, [ [Double] ] 1 { _A_ 1 _U_ 2 _N_ _N_ _N_ _N_ }, [ [Float] ] 1 { _A_ 1 _U_ 2 _N_ _N_ _N_ _N_ }, [ [Int] ] 1 { _A_ 1 _U_ 2 _N_ _N_ _N_ _N_ }, [ [Integer] ] 1 { _A_ 1 _U_ 2 _N_ _N_ _N_ _N_ }, [ [[Char]] ] 1 { _A_ 1 _U_ 2 _N_ _N_ _N_ _N_ }, [ [[Int]] ] 1 { _A_ 1 _U_ 2 _N_ _N_ _N_ _N_ }, [ [Complex Double] ] 1 { _A_ 1 _U_ 2 _N_ _N_ _N_ _N_ }, [ (Ratio Integer) ] 1 { _A_ 1 _U_ 2 _N_ _N_ _N_ _N_ }, [ (Array Int Double) ] 1 { _A_ 1 _U_ 2 _N_ _N_ _N_ _N_ }, [ (Array (Int, Int) Double) ] 1 { _A_ 1 _U_ 2 _N_ _N_ _N_ _N_ }, [ _PackedString ] 1 { _A_ 1 _U_ 2 _N_ _S_ _!_ _N_ _N_ }, [ (Complex Double) ] 1 { _A_ 1 _U_ 2 _N_ _N_ _N_ _N_ }, [ () ] 1 { _A_ 1 _U_ 2 _N_ _N_ _N_ _N_ }, [ (Int, Int) ] 1 { _A_ 1 _U_ 2 _N_ _N_ _N_ _N_ }, [ (Integer, Integer) ] 1 { _A_ 1 _U_ 2 _N_ _N_ _N_ _N_ }, [ (Int, Int, Int) ] 1 { _A_ 1 _U_ 2 _N_ _N_ _N_ _N_ } #-}
readDec :: Integral a => [Char] -> [(a, [Char])]
- {-# GHC_PRAGMA _A_ 1 _U_ 22 _N_ _N_ _N_ _SPECIALISE_ [ Int ] 1 { _A_ 1 _U_ 2 _N_ _N_ _N_ _N_ }, [ Integer ] 1 { _A_ 1 _U_ 2 _N_ _S_ "S" _N_ _N_ } #-}
+ {-# GHC_PRAGMA _A_ 1 _U_ 22 _N_ _N_ _N_ _SPECIALISE_ [ Int ] 1 { _A_ 1 _U_ 2 _N_ _N_ _N_ _N_ }, [ Integer ] 1 { _A_ 1 _U_ 2 _N_ _N_ _N_ _N_ } #-}
readFloat :: RealFloat a => [Char] -> [(a, [Char])]
- {-# GHC_PRAGMA _A_ 2 _U_ 12 _N_ _S_ "LS" _N_ _SPECIALISE_ [ Double ] 1 { _A_ 1 _U_ 2 _N_ _S_ "S" _N_ _N_ }, [ Float ] 1 { _A_ 1 _U_ 2 _N_ _S_ "S" _N_ _N_ } #-}
+ {-# GHC_PRAGMA _A_ 2 _U_ 12 _N_ _S_ "LS" _N_ _SPECIALISE_ [ Double ] 1 { _A_ 1 _U_ 2 _N_ _S_ "S" _N_ _N_ } #-}
readLitChar :: [Char] -> [(Char, [Char])]
{-# GHC_PRAGMA _A_ 0 _U_ 1 _N_ _N_ _N_ _N_ #-}
readParen :: Bool -> ([Char] -> [(a, [Char])]) -> [Char] -> [(a, [Char])]
readSigned :: Real a => ([Char] -> [(a, [Char])]) -> [Char] -> [(a, [Char])]
{-# GHC_PRAGMA _A_ 2 _U_ 122 _N_ _N_ _N_ _SPECIALISE_ [ Double ] 1 { _A_ 1 _U_ 22 _N_ _N_ _N_ _N_ }, [ Int ] 1 { _A_ 1 _U_ 22 _N_ _N_ _N_ _N_ }, [ Integer ] 1 { _A_ 1 _U_ 22 _N_ _N_ _N_ _N_ } #-}
reads :: Text a => [Char] -> [(a, [Char])]
- {-# GHC_PRAGMA _A_ 1 _U_ 12 _N_ _S_ "U(SAAA)" {_A_ 1 _U_ 12 _N_ _N_ _N_ _N_} _N_ _SPECIALISE_ [ Double ] 1 { _A_ 1 _U_ 2 _N_ _N_ _N_ _N_ }, [ Float ] 1 { _A_ 1 _U_ 2 _N_ _N_ _N_ _N_ }, [ Int ] 1 { _A_ 1 _U_ 2 _N_ _N_ _N_ _N_ }, [ Integer ] 1 { _A_ 1 _U_ 2 _N_ _N_ _N_ _N_ } #-}
+ {-# GHC_PRAGMA _A_ 1 _U_ 12 _N_ _S_ "U(SAAA)" {_A_ 1 _U_ 12 _N_ _N_ _N_ _N_} _N_ _SPECIALISE_ [ Bool ] 1 { _A_ 1 _U_ 2 _N_ _N_ _N_ _N_ }, [ Char ] 1 { _A_ 0 _U_ 2 _N_ _N_ _N_ _N_ }, [ Double ] 1 { _A_ 1 _U_ 2 _N_ _N_ _N_ _N_ }, [ Int ] 1 { _A_ 1 _U_ 2 _N_ _N_ _N_ _N_ }, [ Integer ] 1 { _A_ 1 _U_ 2 _N_ _N_ _N_ _N_ }, [ [Bool] ] 1 { _A_ 0 _U_ 2 _N_ _N_ _F_ _IF_ARGS_ 0 0 X 1 _CONSTM_ Text readList (Bool) _N_ }, [ [Char] ] 1 { _A_ 0 _U_ 2 _N_ _N_ _F_ _IF_ARGS_ 0 0 X 1 _CONSTM_ Text readList (Char) _N_ }, [ [Double] ] 1 { _A_ 0 _U_ 2 _N_ _N_ _F_ _IF_ARGS_ 0 0 X 1 _CONSTM_ Text readList (Double) _N_ }, [ [Float] ] 1 { _A_ 0 _U_ 2 _N_ _N_ _N_ _N_ }, [ [Int] ] 1 { _A_ 0 _U_ 2 _N_ _N_ _F_ _IF_ARGS_ 0 0 X 1 _CONSTM_ Text readList (Int) _N_ }, [ [Integer] ] 1 { _A_ 0 _U_ 2 _N_ _N_ _F_ _IF_ARGS_ 0 0 X 1 _CONSTM_ Text readList (Integer) _N_ }, [ [[Char]] ] 1 { _A_ 0 _U_ 2 _N_ _N_ _F_ _IF_ARGS_ 0 0 X 1 _CONSTM_ Text readList ([Char]) _N_ }, [ [[Int]] ] 1 { _A_ 0 _U_ 2 _N_ _N_ _F_ _IF_ARGS_ 0 0 X 1 _CONSTM_ Text readList ([Int]) _N_ }, [ [Complex Double] ] 1 { _A_ 0 _U_ 2 _N_ _N_ _F_ _IF_ARGS_ 0 0 X 1 _CONSTM_ Text readList (Complex Double) _N_ }, [ (Ratio Integer) ] 1 { _A_ 0 _U_ 2 _N_ _N_ _N_ _N_ }, [ (Array Int Double) ] 1 { _A_ 0 _U_ 2 _N_ _N_ _N_ _N_ }, [ (Array (Int, Int) Double) ] 1 { _A_ 0 _U_ 2 _N_ _N_ _N_ _N_ }, [ _PackedString ] 1 { _A_ 1 _U_ 2 _N_ _S_ _!_ _N_ _N_ }, [ (Complex Double) ] 1 { _A_ 0 _U_ 2 _N_ _N_ _N_ _N_ }, [ () ] 1 { _A_ 0 _U_ 2 _N_ _N_ _N_ _N_ }, [ (Int, Int) ] 1 { _A_ 0 _U_ 2 _N_ _N_ _N_ _N_ }, [ (Integer, Integer) ] 1 { _A_ 0 _U_ 2 _N_ _N_ _N_ _N_ }, [ (Int, Int, Int) ] 1 { _A_ 0 _U_ 2 _N_ _N_ _N_ _N_ } #-}
show :: Text a => a -> [Char]
- {-# GHC_PRAGMA _A_ 1 _U_ 12 _N_ _S_ "U(ASAA)" {_A_ 1 _U_ 12 _N_ _N_ _N_ _N_} _N_ _SPECIALISE_ [ Char ] 1 { _A_ 1 _U_ 1 _N_ _S_ "U(P)" {_A_ 1 _U_ 2 _N_ _N_ _N_ _N_} _N_ _N_ }, [ Double ] 1 { _A_ 1 _U_ 1 _N_ _S_ "U(P)" {_A_ 1 _U_ 2 _N_ _N_ _N_ _N_} _N_ _N_ }, [ Float ] 1 { _A_ 1 _U_ 2 _N_ _N_ _N_ _N_ }, [ Int ] 1 { _A_ 1 _U_ 1 _N_ _S_ "U(P)" {_A_ 1 _U_ 2 _N_ _N_ _N_ _N_} _N_ _N_ }, [ Integer ] 1 { _A_ 1 _U_ 1 _N_ _S_ "U(PPP)" {_A_ 3 _U_ 222 _N_ _N_ _N_ _N_} _N_ _N_ }, [ [Char] ] 1 { _A_ 1 _U_ 2 _N_ _N_ _N_ _N_ }, [ _PackedString ] 1 { _A_ 1 _U_ 1 _N_ _N_ _N_ _N_ }, [ (Int, Int) ] 1 { _A_ 1 _U_ 1 _N_ _S_ "U(LL)" {_A_ 2 _U_ 22 _N_ _N_ _N_ _N_} _N_ _N_ }, [ (Integer, Integer) ] 1 { _A_ 1 _U_ 1 _N_ _S_ "U(LL)" {_A_ 2 _U_ 22 _N_ _N_ _N_ _N_} _N_ _N_ } #-}
+ {-# GHC_PRAGMA _A_ 1 _U_ 12 _N_ _S_ "U(ASAA)" {_A_ 1 _U_ 12 _N_ _N_ _N_ _N_} _N_ _SPECIALISE_ [ Bool ] 1 { _A_ 1 _U_ 2 _N_ _S_ "E" _N_ _N_ }, [ Char ] 1 { _A_ 1 _U_ 1 _N_ _S_ "U(P)" {_A_ 1 _U_ 2 _N_ _N_ _N_ _N_} _N_ _N_ }, [ Double ] 1 { _A_ 1 _U_ 1 _N_ _S_ "U(P)" {_A_ 1 _U_ 2 _N_ _N_ _N_ _N_} _N_ _N_ }, [ Int ] 1 { _A_ 1 _U_ 1 _N_ _S_ "U(P)" {_A_ 1 _U_ 2 _N_ _N_ _N_ _N_} _N_ _N_ }, [ Integer ] 1 { _A_ 1 _U_ 1 _N_ _S_ "U(PPP)" {_A_ 3 _U_ 222 _N_ _N_ _N_ _N_} _N_ _N_ }, [ [Bool] ] 1 { _A_ 1 _U_ 1 _N_ _S_ "S" _N_ _N_ }, [ [Char] ] 1 { _A_ 1 _U_ 2 _N_ _N_ _N_ _N_ }, [ [Double] ] 1 { _A_ 1 _U_ 2 _N_ _N_ _N_ _N_ }, [ [Int] ] 1 { _A_ 1 _U_ 2 _N_ _N_ _N_ _N_ }, [ [Integer] ] 1 { _A_ 1 _U_ 2 _N_ _N_ _N_ _N_ }, [ [[Char]] ] 1 { _A_ 1 _U_ 1 _N_ _S_ "S" _N_ _N_ }, [ [[Int]] ] 1 { _A_ 1 _U_ 1 _N_ _S_ "S" _N_ _N_ }, [ [Complex Double] ] 1 { _A_ 1 _U_ 2 _N_ _N_ _N_ _N_ }, [ (Ratio Integer) ] 1 { _A_ 1 _U_ 1 _N_ _S_ "U(LL)" {_A_ 2 _U_ 22 _N_ _N_ _N_ _N_} _N_ _N_ }, [ (Array Int Double) ] 1 { _A_ 1 _U_ 2 _N_ _N_ _N_ _N_ }, [ (Array (Int, Int) Double) ] 1 { _A_ 1 _U_ 2 _N_ _N_ _N_ _N_ }, [ _PackedString ] 1 { _A_ 1 _U_ 1 _N_ _N_ _N_ _N_ }, [ (Complex Double) ] 1 { _A_ 1 _U_ 1 _N_ _S_ "U(LL)" {_A_ 2 _U_ 22 _N_ _N_ _N_ _N_} _N_ _N_ }, [ () ] 1 { _A_ 1 _U_ 1 _N_ _S_ "E" _N_ _N_ }, [ (Int, Int) ] 1 { _A_ 1 _U_ 1 _N_ _S_ "U(LL)" {_A_ 2 _U_ 22 _N_ _N_ _N_ _N_} _N_ _N_ }, [ (Integer, Integer) ] 1 { _A_ 1 _U_ 1 _N_ _S_ "U(LL)" {_A_ 2 _U_ 22 _N_ _N_ _N_ _N_} _N_ _N_ }, [ (Int, Int, Int) ] 1 { _A_ 1 _U_ 1 _N_ _S_ "U(LLL)" {_A_ 3 _U_ 222 _N_ _N_ _N_ _N_} _N_ _N_ } #-}
showChar :: Char -> [Char] -> [Char]
{-# GHC_PRAGMA _A_ 2 _U_ 22 _N_ _N_ _F_ _IF_ARGS_ 0 2 XX 3 \ (u0 :: Char) (u1 :: [Char]) -> _!_ (:) [Char] [u0, u1] _N_ #-}
showFloat :: RealFloat a => a -> [Char] -> [Char]
- {-# GHC_PRAGMA _A_ 1 _U_ 122 _N_ _S_ "U(U(LU(SLLL)LAAAA)LLLALAAAA)" {_A_ 5 _U_ 1122222 _N_ _N_ _N_ _N_} _N_ _SPECIALISE_ [ Double ] 1 { _A_ 1 _U_ 12 _N_ _S_ "U(P)" {_A_ 1 _U_ 22 _N_ _N_ _N_ _N_} _N_ _N_ }, [ Float ] 1 { _A_ 0 _U_ 22 _N_ _N_ _N_ _N_ } #-}
+ {-# GHC_PRAGMA _A_ 1 _U_ 122 _N_ _S_ "U(U(AU(SAAA)AAAAL)LLLALAAAA)" {_A_ 5 _U_ 1122222 _N_ _N_ _N_ _N_} _N_ _SPECIALISE_ [ Double ] 1 { _A_ 1 _U_ 12 _N_ _S_ "U(P)" {_A_ 1 _U_ 22 _N_ _N_ _N_ _N_} _N_ _N_ } #-}
showInt :: Integral a => a -> [Char] -> [Char]
{-# GHC_PRAGMA _A_ 1 _U_ 122 _N_ _S_ "U(U(U(U(SL)LLLLLLLLL)LL)LLLLLSLLLLL)" _N_ _SPECIALISE_ [ Int ] 1 { _A_ 2 _U_ 12 _N_ _S_ "U(P)L" {_A_ 2 _U_ 22 _N_ _N_ _N_ _N_} _N_ _N_ }, [ Integer ] 1 { _A_ 2 _U_ 12 _N_ _S_ "U(PPP)L" {_A_ 4 _U_ 2222 _N_ _N_ _N_ _N_} _N_ _N_ } #-}
showLitChar :: Char -> [Char] -> [Char]
showString :: [Char] -> [Char] -> [Char]
{-# GHC_PRAGMA _A_ 2 _U_ 12 _N_ _N_ _F_ _IF_ARGS_ 0 0 X 1 _TYAPP_ _ORIG_ PreludeList (++) { Char } _N_ #-}
shows :: Text a => a -> [Char] -> [Char]
- {-# GHC_PRAGMA _A_ 1 _U_ 122 _N_ _S_ "U(ASAA)" {_A_ 1 _U_ 122 _N_ _N_ _N_ _N_} _N_ _SPECIALISE_ [ Char ] 1 { _A_ 2 _U_ 12 _N_ _S_ "U(P)L" {_A_ 2 _U_ 22 _N_ _N_ _N_ _N_} _N_ _N_ }, [ Double ] 1 { _A_ 1 _U_ 12 _N_ _S_ "U(P)" {_A_ 1 _U_ 22 _N_ _N_ _N_ _N_} _N_ _N_ }, [ Float ] 1 { _A_ 0 _U_ 22 _N_ _N_ _N_ _N_ }, [ Int ] 1 { _A_ 2 _U_ 12 _N_ _S_ "U(P)L" {_A_ 2 _U_ 22 _N_ _N_ _N_ _N_} _N_ _N_ }, [ Integer ] 1 { _A_ 2 _U_ 12 _N_ _S_ "U(PPP)L" {_A_ 4 _U_ 2222 _N_ _N_ _N_ _N_} _N_ _N_ }, [ [Char] ] 1 { _A_ 1 _U_ 22 _N_ _N_ _F_ _IF_ARGS_ 0 0 X 1 _CONSTM_ Text showList (Char) _N_ }, [ _PackedString ] 1 { _A_ 2 _U_ 12 _N_ _N_ _N_ _N_ }, [ (Int, Int) ] 1 { _A_ 2 _U_ 12 _N_ _S_ "U(LL)L" {_A_ 3 _U_ 222 _N_ _N_ _N_ _N_} _N_ _N_ }, [ (Integer, Integer) ] 1 { _A_ 2 _U_ 12 _N_ _S_ "U(LL)L" {_A_ 3 _U_ 222 _N_ _N_ _N_ _N_} _N_ _N_ } #-}
+ {-# GHC_PRAGMA _A_ 1 _U_ 122 _N_ _S_ "U(ASAA)" {_A_ 1 _U_ 122 _N_ _N_ _N_ _N_} _N_ _SPECIALISE_ [ Bool ] 1 { _A_ 2 _U_ 22 _N_ _N_ _N_ _N_ }, [ Char ] 1 { _A_ 2 _U_ 12 _N_ _S_ "U(P)L" {_A_ 2 _U_ 22 _N_ _N_ _N_ _N_} _N_ _N_ }, [ Double ] 1 { _A_ 1 _U_ 12 _N_ _S_ "U(P)" {_A_ 1 _U_ 22 _N_ _N_ _N_ _N_} _N_ _N_ }, [ Int ] 1 { _A_ 2 _U_ 12 _N_ _S_ "U(P)L" {_A_ 2 _U_ 22 _N_ _N_ _N_ _N_} _N_ _N_ }, [ Integer ] 1 { _A_ 2 _U_ 12 _N_ _S_ "U(PPP)L" {_A_ 4 _U_ 2222 _N_ _N_ _N_ _N_} _N_ _N_ }, [ [Bool] ] 1 { _A_ 1 _U_ 12 _N_ _S_ "S" _F_ _IF_ARGS_ 0 1 X 3 \ (u0 :: [Bool]) -> _APP_ _TYAPP_ _ORIG_ PreludeCore _showList { Bool } [ _WRKR_ _CONSTM_ Text showsPrec (Bool), u0 ] _N_ }, [ [Char] ] 1 { _A_ 1 _U_ 22 _N_ _N_ _F_ _IF_ARGS_ 0 0 X 1 _CONSTM_ Text showList (Char) _N_ }, [ [Double] ] 1 { _A_ 1 _U_ 22 _N_ _N_ _F_ _IF_ARGS_ 0 0 X 1 _CONSTM_ Text showList (Double) _N_ }, [ [Int] ] 1 { _A_ 1 _U_ 22 _N_ _N_ _F_ _IF_ARGS_ 0 0 X 1 _CONSTM_ Text showList (Int) _N_ }, [ [Integer] ] 1 { _A_ 1 _U_ 22 _N_ _N_ _F_ _IF_ARGS_ 0 0 X 1 _CONSTM_ Text showList (Integer) _N_ }, [ [[Char]] ] 1 { _A_ 1 _U_ 12 _N_ _S_ "S" _F_ _IF_ARGS_ 0 1 X 3 \ (u0 :: [[Char]]) -> _APP_ _TYAPP_ _ORIG_ PreludeCore _showList { [Char] } [ _CONSTM_ Text showList (Char), u0 ] _N_ }, [ [[Int]] ] 1 { _A_ 1 _U_ 12 _N_ _S_ "S" _F_ _IF_ARGS_ 0 1 X 3 \ (u0 :: [[Int]]) -> _APP_ _TYAPP_ _ORIG_ PreludeCore _showList { [Int] } [ _CONSTM_ Text showList (Int), u0 ] _N_ }, [ [Complex Double] ] 1 { _A_ 1 _U_ 22 _N_ _N_ _F_ _IF_ARGS_ 0 0 X 1 _CONSTM_ Text showList (Complex Double) _N_ }, [ (Ratio Integer) ] 1 { _A_ 1 _U_ 12 _N_ _S_ "U(LL)" {_A_ 2 _U_ 222 _N_ _N_ _N_ _N_} _N_ _N_ }, [ (Array Int Double) ] 1 { _A_ 1 _U_ 22 _N_ _N_ _N_ _N_ }, [ (Array (Int, Int) Double) ] 1 { _A_ 1 _U_ 22 _N_ _N_ _N_ _N_ }, [ _PackedString ] 1 { _A_ 2 _U_ 12 _N_ _N_ _N_ _N_ }, [ (Complex Double) ] 1 { _A_ 1 _U_ 12 _N_ _S_ "U(LL)" {_A_ 2 _U_ 222 _N_ _N_ _N_ _N_} _N_ _N_ }, [ () ] 1 { _A_ 2 _U_ 12 _N_ _S_ "EL" _F_ _IF_ARGS_ 0 2 CX 4 \ (u0 :: ()) (u1 :: [Char]) -> case u0 of { _ALG_ _TUP_0 -> _APP_ _TYAPP_ _ORIG_ PreludeList (++) { Char } [ _NOREP_S_ "()", u1 ]; _NO_DEFLT_ } _N_ }, [ (Int, Int) ] 1 { _A_ 2 _U_ 12 _N_ _S_ "U(LL)L" {_A_ 3 _U_ 222 _N_ _N_ _N_ _N_} _N_ _N_ }, [ (Integer, Integer) ] 1 { _A_ 2 _U_ 12 _N_ _S_ "U(LL)L" {_A_ 3 _U_ 222 _N_ _N_ _N_ _N_} _N_ _N_ }, [ (Int, Int, Int) ] 1 { _A_ 2 _U_ 12 _N_ _S_ "U(LLL)L" {_A_ 4 _U_ 2222 _N_ _N_ _N_ _N_} _N_ _N_ } #-}
-{-# GHC_PRAGMA INTERFACE VERSION 5 #-}
+{-# GHC_PRAGMA INTERFACE VERSION 6 #-}
interface SampleVar where
import PreludeIOError(IOError13)
import PreludeMonadicIO(Either)
-{-# GHC_PRAGMA INTERFACE VERSION 5 #-}
+{-# GHC_PRAGMA INTERFACE VERSION 6 #-}
interface SampleVar where
import PreludeIOError(IOError13)
import PreludeMonadicIO(Either)
-{-# GHC_PRAGMA INTERFACE VERSION 5 #-}
+{-# GHC_PRAGMA INTERFACE VERSION 6 #-}
interface SampleVar where
import PreludeIOError(IOError13)
import PreludeMonadicIO(Either)
-{-# GHC_PRAGMA INTERFACE VERSION 5 #-}
+{-# GHC_PRAGMA INTERFACE VERSION 6 #-}
interface SampleVar where
import PreludeIOError(IOError13)
import PreludeMonadicIO(Either)
-{-# GHC_PRAGMA INTERFACE VERSION 5 #-}
+{-# GHC_PRAGMA INTERFACE VERSION 6 #-}
interface SampleVar where
import PreludeIOError(IOError13)
import PreludeMonadicIO(Either)
-{-# GHC_PRAGMA INTERFACE VERSION 5 #-}
+{-# GHC_PRAGMA INTERFACE VERSION 6 #-}
interface Semaphore where
import PreludeIOError(IOError13)
import PreludeMonadicIO(Either)
-{-# GHC_PRAGMA INTERFACE VERSION 5 #-}
+{-# GHC_PRAGMA INTERFACE VERSION 6 #-}
interface Semaphore where
import PreludeIOError(IOError13)
import PreludeMonadicIO(Either)
-{-# GHC_PRAGMA INTERFACE VERSION 5 #-}
+{-# GHC_PRAGMA INTERFACE VERSION 6 #-}
interface Semaphore where
import PreludeIOError(IOError13)
import PreludeMonadicIO(Either)
-{-# GHC_PRAGMA INTERFACE VERSION 5 #-}
+{-# GHC_PRAGMA INTERFACE VERSION 6 #-}
interface Semaphore where
import PreludeIOError(IOError13)
import PreludeMonadicIO(Either)
-{-# GHC_PRAGMA INTERFACE VERSION 5 #-}
+{-# GHC_PRAGMA INTERFACE VERSION 6 #-}
interface Semaphore where
import PreludeIOError(IOError13)
import PreludeMonadicIO(Either)
-{-# GHC_PRAGMA INTERFACE VERSION 5 #-}
+{-# GHC_PRAGMA INTERFACE VERSION 6 #-}
interface PreludeText where
import PreludeBuiltin(Char(..), Int(..), Integer(..), List(..), Tuple2)
import PreludeCore(Bool(..), Integral(..), Real(..), RealFloat(..), Text(..))
lex :: [Char] -> [([Char], [Char])]
{-# GHC_PRAGMA _A_ 1 _U_ 2 _N_ _S_ "S" _N_ _N_ #-}
read :: Text a => [Char] -> a
- {-# GHC_PRAGMA _A_ 1 _U_ 12 _N_ _S_ "U(SAAA)" {_A_ 1 _U_ 12 _N_ _N_ _N_ _N_} _N_ _SPECIALISE_ [ Double ] 1 { _A_ 1 _U_ 2 _N_ _N_ _N_ _N_ }, [ Float ] 1 { _A_ 1 _U_ 2 _N_ _N_ _N_ _N_ }, [ Int ] 1 { _A_ 1 _U_ 2 _N_ _N_ _N_ _N_ }, [ Integer ] 1 { _A_ 1 _U_ 2 _N_ _N_ _N_ _N_ } #-}
+ {-# GHC_PRAGMA _A_ 1 _U_ 12 _N_ _S_ "U(SAAA)" {_A_ 1 _U_ 12 _N_ _N_ _N_ _N_} _N_ _SPECIALISE_ [ Bool ] 1 { _A_ 1 _U_ 2 _N_ _N_ _N_ _N_ }, [ Char ] 1 { _A_ 1 _U_ 2 _N_ _N_ _N_ _N_ }, [ Double ] 1 { _A_ 1 _U_ 2 _N_ _N_ _N_ _N_ }, [ Int ] 1 { _A_ 1 _U_ 2 _N_ _N_ _N_ _N_ }, [ Integer ] 1 { _A_ 1 _U_ 2 _N_ _N_ _N_ _N_ }, [ [Bool] ] 1 { _A_ 1 _U_ 2 _N_ _N_ _N_ _N_ }, [ [Char] ] 1 { _A_ 1 _U_ 2 _N_ _N_ _N_ _N_ }, [ [Double] ] 1 { _A_ 1 _U_ 2 _N_ _N_ _N_ _N_ }, [ [Float] ] 1 { _A_ 1 _U_ 2 _N_ _N_ _N_ _N_ }, [ [Int] ] 1 { _A_ 1 _U_ 2 _N_ _N_ _N_ _N_ }, [ [Integer] ] 1 { _A_ 1 _U_ 2 _N_ _N_ _N_ _N_ }, [ [[Char]] ] 1 { _A_ 1 _U_ 2 _N_ _N_ _N_ _N_ }, [ [[Int]] ] 1 { _A_ 1 _U_ 2 _N_ _N_ _N_ _N_ }, [ [Complex Double] ] 1 { _A_ 1 _U_ 2 _N_ _N_ _N_ _N_ }, [ (Ratio Integer) ] 1 { _A_ 1 _U_ 2 _N_ _N_ _N_ _N_ }, [ (Array Int Double) ] 1 { _A_ 1 _U_ 2 _N_ _N_ _N_ _N_ }, [ (Array (Int, Int) Double) ] 1 { _A_ 1 _U_ 2 _N_ _N_ _N_ _N_ }, [ _PackedString ] 1 { _A_ 1 _U_ 2 _N_ _S_ _!_ _N_ _N_ }, [ (Complex Double) ] 1 { _A_ 1 _U_ 2 _N_ _N_ _N_ _N_ }, [ () ] 1 { _A_ 1 _U_ 2 _N_ _N_ _N_ _N_ }, [ (Int, Int) ] 1 { _A_ 1 _U_ 2 _N_ _N_ _N_ _N_ }, [ (Integer, Integer) ] 1 { _A_ 1 _U_ 2 _N_ _N_ _N_ _N_ }, [ (Int, Int, Int) ] 1 { _A_ 1 _U_ 2 _N_ _N_ _N_ _N_ } #-}
readDec :: Integral a => [Char] -> [(a, [Char])]
- {-# GHC_PRAGMA _A_ 1 _U_ 22 _N_ _N_ _N_ _SPECIALISE_ [ Int ] 1 { _A_ 1 _U_ 2 _N_ _N_ _N_ _N_ }, [ Integer ] 1 { _A_ 1 _U_ 2 _N_ _S_ "S" _N_ _N_ } #-}
+ {-# GHC_PRAGMA _A_ 1 _U_ 22 _N_ _N_ _N_ _SPECIALISE_ [ Int ] 1 { _A_ 1 _U_ 2 _N_ _N_ _N_ _N_ }, [ Integer ] 1 { _A_ 1 _U_ 2 _N_ _N_ _N_ _N_ } #-}
readFloat :: RealFloat a => [Char] -> [(a, [Char])]
- {-# GHC_PRAGMA _A_ 2 _U_ 12 _N_ _S_ "LS" _N_ _SPECIALISE_ [ Double ] 1 { _A_ 1 _U_ 2 _N_ _S_ "S" _N_ _N_ }, [ Float ] 1 { _A_ 1 _U_ 2 _N_ _S_ "S" _N_ _N_ } #-}
+ {-# GHC_PRAGMA _A_ 2 _U_ 12 _N_ _S_ "LS" _N_ _SPECIALISE_ [ Double ] 1 { _A_ 1 _U_ 2 _N_ _S_ "S" _N_ _N_ } #-}
readHex :: Integral a => [Char] -> [(a, [Char])]
- {-# GHC_PRAGMA _A_ 1 _U_ 22 _N_ _N_ _N_ _SPECIALISE_ [ Int ] 1 { _A_ 1 _U_ 2 _N_ _N_ _N_ _N_ } #-}
+ {-# GHC_PRAGMA _A_ 1 _U_ 22 _N_ _N_ _N_ _SPECIALISE_ [ Int ] 1 { _A_ 1 _U_ 2 _N_ _N_ _N_ _N_ }, [ Integer ] 1 { _A_ 1 _U_ 2 _N_ _N_ _N_ _N_ } #-}
readLitChar :: [Char] -> [(Char, [Char])]
{-# GHC_PRAGMA _A_ 0 _U_ 1 _N_ _N_ _N_ _N_ #-}
readOct :: Integral a => [Char] -> [(a, [Char])]
- {-# GHC_PRAGMA _A_ 1 _U_ 22 _N_ _N_ _N_ _SPECIALISE_ [ Int ] 1 { _A_ 1 _U_ 2 _N_ _N_ _N_ _N_ } #-}
+ {-# GHC_PRAGMA _A_ 1 _U_ 22 _N_ _N_ _N_ _SPECIALISE_ [ Int ] 1 { _A_ 1 _U_ 2 _N_ _N_ _N_ _N_ }, [ Integer ] 1 { _A_ 1 _U_ 2 _N_ _N_ _N_ _N_ } #-}
readParen :: Bool -> ([Char] -> [(a, [Char])]) -> [Char] -> [(a, [Char])]
{-# GHC_PRAGMA _A_ 2 _U_ 122 _N_ _S_ "EL" _N_ _N_ #-}
readSigned :: Real a => ([Char] -> [(a, [Char])]) -> [Char] -> [(a, [Char])]
{-# GHC_PRAGMA _A_ 2 _U_ 122 _N_ _N_ _N_ _SPECIALISE_ [ Double ] 1 { _A_ 1 _U_ 22 _N_ _N_ _N_ _N_ }, [ Int ] 1 { _A_ 1 _U_ 22 _N_ _N_ _N_ _N_ }, [ Integer ] 1 { _A_ 1 _U_ 22 _N_ _N_ _N_ _N_ } #-}
reads :: Text a => [Char] -> [(a, [Char])]
- {-# GHC_PRAGMA _A_ 1 _U_ 12 _N_ _S_ "U(SAAA)" {_A_ 1 _U_ 12 _N_ _N_ _N_ _N_} _N_ _SPECIALISE_ [ Double ] 1 { _A_ 1 _U_ 2 _N_ _N_ _N_ _N_ }, [ Float ] 1 { _A_ 1 _U_ 2 _N_ _N_ _N_ _N_ }, [ Int ] 1 { _A_ 1 _U_ 2 _N_ _N_ _N_ _N_ }, [ Integer ] 1 { _A_ 1 _U_ 2 _N_ _N_ _N_ _N_ } #-}
+ {-# GHC_PRAGMA _A_ 1 _U_ 12 _N_ _S_ "U(SAAA)" {_A_ 1 _U_ 12 _N_ _N_ _N_ _N_} _N_ _SPECIALISE_ [ Bool ] 1 { _A_ 1 _U_ 2 _N_ _N_ _N_ _N_ }, [ Char ] 1 { _A_ 0 _U_ 2 _N_ _N_ _N_ _N_ }, [ Double ] 1 { _A_ 1 _U_ 2 _N_ _N_ _N_ _N_ }, [ Int ] 1 { _A_ 1 _U_ 2 _N_ _N_ _N_ _N_ }, [ Integer ] 1 { _A_ 1 _U_ 2 _N_ _N_ _N_ _N_ }, [ [Bool] ] 1 { _A_ 0 _U_ 2 _N_ _N_ _F_ _IF_ARGS_ 0 0 X 1 _CONSTM_ Text readList (Bool) _N_ }, [ [Char] ] 1 { _A_ 0 _U_ 2 _N_ _N_ _F_ _IF_ARGS_ 0 0 X 1 _CONSTM_ Text readList (Char) _N_ }, [ [Double] ] 1 { _A_ 0 _U_ 2 _N_ _N_ _F_ _IF_ARGS_ 0 0 X 1 _CONSTM_ Text readList (Double) _N_ }, [ [Float] ] 1 { _A_ 0 _U_ 2 _N_ _N_ _N_ _N_ }, [ [Int] ] 1 { _A_ 0 _U_ 2 _N_ _N_ _F_ _IF_ARGS_ 0 0 X 1 _CONSTM_ Text readList (Int) _N_ }, [ [Integer] ] 1 { _A_ 0 _U_ 2 _N_ _N_ _F_ _IF_ARGS_ 0 0 X 1 _CONSTM_ Text readList (Integer) _N_ }, [ [[Char]] ] 1 { _A_ 0 _U_ 2 _N_ _N_ _F_ _IF_ARGS_ 0 0 X 1 _CONSTM_ Text readList ([Char]) _N_ }, [ [[Int]] ] 1 { _A_ 0 _U_ 2 _N_ _N_ _F_ _IF_ARGS_ 0 0 X 1 _CONSTM_ Text readList ([Int]) _N_ }, [ [Complex Double] ] 1 { _A_ 0 _U_ 2 _N_ _N_ _F_ _IF_ARGS_ 0 0 X 1 _CONSTM_ Text readList (Complex Double) _N_ }, [ (Ratio Integer) ] 1 { _A_ 0 _U_ 2 _N_ _N_ _N_ _N_ }, [ (Array Int Double) ] 1 { _A_ 0 _U_ 2 _N_ _N_ _N_ _N_ }, [ (Array (Int, Int) Double) ] 1 { _A_ 0 _U_ 2 _N_ _N_ _N_ _N_ }, [ _PackedString ] 1 { _A_ 1 _U_ 2 _N_ _S_ _!_ _N_ _N_ }, [ (Complex Double) ] 1 { _A_ 0 _U_ 2 _N_ _N_ _N_ _N_ }, [ () ] 1 { _A_ 0 _U_ 2 _N_ _N_ _N_ _N_ }, [ (Int, Int) ] 1 { _A_ 0 _U_ 2 _N_ _N_ _N_ _N_ }, [ (Integer, Integer) ] 1 { _A_ 0 _U_ 2 _N_ _N_ _N_ _N_ }, [ (Int, Int, Int) ] 1 { _A_ 0 _U_ 2 _N_ _N_ _N_ _N_ } #-}
show :: Text a => a -> [Char]
- {-# GHC_PRAGMA _A_ 1 _U_ 12 _N_ _S_ "U(ASAA)" {_A_ 1 _U_ 12 _N_ _N_ _N_ _N_} _N_ _SPECIALISE_ [ Char ] 1 { _A_ 1 _U_ 1 _N_ _S_ "U(P)" {_A_ 1 _U_ 2 _N_ _N_ _N_ _N_} _N_ _N_ }, [ Double ] 1 { _A_ 1 _U_ 1 _N_ _S_ "U(P)" {_A_ 1 _U_ 2 _N_ _N_ _N_ _N_} _N_ _N_ }, [ Float ] 1 { _A_ 1 _U_ 2 _N_ _N_ _N_ _N_ }, [ Int ] 1 { _A_ 1 _U_ 1 _N_ _S_ "U(P)" {_A_ 1 _U_ 2 _N_ _N_ _N_ _N_} _N_ _N_ }, [ Integer ] 1 { _A_ 1 _U_ 1 _N_ _S_ "U(PPP)" {_A_ 3 _U_ 222 _N_ _N_ _N_ _N_} _N_ _N_ }, [ [Char] ] 1 { _A_ 1 _U_ 2 _N_ _N_ _N_ _N_ }, [ _PackedString ] 1 { _A_ 1 _U_ 1 _N_ _N_ _N_ _N_ }, [ (Int, Int) ] 1 { _A_ 1 _U_ 1 _N_ _S_ "U(LL)" {_A_ 2 _U_ 22 _N_ _N_ _N_ _N_} _N_ _N_ }, [ (Integer, Integer) ] 1 { _A_ 1 _U_ 1 _N_ _S_ "U(LL)" {_A_ 2 _U_ 22 _N_ _N_ _N_ _N_} _N_ _N_ } #-}
+ {-# GHC_PRAGMA _A_ 1 _U_ 12 _N_ _S_ "U(ASAA)" {_A_ 1 _U_ 12 _N_ _N_ _N_ _N_} _N_ _SPECIALISE_ [ Bool ] 1 { _A_ 1 _U_ 2 _N_ _S_ "E" _N_ _N_ }, [ Char ] 1 { _A_ 1 _U_ 1 _N_ _S_ "U(P)" {_A_ 1 _U_ 2 _N_ _N_ _N_ _N_} _N_ _N_ }, [ Double ] 1 { _A_ 1 _U_ 1 _N_ _S_ "U(P)" {_A_ 1 _U_ 2 _N_ _N_ _N_ _N_} _N_ _N_ }, [ Int ] 1 { _A_ 1 _U_ 1 _N_ _S_ "U(P)" {_A_ 1 _U_ 2 _N_ _N_ _N_ _N_} _N_ _N_ }, [ Integer ] 1 { _A_ 1 _U_ 1 _N_ _S_ "U(PPP)" {_A_ 3 _U_ 222 _N_ _N_ _N_ _N_} _N_ _N_ }, [ [Bool] ] 1 { _A_ 1 _U_ 1 _N_ _S_ "S" _N_ _N_ }, [ [Char] ] 1 { _A_ 1 _U_ 2 _N_ _N_ _N_ _N_ }, [ [Double] ] 1 { _A_ 1 _U_ 2 _N_ _N_ _N_ _N_ }, [ [Int] ] 1 { _A_ 1 _U_ 2 _N_ _N_ _N_ _N_ }, [ [Integer] ] 1 { _A_ 1 _U_ 2 _N_ _N_ _N_ _N_ }, [ [[Char]] ] 1 { _A_ 1 _U_ 1 _N_ _S_ "S" _N_ _N_ }, [ [[Int]] ] 1 { _A_ 1 _U_ 1 _N_ _S_ "S" _N_ _N_ }, [ [Complex Double] ] 1 { _A_ 1 _U_ 2 _N_ _N_ _N_ _N_ }, [ (Ratio Integer) ] 1 { _A_ 1 _U_ 1 _N_ _S_ "U(LL)" {_A_ 2 _U_ 22 _N_ _N_ _N_ _N_} _N_ _N_ }, [ (Array Int Double) ] 1 { _A_ 1 _U_ 2 _N_ _N_ _N_ _N_ }, [ (Array (Int, Int) Double) ] 1 { _A_ 1 _U_ 2 _N_ _N_ _N_ _N_ }, [ _PackedString ] 1 { _A_ 1 _U_ 1 _N_ _N_ _N_ _N_ }, [ (Complex Double) ] 1 { _A_ 1 _U_ 1 _N_ _S_ "U(LL)" {_A_ 2 _U_ 22 _N_ _N_ _N_ _N_} _N_ _N_ }, [ () ] 1 { _A_ 1 _U_ 1 _N_ _S_ "E" _N_ _N_ }, [ (Int, Int) ] 1 { _A_ 1 _U_ 1 _N_ _S_ "U(LL)" {_A_ 2 _U_ 22 _N_ _N_ _N_ _N_} _N_ _N_ }, [ (Integer, Integer) ] 1 { _A_ 1 _U_ 1 _N_ _S_ "U(LL)" {_A_ 2 _U_ 22 _N_ _N_ _N_ _N_} _N_ _N_ }, [ (Int, Int, Int) ] 1 { _A_ 1 _U_ 1 _N_ _S_ "U(LLL)" {_A_ 3 _U_ 222 _N_ _N_ _N_ _N_} _N_ _N_ } #-}
showChar :: Char -> [Char] -> [Char]
{-# GHC_PRAGMA _A_ 2 _U_ 22 _N_ _N_ _F_ _IF_ARGS_ 0 2 XX 3 \ (u0 :: Char) (u1 :: [Char]) -> _!_ (:) [Char] [u0, u1] _N_ #-}
showFloat :: RealFloat a => a -> [Char] -> [Char]
- {-# GHC_PRAGMA _A_ 1 _U_ 122 _N_ _S_ "U(U(LU(SLLL)LAAAA)LLLALAAAA)" {_A_ 5 _U_ 1122222 _N_ _N_ _N_ _N_} _N_ _SPECIALISE_ [ Double ] 1 { _A_ 1 _U_ 12 _N_ _S_ "U(P)" {_A_ 1 _U_ 22 _N_ _N_ _N_ _N_} _N_ _N_ }, [ Float ] 1 { _A_ 0 _U_ 22 _N_ _N_ _N_ _N_ } #-}
+ {-# GHC_PRAGMA _A_ 1 _U_ 122 _N_ _S_ "U(U(AU(SAAA)AAAAL)LLLALAAAA)" {_A_ 5 _U_ 1122222 _N_ _N_ _N_ _N_} _N_ _SPECIALISE_ [ Double ] 1 { _A_ 1 _U_ 12 _N_ _S_ "U(P)" {_A_ 1 _U_ 22 _N_ _N_ _N_ _N_} _N_ _N_ } #-}
showInt :: Integral a => a -> [Char] -> [Char]
{-# GHC_PRAGMA _A_ 1 _U_ 122 _N_ _S_ "U(U(U(U(SL)LLLLLLLLL)LL)LLLLLSLLLLL)" _N_ _SPECIALISE_ [ Int ] 1 { _A_ 2 _U_ 12 _N_ _S_ "U(P)L" {_A_ 2 _U_ 22 _N_ _N_ _N_ _N_} _N_ _N_ }, [ Integer ] 1 { _A_ 2 _U_ 12 _N_ _S_ "U(PPP)L" {_A_ 4 _U_ 2222 _N_ _N_ _N_ _N_} _N_ _N_ } #-}
showLitChar :: Char -> [Char] -> [Char]
showString :: [Char] -> [Char] -> [Char]
{-# GHC_PRAGMA _A_ 2 _U_ 12 _N_ _N_ _F_ _IF_ARGS_ 0 0 X 1 _TYAPP_ _ORIG_ PreludeList (++) { Char } _N_ #-}
shows :: Text a => a -> [Char] -> [Char]
- {-# GHC_PRAGMA _A_ 1 _U_ 122 _N_ _S_ "U(ASAA)" {_A_ 1 _U_ 122 _N_ _N_ _N_ _N_} _N_ _SPECIALISE_ [ Char ] 1 { _A_ 2 _U_ 12 _N_ _S_ "U(P)L" {_A_ 2 _U_ 22 _N_ _N_ _N_ _N_} _N_ _N_ }, [ Double ] 1 { _A_ 1 _U_ 12 _N_ _S_ "U(P)" {_A_ 1 _U_ 22 _N_ _N_ _N_ _N_} _N_ _N_ }, [ Float ] 1 { _A_ 0 _U_ 22 _N_ _N_ _N_ _N_ }, [ Int ] 1 { _A_ 2 _U_ 12 _N_ _S_ "U(P)L" {_A_ 2 _U_ 22 _N_ _N_ _N_ _N_} _N_ _N_ }, [ Integer ] 1 { _A_ 2 _U_ 12 _N_ _S_ "U(PPP)L" {_A_ 4 _U_ 2222 _N_ _N_ _N_ _N_} _N_ _N_ }, [ [Char] ] 1 { _A_ 1 _U_ 22 _N_ _N_ _F_ _IF_ARGS_ 0 0 X 1 _CONSTM_ Text showList (Char) _N_ }, [ _PackedString ] 1 { _A_ 2 _U_ 12 _N_ _N_ _N_ _N_ }, [ (Int, Int) ] 1 { _A_ 2 _U_ 12 _N_ _S_ "U(LL)L" {_A_ 3 _U_ 222 _N_ _N_ _N_ _N_} _N_ _N_ }, [ (Integer, Integer) ] 1 { _A_ 2 _U_ 12 _N_ _S_ "U(LL)L" {_A_ 3 _U_ 222 _N_ _N_ _N_ _N_} _N_ _N_ } #-}
+ {-# GHC_PRAGMA _A_ 1 _U_ 122 _N_ _S_ "U(ASAA)" {_A_ 1 _U_ 122 _N_ _N_ _N_ _N_} _N_ _SPECIALISE_ [ Bool ] 1 { _A_ 2 _U_ 22 _N_ _N_ _N_ _N_ }, [ Char ] 1 { _A_ 2 _U_ 12 _N_ _S_ "U(P)L" {_A_ 2 _U_ 22 _N_ _N_ _N_ _N_} _N_ _N_ }, [ Double ] 1 { _A_ 1 _U_ 12 _N_ _S_ "U(P)" {_A_ 1 _U_ 22 _N_ _N_ _N_ _N_} _N_ _N_ }, [ Int ] 1 { _A_ 2 _U_ 12 _N_ _S_ "U(P)L" {_A_ 2 _U_ 22 _N_ _N_ _N_ _N_} _N_ _N_ }, [ Integer ] 1 { _A_ 2 _U_ 12 _N_ _S_ "U(PPP)L" {_A_ 4 _U_ 2222 _N_ _N_ _N_ _N_} _N_ _N_ }, [ [Bool] ] 1 { _A_ 1 _U_ 12 _N_ _S_ "S" _F_ _IF_ARGS_ 0 1 X 3 \ (u0 :: [Bool]) -> _APP_ _TYAPP_ _ORIG_ PreludeCore _showList { Bool } [ _WRKR_ _CONSTM_ Text showsPrec (Bool), u0 ] _N_ }, [ [Char] ] 1 { _A_ 1 _U_ 22 _N_ _N_ _F_ _IF_ARGS_ 0 0 X 1 _CONSTM_ Text showList (Char) _N_ }, [ [Double] ] 1 { _A_ 1 _U_ 22 _N_ _N_ _F_ _IF_ARGS_ 0 0 X 1 _CONSTM_ Text showList (Double) _N_ }, [ [Int] ] 1 { _A_ 1 _U_ 22 _N_ _N_ _F_ _IF_ARGS_ 0 0 X 1 _CONSTM_ Text showList (Int) _N_ }, [ [Integer] ] 1 { _A_ 1 _U_ 22 _N_ _N_ _F_ _IF_ARGS_ 0 0 X 1 _CONSTM_ Text showList (Integer) _N_ }, [ [[Char]] ] 1 { _A_ 1 _U_ 12 _N_ _S_ "S" _F_ _IF_ARGS_ 0 1 X 3 \ (u0 :: [[Char]]) -> _APP_ _TYAPP_ _ORIG_ PreludeCore _showList { [Char] } [ _CONSTM_ Text showList (Char), u0 ] _N_ }, [ [[Int]] ] 1 { _A_ 1 _U_ 12 _N_ _S_ "S" _F_ _IF_ARGS_ 0 1 X 3 \ (u0 :: [[Int]]) -> _APP_ _TYAPP_ _ORIG_ PreludeCore _showList { [Int] } [ _CONSTM_ Text showList (Int), u0 ] _N_ }, [ [Complex Double] ] 1 { _A_ 1 _U_ 22 _N_ _N_ _F_ _IF_ARGS_ 0 0 X 1 _CONSTM_ Text showList (Complex Double) _N_ }, [ (Ratio Integer) ] 1 { _A_ 1 _U_ 12 _N_ _S_ "U(LL)" {_A_ 2 _U_ 222 _N_ _N_ _N_ _N_} _N_ _N_ }, [ (Array Int Double) ] 1 { _A_ 1 _U_ 22 _N_ _N_ _N_ _N_ }, [ (Array (Int, Int) Double) ] 1 { _A_ 1 _U_ 22 _N_ _N_ _N_ _N_ }, [ _PackedString ] 1 { _A_ 2 _U_ 12 _N_ _N_ _N_ _N_ }, [ (Complex Double) ] 1 { _A_ 1 _U_ 12 _N_ _S_ "U(LL)" {_A_ 2 _U_ 222 _N_ _N_ _N_ _N_} _N_ _N_ }, [ () ] 1 { _A_ 2 _U_ 12 _N_ _S_ "EL" _F_ _IF_ARGS_ 0 2 CX 4 \ (u0 :: ()) (u1 :: [Char]) -> case u0 of { _ALG_ _TUP_0 -> _APP_ _TYAPP_ _ORIG_ PreludeList (++) { Char } [ _NOREP_S_ "()", u1 ]; _NO_DEFLT_ } _N_ }, [ (Int, Int) ] 1 { _A_ 2 _U_ 12 _N_ _S_ "U(LL)L" {_A_ 3 _U_ 222 _N_ _N_ _N_ _N_} _N_ _N_ }, [ (Integer, Integer) ] 1 { _A_ 2 _U_ 12 _N_ _S_ "U(LL)L" {_A_ 3 _U_ 222 _N_ _N_ _N_ _N_} _N_ _N_ }, [ (Int, Int, Int) ] 1 { _A_ 2 _U_ 12 _N_ _S_ "U(LLL)L" {_A_ 4 _U_ 2222 _N_ _N_ _N_ _N_} _N_ _N_ } #-}
_showHex, _showRadix, _showDigit, -- non-std
showSpace__, -- non-std
--- lexToss__, -- non-std
readOct, readHex
) where
import Cls
import Core
-import IChar -- instances
+import IArray
+import IBool -- instances
+import IChar
+import IComplex
import IDouble
import IFloat
import IInt
import IInteger
import IList
import IRatio
+import ITup0
import ITup2
+import ITup3
import List
import Prel
import PS ( _PackedString, _unpackPS )
type ReadS a = String -> [(a,String)]
type ShowS = String -> String
--- *** instances omitted ***
+#if defined(__UNBOXED_INSTANCES__)
+{-# SPECIALIZE shows :: Int# -> String -> String = shows_Int# #-}
+{-# SPECIALIZE show :: Int# -> String = itos# #-}
+{-# SPECIALIZE showSigned :: (Int# -> ShowS) -> Int -> Int# -> ShowS = showSigned_Int# #-}
+#endif
+-- *** instances omitted ***
-{-# SPECIALIZE reads :: ReadS Int,
- ReadS Integer,
- ReadS Float,
- ReadS Double #-}
-{-# SPECIALIZE shows :: Int -> String -> String = shows_Int,
- Integer -> String -> String = shows_Integer,
- Float -> String -> String,
- Double -> String -> String #-}
-{-# SPECIALIZE show :: Char -> String,
- Int -> String = itos,
- Integer -> String = jtos,
- Float -> String,
- Double -> String,
- _PackedString -> String,
- String -> String,
- (Int,Int) -> String,
- (Integer,Integer) -> String #-}
-{-# SPECIALIZE read :: String -> Int,
- String -> Integer,
- String -> Float,
- String -> Double #-}
-
---{-# GENERATE_SPECS reads a #-}
reads :: (Text a) => ReadS a
reads = readsPrec 0
---{-# GENERATE_SPECS read a #-}
+{-# GENERATE_SPECS read a{+,Int,Integer,(),Bool,Char,Double,Rational,Ratio(Integer),Complex(Double#),Complex(Double),_PackedString,[Bool],[Char],[Int],[Double],[Float],[Integer],[Complex(Double)],[[Int]],[[Char]],(Int,Int),(Int,Int,Int),(Integer,Integer),Array(Int)(Double),Array(Int,Int)(Double)} #-}
read :: (Text a) => String -> a
read s = case [x | (x,t) <- reads s, ("","") <- lex t] of
[x] -> x
[] -> error ("read{PreludeText}: no parse:"++s++"\n")
_ -> error ("read{PreludeText}: ambiguous parse:"++s++"\n")
---{-# GENERATE_SPECS shows a{+,Int} #-}
+{-# SPECIALIZE shows :: Int -> String -> String = shows_Int,
+ Integer -> String -> String = shows_Integer #-}
+
shows :: (Text a) => a -> ShowS
shows = showsPrec 0
+shows_Int# :: Int# -> ShowS
+shows_Int# n r = itos# n ++ r -- showsPrec 0 n r
+
shows_Int :: Int -> ShowS
-shows_Int n r = itos n ++ r -- showsPrec 0 n r
+shows_Int n r = itos n ++ r -- showsPrec 0 n r
shows_Integer :: Integer -> ShowS
-shows_Integer n r = jtos n ++ r -- showsPrec 0 n r
+shows_Integer n r = jtos n ++ r -- showsPrec 0 n r
---{-# GENERATE_SPECS show a{+,Int} #-}
+{-# SPECIALIZE show :: Int -> String = itos,
+ Integer -> String = jtos #-}
+{-# GENERATE_SPECS show a{Char#,Double#,(),Bool,Char,Double,Rational,Ratio(Integer),Complex(Double#),Complex(Double),_PackedString,[Bool],[Char],[Int],[Double],[Integer],[Complex(Double)],[[Int]],[[Char]],(Int,Int),(Int,Int,Int),(Integer,Integer),Array(Int)(Double),Array(Int,Int)(Double)} #-}
show :: (Text a) => a -> String
show x = shows x ""
where
lexNest f ('-':'}':s) = f s
lexNest f ('{':'-':s) = lexNest (lexNest f) s
- lexNest f (c:s) = lexNest f s
+ lexNest f (c:s) = lexNest f s
lexNest _ "" = [] -- unterminated
-- nested comment
where cont s@(c:_) | p c = "\\&" ++ s
cont s = s
-{-# SPECIALIZE readDec :: ReadS Int, ReadS Integer #-}
--- specialisations of readInt should happen automagically
-{-# SPECIALIZE showInt :: Int -> ShowS, Integer -> ShowS #-}
+{-# GENERATE_SPECS readDec a{Int#,Int,Integer} #-}
+readDec :: (Integral a) => ReadS a
+readDec = readInt __i10 isDigit (\d -> ord d - ord_0)
-readDec, readOct, readHex :: (Integral a) => ReadS a
-readDec = readInt 10 isDigit (\d -> ord d - i_ord_0)
-readOct = readInt 8 isOctDigit (\d -> ord d - i_ord_0)
-readHex = readInt 16 isHexDigit hex
- where hex d = ord d - (if isDigit d then i_ord_0
- else ord (if isUpper d then 'A' else 'a')
- - 10)
+{-# GENERATE_SPECS readOct a{Int#,Int,Integer} #-}
+readOct :: (Integral a) => ReadS a
+readOct = readInt __i8 isOctDigit (\d -> ord d - ord_0)
+{-# GENERATE_SPECS readHex a{Int#,Int,Integer} #-}
+readHex :: (Integral a) => ReadS a
+readHex = readInt __i16 isHexDigit hex
+ where hex d = ord d - (if isDigit d then ord_0
+ else ord (if isUpper d then 'A' else 'a') - 10)
+
+{-# GENERATE_SPECS readInt a{Int#,Int,Integer} #-}
readInt :: (Integral a) => a -> (Char -> Bool) -> (Char -> Int) -> ReadS a
readInt radix isDig digToInt s =
- [(foldl1 (\n d -> n * radix + d) (map (fromIntegral . digToInt) ds), r)
+ [(foldl1 (\n d -> n * radix + d) (map (fromInt . digToInt) ds), r)
| (ds,r) <- nonnull isDig s ]
+
+{-# GENERATE_SPECS showInt a{Int#,Int,Integer} #-}
showInt :: (Integral a) => a -> ShowS
+
{- USE_REPORT_PRELUDE
showInt n r = let (n',d) = quotRem n 10
- r' = chr (i_ord_0 + fromIntegral d) : r
+ r' = chr (ord_0 + fromIntegral d) : r
in if n' == 0 then r' else showInt n' r'
-}
showInt n r
= case quotRem n 10 of { (n', d) ->
- case (chr (i_ord_0 + fromIntegral d)) of { C# c# -> -- stricter than necessary
+ case (chr (ord_0 + fromIntegral d)) of { C# c# -> -- stricter than necessary
let
r' = C# c# : r
in
if n' == 0 then r' else showInt n' r'
}}
--- #endif /* ! USE_REPORT_PRELUDE */
-
-{-# SPECIALIZE readSigned :: ReadS Int -> ReadS Int,
- ReadS Integer -> ReadS Integer,
- ReadS Double -> ReadS Double #-}
-{-# SPECIALIZE showSigned :: (Int -> ShowS) -> Int -> Int -> ShowS = showSigned_Int,
- (Integer -> ShowS) -> Int -> Integer -> ShowS = showSigned_Integer,
- (Double -> ShowS) -> Int -> Double -> ShowS #-}
-{-# SPECIALIZE readFloat :: ReadS Float,
- ReadS Double #-}
-{-# SPECIALIZE showFloat :: Float -> ShowS, Double -> ShowS #-}
+-- ******************************************************************
-readSigned:: (Real a) => ReadS a -> ReadS a
+{-# GENERATE_SPECS readSigned a{Int#,Double#,Int,Integer,Double} #-}
+readSigned :: (Real a) => ReadS a -> ReadS a
readSigned readPos = readParen False read'
where read' r = read'' r ++
[(-x,t) | ("-",s) <- lex r,
read'' r = [(n,s) | (str,s) <- lex r,
(n,"") <- readPos str]
--- ******************************************************************
-showSigned:: (Real a) => (a -> ShowS) -> Int -> a -> ShowS
+{-# SPECIALIZE showSigned :: (Int -> ShowS) -> Int -> Int -> ShowS = showSigned_Int,
+ (Integer -> ShowS) -> Int -> Integer -> ShowS = showSigned_Integer #-}
+{-# GENERATE_SPECS showSigned a{Double#,Double} #-}
+showSigned :: (Real a) => (a -> ShowS) -> Int -> a -> ShowS
showSigned showPos p x = if x < 0 then showParen (p > 6)
(showChar '-' . showPos (-x))
else showPos x
+showSigned_Int# :: (Int# -> ShowS) -> Int -> Int# -> ShowS
+showSigned_Int# _ p n r
+ = -- from HBC version; support code follows
+ if n `ltInt#` 0# && p > 6 then '(':itos# n++(')':r) else itos# n ++ r
+
showSigned_Int :: (Int -> ShowS) -> Int -> Int -> ShowS
showSigned_Int _ p n r
= -- from HBC version; support code follows
= -- from HBC version; support code follows
if n < 0 && p > 6 then '(':jtos n++(')':r) else jtos n ++ r
-itos :: Int -> String
-itos n =
- if n < 0 then
- if -n < 0 then
+
+-- ******************************************************************
+
+itos# :: Int# -> String
+itos# n =
+ if n `ltInt#` 0# then
+ if negateInt# n `ltInt#` 0# then
-- n is minInt, a difficult number
- itos (n `quot` 10) ++ itos' (-(n `rem` 10)) []
+ itos# (n `quotInt#` 10#) ++ itos' (negateInt# (n `remInt#` 10#)) []
else
- '-':itos' (-n) []
+ '-':itos' (negateInt# n) []
else
itos' n []
where
- itos' :: Int -> String -> String
+ itos' :: Int# -> String -> String
itos' n cs =
- if n < 10 then
- chr (n + i_ord_0) : cs
+ if n `ltInt#` 10# then
+ fromChar# (chr# (n `plusInt#` ord# '0'#)) : cs
else
- itos' (n `quot` 10) (chr (n `rem` 10+i_ord_0) : cs)
+ itos' (n `quotInt#` 10#) (fromChar# (chr# (n `remInt#` 10# `plusInt#` ord# '0'#)) : cs)
-i_ord_0 :: Int
-j_ord_0 :: Integer
-i_ord_0 = ord '0'
-j_ord_0 = toInteger (ord '0')
+itos :: Int -> String
+itos (I# n) = itos# n
jtos :: Integer -> String
-jtos n =
- if n < 0 then
- if -n < 0 then
- -- n is minInt, a difficult number
- jtos (n `quot` 10) ++ jtos' (-(n `rem` 10)) []
- else
- '-':jtos' (-n) []
+jtos n
+ = if n < __i0 then
+ '-' : jtos' (-n) []
else
jtos' n []
- where
- jtos' :: Integer -> String -> String
- jtos' n cs =
- if n < 10 then
- chr (fromInteger (n + j_ord_0)) : cs
- else
- jtos' (n `quot` 10) (chr (fromInteger (n `rem` 10+j_ord_0)) : cs)
+
+jtos' :: Integer -> String -> String
+jtos' n cs
+ = if n < __i10 then
+ chr (fromInteger (n + ord_0)) : cs
+ else
+ jtos' (n `quot` __i10) (chr (fromInteger (n `rem` __i10 + ord_0)) : cs)
+
+ord_0 :: Num a => a
+ord_0 = fromInt (ord '0')
+
-- ******************************************************************
-- decimal. It is often possible to use a higher-precision floating-
-- point type to obtain the same results.
+{-# GENERATE_SPECS readFloat a{Double#,Double} #-}
readFloat :: (RealFloat a) => ReadS a
readFloat r = [(fromRational x, t) | (x, t) <- readRational r]
zeros = repeat '0'
+{-# GENERATE_SPECS showFloat a{Double#,Double} #-}
showFloat:: (RealFloat a) => a -> ShowS
showFloat x =
if x == 0 then showString ("0." ++ take (m-1) zeros)
where (d:frac) = show sig
(m, sig, e) = if b == 10 then (w, s, n+w-1)
else (m', sig', e' )
- m' = _ceiling
- ((fromIntegral w * log (fromInteger b)) / log 10 :: Double)
+ m' = ceiling
+ ((fromInt w * log (fromInteger b)) / log 10 :: Double)
+ 1
- (sig', e') = if sig1 >= 10^m' then (_round (t/10), e1+1)
- else if sig1 < 10^(m'-1) then (_round (t*10), e1-1)
+ (sig', e') = if sig1 >= 10^m' then (round (t/10), e1+1)
+ else if sig1 < 10^(m'-1) then (round (t*10), e1-1)
else (sig1, e1 )
- sig1 = _round t
+ sig1 = round t
t = s%1 * (b%1)^^n * 10^^(m'-e1-1)
- e1 = _floor (logBase 10 x)
+ e1 = floor (logBase 10 x)
(s, n) = decodeFloat x
b = floatRadix x
w = floatDigits x
if n' == 0 then r' else _showRadix radix n' r'
_showDigit :: Int -> Char
-_showDigit d | d < 10 = chr (i_ord_0 + d)
+_showDigit d | d < 10 = chr (ord_0 + d)
| otherwise = chr (ord 'a' + (d - 10))
-{-# GHC_PRAGMA INTERFACE VERSION 5 #-}
+{-# GHC_PRAGMA INTERFACE VERSION 6 #-}
interface PreludeText where
import PreludeBuiltin(Char(..), Int(..), Integer(..), List(..), Tuple2)
import PreludeCore(Bool(..), Integral(..), Real(..), RealFloat(..), Text(..))
lex :: [Char] -> [([Char], [Char])]
{-# GHC_PRAGMA _A_ 1 _U_ 2 _N_ _S_ "S" _N_ _N_ #-}
read :: Text a => [Char] -> a
- {-# GHC_PRAGMA _A_ 1 _U_ 12 _N_ _S_ "U(SAAA)" {_A_ 1 _U_ 12 _N_ _N_ _N_ _N_} _N_ _SPECIALISE_ [ Double ] 1 { _A_ 1 _U_ 2 _N_ _N_ _N_ _N_ }, [ Float ] 1 { _A_ 1 _U_ 2 _N_ _N_ _N_ _N_ }, [ Int ] 1 { _A_ 1 _U_ 2 _N_ _N_ _N_ _N_ }, [ Integer ] 1 { _A_ 1 _U_ 2 _N_ _N_ _N_ _N_ } #-}
+ {-# GHC_PRAGMA _A_ 1 _U_ 12 _N_ _S_ "U(SAAA)" {_A_ 1 _U_ 12 _N_ _N_ _N_ _N_} _N_ _SPECIALISE_ [ Bool ] 1 { _A_ 1 _U_ 2 _N_ _N_ _N_ _N_ }, [ Char ] 1 { _A_ 1 _U_ 2 _N_ _N_ _N_ _N_ }, [ Double ] 1 { _A_ 1 _U_ 2 _N_ _N_ _N_ _N_ }, [ Int ] 1 { _A_ 1 _U_ 2 _N_ _N_ _N_ _N_ }, [ Integer ] 1 { _A_ 1 _U_ 2 _N_ _N_ _N_ _N_ }, [ [Bool] ] 1 { _A_ 1 _U_ 2 _N_ _N_ _N_ _N_ }, [ [Char] ] 1 { _A_ 1 _U_ 2 _N_ _N_ _N_ _N_ }, [ [Double] ] 1 { _A_ 1 _U_ 2 _N_ _N_ _N_ _N_ }, [ [Float] ] 1 { _A_ 1 _U_ 2 _N_ _N_ _N_ _N_ }, [ [Int] ] 1 { _A_ 1 _U_ 2 _N_ _N_ _N_ _N_ }, [ [Integer] ] 1 { _A_ 1 _U_ 2 _N_ _N_ _N_ _N_ }, [ [[Char]] ] 1 { _A_ 1 _U_ 2 _N_ _N_ _N_ _N_ }, [ [[Int]] ] 1 { _A_ 1 _U_ 2 _N_ _N_ _N_ _N_ }, [ [Complex Double] ] 1 { _A_ 1 _U_ 2 _N_ _N_ _N_ _N_ }, [ (Ratio Integer) ] 1 { _A_ 1 _U_ 2 _N_ _N_ _N_ _N_ }, [ (Array Int Double) ] 1 { _A_ 1 _U_ 2 _N_ _N_ _N_ _N_ }, [ (Array (Int, Int) Double) ] 1 { _A_ 1 _U_ 2 _N_ _N_ _N_ _N_ }, [ _PackedString ] 1 { _A_ 1 _U_ 2 _N_ _S_ _!_ _N_ _N_ }, [ (Complex Double) ] 1 { _A_ 1 _U_ 2 _N_ _N_ _N_ _N_ }, [ () ] 1 { _A_ 1 _U_ 2 _N_ _N_ _N_ _N_ }, [ (Int, Int) ] 1 { _A_ 1 _U_ 2 _N_ _N_ _N_ _N_ }, [ (Integer, Integer) ] 1 { _A_ 1 _U_ 2 _N_ _N_ _N_ _N_ }, [ (Int, Int, Int) ] 1 { _A_ 1 _U_ 2 _N_ _N_ _N_ _N_ } #-}
readDec :: Integral a => [Char] -> [(a, [Char])]
- {-# GHC_PRAGMA _A_ 1 _U_ 22 _N_ _N_ _N_ _SPECIALISE_ [ Int ] 1 { _A_ 1 _U_ 2 _N_ _N_ _N_ _N_ }, [ Integer ] 1 { _A_ 1 _U_ 2 _N_ _S_ "S" _N_ _N_ } #-}
+ {-# GHC_PRAGMA _A_ 1 _U_ 22 _N_ _N_ _N_ _SPECIALISE_ [ Int ] 1 { _A_ 1 _U_ 2 _N_ _N_ _N_ _N_ }, [ Integer ] 1 { _A_ 1 _U_ 2 _N_ _N_ _N_ _N_ } #-}
readFloat :: RealFloat a => [Char] -> [(a, [Char])]
- {-# GHC_PRAGMA _A_ 2 _U_ 12 _N_ _S_ "LS" _N_ _SPECIALISE_ [ Double ] 1 { _A_ 1 _U_ 2 _N_ _S_ "S" _N_ _N_ }, [ Float ] 1 { _A_ 1 _U_ 2 _N_ _S_ "S" _N_ _N_ } #-}
+ {-# GHC_PRAGMA _A_ 2 _U_ 12 _N_ _S_ "LS" _N_ _SPECIALISE_ [ Double ] 1 { _A_ 1 _U_ 2 _N_ _S_ "S" _N_ _N_ } #-}
readHex :: Integral a => [Char] -> [(a, [Char])]
- {-# GHC_PRAGMA _A_ 1 _U_ 22 _N_ _N_ _N_ _SPECIALISE_ [ Int ] 1 { _A_ 1 _U_ 2 _N_ _N_ _N_ _N_ } #-}
+ {-# GHC_PRAGMA _A_ 1 _U_ 22 _N_ _N_ _N_ _SPECIALISE_ [ Int ] 1 { _A_ 1 _U_ 2 _N_ _N_ _N_ _N_ }, [ Integer ] 1 { _A_ 1 _U_ 2 _N_ _N_ _N_ _N_ } #-}
readLitChar :: [Char] -> [(Char, [Char])]
{-# GHC_PRAGMA _A_ 0 _U_ 1 _N_ _N_ _N_ _N_ #-}
readOct :: Integral a => [Char] -> [(a, [Char])]
- {-# GHC_PRAGMA _A_ 1 _U_ 22 _N_ _N_ _N_ _SPECIALISE_ [ Int ] 1 { _A_ 1 _U_ 2 _N_ _N_ _N_ _N_ } #-}
+ {-# GHC_PRAGMA _A_ 1 _U_ 22 _N_ _N_ _N_ _SPECIALISE_ [ Int ] 1 { _A_ 1 _U_ 2 _N_ _N_ _N_ _N_ }, [ Integer ] 1 { _A_ 1 _U_ 2 _N_ _N_ _N_ _N_ } #-}
readParen :: Bool -> ([Char] -> [(a, [Char])]) -> [Char] -> [(a, [Char])]
{-# GHC_PRAGMA _A_ 2 _U_ 122 _N_ _S_ "EL" _N_ _N_ #-}
readSigned :: Real a => ([Char] -> [(a, [Char])]) -> [Char] -> [(a, [Char])]
{-# GHC_PRAGMA _A_ 2 _U_ 122 _N_ _N_ _N_ _SPECIALISE_ [ Double ] 1 { _A_ 1 _U_ 22 _N_ _N_ _N_ _N_ }, [ Int ] 1 { _A_ 1 _U_ 22 _N_ _N_ _N_ _N_ }, [ Integer ] 1 { _A_ 1 _U_ 22 _N_ _N_ _N_ _N_ } #-}
reads :: Text a => [Char] -> [(a, [Char])]
- {-# GHC_PRAGMA _A_ 1 _U_ 12 _N_ _S_ "U(SAAA)" {_A_ 1 _U_ 12 _N_ _N_ _N_ _N_} _N_ _SPECIALISE_ [ Double ] 1 { _A_ 1 _U_ 2 _N_ _N_ _N_ _N_ }, [ Float ] 1 { _A_ 1 _U_ 2 _N_ _N_ _N_ _N_ }, [ Int ] 1 { _A_ 1 _U_ 2 _N_ _N_ _N_ _N_ }, [ Integer ] 1 { _A_ 1 _U_ 2 _N_ _N_ _N_ _N_ } #-}
+ {-# GHC_PRAGMA _A_ 1 _U_ 12 _N_ _S_ "U(SAAA)" {_A_ 1 _U_ 12 _N_ _N_ _N_ _N_} _N_ _SPECIALISE_ [ Bool ] 1 { _A_ 1 _U_ 2 _N_ _N_ _N_ _N_ }, [ Char ] 1 { _A_ 0 _U_ 2 _N_ _N_ _N_ _N_ }, [ Double ] 1 { _A_ 1 _U_ 2 _N_ _N_ _N_ _N_ }, [ Int ] 1 { _A_ 1 _U_ 2 _N_ _N_ _N_ _N_ }, [ Integer ] 1 { _A_ 1 _U_ 2 _N_ _N_ _N_ _N_ }, [ [Bool] ] 1 { _A_ 0 _U_ 2 _N_ _N_ _F_ _IF_ARGS_ 0 0 X 1 _CONSTM_ Text readList (Bool) _N_ }, [ [Char] ] 1 { _A_ 0 _U_ 2 _N_ _N_ _F_ _IF_ARGS_ 0 0 X 1 _CONSTM_ Text readList (Char) _N_ }, [ [Double] ] 1 { _A_ 0 _U_ 2 _N_ _N_ _F_ _IF_ARGS_ 0 0 X 1 _CONSTM_ Text readList (Double) _N_ }, [ [Float] ] 1 { _A_ 0 _U_ 2 _N_ _N_ _N_ _N_ }, [ [Int] ] 1 { _A_ 0 _U_ 2 _N_ _N_ _F_ _IF_ARGS_ 0 0 X 1 _CONSTM_ Text readList (Int) _N_ }, [ [Integer] ] 1 { _A_ 0 _U_ 2 _N_ _N_ _F_ _IF_ARGS_ 0 0 X 1 _CONSTM_ Text readList (Integer) _N_ }, [ [[Char]] ] 1 { _A_ 0 _U_ 2 _N_ _N_ _F_ _IF_ARGS_ 0 0 X 1 _CONSTM_ Text readList ([Char]) _N_ }, [ [[Int]] ] 1 { _A_ 0 _U_ 2 _N_ _N_ _F_ _IF_ARGS_ 0 0 X 1 _CONSTM_ Text readList ([Int]) _N_ }, [ [Complex Double] ] 1 { _A_ 0 _U_ 2 _N_ _N_ _F_ _IF_ARGS_ 0 0 X 1 _CONSTM_ Text readList (Complex Double) _N_ }, [ (Ratio Integer) ] 1 { _A_ 0 _U_ 2 _N_ _N_ _N_ _N_ }, [ (Array Int Double) ] 1 { _A_ 0 _U_ 2 _N_ _N_ _N_ _N_ }, [ (Array (Int, Int) Double) ] 1 { _A_ 0 _U_ 2 _N_ _N_ _N_ _N_ }, [ _PackedString ] 1 { _A_ 1 _U_ 2 _N_ _S_ _!_ _N_ _N_ }, [ (Complex Double) ] 1 { _A_ 0 _U_ 2 _N_ _N_ _N_ _N_ }, [ () ] 1 { _A_ 0 _U_ 2 _N_ _N_ _N_ _N_ }, [ (Int, Int) ] 1 { _A_ 0 _U_ 2 _N_ _N_ _N_ _N_ }, [ (Integer, Integer) ] 1 { _A_ 0 _U_ 2 _N_ _N_ _N_ _N_ }, [ (Int, Int, Int) ] 1 { _A_ 0 _U_ 2 _N_ _N_ _N_ _N_ } #-}
show :: Text a => a -> [Char]
- {-# GHC_PRAGMA _A_ 1 _U_ 12 _N_ _S_ "U(ASAA)" {_A_ 1 _U_ 12 _N_ _N_ _N_ _N_} _N_ _SPECIALISE_ [ Char ] 1 { _A_ 1 _U_ 1 _N_ _S_ "U(P)" {_A_ 1 _U_ 2 _N_ _N_ _N_ _N_} _N_ _N_ }, [ Double ] 1 { _A_ 1 _U_ 1 _N_ _S_ "U(P)" {_A_ 1 _U_ 2 _N_ _N_ _N_ _N_} _N_ _N_ }, [ Float ] 1 { _A_ 1 _U_ 2 _N_ _N_ _N_ _N_ }, [ Int ] 1 { _A_ 1 _U_ 1 _N_ _S_ "U(P)" {_A_ 1 _U_ 2 _N_ _N_ _N_ _N_} _N_ _N_ }, [ Integer ] 1 { _A_ 1 _U_ 1 _N_ _S_ "U(PPP)" {_A_ 3 _U_ 222 _N_ _N_ _N_ _N_} _N_ _N_ }, [ [Char] ] 1 { _A_ 1 _U_ 2 _N_ _N_ _N_ _N_ }, [ _PackedString ] 1 { _A_ 1 _U_ 1 _N_ _N_ _N_ _N_ }, [ (Int, Int) ] 1 { _A_ 1 _U_ 1 _N_ _S_ "U(LL)" {_A_ 2 _U_ 22 _N_ _N_ _N_ _N_} _N_ _N_ }, [ (Integer, Integer) ] 1 { _A_ 1 _U_ 1 _N_ _S_ "U(LL)" {_A_ 2 _U_ 22 _N_ _N_ _N_ _N_} _N_ _N_ } #-}
+ {-# GHC_PRAGMA _A_ 1 _U_ 12 _N_ _S_ "U(ASAA)" {_A_ 1 _U_ 12 _N_ _N_ _N_ _N_} _N_ _SPECIALISE_ [ Bool ] 1 { _A_ 1 _U_ 2 _N_ _S_ "E" _N_ _N_ }, [ Char ] 1 { _A_ 1 _U_ 1 _N_ _S_ "U(P)" {_A_ 1 _U_ 2 _N_ _N_ _N_ _N_} _N_ _N_ }, [ Double ] 1 { _A_ 1 _U_ 1 _N_ _S_ "U(P)" {_A_ 1 _U_ 2 _N_ _N_ _N_ _N_} _N_ _N_ }, [ Int ] 1 { _A_ 1 _U_ 1 _N_ _S_ "U(P)" {_A_ 1 _U_ 2 _N_ _N_ _N_ _N_} _N_ _N_ }, [ Integer ] 1 { _A_ 1 _U_ 1 _N_ _S_ "U(PPP)" {_A_ 3 _U_ 222 _N_ _N_ _N_ _N_} _N_ _N_ }, [ [Bool] ] 1 { _A_ 1 _U_ 1 _N_ _S_ "S" _N_ _N_ }, [ [Char] ] 1 { _A_ 1 _U_ 2 _N_ _N_ _N_ _N_ }, [ [Double] ] 1 { _A_ 1 _U_ 2 _N_ _N_ _N_ _N_ }, [ [Int] ] 1 { _A_ 1 _U_ 2 _N_ _N_ _N_ _N_ }, [ [Integer] ] 1 { _A_ 1 _U_ 2 _N_ _N_ _N_ _N_ }, [ [[Char]] ] 1 { _A_ 1 _U_ 1 _N_ _S_ "S" _N_ _N_ }, [ [[Int]] ] 1 { _A_ 1 _U_ 1 _N_ _S_ "S" _N_ _N_ }, [ [Complex Double] ] 1 { _A_ 1 _U_ 2 _N_ _N_ _N_ _N_ }, [ (Ratio Integer) ] 1 { _A_ 1 _U_ 1 _N_ _S_ "U(LL)" {_A_ 2 _U_ 22 _N_ _N_ _N_ _N_} _N_ _N_ }, [ (Array Int Double) ] 1 { _A_ 1 _U_ 2 _N_ _N_ _N_ _N_ }, [ (Array (Int, Int) Double) ] 1 { _A_ 1 _U_ 2 _N_ _N_ _N_ _N_ }, [ _PackedString ] 1 { _A_ 1 _U_ 1 _N_ _N_ _N_ _N_ }, [ (Complex Double) ] 1 { _A_ 1 _U_ 1 _N_ _S_ "U(LL)" {_A_ 2 _U_ 22 _N_ _N_ _N_ _N_} _N_ _N_ }, [ () ] 1 { _A_ 1 _U_ 1 _N_ _S_ "E" _N_ _N_ }, [ (Int, Int) ] 1 { _A_ 1 _U_ 1 _N_ _S_ "U(LL)" {_A_ 2 _U_ 22 _N_ _N_ _N_ _N_} _N_ _N_ }, [ (Integer, Integer) ] 1 { _A_ 1 _U_ 1 _N_ _S_ "U(LL)" {_A_ 2 _U_ 22 _N_ _N_ _N_ _N_} _N_ _N_ }, [ (Int, Int, Int) ] 1 { _A_ 1 _U_ 1 _N_ _S_ "U(LLL)" {_A_ 3 _U_ 222 _N_ _N_ _N_ _N_} _N_ _N_ } #-}
showChar :: Char -> [Char] -> [Char]
{-# GHC_PRAGMA _A_ 2 _U_ 22 _N_ _N_ _F_ _IF_ARGS_ 0 2 XX 3 \ (u0 :: Char) (u1 :: [Char]) -> _!_ (:) [Char] [u0, u1] _N_ #-}
showFloat :: RealFloat a => a -> [Char] -> [Char]
- {-# GHC_PRAGMA _A_ 1 _U_ 122 _N_ _S_ "U(U(LU(SLLL)LAAAA)LLLALAAAA)" {_A_ 5 _U_ 1122222 _N_ _N_ _N_ _N_} _N_ _SPECIALISE_ [ Double ] 1 { _A_ 1 _U_ 12 _N_ _S_ "U(P)" {_A_ 1 _U_ 22 _N_ _N_ _N_ _N_} _N_ _N_ }, [ Float ] 1 { _A_ 0 _U_ 22 _N_ _N_ _N_ _N_ } #-}
+ {-# GHC_PRAGMA _A_ 1 _U_ 122 _N_ _S_ "U(U(AU(SAAA)AAAAL)LLLALAAAA)" {_A_ 5 _U_ 1122222 _N_ _N_ _N_ _N_} _N_ _SPECIALISE_ [ Double ] 1 { _A_ 1 _U_ 12 _N_ _S_ "U(P)" {_A_ 1 _U_ 22 _N_ _N_ _N_ _N_} _N_ _N_ } #-}
showInt :: Integral a => a -> [Char] -> [Char]
{-# GHC_PRAGMA _A_ 1 _U_ 122 _N_ _S_ "U(U(U(U(SL)LLLLLLLLL)LL)LLLLLSLLLLL)" _N_ _SPECIALISE_ [ Int ] 1 { _A_ 2 _U_ 12 _N_ _S_ "U(P)L" {_A_ 2 _U_ 22 _N_ _N_ _N_ _N_} _N_ _N_ }, [ Integer ] 1 { _A_ 2 _U_ 12 _N_ _S_ "U(PPP)L" {_A_ 4 _U_ 2222 _N_ _N_ _N_ _N_} _N_ _N_ } #-}
showLitChar :: Char -> [Char] -> [Char]
showString :: [Char] -> [Char] -> [Char]
{-# GHC_PRAGMA _A_ 2 _U_ 12 _N_ _N_ _F_ _IF_ARGS_ 0 0 X 1 _TYAPP_ _ORIG_ PreludeList (++) { Char } _N_ #-}
shows :: Text a => a -> [Char] -> [Char]
- {-# GHC_PRAGMA _A_ 1 _U_ 122 _N_ _S_ "U(ASAA)" {_A_ 1 _U_ 122 _N_ _N_ _N_ _N_} _N_ _SPECIALISE_ [ Char ] 1 { _A_ 2 _U_ 12 _N_ _S_ "U(P)L" {_A_ 2 _U_ 22 _N_ _N_ _N_ _N_} _N_ _N_ }, [ Double ] 1 { _A_ 1 _U_ 12 _N_ _S_ "U(P)" {_A_ 1 _U_ 22 _N_ _N_ _N_ _N_} _N_ _N_ }, [ Float ] 1 { _A_ 0 _U_ 22 _N_ _N_ _N_ _N_ }, [ Int ] 1 { _A_ 2 _U_ 12 _N_ _S_ "U(P)L" {_A_ 2 _U_ 22 _N_ _N_ _N_ _N_} _N_ _N_ }, [ Integer ] 1 { _A_ 2 _U_ 12 _N_ _S_ "U(PPP)L" {_A_ 4 _U_ 2222 _N_ _N_ _N_ _N_} _N_ _N_ }, [ [Char] ] 1 { _A_ 1 _U_ 22 _N_ _N_ _F_ _IF_ARGS_ 0 0 X 1 _CONSTM_ Text showList (Char) _N_ }, [ _PackedString ] 1 { _A_ 2 _U_ 12 _N_ _N_ _N_ _N_ }, [ (Int, Int) ] 1 { _A_ 2 _U_ 12 _N_ _S_ "U(LL)L" {_A_ 3 _U_ 222 _N_ _N_ _N_ _N_} _N_ _N_ }, [ (Integer, Integer) ] 1 { _A_ 2 _U_ 12 _N_ _S_ "U(LL)L" {_A_ 3 _U_ 222 _N_ _N_ _N_ _N_} _N_ _N_ } #-}
+ {-# GHC_PRAGMA _A_ 1 _U_ 122 _N_ _S_ "U(ASAA)" {_A_ 1 _U_ 122 _N_ _N_ _N_ _N_} _N_ _SPECIALISE_ [ Bool ] 1 { _A_ 2 _U_ 22 _N_ _N_ _N_ _N_ }, [ Char ] 1 { _A_ 2 _U_ 12 _N_ _S_ "U(P)L" {_A_ 2 _U_ 22 _N_ _N_ _N_ _N_} _N_ _N_ }, [ Double ] 1 { _A_ 1 _U_ 12 _N_ _S_ "U(P)" {_A_ 1 _U_ 22 _N_ _N_ _N_ _N_} _N_ _N_ }, [ Int ] 1 { _A_ 2 _U_ 12 _N_ _S_ "U(P)L" {_A_ 2 _U_ 22 _N_ _N_ _N_ _N_} _N_ _N_ }, [ Integer ] 1 { _A_ 2 _U_ 12 _N_ _S_ "U(PPP)L" {_A_ 4 _U_ 2222 _N_ _N_ _N_ _N_} _N_ _N_ }, [ [Bool] ] 1 { _A_ 1 _U_ 12 _N_ _S_ "S" _F_ _IF_ARGS_ 0 1 X 3 \ (u0 :: [Bool]) -> _APP_ _TYAPP_ _ORIG_ PreludeCore _showList { Bool } [ _WRKR_ _CONSTM_ Text showsPrec (Bool), u0 ] _N_ }, [ [Char] ] 1 { _A_ 1 _U_ 22 _N_ _N_ _F_ _IF_ARGS_ 0 0 X 1 _CONSTM_ Text showList (Char) _N_ }, [ [Double] ] 1 { _A_ 1 _U_ 22 _N_ _N_ _F_ _IF_ARGS_ 0 0 X 1 _CONSTM_ Text showList (Double) _N_ }, [ [Int] ] 1 { _A_ 1 _U_ 22 _N_ _N_ _F_ _IF_ARGS_ 0 0 X 1 _CONSTM_ Text showList (Int) _N_ }, [ [Integer] ] 1 { _A_ 1 _U_ 22 _N_ _N_ _F_ _IF_ARGS_ 0 0 X 1 _CONSTM_ Text showList (Integer) _N_ }, [ [[Char]] ] 1 { _A_ 1 _U_ 12 _N_ _S_ "S" _F_ _IF_ARGS_ 0 1 X 3 \ (u0 :: [[Char]]) -> _APP_ _TYAPP_ _ORIG_ PreludeCore _showList { [Char] } [ _CONSTM_ Text showList (Char), u0 ] _N_ }, [ [[Int]] ] 1 { _A_ 1 _U_ 12 _N_ _S_ "S" _F_ _IF_ARGS_ 0 1 X 3 \ (u0 :: [[Int]]) -> _APP_ _TYAPP_ _ORIG_ PreludeCore _showList { [Int] } [ _CONSTM_ Text showList (Int), u0 ] _N_ }, [ [Complex Double] ] 1 { _A_ 1 _U_ 22 _N_ _N_ _F_ _IF_ARGS_ 0 0 X 1 _CONSTM_ Text showList (Complex Double) _N_ }, [ (Ratio Integer) ] 1 { _A_ 1 _U_ 12 _N_ _S_ "U(LL)" {_A_ 2 _U_ 222 _N_ _N_ _N_ _N_} _N_ _N_ }, [ (Array Int Double) ] 1 { _A_ 1 _U_ 22 _N_ _N_ _N_ _N_ }, [ (Array (Int, Int) Double) ] 1 { _A_ 1 _U_ 22 _N_ _N_ _N_ _N_ }, [ _PackedString ] 1 { _A_ 2 _U_ 12 _N_ _N_ _N_ _N_ }, [ (Complex Double) ] 1 { _A_ 1 _U_ 12 _N_ _S_ "U(LL)" {_A_ 2 _U_ 222 _N_ _N_ _N_ _N_} _N_ _N_ }, [ () ] 1 { _A_ 2 _U_ 12 _N_ _S_ "EL" _F_ _IF_ARGS_ 0 2 CX 4 \ (u0 :: ()) (u1 :: [Char]) -> case u0 of { _ALG_ _TUP_0 -> _APP_ _TYAPP_ _ORIG_ PreludeList (++) { Char } [ _NOREP_S_ "()", u1 ]; _NO_DEFLT_ } _N_ }, [ (Int, Int) ] 1 { _A_ 2 _U_ 12 _N_ _S_ "U(LL)L" {_A_ 3 _U_ 222 _N_ _N_ _N_ _N_} _N_ _N_ }, [ (Integer, Integer) ] 1 { _A_ 2 _U_ 12 _N_ _S_ "U(LL)L" {_A_ 3 _U_ 222 _N_ _N_ _N_ _N_} _N_ _N_ }, [ (Int, Int, Int) ] 1 { _A_ 2 _U_ 12 _N_ _S_ "U(LLL)L" {_A_ 4 _U_ 2222 _N_ _N_ _N_ _N_} _N_ _N_ } #-}
-{-# GHC_PRAGMA INTERFACE VERSION 5 #-}
+{-# GHC_PRAGMA INTERFACE VERSION 6 #-}
interface PreludeText where
import PreludeBuiltin(Char(..), Int(..), Integer(..), List(..), Tuple2)
import PreludeCore(Bool(..), Integral(..), Real(..), RealFloat(..), Text(..))
lex :: [Char] -> [([Char], [Char])]
{-# GHC_PRAGMA _A_ 1 _U_ 2 _N_ _S_ "S" _N_ _N_ #-}
read :: Text a => [Char] -> a
- {-# GHC_PRAGMA _A_ 1 _U_ 12 _N_ _S_ "U(SAAA)" {_A_ 1 _U_ 12 _N_ _N_ _N_ _N_} _N_ _SPECIALISE_ [ Double ] 1 { _A_ 1 _U_ 2 _N_ _N_ _N_ _N_ }, [ Float ] 1 { _A_ 1 _U_ 2 _N_ _N_ _N_ _N_ }, [ Int ] 1 { _A_ 1 _U_ 2 _N_ _N_ _N_ _N_ }, [ Integer ] 1 { _A_ 1 _U_ 2 _N_ _N_ _N_ _N_ } #-}
+ {-# GHC_PRAGMA _A_ 1 _U_ 12 _N_ _S_ "U(SAAA)" {_A_ 1 _U_ 12 _N_ _N_ _N_ _N_} _N_ _SPECIALISE_ [ Bool ] 1 { _A_ 1 _U_ 2 _N_ _N_ _N_ _N_ }, [ Char ] 1 { _A_ 1 _U_ 2 _N_ _N_ _N_ _N_ }, [ Double ] 1 { _A_ 1 _U_ 2 _N_ _N_ _N_ _N_ }, [ Int ] 1 { _A_ 1 _U_ 2 _N_ _N_ _N_ _N_ }, [ Integer ] 1 { _A_ 1 _U_ 2 _N_ _N_ _N_ _N_ }, [ [Bool] ] 1 { _A_ 1 _U_ 2 _N_ _N_ _N_ _N_ }, [ [Char] ] 1 { _A_ 1 _U_ 2 _N_ _N_ _N_ _N_ }, [ [Double] ] 1 { _A_ 1 _U_ 2 _N_ _N_ _N_ _N_ }, [ [Float] ] 1 { _A_ 1 _U_ 2 _N_ _N_ _N_ _N_ }, [ [Int] ] 1 { _A_ 1 _U_ 2 _N_ _N_ _N_ _N_ }, [ [Integer] ] 1 { _A_ 1 _U_ 2 _N_ _N_ _N_ _N_ }, [ [[Char]] ] 1 { _A_ 1 _U_ 2 _N_ _N_ _N_ _N_ }, [ [[Int]] ] 1 { _A_ 1 _U_ 2 _N_ _N_ _N_ _N_ }, [ [Complex Double] ] 1 { _A_ 1 _U_ 2 _N_ _N_ _N_ _N_ }, [ (Ratio Integer) ] 1 { _A_ 1 _U_ 2 _N_ _N_ _N_ _N_ }, [ (Array Int Double) ] 1 { _A_ 1 _U_ 2 _N_ _N_ _N_ _N_ }, [ (Array (Int, Int) Double) ] 1 { _A_ 1 _U_ 2 _N_ _N_ _N_ _N_ }, [ _PackedString ] 1 { _A_ 1 _U_ 2 _N_ _S_ _!_ _N_ _N_ }, [ (Complex Double) ] 1 { _A_ 1 _U_ 2 _N_ _N_ _N_ _N_ }, [ () ] 1 { _A_ 1 _U_ 2 _N_ _N_ _N_ _N_ }, [ (Int, Int) ] 1 { _A_ 1 _U_ 2 _N_ _N_ _N_ _N_ }, [ (Integer, Integer) ] 1 { _A_ 1 _U_ 2 _N_ _N_ _N_ _N_ }, [ (Int, Int, Int) ] 1 { _A_ 1 _U_ 2 _N_ _N_ _N_ _N_ } #-}
readDec :: Integral a => [Char] -> [(a, [Char])]
- {-# GHC_PRAGMA _A_ 1 _U_ 22 _N_ _N_ _N_ _SPECIALISE_ [ Int ] 1 { _A_ 1 _U_ 2 _N_ _N_ _N_ _N_ }, [ Integer ] 1 { _A_ 1 _U_ 2 _N_ _S_ "S" _N_ _N_ } #-}
+ {-# GHC_PRAGMA _A_ 1 _U_ 22 _N_ _N_ _N_ _SPECIALISE_ [ Int ] 1 { _A_ 1 _U_ 2 _N_ _N_ _N_ _N_ }, [ Integer ] 1 { _A_ 1 _U_ 2 _N_ _N_ _N_ _N_ } #-}
readFloat :: RealFloat a => [Char] -> [(a, [Char])]
- {-# GHC_PRAGMA _A_ 2 _U_ 12 _N_ _S_ "LS" _N_ _SPECIALISE_ [ Double ] 1 { _A_ 1 _U_ 2 _N_ _S_ "S" _N_ _N_ }, [ Float ] 1 { _A_ 1 _U_ 2 _N_ _S_ "S" _N_ _N_ } #-}
+ {-# GHC_PRAGMA _A_ 2 _U_ 12 _N_ _S_ "LS" _N_ _SPECIALISE_ [ Double ] 1 { _A_ 1 _U_ 2 _N_ _S_ "S" _N_ _N_ } #-}
readHex :: Integral a => [Char] -> [(a, [Char])]
- {-# GHC_PRAGMA _A_ 1 _U_ 22 _N_ _N_ _N_ _SPECIALISE_ [ Int ] 1 { _A_ 1 _U_ 2 _N_ _N_ _N_ _N_ } #-}
+ {-# GHC_PRAGMA _A_ 1 _U_ 22 _N_ _N_ _N_ _SPECIALISE_ [ Int ] 1 { _A_ 1 _U_ 2 _N_ _N_ _N_ _N_ }, [ Integer ] 1 { _A_ 1 _U_ 2 _N_ _N_ _N_ _N_ } #-}
readLitChar :: [Char] -> [(Char, [Char])]
{-# GHC_PRAGMA _A_ 0 _U_ 1 _N_ _N_ _N_ _N_ #-}
readOct :: Integral a => [Char] -> [(a, [Char])]
- {-# GHC_PRAGMA _A_ 1 _U_ 22 _N_ _N_ _N_ _SPECIALISE_ [ Int ] 1 { _A_ 1 _U_ 2 _N_ _N_ _N_ _N_ } #-}
+ {-# GHC_PRAGMA _A_ 1 _U_ 22 _N_ _N_ _N_ _SPECIALISE_ [ Int ] 1 { _A_ 1 _U_ 2 _N_ _N_ _N_ _N_ }, [ Integer ] 1 { _A_ 1 _U_ 2 _N_ _N_ _N_ _N_ } #-}
readParen :: Bool -> ([Char] -> [(a, [Char])]) -> [Char] -> [(a, [Char])]
{-# GHC_PRAGMA _A_ 2 _U_ 122 _N_ _S_ "EL" _N_ _N_ #-}
readSigned :: Real a => ([Char] -> [(a, [Char])]) -> [Char] -> [(a, [Char])]
{-# GHC_PRAGMA _A_ 2 _U_ 122 _N_ _N_ _N_ _SPECIALISE_ [ Double ] 1 { _A_ 1 _U_ 22 _N_ _N_ _N_ _N_ }, [ Int ] 1 { _A_ 1 _U_ 22 _N_ _N_ _N_ _N_ }, [ Integer ] 1 { _A_ 1 _U_ 22 _N_ _N_ _N_ _N_ } #-}
reads :: Text a => [Char] -> [(a, [Char])]
- {-# GHC_PRAGMA _A_ 1 _U_ 12 _N_ _S_ "U(SAAA)" {_A_ 1 _U_ 12 _N_ _N_ _N_ _N_} _N_ _SPECIALISE_ [ Double ] 1 { _A_ 1 _U_ 2 _N_ _N_ _N_ _N_ }, [ Float ] 1 { _A_ 1 _U_ 2 _N_ _N_ _N_ _N_ }, [ Int ] 1 { _A_ 1 _U_ 2 _N_ _N_ _N_ _N_ }, [ Integer ] 1 { _A_ 1 _U_ 2 _N_ _N_ _N_ _N_ } #-}
+ {-# GHC_PRAGMA _A_ 1 _U_ 12 _N_ _S_ "U(SAAA)" {_A_ 1 _U_ 12 _N_ _N_ _N_ _N_} _N_ _SPECIALISE_ [ Bool ] 1 { _A_ 1 _U_ 2 _N_ _N_ _N_ _N_ }, [ Char ] 1 { _A_ 0 _U_ 2 _N_ _N_ _N_ _N_ }, [ Double ] 1 { _A_ 1 _U_ 2 _N_ _N_ _N_ _N_ }, [ Int ] 1 { _A_ 1 _U_ 2 _N_ _N_ _N_ _N_ }, [ Integer ] 1 { _A_ 1 _U_ 2 _N_ _N_ _N_ _N_ }, [ [Bool] ] 1 { _A_ 0 _U_ 2 _N_ _N_ _F_ _IF_ARGS_ 0 0 X 1 _CONSTM_ Text readList (Bool) _N_ }, [ [Char] ] 1 { _A_ 0 _U_ 2 _N_ _N_ _F_ _IF_ARGS_ 0 0 X 1 _CONSTM_ Text readList (Char) _N_ }, [ [Double] ] 1 { _A_ 0 _U_ 2 _N_ _N_ _F_ _IF_ARGS_ 0 0 X 1 _CONSTM_ Text readList (Double) _N_ }, [ [Float] ] 1 { _A_ 0 _U_ 2 _N_ _N_ _N_ _N_ }, [ [Int] ] 1 { _A_ 0 _U_ 2 _N_ _N_ _F_ _IF_ARGS_ 0 0 X 1 _CONSTM_ Text readList (Int) _N_ }, [ [Integer] ] 1 { _A_ 0 _U_ 2 _N_ _N_ _F_ _IF_ARGS_ 0 0 X 1 _CONSTM_ Text readList (Integer) _N_ }, [ [[Char]] ] 1 { _A_ 0 _U_ 2 _N_ _N_ _F_ _IF_ARGS_ 0 0 X 1 _CONSTM_ Text readList ([Char]) _N_ }, [ [[Int]] ] 1 { _A_ 0 _U_ 2 _N_ _N_ _F_ _IF_ARGS_ 0 0 X 1 _CONSTM_ Text readList ([Int]) _N_ }, [ [Complex Double] ] 1 { _A_ 0 _U_ 2 _N_ _N_ _F_ _IF_ARGS_ 0 0 X 1 _CONSTM_ Text readList (Complex Double) _N_ }, [ (Ratio Integer) ] 1 { _A_ 0 _U_ 2 _N_ _N_ _N_ _N_ }, [ (Array Int Double) ] 1 { _A_ 0 _U_ 2 _N_ _N_ _N_ _N_ }, [ (Array (Int, Int) Double) ] 1 { _A_ 0 _U_ 2 _N_ _N_ _N_ _N_ }, [ _PackedString ] 1 { _A_ 1 _U_ 2 _N_ _S_ _!_ _N_ _N_ }, [ (Complex Double) ] 1 { _A_ 0 _U_ 2 _N_ _N_ _N_ _N_ }, [ () ] 1 { _A_ 0 _U_ 2 _N_ _N_ _N_ _N_ }, [ (Int, Int) ] 1 { _A_ 0 _U_ 2 _N_ _N_ _N_ _N_ }, [ (Integer, Integer) ] 1 { _A_ 0 _U_ 2 _N_ _N_ _N_ _N_ }, [ (Int, Int, Int) ] 1 { _A_ 0 _U_ 2 _N_ _N_ _N_ _N_ } #-}
show :: Text a => a -> [Char]
- {-# GHC_PRAGMA _A_ 1 _U_ 12 _N_ _S_ "U(ASAA)" {_A_ 1 _U_ 12 _N_ _N_ _N_ _N_} _N_ _SPECIALISE_ [ Char ] 1 { _A_ 1 _U_ 1 _N_ _S_ "U(P)" {_A_ 1 _U_ 2 _N_ _N_ _N_ _N_} _N_ _N_ }, [ Double ] 1 { _A_ 1 _U_ 1 _N_ _S_ "U(P)" {_A_ 1 _U_ 2 _N_ _N_ _N_ _N_} _N_ _N_ }, [ Float ] 1 { _A_ 1 _U_ 2 _N_ _N_ _N_ _N_ }, [ Int ] 1 { _A_ 1 _U_ 1 _N_ _S_ "U(P)" {_A_ 1 _U_ 2 _N_ _N_ _N_ _N_} _N_ _N_ }, [ Integer ] 1 { _A_ 1 _U_ 1 _N_ _S_ "U(PPP)" {_A_ 3 _U_ 222 _N_ _N_ _N_ _N_} _N_ _N_ }, [ [Char] ] 1 { _A_ 1 _U_ 2 _N_ _N_ _N_ _N_ }, [ _PackedString ] 1 { _A_ 1 _U_ 1 _N_ _N_ _N_ _N_ }, [ (Int, Int) ] 1 { _A_ 1 _U_ 1 _N_ _S_ "U(LL)" {_A_ 2 _U_ 22 _N_ _N_ _N_ _N_} _N_ _N_ }, [ (Integer, Integer) ] 1 { _A_ 1 _U_ 1 _N_ _S_ "U(LL)" {_A_ 2 _U_ 22 _N_ _N_ _N_ _N_} _N_ _N_ } #-}
+ {-# GHC_PRAGMA _A_ 1 _U_ 12 _N_ _S_ "U(ASAA)" {_A_ 1 _U_ 12 _N_ _N_ _N_ _N_} _N_ _SPECIALISE_ [ Bool ] 1 { _A_ 1 _U_ 2 _N_ _S_ "E" _N_ _N_ }, [ Char ] 1 { _A_ 1 _U_ 1 _N_ _S_ "U(P)" {_A_ 1 _U_ 2 _N_ _N_ _N_ _N_} _N_ _N_ }, [ Double ] 1 { _A_ 1 _U_ 1 _N_ _S_ "U(P)" {_A_ 1 _U_ 2 _N_ _N_ _N_ _N_} _N_ _N_ }, [ Int ] 1 { _A_ 1 _U_ 1 _N_ _S_ "U(P)" {_A_ 1 _U_ 2 _N_ _N_ _N_ _N_} _N_ _N_ }, [ Integer ] 1 { _A_ 1 _U_ 1 _N_ _S_ "U(PPP)" {_A_ 3 _U_ 222 _N_ _N_ _N_ _N_} _N_ _N_ }, [ [Bool] ] 1 { _A_ 1 _U_ 1 _N_ _S_ "S" _N_ _N_ }, [ [Char] ] 1 { _A_ 1 _U_ 2 _N_ _N_ _N_ _N_ }, [ [Double] ] 1 { _A_ 1 _U_ 2 _N_ _N_ _N_ _N_ }, [ [Int] ] 1 { _A_ 1 _U_ 2 _N_ _N_ _N_ _N_ }, [ [Integer] ] 1 { _A_ 1 _U_ 2 _N_ _N_ _N_ _N_ }, [ [[Char]] ] 1 { _A_ 1 _U_ 1 _N_ _S_ "S" _N_ _N_ }, [ [[Int]] ] 1 { _A_ 1 _U_ 1 _N_ _S_ "S" _N_ _N_ }, [ [Complex Double] ] 1 { _A_ 1 _U_ 2 _N_ _N_ _N_ _N_ }, [ (Ratio Integer) ] 1 { _A_ 1 _U_ 1 _N_ _S_ "U(LL)" {_A_ 2 _U_ 22 _N_ _N_ _N_ _N_} _N_ _N_ }, [ (Array Int Double) ] 1 { _A_ 1 _U_ 2 _N_ _N_ _N_ _N_ }, [ (Array (Int, Int) Double) ] 1 { _A_ 1 _U_ 2 _N_ _N_ _N_ _N_ }, [ _PackedString ] 1 { _A_ 1 _U_ 1 _N_ _N_ _N_ _N_ }, [ (Complex Double) ] 1 { _A_ 1 _U_ 1 _N_ _S_ "U(LL)" {_A_ 2 _U_ 22 _N_ _N_ _N_ _N_} _N_ _N_ }, [ () ] 1 { _A_ 1 _U_ 1 _N_ _S_ "E" _N_ _N_ }, [ (Int, Int) ] 1 { _A_ 1 _U_ 1 _N_ _S_ "U(LL)" {_A_ 2 _U_ 22 _N_ _N_ _N_ _N_} _N_ _N_ }, [ (Integer, Integer) ] 1 { _A_ 1 _U_ 1 _N_ _S_ "U(LL)" {_A_ 2 _U_ 22 _N_ _N_ _N_ _N_} _N_ _N_ }, [ (Int, Int, Int) ] 1 { _A_ 1 _U_ 1 _N_ _S_ "U(LLL)" {_A_ 3 _U_ 222 _N_ _N_ _N_ _N_} _N_ _N_ } #-}
showChar :: Char -> [Char] -> [Char]
{-# GHC_PRAGMA _A_ 2 _U_ 22 _N_ _N_ _F_ _IF_ARGS_ 0 2 XX 3 \ (u0 :: Char) (u1 :: [Char]) -> _!_ (:) [Char] [u0, u1] _N_ #-}
showFloat :: RealFloat a => a -> [Char] -> [Char]
- {-# GHC_PRAGMA _A_ 1 _U_ 122 _N_ _S_ "U(U(LU(SLLL)LAAAA)LLLALAAAA)" {_A_ 5 _U_ 1122222 _N_ _N_ _N_ _N_} _N_ _SPECIALISE_ [ Double ] 1 { _A_ 1 _U_ 12 _N_ _S_ "U(P)" {_A_ 1 _U_ 22 _N_ _N_ _N_ _N_} _N_ _N_ }, [ Float ] 1 { _A_ 0 _U_ 22 _N_ _N_ _N_ _N_ } #-}
+ {-# GHC_PRAGMA _A_ 1 _U_ 122 _N_ _S_ "U(U(AU(SAAA)AAAAL)LLLALAAAA)" {_A_ 5 _U_ 1122222 _N_ _N_ _N_ _N_} _N_ _SPECIALISE_ [ Double ] 1 { _A_ 1 _U_ 12 _N_ _S_ "U(P)" {_A_ 1 _U_ 22 _N_ _N_ _N_ _N_} _N_ _N_ } #-}
showInt :: Integral a => a -> [Char] -> [Char]
{-# GHC_PRAGMA _A_ 1 _U_ 122 _N_ _S_ "U(U(U(U(SL)LLLLLLLLL)LL)LLLLLSLLLLL)" _N_ _SPECIALISE_ [ Int ] 1 { _A_ 2 _U_ 12 _N_ _S_ "U(P)L" {_A_ 2 _U_ 22 _N_ _N_ _N_ _N_} _N_ _N_ }, [ Integer ] 1 { _A_ 2 _U_ 12 _N_ _S_ "U(PPP)L" {_A_ 4 _U_ 2222 _N_ _N_ _N_ _N_} _N_ _N_ } #-}
showLitChar :: Char -> [Char] -> [Char]
showString :: [Char] -> [Char] -> [Char]
{-# GHC_PRAGMA _A_ 2 _U_ 12 _N_ _N_ _F_ _IF_ARGS_ 0 0 X 1 _TYAPP_ _ORIG_ PreludeList (++) { Char } _N_ #-}
shows :: Text a => a -> [Char] -> [Char]
- {-# GHC_PRAGMA _A_ 1 _U_ 122 _N_ _S_ "U(ASAA)" {_A_ 1 _U_ 122 _N_ _N_ _N_ _N_} _N_ _SPECIALISE_ [ Char ] 1 { _A_ 2 _U_ 12 _N_ _S_ "U(P)L" {_A_ 2 _U_ 22 _N_ _N_ _N_ _N_} _N_ _N_ }, [ Double ] 1 { _A_ 1 _U_ 12 _N_ _S_ "U(P)" {_A_ 1 _U_ 22 _N_ _N_ _N_ _N_} _N_ _N_ }, [ Float ] 1 { _A_ 0 _U_ 22 _N_ _N_ _N_ _N_ }, [ Int ] 1 { _A_ 2 _U_ 12 _N_ _S_ "U(P)L" {_A_ 2 _U_ 22 _N_ _N_ _N_ _N_} _N_ _N_ }, [ Integer ] 1 { _A_ 2 _U_ 12 _N_ _S_ "U(PPP)L" {_A_ 4 _U_ 2222 _N_ _N_ _N_ _N_} _N_ _N_ }, [ [Char] ] 1 { _A_ 1 _U_ 22 _N_ _N_ _F_ _IF_ARGS_ 0 0 X 1 _CONSTM_ Text showList (Char) _N_ }, [ _PackedString ] 1 { _A_ 2 _U_ 12 _N_ _N_ _N_ _N_ }, [ (Int, Int) ] 1 { _A_ 2 _U_ 12 _N_ _S_ "U(LL)L" {_A_ 3 _U_ 222 _N_ _N_ _N_ _N_} _N_ _N_ }, [ (Integer, Integer) ] 1 { _A_ 2 _U_ 12 _N_ _S_ "U(LL)L" {_A_ 3 _U_ 222 _N_ _N_ _N_ _N_} _N_ _N_ } #-}
+ {-# GHC_PRAGMA _A_ 1 _U_ 122 _N_ _S_ "U(ASAA)" {_A_ 1 _U_ 122 _N_ _N_ _N_ _N_} _N_ _SPECIALISE_ [ Bool ] 1 { _A_ 2 _U_ 22 _N_ _N_ _N_ _N_ }, [ Char ] 1 { _A_ 2 _U_ 12 _N_ _S_ "U(P)L" {_A_ 2 _U_ 22 _N_ _N_ _N_ _N_} _N_ _N_ }, [ Double ] 1 { _A_ 1 _U_ 12 _N_ _S_ "U(P)" {_A_ 1 _U_ 22 _N_ _N_ _N_ _N_} _N_ _N_ }, [ Int ] 1 { _A_ 2 _U_ 12 _N_ _S_ "U(P)L" {_A_ 2 _U_ 22 _N_ _N_ _N_ _N_} _N_ _N_ }, [ Integer ] 1 { _A_ 2 _U_ 12 _N_ _S_ "U(PPP)L" {_A_ 4 _U_ 2222 _N_ _N_ _N_ _N_} _N_ _N_ }, [ [Bool] ] 1 { _A_ 1 _U_ 12 _N_ _S_ "S" _F_ _IF_ARGS_ 0 1 X 3 \ (u0 :: [Bool]) -> _APP_ _TYAPP_ _ORIG_ PreludeCore _showList { Bool } [ _WRKR_ _CONSTM_ Text showsPrec (Bool), u0 ] _N_ }, [ [Char] ] 1 { _A_ 1 _U_ 22 _N_ _N_ _F_ _IF_ARGS_ 0 0 X 1 _CONSTM_ Text showList (Char) _N_ }, [ [Double] ] 1 { _A_ 1 _U_ 22 _N_ _N_ _F_ _IF_ARGS_ 0 0 X 1 _CONSTM_ Text showList (Double) _N_ }, [ [Int] ] 1 { _A_ 1 _U_ 22 _N_ _N_ _F_ _IF_ARGS_ 0 0 X 1 _CONSTM_ Text showList (Int) _N_ }, [ [Integer] ] 1 { _A_ 1 _U_ 22 _N_ _N_ _F_ _IF_ARGS_ 0 0 X 1 _CONSTM_ Text showList (Integer) _N_ }, [ [[Char]] ] 1 { _A_ 1 _U_ 12 _N_ _S_ "S" _F_ _IF_ARGS_ 0 1 X 3 \ (u0 :: [[Char]]) -> _APP_ _TYAPP_ _ORIG_ PreludeCore _showList { [Char] } [ _CONSTM_ Text showList (Char), u0 ] _N_ }, [ [[Int]] ] 1 { _A_ 1 _U_ 12 _N_ _S_ "S" _F_ _IF_ARGS_ 0 1 X 3 \ (u0 :: [[Int]]) -> _APP_ _TYAPP_ _ORIG_ PreludeCore _showList { [Int] } [ _CONSTM_ Text showList (Int), u0 ] _N_ }, [ [Complex Double] ] 1 { _A_ 1 _U_ 22 _N_ _N_ _F_ _IF_ARGS_ 0 0 X 1 _CONSTM_ Text showList (Complex Double) _N_ }, [ (Ratio Integer) ] 1 { _A_ 1 _U_ 12 _N_ _S_ "U(LL)" {_A_ 2 _U_ 222 _N_ _N_ _N_ _N_} _N_ _N_ }, [ (Array Int Double) ] 1 { _A_ 1 _U_ 22 _N_ _N_ _N_ _N_ }, [ (Array (Int, Int) Double) ] 1 { _A_ 1 _U_ 22 _N_ _N_ _N_ _N_ }, [ _PackedString ] 1 { _A_ 2 _U_ 12 _N_ _N_ _N_ _N_ }, [ (Complex Double) ] 1 { _A_ 1 _U_ 12 _N_ _S_ "U(LL)" {_A_ 2 _U_ 222 _N_ _N_ _N_ _N_} _N_ _N_ }, [ () ] 1 { _A_ 2 _U_ 12 _N_ _S_ "EL" _F_ _IF_ARGS_ 0 2 CX 4 \ (u0 :: ()) (u1 :: [Char]) -> case u0 of { _ALG_ _TUP_0 -> _APP_ _TYAPP_ _ORIG_ PreludeList (++) { Char } [ _NOREP_S_ "()", u1 ]; _NO_DEFLT_ } _N_ }, [ (Int, Int) ] 1 { _A_ 2 _U_ 12 _N_ _S_ "U(LL)L" {_A_ 3 _U_ 222 _N_ _N_ _N_ _N_} _N_ _N_ }, [ (Integer, Integer) ] 1 { _A_ 2 _U_ 12 _N_ _S_ "U(LL)L" {_A_ 3 _U_ 222 _N_ _N_ _N_ _N_} _N_ _N_ }, [ (Int, Int, Int) ] 1 { _A_ 2 _U_ 12 _N_ _S_ "U(LLL)L" {_A_ 4 _U_ 2222 _N_ _N_ _N_ _N_} _N_ _N_ } #-}
-{-# GHC_PRAGMA INTERFACE VERSION 5 #-}
+{-# GHC_PRAGMA INTERFACE VERSION 6 #-}
interface PreludeText where
import PreludeBuiltin(Char(..), Int(..), Integer(..), List(..), Tuple2)
import PreludeCore(Bool(..), Integral(..), Real(..), RealFloat(..), Text(..))
lex :: [Char] -> [([Char], [Char])]
{-# GHC_PRAGMA _A_ 1 _U_ 2 _N_ _S_ "S" _N_ _N_ #-}
read :: Text a => [Char] -> a
- {-# GHC_PRAGMA _A_ 1 _U_ 12 _N_ _S_ "U(SAAA)" {_A_ 1 _U_ 12 _N_ _N_ _N_ _N_} _N_ _SPECIALISE_ [ Double ] 1 { _A_ 1 _U_ 2 _N_ _N_ _N_ _N_ }, [ Float ] 1 { _A_ 1 _U_ 2 _N_ _N_ _N_ _N_ }, [ Int ] 1 { _A_ 1 _U_ 2 _N_ _N_ _N_ _N_ }, [ Integer ] 1 { _A_ 1 _U_ 2 _N_ _N_ _N_ _N_ } #-}
+ {-# GHC_PRAGMA _A_ 1 _U_ 12 _N_ _S_ "U(SAAA)" {_A_ 1 _U_ 12 _N_ _N_ _N_ _N_} _N_ _SPECIALISE_ [ Bool ] 1 { _A_ 1 _U_ 2 _N_ _N_ _N_ _N_ }, [ Char ] 1 { _A_ 1 _U_ 2 _N_ _N_ _N_ _N_ }, [ Double ] 1 { _A_ 1 _U_ 2 _N_ _N_ _N_ _N_ }, [ Int ] 1 { _A_ 1 _U_ 2 _N_ _N_ _N_ _N_ }, [ Integer ] 1 { _A_ 1 _U_ 2 _N_ _N_ _N_ _N_ }, [ [Bool] ] 1 { _A_ 1 _U_ 2 _N_ _N_ _N_ _N_ }, [ [Char] ] 1 { _A_ 1 _U_ 2 _N_ _N_ _N_ _N_ }, [ [Double] ] 1 { _A_ 1 _U_ 2 _N_ _N_ _N_ _N_ }, [ [Float] ] 1 { _A_ 1 _U_ 2 _N_ _N_ _N_ _N_ }, [ [Int] ] 1 { _A_ 1 _U_ 2 _N_ _N_ _N_ _N_ }, [ [Integer] ] 1 { _A_ 1 _U_ 2 _N_ _N_ _N_ _N_ }, [ [[Char]] ] 1 { _A_ 1 _U_ 2 _N_ _N_ _N_ _N_ }, [ [[Int]] ] 1 { _A_ 1 _U_ 2 _N_ _N_ _N_ _N_ }, [ [Complex Double] ] 1 { _A_ 1 _U_ 2 _N_ _N_ _N_ _N_ }, [ (Ratio Integer) ] 1 { _A_ 1 _U_ 2 _N_ _N_ _N_ _N_ }, [ (Array Int Double) ] 1 { _A_ 1 _U_ 2 _N_ _N_ _N_ _N_ }, [ (Array (Int, Int) Double) ] 1 { _A_ 1 _U_ 2 _N_ _N_ _N_ _N_ }, [ _PackedString ] 1 { _A_ 1 _U_ 2 _N_ _S_ _!_ _N_ _N_ }, [ (Complex Double) ] 1 { _A_ 1 _U_ 2 _N_ _N_ _N_ _N_ }, [ () ] 1 { _A_ 1 _U_ 2 _N_ _N_ _N_ _N_ }, [ (Int, Int) ] 1 { _A_ 1 _U_ 2 _N_ _N_ _N_ _N_ }, [ (Integer, Integer) ] 1 { _A_ 1 _U_ 2 _N_ _N_ _N_ _N_ }, [ (Int, Int, Int) ] 1 { _A_ 1 _U_ 2 _N_ _N_ _N_ _N_ } #-}
readDec :: Integral a => [Char] -> [(a, [Char])]
- {-# GHC_PRAGMA _A_ 1 _U_ 22 _N_ _N_ _N_ _SPECIALISE_ [ Int ] 1 { _A_ 0 _U_ 2 _N_ _N_ _N_ _N_ }, [ Integer ] 1 { _A_ 1 _U_ 2 _N_ _S_ "S" _N_ _N_ } #-}
+ {-# GHC_PRAGMA _A_ 1 _U_ 22 _N_ _N_ _N_ _SPECIALISE_ [ Int ] 1 { _A_ 0 _U_ 2 _N_ _N_ _N_ _N_ }, [ Integer ] 1 { _A_ 0 _U_ 2 _N_ _N_ _N_ _N_ } #-}
readFloat :: RealFloat a => [Char] -> [(a, [Char])]
- {-# GHC_PRAGMA _A_ 2 _U_ 12 _N_ _S_ "LS" _N_ _SPECIALISE_ [ Double ] 1 { _A_ 1 _U_ 2 _N_ _S_ "S" _N_ _N_ }, [ Float ] 1 { _A_ 1 _U_ 2 _N_ _S_ "S" _N_ _N_ } #-}
+ {-# GHC_PRAGMA _A_ 2 _U_ 12 _N_ _S_ "LS" _N_ _SPECIALISE_ [ Double ] 1 { _A_ 1 _U_ 2 _N_ _S_ "S" _N_ _N_ } #-}
readHex :: Integral a => [Char] -> [(a, [Char])]
- {-# GHC_PRAGMA _A_ 1 _U_ 22 _N_ _N_ _N_ _SPECIALISE_ [ Int ] 1 { _A_ 0 _U_ 2 _N_ _N_ _N_ _N_ } #-}
+ {-# GHC_PRAGMA _A_ 1 _U_ 22 _N_ _N_ _N_ _SPECIALISE_ [ Int ] 1 { _A_ 0 _U_ 2 _N_ _N_ _N_ _N_ }, [ Integer ] 1 { _A_ 0 _U_ 2 _N_ _N_ _N_ _N_ } #-}
readLitChar :: [Char] -> [(Char, [Char])]
{-# GHC_PRAGMA _A_ 0 _U_ 1 _N_ _N_ _N_ _N_ #-}
readOct :: Integral a => [Char] -> [(a, [Char])]
- {-# GHC_PRAGMA _A_ 1 _U_ 22 _N_ _N_ _N_ _SPECIALISE_ [ Int ] 1 { _A_ 0 _U_ 2 _N_ _N_ _N_ _N_ } #-}
+ {-# GHC_PRAGMA _A_ 1 _U_ 22 _N_ _N_ _N_ _SPECIALISE_ [ Int ] 1 { _A_ 0 _U_ 2 _N_ _N_ _N_ _N_ }, [ Integer ] 1 { _A_ 0 _U_ 2 _N_ _N_ _N_ _N_ } #-}
readParen :: Bool -> ([Char] -> [(a, [Char])]) -> [Char] -> [(a, [Char])]
{-# GHC_PRAGMA _A_ 2 _U_ 122 _N_ _S_ "EL" _N_ _N_ #-}
readSigned :: Real a => ([Char] -> [(a, [Char])]) -> [Char] -> [(a, [Char])]
{-# GHC_PRAGMA _A_ 2 _U_ 122 _N_ _N_ _N_ _SPECIALISE_ [ Double ] 1 { _A_ 1 _U_ 22 _N_ _N_ _N_ _N_ }, [ Int ] 1 { _A_ 1 _U_ 22 _N_ _N_ _N_ _N_ }, [ Integer ] 1 { _A_ 1 _U_ 22 _N_ _N_ _N_ _N_ } #-}
reads :: Text a => [Char] -> [(a, [Char])]
- {-# GHC_PRAGMA _A_ 1 _U_ 12 _N_ _S_ "U(SAAA)" {_A_ 1 _U_ 12 _N_ _N_ _N_ _N_} _N_ _SPECIALISE_ [ Double ] 1 { _A_ 1 _U_ 2 _N_ _N_ _N_ _N_ }, [ Float ] 1 { _A_ 1 _U_ 2 _N_ _N_ _N_ _N_ }, [ Int ] 1 { _A_ 1 _U_ 2 _N_ _N_ _N_ _N_ }, [ Integer ] 1 { _A_ 1 _U_ 2 _N_ _N_ _N_ _N_ } #-}
+ {-# GHC_PRAGMA _A_ 1 _U_ 12 _N_ _S_ "U(SAAA)" {_A_ 1 _U_ 12 _N_ _N_ _N_ _N_} _N_ _SPECIALISE_ [ Bool ] 1 { _A_ 1 _U_ 2 _N_ _N_ _N_ _N_ }, [ Char ] 1 { _A_ 0 _U_ 2 _N_ _N_ _N_ _N_ }, [ Double ] 1 { _A_ 1 _U_ 2 _N_ _N_ _N_ _N_ }, [ Int ] 1 { _A_ 1 _U_ 2 _N_ _N_ _N_ _N_ }, [ Integer ] 1 { _A_ 1 _U_ 2 _N_ _N_ _N_ _N_ }, [ [Bool] ] 1 { _A_ 0 _U_ 2 _N_ _N_ _F_ _IF_ARGS_ 0 0 X 1 _CONSTM_ Text readList (Bool) _N_ }, [ [Char] ] 1 { _A_ 0 _U_ 2 _N_ _N_ _F_ _IF_ARGS_ 0 0 X 1 _CONSTM_ Text readList (Char) _N_ }, [ [Double] ] 1 { _A_ 0 _U_ 2 _N_ _N_ _F_ _IF_ARGS_ 0 0 X 1 _CONSTM_ Text readList (Double) _N_ }, [ [Float] ] 1 { _A_ 0 _U_ 2 _N_ _N_ _N_ _N_ }, [ [Int] ] 1 { _A_ 0 _U_ 2 _N_ _N_ _F_ _IF_ARGS_ 0 0 X 1 _CONSTM_ Text readList (Int) _N_ }, [ [Integer] ] 1 { _A_ 0 _U_ 2 _N_ _N_ _F_ _IF_ARGS_ 0 0 X 1 _CONSTM_ Text readList (Integer) _N_ }, [ [[Char]] ] 1 { _A_ 0 _U_ 2 _N_ _N_ _F_ _IF_ARGS_ 0 0 X 1 _CONSTM_ Text readList ([Char]) _N_ }, [ [[Int]] ] 1 { _A_ 0 _U_ 2 _N_ _N_ _F_ _IF_ARGS_ 0 0 X 1 _CONSTM_ Text readList ([Int]) _N_ }, [ [Complex Double] ] 1 { _A_ 0 _U_ 2 _N_ _N_ _F_ _IF_ARGS_ 0 0 X 1 _CONSTM_ Text readList (Complex Double) _N_ }, [ (Ratio Integer) ] 1 { _A_ 0 _U_ 2 _N_ _N_ _N_ _N_ }, [ (Array Int Double) ] 1 { _A_ 0 _U_ 2 _N_ _N_ _N_ _N_ }, [ (Array (Int, Int) Double) ] 1 { _A_ 0 _U_ 2 _N_ _N_ _N_ _N_ }, [ _PackedString ] 1 { _A_ 1 _U_ 2 _N_ _S_ _!_ _N_ _N_ }, [ (Complex Double) ] 1 { _A_ 0 _U_ 2 _N_ _N_ _N_ _N_ }, [ () ] 1 { _A_ 0 _U_ 2 _N_ _N_ _N_ _N_ }, [ (Int, Int) ] 1 { _A_ 0 _U_ 2 _N_ _N_ _N_ _N_ }, [ (Integer, Integer) ] 1 { _A_ 0 _U_ 2 _N_ _N_ _N_ _N_ }, [ (Int, Int, Int) ] 1 { _A_ 0 _U_ 2 _N_ _N_ _N_ _N_ } #-}
show :: Text a => a -> [Char]
- {-# GHC_PRAGMA _A_ 1 _U_ 12 _N_ _S_ "U(ASAA)" {_A_ 1 _U_ 12 _N_ _N_ _N_ _N_} _N_ _SPECIALISE_ [ Char ] 1 { _A_ 1 _U_ 1 _N_ _S_ "U(P)" {_A_ 1 _U_ 2 _N_ _N_ _N_ _N_} _N_ _N_ }, [ Double ] 1 { _A_ 1 _U_ 1 _N_ _S_ "U(P)" {_A_ 1 _U_ 2 _N_ _N_ _N_ _N_} _N_ _N_ }, [ Float ] 1 { _A_ 1 _U_ 2 _N_ _N_ _N_ _N_ }, [ Int ] 1 { _A_ 1 _U_ 1 _N_ _S_ "U(P)" {_A_ 1 _U_ 2 _N_ _N_ _N_ _N_} _N_ _N_ }, [ Integer ] 1 { _A_ 1 _U_ 1 _N_ _S_ "U(PPP)" {_A_ 3 _U_ 222 _N_ _N_ _N_ _N_} _N_ _N_ }, [ [Char] ] 1 { _A_ 1 _U_ 2 _N_ _N_ _N_ _N_ }, [ _PackedString ] 1 { _A_ 1 _U_ 1 _N_ _N_ _N_ _N_ }, [ (Int, Int) ] 1 { _A_ 1 _U_ 1 _N_ _S_ "U(LL)" {_A_ 2 _U_ 22 _N_ _N_ _N_ _N_} _N_ _N_ }, [ (Integer, Integer) ] 1 { _A_ 1 _U_ 1 _N_ _S_ "U(LL)" {_A_ 2 _U_ 22 _N_ _N_ _N_ _N_} _N_ _N_ } #-}
+ {-# GHC_PRAGMA _A_ 1 _U_ 12 _N_ _S_ "U(ASAA)" {_A_ 1 _U_ 12 _N_ _N_ _N_ _N_} _N_ _SPECIALISE_ [ Bool ] 1 { _A_ 1 _U_ 2 _N_ _S_ "E" _N_ _N_ }, [ Char ] 1 { _A_ 1 _U_ 1 _N_ _S_ "U(P)" {_A_ 1 _U_ 2 _N_ _N_ _N_ _N_} _N_ _N_ }, [ Double ] 1 { _A_ 1 _U_ 1 _N_ _S_ "U(P)" {_A_ 1 _U_ 2 _N_ _N_ _N_ _N_} _N_ _N_ }, [ Int ] 1 { _A_ 1 _U_ 1 _N_ _S_ "U(P)" {_A_ 1 _U_ 2 _N_ _N_ _N_ _N_} _N_ _N_ }, [ Integer ] 1 { _A_ 1 _U_ 1 _N_ _S_ "U(PPP)" {_A_ 3 _U_ 222 _N_ _N_ _N_ _N_} _N_ _N_ }, [ [Bool] ] 1 { _A_ 1 _U_ 1 _N_ _S_ "S" _N_ _N_ }, [ [Char] ] 1 { _A_ 1 _U_ 2 _N_ _N_ _N_ _N_ }, [ [Double] ] 1 { _A_ 1 _U_ 2 _N_ _N_ _N_ _N_ }, [ [Int] ] 1 { _A_ 1 _U_ 2 _N_ _N_ _N_ _N_ }, [ [Integer] ] 1 { _A_ 1 _U_ 2 _N_ _N_ _N_ _N_ }, [ [[Char]] ] 1 { _A_ 1 _U_ 1 _N_ _S_ "S" _N_ _N_ }, [ [[Int]] ] 1 { _A_ 1 _U_ 1 _N_ _S_ "S" _N_ _N_ }, [ [Complex Double] ] 1 { _A_ 1 _U_ 2 _N_ _N_ _N_ _N_ }, [ (Ratio Integer) ] 1 { _A_ 1 _U_ 1 _N_ _S_ "U(LL)" {_A_ 2 _U_ 22 _N_ _N_ _N_ _N_} _N_ _N_ }, [ (Array Int Double) ] 1 { _A_ 1 _U_ 2 _N_ _N_ _N_ _N_ }, [ (Array (Int, Int) Double) ] 1 { _A_ 1 _U_ 2 _N_ _N_ _N_ _N_ }, [ _PackedString ] 1 { _A_ 1 _U_ 1 _N_ _N_ _N_ _N_ }, [ (Complex Double) ] 1 { _A_ 1 _U_ 1 _N_ _S_ "U(LL)" {_A_ 2 _U_ 22 _N_ _N_ _N_ _N_} _N_ _N_ }, [ () ] 1 { _A_ 1 _U_ 1 _N_ _S_ "E" _N_ _N_ }, [ (Int, Int) ] 1 { _A_ 1 _U_ 1 _N_ _S_ "U(LL)" {_A_ 2 _U_ 22 _N_ _N_ _N_ _N_} _N_ _N_ }, [ (Integer, Integer) ] 1 { _A_ 1 _U_ 1 _N_ _S_ "U(LL)" {_A_ 2 _U_ 22 _N_ _N_ _N_ _N_} _N_ _N_ }, [ (Int, Int, Int) ] 1 { _A_ 1 _U_ 1 _N_ _S_ "U(LLL)" {_A_ 3 _U_ 222 _N_ _N_ _N_ _N_} _N_ _N_ } #-}
showChar :: Char -> [Char] -> [Char]
{-# GHC_PRAGMA _A_ 2 _U_ 22 _N_ _N_ _F_ _IF_ARGS_ 0 2 XX 3 \ (u0 :: Char) (u1 :: [Char]) -> _!_ (:) [Char] [u0, u1] _N_ #-}
showFloat :: RealFloat a => a -> [Char] -> [Char]
- {-# GHC_PRAGMA _A_ 1 _U_ 122 _N_ _S_ "U(U(LU(SLLL)LAAAA)LLLALAAAA)" {_A_ 5 _U_ 1122222 _N_ _N_ _N_ _N_} _N_ _SPECIALISE_ [ Double ] 1 { _A_ 1 _U_ 12 _N_ _S_ "U(P)" {_A_ 1 _U_ 22 _N_ _N_ _N_ _N_} _N_ _N_ }, [ Float ] 1 { _A_ 0 _U_ 22 _N_ _N_ _N_ _N_ } #-}
+ {-# GHC_PRAGMA _A_ 1 _U_ 122 _N_ _S_ "U(U(AU(SAAA)AAAAL)LLLALAAAA)" {_A_ 5 _U_ 1122222 _N_ _N_ _N_ _N_} _N_ _SPECIALISE_ [ Double ] 1 { _A_ 1 _U_ 12 _N_ _S_ "U(P)" {_A_ 1 _U_ 22 _N_ _N_ _N_ _N_} _N_ _N_ } #-}
showInt :: Integral a => a -> [Char] -> [Char]
{-# GHC_PRAGMA _A_ 1 _U_ 222 _N_ _S_ "U(U(U(U(SL)LLLLLLLLL)LL)LLLLLSLLLLL)" _N_ _SPECIALISE_ [ Int ] 1 { _A_ 2 _U_ 12 _N_ _S_ "U(P)L" {_A_ 2 _U_ 22 _N_ _N_ _N_ _N_} _N_ _N_ }, [ Integer ] 1 { _A_ 2 _U_ 12 _N_ _S_ "U(PPP)L" {_A_ 4 _U_ 2222 _N_ _N_ _N_ _N_} _N_ _N_ } #-}
showLitChar :: Char -> [Char] -> [Char]
showString :: [Char] -> [Char] -> [Char]
{-# GHC_PRAGMA _A_ 2 _U_ 12 _N_ _N_ _F_ _IF_ARGS_ 0 0 X 1 _TYAPP_ _ORIG_ PreludeList (++) { Char } _N_ #-}
shows :: Text a => a -> [Char] -> [Char]
- {-# GHC_PRAGMA _A_ 1 _U_ 122 _N_ _S_ "U(ASAA)" {_A_ 1 _U_ 122 _N_ _N_ _N_ _N_} _N_ _SPECIALISE_ [ Char ] 1 { _A_ 2 _U_ 12 _N_ _S_ "U(P)L" {_A_ 2 _U_ 22 _N_ _N_ _N_ _N_} _N_ _N_ }, [ Double ] 1 { _A_ 1 _U_ 12 _N_ _S_ "U(P)" {_A_ 1 _U_ 22 _N_ _N_ _N_ _N_} _N_ _N_ }, [ Float ] 1 { _A_ 0 _U_ 22 _N_ _N_ _N_ _N_ }, [ Int ] 1 { _A_ 2 _U_ 12 _N_ _S_ "U(P)L" {_A_ 2 _U_ 22 _N_ _N_ _N_ _N_} _N_ _N_ }, [ Integer ] 1 { _A_ 2 _U_ 12 _N_ _S_ "U(PPP)L" {_A_ 4 _U_ 2222 _N_ _N_ _N_ _N_} _N_ _N_ }, [ [Char] ] 1 { _A_ 1 _U_ 22 _N_ _N_ _F_ _IF_ARGS_ 0 0 X 1 _CONSTM_ Text showList (Char) _N_ }, [ _PackedString ] 1 { _A_ 2 _U_ 12 _N_ _N_ _N_ _N_ }, [ (Int, Int) ] 1 { _A_ 2 _U_ 12 _N_ _S_ "U(LL)L" {_A_ 3 _U_ 222 _N_ _N_ _N_ _N_} _N_ _N_ }, [ (Integer, Integer) ] 1 { _A_ 2 _U_ 12 _N_ _S_ "U(LL)L" {_A_ 3 _U_ 222 _N_ _N_ _N_ _N_} _N_ _N_ } #-}
+ {-# GHC_PRAGMA _A_ 1 _U_ 122 _N_ _S_ "U(ASAA)" {_A_ 1 _U_ 122 _N_ _N_ _N_ _N_} _N_ _SPECIALISE_ [ Bool ] 1 { _A_ 2 _U_ 22 _N_ _N_ _N_ _N_ }, [ Char ] 1 { _A_ 2 _U_ 12 _N_ _S_ "U(P)L" {_A_ 2 _U_ 22 _N_ _N_ _N_ _N_} _N_ _N_ }, [ Double ] 1 { _A_ 1 _U_ 12 _N_ _S_ "U(P)" {_A_ 1 _U_ 22 _N_ _N_ _N_ _N_} _N_ _N_ }, [ Int ] 1 { _A_ 2 _U_ 12 _N_ _S_ "U(P)L" {_A_ 2 _U_ 22 _N_ _N_ _N_ _N_} _N_ _N_ }, [ Integer ] 1 { _A_ 2 _U_ 12 _N_ _S_ "U(PPP)L" {_A_ 4 _U_ 2222 _N_ _N_ _N_ _N_} _N_ _N_ }, [ [Bool] ] 1 { _A_ 1 _U_ 12 _N_ _S_ "S" _F_ _IF_ARGS_ 0 1 X 3 \ (u0 :: [Bool]) -> _APP_ _TYAPP_ _ORIG_ PreludeCore _showList { Bool } [ _WRKR_ _CONSTM_ Text showsPrec (Bool), u0 ] _N_ }, [ [Char] ] 1 { _A_ 1 _U_ 22 _N_ _N_ _F_ _IF_ARGS_ 0 0 X 1 _CONSTM_ Text showList (Char) _N_ }, [ [Double] ] 1 { _A_ 1 _U_ 22 _N_ _N_ _F_ _IF_ARGS_ 0 0 X 1 _CONSTM_ Text showList (Double) _N_ }, [ [Int] ] 1 { _A_ 1 _U_ 22 _N_ _N_ _F_ _IF_ARGS_ 0 0 X 1 _CONSTM_ Text showList (Int) _N_ }, [ [Integer] ] 1 { _A_ 1 _U_ 22 _N_ _N_ _F_ _IF_ARGS_ 0 0 X 1 _CONSTM_ Text showList (Integer) _N_ }, [ [[Char]] ] 1 { _A_ 1 _U_ 12 _N_ _S_ "S" _F_ _IF_ARGS_ 0 1 X 3 \ (u0 :: [[Char]]) -> _APP_ _TYAPP_ _ORIG_ PreludeCore _showList { [Char] } [ _CONSTM_ Text showList (Char), u0 ] _N_ }, [ [[Int]] ] 1 { _A_ 1 _U_ 12 _N_ _S_ "S" _F_ _IF_ARGS_ 0 1 X 3 \ (u0 :: [[Int]]) -> _APP_ _TYAPP_ _ORIG_ PreludeCore _showList { [Int] } [ _CONSTM_ Text showList (Int), u0 ] _N_ }, [ [Complex Double] ] 1 { _A_ 1 _U_ 22 _N_ _N_ _F_ _IF_ARGS_ 0 0 X 1 _CONSTM_ Text showList (Complex Double) _N_ }, [ (Ratio Integer) ] 1 { _A_ 1 _U_ 12 _N_ _S_ "U(LL)" {_A_ 2 _U_ 222 _N_ _N_ _N_ _N_} _N_ _N_ }, [ (Array Int Double) ] 1 { _A_ 1 _U_ 22 _N_ _N_ _N_ _N_ }, [ (Array (Int, Int) Double) ] 1 { _A_ 1 _U_ 22 _N_ _N_ _N_ _N_ }, [ _PackedString ] 1 { _A_ 2 _U_ 12 _N_ _N_ _N_ _N_ }, [ (Complex Double) ] 1 { _A_ 1 _U_ 12 _N_ _S_ "U(LL)" {_A_ 2 _U_ 222 _N_ _N_ _N_ _N_} _N_ _N_ }, [ () ] 1 { _A_ 2 _U_ 12 _N_ _S_ "EL" _F_ _IF_ARGS_ 0 2 CX 4 \ (u0 :: ()) (u1 :: [Char]) -> case u0 of { _ALG_ _TUP_0 -> _APP_ _TYAPP_ _ORIG_ PreludeList (++) { Char } [ _NOREP_S_ "()", u1 ]; _NO_DEFLT_ } _N_ }, [ (Int, Int) ] 1 { _A_ 2 _U_ 12 _N_ _S_ "U(LL)L" {_A_ 3 _U_ 222 _N_ _N_ _N_ _N_} _N_ _N_ }, [ (Integer, Integer) ] 1 { _A_ 2 _U_ 12 _N_ _S_ "U(LL)L" {_A_ 3 _U_ 222 _N_ _N_ _N_ _N_} _N_ _N_ }, [ (Int, Int, Int) ] 1 { _A_ 2 _U_ 12 _N_ _S_ "U(LLL)L" {_A_ 4 _U_ 2222 _N_ _N_ _N_ _N_} _N_ _N_ } #-}
-{-# GHC_PRAGMA INTERFACE VERSION 5 #-}
+{-# GHC_PRAGMA INTERFACE VERSION 6 #-}
interface PreludeText where
import PreludeBuiltin(Char(..), Int(..), Integer(..), List(..), Tuple2)
import PreludeCore(Bool(..), Integral(..), Real(..), RealFloat(..), Text(..))
lex :: [Char] -> [([Char], [Char])]
{-# GHC_PRAGMA _A_ 1 _U_ 2 _N_ _S_ "S" _N_ _N_ #-}
read :: Text a => [Char] -> a
- {-# GHC_PRAGMA _A_ 1 _U_ 12 _N_ _S_ "U(SAAA)" {_A_ 1 _U_ 12 _N_ _N_ _N_ _N_} _N_ _SPECIALISE_ [ Double ] 1 { _A_ 1 _U_ 2 _N_ _N_ _N_ _N_ }, [ Float ] 1 { _A_ 1 _U_ 2 _N_ _N_ _N_ _N_ }, [ Int ] 1 { _A_ 1 _U_ 2 _N_ _N_ _N_ _N_ }, [ Integer ] 1 { _A_ 1 _U_ 2 _N_ _N_ _N_ _N_ } #-}
+ {-# GHC_PRAGMA _A_ 1 _U_ 12 _N_ _S_ "U(SAAA)" {_A_ 1 _U_ 12 _N_ _N_ _N_ _N_} _N_ _SPECIALISE_ [ Bool ] 1 { _A_ 1 _U_ 2 _N_ _N_ _N_ _N_ }, [ Char ] 1 { _A_ 1 _U_ 2 _N_ _N_ _N_ _N_ }, [ Double ] 1 { _A_ 1 _U_ 2 _N_ _N_ _N_ _N_ }, [ Int ] 1 { _A_ 1 _U_ 2 _N_ _N_ _N_ _N_ }, [ Integer ] 1 { _A_ 1 _U_ 2 _N_ _N_ _N_ _N_ }, [ [Bool] ] 1 { _A_ 1 _U_ 2 _N_ _N_ _N_ _N_ }, [ [Char] ] 1 { _A_ 1 _U_ 2 _N_ _N_ _N_ _N_ }, [ [Double] ] 1 { _A_ 1 _U_ 2 _N_ _N_ _N_ _N_ }, [ [Float] ] 1 { _A_ 1 _U_ 2 _N_ _N_ _N_ _N_ }, [ [Int] ] 1 { _A_ 1 _U_ 2 _N_ _N_ _N_ _N_ }, [ [Integer] ] 1 { _A_ 1 _U_ 2 _N_ _N_ _N_ _N_ }, [ [[Char]] ] 1 { _A_ 1 _U_ 2 _N_ _N_ _N_ _N_ }, [ [[Int]] ] 1 { _A_ 1 _U_ 2 _N_ _N_ _N_ _N_ }, [ [Complex Double] ] 1 { _A_ 1 _U_ 2 _N_ _N_ _N_ _N_ }, [ (Ratio Integer) ] 1 { _A_ 1 _U_ 2 _N_ _N_ _N_ _N_ }, [ (Array Int Double) ] 1 { _A_ 1 _U_ 2 _N_ _N_ _N_ _N_ }, [ (Array (Int, Int) Double) ] 1 { _A_ 1 _U_ 2 _N_ _N_ _N_ _N_ }, [ _PackedString ] 1 { _A_ 1 _U_ 2 _N_ _S_ _!_ _N_ _N_ }, [ (Complex Double) ] 1 { _A_ 1 _U_ 2 _N_ _N_ _N_ _N_ }, [ () ] 1 { _A_ 1 _U_ 2 _N_ _N_ _N_ _N_ }, [ (Int, Int) ] 1 { _A_ 1 _U_ 2 _N_ _N_ _N_ _N_ }, [ (Integer, Integer) ] 1 { _A_ 1 _U_ 2 _N_ _N_ _N_ _N_ }, [ (Int, Int, Int) ] 1 { _A_ 1 _U_ 2 _N_ _N_ _N_ _N_ } #-}
readDec :: Integral a => [Char] -> [(a, [Char])]
- {-# GHC_PRAGMA _A_ 1 _U_ 22 _N_ _N_ _N_ _SPECIALISE_ [ Int ] 1 { _A_ 1 _U_ 2 _N_ _N_ _N_ _N_ }, [ Integer ] 1 { _A_ 1 _U_ 2 _N_ _S_ "S" _N_ _N_ } #-}
+ {-# GHC_PRAGMA _A_ 1 _U_ 22 _N_ _N_ _N_ _SPECIALISE_ [ Int ] 1 { _A_ 1 _U_ 2 _N_ _N_ _N_ _N_ }, [ Integer ] 1 { _A_ 1 _U_ 2 _N_ _N_ _N_ _N_ } #-}
readFloat :: RealFloat a => [Char] -> [(a, [Char])]
- {-# GHC_PRAGMA _A_ 2 _U_ 12 _N_ _S_ "LS" _N_ _SPECIALISE_ [ Double ] 1 { _A_ 1 _U_ 2 _N_ _S_ "S" _N_ _N_ }, [ Float ] 1 { _A_ 1 _U_ 2 _N_ _S_ "S" _N_ _N_ } #-}
+ {-# GHC_PRAGMA _A_ 2 _U_ 12 _N_ _S_ "LS" _N_ _SPECIALISE_ [ Double ] 1 { _A_ 1 _U_ 2 _N_ _S_ "S" _N_ _N_ } #-}
readHex :: Integral a => [Char] -> [(a, [Char])]
- {-# GHC_PRAGMA _A_ 1 _U_ 22 _N_ _N_ _N_ _SPECIALISE_ [ Int ] 1 { _A_ 1 _U_ 2 _N_ _N_ _N_ _N_ } #-}
+ {-# GHC_PRAGMA _A_ 1 _U_ 22 _N_ _N_ _N_ _SPECIALISE_ [ Int ] 1 { _A_ 1 _U_ 2 _N_ _N_ _N_ _N_ }, [ Integer ] 1 { _A_ 1 _U_ 2 _N_ _N_ _N_ _N_ } #-}
readLitChar :: [Char] -> [(Char, [Char])]
{-# GHC_PRAGMA _A_ 0 _U_ 1 _N_ _N_ _N_ _N_ #-}
readOct :: Integral a => [Char] -> [(a, [Char])]
- {-# GHC_PRAGMA _A_ 1 _U_ 22 _N_ _N_ _N_ _SPECIALISE_ [ Int ] 1 { _A_ 1 _U_ 2 _N_ _N_ _N_ _N_ } #-}
+ {-# GHC_PRAGMA _A_ 1 _U_ 22 _N_ _N_ _N_ _SPECIALISE_ [ Int ] 1 { _A_ 1 _U_ 2 _N_ _N_ _N_ _N_ }, [ Integer ] 1 { _A_ 1 _U_ 2 _N_ _N_ _N_ _N_ } #-}
readParen :: Bool -> ([Char] -> [(a, [Char])]) -> [Char] -> [(a, [Char])]
{-# GHC_PRAGMA _A_ 2 _U_ 122 _N_ _S_ "EL" _N_ _N_ #-}
readSigned :: Real a => ([Char] -> [(a, [Char])]) -> [Char] -> [(a, [Char])]
{-# GHC_PRAGMA _A_ 2 _U_ 122 _N_ _N_ _N_ _SPECIALISE_ [ Double ] 1 { _A_ 1 _U_ 22 _N_ _N_ _N_ _N_ }, [ Int ] 1 { _A_ 1 _U_ 22 _N_ _N_ _N_ _N_ }, [ Integer ] 1 { _A_ 1 _U_ 22 _N_ _N_ _N_ _N_ } #-}
reads :: Text a => [Char] -> [(a, [Char])]
- {-# GHC_PRAGMA _A_ 1 _U_ 12 _N_ _S_ "U(SAAA)" {_A_ 1 _U_ 12 _N_ _N_ _N_ _N_} _N_ _SPECIALISE_ [ Double ] 1 { _A_ 1 _U_ 2 _N_ _N_ _N_ _N_ }, [ Float ] 1 { _A_ 1 _U_ 2 _N_ _N_ _N_ _N_ }, [ Int ] 1 { _A_ 1 _U_ 2 _N_ _N_ _N_ _N_ }, [ Integer ] 1 { _A_ 1 _U_ 2 _N_ _N_ _N_ _N_ } #-}
+ {-# GHC_PRAGMA _A_ 1 _U_ 12 _N_ _S_ "U(SAAA)" {_A_ 1 _U_ 12 _N_ _N_ _N_ _N_} _N_ _SPECIALISE_ [ Bool ] 1 { _A_ 1 _U_ 2 _N_ _N_ _N_ _N_ }, [ Char ] 1 { _A_ 0 _U_ 2 _N_ _N_ _N_ _N_ }, [ Double ] 1 { _A_ 1 _U_ 2 _N_ _N_ _N_ _N_ }, [ Int ] 1 { _A_ 1 _U_ 2 _N_ _N_ _N_ _N_ }, [ Integer ] 1 { _A_ 1 _U_ 2 _N_ _N_ _N_ _N_ }, [ [Bool] ] 1 { _A_ 0 _U_ 2 _N_ _N_ _F_ _IF_ARGS_ 0 0 X 1 _CONSTM_ Text readList (Bool) _N_ }, [ [Char] ] 1 { _A_ 0 _U_ 2 _N_ _N_ _F_ _IF_ARGS_ 0 0 X 1 _CONSTM_ Text readList (Char) _N_ }, [ [Double] ] 1 { _A_ 0 _U_ 2 _N_ _N_ _F_ _IF_ARGS_ 0 0 X 1 _CONSTM_ Text readList (Double) _N_ }, [ [Float] ] 1 { _A_ 0 _U_ 2 _N_ _N_ _N_ _N_ }, [ [Int] ] 1 { _A_ 0 _U_ 2 _N_ _N_ _F_ _IF_ARGS_ 0 0 X 1 _CONSTM_ Text readList (Int) _N_ }, [ [Integer] ] 1 { _A_ 0 _U_ 2 _N_ _N_ _F_ _IF_ARGS_ 0 0 X 1 _CONSTM_ Text readList (Integer) _N_ }, [ [[Char]] ] 1 { _A_ 0 _U_ 2 _N_ _N_ _F_ _IF_ARGS_ 0 0 X 1 _CONSTM_ Text readList ([Char]) _N_ }, [ [[Int]] ] 1 { _A_ 0 _U_ 2 _N_ _N_ _F_ _IF_ARGS_ 0 0 X 1 _CONSTM_ Text readList ([Int]) _N_ }, [ [Complex Double] ] 1 { _A_ 0 _U_ 2 _N_ _N_ _F_ _IF_ARGS_ 0 0 X 1 _CONSTM_ Text readList (Complex Double) _N_ }, [ (Ratio Integer) ] 1 { _A_ 0 _U_ 2 _N_ _N_ _N_ _N_ }, [ (Array Int Double) ] 1 { _A_ 0 _U_ 2 _N_ _N_ _N_ _N_ }, [ (Array (Int, Int) Double) ] 1 { _A_ 0 _U_ 2 _N_ _N_ _N_ _N_ }, [ _PackedString ] 1 { _A_ 1 _U_ 2 _N_ _S_ _!_ _N_ _N_ }, [ (Complex Double) ] 1 { _A_ 0 _U_ 2 _N_ _N_ _N_ _N_ }, [ () ] 1 { _A_ 0 _U_ 2 _N_ _N_ _N_ _N_ }, [ (Int, Int) ] 1 { _A_ 0 _U_ 2 _N_ _N_ _N_ _N_ }, [ (Integer, Integer) ] 1 { _A_ 0 _U_ 2 _N_ _N_ _N_ _N_ }, [ (Int, Int, Int) ] 1 { _A_ 0 _U_ 2 _N_ _N_ _N_ _N_ } #-}
show :: Text a => a -> [Char]
- {-# GHC_PRAGMA _A_ 1 _U_ 12 _N_ _S_ "U(ASAA)" {_A_ 1 _U_ 12 _N_ _N_ _N_ _N_} _N_ _SPECIALISE_ [ Char ] 1 { _A_ 1 _U_ 1 _N_ _S_ "U(P)" {_A_ 1 _U_ 2 _N_ _N_ _N_ _N_} _N_ _N_ }, [ Double ] 1 { _A_ 1 _U_ 1 _N_ _S_ "U(P)" {_A_ 1 _U_ 2 _N_ _N_ _N_ _N_} _N_ _N_ }, [ Float ] 1 { _A_ 1 _U_ 2 _N_ _N_ _N_ _N_ }, [ Int ] 1 { _A_ 1 _U_ 1 _N_ _S_ "U(P)" {_A_ 1 _U_ 2 _N_ _N_ _N_ _N_} _N_ _N_ }, [ Integer ] 1 { _A_ 1 _U_ 1 _N_ _S_ "U(PPP)" {_A_ 3 _U_ 222 _N_ _N_ _N_ _N_} _N_ _N_ }, [ [Char] ] 1 { _A_ 1 _U_ 2 _N_ _N_ _N_ _N_ }, [ _PackedString ] 1 { _A_ 1 _U_ 1 _N_ _N_ _N_ _N_ }, [ (Int, Int) ] 1 { _A_ 1 _U_ 1 _N_ _S_ "U(LL)" {_A_ 2 _U_ 22 _N_ _N_ _N_ _N_} _N_ _N_ }, [ (Integer, Integer) ] 1 { _A_ 1 _U_ 1 _N_ _S_ "U(LL)" {_A_ 2 _U_ 22 _N_ _N_ _N_ _N_} _N_ _N_ } #-}
+ {-# GHC_PRAGMA _A_ 1 _U_ 12 _N_ _S_ "U(ASAA)" {_A_ 1 _U_ 12 _N_ _N_ _N_ _N_} _N_ _SPECIALISE_ [ Bool ] 1 { _A_ 1 _U_ 2 _N_ _S_ "E" _N_ _N_ }, [ Char ] 1 { _A_ 1 _U_ 1 _N_ _S_ "U(P)" {_A_ 1 _U_ 2 _N_ _N_ _N_ _N_} _N_ _N_ }, [ Double ] 1 { _A_ 1 _U_ 1 _N_ _S_ "U(P)" {_A_ 1 _U_ 2 _N_ _N_ _N_ _N_} _N_ _N_ }, [ Int ] 1 { _A_ 1 _U_ 1 _N_ _S_ "U(P)" {_A_ 1 _U_ 2 _N_ _N_ _N_ _N_} _N_ _N_ }, [ Integer ] 1 { _A_ 1 _U_ 1 _N_ _S_ "U(PPP)" {_A_ 3 _U_ 222 _N_ _N_ _N_ _N_} _N_ _N_ }, [ [Bool] ] 1 { _A_ 1 _U_ 1 _N_ _S_ "S" _N_ _N_ }, [ [Char] ] 1 { _A_ 1 _U_ 2 _N_ _N_ _N_ _N_ }, [ [Double] ] 1 { _A_ 1 _U_ 2 _N_ _N_ _N_ _N_ }, [ [Int] ] 1 { _A_ 1 _U_ 2 _N_ _N_ _N_ _N_ }, [ [Integer] ] 1 { _A_ 1 _U_ 2 _N_ _N_ _N_ _N_ }, [ [[Char]] ] 1 { _A_ 1 _U_ 1 _N_ _S_ "S" _N_ _N_ }, [ [[Int]] ] 1 { _A_ 1 _U_ 1 _N_ _S_ "S" _N_ _N_ }, [ [Complex Double] ] 1 { _A_ 1 _U_ 2 _N_ _N_ _N_ _N_ }, [ (Ratio Integer) ] 1 { _A_ 1 _U_ 1 _N_ _S_ "U(LL)" {_A_ 2 _U_ 22 _N_ _N_ _N_ _N_} _N_ _N_ }, [ (Array Int Double) ] 1 { _A_ 1 _U_ 2 _N_ _N_ _N_ _N_ }, [ (Array (Int, Int) Double) ] 1 { _A_ 1 _U_ 2 _N_ _N_ _N_ _N_ }, [ _PackedString ] 1 { _A_ 1 _U_ 1 _N_ _N_ _N_ _N_ }, [ (Complex Double) ] 1 { _A_ 1 _U_ 1 _N_ _S_ "U(LL)" {_A_ 2 _U_ 22 _N_ _N_ _N_ _N_} _N_ _N_ }, [ () ] 1 { _A_ 1 _U_ 1 _N_ _S_ "E" _N_ _N_ }, [ (Int, Int) ] 1 { _A_ 1 _U_ 1 _N_ _S_ "U(LL)" {_A_ 2 _U_ 22 _N_ _N_ _N_ _N_} _N_ _N_ }, [ (Integer, Integer) ] 1 { _A_ 1 _U_ 1 _N_ _S_ "U(LL)" {_A_ 2 _U_ 22 _N_ _N_ _N_ _N_} _N_ _N_ }, [ (Int, Int, Int) ] 1 { _A_ 1 _U_ 1 _N_ _S_ "U(LLL)" {_A_ 3 _U_ 222 _N_ _N_ _N_ _N_} _N_ _N_ } #-}
showChar :: Char -> [Char] -> [Char]
{-# GHC_PRAGMA _A_ 2 _U_ 22 _N_ _N_ _F_ _IF_ARGS_ 0 2 XX 3 \ (u0 :: Char) (u1 :: [Char]) -> _!_ (:) [Char] [u0, u1] _N_ #-}
showFloat :: RealFloat a => a -> [Char] -> [Char]
- {-# GHC_PRAGMA _A_ 1 _U_ 122 _N_ _S_ "U(U(LU(SLLL)LAAAA)LLLALAAAA)" {_A_ 5 _U_ 1122222 _N_ _N_ _N_ _N_} _N_ _SPECIALISE_ [ Double ] 1 { _A_ 1 _U_ 12 _N_ _S_ "U(P)" {_A_ 1 _U_ 22 _N_ _N_ _N_ _N_} _N_ _N_ }, [ Float ] 1 { _A_ 0 _U_ 22 _N_ _N_ _N_ _N_ } #-}
+ {-# GHC_PRAGMA _A_ 1 _U_ 122 _N_ _S_ "U(U(AU(SAAA)AAAAL)LLLALAAAA)" {_A_ 5 _U_ 1122222 _N_ _N_ _N_ _N_} _N_ _SPECIALISE_ [ Double ] 1 { _A_ 1 _U_ 12 _N_ _S_ "U(P)" {_A_ 1 _U_ 22 _N_ _N_ _N_ _N_} _N_ _N_ } #-}
showInt :: Integral a => a -> [Char] -> [Char]
{-# GHC_PRAGMA _A_ 1 _U_ 122 _N_ _S_ "U(U(U(U(SL)LLLLLLLLL)LL)LLLLLSLLLLL)" _N_ _SPECIALISE_ [ Int ] 1 { _A_ 2 _U_ 12 _N_ _S_ "U(P)L" {_A_ 2 _U_ 22 _N_ _N_ _N_ _N_} _N_ _N_ }, [ Integer ] 1 { _A_ 2 _U_ 12 _N_ _S_ "U(PPP)L" {_A_ 4 _U_ 2222 _N_ _N_ _N_ _N_} _N_ _N_ } #-}
showLitChar :: Char -> [Char] -> [Char]
showString :: [Char] -> [Char] -> [Char]
{-# GHC_PRAGMA _A_ 2 _U_ 12 _N_ _N_ _F_ _IF_ARGS_ 0 0 X 1 _TYAPP_ _ORIG_ PreludeList (++) { Char } _N_ #-}
shows :: Text a => a -> [Char] -> [Char]
- {-# GHC_PRAGMA _A_ 1 _U_ 122 _N_ _S_ "U(ASAA)" {_A_ 1 _U_ 122 _N_ _N_ _N_ _N_} _N_ _SPECIALISE_ [ Char ] 1 { _A_ 2 _U_ 12 _N_ _S_ "U(P)L" {_A_ 2 _U_ 22 _N_ _N_ _N_ _N_} _N_ _N_ }, [ Double ] 1 { _A_ 1 _U_ 12 _N_ _S_ "U(P)" {_A_ 1 _U_ 22 _N_ _N_ _N_ _N_} _N_ _N_ }, [ Float ] 1 { _A_ 0 _U_ 22 _N_ _N_ _N_ _N_ }, [ Int ] 1 { _A_ 2 _U_ 12 _N_ _S_ "U(P)L" {_A_ 2 _U_ 22 _N_ _N_ _N_ _N_} _N_ _N_ }, [ Integer ] 1 { _A_ 2 _U_ 12 _N_ _S_ "U(PPP)L" {_A_ 4 _U_ 2222 _N_ _N_ _N_ _N_} _N_ _N_ }, [ [Char] ] 1 { _A_ 1 _U_ 22 _N_ _N_ _F_ _IF_ARGS_ 0 0 X 1 _CONSTM_ Text showList (Char) _N_ }, [ _PackedString ] 1 { _A_ 2 _U_ 12 _N_ _N_ _N_ _N_ }, [ (Int, Int) ] 1 { _A_ 2 _U_ 12 _N_ _S_ "U(LL)L" {_A_ 3 _U_ 222 _N_ _N_ _N_ _N_} _N_ _N_ }, [ (Integer, Integer) ] 1 { _A_ 2 _U_ 12 _N_ _S_ "U(LL)L" {_A_ 3 _U_ 222 _N_ _N_ _N_ _N_} _N_ _N_ } #-}
+ {-# GHC_PRAGMA _A_ 1 _U_ 122 _N_ _S_ "U(ASAA)" {_A_ 1 _U_ 122 _N_ _N_ _N_ _N_} _N_ _SPECIALISE_ [ Bool ] 1 { _A_ 2 _U_ 22 _N_ _N_ _N_ _N_ }, [ Char ] 1 { _A_ 2 _U_ 12 _N_ _S_ "U(P)L" {_A_ 2 _U_ 22 _N_ _N_ _N_ _N_} _N_ _N_ }, [ Double ] 1 { _A_ 1 _U_ 12 _N_ _S_ "U(P)" {_A_ 1 _U_ 22 _N_ _N_ _N_ _N_} _N_ _N_ }, [ Int ] 1 { _A_ 2 _U_ 12 _N_ _S_ "U(P)L" {_A_ 2 _U_ 22 _N_ _N_ _N_ _N_} _N_ _N_ }, [ Integer ] 1 { _A_ 2 _U_ 12 _N_ _S_ "U(PPP)L" {_A_ 4 _U_ 2222 _N_ _N_ _N_ _N_} _N_ _N_ }, [ [Bool] ] 1 { _A_ 1 _U_ 12 _N_ _S_ "S" _F_ _IF_ARGS_ 0 1 X 3 \ (u0 :: [Bool]) -> _APP_ _TYAPP_ _ORIG_ PreludeCore _showList { Bool } [ _WRKR_ _CONSTM_ Text showsPrec (Bool), u0 ] _N_ }, [ [Char] ] 1 { _A_ 1 _U_ 22 _N_ _N_ _F_ _IF_ARGS_ 0 0 X 1 _CONSTM_ Text showList (Char) _N_ }, [ [Double] ] 1 { _A_ 1 _U_ 22 _N_ _N_ _F_ _IF_ARGS_ 0 0 X 1 _CONSTM_ Text showList (Double) _N_ }, [ [Int] ] 1 { _A_ 1 _U_ 22 _N_ _N_ _F_ _IF_ARGS_ 0 0 X 1 _CONSTM_ Text showList (Int) _N_ }, [ [Integer] ] 1 { _A_ 1 _U_ 22 _N_ _N_ _F_ _IF_ARGS_ 0 0 X 1 _CONSTM_ Text showList (Integer) _N_ }, [ [[Char]] ] 1 { _A_ 1 _U_ 12 _N_ _S_ "S" _F_ _IF_ARGS_ 0 1 X 3 \ (u0 :: [[Char]]) -> _APP_ _TYAPP_ _ORIG_ PreludeCore _showList { [Char] } [ _CONSTM_ Text showList (Char), u0 ] _N_ }, [ [[Int]] ] 1 { _A_ 1 _U_ 12 _N_ _S_ "S" _F_ _IF_ARGS_ 0 1 X 3 \ (u0 :: [[Int]]) -> _APP_ _TYAPP_ _ORIG_ PreludeCore _showList { [Int] } [ _CONSTM_ Text showList (Int), u0 ] _N_ }, [ [Complex Double] ] 1 { _A_ 1 _U_ 22 _N_ _N_ _F_ _IF_ARGS_ 0 0 X 1 _CONSTM_ Text showList (Complex Double) _N_ }, [ (Ratio Integer) ] 1 { _A_ 1 _U_ 12 _N_ _S_ "U(LL)" {_A_ 2 _U_ 222 _N_ _N_ _N_ _N_} _N_ _N_ }, [ (Array Int Double) ] 1 { _A_ 1 _U_ 22 _N_ _N_ _N_ _N_ }, [ (Array (Int, Int) Double) ] 1 { _A_ 1 _U_ 22 _N_ _N_ _N_ _N_ }, [ _PackedString ] 1 { _A_ 2 _U_ 12 _N_ _N_ _N_ _N_ }, [ (Complex Double) ] 1 { _A_ 1 _U_ 12 _N_ _S_ "U(LL)" {_A_ 2 _U_ 222 _N_ _N_ _N_ _N_} _N_ _N_ }, [ () ] 1 { _A_ 2 _U_ 12 _N_ _S_ "EL" _F_ _IF_ARGS_ 0 2 CX 4 \ (u0 :: ()) (u1 :: [Char]) -> case u0 of { _ALG_ _TUP_0 -> _APP_ _TYAPP_ _ORIG_ PreludeList (++) { Char } [ _NOREP_S_ "()", u1 ]; _NO_DEFLT_ } _N_ }, [ (Int, Int) ] 1 { _A_ 2 _U_ 12 _N_ _S_ "U(LL)L" {_A_ 3 _U_ 222 _N_ _N_ _N_ _N_} _N_ _N_ }, [ (Integer, Integer) ] 1 { _A_ 2 _U_ 12 _N_ _S_ "U(LL)L" {_A_ 3 _U_ 222 _N_ _N_ _N_ _N_} _N_ _N_ }, [ (Int, Int, Int) ] 1 { _A_ 2 _U_ 12 _N_ _S_ "U(LLL)L" {_A_ 4 _U_ 2222 _N_ _N_ _N_ _N_} _N_ _N_ } #-}
-{-# GHC_PRAGMA INTERFACE VERSION 5 #-}
+{-# GHC_PRAGMA INTERFACE VERSION 6 #-}
interface PreludeArray where
import PreludeBuiltin(Tuple2)
import PreludeCore(_CCallable(..))
import Cls
import Core
+import TyComplex
+import PS ( _PackedString, _unpackPS )
+
data Assoc a b = a := b deriving ()
-{-# GHC_PRAGMA INTERFACE VERSION 5 #-}
+{-# GHC_PRAGMA INTERFACE VERSION 6 #-}
interface PreludeArray where
import PreludeBuiltin(Tuple2)
import PreludeCore(_CCallable(..))
-{-# GHC_PRAGMA INTERFACE VERSION 5 #-}
+{-# GHC_PRAGMA INTERFACE VERSION 6 #-}
interface PreludeArray where
import PreludeBuiltin(Tuple2)
import PreludeCore(_CCallable(..))
-{-# GHC_PRAGMA INTERFACE VERSION 5 #-}
+{-# GHC_PRAGMA INTERFACE VERSION 6 #-}
interface PreludeArray where
import PreludeBuiltin(Tuple2)
import PreludeCore(_CCallable(..))
-{-# GHC_PRAGMA INTERFACE VERSION 5 #-}
+{-# GHC_PRAGMA INTERFACE VERSION 6 #-}
interface PreludeArray where
import PreludeBuiltin(Tuple2)
import PreludeCore(_CCallable(..))
-{-# GHC_PRAGMA INTERFACE VERSION 5 #-}
+{-# GHC_PRAGMA INTERFACE VERSION 6 #-}
interface PreludeComplex where
-data Complex a = (:+) a a
+data Complex a = (:+) a a {-# GHC_PRAGMA _SPECIALISE_ [ Double# ] #-}
-- (NB: compiler's builtin idea of "data Complex ..." must also
-- omit the context!)
--- {-# SPECIALIZE data Complex Double# #-}
+{-# SPECIALIZE data Complex Double# #-}
-{-# GHC_PRAGMA INTERFACE VERSION 5 #-}
+{-# GHC_PRAGMA INTERFACE VERSION 6 #-}
interface PreludeComplex where
-data Complex a = (:+) a a
+data Complex a = (:+) a a {-# GHC_PRAGMA _SPECIALISE_ [ Double# ] #-}
-{-# GHC_PRAGMA INTERFACE VERSION 5 #-}
+{-# GHC_PRAGMA INTERFACE VERSION 6 #-}
interface PreludeComplex where
-data Complex a = (:+) a a
+data Complex a = (:+) a a {-# GHC_PRAGMA _SPECIALISE_ [ Double# ] #-}
-{-# GHC_PRAGMA INTERFACE VERSION 5 #-}
+{-# GHC_PRAGMA INTERFACE VERSION 6 #-}
interface PreludeComplex where
-data Complex a = (:+) a a
+data Complex a = (:+) a a {-# GHC_PRAGMA _SPECIALISE_ [ Double# ] #-}
-{-# GHC_PRAGMA INTERFACE VERSION 5 #-}
+{-# GHC_PRAGMA INTERFACE VERSION 6 #-}
interface PreludeComplex where
-data Complex a = (:+) a a
+data Complex a = (:+) a a {-# GHC_PRAGMA _SPECIALISE_ [ Double# ] #-}
----------------------------------------------------
data List a = Nil | a : (List a)
+{-# GENERATE_SPECS data a :: List a #-}
----------------------------------------------------
data Tuple32 a b c d e f g h i j k l m n o p q r s t u v w x y z a_ b_ c_ d_ e_ f_
= Tup32 a b c d e f g h i j k l m n o p q r s t u v w x y z a_ b_ c_ d_ e_ f_
+{-# GENERATE_SPECS data a b :: Tuple2 a b #-}
+{-# GENERATE_SPECS data a b c :: Tuple3 a b c #-}
+{-# GENERATE_SPECS data a b c d :: Tuple4 a b c d #-}
+
+{-# SPECIALIZE data Tuple5 Int# Int# Int# Int# Int# #-}
+{-# SPECIALIZE data Tuple5 Char# Char# Char# Char# Char# #-}
+{-# SPECIALIZE data Tuple5 Double# Double# Double# Double# Double# #-}
+
+-- Check this out ... We need this for instance Floating Double# ...
+
+{-# SPECIALIZE data Tuple19 a Double# b c d e f g h i j k l m n o p q r #-}
+
----------------------------------------------------
-- Ratio: in PreludeRatio
-- IO things: in PreludeIO
---{-# SPECIALIZE data _Lift (State# _RealWorld) #-}
-
data _Lift a = _Lift a
+{-# GENERATE_SPECS data a :: _Lift a #-}
-# line 8 "only4-ghc.ljm"
+# line 8 "mkworld/only4-ghc.ljm"
/* Project identification - name and version */
#ifndef ProjectName
#ifndef GhcBuildeeVersion
#define GhcBuildeeVersion 27
#endif
-# line 29 "only4-ghc.ljm"
+# line 29 "mkworld/only4-ghc.ljm"
/* state of the source world */
GHC_DRIVERSRC = $(TOP)/ghc/driver
GHC_COMPILERSRC = $(TOP)/ghc/compiler
GHC_INCLUDESRC = $(TOP)/ghc/includes
GHC_UTILSRC = $(TOP)/ghc/utils
GHC_BOOKSRC = $(TOP)/ghc/book
-# line 41 "only4-ghc.ljm"
+# line 41 "mkworld/only4-ghc.ljm"
#ifndef GhcIncludesDir
#define GhcIncludesDir $(GHC_INCLUDESRC)
#endif
GHC_INCLUDES = GhcIncludesDir
-# line 51 "only4-ghc.ljm"
+# line 51 "mkworld/only4-ghc.ljm"
#ifndef AllProjectsGhcOpts
#define AllProjectsGhcOpts /*none*/
#endif
GenerateOptionsMakeVars(GHC,OPTS,AllProjectsGhcOpts,PlatformGhcOpts,ProjectGhcOpts,SetupGhcOpts)
GHCFLAGS=$(GLUED_CPP_DEFINES) $(GLUED_GHC_OPTS)
-# line 95 "only4-ghc.ljm"
+# line 95 "mkworld/only4-ghc.ljm"
/* build York interpreter as well as Glasgow compiler
*/
#ifndef BuildYorkInterpreter
#ifndef UseSemantiqueStrictnessAnalyser
#define UseSemantiqueStrictnessAnalyser NO
#endif
-# line 116 "only4-ghc.ljm"
+# line 116 "mkworld/only4-ghc.ljm"
/* defaults for which pieces should be installed */
/* ToDo: possibly obsolete */
#ifndef DoInstallGHCSystem
#define DoInstallGHCSystem YES
#endif /* DoInstallGHCSystem */
-# line 124 "only4-ghc.ljm"
+# line 124 "mkworld/only4-ghc.ljm"
/* ------------------------------------------------------------------ */
/* compiler-proper subsystem:
the lib/data bits are installed w/ a version number as well
INSTSCRIPTDIR_GHC = InstScriptDir_GHC
INSTLIBDIR_GHC = InstLibDir_GHC
INSTDATADIR_GHC = InstDataDir_GHC
-# line 183 "only4-ghc.ljm"
+# line 183 "mkworld/only4-ghc.ljm"
#ifndef GhcDriverInstallName
#define GhcDriverInstallName ghc
#endif /* ! GhcDriverInstallName */
GHC_DRIVER_INST_NAME = GhcDriverInstallName
-# line 197 "only4-ghc.ljm"
+# line 197 "mkworld/only4-ghc.ljm"
/* ghc: std driver for compilation system */
#ifndef GhcDriverCmd
#define GhcDriverCmd $(GHC_DRIVERSRC)/ghc
/* could be GHC_DRIVER, but GHC is its common name */
GHC = GhcDriverCmd
-# line 218 "only4-ghc.ljm"
+# line 218 "mkworld/only4-ghc.ljm"
#ifndef HsCppCmd
#define HsCppCmd $(GHC_HSCPPSRC)/hscpp
#endif
GHC_HSCPP = HsCppCmd $(ALLPROJ_CPP_DEFINES)
GHC_HSCPPSRC = $(GHC_UTILSRC)/hscpp
-# line 233 "only4-ghc.ljm"
+# line 233 "mkworld/only4-ghc.ljm"
#ifndef HsParserCmd
#define HsParserCmd $(GHC_HSPSRC)/hsp
#endif
GHC_HSP = HsParserCmd
GHC_HSPSRC = $(GHC_HSCSRC)
-# line 248 "only4-ghc.ljm"
+# line 248 "mkworld/only4-ghc.ljm"
#ifndef HsCompilerCmd
#define HsCompilerCmd $(GHC_HSCSRC)/hsc
#endif
GHC_HSC = HsCompilerCmd
GHC_HSCSRC = $(GHC_COMPILERSRC)
-# line 263 "only4-ghc.ljm"
+# line 263 "mkworld/only4-ghc.ljm"
#ifndef SysManCmd
#define SysManCmd $(GHC_RUNTIMESRC)/gum/SysMan
#endif
GHC_SYSMAN = SysManCmd
GHC_SYSMANSRC = $(GHC_RUNTIMESRC)
-# line 318 "only4-ghc.ljm"
+# line 318 "mkworld/only4-ghc.ljm"
/* NON-OPTIMISING C COMPILATION: ==================================
We can use GCC 2.n for the non-optimising (normal) .hc C
#endif /* ! gcc */
#endif /* GhcDebuggingHighLevelAsmCmd */
GHC_DEBUG_HILEV_ASM = GhcDebuggingHighLevelAsmCmd
-# line 342 "only4-ghc.ljm"
+# line 342 "mkworld/only4-ghc.ljm"
/* OPTIMISING C COMPILATION (regs, etc): ==========================
Must use GCC 2.n for this
/* these had to be de-configure-ified because of 99-cmd-limit brain-dead seds */
-#define GhcBuild_a NO /*@GhcBuild_a@*/ /* "user way" a */
+/* stuff for "update" paper; also use --enable-ticky */
+
+#define GhcBuild_a YES /*@GhcBuild_a@*/ /* "user way" a */
#if GhcBuild_a == YES
# define IfGhcBuild_a(x) x
-GHC_BUILD_FLAG_a = -build-a-not-defined /* >>>change here<<< if required */
-GHC_BUILD_OPTS_a = -build-a-not-defined-error
+GHC_BUILD_FLAG_a = -SA-noUpdA
+GHC_BUILD_OPTS_a = -fticky-ticky -optcO-DTICKY_TICKY -debug \
+ -Ofile /local/grasp/partain-other/performance/update/Ofile.SA-noUpdA
#else
# define IfGhcBuild_a(x) /**/
GHC_BUILD_FLAG_a = -build-a-not-defined
GHC_BUILD_OPTS_a = -build-a-not-defined-error
#endif
-#define GhcBuild_b NO /*@GhcBuild_b@*/ /* "user way" b */
+#define GhcBuild_b YES /*@GhcBuild_b@*/ /* "user way" b */
#if GhcBuild_b == YES
# define IfGhcBuild_b(x) x
-GHC_BUILD_FLAG_b = -build-b-not-defined /* >>>change here<<< if required */
-GHC_BUILD_OPTS_b = -build-b-not-defined-error
+GHC_BUILD_FLAG_b = -noSA-UpdA
+GHC_BUILD_OPTS_b = -fticky-ticky -optcO-DTICKY_TICKY -debug \
+ -Ofile /local/grasp/partain-other/performance/update/Ofile.noSA-UpdA
#else
# define IfGhcBuild_b(x) /**/
GHC_BUILD_FLAG_b = -build-b-not-defined
GHC_BUILD_OPTS_b = -build-b-not-defined-error
#endif
-#define GhcBuild_c NO /*@GhcBuild_c@*/ /* "user way" c */
+#define GhcBuild_c YES /*@GhcBuild_c@*/ /* "user way" c */
#if GhcBuild_c == YES
# define IfGhcBuild_c(x) x
-GHC_BUILD_FLAG_c = -build-c-not-defined /* >>>change here<<< if required */
-GHC_BUILD_OPTS_c = -build-c-not-defined-error
+GHC_BUILD_FLAG_c = -noSA-noUpdA
+GHC_BUILD_OPTS_c = -fticky-ticky -optcO-DTICKY_TICKY -debug \
+ -Ofile /local/grasp/partain-other/performance/update/Ofile.noSA-noUpdA
#else
# define IfGhcBuild_c(x) /**/
GHC_BUILD_FLAG_c = -build-c-not-defined
GHC_BUILD_OPTS_c = -build-c-not-defined-error
#endif
-#define GhcBuild_d NO /*@GhcBuild_d@*/ /* "user way" d */
+#define GhcBuild_d NO/*YES*/ /*@GhcBuild_d@*/ /* "user way" d */
#if GhcBuild_d == YES
# define IfGhcBuild_d(x) x
-GHC_BUILD_FLAG_d = -build-d-not-defined /* >>>change here<<< if required */
-GHC_BUILD_OPTS_d = -build-d-not-defined-error
+GHC_BUILD_FLAG_d = -regs-avail-2
+GHC_BUILD_OPTS_d = -fticky-ticky -optcO-DTICKY_TICKY -debug \
+ -O -freturn-in-regs-threshold2
#else
# define IfGhcBuild_d(x) /**/
GHC_BUILD_FLAG_d = -build-d-not-defined
GHC_BUILD_OPTS_d = -build-d-not-defined-error
#endif
-#define GhcBuild_e NO /*@GhcBuild_e@*/ /* "user way" e */
+#define GhcBuild_e NO/*YES*/ /*@GhcBuild_e@*/ /* "user way" e */
#if GhcBuild_e == YES
# define IfGhcBuild_e(x) x
-GHC_BUILD_FLAG_e = -build-e-not-defined /* >>>change here<<< if required */
-GHC_BUILD_OPTS_e = -build-e-not-defined-error
+GHC_BUILD_FLAG_e = -regs-avail-3
+GHC_BUILD_OPTS_e = -fticky-ticky -optcO-DTICKY_TICKY -debug \
+ -O -freturn-in-regs-threshold3
#else
# define IfGhcBuild_e(x) /**/
GHC_BUILD_FLAG_e = -build-e-not-defined
GHC_BUILD_OPTS_e = -build-e-not-defined-error
#endif
-#define GhcBuild_f NO /*@GhcBuild_f@*/ /* "user way" f */
+#define GhcBuild_f NO/*YES*/ /*@GhcBuild_f@*/ /* "user way" f */
#if GhcBuild_f == YES
# define IfGhcBuild_f(x) x
-GHC_BUILD_FLAG_f = -build-f-not-defined /* >>>change here<<< if required */
-GHC_BUILD_OPTS_f = -build-f-not-defined-error
+GHC_BUILD_FLAG_f = -regs-avail-4
+GHC_BUILD_OPTS_f = -fticky-ticky -optcO-DTICKY_TICKY -debug \
+ -O -freturn-in-regs-threshold4
#else
# define IfGhcBuild_f(x) /**/
GHC_BUILD_FLAG_f = -build-f-not-defined
GHC_BUILD_OPTS_f = -build-f-not-defined-error
#endif
-#define GhcBuild_g NO /*@GhcBuild_g@*/ /* "user way" g */
+#define GhcBuild_g NO/*YES*/ /*@GhcBuild_g@*/ /* "user way" g */
#if GhcBuild_g == YES
# define IfGhcBuild_g(x) x
-GHC_BUILD_FLAG_g = -build-g-not-defined /* >>>change here<<< if required */
-GHC_BUILD_OPTS_g = -build-g-not-defined-error
+GHC_BUILD_FLAG_g = -regs-avail-5
+GHC_BUILD_OPTS_g = -fticky-ticky -optcO-DTICKY_TICKY -debug \
+ -O -freturn-in-regs-threshold5
#else
# define IfGhcBuild_g(x) /**/
GHC_BUILD_FLAG_g = -build-g-not-defined
GHC_BUILD_OPTS_g = -build-g-not-defined-error
#endif
-#define GhcBuild_h NO /*@GhcBuild_h@*/ /* "user way" h */
-#if GhcBuild_h == YES
+#define GhcBuild_h YES /*@GhcBuild_h@*/ /* "user way" a */
+#if GhcBuild_h == YES
# define IfGhcBuild_h(x) x
-GHC_BUILD_FLAG_h = -build-h-not-defined /* >>>change here<<< if required */
-GHC_BUILD_OPTS_h = -build-h-not-defined-error
+GHC_BUILD_FLAG_h = -semi-tagged
+GHC_BUILD_OPTS_h = -fticky-ticky -optcO-DTICKY_TICKY -debug \
+ -O -fsemi-tagging
#else
# define IfGhcBuild_h(x) /**/
GHC_BUILD_FLAG_h = -build-h-not-defined
GHC_BUILD_OPTS_h = -build-h-not-defined-error
#endif
-#define GhcBuild_i NO /*@GhcBuild_i@*/ /* "user way" i */
+/* _b minus ticky */
+#define GhcBuild_i NO/*YES*/ /*@GhcBuild_i@*/ /* "user way" b */
#if GhcBuild_i == YES
# define IfGhcBuild_i(x) x
-GHC_BUILD_FLAG_i = -build-i-not-defined /* >>>change here<<< if required */
-GHC_BUILD_OPTS_i = -build-i-not-defined-error
+GHC_BUILD_FLAG_i = -noSA-noFI2
+GHC_BUILD_OPTS_i = -Ofile /local/grasp/partain-other/performance/update/Ofile.noSA-noFI
#else
# define IfGhcBuild_i(x) /**/
GHC_BUILD_FLAG_i = -build-i-not-defined
GHC_BUILD_OPTS_i = -build-i-not-defined-error
#endif
-#define GhcBuild_j NO /*@GhcBuild_j@*/ /* "user way" j */
+#define GhcBuild_j NO/*YES*/ /*@GhcBuild_j@*/ /* "user way" c */
#if GhcBuild_j == YES
# define IfGhcBuild_j(x) x
-GHC_BUILD_FLAG_j = -build-j-not-defined /* >>>change here<<< if required */
-GHC_BUILD_OPTS_j = -build-j-not-defined-error
+GHC_BUILD_FLAG_j = -SA-noFI2
+GHC_BUILD_OPTS_j = -Ofile /local/grasp/partain-other/performance/update/Ofile.SA-noFI
#else
# define IfGhcBuild_j(x) /**/
GHC_BUILD_FLAG_j = -build-j-not-defined
GHC_BUILD_OPTS_j = -build-j-not-defined-error
#endif
-#define GhcBuild_k NO /*@GhcBuild_k@*/ /* "user way" k */
+#define GhcBuild_k NO/*YES*/ /*@GhcBuild_k@*/ /* "user way" d */
#if GhcBuild_k == YES
# define IfGhcBuild_k(x) x
-GHC_BUILD_FLAG_k = -build-k-not-defined /* >>>change here<<< if required */
-GHC_BUILD_OPTS_k = -build-k-not-defined-error
+GHC_BUILD_FLAG_k = -SA-noFL2
+GHC_BUILD_OPTS_k = -Ofile /local/grasp/partain-other/performance/update/Ofile.SA-noFL
#else
# define IfGhcBuild_k(x) /**/
GHC_BUILD_FLAG_k = -build-k-not-defined
GHC_BUILD_OPTS_k = -build-k-not-defined-error
#endif
-#define GhcBuild_l NO /*@GhcBuild_l@*/ /* "user way" l */
+#define GhcBuild_l NO/*YES*/ /*@GhcBuild_l@*/ /* "user way" e */
#if GhcBuild_l == YES
# define IfGhcBuild_l(x) x
-GHC_BUILD_FLAG_l = -build-l-not-defined /* >>>change here<<< if required */
-GHC_BUILD_OPTS_l = -build-l-not-defined-error
+GHC_BUILD_FLAG_l = -float-strict2
+GHC_BUILD_OPTS_l = -Ofile /local/grasp/partain-other/performance/update/Ofile.float-strict
#else
# define IfGhcBuild_l(x) /**/
GHC_BUILD_FLAG_l = -build-l-not-defined
GHC_BUILD_OPTS_l = -build-l-not-defined-error
#endif
-#define GhcBuild_m NO /*@GhcBuild_m@*/ /* "user way" m */
+#define GhcBuild_m NO/*YES*/ /*@GhcBuild_m@*/ /* "user way" f */
#if GhcBuild_m == YES
# define IfGhcBuild_m(x) x
-GHC_BUILD_FLAG_m = -build-m-not-defined /* >>>change here<<< if required */
-GHC_BUILD_OPTS_m = -build-m-not-defined-error
+GHC_BUILD_FLAG_m = -float-always2
+GHC_BUILD_OPTS_m = -Ofile /local/grasp/partain-other/performance/update/Ofile.float-always
#else
# define IfGhcBuild_m(x) /**/
GHC_BUILD_FLAG_m = -build-m-not-defined
GHC_BUILD_OPTS_m = -build-m-not-defined-error
#endif
-#define GhcBuild_n NO /*@GhcBuild_n@*/ /* "user way" n */
+#define GhcBuild_n NO/*YES*/ /*@GhcBuild_n@*/ /* "user way" g */
#if GhcBuild_n == YES
# define IfGhcBuild_n(x) x
-GHC_BUILD_FLAG_n = -build-n-not-defined /* >>>change here<<< if required */
-GHC_BUILD_OPTS_n = -build-n-not-defined-error
+GHC_BUILD_FLAG_n = -no-float2
+GHC_BUILD_OPTS_n = -Ofile /local/grasp/partain-other/performance/update/Ofile.no-float
#else
# define IfGhcBuild_n(x) /**/
GHC_BUILD_FLAG_n = -build-n-not-defined
GHC_BUILD_OPTS_n = -build-n-not-defined-error
#endif
-#define GhcBuild_o NO /*@GhcBuild_o@*/ /* "user way" o */
-#if GhcBuild_o == YES
-# define IfGhcBuild_o(x) x
-GHC_BUILD_FLAG_o = -build-o-not-defined /* >>>change here<<< if required */
-GHC_BUILD_OPTS_o = -build-o-not-defined-error
-#else
-# define IfGhcBuild_o(x) /**/
-GHC_BUILD_FLAG_o = -build-o-not-defined
-GHC_BUILD_OPTS_o = -build-o-not-defined-error
-#endif
-
-#define GhcBuild_A NO /*@GhcBuild_A@*/ /* "user way" A */
+#define GhcBuild_A NO/*YES*/ /*@GhcBuild_A@*/ /* "user way" A */
#if GhcBuild_A == YES
# define IfGhcBuild_A(x) x
-GHC_BUILD_FLAG_A = -build-A-not-defined /* >>>change here<<< if required */
-GHC_BUILD_OPTS_A = -build-A-not-defined-error
+GHC_BUILD_FLAG_A = -no-local-float
+GHC_BUILD_OPTS_A = -fticky-ticky -optcO-DTICKY_TICKY -debug \
+ -Ofile /local/grasp/partain-other/performance/update/Ofile.no-local-float
#else
# define IfGhcBuild_A(x) /**/
GHC_BUILD_FLAG_A = -build-A-not-defined
GHC_BUILD_OPTS_A = -build-A-not-defined-error
#endif
-#define GhcBuild_B NO /*@GhcBuild_B@*/ /* "user way" B */
+#define GhcBuild_B NO/*YES*/ /*@GhcBuild_B@*/ /* "user way" B */
#if GhcBuild_B == YES
# define IfGhcBuild_B(x) x
-GHC_BUILD_FLAG_B = -build-B-not-defined /* >>>change here<<< if required */
-GHC_BUILD_OPTS_B = -build-B-not-defined-error
+GHC_BUILD_FLAG_B = -no-local-float2
+GHC_BUILD_OPTS_B = -Ofile /local/grasp/partain-other/performance/update/Ofile.no-local-float
#else
# define IfGhcBuild_B(x) /**/
GHC_BUILD_FLAG_B = -build-B-not-defined
GHC_BUILD_OPTS_B = -build-B-not-defined-error
#endif
+
+/* end of "floating" stuff */
+
+#define GhcBuild_o NO /*@GhcBuild_o@*/ /* "user way" o */
+#if GhcBuild_o == YES
+# define IfGhcBuild_o(x) x
+GHC_BUILD_FLAG_o = -build-o-not-defined /* >>>change here<<< if required */
+GHC_BUILD_OPTS_o = -build-o-not-defined-error
+#else
+# define IfGhcBuild_o(x) /**/
+GHC_BUILD_FLAG_o = -build-o-not-defined
+GHC_BUILD_OPTS_o = -build-o-not-defined-error
+#endif
+
/* ======= END OF BUILD INFO ==================================== */
}
\end{code}
-@SynchroniseSystem@ synchronises the reduction task with the system manager,
-and gathers information about which PEs are actually in use.
+@SynchroniseSystem@ synchronises the reduction task with the system manager.
\begin{code}
GLOBAL_TASK_ID *PEs;
\end{code}
\begin{code}
-static GLOBAL_TASK_ID gtids[MAX_PES], IOTask = 0, StatsTask = 0;
+static GLOBAL_TASK_ID gtids[MAX_PES], StatsTask = 0;
static long PEbuffer[MAX_PES];
static int nPEs = 0;
\end{code}
\begin{code}
-static GLOBAL_TASK_ID sysman_id, sender_id;
+static GLOBAL_TASK_ID sysman_id, sender_id, mainThread_id;
GLOBAL_TASK_ID mytid;
int rbufid;
int opcode, nbytes;
char **pargv;
- int i;
-#if 0
- int status;
-#endif
+ int i, cc;
int spawn_flag = PvmTaskDefault;
- char *petask;
+ char *petask, *pvmExecutable;
setbuf(stdout, NULL);
setbuf(stderr, NULL);
argv[1] = argv[0];
argv++; argc--;
}
- sysman_id = pvm_mytid();/* This must be the first PVM call */
- checkerr(sysman_id);
+ mainThread_id = pvm_mytid();/* This must be the first PVM call */
+ checkerr(mainThread_id);
nPEs = atoi(argv[1]);
if ((petask = getenv(PETASK)) == NULL)
petask = PETASK;
-#if 1
+#if 0
fprintf(stderr, "nPEs (%s) = %d\n", petask, nPEs);
#endif
fprintf(stderr, "No more than %d PEs allowed (%d requested)\n", MAX_PES, nPEs);
EXIT(EXIT_FAILURE);
}
+ /*
+ Get the full path and filename of the pvm executable (stashed in some
+ PVM directory.
+ */
+ pvmExecutable = argv[2];
+
/* Create the PE Tasks */
if (nPEs > 0) {
- /* Initialise the PE task arguments from Sysman's arguments */
- pargv = argv + 1;
-#if 0
+ /* Spawn nPEs-1 pvm threads: the Main Thread (starts execution and performs
+ IO is created by forking SysMan */
+ nPEs--;
+#if 1
fprintf(stderr, "Spawning %d PEs(%s) ...\n", nPEs, petask);
fprintf(stderr, " args: ");
for (i = 0; pargv[i]; ++i)
fprintf(stderr, "%s, ", pargv[i]);
fprintf(stderr, "\n");
#endif
-
+ /* Initialise the PE task arguments from Sysman's arguments */
+ pargv = argv + 2;
checkerr(pvm_spawn(petask, pargv, spawn_flag, "", nPEs, gtids));
+ PEbuffer[0] = mainThread_id;
for (i = 0; i < nPEs; i++)
- PEbuffer[i] = (long) gtids[i];
-#if 0
+ PEbuffer[i++] = (long) gtids[i];
+#if 1
fprintf(stderr, "Spawned /* PWT */\n");
#endif
(Phil Trinder, 95/10)
*/
checkerr(pvm_joingroup(PECTLGROUP));
-#if 0
+#if 1
fprintf(stderr, "Joined PECTLGROUP /* PWT */\n");
#endif
/* Wait for all the PEs and IMUs to arrive */
checkerr(pvm_barrier(PECTLGROUP, nPEs + 1));
-#if 0
+#if 1
fprintf(stderr, "PECTLGROUP barrier passed /* HWL */\n");
#endif
+ /*
+ Create the MainThread PE by forking SysMan. This arcane coding
+ is required to allow MainThread to read stdin and write to stdout.
+ PWT 18/1/96
+ */
+ if (cc = fork()) {
+ checkerr(cc);
+ exec($some path$/petask) /* Parent task become Main Thread PE */
+ } else {
+ /* Child continues as SysMan */
+ pvmendtask(); /* Disconnect from PVM to avoid confusion */
+ sysman_id = pvm_mytid(); /* Reconnect to PVM to get new task id */
- /* Broadcast Global Task Ids of all PEs */
+ /* Broadcast Global Task Ids of all PEs */
- pvm_initsend(PvmDataDefault);
- PutArgs(PEbuffer, nPEs);
- pvm_bcast(PEGROUP, PP_PETIDS);
+ pvm_initsend(PvmDataDefault);
+ PutArgs(PEbuffer, nPEs);
+ pvm_bcast(PEGROUP, PP_PETIDS);
-#if 0
- /* Find an IO task */
- for (i = 0; IOTask <= 0 || status != PvmOk; ++i) {
- IOTask = pvm_gettid(PEGROUP, i);
- status = pvm_pstat(IOTask);
- fprintf(stderr, "Task %x, Status %x\n", IOTask, status);
- }
-#endif
-
- IOTask = gtids[0];
-#if 0
- fprintf(stderr, "IO Task is [t%x]\n", IOTask);
+#if 1
+ fprintf(stderr, "Main Thread Task is [t%x]\n", mainThread_id);
#endif
- pvm_initsend(PvmDataDefault);
- pvm_send(IOTask, PP_IO_INIT);
+ pvm_initsend(PvmDataDefault);
+ pvm_send(mainThread_id, PP_IO_INIT);
- pvm_initsend(PvmDataDefault);
- pvm_bcast(PEGROUP, PP_INIT);
-#if 0
- fprintf(stderr, "Broadcast PP_INIT to all PEs\n");
+ pvm_initsend(PvmDataDefault);
+ pvm_bcast(PEGROUP, PP_INIT);
+#if 1
+ fprintf(stderr, "Broadcast PP_INIT to all PEs\n");
#endif
/* HWL-DEBUG */
-#if 0
- fprintf(stderr, "Sysman successfully initialized!\n");
+#if 1
+ fprintf(stderr, "Sysman successfully initialized!\n");
#endif
/* Process incoming messages */
- while (1) {
- if ((rbufid = pvm_recv(ANY_TASK, ANY_OPCODE)) < 0)
- pvm_perror("Sysman: Receiving Message");
+ while (1) {
+ if ((rbufid = pvm_recv(ANY_TASK, ANY_OPCODE)) < 0)
+ pvm_perror("Sysman: Receiving Message");
- else {
- pvm_bufinfo(rbufid, &nbytes, &opcode, &sender_id);
+ else {
+ pvm_bufinfo(rbufid, &nbytes, &opcode, &sender_id);
#if 0
- fprintf(stderr, "HWL-DBG(SysMan; main loop): rbufid=%x, nbytes = %d, opcode = %x, sender_id = %x\n",
- rbufid, nbytes, opcode, sender_id);
+ fprintf(stderr, "HWL-DBG(SysMan; main loop): rbufid=%x, nbytes = %d, opcode = %x, sender_id = %x\n",
+ rbufid, nbytes, opcode, sender_id);
#endif
- switch (opcode) {
- case PP_GC_INIT:
+ switch (opcode) {
+ case PP_GC_INIT:
/* This Function not yet implemented for GUM */
fprintf(stderr, "Global GC from %x Not yet implemented for GUM!\n", sender_id);
sync(PECTLGROUP, PP_FULL_SYSTEM);
broadcast(PEGROUP, PP_INIT);
break;
- case PP_STATS_ON:
- case PP_STATS_OFF:
- /* This Function not yet implemented for GUM */
- break;
-
- case PP_FINISH:
- fprintf(stderr, "Finish from %x\n", sender_id);
- if (!Finishing) {
- long buf = (long) StatsTask;
- Finishing = rtsTrue;
- pvm_initsend(PvmDataDefault);
- pvm_pklong(&buf, 1, 1);
- pvm_bcast(PEGROUP, PP_FINISH);
- } else {
- ++PEsTerminated;
- }
-
- if (PEsTerminated >= nPEs) {
- broadcast(PEGROUP, PP_FINISH);
- broadcast(MGRGROUP, PP_FINISH);
- pvm_lvgroup(PEGROUP);
- pvm_lvgroup(PECTLGROUP);
- pvm_lvgroup(MGRGROUP);
- pvm_exit();
- EXIT(EXIT_SUCCESS);
- }
- break;
-
- case PP_FAIL:
- fprintf(stderr, "Fail from %x\n", sender_id);
- if (!Finishing) {
- Finishing = rtsTrue;
- broadcast(PEGROUP, PP_FAIL);
- }
- break;
-
- default:
- {
-/* char *opname = GetOpName(opcode);
- fprintf(stderr,"Sysman: Unrecognised opcode %s (%x)\n",
+ case PP_STATS_ON:
+ case PP_STATS_OFF:
+ /* This Function not yet implemented for GUM */
+ break;
+
+ case PP_FINISH:
+ fprintf(stderr, "Finish from %x\n", sender_id);
+ if (!Finishing) {
+ long buf = (long) StatsTask;
+ Finishing = rtsTrue;
+ pvm_initsend(PvmDataDefault);
+ pvm_pklong(&buf, 1, 1);
+ pvm_bcast(PEGROUP, PP_FINISH);
+ } else {
+ ++PEsTerminated;
+ }
+
+ if (PEsTerminated >= nPEs) {
+ broadcast(PEGROUP, PP_FINISH);
+ broadcast(MGRGROUP, PP_FINISH);
+ pvm_lvgroup(PEGROUP);
+ pvm_lvgroup(PECTLGROUP);
+ pvm_lvgroup(MGRGROUP);
+ pvm_exit();
+ EXIT(EXIT_SUCCESS);
+ }
+ break;
+
+ case PP_FAIL:
+ fprintf(stderr, "Fail from %x\n", sender_id);
+ if (!Finishing) {
+ Finishing = rtsTrue;
+ broadcast(PEGROUP, PP_FAIL);
+ }
+ break;
+
+ default:
+ {
+/* char *opname = GetOpName(opcode);
+ fprintf(stderr,"Sysman: Unrecognised opcode %s (%x)\n",
opname,opcode); */
- fprintf(stderr, "Sysman: Unrecognised opcode (%x)\n",
- opcode);
- }
- break;
- }
+ fprintf(stderr, "Sysman: Unrecognised opcode (%x)\n",
+ opcode);
+ }
+ break;
+ }
}
}
}
#define IHaveSubdirs
-SUBDIRS = heap-view \
- hp2ps \
+SUBDIRS = hp2ps \
hscpp \
hstags \
mkdependHS \
stat2resid \
ugen \
unlit
+
+/* "heap-view" is not in the list because (a) it requires
+ a Haskell compiler (which you may not have yet), and (b) you are
+ unlikely to want it desperately. It is easy to build once you have
+ a Haskell compiler and if you want it.
+*/
#
# Note: There must be no white space between { }s
# Use ( )s around type names when separation is required
-#
$Verbose = 0;
+
+$DoGenSpecs = 0;
+$DoGenSpecsUnboxed = 0;
+@SpecingTypes = ();
+
while ($#ARGV >= 0 && $ARGV[0] eq '-v' || $ARGV[0] =~ /^-genSPECS/) {
if ($ARGV[0] eq '-v') {
$Verbose = 1;
- } elsif ( $ARGV[0] eq '-genSPECS0' ) { # do it, but no SpecingString
- $SpecingString = '';
- @SpecingTypes = ();
+ } elsif ($ARGV[0] eq '-genSPECS') {
$DoGenSpecs = 1;
- } else {
- shift(@ARGV);
- $SpecingString = $ARGV[0];
- @SpecingTypes = split(/,/, $SpecingString);
+ } elsif ($ARGV[0] eq '-genSPECSunboxed') {
$DoGenSpecs = 1;
+ $DoGenSpecsUnboxed = 1;
+ $SpecingString = "Char#,Int#,Double#";
+ @SpecingTypes = split(/,/, $SpecingString);
+ } else {
+ die "hscpp: unrecognised argument: $$ARGV[0]\n";
}
shift(@ARGV);
}
# genSPEC processing:
if ( /^\s*\{-#\s*GENERATE_SPECS/ ) {
if ( $DoGenSpecs ) {
+ $line = $_;
$data_or_inst = 0;
$data_inst_str = "";
$remove_poly = 1;
+ $space = "";
if ( /^\s*\{-#\s*GENERATE_SPECS\s+(data)\s+(\S.*)\s*::(.*)#-\}\s*$/ ) {
$data_or_inst = 1;
$data_inst_str = $1;
$vars = $2;
$type = $3;
- } elsif ( /^\s*\{-#\s*GENERATE_SPECS\s+(\S+)\s+(.*)\s*#-\}\s*$/ ) {
- $line = $_;
- $fun = $1;
- $vars = $2;
+ } elsif ( /^(\s*)\{-#\s*GENERATE_SPECS\s+(\S+)\s+(.*)\s*#-\}\s*$/ ) {
+ $space = $1;
+ $fun = $2;
+ $vars = $3;
$tysig = <INPIPE>;
while ( $tysig =~ /^\s*$/ ) {
if ( $var =~ /^(\w+)\{(.*)\}$/ ) {
$var = $1;
- @specing_types = split(/,/, $2);
+ @specing_types = &split_types($2);
if ($specing_types[0] eq '~') {
shift(@specing_types);
@tospec = (); # remove specs polymorphic in this tyvar
} else {
@specing_types = @SpecingTypes;
}
+
+ # If not $DoGenSpecsUnboxed we remove any unboxed types
+ # (i.e. types containing a #) from the specing_types
+
+ @specing_types = grep(!/#/, @specing_types) if ! $DoGenSpecsUnboxed;
foreach $uty (@specing_types) {
@speced = @specing;
if ($#tospec >= 0) {
$specty = shift(@tospec);
- print ($data_or_inst ? "{-# SPECIALIZE $data_inst_str $specty #-}" : "{-# SPECIALIZE $fun :: $specty");
+ print ($data_or_inst ? "{-# SPECIALIZE $data_inst_str $specty #-}" : "$space{-# SPECIALIZE $fun :: $specty");
while ($#tospec >= 0) {
$specty = shift(@tospec);
print ($data_or_inst ? "; {-# SPECIALIZE $data_inst_str $specty #-}" : ", $specty");
}
print ($data_or_inst ? "\n" : " #-}\n");
} else {
- print "{-# NO_SPECS_GENERATED ", $data_or_inst ? $specty : $fun, " #-}\n";
+ print "{- NO_SPECS_GENERATED ", $data_or_inst ? $specty : $fun, " -}\n";
+ print STDERR "Warning: No specs for GENERATE_SPECS pre-processing pragma:\n $_";
}
print $tysig if ! $data_or_inst;
} else {
}
close(INPIPE) || exit(1); # exit is so we reflect any errors.
+
+exit(0);
+
+
+# splits a list of types seperated by ,s but allowing ,s within ()s
+
+
+sub split_types {
+ local($type_str) = @_;
+
+ local(@chars) = split(//,$type_str);
+ local($depth) = 0;
+ local($start) = 0;
+ local($cur) = 0;
+ local($char);
+
+ local(@types) = ();
+
+ while ($char = $chars[$cur]) {
+ if ($char eq ',' && $depth == 0) {
+ push(@types, join('', @chars[$start .. $cur-1])) if ($start < $cur);
+ $start = $cur+1;
+ } elsif ($char eq '(') {
+ $depth++;
+ } elsif ($char eq ')') {
+ $depth--;
+ }
+ $cur++;
+ }
+ if ($depth == 0) {
+ push(@types, join('', @chars[$start .. $cur-1])) if ($start < $cur);
+ } else {
+ print STDERR "Error: GENERATE_SPECS pre-processing pragma has unbalanced ( )s\n$line\n";
+ exit(1);
+ }
+ return(@types);
+}
+
+
+
(dp->d_name[1] == '\0' || (dp->d_name[1] == '.' &&
dp->d_name[2] == '\0')))
continue;
+ if (!strcmp (dp->d_name, "CVS")) /* partain */
+ continue;
if (!strcmp (dp->d_name, "RCS"))
continue;
if (!strcmp (dp->d_name, "SCCS"))