
    
Ng                     R   U d dl Zd dlZd dlZd dl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Zd dl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%m&Z&m'Z'm(Z(m)Z) eee*e+e+e+f         ee*e+e+e+e+f         f         Z,ee,         Z-eee*e*f                  Z.g dZ/e-e0d<   e	ee*e+f         e+f         Z1de-de1fd	Z2 e2e/          Z3	 ddee         de4de+fdZ5	 	 	 	 dde*dee*         dee*         dee*         dee*         dee*         dee*         dedefdZ6de*de+defdZ7	 	 	 	 ddee         de*dee&         dee&         deee"                  dee*         deee&                  deee!                  defdZ8de*de+defdZ9	 	 	 	 	 dde*de*dee*         dee*         dee         d ee         d!eee*                  d"eee                  dee*         dee*         deee&                  defd#Z:d$ededefd%Z;d$ededefd&Z<d'eeeeee"e&f         d(e	e*e*f         ddfd)Z=d*ed(e	e*e*f         ddfd+Z>d,eej?                 dee+         fd-Z@dd.eAd/e4de+fd0ZB	 	 	 	 dd.eAd3eAd4e4d5e4d6e4de+fd7ZC	 	 	 	 dd.eAd3eAd4e4d5e4d6e4de+fd8ZDd9eejE        ef         d:e4dejE        fd;ZF	 dde*d<e+d=ee+         d>ed?e4de"fd@ZGdAe"dBe"d=ee+         de!fdCZHde*dDe jI        dAee         de fdEZJde*dFe+dGee         dAe def
dHZKde*dDejI        dIee         defdJZLdIee*eMf         deMfdKZN	 	 ddLe*dIedee*         dMee+         def
dNZO	 dde*dMejP        dee*         defdOZQdPedefdQZRdRedSe*defdTZSde*de&fdUZT	 ddDe+dVeeee*e+df                           dWeee*                  de%fdXZU	 	 dde*dDe+dVeeee*e+df                           de*dWeee*                  de&fdZZV	 ddDe+dVeeee*e+df                           dWeee*                  de%fd[ZW	 	 dde*dDe+dVeeee*e+df                           de*dWeee*                  de&fd\ZXd]e%de%fd^ZYd]e%de%fd_ZZdFe+d`e%de%fdaZ[	 dde*dbe%de*de&fdcZ\ddee*eMf         de*fdeZ]	 	 dde*dDe+dVeeee*e+df                           de*dfeee*                  de&fdgZ^	 ddPedhe4dee*ee*ee         f         f         fdiZ_dje#j`        de*fdkZadle%de*fdmZbdne&de*fdoZcdle"de*fdpZd	 ddRedqe*dhe4dee*ee*ee         f         f         fdrZedd$edqe*de*fdsZfd'ejg        jh        ji        ddfdtZjduedve.dwee         dxee.         de$f
dyZkdze+dejl        fd{Zmdze+de+fd|Zndze+de*fd}Zodze+de*fd~Zpdejl        de+fdZqde
e+         fdZrd ejP        s                                D             ZtdMe+de*fdZudS )    N)isnan)AnyCallableDictKeysViewListOptionalSequenceTupleTypeVarUnioncast)
IR_VERSIONAttributeProtoFunctionProto
GraphProtoMapProto
ModelProto	NodeProtoOperatorSetIdProtoOptionalProtoSequenceProtoSparseTensorProtoTensorProtoTensorShapeProtoTrainingInfoProto	TypeProtoValueInfoProtodefsmappingsubbyte))z1.0      r#   )z1.1r"      r#   )z1.1.2r"      r#   )z1.2r"      r#   )z1.3r"      r#   )z1.4.1   	   r#   )z1.5.0r$   
   r#   )z1.6.0r%         )z1.7.0r&      r,   r#   )z1.8.0r&      r,   r#   )z1.8.1r&   r.   r,   r#   )z1.9.0r&      r,   r#   )z1.10.0r'      r,   r#   )z1.10.1r'   r0   r,   r#   )z1.10.2r'   r0   r,   r#   )z1.11.0r'      r"   r#   )z1.12.0r'      r"   r#   )z1.13.0r'      r"   r#   )z1.13.1r'   r3   r"   r#   )z1.14.0r)      r"   r#   )z1.14.1r)   r4   r"   r#   )z1.15.0r)      r(   r#   )z1.16.0r*      r$   r#   VERSION_TABLEtablereturnc                 Z    i dt           dt          dt          ddffd}| D ]} ||  S )zOCreate a map from (opset-domain, opset-version) to ir-version from above table.release_version
ir_versionargsr9   Nc                 x    ~ t          g d|          D ]$}|vr||<   |d         dk    r|d|d         f<   %d S )N)ai.onnxz
ai.onnx.mlai.onnx.trainingr   r@   zai.onnx.preview.trainingr#   )zip)r;   r<   r=   pairresults       G/var/www/html/ai-engine/env/lib/python3.11/site-packages/onnx/helper.pyprocessz-create_op_set_id_version_map.<locals>.processX   sm    EEEtLL 	M 	MD6!!)t7000BLF5tAw>?		M 	M    )strintr   )r8   rE   rowrC   s      @rD   create_op_set_id_version_maprJ   T   so    FM M# Mc Md M M M M M M   MrF   Fopsetidlistignore_unknownc                     ddt           t          df         dt          dt          ffd| rt          fd| D                       S S )a=  Given list of opset ids, determine minimum IR version required.

    Args:
        opsetidlist: A sequence of OperatorSetIdProto.
        ignore_unknown: If True, ignore unknown domain and return default minimum
            version for that domain.

    Returns:
        The minimum IR version required (integer)
    r"   domainNversionr9   c                 b    | pd|f}|t           v rt           |         S rS t          d          )Nr?   zUnsupported opset-version.)OP_SET_ID_VERSION_MAP
