{      !"#$%&'()*+,-./0123456789:;<=>?@ABCDEFGHIJKLMNOPQRSTUVWXYZ[\]^_`abcdefghijklmnopqrstuvwxyz{|}~                  !"#$%&'()*+,-./0123456789:;<=>?@ABCDEFGHIJKLMNOPQRSTUVWXYZ[\]^_`abcdefghijklmnopqrstuvwxyz Safe-Inferred {|}~| {|}~ Safe-Inferred      Safe-InferredY ZOrdGr comes equipped with an Ord instance, so that graphs can be used as e.g. Map keys. Merge the  into the  .Minimum implementation: , , , ,  An empty .True if the given  is empty. Decompose a  into the - found for the given node and the remaining . Create a  from the list of )s and &s.&For graphs that are also instances of  , mkGraph ns es should be equivalent to (> es . = ns) .A list of all ) s in the .Decompose a graph into the  for an arbitrarily-chosen * and the remaining .The number of *s in a .The minimum and maximum * in a .A list of all & s in the .Unlabeled decomposition.Unlabeled context. The same as , only more sure of itself., decomposition - the context removed from a , and the rest of the . Links to the *, the *! itself, a label, links from the *.Labeled links to or from a *. Quasi-unlabeled path! Labeled path$Unlabeled path%Quasi-unlabeled edge& Labeled edge'Unlabeled edge(Quasi-unlabeled node) Labeled node*Unlabeled node+Fold a function over the graph.,Map a function over the graph.-Map a function over the * labels in a graph..Map a function over the ' labels in a graph./Map functions over both the * and ' labels in a graph.0 List all * s in the .1 List all ' s in the .2$Drop the label component of an edge.3Add a label to an edge.4The label in an edge.5List N available *s, i.e. *s that are not used in the .6 if the * is present in the .7 Insert a ) into the .8 Insert a & into the .9 Remove a * from the .: Remove an ' from the .6NOTE: in the case of multiple edges, this will delete all such edges from the graph as there is no way to distinguish between them. If you need to delete only a single such edge, please use ;.; Remove an & from the .VNOTE: in the case of multiple edges with the same label, this will only delete the first5 such edge. To delete all such edges, please use  delAllLedges.<,Remove all edges equal to the one specified.=Insert multiple ) s into the .>Insert multiple & s into the .?Remove multiple * s from the .@Remove multiple ' s from the .ABuild a  from a list of s.2The list should be in the order such that earlier 1s depend upon later ones (i.e. as produced by + (:) []).BBuild a quasi-unlabeled .CCBuild a graph out of the contexts for which the predicate is true.D[Returns the subgraph only containing the labelled nodes which satisfy the given predicate.ERReturns the subgraph only containing the nodes which satisfy the given predicate.FYReturns the subgraph only containing the nodes whose labels satisfy the given predicate.G3Returns the subgraph induced by the supplied nodes.HFind the context for the given *. Causes an error if the * is not present in the .IFind the label for a *.JFind the neighbors for a *.K4Find the labelled links coming into or going from a .L Find all *"s that have a link from the given *.M Find all *s that link to to the given *.N Find all *!s that are linked from the given * and the label of each link.O Find all *s that link to the given * and the label of each link.PFind all outward-bound &s for the given *.QFind all inward-bound &s for the given *.R The outward-bound degree of the *.SThe inward-bound degree of the *.TThe degree of the *.UThe * in a .VThe label in a .WThe ) from a .XAll *s linked to or from in a .Y/All labelled links coming into or going from a .ZAll *s linked to in a .[All *s linked from in a .\All *s linked from in a , and the label of the links.]All *s linked from in a , and the label of the links.^All outward-directed &s in a ._All inward-directed &s in a .`The outward degree of a .aThe inward degree of a .bThe degree of a .c5Checks if there is a directed edge between two nodes.d8Checks if there is an undirected edge between two nodes.e5Checks if there is a labelled edge between two nodes.fAChecks if there is an undirected labelled edge between two nodes.hbPretty-print the graph. Note that this loses a lot of information, such as edge inverses, etc.i!Pretty-print the graph to stdout.s   !"#$%&'()*+,-./0123456789:;<=>?@ABCDEFGHIJKLMNOPQRSTUVWXYZ[\]^_`abcdefghi`  !"#$%&'()*+,-./0123456789:;<=>?@ABCDEFGHIJKLMNOPQRSTUVWXYZ[\]^_`abcdefghi`*)('&%$!"#  +,-./0124356789:;<=>?@ABCEDFGHIJKLMNOPQRSTcdefgUVWXYZ[]\^_`abhi d     !"#$%&'()*+,-./0123456789:;<=>?@ABCDEFGHIJKLMNOPQRSTUVWXYZ[\]^_`abcdefghi Safe-Inferred j#Reverse the direction of all edges.k^Make the graph undirected, i.e. for every edge from A to B, there exists an edge from B to A.lRemove all labels.m Return all 's for which the given function returns .nFilter based on edge property.o$Filter based on edge label property.p/ if the graph has any edges of the form (A, A).qThe inverse of p.rDirected graph fold.s Flatten a ', returning the elements in post-order.tFlatten multiple s in post-order.u Flatten a 6, returning the elements in pre-order. Equivalent to  in .vFlatten multiple s in pre-order.jklmnopqrdirection of folddepth aggregationbreadth/level aggregationstuv jklmnopqrstuv jklmrnopqstuvjklmnopqrstuvNone0Mwxwxxwwx Safe-Inferred6 graph foldyz{|}~yz{|}~yz{|}~y z{|}~None2346_filter list (of successors/predecessors) through a boolean ST array representing deleted marks  None6 generate list of unlabeled nodesgenerate list of labeled nodesdenote unlabeled edgesempty (unlabeled) edge list3333 Safe-Inferred 3Graph construction monad; handles passing both the  and the .Create a new, empty mapping.;Generate a mapping containing the nodes in the given graph.^Generate a labelled node from the given label. Will return the same node for the same label.5Generate a labelled node and throw away the modified . Generate a & from the node labels.Generates a list of &s.Construct a list of nodes.6Construct a list of nodes and throw away the modified .GRun a construction; return the value of the computation, the modified , and the modified .'Run a construction and only return the .Monadic node construction.,##)  Safe-InferredeFinds the articulation points for a connected undirected graph, by using the low numbers criteria:Ja) The root node is an articulation point iff it has two or more children.b) An non-root node v is an articulation point iff there exists at least one child w of v such that lowNumber(w) >= dfsNumber(v).   Safe-InferredMany functions take a list of nodes to visit as an explicit argument. fixNodes is a convenience function that adds all the nodes present in a graph as that list.fMost general DFS algorithm to create a list of results. The other list-returning functions such as ) are all defined in terms of this one.  d f vs = v .  d f vs Depth-first search.\Undirected depth-first search, obtained by following edges regardless of their direction.?Reverse depth-first search, obtained by following predecessors.WMost general DFS algorithm to create a forest of results, otherwise very similar to /. The other forest-returning functions such as ) are all defined in terms of this one.(Discard the graph part of the result of . +xdffWith d f vs g = fst (xdfWith d f vs g) Directed depth-first forest.\Undirected depth-first forest, obtained by following edges regardless of their direction.?Reverse depth-first forest, obtained by following predecessors."Collection of connected componentsNumber of connected componentsIs the graph connected? Flatten a  in reverse order!Flatten a forest in reverse order 0http://en.wikipedia.org/wiki/Topological_sortingTopological sorting, i.e. a list of *ms so that if there's an edge between a source and a target node, the source appears earlier in the result.), returning only the labels of the nodes.+Collection of strongly connected components 4Collection of nodes reachable from a starting point. [The condensation of the given graph, i.e., the graph of its strongly connected components.#@Mapping from a node to its neighbours to be visited as well. Z for example makes ? traverse the graph following the edge directions, while [ means reversed directions.Mapping from the  of a node to a result value.Nodes to be visited.      #   Safe-Inferred Finds the bi-connected components of an undirected connected graph. It first finds the articulation points of the graph. Then it disconnects the graph on each articulation point and computes the connected components.     Safe-Inferred Breturn immediate dominators for each node of a graph, given a root Breturn the set of dominators of the nodes of a graph, given a root          Safe-InferredECalculate the maximum independent node set of the specified graph.5The maximum independent node set along with its size. Safe-Inferred6%0encapsulates a simple recursion schema on graphs-2Monadic graph algorithms are defined in two steps: Cdefine the (possibly parameterized) graph transformer (e.g., dfsGT)=run the graph transformer (applied to arguments) (e.g., dfsM).+depth-first search yielding number of nodes0&depth-first search yielding dfs forest' !"#$%&'()*+,-./012# !"#$%&'()*+,-./012# !"#$%&'()*+,-./012& !"#$%&'()*+,-./012 Safe-Inferred3Finds the transitive closure of a directed graph. Given a graph G=(V,E), its transitive closure is the graph: G* = (V,E*) where E*={(i,j): i,j in V and there is a path from i to j in G}3333 Safe-Inferred045455445 Safe-Inferred=Find the first path in a tree that starts with the given node6789:;6789:;6789:;6789:; Safe-Inferred<=>?@AB<=>?@AB<=>?@AB<=>?@AB Safe-InferredCDEFGHIJKLMN 6CDEFGHIJKLMN FDECGHJIKM6LNCDEFGHIJKLMN Safe-InferredO  i 0 For each edge a--->b this function returns edge b--->a . i Edges a<--->b are ignored j P  i 0 For each edge a--->b insert into graph the edge a<---b . Then change the i (i,0,i) label of every edge from a---->b to a------->b Cwhere label (x,y,z)=(Max Capacity, Current flow, Residual capacity)Q/Given a successor or predecessor list for node u and given node v*, find the label corresponding to edge (u,v)d and update the flow and residual capacity of that edge's label. Then return the updated list.R=Update flow and residual capacity along augmenting path from s to t in graph @G. For a path  [u,v,w,...] find the node u in GS and its successor and predecessor list, then update the corresponding edges (u,v) and L(v,u)@ on those lists by using the minimum residual capacity of the path.SCompute the flow from s to t, on a graph whose edges are labeled with 5(x,y,z)=(max capacity,current flow,residual capacity)" and all edges are of the form a<---->b. First compute the residual graph, that is, delete those edges whose residual capacity is zero. Then compute the shortest augmenting path from s to t, and finally update the flow and residual capacity along that path by using the minimum capacity of that path. Repeat this process until no shortest path from s to t exist.THCompute the flow from s to t on a graph whose edges are labeled with x, which is the max capacity and where not all edges need to be of the form a<---->b. Return the flow as a grap whose edges are labeled with (x,y,z)=(max capacity,current flow,residual capacity) and all edges are of the form a<---->bU Compute the maximum flow from s to t on a graph whose edges are labeled with x, which is the max capacity and where not all edges need to be of the form a<---->b. Return the flow as a graph whose edges are labeled with (y,x) = (current flow, max capacity).V"Compute the value of a maximumflowOPQRSTUVOPQRSTUVOPQRSTUVOPQRSTUVNone     WXY ZWXYZWYXZ     WXY Z Safe-Inferred[\]^_`abcdefghijk![\]^_`abcdefghijk[]\^_`abcdefghijk[]\^_`abcdefghijk! Safe-Inferred"#lmn$%7lmnlmn7"#lmn$% Safe-Inferredo#Dijkstra's shortest path algorithm.pSTree of shortest paths from a certain node to the rest of the (reachable) nodes.Corresponds to oo applied to a heap in which the only known node is the starting node, with a path of length 0 leading to it.q.Length of the shortest path between two nodes.r Shortest path between two nodes.&o.Initial heap of known paths and their lengths.pqStart DestinationrStart Destination7[opqrprqo7[&opqr Safe-Inferreds)Representation of a shortest path forest.tiProduce a shortest path forest (the roots of which are those nodes specified) from nodes in the graph to( one of the root nodes (if possible).uiProduce a shortest path forest (the roots of which are those nodes specified) from nodes in the graph from( one of the root nodes (if possible).v<Return the nodes reachable to/from (depending on how the s was constructed) from the specified root node (if the specified node is not one of the root nodes of the shortest path forest, an empty list will be returned).'iTry to construct a path to/from a specified node to one of the root nodes of the shortest path forest.w[Try to determine the nearest root node to the one specified in the shortest path forest.xThe distance to the w2 (if there is one) in the shortest path forest.yiTry to construct a path to/from a specified node to one of the root nodes of the shortest path forest.stuv'wxy7stuvwxys7tuvwxystuv'wxyNones      !"#$%&'()*+,-./012367CDEFGHIJKLMNOPQRSTUVWXYZ[lmnopqrstuvwxyNonez Version infoz!  !"#$%&'()*+,-./0123456789:;<=>?@ABCDEFGHIJKLMNOPQRSTUVWXYZ[\]^_`abcdefghijklmnopqrstuvwxyz{|}~      !"#$%&'()*+,-./012367CDEFGHIJKLMNOPQRSTUVWXYZ[lmnopqrstuvwxyzzz( !"#$%&'())*+,-./0123456789:;<=>?@ABCDEFGHIJKLMNOPQRSTUVWXYZ[\]^_`abcdefghijklmnopqrstuvwxyz{|}~                           ! " # $ % & ' ( ) * + ,-./0123456789:;<=>?@ABCDEFGHIJKLMNOPQRSTUVWXYZ[\]^_`abcdefghijklmnopqrstuvHwxy.z{|}/~                                       !"#$%&'()*+,-./0 fgl-5.5.2.3$Data.Graph.Inductive.Internal.ThreadData.Graph.Inductive.GraphData.Graph.Inductive.Basic!Data.Graph.Inductive.PatriciaTreeData.Graph.Inductive.Monad"Data.Graph.Inductive.Monad.IOArrayData.Graph.Inductive.ExampleData.Graph.Inductive.NodeMap#Data.Graph.Inductive.Query.ArtPointData.Graph.Inductive.Query.DFSData.Graph.Inductive.Query.BCC%Data.Graph.Inductive.Query.Dominators Data.Graph.Inductive.Query.Indep Data.Graph.Inductive.Query.Monad$Data.Graph.Inductive.Query.TransClosData.Graph.Inductive.Tree&Data.Graph.Inductive.Internal.RootPath#Data.Graph.Inductive.Internal.QueueData.Graph.Inductive.Query.BFS"Data.Graph.Inductive.Query.MaxFlow#Data.Graph.Inductive.Query.MaxFlow2"Data.Graph.Inductive.Internal.HeapData.Graph.Inductive.Query.MSTData.Graph.Inductive.Query.SPData.Graph.Inductive.Query.GVDData.Graph.Inductive Paths_fglDataTreeData.Graph.Inductive.QuerySplitMCollectThreadSplit threadList' threadList threadMaybe' threadMaybesplitPar splitParMOrdGrunOrdGrDynGraph&GraphemptyisEmptymatchmkGraphlabNodesmatchAnynoNodes nodeRangelabEdgesUDecompUContextGDecompDecompMContextContextAdjUPathLPathLPunLPathPathUEdgeLEdgeEdgeUNodeLNodeNodeufoldgmapnmapemapnemapnodesedgestoEdgetoLEdge edgeLabelnewNodesgeleminsNodeinsEdgedelNodedelEdgedelLEdge delAllLEdgeinsNodesinsEdgesdelNodesdelEdgesbuildGrmkUGraph gfiltermap labnfilternfilter labfiltersubgraphcontextlab neighbors lneighborssucprelsuclpreoutinnoutdegindegdegnode'lab'labNode' neighbors' lneighbors'suc'pre'lsuc'lpre'out'inn'outdeg'indeg'deg'hasEdge hasNeighborhasLEdgehasNeighborAdjequalprettify prettyPrintgrevundirunlabgselefilterelfilterhasLoopisSimplegfold postorder postorderFpreorder preorderFUGrGrGraphMemptyMisEmptyMmatchMmkGraphM labNodesM matchAnyMnoNodesM nodeRangeM labEdgesMufoldMnodesMedgesM newNodesMdelNodeM delNodesM mkUGraphMcontextMlabMUSGrContext'GraphRepSGrdefaultGraphSizeemptyN removeDel genUNodes genLNodes labUEdgesnoEdgesabcee3loopababbcyc3dag3dag4d1d3g3g3ba'b'c'e'e3'loop'ab'abb'dag3'dag4'd1'd3'ucyclestarucycleMstarMclr479clr486clr489clr508clr528clr595gr1kin248vorclr479'clr486'clr489'clr508'clr528'kin248'vor'NodeMapMNodeMapnew fromGraphmkNodemkNode_mkEdgemkEdgesmkNodesmkNodes_ insMapNode insMapNode_ insMapEdge delMapNode delMapEdge insMapNodes insMapNodes_ insMapEdges delMapNodes delMapEdges mkMapGraphrunrun_mkNodeMmkNodesMmkEdgeMmkEdgesM insMapNodeM insMapEdgeM delMapNodeM delMapEdgeM insMapNodesM insMapEdgesM delMapNodesM delMapEdgesMapCFunxdfsWithdfsdfsWithdfsWith'dfs'udfsudfs'rdfsrdfs'xdfWithxdffWithdffdffWithdffWith'dff'udffudffWith udffWith'udff'rdffrdffWith rdffWith'rdff' components noComponents isConnectedtopsorttopsort'scc reachable condensationbcciDomdomindep indepSizeGTMGTmapFstmapSnd><orPapplyapply' applyWith applyWith'runGTcondMGT'recMGT'condMGTrecMGTgetNode getContext getNodes'getNodessucGTsucMgraphRec graphRec' graphUFold graphNodesM0 graphNodesM graphNodes graphFilterM graphFilterdfsGTdfsMdfsM'dffMgraphDff graphDff'trcRTreeLRTreegetPathgetLPath getDistance getLPathNodesQueueMkQueuemkQueuequeuePut queuePutListqueueGet queueEmptybfsnWithbfsnbfsWithbfslevellevelnbfenbfebftesplbftlesp getRevEdges augmentGraph updAdjList updateFlowmfmgmf maxFlowgraphmaxFlowNetworkekFusedekSimpleekListHeapEmpty prettyHeapprintPrettyHeapunitinsertmergemergeAllfindMin deleteMinsplitMinbuildtoListheapsortmsTreeAtmsTreemsPathdijkstraspTreespLengthspVoronoigvdIngvdOut voronoiSet nearestNode nearestDist nearestPathversioncatchIObindirlibdirdatadir libexecdir sysconfdir getBinDir getLibDir getDataDir getLibexecDir getSysconfDirgetDataFileNameghc-prim GHC.TypesTrue GroupEdgesGEs delLEdgeBy slabNodes glabEdgeseqLists.:flip2 context1l context4lmcontext context1l' context4l' $fOrdOrdGr $fEqOrdGr$fEqGroupEdges $fOrdLPath $fEqLPath $fShowLPathcontainers-0.5.5.1 Data.Treeflatten threadGraphgfold1gfoldnmatchGr fastInsNode fastInsEdgefastGMapfastNMapfastEMap fastNEMaptoAdjfromAdj toContext fromContextswapaddListsaddSuccaddPred clearSucc clearPred $fNFDataGr $fDynGraphGr $fGraphGr$fReadGr$fShowGr$fEqGr>>. labUNodesonMatch showGraph $fGraphMIOSGr$fShowIO $fShowSGrmapkeymap'liftN2liftN2'liftM1liftM1'$fNFDataNodeMapLOWTreeBrcDFSTreeB getBackEdgesdfsTree minbckEdgegetLowlowTree getLowTreeisaparp artpointsfixNodes postflatten postflattenF gComponents embedContexts findGraph splitGraphsFromNodeToNodePredsIDomNode'idomWork refineIDom intersectgetDom numberTree numberForest treeEdgesfixEq nodeGetter $fMonadGT$fApplicativeGT $fFunctorGT getNewEdges cleanSplitupdAdjfindPfirst bfsnInternalsuci bfenInternaloutUbflbf EKStepFuncDirRTreeDirPathDirEdge DirectionBackwardForwardpathFromDirPath augPathFusedbftForEKbfForEKextractPathFused ekFusedStep residualGraphaugPath extractPath extractEdge extractAdj getPathDeltasintegrateDelta ekSimpleStepekWithextractPathList ekStepList $fNFDataHeapnewEdgesprim joinPathsjoinAtexpand maybePath