!q1N      !"#$%&'()*+,-./0123456789:;<=>?@ABCDEFGHIJKLMNOPQRSTUVWXYZ[\]^_`abcdefghijklmnopqrstuvwxyz{|}~      !"#$%&'()*+,-./0123456789:;<=>?@ABCDEFGHIJKLMNOPQRSTUVWXYZ[\]^_`abcdefghijklmnopqrstuvwxyz{|}~                       ! " # $ % & ' ( ) * + , - . / 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 { | } ~                                                                                                                                                                   ! " # $ % & ' ( ) * + , - . / 0 1 2 3 4 5 6 7 8 9 : ; < = >?@ABCDEFGHIJKLMSafe12456=?@AFHUV+cNOPQRSTUVWXYZ[\]^_`abcdefghijklmnopqrstuvwxyz{|}~Safe-17=?@AHUV-Safe.EcNOPQRSTUVWXYZ[\]^_`abcdefghijklmnopqrstuvwxyz{|}~Safe -8=>?HUVf0_Safe -8=>?HUV13845679:;<=>?@ABCDEFGHIJKLMN3845679:;>?@ABCDEFGHIJKLMN<= Trustworthy -8=>?FHUV2vwxyzvwzxy Trustworthy -8=>?HUVThe list of values in the subrange defined by a bounding pair.generic-deriving,The position of a subscript in the subrange.generic-derivingReturns B the given subscript lies in the range defined the bounding pair.generic-derivingwInterleave elements from two lists. Similar to (++), but swap left and right arguments on every recursive application. From Mark Jones' talk at AFP2008generic-deriving{Diagonalization of nested lists. Ensure that some elements from every sublist will be included. Handles infinite sublists. From Mark Jones' talk at AFP2008    5Safe -8=>?HUV=u(c) 2012 University of OxfordBSD3generics@haskell.org experimental non-portableSafe -=>?HUVXAgeneric-derivingFReturn the name of all the constructors of the type of the given term.generic-deriving4Return the name of the constructor of the given termSafe-8>HUVCS generic-derivingOnly available with base-4.9 or later    6 6 6Safe-8>HUVEggeneric-derivingGeneric generic-derivingGeneric generic-derivingGeneric 1 SafeFj        SafeF1    Trustworthy 8=>?FUVXfH  !"#$%&  !"&#$%#(c) 2008--2009 Universiteit UtrechtBSD3generics@haskell.org experimental non-portableSafe0%generic-deriving A version of H in which the data family instance constructors come equipped with the 7 of the first constructor in the family instance (for  generation purposes).generic-derivingLike  GenericArity!, but bundling two things in the  case: The  of the last type parameter.XIf that last type parameter had kind k (where k is some kind variable), then it has  the kind variable . Otherwise, it has .generic-deriving7Indicates whether Generic or Generic1 is being derived.generic-derivingEWhether a type is not of kind *, is of kind *, or is a kind variable.generic-deriving8Does a Type have kind * or k (for some kind variable k)?generic-derivingReturns  the kind variable  of a # if it exists. Otherwise, returns .generic-derivingjConcat together all of the StarKindStatuses that are IsKindVar and extract the kind variables' Names out.generic-deriving"Returns True if a Type has kind *.generic-derivingbConverts a VarT or a SigT into Just the corresponding TyVarBndr. Converts other Types to Nothing.generic-derivingEIf a Type is a SigT, returns its kind signature. Otherwise, return *.generic-derivingTurns  [a, b] c into  a -> b -> c generic-derivingTurns  [k1, k2] k3 into k1 -> k2 -> k3 generic-deriving]Detect if a Name occurs as an argument to some type family. This makes an effort to exclude  oversaturatedV arguments to type families. For instance, if one declared the following type family:  type family F a :: Type -> Type Then in the type F a b, we would consider a to be an argument to F , but not b.generic-deriving*True if the type does not mention the Namegeneric-deriving)Construct a type via curried application.generic-deriving7Apply a type constructor name to type variable binders.generic-derivingHSplit an applied type into its individual components. For example, this: Either Int Char would split to this: [Either, Int, Char] generic-derivingESplit 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, ()]) generic-deriving)Like uncurryType, except on a kind level.generic-derivingKGenerate a list of fresh names with a common prefix, and numbered suffixes.generic-derivingChecks 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 typesgeneric-derivingdExtract the Name from a type variable. If the argument Type is not a type variable, throw an error.generic-derivingIs the given type a variable?generic-derivingIs the given kind a variable?generic-derivingReturns  is a  contains no type variables.generic-deriving6Peel off a kind signature from a Type (if it has one).generic-deriving;Peel off a kind signature from a TyVarBndr (if it has one).generic-deriving9Does the given type mention any of the Names in the list?generic-derivingAAre all of the items in a list (which have an ordering) distinct?HThis uses Set (as opposed to nub) for better asymptotic time complexity.generic-deriving*Credit to Vctor Lpez Juan for this trickgeneric-deriving}One of the last type variables cannot be eta-reduced (see the canEtaReduce function for the criteria it would have to meet).generic-derivingEither the given data type doesn't have enough type variables, or one of the type variables to be eta-reduced cannot realize kind *.generic-derivingThe data type mentions the last type variable in a place other than the last position of a data type in a constructor's field.generic-deriving>Cannot have a constructor argument of form (forall a1 ... an.  type) when deriving Generic(1)generic-deriving"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.generic-derivingOne cannot derive Generic(1) instance for anything that uses DatatypeContexts, so check to make sure the Cxt field of a datatype is null.generic-derivingIDeriving Generic(1) doesn't work with ExistentialQuantification or GADTs.      !"#$%&'()*+,-./0123456789:;<=>?@ABCDEFGHIJKLMNOPQRSTUVWXYZ[\]^_`abcdefghijklmnopqrstuvwxyz{|}~#(c) 2008--2009 Universiteit UtrechtBSD3generics@haskell.org experimental non-portableSafegeneric-derivingNGiven 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.generic-deriving?Given a datatype name, derive a datatype and instance of class .vOn GHC 7.11 and up, this functionality is no longer used in GHC generics, so this function generates no declarations.generic-deriving@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.generic-deriving?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.  #(c) 2008--2009 Universiteit UtrechtBSD3generics@haskell.org experimental non-portableSafe-'generic-deriving7 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.generic-deriving8 if explicit kind signatures should be used in derived 'Generic'/'Generic1' instances,  otherwise.generic-derivingConfigures whether  'Rep'/'Rep1'7 type instances should be defined inline in a derived 'Generic'/'Generic1' instance (*) or defined in terms of a type synonym ().generic-deriving+Additional options for configuring derived 'Generic'/'Generic1'# instances using Template Haskell.generic-derivingSensible default .generic-deriving, a sensible default .generic-deriving, a sensible default .generic-derivingSensible default .generic-deriving#A backwards-compatible synonym for .generic-derivingNGiven 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.generic-derivingLike , but takes an  argument.generic-derivingNGiven 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.generic-derivingLike , but takes an  argument.generic-derivingNGiven 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.generic-derivingLike , but takes an  argument.generic-derivingeGiven the type and the name (as string) for the Representable0 type synonym to derive, generate the Representable0 instance.generic-derivingLike , but takes an  argument.generic-derivingeGiven the type and the name (as string) for the Representable1 type synonym to derive, generate the Representable1 instance.generic-derivingLike , but takes an  argument.generic-derivingDerive only the Rep0 type synonym. Not needed if  is used.generic-derivingLike , but takes an  argument.generic-derivingDerive only the Rep1 type synonym. Not needed if  is used.generic-derivingLike , but takes an  argument.generic-derivingGenerates 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!generic-derivingGenerates 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!generic-derivingGenerates 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.generic-derivingGenerates 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.generic-derivingGenerates 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.generic-derivingGenerates 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.generic-deriving#A backwards-compatible synonym for .generic-deriving1Generates a lambda expression which behaves like from.generic-derivingLike , but takes an  argument.generic-deriving#A backwards-compatible synonym for .generic-deriving1Generates a lambda expression which behaves like to.generic-derivingLike , but takes an  argument.generic-deriving1Generates a lambda expression which behaves like from1.generic-derivingLike , but takes an  argument.generic-deriving1Generates a lambda expression which behaves like to1.generic-derivingLike , but takes an  argument.generic-derivingGeneric or Generic1generic-derivingCWhether or not to use explicit kind signatures in the instance typegeneric-deriving(The type constructor or data family namegeneric-deriving*The types to instantiate the instance with11 Safe -8=>?HUVfC 42011-2012 Universiteit Utrecht, University of OxfordBSD3generics@haskell.org experimental non-portable Trustworthy -8=>?@AHUV      !     ! *Default implementations of generic classes BSD-3-Clausegenerics@haskell.org experimental non-portableSafe8>->generic-derivingeThis newtype wrapper can be used to derive default instances for classes taking an argument of kind  -> .Ageneric-derivingeThis newtype wrapper can be used to derive default instances for classes taking an argument of kind .Fgeneric-deriving8Semigroups often have many sensible implementations of  / :, and therefore no sensible default. Indeed, there is no  , instance for representations of sum types.FIn other cases, one may wish to use the existing wrapper newtypes in base, such as the following (using ): (newtype FirstSemigroup = FirstSemigroup  deriving stock (, ) deriving () via ( ) Ggeneric-derivingFor example, with this type: newtype TestShow = TestShow  deriving () via (A ) ! for TestShow" would produce the same string as ! for .In this example, TestShow requires no N! instance, as the constraint on  from A  is N .jIn general, when using a newtype wrapper, the instance can be derived via the wrapped type, as here (via A  rather than A TestShow).Hgeneric-derivingThe  class in base% is slightly different; it comprises  and . Generics.Deriving.Enum provides functions  and .>?@ABCABC>?@Safe-NOPQRSTUVWXYZ[\]^_`abcdefghijklmnopqrstuvwxyz{|}~vwxyz   !"#$%&      !>?@ABCSafe0 !"#$%&'()*+,-./0123456789:;<=>?@ABCDEFGHIJKLMNOPQRSTUVWXYZ[\]^_`abcdefghijklmnopqrstuvwxyz{|}~      !"#$%&'()*+,-./0123456789:;<=>?@ABCDEFGHIJKLMNOPQRSTUVWXYZ[\]^_`abcdefghijklmnopqrstuvwxyz{|}~      !"#$%&'()*+,-./01234567 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 { | } ~                                                                                                                                                                ! " # $ % & ' ( ) * + , - . / 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 XYYZ[[\]^_`abcdefghighjghkghlghmghnghoghpghqghrghsghtghughvghwghxghyghzgh{gh|gh}gh~ghghghghghghghghghghghghghghghghghghghghghghghghghghghghghghghghghghghghghghghghghghghghghghghghghghghghghghghghghghghghghghghghghghghghghghghghghghghghghggggggggggggggggggggggggggggggggggggg     mi !"#$%&'()*+,-./0123456789:;<=>?@ABCDEFGHIJKLMNOPQRSTUVWXYZ[\]^_`abcdefghijklmnopqrstuvwxyz{|}~q gggg,generic-deriving-1.14-LUPw2khag6g7icIuVRaI7NGenerics.Deriving.InstancesGenerics.Deriving.FunctorGenerics.Deriving.FoldableGenerics.Deriving.EqGenerics.Deriving.EnumGenerics.Deriving.CopointGenerics.Deriving.ConNamesGenerics.Deriving.SemigroupGenerics.Deriving.MonoidGenerics.Deriving.ShowGenerics.Deriving.THGenerics.Deriving.TraversableGenerics.Deriving.UniplateGenerics.Deriving.DefaultGenerics.Deriving.Base.InternalGenerics.Deriving.Base$Generics.Deriving.Semigroup.Internal!Generics.Deriving.Monoid.InternalGenerics.Deriving.TH.InternalGenerics.Deriving.TH.Post4_9 Data.KindTypeData.Semigroup<>FirstGenerics.DerivingPaths_generic_deriving Rep1Kleisli Rep0Kleisli$fGeneric1Kleisli$fGenericKleisliGFunctorgmap GFunctor'gmap' gmapdefault$fGFunctor'URec$fGFunctor'URec0$fGFunctor'URec1$fGFunctor'URec2$fGFunctor'URec3$fGFunctor'URec4$fGFunctor':*:$fGFunctor':+: $fGFunctor'M1 $fGFunctor'K1$fGFunctor'Par1 $fGFunctor'U1 $fGFunctor'V1$fGFunctorZipList$fGFunctorWrappedMonoid $fGFunctorSum$fGFunctorSum0$fGFunctorProxy$fGFunctorProduct$fGFunctorProduct0$fGFunctorNonEmpty $fGFunctorMin$fGFunctorMaybe $fGFunctorMax$fGFunctorLast$fGFunctorLast0 $fGFunctorIO$fGFunctorIdentity$fGFunctorFirst$fGFunctorFirst0$fGFunctorEither$fGFunctorDual$fGFunctorDown$fGFunctorConst$fGFunctorComplex $fGFunctorArg $fGFunctorAlt $fGFunctor[] $fGFunctor(,) $fGFunctor->$fGFunctor':.:$fGFunctor'Rec1 GFoldablegfoldMapgfoldgfoldrgfoldr'gfoldlgfoldl'gfoldr1gfoldl1 GFoldable' gfoldMap'gfoldMapdefaultgtoListgconcat gconcatMapgandgorganygallgsumgproductgmaximum gmaximumBygminimum gminimumBygelemgnotElemgfind$fGFoldable'URec$fGFoldable'URec0$fGFoldable'URec1$fGFoldable'URec2$fGFoldable'URec3$fGFoldable'URec4$fGFoldable':*:$fGFoldable':+:$fGFoldable'M1$fGFoldable'K1$fGFoldable'Par1$fGFoldable'U1$fGFoldable'V1$fGFoldableZipList$fGFoldableWrappedMonoid$fGFoldableSum$fGFoldableSum0$fGFoldableProxy$fGFoldableProduct$fGFoldableProduct0$fGFoldableNonEmpty$fGFoldableMin$fGFoldableMaybe$fGFoldableMax$fGFoldableLast$fGFoldableLast0$fGFoldableIdentity$fGFoldableFirst$fGFoldableFirst0$fGFoldableEither$fGFoldableDual$fGFoldableDown$fGFoldableConst$fGFoldableComplex$fGFoldableArg $fGFoldable[]$fGFoldable(,)$fGFoldable':.:$fGFoldable'Rec1GEqgeqGEq'geq' geqdefault $fGEq'kURec $fGEq'kURec0 $fGEq'kURec1 $fGEq'kURec2 $fGEq'kURec3 $fGEq'kURec4 $fGEq'k:*: $fGEq'k:+: $fGEq'kM1 $fGEq'kU1 $fGEq'kV1 $fGEqCTimer $fGEqCKey$fGEqCId$fGEqCFsFilCnt$fGEqCFsBlkCnt $fGEqCClockId $fGEqCBlkCnt $fGEqCBlkSize $fGEqCBool $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 $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 $fGEqDown $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'kK1GIxrangeindexinRangeGEnumgenumEnum'enum' genumDefault toEnumDefaultfromEnumDefault rangeDefault indexDefaultinRangeDefault $fEnum'k:*: $fEnum'k:+: $fEnum'kM1 $fEnum'kU1 $fGEnumCKey $fGEnumCId$fGEnumCFsFilCnt$fGEnumCFsBlkCnt$fGEnumCClockId$fGEnumCBlkCnt$fGEnumCBlkSize $fGEnumCBool$fGEnumZipList$fGEnumWrappedMonoid$fGEnumWordPtr $fGEnumWord64 $fGEnumWord32 $fGEnumWord16 $fGEnumWord8 $fGEnumWord $fGEnumU1 $fGEnumSum $fGEnumRec1 $fGEnumProxy$fGEnumProduct $fGEnumPar1$fGEnumOrdering$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'kK1 $fGIxCKey$fGIxCId$fGIxCFsFilCnt$fGIxCFsBlkCnt $fGIxCClockId $fGIxCBlkCnt $fGIxCBlkSize $fGIxCBool$fGIxWrappedMonoid $fGIxWordPtr $fGIxWord64 $fGIxWord32 $fGIxWord16 $fGIxWord8 $fGIxWord$fGIxSum $fGIxProxy $fGIxProduct $fGIxOrdering $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()GCopointgcopoint GCopoint' gcopoint'gcopointdefault$fGCopoint':*:$fGCopoint':+: $fGCopoint'M1 $fGCopoint'K1$fGCopoint'Par1 $fGCopoint'U1 $fGCopoint'V1$fGCopointWrappedMonoid$fGCopointWrappedMonad $fGCopointSum$fGCopointSum0 $fGCopointMin $fGCopointMax$fGCopointLast$fGCopointIdentity$fGCopointFirst$fGCopointDual$fGCopointDown $fGCopointArg $fGCopointAlt$fGCopoint(,,,,,,)$fGCopoint(,,,,,)$fGCopoint(,,,,)$fGCopoint(,,,)$fGCopoint(,,) $fGCopoint(,)$fGCopoint':.:$fGCopoint'Rec1ConNames gconNames gconNameOfconNames conNameOf $fConNameskM1$fConNameskM10$fConNamesk:+: GSemigroupgsappendgstimesgsconcat GSemigroup' gsappend'gsappenddefaultGMonoidgmemptygmappendgmconcatMonoid'mempty'mappend'GMonoid'gmempty' gmappend'gmemptydefaultgmappenddefault memptydefaultmappenddefault$fGSemigroupWrappedMonoid$fGMonoidWrappedMonoid$fGMonoidMaybeGShow gshowsPrecgshowsgshow gshowListGShow' gshowsPrec' isNullarygshowsPrecdefault $fGShow'URec $fGShow'URec0 $fGShow'URec1 $fGShow'URec2 $fGShow'URec3 $fGShow':*: $fGShow':+: $fGShow'M1 $fGShow'M10 $fGShow'M11 $fGShow'U1 $fGShow'V1 $fGShowCBool$fGShowZipList$fGShowWrappedMonoid$fGShowWordPtr $fGShowWord64 $fGShowWord32 $fGShowWord16 $fGShowWord8 $fGShowWord $fGShowVoid$fGShowVersion $fGShowURec $fGShowURec0 $fGShowURec1 $fGShowURec2 $fGShowURec3 $fGShowU1 $fGShowSum$fGShowSeekMode $fGShowRec1 $fGShowPtr $fGShowProxy$fGShowProduct $fGShowPar1$fGShowOrdering$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 $fGShowDown $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[]$fGShow(,,,,,,)$fGShow(,,,,,) $fGShow(,,,,) $fGShow(,,,) $fGShow(,,) $fGShow(,) $fGShow() $fGShow'K1 deriveMeta deriveDataderiveConstructorsderiveSelectorsEmptyCaseOptionsKindSigOptions RepOptions InlineRepTypeSynonymRepOptions repOptionskindSigOptionsemptyCaseOptionsdefaultOptionsdefaultRepOptionsdefaultKindSigOptionsdefaultEmptyCaseOptions deriveAll deriveAll0deriveAll0Options deriveAll1deriveAll1OptionsderiveAll0And1deriveAll0And1OptionsderiveRepresentable0deriveRepresentable0OptionsderiveRepresentable1deriveRepresentable1Options deriveRep0deriveRep0Options deriveRep1deriveRep1OptionsmakeRep0InlinemakeRep1InlinemakeRep0makeRep1makeRep0FromTypemakeRep1FromTypemakeFrom makeFrom0makeFrom0OptionsmakeTomakeTo0makeTo0Options makeFrom1makeFrom1OptionsmakeTo1makeTo1Options$fEqRepOptions$fOrdRepOptions$fReadRepOptions$fShowRepOptions $fEqOptions $fOrdOptions $fReadOptions $fShowOptions GTraversable gtraverse gsequenceAgmapM gsequence GTraversable' gtraverse'gtraversedefault$fGTraversable'URec$fGTraversable'URec0$fGTraversable'URec1$fGTraversable'URec2$fGTraversable'URec3$fGTraversable'URec4$fGTraversable':*:$fGTraversable':+:$fGTraversable'M1$fGTraversable'K1$fGTraversable'Par1$fGTraversable'U1$fGTraversable'V1$fGTraversableZipList$fGTraversableWrappedMonoid$fGTraversableSum$fGTraversableSum0$fGTraversableProxy$fGTraversableProduct$fGTraversableProduct0$fGTraversableNonEmpty$fGTraversableMin$fGTraversableMaybe$fGTraversableMax$fGTraversableLast$fGTraversableLast0$fGTraversableIdentity$fGTraversableFirst$fGTraversableFirst0$fGTraversableEither$fGTraversableDual$fGTraversableDown$fGTraversableConst$fGTraversableComplex$fGTraversableArg$fGTraversable[]$fGTraversable(,)$fGTraversable':.:$fGTraversable'Rec1UniplatechildrencontextdescenddescendM transform transformMContext'context' Uniplate' children'descend' descendM' transform' transformM'childrendefaultcontextdefaultdescenddefaultdescendMdefaulttransformdefaulttransformMdefaultuniplateuniverserewriterewriteMcontextsholespara$fUniplate'k:*:b$fUniplate'k:+:b$fUniplate'kM1b$fUniplate'kK1b$fUniplate'kU1a$fContext'k:*:b$fContext'k:*:a$fContext'k:+:b$fContext'kM1b$fContext'kK1b$fContext'kK1a$fContext'kU1b $fUniplate[]$fUniplateEither$fUniplateMaybe$fUniplate(,,,,,,)$fUniplate(,,,,,)$fUniplate(,,,,)$fUniplate(,,,)$fUniplate(,,) $fUniplate(,) $fUniplate() $fUniplateInt$fUniplateFloat$fUniplateDouble$fUniplateChar$fUniplateBool$fUniplate'kK1aDefault1 unDefault1Default unDefault$fUniplateDefault$fGMonoidDefault$fGSemigroupDefault$fGShowDefault$fGEnumDefault $fGEqDefault$fGTraversableDefault1$fGFoldableDefault1$fGCopointDefault1$fGFunctorDefault1base GHC.GenericsGenericRepfromtoGeneric1Rep1from1to1Datatype datatypeName moduleName packageName isNewtype ConstructorconName conFixity conIsRecordSelectorselNameselSourceUnpackednessselSourceStrictnessselDecidedStrictnessV1U1Par1unPar1Rec1unRec1K1unK1M1unM1:+:L1R1:*::.:Comp1unComp1RDCSRec0D1C1S1URecUAddrUCharUDoubleUFloatUIntUWorduWord#uInt#uFloat#uDouble#uChar#uAddr#precFixityPrefixInfixFixityIPrefixIInfixI AssociativityLeftAssociativeRightAssociativeNotAssociativeSourceUnpackedness SourceUnpackSourceNoUnpackNoSourceUnpackednessSourceStrictness SourceLazy SourceStrictNoSourceStrictnessDecidedStrictness DecidedLazy DecidedStrict DecidedUnpackMetaMetaDataMetaConsMetaSelghc-prim GHC.TypesTrue|||diagGHC.BasememptymappendmconcatMonoid Data.MonoidgetFirstLastgetLastApgetApData.Semigroup.InternalDualgetDualEndoappEndoAllgetAllAnygetAnySumgetSumProduct getProductAltgetAltDatatypeVariant_-th-abstraction-0.4.0.0-26iKboY3ZgK74efBl0kjeOLanguage.Haskell.TH.DatatypeDatatypeVariantConstructorInfotemplate-haskellLanguage.Haskell.TH.SyntaxName GenericKindGen1 GHC.MaybeJustNothing GenericClassStarKindStatuscanRealizeKindStarstarKindStatusToNamecatKindVarNames hasKindStartypeToTyVarBndrtypeKind makeFunType makeFunKindisInTypeFamilyAppground applyTyToTys applyTyToTvbs unapplyTy uncurryTy uncurryKind newNameList canEtaReduce varTToNameisTyVar isKindVarisTypeMonomorphicunSigT unKindedTV mentionsName allDistinct sanitizeNameetaReductionErrorderivingKindErroroutOfPlaceTyVarError rankNError reifyDataInfocheckDataContextcheckExistentialContextNewtypeInstance_ DataInstance_Newtype_ Datatype_Gen0 IsKindVarKindStar NotKindStar TypeSubstapplySubstitutionKindsubstNameWithKindsubstNamesWithKindStartyVarBndrToTypefst3snd3trd3shrinkfoldBalisNewtypeVariant genericKindshowsDatatypeVariant showNameQual 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 fmapValNameundefinedValNamedecidedLazyDataNamedecidedStrictDataNamedecidedUnpackDataNameinfixIDataNamemetaConsDataNamemetaDataDataNamemetaNoSelDataNamemetaSelDataNamenoSourceStrictnessDataNamenoSourceUnpackednessDataNameprefixIDataNamesourceLazyDataNamesourceNoUnpackDataNamesourceStrictDataNamesourceUnpackDataNamepackageNameValName SelStrictInfomkMetaDataTypemkMetaConsType mkMetaSelTypereifySelStrictInfoFalsebuildTypeInstanceBool GHC.ClassesEqGHC.ShowShowGHC.EnumEnumtoEnumfromEnumversion getBinDir getLibDir getDynLibDir getDataDir getLibexecDir getSysconfDirgetDataFileName