anchor.diff:  (defgeneric play             (puzzle))
   
   
  +(defun shuffle (list)
  +  (let ((vector (coerce list 'vector)))
  +    (loop :for i :from (1- (length vector)) :downto 2
  +          :do (rotatef (aref vector i) (aref vector (random i))))
  +    (coerce vector 'list)))
   
   (defmethod initialize-instance ((self puzzle) &rest args)
     (declare (ignore args))
     (call-next-method)
     (let ((places (make-array (list (size self) (size self))
                               :element-type '(or null square)
  -                            :initial-element nil)))
  +                            :initial-element nil))
  +        (squares (shuffle (loop :for i :below (* (size self) (size self)) :collect i))))
       (declare (type (simple-array (or null square) (* *)) places))
  -    (loop with size = (size self)
  -          for i from 0 below size do
  -          (loop for j from 0 below size do
  -                (unless (and (= i (1- size)) (= j (1- size)))
  -                  (setf (aref places i j)
  -                        (make-instance 'square :label (1+ (+ (* i size) j)))))))
  +    (loop :with size = (size self)
  +          :for i :from 0 :below size
  +          :do (loop :for j :from 0 :below size
  +                    :for square := (pop squares)
  +                    :if (zerop square)
  +                      :do (setf (empty self) (cons i j))
  +                    :else
  +                      :do (setf (aref places i j) (make-instance 'square :label square))))
       (setf (places self) places)
  -    (setf (empty  self) (cons (1- (size self)) (1- (size self))))
  -    self));;initialize-instance
  +    self))
   
   
   (defmethod print-object ((self puzzle) (out stream))
  
positive.code:     This software is in Public Domain.
      You're free to do with it as you please.")
    (:use "COMMON-LISP")
    (:export  "MAIN")
    );;COM.INFORMATIMAGO.COMMON-LISP.PUZZLE
  (in-package "COM.INFORMATIMAGO.COMMON-LISP.PUZZLE")
  
  
  (defclass square ()
    ;; What? A class for a mere integer?  No. We just leave to the reader
    ;; the pleasure to implement an picture-square subclass that would
    ;; display a picture part like on the real puzzle games.
    ((label :accessor label  :initform 0 :initarg :label :type integer)));;square
  
  
  (defclass puzzle ()
    ((size   :accessor size   :initform 4 :initarg :size :type (integer 2))
     (places :accessor places :initform nil
             :type (simple-array (or null square) (* *)))
     (empty  :accessor empty  :initform nil :type cons)));;puzzle
  
  
  (defgeneric get-coordinates  (puzzle relative-move))
  
negative.code:                             ((:u :up u up)       :u)
                              ((:d :down d down)   :d)
                              ((:q :quit q quit :exit exit
                                 :abort abort :break break)
                               (return-from play))
                              (otherwise input))))
                    ;; (setf square (aref (places self) x y))
                    )
                (error (err) (format t "~A~%" err) (go :loop))))
             (otherwise (format t "Invalid input.~%") (go :loop)))
           ;; (format t "Moving square ~S~%" square)
           (move-square self x y)))))
  
  
  (defun main ()
  