AeddlmZddlZddlmZmZmZmZmZm Z ddlm Z m Z m Z ddl mZmZmZmZddlmZGd d eZy) )absolute_importN) ExprNodes PyrexTypes MemoryViewParseTreeTransformsStringEncodingErrors) CloneNode ProxyNode TupleNode) FuncDefNode CFuncDefNode StatListNodeDefNode) OrderedSetceZdZdZdZdZdZdZdZe jgdzZ fdZ dZ dZ dZdZd Zd Zd Zd Zd ZdZdZdZdZdZdZdZdZdZdZdZdZ dZ!dZ"dZ#dZ$dZ%dZ&xZ'S) FusedCFuncDefNodea This node replaces a function with fused arguments. It deep-copies the function for every permutation of fused types, and allocates a new local scope for it. It keeps track of the original function in self.node, and the entry of the original function in the symbol table is given the 'fused_cfunction' attribute which points back to us. Then when a function lookup occurs (to e.g. call it), the call can be dispatched to the right function. node FuncDefNode the original function nodes [FuncDefNode] list of copies of node with different specific types py_func DefNode the fused python function subscriptable from Python space __signatures__ A DictNode mapping signature specialization strings to PyCFunction nodes resulting_fused_function PyCFunction for the fused DefNode that delegates to specializations fused_func_assignment Assignment of the fused function to the function name defaults_tuple TupleNode of defaults (letting PyCFunctionNode build defaults would result in many different tuples) specialized_pycfuncs List of synthesized pycfunction nodes for the specializations code_object CodeObjectNode shared by all specializations and the fused function fused_compound_types All fused (compound) types (e.g. floating[:]) N)__signatures__resulting_fused_functionfused_func_assignmentctt| |jg|_||_t |j t}|r|j|n|j||jD]}|jjjrJ|jjjrJ|jjr|jjrJ|rx|jj s|jj"rJ||j_|jdd|_yN)superr__init__posnodesnode isinstancercopy_def copy_cdefentrytypeis_fused local_scope return_typecfunc_declaratoroptional_arg_count op_arg_structfused_cfunctionstats)selfrenvis_defn __class__s 9lib/python3.12/site-packages/Cython/Compiler/FusedNode.pyrzFusedCFuncDefNode.__init__2s /9  DIIw/  MM#  NN3  ,Aww||,, ,}}0099 9((==111a00CCvv+++ ,&* "ZZ] ctj|jjDcgc]%}|jj s|j'c}}|j |}tj|}||_|jj|jvr/|jj|jj|D]X\}}tj|j}|jjj|j_|j|j||jj j#||_|j%||j'||||j)|||jj||tj*|j|d|j_|j|j.|jj0<|j3|rYn|j|_|j7|j|d|_ycc}w)zh Create a copy of the original def or lambda function for specialized versions. Tr/N)runiquerargsr$r%_get_fused_base_types get_all_specialized_permutationsfused_compound_typesr#pyfunc_entriesremovecopydeepcopy signature_specialize_function_argsr' specializeanalyse_declarationscreate_new_local_scopespecialize_copied_defspecialize_entryusedentriesnamereplace_fused_typechecks orig_py_funcmake_fused_cpdefpy_func) r-r.argr: fused_types permutationscnamefused_to_specific copied_nodes r2r!zFusedCFuncDefNode.copy_defOs *00!% E#3883D3DSXX E G001EF !BB;O $8! 99??c00 0    % %diioo 6(4  $E$-- 2K*.))//*C*CK   '  * *;+;+;=N O&*ii&;&;&F&F4E'GK #  , ,S 1  ' ' S:K L  & &{E499??'8:N P  ' ' (9(95 A%)K   "2=2C2CCKK )).. /00=+ .!II,,TYYD,I C Fs I*I*c|jjj}|jjx|_}d|j_|r%|j j |j|jjj}||_ g}|D]\}}tj|j}|jj|} |j} | j| |t|jD]\} } | j | j k(s | j#| js<|j| |_|jj$s| j$|j_|j} | j} n|j'| | |_| | c| _| _| j(xs<|jjj*xs|j,xs | j.| _|jj0j2r(|jj0j5| ||| j6|_|j9||||j;|j0j<||j?||jrl|j j |jj|jA|j||jjjB|||jE|rn |jjG|jj} ||j| | dz|r|jM||d|_y||_y#tH$r|jjK|YJwxYw)zf Create a copy of the original c(p)def function for all specialized versions. N) fused_cnamerFr5)'rr$r9rLrJr;r<r#get_fused_typesr:r=r>rArE enumerate cfunc_entriesrPsame_as_resolved_type func_cnameappendrFdefined_in_pxdis_c_class_scope is_cmethodr(r)declare_optional_arg_structr'rCr@r7declare_cpdef_wrapperrD as_variablerIindex ValueErrorextendrK)r-r.rOrJrNnew_cfunc_entriesrPrQrRr$r#i orig_entrycindexs r2r"zFusedCFuncDefNode.copy_cdefxs` yy~~FFH ,099+<+<<L       % %l&8&8 9iinn446 $/!(42  $E$-- 2K##../@AD%%E  ! !% /"+3+<+  - -c 2""""))+*=*=*C*CD**#++UDIIOO4O4O);800=e2 j C&&,,TYY__=F2CC  fVAX . 00s8=1?DL(DL 8    $ $%6 7 8s!/O$O-,O-cRg}t}|D]}|j|||S)zq Get a list of unique basic fused types, from a list of (possibly) compound fused types. )resultseen)setrU)r-r: base_typesrj fused_types r2r8z'FusedCFuncDefNode._get_fused_base_typess:  u. EJ  & &jt & D Er3c|D]u}|jjs|jj||_|jjsQ|jj |j wyr)r$r%rAis_memoryviewslicevalidate_memslice_dtyper)r-r7rQrMs r2r@z+FusedCFuncDefNode._specialize_function_argssX >Cxx  88../@A88..HH44SWW=  >r3c|j|||j_d|_|jj |y)a Create a new local scope for the copied node and append it to self.nodes. A new local scope is needed because the arguments with the fused types are already in the local scope, and we need the specialized entries created after analyse_declarations on each specialized version of the (CFunc)DefNode. f2s is a dict mapping each fused type to its specialized version FN)create_local_scoper&rQhas_fused_argumentsrrZ)r-rr.f2ss r2rCz(FusedCFuncDefNode.create_new_local_scopes< $-0*$)  $r3c|j|}|Dcgc]}tj||}}dj||_tj ||j j|j _|j|j _|j|j _ ycc}w)zwSpecialize the copy of a DefNode given the copied node, the specialization cname and the original DefNode entry|N) r8rspecialization_signature_stringjoinspecialized_signature_stringget_fused_cnamer#pymethdef_cnamedoc doc_cname) r-rrPpy_entryrtr:rNrm type_stringss r2rDz'FusedCFuncDefNode.specialize_copied_defs001EF #.   6 6z3 G  -0HH\,B)%/%?%?(-tzz/I/I&K "! '11  sB;ctj}tj|j}||tj|kDryy)z Branch-prune fused type checks like if fused_t is int: ... Returns whether an error was issued and whether we should stop in in order to prevent a flood of errors. FT)r num_errorsrReplaceFusedTypeChecksr&)r-rRr transforms r2rIz*FusedCFuncDefNode.replace_fused_typecheckssE&& '>>'2'>'>@ +   z )r3c|D]H}|jj|j|j|j dJy)zl Generate Cython code for instance checks, matching an object to specialized types. ) py_type_namespecialized_type_namez if isinstance(arg, {{py_type_name}}): dest_sig[{{dest_sig_idx}}] = '{{specialized_type_name}}'; break N)contextupdaterspecialization_string put_chunk)r- normal_typespyx_coder.specialized_types r2_fused_instance_checksz(FusedCFuncDefNode._fused_instance_checkssW !-      # #-::<&6&L&L $      r3cZ|jrd|zSt|jddS)Nz ___pyx_%s _) is_typedefstrreplacer-dtypes r2 _dtype_namezFusedCFuncDefNode._dtype_name&s-   & &5z!!#s++r3cR|jr|j|St|Sr)rrrrs r2 _dtype_typezFusedCFuncDefNode._dtype_type+s&   ##E* *5zr3cD|jryd|j|zS)Nzsizeof(void *)z sizeof(%s)) is_pyobjectrrs r2 _sizeof_dtypezFusedCFuncDefNode._sizeof_dtype0s$   #$"2"25"99 9r3c|jdr2|jd|jd|j|jdr2|jd|jd|j|jdr2|jd|jd|j|jdr3|jd|jd |jy y ) z?Setup some common cases to match dtypes against specializationszif kind in b'iu':pass dtype_intzelif kind == b'f': dtype_floatzelif kind == b'c': dtype_complexzelif kind == b'O': dtype_objectN)indenterputlnnamed_insertion_pointdedentr-rs r2%_buffer_check_numpy_dtype_setup_casesz7FusedCFuncDefNode._buffer_check_numpy_dtype_setup_cases6s   0 1 NN6 "  * *; 7 OO    1 2 NN6 "  * *= 9 OO    1 2 NN6 "  * *? ; OO    1 2 NN6 "  * *> : OO  3r3z8dest_sig[{{dest_sig_idx}}] = '{{specialized_type_name}}'z!dest_sig[{{dest_sig_idx}}] = Nonec|j|||zD]M}|}|jr |j}|j}|jj |j |dzd|j|z||j|j|jf|j|jf|j|jfg}|D]\}} |s d|jfz} |jr| dz } |jr| dz } | j!d| zsP| j#|j$| j#d| j'Py ) zO Match a numpy dtype object to the individual specializations. z == itemsizez!not (%s_is_signed ^ dtype_signed))itemsize_match signed_matchrrz3{{itemsize_match}} and (arg.ndim) == %dz and {{signed_match}}z and arg_is_pythran_compatiblezif %s:breakN)ris_pythran_expr org_bufferrrrrrris_intris_floatr is_complexrndimrrmatchr) r-rspecialized_buffer_types pythran_typesr final_typerdtypesdtype_category codewriterconds r2_buffer_check_numpy_dtypez+FusedCFuncDefNode._buffer_check_numpy_dtypeNss 228< -.F F , )J//#3#>#> $**E    # ##11%8>I@4CSCSTYCZZ&0&F&F $ Hx112!5!56!!8#9#9:F /5 ,* !P4D4I4ITLLD|| 77!11 @@!**8d?;"((4"((1"))+ ,# ,r3c|j}|jrdg|jz}n |j}t j ||}|j ||jj|j||jd|jj|j|j||jd|jzy)z For each specialized type, try to coerce the object to a memoryview slice of that type. This means obtaining a buffer and parsing the format string. TODO: separate buffer acquisition from format parsing )directstrided)coerce_from_py_funcrz;{{memviewslice_cname}} {{coerce_from_py_func}}(object, int))r sizeof_dtypea # try {{dtype}} if itemsize == -1 or itemsize == {{sizeof_dtype}}: memslice = {{coerce_from_py_func}}(arg, 0) if memslice.memview: __PYX_XDEC_MEMVIEW(&memslice, 1) # print 'found a match for the buffer through format parsing' %s break else: __pyx_PyErr_Clear() N)r is_bufferraxesrMemoryViewSliceTypecreate_from_py_utility_coderrfrom_py_functionrrrrr)r-r decl_coderr.rr memslice_types r2!_buffer_parse_format_string_checkz3FusedCFuncDefNode._buffer_parse_format_string_checkus!&&  % %)*-=-B-BBD#((D"66udC 11#6 - > >    I K "2"H"H++E2  4  **  r3c6|jd|rdndzdz|rdndzdz|jd|r|jd|jd |j||||j d|D]}|j ||||y ) a^ Generate Cython code to match objects to buffer specializations. First try to get a numpy dtype object and match it against the individual specializations. If that fails, try naively to coerce the object to each specialization, which obtains the buffer each time and tries to match the format string. z z!arg_is_pythran_compatible = Falsez if ndarray is not None: if isinstance(arg, ndarray): dtype = arg.dtype z arg_is_pythran_compatible = TrueaC elif __pyx_memoryview_check(arg): arg_base = arg.base if isinstance(arg_base, ndarray): dtype = arg_base.dtype else: dtype = None else: dtype = None itemsize = -1 if dtype is not None: itemsize = dtype.itemsize kind = ord(dtype.kind) dtype_signed = kind == 'i' raS # Pythran only supports the endianness of the current compiler byteorder = dtype.byteorder if byteorder == "<" and not __Pyx_Is_Little_Endian(): arg_is_pythran_compatible = False elif byteorder == ">" and __Pyx_Is_Little_Endian(): arg_is_pythran_compatible = False if arg_is_pythran_compatible: cur_stride = itemsize shape = arg.shape strides = arg.strides for i in range(arg.ndim-1, -1, -1): if (strides[i]) != cur_stride: arg_is_pythran_compatible = False break cur_stride *= shape[i] else: arg_is_pythran_compatible = not (arg.flags.f_contiguous and (arg.ndim) > 1) numpy_dtype_checksN)rindentrrrr)r- buffer_typesrrrr.rs r2_buffer_checksz FusedCFuncDefNode._buffer_checkss  ?L;RU WZ  GTBY\  ^ a   ,      ( &&';< &&x}M , @   2 2i)93 @ @r3c |jd|jjd|r|jjd|jjdt}t}|D]}|j}|j |} |j rL| |vrH|j| |jd|jd| d|jd|jjst||vs|jt||jj| |j| |jjd y ) zr If we have any buffer specializations, write out some variable declarations and imports. z ctypedef struct {{memviewslice_cname}}: void *memview void __PYX_XDEC_MEMVIEW({{memviewslice_cname}} *, int have_gil) bint __pyx_memoryview_check(object) z cdef {{memviewslice_cname}} memslice cdef Py_ssize_t itemsize cdef bint dtype_signed cdef char kind itemsize = -1 zl cdef bint arg_is_pythran_compatible cdef Py_ssize_t cur_stride zq cdef type ndarray ndarray = __Pyx_ImportNumPyArrayTypeIfAvailable() z ctypedef rz "") dtype_name dtype_typez cdef bint {{dtype_name}}_is_signed {{dtype_name}}_is_signed = not (<{{dtype_type}}> -1 > 0) N)rlocal_variable_declarationsimportsrkrrraddrresolveempty_declaration_coderrrrr) r-rrall_buffer_typesr seen_typedefsseen_int_dtypes buffer_typerrs r2_buffer_declarationsz&FusedCFuncDefNode._buffer_declarationss`    ,,66     0 0 : :<  ""    %+ K%%E))%0J]2!%%j1OO16*161M1M1OQR  ''u:_4#''E 3$$++z7;7G7G7N,P88BB r3ctj|j}|jt }ggg}}}d}|D]}|j } | r0| |vr|j | | dk(rd}3|j|E|jr|j|c|js |js||j|||||fS)zV Specialize fused types and split into normal types and buffer types. FobjectT) rget_specialized_typesr$sortrkrrrZrrro) r-rMspecialized_typesseen_py_type_namesrrrhas_object_fallbackrrs r2_split_fused_typesz$FusedCFuncDefNode._split_fused_typess'<args): arg = (args)[{{arg_tuple_idx}}] elif kwargs is not None and '{{arg.name}}' in kwargs: arg = (kwargs)['{{arg.name}}'] else: {{if arg.default}} arg = (defaults)[{{default_idx}}] {{else}} {{if arg_tuple_idx < min_positional_args}} raise TypeError("Expected at least %d argument%s, got %d" % ( {{min_positional_args}}, {{'"s"' if min_positional_args != 1 else '""'}}, len(args))) {{else}} raise TypeError("Missing keyword-only argument: '%s'" % "{{arg.default}}") {{endif}} {{endif}} )rrs r2_unpack_argumentz"FusedCFuncDefNode._unpack_argument2s  r3c ddlm}m}m}|j |j j Dcgc]%}|jjs|j'c}}tj|j j t||r-|j j|j jz n%td|j j D|jj d} |j#| } |j#| } | j%d| j'| j%d| j'| j)d| j)d | j)d d } d } t+}t-}t/|j j D]\}}|jjr8|jj1}t|dkDr t3d |d }|jjr`|vr[|j5|| j7||| | |j9|\}}}}|j;| | j=dr|r|j?|| ||s|r@|jA|jjCdd|jE||| | ||r8| jFj7d| jI|jJn| jI|jL| jId| jO| dz } |j7||j7d|D|jPs| dz } |rj|jS| | ||jA|jjCdd|jA|jjCdd| j%d| jU}ddl+m,}|j|d|g}|j[|j j\|j^}|ja| jU|jc||_2|jg||jhd}|jd|_5tm|j tnr|jpdd|_9|S|jpDcgc]}|jtc}|_9|Scc}wcc}w)a! This creates the function that is indexable from Python and does runtime dispatch based on the argument types. The function gets the arg tuple and kwargs dict (or None) and the defaults tuple as arguments from the Binding Fused Function's tp_call. r) TreeFragmentCode UtilityCodec3:K|]}|jdyw)Nr)default).0rMs r2 z5FusedCFuncDefNode.make_fused_cpdef..ZsG#3;;3FAGs)memviewslice_cname func_argsn_fusedmin_positional_argsrH)rz cdef extern from *: void __pyx_PyErr_Clear "PyErr_Clear" () type __Pyx_ImportNumPyArrayTypeIfAvailable() int __Pyx_Is_Little_Endian() a def __pyx_fused_cpdef(signatures, args, kwargs, defaults): # FIXME: use a typed signature - currently fails badly because # default arguments inherit the types we specify here! dest_sig = [None] * {{n_fused}} if kwargs is not None and not kwargs: kwargs = None cdef Py_ssize_t i # instance check body r func_defsrrzODetermination of more than one fused base type per argument is not implemented.) arg_tuple_idxrM dest_sig_idx default_idxzwhile 1:IsLittleEndianzModuleSetupCode.cr)rrc34K|]}|jywr)r)rtys r2rz5FusedCFuncDefNode.make_fused_cpdef..s'N" 'NsImportzImportExport.cImportNumPyArraya candidates = [] for sig in signatures: match_found = False src_sig = sig.strip('()').split('|') for i in range(len(dest_sig)): dst_type = dest_sig[i] if dst_type is not None: if src_sig[i] == dst_type: match_found = True else: match_found = False break if match_found: candidates.append(sig) if not candidates: raise TypeError("No matching signature found") elif len(candidates) > 1: raise TypeError("Function call with ambiguous argument types") else: return (signatures)[candidates[0]] )ConstantFoldingmodule)levelpipelineN);rrrrr8rr7r$r%rrlennum_required_argsnum_required_kw_argssumr#rH PyxCodeWriterrrrrrkrVrUNotImplementedErrorrrrrrruse_utility_code load_cachedrrrrno_matchrrrgetvalueOptimizerSetPosTransformrrootdeclare_declarations_in_scope global_scopescoperBr,fragment_scoper rrspecialized_cpdefsrL)r-rJr.r/rrrrMrNrrr fused_indexrrseen_fused_typesrearg_fused_typesrmrrrr fragment_coderfragmentastrLr0s r2rKz"FusedCFuncDefNode.make_fused_cpdefGs 6500 $ 2E#((2C2CCHH2EF #-"?"?;' ++dii.L.LLGGG &&++  %%g%6&&w&7       &&y1&&{3&&'DE  %<5 /) !FAsxx  "%((":":"<'!+-/VWW,Q/ xx  Z7G%G $$Z0"#!, + RVQhQhilQmN lM;N%%h/$$Z0#33L(CP#},,T-=-=-I-IJZ\o-pq++L-S\^ab* ((//h/O tzz2 t}}5NN7+OO%q  '' 5 '''N 'NN{{q S) !V   % %h ;K] [  !1!1!=!=hHX!Y Z  !1!1!=!=>PRb!c d  4!))+  .,, _5F4G-I9l**499==9(--H11    #"2"2"4 6    %))B-!ii dii ))-AG &>BZZ)H!)))HG &a2E\*IsU U1Uc d}|jj}|D]-}t||t|jj|/|jj |j_|jj |j_|jjddt|jtr||j|j <n||j|j _ |jj|||jj_|j D]Z}t|jtr|j|_/|j|j_||j_ \|j%|j&j|j(y)N) rHrrPrY pyfunc_cnamer{r|r} is_memberr__pyx_fused_cpdef)rLr#setattrgetattrrJrHr|rGpopr rrr`r;rZr+r fused_py_funcsynthesize_defnodesr,r)r-r.copy_attributesr#attrrs r2update_fused_defnode_entryz,FusedCFuncDefNode.update_fused_defnode_entrysZ   ""# } t+|j4| _t+|j<| _t!|j:D]Y\}} t+|j<| _| j7|x} |j:|<t+|j4| _[|Scc} w)z Analyse the expressions. Take care to only evaluate default arguments once and clone the result for all specializations N)r7T) skip_childrenr) r:rUtypesrcreate_declaration_utility_coderLranalyse_expressionsrrdefaultsrr7rrZr rVr,r rzipr coerce_tor$r rdefaults_tuple analyse_typescoerce_to_pyobjectspecialized_pycfuncs code_objectrM) r-r.fused_compound_typermspecialization_typer*rMrestatrr7 fused_funcpycfuncs r2r)z%FusedCFuncDefNode.analyse_expressionss $(#<#< Q 1AAC Q +5+;+;Q'*55+KKCPQ Q Q <<"&"5"5"I"I#"ND <<;;C@DL,0,I,I,],]^a,bD ))-)C)C)W)WX[)\D &#%% 99>> &C{{!kk==cB  #++ 67%  &!, RGAt#'#;#;C#@ @D4::a=$ ,$' 8$<RLC*&/&8&B&B388S&Q R R <<6>J7'Ig&JDJ"+DHH4"@D "&"5"5"C"CCW["C"\"o"ops"tD "+D,?,?"@D ()B)B1)E)Q)QRD 66::J(1$2E2E(FJ %%.t/?/?%@J "'(A(AB H 7&/0@0@&A#9@9N9Ns9SS$33A6)243F3F)G& H Ks M4 M4ct|jdtr$|jDcgc]}|j}}n |j}|Dcgc]!}t j |j #}}t||Dcgc]&\}}tj|j|(}}}|Dcgc]#}tjj|d%}}tjj|jt|||_||_|D] }d|_ ycc}wcc}wcc}}wcc}w)zT Create the __signatures__ dict of PyCFunctionNode specializations. r)valueT)bindingN)r rrrLr EncodedStringryr+r StringNoderPyCFunctionNode from_defnodeDictNode from_pairsrr0is_specialization)r-rr signaturessigkeysvalues pycfuncnodes r2r!z%FusedCFuncDefNode.synthesize_defnodes7s6 djjm\ 2.2jj9dT\\9E9JJE#()%2243T3TU) )"%UJ!79D#$$TXXS999$%++88t8L%%(00;;DHHc$PVFWX$*!! 1K,0K ) 1:)9%sD4&D9 +D>;(EcB|jr-d|j_|jj|||jD]W}t |t s|jjs+|j|j|j||Yy)NT) rLpymethdef_requiredrgenerate_function_definitionsr,r rr#rFmark_posr)r-r.coder4s r2rHz/FusedCFuncDefNode.generate_function_definitionsMsr <<.2DLL +  & & D DS$ OJJ >D$ , dhh'223= >r3c(|jD]}||j||jr6|jj||jj||j D]Z}|j |jt|tjr|j|J|j|\|jr|jj||jd|jjd|jjd|j!|jj|jj#||jj%||j&j||jj)||jj%||jj)||jj%||jj)||jj%||jD]'}||j)||j%|)y)Nz((__pyx_FusedFunctionObject *) z)->__signatures__ = ;)r*generate_evaluation_coderLr-r1r,rIrr rExprNodegenerate_execution_coderrrri put_giverefgenerate_post_assignment_code free_tempsrgenerate_disposal_code)r-rJrr4s r2rOz)FusedCFuncDefNode.generate_execution_codeWs }} 7G"006 7 <<    8 8 >    5 5d ;JJ 3D MM$(( #$ 2 23--d3,,T2  3     ) ) B B4 H JJ%)%B%B%I%I%K%)%8%8%?%?%AC D   T00779 :    = =d C    * *4 0  & & > >t D  ) ) @ @ F  ) ) 4 4T :    6 6t <    * *4 0    3 3D 9    ' ' -}} )G"..t4""4( )r3cH|jD]}|j|yr)r,annotate)r-rJr4s r2rUzFusedCFuncDefNode.annotates!JJ D MM$  r3)(__name__ __module__ __qualname____doc__rrrr- decoratorsr child_attrsrr!r"r8r@rCrDrIrrrrrrr rrrrrrrKr$r)r!rHrOrU __classcell__)r1s@r2rr s8N# NJ**.OOK#:'JRT(l > "2 (",  : , GE2H%,N&P;@z9vN:*Yv!/F0d1,>*)X r3r) __future__rr=rrrrrr r r r r NodesrrrrUtilsrrr3r2ras2& <<66CCy  y  r3