ValueError)rN   rO   keydefault_min_versionrL   s      rD   find_minz)find_min_ir_version_for.<locals>.find_minw   sF    "G,'''(-- 	'&&5666rF   c              3   D   K   | ]} |j         |j                  V  d S N)rN   rO   ).0xrU   s     rD   	<genexpr>z*find_min_ir_version_for.<locals>.<genexpr>   s3      FFQ88AHai00FFFFFFrF   )r   rG   rH   max)rK   rL   rT   rU   s    `@@rD   find_min_ir_version_forr\   h   s     7sDy) 7C 7C 7 7 7 7 7 7 7  GFFFF+FFFFFFrF   op_typeinputsoutputsname
doc_stringrN   overloadkwargsc                 j   t                      }| |_        |j                            |           |j                            |           |r||_        |r||_        |||_        |||_        |rC|j	                            d t          |                                          D                        |S )a  Construct a NodeProto.

    Args:
        op_type (string): The name of the operator to construct
        inputs (list of string): list of input names
        outputs (list of string): list of output names
        name (string, default None): optional unique identifier for NodeProto
        doc_string (string, default None): optional documentation string for NodeProto
        domain (string, default None): optional domain for NodeProto.
            If it's None, we will just use default domain (which is empty)
        overload (string, default None): optional field, used to
            resolve calls to model-local functions
        **kwargs (dict): the attributes of the node.  The acceptable values
            are documented in :func:`make_attribute`.

    Returns:
        NodeProto
    Nc              3   @   K   | ]\  }}|t          ||          V  d S rW   )make_attribute)rX   rS   values      rD   rZ   zmake_node.<locals>.<genexpr>   sB       
 
U  3&&    
 
rF   )r   r]   inputextendoutputr`   ra   rN   rb   	attributesorteditems)	r]   r^   r_   r`   ra   rN   rb   rc   nodes	            rD   	make_nodero      s    8 ;;DDLJfKw 	 %$  
 
 
$V\\^^44
 
 
 	
 	
 	

 KrF   rO   c                 >    t                      }| |_        ||_        |S zConstruct an OperatorSetIdProto.

    Args:
        domain (string): The domain of the operator set id
        version (integer): Version of operator set id
    Returns:
        OperatorSetIdProto
    r   rN   rO   )rN   rO   operatorsetids      rD   make_operatorsetidrt      s%     '((M!M#MrF   nodesinitializer
value_infosparse_initializerc                    |g }|g }|g }t                      }|j                            |            ||_        |j                            |           |j                            |           |j                            |           |j                            |           |j                            |           |r||_	        |S )a  Construct a GraphProto

    Args:
        nodes: list of NodeProto
        name (string): graph name
        inputs: list of ValueInfoProto
        outputs: list of ValueInfoProto
        initializer: list of TensorProto
        doc_string (string): graph documentation
        value_info: list of ValueInfoProto
        sparse_initializer: list of SparseTensorProto
    Returns:
        GraphProto
    )
r   rn   ri   r`   rh   rj   rv   rx   rw   ra   )	ru   r`   r^   r_   rv   ra   rw   rx   graphs	            rD   
make_graphr{      s    0 !
LLE	JeEJ	Kv	L   	[)))	##$6777	J''' &%LrF   c                 >    t                      }| |_        ||_        |S rq   rr   )rN   rO   opsetids      rD   make_opsetidr~      s"     !""GGNGONrF   fnameopset_imports
attributesattribute_protosc                    |g }|g }|
g }
t                      }| |_        ||_        |j                            |           |j                            |           |j                            |           |j                            |           |j                            |           |j	                            |           |r||_
        |	|	|_        |j                            |
           |S rW   )r   rN   r`   rh   ri   rj   rn   opset_importrk   attribute_protora   rb   rw   )rN   r   r^   r_   ru   r   r   r   ra   rb   rw   fs               rD   make_functionr     s     

AAHAFGNN6HOOGFMM%N-(((Kz"""-... "!
L
###HrF   rz   c                    t                      }t          |_        |j                            |            d}|                    dd          }||j                            |           n1|j                                        }t          j
                    |_        d}|                    dd          }||j                            |           |                                D ]\  }}t          |||           |S )zConstruct a ModelProto

    Args:
        graph (GraphProto): *make_graph* returns
        **kwargs: any attribute to add to the returned instance
    Returns:
        ModelProto
    Nr   	functions)r   r   r<   rz   CopyFrompopr   ri   addr   onnx_opset_versionrO   r   rm   setattr)rz   rc   modelr   impr   kvs           rD   
make_modelr   %  s     LLE "E	K<@MJJ55M !!-0000  $$&&-//37I

;--Iy)))  1q!LrF   c                 |    d}||vr*d}|                     |g           }t          |          ||<   t          | fi |S )Nr<   r   )getr\   r   )rz   rc   ir_version_fieldopset_imports_fieldimportss        rD   make_model_gen_versionr   J  sV    #v%%-**0"55#:7#C#C e&&v&&&rF   proto
dict_valuec                     | j         d d = |                                D ],\  }}| j                                         }||_        ||_        -d S rW   )metadata_propsrm   r   rS   rg   )r   r   r   r   entrys        rD   set_metadata_propsr   S  s`     	QQQ  ""  1$((**	 rF   r   c                 &    t          | |           d S rW   )r   )r   r   s     rD   set_model_propsr   `  s    uj)))))rF   cac                 Z      fdt          t                     dz            D             S )Nc                 b    g | ]+}|d z  dk    r|d z           j         n|d z           j        ,S )r,   r   )realimag)rX   ir   s     rD   
<listcomp>z*split_complex_to_pairs.<locals>.<listcomp>e  sM        UaZZAFbajo  rF   r,   )rangelen)r   s   `rD   split_complex_to_pairsr   d  s@       s2ww{##   rF   fvaltruncatec                     t                               t          j        d|           d          }|r|dz	  S t	          |           rdS |dz	  dz  dz   }||z   dz	  S )N<flittler1   i  r#   i  )rH   
from_bytesstructpackr   )r   r   ivalroundeds       rD   float32_to_bfloat16r   q  sj    >>&+dD118<<D rzT{{ v 
a6)G7Nr!!rF         ?Tscalefnuzsaturatec                 j   |st          d          | |z  }t                              t          j        dt          j        |                    d          }|dz  dz	  }|r|dz  dk    rdS t          j        |          r	|r|dz  S dS |d	z  d
z	  }|dz  }	|dk     rd}n|dk     rm|dz
  }
|
dk    r|dd|
z   z  z  }||	d|
z
  z	  z  }n|	dk    r|dz  }nd}dd|
z
  z  }|	|z  r/|dz  s%|	|dz
  z  dk    s|	|z  r|	|dz  z  r|	|dz
  z  dk    r|dz  }n\|dk     rL|dz
  }
