h$~a0      !"#$%&'()*+,-./0123456789:;<=>?@ABCDEFGHIJKLMNOPQRSTUVWXYZ[\]^_`abcdefghijklmnopqrstuvwxyz{|}~                                                                                                                                                                                                                                                                                                                Safe23567>Safe.28>  SafeSafe .9>? !"#$ !$"#Safe .9>?:OTPQRSUVWXYZ[\]^_`abcdefghijOTPQRSUVWZ[\]^_`abcdefghijXY Trustworthy .9>? Trustworthy .9>?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.5Safe .9>?Z(c) 2012 University of OxfordBSD3generics@haskell.org experimental non-portableSafe .>?generic-derivingReturn the name of all the constructors of the type of the given term.generic-deriving4Return the name of the constructor of the given termSafe.9?generic-derivingOnly available with base-4.9 or later666Safe.9?generic-derivingGeneric generic-derivingGeneric generic-derivingGeneric 1SafeQ Safe1  Trustworthy 9>??  #(c) 2008--2009 Universiteit UtrechtBSD3generics@haskell.org experimental non-portable Safe-Inferred1/generic-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-Inferred7generic-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&V'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.11 Safe .9>?W 42011-2012 Universiteit Utrecht, University of OxfordBSD3generics@haskell.org experimental non-portable Trustworthy .9>?X*Default implementations of generic classes BSD-3-Clausegenerics@haskell.org experimental non-portableSafe9?_Vgeneric-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_ !"#$ Safe-Inferreda   !"#$%&'()*+,-./0123456789:;<=>?@ABCDEFGHIJKLMNOPQRSTUVWXYZ[\]^_`abcdefghijklmnopqrstuvwxyz{|}~                                                                                                                                                                                                                                                                                                                                                                             .generic-deriving-1.14.2-H9k3NKvuFFG54Q8bAi6eetGenerics.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 Rep1Tuple15 Rep1Tuple14 Rep1Tuple13 Rep1Tuple12 Rep1Tuple11 Rep1Tuple10 Rep1Tuple9 Rep1Tuple8 Rep0Tuple15 Rep0Tuple14 Rep0Tuple13 Rep0Tuple12 Rep0Tuple11 Rep0Tuple10 Rep0Tuple9 Rep0Tuple8$fGeneric1TYPE(,,,,,,,,,,,,,,)$fGeneric1TYPE(,,,,,,,,,,,,,)$fGeneric1TYPE(,,,,,,,,,,,,)$fGeneric1TYPE(,,,,,,,,,,,)$fGeneric1TYPE(,,,,,,,,,,)$fGeneric1TYPE(,,,,,,,,,)$fGeneric1TYPE(,,,,,,,,)$fGeneric1TYPE(,,,,,,,)$fGeneric(,,,,,,,,,,,,,,)$fGeneric(,,,,,,,,,,,,,)$fGeneric(,,,,,,,,,,,,)$fGeneric(,,,,,,,,,,,)$fGeneric(,,,,,,,,,,)$fGeneric(,,,,,,,,,)$fGeneric(,,,,,,,,)$fGeneric(,,,,,,,)GFunctorgmap 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 $fEqOptions $fOrdOptions $fReadOptions $fShowOptions$fEqRepOptions$fOrdRepOptions$fReadRepOptions$fShowRepOptions 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.GenericsGenerictoRepfromGeneric1to1Rep1from1Datatype isNewtype packageName datatypeName moduleName Constructor conIsRecordconName conFixitySelectorselDecidedStrictnessselSourceStrictnessselNameselSourceUnpackednessV1U1Par1unPar1Rec1unRec1K1unK1M1unM1:+:L1R1:*::.:Comp1unComp1RDCSRec0D1C1S1URecUWordUIntUFloatUDoubleUAddrUCharuAddr#uChar#uDouble#uFloat#uWord#uInt#precFixityPrefixInfixFixityIPrefixIInfixI AssociativityNotAssociativeLeftAssociativeRightAssociativeSourceUnpackednessNoSourceUnpackedness SourceUnpackSourceNoUnpackSourceStrictnessNoSourceStrictness SourceLazy SourceStrictDecidedStrictness DecidedUnpack DecidedLazy DecidedStrictMetaMetaSelMetaDataMetaConsghc-prim GHC.TypesTrue|||GHC.BasememptymappendmconcatMonoid Data.MonoidgetFirstLastgetLastApgetApData.Semigroup.InternalDualgetDualEndoappEndoAllgetAllAnygetAnySumgetSumProduct getProductAltgetAltDatatypeVariant_,th-abstraction-0.4.4.0-42zopQTBYuCFgJGGATTemLanguage.Haskell.TH.DatatypeDatatypeVariantConstructorInfotemplate-haskellLanguage.Haskell.TH.SyntaxName GenericTvbsGen0Gen1gen0Tvbs gen1InitTvbsgen1LastTvbNamegen1LastTvbKindVar GHC.MaybeJustNothing GenericClassStarKindStatuscanRealizeKindStarstarKindStatusToNamecatKindVarNames hasKindStartypeToTyVarBndrtypeKind makeFunType makeFunKinddustOffSigTParensTInfixTisUnsaturatedTypegetTypeFamilyBindersground applyTyToTys applyTyToTvbs uncurryTy uncurryKind newNameList canEtaReduce varTToNameisTyVar isKindVarisTypeMonomorphicunSigT unKindedTV mentionsName allDistinct mkGenericTvbsgenericInitTvbs sanitizeNameetaReductionErrorderivingKindErroroutOfPlaceTyVarErrortypeFamilyApplicationError rankNError reifyDataInfocheckDataContextcheckExistentialContextNewtypeInstance_ DataInstance_Newtype_ Datatype_ OtherKind IsKindVarKindStar TypeSubstapplySubstitutionKindsubstNameWithKindsubstNamesWithKindStartyVarBndrToTypefst3snd3trd3shrinkfoldBalisNewtypeVariantshowsDatatypeVariant 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 mkMetaSelTypereifySelStrictInfoFalseBool GHC.ClassesEqGHC.ShowShowGHC.EnumEnumtoEnumfromEnumversion getBinDir getLibDir getDynLibDir getDataDir getLibexecDir getSysconfDirgetDataFileName