
    /iiU                     \   d dl Z d dlZd dlZd dlZdZ G d de          Z G d de          Z G d d          Z	 G d	 d
          Z
 G d d          Z G d d          Z G d d          Z G d d          Z G d d          Z G d d          Z G d d          Z G d de          Z G d de          Z G d d          Z G d d           Z G d! d"          Z G d# d$          Z G d% d&          Z G d' d(          ZeZe	ZeZeZe
ZeZeZ eZ!eZ"eZ#eZ$eZ%eZ&eZ'eZ(dS ))    N)!DataRequireddata_requiredEmailemailEqualToequal_to	IPAddress
ip_addressInputRequiredinput_requiredLengthlengthNumberRangenumber_rangeOptionaloptionalRegexpregexpURLurlAnyOfany_ofNoneOfnone_of
MacAddressmac_addressUUIDValidationErrorStopValidationreadonlyReadOnlydisabledDisabledc                       e Zd ZdZddZdS )r   z>
    Raised when a validator fails to validate its input.
     c                 2    t          j        | |g|R i | d S N)
ValueError__init__selfmessageargskwargss       M/var/www/html/ecfs/ecfsenv/lib/python3.11/site-packages/wtforms/validators.pyr)   zValidationError.__init__0   s+    D';D;;;F;;;;;    Nr%   __name__
__module____qualname____doc__r)    r0   r/   r   r   +   s2         < < < < < <r0   r   c                       e Zd ZdZddZdS )r   z
    Causes the validation chain to stop.

    If StopValidation is raised, no more validators in the validation chain are
    called. If raised with a message, the message will be added to the errors
    list.
    r%   c                 2    t          j        | |g|R i | d S r'   )	Exceptionr)   r*   s       r/   r)   zStopValidation.__init__=   s+    4:4:::6:::::r0   Nr1   r2   r7   r0   r/   r   r   4   s2         ; ; ; ; ; ;r0   r   c                        e Zd ZdZddZd ZdS )r   a9  
    Compares the values of two fields.

    :param fieldname:
        The name of the other field to compare to.
    :param message:
        Error message to raise in case of a validation error. Can be
        interpolated with `%(other_label)s` and `%(other_name)s` to provide a
        more helpful error.
    Nc                 "    || _         || _        d S r'   )	fieldnamer,   )r+   r=   r,   s      r/   r)   zEqualTo.__init__M   s    "r0   c                 t   	 || j                  }n=# t          $ r0}t          |                    d          | j         z            |d }~ww xY w|j        |j        k    rd S t          |d          r|j        j        p| j         | j         d}| j        }||                    d          }t          ||z            )NzInvalid field name '%s'.label)other_label