|
dk    r|dz  }||	dz	  z  }n||
dz  z  }||	dz	  z  }|	dz  r|	dz  s|	dz  r|dz  dk     r|dz  }n|sdS n
|r|dz  }nd}t          |          S |dz  dk    rd|z  S t          j        |          r|r|dz  S d|z  S |d	z  d
z	  }|dz  }	|dk    r|dk     rn|dk     rj|dz
  }
|
dk    r|dd|
z   z  z  }||	d|
z
  z	  z  }n|	dk    r|dz  }dd|
z
  z  }|	|z  r/|dz  s%|	|dz
  z  dk    s|	|z  r|	|dz  z  r|	|dz
  z  dk    r|dz  }np|dk     r]|dz
  }
|
dk    r|dz  }||	dz	  z  }n||
dz  z  }||	dz	  z  }|dz  dk    r|dz  }|	dz  r |	dz  s|	dz  r|dz  dk     r|dz  }n|s|dz  }n|r|dz  }n|dz  }t          |          S ) a  Convert a float32 value to a float8, e4m3 (as int).

    See :ref:`onnx-detail-float8` for technical details.

    Args:
        fval: float to convert
        scale: scale, divide *fval* by *scale* before casting it
        fn: no infinite values
        uz: no negative zero
        saturate: if True, any value out of range included inf becomes
            the maximum value, otherwise, it becomes NaN. The
            description of operator Cast fully describes the
            differences.

    Returns:
        converted float
    z4float32_to_float8e4m3 not implemented with fn=False.r   r                            t   r   x   w   r#   r,   r6   r5      r(   r"   i      i ~   u   y         )NotImplementedErrorrH   r   r   r   npfloat32isinfr   r   r   r   r   rY   bretemexmasks               rD   float32_to_float8e4m3r   ~  sd   0  
!B
 
 	
 	uAv{4A77BBAz>b
 C	 d
Nz))48A;; 	 !Sy 4^"
Ns77CCWWSBRxxqQV}$qR"W~%Qqb>D4x aq>A%%H &!"dai &56$(^q5H5H qWWSBQwws
qBwrQwqBw7{  X  1w;  $J$&&1HCC!  4 	4KCCC3xx
Nz))#:8A;; 	 !Sy #:^"
N663wwSW881R=(C1b>)CCUU1HCR"W~t8 !GD1H~))D *%&$!)_ *9:dQh19L9L 1HCSW773JC17NCC27NC17NCd
t++tK $q8| $W $d
d**q% $t s
t3xxrF   c                     | |z  }t                               t          j        dt	          j        |                    d          }|dz  dz	  }|r|r|dz  dk    rdS |dz  dk    r	|r|d	z  S dS |dz  d
z	  }|dz  }	|dk     rd}n|dk     rm|dz
  }
|
dk    r|dd|
z   z  z  }||	d|
z
  z	  z  }n|	dk    r|dz  }nd}dd|
z
  z  }|	|z  r/|dz  s%|	|dz
  z  dk    s|	|z  r|	|dz  z  r|	|dz
  z  dk    r|dz  }nW|dk     r8|dz
  }
||
dz  z  }||	dz	  z  }|	dz  r|	dz  s|	dz  r|d	z  d	k     r|dz  }n|sd}n|dk    r	|	dk    rd}n
|r|d	z  }nd}t          |          S |s|s|dz  dk    rd	|z  S t	          j        |          r|rd|z  S d|z  S |dz  d
z	  }|dz  }	|dk    r|dk     rn|dk     rj|dz
  }
|
dk    r|dd|
z   z  z  }||	d|
z
  z	  z  }n|	dk    r|dz  }dd|
z
  z  }|	|z  r/|dz  s%|	|dz
  z  dk    s|	|z  r|	|dz  z  r|	|dz
  z  dk    r|dz  }nT|dk     rA|dz
  }
||
dz  z  }||	dz	  z  }|	dz  r&|	dz  s|	dz  r|d	z  dk     r|dz  }n|r|dz  }n|dz  }n|r|dz  }n|dz  }t          |          S t          d          )a  Convert a float32 value to a float8, e5m2 (as int).

    Args:
        fval: float to convert
        scale: scale, divide *fval* by *scale* before casting it
        fn: no infinite values
        uz: no negative zero
        saturate: if True, any value out of range included inf becomes
            the maximum value, otherwise, it becomes NaN. The
            description of operator Cast fully describes the
            differences.

    Returns:
        converted float
    r   r   r   r   r   r   ir   r   r   r   m   r   p   o   r#      r6      r,   r   i i       {   |   n   q   z%fn and uz must be both False or True.)rH   r   r   r   r   r   r   r   r   s               rD   float32_to_float8e5m2r     s7   , 	uAv{4A77BBAz>b
 C	 aKb aK
Nz))4
Nz)) "Tz!4^"
Ns77CCWWSBRxxqQV}$qR"W~%Qqb>D4x aq>A%%H &!"dai &56$(^q5H5H qWWSB27NC17NC8| !g+ 1x< $J$&&1HCC! C#XX!q&&CC 	4KCCC3xx 0K 0K
Nz))#:8A;; 	 "cz!#:^"
N663wwSW881R=(C1b>)CCUU1HCR"W~t8 !GD1H~))D *%&$!)_ *9:dQh19L9L 1HCSWrQwqBwx< $a'k $q8| $d
d**q! $tt tt3xx!"IJJJrF   arraysignedc                    t          | t          j                  s t          j        | t          j                  } |                                 }t          j        | j                  dz  dk    }|r(t          j        |t          j	        dg                    }fd}t          j
        |dd          } ||ddd         |ddd                   }|                    t          j                  S )ax  Convert an array of float32 value to a 4bit data-type and pack every two concecutive elements in a byte.
    See :ref:`onnx-detail-int4` for technical details.

    Args:
        array: array of float to convert and pack
        signed: Whether the 4 bit variant is signed or unsigned

    Returns:
        Packed array with size `ceil(farray.size/2)` (single dimension).
    dtyper,   r#   r   c                 0    t          j        | |          S rW   )r!   float32x2_to_4bitx2)rY   yr   s     rD   <lambda>z&pack_float32_to_4bit.<locals>.<lambda>  s    w:1aHH rF   N)
