
    .`ihd                     	   U d dl Z d dlZd dlZd dlZd dlZd dlmZmZ d dl	m
Z
 d dlmZmZmZ d dlZd dlmZ d dlZd dlmZ d dlmZ d dlmZmZ d dlmZ erd dlmZ d d	lm Z  ne!Ze!Z d dl"Z" e"j#        e$          Z%ej&        ej'        ej(        ej)        ej*        ej+        ej+        ej+        ej,        ej-        ej+        d
Z.ej(        ej(        ej&        ej&        ej/        ej/        ej+        ej+        ej0        ej0        ej1        ej1        iZ2ddiZ3 ed          Z4dej5        de6fdZ7e j8        dej9        fd            Z:e j8        de;fd            Z<e j8        d             Z=dej9        de;fdZ>dej9        de;fdZ?dej9        dej9        fdZ@deej9                 fdZAdej5        de*de*ddfd ZB	 dhd!eCej9        z  dz  d"eCej9        z  dz  dej9        fd#ZDd$eEeCef         deCdz  fd%ZFd$eEeCef         dej9        dz  fd&ZGd'eCd(edeCfd)ZHd'eCd(edej9        fd*ZId+e;dz  ddfd,ZJ	 	 	 	 did/e;d0e;d1e;d2e;d3e;d!eCej9        z  dz  d"eCej9        z  dz  d+e;dz  d4eCdz  d5eCdz  deKeLej5                 eLej5                 f         fd6ZM	 	 	 djd/e;d0e;d1e;d2e;d3e;d!eCej9        z  dz  d"eCej9        z  dz  d+e;dz  d4eCdz  deKeLej5                 eLej5                 f         fd7ZNd8eLdej9        d9eCejO        z  d:e6dej5        f
d;ZPdd<d=eLeLe4                  d>e4dejQ        d?e;dz  dejR        f
d@ZSdddAdBd=eLeLe4                  d>e4dej9        d?e;dz  d4eCejO        z  dz  d:e6dej5        fdCZTejU        jV        ZW ejX                    ZYdDejU        jZ        ddfdEZ[e[ejU        _V         G dF dG          Z\dejU        jZ        fdHZ]da^ejU        jZ        dz  e_dI<   dejU        jZ        dz  fdJZ` e
dKL          dhdMeCdz  de;fdN            Zade;fdOZbdedefdPZcdQej5        eLej5                 z  eKej5                 z  e z  dej5        eLe         z  eKe         z  ez  fdRZddSej5        dej5        fdTZedUeCdVeCde6fdWZfdVeCde6fdXZgdVeCde6fdYZhdVeCde6fdZZide6fd[Zj ed\d]          Zk	 	 	 	 	 dkd_eCd`edaeLeC         dz  dbedz  dcedz  ddeCdz  deeKejl        dff         fdgZmdS )l    N)Callable
Collection)	lru_cache)TYPE_CHECKINGAnyTypeVar)version)Version)Libraryinfer_schema)ModelConfigIntermediateTensors)float32halffloat16bfloat16floatfp8fp8_e4m3fp8_e5m2int8fp8_inc
fp8_ds_mlar   r   Ttreturnc                     |                                  sdS | j        }|                                 }d}t          t	          |          dz
  dd          D ]}||         |k    r dS |||         z  }dS )a  
    Check if tensor is contiguous AND has no degenerate strides.

    A degenerate stride occurs when a dimension has size 1 but the stride
    doesn't match the canonical contiguous layout. This can cause issues
    in some CUDA kernels that rely on stride values for memory access.

    For a C-contiguous tensor of shape (d0, d1, ..., dn), the expected
    strides are: stride[i] = product(shape[i+1:]) for all i, with stride[-1]=1.

    Example with torch.Size([16, 1, 8, 32]):
        - Canonical strides: (256, 256, 32, 1)
        - Degenerate strides: (256, 1, 32, 1)  # dim=1 has size=1, allowing
                                                  # non-canonical stride in dim=0
    F   T)is_contiguousshapestriderangelen)r   r"   stridesexpected_strideis        j/home/jaya/work/projects/VOICE-AGENT/VIET/agent-env/lib/python3.11/site-packages/vllm/utils/torch_utils.pyis_strictly_contiguousr*   C   s      ?? u GEhhjjGO3u::>2r** $ $1:((5558#4    dtypec              #      K   t          j                    }t          j        |            dV  t          j        |           dS )z0Sets the default torch dtype to the given dtype.N)torchget_default_dtypeset_default_dtype)r,   	old_dtypes     r)   set_default_torch_dtyper2   a   sG       '))I	E"""	EEE	I&&&&&r+   num_threadsc              #      K   t          j                    }t          j        |            dV  t          j        |           dS )zBSets the default number of threads for PyTorch to the given value.N)r.   get_num_threadsset_num_threads)r3   old_num_threadss     r)   set_default_torch_num_threadsr8   j   sG       +--O	+&&&	EEE	/*****r+   c               #     K   ddl m}  |                                 sdV  dS t          j                            d          }dt          j        d<   	 dV  nE# t          $ r8}dt          |          v rd}nt          |          }t          |          |d}~ww xY w	 |t          j        d= dS |t          j        d<   dS # |t          j        d= n|t          j        d<   w xY w)z%Avoid unexpected CUDA initialization.r   current_platformNCUDA_VISIBLE_DEVICES zNo CUDA GPUs are availablezCUDA initialization is blocked.)	vllm.platformsr;   is_cudaosenvironget	ExceptionstrRuntimeError)r;   	old_valueeerr_msgs       r)   guard_cuda_initializationrI   s   s       0/////##%% 
566I)+BJ%&; + + +'3q66117GG!ffG7##*+ 	 
12221:BJ-... 
1221:BJ-.::::s*   A B? 
B!3BBB? ?!C c                 R    t          j        g |                                           S )z'Get the size of the data type in bytes.r,   )r.   tensorelement_sizerK   s    r)   get_dtype_sizerN      s#    <%(((55777r+   c                 H    | t           j        k    | j        z   | j        dz  z   S )N   )r.   boolis_floating_point
is_complexrK   s    r)   _get_precision_levelrT      s%    UZ5#::U=MPQ=QQQr+   	src_dtype	tgt_dtypec                    | |k    rdS t          |           }t          |          }||k     rdS ||k    rdS | j        sO| j        sHt          j        |           }t          j        |          }|j        |j        k    o|j        |j        k    S t          j        |           }t          j        |          }|j        |j        k    o|j        |j        k    o|j        |j        k    S )z[
    Test whether it is lossless to cast a tensor from
    `src_dtype` to `tgt_dtype`.
    TF)	rT   rR   rS   r.   iinfominmaxfinfo
resolution)rU   rV   	src_level	tgt_levelsrc_infotgt_infos         r)   is_lossless_castra      s    
 It$Y//I$Y//I9t9u & My/C M;y));y))|x|+L0LL {9%%H{9%%H$ 	7LHL(	78#66r+   dtypesc                 ,     t            fd          S )zv
    Get the common `dtype` where all of the other `dtypes` can be
    cast to it without losing any information.
    c                 <     t           fdD                       S )Nc              3   8   K   | ]}t          |          V  d S N)ra   ).0dtr,   s     r)   	<genexpr>z?common_broadcastable_dtype.<locals>.<lambda>.<locals>.<genexpr>   s.      KKb.r599KKKKKKr+   )sum)r,   rb   s   `r)   <lambda>z,common_broadcastable_dtype.<locals>.<lambda>   s%    #KKKKFKKKKK r+   )key)rZ   )rb   s   `r)   common_broadcastable_dtyperm      s+    
 KKKK   r+   rL   lowhighc                     ddl m} t          j        | t          j                  }|                    ||           |                    | |           ~d S )Nr   )_custom_opsrK   )vllmrq   r.   
