
    ^jk              
          U d Z ddlZddlZddlmZmZ ddlmZmZm	Z	 ddl
mZ ddlmZmZ ddlmZ ej"                  j%                         D  ci c]  \  } }|| 
 c}} Zeeef   ed	<    ej.                  d
      Z eej"                  j5                               Zee   ed<    eh d      Zee   ed<    eddh      Zee   ed<    ed       G d d             Z ed       G d d             Zdede fdZ!ejD                  d-dededz  defd       Z#dedz  de$edz  ef   fdZ%dedz  dee   fdZ&d-dededz  de fdZ'dedefd Z(d-d!ededz  defd"Z)d#edefd$Z*d%ed&ede$eedz  e dz  f   fd'Z+d(ed&ede$ejX                  ef   fd)Z-d(ed*ejX                  d&edefd+Z.d(ed*ejX                  d&edefd,Z/yc c}} w ).a  Centralized parser for Hugging Face Hub URIs ('hf://...') and mount specifications.

A HF URI is a URI-like string that identifies a location on the Hugging Face
Hub: a model/dataset/space/kernel repository, a bucket, optionally a revision,
and optionally a path inside the repo or bucket.

Canonical syntax:

```
hf://[<TYPE>/]<ID>[@<REVISION>][/<PATH>]
```

For convenience, [`parse_hf_uri`] also accepts Hugging Face **web URLs** (the
ones you copy-paste from your browser), e.g.
'https://huggingface.co/datasets/my-org/my-dataset/blob/main/train.csv'. They are
normalized to the canonical 'hf://' form before parsing. Only unambiguous URLs
(repository / bucket pages and file/folder viewer routes) are accepted; any other
route is rejected rather than guessed.

A HF mount wraps a HF URI with a local mount path and an optional ':ro'/':rw'
flag (used by Spaces and Jobs volumes):

```
hf://[<TYPE>/]<ID>[@<REVISION>][/<PATH>]:<MOUNT_PATH>[:ro|:rw]
```

See 'docs/source/en/package_reference/hf_uris.md' for the full grammar and examples.
    N)	dataclassfield)quoteunquoteurlsplit)	constants)
HfUriErrorHFValidationError   )validate_repo_id_TYPE_TO_PREFIXz ^refs/(?:convert/[\w.-]+|pr/\d+)_VALID_URI_TYPES>   rawblobtreeblameresolve_URL_REPO_LOCATION_ACTIONSr   r   _URL_BUCKET_LOCATION_ACTIONST)frozenc                       e Zd ZU dZej
                  ed<   eed<   dZedz  ed<   dZ	eed<    e
dddd	      Zedz  ed
<   ddZedefd       Zedefd       ZdefdZddedz  defdZy)HfUria  Parsed representation of a Hugging Face Hub URI ('hf://...').

    Attributes:
        type (`str`):
            One of 'model', 'dataset', 'space', 'kernel' or 'bucket'.
        id (`str`):
            The repository id ('namespace/name', e.g. 'my-org/my-model') for repo URIs, or the bucket id ('namespace/name') for bucket URIs.
        revision (`str`, *optional*):
            The revision specified after '@' in the URI, URL-decoded. 'None' if no revision was specified, or for bucket URIs (which
            never carry a revision). Special refs like 'refs/pr/10' and 'refs/convert/parquet' are preserved as-is.
        path_in_repo (`str`):
            The path inside the repo or bucket. Empty string if the URI points at the root.
    typeidNrevision path_in_repoFreprhashcomparedefault_rawreturnc           	         | j                   xs d}| j                  t        vr+t        |d| j                   dt	        t               d      | j
                  r| j
                  j                  d      dk7  rt        |d| j
                   d	      | j                  d
k7  r	 t        | j
                         | j                  | j                  st        |d      | j                  d