isinstancer   ndarrayasarrayr   ravelprodshapeappendr   
frompyfuncastypeuint8)r   r   
array_flatis_odd_volumesingle_funcfuncarrs    `     rD   pack_float32_to_4bitr    s     eRZ(( 4
5
333JGEK((1,1M :Yz28QC==99
HHHHK=a++D
$z!$Q$ADqD!1
2
2C::bhrF   	data_typedimsvalsrawc           
         t                      }||_        | |_        |t           j        k    r|rt	          d          t          |          }d}|rj|t           j        k    rd}nW|t           j        t           j        t           j	        t           j
        fv rd}n$|t           j        t           j        fv rd}n|j        }t          |          t          j        u r,t#          |j                  dk    r|                                }|D ]}||z  }t#          |          |k    rS|t           j        t           j        fv rt#          |          |dz   k    s#t)          d| dt#          |           d          |r	||_        n|t           j        t           j        fv rt1          |          }n^|t           j        k    rkt          j        |                              |                              t          j                                                                                  }n|t           j        t           j        t           j        t           j	        t           j
        fv rt           j        t>          t           j        t@          t           j        d	 t           j	        tB          t           j
        d
 i|         }	tE          tG          |	t          j        |                              |                                                                                              }n|t           j        t           j        fv rY|t           j        k    }
tI          ||
                              |                                                                          }ny|t           j%        k    r-t          j        |                              tL                    }n<|t           j        k    r,t          j        |                              tN                    }tQ          |          }tS          ||          *                    |           |j+        *                    |           |S )a  Make a TensorProto with specified arguments.  If raw is False, this
    function will choose the corresponding proto field to store the
    values based on data_type. If raw is True, use "raw_data" proto
    field to store the values, and values should be of type bytes in
    this case.

    Args:
        name (string): tensor name
        data_type (int): a value such as onnx.TensorProto.FLOAT
        dims (List[int]): shape
        vals: values
        raw (bool): if True, vals contains the serialized content of the tensor,
            otherwise, vals should be a list of values of the type defined by *data_type*

    Returns:
        TensorProto
    z*Can not use raw_data to store string type.r#   r,   g      ?z8Number of values does not match tensor's size. Expected z, but it is z. r   c                      t          | ddiS )Nr   T)r   r=   s    rD   r   zmake_tensor.<locals>.<lambda>  s    :O;"; ; rF   c                      t          | dddS )NT)r   r   )r   r  s    rD   r   zmake_tensor.<locals>.<lambda>  s    :Odt; ; ; rF   )r   ),r   r  r`   STRING	TypeErrortensor_dtype_to_np_dtypeBFLOAT16FLOAT8E4M3FNFLOAT8E4M3FNUZ
FLOAT8E5M2FLOAT8E5M2FNUZUINT4INT4itemsizetyper   r   r   r   flattenrR   raw_data	COMPLEX64
COMPLEX128r   FLOAT16r   r   viewuint16tolistr   r   r   listmapr  BOOLrH   bytestensor_dtype_to_fieldgetattrri   r  )r`   r  r  r  r  tensornp_dtypeexpected_sizedfcastr   fields               rD   make_tensorr*    s   ( ]]F FFKK&&&3&DEEE'	22H M
 .,,,MM$&"&	
 
 
 MM;,k.>???MM$-MDzzRZC
OOa$7$7||~~  
4yyM!! ++[-=>>>D		]S000s=ssfijnfofosss    3,.0FGGG)$//DD+---%%h//44294EEMMOOVVXX D  $&"&
 
 
 $&9(*?* - - &(=* - -
 E HTNN))(33;;==DDFF  DD 
 
 
 +"22F$T&999!!	 D +***8D>>((--DD+,,,8D>>((//D%i00%%d+++
KtMrF   valuesindicesc                     t                      }|j                            |            |j                            |           |j                            |           |S )zConstruct a SparseTensorProto

    Args:
        values (TensorProto): the values
        indices (TensorProto): the indices
        dims: the shape

    Returns:
        SparseTensorProto
    )r   r+  r   r,  r  ri   )r+  r,  r  sparses       rD   make_sparse_tensorr/    sV       F
M6"""
NG$$$
KtMrF   	elem_typec                    t                      }| |_        ||_        |t           j        k    r|S |t           j        k    r|j        }no|t           j        k    r|j        }nW|t           j        k    r|j	        }n?|t           j
        k    r|j        }n'|t          j        k    r|j        }nt          d          |                    |           |S )z/Make a Sequence with specified value arguments.z8The element type in the input sequence is not supported.)r   r`   r0  	UNDEFINEDTENSORtensor_valuesSPARSE_TENSORsparse_tensor_valuesSEQUENCEsequence_valuesMAP
