;i̗ddlZddlmZddlmZmZmZmZmZm Z m Z m Z m Z ddlmZddlmZmZmZmZmZmZmZmZmZmZmZmZmZmZmZm Z m!Z!m"Z"m#Z#m$Z$m%Z%m&Z&m'Z'm(Z(m)Z)m*Z*m+Z+m,Z,m-Z-ddl.m/Z/ddl0m1Z1m2Z2m3Z3m4Z4m5Z5m6Z6m7Z7ddl8m9Z9dd l:m;Z;dd lm?Z?m@Z@mAZAmBZBmCZCmDZDm Z mEZEmFZFmGZGmHZHmIZImJZJdd lKmLZLdd lMmNZNddlOmPZQddlRmSZS ddl>mTZTn#eU$r ddl>mHZTYnwxYwdZVdZWeXddZYeYdZZeYdZ[eYdZ\eYdZ]eYdZ^de_de e`dffdZaeaeQZbebdkrdnd Zcd!ZPde_dd"fd#ZdGd$d%e5ZeGd&d'Zfd(e4de fd)ZgGd*d+ZhGd,d-ZiGd.d/Zjed0d1d2Zked3d4d2Zled5d6d2Zmed7d8d2Zned9d:d2Zoed9d;d2Zpdeddfd?Zqd@e_d=e7d>eddfdAZrd=e7d>eddfdBZsdCe_d=e e1e7fd>eddfdDZtd=e7d>eddfdEZud=e1d>eddfdFZv dTd(e2d@e_dHeedIe dJee dKeeTdLewdMewddfdNZxdOe ee(fde_fdPZydOe ee(fde_fdQZzdRe_deee_effdSZ{dS)UN) ConfigParser) AnyCallableDictListOptionalSetTupleTypeUnion) ErrorCode) ARG_NAMED ARG_NAMED_OPTARG_OPTARG_POS ARG_STAR2MDEFArgumentAssignmentStmtBlockCallExprClassDefContext Decorator EllipsisExprFuncBaseFuncDefJsonDict MemberExprNameExprPassStmtPlaceholderNodeRefExprStrExpr SymbolNodeSymbolTableNodeTempNodeTypeInfo TypeVarExprVar)Options)CheckerPluginInterfaceClassDefContextFunctionContext MethodContextPluginReportConfigContextSemanticAnalyzerPluginInterface) dataclasses)set_callable_name)make_wildcard_trigger) AnyType CallableTypeInstanceNoneType Overloaded ProperTyper TypeOfAnyTypeType TypeVarId TypeVarType UnionTypeget_proper_type) fill_typevars)get_unique_redefinition_name) __version__)is_valid_field) TypeVarDef)r? pydantic-mypyzpydantic-mypy-metadataz.main.BaseModelz.env_settings.BaseSettingsz.main.ModelMetaclassz .fields.Fieldz.dataclasses.dataclassversionreturn.cttt|dddS)N+r.)tuplemapint partitionsplitrIs DC:\PYTHON\MyICR_Workspace\venv\Lib\site-packages\pydantic/v1/mypy.pyparse_mypy_versionrUWs; S'++C00399#>>?? @ @@)ribuiltins __builtins__zTypingType[Plugin]ctS)z `version` is the mypy version string We might want to use this to print a warning if the mypy version being used is newer, or especially older, than we expect (or need). )PydanticPluginrSs rTpluginr\bs  rVc"eZdZdeddffd ZdeddfdZdedeee gdffdZ dedd fd Z dedeee ge ffd Zdedeee gdffd Zd edeeeffdZd e ddfdZd e ddfdZd eddfdZxZS)r[optionsrJNct||_|j|_t |dSN)PydanticPluginConfig plugin_configto_data _plugin_datasuper__init__)selfr^ __class__s rTrfzPydanticPlugin.__init__msH1':: .6688 !!!!!rVfullnamez+Optional[Callable[[ClassDefContext], None]]c||}|rDt|jtr*t d|jjDr|jSdS)Nc3FK|]}t|tkVdSr`) get_fullnameBASEMODEL_FULLNAME.0bases rT z5PydanticPlugin.get_base_class_hook..vs0UU<%%);;UUUUUUrV)lookup_fully_qualified isinstancenoder(anymro$_pydantic_model_class_maker_callbackrgrisyms rTget_base_class_hookz"PydanticPlugin.get_base_class_hookrsd))(33  A:ch11 AUU UUUUU A@@trVc*|tkr|jSdSr`)MODEL_METACLASS_FULLNAME)_pydantic_model_metaclass_marker_callbackrgris rTget_metaclass_hookz!PydanticPlugin.get_metaclass_hookzs / / /A AtrVz+Optional[Callable[[FunctionContext], Type]]cb||}|r|jtkr|jSdSr`)rrriFIELD_FULLNAME_pydantic_field_callbackrxs rTget_function_hookz PydanticPlugin.get_function_hooks7))(33  13<>110 0trVc>|drtSdS)Nz .from_orm)endswithfrom_orm_callbackr~s rTget_method_hookzPydanticPlugin.get_method_hooks#   [ ) ) %$ $trVcJ|tkrtdkr tjSdS)zMark pydantic.dataclasses as dataclass. Mypy version 1.1.1 added support for `@dataclass_transform` decorator. )rN)DATACLASS_FULLNAMEMYPY_VERSION_TUPLEr3dataclass_class_maker_callbackr~s rTget_class_decorator_hookz'PydanticPlugin.get_class_decorator_hooks) ) ) ).@6.I.I= =trVctxc|jS)zjReturn all plugin config data. Used by mypy to determine if cache needs to be discarded. )rd)rgrs rTreport_config_dataz!PydanticPlugin.report_config_datas   rVcXt||j}|dSr`)PydanticModelTransformerrb transform)rgr transformers rTrwz3PydanticPlugin._pydantic_model_class_maker_callbacks,.sD4FGG rVc|jjrdS|jjj}|s Jdt |jddrd|j_dSdS)zReset dataclass_transform_spec attribute of ModelMetaclass. Let the plugin handle it. This behavior can be disabled if 'debug_dataclass_transform' is set to True', for testing purposes. Nz-callback not passed from 'get_metaclass_hook'dataclass_transform_spec)rbdebug_dataclass_transformclsinfodeclared_metaclassgetattrtyper)rgrinfo_metaclasss rTr}z8PydanticPlugin._pydantic_model_metaclass_marker_callbacksm   7  F8NNNNN~ >&(BD I I @;?N  8 8 8 @ @rVr c:|j}|jddks Jd|jddks Jd|jd}|jd}|r|rt|j|j|S|r3|jdd}|d}t|ts|Sn|r|jdd}t|tr3tdkr|j d}n| d}t|tr|t|j}t|trQ|jrJt!d|jDr,||gt%|jz }|S|S) ax Extract the type of the `default` argument from the Field function, and use it as the return type. In particular: * Check whether the default and default_factory argument is specified. * Output an error if both are specified. * Retrieve the type of the argument which is specified, and use it as return type for the function. rdefaultz0"default" is no longer first argument in Field()rdefault_factoryz9"default_factory" is no longer second argument in Field())ric3@K|]}t|tVdSr`)rsr?)roargs rTrqz:PydanticPlugin._pydantic_field_callback..s,RRSJsK88RRRRRRrV)args)default_return_typecallee_arg_namesr+error_default_and_default_factory_specifiedapicontext arg_typesrsrr:ritemsr7rAret_typer8all copy_modifiedlen) rgrdefault_any_type default_argsdefault_factory_args default_type default_argdefault_factory_typers rTrz'PydanticPlugin._pydantic_field_callbacks2#A&)3335g333#A&*;;;;=x;;;x{ "x{  $0 $ 7 M M M# #  =+A.L&q/Kk<88 $## $" #&=#3A#6 . ;; K%00+?+Ea+H((,@+E+E+G+G+J(. == *+?+HIIx22d dRRHMRRRRRd (553QV2WWc7++++ , ,rVc*fdjDS)Nc2i|]}|t|S)r)rorrgs rT z0PydanticPluginConfig.to_data..s%BBBCWT3''BBBrV)rrgs`rTrczPydanticPluginConfig.to_datasBBBB4>BBBBrV) rrrrr__annotations__r+rfrrrrcrrVrTrarasI#''''####,,D,,,,&Cc3hCCCCCCrVrarcl|j}t|tr|j}t|tr"t|jt r|j}nMt|t r|}n5d|d|jjd}t||j |j |j S|jj t}||j S|did}|dur-t!t#|j|j |j |j S)z3 Raise an error if orm_mode is not enabled z ctx.type: (of type )Nrorm_modeT)rrsr=itemr7rr8rhrerror_unexpected_behaviorrrrmetadatar METADATA_KEYerror_from_ormget_name)rctx_type model_typedetailpydantic_metadatars rTrrs) xH(H%%!=(L))'j9JH.U.U'& Hh ' '' PhPP(2D2MPPP!&#'3;???&&"044\BB && $$Xr2266zBBHtx 00#'3;GGG  ""rVc eZdZUhdZeeed<dededdfdZ d&dZ d&d Z d'd Z d d de d fdZde d dd deddfdZde d ddfdZde d deddfdZdeded fdZededededefdZedeedefdZededeeeeffdZde d ded ed!ede ef d"Zde d dd defd#Z ede d d$edefd%Z!dS)(r>extrafrozenrallow_mutationalias_generatorallow_population_by_field_nametracked_config_fieldsrrbrJNc"||_||_dSr`)_ctxrb)rgrrbs rTrfz!PydanticModelTransformer.__init__)s *rVc|j}|jj}||}||}t d|jddD}||||| || ||j dup|j dud|D| d|jt<dS) a Configures the BaseModel subclass according to the plugin settings. In particular: * determines the model config and fields, * adds a fields-aware signature for the initializer and construct methods * freezes the class if allow_mutation = False or frozen = True * stores the fields, config, and if the class is settings in the mypy metadata for access by subclasses c3FK|]}t|tkVdSr`)rlBASESETTINGS_FULLNAMErns rTrqz5PydanticModelTransformer.transform..=s0``$,t,,0EE``````rVNFT)rcBi|]}|j|Sr)name serialize)rofields rTrz6PydanticModelTransformer.transform..Bs&IIIuz5??#4#4IIIrV)fieldsr)rrradjust_validator_signaturescollect_configcollect_fieldsrurvadd_initializeradd_construct_method set_frozenrrset_values_dictrr)rgrrrr is_settingss rTrz"PydanticModelTransformer.transform-siw| ((***$$&&$$V,,``RVRZ[^\^[^R_`````  VV[999 !!&))) v'<'E'^Z^I^___II&III,,..' '  l###rVcj|jjjjD]\}}t |jtrj|jjd}t |trCt |j tr)|j j tdkrd|jj_dS)a[When we decorate a function `f` with `pydantic.validator(...), mypy sees `f` as a regular method taking a `self` instance, even though pydantic internally wraps `f` with `classmethod` if necessary. Teach mypy this by marking any function whose outermost decorator is a `validator()` call as a classmethod. rz.class_validators.validatorTN)rrrnamesrrsrtroriginal_decoratorsrcalleer ri _NAMESPACEfuncis_class)rgrry first_decs rTrz4PydanticModelTransformer.adjust_validator_signaturesFs+17799 2 2ID##(I.. 2H8; y(332"9#3X>>2"(1 5_5_5___-1CHM* 2 2rVModelConfigDatac|j}|j}t}|jjD]}t |t s|jdkr||jjD]@}t |ts| | |A|j r(|j s!|j jrt|j||jjddD]}t&|jvr|jt-t/||jt&dD]\}}||||S)zz Collects the values of the config attributes that are used by the plugin, accounting for parent classes. ConfigrNr)rrrdefsbodyrsrrrupdateget_config_updatehas_alias_generatorrrbrerror_required_dynamic_aliasesrrrvrradd_plugin_dependencyr5rlr setdefault) rgrrrstmtsubstmtrrvalues rTrz'PydanticModelTransformer.collect_configXsig ""HM B BDdH-- yH$$#y~CCG%g~>>! MM$"8"8"A"ABBBB.B"AB*HB 337DAAAHL$ / /D4=00 G ) )*? T@R@R*S*S T T T#}\:8DJJLL / / e!!$.... / rV model_configPydanticModelFieldc |j}|jj}g}t}|jjD]}t |t s|jd}t |trt|j sP|j s!|j j rt|j||jj|j }||j} t | t(rt | t*s| jr||||} ||\} } | r(|js!|j jrt7|j||t;|j | | | |j|j| |j |!} |jj"ddD]}tF|j$vrg}|j%tMtO||j$tFd(D]\}|vrFt:)||}| ||Ofd| D\}| *||||| z} | S)zR Collects the fields for the model, accounting for parent classes rNr is_requiredaliashas_dynamic_aliaslinecolumnrrc32K|]}|jk |VdSr`)r)roars rTrqz:PydanticModelTransformer.collect_fields..s)HHa4HHrV)+rrsetr r rsrlvaluesr rEr new_syntaxrbrerror_untyped_fieldsrrrrrtr"r* is_classvarget_is_requiredget_alias_inforrrappendrrraddcopyrvrrrr5rlr deserializeremove)rgrrrr known_fieldsrlhsryrtrrr all_fieldsrsuperclass_fieldsdatarrs @rTrz'PydanticModelTransformer.collect_fieldsws iimuu HM5 '5 'DdN33 ,q/Cc8,, N384L4L ? 4t'9'M 4$SWd333 (.$$SX..C{8D$00 dC((  ..sD#>>K'+':':4'@'@ $E$! >$C >&D > /sw=== MM" +&7;       SX & & & &[[]] HL$ 8 8D4=00 "  G ) )*? T@R@R*S*S T T T"mL9(CIIKK 4 4 d|++.::4FFE $$T***%,,U3333HHHH:HHHHU%%e,,,%,,U3333*Z7JJrVrrrc|j}|jj}|jdu}|pt |jo|j }|||||}|||sPtd} | t| ttj dtd|jjjvr t%|d|t'dSdS)z Adds a fields-aware `__init__` method to the class. The added `__init__` will be annotated with types vs. all `Any` depending on the plugin settings. Ttypedforce_all_optional use_aliaskwargsNrf)rrbrrrr get_field_argumentsshould_init_forbid_extrar*r&rr6r<explicitrrrr add_methodr9) rgrrrrr2r4r3init_argumentsvars rTrz(PydanticModelTransformer.add_initializers i"-9E ( D  & Tv/T+T- - 11 %4FR[2  ,,VV<< _h--C  ! !(3 8J0K0KTS\"]"] ^ ^ ^ SW\/ / / sJ C C C C C 0 /rVc  |j}|jtd|jtdg}t |t g}t td||dt}| |ddd}|g|z}|jtd}d }|j j d z|z} td krt|| td krtd |j j dzntd g|tt j} t%|| g|tt j} n%t'|| d g|} t%|| g|} t)t*| |j jj|<t1| tr| } nt| } t3|d|| | | ddS)z Adds a fully typed `construct` classmethod to the class. Similar to the fields-aware __init__ method, but always uses the field names (not aliases), and does not treat settings fields as optional. z.setz.str _fields_setNTFr1z.object_PydanticBaseModelrM)r)r rz .construct) namespace construct) return_type self_typetvar_defis_classmethod)rr named_type BUILTINS_NAMEr@r9rr*rr6rrirr?r>r6r<from_omitted_genericsr)rFr&rrrrsr9) rgrrset_stroptional_set_strfields_set_argumentconstruct_argumentsobj_typeself_tvar_name tvar_fullnametvdself_tvar_exprrDs rTrz-PydanticModelTransformer.add_construct_methodsi'$$ %;%;%;cg>P>PTaQgQgQg>h>h=ijj$gxzz%:;;&s=:J'K'KM]_celmm"66vT^cot6uu236II7%%&?&?&?@@-(3.?  ' '*W44bCG,<|,KLLLL"2 788  C) 788 NN^]BHMMC(HUUN--R-R >* c; ' ' )II#C((I   !      rVrc|j}|jj}|D]S}|j|j}||j}t|tr||_ Ht|tr&|j j s|j  t|}n#t$rt!|}YnwxYwd|d|jd} t%| |j |j||d}||_||_ t)|dzt+|z|_t/t0||jt+|<UdS)z Marks all fields as properties so that attempts to set them trigger mypy errors. This is the same approach used by the attrs and dataclasses plugins. Nzsym_node.node: rrF)r4rM)rrrrrrrtrsr* is_propertyr"rfinal_iterationdeferr TypeErrorreprrhrto_varrlr _fullnamer&r) rgrrrrrsym_noder;var_strrs rTrz#PydanticModelTransformer.set_frozenss iw| G GEz~~ej11H#mc3'' H&,COO_55 Hcg>U HGMMOOOO,"%c(($,,,"&s)),SwRR#-RRRF-fcgswGGGGll45l99"( ,T 2 2S 88C== H ,;D#,F,F 8C==))/ G GsB**CCrc|jd}t|tr|j|jvsdS|jdkrt|jt r|jjdk}nMt|jtr|jjdk}n"t|j|j j |dSt|S|jdkr>d}t|jtr|jj dkrd }t| St|jtr/|jj d vr!td i|j|jj d kiSt|j|j j |dS)z Determines the config update due to a single statement in the Config class definition. Warns if a tracked config attribute is set to a value the plugin doesn't know how to interpret (e.g., an int) rNrforbid) forbid_extrarTz builtins.NoneF)r ) builtins.Truezbuiltins.Falser`r)r rsr rrrvaluer$rrerror_invalid_config_valuerrrri)rgrr,r_r s rTr z*PydanticModelTransformer.get_config_update<sr oa 3)) ch$:T.T.T4 8w  '.'22 &~3x? GNJ77 &~2h> *38TY]GLLLt" === = 8( ( ("& '.(33 ,8OSb8b8b&+#"7JKKK K gnh / / ]GN4KOr4r4r"\\ch0G?0Z%[\\ \"38TY]GDDDtrVrrr,cj|j}t|tr?t|j|jj}t| St|trt|j tr|j j tkrt|j|jD]&\}}||dkr|jt$ucS|dkrdS't|j|jj}t| St|t$S)zg Returns a boolean indicating whether the field defined in `stmt` is a required field. NrrF)rarsr'rArrrrtype_has_implicit_defaultrrr#rirzipr arg_namesrhr)rrr,expr value_typerrs rTr$z(PydanticModelTransformer.get_is_requiredXs$ { dH % % V(#();)@AAJ/II*UUU U dH % % V*T['*J*J Vt{OcguOuOu!DN;; ! ! T<49#4#4=L8888,,, 55-)#();)@AAJ/II*UUU U$ ---rVtype_ct|trdSt|tr td|jDrdSdS)z Returns True if the passed type will be given an implicit default value. In pydantic v1, this is the case for Optional types and Any (with default value None). Tc3jK|].}t|tpt|tV/dSr`)rsr9r6)rors rTrqzEPydanticModelTransformer.type_has_implicit_default..|sL0 0 HLJtX & & C*T7*C*C0 0 0 0 0 0 rVF)rsr6r@rur)ris rTrdz2PydanticModelTransformer.type_has_implicit_defaultrsi eW % % 4 eY ' ' C0 0 PUP[0 0 0 - -  4urVcn|j}t|trdSt|tr/t|jt r|jjtksdSt|j D];\}}|dkr |j |}t|tr |j dfcSdSdS)a  Returns a pair (alias, has_dynamic_alias), extracted from the declaration of the field defined in `stmt`. `has_dynamic_alias` is True if and only if an alias is provided, but not as a string literal. If `has_dynamic_alias` is True, `alias` will be None. )NFrF)NT) rarsr'rrr#rir enumeraterfrr$r)rrgiarg_namers rTr%z'PydanticModelTransformer.get_alias_infos{ dH % % ; tX & & +5dk7+K+K PTP[PdhvPvPv;$T^44 " "KAx7"")A,C#w'' "y%''''!zz{rVr2r3r4cR|jjjfd|D}|S)z Helper function used during the construction of the `__init__` and `construct` method signatures. Returns a list of mypy Argument instances for use in the generated signatures. cTg|]$}r|j |%S))r2force_optionalr4)r to_argument)rorr3rr2r4s rT z@PydanticModelTransformer.get_field_arguments..sU    #("9   d%@R^g  h h   rV)rrr)rgrr2r3r4 argumentsrs ``` @rTr6z,PydanticModelTransformer.get_field_argumentssSy}!          rVc|js*||t|jrdS|jrdS|jjS)aH Indicates whether the generated `__init__` should get a `**kwargs` at the end of its signature We disallow arbitrary kwargs if the extra config setting is "forbid", or if the plugin config says to, *unless* a required dynamic alias is present (since then we can't determine a valid signature). FT)ris_dynamic_alias_presentrr r_rbr)rgrrs rTr7z1PydanticModelTransformer.should_init_forbid_extrasS4 ,,VT&:T5U5UVV u   4!33rVr cF|D] }|jrdS |r|D] }|jdS dS)z Returns whether any fields on the model have a "dynamic alias", i.e., an alias that cannot be determined during static analysis. TNF)rr)rr rs rTrwz1PydanticModelTransformer.is_dynamic_alias_presentsZ   E& tt     ;&44'urV)rJN)rJr)"rrrrr rrr-rarfrrrrrrrrrrrr  staticmethodrr r$r;rdr r%rr6r7rwrrVrTrrs'''3s8+O+R+<RFZA[RRRRhDd+?&@DJ[DjnDswDDDD,8 40D+E8 $8 8 8 8 tG&:!;GTGdGGGGBHEV.sHHHA!-1---rV)rrrs rTrzModelConfigData.set_values_dicts$HH!4!4!6!6HHHHrVrc|dS|D]\}}t|||dSr`)rrr)rgrrrs rTr zModelConfigData.updatesV > F**,,2244  DAq D!Q      rVrrcLt||t|||dSdSr`)rr)rgrrs rTrzModelConfigData.setdefault s2 4   % D#u % % % % % & %rV)NNNNNN) rrrrrrfrrrrr rrrVrTrrs (,)-!%#'9=.277tn7!7 7 4. 7 )1 7&d^7777 Ic3hIIII X&78 T    &c&#&$&&&&&&rVrz pydantic-ormzInvalid from_orm callPydanticzpydantic-configzInvalid config valuezpydantic-aliaszDynamic alias disallowedzpydantic-unexpectedzUnexpected behaviorzpydantic-fieldzUntyped field disallowedzInvalid Field defaults model_namerrcH|d|d|tdS)N"z" does not have orm_mode=Truecode)fail ERROR_ORM)rrrs rTrrs,HH : : : :G)HTTTTTrVrcH|d|d|tdS)NzInvalid value for "Config.rr)r ERROR_CONFIG)rrrs rTrbrbs,HH 1$ 1 1 17HNNNNNrVc@|d|tdS)Nz#Required dynamic aliases disallowedr)r ERROR_ALIASrrs rTrr"s!HH 2G+HNNNNNrVrcbd}d|d}|d|dz }|||tdS)Nz6https://github.com/pydantic/pydantic/issues/new/choosez7The pydantic mypy plugin ran into unexpected behavior:  z&Please consider reporting this bug at z so we can try to fix it!r)rERROR_UNEXPECTED)rrrlink full_messages rTrr&sO DDWVWWWL\T\\\\LHH\7)9H:::::rVc@|d|tdS)NzUntyped fields disallowedr)r ERROR_UNTYPEDrs rTr"r"0s!HH (' HFFFFFrVc@|d|tdS)Nz>Field default and default_factory cannot be specified togetherr)rERROR_FIELD_DEFAULTSrs rTrr4s"HH Mw]qHrrrrrrVFrrCrDrErFis_newc(|jj}||jvrW|j|} | jrCt | jt r)|jjj | j|pt|}|s|r8ttdtj|dtg} n6|pt|}ttd|dtg} | |z}ggg} } } |D]n}|js Jd| |j| t%|j| |jo|jt.d}t1| | | |||r|gnd}t ||t3t5g}||_t7|||_||_t=|dz|z|_|j |_ ||jvr*tC||j}|j||j|<|rwd|_"t||j}||_|j|_d|_#tI|tKd g|}|j |_ tMtN|} ntMtN|} d| _| |j|<|j(jj|dS) z} Adds a new method to a class. This can be dropped if/when https://github.com/python/mypy/issues/7301 is merged _clsN__pydantic_self__z"All arguments must be fully typed.z .function) variablesrMTr))rrrplugin_generatedrsrtrr r r*rBrr*r=make_normalizedrrr&rr~rrrGrHr7rr!r4rrrlrZrrC is_decoratedrFrr r&rdefn)rrrrCrDrErFrrryfirstrrf arg_kindsr function_type signaturerr_namerdecs rTr9r98s 7r?r@rA mypy.typevarsrB mypy.utilrC mypy.versionrD mypy_versionpydantic.v1.utilsrErFrrrrrrmrr|rrrrPrUrrHr\r[rarrrrrrrrrrrrbrrr"rrr9rlrrrrVrTrs` %%%%%%]]]]]]]]]]]]]]]]]]]]]]%%%%%%>! %$$$$$******555555('''''222222444444,,,,,,5%%%%%%%555444444445!' crc] "333%AAA(>>>---":::AAc3hAAAA(' 550H<< .  C0r r r r r Vr r r j"C"C"C"C"C"C"C"CJ#=#T####2llllllll^ """"""""J&&&&&&&&> In&=z J J y*,BJOO i(*DjQQ 924I:VV *,F SS  y!13KZXXUsU)?U'UVZUUUUOSO/NOY`OeiOOOOO(GORYO^bOOOO; ;24SST;_f; ;;;;G=GGTXGGGGs5KsV]sbfssss!%%) P%P% P% P% x.P% P% ~ P% z" P%P% P% P%P%P%P%fE(J./Ch *+CHT#s(^$<sC CC