!"#$%&'()*+,-./0123456789:;<=>?@ABCDEFGHIJKLMNOPQRSTUVWXY Z [ \]^_`abcdefghijklmnopq r s t u v w x y z { | } ~                                   ! " # $ % & ' ( ) * + , - . / 0 1 2 3 4 5 6 7 8 9 : ; < = > ? @ABCDEFGHIJKLMNOPQRSTUVWXYZ[\]^_`abcdefghijklmnopqrstuvwxyz{|}~      !"#$%&'()*+,-./0123456789:;<=>?@ABCDEFGHIJKLMNOPQRSTUVWXYZ[\]^_`abcdefghijklmnopqrstuvwxyz{|}~None@yG)Embed bytes in a C array, return an Addr#H.Adapted from the raw-strings-qq package (BSD3)}A quasiquoter for raw string literals - that is, string literals that don't recognise the standard escape sequences (such as '\n'). Basically, they make your code more readable by freeing you from the responsibility to escape backslashes. They are useful when working with regular expressions, DOS/Windows paths and markup languages (such as XML).Don't forget the LANGUAGE QuasiQuotes1 pragma if you're using this module in your code.Usage:  ghci> :set -XQuasiQuotes ghci> import Text.RawString.QQ ghci> let s = [raw|\w+@[a-zA-Z_]+?\.[a-zA-Z]{2,3}|] ghci> s "\\w+@[a-zA-Z_]+?\\.[a-zA-Z]{2,3}" ghci> [raw|C:\Windows\SYSTEM|] ++ [raw|\user32.dll|] "C:\\Windows\\SYSTEM\\user32.dll" 1Multiline raw string literals are also supported:  multiline :: String multiline = [raw|<HTML> <HEAD> <TITLE>Auto-generated html formated source</TITLE> <META HTTP-EQUIV="Content-Type" CONTENT="text/html; charset=windows-1252"> </HEAD> <BODY LINK="0000ff\" VLINK=\"4800080" BGCOLOR="#ffffff"> <P> </P> <PRE>|] Caveat: since the "|]"q character sequence is used to terminate the quasiquotation, you can't use it inside the raw string literal. Use ID if you want to embed that character sequence inside the raw string.I A variant of H that interprets the "|~]" sequence as "|]", "|~~]" as "|~]" and, in general, "|~^n]" as  "|~^(n-1)]" for n >= 1.Usage: j ghci> [rawQ||~]|~]|] "|]|]" ghci> [rawQ||~~]|] "|~]" ghci> [rawQ||~~~~]|] "|~~~]"      GHIGHISafeB J?Check that a list has the given length (support infinite lists) !"#$%&'()*+,-./0123456789:;<=>?@ABCDEFGHIJKLMNOPQRSTUVWXYZ[\]^_`abcdefghijklmnopqrstuvwxyz{|}~JJSafeD      !"#$%&'()*+,-./0123456789:;<=SafeG=}>?@ABCDEFGHIJKLMNOPQRSTUVWXYZ[\]^_`abcdefghijklmno     !)/012356789:;<=Safe]JKFlipped pLFlipped MMfromMaybe in a MonadN3Get the head of the list if the latter is not emptyqrstuvwpxyz{KLMNKLMNSafeFQTVMAP0Lift with*-like functions into IO (alloca, etc.)Q0Lift with*-like functions into IO (alloca, etc.)I|}~&',-./012OPQOPQOPQSafePT%Execute an STM transaction atomicallyURead a TVar in an IO monadVCreate a broadcast channelW Create a TVarXCreate a TMVar !"#$%3456789:;<=>?@ABCDETUVWX$#T%WU !"354@X6?>9=;78:<EVDCAB SafeQYZYZYZNone+X\ STM hashmap]Indicate if the map is empty^%Get the number of elements in the map_)Lookup an element in the map from its key`Check if a key is in the mapa Check if a key is not in the mapbCreate an empty mapc(Create a map containing a single elementdInsert an element in the mapeCreate a new TMap from a listfDelete an element from the mapCreate a list of (key,value)g Get valueshGet keysiUnsafe lookup in the mapF\]^_`abcdefghi\F]^_`abcdefghiSafe ,-FSTVhbjType equality to NatHelper for ModulokModulolLike: If cond t (TypeError msg)The difference is that the TypeError doesn't appear in the RHS of the type which lead to better error messages (see GHC #14771).XFor instance: type family F n where F n = If (n <=? 8) Int8 (TypeError (Text ERROR))?type family G n where G n = Assert (n <=? 8) Int8 (Text ERROR)uIf GHC cannot solve `F n ~ Word`, it shows: ERROR If GHC cannot solve `G n ~ Word`, it shows: can't match  with m If-then-elsenGet a Nat valueoGet a Nat valuepGet a Symbol value ()+*jklmnopnop ) lmkj+* ( Safe -;<=>?AFThk qReorder tuple elementsrReorder tuple elementsy Extract a tuple value staticallyz)Extract a tuple value by type-level index}Singleton typeUncurry specialised for triple!Uncurry specialised for quadrupleTake specialised for quadrupletoList for quadrupleqrstuvwxyz{|}~}~|{yzwxuvstqrqrstuvwxyz}~ Safe +,-<FSTV}+3Check that a list only contain a value of each typeConstraint: x member of xsUnion two listsIndexed access into the listHelper for MaybeIndexOf<Get the first index (starting from 1) of a type or 0 if noneGet the first index of a typeGet all the indexes of a typeGet the first index of a typeGet the first index of a type)Keep only a single value of the head type%Keep only a single value of each typeRemove a in l Zip two lists&Map to 1 if type equality, 0 otherwiseGet list indexesHelper for IsSubset(Check that a list is a subset of another*Check that a type is member of a type list*Check that a type is member of a type listGenerate a list of Nat [n..m-1]+Apply Maybe to all the elements of the listRemove types at several indexes*Remove a type at index (0 == don't remove)Remove a type at indexReverse a list replace types at offsets ns in lreplace a type at offset n in lreplace a type by another in lreplace l[n] with l2 (folded)Insert a list at n ReplicateGet list lengthConcat two type listsHead of a listSnocInit of a listTake elements in a listDrop elements in a listTail of a listHelper for MaxGet the max of a list of NatsMap a type function%% Safe-FSTHaExtract types of the fields of a data type - only support data type with a single constructortExtract fields of a data type: - require selector symbols - only support data type with a single constructor  Named fieldi        Safe+-0;<=>?AFSTVh  !Convert between hlists and tuples *Convert an heterogeneous list into a tuple *Convert a tuple into an heterogeneous list+Like HFoldl but only use types, not values!TIt allows us to foldr over a list of types, without any associated hlist of values.+Like HFoldr but only use types, not values!TIt allows us to foldr over a list of types, without any associated hlist of values.GApply the function identified by the data type f from type a to type b.Heterogeneous listHeadTailLength              !2Safe-;<=>?AFSTVhk F5Convert a tuple of continuations into a list of typesGRConvert a list of types into the actual data type representing the continuations.H!A continuation based control-flowJ'Bind a flow to a tuple of continuationsK)Bind a flow to a 1-tuple of continuationsLHBind a flow to a tuple of continuations and reorder fields if necessaryMKCall the type-indexed continuation from the tuple passed as first parameterN<Implicitly call the type-indexed continuation in the contextOFCall the indexed continuation from the tuple passed as first parameterP<Implicitly call the type-indexed continuation in the contextQRecursive call@ABCDEFGHIJKLMNOPQRHIJKLMONPQGFDERBC@A@ABCHIJ0K0L0None%+-;<=>?CFGQSTVdhƉ0T+Convert a variant into a multi-continuationU+Convert a variant into a multi-continuationV+Convert a multi-continuation into a VariantW+Convert a multi-continuation into a VariantX(Convert a variant into a HList of MaybesYxs is liftable in ys\FUseful to specify a "* -> Constraint" function returning no constraint"#Wrap a function and its constraints##Wrap a function and its constraints`a may be popable in xsaa is popable in xs$Remove a type from a variantcPA variant contains a value whose type is at the given position in the type listd*Statically unchecked matching on a VarianteMake GHC consider lQ as a representational parameter to make coercions between Variant values unsafePattern synonym for VariantRUsage: case v of V (x :: Int) -> ... V (x :: String) -> ...fGet Variant indexg)Set the value with the given indexed typehSet the first valuei Set the tailj(Get the value if it has the indexed typekOPop a variant value by index, return either the value or the remaining variantlPop the head of a variant valuemUpdate a variant valuenPut a value into a Variant"Use the first matching type index.o]Extract a type from a variant. Return either the value of this type or the remaining variantp]Extract a type from a variant. Return either the value of this type or the remaining variantq)Pick the first matching type of a VariantHfromVariantFirst @A (Variant 2 undefined :: Variant '[A,B,A]) == Nothingr3Try to a get a value of a given type from a Variants^Try to a get a value of a given type from a Variant that may not even support the given type.tUpdate a variant valueu2Monadic update of the first matching variant valuev#Map the matching types of a variantw9Update a variant value with a variant and fold the resultx9Update a variant value with a variant and fold the resulty9Update a variant value with a variant and fold the resultz9Update a variant value with a variant and fold the result{9Update a variant value with a variant and fold the result|YAlter a variant. You need to specify the constraints required by the modifying function.Usage: alterVariant +NoConstraint id v alterVariant Resizable (resize 4) vHclass (Ord a, Num a) => OrdNum a instance (Ord a, Num a) => OrdNum a}\Traverse a variant. You need to specify the constraints required by the modifying function.~\Traverse a variant. You need to specify the constraints required by the modifying function.3Extend a variant by appending other possible values4Extend a variant by prepending other possible valuesLift a variant into another%Set values to the first matching typeNub the type listRetreive a single value+Convert a variant of two values in a Either5Get variant possible values in a tuple of Maybe types<Lift an Either into a Variant (reversed order by convention)6STUVWXYZ[\]^_`abcdefghijklmnopqrstuvwxyz{|}~6cbfedghijklmwxna`oprsqtu_vyz{]^Z[\|}~YXSTUVW STUVW%X&'Z["(#)]^*+,$c-None -<CFSTV]h*@ Control-flowReturn in the first element&Return in the first well-typed elementReturn a single elementLift a flow into anotherLift a flow into a ContFlow'Traverse a list and stop on first error'Traverse a list and stop on first error,Traverse a list and return only valid values,Traverse a list and return only valid valuesExtract single flow result.:Lift an operation on a Variant into an operation on a flowApply a functionApply a functionApply a function in a FunctorApply a function in a Functor6Map a pure function onto the correct value in the flow4Bind two flows in a monadish way (error types union)6Bind two flows in a monadic way (constant error types)Match a value in a flowDMatch a value in a flow and use a non-returning failure in this case,Extract the first value, set the first value,Extract the first value, set the first value*Extract the first value, concat the result+Extract the first value, concat the results"Extract the first value, lift both"Extract the first value, lift both(Extract the first value, lift unselected(Extract the first value, lift unselected*Extract the first value, use the same tail*Extract the first value, use the same tail'Take the first output, union the result(Take the first output, fusion the resultGExtract the first value and perform effect. Passthrough the input valueGExtract the first value and perform effect. Passthrough the input value+Extract the first value and perform effect.+Extract the first value and perform effect.+Extract the first value and perform effect.+Extract the first value and perform effect.,Extract the first value, set the first value,Extract the first value, set the first value,Extract the first value, set the first value,Extract the first value, set the first valueFunctor  $ equivalent Applicative  * equivalent Applicative  * equivalent, with error union,Extract the first value, set the first value,Extract the first value, set the first value*Extract the first value, concat the result+Extract the first value, concat the results(Extract the first value, lift the result(Extract the first value, lift the result7Extract the first value, connect to the expected output7Extract the first value, connect to the expected output1Extract the first value, use the same output type1Extract the first value, use the same output type(Take the first output, fusion the result(Take the first output, fusion the resultGExtract the first value and perform effect. Passthrough the input valueGExtract the first value and perform effect. Passthrough the input value+Extract the first value and perform effect.+Extract the first value and perform effect.%Extract the tail, set the first value%Extract the tail, set the first value5Extract the tail, set the first value (pure function)5Extract the tail, set the first value (pure function)Extract the tail, set the tailExtract the tail, set the tailExtract the tail, set the tailExtract the tail, set the tail!Extract the tail, lift the result!Extract the tail, lift the result$Extract the tail, connect the result$Extract the tail, connect the result1Match in the tail, connect to the expected result1Match in the tail, connect to the expected result1Match in the tail, connect to the expected result1Match in the tail, connect to the expected result.Match in the tail, lift to the expected result.Match in the tail, lift to the expected result.Match in the tail, lift to the expected result.Match in the tail, lift to the expected result&Match in the tail, keep the same types&Match in the tail, keep the same types&Match in the tail, keep the same types&Match in the tail, keep the same typesCExtract the tail and perform an effect. Passthrough the input valueCExtract the tail and perform an effect. Passthrough the input value&Extract the tail and perform an effect&Extract the tail and perform an effect&Extract the tail and perform an effect&Extract the tail and perform an effect'Match in the tail and perform an effect'Match in the tail and perform an effect'Match in the tail and perform an effect'Match in the tail and perform an effect'Match in the tail and perform an effect'Match in the tail and perform an effect 'Match in the tail and perform an effect 'Match in the tail and perform an effect  Pop element, set the first value  Pop element, set the first value  Pop element, set the first value Pop element, set the first valuePop element, concat the resultPop element, concat the resultPop element, concat the resultPop element, concat the resultPop element, lift the resultPop element, lift the resultPop element, lift the resultPop element, lift the result+Pop element, connect to the expected output+Pop element, connect to the expected output+Pop element, connect to the expected output+Pop element, connect to the expected output%Pop element, use the same output type%Pop element, use the same output type%Pop element, use the same output type%Pop element, use the same output typePop element, fusion the result Pop element, fusion the result!Pop element, fusion the result"Pop element, fusion the result#<Pop element and perform effect. Passthrough the input value.$<Pop element and perform effect. Passthrough the input value.%<Pop element and perform effect. Passthrough the input value.&<Pop element and perform effect. Passthrough the input value.'Pop element and perform effect.(Pop element and perform effect.)Pop element and perform effect.*Pop element and perform effect.+Pop element and perform effect.,Pop element and perform effect.-Pop element and perform effect..Pop element and perform effect./Make a flow operator0Make a flow operator1Select the first value2Select the tail3Select by type4Const application5Pure application6Lift a monadic function/Lift a monadic function7Lift a monadic function8'Set the first value (the "correct" one)9-Set the first value, keep the same tail type :#Return the valid variant unmodified;Concatenate unselected values<Union=Lift unselected> Lift both? Single value@7Lift a pure function into a Variant to Variant functionALift a function into a Flow&',-./012OPQY`a      !"#$%&'()*+,-./0123456789:;<=>?@AOPQYa`-0/.,&'21   !"%&)*-.   #$'(+,/0213456789:;<=>?@Aw000000000000000000000000004440000000000000000000000000000000000000000000000000000 0 0 0 0 0000000000000000000 0!0"0#0$0%0&0'0(0)0*0+0,0-0.0None ;<=FNTV]^`3%BReduction resultHPredicated data }data T data NT type family RuleT e p a s :: * where RuleT e p a T = a RuleT e p a NT = Rule e p a data PD t = PD { p1 :: RuleT () Bool Int t , p2 :: RuleT () Bool String t } deriving instance Eq (PD T) deriving instance Show (PD T) deriving instance Ord (PD T) deriving instance Eq (PD NT) deriving instance Show (PD NT) deriving instance Ord (PD NT) instance Predicated (PD NT) where type PredErr (PD NT) = () type Pred (PD NT) = Bool type PredTerm (PD NT) = PD T liftTerminal (PD a b) = PD (liftTerminal a) (liftTerminal b) reducePredicates oracle (PD a b) = initP PD PD |> (m) reducePredicates oracle a) |> (mp reducePredicates oracle b) |> resultP getTerminals (PD as bs) = [ PD a b | a <- getTerminals as , b <- getTerminals bs ] getPredicates (PD a b) = concat [ getPredicates a , getPredicates b ] I Error typeJPredicate typeK Terminal typeL$Build a non terminal from a terminalMReduce predicatesN Get possible resulting terminalsOGet used predicates[Predicate oracle\Predicate state] Set predicate^Unset predicate_Undefined predicate`#Ask an oracle if a predicate is seta%Ask an oracle if a predicate is unsetb)Ask an oracle if a predicate is undefinedcCheck the state of a predicatedGet predicate stateeCreate an oracle from a listf'Get a list of predicates from an oraclegOracle that always answer UndefhReduce a constraint0=Check that a constraint is evaluated to a given boolean value1#Get predicates used in a constraint2Get constraint terminalsi4NonTerminal whose constraints are evaluated in orderKEarlier constraints must be proven false for the next ones to be consideredjSimplify a constraintkMerge two rules together3 Reduce a rule4 Get possible resulting terminals5Get predicates used in a rulelFConstraint checking that a predicated value evaluates to some terminalmCompose reduction resultsWe reuse the MatchResult data type: * a "terminal" on the left can be used to build either a terminal or a non terminal * a "non terminal" on the left can only be used to build a non terminalnIInitialise a reduction result (typically with two functions/constructors)o#Fixup result (see initP and applyP)p3Create a table of predicates that return a terminal/BDFCGEHJKILMNOPSQRTVZUWXY[\]^_`abcdefghijklmnop/\]^_[efg`abcdTUVWXYZjhPQRSiklBCDEFGHIJKLMNOpnmoBCDEFGHIJKLMNOPQRSTUVWXYZ\]^_None+i8STM SetIndicate if the set is emptyNumber of elements in the set!Check if an element is in the set%Check if an element is not in the setCreate an empty set(Create a set containing a single elementInsert an element in a setDelete an element from a setConvert a set into a listCreate a set from a listGet the set elementsGet the set as a ListT streamPerform a set union+Apply a function to each element in the setNoneV]z A node in the listEvery list has a marker node whose value is Nothing. Its nodePrev links to the last node and its nodeNext links to the first node.A double linked-list Get value associated with a nodeEmpty node singleton*Remove all the elements of the list (O(1))Create a singleton listIndicate if the list is empty/Count the number of elements in the list (0(n))Get the first element if anyGet the last element if anyGet the previous element if anyGet the next element if anyDelete a element of the list6)Insert a node between two adjacent nodes.Append an element to the listAppend an element to the listPrepend an element to the listPrepend an element to the list Insert an element before anotherInsert an element after anotherConvert into a list (O(n))#Convert into a reversed list (O(n))Create from a list(Only keep element matching the criterium3Find the first node matching the predicate (if any)Get the node from its index5Take (and remove) up to n elements in the list (O(n))789:;None Path in the treeA STM mutable treeNode identifier Node valueChildrenParentCreate a singleton node Add a childDetach a childEAttach a child a node (detaching it from a previous one if necessary) Follow a path from a parent node  None,@A node contains a value and two lists of incoming/outgoing edgesDeep-first graph traversalubefore is executed when the node is entered after is executed when the node is leaved children gets node's childrenBreadth-first graph traversalsvisit is executed when the node is entered. If False is returned, the traversal ends children gets node's childrenCreate a graph nodeLink two nodes together  None= Setter for a future valueFuture value of type aCreate a Future and its source in < Set a futureSet a future in IO Set a future'Return False if it has already been setWait for a future Poll a future in <  =>None-;<=>?CFTVhg  Parser errorTry to apply the actions in the list in order, until one of them succeeds. Returns the value of the succeeding action, or the value of the last one. Failures are detected with values of type  ParseError.Try to apply the actions in the list in order, until one of them succeeds. Returns the value of the succeeding action, or the value of the last one. Failures are detected with values of type "a".LApply the action zero or more times (until a ParseError result is returned)VApply the action zero or more times (up to max) until a ParseError result is returnedVApply the action zero or more times (up to max) until a ParseError result is returnedVApply the action zero or more times (up to max) until a ParseError result is returnedXApply the action at least n times or more times (until a ParseError result is returned){Apply the first action zero or more times until the second succeeds. If the first action fails, the whole operation fails.9Return both the list of first values and the ending value{Apply the first action zero or more times until the second succeeds. If the first action fails, the whole operation fails.$Return only the list of first values Apply the given action at least min times and at most max timeOn failure, fails.None+-<CFGSTVhA type t is maybe indexable in the arrayA type t is indexable in the array The type t with index n is indexable in the arrayheterogeneous array Empty array Empty arrayGet an element by indexGet first elementSet an element by index<Get an element by type (select the first one with this type)<Set an element by type (select the first one with this type)<Get an element by type (select the first one with this type)!Append a value to an array (O(n))"Prepend a value to an array (O(n)) Concat arraysDrop the last elementDrop the first elementCompose HArrayT?None -<CFSTV Multi-stateMulti-state monad transformer,States are stacked in a heterogeneous array. Run MStateEvaluate MStateExecute MStateSet a value in the stateGet a value in the stateTry to get a value in the stateModify a value in the state,Modify a value in the state (strict version)(Execute an action with an extended state-Lift a multi-state into an HArray transformerCompose MStateTCompose MStateT@ !"#$%&'(&')"*"+","-".$/"0$1$2$3$4$567689:;<=>?@ABCBDBEFGFHFIFJFKFLMNMO$P"QRSRSTU VWXYWXZWX[WX\WX]^_`^_a^_b^cd^ce^cf^cg^ch^ci^cj^ck^cl^cm^cn^op^oq^or^os^otuvwxyz{|}~                                             ! " # $ % & ' ( ) * + , - . / 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 nooppqrstuuvwxyz{|}~      !"#$%&'()*+,-./0123456789:;<=>?@ABCDEFGHIJKLMNOPQRSTUVWXYZ[\]^_`abcdefghijklmnopqrstuvwxyz{|}~      !"#$ %&&' M(MMM)M*M+M,M-M.M/M0M123B4B5MM6M7M8M9M:M;M<M=M>?@?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&{&|&&}&~&&&&&&&&&&&&&&&&&&&&&WWWWWWWWWWWWWWWWWWWWWWWWWWWWWWWWWWWWWWWWWWWWWWWWWWWWWWWW*)(b     i !"#$r%&'()*+,-./0123j42555555555555555555555555555 5 5 55555555"5%5&5'5(5)5*5+5,5-5.555367 8 9 :66;6<6=6>6?6@6A B C D E F G HIJKLMMNMO P Q R S T U V W X YWXZWX[WX\WX]WX^WX_WX`WXaWXbWXcWXdWXeWXfWXgWXhWXiWXjWXkWXlmnomnpq&'rstsusvswsx y z { | } ~        &'+haskus-utils-0.8.0.0-AQfyyynnSSs8gwQSCgSVjRHaskus.Utils.FlowHaskus.Utils.TypesHaskus.Utils.STMHaskus.Utils.STM.TMapHaskus.Utils.EmbedHaskus.Utils.ListHaskus.Utils.MaybeHaskus.Utils.MonadHaskus.Utils.STM.TEqHaskus.Utils.TupleHaskus.Utils.Types.ListHaskus.Utils.Types.GenericsHaskus.Utils.HListHaskus.Utils.ContFlowHaskus.Utils.VariantHaskus.Utils.SolverHaskus.Utils.STM.TSetHaskus.Utils.STM.TListHaskus.Utils.STM.TTreeHaskus.Utils.STM.TGraphHaskus.Utils.STM.FutureHaskus.Utils.ParserHaskus.Utils.HArrayHaskus.Utils.MultiStateHaskus.Utils.MapHaskus.Utils.Map.StrictAssert..base Control.MonadguardGHC.Basejoin GHC.TypeNatsKnownNat GHC.TypeLits KnownSymbolghc-prim GHC.TypesNatSymbol+*^<=?- CmpSymbolCmpNat TypeErrorText:<>::$$:ShowTypeControl.Monad.IO.ClassliftIOMonadIOunless replicateM_ replicateMfoldM_foldMforever<=<>=>filterMData.TraversableforMsequencemapM GHC.Conc.Sync writeTVarreadTVarnewTVarretrySTMTVar Data.FoldableforM_mapM_ ErrorMessage<= Data.ProxyProxy Data.Functorvoidwhen"extra-1.6.3-KTTUYhjGvuDKkbHr9uoCBDControl.Monad.ExtraifMunlessMwhenMwhileMloopM"stm-2.4.4.1-6AExGOUG8NB2Rzejnay0wwControl.Concurrent.STM.TVarswapTVar modifyTVar' modifyTVarControl.Concurrent.STM.TMVar isEmptyTMVar swapTMVar tryReadTMVar readTMVar tryPutTMVarputTMVar tryTakeTMVar takeTMVarnewEmptyTMVarIO newEmptyTMVarTMVarControl.Concurrent.STM.TChandupTChan readTChan writeTChannewBroadcastTChanTChan,stm-containers-0.2.16-EF4PtF44bcRKCZyiEa2a9iSTMContainers.MapKey embedBytesrawrawQ checkLength onNothing onNothingM fromMaybeM headMaybe MonadInIOliftWith liftWith2$fMonadInIOStateT $fMonadInIOIO atomically readTVarIOnewBroadcastTChanIO newTVarIO newTMVarIOTEqteq $fTEqTVarTMapnullsizelookupmember notMemberempty singletoninsertfromListdeleteelemskeys!SameModuloIfnatValue natValue' symbolValue ReorderTuple tupleReorder TupleCons tupleCons TupleTail tupleTail TupleHead tupleHead ExtractTupletupleN ListToTuple TupleToListSingleuncurry3uncurry4take4 fromTuple4$fExtractTuple7(,,,,,,,)e7$fExtractTuple6(,,,,,,,)e6$fExtractTuple5(,,,,,,,)e5$fExtractTuple4(,,,,,,,)e4$fExtractTuple3(,,,,,,,)e3$fExtractTuple2(,,,,,,,)e2$fExtractTuple1(,,,,,,,)e1$fExtractTuple0(,,,,,,,)e0$fExtractTuple6(,,,,,,)e6$fExtractTuple5(,,,,,,)e5$fExtractTuple4(,,,,,,)e4$fExtractTuple3(,,,,,,)e3$fExtractTuple2(,,,,,,)e2$fExtractTuple1(,,,,,,)e1$fExtractTuple0(,,,,,,)e0$fExtractTuple5(,,,,,)e5$fExtractTuple4(,,,,,)e4$fExtractTuple3(,,,,,)e3$fExtractTuple2(,,,,,)e2$fExtractTuple1(,,,,,)e1$fExtractTuple0(,,,,,)e0$fExtractTuple4(,,,,)e4$fExtractTuple3(,,,,)e3$fExtractTuple2(,,,,)e2$fExtractTuple1(,,,,)e1$fExtractTuple0(,,,,)e0$fExtractTuple3(,,,)e3$fExtractTuple2(,,,)e2$fExtractTuple1(,,,)e1$fExtractTuple0(,,,)e0$fExtractTuple2(,,)e2$fExtractTuple1(,,)e1$fExtractTuple0(,,)e0$fExtractTuple1(,)e1$fExtractTuple0(,)e0$fExtractTuple0Singlet$fTupleHead(,,,,,)a$fTupleHead(,,,,)a$fTupleHead(,,,)a$fTupleHead(,,)a$fTupleHead(,)a$fTupleHeadSinglea$fTupleTail(,,,,,)(,,,,)$fTupleTail(,,,,)(,,,)$fTupleTail(,,,)(,,)$fTupleTail(,,)(,)$fTupleTail(,)Single$fTupleConsa(,,,,)(,,,,,)$fTupleConsa(,,,)(,,,,)$fTupleConsa(,,)(,,,)$fTupleConsa(,)(,,)$fTupleConsaSingle(,)$fReorderTuple(,,,,,,)(,,,,,,)$fReorderTuple(,,,,,,)(,,,,,,)0$fReorderTuple(,,,,,,)(,,,,,,)1$fReorderTuple(,,,,,,)(,,,,,,)2$fReorderTuple(,,,,,,)(,,,,,,)3$fReorderTuple(,,,,,,)(,,,,,,)4$fReorderTuple(,,,,,,)(,,,,,,)5$fReorderTuple(,,,,,)(,,,,,)$fReorderTuple(,,,,,)(,,,,,)0$fReorderTuple(,,,,,)(,,,,,)1$fReorderTuple(,,,,,)(,,,,,)2$fReorderTuple(,,,,,)(,,,,,)3$fReorderTuple(,,,,,)(,,,,,)4$fReorderTuple(,,,,)(,,,,)$fReorderTuple(,,,,)(,,,,)0$fReorderTuple(,,,,)(,,,,)1$fReorderTuple(,,,,)(,,,,)2$fReorderTuple(,,,,)(,,,,)3$fReorderTuple(,,,)(,,,)$fReorderTuple(,,,)(,,,)0$fReorderTuple(,,,)(,,,)1$fReorderTuple(,,,)(,,,)2$fReorderTuple(,,)(,,)$fReorderTuple(,,)(,,)0$fReorderTuple(,,)(,,)1$fReorderTuple(,,)(,,)2$fReorderTuple(,,)(,,)3$fReorderTuple(,)(,)$$fReorderTuple(,,,,,,,,,)(,,,,,,,,,)"$fReorderTuple(,,,,,,,,)(,,,,,,,,) $fReorderTuple(,,,,,,,)(,,,,,,,)$fReorderTuple(,,,,,,)(,,,,,,)6$fReorderTuple(,,,,,)(,,,,,)5$fReorderTuple(,,,,)(,,,,)4$fReorderTuple(,,,)(,,,)3$fReorderTuple(,,)(,,)4$fReorderTuple(,)(,)0$fReorderTupleSingleSingle $fShowSingle $fEqSingleCheckNubMemberUnionIndex MaybeIndexOf IndexesOfIndexOfNubHeadNubFilterZipMapTestIndexesIsSubsetIsMemberGenerateMapMaybe RemoveAtN RemoveAt1RemoveAtReverse ReplaceNSReplaceNReplace ReplaceAtInsertAt ReplicateLengthConcatHeadSnocInitTakeDropTailMaxMapExtractFieldTypes ExtractFields LookupFieldLookupFieldType FieldTypeFieldHTuple' hToTuple' hFromTuple'HReversehReverseHZipListhZipListHFoldl'hFoldl'HFoldlhFoldlHFoldr'hFoldr'HFoldrhFoldrApplyapplyhAppendHListhHeadhTailhLength $fShowHList $fShowHList0$fHAppendList:l'$fHAppendList[]l2 $fHFoldrfv:r'$fHFoldrfv[]v'$fHFoldr'fv:r'$fHFoldr'fv[]v'$fHFoldlfz[]z' $fHFoldlfz:r$fHFoldl'fz[]z' $fHFoldl'fz:r $fHZipList:::$fHZipList[][][] $fHRevApp:l'z$fHRevApp[]l2l2$fHReversexssx$fHTuple':(,,,,,,,,,)$fHTuple':(,,,,,,,,)$fHTuple':(,,,,,,,)$fHTuple':(,,,,,,)$fHTuple':(,,,,,)$fHTuple':(,,,,)$fHTuple':(,,,)$fHTuple':(,,) $fHTuple':(,)$fHTuple':Single $fHTuple'[]() $fOrdHList $fOrdHList0 $fEqHList $fEqHList0ElseThenStripRAddRContTupleToListContListToTupleContFlow>::>>:-:>>:%:>fretfreturnfretNfreturnNfrecfIf ContVariant variantToContvariantToContM contToVariantcontToVariantMvariantToHListLiftableTraverseVarianttraverseVariant' NoConstraint AlterVariant alterVariant'MappableVariant MaybePopablePopableVVariantVMaybe variantIndex toVariantAt toVariantHead toVariantTail fromVariantAt popVariantAtpopVariantHeadupdateVariantAt toVariant popVariantpopVariantMaybefromVariantFirst fromVariantfromVariantMaybeupdateVariantFirstupdateVariantFirstM mapVariantfoldMapVariantAtfoldMapVariantAtMfoldMapVariantFirstfoldMapVariantFirstMfoldMapVariant alterVarianttraverseVarianttraverseVariant_ appendVariantprependVariant liftVariant nubVariantvariantToValuevariantToEithervariantToTuplevariantFromEither $fShowVariant$fShowVariant0 $fOrdVariant $fOrdVariant0 $fEqVariant $fEqVariant0$fPopVarianta:$fPopVarianta[]$fMapVariantabcs:$fMapVariantabcs[]$fMapVariantab[]is$fAlterVariantc:$fAlterVariantc[]$fNoConstrainta$fTraverseVariantc:m$fTraverseVariantc[]m$fVariantLift:ys$fVariantLift[]ys$fVariantToHList:$fVariantToHList[]$fContVariant:$fContVariant:0$fContVariant:1$fContVariant:2$fContVariant:3$fContVariant:4$fContVariant:5$fContVariant:6$fContVariant:7$fContVariant:8$fContVariant:9$fContVariant:10IOVFlowflowSetNflowSet flowSingleflowLift flowToCont flowTraverseflowForflowTraverseFilter flowForFilterflowRes|><|||><||flowMapflowBind flowBind' flowMatch flowMatchFail.~.>>.~.>.~+>>.~+>.~^^>>.~^^>.~^>>.~^>.~$>>.~$>.~|>>.~|>.~=>>.~=>.~!>>.~!>.~!!>>.~!!>.-.>>.-.><.-.<.-.<<$<<*<<|<.~~.>>.~~.>.~~+>>.~~+>.~~^^>>.~~^^>.~~^>>.~~^>.~~$>>.~~$>.~~|>>.~~|>.~~=>>.~~=>.~~!>>.~~!>..~.>>..~.>..-.>>..-.>..-..>>..-..>..~..>>..~..>..~^^>>..~^^>..~^>>..~^>..?~^>>..?~^>..%~^>>..%~^>..?~^^>>..?~^^>..%~^^>>..%~^^>..?~$>>..?~$>..%~$>>..%~$>..~=>>..~=>..~!>>..~!>..~!!>>..~!!>..?~!!>>..?~!!>..%~!!>>..%~!!>..?~!>>..?~!>..%~!>>..%~!>?~.>>?~.>%~.>>%~.>?~+>>?~+>%~+>>%~+>?~^^>>?~^^>%~^^>>%~^^>?~^>>?~^>%~^>>%~^>?~$>>?~$>%~$>>%~$>?~|>>?~|>%~|>>%~|>?~=>>?~=>%~=>>%~=>?~!>>?~!>%~!>>%~!>?~!!>>?~!!>%~!!>>%~!!> makeFlowOp makeFlowOpM selectFirst selectTail selectType applyConst applyPureapplyMapplyF combineFirstcombineSameTail combineEither combineConcat combineUnioncombineLiftUnselectedcombineLiftBoth combineSingleliftVliftF MatchResultNoMatchMatch DontMatch MatchFail MatchDiverge PredicatedPredErrPredPredTerm liftTerminalreducePredicates getTerminals getPredicatesRuleTerminal NonTerminalFail Constraint PredicateNotAndOrXorCBool PredOracle PredStateSetPred UnsetPred UndefPred predIsSet predIsUnset predIsUndefpredIs predState makeOracleoraclePredicates emptyOracleconstraintReduceorderedNonTerminalsimplifyConstraint mergeRulesevalsToapplyPinitPresultPcreatePredicateTable$fFunctorConstraint $fFunctorRule$fFunctorMatchResult$fPredicatedConstraint$fPredicatedRule$fShowPredState $fEqPredState$fOrdPredState$fShowConstraint$fEqConstraint$fOrdConstraint $fShowRule$fEqRule $fOrdRule$fShowMatchResult$fEqMatchResult$fOrdMatchResultTSettoListstreamunionsmapTNodeTListvalue deleteAlllengthfirstlastprevnextappendappend_prependprepend_ insertBefore insertAfter toReverseListfilterfindindextake TTreePathTTreetreeKey treeValue treeChildren treeParentaddChild detachChild attachChildtreeFollowPath nodeValue nodeEdgeIn nodeEdgeOut deepFirst breadthFirstlinkTo FutureSourceFuture newFuture newFutureIO setFuture setFutureIO setFuture' waitFuture pollFuture pollFutureIOChoice ParseError SyntaxError EndOfInputchoicechoice'many manyAtMost manyAtMost' manyAtMost'' manyAtLeastmanyTill manyTill' manyBounded$fApplyChoice(,)z$fShowParseError$fEqParseErrorHArrayT runHArrayTHArrayTryIndexT HArrayIndexT HArrayIndexHArray emptyHArray singleHArray getHArrayN getHArray0 setHArrayN getHArrayT setHArrayT tryGetHArrayT appendHArray prependHArray concatHArray initHArray tailHArray>~:~>MStateMStateT runMState evalMState execMStatemSetmGetmTryGetmModifymModify'mWith liftMStateT>~:>>:>)file-embed-0.0.10.1-dHJWrXRvu59h2yyMVhlwGData.FileEmbedmakeRelativeToProjectinjectFileWith injectFile injectWithinjectdummySpaceWith dummySpacestrToExpembedOneStringFileOfembedStringFile stringToBsbsToExpgetDirembedDirembedOneFileOf embedFile++GHC.Listzipfoldrfoldlfoldl'foldl1sumproductfoldr1maximumminimumelem Data.ListisSubsequenceOf mapAccumR mapAccumLnotElem minimumBy maximumByallanyorand concatMapconcat Data.OldListunwordswordsunlineslinesunfoldrsortOnsortBysort permutations subsequencestailsinitsgroupBygroupdeleteFirstsByunzip7unzip6unzip5unzip4zipWith7zipWith6zipWith5zipWith4zip7zip6zip5zip4genericReplicate genericIndexgenericSplitAt genericDrop genericTake genericLengthinsertBy partition transpose intercalate intersperse intersectBy intersectunionByunion\\deleteBynubBynub isInfixOf isSuffixOf isPrefixOf findIndices findIndex elemIndices elemIndex stripPrefix dropWhileEndunzip3unzipzipWith3zipWithzip3!!reversebreakspansplitAtdrop dropWhile takeWhilecycle replicaterepeatiteratescanr1scanrscanl'scanl1scanlfoldl1'inittailunconsheadData.List.ExtranubOrdBynubOrdOnnubOrd nubSortBy nubSortOnnubSortchunksOf stripInfixEnd stripInfix stripSuffix dropWhileEnd'splitsplitOn breakOnEndbreakOn mconcatMapdrop1 firstJustlinesBywordsByspanEndbreakEndreplacemergeBymerge groupSortBy groupSortOn groupSort minimumOn maximumOnnubOngroupOnline1word1upperlowertrimtrimEnd trimStart takeWhileEnd concatUnzip3 concatUnzip zipWithFromzipFrom splitAtEnddropEndtakeEndsnocconsunsnoclistallSameanySamedisjointfor repeatedlycontainers-0.5.10.2Data.Map foldWithKeyfoldinsertLookupWithKey'insertWithKey' insertWith'$Data.Map.Internal.DeprecatedShowTree showTreeWithshowTreeData.Map.Internal.DebugvalidData.Map.Internal splitRoot deleteFindMax deleteFindMin splitLookupfromDistinctDescListfromDistinctAscListfromDescListWithKeyfromAscListWithKeyfromDescListWithfromAscListWith fromDescList fromAscList toDescList toAscListfromListWithKey fromListWithfromSetkeysSetassocsfoldMapWithKey foldlWithKey' foldlWithKey foldrWithKey' foldrWithKeyfoldr'mapKeysMonotonic mapKeysWithmapKeysmapAccumRWithKeymapAccumWithKeymapAccumtraverseWithKey mapWithKeymapEitherWithKey mapEithertraverseMaybeWithKeymapMaybeWithKeymapMaybepartitionWithKey spanAntitonedropWhileAntitonetakeWhileAntitone filterWithKeyisProperSubmapOfByisProperSubmapOf isSubmapOfBy isSubmapOf mergeWithKeyintersectionWithKeyintersectionWith restrictKeys intersectiondifferenceWithKeydifferenceWith withoutKeys difference unionWithKey unionWith unionsWithmaxViewminViewmaxViewWithKeyminViewWithKeyupdateMaxWithKeyupdateMinWithKey updateMax updateMin deleteMax deleteMinfindMax lookupMaxfindMin lookupMindeleteAtupdateAtelemAt lookupIndexalterFalterupdateLookupWithKey updateWithKeyupdate adjustWithKeyadjustinsertLookupWithKey insertWithKey insertWithlookupGElookupLElookupGTlookupLTfindWithDefault!?Data.Map.Strict.Internal Data.Maybe fromMaybeMaybeNothingJust catMaybes listToMaybe maybeToListfromJust isNothingisJustmaybeMonad>>=>>returnfailFunctorfmapmfilter<$!> zipWithM_zipWithM mapAndUnzipMmsum sequence_apliftM5liftM4liftM3liftM2liftM=<< MonadPlusmzeromplus firstJustMfindMandMorMallManyM&&^||^notM mapMaybeM mconcatMapM concatForM concatMapM partitionMeitherMmaybeMunit whenJustMwhenJusttransformers-0.5.2.0Control.Monad.Trans.Class MonadTransliftModulo'Word Data.Tuplefstsndswapuncurrycurry MaybeIndexOf' IndexesOf'IndexOf' IsSubset' IsMember'Max' GHC.GenericsGenericRepfromtoGeneric1Rep1from1to1Datatype datatypeName moduleName packageName isNewtype ConstructorconName conFixity conIsRecordSelectorselNameselSourceUnpackednessselSourceStrictnessselDecidedStrictnessV1U1Par1unPar1Rec1unRec1K1unK1M1unM1:+:L1R1:*::.:Comp1unComp1RDCSRec0D1C1S1URecUAddrUCharUDoubleUFloatUIntUWorduAddr#uChar#uDouble#uFloat#uInt#uWord#precFixityPrefixInfixFixityIPrefixIInfixI AssociativityLeftAssociativeRightAssociativeNotAssociativeSourceUnpackedness SourceUnpackSourceNoUnpackNoSourceUnpackednessSourceStrictness SourceLazy SourceStrictNoSourceStrictnessDecidedStrictness DecidedLazy DecidedStrict DecidedUnpackMetaMetaDataMetaConsMetaSelHNilHConsHRevApphRevApp hUnzipList HAppendList D:R:HList:0 D:R:HList[]0AlterMAlter popVariant'VariantToHList VariantLift liftVariant' MapVariant mapVariant' PopVariantliftmapplyVMconstraintIsBoolgetConstraintPredicatesgetConstraintTerminals ruleReducegetRuleTerminalsgetRulePredicates insertBetweennodePrevnodeNextIO