anchor.diff:                                      :stroke-width 1
                                       ;;:fill-opacity (* alpha 0.6)
                                       ;;:stroke-linecap "round"
  -                                    :stroke-dasharray (format nil "~A,~A" *border* *border*)))))
  +                                    :stroke-dasharray "5,5"))))
       (draw group (:line :x1 a1 :y1 a1 :x2 a2 :y2 a1))
       (draw group (:line :x1 a1 :y1 a1 :x2 a1 :y2 a2))
       (draw group (:line :x1 a2 :y1 a2 :x2 a1 :y2 a2))
  
positive.code: (defun draw-point (scene point)
    (draw scene (:circle :cx (get-x (x point)) :cy (get-y (y point)) :r 2)))
  
  (defun draw-polygon (scene polygon &key stroke)
    (let* ((points (point-list polygon))
           (string-points (format nil "~{~A~^ ~}" (mapcar (lambda (point)
                                                            (format nil "~A,~A"
                                                                    (get-x (x point))
                                                                    (get-y (y point))))
                                                          points))))
      (draw scene (:polygon :points string-points :fill "orange" :stroke stroke))))
  
  (defun draw-polygons-to-svg (polygons &key (filename "~/polygon.svg"))
    (let ((size (+ *scale* (* 2 *border*))))
      (with-svg-to-file
          (scene 'svg-1.1-toplevel :height size :width size)
          (filename :if-exists :supersede)
        (mapc (lambda (polygon) (draw-polygon scene polygon :stroke "white")) polygons)
        (draw-field scene))))
  
  (defun draw-line-segment (scene line-segment)
    (let ((group
  
negative.code:   (:import-from :spatial-trees)
    (:import-from :rectangles)
    (:import-from :src/types)
    (:import-from :src/parser))
  
  (in-package :src/drawer)
  
  (defparameter *scale* 500)
  (defparameter *border* (round (/ *scale* 100)))
  (defparameter *steps* 5)
  (defparameter *x-shift* 0)
  (defparameter *y-shift* 0)
  
  (defun get-x (x)
    (round (+ *border* (* (+ *x-shift* x) *scale*))))
  
  (defun get-y (y)
    (round (- *scale* (- (* (+ *y-shift* y) *scale*) *border*))))
  
  (defun draw-field (scene)
    (let ((a1 *border*)
  