map_valuesr   OPTIONALoptional_valuesr  ri   )r`   r0  r+  sequencerk   s        rD   make_sequencer>  )  s     HHM"HM+++M(((*			m1	1	11			m,	,	,,			m'	'	''			m,	,	,,		RSSSVOrF   key_typekeysc                    t                      }t          j        t          j        t          j        t          j        t          j        t          j        t          j        t          j	        g}| |_
        ||_        |t          j        k    r|j                            |           n||v r|j                            |           |j                            |           |S )zMake a Map with specified key-value pair arguments.

    Criteria for conversion:
    - Keys and Values must have the same number of elements
    - Every key in keys must be of the same type
    - Every value in values must be of the same type
    )r   r   INT8INT16INT32INT64UINT8UINT16UINT32UINT64r`   r?  r
  string_keysri   r@  r+  r   )r`   r?  r@  r+  	map_protovalid_key_int_typess         rD   make_maprM  F  s     

I	 IN!I;%%%$$T****	(	(	(d###f%%%rF   rg   c                    t                      }| |_        ||_        |t           j        k    r|S |t           j        k    r|j        }no|t           j        k    r|j        }nW|t           j        k    r|j	        }n?|t           j
        k    r|j        }n'|t           j        k    r|j        }nt          d          |                    |           |S )z0Make an Optional with specified value arguments.z8The element type in the input optional is not supported.)r   r`   r0  r2  r3  tensor_valuer5  sparse_tensor_valuer7  sequence_valuer9  	map_valuer;  optional_valuer  r   )r`   r0  rg   optionalrk   s        rD   make_optionalrU  e  s     HHM"HM+++M((()			m1	1	10			m,	,	,+			m'	'	'&			m,	,	,+		RSSSuOrF   c                 Z    t          | t                    r| n|                     d          S )z2Coerce a string (or bytes) value into UTF-8 bytes.utf-8)r   r!  encode)rg   s    rD   	_to_bytesrY    s'    ue,,G55%,,w2G2GGrF   rS   	attr_typec                 t
   t                      }| |_        |r||_        t          |t          j                  r't          |          |_        t           j        |_	        nt          |t          j
                  r't          |          |_        t           j        |_	        nIt          |t          t          f          r't!          |          |_        t           j        |_	        nt          |t&                    r-|j                            |           t           j        |_	        nt          |t.                    r-|j                            |           t           j        |_	        nt          |t4                    r-|j                            |           t           j        |_	        n@t          |t:                    r-|j                            |           t           j        |_	        nt          |t@          j!        j"                  rtG          |          }tI          |          dk    r|tK          d|  d          |d |D             }t          j        t           j&        ft          j
        t           j'        ft          t          ft           j(        ft&          t           j)        ft.          t           j*        ft4          t           j+        ft:          t           j,        ffD ]$\  }t[          fd|D                       r|} n%|tK          d          |t           j&        k    r-|j.        /                    |           t           j&        |_	        n|t           j'        k    r-|j0        /                    |           t           j'        |_	        nX|t           j(        k    r7|j1        /                    d |D                        t           j(        |_	        n|t           j)        k    r,|j2        /                    |           t           j)        |_	        n|t           j*        k    r,|j3        /                    |           t           j*        |_	        n|t           j+        k    r,|j4        /                    |           t           j+        |_	        n]|t           j,        k    r,|j5        /                    |           t           j,        |_	        n!tm                      to          d	| d
          |K|j	        |k    r@to          dtq          |j	                   d|j	         dtq          |           d| d	          |S )z0Makes an AttributeProto based on the value type.r   NzCould not infer attribute `z` type from empty iteratorc                 ,    h | ]}t          |          S  )r  rX   r   s     rD   	<setcomp>z!make_attribute.<locals>.<setcomp>  s    ,,,T!WW,,,rF   c              3   8   K   | ]}t          |          V  d S rW   )
issubclass)rX   texp_ts     rD   rZ   z!make_attribute.<locals>.<genexpr>  s-      ;;z!U++;;;;;;rF   zRCould not infer the attribute type from the elements of the passed Iterable value.c              3   4   K   | ]}t          |          V  d S rW   )rY  r^  s     rD   rZ   z!make_attribute.<locals>.<genexpr>  s(      <<	!<<<<<<rF   'z%' is not an accepted attribute value.zInferred attribute type 'z'(z") mismatched with specified type '))9r   r`   ra   r   numbersIntegralrH   r   INTr  Realfloatr   FLOATrG   r!  rY  sr
  r   rb  r   r3  r   sparse_tensorr5  r   gGRAPHr   tp
