intellecton/venv/lib/python3.12/site-packages/matplotlib/__pycache__/patheffects.cpython-312.pyc

<EFBFBD>
<00>Rj<>G<00><00>6
<00>dZd
dl
mZ
d
dlmZ
d
dlmZ
d
dlmZ	
d
dl
mZ
d
dlZ
Gd<08>d	<09>ZGd
<EFBFBD>de<02>ZGd<0C>d
e<0E>Zd<0E>ZGd<0F>de<0E>Zee<12><11>
ZGd<12>de<0E>Zee<14><11>
ZGd<14>de<0E>ZGd<16>de<0E>ZGd<18>de<0E>Zee<18><11>
Zy)z<>
Defines classes for path effects. The path effects are supported in `.Text`,
`.Line2D` and `.Patch`.

.. seealso::
   :ref:`patheffects_guide`
<EFBFBD>)
<01>RendererBase)
<01>colors)
<01>patches)
<01>
transforms)
<01>PathNc<00>,<00>eZ
dZd
Zdd<02>
Zd<03>Zd<04>Zdd<06>
Zy)	<09>AbstractPathEffectz<74>
    A base class for path effects.

    Subclasses should override the ``draw_path`` method to add effect
    functionality.
    c<00><00>|
|_y
)z<>
        Parameters
        ----------
        offset : (float, float), default: (0, 0)
            The (x, y) offset to apply to the path, measured in points.
        N)
<01>_offset)<02>self<6C>offsets  <20>Y/home/antigravity/intellecton/venv/lib/python3.12/site-packages/matplotlib/patheffects.py<70>__init__zAbstractPathEffect.__init__s<00><00><1E><04><0C>c<00><><00>t
j<00>jt|
j|j
<00><00>S)
z(Apply the offset to the given transform.)<06>mtransforms<6D>Affine2D<32>	translate<74>map<61>points_to_pixelsr)r<00>renderers  r<00>_offset_transformz$AbstractPathEffect._offset_transform"s4<00><00>/<2F>{<7B>#<23>#<23>%<25>/<2F>/<2F>
<10><18>*<2A>*<2A>D<EFBFBD>L<EFBFBD>L<EFBFBD>
9<>
;<3B>
	;rc<00>
<00>|j
<00>}|jd
d<02>}|r|
jdi|<03>
<01>

|j<00>D]6\}}t	|
d|zd<02>}t|<06>
st
d|<04><00><02>
<00>
||<05>

<00>8|
S)z<>
        Update the given GraphicsContext with the given dict of properties.

        The keys in the dictionary are used to identify the appropriate
        ``set_`` method on the *gc*.
        <20>dashesN<73>set_zUnknown property <20>)<07>copy<70>pop<6F>
set_dashes<EFBFBD>items<6D>getattr<74>callable<6C>AttributeError)r<00>gc<67>new_gc_dictr<00>
k<>
v<>
set_methods       r<00>
_update_gczAbstractPathEffect._update_gc's<><00><00>"<22>&<26>&<26>(<28><0B><1C><1F><1F><18>4<EFBFBD>0<><06><11><19>B<EFBFBD>M<EFBFBD>M<EFBFBD>#<23>F<EFBFBD>#<23><1F>%<25>%<25>'<27>	<1A>D<EFBFBD>A<EFBFBD>q<EFBFBD> <20><12>V<EFBFBD>a<EFBFBD>Z<EFBFBD><14>6<>J<EFBFBD><1B>J<EFBFBD>'<27>$<24>'8<><11><03>%<<3C>=<3D>=<3D><16>q<EFBFBD>M<EFBFBD>		<1A>
<12>	rNc<00>b<00>t
|
t<00>r|
j}
|
j||||<05>S)
z<>
        Derived should override this method. The arguments are the same
        as :meth:`matplotlib.backend_bases.RendererBase.draw_path`
        except the first argument is a renderer.
        )<04>