other_namez&Field must be equal to %(other_name)s.)	r=   KeyErrorr   gettextdatahasattrr?   textr,   )r+   formfieldotherexcdr,   s          r/   __call__zEqualTo.__call__Q   s    	(EE 	 	 	!899DNJ 	 :##F #5'22 ! ~.	
 
 ,?mm$LMMGgk***s    
A
+AA
r'   r3   r4   r5   r6   r)   rL   r7   r0   r/   r   r   A   sA        	 	   + + + + +r0   r   c                        e Zd ZdZddZd ZdS )r   a\  
    Validates the length of a string.

    :param min:
        The minimum required length of the string. If not provided, minimum
        length will not be checked.
    :param max:
        The maximum length of the string. If not provided, maximum length
        will not be checked.
    :param message:
        Error message to raise in case of a validation error. Can be
        interpolated using `%(min)d` and `%(max)d` if desired. Useful defaults
        are provided depending on the existence of min and max.

    When supported, sets the `minlength` and `maxlength` attributes on widgets.
    Nc                    |dk    s|dk    s
J d            |dk    s||k    s
J d            || _         || _        || _        i | _        | j         dk    r| j         | j        d<   | j        dk    r| j        | j        d<   d S d S )NrO   z1At least one of `min` or `max` must be specified.z `min` cannot be more than `max`.	minlength	maxlengthminmaxr,   field_flagsr+   rT   rU   r,   s       r/   r)   zLength.__init__z   s    2II> #byyC3JJJ(JJJJ8r>>,0HD[)8r>>,0HD[))) >r0   c                    |j         rt          |j                   pd}|| j        k    r| j        dk    s|| j        k    rd S | j        | j        }n| j        dk    r|                    dd| j                  }nj| j        dk    r|                    dd| j                  }nB| j        | j        k    r|                    dd| j                  }n|                    d	          }t          |t          | j        | j        |
          z            )Nr   rO   z.Field must be at least %(min)d character long.z/Field must be at least %(min)d characters long.z.Field cannot be longer than %(max)d character.z/Field cannot be longer than %(max)d characters.z-Field must be exactly %(max)d character long.z.Field must be exactly %(max)d characters long.z:Field must be between %(min)d and %(max)d characters long.)rT   rU   r   )	rD   lenrT   rU   r,   ngettextrC   r   dict)r+   rG   rH   r   r,   s        r/   rL   zLength.__call__   s   /EJ41TX48r>>Vtx5G5GF<#lGGX^^nn@A GG
 X^^nn@A GG
 X!!nn?@ GG mmL G gtxPV(W(W(WWXXXr0   )rO   rO   NrM   r7   r0   r/   r   r   h   sF         "5 5 5 5Y Y Y Y Yr0   r   c                        e Zd ZdZddZd ZdS )r   a  
    Validates that a number is of a minimum and/or maximum value, inclusive.
    This will work with any comparable number type, such as floats and
    decimals, not just integers.

    :param min:
        The minimum required value of the number. If not provided, minimum
        value will not be checked.
    :param max:
        The maximum value of the number. If not provided, maximum value
        will not be checked.
    :param message:
        Error message to raise in case of a validation error. Can be
        interpolated using `%(min)s` and `%(max)s` if desired. Useful defaults
        are provided depending on the existence of min and max.

    When supported, sets the `min` and `max` attributes on widgets.
    Nc                     || _         || _        || _        i | _        | j         | j         | j        d<   | j        | j        | j        d<   d S d S )NrT   rU   rS   rW   s       r/   r)   zNumberRange.__init__   s[    8&*hDU#8&*hDU###  r0   c                    |j         }|:t          j        |          s&| j        || j        k    r| j        || j        k    rd S | j        | j        }nO| j        |                    d          }n2| j        |                    d          }n|                    d          }t          |t          | j        | j                  z            )Nz Number must be at least %(min)s.zNumber must be at most %(max)s.z+Number must be between %(min)s and %(max)s.)rT   rU   )	rD   mathisnanrT   rU   r,   rC   r   r[   r+   rG   rH   rD   r,   s        r/   rL   zNumberRange.__call__   s    zJt$$ !TTX%5%5!TTX%5%5F<#lGG Xmm$FGGGGXmm$EFFGG mm$QRRGgtx(H(H(HHIIIr0   )NNNrM   r7   r0   r/   r   r      sF         &/ / / /J J J J Jr0   r   c                        e Zd ZdZddZd ZdS )r   al  
    Allows empty input and stops the validation chain from continuing.

    If input is empty, also removes prior errors (such as processing errors)
    from the field.

    :param strip_whitespace:
        If True (the default) also stop the validation chain on input which
        consists of only whitespace.

    Sets the `optional` attribute on widgets.
    Tc                 >    |r	d | _         nd | _         ddi| _        d S )Nc                 *    |                                  S r'   )stripss    r/   <lambda>z#Optional.__init__.<locals>.<lambda>   s    !'')) r0   c                     | S r'   r7   rf   s    r/   rh   z#Optional.__init__.<locals>.<lambda>   s    ! r0   r   T)string_checkrV   )r+   strip_whitespaces     r/   r)   zOptional.__init__   s5     	, 3 3D +D&-r0   c                     |j         r@t          |j         d         t                    r:|                     |j         d                   sg |j        d d <   t                      d S d S )Nr   )raw_data