TYPE_PROTOcollectionsabcIterabler  r   rR   INTSFLOATSSTRINGSTENSORSSPARSE_TENSORSGRAPHSTYPE_PROTOSallintsri   floatsstringstensorssparse_tensorsgraphstype_protosAssertionErrorr  _attr_type_to_str)rS   rg   ra   rZ  attrtypesexp_enumrc  s          @rD   rf   rf     s    DDI %$ %)** HJU"&			E7<	(	( EJu"(			EC<	(	( BJ5!!")			E;	'	' >J")			E,	-	- ;J##E***"0			E:	&	& 8J"(			E9	%	% 5J"-			E;?3	4	4 1JUu::??y0McMMM   ,,e,,,E!>#67~45u~56n45"N$AB^23N67$  x ;;;;U;;;;;  (IE   h   +++IU###&+DII.///Ku%%%&-DII.000L<<e<<<<<<&.DII.000L&&&&.DII.777&&u---&5DII.///Ku%%%&-DII.444##E***&2DII """HEHHHIIIi!7!7 b(9$)(D(D  b  b	  b  b  vG  HQ  vR  vR  b  b  V_  b  b  b
 
 	
 KrF   c                 P    t                      }| |_        ||_        |r||_        |S )zeMake an AttributeProto holding a reference to the parent function's attribute of given name and type.)r   r`   r  ra   )r`   rZ  ra   r  s       rD   make_attribute_refr    s1     DDIDI %$KrF   r  c                 L   | j         rt          d|            | j        t          j        k    r| j        S | j        t          j        k    r| j        S | j        t          j        k    r| j	        S | j        t          j
        k    r| j        S | j        t          j        k    r| j        S | j        t          j        k    r| j        S | j        t          j        k    r| j        S | j        t          j        k    rt'          | j                  S | j        t          j        k    rt'          | j                  S | j        t          j        k    rt'          | j                  S | j        t          j        k    rt'          | j                  S | j        t          j        k    rt'          | j                  S | j        t          j        k    rt'          | j                  S | j        t          j        k    rt'          | j                   S | j        t          j!        k    rd S t          d|            )Nz)Cannot get value of reference attribute: zUnsupported ONNX attribute: )"ref_attr_namerR   r  r   rl  r   ri  r   r
  rm  r3  rb  r5  rn  rp  ro  rr  rq  rw  r  r  rv  r~  rx  r  ry  r  rz  r  r{  r  r|  r  r2  )r  s    rD   get_attribute_valuer    s    MKTKKLLLyN(((vyN&&&vyN)))vyN)))vyN000!!yN(((vyN---wyN)))DK   yN'''DIyN***DL!!!yN***DL!!!yN111D'(((yN)))DK   yN...D$%%%yN,,,t
:D::
;
;;rF   rn   	attr_namec                     fd| j         D             }t          |          dk    rt          d           t          |          dk     rt          d           t          |d                   S )Nc                 *    g | ]}|j         k    |S r]  r`   )rX   rY   r  s     rD   r   z'get_node_attr_value.<locals>.<listcomp>  s%    AAAaQVy-@-@-@-@-@rF   r#   z'Node has multiple attributes with name z Node has no attribute with name r   )rk   r   rR   r  )rn   r  matchings    ` rD   get_node_attr_valuer    s    AAAA4>AAAH
8}}qN9NNOOO
8}}qGIGGHHHx{+++rF   c                 0    t                      }| |_        |S rW   )r   r`   )r`   value_info_protos     rD   make_empty_tensor_value_infor    s    %'' rF   r   shape_denotationc                     t                      }|j        }| |_        |j        }||j                            g            |r/t          |          t          |          k    rt          d          t          |          D ]}\  }}|j        	                                }|nMt          |t                    r||_        n0t          |t                    r||_        nt          d| d          |r||         |_        ~|S )z:Makes a Tensor TypeProto based on the data type and shape.N>Invalid shape_denotation. Must be of the same length as shape.Invalid item in shape: z. Needs to be of int or str.)r   tensor_typer0  r   dimri   r   rR   	enumerater   r   rH   	dim_valuerG   	dim_param
denotation)	r0  r   r  
type_prototensor_type_prototensor_shape_protor   r'  r  s	            rD   make_tensor_type_protor  $  s)    J"."+*0 	%%b))) 	$4 5 5U C CP   e$$ 	5 	5DAq$(,,..CyAs##  !As##  ! MaMMM     5!1!!4rF    c                     t                      }| |_        |r||_        t          |||          }|j                            |           |S )z8Makes a ValueInfoProto based on the data type and shape.)r   r`   ra   r  r  r   )r`   r0  r   ra   r  r  r  s          rD   make_tensor_value_infor  Q  s[     &''  1&0#.y%AQRR""#4555rF   c                     t                      }|j        }| |_        |j        }||j                            g            |r/t          |          t          |          k    rt          d          t          |          D ]}\  }}|j        	                                }|nMt          |t                    r||_        n0t          |t                    r||_        nt          d| d          |r||         |_        ~|S )z@Makes a SparseTensor TypeProto based on the data type and shape.Nr  r  z. Needs to be of int or text.)r   sparse_tensor_typer0  r   r  ri   r   rR   r  r   r   rH   r  rG   r  r  )	r0  r   r  r  sparse_tensor_type_protosparse_tensor_shape_protor   r'  r  s	            rD   make_sparse_tensor_type_protor  c  s)    J)<)2& 8 > 	"%,,R000 	$4 5 5U C CP   e$$ 	5 	5DAq+/3355CyAs##  !As##  ! NaNNN     5!1!!4rF   c                     t                      }| |_        |r||_        t          |||          }|j        j                            |j                   |S )zEMakes a SparseTensor ValueInfoProto based on the data type and shape.)r   r`   ra   r  r  r  r   )r`   r0  r   ra   r  r  r  s          rD   make_sparse_tensor_value_infor    sp     &''  1&0#<5*    ,55 3   rF   inner_type_protoc                 `    t                      }|j        j                            |            |S )zMakes a sequence TypeProto.)r   sequence_typer0  r   r  r  s     rD   make_sequence_type_protor    .     J&//0@AAArF   c                 `    t                      }|j        j                            |            |S )zMakes an optional TypeProto.)r   optional_typer0  r   r  s     rD   make_optional_type_protor    r  rF   
value_typec                 x    t                      }| |j        _        |j        j                            |           |S )zMakes a map TypeProto.)r   map_typer?  r  r   )r?  r  r  s      rD   make_map_type_protor    s8    
 J#+J "++J777rF   r  c                 v    t                      }| |_        |r||_        |j                            |           |S )z1Makes a ValueInfoProto with the given type_proto.)r   r`   ra   r  r   )r`   r  ra   r  s       rD   make_value_infor    sG     &''  1&0#"":...rF   rm  c                    t          | t                    r| }n<t          | t                    r|                     dd          }nt          |           }t	          |          dk     r|S |d d         dt	          |          dz
   dz   S )NrW  ignore)errors@   z	...<+len=>)r   rG   r!  decoder   )rm  	sanitizeds     rD   _sanitize_strr    s    !S 			Au		 HHWXH66		FF	
9~~SbS>@Y")<@@@@@rF   elem_shape_denotationc                     t                      }| |_        |r||_        t          |||          }t	          |          }|j        j                            |j                   |S )zJMakes a Sequence[Tensors] ValueInfoProto based on the data type and shape.)r   r`   ra   r  r  r  r  r   )r`   r0  r   ra   r  r  r  sequence_type_protos           rD   make_tensor_sequence_value_infor    sp     &''  1&0#.y%AVWW23DEE'001D1RSSSrF   	subgraphsc           
      D	   g }|                     | j                   |                     d           dt          dt          fd}dt          dt          fd}t          d          }dt          |gt          f         d	t          |         dt          fd
}g }|                     d          r%|                      || j	                             n|                     d          r%|                      || j
                             nl|                     d          r6|                     t          t          | j                                       n!|                     d          r{t          | j        j                  dk    r|                     d           nt#          | j        j                  }|                     dt'          | j        |           d           n|                     d          r?|                     d| j        j         d           |                     | j                   n=|                     d          r |                     d| j         d           n| j        r&|                      ||| j                             n| j        r&|                      ||| j                             n| j        rI|                     t          t3          t5          t          | j                                                 n^| j        r|                     d           n@| j        r|                     d           t;          | j                  D ]?\  }	}
|	t          | j                  dz
  k    rdnd}|                     d|
 d|            @|                     d           n| j        r|                     d           t;          | j                  D ]D\  }	}|	t          | j                  dz
  k    rdnd}|                     d|j         d|            E|                     d           |                    | j                   n|                     d           |rd                     |          |fS d                     |          S )N=r   r9   c                 
    | dS )Nz.15gr]  )r   s    rD   	str_floatz&printable_attribute.<locals>.str_float  s     {{rF   r   c                      t          |           S rW   )rG   )r   s    rD   str_intz$printable_attribute.<locals>.str_int  s    1vvrF   _Tstr_elemxsc                 T    dd                     t          | |                    z   dz   S )N[, ])joinr  )r  r  s     rD   str_listz%printable_attribute.<locals>.str_list  s(    TYYs8R00111C77rF   rm  rb  r   z<Tensor>z<Scalar Tensor r  ro  z<graph rq  z<Type Proto z[<Tensor>, ...]r  r#   ,r  r  z	<Unknown> )!r   r`   rk  rG   rH   r   r   r
   HasFieldr   r   reprr  rm  r   rb  r  r"  r  r#  ro  rq  r  r~  r  r  r  r  r  r  r  ri   r  )r  r  contentr  r  r  r  r  r)  r   rq  commaro  s                rD   printable_attributer    s    GNN49NN3U s    3 3     
B88RD#I. 8HRL 8S 8 8 8 8 F}}S *$yy(())))	s		 ($wwtv''''	s		 &$tM$&11223333	s		 #$tv{aNN:&&&& *$&*:;;ENNFWTVU-C-CFFFGGGG	s		 $////000df	t		 $0dg0001111	 $xx	4;778888	 $xx334444	 $s4M4< @ @AABBCCCC	 $())))		 $st/00 	8 	8EArD$4 5 5 999CCrENN6"66u667777s	 $sdk** 	7 	7DAqDK 0 01 444CC"ENN5QV55e556666sdk""""{### )xx  &((88GrF   r  c                 n    |                      d          }|dS t          t          | |                    S )Nrg   ?)
WhichOneofrG   r#  )r  whichs     rD   printable_dimr  >  s5    NN7##E}swsE""###rF   rb  c           
         |                      d          dk    rt          j                            | j        j                  }| j                            d          rnt          | j        j        j	                  rK|t          dd                    t          t          | j        j        j	                            z             z  }n|dz  }|S |                      d          dS d|                      d           S )	Nrg   r  r   r  rY   , scalarr  zUnknown type )r  r   DataTypeNamer  r0  r  r   r   r  rG   r  r  r  rb  rm  s     rD   printable_typer  E  s    ||G-- %%am&=>>=!!'** 	 1=&*++  S]AM<O<S)T)T U UUVVVZ||G$r21<<00222rF   r   c                 \    d| j          }| j        r| dt          | j                   d}|S )N%r  r  )r`   r  r  )r   rm  s     rD   printable_value_infor  S  s>    AFAv -,,>!&)),,,HrF   c           
      6   d| j          d}|t          j                            | j                  z  }| j        Zt          | j                  rA|t          dd                    t          t          | j                            z             z  }n|dz  }|dz  }|S )Nr  r  r  rY   r  r  )