empty_liker   uniform_convert_fp8)rL   rn   ro   ops
tensor_tmps        r)   _generate_random_fp8rx      s^     ('''''!&>>>JT"""OOFJ'''

r+   cache_dtypemodel_dtypec                    t          | t                    r| dk    r[t          |t                    r|t          v rt          |         }nt          |t          j                  r|}njt          d|           | t          v rt          |          }nAt          d|            t          | t          j                  r| }nt          d|            |S )NautozInvalid model dtype: zInvalid kv cache dtype: )
isinstancerD   STR_DTYPE_TO_TORCH_DTYPEr.   r,   
ValueError)ry   rz   torch_dtypes      r)   get_kv_cache_torch_dtyper      s     +s## C&  +s++ H?W0W0W6{CK55 H) !F!F!FGGG4442;?KKEEEFFF	K	-	- C!AKAABBBr+   	quant_cfgc                 |   |                      dd          }|                    d          r|                      d|           }|                     d          p>|                      d          p)|                     d          p|                      d          }t          |t                    r|                     d          du r5|                     d	          d
k    r|                     d          dk    rd}nCt                              d| t          t                                                               dS t          |t                    rl|
                                }|t          v rt          |         S t                              d|t          t                                                               dS dS )a  Get the KV cache quantization algorithm string from the quantization config.

    Maps various FP8 format names to vLLM's standard cache dtype strings.
    Returns None if no kv_cache_quant_algo is specified.
    Returns "auto" if the value is not recognized/supported.
    quant_methodr=   modeloptquantizationkv_cache_schemekv_cache_quant_algodynamicFnum_bits   typer   r   zhWARNING: Unknown kv_cache_quant_algo '%s' in model config. Supported values: %s. Falling back to 'auto'.r|   N)rB   
