3 hm|@s.ddlZddlmZddlZddlZddlmZddl m Z m Z ddl m Z mZddd d d d d dddddg Zeddddddddddg ddddddgdddd d!d"d#d$d%d&g ddd d!d%d&gd'd(d)d*d+d,d-d.d/d0g d'd)d*d+d/d0gd1d2d3d4d5d6d7d8d9d:g d1d3d4d5d9d:gd;dd?d@dAdBdCdDg d;d=d>d?dCdDgdEdFdGdHdIdJdKdLdMdNg dEdGdHdIdMdNgdO ZdPdQdQdQdRdSdTdSdTdRdSdSdU ZejZejdVdWejDeejZGdXdYdYeZdzd[dZd{d`dZd|dbd Zd}dcd ZdddeZd~dgd Z ddhd Z!ddld Z"ddmdZ#dndZ$dodZ%ddudZ&dvdwZ'ddydZ(dS)N)cycle)husl) desaturateget_color_cycle)xkcd_rgbcrayons color_palette hls_palette husl_palette mpl_palette dark_palette light_palettediverging_palette blend_palette xkcd_palettecrayon_palettecubehelix_paletteset_color_codesz#4C72B0z#DD8452z#55A868z#C44E52z#8172B3z#937860z#DA8BC3z#8C8C8Cz#CCB974z#64B5CDz#4878D0z#EE854Az#6ACC64z#D65F5Fz#956CB4z#8C613Cz#DC7EC0z#797979z#D5BB67z#82C6E2z#A1C9F4z#FFB482z#8DE5A1z#FF9F9Bz#D0BBFFz#DEBB9Bz#FAB0E4z#CFCFCFz#FFFEA3z#B9F2F0z#023EFFz#FF7C00z#1AC938z#E8000Bz#8B2BE2z#9F4800z#F14CC1z#A3A3A3z#FFC400z#00D7FFz#001C7Fz#B1400Dz#12711Cz#8C0800z#591E71z#592F0Dz#A23582z#3C3C3Cz#B8850Az#006374z#0173B2z#DE8F05z#029E73z#D55E00z#CC78BCz#CA9161z#FBAFE4z#949494z#ECE133z#56B4E9) deepZdeep6ZmutedZmuted6ZpastelZpastel6ZbrightZbright6darkZdark6Z colorblindZ colorblind6   ) Ztab10Ztab20Ztab20bZtab20cZSet1ZSet2ZSet3ZAccentZPairedZPastel1ZPastel2ZDark2cCsi|]\}}t||qS)len).0kvrr3/tmp/pip-build-riy7u7_k/seaborn/seaborn/palettes.py 8sr"c@s0eZdZdZddZddZddZdd Zd S) _ColorPalettez?Set the color palette in a with statement, otherwise be a list.cCs ddlm}t|_|||S)zOpen the context.r) set_palette)rcmodr$r _orig_palette)selfr$rrr! __enter__>s z_ColorPalette.__enter__cGsddlm}||jdS)zClose the context.r)r$N)r%r$r&)r'argsr$rrr!__exit__Es z_ColorPalette.__exit__cCsdd|D}t|S)zLsz(_ColorPalette.as_hex..)r#)r'hexrrr!as_hexJsz_ColorPalette.as_hexc Csnd}t|}d||d|d}x>t|jD].\}}|d||d|d|d|d 7}q0W|d 7}|S) z6Rich display of the color palette in an HTML frontend.7z z z)r enumerater0)r'snhtmlicrrr! _repr_html_Os(z_ColorPalette._repr_html_N)__name__ __module__ __qualname____doc__r(r*r0r8rrrr!r#<s r#Fc sd|dkr"t}|dkrt|}nt|tsD|}|dkr@t|}n|dkrXtj|d}|tkrlt|}nr|dkrt||d}nZ|dkrt||d}nB|j dkrt dn*|j drt |\}}t |f||d |i}n|j d r,|jd \}}|jd }|r|dd}t||||d}n|j drt|jd \}}|jd }|rb|dd}t||||d}nj|j dr|jd \}} | jd} t| ||d}n6yt|||d}Wn"t k rt d|YnXdk rfdd|D}|s`t|fddt|D}yttjjj|}t|}Wn$t k r^t d|YnX|S)aReturn a list of colors or continuous colormap defining a palette. Possible ``palette`` values include: - Name of a seaborn palette (deep, muted, bright, pastel, dark, colorblind) - Name of matplotlib colormap - 'husl' or 'hls' - 'ch:' - 'light:', 'dark:', 'blend:,', - A sequence of colors in any format matplotlib accepts Calling this function with ``palette=None`` will return the current matplotlib color cycle. This function can also be used in a ``with`` statement to temporarily set the color cycle for a plot or set of plots. See the :ref:`tutorial ` for more information. Parameters ---------- palette : None, string, or sequence, optional Name of palette or None to return current palette. If a sequence, input colors are used but possibly cycled and desaturated. n_colors : int, optional Number of colors in the palette. If ``None``, the default will depend on how ``palette`` is specified. Named palettes default to 6 colors, but grabbing the current palette or passing in a list of colors will not change the number of colors unless this is specified. Asking for more colors than exist in the palette will cause it to cycle. Ignored when ``as_cmap`` is True. desat : float, optional Proportion to desaturate each color by. as_cmap : bool If True, return a :class:`matplotlib.colors.Colormap`. Returns ------- list of RGB tuples or :class:`matplotlib.colors.Colormap` See Also -------- set_palette : Set the default color cycle for all plots. set_color_codes : Reassign color codes like ``"b"``, ``"g"``, etc. to colors from one of the seaborn palettes. Examples -------- .. include:: ../docstrings/color_palette.rst Nhls)as_cmaprZjetzNo.zch:r?zlight::_r)reverser?zdark:zblend:,z%s is not a valid palette namecsg|]}t|qSr)r)rr7)desatrr!r.sz!color_palette..csg|] }tqSr)next)r_) pal_cyclerr!r.sz!Could not generate a palette for rI)rr isinstancestrQUAL_PALETTE_SIZESgetSEABORN_PALETTESr r lower ValueError startswith_parse_cubehelix_argsrsplitendswithrr rr rrangemapr+r,colorConverterto_rgbr#) paletten_colorsrEr?r)kwargsrGcolorrCr,r)rErHr!r ]sh4                   r={Gz?333333??csv|rd}tjddt|ddd}||7}|d;}||jt8}fdd|D}|rjtjj|dSt|SdS) aGet a set of evenly spaced colors in HLS hue space. h, l, and s should be between 0 and 1 Parameters ---------- n_colors : int number of colors in the palette h : float first hue l : float lightness s : float saturation Returns ------- list of RGB tuples or :class:`matplotlib.colors.Colormap` See Also -------- husl_palette : Make a palette using evenly spaced hues in the HUSL system. Examples -------- Create a palette of 10 colors with the default parameters: .. plot:: :context: close-figs >>> import seaborn as sns; sns.set_theme() >>> sns.palplot(sns.hls_palette(10)) Create a palette of 10 colors that begins at a different hue value: .. plot:: :context: close-figs >>> sns.palplot(sns.hls_palette(10, h=.5)) Create a palette of 10 colors that are darker than the default: .. plot:: :context: close-figs >>> sns.palplot(sns.hls_palette(10, l=.4)) Create a palette of 10 colors that are less saturated than the default: .. plot:: :context: close-figs >>> sns.palplot(sns.hls_palette(10, s=.4)) rrNcsg|]}tj|qSr)colorsys hls_to_rgb)rh_i)lr3rr!r.%szhls_palette..r>)nplinspaceintZastyper+r,ListedColormapr#)rZhrdr3r?huesrYr)rdr3r!r s:?cs|rd}tjddt|ddd }||7}|d;}|d9}d9d9fdd|D}|rttjj|d St|SdS) aGet a set of evenly spaced colors in HUSL hue space. h, s, and l should be between 0 and 1 Parameters ---------- n_colors : int number of colors in the palette h : float first hue s : float saturation l : float lightness Returns ------- list of RGB tuples or :class:`matplotlib.colors.Colormap` See Also -------- hls_palette : Make a palette using evently spaced circular hues in the HSL system. Examples -------- Create a palette of 10 colors with the default parameters: .. plot:: :context: close-figs >>> import seaborn as sns; sns.set_theme() >>> sns.palplot(sns.husl_palette(10)) Create a palette of 10 colors that begins at a different hue value: .. plot:: :context: close-figs >>> sns.palplot(sns.husl_palette(10, h=.5)) Create a palette of 10 colors that are darker than the default: .. plot:: :context: close-figs >>> sns.palplot(sns.husl_palette(10, l=.4)) Create a palette of 10 colors that are less saturated than the default: .. plot:: :context: close-figs >>> sns.palplot(sns.husl_palette(10, s=.4)) r`rrNigccsg|]}t|fddqS)r)input) _color_to_rgb)rrc)rdr3rr!r.osz husl_palette..Zhslre)rfrgrhr+r,rir#)rZrjr3rdr?rkrYr)rdr3r!r ,s;c Cs|jdrh|dd }|jdr2d}|dd }nd}t|ddg}|rX|ddd}t||dd }n tjj|}|tkrtjd dt|d|}ntjd dt |ddd}t t t ||dddd f}|r|St |SdS)aReturn discrete colors from a matplotlib palette. Note that this handles the qualitative colorbrewer palettes properly, although if you ask for more colors than a particular qualitative palette can provide you will get fewer than you are expecting. In contrast, asking for qualitative color brewer palettes using :func:`color_palette` will return the expected number of colors, but they will cycle. If you are using the IPython notebook, you can also use the function :func:`choose_colorbrewer_palette` to interactively select palettes. Parameters ---------- name : string Name of the palette. This should be a named matplotlib colormap. n_colors : int Number of discrete colors in the palette. Returns ------- list of RGB tuples or :class:`matplotlib.colors.Colormap` Examples -------- Create a qualitative colorbrewer palette with 8 colors: .. plot:: :context: close-figs >>> import seaborn as sns; sns.set_theme() >>> sns.palplot(sns.mpl_palette("Set2", 8)) Create a sequential colorbrewer palette: .. plot:: :context: close-figs >>> sns.palplot(sns.mpl_palette("Blues")) Create a diverging palette: .. plot:: :context: close-figs >>> sns.palplot(sns.mpl_palette("seismic", 8)) Create a "dark" sequential palette: .. plot:: :context: close-figs >>> sns.palplot(sns.mpl_palette("GnBu_d")) Z_dNrBrATFz#333333r)r?rrIrIrere)rTr rr+cmZget_cmap MPL_QUAL_PALSrfrgrhlistrVtupler#) namerZr?Zsub_namerCpalcmapZbinsrYrrr!r vs$9    "cCsV|dkrtj|}n6|dkr:tj|}ttj|dd}n|dkrJt|}tj j |S)z+Add some more flexibility to color choices.r>rrrZxkcd) rarbrZ husl_to_rgbrtrfZcliprr+r,rX)r\rnrrr!ros  ror-c CsZt||}tj|\}}}d|d} } t|| | fdd} |rF|| gn| |g} t| ||S)aMake a sequential palette that blends from dark to ``color``. This kind of palette is good for data that range between relatively uninteresting low values and interesting high values. The ``color`` parameter can be specified in a number of ways, including all options for defining a color in matplotlib and several additional color spaces that are handled by seaborn. You can also use the database of named colors from the XKCD color survey. If you are using the IPython notebook, you can also choose this palette interactively with the :func:`choose_dark_palette` function. Parameters ---------- color : base color for high values hex, rgb-tuple, or html color name n_colors : int, optional number of colors in the palette reverse : bool, optional if True, reverse the direction of the blend as_cmap : bool, optional If True, return a :class:`matplotlib.colors.Colormap`. input : {'rgb', 'hls', 'husl', xkcd'} Color space to interpret the input color. The first three options apply to tuple inputs and the latter applies to string inputs. Returns ------- list of RGB tuples or :class:`matplotlib.colors.Colormap` See Also -------- light_palette : Create a sequential palette with bright low values. diverging_palette : Create a diverging palette with two colors. Examples -------- Generate a palette from an HTML color: .. plot:: :context: close-figs >>> import seaborn as sns; sns.set_theme() >>> sns.palplot(sns.dark_palette("purple")) Generate a palette that decreases in lightness: .. plot:: :context: close-figs >>> sns.palplot(sns.dark_palette("seagreen", reverse=True)) Generate a palette from an HUSL-space seed: .. plot:: :context: close-figs >>> sns.palplot(sns.dark_palette((260, 75, 60), input="husl")) Generate a colormap object: .. plot:: :context: close-figs >>> from numpy import arange >>> x = arange(25).reshape(5, 5) >>> cmap = sns.dark_palette("#2ecc71", as_cmap=True) >>> ax = sns.heatmap(x, cmap=cmap) g333333?r)rn)ror rgb_to_huslr) r\rZrCr?rnr-rjr3rdgray_sgray_lgrayr,rrr!r s I c CsZt||}tj|\}}}d|d} } t|| | fdd} |rF|| gn| |g} t| ||S)aMake a sequential palette that blends from light to ``color``. This kind of palette is good for data that range between relatively uninteresting low values and interesting high values. The ``color`` parameter can be specified in a number of ways, including all options for defining a color in matplotlib and several additional color spaces that are handled by seaborn. You can also use the database of named colors from the XKCD color survey. If you are using the IPython notebook, you can also choose this palette interactively with the :func:`choose_light_palette` function. Parameters ---------- color : base color for high values hex code, html color name, or tuple in ``input`` space. n_colors : int, optional number of colors in the palette reverse : bool, optional if True, reverse the direction of the blend as_cmap : bool, optional If True, return a :class:`matplotlib.colors.Colormap`. input : {'rgb', 'hls', 'husl', xkcd'} Color space to interpret the input color. The first three options apply to tuple inputs and the latter applies to string inputs. Returns ------- list of RGB tuples or :class:`matplotlib.colors.Colormap` See Also -------- dark_palette : Create a sequential palette with dark low values. diverging_palette : Create a diverging palette with two colors. Examples -------- Generate a palette from an HTML color: .. plot:: :context: close-figs >>> import seaborn as sns; sns.set_theme() >>> sns.palplot(sns.light_palette("purple")) Generate a palette that increases in lightness: .. plot:: :context: close-figs >>> sns.palplot(sns.light_palette("seagreen", reverse=True)) Generate a palette from an HUSL-space seed: .. plot:: :context: close-figs >>> sns.palplot(sns.light_palette((260, 75, 60), input="husl")) Generate a colormap object: .. plot:: :context: close-figs >>> from numpy import arange >>> x = arange(25).reshape(5, 5) >>> cmap = sns.light_palette("#2ecc71", as_cmap=True) >>> ax = sns.heatmap(x, cmap=cmap) g333333?_r)rn)rorryr) r\rZrCr?rnr-rjr3rdrzr{r|r,rrr!r's I K2lightcCstttd|}td|d} ||||f| ddd} ||||f| dd} td gd gd |} | |} ttj| | | g||d }|S)aMake a diverging palette between two HUSL colors. If you are using the IPython notebook, you can also choose this palette interactively with the :func:`choose_diverging_palette` function. Parameters ---------- h_neg, h_pos : float in [0, 359] Anchor hues for negative and positive extents of the map. s : float in [0, 100], optional Anchor saturation for both extents of the map. l : float in [0, 100], optional Anchor lightness for both extents of the map. sep : int, optional Size of the intermediate region. n : int, optional Number of colors in the palette (if not returning a cmap) center : {"light", "dark"}, optional Whether the center of the palette is light or dark as_cmap : bool, optional If True, return a :class:`matplotlib.colors.Colormap`. Returns ------- list of RGB tuples or :class:`matplotlib.colors.Colormap` See Also -------- dark_palette : Create a sequential palette with dark values. light_palette : Create a sequential palette with light values. Examples -------- Generate a blue-white-red palette: .. plot:: :context: close-figs >>> import seaborn as sns; sns.set_theme() >>> sns.palplot(sns.diverging_palette(240, 10, n=9)) Generate a brighter green-white-purple palette: .. plot:: :context: close-figs >>> sns.palplot(sns.diverging_palette(150, 275, s=80, l=55, n=9)) Generate a blue-black-red palette: .. plot:: :context: close-figs >>> sns.palplot(sns.diverging_palette(250, 15, s=75, l=40, ... n=9, center="dark")) Generate a colormap object: .. plot:: :context: close-figs >>> from numpy import arange >>> x = arange(25).reshape(5, 5) >>> cmap = sns.diverging_palette(220, 20, as_cmap=True) >>> ax = sns.heatmap(x, cmap=cmap) )rrrBTr)rCrn)rnffffff?/$?)rr)r?)rrr)rrr)dictr rrhrrfZ concatenate)Zh_negZh_posr3rdsepr4centerr?ZpalfuncZn_halfnegposZmidpointZmidrvrrr!rxsFcsbfdd|D}d}tjjj||}|s^|tjddt|ddddf}ttt |}|S)aMake a palette that blends between a list of colors. Parameters ---------- colors : sequence of colors in various formats interpreted by ``input`` hex code, html color name, or tuple in ``input`` space. n_colors : int, optional Number of colors in the palette. as_cmap : bool, optional If True, return a :class:`matplotlib.colors.Colormap`. Returns ------- list of RGB tuples or :class:`matplotlib.colors.Colormap` csg|]}t|qSr)ro)rr\)rnrr!r.sz!blend_palette..ZblendrrNrp) r+r,LinearSegmentedColormap from_listrfrgrhr#rVrt)r,rZr?rnrurvZ rgb_arrayr)rnr!rs&cCsdd|D}t|t|S)a^Make a palette with color names from the xkcd color survey. See xkcd for the full list of colors: https://xkcd.com/color/rgb/ This is just a simple wrapper around the ``seaborn.xkcd_rgb`` dictionary. Parameters ---------- colors : list of strings List of keys in the ``seaborn.xkcd_rgb`` dictionary. Returns ------- palette : seaborn color palette Returns the list of colors as RGB tuples in an object that behaves like other seaborn color palettes. See Also -------- crayon_palette : Make a palette with Crayola crayon colors. cSsg|] }t|qSr)r)rrurrr!r.sz xkcd_palette..)r r)r,rYrrr!rscCsdd|D}t|t|S)aMake a palette with color names from Crayola crayons. Colors are taken from here: https://en.wikipedia.org/wiki/List_of_Crayola_crayon_colors This is just a simple wrapper around the ``seaborn.crayons`` dictionary. Parameters ---------- colors : list of strings List of keys in the ``seaborn.crayons`` dictionary. Returns ------- palette : seaborn color palette Returns the list of colors as rgb tuples in an object that behaves like other seaborn color palettes. See Also -------- xkcd_palette : Make a palette with named colors from the XKCD color survey. cSsg|] }t|qSr)r)rrurrr!r.sz"crayon_palette..)r r)r,rYrrr!rs皙??皙?333333?333333?c sfdd} | dd| dd| ddd } tjjd | } tj||t|} | | d d d d fj} |r~| d d d} |rtj||d}|r|d d d}| |}tjj|d} | St| Sd S)a Make a sequential palette from the cubehelix system. This produces a colormap with linearly-decreasing (or increasing) brightness. That means that information will be preserved if printed to black and white or viewed by someone who is colorblind. "cubehelix" is also available as a matplotlib-based palette, but this function gives the user more control over the look of the palette and has a different set of defaults. In addition to using this function, it is also possible to generate a cubehelix palette generally in seaborn using a string-shorthand; see the example below. Parameters ---------- n_colors : int Number of colors in the palette. start : float, 0 <= start <= 3 The hue at the start of the helix. rot : float Rotations around the hue wheel over the range of the palette. gamma : float 0 <= gamma Gamma factor to emphasize darker (gamma < 1) or lighter (gamma > 1) colors. hue : float, 0 <= hue <= 1 Saturation of the colors. dark : float 0 <= dark <= 1 Intensity of the darkest color in the palette. light : float 0 <= light <= 1 Intensity of the lightest color in the palette. reverse : bool If True, the palette will go from dark to light. as_cmap : bool If True, return a :class:`matplotlib.colors.Colormap`. Returns ------- list of RGB tuples or :class:`matplotlib.colors.Colormap` See Also -------- choose_cubehelix_palette : Launch an interactive widget to select cubehelix palette parameters. dark_palette : Create a sequential palette with dark low values. light_palette : Create a sequential palette with bright low values. References ---------- Green, D. A. (2011). "A colour scheme for the display of astronomical intensity images". Bulletin of the Astromical Society of India, Vol. 39, p. 289-295. Examples -------- Generate the default palette: .. plot:: :context: close-figs >>> import seaborn as sns; sns.set_theme() >>> sns.palplot(sns.cubehelix_palette()) Rotate backwards from the same starting location: .. plot:: :context: close-figs >>> sns.palplot(sns.cubehelix_palette(rot=-.4)) Use a different starting point and shorter rotation: .. plot:: :context: close-figs >>> sns.palplot(sns.cubehelix_palette(start=2.8, rot=.1)) Reverse the direction of the lightness ramp: .. plot:: :context: close-figs >>> sns.palplot(sns.cubehelix_palette(reverse=True)) Generate a colormap object: .. plot:: :context: close-figs >>> from numpy import arange >>> x = arange(25).reshape(5, 5) >>> cmap = sns.cubehelix_palette(as_cmap=True) >>> ax = sns.heatmap(x, cmap=cmap) Use the full lightness range: .. plot:: :context: close-figs >>> cmap = sns.cubehelix_palette(dark=0, light=1, as_cmap=True) >>> ax = sns.heatmap(x, cmap=cmap) Use through the :func:`color_palette` interface: .. plot:: :context: close-figs >>> sns.palplot(sns.color_palette("ch:2,r=.2,l=.6")) csfdd}|S)NcsZ|}|d|d}dtjd|}||tj|tj|S)NrrBrp)rfpicossin)xZxgaphi)gammahuep0p1rotstartrr!r\sz.get_color_function..colorr)rrr\)rrrr)rrr!get_color_functions z-cubehelix_palette..get_color_functiongK?g9?gۅ:?gRQ?g)?g)ZredZgreenZblueZ cubehelixNrprr`Zseaborn_cubehelixgKÿgۅ:ҿgRQrere) r+r,rrfrgrhtolistrir#)rZrrrrrrrCr?rZcdictrwrrvZx_256Zpal_256r)rrrrr!rs"pcs|jdr|dd}|jdr2d}|dd}nd}|sFgd|ifS|jd }d d |D}d d |D}d d|D}tdddddddfdd|jD}|rd|d<||fS)z3Turn stringified cubehelix params into args/kwargs.zch:rpNrATrBFrCrDcSs"g|]}d|krt|jdqS)= )floatstrip)rrrrr!r.sz)_parse_cubehelix_args..cSsg|]}d|kr|jdqS)r)rS)rrrrr!r.scSs&i|]\}}t|jd|jdqS)r)rr)rrr rrr!r"sz)_parse_cubehelix_args..rrrrrr)r3rgrjrddcsi|]\}}|j||qSr)rM)rrr ) kwarg_maprr!r"srI)rQrTrSritems)ZargstrrCZall_argsr)r[r)rr!rRs&      rRrc Cs|dkrd d dddddg}nTt|ts4d}t|n<|tkr^|jdsN|d}t|dg}nd j|}t|x@td |D]2\}}tj j j |}|tj j j |<|tj j j |<q|Wd S)aHChange how matplotlib color shorthands are interpreted. Calling this will change how shorthand codes like "b" or "g" are interpreted by matplotlib in subsequent plots. Parameters ---------- palette : {deep, muted, pastel, dark, bright, colorblind} Named seaborn palette to use as the source of colors. See Also -------- set : Color codes can be set through the high-level seaborn style manager. set_palette : Color codes can also be set through the function that sets the matplotlib color cycle. Examples -------- Map matplotlib color codes to the default seaborn palette. .. plot:: :context: close-figs >>> import matplotlib.pyplot as plt >>> import seaborn as sns; sns.set_theme() >>> sns.set_color_codes() >>> _ = plt.plot([0, 1], color="r") Use a different seaborn palette. .. plot:: :context: close-figs >>> sns.set_color_codes("dark") >>> _ = plt.plot([0, 1], color="g") >>> _ = plt.plot([0, 2], color="m") reset???z0set_color_codes requires a named seaborn palette6皙?z#Cannot set colors with palette '{}'ZbgrmyckN)rrr)rrr)rrr)rrr)rrr)rrr)rrr)rrr) rJrK TypeErrorrNrTformatrPzipr+r,rWrXcache)rYr,errcoder\r-rrr!rs )     )NNNF)r=r]r^r_F)r=r]rlr_F)r=F)r=FFr-)r=FFr-)r~rrr=rF)r=Fr-) r=rrrrrrFF)r))ra itertoolsrZnumpyrfZ matplotlibr+Zexternalrutilsrrr,rr__all__rrNrrcopyrLupdaterrskeysZ QUAL_PALETTESr#r r r r ror rrrrrrrRrrrrr!sz                !  G J S Q Q O  #