h&dB      !"#$%&'()*+,-./0123456789:;<=>?@ABCDEFGHIJKLMNOPQRSTUVWXYZ[\]^_`abcdefghijklmnopqrstuvwxyz{|}~                                                                                                                                                                                                                                                                                                                Safe5689:4Safe05;2SafePSafe 0<JSafe 0</4012356789:;<=>?@ABCDEFGHIJ/40123567:;<=>?@ABCDEFGHIJ89 Trustworthy 0<rstuvrsvtu Trustworthy 0<generic-deriving>The list of values in the subrange defined by a bounding pair.generic-deriving,The position of a subscript in the subrange.generic-derivingReturns  the given subscript lies in the range defined the bounding pair.generic-derivingInterleave elements from two lists. Similar to (++), but swap left and right arguments on every recursive application. From Mark Jones' talk at AFP2008generic-derivingDiagonalization of nested lists. Ensure that some elements from every sublist will be included. Handles infinite sublists. From Mark Jones' talk at AFP20085Safe 0<(c) 2012 University of OxfordBSD3generics@haskell.org experimental non-portableSafe 0Ggeneric-derivingReturn the name of all the constructors of the type of the given term.generic-deriving4Return the name of the constructor of the given termSafe0<generic-derivingOnly available with base-4.9 or later666Safe0<generic-derivingGeneric generic-derivingGeneric generic-derivingGeneric 1SafeSafe=1  Trustworthy <   Safe 0<F 42011-2012 Universiteit Utrecht, University of OxfordBSD3generics@haskell.org experimental non-portable Trustworthy 0< *Default implementations of generic classes BSD-3-Clausegenerics@haskell.org experimental non-portableSafe<!generic-derivingThis newtype wrapper can be used to derive default instances for classes taking an argument of kind  -> .generic-derivingThis newtype wrapper can be used to derive default instances for classes taking an argument of kind .generic-deriving8Semigroups often have many sensible implementations of  / :, and therefore no sensible default. Indeed, there is no , instance for representations of sum types.In 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 ( ) generic-derivingFor example, with this type: newtype TestShow = TestShow  deriving () via ( )  for TestShow" would produce the same string as  for .In this example, TestShow requires no ! instance, as the constraint on  from   is  .In general, when using a newtype wrapper, the instance can be derived via the wrapped type, as here (via   rather than  TestShow).generic-derivingThe  class in base% is slightly different; it comprises  and . Generics.Deriving.Enum provides functions  and . Safe-Inferred"rstuv#(c) 2008--2009 Universiteit UtrechtBSD3generics@haskell.org experimental non-portable Safe-Inferred<0generic-deriving A version of  in which the data family instance constructors come equipped with the 7 of the first constructor in the family instance (for  generation purposes).generic-derivingRecords information about the type variables of a data type with a  or  instance.generic-deriving%Information about a data type with a  instance.generic-deriving%Information about a data type with a  instance.generic-deriving4All of the type variable arguments to the data type.generic-derivingAll of the type variable arguments to the data type except the last one. In a  (T a_1 ... a_(n-1)) instance, the  would be [a_1, ..., a_(n-1)].generic-derivingThe name of the last type variable argument to the data type. In a  (T a_1 ... a_(n-1)) instance, the  name would be a_n.generic-derivingIf the  has kind k, where k$ is some kind variable, then the  is  k. Otherwise, the  is .generic-deriving7Indicates whether Generic or Generic1 is being derived.generic-derivingWhether a type is of kind *, a kind variable, or some other kind. The kind variable case is given special treatment solely to support GHC 8.0 and earlier, in which Generic1 was not poly-kinded. In order to support deriving Generic1 instances on these versions of GHC, we must substitute such kinds with *< to ensure that the resulting instance is well kinded. See *Note [Generic1 is polykinded in base-4.10] in Generics.Deriving.TH.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-derivingConcat 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-derivingConverts a VarT or a SigT into Just the corresponding TyVarBndr. Converts other Types to Nothing.generic-derivingIf 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-derivingRemove any outer  and & constructors, and turn an outermost % constructor into plain applications.generic-derivingChecks whether a type is an unsaturated type family application.generic-derivingGiven a name, check if that name is a type family. If so, return a list of its binders.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-derivingSplit 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-derivingGenerate 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 distinctCannot 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: It must be the name of a type constructor of a plain data type or newtype.It 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-derivingDeriving Generic(1) doesn't work with ExistentialQuantification or GADTs. #(c) 2008--2009 Universiteit UtrechtBSD3generics@haskell.org experimental non-portable Safe-InferredBQgeneric-derivingGiven the type and the name (as string) for the type to derive, generate the Data instance, the  Constructor instances, and the Selector instances.On 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  .On GHC 7.11 and up, this functionality is no longer used in GHC generics, so this function generates no declarations.generic-derivingGiven a datatype name, derive datatypes and instances of class  Constructor.On 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.On 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-portable Safe-Inferred(cB( generic-derivingThe result of checking the argument. This NoPar means the parameter wasn't there. The Bool is True if the argument *is* the parameter, and False otherwise.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 / instances,   otherwise.generic-derivingConfigures whether Rep/Rep17 type instances should be defined inline in a derived / instance (*) or defined in terms of a type synonym ().generic-deriving+Additional options for configuring derived /# 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-derivingGiven 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-derivingGiven 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-derivingGiven 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-derivingGiven 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-derivingGiven 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 Rep 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 a. 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 Rep1 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 a. 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 , 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 a. 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  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 , 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 a. 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  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-derivingWhether 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-Inferredd-   !"#$%&'()*+,-./0123456789:;<=>?@ABCDEFGHIJKLMNOPQRSTUVWXYZ[\]^_`abcdefghijklmnopqrstuvwxyz{|}~                                                                                                                                                                                                                                                                                                                                                .generic-deriving-1.14.5-2gIUuSb09dADbSXq7uBcZzGenerics.Deriving.FunctorGenerics.Deriving.FoldableGenerics.Deriving.EqGenerics.Deriving.EnumGenerics.Deriving.CopointGenerics.Deriving.ConNamesGenerics.Deriving.SemigroupGenerics.Deriving.MonoidGenerics.Deriving.ShowGenerics.Deriving.TraversableGenerics.Deriving.UniplateGenerics.Deriving.DefaultGenerics.Deriving.THGenerics.Deriving.Base.InternalGenerics.Deriving.InstancesGenerics.Deriving.Base$Generics.Deriving.Semigroup.Internal!Generics.Deriving.Monoid.Internal Data.KindTypeData.Semigroup<>FirstGenerics.DerivingGenerics.Deriving.TH.InternalGenerics.Deriving.TH.Post4_9Paths_generic_derivingGFunctorgmap 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(,) $fGFunctorFUN$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 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$fGFunctorDefault1 deriveMeta deriveDataderiveConstructorsderiveSelectorsEmptyCaseOptionsKindSigOptions RepOptions InlineRepTypeSynonymRepOptions repOptionskindSigOptionsemptyCaseOptionsdefaultOptionsdefaultRepOptionsdefaultKindSigOptionsdefaultEmptyCaseOptions deriveAll deriveAll0deriveAll0Options deriveAll1deriveAll1OptionsderiveAll0And1deriveAll0And1OptionsderiveRepresentable0deriveRepresentable0OptionsderiveRepresentable1deriveRepresentable1Options deriveRep0deriveRep0Options deriveRep1deriveRep1OptionsmakeRep0InlinemakeRep1InlinemakeRep0makeRep1makeRep0FromTypemakeRep1FromTypemakeFrom makeFrom0makeFrom0OptionsmakeTomakeTo0makeTo0Options makeFrom1makeFrom1OptionsmakeTo1makeTo1Options $fEqOptions $fOrdOptions $fReadOptions $fShowOptions$fEqRepOptions$fOrdRepOptions$fReadRepOptions$fShowRepOptionsbase GHC.GenericsGenerictoRepfromGeneric1to1Rep1from1Datatype packageName moduleName datatypeName isNewtype ConstructorconName conFixity conIsRecordSelectorselSourceUnpackednessselSourceStrictnessselDecidedStrictnessselNameV1U1Par1unPar1Rec1unRec1K1unK1M1unM1:+:L1R1:*::.:Comp1unComp1RDCSRec0D1C1S1URecuWord#uInt#uFloat#uDouble#uChar#uAddr#UWordUIntUFloatUDoubleUAddrUCharSourceUnpackednessNoSourceUnpackedness SourceUnpackSourceNoUnpackSourceStrictnessNoSourceStrictness SourceLazy SourceStrictMetaMetaSelMetaDataMetaConsFixityIPrefixIInfixIFixityInfixPrefixDecidedStrictness DecidedUnpack DecidedLazy DecidedStrict AssociativityNotAssociativeLeftAssociativeRightAssociativeprecghc-prim GHC.TypesTrue|||diagGHC.BasememptymappendmconcatMonoid Data.MonoidLastgetLastgetFirstApgetApData.Semigroup.InternalSumgetSumProduct getProductEndoappEndoDualgetDualAnygetAnyAltgetAltAllgetAllBool GHC.ClassesEqGHC.ShowShowGHC.EnumEnumtoEnumfromEnumDatatypeVariant_-th-abstraction-0.6.0.0-EUWcfiaG67q8PVRaO1uLGsLanguage.Haskell.TH.DatatypeDatatypeVariantConstructorInfotemplate-haskellLanguage.Haskell.TH.SyntaxName GenericTvbs GenericClassGen0Gen1gen0Tvbs gen1InitTvbsgen1LastTvbNamegen1LastTvbKindVar GHC.MaybeJustNothingStarKindStatuscanRealizeKindStarstarKindStatusToNamecatKindVarNames hasKindStartypeToTyVarBndrtypeKind makeFunType makeFunKinddustOffSigTParensTInfixTisUnsaturatedTypegetTypeFamilyBindersground applyTyToTys applyTyToTvbs uncurryTy uncurryKind newNameList canEtaReduce varTToNameisTyVar isKindVarisTypeMonomorphicunSigT unKindedTV mentionsName allDistinct mkGenericTvbsgenericInitTvbs sanitizeNameetaReductionErrorderivingKindErroroutOfPlaceTyVarErrortypeFamilyApplicationError typeDataError rankNError reifyDataInfocheckDataContextcheckExistentialContextNewtypeInstance_ DataInstance_Newtype_ Datatype_ OtherKind IsKindVarKindStar TypeSubstapplySubstitutionKindsubstNameWithKindsubstNamesWithKindStartyVarBndrToTypefst3snd3trd3shrinkfoldBalisNewtypeVariantshowsDatatypeVariant showNameQual comp1DataName infixDataName k1DataName l1DataNameleftAssociativeDataName m1DataNamenotAssociativeDataName par1DataNameprefixDataNameproductDataName r1DataName rec1DataNamerightAssociativeDataName u1DataName uAddrDataName uCharDataNameuDoubleDataNameuFloatDataName uIntDataName uWordDataName c1TypeNamecomposeTypeNameconstructorTypeName d1TypeNamegenericTypeNamegeneric1TypeNamedatatypeTypeName par1TypeNameproductTypeName rec0TypeName rec1TypeName repTypeName rep1TypeName s1TypeNameselectorTypeName sumTypeName u1TypeName uAddrTypeName uCharTypeNameuDoubleTypeNameuFloatTypeName uIntTypeName uWordTypeName v1TypeNameconFixityValNameconIsRecordValNameconNameValNamedatatypeNameValNameisNewtypeValName fromValName from1ValNamemoduleNameValNameselNameValName seqValName toValName to1ValNameuAddrHashValNameuCharHashValNameuDoubleHashValNameuFloatHashValNameuIntHashValNameuWordHashValNameunComp1ValName unK1ValName unPar1ValName unRec1ValName trueDataName falseDataNamenothingDataName justDataNameaddrHashTypeNamecharHashTypeNamedoubleHashTypeNamefloatHashTypeNameintHashTypeNamewordHashTypeNamecomposeValName errorValName fmapValNameundefinedValNamedecidedLazyDataNamedecidedStrictDataNamedecidedUnpackDataNameinfixIDataNamemetaConsDataNamemetaDataDataNamemetaSelDataNamenoSourceStrictnessDataNamenoSourceUnpackednessDataNameprefixIDataNamesourceLazyDataNamesourceNoUnpackDataNamesourceStrictDataNamesourceUnpackDataNamepackageNameValName SelStrictInfomkMetaDataTypemkMetaConsType mkMetaSelTypereifySelStrictInfoArgResFalsebuildTypeInstanceversiongetDataFileName getBinDir getLibDir getDynLibDir getDataDir getLibexecDir getSysconfDir