
    <i
e                    Z   U d Z ddlmZ dZddlZ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 dZerddlmZmZmZmZmZmZ ddl
mZ dd	lmZ 	  e	j                    5   e	j        d
            ej                    d         p ej                    d                                         Zded<   ddd           n# 1 swxY w Y   n	#  dZY nxY w	  ej        e           n# ee f$ r dZY nw xY w G d de!          Z" G d de!          Z#d2dZ$d3dZ% G d de          Z& G d de          Z' G d  d!          Z( G d" d#e&          Z) G d$ d%e'          Z* G d& d'e*          Z+ G d( d)e&          Z, G d* d+e'          Z- G d, d-e&          Z. G d. d/e'          Z/ G d0 d1e&          Z0dS )4z
I/O classes provide a uniform API for low-level input and output.  Subclasses
exist for a variety of input/output mechanisms.
    )annotationsreStructuredTextN)TransformSpecF)AnyBinaryIOClassVarFinalLiteralTextIO)nodes)StrPathignore   
str | None_locale_encodingc                      e Zd ZdS )
InputErrorN__name__
__module____qualname__     /Users/kimhansen/Desktop/03 Workspace/ceo-agents/chl-effectiveness/mcp-servers/whoop/.venv/lib/python3.11/site-packages/docutils/io.pyr   r   4             r   r   c                      e Zd ZdS )OutputErrorNr   r   r   r   r   r   5   r   r   r   streamr   encodingstrreturnbool | Nonec                    	 t          j        | j                  t          j        |          k    S # t          t          t
          f$ r Y dS w xY w)aN  Test, whether the encoding of `stream` matches `encoding`.

    Returns

    :None:  if `encoding` or `stream.encoding` are not a valid encoding
            argument (e.g. ``None``) or `stream.encoding is missing.
    :True:  if the encoding argument resolves to the same value as `encoding`,
    :False: if the encodings differ.
    N)codecslookupr   LookupErrorAttributeError	TypeError)r   r   s     r   check_encodingr)   8   sQ    }V_--x1H1HHH3   tts   .1 AAerrBaseExceptionc                $    | j         j         d|  S )z5Return string representation of Exception `err`.
    z: )	__class__r   )r*   s    r   error_stringr.   H   s     m$-----r   c                      e Zd ZU dZdZded<   dZded<   	 	 	 	 d'd(dZd)dZd)dZ	d*dZ
 ej        d          Zded<   	 ej        dfej        dfej        dfej        d fej        d ffZd!ed"<   	 d+d$Zd,d&ZdS )-Inputak  
    Abstract base class for input wrappers.

    Docutils input objects must provide a `read()` method that
    returns the source, typically as `str` instance.

    Inheriting `TransformSpec` allows input objects to add "transforms" to
    the "Transformer".  (Since Docutils 0.19, input objects are no longer
    required to be `TransformSpec` instances.)
    inputr	   component_typeNClassVar[str | None]default_source_pathutf-8strictsource$str | TextIO | nodes.document | Nonesource_pathStrPath | Noner   str | Literal['unicode'] | Noneerror_handlerr   r!   Nonec                p    || _         	 || _        	 || _        	 || _        	 |s| j        | _        d | _        d S N)r   r<   r7   r9   r4   successful_encoding)selfr7   r9   r   r<   s        r   __init__zInput.__init__^   sO     !1**'&- 	8#7D#' EEr   r    c                4    | j         d| j        d| j        S )Nz	: source=z, source_path=)r-   r7   r9   rA   s    r   __repr__zInput.__repr__w   s(    26...$+++262B2BD 	Dr   c                    t           )z,Return input as `str`. Define in subclasses.NotImplementedErrorrD   s    r   readz
Input.read{       !!r   datastr | bytesc                   | j         r<| j                                         dk    rt          |t                    s
J d            t          |t                    r|S | j         r	| j         g}nt	          j                    5  t	          j        dt                     |                     |          }ddd           n# 1 swxY w Y   |r|g}nsdg}t          j
        dd         dk    rt          j                    }nt          j        d	
          }|r-|                                dk    r|                    |           | j         s(|d         dk    rt	          j        dt          d           |D ]C}	 t          ||| j                  }|| _        |c S # t$          t&          f$ r}|}Y d}~<d}~ww xY wt%          dd                    d |D                        dt+          |           d          )a  
        Decode `data` if required.

        Return Unicode `str` instances unchanged (nothing to decode).

        If `self.encoding` is None, determine encoding from data
        or try UTF-8 and the locale's preferred encoding.
        The client application should call ``locale.setlocale()`` at the
        beginning of processing::

            locale.setlocale(locale.LC_ALL, '')

        Raise UnicodeError if unsuccessful.

        Provisional: encoding detection will be removed in Docutils 1.0.
        unicodez;input encoding is "unicode" but `data` is no `str` instancer   )categoryNr5      )      F)do_setlocaler   ur   Input encoding auto-detection will be removed and the encoding values None and "" become invalid in Docutils 1.0.
stacklevelz=Unable to decode input data.  Tried the following encodings: z, c              3  4   K   | ]}t          |          V  d S r?   )repr).0encs     r   	<genexpr>zInput.decode.<locals>.<genexpr>   s(      BBscBBBBBBr   .
())r   lower
isinstancer    warningscatch_warningsfilterwarningsDeprecationWarningdetermine_encoding_from_datasysversion_infolocalegetencodinggetpreferredencodingappendwarnr<   r@   UnicodeErrorr&   joinr.   )	rA   rK   encoding_candidatesdata_encodingfallbackrY   decodedr*   errors	            r   decodezInput.decode   s   " = 	NT]0022i??dC(( N N ,M N N NdC   	K= 	9 $(=/(** H H';MNNNN $ A A$ G GH H H H H H H H H H H H H H H  9'4o##
 (/i##BQB'722%133HH%:NNNH 9 0 0G ; ;'..x888} 	Q!4Q!77!B!BM ./AaQ Q Q Q ' 	 	CdC);<<+.( +.    'yyBB.ABBBBB' 'U##' ' '( ( 	(s*   >1B;;B?B?3FF1%F,,F1s   coding[:=]\s*([-\w.]+)zClassVar[re.Pattern[bytes]]coding_slugzutf-32z	utf-8-sigzutf-16z'ClassVar[tuple[tuple[bytes, str], ...]]byte_order_marksbytesc                T   t          j        dt          d           | j        D ]\  }}|                    |          r|c S |                                dd         D ]H}| j                            |          }|r*|                    d          	                    d          c S IdS )z
        Try to determine the encoding of `data` by looking *in* `data`.
        Check for a byte order mark (BOM) or an encoding declaration.

        Deprecated. Will be removed in Docutils 1.0.
        uR   docutils.io.Input.determine_encoding_from_data() will be removed in Docutils 1.0.rP   rT   Nr   ascii)
r_   rj   rb   rt   
startswith
splitlinesrs   searchgrouprr   )rA   rK   start_bytesr   linematchs         r   rc   z"Input.determine_encoding_from_data   s     	 :(Q	8 	8 	8 	8 &*%: 	  	 !K{++    OO%%bqb) 	6 	6D$++D11E 6{{1~~,,W555556tr   boolc                X    	 | j                                         S # t          $ r Y dS w xY w)z>Return True, if the input source is connected to a TTY device.F)r7   isattyr'   rD   s    r   r   zInput.isatty   s=    	;%%''' 	 	 	55	    
)))NNr5   r6   )
r7   r8   r9   r:   r   r;   r<   r   r!   r=   r!   r    )rK   rL   r!   r    )rK   ru   r!   r   r!   r   )r   r   r   __doc__r2   __annotations__r4   rB   rE   rI   rr   recompilers   r$   BOM_UTF32_BEBOM_UTF32_LEBOM_UTF8BOM_UTF16_BEBOM_UTF16_LErt   rc   r   r   r   r   r0   r0   N   se        	 	 $N####044444 8<&*4;$,F F F F F2D D D D" " " "=( =( =( =(~ 0:rz"0 0K     ( 
	h'		h'	+&		h'		h'A       *     r   r0   c                  Z    e Zd ZU dZdZded<   dZded<   	 	 	 	 dddZddZddZ	ddZ
dS )Outputan  
    Abstract base class for output wrappers.

    Docutils output objects must provide a `write()` method that
    expects and handles one argument (the output).

    Inheriting `TransformSpec` allows output objects to add "transforms" to
    the "Transformer".  (Since Docutils 0.19, output objects are no longer
    required to be `TransformSpec` instances.)
    outputr	   r2   Nr3   default_destination_pathr6   destinationTextIO | str | bytes | Nonedestination_pathr:   r   r   r<   r!   r=   c                j    || _         	 |pd| _        	 || _        	 || _        	 |s| j        | _        d S d S )Nr6   )r   r<   r   r   r   )rA   r   r   r   r<   s        r   rB   zOutput.__init__   sZ     %-7"/";8*8C.0@2 	B$($AD!!!	B 	Br   r    c                4    | j         d| j        d| j        S )Nz: destination=z, destination_path=)r-   r   r   rD   s    r   rE   zOutput.__repr__  s*    >>>4#3#3#3T5J5JL 	Mr   rK   rL   str | bytes | Nonec                    t           )z#Write `data`. Define in subclasses.rG   rA   rK   s     r   writezOutput.write  rJ   r   c                    | j         r>| j                                         dk    r!t          |t                    s
J d            |S t          |t                    s|S |                    | j         | j                  S )a?  
        Encode and return `data`.

        If `data` is a `bytes` instance, it is returned unchanged.
        Otherwise it is encoded with `self.encoding`.

        Provisional: If `self.encoding` is set to the pseudo encoding name
        "unicode", `data` must be a `str` instance and is returned unchanged.
        rN   z<output encoding is "unicode" but `data` is no `str` instance)r   r]   r^   r    encoder<   r   s     r   r   zOutput.encode  s     = 	T]0022i??dC(( N N ,M N N NK$$$ 	BK;;t}d.@AAAr   )NNNr6   )
r   r   r   r:   r   r   r<   r   r!   r=   r   )rK   rL   r!   r   rK   rL   r!   rL   )r   r   r   r   r2   r   r   rB   rE   r   r   r   r   r   r   r      s         	 	 %N$$$$599999 48+/#$,B B B B B,M M M M" " " "B B B B B Br   r   c                  <    e Zd ZdZ	 	 	 	 dddZddZddZddZdS )ErrorOutputz
    Wrapper class for file-like error streams with
    failsafe de- and encoding of `str`, `bytes`, and `Exception` instances.
    Nbackslashreplacereplacer   /TextIO | BinaryIO | str | Literal[False] | Noner   r   encoding_errorsr    decoding_errorsr!   r=   c                    |t           j        }n*|sd}n%t          |t                    rt	          |d          }|| _        	 |pt          |dd          pt          pd| _        	 || _	        	 || _
        dS )a  
        :Parameters:
            - `destination`: a file-like object,
                        a string (path to a file),
                        `None` (write to `sys.stderr`, default), or
                        evaluating to `False` (write() requests are ignored).
            - `encoding`: `destination` text encoding. Guessed if None.
            - `encoding_errors`: how to treat encoding errors.
        NFwr   rw   )rd   stderrr^   r    openr   getattrr   r   r   r   )rA   r   r   r   r   s        r   rB   zErrorOutput.__init__7  s      *KK 	1KKS)) 	1{C00K?J+  {J55 	 	 	-$3%$3%%r   rK   str | bytes | Exceptionc                   | j         sdS t          |t                    rt          |          }	 | j                             |           dS # t
          $ r> |                    | j        | j                  }| j                             |           Y dS t          $ r t          |t                    r=|                    | j        | j                  }| j                             |           Y dS | j         t          j        t          j        fv r"| j         j                            |           Y dS |                    | j        | j                  }| j                             |           Y dS w xY w)z
        Write `data` to self.destination. Ignore, if self.destination is False.

        `data` can be a `bytes`, `str`, or `Exception` instance.
        N)r   r^   	Exceptionr    r   UnicodeEncodeErrorr   r   r   r(   rd   r   stdoutbufferrr   r   )rA   rK   binarystrings       r   r   zErrorOutput.write`  sx     	FdI&& 	t99D	/""4(((((! 	+ 	+ 	+ [[0DEEF""6****** 
	/ 
	/ 
	/$$$ 	/T]D4HII &&v......!cj#*%=== '--d333333 T]D4HII &&v......
	/s%   A AE,AE,->E,.:E,+E,c                    | j         t          j        t          j        fv rdS 	 | j                                          dS # t
          $ r Y dS w xY w)z
        Close the error-output stream.

        Ignored if the destination is` sys.stderr` or `sys.stdout` or has no
        close() method.
        N)r   rd   r   r   closer'   rD   s    r   r   zErrorOutput.close  sb     
CJ777F	""$$$$$ 	 	 	DD	s   > 
AAr   c                X    	 | j                                         S # t          $ r Y dS w xY w)z=Return True, if the destination is connected to a TTY device.F)r   r   r'   rD   s    r   r   zErrorOutput.isatty  s>    	#**,,, 	 	 	55	r   )NNr   r   )
r   r   r   r   r   r    r   r    r!   r=   )rK   r   r!   r=   r!   r=   r   )r   r   r   r   rB   r   r   r   r   r   r   r   r   1  s          HL#1('& '& '& '& '&R/ / / /@        r   r   c                  J     e Zd ZdZ	 	 	 	 	 	 dd fdZddZddZddZ xZS ) 	FileInputz5
    Input for single, simple file-like objects.
    Nr5   r6   Trr7   TextIO | Noner9   r:   r   r;   r<   r   	autocloser   modeLiteral['r', 'rb', 'br']r!   r=   c                "   t                                          ||||           || _        t                      | _        |e|rQ	 t          ||| j        | j                  | _        n# t          $ r }t          |j        |j        |          d}~ww xY wt          j        | _        nAt          | j        | j                  du r%t!          d| j        d| j        j        d          |s%	 | j        j        | _        dS # t&          $ r Y dS w xY wdS )a  
        :Parameters:
            - `source`: either a file-like object (which is read directly), or
              `None` (which implies `sys.stdin` if no `source_path` given).
            - `source_path`: a path to a file, which is opened for reading.
            - `encoding`: the expected text encoding of the input file.
            - `error_handler`: the encoding error handler to use.
            - `autoclose`: close automatically after read (except when
              `sys.stdin` is the source).
            - `mode`: how the file is to be opened (see standard function
              `open`). The default is read only ('r').
        Nr   errorsFz#Encoding clash: encoding given is "z&" but source is opened with encoding "z".)superrB   r   r   _stderrr   r   r<   r7   OSErrorr   errnostrerrorrd   stdinr)   rk   namer9   r'   )	rA   r7   r9   r   r<   r   r   rq   r-   s	           r   rB   zFileInput.__init__  sT   * 	hFFF""}}> (O"&{D04.2.@#B #B #BDKK  O O O$U[%.+NNNO "iDK775@@, $t{/C/C/C E F F F  	#';#3   !   	 	s*   "A( (
B2BB+C> >
DDr    c                   	 | j         stt          | j        d          r_| j        j                                        }|                     |          }d                    |                                dgz             }n| j                                        }| j        r| 	                                 n!# | j        r| 	                                 w w xY w|S )zA
        Read and decode a single file, return as `str`.
        r   
 )
