w6b      !"#$%&'()*+,-./0123456789:;<=>?@ABCDEFGHIJKLMNOPQRSTUVWXYZ[\]^_`abcdefghijklmnopqrstuvwxyz{|}~      !"#$%&'()*+,-./0123456789:;<=>?@ABCDEFGHIJKLMNOPQRSTUVWXYZ[\]^_`abcdefghijklmnopqrstuvwxyz{|}~      !"#$%&'()*+,-./0123456789:;<=>?@ABCDEFGHIJKLMNOPQR S T U V W X Y Z [ \ ] ^ _ ` 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 { | } ~                                                                                                                                                                   ! " # $ % & ' ( ) * + , - . / 0 1 2 3 4 5 6 7 8 9 : ; < = > ? @ 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  Safe bcdefghijklmncijklmn bcdefghijklmn#(c) 2008--2009 Universiteit UtrechtBSD3generics@haskell.org experimental non-portableNone+oIndicates whether Generic(1) is being derived for a plain data type (DataPlain) or a data family instance (DataFamily). DataFamily bundles the Name of the data family instance's first constructor (for Name-generation purposes) and the types used to instantiate the instance.pLike  GenericArity!, but bundling two things in the q case: The r of the last type parameter.XIf that last type parameter had kind k (where k is some kind variable), then it has s the kind variable r. Otherwise, it has t.u7Indicates whether Generic or Generic1 is being derived.vEWhether a type is not of kind *, is of kind *, or is a kind variable.wBExpands all type synonyms in a type. Written by Dan Rosn in the  genifunctors package (licensed under BSD3).x8Does a Type have kind * or k (for some kind variable k)?yReturns s the kind variable r of a v# if it exists. Otherwise, returns t.zjConcat together all of the StarKindStatuses that are IsKindVar and extract the kind variables' Names out.{"Returns True if a Type has kind *.|GGets all of the type/kind variable names mentioned somewhere in a Type.}Gets all of the required type/kind variable binders mentioned in a Type. This does not add separate items for kind variable binders (in contrast with the behavior of |).~bConverts a VarT or a SigT into Just the corresponding TyVarBndr. Converts other Types to Nothing.EIf a Type is a SigT, returns its kind signature. Otherwise, return *.Turns  [a, b] c into  a -> b -> c Turns  [k1, k2] k3 into k1 -> k2 -> k3 PIs the given type a type family constructor (and not a data family constructor)?*True if the type does not mention the Name)Construct a type via curried application.7Apply a type constructor name to type variable binders.HSplit an applied type into its individual components. For example, this: Either Int Char would split to this: [Either, Int, Char] ESplit a type signature by the arrows on its spine. For example, this: #forall a b. (a -> b) -> Char -> () would split to this: ([a, b], [a -> b, Char, ()]) )Like uncurryType, except on a kind level.KIf a VarT is missing an explicit kind signature, steal it from a TyVarBndr.KGenerate a list of fresh names with a common prefix, and numbered suffixes.Checks to see if the last types in a data family instance can be safely eta- reduced (i.e., dropped), given the other types. This checks for three conditions: +All of the dropped types are type variables%All of the dropped types are distinct<None of the remaining types mention any of the dropped typesdExtract the Name from a type variable. If the argument Type is not a type variable, throw an error.Is the given type a variable?Is the given kind a variable?Returns  is a  contains no type variables.6Peel off a kind signature from a Type (if it has one).;Peel off a kind signature from a TyVarBndr (if it has one).9Does the given type mention any of the Names in the list?AAre all of the items in a list (which have an ordering) distinct?HThis uses Set (as opposed to nub) for better asymptotic time complexity.AVariant of foldr1 which returns a special element for empty lists#Extracts the name of a constructor.;Extracts the constructors of a data or newtype declaration.*Credit to Vctor Lpez Juan for this trick}One of the last type variables cannot be eta-reduced (see the canEtaReduce function for the criteria it would have to meet).Either the given data type doesn't have enough type variables, or one of the type variables to be eta-reduced cannot realize kind *.HDeriving Generic(1) doesn't work with ExistentialQuantification or GADTs>Cannot have a constructor argument of form (forall a1 ... an.  type) when deriving Generic(1)"Boilerplate for top level splices.-The given Name must meet one of two criteria: JIt must be the name of a type constructor of a plain data type or newtype.NIt must be the name of a data family instance or newtype instance constructor.,Any other value will result in an exception.One cannot derive Generic(1) instance for anything that uses DatatypeContexts, so check to make sure the Cxt field of a datatype is null.opquvwxyz{|}~      !"#$%&'()*+,opquvwxyz{|}~      !"#$%&'()*+,opquvwxyz{|}~      !"#$%&'()*+,#(c) 2008--2009 Universiteit UtrechtBSD3generics@haskell.org experimental non-portableNoneNGiven the type and the name (as string) for the type to derive, generate the Data instance, the  Constructor instances, and the Selector instances.vOn GHC 7.11 and up, this functionality is no longer used in GHC generics, so this function generates no declarations.?Given a datatype name, derive a datatype and instance of class Datatype.vOn GHC 7.11 and up, this functionality is no longer used in GHC generics, so this function generates no declarations.@Given a datatype name, derive datatypes and instances of class  Constructor.vOn GHC 7.11 and up, this functionality is no longer used in GHC generics, so this function generates no declarations.?Given a datatype name, derive datatypes and instances of class Selector.vOn GHC 7.11 and up, this functionality is no longer used in GHC generics, so this function generates no declarations.-./0123456789 -./048-./0123456789#(c) 2008--2009 Universiteit UtrechtBSD3generics@haskell.org experimental non-portableNone(7 if generated code for empty data types should use the  EmptyCase extension, :: otherwise. This has no effect on GHCs before 7.8, since  EmptyCase# is only available in 7.8 or later.8 if explicit kind signatures should be used in derived 'Generic'/'Generic1' instances, : otherwise.Configures whether  'Rep'/'Rep1'7 type instances should be defined inline in a derived 'Generic'/'Generic1' instance (*) or defined in terms of a type synonym (). +Additional options for configuring derived 'Generic'/'Generic1'# instances using Template Haskell.Sensible default  ., a sensible default ., a sensible default .Sensible default .#A backwards-compatible synonym for .NGiven the type and the name (as string) for the type to derive, generate the Data instance, the  Constructor instances, the Selector instances, and the Representable0 instance.Like , but takes an   argument.NGiven the type and the name (as string) for the type to derive, generate the Data instance, the  Constructor instances, the Selector instances, and the Representable1 instance.Like , but takes an   argument.NGiven the type and the name (as string) for the type to derive, generate the Data instance, the  Constructor instances, the Selector instances, the Representable0 instance, and the Representable1 instance.Like , but takes an   argument.eGiven the type and the name (as string) for the Representable0 type synonym to derive, generate the Representable0 instance.Like , but takes an   argument.eGiven the type and the name (as string) for the Representable1 type synonym to derive, generate the Representable1 instance.Like , but takes an   argument.Derive only the Rep0 type synonym. Not needed if  is used.Like , but takes an  argument.Derive only the Rep1 type synonym. Not needed if  is used. Like , but takes an  argument.!Generates the full Repa type inline. Since this type can be quite large, it is recommended you only use this to define Rep, e.g., type Rep (Foo (a :: k) b) = $(! ''Foo [t| Foo (a :: k) b |]) You can then simply refer to  Rep (Foo a b) elsewhere.,Note that the type passed as an argument to !" must match the type argument of Rep? exactly, even up to including the explicit kind signature on aO. This is due to a limitation of Template Haskell without the kind signature, !) has no way of figuring out the kind of a?, and the generated type might be completely wrong as a result!"Generates the full Rep1a type inline. Since this type can be quite large, it is recommended you only use this to define Rep1, e.g., type Rep1 (Foo (a :: k)) = $(! ''Foo [t| Foo (a :: k) |]) You can then simply refer to  Rep1 (Foo a) elsewhere.,Note that the type passed as an argument to "" must match the type argument of Rep1? exactly, even up to including the explicit kind signature on aO. This is due to a limitation of Template Haskell without the kind signature, ") has no way of figuring out the kind of a?, and the generated type might be completely wrong as a result!#Generates the Rep) type synonym constructor (as opposed to , which generates the type synonym declaration). After splicing it into Haskell source, it expects types as arguments. For example: type Rep (Foo a b) = $(# ''Foo) a b  The use of # is generally discouraged, as it can sometimes be difficult to predict the order in which you are expected to pass type variables. As a result, !# is recommended instead. However, != is not usable on GHC 7.0, 7.2, or 7.4 due to a GHC bug, so #. still exists for GHC 7.0, 7.2, and 7.4 users.$Generates the Rep1) type synonym constructor (as opposed to , which generates the type synonym declaration). After splicing it into Haskell source, it expects types as arguments. For example: type Rep1 (Foo a) = $($ ''Foo) a  The use of $ is generally discouraged, as it can sometimes be difficult to predict the order in which you are expected to pass type variables. As a result, "# is recommended instead. However, "= is not usable on GHC 7.0, 7.2, or 7.4 due to a GHC bug, so $. still exists for GHC 7.0, 7.2, and 7.4 users.%Generates the Rep) type synonym constructor (as opposed to X, which generates the type synonym declaration) applied to its type arguments. Unlike #, this also takes a quoted  as an argument, e.g., type Rep (Foo (a :: k) b) = $(% ''Foo [t| Foo (a :: k) b |]) ,Note that the type passed as an argument to %" must match the type argument of Rep? exactly, even up to including the explicit kind signature on aO. This is due to a limitation of Template Haskell without the kind signature, %) has no way of figuring out the kind of a?, and the generated type might be completely wrong as a result! The use of %! is generally discouraged, since !o does exactly the same thing but without having to go through an intermediate type synonym, and as a result, ! tends to be less buggy.&Generates the Rep1) type synonym constructor (as opposed to X, which generates the type synonym declaration) applied to its type arguments. Unlike $, this also takes a quoted  as an argument, e.g., type Rep1 (Foo (a :: k)) = $(& ''Foo [t| Foo (a :: k) |]) ,Note that the type passed as an argument to &" must match the type argument of Rep? exactly, even up to including the explicit kind signature on aO. This is due to a limitation of Template Haskell without the kind signature, &) has no way of figuring out the kind of a?, and the generated type might be completely wrong as a result! The use of &! is generally discouraged, since "o does exactly the same thing but without having to go through an intermediate type synonym, and as a result, " tends to be less buggy.'#A backwards-compatible synonym for (.(1Generates a lambda expression which behaves like from.)Like ), but takes an  argument.*#A backwards-compatible synonym for +.+1Generates a lambda expression which behaves like to.,Like ,, but takes an  argument.-1Generates a lambda expression which behaves like from1..Like ., but takes an  argument./1Generates a lambda expression which behaves like to1.0Like 0, but takes an  argument.;FDeduces the instance type (and kind) to use for a Generic(1) instance.V <= >?@!"#$%&ABC'()*+,-./0DEFGHIJKLMNOPQRSTUVWXYZ[\]^_`a;Generic or Generic1CWhether or not to use explicit kind signatures in the instance type(The type constructor or data family name=The type variables from the data type/data family declarationUIf using a data family instance, provides the types used to instantiate the instancebGeneric or Generic1CWhether or not to use explicit kind signatures in the instance type(The type constructor or data family name*The types to instantiate the instance withc1  !"#$%&'()*+,-./01!#%'(*+"$&-/  ),.0P  <= >?@!"#$%&ABC'()*+,-./0DEFGHIJKLMNOPQRSTUVWXYZ[\]^_`a;bcSafe +9;<=DQRSafe/02349;<=BDQRcdefghijklmnopqrstuvwxyz{|}~Safecdefghijklmnopqrstuvwxyz{|}~(c) 2012 University of OxfordBSD3generics@haskell.org experimental non-portableSafe +9:;DQRT<FReturn the name of all the constructors of the type of the given term.=4Return the name of the constructor of the given term9:;<=>?@9:;<=9:;<=9:;<=>?@Safe +69:;DQR ABCDEFGHIJKLMNOPQRSTUVWXYZ[\]^_`ABCDEABBECDABBCDEFGHIJKLMNOPQRSTUVWXYZ[\]^_` Trustworthy +69:;BDQRabcdefghijklmnopqrstuvwxyz{|}~abcdeabbecdabbcdefghijklmnopqrstuvwxyz{|}~ Trustworthy +69:;DQR>The list of values in the subrange defined by a bounding pair.,The position of a subscript in the subrange.Returns B the given subscript lies in the range defined the bounding pair.wInterleave elements from two lists. Similar to (++), but swap left and right arguments on every recursive application. From Mark Jones' talk at AFP2008{Diagonalization of nested lists. Ensure that some elements from every sublist will be included. Handles infinite sublists. From Mark Jones' talk at AFP2008      !"#$%&'()*+,-./0123456789:;<=>?@ABCDEFGHIJKLMNOPQRSTUVWXYZ[\]^_`abcdefghijklmnopqrstuvwxyz{|}~      !"#$%&'()*+,-./0123456789:;<=>?@ABCDEFGHIJKLMNOPQRSTUVWXYZ[\]^_`abcdefghijklmnopqrstuvwxyz{|}~5Safe +69:;DQRC: Safe +69:;DQRa/      !"-      !"Safe+6:DQR$Generic %Generic &Generic /#$%&'()*+,-./0123456789:;<=>?@ABCDEFGHIJKLMNOPQ.#$%&'()*+,-./0#$%&$%-.*+,/0'()(#$%&$%'()*+,-./0123456789:;<=>?@ABCDEFGHIJKLMNOPQ Safe+6:DQRUOnly available with base-4.9 or later,RSTUVWXYZ[\]^_`abcdefghijklmnopqrstuvwxyz{|}RSTUVWXRSSTUXVW(RSSTUVWXYZ[\]^_`abcdefghijklmnopqrstuvwxyz{|}S6W6X6  Trustworthy 69:;BQRTa~~ ~}~ Safe +69:;DQRa/      !"#$%&'()*+ *      !"#$%&'()*+ 42011-2012 Universiteit Utrecht, University of OxfordBSD3generics@haskell.org experimental non-portable Trustworthy +69:;<=DQR8,-./0123456789:;<=>?@ABCDEFGHIJKLMNOPQRSTUVWXYZ[\]^_`a,12-./03456789:;<=>?@ABCDE ,--..//001122?@ABCDE9:;<=>345678,, --..//0011223456789:;<=>?@ABCDEFGHIJKLMNOPQRSTUVWXYZ[\]^_`aSafedefghijklmnopqrstuvwxyz{|}~9:;<=ABCDEabcde~,12-./03456789:;<=>?@ABCDE !"#$%&'()*+,-./0123456789:;<=>?@ABCDEFGHIJKLMNOPQRSTUVWXYZ[\]^_`abcdefghijklmnopqrstuvwxyz{|}~      !"#$%&'()*+,-./0123456789:;<=>?@ABCDEFGHIJKLMNOPQRSTUVWXYZ[\]^_`abcdefghijklmnopqrstuvwxyz{|}~      !"#$%&'()*+,-./0123456789:;<=>?@ABCDEFGHIJKLMNOPQRSTUVWXYZ[\]^_`abcd e f g h i j k l m n o p q r s t u v w x y z { | } ~                                                                                                                                                                   ! " # $ % & ' ( ) * + , - . / 0 1 2 3 4 5 6 7 8 9 : ; < = > ? @ 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 g h i j k l m n o p q r s t u v w x y z { | } ~         !"#$%&'()*+,-./0123456789:;<=>?@ABCDEFFGHIJKLMNOPQRSTUVWXYZ[\]^_`abcdefghijklmnopqrstuvwxyz{||}|~||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||         ,generic-deriving-1.12-10OZVfRpTc2IzQMHWQ9WBkGenerics.Deriving.THGenerics.Deriving.ConNamesGenerics.Deriving.CopointGenerics.Deriving.EqGenerics.Deriving.EnumGenerics.Deriving.FoldableGenerics.Deriving.FunctorGenerics.Deriving.MonoidGenerics.Deriving.SemigroupGenerics.Deriving.ShowGenerics.Deriving.TraversableGenerics.Deriving.UniplatePaths_generic_derivingGenerics.Deriving.TH.InternalGenerics.Deriving.TH.Post4_9Generics.Deriving.InstancesGenerics.Deriving.Base.InternalGenerics.Deriving.BaseGenerics.Deriving deriveMeta deriveDataderiveConstructorsderiveSelectorsEmptyCaseOptionsKindSigOptions RepOptions InlineRepTypeSynonymRepOptions repOptionskindSigOptionsemptyCaseOptionsdefaultOptionsdefaultRepOptionsdefaultKindSigOptionsdefaultEmptyCaseOptions deriveAll deriveAll0deriveAll0Options deriveAll1deriveAll1OptionsderiveAll0And1deriveAll0And1OptionsderiveRepresentable0deriveRepresentable0OptionsderiveRepresentable1deriveRepresentable1Options deriveRep0deriveRep0Options deriveRep1deriveRep1OptionsmakeRep0InlinemakeRep1InlinemakeRep0makeRep1makeRep0FromTypemakeRep1FromTypemakeFrom makeFrom0makeFrom0OptionsmakeTomakeTo0makeTo0Options makeFrom1makeFrom1OptionsmakeTo1makeTo1Options$fEqRepOptions$fOrdRepOptions$fReadRepOptions$fShowRepOptions $fEqOptions $fOrdOptions $fReadOptions $fShowOptionsConNames gconNames gconNameOfconNames conNameOf$fConNamesTYPEM1$fConNamesTYPEM10$fConNamesTYPE:+:GCopointgcopoint GCopoint' gcopoint'gcopointdefault$fGCopointWrappedMonoid$fGCopointWrappedMonad $fGCopointSum$fGCopointSum0 $fGCopointMin $fGCopointMax$fGCopointLast$fGCopointIdentity$fGCopointFirst$fGCopointDual $fGCopointArg $fGCopointAlt$fGCopoint(,,,,,,)$fGCopoint(,,,,,)$fGCopoint(,,,,)$fGCopoint(,,,)$fGCopoint(,,) $fGCopoint(,)$fGCopoint':.:$fGCopoint'Rec1$fGCopoint':*:$fGCopoint':+: $fGCopoint'M1 $fGCopoint'K1$fGCopoint'Par1 $fGCopoint'U1 $fGCopoint'V1GEqgeqGEq'geq' geqdefault $fGEqZipList$fGEqWrappedMonoid $fGEqWordPtr $fGEqWord64 $fGEqWord32 $fGEqWord16 $fGEqWord8 $fGEqWord $fGEqVoid $fGEqVersion $fGEqURec $fGEqURec0 $fGEqURec1 $fGEqURec2 $fGEqURec3 $fGEqURec4$fGEqU1$fGEqSum$fGEqSourceUnpackedness$fGEqSourceStrictness$fGEqStablePtr $fGEqSeekMode $fGEqRec1$fGEqPtr $fGEqProxy $fGEqProduct $fGEqPar1 $fGEqOrdering $fGEqOption $fGEqNonEmpty $fGEqNatural$fGEqMin$fGEqMax $fGEqMaybe$fGEqM1 $fGEqLast $fGEqLast0$fGEqK1 $fGEqIOMode$fGEqIOErrorType$fGEqIOException $fGEqIntPtr $fGEqInteger $fGEqInt64 $fGEqInt32 $fGEqInt16 $fGEqInt8$fGEqInt $fGEqIdentity$fGEqHandlePosn $fGEqHandle$fGEqGeneralCategory $fGEqFunPtr$fGEqForeignPtr $fGEqFloat $fGEqFixity $fGEqFirst $fGEqFirst0$fGEqFd $fGEqExitCode $fGEqErrno $fGEqEither $fGEqDual $fGEqDouble$fGEqDecidedStrictness $fGEqCWchar $fGEqCUShort$fGEqCUSeconds $fGEqCULong $fGEqCULLong $fGEqCUIntPtr $fGEqCUIntMax $fGEqCUInt $fGEqCUid $fGEqCUChar $fGEqCTime $fGEqCTcflag $fGEqCSsize $fGEqCSize$fGEqCSigAtomic $fGEqCShort$fGEqCSUSeconds $fGEqCSpeed $fGEqCSChar $fGEqCRLim $fGEqCPtrdiff $fGEqCPid $fGEqConst $fGEqComplex $fGEqCOff $fGEqCNlink $fGEqCMode $fGEqCLong $fGEqCLLong $fGEqCIntPtr $fGEqCIntMax $fGEqCInt $fGEqCIno $fGEqChar $fGEqCGid $fGEqCFloat $fGEqCDouble $fGEqCDev $fGEqCClock $fGEqCChar$fGEqCCc$fGEqBufferMode $fGEqBool$fGEqAssociativity$fGEqArg$fGEqAny$fGEqAlt$fGEqAll$fGEq:.:$fGEq:*:$fGEq:+:$fGEq[] $fGEq(,,,,,,) $fGEq(,,,,,) $fGEq(,,,,) $fGEq(,,,) $fGEq(,,)$fGEq(,)$fGEq()$fGEq'TYPEURec$fGEq'TYPEURec0$fGEq'TYPEURec1$fGEq'TYPEURec2$fGEq'TYPEURec3$fGEq'TYPEURec4 $fGEq'TYPE:*: $fGEq'TYPE:+: $fGEq'TYPEM1 $fGEq'TYPEK1 $fGEq'TYPEU1 $fGEq'TYPEV1GIxrangeindexinRangeGEnumgenumEnum'enum' genumDefault toEnumDefaultfromEnumDefault rangeDefault indexDefaultinRangeDefault$fGIxWrappedMonoid $fGIxWordPtr $fGIxWord64 $fGIxWord32 $fGIxWord16 $fGIxWord8 $fGIxWord$fGIxSum $fGIxProxy $fGIxProduct $fGIxOrdering $fGIxOption $fGIxNonEmpty $fGIxNatural$fGIxMin $fGIxMaybe$fGIxMax $fGIxLast $fGIxLast0 $fGIxIntPtr $fGIxInteger $fGIxInt64 $fGIxInt32 $fGIxInt16 $fGIxInt8$fGIxInt $fGIxIdentity $fGIxFixity $fGIxFirst $fGIxFirst0$fGIxFd $fGIxExitCode $fGIxEither $fGIxDual $fGIxCWchar $fGIxCUShort $fGIxCULong $fGIxCULLong $fGIxCUIntPtr $fGIxCUIntMax $fGIxCUInt $fGIxCUid $fGIxCUChar $fGIxCTcflag $fGIxCSsize $fGIxCSize$fGIxCSigAtomic $fGIxCShort $fGIxCSChar $fGIxCRLim $fGIxCPtrdiff $fGIxCPid $fGIxCOff $fGIxCNlink $fGIxCMode $fGIxCLong $fGIxCLLong $fGIxCIntPtr $fGIxCIntMax $fGIxCInt $fGIxCIno $fGIxCGid $fGIxCChar $fGIxBool$fGIxAssociativity$fGIxArg$fGIxAny$fGIxAlt$fGIxAll$fGIx[] $fGIx(,,,,,,) $fGIx(,,,,,) $fGIx(,,,,) $fGIx(,,,) $fGIx(,,)$fGIx(,)$fGIx()$fGEnumZipList$fGEnumWrappedMonoid$fGEnumWordPtr $fGEnumWord64 $fGEnumWord32 $fGEnumWord16 $fGEnumWord8 $fGEnumWord $fGEnumU1 $fGEnumSum $fGEnumRec1 $fGEnumProxy$fGEnumProduct $fGEnumPar1$fGEnumOrdering $fGEnumOption$fGEnumNonEmpty$fGEnumNatural $fGEnumMin $fGEnumMaybe $fGEnumMax $fGEnumM1 $fGEnumLast $fGEnumLast0 $fGEnumK1 $fGEnumIntPtr$fGEnumInteger $fGEnumInt64 $fGEnumInt32 $fGEnumInt16 $fGEnumInt8 $fGEnumInt$fGEnumIdentity $fGEnumFloat $fGEnumFixity $fGEnumFirst $fGEnumFirst0 $fGEnumFd$fGEnumExitCode $fGEnumEither $fGEnumDual $fGEnumDouble $fGEnumCWchar$fGEnumCUShort$fGEnumCUSeconds $fGEnumCULong$fGEnumCULLong$fGEnumCUIntPtr$fGEnumCUIntMax $fGEnumCUInt $fGEnumCUid $fGEnumCUChar $fGEnumCTime$fGEnumCTcflag $fGEnumCSsize $fGEnumCSize$fGEnumCSigAtomic $fGEnumCShort$fGEnumCSUSeconds $fGEnumCSpeed $fGEnumCSChar $fGEnumCRLim$fGEnumCPtrdiff $fGEnumCPid $fGEnumConst$fGEnumComplex $fGEnumCOff $fGEnumCNlink $fGEnumCMode $fGEnumCLong $fGEnumCLLong$fGEnumCIntPtr$fGEnumCIntMax $fGEnumCInt $fGEnumCIno $fGEnumCGid $fGEnumCFloat$fGEnumCDouble $fGEnumCDev $fGEnumCClock $fGEnumCChar $fGEnumCCc $fGEnumBool$fGEnumAssociativity $fGEnumArg $fGEnumAny $fGEnumAlt $fGEnumAll $fGEnum:.: $fGEnum:*: $fGEnum:+: $fGEnum[]$fGEnum(,,,,,,)$fGEnum(,,,,,) $fGEnum(,,,,) $fGEnum(,,,) $fGEnum(,,) $fGEnum(,) $fGEnum()$fEnum'TYPE:*:$fEnum'TYPE:+: $fEnum'TYPEM1 $fEnum'TYPEK1 $fEnum'TYPEU1 GFoldablegfoldMapgfoldgfoldrgfoldr'gfoldlgfoldl'gfoldr1gfoldl1 GFoldable' gfoldMap'gfoldMapdefaultgtoListgconcat gconcatMapgandgorganygallgsumgproductgmaximum gmaximumBygminimum gminimumBygelemgnotElemgfind$fGFoldableZipList$fGFoldableWrappedMonoid$fGFoldableSum$fGFoldableSum0$fGFoldableProxy$fGFoldableProduct$fGFoldableProduct0$fGFoldableOption$fGFoldableNonEmpty$fGFoldableMin$fGFoldableMaybe$fGFoldableMax$fGFoldableLast$fGFoldableLast0$fGFoldableIdentity$fGFoldableFirst$fGFoldableFirst0$fGFoldableEither$fGFoldableDual$fGFoldableConst$fGFoldableComplex$fGFoldableArg $fGFoldable[]$fGFoldable(,)$fGFoldable'URec$fGFoldable'URec0$fGFoldable'URec1$fGFoldable'URec2$fGFoldable'URec3$fGFoldable'URec4$fGFoldable':.:$fGFoldable':*:$fGFoldable':+:$fGFoldable'M1$fGFoldable'Rec1$fGFoldable'K1$fGFoldable'Par1$fGFoldable'U1$fGFoldable'V1GFunctorgmap GFunctor'gmap' gmapdefault$fGFunctorZipList$fGFunctorWrappedMonoid $fGFunctorSum$fGFunctorSum0$fGFunctorProxy$fGFunctorProduct$fGFunctorProduct0$fGFunctorOption$fGFunctorNonEmpty $fGFunctorMin$fGFunctorMaybe $fGFunctorMax$fGFunctorLast$fGFunctorLast0 $fGFunctorIO$fGFunctorIdentity$fGFunctorFirst$fGFunctorFirst0$fGFunctorEither$fGFunctorDual$fGFunctorConst$fGFunctorComplex $fGFunctorArg $fGFunctorAlt $fGFunctor[] $fGFunctor(,)$fGFunctor(->)$fGFunctor'URec$fGFunctor'URec0$fGFunctor'URec1$fGFunctor'URec2$fGFunctor'URec3$fGFunctor'URec4$fGFunctor':.:$fGFunctor':*:$fGFunctor':+: $fGFunctor'M1$fGFunctor'Rec1 $fGFunctor'K1$fGFunctor'Par1 $fGFunctor'U1 $fGFunctor'V1GMonoidgmemptygmappendgmconcatMonoid'mempty'mappend'GMonoid'gmempty' gmappend'gmemptydefaultgmappenddefault memptydefaultmappenddefault$fGMonoid(,,,,,,,)$fGMonoid(,,,,,,)$fGMonoid(,,,,,)$fGMonoid(,,,,)$fGMonoid(,,,) $fGMonoid(,,) $fGMonoid(,)$fGMonoidWrappedMonoid$fGMonoidIdentity$fGMonoidProxy$fGMonoidConst $fGMonoid(->)$fGMonoidMaybe $fGMonoidDual $fGMonoidAlt $fGMonoidEndo $fGMonoid[]$fGMonoidProduct $fGMonoidSum $fGMonoidLast$fGMonoidFirst $fGMonoidAll $fGMonoidAny $fGMonoid()$fGMonoidOrdering$fMonoid'TYPE:*:$fMonoid'TYPEM1$fMonoid'TYPEK1$fMonoid'TYPEU1$fGMonoid'TYPE:*:$fGMonoid'TYPEM1$fGMonoid'TYPEK1$fGMonoid'TYPEU1 GSemigroupgsappendgstimesgsconcat GSemigroup' gsappend'gsappenddefault$fGSemigroup(,,,,,,,)$fGSemigroup(,,,,,,)$fGSemigroup(,,,,,)$fGSemigroup(,,,,)$fGSemigroup(,,,)$fGSemigroup(,,)$fGSemigroup(,)$fGSemigroupWrappedMonoid$fGSemigroupOption$fGSemigroupNonEmpty$fGSemigroupMin$fGSemigroupMax$fGSemigroupLast$fGSemigroupFirst$fGSemigroupVoid$fGSemigroupIdentity$fGSemigroupProxy$fGSemigroupEither$fGSemigroupConst$fGSemigroup(->)$fGSemigroupMaybe$fGSemigroupDual$fGSemigroupAlt$fGSemigroupEndo$fGSemigroup[]$fGSemigroupProduct$fGSemigroupSum$fGSemigroupLast0$fGSemigroupFirst0$fGSemigroupAll$fGSemigroupAny$fGSemigroup()$fGSemigroupOrdering$fGSemigroup'TYPE:*:$fGSemigroup'TYPEM1$fGSemigroup'TYPEK1$fGSemigroup'TYPEU1GShow gshowsPrecgshowsgshowGShow' gshowsPrec' isNullarygshowsPrecdefault$fGShowZipList$fGShowWrappedMonoid$fGShowWordPtr $fGShowWord64 $fGShowWord32 $fGShowWord16 $fGShowWord8 $fGShowWord $fGShowVoid$fGShowVersion $fGShowURec $fGShowURec0 $fGShowURec1 $fGShowURec2 $fGShowURec3 $fGShowU1 $fGShowSum $fGShow[]$fGShowSeekMode $fGShowRec1 $fGShowPtr $fGShowProxy$fGShowProduct $fGShowPar1$fGShowOrdering $fGShowOption$fGShowNonEmpty$fGShowNatural $fGShowMin $fGShowMaybe $fGShowMax $fGShowM1 $fGShowLast $fGShowLast0 $fGShowK1 $fGShowIOMode$fGShowIOErrorType$fGShowIOException $fGShowIntPtr$fGShowInteger $fGShowInt64 $fGShowInt32 $fGShowInt16 $fGShowInt8 $fGShowInt$fGShowIdentity$fGShowHandlePosn $fGShowHandle$fGShowGeneralCategory $fGShowFunPtr$fGShowForeignPtr $fGShowFloat $fGShowFixity $fGShowFirst $fGShowFirst0 $fGShowFd$fGShowExitCode $fGShowEither $fGShowDual $fGShowDouble $fGShowCWchar$fGShowCUShort$fGShowCUSeconds $fGShowCULong$fGShowCULLong$fGShowCUIntPtr$fGShowCUIntMax $fGShowCUInt $fGShowCUChar $fGShowCTime $fGShowCSize$fGShowCSigAtomic $fGShowCShort$fGShowCSUSeconds $fGShowCSChar$fGShowCPtrdiff $fGShowConst$fGShowComplex $fGShowCLong $fGShowCLLong$fGShowCIntPtr$fGShowCIntMax $fGShowCInt $fGShowChar $fGShowCFloat$fGShowCDouble $fGShowCClock $fGShowCChar$fGShowBufferMode $fGShowBool$fGShowAssociativity $fGShowArg $fGShowAny $fGShowAlt $fGShowAll $fGShow:.: $fGShow:*: $fGShow:+: $fGShow[]0$fGShow(,,,,,,)$fGShow(,,,,,) $fGShow(,,,,) $fGShow(,,,) $fGShow(,,) $fGShow(,) $fGShow() $fGShow'URec $fGShow'URec0 $fGShow'URec1 $fGShow'URec2 $fGShow'URec3 $fGShow':*: $fGShow':+: $fGShow'M1 $fGShow'M10 $fGShow'M11 $fGShow'K1 $fGShow'U1 $fGShow'V1 GTraversable gtraverse gsequenceAgmapM gsequence GTraversable' gtraverse'gtraversedefault$fGTraversableZipList$fGTraversableWrappedMonoid$fGTraversableSum$fGTraversableSum0$fGTraversableProxy$fGTraversableProduct$fGTraversableProduct0$fGTraversableOption$fGTraversableNonEmpty$fGTraversableMin$fGTraversableMaybe$fGTraversableMax$fGTraversableLast$fGTraversableLast0$fGTraversableIdentity$fGTraversableFirst$fGTraversableFirst0$fGTraversableEither$fGTraversableDual$fGTraversableConst$fGTraversableComplex$fGTraversableArg$fGTraversable[]$fGTraversable(,)$fGTraversable'URec$fGTraversable'URec0$fGTraversable'URec1$fGTraversable'URec2$fGTraversable'URec3$fGTraversable'URec4$fGTraversable':.:$fGTraversable':*:$fGTraversable':+:$fGTraversable'M1$fGTraversable'Rec1$fGTraversable'K1$fGTraversable'Par1$fGTraversable'U1$fGTraversable'V1UniplatechildrencontextdescenddescendM transform transformM Uniplate' children'descend' descendM' transform' transformM'childrendefaultcontextdefaultdescenddefaultdescendMdefaulttransformdefaulttransformMdefaultuniplateuniverserewriterewriteMcontextsholespara $fUniplate[]$fUniplateEither$fUniplateMaybe$fUniplate(,,,,,,)$fUniplate(,,,,,)$fUniplate(,,,,)$fUniplate(,,,)$fUniplate(,,) $fUniplate(,) $fUniplate() $fUniplateInt$fUniplateFloat$fUniplateDouble$fUniplateChar$fUniplateBool$fContext'TYPE:*:b$fContext'TYPE:*:a$fContext'TYPE:+:b$fContext'TYPEM1b$fContext'TYPEK1b$fContext'TYPEK1a$fContext'TYPEU1b$fUniplate'TYPE:*:b$fUniplate'TYPE:+:b$fUniplate'TYPEM1b$fUniplate'TYPEK1b$fUniplate'TYPEK1a$fUniplate'TYPEU1acatchIOversionbindirlibdirdatadir libexecdir sysconfdir getBinDir getLibDir getDataDir getLibexecDir getSysconfDirgetDataFileName DataVariety GenericKindGen1template-haskellLanguage.Haskell.TH.SyntaxNamebaseGHC.BaseJustNothing GenericClassStarKindStatus expandSyncanRealizeKindStarstarKindStatusToNamecatKindVarNames hasKindStartyVarNamesOfTyperequiredTyVarsOfTypetypeToTyVarBndrtypeKind makeFunType makeFunKind isTyFamilyground applyTyToTys applyTyToTvbs unapplyTy uncurryTy uncurryKindstealKindForType newNameList canEtaReduce varTToNameisTyVar isKindVarisTypeMonomorphicghc-prim GHC.TypesTrueTypeunSigT unKindedTV mentionsName allDistinctfoldr1'constructorName dataDecCons sanitizeNameetaReductionErrorderivingKindError gadtError rankNError reifyDataInfocheckDataContext DataPlain DataFamilyGen0GenericGeneric1 NotKindStarKindStar IsKindVar KindSubst TypeSubst expandSynKind expandSynAppmkSubst substType substKindsubstNameWithKindsubstNamesWithKindStarsubstTyVarBndrTypesubstTyVarBndrKind substNameWithKindStarInTyVarBndrtyVarBndrToType tyVarBndrName tyVarBndrKindfst3snd3trd3shrink reifyConTysshowsDataVariety showNameQualoutOfPlaceTyVarError gdPackageKey mkGD4'4_d mkGD4'9_d mkGD4'4_tc mkGD4'9_tc mkGD4'4_v mkGD4'9_v mkBaseName_dmkGHCPrimName_dmkGHCPrimName_tcmkGHCPrimName_v comp1DataName infixDataName k1DataName l1DataNameleftAssociativeDataName m1DataNamenotAssociativeDataName par1DataNameprefixDataNameproductDataName r1DataName rec1DataNamerightAssociativeDataName u1DataName uAddrDataName uCharDataNameuDoubleDataNameuFloatDataName uIntDataName uWordDataName c1TypeNamecomposeTypeNameconstructorTypeName d1TypeNamegenericTypeNamegeneric1TypeNamedatatypeTypeNamenoSelectorTypeName par1TypeNameproductTypeName rec0TypeName rec1TypeName repTypeName rep1TypeName s1TypeNameselectorTypeName sumTypeName u1TypeName uAddrTypeName uCharTypeNameuDoubleTypeNameuFloatTypeName uIntTypeName uWordTypeName v1TypeNameconFixityValNameconIsRecordValNameconNameValNamedatatypeNameValNameisNewtypeValName fromValName from1ValNamemoduleNameValNameselNameValName seqValName toValName to1ValNameuAddrHashValNameuCharHashValNameuDoubleHashValNameuFloatHashValNameuIntHashValNameuWordHashValNameunComp1ValName unK1ValName unPar1ValName unRec1ValName trueDataName falseDataNamenothingDataName justDataName mkGHCPrim_tcaddrHashTypeNamecharHashTypeNamedoubleHashTypeNamefloatHashTypeNameintHashTypeNamewordHashTypeNamecomposeValName errorValName fmapValNameundefinedValName starKindNamedecidedLazyDataNamedecidedStrictDataNamedecidedUnpackDataNameinfixIDataNamemetaConsDataNamemetaDataDataNamemetaNoSelDataNamemetaSelDataNamenoSourceStrictnessDataNamenoSourceUnpackednessDataNameprefixIDataNamesourceLazyDataNamesourceNoUnpackDataNamesourceStrictDataNamesourceUnpackDataNamepackageNameValName SelStrictInfomkMetaDataTypemkMetaConsType promoteBoolfixityIPromotedTypepromoteAssociativity mkMetaSelTypepromoteSourceUnpackednesspromoteSourceStrictnesspromoteDecidedStrictnessreifySelStrictInfo splitBangFalsebuildTypeInstancederiveAllCommonderiveRepresentableCommonderiveRepCommon deriveInstderiveInstCommon makeRepCommon makeRepInlinemakeRepTySynApp makeFunCommon genRepNamerepTyperepCon repConWithprodTrepField repFieldArgboxT mkCaseExpmkFrom errorFrommkToerrorTo ghc7'8OrLaterfromConprodE fromField fromFieldWrapwC boxRepNametoCon toConUnwCtoField toFieldWrapunwC unboxRepNamelrPlrEunboxedRepNamesbuildTypeInstanceFromTysgrabTyVarsFromCons GHC.GenericsRepfromtoRep1from1to1Datatype moduleName datatypeName packageName isNewtype ConstructorconName conFixity conIsRecordSelectorselNameselSourceUnpackednessselSourceStrictnessselDecidedStrictnessV1U1Par1unPar1Rec1unRec1K1unK1M1unM1:+:L1R1:*::.:Comp1unComp1RDCSRec0D1C1S1URecUAddrUCharUDoubleUFloatUIntUWorduWord#uInt#uFloat#uDouble#uChar#uAddr#precFixityPrefixInfixFixityIPrefixIInfixI AssociativityLeftAssociativeRightAssociativeNotAssociativeSourceUnpackedness SourceUnpackSourceNoUnpackNoSourceUnpackednessSourceStrictness SourceLazy SourceStrictNoSourceStrictnessDecidedStrictness DecidedLazy DecidedStrict DecidedUnpackMetaMetaDataMetaConsMetaSel|||diagskewcombine findIndexgenumNumUnboundedgenumNumSignedgenumNumUnsigned rangeEnum indexIntegral inRangeOrdmemptymappendmconcatMonoid Data.Monoid<>DualgetDualEndoappEndoAllgetAllAnygetAnySumgetSumProduct getProductFirstgetFirstLastgetLastAltgetAltRecTupPrefInf intersperseappPrecContext'context'