r`   r   r  r  r  r  r   rG   r  r  r  s     rD   printable_tensor_protor  Z  s    AFA		"	"1;	/	//Avqv;; 	TCHHSaf%5%5666777AAOAHAHrF   prefixc                    g }t          | j                  rL|                    d                    d | j        D                                  |                    d           g }g }| j        D ]}|rzt          ||          }t          |d         t                    st          dt           d          |	                    |d                    |                    |d                    ~t          |          }t          |t                    st          dt           d          |                    |           d                    t          |                    }	d                    d	 | j        D                       }
| j        r$|                    | j         d
|	 d|
 d           n |                    | j         d|
 d           |r|d                    |          z   |fS |d                    |          z   S )Nr  c                     g | ]}d | S r  r]  rX   r`   s     rD   r   z"printable_node.<locals>.<listcomp>k  s    !E!E!E*d**!E!E!ErF   r  r#   z1printed_attr_subgraphs[1] must be an instance of .r   zprinted must be an instance of c                     g | ]}d | S r  r]  r  s     rD   r   z"printable_node.<locals>.<listcomp>  s    BBBt
D

BBBrF   r  z](rf  (r  )r   rj   r   r  rk   r  r   r  r  ri   rG   rl   rh   r]   )rn   r  r  r  r  printed_attrsr  printed_attr_subgraphsprintedprinted_attributesprinted_inputss              rD   printable_noder  f  s&    G
4; tyy!E!E!E!E!EFFGGGs!FM * * 	*%8y%I%I"4Q7>> OOOO   MM03444  !7!:;;;;)$//Ggs++ J H# H H HIII  ))))6-#8#899YYBBtzBBBCCN~ <$,PP);PP~PPPQQQQ$,:::::;;; 2)))611CHHW%%%%rF   c                    g }|dz   }d| j         g}d | j        D             }t          | j                  r	|                    d           g }g }| j        D ]P}|j         |vr#|                    t          |                     .|                    t          |                     Q|rM|                    |d                    |          z              g }|D ]}	|                    |dz   |	z              |                    d           |rw|                    d           |                    |d                    |          z              g }|D ]}	|                    |dz   |	z              |                    d           t          |          t          |          k     rd | j        D             fd	| j        D             }
|                    d
           |                    |d                    |          z              g }|
D ]}	|                    |dz   |	z              |                    d           |                    d           |                    |d                    |          z              g }| j        D ]}}t          ||d          }t          |d         t                    st          dt           d          |                    |d                    |                    |d                    ~dg}t          | j                  r7|                    d                    d | j        D                                  |                    |d                    |          z              |                    |dz              |D ]'}|                    dt          |          z              (d                    |          S )zDisplay a GraphProto as a string.

    Args:
        graph (GraphProto): the graph to display
        prefix (string): prefix of every line

    Returns:
        string
    z  rz   c                     h | ]	}|j         
S r]  r  )rX   rb  s     rD   r_  z"printable_graph.<locals>.<setcomp>  s    666qAF666rF   r  r  rf  z,optional inputs with matching initializers (c                     h | ]	}|j         
S r]  r  )rX   r   s     rD   r_  z"printable_graph.<locals>.<setcomp>  s    888qAF888rF   c                 @    g | ]}|j         vt          |          S r]  )r`   r  )rX   r   graph_inputss     rD   r   z#printable_graph.<locals>.<listcomp>  s8       6-- 'q))---rF   zinitializers ({T)r  r#   z-contents_subgraphs[1] must be an instance of r  r   r9   r  c                 "    g | ]}d |j          S r  r  )rX   outs     rD   r   z#printable_graph.<locals>.<listcomp>  s     FFF#~38~~FFFrF   }
)r`   rv   r   rh   r   r  r  rn   r  r   r  r  ri   rj   printable_graph)rz   r  r  indentheaderinitializersin_strsin_with_init_strsinpline	init_strsr  rn   contents_subgraphstailro  r  s                   @rD   r
  r
    s    Gd]Fuz"F66E$5666L
5; (c 	 ; 	D 	DCx|++3C889999!(()=c)B)BCCCC 	5NN6CHHV$4$44555F 5 5v}t34444c 	MMHIIINN6CHHV$4$44555F) 5 5v}t34444MM#  !!C$5$55588EK888L   *  I
 MM*+++NN6CHHV$4$44555F! 5 5v}t34444MM#
MM#NN6CHHV,,,---!F
 - -+D&DIII,Q/66 	USDSSSTTT)!,---(+,,,,:D
5< IDIIFFFFFGGHHHNN6CHHTNN*+++NN6C<    2 2toa000111199WrF   c                    t          | t          j        j        j                  s't          dt          j        j        j         d          | j        j        D ]}|j        dk    r| 	                    |j                   (|j
        |j        k    rt|j        |j        k    r(t          | |j                  D ]}t          |           p|                     |j                  r"t          t          | |j                             dS )z:Empties `doc_string` field on any nested protobuf messageszproto must be an instance of r  ra   N)r   googleprotobufmessageMessager  
DESCRIPTORfieldsr`   
ClearFieldr  TYPE_MESSAGElabelLABEL_REPEATEDr#  strip_doc_stringr  )r   
descriptorrY   s      rD   r   r     s   eV_4<== 
NFO,C,KNNN
 
 	
 &- B B