k(  r| j                  t        |d      | j                  rE| j                  j                  d      sd| j                  v rt        |d| j                   d      y y # t        $ r}t        |t        |            |d }~ww xY w)Nr   zInvalid type 'z'. Must be one of .urimsg/r   z"Id must be 'namespace/name', got ''.bucketz%Revision must not be an empty string.z&Bucket URIs do not support a revision.//z+Path must not contain empty segments (got 'z').)r#   r   r   r	   sortedr   countr   r
   strr   r   
startswith)selfr(   es      i/var/www/ramen.bs-engineer-server.com/venv/lib/python3.12/site-packages/huggingface_hub/utils/_hf_uris.py__post_init__zHfUri.__post_init__d   s]   iio2 99,,N499+EWX^_oXpWqqr*stt ww$''--,1,NtwwiWY*Z[[99 = )
 ==$T]]*QRR99 T]]%>*RSS   ++C0DD<M<M4M S0[\`\m\m[nnq.rss 5N  % = Sc!f51<=s   #E 	E< E77E<c                      | j                   dk(  S )z$True if this URI points at a bucket.r,   r   r2   s    r4   	is_bucketzHfUri.is_bucket        yyH$$    c                      | j                   dk7  S )zJTrue if this URI points at a repository (model, dataset, space or kernel).r,   r7   r8   s    r4   is_repozHfUri.is_repo   r:   r;   c                    t         j                  t        | j                     d| j                  g}| j
                  K| j
                  }d|v r't        j                  |      |j                  dd      }|j                  d|        | j                  r|j                  d| j                          dj                  |      S )zRender the URI as a canonical 'hf://' string.

        The type prefix is always written explicitly (e.g. 'hf://models/my-org/my-model').
        r*   %2F@r   )r   HF_PROTOCOLr   r   r   r   _SPECIAL_REFS_REVISION_REGEX	fullmatchreplaceappendr   join)r2   partsr   s      r4   to_urizHfUri.to_uri   s    
 &11?4993MsTXT[T[\==$ }}Hh#?#I#I(#S#[#++C7LL1XJ(LL1T../01wwu~r;   endpointc                    |xs t         j                  j                  d      }t        | j                  d      }| j
                  dk(  r| d| j                   }|r|d| z  }|S | j
                  dk(  r| d| j                   n$| dt        | j
                      d| j                   }| j                  }|"t        j                  |      t        |d      }|r|d|xs t         j                   d| z  }|S ||d| z  }|S )	a  Render the URI as a Hugging Face **web URL** (the kind you open in a browser).

        This is the inverse of parsing a URL with [`parse_hf_uri`]. The returned URL points at:

        - the repository / bucket landing page when no path or revision is set;
        - the folder viewer ('/tree/<revision>') when only a revision is set;
        - the file viewer ('/blob/<revision>/<path>') for repository files (revision defaults to 'main');
        - the tree route ('/tree/<path>') for bucket files (buckets are not versioned).

        Args:
            endpoint (`str`, *optional*):
                Base endpoint to use. Defaults to 'constants.ENDPOINT' (i.e. 'https://huggingface.co').

        Returns:
            `str`: the web URL.

        Example:
            ```py
            >>> from huggingface_hub import parse_hf_uri
            >>> parse_hf_uri("hf://datasets/my-org/my-dataset@v1/train.csv").to_url()
            'https://huggingface.co/datasets/my-org/my-dataset/blob/v1/train.csv'
            ```
        r*   )safer,   z	/buckets/z/tree/modelr   z/blob/)r   ENDPOINTrstripr   r   r   r   r   r   rB   rC   DEFAULT_REVISION)r2   rI   basepathurlr   s         r4   to_urlzHfUri.to_url   s.   0 .I..66s; T&&S199 F)DGG9-Cv&J &*YY'%9ay!$qY]YbYbIcHddefjfmfmen?o==
 $@$J$J8$T$\XB/HVHB	(B(BC1TFKKC 
 !VH:&&C
r;   r$   NN)__name__
__module____qualname____doc__r   	HfUriType__annotations__r0   r   r   r   r#   r5   propertyboolr9   r=   rH   rS    r;   r4   r   r   N   s     

GHcDjL#%eUDQD#*Qt6 %4 % % % % % $0sTz 0S 0r;   r   c                   v    e Zd ZU dZeed<   eed<   dZedz  ed<    e	dddd      Z
edz  ed<   dd
Zd	efdZy)HfMountaF  A HF URI paired with a local mount path and optional read-only flag.

    Used by Spaces and Jobs to describe volume mounts. The full syntax is:

    ```
    hf://[<TYPE>/]<ID>[@<REVISION>][/<PATH>]:<MOUNT_PATH>[:ro|:rw]
    ```

    Attributes:
        source ([`HfUri`]):
            The parsed HF URI identifying the Hub resource to mount.
        mount_path (`str`):
            The local mount path (always starts with '/').
        read_only (`bool`, *optional*):
            True if the mount ends with ':ro', False if it ends with ':rw', 'None' if no flag was provided.
    source
mount_pathN	read_onlyFr   r#   r$   c                     | j                   xs d}| j                  j                  d      r| j                  dk(  rt        |d| j                   d      y )Nr   r*   zEMount path must be a non-empty absolute path starting with '/', got 'r+   r'   )r#   rb   r1   r	   )r2   r   s     r4   r5   zHfMount.__post_init__   sW    iio2))#.$//S2H[\`\k\k[llno  3Ir;   c                     | j                   j                         d| j                  g}| j                  |j	                  | j                  rdnd       dj                  |      S )zqRender the mount as a canonical 'hf://' string.

        Example: 'hf://models/my-org/my-model:/data:ro'
        ::ro:rwr   )ra   rH   rb   rc   rE   rF   )r2   rG   s     r4   rH   zHfMount.to_uri   sM    
 ##%sDOO<>>%LL$..e<wwu~r;   rT   )rV   rW   rX   rY   r   r[   r0   rc   r]   r   r#   r5   rH   r^   r;   r4   r`   r`      sK    " MO!Itd{!%eUDQD#*Q r;   r`   r(   r$   c                 :    	 t        |        y# t        $ r Y yw xY w)zVCheck if a string is a valid HF URI ('hf://...') or a recognized Hugging Face web URL.TF)parse_hf_urir	   )r(   s    r4   	is_hf_urirk      s$    S s    	rI   c                    | }| j                  t        j                        r<| t        t        j                        d }|sht	        | dt        j                   d      t        | |      rt        | |      }n/t	        | dt        j                   dt        j                   d      t        ||      \  }}|d	k(  rt        |||      S t        |||      S )
a  Parse a Hugging Face Hub URI ('hf://...') or a Hugging Face web URL.

    A HF URI is a URI-like string identifying a location on the Hugging Face Hub. The full grammar is:

    ```
    hf://[<TYPE>/]<ID>[@<REVISION>][/<PATH>]
    ```

    For convenience, Hugging Face **web URLs** (the ones you copy-paste from the website) are also
    accepted and normalized to the canonical 'hf://' form, e.g.
    'https://huggingface.co/datasets/my-org/my-dataset/blob/main/train.csv'. Only unambiguous URLs
    (repository / bucket pages and file/folder viewer routes) are accepted; any other route is rejected.

    See 'docs/source/en/package_reference/hf_uris.md' for the full specification.

    Args:
        uri (`str`):
            The URI to parse. Must start with 'hf://', or be a Hugging Face URL (e.g. 'https://huggingface.co/...').
        endpoint (`str`, *optional*):
            A custom Hub endpoint (e.g. a self-hosted or proxied Hub like 'https://hub.my-company.com' or
            'http://localhost:8080/hf'). When provided, web URLs on that endpoint are recognized in addition to
            the default Hugging Face hosts. Has no effect on 'hf://' URIs.

    Returns:
        [`HfUri`]: the parsed URI.

    Raises:
        [`HfUriError`]:
            If the URI is malformed (missing prefix, invalid type, missing id, unsupported URL route, etc.).

    Examples:
        ```py
        >>> from huggingface_hub.utils import parse_hf_uri
        >>> parse_hf_uri("hf://my-org/my-model")
        HfUri(type='model', id='my-org/my-model', revision=None, path_in_repo='')
        >>> parse_hf_uri("hf://datasets/my-org/my-dataset@refs/pr/3/train.json")
        HfUri(type='dataset', id='my-org/my-dataset', revision='refs/pr/3', path_in_repo='train.json')
        >>> parse_hf_uri("https://huggingface.co/datasets/my-org/my-dataset/blob/main/train.csv")
        HfUri(type='dataset', id='my-org/my-dataset', revision='main', path_in_repo='train.csv')
        ```
    NEmpty body after 'r+   )rI   Must start with 'zQ' or be a Hugging Face URL (e.g. 'https://huggingface.co/...'). Expected format: z#[<TYPE>/]<ID>[@<REVISION>][/<PATH>]r   r,   )
r1   r   rA   lenr	   _looks_like_hf_url_url_to_uri_body_split_type_parse_bucket_body_parse_repo_body)r(   rI   r   bodytype_locations         r4   rj   rj     s    V C
~~i++,3y,,-/0S$6y7L7L6MR"PQQ	C(	3h7	 5 56 7  ) 5 566Y[
 	
 "$C0OE8!(Es;;He55r;   c                     | yt        d| v r| nd| z         }|j                  r|j                  j                         nd}||j                  j	                  d      fS )a  Return the lowercased host and stripped path prefix of a custom Hub 'endpoint'.

    E.g. 'https://hub.my-company.com' -> ('hub.my-company.com', '') and a self-hosted
    'http://localhost:8080/hf' -> ('localhost', 'hf'). Returns '(None, "")' when 'endpoint' is None.
    N)Nr   ://r-   r*   )r   hostnamelowerrQ   strip)rI   parsedhosts      r4   _endpoint_host_and_pathr   B  sX     %8"3hIF&,oo6??  "4D""3'''r;   c                 j    t        |       \  }}|rt        j                  |hz  S t        j                  S )z^The set of hosts whose web URLs can be parsed: the default Hugging Face hosts plus 'endpoint'.)r   r   HF_URL_HOSTS)rI   r   _s      r4   _recognized_hostsr   P  s0    %h/GD!.29!!TF*N	8N8NNr;   c                     | j                         j                  d      ryt        fdt        |      D              S )zNReturn True if 'uri' looks like a (possibly scheme-less) Hugging Face web URL.)zhttp://zhttps://Tc              3   T   K   | ]  }|k(  xs j                  |d z          ! yw)r*   N)r1   ).0r   lowereds     r4   	<genexpr>z%_looks_like_hf_url.<locals>.<genexpr>\  s,     iTw$@'"4"4TCZ"@@is   %()r|   r1   anyr   )r(   rI   r   s     @r4   rq   rq   V  s8    iikG12iM^_gMhiiir;   segmentc                 8    t        |       j                  dd      S )aw  Percent-decode a single URL path segment (e.g. 'file%20name.txt' -> 'file name.txt').

    A decoded '/' is re-encoded as '%2F' so the segment stays atomic when the normalized body is
    re-split by the shared parser. This decodes ordinary path characters (spaces, '#', ...) that
    browsers encode, while keeping '%2F'-encoded revisions (e.g. 'feature%2Ffoo') intact.
    r*   r?   )r   rD   )r   s    r4   _decode_url_path_segmentr   _  s     7##C//r;   rR   c                    | }t        d| v r| nd| z         }|j                  xs dj                         }|t        |      vrt	        |d|xs |  d      |j
                  }t        |      \  }}|r1||k(  r,d|z   }||k(  s|j                  |dz         r|t        |      d }|j                  d      D 	cg c]  }	|	s|		 }
}	|
st	        |d	|  d
      d}|
