Liren Large Software Subsidy 13/13.iso/p/p024/10.img/BONUS3.LIB/XPLODE.LSP

Text File | 1993-01-23 | 20.2 KB | 677 lines

;;;--------------------------------------------------------------------------;
;;; XPLODE.LSP
;;;   (C) ¬⌐┼v 1988-1992  Autodesk ñ╜Ñq
;;;
;;;   Ñ╗╡{ªíñwÑ╤ Autodesk ñ╜Ñq╡∙ÑU¬⌐┼v, ╢╚⌐≤ñU¡z▒í¬pñUÑi▒┬╗P▒zíu│\ÑiívíC
;;;   ╗╒ñUñú▒oÑHÑ⌠ª≤º╬ªí╡oªµ⌐╬ÑX¬⌐ª╣╡{ªí¬║íu¡∞⌐l╜Xív; ª²ñ╣│\▒zªb»S⌐w¡lÑ═
;;;   ¬║ñuº@ñW╡▓ªXª╣╡{ªí¬║íuÑ╪¬║╜Xív¿╧Ñ╬íCª│├÷│o├■¡lÑ═ñuº@¬║▒°Ñ≤ªpñU:
;;;
;;;   ( i)  │]¡pñW╗Pñuº@ñW¼╥»┬║Θ░w╣∩ Autodesk ñ╜Ñq¬║▓ú½~íC
;;;   (ii)  ╕ⁿª│íu¬⌐┼v  (C) 1988-1992  Autodesk ñ╜Ñqív¬║¬⌐┼v│qºiíC
;;;
;;;
;;;
;;;   AUTODESKñ╜Ñq┤ú¿╤ª╣╡{ªí╢╚¿╤º@íu├■ªⁿív¬║░╤ª╥, ª╙ÑBñú▒╞░úª│Ñ⌠ª≤┐∙╗~¬║
;;;   Ñi»αíCAUTODESKñ╜Ñq»Sª╣º_╗{Ñ⌠ª≤»S⌐wÑ╬│~ñº╛A║┘⌐╩, ÑHñ╬░╙╖~╛P░Γ⌐╥┴⌠ºt
;;;   ÑX¿π¬║½O├╥íCAUTODESKñ╜ÑqªP«╔ÑτñúÑX¿πª╣╡{ªí░⌡ªµ«╔ñ@⌐wñú╖|íuññ┬_ív⌐╬
;;;   íuº╣Ñ■╡L╗~ív¬║½O├╥íC
;;;
;;;
;;;   Jan S. Yoder & K.C. Jones   Version 1.0
;;;
;;;   Modified to allow explosion of blocks with equal absolute scaling
;;;   parameters but varying signs (i.e. 1,-1,1).  This allows mirrored blocks
;;;   to be exploded.
;;;
;;;   Jerry Ford   Version 2.0  8/20/91
;;; --------------------------------------------------------------------------;
;;; DESCRIPTION
;;;
;;;
;;;   This is a replacement for the EXPLODE command in AutoCAD.  It allows
;;;   you to control all of the properties of the component entities of a
;;;   block or set of blocks while exploding them.  There are several major
;;;   differences between XPlode and the EXPLODE command in AutoCAD.
;;;
;;;   First, you can select as many entities as you wish; all dimensions,
;;;   polyline and polymeshes, and block insertions will be extracted from
;;;   your selection set, and you will be asked to XPlode them either
;;;   globally or individually.  If you chose to explode them globally, you
;;;   will see the following prompt for all of the candidate entities:
;;;
;;;     All/Color/LAyer/LType/Inherit from parent block/<Explode>:
;;;
;;;   If, on the other hand, you elect to operate on each element of the
;;;   selection set individually, you will need to make a selection from this
;;;   prompt for each entity to be exploded.
;;;
;;;   Second, the EXPLODE command in AutoCAD does not allow you to specify
;;;   any of the properties for the resulting entities generated from the
;;;   EXPLODE command.  Nor does it allow you to let the component entities
;;;   inherit the attributes of the parent block.
;;;
;;;   Third, this routine allows blocks inserted with equal absolute scale
;;;   factors but differing signs to be exploded (i.e. -1,1,1).  This allows
;;;   mirrored blocks to be exploded.
;;;
;;;   ALL
;;;
;;;   This option allows you to specify a color, linetype, and layer for the
;;;   new entities.
;;;
;;;   COLOR
;;;
;;;   This option prompts you for a new color for the component entities.
;;;
;;;     New color for exploded entities.
;;;     Red/Yellow/Green/Cyan/Blue/Magenta/White/BYLayer/BYBlock/<cecolor>:
;;;
;;;   You may enter any color number from 1 through 255, or one of the
;;;   standard color names listed.  "Cecolor" is the current entity color
;;;   from the CECOLOR system variable.
;;;
;;;   LAYER
;;;
;;;   This option prompts you to enter the name of the layer on which you
;;;   want the component entities to be placed.
;;;
;;;     XPlode onto what layer?  <clayer>:
;;;
;;;   The layer name entered is verified and if it does not exist you are
;;;   reprompted for a layer name.  Pressing RETURN causes the current
;;;   layer to be used.
;;;
;;;   LTYPE
;;;
;;;   This option lists all of the loaded linetypes in the current drawing,
;;;   and prompts you to choose one of them.  You must type the entire
;;;   linetype name (sorry), or you may press RETURN to use the current one.
;;;
;;;     Choose from the following list of linetypes.
;;;     CONTinuous/...others.../<CONTINUOUS>:
;;;
;;;   INHERIT
;;;
;;;   Inherit from parent block means that the attributes of the block
;;;   being XPloded will be the attributes of component entities.  No other
;;;   choices are required.
;;;
;;;   EXPLODE
;;;
;;;   This option issues the current EXPLODE command for each of the entities
;;;   in the selection set.
;;;
;;; --------------------------------------------------------------------------;

;;; ------------------------ INTERNAL ERROR HANDLER --------------------------;

(defun xp_err (s)                     ; If an error (such as CTRL-C) occurs
  ;; while this command is active...
  (if (/= s "Ñ\»α¿·«°")
    (princ (strcat "\n┐∙╗~: " s))
  )
  (if xp_oce (setvar "cmdecho" xp_oce)) ; restore old cmdecho value
  (setq *error* olderr)               ; restore old *error* handler
  (princ)
)

;;; ---------------------------- COMMON FUNCTION -----------------------------;

(defun xp_val (n e f)
  (if f ; if f then e is an entity list.
    (cdr (assoc n e))
    (cdr (assoc n (entget e)))
  )
)

;;; ------------------------- GET ENTITY TO EXPLODE --------------------------;
;;; ---------------------------- MAIN PROGRAM --------------------------------;

(defun explode ( / oce ohl e0 en e1 s0)

  ;; Version number.  Reset this local if you make a change.
  (setq xp_ver "2.00")

  (setq xp_oer *error*
        *error* xp_err)
  (setq xp_oce (getvar "cmdecho"))    ; save value of cmdecho
  (setvar "cmdecho" 0)                ; turn cmdecho off

  (graphscr)
  (princ (strcat "\nXPlode, ¬⌐Ñ╗ " xp_ver ", (c) 1991 Autodesk ñ╜ÑqíC"))

  (princ "\n┐∩╛▄╣w│╞íu¼╡╢} (XPlode)ív¬║╣╧ñ╕ íC")
  (setq ss (ssget))

  (if ss
    (progn
      ;; Sort out any entities not explodeable...
      (setq ss (xp_sxe)) ; DLine_Sort_Xplodable_Entities

      ;; XPlode Individually or Globally?

      (if (> (sslength ss) 0)
        (progn
          (if (> (sslength ss) 1)
            (progn
              (initget "Individually Globally")
              (setq ans (getkword "\n\n¼╡╢} (XPlode) í╨ I¡╙ºO/<G╛π┼Θ>: "))
            )
            (setq ans "Globally")
          )


          (cond
            ((= ans "Individually")
              (setq sslen (sslength ss)
                    j    0
              )
              (while (< j sslen)
                (setq temp  (ssname ss j)
                      prmpt T
                )

                (redraw temp 3)
                (setq typ (xp_gxt))
                (xp_xpe temp typ)
                (redraw temp 4)
                (setq j (1+ j))
              )
            )
            (T
              (setq sslen (sslength ss)
                    j     0
                    ans   "Globally"
                    prmpt T
              )
              (setq typ (xp_gxt))
              (while (< j sslen)
                (setq temp (ssname ss j))
                (xp_xpe temp typ)
                (setq j (1+ j))
              )
            )
          )
        )
      )
    )
  )

  (if xp_oce (setvar "cmdecho" xp_oce)) ; restore old cmdecho value
  (setq *error* xp_err)               ; restore old *error* handler
  (prin1)
)
;;;
;;; Sort out all of the entities which can be exploded from the selection
;;; set.  Also ensure that block insertions have equal X, Y and Z scale factors.
;;;
;;; xp_sxe == DLine_Sort_Xplodable_Entities
;;;
(defun xp_sxe (/ temp bad)

  (setq sslen (sslength ss)
        j     0
        ss1   (ssadd)
  )
  (while (< j sslen)
    (setq temp (ssname ss j))
    (setq j (1+ j))
    (if (member (xp_val 0 temp nil) '("INSERT" "DIMENSION" "POLYLINE"))
      (if (= (xp_val 0 temp nil) "INSERT")
        (if (and (= (abs (xp_val 41 temp nil)) (abs (xp_val 42 temp nil)))
                 (= (abs (xp_val 41 temp nil)) (abs (xp_val 43 temp nil)))
            )
          (ssadd temp ss1)
        )
        (ssadd temp ss1)
      )
    )
  )
  (setq sslen (sslength ss)
        bad (sslength ss1)
  )
  (princ "\n")
  (princ "ºΣ¿∞ ")
  (princ sslen)
  (princ " ▓╒╣╧ñ╕íC ")
  (if (> (- sslen bad) 0)
    (progn
      (princ (- sslen bad))
      (princ " ▓╒╡L«─íC ")
    )
  )
  ss1
)
;;;
;;; Set the type of explode to do.
;;;
;;; xp_gxt == XPlode_Get_Xplode_Type
;;;
(defun xp_gxt (/ temp)

  (initget "All Color LAyer LType Inherit Explode")
  (setq temp (getkword
    "\n\nAÑ■│í/C├CªΓ/LA╣╧╝h/LT╜u½¼/I⌐╙┼ºñ≈¿t╣╧╕s/<E¼╡╢}>: "))

  (if (or (= temp "") (null temp))
    (setq temp "Explode")
  )
  temp
)
;;;
;;; Do the explosion of an entity.
;;;
;;; xp_xpe == XPlode_XPlode_Entity
;;;
(defun xp_xpe (ent typ /  )
  (cond
    ((= typ "All")
      (if prmpt
        (progn
          (setq color (xp_scn))
          (setq ltype (xp_slt))
          (setq layer (xp_sla))
          (setq prmpt nil)
        )
      )

      (xp_xfa)
      (if (or (= ans "Individually") (= j (1- sslen)))
        (progn
          (if (and (> sslen 1) (= ans "Globally"))
            (princ "\níu¼╡╢}ívñº½ß¬║╣╧ñ╕")
            (princ "\níu¼╡╢}ívñº½ß¬║╣╧ñ╕")
          )
          (princ (strcat "├CªΓ╜X = "
                         (if (= (type color) 'INT) (itoa color) color) " ,"
                         " ╜u½¼ = " ltype " , "
                         "╕m⌐≤íu" layer "ív╣╧╝híC"))
        )
      )
    )
    ((= typ "Color")
      (if prmpt
        (progn
          (setq color (xp_scn))
          (setq ltype (getvar "celtype"))
          (setq layer (getvar "clayer"))
          (setq prmpt nil)
        )
      )

      (xp_xfa)
      (if (or (= ans "Individually") (= j (1- sslen)))
        (progn
          (if (and (> sslen 1) (= ans "Globally"))
            (princ "\níu¼╡╢}ív½ßñº╣╧ñ╕")
            (princ "\níu¼╡╢}ív½ßñº╣╧ñ╕")
          )
          (princ (strcat "├CªΓ╜X = "
                         (if (= (type color) 'INT) (itoa color) color) " íC"))
        )
      )
    )
    ((=
    typ "LAyer")
      (if prmpt
        (progn
          (setq color (getvar "cecolor"))
          (setq ltype (getvar "celtype"))
          (setq layer (xp_sla))
          (setq prmpt nil)
        )
      )

      (xp_xfa)
      (if (or (= ans "Individually") (= j (1- sslen)))
        (progn
          (if (and (> sslen 1) (= ans "Globally"))
            (princ "\níu¼╡╢}ív½ßñº╣╧ñ╕")
            (princ "\níu¼╡╢}ív½ßñº╣╧ñ╕")
          )
          (princ (strcat "╕m⌐≤íu" layer "ív╣╧╝híC"))
        )
      )
    )
    ((= typ "LType")
      (if prmpt
        (progn
          (setq color (getvar "cecolor"))
          (setq ltype (xp_slt))
          (setq layer (getvar "clayer"))
          (setq prmpt nil)
        )
      )

      (xp_xfa)
      (if (or (= ans "Individually") (= j (1- sslen)))
        (progn
          (if (and (> sslen 1) (= ans "Globally"))
            (princ "\níu¼╡╢}ív½ßñº╣╧ñ╕")
            (princ "\níu¼╡╢}ív½ßñº╣╧ñ╕")
          )
          (princ (strcat "╜u½¼ = " ltype " íC"))
        )
      )
    )
    ((= typ "Inherit")
      (xp_iap ent)
    )
    (T
      (xp_mirrchk (xp_val -1 ent nil)) ; check entity and explode
    )
  )
)
;;;
;;; Force the color, linetype and layer attributes after exploding.
;;;
;;; xp_xea == XPlode_Xplode_Force_All
;;;
(defun xp_xfa ()

  (setq e0 (entlast))
  (setq en (entnext e0))
  (while (not (null en))              ; find the last entity
    (setq e0 en)
    (setq en (entnext e0))
  )

  (xp_mirrchk (xp_val -1 ent nil))    ; check entity and explode

  (setq s0 (ssadd))

  (while (entnext e0)
    (ssadd (setq e0 (entnext e0))
           s0
    )
  )
  (command "_.CHPROP" s0 ""             ; change entities to the proper layer
           "_C"  color                 ; color, and linetype, regardless
           "_LT" ltype                 ; of their extrusion direction
           "_LA" layer
           ""
  )
)
;;;
;;; Inherit attributes (if BYBLOCK) from parent.
;;;
;;; xp_iap == XPlode_Inherit_Attributes_from_Parent
;;;
(defun xp_iap (t1 / t1cl t1lt t1ly s0ly s0lt s0cl t0e)
  (setq yyy t1)
  (setq t0 (entlast))
  (setq tn (entnext t0))
  (while (not (null tn))              ; find the last entity
    (setq t0 tn)
    (setq tn (entnext t0))
  )

  (setq t1cl (xp_val 62 t1 nil))      ; record the attributes of the block
  (setq t1lt (xp_val 6  t1 nil))
  (setq t1ly (xp_val 8  t1 nil))
  (xp_mirrchk (xp_val -1 t1 nil))     ; check entity and explode
  (setq s0ly (ssadd))                 ; create nil selection sets for layer
  (setq s0lt (ssadd))                 ; linetype and color changes
  (setq s0cl (ssadd))
  (setq t0 (entnext t0))
  (while t0                           ; can exploded entities
    (setq t0e (entget t0))            ; and build selection sets

    (if (=  (xp_val 62 t0e T) "BYBLOCK") (ssadd t0 s0cl))
    (if (=  (xp_val 6  t0e T) "BYBLOCK") (ssadd t0 s0lt))
    (if (=  (xp_val 8  t0e T) "0")       (ssadd t0 s0ly))
    (setq t0 (entnext t0))
  )
  (if (> (sslength s0cl) 0)           ; is selection set non-nil...
      (command "_.CHPROP" s0cl ""       ; Change exploded entities with color
               "_CO" t1cl "")          ; BYBLOCK to color of old block
  )
  (if (> (sslength s0lt) 0)
      (command "_.CHPROP" s0lt ""       ; Change exploded entities with linetype
               "_LT" t1lt "")          ; BYBLOCK to linetype of old block
  )
  (if (> (sslength s0ly) 0)
      (command "_.CHPROP" s0ly ""       ; Change exploded entities with linetype
               "_LA" t1ly "")          ; BYBLOCK to linetype of old block
  )
  (if (or (= ans "Individually") (= j (1- sslen)))
    (progn
      (if (and (> sslen 1) (= ans "Globally"))
        (princ "\n╣╧ñ╕")
        (princ "\n╣╧ñ╕")
      )
      (princ "ñwíu¼╡╢}ívíC")
    )
  )
)

;;;
;;; Set the color for the exploded entities.
;;;
;;; xp_scn == XPlode_Set_Color_Number
;;;
(defun xp_scn ()
  (setq arg 257)
  (while (> arg 256)
    (initget 2 "Red Yellow Green Cyan Blue Magenta White BYLayer BYBlock")
    (setq arg (getint (strcat
      "\n\níu¼╡╢}ív½ß╖s╣╧ñ╕¬║íu├CªΓíví╨ "
      "\nR¼⌡/Y╢└/G║±/Cñ⌠┬┼/B┬┼/"
      "M╡╡¼⌡/WÑ╒/BYL¿╠╖╙╣╧╝h/BYB¿╠╖╙╣╧╕s/<"
      (if (= (type (getvar "cecolor")) 'INT)
        (itoa (getvar "cecolor"))
        (getvar "cecolor")
      )
      ">: ")))
    (cond
      ((= arg "BYBlock") (setq arg 0))
      ((= arg "Red")     (setq arg 1))
      ((= arg "Yellow")  (setq arg 2))
      ((= arg "Green")   (setq arg 3))
      ((= arg "Cyan")    (setq arg 4))
      ((= arg "Blue")    (setq arg 5))
      ((= arg "Magenta") (setq arg 6))
      ((= arg "White")   (setq arg 7))
      ((= arg "BYLayer") (setq arg 256))
      (T
        (if (= (type arg) 'INT)
          (if (> arg 255)
            (progn
              (princ "\níu├CªΓ╜Xív╢WÑX╜d│≥ 1 í╨ 255 íC")
              (setq arg 257) ; kludge
            )
          )
          (setq arg (if (= (type (setq arg (getvar "cecolor"))) 'INT)
                      (getvar "cecolor")
                      (cond
                        ((= arg "BYBLOCK") (setq arg 0))
                        ((= arg "BYLAYER") (setq arg 256))
                      )
                    )
          )
        )
      )
    )
  )
  (cond
    ((= arg 0) (setq arg "BYBLOCK"))
    ((= arg 256) (setq arg "BYLAYER"))
  )
  arg
)
;;;
;;; Set the linetype from the loaded linetypes.
;;;
;;; xp_slt == XPlode_Set_Line_Type
;;;
(defun xp_slt ()
  (princ "\n\nÑ╤ÑHñUªCÑ▄¬║╜u½¼ññ¼D┐∩...")
  (tblnext "ltype" T)
  (setq xp_lta "CONTINUOUS,CONT BYLayer BYBlock"
        xp_ltb "BYB¿╠╖╙╣╧╕s/BYL¿╠╖╙╣╧╝h/CONT│s─≥╜u")

  (while (setq xp_lt (cdr(assoc 2 (tblnext "ltype"))))
    (setq xp_lta (strcat xp_lta " " xp_lt)
          xp_ltb (strcat xp_ltb "/" xp_lt))
  )
  (initget xp_lta)
  (princ (strcat
    "\n┐ΘñJ╖s¬║íu╜u½¼ívªW║┘  \n" xp_ltb "/<"
    (getvar "celtype") "> : "))
  (setq xp_nln (getkword) )
  (if (or (= xp_nln nil) (= xp_nln ""))
    (setq xp_nln (getvar "celtype"))
  )
  xp_nln
)
;;;
;;; Set a layer if it exists.
;;;
;;; xp_sla == XPlode_Set_LAyer
;;;
(defun xp_sla (/ temp)
  (while (null temp)
    (initget 1)
    (setq temp (getstring (strcat
      "\n\níu¼╡╢}ív½ß╣w│╞⌐±╕m¬║íu╣╧╝hívªW║┘?  <" (getvar "clayer") ">: ")))
    (if (or (= temp "") (null temp))
      (setq temp (getvar "clayer"))
      (if (not (tblsearch "layer" temp))
        (progn
          (princ "\n╡L«─¬║íu╝hªWívíC")
          (setq temp nil)
        )
      )
    )
  )
  temp
)

;;; ------------------ xp_mirrchk == mirror check ------------------------------;
;;;
;;;  Check entity type ...
;;;
;;;  If it's a block with equal absolute scale factors but differing signs
;;;  (i.e. -1,1,1), then:
;;;
;;;      1) copy the block off screen
;;;      2) modify the block with positive scale factors
;;;      3) explode the block
;;;      4) mirror or rotate the resulting entities
;;;      5) erase the original block
;;;      6) move the exploded entites into position
;;;
;;;  Else, just explode the block, polyline or dimension.
;;;
(defun xp_mirrchk (e / elist etype laste icon xoffset ss
     xscl yscl zscl xsclist)
  (setq elist (entget e))
  (setq etype (cdr (assoc 0 elist)))
  (setq xscl (cdr (setq xsclist (assoc 41 elist))))
  (setq yscl (cdr (setq ysclist (assoc 42 elist))))
  (setq zscl (cdr (setq zsclist (assoc 43 elist))))
  (if (and (equal etype "INSERT")
             (not (and (= xscl yscl) (= xscl zscl)))
      )
      (progn
        (command "_.UNDO" "_GROUP")
        (setq icon (getvar "ucsicon"))
        (setvar "ucsicon" 0)
        (setq xoffset (list (* (getvar "viewsize") 3) 0))
        (setq ss (ssadd))
        (setq laste (entlast))
        (command "_.UCS" "_V")
        (command "_.COPY" e "" '(0 0) xoffset)
        (setq elist (entget (entlast)))
        (command "_.UCS" "_E" (entlast))
        (setq elist (subst (cons 41 (abs xscl)) xsclist elist))
        (setq elist (subst (cons 42 (abs yscl)) ysclist elist))
        (setq elist (subst (cons 43 (abs zscl)) zsclist elist))
        (entmod elist)
        (command "_.EXPLODE" (entlast))
        (while (setq next (entnext laste))
             (ssadd next ss)
             (setq laste next)
        )
        (cond ((and (minusp xscl)
                            (not (minusp yscl))
                            (not (minusp zscl))
                       ) (-xyz)
                      )
                      ((and (not (minusp xscl))
                            (not (minusp yscl))
                            (minusp zscl)
                       ) (xy-z)
                      )
                      ((and (minusp xscl)
                            (not (minusp yscl))
                            (minusp zscl)
                       ) (-xy-z)
                      )
                      ((and (not (minusp xscl))
                            (minusp yscl)
                            (not (minusp zscl))
                       ) (x-yz)
                      )
                      ((and (minusp xscl)
                            (minusp yscl)
                            (not (minusp zscl))
                       ) (-x-yz)
                      )
                      ((and (not (minusp xscl))
                            (minusp yscl)
                            (minusp zscl)
                       ) (x-y-z)
                      )
        )
        (command "_.ERASE" e "")
        (command "_.UCS" "_P")
        (command "_.MOVE" ss "" xoffset '(0 0))
        (command "_.UCS" "_P")
        (setvar "ucsicon" icon)
        (command "_.UNDO" "_END")
      )
      (command "_.EXPLODE" (xp_val -1 ent nil))
  )
)
;;;
;;;  Functions that reposition exploded modified block into place
;;;
(defun -xyz ()
  (command "_.MIRROR" ss "" '(0 0) '(0 1) "y")
)

(defun xy-z ()
  (command "_.UCS" "_Y" "90")
  (command "_.MIRROR" ss "" '(0 0) '(0 1) "_Y")
  (command "_.UCS" "_P")
)

(defun -xy-z ()
  (command "_.UCS" "_X" "90")
  (command "_.ROTATE" ss "" '(0 0) "180")
  (command "_.UCS" "_P")
)

(defun x-yz ()
  (command "_.MIRROR" ss "" '(0 0) '(1 0) "_Y")
)

(defun -x-yz ()
  (command "_.MIRROR" ss "" '(0 0) '(1 0) "_Y")
  (command "_.MIRROR" ss "" '(0 0) '(0 1) "_Y")
)

(defun x-y-z ()
  (command "_.UCS" "_Y" "90")
  (command "_.ROTATE" ss "" '(0 0) "180")
  (command "_.UCS" "_P")
)

;;; --------------------------------------------------------------------------;
(defun c:xp       () (explode))
(defun c:xplode   () (explode))
(princ
  "\n\tíuC:XPlodeívñw╕ⁿñJ; ╜╨ÑH XP ⌐╬ XPLODE ▒╥░╩½ⁿÑOíC")
(princ)