startswithr}   dictloggerwarninglist#MODELOPT_TO_VLLM_KV_CACHE_DTYPE_MAPkeysrD   lower)r   r   quantization_innerkv_algokv_algo_lowers        r)   get_kv_cache_quant_algo_stringr      s    ==44Lz** '&]]>9EE ""#455 4}}.//4!%%&;<<4 }}233	 	 gt$$ 	I&&%//KK
++q00KK''722 LL<AACCDD	   vgs## 	#MMOOM  CCC:=II L<AACCDD	   v4r+   c                 N    t          |           }||dk    rt          |         S dS )zKGet the KV cache quantization algorithm dtype from the quantization config.Nr|   )r   r~   )r   kv_algo_strs     r)   get_kv_cache_quant_algo_dtyper   $  s/    0;;K;&#8#8'444r+   kv_cache_dtypemodel_configc                     | dk    r| S t          |dd          }|&t          |dd          }|t          |          }||S dS )z}Resolve 'auto' kv_cache_dtype to the actual string value from model config.
    Returns the resolved cache_dtype string.
    r|   	hf_configNquantization_config)getattrr   )r   r   hf_cfgr   r   s        r)   resolve_kv_cache_dtype_stringr   -  sd     \;55FF$94@@	 8CCK&"" 6r+   c                 R    | dk    r|r|j         nt          j        S t          |          S )Nr|   )r,   r.   r   r~   )r   r   s     r)   kv_cache_dtype_str_to_dtyper   B  s/     %1A|!!uzA#N33r+   seedc                    | t          j        |            t          j                             |            t          j        |            t          j                                        r#t          j                            |            d S d S d S rf   )randomr   npr.   manual_seedcudais_availablemanual_seed_all)r   s    r)   set_random_seedr   K  s    D
	t$:""$$ 	-J&&t,,,,, 	- 	-r+   r   NHD
num_blocks
block_size
num_layers	num_heads	head_sizedevicecache_layoutc
                 ,   t          |           t          ||          }
| d|||f|	dv sJ |	dk    rdnd}t          fd|D                       }|dz  }g }g }t          |          D ]} t	          j        ||
|          j        | }|d	v r|                    | |           n+|d
k    rt          || |           nt          d|           |
                    |d d df                    |
                    |d d df                    ||fS )NrP   )r   HNDr   )r   r   rP         )r   r   r   rP   r   c              3   (   K   | ]}|         V  d S rf    )rg   r(   generic_kv_cache_shapes     r)   ri   z5create_kv_caches_with_random_flash.<locals>.<genexpr>g  s)      %V%VA&<Q&?%V%V%V%V%V%Vr+         ࿩sizer,   r   r|   r   r   r   r   #Does not support key cache of type r   r   )r   r   tupler$   r.   emptypermutert   rx   r   append)r   r   r   r   r   ry   rz   r   r   r   r,   stride_orderkv_cache_allocation_shapescale
key_cachesvalue_caches_key_value_cacher   s                     @r)   "create_kv_caches_with_random_flashr   T  s    D$[+>>E(!ZIN>))))&2e&;&;??L %%V%V%V%V%V%V%V V VtOE%'J')L: 3 3%+*%
 
 

