7      !"#$%&'()*+,-./0123456789:;<=>?@ABCDEFGHIJKLMNOPQRSTUVWXYZ[\]^_`abcdefghijklmnopqrstuvwxyz{|}~             !"#$%&'()*+,-./0123456789:;<=>?@ABCDEFGHIJKLMNOPQRSTUVWXYZ[\]^_`abcdefghijklmnopqrstuvwxyz{|}~Safe  Safe     Safe     Safe !" ! ! !"Safe[&ZOrdGr comes equipped with an Ord instance, so that graphs can be used as e.g. Map keys.* Merge the : into the ).pContexts should only refer to either a Node already in a graph or the node in the Context itself (for loops).+Minimum implementation: ,, -, ., /, 0, An empty +.-True if the given + is empty.. Decompose a + into the 9- found for the given node and the remaining +./ Create a + from the list of Es and Bs.&For graphs that are also instances of ), mkGraph ns es should be equivalent to (\ es . [ ns) ,.0A list of all E s in the +.1Decompose a graph into the : for an arbitrarily-chosen F and the remaining +.2The number of Fs in a +.3The minimum and maximum F in a +.4A list of all B s in the +.5Unlabeled decomposition.6Unlabeled context.7 The same as 8, only more sure of itself.8+, decomposition - the context removed from a +, and the rest of the +.: Links to the F, the F! itself, a label, links from the F.;Labeled links to or from a F.<Quasi-unlabeled path= Labeled path@Unlabeled pathAQuasi-unlabeled edgeB Labeled edgeCUnlabeled edgeDQuasi-unlabeled nodeE Labeled nodeFUnlabeled nodeG0The number of nodes in the graph. An alias for 2.H!The number of edges in the graph.Note that this counts every edge found, so if you are representing an unordered graph by having each edge mirrored this will be incorrect.dIf you created an unordered graph by either mirroring every edge (including loops!) or using the undir function in Data.Graph.Inductive.Basic9 then you can safely halve the value returned by this.IFold a function over the graph.JMap a function over the graph.KMap a function over the F labels in a graph.LMap a function over the C labels in a graph.MMap functions over both the F and C labels in a graph.N List all F s in the +.O List all C s in the +.P$Drop the label component of an edge.QAdd a label to an edge.RThe label in an edge.SList N available Fs, i.e. Fs that are not used in the +.T if the F is present in the +.U Insert a E into the +.V Insert a B into the +.W Remove a F from the +.X Remove an C 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 Y.Y Remove an B 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  delAllLedge.Z,Remove all edges equal to the one specified.[Insert multiple E s into the +.\Insert multiple B s into the +.]Remove multiple F s from the +.^Remove multiple C s from the +._Build 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 I (:) []).`Build a quasi-unlabeled +.aCBuild a graph out of the contexts for which the predicate is true.b[Returns the subgraph only containing the labelled nodes which satisfy the given predicate.cRReturns the subgraph only containing the nodes which satisfy the given predicate.dYReturns the subgraph only containing the nodes whose labels satisfy the given predicate.e3Returns the subgraph induced by the supplied nodes.fFind the context for the given F. Causes an error if the F is not present in the +.gFind the label for a F.hFind the neighbors for a F.i4Find the labelled links coming into or going from a :.j Find all F"s that have a link from the given F.k Find all Fs that link to to the given F.l Find all F!s that are linked from the given F and the label of each link.m Find all Fs that link to the given F and the label of each link.nFind all outward-bound Bs for the given F.oFind all inward-bound Bs for the given F.p The outward-bound degree of the F.qThe inward-bound degree of the F.rThe degree of the F.sThe F in a :.tThe label in a :.uThe E from a :.vAll Fs linked to or from in a :.w/All labelled links coming into or going from a :.xAll Fs linked to in a :.yAll Fs linked from in a :.zAll Fs linked from in a :, and the label of the links.{All Fs linked from in a :, and the label of the links.|All outward-directed Bs in a :.}All inward-directed Bs in a :.~The outward degree of a :.The inward degree of a :.The degree of a :.5Checks if there is a directed edge between two nodes.8Checks if there is an undirected edge between two nodes.5Checks if there is a labelled edge between two nodes.AChecks if there is an undirected labelled edge between two nodes.bPretty-print the graph. Note that this loses a lot of information, such as edge inverses, etc.!Pretty-print the graph to stdout.u&'()*+,-./0123456789:;<=>?@ABCDEFGHIJKLMNOPQRSTUVWXYZ[\]^_`abcdefghijklmnopqrstuvwxyz{|}~b&'()*+.,-/0123456789:;<=>?@ABCDEFGHIJKLMNOPQRSTUVWXYZ[\]^_`abcdefghijklmnopqrstuvwxyz{|}~bFEDCBA;:98765@=>?<+,-./01234)*GHIJKLMNOPRQSTUVWXYZ[\]^_`acbdefghijklmnopqrstuvwxy{z|}~&'(f&'()*+ ,-./0123456789:;<=>?@ABCDEFGHIJKLMNOPQRSTUVWXYZ[\]^_`abcdefghijklmnopqrstuvwxyz{|}~Safe=Find the first path in a tree that starts with the given nodeSafe<= graph fold None9:;<=_filter list (of successors/predecessors) through a boolean ST array representing deleted marks(Please not that this instance is unsafe.(Please not that this instance is unsafe.  None9:;<=_filter list (of successors/predecessors) through a boolean ST array representing deleted marks(Please not that this instance is unsafe.   Safe 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 B from the node labels.Generates a list of Bs.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.,##) None5T SafeeFinds 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             SafeECalculate the maximum independent node set of the specified graph.5The maximum independent node set along with its size.SafeNone   !"#$%&' ()            !"#$%&' () Safe<=&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 nodes1&depth-first search yielding dfs forest' !"#*$%&'()*+,-./0123456# !"#$%&'()*+,-./0123# !"#$%&'()*+,-./0123& !"#*$%&'()*+,-./01234568Safe7#Dijkstra's shortest path algorithm.8STree of shortest paths from a certain node to the rest of the (reachable) nodes.Corresponds to 7o applied to a heap in which the only known node is the starting node, with a path of length 0 leading to it.9.Length of the shortest path between two nodes.: Shortest path between two nodes.+7.Initial heap of known paths and their lengths.89Start Destination:Start Destination789:8:97+789:Safe;Finds 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}<Finds the transitive, reflexive 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 either i = j or there is a path from i to j in G}=Finds the reflexive closure of a directed graph. Given a graph G=(V,E), its transitive closure is the graph: G* = (V,Er union E) where Er = {(i,i): i in V};<=;<=<=;;<=Safe5>,-?./01234@ABCDEF>??>>,-?./01234@ABCDEFNone<=H generate list of unlabeled nodesIgenerate list of labeled nodesJdenote unlabeled edgesKempty (unlabeled) edge list3HIJKLMNOPQRSTUVWXYZ[\]^_`abcdefghijklmnopqrstuvwxyz3HIJKLMNOPQRSTUVWXYZ[\]^_`abcdefghijklmnopqrstuvwxyz3HIJKLMNOQRSUPTYZVWX[\]^`abc_defghijkmlnopqrstvuwxyz3HIJKLMNOPQRSTUVWXYZ[\]^_`abcdefghijklmnopqrstuvwxyzSafe {#Reverse the direction of all edges.|^Make the graph undirected, i.e. for every edge from A to B, there exists an edge from B to A.}Remove all labels.~ Return all :'s for which the given function returns .Filter based on edge property.$Filter based on edge label property./ if the graph has any edges of the form (A, A).The inverse of .Directed graph fold. Flatten a 5', returning the elements in post-order.Flatten multiple 5s in post-order. Flatten a 56, returning the elements in pre-order. Equivalent to 6 in .Flatten multiple 5s in pre-order.{|}~789direction of folddepth aggregationbreadth/level aggregation {|}~ {|}~{|}~789Safe:Many 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 =  .  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 5 in reverse order<!Flatten a forest in reverse order 0http://en.wikipedia.org/wiki/Topological_sortingTopological sorting, i.e. a list of Fms 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 components4Collection 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. x for example makes ? traverse the graph following the edge directions, while y means reversed directions.Mapping from the : of a node to a result value.Nodes to be visited.;<  #:;<SafeFinds 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.=>?@=>?@SafeBreturn immediate dominators for each node of a graph, given a rootBreturn the set of dominators of the nodes of a graph, given a rootABCDEFGHIJKLMABCDEFGHIJKLMSafe)Representation of a shortest path forest.iProduce 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).iProduce 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).<Return the nodes reachable to/from (depending on how the  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).NiTry to construct a path to/from a specified node to one of the root nodes of the shortest path forest.[Try to determine the nearest root node to the one specified in the shortest path forest.The distance to the 2 (if there is one) in the shortest path forest.iTry to construct a path to/from a specified node to one of the root nodes of the shortest path forest.NNSafe  i 0 For each edge a--->b this function returns edge b--->a . i Edges a<--->b are ignored j   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)/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.=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.Compute 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.HCompute 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<---->b 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)."Compute the value of a maximumflowNoneu     !"#$%&'()*+,-./0123789:;<=None Version info%&'()*+.,-/0123456789:;<=>?@ABCDEFGHIJKLMNOPQRSTUVWXYZ[\]^_`abcdefghijklmnopqrstuvwxyz{|}~     !"#$%&'()*+,-./0123789:;<={|}~O !"#$%&'()*+,-./0123456789:;<=>?@ABCDEFFGHIJ6;KLMNOPQRSTUVWXYZ[\]^_`ab3cdefghijklmnopqrstuvwxyz{|}~                             !"#$%&'()*+,-./0123456789:;<=>?@ABCDEFGHIJKLMNOPQRSTUVWXYZ[\]^_`abcdefghijklmnopqrstuvwxyz{|}~R                                                !"#$%&'()*+,-./012123456789:;<=>?@ABCDEFGHIJKL"fgl-5.5.3.0-KO9F4uETTjy3vgLQ22ev7I$Data.Graph.Inductive.Internal.Thread#Data.Graph.Inductive.Internal.Queue"Data.Graph.Inductive.Internal.HeapData.Graph.Inductive.Graph&Data.Graph.Inductive.Internal.RootPathData.Graph.Inductive.Monad"Data.Graph.Inductive.Monad.IOArray"Data.Graph.Inductive.Monad.STArrayData.Graph.Inductive.NodeMap!Data.Graph.Inductive.PatriciaTree#Data.Graph.Inductive.Query.ArtPointData.Graph.Inductive.Query.BFS Data.Graph.Inductive.Query.IndepData.Graph.Inductive.Query.MST#Data.Graph.Inductive.Query.MaxFlow2 Data.Graph.Inductive.Query.MonadData.Graph.Inductive.Query.SP$Data.Graph.Inductive.Query.TransClosData.Graph.Inductive.TreeData.Graph.Inductive.ExampleData.Graph.Inductive.BasicData.Graph.Inductive.Query.DFSData.Graph.Inductive.Query.BCC%Data.Graph.Inductive.Query.DominatorsData.Graph.Inductive.Query.GVD"Data.Graph.Inductive.Query.MaxFlowData.Graph.Inductive Paths_fglDataTreeData.Graph.Inductive.QuerySplitMCollectThreadSplit threadList' threadList threadMaybe' threadMaybesplitPar splitParMQueueMkQueuemkQueuequeuePut queuePutListqueueGet queueEmptyHeapEmptyNode prettyHeapprintPrettyHeapemptyunitinsertmergemergeAllisEmptyfindMin deleteMinsplitMinbuildtoListheapsort $fNFDataHeap$fEqHeap $fShowHeap $fReadHeapOrdGrunOrdGrDynGraph&GraphmatchmkGraphlabNodesmatchAnynoNodes nodeRangelabEdgesUDecompUContextGDecompDecompMContextContextAdjUPathLPathLPunLPathPathUEdgeLEdgeEdgeUNodeLNodeordersizeufoldgmapnmapemapnemapnodesedgestoEdgetoLEdge edgeLabelnewNodesgeleminsNodeinsEdgedelNodedelEdgedelLEdge delAllLEdgeinsNodesinsEdgesdelNodesdelEdgesbuildGrmkUGraph gfiltermap labnfilternfilter labfiltersubgraphcontextlab neighbors lneighborssucprelsuclpreoutinnoutdegindegdegnode'lab'labNode' neighbors' lneighbors'suc'pre'lsuc'lpre'out'inn'outdeg'indeg'deg'hasEdge hasNeighborhasLEdgehasNeighborAdjequalprettify prettyPrint $fOrdOrdGr $fEqOrdGr$fEqGroupEdges $fOrdLPath $fEqLPath $fShowLPath$fShowGroupEdges$fReadGroupEdges $fReadOrdGr $fShowOrdGrRTreeLRTreegetPathgetLPath getDistance getLPathNodesGraphMemptyMisEmptyMmatchMmkGraphM labNodesM matchAnyMnoNodesM nodeRangeM labEdgesMufoldMnodesMedgesM newNodesMdelNodeM delNodesM mkUGraphMcontextMlabMUSGrContext'GraphRepSGrdefaultGraphSizeemptyN removeDel $fGraphMIOSGr$fShowIO $fShowSGr $fGraphMSTSGrNodeMapMNodeMapnew fromGraphmkNodemkNode_mkEdgemkEdgesmkNodesmkNodes_ insMapNode insMapNode_ insMapEdge delMapNode delMapEdge insMapNodes insMapNodes_ insMapEdges delMapNodes delMapEdges mkMapGraphrunrun_mkNodeMmkNodesMmkEdgeMmkEdgesM insMapNodeM insMapEdgeM delMapNodeM delMapEdgeM insMapNodesM insMapEdgesM delMapNodesM delMapEdgesM$fNFDataNodeMap $fEqNodeMap $fShowNodeMap $fReadNodeMapUGrGr $fBifunctorGr $fNFDataGr $fDynGraphGr $fGraphGr$fReadGr$fShowGr$fEqGr $fGenericGrap $fEqDFSTree $fShowDFSTree $fReadDFSTree $fEqLOWTree $fShowLOWTree $fReadLOWTreebfsnWithbfsnbfsWithbfslevellevelnbfenbfebftesplbftlespindep indepSizemsTreeAtmsTreemsPathNetworkekFusedekSimpleekList $fEqDirection$fOrdDirection$fShowDirection$fReadDirectionGTMGTmapFstmapSnd><orPapplyapply' applyWith applyWith'runGTcondMGT'recMGT'condMGTrecMGTgetNode getContext getNodes'getNodessucGTsucMgraphRec graphRec' graphUFold graphNodesM0 graphNodesM graphNodes graphFilterM graphFilterdfsGTdfsMdfsM'dffMgraphDff graphDff' $fMonadGT$fApplicativeGT $fFunctorGTdijkstraspTreespLengthsptctrcrc genUNodes genLNodes labUEdgesnoEdgesabcee3loopababbcyc3dag3dag4d1d3g3g3ba'b'c'e'e3'loop'ab'abb'dag3'dag4'd1'd3'ucyclestarucycleMstarMclr479clr486clr489clr508clr528clr595gr1kin248vorclr479'clr486'clr489'clr508'clr528'kin248'vor'grevundirunlabgselefilterelfilterhasLoopisSimplegfold postorder postorderFpreorder preorderFCFunxdfsWithdfsdfsWithdfsWith'dfs'udfsudfs'rdfsrdfs'xdfWithxdffWithdffdffWithdffWith'dff'udffudffWith udffWith'udff'rdffrdffWith rdffWith'rdff' components noComponents isConnectedtopsorttopsort'scc reachable condensationbcciDomdomVoronoigvdIngvdOut voronoiSet nearestNode nearestDist nearestPath getRevEdges augmentGraph updAdjList updateFlowmfmgmf maxFlowgraphmaxFlowversioncatchIObindirlibdirdatadir libexecdir sysconfdir getBinDir getLibDir getDataDir getLibexecDir getSysconfDirgetDataFileNameghc-prim GHC.TypesTrue GroupEdgesGEs delLEdgeBy slabNodes glabEdgeseqLists.:flip2 context1l context4lmcontext context1l' context4l'findPfirst>>. labUNodesonMatch showGraphunsafeSTmapkeymap'liftN2liftN2'liftM1liftM1'matchGr fastInsNode fastInsEdgefastGMapfastNMapfastEMap fastNEMaptoAdjfromAdj toContext fromContextswapaddListsaddSuccaddPred clearSucc clearPredLOWTreeBrcDFSTreeB getBackEdgesdfsTree minbckEdgegetLowlowTree getLowTreeisaparp artpoints bfsnInternalsuci bfenInternaloutUbflbfnewEdgesprim joinPathsjoinAt EKStepFuncDirRTreeDirPathDirEdge DirectionForwardBackwardpathFromDirPath augPathFusedbftForEKbfForEKextractPathFused ekFusedStep residualGraphaugPath extractPath extractEdge extractAdj getPathDeltasintegrateDelta ekSimpleStepekWithextractPathList ekStepList nodeGetterexpand cleanSplitupdAdjcontainers-0.5.7.1 Data.Treeflatten threadGraphgfold1gfoldnfixNodes postflatten postflattenF gComponents embedContexts findGraph splitGraphsFromNodeToNodePredsIDomNode'idomWork refineIDom intersectgetDom numberTree numberForest treeEdgesfixEq maybePath