
    mi                    
   U d Z ddlmZ ddlmZmZmZmZ ddl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mZmZ ddlmZmZ ddlmZmZmZmZm Z m!Z!m"Z"m#Z#m$Z$m%Z%m&Z& ddl'm(Z(m)Z)m*Z*m+Z+m,Z,m-Z-m.Z.m/Z/m0Z0m1Z1m2Z2m3Z3m4Z4m5Z5m6Z6m7Z7m8Z8m9Z9m:Z:m;Z;m<Z<m=Z=m>Z>m?Z?m@Z@mAZAmBZB ddlCmDZD dd	lEmFZF dd
lGmHZHmIZImJZJmKZK ddlLmMZMmNZNmOZOmPZP ddlQmRZRmSZS ddlTmUZUmVZVmWZWmXZXmYZY ddlZm[Z[ ddl\m]Z]m^Z^ ddl_m`Z` ddlambZbmcZc ddldmeZe ddlfmgZgmhZh ddlimjZjmkZkmlZlmmZmmnZnmoZompZp ddlqmrZrmsZs edeegee&         f         Zti Zudevd<   	 ddd%Zwdd&Zx	 ddd(Zy	 ddd+Zz ezd,          dd-            Z{ ezd.           ezd/           ezd0           ezd1           ezd2           ezd3           ezd4           ezd5          dd6                                                                                                Z| ezd7          dd8            Z} ezd9          dd:            Z~ ezd9          dd;            Z ezd<          dd=            Z ezd>          dd?            Z ezd@           ezdA          ddB                        Z ezd<           ezdC           ezdD           ezd@           ezdA           ezdE           ezdF           ezdGeA           ezdHe>           ezdIe/           ezdIe@          ddJ                                                                                                                                    Z ezdK          ddL            Z ezdM          ddN            ZddWZ ezdX          ddY            Z ezdZ           ezd[           ezd\           ezd]          dd^                                                Z ezd_          dd`            ZeeeReSeYe[ege`ebehemerdaZdbevdc<    ezdd          dde            Z ezdfe/          ddg            Z ezdheA          ddi            Z ezdGeA          ddj            Z ezdkeA          ddl            Z ezdme-          ddn            Z ezd2          ddo            Z ezd3          ddp            Z ezd4          ddq            Z ezd5          ddr            ZddvZ ezd/          ddw            Z ezdx          ddy            Z ezd0          ddz            Z ezd{          dd|            Zdd~ZddZ ezde?          dd            Z ezde?          dd            ZdS )a0  Special case IR generation of calls to specific builtin functions.

Most special cases should be handled using the data driven "primitive
ops" system, but certain operations require special handling that has
access to the AST/IR directly and can make decisions/optimizations
based on it. These special cases can be implemented here.

For example, we use specializers to statically emit the length of a
fixed length tuple and to emit optimized code for any()/all() calls with
generator comprehensions as the argument.

See comment below for more documentation.
    )annotations)CallableFinalOptionalcast)	ARG_NAMEDARG_POSCallExprDictExpr
ExpressionGeneratorExprIntExprListExpr
MemberExprNameExprRefExprStrExpr	SuperExpr	TupleExprVar)AnyType	TypeOfAny)
BasicBlockCallExtendIntegerPrimitiveDescriptionRaiseStandardErrorRegisterSetAttrTruncateUnreachableValue)	RInstance
RPrimitiveRTupleRTypebool_rprimitivebytes_rprimitivec_int_rprimitivedict_rprimitiveint16_rprimitiveint32_rprimitiveint64_rprimitiveint_rprimitiveis_bool_rprimitiveis_dict_rprimitiveis_fixed_width_rtypeis_float_rprimitiveis_int16_rprimitiveis_int32_rprimitiveis_int64_rprimitiveis_int_rprimitiveis_list_rprimitiveis_uint8_rprimitivelist_rprimitiveobject_rprimitiveset_rprimitivestr_rprimitiveuint8_rprimitive)	IRBuilder)constant_fold_expr)comprehension_helper*sequence_from_generator_preallocate_helpertranslate_list_comprehensiontranslate_set_comprehension)FormatOpconvert_format_expr_to_strjoin_formatted_stringstokenizer_format_call)isinstance_bytearrayisinstance_bytes)dict_items_opdict_keys_opdict_setdefault_spec_init_opdict_values_opisinstance_dict)isinstance_float)generic_setattrsetup_object)isinstance_int)isinstance_listnew_list_set_item_op)isinstance_bool)isinstance_frozensetisinstance_set)bytes_decode_ascii_strictbytes_decode_latin1_strictbytes_decode_utf8_strictisinstance_strstr_encode_ascii_strictstr_encode_latin1_strictstr_encode_utf8_strict)isinstance_tuplenew_tuple_set_item_opr?   z1dict[tuple[str, RType | None], list[Specializer]]specializersNbuilderexprr
   calleer   name
