NL i3LdZddlmZddlmZddlmZddlmZddl m Z m Z m Z m Z mZmZmZmZmZmZddlmZmZmZmZddlmZmZmZmZdd lmZm Z dd 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/m0Z0m1Z1m2Z2m3Z3m4Z4dd l5m6Z6m7Z7m8Z8m9Z9m:Z:dd l;mZ>ddl?m@Z@mAZAmBZBmCZCddlDmEZEddlFmGZGmHZHmIZImJZJddlKmLZLmMZMddlNmOZOddlPmQZQmRZRmSZSddlTmUZUddlVmWZWddlXmYZYddlZm[Z[m\Z\d>dZ]d?dZ^d@dZ_dAdZ` dB dCdZa dDdZbdEd Zc dF dGd!ZddHd"Ze dId#ZfdJd$ZgdKd%ZhdLd&Zidd' dMd(ZjGd)d*eZkdNd+Zl dOd,Zm dPd-Zn dQd.ZodRd/ZpdSd0ZqdTd1Zr dUd2Zs dVd3Zt dWd4Zu dXd5ZvdYd6ZwdZd7Zxd[d8Zyd\d9Zzd]d:Z{d^d;Z| d_d<Z} d_d=Z~y)`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) FAST_PREFIX 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_opexact_dict_set_item_op) py_setattr_op)register_function) builtin_names)is_same_method_signature is_same_typec<|jj||jj}t |||j |\}}|r'|j t||||jt|||j||jyN) mapper fdef_to_sigoptionsstrict_dunders_typing gen_func_itemnameassignget_func_targetlinemaybe_insert_into_registry_dict add_function)builderfdefsigfunc_irfunc_regs \/mnt/ssd/data/python-lab/Trading/venv/lib/python3.12/site-packages/mypyc/irbuild/function.pytransform_func_defr\\sy .. $ $T7??+P+P QC%gtTYYDGXw5xK#GT2 $)),cV|jsJ|j|jyrJ)implaccept)rVos r[transform_overloaded_func_defrbhs 66M6 NN166r]cz|jj|j|jj}t ||j|jj |\}}d}|rSt||j|}|jt||j||jjns|j|jvr[|jjjdd}|j||j}t||j|}|U|jt |j#|j%|jj |g|jt'||j|j(j+|y)N.)rKrLfuncrMrNrOrPload_decorated_funcrQrRrSfdefs_to_decoratorsfullnamesplitload_global_strcall_crCload_globals_dictload_strrT functionsappend)rVdecrXrYrZdecorated_funcrP orig_funcs r[transform_decoratorrtnsI .. $ $SXXw/T/T UC%gsxxLGX#'N,WchhIw9>388==Y W00 0xx  &&s+B/++D#((; ,Wchh J! "  & & ('*:*:388==*I> Z    $GSXX6 W%r]c lt|j|}t|tsJ|g}t |j |j D]_\}}||j_|jt|jj|j||ja|j|j}t||}t |j"}|xj"dz c_t%||||\} } | J|j&j| | S)N)rtypes isinstancerzip arguments arg_typesvariabletyperpr!rP type_to_rtypekindret_typer rlambda_counterrOro) rVexprtyp runtime_argsargarg_typerfsigfnamerYrZs r[transform_lambda_exprrs '--- .C c< (-#- (LT^^S]]; X$  s||(('*?*?*I388 T  $$S\\2H x 0DmG223 4E a%gtUDAGX    W% Or]NFc d}|jvxst|t}|jj v}|j v} |j vd} t|} d} rAjjj} | j xr| } j} r t|}n|}t||| t||| | |  }|j }j#|j$|s|r%j&j)s t+|s| r t-|r#t/fd\}}t1||nt3\}}rKj4j7|t|t8sJ|t;||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) fitemrP class_name namespace is_nestedcontains_nested is_decorated in_non_extadd_nested_funcs_to_env)rc &t|||SrJ) gen_func_ir)argsblocksfn_inforVcdefis_singledispatchrXs r[zgen_func_item..s+vsGT;L+r]) nested_fitemsrxr encapsulating_funcskeysrhsingledispatch_implshas_nested_func_self_referencerK type_to_irinfo is_ext_classrPsingledispatch_main_func_namer9 gen_func_ns is_generatorenterrr#can_merge_generator_and_env_classesr=r8r>r? gen_func_bodyrorpr gen_dispatch_func_ir)rVrrPrXrmake_ext_methodrZrrrrrrir func_namerrrYrs` `` @r[rOrOsX"H ...O*UJ2OIw::??AAOG777L!=!==JOP  )%)050)#GUGLL$LL H r]c t|t||jjr t |t ||j |jjj|j|jd}|j\}}}}} t||||| ||\} } t|| | || | fS)Nre)r<r4rrr;r:r`rbodymaybe_add_implicit_return symtablesleaverr3) rVrXrrsymtabler_rrrrYrZs r[rrswW&&7#G NN7??((--. %%'  $H)0&D!VXw#GT63O`aGX7GXx@ H r]ctdjj|tDrytfdjj|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|tywrJ)rxr ).0syms r[ z1has_nested_func_self_reference..:s Y:c8 $ YTc36K|]}t|ywrJ)r)rnestedrVs r[rz1has_nested_func_self_reference..<s   'w7s)anyfree_variablesgetsetr)rVrs` r[rr4sZ  Y0F0F0J0J5RURW0X YY 1155eR@ r]c d}|js |jr+t|||||}t||t ||}||fS|j } t | tsJ| |jj| } |rZ|jt| jzk(r:|jj|jj|j} |js|r{|dn |j} t!|j| |j"|| j$| j&| j(} t+| ||| j,| j}||fSt+| ||| j,| j}||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)rrr5r6r7rrxr rK func_to_declrPrrr method_declsrr module_nameris_prop_getteris_prop_setterrrS) rVrrrXrris_singledispatch_main_funcrZrYr func_declrs r[rrBsk "HG..,WdFCQ!'73-gw?, X ) %)050)NN//6 GLLK)..$@@11$))<II',,WI   #>!%499J  ##((((IYfejjQVQ[Q[\G X YfejjQVQ[Q[\G X r]c |j}|jj|j}|jj ||j j }t|||||\}}|jj|t||r|jjd\}}}|j|j} |j| ||j} t!||| } |j#t$| |j'|| g|j|j(r"||j*vsJ|df|j*|<nA||j,vr3||j*vsJ|j*|\} }| |f|j*|<||j.|j0j<|j2ddD]} || j4vs|dk7st7|j4|j8| j4|j8rSt;|| j4|j8||| |}||j<| |f<|jj||j>rIt;||j8||||d}||j<||f<|jj|yy)Nrdrv__init__T do_py_ops) rPrKrrrLrMrNrOrorprri rpartitionload_native_type_object py_get_attrrSrg primitive_oprDrn is_property properties prop_settersmethodsdeclmrorrGrXgen_glue glue_methodsallow_interpreted_subclasses)rVrrWrPclass_irrXrYrZrrrsrr getter_irbasefs r[handle_ext_methodros 99D~~((3H .. $ $T7??+P+P QC%gtT3EGX W%GT"]]--c2 1d--dmm<''T499= -WdIF  C!1!1$!7H$))  8.....%,dOD! %% %x*******40 1%.$8D!*1HW\\&&' QR ( D%% % ",%%d+//1B1B41H1L1L$"3"3D"9"="=wRVX\]A23H ! !4, /    $ $Q '((,, Wgkk7HhX\ ]23x./  #-r]cv|j}|jj||jj}t |||||\}}|J|j j|t||r|}t|||}|jr;|jd|j} |j| |g|j}n|jj|jt k(r;|jd|j} |j| |g|j}nd|jj|jt"k(r:|jd|j} |j| |g|j}|j%||||j|jj&|j(} t*|jz}|| j,vr?t |||||d\}}|| j.|<|j j|yy)Nzbuiltins.propertyzbuiltins.classmethodzbuiltins.staticmethodT)r)rPrKrLrMrNrOrorprrgrload_module_attr_by_fullnamerSpy_callrrrradd_to_non_ext_dictrrrrr) rVnon_extrrWrPrXrYrZrspropcls_meth stat_methrs r[handle_non_ext_methodrs 99D .. $ $T7??+P+P QC%gtT3EGX    W%GT" &wi@ 334GS??4(TYY?  $ $T * / /3C C778NPTPYPYZ??8hZC  $ $T * / /3D D889PRVR[R[\ ??9xj$))D xC~~((3H  "D x$$$)'4sDZ^_!(  )%r]cFdjd|jDS)zJGenerate a namespace for a nested function using its outer function names.rc3K|]I}|jr;|jdk7r,|j|jsdnd|jzzKyw)zrN)rPr)rrs r[rzgen_func_ns..sD  99j0 tRC$//4IJsAA)joinfn_infos)rVs r[rrs& 88$$ r]ct||s|S|j|}|}t|D]R}|j|j}t |t sJ||j||g|j}T|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. ) rrhreversedr`visitorrxr,rrS)rVrW orig_func_reg decoratorsrZd decorators r[rgrgs  &,,T2JH j !IHHW__- )U+6Y6+??9xj(--HI Or]c||jvSrJ)rhrVrWs r[rrs 7.. ..r]rc |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_propertyrSgen_glue_method)rVbase_sigtargetclsrrWrs r[rrsE&  (FCtyyR[\\w&#tTYYPYZZr]c,eZdZUded<ded<ded<y)ArgInfoz list[Value]rzlist[str | None] arg_namesz list[ArgKind] arg_kindsN)__name__ __module__ __qualname____annotations__r]r[rrs r]rc |Dcgc]#}t|j|jf%}}|Dcgc])\}}|j|j ||d|+}}}|Dcgc]P}|j j s&|j jr|js |jndR}}|Dcgc]}|j } }t||| Scc}wcc}}wcc}wcc}w)NT)is_arg) rrPr}read add_local_regris_named is_optionalpos_onlyr) rVrt_argsrSr fake_varsvarr}rrrs r[get_argsrs6=>s#chh-*>I>#  C  W**3T*BDI D   HH%%'CHH,@,@,B3<<^bbI&--c-I- 4I ..? .s(C&.C+)AC1C6c t|||jj||j|j|j d<t |j}|jjtk(r/t|jdjt||d<t|||}|j|j|j} } } d} |j r]| d|j } | d|j } | d|j } t |j"j|j d} t%d| Dr2t%d|jjjDrd}|rv|jjt&k(r|j"j)|} d}n| d} d}|j"j+| |j| |d|| |d| |d}n+|j"j-|j| | | || }|j/||j|}|j1t3||j5\}}}}}|j r|d|j }t7t9|jd z|jzd z|j|j:t=|||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. rerNc3<K|]}|jywrJ)is_star)rrs r[rz"gen_glue_method..bs 0d4<<> 0rc3RK|]}|jj !ywrJ)rr)rrs r[rz"gen_glue_method..bs%9#&CHH   9s%'Trv) bitmap_args___glue)check_native_overriderrXrr ret_typeslistrrrr!rPr-rrrnum_bitmap_argsrVrrget_native_typepy_method_callcallcoerceaddr(rrrrr )rVrrrrrS do_pycallr arg_inforrrrfirststretvalarg_regsrrrs r[rr+sD'8V[[__dC MMO$--Gb8==!G {{;& a 0 5 5y~F $/H!)0B0BHDVDVY)DK/x///09!9!9 9: 9!9!9 9: 7??//1I1I0I0KLM  0i 00S9*0++//*>*>96  ;;  0 0OO33C8EBGEB// 6;;RS 42323 %% KKy)T{& ^^FH$5$5t V>V ,(--(^_` == & &',,*D*D w||< 1',,'? bQRr]c |jttt|}|j |}|j ||} |j |jd<|r|j| |j|} n&|jt| |j|} |j| |j |} |jt| |j\} } }}} tt!|jdz|jzdz|j|j"t%|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. rerr)rr!rr-add_self_to_envrrrrrPrr#rr(rrrrr )rVrXrrrrS do_pygetattrrt_arg self_targetrr$retboxrrr return_types r[rrs$ MMO  9S> 2F))#.K ,,{D )CLLGb$$S&++t<WS&++t<= ^^FCLL$ 7F KKv&-mmo#D!V[!  KK$  *W 4 HH    6(K 0    r]c|jr|j|jS|jjs|jjr|j|S|j |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_deflookuprrrrr1rs r[rRrRs^  ~~d//00##w'N'N~~d##  '8 99r]cD t|tr |jn |jj d|j ||j j vr6|j j |}|jj|}|S|jtvr4t|j\}}|jt|||}|St fd|jDdtx}r|j|} |k7r# j!|dj#dngD]} |j%| | |} |jj'| |jt(|d}|S|j+|j|}|S)Nrdc3VK|] }|k(sj|ds|"yw)rdN) startswith)riload_attr_paths r[rzload_type..s/aq~':n>W>W[\Z]]^X_>`as))r)defaultkeyF)borrow)rxrrPri removesuffixrKrrVrrFrr%maximportslen load_module removeprefixrjrget_attrr1rk) rVrunbounded_typerSr class_objbuiltin_addr_typesrcr loaded_moduleattrr=s @r[ load_typerNs *.+FCLLlQsxxj>" gnn'''>>,,S1OO33H= 4 3  &!.s||!<3KK ,=sD IJ . +aGOOa     ++K8 ,  ' ';-q(9 : @ @ E KD $// tTJM  K OO,, 388%6U- ++CHHd; r]c|rU|j|js:|jdd}|j|}|j |||}|S|j ||}|S)Nrdr)r;current_modulersplitrErrk)rVrrirSmodulerLrfs r[ load_funcrSsq++G,B,BC %a(++F3 ""=)TB K&&y$7 Kr]c|j}|jj|}t||jj |}|j }|jj|j d|}|jj|dt|}ttt} } } |jt||g|} |j| |jd|} t!t"}|j%| | | |j'| |j)|| ||j+| |j'| |j-d|}t/|||}|j1|||g|}|j3t4|||g||j)||||j+| |j'| t7|||||y)Nrdispatch_cachezis notzfunctools._find_impl)rSrKrrrXrselfrVget_type_of_objrGr/r"rrAtranslate_is_op none_objectr'r1add_bool_branchactivate_blockrQgotorload_singledispatch_registryrrlrCgen_calls_to_correct_impl)rV!main_singledispatch_function_namerrScurrent_func_declr!dispatch_func_objrrUcall_find_impl use_cache call_func get_result is_not_none impl_to_use find_implregistry uncached_impls r[)generate_singledispatch_dispatch_functionrk&s ::D33E:!2!6!6!;!;TBH ..x}}Q/?FH__--+_dN,6<z|yIN%%&?.RZA[]abJ))*g6I6I6KXW[\K,-K KNC 9% NN; D1 LL >*445KTRI+G5FMHOOI(/CTJM NN)NHm+TVZ[ NN; t4 LL 9%g{HeTJr]cjj|dfd }td\}}jt ||}j j ||} tt} } j| | | j| jt|t} t|} | jD]{\}}tt}}j|}j| |d}j|||j|||j|}jt!j| j#|j$j&j(}j+|j,j.}jt1|y)Nc4jj|}jj|jj j }j|jj}jt|yrJ) rKrrVrrrrrrXrrr()rWrret_valcoercedr!rVr`rSs r[gen_native_func_call_and_returnzBgen_calls_to_correct_impl..gen_native_func_call_and_returnNswNN//5 //&& x}}h&8&8(:L:Ld ..*;*?*?*H*H$O F7O$r]z builtins.intz==)rWr returnNone)rKrrFrr%rV type_is_opr"rZr[r*r0get_native_impl_idsitemsload_int binary_opr+rrrrrrXrr()rVrgr!rrSrprrK int_type_objis_int native_callnon_native_call passed_id native_idsr_r< call_impl next_impl current_idcondrnror`s` ` ` @r[r^r^Is 33E:%%^,HC;;{3T:;L __ ' ' \4 HF#-<K FKA ;' E+~tDEI$We4J##% *a)|Z\9 %%a(   JdCi; y)'-y) * KK  ?+ooX]]D(*<*P>PGnnW&7&;&;&D&DdKG KKw r]c|jt||t|t|jj j jd<t|jj j jd<d|jj j _d|jj j _ t|t||||j\}}}}}t|||||} |jj| t!||t#||t%||} t'||| j(|} | | fS)zCreate a dispatch function (a function that checks the first argument type and dispatches to the correct implementation) rirUT)rr9r8r/rcallable_classr attributeshas_dictneeds_getseters+generate_singledispatch_callable_class_ctorrkrr5rorpr6%add_register_method_to_callable_classr7&generate_dispatch_glue_native_functionr) rVrmain_func_name dispatch_namerXrrrrdispatch_callable_classrZdispatch_func_irs r[rrys,  MM(5-01!?NGOO""%%00> & &u -D5H  hmm +D!H$6$66I""I Qoo""#6iTXYG KKw &-mmo#HaG $& ))r]c d}|jjj}|j|dt5|j t g|}|jt|jd|||j t g|}|jd}|jt|j||g||jttdt||dddy#1swYyxYw)zGCreate an __init__ that sets registry and dispatch_cache to empty dictsrerrirUrvN)rrr enter_methodr.rlrBrr)rVrnrrDr(r$)rVrSr empty_dict cache_dictdispatch_cache_strs r[rrs D--00H   h O DE^^KT:  GGLLNJ DIJ^^KT: $--.>?]W\\^=OQ[,\^bc F71ot>@= 5#( = M4}I&--m< == :"6uzzB!'>5>>4P $AABSUYZ114F 3V2WY]^ #33EJJE -w/?/? /K][]a '2&7&7&9I"U)2EF  "!'5::u~~tLI#E*J&z3DEL L1I% (--/B/K/KT 09JDQ ]C#GS$=K NN1Hk93UW[ \ ]!11 /$  T4H+Ir]c |j|}t|Dcic]\}\}}t||r||c}}}Scc}}}w)zgReturn a dict of registered implementation to native implementation ID for all implementations )r enumerater)rVrrr<rr_s r[rtrtsG  ( ()< =E*3E*: ^ ^;C,wX\B]D!G ^^ ^s AAc|j}|j||jd|jjdj }|sM|j j|||jjd}|jt|n|jt|j\}}} } } t||| S)zGenerate an implicit trivial property getter for an attribute. These are used if an attribute can also be accessed as a property. rVrre)rPrrrXrr}rVrGrrr(r+rr) rVrris_traitrPself_regvaluerrrrrs r[gen_property_getter_irrs >>D MM$##FIMM,>,>q,A,F,FGH ((49O9OQST F5M" KM")0&D!VXw )T6 **r]c.|j}|j||jd|jjdj }|jd|jjdj }|j tsJ|ttd}|s|jt|||d|jt|j|j\}} } } } t||| S)zGenerate an implicit trivial property setter for an attribute. These are used if an attribute can also be accessed as a property. rVrrrvNre)rPrrrXrr}r;rrDrr)r(nonerr) rVrrrrPr value_reg attr_namerrrrrs r[gen_property_setter_irrs >>D MM$##FIMM,>,>q,A,F,FGH$$Wimm.@.@.C.H.HII ??> ** *S(*+I  GHiB?@ KKw||~&')0&D!VXw )T6 **r])rVr2rWr rqrr)rVr2rarrqrr)rVr2rqr rqrr)rVr2rr rqr,)NF)rVr2rr rPstrrXr rClassDef | Nonerboolrqtuple[FuncIR, Value | None]) rVr2rXr rrrrrqr)rVr2rr rqr)F)rVr2rzlist[Register]rzlist[BasicBlock]rXr rr9rrrrrqr)rVr2rrrWr rqrr) rVr2rrrrrWr rqrr)rVr2rqr)rVr2rWr rr,rqr,)rVr2rWr rqr)rVr2rr rrrrrrrWr rrrqr)rVr2r zSequence[RuntimeArg]rSintrqr)rVr2rr rrrrrrrSrr rrqr) rVr2rr r,r rSrrqrr)rVr2rXr rrrrrrrSrr1rrqr)rVr2rWr rqr@) rVr2rrrHz Type | NonerSrrqr,) rVr2rrriz str | NonerSrrqr,)rVr2r_rrr rqrr) rVr2rgr,r!rrr rSrrqrr) rVr2rr rrrrrXr rqztuple[FuncIR, Value]) rVr2rr rrrrrqr)rVr2rqrr)rVr2rr9rqrr)rVr2rar,rSrrqr,)rrrqr)rVr2rr rqrr)rVr2rr rqzdict[FuncDef, int]) rVr2rrrrrrrqr)__doc__ __future__r collectionsrcollections.abcrtypingr mypy.nodesrrr r r r r rrr mypy.typesrrrr mypyc.commonrrrrmypyc.ir.class_irrrmypyc.ir.func_irrrrrrr r! mypyc.ir.opsr"r#r$r%r&r'r(r)r*r+r,mypyc.ir.rtypesr-r.r/r0r1mypyc.irbuild.builderr2r3r4mypyc.irbuild.callable_classr5r6r7r8mypyc.irbuild.contextr9mypyc.irbuild.env_classr:r;r<r=mypyc.irbuild.generatorr>r?mypyc.irbuild.targetsr@mypyc.primitives.dict_opsrArBrCmypyc.primitives.generic_opsrDmypyc.primitives.misc_opsrEmypyc.primitives.registryrFmypyc.sametyperGrHr\rbrtrrOrrrrrrrgrrrrrrrrRrNrSrkr^rrrrr]rrTrtrrrr]r[rs} ##$   HGLL6    VU + P2 773A - &>>!! q q q q  q  q  q!qh *2AVZ 2 *).* * * *  *  *  *"&*!*Z@$F%* %*!0%*8@%*HO%* %*P,/[ [[ [  [  [  [[ [2j /[ [[ [  [  [  [[ [| "/:GOR :) ) ) )  )  )  )) )X :*,^  K  K;> KGN K  KF-! -!%*-!6=-!FM-!UX-! -!`& &&&8;&LO&Vc&&8* *&*=E*VY* *& E+ZA.Ib_+ +#++3;+GK+ +&+ +#++3;+GK+ +r]