ޠj* SSKJr SSKrSSKrSSKrSSKrSSKJr SSKJ r J r J r J r SSK JrJr SSKJr SSKJr SSKJrJrJrJr SS KJr SS KJr SS KJrJrJrJrJrJ r J!r!J"r"J#r#J$r$ SS K%J&r&J'r' SS K(J)r) SSK*J+r+ SSK,J-r- SSK.J/r/J0r0 SSK1J2r2J3r3J4r4J5r5J6r6 SSK7J8r8 SSK9J:r:J;r;JJ?r?J@r@JArA SSKBJCrC SSKDJErE SSKFJGrG SSKHJIrIJJrJJKrK SSKLJMrM SSKNJOrO SSKPJQrQ SSKRJSrS SSKTJUrUJVrV SSKWJXrXJYrY SSKZJ[r[J\r\J]r] SS K^J_r_J`r`JaraJbrb SS!KcJdrd SS"KeJfrfJgrg SS#KhJiriJjrj SS$KkJlrl SS%KmJnrnJoro SS&KpJqrqJrrrJsrs SS'KtJuruJvrvJwrwJxrxJyryJzrzJ{r{J|r|J}r} SS(K~JrJrJrJrJr SS)KJrJr S*r\GR"\5rS+rS,r\"S-S.9"S/S055rSFS1jrSGS2jr"S3S4\\\\\45r"S5S6\l\\\\4\\\\\45rSHS7jr\"S85rSIS9jrSJS:jrSKS;jrSLS<jrSMS=jr\$SNS>j5r\$S-S?.SOS@jj5rS-S?.SPSAjjrSQSBjrSRSCjrSSSDjrSTSEjrg)U) annotationsN) defaultdict) AwaitableCallableHashableSequence) dataclass is_dataclass) timedelta)partial)isclass isfunctionismethod signature) FunctionType)NoneType) AnyGenericLiteralTypeVarUnioncastget_args get_originget_type_hintsoverload)RunnableRunnableConfig) BaseCache) Checkpoint) BaseStore) BaseModel TypeAdapter) NotRequiredRequiredSelfUnpack is_typeddict)_serde) INTERRUPTNS_ENDNS_SEPTASKS)get_cached_annotated_keysget_field_defaultget_update_as_tuples) create_model)coerce_to_runnable)coerce_timeout_policy) EMPTY_SEQMISSINGDeprecatedKwargs) BaseChannel)BinaryOperatorAggregate) DeltaChannel)EphemeralValue) LastValueLastValueAfterFinish)NamedBarrierValueNamedBarrierValueAfterFinish)ENDSTART TAG_HIDDEN) ErrorCodeInvalidUpdateError ParentCommandcreate_error_message) BranchSpec) StateNode StateNodeSpec)ManagedValueSpecis_managed_value)Pregel) ChannelRead PregelNode) ChannelWriteChannelWriteEntryChannelWriteTupleEntry) All CachePolicy CheckpointerCommand RetryPolicySend TimeoutPolicy TracePolicyensure_valid_checkpointer)ContextTInputT NodeInputTOutputTStateT)LangGraphDeprecatedSinceV05LangGraphDeprecatedSinceV10) StateGraphCompiledStateGraphz branch:to:{}__default_error_handler__T)slotscR\rSrSr%SrSrS\S'SrS\S'SrS\S 'Sr S \S 'S r g) _NodeDefaultsfz??@s #"Ac \rSrSr%SrS\S'S\S'S\S'S \S 'S \S 'S \S'S\S'S\S'S\S'S\S'S\S'S\S'S4SSS.S5SjjjrSSSSS.S6Sjjr\S7S j5r S8S9S!jjr \ S"SSSSSSSSS#. S:S$jj5r \ S"SSSSSSSS%.S;S&jj5r \ S"SSSSSSSSS#. SS)jjjr S?S*jr S4S@S+jjrSAS,jrSBS-jrS4SCS.jjrSBS/jrS4SDS0jjrS4SSSSS"SSS1.SES2jjjrS3rg)FraaA graph whose nodes communicate by reading and writing to a shared state. The signature of each node is `State -> Partial`. Each state key can optionally be annotated with a reducer function that will be used to aggregate the values of that key received from multiple nodes. The signature of a reducer function is `(Value, Value) -> Value`. !!! warning `StateGraph` is a builder class and cannot be used directly for execution. You must first call `.compile()` to create an executable graph that supports methods like `invoke()`, `stream()`, `astream()`, and `ainvoke()`. See the `CompiledStateGraph` documentation for more details. Args: state_schema: The schema class that defines the state. context_schema: The schema class that defines the runtime context. Use this to expose immutable context data to your nodes, like `user_id`, `db_conn`, etc. input_schema: The schema class that defines the input to the graph. output_schema: The schema class that defines the output from the graph. !!! warning "`config_schema` Deprecated" The `config_schema` parameter is deprecated in v0.6.0 and support will be removed in v2.0.0. Please use `context_schema` instead to specify the schema for run-scoped context. Example: ```python from langchain_core.runnables import RunnableConfig from typing_extensions import Annotated, TypedDict from langgraph.checkpoint.memory import InMemorySaver from langgraph.graph import StateGraph from langgraph.runtime import Runtime def reducer(a: list, b: int | None) -> list: if b is not None: return a + [b] return a class State(TypedDict): x: Annotated[list, reducer] class Context(TypedDict): r: float graph = StateGraph(state_schema=State, context_schema=Context) def node(state: State, runtime: Runtime[Context]) -> dict: r = runtime.context.get("r", 1.0) x = state["x"][-1] next_value = x * r * (1 - x) return {"x": next_value} graph.add_node("A", node) graph.set_entry_point("A") graph.set_finish_point("A") compiled = graph.compile() step1 = compiled.invoke({"x": 0.5}, context={"r": 3.0}) # {'x': [0.5, 0.75]} ``` set[tuple[str, str]]edgesz'dict[str, StateNodeSpec[Any, ContextT]]nodesz'defaultdict[str, dict[str, BranchSpec]]brancheszdict[str, BaseChannel]channelszdict[str, ManagedValueSpec]managedz:dict[type[Any], dict[str, BaseChannel | ManagedValueSpec]]schemasz set[tuple[tuple[str, ...], str]] waiting_edgesboolcompiled type[StateT] state_schematype[ContextT] | Nonecontext_schemaz type[InputT] input_schemaz type[OutputT] output_schemaN)rrc URS[5=n[La4[R"S[SS9 Uc[ [ [U5nURS[5=n[La4[R"S[SS9 Uc[ [ [U5nURS[5=n[La4[R"S[SS9 Uc[ [ [U5n0Ul [5Ul [[5Ul0Ul0Ul0UlS Ul[5UlXl[ [ [U=(d U5Ul[ [ [U=(d U5UlX l[55UlUR9UR,5 UR9UR.S S 9 UR9UR0S S 9 g) N config_schemazW`config_schema` is deprecated and will be removed. Please use `context_schema` instead.)category stacklevelinputM`input` is deprecated and will be removed. Please use `input_schema` instead.outputzO`output` is deprecated and will be removed. Please use `output_schema` instead.F allow_managed)getr5r|r}r`rrzrZr_r[r]rsetrrdictrrrrrrrrrrrf_node_defaults _add_schema) selfrrrrkwargsrinput_rs rw__init__StateGraph.__init__s$ZZA AM' Q MMi4  %!%d8nm!Djj'2 2F7 B MM_4  ##DL&9 jj73 3FG C MMa4  $ $T']F ;  U #D)      U( f|/K|L!$w-1N,O,-:_ **+ **%@ ++5Arv)rirkrlrmczURnUbXlUbX%lUbX5lUb[ U5UlU$)a Set default node policies that apply to every node in this graph. Per-node values passed to `add_node` always take precedence over these defaults. Defaults are applied at `compile()` time. Policies set here are **not** inherited by subgraphs. `retry_policy` and `timeout` defaults apply to **all** nodes, including error-handler nodes. `cache_policy` and `error_handler` defaults only apply to regular nodes -- caching error-handler results is unsafe, and handlers must never catch themselves. Args: retry_policy: Default retry policy for nodes that don't specify their own via `add_node(..., retry_policy=...)`. Also applies to error-handler nodes. cache_policy: Default cache policy for nodes that don't specify their own via `add_node(..., cache_policy=...)`. Does **not** apply to error-handler nodes. error_handler: Default error handler invoked when any regular node raises and does not have its own `error_handler` set via `add_node`. The handler is **not** invoked when an error-handler node itself raises -- handler failures fail the run. timeout: Default timeout policy for nodes that don't specify their own via `add_node(..., timeout=...)`. Also applies to error-handler nodes. Accepts a `TimeoutPolicy`, a number of seconds (`float`), or a `timedelta`. Returns: Self: The builder instance, for chaining. Example: ```python graph = ( StateGraph(State) .set_node_defaults( retry_policy=RetryPolicy(max_attempts=3), error_handler=my_fallback_handler, ) .add_node("a", node_a) .add_node("b", node_b, retry_policy=custom_retry) # overrides default .add_edge(START, "a") .compile() ) ``` )rrirkrlr3rm)rrirkrlrmdefaultss rwset_node_defaultsStateGraph.set_node_defaultssLl&&  #$0 !  #$0 !  $%2 "  4W=H  rvc URURVVVs1sHupUHo3U4iM M snnn-$s snnnfN)rr)rstartsendstarts rw _all_edgesStateGraph._all_edgesQsBzz,0,>,> ,>[VF5CLFL,>    s: cXR;Ga6[U5 [U5up4nU(a7U(d0SRU5n[ USS5n[ SUSUS35e0UEUEURU'UR 5H]upXR;a;URUU :wa&[U [5(aM>[ SUS35eMOXRU'M_ UR 5HFupXR;a$URUU:wa[ S US35eM8X@RU'MH gg) Nz, roz%Invalid managed channels detected in z: z<. Managed channels are not permitted in Input/Output schema.z Channel 'z&' already exists with a different typezManaged value ') rr _get_channelsjoinr ValueErroritemsrryr;r) rr~rrr type_hintsnames schema_namekeychannels rwrStateGraph._add_schemaWsQ  % &v .,9&,A )Hz} '*%fj"=  ;K=5'RRR$;h#:'#:DLL ( 0 --'}}S)W4%gy99 ","+C50V W# 5*1MM#&!1!(  ,,&||C(G3(-cU2XY4 )0LL%!0- &rvF) defermetadatarrirkrl destinationsrm trace_policyc  g)aAdd a new node to the `StateGraph`, input schema is inferred as the state schema. Will take the name of the function/runnable as the node name. Args: node: The function or runnable this node will run. defer: Whether to defer the execution of the node until the run is about to end. metadata: The metadata associated with the node. input_schema: The input schema for the node. (Default: the graph's state schema) retry_policy: The retry policy for the node. If a sequence is provided, the first matching policy will be applied. cache_policy: The cache policy for the node. destinations: Destinations that indicate where a node can route to. Useful for edgeless graphs with nodes that return `Command` objects. If a `dict` is provided, the keys will be used as the target node names and the values will be used as the labels for the edges. If a `tuple` is provided, the values will be used as the target node names. !!! warning This is only used for graph rendering and doesn't have any effect on the graph execution. Example: ```python from typing_extensions import TypedDict from langchain_core.runnables import RunnableConfig from langgraph.graph import START, StateGraph class State(TypedDict): x: int def my_node(state: State, config: RunnableConfig) -> State: return {"x": state["x"] + 1} builder = StateGraph(State) builder.add_node(my_node) # node name will be 'my_node' builder.add_edge(START, "my_node") graph = builder.compile() graph.invoke({"x": 1}) # {'x': 2} ``` Returns: Self: The instance of the `StateGraph`, allowing for method chaining. Nrn rrrrrrirkrlrrmrrs rwadd_nodeStateGraph.add_nodewH rv)rrrirkrlrrmrc  g)aAdd a new node to the `StateGraph` where input schema is specified. Will take the name of the function/runnable as the node name. Args: node: The function or runnable this node will run. defer: Whether to defer the execution of the node until the run is about to end. metadata: The metadata associated with the node. input_schema: The input schema for the node. retry_policy: The retry policy for the node. If a sequence is provided, the first matching policy will be applied. cache_policy: The cache policy for the node. destinations: Destinations that indicate where a node can route to. Useful for edgeless graphs with nodes that return `Command` objects. If a `dict` is provided, the keys will be used as the target node names and the values will be used as the labels for the edges. If a `tuple` is provided, the values will be used as the target node names. !!! warning This is only used for graph rendering and doesn't have any effect on the graph execution. Example: ```python from typing_extensions import TypedDict from langchain_core.runnables import RunnableConfig from langgraph.graph import START, StateGraph class State(TypedDict): x: int class NodeInput(TypedDict): x: int def my_node(state: NodeInput, config: RunnableConfig) -> State: return {"x": state["x"] + 1} builder = StateGraph(State) builder.add_node(my_node, input_schema=NodeInput) # node name will be 'my_node' builder.add_edge(START, "my_node") graph = builder.compile() graph.invoke({"x": 1}) # {'x': 2} ``` Returns: Self: The instance of the `StateGraph`, allowing for method chaining. Nrnrs rwrrsP rvc  g)aAdd a new node to the `StateGraph`, input schema is inferred as the state schema. Args: node: The name of the node. action: The function or runnable this node will run. defer: Whether to defer the execution of the node until the run is about to end. metadata: The metadata associated with the node. input_schema: The input schema for the node. (Default: the graph's state schema) retry_policy: The retry policy for the node. If a sequence is provided, the first matching policy will be applied. cache_policy: The cache policy for the node. destinations: Destinations that indicate where a node can route to. Useful for edgeless graphs with nodes that return `Command` objects. If a `dict` is provided, the keys will be used as the target node names and the values will be used as the labels for the edges. If a `tuple` is provided, the values will be used as the target node names. !!! warning This is only used for graph rendering and doesn't have any effect on the graph execution. Example: ```python from typing_extensions import TypedDict from langchain_core.runnables import RunnableConfig from langgraph.graph import START, StateGraph class State(TypedDict): x: int def my_node(state: State, config: RunnableConfig) -> State: return {"x": state["x"] + 1} builder = StateGraph(State) builder.add_node("my_fair_node", my_node) builder.add_edge(START, "my_fair_node") graph = builder.compile() graph.invoke({"x": 1}) # {'x': 2} ``` Returns: Self: The instance of the `StateGraph`, allowing for method chaining. Nrn rractionrrrrirkrlrrmrrs rwrrrrvc  g)aAdd a new node to the `StateGraph`, input schema is specified. Args: node: The function or runnable this node will run. If a string is provided, it will be used as the node name, and action will be used as the function or runnable. action: The action associated with the node. Will be used as the node function or runnable if `node` is a string (node name). defer: Whether to defer the execution of the node until the run is about to end. metadata: The metadata associated with the node. input_schema: The input schema for the node. retry_policy: The retry policy for the node. If a sequence is provided, the first matching policy will be applied. cache_policy: The cache policy for the node. destinations: Destinations that indicate where a node can route to. Useful for edgeless graphs with nodes that return `Command` objects. If a `dict` is provided, the keys will be used as the target node names and the values will be used as the labels for the edges. If a `tuple` is provided, the values will be used as the target node names. !!! warning This is only used for graph rendering and doesn't have any effect on the graph execution. Example: ```python from typing_extensions import TypedDict from langchain_core.runnables import RunnableConfig from langgraph.graph import START, StateGraph class State(TypedDict): x: int class NodeInput(TypedDict): x: int def my_node(state: NodeInput, config: RunnableConfig) -> State: return {"x": state["x"] + 1} builder = StateGraph(State) builder.add_node("my_fair_node", my_node, input_schema=NodeInput) builder.add_edge(START, "my_fair_node") graph = builder.compile() graph.invoke({"x": 1}) # {'x': 2} ``` Returns: Self: The instance of the `StateGraph`, allowing for method chaining. Nrnrs rwrrMsX rvc  U RS[5=n [La[R"S[S9 UcU nU RS[5=n[La6[R"S[S9 Uc[ [ [S-U5n[U 5n [U[5(dWUn[U[5(aUR5nO![USURR5nUc [!S5eUR"(a[$R'S 5 [U[5(d6Un[ [[US [USS555nUc [!S5eUc[(eXR*;a[!S US 35eU[,:Xd U[.:Xa[!S US 35e[0[24HnX;dM [!SUS35e Sn[4n[7U5(d,[9U5(d[9[USS55(Ga`[;[US55=(d [;U5=n(Ga1Uc[=[?[@RB"[ [DU55RFRI555nURU5=n(a'[U[ 5(a[;U5(aUnURS5=n(a[KU5nU[LLa.[OU5nUHn[KU5nU[PLdMUnUn O U[PLa>[OU5=n(a,[KUS5[RLa[OUS5=n(aUnU bU nU=(d U=(d URZnSnUbVSU3nUUR*;a[!SUS35e[\[^[`4"[cUUSS9SUSSSS9UR*U'Ub6[\[[`4"[cX!SS9UUUUUUUU U S9 UR*U'OjUb([][cX!SS9UUUUUUUU U S9 UR*U'O?[\[d[`4"[cX!SS9UURZUUUUUU U S9 UR*U'U=(d UnUbURgU5 U$![T[V[X4a GNZf=f)a Add a new node to the `StateGraph`. Args: node: The function or runnable this node will run. If a string is provided, it will be used as the node name, and action will be used as the function or runnable. action: The action associated with the node. Will be used as the node function or runnable if `node` is a string (node name). defer: Whether to defer the execution of the node until the run is about to end. metadata: The metadata associated with the node. input_schema: The input schema for the node. (Default: the graph's state schema) retry_policy: The retry policy for the node. If a sequence is provided, the first matching policy will be applied. cache_policy: The cache policy for the node. error_handler: Optional node-level error handler callable for this node. trace_policy: Optional policy controlling how this node's run is traced. Its `process_inputs` callable transforms the node's input before it is recorded (e.g. to omit or summarize large message history) without changing the value passed to the node. Does not affect execution. destinations: Destinations that indicate where a node can route to. Useful for edgeless graphs with nodes that return `Command` objects. If a `dict` is provided, the keys will be used as the target node names and the values will be used as the labels for the edges. If a `tuple` is provided, the values will be used as the target node names. !!! warning This is only used for graph rendering and doesn't have any effect on the graph execution. timeout: Timeout for each node attempt. A number or `timedelta` is a hard wall-clock cap and is not refreshed. Use `TimeoutPolicy` to configure both a wall-clock `run_timeout` and an `idle_timeout` refreshed by progress signals. When exceeded, a [`NodeTimeoutError`][langgraph.errors.NodeTimeoutError] is raised and the retry policy (if any) decides whether to retry. Timeouts are supported only for async nodes; sync nodes cannot be safely cancelled in-process. Example: ```python from typing_extensions import TypedDict from langchain_core.runnables import RunnableConfig from langgraph.graph import START, StateGraph class State(TypedDict): x: int def my_node(state: State, config: RunnableConfig) -> State: return {"x": state["x"] + 1} builder = StateGraph(State) builder.add_node(my_node) # node name will be 'my_node' builder.add_edge(START, "my_node") graph = builder.compile() graph.invoke({"x": 1}) # {'x': 2} ``` Example: Customize the name: ```python builder = StateGraph(State) builder.add_node("my_fair_node", my_node) builder.add_edge(START, "my_fair_node") graph = builder.compile() graph.invoke({"x": 1}) # {'x': 2} ``` Returns: Self: The instance of the `StateGraph`, allowing for method chaining. retryzM`retry` is deprecated and will be removed. Please use `retry_policy` instead.)rNrrroz6Node name must be provided if action is not a functionzjAdding a node to a graph that has already been compiled. This will not be reflected in the compiled graph.namezNode `z` already present.z` is reserved.'z?' is a reserved character and is not allowed in the node names.__call__returnr__error_handler__z#Auto-generated error handler node `` already exists.FrtraceTrrrirkis_error_handler)rrirkerror_handler_nodeendsrrmr)4rr5r|r}r_rrzr\r3rystrrget_namerrrorrloggerwarning RuntimeErrorrr?r@r,r+r4rrrnextiterinspectrr parameterskeysrrrrTr NameErrorr StopIterationrrHrrZr2r^r)rrrrrrrirkrlrrmrrrr characterinferred_input_schemarhintsfirst_parameter_name input_hintrtn rtn_originrtn_argsarg arg_originrargsvalsresolved_input_schemahandler_node_names rwrrs|ZZ1 1E' A MM_4 #$ jj'2 2F7 B MM_4 ##D$4t$;VD '0$$$F&(++(vz63C3C3L3LM| L == NN: $$$FWVVWVZQU5VWXD| L >  :: vdV+=>? ? 3;$%-vdV>:; ; &)I   {"ab* !%1:* 6""F##GFJ=>>' (CD*!&)** '+/#-- $\6 :(j,(&+YY/C%DDzD%j$77N:1))H--3-!+CJ!U*#+C=#+C)3CJ)W4&)-7 % $,#g-&.sm3U3&uQx0G;%-eAh%77T7#  #D  F1 FT5F5F )-  $"3D6 :  DJJ. 9:K9LL]^-:#x-,H"=7HPUV2!!!% -DJJ( )  #,Z-AB"6EB)))#4) DJJt # .,"6EB2))#4) DJJt  -VX-=>"6EB!..))#4) DJJt $<'<  #   \ * K9m4   s5E SASS,+S,cUR(a[RS5 [U[5(aU[ :Xa [ S5eU[:Xa [ S5e[US5(d/U[SUR55;a[ SUS35eURRX45 U$UH6nU[ :Xa [ S5eX0R;dM)[ SUS 35e U[:Xa [ S5eU[ :waX R;a[ SUS 35eURR[U5U45 U$) aAdd a directed edge from the start node (or list of start nodes) to the end node. When a single start node is provided, the graph will wait for that node to complete before executing the end node. When multiple start nodes are provided, the graph will wait for ALL of the start nodes to complete before executing the end node. Args: start_key: The key(s) of the start node(s) of the edge. end_key: The key of the end node of the edge. Raises: ValueError: If the start key is `'END'` or if the start key or end key is not present in the graph. Returns: Self: The instance of the `StateGraph`, allowing for method chaining. kAdding an edge to a graph that has already been compiled. This will not be reflected in the compiled graph.zEND cannot be a start nodezSTART cannot be an end noderc3(# UH upUv M g7frrn).0r_s rw &StateGraph.add_edge..sB&0(%jszAlready found path for node 'zB'. For multiple edges, use StateGraph with an Annotated state key.zNeed to add_node `z` first)rrrryrr?rr@hasattrrraddrrtuple)r start_keyend_keyrs rwadd_edgeStateGraph.add_edgesY" == NN:  i % %C !=>>% !>??4,,cB&*jjB?2!3I;?VV JJNNI/ 0KE| !=>>JJ& #5eWG!DEE  e :; ; c>gZZ71''BC C i 0':; rvcUR(a[RS5 [USSS9nUR=(d SnX@R U;a[ SURSUS35e[R"X#S5UR UU'UR UUR=n(aURU5 U$) a$Add a conditional edge from the starting node to any number of destination nodes. Args: source: The starting node. This conditional edge will run when exiting this node. path: The callable that determines the next node or nodes. If not specifying `path_map` it should return one or more nodes. If it returns `'END'`, the graph will stop execution. path_map: Optional mapping of paths to node names. If omitted the paths returned by `path` should be node names. Returns: Self: The instance of the graph, allowing for method chaining. !!! warning Without type hints on the `path` function's return value (e.g., `-> Literal["foo", "__end__"]:`) or a path_map, the graph visualization assumes the edge could transition to any node in the graph. rNTr conditionzBranch with name `z` already exists for node ``) rrrr2rrrrF from_pathrr)rsourcepathpath_maprr~s rwadd_conditional_edges StateGraph.add_conditional_edgess< == NN:  "$T>yy'K ==( ($TYYK/J6(RST '1&:&:44&P fd#]]6*40== =6 =   V $ rvcB[U5S:a [S5eSnUH|n[U[5(a[U5S:XaUupCO [ U5nX@R ;a[SUS35eUR XC5 UbURX$5 UnM~ U$)a3Add a sequence of nodes that will be executed in the provided order. Args: nodes: A sequence of `StateNode` (callables that accept a `state` arg) or `(name, StateNode)` tuples. If no names are provided, the name will be inferred from the node object (e.g. a `Runnable` or a `Callable` name). Each node will be executed in the order provided. Raises: ValueError: If the sequence is empty. ValueError: If the sequence contains duplicate node names. Returns: Self: The instance of the `StateGraph`, allowing for method chaining. z$Sequence requires at least one node.Nrz/Node names must be unique: node with the name 'z' already exists. If you need to use two different runnables/callables with the same name (for example, using `lambda`), please provide them as tuples (name, runnable/callable).)lenrryrrrrr)rr previous_namerrs rw add_sequenceStateGraph.add_sequences. u:>CD D$( D$&&3t9>! d%d+zz! EdVLvv MM$ %( m2 M!$ rvc.UR[U5$)zSpecifies the first node to be called in the graph. Equivalent to calling `add_edge(START, key)`. Parameters: key (str): The key of the node to set as the entry point. Returns: Self: The instance of the graph, allowing for method chaining. )rr@rrs rwset_entry_pointStateGraph.set_entry_point7s}}UC((rvc.UR[X5$)aSets a conditional entry point in the graph. Args: path: The callable that determines the next node or nodes. If not specifying `path_map` it should return one or more nodes. If it returns END, the graph will stop execution. path_map: Optional mapping of paths to node names. If omitted the paths returned by `path` should be node names. Returns: Self: The instance of the graph, allowing for method chaining. )rr@)rr rs rwset_conditional_entry_point&StateGraph.set_conditional_entry_pointDs,))%@@rvc.URU[5$)aMarks a node as a finish point of the graph. If the graph reaches this node, it will cease execution. Parameters: key (str): The key of the node to set as the finish point. Returns: Self: The instance of the graph, allowing for method chaining. )rr?rs rwset_finish_pointStateGraph.set_finish_point\s}}S#&&rvc hURVVs1sHup#UiM nnnURR5HupVURU5 M URR5H)upxUR (dMURU5 M+ UH-n XR;dMU [ :wdM [SU S35e [ U;a [S5eURVV s1sHup:U iM n nn URR5HupVUR5HupU R bbU R R5HBn XR;aU [:wa[SUSU SU S35eU RU 5 MD MtU R[5 URHnX:wdM U RU5 M M M URR5H3upxUR (dMU RUR 5 M5 U H-nXR;dMU[:wdM [SUS35e U(a'UH!nXR;dM[S US 35e S Ul U$s snnfs sn nf) Nz%Found edge starting at unknown node 'rzOGraph must have an entrypoint: add at least one edge from START to another nodezAt 'z ' node, 'z' branch found unknown target 'z#Found edge ending at unknown node `r zInterrupt node `z ` not foundT) rrrrrrr@rvaluesr?updater)r interruptsrcr all_sourcesrrrspecr r all_targetscondbranchrtargets rwvalidateStateGraph.validateisF)-9vss 9#}}224OE OOE " 5****,JDyyy%-"FZZ'FeO #HPQ!RSS"  #a  *.9vqs 9#}}224OE ( 0 ;;*%{{113jj0SCZ","&ugYtf<[\_[``a b#$, 4 OOC( $ ='OOD1!+!1 5****,JDyyy""499--"FZZ'FcM #Fvha!PQQ" !zz)$'7v[%IJJ"  Y:":s J(2 J.)cachestoreinterrupt_beforeinterrupt_afterdebugr transformersc  [U5nSn [R(GaURURUR /n UR bU RUR 5 URR5Hn U RU R5 M URR5HDn U R5H-n U RcMU RU R5 M/ MF [R"U URS9n [R"X5nU=(d /nU=(d /nURUS:wa US:waUO/U-O/S9 [UR UR 5S:XaSUR UR ;aSOLUR UR R#5VVs/sHup[%U5(aMUPM snnn[UR5S:XaSUR;aSO?URR#5VVs/sHup[%U5(aMUPM snnnUR&nSnUR(bs[*UR;a[-S[*S35e[*n[.[0[24"[5UR(US S 9SURSSS S 9URU'URR5HnUR6(dUbUR8cUUlUR:bUR:cUR:UlUR6(d+UR<bUR<cUR<UlUR>cMUR>bMUR>UlM URR#5VVs0sH5unnUR6(aMUR8cM(UUR8_M7 nnn[@[B[2[D[F4"S"0S U_S0_SUR _S0_S0UREURHE[J[MUR50E_S[J_SS_SU_SU_SU_SU_SU_SS _SU_SU_SU_SU_SU=(d S _S!U_6nU Ul'URQ[JS5 URR#5HupURQX5 M [S[UU[V5(a [WU5OU/UR 5Ul,[S[UU[V5(a [WU5OU/UR5Ul-UR\HunnUR_UU5 M UR`HunnUR_UU5 M URR#5H1unn U R#5Hup}URcUX}5 M M3 UR5$s snnfs snnfs snnf)#aHCompiles the `StateGraph` into a `CompiledStateGraph` object. The compiled graph implements the `Runnable` interface and can be invoked, streamed, batched, and run asynchronously. Args: checkpointer: A checkpoint saver object or flag. If provided, this `Checkpointer` serves as a fully versioned "short-term memory" for the graph, allowing it to be paused, resumed, and replayed from any point. If `None`, it may inherit the parent graph's checkpointer when used as a subgraph. If `False`, it will not use or inherit any checkpointer. **Important**: When a checkpointer is enabled, you should pass a `thread_id` in the config when invoking the graph: ```python config = {"configurable": {"thread_id": "my-thread"}} graph.invoke(inputs, config) ``` The `thread_id` is the key used to store and retrieve checkpoints. Use a unique ID for independent runs, or reuse the same ID to accumulate state across invocations (e.g., for conversation memory). interrupt_before: An optional list of node names to interrupt before. interrupt_after: An optional list of node names to interrupt after. debug: A flag indicating whether to enable debug mode. name: The name to use for the compiled graph. transformers: Optional sequence of `StreamTransformer` classes or configured factories. Classes and factories are instantiated per run whenever `stream_events(version="v3")` / `astream_events(version="v3")` is called and are propagated to subgraph scopes. Custom factories should follow the standard `StreamTransformer` constructor shape by accepting `scope` as their first argument. Appended after the built-in stream transformers. Returns: CompiledStateGraph: The compiled `StateGraph`. N)rr*)r$r__root__z+Auto-generated default error handler node `rFrTrbuilderschema_to_mapperrrrinput_channels stream_modeupdatesoutput_channelsstream_channels checkpointerinterrupt_before_nodesinterrupt_after_nodes auto_validater2r/r.node_error_handler_mapr LangGraphstream_transformersrn)2rYr)STRICT_MSGPACK_ENABLEDrrrrappendrr"rbuild_serde_allowlistrapply_checkpointer_allowlistr,rrrrJrrl_DEFAULT_ERROR_HANDLER_NODErrHrrZr2rrrirkrmrbr^r[r]rr@r:_serde_allowlist attach_node _pick_mapperrylist_output_mapper _state_mapperr attach_edger attach_branch)rr>r.r/r0r1r2rr3serde_allowlist schema_typesrrr*rvalr<r=rdefault_handler_namer' node_namerBrrrrs rwcompileStateGraph.compilesAl1> 7;  ( ( (!!!!""-L "".##D$7$78 ))+##D$5$56, MM002&oo/F**6$++F,?,?@03%::$O">>L ,1r)/R #c)&6%<!"W  4<< 2 2349dll4+=+=>>  !% T-?-? @ F F H HHC', H 4==!Q&:+F %)MM$7$7$9$9AQRUAV$9 &&+/  ! ! -*djj8 344EG$? /'$$0T5F5F5N$,$9$9! ))))5%%-$,$9$9!+ 0D'// 3(:$(::#3#3#5" #5 4(( /-1-D-D /It.. .#5 " &fh&GH    ..   --,,~d&7&78  ! " , , & $4 #2! " # $% &' () *$:+ ,$- .!-/ 2%4!UD)))+IC   +,#//400  !!"    #  "./400  !!"    " **JE3   ,% --KFC   -. $}}224OE8 ( 0 &&ud;!1 5  ""r" s*)YYY!-Y!Y' Y'+Y') rrrrrrrrrrrrrr) rrrrrztype[InputT] | Nonerztype[OutputT] | NonerUnpack[DeprecatedKwargs]rNone) rirhrkrjrlStateNode[Any, ContextT] | Nonerm(float | timedelta | TimeoutPolicy | Nonerr&)rr)T)rrr~ type[Any]rrZ)rStateNode[NodeInputT, ContextT]rrrdict[str, Any] | NonerrZrirhrkrjrlr[r'dict[str, str] | tuple[str, ...] | Nonermr\rTracePolicy | NonerrYrr&)rr^rrrr_rtype[NodeInputT]rirhrkrjrlr[rr`rmr\rrarrYrr&)rrrr^rrrr_rrZrirhrkrjrlr[rr`rmr\rrarrYrr&)r%str | StateNode[NodeInputT, ContextT]r&StateNode[NodeInputT, ContextT] | Nonerrrr_rrbrirhrkrjrlr[rr`rmr\rrarrYrr&)rrcrrdrrrr_rztype[NodeInputT] | Nonerirhrkrjrlr[rr`rmr\rrarrYrr&)rzstr | list[str]rrrr&)r rr Callable[..., Hashable | Sequence[Hashable]] | Callable[..., Awaitable[Hashable | Sequence[Hashable]]] | Runnable[Any, Hashable | Sequence[Hashable]]r&dict[Hashable, str] | list[str] | Nonerr&)rzWSequence[StateNode[NodeInputT, ContextT] | tuple[str, StateNode[NodeInputT, ContextT]]]rr&)rrrr&)r rerrfrr&)r$zSequence[str] | Nonerr&)r>rSr.zBaseCache | Noner/zBaseStore | Noner0All | list[str] | Noner1rgr2rrz str | Noner3z1Sequence[Callable[[tuple[str, ...]], Any]] | Nonerz5CompiledStateGraph[StateT, ContextT, InputT, OutputT])rorprqrrrsrtrrpropertyrrrrrrrrrrr,rWrurnrvrwrarasDL  2255$$ (( GG33N))  156B -1.2 6B"6B.6B * 6B , 6B+6B 6BvDH+/9=<@ ?A?) ? 7 ? : ? ?B  0@ *.!CG+/9=@D<@+/C -C  C ( C  C AC )C 7C >C :C )C +C  C C J *.CG+/9=@D<@+/G -G  G ( G ' G AG )G 7G >G :G )G +G  G G R *.!CG+/9=@D<@+/C C 0C  C ( C C AC )C 7C >C :C )C +C  C C J:>K *.CG+/9=@D<@+/K 3K 7K  K ( K 'K AK )K 7K >K :K )K +K  K K `:>C *.04CG+/9=@D<@+/C3C7C  C ( C.CAC)C7C>C:C)C+C CJ4x<@ 0070 9 0 0d- -  -^ )$<@ A7A 9 A  A0 '.d&*`##'"&3726JN`#"`# `#  `# 1 `#0`#`#`#H`# ?`#`#rvrac^\rSrSr%S\S'S\S'S\S'S\S'SU4S jjrSSS jjrSSS jjrSS jrSS jr SS.SSjjr SU4Sjjr Sr U=r $)rbi|-StateGraph[StateT, ContextT, InputT, OutputT]r7,dict[type[Any], Callable[[Any], Any] | None]r8Callable[[Any], Any] | NonerNrOc >>[TU]"S0UD6 XlX lgNrn)superrr7r8)rr7r8rrs rwrCompiledStateGraph.__init__s  "6" 0rvc[URRURRURRUR S5S9$)NInputtyprrr)_get_json_schemar7rrrrrconfigs rwget_input_jsonschema'CompiledStateGraph.get_input_jsonschemasD  ))LL((\\**w'   rvc[URRURRURRUR S5S9$)NOutputrs)rur7rrrrrvs rwget_output_jsonschema(CompiledStateGraph.get_output_jsonschemasD  **LL((\\**x(   rvc^ ^ U[:XabURRURRR 5VVs/sHup4[ U5(aMUPM snnm OX[ URR5URRR 5VVs/sHup4UPM snn-m S U U 4Sjjm [T S/:Xa[OT S9[[Ub"URb[UR5OSS94nU[:Xa2[[/[/[[!U5/S9UR"U'gUGbsU(a UROURR$n[ URRU5n['U5S:H=(a SU;nX`R(;aUR(Un O[+Xv5n XR(U'[,R/U5n UR0(a[3[45O [7[4SS9URU '[U /U(aSOUU [!U5/UR8UR:UR<UR>UR@URBURDURFS 9 UR"U'g[Hes snnfs snnf) Nc>Ucg[U[5(a-UR5VVs/sHupUT;dM X4PM snn$[U[5(aLUR[R :XagUR 5VVs/sHupUT;dM X4PM snn$[U[[45(aU(a[SU55(a/nUHn[U[5(aKUR[R :XaM8URU4SjUR 555 McURT"U5=(d S5 M U$[U5=n(a[U5(a [UT5$[SU3[R S9n[#U5es snnfs snnf)Nc3@# UHn[U[5v M g7frryrTris rwrGCompiledStateGraph.attach_node.._get_updates..s>1 1g..c3<># UHupUT;dM X4v M g7frrn)rkv output_keyss rwrrs"'/Dtq[HXFQF/Ds  rnzExpected dict, got )message error_code)ryrrrTgraphPARENT_update_as_tuplesrMranyextendrzr.r0rErBINVALID_GRAPH_NODE_RETURN_VALUErC) rrrr;rtmsg _get_updatesrs rwr4CompiledStateGraph.attach_node.._get_updatess}E4((+0;;=M=41A'>'@'@tqADTFQF'@54-00>>>>13A!!W--77gnn4$'/0/B/B/D' |A'<"=E{"!"(A!(D(D+E;??*1%9(HH)--=Ns GG G G r6)mapper)rstatic)tagstriggersrwritersrF)guard) rrrrrrirkrrboundrmr)rzNone | dict | Anyr Sequence[tuple[str, Any]] | None)%r@r7rrrrJrMrrrP _get_root_control_branchr_control_staticrMrArNrrrr8rL_CHANNEL_BRANCH_TOformatrr<rr:rrirkrrrunnablermrr) rrrrr write_entriesrr9is_single_inputrbranch_channelrrs @@rwrKCompiledStateGraph.attach_nodes~ %<!LL001J1JKQQSSDA'*SK t||445"ll2288:9:da:9K$ .$$ . -$ .$ .P #$/J<$?y\  #&# (='tyy1   Q  %<( \%m45 DJJsO  044,,$,,:S:SL!$,,"6"6|"DEN!.1Q6W:;WO444..|<%nC6<%%l3/66s;N::%S)#Cu5 MM. ) )()(7*^%m45!..!..!%!6!6#'#:#:mm !..DJJsO$ O 9s K$K4 Kc [U[5(a[U[:waPURURR [ [[RU5S5455 ggU[:waSSRU5SU3nURRUR(a'[[[U55URU'O&[![[U55URU'URUR"R U5 UH>nURURR [ [X45455 M@ gg)Nzjoin:+:)ryrr?rrrFrNrOrrrr7rr>rrr=r)rrr channel_namers rwrPCompiledStateGraph.attach_edges' fc " "cz 6"**11 *+=+D+DS+I4PR CZ"388F#3"4AcU;L||!!#&,,.JV/ l+/@S[.Q l+ JJsO $ $ + +L 9 5!))00 "3L"H!JK rvT) with_readercjSSSjjnU(aUR=(dR XRR;a#URRUROURRn[ URR U5nX`R ;aUR UnO[Xv5nXR U'[[RUS/:XaUSOUSUS9n OSn URURRURXY55 g)NcUVs/sHYnU(aO U[:wdM[U[5(d+[U[:XaUO[R U5S5OUPM[ nnU(d/$U$s snfr)r?ryrVrOrr)packetsrpwritess rw get_writes4CompiledStateGraph.attach_branch..get_writes,s! !A"DS&a..&#X+=+D+DQ+G  !   M s A1AA1r6rT)selectfreshr)F)rzSequence[str | Send]rrrz"Sequence[ChannelWriteEntry | Send])rr7rrrMrr8rLr rLdo_readrrFrun) rrrr*rrr~rrreaders rwrQ CompiledStateGraph.attach_branch)s;@ ) 37  / $ ((LL... ""5)66\\..  DLL0089H.....v6%h706%%f-=D##&.:,&>x{H >FF 5!!((J)GHrvc>[TU]U5 USnUSnUSnU(dgUSS:ag[U5HnURS5(dMUR S5S nX`R ;aM@S U3nXs;a[ X7URU55OURU5nURU05UR[054H6n XY;dM U RU5n Xy;a[ XU5X'M2XU'M8 Xr;aXR;aURU5X''XU'M [U5GHnURS 5(dMURS5S:XdM3UR S5S nX`R ;aMXS U3nXs;a[ X7URU55OURU5nURU05UR[054H6n XY;dM U RU5n Xy;a[ XU5X'M2XU'M8 Xr;aXR;aURU5X''XU'GM [UR 5RU5(Gdx[[5n URRH0upU [ :wdMU [":wdMXR%U 5 M2 [U5GHnU[ :XaMXPR ;dM!URU5nURU[&5nXHn S U 3nXs;a[ X7U5OUnURU 05UR[054H6n XY;dM U RU5n Xy;a[ XU5X'M2XU'M8 Xr;a U[&LaXU'XU'M [U;dMU[RU[&5 GM gg) z+Migrate a checkpoint to new channel layout.channel_valueschannel_versions versions_seenNrzstart:rrz branch:to:zbranch:)ro_migrate_checkpointrM startswithsplitrmaxpoprr*countr isdisjointrr7rr@r?rFr5)r checkpointr"versionsseenrrnew_knew_vssssource_to_targetrrrcrs rwr&CompiledStateGraph._migrate_checkpointZs #J/,-01/*  c?a  hA||H%%wws|Azz)$TF+(a9!a  88D"-txx 2/FGBwFF1I ;(+A%y(9BI()uI H&1;$*JJqMFM"'3 8hA||I&&1773<1+<wws|B'zz)$TF+(a9!a  88D"-txx 2/FGBwFF1I ;(+A%y(9BI()uI H&1;$*JJqMFM"'3 64::))(33*40 "ll00 E>cSj$+22371(^: ? QA 1g.A/2",SE 2;@;LHOQ 7RS#'88C#4dhhy"6M"NB w$&FF1I#(;03A%y0ABI01uI #O!.1G3C,-5M*/! 3$!D(Y++Aw73$ 4rv)r7r8)r7rjr8rkrrrrZr)rwzRunnableConfig | Nonerdict[str, Any])rrrz#StateNodeSpec[Any, ContextT] | NonerrZ)rzstr | Sequence[str]rrrrZ) rrrrr*rFrrrrZ)rr rrZ)rorprqrrrtrrxr|rKrPrQrru __classcell__)rs@rwrbrb|s;:BB//.. 1? 1G 1  1  1/3 +  /3 +  iV6QU/I/I #/I-7/IIM/I /Ibg8g8rvrbcUS/:Xag[U5(a5[U[5(d[U5(a[ [ U5$g)Nr6)r issubclassr"r r _coerce_state) state_keysr~s rwrLrLs@j\!vJvy99\&=Q=Q}f-- rv_ScU"S0UD6$rnrn)r~rs rwrrs ?E?rvc[U[5(a [U44$/n[U[5(aUR U5 OL[U[ [ 45(a1UH+n[U[5(dMUR U5 M- /nUHnUR[R:Xa [U5e[UR[[45(a UR/O URnUHzn[U[5(aUR [U45 M1[U[5(dMHU[:wdMTUR [RU5S45 M| M U$r)ryrVr-rTrFrMrrrrDgotorr?rr)valuecommandscmdrcommand goto_targetsgos rwrrs&%   H%!! ED%= ) )C#w''$"$C ==GNN *( ()c{CCW\\N B"d## E2;'B$$s .55b94@A  Jrvc4[U[5(aFUR5VVs/sH)upU[:XaUO[R U5SU4PM+ snn$UVs/sH&o3[:XaUO[R U5SS4PM( sn$s snnfs snfr)ryrrr?rr)rrlabeles rwrrs$!JJL (s(Q 2 9 9! .s61 1g&&rr6) ryrTrrrrMrrrrF)rr;rs rwrrs%!! ;;'.. (&&((54-((  66 6 6)+A!W%%77gnn,q2245 A/   U#$$ rvc [US5(dS[SUSS90004$[USS9nUR5VVs0sHup#US:wdM U[X#5_M nnnUR5VVs0sHupV[ U[ 5(dMXV_M snnUR5VVs0sHupV[ U5(dMXV_M snnU4$s snnfs snnfs snnf)Nrtr6FrT)include_extras __slots__)r _get_channelrrryr7rJ)r~rrrtall_keysrrs rwrrs 6, - - j&N O     tq.A*B   JBs# CC4CC.CCcgrrnr annotationrs rwrr.srvrcgrrnrs rwrr4s&)rvcX[US5(a)UR[[4;aURSn[ X5=n(aU(aU$[ SUS35e[U5=n(aXlU$[U5=n(aXlU$[U5nXlU$)N __origin__rzThis z not allowed in this position) rrr%r$__args___is_field_managed_valuer_is_field_channelr_is_field_binopr;)rrrmanagerrfallbacks rwrr:sz<((Z-B-BG. ((+ )$;;w; NuZL0MNO O%j1 1 1 #J/ / / #J/HL OrvcP[US5(GaURnUGHn[U[5(a[U[5(a|[US5(akUR n[US5(a)UR [ [4;aURSnURURUURS9nUs $[U5(dM[U[5(dMU"[US5(aUR 5s $U5s $ g)N __metadata__rr)snapshot_frequency)rrryr7r9rr%r$rrreducerrr r)rtmetaitemorigins rwrrTssN##D$ ,,dL11gc<6P6P ^^Fv|449J9J #O:"(!3>> +/+B+B*D  :dK#@#@gc<.H.HCNNRRcRR)* rvcH[US5(aURn[U5S:av[US5(ac[ US5n[ UR R55n[SU55S:Xa[XS5$[SU35eg)Nrrrc3j# UH*nURURUR4;v M, g7fr)kindPOSITIONAL_ONLYPOSITIONAL_OR_KEYWORD)rrs rwr"_is_field_binop..ws1#FFq00!2I2IJJ#s13rz5Invalid reducer signature. Expected (a, b) -> c. Got ) rrrcallablerrMrr"sumr8r)rtrsigparamss rwrrpssN## t9>htBx00DH%C#..//12F#  /sH== KC5Q rvc[US5(aGURn[U5S:a,[US5=(d USn[ U5(aU$[U5b)[ U5=n(aUS=n(a [ X5$g)Nrrrr)rrrrrJrr)rrtr decorationargs inner_types rwrrssN## t9>#DH-9bJ ++!! 3#c] "T "7 "Z "&t88 rvc `[U5(a%[U[5(aUR5$[ U5(a[ U5R 5$[XR55n[U5S:Xa2USS:Xa)[UX$SRS4S9R5$[UXVs0sHKnXR;dM [X%[5(dM#UX%R[UX%RU54_MM snS9R5$s snf)Nrrr6)root)field_definitions)r rr"model_json_schemar(r# json_schemarMrrr1 UpdateTyperyr7r/)rtrrrrrs rwrurus/ s|| 3 22$$&& c  3++--GL%%'( t9>d1g3Aw'22D9 ! "  %\ #*} *4HK)M A ..- ! ( 6 6 #  * #  !! " #sD+ D+ ,,D+ )r~ztype[Any] | AnyrrZ)rzStateNode[Any, ContextT]rr)rz Sequence[str]r~r]rrl)r~ztype[_S]rrrr)rrrzSequence[tuple[str, Any]])rz tuple[str, ...] | dict[str, str]rz%Sequence[tuple[str, Any, str | None]])rrrr)r~z type[dict]rzJtuple[dict[str, BaseChannel], dict[str, ManagedValueSpec], dict[str, Any]])rrrrrzLiteral[False]rr7)rrrrrz Literal[True]rBaseChannel | ManagedValueSpec)rrrrrrrr)rtr]rzBaseChannel | None)rtr]rzBinaryOperatorAggregate | None)rrrtr]rzManagedValueSpec | None) rtrzrrrrrrrr) __future__rrloggingr{r| collectionsrcollections.abcrrrr dataclassesr r datetimer functoolsr r rrrtypesrrrrrrrrrrrrlangchain_core.runnablesrrlanggraph.cache.baserlanggraph.checkpoint.baser langgraph.store.baser!pydanticr"r#typing_extensionsr$r%r&r'r(langgraph._internalr)langgraph._internal._constantsr*r+r,r-langgraph._internal._fieldsr.r/r0langgraph._internal._pydanticr1langgraph._internal._runnabler2langgraph._internal._timeoutr3langgraph._internal._typingr4r5r6langgraph.channels.baser7langgraph.channels.binopr8langgraph.channels.deltar9"langgraph.channels.ephemeral_valuer:langgraph.channels.last_valuer;r<&langgraph.channels.named_barrier_valuer=r>langgraph.constantsr?r@rAlanggraph.errorsrBrCrDrElanggraph.graph._branchrFlanggraph.graph._noderGrHlanggraph.managed.baserIrJlanggraph.pregelrKlanggraph.pregel._readrLrMlanggraph.pregel._writerNrOrPlanggraph.typesrQrRrSrTrUrVrWrXrYlanggraph.typingrZr[r\r]r^langgraph.warningsr_r`__all__ getLoggerrorrrIrfrrrarbrLrrrrrrrrrrrurnrvrwr=s" #CC/<<&   >*0*+OO&  7<>LL/<1=I76 /:$:   KJW .   8 $#9 ))) @v#67:;v#r'E8 68VW ,- FHfg -.E8P '0  T]:  *  *  %. O.  2@   BF) ))2?)#) ) :> 26#48*&"" "" """"  ""  ""rv