r   hasattrr7   r   rI   rr   rl   ry   r   r   r   s     r   rI   zFileInput.read  s    	= *WT[(%C%C *{)..00{{4((yy!2!2B4!788{''))~ 

 ~ 

s   BB2 2C	list[str]c                P    |                                                      d          S )zC
        Return lines of a single file as list of strings.
        T)rI   ry   rD   s    r   	readlineszFileInput.readlines  s      yy{{%%d+++r   c                b    | j         t          j        ur| j                                          d S d S r?   )r7   rd   r   r   rD   s    r   r   zFileInput.close  s3    ;ci''K ('r   )NNr5   r6   Tr   )r7   r   r9   r:   r   r;   r<   r   r   r   r   r   r!   r=   r   )r!   r   r   )	r   r   r   r   rB   rI   r   r   __classcell__r-   s   @r   r   r     s         
 !%&*4;$,),, , , , , , ,\   &, , , ,               r   r   c                  l     e Zd ZU dZdZded<   dZded<   	 	 	 	 	 	 	 	 dd fdZddZd dZ	ddZ
 xZS )!
FileOutputz,Output for single, simple file-like objects.z<file>r	   r   r   z:Literal['w', 'a', 'x', 'wb', 'ab', 'xb', 'bw', 'ba', 'bx']r   Nr6   Tr   r   r   r:   r   r   r<   r   r   handle_io_errorsr=   r!   c                   t                                          ||||           d| _        || _        |t	          j        dt          d           ||| _        t                      | _	        ||rd| _        n`t          j        | _        nN|rLt          | j        d          r7|| j        j        k    r't          d| j        j        d	|d
| j	                   |s%	 | j        j        | _        dS # t"          $ r Y dS w xY wdS )aA  
        :Parameters:
            - `destination`: either a file-like object (which is written
              directly) or `None` (which implies `sys.stdout` if no
              `destination_path` given).
            - `destination_path`: a path to a file, which is opened and then
              written.
            - `encoding`: the text encoding of the output file.
            - `error_handler`: the encoding error handler to use.
            - `autoclose`: close automatically after write (except when
              `sys.stdout` or `sys.stderr` is the destination).
            - `handle_io_errors`: ignored, deprecated, will be removed.
            - `mode`: how the file is to be opened (see standard function
              `open`). The default is 'w', providing universal newline
              support for text files.
        TNz_io.FileOutput: init argument "handle_io_errors" is ignored and will be removed in Docutils 2.0.rP   rT   Fr   zWarning: Destination mode "z" differs from specified mode "")file)r   rB   openedr   r_   rj   rb   r   r   r   rd   r   r   r   printr   r   r'   )	rA   r   r   r   r<   r   r   r   r-   s	           r   rB   zFileOutput.__init__  s\   2 	)8]	D 	D 	D"'M *+=!M M M M DI"}} .##&:  	%t/88	%$*///E!%!1!6!6!6>|% % % %   	(,(8(=%%%!   	 	s   C0 0
C>=C>c                    d| j         vr| j        | j        d}ni }	 t          | j        | j         fi || _        n2# t          $ r%}t          |j        |j	        | j                  d }~ww xY wd| _
        d S )Nbr   T)r   r   r<   r   r   r   r   r   r   r   r   )rA   kwargsrq   s      r   r   zFileOutput.open(  s    di"&- $ 24 4FF F	5#D$949OOOOD 	5 	5 	5ek5>"35 5 5	5 s   ; 
A* A%%A*rK   rL   c                   | j         s|                                  t          |t                    rat	          | j        | j                  du rEt          j        dk    r |	                    dt          j                  }| 
                    |          }	 | j                            |           n# t          $ r}t          |t                    rz	 | j        j                            |           nY# t          $ rL t	          | j        | j                  du r-t!          d| j         d| j        j         d| j         d          |w xY wY d}~nDd}~wt$          t&          f$ r-}t%          d| j         d	t)          |           d          d}~ww xY w| j        r|                                  n!# | j        r|                                  w w xY w|S )
aB  Write `data` to a single file, also return it.

        `data` can be a `str` or `bytes` instance.
        If writing `bytes` fails, an attempt is made to write to
        the low-level interface ``self.destination.buffer``.

        If `data` is a `str` instance and `self.encoding` and
        `self.destination.encoding` are  set to different values, `data`
        is encoded to a `bytes` instance using `self.encoding`.

        Provisional: future versions may raise an error if `self.encoding`
        and `self.destination.encoding` are set to different values.
        Fr   zEncoding of z (z&) differs 
  from specified encoding (r\   Nz2Unable to encode output data. output-encoding is: r[   )r   r   r^   r    r)   r   r   oslinesepr   r   r   r(   ru   r   r'   
ValueErrorr   rk   r&   r.   r   r   )rA   rK   r*   s      r   r   zFileOutput.write6  s/    { 	IIKKKtS!! 	%t/??5HHzT!!||D"*55;;t$$D	""4(((( 	" 	" 	"$&& "
"$+11$7777% " " "%d&6&*m5 58=> >(K4+@ K K $ 0 9K K:>-K K KL L L
 "	" k* 	< 	< 	<;=; ;&23&7&7; ; ;< < <	<
 ~ 

 ~ 

sU   B. -F, .
F8EC.-E.AEEF, F (FFF, ,G
c                    | j         t          j        t          j        fvr"| j                                          d| _        d S d S )NF)r   rd   r   r   r   r   rD   s    r   r   zFileOutput.closed  sA    CJ
#;;;""$$$DKKK <;r   )NNNr6   TNN)r   r   r   r:   r   r   r<   r   r   r   r   r=   r!   r=   r   r   )r   r   r   r   r   r   r   rB   r   r   r   r   r   s   @r   r   r     s         66&.....GJDJJJJ) /348(,-5#'*.3 3 3 3 3 3 3j   , , , ,\               r   r   c                  (     e Zd ZdZdZd	 fdZ xZS )
BinaryFileOutputu   
    A version of docutils.io.FileOutput which writes to a binary file.

    Deprecated. Use `FileOutput` (works with `bytes` since Docutils 0.20).
    Will be removed in Docutils 0.24.
    wbargsr   r   r!   r=   c                r    t          j        dt          d            t                      j        |i | d S )NzU"BinaryFileOutput" is obsoleted by "FileOutput" and will be removed in Docutils 0.24.rP   rT   )r_   rj   rb   r   rB   )rA   r   r   r-   s      r   rB   zBinaryFileOutput.__init__t  sJ     ?(Q	8 	8 	8 	8 	$)&)))))r   )r   r   r   r   r!   r=   )r   r   r   r   r   rB   r   r   s   @r   r   r   j  sN          D* * * * * * * * * *r   r   c                  4    e Zd ZU dZded<   dZded<   dd	Zd
S )StringInputz'Input from a `str` or `bytes` instance.rL   r7   <string>r	   r4   r!   r    c                6    |                      | j                  S )z`Return the source as `str` instance.

        Decode, if required (see `Input.decode`).
        )rr   r7   rD   s    r   rI   zStringInput.read  s    
 {{4;'''r   Nr   r   r   r   r   r   r4   rI   r   r   r   r   r   {  sN         11!+++++( ( ( ( ( (r   r   c                  4    e Zd ZU dZded<   dZded<   dd	Zd
S )StringOutputz=Output to a `bytes` or `str` instance.

    Provisional.
    rL   r   r   r	   r   rK   r!   c                D    |                      |          | _        | j        S )av  Store `data` in `self.destination`, and return it.

        If `self.encoding` is set to the pseudo encoding name "unicode",
        `data` must be a `str` instance and is stored/returned unchanged
        (cf. `Output.encode`).

        Otherwise, `data` can be a `bytes` or `str` instance and is
        stored/returned as a `bytes` instance
        (`str` data is encoded with `self.encode()`).

        Attention: the `output_encoding`_ setting may affect the content
        of the output (e.g. an encoding declaration in HTML or XML or the
        representation of characters as LaTeX macro vs. literal character).
        )r   r   r   s     r   r   zStringOutput.write  s!      ;;t,,r   Nr   r   r   r   r   r   r   r   r   r   r   r   r     sT          
 &00000           r   r   c                  4    e Zd ZU dZded<   dZded<   dd	Zd
S )	NullInputzDegenerate input: read nothing.r=   r7   z
null inputr	   r4   r!   r    c                    dS )zReturn an empty string.r   r   rD   s    r   rI   zNullInput.read  s    rr   Nr   r   r   r   r   r   r     sK         ))LLL!-----     r   r   c                  4    e Zd ZU dZded<   dZded<   dd
ZdS )
NullOutputz!Degenerate output: write nothing.r=   r   znull outputr	   r   rK   rL   r!   c                    dS )zDo nothing, return None.Nr   r   s     r   r   zNullOutput.write  s      r   N)rK   rL   r!   r=   r   r   r   r   r   r     sN         ++&33333' ' ' ' ' 'r   r   c                  4    e Zd ZU dZded<   dZded<   d
dZd	S )DocTreeInputzm
    Adapter for document tree input.

    The document tree must be passed in the ``source`` parameter.
    nodes.documentr7   zdoctree inputr	   r4   r!   c                    | j         S )zReturn the document tree.)r7   rD   s    r   rI   zDocTreeInput.read  s
    {r   N)r!   r   r   r   r   r   r   r     sT           !00000     r   r   )r   r   r   r    r!   r"   )r*   r+   r!   r    )1r   
__future__r   __docformat__r$   rf   r   r   rd   r_   docutilsr   TYPE_CHECKINGtypingr   r   r   r	   r
   r   r   docutils.nodesr   r`   simplefilter	getlocalegetdefaultlocaler]   r   r   r%   r&   r(   r   r   r   r)   r.   r0   r   r   r   r   r   r   r   r   r   r   r   r   r   <module>r     sh  
  
 # " " " " ""   				 				 



  " " " " " " 'FFFFFFFFFFFFFFFF&&&&&&		 	 	"	" 2 2h'''(8(8(:(:1(= )H+B6+B+D+DQ+G*/%'' 	 	2 	2 	2 	22 2 2 2 2 2 2 2 2 2 2 2 2 2 2
FM"####Y                      '          . . . .] ] ] ] ]M ] ] ]@@B @B @B @B @B] @B @B @BFb b b b b b b bJN  N  N  N  N  N  N  N b@  @  @  @  @  @  @  @ F* * * * *z * * *"( ( ( ( (% ( ( (         6      :
 
 
 
 
 
 
 
	' 	' 	' 	' 	' 	' 	' 	'    5     sC   C AB8,C 8B<<C ?B< C C
C 	C+*C+