<! ???$$eVU3333E!! 5&%@@@@P;PPQQQ/!!!Q$/000OAAAqD12222|##r+   c	                    |dk    r|dz  rt          d|           t          |           t          ||          }	|dz  }
dt          j        g |	                                          z  }| |||z  ||f}g }t          |          D ]u}t          j        ||	|          }|dv r|                    |
 |
           n+|dk    rt          ||
 |
           nt          d|           |
                    |           v| |||f}g }t          |          D ]u}t          j        ||	|          }|dv r|                    |
 |
           n+|dk    rt          ||
 |
           nt          d	|           |
                    |           v||fS )
Nr      z6Does not support key cache of type fp8 with head_size r   rK   r   r   r   z%Does not support value cache of type )r   r   r   r.   rL   rM   r$   r   rt   rx   r   )r   r   r   r   r   ry   rz   r   r   r,   r   xkey_cache_shaper   r   	key_cachevalue_cache_shaper   value_caches                      r)   create_kv_caches_with_randomr   |  s    e	BPYPP
 
 	
 D$[+>>EtOE
el2U+++88:::A!9i1nj!LO%'J: % %K_E&QQQ	???vu----E!! UFE::::P;PPQQQ)$$$$#Y	:F')L: ) )k'8fUUU???  %////E!! ufe<<<<R[RRSSSK((((|##r+   datatarget_device
pin_memoryc                 `    t          j        | ||d          }|                    |d          S )z?Asynchronously create a tensor and copy it from host to device.cpu)r,   r   r   T)r   non_blocking)r.   rL   to)r   r,   r   r   r   s        r)   async_tensor_h2dr     s2     	T:eLLLA44}44888r+   max_lenr   padr   c                   |$t          t          t          |           d          }t          j        t          |           |f||          }t          |           D ]0\  }}t          |          |k    sJ |||dt          |          f<   1|S )z
    Make a padded array from 2D inputs.

    The padding is applied to the end of each inner list until it reaches
    `max_len`.
    Nr   )defaultrK   )rZ   mapr%   r   full	enumerate)r   r   r,   r   padded_xindblocktbs          r)   make_ndarray_with_padr     s     c#qkk1---wA(#U;;;H!! 0 0W7||w&&&&(/nGn$%%Or+   F)r   r   r   c                    t           |         }t          | |||          }t          j        |                              |          }|r|                                }|S )z
    Make a padded tensor from 2D inputs.

    The padding is applied to the end of each inner list until it reaches
    `max_len`.
    r   )TORCH_DTYPE_TO_NUMPY_DTYPEr   r.   
from_numpyr   r   )	r   r   r,   r   r   r   np_dtyper   rL   s	            r)   make_tensor_with_padr     s`     *%0H$QXwGGGHh''**622F %""$$Mr+   streamc                 <    | t           _        t          |            d S rf   )_current_stream_tlsvalueprev_set_stream)r   s    r)   _patched_set_streamr     s     &Fr+   c                       e Zd Zd ZdS )_StreamPlaceholderc                     d | _         d S )Nc                      d S rf   r   r   r+   r)   rk   z-_StreamPlaceholder.__init__.<locals>.<lambda>  s    4 r+   )synchronize)selfs    r)   __init__z_StreamPlaceholder.__init__  s    '<r+   N)__name__
__module____qualname__r   r   r+   r)   r   r     s#        ( ( ( ( (r+   r   c                     ddl m}  t          t          d          rt          j        |                                 s|                                 r<t          j        	                    t          j        
                                           nZ|                                 rt                      t          _        n-| j        }| |            t          _        nt          d          t          j        S )a  
    replace `torch.cuda.current_stream()` with `vllm.utils.current_stream()`.
    it turns out that `torch.cuda.current_stream()` is quite expensive,
    as it will construct a new stream object at each call.
    here we patch `torch.cuda.set_stream` to keep track of the current stream
    directly, so that we can avoid calling `torch.cuda.current_stream()`.

    the underlying hypothesis is that we do not call `torch._C._cuda_setStream`
    from C/C++ code.
    r   r:   r   NzZFail to set current stream, current platform may not support current_stream with torch API)r>   r;   hasattrr   r   is_rocmr?   r.   r   
set_streamStreamis_cpur   current_streamr   )r;   r  s     r)   r  r    s     0/////&00 4G4M4U ##%% 	)9)A)A)C)C 	J!!%*"3"3"5"56666$$&& 
	(:(<(<%%-<N),:N,<,<#)) D   $$r+   _aux_streamc                      ddl m}  t          2|                                 rt          j                                        at          S )z5
    Ensures aux_stream is initialized only once
    r   r:   )r>   r;   r  is_cuda_aliker.   r   r  r:   s    r)   
