hSrSSKrSSKJrJr SSKJrJr SSKr SSK J r /SQr \ R"SSS9S 5r\ R"SSS9S 5r\ "S 5\ R"SSS9SS .S j55r\ "S 5\ R"SSS9SS .Sj55r\ "S 5\ R"SSS9SS .Sj55rSSjrSrSrSr\ "S 5\ R"SSS9SSS.Sj55rSrSrSr\ "S 5\ R"SSS9SSSS.Sj55rSrSrSr\ "S 5\ R"SSS9SSS.Sj55rg) a Functions for generating trees. The functions sampling trees at random in this module come in two variants: labeled and unlabeled. The labeled variants sample from every possible tree with the given number of nodes uniformly at random. The unlabeled variants sample from every possible *isomorphism class* of trees with the given number of nodes uniformly at random. To understand the difference, consider the following example. There are two isomorphism classes of trees with four nodes. One is that of the path graph, the other is that of the star graph. The unlabeled variant will return a line graph or a star graph with probability 1/2. The labeled variant will return the line graph with probability 3/4 and the star graph with probability 1/4, because there are more labeled variants of the line graph than of the star graph. More precisely, the line graph has an automorphism group of order 2, whereas the star graph has an automorphism group of order 6, so the line graph has three times as many labeled variants as the star graph, and thus three more chances to be drawn. Additionally, some functions in this module can sample rooted trees and forests uniformly at random. A rooted tree is a tree with a designated root node. A rooted forest is a disjoint union of rooted trees. N)Counter defaultdict)comb factorial)py_random_state) prefix_treeprefix_tree_recursiverandom_labeled_treerandom_labeled_rooted_treerandom_labeled_rooted_forestrandom_unlabeled_treerandom_unlabeled_rooted_treerandom_unlabeled_rooted_forestT)graphs returns_graphc^ ^ U U 4Sjn[R"5m SnT RUSS9 Sm T RT SS9 U"X 5nU[UR 554/nU(a~USupV[ U5upx[T 5S- n T RXS9 T RXY5 U"X5nURU [UR 5545 U(aM~T $![ a UR5 Mf=f)a Creates a directed prefix tree from a list of paths. Usually the paths are described as strings or lists of integers. A "prefix tree" represents the prefix structure of the strings. Each node represents a prefix of some string. The root represents the empty prefix with children for the single letter prefixes which in turn have children for each double letter prefix starting with the single letter corresponding to the parent node, and so on. More generally the prefixes do not need to be strings. A prefix refers to the start of a sequence. The root has children for each one element prefix and they have children for each two element prefix that starts with the one element sequence of the parent, and so on. Note that this implementation uses integer nodes with an attribute. Each node has an attribute "source" whose value is the original element of the path to which this node corresponds. For example, suppose `paths` consists of one path: "can". Then the nodes `[1, 2, 3]` which represent this path have "source" values "c", "a" and "n". All the descendants of a node have a common prefix in the sequence/path associated with that node. From the returned tree, the prefix for each node can be constructed by traversing the tree up to the root and accumulating the "source" values along the way. The root node is always `0` and has "source" attribute `None`. The root is the only node with in-degree zero. The nil node is always `-1` and has "source" attribute `"NIL"`. The nil node is the only node with out-degree zero. Parameters ---------- paths: iterable of paths An iterable of paths which are themselves sequences. Matching prefixes among these sequences are identified with nodes of the prefix tree. One leaf of the tree is associated with each path. (Identical paths are associated with the same leaf of the tree.) Returns ------- tree: DiGraph A directed graph representing an arborescence consisting of the prefix tree generated by `paths`. Nodes are directed "downward", from parent to child. A special "synthetic" root node is added to be the parent of the first node in each path. A special "synthetic" leaf node, the "nil" node `-1`, is added to be the child of all nodes representing the last element in a path. (The addition of this nil node technically makes this not an arborescence but a directed acyclic graph; removing the nil node makes it an arborescence.) Notes ----- The prefix tree is also known as a *trie*. Examples -------- Create a prefix tree from a list of strings with common prefixes:: >>> paths = ["ab", "abs", "ad"] >>> T = nx.prefix_tree(paths) >>> list(T.edges) [(0, 1), (1, 2), (1, 4), (2, -1), (2, 3), (3, -1), (4, -1)] The leaf nodes can be obtained as predecessors of the nil node:: >>> root, NIL = 0, -1 >>> list(T.predecessors(NIL)) [2, 3, 4] To recover the original paths that generated the prefix tree, traverse up the tree from the node `-1` to the node `0`:: >>> recovered = [] >>> for v in T.predecessors(NIL): ... prefix = "" ... while v != root: ... prefix = str(T.nodes[v]["source"]) + prefix ... v = next(T.predecessors(v)) # only one predecessor ... recovered.append(prefix) >>> sorted(recovered) ['ab', 'abs', 'ad'] c>[[5nUH4nU(dTRUT5 MUtpEX$RU5 M6 U$N)rlistadd_edgeappend)parentpathschildrenpathchildrestNILtrees K/var/www/html/env/lib/python3.13/site-packages/networkx/generators/trees.py get_children!prefix_tree..get_childrensKt$D fc*LE O " "4 (rNsourcer) nxDiGraphadd_nodeiteritemsnext StopIterationpoplenrr) rr!rootrstackrremaining_childrenrremaining_pathsnew_namerrs @@r rr2sx  ::>> paths = ["ab", "abs", "ad"] >>> T = nx.prefix_tree(paths) >>> list(T.edges) [(0, 1), (1, 2), (1, 4), (2, -1), (2, 3), (3, -1), (4, -1)] The leaf nodes can be obtained as predecessors of the nil node. >>> root, NIL = 0, -1 >>> list(T.predecessors(NIL)) [2, 3, 4] To recover the original paths that generated the prefix tree, traverse up the tree from the node `-1` to the node `0`:: >>> recovered = [] >>> for v in T.predecessors(NIL): ... prefix = "" ... while v != root: ... prefix = str(T.nodes[v]["source"]) + prefix ... v = next(T.predecessors(v)) # only one predecessor ... recovered.append(prefix) >>> sorted(recovered) ['ab', 'abs', 'ad'] c8>[[5nUH4nU(dURUT 5 MUtpVX5RU5 M6 UR 5H<upW[ U5S- nUR XS9 URX5 T "XxU5 M> g)a Recursively create a trie from the given list of paths. `paths` is a list of paths, each of which is itself a list of nodes, relative to the given `root` (but not including it). This list of paths will be interpreted as a tree-like structure, in which two paths that share a prefix represent two branches of the tree with the same initial segment. `root` is the parent of the node at index 0 in each path. `tree` is the "accumulator", the :class:`networkx.DiGraph` representing the branching to which the new nodes and edges will be added. r'r$N)rrrrr,r0r*) rr1rrrrrr4r5r_helpers r r8&prefix_tree_recursive.._helpers$t$D dC(LE O " "4 ('/nn&6 "E4y1}H MM(M 1 MM$ ) Ot 4 '7r#rNr$r&r)r(r)r*)rrr1rr8s @@r r r sP~"5J ::` Returns ------- :class:`networkx.Graph` A `networkx.Graph` with nodes in the set {0, …, *n* - 1}. Raises ------ NetworkXPointlessConcept If `n` is zero (because the null graph is not a tree). Examples -------- >>> G = nx.random_labeled_tree(5, seed=42) >>> nx.is_tree(G) True >>> G.edges EdgeView([(0, 1), (0, 3), (0, 2), (2, 4)]) A tree with *arbitrarily directed* edges can be created by assigning generated edges to a ``DiGraph``: >>> DG = nx.DiGraph() >>> DG.add_edges_from(G.edges) >>> nx.is_tree(DG) True >>> DG.edges OutEdgeView([(0, 1), (0, 3), (0, 2), (2, 4)]) rthe null graph is not a treer')r(NetworkXPointlessConcept empty_graphfrom_prufer_sequencerangechoice)nr:is r r r Esj^ Av))*HIIAv~~a  " "5Q<#P`. Returns ------- :class:`networkx.Graph` A `networkx.Graph` with integer nodes 0 <= node <= `n` - 1. The root of the tree is selected uniformly from the nodes. The "root" graph attribute identifies the root of the tree. Notes ----- This function returns the result of :func:`random_labeled_tree` with a randomly selected root. Raises ------ NetworkXPointlessConcept If `n` is zero (because the null graph is not a tree). r;rr'r1)r randintgraph)rDr:ts r r r {s0@ A)All1a!e,AGGFO Hr#c&^Sn[R"U5nUS:Xa0URS'U$U"X5nX@:Xa#[[ U55URS'U$UR [ U5U5n[[ U55R U5n[ X- S- 5Vs/sHoqRSUS- 5PM nn[UV s/sH oU;dM U PM sn 5m[U4SjU55n [U 5=pUH?n URX5 TU ==S-ss'X:a TU S:XaU n M3[U 5=pMA URXS5 [U5URS'U$s snfs sn f)u{Returns a labeled rooted forest with `n` nodes. The returned forest is chosen uniformly at random using a generalization of Prüfer sequences [1]_ in the form described in [2]_. Parameters ---------- n : int The number of nodes. seed : random_state See :ref:`Randomness`. Returns ------- :class:`networkx.Graph` A `networkx.Graph` with integer nodes 0 <= node <= `n` - 1. The "roots" graph attribute is a set of integers containing the roots. References ---------- .. [1] Knuth, Donald E. "Another Enumeration of Trees." Canadian Journal of Mathematics, 20 (1968): 1077-1086. https://doi.org/10.4153/CJM-1968-104-8 .. [2] Rubey, Martin. "Counting Spanning Trees". Diplomarbeit zur Erlangung des akademischen Grades Magister der Naturwissenschaften an der Formal- und Naturwissenschaftlichen Fakultät der Universität Wien. Wien, May 2000. cURSUS-US- -S- 5nSn[SU5HBnU[US- 5XU- --[US- 5[X- 5--- nX#:dM@Us $ U$)Nrr')rGrBr)rDr:rcum_sumks r _select_k/random_labeled_rooted_forest.._select_ks LLQUA.2 3q!A  !a%(1Q<7!a% 9QU#33 G{ r#rrootsr'c3>># UHnTUS:XdMUv M g7f)rN).0xdegrees r /random_labeled_rooted_forest..s3q!F1INAAqs  ) r(r@rHsetrBsample differencerGrr+r-r)rDr:rOFrNrQprENrUiteratorulastvrVs @r r r shD  qAAv!AvuQx= KKa! $E E!H   'A).quqy)9:)9AaQ )9A: -A1fa- .F3q33HH~A 1q Q 8q QAH~ %D1 JJq(5zAGGG H% ;-s2F  F(Fc[R"U5nURU5 UbX$RS'UbX4RS'U$)a Converts the (edges, n_nodes) input to a :class:`networkx.Graph`. The (edges, n_nodes) input is a list of even length, where each pair of consecutive integers represents an edge, and an integer `n_nodes`. Integers in the list are elements of `range(n_nodes)`. Parameters ---------- edges : list of ints The flattened list of edges of the graph. n_nodes : int The number of nodes of the graph. root: int (default=None) If not None, the "root" attribute of the graph will be set to this value. roots: collection of ints (default=None) If not None, he "roots" attribute of the graph will be set to this value. Returns ------- :class:`networkx.Graph` The graph with `n_nodes` nodes and edges given by `edges`. r1rQ)r(r@add_edges_fromrH)edgesn_nodesr1rQGs r _to_nxrhsH. wAU    Hr#c&[[U5US-5HlnUR[[SU5VVs/sH1n[SUS- U-S-5HnX1X$U-- -X-PM M3 snn5US- -5 Mn X$s snnf)aReturns the number of unlabeled rooted trees with `n` nodes. See also https://oeis.org/A000081. Parameters ---------- n : int The number of nodes cache_trees : list of ints The $i$-th element is the number of unlabeled rooted trees with $i$ nodes, which is used as a cache (and is extended to length $n+1$ if needed) Returns ------- int The number of unlabeled rooted trees with `n` nodes. r')rBr0rsum)rD cache_treesn_idjs r _num_rooted_treesros$S%q1u- #1c]*"1sQw1nq&89Ca%K00;>A9B* a  . >s8B c URS[X5US- -S- 5nSn[US- SS5HNn[SUS- U-S-5H2nUU[XU-- U5-[XQ5-- nX4:dM-Xe4s s $ MP g)aReturns a pair $(j,d)$ with a specific probability Given $n$, returns a pair of positive integers $(j,d)$ with the probability specified in formula (5) of Chapter 29 of [1]_. Parameters ---------- n : int The number of nodes cache_trees : list of ints Cache for :func:`_num_rooted_trees`. seed : random_state See :ref:`Randomness`. Returns ------- (int, int) A pair of positive integers $(j,d)$ satisfying formula (5) of Chapter 29 of [1]_. References ---------- .. [1] Nijenhuis, Albert, and Wilf, Herbert S. "Combinatorial algorithms: for computers and calculators." Academic Press, 1978. https://doi.org/10.1016/C2013-0-11243-3 rr'r&N)rGrorB)rDrkr:r]cumsumrmrns r _select_jd_treesrr4s8 Q)!9QUCaGHA F 1q5!R q1q5Q,*+A #AAI{;<#A34 F zv ,!r#cr^ US:Xa/SpCX44$US:XaS/SpCX44$[XU5upV[XU-- X5unm [XaU5up[U5V s/sH n SX-T -4PM n n URU 5 [U5H#n URU 4SjU55 T U - m M% UT 4$s sn f)a9Returns an unlabeled rooted tree with `n` nodes. Returns an unlabeled rooted tree with `n` nodes chosen uniformly at random using the "RANRUT" algorithm from [1]_. The tree is returned in the form: (list_of_edges, number_of_nodes) Parameters ---------- n : int The number of nodes, greater than zero. cache_trees : list ints Cache for :func:`_num_rooted_trees`. seed : random_state See :ref:`Randomness`. Returns ------- (list_of_edges, number_of_nodes) : list, int A random unlabeled rooted tree with `n` nodes as a 2-tuple ``(list_of_edges, number_of_nodes)``. The root is node 0. References ---------- .. [1] Nijenhuis, Albert, and Wilf, Herbert S. "Combinatorial algorithms: for computers and calculators." Academic Press, 1978. https://doi.org/10.1016/C2013-0-11243-3 r'r>)rr'rc3<># UHupUT-UT-4v M g7frrSrTn1n2t1_nodess r rW0_random_unlabeled_rooted_tree.. BrVR2="x-0r)rr_random_unlabeled_rooted_treerBextend)rDrkr:rerfrnrmt1t2t2_nodesrEt12_rxs @r r|r|]s< AvQw~Av 1w~ AD 1DA0UKNLB0FLB16q :AAx|h& 'C :IIcN 1X BrBBH x< ;sB4)number_of_treesr:c US:Xa[R"S5eSS/nUc[[XU5SS06$[ U5Vs/sHn[[XU5SS06PM sn$s snf)u?Returns a number of unlabeled rooted trees uniformly at random Returns one or more (depending on `number_of_trees`) unlabeled rooted trees with `n` nodes drawn uniformly at random. Parameters ---------- n : int The number of nodes number_of_trees : int or None (default) If not None, this number of trees is generated and returned. seed : integer, random_state, or None (default) Indicator of random number generation state. See :ref:`Randomness`. Returns ------- :class:`networkx.Graph` or list of :class:`networkx.Graph` A single `networkx.Graph` (or a list thereof, if `number_of_trees` is specified) with nodes in the set {0, …, *n* - 1}. The "root" graph attribute identifies the root of the tree. Notes ----- The trees are generated using the "RANRUT" algorithm from [1]_. The algorithm needs to compute some counting functions that are relatively expensive: in case several trees are needed, it is advisable to use the `number_of_trees` optional argument to reuse the counting functions. Raises ------ NetworkXPointlessConcept If `n` is zero (because the null graph is not a tree). References ---------- .. [1] Nijenhuis, Albert, and Wilf, Herbert S. "Combinatorial algorithms: for computers and calculators." Academic Press, 1978. https://doi.org/10.1016/C2013-0-11243-3 rr=r'r1)r(r?rhr|rB)rDrr:rkrEs r rrs\ Av))*HIIa&K4QTJSQRSS' 'A -adCL!L'  sA(c:[[U5US-5Hvn[X15nUR[ [SUS-5VVs/sH0n[SX5-S-5HnXRX6U-- -X%S- -PM M2 snn5U-5 Mx X $s snnf)avReturns the number of unlabeled rooted forests with `n` nodes, and with no more than `q` nodes per tree. A recursive formula for this is (2) in [1]_. This function is implemented using dynamic programming instead of recursion. Parameters ---------- n : int The number of nodes. q : int The maximum number of nodes for each tree of the forest. cache_forests : list of ints The $i$-th element is the number of unlabeled rooted forests with $i$ nodes, and with no more than `q` nodes per tree; this is used as a cache (and is extended to length `n` + 1 if needed). Returns ------- int The number of unlabeled rooted forests with `n` nodes with no more than `q` nodes per tree. References ---------- .. [1] Wilf, Herbert S. "The uniform selection of free trees." Journal of Algorithms 2.2 (1981): 204-207. https://doi.org/10.1016/0196-6774(81)90021-3 r')rBr0minrrj)rDq cache_forestsrlq_irmrns r _num_rooted_forestsrs:S'Q/#k #1cAg.."1chl3cEk22]q55II3J.   0  s 7Bc  URS[XU5U-S- 5nSn[USS5HNn[SX-S-5H6nUU[XU-- X5-[US- X5-- nXE:dM1Xv4s s $ MP g)axGiven `n` and `q`, returns a pair of positive integers $(j,d)$ such that $j\leq d$, with probability satisfying (F1) of [1]_. Parameters ---------- n : int The number of nodes. q : int The maximum number of nodes for each tree of the forest. cache_forests : list of ints Cache for :func:`_num_rooted_forests`. seed : random_state See :ref:`Randomness`. Returns ------- (int, int) A pair of positive integers $(j,d)$ References ---------- .. [1] Wilf, Herbert S. "The uniform selection of free trees." Journal of Algorithms 2.2 (1981): 204-207. https://doi.org/10.1016/0196-6774(81)90021-3 rr'r&N)rGrrB)rDrrr:r]rqrmrns r _select_jd_forestsrs4 Q+A-@1DqHIA F 1a_q!&1*%A %aa%iBC%a!eQ>? F zv &r#c^ US:Xa/S/4$[XX45upV[XU-- XX45unm n[XbU5up[U5H4n UR T 5 UR U 4SjU 55 T U - m M6 UT U4$)aReturns an unlabeled rooted forest with `n` nodes, and with no more than `q` nodes per tree, drawn uniformly at random. It is an implementation of the algorithm "Forest" of [1]_. Parameters ---------- n : int The number of nodes. q : int The maximum number of nodes per tree. cache_trees : Cache for :func:`_num_rooted_trees`. cache_forests : Cache for :func:`_num_rooted_forests`. seed : random_state See :ref:`Randomness`. Returns ------- (edges, n, r) : (list, int, list) The forest (edges, n) and a list r of root nodes. References ---------- .. [1] Wilf, Herbert S. "The uniform selection of free trees." Journal of Algorithms 2.2 (1981): 204-207. https://doi.org/10.1016/0196-6774(81)90021-3 rc3<># UHupUT-UT-4v M g7frrSrus r rW2_random_unlabeled_rooted_forest..Brzr{)r_random_unlabeled_rooted_forestr|rBrr}) rDrrkrr:rnrmr~r1rrrrxs @r rrs: AvAr{ aM 8DA6 E 1=B"1FLB 1X ( BrBBH x r#)rnumber_of_forestsr:c $UcUnUS:XaUS:wa [S5eSS/nS/nUc#[XXEU5upgn[Xg[U5S9$/n [ U5H5n [XXEU5upgnU R [Xg[U5S95 M7 U $)uReturns a forest or list of forests selected at random. Returns one or more (depending on `number_of_forests`) unlabeled rooted forests with `n` nodes, and with no more than `q` nodes per tree, drawn uniformly at random. The "roots" graph attribute identifies the roots of the forest. Parameters ---------- n : int The number of nodes q : int or None (default) The maximum number of nodes per tree. number_of_forests : int or None (default) If not None, this number of forests is generated and returned. seed : integer, random_state, or None (default) Indicator of random number generation state. See :ref:`Randomness`. Returns ------- :class:`networkx.Graph` or list of :class:`networkx.Graph` A single `networkx.Graph` (or a list thereof, if `number_of_forests` is specified) with nodes in the set {0, …, *n* - 1}. The "roots" graph attribute is a set containing the roots of the trees in the forest. Notes ----- This function implements the algorithm "Forest" of [1]_. The algorithm needs to compute some counting functions that are relatively expensive: in case several trees are needed, it is advisable to use the `number_of_forests` optional argument to reuse the counting functions. Raises ------ ValueError If `n` is non-zero but `q` is zero. References ---------- .. [1] Wilf, Herbert S. "The uniform selection of free trees." Journal of Algorithms 2.2 (1981): 204-207. https://doi.org/10.1016/0196-6774(81)90021-3 rz.q must be a positive integer if n is positive.r')rQ) ValueErrorrrhrYrBr) rDrrr:rkrgnodesrsresrEs r rrGsb y Av!q&IJJa&KCM 6 +d "ac"g.. C $ %6 +d " 6!#b'23 & Jr#c [X5[[SUS-S-5Vs/sHn[X!5[X- U5-PM sn5- nUS-S:XaU[[US-U5S-S5- nU$s snf)aReturns the number of unlabeled trees with `n` nodes. See also https://oeis.org/A000055. Parameters ---------- n : int The number of nodes. cache_trees : list of ints Cache for :func:`_num_rooted_trees`. Returns ------- int The number of unlabeled trees with `n` nodes. r'r>r)rorjrBr)rDrkrnrLs r _num_treesrs" !)C1a1fqj) ) a -0A!%0U U) - A  1uz T#AFK81` Returns ------- (edges, n) The tree as a list of edges and number of nodes. References ---------- .. [1] Wilf, Herbert S. "The uniform selection of free trees." Journal of Algorithms 2.2 (1981): 204-207. https://doi.org/10.1016/0196-6774(81)90021-3 r>r)r|rGror}r) rDcacher:rIt_nodesrrrvrws r _bicenterrs2/qAvuCJA ||A(a78A=H4Q!VUI HH2 >2r!V}bFm,2 >?HHaa[   ?sB c$US-S:XaSnO[[US-U5S-S5nURS[X5S- 5U:a [ XU5$[ US- US- S-XU5upVnUHnUR X45 M XVS-4$)aReturns a tree on `n` nodes drawn uniformly at random. It implements the Wilf's algorithm "Free" of [1]_. Parameters ---------- n : int The number of nodes, greater than zero. cache_trees : list of ints Cache for :func:`_num_rooted_trees`. cache_forests : list of ints Cache for :func:`_num_rooted_forests`. seed : random_state Indicator of random number generation state. See :ref:`Randomness` Returns ------- (edges, n) The tree as a list of edges and number of nodes. References ---------- .. [1] Wilf, Herbert S. "The uniform selection of free trees." Journal of Algorithms 2.2 (1981): 204-207. https://doi.org/10.1016/0196-6774(81)90021-3 r>r'r)rrorGrrrr) rDrkrr:r]fn_frLrEs r _random_unlabeled_treers6 1uz  "16;7!;Q ? ||Az!1A56:..3 EAEa<T A HHaX 'zr#c US:Xa[R"S5eSS/nS/nUc[[XXB56$[ U5Vs/sHn[[XXB56PM sn$s snf)uReturns a tree or list of trees chosen randomly. Returns one or more (depending on `number_of_trees`) unlabeled trees with `n` nodes drawn uniformly at random. Parameters ---------- n : int The number of nodes number_of_trees : int or None (default) If not None, this number of trees is generated and returned. seed : integer, random_state, or None (default) Indicator of random number generation state. See :ref:`Randomness`. Returns ------- :class:`networkx.Graph` or list of :class:`networkx.Graph` A single `networkx.Graph` (or a list thereof, if `number_of_trees` is specified) with nodes in the set {0, …, *n* - 1}. Raises ------ NetworkXPointlessConcept If `n` is zero (because the null graph is not a tree). Notes ----- This function generates an unlabeled tree uniformly at random using Wilf's algorithm "Free" of [1]_. The algorithm needs to compute some counting functions that are relatively expensive: in case several trees are needed, it is advisable to use the `number_of_trees` optional argument to reuse the counting functions. References ---------- .. [1] Wilf, Herbert S. "The uniform selection of free trees." Journal of Algorithms 2.2 (1981): 204-207. https://doi.org/10.1016/0196-6774(81)90021-3 rr=r')r(r?rhrrB)rDrr:rkrrEs r r r sX Av))*HIIa&KCM-amRSS?+ + *1=O P+   sA%)NN) __doc__warnings collectionsrrmathrrnetworkxr(networkx.utilsr__all__ _dispatchablerr r r r rhrorrr|rrrrrrrrr rSr#r rs<, * T2A3AHT2J3JZT2#'1R31RhT2*.  3  FT2,0L 3L d @@&R.bT27;$434n*Z$N)XT2+/4dC3CL 8 !F'TT20445 35 r#