d   t        j                  v r
|
d   }|
dd }
t        |
      dk  rt	        |d|  d      |
d    d|
d    }|
dd }|dk(  rN|sd| S |^}}|t        vrt	        |d|  d| d      dj                  d |D              }|rd| d| S d| S |r| dnd}|s| | S |^}}|t        vrt	        |d|  d| d      |s| | S dj                  d |D              }| | d| S c c}	w )a  Normalize a Hugging Face web URL into the body of a 'hf://' URI (everything after 'hf://').

    The returned string is fed back into the regular URI parsing logic, so all validation
    (repo id, revision, empty path segments, ...) is shared with the canonical 'hf://' path.
    Only unambiguous URLs are accepted: any unrecognized route raises [`HfUriError`]. When 'endpoint'
    is provided, URLs on that custom Hub host are recognized too (and its path prefix is stripped).
    rz   r-   r   zUnrecognized host 'zC'. Expected a Hugging Face URL (e.g. 'https://huggingface.co/...').r'   r*   Nz0Missing repository or bucket identifier in URL 'r+   r   r      zCannot parse URL 'z{': expected a '<namespace>/<name>' repository or bucket. User/organization pages and single-segment URLs are not supported.bucketszbuckets/zCannot parse bucket URL 'z': unsupported '/z	/' route.c              3   2   K   | ]  }t        |        y wrU   r   r   r   s     r4   r   z#_url_to_uri_body.<locals>.<genexpr>  s     Ng09N   zl/' route. Only repository pages and file/folder viewer routes (blob, resolve, raw, tree, ...) can be parsed.c              3   2   K   | ]  }t        |        y wrU   r   r   s     r4   r   z#_url_to_uri_body.<locals>.<genexpr>  s     MW/8Mr   r@   )r   r{   r|   r   r	   rQ   r   r1   rp   splitr   HF_URI_TYPE_PREFIXESr   rF   r   )rR   rI   r   r~   r   rQ   endpoint_hostendpoint_pathprefixr   segmentstype_prefixrepo_idrestactiontaildecodeds                    r4   rr   rr   i  s    CUc\ctcz:FOO!r((*D$X..%dkc]2uv
 	
 ;;D $;8#D M=.}$6>T__Vc\:F&D'+zz#BG'BHBS(XY\X]]_&`aa #K{i444qkAB< 8}q$SE *U U
 	
 !Qx{m,GAB<DigY''55,EcUJ[\b[ccl*mnnxxNNN.2'!D6*L(7)8LL"-}A2F'##MFT//$SE):6( Cu u
 	
 '##
 hhMMMGXgYay))i Cs   7G?G	mount_strc                    | j                  t        j                        st        | dt        j                   d      | }| t	        t        j                        d }|st        |dt        j                   d      t        ||      \  }}}|t        |d      t        j                  |z   }	 t        |      }t        ||||      S # t        $ r}t        ||j                        |d}~ww xY w)	a  Parse a HF mount specification ('hf://...:<MOUNT_PATH>[:ro|:rw]').

    A mount specification is a HF URI followed by a local mount path and an optional read-only/read-write flag.
    The full grammar is:

    ```
    hf://[<TYPE>/]<ID>[@<REVISION>][/<PATH>]:<MOUNT_PATH>[:ro|:rw]
    ```

    See 'docs/source/en/package_reference/hf_uris.md' for the full specification.

    Args:
        mount_str (`str`):
            The mount string to parse. Must start with 'hf://' and contain a ':<MOUNT_PATH>' segment.

    Returns:
        [`HfMount`]: the parsed mount.

    Raises:
        [`HfUriError`]:
            If the mount string is malformed (missing mount path, invalid URI, etc.).

    Examples:
        ```py
        >>> from huggingface_hub.utils import parse_hf_mount
        >>> parse_hf_mount("hf://my-org/my-model:/data:ro")
        HfMount(source=HfUri(type='model', id='my-org/my-model', revision=None, path_in_repo=''), mount_path='/data', read_only=True)
        >>> parse_hf_mount("hf://buckets/my-org/my-bucket/sub/dir:/mnt:rw")
        HfMount(source=HfUri(type='bucket', id='my-org/my-bucket', revision=None, path_in_repo='sub/dir'), mount_path='/mnt', read_only=False)
        ```
    rn   r+   r'   Nrm   ro   zKMissing mount path. Expected ':<MOUNT_PATH>' (e.g. 'hf://org/model:/data').)ra   rb   rc   r#   )	r1   r   rA   r	   rp   _split_mountrj   r)   r`   )	r   r   rv   rx   rb   rc   uri_strra   r3   s	            r4   parse_hf_mountr     s    @ 	 5 56#I$9$9#:"=
 	

 CS../12DS(:9;P;P:QQS&TUU&24S&A#Hj)S&stt ##h.G4g& &Z9SVWW  4Saee,!34s   2C 	C2C--C2rv   r   c                0   | j                  d      rd| j                  d      } }n'| j                  d      rd| j                  d      } }nd}| j                  d      }|dk(  r|t        |d	      | ddfS | d| }| |d
z   d }|st        |d	      |||fS )zSplit the ':<MOUNT_PATH>[:ro|:rw]' suffix from 'body'.

    Returns '(location, mount_path, read_only)' where 'mount_path' is 'None' if no mount segment is present.
    rg   Trh   FNz:/zb':ro'/':rw' suffix is only valid when a mount path is provided (e.g. 'hf://...:/<MOUNT_PATH>:ro').r'   r   z#Missing location before mount path.)endswithremovesuffixrfindr	   )rv   r   rc   idxrx   rb   s         r4   r   r     s    
 }}U 1 1% 84		u	!2!25!94		 **T