isinstancestrrj   errorsr   r+   rG   rH   s      r/   rL   zOptional.__call__   su    	#%.+S11	# %%enQ&788	#
 !ELO """	# 	# 	# 	#r0   N)TrM   r7   r0   r/   r   r      sA         . . . .# # # # #r0   r   c                        e Zd ZdZddZd ZdS )r   a  
    Checks the field's data is 'truthy' otherwise stops the validation chain.

    This validator checks that the ``data`` attribute on the field is a 'true'
    value (effectively, it does ``if field.data``.) Furthermore, if the data
    is a string type, a string containing only whitespace characters is
    considered false.

    If the data is empty, also removes prior errors (such as processing errors)
    from the field.

    **NOTE** this validator used to be called `Required` but the way it behaved
    (requiring coerced data, not input data) meant it functioned in a way
    which was not symmetric to the `Optional` validator and furthermore caused
    confusion with certain fields which coerced data to 'falsey' values like
    ``0``, ``Decimal(0)``, ``time(0)`` etc. Unless a very specific reason
    exists, we recommend using the :class:`InputRequired` instead.

    :param message:
        Error message to raise in case of a validation error.

    Sets the `required` attribute on widgets.
    Nc                 &    || _         ddi| _        d S NrequiredTr,   rV   r+   r,   s     r/   r)   zDataRequired.__init__      &-r0   c                     |j         r5t          |j         t                    r|j                                         rd S | j        |                    d          }n| j        }g |j        d d <   t          |          )NThis field is required.)rD   rn   ro   re   r,   rC   rp   r   r+   rG   rH   r,   s       r/   rL   zDataRequired.__call__   sy    : 	z%*c:: 	ej>N>N>P>P 	F<mm$=>>GGlGQQQW%%%r0   r'   rM   r7   r0   r/   r   r     sA         0. . . .
& 
& 
& 
& 
&r0   r   c                        e Zd ZdZddZd ZdS )r   a  
    Validates that input was provided for this field.

    Note there is a distinction between this and DataRequired in that
    InputRequired looks that form-input data was provided, and DataRequired
    looks at the post-coercion data. This means that this validator only checks
    whether non-empty data was sent, not whether non-empty data was coerced
    from that data. Initially populated data is not considered sent.

    Sets the `required` attribute on widgets.
    Nc                 &    || _         ddi| _        d S rt   rv   rw   s     r/   r)   zInputRequired.__init__:  rx   r0   c                     |j         r|j         d         rd S | j        |                    d          }n| j        }g |j        d d <   t	          |          )Nr   rz   )rm   r,   rC   rp   r   r{   s       r/   rL   zInputRequired.__call__>  s_    > 	enQ/ 	F<mm$=>>GGlGQQQW%%%r0   r'   rM   r7   r0   r/   r   r   -  sA        
 
. . . .
& 
& 
& 
& 
&r0   r   c                   "    e Zd ZdZddZddZdS )r   a  
    Validates the field against a user provided regexp.

    :param regex:
        The regular expression string to use. Can also be a compiled regular
        expression pattern.
    :param flags:
        The regexp flags to use, for example re.IGNORECASE. Ignored if
        `regex` is not a string.
    :param message:
        Error message to raise in case of a validation error.
    r   Nc                 v    t          |t                    rt          j        ||          }|| _        || _        d S r'   )rn   ro   recompileregexr,   )r+   r   flagsr,   s       r/   r)   zRegexp.__init__Y  s7    eS!! 	-Jue,,E
r0   c                     | j                             |j        pd          }|r|S |$| j        |                    d          }n| j        }t          |          )Nr%   zInvalid input.)r   matchrD   r,   rC   r   )r+   rG   rH   r,   r   s        r/   rL   zRegexp.__call___  sa    
  !1r22 	L?|#--(899,g&&&r0   )r   Nr'   rM   r7   r0   r/   r   r   K  sF            ' ' ' ' ' 'r0   r   c                   *    e Zd ZdZ	 	 	 	 	 ddZd ZdS )r   a  
    Validates an email address. Requires email_validator package to be
    installed. For ex: pip install wtforms[email].

    :param message:
        Error message to raise in case of a validation error.
    :param granular_message:
        Use validation failed message from email_validator library
        (Default False).
    :param check_deliverability:
        Perform domain name resolution check (Default False).
    :param allow_smtputf8:
        Fail validation for addresses that would require SMTPUTF8
        (Default True).
    :param allow_empty_local:
        Allow an empty local part (i.e. @example.com), e.g. for validating
        Postfix aliases (Default False).
    NFTc                 L    || _         || _        || _        || _        || _        d S r'   )r,   granular_messagecheck_deliverabilityallow_smtputf8allow_empty_local)r+   r,   r   r   r   r   s         r/   r)   zEmail.__init__  s1      0$8!,!2r0   c                    	 dd l }n"# t          $ r}t          d          |d }~ww xY w	 |j        |                                |                    |j        | j        | j        | j                   d S # |j        $ rP}| j	        }|2| j
        r|                    |          }n|                    d          }t          |          |d }~ww xY w)Nr   z7Install 'email_validator' for email validation support.)r   r   r   zInvalid email address.)email_validatorImportErrorr:   rD   EmailNotValidErrorvalidate_emailr   r   r   r,   r   rC   r   )r+   rG   rH   r   rJ   er,   s          r/   rL   zEmail.__call__  s   	""""" 	 	 	I 	
	2z!%88:::**