isinstance<EFBFBD>PathEffectRenderer<65>	_renderer<65>	draw_path)rrr$<00>tpath<74>affine<6E>rgbFaces      rr.zAbstractPathEffect.draw_path;s1<00><00><16>h<EFBFBD> 2<>3<><1F>)<29>)<29>H<EFBFBD><17>!<21>!<21>"<22>e<EFBFBD>V<EFBFBD>W<EFBFBD>=<3D>=r)
)<02>r2<00>
N)<08>__name__<5F>
__module__<EFBFBD>__qualname__<5F>__doc__rrr)r.rrrr	r	s<00><00><08><1E>;<3B>
<12>(	>rr	c<00>T<00><00>eZ
dZd
Zd<02>Zd<03>Zd<04>Zd
d<05>
Z<07>f
d<06>Z<08>f
d<07>Z	d
d<08>
Z
d	<09>Z<0B>x
ZS)r,aw

    Implements a Renderer which contains another renderer.

    This proxy then intercepts draw calls, calling the appropriate
    :class:`AbstractPathEffect` draw method.

    .. note::
        Not all methods have been overridden on this RendererBase subclass.
        It may be necessary to add further methods to extend the PathEffects
        capabilities further.
    c<00> <00>|
|_||_
y
)z<>
        Parameters
        ----------
        path_effects : iterable of :class:`AbstractPathEffect`
            The path effects which this renderer represents.
        renderer : `~matplotlib.backend_bases.RendererBase` subclass

        N)<02>