str | NonetypRType | NonereturnValue | Nonec                j    |r0||ft           v r%t           ||f         D ]} || ||          }||c S d S N)rb   )rc   rd   re   rf   rh   specializervals          p/var/www/html/bestrading.cuttalo.com/scripts/kaggle-env/lib/python3.11/site-packages/mypyc/irbuild/specialize.py_apply_specializationrq      s]      s|++'c	2 	 	K+gtV44C


 4    c                0    t          | |||j                  S )zIInvoke the Specializer callback for a function if one has been registered)rq   fullnamerc   rd   re   s      rp   apply_function_specializationrv      s     !$HHHrr   r   c                H    ||j         n|j        }t          | ||||          S )zGInvoke the Specializer callback for a method if one has been registered)rt   rf   rq   )rc   rd   re   rh   rf   s        rp   apply_method_specializationrx      s+     "k6??v{D $cBBBrr   str$Callable[[Specializer], Specializer]c                     d fd}|S )zDecorator to register a function as being a specializer.

    There may exist multiple specializers for one function. When
    translating method calls, the earlier appended specializer has
    higher priority.
    fSpecializerrj   c                h    t                               fg                               |            | S rm   )rb   
setdefaultappend)r|   rf   rh   s    rp   wrapperz$specialize_function.<locals>.wrapper   s0    sR0077:::rr   )r|   r}   rj   r}    )rf   rh   r   s   `` rp   specialize_functionr      s.           Nrr   zbuiltins.globalsc                ^    t          |j                  dk    r|                                 S d S )Nr   )lenargsload_globals_dictru   s      rp   translate_globalsr      s,    
49~~((***4rr   zbuiltins.absbuiltins.intbuiltins.floatzbuiltins.complexzmypy_extensions.i64zmypy_extensions.i32zmypy_extensions.i16zmypy_extensions.u8c                   t          |j                  dk    r|j        t          gk    rt	          |t
                    r|j        d         }|                     |          }|j                            d          d         }|dv rd}nd| d}t	          |t                    rM|j
                            |          r3|                     |          }|                     ||g d|j                  S dS )zSpecialize calls on native classes that implement the associated dunder.

    E.g. i64(x) gets specialized to x.__int__() if x is a native instance.
       r   .)i64i32i16u8__int____N)r   r   	arg_kindsr	   