%)%>#2"&"8	 +      1 	2 	2 	2lG( F#mmA..GG#mm,DEEG!'**1	2s)    
&!&AA4 4
C>AC		C)NFFTFrM   r7   r0   r/   r   r   m  sR         * "3 3 3 32 2 2 2 2r0   r   c                   L    e Zd ZdZd	dZd Zed             Zed             ZdS )
r	   a  
    Validates an IP address.

    :param ipv4:
        If True, accept IPv4 addresses as valid (default True)
    :param ipv6:
        If True, accept IPv6 addresses as valid (default False)
    :param message:
        Error message to raise in case of a validation error.
    TFNc                 V    |s|st          d          || _        || _        || _        d S )NzDIP Address Validator must have at least one of ipv4 or ipv6 enabled.)r(   ipv4ipv6r,   )r+   r   r   r,   s       r/   r)   zIPAddress.__init__  sA     	D 	V   		r0   c                     |j         }d}|r8| j        r|                     |          p| j        o|                     |          }|rd S | j        }||                    d          }t          |          )NFzInvalid IP address.)rD   r   
check_ipv4r   
check_ipv6r,   rC   r   )r+   rG   rH   valuevalidr,   s         r/   rL   zIPAddress.__call__  s    
 	Y94??5#9#9 	4dooe44   	F,?mm$9::Gg&&&r0   c                     	 t          j        |          }n# t          $ r Y dS w xY wt          |t           j                  sdS dS NFT)	ipaddressr
   r(   rn   IPv4Addressclsr   addresss      r/   r   zIPAddress.check_ipv4  \    	*511GG 	 	 	55	 '9#899 	5t    
%%c                     	 t          j        |          }n# t          $ r Y dS w xY wt          |t           j                  sdS dS r   )r   r
   r(   rn   IPv6Addressr   s      r/   r   zIPAddress.check_ipv6  r   r   )TFN)	r3   r4   r5   r6   r)   rL   classmethodr   r   r7   r0   r/   r	   r	     sw        	 	   ' ' '  	 	 [	 	 	 [	 	 	r0   r	   c                   .     e Zd ZdZd fd	Z fdZ xZS )r   zu
    Validates a MAC address.

    :param message:
        Error message to raise in case of a validation error.
    Nc                 R    d}t                                          ||           d S )Nz&^(?:[0-9a-fA-F]{2}:){5}[0-9a-fA-F]{2}$r,   )superr)   )r+   r,   pattern	__class__s      r/   r)   zMacAddress.__init__  s+    ;'22222r0   c                     | j         }||                    d          }t                                          |||           d S )NzInvalid Mac address.)r,   rC   r   rL   )r+   rG   rH   r,   r   s       r/   rL   zMacAddress.__call__  sC    ,?mm$:;;Gug.....r0   r'   r3   r4   r5   r6   r)   rL   __classcell__r   s   @r/   r   r     s`         3 3 3 3 3 3/ / / / / / / / /r0   r   c                   .     e Zd ZdZd fd	Z fdZ xZS )r   a  
    Simple regexp based url validation. Much like the email validator, you
    probably want to validate the url later by other means if the url must
    resolve.

    :param require_tld:
        If true, then the domain-name portion of the URL must contain a .tld
        suffix.  Set this to false if you want to allow domains like
        `localhost`.
    :param allow_ip:
        If false, then give ip as host will fail validation
    :param message:
        Error message to raise in case of a validation error.
    TNc                     d}t                                          |t          j        |           t	          ||          | _        d S )NzP^[a-z]+://(?P<host>[^\/\?:]+)(?P<port>:[0-9]+)?(?P<path>\/.*?)?(?P<query>\?.*)?$require_tldallow_ip)r   r)   r   
IGNORECASEHostnameValidationvalidate_hostname)r+   r   r   r,   r   r   s        r/   r)   zURL.__init__  sO    ! 	 	w777!3#h"
 "
 "
r0   c                     | j         }||                    d          }t                                          |||          }|                     |                    d                    st          |          d S )NzInvalid URL.host)r,   rC   r   rL   r   groupr   )r+   rG   rH   r,   r   r   s        r/   rL   zURL.__call__  su    ,?mmN33G  ug66%%ekk&&9&9:: 	+!'***	+ 	+r0   )TTNr   r   s   @r/   r   r     s`         
 
 
 
 
 