aux_streamr
  ,  sG     0//////==??j''))r+   r   )maxsizecuda_visible_devicesc                 V   dd l }dd l}ddlm} |j                                        sdS |                                r1t          |j        d          r|j                                        nd}n|j        	                                }|dk     r|j
                                        n|}|S )Nr   r:   _device_count_amdsmir    )
torch.cudatorch.versionr>   r;   r   _is_compiledr  r  r  _device_count_nvml_C_cuda_getDeviceCount)r  r.   r;   	raw_countrs        r)   _cuda_device_count_statelessr  :  s     //////:""$$ q!! 	4
 
$:;;EJ++--- 		 J1133	+4q==%%'''iAHr+   c                  4    t          t          j                  S )zGet number of CUDA devices, caching based on the value of
    CUDA_VISIBLE_DEVICES at the time of call.

    This should be used instead of torch.cuda.device_count()
    unless CUDA_VISIBLE_DEVICES has already been set to the desired
    value.)r  envsr<   r   r+   r)   cuda_device_count_statelessr  X  s     ((ABBBr+   c                     t          | t          j                  r<|                                 dk    r$t          j        j                            |           S | S )z
    Create a weak reference to a tensor.
    The new tensor will share the same data as the original tensor,
    but will not keep the original tensor alive.
    This ignores 0-size tensors as those don't allocate any memory.
    r   )r}   r.   Tensornumelrv   r  weak_ref_tensor)rL   s    r)   r  r  e  sG     &%,'' FLLNNQ,>,>y|++F333r+   tensorsc                    t          | t          j                  rt          |           S t          | t                    rd | D             S t          | t
                    rt          d | D                       S ddlm} t          | |          r. |d | j        	                                D                       }|S t          d          )z
    Convenience function to create weak references to tensors,
    for single tensor, list of tensors or tuple of tensors.
    c                 ,    g | ]}t          |          S r   r  rg   r   s     r)   
<listcomp>z$weak_ref_tensors.<locals>.<listcomp>  s     444q""444r+   c              3   4   K   | ]}t          |          V  d S rf   r"  r#  s     r)   ri   z#weak_ref_tensors.<locals>.<genexpr>  s*      99A_Q''999999r+   r   r   c                 4    i | ]\  }}|t          |          S r   r"  )rg   rl   vals      r)   
<dictcomp>z$weak_ref_tensors.<locals>.<dictcomp>  s&    OOO83S/#&&OOOr+   zInvalid type for tensors)r}   r.   r  r  r   r   vllm.sequencer   r  itemsr   )r  r   rets      r)   weak_ref_tensorsr,  r  s     '5<(( (w''''4   544G4444'5!! :99999999 211111'.// !!OOw7L7L7N7NOOO
 
 

/
0
00r+   
cpu_tensorc                     |                                  s
J d            t          j        j                            |           S )zQ
    Get a CUDA view of a CPU tensor using Unified Virtual Addressing (UVA).
    zCPU tensor must be pinned)	is_pinnedr.   rv   r  get_cuda_view_from_cpu_tensor)r-  s    r)   r0  r0    s=     !!>>#>>>!9<55jAAAr+   torch_versiontargetc                 V    t          j        |           t          j        |          k    S rf   )r	   parse)r1  r2  s     r)   _is_torch_equal_or_newerr5    s!    =''7=+@+@@@r+   c                     	 t          t          t          j                  |           S # t          $ r@ t          t          j                            d                    t          |           k    cY S w xY w)zCheck if the installed torch version is >= the target version.

    Args:
        target: a version string, like "2.6.0".

    Returns:
        Whether the condition meets.
    r.   )	r5  rD   r.   __version__rC   r
   	importlibmetadatar	   r2  s    r)   is_torch_equal_or_newerr;    sr    O'E,=(>(>GGG O O Oy)11'::;;wvNNNNOs   &) AA32A3c                     |                      d          dk    sJ t          t          j                  }t	          j        |          }|t	          j        |           k    ot	          j        | dz             |k    S )N.rP   z.1)countrD   r.   r7  r	   r4  )r2  r1  s     r)   _is_torch_equalr?    sr    <<!!!!)**MM-00M 	v... 	9M&4-((=8r+   c                     	 t          |           S # t          $ r@ t          t          j                            d                    t          |           k    cY S w xY w)zCheck if the installed torch version is == the target version.

    Args:
        target: a version string, like "2.6.0".

    Returns:
        Whether the condition meets.
    r.   )r?  rC   r
   r8  r9  r	   r:  s    r)   is_torch_equalrA    se    Ov&&& O O Oy)11'::;;wvNNNNOs    AAAc                  \    t          d          ot          j                                        S )Nz	2.8.0.dev)r;  r.   distributedis_xccl_availabler   r+   r)   supports_xcclrE    s&    ,,V1B1T1T1V1Vr+   rr   FRAGMENTr   op_nameop_funcmutates_args	fake_impl
