2bi: F S r SSKrSSKrSSKrSSKJrJr SSKJr SSK J
r
J r J r J
r
Jr SSKJrJrJrJrJrJr SSKJr / SQr\R2 " S 5 r/ S
Qr\ " S 5 r " S S
\ 5 r " S S\ S9r " S S\ 5 r! " S S\"5 r# " S S5 r$\$" 5 r% " S S\&5 r' " S S5 r(S r) " S S 5 r*\*" 5 r+S r, " S S 5 r- " S! S"\5 r. " S# S$\ 5 r/ " S% S&\ \/S9r0 " S' S(5 r1 " S) S*\05 r2S+ r3 " S, S-\/5 r4 " S. S/\0\4S9r5g)0z
pygments.lexer
~~~~~~~~~~~~~~
Base lexer classes.
:copyright: Copyright 2006-2023 by the Pygments team, see AUTHORS.
:license: BSD, see LICENSE for details.
N)
apply_filtersFilter)get_filter_by_name)ErrorTextOther
Whitespace
_TokenType) get_bool_opt get_int_opt get_list_optmake_analysatorFuture guess_decode) regex_opt)
Lexer
RegexLexerExtendedRegexLexerDelegatingLexer LexerContextincludeinheritbygroupsusingthisdefaultwordsline_rez.*?
))s utf-8)s zutf-32)s zutf-32be)s zutf-16)s zutf-16bec g)N )xs ڌ/builddir/build/BUILDROOT/alt-python313-pip-23.3.1-3.el8.x86_64/opt/alt/python313/lib/python3.13/site-packages/pip/_vendor/pygments/lexer.pyr% " s # c \ rS rSrSrS rSrg) LexerMeta% zv
This metaclass automagically converts ``analyse_text`` methods into
static methods which always return float values.
c \ SU; a [ US 5 US' [ R XX#5 $ )N analyse_text)r type__new__)mcsnamebasesds r$ r- LexerMeta.__new__+ s/ Q /.0A BAn ||Cu00r& r" N)__name__
__module__ __qualname____firstlineno____doc__r- __static_attributes__r" r& r$ r( r( % s
1r& r( c \ \ rS rSrSrSr/ r/ r/ r/ r Sr
Sr S r S r
S rS rS S jrS
rS rg)
r 1 a
Lexer for a specific language.
See also :doc:`lexerdevelopment`, a high-level guide to writing
lexers.
Lexer classes have attributes used for choosing the most appropriate
lexer based on various criteria.
.. autoattribute:: name
:no-value:
.. autoattribute:: aliases
:no-value:
.. autoattribute:: filenames
:no-value:
.. autoattribute:: alias_filenames
.. autoattribute:: mimetypes
:no-value:
.. autoattribute:: priority
Lexers included in Pygments should have an additional attribute:
.. autoattribute:: url
:no-value:
You can pass options to the constructor. The basic options recognized
by all lexers and processed by the base `Lexer` class are:
``stripnl``
Strip leading and trailing newlines from the input (default: True).
``stripall``
Strip all leading and trailing whitespace from the input
(default: False).
``ensurenl``
Make sure that the input ends with a newline (default: True). This
is required for some lexers that consume input linewise.
.. versionadded:: 1.3
``tabsize``
If given and greater than 0, expand tabs in the input (default: 0).
``encoding``
If given, must be an encoding name. This encoding will be used to
convert the input string to Unicode, if it is not already a Unicode
string (default: ``'guess'``, which uses a simple UTF-8 / Locale /
Latin1 detection. Can also be ``'chardet'`` to use the chardet
library, if it is installed.
``inencoding``
Overrides the ``encoding`` if given.
Nr c x Xl [ USS5 U l [ USS5 U l [ USS5 U l [ USS5 U l UR SS 5 U l UR S
5 =( d U R U l / U l [ US S 5 H nU R U5 M g
)a)
This constructor takes arbitrary options as keyword arguments.
Every subclass must first process its own options and then call
the `Lexer` constructor, since it processes the basic
options like `stripnl`.
An example looks like this:
.. sourcecode:: python
def __init__(self, **options):
self.compress = options.get('compress', '')
Lexer.__init__(self, **options)
As these options must all be specifiable as strings (due to the
command line usage), there are various utility functions
available to help with that, see `Utilities`_.
stripnlTstripallFensurenltabsizer encodingguess
inencodingfiltersr" N) optionsr r< r= r> r r? getr@ rC r
add_filter)selfrD filter_s r$ __init__Lexer.__init__ s & #GY= $Wj%@
$Wj$?
"7Iq9 J8
L1BT]]
#GY;G OOG $ z)rD __class__r3 rG s r$ __repr__Lexer.__repr__ sB <<<59^^5L5L59\\C
C *DNN,C,CC Cr& c | [ U[ 5 ( d [ U40 UD6nU R R U5 g)z(
Add a new stream filter to this lexer.
N)
isinstancer r rC append)rG rH rD s r$ rF Lexer.add_filter s2 '6**( UR TSS 5 n TR U R S 5 =( d S
S5 nUmOdTR T R 5 mTR S 5 ( a T[ S 5 S mO$TR S 5 ( a T[ S 5 S mTR S S
5 mTR SS
5 mT R ( a TR 5 mO"T R ( a TR S
5 mT R" S: a TR% T R" 5 mT R& ( a TR) S
5 ( d TS
-
mU U4S jn
U
" 5 n U( d [+ U T R, T 5 n U $ ! [ a n[
S5 UeSnAff = f)a
This method is the basic interface of a lexer. It is called by
the `highlight()` function. It must process the text and return an
iterable of ``(tokentype, value)`` pairs from `text`.
Normally, you don't need to override this method. The default
implementation processes the options recognized by all lexers
(`stripnl`, `stripall` and so on), and then yields all tokens
from `get_tokens_unprocessed()`, with the ``index`` dropped.
If `unfiltered` is set to `True`, the filtering mechanism is
bypassed even if filters are defined.
rA chardetr )rY zkTo enable chardet encoding guessing, please install the chardet library from http://chardet.feedparser.org/Nreplacei r@ r u z
c 3 N ># TR T5 H u pnX4v M
g 7fN)get_tokens_unprocessed)_tvrG rV s r$ streamer"Lexer.get_tokens..streamer s& 66t<ad
=s "%)rR strr@ r pip._vendorrY ImportError
_encoding_map
startswithlendecodedetectrE rZ r= stripr< r?
expandtabsr> endswithr rC ) rG rV
unfilteredr` rY edecodedbomr@ encrc streams `` r$
get_tokensLexer.get_tokens s $$$}}'&t,a )+T3 %2MCs++"&s3xy/"8"89"M &3
?!..et5C "kk#''**=*H*3 5G {{4==1??8,, H
/Dx((CMN+ ||FD)||D$' ==::F
U # T% 'L MRSTTs
H, ,
I6 IIc [ e)a#
This method should process the text and return an iterable of
``(index, tokentype, value)`` tuples where ``index`` is the starting
position of the token within the input text.
It must be overridden by subclasses. It is recommended to
implement it as a generator to maximize effectiveness.
)NotImplementedError)rG rV s r$ r_ Lexer.get_tokens_unprocessed s
"!r& )r@ r> rC rD r= r< r? )F)r3 r4 r5 r6 r7 r/ aliases filenamesalias_filenames mimetypespriorityurlrI rO rF r+ rv r_ r8 r" r& r$ r r 1 sY 1h D G
I O I H C %<D% ">@ "r& r ) metaclassc * \ rS rSrSr\4S jrS rSrg)r i
a
This lexer takes two lexer as arguments. A root lexer and
a language lexer. First everything is scanned using the language
lexer, afterwards all ``Other`` tokens are lexed using the root
lexer.
The lexers from the ``template`` lexer package use this base lexer.
c r U" S0 UD6U l U" S0 UD6U l X0l [ R " U 40 UD6 g Nr" )
root_lexerlanguage_lexerneedler rI )rG _root_lexer_language_lexer_needlerD s r$ rI DelegatingLexer.__init__ s7 %00 - 8 8
t'w'r& c Sn/ n/ nU R R U5 HR u pVnX`R L a+ U( a UR [ U5 U45 / nX'-
nM? UR XVU45 MT U( a UR [ U5 U45 [ UU R R U5 5 $ )N )r r_ r rS rj
do_insertionsr )rG rV buffered
insertions
lng_bufferira rb s r$ r_ &DelegatingLexer.get_tokens_unprocessed s
**AA$GGA!KK %%s8}j&AB!#J
!!1), H s8}j 9 : Z !__ C CH MO Or& )r r r N) r3 r4 r5 r6 r7 r rI r_ r8 r" r& r$ r r
s >C ( Or& r c \ rS rSrSrSrg)r i4 zA
Indicates that a state should include rules from another state.
r" Nr3 r4 r5 r6 r7 r8 r" r& r$ r r 4 s r& r c \ rS rSrSrS rSrg)_inheriti; z;
Indicates the a state should inherit from its superclass.
c g)Nr r" rN s r$ rO _inherit.__repr__? s r& r" N)r3 r4 r5 r6 r7 rO r8 r" r& r$ r r ; s r& r c $ \ rS rSrSrS rS rSrg)combinediE z2
Indicates a state combined from multiple states.
c , [ R X5 $ r^ )tupler- )clsargss r$ r- combined.__new__J s }}S''r& c g r^ r" )rG r s r$ rI combined.__init__M s r& r" N)r3 r4 r5 r6 r7 r- rI r8 r" r& r$ r r E s (
r& r c H \ rS rSrSrS rS S jrS S jrS S jrS r S r
S
r g) _PseudoMatchiR z2
A pseudo match object constructed from a string.
c X l Xl g r^ )_text_start)rG startrV s r$ rI _PseudoMatch.__init__W s
r& Nc U R $ r^ )r rG args r$ r _PseudoMatch.start[ s {{r& c F U R [ U R 5 - $ r^ )r rj r r s r$ end_PseudoMatch.end^ s {{S_,,r& c > U( a [ S5 eU R $ )Nz
No such group)
IndexErrorr r s r$ group_PseudoMatch.groupa s _- -zzr& c U R 4$ r^ )r rN s r$ groups_PseudoMatch.groupsf s
} r& c 0 $ r^ r" rN s r$ groupdict_PseudoMatch.groupdicti s r& )r r r^ ) r3 r4 r5 r6 r7 rI r r r r r r8 r" r& r$ r r R s% -
r& r c ^ SU 4S jjnU$ )zD
Callback that yields multiple actions for each group in the match.
c
3 ># [ T5 H u p4Uc M
[ U5 [ L a7 UR US- 5 nU( a UR US- 5 XE4v MQ MS UR US- 5 nUc Ml U( a UR US- 5 Ul U" U [
UR US- 5 U5 U5 H nU( d M Uv M M U( a UR 5 Ul g g 7f)N ) enumerater, r
r r posr r )lexermatchctxr actiondataitemr s r$ callbackbygroups..callbackq s "4 IA~f + {{1q5) ++a!e,f:: {{1q5)#"'++a!e"4 &u'3EKKA4F'Ms!T 4"&J!T ) iikCG s A4C7;AC7
*C7r^ r" )r r s ` r$ r r m s "& Or& c \ rS rSrSrSrg)_Thisi zL
Special singleton used for indicating the caller class.
Used by ``using``.
r" Nr r" r& r$ r r s r& r c ^ ^^ 0 mST; a9 TR S5 n[ U[ [ 45 ( a UTS' OSU4TS' T [ L a SUU4S jjnU$ SU UU4S jjnU$ )a
Callback that processes the match with a different lexer.
The keyword arguments are forwarded to the lexer, except `state` which
is handled separately.
`state` specifies the state that the new lexer will start in, and can
be an enumerable such as ('root', 'inline', 'string') or a simple
string which is assumed to be on top of the root state.
Note: For that to work, `_other` must not be an `ExtendedRegexLexer`.
statestackrootc 3 < ># T ( a. T R U R 5 U R " S0 T D6nOU nUR 5 nUR " UR 5 40 TD6 H u pVnXT- Xg4v M U( a UR
5 Ul g g 7fr )updaterD rM r r_ r r r )
r r r lxsr ra rb gt_kwargskwargss
r$ r using..callback s
emm,__.v.
A 44U[[]PiPaeQk! Q ))+ s BB c 3 ># T
R U R 5 T" S0 T
D6nUR 5 nUR " UR 5 40 T D6 H u pVnXT- Xg4v M U( a UR 5 Ul g g 7fr )r rD r r_ r r r ) r r r r r r ra rb _otherr r s r$ r r st MM%-- (!&!B
A 44U[[]PiPaeQk! Q ))+ s BBr^ )poprR listr r )r r r r r s `` @r$ r r sr I& JJw a$ ' '!"Ig "(!Ig
~
&
&2 O & & Or& c \ rS rSrSrS rSrg)r i z
Indicates a state or state action (e.g. #pop) to apply.
For example default('#pop') is equivalent to ('', Token, '#pop')
Note that state tuples may be used as well.
.. versionadded:: 2.0
c Xl g r^ r )rG r s r$ rI default.__init__ s
r& r N)r3 r4 r5 r6 r7 rI r8 r" r& r$ r r s r& r c ( \ rS rSrSrSS jrS rSrg)r i z
Indicates a list of literal words that is transformed into an optimized
regex that matches any of the words.
.. versionadded:: 2.0
c ( Xl X l X0l g r^ )r prefixsuffix)rG r r r s r$ rI words.__init__ s
r& c T [ U R U R U R S9$ )Nr r )r r r r rN s r$ rE words.get s DKK LLr& )r r r N)r r )r3 r4 r5 r6 r7 rI rE r8 r" r& r$ r r s
Mr& r c F \ rS rSrSrS rS rS rS rS S jr S r
S
r S r g)
RegexLexerMetai zk
Metaclass for RegexLexer, creates the self._tokens attribute from
self.tokens on the first instantiation.
c [ U[ 5 ( a UR 5 n[ R " X5 R
$ )zBPreprocess the regular expression component of a token definition.)rR r rE recompiler )r regexrflagsr s r$ _process_regex RegexLexerMeta._process_regex s/ eV $ $IIKEzz%(...r& c ` [ U5 [ L d [ U5 ( d SU< 35 eU$ )z5Preprocess the token component of a token definition.z0token type must be simple type or callable, not )r, r
callable)r tokens r$ _process_token RegexLexerMeta._process_token s0 E{j(HUOO LDI K L; r& c [ U[ 5 ( a9 US:X a gX; a U4$ US:X a U$ USS S:X a [ USS 5 * $ SU- 5 e[ U[ 5 ( af SU R - nU =R S -
sl / nU H3 nXa:w d
S
U- 5 eUR U R
UX65 5 M5 XSU' U4$ [ U[ 5 ( a" U H nXb; a M
US ; a M S U- 5 e U$ S
U- 5 e)z=Preprocess the state transition action of a token definition.#pop#pushN z#pop:zunknown new state %rz_tmp_%dr zcircular state ref %r)r r zunknown new state zunknown new state def %r)rR re intr _tmpnameextend_process_stater )r new_state unprocessed processed tmp_stateitokensistates r$ _process_new_state!RegexLexerMeta._process_new_state s> i % %F")!|#g% 2A ')IabM***@ 4y @@u
8
,
,!CLL0I LLA LG# *L,Cf,LL*s 1 1+2; E F $ $+i <
5
)
)# - "332(612 4 $ @4y@ @5r& c [ U5 [ L d
SU- 5 eUS S:w d
SU- 5 eX2; a X# $ / =oBU' U R nX GHP n[ U[ 5 ( a; Xc:w d
SU- 5 eUR U R
X[ U5 5 5 MT [ U[ 5 ( a Mk [ U[ 5 ( aP U R UR X5 nUR [ R " S5 R SU45 M [ U5 [ L d
SU- 5 e U R! US XS5 nU R' US
5 n
[) U5 S:X a SnOU R US X5 nUR XU45 GMS U$ ! [" a$ n [% S US < S
U< S U < S U < 35 U eSn A ff = f)z%Preprocess a single state definition.zwrong state name %rr #zinvalid state name %rzcircular state reference %rr Nzwrong rule def %rzuncompilable regex z
in state z of z: r )r, re flagsrR r r r r r r r rS r r r r r Exception
ValueErrorr rj ) r r r r tokensr tdefr rexerrr s r$ r RegexLexerMeta._process_state s E{c!@#85#@@!Qx3? 7% ?? # #$&&5! &D$((}K&Ce&KK}
c 0 014T < =$)) $(( 2 24::{ V
rzz"~ 3 3T9 EF:& B(;d(B B&
F((a&@
&&tAw/E4yA~ 2 2473> K
MM3y1 2C 'D
F "&q'5#s"< =BEF
Fs <F&&
G0 GGNc 0 =o0R U' U=( d U R U n[ U5 H nU R X#U5 M U$ )z-Preprocess a dictionary of token definitions.) _all_tokensr
r r )r r/ tokendefsr r s r$ process_tokendef RegexLexerMeta.process_tokendef? sJ ,.. OOD) 1D!1 )_E yU ; %r& c 0 n0 nU R H nUR R S0 5 nUR 5 Hr u pVUR U5 nUc XaU' UR [
5 nXU' M9 UR US5 nUc MP XgXS- & UR [
5 n X- X%' Mt M U$ ! [ a M f = f! [ a M f = f)a
Merge tokens from superclasses in MRO order, returning a single tokendef
dictionary.
Any state that is not defined by a subclass will be inherited
automatically. States that *are* defined by subclasses will, by
default, override that state in the superclass. If a subclass wishes to
inherit definitions from a superclass, it can use the special value
"inherit", which will cause the superclass' state definition to be
included at that point in the state.
r
Nr )__mro____dict__rE itemsindexr r r )
r r
inheritablectoksr r curitems inherit_ndx new_inh_ndxs
r$
get_tokendefs RegexLexerMeta.get_tokendefsG s A::>>(B/D $
!::e,#
%*5M!&+kk'&: *5& )ooeT : & 7<]3C #(++g"6K *5)BK&9 !- B
) & ! ! " s$ B<C
<
C
C
CCc SU R ; aV 0 U l SU l [ U S5 ( a U R ( a O%U R SU R
5 5 U l [ R " U /UQ70 UD6$ )z:Instantiate cls after preprocessing its token definitions._tokensr token_variantsr )
r r r hasattrr# r r r" r, __call__)r r kwdss r$ r% RegexLexerMeta.__call__x sk CLL ( CO CLs ,--#2D2D ! 2 22s7H7H7J K }}S040400r& r" r^ )
r3 r4 r5 r6 r7 r r r r r r r% r8 r" r& r$ r r s.
/ !AF*X/b 1r& r c > \ rS rSrSr\R r0 rSS jr Sr
g)r i z
Base for simple stateful regular expression-based lexers.
Simplifies the lexing process so that you need only
provide a list of states and regular expressions.
c # l # SnU R n[ U5 nXES n U GH= u pxn U" X5 n
U
( d M Ub7 [ U5 [ L a X8U
R 5 4v OU" X
5 Sh vN U
R 5 nU b [
U [ 5 ( a` U HY n U S:X a# [ U5 S: a UR 5 M* M, U S:X a UR US 5 MH UR U 5 M[ O][
U [ 5 ( a# [ U 5 [ U5 : a USS2 O*XYS2 O%U S:X a UR US 5 O
SU - 5 eXES n O8 X S:X a S /nUS nU[ S4v US-
nGMi U[ X 4v US-
nGM} GN.! [ a gf = f7f)
zf
Split ``text`` into (tokentype, text) pairs.
``stack`` is the initial stack (default: ``['root']``)
r r r Nr r wrong state def: %rr[ r )r" r r, r
r r rR r rj r rS r absr r r ) rG rV r r r
statestack statetokensrexmatchr r mr s r$ r_ !RegexLexer.get_tokens_unprocessed s LL %[
2/ /:+) T'1 ) <:5"%qwwy"8 8'-d 6 6%%'C ,%i77)2#(F?'*:':(2(8 (;%*g%5$.$5$5jn$E$.$5$5e$< *3 ( 3 7 7 #9~Z @$.qrN$.z$: &' 1 & - -jn = K*?)*K K5&/2&? C 0;J yD(&,X
&/&7 !:t 33q udi//1HC_ 7P " sG 8F45F43F!4C4F4) F$ F4 F$ F4$
F1.F40F11F4r" N)r ) r3 r4 r5 r6 r7 r MULTILINEr r
r_ r8 r" r& r$ r r s
LLE0 F;r& r c ( \ rS rSrSrSS jrS rSrg)r i z1
A helper object that holds lexer position data.
Nc p Xl X l U=( d [ U5 U l U=( d S/U l g )Nr )rV r rj r r )rG rV r r r s r$ rI LexerContext.__init__ s* ##d)&vh
r& c \ SU R < SU R < SU R < S3$ )Nz
LexerContext(z, ))rV r r rN s r$ rO LexerContext.__repr__ s IItxx- -r& )r r r rV NN)r3 r4 r5 r6 r7 rI rO r8 r" r& r$ r r s ' -r& r c " \ rS rSrSrSS jrSrg)r i z=
A RegexLexer that uses a context object to store its state.
Nc # # U R nU( d [ US5 nUS nO UnX4R S nUR n U GH u pgnU" XR UR
5 n U ( d M- Ubo [
U5 [ L a4 UR XyR 5 4v U R 5 Ul O)U" X U5 Sh vN U( d X4R S nUGbH [ U[ 5 ( a U H n
U
S:X a7 [ UR 5 S: a UR R 5 M> M@ U
S:X a* UR R UR S 5 Mp UR R U
5 M O[ U[ 5 ( aB [ U5 [ UR 5 : a UR SS2 OIUR US2 O9US:X a) UR R UR S 5 O
SU- 5 eX4R S n O UR UR
: a gXR S :X a: S/Ul US nUR [ S 4v U=R S-
sl GMZ UR [" XR 4v U=R S-
sl GM GN! [$ a gf = f7f)
zg
Split ``text`` into (tokentype, text) pairs.
If ``context`` is given, use this lexer context instead.
r r r r Nr r r* r[ )r" r r rV r r r, r
r rR r rj r rS r r+ r r r ) rG rV contextr r r- r. r r r/ r s r$ r_ )ExtendedRegexLexer.get_tokens_unprocessed se
LL tQ'C#F+KC#IIbM2K88D/:+) T77CGG41 ) <:5"%''6779"< <&'eegCG'-ds'; ; ;#,.7 "
.F ,%i77)2#(F?'*399~'9(+
(:%*g%5$'II$4$4SYYr]$C$'II$4$4U$; *3 ( 3 7 7 "9~SYY ?$'IIabM$'IIij$9 &' 1 II , ,SYYr] ; K*?)*K K5&/ "
&> G 0;J
ww#'') GG},%+H &/&7 !ggtT 111 ''5$ww-77GGqLGc E?EE/EE/
EE/EE/ E,)E/+E,,E/c \ rS rSrSrS rSrg)ProfilingRegexLexerMetai z>Metaclass for ProfilingRegexLexer, collects regex timing info.c ^ ^^^ [ U[ 5 ( a* [ UR UR UR S9mOUm[
R " TU5 m[ R 4U UUU4S jjnU$ )Nr c > TR S R T
T 4SS/5 n[ R " 5 nTR XU5 n[ R " 5 nUS== S-
ss' US== Xd-
-
ss' U$ )Nr r r! r )
_prof_data
setdefaulttimer ) rV r endposinfot0rest1r compiledr r s r$
match_func:ProfilingRegexLexerMeta._process_regex..match_func sn >>"%00% 3xHDB..F3CB GqLG Grw GJr& ) rR r r r r r r sysmaxsize)r r r r rW rV r s ` ` @@r$ r &ProfilingRegexLexerMeta._process_regex s] eU # #EKK #(<<1C C::c6*), r& r" N)r3 r4 r5 r6 r7 r r8 r" r& r$ rK rK s
Hr& rK c * \ rS rSrSr/ rSrSS jrSrg)ProfilingRegexLexeri zFDrop-in replacement for RegexLexer that does profiling of its regexes. c # H ^ # T R R R 0 5 [ R T X5 S h vN T R R R 5 n[
S UR 5 5 U 4S jSS9n[ S U 5 5 n[ 5 [ ST R R [ U5 U4- 5 [ S5 [ SS - 5 [ S
5 U H n[ S U- 5 M [ S5 g N7f) Nc 3 # U HG u u pu p4U[ U5 R S 5 R SS5 SS USU- SU- U- 4v MI g7f)zu'z\\\NA i )reprrm rZ ).0r rnra s r$ =ProfilingRegexLexer.get_tokens_unprocessed.. s\ @/>+FQFQ 47==/77EcrJ4!8TAX\3/>s AAc " > U TR $ r^ )_prof_sort_index)r# rG s r$ r% . s Ad&;&;$r~ sH
= ; Q Q* * 3 *
**W
,
. 1 1Y"i Y"x Oe ON c *
u
64
w/d
MF
M e1Y e1P^. ^B
-
- E EP=@n ,*0G r&