?l**Z_----_
 777:#<<< 
88 ( (A$Q''''(
00 B 
!@!@AAAB BrF   	algorithmalgorithm_bindingsinitializationinitialization_bindingsc                 N   t                      }|j                            |            |D ],\  }}|j                                        }||_        ||_        -|r|j                            |           |r/|D ],\  }}|j                                        }||_        ||_        -|S rW   )	r   r"  r   update_bindingr   rS   rg   r$  initialization_binding)r"  r#  r$  r%  training_infor   r   bindings           rD   make_training_infor+    s     &''M$$Y///"  1.2244 >$--n=== + 	 	DAq#:>>@@GGKGMMrF   tensor_dtypec                 0    t           j        |          j        S )zConvert a TensorProto's data_type to corresponding numpy dtype. It can be used while making tensor.

    Args:
        tensor_dtype: TensorProto's data_type

    Returns:
        numpy's data_type
    )r    TENSOR_TYPE_MAPr%  r,  s    rD   r  r    s     "<099rF   c                 0    t           j        |          j        S )zConvert a TensorProto's data_type to corresponding data_type for storage.

    Args:
        tensor_dtype: TensorProto's data_type

    Returns:
        data_type for storage
    )r    r.  storage_dtyper/  s    rD   $tensor_dtype_to_storage_tensor_dtyper2    s     "<0>>rF   c                 0    t           j        |          j        S )zGet the name of given TensorProto's data_type.

    Args:
        tensor_dtype: TensorProto's data_type

    Returns:
        the name of data_type
    )r    r.  r`   r/  s    rD   tensor_dtype_to_stringr4    s     "<055rF   c                 P    t           j        t           j        |          j                 S )zConvert a TensorProto's data_type to corresponding field name for storage. It can be used while making tensors.

    Args:
        tensor_dtype: TensorProto's data_type

    Returns:
        field name
    )r    _STORAGE_TENSOR_TYPE_TO_FIELDr.  r1  r/  s    rD   r"  r"  &  s"     0-; rF   r%  c                 L    t          t          t          j        |                    S )zConvert a numpy's dtype to corresponding tensor type. It can be used while converting numpy arrays to tensors.

    Args:
        np_dtype: numpy's data_type

    Returns:
        TensorsProto's data_type
    )r   rH   r    _NP_TYPE_TO_TENSOR_TYPE)r%  s    rD   np_dtype_to_tensor_dtyper9  4  s$     '1  rF   c                  >    t           j                                        S )zcGet all tensor types from TensorProto.

    Returns:
        all tensor types from TensorProto
    )r    r.  r@  r]  rF   rD   get_all_tensor_dtypesr;  C  s     "'')))rF   c                     i | ]\  }}||	S r]  r]  )rX   r   r   s      rD   
<dictcomp>r=  L  s    PPP41a!QPPPrF   c                     | t           j                                        v rt          |          S t           j                                        d         S )zConvert AttributeProto type to string.

    Args:
        attr_type: AttributeProto type.

    Returns:
        String representing the supplied attr_type.
    r   )r   AttributeTyper+  _ATTRIBUTE_TYPE_TO_STRr@  )rZ  s    rD   r  r  O  sC     N0779999%i00',,..q11rF   )F)NNNN)NNNNN)r   TFT)r   FFT)NNrW   )r  N)r  )r  F)vcollections.abcrs  rg  r   cmathr   typingr   r   r   r   r   r	   r
   r   r   r   r   google.protobuf.messager  numpyr   onnxr   r   r   r   r   r   r   r   r   r   r   r   r   r   r   r   r   r    r!   rG   rH   VersionRowTypeVersionTableTypeAssignmentBindingTyper7   __annotations__VersionMapTyperJ   rQ   boolr\   ro   rt   r{   r~   r   r   r   r   r   	complex64r   rk  r   r   r   r   r  r*  r/  r  r>  rM  rU  r!  rY  rf   r?  r  r  r  r  r  r  r  r  r  r  r  r  r  r  r  	Dimensionr  r  r  r  r  r
  r  r  r  r   r+  r   r  r2  r4  r"  r9  r;  rm   r@  r  r]  rF   rD   <module>rO     s  
                                                                                       , uS#sC/0%S#sC8O2PPQ' U38_- # # #   6 eCHos*+(8 ^    " 54]CC  GL ,-?C   @  $ ". ..SM. c]. 3-	.
 . SM. sm. . . . . .b    . 48 $59@D( (I(
( ^$( n%	(
 (;/0( ( .12( !*;!<=( ( ( ( (V s /A    , +/;? $"59! !!! SM! c]	!
 I! ./! #'! x78! ! sm! .12! ! ! ! !H j  C  J        J'* ' '
 ' ' ' '
Jy+~U
 S#X	

 

 
 
 
*: *4S> *d * * * *x5 (3-    
" 
"e 
"t 
" 
" 
" 
" 
" C C
CC 	C 		C
 C 	C C C CP {K {K
{K{K 	{K 		{K
 {K 	{K {K {K {K| X%& 04 Z       : LQt t
tt%-c]t:=tDHtt t t tn"-5=c]   (
% SM 	   :
$(I7D   >
% C= 	   :HU3:& H5 H H H H !%#	[ [	[[ [ }	[
 [ [ [ [~ UY	 	
	(6	DLSM		 	 	 	!<n !< !< !< !< !<H,i ,C ,C , , , ,s ~     -1* **HU3T>234* tCy)* 	* * * *b ,0 
 HU3T>234 	
 tCy)    * -1* **HU3T>234* tCy)* 	* * * *b ,0 
 HU3T>234 	
 tCy)    ,            
  	   	AU3:& 	A3 	A 	A 	A 	A  15 
 HU3T>234 	
 $DI.    * -2I I
I%)I
3c4
++,,-I I I IX$'1 $c $ $ $ $3i 3C 3 3 3 3N s    	k 	c 	 	 	 	 :? &  &
 &  &26 &
3c4
++,,- &  &  &  &FL L: Ls LC L L L L^BFO3; B B B B B"- Z( &&;<	
    2	:3 	:28 	: 	: 	: 	:	?s 	?s 	? 	? 	? 	?	6 	6 	6 	6 	6 	6     rx C    *x} * * * * QP>+G+M+M+O+OPPP 2 2 2 2 2 2 2 2rF   