isinstancer   	node_typert   splitr$   class_ir
has_methodacceptgen_method_callline)rc   rd   re   argarg_typ	shortnamemethodobjs           rp   $translate_builtins_with_unary_dunderr      s     49~~t~'::z&RZ?[?[:il##C((O))#..q1	333FF')'''Fgy)) 	Mg.>.I.I&.Q.Q 	M..%%C**3D$)LLL4rr   zbuiltins.lenc                   t          |j                  dk    r|j        t          gk    r|j        d         }|                     |          }t          |t                    r6|                     |           t          t          |j	                            S t          |                     |                    rd}nd}|                     ||          }|                     ||j                  S d S )Nr   r   TF
can_borrow)r   r   r   r	   r   r   r&   r   r   typesr8   builtin_lenr   )rc   rd   re   r   
expr_rtypeborrowr   s          rp   translate_lenr      s    
49~~t~'::il&&s++
j&)) 	7 NN33z/00111!'"3"3C"8"899 ...88C&&sDI6664rr   builtins.listc                t   t          |j                  dk    r|j        t          gk    sdS |j        d         }t	          |t
                    r!|j        st	          |j        t                    sdS |j        j        }|j        j	        }| 
                    |          }t          |          r|dv sdS |                     |          }|dk    r"|                     t          |g|j                  S |dk    r"|                     t           |g|j                  S |                     t"          |g|j                  S )zSpecialize a common case when list() is called on a dictionary
    view method call.

    For example:
        foo = list(bar.keys())
    r   Nr   )keysvaluesitemsr   r   )r   r   r   r	   r   r
   re   r   rd   rf   r   r1   r   call_crL   r   rN   rK   )rc   rd   re   r   baseattrrtyper   s           rp   dict_methods_fast_pathr      s#    	NNaDNwi$?$?t
)A,CsH%% ch :cjR\;];] t:?D:?Dd##Eu%% $2M*M*Mt
..

C v~~~~lSE49===			~~nseTY???~~mcUDI>>>rr   c                    t          |j                  dk    rc|j        d         t          k    rMt	          |j        d         t
                    r-t          | |j        d         | j        j        t                    S dS )zSpecial case for simplest list comprehension.

    For example:
        list(f(x) for x in some_list/some_tuple/some_str)
    'translate_list_comprehension()' would take care of other cases
    if this fails.
    r   r   empty_op_llbuilderset_item_opN)
r   r   r   r	   r   r   rB   rc   new_list_op_with_lengthrU   ru   s      rp   "translate_list_from_generator_callr     sx     	DI!N1((ty|]33 ) :IaL&F,	
 
 
 	
 4rr   builtins.tuplec                    t          |j                  dk    rc|j        d         t          k    rMt	          |j        d         t
                    r-t          | |j        d         | j        j        t                    S dS )zSpecial case for simplest tuple creation from a generator.

    For example:
        tuple(f(x) for x in some_list/some_tuple/some_str/some_bytes)
    'translate_safe_generator_call()' would take care of other cases
    if this fails.
    r   r   r   N)
r   r   r   r	   r   r   rB   rc   new_tuple_with_lengthra   ru   s      rp   #translate_tuple_from_generator_callr   '  sx     	DI!N1((ty|]33 ) :IaL&D-	
 
 
 	
 4rr   builtins.setc                    t          |j                  dk    rQ|j        d         t          k    r;t	          |j        d         t
                    rt          | |j        d                   S dS )zSpecial case for set creation from a generator.

    For example:
        set(f(...) for ... in iterator/nested_generators...)
    r   r   N)r   r   r   r	   r   r   rD   ru   s      rp   !translate_set_from_generator_callr   @  s^     	DI!N1((ty|]33 ) +7DIaLAAA4rr   builtins.minzbuiltins.maxc                   |j         t          t          gk    r|                     |j        d                   |                     |j        d                   }}t	          |                     |                    }|j        dk    r|                     ||d|j                  }n|                     ||d|j                  }t                      t                      t                      }	}}| 
                    |||           |                     |           |                     ||                     ||j        |j                  |j                   |                     |	           |                     |           |                     ||                     ||j        |j                  |j                   |                     |	           |                     |	           |S d S )Nr   r   r   <>)r   r	   r   r   r   r   rt   	binary_opr   r   add_bool_branchactivate_blockassigncoercetypegoto)
rc   rd   re   xyresult
comparison
true_blockfalse_block
next_blocks
             rp   faster_min_maxr   R  s    ~'7+++~~dil++W^^DIaL-I-I1'++D1122?n,, **1adi@@JJ **1adi@@J.8llJLL*,,K

JDDDz***vw~~adiHH$)TTTZ   {+++vw~~adiHH$)TTTZ   z***4rr   builtins.frozensetbuiltins.dictzbuiltins.sortedzcollections.OrderedDictjoinextendupdatec           	         t          |j                  dk    r)|j        d         t          k    rt	          |j        d         t
                    rt	          |t                    r                                          |j	                  |j
        t           |j        d                   g fd|j        dd         D             z                        |          |j        |j        |j                  S                      ||t           |j        d                   g fd|j        dd         D             z             S dS )zuSpecial cases for things that consume iterators where we know we
    can safely compile a generator into a list.
    r   c                :    g | ]}                     |          S r   r   .0r   rc   s     rp   
<listcomp>z1translate_safe_generator_call.<locals>.<listcomp>  %    DDDsw~~c**DDDrr   r   Nc                :    g | ]}                     |          S r   r   r   s     rp   r   z1translate_safe_generator_call.<locals>.<listcomp>  r   rr   )r   r   r   r	   r   r   r   r   r   rd   rf   rC   r   r   	arg_namescall_refexpr_with_argsru   s   `  rp   translate_safe_generator_callr   n  sG   $ 	DIN1((ty|]33 ) fj)) 	**v{++1'49Q<HHIDDDDdimDDDE !!$''	   111'49Q<HHIDDDDdimDDDE	   4rr   zbuiltins.anyc                    t          |j                  dk    rZ|j        t          gk    rIt	          |j        d         t
                    r)t          | |j        d         | j        d | j                  S d S )Nr   r   c                    | S rm   r   )r   s    rp   <lambda>z$translate_any_call.<locals>.<lambda>  s    a rr   )	r   r   r   r	   r   r   any_all_helperfalsetrueru   s      rp   translate_any_callr     si     	DI!Nwi''ty|]33 ( gty|W]KKQXQ]^^^4rr   zbuiltins.allc                     t          j                  dk    r]j        t          gk    rLt	          j        d         t
                    r,t           j        d          j         fd j                  S d S )Nr   r   c                <                         | dj                  S )Nnot)unary_opr   )r   rc   rd   s    rp   r   z$translate_all_call.<locals>.<lambda>  s    g&&q%;; rr   )	r   r   r   r	   r   r   r   r   r   ru   s   `` rp   translate_all_callr     s     	DI!Nwi''ty|]33 ( IaLL;;;;;M
 
 	
 4rr   genr   initial_valueCallable[[], Value]modifyCallable[[Value], Value]	new_valuer#   c           	        	
 t          t                    	                     	 |            d           t          t	          j        j        j        j                            }t                      t                      t                      c
d 	
fd}t           ||j                                                   	S )Nrj   Nonec                 8                         j                            }                     |                                                                            d                                                                         d S )Nr   )r   	left_exprr   r   r   r   )	r   rc   
exit_blockr   r   r   r   retvalr   s	    rp   gen_inner_stmtsz'any_all_helper.<locals>.gen_inner_stmts  s    VGNN3=99::

JDDDz***vyy{{B///Z   {+++++rr   rj   r   )r   r(   r   listzipindices	sequences	condlistsis_asyncr   rA   r   goto_and_activate)rc   r   r   r   r   loop_paramsr   r   r   r   r   s   `` ``  @@@@rp   r   r     s     o&&FNN6==??B///s3;s}clSSTTK*4,,
jll'JZ, , , , , , , , , , , , , +IIIj)))Mrr   zbuiltins.sumc                    t          |j                  dv r6|j        d         t          k    r t	          |j        d         t
                    sd S t          |j                  dk    r+|j        d         t          t          fvrd S |j        d         }nt          d          }|j        d                              |          }t          |           
                                                              |          |d          d           d	 fd}t          t          j        j        j        j                            }t'           ||j                   S )
N)r      r   r	  r   r   rj   r   c            	                              j                  }                                         | dd          d           d S )N+r   )r   r   r   r   )	call_exprrc   gen_exprr   s    rp   r   z+translate_sum_call.<locals>.gen_inner_stmts  sG    NN8#566	vw00CLLbQQQQQrr   r   )r   r   r   r	   r   r   r   r   r   r   r   r   r   r   r  r  r  r  r  rA   r   )	rc   rd   re   
start_exprtarget_typer   r  r  r   s	   `      @@rp   translate_sum_callr    sn    	DI&  N1((ty|]33 ) t 49~~>!Wi$8884Yq\

QZZ
y|H##D))Kk""FNN67>>'..*D*DkSUVVXZ[[[R R R R R R R R Hh0(2DhFWXX K +NNNMrr   zdataclasses.fieldzattr.ibzattr.attribzattr.Factoryc                H    t          t          j                  | j        |<   dS )a,  Special case for 'dataclasses.field', 'attr.attrib', and 'attr.Factory'
    function calls because the results of such calls are type-checked
    by mypy using the types of the arguments to their respective
    functions, resulting in attempted coercions by mypyc that throw a
    runtime error.
    N)r   r   
from_errorr   ru   s      rp    translate_dataclasses_field_callr    s      ")"677GM$4rr   zbuiltins.nextc                d    |j         t          gt          t          gfv r t          |j        d         t                    sdS |j        d         t                               |                    t          |j                  dk    r                      |j        d                   nd}t                      d fd}t          t          j        j        j        j                            }t!           ||j                   |r7                     |j        j                                                   nT                     t-          t,          j        d|j                                                  t1                                                                 S )a6  Special case for calling next() on a generator expression, an
    idiom that shows up some in mypy.

    For example, next(x for x in l if x.id == 12, None) will
    generate code that searches l for an element where x.id == 12
    and produce the first such object, or None if no such element
    exists.
    r   Nr   rj   r   c                                                                j                  j        j                                                   d S rm   )r   r   r   r   r   )rc   r   r   r   s   rp   r   z,translate_next_call.<locals>.gen_inner_stmts   sF     	vw~~cm<<cm>PQQQZ     rr   r   )r   r	   r   r   r   r   r   r   r   r   r   r  r  r  r  r  rA   r   r   r   r   addr   STOP_ITERATIONr"   r   )	rc   rd   re   default_valr   r  r   r   r   s	   `     @@@rp   translate_next_callr    s    	G9w&8999ty|]33 	: t
)A,Cg''--..F25di..12D2D'..1...$KJ! ! ! ! ! ! ! ! ! s3;s}clSSTTK+III
  #v{CM,>???Z    &'9'H$PTPYZZ[[[KMM""":&&&Mrr   )builtins.boolzbuiltins.bytearrayzbuiltins.bytesr   r   r   r   r   r   zbuiltins.strr   r   isinstance_primitiveszbuiltins.isinstancec           	        t          |j                  dk    r|j        t          t          gk    sdS |j        d         }|j        d         }t	          |t
                    r|j        s|                                 S t	          |t          t
          f          rt          t          j                  | j        |<   |                     |          }|Qt          d |D                       }|                     ||          }| j                            |||j                  S t	          |t                    r^|j        }|rSt(                              |j                  }	|	r2|                     |          }|                     |	|g|j                  S n6t	          |t
                    r g }
|j        D ]Q}t	          |t                    s dS |j         dS |j        j        |
vr|
                    |j        j                   Rd |
D             }d|v rdS |                     |          }t3          t4                    }t7                      }t7                      }t7                      }t9          |          D ]\  }}	|t          |          dz
  k    }|r|nt7                      }|                     |                     t=          t>          |	          |g|j                  ||           |s|                      |           |                      |           | !                    || "                                |j                   | #                    |           |                      |           | !                    ||                                 |j                   | #                    |           |                      |           |S dS )zSpecial case for builtins.isinstance.

    Prevent coercions on the thing we are checking the instance of -
    there is no need to coerce something to a new type before checking
    what type it is, and the coercion could lead to bugs.
    r	  Nr   r   c              3  D   K   | ]}|j         o|j         o|j         V  d S rm   )is_ext_classinherits_pythonallow_interpreted_subclasses)r   irs     rp   	<genexpr>z'translate_isinstance.<locals>.<genexpr>]  sN         b(:$:b2Cb?b     rr   r   c                B    g | ]}t                               |          S r   )r  get)r   rt   s     rp   r   z(translate_isinstance.<locals>.<listcomp>v  s'    PPP&**844PPPrr   )$r   r   r   r	   r   r   r   r   r   r   r   r  r   flatten_classesallr   rc   isinstance_helperr   noder  r$  rt   primitive_opr   r   r(   r   	enumerater   r   r   r   r   r   r   )rc   rd   re   obj_expr	type_exprirsr   r   r(  desc
node_namesitemdescsr   
pass_block
fail_blockr   iis_lastr   s                       rp   translate_isinstancer6  F  s    	NNaDNw6H$H$Hty|H	!I)Y'' 	 }})gy122 
J"))*>"?"?h%%i00?      J ..j.AAC?44S#tyIII)W%% 6~ 	D(,,T];;D DnnX..++D3%CCC	Iy	)	) . "
O 	6 	6DdG,, tty tty!33!!$)"4555PPZPPP5==4nnX&&/**\\
\\
\\
 !'' 		3 		3GAt3u::>)G'.@JLLJ##$$T*>%E%EudiXX  
  3&&z222 	z***vw||~~ty999Z    	z***vw}}	:::Z    	z***4rr   r   c                l   t          |j                  dk    r|j        t          t          gk    rt	          |t
                    rl|j        d         }t	          |t                    r2t          |j                  rdS t          dt          |j
                  }nt	          |t                    r2t          |j                  rdS t          dt          |j
                  }nst	          |t                    r\t	          |j        t                    rB|j        j        dk    r2t          |j                  rdS t          dt          |j
                  }ndS |                     |j                  }|                     |j        d                   }|                     t&          |||g|j
                  S dS )a  Special case for 'dict.setdefault' which would only construct
    default empty collection when needed.

    The dict_setdefault_spec_init_op checks whether the dict contains
    the key and would construct the empty collection only once.

    For example, this specializer works for the following cases:
         d.setdefault(key, set()).add(value)
         d.setdefault(key, []).append(value)
         d.setdefault(key, {})[inner_key] = inner_val
    r	  r   Nr      r   )r   r   r   r	   r   r   r   r   r   r*   r   r   r
   re   r   rt   r   rd   r   rM   )rc   rd   re   r   	data_typecallee_dictkey_vals          rp   translate_dict_setdefaultr<    s    	DI!Nw000vz** 1 ilc8$$ 	39~~ t#3TY??IIX&& 	39~~ t#3TY??IIsH%%		3:x00		 
#~5538}} t#3TY??II4nnV[11..1..~~(;*KTY
 
 	
 4rr   formatc                   t          |t                    rt          | |j                  }t          |t                    r|j                            t                    t          |j                  k    rOt          |          }|d S |\  }}t          | ||j        |j                  }|d S t          | |||j                  S d S rm   )r   r   r@   rd   ry   r   countr	   r   rH   rF   r   r   rG   )rc   rd   re   folded_calleetokensliterals
format_opssubstitutionss           rp   translate_str_formatrE    s    &*%% W*7FK@@mS)) 		Wdn.B.B7.K.KsSWSaObOb.b.b*=99F~t#) Hj6w
DIW[W`aaM$t)'8]DIVVV4rr   c                   t          |t                    r't          |j        t                    r|j        j        dk    r|j        t          gk    rt          |j        d         t                    r|j        d         j	        D ]}t          |t                    rt          |t                    rt          |j        t                    r|j        j        dk    r dS t          |j        j        t                    r|j        j        j        dk    r dS t          |j        d         t                    r|j        d         j        dk    r dS  dS g }g }|j        d         j	        D ]}t          |t                    r@|j        dk    r5|                    t          j                   |                    |           Wt          |t                    r?|                    t          j                   |                    |j        d                    dd}t!          t#          |          dz
            D ]}t#          |          |dz   k    r |||                   x} |||dz                      x}	g |d|         t          ||	z             ||dz   d         }g |d|         t          j        ||dz   d         }t#          |          |dz   k    r) |||                   x} |||dz                      x}	t%          | |||j                  }
|
dS t)          | d|
|j                  S dS )zSpecial case for f-string, which is translated into str.join()
    in mypy AST.

    This specializer optimizes simplest f-strings which don't contain
    any format operation.
     r   r=  Nz{:{}}r   rd   r   rj   rg   c                    t          | t                    r| j        S t          | t                    rCt          | j        t
                    r)| j        j        r| j        j        }|t          |          S d S rm   )	r   r   valuer   r(  r   is_finalfinal_valuery   )rd   rK  s     rp   get_literal_strz*translate_fstring.<locals>.get_literal_str  sp    $(( ,z!D'** ,z$)S/I/I ,diN` ,"i3*{+++4rr   r	  )rd   r   rj   rg   )r   r   rd   r   rI  r   r	   r   r   r   r
   re   rf   r   rE   STRranger   rF   r   rG   )rc   rd   re   r0  rC  exprsrL  r4  firstsecondrD  s              rp   translate_fstringrR    s_    	6:&&8Ov{G,,8O K##Nwi''ty|X.. ( IaL& 	 	D$(( D(++ !$+z::  dk>NRZ>Z>Z44"4;#3W== AEAQAW[bAbAb44!$)A,88  DIaL<NRT<T<T44 =U tt
"$IaL& 	+ 	+D$(( +TZ2-=-=!!(,///T""""D(++ +!!(,///TYq\***	 	 	 	 s5zzA~&& 	S 	SAE

a!e##-oeAh777UD.uQU|<<<VIN%)NWUV^%<%<NuQUWW~NRz"1"~Rx|RjQ>QR
 E

a!e##-oeAh777UD.uQU|<<<VI
 37JtyYY 4%gt]DINNN4rr   encodec                $   t          |t                    sdS t          |j                  dk    r"t          |j        d         t
                    sdS t          |j                  dk    r"t          |j        d         t
                    sdS d}d}t          |j                  dk    rt          |j        d         t
                    r|j        d         t          k    rH|j        d         dk    r|j        d         j        }nO|j        d         dk    r|j        d         j        }n+|j        d         t          k    r|j        d         j        }ndS t          |j                  dk    rt          |j        d         t
                    r|j        d         t          k    rH|j        d         dk    r|j        d         j        }nO|j        d         dk    r|j        d         j        }n+|j        d         t          k    r|j        d         j        }ndS |dk    rdS |
                                                    dd	                              d
d	          }|dv r:|                     t          |                     |j                  g|j                  S |dv r:|                     t"          |                     |j                  g|j                  S |dv r:|                     t$          |                     |j                  g|j                  S dS )zPSpecialize common cases of str.encode for most used encodings and strict errors.Nr   r   utf8strictencodingerrors-rG  _)r   utfrU  cp65001)646asciiusascii)iso885918859cp819latinlatin1l1)r   r   r   r   r   r   r   r   rI  r	   lowerreplacer   r_   r   rd   r   r]   r^   rc   rd   re   rW  rX  s        rp   str_encode_fast_pathri  "  s    fj)) t 4>Qz$)A,'H'Ht
4>Qz$)A,'H'HtHF
4>Q:dilG#D#D>!	))~a J..9Q<-"h..1+^A'))y|)HH4
4>Q:dilG#D#D>!	))~a J..9Q<-"h..1+^A'))Yq\'FF4t~~''R0088bAAH333~~4w~~fk7R7R6SUYU^___	0	0	0~~5v{8S8S7TVZV_```	K	K	K~~69T9T8UW[W`aaa4rr   decodec                   t          |t                    sdS t          |j                  dk    r"t          |j        d         t
                    sdS t          |j                  dk    r"t          |j        d         t
                    sdS d}d}t          |j                  dk    rt          |j        d         t
                    r|j        d         t          k    rH|j        d         dk    r|j        d         j        }nO|j        d         dk    r|j        d         j        }n+|j        d         t          k    r|j        d         j        }ndS t          |j                  dk    rt          |j        d         t
                    r|j        d         t          k    rH|j        d         dk    r|j        d         j        }nO|j        d         dk    r|j        d         j        }n+|j        d         t          k    r|j        d         j        }ndS |dk    rdS |
                                                    dd	          }|d
v r:|                     t          |                     |j                  g|j                  S |dv r:|                     t"          |                     |j                  g|j                  S |dv r:|                     t$          |                     |j                  g|j                  S dS )zPSpecialize common cases of obj.decode for most used encodings and strict errors.Nr   r   rU  rV  rW  rX  rZ  rY  )r   r[  rU  zutf-8r\  )r]  r^  r_  zus-ascii)z	iso8859-1z
iso-8859-1ra  rb  rc  rd  zlatin-1re  )r   r   r   r   r   r   r   r   rI  r	   rf  rg  r   r[   r   rd   r   rY   rZ   rh  s        rp   bytes_decode_fast_pathrl  V  s    fj)) t 4>Qz$)A,'H'Ht
4>Qz$)A,'H'HtHF
4>Q:dilG#D#D>!	))~a J..9Q<-"h..1+^A'))y|)HH4
4>Q:dilG#D#D>!	))~a J..9Q<-"h..1+^A'))Yq\'FF4t~~''S11H<<<~~69T9T8UW[W`aaa	<	<	<~~7'..:U:U9VX\Xabbb	 	 	
 	
 ~~87>>&+;V;V:WY]Ybccc4rr   c                   t          |j                  dk    s|j        d         t          k    rd S |j        d         }|                     |          }t          |          r|                     |          S t          |          st          |          rE|                     |          }| 	                    t          |t          d|j                            S t          |          rE|                     |          }| 	                    t          |t          d|j                            S t          |          st          |          r6|                     |          }|                     |t          |j                  S d S )Nr   r   Tsignedr   F)r   r   r   r	   r   r6   r   r5   r4   r  r   r.   r   r9   r7   r0   r   rc   rd   re   r   arg_typero   s         rp   translate_i64rr    s^   
49~~dnQ/7::t
)A,C  %%H8$$ 
@~~c"""	X	&	& @*=h*G*G @nnS!!{{6#'749UUUVVV	X	&	& @nnS!!{{6#'7DIVVVWWW	8	$	$ @(:8(D(D @nnS!!~~c#3TY???4rr   c                   t          |j                  dk    s|j        d         t          k    rd S |j        d         }|                     |          }t          |          r|                     |          S t          |          rD|                     |          }|                     t          |t          |j                            S t          |          rE|                     |          }|                     t          |t          d|j                            S t          |          rE|                     |          }|                     t          |t          d|j                            S t          |          st!          |          rK|                     |          }t#          |t                    }|                     |t          |j                  S d S )Nr   r   r   Trn  F)r   r   r   r	   r   r5   r   r6   r  r!   r-   r   r4   r   r9   r7   r0   truncate_literalr   rp  s         rp   translate_i32rv    s   
49~~dnQ/7::t
)A,C  %%H8$$ @~~c"""	X	&	& @nnS!!{{8C)9	JJJKKK	X	&	& 	@nnS!!{{6#'749UUUVVV	X	&	& @nnS!!{{6#'7DIVVVWWW	8	$	$ @(:8(D(D @nnS!!s$455~~c#3TY???4rr   c                0   t          |j                  dk    s|j        d         t          k    rd S |j        d         }|                     |          }t          |          r|                     |          S t          |          st          |          rD|                     |          }| 	                    t          |t          |j                            S t          |          rE|                     |          }| 	                    t          |t          d|j                            S t          |          st!          |          rK|                     |          }t#          |t                    }|                     |t          |j                  S d S )Nr   r   rt  Frn  )r   r   r   r	   r   r4   r   r5   r6   r  r!   r,   r   r9   r   r7   r0   ru  r   rp  s         rp   translate_i16rx    sl   
49~~dnQ/7::t
)A,C  %%H8$$ @~~c"""	X	&	& 	@*=h*G*G 	@nnS!!{{8C)9	JJJKKK	X	&	& @nnS!!{{6#'7DIVVVWWW	8	$	$ @(:8(D(D @nnS!!s$455~~c#3TY???4rr   c                   t          |j                  dk    s|j        d         t          k    rd S |j        d         }|                     |          }t          |          r|                     |          S t          |          st          |          st          |          rD|                     |          }| 
                    t          |t          |j                            S t          |          st          |          rK|                     |          }t!          |t                    }|                     |t          |j                  S d S )Nr   r   rt  )r   r   r   r	   r   r9   r   r4   r5   r6   r  r!   r>   r   r7   r0   ru  r   rp  s         rp   translate_u8rz    s9   
49~~dnQ/7::t
)A,C  %%H8$$ @~~c"""H%%
@x((
@ x((
@
 nnS!!{{8C)9	JJJKKK	8	$	$ @(:8(D(D @nnS!!s$455~~c#3TY???4rr   rI  r   r%   c                    t          | t                    s| S |                                 }d|j        dz  z  dz
  }||z  }|j        r||dz   dz  k    r||dz   z  }t          ||          S )zIf value is an integer literal value, truncate it to given native int rtype.

    For example, truncate 256 into 0 if rtype is u8.
    r      r	  )r   r   numeric_valuesize	is_signed)rI  r   r   max_unsigneds       rp   ru  ru    s    
 eW%% A%*q.)Q.L	LA 1!1a 777	\A1err   c                p   t          |j                  dk    s|j        d         t          k    rd S |j        d         }|                     |          }t          |          st          |          st          |          r6|                     |          }| 	                    |t          |j                  S d S Nr   r   )r   r   r   r	   r   r0   r7   r2   r   r   r/   r   )rc   rd   re   r   rq  srcs         rp   translate_intr    s    
49~~dnQ/7::t
)A,C  %%H8$$>X&&>  ))>
 nnS!!~~c>49===4rr   r  c                    t          |j                  dk    s|j        d         t          k    rd S |j        d         }|                     |          }| j                            |          S r  )r   r   r   r	   r   rc   
bool_value)rc   rd   re   r   r  s        rp   translate_boolr  
  s]    
49~~dnQ/7::t
)A,C
..

C?%%c***rr   c                    t          |j                  dk    s|j        d         t          k    rd S |j        d         }|                     |          }t          |          r|                     |          S d S r  )r   r   r   r	   r   r3   r   )rc   rd   re   r   rq  s        rp   translate_floatr    sp    
49~~dnQ/7::t
)A,C  %%H8$$ #~~c"""4rr   zbuiltins.ordc                2   t          |j                  dk    s|j        d         t          k    rd S t	          | |j        d                   }t          |t          t          f          r/t          |          dk    rt          t          |                    S d S r  )
r   r   r   r	   r@   r   ry   bytesr   ord)rc   rd   re   r   s       rp   translate_ordr    s}    
49~~dnQ/7::t
Wdil
3
3C#U|$$ !SQs3xx   4rr   boolc                    t          | t                    o)t          | j        t                    o| j        j        dk    S )z%Returns True for object.<name> calls.zbuiltins.object)r   r   rd   r   rt   )re   s    rp   	is_objectr  )  s=     	6:&& 	6v{H--	6K $55rr   c                T    t          | j        t                    pt          |          S )z7Returns True for super().<name> or object.<name> calls.)r   re   r   r  )rd   re   s     rp   is_super_or_objectr  2  s!    dk9--B61B1BBrr   __new__c                   | j         }|j        dk    st          ||          sd S |                                 }|d S d}|j        s |                     | d|j                   d S |j        r |                     | d|j                   d S t          |j	                  dk    r4|                     | dt          |j	                   |j                   d S |j	        d         }|j
        j        }t          |t                    rt          |          dk    r|d         |j        k    r|                     |j	        d                   }|                                }	|	Bt          |	          dk    r/|                     t#          |j        |g|j                            S |                     t(          |g|j                  S d S )Nr  z"object.__new__()"z( not supported for non-extension classesz= not supported for classes inheriting from non-native classesr   z% supported only with 1 argument, got r   )fn_inforf   r  get_current_class_irr  errorr   r  r   r   fitemr   r   r   r   
subclassesr  r   setupr   rR   )
rc   rd   re   fnr!  calltyp_argmethod_argssubtypesubss
             rp   translate_object_newr  7  s   	B	w)#5dF#C#Ct		%	%	'	'B	ztD? GGGSSSt	 RRRTXT]	
 	
 	
 t
49~~TTC	NNTTVZV_```tilG($K'8$$ 	B[)9)9A)=)=+a.T[T`B`B`..1..}}D		Q;;tBHwiCCDDD
 ~~lWItyAAA4rr   __setattr__c                   t          |j        t                    }t          |          }|rt	          |j                  dk    s|rt	          |j                  dk    sd S |r |                     |j        d                   n|                                 }|                                 }|r|j	        r|j
        s|j        rd S |rdnd}|rdnd}|j        |         }	|j        |         }
|                     |
          }t          |	t                    rt|rr|                    |	j                  rX|	j        }|                     ||j        |         |j                  }|                     t'          ||||j                            S |                     |	          }|                     t*          |||g|j                  S )Nr	  r8  r   r   )r   re   r   r  r   r   r   selfr  r  builtin_baser  r   has_attrrI  r   
attributesr   r  r    r   rQ   )rc   rd   re   is_superis_object_calleeself_regr!  name_idx	value_idx	attr_name
attr_valuerI  rf   name_regs                 rp   translate_object_setattrr  ^  s   $+y11H (( #di..A--3C-DIZ[H[H[t/?Sw~~dil+++W\\^^H		%	%	'	'B	 2? bo 9K t#qq!H$1I	(#I9%JNN:&&E)W%% F" FY_1M1M FubmD&949EE{{78T5$)DDEEE~~i((H>>/Hh+F	RRRrr   rm   )rc   r?   rd   r
   re   r   rf   rg   rh   ri   rj   rk   )rc   r?   rd   r
   re   r   rj   rk   )
rc   r?   rd   r
   re   r   rh   ri   rj   rk   )rf   ry   rh   ri   rj   rz   )rc   r?   r   r   r   r   r   r   r   r   rj   r#   )rI  r#   r   r%   rj   r#   )re   r   rj   r  )rd   r
   re   r   rj   r  )__doc__
__future__r   typingr   r   r   r   
mypy.nodesr   r	   r
   r   r   r   r   r   r   r   r   r   r   r   r   
mypy.typesr   r   mypyc.ir.opsr   r   r   r   r   r   r   r    r!   r"   r#   mypyc.ir.rtypesr$   r%   r&   r'   r(   r)   r*   r+   r,   r-   r.   r/   r0   r1   r2   r3   r4   r5   r6   r7   r8   r9   r:   r;   r<   r=   r>   mypyc.irbuild.builderr?   mypyc.irbuild.constant_foldr@   mypyc.irbuild.for_helpersrA   rB   rC   rD   "mypyc.irbuild.format_str_tokenizerrE   rF   rG   rH   mypyc.primitives.bytes_opsrI   rJ   mypyc.primitives.dict_opsrK   rL   rM   rN   rO   mypyc.primitives.float_opsrP   mypyc.primitives.generic_opsrQ   rR   mypyc.primitives.int_opsrS   mypyc.primitives.list_opsrT   rU   mypyc.primitives.misc_opsrV   mypyc.primitives.set_opsrW   rX   mypyc.primitives.str_opsrY   rZ   r[   r\   r]   r^   r_   mypyc.primitives.tuple_opsr`   ra   r}   rb   __annotations__rq   rv   rx   r   r   r   r   r   r   r   r   r   r   r   r   r   r  r  r  r  r6  r<  rE  rR  ri  rl  rr  rv  rx  rz  ru  r  r  r  r  r  r  r  r  r   rr   rp   <module>r     s/     # " " " " " 2 2 2 2 2 2 2 2 2 2 2 2                                 " * ) ) ) ) ) ) )                                                                                  : , + + + + + : : : : : :                       N M M M M M M M              8 7 7 7 7 7 F F F F F F F F 3 3 3 3 3 3 K K K K K K K K 5 5 5 5 5 5 I I I I I I I I                  O N N N N N N N Xw7%HI CE D D D D `d     I I I I QUC C C C C $(    " '((   )( ^$$^$$%&&'((*++*++*++)**   +* ,+ ,+ ,+ )( '& %$ %$, ^$$   %$& _%%? ? ? &%?< _%%   &%0 %&&   '&0 ^$$   %$" ^$$^$$   %$ %$4 %&&)**_%%^$$^$$&''.//V^,,X//X//X~..! ! ! /. 0/ 0/ -, 0/ (' %$ %$ &% +* '&!H ^$$   %$ ^$$   %$    4 ^$$# # # %$#L ())Y]##^$$
 
 
 %$ $#   *)
 _%%( ( ( &%(X %.&$&."$""&         *++U U U ,+Up \?33* * * 43*Z X~..   /.  V^,,@ @ @ -,@F X~..0 0 0 /.0f X/009 9 9 109x *++   ,+& *++   ,+. *++   ,+( )**   +**     ^$$   %$ _%%+ + + &%+ %&&   '& ^$$   %$   C C C C
 Y 122# # # 32#L ]$566S S S 76S S Srr   