+ + + + + + + + +r0   r   c                        e Zd ZdZddZd ZdS )r   zn
    Validates a UUID.

    :param message:
        Error message to raise in case of a validation error.
    Nc                     || _         d S r'   r   rw   s     r/   r)   zUUID.__init__+  s    r0   c                     | j         }||                    d          }	 t          j        |j                   d S # t
          $ r}t          |          |d }~ww xY w)NzInvalid UUID.)r,   rC   uuidr   rD   r(   r   )r+   rG   rH   r,   rJ   s        r/   rL   zUUID.__call__.  sk    ,?mmO44G	4Iej!!!!! 	4 	4 	4!'**3	4s   ; 
AAAr'   rM   r7   r0   r/   r   r   #  sA            4 4 4 4 4r0   r   c                   6    e Zd ZdZddZd Zed             ZdS )r   ae  
    Compares the incoming data to a sequence of valid inputs.

    :param values:
        A sequence of valid inputs.
    :param message:
        Error message to raise in case of a validation error. `%(values)s`
        contains the list of values.
    :param values_formatter:
        Function used to format the list of values in the error message.
    Nc                 B    || _         || _        || j        }|| _        d S r'   valuesr,   default_values_formattervalues_formatterr+   r   r,   r   s       r/   r)   zAnyOf.__init__E  -    ##< 0r0   c                 <    t          |j        t                    r|j        n|j        g}t           fd|D                       rd S  j        }||                    d          }t          |t                                j	                            z            )Nc              3   *   K   | ]}|j         v V  d S r'   r   .0rK   r+   s     r/   	<genexpr>z!AnyOf.__call__.<locals>.<genexpr>N  s*      ..AqDK......r0   z*Invalid value, must be one of: %(values)s.r   
rn   rD   listanyr,   rC   r   r[   r   r   ra   s   `    r/   rL   zAnyOf.__call__L  s    '
D99Kuzz
|......... 	F,?mm$PQQGgD4I4I$+4V4V(W(W(WWXXXr0   c                 @    d                     d | D                       S )N, c              3   4   K   | ]}t          |          V  d S r'   ro   r   xs     r/   r   z1AnyOf.default_values_formatter.<locals>.<genexpr>Y  s(      00AQ000000r0   joinr   s    r/   r   zAnyOf.default_values_formatterW  s#    yy00000000r0   NNr3   r4   r5   r6   r)   rL   staticmethodr   r7   r0   r/   r   r   8  s_        
 
1 1 1 1	Y 	Y 	Y 1 1 \1 1 1r0   r   c                   6    e Zd ZdZddZd Zed             ZdS )r   ai  
    Compares the incoming data to a sequence of invalid inputs.

    :param values:
        A sequence of invalid inputs.
    :param message:
        Error message to raise in case of a validation error. `%(values)s`
        contains the list of values.
    :param values_formatter:
        Function used to format the list of values in the error message.
    Nc                 B    || _         || _        || j        }|| _        d S r'   r   r   s       r/   r)   zNoneOf.__init__i  r   r0   c                 <    t          |j        t                    r|j        n|j        g}t           fd|D                       sd S  j        }||                    d          }t          |t                                j	                            z            )Nc              3   *   K   | ]}|j         v V  d S r'   r   r   s     r/   r   z"NoneOf.__call__.<locals>.<genexpr>r  s*      221#222222r0   z+Invalid value, can't be any of: %(values)s.r   r   ra   s   `    r/   rL   zNoneOf.__call__p  s    '
D99Kuzz
|2222T22222 	F,?mm$QRRGgD4I4I$+4V4V(W(W(WWXXXr0   c                 @    d                     d | D                       S )Nr   c              3   4   K   | ]}t          |          V  d S r'   r   r   s     r/   r   z2NoneOf.default_values_formatter.<locals>.<genexpr>}  s(      ++AQ++++++r0   r   )vs    r/   r   zNoneOf.default_values_formatter{  s#    yy++++++++r0   r   r   r7   r0   r/   r   r   \  s_        
 
1 1 1 1	Y 	Y 	Y , , \, , ,r0   r   c                   x    e Zd ZdZ ej        dej                  Z ej        dej                  Zd	dZ	d Z
dS )
r   z
    Helper class for checking hostnames for validation.

    This is not a validator in and of itself, and as such is not exported.
    z!^(xn-|[a-z0-9_]+)(-[a-z0-9_-]+)*$z*^([a-z]{2,20}|xn--([a-z0-9]+-)*[a-z0-9]+)$TFc                 "    || _         || _        d S r'   r   )r+   r   r   s      r/   r)   zHostnameValidation.__init__  s    & r0   c                 b   | j         r6t                              |          st                              |          rdS 	 |                    d          }n# t
          $ r Y nw xY wt          |t                    s|                    d          }t          |          dk    rdS |
                    d          }|D ]7}|rt          |          dk    r dS | j                            |          s dS 8| j        r5t          |          dk     s | j                            |d	                   sdS dS )