C
by x  T4DSzHcAgiJS&KLLZ**r;   rx   c          	         | j                  d      }|dk(  rr| t        j                  v r$t        |d|  dt        j                   |  d      t
        j                  |       x}!t        |dt        j                   | d	      d
| fS | d| }| |dz   d }|t        j                  v rt        j                  |   |fS t
        j                  |      x}t        |d| d| d      d
| fS )zDetect the (optional) type prefix and return '(type, remaining_location)'.

    A missing type prefix defaults to 'model'. Singular forms ('model/', 'dataset/', etc.) are explicitly rejected with a helpful error.
    r*   r   zMissing identifier after 'z'. Expected 'z/<ID>'.r'   Nz*Type prefix must be plural. Did you mean 'z/...'?rL   r   z!Type prefix must be plural, got 'z/'. Did you mean 'z/'?)findr   r   r	   rA   r   get)rx   r   	slash_idxsingular_pluralfirstr   s         r4   rs   rs     s/   
 c"IBy5550
-	H]H]G^_g^hhop   /228<<OI@AVAV@WXgWhhno    Zi EIMO$D	...--e4d::*..u55B<UGCUVeUffij
 	
 Hr;   rw   c                    | j                  d      } | j                  dd      }t        |      dk  s
|d   r|d   st        |d|  d      |d    d|d    }d|v rt        |d	      t        |      d
k\  r|d   nd}t	        ||d||      S )z8Parse the body of a bucket URI: 'namespace/name[/path]'.r*   r   r   r   z)Bucket id must be 'namespace/name', got 'r+   r'   r@   z3Bucket URIs do not support a revision marker ('@').   r   Nr   r   r   r   r#   )r}   r   rp   r	   r   )rx   rw   r   rG   	bucket_idpath_in_buckets         r4   rt   rt   2  s     ~~c"HNN3"E
5zA~U1XU1XS(QRZQ[[]&^__8*AeAhZ(I
iS&[\\!$UqU1XbN# r;   c                   | j                  d      } | st        |d      | j                  d      }|dk(  s| d| j                  d      dkD  rVd}| j	                  dd      }t        |      dk  rt        |d	|  d
      |d    d|d    }t        |      dkD  r|d   nd}n| d| }| |dz   d }|st        |d      |j                  d      dk7  rt        |d	| d      t        j                  |      }	|	.|	j                         }|t        |      d j                  d      }n(|j                  d      }
