mi*dZddlmZddlmZddlmZddlmZddl 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/m0Z0m1Z1m2Z2m3Z3m4Z4m5Z5dd l6m7Z7m8Z8m9Z9m:Z:m;Z;mZ>m?Z?m@Z@ddlAmBZBmCZCmDZDmEZEddlFmGZGmHZHddlImJZJmKZKmLZLmMZMddlNmOZOmPZPddlQmRZRddlSmTZTmUZUmVZVddlWmXZXmYZYmZZZddl[m\Z\ddl]m^Z^ddl_m`Z`maZaddZbdd!Zcdd$Zddd(Ze ddd6Zfdd8Zgdd9Zh dddAZiddDZjddFZkddGZlddJZmddKZnddMZoddNZpd*dOddWZqGdXdYeZrdd^Zsdd`ZtddbZudddZvddfZwddkZxddoZyddqZzddtZ{ddxZ|dd{Z}dd|Z~dd}ZddZddZddZddZddZddZd)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) FAST_PREFIX LAMBDA_NAMEPROPSET_PREFIX SELF_NAME)ClassIRNonExtClassInfo)FUNC_CLASSMETHOD FUNC_NORMALFUNC_STATICMETHODFuncDeclFuncIR FuncSignature RuntimeArg) BasicBlock ComparisonOpGetAttrInteger LoadAddress LoadLiteralRegisterReturnSetAttrUnbox UnreachableValue) RInstancebool_rprimitivec_int_rprimitivedict_rprimitiveint_rprimitiveobject_rprimitive) IRBuildercalculate_arg_defaultsgen_arg_defaults)add_call_to_callable_classadd_get_to_callable_classinstantiate_callable_classsetup_callable_class)FuncInfoGeneratorClass)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)generic_getattrgeneric_setattr py_setattr_op)register_function) builtin_names)is_same_method_signature is_same_typebuilderr4fdefr 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)rNrOsigfunc_irfunc_regs n/var/www/html/bestrading.cuttalo.com/scripts/kaggle-env/lib/python3.11/site-packages/mypyc/irbuild/function.pytransform_func_defrc^s . $ $T7?+P Q QC%gtTYDDGXLw55xKKK#GT222 $),,,,,orcL|jsJ||jdSrS)implaccept)rNres rbtransform_overloaded_func_defrijs' 6MMM NN16rddecr 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.)rTrUfuncrVrWrXrYload_decorated_funcrZr[r\fdefs_to_decoratorsfullnamesplitload_global_strcall_crFload_globals_dictload_strr] functionsappend)rNrjr_r`radecorated_funcrY orig_funcs rbtransform_decoratorr{psa . $ $SXw/T U UC%gsxLLGX#'N K,WchIIw99>38=YYYY W0 0 0x &&s++B/++D#(;; ,Wch JJ! "  & & ( ('*:*:38=*I*I> Z     $GSX666 W%%%%%rdexprr r-c Zt|j|}t|ts J|g}t |j|jD]W\}}||j_| t|jj | ||j X| |j}t||}t |j}|xjdz c_t%||||\} } | J|j | | S)N)rtypes isinstancerzip arguments arg_typesvariabletyperxr!rY type_to_rtypekindret_typer rlambda_counterrXrw) rNr|typ runtime_argsargarg_typerfsigfnamer`ras rbtransform_lambda_exprrs2 '-- . .C c< ( (--#---LT^S];;  X$  s|('*?*?*I*I38 T T    $$S\22H x 0 0D 4G2 4 4E a%gtUDAAGX     W%%% OrdNFfitemr rYstrr_r cdefClassDef | Nonemake_ext_methodbooltuple[FuncIR, Value | None]c :d}|jvpt|t}|jv}|jv} |jvd} t|} d} r)jj j } | j o| } j } rt|}n|}t||| t||| | |  }|j}|j|rVjj}t|t*s J|jj|}t/|j_|s|r(jst5|s| rt7|r+t9fd\}}t;||nt=\}}rQj |t|t*s J|tC||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) rrY class_name namespace is_nestedcontains_nested is_decorated in_non_extadd_nested_funcs_to_env)rc .t|||SrS) gen_func_ir)argsblocksfn_inforNris_singledispatchr_s rbzgen_func_item..s!+vsGT;L++rd)" nested_fitemsrr encapsulating_funcskeysrpsingledispatch_implshas_nested_func_self_referencerT type_to_irinfo is_ext_classrYsingledispatch_main_func_namer; gen_func_ns is_generatorenterrrrr fdef_to_generatorr<generator_class#can_merge_generator_and_env_classesr@r:rArB gen_func_bodyrwrxgen_dispatch_func_ir)rNrrYr_rrrarrrrrrir func_namerrgenerator_class_irr`rs` `` @rbrXrXsX"H ..O*UJ2O2OIw:??AAAOG77L!==JOPPM  )))%))005000#GUGL$LLL H rdrc t|t||jjrt |t |||jjj| |j d}| \}}}}} t||||| ||\} } t|| | || | fS)Nrm)r?r6rrr>r=rhrbodymaybe_add_implicit_return symtablesleaverr5) rNr_rrsymtabler_rrrr`ras rbrr#swW&$7###G NN7?(-... %%''' $H)0&D!VXw#GT63O`aaGX7GXx@@@ H rdctdj|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|tVdSrS)rr ).0syms rb z1has_nested_func_self_reference..Bs, Y Y:c8 $ $ Y Y Y Y Y YrdTc38K|]}t|VdSrS)r)rnestedrNs rbrz1has_nested_func_self_reference..DsA  'w77rd)anyfree_variablesgetsetr)rNrs` rbrr<s  Y Y0F0J0J5RURWRW0X0X Y Y YYYt 155eR@@  rdrlist[Register]rlist[BasicBlock]rr;is_singledispatch_main_funcc d}|js|jr4t|||||}t||t ||}n|j} t | ts J| |jj | } |r?|j t| j zkr'|jj |j j|j } |js|rY|dn|j } t!|j | |j|| j| j| j} t+| ||| j| j }nt+| ||| 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)is_prop_getteris_prop_setter)traceback_name)rrr7r8r9rrr rT func_to_declrYrrr method_declsrr module_namerrrrr\) rNrrr_rrrrar`r func_declrs rbrrJsf "H]G.],WdFCQQ!'7333-gw?? %))005000N/6  XGLK).$@@@1$)<I',WI   ]#> ]!%49J  #(7(7IYfejQVQ[\\\GGYfejQVQ[\\\G X rdrgetattrc ,|jdz}|jj|j}|j}d|jd}|jr||dz||jr||dz||||td5| dt}| t| |g|}tt} } td t|} |t#|| t"j|} || | | || |t+|||| || |j|gt|} |t+| |d d d d S#1swxYwYd S) ag Generate a wrapper function for __getattr__ that can be put into the tp_getattro slot. The wrapper takes one argument besides self which is the attribute name. It first checks if the name matches any of the attributes of this class. If it does, it returns that attribute. If none match, it calls __getattr__. __getattr__ is not supported in classes that allow interpreted subclasses because the tp_getattro slot is inherited by subclasses and if the subclass overrides __getattr__, the override would be ignored in our wrapper. TODO: To support this, the wrapper would have to check type of self and if it's not the compiled class, resolve "__getattr__" against the type at runtime and call the returned method, like _Py_slot_tp_getattr_hook in cpython. __getattr__ is not supported in classes which inherit from non-native classes because those have __dict__ which currently has some strange interactions when class attributes and variables are assigned through __dict__ vs. through regular attribute access. Allowing __getattr__ on top of that could be problematic. __wrapperz&"__getattr__" not supported in class " " because it allows interpreted subclasses#it inherits from a non-native classTinternalattrrN)rYrTrrr\allow_interpreted_subclasseserrorinherits_python enter_methodr3 add_argumentrtrGselfr"r%addr#NEQadd_bool_branchactivate_blockr)gen_method_call)rNrrrYrr\ error_baseattr_arggeneric_getattr_resultreturn_generic call_getattrnull got_genericgetattr_results rbgenerate_getattr_wrapperrws8$ <+ %D  "49 -B 400111'222222222222222222sE*H  H H setattrc |jdz}|jj|j}|j}d|jd}|jr||dz||jr||dz||||td5| dt}| d t}tt} } td t|} |t|| tj|} || | | || |jd } | r| jnd }|d uo|jd  }|r-||d |gd |n1|t4||| g||t7td t||| |||j||gd ||t7td t|d d d d S#1swxYwYd S)a Generate a wrapper function for __setattr__ that can be put into the tp_setattro slot. The wrapper takes two arguments besides self - attribute name and the new value. Returns 0 on success and -1 on failure. Restrictions are similar to the __getattr__ wrapper above. The wrapper calls the user-defined __setattr__ when the value to set is not NULL. When it's NULL, this means that the call to tp_setattro comes from a del statement, so it calls __delattr__ instead. If __delattr__ is not overridden in the native class, this will call the base implementation in object which doesn't work without __dict__. rz&"__setattr__" not supported in class "rrrTrrvaluer __delattr__N builtins.)rYrTrrr\rrrrr0rr3r"r%rr#EQrrrnoderq startswithrrrtrHr))rNrrrYrr\rr value_arg call_delattr call_setattrr is_delattrdelattr_symboldelattrdelattr_overrides rbgenerate_setattr_wrapperrs <+ %D  "49 -B >???|,,,  x>SUY[_``` F71&677>>???5@@@@@@@@@@@@@@@@@@sHJ::J>J>c  |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 ||jrAt;||j||||d}||j||f<|j ||jdkrtA|||dS|jdkrtC|||dS|jdkr_|j"d}|r&|j#r|j#j $d r|%d |jdSdSdS) Nrlr~__init__T do_py_ops __getattr__ __setattr__rrz{"__delattr__" supported only in classes that also override "__setattr__", or inherit from a native class that overrides it.)&rYrTrrrUrVrWrXrwrxrrq rpartitionload_native_type_object py_get_attrr\ro primitive_oprIrv is_property properties prop_settersmethodsdeclmrorrLr_gen_glue glue_methodsrrrrrrr)rNrrOrYclass_irr_r`rarrrzry getter_irbasefrs rbhandle_ext_methodrsu 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./  ### yM!! $55555 m # # $55555 m # #)-- .. gl gl.C.N.N{.[.[  MMF       $ #  rdnon_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 |jj|j} t*|jz}|| jvr>t |||||d\}}|| j|<|j|dSdS)Nzbuiltins.propertyzbuiltins.classmethodzbuiltins.staticmethodT)r)rYrTrUrVrWrXrwrxrrorload_module_attr_by_fullnamer\py_callrrrradd_to_non_ext_dictrrrrr) rNrrrOrYr_r`rarzpropcls_meth stat_methrs rbhandle_non_ext_methodr$,s 9D . $ $T7?+P Q QC%gtT3EEGX     W%%%GT""A &wi@@  E334GSS??4(TY??  $T * /3C C C778NPTPYZZ??8hZCC  $T * /3D D D889PRVR[\\ ??9xj$)DD xCCC~(3H  "D x$$$)'4sDZ^___!(  )))))%$rdcJdd|jDS)zJGenerate a namespace for a nested function using its outer function names.rc3pK|]1}|jr(|jdk|j|jsdn d|jzzV2dS)zrN)rYr)rrs rbrzgen_func_ns..Vs`  9j00 tIRRC$/4IJ0000rd)joinfn_infos)rNs rbrrTs7 88$  rd orig_func_regct||s|S|j|}|}t|D]X}||j}t |t s J||||g|j}Y|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. ) rrpreversedrhvisitorrr-rr\)rNrOr* decoratorsrad decorators rbroro]s  & &,T2JH j ! !IIHHW_-- )U++66Y666??9xj(-HH Ordc||jvSrS)rprNrOs rbrrss 7. ..rdrbase_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_propertyr\gen_glue_method)rNr3r4r5rrOrs rbrrwsJ& [ (FCtyR[\\\w&#tTYPYZZZrdc.eZdZUded<ded<ded<dS)ArgInfoz list[Value]rzlist[str | None] arg_namesz list[ArgKind] arg_kindsN)__name__ __module__ __qualname____annotations__rdrbr:r:s6rdr:rt_argsSequence[RuntimeArg]r\intcd|D}fd|D}d|D}d|D}t|||S)NcDg|]}t|j|jfSrA)rrYrrrs rb zget_args..s'>>>s#ch--*>>>rdc ng|]1\}}||d2S)T)is_arg)read add_local_reg)rvarrrNr\s rbrHzget_args..sP    C  W**3T*BBDII   rdcg|]D}|js |jr|js|jndESrS)ris_named is_optionalpos_onlyrYrGs rbrHzget_args..s\ H%%''bCH,@,@,B,Bb3<b^brdcg|] }|j SrA)rrGs rbrHzget_args..s---c---rd)r:)rNrBr\ fake_varsrr;r<s` ` rbget_argsrTs>>g>>>I     "   DI.-W---I 4I . ..rd 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. rmrNc3>K|]}|VdSrS)is_star)rrs rbrz"gen_glue_method..s* 0 0d4<<>> 0 0 0 0 0 0rdc3JK|]}|j VdSrS)rrXrGs rbrz"gen_glue_method..sD99#&CH    999999rdTr~) bitmap_args___glue)check_native_overriderr_rr ret_typeslistrrrr!rYr.rTr<r;num_bitmap_argsrNrrget_native_typepy_method_callcallcoercerr)rrrrr )rNr3r4r5rr\rUrBarg_inforr<r;rZfirststretvalarg_regsrrrs rbr8r8sD'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 QQQRrd 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. rmr[r\)rr!rr.add_self_to_envrKrr^r rYrr$rdr)rrrrr )rNr_r4r5rr\rrrt_arg self_targetrrhretboxrrr return_types rbr7r7 s;$ 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      rdrCc|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_deflookuprrrrLr3r2s rbr[r[Lsf  1~~d/000#$w'N$~~d###  '8 9 99rdrrunbounded_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)Nrlc3XK|]$}|ks|d |V%dS)rlN)r)riload_attr_paths rbrzload_type..ysJaaq~':':n>W>W[\X_X_X_>`>`':':':':':aardr')defaultkeyF)borrow)rrrYrq removesuffixrTrrNrarKrr&maximportslen load_module removeprefixrrr get_attrr3rs) rNrr|r\r class_objbuiltin_addr_typesrcr loaded_modulerrs @rb load_typeras *.+FFXCLl>sx>>"" gn'''>,S1O33H==  & &!.s|!<3KK ,=sD I IJJ aaaaGOaaa  <  ++K88 ,,  ' ';(9(9(9 : : @ @ E E E K KD $// tTJJMMO,, 38%6U-  ++CHd;; rdrrq str | Nonec|rb||jsH|dd}||}||||}n|||}|S)Nrlr)rcurrent_modulersplitrr rs)rNrrqr\modulerrns rb load_funcrs 8++G,BCC 8 %%a(++F33 ""=)TBB&&y$77 Krd!main_singledispatch_function_namecr|j}|jj|}t||jj|}|}|j|jd|}|j |dt|}ttt} } } | t||g|} || |d|} t!t"}|| | | || ||| ||| || |d|}t/|||}||||g|}|t4|||g||||||| || t7|||||dS)Nrdispatch_cachezis notzfunctools._find_impl)r\rTrrTr_rrrNget_type_of_objrr1r"rrDtranslate_is_op none_objectr(r3rrrZgotorload_singledispatch_registryrrtrFgen_calls_to_correct_impl)rNrrr\current_func_declredispatch_func_objrrcall_find_impl use_cache call_func get_result is_not_none impl_to_use find_implregistry uncached_impls rb)generate_singledispatch_dispatch_functionrs :D3E:!2!6!;TBBH ..x}Q/?FFH_--+_dN,6<<z||yIN%%&?.RZA[]abbJ))*g6I6I6K6KXW[\\K,--K KNCCC 9%%% NN; D111 LL >***445KTRRI+G5FMMHOOI(/CTJJM NN)NHm+TVZ[[[ NN; t444 LL 9%%%g{HeTJJJJJrdrrecjj|dfd }td\}}t ||}j||} tt} } | | |  | t|t} t|} | D]\}}tt}}|}| |d}||| ||| |t! | |jjj}|jj}t1|dS) NrOr rPrQc jj|}j|jjj}|jj } t|dSrS) rTrrNrcrr<r;rdr_rrr))rOrret_valcoercedrerNrr\s rbgen_native_func_call_and_returnzBgen_calls_to_correct_impl..gen_native_func_call_and_returnsxN/5 /&& x}h&8(:Ld  ..*;*?*H$OO F7OO$$$$$rdz builtins.intz==)rOr rPrQ)rTrrKrr&rN type_is_opr"rrr+r2get_native_impl_idsitemsload_int binary_opr,rrr<r;rdr_rr))rNrrerr\rrr int_type_objis_int native_callnon_native_call passed_id native_idsrgr call_impl next_impl current_idcondrrrs` ` ` @rbrrs4 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     rdmain_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) rrT)rr;r:r1rcallable_classr attributeshas_dictneeds_getseters+generate_singledispatch_callable_class_ctorrrr7rwrxr8%add_register_method_to_callable_classr9&generate_dispatch_glue_native_functionr) rNrrrr_rrrrdispatch_callable_classradispatch_func_irs rbrrs:  MM(5-00111!!!?NGO"%0 &u -D55H  hm +D!H$66I"I Qo""#6iTXYYG KKw   &-mmoo#HaG $& ) ))rdc 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 dictsrmrrrr~N)rrrrr/rtrErr*rrvrrIr)r%)rNr\r empty_dict cache_dictdispatch_cache_strs rbrr"s] D-0H   h O D DEE^^KT::  GGLLNNJ DIIJJJ^^KT:: $--.>??]W\\^^=OQ[,\^bccc F71ot<s @9 @ @ @@rdc|j}||jv}tt}|jD].\}}|D]&\}}||kr|||'/|s|sdS|rt |j} t|| |j |} | d|} |j | | fg|} | |j|} |t| |d| g||D]\}}t#||}||vrt||j|j |}n2||}t%|t&}||}t||j|j |} t+|| |}|D]3}t-||d|}|t0|||g|4|j | dt4|}||dgd| dS)Nzbuiltins.objectrrclear)r\rrr_rrxrrYrrqrrN make_dictrsrrIrvrr'r3rrrrtrFrr1r)rNrr\r to_register main_funcimpls dispatch_typergr main_func_objloaded_object_type registry_dictrsingledispatch_funcrr to_insertr load_literalrr loaded_typers rbr]r]Bs :D"'7+G"G8CD8I8IK#8>>@@== 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 NN1Hk93UW[ \ \ \ \ 11 /$   T4HHHH+IIrdrdict[FuncDef, int]cTj|}fdt|DS)zgReturn a dict of registered implementation to native implementation ID for all implementations cBi|]\}\}}t|||SrA)r)rrrrgrNs rb z'get_native_impl_ids..xs3 ^ ^ ^;C,wX\B]B] ^D! ^ ^ ^rd)r enumerate)rNrrs` rbrrss5  ()< =E ^ ^ ^ ^)E*:*: ^ ^ ^^rdris_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. rrrm)rYrrr_rrrNrrrr)r,rr) rNrrrrYself_regrrrrrrs rbgen_property_getter_irr{s >D MM$##FIM,>q,A,FGGH #((49OQSTT F5MM"""" KMM""")0&D!VXw )T6 * **rdcb|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. rrrr~Nrm)rYrrr_rrrrrrr*r)nonerr) rNrrrrYr value_reg attr_namerrrrrs rbgen_property_setter_irrs >D MM$##FIM,>q,A,FGGH$$Wim.@.C.HIII ??> * ****S((**+I A GHiB??@@@ KKw||~~&&''')0&D!VXw )T6 * **rd)rNr4rOr rPrQ)rNr4rerrPrQ)rNr4rjr rPrQ)rNr4r|r rPr-)NF)rNr4rr rYrr_r rrrrrPr) rNr4r_r rrrrrPr)rNr4rr rPr)F)rNr4rrrrr_r rr;rrrrrPr)rNr4rrrr rPrQ)rNr4rrrr rPrQ)rNr4rrrOr rPrQ) rNr4rrrrrOr rPrQ)rNr4rPr)rNr4rOr r*r-rPr-)rNr4rOr rPr)rNr4r3r r4rr5rrrrOr rrrPr)rNr4rBrCr\rDrPr:)rNr4r3r r4rr5rrrr\rDrUrrPr) rNr4r3r rjr r\rDrPrQ)rNr4r_r r4rr5rrrr\rDrrrrPr)rNr4rOr rPrC) rNr4rrr|r}r\rDrPr-) rNr4rrrqrr\rDrPr-)rNr4rrrr rPrQ) rNr4rr-rer:rr r\rDrPrQ) rNr4rr rrrrr_r rPr) rNr4rr rrrrrPr)rNr4rPrQ)rNr4rr;rPrQ)rNr4rr-r\rDrPr-)rrrPr)rNr4rr rPrQ)rNr4rr rPr) rNr4rrrrrrrPr)__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,r-mypyc.ir.rtypesr.r/r0r1r2r3mypyc.irbuild.builderr4r5r6mypyc.irbuild.callable_classr7r8r9r:mypyc.irbuild.contextr;r<mypyc.irbuild.env_classr=r>r?r@mypyc.irbuild.generatorrArBmypyc.irbuild.targetsrCmypyc.primitives.dict_opsrDrErFmypyc.primitives.generic_opsrGrHrImypyc.primitives.misc_opsrJmypyc.primitives.registryrKmypyc.sametyperLrMrcrir{rrXrrrrrrr$rrorrr:rTr8r]r7r[rrrrrrrrrrr]rrrrArdrbrs*  #"""""######$$$$$$                        HGGGGGGGGGGGLLLLLLLLLLLL66666666                            VUUUUUUUUU ;::::::: POOOOOOO222222 YXXXXXXXXX777777333333AAAAAAAA - - - - &&&&>>!! wwwwwt2    *).*****Z/2/2/2/2d0@0@0@0@fMMMM`%*%*%*%*P,////[[[[[[2j / / / /[[[[|:))))X : : : :*,,,,^     K K K KF-!-!-!-!`&&&&8****& E E E E++++ZZZZAAAA.I.I.I.Ib____++++&++++++rd