NTidnaascii   F.?      rO   )r   r	   r   r   encodeUnicodeErrorrn   ro   decoderY   splithostname_partr   r   tld_part)r+   hostnamepartsparts       r/   rL   zHostnameValidation.__call__  sT   = 	  **	.7.B.B8.L.L	 4	v..HH 	 	 	D	 (C(( 	0w//Hx==35 s## 	 	D 3t99r>>uu%++D11 uu  	Uat}7J7J5QS97U7U5ts   A 
A"!A"N)TF)r3   r4   r5   r6   r   r   r   r   r   r)   rL   r7   r0   r/   r   r     so          BJCR]SSMrzGWWH! ! ! !    r0   r   c                       e Zd ZdZd Zd ZdS )r!   z
    Set a field readonly.

    Validation fails if the form data is different than the
    field object data, or if unset, from the field default data.
    c                     ddi| _         d S )Nr    TrV   r+   s    r/   r)   zReadOnly.__init__      &-r0   c                 j    |j         |j        k    r"t          |                    d                    d S )NzThis field cannot be edited.)rD   object_datar   rC   rq   s      r/   rL   zReadOnly.__call__  s5    :***!%--0N"O"OPPP +*r0   NrM   r7   r0   r/   r!   r!     sA         . . .Q Q Q Q Qr0   r!   c                       e Zd ZdZd Zd ZdS )r#   zU
    Set a field disabled.

    Validation fails if the form data has any value.
    c                     ddi| _         d S )Nr"   Tr   r   s    r/   r)   zDisabled.__init__  r   r0   c                 X    |j         "t          |                    d                    d S )Nz/This field is disabled and cannot have a value.)rm   r   rC   rq   s      r/   rL   zDisabled.__call__  s4    >%!OPP   &%r0   NrM   r7   r0   r/   r#   r#     s<         . . .    r0   r#   ))r   r_   r   r   __all__r(   r   r:   r   r   r   r   r   r   r   r   r   r	   r   r   r   r   r   r   r!   r#   r   r   r
   r   r   r   r   r   r   r   r   r   r   r    r"   r7   r0   r/   <module>r     s        				 "J< < < < <j < < <
; 
; 
; 
; 
;Y 
; 
; 
;$+ $+ $+ $+ $+ $+ $+ $+N?Y ?Y ?Y ?Y ?Y ?Y ?Y ?YD6J 6J 6J 6J 6J 6J 6J 6Jr# # # # # # # #@'& '& '& '& '& '& '& '&T& & & & & & & &<' ' ' ' ' ' ' 'D:2 :2 :2 :2 :2 :2 :2 :2z; ; ; ; ; ; ; ;|/ / / / / / / /($+ $+ $+ $+ $+& $+ $+ $+N4 4 4 4 4 4 4 4*!1 !1 !1 !1 !1 !1 !1 !1H!, !, !, !, !, !, !, !,H, , , , , , , ,^Q Q Q Q Q Q Q Q        " 	
				
r0   