_path_effectsr-)r<00>path_effectsrs   rrzPathEffectRenderer.__init__Ts<00><00>*<2A><04><1A>!<21><04>rc<00>:<00>|j
|
|j<00>Sr3)<02>	__class__r-)rr;s  r<00>copy_with_path_effectz(PathEffectRenderer.copy_with_path_effect`s<00><00><13>~<7E>~<7E>l<EFBFBD>D<EFBFBD>N<EFBFBD>N<EFBFBD>;<3B>;rc<00>b<00>|
d
vrt
|j|
<01>Stj||
<01>S)N)<07>flipy<70>get_canvas_width_height<68>new_gcr<00>
_text2path<EFBFBD>height<68>width)r!r-<00>object<63>__getattribute__)r<00>names  rrGz#PathEffectRenderer.__getattribute__cs5<00><00><0F>
I
<01>
I
<01><1A>4<EFBFBD>><3E>><3E>4<EFBFBD>0<>0<><19>*<2A>*<2A>4<EFBFBD><14>6<>6rc<00>d<00>|jD]!}|j|j|
|||<04>
<00>#yr3)r:r.r-)rr$r/r0r1<00>path_effects      rr.zPathEffectRenderer.draw_pathjs4<00><00><1F>-<2D>-<2D>	+<2B>K<EFBFBD><17>!<21>!<21>$<24>.<2E>.<2E>"<22>e<EFBFBD>V<EFBFBD>")<29>

+<2B>	+rc<00><><00>
<01>t
|j<00>
d
k(rt<00>	|<00>|
|||g|<05>
<01>i|<06>
<01>
S|jD]-}|j	|g
<01>
}|j|
|||g|<05>
<01>i|<06>
<01>

<00>/y<00>N<>
)<05>lenr:<00>super<65>draw_markersr>)
rr$<00>marker_path<74>marker_trans<6E>path<74>args<67>kwargsrJrr=s
         <20>rrPzPathEffectRenderer.draw_markersos<><00><><00>
<0F>t<EFBFBD>!<21>!<21>"<22>a<EFBFBD>'<27><19>7<EFBFBD>'<27><02>K<EFBFBD><1C>t<EFBFBD>
9<>)-<2D>
9<>17<31>
9<>

9<> <20>-<2D>-<2D>	3<>K<EFBFBD><1B>1<>1<>;<3B>-<2D>@<40>H<EFBFBD>
"<22>H<EFBFBD>!<21>!<21>"<22>k<EFBFBD><<3C><14>

3<>#'<27>

3<>+1<>

3<>		3rc<00><><00>
<01>t
|j<00>
d
k(rt<00>|<00>|
||g|<04>
<01>i|<05>
<01>
S|jD],}|j	|g
<01>
}|j|
||g|<04>
<01>i|<05>
<01>

<00>.yrL)rNr:rO<00>draw_path_collectionr>)	rr$<00>master_transform<72>pathsrTrUrJrr=s	        <20>rrWz'PathEffectRenderer.draw_path_collection<6F>s<><00><><00>
<0F>t<EFBFBD>!<21>!<21>"<22>a<EFBFBD>'<27><19>7<EFBFBD>/<2F><02>4D<34>e<EFBFBD>
A
<01>15<31>
A
<01>9?<3F>
A
<01>

A
<01> <20>-<2D>-<2D>	;<3B>K<EFBFBD><1B>1<>1<>;<3B>-<2D>@<40>H<EFBFBD>
*<2A>H<EFBFBD>)<29>)<29>"<22>.><3E><05>

;<3B>+/<2F>

;<3B>39<33>

;<3B>		;rc<00>:<00>|jj|
|<02>Sr3)r-<00>
open_group)r<00>
s<>gids   rr[zPathEffectRenderer.open_group<75>s<00><00><13>~<7E>~<7E>(<28>(<28><11>C<EFBFBD>0<>0rc<00>8<00>|jj|
<01>
Sr3)r-<00>close_group)rr\s  rr_zPathEffectRenderer.close_group<75>s<00><00><13>~<7E>~<7E>)<29>)<29>!<21>,<2C>,rr3)
r4r5r6r7rr>rGr.rPrWr[r_<00>
__classcell__<5F>
r=s
@rr,r,Gs0<00><><00>
<08>
"<22>
<<3C>7<>+<2B>
3<>$;<3B>$
1<>
-rr,c
<00><00>eZ
dZd
Zy)<03>Normalz<6C>
    The "identity" PathEffect.

    The Normal PathEffect's sole purpose is to draw the original artist with
    no special path effect.
    N)r4r5r6r7rrrrcrc<00>s<00><00>rrcc
<00>
<00>Gd
<01>d|<00>}
d|j<00><00>|
_d|j<00><00>|
_
d|j<00>d|j<00>d|j<00>d<07>|
_|jj|
j_|
S)zO
    Create a PathEffect class combining *effect_class* and a normal draw.
    c<00><00><00>eZ
dZ<02>f
d
<01>Z<03>x
ZS)<02>)_subclass_with_normal.<locals>.withEffectc<00>T<00>
<01>t<00>|<00>|
||||<05>
|
j||||<05>
yr3)rOr.)rrr$r/r0r1r=s      <20>rr.z3_subclass_with_normal.<locals>.withEffect.draw_path<74>s,<00><><00><11>G<EFBFBD><1D>h<EFBFBD><02>E<EFBFBD>6<EFBFBD>7<EFBFBD>C<><14><1E><1E>r<EFBFBD>5<EFBFBD>&<26>'<27>:r)r4r5r6r.r`ras
@r<00>
withEffectrf<00>s
<00><><00>	;<3B>	;rrh<00>withz*
    A shortcut PathEffect for applying `.z<>` and then
    drawing the original Artist.

    With this class you can use ::

        artist.set_path_effects([patheffects.withzM()])

    as a shortcut for ::

        artist.set_path_effects([patheffects.z@(),
                                 patheffects.Normal()])
    )r4r6r7r.)<02>effect_classrhs  r<00>_subclass_with_normalrk<00>s<><00><00>
;<3B>\<5C>;<3B>
!<21><1C>!6<>!6<> 7<>8<>J<EFBFBD><17> $<24>\<5C>%:<3A>%:<3A>$;<3B><<3C>J<EFBFBD><1B>
*<2A>*6<>*?<3F>*?<3F>)@<40>A
2<>
3?<3F>2G<32>2G<32>1H<31>I
.<2E>/;<3B>.C<>.C<>-D<>E
<05><08>J<EFBFBD><16>$0<>#9<>#9<>#A<>#A<>J<EFBFBD><18><18> <20><15>rc<00>*<00><00>eZ
dZd
Zd<04>f
d<02>	Zd<03>Z<05>x
ZS)<05>Strokez0A line based PathEffect which re-draws a stroke.c<00>2<00>
<01>t<00>|<00>|
<01>

