X-PhdZddlmZddlmZddlmZddlmZddl m Z m Z m Z m Z mZmZmZmZmZmZddlmZmZmZmZddlmZmZmZdd lmZmZdd l m!Z!m"Z"m#Z#m$Z$m%Z%m&Z&m'Z'dd l(m)Z)m*Z*m+Z+m,Z,m-Z-m.Z.m/Z/m0Z0m1Z1m2Z2m3Z3dd l4m5Z5m6Z6m7Z7m8Z8m9Z9dd l:m;Z;mm?Z?m@Z@mAZAmBZBddlCmDZDddlEmFZFmGZGmHZHmIZIddlJmKZKmLZLddlMmNZNddlOmPZPmQZQmRZRddlSmTZTddlUmVZVddlWmXZXddlYmZZZm[Z[ddZ\dd!Z]dd$Z^dd(Z_ ddd3Z`dd6Zadd7Zb ddd@ZcddBZdddEZeddFZfddHZgddIZhd8dJddRZiGdSdTeZjddYZkdd[Zldd]Zmdd_ZnddaZoddfZpddjZqddlZrddoZsddsZtddvZuddwZvddxZwddzZxdd|Zydd}ZzddZ{ddZ|ddZ}d)S)aTransform mypy AST functions to IR (and related things). Normal functions are translated into a list of basic blocks containing various IR ops (defined in mypyc.ir.ops). This also deals with generators, async functions and nested functions. All of these are transformed into callable classes. These have a custom __call__ method that implements the call, and state, such as an environment containing non-local variables, is stored in the instance of the callable class. ) annotations) defaultdict)Sequence) NamedTuple) ArgKindClassDef DecoratorFuncBaseFuncDefFuncItem LambdaExprOverloadedFuncDefTypeInfoVar) CallableTypeType UnboundTypeget_proper_type) LAMBDA_NAMEPROPSET_PREFIX SELF_NAME)ClassIRNonExtClassInfo)FUNC_CLASSMETHOD FUNC_NORMALFUNC_STATICMETHODFuncDeclFuncIR FuncSignature RuntimeArg) BasicBlockGetAttrInteger LoadAddress LoadLiteralRegisterReturnSetAttrUnbox UnreachableValue) RInstancebool_rprimitivedict_rprimitiveint_rprimitiveobject_rprimitive) IRBuildercalculate_arg_defaultsgen_arg_defaults)add_call_to_callable_classadd_get_to_callable_classinstantiate_callable_classsetup_callable_class)FuncInfo)add_vars_to_envfinalize_env_classload_env_registerssetup_env_class)gen_generator_funcgen_generator_func_body)AssignmentTarget)dict_get_method_with_none dict_new_opdict_set_item_op) py_setattr_op)register_function) builtin_names)is_same_method_signature is_same_typebuilderr1fdefr returnNonec2|j||jj}t |||j|\}}|r*|t||||jt||| ||jdSN) mapper fdef_to_sigoptionsstrict_dunders_typing gen_func_itemnameassignget_func_targetlinemaybe_insert_into_registry_dict add_function)rHrIsigfunc_irfunc_regs V/var/www/html/test/jupyter/venv/lib/python3.11/site-packages/mypyc/irbuild/function.pytransform_func_defr]Xs . $ $T7?+P Q QC%gtTYDDGXLw55xKKK#GT222 $),,,,,orcL|jsJ||jdSrM)implaccept)rHr_s r\transform_overloaded_func_defrcds' 6MMM NN16r^decr c|j|j|jj}t ||j|jj|\}}d}|rKt||j|}|t||j||jj nd|j|j vrV|jj dd}|||j }t||j|}|S|t |||jj|g|j t'||j|j|dS)N.)rNrOfuncrPrQrRrSload_decorated_funcrTrUrVfdefs_to_decoratorsfullnamesplitload_global_str primitive_oprBload_globals_dictload_strrW functionsappend)rHrdrYrZr[decorated_funcrS orig_funcs r\transform_decoratorrujsc . $ $SXw/T U UC%gsxLLGX#'N K,WchIIw99>38=YYYY W0 0 0x &&s++B/++D#(;; ,Wch JJ!   & & ( ('*:*:38=*I*I> Z     $GSX666 W%%%%%r^exprr r+c Jt|j|}t|tsJg}t |j|jD]W\}}||j_| t|jj | ||j X| |j}t||}t |j}|xjdz c_t%||||\} } | J|j | | S)N)rtypes isinstancerzip arguments arg_typesvariabletyperrr rS type_to_rtypekindret_typerrlambda_counterrRrq) rHrvtyp runtime_argsargarg_typerfsigfnamerZr[s r\transform_lambda_exprrs* '-- . .C c< ( ((((LT^S];;  X$  s|('*?*?*I*I38 T T    $$S\22H x 0 0D 4G2 4 4E a%gtUDAAGX     W%%% Or^Nfitemr rSstrrYrcdefClassDef | Nonetuple[FuncIR, Value | None]c Dd}|jvpt|t}|jv}|jv}|jvd} t|} d} r&jj j } | j } j } rt|} n|} t|| | t|||| |  }|j}|j|s|rt'|s| rt)|r,t+fd\}}t-||nt/\}}rIj|t|t4sJt7||j |S||fS)aGenerate and return the FuncIR for a given FuncDef. If the given FuncItem is a nested function, then we generate a callable class representing the function and use that instead of the actual function. if the given FuncItem contains a nested function, then we generate an environment class so that inner nested functions can access the environment of the given FuncDef. Consider the following nested function: def a() -> None: def b() -> None: def c() -> None: return None return None return None The classes generated would look something like the following. has pointer to +-------+ +--------------------------> | a_env | | +-------+ | ^ | | has pointer to +-------+ associated with +-------+ | b_obj | -------------------> | b_env | +-------+ +-------+ ^ | +-------+ has pointer to | | c_obj | --------------------------+ +-------+ NF) rrS class_name namespace is_nestedcontains_nested is_decorated in_non_extadd_nested_funcs_to_env)rc .t|||SrM) gen_func_ir)argsblocksfn_inforHris_singledispatchrYs r\zgen_func_item..s!+vsGT;L++r^) nested_fitemsrzr encapsulating_funcskeysrjsingledispatch_implshas_nested_func_self_referencerN type_to_irinfo is_ext_classrSsingledispatch_main_func_namer8 gen_func_ns is_generatorenterrr<r7r=r> gen_func_bodyrqrrr gen_dispatch_func_ir)rHrrSrYrr[rrrrrrir func_namerrrZrs` `` @r\rRrRs#V"H ..O*UJ2O2OIw:??AAAOG77L!==JOPPM  )))%)))))#GUGL$LLL H r^rboolc t|t||jjrt |t |||jjj| |j d}| \}}}}} t||||| ||\} } t|| | || | fS)Nrg)r;r3rrr:r9rbrbodymaybe_add_implicit_return symtablesleaverr2) rHrYrrsymtabler_rrrrZr[s r\rrswW&$7###G NN7?(-... %%''' $H)0&D!VXw#GT63O`aaGX7GXx@@@ H r^ctdj|tDrdStfdj|gDS)zDoes a nested function contain a self-reference in its body? If a nested function only has references in the surrounding function, we don't need to add it to the environment. c3@K|]}t|tVdSrM)rzr ).0syms r\ z1has_nested_func_self_reference..3s, Y Y:c8 $ $ Y Y Y Y Y Yr^Tc38K|]}t|VdSrM)r)rnestedrHs r\rz1has_nested_func_self_reference..5sA  'w77r^)anyfree_variablesgetsetr)rHrs` r\rr-s  Y Y0F0J0J5RURWRW0X0X Y Y YYYt 155eR@@  r^Frlist[Register]rlist[BasicBlock]rr8is_singledispatch_main_funcc d}|js|jr4t|||||}t||t ||}nt |jtsJ|jj |j} |j s|rb|dn|j } t|j | |j || j| j| j} t#| |||jj|jj }n(t#| |||jj|jj }||fS)aGenerate the FuncIR for a function. This takes the basic blocks and function info of a particular function and returns the IR. If the function is nested, also returns the register containing the instance of the corresponding callable class. N)traceback_name)rrr4r5r6rzrr rN func_to_declrrSr module_nameris_prop_getteris_prop_setterrrV) rHrrrYrrrr[rZ func_declrs r\rr;s5 "HG.,WdFCQQ!'7333-gw??'-11111N/ >   #> !%49J  #((I4);GML^GG4);GML^G X r^rc |j}|jj|j}|j||jj}t|||||\}}|j |t||r|j d\}}}| |j } || ||j} t!||| } |t$| ||| g|j|jr||jvsJ|df|j|<n0||jvr'||jvsJ|j|\} }| |f|j|<||j|jj<|jddD]} || jvr|dkrzt7|j|j| j|jsJt;|| j|j||| |}||j| |f<|j ||jrCt;||j||||d}||j||f<|j |dSdS)Nrfrx__init__T do_py_ops) rSrNrrrOrPrQrRrqrrrrk rpartitionload_native_type_object py_get_attrrVrirnrCrp is_property properties prop_settersmethodsdeclmro method_declsrFrYgen_glue glue_methodsallow_interpreted_subclasses)rHrrIrSclass_irrYrZr[rrrtrs getter_irbasefs r\handle_ext_methodrhs 9D~(3H . $ $T7?+P Q QC%gtT3EEGX W%%%GT"" ]--c22 1d--dm<<''T49== -WdIFF  C!1!1$!7!7H$)     98.....%,dOD!! % % %x******40 1%.$8D!*1HW\&' QRR (( D% % % "",%d+/1B41H1L#$"3D"9"=wRVX\]]A23H !4, /   $ $Q ' ' ' ,$ Wgk7HhX\ ] ] ]23x./  #####$$r^non_extrc(|j}|j||jj}t |||||\}}|J|j|t||r|}t|||}|j r9| d|j } | | |g|j }n|jj|jt kr9| d|j } | | |g|j }nX|jj|jt"kr8| d|j } | | |g|j }|||||j dS)Nzbuiltins.propertyzbuiltins.classmethodzbuiltins.staticmethod)rSrNrOrPrQrRrqrrrrirload_module_attr_by_fullnamerVpy_callrrrradd_to_non_ext_dict) rHrrrIrSrYrZr[rtpropcls_meth stat_meths r\handle_non_ext_methodrs 9D . $ $T7?+P Q QC%gtT3EEGX     W%%%GT""A &wi@@  E334GSS??4(TY??  $T * /3C C C778NPTPYZZ??8hZCC  $T * /3D D D889PRVR[\\ ??9xj$)DD xCCCCCr^cJdd|jDS)zJGenerate a namespace for a nested function using its outer function names.rc3pK|]1}|jr(|jdk|j|jsdn d|jzzV2dS)zrN)rSr)rrs r\rzgen_func_ns..s`  9j00 tIRRC$/4IJ0000r^)joinfn_infos)rHs r\rrs7 88$  r^ orig_func_regct||s|S|j|}|}t|D]P}||j}t |t sJ|||g|j}Q|S)zApply decorators to a function. Given a decorated FuncDef and an instance of the callable class representing that FuncDef, apply the corresponding decorator functions on that decorated FuncDef and return the decorated function. ) rrjreversedrbvisitorrzr+rrV)rHrIr decoratorsr[d decorators r\riris  & &,T2JH j ! !IIHHW_-- )U+++++??9xj(-HH Or^c||jvSrM)rjrHrIs r\rrs 7. ..r^rbase_sigtargetrclsrrrc x|jrt||||||j|St||||||j|S)ayGenerate glue methods that mediate between different method types in subclasses. Works on both properties and methods. See gen_glue_methods below for more details. If do_py_ops is True, then the glue methods should use generic C API operations instead of direct calls, to enable generating "shadow" glue methods that work with interpreted subclasses. )rgen_glue_propertyrVgen_glue_method)rHrrrrrIrs r\rrsJ& [ (FCtyR[\\\w&#tTYPYZZZr^c.eZdZUded<ded<ded<dS)ArgInfoz list[Value]rzlist[str | None] arg_namesz list[ArgKind] arg_kindsN)__name__ __module__ __qualname____annotations__r^r\rrs6r^rrt_argsSequence[RuntimeArg]rVintcd|D}fd|D}d|D}d|D}t|||S)NcDg|]}t|j|jfSr)rrSrrrs r\ zget_args..s'>>>s#ch--*>>>r^c ng|]1\}}||d2S)T)is_arg)read add_local_reg)rvarrrHrVs r\rzget_args..sP    C  W**3T*BBDII   r^cg|]D}|js |jr|js|jndESrM)ris_named is_optionalpos_onlyrSr s r\rzget_args..s\ H%%''bCH,@,@,B,Bb3<b^br^cg|] }|j Sr)rr s r\rzget_args..s---c---r^)r)rHrrV fake_varsrrrs` ` r\get_argsr s>>g>>>I     "   DI.-W---I 4I . ..r^ do_pycallc t|||jj|||j|jd<t |j}|jjtkr0t|jdj t||d<t|||}|j|j|j} } } d} |jrW| d|j } | d|j } | d|j } t |jj|j d} t%d| Dr*t%d|jjjDrd}|ry|jjt&kr|j|} d}n | d} d}|j| |j | |d|| |d| |d}n%|j|j| | | || }|||j|}|t3||\}}}}}|jr|d|j }t7t9|j d z|j zd z|j |jt=|||jj||S) aUGenerate glue methods that mediate between different method types in subclasses. For example, if we have: class A: def f(builder: IRBuilder, x: int) -> object: ... then it is totally permissible to have a subclass class B(A): def f(builder: IRBuilder, x: object) -> int: ... since '(object) -> int' is a subtype of '(int) -> object' by the usual contra/co-variant function subtyping rules. The trickiness here is that int and object have different runtime representations in mypyc, so A.f and B.f have different signatures at the native C level. To deal with this, we need to generate glue methods that mediate between the different versions by coercing the arguments and return values. If do_pycall is True, then make the call using the C API instead of a native call. rgrNc3>K|]}|VdSrM)is_star)rrs r\rz"gen_glue_method..Rs* 0 0d4<<>> 0 0 0 0 0 0r^c3JK|]}|j VdSrM)rrr s r\rz"gen_glue_method..RsD99#&CH    999999r^Trx) bitmap_args___glue)check_native_overriderrYrr ret_typeslistrrrr rSr,rrrnum_bitmap_argsrHrrget_native_typepy_method_callcallcoerceaddr'rrrrr)rHrrrrrVrrarg_inforrrr firststretvalarg_regsrrrs r\rrsD'8V[_dCCC MMOOO$-Gb8=!!G {;&& a 0 5y~~FF $//H!)0BHDVY)DKN/x///09!9 99: 9!9 99: 7?/1I0I0K0KLMM  0 0i 0 0 000S99*0+/*>99966  ; 0 0 0O33C88EBBGEB// 6;RSS 4233233  %% Ky)T{&  ^^FH$5t < V  ,_(-___` = & ',*D  w|<<  1Q',QQ QQQRr^ do_pygetattrc |ttt|}||}|||} |j|jd<|r|| |j |} n)| t| |j |} | | |j|} | t| |\} } }}} tt!|j dz|j zdz|j |jt%|g|| |S)aGenerate glue methods for properties that mediate between different subclass types. Similarly to methods, properties of derived types can be covariantly subtyped. Thus, properties also require glue. However, this only requires the return type to change. Further, instead of a method call, an attribute get is performed. If do_pygetattr is True, then get the attribute using the Python C API instead of a native call. rgr!r")rr rr,add_self_to_envrrr$rrSr+r"r*r'rrrrr)rHrYrrrrVr:rt_arg self_targetrr/retboxrrr return_types r\rrs;$ MMOOO  9S>> 2 2F))#..K ,,{D ) )CLGb>$$S&+t<<WS&+t<<== ^^FCL$ 7 7F KKv&-mmoo#D!V[!  K$  *W 4 H   6(K 0 0      r^r?c|jr||jS|jjs |jjr||S||t S)zGiven a FuncDef, return the target for the instance of its callable class. If the function was not already defined somewhere, then define it and add it to the current environment. ) original_deflookuprrrrr0rs r\rUrUsf  1~~d/000#$w'N$~~d###  '8 9 99r^rrunbounded_type Type | Nonec. t|tr|jn|jd|j ||jjvr.|jj|}|j|}n|jtvr:t|j\}}| t|||}nt fd|j Ddtx}r||} |kr+ |ddngD]} || | |} |j| |jt(|d}n||j|}|S)Nrfc3XK|]$}|ks|d |V%dS)rfN) startswith)riload_attr_paths r\rzload_type..sJaaq~':':n>W>W[\X_X_X_>`>`':':':':':aar^r)defaultkeyF)borrow)rzrrSrk removesuffixrNrrHr'rEr+r$maximportslen load_module removeprefixrlrget_attrr0rm) rHrrDrVr class_objbuiltin_addr_typesrcr loaded_moduleattrrJs @r\ load_typerZs *.+FFXCLl>sx>>"" gn'''>,S1O33H==  & &!.s|!<3KK ,=sD I IJJ aaaaGOaaa  <  ++K88 ,,  ' ';(9(9(9 : : @ @ E E E K KD $// tTJJMMO,, 38%6U-  ++CHd;; r^rrk str | Nonec|rb||jsH|dd}||}||||}n|||}|S)Nrfr)rHcurrent_modulersplitrRrrm)rHrrkrVmodulerXrhs r\ load_funcr`s 8++G,BCC 8 %%a(++F33 ""=)TBB&&y$77 Kr^!main_singledispatch_function_namecr|j}|jj|}t||jj|}|}|j|jd|}|j |dt|}ttt} } } | t||g|} || |d|} t!t"}|| | | || ||| ||| || |d|}t/|||}||||g|}| t2|||g||||||| || t5|||||dS)Nrdispatch_cachezis notzfunctools._find_impl)rVrNrrrYrselfrHget_type_of_objrTr.r!rnr@translate_is_op none_objectr&r0add_bool_branchactivate_blockrTgotorload_singledispatch_registryrrBgen_calls_to_correct_impl)rHrarrVcurrent_func_declr,dispatch_func_objrrccall_find_impl use_cache call_func get_result is_not_none impl_to_use find_implregistry uncached_impls r\)generate_singledispatch_dispatch_functionrxs :D3E:!2!6!;TBBH ..x}Q/?FFH_--+_dN,6<<z||yIN%%&?.RZA[]abbJ))*g6I6I6K6KXW[\\K,--K KNCCC 9%%% NN; D111 LL >***445KTRRI+G5FMMHOOI(/CTJJM )NHm+TVZ[[[ NN; t444 LL 9%%%g{HeTJJJJJr^rtr,cjj|dfd }td\}}t ||}j||} tt} } | | |  | t|t} t|} | D]\}}tt}}|}| |d}||| ||| |t! | |jjj}|jj}t1|dS) NrIr rJrKc jj|}j|jjj}|jj } t|dSrM) rNrrHr)rrrr*rYrr+r')rIrret_valcoercedr,rHrmrVs r\gen_native_func_call_and_returnzBgen_calls_to_correct_impl..gen_native_func_call_and_return>sxN/5 /&& x}h&8(:Ld  ..*;*?*H$OO F7OO$$$$$r^z builtins.intz==)rIr rJrK)rNrrEr+r$rH type_is_opr!rhrir)r/get_native_impl_idsitemsload_int binary_opr*rrrrr*rYrr')rHrtr,rrVr}rrW int_type_objis_int native_callnon_native_call passed_id native_idsrarI call_impl next_impl current_idcondr{r|rms` ` ` @r\rlrl9s4 3E:%%%%%%%%%^,HC;;{3T::;;L _ ' ' \4 H HF#-<<K FKAAA ;''' E+~tDDEEI$We44J##%% * *a)||Z\\9 %%a((   JdCCi;;; y)))''---y)))) KK  ?+++ooX]D(*PGnnW&7&;&DdKKG KKw     r^main_func_name dispatch_nametuple[FuncIR, Value]c|t||t|t|jjjjd<t|jjjjd<d|jjj_d|jjj_ t|t|||| \}}}}}t|||||} |j| t!||t#||t%||} t'||| j|} | | fS)zCreate a dispatch function (a function that checks the first argument type and dispatches to the correct implementation) rvrcT)rr8r7r.rcallable_classr attributeshas_dictneeds_getseters+generate_singledispatch_callable_class_ctorrxrr4rqrrr5%add_register_method_to_callable_classr6&generate_dispatch_glue_native_functionr) rHrrrrYrrrrdispatch_callable_classr[dispatch_func_irs r\rris:  MM(5-00111!!!?NGO"%0 &u -D55H  hm +D!H$66I"I Qo""#6iTXYYG KKw   &-mmoo#HaG $& ) ))r^c nd}|jjj}||dt5|t g|}|t| d|||t g|}| d}| t| ||g||ttdt||ddddS#1swxYwYdS)zGCreate an __init__ that sets registry and dispatch_cache to empty dictsrgrrvrcrxN)rrr enter_methodr-call_crAr+r(rdrprnrCr'r#)rHrVr empty_dict cache_dictdispatch_cache_strs r\rrs] D-0H   h O D DEE^^KT::  GGLLNNJ DIIJJJ^^KT:: $--.>??]W\\^^=OQ[,\^bccc F71ot<>@@== 5#( = = M4}}I&--m<<< = :"  6uzBB!'>5>4PP $AABSUYZZ114F 3V2WY]^^ #33EJEE -w/?/? /K/K][]a   '2&7&7&9&9II"U)2EFF  " "!'5:u~tLLII#E*J&z3DEEL L11I% (-/B/KT  09JDQQ ] ]C#GS$==K  !1Hk93UW[ \ \ \ \ 11 /$   T4HHHH+IIr^rdict[FuncDef, int]cTj|}fdt|DS)zgReturn a dict of registered implementation to native implementation ID for all implementations cBi|]\}\}}t|||Sr)r)rrIrrarHs r\ z'get_native_impl_ids..s3 ^ ^ ^;C,wX\B]B] ^D! ^ ^ ^r^)r enumerate)rHrrs` r\rrs5  ()< =E ^ ^ ^ ^)E*:*: ^ ^ ^^r^ris_traitc|j}|||d|jjdj}|sJ|j|||jjd}| t|n!| t| \}}} } } t||| S)zGenerate an implicit trivial property getter for an attribute. These are used if an attribute can also be accessed as a property. rdrrg)rSrrrYrrrHrTrr+r'r*rr) rHrrrrSself_regvaluerrrrrs r\gen_property_getter_irrs >D MM$##FIM,>q,A,FGGH #((49OQSTT F5MM"""" KMM""")0&D!VXw )T6 * **r^cb|j}|||d|jjdj}|d|jjdj}|tsJ|ttd}|s%| t|||d| t| | \}} } } } t||| S)zGenerate an implicit trivial property setter for an attribute. These are used if an attribute can also be accessed as a property. rdrrrxNrg)rSrrrYrrrHrrQr+r(r'nonerr) rHrrrrSr value_reg attr_namerrrrrs r\gen_property_setter_irrs >D MM$##FIM,>q,A,FGGH$$Wim.@.C.HIII ??> * ****S((**+I A GHiB??@@@ KKw||~~&&''')0&D!VXw )T6 * **r^)rHr1rIr rJrK)rHr1r_rrJrK)rHr1rdr rJrK)rHr1rvr rJr+rM) rHr1rr rSrrYrrrrJr) rHr1rYrrrrrrJr)rHr1rr rJr)F)rHr1rrrrrYrrr8rrrrrJr)rHr1rrrIr rJrK) rHr1rrrrrIr rJrK)rHr1rJr)rHr1rIr rr+rJr+)rHr1rIr rJr)rHr1rrrrrrrrrIr rrrJr)rHr1rr rVr rJr)rHr1rrrrrrrrrVr rrrJr) rHr1rrr1rrVr rJrK)rHr1rYrrrrrrrrVr r:rrJr)rHr1rIr rJr?) rHr1rrrDrErVr rJr+) rHr1rrrkr[rVr rJr+)rHr1rarrr rJrK) rHr1rtr+r,rrr rVr rJrK) rHr1rr rrrrrYrrJr) rHr1rr rrrrrJr)rHr1rJrK)rHr1rr8rJrK)rHr1rnr+rVr rJr+)rrrJr)rHr1rr rJrK)rHr1rr rJr) rHr1rrrrrrrJr)~__doc__ __future__r collectionsrcollections.abcrtypingr mypy.nodesrrr r r r r rrr mypy.typesrrrr mypyc.commonrrrmypyc.ir.class_irrrmypyc.ir.func_irrrrrrrr mypyc.ir.opsr!r"r#r$r%r&r'r(r)r*r+mypyc.ir.rtypesr,r-r.r/r0mypyc.irbuild.builderr1r2r3mypyc.irbuild.callable_classr4r5r6r7mypyc.irbuild.contextr8mypyc.irbuild.env_classr9r:r;r<mypyc.irbuild.generatorr=r>mypyc.irbuild.targetsr?mypyc.primitives.dict_opsr@rArBmypyc.primitives.generic_opsrCmypyc.primitives.misc_opsrDmypyc.primitives.registryrEmypyc.sametyperFrGr]rcrurrRrrrrrrrirrrrrr#rrUrZr`rxrlrrrrrkrrWrrrrr^r\rs  #"""""######$$$$$$                        HGGGGGGGGGGG??????????66666666                          VUUUUUUUUU +***** POOOOOOO222222^^^^^^^^^^666666777777333333AAAAAAAA - - - - &&&&>>! nnnnnb2    *).*****Z@$@$@$@$FDDDD>,////[[[[[[2j / / / /[[[[|:))))X : : : :*,,,,^     K K K KF-!-!-!-!`&&&&8****& E E E E++++ZZZZAAAA.I.I.I.Ib____++++&++++++r^