|
dk(  r|}d}n|d|
 }||
dz   d }t        |      }|st        |d      t        |||||      S )z@Parse the body of a repo URI: '<repo_id>[@<revision>][/<path>]'.r*   zMissing repository id.r'   r@   r   Nr   r   z-Repository id must be 'namespace/name', got 'z'. r   r   z!Missing repository id before '@'.r+   zEmpty revision after '@'.r   )r}   r	   r   r/   r   rp   rB   matchgroupremoveprefixr   r   )rx   rw   r   at_idxr   rG   r   r   rev_and_pathr   r   s              r4   ru   ru   J  s    ~~c"HS&>??
 ]]3F |x(..s3a7sA&u:>,YZbYccf*ghh1XJaaz*#&u:>uQxr7F#
-*MNN==",YZaYbbd*eff -22<@{{}H'H8EEcJL$))#.IB'!'
3+IMO<8$*EFF! r;   rU   )0rY   	functoolsredataclassesr   r   urllib.parser   r   r   huggingface_hubr   huggingface_hub.errorsr	   r
   _validatorsr   r   itemsr   dictr0   r[   compilerB   	frozensetvaluesr   r   r   r   r`   r]   rk   	lru_cacherj   tupler   r   rq   r   rr   r   r   rZ   rs   rt   ru   )kvs   00r4   <module>r      s  :  	 ( 1 1 % @ )
 5>4R4R4X4X4Z"[DAq1a4"[c3h [  *rzz*MN  $-Y-K-K-R-R-T#U )C. U .77b-c IcN c 09)V9L/M in M $| | |~ $' ' 'T3 4  <6c <6S4Z <65 <6 <6~(cDj (U3:s?5K (Od
 Oy~ OjC j3: j j0c 0c 0O*# O*t O*s O*d7Xc 7Xg 7Xt+s +C +E#sTz4$;2N,O +<# s uY5H5H#5M/N > 
	
 0888 
	8
 8e #\s   G