||_y
)z<>
        The path will be stroked with its gc updated with the given
        keyword arguments, i.e., the keyword arguments should be valid
        gc parameter values.
        N)rOr<00>_gc<67>rr
rUr=s   <20>rrzStroke.__init__<5F>s<00><><00>	<0E><07><18><16> <20><19><04>rc<00><><00>|
j
<00>}|j|<02>

|j||j<00>}|
j	||||j|
<01>
z|<05>
|j
<00>
y
)<02>Draw the path with updated gc.N)rB<00>copy_propertiesr)ror.r<00>restore)rrr$r/r0r1<00>gc0s       rr.zStroke.draw_path<74>sa<00><00><16>o<EFBFBD>o<EFBFBD><1F><03><0B><1B><1B>B<EFBFBD><1F><12>o<EFBFBD>o<EFBFBD>c<EFBFBD>4<EFBFBD>8<EFBFBD>8<EFBFBD>,<2C><03><10><1A><1A><0F><15><06><14>!7<>!7<><08>!A<>A<>7<EFBFBD>
	L
<01><0B><0B><0B>
r<00>
<01>rr<00>r4r5r6r7rr.r`ras
@rrmrm<00>s<00><><00>:<3A><1A>rrm)
rjc<00>0<00><00>eZ
dZd
Z			d<04>f
d<02>	Zd<03>Z<05>x
ZS)<05>SimplePatchShadowz#A simple shadow via a filled patch.c<00><><00>
<01>t<00>|<00>|
<01>

|<02>||_ntj|<02>
|_|<03>d}||_||_||_y
)aR
        Parameters
        ----------
        offset : (float, float), default: (2, -2)
            The (x, y) offset of the shadow in points.
        shadow_rgbFace : :mpltype:`color`
            The shadow color.
        alpha : float, default: 0.3
            The alpha transparency of the created shadow patch.
        rho : float, default: 0.3
            A scale factor to apply to the rgbFace color if *shadow_rgbFace*
            is not specified.
        **kwargs
            Extra keywords are stored and passed through to
            :meth:`AbstractPathEffect._update_gc`.

        N<>333333<33>?)rOr<00>_shadow_rgbFace<63>mcolors<72>to_rgba<62>_alpha<68>_rhoro)rr
<00>shadow_rgbFace<63>alpha<68>rhorUr=s      <20>rrzSimplePatchShadow.__init__<5F>sR<00><><00>(	<0E><07><18><16> <20><19>!<21>#1<>D<EFBFBD> <20>#*<2A>?<3F>?<3F>><3E>#B<>D<EFBFBD> <20><10>=<3D><17>E<EFBFBD><1B><04><0B><17><04>	<09><1A><04>rc<00><00>|
j
<00>}|j|<02>

|j<00>:|x
s
dd
d\}}}	||jz||jz|	|jzf}
n|j}
|j	d<04>

|j|j<00>

|jd<05>

|j||j<00>}|
j||||j|
<01>
z|
<EFBFBD>
|j<00>
y
)<06>
        Overrides the standard draw_path to add the shadow offset and
        necessary color changes for the shadow.
        N<><03><00>?r<>r<><00><00>noner)
rBrsr}r<><00>set_foreground<6E>	set_alphar<61><00>
set_linewidthr)ror.rrt<00>rrr$r/r0r1ru<00>
r<>
g<>
br<62>s           rr.zSimplePatchShadow.draw_path

s<><00><00>
<17>o<EFBFBD>o<EFBFBD><1F><03><0B><1B><1B>B<EFBFBD><1F><0F><1F><1F>'<27><1E>.<2E>,<2C><02><11>3<>G<EFBFBD>A<EFBFBD>q<EFBFBD>!<21><1F>$<24>)<29>)<29>m<EFBFBD>Q<EFBFBD><14><19><19>]<5D>A<EFBFBD><04>	<09>	<09>M<EFBFBD>J<>N<EFBFBD>!<21>1<>1<>N<EFBFBD><0B><1A><1A>6<EFBFBD>"<22><0B>
<0A>
<0A>d<EFBFBD>k<EFBFBD>k<EFBFBD>"<22><0B><19><19>!<21><1C><12>o<EFBFBD>o<EFBFBD>c<EFBFBD>4<EFBFBD>8<EFBFBD>8<EFBFBD>,<2C><03><10><1A><1A><0F><15><06><14>!7<>!7<><08>!A<>A<><1A>	<1C>	<0C><0B><0B>
r)<04><02><00><><EFBFBD><EFBFBD><EFBFBD>NNr|rxras
@rrzrz<00>s<00><><00>-<2D>%<25>,0<><18>"<1A>H
rrzc<00>.<00><00>eZ
dZd
Z		d<04>f
d<02>	Zd<03>Z<05>x
ZS)<05>SimpleLineShadowzA simple shadow via a line.c<00><><00>
<01>t<00>|<00>|
<01>

|<02>||_ntj|<02>
|_||_||_||_y
)a<>
        Parameters
        ----------
        offset : (float, float), default: (2, -2)
            The (x, y) offset to apply to the path, in points.
        shadow_color : :mpltype:`color`, default: 'black'
            The shadow color.
            A value of ``None`` takes the original artist's color
            with a scale factor of *rho*.
        alpha : float, default: 0.3
            The alpha transparency of the created shadow patch.
        rho : float, default: 0.3
            A scale factor to apply to the rgbFace color if *shadow_color*
            is ``None``.
        **kwargs
            Extra keywords are stored and passed through to
            :meth:`AbstractPathEffect._update_gc`.
        N)rOr<00>
_shadow_colorr~rr<>r<>ro)rr
<00>shadow_colorr<72>r<>rUr=s      <20>rrzSimpleLineShadow.__init__!
sF<00><><00>(	<0E><07><18><16> <20><17><1F>!-<2D>D<EFBFBD><1E>!(<28><1F><1F><1C>!><3E>D<EFBFBD><1E><1B><04><0B><17><04>	<09><19><04>rc<00><00>|
j
<00>}|j|<02>

|j<00>H|j<00>x
s
dd
d\}}}	||jz||jz|	|jzf}
n|j}
|j|
<EFBFBD>

|j
|j<00>

|j||j<00>}|
j||||j|
<01>
z<00>
|j<00>
y
)r<>Nr<4E>r<>)
rBrsr<><00>get_foregroundr<64>r<>r<>r<>r)ror.rrtr<>s           rr.zSimpleLineShadow.draw_path?
s<><00><00>
<17>o<EFBFBD>o<EFBFBD><1F><03><0B><1B><1B>B<EFBFBD><1F><0F><1D><1D>%<25><1A>)<29>)<29>+<2B>;<3B>|<7C>R<EFBFBD>a<EFBFBD>@<40>G<EFBFBD>A<EFBFBD>q<EFBFBD>!<21><1F>$<24>)<29>)<29>m<EFBFBD>Q<EFBFBD><14><19><19>]<5D>A<EFBFBD><04>	<09>	<09>M<EFBFBD>J<>N<EFBFBD>!<21>/<2F>/<2F>N<EFBFBD><0B><1A><1A>><3E>*<2A><0B>
<0A>
<0A>d<EFBFBD>k<EFBFBD>k<EFBFBD>"<22><12>o<EFBFBD>o<EFBFBD>c<EFBFBD>4<EFBFBD>8<EFBFBD>8<EFBFBD>,<2C><03><10><1A><1A><0F><15><06><14>!7<>!7<><08>!A<>A<>
	C
<01><0B><0B><0B>
r)r<>r&r|r|rxras
@rr<>r<>
s<00><><00>%<25>%<25>25<32><1A><rr<>c<00>*<00><00>eZ
dZd
Zd<04>f
d<02>	Zd<03>Z<05>x
ZS)<05>PathPatchEffectza
    Draws a `.PathPatch` instance whose Path comes from the original
    PathEffect artist.
    c<00>\<00>
<01>t<00>|<00>|
<01>
<01>

tjgf
i|<02>
<01>
|_y)a<>

        Parameters
        ----------
        offset : (float, float), default: (0, 0)
            The (x, y) offset to apply to the path, in points.
        **kwargs
            All keyword arguments are passed through to the
            :class:`~matplotlib.patches.PathPatch` constructor. The
            properties which cannot be overridden are "path", "clip_box"
            "transform" and "clip_path".
        )
r
N)rOr<00>mpatches<65>	PathPatch<63>patchrps   <20>rrzPathPatchEffect.__init__]
s,<00><><00>	<0E><07><18><06><18>'<27><1D>'<27>'<27><02>5<>f<EFBFBD>5<><04>
rc<00><>
<00>||j_
|jj||j|
<01>
z<00>

|jj	|j<00><00>

|j
<00>}|r3|jj
<00><00>|jj|<06>
|jj|
<01>

yr3)	r<><00>_path<74>
set_transformr<00>set_clip_box<6F>get_clip_rectangle<6C>
get_clip_path<74>
set_clip_path<74>draw)rrr$r/r0r1<00>	clip_paths       rr.zPathPatchEffect.draw_pathl
s<><00><00> <20><04>
<EFBFBD>
<EFBFBD><18><0C>
<EFBFBD>
<EFBFBD> <20> <20><16>$<24>*@<40>*@<40><18>*J<>!J<>K<><0C>
<EFBFBD>
<EFBFBD><1F><1F><02> 5<> 5<> 7<>8<><16>$<24>$<24>&<26>	<09><14><14><1A><1A>1<>1<>3<>;<3B>$<24>D<EFBFBD>J<EFBFBD>J<EFBFBD>$<24>$<24>i<EFBFBD>0<><0C>
<EFBFBD>
<EFBFBD><0F><0F><08>!rrvrxras
@rr<>r<>W
s<00><><00><08>

6<>"rr<>c<00>R<00><00>eZ
dZd
Zdddej
d<05>
f<04>f
d<06>	Zd<07>Z<07>x
ZS)<08>TickedStrokea
    A line-based PathEffect which draws a path with a ticked style.

    This line style is frequently used to represent constraints in
    optimization.  The ticks may be used to indicate that one side
    of the line is invalid or to represent a closed boundary of a
    domain (i.e. a wall or the edge of a pipe).

    The spacing, length, and angle of ticks can be controlled.

    This line style is sometimes referred to as a hatched line.

    See also the :doc:`/gallery/misc/tickedstroke_demo` example.
    rwg$@g<00>F@r<>c<00>\<00>
<01>t<00>|<00>|
<01>

||_||_||_||_y
)a%
        Parameters
        ----------
        offset : (float, float), default: (0, 0)
            The (x, y) offset to apply to the path, in points.
        spacing : float, default: 10.0
            The spacing between ticks in points.
        angle : float, default: 45.0
            The angle between the path and the tick in degrees.  The angle
            is measured as if you were an ant walking along the curve, with
            zero degrees pointing directly ahead, 90 to your left, -90
            to your right, and 180 behind you. To change side of the ticks,
            change sign of the angle.
        length : float, default: 1.414
            The length of the tick relative to spacing.
            Recommended length = 1.414 (sqrt(2)) when angle=45, length=1.0
            when angle=90 and length=2.0 when angle=60.
        **kwargs
            Extra keywords are stored and passed through to
            :meth:`AbstractPathEffect._update_gc`.

        Examples
        --------
        See :doc:`/gallery/misc/tickedstroke_demo`.
        N)rOr<00>_spacing<6E>_angle<6C>_lengthro)rr
<00>spacing<6E>angle<6C>lengthrUr=s      <20>rrzTickedStroke.__init__<5F>
s.<00><><00>8	<0E><07><18><16> <20><1F><04>
<0A><1B><04><0B><1D><04><0C><19><04>rc<00><><00>|
j
<00>}|j|<02>

|j||j<00>}||j	|
<01>
z}tj|j<00>
}tjtj|<08>
tj|<08>
gtj|<08>
tj|<08>
gg<02>
}	|
j|j<00>
}
|j|<03>
}|jd
<01><02>
}|D<00>]<5D>}
|
dd<03>df}|
dd<03>df}|jdkr
<01>&tj |dd|ddz
|dd|ddz
<00>}tj"dg
tj$|<10>
f<02>
}|d}t'tj(||
z<00>
<00>
dz
}tj*|
dz||
dzz
|<13>}tj,|||<0E>}tj,|||<0F>}|jd	z}tj,||z||<0E>|z
|z}tj,||z||<0F>|z
|z}tj ||<19>}|dk(}d
||<tj||z||zg<02>
j.}tjddg<02>
j.||<tj0||	<09>|j2z|
z}||dd<03>dfz}||dd<03>dfz}tj4d|zdf|j6<00><0B>} || ddd<06>df<|| ddd<06>df<|| ddd<06>df<|| ddd<06>df<tj8t:j<t:j>g|<13>}!t;| |!<21>}"|
jA||"|jC<00>|z|<05>
<00><02><>|jE<00>
y)rrF)
<01>closed_onlyNrrMr<><00><><EFBFBD><EFBFBD><EFBFBD>r2g<><67><EFBFBD><EFBFBD>MbP?r<>)
<01>dtype)#rBrsr)ror<00>np<6E>radiansr<73><00>array<61>cos<6F>sinrr<><00>transform_path<74>to_polygons<6E>size<7A>hypot<6F>concatenate<74>cumsum<75>int<6E>ceil<69>linspace<63>interp<72>
T<>dotr<74><00>emptyr<79><00>tiler<00>MOVETO<54>LINETOr.<00>invertedrt)#rrr$r/r0r1ru<00>trans<6E>theta<74>trans_matrix<69>
spacing_px<EFBFBD>	transpath<74>polys<79>
p<>
x<>
y<>dsr\<00>s_total<61>num<75>s_tick<63>x_tick<63>y_tick<63>delta_s<5F>
ur'<00>
n<>mask<73>uv<75>dxy<78>x_end<6E>y_end<6E>xyt<79>codes<65>
hs#                                   rr.zTickedStroke.draw_path<74>
s<><00><00><17>o<EFBFBD>o<EFBFBD><1F><03><0B><1B><1B>B<EFBFBD><1F><12>o<EFBFBD>o<EFBFBD>c<EFBFBD>4<EFBFBD>8<EFBFBD>8<EFBFBD>,<2C><03><16><14>/<2F>/<2F><08>9<>9<><05><13><1A><1A>D<EFBFBD>K<EFBFBD>K<EFBFBD>(<28>(<28><05><19>x<EFBFBD>x<EFBFBD>"<22>&<26>&<26><15>-<2D>"<22>&<26>&<26><15>-<2D><1E>!@<40>"$<24>&<26>&<26><15>-<2D><12><16><16><05><1D>!?<3F>
!A
<01>
B
<01><0C><1E>.<2E>.<2E>t<EFBFBD>}<7D>}<7D>=<3D>
<EFBFBD><1B>)<29>)<29>%<25>0<>	<09><1A>%<25>%<25>%<25>%<25>8<><05><16>9	K
<01>A<EFBFBD><11>!<21>Q<EFBFBD>$<24><07>A<EFBFBD><11>!<21>Q<EFBFBD>$<24><07>A<EFBFBD><11>v<EFBFBD>v<EFBFBD>
<01>z<EFBFBD><18><14><18><18>!<21>A<EFBFBD>B<EFBFBD>%<25>!<21>C<EFBFBD>R<EFBFBD>&<26>.<2E>!<21>A<EFBFBD>B<EFBFBD>%<25>!<21>C<EFBFBD>R<EFBFBD>&<26>.<2E>9<>B<EFBFBD><13><0E><0E><13><05>r<EFBFBD>y<EFBFBD>y<EFBFBD><12>}<7D>5<>6<>A<EFBFBD><17><02>e<EFBFBD>G<EFBFBD><15>b<EFBFBD>g<EFBFBD>g<EFBFBD>g<EFBFBD>
<EFBFBD>2<>3<>4<>q<EFBFBD>8<>C<EFBFBD><17>[<5B>[<5B><1A>A<EFBFBD><1C>w<EFBFBD><1A>A<EFBFBD><1C>/E<>s<EFBFBD>K<>F<EFBFBD><18>Y<EFBFBD>Y<EFBFBD>v<EFBFBD>q<EFBFBD>!<21>,<2C>F<EFBFBD><17>Y<EFBFBD>Y<EFBFBD>v<EFBFBD>q<EFBFBD>!<21>,<2C>F<EFBFBD><1B>m<EFBFBD>m<EFBFBD>d<EFBFBD>*<2A>G<EFBFBD><13><19><19>6<EFBFBD>G<EFBFBD>+<2B>Q<EFBFBD>
<01>2<>V<EFBFBD>;<3B>w<EFBFBD>F<>A<EFBFBD><13><19><19>6<EFBFBD>G<EFBFBD>+<2B>Q<EFBFBD>
<01>2<>V<EFBFBD>;<3B>w<EFBFBD>F<>A<EFBFBD><13><08><08><11>A<EFBFBD><0E>A<EFBFBD><14>
<01>6<EFBFBD>D<EFBFBD><19>A<EFBFBD>d<EFBFBD>G<EFBFBD><13><18><18>1<EFBFBD>q<EFBFBD>5<EFBFBD>!<21>a<EFBFBD>%<25>.<2E>)<29>+<2B>+<2B>B<EFBFBD><19>x<EFBFBD>x<EFBFBD><11>A<EFBFBD><06>'<27>)<29>)<29>B<EFBFBD>t<EFBFBD>H<EFBFBD><15>&<26>&<26><12>\<5C>*<2A>T<EFBFBD>\<5C>\<5C>9<>J<EFBFBD>F<>C<EFBFBD><1B>S<EFBFBD><11>A<EFBFBD><14>Y<EFBFBD>&<26>E<EFBFBD><1A>S<EFBFBD><11>A<EFBFBD><14>Y<EFBFBD>&<26>E<EFBFBD><15>(<28>(<28>A<EFBFBD><03>G<EFBFBD>Q<EFBFBD><<3C>v<EFBFBD>|<7C>|<7C><<3C>C<EFBFBD>!<21>C<EFBFBD>
<01><04>1<EFBFBD><04>a<EFBFBD><07>L<EFBFBD> <20>C<EFBFBD>
<01><04>1<EFBFBD><04>a<EFBFBD><07>L<EFBFBD>!<21>C<EFBFBD>
<01><04>1<EFBFBD><04>a<EFBFBD><07>L<EFBFBD> <20>C<EFBFBD>
<01><04>1<EFBFBD><04>a<EFBFBD><07>L<EFBFBD><17>G<EFBFBD>G<EFBFBD>T<EFBFBD>[<5B>[<5B>$<24>+<2B>+<2B>6<><03><<3C>E<EFBFBD><15>S<EFBFBD>%<25> <20>A<EFBFBD><14><1E><1E>s<EFBFBD>A<EFBFBD>v<EFBFBD><EFBFBD><EFBFBD>'8<>5<EFBFBD>'@<40>'<27>J<>s
9	K
<01>v
	<0C><0B><0B>
r)	r4r5r6r7r<><00>sqrtrr.r`ras
@rr<>r<>v
s*<00><><00>
<08>%<25><1D>T<EFBFBD>'<27>"<22>'<27>'<27>!<21>*<2A>!<1A>F
S
rr<>)r7<00>matplotlib.backend_basesr<00>
matplotlibrr~rr<>rr<00>matplotlib.pathr<00>numpyr<79>r	r,rcrkrm<00>
withStrokerz<00>withSimplePatchShadowr<77>r<>r<><00>withTickedStrokerrr<00><module>r<>
s<><00>


<01>
<04>
2<>(<28>*<2A>0<> <20><12>3
><3E>3
><3E>l
P

-<2D><1C>P

-<2D>f
<08>
<1F>
<08>
<16><
<16>
<1F>
<16>,#<23><06>
7<>
<EFBFBD>>
<16>*<2A>>
<16>B.<2E>;L<>M<><15>6
<16>)<29>6
<16>r

"<22>(<28>
"<22>>F
<16>%<25>F
<16>R)<29>l<EFBFBD>C<>r