hhddlmZddlmZmZmZmZmZddlZddl Z ddl m Z m Z mZmZmZmZmZmZmZmZmZmZmZmZmZmZmZmZmZmZddl m!Z!ddl"m#Z#ddl$m%Z%dd l&m'Z'dd l(m)Z)m*Z*er ddl"m#Z#dd l+m,Z,gd Z-d Z.dZ/dZ0dZ1ddZ4d?dZ5ddd@dZ6dAdZ7 dB dCdZ8dDdZ9dDdZ:e.e/edd dEdZ;d dedd dEdZe.e/dd# dGd$Z?e.e/dd# dGd%Z@e0dd& dHd'ZA dI dJd(ZBdKd)ZCdLd*ZD dM dNd+ZEdOdPd,ZFd-d.d/ dQd0ZGdRd1ZHdRd2ZIdSdTd3ZJdUd4ZKdVd5ZLdWd6ZMdXdYd7ZNdZd8ZOd[d9ZP d\ d]d:ZQd^d_d;ZRy)`) annotations) TYPE_CHECKINGIterableIteratorOptionalSequenceN)Vec2Vec3UVecZ_AXISOCSUCSMatrix44 BoundingBoxConstructionEllipsecubic_bezier_from_ellipseBezier4PBezier3PBSplinereverse_bezier_curves bulge_to_arclinear_vertex_spacinginscribe_circle_tangent_lengthcubic_bezier_arc_parameterscubic_bezier_bboxquadratic_bezier_bbox)mapbox_earcut_2d) EntityQuery)Path)Command) converternesting)GenericLayoutType)bbox precise_bboxfit_paths_into_boxtransform_pathstransform_paths_to_ocsrender_lwpolylinesrender_polylines2drender_polylines3d render_linesrender_hatchesrender_mpolygonsrender_splines_and_polylines add_bezier4p add_bezier3p add_ellipseadd_2d_polyline add_spline to_multi_path single_pathshave_close_control_verticeslines_to_curve3lines_to_curve4filletpolygonal_filletchamferchamfer2 triangulateis_rectangular{Gz?g-C6?g|=cJt}|D]}|j||S)zReturns a multi-path object from all given paths and their sub-paths. Ignores paths without any commands (empty paths). )r extend_multi_path)paths multi_pathps 0lib/python3.12/site-packages/ezdxf/path/tools.pyr6r6Us)J $$Q' c#pK|D]+}|jr|jEd{(|-y7 w)zBYields all given paths and their sub-paths as single path objects.N) has_sub_paths sub_paths)rErGs rHr7r7_s.  ??{{} $ $G  $s %64 6cJ|Dcgc]}|j|c}Scc}w)aTransform multiple path objects at once by transformation matrix `m`. Returns a list of the transformed path objects. Args: paths: iterable of :class:`Path` or :class:`Path2d` objects m: transformation matrix of type :class:`~ezdxf.math.Matrix44` ) transform)rEmrGs rHr(r(hs$%* *EqAKKNE ** *s cn|jj}|jt||S)aTransform multiple :class:`Path` objects at once from WCS to OCS. Returns a list of the transformed :class:`Path` objects. Args: paths: iterable of :class:`Path` or :class:`Path2d` objects ocs: OCS transformation of type :class:`~ezdxf.math.OCS` )matrixcopy transposer()rEocsts rHr)r)ts* AKKM 5! $$rIFfastct}|D]c}|r |j|j%t|}|js=|j|j |j fe|S)uUReturns the :class:`~ezdxf.math.BoundingBox` for the given paths. Args: paths: iterable of :class:`Path` or :class:`Path2d` objects fast: calculates the precise bounding box of Bèzier curves if ``False``, otherwise uses the control points of Bézier curves to determine their bounding box. )rextendcontrol_verticesr&has_dataextminextmax)rErWboxrGbbs rHr%r%s] -C   JJq))+ ,aB{{ BIIryy12  JrIc t|dk(r tS|j}|g}|jD]}|jt j k(r|j|jnA|jt jk(rmtt||j|j|jf}|j|j|j|jn|jt j k(rbt#t%||j&|jf}|j|j|j|jn8|jt j(k(r|j|j|j}t|S)zIReturns the precise :class:`~ezdxf.math.BoundingBox` for the given paths.r)lenrstartcommandstyper!LINE_TOappendend CURVE4_TOrrctrl1ctrl2r\r] CURVE3_TOrrctrlMOVE_TO)pathrbpointscmdr_s rHr&r&s6 4yA~} JJEF}} 88w & MM#'' " XX** *"%CIIsww?@B MM")) $ MM")) $ XX** *&x#''0J'KLB MM")) $ MM")) $ XX ( MM#'' "" v rITct|}t|dk(r|S|t|d}n|}|jr|jdk(r|St |}|dk(st |dkr td|rt|j|\}}}nt|j|\}}}tj|||} t|| S)aScale the given `paths` to fit into a box of the given `size`, so that all path vertices are inside these borders. If `source_box` is ``None`` the default source bounding box is calculated from the control points of the `paths`. `Note:` if the target size has a z-size of 0, the `paths` are projected into the xy-plane, same is true for the x-size, projects into the yz-plane and the y-size, projects into and xz-plane. Args: paths: iterable of :class:`~ezdxf.path.Path` objects size: target box size as tuple of x-, y- and z-size values uniform: ``True`` for uniform scaling source_box: pass precalculated source bounding box, or ``None`` to calculate the default source bounding box from the control vertices rTrV)rrrzinvalid target size) listrar%r[sizer min ValueError_get_uniform_scaling_get_non_uniform_scalingrscaler() rErsuniform source_box current_box target_sizesxsyszrOs rHr'r's. KE 5zQ 5t,    ;#3#3y#@ t*Ki3{#3a#7.//)+*:*:KH B-k.>.> L Br2r"A 5! $$rIcd}tj}|j|kDr(|j|kDr|j|jz }tj}|j|kDr(|j|kDr|j|jz }tj}|j|kDr(|j|kDr|j|jz }t |||}|tjur t d|j|kDr|nd}|j|kDr|nd}|j|kDr|nd}|||fS)Nư>zinternal errorr)mathinfxyzrtArithmeticError) current_sizer|TOLscale_xscale_yscale_z uniform_scales rHrvrvs ChhG~~  3--,..0hhG~~  3--,..0hhG~~  3--,..0'2M .//*}}s2mG*}}s2mG*}}s2mG GW $$rIc d}d}|j|kDr|j|jz }d}|j|kDr|j|jz }d}|j|kDr|j|jz }|||fS)Nrg?)rrr)rr|rrrrs rHrwrws} CG~~--,..0G~~--,..0G~~--,..0 GW $$rIdistancesegments extrusion dxfattribsc ttj|||||}|D]}|j|t |S)uARender the given `paths` into `layout` as :class:`~ezdxf.entities.LWPolyline` entities. The `extrusion` vector is applied to all paths, all vertices are projected onto the plane normal to this extrusion vector. The default extrusion vector is the WCS z-axis. The plane elevation is the distance from the WCS origin to the start point of the first path. Args: layout: the modelspace, a paperspace layout or a block definition paths: iterable of :class:`Path` or :class:`Path2d` objects distance: maximum distance, see :meth:`Path.flattening` segments: minimum segment count per Bézier curve extrusion: extrusion vector for all paths dxfattribs: additional DXF attribs Returns: created entities in an :class:`~ezdxf.query.EntityQuery` object r)rrr"to_lwpolylines add_entityr)layoutrErrrr lwpolylines lwpolylines rHr*r*P8  !  K" *%" { ##rIc ttj|||||}|D]}|j|t |S)uARender the given `paths` into `layout` as 2D :class:`~ezdxf.entities.Polyline` entities. The `extrusion` vector is applied to all paths, all vertices are projected onto the plane normal to this extrusion vector.The default extrusion vector is the WCS z-axis. The plane elevation is the distance from the WCS origin to the start point of the first path. Args: layout: the modelspace, a paperspace layout or a block definition paths: iterable of :class:`Path` or :class:`Path2d` objects distance: maximum distance, see :meth:`Path.flattening` segments: minimum segment count per Bézier curve extrusion: extrusion vector for all paths dxfattribs: additional DXF attribs Returns: created entities in an :class:`~ezdxf.query.EntityQuery` object r)rrr"to_polylines2drr)rrErrrr polylines2d polyline2ds rHr+r+-rrI edge_pathrrg1_tolrrc ttj|||||||}|D]} |j| t |S)u/Render the given `paths` into `layout` as :class:`~ezdxf.entities.Hatch` entities. The `extrusion` vector is applied to all paths, all vertices are projected onto the plane normal to this extrusion vector. The default extrusion vector is the WCS z-axis. The plane elevation is the distance from the WCS origin to the start point of the first path. Args: layout: the modelspace, a paperspace layout or a block definition paths: iterable of :class:`Path` or :class:`Path2d` objects edge_path: ``True`` for edge paths build of LINE and SPLINE edges, ``False`` for only LWPOLYLINE paths as boundary paths distance: maximum distance, see :meth:`Path.flattening` segments: minimum segment count per Bézier curve to flatten polyline paths g1_tol: tolerance for G1 continuity check to separate SPLINE edges extrusion: extrusion vector for all paths dxfattribs: additional DXF attribs Returns: created entities in an :class:`~ezdxf.query.EntityQuery` object r)rrr" to_hatchesrr) rrErrrrrrhatcheshatchs rHr.r.WsWB !  G%  w rIc ttj|||||}|D]}|j|t |S)uRender the given `paths` into `layout` as :class:`~ezdxf.entities.MPolygon` entities. The MPOLYGON entity supports only polyline boundary paths. All curves will be approximated. The `extrusion` vector is applied to all paths, all vertices are projected onto the plane normal to this extrusion vector. The default extrusion vector is the WCS z-axis. The plane elevation is the distance from the WCS origin to the start point of the first path. Args: layout: the modelspace, a paperspace layout or a block definition paths: iterable of :class:`Path` or :class:`Path2d` objects distance: maximum distance, see :meth:`Path.flattening` segments: minimum segment count per Bézier curve to flatten polyline paths extrusion: extrusion vector for all paths dxfattribs: additional DXF attribs Returns: created entities in an :class:`~ezdxf.query.EntityQuery` object r)rrr" to_mpolygonsrr)rrErrrrpolygonspolygons rHr/r/sP< !  H'" x  rIrrrcttj||||}|D]}|j|t |S)uRender the given `paths` into `layout` as 3D :class:`~ezdxf.entities.Polyline` entities. Args: layout: the modelspace, a paperspace layout or a block definition paths: iterable of :class:`Path`or :class:`Path2d` objects distance: maximum distance, see :meth:`Path.flattening` segments: minimum segment count per Bézier curve dxfattribs: additional DXF attribs Returns: created entities in an :class:`~ezdxf.query.EntityQuery` object r)rrr"to_polylines3drr)rrErrr polylines3d polyline3ds rHr,r,sM.  !  K" *%" { ##rIcttj||||}|D]}|j|t |S)uRender the given `paths` into `layout` as :class:`~ezdxf.entities.Line` entities. Args: layout: the modelspace, a paperspace layout or a block definition paths: iterable of :class:`Path`or :class:`Path2d` objects distance: maximum distance, see :meth:`Path.flattening` segments: minimum segment count per Bézier curve dxfattribs: additional DXF attribs Returns: created entities in an :class:`~ezdxf.query.EntityQuery` object r)rrr"to_linesrr)rrErrrlineslines rHr-r-sM,  !   E$ u rIrrcttj|||}|D]}|j|t |S)aRender the given `paths` into `layout` as :class:`~ezdxf.entities.Spline` and 3D :class:`~ezdxf.entities.Polyline` entities. Args: layout: the modelspace, a paperspace layout or a block definition paths: iterable of :class:`Path`or :class:`Path2d` objects g1_tol: tolerance for G1 continuity check dxfattribs: additional DXF attribs Returns: created entities in an :class:`~ezdxf.query.EntityQuery` object r)rrr"to_splines_and_polylinesrr)rrErrentitiesentitys rHr0r0sJ(** ! H&! x  rIct|jdkryt|dk(r|r|j|_t |t ||y)uAdd an elliptical arc as multiple cubic Bèzier-curves to the given `path`, use :meth:`~ezdxf.math.ConstructionEllipse.from_arc` constructor of class :class:`~ezdxf.math.ConstructionEllipse` to add circular arcs. Auto-detect the connection point to the given `path`, if neither the start- nor the end point of the ellipse is close to the path end point, a line from the path end point to the ellipse start point will be added automatically (see :func:`add_bezier4p`). By default, the start of an **empty** path is set to the start point of the ellipse, setting argument `reset` to ``False`` prevents this behavior. Args: path: :class:`~ezdxf.path.Path` object ellipse: ellipse parameters as :class:`~ezdxf.math.ConstructionEllipse` object segments: count of Bèzier-curve segments, at least one segment for each quarter (pi/2), ``1`` for as few as possible. reset: set start point to start of ellipse if path is empty & .>Nr)abs param_spanra start_pointrbr1r)rnellipserresets rHr3r3sF2 7  % 4yA~%(( 0(CDrIcd}d}t|}t|sy|djd}|jj |r t |}|D]}|j\}}}}|j |js|j ||j |||r&|j |||r|j |z|j|||y)u;Add multiple cubic Bèzier-curves to the given `path`. Auto-detect the connection point to the given `path`, if neither the start- nor the end point of the curves is close to the path end point, a line from the path end point to the start point of the first curve will be added automatically. V瞯<Nrel_tolabs_tol)rrracontrol_pointsrgiscloserline_to curve4_to) rncurvesrrrgcurverbrirjs rHr1r1;sGG &\F v; * # #B 'C xx&v.#(#7#7 ueS}}TXX& LL  === Ackk 7GGRG  LL  NN3u -rIcd}d}t|}t|sy|djd}|jj |r t |}|D]}|j\}}}|j |j||s|j ||j |||s|j |||r|j |||j||y)u?Add multiple quadratic Bèzier-curves to the given `path`. Auto-detect the connection point to the given `path`, if neither the start- nor the end point of the curves is close to the path end point, a line from the path end point to the start point of the first curve will be added automatically. rrNrr)rrrarrgrrr curve3_to)rnrrrrgrrbrls rHr2r2\sGG &\F v; * # #B 'C xx&v. //tS}}TXXw}H LL  ==w= @CKK '7EPE  LL  NN3 %rIcdfd }tr tdd}d}|D]S\} } } t| dkrd} t| | } | | _| }| }1|r ||| ||nj | | }| }U|rijj jtds=|r |jj||nj j|js|rj||yy)zYInternal API to add 2D polylines which may include bulges to an **empty** path. c |j|tdrytj|dz }t |||\}}}}|tj z}|tj z}||kDr|tj z }t tj|||dz} g} t|D]q} tj||ttj| | tj| | dz} | jt t| s| d} | j d}|j|tdr t#| } t%| y)Nrrr)r IS_CLOSE_TOLrceilrtaurrnplinspacerangerfrom_arcr degreesrYrrrr1)p1p2bulgernum_bezcenter start_angle end_angleradiusanglesrircurve0cp0rns rHbulge_toz!add_2d_polyline..bulge_tos8 ::b,: : ))HqL)1=b"e1L. Y!DHH, (  "  !Ibkk+y'A+FGwA)22 VAY' VAE]+ G MM$8AB C ##A& ;;r<; ;*62FT6"rIzRequires an empty path.Nrrr)rr rr rfloatrint) rarurr rbrrrgrrNto_wcs) rnrocloserT elevationrr prev_point prev_bulgerrrpoints ` rHr4r4|s#8 4y233!%JJ 1e u: EQ   DJJJ   Z H = LL   !$ TZZ'',PQ'R  TXXtzz:x @ LL $ }}  C#"rIc2t|dk(r|r|jd|_|jdk(r?|js3|j r'|j Dcgc] }t|}}n|j|}t||ycc}w)uAdd a B-spline as multiple cubic Bèzier-curves. Non-rational B-splines of 3rd degree gets a perfect conversion to cubic Bézier curves with a minimal count of curve segments, all other B-spline require much more curve segments for approximation. Auto-detect the connection point to the given `path`, if neither the start- nor the end point of the B-spline is close to the path end point, a line from the path end point to the start point of the B-spline will be added automatically. (see :meth:`add_bezier4p`). By default, the start of an **empty** path is set to the start point of the spline, setting argument `reset` to ``False`` prevents this behavior. Args: path: :class:`~ezdxf.path.Path` object spline: B-spline parameters as :class:`~ezdxf.math.BSpline` object level: subdivision level of approximation segments reset: set start point to start of spline if path is empty rr)levelN) rarrbdegree is_rational is_clampedbezier_decompositionrcubic_bezier_approximationr1)rnsplinerrrors rHr5r5s. 4yA~%\\!_  }}&"4"49J9J171L1L1NO1Nv(6"1NO222?vPs Br-q=rc|tfdt|j|jDS)zBReturns ``True`` if the control vertices of given paths are close.c3LK|]\}}|j|yw)rN)r).0cp_acp_brrs rH z.have_close_control_vertices..s,IJD$ T7G <Is!$)allziprZ)abrrs ``rHr8r8s8 a002A4F4F4HI rIct|dS)u^Replaces all lines by quadratic Bézier curves. Returns a new :class:`Path` instance. rcount_all_lines_to_curverns rHr9r9 t1 --rIct|dS)uZReplaces all lines by cubic Bézier curves. Returns a new :class:`Path` instance. rBrrrs rHr:r:rrIc\|dk(s|dk(s Jd||j}t|}|dk(r tS|j}tj }t|j}|D]}|j |k(r|j|jr|dk(rz|j||cSt||j|}|dk(r|j|d|dn/|j|d|d|dn|j||j}|S) NrBrzinvalid count: rr)rl)rirj) rcrar rbr!rerdrrgappend_path_elementrrr) rnrcmdsrsrbrnew_pathrpverticess rHrrs# A:!>ug%>> # ==?D t9D qyv JJEooGDJJH 88w }}SWW%19 005#O1GA:&&x{!&E&&  &qk&qk'  ( ( -12 OrIc||z j}||z j}|j|s|j| rt|j|}t |||}|||zz}|j |} | j | j|} || z} t | | | } |tj|z | fS)N)originuxuz) normalizerZeroDivisionError angle_betweenrcrossrrpi) p0rrrdir1dir2angletangent_lengtharc_start_point local_z_axis radius_vec arc_centerucss rH_get_local_fillet_ucsr"%s G   D G   D ||DT\\4%0   t $E3D$GND>12O ::d#L##TE*44V.Vs0LVVVsrr ) rarurr r"rrrtuple points_to_wcsr) rorrrrrGrp3rrr!params bez_pointss ` rHr;r;<s? 6{QDEE {+F8455$'qr $; <$;&"bb"X$;E < VAYA!%qr3R(2r &;BB&O #K +1!U;Fs000LV0LLMJ KK 2 1 z!} E<4IIfRj H! = !  IIbM  sD;D  D)(D)cltd|}tt|tj|z z dS)NrBr)maxrrr)rrs rH_segment_countr0\s- 5ME s5DHHu,-. 22rIcNt|dkr td|dkrtd|t||ddDcgc] \}}||f }}}t|d}t||ddD]{\\}}\}} t ||||\} } } t| |} | | z } t| dzD];}tj|| z|}|j | j|=}|j |d|Scc}}w#t $r|j |YwxYw)a` Returns a :class:`Path` with polygonal fillets of given `radius` between straight line segments. The `count` argument defines the vertex count of the fillet for a full circle. Args: points: coordinates of the line segments radius: fillet radius count: polygon vertex count for a full circle, minimum is 4 rr$rr%rNr) rarurr r"rrr0rr from_angler)rorrrrrrGrr+_rr!rdeltarrs rHr<r<as; 6{QDEE {+F8455$'qr $; <$;&"bb"X$;E < VAYA!%qr3R(2r 1"b"fEMAuc"%/ x!|$AUF;J IIcjj, -%4IIfRj H! = !  IIbM  sD:DD$#D$ct|dkr tdt||ddDcgc] \}}||f }}}t|d}t||ddD]\\}}\}} ||z j }||z j } |j | s|j | rt |j| dz } t|dz tj| z } |j||| zz|j|| | zz|j|d|Scc}}w#t $r|j|YwxYw)z Returns a :class:`Path` with chamfers of given `length` between straight line segments. Args: points: coordinates of the line segments length: chamfer length rr$rNrg@r) rarurr rrrrrrsinr) rolengthrrrrGrr+rrrrs rHr=r=sT 6{QDEE$'qr $; <$;&"bb"X$;E < VAYA!%qr3R(2r G&&(DG&&(D||D!T\\4%%8''&&t,s2EVc\TXXe_45A "q/" "q/"4IIfRj H# =!  IIbM  sD4'BD::EEcFt|dkr tdt||ddDcgc] \}}||f }}}t|d}t||ddD]\\}}\}} ||z j } ||z j } | j | s| j | rt  |j|| |zz|j|| |zz|j|d|Scc}}w#t $r|j|YwxYw)aQ Returns a :class:`Path` with chamfers at the given distances `a` and `b` from the segment points between straight line segments. Args: points: coordinates of the line segments a: distance of the chamfer start point to the segment point b: distance of the chamfer end point to the segment point rz)at least 3 non-coincident points requiredrNrr)rarurr rrrr) rorrrrrrGrr+rrs rHr>r>s) 6{QDEE$'qr $; <$;&"bb"X$;E < VAYA!%qr3R(2r G&&(DG&&(D||D!T\\4%%8''&9 "q/" "q/"4IIfRj H =!  IIbM  sC='ADD D c#Ktjt|D]M}|dj||}|ddDcgc]}|j||}}t ||Ed{Oycc}w7 w)uTessellate nested 2D paths into triangle-faces. For 3D paths the projection onto the xy-plane will be triangulated. Args: paths: iterable of nested Path instances max_sagitta: maximum distance from the center of the curve to the center of the line segment between two approximation points to determine if a segment should be subdivided. min_segments: minimum segment count per Bézier curve rrN)r# group_pathsr7 flatteningr)rE max_sagitta min_segmentsrexteriorrGholess rHr?r?ss&&|E':;1:((lCBI!"+N+Qk<8+N#He444<N4s>A9A2A9*A7+ A9c|j}t|dkry|dj|dr|jt|dk7ry|r<|d|dz }t |j dkst |j dksy|dj|d}|dj|d}tj||sy|dj|d}|dj|d}tj||sy|dj|d}|dj|d}tj||syy ) zReturns ``True`` if `path` is a rectangular quadrilateral (square or rectangle). If the argument `aligned` is ``True`` all sides of the quadrilateral have to be parallel to the x- and y-axis. rBFrrrrr rT) rZrarpoprrrrr)rnalignedro first_sidev1v2s rHr@r@sO  " " $F 6{Q ay$  6{aAY* JLL!E)S->-F   F1I &B   F1I &B <<B    F1I &B   F1I &B <<B    F1I &B   F1I &B <<B  rI)rEIterable[Path]returnr )rErFrGrF)rErFrOrrG list[Path])rErFrTr rGrH)rErFrGr)rnr rGr)TN) rErFrsztuple[float, float, float]ryboolrzzOptional[BoundingBox]rGrH)rr r|r ) rr$rErFrrrrrr rGr)rr$rErFrrIrrrrrrrr rGr) rr$rErFrrrrrGr)rr$rErFrrrGr)rT)rnr rrrGNone)rnr rzIterable[Bezier4P]rGrJ)rnr rzIterable[Bezier3P]rGrJ)r)rnr rozIterable[Sequence[float]]rrIrTr rrrrrGrJ)rBT)rnr rrrGrJ)rr rr rGrI)rnr rGr )rB)rnr rrrGr )rGztuple[Vec3, float, UCS])roSequence[Vec3]rrrGr )rrrrrGr) )rorKrrrrrGr )rorKr7rrGr )rorKrrrrrGr )rA)rErFr<rr=rrGzIterator[Sequence[Vec2]])T)rnr rGrI)S __future__rtypingrrrrrrnumpyr ezdxf.mathr r r r r rrrrrrrrrrrrrrrezdxf.math.triangulationr ezdxf.queryrrnr rcr!r"r# ezdxf.eztypesr$__all__ MAX_DISTANCE MIN_SEGMENTSG1_TOLrr6r7r(r)r%r&r'rvrwr*r+r.r/r,r-r0r3r1r2r4r5r8r9r:rr"r;r0r<r=r>r?r@r'rIrHrZs# ,6# '/ >    + %).*:(, )% )% $)%)%& )%  )%X%* %*# '$ '$ '$ '$  '$  '$'$\'$ '$ '$ '$  '$  '$'$\" . . .  .  .  .  . . . j# )! )! )! )!  )!  )!)!`#  !$ !$ !$ !$  !$!$P#          N ! ! !  !  !BAEE E,E E@.B&L G$ G$ %G$ G$ G$  G$  G$ G$TD"&u  ..#L1. @3  F @ @KM5 5(-5DG55("rI