&`i`PdZddlZddlZddlZddlZddlmZddlmZddl m Z m Z m Z m Z mZddlZddlmZddlmZmZmZddlmZdd lmZdd lmZmZmZmZmZm Z dd l!m"Z"dd l#m$Z$m%Z%m&Z&m'Z'm(Z(dd l)m*Z*ej+e,Z-eZ.e eZ/GddZ0GddZ1GddZ2de eefde ee3fde efdZ4de ede ee3fde eefde3dede ede e.e/e5ge e0fde ee ee3fe ee3fffdZ6 d2de eefde ee3fded e3d!e ede e.e/e5ge e0fd"e7de ee3fe effd#Z8ded!e ed$ede ee7e3e9e9ffd%Z:ded!e ed&e5d$efd'Z; d2de ed(e ed"e7de ee effd)Zd-ej?d.e ddfd/Z@d0e edee ee e effd1ZAdS)3auImplements multi-node-type autoscaling. This file implements an autoscaling algorithm that is aware of multiple node types (e.g., example-multi-node-type.yaml). The Ray autoscaler will pass in a vector of resource shape demands, and the resource demand scheduler will return a list of node types that can satisfy the demands given constraints (i.e., reverse bin packing). N)abstractmethod)partial)CallableDictListOptionalTuple)PlacementGroupTableData)AUTOSCALER_CONSERVE_GPU_NODES&AUTOSCALER_UPSCALING_INITIAL_NUM_NODES!AUTOSCALER_UTILIZATION_SCORER_KEY)load_function_or_class)NodeAvailabilitySummary)NodeIDNodeIPNodeTypeNodeTypeConfigDict ResourceDictis_placement_group_resource) NodeProvider)NODE_KIND_HEADNODE_KIND_UNMANAGEDNODE_KIND_WORKERTAG_RAY_NODE_KINDTAG_RAY_USER_NODE_TYPE)PlacementStrategyceZdZdZedddefdZedddddefdZdddddefdZdddddefdZ dddddefd Z d S) UtilizationScoreaThis fancy class just defines the `UtilizationScore` protocol to be some type that is a "totally ordered set" (i.e. things that can be sorted). What we're really trying to express is ``` UtilizationScore = TypeVar("UtilizationScore", bound=Comparable["UtilizationScore"]) ``` but Comparable isn't a real type and, and a bound with a type argument can't be enforced (f-bounded polymorphism with contravariance). See Guido's comment for more details: https://github.com/python/typing/issues/59. This isn't just a `float`. In the case of the default scorer, it's a `Tuple[float, float]` which is quite difficult to map to a single number. otherreturncdSNselfrs /home/jaya/work/projects/VOICE-AGENT/VIET/agent-env/lib/python3.11/site-packages/ray/autoscaler/_private/resource_demand_scheduler.py__eq__zUtilizationScore.__eq__H r%cdSr"r#r$s r&__lt__zUtilizationScore.__lt__Lr(r)c||k o||kSr"r#r$s r&__gt__zUtilizationScore.__gt__Ps5L 3dem3r)c||kp||kSr"r#r$s r&__le__zUtilizationScore.__le__Sse|,tu},r)c||k Sr"r#r$s r&__ge__zUtilizationScore.__ge__Vs%<r)N) __name__ __module__ __qualname____doc__rboolr'r+r-r/r1r#r)r&rr5s$ . 4   ^  ' 0B t   ^ 4'40B4t4444-'-0B-t---- ' 0B t      r)rc 2eZdZdedededeefdZdS)UtilizationScorernode_resourcesresource_demandsnode_availability_summaryr cdSr"r#)r9r:r;s r&__call__zUtilizationScorer.__call__[s r)N) r2r3r4 NodeResourcesResourceDemandsrrrr=r#r)r&r8r8ZsR % ) $;  " #       r)r8ceZdZdedeeefdedededdf dZ d e e de e e e ffd Z d(dedeeefdedededdf d Zd edefdZd e e deeefde edeeefde edeeefde ededeeefe effdZd e e deeeffdZdeeefde ede e deeefdeeefdeeefdeeeffdZde e de edeeefeeefffdZd e e d ee efdeeefde eeeefffd!Zd"e e ed#e ed$eeefd%eeegeeffd&Z d e e d ee efdeeefdefd'Z!dS))ResourceDemandSchedulerprovider node_types max_workershead_node_typeupscaling_speedr Nc||_tj||_t |_||_||_||_tj td}t||_dS)NzMray.autoscaler._private.resource_demand_scheduler._default_utilization_scorer)rBcopydeepcopyrCsetnode_resource_updatedrDrErFosenvirongetr rutilization_scorer)r%rBrCrDrErFutilization_scorer_strs r&__init__z ResourceDemandScheduler.__init__es|! - 33%(UU"&,.!# - +" "  6L "6 6 r)nodescdg}}|D]`}|j|}|ttkr|}5|ttkr||a||fS)zReturns the head node's id and the list of all worker node ids, given a list `nodes` of all node ids in the cluster. N)rB node_tagsrrrappend)r%rRhead_id worker_idsnodetagss r&_get_head_and_workersz-ResourceDemandScheduler._get_head_and_workers}s{#B ( (D=**400D%&.88'(,<<<!!$''' ""r)c||_tj||_t |_||_||_||_dS)zUpdates the class state variables. For legacy yamls, it merges previous state and new state to make sure inferered resources are not lost. N) rBrHrIrCrJrKrDrErF)r%rBrCrDrErFs r& reset_configz$ResourceDemandScheduler.reset_configsF! - 33%(UU"&,.r)bundlec|jD]G\}}|dd}|d}||jks|dkrt ||rdSHdS)NrDr resourcesTF)rCitemsrNrE_fits)r%r^ node_typeconfig max_of_typer9s r& is_feasiblez#ResourceDemandScheduler.is_feasibles{!%!6!6!8!8   Iv **]A66K#K0NT000K!OOJJOttur)launching_nodesr:unused_resources_by_ippending_placement_groupsmax_resources_by_ipensure_min_cluster_sizer;c  t|j|} |||||||\} } td| td| t| | |j|j |j || \} } } td|t|\} }| |z}| || | | \} } t| | \}}|j dzt| z }t!|j| |j ||| \}fd|jD}t| |\}}td|td |t!|j| |j ||| \}}td |i}|jD]Q}| |d |d z||d z}|d kr|||<R|||||| |}td |||fS) aGiven resource demands, return node types to add to the cluster. This method: (1) calculates the resources present in the cluster by: - computing available resources for each existing node - counting the number of nodes per node type - including both running and launching nodes (2) calculates the remaining nodes to add to respect min_workers constraint per node type. (3) for each strict spread placement group, reserve space on available nodes and launch new nodes if necessary. (4) calculates the unfulfilled resource bundles. (5) calculates which nodes need to be launched to fulfill all the bundle requests, subject to max_worker constraints. Args: nodes: List of existing nodes in the cluster. launching_nodes: Summary of node types currently being launched. resource_demands: Vector of resource demands from the scheduler. unused_resources_by_ip: Mapping from ip to available resources. pending_placement_groups: Placement group demands. max_resources_by_ip: Mapping from ip to static node resources. ensure_min_cluster_size: Try to ensure the cluster can fit at least this set of resources. This differs from resources_demands in that we don't take into account existing usage. node_availability_summary: A snapshot of the current NodeAvailabilitySummary. Returns: Dict of count to add for each node type, and residual of resources that still cannot be fulfilled. r;zCluster resources: {}zNode counts: {}rOzPlacement group demands: r[cli|]0}||d|dz1S)r)rN).0rc!pg_demands_nodes_max_launch_limitspread_pg_nodes_to_adds r& z?ResourceDemandScheduler.get_nodes_to_launch..'sW, , ,  -11)Q??/33IqAAB, , , r)zResource demands: {}zUnfulfilled demands: {}zFinal unfulfilled: {}rzNode requests: {})rrO#_update_node_resources_from_runtimecalculate_node_resourcesloggerdebugformat_add_min_workers_nodesrCrDrE$placement_groups_to_resource_demandsreserve_and_allocate_spreadget_bin_pack_residualsumvalues get_nodes_forrN)_get_concurrent_resource_demand_to_launchkeys)r%rRrgr:rhrirjrkr;rOr9node_type_countsadjusted_min_workersplacement_group_demand_vectorstrict_spreads$unfulfilled_placement_groups_demands_ max_to_add placement_groups_nodes_max_limit unfulfillednodes_to_add_based_on_demandfinal_unfulfilledtotal_nodes_to_addrc nodes_to_addrqrrs @@r&get_nodes_to_launchz+ResourceDemandScheduler.get_nodes_to_launchsX%  #?X    008KLLL ,0+H+H ?$:, , ((  ,33NCCDDD &--.>??@@@ #   O     #1        K1IKKLLL& 11I J J )  9;KK  , ,        "  3H  )3 3 /,a %)C0@0G0G0I0I,J,JJ /< O     01 0 0 0 ,)1, , , , , "_, , , (/~?OPP Q +223CDDEEE .55kBBCCC:G O     1 ; ; ; 7$&7  ,334EFFGGG  = =I$((A66(,,Y::;.229a@@A  a0<"9-"KK  " ' ' ) )   ,     (//0BCCDDD!#444r)cpt|jt|jk}|sdS|D]}|j|}t |vr'|t }||jvs ||jvrG|j|}||}|rtj |}|j|di} dD]} | |vr || | | <| |j|d<|t} | tkr|j |dS)a Update static node type resources with runtime resources This will update the cached static node type resources with the runtime resources. Because we can not know the exact autofilled memory or object_store_memory from config file. Nr`)CPUGPUmemory) lenrCrKrBrTr internal_iprNrHrIrradd) r%rRrj need_updatenode_idrYrcipruntime_resourcesr`key node_kinds r&rtz;ResourceDemandScheduler._update_node_resources_from_runtimeVsd$/**c$2L.M.MM   F > >G=**733D%T1134IT777DO33**733B 3 7 7 ; ;   >$(M2C$D$D! OI6::;KK 3@@C///):3)? #:C *;7 !23  000.229===A > >r) to_launchconnected_nodesnon_terminated_nodespending_launches_nodesrplacement_group_nodesc i}|||\}} |D]} ttt|jt|| dz} || d| | z} t| | z || d|| dz} | dkrt | || || <|S)a$Updates the max concurrent resources to launch for each node type. Given the current nodes that should be launched, the non terminated nodes (running and pending) and the pending to be launched nodes. This method calculates the maximum number of nodes to launch concurrently for each node type as follows: 1) Calculates the running nodes. 2) Calculates the pending nodes and gets the launching nodes. 3) Limits the total number of pending + currently-launching + to-be-launched nodes to: max( 5, self.upscaling_speed * max(running_nodes[node_type], 1) ). Args: to_launch: List of number of nodes to launch based on resource demand for every node type. connected_nodes: Running nodes (from LoadMetrics). non_terminated_nodes: Non terminated nodes (pending/running). pending_launches_nodes: Nodes that are in the launch queue. adjusted_min_workers: Nodes to launch to satisfy min_workers and request_resources(). This overrides the launch limits since the user is hinting to immediately scale up to this size. placement_group_nodes: Nodes to launch for placement groups. This overrides the launch concurrency limits. Returns: Dict[NodeType, int]: Maximum number of nodes to launch for each node type. r[r)#_separate_running_and_pending_nodesmaxr intrFrNmin)r%rrrrrrupdated_nodes_to_launch running_nodes pending_nodesrcmax_allowed_pending_nodestotal_pending_nodes upper_bounds r&rzAResourceDemandScheduler._get_concurrent_resource_demand_to_launchsP#%'+'O'O ( ( $ }#  I),6D(3}Y/G+K+KKLL)) % '**9a88=;SS ),??%((A66'++Iq99: KQ589!566' 2'&r)cVtjt}tjt}|D]q}|j|}t |vrL|t }|j|}||vr||xxdz cc<a||xxdz cc<r||fS)z?Splits connected and non terminated nodes to pending & running.r[) collections defaultdictrrBrTrr) r%rrrrrrYrcnode_ips r&rz;ResourceDemandScheduler._separate_running_and_pending_nodess$/44 #/44 + 2 2G=**733D%-- !78 -33G<<o--!),,,1,,,,!),,,1,,,m++r)rc g tjt d fd }|D]m}j|}t |vrH|t }j|}||} ||| n|D]"\}} t| D] } ||# fS)aReturns node resource list and node type counts. Counts the running nodes, pending nodes. Args: nodes: Existing nodes. pending_nodes: Pending nodes. Returns: node_resources: a list of running + pending resources. E.g., [{"CPU": 4}, {"GPU": 2}]. node_type_counts: running + pending workers per node type. Nc J|jvr8td|djdtdtd dSt jj|d}|t j|}||xxdz cc<dS)NzMissing entry for node_type z in cluster config: z under entry available_node_types. This node's resources will be ignored. If you are using an unmanaged node, manually set the z tag to "z." in your cloud provider's management console.r`r[)rCrverrorrrrHrIrU)rcavailable_resources availabler9rr%s r&add_nodezBResourceDemandScheduler.calculate_node_resources..add_nodes// *9**'+** 1 ** , ***t doi&@&MNNI#. M*=>>  ! !) , , , Y ' ' '1 , ' ' ' ' 'r)r") rrrrBrTrrrNrarange)r%rRrrhrrrYrcrrcountrr9rs` @@r&ruz0ResourceDemandScheduler.calculate_node_resourcess$&2377 - - - - - - - -2 9 9G=**733D%-- !78 ]..w77&<&@&@&D&D#$7888 - 3 3 5 5 $ $ Iu5\\ $ $#### $///r)rr9rrOc tjt}|D]}t||d\}}|jdzt |z } t|j||j | ||d\} } t|j| } t| |d\}} |r.t d |t|| t|| || z}|||fS)aFor each strict spread, attempt to reserve as much space as possible on the node, then allocate new nodes for the unfulfilled portion. Args: strict_spreads (List[List[ResourceDict]]): A list of placement groups which must be spread out. node_resources (List[ResourceDict]): Available node resources in the cluster. node_type_counts (Dict[NodeType, int]): The amount of each type of node pending or in the cluster. utilization_scorer: A function that, given a node type, its resources, and resource demands, returns what its utilization would be. Returns: Dict[NodeType, int]: Nodes to add. List[ResourceDict]: The updated node_resources after the method. Dict[NodeType, int]: The updated node_type_counts. T) strict_spreadr[)rOrz-Unfulfilled strict spread placement group: {})rrrr|rDr}r~rrCrE#_node_type_counts_to_node_resourcesrvrwrx _inplace_add)r%rr9rrOto_addbundlesrupdated_node_resourcesrrrnew_node_resourcesincluding_reserveds r&r{z3ResourceDemandScheduler.reserve_and_allocate_spreadsT:(--% I IG3Ht333 /K/)A-4D4K4K4M4M0N0NNJ( ##5"LIq"E""  /D"Kt/// +K+  CJJ7SS )9 5 5 5  + + +36HHNN~'777r)c ||||\}}d}|D]Q\}}|d||z }||r|d||z }R|S)NzWorker node types:z - {}: {}z ({} pending))rurarxrN) r%rRrrhr9routrcrs r& debug_stringz$ResourceDemandScheduler.debug_string]s ,0+H+H ="8, , ((# 0 6 6 8 8 H H Iu ='' 599 9C  ++ H--mI.FGGG r))r[)"r2r3r4rrrrrfloatrQrrr rZr]rr6rfrr rrrtrrstrrurr>r?rrr{rr#r)r&rArAds   #556   !         0 #4< #E&$v,BV"? l5"&,"67l5"&l!3l5$;l5 x} tL1 2l5l5l5l5\->&\->8->->->^E'# &E'fE'#6l E' !%Xs] 3 E' #8S=1 E' $HcM2E' hm E'E'E'E'N,"6l,f, x} tHcM2 3 ,,,,(:0F|:0FCK(:0!%S,%6 7 :0 | d8S=1 2 :0:0:0:0x?8T,/0?8\*?8x}- ?8 % O ,h7G.H H ?8?8?8?8BF|FCK(!%S,%6 7  r)rArCrr cg}|D]$\}|fdt|Dz }%|S)z?Converts a node_type_counts dict into a list of node_resources.cPg|]"}d#Sr`)rHrprrcrCs r& z7_node_type_counts_to_node_resources..xs/VVVAj+K8==??VVVr))rar)rCrr`rrcs` @r&rrps] I,2244WW 5VVVVVuVVVV r)r9rDrErkrOci}D]\}|d} t|dd|dd} |kr| dz} | | krB| | z |<| |<|fdt |D|r|dzt |z } g} |D]7| fdt |D8t| |\} }t||| | |\}}|D]|d}|dkrg||dz|<|fdt |D||dz|<|||fS) aUpdates resource demands to respect the min_workers and request_resources() constraints. Args: node_resources: Resources of existing nodes already launched/pending. node_type_counts: Counts of existing nodes already launched/pending. node_types: Node types config. max_workers: global max_workers constaint. ensure_min_cluster_size: resource demands from request_resources(). utilization_scorer: A function that, given a node type, its resources, and resource demands, returns what its utilization would be. Returns: node_resources: The updated node resources after adding min_workers and request_resources() constraints per node type. node_type_counts: The updated node counts after adding min_workers and request_resources() constraints per node type. total_nodes_to_add_dict: The nodes to add to respect min_workers and request_resources() constraints. r min_workersrDr[cPg|]"}tjd#SrrHrIrs r&rz*_add_min_workers_nodes..=M*Y"7 "DEEr)cPg|]"}tjd#Srrrs r&rz*_add_min_workers_nodes..rr)rncPg|]"}tjd#Srrrs r&rz*_add_min_workers_nodes..s= j&;K&HIIr)) rarNrextendrr}r~r|r)r9rrCrDrErkrOtotal_nodes_to_add_dictrdexistingtargetrmax_node_resourcesresource_requests_unfulfilledrnodes_to_add_request_resourcesrrcs ` @r&ryry|s@!'--// 6#'' 155VZZ q116::mQ3O3OPP  & &aZF f  17(1B #I .*0 Y '  ! !"#:9#EFF   'M 1_s+;+B+B+D+D'E'EE )  I  % %"#3I#>??    ,A  7, , (%q-:     )1 - - - )&8 M MI9==iKKLa.:=M=Q=Qq>>/ +%%!&|!4!4!#:#>#>y!#L#LL( +-D DDr)Fexisting_nodesrr`rctjt}|rt||krg}|D]} || dd} || kr| dz} || d|| dz| kr[|| d} |r|| |dg| } n || || } | || | f|s8td|Dst d|dnt|d }|dd} || xxdz cc<|r |dd}nP|| d}t|g|\}}t|t|ks J||f|}|r&t||k||fS) aDetermine nodes to add given resource demands and constraints. Args: node_types: node types config. existing_nodes: counts of existing nodes already launched. This sets constraints on the number of new nodes to add. max_to_add: global constraint on nodes to add. resources: resource demands to fulfill. strict_spread: If true, each element in `resources` must be placed on a different node. utilization_scorer: A function that, given a node type, its resources, and resource demands, returns what its utilization would be. Returns: Dict of count to add for each node type, and residual of resources that still cannot be fulfilled. rDrr[r`Nc3>K|]}|D]}t|VdSr")r)rpresources_dictresources r& z get_nodes_for..sU" .,H55r)zBThe autoscaler could not find a node type to satisfy the request: z:. Please specify a node type with the necessary resources.T)reverse) rrrr}r~rNrUanyrvwarningsortedr|r)rCrrErr`rOrrutilization_scoresrcmax_workers_of_node_typer9scorebest_node_typeallocated_resourceresidualrs r&rrst:)4(?(D(DL -!L//1122Z??# > >I'1)'<'@'@PQ'R'R $**+Ca+G(""9a00<3C3CIq3Q3QQ+,,' 2;?N Q+*>IaL>9UU**>9iPP "))5)*<===" &/  , ),,, #$6EEE+A.q1^$$$)$$$  !!!"" II!+N!;K!H /1C0DiPPKHax==3y>>111Ix3H111 I[ -!L//1122Z??^  ""r)r;ctj|}g}t}|D]l}|D] \}}|dkr||!t ||r%||t||m|sdSg} d} |D]>\}}|dkr ||vr| dz } |||z |z } | || dzz?| sdSd} tr/d|vo |ddk} td|D}| r|sd} | | t| tt| t| z fS)Nrr[Trc3K|]}d|vV dS)rNr#)rprs r&rz5_resource_based_utilization_scorer..Rs&99!5A:999999r)F)rHrIrJrarrbrU_inplace_subtractr rrrr}r)r9r`r; remainingfittableresource_typesrkvutil_by_resourcesnum_matching_resource_typesutilgpu_ok is_gpu_node any_gpu_tasks r&"_resource_based_utilization_scorerr)s  n--IHUUN ,,GGII & &DAq1uu""1%%% A   , OOA    i + + + t"#$$&& 0 01 q55     '1 , 'IaL A%  dAg//// tF$~-K.2G!2K 99y99999  | F #  c#$$%%,=(>(>>  r)rcc&t|||S)Nrm)r)r9r`rcr;s r&_default_utilization_scorerrcs# . =V   r)r:cg}tj|}t}t|ddD]}d}d}t t |D]:} | |vr|| }t ||rd}|r|| n;|r|rt||r| |||fS)a6Return a subset of resource_demands that cannot fit in the cluster. TODO(ekl): this currently does not guarantee the resources will be packed correctly by the Ray scheduler. This is only possible once the Ray backend supports a placement groups API. Args: node_resources (List[ResourceDict]): List of resources per node. resource_demands (List[ResourceDict]): List of resource bundles that need to be bin packed onto the nodes. strict_spread: If true, each element in resource_demands must be placed on a different entry in `node_resources`. Returns: List[ResourceDict]: the residual list resources that do not fit. List[ResourceDict]: The updated node_resources after the method. The order of the list elements remains unchanged. ct|t|t|fSr")rr~r}rra)demands r&z'get_bin_pack_residual..sB     6<<>> " " r)T)rrFN) rHrIrJrrrrbrrrU) r9r:rrrRusedrfoundrXis r&r|r|os.K M. ) )E 55D   ''s5zz""  ADyy8DT6""   HHQKKK    'T ' dF + + + +   v & & & &  r)rXc|D]H\}}||||tjjrdndkrdSIdS)Ng?FT)rarN startswithray_rayletIMPLICIT_RESOURCE_PREFIXrXr`rrs r&rbrbsr!!1 txx all3;#GHHQssc    55  4r)c,|D]~\}}|dkr ||vr5|tjjs J||fd||<||vs J||f||xx|zcc<||dks J|||fdS)Nrr[r)rarrrr r s r&rrs!! , ,1 66  D==<< DEE P P4y P PEDGDyyy1d)yyy Q1 Aw#~~~a|~~~~ , ,r)abcZ|D]\}}||xx|z cc<dS)zWGenerically adds values in `b` to `a`. a[k] should be defined for all k in b.keys()N)ra)r r rrs r&rrs@ 1 ! r)ricg}g}|D]?}g}|jD]5}|jdkr|t|j6|jt jks|jt jkr| ||jt j kr^tj t}|D],}|D]\}} ||xx| z cc<-|||jt jkr||!t d|dA||fS)aPreprocess placement group requests into regular resource demand vectors when possible. The policy is: * STRICT_PACK - Convert to a single bundle. * PACK - Flatten into a resource demand vector. * STRICT_SPREAD - Cannot be converted. * SPREAD - Flatten into a resource demand vector. Args: pending_placement_groups (List[PlacementGroupData]): List of PlacementGroupLoad's. Returns: List[ResourceDict]: The placement groups which were converted to a resource demand vector. List[List[ResourceDict]]: The placement groups which should be strictly spread. r)z&Unknown placement group request type: zI. Please file a bug report https://github.com/ray-project/ray/issues/new.)rrrUdictunit_resourcesstrategyrPACKSPREADr STRICT_PACKrrrra STRICT_SPREADrvr) riresource_demand_vector unconvertedplacement_groupshapesr^combinedshapelabelquantitys r&rzrzs( K3%- 7 7F~$$ MM$v455 6 6 6 6  $(9(> > >'+<+CCC " ) )& 1 1 1 1  %):)F F F".u55H 0 0',{{}}00OE8UOOOx/OOOO0 " ) )( 3 3 3 3  %):)H H H   v & & & & LLBBBB     "; ..r))F)Br5rrHloggingrLabcr functoolsrtypingrrrrr rray._private.gcs_utilsr !ray.autoscaler._private.constantsr r r ray.autoscaler._private.loaderr:ray.autoscaler._private.node_provider_availability_trackerrray.autoscaler._private.utilrrrrrrray.autoscaler.node_providerrray.autoscaler.tagsrrrrrray.core.generated.common_pb2r getLoggerr2rvr>r?rr8rArrrryr6rrrrr|rbrrrrzr#r)r&r,s  88888888888888 :::::: BAAAAA655555<;;;;;  8 $ $ |$" " " " " " " " J        IIIIIIIIX X112 8S=)  ,    YE&YE8S=)YEX112YE YE  YE ",/ YE! -x8H/IIYE <$x}-tHcM/BCYEYEYEYEJ N#N#X112N#3'N#N# N# L! N# ! -x8H/II N#N# 8S=4 -.N#N#N#N#b7 7L!7 7 7 eD#ue+,- 7777t   L!   7     ;;&;<(;; <$|,- ;;;;| $ ,L ,\ ,d , , , ,K+1/"#:;1/ 4 tD$67 781/1/1/1/1/1/r)