anchor.diff:  ;; in dotted pair notation when necessary but will use normal list notation
   ;; when possible
   
  -(defun print-normal-when-possible (lst)
  -  (print-normal-when-possible-iter lst 0))
  -
  -
  -; TODO: finish this
  -(defun print-normal-when-possible-iter (lst count)
  +(defun print-normal (lst)
     (cond ((null lst)
            (princ '()))
           ((null (rest lst))
  -         (princ lst)
  -         (dotimes (x count)
  -           (princ ")")))
  +         (princ lst))
           (t
  -         (princ "(")
  -         (let ((prev-elem (first lst))
  -               (current-list (rest lst)))
  -           (if (listp current-list)
  -               (progn
  -                 (dotimes (i (length current-list))
  -                   (if (listp current-list)
  -                       (if (listp prev-elem)
  -                           (progn
  -                             (print-normal-when-possible prev-elem)
  -                             (princ " "))
  -                           (progn
  -                             (princ prev-elem) (princ " ")))
  -                       (progn
  -                         (princ " . ") (princ current-list)))
  -                   (setf prev-elem (first current-list))
  -                   (setf current-list (rest current-list)))
  -                 (princ prev-elem) (princ ")"))
  -               (progn
  -                 (princ " . " (princ current-list))))))))
  -
  -
  +         (let ((elem (first lst))
  +               (next-lst (rest lst)))
  +           (princ "(")
  +           (dotimes (x (length-dotted-pair lst)) 
  +             (cond ((not (listp next-lst)) ; dotted list
  +                    (princ elem) (princ " . ") (princ next-lst) (princ ")")
  +                    (return))
  +                   ; case where first element is also a list
  +                   ((listp elem)
  +                    (print-normal elem)
  +                    (if (null next-lst)
  +                        (princ ")")
  +                        (princ " ")))
  +                   ; end of list, terminate
  +                   ((null next-lst)
  +                    (princ elem) (princ ")"))
  +                   (t ; normal case
  +                    (princ elem ) (princ " ")))
  +             (setq elem (first next-lst))
  +             (setq next-lst (rest next-lst)))))))
  +
  +(defun length-dotted-pair (lst)
  +  "Find the length of the input list, even if it has a dotted pair inside."
  +  (length-dotted-pair-iter lst 0))
  +
  +(defun length-dotted-pair-iter (lst count)
  +  (cond ((null lst) count)
  +        ((not (listp lst)) (1+ count))
  +        (t
  +         (length-dotted-pair-iter (rest lst) (1+ count)))))
   
   ;; Exercise 3.5 [h]
   ;;
  
positive.code: ;;
  ;; Write a version of length using the function 'reduce'
  
  
  
  
  
  
  
  ;;
  ;; Exercise 3.10 [m]
  ;
  ;; Use a reference manual or 'describe' to figure out what the functions
  ;; '?????' and 'nreconc' do.
  
  
  
  ;; 
  ;; Exercise 3.11 [m]
  
negative.code: ;; for the same keyword.
  ;; Change the definition of find-all so that it works in KCL.
  
  (defun find-all (item sequence &rest keyword-args
                                   &key (test #'eql) test-not &allow-other-keys)
    "Find all those elements of sequence that match item, according to keywords.
     Doesn't alter sequence."
    (if test-not
        (apply #'remove item sequence
               (append keyword-args (list :test-not (complement test-not))))
        (apply #'remove item sequence
               (append keyword-args (list :test (complement test))))))
  
  
  ;;
  