target_libdispatch_keytags.c                     |g }|ddl m} |j        }t          ||          }|pt          }	|	                    | |z   |           |	                    | ||           ||	                    | |           dS dS )a  
    `torch.library.custom_op` can have significant overhead because it
    needs to consider complicated dispatching logic. This function
    directly registers a custom op and dispatches it to the CUDA backend.
    See https://gist.github.com/youkaichao/ecbea9ec9fc79a45d2adce1784d7a9a5
    for more details.

    By default, the custom op is registered to the vLLM library. If you
    want to register it to a different library, you can pass the library
    object to the `target_lib` argument.

    IMPORTANT: the lifetime of the operator is tied to the lifetime of the
    library object. If you want to bind the operator to a different library,
    make sure the library object is alive when the operator is used.
    Nr   r:   )rI  )rM  )rL  )r>   r;   rL  r   vllm_libdefineimpl_register_fake)
rG  rH  rI  rJ  rK  rL  rM  r;   
schema_strmy_libs
             r)   direct_register_custom_oprU    s    0 333333'4gLAAAJ#8F
MM'J&TM222
KK|K<<<gy11111 r+   rf   )NNr   r   )NNr   )NNNNr   )n
contextlibimportlib.metadatar8  r@   r   	threadingcollections.abcr   r   	functoolsr   typingr   r   r   numpyr   numpy.typingnptr.   	packagingr	   packaging.versionr
   torch.libraryr   r   	vllm.envsr  vllm.configr   r)  r   objectlogging	getLoggerr   r   r   r   r   r   r   uint8r   float8_e4m3fnr~   float64int32int64r   r   r   r  rQ   r*   contextmanagerr,   r2   intr8   rI   rN   rT   ra   rm   rx   rD   r   r   r   r   r   r   r   r   r   r   r   r   r   	DTypeLikeNDArrayr   r   r   r  r   localr   r  r   r   r  r  __annotations__r
  r  r  r  r,  r0  r5  r;  r?  rA  rE  rO  TagrU  r   r+   r)   <module>rs     s
            				      0 0 0 0 0 0 0 0       . . . . . . . . . .                  % % % % % % / / / / / / / /       !''''''1111111K  		8	$	$ }J}[;J"+   
M2:	M2:	M2:	K	K	K  
:	' # GCLLel t    < '5; ' ' ' ' +s + + + + ; ; ;28%+ 8# 8 8 8 8R R R R R R
     @z%+'>    L	  
	   . -1 u{"T)u{"T) [   .2d38n 2t 2 2 2 2jT#s(^ d@R    '2   *44'24
[4 4 4 4-#* - - - - -  -1$%$ %$%$%$ %$ 	%$
 %$ u{"T)%$ u{"T)%$ *%$ $J%$ *%$ 4tEL112%$ %$ %$ %$^ -1-$ -$-$-$ -$ 	-$
 -$ u{"T)-$ u{"T)-$ *-$ $J-$ 4tEL112-$ -$ -$ -$`9
9;9 %9 	9
 \9 9 9 9    DG}	
 =
 4Z 	[   < (,  DG}	
 ;
 4Z %,%  \   2 *'%io'' 
 1 d    
 ,
 ( ( ( ( ( ( ( (
%%
) %% %% %% %%\ )-UZ% , , ,EJ%,     1 sTz S    :
CS 
C 
C 
C 
C
C 
C 
 
 
 
1\
5<EL 1
 \DIc
*S01 1 1 18Bel Bu| B B B BAC A A A A A AOC OD O O O O 	C 	D 	 	 	 	O3 O4 O O O O t     76:&& &*!%!%#"$&2 &2&2&2 s)d"&2 $	&2
 $&2 *&2 	3
&2 &2 &2 &2 &2 &2r+   